From 6a10972e507334991dbbae4edb85602f7935dc8e Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Tue, 25 Jan 2022 14:31:09 +0100
Subject: [PATCH 1/8] Add failing test for package.json holding "type":
 "module"

---
 test/e2e/type-module-interop/index.test.ts | 35 ++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 test/e2e/type-module-interop/index.test.ts

diff --git a/test/e2e/type-module-interop/index.test.ts b/test/e2e/type-module-interop/index.test.ts
new file mode 100644
index 0000000000000..8bc18c2ba8142
--- /dev/null
+++ b/test/e2e/type-module-interop/index.test.ts
@@ -0,0 +1,35 @@
+import { createNext } from 'e2e-utils'
+import { NextInstance } from 'test/lib/next-modes/base'
+import { renderViaHTTP } from 'next-test-utils'
+
+describe('Type module interop', () => {
+  let next: NextInstance
+
+  beforeAll(async () => {
+    next = await createNext({
+      files: {
+        'pages/index.js': `
+          export default function Page() { 
+            return <p>hello world</p>
+          } 
+        `,
+      },
+      dependencies: {},
+    })
+    const contents = await next.readFile('package.json')
+    const pkg = JSON.parse(contents)
+    await next.patchFile(
+      'package.json',
+      JSON.stringify({
+        ...pkg,
+        type: 'module',
+      })
+    )
+  })
+  afterAll(() => next.destroy())
+
+  it('should work', async () => {
+    const html = await renderViaHTTP(next.url, '/')
+    expect(html).toContain('hello world')
+  })
+})

From cb2a4498b53c2e12da6555b041034021b1bbea9d Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Tue, 25 Jan 2022 15:06:57 +0100
Subject: [PATCH 2/8] Write "type": "commonjs" package.json to .next

---
 packages/next/build/index.ts             |  7 +++++++
 packages/next/server/dev/hot-reloader.ts | 10 ++++++++++
 2 files changed, 17 insertions(+)

diff --git a/packages/next/build/index.ts b/packages/next/build/index.ts
index 89cc94663989c..da1f6aad7681a 100644
--- a/packages/next/build/index.ts
+++ b/packages/next/build/index.ts
@@ -529,6 +529,13 @@ export default async function build(
       await recursiveDelete(distDir, /^cache/)
     }
 
+    // Ensure commonjs handling is used for files in the distDir (generally .next)
+    // Files outside of the distDir can be "type": "module"
+    await promises.writeFile(
+      path.join(config.distDir, 'package.json'),
+      '{"type": "commonjs"}'
+    )
+
     // We need to write the manifest with rewrites before build
     // so serverless can import the manifest
     await nextBuildSpan
diff --git a/packages/next/server/dev/hot-reloader.ts b/packages/next/server/dev/hot-reloader.ts
index 4a20caadeae26..e06961788117d 100644
--- a/packages/next/server/dev/hot-reloader.ts
+++ b/packages/next/server/dev/hot-reloader.ts
@@ -41,6 +41,7 @@ import { DecodeError } from '../../shared/lib/utils'
 import { Span, trace } from '../../trace'
 import { getProperError } from '../../lib/is-error'
 import ws from 'next/dist/compiled/ws'
+import { promises as fs } from 'fs'
 
 const wsServer = new ws.Server({ noServer: true })
 
@@ -431,6 +432,15 @@ export default class HotReloader {
     startSpan.stop() // Stop immediately to create an artificial parent span
 
     await this.clean(startSpan)
+    // Ensure distDir exists before writing package.json
+    await fs.mkdir(this.config.distDir, { recursive: true })
+
+    // Ensure commonjs handling is used for files in the distDir (generally .next)
+    // Files outside of the distDir can be "type": "module"
+    await fs.writeFile(
+      join(this.config.distDir, 'package.json'),
+      '{"type": "commonjs"}'
+    )
 
     const configs = await this.getWebpackConfig(startSpan)
 

From 7b11582f83f9399d49e1569afa4e3f361a0f3d15 Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Tue, 25 Jan 2022 15:12:47 +0100
Subject: [PATCH 3/8] Add failing test for client-side development

---
 test/e2e/type-module-interop/index.test.ts | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/e2e/type-module-interop/index.test.ts b/test/e2e/type-module-interop/index.test.ts
index 8bc18c2ba8142..21e13a32586bf 100644
--- a/test/e2e/type-module-interop/index.test.ts
+++ b/test/e2e/type-module-interop/index.test.ts
@@ -1,6 +1,7 @@
 import { createNext } from 'e2e-utils'
 import { NextInstance } from 'test/lib/next-modes/base'
-import { renderViaHTTP } from 'next-test-utils'
+import { hasRedbox, renderViaHTTP } from 'next-test-utils'
+import webdriver from 'next-webdriver'
 
 describe('Type module interop', () => {
   let next: NextInstance
@@ -28,8 +29,14 @@ describe('Type module interop', () => {
   })
   afterAll(() => next.destroy())
 
-  it('should work', async () => {
+  it('should render server-side', async () => {
     const html = await renderViaHTTP(next.url, '/')
     expect(html).toContain('hello world')
   })
+
+  it('should render client-side', async () => {
+    const browser = await webdriver(next.url, '/')
+    expect(await hasRedbox(browser)).toBe(false)
+    await browser.close()
+  })
 })

From 7e17e1709044f47325c7a746f7373522c2b77660 Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Mon, 14 Feb 2022 11:16:32 +0100
Subject: [PATCH 4/8] Update react-refresh runtime to be compatible with
 esmodules in webpack

---
 packages/next/compiled/webpack/bundle5.js     | 225196 +++++++--------
 .../internal/ReactRefreshModule.runtime.ts    |     18 +-
 2 files changed, 112608 insertions(+), 112606 deletions(-)

diff --git a/packages/next/compiled/webpack/bundle5.js b/packages/next/compiled/webpack/bundle5.js
index 093c9ba888ef5..6f57a1885204f 100644
--- a/packages/next/compiled/webpack/bundle5.js
+++ b/packages/next/compiled/webpack/bundle5.js
@@ -10139,17433 +10139,13866 @@ var __classPrivateFieldSet;
 
 /***/ }),
 
-/***/ 70665:
+/***/ 42752:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
-const Variable = __webpack_require__(82971);
-
-/**
- * @class Definition
- */
-class Definition {
-    constructor(type, name, node, parent, index, kind) {
-
-        /**
-         * @member {String} Definition#type - type of the occurrence (e.g. "Parameter", "Variable", ...).
-         */
-        this.type = type;
-
-        /**
-         * @member {espree.Identifier} Definition#name - the identifier AST node of the occurrence.
-         */
-        this.name = name;
-
-        /**
-         * @member {espree.Node} Definition#node - the enclosing node of the identifier.
-         */
-        this.node = node;
-
-        /**
-         * @member {espree.Node?} Definition#parent - the enclosing statement node of the identifier.
-         */
-        this.parent = parent;
 
-        /**
-         * @member {Number?} Definition#index - the index in the declaration statement.
-         */
-        this.index = index;
+const DescriptionFileUtils = __webpack_require__(702);
+const getInnerRequest = __webpack_require__(50290);
 
-        /**
-         * @member {String?} Definition#kind - the kind of the declaration statement.
-         */
-        this.kind = kind;
-    }
-}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-/**
- * @class ParameterDefinition
- */
-class ParameterDefinition extends Definition {
-    constructor(name, node, index, rest) {
-        super(Variable.Parameter, name, node, null, index, null);
+module.exports = class AliasFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | Array<string>} field field
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, field, target) {
+		this.source = source;
+		this.field = field;
+		this.target = target;
+	}
 
-        /**
-         * Whether the parameter definition is a part of a rest parameter.
-         * @member {boolean} ParameterDefinition#rest
-         */
-        this.rest = rest;
-    }
-}
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => {
+				if (!request.descriptionFileData) return callback();
+				const innerRequest = getInnerRequest(resolver, request);
+				if (!innerRequest) return callback();
+				const fieldData = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.field
+				);
+				if (fieldData === null || typeof fieldData !== "object") {
+					if (resolveContext.log)
+						resolveContext.log(
+							"Field '" +
+								this.field +
+								"' doesn't contain a valid alias configuration"
+						);
+					return callback();
+				}
+				const data1 = fieldData[innerRequest];
+				const data2 = fieldData[innerRequest.replace(/^\.\//, "")];
+				const data = typeof data1 !== "undefined" ? data1 : data2;
+				if (data === innerRequest) return callback();
+				if (data === undefined) return callback();
+				if (data === false) {
+					/** @type {ResolveRequest} */
+					const ignoreObj = {
+						...request,
+						path: false
+					};
+					return callback(null, ignoreObj);
+				}
+				const obj = {
+					...request,
+					path: request.descriptionFileRoot,
+					request: data,
+					fullySpecified: false
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"aliased from description file " +
+						request.descriptionFilePath +
+						" with mapping '" +
+						innerRequest +
+						"' to '" +
+						data +
+						"'",
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
 
-module.exports = {
-    ParameterDefinition,
-    Definition
+						// Don't allow other aliasing or raw request
+						if (result === undefined) return callback(null, null);
+						callback(null, result);
+					}
+				);
+			});
+	}
 };
 
-/* vim: set sw=4 ts=4 et tw=80 : */
-
 
 /***/ }),
 
-/***/ 36007:
+/***/ 51547:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2013 Alex Seville <hi@alexanderseville.com>
-  Copyright (C) 2014 Thiago de Arruda <tpadilha84@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
-/**
- * Escope (<a href="http://github.com/estools/escope">escope</a>) is an <a
- * href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript</a>
- * scope analyzer extracted from the <a
- * href="http://github.com/estools/esmangle">esmangle project</a/>.
- * <p>
- * <em>escope</em> finds lexical scopes in a source program, i.e. areas of that
- * program where different occurrences of the same identifier refer to the same
- * variable. With each scope the contained variables are collected, and each
- * identifier reference in code is linked to its corresponding variable (if
- * possible).
- * <p>
- * <em>escope</em> works on a syntax tree of the parsed source code which has
- * to adhere to the <a
- * href="https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API">
- * Mozilla Parser API</a>. E.g. <a href="https://github.com/eslint/espree">espree</a> is a parser
- * that produces such syntax trees.
- * <p>
- * The main interface is the {@link analyze} function.
- * @module escope
- */
-
-
-/* eslint no-underscore-dangle: ["error", { "allow": ["__currentScope"] }] */
-
-const assert = __webpack_require__(39491);
-
-const ScopeManager = __webpack_require__(96988);
-const Referencer = __webpack_require__(44585);
-const Reference = __webpack_require__(64945);
-const Variable = __webpack_require__(82971);
-const Scope = (__webpack_require__(16313).Scope);
-const version = (__webpack_require__(30290)/* .version */ .i8);
 
-/**
- * Set the default options
- * @returns {Object} options
- */
-function defaultOptions() {
-    return {
-        optimistic: false,
-        directive: false,
-        nodejsScope: false,
-        impliedStrict: false,
-        sourceType: "script", // one of ['script', 'module']
-        ecmaVersion: 5,
-        childVisitorKeys: null,
-        fallback: "iteration"
-    };
-}
 
-/**
- * Preform deep update on option object
- * @param {Object} target - Options
- * @param {Object} override - Updates
- * @returns {Object} Updated options
- */
-function updateDeeply(target, override) {
+const forEachBail = __webpack_require__(8266);
 
-    /**
-     * Is hash object
-     * @param {Object} value - Test value
-     * @returns {boolean} Result
-     */
-    function isHashObject(value) {
-        return typeof value === "object" && value instanceof Object && !(value instanceof Array) && !(value instanceof RegExp);
-    }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{alias: string|Array<string>|false, name: string, onlyModule?: boolean}} AliasOption */
 
-    for (const key in override) {
-        if (Object.prototype.hasOwnProperty.call(override, key)) {
-            const val = override[key];
+module.exports = class AliasPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {AliasOption | Array<AliasOption>} options options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, options, target) {
+		this.source = source;
+		this.options = Array.isArray(options) ? options : [options];
+		this.target = target;
+	}
 
-            if (isHashObject(val)) {
-                if (isHashObject(target[key])) {
-                    updateDeeply(target[key], val);
-                } else {
-                    target[key] = updateDeeply({}, val);
-                }
-            } else {
-                target[key] = val;
-            }
-        }
-    }
-    return target;
-}
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AliasPlugin", (request, resolveContext, callback) => {
+				const innerRequest = request.request || request.path;
+				if (!innerRequest) return callback();
+				forEachBail(
+					this.options,
+					(item, callback) => {
+						let shouldStop = false;
+						if (
+							innerRequest === item.name ||
+							(!item.onlyModule && innerRequest.startsWith(item.name + "/"))
+						) {
+							const remainingRequest = innerRequest.substr(item.name.length);
+							const resolveWithAlias = (alias, callback) => {
+								if (alias === false) {
+									const ignoreObj = {
+										...request,
+										path: false
+									};
+									return callback(null, ignoreObj);
+								}
+								if (
+									innerRequest !== alias &&
+									!innerRequest.startsWith(alias + "/")
+								) {
+									shouldStop = true;
+									const newRequestStr = alias + remainingRequest;
+									const obj = {
+										...request,
+										request: newRequestStr,
+										fullySpecified: false
+									};
+									return resolver.doResolve(
+										target,
+										obj,
+										"aliased with mapping '" +
+											item.name +
+											"': '" +
+											alias +
+											"' to '" +
+											newRequestStr +
+											"'",
+										resolveContext,
+										(err, result) => {
+											if (err) return callback(err);
+											if (result) return callback(null, result);
+											return callback();
+										}
+									);
+								}
+								return callback();
+							};
+							const stoppingCallback = (err, result) => {
+								if (err) return callback(err);
 
-/**
- * Main interface function. Takes an Espree syntax tree and returns the
- * analyzed scopes.
- * @function analyze
- * @param {espree.Tree} tree - Abstract Syntax Tree
- * @param {Object} providedOptions - Options that tailor the scope analysis
- * @param {boolean} [providedOptions.optimistic=false] - the optimistic flag
- * @param {boolean} [providedOptions.directive=false]- the directive flag
- * @param {boolean} [providedOptions.ignoreEval=false]- whether to check 'eval()' calls
- * @param {boolean} [providedOptions.nodejsScope=false]- whether the whole
- * script is executed under node.js environment. When enabled, escope adds
- * a function scope immediately following the global scope.
- * @param {boolean} [providedOptions.impliedStrict=false]- implied strict mode
- * (if ecmaVersion >= 5).
- * @param {string} [providedOptions.sourceType='script']- the source type of the script. one of 'script' and 'module'
- * @param {number} [providedOptions.ecmaVersion=5]- which ECMAScript version is considered
- * @param {Object} [providedOptions.childVisitorKeys=null] - Additional known visitor keys. See [esrecurse](https://github.com/estools/esrecurse)'s the `childVisitorKeys` option.
- * @param {string} [providedOptions.fallback='iteration'] - A kind of the fallback in order to encounter with unknown node. See [esrecurse](https://github.com/estools/esrecurse)'s the `fallback` option.
- * @returns {ScopeManager} ScopeManager
- */
-function analyze(tree, providedOptions) {
-    const options = updateDeeply(defaultOptions(), providedOptions);
-    const scopeManager = new ScopeManager(options);
-    const referencer = new Referencer(options, scopeManager);
+								if (result) return callback(null, result);
+								// Don't allow other aliasing or raw request
+								if (shouldStop) return callback(null, null);
+								return callback();
+							};
+							if (Array.isArray(item.alias)) {
+								return forEachBail(
+									item.alias,
+									resolveWithAlias,
+									stoppingCallback
+								);
+							} else {
+								return resolveWithAlias(item.alias, stoppingCallback);
+							}
+						}
+						return callback();
+					},
+					callback
+				);
+			});
+	}
+};
 
-    referencer.visit(tree);
 
-    assert(scopeManager.__currentScope === null, "currentScope should be null.");
+/***/ }),
 
-    return scopeManager;
-}
+/***/ 66477:
+/***/ (function(module) {
 
-module.exports = {
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    /** @name module:escope.version */
-    version,
 
-    /** @name module:escope.Reference */
-    Reference,
 
-    /** @name module:escope.Variable */
-    Variable,
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    /** @name module:escope.Scope */
-    Scope,
+module.exports = class AppendPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} appending appending
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, appending, target) {
+		this.source = source;
+		this.appending = appending;
+		this.target = target;
+	}
 
-    /** @name module:escope.ScopeManager */
-    ScopeManager,
-    analyze
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AppendPlugin", (request, resolveContext, callback) => {
+				const obj = {
+					...request,
+					path: request.path + this.appending,
+					relativePath:
+						request.relativePath && request.relativePath + this.appending
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					this.appending,
+					resolveContext,
+					callback
+				);
+			});
+	}
 };
 
 
-/* vim: set sw=4 ts=4 et tw=80 : */
-
-
 /***/ }),
 
-/***/ 54162:
+/***/ 89429:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
-/* eslint-disable no-undefined */
-
-const Syntax = (__webpack_require__(18350).Syntax);
-const esrecurse = __webpack_require__(81217);
 
-/**
- * Get last array element
- * @param {array} xs - array
- * @returns {any} Last elment
- */
-function getLast(xs) {
-    return xs[xs.length - 1] || null;
-}
+const nextTick = (__webpack_require__(77282).nextTick);
 
-class PatternVisitor extends esrecurse.Visitor {
-    static isPattern(node) {
-        const nodeType = node.type;
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
 
-        return (
-            nodeType === Syntax.Identifier ||
-            nodeType === Syntax.ObjectPattern ||
-            nodeType === Syntax.ArrayPattern ||
-            nodeType === Syntax.SpreadElement ||
-            nodeType === Syntax.RestElement ||
-            nodeType === Syntax.AssignmentPattern
-        );
-    }
+const dirname = path => {
+	let idx = path.length - 1;
+	while (idx >= 0) {
+		const c = path.charCodeAt(idx);
+		// slash or backslash
+		if (c === 47 || c === 92) break;
+		idx--;
+	}
+	if (idx < 0) return "";
+	return path.slice(0, idx);
+};
 
-    constructor(options, rootPattern, callback) {
-        super(null, options);
-        this.rootPattern = rootPattern;
-        this.callback = callback;
-        this.assignments = [];
-        this.rightHandNodes = [];
-        this.restElements = [];
-    }
+const runCallbacks = (callbacks, err, result) => {
+	if (callbacks.length === 1) {
+		callbacks[0](err, result);
+		callbacks.length = 0;
+		return;
+	}
+	let error;
+	for (const callback of callbacks) {
+		try {
+			callback(err, result);
+		} catch (e) {
+			if (!error) error = e;
+		}
+	}
+	callbacks.length = 0;
+	if (error) throw error;
+};
 
-    Identifier(pattern) {
-        const lastRestElement = getLast(this.restElements);
+class OperationMergerBackend {
+	/**
+	 * @param {any} provider async method
+	 * @param {any} syncProvider sync method
+	 * @param {any} providerContext call context for the provider methods
+	 */
+	constructor(provider, syncProvider, providerContext) {
+		this._provider = provider;
+		this._syncProvider = syncProvider;
+		this._providerContext = providerContext;
+		this._activeAsyncOperations = new Map();
 
-        this.callback(pattern, {
-            topLevel: pattern === this.rootPattern,
-            rest: lastRestElement !== null && lastRestElement !== undefined && lastRestElement.argument === pattern,
-            assignments: this.assignments
-        });
-    }
+		this.provide = this._provider
+			? (path, options, callback) => {
+					if (typeof options === "function") {
+						callback = options;
+						options = undefined;
+					}
+					if (options) {
+						return this._provider.call(
+							this._providerContext,
+							path,
+							options,
+							callback
+						);
+					}
+					if (typeof path !== "string") {
+						callback(new TypeError("path must be a string"));
+						return;
+					}
+					let callbacks = this._activeAsyncOperations.get(path);
+					if (callbacks) {
+						callbacks.push(callback);
+						return;
+					}
+					this._activeAsyncOperations.set(path, (callbacks = [callback]));
+					provider(path, (err, result) => {
+						this._activeAsyncOperations.delete(path);
+						runCallbacks(callbacks, err, result);
+					});
+			  }
+			: null;
+		this.provideSync = this._syncProvider
+			? (path, options) => {
+					return this._syncProvider.call(this._providerContext, path, options);
+			  }
+			: null;
+	}
 
-    Property(property) {
+	purge() {}
+	purgeParent() {}
+}
 
-        // Computed property's key is a right hand node.
-        if (property.computed) {
-            this.rightHandNodes.push(property.key);
-        }
+/*
 
-        // If it's shorthand, its key is same as its value.
-        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).
-        // If it's not shorthand, the name of new variable is its value's.
-        this.visit(property.value);
-    }
+IDLE:
+	insert data: goto SYNC
 
-    ArrayPattern(pattern) {
-        for (let i = 0, iz = pattern.elements.length; i < iz; ++i) {
-            const element = pattern.elements[i];
+SYNC:
+	before provide: run ticks
+	event loop tick: goto ASYNC_ACTIVE
 
-            this.visit(element);
-        }
-    }
+ASYNC:
+	timeout: run tick, goto ASYNC_PASSIVE
 
-    AssignmentPattern(pattern) {
-        this.assignments.push(pattern);
-        this.visit(pattern.left);
-        this.rightHandNodes.push(pattern.right);
-        this.assignments.pop();
-    }
+ASYNC_PASSIVE:
+	before provide: run ticks
 
-    RestElement(pattern) {
-        this.restElements.push(pattern);
-        this.visit(pattern.argument);
-        this.restElements.pop();
-    }
+IDLE --[insert data]--> SYNC --[event loop tick]--> ASYNC_ACTIVE --[interval tick]-> ASYNC_PASSIVE
+                                                          ^                             |
+                                                          +---------[insert data]-------+
+*/
 
-    MemberExpression(node) {
+const STORAGE_MODE_IDLE = 0;
+const STORAGE_MODE_SYNC = 1;
+const STORAGE_MODE_ASYNC = 2;
 
-        // Computed property's key is a right hand node.
-        if (node.computed) {
-            this.rightHandNodes.push(node.property);
-        }
+class CacheBackend {
+	/**
+	 * @param {number} duration max cache duration of items
+	 * @param {any} provider async method
+	 * @param {any} syncProvider sync method
+	 * @param {any} providerContext call context for the provider methods
+	 */
+	constructor(duration, provider, syncProvider, providerContext) {
+		this._duration = duration;
+		this._provider = provider;
+		this._syncProvider = syncProvider;
+		this._providerContext = providerContext;
+		/** @type {Map<string, (function(Error, any): void)[]>} */
+		this._activeAsyncOperations = new Map();
+		/** @type {Map<string, { err: Error, result: any, level: Set<string> }>} */
+		this._data = new Map();
+		/** @type {Set<string>[]} */
+		this._levels = [];
+		for (let i = 0; i < 10; i++) this._levels.push(new Set());
+		for (let i = 5000; i < duration; i += 500) this._levels.push(new Set());
+		this._currentLevel = 0;
+		this._tickInterval = Math.floor(duration / this._levels.length);
+		/** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */
+		this._mode = STORAGE_MODE_IDLE;
 
-        // the object is only read, write to its property.
-        this.rightHandNodes.push(node.object);
-    }
+		/** @type {NodeJS.Timeout | undefined} */
+		this._timeout = undefined;
+		/** @type {number | undefined} */
+		this._nextDecay = undefined;
 
-    //
-    // ForInStatement.left and AssignmentExpression.left are LeftHandSideExpression.
-    // By spec, LeftHandSideExpression is Pattern or MemberExpression.
-    //   (see also: https://github.com/estree/estree/pull/20#issuecomment-74584758)
-    // But espree 2.0 parses to ArrayExpression, ObjectExpression, etc...
-    //
+		this.provide = provider ? this.provide.bind(this) : null;
+		this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
+	}
 
-    SpreadElement(node) {
-        this.visit(node.argument);
-    }
+	provide(path, options, callback) {
+		if (typeof options === "function") {
+			callback = options;
+			options = undefined;
+		}
+		if (typeof path !== "string") {
+			callback(new TypeError("path must be a string"));
+			return;
+		}
+		if (options) {
+			return this._provider.call(
+				this._providerContext,
+				path,
+				options,
+				callback
+			);
+		}
 
-    ArrayExpression(node) {
-        node.elements.forEach(this.visit, this);
-    }
+		// When in sync mode we can move to async mode
+		if (this._mode === STORAGE_MODE_SYNC) {
+			this._enterAsyncMode();
+		}
 
-    AssignmentExpression(node) {
-        this.assignments.push(node);
-        this.visit(node.left);
-        this.rightHandNodes.push(node.right);
-        this.assignments.pop();
-    }
+		// Check in cache
+		let cacheEntry = this._data.get(path);
+		if (cacheEntry !== undefined) {
+			if (cacheEntry.err) return nextTick(callback, cacheEntry.err);
+			return nextTick(callback, null, cacheEntry.result);
+		}
 
-    CallExpression(node) {
+		// Check if there is already the same operation running
+		let callbacks = this._activeAsyncOperations.get(path);
+		if (callbacks !== undefined) {
+			callbacks.push(callback);
+			return;
+		}
+		this._activeAsyncOperations.set(path, (callbacks = [callback]));
 
-        // arguments are right hand nodes.
-        node.arguments.forEach(a => {
-            this.rightHandNodes.push(a);
-        });
-        this.visit(node.callee);
-    }
-}
+		// Run the operation
+		this._provider.call(this._providerContext, path, (err, result) => {
+			this._activeAsyncOperations.delete(path);
+			this._storeResult(path, err, result);
 
-module.exports = PatternVisitor;
+			// Enter async mode if not yet done
+			this._enterAsyncMode();
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+			runCallbacks(callbacks, err, result);
+		});
+	}
 
+	provideSync(path, options) {
+		if (typeof path !== "string") {
+			throw new TypeError("path must be a string");
+		}
+		if (options) {
+			return this._syncProvider.call(this._providerContext, path, options);
+		}
 
-/***/ }),
+		// In sync mode we may have to decay some cache items
+		if (this._mode === STORAGE_MODE_SYNC) {
+			this._runDecays();
+		}
 
-/***/ 64945:
-/***/ (function(module) {
+		// Check in cache
+		let cacheEntry = this._data.get(path);
+		if (cacheEntry !== undefined) {
+			if (cacheEntry.err) throw cacheEntry.err;
+			return cacheEntry.result;
+		}
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+		// Get all active async operations
+		// This sync operation will also complete them
+		const callbacks = this._activeAsyncOperations.get(path);
+		this._activeAsyncOperations.delete(path);
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+		// Run the operation
+		// When in idle mode, we will enter sync mode
+		let result;
+		try {
+			result = this._syncProvider.call(this._providerContext, path);
+		} catch (err) {
+			this._storeResult(path, err, undefined);
+			this._enterSyncModeWhenIdle();
+			if (callbacks) runCallbacks(callbacks, err, undefined);
+			throw err;
+		}
+		this._storeResult(path, undefined, result);
+		this._enterSyncModeWhenIdle();
+		if (callbacks) runCallbacks(callbacks, undefined, result);
+		return result;
+	}
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+	purge(what) {
+		if (!what) {
+			if (this._mode !== STORAGE_MODE_IDLE) {
+				this._data.clear();
+				for (const level of this._levels) {
+					level.clear();
+				}
+				this._enterIdleMode();
+			}
+		} else if (typeof what === "string") {
+			for (let [key, data] of this._data) {
+				if (key.startsWith(what)) {
+					this._data.delete(key);
+					data.level.delete(key);
+				}
+			}
+			if (this._data.size === 0) {
+				this._enterIdleMode();
+			}
+		} else {
+			for (let [key, data] of this._data) {
+				for (const item of what) {
+					if (key.startsWith(item)) {
+						this._data.delete(key);
+						data.level.delete(key);
+						break;
+					}
+				}
+			}
+			if (this._data.size === 0) {
+				this._enterIdleMode();
+			}
+		}
+	}
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+	purgeParent(what) {
+		if (!what) {
+			this.purge();
+		} else if (typeof what === "string") {
+			this.purge(dirname(what));
+		} else {
+			const set = new Set();
+			for (const item of what) {
+				set.add(dirname(item));
+			}
+			this.purge(set);
+		}
+	}
 
+	_storeResult(path, err, result) {
+		if (this._data.has(path)) return;
+		const level = this._levels[this._currentLevel];
+		this._data.set(path, { err, result, level });
+		level.add(path);
+	}
 
-const READ = 0x1;
-const WRITE = 0x2;
-const RW = READ | WRITE;
+	_decayLevel() {
+		const nextLevel = (this._currentLevel + 1) % this._levels.length;
+		const decay = this._levels[nextLevel];
+		this._currentLevel = nextLevel;
+		for (let item of decay) {
+			this._data.delete(item);
+		}
+		decay.clear();
+		if (this._data.size === 0) {
+			this._enterIdleMode();
+		} else {
+			// @ts-ignore _nextDecay is always a number in sync mode
+			this._nextDecay += this._tickInterval;
+		}
+	}
 
-/**
- * A Reference represents a single occurrence of an identifier in code.
- * @class Reference
- */
-class Reference {
-    constructor(ident, scope, flag, writeExpr, maybeImplicitGlobal, partial, init) {
+	_runDecays() {
+		while (
+			/** @type {number} */ (this._nextDecay) <= Date.now() &&
+			this._mode !== STORAGE_MODE_IDLE
+		) {
+			this._decayLevel();
+		}
+	}
 
-        /**
-         * Identifier syntax node.
-         * @member {espreeIdentifier} Reference#identifier
-         */
-        this.identifier = ident;
+	_enterAsyncMode() {
+		let timeout = 0;
+		switch (this._mode) {
+			case STORAGE_MODE_ASYNC:
+				return;
+			case STORAGE_MODE_IDLE:
+				this._nextDecay = Date.now() + this._tickInterval;
+				timeout = this._tickInterval;
+				break;
+			case STORAGE_MODE_SYNC:
+				this._runDecays();
+				// @ts-ignore _runDecays may change the mode
+				if (this._mode === STORAGE_MODE_IDLE) return;
+				timeout = Math.max(
+					0,
+					/** @type {number} */ (this._nextDecay) - Date.now()
+				);
+				break;
+		}
+		this._mode = STORAGE_MODE_ASYNC;
+		const ref = setTimeout(() => {
+			this._mode = STORAGE_MODE_SYNC;
+			this._runDecays();
+		}, timeout);
+		if (ref.unref) ref.unref();
+		this._timeout = ref;
+	}
 
-        /**
-         * Reference to the enclosing Scope.
-         * @member {Scope} Reference#from
-         */
-        this.from = scope;
+	_enterSyncModeWhenIdle() {
+		if (this._mode === STORAGE_MODE_IDLE) {
+			this._mode = STORAGE_MODE_SYNC;
+			this._nextDecay = Date.now() + this._tickInterval;
+		}
+	}
 
-        /**
-         * Whether the reference comes from a dynamic scope (such as 'eval',
-         * 'with', etc.), and may be trapped by dynamic scopes.
-         * @member {boolean} Reference#tainted
-         */
-        this.tainted = false;
+	_enterIdleMode() {
+		this._mode = STORAGE_MODE_IDLE;
+		this._nextDecay = undefined;
+		if (this._timeout) clearTimeout(this._timeout);
+	}
+}
 
-        /**
-         * The variable this reference is resolved with.
-         * @member {Variable} Reference#resolved
-         */
-        this.resolved = null;
+const createBackend = (duration, provider, syncProvider, providerContext) => {
+	if (duration > 0) {
+		return new CacheBackend(duration, provider, syncProvider, providerContext);
+	}
+	return new OperationMergerBackend(provider, syncProvider, providerContext);
+};
 
-        /**
-         * The read-write mode of the reference. (Value is one of {@link
-         * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).
-         * @member {number} Reference#flag
-         * @private
-         */
-        this.flag = flag;
-        if (this.isWrite()) {
+module.exports = class CachedInputFileSystem {
+	constructor(fileSystem, duration) {
+		this.fileSystem = fileSystem;
 
-            /**
-             * If reference is writeable, this is the tree being written to it.
-             * @member {espreeNode} Reference#writeExpr
-             */
-            this.writeExpr = writeExpr;
+		this._lstatBackend = createBackend(
+			duration,
+			this.fileSystem.lstat,
+			this.fileSystem.lstatSync,
+			this.fileSystem
+		);
+		const lstat = this._lstatBackend.provide;
+		this.lstat = /** @type {FileSystem["lstat"]} */ (lstat);
+		const lstatSync = this._lstatBackend.provideSync;
+		this.lstatSync = /** @type {SyncFileSystem["lstatSync"]} */ (lstatSync);
 
-            /**
-             * Whether the Reference might refer to a partial value of writeExpr.
-             * @member {boolean} Reference#partial
-             */
-            this.partial = partial;
+		this._statBackend = createBackend(
+			duration,
+			this.fileSystem.stat,
+			this.fileSystem.statSync,
+			this.fileSystem
+		);
+		const stat = this._statBackend.provide;
+		this.stat = /** @type {FileSystem["stat"]} */ (stat);
+		const statSync = this._statBackend.provideSync;
+		this.statSync = /** @type {SyncFileSystem["statSync"]} */ (statSync);
 
-            /**
-             * Whether the Reference is to write of initialization.
-             * @member {boolean} Reference#init
-             */
-            this.init = init;
-        }
-        this.__maybeImplicitGlobal = maybeImplicitGlobal;
-    }
+		this._readdirBackend = createBackend(
+			duration,
+			this.fileSystem.readdir,
+			this.fileSystem.readdirSync,
+			this.fileSystem
+		);
+		const readdir = this._readdirBackend.provide;
+		this.readdir = /** @type {FileSystem["readdir"]} */ (readdir);
+		const readdirSync = this._readdirBackend.provideSync;
+		this.readdirSync = /** @type {SyncFileSystem["readdirSync"]} */ (readdirSync);
 
-    /**
-     * Whether the reference is static.
-     * @method Reference#isStatic
-     * @returns {boolean} static
-     */
-    isStatic() {
-        return !this.tainted && this.resolved && this.resolved.scope.isStatic();
-    }
-
-    /**
-     * Whether the reference is writeable.
-     * @method Reference#isWrite
-     * @returns {boolean} write
-     */
-    isWrite() {
-        return !!(this.flag & Reference.WRITE);
-    }
-
-    /**
-     * Whether the reference is readable.
-     * @method Reference#isRead
-     * @returns {boolean} read
-     */
-    isRead() {
-        return !!(this.flag & Reference.READ);
-    }
-
-    /**
-     * Whether the reference is read-only.
-     * @method Reference#isReadOnly
-     * @returns {boolean} read only
-     */
-    isReadOnly() {
-        return this.flag === Reference.READ;
-    }
-
-    /**
-     * Whether the reference is write-only.
-     * @method Reference#isWriteOnly
-     * @returns {boolean} write only
-     */
-    isWriteOnly() {
-        return this.flag === Reference.WRITE;
-    }
-
-    /**
-     * Whether the reference is read-write.
-     * @method Reference#isReadWrite
-     * @returns {boolean} read write
-     */
-    isReadWrite() {
-        return this.flag === Reference.RW;
-    }
-}
-
-/**
- * @constant Reference.READ
- * @private
- */
-Reference.READ = READ;
-
-/**
- * @constant Reference.WRITE
- * @private
- */
-Reference.WRITE = WRITE;
+		this._readFileBackend = createBackend(
+			duration,
+			this.fileSystem.readFile,
+			this.fileSystem.readFileSync,
+			this.fileSystem
+		);
+		const readFile = this._readFileBackend.provide;
+		this.readFile = /** @type {FileSystem["readFile"]} */ (readFile);
+		const readFileSync = this._readFileBackend.provideSync;
+		this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */ (readFileSync);
 
-/**
- * @constant Reference.RW
- * @private
- */
-Reference.RW = RW;
+		this._readJsonBackend = createBackend(
+			duration,
+			this.fileSystem.readJson ||
+				(this.readFile &&
+					((path, callback) => {
+						// @ts-ignore
+						this.readFile(path, (err, buffer) => {
+							if (err) return callback(err);
+							if (!buffer || buffer.length === 0)
+								return callback(new Error("No file content"));
+							let data;
+							try {
+								data = JSON.parse(buffer.toString("utf-8"));
+							} catch (e) {
+								return callback(e);
+							}
+							callback(null, data);
+						});
+					})),
+			this.fileSystem.readJsonSync ||
+				(this.readFileSync &&
+					(path => {
+						const buffer = this.readFileSync(path);
+						const data = JSON.parse(buffer.toString("utf-8"));
+						return data;
+					})),
+			this.fileSystem
+		);
+		const readJson = this._readJsonBackend.provide;
+		this.readJson = /** @type {FileSystem["readJson"]} */ (readJson);
+		const readJsonSync = this._readJsonBackend.provideSync;
+		this.readJsonSync = /** @type {SyncFileSystem["readJsonSync"]} */ (readJsonSync);
 
-module.exports = Reference;
+		this._readlinkBackend = createBackend(
+			duration,
+			this.fileSystem.readlink,
+			this.fileSystem.readlinkSync,
+			this.fileSystem
+		);
+		const readlink = this._readlinkBackend.provide;
+		this.readlink = /** @type {FileSystem["readlink"]} */ (readlink);
+		const readlinkSync = this._readlinkBackend.provideSync;
+		this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */ (readlinkSync);
+	}
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+	purge(what) {
+		this._statBackend.purge(what);
+		this._lstatBackend.purge(what);
+		this._readdirBackend.purgeParent(what);
+		this._readFileBackend.purge(what);
+		this._readlinkBackend.purge(what);
+		this._readJsonBackend.purge(what);
+	}
+};
 
 
 /***/ }),
 
-/***/ 44585:
+/***/ 2020:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable no-undefined */
 
-const Syntax = (__webpack_require__(18350).Syntax);
-const esrecurse = __webpack_require__(81217);
-const Reference = __webpack_require__(64945);
-const Variable = __webpack_require__(82971);
-const PatternVisitor = __webpack_require__(54162);
-const definition = __webpack_require__(70665);
-const assert = __webpack_require__(39491);
+const basename = (__webpack_require__(48608).basename);
 
-const ParameterDefinition = definition.ParameterDefinition;
-const Definition = definition.Definition;
+/** @typedef {import("./Resolver")} Resolver */
 
-/**
- * Traverse identifier in pattern
- * @param {Object} options - options
- * @param {pattern} rootPattern - root pattern
- * @param {Refencer} referencer - referencer
- * @param {callback} callback - callback
- * @returns {void}
- */
-function traverseIdentifierInPattern(options, rootPattern, referencer, callback) {
+module.exports = class CloneBasenamePlugin {
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-    // Call the callback at left hand identifier nodes, and Collect right hand nodes.
-    const visitor = new PatternVisitor(options, rootPattern, callback);
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
+				const filename = basename(request.path);
+				const filePath = resolver.join(request.path, filename);
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, filename)
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"using path: " + filePath,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
-    visitor.visit(rootPattern);
 
-    // Process the right hand nodes recursively.
-    if (referencer !== null && referencer !== undefined) {
-        visitor.rightHandNodes.forEach(referencer.visit, referencer);
-    }
-}
+/***/ }),
 
-// Importing ImportDeclaration.
-// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-moduledeclarationinstantiation
-// https://github.com/estree/estree/blob/master/es6.md#importdeclaration
-// FIXME: Now, we don't create module environment, because the context is
-// implementation dependent.
+/***/ 44193:
+/***/ (function(module) {
 
-class Importer extends esrecurse.Visitor {
-    constructor(declaration, referencer) {
-        super(null, referencer.options);
-        this.declaration = declaration;
-        this.referencer = referencer;
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    visitImport(id, specifier) {
-        this.referencer.visitPattern(id, pattern => {
-            this.referencer.currentScope().__define(pattern,
-                new Definition(
-                    Variable.ImportBinding,
-                    pattern,
-                    specifier,
-                    this.declaration,
-                    null,
-                    null
-                ));
-        });
-    }
 
-    ImportNamespaceSpecifier(node) {
-        const local = (node.local || node.id);
 
-        if (local) {
-            this.visitImport(local, node);
-        }
-    }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    ImportDefaultSpecifier(node) {
-        const local = (node.local || node.id);
+module.exports = class ConditionalPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Partial<ResolveRequest>} test compare object
+	 * @param {string | null} message log message
+	 * @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, test, message, allowAlternatives, target) {
+		this.source = source;
+		this.test = test;
+		this.message = message;
+		this.allowAlternatives = allowAlternatives;
+		this.target = target;
+	}
 
-        this.visitImport(local, node);
-    }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const { test, message, allowAlternatives } = this;
+		const keys = Object.keys(test);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ConditionalPlugin", (request, resolveContext, callback) => {
+				for (const prop of keys) {
+					if (request[prop] !== test[prop]) return callback();
+				}
+				resolver.doResolve(
+					target,
+					request,
+					message,
+					resolveContext,
+					allowAlternatives
+						? callback
+						: (err, result) => {
+								if (err) return callback(err);
 
-    ImportSpecifier(node) {
-        const local = (node.local || node.id);
+								// Don't allow other alternatives
+								if (result === undefined) return callback(null, null);
+								callback(null, result);
+						  }
+				);
+			});
+	}
+};
 
-        if (node.name) {
-            this.visitImport(node.name, node);
-        } else {
-            this.visitImport(local, node);
-        }
-    }
-}
 
-// Referencing variables and creating bindings.
-class Referencer extends esrecurse.Visitor {
-    constructor(options, scopeManager) {
-        super(null, options);
-        this.options = options;
-        this.scopeManager = scopeManager;
-        this.parent = null;
-        this.isInnerMethodDefinition = false;
-    }
+/***/ }),
 
-    currentScope() {
-        return this.scopeManager.__currentScope;
-    }
+/***/ 66826:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    close(node) {
-        while (this.currentScope() && node === this.currentScope().block) {
-            this.scopeManager.__currentScope = this.currentScope().__close(this.scopeManager);
-        }
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    pushInnerMethodDefinition(isInnerMethodDefinition) {
-        const previous = this.isInnerMethodDefinition;
 
-        this.isInnerMethodDefinition = isInnerMethodDefinition;
-        return previous;
-    }
 
-    popInnerMethodDefinition(isInnerMethodDefinition) {
-        this.isInnerMethodDefinition = isInnerMethodDefinition;
-    }
+const DescriptionFileUtils = __webpack_require__(702);
 
-    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {
-        const scope = this.currentScope();
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-        assignments.forEach(assignment => {
-            scope.__referencing(
-                pattern,
-                Reference.WRITE,
-                assignment.right,
-                maybeImplicitGlobal,
-                pattern !== assignment.left,
-                init
-            );
-        });
-    }
+module.exports = class DescriptionFilePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string[]} filenames filenames
+	 * @param {boolean} pathIsFile pathIsFile
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filenames, pathIsFile, target) {
+		this.source = source;
+		this.filenames = filenames;
+		this.pathIsFile = pathIsFile;
+		this.target = target;
+	}
 
-    visitPattern(node, options, callback) {
-        let visitPatternOptions = options;
-        let visitPatternCallback = callback;
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"DescriptionFilePlugin",
+				(request, resolveContext, callback) => {
+					const path = request.path;
+					if (!path) return callback();
+					const directory = this.pathIsFile
+						? DescriptionFileUtils.cdUp(path)
+						: path;
+					if (!directory) return callback();
+					DescriptionFileUtils.loadDescriptionFile(
+						resolver,
+						directory,
+						this.filenames,
+						request.descriptionFilePath
+							? {
+									path: request.descriptionFilePath,
+									content: request.descriptionFileData,
+									directory: /** @type {string} */ (request.descriptionFileRoot)
+							  }
+							: undefined,
+						resolveContext,
+						(err, result) => {
+							if (err) return callback(err);
+							if (!result) {
+								if (resolveContext.log)
+									resolveContext.log(
+										`No description file found in ${directory} or above`
+									);
+								return callback();
+							}
+							const relativePath =
+								"." + path.substr(result.directory.length).replace(/\\/g, "/");
+							const obj = {
+								...request,
+								descriptionFilePath: result.path,
+								descriptionFileData: result.content,
+								descriptionFileRoot: result.directory,
+								relativePath: relativePath
+							};
+							resolver.doResolve(
+								target,
+								obj,
+								"using description file: " +
+									result.path +
+									" (relative path: " +
+									relativePath +
+									")",
+								resolveContext,
+								(err, result) => {
+									if (err) return callback(err);
 
-        if (typeof options === "function") {
-            visitPatternCallback = options;
-            visitPatternOptions = { processRightHandNodes: false };
-        }
+									// Don't allow other processing
+									if (result === undefined) return callback(null, null);
+									callback(null, result);
+								}
+							);
+						}
+					);
+				}
+			);
+	}
+};
 
-        traverseIdentifierInPattern(
-            this.options,
-            node,
-            visitPatternOptions.processRightHandNodes ? this : null,
-            visitPatternCallback
-        );
-    }
 
-    visitFunction(node) {
-        let i, iz;
+/***/ }),
 
-        // FunctionDeclaration name is defined in upper scope
-        // NOTE: Not referring variableScope. It is intended.
-        // Since
-        //  in ES5, FunctionDeclaration should be in FunctionBody.
-        //  in ES6, FunctionDeclaration should be block scoped.
+/***/ 702:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-        if (node.type === Syntax.FunctionDeclaration) {
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-            // id is defined in upper scope
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.FunctionName,
-                    node.id,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-        }
 
-        // FunctionExpression with name creates its special scope;
-        // FunctionExpressionNameScope.
-        if (node.type === Syntax.FunctionExpression && node.id) {
-            this.scopeManager.__nestFunctionExpressionNameScope(node);
-        }
 
-        // Consider this function is in the MethodDefinition.
-        this.scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);
+const forEachBail = __webpack_require__(8266);
 
-        const that = this;
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
 
-        /**
-         * Visit pattern callback
-         * @param {pattern} pattern - pattern
-         * @param {Object} info - info
-         * @returns {void}
-         */
-        function visitPatternCallback(pattern, info) {
-            that.currentScope().__define(pattern,
-                new ParameterDefinition(
-                    pattern,
-                    node,
-                    i,
-                    info.rest
-                ));
+/**
+ * @typedef {Object} DescriptionFileInfo
+ * @property {any=} content
+ * @property {string} path
+ * @property {string} directory
+ */
 
-            that.referencingDefaultValue(pattern, info.assignments, null, true);
-        }
-
-        // Process parameter declarations.
-        for (i = 0, iz = node.params.length; i < iz; ++i) {
-            this.visitPattern(node.params[i], { processRightHandNodes: true }, visitPatternCallback);
-        }
-
-        // if there's a rest argument, add that
-        if (node.rest) {
-            this.visitPattern({
-                type: "RestElement",
-                argument: node.rest
-            }, pattern => {
-                this.currentScope().__define(pattern,
-                    new ParameterDefinition(
-                        pattern,
-                        node,
-                        node.params.length,
-                        true
-                    ));
-            });
-        }
-
-        // In TypeScript there are a number of function-like constructs which have no body,
-        // so check it exists before traversing
-        if (node.body) {
-
-            // Skip BlockStatement to prevent creating BlockStatement scope.
-            if (node.body.type === Syntax.BlockStatement) {
-                this.visitChildren(node.body);
-            } else {
-                this.visit(node.body);
-            }
-        }
+/**
+ * @callback ErrorFirstCallback
+ * @param {Error|null=} error
+ * @param {DescriptionFileInfo=} result
+ */
 
-        this.close(node);
-    }
+/**
+ * @param {Resolver} resolver resolver
+ * @param {string} directory directory
+ * @param {string[]} filenames filenames
+ * @param {DescriptionFileInfo|undefined} oldInfo oldInfo
+ * @param {ResolveContext} resolveContext resolveContext
+ * @param {ErrorFirstCallback} callback callback
+ */
+function loadDescriptionFile(
+	resolver,
+	directory,
+	filenames,
+	oldInfo,
+	resolveContext,
+	callback
+) {
+	(function findDescriptionFile() {
+		if (oldInfo && oldInfo.directory === directory) {
+			// We already have info for this directory and can reuse it
+			return callback(null, oldInfo);
+		}
+		forEachBail(
+			filenames,
+			(filename, callback) => {
+				const descriptionFilePath = resolver.join(directory, filename);
+				if (resolver.fileSystem.readJson) {
+					resolver.fileSystem.readJson(descriptionFilePath, (err, content) => {
+						if (err) {
+							if (typeof err.code !== "undefined") {
+								if (resolveContext.missingDependencies) {
+									resolveContext.missingDependencies.add(descriptionFilePath);
+								}
+								return callback();
+							}
+							if (resolveContext.fileDependencies) {
+								resolveContext.fileDependencies.add(descriptionFilePath);
+							}
+							return onJson(err);
+						}
+						if (resolveContext.fileDependencies) {
+							resolveContext.fileDependencies.add(descriptionFilePath);
+						}
+						onJson(null, content);
+					});
+				} else {
+					resolver.fileSystem.readFile(descriptionFilePath, (err, content) => {
+						if (err) {
+							if (resolveContext.missingDependencies) {
+								resolveContext.missingDependencies.add(descriptionFilePath);
+							}
+							return callback();
+						}
+						if (resolveContext.fileDependencies) {
+							resolveContext.fileDependencies.add(descriptionFilePath);
+						}
+						let json;
 
-    visitClass(node) {
-        if (node.type === Syntax.ClassDeclaration) {
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.ClassName,
-                    node.id,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-        }
+						if (content) {
+							try {
+								json = JSON.parse(content.toString());
+							} catch (e) {
+								return onJson(e);
+							}
+						} else {
+							return onJson(new Error("No content in file"));
+						}
 
-        this.visit(node.superClass);
+						onJson(null, json);
+					});
+				}
 
-        this.scopeManager.__nestClassScope(node);
+				function onJson(err, content) {
+					if (err) {
+						if (resolveContext.log)
+							resolveContext.log(
+								descriptionFilePath + " (directory description file): " + err
+							);
+						else
+							err.message =
+								descriptionFilePath + " (directory description file): " + err;
+						return callback(err);
+					}
+					callback(null, {
+						content,
+						directory,
+						path: descriptionFilePath
+					});
+				}
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				if (result) {
+					return callback(null, result);
+				} else {
+					const dir = cdUp(directory);
+					if (!dir) {
+						return callback();
+					} else {
+						directory = dir;
+						return findDescriptionFile();
+					}
+				}
+			}
+		);
+	})();
+}
 
-        if (node.id) {
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.ClassName,
-                    node.id,
-                    node
-                ));
-        }
-        this.visit(node.body);
+/**
+ * @param {any} content content
+ * @param {string|string[]} field field
+ * @returns {object|string|number|boolean|undefined} field data
+ */
+function getField(content, field) {
+	if (!content) return undefined;
+	if (Array.isArray(field)) {
+		let current = content;
+		for (let j = 0; j < field.length; j++) {
+			if (current === null || typeof current !== "object") {
+				current = null;
+				break;
+			}
+			current = current[field[j]];
+		}
+		return current;
+	} else {
+		return content[field];
+	}
+}
 
-        this.close(node);
-    }
+/**
+ * @param {string} directory directory
+ * @returns {string|null} parent directory or null
+ */
+function cdUp(directory) {
+	if (directory === "/") return null;
+	const i = directory.lastIndexOf("/"),
+		j = directory.lastIndexOf("\\");
+	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
+	if (p < 0) return null;
+	return directory.substr(0, p || 1);
+}
 
-    visitProperty(node) {
-        let previous;
+exports.loadDescriptionFile = loadDescriptionFile;
+exports.getField = getField;
+exports.cdUp = cdUp;
 
-        if (node.computed) {
-            this.visit(node.key);
-        }
 
-        const isMethodDefinition = node.type === Syntax.MethodDefinition;
+/***/ }),
 
-        if (isMethodDefinition) {
-            previous = this.pushInnerMethodDefinition(true);
-        }
-        this.visit(node.value);
-        if (isMethodDefinition) {
-            this.popInnerMethodDefinition(previous);
-        }
-    }
+/***/ 73688:
+/***/ (function(module) {
 
-    visitForIn(node) {
-        if (node.left.type === Syntax.VariableDeclaration && node.left.kind !== "var") {
-            this.scopeManager.__nestForScope(node);
-        }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        if (node.left.type === Syntax.VariableDeclaration) {
-            this.visit(node.left);
-            this.visitPattern(node.left.declarations[0].id, pattern => {
-                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, null, true, true);
-            });
-        } else {
-            this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
-                let maybeImplicitGlobal = null;
 
-                if (!this.currentScope().isStrict) {
-                    maybeImplicitGlobal = {
-                        pattern,
-                        node
-                    };
-                }
-                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
-                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, true, false);
-            });
-        }
-        this.visit(node.right);
-        this.visit(node.body);
 
-        this.close(node);
-    }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    visitVariableDeclaration(variableTargetScope, type, node, index) {
+module.exports = class DirectoryExistsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-        const decl = node.declarations[index];
-        const init = decl.init;
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"DirectoryExistsPlugin",
+				(request, resolveContext, callback) => {
+					const fs = resolver.fileSystem;
+					const directory = request.path;
+					if (!directory) return callback();
+					fs.stat(directory, (err, stat) => {
+						if (err || !stat) {
+							if (resolveContext.missingDependencies)
+								resolveContext.missingDependencies.add(directory);
+							if (resolveContext.log)
+								resolveContext.log(directory + " doesn't exist");
+							return callback();
+						}
+						if (!stat.isDirectory()) {
+							if (resolveContext.missingDependencies)
+								resolveContext.missingDependencies.add(directory);
+							if (resolveContext.log)
+								resolveContext.log(directory + " is not a directory");
+							return callback();
+						}
+						if (resolveContext.fileDependencies)
+							resolveContext.fileDependencies.add(directory);
+						resolver.doResolve(
+							target,
+							request,
+							`existing directory ${directory}`,
+							resolveContext,
+							callback
+						);
+					});
+				}
+			);
+	}
+};
 
-        this.visitPattern(decl.id, { processRightHandNodes: true }, (pattern, info) => {
-            variableTargetScope.__define(
-                pattern,
-                new Definition(
-                    type,
-                    pattern,
-                    decl,
-                    node,
-                    index,
-                    node.kind
-                )
-            );
 
-            this.referencingDefaultValue(pattern, info.assignments, null, true);
-            if (init) {
-                this.currentScope().__referencing(pattern, Reference.WRITE, init, null, !info.topLevel, true);
-            }
-        });
-    }
+/***/ }),
 
-    AssignmentExpression(node) {
-        if (PatternVisitor.isPattern(node.left)) {
-            if (node.operator === "=") {
-                this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
-                    let maybeImplicitGlobal = null;
+/***/ 80163:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-                    if (!this.currentScope().isStrict) {
-                        maybeImplicitGlobal = {
-                            pattern,
-                            node
-                        };
-                    }
-                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
-                    this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, !info.topLevel, false);
-                });
-            } else {
-                this.currentScope().__referencing(node.left, Reference.RW, node.right);
-            }
-        } else {
-            this.visit(node.left);
-        }
-        this.visit(node.right);
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-    CatchClause(node) {
-        this.scopeManager.__nestCatchScope(node);
 
-        this.visitPattern(node.param, { processRightHandNodes: true }, (pattern, info) => {
-            this.currentScope().__define(pattern,
-                new Definition(
-                    Variable.CatchClause,
-                    node.param,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-            this.referencingDefaultValue(pattern, info.assignments, null, true);
-        });
-        this.visit(node.body);
 
-        this.close(node);
-    }
+const path = __webpack_require__(71017);
+const DescriptionFileUtils = __webpack_require__(702);
+const forEachBail = __webpack_require__(8266);
+const { processExportsField } = __webpack_require__(28348);
+const { parseIdentifier } = __webpack_require__(7780);
+const { checkExportsFieldTarget } = __webpack_require__(3011);
 
-    Program(node) {
-        this.scopeManager.__nestGlobalScope(node);
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./util/entrypoints").ExportsField} ExportsField */
+/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
 
-        if (this.scopeManager.__isNodejsScope()) {
+module.exports = class ExportsFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Set<string>} conditionNames condition names
+	 * @param {string | string[]} fieldNamePath name path
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, conditionNames, fieldNamePath, target) {
+		this.source = source;
+		this.target = target;
+		this.conditionNames = conditionNames;
+		this.fieldName = fieldNamePath;
+		/** @type {WeakMap<any, FieldProcessor>} */
+		this.fieldProcessorCache = new WeakMap();
+	}
 
-            // Force strictness of GlobalScope to false when using node.js scope.
-            this.currentScope().isStrict = false;
-            this.scopeManager.__nestFunctionScope(node, false);
-        }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ExportsFieldPlugin", (request, resolveContext, callback) => {
+				// When there is no description file, abort
+				if (!request.descriptionFilePath) return callback();
+				if (
+					// When the description file is inherited from parent, abort
+					// (There is no description file inside of this package)
+					request.relativePath !== "." ||
+					request.request === undefined
+				)
+					return callback();
 
-        if (this.scopeManager.__isES6() && this.scopeManager.isModule()) {
-            this.scopeManager.__nestModuleScope(node);
-        }
+				const remainingRequest =
+					request.query || request.fragment
+						? (request.request === "." ? "./" : request.request) +
+						  request.query +
+						  request.fragment
+						: request.request;
+				/** @type {ExportsField|null} */
+				const exportsField = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.fieldName
+				);
+				if (!exportsField) return callback();
 
-        if (this.scopeManager.isStrictModeSupported() && this.scopeManager.isImpliedStrict()) {
-            this.currentScope().isStrict = true;
-        }
+				if (request.directory) {
+					return callback(
+						new Error(
+							`Resolving to directories is not possible with the exports field (request was ${remainingRequest}/)`
+						)
+					);
+				}
 
-        this.visitChildren(node);
-        this.close(node);
-    }
+				let paths;
 
-    Identifier(node) {
-        this.currentScope().__referencing(node);
-    }
+				try {
+					// We attach the cache to the description file instead of the exportsField value
+					// because we use a WeakMap and the exportsField could be a string too.
+					// Description file is always an object when exports field can be accessed.
+					let fieldProcessor = this.fieldProcessorCache.get(
+						request.descriptionFileData
+					);
+					if (fieldProcessor === undefined) {
+						fieldProcessor = processExportsField(exportsField);
+						this.fieldProcessorCache.set(
+							request.descriptionFileData,
+							fieldProcessor
+						);
+					}
+					paths = fieldProcessor(remainingRequest, this.conditionNames);
+				} catch (err) {
+					if (resolveContext.log) {
+						resolveContext.log(
+							`Exports field in ${request.descriptionFilePath} can't be processed: ${err}`
+						);
+					}
+					return callback(err);
+				}
 
-    UpdateExpression(node) {
-        if (PatternVisitor.isPattern(node.argument)) {
-            this.currentScope().__referencing(node.argument, Reference.RW, null);
-        } else {
-            this.visitChildren(node);
-        }
-    }
+				if (paths.length === 0) {
+					return callback(
+						new Error(
+							`Package path ${remainingRequest} is not exported from package ${request.descriptionFileRoot} (see exports field in ${request.descriptionFilePath})`
+						)
+					);
+				}
 
-    MemberExpression(node) {
-        this.visit(node.object);
-        if (node.computed) {
-            this.visit(node.property);
-        }
-    }
+				forEachBail(
+					paths,
+					(p, callback) => {
+						const parsedIdentifier = parseIdentifier(p);
 
-    Property(node) {
-        this.visitProperty(node);
-    }
+						if (!parsedIdentifier) return callback();
 
-    MethodDefinition(node) {
-        this.visitProperty(node);
-    }
+						const [relativePath, query, fragment] = parsedIdentifier;
 
-    BreakStatement() {} // eslint-disable-line class-methods-use-this
+						const error = checkExportsFieldTarget(relativePath);
 
-    ContinueStatement() {} // eslint-disable-line class-methods-use-this
+						if (error) {
+							return callback(error);
+						}
 
-    LabeledStatement(node) {
-        this.visit(node.body);
-    }
+						const obj = {
+							...request,
+							request: undefined,
+							path: path.join(
+								/** @type {string} */ (request.descriptionFileRoot),
+								relativePath
+							),
+							relativePath,
+							query,
+							fragment
+						};
 
-    ForStatement(node) {
+						resolver.doResolve(
+							target,
+							obj,
+							"using exports field: " + p,
+							resolveContext,
+							callback
+						);
+					},
+					(err, result) => callback(err, result || null)
+				);
+			});
+	}
+};
 
-        // Create ForStatement declaration.
-        // NOTE: In ES6, ForStatement dynamically generates
-        // per iteration environment. However, escope is
-        // a static analyzer, we only generate one scope for ForStatement.
-        if (node.init && node.init.type === Syntax.VariableDeclaration && node.init.kind !== "var") {
-            this.scopeManager.__nestForScope(node);
-        }
 
-        this.visitChildren(node);
+/***/ }),
 
-        this.close(node);
-    }
+/***/ 98699:
+/***/ (function(module) {
 
-    ClassExpression(node) {
-        this.visitClass(node);
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    ClassDeclaration(node) {
-        this.visitClass(node);
-    }
 
-    CallExpression(node) {
 
-        // Check this is direct call to eval
-        if (!this.scopeManager.__ignoreEval() && node.callee.type === Syntax.Identifier && node.callee.name === "eval") {
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-            // NOTE: This should be `variableScope`. Since direct eval call always creates Lexical environment and
-            // let / const should be enclosed into it. Only VariableDeclaration affects on the caller's environment.
-            this.currentScope().variableScope.__detectEval();
-        }
-        this.visitChildren(node);
-    }
+module.exports = class FileExistsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-    BlockStatement(node) {
-        if (this.scopeManager.__isES6()) {
-            this.scopeManager.__nestBlockScope(node);
-        }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const fs = resolver.fileSystem;
+		resolver
+			.getHook(this.source)
+			.tapAsync("FileExistsPlugin", (request, resolveContext, callback) => {
+				const file = request.path;
+				if (!file) return callback();
+				fs.stat(file, (err, stat) => {
+					if (err || !stat) {
+						if (resolveContext.missingDependencies)
+							resolveContext.missingDependencies.add(file);
+						if (resolveContext.log) resolveContext.log(file + " doesn't exist");
+						return callback();
+					}
+					if (!stat.isFile()) {
+						if (resolveContext.missingDependencies)
+							resolveContext.missingDependencies.add(file);
+						if (resolveContext.log) resolveContext.log(file + " is not a file");
+						return callback();
+					}
+					if (resolveContext.fileDependencies)
+						resolveContext.fileDependencies.add(file);
+					resolver.doResolve(
+						target,
+						request,
+						"existing file: " + file,
+						resolveContext,
+						callback
+					);
+				});
+			});
+	}
+};
 
-        this.visitChildren(node);
 
-        this.close(node);
-    }
+/***/ }),
 
-    ThisExpression() {
-        this.currentScope().variableScope.__detectThis();
-    }
+/***/ 86058:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    WithStatement(node) {
-        this.visit(node.object);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-        // Then nest scope for WithStatement.
-        this.scopeManager.__nestWithScope(node);
 
-        this.visit(node.body);
 
-        this.close(node);
-    }
+const path = __webpack_require__(71017);
+const DescriptionFileUtils = __webpack_require__(702);
+const forEachBail = __webpack_require__(8266);
+const { processImportsField } = __webpack_require__(28348);
+const { parseIdentifier } = __webpack_require__(7780);
 
-    VariableDeclaration(node) {
-        const variableTargetScope = (node.kind === "var") ? this.currentScope().variableScope : this.currentScope();
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
+/** @typedef {import("./util/entrypoints").ImportsField} ImportsField */
 
-        for (let i = 0, iz = node.declarations.length; i < iz; ++i) {
-            const decl = node.declarations[i];
+const dotCode = ".".charCodeAt(0);
 
-            this.visitVariableDeclaration(variableTargetScope, Variable.Variable, node, i);
-            if (decl.init) {
-                this.visit(decl.init);
-            }
-        }
-    }
+module.exports = class ImportsFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Set<string>} conditionNames condition names
+	 * @param {string | string[]} fieldNamePath name path
+	 * @param {string | ResolveStepHook} targetFile target file
+	 * @param {string | ResolveStepHook} targetPackage target package
+	 */
+	constructor(
+		source,
+		conditionNames,
+		fieldNamePath,
+		targetFile,
+		targetPackage
+	) {
+		this.source = source;
+		this.targetFile = targetFile;
+		this.targetPackage = targetPackage;
+		this.conditionNames = conditionNames;
+		this.fieldName = fieldNamePath;
+		/** @type {WeakMap<any, FieldProcessor>} */
+		this.fieldProcessorCache = new WeakMap();
+	}
 
-    // sec 13.11.8
-    SwitchStatement(node) {
-        this.visit(node.discriminant);
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const targetFile = resolver.ensureHook(this.targetFile);
+		const targetPackage = resolver.ensureHook(this.targetPackage);
 
-        if (this.scopeManager.__isES6()) {
-            this.scopeManager.__nestSwitchScope(node);
-        }
+		resolver
+			.getHook(this.source)
+			.tapAsync("ImportsFieldPlugin", (request, resolveContext, callback) => {
+				// When there is no description file, abort
+				if (!request.descriptionFilePath || request.request === undefined) {
+					return callback();
+				}
 
-        for (let i = 0, iz = node.cases.length; i < iz; ++i) {
-            this.visit(node.cases[i]);
-        }
+				const remainingRequest =
+					request.request + request.query + request.fragment;
+				/** @type {ImportsField|null} */
+				const importsField = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.fieldName
+				);
+				if (!importsField) return callback();
 
-        this.close(node);
-    }
+				if (request.directory) {
+					return callback(
+						new Error(
+							`Resolving to directories is not possible with the imports field (request was ${remainingRequest}/)`
+						)
+					);
+				}
 
-    FunctionDeclaration(node) {
-        this.visitFunction(node);
-    }
+				let paths;
 
-    FunctionExpression(node) {
-        this.visitFunction(node);
-    }
+				try {
+					// We attach the cache to the description file instead of the importsField value
+					// because we use a WeakMap and the importsField could be a string too.
+					// Description file is always an object when exports field can be accessed.
+					let fieldProcessor = this.fieldProcessorCache.get(
+						request.descriptionFileData
+					);
+					if (fieldProcessor === undefined) {
+						fieldProcessor = processImportsField(importsField);
+						this.fieldProcessorCache.set(
+							request.descriptionFileData,
+							fieldProcessor
+						);
+					}
+					paths = fieldProcessor(remainingRequest, this.conditionNames);
+				} catch (err) {
+					if (resolveContext.log) {
+						resolveContext.log(
+							`Imports field in ${request.descriptionFilePath} can't be processed: ${err}`
+						);
+					}
+					return callback(err);
+				}
 
-    ForOfStatement(node) {
-        this.visitForIn(node);
-    }
+				if (paths.length === 0) {
+					return callback(
+						new Error(
+							`Package import ${remainingRequest} is not imported from package ${request.descriptionFileRoot} (see imports field in ${request.descriptionFilePath})`
+						)
+					);
+				}
 
-    ForInStatement(node) {
-        this.visitForIn(node);
-    }
+				forEachBail(
+					paths,
+					(p, callback) => {
+						const parsedIdentifier = parseIdentifier(p);
 
-    ArrowFunctionExpression(node) {
-        this.visitFunction(node);
-    }
+						if (!parsedIdentifier) return callback();
 
-    ImportDeclaration(node) {
-        assert(this.scopeManager.__isES6() && this.scopeManager.isModule(), "ImportDeclaration should appear when the mode is ES6 and in the module context.");
+						const [path_, query, fragment] = parsedIdentifier;
 
-        const importer = new Importer(node, this);
+						switch (path_.charCodeAt(0)) {
+							// should be relative
+							case dotCode: {
+								const obj = {
+									...request,
+									request: undefined,
+									path: path.join(
+										/** @type {string} */ (request.descriptionFileRoot),
+										path_
+									),
+									relativePath: path_,
+									query,
+									fragment
+								};
 
-        importer.visit(node);
-    }
+								resolver.doResolve(
+									targetFile,
+									obj,
+									"using imports field: " + p,
+									resolveContext,
+									callback
+								);
+								break;
+							}
 
-    visitExportDeclaration(node) {
-        if (node.source) {
-            return;
-        }
-        if (node.declaration) {
-            this.visit(node.declaration);
-            return;
-        }
+							// package resolving
+							default: {
+								const obj = {
+									...request,
+									request: path_,
+									relativePath: path_,
+									fullySpecified: true,
+									query,
+									fragment
+								};
 
-        this.visitChildren(node);
-    }
+								resolver.doResolve(
+									targetPackage,
+									obj,
+									"using imports field: " + p,
+									resolveContext,
+									callback
+								);
+							}
+						}
+					},
+					(err, result) => callback(err, result || null)
+				);
+			});
+	}
+};
 
-    // TODO: ExportDeclaration doesn't exist. for bc?
-    ExportDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
 
-    ExportAllDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
+/***/ }),
 
-    ExportDefaultDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
+/***/ 20879:
+/***/ (function(module) {
 
-    ExportNamedDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    ExportSpecifier(node) {
 
-        // TODO: `node.id` doesn't exist. for bc?
-        const local = (node.id || node.local);
 
-        this.visit(local);
-    }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    MetaProperty() { // eslint-disable-line class-methods-use-this
+const namespaceStartCharCode = "@".charCodeAt(0);
 
-        // do nothing.
-    }
-}
+module.exports = class JoinRequestPartPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-module.exports = Referencer;
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"JoinRequestPartPlugin",
+				(request, resolveContext, callback) => {
+					const req = request.request || "";
+					let i = req.indexOf("/", 3);
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+					if (i >= 0 && req.charCodeAt(2) === namespaceStartCharCode) {
+						i = req.indexOf("/", i + 1);
+					}
+
+					let moduleName, remainingRequest, fullySpecified;
+					if (i < 0) {
+						moduleName = req;
+						remainingRequest = ".";
+						fullySpecified = false;
+					} else {
+						moduleName = req.slice(0, i);
+						remainingRequest = "." + req.slice(i);
+						fullySpecified = request.fullySpecified;
+					}
+					const obj = {
+						...request,
+						path: resolver.join(request.path, moduleName),
+						relativePath:
+							request.relativePath &&
+							resolver.join(request.relativePath, moduleName),
+						request: remainingRequest,
+						fullySpecified
+					};
+					resolver.doResolve(target, obj, null, resolveContext, callback);
+				}
+			);
+	}
+};
 
 
 /***/ }),
 
-/***/ 96988:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 71474:
+/***/ (function(module) {
 
 "use strict";
 /*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
+module.exports = class JoinRequestPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-/* eslint-disable no-underscore-dangle */
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => {
+				const obj = {
+					...request,
+					path: resolver.join(request.path, request.request),
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, request.request),
+					request: undefined
+				};
+				resolver.doResolve(target, obj, null, resolveContext, callback);
+			});
+	}
+};
 
-const Scope = __webpack_require__(16313);
-const assert = __webpack_require__(39491);
 
-const GlobalScope = Scope.GlobalScope;
-const CatchScope = Scope.CatchScope;
-const WithScope = Scope.WithScope;
-const ModuleScope = Scope.ModuleScope;
-const ClassScope = Scope.ClassScope;
-const SwitchScope = Scope.SwitchScope;
-const FunctionScope = Scope.FunctionScope;
-const ForScope = Scope.ForScope;
-const FunctionExpressionNameScope = Scope.FunctionExpressionNameScope;
-const BlockScope = Scope.BlockScope;
+/***/ }),
 
-/**
- * @class ScopeManager
- */
-class ScopeManager {
-    constructor(options) {
-        this.scopes = [];
-        this.globalScope = null;
-        this.__nodeToScope = new WeakMap();
-        this.__currentScope = null;
-        this.__options = options;
-        this.__declaredVariables = new WeakMap();
-    }
+/***/ 47032:
+/***/ (function(module) {
 
-    __useDirective() {
-        return this.__options.directive;
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    __isOptimistic() {
-        return this.__options.optimistic;
-    }
 
-    __ignoreEval() {
-        return this.__options.ignoreEval;
-    }
 
-    __isNodejsScope() {
-        return this.__options.nodejsScope;
-    }
-
-    isModule() {
-        return this.__options.sourceType === "module";
-    }
+/** @typedef {import("./Resolver")} Resolver */
 
-    isImpliedStrict() {
-        return this.__options.impliedStrict;
-    }
+module.exports = class LogInfoPlugin {
+	constructor(source) {
+		this.source = source;
+	}
 
-    isStrictModeSupported() {
-        return this.__options.ecmaVersion >= 5;
-    }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const source = this.source;
+		resolver
+			.getHook(this.source)
+			.tapAsync("LogInfoPlugin", (request, resolveContext, callback) => {
+				if (!resolveContext.log) return callback();
+				const log = resolveContext.log;
+				const prefix = "[" + source + "] ";
+				if (request.path)
+					log(prefix + "Resolving in directory: " + request.path);
+				if (request.request)
+					log(prefix + "Resolving request: " + request.request);
+				if (request.module) log(prefix + "Request is an module request.");
+				if (request.directory) log(prefix + "Request is a directory request.");
+				if (request.query)
+					log(prefix + "Resolving request query: " + request.query);
+				if (request.fragment)
+					log(prefix + "Resolving request fragment: " + request.fragment);
+				if (request.descriptionFilePath)
+					log(
+						prefix + "Has description data from " + request.descriptionFilePath
+					);
+				if (request.relativePath)
+					log(
+						prefix +
+							"Relative path from description file is: " +
+							request.relativePath
+					);
+				callback();
+			});
+	}
+};
 
-    // Returns appropriate scope for this node.
-    __get(node) {
-        return this.__nodeToScope.get(node);
-    }
 
-    /**
-     * Get variables that are declared by the node.
-     *
-     * "are declared by the node" means the node is same as `Variable.defs[].node` or `Variable.defs[].parent`.
-     * If the node declares nothing, this method returns an empty array.
-     * CAUTION: This API is experimental. See https://github.com/estools/escope/pull/69 for more details.
-     *
-     * @param {Espree.Node} node - a node to get.
-     * @returns {Variable[]} variables that declared by the node.
-     */
-    getDeclaredVariables(node) {
-        return this.__declaredVariables.get(node) || [];
-    }
+/***/ }),
 
-    /**
-     * acquire scope from node.
-     * @method ScopeManager#acquire
-     * @param {Espree.Node} node - node for the acquired scope.
-     * @param {boolean=} inner - look up the most inner scope, default value is false.
-     * @returns {Scope?} Scope from node
-     */
-    acquire(node, inner) {
+/***/ 73507:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        /**
-         * predicate
-         * @param {Scope} testScope - scope to test
-         * @returns {boolean} predicate
-         */
-        function predicate(testScope) {
-            if (testScope.type === "function" && testScope.functionExpressionScope) {
-                return false;
-            }
-            return true;
-        }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        const scopes = this.__get(node);
 
-        if (!scopes || scopes.length === 0) {
-            return null;
-        }
 
-        // Heuristic selection from all scopes.
-        // If you would like to get all scopes, please use ScopeManager#acquireAll.
-        if (scopes.length === 1) {
-            return scopes[0];
-        }
+const path = __webpack_require__(71017);
+const DescriptionFileUtils = __webpack_require__(702);
 
-        if (inner) {
-            for (let i = scopes.length - 1; i >= 0; --i) {
-                const scope = scopes[i];
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{name: string|Array<string>, forceRelative: boolean}} MainFieldOptions */
 
-                if (predicate(scope)) {
-                    return scope;
-                }
-            }
-        } else {
-            for (let i = 0, iz = scopes.length; i < iz; ++i) {
-                const scope = scopes[i];
+const alreadyTriedMainField = Symbol("alreadyTriedMainField");
 
-                if (predicate(scope)) {
-                    return scope;
-                }
-            }
-        }
+module.exports = class MainFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {MainFieldOptions} options options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, options, target) {
+		this.source = source;
+		this.options = options;
+		this.target = target;
+	}
 
-        return null;
-    }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("MainFieldPlugin", (request, resolveContext, callback) => {
+				if (
+					request.path !== request.descriptionFileRoot ||
+					request[alreadyTriedMainField] === request.descriptionFilePath ||
+					!request.descriptionFilePath
+				)
+					return callback();
+				const filename = path.basename(request.descriptionFilePath);
+				let mainModule = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.options.name
+				);
 
-    /**
-     * acquire all scopes from node.
-     * @method ScopeManager#acquireAll
-     * @param {Espree.Node} node - node for the acquired scope.
-     * @returns {Scopes?} Scope array
-     */
-    acquireAll(node) {
-        return this.__get(node);
-    }
+				if (
+					!mainModule ||
+					typeof mainModule !== "string" ||
+					mainModule === "." ||
+					mainModule === "./"
+				) {
+					return callback();
+				}
+				if (this.options.forceRelative && !/^\.\.?\//.test(mainModule))
+					mainModule = "./" + mainModule;
+				const obj = {
+					...request,
+					request: mainModule,
+					module: false,
+					directory: mainModule.endsWith("/"),
+					[alreadyTriedMainField]: request.descriptionFilePath
+				};
+				return resolver.doResolve(
+					target,
+					obj,
+					"use " +
+						mainModule +
+						" from " +
+						this.options.name +
+						" in " +
+						filename,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
-    /**
-     * release the node.
-     * @method ScopeManager#release
-     * @param {Espree.Node} node - releasing node.
-     * @param {boolean=} inner - look up the most inner scope, default value is false.
-     * @returns {Scope?} upper scope for the node.
-     */
-    release(node, inner) {
-        const scopes = this.__get(node);
 
-        if (scopes && scopes.length) {
-            const scope = scopes[0].upper;
+/***/ }),
 
-            if (!scope) {
-                return null;
-            }
-            return this.acquire(scope.block, inner);
-        }
-        return null;
-    }
+/***/ 3688:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    attach() { } // eslint-disable-line class-methods-use-this
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    detach() { } // eslint-disable-line class-methods-use-this
 
-    __nestScope(scope) {
-        if (scope instanceof GlobalScope) {
-            assert(this.__currentScope === null);
-            this.globalScope = scope;
-        }
-        this.__currentScope = scope;
-        return scope;
-    }
 
-    __nestGlobalScope(node) {
-        return this.__nestScope(new GlobalScope(this, node));
-    }
+const forEachBail = __webpack_require__(8266);
+const getPaths = __webpack_require__(48608);
 
-    __nestBlockScope(node) {
-        return this.__nestScope(new BlockScope(this, this.__currentScope, node));
-    }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    __nestFunctionScope(node, isMethodDefinition) {
-        return this.__nestScope(new FunctionScope(this, this.__currentScope, node, isMethodDefinition));
-    }
+module.exports = class ModulesInHierachicDirectoriesPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | Array<string>} directories directories
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, directories, target) {
+		this.source = source;
+		this.directories = /** @type {Array<string>} */ ([]).concat(directories);
+		this.target = target;
+	}
 
-    __nestForScope(node) {
-        return this.__nestScope(new ForScope(this, this.__currentScope, node));
-    }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"ModulesInHierachicDirectoriesPlugin",
+				(request, resolveContext, callback) => {
+					const fs = resolver.fileSystem;
+					const addrs = getPaths(request.path)
+						.paths.map(p => {
+							return this.directories.map(d => resolver.join(p, d));
+						})
+						.reduce((array, p) => {
+							array.push.apply(array, p);
+							return array;
+						}, []);
+					forEachBail(
+						addrs,
+						(addr, callback) => {
+							fs.stat(addr, (err, stat) => {
+								if (!err && stat && stat.isDirectory()) {
+									const obj = {
+										...request,
+										path: addr,
+										request: "./" + request.request,
+										module: false
+									};
+									const message = "looking for modules in " + addr;
+									return resolver.doResolve(
+										target,
+										obj,
+										message,
+										resolveContext,
+										callback
+									);
+								}
+								if (resolveContext.log)
+									resolveContext.log(
+										addr + " doesn't exist or is not a directory"
+									);
+								if (resolveContext.missingDependencies)
+									resolveContext.missingDependencies.add(addr);
+								return callback();
+							});
+						},
+						callback
+					);
+				}
+			);
+	}
+};
 
-    __nestCatchScope(node) {
-        return this.__nestScope(new CatchScope(this, this.__currentScope, node));
-    }
 
-    __nestWithScope(node) {
-        return this.__nestScope(new WithScope(this, this.__currentScope, node));
-    }
+/***/ }),
 
-    __nestClassScope(node) {
-        return this.__nestScope(new ClassScope(this, this.__currentScope, node));
-    }
+/***/ 48952:
+/***/ (function(module) {
 
-    __nestSwitchScope(node) {
-        return this.__nestScope(new SwitchScope(this, this.__currentScope, node));
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    __nestModuleScope(node) {
-        return this.__nestScope(new ModuleScope(this, this.__currentScope, node));
-    }
 
-    __nestFunctionExpressionNameScope(node) {
-        return this.__nestScope(new FunctionExpressionNameScope(this, this.__currentScope, node));
-    }
 
-    __isES6() {
-        return this.__options.ecmaVersion >= 6;
-    }
-}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-module.exports = ScopeManager;
+module.exports = class ModulesInRootPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} path path
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, path, target) {
+		this.source = source;
+		this.path = path;
+		this.target = target;
+	}
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => {
+				const obj = {
+					...request,
+					path: this.path,
+					request: "./" + request.request,
+					module: false
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"looking for modules in " + this.path,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
 
 /***/ }),
 
-/***/ 16313:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 79135:
+/***/ (function(module) {
 
 "use strict";
 /*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable no-undefined */
 
-const Syntax = (__webpack_require__(18350).Syntax);
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-const Reference = __webpack_require__(64945);
-const Variable = __webpack_require__(82971);
-const Definition = (__webpack_require__(70665).Definition);
-const assert = __webpack_require__(39491);
+module.exports = class NextPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-/**
- * Test if scope is struct
- * @param {Scope} scope - scope
- * @param {Block} block - block
- * @param {boolean} isMethodDefinition - is method definition
- * @param {boolean} useDirective - use directive
- * @returns {boolean} is strict scope
- */
-function isStrictScope(scope, block, isMethodDefinition, useDirective) {
-    let body;
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("NextPlugin", (request, resolveContext, callback) => {
+				resolver.doResolve(target, request, null, resolveContext, callback);
+			});
+	}
+};
 
-    // When upper scope is exists and strict, inner scope is also strict.
-    if (scope.upper && scope.upper.isStrict) {
-        return true;
-    }
 
-    if (isMethodDefinition) {
-        return true;
-    }
+/***/ }),
 
-    if (scope.type === "class" || scope.type === "module") {
-        return true;
-    }
+/***/ 15234:
+/***/ (function(module) {
 
-    if (scope.type === "block" || scope.type === "switch") {
-        return false;
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    if (scope.type === "function") {
-        if (block.type === Syntax.ArrowFunctionExpression && block.body.type !== Syntax.BlockStatement) {
-            return false;
-        }
 
-        if (block.type === Syntax.Program) {
-            body = block;
-        } else {
-            body = block.body;
-        }
 
-        if (!body) {
-            return false;
-        }
-    } else if (scope.type === "global") {
-        body = block;
-    } else {
-        return false;
-    }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    // Search 'use strict' directive.
-    if (useDirective) {
-        for (let i = 0, iz = body.body.length; i < iz; ++i) {
-            const stmt = body.body[i];
+module.exports = class ParsePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Partial<ResolveRequest>} requestOptions request options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, requestOptions, target) {
+		this.source = source;
+		this.requestOptions = requestOptions;
+		this.target = target;
+	}
 
-            if (stmt.type !== Syntax.DirectiveStatement) {
-                break;
-            }
-            if (stmt.raw === "\"use strict\"" || stmt.raw === "'use strict'") {
-                return true;
-            }
-        }
-    } else {
-        for (let i = 0, iz = body.body.length; i < iz; ++i) {
-            const stmt = body.body[i];
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ParsePlugin", (request, resolveContext, callback) => {
+				const parsed = resolver.parse(/** @type {string} */ (request.request));
+				const obj = { ...request, ...parsed, ...this.requestOptions };
+				if (request.query && !parsed.query) {
+					obj.query = request.query;
+				}
+				if (request.fragment && !parsed.fragment) {
+					obj.fragment = request.fragment;
+				}
+				if (parsed && resolveContext.log) {
+					if (parsed.module) resolveContext.log("Parsed request is a module");
+					if (parsed.directory)
+						resolveContext.log("Parsed request is a directory");
+				}
+				// There is an edge-case where a request with # can be a path or a fragment -> try both
+				if (obj.request && !obj.query && obj.fragment) {
+					const directory = obj.fragment.endsWith("/");
+					const alternative = {
+						...obj,
+						directory,
+						request:
+							obj.request +
+							(obj.directory ? "/" : "") +
+							(directory ? obj.fragment.slice(0, -1) : obj.fragment),
+						fragment: ""
+					};
+					resolver.doResolve(
+						target,
+						alternative,
+						null,
+						resolveContext,
+						(err, result) => {
+							if (err) return callback(err);
+							if (result) return callback(null, result);
+							resolver.doResolve(target, obj, null, resolveContext, callback);
+						}
+					);
+					return;
+				}
+				resolver.doResolve(target, obj, null, resolveContext, callback);
+			});
+	}
+};
 
-            if (stmt.type !== Syntax.ExpressionStatement) {
-                break;
-            }
-            const expr = stmt.expression;
 
-            if (expr.type !== Syntax.Literal || typeof expr.value !== "string") {
-                break;
-            }
-            if (expr.raw !== null && expr.raw !== undefined) {
-                if (expr.raw === "\"use strict\"" || expr.raw === "'use strict'") {
-                    return true;
-                }
-            } else {
-                if (expr.value === "use strict") {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
+/***/ }),
 
-/**
- * Register scope
- * @param {ScopeManager} scopeManager - scope manager
- * @param {Scope} scope - scope
- * @returns {void}
- */
-function registerScope(scopeManager, scope) {
-    scopeManager.scopes.push(scope);
+/***/ 71488:
+/***/ (function(module) {
 
-    const scopes = scopeManager.__nodeToScope.get(scope.block);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Maël Nison @arcanis
+*/
 
-    if (scopes) {
-        scopes.push(scope);
-    } else {
-        scopeManager.__nodeToScope.set(scope.block, [scope]);
-    }
-}
 
-/**
- * Should be statically
- * @param {Object} def - def
- * @returns {boolean} should be statically
- */
-function shouldBeStatically(def) {
-    return (
-        (def.type === Variable.ClassName) ||
-        (def.type === Variable.Variable && def.parent.kind !== "var")
-    );
-}
 
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 /**
- * @class Scope
+ * @typedef {Object} PnpApiImpl
+ * @property {function(string, string, object): string} resolveToUnqualified
  */
-class Scope {
-    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
 
-        /**
-         * One of 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.
-         * @member {String} Scope#type
-         */
-        this.type = type;
+module.exports = class PnpPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {PnpApiImpl} pnpApi pnpApi
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, pnpApi, target) {
+		this.source = source;
+		this.pnpApi = pnpApi;
+		this.target = target;
+	}
 
-        /**
-         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name
-         * : Variable }</code>.
-         * @member {Map} Scope#set
-         */
-        this.set = new Map();
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("PnpPlugin", (request, resolveContext, callback) => {
+				const req = request.request;
+				if (!req) return callback();
 
-        /**
-         * The tainted variables of this scope, as <code>{ Variable.name :
-         * boolean }</code>.
-         * @member {Map} Scope#taints */
-        this.taints = new Map();
+				// The trailing slash indicates to PnP that this value is a folder rather than a file
+				const issuer = `${request.path}/`;
 
-        /**
-         * Generally, through the lexical scoping of JS you can always know
-         * which variable an identifier in the source code refers to. There are
-         * a few exceptions to this rule. With 'global' and 'with' scopes you
-         * can only decide at runtime which variable a reference refers to.
-         * Moreover, if 'eval()' is used in a scope, it might introduce new
-         * bindings in this or its parent scopes.
-         * All those scopes are considered 'dynamic'.
-         * @member {boolean} Scope#dynamic
-         */
-        this.dynamic = this.type === "global" || this.type === "with";
+				const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req);
+				if (!packageMatch) return callback();
 
-        /**
-         * A reference to the scope-defining syntax node.
-         * @member {espree.Node} Scope#block
-         */
-        this.block = block;
+				const packageName = packageMatch[0];
+				const innerRequest = `.${req.slice(packageName.length)}`;
 
-        /**
-         * The {@link Reference|references} that are not resolved with this scope.
-         * @member {Reference[]} Scope#through
-         */
-        this.through = [];
+				let resolution;
+				let apiResolution;
+				try {
+					resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, {
+						considerBuiltins: false
+					});
+					if (resolveContext.fileDependencies) {
+						apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, {
+							considerBuiltins: false
+						});
+					}
+				} catch (error) {
+					if (
+						error.code === "MODULE_NOT_FOUND" &&
+						error.pnpCode === "UNDECLARED_DEPENDENCY"
+					) {
+						// This is not a PnP managed dependency.
+						// Try to continue resolving with our alternatives
+						if (resolveContext.log) {
+							resolveContext.log(`request is not managed by the pnpapi`);
+							for (const line of error.message.split("\n").filter(Boolean))
+								resolveContext.log(`  ${line}`);
+						}
+						return callback();
+					}
+					return callback(error);
+				}
 
-        /**
-         * The scoped {@link Variable}s of this scope. In the case of a
-         * 'function' scope this includes the automatic argument <em>arguments</em> as
-         * its first element, as well as all further formal arguments.
-         * @member {Variable[]} Scope#variables
-         */
-        this.variables = [];
+				if (resolution === packageName) return callback();
 
-        /**
-         * Any variable {@link Reference|reference} found in this scope. This
-         * includes occurrences of local variables as well as variables from
-         * parent scopes (including the global scope). For local variables
-         * this also includes defining occurrences (like in a 'var' statement).
-         * In a 'function' scope this does not include the occurrences of the
-         * formal parameter in the parameter list.
-         * @member {Reference[]} Scope#references
-         */
-        this.references = [];
+				if (apiResolution && resolveContext.fileDependencies) {
+					resolveContext.fileDependencies.add(apiResolution);
+				}
 
-        /**
-         * For 'global' and 'function' scopes, this is a self-reference. For
-         * other scope types this is the <em>variableScope</em> value of the
-         * parent scope.
-         * @member {Scope} Scope#variableScope
-         */
-        this.variableScope =
-            (this.type === "global" || this.type === "function" || this.type === "module") ? this : upperScope.variableScope;
+				const obj = {
+					...request,
+					path: resolution,
+					request: innerRequest,
+					ignoreSymlinks: true,
+					fullySpecified: request.fullySpecified && innerRequest !== "."
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					`resolved by pnp to ${resolution}`,
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
+						if (result) return callback(null, result);
+						// Skip alternatives
+						return callback(null, null);
+					}
+				);
+			});
+	}
+};
 
-        /**
-         * Whether this scope is created by a FunctionExpression.
-         * @member {boolean} Scope#functionExpressionScope
-         */
-        this.functionExpressionScope = false;
 
-        /**
-         * Whether this is a scope that contains an 'eval()' invocation.
-         * @member {boolean} Scope#directCallToEvalScope
-         */
-        this.directCallToEvalScope = false;
+/***/ }),
 
-        /**
-         * @member {boolean} Scope#thisFound
-         */
-        this.thisFound = false;
+/***/ 37432:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        this.__left = [];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        /**
-         * Reference to the parent {@link Scope|scope}.
-         * @member {Scope} Scope#upper
-         */
-        this.upper = upperScope;
 
-        /**
-         * Whether 'use strict' is in effect in this scope.
-         * @member {boolean} Scope#isStrict
-         */
-        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());
 
-        /**
-         * List of nested {@link Scope}s.
-         * @member {Scope[]} Scope#childScopes
-         */
-        this.childScopes = [];
-        if (this.upper) {
-            this.upper.childScopes.push(this);
-        }
+const { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } = __webpack_require__(41242);
+const createInnerContext = __webpack_require__(95478);
+const { parseIdentifier } = __webpack_require__(7780);
+const {
+	normalize,
+	cachedJoin: join,
+	getType,
+	PathType
+} = __webpack_require__(3011);
 
-        this.__declaredVariables = scopeManager.__declaredVariables;
+/** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */
 
-        registerScope(scopeManager, this);
-    }
+/**
+ * @typedef {Object} FileSystemStats
+ * @property {function(): boolean} isDirectory
+ * @property {function(): boolean} isFile
+ */
 
-    __shouldStaticallyClose(scopeManager) {
-        return (!this.dynamic || scopeManager.__isOptimistic());
-    }
+/**
+ * @typedef {Object} FileSystemDirent
+ * @property {Buffer | string} name
+ * @property {function(): boolean} isDirectory
+ * @property {function(): boolean} isFile
+ */
 
-    __shouldStaticallyCloseForGlobal(ref) {
+/**
+ * @typedef {Object} PossibleFileSystemError
+ * @property {string=} code
+ * @property {number=} errno
+ * @property {string=} path
+ * @property {string=} syscall
+ */
 
-        // On global scope, let/const/class declarations should be resolved statically.
-        const name = ref.identifier.name;
+/**
+ * @template T
+ * @callback FileSystemCallback
+ * @param {PossibleFileSystemError & Error | null | undefined} err
+ * @param {T=} result
+ */
 
-        if (!this.set.has(name)) {
-            return false;
-        }
+/**
+ * @typedef {Object} FileSystem
+ * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readFile
+ * @property {(function(string, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void) & function(string, object, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void} readdir
+ * @property {((function(string, FileSystemCallback<object>): void) & function(string, object, FileSystemCallback<object>): void)=} readJson
+ * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readlink
+ * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void=} lstat
+ * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} stat
+ */
 
-        const variable = this.set.get(name);
-        const defs = variable.defs;
+/**
+ * @typedef {Object} SyncFileSystem
+ * @property {function(string, object=): Buffer | string} readFileSync
+ * @property {function(string, object=): (Buffer | string)[] | FileSystemDirent[]} readdirSync
+ * @property {(function(string, object=): object)=} readJsonSync
+ * @property {function(string, object=): Buffer | string} readlinkSync
+ * @property {function(string, object=): FileSystemStats=} lstatSync
+ * @property {function(string, object=): FileSystemStats} statSync
+ */
 
-        return defs.length > 0 && defs.every(shouldBeStatically);
-    }
+/**
+ * @typedef {Object} ParsedIdentifier
+ * @property {string} request
+ * @property {string} query
+ * @property {string} fragment
+ * @property {boolean} directory
+ * @property {boolean} module
+ * @property {boolean} file
+ * @property {boolean} internal
+ */
 
-    __staticCloseRef(ref) {
-        if (!this.__resolve(ref)) {
-            this.__delegateToUpperScope(ref);
-        }
-    }
+/**
+ * @typedef {Object} BaseResolveRequest
+ * @property {string | false} path
+ * @property {string=} descriptionFilePath
+ * @property {string=} descriptionFileRoot
+ * @property {object=} descriptionFileData
+ * @property {string=} relativePath
+ * @property {boolean=} ignoreSymlinks
+ * @property {boolean=} fullySpecified
+ */
 
-    __dynamicCloseRef(ref) {
+/** @typedef {BaseResolveRequest & Partial<ParsedIdentifier>} ResolveRequest */
 
-        // notify all names are through to global
-        let current = this;
+/**
+ * String with special formatting
+ * @typedef {string} StackEntry
+ */
 
-        do {
-            current.through.push(ref);
-            current = current.upper;
-        } while (current);
-    }
+/** @template T @typedef {{ add: (T) => void }} WriteOnlySet */
 
-    __globalCloseRef(ref) {
+/**
+ * Resolve context
+ * @typedef {Object} ResolveContext
+ * @property {WriteOnlySet<string>=} contextDependencies
+ * @property {WriteOnlySet<string>=} fileDependencies files that was found on file system
+ * @property {WriteOnlySet<string>=} missingDependencies dependencies that was not found on file system
+ * @property {Set<StackEntry>=} stack set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`,
+ * @property {(function(string): void)=} log log function
+ */
 
-        // let/const/class declarations should be resolved statically.
-        // others should be resolved dynamically.
-        if (this.__shouldStaticallyCloseForGlobal(ref)) {
-            this.__staticCloseRef(ref);
-        } else {
-            this.__dynamicCloseRef(ref);
-        }
-    }
+/** @typedef {AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest | null>} ResolveStepHook */
 
-    __close(scopeManager) {
-        let closeRef;
+/**
+ * @param {string} str input string
+ * @returns {string} in camel case
+ */
+function toCamelCase(str) {
+	return str.replace(/-([a-z])/g, str => str.substr(1).toUpperCase());
+}
 
-        if (this.__shouldStaticallyClose(scopeManager)) {
-            closeRef = this.__staticCloseRef;
-        } else if (this.type !== "global") {
-            closeRef = this.__dynamicCloseRef;
-        } else {
-            closeRef = this.__globalCloseRef;
-        }
+class Resolver {
+	/**
+	 * @param {ResolveStepHook} hook hook
+	 * @param {ResolveRequest} request request
+	 * @returns {StackEntry} stack entry
+	 */
+	static createStackEntry(hook, request) {
+		return (
+			hook.name +
+			": (" +
+			request.path +
+			") " +
+			(request.request || "") +
+			(request.query || "") +
+			(request.fragment || "") +
+			(request.directory ? " directory" : "") +
+			(request.module ? " module" : "")
+		);
+	}
 
-        // Try Resolving all references in this scope.
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
+	/**
+	 * @param {FileSystem} fileSystem a filesystem
+	 * @param {ResolveOptions} options options
+	 */
+	constructor(fileSystem, options) {
+		this.fileSystem = fileSystem;
+		this.options = options;
+		this.hooks = {
+			/** @type {SyncHook<[ResolveStepHook, ResolveRequest], void>} */
+			resolveStep: new SyncHook(["hook", "request"], "resolveStep"),
+			/** @type {SyncHook<[ResolveRequest, Error]>} */
+			noResolve: new SyncHook(["request", "error"], "noResolve"),
+			/** @type {ResolveStepHook} */
+			resolve: new AsyncSeriesBailHook(
+				["request", "resolveContext"],
+				"resolve"
+			),
+			/** @type {AsyncSeriesHook<[ResolveRequest, ResolveContext]>} */
+			result: new AsyncSeriesHook(["result", "resolveContext"], "result")
+		};
+	}
 
-            closeRef.call(this, ref);
-        }
-        this.__left = null;
+	/**
+	 * @param {string | ResolveStepHook} name hook name or hook itself
+	 * @returns {ResolveStepHook} the hook
+	 */
+	ensureHook(name) {
+		if (typeof name !== "string") {
+			return name;
+		}
+		name = toCamelCase(name);
+		if (/^before/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.ensureHook(
+				name[6].toLowerCase() + name.substr(7)
+			).withOptions({
+				stage: -10
+			}));
+		}
+		if (/^after/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.ensureHook(
+				name[5].toLowerCase() + name.substr(6)
+			).withOptions({
+				stage: 10
+			}));
+		}
+		const hook = this.hooks[name];
+		if (!hook) {
+			return (this.hooks[name] = new AsyncSeriesBailHook(
+				["request", "resolveContext"],
+				name
+			));
+		}
+		return hook;
+	}
 
-        return this.upper;
-    }
+	/**
+	 * @param {string | ResolveStepHook} name hook name or hook itself
+	 * @returns {ResolveStepHook} the hook
+	 */
+	getHook(name) {
+		if (typeof name !== "string") {
+			return name;
+		}
+		name = toCamelCase(name);
+		if (/^before/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.getHook(
+				name[6].toLowerCase() + name.substr(7)
+			).withOptions({
+				stage: -10
+			}));
+		}
+		if (/^after/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.getHook(
+				name[5].toLowerCase() + name.substr(6)
+			).withOptions({
+				stage: 10
+			}));
+		}
+		const hook = this.hooks[name];
+		if (!hook) {
+			throw new Error(`Hook ${name} doesn't exist`);
+		}
+		return hook;
+	}
 
-    // To override by function scopes.
-    // References in default parameters isn't resolved to variables which are in their function body.
-    __isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars
-        return true;
-    }
+	/**
+	 * @param {object} context context information object
+	 * @param {string} path context path
+	 * @param {string} request request string
+	 * @returns {string | false} result
+	 */
+	resolveSync(context, path, request) {
+		/** @type {Error | null | undefined} */
+		let err = undefined;
+		/** @type {string | false | undefined} */
+		let result = undefined;
+		let sync = false;
+		this.resolve(context, path, request, {}, (e, r) => {
+			err = e;
+			result = r;
+			sync = true;
+		});
+		if (!sync) {
+			throw new Error(
+				"Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!"
+			);
+		}
+		if (err) throw err;
+		if (result === undefined) throw new Error("No result");
+		return result;
+	}
 
-    __resolve(ref) {
-        const name = ref.identifier.name;
+	/**
+	 * @param {object} context context information object
+	 * @param {string} path context path
+	 * @param {string} request request string
+	 * @param {ResolveContext} resolveContext resolve context
+	 * @param {function(Error | null, (string|false)=, ResolveRequest=): void} callback callback function
+	 * @returns {void}
+	 */
+	resolve(context, path, request, resolveContext, callback) {
+		if (!context || typeof context !== "object")
+			return callback(new Error("context argument is not an object"));
+		if (typeof path !== "string")
+			return callback(new Error("path argument is not a string"));
+		if (typeof request !== "string")
+			return callback(new Error("path argument is not a string"));
+		if (!resolveContext)
+			return callback(new Error("resolveContext argument is not set"));
 
-        if (!this.set.has(name)) {
-            return false;
-        }
-        const variable = this.set.get(name);
+		const obj = {
+			context: context,
+			path: path,
+			request: request
+		};
 
-        if (!this.__isValidResolution(ref, variable)) {
-            return false;
-        }
-        variable.references.push(ref);
-        variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
-        if (ref.tainted) {
-            variable.tainted = true;
-            this.taints.set(variable.name, true);
-        }
-        ref.resolved = variable;
+		const message = `resolve '${request}' in '${path}'`;
 
-        return true;
-    }
+		const finishResolved = result => {
+			return callback(
+				null,
+				result.path === false
+					? false
+					: `${result.path.replace(/#/g, "\0#")}${
+							result.query ? result.query.replace(/#/g, "\0#") : ""
+					  }${result.fragment || ""}`,
+				result
+			);
+		};
 
-    __delegateToUpperScope(ref) {
-        if (this.upper) {
-            this.upper.__left.push(ref);
-        }
-        this.through.push(ref);
-    }
+		const finishWithoutResolve = log => {
+			/**
+			 * @type {Error & {details?: string}}
+			 */
+			const error = new Error("Can't " + message);
+			error.details = log.join("\n");
+			this.hooks.noResolve.call(obj, error);
+			return callback(error);
+		};
 
-    __addDeclaredVariablesOfNode(variable, node) {
-        if (node === null || node === undefined) {
-            return;
-        }
+		if (resolveContext.log) {
+			// We need log anyway to capture it in case of an error
+			const parentLog = resolveContext.log;
+			const log = [];
+			return this.doResolve(
+				this.hooks.resolve,
+				obj,
+				message,
+				{
+					log: msg => {
+						parentLog(msg);
+						log.push(msg);
+					},
+					fileDependencies: resolveContext.fileDependencies,
+					contextDependencies: resolveContext.contextDependencies,
+					missingDependencies: resolveContext.missingDependencies,
+					stack: resolveContext.stack
+				},
+				(err, result) => {
+					if (err) return callback(err);
 
-        let variables = this.__declaredVariables.get(node);
+					if (result) return finishResolved(result);
 
-        if (variables === null || variables === undefined) {
-            variables = [];
-            this.__declaredVariables.set(node, variables);
-        }
-        if (variables.indexOf(variable) === -1) {
-            variables.push(variable);
-        }
-    }
+					return finishWithoutResolve(log);
+				}
+			);
+		} else {
+			// Try to resolve assuming there is no error
+			// We don't log stuff in this case
+			return this.doResolve(
+				this.hooks.resolve,
+				obj,
+				message,
+				{
+					log: undefined,
+					fileDependencies: resolveContext.fileDependencies,
+					contextDependencies: resolveContext.contextDependencies,
+					missingDependencies: resolveContext.missingDependencies,
+					stack: resolveContext.stack
+				},
+				(err, result) => {
+					if (err) return callback(err);
 
-    __defineGeneric(name, set, variables, node, def) {
-        let variable;
+					if (result) return finishResolved(result);
 
-        variable = set.get(name);
-        if (!variable) {
-            variable = new Variable(name, this);
-            set.set(name, variable);
-            variables.push(variable);
-        }
+					// log is missing for the error details
+					// so we redo the resolving for the log info
+					// this is more expensive to the success case
+					// is assumed by default
 
-        if (def) {
-            variable.defs.push(def);
-            this.__addDeclaredVariablesOfNode(variable, def.node);
-            this.__addDeclaredVariablesOfNode(variable, def.parent);
-        }
-        if (node) {
-            variable.identifiers.push(node);
-        }
-    }
+					const log = [];
 
-    __define(node, def) {
-        if (node && node.type === Syntax.Identifier) {
-            this.__defineGeneric(
-                node.name,
-                this.set,
-                this.variables,
-                node,
-                def
-            );
-        }
-    }
+					return this.doResolve(
+						this.hooks.resolve,
+						obj,
+						message,
+						{
+							log: msg => log.push(msg),
+							stack: resolveContext.stack
+						},
+						(err, result) => {
+							if (err) return callback(err);
 
-    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
+							return finishWithoutResolve(log);
+						}
+					);
+				}
+			);
+		}
+	}
 
-        // because Array element may be null
-        if (!node || node.type !== Syntax.Identifier) {
-            return;
-        }
+	doResolve(hook, request, message, resolveContext, callback) {
+		const stackEntry = Resolver.createStackEntry(hook, request);
 
-        // Specially handle like `this`.
-        if (node.name === "super") {
-            return;
-        }
+		let newStack;
+		if (resolveContext.stack) {
+			newStack = new Set(resolveContext.stack);
+			if (resolveContext.stack.has(stackEntry)) {
+				/**
+				 * Prevent recursion
+				 * @type {Error & {recursion?: boolean}}
+				 */
+				const recursionError = new Error(
+					"Recursion in resolving\nStack:\n  " +
+						Array.from(newStack).join("\n  ")
+				);
+				recursionError.recursion = true;
+				if (resolveContext.log)
+					resolveContext.log("abort resolving because of recursion");
+				return callback(recursionError);
+			}
+			newStack.add(stackEntry);
+		} else {
+			newStack = new Set([stackEntry]);
+		}
+		this.hooks.resolveStep.call(hook, request);
 
-        const ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
+		if (hook.isUsed()) {
+			const innerContext = createInnerContext(
+				{
+					log: resolveContext.log,
+					fileDependencies: resolveContext.fileDependencies,
+					contextDependencies: resolveContext.contextDependencies,
+					missingDependencies: resolveContext.missingDependencies,
+					stack: newStack
+				},
+				message
+			);
+			return hook.callAsync(request, innerContext, (err, result) => {
+				if (err) return callback(err);
+				if (result) return callback(null, result);
+				callback();
+			});
+		} else {
+			callback();
+		}
+	}
 
-        this.references.push(ref);
-        this.__left.push(ref);
-    }
+	/**
+	 * @param {string} identifier identifier
+	 * @returns {ParsedIdentifier} parsed identifier
+	 */
+	parse(identifier) {
+		const part = {
+			request: "",
+			query: "",
+			fragment: "",
+			module: false,
+			directory: false,
+			file: false,
+			internal: false
+		};
 
-    __detectEval() {
-        let current = this;
+		const parsedIdentifier = parseIdentifier(identifier);
 
-        this.directCallToEvalScope = true;
-        do {
-            current.dynamic = true;
-            current = current.upper;
-        } while (current);
-    }
+		if (!parsedIdentifier) return part;
 
-    __detectThis() {
-        this.thisFound = true;
-    }
+		[part.request, part.query, part.fragment] = parsedIdentifier;
 
-    __isClosed() {
-        return this.__left === null;
-    }
+		if (part.request.length > 0) {
+			part.internal = this.isPrivate(identifier);
+			part.module = this.isModule(part.request);
+			part.directory = this.isDirectory(part.request);
+			if (part.directory) {
+				part.request = part.request.substr(0, part.request.length - 1);
+			}
+		}
 
-    /**
-     * returns resolved {Reference}
-     * @method Scope#resolve
-     * @param {Espree.Identifier} ident - identifier to be resolved.
-     * @returns {Reference} reference
-     */
-    resolve(ident) {
-        let ref, i, iz;
+		return part;
+	}
 
-        assert(this.__isClosed(), "Scope should be closed.");
-        assert(ident.type === Syntax.Identifier, "Target should be identifier.");
-        for (i = 0, iz = this.references.length; i < iz; ++i) {
-            ref = this.references[i];
-            if (ref.identifier === ident) {
-                return ref;
-            }
-        }
-        return null;
-    }
+	isModule(path) {
+		return getType(path) === PathType.Normal;
+	}
 
-    /**
-     * returns this scope is static
-     * @method Scope#isStatic
-     * @returns {boolean} static
-     */
-    isStatic() {
-        return !this.dynamic;
-    }
+	isPrivate(path) {
+		return getType(path) === PathType.Internal;
+	}
 
-    /**
-     * returns this scope has materialized arguments
-     * @method Scope#isArgumentsMaterialized
-     * @returns {boolean} arguemnts materialized
-     */
-    isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this
-        return true;
-    }
+	/**
+	 * @param {string} path a path
+	 * @returns {boolean} true, if the path is a directory path
+	 */
+	isDirectory(path) {
+		return path.endsWith("/");
+	}
 
-    /**
-     * returns this scope has materialized `this` reference
-     * @method Scope#isThisMaterialized
-     * @returns {boolean} this materialized
-     */
-    isThisMaterialized() { // eslint-disable-line class-methods-use-this
-        return true;
-    }
+	join(path, request) {
+		return join(path, request);
+	}
 
-    isUsedName(name) {
-        if (this.set.has(name)) {
-            return true;
-        }
-        for (let i = 0, iz = this.through.length; i < iz; ++i) {
-            if (this.through[i].identifier.name === name) {
-                return true;
-            }
-        }
-        return false;
-    }
+	normalize(path) {
+		return normalize(path);
+	}
 }
 
-class GlobalScope extends Scope {
-    constructor(scopeManager, block) {
-        super(scopeManager, "global", null, block, false);
-        this.implicit = {
-            set: new Map(),
-            variables: [],
-
-            /**
-            * List of {@link Reference}s that are left to be resolved (i.e. which
-            * need to be linked to the variable they refer to).
-            * @member {Reference[]} Scope#implicit#left
-            */
-            left: []
-        };
-    }
+module.exports = Resolver;
 
-    __close(scopeManager) {
-        const implicit = [];
 
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
+/***/ }),
 
-            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
-                implicit.push(ref.__maybeImplicitGlobal);
-            }
-        }
+/***/ 53990:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-        // create an implicit global variable from assignment expression
-        for (let i = 0, iz = implicit.length; i < iz; ++i) {
-            const info = implicit[i];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-            this.__defineImplicit(info.pattern,
-                new Definition(
-                    Variable.ImplicitGlobalVariable,
-                    info.pattern,
-                    info.node,
-                    null,
-                    null,
-                    null
-                ));
 
-        }
 
-        this.implicit.left = this.__left;
+const versions = (__webpack_require__(77282).versions);
+const Resolver = __webpack_require__(37432);
+const { getType, PathType } = __webpack_require__(3011);
+
+const SyncAsyncFileSystemDecorator = __webpack_require__(57746);
+
+const AliasFieldPlugin = __webpack_require__(42752);
+const AliasPlugin = __webpack_require__(51547);
+const AppendPlugin = __webpack_require__(66477);
+const ConditionalPlugin = __webpack_require__(44193);
+const DescriptionFilePlugin = __webpack_require__(66826);
+const DirectoryExistsPlugin = __webpack_require__(73688);
+const ExportsFieldPlugin = __webpack_require__(80163);
+const FileExistsPlugin = __webpack_require__(98699);
+const ImportsFieldPlugin = __webpack_require__(86058);
+const JoinRequestPartPlugin = __webpack_require__(20879);
+const JoinRequestPlugin = __webpack_require__(71474);
+const MainFieldPlugin = __webpack_require__(73507);
+const ModulesInHierachicDirectoriesPlugin = __webpack_require__(3688);
+const ModulesInRootPlugin = __webpack_require__(48952);
+const NextPlugin = __webpack_require__(79135);
+const ParsePlugin = __webpack_require__(15234);
+const PnpPlugin = __webpack_require__(71488);
+const RestrictionsPlugin = __webpack_require__(39222);
+const ResultPlugin = __webpack_require__(10615);
+const RootsPlugin = __webpack_require__(34403);
+const SelfReferencePlugin = __webpack_require__(32317);
+const SymlinkPlugin = __webpack_require__(21300);
+const TryNextPlugin = __webpack_require__(16442);
+const UnsafeCachePlugin = __webpack_require__(3501);
+const UseFilePlugin = __webpack_require__(50318);
 
-        return super.__close(scopeManager);
-    }
+/** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */
+/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
 
-    __defineImplicit(node, def) {
-        if (node && node.type === Syntax.Identifier) {
-            this.__defineGeneric(
-                node.name,
-                this.implicit.set,
-                this.implicit.variables,
-                node,
-                def
-            );
-        }
-    }
-}
+/** @typedef {string|string[]|false} AliasOptionNewRequest */
+/** @typedef {{[k: string]: AliasOptionNewRequest}} AliasOptions */
+/** @typedef {{apply: function(Resolver): void} | function(this: Resolver, Resolver): void} Plugin */
 
-class ModuleScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "module", upperScope, block, false);
-    }
-}
+/**
+ * @typedef {Object} UserResolveOptions
+ * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value
+ * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option
+ * @property {(string | string[])[]=} aliasFields A list of alias fields in description files
+ * @property {(function(ResolveRequest): boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
+ * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key.
+ * @property {string[]=} descriptionFiles A list of description files to read from
+ * @property {string[]=} conditionNames A list of exports field condition names.
+ * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used
+ * @property {(string | string[])[]=} exportsFields A list of exports fields in description files
+ * @property {(string | string[])[]=} importsFields A list of imports fields in description files
+ * @property {string[]=} extensions A list of extensions which should be tried for files
+ * @property {FileSystem} fileSystem The file system which should be used
+ * @property {(object | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests
+ * @property {boolean=} symlinks Resolve symlinks to their symlinked location
+ * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached
+ * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name
+ * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files
+ * @property {string[]=} mainFiles  A list of main files in directories
+ * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied
+ * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto"
+ * @property {string[]=} roots A list of root paths
+ * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it
+ * @property {boolean=} resolveToContext Resolve to a context instead of a file
+ * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions
+ * @property {boolean=} useSyncFileSystemCalls Use only the sync constiants of the file system calls
+ * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules
+ * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
+ */
 
-class FunctionExpressionNameScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "function-expression-name", upperScope, block, false);
-        this.__define(block.id,
-            new Definition(
-                Variable.FunctionName,
-                block.id,
-                block,
-                null,
-                null,
-                null
-            ));
-        this.functionExpressionScope = true;
-    }
-}
-
-class CatchScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "catch", upperScope, block, false);
-    }
-}
+/**
+ * @typedef {Object} ResolveOptions
+ * @property {AliasOptionEntry[]} alias
+ * @property {AliasOptionEntry[]} fallback
+ * @property {Set<string | string[]>} aliasFields
+ * @property {(function(ResolveRequest): boolean)} cachePredicate
+ * @property {boolean} cacheWithContext
+ * @property {Set<string>} conditionNames A list of exports field condition names.
+ * @property {string[]} descriptionFiles
+ * @property {boolean} enforceExtension
+ * @property {Set<string | string[]>} exportsFields
+ * @property {Set<string | string[]>} importsFields
+ * @property {Set<string>} extensions
+ * @property {FileSystem} fileSystem
+ * @property {object | false} unsafeCache
+ * @property {boolean} symlinks
+ * @property {Resolver=} resolver
+ * @property {Array<string | string[]>} modules
+ * @property {{name: string[], forceRelative: boolean}[]} mainFields
+ * @property {Set<string>} mainFiles
+ * @property {Plugin[]} plugins
+ * @property {PnpApi | null} pnpApi
+ * @property {Set<string>} roots
+ * @property {boolean} fullySpecified
+ * @property {boolean} resolveToContext
+ * @property {Set<string|RegExp>} restrictions
+ * @property {boolean} preferRelative
+ * @property {boolean} preferAbsolute
+ */
 
-class WithScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "with", upperScope, block, false);
-    }
+/**
+ * @param {PnpApi | null=} option option
+ * @returns {PnpApi | null} processed option
+ */
+function processPnpApiOption(option) {
+	if (
+		option === undefined &&
+		/** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp
+	) {
+		// @ts-ignore
+		return __webpack_require__(35125); // eslint-disable-line node/no-missing-require
+	}
 
-    __close(scopeManager) {
-        if (this.__shouldStaticallyClose(scopeManager)) {
-            return super.__close(scopeManager);
-        }
+	return option || null;
+}
 
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
+/**
+ * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias
+ * @returns {AliasOptionEntry[]} normalized aliases
+ */
+function normalizeAlias(alias) {
+	return typeof alias === "object" && !Array.isArray(alias) && alias !== null
+		? Object.keys(alias).map(key => {
+				/** @type {AliasOptionEntry} */
+				const obj = { name: key, onlyModule: false, alias: alias[key] };
 
-            ref.tainted = true;
-            this.__delegateToUpperScope(ref);
-        }
-        this.__left = null;
+				if (/\$$/.test(key)) {
+					obj.onlyModule = true;
+					obj.name = key.substr(0, key.length - 1);
+				}
 
-        return this.upper;
-    }
+				return obj;
+		  })
+		: /** @type {Array<AliasOptionEntry>} */ (alias) || [];
 }
 
-class BlockScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "block", upperScope, block, false);
-    }
-}
+/**
+ * @param {UserResolveOptions} options input options
+ * @returns {ResolveOptions} output options
+ */
+function createOptions(options) {
+	const mainFieldsSet = new Set(options.mainFields || ["main"]);
+	const mainFields = [];
 
-class SwitchScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "switch", upperScope, block, false);
-    }
+	for (const item of mainFieldsSet) {
+		if (typeof item === "string") {
+			mainFields.push({
+				name: [item],
+				forceRelative: true
+			});
+		} else if (Array.isArray(item)) {
+			mainFields.push({
+				name: item,
+				forceRelative: true
+			});
+		} else {
+			mainFields.push({
+				name: Array.isArray(item.name) ? item.name : [item.name],
+				forceRelative: item.forceRelative
+			});
+		}
+	}
+
+	return {
+		alias: normalizeAlias(options.alias),
+		fallback: normalizeAlias(options.fallback),
+		aliasFields: new Set(options.aliasFields),
+		cachePredicate:
+			options.cachePredicate ||
+			function () {
+				return true;
+			},
+		cacheWithContext:
+			typeof options.cacheWithContext !== "undefined"
+				? options.cacheWithContext
+				: true,
+		exportsFields: new Set(options.exportsFields || ["exports"]),
+		importsFields: new Set(options.importsFields || ["imports"]),
+		conditionNames: new Set(options.conditionNames),
+		descriptionFiles: Array.from(
+			new Set(options.descriptionFiles || ["package.json"])
+		),
+		enforceExtension:
+			options.enforceExtension === undefined
+				? options.extensions && options.extensions.includes("")
+					? true
+					: false
+				: options.enforceExtension,
+		extensions: new Set(options.extensions || [".js", ".json", ".node"]),
+		fileSystem: options.useSyncFileSystemCalls
+			? new SyncAsyncFileSystemDecorator(
+					/** @type {SyncFileSystem} */ (
+						/** @type {unknown} */ (options.fileSystem)
+					)
+			  )
+			: options.fileSystem,
+		unsafeCache:
+			options.unsafeCache && typeof options.unsafeCache !== "object"
+				? {}
+				: options.unsafeCache || false,
+		symlinks: typeof options.symlinks !== "undefined" ? options.symlinks : true,
+		resolver: options.resolver,
+		modules: mergeFilteredToArray(
+			Array.isArray(options.modules)
+				? options.modules
+				: options.modules
+				? [options.modules]
+				: ["node_modules"],
+			item => {
+				const type = getType(item);
+				return type === PathType.Normal || type === PathType.Relative;
+			}
+		),
+		mainFields,
+		mainFiles: new Set(options.mainFiles || ["index"]),
+		plugins: options.plugins || [],
+		pnpApi: processPnpApiOption(options.pnpApi),
+		roots: new Set(options.roots || undefined),
+		fullySpecified: options.fullySpecified || false,
+		resolveToContext: options.resolveToContext || false,
+		preferRelative: options.preferRelative || false,
+		preferAbsolute: options.preferAbsolute || false,
+		restrictions: new Set(options.restrictions)
+	};
 }
 
-class FunctionScope extends Scope {
-    constructor(scopeManager, upperScope, block, isMethodDefinition) {
-        super(scopeManager, "function", upperScope, block, isMethodDefinition);
+/**
+ * @param {UserResolveOptions} options resolve options
+ * @returns {Resolver} created resolver
+ */
+exports.createResolver = function (options) {
+	const normalizedOptions = createOptions(options);
 
-        // section 9.2.13, FunctionDeclarationInstantiation.
-        // NOTE Arrow functions never have an arguments objects.
-        if (this.block.type !== Syntax.ArrowFunctionExpression) {
-            this.__defineArguments();
-        }
-    }
+	const {
+		alias,
+		fallback,
+		aliasFields,
+		cachePredicate,
+		cacheWithContext,
+		conditionNames,
+		descriptionFiles,
+		enforceExtension,
+		exportsFields,
+		importsFields,
+		extensions,
+		fileSystem,
+		fullySpecified,
+		mainFields,
+		mainFiles,
+		modules,
+		plugins: userPlugins,
+		pnpApi,
+		resolveToContext,
+		preferRelative,
+		preferAbsolute,
+		symlinks,
+		unsafeCache,
+		resolver: customResolver,
+		restrictions,
+		roots
+	} = normalizedOptions;
 
-    isArgumentsMaterialized() {
+	const plugins = userPlugins.slice();
 
-        // TODO(Constellation)
-        // We can more aggressive on this condition like this.
-        //
-        // function t() {
-        //     // arguments of t is always hidden.
-        //     function arguments() {
-        //     }
-        // }
-        if (this.block.type === Syntax.ArrowFunctionExpression) {
-            return false;
-        }
+	const resolver = customResolver
+		? customResolver
+		: new Resolver(fileSystem, normalizedOptions);
 
-        if (!this.isStatic()) {
-            return true;
-        }
+	//// pipeline ////
 
-        const variable = this.set.get("arguments");
+	resolver.ensureHook("resolve");
+	resolver.ensureHook("internalResolve");
+	resolver.ensureHook("newInteralResolve");
+	resolver.ensureHook("parsedResolve");
+	resolver.ensureHook("describedResolve");
+	resolver.ensureHook("internal");
+	resolver.ensureHook("rawModule");
+	resolver.ensureHook("module");
+	resolver.ensureHook("resolveAsModule");
+	resolver.ensureHook("undescribedResolveInPackage");
+	resolver.ensureHook("resolveInPackage");
+	resolver.ensureHook("resolveInExistingDirectory");
+	resolver.ensureHook("relative");
+	resolver.ensureHook("describedRelative");
+	resolver.ensureHook("directory");
+	resolver.ensureHook("undescribedExistingDirectory");
+	resolver.ensureHook("existingDirectory");
+	resolver.ensureHook("undescribedRawFile");
+	resolver.ensureHook("rawFile");
+	resolver.ensureHook("file");
+	resolver.ensureHook("finalFile");
+	resolver.ensureHook("existingFile");
+	resolver.ensureHook("resolved");
 
-        assert(variable, "Always have arguments variable.");
-        return variable.tainted || variable.references.length !== 0;
-    }
+	// resolve
+	for (const { source, resolveOptions } of [
+		{ source: "resolve", resolveOptions: { fullySpecified } },
+		{ source: "internal-resolve", resolveOptions: { fullySpecified: false } }
+	]) {
+		if (unsafeCache) {
+			plugins.push(
+				new UnsafeCachePlugin(
+					source,
+					cachePredicate,
+					unsafeCache,
+					cacheWithContext,
+					`new-${source}`
+				)
+			);
+			plugins.push(
+				new ParsePlugin(`new-${source}`, resolveOptions, "parsed-resolve")
+			);
+		} else {
+			plugins.push(new ParsePlugin(source, resolveOptions, "parsed-resolve"));
+		}
+	}
 
-    isThisMaterialized() {
-        if (!this.isStatic()) {
-            return true;
-        }
-        return this.thisFound;
-    }
+	// parsed-resolve
+	plugins.push(
+		new DescriptionFilePlugin(
+			"parsed-resolve",
+			descriptionFiles,
+			false,
+			"described-resolve"
+		)
+	);
+	plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve"));
 
-    __defineArguments() {
-        this.__defineGeneric(
-            "arguments",
-            this.set,
-            this.variables,
-            null,
-            null
-        );
-        this.taints.set("arguments", true);
-    }
+	// described-resolve
+	plugins.push(new NextPlugin("described-resolve", "normal-resolve"));
+	if (fallback.length > 0) {
+		plugins.push(
+			new AliasPlugin("described-resolve", fallback, "internal-resolve")
+		);
+	}
 
-    // References in default parameters isn't resolved to variables which are in their function body.
-    //     const x = 1
-    //     function f(a = x) { // This `x` is resolved to the `x` in the outer scope.
-    //         const x = 2
-    //         console.log(a)
-    //     }
-    __isValidResolution(ref, variable) {
+	// normal-resolve
+	if (alias.length > 0)
+		plugins.push(new AliasPlugin("normal-resolve", alias, "internal-resolve"));
+	aliasFields.forEach(item => {
+		plugins.push(
+			new AliasFieldPlugin("normal-resolve", item, "internal-resolve")
+		);
+	});
+	if (preferRelative) {
+		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+	}
+	plugins.push(
+		new ConditionalPlugin(
+			"after-normal-resolve",
+			{ module: true },
+			"resolve as module",
+			false,
+			"raw-module"
+		)
+	);
+	plugins.push(
+		new ConditionalPlugin(
+			"after-normal-resolve",
+			{ internal: true },
+			"resolve as internal import",
+			false,
+			"internal"
+		)
+	);
+	if (preferAbsolute) {
+		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+	}
+	if (roots.size > 0) {
+		plugins.push(new RootsPlugin("after-normal-resolve", roots, "relative"));
+	}
+	if (!preferRelative && !preferAbsolute) {
+		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+	}
 
-        // If `options.nodejsScope` is true, `this.block` becomes a Program node.
-        if (this.block.type === "Program") {
-            return true;
-        }
+	// internal
+	importsFields.forEach(importsField => {
+		plugins.push(
+			new ImportsFieldPlugin(
+				"internal",
+				conditionNames,
+				importsField,
+				"relative",
+				"internal-resolve"
+			)
+		);
+	});
 
-        const bodyStart = this.block.body.range[0];
+	// raw-module
+	exportsFields.forEach(exportsField => {
+		plugins.push(
+			new SelfReferencePlugin("raw-module", exportsField, "resolve-as-module")
+		);
+	});
+	modules.forEach(item => {
+		if (Array.isArray(item)) {
+			if (item.includes("node_modules") && pnpApi) {
+				plugins.push(
+					new ModulesInHierachicDirectoriesPlugin(
+						"raw-module",
+						item.filter(i => i !== "node_modules"),
+						"module"
+					)
+				);
+				plugins.push(
+					new PnpPlugin("raw-module", pnpApi, "undescribed-resolve-in-package")
+				);
+			} else {
+				plugins.push(
+					new ModulesInHierachicDirectoriesPlugin("raw-module", item, "module")
+				);
+			}
+		} else {
+			plugins.push(new ModulesInRootPlugin("raw-module", item, "module"));
+		}
+	});
 
-        // It's invalid resolution in the following case:
-        return !(
-            variable.scope === this &&
-            ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.
-            variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.
-        );
-    }
-}
+	// module
+	plugins.push(new JoinRequestPartPlugin("module", "resolve-as-module"));
 
-class ForScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "for", upperScope, block, false);
-    }
-}
+	// resolve-as-module
+	if (!resolveToContext) {
+		plugins.push(
+			new ConditionalPlugin(
+				"resolve-as-module",
+				{ directory: false, request: "." },
+				"single file module",
+				true,
+				"undescribed-raw-file"
+			)
+		);
+	}
+	plugins.push(
+		new DirectoryExistsPlugin(
+			"resolve-as-module",
+			"undescribed-resolve-in-package"
+		)
+	);
 
-class ClassScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "class", upperScope, block, false);
-    }
-}
+	// undescribed-resolve-in-package
+	plugins.push(
+		new DescriptionFilePlugin(
+			"undescribed-resolve-in-package",
+			descriptionFiles,
+			false,
+			"resolve-in-package"
+		)
+	);
+	plugins.push(
+		new NextPlugin("after-undescribed-resolve-in-package", "resolve-in-package")
+	);
 
-module.exports = {
-    Scope,
-    GlobalScope,
-    ModuleScope,
-    FunctionExpressionNameScope,
-    CatchScope,
-    WithScope,
-    BlockScope,
-    SwitchScope,
-    FunctionScope,
-    ForScope,
-    ClassScope
-};
+	// resolve-in-package
+	exportsFields.forEach(exportsField => {
+		plugins.push(
+			new ExportsFieldPlugin(
+				"resolve-in-package",
+				conditionNames,
+				exportsField,
+				"relative"
+			)
+		);
+	});
+	plugins.push(
+		new NextPlugin("resolve-in-package", "resolve-in-existing-directory")
+	);
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+	// resolve-in-existing-directory
+	plugins.push(
+		new JoinRequestPlugin("resolve-in-existing-directory", "relative")
+	);
 
+	// relative
+	plugins.push(
+		new DescriptionFilePlugin(
+			"relative",
+			descriptionFiles,
+			true,
+			"described-relative"
+		)
+	);
+	plugins.push(new NextPlugin("after-relative", "described-relative"));
 
-/***/ }),
-
-/***/ 82971:
-/***/ (function(module) {
-
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+	// described-relative
+	if (resolveToContext) {
+		plugins.push(new NextPlugin("described-relative", "directory"));
+	} else {
+		plugins.push(
+			new ConditionalPlugin(
+				"described-relative",
+				{ directory: false },
+				null,
+				true,
+				"raw-file"
+			)
+		);
+		plugins.push(
+			new ConditionalPlugin(
+				"described-relative",
+				{ fullySpecified: false },
+				"as directory",
+				true,
+				"directory"
+			)
+		);
+	}
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+	// directory
+	plugins.push(
+		new DirectoryExistsPlugin("directory", "undescribed-existing-directory")
+	);
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+	if (resolveToContext) {
+		// undescribed-existing-directory
+		plugins.push(new NextPlugin("undescribed-existing-directory", "resolved"));
+	} else {
+		// undescribed-existing-directory
+		plugins.push(
+			new DescriptionFilePlugin(
+				"undescribed-existing-directory",
+				descriptionFiles,
+				false,
+				"existing-directory"
+			)
+		);
+		mainFiles.forEach(item => {
+			plugins.push(
+				new UseFilePlugin(
+					"undescribed-existing-directory",
+					item,
+					"undescribed-raw-file"
+				)
+			);
+		});
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+		// described-existing-directory
+		mainFields.forEach(item => {
+			plugins.push(
+				new MainFieldPlugin(
+					"existing-directory",
+					item,
+					"resolve-in-existing-directory"
+				)
+			);
+		});
+		mainFiles.forEach(item => {
+			plugins.push(
+				new UseFilePlugin("existing-directory", item, "undescribed-raw-file")
+			);
+		});
 
+		// undescribed-raw-file
+		plugins.push(
+			new DescriptionFilePlugin(
+				"undescribed-raw-file",
+				descriptionFiles,
+				true,
+				"raw-file"
+			)
+		);
+		plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file"));
 
-/**
- * A Variable represents a locally scoped identifier. These include arguments to
- * functions.
- * @class Variable
- */
-class Variable {
-    constructor(name, scope) {
+		// raw-file
+		plugins.push(
+			new ConditionalPlugin(
+				"raw-file",
+				{ fullySpecified: true },
+				null,
+				false,
+				"file"
+			)
+		);
+		if (!enforceExtension) {
+			plugins.push(new TryNextPlugin("raw-file", "no extension", "file"));
+		}
+		extensions.forEach(item => {
+			plugins.push(new AppendPlugin("raw-file", item, "file"));
+		});
 
-        /**
-         * The variable name, as given in the source code.
-         * @member {String} Variable#name
-         */
-        this.name = name;
+		// file
+		if (alias.length > 0)
+			plugins.push(new AliasPlugin("file", alias, "internal-resolve"));
+		aliasFields.forEach(item => {
+			plugins.push(new AliasFieldPlugin("file", item, "internal-resolve"));
+		});
+		plugins.push(new NextPlugin("file", "final-file"));
 
-        /**
-         * List of defining occurrences of this variable (like in 'var ...'
-         * statements or as parameter), as AST nodes.
-         * @member {espree.Identifier[]} Variable#identifiers
-         */
-        this.identifiers = [];
+		// final-file
+		plugins.push(new FileExistsPlugin("final-file", "existing-file"));
 
-        /**
-         * List of {@link Reference|references} of this variable (excluding parameter entries)
-         * in its defining scope and all nested scopes. For defining
-         * occurrences only see {@link Variable#defs}.
-         * @member {Reference[]} Variable#references
-         */
-        this.references = [];
+		// existing-file
+		if (symlinks)
+			plugins.push(new SymlinkPlugin("existing-file", "existing-file"));
+		plugins.push(new NextPlugin("existing-file", "resolved"));
+	}
 
-        /**
-         * List of defining occurrences of this variable (like in 'var ...'
-         * statements or as parameter), as custom objects.
-         * @member {Definition[]} Variable#defs
-         */
-        this.defs = [];
+	// resolved
+	if (restrictions.size > 0) {
+		plugins.push(new RestrictionsPlugin(resolver.hooks.resolved, restrictions));
+	}
+	plugins.push(new ResultPlugin(resolver.hooks.resolved));
 
-        this.tainted = false;
+	//// RESOLVER ////
 
-        /**
-         * Whether this is a stack variable.
-         * @member {boolean} Variable#stack
-         */
-        this.stack = true;
+	for (const plugin of plugins) {
+		if (typeof plugin === "function") {
+			plugin.call(resolver, resolver);
+		} else {
+			plugin.apply(resolver);
+		}
+	}
 
-        /**
-         * Reference to the enclosing Scope.
-         * @member {Scope} Variable#scope
-         */
-        this.scope = scope;
-    }
-}
+	return resolver;
+};
 
-Variable.CatchClause = "CatchClause";
-Variable.Parameter = "Parameter";
-Variable.FunctionName = "FunctionName";
-Variable.ClassName = "ClassName";
-Variable.Variable = "Variable";
-Variable.ImportBinding = "ImportBinding";
-Variable.ImplicitGlobalVariable = "ImplicitGlobalVariable";
+/**
+ * Merging filtered elements
+ * @param {string[]} array source array
+ * @param {function(string): boolean} filter predicate
+ * @returns {Array<string | string[]>} merge result
+ */
+function mergeFilteredToArray(array, filter) {
+	/** @type {Array<string | string[]>} */
+	const result = [];
+	const set = new Set(array);
 
-module.exports = Variable;
+	for (const item of set) {
+		if (filter(item)) {
+			const lastElement =
+				result.length > 0 ? result[result.length - 1] : undefined;
+			if (Array.isArray(lastElement)) {
+				lastElement.push(item);
+			} else {
+				result.push([item]);
+			}
+		} else {
+			result.push(item);
+		}
+	}
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+	return result;
+}
 
 
 /***/ }),
 
-/***/ 81217:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 39222:
+/***/ (function(module) {
 
+"use strict";
 /*
-  Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-(function () {
-    'use strict';
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    var estraverse = __webpack_require__(50165);
+const slashCode = "/".charCodeAt(0);
+const backslashCode = "\\".charCodeAt(0);
 
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
+const isInside = (path, parent) => {
+	if (!path.startsWith(parent)) return false;
+	if (path.length === parent.length) return true;
+	const charCode = path.charCodeAt(parent.length);
+	return charCode === slashCode || charCode === backslashCode;
+};
 
-    function isProperty(nodeType, key) {
-        return (nodeType === estraverse.Syntax.ObjectExpression || nodeType === estraverse.Syntax.ObjectPattern) && key === 'properties';
-    }
+module.exports = class RestrictionsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Set<string | RegExp>} restrictions restrictions
+	 */
+	constructor(source, restrictions) {
+		this.source = source;
+		this.restrictions = restrictions;
+	}
 
-    function Visitor(visitor, options) {
-        options = options || {};
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		resolver
+			.getHook(this.source)
+			.tapAsync("RestrictionsPlugin", (request, resolveContext, callback) => {
+				if (typeof request.path === "string") {
+					const path = request.path;
+					for (const rule of this.restrictions) {
+						if (typeof rule === "string") {
+							if (!isInside(path, rule)) {
+								if (resolveContext.log) {
+									resolveContext.log(
+										`${path} is not inside of the restriction ${rule}`
+									);
+								}
+								return callback(null, null);
+							}
+						} else if (!rule.test(path)) {
+							if (resolveContext.log) {
+								resolveContext.log(
+									`${path} doesn't match the restriction ${rule}`
+								);
+							}
+							return callback(null, null);
+						}
+					}
+				}
 
-        this.__visitor = visitor ||  this;
-        this.__childVisitorKeys = options.childVisitorKeys
-            ? Object.assign({}, estraverse.VisitorKeys, options.childVisitorKeys)
-            : estraverse.VisitorKeys;
-        if (options.fallback === 'iteration') {
-            this.__fallback = Object.keys;
-        } else if (typeof options.fallback === 'function') {
-            this.__fallback = options.fallback;
-        }
-    }
+				callback();
+			});
+	}
+};
 
-    /* Default method for visiting children.
-     * When you need to call default visiting operation inside custom visiting
-     * operation, you can use it with `this.visitChildren(node)`.
-     */
-    Visitor.prototype.visitChildren = function (node) {
-        var type, children, i, iz, j, jz, child;
 
-        if (node == null) {
-            return;
-        }
+/***/ }),
 
-        type = node.type || estraverse.Syntax.Property;
+/***/ 10615:
+/***/ (function(module) {
 
-        children = this.__childVisitorKeys[type];
-        if (!children) {
-            if (this.__fallback) {
-                children = this.__fallback(node);
-            } else {
-                throw new Error('Unknown node type ' + type + '.');
-            }
-        }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        for (i = 0, iz = children.length; i < iz; ++i) {
-            child = node[children[i]];
-            if (child) {
-                if (Array.isArray(child)) {
-                    for (j = 0, jz = child.length; j < jz; ++j) {
-                        if (child[j]) {
-                            if (isNode(child[j]) || isProperty(type, children[i])) {
-                                this.visit(child[j]);
-                            }
-                        }
-                    }
-                } else if (isNode(child)) {
-                    this.visit(child);
-                }
-            }
-        }
-    };
 
-    /* Dispatching node. */
-    Visitor.prototype.visit = function (node) {
-        var type;
 
-        if (node == null) {
-            return;
-        }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-        type = node.type || estraverse.Syntax.Property;
-        if (this.__visitor[type]) {
-            this.__visitor[type].call(this, node);
-            return;
-        }
-        this.visitChildren(node);
-    };
+module.exports = class ResultPlugin {
+	/**
+	 * @param {ResolveStepHook} source source
+	 */
+	constructor(source) {
+		this.source = source;
+	}
 
-    exports.version = __webpack_require__(12166).version;
-    exports.Visitor = Visitor;
-    exports.visit = function (node, visitor, options) {
-        var v = new Visitor(visitor, options);
-        v.visit(node);
-    };
-}());
-/* vim: set sw=4 ts=4 et tw=80 : */
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		this.source.tapAsync(
+			"ResultPlugin",
+			(request, resolverContext, callback) => {
+				const obj = { ...request };
+				if (resolverContext.log)
+					resolverContext.log("reporting result " + obj.path);
+				resolver.hooks.result.callAsync(obj, resolverContext, err => {
+					if (err) return callback(err);
+					callback(null, obj);
+				});
+			}
+		);
+	}
+};
 
 
 /***/ }),
 
-/***/ 50165:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 34403:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+"use strict";
 /*
-  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
 */
-/*jslint vars:false, bitwise:true*/
-/*jshint indent:4*/
-/*global exports:true*/
-(function clone(exports) {
-    'use strict';
 
-    var Syntax,
-        VisitorOption,
-        VisitorKeys,
-        BREAK,
-        SKIP,
-        REMOVE;
 
-    function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                val = obj[key];
-                if (typeof val === 'object' && val !== null) {
-                    ret[key] = deepCopy(val);
-                } else {
-                    ret[key] = val;
-                }
-            }
-        }
-        return ret;
-    }
 
-    // based on LLVM libc++ upper_bound / lower_bound
-    // MIT License
+const forEachBail = __webpack_require__(8266);
 
-    function upperBound(array, func) {
-        var diff, len, i, current;
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-        len = array.length;
-        i = 0;
+class RootsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source hook
+	 * @param {Set<string>} roots roots
+	 * @param {string | ResolveStepHook} target target hook
+	 */
+	constructor(source, roots, target) {
+		this.roots = Array.from(roots);
+		this.source = source;
+		this.target = target;
+	}
 
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                len = diff;
-            } else {
-                i = current + 1;
-                len -= diff + 1;
-            }
-        }
-        return i;
-    }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
 
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        AssignmentPattern: 'AssignmentPattern',
-        ArrayExpression: 'ArrayExpression',
-        ArrayPattern: 'ArrayPattern',
-        ArrowFunctionExpression: 'ArrowFunctionExpression',
-        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ChainExpression: 'ChainExpression',
-        ClassBody: 'ClassBody',
-        ClassDeclaration: 'ClassDeclaration',
-        ClassExpression: 'ClassExpression',
-        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        DirectiveStatement: 'DirectiveStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExportAllDeclaration: 'ExportAllDeclaration',
-        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
-        ExportNamedDeclaration: 'ExportNamedDeclaration',
-        ExportSpecifier: 'ExportSpecifier',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        ForOfStatement: 'ForOfStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        ImportExpression: 'ImportExpression',
-        ImportDeclaration: 'ImportDeclaration',
-        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
-        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
-        ImportSpecifier: 'ImportSpecifier',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        MetaProperty: 'MetaProperty',
-        MethodDefinition: 'MethodDefinition',
-        ModuleSpecifier: 'ModuleSpecifier',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        ObjectPattern: 'ObjectPattern',
-        Program: 'Program',
-        Property: 'Property',
-        RestElement: 'RestElement',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SpreadElement: 'SpreadElement',
-        Super: 'Super',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        TaggedTemplateExpression: 'TaggedTemplateExpression',
-        TemplateElement: 'TemplateElement',
-        TemplateLiteral: 'TemplateLiteral',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement',
-        YieldExpression: 'YieldExpression'
-    };
+		resolver
+			.getHook(this.source)
+			.tapAsync("RootsPlugin", (request, resolveContext, callback) => {
+				const req = request.request;
+				if (!req) return callback();
+				if (!req.startsWith("/")) return callback();
 
-    VisitorKeys = {
-        AssignmentExpression: ['left', 'right'],
-        AssignmentPattern: ['left', 'right'],
-        ArrayExpression: ['elements'],
-        ArrayPattern: ['elements'],
-        ArrowFunctionExpression: ['params', 'body'],
-        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
-        BlockStatement: ['body'],
-        BinaryExpression: ['left', 'right'],
-        BreakStatement: ['label'],
-        CallExpression: ['callee', 'arguments'],
-        CatchClause: ['param', 'body'],
-        ChainExpression: ['expression'],
-        ClassBody: ['body'],
-        ClassDeclaration: ['id', 'superClass', 'body'],
-        ClassExpression: ['id', 'superClass', 'body'],
-        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ['test', 'consequent', 'alternate'],
-        ContinueStatement: ['label'],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ['body', 'test'],
-        EmptyStatement: [],
-        ExportAllDeclaration: ['source'],
-        ExportDefaultDeclaration: ['declaration'],
-        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
-        ExportSpecifier: ['exported', 'local'],
-        ExpressionStatement: ['expression'],
-        ForStatement: ['init', 'test', 'update', 'body'],
-        ForInStatement: ['left', 'right', 'body'],
-        ForOfStatement: ['left', 'right', 'body'],
-        FunctionDeclaration: ['id', 'params', 'body'],
-        FunctionExpression: ['id', 'params', 'body'],
-        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ['test', 'consequent', 'alternate'],
-        ImportExpression: ['source'],
-        ImportDeclaration: ['specifiers', 'source'],
-        ImportDefaultSpecifier: ['local'],
-        ImportNamespaceSpecifier: ['local'],
-        ImportSpecifier: ['imported', 'local'],
-        Literal: [],
-        LabeledStatement: ['label', 'body'],
-        LogicalExpression: ['left', 'right'],
-        MemberExpression: ['object', 'property'],
-        MetaProperty: ['meta', 'property'],
-        MethodDefinition: ['key', 'value'],
-        ModuleSpecifier: [],
-        NewExpression: ['callee', 'arguments'],
-        ObjectExpression: ['properties'],
-        ObjectPattern: ['properties'],
-        Program: ['body'],
-        Property: ['key', 'value'],
-        RestElement: [ 'argument' ],
-        ReturnStatement: ['argument'],
-        SequenceExpression: ['expressions'],
-        SpreadElement: ['argument'],
-        Super: [],
-        SwitchStatement: ['discriminant', 'cases'],
-        SwitchCase: ['test', 'consequent'],
-        TaggedTemplateExpression: ['tag', 'quasi'],
-        TemplateElement: [],
-        TemplateLiteral: ['quasis', 'expressions'],
-        ThisExpression: [],
-        ThrowStatement: ['argument'],
-        TryStatement: ['block', 'handler', 'finalizer'],
-        UnaryExpression: ['argument'],
-        UpdateExpression: ['argument'],
-        VariableDeclaration: ['declarations'],
-        VariableDeclarator: ['id', 'init'],
-        WhileStatement: ['test', 'body'],
-        WithStatement: ['object', 'body'],
-        YieldExpression: ['argument']
-    };
+				forEachBail(
+					this.roots,
+					(root, callback) => {
+						const path = resolver.join(root, req.slice(1));
+						const obj = {
+							...request,
+							path,
+							relativePath: request.relativePath && path
+						};
+						resolver.doResolve(
+							target,
+							obj,
+							`root path ${root}`,
+							resolveContext,
+							callback
+						);
+					},
+					callback
+				);
+			});
+	}
+}
 
-    // unique id
-    BREAK = {};
-    SKIP = {};
-    REMOVE = {};
+module.exports = RootsPlugin;
 
-    VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-    };
 
-    function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-    }
+/***/ }),
 
-    Reference.prototype.replace = function replace(node) {
-        this.parent[this.key] = node;
-    };
+/***/ 32317:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    Reference.prototype.remove = function remove() {
-        if (Array.isArray(this.parent)) {
-            this.parent.splice(this.key, 1);
-            return true;
-        } else {
-            this.replace(null);
-            return false;
-        }
-    };
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-    }
 
-    function Controller() { }
 
-    // API:
-    // return property path array from root to current node
-    Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
+const DescriptionFileUtils = __webpack_require__(702);
 
-        function addToPath(result, path) {
-            if (Array.isArray(path)) {
-                for (j = 0, jz = path.length; j < jz; ++j) {
-                    result.push(path[j]);
-                }
-            } else {
-                result.push(path);
-            }
-        }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-        // root node
-        if (!this.__current.path) {
-            return null;
-        }
+const slashCode = "/".charCodeAt(0);
 
-        // first node is sentinel, second node is root element
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-            element = this.__leavelist[i];
-            addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-    };
+module.exports = class SelfReferencePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | string[]} fieldNamePath name path
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, fieldNamePath, target) {
+		this.source = source;
+		this.target = target;
+		this.fieldName = fieldNamePath;
+	}
 
-    // API:
-    // return type of current node
-    Controller.prototype.type = function () {
-        var node = this.current();
-        return node.type || this.__current.wrap;
-    };
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("SelfReferencePlugin", (request, resolveContext, callback) => {
+				if (!request.descriptionFilePath) return callback();
 
-    // API:
-    // return array of parent elements
-    Controller.prototype.parents = function parents() {
-        var i, iz, result;
+				const req = request.request;
+				if (!req) return callback();
 
-        // first node is sentinel
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-            result.push(this.__leavelist[i].node);
-        }
+				// Feature is only enabled when an exports field is present
+				const exportsField = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.fieldName
+				);
+				if (!exportsField) return callback();
 
-        return result;
-    };
+				const name = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					"name"
+				);
+				if (typeof name !== "string") return callback();
 
-    // API:
-    // return current node
-    Controller.prototype.current = function current() {
-        return this.__current.node;
-    };
+				if (
+					req.startsWith(name) &&
+					(req.length === name.length ||
+						req.charCodeAt(name.length) === slashCode)
+				) {
+					const remainingRequest = `.${req.slice(name.length)}`;
 
-    Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
+					const obj = {
+						...request,
+						request: remainingRequest,
+						path: /** @type {string} */ (request.descriptionFileRoot),
+						relativePath: "."
+					};
 
-        result = undefined;
+					resolver.doResolve(
+						target,
+						obj,
+						"self reference",
+						resolveContext,
+						callback
+					);
+				} else {
+					return callback();
+				}
+			});
+	}
+};
 
-        previous  = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
 
-        return result;
-    };
+/***/ }),
 
-    // API:
-    // notify control skip / break
-    Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-    };
+/***/ 21300:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    // API:
-    // skip child nodes of current node
-    Controller.prototype.skip = function () {
-        this.notify(SKIP);
-    };
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    // API:
-    // break traversals
-    Controller.prototype['break'] = function () {
-        this.notify(BREAK);
-    };
 
-    // API:
-    // remove node
-    Controller.prototype.remove = function () {
-        this.notify(REMOVE);
-    };
 
-    Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = null;
-        if (visitor.fallback === 'iteration') {
-            this.__fallback = Object.keys;
-        } else if (typeof visitor.fallback === 'function') {
-            this.__fallback = visitor.fallback;
-        }
+const forEachBail = __webpack_require__(8266);
+const getPaths = __webpack_require__(48608);
+const { getType, PathType } = __webpack_require__(3011);
 
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
-        }
-    };
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
+module.exports = class SymlinkPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-    function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
-    }
-  
-    function candidateExistsInLeaveList(leavelist, candidate) {
-        for (var i = leavelist.length - 1; i >= 0; --i) {
-            if (leavelist[i].node === candidate) {
-                return true;
-            }
-        }
-        return false;
-    }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const fs = resolver.fileSystem;
+		resolver
+			.getHook(this.source)
+			.tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
+				if (request.ignoreSymlinks) return callback();
+				const pathsResult = getPaths(request.path);
+				const pathSeqments = pathsResult.seqments;
+				const paths = pathsResult.paths;
 
-    Controller.prototype.traverse = function traverse(root, visitor) {
-        var worklist,
-            leavelist,
-            element,
-            node,
-            nodeType,
-            ret,
-            key,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel;
+				let containsSymlink = false;
+				let idx = -1;
+				forEachBail(
+					paths,
+					(path, callback) => {
+						idx++;
+						if (resolveContext.fileDependencies)
+							resolveContext.fileDependencies.add(path);
+						fs.readlink(path, (err, result) => {
+							if (!err && result) {
+								pathSeqments[idx] = result;
+								containsSymlink = true;
+								// Shortcut when absolute symlink found
+								const resultType = getType(result.toString());
+								if (
+									resultType === PathType.AbsoluteWin ||
+									resultType === PathType.AbsolutePosix
+								) {
+									return callback(null, idx);
+								}
+							}
+							callback();
+						});
+					},
+					(err, idx) => {
+						if (!containsSymlink) return callback();
+						const resultSeqments =
+							typeof idx === "number"
+								? pathSeqments.slice(0, idx + 1)
+								: pathSeqments.slice();
+						const result = resultSeqments.reduceRight((a, b) => {
+							return resolver.join(a, b);
+						});
+						const obj = {
+							...request,
+							path: result
+						};
+						resolver.doResolve(
+							target,
+							obj,
+							"resolved symlink to " + result,
+							resolveContext,
+							callback
+						);
+					}
+				);
+			});
+	}
+};
 
-        this.__initialize(root, visitor);
 
-        sentinel = {};
+/***/ }),
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+/***/ 57746:
+/***/ (function(module) {
 
-        // initialize
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        while (worklist.length) {
-            element = worklist.pop();
 
-            if (element === sentinel) {
-                element = leavelist.pop();
 
-                ret = this.__execute(visitor.leave, element);
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-                continue;
-            }
+/**
+ * @param {SyncFileSystem} fs file system implementation
+ * @constructor
+ */
+function SyncAsyncFileSystemDecorator(fs) {
+	this.fs = fs;
 
-            if (element.node) {
+	this.lstat = undefined;
+	this.lstatSync = undefined;
+	const lstatSync = fs.lstatSync;
+	if (lstatSync) {
+		this.lstat = (arg, options, callback) => {
+			let result;
+			try {
+				result = lstatSync.call(fs, arg);
+			} catch (e) {
+				return (callback || options)(e);
+			}
+			(callback || options)(null, result);
+		};
+		this.lstatSync = (arg, options) => lstatSync.call(fs, arg, options);
+	}
 
-                ret = this.__execute(visitor.enter, element);
+	this.stat = (arg, options, callback) => {
+		let result;
+		try {
+			result = callback ? fs.statSync(arg, options) : fs.statSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.statSync = (arg, options) => fs.statSync(arg, options);
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
+	this.readdir = (arg, options, callback) => {
+		let result;
+		try {
+			result = fs.readdirSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.readdirSync = (arg, options) => fs.readdirSync(arg, options);
 
-                worklist.push(sentinel);
-                leavelist.push(element);
+	this.readFile = (arg, options, callback) => {
+		let result;
+		try {
+			result = fs.readFileSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.readFileSync = (arg, options) => fs.readFileSync(arg, options);
 
-                if (this.__state === SKIP || ret === SKIP) {
-                    continue;
-                }
+	this.readlink = (arg, options, callback) => {
+		let result;
+		try {
+			result = fs.readlinkSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.readlinkSync = (arg, options) => fs.readlinkSync(arg, options);
 
-                node = element.node;
-                nodeType = node.type || element.wrap;
-                candidates = this.__keys[nodeType];
-                if (!candidates) {
-                    if (this.__fallback) {
-                        candidates = this.__fallback(node);
-                    } else {
-                        throw new Error('Unknown node type ' + nodeType + '.');
-                    }
-                }
+	this.readJson = undefined;
+	this.readJsonSync = undefined;
+	const readJsonSync = fs.readJsonSync;
+	if (readJsonSync) {
+		this.readJson = (arg, options, callback) => {
+			let result;
+			try {
+				result = readJsonSync.call(fs, arg);
+			} catch (e) {
+				return (callback || options)(e);
+			}
+			(callback || options)(null, result);
+		};
 
-                current = candidates.length;
-                while ((current -= 1) >= 0) {
-                    key = candidates[current];
-                    candidate = node[key];
-                    if (!candidate) {
-                        continue;
-                    }
+		this.readJsonSync = (arg, options) => readJsonSync.call(fs, arg, options);
+	}
+}
+module.exports = SyncAsyncFileSystemDecorator;
 
-                    if (Array.isArray(candidate)) {
-                        current2 = candidate.length;
-                        while ((current2 -= 1) >= 0) {
-                            if (!candidate[current2]) {
-                                continue;
-                            }
 
-                            if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
-                              continue;
-                            }
+/***/ }),
 
-                            if (isProperty(nodeType, candidates[current])) {
-                                element = new Element(candidate[current2], [key, current2], 'Property', null);
-                            } else if (isNode(candidate[current2])) {
-                                element = new Element(candidate[current2], [key, current2], null, null);
-                            } else {
-                                continue;
-                            }
-                            worklist.push(element);
-                        }
-                    } else if (isNode(candidate)) {
-                        if (candidateExistsInLeaveList(leavelist, candidate)) {
-                          continue;
-                        }
+/***/ 16442:
+/***/ (function(module) {
 
-                        worklist.push(new Element(candidate, key, null, null));
-                    }
-                }
-            }
-        }
-    };
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    Controller.prototype.replace = function replace(root, visitor) {
-        var worklist,
-            leavelist,
-            node,
-            nodeType,
-            target,
-            element,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel,
-            outer,
-            key;
 
-        function removeElem(element) {
-            var i,
-                key,
-                nextElem,
-                parent;
 
-            if (element.ref.remove()) {
-                // When the reference is an element of an array.
-                key = element.ref.key;
-                parent = element.ref.parent;
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-                // If removed from array, then decrease following items' keys.
-                i = worklist.length;
-                while (i--) {
-                    nextElem = worklist[i];
-                    if (nextElem.ref && nextElem.ref.parent === parent) {
-                        if  (nextElem.ref.key < key) {
-                            break;
-                        }
-                        --nextElem.ref.key;
-                    }
-                }
-            }
-        }
+module.exports = class TryNextPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} message message
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, message, target) {
+		this.source = source;
+		this.message = message;
+		this.target = target;
+	}
 
-        this.__initialize(root, visitor);
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("TryNextPlugin", (request, resolveContext, callback) => {
+				resolver.doResolve(
+					target,
+					request,
+					this.message,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
-        sentinel = {};
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+/***/ }),
 
-        // initialize
-        outer = {
-            root: root
-        };
-        element = new Element(root, null, null, new Reference(outer, 'root'));
-        worklist.push(element);
-        leavelist.push(element);
+/***/ 3501:
+/***/ (function(module) {
 
-        while (worklist.length) {
-            element = worklist.pop();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-            if (element === sentinel) {
-                element = leavelist.pop();
 
-                target = this.__execute(visitor.leave, element);
 
-                // node may be replaced with null,
-                // so distinguish between undefined and null in this place
-                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                    // replace
-                    element.ref.replace(target);
-                }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{[k: string]: any}} Cache */
 
-                if (this.__state === REMOVE || target === REMOVE) {
-                    removeElem(element);
-                }
+function getCacheId(request, withContext) {
+	return JSON.stringify({
+		context: withContext ? request.context : "",
+		path: request.path,
+		query: request.query,
+		fragment: request.fragment,
+		request: request.request
+	});
+}
 
-                if (this.__state === BREAK || target === BREAK) {
-                    return outer.root;
-                }
-                continue;
-            }
+module.exports = class UnsafeCachePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {function(ResolveRequest): boolean} filterPredicate filterPredicate
+	 * @param {Cache} cache cache
+	 * @param {boolean} withContext withContext
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filterPredicate, cache, withContext, target) {
+		this.source = source;
+		this.filterPredicate = filterPredicate;
+		this.withContext = withContext;
+		this.cache = cache;
+		this.target = target;
+	}
 
-            target = this.__execute(visitor.enter, element);
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
+				if (!this.filterPredicate(request)) return callback();
+				const cacheId = getCacheId(request, this.withContext);
+				const cacheEntry = this.cache[cacheId];
+				if (cacheEntry) {
+					return callback(null, cacheEntry);
+				}
+				resolver.doResolve(
+					target,
+					request,
+					null,
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
+						if (result) return callback(null, (this.cache[cacheId] = result));
+						callback();
+					}
+				);
+			});
+	}
+};
 
-            // node may be replaced with null,
-            // so distinguish between undefined and null in this place
-            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                // replace
-                element.ref.replace(target);
-                element.node = target;
-            }
 
-            if (this.__state === REMOVE || target === REMOVE) {
-                removeElem(element);
-                element.node = null;
-            }
+/***/ }),
 
-            if (this.__state === BREAK || target === BREAK) {
-                return outer.root;
-            }
+/***/ 50318:
+/***/ (function(module) {
 
-            // node may be null
-            node = element.node;
-            if (!node) {
-                continue;
-            }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-            worklist.push(sentinel);
-            leavelist.push(element);
 
-            if (this.__state === SKIP || target === SKIP) {
-                continue;
-            }
 
-            nodeType = node.type || element.wrap;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-                if (this.__fallback) {
-                    candidates = this.__fallback(node);
-                } else {
-                    throw new Error('Unknown node type ' + nodeType + '.');
-                }
-            }
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-                key = candidates[current];
-                candidate = node[key];
-                if (!candidate) {
-                    continue;
-                }
+module.exports = class UseFilePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} filename filename
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filename, target) {
+		this.source = source;
+		this.filename = filename;
+		this.target = target;
+	}
 
-                if (Array.isArray(candidate)) {
-                    current2 = candidate.length;
-                    while ((current2 -= 1) >= 0) {
-                        if (!candidate[current2]) {
-                            continue;
-                        }
-                        if (isProperty(nodeType, candidates[current])) {
-                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
-                        } else if (isNode(candidate[current2])) {
-                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                        } else {
-                            continue;
-                        }
-                        worklist.push(element);
-                    }
-                } else if (isNode(candidate)) {
-                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-                }
-            }
-        }
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
+				const filePath = resolver.join(request.path, this.filename);
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, this.filename)
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"using path: " + filePath,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
-        return outer.root;
-    };
 
-    function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-    }
+/***/ }),
 
-    function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-    }
+/***/ 95478:
+/***/ (function(module) {
 
-    function extendCommentRange(comment, tokens) {
-        var target;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        target = upperBound(tokens, function search(token) {
-            return token.range[0] > comment.range[0];
-        });
 
-        comment.extendedRange = [comment.range[0], comment.range[1]];
 
-        if (target !== tokens.length) {
-            comment.extendedRange[1] = tokens[target].range[0];
-        }
+module.exports = function createInnerContext(
+	options,
+	message,
+	messageOptional
+) {
+	let messageReported = false;
+	let innerLog = undefined;
+	if (options.log) {
+		if (message) {
+			innerLog = msg => {
+				if (!messageReported) {
+					options.log(message);
+					messageReported = true;
+				}
+				options.log("  " + msg);
+			};
+		} else {
+			innerLog = options.log;
+		}
+	}
+	const childContext = {
+		log: innerLog,
+		fileDependencies: options.fileDependencies,
+		contextDependencies: options.contextDependencies,
+		missingDependencies: options.missingDependencies,
+		stack: options.stack
+	};
+	return childContext;
+};
 
-        target -= 1;
-        if (target >= 0) {
-            comment.extendedRange[0] = tokens[target].range[1];
-        }
 
-        return comment;
-    }
+/***/ }),
 
-    function attachComments(tree, providedComments, tokens) {
-        // At first, we should calculate extended comment ranges.
-        var comments = [], comment, len, i, cursor;
+/***/ 8266:
+/***/ (function(module) {
 
-        if (!tree.range) {
-            throw new Error('attachComments needs range information');
-        }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        // tokens array is empty, we attach comments to tree as 'leadingComments'
-        if (!tokens.length) {
-            if (providedComments.length) {
-                for (i = 0, len = providedComments.length; i < len; i += 1) {
-                    comment = deepCopy(providedComments[i]);
-                    comment.extendedRange = [0, tree.range[0]];
-                    comments.push(comment);
-                }
-                tree.leadingComments = comments;
-            }
-            return tree;
-        }
 
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
 
-        // This is based on John Freeman's implementation.
-        cursor = 0;
-        traverse(tree, {
-            enter: function (node) {
-                var comment;
+module.exports = function forEachBail(array, iterator, callback) {
+	if (array.length === 0) return callback();
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (comment.extendedRange[1] > node.range[0]) {
-                        break;
-                    }
+	let i = 0;
+	const next = () => {
+		let loop = undefined;
+		iterator(array[i++], (err, result) => {
+			if (err || result !== undefined || i >= array.length) {
+				return callback(err, result);
+			}
+			if (loop === false) while (next());
+			loop = true;
+		});
+		if (!loop) loop = false;
+		return loop;
+	};
+	while (next());
+};
 
-                    if (comment.extendedRange[1] === node.range[0]) {
-                        if (!node.leadingComments) {
-                            node.leadingComments = [];
-                        }
-                        node.leadingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+/***/ }),
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+/***/ 50290:
+/***/ (function(module) {
 
-        cursor = 0;
-        traverse(tree, {
-            leave: function (node) {
-                var comment;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (node.range[1] < comment.extendedRange[0]) {
-                        break;
-                    }
 
-                    if (node.range[1] === comment.extendedRange[0]) {
-                        if (!node.trailingComments) {
-                            node.trailingComments = [];
-                        }
-                        node.trailingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+module.exports = function getInnerRequest(resolver, request) {
+	if (
+		typeof request.__innerRequest === "string" &&
+		request.__innerRequest_request === request.request &&
+		request.__innerRequest_relativePath === request.relativePath
+	)
+		return request.__innerRequest;
+	let innerRequest;
+	if (request.request) {
+		innerRequest = request.request;
+		if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) {
+			innerRequest = resolver.join(request.relativePath, innerRequest);
+		}
+	} else {
+		innerRequest = request.relativePath;
+	}
+	request.__innerRequest_request = request.request;
+	request.__innerRequest_relativePath = request.relativePath;
+	return (request.__innerRequest = innerRequest);
+};
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
 
-        return tree;
-    }
+/***/ }),
 
-    exports.Syntax = Syntax;
-    exports.traverse = traverse;
-    exports.replace = replace;
-    exports.attachComments = attachComments;
-    exports.VisitorKeys = VisitorKeys;
-    exports.VisitorOption = VisitorOption;
-    exports.Controller = Controller;
-    exports.cloneEnvironment = function () { return clone({}); };
+/***/ 48608:
+/***/ (function(module) {
 
-    return exports;
-}(exports));
-/* vim: set sw=4 ts=4 et tw=80 : */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
 
-/***/ }),
 
-/***/ 18350:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+module.exports = function getPaths(path) {
+	const parts = path.split(/(.*?[\\/]+)/);
+	const paths = [path];
+	const seqments = [parts[parts.length - 1]];
+	let part = parts[parts.length - 1];
+	path = path.substr(0, path.length - part.length - 1);
+	for (let i = parts.length - 2; i > 2; i -= 2) {
+		paths.push(path);
+		part = parts[i];
+		path = path.substr(0, path.length - part.length) || "/";
+		seqments.push(part.substr(0, part.length - 1));
+	}
+	part = parts[1];
+	seqments.push(part);
+	paths.push(part);
+	return {
+		paths: paths,
+		seqments: seqments
+	};
+};
 
-/*
-  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+module.exports.basename = function basename(path) {
+	const i = path.lastIndexOf("/"),
+		j = path.lastIndexOf("\\");
+	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
+	if (p < 0) return null;
+	const s = path.substr(p + 1);
+	return s;
+};
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+/***/ }),
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/***/ 30662:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
-/*jslint vars:false, bitwise:true*/
-/*jshint indent:4*/
-/*global exports:true*/
-(function clone(exports) {
-    'use strict';
 
-    var Syntax,
-        VisitorOption,
-        VisitorKeys,
-        BREAK,
-        SKIP,
-        REMOVE;
 
-    function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                val = obj[key];
-                if (typeof val === 'object' && val !== null) {
-                    ret[key] = deepCopy(val);
-                } else {
-                    ret[key] = val;
-                }
-            }
-        }
-        return ret;
-    }
 
-    // based on LLVM libc++ upper_bound / lower_bound
-    // MIT License
+const fs = __webpack_require__(90552);
+const CachedInputFileSystem = __webpack_require__(89429);
+const ResolverFactory = __webpack_require__(53990);
 
-    function upperBound(array, func) {
-        var diff, len, i, current;
+/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./ResolverFactory").Plugin} Plugin */
+/** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */
 
-        len = array.length;
-        i = 0;
+const nodeFileSystem = new CachedInputFileSystem(fs, 4000);
 
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                len = diff;
-            } else {
-                i = current + 1;
-                len -= diff + 1;
-            }
-        }
-        return i;
-    }
+const nodeContext = {
+	environments: ["node+es3+es5+process+native"]
+};
 
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        AssignmentPattern: 'AssignmentPattern',
-        ArrayExpression: 'ArrayExpression',
-        ArrayPattern: 'ArrayPattern',
-        ArrowFunctionExpression: 'ArrowFunctionExpression',
-        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ClassBody: 'ClassBody',
-        ClassDeclaration: 'ClassDeclaration',
-        ClassExpression: 'ClassExpression',
-        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        DirectiveStatement: 'DirectiveStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExportAllDeclaration: 'ExportAllDeclaration',
-        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
-        ExportNamedDeclaration: 'ExportNamedDeclaration',
-        ExportSpecifier: 'ExportSpecifier',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        ForOfStatement: 'ForOfStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        ImportExpression: 'ImportExpression',
-        ImportDeclaration: 'ImportDeclaration',
-        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
-        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
-        ImportSpecifier: 'ImportSpecifier',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        MetaProperty: 'MetaProperty',
-        MethodDefinition: 'MethodDefinition',
-        ModuleSpecifier: 'ModuleSpecifier',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        ObjectPattern: 'ObjectPattern',
-        Program: 'Program',
-        Property: 'Property',
-        RestElement: 'RestElement',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SpreadElement: 'SpreadElement',
-        Super: 'Super',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        TaggedTemplateExpression: 'TaggedTemplateExpression',
-        TemplateElement: 'TemplateElement',
-        TemplateLiteral: 'TemplateLiteral',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement',
-        YieldExpression: 'YieldExpression'
-    };
+const asyncResolver = ResolverFactory.createResolver({
+	conditionNames: ["node"],
+	extensions: [".js", ".json", ".node"],
+	fileSystem: nodeFileSystem
+});
+function resolve(context, path, request, resolveContext, callback) {
+	if (typeof context === "string") {
+		callback = resolveContext;
+		resolveContext = request;
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	if (typeof callback !== "function") {
+		callback = resolveContext;
+	}
+	asyncResolver.resolve(context, path, request, resolveContext, callback);
+}
 
-    VisitorKeys = {
-        AssignmentExpression: ['left', 'right'],
-        AssignmentPattern: ['left', 'right'],
-        ArrayExpression: ['elements'],
-        ArrayPattern: ['elements'],
-        ArrowFunctionExpression: ['params', 'body'],
-        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
-        BlockStatement: ['body'],
-        BinaryExpression: ['left', 'right'],
-        BreakStatement: ['label'],
-        CallExpression: ['callee', 'arguments'],
-        CatchClause: ['param', 'body'],
-        ClassBody: ['body'],
-        ClassDeclaration: ['id', 'superClass', 'body'],
-        ClassExpression: ['id', 'superClass', 'body'],
-        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ['test', 'consequent', 'alternate'],
-        ContinueStatement: ['label'],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ['body', 'test'],
-        EmptyStatement: [],
-        ExportAllDeclaration: ['source'],
-        ExportDefaultDeclaration: ['declaration'],
-        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
-        ExportSpecifier: ['exported', 'local'],
-        ExpressionStatement: ['expression'],
-        ForStatement: ['init', 'test', 'update', 'body'],
-        ForInStatement: ['left', 'right', 'body'],
-        ForOfStatement: ['left', 'right', 'body'],
-        FunctionDeclaration: ['id', 'params', 'body'],
-        FunctionExpression: ['id', 'params', 'body'],
-        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ['test', 'consequent', 'alternate'],
-        ImportExpression: ['source'],
-        ImportDeclaration: ['specifiers', 'source'],
-        ImportDefaultSpecifier: ['local'],
-        ImportNamespaceSpecifier: ['local'],
-        ImportSpecifier: ['imported', 'local'],
-        Literal: [],
-        LabeledStatement: ['label', 'body'],
-        LogicalExpression: ['left', 'right'],
-        MemberExpression: ['object', 'property'],
-        MetaProperty: ['meta', 'property'],
-        MethodDefinition: ['key', 'value'],
-        ModuleSpecifier: [],
-        NewExpression: ['callee', 'arguments'],
-        ObjectExpression: ['properties'],
-        ObjectPattern: ['properties'],
-        Program: ['body'],
-        Property: ['key', 'value'],
-        RestElement: [ 'argument' ],
-        ReturnStatement: ['argument'],
-        SequenceExpression: ['expressions'],
-        SpreadElement: ['argument'],
-        Super: [],
-        SwitchStatement: ['discriminant', 'cases'],
-        SwitchCase: ['test', 'consequent'],
-        TaggedTemplateExpression: ['tag', 'quasi'],
-        TemplateElement: [],
-        TemplateLiteral: ['quasis', 'expressions'],
-        ThisExpression: [],
-        ThrowStatement: ['argument'],
-        TryStatement: ['block', 'handler', 'finalizer'],
-        UnaryExpression: ['argument'],
-        UpdateExpression: ['argument'],
-        VariableDeclaration: ['declarations'],
-        VariableDeclarator: ['id', 'init'],
-        WhileStatement: ['test', 'body'],
-        WithStatement: ['object', 'body'],
-        YieldExpression: ['argument']
-    };
+const syncResolver = ResolverFactory.createResolver({
+	conditionNames: ["node"],
+	extensions: [".js", ".json", ".node"],
+	useSyncFileSystemCalls: true,
+	fileSystem: nodeFileSystem
+});
+function resolveSync(context, path, request) {
+	if (typeof context === "string") {
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	return syncResolver.resolveSync(context, path, request);
+}
 
-    // unique id
-    BREAK = {};
-    SKIP = {};
-    REMOVE = {};
+function create(options) {
+	options = {
+		fileSystem: nodeFileSystem,
+		...options
+	};
+	const resolver = ResolverFactory.createResolver(options);
+	return function (context, path, request, resolveContext, callback) {
+		if (typeof context === "string") {
+			callback = resolveContext;
+			resolveContext = request;
+			request = path;
+			path = context;
+			context = nodeContext;
+		}
+		if (typeof callback !== "function") {
+			callback = resolveContext;
+		}
+		resolver.resolve(context, path, request, resolveContext, callback);
+	};
+}
 
-    VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-    };
+function createSync(options) {
+	options = {
+		useSyncFileSystemCalls: true,
+		fileSystem: nodeFileSystem,
+		...options
+	};
+	const resolver = ResolverFactory.createResolver(options);
+	return function (context, path, request) {
+		if (typeof context === "string") {
+			request = path;
+			path = context;
+			context = nodeContext;
+		}
+		return resolver.resolveSync(context, path, request);
+	};
+}
 
-    function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-    }
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	Object.defineProperties(obj, descriptors);
+	return /** @type {A & B} */ (Object.freeze(obj));
+};
 
-    Reference.prototype.replace = function replace(node) {
-        this.parent[this.key] = node;
-    };
+module.exports = mergeExports(resolve, {
+	get sync() {
+		return resolveSync;
+	},
+	create: mergeExports(create, {
+		get sync() {
+			return createSync;
+		}
+	}),
+	ResolverFactory,
+	CachedInputFileSystem,
+	get CloneBasenamePlugin() {
+		return __webpack_require__(2020);
+	},
+	get LogInfoPlugin() {
+		return __webpack_require__(47032);
+	},
+	get forEachBail() {
+		return __webpack_require__(8266);
+	}
+});
 
-    Reference.prototype.remove = function remove() {
-        if (Array.isArray(this.parent)) {
-            this.parent.splice(this.key, 1);
-            return true;
-        } else {
-            this.replace(null);
-            return false;
-        }
-    };
 
-    function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-    }
+/***/ }),
 
-    function Controller() { }
+/***/ 28348:
+/***/ (function(module) {
 
-    // API:
-    // return property path array from root to current node
-    Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-        function addToPath(result, path) {
-            if (Array.isArray(path)) {
-                for (j = 0, jz = path.length; j < jz; ++j) {
-                    result.push(path[j]);
-                }
-            } else {
-                result.push(path);
-            }
-        }
 
-        // root node
-        if (!this.__current.path) {
-            return null;
-        }
 
-        // first node is sentinel, second node is root element
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-            element = this.__leavelist[i];
-            addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-    };
+/** @typedef {string|(string|ConditionalMapping)[]} DirectMapping */
+/** @typedef {{[k: string]: MappingValue}} ConditionalMapping */
+/** @typedef {ConditionalMapping|DirectMapping|null} MappingValue */
+/** @typedef {Record<string, MappingValue>|ConditionalMapping|DirectMapping} ExportsField */
+/** @typedef {Record<string, MappingValue>} ImportsField */
 
-    // API:
-    // return type of current node
-    Controller.prototype.type = function () {
-        var node = this.current();
-        return node.type || this.__current.wrap;
-    };
+/**
+ * @typedef {Object} PathTreeNode
+ * @property {Map<string, PathTreeNode>|null} children
+ * @property {MappingValue} folder
+ * @property {Map<string, MappingValue>|null} wildcards
+ * @property {Map<string, MappingValue>} files
+ */
 
-    // API:
-    // return array of parent elements
-    Controller.prototype.parents = function parents() {
-        var i, iz, result;
+/**
+ * Processing exports/imports field
+ * @callback FieldProcessor
+ * @param {string} request request
+ * @param {Set<string>} conditionNames condition names
+ * @returns {string[]} resolved paths
+ */
 
-        // first node is sentinel
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-            result.push(this.__leavelist[i].node);
-        }
+/*
+Example exports field:
+{
+  ".": "./main.js",
+  "./feature": {
+    "browser": "./feature-browser.js",
+    "default": "./feature.js"
+  }
+}
+Terminology:
 
-        return result;
-    };
+Enhanced-resolve name keys ("." and "./feature") as exports field keys.
 
-    // API:
-    // return current node
-    Controller.prototype.current = function current() {
-        return this.__current.node;
-    };
+If value is string or string[], mapping is called as a direct mapping
+and value called as a direct export.
 
-    Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
+If value is key-value object, mapping is called as a conditional mapping
+and value called as a conditional export.
 
-        result = undefined;
+Key in conditional mapping is called condition name.
 
-        previous  = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
+Conditional mapping nested in another conditional mapping is called nested mapping.
 
-        return result;
-    };
+----------
 
-    // API:
-    // notify control skip / break
-    Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-    };
+Example imports field:
+{
+  "#a": "./main.js",
+  "#moment": {
+    "browser": "./moment/index.js",
+    "default": "moment"
+  },
+  "#moment/": {
+    "browser": "./moment/",
+    "default": "moment/"
+  }
+}
+Terminology:
 
-    // API:
-    // skip child nodes of current node
-    Controller.prototype.skip = function () {
-        this.notify(SKIP);
-    };
+Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys.
 
-    // API:
-    // break traversals
-    Controller.prototype['break'] = function () {
-        this.notify(BREAK);
-    };
+If value is string or string[], mapping is called as a direct mapping
+and value called as a direct export.
 
-    // API:
-    // remove node
-    Controller.prototype.remove = function () {
-        this.notify(REMOVE);
-    };
+If value is key-value object, mapping is called as a conditional mapping
+and value called as a conditional export.
 
-    Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = null;
-        if (visitor.fallback === 'iteration') {
-            this.__fallback = Object.keys;
-        } else if (typeof visitor.fallback === 'function') {
-            this.__fallback = visitor.fallback;
-        }
+Key in conditional mapping is called condition name.
 
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
-        }
-    };
+Conditional mapping nested in another conditional mapping is called nested mapping.
 
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
+*/
 
-    function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
-    }
+const slashCode = "/".charCodeAt(0);
+const dotCode = ".".charCodeAt(0);
+const hashCode = "#".charCodeAt(0);
 
-    Controller.prototype.traverse = function traverse(root, visitor) {
-        var worklist,
-            leavelist,
-            element,
-            node,
-            nodeType,
-            ret,
-            key,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel;
+/**
+ * @param {ExportsField} exportsField the exports field
+ * @returns {FieldProcessor} process callback
+ */
+module.exports.processExportsField = function processExportsField(
+	exportsField
+) {
+	return createFieldProcessor(
+		buildExportsFieldPathTree(exportsField),
+		assertExportsFieldRequest,
+		assertExportTarget
+	);
+};
 
-        this.__initialize(root, visitor);
+/**
+ * @param {ImportsField} importsField the exports field
+ * @returns {FieldProcessor} process callback
+ */
+module.exports.processImportsField = function processImportsField(
+	importsField
+) {
+	return createFieldProcessor(
+		buildImportsFieldPathTree(importsField),
+		assertImportsFieldRequest,
+		assertImportTarget
+	);
+};
 
-        sentinel = {};
+/**
+ * @param {PathTreeNode} treeRoot root
+ * @param {(s: string) => string} assertRequest assertRequest
+ * @param {(s: string, f: boolean) => void} assertTarget assertTarget
+ * @returns {FieldProcessor} field processor
+ */
+function createFieldProcessor(treeRoot, assertRequest, assertTarget) {
+	return function fieldProcessor(request, conditionNames) {
+		request = assertRequest(request);
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+		const match = findMatch(request, treeRoot);
 
-        // initialize
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
+		if (match === null) return [];
 
-        while (worklist.length) {
-            element = worklist.pop();
+		const [mapping, remainRequestIndex] = match;
 
-            if (element === sentinel) {
-                element = leavelist.pop();
+		/** @type {DirectMapping|null} */
+		let direct = null;
 
-                ret = this.__execute(visitor.leave, element);
+		if (isConditionalMapping(mapping)) {
+			direct = conditionalMapping(
+				/** @type {ConditionalMapping} */ (mapping),
+				conditionNames
+			);
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-                continue;
-            }
+			// matching not found
+			if (direct === null) return [];
+		} else {
+			direct = /** @type {DirectMapping} */ (mapping);
+		}
 
-            if (element.node) {
+		const remainingRequest =
+			remainRequestIndex === request.length + 1
+				? undefined
+				: remainRequestIndex < 0
+				? request.slice(-remainRequestIndex - 1)
+				: request.slice(remainRequestIndex);
 
-                ret = this.__execute(visitor.enter, element);
+		return directMapping(
+			remainingRequest,
+			remainRequestIndex < 0,
+			direct,
+			conditionNames,
+			assertTarget
+		);
+	};
+}
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
+/**
+ * @param {string} request request
+ * @returns {string} updated request
+ */
+function assertExportsFieldRequest(request) {
+	if (request.charCodeAt(0) !== dotCode) {
+		throw new Error('Request should be relative path and start with "."');
+	}
+	if (request.length === 1) return "";
+	if (request.charCodeAt(1) !== slashCode) {
+		throw new Error('Request should be relative path and start with "./"');
+	}
+	if (request.charCodeAt(request.length - 1) === slashCode) {
+		throw new Error("Only requesting file allowed");
+	}
 
-                worklist.push(sentinel);
-                leavelist.push(element);
+	return request.slice(2);
+}
 
-                if (this.__state === SKIP || ret === SKIP) {
-                    continue;
-                }
+/**
+ * @param {string} request request
+ * @returns {string} updated request
+ */
+function assertImportsFieldRequest(request) {
+	if (request.charCodeAt(0) !== hashCode) {
+		throw new Error('Request should start with "#"');
+	}
+	if (request.length === 1) {
+		throw new Error("Request should have at least 2 characters");
+	}
+	if (request.charCodeAt(1) === slashCode) {
+		throw new Error('Request should not start with "#/"');
+	}
+	if (request.charCodeAt(request.length - 1) === slashCode) {
+		throw new Error("Only requesting file allowed");
+	}
 
-                node = element.node;
-                nodeType = node.type || element.wrap;
-                candidates = this.__keys[nodeType];
-                if (!candidates) {
-                    if (this.__fallback) {
-                        candidates = this.__fallback(node);
-                    } else {
-                        throw new Error('Unknown node type ' + nodeType + '.');
-                    }
-                }
+	return request.slice(1);
+}
 
-                current = candidates.length;
-                while ((current -= 1) >= 0) {
-                    key = candidates[current];
-                    candidate = node[key];
-                    if (!candidate) {
-                        continue;
-                    }
+/**
+ * @param {string} exp export target
+ * @param {boolean} expectFolder is folder expected
+ */
+function assertExportTarget(exp, expectFolder) {
+	if (
+		exp.charCodeAt(0) === slashCode ||
+		(exp.charCodeAt(0) === dotCode && exp.charCodeAt(1) !== slashCode)
+	) {
+		throw new Error(
+			`Export should be relative path and start with "./", got ${JSON.stringify(
+				exp
+			)}.`
+		);
+	}
 
-                    if (Array.isArray(candidate)) {
-                        current2 = candidate.length;
-                        while ((current2 -= 1) >= 0) {
-                            if (!candidate[current2]) {
-                                continue;
-                            }
-                            if (isProperty(nodeType, candidates[current])) {
-                                element = new Element(candidate[current2], [key, current2], 'Property', null);
-                            } else if (isNode(candidate[current2])) {
-                                element = new Element(candidate[current2], [key, current2], null, null);
-                            } else {
-                                continue;
-                            }
-                            worklist.push(element);
-                        }
-                    } else if (isNode(candidate)) {
-                        worklist.push(new Element(candidate, key, null, null));
-                    }
-                }
-            }
-        }
-    };
+	const isFolder = exp.charCodeAt(exp.length - 1) === slashCode;
 
-    Controller.prototype.replace = function replace(root, visitor) {
-        var worklist,
-            leavelist,
-            node,
-            nodeType,
-            target,
-            element,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel,
-            outer,
-            key;
+	if (isFolder !== expectFolder) {
+		throw new Error(
+			expectFolder
+				? `Expecting folder to folder mapping. ${JSON.stringify(
+						exp
+				  )} should end with "/"`
+				: `Expecting file to file mapping. ${JSON.stringify(
+						exp
+				  )} should not end with "/"`
+		);
+	}
+}
 
-        function removeElem(element) {
-            var i,
-                key,
-                nextElem,
-                parent;
+/**
+ * @param {string} imp import target
+ * @param {boolean} expectFolder is folder expected
+ */
+function assertImportTarget(imp, expectFolder) {
+	const isFolder = imp.charCodeAt(imp.length - 1) === slashCode;
 
-            if (element.ref.remove()) {
-                // When the reference is an element of an array.
-                key = element.ref.key;
-                parent = element.ref.parent;
+	if (isFolder !== expectFolder) {
+		throw new Error(
+			expectFolder
+				? `Expecting folder to folder mapping. ${JSON.stringify(
+						imp
+				  )} should end with "/"`
+				: `Expecting file to file mapping. ${JSON.stringify(
+						imp
+				  )} should not end with "/"`
+		);
+	}
+}
 
-                // If removed from array, then decrease following items' keys.
-                i = worklist.length;
-                while (i--) {
-                    nextElem = worklist[i];
-                    if (nextElem.ref && nextElem.ref.parent === parent) {
-                        if  (nextElem.ref.key < key) {
-                            break;
-                        }
-                        --nextElem.ref.key;
-                    }
-                }
-            }
-        }
+/**
+ * Trying to match request to field
+ * @param {string} request request
+ * @param {PathTreeNode} treeRoot path tree root
+ * @returns {[MappingValue, number]|null} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings
+ */
+function findMatch(request, treeRoot) {
+	if (request.length === 0) {
+		const value = treeRoot.files.get("");
 
-        this.__initialize(root, visitor);
+		return value ? [value, 1] : null;
+	}
 
-        sentinel = {};
+	if (
+		treeRoot.children === null &&
+		treeRoot.folder === null &&
+		treeRoot.wildcards === null
+	) {
+		const value = treeRoot.files.get(request);
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+		return value ? [value, request.length + 1] : null;
+	}
 
-        // initialize
-        outer = {
-            root: root
-        };
-        element = new Element(root, null, null, new Reference(outer, 'root'));
-        worklist.push(element);
-        leavelist.push(element);
+	let node = treeRoot;
+	let lastNonSlashIndex = 0;
+	let slashIndex = request.indexOf("/", 0);
 
-        while (worklist.length) {
-            element = worklist.pop();
+	/** @type {[MappingValue, number]|null} */
+	let lastFolderMatch = null;
 
-            if (element === sentinel) {
-                element = leavelist.pop();
+	const applyFolderMapping = () => {
+		const folderMapping = node.folder;
+		if (folderMapping) {
+			if (lastFolderMatch) {
+				lastFolderMatch[0] = folderMapping;
+				lastFolderMatch[1] = -lastNonSlashIndex - 1;
+			} else {
+				lastFolderMatch = [folderMapping, -lastNonSlashIndex - 1];
+			}
+		}
+	};
 
-                target = this.__execute(visitor.leave, element);
+	const applyWildcardMappings = (wildcardMappings, remainingRequest) => {
+		if (wildcardMappings) {
+			for (const [key, target] of wildcardMappings) {
+				if (remainingRequest.startsWith(key)) {
+					if (!lastFolderMatch) {
+						lastFolderMatch = [target, lastNonSlashIndex + key.length];
+					} else if (lastFolderMatch[1] < lastNonSlashIndex + key.length) {
+						lastFolderMatch[0] = target;
+						lastFolderMatch[1] = lastNonSlashIndex + key.length;
+					}
+				}
+			}
+		}
+	};
 
-                // node may be replaced with null,
-                // so distinguish between undefined and null in this place
-                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                    // replace
-                    element.ref.replace(target);
-                }
+	while (slashIndex !== -1) {
+		applyFolderMapping();
 
-                if (this.__state === REMOVE || target === REMOVE) {
-                    removeElem(element);
-                }
+		const wildcardMappings = node.wildcards;
 
-                if (this.__state === BREAK || target === BREAK) {
-                    return outer.root;
-                }
-                continue;
-            }
+		if (!wildcardMappings && node.children === null) return lastFolderMatch;
 
-            target = this.__execute(visitor.enter, element);
+		const folder = request.slice(lastNonSlashIndex, slashIndex);
 
-            // node may be replaced with null,
-            // so distinguish between undefined and null in this place
-            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                // replace
-                element.ref.replace(target);
-                element.node = target;
-            }
+		applyWildcardMappings(wildcardMappings, folder);
 
-            if (this.__state === REMOVE || target === REMOVE) {
-                removeElem(element);
-                element.node = null;
-            }
+		if (node.children === null) return lastFolderMatch;
 
-            if (this.__state === BREAK || target === BREAK) {
-                return outer.root;
-            }
+		const newNode = node.children.get(folder);
 
-            // node may be null
-            node = element.node;
-            if (!node) {
-                continue;
-            }
+		if (!newNode) {
+			return lastFolderMatch;
+		}
 
-            worklist.push(sentinel);
-            leavelist.push(element);
+		node = newNode;
+		lastNonSlashIndex = slashIndex + 1;
+		slashIndex = request.indexOf("/", lastNonSlashIndex);
+	}
 
-            if (this.__state === SKIP || target === SKIP) {
-                continue;
-            }
+	const remainingRequest =
+		lastNonSlashIndex > 0 ? request.slice(lastNonSlashIndex) : request;
 
-            nodeType = node.type || element.wrap;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-                if (this.__fallback) {
-                    candidates = this.__fallback(node);
-                } else {
-                    throw new Error('Unknown node type ' + nodeType + '.');
-                }
-            }
+	const value = node.files.get(remainingRequest);
 
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-                key = candidates[current];
-                candidate = node[key];
-                if (!candidate) {
-                    continue;
-                }
+	if (value) {
+		return [value, request.length + 1];
+	}
 
-                if (Array.isArray(candidate)) {
-                    current2 = candidate.length;
-                    while ((current2 -= 1) >= 0) {
-                        if (!candidate[current2]) {
-                            continue;
-                        }
-                        if (isProperty(nodeType, candidates[current])) {
-                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
-                        } else if (isNode(candidate[current2])) {
-                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                        } else {
-                            continue;
-                        }
-                        worklist.push(element);
-                    }
-                } else if (isNode(candidate)) {
-                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-                }
-            }
-        }
+	applyFolderMapping();
 
-        return outer.root;
-    };
+	applyWildcardMappings(node.wildcards, remainingRequest);
 
-    function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-    }
+	return lastFolderMatch;
+}
 
-    function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-    }
+/**
+ * @param {ConditionalMapping|DirectMapping|null} mapping mapping
+ * @returns {boolean} is conditional mapping
+ */
+function isConditionalMapping(mapping) {
+	return (
+		mapping !== null && typeof mapping === "object" && !Array.isArray(mapping)
+	);
+}
 
-    function extendCommentRange(comment, tokens) {
-        var target;
+/**
+ * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
+ * @param {boolean} subpathMapping true, for subpath mappings
+ * @param {DirectMapping|null} mappingTarget direct export
+ * @param {Set<string>} conditionNames condition names
+ * @param {(d: string, f: boolean) => void} assert asserting direct value
+ * @returns {string[]} mapping result
+ */
+function directMapping(
+	remainingRequest,
+	subpathMapping,
+	mappingTarget,
+	conditionNames,
+	assert
+) {
+	if (mappingTarget === null) return [];
 
-        target = upperBound(tokens, function search(token) {
-            return token.range[0] > comment.range[0];
-        });
+	if (typeof mappingTarget === "string") {
+		return [
+			targetMapping(remainingRequest, subpathMapping, mappingTarget, assert)
+		];
+	}
 
-        comment.extendedRange = [comment.range[0], comment.range[1]];
+	const targets = [];
 
-        if (target !== tokens.length) {
-            comment.extendedRange[1] = tokens[target].range[0];
-        }
+	for (const exp of mappingTarget) {
+		if (typeof exp === "string") {
+			targets.push(
+				targetMapping(remainingRequest, subpathMapping, exp, assert)
+			);
+			continue;
+		}
 
-        target -= 1;
-        if (target >= 0) {
-            comment.extendedRange[0] = tokens[target].range[1];
-        }
+		const mapping = conditionalMapping(exp, conditionNames);
+		if (!mapping) continue;
+		const innerExports = directMapping(
+			remainingRequest,
+			subpathMapping,
+			mapping,
+			conditionNames,
+			assert
+		);
+		for (const innerExport of innerExports) {
+			targets.push(innerExport);
+		}
+	}
 
-        return comment;
-    }
+	return targets;
+}
 
-    function attachComments(tree, providedComments, tokens) {
-        // At first, we should calculate extended comment ranges.
-        var comments = [], comment, len, i, cursor;
+/**
+ * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
+ * @param {boolean} subpathMapping true, for subpath mappings
+ * @param {string} mappingTarget direct export
+ * @param {(d: string, f: boolean) => void} assert asserting direct value
+ * @returns {string} mapping result
+ */
+function targetMapping(
+	remainingRequest,
+	subpathMapping,
+	mappingTarget,
+	assert
+) {
+	if (remainingRequest === undefined) {
+		assert(mappingTarget, false);
+		return mappingTarget;
+	}
+	if (subpathMapping) {
+		assert(mappingTarget, true);
+		return mappingTarget + remainingRequest;
+	}
+	assert(mappingTarget, false);
+	return mappingTarget.replace(/\*/g, remainingRequest.replace(/\$/g, "$$"));
+}
 
-        if (!tree.range) {
-            throw new Error('attachComments needs range information');
-        }
+/**
+ * @param {ConditionalMapping} conditionalMapping_ conditional mapping
+ * @param {Set<string>} conditionNames condition names
+ * @returns {DirectMapping|null} direct mapping if found
+ */
+function conditionalMapping(conditionalMapping_, conditionNames) {
+	/** @type {[ConditionalMapping, string[], number][]} */
+	let lookup = [[conditionalMapping_, Object.keys(conditionalMapping_), 0]];
 
-        // tokens array is empty, we attach comments to tree as 'leadingComments'
-        if (!tokens.length) {
-            if (providedComments.length) {
-                for (i = 0, len = providedComments.length; i < len; i += 1) {
-                    comment = deepCopy(providedComments[i]);
-                    comment.extendedRange = [0, tree.range[0]];
-                    comments.push(comment);
-                }
-                tree.leadingComments = comments;
-            }
-            return tree;
-        }
+	loop: while (lookup.length > 0) {
+		const [mapping, conditions, j] = lookup[lookup.length - 1];
+		const last = conditions.length - 1;
 
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
+		for (let i = j; i < conditions.length; i++) {
+			const condition = conditions[i];
 
-        // This is based on John Freeman's implementation.
-        cursor = 0;
-        traverse(tree, {
-            enter: function (node) {
-                var comment;
+			// assert default. Could be last only
+			if (i !== last) {
+				if (condition === "default") {
+					throw new Error("Default condition should be last one");
+				}
+			} else if (condition === "default") {
+				const innerMapping = mapping[condition];
+				// is nested
+				if (isConditionalMapping(innerMapping)) {
+					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
+					lookup[lookup.length - 1][2] = i + 1;
+					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
+					continue loop;
+				}
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (comment.extendedRange[1] > node.range[0]) {
-                        break;
-                    }
+				return /** @type {DirectMapping} */ (innerMapping);
+			}
 
-                    if (comment.extendedRange[1] === node.range[0]) {
-                        if (!node.leadingComments) {
-                            node.leadingComments = [];
-                        }
-                        node.leadingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
+			if (conditionNames.has(condition)) {
+				const innerMapping = mapping[condition];
+				// is nested
+				if (isConditionalMapping(innerMapping)) {
+					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
+					lookup[lookup.length - 1][2] = i + 1;
+					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
+					continue loop;
+				}
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+				return /** @type {DirectMapping} */ (innerMapping);
+			}
+		}
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+		lookup.pop();
+	}
 
-        cursor = 0;
-        traverse(tree, {
-            leave: function (node) {
-                var comment;
+	return null;
+}
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (node.range[1] < comment.extendedRange[0]) {
-                        break;
-                    }
+/**
+ * Internal helper to create path tree node
+ * to ensure that each node gets the same hidden class
+ * @returns {PathTreeNode} node
+ */
+function createNode() {
+	return {
+		children: null,
+		folder: null,
+		wildcards: null,
+		files: new Map()
+	};
+}
 
-                    if (node.range[1] === comment.extendedRange[0]) {
-                        if (!node.trailingComments) {
-                            node.trailingComments = [];
-                        }
-                        node.trailingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
+/**
+ * Internal helper for building path tree
+ * @param {PathTreeNode} root root
+ * @param {string} path path
+ * @param {MappingValue} target target
+ */
+function walkPath(root, path, target) {
+	if (path.length === 0) {
+		root.folder = target;
+		return;
+	}
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+	let node = root;
+	// Typical path tree can looks like
+	// root
+	// - files: ["a.js", "b.js"]
+	// - children:
+	//    node1:
+	//    - files: ["a.js", "b.js"]
+	let lastNonSlashIndex = 0;
+	let slashIndex = path.indexOf("/", 0);
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+	while (slashIndex !== -1) {
+		const folder = path.slice(lastNonSlashIndex, slashIndex);
+		let newNode;
 
-        return tree;
-    }
+		if (node.children === null) {
+			newNode = createNode();
+			node.children = new Map();
+			node.children.set(folder, newNode);
+		} else {
+			newNode = node.children.get(folder);
 
-    exports.version = (__webpack_require__(15535)/* .version */ .i8);
-    exports.Syntax = Syntax;
-    exports.traverse = traverse;
-    exports.replace = replace;
-    exports.attachComments = attachComments;
-    exports.VisitorKeys = VisitorKeys;
-    exports.VisitorOption = VisitorOption;
-    exports.Controller = Controller;
-    exports.cloneEnvironment = function () { return clone({}); };
+			if (!newNode) {
+				newNode = createNode();
+				node.children.set(folder, newNode);
+			}
+		}
 
-    return exports;
-}(exports));
-/* vim: set sw=4 ts=4 et tw=80 : */
+		node = newNode;
+		lastNonSlashIndex = slashIndex + 1;
+		slashIndex = path.indexOf("/", lastNonSlashIndex);
+	}
 
+	if (lastNonSlashIndex >= path.length) {
+		node.folder = target;
+	} else {
+		const file = lastNonSlashIndex > 0 ? path.slice(lastNonSlashIndex) : path;
+		if (file.endsWith("*")) {
+			if (node.wildcards === null) node.wildcards = new Map();
+			node.wildcards.set(file.slice(0, -1), target);
+		} else {
+			node.files.set(file, target);
+		}
+	}
+}
 
-/***/ }),
+/**
+ * @param {ExportsField} field exports field
+ * @returns {PathTreeNode} tree root
+ */
+function buildExportsFieldPathTree(field) {
+	const root = createNode();
 
-/***/ 86140:
-/***/ (function(module) {
+	// handle syntax sugar, if exports field is direct mapping for "."
+	if (typeof field === "string") {
+		root.files.set("", field);
 
-module.exports = function (glob, opts) {
-  if (typeof glob !== 'string') {
-    throw new TypeError('Expected a string');
-  }
+		return root;
+	} else if (Array.isArray(field)) {
+		root.files.set("", field.slice());
 
-  var str = String(glob);
+		return root;
+	}
 
-  // The regexp we are building, as a string.
-  var reStr = "";
+	const keys = Object.keys(field);
 
-  // Whether we are matching so called "extended" globs (like bash) and should
-  // support single character matching, matching ranges of characters, group
-  // matching, etc.
-  var extended = opts ? !!opts.extended : false;
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
 
-  // When globstar is _false_ (default), '/foo/*' is translated a regexp like
-  // '^\/foo\/.*$' which will match any string beginning with '/foo/'
-  // When globstar is _true_, '/foo/*' is translated to regexp like
-  // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
-  // which does not have a '/' to the right of it.
-  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
-  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
-  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
-  // globstar is _false_
-  var globstar = opts ? !!opts.globstar : false;
+		if (key.charCodeAt(0) !== dotCode) {
+			// handle syntax sugar, if exports field is conditional mapping for "."
+			if (i === 0) {
+				while (i < keys.length) {
+					const charCode = keys[i].charCodeAt(0);
+					if (charCode === dotCode || charCode === slashCode) {
+						throw new Error(
+							`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
+								key
+							)})`
+						);
+					}
+					i++;
+				}
 
-  // If we are doing extended matching, this boolean is true when we are inside
-  // a group (eg {*.html,*.js}), and false otherwise.
-  var inGroup = false;
+				root.files.set("", field);
+				return root;
+			}
 
-  // RegExp flags (eg "i" ) to pass in to RegExp constructor.
-  var flags = opts && typeof( opts.flags ) === "string" ? opts.flags : "";
+			throw new Error(
+				`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-  var c;
-  for (var i = 0, len = str.length; i < len; i++) {
-    c = str[i];
+		if (key.length === 1) {
+			root.files.set("", field[key]);
+			continue;
+		}
 
-    switch (c) {
-    case "/":
-    case "$":
-    case "^":
-    case "+":
-    case ".":
-    case "(":
-    case ")":
-    case "=":
-    case "!":
-    case "|":
-      reStr += "\\" + c;
-      break;
+		if (key.charCodeAt(1) !== slashCode) {
+			throw new Error(
+				`Exports field key should be relative path and start with "./" (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-    case "?":
-      if (extended) {
-        reStr += ".";
-	    break;
-      }
+		walkPath(root, key.slice(2), field[key]);
+	}
 
-    case "[":
-    case "]":
-      if (extended) {
-        reStr += c;
-	    break;
-      }
+	return root;
+}
 
-    case "{":
-      if (extended) {
-        inGroup = true;
-	    reStr += "(";
-	    break;
-      }
+/**
+ * @param {ImportsField} field imports field
+ * @returns {PathTreeNode} root
+ */
+function buildImportsFieldPathTree(field) {
+	const root = createNode();
 
-    case "}":
-      if (extended) {
-        inGroup = false;
-	    reStr += ")";
-	    break;
-      }
+	const keys = Object.keys(field);
 
-    case ",":
-      if (inGroup) {
-        reStr += "|";
-	    break;
-      }
-      reStr += "\\" + c;
-      break;
-
-    case "*":
-      // Move over all consecutive "*"'s.
-      // Also store the previous and next characters
-      var prevChar = str[i - 1];
-      var starCount = 1;
-      while(str[i + 1] === "*") {
-        starCount++;
-        i++;
-      }
-      var nextChar = str[i + 1];
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
 
-      if (!globstar) {
-        // globstar is disabled, so treat any number of "*" as one
-        reStr += ".*";
-      } else {
-        // globstar is enabled, so determine if this is a globstar segment
-        var isGlobstar = starCount > 1                      // multiple "*"'s
-          && (prevChar === "/" || prevChar === undefined)   // from the start of the segment
-          && (nextChar === "/" || nextChar === undefined)   // to the end of the segment
+		if (key.charCodeAt(0) !== hashCode) {
+			throw new Error(
+				`Imports field key should start with "#" (key: ${JSON.stringify(key)})`
+			);
+		}
 
-        if (isGlobstar) {
-          // it's a globstar, so match zero or more path segments
-          reStr += "((?:[^/]*(?:\/|$))*)";
-          i++; // move over the "/"
-        } else {
-          // it's not a globstar, so only match one path segment
-          reStr += "([^/]*)";
-        }
-      }
-      break;
+		if (key.length === 1) {
+			throw new Error(
+				`Imports field key should have at least 2 characters (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-    default:
-      reStr += c;
-    }
-  }
+		if (key.charCodeAt(1) === slashCode) {
+			throw new Error(
+				`Imports field key should not start with "#/" (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-  // When regexp 'g' flag is specified don't
-  // constrain the regular expression with ^ & $
-  if (!flags || !~flags.indexOf('g')) {
-    reStr = "^" + reStr + "$";
-  }
+		walkPath(root, key.slice(1), field[key]);
+	}
 
-  return new RegExp(reStr, flags);
-};
+	return root;
+}
 
 
 /***/ }),
 
-/***/ 89132:
+/***/ 7780:
 /***/ (function(module) {
 
 "use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
 
-module.exports = clone
-
-var getPrototypeOf = Object.getPrototypeOf || function (obj) {
-  return obj.__proto__
-}
 
-function clone (obj) {
-  if (obj === null || typeof obj !== 'object')
-    return obj
+const PATH_QUERY_FRAGMENT_REGEXP = /^(#?(?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
-  if (obj instanceof Object)
-    var copy = { __proto__: getPrototypeOf(obj) }
-  else
-    var copy = Object.create(null)
+/**
+ * @param {string} identifier identifier
+ * @returns {[string, string, string]|null} parsed identifier
+ */
+function parseIdentifier(identifier) {
+	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier);
 
-  Object.getOwnPropertyNames(obj).forEach(function (key) {
-    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
-  })
+	if (!match) return null;
 
-  return copy
+	return [
+		match[1].replace(/\0(.)/g, "$1"),
+		match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		match[3] || ""
+	];
 }
 
+module.exports.parseIdentifier = parseIdentifier;
+
 
 /***/ }),
 
-/***/ 90552:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 3011:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-var fs = __webpack_require__(57147)
-var polyfills = __webpack_require__(11290)
-var legacy = __webpack_require__(54410)
-var clone = __webpack_require__(89132)
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-var util = __webpack_require__(73837)
 
-/* istanbul ignore next - node 0.x polyfill */
-var gracefulQueue
-var previousSymbol
 
-/* istanbul ignore else - node 0.x polyfill */
-if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
-  gracefulQueue = Symbol.for('graceful-fs.queue')
-  // This is used in testing by future versions
-  previousSymbol = Symbol.for('graceful-fs.previous')
-} else {
-  gracefulQueue = '___graceful-fs.queue'
-  previousSymbol = '___graceful-fs.previous'
-}
+const path = __webpack_require__(71017);
 
-function noop () {}
+const CHAR_HASH = "#".charCodeAt(0);
+const CHAR_SLASH = "/".charCodeAt(0);
+const CHAR_BACKSLASH = "\\".charCodeAt(0);
+const CHAR_A = "A".charCodeAt(0);
+const CHAR_Z = "Z".charCodeAt(0);
+const CHAR_LOWER_A = "a".charCodeAt(0);
+const CHAR_LOWER_Z = "z".charCodeAt(0);
+const CHAR_DOT = ".".charCodeAt(0);
+const CHAR_COLON = ":".charCodeAt(0);
 
-function publishQueue(context, queue) {
-  Object.defineProperty(context, gracefulQueue, {
-    get: function() {
-      return queue
-    }
-  })
-}
+const posixNormalize = path.posix.normalize;
+const winNormalize = path.win32.normalize;
 
-var debug = noop
-if (util.debuglog)
-  debug = util.debuglog('gfs4')
-else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
-  debug = function() {
-    var m = util.format.apply(util, arguments)
-    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
-    console.error(m)
-  }
+/**
+ * @enum {number}
+ */
+const PathType = Object.freeze({
+	Empty: 0,
+	Normal: 1,
+	Relative: 2,
+	AbsoluteWin: 3,
+	AbsolutePosix: 4,
+	Internal: 5
+});
+exports.PathType = PathType;
 
-// Once time initialization
-if (!fs[gracefulQueue]) {
-  // This queue can be shared by multiple loaded instances
-  var queue = global[gracefulQueue] || []
-  publishQueue(fs, queue)
+/**
+ * @param {string} p a path
+ * @returns {PathType} type of path
+ */
+const getType = p => {
+	switch (p.length) {
+		case 0:
+			return PathType.Empty;
+		case 1: {
+			const c0 = p.charCodeAt(0);
+			switch (c0) {
+				case CHAR_DOT:
+					return PathType.Relative;
+				case CHAR_SLASH:
+					return PathType.AbsolutePosix;
+				case CHAR_HASH:
+					return PathType.Internal;
+			}
+			return PathType.Normal;
+		}
+		case 2: {
+			const c0 = p.charCodeAt(0);
+			switch (c0) {
+				case CHAR_DOT: {
+					const c1 = p.charCodeAt(1);
+					switch (c1) {
+						case CHAR_DOT:
+						case CHAR_SLASH:
+							return PathType.Relative;
+					}
+					return PathType.Normal;
+				}
+				case CHAR_SLASH:
+					return PathType.AbsolutePosix;
+				case CHAR_HASH:
+					return PathType.Internal;
+			}
+			const c1 = p.charCodeAt(1);
+			if (c1 === CHAR_COLON) {
+				if (
+					(c0 >= CHAR_A && c0 <= CHAR_Z) ||
+					(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)
+				) {
+					return PathType.AbsoluteWin;
+				}
+			}
+			return PathType.Normal;
+		}
+	}
+	const c0 = p.charCodeAt(0);
+	switch (c0) {
+		case CHAR_DOT: {
+			const c1 = p.charCodeAt(1);
+			switch (c1) {
+				case CHAR_SLASH:
+					return PathType.Relative;
+				case CHAR_DOT: {
+					const c2 = p.charCodeAt(2);
+					if (c2 === CHAR_SLASH) return PathType.Relative;
+					return PathType.Normal;
+				}
+			}
+			return PathType.Normal;
+		}
+		case CHAR_SLASH:
+			return PathType.AbsolutePosix;
+		case CHAR_HASH:
+			return PathType.Internal;
+	}
+	const c1 = p.charCodeAt(1);
+	if (c1 === CHAR_COLON) {
+		const c2 = p.charCodeAt(2);
+		if (
+			(c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) &&
+			((c0 >= CHAR_A && c0 <= CHAR_Z) ||
+				(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z))
+		) {
+			return PathType.AbsoluteWin;
+		}
+	}
+	return PathType.Normal;
+};
+exports.getType = getType;
 
-  // Patch fs.close/closeSync to shared queue version, because we need
-  // to retry() whenever a close happens *anywhere* in the program.
-  // This is essential when multiple graceful-fs instances are
-  // in play at the same time.
-  fs.close = (function (fs$close) {
-    function close (fd, cb) {
-      return fs$close.call(fs, fd, function (err) {
-        // This function uses the graceful-fs shared queue
-        if (!err) {
-          resetQueue()
-        }
+/**
+ * @param {string} p a path
+ * @returns {string} the normalized path
+ */
+const normalize = p => {
+	switch (getType(p)) {
+		case PathType.Empty:
+			return p;
+		case PathType.AbsoluteWin:
+			return winNormalize(p);
+		case PathType.Relative: {
+			const r = posixNormalize(p);
+			return getType(r) === PathType.Relative ? r : `./${r}`;
+		}
+	}
+	return posixNormalize(p);
+};
+exports.normalize = normalize;
 
-        if (typeof cb === 'function')
-          cb.apply(this, arguments)
-      })
-    }
+/**
+ * @param {string} rootPath the root path
+ * @param {string | undefined} request the request path
+ * @returns {string} the joined path
+ */
+const join = (rootPath, request) => {
+	if (!request) return normalize(rootPath);
+	const requestType = getType(request);
+	switch (requestType) {
+		case PathType.AbsolutePosix:
+			return posixNormalize(request);
+		case PathType.AbsoluteWin:
+			return winNormalize(request);
+	}
+	switch (getType(rootPath)) {
+		case PathType.Normal:
+		case PathType.Relative:
+		case PathType.AbsolutePosix:
+			return posixNormalize(`${rootPath}/${request}`);
+		case PathType.AbsoluteWin:
+			return winNormalize(`${rootPath}\\${request}`);
+	}
+	switch (requestType) {
+		case PathType.Empty:
+			return rootPath;
+		case PathType.Relative: {
+			const r = posixNormalize(rootPath);
+			return getType(r) === PathType.Relative ? r : `./${r}`;
+		}
+	}
+	return posixNormalize(rootPath);
+};
+exports.join = join;
 
-    Object.defineProperty(close, previousSymbol, {
-      value: fs$close
-    })
-    return close
-  })(fs.close)
+const joinCache = new Map();
 
-  fs.closeSync = (function (fs$closeSync) {
-    function closeSync (fd) {
-      // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs, arguments)
-      resetQueue()
-    }
+/**
+ * @param {string} rootPath the root path
+ * @param {string | undefined} request the request path
+ * @returns {string} the joined path
+ */
+const cachedJoin = (rootPath, request) => {
+	let cacheEntry;
+	let cache = joinCache.get(rootPath);
+	if (cache === undefined) {
+		joinCache.set(rootPath, (cache = new Map()));
+	} else {
+		cacheEntry = cache.get(request);
+		if (cacheEntry !== undefined) return cacheEntry;
+	}
+	cacheEntry = join(rootPath, request);
+	cache.set(request, cacheEntry);
+	return cacheEntry;
+};
+exports.cachedJoin = cachedJoin;
 
-    Object.defineProperty(closeSync, previousSymbol, {
-      value: fs$closeSync
-    })
-    return closeSync
-  })(fs.closeSync)
+const checkExportsFieldTarget = relativePath => {
+	let lastNonSlashIndex = 2;
+	let slashIndex = relativePath.indexOf("/", 2);
+	let cd = 0;
 
-  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
-    process.on('exit', function() {
-      debug(fs[gracefulQueue])
-      __webpack_require__(39491).equal(fs[gracefulQueue].length, 0)
-    })
-  }
-}
+	while (slashIndex !== -1) {
+		const folder = relativePath.slice(lastNonSlashIndex, slashIndex);
 
-if (!global[gracefulQueue]) {
-  publishQueue(global, fs[gracefulQueue]);
-}
+		switch (folder) {
+			case "..": {
+				cd--;
+				if (cd < 0)
+					return new Error(
+						`Trying to access out of package scope. Requesting ${relativePath}`
+					);
+				break;
+			}
+			default:
+				cd++;
+				break;
+		}
 
-module.exports = patch(clone(fs))
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-    module.exports = patch(fs)
-    fs.__patched = true;
-}
+		lastNonSlashIndex = slashIndex + 1;
+		slashIndex = relativePath.indexOf("/", lastNonSlashIndex);
+	}
+};
+exports.checkExportsFieldTarget = checkExportsFieldTarget;
 
-function patch (fs) {
-  // Everything that references the open() function needs to be in here
-  polyfills(fs)
-  fs.gracefulify = patch
 
-  fs.createReadStream = createReadStream
-  fs.createWriteStream = createWriteStream
-  var fs$readFile = fs.readFile
-  fs.readFile = readFile
-  function readFile (path, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+/***/ }),
 
-    return go$readFile(path, options, cb)
+/***/ 70665:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    function go$readFile (path, options, cb, startTime) {
-      return fs$readFile(path, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+"use strict";
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-  var fs$writeFile = fs.writeFile
-  fs.writeFile = writeFile
-  function writeFile (path, data, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-    return go$writeFile(path, data, options, cb)
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-    function go$writeFile (path, data, options, cb, startTime) {
-      return fs$writeFile(path, data, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-  var fs$appendFile = fs.appendFile
-  if (fs$appendFile)
-    fs.appendFile = appendFile
-  function appendFile (path, data, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
 
-    return go$appendFile(path, data, options, cb)
+const Variable = __webpack_require__(82971);
 
-    function go$appendFile (path, data, options, cb, startTime) {
-      return fs$appendFile(path, data, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+/**
+ * @class Definition
+ */
+class Definition {
+    constructor(type, name, node, parent, index, kind) {
 
-  var fs$copyFile = fs.copyFile
-  if (fs$copyFile)
-    fs.copyFile = copyFile
-  function copyFile (src, dest, flags, cb) {
-    if (typeof flags === 'function') {
-      cb = flags
-      flags = 0
-    }
-    return go$copyFile(src, dest, flags, cb)
+        /**
+         * @member {String} Definition#type - type of the occurrence (e.g. "Parameter", "Variable", ...).
+         */
+        this.type = type;
 
-    function go$copyFile (src, dest, flags, cb, startTime) {
-      return fs$copyFile(src, dest, flags, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+        /**
+         * @member {espree.Identifier} Definition#name - the identifier AST node of the occurrence.
+         */
+        this.name = name;
 
-  var fs$readdir = fs.readdir
-  fs.readdir = readdir
-  function readdir (path, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+        /**
+         * @member {espree.Node} Definition#node - the enclosing node of the identifier.
+         */
+        this.node = node;
 
-    return go$readdir(path, options, cb)
+        /**
+         * @member {espree.Node?} Definition#parent - the enclosing statement node of the identifier.
+         */
+        this.parent = parent;
 
-    function go$readdir (path, options, cb, startTime) {
-      return fs$readdir(path, options, function (err, files) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (files && files.sort)
-            files.sort()
+        /**
+         * @member {Number?} Definition#index - the index in the declaration statement.
+         */
+        this.index = index;
 
-          if (typeof cb === 'function')
-            cb.call(this, err, files)
-        }
-      })
+        /**
+         * @member {String?} Definition#kind - the kind of the declaration statement.
+         */
+        this.kind = kind;
     }
-  }
+}
 
-  if (process.version.substr(0, 4) === 'v0.8') {
-    var legStreams = legacy(fs)
-    ReadStream = legStreams.ReadStream
-    WriteStream = legStreams.WriteStream
-  }
+/**
+ * @class ParameterDefinition
+ */
+class ParameterDefinition extends Definition {
+    constructor(name, node, index, rest) {
+        super(Variable.Parameter, name, node, null, index, null);
 
-  var fs$ReadStream = fs.ReadStream
-  if (fs$ReadStream) {
-    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
-    ReadStream.prototype.open = ReadStream$open
-  }
+        /**
+         * Whether the parameter definition is a part of a rest parameter.
+         * @member {boolean} ParameterDefinition#rest
+         */
+        this.rest = rest;
+    }
+}
 
-  var fs$WriteStream = fs.WriteStream
-  if (fs$WriteStream) {
-    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
-    WriteStream.prototype.open = WriteStream$open
-  }
+module.exports = {
+    ParameterDefinition,
+    Definition
+};
 
-  Object.defineProperty(fs, 'ReadStream', {
-    get: function () {
-      return ReadStream
-    },
-    set: function (val) {
-      ReadStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
-  Object.defineProperty(fs, 'WriteStream', {
-    get: function () {
-      return WriteStream
-    },
-    set: function (val) {
-      WriteStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-  // legacy names
-  var FileReadStream = ReadStream
-  Object.defineProperty(fs, 'FileReadStream', {
-    get: function () {
-      return FileReadStream
-    },
-    set: function (val) {
-      FileReadStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
-  var FileWriteStream = WriteStream
-  Object.defineProperty(fs, 'FileWriteStream', {
-    get: function () {
-      return FileWriteStream
-    },
-    set: function (val) {
-      FileWriteStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
 
-  function ReadStream (path, options) {
-    if (this instanceof ReadStream)
-      return fs$ReadStream.apply(this, arguments), this
-    else
-      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
-  }
+/***/ }),
 
-  function ReadStream$open () {
-    var that = this
-    open(that.path, that.flags, that.mode, function (err, fd) {
-      if (err) {
-        if (that.autoClose)
-          that.destroy()
+/***/ 36007:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        that.emit('error', err)
-      } else {
-        that.fd = fd
-        that.emit('open', fd)
-        that.read()
-      }
-    })
-  }
+"use strict";
+/*
+  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2013 Alex Seville <hi@alexanderseville.com>
+  Copyright (C) 2014 Thiago de Arruda <tpadilha84@gmail.com>
 
-  function WriteStream (path, options) {
-    if (this instanceof WriteStream)
-      return fs$WriteStream.apply(this, arguments), this
-    else
-      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
-  }
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-  function WriteStream$open () {
-    var that = this
-    open(that.path, that.flags, that.mode, function (err, fd) {
-      if (err) {
-        that.destroy()
-        that.emit('error', err)
-      } else {
-        that.fd = fd
-        that.emit('open', fd)
-      }
-    })
-  }
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-  function createReadStream (path, options) {
-    return new fs.ReadStream(path, options)
-  }
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-  function createWriteStream (path, options) {
-    return new fs.WriteStream(path, options)
-  }
+/**
+ * Escope (<a href="http://github.com/estools/escope">escope</a>) is an <a
+ * href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript</a>
+ * scope analyzer extracted from the <a
+ * href="http://github.com/estools/esmangle">esmangle project</a/>.
+ * <p>
+ * <em>escope</em> finds lexical scopes in a source program, i.e. areas of that
+ * program where different occurrences of the same identifier refer to the same
+ * variable. With each scope the contained variables are collected, and each
+ * identifier reference in code is linked to its corresponding variable (if
+ * possible).
+ * <p>
+ * <em>escope</em> works on a syntax tree of the parsed source code which has
+ * to adhere to the <a
+ * href="https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API">
+ * Mozilla Parser API</a>. E.g. <a href="https://github.com/eslint/espree">espree</a> is a parser
+ * that produces such syntax trees.
+ * <p>
+ * The main interface is the {@link analyze} function.
+ * @module escope
+ */
 
-  var fs$open = fs.open
-  fs.open = open
-  function open (path, flags, mode, cb) {
-    if (typeof mode === 'function')
-      cb = mode, mode = null
 
-    return go$open(path, flags, mode, cb)
+/* eslint no-underscore-dangle: ["error", { "allow": ["__currentScope"] }] */
 
-    function go$open (path, flags, mode, cb, startTime) {
-      return fs$open(path, flags, mode, function (err, fd) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+const assert = __webpack_require__(39491);
 
-  return fs
-}
+const ScopeManager = __webpack_require__(96988);
+const Referencer = __webpack_require__(44585);
+const Reference = __webpack_require__(64945);
+const Variable = __webpack_require__(82971);
+const Scope = (__webpack_require__(16313).Scope);
+const version = (__webpack_require__(30290)/* .version */ .i8);
 
-function enqueue (elem) {
-  debug('ENQUEUE', elem[0].name, elem[1])
-  fs[gracefulQueue].push(elem)
-  retry()
+/**
+ * Set the default options
+ * @returns {Object} options
+ */
+function defaultOptions() {
+    return {
+        optimistic: false,
+        directive: false,
+        nodejsScope: false,
+        impliedStrict: false,
+        sourceType: "script", // one of ['script', 'module']
+        ecmaVersion: 5,
+        childVisitorKeys: null,
+        fallback: "iteration"
+    };
 }
 
-// keep track of the timeout between retry() calls
-var retryTimer
+/**
+ * Preform deep update on option object
+ * @param {Object} target - Options
+ * @param {Object} override - Updates
+ * @returns {Object} Updated options
+ */
+function updateDeeply(target, override) {
 
-// reset the startTime and lastTime to now
-// this resets the start of the 60 second overall timeout as well as the
-// delay between attempts so that we'll retry these jobs sooner
-function resetQueue () {
-  var now = Date.now()
-  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
-    // entries that are only a length of 2 are from an older version, don't
-    // bother modifying those since they'll be retried anyway.
-    if (fs[gracefulQueue][i].length > 2) {
-      fs[gracefulQueue][i][3] = now // startTime
-      fs[gracefulQueue][i][4] = now // lastTime
+    /**
+     * Is hash object
+     * @param {Object} value - Test value
+     * @returns {boolean} Result
+     */
+    function isHashObject(value) {
+        return typeof value === "object" && value instanceof Object && !(value instanceof Array) && !(value instanceof RegExp);
     }
-  }
-  // call retry to make sure we're actively processing the queue
-  retry()
-}
-
-function retry () {
-  // clear the timer and remove it to help prevent unintended concurrency
-  clearTimeout(retryTimer)
-  retryTimer = undefined
-
-  if (fs[gracefulQueue].length === 0)
-    return
 
-  var elem = fs[gracefulQueue].shift()
-  var fn = elem[0]
-  var args = elem[1]
-  // these items may be unset if they were added by an older graceful-fs
-  var err = elem[2]
-  var startTime = elem[3]
-  var lastTime = elem[4]
+    for (const key in override) {
+        if (Object.prototype.hasOwnProperty.call(override, key)) {
+            const val = override[key];
 
-  // if we don't have a startTime we have no way of knowing if we've waited
-  // long enough, so go ahead and retry this item now
-  if (startTime === undefined) {
-    debug('RETRY', fn.name, args)
-    fn.apply(null, args)
-  } else if (Date.now() - startTime >= 60000) {
-    // it's been more than 60 seconds total, bail now
-    debug('TIMEOUT', fn.name, args)
-    var cb = args.pop()
-    if (typeof cb === 'function')
-      cb.call(null, err)
-  } else {
-    // the amount of time between the last attempt and right now
-    var sinceAttempt = Date.now() - lastTime
-    // the amount of time between when we first tried, and when we last tried
-    // rounded up to at least 1
-    var sinceStart = Math.max(lastTime - startTime, 1)
-    // backoff. wait longer than the total time we've been retrying, but only
-    // up to a maximum of 100ms
-    var desiredDelay = Math.min(sinceStart * 1.2, 100)
-    // it's been long enough since the last retry, do it again
-    if (sinceAttempt >= desiredDelay) {
-      debug('RETRY', fn.name, args)
-      fn.apply(null, args.concat([startTime]))
-    } else {
-      // if we can't do this job yet, push it to the end of the queue
-      // and let the next iteration check again
-      fs[gracefulQueue].push(elem)
+            if (isHashObject(val)) {
+                if (isHashObject(target[key])) {
+                    updateDeeply(target[key], val);
+                } else {
+                    target[key] = updateDeeply({}, val);
+                }
+            } else {
+                target[key] = val;
+            }
+        }
     }
-  }
-
-  // schedule our next run if one isn't already scheduled
-  if (retryTimer === undefined) {
-    retryTimer = setTimeout(retry, 0)
-  }
+    return target;
 }
 
+/**
+ * Main interface function. Takes an Espree syntax tree and returns the
+ * analyzed scopes.
+ * @function analyze
+ * @param {espree.Tree} tree - Abstract Syntax Tree
+ * @param {Object} providedOptions - Options that tailor the scope analysis
+ * @param {boolean} [providedOptions.optimistic=false] - the optimistic flag
+ * @param {boolean} [providedOptions.directive=false]- the directive flag
+ * @param {boolean} [providedOptions.ignoreEval=false]- whether to check 'eval()' calls
+ * @param {boolean} [providedOptions.nodejsScope=false]- whether the whole
+ * script is executed under node.js environment. When enabled, escope adds
+ * a function scope immediately following the global scope.
+ * @param {boolean} [providedOptions.impliedStrict=false]- implied strict mode
+ * (if ecmaVersion >= 5).
+ * @param {string} [providedOptions.sourceType='script']- the source type of the script. one of 'script' and 'module'
+ * @param {number} [providedOptions.ecmaVersion=5]- which ECMAScript version is considered
+ * @param {Object} [providedOptions.childVisitorKeys=null] - Additional known visitor keys. See [esrecurse](https://github.com/estools/esrecurse)'s the `childVisitorKeys` option.
+ * @param {string} [providedOptions.fallback='iteration'] - A kind of the fallback in order to encounter with unknown node. See [esrecurse](https://github.com/estools/esrecurse)'s the `fallback` option.
+ * @returns {ScopeManager} ScopeManager
+ */
+function analyze(tree, providedOptions) {
+    const options = updateDeeply(defaultOptions(), providedOptions);
+    const scopeManager = new ScopeManager(options);
+    const referencer = new Referencer(options, scopeManager);
 
-/***/ }),
+    referencer.visit(tree);
 
-/***/ 54410:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    assert(scopeManager.__currentScope === null, "currentScope should be null.");
 
-var Stream = (__webpack_require__(12781).Stream)
+    return scopeManager;
+}
 
-module.exports = legacy
+module.exports = {
 
-function legacy (fs) {
-  return {
-    ReadStream: ReadStream,
-    WriteStream: WriteStream
-  }
+    /** @name module:escope.version */
+    version,
 
-  function ReadStream (path, options) {
-    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+    /** @name module:escope.Reference */
+    Reference,
 
-    Stream.call(this);
+    /** @name module:escope.Variable */
+    Variable,
 
-    var self = this;
+    /** @name module:escope.Scope */
+    Scope,
 
-    this.path = path;
-    this.fd = null;
-    this.readable = true;
-    this.paused = false;
+    /** @name module:escope.ScopeManager */
+    ScopeManager,
+    analyze
+};
 
-    this.flags = 'r';
-    this.mode = 438; /*=0666*/
-    this.bufferSize = 64 * 1024;
 
-    options = options || {};
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-    // Mixin options into this
-    var keys = Object.keys(options);
-    for (var index = 0, length = keys.length; index < length; index++) {
-      var key = keys[index];
-      this[key] = options[key];
-    }
 
-    if (this.encoding) this.setEncoding(this.encoding);
+/***/ }),
 
-    if (this.start !== undefined) {
-      if ('number' !== typeof this.start) {
-        throw TypeError('start must be a Number');
-      }
-      if (this.end === undefined) {
-        this.end = Infinity;
-      } else if ('number' !== typeof this.end) {
-        throw TypeError('end must be a Number');
-      }
+/***/ 54162:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-      if (this.start > this.end) {
-        throw new Error('start must be <= end');
-      }
+"use strict";
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-      this.pos = this.start;
-    }
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-    if (this.fd !== null) {
-      process.nextTick(function() {
-        self._read();
-      });
-      return;
-    }
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-    fs.open(this.path, this.flags, this.mode, function (err, fd) {
-      if (err) {
-        self.emit('error', err);
-        self.readable = false;
-        return;
-      }
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-      self.fd = fd;
-      self.emit('open', fd);
-      self._read();
-    })
-  }
 
-  function WriteStream (path, options) {
-    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+/* eslint-disable no-undefined */
 
-    Stream.call(this);
+const Syntax = (__webpack_require__(18350).Syntax);
+const esrecurse = __webpack_require__(81217);
 
-    this.path = path;
-    this.fd = null;
-    this.writable = true;
+/**
+ * Get last array element
+ * @param {array} xs - array
+ * @returns {any} Last elment
+ */
+function getLast(xs) {
+    return xs[xs.length - 1] || null;
+}
 
-    this.flags = 'w';
-    this.encoding = 'binary';
-    this.mode = 438; /*=0666*/
-    this.bytesWritten = 0;
+class PatternVisitor extends esrecurse.Visitor {
+    static isPattern(node) {
+        const nodeType = node.type;
 
-    options = options || {};
+        return (
+            nodeType === Syntax.Identifier ||
+            nodeType === Syntax.ObjectPattern ||
+            nodeType === Syntax.ArrayPattern ||
+            nodeType === Syntax.SpreadElement ||
+            nodeType === Syntax.RestElement ||
+            nodeType === Syntax.AssignmentPattern
+        );
+    }
 
-    // Mixin options into this
-    var keys = Object.keys(options);
-    for (var index = 0, length = keys.length; index < length; index++) {
-      var key = keys[index];
-      this[key] = options[key];
+    constructor(options, rootPattern, callback) {
+        super(null, options);
+        this.rootPattern = rootPattern;
+        this.callback = callback;
+        this.assignments = [];
+        this.rightHandNodes = [];
+        this.restElements = [];
     }
 
-    if (this.start !== undefined) {
-      if ('number' !== typeof this.start) {
-        throw TypeError('start must be a Number');
-      }
-      if (this.start < 0) {
-        throw new Error('start must be >= zero');
-      }
+    Identifier(pattern) {
+        const lastRestElement = getLast(this.restElements);
 
-      this.pos = this.start;
+        this.callback(pattern, {
+            topLevel: pattern === this.rootPattern,
+            rest: lastRestElement !== null && lastRestElement !== undefined && lastRestElement.argument === pattern,
+            assignments: this.assignments
+        });
     }
 
-    this.busy = false;
-    this._queue = [];
+    Property(property) {
 
-    if (this.fd === null) {
-      this._open = fs.open;
-      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
-      this.flush();
+        // Computed property's key is a right hand node.
+        if (property.computed) {
+            this.rightHandNodes.push(property.key);
+        }
+
+        // If it's shorthand, its key is same as its value.
+        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).
+        // If it's not shorthand, the name of new variable is its value's.
+        this.visit(property.value);
     }
-  }
-}
 
+    ArrayPattern(pattern) {
+        for (let i = 0, iz = pattern.elements.length; i < iz; ++i) {
+            const element = pattern.elements[i];
 
-/***/ }),
+            this.visit(element);
+        }
+    }
 
-/***/ 11290:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    AssignmentPattern(pattern) {
+        this.assignments.push(pattern);
+        this.visit(pattern.left);
+        this.rightHandNodes.push(pattern.right);
+        this.assignments.pop();
+    }
 
-var constants = __webpack_require__(22057)
+    RestElement(pattern) {
+        this.restElements.push(pattern);
+        this.visit(pattern.argument);
+        this.restElements.pop();
+    }
 
-var origCwd = process.cwd
-var cwd = null
+    MemberExpression(node) {
 
-var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+        // Computed property's key is a right hand node.
+        if (node.computed) {
+            this.rightHandNodes.push(node.property);
+        }
 
-process.cwd = function() {
-  if (!cwd)
-    cwd = origCwd.call(process)
-  return cwd
-}
-try {
-  process.cwd()
-} catch (er) {}
+        // the object is only read, write to its property.
+        this.rightHandNodes.push(node.object);
+    }
 
-// This check is needed until node.js 12 is required
-if (typeof process.chdir === 'function') {
-  var chdir = process.chdir
-  process.chdir = function (d) {
-    cwd = null
-    chdir.call(process, d)
-  }
-  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
-}
+    //
+    // ForInStatement.left and AssignmentExpression.left are LeftHandSideExpression.
+    // By spec, LeftHandSideExpression is Pattern or MemberExpression.
+    //   (see also: https://github.com/estree/estree/pull/20#issuecomment-74584758)
+    // But espree 2.0 parses to ArrayExpression, ObjectExpression, etc...
+    //
 
-module.exports = patch
+    SpreadElement(node) {
+        this.visit(node.argument);
+    }
 
-function patch (fs) {
-  // (re-)implement some things that are known busted or missing.
+    ArrayExpression(node) {
+        node.elements.forEach(this.visit, this);
+    }
 
-  // lchmod, broken prior to 0.6.2
-  // back-port the fix here.
-  if (constants.hasOwnProperty('O_SYMLINK') &&
-      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-    patchLchmod(fs)
-  }
+    AssignmentExpression(node) {
+        this.assignments.push(node);
+        this.visit(node.left);
+        this.rightHandNodes.push(node.right);
+        this.assignments.pop();
+    }
 
-  // lutimes implementation, or no-op
-  if (!fs.lutimes) {
-    patchLutimes(fs)
-  }
+    CallExpression(node) {
 
-  // https://github.com/isaacs/node-graceful-fs/issues/4
-  // Chown should not fail on einval or eperm if non-root.
-  // It should not fail on enosys ever, as this just indicates
-  // that a fs doesn't support the intended operation.
+        // arguments are right hand nodes.
+        node.arguments.forEach(a => {
+            this.rightHandNodes.push(a);
+        });
+        this.visit(node.callee);
+    }
+}
 
-  fs.chown = chownFix(fs.chown)
-  fs.fchown = chownFix(fs.fchown)
-  fs.lchown = chownFix(fs.lchown)
+module.exports = PatternVisitor;
 
-  fs.chmod = chmodFix(fs.chmod)
-  fs.fchmod = chmodFix(fs.fchmod)
-  fs.lchmod = chmodFix(fs.lchmod)
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-  fs.chownSync = chownFixSync(fs.chownSync)
-  fs.fchownSync = chownFixSync(fs.fchownSync)
-  fs.lchownSync = chownFixSync(fs.lchownSync)
 
-  fs.chmodSync = chmodFixSync(fs.chmodSync)
-  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
-  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+/***/ }),
 
-  fs.stat = statFix(fs.stat)
-  fs.fstat = statFix(fs.fstat)
-  fs.lstat = statFix(fs.lstat)
+/***/ 64945:
+/***/ (function(module) {
 
-  fs.statSync = statFixSync(fs.statSync)
-  fs.fstatSync = statFixSync(fs.fstatSync)
-  fs.lstatSync = statFixSync(fs.lstatSync)
+"use strict";
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-  // if lchmod/lchown do not exist, then make them no-ops
-  if (!fs.lchmod) {
-    fs.lchmod = function (path, mode, cb) {
-      if (cb) process.nextTick(cb)
-    }
-    fs.lchmodSync = function () {}
-  }
-  if (!fs.lchown) {
-    fs.lchown = function (path, uid, gid, cb) {
-      if (cb) process.nextTick(cb)
-    }
-    fs.lchownSync = function () {}
-  }
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-  // on Windows, A/V software can lock the directory, causing this
-  // to fail with an EACCES or EPERM if the directory contains newly
-  // created files.  Try again on failure, for up to 60 seconds.
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-  // Set the timeout this long because some Windows Anti-Virus, such as Parity
-  // bit9, may lock files for up to a minute, causing npm package install
-  // failures. Also, take care to yield the scheduler. Windows scheduling gives
-  // CPU to a busy looping process, which can cause the program causing the lock
-  // contention to be starved of CPU by node, so the contention doesn't resolve.
-  if (platform === "win32") {
-    fs.rename = (function (fs$rename) { return function (from, to, cb) {
-      var start = Date.now()
-      var backoff = 0;
-      fs$rename(from, to, function CB (er) {
-        if (er
-            && (er.code === "EACCES" || er.code === "EPERM")
-            && Date.now() - start < 60000) {
-          setTimeout(function() {
-            fs.stat(to, function (stater, st) {
-              if (stater && stater.code === "ENOENT")
-                fs$rename(from, to, CB);
-              else
-                cb(er)
-            })
-          }, backoff)
-          if (backoff < 100)
-            backoff += 10;
-          return;
-        }
-        if (cb) cb(er)
-      })
-    }})(fs.rename)
-  }
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-  // if read() returns EAGAIN, then just try it again.
-  fs.read = (function (fs$read) {
-    function read (fd, buffer, offset, length, position, callback_) {
-      var callback
-      if (callback_ && typeof callback_ === 'function') {
-        var eagCounter = 0
-        callback = function (er, _, __) {
-          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
-            eagCounter ++
-            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-          }
-          callback_.apply(this, arguments)
-        }
-      }
-      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-    }
 
-    // This ensures `util.promisify` works as it does for native `fs.read`.
-    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
-    return read
-  })(fs.read)
+const READ = 0x1;
+const WRITE = 0x2;
+const RW = READ | WRITE;
 
-  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
-    var eagCounter = 0
-    while (true) {
-      try {
-        return fs$readSync.call(fs, fd, buffer, offset, length, position)
-      } catch (er) {
-        if (er.code === 'EAGAIN' && eagCounter < 10) {
-          eagCounter ++
-          continue
-        }
-        throw er
-      }
-    }
-  }})(fs.readSync)
+/**
+ * A Reference represents a single occurrence of an identifier in code.
+ * @class Reference
+ */
+class Reference {
+    constructor(ident, scope, flag, writeExpr, maybeImplicitGlobal, partial, init) {
 
-  function patchLchmod (fs) {
-    fs.lchmod = function (path, mode, callback) {
-      fs.open( path
-             , constants.O_WRONLY | constants.O_SYMLINK
-             , mode
-             , function (err, fd) {
-        if (err) {
-          if (callback) callback(err)
-          return
-        }
-        // prefer to return the chmod error, if one occurs,
-        // but still try to close, and report closing errors if they occur.
-        fs.fchmod(fd, mode, function (err) {
-          fs.close(fd, function(err2) {
-            if (callback) callback(err || err2)
-          })
-        })
-      })
-    }
+        /**
+         * Identifier syntax node.
+         * @member {espreeIdentifier} Reference#identifier
+         */
+        this.identifier = ident;
 
-    fs.lchmodSync = function (path, mode) {
-      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+        /**
+         * Reference to the enclosing Scope.
+         * @member {Scope} Reference#from
+         */
+        this.from = scope;
 
-      // prefer to return the chmod error, if one occurs,
-      // but still try to close, and report closing errors if they occur.
-      var threw = true
-      var ret
-      try {
-        ret = fs.fchmodSync(fd, mode)
-        threw = false
-      } finally {
-        if (threw) {
-          try {
-            fs.closeSync(fd)
-          } catch (er) {}
-        } else {
-          fs.closeSync(fd)
-        }
-      }
-      return ret
-    }
-  }
+        /**
+         * Whether the reference comes from a dynamic scope (such as 'eval',
+         * 'with', etc.), and may be trapped by dynamic scopes.
+         * @member {boolean} Reference#tainted
+         */
+        this.tainted = false;
 
-  function patchLutimes (fs) {
-    if (constants.hasOwnProperty("O_SYMLINK")) {
-      fs.lutimes = function (path, at, mt, cb) {
-        fs.open(path, constants.O_SYMLINK, function (er, fd) {
-          if (er) {
-            if (cb) cb(er)
-            return
-          }
-          fs.futimes(fd, at, mt, function (er) {
-            fs.close(fd, function (er2) {
-              if (cb) cb(er || er2)
-            })
-          })
-        })
-      }
+        /**
+         * The variable this reference is resolved with.
+         * @member {Variable} Reference#resolved
+         */
+        this.resolved = null;
 
-      fs.lutimesSync = function (path, at, mt) {
-        var fd = fs.openSync(path, constants.O_SYMLINK)
-        var ret
-        var threw = true
-        try {
-          ret = fs.futimesSync(fd, at, mt)
-          threw = false
-        } finally {
-          if (threw) {
-            try {
-              fs.closeSync(fd)
-            } catch (er) {}
-          } else {
-            fs.closeSync(fd)
-          }
-        }
-        return ret
-      }
+        /**
+         * The read-write mode of the reference. (Value is one of {@link
+         * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).
+         * @member {number} Reference#flag
+         * @private
+         */
+        this.flag = flag;
+        if (this.isWrite()) {
 
-    } else {
-      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
-      fs.lutimesSync = function () {}
-    }
-  }
+            /**
+             * If reference is writeable, this is the tree being written to it.
+             * @member {espreeNode} Reference#writeExpr
+             */
+            this.writeExpr = writeExpr;
 
-  function chmodFix (orig) {
-    if (!orig) return orig
-    return function (target, mode, cb) {
-      return orig.call(fs, target, mode, function (er) {
-        if (chownErOk(er)) er = null
-        if (cb) cb.apply(this, arguments)
-      })
+            /**
+             * Whether the Reference might refer to a partial value of writeExpr.
+             * @member {boolean} Reference#partial
+             */
+            this.partial = partial;
+
+            /**
+             * Whether the Reference is to write of initialization.
+             * @member {boolean} Reference#init
+             */
+            this.init = init;
+        }
+        this.__maybeImplicitGlobal = maybeImplicitGlobal;
     }
-  }
 
-  function chmodFixSync (orig) {
-    if (!orig) return orig
-    return function (target, mode) {
-      try {
-        return orig.call(fs, target, mode)
-      } catch (er) {
-        if (!chownErOk(er)) throw er
-      }
+    /**
+     * Whether the reference is static.
+     * @method Reference#isStatic
+     * @returns {boolean} static
+     */
+    isStatic() {
+        return !this.tainted && this.resolved && this.resolved.scope.isStatic();
     }
-  }
 
+    /**
+     * Whether the reference is writeable.
+     * @method Reference#isWrite
+     * @returns {boolean} write
+     */
+    isWrite() {
+        return !!(this.flag & Reference.WRITE);
+    }
 
-  function chownFix (orig) {
-    if (!orig) return orig
-    return function (target, uid, gid, cb) {
-      return orig.call(fs, target, uid, gid, function (er) {
-        if (chownErOk(er)) er = null
-        if (cb) cb.apply(this, arguments)
-      })
+    /**
+     * Whether the reference is readable.
+     * @method Reference#isRead
+     * @returns {boolean} read
+     */
+    isRead() {
+        return !!(this.flag & Reference.READ);
     }
-  }
 
-  function chownFixSync (orig) {
-    if (!orig) return orig
-    return function (target, uid, gid) {
-      try {
-        return orig.call(fs, target, uid, gid)
-      } catch (er) {
-        if (!chownErOk(er)) throw er
-      }
+    /**
+     * Whether the reference is read-only.
+     * @method Reference#isReadOnly
+     * @returns {boolean} read only
+     */
+    isReadOnly() {
+        return this.flag === Reference.READ;
     }
-  }
 
-  function statFix (orig) {
-    if (!orig) return orig
-    // Older versions of Node erroneously returned signed integers for
-    // uid + gid.
-    return function (target, options, cb) {
-      if (typeof options === 'function') {
-        cb = options
-        options = null
-      }
-      function callback (er, stats) {
-        if (stats) {
-          if (stats.uid < 0) stats.uid += 0x100000000
-          if (stats.gid < 0) stats.gid += 0x100000000
-        }
-        if (cb) cb.apply(this, arguments)
-      }
-      return options ? orig.call(fs, target, options, callback)
-        : orig.call(fs, target, callback)
+    /**
+     * Whether the reference is write-only.
+     * @method Reference#isWriteOnly
+     * @returns {boolean} write only
+     */
+    isWriteOnly() {
+        return this.flag === Reference.WRITE;
     }
-  }
 
-  function statFixSync (orig) {
-    if (!orig) return orig
-    // Older versions of Node erroneously returned signed integers for
-    // uid + gid.
-    return function (target, options) {
-      var stats = options ? orig.call(fs, target, options)
-        : orig.call(fs, target)
-      if (stats) {
-        if (stats.uid < 0) stats.uid += 0x100000000
-        if (stats.gid < 0) stats.gid += 0x100000000
-      }
-      return stats;
+    /**
+     * Whether the reference is read-write.
+     * @method Reference#isReadWrite
+     * @returns {boolean} read write
+     */
+    isReadWrite() {
+        return this.flag === Reference.RW;
     }
-  }
+}
 
-  // ENOSYS means that the fs doesn't support the op. Just ignore
-  // that, because it doesn't matter.
-  //
-  // if there's no getuid, or if getuid() is something other
-  // than 0, and the error is EINVAL or EPERM, then just ignore
-  // it.
-  //
-  // This specific case is a silent failure in cp, install, tar,
-  // and most other unix tools that manage permissions.
-  //
-  // When running as root, or if other types of errors are
-  // encountered, then it's strict.
-  function chownErOk (er) {
-    if (!er)
-      return true
-
-    if (er.code === "ENOSYS")
-      return true
-
-    var nonroot = !process.getuid || process.getuid() !== 0
-    if (nonroot) {
-      if (er.code === "EINVAL" || er.code === "EPERM")
-        return true
-    }
-
-    return false
-  }
-}
-
-
-/***/ }),
+/**
+ * @constant Reference.READ
+ * @private
+ */
+Reference.READ = READ;
 
-/***/ 15235:
-/***/ (function(module) {
+/**
+ * @constant Reference.WRITE
+ * @private
+ */
+Reference.WRITE = WRITE;
 
-"use strict";
+/**
+ * @constant Reference.RW
+ * @private
+ */
+Reference.RW = RW;
 
+module.exports = Reference;
 
-module.exports = parseJson
-function parseJson (txt, reviver, context) {
-  context = context || 20
-  try {
-    return JSON.parse(txt, reviver)
-  } catch (e) {
-    if (typeof txt !== 'string') {
-      const isEmptyArray = Array.isArray(txt) && txt.length === 0
-      const errorMessage = 'Cannot parse ' +
-      (isEmptyArray ? 'an empty array' : String(txt))
-      throw new TypeError(errorMessage)
-    }
-    const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
-    const errIdx = syntaxErr
-    ? +syntaxErr[1]
-    : e.message.match(/^Unexpected end of JSON.*/i)
-    ? txt.length - 1
-    : null
-    if (errIdx != null) {
-      const start = errIdx <= context
-      ? 0
-      : errIdx - context
-      const end = errIdx + context >= txt.length
-      ? txt.length
-      : errIdx + context
-      e.message += ` while parsing near '${
-        start === 0 ? '' : '...'
-      }${txt.slice(start, end)}${
-        end === txt.length ? '' : '...'
-      }'`
-    } else {
-      e.message += ` while parsing '${txt.slice(0, context * 2)}'`
-    }
-    throw e
-  }
-}
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 54983:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 44585:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
-var __webpack_unused_export__;
-
-
-__webpack_unused_export__ = ({
-  value: true
-});
-exports.Z = void 0;
-
-const {
-  stringHints,
-  numberHints
-} = __webpack_require__(79926);
-/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-/** @typedef {import("./validate").Schema} Schema */
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-/** @typedef {import("./validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-/** @typedef {import("./validate").PostFormatter} PostFormatter */
 
-/** @typedef {import("./validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-undefined */
 
-/** @enum {number} */
+const Syntax = (__webpack_require__(18350).Syntax);
+const esrecurse = __webpack_require__(81217);
+const Reference = __webpack_require__(64945);
+const Variable = __webpack_require__(82971);
+const PatternVisitor = __webpack_require__(54162);
+const definition = __webpack_require__(70665);
+const assert = __webpack_require__(39491);
 
+const ParameterDefinition = definition.ParameterDefinition;
+const Definition = definition.Definition;
 
-const SPECIFICITY = {
-  type: 1,
-  not: 1,
-  oneOf: 1,
-  anyOf: 1,
-  if: 1,
-  enum: 1,
-  const: 1,
-  instanceof: 1,
-  required: 2,
-  pattern: 2,
-  patternRequired: 2,
-  format: 2,
-  formatMinimum: 2,
-  formatMaximum: 2,
-  minimum: 2,
-  exclusiveMinimum: 2,
-  maximum: 2,
-  exclusiveMaximum: 2,
-  multipleOf: 2,
-  uniqueItems: 2,
-  contains: 2,
-  minLength: 2,
-  maxLength: 2,
-  minItems: 2,
-  maxItems: 2,
-  minProperties: 2,
-  maxProperties: 2,
-  dependencies: 2,
-  propertyNames: 2,
-  additionalItems: 2,
-  additionalProperties: 2,
-  absolutePath: 2
-};
 /**
- *
- * @param {Array<SchemaUtilErrorObject>} array
- * @param {(item: SchemaUtilErrorObject) => number} fn
- * @returns {Array<SchemaUtilErrorObject>}
+ * Traverse identifier in pattern
+ * @param {Object} options - options
+ * @param {pattern} rootPattern - root pattern
+ * @param {Refencer} referencer - referencer
+ * @param {callback} callback - callback
+ * @returns {void}
  */
+function traverseIdentifierInPattern(options, rootPattern, referencer, callback) {
 
-function filterMax(array, fn) {
-  const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
-  return array.filter(item => fn(item) === evaluatedMax);
-}
-/**
- *
- * @param {Array<SchemaUtilErrorObject>} children
- * @returns {Array<SchemaUtilErrorObject>}
- */
+    // Call the callback at left hand identifier nodes, and Collect right hand nodes.
+    const visitor = new PatternVisitor(options, rootPattern, callback);
 
+    visitor.visit(rootPattern);
 
-function filterChildren(children) {
-  let newChildren = children;
-  newChildren = filterMax(newChildren,
-  /**
-   *
-   * @param {SchemaUtilErrorObject} error
-   * @returns {number}
-   */
-  error => error.dataPath ? error.dataPath.length : 0);
-  newChildren = filterMax(newChildren,
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {number}
-   */
-  error => SPECIFICITY[
-  /** @type {keyof typeof SPECIFICITY} */
-  error.keyword] || 2);
-  return newChildren;
+    // Process the right hand nodes recursively.
+    if (referencer !== null && referencer !== undefined) {
+        visitor.rightHandNodes.forEach(referencer.visit, referencer);
+    }
 }
-/**
- * Find all children errors
- * @param {Array<SchemaUtilErrorObject>} children
- * @param {Array<string>} schemaPaths
- * @return {number} returns index of first child
- */
-
 
-function findAllChildren(children, schemaPaths) {
-  let i = children.length - 1;
+// Importing ImportDeclaration.
+// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-moduledeclarationinstantiation
+// https://github.com/estree/estree/blob/master/es6.md#importdeclaration
+// FIXME: Now, we don't create module environment, because the context is
+// implementation dependent.
 
-  const predicate =
-  /**
-   * @param {string} schemaPath
-   * @returns {boolean}
-   */
-  schemaPath => children[i].schemaPath.indexOf(schemaPath) !== 0;
+class Importer extends esrecurse.Visitor {
+    constructor(declaration, referencer) {
+        super(null, referencer.options);
+        this.declaration = declaration;
+        this.referencer = referencer;
+    }
 
-  while (i > -1 && !schemaPaths.every(predicate)) {
-    if (children[i].keyword === "anyOf" || children[i].keyword === "oneOf") {
-      const refs = extractRefs(children[i]);
-      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(children[i].schemaPath));
-      i = childrenStart - 1;
-    } else {
-      i -= 1;
+    visitImport(id, specifier) {
+        this.referencer.visitPattern(id, pattern => {
+            this.referencer.currentScope().__define(pattern,
+                new Definition(
+                    Variable.ImportBinding,
+                    pattern,
+                    specifier,
+                    this.declaration,
+                    null,
+                    null
+                ));
+        });
     }
-  }
 
-  return i + 1;
-}
-/**
- * Extracts all refs from schema
- * @param {SchemaUtilErrorObject} error
- * @return {Array<string>}
- */
+    ImportNamespaceSpecifier(node) {
+        const local = (node.local || node.id);
 
+        if (local) {
+            this.visitImport(local, node);
+        }
+    }
 
-function extractRefs(error) {
-  const {
-    schema
-  } = error;
+    ImportDefaultSpecifier(node) {
+        const local = (node.local || node.id);
 
-  if (!Array.isArray(schema)) {
-    return [];
-  }
+        this.visitImport(local, node);
+    }
 
-  return schema.map(({
-    $ref
-  }) => $ref).filter(s => s);
+    ImportSpecifier(node) {
+        const local = (node.local || node.id);
+
+        if (node.name) {
+            this.visitImport(node.name, node);
+        } else {
+            this.visitImport(local, node);
+        }
+    }
 }
-/**
- * Groups children by their first level parent (assuming that error is root)
- * @param {Array<SchemaUtilErrorObject>} children
- * @return {Array<SchemaUtilErrorObject>}
- */
 
+// Referencing variables and creating bindings.
+class Referencer extends esrecurse.Visitor {
+    constructor(options, scopeManager) {
+        super(null, options);
+        this.options = options;
+        this.scopeManager = scopeManager;
+        this.parent = null;
+        this.isInnerMethodDefinition = false;
+    }
 
-function groupChildrenByFirstChild(children) {
-  const result = [];
-  let i = children.length - 1;
+    currentScope() {
+        return this.scopeManager.__currentScope;
+    }
 
-  while (i > 0) {
-    const child = children[i];
+    close(node) {
+        while (this.currentScope() && node === this.currentScope().block) {
+            this.scopeManager.__currentScope = this.currentScope().__close(this.scopeManager);
+        }
+    }
 
-    if (child.keyword === "anyOf" || child.keyword === "oneOf") {
-      const refs = extractRefs(child);
-      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(child.schemaPath));
+    pushInnerMethodDefinition(isInnerMethodDefinition) {
+        const previous = this.isInnerMethodDefinition;
 
-      if (childrenStart !== i) {
-        result.push(Object.assign({}, child, {
-          children: children.slice(childrenStart, i)
-        }));
-        i = childrenStart;
-      } else {
-        result.push(child);
-      }
-    } else {
-      result.push(child);
+        this.isInnerMethodDefinition = isInnerMethodDefinition;
+        return previous;
     }
 
-    i -= 1;
-  }
-
-  if (i === 0) {
-    result.push(children[i]);
-  }
+    popInnerMethodDefinition(isInnerMethodDefinition) {
+        this.isInnerMethodDefinition = isInnerMethodDefinition;
+    }
 
-  return result.reverse();
-}
-/**
- * @param {string} str
- * @param {string} prefix
- * @returns {string}
- */
+    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {
+        const scope = this.currentScope();
 
+        assignments.forEach(assignment => {
+            scope.__referencing(
+                pattern,
+                Reference.WRITE,
+                assignment.right,
+                maybeImplicitGlobal,
+                pattern !== assignment.left,
+                init
+            );
+        });
+    }
 
-function indent(str, prefix) {
-  return str.replace(/\n(?!$)/g, `\n${prefix}`);
-}
-/**
- * @param {Schema} schema
- * @returns {schema is (Schema & {not: Schema})}
- */
+    visitPattern(node, options, callback) {
+        let visitPatternOptions = options;
+        let visitPatternCallback = callback;
 
+        if (typeof options === "function") {
+            visitPatternCallback = options;
+            visitPatternOptions = { processRightHandNodes: false };
+        }
 
-function hasNotInSchema(schema) {
-  return !!schema.not;
-}
-/**
- * @param {Schema} schema
- * @return {Schema}
- */
+        traverseIdentifierInPattern(
+            this.options,
+            node,
+            visitPatternOptions.processRightHandNodes ? this : null,
+            visitPatternCallback
+        );
+    }
 
+    visitFunction(node) {
+        let i, iz;
 
-function findFirstTypedSchema(schema) {
-  if (hasNotInSchema(schema)) {
-    return findFirstTypedSchema(schema.not);
-  }
+        // FunctionDeclaration name is defined in upper scope
+        // NOTE: Not referring variableScope. It is intended.
+        // Since
+        //  in ES5, FunctionDeclaration should be in FunctionBody.
+        //  in ES6, FunctionDeclaration should be block scoped.
 
-  return schema;
-}
-/**
- * @param {Schema} schema
- * @return {boolean}
- */
+        if (node.type === Syntax.FunctionDeclaration) {
 
+            // id is defined in upper scope
+            this.currentScope().__define(node.id,
+                new Definition(
+                    Variable.FunctionName,
+                    node.id,
+                    node,
+                    null,
+                    null,
+                    null
+                ));
+        }
 
-function canApplyNot(schema) {
-  const typedSchema = findFirstTypedSchema(schema);
-  return likeNumber(typedSchema) || likeInteger(typedSchema) || likeString(typedSchema) || likeNull(typedSchema) || likeBoolean(typedSchema);
-}
-/**
- * @param {any} maybeObj
- * @returns {boolean}
- */
+        // FunctionExpression with name creates its special scope;
+        // FunctionExpressionNameScope.
+        if (node.type === Syntax.FunctionExpression && node.id) {
+            this.scopeManager.__nestFunctionExpressionNameScope(node);
+        }
 
+        // Consider this function is in the MethodDefinition.
+        this.scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);
 
-function isObject(maybeObj) {
-  return typeof maybeObj === "object" && maybeObj !== null;
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+        const that = this;
 
+        /**
+         * Visit pattern callback
+         * @param {pattern} pattern - pattern
+         * @param {Object} info - info
+         * @returns {void}
+         */
+        function visitPatternCallback(pattern, info) {
+            that.currentScope().__define(pattern,
+                new ParameterDefinition(
+                    pattern,
+                    node,
+                    i,
+                    info.rest
+                ));
 
-function likeNumber(schema) {
-  return schema.type === "number" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+            that.referencingDefaultValue(pattern, info.assignments, null, true);
+        }
 
+        // Process parameter declarations.
+        for (i = 0, iz = node.params.length; i < iz; ++i) {
+            this.visitPattern(node.params[i], { processRightHandNodes: true }, visitPatternCallback);
+        }
 
-function likeInteger(schema) {
-  return schema.type === "integer" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+        // if there's a rest argument, add that
+        if (node.rest) {
+            this.visitPattern({
+                type: "RestElement",
+                argument: node.rest
+            }, pattern => {
+                this.currentScope().__define(pattern,
+                    new ParameterDefinition(
+                        pattern,
+                        node,
+                        node.params.length,
+                        true
+                    ));
+            });
+        }
 
+        // In TypeScript there are a number of function-like constructs which have no body,
+        // so check it exists before traversing
+        if (node.body) {
 
-function likeString(schema) {
-  return schema.type === "string" || typeof schema.minLength !== "undefined" || typeof schema.maxLength !== "undefined" || typeof schema.pattern !== "undefined" || typeof schema.format !== "undefined" || typeof schema.formatMinimum !== "undefined" || typeof schema.formatMaximum !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+            // Skip BlockStatement to prevent creating BlockStatement scope.
+            if (node.body.type === Syntax.BlockStatement) {
+                this.visitChildren(node.body);
+            } else {
+                this.visit(node.body);
+            }
+        }
 
+        this.close(node);
+    }
 
-function likeBoolean(schema) {
-  return schema.type === "boolean";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+    visitClass(node) {
+        if (node.type === Syntax.ClassDeclaration) {
+            this.currentScope().__define(node.id,
+                new Definition(
+                    Variable.ClassName,
+                    node.id,
+                    node,
+                    null,
+                    null,
+                    null
+                ));
+        }
 
+        this.visit(node.superClass);
 
-function likeArray(schema) {
-  return schema.type === "array" || typeof schema.minItems === "number" || typeof schema.maxItems === "number" || typeof schema.uniqueItems !== "undefined" || typeof schema.items !== "undefined" || typeof schema.additionalItems !== "undefined" || typeof schema.contains !== "undefined";
-}
-/**
- * @param {Schema & {patternRequired?: Array<string>}} schema
- * @returns {boolean}
- */
+        this.scopeManager.__nestClassScope(node);
 
+        if (node.id) {
+            this.currentScope().__define(node.id,
+                new Definition(
+                    Variable.ClassName,
+                    node.id,
+                    node
+                ));
+        }
+        this.visit(node.body);
 
-function likeObject(schema) {
-  return schema.type === "object" || typeof schema.minProperties !== "undefined" || typeof schema.maxProperties !== "undefined" || typeof schema.required !== "undefined" || typeof schema.properties !== "undefined" || typeof schema.patternProperties !== "undefined" || typeof schema.additionalProperties !== "undefined" || typeof schema.dependencies !== "undefined" || typeof schema.propertyNames !== "undefined" || typeof schema.patternRequired !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+        this.close(node);
+    }
 
+    visitProperty(node) {
+        let previous;
 
-function likeNull(schema) {
-  return schema.type === "null";
-}
-/**
- * @param {string} type
- * @returns {string}
- */
+        if (node.computed) {
+            this.visit(node.key);
+        }
 
+        const isMethodDefinition = node.type === Syntax.MethodDefinition;
 
-function getArticle(type) {
-  if (/^[aeiou]/i.test(type)) {
-    return "an";
-  }
+        if (isMethodDefinition) {
+            previous = this.pushInnerMethodDefinition(true);
+        }
+        this.visit(node.value);
+        if (isMethodDefinition) {
+            this.popInnerMethodDefinition(previous);
+        }
+    }
 
-  return "a";
-}
-/**
- * @param {Schema=} schema
- * @returns {string}
- */
+    visitForIn(node) {
+        if (node.left.type === Syntax.VariableDeclaration && node.left.kind !== "var") {
+            this.scopeManager.__nestForScope(node);
+        }
 
+        if (node.left.type === Syntax.VariableDeclaration) {
+            this.visit(node.left);
+            this.visitPattern(node.left.declarations[0].id, pattern => {
+                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, null, true, true);
+            });
+        } else {
+            this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
+                let maybeImplicitGlobal = null;
 
-function getSchemaNonTypes(schema) {
-  if (!schema) {
-    return "";
-  }
+                if (!this.currentScope().isStrict) {
+                    maybeImplicitGlobal = {
+                        pattern,
+                        node
+                    };
+                }
+                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
+                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, true, false);
+            });
+        }
+        this.visit(node.right);
+        this.visit(node.body);
 
-  if (!schema.type) {
-    if (likeNumber(schema) || likeInteger(schema)) {
-      return " | should be any non-number";
+        this.close(node);
     }
 
-    if (likeString(schema)) {
-      return " | should be any non-string";
-    }
+    visitVariableDeclaration(variableTargetScope, type, node, index) {
 
-    if (likeArray(schema)) {
-      return " | should be any non-array";
-    }
+        const decl = node.declarations[index];
+        const init = decl.init;
 
-    if (likeObject(schema)) {
-      return " | should be any non-object";
+        this.visitPattern(decl.id, { processRightHandNodes: true }, (pattern, info) => {
+            variableTargetScope.__define(
+                pattern,
+                new Definition(
+                    type,
+                    pattern,
+                    decl,
+                    node,
+                    index,
+                    node.kind
+                )
+            );
+
+            this.referencingDefaultValue(pattern, info.assignments, null, true);
+            if (init) {
+                this.currentScope().__referencing(pattern, Reference.WRITE, init, null, !info.topLevel, true);
+            }
+        });
     }
-  }
 
-  return "";
-}
-/**
- * @param {Array<string>} hints
- * @returns {string}
- */
+    AssignmentExpression(node) {
+        if (PatternVisitor.isPattern(node.left)) {
+            if (node.operator === "=") {
+                this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
+                    let maybeImplicitGlobal = null;
 
+                    if (!this.currentScope().isStrict) {
+                        maybeImplicitGlobal = {
+                            pattern,
+                            node
+                        };
+                    }
+                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
+                    this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, !info.topLevel, false);
+                });
+            } else {
+                this.currentScope().__referencing(node.left, Reference.RW, node.right);
+            }
+        } else {
+            this.visit(node.left);
+        }
+        this.visit(node.right);
+    }
 
-function formatHints(hints) {
-  return hints.length > 0 ? `(${hints.join(", ")})` : "";
-}
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @returns {string[]}
- */
+    CatchClause(node) {
+        this.scopeManager.__nestCatchScope(node);
 
+        this.visitPattern(node.param, { processRightHandNodes: true }, (pattern, info) => {
+            this.currentScope().__define(pattern,
+                new Definition(
+                    Variable.CatchClause,
+                    node.param,
+                    node,
+                    null,
+                    null,
+                    null
+                ));
+            this.referencingDefaultValue(pattern, info.assignments, null, true);
+        });
+        this.visit(node.body);
 
-function getHints(schema, logic) {
-  if (likeNumber(schema) || likeInteger(schema)) {
-    return numberHints(schema, logic);
-  } else if (likeString(schema)) {
-    return stringHints(schema, logic);
-  }
+        this.close(node);
+    }
 
-  return [];
-}
+    Program(node) {
+        this.scopeManager.__nestGlobalScope(node);
 
-class ValidationError extends Error {
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @param {Schema} schema
-   * @param {ValidationErrorConfiguration} configuration
-   */
-  constructor(errors, schema, configuration = {}) {
-    super();
-    /** @type {string} */
+        if (this.scopeManager.__isNodejsScope()) {
 
-    this.name = "ValidationError";
-    /** @type {Array<SchemaUtilErrorObject>} */
+            // Force strictness of GlobalScope to false when using node.js scope.
+            this.currentScope().isStrict = false;
+            this.scopeManager.__nestFunctionScope(node, false);
+        }
 
-    this.errors = errors;
-    /** @type {Schema} */
+        if (this.scopeManager.__isES6() && this.scopeManager.isModule()) {
+            this.scopeManager.__nestModuleScope(node);
+        }
 
-    this.schema = schema;
-    let headerNameFromSchema;
-    let baseDataPathFromSchema;
+        if (this.scopeManager.isStrictModeSupported() && this.scopeManager.isImpliedStrict()) {
+            this.currentScope().isStrict = true;
+        }
 
-    if (schema.title && (!configuration.name || !configuration.baseDataPath)) {
-      const splittedTitleFromSchema = schema.title.match(/^(.+) (.+)$/);
+        this.visitChildren(node);
+        this.close(node);
+    }
 
-      if (splittedTitleFromSchema) {
-        if (!configuration.name) {
-          [, headerNameFromSchema] = splittedTitleFromSchema;
+    Identifier(node) {
+        this.currentScope().__referencing(node);
+    }
+
+    UpdateExpression(node) {
+        if (PatternVisitor.isPattern(node.argument)) {
+            this.currentScope().__referencing(node.argument, Reference.RW, null);
+        } else {
+            this.visitChildren(node);
         }
+    }
 
-        if (!configuration.baseDataPath) {
-          [,, baseDataPathFromSchema] = splittedTitleFromSchema;
+    MemberExpression(node) {
+        this.visit(node.object);
+        if (node.computed) {
+            this.visit(node.property);
         }
-      }
     }
-    /** @type {string} */
 
+    Property(node) {
+        this.visitProperty(node);
+    }
 
-    this.headerName = configuration.name || headerNameFromSchema || "Object";
-    /** @type {string} */
+    MethodDefinition(node) {
+        this.visitProperty(node);
+    }
 
-    this.baseDataPath = configuration.baseDataPath || baseDataPathFromSchema || "configuration";
-    /** @type {PostFormatter | null} */
+    BreakStatement() {} // eslint-disable-line class-methods-use-this
 
-    this.postFormatter = configuration.postFormatter || null;
-    const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialized using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
-    /** @type {string} */
+    ContinueStatement() {} // eslint-disable-line class-methods-use-this
 
-    this.message = `${header}${this.formatValidationErrors(errors)}`;
-    Error.captureStackTrace(this, this.constructor);
-  }
-  /**
-   * @param {string} path
-   * @returns {Schema}
-   */
+    LabeledStatement(node) {
+        this.visit(node.body);
+    }
 
+    ForStatement(node) {
 
-  getSchemaPart(path) {
-    const newPath = path.split("/");
-    let schemaPart = this.schema;
+        // Create ForStatement declaration.
+        // NOTE: In ES6, ForStatement dynamically generates
+        // per iteration environment. However, escope is
+        // a static analyzer, we only generate one scope for ForStatement.
+        if (node.init && node.init.type === Syntax.VariableDeclaration && node.init.kind !== "var") {
+            this.scopeManager.__nestForScope(node);
+        }
 
-    for (let i = 1; i < newPath.length; i++) {
-      const inner = schemaPart[
-      /** @type {keyof Schema} */
-      newPath[i]];
+        this.visitChildren(node);
 
-      if (!inner) {
-        break;
-      }
+        this.close(node);
+    }
 
-      schemaPart = inner;
+    ClassExpression(node) {
+        this.visitClass(node);
     }
 
-    return schemaPart;
-  }
-  /**
-   * @param {Schema} schema
-   * @param {boolean} logic
-   * @param {Array<Object>} prevSchemas
-   * @returns {string}
-   */
+    ClassDeclaration(node) {
+        this.visitClass(node);
+    }
 
+    CallExpression(node) {
 
-  formatSchema(schema, logic = true, prevSchemas = []) {
-    let newLogic = logic;
+        // Check this is direct call to eval
+        if (!this.scopeManager.__ignoreEval() && node.callee.type === Syntax.Identifier && node.callee.name === "eval") {
 
-    const formatInnerSchema =
-    /**
-     *
-     * @param {Object} innerSchema
-     * @param {boolean=} addSelf
-     * @returns {string}
-     */
-    (innerSchema, addSelf) => {
-      if (!addSelf) {
-        return this.formatSchema(innerSchema, newLogic, prevSchemas);
-      }
+            // NOTE: This should be `variableScope`. Since direct eval call always creates Lexical environment and
+            // let / const should be enclosed into it. Only VariableDeclaration affects on the caller's environment.
+            this.currentScope().variableScope.__detectEval();
+        }
+        this.visitChildren(node);
+    }
 
-      if (prevSchemas.includes(innerSchema)) {
-        return "(recursive)";
-      }
+    BlockStatement(node) {
+        if (this.scopeManager.__isES6()) {
+            this.scopeManager.__nestBlockScope(node);
+        }
 
-      return this.formatSchema(innerSchema, newLogic, prevSchemas.concat(schema));
-    };
+        this.visitChildren(node);
 
-    if (hasNotInSchema(schema) && !likeObject(schema)) {
-      if (canApplyNot(schema.not)) {
-        newLogic = !logic;
-        return formatInnerSchema(schema.not);
-      }
+        this.close(node);
+    }
 
-      const needApplyLogicHere = !schema.not.not;
-      const prefix = logic ? "" : "non ";
-      newLogic = !logic;
-      return needApplyLogicHere ? prefix + formatInnerSchema(schema.not) : formatInnerSchema(schema.not);
+    ThisExpression() {
+        this.currentScope().variableScope.__detectThis();
     }
 
-    if (
-    /** @type {Schema & {instanceof: string | Array<string>}} */
-    schema.instanceof) {
-      const {
-        instanceof: value
-      } =
-      /** @type {Schema & {instanceof: string | Array<string>}} */
-      schema;
-      const values = !Array.isArray(value) ? [value] : value;
-      return values.map(
-      /**
-       * @param {string} item
-       * @returns {string}
-       */
-      item => item === "Function" ? "function" : item).join(" | ");
+    WithStatement(node) {
+        this.visit(node.object);
+
+        // Then nest scope for WithStatement.
+        this.scopeManager.__nestWithScope(node);
+
+        this.visit(node.body);
+
+        this.close(node);
     }
 
-    if (schema.enum) {
-      return (
-        /** @type {Array<any>} */
-        schema.enum.map(item => JSON.stringify(item)).join(" | ")
-      );
+    VariableDeclaration(node) {
+        const variableTargetScope = (node.kind === "var") ? this.currentScope().variableScope : this.currentScope();
+
+        for (let i = 0, iz = node.declarations.length; i < iz; ++i) {
+            const decl = node.declarations[i];
+
+            this.visitVariableDeclaration(variableTargetScope, Variable.Variable, node, i);
+            if (decl.init) {
+                this.visit(decl.init);
+            }
+        }
     }
 
-    if (typeof schema.const !== "undefined") {
-      return JSON.stringify(schema.const);
+    // sec 13.11.8
+    SwitchStatement(node) {
+        this.visit(node.discriminant);
+
+        if (this.scopeManager.__isES6()) {
+            this.scopeManager.__nestSwitchScope(node);
+        }
+
+        for (let i = 0, iz = node.cases.length; i < iz; ++i) {
+            this.visit(node.cases[i]);
+        }
+
+        this.close(node);
     }
 
-    if (schema.oneOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.oneOf.map(item => formatInnerSchema(item, true)).join(" | ")
-      );
+    FunctionDeclaration(node) {
+        this.visitFunction(node);
     }
 
-    if (schema.anyOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.anyOf.map(item => formatInnerSchema(item, true)).join(" | ")
-      );
+    FunctionExpression(node) {
+        this.visitFunction(node);
     }
 
-    if (schema.allOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.allOf.map(item => formatInnerSchema(item, true)).join(" & ")
-      );
+    ForOfStatement(node) {
+        this.visitForIn(node);
     }
 
-    if (
-    /** @type {JSONSchema7} */
-    schema.if) {
-      const {
-        if: ifValue,
-        then: thenValue,
-        else: elseValue
-      } =
-      /** @type {JSONSchema7} */
-      schema;
-      return `${ifValue ? `if ${formatInnerSchema(ifValue)}` : ""}${thenValue ? ` then ${formatInnerSchema(thenValue)}` : ""}${elseValue ? ` else ${formatInnerSchema(elseValue)}` : ""}`;
+    ForInStatement(node) {
+        this.visitForIn(node);
     }
 
-    if (schema.$ref) {
-      return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
+    ArrowFunctionExpression(node) {
+        this.visitFunction(node);
     }
 
-    if (likeNumber(schema) || likeInteger(schema)) {
-      const [type, ...hints] = getHints(schema, logic);
-      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
-      return logic ? str : hints.length > 0 ? `non-${type} | ${str}` : `non-${type}`;
+    ImportDeclaration(node) {
+        assert(this.scopeManager.__isES6() && this.scopeManager.isModule(), "ImportDeclaration should appear when the mode is ES6 and in the module context.");
+
+        const importer = new Importer(node, this);
+
+        importer.visit(node);
     }
 
-    if (likeString(schema)) {
-      const [type, ...hints] = getHints(schema, logic);
-      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
-      return logic ? str : str === "string" ? "non-string" : `non-string | ${str}`;
+    visitExportDeclaration(node) {
+        if (node.source) {
+            return;
+        }
+        if (node.declaration) {
+            this.visit(node.declaration);
+            return;
+        }
+
+        this.visitChildren(node);
     }
 
-    if (likeBoolean(schema)) {
-      return `${logic ? "" : "non-"}boolean`;
+    // TODO: ExportDeclaration doesn't exist. for bc?
+    ExportDeclaration(node) {
+        this.visitExportDeclaration(node);
     }
 
-    if (likeArray(schema)) {
-      // not logic already applied in formatValidationError
-      newLogic = true;
-      const hints = [];
+    ExportAllDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
-      if (typeof schema.minItems === "number") {
-        hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? "s" : ""}`);
-      }
+    ExportDefaultDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
-      if (typeof schema.maxItems === "number") {
-        hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? "s" : ""}`);
-      }
+    ExportNamedDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
-      if (schema.uniqueItems) {
-        hints.push("should not have duplicate items");
-      }
+    ExportSpecifier(node) {
 
-      const hasAdditionalItems = typeof schema.additionalItems === "undefined" || Boolean(schema.additionalItems);
-      let items = "";
+        // TODO: `node.id` doesn't exist. for bc?
+        const local = (node.id || node.local);
 
-      if (schema.items) {
-        if (Array.isArray(schema.items) && schema.items.length > 0) {
-          items = `${
-          /** @type {Array<Schema>} */
-          schema.items.map(item => formatInnerSchema(item)).join(", ")}`;
-
-          if (hasAdditionalItems) {
-            if (schema.additionalItems && isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
-              hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
-            }
-          }
-        } else if (schema.items && Object.keys(schema.items).length > 0) {
-          // "additionalItems" is ignored
-          items = `${formatInnerSchema(schema.items)}`;
-        } else {
-          // Fallback for empty `items` value
-          items = "any";
-        }
-      } else {
-        // "additionalItems" is ignored
-        items = "any";
-      }
+        this.visit(local);
+    }
 
-      if (schema.contains && Object.keys(schema.contains).length > 0) {
-        hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
-      }
+    MetaProperty() { // eslint-disable-line class-methods-use-this
 
-      return `[${items}${hasAdditionalItems ? ", ..." : ""}]${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+        // do nothing.
     }
+}
 
-    if (likeObject(schema)) {
-      // not logic already applied in formatValidationError
-      newLogic = true;
-      const hints = [];
+module.exports = Referencer;
 
-      if (typeof schema.minProperties === "number") {
-        hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? "properties" : "property"}`);
-      }
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-      if (typeof schema.maxProperties === "number") {
-        hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties && schema.minProperties > 1 ? "properties" : "property"}`);
-      }
 
-      if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
-        const patternProperties = Object.keys(schema.patternProperties);
-        hints.push(`additional property names should match pattern${patternProperties.length > 1 ? "s" : ""} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(" | ")}`);
-      }
+/***/ }),
 
-      const properties = schema.properties ? Object.keys(schema.properties) : [];
-      const required = schema.required ? schema.required : [];
-      const allProperties = [...new Set(
-      /** @type {Array<string>} */
-      [].concat(required).concat(properties))];
-      const objectStructure = allProperties.map(property => {
-        const isRequired = required.includes(property); // Some properties need quotes, maybe we should add check
-        // Maybe we should output type of property (`foo: string`), but it is looks very unreadable
+/***/ 96988:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        return `${property}${isRequired ? "" : "?"}`;
-      }).concat(typeof schema.additionalProperties === "undefined" || Boolean(schema.additionalProperties) ? schema.additionalProperties && isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ["…"] : []).join(", ");
-      const {
-        dependencies,
-        propertyNames,
-        patternRequired
-      } =
-      /** @type {Schema & {patternRequired?: Array<string>;}} */
-      schema;
+"use strict";
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-      if (dependencies) {
-        Object.keys(dependencies).forEach(dependencyName => {
-          const dependency = dependencies[dependencyName];
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-          if (Array.isArray(dependency)) {
-            hints.push(`should have ${dependency.length > 1 ? "properties" : "property"} ${dependency.map(dep => `'${dep}'`).join(", ")} when property '${dependencyName}' is present`);
-          } else {
-            hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
-          }
-        });
-      }
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-      if (propertyNames && Object.keys(propertyNames).length > 0) {
-        hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
-      }
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-      if (patternRequired && patternRequired.length > 0) {
-        hints.push(`should have property matching pattern ${patternRequired.map(
-        /**
-         * @param {string} item
-         * @returns {string}
-         */
-        item => JSON.stringify(item))}`);
-      }
 
-      return `object {${objectStructure ? ` ${objectStructure} ` : ""}}${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+/* eslint-disable no-underscore-dangle */
+
+const Scope = __webpack_require__(16313);
+const assert = __webpack_require__(39491);
+
+const GlobalScope = Scope.GlobalScope;
+const CatchScope = Scope.CatchScope;
+const WithScope = Scope.WithScope;
+const ModuleScope = Scope.ModuleScope;
+const ClassScope = Scope.ClassScope;
+const SwitchScope = Scope.SwitchScope;
+const FunctionScope = Scope.FunctionScope;
+const ForScope = Scope.ForScope;
+const FunctionExpressionNameScope = Scope.FunctionExpressionNameScope;
+const BlockScope = Scope.BlockScope;
+
+/**
+ * @class ScopeManager
+ */
+class ScopeManager {
+    constructor(options) {
+        this.scopes = [];
+        this.globalScope = null;
+        this.__nodeToScope = new WeakMap();
+        this.__currentScope = null;
+        this.__options = options;
+        this.__declaredVariables = new WeakMap();
     }
 
-    if (likeNull(schema)) {
-      return `${logic ? "" : "non-"}null`;
+    __useDirective() {
+        return this.__options.directive;
     }
 
-    if (Array.isArray(schema.type)) {
-      // not logic already applied in formatValidationError
-      return `${schema.type.join(" | ")}`;
-    } // Fallback for unknown keywords
-    // not logic already applied in formatValidationError
+    __isOptimistic() {
+        return this.__options.optimistic;
+    }
 
-    /* istanbul ignore next */
+    __ignoreEval() {
+        return this.__options.ignoreEval;
+    }
 
+    __isNodejsScope() {
+        return this.__options.nodejsScope;
+    }
 
-    return JSON.stringify(schema, null, 2);
-  }
-  /**
-   * @param {Schema=} schemaPart
-   * @param {(boolean | Array<string>)=} additionalPath
-   * @param {boolean=} needDot
-   * @param {boolean=} logic
-   * @returns {string}
-   */
+    isModule() {
+        return this.__options.sourceType === "module";
+    }
 
+    isImpliedStrict() {
+        return this.__options.impliedStrict;
+    }
 
-  getSchemaPartText(schemaPart, additionalPath, needDot = false, logic = true) {
-    if (!schemaPart) {
-      return "";
+    isStrictModeSupported() {
+        return this.__options.ecmaVersion >= 5;
     }
 
-    if (Array.isArray(additionalPath)) {
-      for (let i = 0; i < additionalPath.length; i++) {
-        /** @type {Schema | undefined} */
-        const inner = schemaPart[
-        /** @type {keyof Schema} */
-        additionalPath[i]];
+    // Returns appropriate scope for this node.
+    __get(node) {
+        return this.__nodeToScope.get(node);
+    }
+
+    /**
+     * Get variables that are declared by the node.
+     *
+     * "are declared by the node" means the node is same as `Variable.defs[].node` or `Variable.defs[].parent`.
+     * If the node declares nothing, this method returns an empty array.
+     * CAUTION: This API is experimental. See https://github.com/estools/escope/pull/69 for more details.
+     *
+     * @param {Espree.Node} node - a node to get.
+     * @returns {Variable[]} variables that declared by the node.
+     */
+    getDeclaredVariables(node) {
+        return this.__declaredVariables.get(node) || [];
+    }
+
+    /**
+     * acquire scope from node.
+     * @method ScopeManager#acquire
+     * @param {Espree.Node} node - node for the acquired scope.
+     * @param {boolean=} inner - look up the most inner scope, default value is false.
+     * @returns {Scope?} Scope from node
+     */
+    acquire(node, inner) {
+
+        /**
+         * predicate
+         * @param {Scope} testScope - scope to test
+         * @returns {boolean} predicate
+         */
+        function predicate(testScope) {
+            if (testScope.type === "function" && testScope.functionExpressionScope) {
+                return false;
+            }
+            return true;
+        }
+
+        const scopes = this.__get(node);
+
+        if (!scopes || scopes.length === 0) {
+            return null;
+        }
+
+        // Heuristic selection from all scopes.
+        // If you would like to get all scopes, please use ScopeManager#acquireAll.
+        if (scopes.length === 1) {
+            return scopes[0];
+        }
 
         if (inner) {
-          // eslint-disable-next-line no-param-reassign
-          schemaPart = inner;
+            for (let i = scopes.length - 1; i >= 0; --i) {
+                const scope = scopes[i];
+
+                if (predicate(scope)) {
+                    return scope;
+                }
+            }
         } else {
-          break;
+            for (let i = 0, iz = scopes.length; i < iz; ++i) {
+                const scope = scopes[i];
+
+                if (predicate(scope)) {
+                    return scope;
+                }
+            }
         }
-      }
+
+        return null;
     }
 
-    while (schemaPart.$ref) {
-      // eslint-disable-next-line no-param-reassign
-      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    /**
+     * acquire all scopes from node.
+     * @method ScopeManager#acquireAll
+     * @param {Espree.Node} node - node for the acquired scope.
+     * @returns {Scopes?} Scope array
+     */
+    acquireAll(node) {
+        return this.__get(node);
     }
 
-    let schemaText = `${this.formatSchema(schemaPart, logic)}${needDot ? "." : ""}`;
+    /**
+     * release the node.
+     * @method ScopeManager#release
+     * @param {Espree.Node} node - releasing node.
+     * @param {boolean=} inner - look up the most inner scope, default value is false.
+     * @returns {Scope?} upper scope for the node.
+     */
+    release(node, inner) {
+        const scopes = this.__get(node);
 
-    if (schemaPart.description) {
-      schemaText += `\n-> ${schemaPart.description}`;
-    }
+        if (scopes && scopes.length) {
+            const scope = scopes[0].upper;
 
-    if (schemaPart.link) {
-      schemaText += `\n-> Read more at ${schemaPart.link}`;
+            if (!scope) {
+                return null;
+            }
+            return this.acquire(scope.block, inner);
+        }
+        return null;
     }
 
-    return schemaText;
-  }
-  /**
-   * @param {Schema=} schemaPart
-   * @returns {string}
-   */
+    attach() { } // eslint-disable-line class-methods-use-this
 
+    detach() { } // eslint-disable-line class-methods-use-this
 
-  getSchemaPartDescription(schemaPart) {
-    if (!schemaPart) {
-      return "";
+    __nestScope(scope) {
+        if (scope instanceof GlobalScope) {
+            assert(this.__currentScope === null);
+            this.globalScope = scope;
+        }
+        this.__currentScope = scope;
+        return scope;
     }
 
-    while (schemaPart.$ref) {
-      // eslint-disable-next-line no-param-reassign
-      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    __nestGlobalScope(node) {
+        return this.__nestScope(new GlobalScope(this, node));
     }
 
-    let schemaText = "";
-
-    if (schemaPart.description) {
-      schemaText += `\n-> ${schemaPart.description}`;
+    __nestBlockScope(node) {
+        return this.__nestScope(new BlockScope(this, this.__currentScope, node));
     }
 
-    if (schemaPart.link) {
-      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    __nestFunctionScope(node, isMethodDefinition) {
+        return this.__nestScope(new FunctionScope(this, this.__currentScope, node, isMethodDefinition));
     }
 
-    return schemaText;
-  }
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {string}
-   */
+    __nestForScope(node) {
+        return this.__nestScope(new ForScope(this, this.__currentScope, node));
+    }
 
+    __nestCatchScope(node) {
+        return this.__nestScope(new CatchScope(this, this.__currentScope, node));
+    }
 
-  formatValidationError(error) {
-    const {
-      keyword,
-      dataPath: errorDataPath
-    } = error;
-    const dataPath = `${this.baseDataPath}${errorDataPath}`;
+    __nestWithScope(node) {
+        return this.__nestScope(new WithScope(this, this.__currentScope, node));
+    }
 
-    switch (keyword) {
-      case "type":
-        {
-          const {
-            parentSchema,
-            params
-          } = error; // eslint-disable-next-line default-case
+    __nestClassScope(node) {
+        return this.__nestScope(new ClassScope(this, this.__currentScope, node));
+    }
 
-          switch (
-          /** @type {import("ajv").TypeParams} */
-          params.type) {
-            case "number":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+    __nestSwitchScope(node) {
+        return this.__nestScope(new SwitchScope(this, this.__currentScope, node));
+    }
 
-            case "integer":
-              return `${dataPath} should be an ${this.getSchemaPartText(parentSchema, false, true)}`;
+    __nestModuleScope(node) {
+        return this.__nestScope(new ModuleScope(this, this.__currentScope, node));
+    }
 
-            case "string":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+    __nestFunctionExpressionNameScope(node) {
+        return this.__nestScope(new FunctionExpressionNameScope(this, this.__currentScope, node));
+    }
 
-            case "boolean":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+    __isES6() {
+        return this.__options.ecmaVersion >= 6;
+    }
+}
 
-            case "array":
-              return `${dataPath} should be an array:\n${this.getSchemaPartText(parentSchema)}`;
+module.exports = ScopeManager;
 
-            case "object":
-              return `${dataPath} should be an object:\n${this.getSchemaPartText(parentSchema)}`;
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-            case "null":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-            default:
-              return `${dataPath} should be:\n${this.getSchemaPartText(parentSchema)}`;
-          }
-        }
+/***/ }),
 
-      case "instanceof":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should be an instance of ${this.getSchemaPartText(parentSchema, false, true)}`;
-        }
+/***/ 16313:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-      case "pattern":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            pattern
-          } =
-          /** @type {import("ajv").PatternParams} */
-          params;
-          return `${dataPath} should match pattern ${JSON.stringify(pattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+"use strict";
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-      case "format":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            format
-          } =
-          /** @type {import("ajv").FormatParams} */
-          params;
-          return `${dataPath} should match format ${JSON.stringify(format)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-      case "formatMinimum":
-      case "formatMaximum":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            comparison,
-            limit
-          } =
-          /** @type {import("ajv").ComparisonParams} */
-          params;
-          return `${dataPath} should be ${comparison} ${JSON.stringify(limit)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-      case "minimum":
-      case "maximum":
-      case "exclusiveMinimum":
-      case "exclusiveMaximum":
-        {
-          const {
-            parentSchema,
-            params
-          } = error;
-          const {
-            comparison,
-            limit
-          } =
-          /** @type {import("ajv").ComparisonParams} */
-          params;
-          const [, ...hints] = getHints(
-          /** @type {Schema} */
-          parentSchema, true);
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-          if (hints.length === 0) {
-            hints.push(`should be ${comparison} ${limit}`);
-          }
 
-          return `${dataPath} ${hints.join(" ")}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-undefined */
 
-      case "multipleOf":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            multipleOf
-          } =
-          /** @type {import("ajv").MultipleOfParams} */
-          params;
-          return `${dataPath} should be multiple of ${multipleOf}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+const Syntax = (__webpack_require__(18350).Syntax);
 
-      case "patternRequired":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            missingPattern
-          } =
-          /** @type {import("ajv").PatternRequiredParams} */
-          params;
-          return `${dataPath} should have property matching pattern ${JSON.stringify(missingPattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+const Reference = __webpack_require__(64945);
+const Variable = __webpack_require__(82971);
+const Definition = (__webpack_require__(70665).Definition);
+const assert = __webpack_require__(39491);
 
-      case "minLength":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
+/**
+ * Test if scope is struct
+ * @param {Scope} scope - scope
+ * @param {Block} block - block
+ * @param {boolean} isMethodDefinition - is method definition
+ * @param {boolean} useDirective - use directive
+ * @returns {boolean} is strict scope
+ */
+function isStrictScope(scope, block, isMethodDefinition, useDirective) {
+    let body;
 
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty string${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
+    // When upper scope is exists and strict, inner scope is also strict.
+    if (scope.upper && scope.upper.isStrict) {
+        return true;
+    }
 
-          const length = limit - 1;
-          return `${dataPath} should be longer than ${length} character${length > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+    if (isMethodDefinition) {
+        return true;
+    }
 
-      case "minItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
+    if (scope.type === "class" || scope.type === "module") {
+        return true;
+    }
 
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty array${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
+    if (scope.type === "block" || scope.type === "switch") {
+        return false;
+    }
 
-          return `${dataPath} should not have fewer than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+    if (scope.type === "function") {
+        if (block.type === Syntax.ArrowFunctionExpression && block.body.type !== Syntax.BlockStatement) {
+            return false;
         }
 
-      case "minProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty object${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
-
-          return `${dataPath} should not have fewer than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        if (block.type === Syntax.Program) {
+            body = block;
+        } else {
+            body = block.body;
         }
 
-      case "maxLength":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          const max = limit + 1;
-          return `${dataPath} should be shorter than ${max} character${max > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        if (!body) {
+            return false;
         }
+    } else if (scope.type === "global") {
+        body = block;
+    } else {
+        return false;
+    }
 
-      case "maxItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+    // Search 'use strict' directive.
+    if (useDirective) {
+        for (let i = 0, iz = body.body.length; i < iz; ++i) {
+            const stmt = body.body[i];
 
-      case "maxProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+            if (stmt.type !== Syntax.DirectiveStatement) {
+                break;
+            }
+            if (stmt.raw === "\"use strict\"" || stmt.raw === "'use strict'") {
+                return true;
+            }
         }
+    } else {
+        for (let i = 0, iz = body.body.length; i < iz; ++i) {
+            const stmt = body.body[i];
 
-      case "uniqueItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            i
-          } =
-          /** @type {import("ajv").UniqueItemsParams} */
-          params;
-          return `${dataPath} should not contain the item '${error.data[i]}' twice${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+            if (stmt.type !== Syntax.ExpressionStatement) {
+                break;
+            }
+            const expr = stmt.expression;
 
-      case "additionalItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}. These items are valid:\n${this.getSchemaPartText(parentSchema)}`;
+            if (expr.type !== Syntax.Literal || typeof expr.value !== "string") {
+                break;
+            }
+            if (expr.raw !== null && expr.raw !== undefined) {
+                if (expr.raw === "\"use strict\"" || expr.raw === "'use strict'") {
+                    return true;
+                }
+            } else {
+                if (expr.value === "use strict") {
+                    return true;
+                }
+            }
         }
+    }
+    return false;
+}
 
-      case "contains":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should contains at least one ${this.getSchemaPartText(parentSchema, ["contains"])} item${getSchemaNonTypes(parentSchema)}.`;
-        }
+/**
+ * Register scope
+ * @param {ScopeManager} scopeManager - scope manager
+ * @param {Scope} scope - scope
+ * @returns {void}
+ */
+function registerScope(scopeManager, scope) {
+    scopeManager.scopes.push(scope);
 
-      case "required":
-        {
-          const {
-            parentSchema,
-            params
-          } = error;
-          const missingProperty =
-          /** @type {import("ajv").DependenciesParams} */
-          params.missingProperty.replace(/^\./, "");
-          const hasProperty = parentSchema && Boolean(
-          /** @type {Schema} */
-          parentSchema.properties &&
-          /** @type {Schema} */
-          parentSchema.properties[missingProperty]);
-          return `${dataPath} misses the property '${missingProperty}'${getSchemaNonTypes(parentSchema)}.${hasProperty ? ` Should be:\n${this.getSchemaPartText(parentSchema, ["properties", missingProperty])}` : this.getSchemaPartDescription(parentSchema)}`;
-        }
+    const scopes = scopeManager.__nodeToScope.get(scope.block);
 
-      case "additionalProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            additionalProperty
-          } =
-          /** @type {import("ajv").AdditionalPropertiesParams} */
-          params;
-          return `${dataPath} has an unknown property '${additionalProperty}'${getSchemaNonTypes(parentSchema)}. These properties are valid:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+    if (scopes) {
+        scopes.push(scope);
+    } else {
+        scopeManager.__nodeToScope.set(scope.block, [scope]);
+    }
+}
 
-      case "dependencies":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            property,
-            deps
-          } =
-          /** @type {import("ajv").DependenciesParams} */
-          params;
-          const dependencies = deps.split(",").map(
-          /**
-           * @param {string} dep
-           * @returns {string}
-           */
-          dep => `'${dep.trim()}'`).join(", ");
-          return `${dataPath} should have properties ${dependencies} when property '${property}' is present${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+/**
+ * Should be statically
+ * @param {Object} def - def
+ * @returns {boolean} should be statically
+ */
+function shouldBeStatically(def) {
+    return (
+        (def.type === Variable.ClassName) ||
+        (def.type === Variable.Variable && def.parent.kind !== "var")
+    );
+}
 
-      case "propertyNames":
-        {
-          const {
-            params,
-            parentSchema,
-            schema
-          } = error;
-          const {
-            propertyName
-          } =
-          /** @type {import("ajv").PropertyNamesParams} */
-          params;
-          return `${dataPath} property name '${propertyName}' is invalid${getSchemaNonTypes(parentSchema)}. Property names should be match format ${JSON.stringify(schema.format)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+/**
+ * @class Scope
+ */
+class Scope {
+    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
 
-      case "enum":
-        {
-          const {
-            parentSchema
-          } = error;
+        /**
+         * One of 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.
+         * @member {String} Scope#type
+         */
+        this.type = type;
 
-          if (parentSchema &&
-          /** @type {Schema} */
-          parentSchema.enum &&
-          /** @type {Schema} */
-          parentSchema.enum.length === 1) {
-            return `${dataPath} should be ${this.getSchemaPartText(parentSchema, false, true)}`;
-          }
+        /**
+         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name
+         * : Variable }</code>.
+         * @member {Map} Scope#set
+         */
+        this.set = new Map();
 
-          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+        /**
+         * The tainted variables of this scope, as <code>{ Variable.name :
+         * boolean }</code>.
+         * @member {Map} Scope#taints */
+        this.taints = new Map();
 
-      case "const":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should be equal to constant ${this.getSchemaPartText(parentSchema, false, true)}`;
-        }
+        /**
+         * Generally, through the lexical scoping of JS you can always know
+         * which variable an identifier in the source code refers to. There are
+         * a few exceptions to this rule. With 'global' and 'with' scopes you
+         * can only decide at runtime which variable a reference refers to.
+         * Moreover, if 'eval()' is used in a scope, it might introduce new
+         * bindings in this or its parent scopes.
+         * All those scopes are considered 'dynamic'.
+         * @member {boolean} Scope#dynamic
+         */
+        this.dynamic = this.type === "global" || this.type === "with";
 
-      case "not":
-        {
-          const postfix = likeObject(
-          /** @type {Schema} */
-          error.parentSchema) ? `\n${this.getSchemaPartText(error.parentSchema)}` : "";
-          const schemaOutput = this.getSchemaPartText(error.schema, false, false, false);
+        /**
+         * A reference to the scope-defining syntax node.
+         * @member {espree.Node} Scope#block
+         */
+        this.block = block;
 
-          if (canApplyNot(error.schema)) {
-            return `${dataPath} should be any ${schemaOutput}${postfix}.`;
-          }
+        /**
+         * The {@link Reference|references} that are not resolved with this scope.
+         * @member {Reference[]} Scope#through
+         */
+        this.through = [];
 
-          const {
-            schema,
-            parentSchema
-          } = error;
-          return `${dataPath} should not be ${this.getSchemaPartText(schema, false, true)}${parentSchema && likeObject(parentSchema) ? `\n${this.getSchemaPartText(parentSchema)}` : ""}`;
-        }
+        /**
+         * The scoped {@link Variable}s of this scope. In the case of a
+         * 'function' scope this includes the automatic argument <em>arguments</em> as
+         * its first element, as well as all further formal arguments.
+         * @member {Variable[]} Scope#variables
+         */
+        this.variables = [];
 
-      case "oneOf":
-      case "anyOf":
-        {
-          const {
-            parentSchema,
-            children
-          } = error;
+        /**
+         * Any variable {@link Reference|reference} found in this scope. This
+         * includes occurrences of local variables as well as variables from
+         * parent scopes (including the global scope). For local variables
+         * this also includes defining occurrences (like in a 'var' statement).
+         * In a 'function' scope this does not include the occurrences of the
+         * formal parameter in the parameter list.
+         * @member {Reference[]} Scope#references
+         */
+        this.references = [];
 
-          if (children && children.length > 0) {
-            if (error.schema.length === 1) {
-              const lastChild = children[children.length - 1];
-              const remainingChildren = children.slice(0, children.length - 1);
-              return this.formatValidationError(Object.assign({}, lastChild, {
-                children: remainingChildren,
-                parentSchema: Object.assign({}, parentSchema, lastChild.parentSchema)
-              }));
-            }
+        /**
+         * For 'global' and 'function' scopes, this is a self-reference. For
+         * other scope types this is the <em>variableScope</em> value of the
+         * parent scope.
+         * @member {Scope} Scope#variableScope
+         */
+        this.variableScope =
+            (this.type === "global" || this.type === "function" || this.type === "module") ? this : upperScope.variableScope;
 
-            let filteredChildren = filterChildren(children);
+        /**
+         * Whether this scope is created by a FunctionExpression.
+         * @member {boolean} Scope#functionExpressionScope
+         */
+        this.functionExpressionScope = false;
 
-            if (filteredChildren.length === 1) {
-              return this.formatValidationError(filteredChildren[0]);
-            }
+        /**
+         * Whether this is a scope that contains an 'eval()' invocation.
+         * @member {boolean} Scope#directCallToEvalScope
+         */
+        this.directCallToEvalScope = false;
 
-            filteredChildren = groupChildrenByFirstChild(filteredChildren);
-            return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}\nDetails:\n${filteredChildren.map(
-            /**
-             * @param {SchemaUtilErrorObject} nestedError
-             * @returns {string}
-             */
-            nestedError => ` * ${indent(this.formatValidationError(nestedError), "   ")}`).join("\n")}`;
-          }
+        /**
+         * @member {boolean} Scope#thisFound
+         */
+        this.thisFound = false;
 
-          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+        this.__left = [];
 
-      case "if":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            failingKeyword
-          } =
-          /** @type {import("ajv").IfParams} */
-          params;
-          return `${dataPath} should match "${failingKeyword}" schema:\n${this.getSchemaPartText(parentSchema, [failingKeyword])}`;
-        }
+        /**
+         * Reference to the parent {@link Scope|scope}.
+         * @member {Scope} Scope#upper
+         */
+        this.upper = upperScope;
 
-      case "absolutePath":
-        {
-          const {
-            message,
-            parentSchema
-          } = error;
-          return `${dataPath}: ${message}${this.getSchemaPartDescription(parentSchema)}`;
+        /**
+         * Whether 'use strict' is in effect in this scope.
+         * @member {boolean} Scope#isStrict
+         */
+        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());
+
+        /**
+         * List of nested {@link Scope}s.
+         * @member {Scope[]} Scope#childScopes
+         */
+        this.childScopes = [];
+        if (this.upper) {
+            this.upper.childScopes.push(this);
         }
 
-      /* istanbul ignore next */
+        this.__declaredVariables = scopeManager.__declaredVariables;
 
-      default:
-        {
-          const {
-            message,
-            parentSchema
-          } = error;
-          const ErrorInJSON = JSON.stringify(error, null, 2); // For `custom`, `false schema`, `$ref` keywords
-          // Fallback for unknown keywords
+        registerScope(scopeManager, this);
+    }
 
-          return `${dataPath} ${message} (${ErrorInJSON}).\n${this.getSchemaPartText(parentSchema, false)}`;
-        }
+    __shouldStaticallyClose(scopeManager) {
+        return (!this.dynamic || scopeManager.__isOptimistic());
     }
-  }
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @returns {string}
-   */
 
+    __shouldStaticallyCloseForGlobal(ref) {
 
-  formatValidationErrors(errors) {
-    return errors.map(error => {
-      let formattedError = this.formatValidationError(error);
+        // On global scope, let/const/class declarations should be resolved statically.
+        const name = ref.identifier.name;
 
-      if (this.postFormatter) {
-        formattedError = this.postFormatter(formattedError, error);
-      }
+        if (!this.set.has(name)) {
+            return false;
+        }
 
-      return ` - ${indent(formattedError, "   ")}`;
-    }).join("\n");
-  }
+        const variable = this.set.get(name);
+        const defs = variable.defs;
 
-}
+        return defs.length > 0 && defs.every(shouldBeStatically);
+    }
 
-var _default = ValidationError;
-exports.Z = _default;
+    __staticCloseRef(ref) {
+        if (!this.__resolve(ref)) {
+            this.__delegateToUpperScope(ref);
+        }
+    }
 
-/***/ }),
-
-/***/ 81184:
-/***/ (function(module) {
+    __dynamicCloseRef(ref) {
 
-"use strict";
+        // notify all names are through to global
+        let current = this;
 
+        do {
+            current.through.push(ref);
+            current = current.upper;
+        } while (current);
+    }
 
-/**
- * @typedef {[number, boolean]} RangeValue
- */
+    __globalCloseRef(ref) {
 
-/**
- * @callback RangeValueCallback
- * @param {RangeValue} rangeValue
- * @returns {boolean}
- */
-class Range {
-  /**
-   * @param {"left" | "right"} side
-   * @param {boolean} exclusive
-   * @returns {">" | ">=" | "<" | "<="}
-   */
-  static getOperator(side, exclusive) {
-    if (side === "left") {
-      return exclusive ? ">" : ">=";
+        // let/const/class declarations should be resolved statically.
+        // others should be resolved dynamically.
+        if (this.__shouldStaticallyCloseForGlobal(ref)) {
+            this.__staticCloseRef(ref);
+        } else {
+            this.__dynamicCloseRef(ref);
+        }
     }
 
-    return exclusive ? "<" : "<=";
-  }
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
-
+    __close(scopeManager) {
+        let closeRef;
 
-  static formatRight(value, logic, exclusive) {
-    if (logic === false) {
-      return Range.formatLeft(value, !logic, !exclusive);
-    }
+        if (this.__shouldStaticallyClose(scopeManager)) {
+            closeRef = this.__staticCloseRef;
+        } else if (this.type !== "global") {
+            closeRef = this.__dynamicCloseRef;
+        } else {
+            closeRef = this.__globalCloseRef;
+        }
 
-    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
-  }
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
+        // Try Resolving all references in this scope.
+        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
+            const ref = this.__left[i];
 
+            closeRef.call(this, ref);
+        }
+        this.__left = null;
 
-  static formatLeft(value, logic, exclusive) {
-    if (logic === false) {
-      return Range.formatRight(value, !logic, !exclusive);
+        return this.upper;
     }
 
-    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
-  }
-  /**
-   * @param {number} start left side value
-   * @param {number} end right side value
-   * @param {boolean} startExclusive is range exclusive from left side
-   * @param {boolean} endExclusive is range exclusive from right side
-   * @param {boolean} logic is not logic applied
-   * @returns {string}
-   */
+    // To override by function scopes.
+    // References in default parameters isn't resolved to variables which are in their function body.
+    __isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars
+        return true;
+    }
 
+    __resolve(ref) {
+        const name = ref.identifier.name;
 
-  static formatRange(start, end, startExclusive, endExclusive, logic) {
-    let result = "should be";
-    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
-    result += logic ? "and" : "or";
-    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
-    return result;
-  }
-  /**
-   * @param {Array<RangeValue>} values
-   * @param {boolean} logic is not logic applied
-   * @return {RangeValue} computed value and it's exclusive flag
-   */
+        if (!this.set.has(name)) {
+            return false;
+        }
+        const variable = this.set.get(name);
 
+        if (!this.__isValidResolution(ref, variable)) {
+            return false;
+        }
+        variable.references.push(ref);
+        variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
+        if (ref.tainted) {
+            variable.tainted = true;
+            this.taints.set(variable.name, true);
+        }
+        ref.resolved = variable;
 
-  static getRangeValue(values, logic) {
-    let minMax = logic ? Infinity : -Infinity;
-    let j = -1;
-    const predicate = logic ?
-    /** @type {RangeValueCallback} */
-    ([value]) => value <= minMax :
-    /** @type {RangeValueCallback} */
-    ([value]) => value >= minMax;
+        return true;
+    }
 
-    for (let i = 0; i < values.length; i++) {
-      if (predicate(values[i])) {
-        [minMax] = values[i];
-        j = i;
-      }
+    __delegateToUpperScope(ref) {
+        if (this.upper) {
+            this.upper.__left.push(ref);
+        }
+        this.through.push(ref);
     }
 
-    if (j > -1) {
-      return values[j];
+    __addDeclaredVariablesOfNode(variable, node) {
+        if (node === null || node === undefined) {
+            return;
+        }
+
+        let variables = this.__declaredVariables.get(node);
+
+        if (variables === null || variables === undefined) {
+            variables = [];
+            this.__declaredVariables.set(node, variables);
+        }
+        if (variables.indexOf(variable) === -1) {
+            variables.push(variable);
+        }
     }
 
-    return [Infinity, true];
-  }
+    __defineGeneric(name, set, variables, node, def) {
+        let variable;
 
-  constructor() {
-    /** @type {Array<RangeValue>} */
-    this._left = [];
-    /** @type {Array<RangeValue>} */
+        variable = set.get(name);
+        if (!variable) {
+            variable = new Variable(name, this);
+            set.set(name, variable);
+            variables.push(variable);
+        }
 
-    this._right = [];
-  }
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
+        if (def) {
+            variable.defs.push(def);
+            this.__addDeclaredVariablesOfNode(variable, def.node);
+            this.__addDeclaredVariablesOfNode(variable, def.parent);
+        }
+        if (node) {
+            variable.identifiers.push(node);
+        }
+    }
+
+    __define(node, def) {
+        if (node && node.type === Syntax.Identifier) {
+            this.__defineGeneric(
+                node.name,
+                this.set,
+                this.variables,
+                node,
+                def
+            );
+        }
+    }
 
+    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
 
-  left(value, exclusive = false) {
-    this._left.push([value, exclusive]);
-  }
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
+        // because Array element may be null
+        if (!node || node.type !== Syntax.Identifier) {
+            return;
+        }
 
+        // Specially handle like `this`.
+        if (node.name === "super") {
+            return;
+        }
 
-  right(value, exclusive = false) {
-    this._right.push([value, exclusive]);
-  }
-  /**
-   * @param {boolean} logic is not logic applied
-   * @return {string} "smart" range string representation
-   */
+        const ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
 
+        this.references.push(ref);
+        this.__left.push(ref);
+    }
 
-  format(logic = true) {
-    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
-    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
+    __detectEval() {
+        let current = this;
 
-    if (!Number.isFinite(start) && !Number.isFinite(end)) {
-      return "";
+        this.directCallToEvalScope = true;
+        do {
+            current.dynamic = true;
+            current = current.upper;
+        } while (current);
     }
 
-    const realStart = leftExclusive ? start + 1 : start;
-    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
+    __detectThis() {
+        this.thisFound = true;
+    }
 
-    if (realStart === realEnd) {
-      return `should be ${logic ? "" : "!"}= ${realStart}`;
-    } // e.g. 4 < x < ∞
+    __isClosed() {
+        return this.__left === null;
+    }
 
+    /**
+     * returns resolved {Reference}
+     * @method Scope#resolve
+     * @param {Espree.Identifier} ident - identifier to be resolved.
+     * @returns {Reference} reference
+     */
+    resolve(ident) {
+        let ref, i, iz;
 
-    if (Number.isFinite(start) && !Number.isFinite(end)) {
-      return Range.formatLeft(start, logic, leftExclusive);
-    } // e.g. ∞ < x < 4
+        assert(this.__isClosed(), "Scope should be closed.");
+        assert(ident.type === Syntax.Identifier, "Target should be identifier.");
+        for (i = 0, iz = this.references.length; i < iz; ++i) {
+            ref = this.references[i];
+            if (ref.identifier === ident) {
+                return ref;
+            }
+        }
+        return null;
+    }
 
+    /**
+     * returns this scope is static
+     * @method Scope#isStatic
+     * @returns {boolean} static
+     */
+    isStatic() {
+        return !this.dynamic;
+    }
 
-    if (!Number.isFinite(start) && Number.isFinite(end)) {
-      return Range.formatRight(end, logic, rightExclusive);
+    /**
+     * returns this scope has materialized arguments
+     * @method Scope#isArgumentsMaterialized
+     * @returns {boolean} arguemnts materialized
+     */
+    isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this
+        return true;
     }
 
-    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
-  }
+    /**
+     * returns this scope has materialized `this` reference
+     * @method Scope#isThisMaterialized
+     * @returns {boolean} this materialized
+     */
+    isThisMaterialized() { // eslint-disable-line class-methods-use-this
+        return true;
+    }
 
+    isUsedName(name) {
+        if (this.set.has(name)) {
+            return true;
+        }
+        for (let i = 0, iz = this.through.length; i < iz; ++i) {
+            if (this.through[i].identifier.name === name) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
 
-module.exports = Range;
-
-/***/ }),
+class GlobalScope extends Scope {
+    constructor(scopeManager, block) {
+        super(scopeManager, "global", null, block, false);
+        this.implicit = {
+            set: new Map(),
+            variables: [],
 
-/***/ 79926:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+            /**
+            * List of {@link Reference}s that are left to be resolved (i.e. which
+            * need to be linked to the variable they refer to).
+            * @member {Reference[]} Scope#implicit#left
+            */
+            left: []
+        };
+    }
 
-"use strict";
+    __close(scopeManager) {
+        const implicit = [];
 
+        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
+            const ref = this.__left[i];
 
-const Range = __webpack_require__(81184);
-/** @typedef {import("../validate").Schema} Schema */
+            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
+                implicit.push(ref.__maybeImplicitGlobal);
+            }
+        }
 
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @return {string[]}
- */
+        // create an implicit global variable from assignment expression
+        for (let i = 0, iz = implicit.length; i < iz; ++i) {
+            const info = implicit[i];
 
+            this.__defineImplicit(info.pattern,
+                new Definition(
+                    Variable.ImplicitGlobalVariable,
+                    info.pattern,
+                    info.node,
+                    null,
+                    null,
+                    null
+                ));
 
-module.exports.stringHints = function stringHints(schema, logic) {
-  const hints = [];
-  let type = "string";
-  const currentSchema = { ...schema
-  };
+        }
 
-  if (!logic) {
-    const tmpLength = currentSchema.minLength;
-    const tmpFormat = currentSchema.formatMinimum;
-    const tmpExclusive = currentSchema.formatExclusiveMaximum;
-    currentSchema.minLength = currentSchema.maxLength;
-    currentSchema.maxLength = tmpLength;
-    currentSchema.formatMinimum = currentSchema.formatMaximum;
-    currentSchema.formatMaximum = tmpFormat;
-    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
-    currentSchema.formatExclusiveMinimum = !tmpExclusive;
-  }
+        this.implicit.left = this.__left;
 
-  if (typeof currentSchema.minLength === "number") {
-    if (currentSchema.minLength === 1) {
-      type = "non-empty string";
-    } else {
-      const length = Math.max(currentSchema.minLength - 1, 0);
-      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
+        return super.__close(scopeManager);
     }
-  }
 
-  if (typeof currentSchema.maxLength === "number") {
-    if (currentSchema.maxLength === 0) {
-      type = "empty string";
-    } else {
-      const length = currentSchema.maxLength + 1;
-      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
+    __defineImplicit(node, def) {
+        if (node && node.type === Syntax.Identifier) {
+            this.__defineGeneric(
+                node.name,
+                this.implicit.set,
+                this.implicit.variables,
+                node,
+                def
+            );
+        }
     }
-  }
+}
 
-  if (currentSchema.pattern) {
-    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
-  }
+class ModuleScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "module", upperScope, block, false);
+    }
+}
 
-  if (currentSchema.format) {
-    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
-  }
+class FunctionExpressionNameScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "function-expression-name", upperScope, block, false);
+        this.__define(block.id,
+            new Definition(
+                Variable.FunctionName,
+                block.id,
+                block,
+                null,
+                null,
+                null
+            ));
+        this.functionExpressionScope = true;
+    }
+}
 
-  if (currentSchema.formatMinimum) {
-    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
-  }
+class CatchScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "catch", upperScope, block, false);
+    }
+}
 
-  if (currentSchema.formatMaximum) {
-    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
-  }
+class WithScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "with", upperScope, block, false);
+    }
 
-  return [type].concat(hints);
-};
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @return {string[]}
- */
+    __close(scopeManager) {
+        if (this.__shouldStaticallyClose(scopeManager)) {
+            return super.__close(scopeManager);
+        }
 
+        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
+            const ref = this.__left[i];
 
-module.exports.numberHints = function numberHints(schema, logic) {
-  const hints = [schema.type === "integer" ? "integer" : "number"];
-  const range = new Range();
+            ref.tainted = true;
+            this.__delegateToUpperScope(ref);
+        }
+        this.__left = null;
 
-  if (typeof schema.minimum === "number") {
-    range.left(schema.minimum);
-  }
+        return this.upper;
+    }
+}
 
-  if (typeof schema.exclusiveMinimum === "number") {
-    range.left(schema.exclusiveMinimum, true);
-  }
+class BlockScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "block", upperScope, block, false);
+    }
+}
 
-  if (typeof schema.maximum === "number") {
-    range.right(schema.maximum);
-  }
+class SwitchScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "switch", upperScope, block, false);
+    }
+}
 
-  if (typeof schema.exclusiveMaximum === "number") {
-    range.right(schema.exclusiveMaximum, true);
-  }
+class FunctionScope extends Scope {
+    constructor(scopeManager, upperScope, block, isMethodDefinition) {
+        super(scopeManager, "function", upperScope, block, isMethodDefinition);
 
-  const rangeFormat = range.format(logic);
+        // section 9.2.13, FunctionDeclarationInstantiation.
+        // NOTE Arrow functions never have an arguments objects.
+        if (this.block.type !== Syntax.ArrowFunctionExpression) {
+            this.__defineArguments();
+        }
+    }
 
-  if (rangeFormat) {
-    hints.push(rangeFormat);
-  }
+    isArgumentsMaterialized() {
 
-  if (typeof schema.multipleOf === "number") {
-    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
-  }
+        // TODO(Constellation)
+        // We can more aggressive on this condition like this.
+        //
+        // function t() {
+        //     // arguments of t is always hidden.
+        //     function arguments() {
+        //     }
+        // }
+        if (this.block.type === Syntax.ArrowFunctionExpression) {
+            return false;
+        }
 
-  return hints;
-};
-
-/***/ }),
-
-/***/ 74315:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const ConstDependency = __webpack_require__(76911);
-const BasicEvaluatedExpression = __webpack_require__(950);
-const {
-	toConstantDependency,
-	evaluateToString
-} = __webpack_require__(93998);
-const ChunkNameRuntimeModule = __webpack_require__(84519);
-const GetFullHashRuntimeModule = __webpack_require__(88732);
+        if (!this.isStatic()) {
+            return true;
+        }
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+        const variable = this.set.get("arguments");
 
-/* eslint-disable camelcase */
-const REPLACEMENTS = {
-	__webpack_require__: {
-		expr: RuntimeGlobals.require,
-		req: [RuntimeGlobals.require],
-		type: "function",
-		assign: false
-	},
-	__webpack_public_path__: {
-		expr: RuntimeGlobals.publicPath,
-		req: [RuntimeGlobals.publicPath],
-		type: "string",
-		assign: true
-	},
-	__webpack_base_uri__: {
-		expr: RuntimeGlobals.baseURI,
-		req: [RuntimeGlobals.baseURI],
-		type: "string",
-		assign: true
-	},
-	__webpack_modules__: {
-		expr: RuntimeGlobals.moduleFactories,
-		req: [RuntimeGlobals.moduleFactories],
-		type: "object",
-		assign: false
-	},
-	__webpack_chunk_load__: {
-		expr: RuntimeGlobals.ensureChunk,
-		req: [RuntimeGlobals.ensureChunk],
-		type: "function",
-		assign: true
-	},
-	__non_webpack_require__: {
-		expr: "require",
-		req: null,
-		type: undefined, // type is not known, depends on environment
-		assign: true
-	},
-	__webpack_nonce__: {
-		expr: RuntimeGlobals.scriptNonce,
-		req: [RuntimeGlobals.scriptNonce],
-		type: "string",
-		assign: true
-	},
-	__webpack_hash__: {
-		expr: `${RuntimeGlobals.getFullHash}()`,
-		req: [RuntimeGlobals.getFullHash],
-		type: "string",
-		assign: false
-	},
-	__webpack_chunkname__: {
-		expr: RuntimeGlobals.chunkName,
-		req: [RuntimeGlobals.chunkName],
-		type: "string",
-		assign: false
-	},
-	__webpack_get_script_filename__: {
-		expr: RuntimeGlobals.getChunkScriptFilename,
-		req: [RuntimeGlobals.getChunkScriptFilename],
-		type: "function",
-		assign: true
-	},
-	__webpack_runtime_id__: {
-		expr: RuntimeGlobals.runtimeId,
-		req: [RuntimeGlobals.runtimeId],
-		assign: false
-	},
-	"require.onError": {
-		expr: RuntimeGlobals.uncaughtErrorHandler,
-		req: [RuntimeGlobals.uncaughtErrorHandler],
-		type: undefined, // type is not known, could be function or undefined
-		assign: true // is never a pattern
-	},
-	__system_context__: {
-		expr: RuntimeGlobals.systemContext,
-		req: [RuntimeGlobals.systemContext],
-		type: "object",
-		assign: false
-	},
-	__webpack_share_scopes__: {
-		expr: RuntimeGlobals.shareScopeMap,
-		req: [RuntimeGlobals.shareScopeMap],
-		type: "object",
-		assign: false
-	},
-	__webpack_init_sharing__: {
-		expr: RuntimeGlobals.initializeSharing,
-		req: [RuntimeGlobals.initializeSharing],
-		type: "function",
-		assign: true
-	}
-};
-/* eslint-enable camelcase */
+        assert(variable, "Always have arguments variable.");
+        return variable.tainted || variable.references.length !== 0;
+    }
 
-class APIPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"APIPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
+    isThisMaterialized() {
+        if (!this.isStatic()) {
+            return true;
+        }
+        return this.thisFound;
+    }
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.chunkName)
-					.tap("APIPlugin", chunk => {
-						compilation.addRuntimeModule(
-							chunk,
-							new ChunkNameRuntimeModule(chunk.name)
-						);
-						return true;
-					});
+    __defineArguments() {
+        this.__defineGeneric(
+            "arguments",
+            this.set,
+            this.variables,
+            null,
+            null
+        );
+        this.taints.set("arguments", true);
+    }
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.getFullHash)
-					.tap("APIPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(chunk, new GetFullHashRuntimeModule());
-						return true;
-					});
+    // References in default parameters isn't resolved to variables which are in their function body.
+    //     const x = 1
+    //     function f(a = x) { // This `x` is resolved to the `x` in the outer scope.
+    //         const x = 2
+    //         console.log(a)
+    //     }
+    __isValidResolution(ref, variable) {
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 */
-				const handler = parser => {
-					Object.keys(REPLACEMENTS).forEach(key => {
-						const info = REPLACEMENTS[key];
-						parser.hooks.expression
-							.for(key)
-							.tap(
-								"APIPlugin",
-								toConstantDependency(parser, info.expr, info.req)
-							);
-						if (info.assign === false) {
-							parser.hooks.assign.for(key).tap("APIPlugin", expr => {
-								const err = new WebpackError(`${key} must not be assigned`);
-								err.loc = expr.loc;
-								throw err;
-							});
-						}
-						if (info.type) {
-							parser.hooks.evaluateTypeof
-								.for(key)
-								.tap("APIPlugin", evaluateToString(info.type));
-						}
-					});
+        // If `options.nodejsScope` is true, `this.block` becomes a Program node.
+        if (this.block.type === "Program") {
+            return true;
+        }
 
-					parser.hooks.expression
-						.for("__webpack_layer__")
-						.tap("APIPlugin", expr => {
-							const dep = new ConstDependency(
-								JSON.stringify(parser.state.module.layer),
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateIdentifier
-						.for("__webpack_layer__")
-						.tap("APIPlugin", expr =>
-							(parser.state.module.layer === null
-								? new BasicEvaluatedExpression().setNull()
-								: new BasicEvaluatedExpression().setString(
-										parser.state.module.layer
-								  )
-							).setRange(expr.range)
-						);
-					parser.hooks.evaluateTypeof
-						.for("__webpack_layer__")
-						.tap("APIPlugin", expr =>
-							new BasicEvaluatedExpression()
-								.setString(
-									parser.state.module.layer === null ? "object" : "string"
-								)
-								.setRange(expr.range)
-						);
+        const bodyStart = this.block.body.range[0];
 
-					parser.hooks.expression
-						.for("__webpack_module__.id")
-						.tap("APIPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"__webpack_module__.id";
-							const dep = new ConstDependency(
-								parser.state.module.moduleArgument + ".id",
-								expr.range,
-								[RuntimeGlobals.moduleId]
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
+        // It's invalid resolution in the following case:
+        return !(
+            variable.scope === this &&
+            ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.
+            variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.
+        );
+    }
+}
 
-					parser.hooks.expression
-						.for("__webpack_module__")
-						.tap("APIPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"__webpack_module__";
-							const dep = new ConstDependency(
-								parser.state.module.moduleArgument,
-								expr.range,
-								[RuntimeGlobals.module]
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for("__webpack_module__")
-						.tap("APIPlugin", evaluateToString("object"));
-				};
+class ForScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "for", upperScope, block, false);
+    }
+}
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("APIPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("APIPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("APIPlugin", handler);
-			}
-		);
-	}
+class ClassScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "class", upperScope, block, false);
+    }
 }
 
-module.exports = APIPlugin;
+module.exports = {
+    Scope,
+    GlobalScope,
+    ModuleScope,
+    FunctionExpressionNameScope,
+    CatchScope,
+    WithScope,
+    BlockScope,
+    SwitchScope,
+    FunctionScope,
+    ForScope,
+    ClassScope
+};
+
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 77198:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 82971:
+/***/ (function(module) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-const WebpackError = __webpack_require__(53799);
-const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-/**
- * @param {string=} method method name
- * @returns {string} message
- */
-function createMessage(method) {
-	return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
-}
 
 /**
- * @constructor
+ * A Variable represents a locally scoped identifier. These include arguments to
+ * functions.
+ * @class Variable
  */
-function Message() {
-	/** @type {string} */
-	this.stack = undefined;
-	Error.captureStackTrace(this);
-	/** @type {RegExpMatchArray} */
-	const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
+class Variable {
+    constructor(name, scope) {
 
-	this.message = match && match[1] ? createMessage(match[1]) : createMessage();
-}
+        /**
+         * The variable name, as given in the source code.
+         * @member {String} Variable#name
+         */
+        this.name = name;
 
-/**
- * Error for abstract method
- * @example
- * class FooClass {
- *     abstractMethod() {
- *         throw new AbstractMethodError(); // error message: Abstract method FooClass.abstractMethod. Must be overridden.
- *     }
- * }
- *
- */
-class AbstractMethodError extends WebpackError {
-	constructor() {
-		super(new Message().message);
-		this.name = "AbstractMethodError";
-	}
+        /**
+         * List of defining occurrences of this variable (like in 'var ...'
+         * statements or as parameter), as AST nodes.
+         * @member {espree.Identifier[]} Variable#identifiers
+         */
+        this.identifiers = [];
+
+        /**
+         * List of {@link Reference|references} of this variable (excluding parameter entries)
+         * in its defining scope and all nested scopes. For defining
+         * occurrences only see {@link Variable#defs}.
+         * @member {Reference[]} Variable#references
+         */
+        this.references = [];
+
+        /**
+         * List of defining occurrences of this variable (like in 'var ...'
+         * statements or as parameter), as custom objects.
+         * @member {Definition[]} Variable#defs
+         */
+        this.defs = [];
+
+        this.tainted = false;
+
+        /**
+         * Whether this is a stack variable.
+         * @member {boolean} Variable#stack
+         */
+        this.stack = true;
+
+        /**
+         * Reference to the enclosing Scope.
+         * @member {Scope} Variable#scope
+         */
+        this.scope = scope;
+    }
 }
 
-module.exports = AbstractMethodError;
+Variable.CatchClause = "CatchClause";
+Variable.Parameter = "Parameter";
+Variable.FunctionName = "FunctionName";
+Variable.ClassName = "ClassName";
+Variable.Variable = "Variable";
+Variable.ImportBinding = "ImportBinding";
+Variable.ImplicitGlobalVariable = "ImplicitGlobalVariable";
+
+module.exports = Variable;
+
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 47736:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 81217:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-"use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-const DependenciesBlock = __webpack_require__(71040);
-const makeSerializable = __webpack_require__(33032);
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+(function () {
+    'use strict';
 
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/Hash")} Hash */
+    var estraverse = __webpack_require__(50165);
 
-class AsyncDependenciesBlock extends DependenciesBlock {
-	/**
-	 * @param {ChunkGroupOptions & { entryOptions?: EntryOptions }} groupOptions options for the group
-	 * @param {DependencyLocation=} loc the line of code
-	 * @param {string=} request the request
-	 */
-	constructor(groupOptions, loc, request) {
-		super();
-		if (typeof groupOptions === "string") {
-			groupOptions = { name: groupOptions };
-		} else if (!groupOptions) {
-			groupOptions = { name: undefined };
-		}
-		this.groupOptions = groupOptions;
-		this.loc = loc;
-		this.request = request;
-		this._stringifiedGroupOptions = undefined;
-	}
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
 
-	/**
-	 * @returns {string} The name of the chunk
-	 */
-	get chunkName() {
-		return this.groupOptions.name;
-	}
+    function isProperty(nodeType, key) {
+        return (nodeType === estraverse.Syntax.ObjectExpression || nodeType === estraverse.Syntax.ObjectPattern) && key === 'properties';
+    }
 
-	/**
-	 * @param {string} value The new chunk name
-	 * @returns {void}
-	 */
-	set chunkName(value) {
-		if (this.groupOptions.name !== value) {
-			this.groupOptions.name = value;
-			this._stringifiedGroupOptions = undefined;
-		}
-	}
+    function Visitor(visitor, options) {
+        options = options || {};
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph } = context;
-		if (this._stringifiedGroupOptions === undefined) {
-			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
-		}
-		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
-		hash.update(
-			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
-		);
-		super.updateHash(hash, context);
-	}
+        this.__visitor = visitor ||  this;
+        this.__childVisitorKeys = options.childVisitorKeys
+            ? Object.assign({}, estraverse.VisitorKeys, options.childVisitorKeys)
+            : estraverse.VisitorKeys;
+        if (options.fallback === 'iteration') {
+            this.__fallback = Object.keys;
+        } else if (typeof options.fallback === 'function') {
+            this.__fallback = options.fallback;
+        }
+    }
 
-	serialize(context) {
-		const { write } = context;
-		write(this.groupOptions);
-		write(this.loc);
-		write(this.request);
-		super.serialize(context);
-	}
+    /* Default method for visiting children.
+     * When you need to call default visiting operation inside custom visiting
+     * operation, you can use it with `this.visitChildren(node)`.
+     */
+    Visitor.prototype.visitChildren = function (node) {
+        var type, children, i, iz, j, jz, child;
 
-	deserialize(context) {
-		const { read } = context;
-		this.groupOptions = read();
-		this.loc = read();
-		this.request = read();
-		super.deserialize(context);
-	}
-}
+        if (node == null) {
+            return;
+        }
 
-makeSerializable(AsyncDependenciesBlock, "webpack/lib/AsyncDependenciesBlock");
+        type = node.type || estraverse.Syntax.Property;
 
-Object.defineProperty(AsyncDependenciesBlock.prototype, "module", {
-	get() {
-		throw new Error(
-			"module property was removed from AsyncDependenciesBlock (it's not needed)"
-		);
-	},
-	set() {
-		throw new Error(
-			"module property was removed from AsyncDependenciesBlock (it's not needed)"
-		);
-	}
-});
+        children = this.__childVisitorKeys[type];
+        if (!children) {
+            if (this.__fallback) {
+                children = this.__fallback(node);
+            } else {
+                throw new Error('Unknown node type ' + type + '.');
+            }
+        }
 
-module.exports = AsyncDependenciesBlock;
+        for (i = 0, iz = children.length; i < iz; ++i) {
+            child = node[children[i]];
+            if (child) {
+                if (Array.isArray(child)) {
+                    for (j = 0, jz = child.length; j < jz; ++j) {
+                        if (child[j]) {
+                            if (isNode(child[j]) || isProperty(type, children[i])) {
+                                this.visit(child[j]);
+                            }
+                        }
+                    }
+                } else if (isNode(child)) {
+                    this.visit(child);
+                }
+            }
+        }
+    };
 
+    /* Dispatching node. */
+    Visitor.prototype.visit = function (node) {
+        var type;
 
-/***/ }),
+        if (node == null) {
+            return;
+        }
 
-/***/ 30111:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+        type = node.type || estraverse.Syntax.Property;
+        if (this.__visitor[type]) {
+            this.__visitor[type].call(this, node);
+            return;
+        }
+        this.visitChildren(node);
+    };
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
+    exports.version = __webpack_require__(12166).version;
+    exports.Visitor = Visitor;
+    exports.visit = function (node, visitor, options) {
+        var v = new Visitor(visitor, options);
+        v.visit(node);
+    };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
+/***/ }),
 
-const WebpackError = __webpack_require__(53799);
+/***/ 50165:
+/***/ (function(__unused_webpack_module, exports) {
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+/*
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
 
-class AsyncDependencyToInitialChunkError extends WebpackError {
-	/**
-	 * Creates an instance of AsyncDependencyToInitialChunkError.
-	 * @param {string} chunkName Name of Chunk
-	 * @param {Module} module module tied to dependency
-	 * @param {DependencyLocation} loc location of dependency
-	 */
-	constructor(chunkName, module, loc) {
-		super(
-			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
-		);
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-		this.name = "AsyncDependencyToInitialChunkError";
-		this.module = module;
-		this.loc = loc;
-	}
-}
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-module.exports = AsyncDependencyToInitialChunkError;
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true*/
+(function clone(exports) {
+    'use strict';
 
+    var Syntax,
+        VisitorOption,
+        VisitorKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
 
-/***/ }),
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
 
-/***/ 17714:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    function upperBound(array, func) {
+        var diff, len, i, current;
 
+        len = array.length;
+        i = 0;
 
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
 
-const asyncLib = __webpack_require__(78175);
-const NormalModule = __webpack_require__(39);
-const PrefetchDependency = __webpack_require__(31618);
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        AssignmentPattern: 'AssignmentPattern',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ChainExpression: 'ChainExpression',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportAllDeclaration: 'ExportAllDeclaration',
+        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
+        ExportNamedDeclaration: 'ExportNamedDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportExpression: 'ImportExpression',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MetaProperty: 'MetaProperty',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        RestElement: 'RestElement',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        Super: 'Super',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
 
-/** @typedef {import("./Compiler")} Compiler */
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        AssignmentPattern: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'body'],
+        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ChainExpression: ['expression'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'superClass', 'body'],
+        ClassExpression: ['id', 'superClass', 'body'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportAllDeclaration: ['source'],
+        ExportDefaultDeclaration: ['declaration'],
+        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['exported', 'local'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'body'],
+        FunctionExpression: ['id', 'params', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportExpression: ['source'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['local'],
+        ImportNamespaceSpecifier: ['local'],
+        ImportSpecifier: ['imported', 'local'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MetaProperty: ['meta', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        RestElement: [ 'argument' ],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        Super: [],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handler', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
 
-class AutomaticPrefetchPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AutomaticPrefetchPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					PrefetchDependency,
-					normalModuleFactory
-				);
-			}
-		);
-		let lastModules = null;
-		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
-			lastModules = [];
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
 
-			for (const m of compilation.modules) {
-				if (m instanceof NormalModule) {
-					lastModules.push({
-						context: m.context,
-						request: m.request
-					});
-				}
-			}
-		});
-		compiler.hooks.make.tapAsync(
-			"AutomaticPrefetchPlugin",
-			(compilation, callback) => {
-				if (!lastModules) return callback();
-				asyncLib.forEach(
-					lastModules,
-					(m, callback) => {
-						compilation.addModuleChain(
-							m.context || compiler.context,
-							new PrefetchDependency(`!!${m.request}`),
-							callback
-						);
-					},
-					err => {
-						lastModules = null;
-						callback(err);
-					}
-				);
-			}
-		);
-	}
-}
-module.exports = AutomaticPrefetchPlugin;
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
 
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
 
-/***/ }),
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
 
-/***/ 21242:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    Reference.prototype.remove = function remove() {
+        if (Array.isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
 
+    function Controller() { }
 
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
 
-const { ConcatSource } = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const Template = __webpack_require__(1626);
-const createSchemaValidation = __webpack_require__(32540);
+        function addToPath(result, path) {
+            if (Array.isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
 
-/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
-/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
 
-const validate = createSchemaValidation(
-	__webpack_require__(42173),
-	() => __webpack_require__(49052),
-	{
-		name: "Banner Plugin",
-		baseDataPath: "options"
-	}
-);
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
 
-const wrapComment = str => {
-	if (!str.includes("\n")) {
-		return Template.toComment(str);
-	}
-	return `/*!\n * ${str
-		.replace(/\*\//g, "* /")
-		.split("\n")
-		.join("\n * ")
-		.replace(/\s+\n/g, "\n")
-		.trimRight()}\n */`;
-};
+    // API:
+    // return type of current node
+    Controller.prototype.type = function () {
+        var node = this.current();
+        return node.type || this.__current.wrap;
+    };
 
-class BannerPlugin {
-	/**
-	 * @param {BannerPluginArgument} options options object
-	 */
-	constructor(options) {
-		if (typeof options === "string" || typeof options === "function") {
-			options = {
-				banner: options
-			};
-		}
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
 
-		validate(options);
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
 
-		this.options = options;
+        return result;
+    };
 
-		const bannerOption = options.banner;
-		if (typeof bannerOption === "function") {
-			const getBanner = bannerOption;
-			this.banner = this.options.raw
-				? getBanner
-				: data => wrapComment(getBanner(data));
-		} else {
-			const banner = this.options.raw
-				? bannerOption
-				: wrapComment(bannerOption);
-			this.banner = () => banner;
-		}
-	}
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const options = this.options;
-		const banner = this.banner;
-		const matchObject = ModuleFilenameHelpers.matchObject.bind(
-			undefined,
-			options
-		);
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
 
-		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
-			compilation.hooks.processAssets.tap(
-				{
-					name: "BannerPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-				},
-				() => {
-					for (const chunk of compilation.chunks) {
-						if (options.entryOnly && !chunk.canBeInitial()) {
-							continue;
-						}
+        result = undefined;
 
-						for (const file of chunk.files) {
-							if (!matchObject(file)) {
-								continue;
-							}
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
 
-							const data = {
-								chunk,
-								filename: file
-							};
+        return result;
+    };
 
-							const comment = compilation.getPath(banner, data);
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
 
-							compilation.updateAsset(
-								file,
-								old => new ConcatSource(comment, "\n", old)
-							);
-						}
-					}
-				}
-			);
-		});
-	}
-}
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
 
-module.exports = BannerPlugin;
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
 
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
 
-/***/ }),
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = null;
+        if (visitor.fallback === 'iteration') {
+            this.__fallback = Object.keys;
+        } else if (typeof visitor.fallback === 'function') {
+            this.__fallback = visitor.fallback;
+        }
 
-/***/ 7592:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
+        }
+    };
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
 
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
+  
+    function candidateExistsInLeaveList(leavelist, candidate) {
+        for (var i = leavelist.length - 1; i >= 0; --i) {
+            if (leavelist[i].node === candidate) {
+                return true;
+            }
+        }
+        return false;
+    }
 
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
 
-const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = __webpack_require__(6967);
-const {
-	makeWebpackError,
-	makeWebpackErrorCallback
-} = __webpack_require__(11351);
+        this.__initialize(root, visitor);
 
-/** @typedef {import("./WebpackError")} WebpackError */
+        sentinel = {};
 
-/**
- * @typedef {Object} Etag
- * @property {function(): string} toString
- */
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
 
-/**
- * @callback GotHandler
- * @param {any} result
- * @param {function(Error=): void} callback
- * @returns {void}
- */
+        while (worklist.length) {
+            element = worklist.pop();
 
-const needCalls = (times, callback) => {
-	return err => {
-		if (--times === 0) {
-			return callback(err);
-		}
-		if (err && times > 0) {
-			times = 0;
-			return callback(err);
-		}
-	};
-};
+            if (element === sentinel) {
+                element = leavelist.pop();
 
-class Cache {
-	constructor() {
-		this.hooks = {
-			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
-			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
-			/** @type {AsyncParallelHook<[string, Etag | null, any]>} */
-			store: new AsyncParallelHook(["identifier", "etag", "data"]),
-			/** @type {AsyncParallelHook<[Iterable<string>]>} */
-			storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
-			/** @type {SyncHook<[]>} */
-			beginIdle: new SyncHook([]),
-			/** @type {AsyncParallelHook<[]>} */
-			endIdle: new AsyncParallelHook([]),
-			/** @type {AsyncParallelHook<[]>} */
-			shutdown: new AsyncParallelHook([])
-		};
-	}
+                ret = this.__execute(visitor.leave, element);
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(identifier, etag, callback) {
-		const gotHandlers = [];
-		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
-			if (err) {
-				callback(makeWebpackError(err, "Cache.hooks.get"));
-				return;
-			}
-			if (result === null) {
-				result = undefined;
-			}
-			if (gotHandlers.length > 1) {
-				const innerCallback = needCalls(gotHandlers.length, () =>
-					callback(null, result)
-				);
-				for (const gotHandler of gotHandlers) {
-					gotHandler(result, innerCallback);
-				}
-			} else if (gotHandlers.length === 1) {
-				gotHandlers[0](result, () => callback(null, result));
-			} else {
-				callback(null, result);
-			}
-		});
-	}
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(identifier, etag, data, callback) {
-		this.hooks.store.callAsync(
-			identifier,
-			etag,
-			data,
-			makeWebpackErrorCallback(callback, "Cache.hooks.store")
-		);
-	}
+            if (element.node) {
 
-	/**
-	 * After this method has succeeded the cache can only be restored when build dependencies are
-	 * @param {Iterable<string>} dependencies list of all build dependencies
-	 * @param {CallbackCache<void>} callback signals when the dependencies are stored
-	 * @returns {void}
-	 */
-	storeBuildDependencies(dependencies, callback) {
-		this.hooks.storeBuildDependencies.callAsync(
-			dependencies,
-			makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies")
-		);
-	}
+                ret = this.__execute(visitor.enter, element);
 
-	/**
-	 * @returns {void}
-	 */
-	beginIdle() {
-		this.hooks.beginIdle.call();
-	}
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
 
-	/**
-	 * @param {CallbackCache<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	endIdle(callback) {
-		this.hooks.endIdle.callAsync(
-			makeWebpackErrorCallback(callback, "Cache.hooks.endIdle")
-		);
-	}
+                worklist.push(sentinel);
+                leavelist.push(element);
 
-	/**
-	 * @param {CallbackCache<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	shutdown(callback) {
-		this.hooks.shutdown.callAsync(
-			makeWebpackErrorCallback(callback, "Cache.hooks.shutdown")
-		);
-	}
-}
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
 
-Cache.STAGE_MEMORY = -10;
-Cache.STAGE_DEFAULT = 0;
-Cache.STAGE_DISK = 10;
-Cache.STAGE_NETWORK = 20;
+                node = element.node;
+                nodeType = node.type || element.wrap;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = this.__fallback(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
 
-module.exports = Cache;
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
 
+                    if (Array.isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
 
-/***/ }),
+                            if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
+                              continue;
+                            }
 
-/***/ 55392:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        if (candidateExistsInLeaveList(leavelist, candidate)) {
+                          continue;
+                        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
 
+    Controller.prototype.replace = function replace(root, visitor) {
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
 
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
 
-const { forEachBail } = __webpack_require__(9256);
-const asyncLib = __webpack_require__(78175);
-const getLazyHashedEtag = __webpack_require__(94075);
-const mergeEtags = __webpack_require__(54980);
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
 
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
-/** @typedef {typeof import("./util/Hash")} HashConstructor */
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
 
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
+        this.__initialize(root, visitor);
 
-/**
- * @template T
- * @callback CallbackNormalErrorCache
- * @param {(Error | null)=} err
- * @param {T=} result
- * @returns {void}
- */
+        sentinel = {};
 
-class MultiItemCache {
-	/**
-	 * @param {ItemCacheFacade[]} items item caches
-	 */
-	constructor(items) {
-		this._items = items;
-		if (items.length === 1) return /** @type {any} */ (items[0]);
-	}
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
-	/**
-	 * @template T
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(callback) {
-		forEachBail(this._items, (item, callback) => item.get(callback), callback);
-	}
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
 
-	/**
-	 * @template T
-	 * @returns {Promise<T>} promise with the data
-	 */
-	getPromise() {
-		const next = i => {
-			return this._items[i].getPromise().then(result => {
-				if (result !== undefined) return result;
-				if (++i < this._items.length) return next(i);
-			});
-		};
-		return next(0);
-	}
+        while (worklist.length) {
+            element = worklist.pop();
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(data, callback) {
-		asyncLib.each(
-			this._items,
-			(item, callback) => item.store(data, callback),
-			callback
-		);
-	}
-
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @returns {Promise<void>} promise signals when the value is stored
-	 */
-	storePromise(data) {
-		return Promise.all(this._items.map(item => item.storePromise(data))).then(
-			() => {}
-		);
-	}
-}
-
-class ItemCacheFacade {
-	/**
-	 * @param {Cache} cache the root cache
-	 * @param {string} name the child cache item name
-	 * @param {Etag | null} etag the etag
-	 */
-	constructor(cache, name, etag) {
-		this._cache = cache;
-		this._name = name;
-		this._etag = etag;
-	}
+            if (element === sentinel) {
+                element = leavelist.pop();
 
-	/**
-	 * @template T
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(callback) {
-		this._cache.get(this._name, this._etag, callback);
-	}
+                target = this.__execute(visitor.leave, element);
 
-	/**
-	 * @template T
-	 * @returns {Promise<T>} promise with the data
-	 */
-	getPromise() {
-		return new Promise((resolve, reject) => {
-			this._cache.get(this._name, this._etag, (err, data) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(data);
-				}
-			});
-		});
-	}
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(data, callback) {
-		this._cache.store(this._name, this._etag, data, callback);
-	}
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @returns {Promise<void>} promise signals when the value is stored
-	 */
-	storePromise(data) {
-		return new Promise((resolve, reject) => {
-			this._cache.store(this._name, this._etag, data, err => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
 
-	/**
-	 * @template T
-	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	provide(computer, callback) {
-		this.get((err, cacheEntry) => {
-			if (err) return callback(err);
-			if (cacheEntry !== undefined) return cacheEntry;
-			computer((err, result) => {
-				if (err) return callback(err);
-				this.store(result, err => {
-					if (err) return callback(err);
-					callback(null, result);
-				});
-			});
-		});
-	}
+            target = this.__execute(visitor.enter, element);
 
-	/**
-	 * @template T
-	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-	 * @returns {Promise<T>} promise with the data
-	 */
-	async providePromise(computer) {
-		const cacheEntry = await this.getPromise();
-		if (cacheEntry !== undefined) return cacheEntry;
-		const result = await computer();
-		await this.storePromise(result);
-		return result;
-	}
-}
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
 
-class CacheFacade {
-	/**
-	 * @param {Cache} cache the root cache
-	 * @param {string} name the child cache name
-	 * @param {string | HashConstructor} hashFunction the hash function to use
-	 */
-	constructor(cache, name, hashFunction) {
-		this._cache = cache;
-		this._name = name;
-		this._hashFunction = hashFunction;
-	}
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
 
-	/**
-	 * @param {string} name the child cache name#
-	 * @returns {CacheFacade} child cache
-	 */
-	getChildCache(name) {
-		return new CacheFacade(
-			this._cache,
-			`${this._name}|${name}`,
-			this._hashFunction
-		);
-	}
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
 
-	/**
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @returns {ItemCacheFacade} item cache
-	 */
-	getItemCache(identifier, etag) {
-		return new ItemCacheFacade(
-			this._cache,
-			`${this._name}|${identifier}`,
-			etag
-		);
-	}
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
 
-	/**
-	 * @param {HashableObject} obj an hashable object
-	 * @returns {Etag} an etag that is lazy hashed
-	 */
-	getLazyHashedEtag(obj) {
-		return getLazyHashedEtag(obj, this._hashFunction);
-	}
+            worklist.push(sentinel);
+            leavelist.push(element);
 
-	/**
-	 * @param {Etag} a an etag
-	 * @param {Etag} b another etag
-	 * @returns {Etag} an etag that represents both
-	 */
-	mergeEtags(a, b) {
-		return mergeEtags(a, b);
-	}
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(identifier, etag, callback) {
-		this._cache.get(`${this._name}|${identifier}`, etag, callback);
-	}
+            nodeType = node.type || element.wrap;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = this.__fallback(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @returns {Promise<T>} promise with the data
-	 */
-	getPromise(identifier, etag) {
-		return new Promise((resolve, reject) => {
-			this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(data);
-				}
-			});
-		});
-	}
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(identifier, etag, data, callback) {
-		this._cache.store(`${this._name}|${identifier}`, etag, data, callback);
-	}
+                if (Array.isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {T} data the value to store
-	 * @returns {Promise<void>} promise signals when the value is stored
-	 */
-	storePromise(identifier, etag, data) {
-		return new Promise((resolve, reject) => {
-			this._cache.store(`${this._name}|${identifier}`, etag, data, err => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
+        return outer.root;
+    };
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	provide(identifier, etag, computer, callback) {
-		this.get(identifier, etag, (err, cacheEntry) => {
-			if (err) return callback(err);
-			if (cacheEntry !== undefined) return cacheEntry;
-			computer((err, result) => {
-				if (err) return callback(err);
-				this.store(identifier, etag, result, err => {
-					if (err) return callback(err);
-					callback(null, result);
-				});
-			});
-		});
-	}
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-	 * @returns {Promise<T>} promise with the data
-	 */
-	async providePromise(identifier, etag, computer) {
-		const cacheEntry = await this.getPromise(identifier, etag);
-		if (cacheEntry !== undefined) return cacheEntry;
-		const result = await computer();
-		await this.storePromise(identifier, etag, result);
-		return result;
-	}
-}
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
 
-module.exports = CacheFacade;
-module.exports.ItemCacheFacade = ItemCacheFacade;
-module.exports.MultiItemCache = MultiItemCache;
+    function extendCommentRange(comment, tokens) {
+        var target;
 
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
 
-/***/ }),
+        comment.extendedRange = [comment.range[0], comment.range[1]];
 
-/***/ 77975:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
 
+        return comment;
+    }
 
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
 
-const WebpackError = __webpack_require__(53799);
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
 
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
 
-/**
- * @param {Module[]} modules the modules to be sorted
- * @returns {Module[]} sorted version of original modules
- */
-const sortModules = modules => {
-	return modules.sort((a, b) => {
-		const aIdent = a.identifier();
-		const bIdent = b.identifier();
-		/* istanbul ignore next */
-		if (aIdent < bIdent) return -1;
-		/* istanbul ignore next */
-		if (aIdent > bIdent) return 1;
-		/* istanbul ignore next */
-		return 0;
-	});
-};
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
 
-/**
- * @param {Module[]} modules each module from throw
- * @param {ModuleGraph} moduleGraph the module graph
- * @returns {string} each message from provided modules
- */
-const createModulesListMessage = (modules, moduleGraph) => {
-	return modules
-		.map(m => {
-			let message = `* ${m.identifier()}`;
-			const validReasons = Array.from(
-				moduleGraph.getIncomingConnectionsByOriginModule(m).keys()
-			).filter(x => x);
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
 
-			if (validReasons.length > 0) {
-				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
-				message += `\n    ${validReasons[0].identifier()}`;
-			}
-			return message;
-		})
-		.join("\n");
-};
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
 
-class CaseSensitiveModulesWarning extends WebpackError {
-	/**
-	 * Creates an instance of CaseSensitiveModulesWarning.
-	 * @param {Iterable<Module>} modules modules that were detected
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 */
-	constructor(modules, moduleGraph) {
-		const sortedModules = sortModules(Array.from(modules));
-		const modulesList = createModulesListMessage(sortedModules, moduleGraph);
-		super(`There are multiple modules with names that only differ in casing.
-This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.
-Use equal casing. Compare these module identifiers:
-${modulesList}`);
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-		this.name = "CaseSensitiveModulesWarning";
-		this.module = sortedModules[0];
-	}
-}
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-module.exports = CaseSensitiveModulesWarning;
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
 
-/***/ }),
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
 
-/***/ 39385:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
+        return tree;
+    }
 
-const ChunkGraph = __webpack_require__(64971);
-const Entrypoint = __webpack_require__(13795);
-const { intersect } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-const StringXor = __webpack_require__(40293);
-const {
-	compareModulesByIdentifier,
-	compareChunkGroupsByIndex,
-	compareModulesById
-} = __webpack_require__(29579);
-const { createArrayToSetDeprecationSet } = __webpack_require__(64518);
-const { mergeRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
-/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
-/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+    exports.cloneEnvironment = function () { return clone({}); };
 
-const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
+    return exports;
+}(exports));
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-/**
- * @typedef {Object} WithId an object who has an id property *
- * @property {string | number} id the id of the object
- */
 
-/**
- * @deprecated
- * @typedef {Object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
- */
+/***/ }),
 
-/**
- * @deprecated
- * @typedef {Object} ChunkModuleMaps
- * @property {Record<string|number, (string|number)[]>} id
- * @property {Record<string|number, string>} hash
- */
+/***/ 18350:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-let debugId = 1000;
+/*
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
 
-/**
- * A Chunk is a unit of encapsulation for Modules.
- * Chunks are "rendered" into bundles that get emitted when the build completes.
- */
-class Chunk {
-	/**
-	 * @param {string=} name of chunk being created, is optional (for subclasses)
-	 * @param {boolean} backCompat enable backward-compatibility
-	 */
-	constructor(name, backCompat = true) {
-		/** @type {number | string | null} */
-		this.id = null;
-		/** @type {(number|string)[] | null} */
-		this.ids = null;
-		/** @type {number} */
-		this.debugId = debugId++;
-		/** @type {string} */
-		this.name = name;
-		/** @type {SortableSet<string>} */
-		this.idNameHints = new SortableSet();
-		/** @type {boolean} */
-		this.preventIntegration = false;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
-		this.filenameTemplate = undefined;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
-		this.cssFilenameTemplate = undefined;
-		/** @private @type {SortableSet<ChunkGroup>} */
-		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
-		/** @type {RuntimeSpec} */
-		this.runtime = undefined;
-		/** @type {Set<string>} */
-		this.files = backCompat ? new ChunkFilesSet() : new Set();
-		/** @type {Set<string>} */
-		this.auxiliaryFiles = new Set();
-		/** @type {boolean} */
-		this.rendered = false;
-		/** @type {string=} */
-		this.hash = undefined;
-		/** @type {Record<string, string>} */
-		this.contentHash = Object.create(null);
-		/** @type {string=} */
-		this.renderedHash = undefined;
-		/** @type {string=} */
-		this.chunkReason = undefined;
-		/** @type {boolean} */
-		this.extraAsync = false;
-	}
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-	// TODO remove in webpack 6
-	// BACKWARD-COMPAT START
-	get entryModule() {
-		const entryModules = Array.from(
-			ChunkGraph.getChunkGraphForChunk(
-				this,
-				"Chunk.entryModule",
-				"DEP_WEBPACK_CHUNK_ENTRY_MODULE"
-			).getChunkEntryModulesIterable(this)
-		);
-		if (entryModules.length === 0) {
-			return undefined;
-		} else if (entryModules.length === 1) {
-			return entryModules[0];
-		} else {
-			throw new Error(
-				"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
-			);
-		}
-	}
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-	/**
-	 * @returns {boolean} true, if the chunk contains an entry module
-	 */
-	hasEntryModule() {
-		return (
-			ChunkGraph.getChunkGraphForChunk(
-				this,
-				"Chunk.hasEntryModule",
-				"DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE"
-			).getNumberOfEntryModules(this) > 0
-		);
-	}
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true*/
+(function clone(exports) {
+    'use strict';
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the chunk could be added
-	 */
-	addModule(module) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.addModule",
-			"DEP_WEBPACK_CHUNK_ADD_MODULE"
-		);
-		if (chunkGraph.isModuleInChunk(module, this)) return false;
-		chunkGraph.connectChunkAndModule(this, module);
-		return true;
-	}
+    var Syntax,
+        VisitorOption,
+        VisitorKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	removeModule(module) {
-		ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.removeModule",
-			"DEP_WEBPACK_CHUNK_REMOVE_MODULE"
-		).disconnectChunkAndModule(this, module);
-	}
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
 
-	/**
-	 * @returns {number} the number of module which are contained in this chunk
-	 */
-	getNumberOfModules() {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getNumberOfModules",
-			"DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES"
-		).getNumberOfChunkModules(this);
-	}
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
 
-	get modulesIterable() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.modulesIterable",
-			"DEP_WEBPACK_CHUNK_MODULES_ITERABLE"
-		);
-		return chunkGraph.getOrderedChunkModulesIterable(
-			this,
-			compareModulesByIdentifier
-		);
-	}
+    function upperBound(array, func) {
+        var diff, len, i, current;
 
-	/**
-	 * @param {Chunk} otherChunk the chunk to compare with
-	 * @returns {-1|0|1} the comparison result
-	 */
-	compareTo(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.compareTo",
-			"DEP_WEBPACK_CHUNK_COMPARE_TO"
-		);
-		return chunkGraph.compareChunks(this, otherChunk);
-	}
+        len = array.length;
+        i = 0;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the chunk contains the module
-	 */
-	containsModule(module) {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.containsModule",
-			"DEP_WEBPACK_CHUNK_CONTAINS_MODULE"
-		).isModuleInChunk(module, this);
-	}
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
 
-	/**
-	 * @returns {Module[]} the modules for this chunk
-	 */
-	getModules() {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getModules",
-			"DEP_WEBPACK_CHUNK_GET_MODULES"
-		).getChunkModules(this);
-	}
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        AssignmentPattern: 'AssignmentPattern',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportAllDeclaration: 'ExportAllDeclaration',
+        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
+        ExportNamedDeclaration: 'ExportNamedDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportExpression: 'ImportExpression',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MetaProperty: 'MetaProperty',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        RestElement: 'RestElement',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        Super: 'Super',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
 
-	/**
-	 * @returns {void}
-	 */
-	remove() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.remove",
-			"DEP_WEBPACK_CHUNK_REMOVE"
-		);
-		chunkGraph.disconnectChunk(this);
-		this.disconnectFromGroups();
-	}
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        AssignmentPattern: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'body'],
+        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'superClass', 'body'],
+        ClassExpression: ['id', 'superClass', 'body'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportAllDeclaration: ['source'],
+        ExportDefaultDeclaration: ['declaration'],
+        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['exported', 'local'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'body'],
+        FunctionExpression: ['id', 'params', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportExpression: ['source'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['local'],
+        ImportNamespaceSpecifier: ['local'],
+        ImportSpecifier: ['imported', 'local'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MetaProperty: ['meta', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        RestElement: [ 'argument' ],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        Super: [],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handler', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
 
-	/**
-	 * @param {Module} module the module
-	 * @param {Chunk} otherChunk the target chunk
-	 * @returns {void}
-	 */
-	moveModule(module, otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.moveModule",
-			"DEP_WEBPACK_CHUNK_MOVE_MODULE"
-		);
-		chunkGraph.disconnectChunkAndModule(this, module);
-		chunkGraph.connectChunkAndModule(otherChunk, module);
-	}
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
 
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @returns {boolean} true, if the specified chunk has been integrated
-	 */
-	integrate(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.integrate",
-			"DEP_WEBPACK_CHUNK_INTEGRATE"
-		);
-		if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
-			chunkGraph.integrateChunks(this, otherChunk);
-			return true;
-		} else {
-			return false;
-		}
-	}
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
 
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @returns {boolean} true, if chunks could be integrated
-	 */
-	canBeIntegrated(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.canBeIntegrated",
-			"DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED"
-		);
-		return chunkGraph.canChunksBeIntegrated(this, otherChunk);
-	}
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
 
-	/**
-	 * @returns {boolean} true, if this chunk contains no module
-	 */
-	isEmpty() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.isEmpty",
-			"DEP_WEBPACK_CHUNK_IS_EMPTY"
-		);
-		return chunkGraph.getNumberOfChunkModules(this) === 0;
-	}
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
 
-	/**
-	 * @returns {number} total size of all modules in this chunk
-	 */
-	modulesSize() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.modulesSize",
-			"DEP_WEBPACK_CHUNK_MODULES_SIZE"
-		);
-		return chunkGraph.getChunkModulesSize(this);
-	}
+    Reference.prototype.remove = function remove() {
+        if (Array.isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
 
-	/**
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of this chunk
-	 */
-	size(options = {}) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.size",
-			"DEP_WEBPACK_CHUNK_SIZE"
-		);
-		return chunkGraph.getChunkSize(this, options);
-	}
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
 
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk or false if the chunk can't be integrated
-	 */
-	integratedSize(otherChunk, options) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.integratedSize",
-			"DEP_WEBPACK_CHUNK_INTEGRATED_SIZE"
-		);
-		return chunkGraph.getIntegratedChunksSize(this, otherChunk, options);
-	}
+    function Controller() { }
 
-	/**
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @returns {ChunkModuleMaps} module map information
-	 */
-	getChunkModuleMaps(filterFn) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getChunkModuleMaps",
-			"DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS"
-		);
-		/** @type {Record<string|number, (string|number)[]>} */
-		const chunkModuleIdMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
-		const chunkModuleHashMap = Object.create(null);
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
 
-		for (const asyncChunk of this.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
-			let array;
-			for (const module of chunkGraph.getOrderedChunkModulesIterable(
-				asyncChunk,
-				compareModulesById(chunkGraph)
-			)) {
-				if (filterFn(module)) {
-					if (array === undefined) {
-						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
-					}
-					const moduleId = chunkGraph.getModuleId(module);
-					array.push(moduleId);
-					chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash(
-						module,
-						undefined
-					);
-				}
-			}
-		}
+        function addToPath(result, path) {
+            if (Array.isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
 
-		return {
-			id: chunkModuleIdMap,
-			hash: chunkModuleHashMap
-		};
-	}
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
 
-	/**
-	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
-	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
-	 * @returns {boolean} return true if module exists in graph
-	 */
-	hasModuleInGraph(filterFn, filterChunkFn) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.hasModuleInGraph",
-			"DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH"
-		);
-		return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn);
-	}
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
 
-	/**
-	 * @deprecated
-	 * @param {boolean} realHash whether the full hash or the rendered hash is to be used
-	 * @returns {ChunkMaps} the chunk map information
-	 */
-	getChunkMaps(realHash) {
-		/** @type {Record<string|number, string>} */
-		const chunkHashMap = Object.create(null);
-		/** @type {Record<string|number, Record<string, string>>} */
-		const chunkContentHashMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
-		const chunkNameMap = Object.create(null);
+    // API:
+    // return type of current node
+    Controller.prototype.type = function () {
+        var node = this.current();
+        return node.type || this.__current.wrap;
+    };
 
-		for (const chunk of this.getAllAsyncChunks()) {
-			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
-			for (const key of Object.keys(chunk.contentHash)) {
-				if (!chunkContentHashMap[key]) {
-					chunkContentHashMap[key] = Object.create(null);
-				}
-				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
-			}
-			if (chunk.name) {
-				chunkNameMap[chunk.id] = chunk.name;
-			}
-		}
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
 
-		return {
-			hash: chunkHashMap,
-			contentHash: chunkContentHashMap,
-			name: chunkNameMap
-		};
-	}
-	// BACKWARD-COMPAT END
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
 
-	/**
-	 * @returns {boolean} whether or not the Chunk will have a runtime
-	 */
-	hasRuntime() {
-		for (const chunkGroup of this._groups) {
-			if (
-				chunkGroup instanceof Entrypoint &&
-				chunkGroup.getRuntimeChunk() === this
-			) {
-				return true;
-			}
-		}
-		return false;
-	}
+        return result;
+    };
 
-	/**
-	 * @returns {boolean} whether or not this chunk can be an initial chunk
-	 */
-	canBeInitial() {
-		for (const chunkGroup of this._groups) {
-			if (chunkGroup.isInitial()) return true;
-		}
-		return false;
-	}
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
 
-	/**
-	 * @returns {boolean} whether this chunk can only be an initial chunk
-	 */
-	isOnlyInitial() {
-		if (this._groups.size <= 0) return false;
-		for (const chunkGroup of this._groups) {
-			if (!chunkGroup.isInitial()) return false;
-		}
-		return true;
-	}
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
 
-	/**
-	 * @returns {EntryOptions | undefined} the entry options for this chunk
-	 */
-	getEntryOptions() {
-		for (const chunkGroup of this._groups) {
-			if (chunkGroup instanceof Entrypoint) {
-				return chunkGroup.options;
-			}
-		}
-		return undefined;
-	}
+        result = undefined;
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
-	 * @returns {void}
-	 */
-	addGroup(chunkGroup) {
-		this._groups.add(chunkGroup);
-	}
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
-	 * @returns {void}
-	 */
-	removeGroup(chunkGroup) {
-		this._groups.delete(chunkGroup);
-	}
+        return result;
+    };
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup to check
-	 * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup
-	 */
-	isInGroup(chunkGroup) {
-		return this._groups.has(chunkGroup);
-	}
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
 
-	/**
-	 * @returns {number} the amount of groups that the said chunk is in
-	 */
-	getNumberOfGroups() {
-		return this._groups.size;
-	}
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
 
-	/**
-	 * @returns {Iterable<ChunkGroup>} the chunkGroups that the said chunk is referenced in
-	 */
-	get groupsIterable() {
-		this._groups.sort();
-		return this._groups;
-	}
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
 
-	/**
-	 * @returns {void}
-	 */
-	disconnectFromGroups() {
-		for (const chunkGroup of this._groups) {
-			chunkGroup.removeChunk(this);
-		}
-	}
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
 
-	/**
-	 * @param {Chunk} newChunk the new chunk that will be split out of
-	 * @returns {void}
-	 */
-	split(newChunk) {
-		for (const chunkGroup of this._groups) {
-			chunkGroup.insertChunk(newChunk, this);
-			newChunk.addGroup(chunkGroup);
-		}
-		for (const idHint of this.idNameHints) {
-			newChunk.idNameHints.add(idHint);
-		}
-		newChunk.runtime = mergeRuntime(newChunk.runtime, this.runtime);
-	}
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = null;
+        if (visitor.fallback === 'iteration') {
+            this.__fallback = Object.keys;
+        } else if (typeof visitor.fallback === 'function') {
+            this.__fallback = visitor.fallback;
+        }
 
-	/**
-	 * @param {Hash} hash hash (will be modified)
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	updateHash(hash, chunkGraph) {
-		hash.update(
-			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
-		);
-		const xor = new StringXor();
-		for (const m of chunkGraph.getChunkModulesIterable(this)) {
-			xor.add(chunkGraph.getModuleHash(m, this.runtime));
-		}
-		xor.updateHash(hash);
-		const entryModules =
-			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
-		for (const [m, chunkGroup] of entryModules) {
-			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
-		}
-	}
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
+        }
+    };
 
-	/**
-	 * @returns {Set<Chunk>} a set of all the async chunks
-	 */
-	getAllAsyncChunks() {
-		const queue = new Set();
-		const chunks = new Set();
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
 
-		const initialChunks = intersect(
-			Array.from(this.groupsIterable, g => new Set(g.chunks))
-		);
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
 
-		const initialQueue = new Set(this.groupsIterable);
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
 
-		for (const chunkGroup of initialQueue) {
-			for (const child of chunkGroup.childrenIterable) {
-				if (child instanceof Entrypoint) {
-					initialQueue.add(child);
-				} else {
-					queue.add(child);
-				}
-			}
-		}
+        this.__initialize(root, visitor);
 
-		for (const chunkGroup of queue) {
-			for (const chunk of chunkGroup.chunks) {
-				if (!initialChunks.has(chunk)) {
-					chunks.add(chunk);
-				}
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+        sentinel = {};
 
-		return chunks;
-	}
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
-	/**
-	 * @returns {Set<Chunk>} a set of all the initial chunks (including itself)
-	 */
-	getAllInitialChunks() {
-		const chunks = new Set();
-		const queue = new Set(this.groupsIterable);
-		for (const group of queue) {
-			if (group.isInitial()) {
-				for (const c of group.chunks) chunks.add(c);
-				for (const g of group.childrenIterable) queue.add(g);
-			}
-		}
-		return chunks;
-	}
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
 
-	/**
-	 * @returns {Set<Chunk>} a set of all the referenced chunks (including itself)
-	 */
-	getAllReferencedChunks() {
-		const queue = new Set(this.groupsIterable);
-		const chunks = new Set();
+        while (worklist.length) {
+            element = worklist.pop();
 
-		for (const chunkGroup of queue) {
-			for (const chunk of chunkGroup.chunks) {
-				chunks.add(chunk);
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+            if (element === sentinel) {
+                element = leavelist.pop();
 
-		return chunks;
-	}
+                ret = this.__execute(visitor.leave, element);
 
-	/**
-	 * @returns {Set<Entrypoint>} a set of all the referenced entrypoints
-	 */
-	getAllReferencedAsyncEntrypoints() {
-		const queue = new Set(this.groupsIterable);
-		const entrypoints = new Set();
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
 
-		for (const chunkGroup of queue) {
-			for (const entrypoint of chunkGroup.asyncEntrypointsIterable) {
-				entrypoints.add(entrypoint);
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+            if (element.node) {
 
-		return entrypoints;
-	}
+                ret = this.__execute(visitor.enter, element);
 
-	/**
-	 * @returns {boolean} true, if the chunk references async chunks
-	 */
-	hasAsyncChunks() {
-		const queue = new Set();
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
 
-		const initialChunks = intersect(
-			Array.from(this.groupsIterable, g => new Set(g.chunks))
-		);
+                worklist.push(sentinel);
+                leavelist.push(element);
 
-		for (const chunkGroup of this.groupsIterable) {
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
 
-		for (const chunkGroup of queue) {
-			for (const chunk of chunkGroup.chunks) {
-				if (!initialChunks.has(chunk)) {
-					return true;
-				}
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+                node = element.node;
+                nodeType = node.type || element.wrap;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = this.__fallback(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
 
-		return false;
-	}
-
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
-	 */
-	getChildIdsByOrders(chunkGraph, filterFn) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
-		const lists = new Map();
-		for (const group of this.groupsIterable) {
-			if (group.chunks[group.chunks.length - 1] === this) {
-				for (const childGroup of group.childrenIterable) {
-					for (const key of Object.keys(childGroup.options)) {
-						if (key.endsWith("Order")) {
-							const name = key.substr(0, key.length - "Order".length);
-							let list = lists.get(name);
-							if (list === undefined) {
-								list = [];
-								lists.set(name, list);
-							}
-							list.push({
-								order: childGroup.options[key],
-								group: childGroup
-							});
-						}
-					}
-				}
-			}
-		}
-		/** @type {Record<string, (string | number)[]>} */
-		const result = Object.create(null);
-		for (const [name, list] of lists) {
-			list.sort((a, b) => {
-				const cmp = b.order - a.order;
-				if (cmp !== 0) return cmp;
-				return a.group.compareTo(chunkGraph, b.group);
-			});
-			/** @type {Set<string | number>} */
-			const chunkIdSet = new Set();
-			for (const item of list) {
-				for (const chunk of item.group.chunks) {
-					if (filterFn && !filterFn(chunk, chunkGraph)) continue;
-					chunkIdSet.add(chunk.id);
-				}
-			}
-			if (chunkIdSet.size > 0) {
-				result[name] = Array.from(chunkIdSet);
-			}
-		}
-		return result;
-	}
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {string} type option name
-	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
-	 */
-	getChildrenOfTypeInOrder(chunkGraph, type) {
-		const list = [];
-		for (const group of this.groupsIterable) {
-			for (const childGroup of group.childrenIterable) {
-				const order = childGroup.options[type];
-				if (order === undefined) continue;
-				list.push({
-					order,
-					group,
-					childGroup
-				});
-			}
-		}
-		if (list.length === 0) return undefined;
-		list.sort((a, b) => {
-			const cmp = b.order - a.order;
-			if (cmp !== 0) return cmp;
-			return a.group.compareTo(chunkGraph, b.group);
-		});
-		const result = [];
-		let lastEntry;
-		for (const { group, childGroup } of list) {
-			if (lastEntry && lastEntry.onChunks === group.chunks) {
-				for (const chunk of childGroup.chunks) {
-					lastEntry.chunks.add(chunk);
-				}
-			} else {
-				result.push(
-					(lastEntry = {
-						onChunks: group.chunks,
-						chunks: new Set(childGroup.chunks)
-					})
-				);
-			}
-		}
-		return result;
-	}
+                    if (Array.isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
-	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string|number, Record<string, (string | number)[]>>} a record object of names to lists of child ids(?) by chunk id
-	 */
-	getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
-		/** @type {Record<string|number, Record<string, (string | number)[]>>} */
-		const chunkMaps = Object.create(null);
+    Controller.prototype.replace = function replace(root, visitor) {
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
 
-		/**
-		 * @param {Chunk} chunk a chunk
-		 * @returns {void}
-		 */
-		const addChildIdsByOrdersToMap = chunk => {
-			const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
-			for (const key of Object.keys(data)) {
-				let chunkMap = chunkMaps[key];
-				if (chunkMap === undefined) {
-					chunkMaps[key] = chunkMap = Object.create(null);
-				}
-				chunkMap[chunk.id] = data[key];
-			}
-		};
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
 
-		if (includeDirectChildren) {
-			/** @type {Set<Chunk>} */
-			const chunks = new Set();
-			for (const chunkGroup of this.groupsIterable) {
-				for (const chunk of chunkGroup.chunks) {
-					chunks.add(chunk);
-				}
-			}
-			for (const chunk of chunks) {
-				addChildIdsByOrdersToMap(chunk);
-			}
-		}
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
 
-		for (const chunk of this.getAllAsyncChunks()) {
-			addChildIdsByOrdersToMap(chunk);
-		}
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
 
-		return chunkMaps;
-	}
-}
+        this.__initialize(root, visitor);
 
-module.exports = Chunk;
+        sentinel = {};
 
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
-/***/ }),
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
 
-/***/ 64971:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+        while (worklist.length) {
+            element = worklist.pop();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+            if (element === sentinel) {
+                element = leavelist.pop();
 
+                target = this.__execute(visitor.leave, element);
 
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
 
-const util = __webpack_require__(73837);
-const Entrypoint = __webpack_require__(13795);
-const ModuleGraphConnection = __webpack_require__(40639);
-const { first } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-const {
-	compareModulesById,
-	compareIterables,
-	compareModulesByIdentifier,
-	concatComparators,
-	compareSelect,
-	compareIds
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const findGraphRoots = __webpack_require__(6261);
-const {
-	RuntimeSpecMap,
-	RuntimeSpecSet,
-	runtimeToString,
-	mergeRuntime,
-	forEachRuntime
-} = __webpack_require__(17156);
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {typeof import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
 
-/** @type {ReadonlySet<string>} */
-const EMPTY_SET = new Set();
+            target = this.__execute(visitor.enter, element);
 
-const ZERO_BIG_INT = BigInt(0);
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
 
-const compareModuleIterables = compareIterables(compareModulesByIdentifier);
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
 
-/** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
-/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
 
-/**
- * @typedef {Object} ChunkSizeOptions
- * @property {number=} chunkOverhead constant overhead for a chunk
- * @property {number=} entryChunkMultiplicator multiplicator for initial chunks
- */
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
 
-class ModuleHashInfo {
-	constructor(hash, renderedHash) {
-		this.hash = hash;
-		this.renderedHash = renderedHash;
-	}
-}
+            worklist.push(sentinel);
+            leavelist.push(element);
 
-/** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
 
-/**
- * @template T
- * @param {SortableSet<T>} set the set
- * @returns {T[]} set as array
- */
-const getArray = set => {
-	return Array.from(set);
-};
+            nodeType = node.type || element.wrap;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = this.__fallback(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
 
-/**
- * @param {SortableSet<Chunk>} chunks the chunks
- * @returns {RuntimeSpecSet} runtimes
- */
-const getModuleRuntimes = chunks => {
-	const runtimes = new RuntimeSpecSet();
-	for (const chunk of chunks) {
-		runtimes.add(chunk.runtime);
-	}
-	return runtimes;
-};
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
 
-/**
- * @param {SortableSet<Module>} set the set
- * @returns {Map<string, SortableSet<Module>>} modules by source type
- */
-const modulesBySourceType = set => {
-	/** @type {Map<string, SortableSet<Module>>} */
-	const map = new Map();
-	for (const module of set) {
-		for (const sourceType of module.getSourceTypes()) {
-			let innerSet = map.get(sourceType);
-			if (innerSet === undefined) {
-				innerSet = new SortableSet();
-				map.set(sourceType, innerSet);
-			}
-			innerSet.add(module);
-		}
-	}
-	for (const [key, innerSet] of map) {
-		// When all modules have the source type, we reuse the original SortableSet
-		// to benefit from the shared cache (especially for sorting)
-		if (innerSet.size === set.size) {
-			map.set(key, set);
-		}
-	}
-	return map;
-};
+                if (Array.isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
 
-/** @type {WeakMap<Function, any>} */
-const createOrderedArrayFunctionMap = new WeakMap();
+        return outer.root;
+    };
 
-/**
- * @template T
- * @param {function(T, T): -1|0|1} comparator comparator function
- * @returns {SetToArrayFunction<T>} set as ordered array
- */
-const createOrderedArrayFunction = comparator => {
-	/** @type {SetToArrayFunction<T>} */
-	let fn = createOrderedArrayFunctionMap.get(comparator);
-	if (fn !== undefined) return fn;
-	fn = set => {
-		set.sortWith(comparator);
-		return Array.from(set);
-	};
-	createOrderedArrayFunctionMap.set(comparator, fn);
-	return fn;
-};
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
 
-/**
- * @param {Iterable<Module>} modules the modules to get the count/size of
- * @returns {number} the size of the modules
- */
-const getModulesSize = modules => {
-	let size = 0;
-	for (const module of modules) {
-		for (const type of module.getSourceTypes()) {
-			size += module.size(type);
-		}
-	}
-	return size;
-};
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
 
-/**
- * @param {Iterable<Module>} modules the sortable Set to get the size of
- * @returns {Record<string, number>} the sizes of the modules
- */
-const getModulesSizes = modules => {
-	let sizes = Object.create(null);
-	for (const module of modules) {
-		for (const type of module.getSourceTypes()) {
-			sizes[type] = (sizes[type] || 0) + module.size(type);
-		}
-	}
-	return sizes;
-};
+    function extendCommentRange(comment, tokens) {
+        var target;
 
-/**
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {boolean} true, if a is always a parent of b
- */
-const isAvailableChunk = (a, b) => {
-	const queue = new Set(b.groupsIterable);
-	for (const chunkGroup of queue) {
-		if (a.isInGroup(chunkGroup)) continue;
-		if (chunkGroup.isInitial()) return false;
-		for (const parent of chunkGroup.parentsIterable) {
-			queue.add(parent);
-		}
-	}
-	return true;
-};
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
 
-class ChunkGraphModule {
-	constructor() {
-		/** @type {SortableSet<Chunk>} */
-		this.chunks = new SortableSet();
-		/** @type {Set<Chunk> | undefined} */
-		this.entryInChunks = undefined;
-		/** @type {Set<Chunk> | undefined} */
-		this.runtimeInChunks = undefined;
-		/** @type {RuntimeSpecMap<ModuleHashInfo>} */
-		this.hashes = undefined;
-		/** @type {string | number} */
-		this.id = null;
-		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
-		this.runtimeRequirements = undefined;
-		/** @type {RuntimeSpecMap<string>} */
-		this.graphHashes = undefined;
-		/** @type {RuntimeSpecMap<string>} */
-		this.graphHashesWithConnections = undefined;
-	}
-}
+        comment.extendedRange = [comment.range[0], comment.range[1]];
 
-class ChunkGraphChunk {
-	constructor() {
-		/** @type {SortableSet<Module>} */
-		this.modules = new SortableSet();
-		/** @type {Map<Module, Entrypoint>} */
-		this.entryModules = new Map();
-		/** @type {SortableSet<RuntimeModule>} */
-		this.runtimeModules = new SortableSet();
-		/** @type {Set<RuntimeModule> | undefined} */
-		this.fullHashModules = undefined;
-		/** @type {Set<RuntimeModule> | undefined} */
-		this.dependentHashModules = undefined;
-		/** @type {Set<string> | undefined} */
-		this.runtimeRequirements = undefined;
-		/** @type {Set<string>} */
-		this.runtimeRequirementsInTree = new Set();
-	}
-}
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
 
-class ChunkGraph {
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string | Hash} hashFunction the hash function to use
-	 */
-	constructor(moduleGraph, hashFunction = "md4") {
-		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
-		this._modules = new WeakMap();
-		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
-		this._chunks = new WeakMap();
-		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
-		this._blockChunkGroups = new WeakMap();
-		/** @private @type {Map<string, string | number>} */
-		this._runtimeIds = new Map();
-		/** @type {ModuleGraph} */
-		this.moduleGraph = moduleGraph;
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
 
-		this._hashFunction = hashFunction;
+        return comment;
+    }
 
-		this._getGraphRoots = this._getGraphRoots.bind(this);
-	}
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
 
-	/**
-	 * @private
-	 * @param {Module} module the module
-	 * @returns {ChunkGraphModule} internal module
-	 */
-	_getChunkGraphModule(module) {
-		let cgm = this._modules.get(module);
-		if (cgm === undefined) {
-			cgm = new ChunkGraphModule();
-			this._modules.set(module, cgm);
-		}
-		return cgm;
-	}
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
 
-	/**
-	 * @private
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ChunkGraphChunk} internal chunk
-	 */
-	_getChunkGraphChunk(chunk) {
-		let cgc = this._chunks.get(chunk);
-		if (cgc === undefined) {
-			cgc = new ChunkGraphChunk();
-			this._chunks.set(chunk, cgc);
-		}
-		return cgc;
-	}
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
 
-	/**
-	 * @param {SortableSet<Module>} set the sortable Set to get the roots of
-	 * @returns {Module[]} the graph roots
-	 */
-	_getGraphRoots(set) {
-		const { moduleGraph } = this;
-		return Array.from(
-			findGraphRoots(set, module => {
-				/** @type {Set<Module>} */
-				const set = new Set();
-				const addDependencies = module => {
-					for (const connection of moduleGraph.getOutgoingConnections(module)) {
-						if (!connection.module) continue;
-						const activeState = connection.getActiveState(undefined);
-						if (activeState === false) continue;
-						if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-							addDependencies(connection.module);
-							continue;
-						}
-						set.add(connection.module);
-					}
-				};
-				addDependencies(module);
-				return set;
-			})
-		).sort(compareModulesByIdentifier);
-	}
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	connectChunkAndModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.chunks.add(chunk);
-		cgc.modules.add(module);
-	}
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	disconnectChunkAndModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgc.modules.delete(module);
-		cgm.chunks.delete(chunk);
-	}
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
 
-	/**
-	 * @param {Chunk} chunk the chunk which will be disconnected
-	 * @returns {void}
-	 */
-	disconnectChunk(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of cgc.modules) {
-			const cgm = this._getChunkGraphModule(module);
-			cgm.chunks.delete(chunk);
-		}
-		cgc.modules.clear();
-		chunk.disconnectFromGroups();
-		ChunkGraph.clearChunkGraphForChunk(chunk);
-	}
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<Module>} modules the modules
-	 * @returns {void}
-	 */
-	attachModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of modules) {
-			cgc.modules.add(module);
-		}
-	}
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<RuntimeModule>} modules the runtime modules
-	 * @returns {void}
-	 */
-	attachRuntimeModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of modules) {
-			cgc.runtimeModules.add(module);
-		}
-	}
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
-	 * @returns {void}
-	 */
-	attachFullHashModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
-		for (const module of modules) {
-			cgc.fullHashModules.add(module);
-		}
-	}
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
-	 * @returns {void}
-	 */
-	attachDependentHashModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined)
-			cgc.dependentHashModules = new Set();
-		for (const module of modules) {
-			cgc.dependentHashModules.add(module);
-		}
-	}
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
 
-	/**
-	 * @param {Module} oldModule the replaced module
-	 * @param {Module} newModule the replacing module
-	 * @returns {void}
-	 */
-	replaceModule(oldModule, newModule) {
-		const oldCgm = this._getChunkGraphModule(oldModule);
-		const newCgm = this._getChunkGraphModule(newModule);
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-		for (const chunk of oldCgm.chunks) {
-			const cgc = this._getChunkGraphChunk(chunk);
-			cgc.modules.delete(oldModule);
-			cgc.modules.add(newModule);
-			newCgm.chunks.add(chunk);
-		}
-		oldCgm.chunks.clear();
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-		if (oldCgm.entryInChunks !== undefined) {
-			if (newCgm.entryInChunks === undefined) {
-				newCgm.entryInChunks = new Set();
-			}
-			for (const chunk of oldCgm.entryInChunks) {
-				const cgc = this._getChunkGraphChunk(chunk);
-				const old = cgc.entryModules.get(oldModule);
-				/** @type {Map<Module, Entrypoint>} */
-				const newEntryModules = new Map();
-				for (const [m, cg] of cgc.entryModules) {
-					if (m === oldModule) {
-						newEntryModules.set(newModule, old);
-					} else {
-						newEntryModules.set(m, cg);
-					}
-				}
-				cgc.entryModules = newEntryModules;
-				newCgm.entryInChunks.add(chunk);
-			}
-			oldCgm.entryInChunks = undefined;
-		}
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
-		if (oldCgm.runtimeInChunks !== undefined) {
-			if (newCgm.runtimeInChunks === undefined) {
-				newCgm.runtimeInChunks = new Set();
-			}
-			for (const chunk of oldCgm.runtimeInChunks) {
-				const cgc = this._getChunkGraphChunk(chunk);
-				cgc.runtimeModules.delete(/** @type {RuntimeModule} */ (oldModule));
-				cgc.runtimeModules.add(/** @type {RuntimeModule} */ (newModule));
-				newCgm.runtimeInChunks.add(chunk);
-				if (
-					cgc.fullHashModules !== undefined &&
-					cgc.fullHashModules.has(/** @type {RuntimeModule} */ (oldModule))
-				) {
-					cgc.fullHashModules.delete(/** @type {RuntimeModule} */ (oldModule));
-					cgc.fullHashModules.add(/** @type {RuntimeModule} */ (newModule));
-				}
-				if (
-					cgc.dependentHashModules !== undefined &&
-					cgc.dependentHashModules.has(/** @type {RuntimeModule} */ (oldModule))
-				) {
-					cgc.dependentHashModules.delete(
-						/** @type {RuntimeModule} */ (oldModule)
-					);
-					cgc.dependentHashModules.add(
-						/** @type {RuntimeModule} */ (newModule)
-					);
-				}
-			}
-			oldCgm.runtimeInChunks = undefined;
-		}
-	}
+        return tree;
+    }
 
-	/**
-	 * @param {Module} module the checked module
-	 * @param {Chunk} chunk the checked chunk
-	 * @returns {boolean} true, if the chunk contains the module
-	 */
-	isModuleInChunk(module, chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.has(module);
-	}
+    exports.version = (__webpack_require__(15535)/* .version */ .i8);
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+    exports.cloneEnvironment = function () { return clone({}); };
 
-	/**
-	 * @param {Module} module the checked module
-	 * @param {ChunkGroup} chunkGroup the checked chunk group
-	 * @returns {boolean} true, if the chunk contains the module
-	 */
-	isModuleInChunkGroup(module, chunkGroup) {
-		for (const chunk of chunkGroup.chunks) {
-			if (this.isModuleInChunk(module, chunk)) return true;
-		}
-		return false;
-	}
+    return exports;
+}(exports));
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-	/**
-	 * @param {Module} module the checked module
-	 * @returns {boolean} true, if the module is entry of any chunk
-	 */
-	isEntryModule(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.entryInChunks !== undefined;
-	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
-	 */
-	getModuleChunksIterable(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks;
-	}
+/***/ }),
 
-	/**
-	 * @param {Module} module the module
-	 * @param {function(Chunk, Chunk): -1|0|1} sortFn sort function
-	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
-	 */
-	getOrderedModuleChunksIterable(module, sortFn) {
-		const cgm = this._getChunkGraphModule(module);
-		cgm.chunks.sortWith(sortFn);
-		return cgm.chunks;
-	}
+/***/ 86140:
+/***/ (function(module) {
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {Chunk[]} array of chunks (cached, do not modify)
-	 */
-	getModuleChunks(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromCache(getArray);
-	}
+module.exports = function (glob, opts) {
+  if (typeof glob !== 'string') {
+    throw new TypeError('Expected a string');
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {number} the number of chunk which contain the module
-	 */
-	getNumberOfModuleChunks(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.size;
-	}
+  var str = String(glob);
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {RuntimeSpecSet} runtimes
-	 */
-	getModuleRuntimes(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
-	}
+  // The regexp we are building, as a string.
+  var reStr = "";
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the number of modules which are contained in this chunk
-	 */
-	getNumberOfChunkModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.size;
-	}
+  // Whether we are matching so called "extended" globs (like bash) and should
+  // support single character matching, matching ranges of characters, group
+  // matching, etc.
+  var extended = opts ? !!opts.extended : false;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the number of full hash modules which are contained in this chunk
-	 */
-	getNumberOfChunkFullHashModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size;
-	}
+  // When globstar is _false_ (default), '/foo/*' is translated a regexp like
+  // '^\/foo\/.*$' which will match any string beginning with '/foo/'
+  // When globstar is _true_, '/foo/*' is translated to regexp like
+  // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
+  // which does not have a '/' to the right of it.
+  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
+  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
+  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
+  // globstar is _false_
+  var globstar = opts ? !!opts.globstar : false;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<Module>} return the modules for this chunk
-	 */
-	getChunkModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules;
-	}
+  // If we are doing extended matching, this boolean is true when we are inside
+  // a group (eg {*.html,*.js}), and false otherwise.
+  var inGroup = false;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {string} sourceType source type
-	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
-	 */
-	getChunkModulesIterableBySourceType(chunk, sourceType) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType)
-			.get(sourceType);
-		return modulesWithSourceType;
-	}
+  // RegExp flags (eg "i" ) to pass in to RegExp constructor.
+  var flags = opts && typeof( opts.flags ) === "string" ? opts.flags : "";
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
-	 * @returns {Iterable<Module>} return the modules for this chunk
-	 */
-	getOrderedChunkModulesIterable(chunk, comparator) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgc.modules.sortWith(comparator);
-		return cgc.modules;
-	}
+  var c;
+  for (var i = 0, len = str.length; i < len; i++) {
+    c = str[i];
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {string} sourceType source type
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
-	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
-	 */
-	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType)
-			.get(sourceType);
-		if (modulesWithSourceType === undefined) return undefined;
-		modulesWithSourceType.sortWith(comparator);
-		return modulesWithSourceType;
-	}
+    switch (c) {
+    case "/":
+    case "$":
+    case "^":
+    case "+":
+    case ".":
+    case "(":
+    case ")":
+    case "=":
+    case "!":
+    case "|":
+      reStr += "\\" + c;
+      break;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
-	 */
-	getChunkModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(getArray);
-	}
+    case "?":
+      if (extended) {
+        reStr += ".";
+	    break;
+      }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
-	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
-	 */
-	getOrderedChunkModules(chunk, comparator) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const arrayFunction = createOrderedArrayFunction(comparator);
-		return cgc.modules.getFromUnorderedCache(arrayFunction);
-	}
+    case "[":
+    case "]":
+      if (extended) {
+        reStr += c;
+	    break;
+      }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, (string|number)[]>} chunk to module ids object
-	 */
-	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
-		/** @type {Record<string|number, (string|number)[]>} */
-		const chunkModuleIdMap = Object.create(null);
+    case "{":
+      if (extended) {
+        inGroup = true;
+	    reStr += "(";
+	    break;
+      }
 
-		for (const asyncChunk of includeAllChunks
-			? chunk.getAllReferencedChunks()
-			: chunk.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
-			let array;
-			for (const module of this.getOrderedChunkModulesIterable(
-				asyncChunk,
-				compareModulesById(this)
-			)) {
-				if (filterFn(module)) {
-					if (array === undefined) {
-						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
-					}
-					const moduleId = this.getModuleId(module);
-					array.push(moduleId);
-				}
-			}
-		}
+    case "}":
+      if (extended) {
+        inGroup = false;
+	    reStr += ")";
+	    break;
+      }
 
-		return chunkModuleIdMap;
-	}
+    case ",":
+      if (inGroup) {
+        reStr += "|";
+	    break;
+      }
+      reStr += "\\" + c;
+      break;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @param {number} hashLength length of the hash
-	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, Record<string|number, string>>} chunk to module id to module hash object
-	 */
-	getChunkModuleRenderedHashMap(
-		chunk,
-		filterFn,
-		hashLength = 0,
-		includeAllChunks = false
-	) {
-		/** @type {Record<string|number, Record<string|number, string>>} */
-		const chunkModuleHashMap = Object.create(null);
+    case "*":
+      // Move over all consecutive "*"'s.
+      // Also store the previous and next characters
+      var prevChar = str[i - 1];
+      var starCount = 1;
+      while(str[i + 1] === "*") {
+        starCount++;
+        i++;
+      }
+      var nextChar = str[i + 1];
 
-		for (const asyncChunk of includeAllChunks
-			? chunk.getAllReferencedChunks()
-			: chunk.getAllAsyncChunks()) {
-			/** @type {Record<string|number, string>} */
-			let idToHashMap;
-			for (const module of this.getOrderedChunkModulesIterable(
-				asyncChunk,
-				compareModulesById(this)
-			)) {
-				if (filterFn(module)) {
-					if (idToHashMap === undefined) {
-						idToHashMap = Object.create(null);
-						chunkModuleHashMap[asyncChunk.id] = idToHashMap;
-					}
-					const moduleId = this.getModuleId(module);
-					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
-					idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
-				}
-			}
-		}
+      if (!globstar) {
+        // globstar is disabled, so treat any number of "*" as one
+        reStr += ".*";
+      } else {
+        // globstar is enabled, so determine if this is a globstar segment
+        var isGlobstar = starCount > 1                      // multiple "*"'s
+          && (prevChar === "/" || prevChar === undefined)   // from the start of the segment
+          && (nextChar === "/" || nextChar === undefined)   // to the end of the segment
 
-		return chunkModuleHashMap;
-	}
+        if (isGlobstar) {
+          // it's a globstar, so match zero or more path segments
+          reStr += "((?:[^/]*(?:\/|$))*)";
+          i++; // move over the "/"
+        } else {
+          // it's not a globstar, so only match one path segment
+          reStr += "([^/]*)";
+        }
+      }
+      break;
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
-	 * @returns {Record<string|number, boolean>} chunk map
-	 */
-	getChunkConditionMap(chunk, filterFn) {
-		const map = Object.create(null);
-		for (const c of chunk.getAllReferencedChunks()) {
-			map[c.id] = filterFn(c, this);
-		}
-		return map;
-	}
+    default:
+      reStr += c;
+    }
+  }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
-	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
-	 * @returns {boolean} return true if module exists in graph
-	 */
-	hasModuleInGraph(chunk, filterFn, filterChunkFn) {
-		const queue = new Set(chunk.groupsIterable);
-		const chunksProcessed = new Set();
+  // When regexp 'g' flag is specified don't
+  // constrain the regular expression with ^ & $
+  if (!flags || !~flags.indexOf('g')) {
+    reStr = "^" + reStr + "$";
+  }
 
-		for (const chunkGroup of queue) {
-			for (const innerChunk of chunkGroup.chunks) {
-				if (!chunksProcessed.has(innerChunk)) {
-					chunksProcessed.add(innerChunk);
-					if (!filterChunkFn || filterChunkFn(innerChunk, this)) {
-						for (const module of this.getChunkModulesIterable(innerChunk)) {
-							if (filterFn(module)) {
-								return true;
-							}
-						}
-					}
-				}
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
-		return false;
-	}
+  return new RegExp(reStr, flags);
+};
 
-	/**
-	 * @param {Chunk} chunkA first chunk
-	 * @param {Chunk} chunkB second chunk
-	 * @returns {-1|0|1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
-	 */
-	compareChunks(chunkA, chunkB) {
-		const cgcA = this._getChunkGraphChunk(chunkA);
-		const cgcB = this._getChunkGraphChunk(chunkB);
-		if (cgcA.modules.size > cgcB.modules.size) return -1;
-		if (cgcA.modules.size < cgcB.modules.size) return 1;
-		cgcA.modules.sortWith(compareModulesByIdentifier);
-		cgcB.modules.sortWith(compareModulesByIdentifier);
-		return compareModuleIterables(cgcA.modules, cgcB.modules);
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} total size of all modules in the chunk
-	 */
-	getChunkModulesSize(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(getModulesSize);
-	}
+/***/ }),
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Record<string, number>} total sizes of all modules in the chunk by source type
-	 */
-	getChunkModulesSizes(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(getModulesSizes);
-	}
+/***/ 89132:
+/***/ (function(module) {
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Module[]} root modules of the chunks (ordered by identifier)
-	 */
-	getChunkRootModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(this._getGraphRoots);
-	}
+"use strict";
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk
-	 */
-	getChunkSize(chunk, options = {}) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const modulesSize = cgc.modules.getFromUnorderedCache(getModulesSize);
-		const chunkOverhead =
-			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
-		const entryChunkMultiplicator =
-			typeof options.entryChunkMultiplicator === "number"
-				? options.entryChunkMultiplicator
-				: 10;
-		return (
-			chunkOverhead +
-			modulesSize * (chunk.canBeInitial() ? entryChunkMultiplicator : 1)
-		);
-	}
 
-	/**
-	 * @param {Chunk} chunkA chunk
-	 * @param {Chunk} chunkB chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk or false if chunks can't be integrated
-	 */
-	getIntegratedChunksSize(chunkA, chunkB, options = {}) {
-		const cgcA = this._getChunkGraphChunk(chunkA);
-		const cgcB = this._getChunkGraphChunk(chunkB);
-		const allModules = new Set(cgcA.modules);
-		for (const m of cgcB.modules) allModules.add(m);
-		let modulesSize = getModulesSize(allModules);
-		const chunkOverhead =
-			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
-		const entryChunkMultiplicator =
-			typeof options.entryChunkMultiplicator === "number"
-				? options.entryChunkMultiplicator
-				: 10;
-		return (
-			chunkOverhead +
-			modulesSize *
-				(chunkA.canBeInitial() || chunkB.canBeInitial()
-					? entryChunkMultiplicator
-					: 1)
-		);
-	}
+module.exports = clone
 
-	/**
-	 * @param {Chunk} chunkA chunk
-	 * @param {Chunk} chunkB chunk
-	 * @returns {boolean} true, if chunks could be integrated
-	 */
-	canChunksBeIntegrated(chunkA, chunkB) {
-		if (chunkA.preventIntegration || chunkB.preventIntegration) {
-			return false;
-		}
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
+}
 
-		const hasRuntimeA = chunkA.hasRuntime();
-		const hasRuntimeB = chunkB.hasRuntime();
+function clone (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
 
-		if (hasRuntimeA !== hasRuntimeB) {
-			if (hasRuntimeA) {
-				return isAvailableChunk(chunkA, chunkB);
-			} else if (hasRuntimeB) {
-				return isAvailableChunk(chunkB, chunkA);
-			} else {
-				return false;
-			}
-		}
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) }
+  else
+    var copy = Object.create(null)
 
-		if (
-			this.getNumberOfEntryModules(chunkA) > 0 ||
-			this.getNumberOfEntryModules(chunkB) > 0
-		) {
-			return false;
-		}
+  Object.getOwnPropertyNames(obj).forEach(function (key) {
+    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+  })
 
-		return true;
-	}
+  return copy
+}
 
-	/**
-	 * @param {Chunk} chunkA the target chunk
-	 * @param {Chunk} chunkB the chunk to integrate
-	 * @returns {void}
-	 */
-	integrateChunks(chunkA, chunkB) {
-		// Decide for one name (deterministic)
-		if (chunkA.name && chunkB.name) {
-			if (
-				this.getNumberOfEntryModules(chunkA) > 0 ===
-				this.getNumberOfEntryModules(chunkB) > 0
-			) {
-				// When both chunks have entry modules or none have one, use
-				// shortest name
-				if (chunkA.name.length !== chunkB.name.length) {
-					chunkA.name =
-						chunkA.name.length < chunkB.name.length ? chunkA.name : chunkB.name;
-				} else {
-					chunkA.name = chunkA.name < chunkB.name ? chunkA.name : chunkB.name;
-				}
-			} else if (this.getNumberOfEntryModules(chunkB) > 0) {
-				// Pick the name of the chunk with the entry module
-				chunkA.name = chunkB.name;
-			}
-		} else if (chunkB.name) {
-			chunkA.name = chunkB.name;
-		}
 
-		// Merge id name hints
-		for (const hint of chunkB.idNameHints) {
-			chunkA.idNameHints.add(hint);
-		}
+/***/ }),
 
-		// Merge runtime
-		chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime);
+/***/ 90552:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
-		for (const module of this.getChunkModules(chunkB)) {
-			this.disconnectChunkAndModule(chunkB, module);
-			this.connectChunkAndModule(chunkA, module);
-		}
+var fs = __webpack_require__(57147)
+var polyfills = __webpack_require__(11290)
+var legacy = __webpack_require__(54410)
+var clone = __webpack_require__(89132)
 
-		for (const [module, chunkGroup] of Array.from(
-			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
-		)) {
-			this.disconnectChunkAndEntryModule(chunkB, module);
-			this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
-		}
+var util = __webpack_require__(73837)
 
-		for (const chunkGroup of chunkB.groupsIterable) {
-			chunkGroup.replaceChunk(chunkB, chunkA);
-			chunkA.addGroup(chunkGroup);
-			chunkB.removeGroup(chunkGroup);
-		}
-		ChunkGraph.clearChunkGraphForChunk(chunkB);
-	}
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue
+var previousSymbol
 
-	/**
-	 * @param {Chunk} chunk the chunk to upgrade
-	 * @returns {void}
-	 */
-	upgradeDependentToFullHashModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined) return;
-		if (cgc.fullHashModules === undefined) {
-			cgc.fullHashModules = cgc.dependentHashModules;
-		} else {
-			for (const m of cgc.dependentHashModules) {
-				cgc.fullHashModules.add(m);
-			}
-			cgc.dependentHashModules = undefined;
-		}
-	}
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+  gracefulQueue = Symbol.for('graceful-fs.queue')
+  // This is used in testing by future versions
+  previousSymbol = Symbol.for('graceful-fs.previous')
+} else {
+  gracefulQueue = '___graceful-fs.queue'
+  previousSymbol = '___graceful-fs.previous'
+}
 
-	/**
-	 * @param {Module} module the checked module
-	 * @param {Chunk} chunk the checked chunk
-	 * @returns {boolean} true, if the chunk contains the module as entry
-	 */
-	isEntryModuleInChunk(module, chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules.has(module);
-	}
+function noop () {}
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {Module} module the entry module
-	 * @param {Entrypoint=} entrypoint the chunk group which must be loaded before the module is executed
-	 * @returns {void}
-	 */
-	connectChunkAndEntryModule(chunk, module, entrypoint) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgm.entryInChunks === undefined) {
-			cgm.entryInChunks = new Set();
-		}
-		cgm.entryInChunks.add(chunk);
-		cgc.entryModules.set(module, entrypoint);
-	}
+function publishQueue(context, queue) {
+  Object.defineProperty(context, gracefulQueue, {
+    get: function() {
+      return queue
+    }
+  })
+}
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the runtime module
-	 * @returns {void}
-	 */
-	connectChunkAndRuntimeModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgm.runtimeInChunks === undefined) {
-			cgm.runtimeInChunks = new Set();
-		}
-		cgm.runtimeInChunks.add(chunk);
-		cgc.runtimeModules.add(module);
-	}
+var debug = noop
+if (util.debuglog)
+  debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments)
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+    console.error(m)
+  }
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the module that require a full hash
-	 * @returns {void}
-	 */
-	addFullHashModuleToChunk(chunk, module) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
-		cgc.fullHashModules.add(module);
-	}
+// Once time initialization
+if (!fs[gracefulQueue]) {
+  // This queue can be shared by multiple loaded instances
+  var queue = global[gracefulQueue] || []
+  publishQueue(fs, queue)
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the module that require a full hash
-	 * @returns {void}
-	 */
-	addDependentHashModuleToChunk(chunk, module) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined)
-			cgc.dependentHashModules = new Set();
-		cgc.dependentHashModules.add(module);
-	}
+  // Patch fs.close/closeSync to shared queue version, because we need
+  // to retry() whenever a close happens *anywhere* in the program.
+  // This is essential when multiple graceful-fs instances are
+  // in play at the same time.
+  fs.close = (function (fs$close) {
+    function close (fd, cb) {
+      return fs$close.call(fs, fd, function (err) {
+        // This function uses the graceful-fs shared queue
+        if (!err) {
+          resetQueue()
+        }
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {Module} module the entry module
-	 * @returns {void}
-	 */
-	disconnectChunkAndEntryModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.entryInChunks.delete(chunk);
-		if (cgm.entryInChunks.size === 0) {
-			cgm.entryInChunks = undefined;
-		}
-		cgc.entryModules.delete(module);
-	}
+        if (typeof cb === 'function')
+          cb.apply(this, arguments)
+      })
+    }
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the runtime module
-	 * @returns {void}
-	 */
-	disconnectChunkAndRuntimeModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.runtimeInChunks.delete(chunk);
-		if (cgm.runtimeInChunks.size === 0) {
-			cgm.runtimeInChunks = undefined;
-		}
-		cgc.runtimeModules.delete(module);
-	}
+    Object.defineProperty(close, previousSymbol, {
+      value: fs$close
+    })
+    return close
+  })(fs.close)
 
-	/**
-	 * @param {Module} module the entry module, it will no longer be entry
-	 * @returns {void}
-	 */
-	disconnectEntryModule(module) {
-		const cgm = this._getChunkGraphModule(module);
-		for (const chunk of cgm.entryInChunks) {
-			const cgc = this._getChunkGraphChunk(chunk);
-			cgc.entryModules.delete(module);
-		}
-		cgm.entryInChunks = undefined;
-	}
+  fs.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
+      // This function uses the graceful-fs shared queue
+      fs$closeSync.apply(fs, arguments)
+      resetQueue()
+    }
 
-	/**
-	 * @param {Chunk} chunk the chunk, for which all entries will be removed
-	 * @returns {void}
-	 */
-	disconnectEntries(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of cgc.entryModules.keys()) {
-			const cgm = this._getChunkGraphModule(module);
-			cgm.entryInChunks.delete(chunk);
-			if (cgm.entryInChunks.size === 0) {
-				cgm.entryInChunks = undefined;
-			}
-		}
-		cgc.entryModules.clear();
-	}
+    Object.defineProperty(closeSync, previousSymbol, {
+      value: fs$closeSync
+    })
+    return closeSync
+  })(fs.closeSync)
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the amount of entry modules in chunk
-	 */
-	getNumberOfEntryModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules.size;
-	}
+  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+    process.on('exit', function() {
+      debug(fs[gracefulQueue])
+      __webpack_require__(39491).equal(fs[gracefulQueue].length, 0)
+    })
+  }
+}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the amount of entry modules in chunk
-	 */
-	getNumberOfRuntimeModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.runtimeModules.size;
-	}
+if (!global[gracefulQueue]) {
+  publishQueue(global, fs[gracefulQueue]);
+}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<Module>} iterable of modules (do not modify)
-	 */
-	getChunkEntryModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules.keys();
-	}
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    module.exports = patch(fs)
+    fs.__patched = true;
+}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<Chunk>} iterable of chunks
-	 */
-	getChunkEntryDependentChunksIterable(chunk) {
-		/** @type {Set<Chunk>} */
-		const set = new Set();
-		for (const chunkGroup of chunk.groupsIterable) {
-			if (chunkGroup instanceof Entrypoint) {
-				const entrypointChunk = chunkGroup.getEntrypointChunk();
-				const cgc = this._getChunkGraphChunk(entrypointChunk);
-				for (const chunkGroup of cgc.entryModules.values()) {
-					for (const c of chunkGroup.chunks) {
-						if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
-							set.add(c);
-						}
-					}
-				}
-			}
-		}
+function patch (fs) {
+  // Everything that references the open() function needs to be in here
+  polyfills(fs)
+  fs.gracefulify = patch
 
-		return set;
-	}
+  fs.createReadStream = createReadStream
+  fs.createWriteStream = createWriteStream
+  var fs$readFile = fs.readFile
+  fs.readFile = readFile
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {boolean} true, when it has dependent chunks
-	 */
-	hasChunkEntryDependentChunks(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const chunkGroup of cgc.entryModules.values()) {
-			for (const c of chunkGroup.chunks) {
-				if (c !== chunk) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
+    return go$readFile(path, options, cb)
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<RuntimeModule>} iterable of modules (do not modify)
-	 */
-	getChunkRuntimeModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.runtimeModules;
-	}
+    function go$readFile (path, options, cb, startTime) {
+      return fs$readFile(path, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {RuntimeModule[]} array of modules in order of execution
-	 */
-	getChunkRuntimeModulesInOrder(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const array = Array.from(cgc.runtimeModules);
-		array.sort(
-			concatComparators(
-				compareSelect(
-					/**
-					 * @param {RuntimeModule} r runtime module
-					 * @returns {number=} stage
-					 */
-					r => r.stage,
-					compareIds
-				),
-				compareModulesByIdentifier
-			)
-		);
-		return array;
-	}
+  var fs$writeFile = fs.writeFile
+  fs.writeFile = writeFile
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
-	 */
-	getChunkFullHashModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.fullHashModules;
-	}
+    return go$writeFile(path, data, options, cb)
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<RuntimeModule> | undefined} set of modules (do not modify)
-	 */
-	getChunkFullHashModulesSet(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.fullHashModules;
-	}
+    function go$writeFile (path, data, options, cb, startTime) {
+      return fs$writeFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
-	 */
-	getChunkDependentHashModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.dependentHashModules;
-	}
+  var fs$appendFile = fs.appendFile
+  if (fs$appendFile)
+    fs.appendFile = appendFile
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
+    return go$appendFile(path, data, options, cb)
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<EntryModuleWithChunkGroup>} iterable of modules (do not modify)
-	 */
-	getChunkEntryModulesWithChunkGroupIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules;
-	}
+    function go$appendFile (path, data, options, cb, startTime) {
+      return fs$appendFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-	/**
-	 * @param {AsyncDependenciesBlock} depBlock the async block
-	 * @returns {ChunkGroup} the chunk group
-	 */
-	getBlockChunkGroup(depBlock) {
-		return this._blockChunkGroups.get(depBlock);
-	}
+  var fs$copyFile = fs.copyFile
+  if (fs$copyFile)
+    fs.copyFile = copyFile
+  function copyFile (src, dest, flags, cb) {
+    if (typeof flags === 'function') {
+      cb = flags
+      flags = 0
+    }
+    return go$copyFile(src, dest, flags, cb)
 
-	/**
-	 * @param {AsyncDependenciesBlock} depBlock the async block
-	 * @param {ChunkGroup} chunkGroup the chunk group
-	 * @returns {void}
-	 */
-	connectBlockAndChunkGroup(depBlock, chunkGroup) {
-		this._blockChunkGroups.set(depBlock, chunkGroup);
-		chunkGroup.addBlock(depBlock);
-	}
+    function go$copyFile (src, dest, flags, cb, startTime) {
+      return fs$copyFile(src, dest, flags, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunk group
-	 * @returns {void}
-	 */
-	disconnectChunkGroup(chunkGroup) {
-		for (const block of chunkGroup.blocksIterable) {
-			this._blockChunkGroups.delete(block);
-		}
-		// TODO refactor by moving blocks list into ChunkGraph
-		chunkGroup._blocks.clear();
-	}
+  var fs$readdir = fs.readdir
+  fs.readdir = readdir
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {string | number} the id of the module
-	 */
-	getModuleId(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.id;
-	}
+    return go$readdir(path, options, cb)
 
-	/**
-	 * @param {Module} module the module
-	 * @param {string | number} id the id of the module
-	 * @returns {void}
-	 */
-	setModuleId(module, id) {
-		const cgm = this._getChunkGraphModule(module);
-		cgm.id = id;
-	}
+    function go$readdir (path, options, cb, startTime) {
+      return fs$readdir(path, options, function (err, files) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (files && files.sort)
+            files.sort()
 
-	/**
-	 * @param {string} runtime runtime
-	 * @returns {string | number} the id of the runtime
-	 */
-	getRuntimeId(runtime) {
-		return this._runtimeIds.get(runtime);
-	}
+          if (typeof cb === 'function')
+            cb.call(this, err, files)
+        }
+      })
+    }
+  }
 
-	/**
-	 * @param {string} runtime runtime
-	 * @param {string | number} id the id of the runtime
-	 * @returns {void}
-	 */
-	setRuntimeId(runtime, id) {
-		this._runtimeIds.set(runtime, id);
-	}
+  if (process.version.substr(0, 4) === 'v0.8') {
+    var legStreams = legacy(fs)
+    ReadStream = legStreams.ReadStream
+    WriteStream = legStreams.WriteStream
+  }
 
-	/**
-	 * @template T
-	 * @param {Module} module the module
-	 * @param {RuntimeSpecMap<T>} hashes hashes data
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {T} hash
-	 */
-	_getModuleHashInfo(module, hashes, runtime) {
-		if (!hashes) {
-			throw new Error(
-				`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
-					runtime
-				)} (hashes not set at all)`
-			);
-		} else if (runtime === undefined) {
-			const hashInfoItems = new Set(hashes.values());
-			if (hashInfoItems.size !== 1) {
-				throw new Error(
-					`No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
-						hashes.keys(),
-						r => runtimeToString(r)
-					).join(", ")}).
-Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
-				);
-			}
-			return first(hashInfoItems);
-		} else {
-			const hashInfo = hashes.get(runtime);
-			if (!hashInfo) {
-				throw new Error(
-					`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
-						runtime
-					)} (available runtimes ${Array.from(
-						hashes.keys(),
-						runtimeToString
-					).join(", ")})`
-				);
-			}
-			return hashInfo;
-		}
-	}
+  var fs$ReadStream = fs.ReadStream
+  if (fs$ReadStream) {
+    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+    ReadStream.prototype.open = ReadStream$open
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, if the module has hashes for this runtime
-	 */
-	hasModuleHashes(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		return hashes && hashes.has(runtime);
-	}
+  var fs$WriteStream = fs.WriteStream
+  if (fs$WriteStream) {
+    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+    WriteStream.prototype.open = WriteStream$open
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	getModuleHash(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		return this._getModuleHashInfo(module, hashes, runtime).hash;
-	}
+  Object.defineProperty(fs, 'ReadStream', {
+    get: function () {
+      return ReadStream
+    },
+    set: function (val) {
+      ReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  Object.defineProperty(fs, 'WriteStream', {
+    get: function () {
+      return WriteStream
+    },
+    set: function (val) {
+      WriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	getRenderedModuleHash(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
-	}
+  // legacy names
+  var FileReadStream = ReadStream
+  Object.defineProperty(fs, 'FileReadStream', {
+    get: function () {
+      return FileReadStream
+    },
+    set: function (val) {
+      FileReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  var FileWriteStream = WriteStream
+  Object.defineProperty(fs, 'FileWriteStream', {
+    get: function () {
+      return FileWriteStream
+    },
+    set: function (val) {
+      FileWriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {string} hash the full hash
-	 * @param {string} renderedHash the shortened hash for rendering
-	 * @returns {void}
-	 */
-	setModuleHashes(module, runtime, hash, renderedHash) {
-		const cgm = this._getChunkGraphModule(module);
-		if (cgm.hashes === undefined) {
-			cgm.hashes = new RuntimeSpecMap();
-		}
-		cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash));
-	}
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
-	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
-	 * @returns {void}
-	 */
-	addModuleRuntimeRequirements(
-		module,
-		runtime,
-		items,
-		transferOwnership = true
-	) {
-		const cgm = this._getChunkGraphModule(module);
-		const runtimeRequirementsMap = cgm.runtimeRequirements;
-		if (runtimeRequirementsMap === undefined) {
-			const map = new RuntimeSpecMap();
-			// TODO avoid cloning item and track ownership instead
-			map.set(runtime, transferOwnership ? items : new Set(items));
-			cgm.runtimeRequirements = map;
-			return;
-		}
-		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
-			if (runtimeRequirements === undefined) {
-				return transferOwnership ? items : new Set(items);
-			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
-				for (const item of items) runtimeRequirements.add(item);
-				return runtimeRequirements;
-			} else {
-				for (const item of runtimeRequirements) items.add(item);
-				return items;
-			}
-		});
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
-	 * @returns {void}
-	 */
-	addChunkRuntimeRequirements(chunk, items) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const runtimeRequirements = cgc.runtimeRequirements;
-		if (runtimeRequirements === undefined) {
-			cgc.runtimeRequirements = items;
-		} else if (runtimeRequirements.size >= items.size) {
-			for (const item of items) runtimeRequirements.add(item);
-		} else {
-			for (const item of runtimeRequirements) items.add(item);
-			cgc.runtimeRequirements = items;
-		}
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<string>} items runtime requirements to be added
-	 * @returns {void}
-	 */
-	addTreeRuntimeRequirements(chunk, items) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const runtimeRequirements = cgc.runtimeRequirementsInTree;
-		for (const item of items) runtimeRequirements.add(item);
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getModuleRuntimeRequirements(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const runtimeRequirements =
-			cgm.runtimeRequirements && cgm.runtimeRequirements.get(runtime);
-		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
-	}
+  function ReadStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        if (that.autoClose)
+          that.destroy()
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getChunkRuntimeRequirements(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const runtimeRequirements = cgc.runtimeRequirements;
-		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
-	}
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+        that.read()
+      }
+    })
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {boolean} withConnections include connections
-	 * @returns {string} hash
-	 */
-	getModuleGraphHash(module, runtime, withConnections = true) {
-		const cgm = this._getChunkGraphModule(module);
-		return withConnections
-			? this._getModuleGraphHashWithConnections(cgm, module, runtime)
-			: this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
-	}
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {boolean} withConnections include connections
-	 * @returns {bigint} hash
-	 */
-	getModuleGraphHashBigInt(module, runtime, withConnections = true) {
-		const cgm = this._getChunkGraphModule(module);
-		return withConnections
-			? BigInt(
-					`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`
-			  )
-			: this._getModuleGraphHashBigInt(cgm, module, runtime);
-	}
+  function WriteStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        that.destroy()
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+      }
+    })
+  }
 
-	/**
-	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {bigint} hash as big int
-	 */
-	_getModuleGraphHashBigInt(cgm, module, runtime) {
-		if (cgm.graphHashes === undefined) {
-			cgm.graphHashes = new RuntimeSpecMap();
-		}
-		const graphHash = cgm.graphHashes.provide(runtime, () => {
-			const hash = createHash(this._hashFunction);
-			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
-			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
-			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
-		});
-		return graphHash;
-	}
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
+  }
 
-	/**
-	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	_getModuleGraphHashWithConnections(cgm, module, runtime) {
-		if (cgm.graphHashesWithConnections === undefined) {
-			cgm.graphHashesWithConnections = new RuntimeSpecMap();
-		}
-		const activeStateToString = state => {
-			if (state === false) return "F";
-			if (state === true) return "T";
-			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
-			throw new Error("Not implemented active state");
-		};
-		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
-		return cgm.graphHashesWithConnections.provide(runtime, () => {
-			const graphHash = this._getModuleGraphHashBigInt(
-				cgm,
-				module,
-				runtime
-			).toString(16);
-			const connections = this.moduleGraph.getOutgoingConnections(module);
-			/** @type {Set<Module>} */
-			const activeNamespaceModules = new Set();
-			/** @type {Map<string, Module | Set<Module>>} */
-			const connectedModules = new Map();
-			const processConnection = (connection, stateInfo) => {
-				const module = connection.module;
-				stateInfo += module.getExportsType(this.moduleGraph, strict);
-				// cspell:word Tnamespace
-				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
-				else {
-					const oldModule = connectedModules.get(stateInfo);
-					if (oldModule === undefined) {
-						connectedModules.set(stateInfo, module);
-					} else if (oldModule instanceof Set) {
-						oldModule.add(module);
-					} else if (oldModule !== module) {
-						connectedModules.set(stateInfo, new Set([oldModule, module]));
-					}
-				}
-			};
-			if (runtime === undefined || typeof runtime === "string") {
-				for (const connection of connections) {
-					const state = connection.getActiveState(runtime);
-					if (state === false) continue;
-					processConnection(connection, state === true ? "T" : "O");
-				}
-			} else {
-				// cspell:word Tnamespace
-				for (const connection of connections) {
-					const states = new Set();
-					let stateInfo = "";
-					forEachRuntime(
-						runtime,
-						runtime => {
-							const state = connection.getActiveState(runtime);
-							states.add(state);
-							stateInfo += activeStateToString(state) + runtime;
-						},
-						true
-					);
-					if (states.size === 1) {
-						const state = first(states);
-						if (state === false) continue;
-						stateInfo = activeStateToString(state);
-					}
-					processConnection(connection, stateInfo);
-				}
-			}
-			// cspell:word Tnamespace
-			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
-				return graphHash;
-			const connectedModulesInOrder =
-				connectedModules.size > 1
-					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
-					: connectedModules;
-			const hash = createHash(this._hashFunction);
-			const addModuleToHash = module => {
-				hash.update(
-					this._getModuleGraphHashBigInt(
-						this._getChunkGraphModule(module),
-						module,
-						runtime
-					).toString(16)
-				);
-			};
-			const addModulesToHash = modules => {
-				let xor = ZERO_BIG_INT;
-				for (const m of modules) {
-					xor =
-						xor ^
-						this._getModuleGraphHashBigInt(
-							this._getChunkGraphModule(m),
-							m,
-							runtime
-						);
-				}
-				hash.update(xor.toString(16));
-			};
-			if (activeNamespaceModules.size === 1)
-				addModuleToHash(activeNamespaceModules.values().next().value);
-			else if (activeNamespaceModules.size > 1)
-				addModulesToHash(activeNamespaceModules);
-			for (const [stateInfo, modules] of connectedModulesInOrder) {
-				hash.update(stateInfo);
-				if (modules instanceof Set) {
-					addModulesToHash(modules);
-				} else {
-					addModuleToHash(modules);
-				}
-			}
-			hash.update(graphHash);
-			return /** @type {string} */ (hash.digest("hex"));
-		});
-	}
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
+  }
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getTreeRuntimeRequirements(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.runtimeRequirementsInTree;
-	}
+  var fs$open = fs.open
+  fs.open = open
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @param {string} deprecateMessage message for the deprecation message
-	 * @param {string} deprecationCode code for the deprecation
-	 * @returns {ChunkGraph} the chunk graph
-	 */
-	static getChunkGraphForModule(module, deprecateMessage, deprecationCode) {
-		const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage);
-		if (fn) return fn(module);
-		const newFn = util.deprecate(
-			/**
-			 * @param {Module} module the module
-			 * @returns {ChunkGraph} the chunk graph
-			 */
-			module => {
-				const chunkGraph = chunkGraphForModuleMap.get(module);
-				if (!chunkGraph)
-					throw new Error(
-						deprecateMessage +
-							": There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)"
-					);
-				return chunkGraph;
-			},
-			deprecateMessage + ": Use new ChunkGraph API",
-			deprecationCode
-		);
-		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
-		return newFn(module);
-	}
+    return go$open(path, flags, mode, cb)
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	static setChunkGraphForModule(module, chunkGraph) {
-		chunkGraphForModuleMap.set(module, chunkGraph);
-	}
+    function go$open (path, flags, mode, cb, startTime) {
+      return fs$open(path, flags, mode, function (err, fd) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	static clearChunkGraphForModule(module) {
-		chunkGraphForModuleMap.delete(module);
-	}
+  return fs
+}
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {string} deprecateMessage message for the deprecation message
-	 * @param {string} deprecationCode code for the deprecation
-	 * @returns {ChunkGraph} the chunk graph
-	 */
-	static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) {
-		const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage);
-		if (fn) return fn(chunk);
-		const newFn = util.deprecate(
-			/**
-			 * @param {Chunk} chunk the chunk
-			 * @returns {ChunkGraph} the chunk graph
-			 */
-			chunk => {
-				const chunkGraph = chunkGraphForChunkMap.get(chunk);
-				if (!chunkGraph)
-					throw new Error(
-						deprecateMessage +
-							"There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)"
-					);
-				return chunkGraph;
-			},
-			deprecateMessage + ": Use new ChunkGraph API",
-			deprecationCode
-		);
-		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);
-		return newFn(chunk);
-	}
+function enqueue (elem) {
+  debug('ENQUEUE', elem[0].name, elem[1])
+  fs[gracefulQueue].push(elem)
+  retry()
+}
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	static setChunkGraphForChunk(chunk, chunkGraph) {
-		chunkGraphForChunkMap.set(chunk, chunkGraph);
-	}
+// keep track of the timeout between retry() calls
+var retryTimer
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {void}
-	 */
-	static clearChunkGraphForChunk(chunk) {
-		chunkGraphForChunkMap.delete(chunk);
-	}
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+  var now = Date.now()
+  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+    // entries that are only a length of 2 are from an older version, don't
+    // bother modifying those since they'll be retried anyway.
+    if (fs[gracefulQueue][i].length > 2) {
+      fs[gracefulQueue][i][3] = now // startTime
+      fs[gracefulQueue][i][4] = now // lastTime
+    }
+  }
+  // call retry to make sure we're actively processing the queue
+  retry()
 }
 
-// TODO remove in webpack 6
-/** @type {WeakMap<Module, ChunkGraph>} */
-const chunkGraphForModuleMap = new WeakMap();
+function retry () {
+  // clear the timer and remove it to help prevent unintended concurrency
+  clearTimeout(retryTimer)
+  retryTimer = undefined
 
-// TODO remove in webpack 6
-/** @type {WeakMap<Chunk, ChunkGraph>} */
-const chunkGraphForChunkMap = new WeakMap();
+  if (fs[gracefulQueue].length === 0)
+    return
 
-// TODO remove in webpack 6
-/** @type {Map<string, (module: Module) => ChunkGraph>} */
-const deprecateGetChunkGraphForModuleMap = new Map();
+  var elem = fs[gracefulQueue].shift()
+  var fn = elem[0]
+  var args = elem[1]
+  // these items may be unset if they were added by an older graceful-fs
+  var err = elem[2]
+  var startTime = elem[3]
+  var lastTime = elem[4]
 
-// TODO remove in webpack 6
-/** @type {Map<string, (chunk: Chunk) => ChunkGraph>} */
-const deprecateGetChunkGraphForChunkMap = new Map();
+  // if we don't have a startTime we have no way of knowing if we've waited
+  // long enough, so go ahead and retry this item now
+  if (startTime === undefined) {
+    debug('RETRY', fn.name, args)
+    fn.apply(null, args)
+  } else if (Date.now() - startTime >= 60000) {
+    // it's been more than 60 seconds total, bail now
+    debug('TIMEOUT', fn.name, args)
+    var cb = args.pop()
+    if (typeof cb === 'function')
+      cb.call(null, err)
+  } else {
+    // the amount of time between the last attempt and right now
+    var sinceAttempt = Date.now() - lastTime
+    // the amount of time between when we first tried, and when we last tried
+    // rounded up to at least 1
+    var sinceStart = Math.max(lastTime - startTime, 1)
+    // backoff. wait longer than the total time we've been retrying, but only
+    // up to a maximum of 100ms
+    var desiredDelay = Math.min(sinceStart * 1.2, 100)
+    // it's been long enough since the last retry, do it again
+    if (sinceAttempt >= desiredDelay) {
+      debug('RETRY', fn.name, args)
+      fn.apply(null, args.concat([startTime]))
+    } else {
+      // if we can't do this job yet, push it to the end of the queue
+      // and let the next iteration check again
+      fs[gracefulQueue].push(elem)
+    }
+  }
 
-module.exports = ChunkGraph;
+  // schedule our next run if one isn't already scheduled
+  if (retryTimer === undefined) {
+    retryTimer = setTimeout(retry, 0)
+  }
+}
 
 
 /***/ }),
 
-/***/ 15626:
+/***/ 54410:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+var Stream = (__webpack_require__(12781).Stream)
 
+module.exports = legacy
 
-const util = __webpack_require__(73837);
-const SortableSet = __webpack_require__(13098);
-const {
-	compareLocations,
-	compareChunks,
-	compareIterables
-} = __webpack_require__(29579);
+function legacy (fs) {
+  return {
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+  }
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Entrypoint")} Entrypoint */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
+  function ReadStream (path, options) {
+    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
 
-/** @typedef {{id: number}} HasId */
-/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */
+    Stream.call(this);
 
-/**
- * @typedef {Object} RawChunkGroupOptions
- * @property {number=} preloadOrder
- * @property {number=} prefetchOrder
- */
+    var self = this;
 
-/** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
+    this.path = path;
+    this.fd = null;
+    this.readable = true;
+    this.paused = false;
 
-let debugId = 5000;
+    this.flags = 'r';
+    this.mode = 438; /*=0666*/
+    this.bufferSize = 64 * 1024;
 
-/**
- * @template T
- * @param {SortableSet<T>} set set to convert to array.
- * @returns {T[]} the array format of existing set
- */
-const getArray = set => Array.from(set);
+    options = options || {};
 
-/**
- * A convenience method used to sort chunks based on their id's
- * @param {ChunkGroup} a first sorting comparator
- * @param {ChunkGroup} b second sorting comparator
- * @returns {1|0|-1} a sorting index to determine order
- */
-const sortById = (a, b) => {
-	if (a.id < b.id) return -1;
-	if (b.id < a.id) return 1;
-	return 0;
-};
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
 
-/**
- * @param {OriginRecord} a the first comparator in sort
- * @param {OriginRecord} b the second comparator in sort
- * @returns {1|-1|0} returns sorting order as index
- */
-const sortOrigin = (a, b) => {
-	const aIdent = a.module ? a.module.identifier() : "";
-	const bIdent = b.module ? b.module.identifier() : "";
-	if (aIdent < bIdent) return -1;
-	if (aIdent > bIdent) return 1;
-	return compareLocations(a.loc, b.loc);
-};
+    if (this.encoding) this.setEncoding(this.encoding);
 
-class ChunkGroup {
-	/**
-	 * Creates an instance of ChunkGroup.
-	 * @param {string|ChunkGroupOptions=} options chunk group options passed to chunkGroup
-	 */
-	constructor(options) {
-		if (typeof options === "string") {
-			options = { name: options };
-		} else if (!options) {
-			options = { name: undefined };
-		}
-		/** @type {number} */
-		this.groupDebugId = debugId++;
-		this.options = options;
-		/** @type {SortableSet<ChunkGroup>} */
-		this._children = new SortableSet(undefined, sortById);
-		/** @type {SortableSet<ChunkGroup>} */
-		this._parents = new SortableSet(undefined, sortById);
-		/** @type {SortableSet<ChunkGroup>} */
-		this._asyncEntrypoints = new SortableSet(undefined, sortById);
-		this._blocks = new SortableSet();
-		/** @type {Chunk[]} */
-		this.chunks = [];
-		/** @type {OriginRecord[]} */
-		this.origins = [];
-		/** Indices in top-down order */
-		/** @private @type {Map<Module, number>} */
-		this._modulePreOrderIndices = new Map();
-		/** Indices in bottom-up order */
-		/** @private @type {Map<Module, number>} */
-		this._modulePostOrderIndices = new Map();
-		/** @type {number} */
-		this.index = undefined;
-	}
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.end === undefined) {
+        this.end = Infinity;
+      } else if ('number' !== typeof this.end) {
+        throw TypeError('end must be a Number');
+      }
 
-	/**
-	 * when a new chunk is added to a chunkGroup, addingOptions will occur.
-	 * @param {ChunkGroupOptions} options the chunkGroup options passed to addOptions
-	 * @returns {void}
-	 */
-	addOptions(options) {
-		for (const key of Object.keys(options)) {
-			if (this.options[key] === undefined) {
-				this.options[key] = options[key];
-			} else if (this.options[key] !== options[key]) {
-				if (key.endsWith("Order")) {
-					this.options[key] = Math.max(this.options[key], options[key]);
-				} else {
-					throw new Error(
-						`ChunkGroup.addOptions: No option merge strategy for ${key}`
-					);
-				}
-			}
-		}
-	}
+      if (this.start > this.end) {
+        throw new Error('start must be <= end');
+      }
 
-	/**
-	 * returns the name of current ChunkGroup
-	 * @returns {string|undefined} returns the ChunkGroup name
-	 */
-	get name() {
-		return this.options.name;
-	}
+      this.pos = this.start;
+    }
 
-	/**
-	 * sets a new name for current ChunkGroup
-	 * @param {string} value the new name for ChunkGroup
-	 * @returns {void}
-	 */
-	set name(value) {
-		this.options.name = value;
-	}
+    if (this.fd !== null) {
+      process.nextTick(function() {
+        self._read();
+      });
+      return;
+    }
 
-	/* istanbul ignore next */
-	/**
-	 * get a uniqueId for ChunkGroup, made up of its member Chunk debugId's
-	 * @returns {string} a unique concatenation of chunk debugId's
-	 */
-	get debugId() {
-		return Array.from(this.chunks, x => x.debugId).join("+");
-	}
+    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+      if (err) {
+        self.emit('error', err);
+        self.readable = false;
+        return;
+      }
 
-	/**
-	 * get a unique id for ChunkGroup, made up of its member Chunk id's
-	 * @returns {string} a unique concatenation of chunk ids
-	 */
-	get id() {
-		return Array.from(this.chunks, x => x.id).join("+");
-	}
+      self.fd = fd;
+      self.emit('open', fd);
+      self._read();
+    })
+  }
 
-	/**
-	 * Performs an unshift of a specific chunk
-	 * @param {Chunk} chunk chunk being unshifted
-	 * @returns {boolean} returns true if attempted chunk shift is accepted
-	 */
-	unshiftChunk(chunk) {
-		const oldIdx = this.chunks.indexOf(chunk);
-		if (oldIdx > 0) {
-			this.chunks.splice(oldIdx, 1);
-			this.chunks.unshift(chunk);
-		} else if (oldIdx < 0) {
-			this.chunks.unshift(chunk);
-			return true;
-		}
-		return false;
-	}
+  function WriteStream (path, options) {
+    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
 
-	/**
-	 * inserts a chunk before another existing chunk in group
-	 * @param {Chunk} chunk Chunk being inserted
-	 * @param {Chunk} before Placeholder/target chunk marking new chunk insertion point
-	 * @returns {boolean} return true if insertion was successful
-	 */
-	insertChunk(chunk, before) {
-		const oldIdx = this.chunks.indexOf(chunk);
-		const idx = this.chunks.indexOf(before);
-		if (idx < 0) {
-			throw new Error("before chunk not found");
-		}
-		if (oldIdx >= 0 && oldIdx > idx) {
-			this.chunks.splice(oldIdx, 1);
-			this.chunks.splice(idx, 0, chunk);
-		} else if (oldIdx < 0) {
-			this.chunks.splice(idx, 0, chunk);
-			return true;
-		}
-		return false;
-	}
+    Stream.call(this);
 
-	/**
-	 * add a chunk into ChunkGroup. Is pushed on or prepended
-	 * @param {Chunk} chunk chunk being pushed into ChunkGroupS
-	 * @returns {boolean} returns true if chunk addition was successful.
-	 */
-	pushChunk(chunk) {
-		const oldIdx = this.chunks.indexOf(chunk);
-		if (oldIdx >= 0) {
-			return false;
-		}
-		this.chunks.push(chunk);
-		return true;
-	}
+    this.path = path;
+    this.fd = null;
+    this.writable = true;
 
-	/**
-	 * @param {Chunk} oldChunk chunk to be replaced
-	 * @param {Chunk} newChunk New chunk that will be replaced with
-	 * @returns {boolean} returns true if the replacement was successful
-	 */
-	replaceChunk(oldChunk, newChunk) {
-		const oldIdx = this.chunks.indexOf(oldChunk);
-		if (oldIdx < 0) return false;
-		const newIdx = this.chunks.indexOf(newChunk);
-		if (newIdx < 0) {
-			this.chunks[oldIdx] = newChunk;
-			return true;
-		}
-		if (newIdx < oldIdx) {
-			this.chunks.splice(oldIdx, 1);
-			return true;
-		} else if (newIdx !== oldIdx) {
-			this.chunks[oldIdx] = newChunk;
-			this.chunks.splice(newIdx, 1);
-			return true;
-		}
-	}
+    this.flags = 'w';
+    this.encoding = 'binary';
+    this.mode = 438; /*=0666*/
+    this.bytesWritten = 0;
 
-	/**
-	 * @param {Chunk} chunk chunk to remove
-	 * @returns {boolean} returns true if chunk was removed
-	 */
-	removeChunk(chunk) {
-		const idx = this.chunks.indexOf(chunk);
-		if (idx >= 0) {
-			this.chunks.splice(idx, 1);
-			return true;
-		}
-		return false;
-	}
+    options = options || {};
 
-	/**
-	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
-	 */
-	isInitial() {
-		return false;
-	}
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
 
-	/**
-	 * @param {ChunkGroup} group chunk group to add
-	 * @returns {boolean} returns true if chunk group was added
-	 */
-	addChild(group) {
-		const size = this._children.size;
-		this._children.add(group);
-		return size !== this._children.size;
-	}
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.start < 0) {
+        throw new Error('start must be >= zero');
+      }
 
-	/**
-	 * @returns {ChunkGroup[]} returns the children of this group
-	 */
-	getChildren() {
-		return this._children.getFromCache(getArray);
-	}
+      this.pos = this.start;
+    }
 
-	getNumberOfChildren() {
-		return this._children.size;
-	}
+    this.busy = false;
+    this._queue = [];
 
-	get childrenIterable() {
-		return this._children;
-	}
+    if (this.fd === null) {
+      this._open = fs.open;
+      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+      this.flush();
+    }
+  }
+}
 
-	/**
-	 * @param {ChunkGroup} group the chunk group to remove
-	 * @returns {boolean} returns true if the chunk group was removed
-	 */
-	removeChild(group) {
-		if (!this._children.has(group)) {
-			return false;
-		}
 
-		this._children.delete(group);
-		group.removeParent(this);
-		return true;
-	}
+/***/ }),
 
-	/**
-	 * @param {ChunkGroup} parentChunk the parent group to be added into
-	 * @returns {boolean} returns true if this chunk group was added to the parent group
-	 */
-	addParent(parentChunk) {
-		if (!this._parents.has(parentChunk)) {
-			this._parents.add(parentChunk);
-			return true;
-		}
-		return false;
-	}
+/***/ 11290:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @returns {ChunkGroup[]} returns the parents of this group
-	 */
-	getParents() {
-		return this._parents.getFromCache(getArray);
-	}
+var constants = __webpack_require__(22057)
 
-	getNumberOfParents() {
-		return this._parents.size;
-	}
+var origCwd = process.cwd
+var cwd = null
 
-	/**
-	 * @param {ChunkGroup} parent the parent group
-	 * @returns {boolean} returns true if the parent group contains this group
-	 */
-	hasParent(parent) {
-		return this._parents.has(parent);
-	}
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
 
-	get parentsIterable() {
-		return this._parents;
-	}
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+try {
+  process.cwd()
+} catch (er) {}
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the parent group
-	 * @returns {boolean} returns true if this group has been removed from the parent
-	 */
-	removeParent(chunkGroup) {
-		if (this._parents.delete(chunkGroup)) {
-			chunkGroup.removeChild(this);
-			return true;
-		}
-		return false;
-	}
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir
+  process.chdir = function (d) {
+    cwd = null
+    chdir.call(process, d)
+  }
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
+}
 
-	/**
-	 * @param {Entrypoint} entrypoint entrypoint to add
-	 * @returns {boolean} returns true if entrypoint was added
-	 */
-	addAsyncEntrypoint(entrypoint) {
-		const size = this._asyncEntrypoints.size;
-		this._asyncEntrypoints.add(entrypoint);
-		return size !== this._asyncEntrypoints.size;
-	}
+module.exports = patch
 
-	get asyncEntrypointsIterable() {
-		return this._asyncEntrypoints;
-	}
+function patch (fs) {
+  // (re-)implement some things that are known busted or missing.
 
-	/**
-	 * @returns {Array} an array containing the blocks
-	 */
-	getBlocks() {
-		return this._blocks.getFromCache(getArray);
-	}
+  // lchmod, broken prior to 0.6.2
+  // back-port the fix here.
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    patchLchmod(fs)
+  }
 
-	getNumberOfBlocks() {
-		return this._blocks.size;
-	}
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs)
+  }
 
-	hasBlock(block) {
-		return this._blocks.has(block);
-	}
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
 
-	/**
-	 * @returns {Iterable<AsyncDependenciesBlock>} blocks
-	 */
-	get blocksIterable() {
-		return this._blocks;
-	}
+  fs.chown = chownFix(fs.chown)
+  fs.fchown = chownFix(fs.fchown)
+  fs.lchown = chownFix(fs.lchown)
 
-	/**
-	 * @param {AsyncDependenciesBlock} block a block
-	 * @returns {boolean} false, if block was already added
-	 */
-	addBlock(block) {
-		if (!this._blocks.has(block)) {
-			this._blocks.add(block);
-			return true;
-		}
-		return false;
-	}
+  fs.chmod = chmodFix(fs.chmod)
+  fs.fchmod = chmodFix(fs.fchmod)
+  fs.lchmod = chmodFix(fs.lchmod)
 
-	/**
-	 * @param {Module} module origin module
-	 * @param {DependencyLocation} loc location of the reference in the origin module
-	 * @param {string} request request name of the reference
-	 * @returns {void}
-	 */
-	addOrigin(module, loc, request) {
-		this.origins.push({
-			module,
-			loc,
-			request
-		});
-	}
+  fs.chownSync = chownFixSync(fs.chownSync)
+  fs.fchownSync = chownFixSync(fs.fchownSync)
+  fs.lchownSync = chownFixSync(fs.lchownSync)
 
-	/**
-	 * @returns {string[]} the files contained this chunk group
-	 */
-	getFiles() {
-		const files = new Set();
+  fs.chmodSync = chmodFixSync(fs.chmodSync)
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
 
-		for (const chunk of this.chunks) {
-			for (const file of chunk.files) {
-				files.add(file);
-			}
-		}
+  fs.stat = statFix(fs.stat)
+  fs.fstat = statFix(fs.fstat)
+  fs.lstat = statFix(fs.lstat)
 
-		return Array.from(files);
-	}
+  fs.statSync = statFixSync(fs.statSync)
+  fs.fstatSync = statFixSync(fs.fstatSync)
+  fs.lstatSync = statFixSync(fs.lstatSync)
 
-	/**
-	 * @returns {void}
-	 */
-	remove() {
-		// cleanup parents
-		for (const parentChunkGroup of this._parents) {
-			// remove this chunk from its parents
-			parentChunkGroup._children.delete(this);
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (!fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchmodSync = function () {}
+  }
+  if (!fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchownSync = function () {}
+  }
 
-			// cleanup "sub chunks"
-			for (const chunkGroup of this._children) {
-				/**
-				 * remove this chunk as "intermediary" and connect
-				 * it "sub chunks" and parents directly
-				 */
-				// add parent to each "sub chunk"
-				chunkGroup.addParent(parentChunkGroup);
-				// add "sub chunk" to parent
-				parentChunkGroup.addChild(chunkGroup);
-			}
-		}
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
 
-		/**
-		 * we need to iterate again over the children
-		 * to remove this from the child's parents.
-		 * This can not be done in the above loop
-		 * as it is not guaranteed that `this._parents` contains anything.
-		 */
-		for (const chunkGroup of this._children) {
-			// remove this as parent of every "sub chunk"
-			chunkGroup._parents.delete(this);
-		}
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = (function (fs$rename) { return function (from, to, cb) {
+      var start = Date.now()
+      var backoff = 0;
+      fs$rename(from, to, function CB (er) {
+        if (er
+            && (er.code === "EACCES" || er.code === "EPERM")
+            && Date.now() - start < 60000) {
+          setTimeout(function() {
+            fs.stat(to, function (stater, st) {
+              if (stater && stater.code === "ENOENT")
+                fs$rename(from, to, CB);
+              else
+                cb(er)
+            })
+          }, backoff)
+          if (backoff < 100)
+            backoff += 10;
+          return;
+        }
+        if (cb) cb(er)
+      })
+    }})(fs.rename)
+  }
 
-		// remove chunks
-		for (const chunk of this.chunks) {
-			chunk.removeGroup(this);
-		}
-	}
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments)
+        }
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+    }
 
-	sortItems() {
-		this.origins.sort(sortOrigin);
-	}
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
+    return read
+  })(fs.read)
 
-	/**
-	 * Sorting predicate which allows current ChunkGroup to be compared against another.
-	 * Sorting values are based off of number of chunks in ChunkGroup.
-	 *
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
-	 * @returns {-1|0|1} sort position for comparison
-	 */
-	compareTo(chunkGraph, otherGroup) {
-		if (this.chunks.length > otherGroup.chunks.length) return -1;
-		if (this.chunks.length < otherGroup.chunks.length) return 1;
-		return compareIterables(compareChunks(chunkGraph))(
-			this.chunks,
-			otherGroup.chunks
-		);
-	}
+  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++
+          continue
+        }
+        throw er
+      }
+    }
+  }})(fs.readSync)
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {Record<string, ChunkGroup[]>} mapping from children type to ordered list of ChunkGroups
-	 */
-	getChildrenByOrders(moduleGraph, chunkGraph) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
-		const lists = new Map();
-		for (const childGroup of this._children) {
-			for (const key of Object.keys(childGroup.options)) {
-				if (key.endsWith("Order")) {
-					const name = key.substr(0, key.length - "Order".length);
-					let list = lists.get(name);
-					if (list === undefined) {
-						lists.set(name, (list = []));
-					}
-					list.push({
-						order: childGroup.options[key],
-						group: childGroup
-					});
-				}
-			}
-		}
-		/** @type {Record<string, ChunkGroup[]>} */
-		const result = Object.create(null);
-		for (const [name, list] of lists) {
-			list.sort((a, b) => {
-				const cmp = b.order - a.order;
-				if (cmp !== 0) return cmp;
-				return a.group.compareTo(chunkGraph, b.group);
-			});
-			result[name] = list.map(i => i.group);
-		}
-		return result;
-	}
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err)
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2)
+          })
+        })
+      })
+    }
 
-	/**
-	 * Sets the top-down index of a module in this ChunkGroup
-	 * @param {Module} module module for which the index should be set
-	 * @param {number} index the index of the module
-	 * @returns {void}
-	 */
-	setModulePreOrderIndex(module, index) {
-		this._modulePreOrderIndices.set(module, index);
-	}
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
 
-	/**
-	 * Gets the top-down index of a module in this ChunkGroup
-	 * @param {Module} module the module
-	 * @returns {number} index
-	 */
-	getModulePreOrderIndex(module) {
-		return this._modulePreOrderIndices.get(module);
-	}
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true
+      var ret
+      try {
+        ret = fs.fchmodSync(fd, mode)
+        threw = false
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd)
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd)
+        }
+      }
+      return ret
+    }
+  }
 
-	/**
-	 * Sets the bottom-up index of a module in this ChunkGroup
-	 * @param {Module} module module for which the index should be set
-	 * @param {number} index the index of the module
-	 * @returns {void}
-	 */
-	setModulePostOrderIndex(module, index) {
-		this._modulePostOrderIndices.set(module, index);
-	}
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK")) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er)
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2)
+            })
+          })
+        })
+      }
 
-	/**
-	 * Gets the bottom-up index of a module in this ChunkGroup
-	 * @param {Module} module the module
-	 * @returns {number} index
-	 */
-	getModulePostOrderIndex(module) {
-		return this._modulePostOrderIndices.get(module);
-	}
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK)
+        var ret
+        var threw = true
+        try {
+          ret = fs.futimesSync(fd, at, mt)
+          threw = false
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd)
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd)
+          }
+        }
+        return ret
+      }
 
-	/* istanbul ignore next */
-	checkConstraints() {
-		const chunk = this;
-		for (const child of chunk._children) {
-			if (!child._parents.has(chunk)) {
-				throw new Error(
-					`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`
-				);
-			}
-		}
-		for (const parentChunk of chunk._parents) {
-			if (!parentChunk._children.has(chunk)) {
-				throw new Error(
-					`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`
-				);
-			}
-		}
-	}
-}
+    } else {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+      fs.lutimesSync = function () {}
+    }
+  }
 
-ChunkGroup.prototype.getModuleIndex = util.deprecate(
-	ChunkGroup.prototype.getModulePreOrderIndex,
-	"ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex",
-	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX"
-);
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
 
-ChunkGroup.prototype.getModuleIndex2 = util.deprecate(
-	ChunkGroup.prototype.getModulePostOrderIndex,
-	"ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex",
-	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2"
-);
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
 
-module.exports = ChunkGroup;
+
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options
+        options = null
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000
+          if (stats.gid < 0) stats.gid += 0x100000000
+        }
+        if (cb) cb.apply(this, arguments)
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
+  }
+
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target)
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000
+        if (stats.gid < 0) stats.gid += 0x100000000
+      }
+      return stats;
+    }
+  }
+
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
+    var nonroot = !process.getuid || process.getuid() !== 0
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
+
+    return false
+  }
+}
 
 
 /***/ }),
 
-/***/ 918:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 15235:
+/***/ (function(module) {
 
 "use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
 
+module.exports = parseJson
+function parseJson (txt, reviver, context) {
+  context = context || 20
+  try {
+    return JSON.parse(txt, reviver)
+  } catch (e) {
+    if (typeof txt !== 'string') {
+      const isEmptyArray = Array.isArray(txt) && txt.length === 0
+      const errorMessage = 'Cannot parse ' +
+      (isEmptyArray ? 'an empty array' : String(txt))
+      throw new TypeError(errorMessage)
+    }
+    const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
+    const errIdx = syntaxErr
+    ? +syntaxErr[1]
+    : e.message.match(/^Unexpected end of JSON.*/i)
+    ? txt.length - 1
+    : null
+    if (errIdx != null) {
+      const start = errIdx <= context
+      ? 0
+      : errIdx - context
+      const end = errIdx + context >= txt.length
+      ? txt.length
+      : errIdx + context
+      e.message += ` while parsing near '${
+        start === 0 ? '' : '...'
+      }${txt.slice(start, end)}${
+        end === txt.length ? '' : '...'
+      }'`
+    } else {
+      e.message += ` while parsing '${txt.slice(0, context * 2)}'`
+    }
+    throw e
+  }
+}
 
-const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("./Chunk")} Chunk */
+/***/ }),
 
-class ChunkRenderError extends WebpackError {
-	/**
-	 * Create a new ChunkRenderError
-	 * @param {Chunk} chunk A chunk
-	 * @param {string} file Related file
-	 * @param {Error} error Original error
-	 */
-	constructor(chunk, file, error) {
-		super();
+/***/ 49448:
+/***/ (function(module) {
 
-		this.name = "ChunkRenderError";
-		this.error = error;
-		this.message = error.message;
-		this.details = error.stack;
-		this.file = file;
-		this.chunk = chunk;
+"use strict";
+
+
+class LoadingLoaderError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LoaderRunnerError";
+		Error.captureStackTrace(this, this.constructor);
 	}
 }
 
-module.exports = ChunkRenderError;
+module.exports = LoadingLoaderError;
 
 
 /***/ }),
 
-/***/ 46341:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 68318:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
+var fs = __webpack_require__(57147);
+var readFile = fs.readFile.bind(fs);
+var loadLoader = __webpack_require__(55102);
 
+function utf8BufferToString(buf) {
+	var str = buf.toString("utf-8");
+	if(str.charCodeAt(0) === 0xFEFF) {
+		return str.substr(1);
+	} else {
+		return str;
+	}
+}
 
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
-const util = __webpack_require__(73837);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("./Compilation")} Compilation */
+/**
+ * @param {string} str the path with query and fragment
+ * @returns {{ path: string, query: string, fragment: string }} parsed parts
+ */
+function parsePathQueryFragment(str) {
+	var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+	return {
+		path: match[1].replace(/\0(.)/g, "$1"),
+		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		fragment: match[3] || ""
+	};
+}
 
-const getJavascriptModulesPlugin = memoize(() =>
-	__webpack_require__(89464)
-);
+function dirname(path) {
+	if(path === "/") return "/";
+	var i = path.lastIndexOf("/");
+	var j = path.lastIndexOf("\\");
+	var i2 = path.indexOf("/");
+	var j2 = path.indexOf("\\");
+	var idx = i > j ? i : j;
+	var idx2 = i > j ? i2 : j2;
+	if(idx < 0) return path;
+	if(idx === idx2) return path.substr(0, idx + 1);
+	return path.substr(0, idx);
+}
 
-// TODO webpack 6 remove this class
-class ChunkTemplate {
-	/**
-	 * @param {OutputOptions} outputOptions output options
-	 * @param {Compilation} compilation the compilation
-	 */
-	constructor(outputOptions, compilation) {
-		this._outputOptions = outputOptions || {};
-		this.hooks = Object.freeze({
-			renderManifest: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.renderManifest.tap(
-							options,
-							(entries, options) => {
-								if (options.chunk.hasRuntime()) return entries;
-								return fn(entries, options);
-							}
-						);
-					},
-					"ChunkTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_MANIFEST"
-				)
-			},
-			modules: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderChunk.tap(options, (source, renderContext) =>
-								fn(
-									source,
-									compilation.moduleTemplates.javascript,
-									renderContext
-								)
-							);
-					},
-					"ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_MODULES"
-				)
-			},
-			render: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderChunk.tap(options, (source, renderContext) =>
-								fn(
-									source,
-									compilation.moduleTemplates.javascript,
-									renderContext
-								)
-							);
-					},
-					"ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER"
-				)
-			},
-			renderWithEntry: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
-								if (
-									renderContext.chunkGraph.getNumberOfEntryModules(
-										renderContext.chunk
-									) === 0 ||
-									renderContext.chunk.hasRuntime()
-								) {
-									return source;
-								}
-								return fn(source, renderContext.chunk);
-							});
-					},
-					"ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY"
-				)
-			},
-			hash: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.fullHash.tap(options, fn);
-					},
-					"ChunkTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH"
-				)
-			},
-			hashForChunk: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.chunkHash.tap(options, (chunk, hash, context) => {
-								if (chunk.hasRuntime()) return;
-								fn(hash, chunk, context);
-							});
-					},
-					"ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK"
-				)
+function createLoaderObject(loader) {
+	var obj = {
+		path: null,
+		query: null,
+		fragment: null,
+		options: null,
+		ident: null,
+		normal: null,
+		pitch: null,
+		raw: null,
+		data: null,
+		pitchExecuted: false,
+		normalExecuted: false
+	};
+	Object.defineProperty(obj, "request", {
+		enumerable: true,
+		get: function() {
+			return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
+		},
+		set: function(value) {
+			if(typeof value === "string") {
+				var splittedRequest = parsePathQueryFragment(value);
+				obj.path = splittedRequest.path;
+				obj.query = splittedRequest.query;
+				obj.fragment = splittedRequest.fragment;
+				obj.options = undefined;
+				obj.ident = undefined;
+			} else {
+				if(!value.loader)
+					throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
+				obj.path = value.loader;
+				obj.fragment = value.fragment || "";
+				obj.type = value.type;
+				obj.options = value.options;
+				obj.ident = value.ident;
+				if(obj.options === null)
+					obj.query = "";
+				else if(obj.options === undefined)
+					obj.query = "";
+				else if(typeof obj.options === "string")
+					obj.query = "?" + obj.options;
+				else if(obj.ident)
+					obj.query = "??" + obj.ident;
+				else if(typeof obj.options === "object" && obj.options.ident)
+					obj.query = "??" + obj.options.ident;
+				else
+					obj.query = "?" + JSON.stringify(obj.options);
 			}
-		});
+		}
+	});
+	obj.request = loader;
+	if(Object.preventExtensions) {
+		Object.preventExtensions(obj);
 	}
+	return obj;
 }
 
-Object.defineProperty(ChunkTemplate.prototype, "outputOptions", {
-	get: util.deprecate(
-		/**
-		 * @this {ChunkTemplate}
-		 * @returns {OutputOptions} output options
-		 */
-		function () {
-			return this._outputOptions;
-		},
-		"ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
-		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
-	)
-});
+function runSyncOrAsync(fn, context, args, callback) {
+	var isSync = true;
+	var isDone = false;
+	var isError = false; // internal error
+	var reportedError = false;
+	context.async = function async() {
+		if(isDone) {
+			if(reportedError) return; // ignore
+			throw new Error("async(): The callback was already called.");
+		}
+		isSync = false;
+		return innerCallback;
+	};
+	var innerCallback = context.callback = function() {
+		if(isDone) {
+			if(reportedError) return; // ignore
+			throw new Error("callback(): The callback was already called.");
+		}
+		isDone = true;
+		isSync = false;
+		try {
+			callback.apply(null, arguments);
+		} catch(e) {
+			isError = true;
+			throw e;
+		}
+	};
+	try {
+		var result = (function LOADER_EXECUTION() {
+			return fn.apply(context, args);
+		}());
+		if(isSync) {
+			isDone = true;
+			if(result === undefined)
+				return callback();
+			if(result && typeof result === "object" && typeof result.then === "function") {
+				return result.then(function(r) {
+					callback(null, r);
+				}, callback);
+			}
+			return callback(null, result);
+		}
+	} catch(e) {
+		if(isError) throw e;
+		if(isDone) {
+			// loader is already "done", so we cannot use the callback function
+			// for better debugging we print the error on the console
+			if(typeof e === "object" && e.stack) console.error(e.stack);
+			else console.error(e);
+			return;
+		}
+		isDone = true;
+		reportedError = true;
+		callback(e);
+	}
 
-module.exports = ChunkTemplate;
+}
 
+function convertArgs(args, raw) {
+	if(!raw && Buffer.isBuffer(args[0]))
+		args[0] = utf8BufferToString(args[0]);
+	else if(raw && typeof args[0] === "string")
+		args[0] = Buffer.from(args[0], "utf-8");
+}
 
-/***/ }),
+function iteratePitchingLoaders(options, loaderContext, callback) {
+	// abort after last loader
+	if(loaderContext.loaderIndex >= loaderContext.loaders.length)
+		return processResource(options, loaderContext, callback);
 
-/***/ 31085:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
+	// iterate
+	if(currentLoaderObject.pitchExecuted) {
+		loaderContext.loaderIndex++;
+		return iteratePitchingLoaders(options, loaderContext, callback);
+	}
 
+	// load loader module
+	loadLoader(currentLoaderObject, function(err) {
+		if(err) {
+			loaderContext.cacheable(false);
+			return callback(err);
+		}
+		var fn = currentLoaderObject.pitch;
+		currentLoaderObject.pitchExecuted = true;
+		if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
 
+		runSyncOrAsync(
+			fn,
+			loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
+			function(err) {
+				if(err) return callback(err);
+				var args = Array.prototype.slice.call(arguments, 1);
+				// Determine whether to continue the pitching process based on
+				// argument values (as opposed to argument presence) in order
+				// to support synchronous and asynchronous usages.
+				var hasArg = args.some(function(value) {
+					return value !== undefined;
+				});
+				if(hasArg) {
+					loaderContext.loaderIndex--;
+					iterateNormalLoaders(options, loaderContext, args, callback);
+				} else {
+					iteratePitchingLoaders(options, loaderContext, callback);
+				}
+			}
+		);
+	});
+}
 
-const asyncLib = __webpack_require__(78175);
-const { SyncBailHook } = __webpack_require__(6967);
-const Compilation = __webpack_require__(85720);
-const createSchemaValidation = __webpack_require__(32540);
-const { join } = __webpack_require__(17139);
-const processAsyncTree = __webpack_require__(42791);
+function processResource(options, loaderContext, callback) {
+	// set loader index to last loader
+	loaderContext.loaderIndex = loaderContext.loaders.length - 1;
 
-/** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").StatsCallback} StatsCallback */
+	var resourcePath = loaderContext.resourcePath;
+	if(resourcePath) {
+		options.processResource(loaderContext, resourcePath, function(err, buffer) {
+			if(err) return callback(err);
+			options.resourceBuffer = buffer;
+			iterateNormalLoaders(options, loaderContext, [buffer], callback);
+		});
+	} else {
+		iterateNormalLoaders(options, loaderContext, [null], callback);
+	}
+}
 
-/** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
-/** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
+function iterateNormalLoaders(options, loaderContext, args, callback) {
+	if(loaderContext.loaderIndex < 0)
+		return callback(null, args);
 
-/**
- * @typedef {Object} CleanPluginCompilationHooks
- * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
- */
+	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
 
-const validate = createSchemaValidation(
-	undefined,
-	() => {
-		const { definitions } = __webpack_require__(73342);
-		return {
-			definitions,
-			oneOf: [{ $ref: "#/definitions/CleanOptions" }]
-		};
-	},
-	{
-		name: "Clean Plugin",
-		baseDataPath: "options"
+	// iterate
+	if(currentLoaderObject.normalExecuted) {
+		loaderContext.loaderIndex--;
+		return iterateNormalLoaders(options, loaderContext, args, callback);
 	}
-);
 
-/**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} outputPath output path
- * @param {Set<string>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
- * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
- * @returns {void}
- */
-const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
-	const directories = new Set();
-	// get directories of assets
-	for (const asset of currentAssets) {
-		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
-	}
-	// and all parent directories
-	for (const directory of directories) {
-		directories.add(directory.replace(/(^|\/)[^/]*$/, ""));
+	var fn = currentLoaderObject.normal;
+	currentLoaderObject.normalExecuted = true;
+	if(!fn) {
+		return iterateNormalLoaders(options, loaderContext, args, callback);
 	}
-	const diff = new Set();
-	asyncLib.forEachLimit(
-		directories,
-		10,
-		(directory, callback) => {
-			fs.readdir(join(fs, outputPath, directory), (err, entries) => {
-				if (err) {
-					if (err.code === "ENOENT") return callback();
-					if (err.code === "ENOTDIR") {
-						diff.add(directory);
-						return callback();
-					}
-					return callback(err);
-				}
-				for (const entry of entries) {
-					const file = /** @type {string} */ (entry);
-					const filename = directory ? `${directory}/${file}` : file;
-					if (!directories.has(filename) && !currentAssets.has(filename)) {
-						diff.add(filename);
-					}
-				}
-				callback();
-			});
-		},
-		err => {
-			if (err) return callback(err);
 
-			callback(null, diff);
-		}
-	);
-};
+	convertArgs(args, currentLoaderObject.raw);
 
-/**
- * @param {Set<string>} currentAssets assets list
- * @param {Set<string>} oldAssets old assets list
- * @returns {Set<string>} diff
- */
-const getDiffToOldAssets = (currentAssets, oldAssets) => {
-	const diff = new Set();
-	for (const asset of oldAssets) {
-		if (!currentAssets.has(asset)) diff.add(asset);
-	}
-	return diff;
-};
+	runSyncOrAsync(fn, loaderContext, args, function(err) {
+		if(err) return callback(err);
 
-/**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} filename path to file
- * @param {StatsCallback} callback callback for provided filename
- * @returns {void}
- */
-const doStat = (fs, filename, callback) => {
-	if ("lstat" in fs) {
-		fs.lstat(filename, callback);
-	} else {
-		fs.stat(filename, callback);
-	}
+		var args = Array.prototype.slice.call(arguments, 1);
+		iterateNormalLoaders(options, loaderContext, args, callback);
+	});
+}
+
+exports.getContext = function getContext(resource) {
+	var path = parsePathQueryFragment(resource).path;
+	return dirname(path);
 };
 
-/**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} outputPath output path
- * @param {boolean} dry only log instead of fs modification
- * @param {Logger} logger logger
- * @param {Set<string>} diff filenames of the assets that shouldn't be there
- * @param {function(string): boolean} isKept check if the entry is ignored
- * @param {function(Error=): void} callback callback
- * @returns {void}
- */
-const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
-	const log = msg => {
-		if (dry) {
-			logger.info(msg);
-		} else {
-			logger.log(msg);
+exports.runLoaders = function runLoaders(options, callback) {
+	// read options
+	var resource = options.resource || "";
+	var loaders = options.loaders || [];
+	var loaderContext = options.context || {};
+	var processResource = options.processResource || ((readResource, context, resource, callback) => {
+		context.addDependency(resource);
+		readResource(resource, callback);
+	}).bind(null, options.readResource || readFile);
+
+	//
+	var splittedResource = resource && parsePathQueryFragment(resource);
+	var resourcePath = splittedResource ? splittedResource.path : undefined;
+	var resourceQuery = splittedResource ? splittedResource.query : undefined;
+	var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+	var contextDirectory = resourcePath ? dirname(resourcePath) : null;
+
+	// execution state
+	var requestCacheable = true;
+	var fileDependencies = [];
+	var contextDependencies = [];
+	var missingDependencies = [];
+
+	// prepare loader objects
+	loaders = loaders.map(createLoaderObject);
+
+	loaderContext.context = contextDirectory;
+	loaderContext.loaderIndex = 0;
+	loaderContext.loaders = loaders;
+	loaderContext.resourcePath = resourcePath;
+	loaderContext.resourceQuery = resourceQuery;
+	loaderContext.resourceFragment = resourceFragment;
+	loaderContext.async = null;
+	loaderContext.callback = null;
+	loaderContext.cacheable = function cacheable(flag) {
+		if(flag === false) {
+			requestCacheable = false;
 		}
 	};
-	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
-	/** @type {Job[]} */
-	const jobs = Array.from(diff, filename => ({
-		type: "check",
-		filename,
-		parent: undefined
-	}));
-	processAsyncTree(
-		jobs,
-		10,
-		({ type, filename, parent }, push, callback) => {
-			const handleError = err => {
-				if (err.code === "ENOENT") {
-					log(`${filename} was removed during cleaning by something else`);
-					handleParent();
-					return callback();
-				}
-				return callback(err);
-			};
-			const handleParent = () => {
-				if (parent && --parent.remaining === 0) push(parent.job);
-			};
-			const path = join(fs, outputPath, filename);
-			switch (type) {
-				case "check":
-					if (isKept(filename)) {
-						// do not decrement parent entry as we don't want to delete the parent
-						log(`${filename} will be kept`);
-						return process.nextTick(callback);
-					}
-					doStat(fs, path, (err, stats) => {
-						if (err) return handleError(err);
-						if (!stats.isDirectory()) {
-							push({
-								type: "unlink",
-								filename,
-								parent
-							});
-							return callback();
-						}
-						fs.readdir(path, (err, entries) => {
-							if (err) return handleError(err);
-							/** @type {Job} */
-							const deleteJob = {
-								type: "rmdir",
-								filename,
-								parent
-							};
-							if (entries.length === 0) {
-								push(deleteJob);
-							} else {
-								const parentToken = {
-									remaining: entries.length,
-									job: deleteJob
-								};
-								for (const entry of entries) {
-									const file = /** @type {string} */ (entry);
-									if (file.startsWith(".")) {
-										log(
-											`${filename} will be kept (dot-files will never be removed)`
-										);
-										continue;
-									}
-									push({
-										type: "check",
-										filename: `${filename}/${file}`,
-										parent: parentToken
-									});
-								}
-							}
-							return callback();
-						});
-					});
-					break;
-				case "rmdir":
-					log(`${filename} will be removed`);
-					if (dry) {
-						handleParent();
-						return process.nextTick(callback);
-					}
-					if (!fs.rmdir) {
-						logger.warn(
-							`${filename} can't be removed because output file system doesn't support removing directories (rmdir)`
-						);
-						return process.nextTick(callback);
-					}
-					fs.rmdir(path, err => {
-						if (err) return handleError(err);
-						handleParent();
-						callback();
-					});
-					break;
-				case "unlink":
-					log(`${filename} will be removed`);
-					if (dry) {
-						handleParent();
-						return process.nextTick(callback);
-					}
-					if (!fs.unlink) {
-						logger.warn(
-							`${filename} can't be removed because output file system doesn't support removing files (rmdir)`
-						);
-						return process.nextTick(callback);
-					}
-					fs.unlink(path, err => {
-						if (err) return handleError(err);
-						handleParent();
-						callback();
-					});
-					break;
-			}
+	loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
+		fileDependencies.push(file);
+	};
+	loaderContext.addContextDependency = function addContextDependency(context) {
+		contextDependencies.push(context);
+	};
+	loaderContext.addMissingDependency = function addMissingDependency(context) {
+		missingDependencies.push(context);
+	};
+	loaderContext.getDependencies = function getDependencies() {
+		return fileDependencies.slice();
+	};
+	loaderContext.getContextDependencies = function getContextDependencies() {
+		return contextDependencies.slice();
+	};
+	loaderContext.getMissingDependencies = function getMissingDependencies() {
+		return missingDependencies.slice();
+	};
+	loaderContext.clearDependencies = function clearDependencies() {
+		fileDependencies.length = 0;
+		contextDependencies.length = 0;
+		missingDependencies.length = 0;
+		requestCacheable = true;
+	};
+	Object.defineProperty(loaderContext, "resource", {
+		enumerable: true,
+		get: function() {
+			if(loaderContext.resourcePath === undefined)
+				return undefined;
+			return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
 		},
-		callback
-	);
-};
-
-/** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class CleanPlugin {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CleanPluginCompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
+		set: function(value) {
+			var splittedResource = value && parsePathQueryFragment(value);
+			loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
+			loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
+			loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
 		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				/** @type {SyncBailHook<[string], boolean>} */
-				keep: new SyncBailHook(["ignore"])
-			};
-			compilationHooksMap.set(compilation, hooks);
+	});
+	Object.defineProperty(loaderContext, "request", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
 		}
-		return hooks;
-	}
+	});
+	Object.defineProperty(loaderContext, "remainingRequest", {
+		enumerable: true,
+		get: function() {
+			if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
+				return "";
+			return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "currentRequest", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "previousRequest", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
+				return o.request;
+			}).join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "query", {
+		enumerable: true,
+		get: function() {
+			var entry = loaderContext.loaders[loaderContext.loaderIndex];
+			return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
+		}
+	});
+	Object.defineProperty(loaderContext, "data", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders[loaderContext.loaderIndex].data;
+		}
+	});
 
-	/** @param {CleanOptions} options options */
-	constructor(options = {}) {
-		validate(options);
-		this.options = { dry: false, ...options };
+	// finish loader context
+	if(Object.preventExtensions) {
+		Object.preventExtensions(loaderContext);
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { dry, keep } = this.options;
-
-		const keepFn =
-			typeof keep === "function"
-				? keep
-				: typeof keep === "string"
-				? path => path.startsWith(keep)
-				: typeof keep === "object" && keep.test
-				? path => keep.test(path)
-				: () => false;
-
-		// We assume that no external modification happens while the compiler is active
-		// So we can store the old assets and only diff to them to avoid fs access on
-		// incremental builds
-		let oldAssets;
-
-		compiler.hooks.emit.tapAsync(
-			{
-				name: "CleanPlugin",
-				stage: 100
-			},
-			(compilation, callback) => {
-				const hooks = CleanPlugin.getCompilationHooks(compilation);
-				const logger = compilation.getLogger("webpack.CleanPlugin");
-				const fs = compiler.outputFileSystem;
-
-				if (!fs.readdir) {
-					return callback(
-						new Error(
-							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
-						)
-					);
-				}
+	var processOptions = {
+		resourceBuffer: null,
+		processResource: processResource
+	};
+	iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
+		if(err) {
+			return callback(err, {
+				cacheable: requestCacheable,
+				fileDependencies: fileDependencies,
+				contextDependencies: contextDependencies,
+				missingDependencies: missingDependencies
+			});
+		}
+		callback(null, {
+			result: result,
+			resourceBuffer: processOptions.resourceBuffer,
+			cacheable: requestCacheable,
+			fileDependencies: fileDependencies,
+			contextDependencies: contextDependencies,
+			missingDependencies: missingDependencies
+		});
+	});
+};
 
-				const currentAssets = new Set();
-				for (const asset of Object.keys(compilation.assets)) {
-					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
-					let normalizedAsset;
-					let newNormalizedAsset = asset.replace(/\\/g, "/");
-					do {
-						normalizedAsset = newNormalizedAsset;
-						newNormalizedAsset = normalizedAsset.replace(
-							/(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
-							"$1"
-						);
-					} while (newNormalizedAsset !== normalizedAsset);
-					if (normalizedAsset.startsWith("../")) continue;
-					currentAssets.add(normalizedAsset);
-				}
 
-				const outputPath = compilation.getPath(compiler.outputPath, {});
+/***/ }),
 
-				const isKept = path => {
-					const result = hooks.keep.call(path);
-					if (result !== undefined) return result;
-					return keepFn(path);
-				};
+/***/ 55102:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				const diffCallback = (err, diff) => {
-					if (err) {
-						oldAssets = undefined;
-						return callback(err);
-					}
-					applyDiff(fs, outputPath, dry, logger, diff, isKept, err => {
-						if (err) {
-							oldAssets = undefined;
-						} else {
-							oldAssets = currentAssets;
-						}
-						callback(err);
-					});
-				};
+var LoaderLoadingError = __webpack_require__(49448);
+var url;
 
-				if (oldAssets) {
-					diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets));
+module.exports = function loadLoader(loader, callback) {
+	if(loader.type === "module") {
+		try {
+			if(url === undefined) url = __webpack_require__(57310);
+			var loaderUrl = url.pathToFileURL(loader.path);
+			var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
+			modulePromise.then(function(module) {
+				handleResult(loader, module, callback);
+			}, callback);
+			return;
+		} catch(e) {
+			callback(e);
+		}
+	} else {
+		try {
+			var module = require(loader.path);
+		} catch(e) {
+			// it is possible for node to choke on a require if the FD descriptor
+			// limit has been reached. give it a chance to recover.
+			if(e instanceof Error && e.code === "EMFILE") {
+				var retry = loadLoader.bind(null, loader, callback);
+				if(typeof setImmediate === "function") {
+					// node >= 0.9.0
+					return setImmediate(retry);
 				} else {
-					getDiffToFs(fs, outputPath, currentAssets, diffCallback);
+					// node < 0.9.0
+					return process.nextTick(retry);
 				}
 			}
-		);
+			return callback(e);
+		}
+		return handleResult(loader, module, callback);
 	}
-}
+};
 
-module.exports = CleanPlugin;
+function handleResult(loader, module, callback) {
+	if(typeof module !== "function" && typeof module !== "object") {
+		return callback(new LoaderLoadingError(
+			"Module '" + loader.path + "' is not a loader (export function or es6 module)"
+		));
+	}
+	loader.normal = typeof module === "function" ? module : module.default;
+	loader.pitch = module.pitch;
+	loader.raw = module.raw;
+	if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
+		return callback(new LoaderLoadingError(
+			"Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
+		));
+	}
+	callback();
+}
 
 
 /***/ }),
 
-/***/ 2102:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 54983:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+var __webpack_unused_export__;
 
 
+__webpack_unused_export__ = ({
+  value: true
+});
+exports.Z = void 0;
 
-const WebpackError = __webpack_require__(53799);
+const {
+  stringHints,
+  numberHints
+} = __webpack_require__(79926);
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
 
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
 
-class CodeGenerationError extends WebpackError {
-	/**
-	 * Create a new CodeGenerationError
-	 * @param {Module} module related module
-	 * @param {Error} error Original error
-	 */
-	constructor(module, error) {
-		super();
+/** @typedef {import("./validate").Schema} Schema */
 
-		this.name = "CodeGenerationError";
-		this.error = error;
-		this.message = error.message;
-		this.details = error.stack;
-		this.module = module;
-	}
+/** @typedef {import("./validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
+
+/** @typedef {import("./validate").PostFormatter} PostFormatter */
+
+/** @typedef {import("./validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+
+/** @enum {number} */
+
+
+const SPECIFICITY = {
+  type: 1,
+  not: 1,
+  oneOf: 1,
+  anyOf: 1,
+  if: 1,
+  enum: 1,
+  const: 1,
+  instanceof: 1,
+  required: 2,
+  pattern: 2,
+  patternRequired: 2,
+  format: 2,
+  formatMinimum: 2,
+  formatMaximum: 2,
+  minimum: 2,
+  exclusiveMinimum: 2,
+  maximum: 2,
+  exclusiveMaximum: 2,
+  multipleOf: 2,
+  uniqueItems: 2,
+  contains: 2,
+  minLength: 2,
+  maxLength: 2,
+  minItems: 2,
+  maxItems: 2,
+  minProperties: 2,
+  maxProperties: 2,
+  dependencies: 2,
+  propertyNames: 2,
+  additionalItems: 2,
+  additionalProperties: 2,
+  absolutePath: 2
+};
+/**
+ *
+ * @param {Array<SchemaUtilErrorObject>} array
+ * @param {(item: SchemaUtilErrorObject) => number} fn
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+function filterMax(array, fn) {
+  const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
+  return array.filter(item => fn(item) === evaluatedMax);
 }
+/**
+ *
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
 
-module.exports = CodeGenerationError;
 
+function filterChildren(children) {
+  let newChildren = children;
+  newChildren = filterMax(newChildren,
+  /**
+   *
+   * @param {SchemaUtilErrorObject} error
+   * @returns {number}
+   */
+  error => error.dataPath ? error.dataPath.length : 0);
+  newChildren = filterMax(newChildren,
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {number}
+   */
+  error => SPECIFICITY[
+  /** @type {keyof typeof SPECIFICITY} */
+  error.keyword] || 2);
+  return newChildren;
+}
+/**
+ * Find all children errors
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @param {Array<string>} schemaPaths
+ * @return {number} returns index of first child
+ */
 
-/***/ }),
 
-/***/ 71426:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+function findAllChildren(children, schemaPaths) {
+  let i = children.length - 1;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  const predicate =
+  /**
+   * @param {string} schemaPath
+   * @returns {boolean}
+   */
+  schemaPath => children[i].schemaPath.indexOf(schemaPath) !== 0;
 
+  while (i > -1 && !schemaPaths.every(predicate)) {
+    if (children[i].keyword === "anyOf" || children[i].keyword === "oneOf") {
+      const refs = extractRefs(children[i]);
+      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(children[i].schemaPath));
+      i = childrenStart - 1;
+    } else {
+      i -= 1;
+    }
+  }
 
+  return i + 1;
+}
+/**
+ * Extracts all refs from schema
+ * @param {SchemaUtilErrorObject} error
+ * @return {Array<string>}
+ */
 
-const { provide } = __webpack_require__(82482);
-const { first } = __webpack_require__(93347);
-const createHash = __webpack_require__(49835);
-const { runtimeToString, RuntimeSpecMap } = __webpack_require__(17156);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {typeof import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+function extractRefs(error) {
+  const {
+    schema
+  } = error;
 
-class CodeGenerationResults {
-	/**
-	 * @param {string | Hash} hashFunction the hash function to use
-	 */
-	constructor(hashFunction = "md4") {
-		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
-		this.map = new Map();
-		this._hashFunction = hashFunction;
-	}
+  if (!Array.isArray(schema)) {
+    return [];
+  }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {CodeGenerationResult} the CodeGenerationResult
-	 */
-	get(module, runtime) {
-		const entry = this.map.get(module);
-		if (entry === undefined) {
-			throw new Error(
-				`No code generation entry for ${module.identifier()} (existing entries: ${Array.from(
-					this.map.keys(),
-					m => m.identifier()
-				).join(", ")})`
-			);
-		}
-		if (runtime === undefined) {
-			if (entry.size > 1) {
-				const results = new Set(entry.values());
-				if (results.size !== 1) {
-					throw new Error(
-						`No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
-							entry.keys(),
-							r => runtimeToString(r)
-						).join(", ")}).
-Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
-					);
-				}
-				return first(results);
-			}
-			return entry.values().next().value;
-		}
-		const result = entry.get(runtime);
-		if (result === undefined) {
-			throw new Error(
-				`No code generation entry for runtime ${runtimeToString(
-					runtime
-				)} for ${module.identifier()} (existing runtimes: ${Array.from(
-					entry.keys(),
-					r => runtimeToString(r)
-				).join(", ")})`
-			);
-		}
-		return result;
-	}
+  return schema.map(({
+    $ref
+  }) => $ref).filter(s => s);
+}
+/**
+ * Groups children by their first level parent (assuming that error is root)
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @return {Array<SchemaUtilErrorObject>}
+ */
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {boolean} true, when we have data for this
-	 */
-	has(module, runtime) {
-		const entry = this.map.get(module);
-		if (entry === undefined) {
-			return false;
-		}
-		if (runtime !== undefined) {
-			return entry.has(runtime);
-		} else if (entry.size > 1) {
-			const results = new Set(entry.values());
-			return results.size === 1;
-		} else {
-			return entry.size === 1;
-		}
-	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {string} sourceType the source type
-	 * @returns {Source} a source
-	 */
-	getSource(module, runtime, sourceType) {
-		return this.get(module, runtime).sources.get(sourceType);
-	}
+function groupChildrenByFirstChild(children) {
+  const result = [];
+  let i = children.length - 1;
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getRuntimeRequirements(module, runtime) {
-		return this.get(module, runtime).runtimeRequirements;
-	}
+  while (i > 0) {
+    const child = children[i];
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {string} key data key
-	 * @returns {any} data generated by code generation
-	 */
-	getData(module, runtime, key) {
-		const data = this.get(module, runtime).data;
-		return data === undefined ? undefined : data.get(key);
-	}
+    if (child.keyword === "anyOf" || child.keyword === "oneOf") {
+      const refs = extractRefs(child);
+      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(child.schemaPath));
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {any} hash of the code generation
-	 */
-	getHash(module, runtime) {
-		const info = this.get(module, runtime);
-		if (info.hash !== undefined) return info.hash;
-		const hash = createHash(this._hashFunction);
-		for (const [type, source] of info.sources) {
-			hash.update(type);
-			source.updateHash(hash);
-		}
-		if (info.runtimeRequirements) {
-			for (const rr of info.runtimeRequirements) hash.update(rr);
-		}
-		return (info.hash = /** @type {string} */ (hash.digest("hex")));
-	}
+      if (childrenStart !== i) {
+        result.push(Object.assign({}, child, {
+          children: children.slice(childrenStart, i)
+        }));
+        i = childrenStart;
+      } else {
+        result.push(child);
+      }
+    } else {
+      result.push(child);
+    }
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {CodeGenerationResult} result result from module
-	 * @returns {void}
-	 */
-	add(module, runtime, result) {
-		const map = provide(this.map, module, () => new RuntimeSpecMap());
-		map.set(runtime, result);
-	}
+    i -= 1;
+  }
+
+  if (i === 0) {
+    result.push(children[i]);
+  }
+
+  return result.reverse();
 }
+/**
+ * @param {string} str
+ * @param {string} prefix
+ * @returns {string}
+ */
 
-module.exports = CodeGenerationResults;
 
+function indent(str, prefix) {
+  return str.replace(/\n(?!$)/g, `\n${prefix}`);
+}
+/**
+ * @param {Schema} schema
+ * @returns {schema is (Schema & {not: Schema})}
+ */
 
-/***/ }),
 
-/***/ 98427:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+function hasNotInSchema(schema) {
+  return !!schema.not;
+}
+/**
+ * @param {Schema} schema
+ * @return {Schema}
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+function findFirstTypedSchema(schema) {
+  if (hasNotInSchema(schema)) {
+    return findFirstTypedSchema(schema.not);
+  }
 
+  return schema;
+}
+/**
+ * @param {Schema} schema
+ * @return {boolean}
+ */
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+function canApplyNot(schema) {
+  const typedSchema = findFirstTypedSchema(schema);
+  return likeNumber(typedSchema) || likeInteger(typedSchema) || likeString(typedSchema) || likeNull(typedSchema) || likeBoolean(typedSchema);
+}
+/**
+ * @param {any} maybeObj
+ * @returns {boolean}
+ */
 
-class CommentCompilationWarning extends WebpackError {
-	/**
-	 *
-	 * @param {string} message warning message
-	 * @param {DependencyLocation} loc affected lines of code
-	 */
-	constructor(message, loc) {
-		super(message);
 
-		this.name = "CommentCompilationWarning";
+function isObject(maybeObj) {
+  return typeof maybeObj === "object" && maybeObj !== null;
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-		this.loc = loc;
-	}
+
+function likeNumber(schema) {
+  return schema.type === "number" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
 }
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-makeSerializable(
-	CommentCompilationWarning,
-	"webpack/lib/CommentCompilationWarning"
-);
 
-module.exports = CommentCompilationWarning;
+function likeInteger(schema) {
+  return schema.type === "integer" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
 
-/***/ }),
+function likeString(schema) {
+  return schema.type === "string" || typeof schema.minLength !== "undefined" || typeof schema.maxLength !== "undefined" || typeof schema.pattern !== "undefined" || typeof schema.format !== "undefined" || typeof schema.formatMinimum !== "undefined" || typeof schema.formatMaximum !== "undefined";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-/***/ 94258:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+function likeBoolean(schema) {
+  return schema.type === "boolean";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
 
+function likeArray(schema) {
+  return schema.type === "array" || typeof schema.minItems === "number" || typeof schema.maxItems === "number" || typeof schema.uniqueItems !== "undefined" || typeof schema.items !== "undefined" || typeof schema.additionalItems !== "undefined" || typeof schema.contains !== "undefined";
+}
+/**
+ * @param {Schema & {patternRequired?: Array<string>}} schema
+ * @returns {boolean}
+ */
 
-const ConstDependency = __webpack_require__(76911);
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+function likeObject(schema) {
+  return schema.type === "object" || typeof schema.minProperties !== "undefined" || typeof schema.maxProperties !== "undefined" || typeof schema.required !== "undefined" || typeof schema.properties !== "undefined" || typeof schema.patternProperties !== "undefined" || typeof schema.additionalProperties !== "undefined" || typeof schema.dependencies !== "undefined" || typeof schema.propertyNames !== "undefined" || typeof schema.patternRequired !== "undefined";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-const nestedWebpackRequireTag = Symbol("nested __webpack_require__");
 
-class CompatibilityPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"CompatibilityPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
+function likeNull(schema) {
+  return schema.type === "null";
+}
+/**
+ * @param {string} type
+ * @returns {string}
+ */
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("CompatibilityPlugin", (parser, parserOptions) => {
-						if (
-							parserOptions.browserify !== undefined &&
-							!parserOptions.browserify
-						)
-							return;
 
-						parser.hooks.call
-							.for("require")
-							.tap("CompatibilityPlugin", expr => {
-								// support for browserify style require delegator: "require(o, !0)"
-								if (expr.arguments.length !== 2) return;
-								const second = parser.evaluateExpression(expr.arguments[1]);
-								if (!second.isBoolean()) return;
-								if (second.asBool() !== true) return;
-								const dep = new ConstDependency("require", expr.callee.range);
-								dep.loc = expr.loc;
-								if (parser.state.current.dependencies.length > 0) {
-									const last =
-										parser.state.current.dependencies[
-											parser.state.current.dependencies.length - 1
-										];
-									if (
-										last.critical &&
-										last.options &&
-										last.options.request === "." &&
-										last.userRequest === "." &&
-										last.options.recursive
-									)
-										parser.state.current.dependencies.pop();
-								}
-								parser.state.module.addPresentationalDependency(dep);
-								return true;
-							});
-					});
+function getArticle(type) {
+  if (/^[aeiou]/i.test(type)) {
+    return "an";
+  }
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					// Handle nested requires
-					parser.hooks.preStatement.tap("CompatibilityPlugin", statement => {
-						if (
-							statement.type === "FunctionDeclaration" &&
-							statement.id &&
-							statement.id.name === "__webpack_require__"
-						) {
-							const newName = `__nested_webpack_require_${statement.range[0]}__`;
-							parser.tagVariable(statement.id.name, nestedWebpackRequireTag, {
-								name: newName,
-								declaration: {
-									updated: false,
-									loc: statement.id.loc,
-									range: statement.id.range
-								}
-							});
-							return true;
-						}
-					});
-					parser.hooks.pattern
-						.for("__webpack_require__")
-						.tap("CompatibilityPlugin", pattern => {
-							const newName = `__nested_webpack_require_${pattern.range[0]}__`;
-							parser.tagVariable(pattern.name, nestedWebpackRequireTag, {
-								name: newName,
-								declaration: {
-									updated: false,
-									loc: pattern.loc,
-									range: pattern.range
-								}
-							});
-							return true;
-						});
-					parser.hooks.expression
-						.for(nestedWebpackRequireTag)
-						.tap("CompatibilityPlugin", expr => {
-							const { name, declaration } = parser.currentTagData;
-							if (!declaration.updated) {
-								const dep = new ConstDependency(name, declaration.range);
-								dep.loc = declaration.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								declaration.updated = true;
-							}
-							const dep = new ConstDependency(name, expr.range);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
+  return "a";
+}
+/**
+ * @param {Schema=} schema
+ * @returns {string}
+ */
 
-					// Handle hashbang
-					parser.hooks.program.tap(
-						"CompatibilityPlugin",
-						(program, comments) => {
-							if (comments.length === 0) return;
-							const c = comments[0];
-							if (c.type === "Line" && c.range[0] === 0) {
-								if (parser.state.source.slice(0, 2).toString() !== "#!") return;
-								// this is a hashbang comment
-								const dep = new ConstDependency("//", 0);
-								dep.loc = c.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
-						}
-					);
-				};
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("CompatibilityPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("CompatibilityPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("CompatibilityPlugin", handler);
-			}
-		);
-	}
+function getSchemaNonTypes(schema) {
+  if (!schema) {
+    return "";
+  }
+
+  if (!schema.type) {
+    if (likeNumber(schema) || likeInteger(schema)) {
+      return " | should be any non-number";
+    }
+
+    if (likeString(schema)) {
+      return " | should be any non-string";
+    }
+
+    if (likeArray(schema)) {
+      return " | should be any non-array";
+    }
+
+    if (likeObject(schema)) {
+      return " | should be any non-object";
+    }
+  }
+
+  return "";
 }
-module.exports = CompatibilityPlugin;
+/**
+ * @param {Array<string>} hints
+ * @returns {string}
+ */
 
 
-/***/ }),
+function formatHints(hints) {
+  return hints.length > 0 ? `(${hints.join(", ")})` : "";
+}
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @returns {string[]}
+ */
 
-/***/ 85720:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+function getHints(schema, logic) {
+  if (likeNumber(schema) || likeInteger(schema)) {
+    return numberHints(schema, logic);
+  } else if (likeString(schema)) {
+    return stringHints(schema, logic);
+  }
 
+  return [];
+}
 
+class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(errors, schema, configuration = {}) {
+    super();
+    /** @type {string} */
 
-const asyncLib = __webpack_require__(78175);
-const {
-	HookMap,
-	SyncHook,
-	SyncBailHook,
-	SyncWaterfallHook,
-	AsyncSeriesHook,
-	AsyncSeriesBailHook,
-	AsyncParallelHook
-} = __webpack_require__(6967);
-const util = __webpack_require__(73837);
-const { CachedSource } = __webpack_require__(51255);
-const { MultiItemCache } = __webpack_require__(55392);
-const Chunk = __webpack_require__(39385);
-const ChunkGraph = __webpack_require__(64971);
-const ChunkGroup = __webpack_require__(15626);
-const ChunkRenderError = __webpack_require__(918);
-const ChunkTemplate = __webpack_require__(46341);
-const CodeGenerationError = __webpack_require__(2102);
-const CodeGenerationResults = __webpack_require__(71426);
-const Dependency = __webpack_require__(54912);
-const DependencyTemplates = __webpack_require__(9163);
-const Entrypoint = __webpack_require__(13795);
-const ErrorHelpers = __webpack_require__(59985);
-const FileSystemInfo = __webpack_require__(79453);
-const {
-	connectChunkGroupAndChunk,
-	connectChunkGroupParentAndChild
-} = __webpack_require__(37234);
-const {
-	makeWebpackError,
-	tryRunOrWebpackError
-} = __webpack_require__(11351);
-const MainTemplate = __webpack_require__(12856);
-const Module = __webpack_require__(73208);
-const ModuleDependencyError = __webpack_require__(67409);
-const ModuleDependencyWarning = __webpack_require__(29656);
-const ModuleGraph = __webpack_require__(99988);
-const ModuleNotFoundError = __webpack_require__(32882);
-const ModuleProfile = __webpack_require__(36418);
-const ModuleRestoreError = __webpack_require__(94560);
-const ModuleStoreError = __webpack_require__(59001);
-const ModuleTemplate = __webpack_require__(62677);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeTemplate = __webpack_require__(18777);
-const Stats = __webpack_require__(31743);
-const WebpackError = __webpack_require__(53799);
-const buildChunkGraph = __webpack_require__(79233);
-const BuildCycleError = __webpack_require__(22273);
-const { Logger, LogType } = __webpack_require__(32597);
-const StatsFactory = __webpack_require__(92629);
-const StatsPrinter = __webpack_require__(30198);
-const { equals: arrayEquals } = __webpack_require__(84953);
-const AsyncQueue = __webpack_require__(12260);
-const LazySet = __webpack_require__(38938);
-const { provide } = __webpack_require__(82482);
-const WeakTupleMap = __webpack_require__(28745);
-const { cachedCleverMerge } = __webpack_require__(60839);
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	compareIds,
-	compareStringsNumeric,
-	compareModulesByIdentifier
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const {
-	arrayToSetDeprecation,
-	soonFrozenObjectDeprecation,
-	createFakeHook
-} = __webpack_require__(64518);
-const processAsyncTree = __webpack_require__(42791);
-const { getRuntimeKey } = __webpack_require__(17156);
-const { isSourceEqual } = __webpack_require__(41245);
+    this.name = "ValidationError";
+    /** @type {Array<SchemaUtilErrorObject>} */
 
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./CacheFacade")} CacheFacade */
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./ModuleFactory")} ModuleFactory */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+    this.errors = errors;
+    /** @type {Schema} */
 
-/**
- * @callback Callback
- * @param {(WebpackError | null)=} err
- * @returns {void}
- */
+    this.schema = schema;
+    let headerNameFromSchema;
+    let baseDataPathFromSchema;
 
-/**
- * @callback ModuleCallback
- * @param {(WebpackError | null)=} err
- * @param {Module=} result
- * @returns {void}
- */
+    if (schema.title && (!configuration.name || !configuration.baseDataPath)) {
+      const splittedTitleFromSchema = schema.title.match(/^(.+) (.+)$/);
 
-/**
- * @callback ModuleFactoryResultCallback
- * @param {(WebpackError | null)=} err
- * @param {ModuleFactoryResult=} result
- * @returns {void}
- */
+      if (splittedTitleFromSchema) {
+        if (!configuration.name) {
+          [, headerNameFromSchema] = splittedTitleFromSchema;
+        }
 
-/**
- * @callback ModuleOrFactoryResultCallback
- * @param {(WebpackError | null)=} err
- * @param {Module | ModuleFactoryResult=} result
- * @returns {void}
- */
+        if (!configuration.baseDataPath) {
+          [,, baseDataPathFromSchema] = splittedTitleFromSchema;
+        }
+      }
+    }
+    /** @type {string} */
 
-/**
- * @callback ExecuteModuleCallback
- * @param {(WebpackError | null)=} err
- * @param {ExecuteModuleResult=} result
- * @returns {void}
- */
 
-/**
- * @callback DepBlockVarDependenciesCallback
- * @param {Dependency} dependency
- * @returns {any}
- */
+    this.headerName = configuration.name || headerNameFromSchema || "Object";
+    /** @type {string} */
 
-/** @typedef {new (...args: any[]) => Dependency} DepConstructor */
-/** @typedef {Record<string, Source>} CompilationAssets */
+    this.baseDataPath = configuration.baseDataPath || baseDataPathFromSchema || "configuration";
+    /** @type {PostFormatter | null} */
 
-/**
- * @typedef {Object} AvailableModulesChunkGroupMapping
- * @property {ChunkGroup} chunkGroup
- * @property {Set<Module>} availableModules
- * @property {boolean} needCopy
- */
+    this.postFormatter = configuration.postFormatter || null;
+    const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialized using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
+    /** @type {string} */
 
-/**
- * @typedef {Object} DependenciesBlockLike
- * @property {Dependency[]} dependencies
- * @property {AsyncDependenciesBlock[]} blocks
- */
+    this.message = `${header}${this.formatValidationErrors(errors)}`;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
 
-/**
- * @typedef {Object} ChunkPathData
- * @property {string|number} id
- * @property {string=} name
- * @property {string} hash
- * @property {function(number): string=} hashWithLength
- * @property {(Record<string, string>)=} contentHash
- * @property {(Record<string, (length: number) => string>)=} contentHashWithLength
- */
 
-/**
- * @typedef {Object} ChunkHashContext
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- */
+  getSchemaPart(path) {
+    const newPath = path.split("/");
+    let schemaPart = this.schema;
 
-/**
- * @typedef {Object} RuntimeRequirementsContext
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults the code generation results
- */
+    for (let i = 1; i < newPath.length; i++) {
+      const inner = schemaPart[
+      /** @type {keyof Schema} */
+      newPath[i]];
 
-/**
- * @typedef {Object} ExecuteModuleOptions
- * @property {EntryOptions=} entryOptions
- */
+      if (!inner) {
+        break;
+      }
 
-/**
- * @typedef {Object} ExecuteModuleResult
- * @property {any} exports
- * @property {boolean} cacheable
- * @property {Map<string, { source: Source, info: AssetInfo }>} assets
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} contextDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} buildDependencies
- */
+      schemaPart = inner;
+    }
 
-/**
- * @typedef {Object} ExecuteModuleArgument
- * @property {Module} module
- * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
- * @property {any} preparedInfo
- * @property {CodeGenerationResult} codeGenerationResult
- */
+    return schemaPart;
+  }
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
 
-/**
- * @typedef {Object} ExecuteModuleContext
- * @property {Map<string, { source: Source, info: AssetInfo }>} assets
- * @property {Chunk} chunk
- * @property {ChunkGraph} chunkGraph
- * @property {function(string): any=} __webpack_require__
- */
 
-/**
- * @typedef {Object} EntryData
- * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
- * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated
- * @property {EntryOptions} options options of the entrypoint
- */
+  formatSchema(schema, logic = true, prevSchemas = []) {
+    let newLogic = logic;
 
-/**
- * @typedef {Object} LogEntry
- * @property {string} type
- * @property {any[]} args
- * @property {number} time
- * @property {string[]=} trace
- */
+    const formatInnerSchema =
+    /**
+     *
+     * @param {Object} innerSchema
+     * @param {boolean=} addSelf
+     * @returns {string}
+     */
+    (innerSchema, addSelf) => {
+      if (!addSelf) {
+        return this.formatSchema(innerSchema, newLogic, prevSchemas);
+      }
 
-/**
- * @typedef {Object} KnownAssetInfo
- * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
- * @property {boolean=} minimized whether the asset is minimized
- * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset
- * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
- * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
- * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
- * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
- * @property {number=} size size in bytes, only set after asset has been emitted
- * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
- * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
- * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
- * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
- */
+      if (prevSchemas.includes(innerSchema)) {
+        return "(recursive)";
+      }
 
-/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
+      return this.formatSchema(innerSchema, newLogic, prevSchemas.concat(schema));
+    };
 
-/**
- * @typedef {Object} Asset
- * @property {string} name the filename of the asset
- * @property {Source} source source of the asset
- * @property {AssetInfo} info info about the asset
- */
+    if (hasNotInSchema(schema) && !likeObject(schema)) {
+      if (canApplyNot(schema.not)) {
+        newLogic = !logic;
+        return formatInnerSchema(schema.not);
+      }
 
-/**
- * @typedef {Object} ModulePathData
- * @property {string|number} id
- * @property {string} hash
- * @property {function(number): string=} hashWithLength
- */
+      const needApplyLogicHere = !schema.not.not;
+      const prefix = logic ? "" : "non ";
+      newLogic = !logic;
+      return needApplyLogicHere ? prefix + formatInnerSchema(schema.not) : formatInnerSchema(schema.not);
+    }
 
-/**
- * @typedef {Object} PathData
- * @property {ChunkGraph=} chunkGraph
- * @property {string=} hash
- * @property {function(number): string=} hashWithLength
- * @property {(Chunk|ChunkPathData)=} chunk
- * @property {(Module|ModulePathData)=} module
- * @property {RuntimeSpec=} runtime
- * @property {string=} filename
- * @property {string=} basename
- * @property {string=} query
- * @property {string=} contentHashType
- * @property {string=} contentHash
- * @property {function(number): string=} contentHashWithLength
- * @property {boolean=} noChunkHash
- * @property {string=} url
- */
+    if (
+    /** @type {Schema & {instanceof: string | Array<string>}} */
+    schema.instanceof) {
+      const {
+        instanceof: value
+      } =
+      /** @type {Schema & {instanceof: string | Array<string>}} */
+      schema;
+      const values = !Array.isArray(value) ? [value] : value;
+      return values.map(
+      /**
+       * @param {string} item
+       * @returns {string}
+       */
+      item => item === "Function" ? "function" : item).join(" | ");
+    }
 
-/**
- * @typedef {Object} KnownNormalizedStatsOptions
- * @property {string} context
- * @property {RequestShortener} requestShortener
- * @property {string} chunksSort
- * @property {string} modulesSort
- * @property {string} chunkModulesSort
- * @property {string} nestedModulesSort
- * @property {string} assetsSort
- * @property {boolean} ids
- * @property {boolean} cachedAssets
- * @property {boolean} groupAssetsByEmitStatus
- * @property {boolean} groupAssetsByPath
- * @property {boolean} groupAssetsByExtension
- * @property {number} assetsSpace
- * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
- * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
- * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
- * @property {boolean} cachedModules
- * @property {boolean} orphanModules
- * @property {boolean} dependentModules
- * @property {boolean} runtimeModules
- * @property {boolean} groupModulesByCacheStatus
- * @property {boolean} groupModulesByLayer
- * @property {boolean} groupModulesByAttributes
- * @property {boolean} groupModulesByPath
- * @property {boolean} groupModulesByExtension
- * @property {boolean} groupModulesByType
- * @property {boolean | "auto"} entrypoints
- * @property {boolean} chunkGroups
- * @property {boolean} chunkGroupAuxiliary
- * @property {boolean} chunkGroupChildren
- * @property {number} chunkGroupMaxAssets
- * @property {number} modulesSpace
- * @property {number} chunkModulesSpace
- * @property {number} nestedModulesSpace
- * @property {false|"none"|"error"|"warn"|"info"|"log"|"verbose"} logging
- * @property {((value: string) => boolean)[]} loggingDebug
- * @property {boolean} loggingTrace
- * @property {any} _env
- */
+    if (schema.enum) {
+      return (
+        /** @type {Array<any>} */
+        schema.enum.map(item => JSON.stringify(item)).join(" | ")
+      );
+    }
 
-/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
+    if (typeof schema.const !== "undefined") {
+      return JSON.stringify(schema.const);
+    }
 
-/**
- * @typedef {Object} KnownCreateStatsOptionsContext
- * @property {boolean=} forToString
- */
+    if (schema.oneOf) {
+      return (
+        /** @type {Array<Schema>} */
+        schema.oneOf.map(item => formatInnerSchema(item, true)).join(" | ")
+      );
+    }
 
-/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
+    if (schema.anyOf) {
+      return (
+        /** @type {Array<Schema>} */
+        schema.anyOf.map(item => formatInnerSchema(item, true)).join(" | ")
+      );
+    }
 
-/** @type {AssetInfo} */
-const EMPTY_ASSET_INFO = Object.freeze({});
+    if (schema.allOf) {
+      return (
+        /** @type {Array<Schema>} */
+        schema.allOf.map(item => formatInnerSchema(item, true)).join(" & ")
+      );
+    }
 
-const esmDependencyCategory = "esm";
-// TODO webpack 6: remove
-const deprecatedNormalModuleLoaderHook = util.deprecate(
-	compilation => {
-		return (__webpack_require__(39).getCompilationHooks)(compilation).loader;
-	},
-	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
-	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
-);
+    if (
+    /** @type {JSONSchema7} */
+    schema.if) {
+      const {
+        if: ifValue,
+        then: thenValue,
+        else: elseValue
+      } =
+      /** @type {JSONSchema7} */
+      schema;
+      return `${ifValue ? `if ${formatInnerSchema(ifValue)}` : ""}${thenValue ? ` then ${formatInnerSchema(thenValue)}` : ""}${elseValue ? ` else ${formatInnerSchema(elseValue)}` : ""}`;
+    }
 
-// TODO webpack 6: remove
-const defineRemovedModuleTemplates = moduleTemplates => {
-	Object.defineProperties(moduleTemplates, {
-		asset: {
-			enumerable: false,
-			configurable: false,
-			get: () => {
-				throw new WebpackError(
-					"Compilation.moduleTemplates.asset has been removed"
-				);
-			}
-		},
-		webassembly: {
-			enumerable: false,
-			configurable: false,
-			get: () => {
-				throw new WebpackError(
-					"Compilation.moduleTemplates.webassembly has been removed"
-				);
-			}
-		}
-	});
-	moduleTemplates = undefined;
-};
+    if (schema.$ref) {
+      return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
+    }
 
-const byId = compareSelect(
-	/**
-	 * @param {Chunk} c chunk
-	 * @returns {number | string} id
-	 */ c => c.id,
-	compareIds
-);
+    if (likeNumber(schema) || likeInteger(schema)) {
+      const [type, ...hints] = getHints(schema, logic);
+      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
+      return logic ? str : hints.length > 0 ? `non-${type} | ${str}` : `non-${type}`;
+    }
 
-const byNameOrHash = concatComparators(
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} name
-		 */
-		c => c.name,
-		compareIds
-	),
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} hash
-		 */ c => c.fullHash,
-		compareIds
-	)
-);
+    if (likeString(schema)) {
+      const [type, ...hints] = getHints(schema, logic);
+      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
+      return logic ? str : str === "string" ? "non-string" : `non-string | ${str}`;
+    }
 
-const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
+    if (likeBoolean(schema)) {
+      return `${logic ? "" : "non-"}boolean`;
+    }
 
-const byModule = compareSelect(
-	err => (err.module && err.module.identifier()) || "",
-	compareStringsNumeric
-);
+    if (likeArray(schema)) {
+      // not logic already applied in formatValidationError
+      newLogic = true;
+      const hints = [];
 
-const byLocation = compareSelect(err => err.loc, compareLocations);
+      if (typeof schema.minItems === "number") {
+        hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? "s" : ""}`);
+      }
 
-const compareErrors = concatComparators(byModule, byLocation, byMessage);
+      if (typeof schema.maxItems === "number") {
+        hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? "s" : ""}`);
+      }
 
-/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
-const unsafeCacheDependencies = new WeakMap();
+      if (schema.uniqueItems) {
+        hints.push("should not have duplicate items");
+      }
 
-/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
-const unsafeCacheData = new WeakMap();
+      const hasAdditionalItems = typeof schema.additionalItems === "undefined" || Boolean(schema.additionalItems);
+      let items = "";
 
-class Compilation {
-	/**
-	 * Creates an instance of Compilation.
-	 * @param {Compiler} compiler the compiler which created the compilation
-	 * @param {CompilationParams} params the compilation parameters
-	 */
-	constructor(compiler, params) {
-		this._backCompat = compiler._backCompat;
+      if (schema.items) {
+        if (Array.isArray(schema.items) && schema.items.length > 0) {
+          items = `${
+          /** @type {Array<Schema>} */
+          schema.items.map(item => formatInnerSchema(item)).join(", ")}`;
 
-		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
-		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
-		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
-		const processAssetsHook = new AsyncSeriesHook(["assets"]);
+          if (hasAdditionalItems) {
+            if (schema.additionalItems && isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
+              hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
+            }
+          }
+        } else if (schema.items && Object.keys(schema.items).length > 0) {
+          // "additionalItems" is ignored
+          items = `${formatInnerSchema(schema.items)}`;
+        } else {
+          // Fallback for empty `items` value
+          items = "any";
+        }
+      } else {
+        // "additionalItems" is ignored
+        items = "any";
+      }
 
-		let savedAssets = new Set();
-		const popNewAssets = assets => {
-			let newAssets = undefined;
-			for (const file of Object.keys(assets)) {
-				if (savedAssets.has(file)) continue;
-				if (newAssets === undefined) {
-					newAssets = Object.create(null);
-				}
-				newAssets[file] = assets[file];
-				savedAssets.add(file);
-			}
-			return newAssets;
-		};
-		processAssetsHook.intercept({
-			name: "Compilation",
-			call: () => {
-				savedAssets = new Set(Object.keys(this.assets));
-			},
-			register: tap => {
-				const { type, name } = tap;
-				const { fn, additionalAssets, ...remainingTap } = tap;
-				const additionalAssetsFn =
-					additionalAssets === true ? fn : additionalAssets;
-				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
-				switch (type) {
-					case "sync":
-						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tap(name, assets => {
-								if (processedAssets.has(this.assets))
-									additionalAssetsFn(assets);
-							});
-						}
-						return {
-							...remainingTap,
-							type: "async",
-							fn: (assets, callback) => {
-								try {
-									fn(assets);
-								} catch (e) {
-									return callback(e);
-								}
-								if (processedAssets !== undefined)
-									processedAssets.add(this.assets);
-								const newAssets = popNewAssets(assets);
-								if (newAssets !== undefined) {
-									this.hooks.processAdditionalAssets.callAsync(
-										newAssets,
-										callback
-									);
-									return;
-								}
-								callback();
-							}
-						};
-					case "async":
-						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tapAsync(
-								name,
-								(assets, callback) => {
-									if (processedAssets.has(this.assets))
-										return additionalAssetsFn(assets, callback);
-									callback();
-								}
-							);
-						}
-						return {
-							...remainingTap,
-							fn: (assets, callback) => {
-								fn(assets, err => {
-									if (err) return callback(err);
-									if (processedAssets !== undefined)
-										processedAssets.add(this.assets);
-									const newAssets = popNewAssets(assets);
-									if (newAssets !== undefined) {
-										this.hooks.processAdditionalAssets.callAsync(
-											newAssets,
-											callback
-										);
-										return;
-									}
-									callback();
-								});
-							}
-						};
-					case "promise":
-						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tapPromise(name, assets => {
-								if (processedAssets.has(this.assets))
-									return additionalAssetsFn(assets);
-								return Promise.resolve();
-							});
-						}
-						return {
-							...remainingTap,
-							fn: assets => {
-								const p = fn(assets);
-								if (!p || !p.then) return p;
-								return p.then(() => {
-									if (processedAssets !== undefined)
-										processedAssets.add(this.assets);
-									const newAssets = popNewAssets(assets);
-									if (newAssets !== undefined) {
-										return this.hooks.processAdditionalAssets.promise(
-											newAssets
-										);
-									}
-								});
-							}
-						};
-				}
-			}
-		});
+      if (schema.contains && Object.keys(schema.contains).length > 0) {
+        hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
+      }
 
-		/** @type {SyncHook<[CompilationAssets]>} */
-		const afterProcessAssetsHook = new SyncHook(["assets"]);
+      return `[${items}${hasAdditionalItems ? ", ..." : ""}]${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+    }
 
-		/**
-		 * @template T
-		 * @param {string} name name of the hook
-		 * @param {number} stage new stage
-		 * @param {function(): AsArray<T>} getArgs get old hook function args
-		 * @param {string=} code deprecation code (not deprecated when unset)
-		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
-		 */
-		const createProcessAssetsHook = (name, stage, getArgs, code) => {
-			if (!this._backCompat && code) return undefined;
-			const errorMessage =
-				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
-BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
-			const getOptions = options => {
-				if (typeof options === "string") options = { name: options };
-				if (options.stage) {
-					throw new Error(errorMessage("it's using the 'stage' option"));
-				}
-				return { ...options, stage: stage };
-			};
-			return createFakeHook(
-				{
-					name,
-					/** @type {AsyncSeriesHook<T>["intercept"]} */
-					intercept(interceptor) {
-						throw new Error(errorMessage("it's using 'intercept'"));
-					},
-					/** @type {AsyncSeriesHook<T>["tap"]} */
-					tap: (options, fn) => {
-						processAssetsHook.tap(getOptions(options), () => fn(...getArgs()));
-					},
-					/** @type {AsyncSeriesHook<T>["tapAsync"]} */
-					tapAsync: (options, fn) => {
-						processAssetsHook.tapAsync(
-							getOptions(options),
-							(assets, callback) =>
-								/** @type {any} */ (fn)(...getArgs(), callback)
-						);
-					},
-					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
-					tapPromise: (options, fn) => {
-						processAssetsHook.tapPromise(getOptions(options), () =>
-							fn(...getArgs())
-						);
-					}
-				},
-				`${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,
-				code
-			);
-		};
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[Module]>} */
-			buildModule: new SyncHook(["module"]),
-			/** @type {SyncHook<[Module]>} */
-			rebuildModule: new SyncHook(["module"]),
-			/** @type {SyncHook<[Module, WebpackError]>} */
-			failedModule: new SyncHook(["module", "error"]),
-			/** @type {SyncHook<[Module]>} */
-			succeedModule: new SyncHook(["module"]),
-			/** @type {SyncHook<[Module]>} */
-			stillValidModule: new SyncHook(["module"]),
+    if (likeObject(schema)) {
+      // not logic already applied in formatValidationError
+      newLogic = true;
+      const hints = [];
 
-			/** @type {SyncHook<[Dependency, EntryOptions]>} */
-			addEntry: new SyncHook(["entry", "options"]),
-			/** @type {SyncHook<[Dependency, EntryOptions, Error]>} */
-			failedEntry: new SyncHook(["entry", "options", "error"]),
-			/** @type {SyncHook<[Dependency, EntryOptions, Module]>} */
-			succeedEntry: new SyncHook(["entry", "options", "module"]),
+      if (typeof schema.minProperties === "number") {
+        hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? "properties" : "property"}`);
+      }
 
-			/** @type {SyncWaterfallHook<[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]>} */
-			dependencyReferencedExports: new SyncWaterfallHook([
-				"referencedExports",
-				"dependency",
-				"runtime"
-			]),
+      if (typeof schema.maxProperties === "number") {
+        hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties && schema.minProperties > 1 ? "properties" : "property"}`);
+      }
 
-			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
-			executeModule: new SyncHook(["options", "context"]),
-			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
-			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
+      if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
+        const patternProperties = Object.keys(schema.patternProperties);
+        hints.push(`additional property names should match pattern${patternProperties.length > 1 ? "s" : ""} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(" | ")}`);
+      }
 
-			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
-			finishModules: new AsyncSeriesHook(["modules"]),
-			/** @type {AsyncSeriesHook<[Module]>} */
-			finishRebuildingModule: new AsyncSeriesHook(["module"]),
-			/** @type {SyncHook<[]>} */
-			unseal: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			seal: new SyncHook([]),
+      const properties = schema.properties ? Object.keys(schema.properties) : [];
+      const required = schema.required ? schema.required : [];
+      const allProperties = [...new Set(
+      /** @type {Array<string>} */
+      [].concat(required).concat(properties))];
+      const objectStructure = allProperties.map(property => {
+        const isRequired = required.includes(property); // Some properties need quotes, maybe we should add check
+        // Maybe we should output type of property (`foo: string`), but it is looks very unreadable
 
-			/** @type {SyncHook<[]>} */
-			beforeChunks: new SyncHook([]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			afterChunks: new SyncHook(["chunks"]),
+        return `${property}${isRequired ? "" : "?"}`;
+      }).concat(typeof schema.additionalProperties === "undefined" || Boolean(schema.additionalProperties) ? schema.additionalProperties && isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ["…"] : []).join(", ");
+      const {
+        dependencies,
+        propertyNames,
+        patternRequired
+      } =
+      /** @type {Schema & {patternRequired?: Array<string>;}} */
+      schema;
 
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
-			optimizeDependencies: new SyncBailHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			afterOptimizeDependencies: new SyncHook(["modules"]),
+      if (dependencies) {
+        Object.keys(dependencies).forEach(dependencyName => {
+          const dependency = dependencies[dependencyName];
 
-			/** @type {SyncHook<[]>} */
-			optimize: new SyncHook([]),
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
-			optimizeModules: new SyncBailHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			afterOptimizeModules: new SyncHook(["modules"]),
+          if (Array.isArray(dependency)) {
+            hints.push(`should have ${dependency.length > 1 ? "properties" : "property"} ${dependency.map(dep => `'${dep}'`).join(", ")} when property '${dependencyName}' is present`);
+          } else {
+            hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
+          }
+        });
+      }
 
-			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
-			optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),
-			/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */
-			afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),
+      if (propertyNames && Object.keys(propertyNames).length > 0) {
+        hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
+      }
 
-			/** @type {AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			optimizeTree: new AsyncSeriesHook(["chunks", "modules"]),
-			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			afterOptimizeTree: new SyncHook(["chunks", "modules"]),
+      if (patternRequired && patternRequired.length > 0) {
+        hints.push(`should have property matching pattern ${patternRequired.map(
+        /**
+         * @param {string} item
+         * @returns {string}
+         */
+        item => JSON.stringify(item))}`);
+      }
 
-			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
-			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
-			/** @type {SyncBailHook<[], boolean>} */
-			shouldRecord: new SyncBailHook([]),
+      return `object {${objectStructure ? ` ${objectStructure} ` : ""}}${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+    }
 
-			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
-			additionalChunkRuntimeRequirements: new SyncHook([
-				"chunk",
-				"runtimeRequirements",
-				"context"
-			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
-			runtimeRequirementInChunk: new HookMap(
-				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
-			),
-			/** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
-			additionalModuleRuntimeRequirements: new SyncHook([
-				"module",
-				"runtimeRequirements",
-				"context"
-			]),
-			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
-			runtimeRequirementInModule: new HookMap(
-				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
-			),
-			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
-			additionalTreeRuntimeRequirements: new SyncHook([
-				"chunk",
-				"runtimeRequirements",
-				"context"
-			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
-			runtimeRequirementInTree: new HookMap(
-				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
-			),
+    if (likeNull(schema)) {
+      return `${logic ? "" : "non-"}null`;
+    }
 
-			/** @type {SyncHook<[RuntimeModule, Chunk]>} */
-			runtimeModule: new SyncHook(["module", "chunk"]),
+    if (Array.isArray(schema.type)) {
+      // not logic already applied in formatValidationError
+      return `${schema.type.join(" | ")}`;
+    } // Fallback for unknown keywords
+    // not logic already applied in formatValidationError
 
-			/** @type {SyncHook<[Iterable<Module>, any]>} */
-			reviveModules: new SyncHook(["modules", "records"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			beforeModuleIds: new SyncHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			moduleIds: new SyncHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			optimizeModuleIds: new SyncHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			afterOptimizeModuleIds: new SyncHook(["modules"]),
+    /* istanbul ignore next */
 
-			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
-			reviveChunks: new SyncHook(["chunks", "records"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			beforeChunkIds: new SyncHook(["chunks"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			chunkIds: new SyncHook(["chunks"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			optimizeChunkIds: new SyncHook(["chunks"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			afterOptimizeChunkIds: new SyncHook(["chunks"]),
 
-			/** @type {SyncHook<[Iterable<Module>, any]>} */
-			recordModules: new SyncHook(["modules", "records"]),
-			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
-			recordChunks: new SyncHook(["chunks", "records"]),
+    return JSON.stringify(schema, null, 2);
+  }
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
 
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			optimizeCodeGeneration: new SyncHook(["modules"]),
 
-			/** @type {SyncHook<[]>} */
-			beforeModuleHash: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterModuleHash: new SyncHook([]),
+  getSchemaPartText(schemaPart, additionalPath, needDot = false, logic = true) {
+    if (!schemaPart) {
+      return "";
+    }
 
-			/** @type {SyncHook<[]>} */
-			beforeCodeGeneration: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterCodeGeneration: new SyncHook([]),
+    if (Array.isArray(additionalPath)) {
+      for (let i = 0; i < additionalPath.length; i++) {
+        /** @type {Schema | undefined} */
+        const inner = schemaPart[
+        /** @type {keyof Schema} */
+        additionalPath[i]];
 
-			/** @type {SyncHook<[]>} */
-			beforeRuntimeRequirements: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterRuntimeRequirements: new SyncHook([]),
+        if (inner) {
+          // eslint-disable-next-line no-param-reassign
+          schemaPart = inner;
+        } else {
+          break;
+        }
+      }
+    }
 
-			/** @type {SyncHook<[]>} */
-			beforeHash: new SyncHook([]),
-			/** @type {SyncHook<[Chunk]>} */
-			contentHash: new SyncHook(["chunk"]),
-			/** @type {SyncHook<[]>} */
-			afterHash: new SyncHook([]),
-			/** @type {SyncHook<[any]>} */
-			recordHash: new SyncHook(["records"]),
-			/** @type {SyncHook<[Compilation, any]>} */
-			record: new SyncHook(["compilation", "records"]),
+    while (schemaPart.$ref) {
+      // eslint-disable-next-line no-param-reassign
+      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    }
 
-			/** @type {SyncHook<[]>} */
-			beforeModuleAssets: new SyncHook([]),
-			/** @type {SyncBailHook<[], boolean>} */
-			shouldGenerateChunkAssets: new SyncBailHook([]),
-			/** @type {SyncHook<[]>} */
-			beforeChunkAssets: new SyncHook([]),
-			// TODO webpack 6 remove
-			/** @deprecated */
-			additionalChunkAssets: createProcessAssetsHook(
-				"additionalChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
-			),
+    let schemaText = `${this.formatSchema(schemaPart, logic)}${needDot ? "." : ""}`;
 
-			// TODO webpack 6 deprecate
-			/** @deprecated */
-			additionalAssets: createProcessAssetsHook(
-				"additionalAssets",
-				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-				() => []
-			),
-			// TODO webpack 6 remove
-			/** @deprecated */
-			optimizeChunkAssets: createProcessAssetsHook(
-				"optimizeChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
-			),
-			// TODO webpack 6 remove
-			/** @deprecated */
-			afterOptimizeChunkAssets: createProcessAssetsHook(
-				"afterOptimizeChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
-			),
-			// TODO webpack 6 deprecate
-			/** @deprecated */
-			optimizeAssets: processAssetsHook,
-			// TODO webpack 6 deprecate
-			/** @deprecated */
-			afterOptimizeAssets: afterProcessAssetsHook,
+    if (schemaPart.description) {
+      schemaText += `\n-> ${schemaPart.description}`;
+    }
 
-			processAssets: processAssetsHook,
-			afterProcessAssets: afterProcessAssetsHook,
-			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
-			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
+    if (schemaPart.link) {
+      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    }
 
-			/** @type {SyncBailHook<[], boolean>} */
-			needAdditionalSeal: new SyncBailHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
-			afterSeal: new AsyncSeriesHook([]),
+    return schemaText;
+  }
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
 
-			/** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */
-			renderManifest: new SyncWaterfallHook(["result", "options"]),
 
-			/** @type {SyncHook<[Hash]>} */
-			fullHash: new SyncHook(["hash"]),
-			/** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */
-			chunkHash: new SyncHook(["chunk", "chunkHash", "ChunkHashContext"]),
+  getSchemaPartDescription(schemaPart) {
+    if (!schemaPart) {
+      return "";
+    }
 
-			/** @type {SyncHook<[Module, string]>} */
-			moduleAsset: new SyncHook(["module", "filename"]),
-			/** @type {SyncHook<[Chunk, string]>} */
-			chunkAsset: new SyncHook(["chunk", "filename"]),
+    while (schemaPart.$ref) {
+      // eslint-disable-next-line no-param-reassign
+      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    }
 
-			/** @type {SyncWaterfallHook<[string, object, AssetInfo]>} */
-			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
+    let schemaText = "";
 
-			/** @type {SyncBailHook<[], boolean>} */
-			needAdditionalPass: new SyncBailHook([]),
+    if (schemaPart.description) {
+      schemaText += `\n-> ${schemaPart.description}`;
+    }
 
-			/** @type {SyncHook<[Compiler, string, number]>} */
-			childCompiler: new SyncHook([
-				"childCompiler",
-				"compilerName",
-				"compilerIndex"
-			]),
+    if (schemaPart.link) {
+      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    }
 
-			/** @type {SyncBailHook<[string, LogEntry], true>} */
-			log: new SyncBailHook(["origin", "logEntry"]),
+    return schemaText;
+  }
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
 
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
-			processWarnings: new SyncWaterfallHook(["warnings"]),
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
-			processErrors: new SyncWaterfallHook(["errors"]),
 
-			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
-			statsPreset: new HookMap(() => new SyncHook(["options", "context"])),
-			/** @type {SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>} */
-			statsNormalize: new SyncHook(["options", "context"]),
-			/** @type {SyncHook<[StatsFactory, NormalizedStatsOptions]>} */
-			statsFactory: new SyncHook(["statsFactory", "options"]),
-			/** @type {SyncHook<[StatsPrinter, NormalizedStatsOptions]>} */
-			statsPrinter: new SyncHook(["statsPrinter", "options"]),
+  formatValidationError(error) {
+    const {
+      keyword,
+      dataPath: errorDataPath
+    } = error;
+    const dataPath = `${this.baseDataPath}${errorDataPath}`;
 
-			get normalModuleLoader() {
-				return getNormalModuleLoader();
-			}
-		});
-		/** @type {string=} */
-		this.name = undefined;
-		this.startTime = undefined;
-		this.endTime = undefined;
-		/** @type {Compiler} */
-		this.compiler = compiler;
-		this.resolverFactory = compiler.resolverFactory;
-		this.inputFileSystem = compiler.inputFileSystem;
-		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
-			managedPaths: compiler.managedPaths,
-			immutablePaths: compiler.immutablePaths,
-			logger: this.getLogger("webpack.FileSystemInfo"),
-			hashFunction: compiler.options.output.hashFunction
-		});
-		if (compiler.fileTimestamps) {
-			this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
-		}
-		if (compiler.contextTimestamps) {
-			this.fileSystemInfo.addContextTimestamps(
-				compiler.contextTimestamps,
-				true
-			);
-		}
-		/** @type {Map<string, string | Set<string>>} */
-		this.valueCacheVersions = new Map();
-		this.requestShortener = compiler.requestShortener;
-		this.compilerPath = compiler.compilerPath;
+    switch (keyword) {
+      case "type":
+        {
+          const {
+            parentSchema,
+            params
+          } = error; // eslint-disable-next-line default-case
 
-		this.logger = this.getLogger("webpack.Compilation");
+          switch (
+          /** @type {import("ajv").TypeParams} */
+          params.type) {
+            case "number":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-		const options = compiler.options;
-		this.options = options;
-		this.outputOptions = options && options.output;
-		/** @type {boolean} */
-		this.bail = (options && options.bail) || false;
-		/** @type {boolean} */
-		this.profile = (options && options.profile) || false;
+            case "integer":
+              return `${dataPath} should be an ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-		this.params = params;
-		this.mainTemplate = new MainTemplate(this.outputOptions, this);
-		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
-		this.runtimeTemplate = new RuntimeTemplate(
-			this,
-			this.outputOptions,
-			this.requestShortener
-		);
-		/** @type {{javascript: ModuleTemplate}} */
-		this.moduleTemplates = {
-			javascript: new ModuleTemplate(this.runtimeTemplate, this)
-		};
-		defineRemovedModuleTemplates(this.moduleTemplates);
+            case "string":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
-		this.moduleMemCaches = undefined;
-		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
-		this.moduleMemCaches2 = undefined;
-		this.moduleGraph = new ModuleGraph();
-		/** @type {ChunkGraph} */
-		this.chunkGraph = undefined;
-		/** @type {CodeGenerationResults} */
-		this.codeGenerationResults = undefined;
+            case "boolean":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.processDependenciesQueue = new AsyncQueue({
-			name: "processDependencies",
-			parallelism: options.parallelism || 100,
-			processor: this._processModuleDependencies.bind(this)
-		});
-		/** @type {AsyncQueue<Module, string, Module>} */
-		this.addModuleQueue = new AsyncQueue({
-			name: "addModule",
-			parent: this.processDependenciesQueue,
-			getKey: module => module.identifier(),
-			processor: this._addModule.bind(this)
-		});
-		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
-		this.factorizeQueue = new AsyncQueue({
-			name: "factorize",
-			parent: this.addModuleQueue,
-			processor: this._factorizeModule.bind(this)
-		});
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.buildQueue = new AsyncQueue({
-			name: "build",
-			parent: this.factorizeQueue,
-			processor: this._buildModule.bind(this)
-		});
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.rebuildQueue = new AsyncQueue({
-			name: "rebuild",
-			parallelism: options.parallelism || 100,
-			processor: this._rebuildModule.bind(this)
-		});
+            case "array":
+              return `${dataPath} should be an array:\n${this.getSchemaPartText(parentSchema)}`;
 
-		/**
-		 * Modules in value are building during the build of Module in key.
-		 * Means value blocking key from finishing.
-		 * Needed to detect build cycles.
-		 * @type {WeakMap<Module, Set<Module>>}
-		 */
-		this.creatingModuleDuringBuild = new WeakMap();
+            case "object":
+              return `${dataPath} should be an object:\n${this.getSchemaPartText(parentSchema)}`;
 
-		/** @type {Map<string, EntryData>} */
-		this.entries = new Map();
-		/** @type {EntryData} */
-		this.globalEntry = {
-			dependencies: [],
-			includeDependencies: [],
-			options: {
-				name: undefined
-			}
-		};
-		/** @type {Map<string, Entrypoint>} */
-		this.entrypoints = new Map();
-		/** @type {Entrypoint[]} */
-		this.asyncEntrypoints = [];
-		/** @type {Set<Chunk>} */
-		this.chunks = new Set();
-		/** @type {ChunkGroup[]} */
-		this.chunkGroups = [];
-		/** @type {Map<string, ChunkGroup>} */
-		this.namedChunkGroups = new Map();
-		/** @type {Map<string, Chunk>} */
-		this.namedChunks = new Map();
-		/** @type {Set<Module>} */
-		this.modules = new Set();
-		if (this._backCompat) {
-			arrayToSetDeprecation(this.chunks, "Compilation.chunks");
-			arrayToSetDeprecation(this.modules, "Compilation.modules");
-		}
-		/** @private @type {Map<string, Module>} */
-		this._modules = new Map();
-		this.records = null;
-		/** @type {string[]} */
-		this.additionalChunkAssets = [];
-		/** @type {CompilationAssets} */
-		this.assets = {};
-		/** @type {Map<string, AssetInfo>} */
-		this.assetsInfo = new Map();
-		/** @type {Map<string, Map<string, Set<string>>>} */
-		this._assetsRelatedIn = new Map();
-		/** @type {WebpackError[]} */
-		this.errors = [];
-		/** @type {WebpackError[]} */
-		this.warnings = [];
-		/** @type {Compilation[]} */
-		this.children = [];
-		/** @type {Map<string, LogEntry[]>} */
-		this.logging = new Map();
-		/** @type {Map<DepConstructor, ModuleFactory>} */
-		this.dependencyFactories = new Map();
-		/** @type {DependencyTemplates} */
-		this.dependencyTemplates = new DependencyTemplates(
-			this.outputOptions.hashFunction
-		);
-		this.childrenCounters = {};
-		/** @type {Set<number|string>} */
-		this.usedChunkIds = null;
-		/** @type {Set<number>} */
-		this.usedModuleIds = null;
-		/** @type {boolean} */
-		this.needAdditionalPass = false;
-		/** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
-		this._restoredUnsafeCacheModuleEntries = new Set();
-		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
-		this._restoredUnsafeCacheEntries = new Map();
-		/** @type {WeakSet<Module>} */
-		this.builtModules = new WeakSet();
-		/** @type {WeakSet<Module>} */
-		this.codeGeneratedModules = new WeakSet();
-		/** @type {WeakSet<Module>} */
-		this.buildTimeExecutedModules = new WeakSet();
-		/** @private @type {Map<Module, Callback[]>} */
-		this._rebuildingModules = new Map();
-		/** @type {Set<string>} */
-		this.emittedAssets = new Set();
-		/** @type {Set<string>} */
-		this.comparedForEmitAssets = new Set();
-		/** @type {LazySet<string>} */
-		this.fileDependencies = new LazySet();
-		/** @type {LazySet<string>} */
-		this.contextDependencies = new LazySet();
-		/** @type {LazySet<string>} */
-		this.missingDependencies = new LazySet();
-		/** @type {LazySet<string>} */
-		this.buildDependencies = new LazySet();
-		// TODO webpack 6 remove
-		this.compilationDependencies = {
-			add: util.deprecate(
-				item => this.fileDependencies.add(item),
-				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
-				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
-			)
-		};
+            case "null":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-		this._modulesCache = this.getCache("Compilation/modules");
-		this._assetsCache = this.getCache("Compilation/assets");
-		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
+            default:
+              return `${dataPath} should be:\n${this.getSchemaPartText(parentSchema)}`;
+          }
+        }
 
-		const unsafeCache = options.module.unsafeCache;
-		this._unsafeCache = !!unsafeCache;
-		this._unsafeCachePredicate =
-			typeof unsafeCache === "function" ? unsafeCache : () => true;
-	}
+      case "instanceof":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${dataPath} should be an instance of ${this.getSchemaPartText(parentSchema, false, true)}`;
+        }
 
-	getStats() {
-		return new Stats(this);
-	}
+      case "pattern":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            pattern
+          } =
+          /** @type {import("ajv").PatternParams} */
+          params;
+          return `${dataPath} should match pattern ${JSON.stringify(pattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	/**
-	 * @param {StatsOptions | string} optionsOrPreset stats option value
-	 * @param {CreateStatsOptionsContext} context context
-	 * @returns {NormalizedStatsOptions} normalized options
-	 */
-	createStatsOptions(optionsOrPreset, context = {}) {
-		if (
-			typeof optionsOrPreset === "boolean" ||
-			typeof optionsOrPreset === "string"
-		) {
-			optionsOrPreset = { preset: optionsOrPreset };
-		}
-		if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
-			// We use this method of shallow cloning this object to include
-			// properties in the prototype chain
-			/** @type {Partial<NormalizedStatsOptions>} */
-			const options = {};
-			for (const key in optionsOrPreset) {
-				options[key] = optionsOrPreset[key];
-			}
-			if (options.preset !== undefined) {
-				this.hooks.statsPreset.for(options.preset).call(options, context);
-			}
-			this.hooks.statsNormalize.call(options, context);
-			return /** @type {NormalizedStatsOptions} */ (options);
-		} else {
-			/** @type {Partial<NormalizedStatsOptions>} */
-			const options = {};
-			this.hooks.statsNormalize.call(options, context);
-			return /** @type {NormalizedStatsOptions} */ (options);
-		}
-	}
+      case "format":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            format
+          } =
+          /** @type {import("ajv").FormatParams} */
+          params;
+          return `${dataPath} should match format ${JSON.stringify(format)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	createStatsFactory(options) {
-		const statsFactory = new StatsFactory();
-		this.hooks.statsFactory.call(statsFactory, options);
-		return statsFactory;
-	}
+      case "formatMinimum":
+      case "formatMaximum":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            comparison,
+            limit
+          } =
+          /** @type {import("ajv").ComparisonParams} */
+          params;
+          return `${dataPath} should be ${comparison} ${JSON.stringify(limit)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	createStatsPrinter(options) {
-		const statsPrinter = new StatsPrinter();
-		this.hooks.statsPrinter.call(statsPrinter, options);
-		return statsPrinter;
-	}
+      case "minimum":
+      case "maximum":
+      case "exclusiveMinimum":
+      case "exclusiveMaximum":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          const {
+            comparison,
+            limit
+          } =
+          /** @type {import("ajv").ComparisonParams} */
+          params;
+          const [, ...hints] = getHints(
+          /** @type {Schema} */
+          parentSchema, true);
 
-	/**
-	 * @param {string} name cache name
-	 * @returns {CacheFacade} the cache facade instance
-	 */
-	getCache(name) {
-		return this.compiler.getCache(name);
-	}
+          if (hints.length === 0) {
+            hints.push(`should be ${comparison} ${limit}`);
+          }
 
-	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
-	 * @returns {Logger} a logger with that name
-	 */
-	getLogger(name) {
-		if (!name) {
-			throw new TypeError("Compilation.getLogger(name) called without a name");
-		}
-		/** @type {LogEntry[] | undefined} */
-		let logEntries;
-		return new Logger(
-			(type, args) => {
-				if (typeof name === "function") {
-					name = name();
-					if (!name) {
-						throw new TypeError(
-							"Compilation.getLogger(name) called with a function not returning a name"
-						);
-					}
-				}
-				let trace;
-				switch (type) {
-					case LogType.warn:
-					case LogType.error:
-					case LogType.trace:
-						trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
-							.split("\n")
-							.slice(3);
-						break;
-				}
-				/** @type {LogEntry} */
-				const logEntry = {
-					time: Date.now(),
-					type,
-					args,
-					trace
-				};
-				if (this.hooks.log.call(name, logEntry) === undefined) {
-					if (logEntry.type === LogType.profileEnd) {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						if (typeof console.profileEnd === "function") {
-							// eslint-disable-next-line node/no-unsupported-features/node-builtins
-							console.profileEnd(`[${name}] ${logEntry.args[0]}`);
-						}
-					}
-					if (logEntries === undefined) {
-						logEntries = this.logging.get(name);
-						if (logEntries === undefined) {
-							logEntries = [];
-							this.logging.set(name, logEntries);
-						}
-					}
-					logEntries.push(logEntry);
-					if (logEntry.type === LogType.profile) {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						if (typeof console.profile === "function") {
-							// eslint-disable-next-line node/no-unsupported-features/node-builtins
-							console.profile(`[${name}] ${logEntry.args[0]}`);
-						}
-					}
-				}
-			},
-			childName => {
-				if (typeof name === "function") {
-					if (typeof childName === "function") {
-						return this.getLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compilation.getLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compilation.getLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getLogger(`${name}/${childName}`);
-					}
-				}
-			}
-		);
-	}
+          return `${dataPath} ${hints.join(" ")}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	/**
-	 * @param {Module} module module to be added that was created
-	 * @param {ModuleCallback} callback returns the module in the compilation,
-	 * it could be the passed one (if new), or an already existing in the compilation
-	 * @returns {void}
-	 */
-	addModule(module, callback) {
-		this.addModuleQueue.add(module, callback);
-	}
+      case "multipleOf":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            multipleOf
+          } =
+          /** @type {import("ajv").MultipleOfParams} */
+          params;
+          return `${dataPath} should be multiple of ${multipleOf}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	/**
-	 * @param {Module} module module to be added that was created
-	 * @param {ModuleCallback} callback returns the module in the compilation,
-	 * it could be the passed one (if new), or an already existing in the compilation
-	 * @returns {void}
-	 */
-	_addModule(module, callback) {
-		const identifier = module.identifier();
-		const alreadyAddedModule = this._modules.get(identifier);
-		if (alreadyAddedModule) {
-			return callback(null, alreadyAddedModule);
-		}
+      case "patternRequired":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            missingPattern
+          } =
+          /** @type {import("ajv").PatternRequiredParams} */
+          params;
+          return `${dataPath} should have property matching pattern ${JSON.stringify(missingPattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-		const currentProfile = this.profile
-			? this.moduleGraph.getProfile(module)
-			: undefined;
-		if (currentProfile !== undefined) {
-			currentProfile.markRestoringStart();
-		}
+      case "minLength":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
 
-		this._modulesCache.get(identifier, null, (err, cacheModule) => {
-			if (err) return callback(new ModuleRestoreError(module, err));
+          if (limit === 1) {
+            return `${dataPath} should be a non-empty string${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
 
-			if (currentProfile !== undefined) {
-				currentProfile.markRestoringEnd();
-				currentProfile.markIntegrationStart();
-			}
+          const length = limit - 1;
+          return `${dataPath} should be longer than ${length} character${length > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-			if (cacheModule) {
-				cacheModule.updateCacheModule(module);
+      case "minItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
 
-				module = cacheModule;
-			}
-			this._modules.set(identifier, module);
-			this.modules.add(module);
-			if (this._backCompat)
-				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
-			if (currentProfile !== undefined) {
-				currentProfile.markIntegrationEnd();
-			}
-			callback(null, module);
-		});
-	}
+          if (limit === 1) {
+            return `${dataPath} should be a non-empty array${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
 
-	/**
-	 * Fetches a module from a compilation by its identifier
-	 * @param {Module} module the module provided
-	 * @returns {Module} the module requested
-	 */
-	getModule(module) {
-		const identifier = module.identifier();
-		return this._modules.get(identifier);
-	}
+          return `${dataPath} should not have fewer than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	/**
-	 * Attempts to search for a module by its identifier
-	 * @param {string} identifier identifier (usually path) for module
-	 * @returns {Module|undefined} attempt to search for module and return it, else undefined
-	 */
-	findModule(identifier) {
-		return this._modules.get(identifier);
-	}
+      case "minProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
 
-	/**
-	 * Schedules a build of the module object
-	 *
-	 * @param {Module} module module to be built
-	 * @param {ModuleCallback} callback the callback
-	 * @returns {void}
-	 */
-	buildModule(module, callback) {
-		this.buildQueue.add(module, callback);
-	}
+          if (limit === 1) {
+            return `${dataPath} should be a non-empty object${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
 
-	/**
-	 * Builds the module object
-	 *
-	 * @param {Module} module module to be built
-	 * @param {ModuleCallback} callback the callback
-	 * @returns {void}
-	 */
-	_buildModule(module, callback) {
-		const currentProfile = this.profile
-			? this.moduleGraph.getProfile(module)
-			: undefined;
-		if (currentProfile !== undefined) {
-			currentProfile.markBuildingStart();
-		}
+          return `${dataPath} should not have fewer than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-		module.needBuild(
-			{
-				compilation: this,
-				fileSystemInfo: this.fileSystemInfo,
-				valueCacheVersions: this.valueCacheVersions
-			},
-			(err, needBuild) => {
-				if (err) return callback(err);
+      case "maxLength":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          const max = limit + 1;
+          return `${dataPath} should be shorter than ${max} character${max > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-				if (!needBuild) {
-					if (currentProfile !== undefined) {
-						currentProfile.markBuildingEnd();
-					}
-					this.hooks.stillValidModule.call(module);
-					return callback();
-				}
+      case "maxItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-				this.hooks.buildModule.call(module);
-				this.builtModules.add(module);
-				module.build(
-					this.options,
-					this,
-					this.resolverFactory.get("normal", module.resolveOptions),
-					this.inputFileSystem,
-					err => {
-						if (currentProfile !== undefined) {
-							currentProfile.markBuildingEnd();
-						}
-						if (err) {
-							this.hooks.failedModule.call(module, err);
-							return callback(err);
-						}
-						if (currentProfile !== undefined) {
-							currentProfile.markStoringStart();
-						}
-						this._modulesCache.store(module.identifier(), null, module, err => {
-							if (currentProfile !== undefined) {
-								currentProfile.markStoringEnd();
-							}
-							if (err) {
-								this.hooks.failedModule.call(module, err);
-								return callback(new ModuleStoreError(module, err));
-							}
-							this.hooks.succeedModule.call(module);
-							return callback();
-						});
-					}
-				);
-			}
-		);
-	}
+      case "maxProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          return `${dataPath} should not have more than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	/**
-	 * @param {Module} module to be processed for deps
-	 * @param {ModuleCallback} callback callback to be triggered
-	 * @returns {void}
-	 */
-	processModuleDependencies(module, callback) {
-		this.processDependenciesQueue.add(module, callback);
-	}
+      case "uniqueItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            i
+          } =
+          /** @type {import("ajv").UniqueItemsParams} */
+          params;
+          return `${dataPath} should not contain the item '${error.data[i]}' twice${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-	/**
-	 * @param {Module} module to be processed for deps
-	 * @returns {void}
-	 */
-	processModuleDependenciesNonRecursive(module) {
-		const processDependenciesBlock = block => {
-			if (block.dependencies) {
-				let i = 0;
-				for (const dep of block.dependencies) {
-					this.moduleGraph.setParents(dep, block, module, i++);
-				}
-			}
-			if (block.blocks) {
-				for (const b of block.blocks) processDependenciesBlock(b);
-			}
-		};
+      case "additionalItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}. These items are valid:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-		processDependenciesBlock(module);
-	}
+      case "contains":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${dataPath} should contains at least one ${this.getSchemaPartText(parentSchema, ["contains"])} item${getSchemaNonTypes(parentSchema)}.`;
+        }
 
-	/**
-	 * @param {Module} module to be processed for deps
-	 * @param {ModuleCallback} callback callback to be triggered
-	 * @returns {void}
-	 */
-	_processModuleDependencies(module, callback) {
-		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
-		const sortedDependencies = [];
+      case "required":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          const missingProperty =
+          /** @type {import("ajv").DependenciesParams} */
+          params.missingProperty.replace(/^\./, "");
+          const hasProperty = parentSchema && Boolean(
+          /** @type {Schema} */
+          parentSchema.properties &&
+          /** @type {Schema} */
+          parentSchema.properties[missingProperty]);
+          return `${dataPath} misses the property '${missingProperty}'${getSchemaNonTypes(parentSchema)}.${hasProperty ? ` Should be:\n${this.getSchemaPartText(parentSchema, ["properties", missingProperty])}` : this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-		/** @type {DependenciesBlock} */
-		let currentBlock;
+      case "additionalProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            additionalProperty
+          } =
+          /** @type {import("ajv").AdditionalPropertiesParams} */
+          params;
+          return `${dataPath} has an unknown property '${additionalProperty}'${getSchemaNonTypes(parentSchema)}. These properties are valid:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
-		let dependencies;
-		/** @type {DepConstructor} */
-		let factoryCacheKey;
-		/** @type {ModuleFactory} */
-		let factoryCacheKey2;
-		/** @type {Map<string, Dependency[]>} */
-		let factoryCacheValue;
-		/** @type {string} */
-		let listCacheKey1;
-		/** @type {string} */
-		let listCacheKey2;
-		/** @type {Dependency[]} */
-		let listCacheValue;
+      case "dependencies":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            property,
+            deps
+          } =
+          /** @type {import("ajv").DependenciesParams} */
+          params;
+          const dependencies = deps.split(",").map(
+          /**
+           * @param {string} dep
+           * @returns {string}
+           */
+          dep => `'${dep.trim()}'`).join(", ");
+          return `${dataPath} should have properties ${dependencies} when property '${property}' is present${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-		let inProgressSorting = 1;
-		let inProgressTransitive = 1;
+      case "propertyNames":
+        {
+          const {
+            params,
+            parentSchema,
+            schema
+          } = error;
+          const {
+            propertyName
+          } =
+          /** @type {import("ajv").PropertyNamesParams} */
+          params;
+          return `${dataPath} property name '${propertyName}' is invalid${getSchemaNonTypes(parentSchema)}. Property names should be match format ${JSON.stringify(schema.format)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-		const onDependenciesSorted = err => {
-			if (err) return callback(err);
+      case "enum":
+        {
+          const {
+            parentSchema
+          } = error;
 
-			// early exit without changing parallelism back and forth
-			if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
-				return callback();
-			}
+          if (parentSchema &&
+          /** @type {Schema} */
+          parentSchema.enum &&
+          /** @type {Schema} */
+          parentSchema.enum.length === 1) {
+            return `${dataPath} should be ${this.getSchemaPartText(parentSchema, false, true)}`;
+          }
 
-			// This is nested so we need to allow one additional task
-			this.processDependenciesQueue.increaseParallelism();
+          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-			for (const item of sortedDependencies) {
-				inProgressTransitive++;
-				this.handleModuleCreation(item, err => {
-					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
-					// errors are created inside closures that keep a reference to the Compilation, so errors are
-					// leaking the Compilation object.
-					if (err && this.bail) {
-						if (inProgressTransitive <= 0) return;
-						inProgressTransitive = -1;
-						// eslint-disable-next-line no-self-assign
-						err.stack = err.stack;
-						onTransitiveTasksFinished(err);
-						return;
-					}
-					if (--inProgressTransitive === 0) onTransitiveTasksFinished();
-				});
-			}
-			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
-		};
+      case "const":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${dataPath} should be equal to constant ${this.getSchemaPartText(parentSchema, false, true)}`;
+        }
 
-		const onTransitiveTasksFinished = err => {
-			if (err) return callback(err);
-			this.processDependenciesQueue.decreaseParallelism();
+      case "not":
+        {
+          const postfix = likeObject(
+          /** @type {Schema} */
+          error.parentSchema) ? `\n${this.getSchemaPartText(error.parentSchema)}` : "";
+          const schemaOutput = this.getSchemaPartText(error.schema, false, false, false);
 
-			return callback();
-		};
+          if (canApplyNot(error.schema)) {
+            return `${dataPath} should be any ${schemaOutput}${postfix}.`;
+          }
 
-		/**
-		 * @param {Dependency} dep dependency
-		 * @param {number} index index in block
-		 * @returns {void}
-		 */
-		const processDependency = (dep, index) => {
-			this.moduleGraph.setParents(dep, currentBlock, module, index);
-			if (this._unsafeCache) {
-				try {
-					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
-					if (unsafeCachedModule === null) return;
-					if (unsafeCachedModule !== undefined) {
-						if (
-							this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
-						) {
-							this._handleExistingModuleFromUnsafeCache(
-								module,
-								dep,
-								unsafeCachedModule
-							);
-							return;
-						}
-						const identifier = unsafeCachedModule.identifier();
-						const cachedModule =
-							this._restoredUnsafeCacheEntries.get(identifier);
-						if (cachedModule !== undefined) {
-							// update unsafe cache to new module
-							unsafeCacheDependencies.set(dep, cachedModule);
-							this._handleExistingModuleFromUnsafeCache(
-								module,
-								dep,
-								cachedModule
-							);
-							return;
-						}
-						inProgressSorting++;
-						this._modulesCache.get(identifier, null, (err, cachedModule) => {
-							if (err) {
-								if (inProgressSorting <= 0) return;
-								inProgressSorting = -1;
-								onDependenciesSorted(err);
-								return;
-							}
-							try {
-								if (!this._restoredUnsafeCacheEntries.has(identifier)) {
-									const data = unsafeCacheData.get(cachedModule);
-									if (data === undefined) {
-										processDependencyForResolving(dep);
-										if (--inProgressSorting === 0) onDependenciesSorted();
-										return;
-									}
-									if (cachedModule !== unsafeCachedModule) {
-										unsafeCacheDependencies.set(dep, cachedModule);
-									}
-									cachedModule.restoreFromUnsafeCache(
-										data,
-										this.params.normalModuleFactory,
-										this.params
-									);
-									this._restoredUnsafeCacheEntries.set(
-										identifier,
-										cachedModule
-									);
-									this._restoredUnsafeCacheModuleEntries.add(cachedModule);
-									if (!this.modules.has(cachedModule)) {
-										inProgressTransitive++;
-										this._handleNewModuleFromUnsafeCache(
-											module,
-											dep,
-											cachedModule,
-											err => {
-												if (err) {
-													if (inProgressTransitive <= 0) return;
-													inProgressTransitive = -1;
-													onTransitiveTasksFinished(err);
-												}
-												if (--inProgressTransitive === 0)
-													return onTransitiveTasksFinished();
-											}
-										);
-										if (--inProgressSorting === 0) onDependenciesSorted();
-										return;
-									}
-								}
-								if (unsafeCachedModule !== cachedModule) {
-									unsafeCacheDependencies.set(dep, cachedModule);
-								}
-								this._handleExistingModuleFromUnsafeCache(
-									module,
-									dep,
-									cachedModule
-								); // a3
-							} catch (err) {
-								if (inProgressSorting <= 0) return;
-								inProgressSorting = -1;
-								onDependenciesSorted(err);
-								return;
-							}
-							if (--inProgressSorting === 0) onDependenciesSorted();
-						});
-						return;
-					}
-				} catch (e) {
-					console.error(e);
-				}
-			}
-			processDependencyForResolving(dep);
-		};
-
-		/**
-		 * @param {Dependency} dep dependency
-		 * @returns {void}
-		 */
-		const processDependencyForResolving = dep => {
-			const resourceIdent = dep.getResourceIdentifier();
-			if (resourceIdent !== undefined && resourceIdent !== null) {
-				const category = dep.category;
-				const constructor = /** @type {DepConstructor} */ (dep.constructor);
-				if (factoryCacheKey === constructor) {
-					// Fast path 1: same constructor as prev item
-					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
-						// Super fast path 1: also same resource
-						listCacheValue.push(dep);
-						return;
-					}
-				} else {
-					const factory = this.dependencyFactories.get(constructor);
-					if (factory === undefined) {
-						throw new Error(
-							`No module factory available for dependency type: ${constructor.name}`
-						);
-					}
-					if (factoryCacheKey2 === factory) {
-						// Fast path 2: same factory as prev item
-						factoryCacheKey = constructor;
-						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
-							// Super fast path 2: also same resource
-							listCacheValue.push(dep);
-							return;
-						}
-					} else {
-						// Slow path
-						if (factoryCacheKey2 !== undefined) {
-							// Archive last cache entry
-							if (dependencies === undefined) dependencies = new Map();
-							dependencies.set(factoryCacheKey2, factoryCacheValue);
-							factoryCacheValue = dependencies.get(factory);
-							if (factoryCacheValue === undefined) {
-								factoryCacheValue = new Map();
-							}
-						} else {
-							factoryCacheValue = new Map();
-						}
-						factoryCacheKey = constructor;
-						factoryCacheKey2 = factory;
-					}
-				}
-				// Here webpack is using heuristic that assumes
-				// mostly esm dependencies would be used
-				// so we don't allocate extra string for them
-				const cacheKey =
-					category === esmDependencyCategory
-						? resourceIdent
-						: `${category}${resourceIdent}`;
-				let list = factoryCacheValue.get(cacheKey);
-				if (list === undefined) {
-					factoryCacheValue.set(cacheKey, (list = []));
-					sortedDependencies.push({
-						factory: factoryCacheKey2,
-						dependencies: list,
-						originModule: module
-					});
-				}
-				list.push(dep);
-				listCacheKey1 = category;
-				listCacheKey2 = resourceIdent;
-				listCacheValue = list;
-			}
-		};
+          const {
+            schema,
+            parentSchema
+          } = error;
+          return `${dataPath} should not be ${this.getSchemaPartText(schema, false, true)}${parentSchema && likeObject(parentSchema) ? `\n${this.getSchemaPartText(parentSchema)}` : ""}`;
+        }
 
-		try {
-			/** @type {DependenciesBlock[]} */
-			const queue = [module];
-			do {
-				const block = queue.pop();
-				if (block.dependencies) {
-					currentBlock = block;
-					let i = 0;
-					for (const dep of block.dependencies) processDependency(dep, i++);
-				}
-				if (block.blocks) {
-					for (const b of block.blocks) queue.push(b);
-				}
-			} while (queue.length !== 0);
-		} catch (e) {
-			return callback(e);
-		}
+      case "oneOf":
+      case "anyOf":
+        {
+          const {
+            parentSchema,
+            children
+          } = error;
 
-		if (--inProgressSorting === 0) onDependenciesSorted();
-	}
+          if (children && children.length > 0) {
+            if (error.schema.length === 1) {
+              const lastChild = children[children.length - 1];
+              const remainingChildren = children.slice(0, children.length - 1);
+              return this.formatValidationError(Object.assign({}, lastChild, {
+                children: remainingChildren,
+                parentSchema: Object.assign({}, parentSchema, lastChild.parentSchema)
+              }));
+            }
 
-	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
-		const moduleGraph = this.moduleGraph;
+            let filteredChildren = filterChildren(children);
 
-		moduleGraph.setResolvedModule(originModule, dependency, module);
+            if (filteredChildren.length === 1) {
+              return this.formatValidationError(filteredChildren[0]);
+            }
 
-		moduleGraph.setIssuerIfUnset(
-			module,
-			originModule !== undefined ? originModule : null
-		);
+            filteredChildren = groupChildrenByFirstChild(filteredChildren);
+            return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}\nDetails:\n${filteredChildren.map(
+            /**
+             * @param {SchemaUtilErrorObject} nestedError
+             * @returns {string}
+             */
+            nestedError => ` * ${indent(this.formatValidationError(nestedError), "   ")}`).join("\n")}`;
+          }
 
-		this._modules.set(module.identifier(), module);
-		this.modules.add(module);
-		if (this._backCompat)
-			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-		this._handleModuleBuildAndDependencies(
-			originModule,
-			module,
-			true,
-			callback
-		);
-	}
+      case "if":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            failingKeyword
+          } =
+          /** @type {import("ajv").IfParams} */
+          params;
+          return `${dataPath} should match "${failingKeyword}" schema:\n${this.getSchemaPartText(parentSchema, [failingKeyword])}`;
+        }
 
-	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
-		const moduleGraph = this.moduleGraph;
+      case "absolutePath":
+        {
+          const {
+            message,
+            parentSchema
+          } = error;
+          return `${dataPath}: ${message}${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-		moduleGraph.setResolvedModule(originModule, dependency, module);
-	}
+      /* istanbul ignore next */
 
-	/**
-	 * @typedef {Object} HandleModuleCreationOptions
-	 * @property {ModuleFactory} factory
-	 * @property {Dependency[]} dependencies
-	 * @property {Module | null} originModule
-	 * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
-	 * @property {string=} context
-	 * @property {boolean=} recursive recurse into dependencies of the created module
-	 * @property {boolean=} connectOrigin connect the resolved module with the origin module
-	 */
+      default:
+        {
+          const {
+            message,
+            parentSchema
+          } = error;
+          const ErrorInJSON = JSON.stringify(error, null, 2); // For `custom`, `false schema`, `$ref` keywords
+          // Fallback for unknown keywords
 
-	/**
-	 * @param {HandleModuleCreationOptions} options options object
-	 * @param {ModuleCallback} callback callback
-	 * @returns {void}
-	 */
-	handleModuleCreation(
-		{
-			factory,
-			dependencies,
-			originModule,
-			contextInfo,
-			context,
-			recursive = true,
-			connectOrigin = recursive
-		},
-		callback
-	) {
-		const moduleGraph = this.moduleGraph;
+          return `${dataPath} ${message} (${ErrorInJSON}).\n${this.getSchemaPartText(parentSchema, false)}`;
+        }
+    }
+  }
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
 
-		const currentProfile = this.profile ? new ModuleProfile() : undefined;
 
-		this.factorizeModule(
-			{
-				currentProfile,
-				factory,
-				dependencies,
-				factoryResult: true,
-				originModule,
-				contextInfo,
-				context
-			},
-			(err, factoryResult) => {
-				const applyFactoryResultDependencies = () => {
-					const { fileDependencies, contextDependencies, missingDependencies } =
-						factoryResult;
-					if (fileDependencies) {
-						this.fileDependencies.addAll(fileDependencies);
-					}
-					if (contextDependencies) {
-						this.contextDependencies.addAll(contextDependencies);
-					}
-					if (missingDependencies) {
-						this.missingDependencies.addAll(missingDependencies);
-					}
-				};
-				if (err) {
-					if (factoryResult) applyFactoryResultDependencies();
-					if (dependencies.every(d => d.optional)) {
-						this.warnings.push(err);
-						return callback();
-					} else {
-						this.errors.push(err);
-						return callback(err);
-					}
-				}
+  formatValidationErrors(errors) {
+    return errors.map(error => {
+      let formattedError = this.formatValidationError(error);
 
-				const newModule = factoryResult.module;
+      if (this.postFormatter) {
+        formattedError = this.postFormatter(formattedError, error);
+      }
 
-				if (!newModule) {
-					applyFactoryResultDependencies();
-					return callback();
-				}
+      return ` - ${indent(formattedError, "   ")}`;
+    }).join("\n");
+  }
 
-				if (currentProfile !== undefined) {
-					moduleGraph.setProfile(newModule, currentProfile);
-				}
+}
 
-				this.addModule(newModule, (err, module) => {
-					if (err) {
-						applyFactoryResultDependencies();
-						if (!err.module) {
-							err.module = module;
-						}
-						this.errors.push(err);
+var _default = ValidationError;
+exports.Z = _default;
 
-						return callback(err);
-					}
+/***/ }),
 
-					if (
-						this._unsafeCache &&
-						factoryResult.cacheable !== false &&
-						/** @type {any} */ (module).restoreFromUnsafeCache &&
-						this._unsafeCachePredicate(module)
-					) {
-						const unsafeCacheableModule =
-							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
-								module
-							);
-						for (let i = 0; i < dependencies.length; i++) {
-							const dependency = dependencies[i];
-							moduleGraph.setResolvedModule(
-								connectOrigin ? originModule : null,
-								dependency,
-								unsafeCacheableModule
-							);
-							unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
-						}
-						if (!unsafeCacheData.has(unsafeCacheableModule)) {
-							unsafeCacheData.set(
-								unsafeCacheableModule,
-								unsafeCacheableModule.getUnsafeCacheData()
-							);
-						}
-					} else {
-						applyFactoryResultDependencies();
-						for (let i = 0; i < dependencies.length; i++) {
-							const dependency = dependencies[i];
-							moduleGraph.setResolvedModule(
-								connectOrigin ? originModule : null,
-								dependency,
-								module
-							);
-						}
-					}
+/***/ 81184:
+/***/ (function(module) {
 
-					moduleGraph.setIssuerIfUnset(
-						module,
-						originModule !== undefined ? originModule : null
-					);
-					if (module !== newModule) {
-						if (currentProfile !== undefined) {
-							const otherProfile = moduleGraph.getProfile(module);
-							if (otherProfile !== undefined) {
-								currentProfile.mergeInto(otherProfile);
-							} else {
-								moduleGraph.setProfile(module, currentProfile);
-							}
-						}
-					}
+"use strict";
 
-					this._handleModuleBuildAndDependencies(
-						originModule,
-						module,
-						recursive,
-						callback
-					);
-				});
-			}
-		);
-	}
 
-	_handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
-		// Check for cycles when build is trigger inside another build
-		let creatingModuleDuringBuildSet = undefined;
-		if (!recursive && this.buildQueue.isProcessing(originModule)) {
-			// Track build dependency
-			creatingModuleDuringBuildSet =
-				this.creatingModuleDuringBuild.get(originModule);
-			if (creatingModuleDuringBuildSet === undefined) {
-				creatingModuleDuringBuildSet = new Set();
-				this.creatingModuleDuringBuild.set(
-					originModule,
-					creatingModuleDuringBuildSet
-				);
-			}
-			creatingModuleDuringBuildSet.add(module);
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
 
-			// When building is blocked by another module
-			// search for a cycle, cancel the cycle by throwing
-			// an error (otherwise this would deadlock)
-			const blockReasons = this.creatingModuleDuringBuild.get(module);
-			if (blockReasons !== undefined) {
-				const set = new Set(blockReasons);
-				for (const item of set) {
-					const blockReasons = this.creatingModuleDuringBuild.get(item);
-					if (blockReasons !== undefined) {
-						for (const m of blockReasons) {
-							if (m === module) {
-								return callback(new BuildCycleError(module));
-							}
-							set.add(m);
-						}
-					}
-				}
-			}
-		}
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(side, exclusive) {
+    if (side === "left") {
+      return exclusive ? ">" : ">=";
+    }
 
-		this.buildModule(module, err => {
-			if (creatingModuleDuringBuildSet !== undefined) {
-				creatingModuleDuringBuildSet.delete(module);
-			}
-			if (err) {
-				if (!err.module) {
-					err.module = module;
-				}
-				this.errors.push(err);
+    return exclusive ? "<" : "<=";
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
 
-				return callback(err);
-			}
 
-			if (!recursive) {
-				this.processModuleDependenciesNonRecursive(module);
-				callback(null, module);
-				return;
-			}
+  static formatRight(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatLeft(value, !logic, !exclusive);
+    }
 
-			// This avoids deadlocks for circular dependencies
-			if (this.processDependenciesQueue.isProcessing(module)) {
-				return callback();
-			}
+    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
 
-			this.processModuleDependencies(module, err => {
-				if (err) {
-					return callback(err);
-				}
-				callback(null, module);
-			});
-		});
-	}
 
-	/**
-	 * @param {FactorizeModuleOptions} options options object
-	 * @param {ModuleOrFactoryResultCallback} callback callback
-	 * @returns {void}
-	 */
-	_factorizeModule(
-		{
-			currentProfile,
-			factory,
-			dependencies,
-			originModule,
-			factoryResult,
-			contextInfo,
-			context
-		},
-		callback
-	) {
-		if (currentProfile !== undefined) {
-			currentProfile.markFactoryStart();
-		}
-		factory.create(
-			{
-				contextInfo: {
-					issuer: originModule ? originModule.nameForCondition() : "",
-					issuerLayer: originModule ? originModule.layer : null,
-					compiler: this.compiler.name,
-					...contextInfo
-				},
-				resolveOptions: originModule ? originModule.resolveOptions : undefined,
-				context: context
-					? context
-					: originModule
-					? originModule.context
-					: this.compiler.context,
-				dependencies: dependencies
-			},
-			(err, result) => {
-				if (result) {
-					// TODO webpack 6: remove
-					// For backward-compat
-					if (result.module === undefined && result instanceof Module) {
-						result = {
-							module: result
-						};
-					}
-					if (!factoryResult) {
-						const {
-							fileDependencies,
-							contextDependencies,
-							missingDependencies
-						} = result;
-						if (fileDependencies) {
-							this.fileDependencies.addAll(fileDependencies);
-						}
-						if (contextDependencies) {
-							this.contextDependencies.addAll(contextDependencies);
-						}
-						if (missingDependencies) {
-							this.missingDependencies.addAll(missingDependencies);
-						}
-					}
-				}
-				if (err) {
-					const notFoundError = new ModuleNotFoundError(
-						originModule,
-						err,
-						dependencies.map(d => d.loc).filter(Boolean)[0]
-					);
-					return callback(notFoundError, factoryResult ? result : undefined);
-				}
-				if (!result) {
-					return callback();
-				}
+  static formatLeft(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatRight(value, !logic, !exclusive);
+    }
 
-				if (currentProfile !== undefined) {
-					currentProfile.markFactoryEnd();
-				}
+    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
 
-				callback(null, factoryResult ? result : result.module);
-			}
-		);
-	}
 
-	/**
-	 * @param {string} context context string path
-	 * @param {Dependency} dependency dependency used to create Module chain
-	 * @param {ModuleCallback} callback callback for when module chain is complete
-	 * @returns {void} will throw if dependency instance is not a valid Dependency
-	 */
-	addModuleChain(context, dependency, callback) {
-		return this.addModuleTree({ context, dependency }, callback);
-	}
+  static formatRange(start, end, startExclusive, endExclusive, logic) {
+    let result = "should be";
+    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
+    result += logic ? "and" : "or";
+    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
+    return result;
+  }
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
 
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.context context string path
-	 * @param {Dependency} options.dependency dependency used to create Module chain
-	 * @param {Partial<ModuleFactoryCreateDataContextInfo>=} options.contextInfo additional context info for the root module
-	 * @param {ModuleCallback} callback callback for when module chain is complete
-	 * @returns {void} will throw if dependency instance is not a valid Dependency
-	 */
-	addModuleTree({ context, dependency, contextInfo }, callback) {
-		if (
-			typeof dependency !== "object" ||
-			dependency === null ||
-			!dependency.constructor
-		) {
-			return callback(
-				new WebpackError("Parameter 'dependency' must be a Dependency")
-			);
-		}
-		const Dep = /** @type {DepConstructor} */ (dependency.constructor);
-		const moduleFactory = this.dependencyFactories.get(Dep);
-		if (!moduleFactory) {
-			return callback(
-				new WebpackError(
-					`No dependency factory available for this dependency type: ${dependency.constructor.name}`
-				)
-			);
-		}
 
-		this.handleModuleCreation(
-			{
-				factory: moduleFactory,
-				dependencies: [dependency],
-				originModule: null,
-				contextInfo,
-				context
-			},
-			(err, result) => {
-				if (err && this.bail) {
-					callback(err);
-					this.buildQueue.stop();
-					this.rebuildQueue.stop();
-					this.processDependenciesQueue.stop();
-					this.factorizeQueue.stop();
-				} else if (!err && result) {
-					callback(null, result);
-				} else {
-					callback();
-				}
-			}
-		);
-	}
+  static getRangeValue(values, logic) {
+    let minMax = logic ? Infinity : -Infinity;
+    let j = -1;
+    const predicate = logic ?
+    /** @type {RangeValueCallback} */
+    ([value]) => value <= minMax :
+    /** @type {RangeValueCallback} */
+    ([value]) => value >= minMax;
 
-	/**
-	 * @param {string} context context path for entry
-	 * @param {Dependency} entry entry dependency that should be followed
-	 * @param {string | EntryOptions} optionsOrName options or deprecated name of entry
-	 * @param {ModuleCallback} callback callback function
-	 * @returns {void} returns
-	 */
-	addEntry(context, entry, optionsOrName, callback) {
-		// TODO webpack 6 remove
-		const options =
-			typeof optionsOrName === "object"
-				? optionsOrName
-				: { name: optionsOrName };
+    for (let i = 0; i < values.length; i++) {
+      if (predicate(values[i])) {
+        [minMax] = values[i];
+        j = i;
+      }
+    }
 
-		this._addEntryItem(context, entry, "dependencies", options, callback);
-	}
+    if (j > -1) {
+      return values[j];
+    }
 
-	/**
-	 * @param {string} context context path for entry
-	 * @param {Dependency} dependency dependency that should be followed
-	 * @param {EntryOptions} options options
-	 * @param {ModuleCallback} callback callback function
-	 * @returns {void} returns
-	 */
-	addInclude(context, dependency, options, callback) {
-		this._addEntryItem(
-			context,
-			dependency,
-			"includeDependencies",
-			options,
-			callback
-		);
-	}
+    return [Infinity, true];
+  }
 
-	/**
-	 * @param {string} context context path for entry
-	 * @param {Dependency} entry entry dependency that should be followed
-	 * @param {"dependencies" | "includeDependencies"} target type of entry
-	 * @param {EntryOptions} options options
-	 * @param {ModuleCallback} callback callback function
-	 * @returns {void} returns
-	 */
-	_addEntryItem(context, entry, target, options, callback) {
-		const { name } = options;
-		let entryData =
-			name !== undefined ? this.entries.get(name) : this.globalEntry;
-		if (entryData === undefined) {
-			entryData = {
-				dependencies: [],
-				includeDependencies: [],
-				options: {
-					name: undefined,
-					...options
-				}
-			};
-			entryData[target].push(entry);
-			this.entries.set(name, entryData);
-		} else {
-			entryData[target].push(entry);
-			for (const key of Object.keys(options)) {
-				if (options[key] === undefined) continue;
-				if (entryData.options[key] === options[key]) continue;
-				if (
-					Array.isArray(entryData.options[key]) &&
-					Array.isArray(options[key]) &&
-					arrayEquals(entryData.options[key], options[key])
-				) {
-					continue;
-				}
-				if (entryData.options[key] === undefined) {
-					entryData.options[key] = options[key];
-				} else {
-					return callback(
-						new WebpackError(
-							`Conflicting entry option ${key} = ${entryData.options[key]} vs ${options[key]}`
-						)
-					);
-				}
-			}
-		}
+  constructor() {
+    /** @type {Array<RangeValue>} */
+    this._left = [];
+    /** @type {Array<RangeValue>} */
 
-		this.hooks.addEntry.call(entry, options);
+    this._right = [];
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
 
-		this.addModuleTree(
-			{
-				context,
-				dependency: entry,
-				contextInfo: entryData.options.layer
-					? { issuerLayer: entryData.options.layer }
-					: undefined
-			},
-			(err, module) => {
-				if (err) {
-					this.hooks.failedEntry.call(entry, options, err);
-					return callback(err);
-				}
-				this.hooks.succeedEntry.call(entry, options, module);
-				return callback(null, module);
-			}
-		);
-	}
 
-	/**
-	 * @param {Module} module module to be rebuilt
-	 * @param {ModuleCallback} callback callback when module finishes rebuilding
-	 * @returns {void}
-	 */
-	rebuildModule(module, callback) {
-		this.rebuildQueue.add(module, callback);
-	}
+  left(value, exclusive = false) {
+    this._left.push([value, exclusive]);
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
 
-	/**
-	 * @param {Module} module module to be rebuilt
-	 * @param {ModuleCallback} callback callback when module finishes rebuilding
-	 * @returns {void}
-	 */
-	_rebuildModule(module, callback) {
-		this.hooks.rebuildModule.call(module);
-		const oldDependencies = module.dependencies.slice();
-		const oldBlocks = module.blocks.slice();
-		module.invalidateBuild();
-		this.buildQueue.invalidate(module);
-		this.buildModule(module, err => {
-			if (err) {
-				return this.hooks.finishRebuildingModule.callAsync(module, err2 => {
-					if (err2) {
-						callback(
-							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
-						);
-						return;
-					}
-					callback(err);
-				});
-			}
 
-			this.processDependenciesQueue.invalidate(module);
-			this.moduleGraph.unfreeze();
-			this.processModuleDependencies(module, err => {
-				if (err) return callback(err);
-				this.removeReasonsOfDependencyBlock(module, {
-					dependencies: oldDependencies,
-					blocks: oldBlocks
-				});
-				this.hooks.finishRebuildingModule.callAsync(module, err2 => {
-					if (err2) {
-						callback(
-							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
-						);
-						return;
-					}
-					callback(null, module);
-				});
-			});
-		});
-	}
+  right(value, exclusive = false) {
+    this._right.push([value, exclusive]);
+  }
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
 
-	_computeAffectedModules(modules) {
-		const moduleMemCacheCache = this.compiler.moduleMemCaches;
-		if (!moduleMemCacheCache) return;
-		if (!this.moduleMemCaches) {
-			this.moduleMemCaches = new Map();
-			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
-		}
-		const { moduleGraph, moduleMemCaches } = this;
-		const affectedModules = new Set();
-		const infectedModules = new Set();
-		let statNew = 0;
-		let statChanged = 0;
-		let statUnchanged = 0;
-		let statReferencesChanged = 0;
-		let statWithoutBuild = 0;
 
-		const computeReferences = module => {
-			/** @type {WeakMap<Dependency, Module>} */
-			let references = undefined;
-			for (const connection of moduleGraph.getOutgoingConnections(module)) {
-				const d = connection.dependency;
-				const m = connection.module;
-				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
-				if (references === undefined) references = new WeakMap();
-				references.set(d, m);
-			}
-			return references;
-		};
+  format(logic = true) {
+    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
+    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
 
-		/**
-		 * @param {Module} module the module
-		 * @param {WeakMap<Dependency, Module>} references references
-		 * @returns {boolean} true, when the references differ
-		 */
-		const compareReferences = (module, references) => {
-			if (references === undefined) return true;
-			for (const connection of moduleGraph.getOutgoingConnections(module)) {
-				const d = connection.dependency;
-				if (!d) continue;
-				const entry = references.get(d);
-				if (entry === undefined) continue;
-				if (entry !== connection.module) return false;
-			}
-			return true;
-		};
+    if (!Number.isFinite(start) && !Number.isFinite(end)) {
+      return "";
+    }
 
-		const modulesWithoutCache = new Set(modules);
-		for (const [module, cachedMemCache] of moduleMemCacheCache) {
-			if (modulesWithoutCache.has(module)) {
-				const buildInfo = module.buildInfo;
-				if (buildInfo) {
-					if (cachedMemCache.buildInfo !== buildInfo) {
-						// use a new one
-						const memCache = new WeakTupleMap();
-						moduleMemCaches.set(module, memCache);
-						affectedModules.add(module);
-						cachedMemCache.buildInfo = buildInfo;
-						cachedMemCache.references = computeReferences(module);
-						cachedMemCache.memCache = memCache;
-						statChanged++;
-					} else if (!compareReferences(module, cachedMemCache.references)) {
-						// use a new one
-						const memCache = new WeakTupleMap();
-						moduleMemCaches.set(module, memCache);
-						affectedModules.add(module);
-						cachedMemCache.references = computeReferences(module);
-						cachedMemCache.memCache = memCache;
-						statReferencesChanged++;
-					} else {
-						// keep the old mem cache
-						moduleMemCaches.set(module, cachedMemCache.memCache);
-						statUnchanged++;
-					}
-				} else {
-					infectedModules.add(module);
-					moduleMemCacheCache.delete(module);
-					statWithoutBuild++;
-				}
-				modulesWithoutCache.delete(module);
-			} else {
-				moduleMemCacheCache.delete(module);
-			}
-		}
+    const realStart = leftExclusive ? start + 1 : start;
+    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
 
-		for (const module of modulesWithoutCache) {
-			const buildInfo = module.buildInfo;
-			if (buildInfo) {
-				// create a new entry
-				const memCache = new WeakTupleMap();
-				moduleMemCacheCache.set(module, {
-					buildInfo,
-					references: computeReferences(module),
-					memCache
-				});
-				moduleMemCaches.set(module, memCache);
-				affectedModules.add(module);
-				statNew++;
-			} else {
-				infectedModules.add(module);
-				statWithoutBuild++;
-			}
-		}
+    if (realStart === realEnd) {
+      return `should be ${logic ? "" : "!"}= ${realStart}`;
+    } // e.g. 4 < x < ∞
 
-		const reduceAffectType = connections => {
-			let affected = false;
-			for (const { dependency } of connections) {
-				if (!dependency) continue;
-				const type = dependency.couldAffectReferencingModule();
-				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
-				if (type === false) continue;
-				affected = true;
-			}
-			return affected;
-		};
-		const directOnlyInfectedModules = new Set();
-		for (const module of infectedModules) {
-			for (const [
-				referencingModule,
-				connections
-			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-				if (!referencingModule) continue;
-				if (infectedModules.has(referencingModule)) continue;
-				const type = reduceAffectType(connections);
-				if (!type) continue;
-				if (type === true) {
-					directOnlyInfectedModules.add(referencingModule);
-				} else {
-					infectedModules.add(referencingModule);
-				}
-			}
-		}
-		for (const module of directOnlyInfectedModules) infectedModules.add(module);
-		const directOnlyAffectModules = new Set();
-		for (const module of affectedModules) {
-			for (const [
-				referencingModule,
-				connections
-			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-				if (!referencingModule) continue;
-				if (infectedModules.has(referencingModule)) continue;
-				if (affectedModules.has(referencingModule)) continue;
-				const type = reduceAffectType(connections);
-				if (!type) continue;
-				if (type === true) {
-					directOnlyAffectModules.add(referencingModule);
-				} else {
-					affectedModules.add(referencingModule);
-				}
-				const memCache = new WeakTupleMap();
-				const cache = moduleMemCacheCache.get(referencingModule);
-				cache.memCache = memCache;
-				moduleMemCaches.set(referencingModule, memCache);
-			}
-		}
-		for (const module of directOnlyAffectModules) affectedModules.add(module);
-		this.logger.log(
-			`${Math.round(
-				(100 * (affectedModules.size + infectedModules.size)) /
-					this.modules.size
-			)}% (${affectedModules.size} affected + ${
-				infectedModules.size
-			} infected of ${
-				this.modules.size
-			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
-		);
-	}
 
-	_computeAffectedModulesWithChunkGraph() {
-		const { moduleMemCaches } = this;
-		if (!moduleMemCaches) return;
-		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
-		const { moduleGraph, chunkGraph } = this;
-		const key = "memCache2";
-		let statUnchanged = 0;
-		let statChanged = 0;
-		let statNew = 0;
-		/**
-		 * @param {Module} module module
-		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
-		 */
-		const computeReferences = module => {
-			const id = chunkGraph.getModuleId(module);
-			/** @type {Map<Module, string | number | undefined>} */
-			let modules = undefined;
-			/** @type {(string | number)[] | undefined} */
-			let blocks = undefined;
-			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
-			if (outgoing !== undefined) {
-				for (const m of outgoing.keys()) {
-					if (!m) continue;
-					if (modules === undefined) modules = new Map();
-					modules.set(m, chunkGraph.getModuleId(m));
-				}
-			}
-			if (module.blocks.length > 0) {
-				blocks = [];
-				const queue = Array.from(module.blocks);
-				for (const block of queue) {
-					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-					if (chunkGroup) {
-						for (const chunk of chunkGroup.chunks) {
-							blocks.push(chunk.id);
-						}
-					} else {
-						blocks.push(null);
-					}
-					queue.push.apply(queue, block.blocks);
-				}
-			}
-			return { id, modules, blocks };
-		};
-		/**
-		 * @param {Module} module module
-		 * @param {Object} references references
-		 * @param {string | number} references.id id
-		 * @param {Map<Module, string | number>=} references.modules modules
-		 * @param {(string | number)[]=} references.blocks blocks
-		 * @returns {boolean} ok?
-		 */
-		const compareReferences = (module, { id, modules, blocks }) => {
-			if (id !== chunkGraph.getModuleId(module)) return false;
-			if (modules !== undefined) {
-				for (const [module, id] of modules) {
-					if (chunkGraph.getModuleId(module) !== id) return false;
-				}
-			}
-			if (blocks !== undefined) {
-				const queue = Array.from(module.blocks);
-				let i = 0;
-				for (const block of queue) {
-					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-					if (chunkGroup) {
-						for (const chunk of chunkGroup.chunks) {
-							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
-						}
-					} else {
-						if (i >= blocks.length || blocks[i++] !== null) return false;
-					}
-					queue.push.apply(queue, block.blocks);
-				}
-				if (i !== blocks.length) return false;
-			}
-			return true;
-		};
+    if (Number.isFinite(start) && !Number.isFinite(end)) {
+      return Range.formatLeft(start, logic, leftExclusive);
+    } // e.g. ∞ < x < 4
 
-		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
-			const cache = memCache.get(key);
-			if (cache === undefined) {
-				const memCache2 = new WeakTupleMap();
-				memCache.set(key, {
-					references: computeReferences(module),
-					memCache: memCache2
-				});
-				moduleMemCaches2.set(module, memCache2);
-				statNew++;
-			} else if (!compareReferences(module, cache.references)) {
-				const memCache = new WeakTupleMap();
-				cache.references = computeReferences(module);
-				cache.memCache = memCache;
-				moduleMemCaches2.set(module, memCache);
-				statChanged++;
-			} else {
-				moduleMemCaches2.set(module, cache.memCache);
-				statUnchanged++;
-			}
-		}
 
-		this.logger.log(
-			`${Math.round(
-				(100 * statChanged) / (statNew + statChanged + statUnchanged)
-			)}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)`
-		);
-	}
+    if (!Number.isFinite(start) && Number.isFinite(end)) {
+      return Range.formatRight(end, logic, rightExclusive);
+    }
 
-	finish(callback) {
-		this.factorizeQueue.clear();
-		if (this.profile) {
-			this.logger.time("finish module profiles");
-			const ParallelismFactorCalculator = __webpack_require__(50780);
-			const p = new ParallelismFactorCalculator();
-			const moduleGraph = this.moduleGraph;
-			const modulesWithProfiles = new Map();
-			for (const module of this.modules) {
-				const profile = moduleGraph.getProfile(module);
-				if (!profile) continue;
-				modulesWithProfiles.set(module, profile);
-				p.range(
-					profile.buildingStartTime,
-					profile.buildingEndTime,
-					f => (profile.buildingParallelismFactor = f)
-				);
-				p.range(
-					profile.factoryStartTime,
-					profile.factoryEndTime,
-					f => (profile.factoryParallelismFactor = f)
-				);
-				p.range(
-					profile.integrationStartTime,
-					profile.integrationEndTime,
-					f => (profile.integrationParallelismFactor = f)
-				);
-				p.range(
-					profile.storingStartTime,
-					profile.storingEndTime,
-					f => (profile.storingParallelismFactor = f)
-				);
-				p.range(
-					profile.restoringStartTime,
-					profile.restoringEndTime,
-					f => (profile.restoringParallelismFactor = f)
-				);
-				if (profile.additionalFactoryTimes) {
-					for (const { start, end } of profile.additionalFactoryTimes) {
-						const influence = (end - start) / profile.additionalFactories;
-						p.range(
-							start,
-							end,
-							f =>
-								(profile.additionalFactoriesParallelismFactor += f * influence)
-						);
-					}
-				}
-			}
-			p.calculate();
+    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
+  }
 
-			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
-			const logByValue = (value, msg) => {
-				if (value > 1000) {
-					logger.error(msg);
-				} else if (value > 500) {
-					logger.warn(msg);
-				} else if (value > 200) {
-					logger.info(msg);
-				} else if (value > 30) {
-					logger.log(msg);
-				} else {
-					logger.debug(msg);
-				}
-			};
-			const logNormalSummary = (category, getDuration, getParallelism) => {
-				let sum = 0;
-				let max = 0;
-				for (const [module, profile] of modulesWithProfiles) {
-					const p = getParallelism(profile);
-					const d = getDuration(profile);
-					if (d === 0 || p === 0) continue;
-					const t = d / p;
-					sum += t;
-					if (t <= 10) continue;
-					logByValue(
-						t,
-						` | ${Math.round(t)} ms${
-							p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-						} ${category} > ${module.readableIdentifier(this.requestShortener)}`
-					);
-					max = Math.max(max, t);
-				}
-				if (sum <= 10) return;
-				logByValue(
-					Math.max(sum / 10, max),
-					`${Math.round(sum)} ms ${category}`
-				);
-			};
-			const logByLoadersSummary = (category, getDuration, getParallelism) => {
-				const map = new Map();
-				for (const [module, profile] of modulesWithProfiles) {
-					const list = provide(
-						map,
-						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
-						() => []
-					);
-					list.push({ module, profile });
-				}
+}
 
-				let sum = 0;
-				let max = 0;
-				for (const [key, modules] of map) {
-					let innerSum = 0;
-					let innerMax = 0;
-					for (const { module, profile } of modules) {
-						const p = getParallelism(profile);
-						const d = getDuration(profile);
-						if (d === 0 || p === 0) continue;
-						const t = d / p;
-						innerSum += t;
-						if (t <= 10) continue;
-						logByValue(
-							t,
-							` |  | ${Math.round(t)} ms${
-								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-							} ${category} > ${module.readableIdentifier(
-								this.requestShortener
-							)}`
-						);
-						innerMax = Math.max(innerMax, t);
-					}
-					sum += innerSum;
-					if (innerSum <= 10) continue;
-					const idx = key.indexOf("!");
-					const loaders = key.slice(idx + 1);
-					const moduleType = key.slice(0, idx);
-					const t = Math.max(innerSum / 10, innerMax);
-					logByValue(
-						t,
-						` | ${Math.round(innerSum)} ms ${category} > ${
-							loaders
-								? `${
-										modules.length
-								  } x ${moduleType} with ${this.requestShortener.shorten(
-										loaders
-								  )}`
-								: `${modules.length} x ${moduleType}`
-						}`
-					);
-					max = Math.max(max, t);
-				}
-				if (sum <= 10) return;
-				logByValue(
-					Math.max(sum / 10, max),
-					`${Math.round(sum)} ms ${category}`
-				);
-			};
-			logNormalSummary(
-				"resolve to new modules",
-				p => p.factory,
-				p => p.factoryParallelismFactor
-			);
-			logNormalSummary(
-				"resolve to existing modules",
-				p => p.additionalFactories,
-				p => p.additionalFactoriesParallelismFactor
-			);
-			logNormalSummary(
-				"integrate modules",
-				p => p.restoring,
-				p => p.restoringParallelismFactor
-			);
-			logByLoadersSummary(
-				"build modules",
-				p => p.building,
-				p => p.buildingParallelismFactor
-			);
-			logNormalSummary(
-				"store modules",
-				p => p.storing,
-				p => p.storingParallelismFactor
-			);
-			logNormalSummary(
-				"restore modules",
-				p => p.restoring,
-				p => p.restoringParallelismFactor
-			);
-			this.logger.timeEnd("finish module profiles");
-		}
-		this.logger.time("compute affected modules");
-		this._computeAffectedModules(this.modules);
-		this.logger.timeEnd("compute affected modules");
-		this.logger.time("finish modules");
-		const { modules, moduleMemCaches } = this;
-		this.hooks.finishModules.callAsync(modules, err => {
-			this.logger.timeEnd("finish modules");
-			if (err) return callback(err);
+module.exports = Range;
 
-			// extract warnings and errors from modules
-			this.moduleGraph.freeze("dependency errors");
-			// TODO keep a cacheToken (= {}) for each module in the graph
-			// create a new one per compilation and flag all updated files
-			// and parents with it
-			this.logger.time("report dependency errors and warnings");
-			for (const module of modules) {
-				// TODO only run for modules with changed cacheToken
-				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
-				const memCache = moduleMemCaches && moduleMemCaches.get(module);
-				if (memCache && memCache.get("noWarningsOrErrors")) continue;
-				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
-					module
-				]);
-				const errors = module.getErrors();
-				if (errors !== undefined) {
-					for (const error of errors) {
-						if (!error.module) {
-							error.module = module;
-						}
-						this.errors.push(error);
-						hasProblems = true;
-					}
-				}
-				const warnings = module.getWarnings();
-				if (warnings !== undefined) {
-					for (const warning of warnings) {
-						if (!warning.module) {
-							warning.module = module;
-						}
-						this.warnings.push(warning);
-						hasProblems = true;
-					}
-				}
-				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
-			}
-			this.moduleGraph.unfreeze();
-			this.logger.timeEnd("report dependency errors and warnings");
+/***/ }),
 
-			callback();
-		});
-	}
+/***/ 79926:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	unseal() {
-		this.hooks.unseal.call();
-		this.chunks.clear();
-		this.chunkGroups.length = 0;
-		this.namedChunks.clear();
-		this.namedChunkGroups.clear();
-		this.entrypoints.clear();
-		this.additionalChunkAssets.length = 0;
-		this.assets = {};
-		this.assetsInfo.clear();
-		this.moduleGraph.removeAllModuleAttributes();
-		this.moduleGraph.unfreeze();
-		this.moduleMemCaches2 = undefined;
-	}
+"use strict";
 
-	/**
-	 * @param {Callback} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	seal(callback) {
-		const finalCallback = err => {
-			this.factorizeQueue.clear();
-			this.buildQueue.clear();
-			this.rebuildQueue.clear();
-			this.processDependenciesQueue.clear();
-			this.addModuleQueue.clear();
-			return callback(err);
-		};
-		const chunkGraph = new ChunkGraph(
-			this.moduleGraph,
-			this.outputOptions.hashFunction
-		);
-		this.chunkGraph = chunkGraph;
 
-		if (this._backCompat) {
-			for (const module of this.modules) {
-				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
-			}
-		}
+const Range = __webpack_require__(81184);
+/** @typedef {import("../validate").Schema} Schema */
 
-		this.hooks.seal.call();
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
 
-		this.logger.time("optimize dependencies");
-		while (this.hooks.optimizeDependencies.call(this.modules)) {
-			/* empty */
-		}
-		this.hooks.afterOptimizeDependencies.call(this.modules);
-		this.logger.timeEnd("optimize dependencies");
 
-		this.logger.time("create chunks");
-		this.hooks.beforeChunks.call();
-		this.moduleGraph.freeze("seal");
-		/** @type {Map<Entrypoint, Module[]>} */
-		const chunkGraphInit = new Map();
-		for (const [name, { dependencies, includeDependencies, options }] of this
-			.entries) {
-			const chunk = this.addChunk(name);
-			if (options.filename) {
-				chunk.filenameTemplate = options.filename;
-			}
-			const entrypoint = new Entrypoint(options);
-			if (!options.dependOn && !options.runtime) {
-				entrypoint.setRuntimeChunk(chunk);
-			}
-			entrypoint.setEntrypointChunk(chunk);
-			this.namedChunkGroups.set(name, entrypoint);
-			this.entrypoints.set(name, entrypoint);
-			this.chunkGroups.push(entrypoint);
-			connectChunkGroupAndChunk(entrypoint, chunk);
+module.exports.stringHints = function stringHints(schema, logic) {
+  const hints = [];
+  let type = "string";
+  const currentSchema = { ...schema
+  };
 
-			const entryModules = new Set();
-			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
-				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
+  if (!logic) {
+    const tmpLength = currentSchema.minLength;
+    const tmpFormat = currentSchema.formatMinimum;
+    const tmpExclusive = currentSchema.formatExclusiveMaximum;
+    currentSchema.minLength = currentSchema.maxLength;
+    currentSchema.maxLength = tmpLength;
+    currentSchema.formatMinimum = currentSchema.formatMaximum;
+    currentSchema.formatMaximum = tmpFormat;
+    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
+    currentSchema.formatExclusiveMinimum = !tmpExclusive;
+  }
 
-				const module = this.moduleGraph.getModule(dep);
-				if (module) {
-					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-					entryModules.add(module);
-					const modulesList = chunkGraphInit.get(entrypoint);
-					if (modulesList === undefined) {
-						chunkGraphInit.set(entrypoint, [module]);
-					} else {
-						modulesList.push(module);
-					}
-				}
-			}
+  if (typeof currentSchema.minLength === "number") {
+    if (currentSchema.minLength === 1) {
+      type = "non-empty string";
+    } else {
+      const length = Math.max(currentSchema.minLength - 1, 0);
+      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
 
-			this.assignDepths(entryModules);
+  if (typeof currentSchema.maxLength === "number") {
+    if (currentSchema.maxLength === 0) {
+      type = "empty string";
+    } else {
+      const length = currentSchema.maxLength + 1;
+      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
 
-			const mapAndSort = deps =>
-				deps
-					.map(dep => this.moduleGraph.getModule(dep))
-					.filter(Boolean)
-					.sort(compareModulesByIdentifier);
-			const includedModules = [
-				...mapAndSort(this.globalEntry.includeDependencies),
-				...mapAndSort(includeDependencies)
-			];
+  if (currentSchema.pattern) {
+    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
+  }
 
-			let modulesList = chunkGraphInit.get(entrypoint);
-			if (modulesList === undefined) {
-				chunkGraphInit.set(entrypoint, (modulesList = []));
-			}
-			for (const module of includedModules) {
-				this.assignDepth(module);
-				modulesList.push(module);
-			}
-		}
-		const runtimeChunks = new Set();
-		outer: for (const [
-			name,
-			{
-				options: { dependOn, runtime }
-			}
-		] of this.entries) {
-			if (dependOn && runtime) {
-				const err =
-					new WebpackError(`Entrypoint '${name}' has 'dependOn' and 'runtime' specified. This is not valid.
-Entrypoints that depend on other entrypoints do not have their own runtime.
-They will use the runtime(s) from referenced entrypoints instead.
-Remove the 'runtime' option from the entrypoint.`);
-				const entry = this.entrypoints.get(name);
-				err.chunk = entry.getEntrypointChunk();
-				this.errors.push(err);
-			}
-			if (dependOn) {
-				const entry = this.entrypoints.get(name);
-				const referencedChunks = entry
-					.getEntrypointChunk()
-					.getAllReferencedChunks();
-				const dependOnEntries = [];
-				for (const dep of dependOn) {
-					const dependency = this.entrypoints.get(dep);
-					if (!dependency) {
-						throw new Error(
-							`Entry ${name} depends on ${dep}, but this entry was not found`
-						);
-					}
-					if (referencedChunks.has(dependency.getEntrypointChunk())) {
-						const err = new WebpackError(
-							`Entrypoints '${name}' and '${dep}' use 'dependOn' to depend on each other in a circular way.`
-						);
-						const entryChunk = entry.getEntrypointChunk();
-						err.chunk = entryChunk;
-						this.errors.push(err);
-						entry.setRuntimeChunk(entryChunk);
-						continue outer;
-					}
-					dependOnEntries.push(dependency);
-				}
-				for (const dependency of dependOnEntries) {
-					connectChunkGroupParentAndChild(dependency, entry);
-				}
-			} else if (runtime) {
-				const entry = this.entrypoints.get(name);
-				let chunk = this.namedChunks.get(runtime);
-				if (chunk) {
-					if (!runtimeChunks.has(chunk)) {
-						const err =
-							new WebpackError(`Entrypoint '${name}' has a 'runtime' option which points to another entrypoint named '${runtime}'.
-It's not valid to use other entrypoints as runtime chunk.
-Did you mean to use 'dependOn: ${JSON.stringify(
-								runtime
-							)}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
-Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
-						const entryChunk = entry.getEntrypointChunk();
-						err.chunk = entryChunk;
-						this.errors.push(err);
-						entry.setRuntimeChunk(entryChunk);
-						continue;
-					}
-				} else {
-					chunk = this.addChunk(runtime);
-					chunk.preventIntegration = true;
-					runtimeChunks.add(chunk);
-				}
-				entry.unshiftChunk(chunk);
-				chunk.addGroup(entry);
-				entry.setRuntimeChunk(chunk);
-			}
-		}
-		buildChunkGraph(this, chunkGraphInit);
-		this.hooks.afterChunks.call(this.chunks);
-		this.logger.timeEnd("create chunks");
+  if (currentSchema.format) {
+    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
+  }
 
-		this.logger.time("optimize");
-		this.hooks.optimize.call();
+  if (currentSchema.formatMinimum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
+  }
 
-		while (this.hooks.optimizeModules.call(this.modules)) {
-			/* empty */
-		}
-		this.hooks.afterOptimizeModules.call(this.modules);
+  if (currentSchema.formatMaximum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
+  }
 
-		while (this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups)) {
-			/* empty */
-		}
-		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
+  return [type].concat(hints);
+};
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
 
-		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {
-			if (err) {
-				return finalCallback(
-					makeWebpackError(err, "Compilation.hooks.optimizeTree")
-				);
-			}
 
-			this.hooks.afterOptimizeTree.call(this.chunks, this.modules);
+module.exports.numberHints = function numberHints(schema, logic) {
+  const hints = [schema.type === "integer" ? "integer" : "number"];
+  const range = new Range();
 
-			this.hooks.optimizeChunkModules.callAsync(
-				this.chunks,
-				this.modules,
-				err => {
-					if (err) {
-						return finalCallback(
-							makeWebpackError(err, "Compilation.hooks.optimizeChunkModules")
-						);
-					}
+  if (typeof schema.minimum === "number") {
+    range.left(schema.minimum);
+  }
 
-					this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);
+  if (typeof schema.exclusiveMinimum === "number") {
+    range.left(schema.exclusiveMinimum, true);
+  }
 
-					const shouldRecord = this.hooks.shouldRecord.call() !== false;
+  if (typeof schema.maximum === "number") {
+    range.right(schema.maximum);
+  }
 
-					this.hooks.reviveModules.call(this.modules, this.records);
-					this.hooks.beforeModuleIds.call(this.modules);
-					this.hooks.moduleIds.call(this.modules);
-					this.hooks.optimizeModuleIds.call(this.modules);
-					this.hooks.afterOptimizeModuleIds.call(this.modules);
+  if (typeof schema.exclusiveMaximum === "number") {
+    range.right(schema.exclusiveMaximum, true);
+  }
 
-					this.hooks.reviveChunks.call(this.chunks, this.records);
-					this.hooks.beforeChunkIds.call(this.chunks);
-					this.hooks.chunkIds.call(this.chunks);
-					this.hooks.optimizeChunkIds.call(this.chunks);
-					this.hooks.afterOptimizeChunkIds.call(this.chunks);
+  const rangeFormat = range.format(logic);
 
-					this.assignRuntimeIds();
+  if (rangeFormat) {
+    hints.push(rangeFormat);
+  }
 
-					this.logger.time("compute affected modules with chunk graph");
-					this._computeAffectedModulesWithChunkGraph();
-					this.logger.timeEnd("compute affected modules with chunk graph");
+  if (typeof schema.multipleOf === "number") {
+    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
+  }
 
-					this.sortItemsWithChunkIds();
+  return hints;
+};
 
-					if (shouldRecord) {
-						this.hooks.recordModules.call(this.modules, this.records);
-						this.hooks.recordChunks.call(this.chunks, this.records);
-					}
+/***/ }),
 
-					this.hooks.optimizeCodeGeneration.call(this.modules);
-					this.logger.timeEnd("optimize");
+/***/ 18151:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					this.logger.time("module hashing");
-					this.hooks.beforeModuleHash.call();
-					this.createModuleHashes();
-					this.hooks.afterModuleHash.call();
-					this.logger.timeEnd("module hashing");
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					this.logger.time("code generation");
-					this.hooks.beforeCodeGeneration.call();
-					this.codeGeneration(err => {
-						if (err) {
-							return finalCallback(err);
-						}
-						this.hooks.afterCodeGeneration.call();
-						this.logger.timeEnd("code generation");
 
-						this.logger.time("runtime requirements");
-						this.hooks.beforeRuntimeRequirements.call();
-						this.processRuntimeRequirements();
-						this.hooks.afterRuntimeRequirements.call();
-						this.logger.timeEnd("runtime requirements");
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-						this.logger.time("hashing");
-						this.hooks.beforeHash.call();
-						const codeGenerationJobs = this.createHash();
-						this.hooks.afterHash.call();
-						this.logger.timeEnd("hashing");
+class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		let code = "";
+		code += `var _results = new Array(${this.options.taps.length});\n`;
+		code += "var _checkDone = function() {\n";
+		code += "for(var i = 0; i < _results.length; i++) {\n";
+		code += "var item = _results[i];\n";
+		code += "if(item === undefined) return false;\n";
+		code += "if(item.result !== undefined) {\n";
+		code += onResult("item.result");
+		code += "return true;\n";
+		code += "}\n";
+		code += "if(item.error) {\n";
+		code += onError("item.error");
+		code += "return true;\n";
+		code += "}\n";
+		code += "}\n";
+		code += "return false;\n";
+		code += "}\n";
+		code += this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && ((_results.length = ${i +
+					1}), (_results[${i}] = { error: ${err} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onResult: (i, result, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i +
+					1}), (_results[${i}] = { result: ${result} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onTap: (i, run, done, doneBreak) => {
+				let code = "";
+				if (i > 0) {
+					code += `if(${i} >= _results.length) {\n`;
+					code += done();
+					code += "} else {\n";
+				}
+				code += run();
+				if (i > 0) code += "}\n";
+				return code;
+			},
+			onDone
+		});
+		return code;
+	}
+}
 
-						this._runCodeGenerationJobs(codeGenerationJobs, err => {
-							if (err) {
-								return finalCallback(err);
-							}
+const factory = new AsyncParallelBailHookCodeFactory();
 
-							if (shouldRecord) {
-								this.logger.time("record hash");
-								this.hooks.recordHash.call(this.records);
-								this.logger.timeEnd("record hash");
-							}
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-							this.logger.time("module assets");
-							this.clearAssets();
+function AsyncParallelBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncParallelBailHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
 
-							this.hooks.beforeModuleAssets.call();
-							this.createModuleAssets();
-							this.logger.timeEnd("module assets");
+AsyncParallelBailHook.prototype = null;
 
-							const cont = () => {
-								this.logger.time("process assets");
-								this.hooks.processAssets.callAsync(this.assets, err => {
-									if (err) {
-										return finalCallback(
-											makeWebpackError(err, "Compilation.hooks.processAssets")
-										);
-									}
-									this.hooks.afterProcessAssets.call(this.assets);
-									this.logger.timeEnd("process assets");
-									this.assets = this._backCompat
-										? soonFrozenObjectDeprecation(
-												this.assets,
-												"Compilation.assets",
-												"DEP_WEBPACK_COMPILATION_ASSETS",
-												`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
-	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
-	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
-										  )
-										: Object.freeze(this.assets);
+module.exports = AsyncParallelBailHook;
 
-									this.summarizeDependencies();
-									if (shouldRecord) {
-										this.hooks.record.call(this, this.records);
-									}
 
-									if (this.hooks.needAdditionalSeal.call()) {
-										this.unseal();
-										return this.seal(callback);
-									}
-									return this.hooks.afterSeal.callAsync(err => {
-										if (err) {
-											return finalCallback(
-												makeWebpackError(err, "Compilation.hooks.afterSeal")
-											);
-										}
-										this.fileSystemInfo.logStatistics();
-										finalCallback();
-									});
-								});
-							};
+/***/ }),
 
-							this.logger.time("create chunk assets");
-							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
-								this.hooks.beforeChunkAssets.call();
-								this.createChunkAssets(err => {
-									this.logger.timeEnd("create chunk assets");
-									if (err) {
-										return finalCallback(err);
-									}
-									cont();
-								});
-							} else {
-								this.logger.timeEnd("create chunk assets");
-								cont();
-							}
-						});
-					});
-				}
-			);
+/***/ 31684:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
+
+class AsyncParallelHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => onError(err) + doneBreak(true),
+			onDone
 		});
 	}
+}
 
-	/**
-	 * @param {Module} module module to report from
-	 * @param {DependenciesBlock[]} blocks blocks to report from
-	 * @returns {boolean} true, when it has warnings or errors
-	 */
-	reportDependencyErrorsAndWarnings(module, blocks) {
-		let hasProblems = false;
-		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
-			const block = blocks[indexBlock];
-			const dependencies = block.dependencies;
+const factory = new AsyncParallelHookCodeFactory();
 
-			for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {
-				const d = dependencies[indexDep];
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-				const warnings = d.getWarnings(this.moduleGraph);
-				if (warnings) {
-					for (let indexWar = 0; indexWar < warnings.length; indexWar++) {
-						const w = warnings[indexWar];
+function AsyncParallelHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncParallelHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
 
-						const warning = new ModuleDependencyWarning(module, w, d.loc);
-						this.warnings.push(warning);
-						hasProblems = true;
-					}
-				}
-				const errors = d.getErrors(this.moduleGraph);
-				if (errors) {
-					for (let indexErr = 0; indexErr < errors.length; indexErr++) {
-						const e = errors[indexErr];
+AsyncParallelHook.prototype = null;
 
-						const error = new ModuleDependencyError(module, e, d.loc);
-						this.errors.push(error);
-						hasProblems = true;
-					}
-				}
-			}
+module.exports = AsyncParallelHook;
 
-			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
-				hasProblems = true;
-		}
-		return hasProblems;
+
+/***/ }),
+
+/***/ 95734:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
+
+class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)}\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone
+		});
 	}
+}
 
-	codeGeneration(callback) {
-		const { chunkGraph } = this;
-		this.codeGenerationResults = new CodeGenerationResults(
-			this.outputOptions.hashFunction
-		);
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
-		const jobs = [];
-		for (const module of this.modules) {
-			const runtimes = chunkGraph.getModuleRuntimes(module);
-			if (runtimes.size === 1) {
-				for (const runtime of runtimes) {
-					const hash = chunkGraph.getModuleHash(module, runtime);
-					jobs.push({ module, hash, runtime, runtimes: [runtime] });
-				}
-			} else if (runtimes.size > 1) {
-				/** @type {Map<string, { runtimes: RuntimeSpec[] }>} */
-				const map = new Map();
-				for (const runtime of runtimes) {
-					const hash = chunkGraph.getModuleHash(module, runtime);
-					const job = map.get(hash);
-					if (job === undefined) {
-						const newJob = { module, hash, runtime, runtimes: [runtime] };
-						jobs.push(newJob);
-						map.set(hash, newJob);
-					} else {
-						job.runtimes.push(runtime);
-					}
-				}
-			}
-		}
+const factory = new AsyncSeriesBailHookCodeFactory();
 
-		this._runCodeGenerationJobs(jobs, callback);
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function AsyncSeriesBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesBailHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
+
+AsyncSeriesBailHook.prototype = null;
+
+module.exports = AsyncSeriesBailHook;
+
+
+/***/ }),
+
+/***/ 96496:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
+
+class AsyncSeriesHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
 	}
+}
 
-	_runCodeGenerationJobs(jobs, callback) {
-		let statModulesFromCache = 0;
-		let statModulesGenerated = 0;
-		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
-			this;
-		const results = this.codeGenerationResults;
-		const errors = [];
-		/** @type {Set<Module> | undefined} */
-		let notCodeGeneratedModules = undefined;
-		const runIteration = () => {
-			let delayedJobs = [];
-			let delayedModules = new Set();
-			asyncLib.eachLimit(
-				jobs,
-				this.options.parallelism,
-				(job, callback) => {
-					const { module } = job;
-					const { codeGenerationDependencies } = module;
-					if (codeGenerationDependencies !== undefined) {
-						if (
-							notCodeGeneratedModules === undefined ||
-							codeGenerationDependencies.some(dep => {
-								const referencedModule = moduleGraph.getModule(dep);
-								return notCodeGeneratedModules.has(referencedModule);
-							})
-						) {
-							delayedJobs.push(job);
-							delayedModules.add(module);
-							return callback();
-						}
-					}
-					const { hash, runtime, runtimes } = job;
-					this._codeGenerationModule(
-						module,
-						runtime,
-						runtimes,
-						hash,
-						dependencyTemplates,
-						chunkGraph,
-						moduleGraph,
-						runtimeTemplate,
-						errors,
-						results,
-						(err, codeGenerated) => {
-							if (codeGenerated) statModulesGenerated++;
-							else statModulesFromCache++;
-							callback(err);
-						}
-					);
-				},
-				err => {
-					if (err) return callback(err);
-					if (delayedJobs.length > 0) {
-						if (delayedJobs.length === jobs.length) {
-							return callback(
-								new Error(
-									`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
-										delayedModules,
-										m => m.identifier()
-									).join(", ")}`
-								)
-							);
-						}
-						jobs = delayedJobs;
-						delayedJobs = [];
-						notCodeGeneratedModules = delayedModules;
-						delayedModules = new Set();
-						return runIteration();
-					}
-					if (errors.length > 0) {
-						errors.sort(
-							compareSelect(err => err.module, compareModulesByIdentifier)
-						);
-						for (const error of errors) {
-							this.errors.push(error);
-						}
-					}
-					this.logger.log(
-						`${Math.round(
-							(100 * statModulesGenerated) /
-								(statModulesGenerated + statModulesFromCache)
-						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
-					);
-					callback();
-				}
-			);
-		};
-		runIteration();
-	}
+const factory = new AsyncSeriesHookCodeFactory();
 
-	/**
-	 * @param {Module} module module
-	 * @param {RuntimeSpec} runtime runtime
-	 * @param {RuntimeSpec[]} runtimes runtimes
-	 * @param {string} hash hash
-	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
-	 * @param {ChunkGraph} chunkGraph chunkGraph
-	 * @param {ModuleGraph} moduleGraph moduleGraph
-	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
-	 * @param {WebpackError[]} errors errors
-	 * @param {CodeGenerationResults} results results
-	 * @param {function(WebpackError=, boolean=): void} callback callback
-	 */
-	_codeGenerationModule(
-		module,
-		runtime,
-		runtimes,
-		hash,
-		dependencyTemplates,
-		chunkGraph,
-		moduleGraph,
-		runtimeTemplate,
-		errors,
-		results,
-		callback
-	) {
-		let codeGenerated = false;
-		const cache = new MultiItemCache(
-			runtimes.map(runtime =>
-				this._codeGenerationCache.getItemCache(
-					`${module.identifier()}|${getRuntimeKey(runtime)}`,
-					`${hash}|${dependencyTemplates.getHash()}`
-				)
-			)
-		);
-		cache.get((err, cachedResult) => {
-			if (err) return callback(err);
-			let result;
-			if (!cachedResult) {
-				try {
-					codeGenerated = true;
-					this.codeGeneratedModules.add(module);
-					result = module.codeGeneration({
-						chunkGraph,
-						moduleGraph,
-						dependencyTemplates,
-						runtimeTemplate,
-						runtime,
-						codeGenerationResults: results
-					});
-				} catch (err) {
-					errors.push(new CodeGenerationError(module, err));
-					result = cachedResult = {
-						sources: new Map(),
-						runtimeRequirements: null
-					};
-				}
-			} else {
-				result = cachedResult;
-			}
-			for (const runtime of runtimes) {
-				results.add(module, runtime, result);
-			}
-			if (!cachedResult) {
-				cache.store(result, err => callback(err, codeGenerated));
-			} else {
-				callback(null, codeGenerated);
-			}
-		});
-	}
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-	_getChunkGraphEntries() {
-		/** @type {Set<Chunk>} */
-		const treeEntries = new Set();
-		for (const ep of this.entrypoints.values()) {
-			const chunk = ep.getRuntimeChunk();
-			if (chunk) treeEntries.add(chunk);
-		}
-		for (const ep of this.asyncEntrypoints) {
-			const chunk = ep.getRuntimeChunk();
-			if (chunk) treeEntries.add(chunk);
-		}
-		return treeEntries;
-	}
+function AsyncSeriesHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
 
-	/**
-	 * @param {Object} options options
-	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
-	 * @param {Iterable<Module>=} options.modules modules
-	 * @param {Iterable<Chunk>=} options.chunks chunks
-	 * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults
-	 * @param {Iterable<Chunk>=} options.chunkGraphEntries chunkGraphEntries
-	 * @returns {void}
-	 */
-	processRuntimeRequirements({
-		chunkGraph = this.chunkGraph,
-		modules = this.modules,
-		chunks = this.chunks,
-		codeGenerationResults = this.codeGenerationResults,
-		chunkGraphEntries = this._getChunkGraphEntries()
-	} = {}) {
-		const context = { chunkGraph, codeGenerationResults };
-		const { moduleMemCaches2 } = this;
-		this.logger.time("runtime requirements.modules");
-		const additionalModuleRuntimeRequirements =
-			this.hooks.additionalModuleRuntimeRequirements;
-		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
-		for (const module of modules) {
-			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
-				const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
-				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-					if (memCache) {
-						const cached = memCache.get(
-							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
-						);
-						if (cached !== undefined) {
-							if (cached !== null) {
-								chunkGraph.addModuleRuntimeRequirements(
-									module,
-									runtime,
-									cached,
-									false
-								);
-							}
-							continue;
-						}
-					}
-					let set;
-					const runtimeRequirements =
-						codeGenerationResults.getRuntimeRequirements(module, runtime);
-					if (runtimeRequirements && runtimeRequirements.size > 0) {
-						set = new Set(runtimeRequirements);
-					} else if (additionalModuleRuntimeRequirements.isUsed()) {
-						set = new Set();
-					} else {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								null
-							);
-						}
-						continue;
-					}
-					additionalModuleRuntimeRequirements.call(module, set, context);
+AsyncSeriesHook.prototype = null;
 
-					for (const r of set) {
-						const hook = runtimeRequirementInModule.get(r);
-						if (hook !== undefined) hook.call(module, set, context);
-					}
-					if (set.size === 0) {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								null
-							);
-						}
-					} else {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								set
-							);
-							chunkGraph.addModuleRuntimeRequirements(
-								module,
-								runtime,
-								set,
-								false
-							);
-						} else {
-							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
-						}
-					}
-				}
-			}
-		}
-		this.logger.timeEnd("runtime requirements.modules");
+module.exports = AsyncSeriesHook;
 
-		this.logger.time("runtime requirements.chunks");
-		for (const chunk of chunks) {
-			const set = new Set();
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-					module,
-					chunk.runtime
-				);
-				for (const r of runtimeRequirements) set.add(r);
-			}
-			this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context);
 
-			for (const r of set) {
-				this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context);
-			}
+/***/ }),
 
-			chunkGraph.addChunkRuntimeRequirements(chunk, set);
-		}
-		this.logger.timeEnd("runtime requirements.chunks");
+/***/ 95999:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		this.logger.time("runtime requirements.entries");
-		for (const treeEntry of chunkGraphEntries) {
-			const set = new Set();
-			for (const chunk of treeEntry.getAllReferencedChunks()) {
-				const runtimeRequirements =
-					chunkGraph.getChunkRuntimeRequirements(chunk);
-				for (const r of runtimeRequirements) set.add(r);
-			}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			this.hooks.additionalTreeRuntimeRequirements.call(
-				treeEntry,
-				set,
-				context
-			);
 
-			for (const r of set) {
-				this.hooks.runtimeRequirementInTree
-					.for(r)
-					.call(treeEntry, set, context);
-			}
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
-		}
-		this.logger.timeEnd("runtime requirements.entries");
+class AsyncSeriesLoopHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsLooping({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
 	}
+}
 
-	// TODO webpack 6 make chunkGraph argument non-optional
-	/**
-	 * @param {Chunk} chunk target chunk
-	 * @param {RuntimeModule} module runtime module
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
-		// Deprecated ModuleGraph association
-		if (this._backCompat)
-			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+const factory = new AsyncSeriesLoopHookCodeFactory();
 
-		// add it to the list
-		this.modules.add(module);
-		this._modules.set(module.identifier(), module);
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-		// connect to the chunk graph
-		chunkGraph.connectChunkAndModule(chunk, module);
-		chunkGraph.connectChunkAndRuntimeModule(chunk, module);
-		if (module.fullHash) {
-			chunkGraph.addFullHashModuleToChunk(chunk, module);
-		} else if (module.dependentHash) {
-			chunkGraph.addDependentHashModuleToChunk(chunk, module);
-		}
+function AsyncSeriesLoopHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesLoopHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
 
-		// attach runtime module
-		module.attach(this, chunk, chunkGraph);
+AsyncSeriesLoopHook.prototype = null;
 
-		// Setup internals
-		const exportsInfo = this.moduleGraph.getExportsInfo(module);
-		exportsInfo.setHasProvideInfo();
-		if (typeof chunk.runtime === "string") {
-			exportsInfo.setUsedForSideEffectsOnly(chunk.runtime);
-		} else if (chunk.runtime === undefined) {
-			exportsInfo.setUsedForSideEffectsOnly(undefined);
-		} else {
-			for (const runtime of chunk.runtime) {
-				exportsInfo.setUsedForSideEffectsOnly(runtime);
-			}
-		}
-		chunkGraph.addModuleRuntimeRequirements(
-			module,
-			chunk.runtime,
-			new Set([RuntimeGlobals.requireScope])
-		);
+module.exports = AsyncSeriesLoopHook;
 
-		// runtime modules don't need ids
-		chunkGraph.setModuleId(module, "");
 
-		// Call hook
-		this.hooks.runtimeModule.call(module, chunk);
-	}
+/***/ }),
 
-	/**
-	 * If `module` is passed, `loc` and `request` must also be passed.
-	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
-	 * @param {Module=} module the module the references the chunk group
-	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string=} request the request from which the the chunk group is referenced
-	 * @returns {ChunkGroup} the new or existing chunk group
-	 */
-	addChunkInGroup(groupOptions, module, loc, request) {
-		if (typeof groupOptions === "string") {
-			groupOptions = { name: groupOptions };
-		}
-		const name = groupOptions.name;
+/***/ 58118:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (name) {
-			const chunkGroup = this.namedChunkGroups.get(name);
-			if (chunkGroup !== undefined) {
-				chunkGroup.addOptions(groupOptions);
-				if (module) {
-					chunkGroup.addOrigin(module, loc, request);
-				}
-				return chunkGroup;
-			}
-		}
-		const chunkGroup = new ChunkGroup(groupOptions);
-		if (module) chunkGroup.addOrigin(module, loc, request);
-		const chunk = this.addChunk(name);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		connectChunkGroupAndChunk(chunkGroup, chunk);
 
-		this.chunkGroups.push(chunkGroup);
-		if (name) {
-			this.namedChunkGroups.set(name, chunkGroup);
-		}
-		return chunkGroup;
-	}
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-	/**
-	 * @param {EntryOptions} options options for the entrypoint
-	 * @param {Module} module the module the references the chunk group
-	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string} request the request from which the the chunk group is referenced
-	 * @returns {Entrypoint} the new or existing entrypoint
-	 */
-	addAsyncEntrypoint(options, module, loc, request) {
-		const name = options.name;
-		if (name) {
-			const entrypoint = this.namedChunkGroups.get(name);
-			if (entrypoint instanceof Entrypoint) {
-				if (entrypoint !== undefined) {
-					if (module) {
-						entrypoint.addOrigin(module, loc, request);
-					}
-					return entrypoint;
-				}
-			} else if (entrypoint) {
-				throw new Error(
-					`Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name`
-				);
-			}
-		}
-		const chunk = this.addChunk(name);
-		if (options.filename) {
-			chunk.filenameTemplate = options.filename;
-		}
-		const entrypoint = new Entrypoint(options, false);
-		entrypoint.setRuntimeChunk(chunk);
-		entrypoint.setEntrypointChunk(chunk);
-		if (name) {
-			this.namedChunkGroups.set(name, entrypoint);
-		}
-		this.chunkGroups.push(entrypoint);
-		this.asyncEntrypoints.push(entrypoint);
-		connectChunkGroupAndChunk(entrypoint, chunk);
-		if (module) {
-			entrypoint.addOrigin(module, loc, request);
-		}
-		return entrypoint;
+class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0])
+		});
 	}
+}
 
-	/**
-	 * This method first looks to see if a name is provided for a new chunk,
-	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
-	 *
-	 * @param {string=} name optional chunk name to be provided
-	 * @returns {Chunk} create a chunk (invoked during seal event)
-	 */
-	addChunk(name) {
-		if (name) {
-			const chunk = this.namedChunks.get(name);
-			if (chunk !== undefined) {
-				return chunk;
-			}
-		}
-		const chunk = new Chunk(name, this._backCompat);
-		this.chunks.add(chunk);
-		if (this._backCompat)
-			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
-		if (name) {
-			this.namedChunks.set(name, chunk);
-		}
-		return chunk;
-	}
+const factory = new AsyncSeriesWaterfallHookCodeFactory();
 
-	/**
-	 * @deprecated
-	 * @param {Module} module module to assign depth
-	 * @returns {void}
-	 */
-	assignDepth(module) {
-		const moduleGraph = this.moduleGraph;
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-		const queue = new Set([module]);
-		let depth;
+function AsyncSeriesWaterfallHook(args = [], name = undefined) {
+	if (args.length < 1)
+		throw new Error("Waterfall hooks must have at least one argument");
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesWaterfallHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
 
-		moduleGraph.setDepth(module, 0);
+AsyncSeriesWaterfallHook.prototype = null;
 
-		/**
-		 * @param {Module} module module for processing
-		 * @returns {void}
-		 */
-		const processModule = module => {
-			if (!moduleGraph.setDepthIfLower(module, depth)) return;
-			queue.add(module);
-		};
+module.exports = AsyncSeriesWaterfallHook;
 
-		for (module of queue) {
-			queue.delete(module);
-			depth = moduleGraph.getDepth(module) + 1;
 
-			for (const connection of moduleGraph.getOutgoingConnections(module)) {
-				const refModule = connection.module;
-				if (refModule) {
-					processModule(refModule);
-				}
-			}
-		}
-	}
+/***/ }),
 
-	/**
-	 * @param {Set<Module>} modules module to assign depth
-	 * @returns {void}
-	 */
-	assignDepths(modules) {
-		const moduleGraph = this.moduleGraph;
+/***/ 21468:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		/** @type {Set<Module | number>} */
-		const queue = new Set(modules);
-		queue.add(1);
-		let depth = 0;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		let i = 0;
-		for (const module of queue) {
-			i++;
-			if (typeof module === "number") {
-				depth = module;
-				if (queue.size === i) return;
-				queue.add(depth + 1);
-			} else {
-				moduleGraph.setDepth(module, depth);
-				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
-					module
-				)) {
-					if (refModule) {
-						queue.add(refModule);
-					}
-				}
-			}
-		}
-	}
 
-	/**
-	 * @param {Dependency} dependency the dependency
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getDependencyReferencedExports(dependency, runtime) {
-		const referencedExports = dependency.getReferencedExports(
-			this.moduleGraph,
-			runtime
-		);
-		return this.hooks.dependencyReferencedExports.call(
-			referencedExports,
-			dependency,
-			runtime
-		);
-	}
+const util = __webpack_require__(73837);
 
-	/**
-	 *
-	 * @param {Module} module module relationship for removal
-	 * @param {DependenciesBlockLike} block //TODO: good description
-	 * @returns {void}
-	 */
-	removeReasonsOfDependencyBlock(module, block) {
-		if (block.blocks) {
-			for (const b of block.blocks) {
-				this.removeReasonsOfDependencyBlock(module, b);
-			}
-		}
+const deprecateContext = util.deprecate(() => {},
+"Hook.context is deprecated and will be removed");
 
-		if (block.dependencies) {
-			for (const dep of block.dependencies) {
-				const originalModule = this.moduleGraph.getModule(dep);
-				if (originalModule) {
-					this.moduleGraph.removeConnection(dep);
+const CALL_DELEGATE = function(...args) {
+	this.call = this._createCall("sync");
+	return this.call(...args);
+};
+const CALL_ASYNC_DELEGATE = function(...args) {
+	this.callAsync = this._createCall("async");
+	return this.callAsync(...args);
+};
+const PROMISE_DELEGATE = function(...args) {
+	this.promise = this._createCall("promise");
+	return this.promise(...args);
+};
 
-					if (this.chunkGraph) {
-						for (const chunk of this.chunkGraph.getModuleChunks(
-							originalModule
-						)) {
-							this.patchChunksAfterReasonRemoval(originalModule, chunk);
-						}
-					}
-				}
-			}
-		}
-	}
+class Hook {
+	constructor(args = [], name = undefined) {
+		this._args = args;
+		this.name = name;
+		this.taps = [];
+		this.interceptors = [];
+		this._call = CALL_DELEGATE;
+		this.call = CALL_DELEGATE;
+		this._callAsync = CALL_ASYNC_DELEGATE;
+		this.callAsync = CALL_ASYNC_DELEGATE;
+		this._promise = PROMISE_DELEGATE;
+		this.promise = PROMISE_DELEGATE;
+		this._x = undefined;
 
-	/**
-	 * @param {Module} module module to patch tie
-	 * @param {Chunk} chunk chunk to patch tie
-	 * @returns {void}
-	 */
-	patchChunksAfterReasonRemoval(module, chunk) {
-		if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
-			this.removeReasonsOfDependencyBlock(module, module);
-		}
-		if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
-			if (this.chunkGraph.isModuleInChunk(module, chunk)) {
-				this.chunkGraph.disconnectChunkAndModule(chunk, module);
-				this.removeChunkFromDependencies(module, chunk);
-			}
-		}
+		this.compile = this.compile;
+		this.tap = this.tap;
+		this.tapAsync = this.tapAsync;
+		this.tapPromise = this.tapPromise;
 	}
 
-	/**
-	 *
-	 * @param {DependenciesBlock} block block tie for Chunk
-	 * @param {Chunk} chunk chunk to remove from dep
-	 * @returns {void}
-	 */
-	removeChunkFromDependencies(block, chunk) {
-		/**
-		 * @param {Dependency} d dependency to (maybe) patch up
-		 */
-		const iteratorDependency = d => {
-			const depModule = this.moduleGraph.getModule(d);
-			if (!depModule) {
-				return;
-			}
-			this.patchChunksAfterReasonRemoval(depModule, chunk);
-		};
-
-		const blocks = block.blocks;
-		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
-			const asyncBlock = blocks[indexBlock];
-			const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
-			// Grab all chunks from the first Block's AsyncDepBlock
-			const chunks = chunkGroup.chunks;
-			// For each chunk in chunkGroup
-			for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
-				const iteratedChunk = chunks[indexChunk];
-				chunkGroup.removeChunk(iteratedChunk);
-				// Recurse
-				this.removeChunkFromDependencies(block, iteratedChunk);
-			}
-		}
+	compile(options) {
+		throw new Error("Abstract: should be overridden");
+	}
 
-		if (block.dependencies) {
-			for (const dep of block.dependencies) iteratorDependency(dep);
-		}
+	_createCall(type) {
+		return this.compile({
+			taps: this.taps,
+			interceptors: this.interceptors,
+			args: this._args,
+			type: type
+		});
 	}
 
-	assignRuntimeIds() {
-		const { chunkGraph } = this;
-		const processEntrypoint = ep => {
-			const runtime = ep.options.runtime || ep.name;
-			const chunk = ep.getRuntimeChunk();
-			chunkGraph.setRuntimeId(runtime, chunk.id);
-		};
-		for (const ep of this.entrypoints.values()) {
-			processEntrypoint(ep);
+	_tap(type, options, fn) {
+		if (typeof options === "string") {
+			options = {
+				name: options.trim()
+			};
+		} else if (typeof options !== "object" || options === null) {
+			throw new Error("Invalid tap options");
 		}
-		for (const ep of this.asyncEntrypoints) {
-			processEntrypoint(ep);
+		if (typeof options.name !== "string" || options.name === "") {
+			throw new Error("Missing name for tap");
 		}
-	}
-
-	sortItemsWithChunkIds() {
-		for (const chunkGroup of this.chunkGroups) {
-			chunkGroup.sortItems();
+		if (typeof options.context !== "undefined") {
+			deprecateContext();
 		}
-
-		this.errors.sort(compareErrors);
-		this.warnings.sort(compareErrors);
-		this.children.sort(byNameOrHash);
+		options = Object.assign({ type, fn }, options);
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
 	}
 
-	summarizeDependencies() {
-		for (
-			let indexChildren = 0;
-			indexChildren < this.children.length;
-			indexChildren++
-		) {
-			const child = this.children[indexChildren];
+	tap(options, fn) {
+		this._tap("sync", options, fn);
+	}
 
-			this.fileDependencies.addAll(child.fileDependencies);
-			this.contextDependencies.addAll(child.contextDependencies);
-			this.missingDependencies.addAll(child.missingDependencies);
-			this.buildDependencies.addAll(child.buildDependencies);
-		}
+	tapAsync(options, fn) {
+		this._tap("async", options, fn);
+	}
 
-		for (const module of this.modules) {
-			module.addCacheDependencies(
-				this.fileDependencies,
-				this.contextDependencies,
-				this.missingDependencies,
-				this.buildDependencies
-			);
-		}
+	tapPromise(options, fn) {
+		this._tap("promise", options, fn);
 	}
 
-	createModuleHashes() {
-		let statModulesHashed = 0;
-		let statModulesFromCache = 0;
-		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
-		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
-		for (const module of this.modules) {
-			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
-			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-				if (memCache) {
-					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
-					if (digest !== undefined) {
-						chunkGraph.setModuleHashes(
-							module,
-							runtime,
-							digest,
-							digest.substr(0, hashDigestLength)
-						);
-						statModulesFromCache++;
-						continue;
-					}
-				}
-				statModulesHashed++;
-				const digest = this._createModuleHash(
-					module,
-					chunkGraph,
-					runtime,
-					hashFunction,
-					runtimeTemplate,
-					hashDigest,
-					hashDigestLength
-				);
-				if (memCache) {
-					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+	_runRegisterInterceptors(options) {
+		for (const interceptor of this.interceptors) {
+			if (interceptor.register) {
+				const newOptions = interceptor.register(options);
+				if (newOptions !== undefined) {
+					options = newOptions;
 				}
 			}
 		}
-		this.logger.log(
-			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
-				Math.round(
-					(100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
-				) / 100
-			} variants per module in average)`
-		);
+		return options;
 	}
 
-	_createModuleHash(
-		module,
-		chunkGraph,
-		runtime,
-		hashFunction,
-		runtimeTemplate,
-		hashDigest,
-		hashDigestLength
-	) {
-		const moduleHash = createHash(hashFunction);
-		module.updateHash(moduleHash, {
-			chunkGraph,
-			runtime,
-			runtimeTemplate
-		});
-		const moduleHashDigest = /** @type {string} */ (
-			moduleHash.digest(hashDigest)
-		);
-		chunkGraph.setModuleHashes(
-			module,
-			runtime,
-			moduleHashDigest,
-			moduleHashDigest.substr(0, hashDigestLength)
-		);
-		return moduleHashDigest;
+	withOptions(options) {
+		const mergeOptions = opt =>
+			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
+
+		return {
+			name: this.name,
+			tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
+			tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
+			tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
+			intercept: interceptor => this.intercept(interceptor),
+			isUsed: () => this.isUsed(),
+			withOptions: opt => this.withOptions(mergeOptions(opt))
+		};
 	}
 
-	createHash() {
-		this.logger.time("hashing: initialize hash");
-		const chunkGraph = this.chunkGraph;
-		const runtimeTemplate = this.runtimeTemplate;
-		const outputOptions = this.outputOptions;
-		const hashFunction = outputOptions.hashFunction;
-		const hashDigest = outputOptions.hashDigest;
-		const hashDigestLength = outputOptions.hashDigestLength;
-		const hash = createHash(hashFunction);
-		if (outputOptions.hashSalt) {
-			hash.update(outputOptions.hashSalt);
-		}
-		this.logger.timeEnd("hashing: initialize hash");
-		if (this.children.length > 0) {
-			this.logger.time("hashing: hash child compilations");
-			for (const child of this.children) {
-				hash.update(child.hash);
-			}
-			this.logger.timeEnd("hashing: hash child compilations");
-		}
-		if (this.warnings.length > 0) {
-			this.logger.time("hashing: hash warnings");
-			for (const warning of this.warnings) {
-				hash.update(`${warning.message}`);
-			}
-			this.logger.timeEnd("hashing: hash warnings");
-		}
-		if (this.errors.length > 0) {
-			this.logger.time("hashing: hash errors");
-			for (const error of this.errors) {
-				hash.update(`${error.message}`);
-			}
-			this.logger.timeEnd("hashing: hash errors");
-		}
+	isUsed() {
+		return this.taps.length > 0 || this.interceptors.length > 0;
+	}
 
-		this.logger.time("hashing: sort chunks");
-		/*
-		 * all non-runtime chunks need to be hashes first,
-		 * since runtime chunk might use their hashes.
-		 * runtime chunks need to be hashed in the correct order
-		 * since they may depend on each other (for async entrypoints).
-		 * So we put all non-runtime chunks first and hash them in any order.
-		 * And order runtime chunks according to referenced between each other.
-		 * Chunks need to be in deterministic order since we add hashes to full chunk
-		 * during these hashing.
-		 */
-		/** @type {Chunk[]} */
-		const unorderedRuntimeChunks = [];
-		/** @type {Chunk[]} */
-		const otherChunks = [];
-		for (const c of this.chunks) {
-			if (c.hasRuntime()) {
-				unorderedRuntimeChunks.push(c);
-			} else {
-				otherChunks.push(c);
+	intercept(interceptor) {
+		this._resetCompilation();
+		this.interceptors.push(Object.assign({}, interceptor));
+		if (interceptor.register) {
+			for (let i = 0; i < this.taps.length; i++) {
+				this.taps[i] = interceptor.register(this.taps[i]);
 			}
 		}
-		unorderedRuntimeChunks.sort(byId);
-		otherChunks.sort(byId);
+	}
 
-		/** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
-		/** @type {Map<Chunk, RuntimeChunkInfo>} */
-		const runtimeChunksMap = new Map();
-		for (const chunk of unorderedRuntimeChunks) {
-			runtimeChunksMap.set(chunk, {
-				chunk,
-				referencedBy: [],
-				remaining: 0
-			});
-		}
-		let remaining = 0;
-		for (const info of runtimeChunksMap.values()) {
-			for (const other of new Set(
-				Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
-					e => e.chunks[e.chunks.length - 1]
-				)
-			)) {
-				const otherInfo = runtimeChunksMap.get(other);
-				otherInfo.referencedBy.push(info);
-				info.remaining++;
-				remaining++;
-			}
+	_resetCompilation() {
+		this.call = this._call;
+		this.callAsync = this._callAsync;
+		this.promise = this._promise;
+	}
+
+	_insert(item) {
+		this._resetCompilation();
+		let before;
+		if (typeof item.before === "string") {
+			before = new Set([item.before]);
+		} else if (Array.isArray(item.before)) {
+			before = new Set(item.before);
 		}
-		/** @type {Chunk[]} */
-		const runtimeChunks = [];
-		for (const info of runtimeChunksMap.values()) {
-			if (info.remaining === 0) {
-				runtimeChunks.push(info.chunk);
-			}
+		let stage = 0;
+		if (typeof item.stage === "number") {
+			stage = item.stage;
 		}
-		// If there are any references between chunks
-		// make sure to follow these chains
-		if (remaining > 0) {
-			const readyChunks = [];
-			for (const chunk of runtimeChunks) {
-				const hasFullHashModules =
-					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
-				const info = runtimeChunksMap.get(chunk);
-				for (const otherInfo of info.referencedBy) {
-					if (hasFullHashModules) {
-						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
-					}
-					remaining--;
-					if (--otherInfo.remaining === 0) {
-						readyChunks.push(otherInfo.chunk);
-					}
+		let i = this.taps.length;
+		while (i > 0) {
+			i--;
+			const x = this.taps[i];
+			this.taps[i + 1] = x;
+			const xStage = x.stage || 0;
+			if (before) {
+				if (before.has(x.name)) {
+					before.delete(x.name);
+					continue;
 				}
-				if (readyChunks.length > 0) {
-					// This ensures deterministic ordering, since referencedBy is non-deterministic
-					readyChunks.sort(byId);
-					for (const c of readyChunks) runtimeChunks.push(c);
-					readyChunks.length = 0;
+				if (before.size > 0) {
+					continue;
 				}
 			}
-		}
-		// If there are still remaining references we have cycles and want to create a warning
-		if (remaining > 0) {
-			let circularRuntimeChunkInfo = [];
-			for (const info of runtimeChunksMap.values()) {
-				if (info.remaining !== 0) {
-					circularRuntimeChunkInfo.push(info);
-				}
+			if (xStage > stage) {
+				continue;
 			}
-			circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
-			const err =
-				new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
-					circularRuntimeChunkInfo,
-					c => c.chunk.name || c.chunk.id
-				).join(", ")})
-This prevents using hashes of each other and should be avoided.`);
-			err.chunk = circularRuntimeChunkInfo[0].chunk;
-			this.warnings.push(err);
-			for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
+			i++;
+			break;
 		}
-		this.logger.timeEnd("hashing: sort chunks");
+		this.taps[i] = item;
+	}
+}
 
-		const fullHashChunks = new Set();
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
-		const codeGenerationJobs = [];
-		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
-		const codeGenerationJobsMap = new Map();
+Object.setPrototypeOf(Hook.prototype, null);
 
-		const processChunk = chunk => {
-			// Last minute module hash generation for modules that depend on chunk hashes
-			this.logger.time("hashing: hash runtime modules");
-			const runtime = chunk.runtime;
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!chunkGraph.hasModuleHashes(module, runtime)) {
-					const hash = this._createModuleHash(
-						module,
-						chunkGraph,
-						runtime,
-						hashFunction,
-						runtimeTemplate,
-						hashDigest,
-						hashDigestLength
-					);
-					let hashMap = codeGenerationJobsMap.get(hash);
-					if (hashMap) {
-						const moduleJob = hashMap.get(module);
-						if (moduleJob) {
-							moduleJob.runtimes.push(runtime);
-							continue;
-						}
-					} else {
-						hashMap = new Map();
-						codeGenerationJobsMap.set(hash, hashMap);
-					}
-					const job = {
-						module,
-						hash,
-						runtime,
-						runtimes: [runtime]
-					};
-					hashMap.set(module, job);
-					codeGenerationJobs.push(job);
-				}
-			}
-			this.logger.timeAggregate("hashing: hash runtime modules");
-			this.logger.time("hashing: hash chunks");
-			const chunkHash = createHash(hashFunction);
-			try {
-				if (outputOptions.hashSalt) {
-					chunkHash.update(outputOptions.hashSalt);
-				}
-				chunk.updateHash(chunkHash, chunkGraph);
-				this.hooks.chunkHash.call(chunk, chunkHash, {
-					chunkGraph,
-					moduleGraph: this.moduleGraph,
-					runtimeTemplate: this.runtimeTemplate
-				});
-				const chunkHashDigest = /** @type {string} */ (
-					chunkHash.digest(hashDigest)
-				);
-				hash.update(chunkHashDigest);
-				chunk.hash = chunkHashDigest;
-				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
-				const fullHashModules =
-					chunkGraph.getChunkFullHashModulesIterable(chunk);
-				if (fullHashModules) {
-					fullHashChunks.add(chunk);
-				} else {
-					this.hooks.contentHash.call(chunk);
-				}
-			} catch (err) {
-				this.errors.push(new ChunkRenderError(chunk, "", err));
-			}
-			this.logger.timeAggregate("hashing: hash chunks");
-		};
-		otherChunks.forEach(processChunk);
-		for (const chunk of runtimeChunks) processChunk(chunk);
+module.exports = Hook;
 
-		this.logger.timeAggregateEnd("hashing: hash runtime modules");
-		this.logger.timeAggregateEnd("hashing: hash chunks");
-		this.logger.time("hashing: hash digest");
-		this.hooks.fullHash.call(hash);
-		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
-		this.hash = this.fullHash.substr(0, hashDigestLength);
-		this.logger.timeEnd("hashing: hash digest");
 
-		this.logger.time("hashing: process full hash modules");
-		for (const chunk of fullHashChunks) {
-			for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
-				const moduleHash = createHash(hashFunction);
-				module.updateHash(moduleHash, {
-					chunkGraph,
-					runtime: chunk.runtime,
-					runtimeTemplate
-				});
-				const moduleHashDigest = /** @type {string} */ (
-					moduleHash.digest(hashDigest)
-				);
-				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
-				chunkGraph.setModuleHashes(
-					module,
-					chunk.runtime,
-					moduleHashDigest,
-					moduleHashDigest.substr(0, hashDigestLength)
-				);
-				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
-			}
-			const chunkHash = createHash(hashFunction);
-			chunkHash.update(chunk.hash);
-			chunkHash.update(this.hash);
-			const chunkHashDigest = /** @type {string} */ (
-				chunkHash.digest(hashDigest)
-			);
-			chunk.hash = chunkHashDigest;
-			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
-			this.hooks.contentHash.call(chunk);
-		}
-		this.logger.timeEnd("hashing: process full hash modules");
-		return codeGenerationJobs;
-	}
+/***/ }),
 
-	/**
-	 * @param {string} file file name
-	 * @param {Source} source asset source
-	 * @param {AssetInfo} assetInfo extra asset information
-	 * @returns {void}
-	 */
-	emitAsset(file, source, assetInfo = {}) {
-		if (this.assets[file]) {
-			if (!isSourceEqual(this.assets[file], source)) {
-				this.errors.push(
-					new WebpackError(
-						`Conflict: Multiple assets emit different content to the same filename ${file}`
-					)
-				);
-				this.assets[file] = source;
-				this._setAssetInfo(file, assetInfo);
-				return;
-			}
-			const oldInfo = this.assetsInfo.get(file);
-			const newInfo = Object.assign({}, oldInfo, assetInfo);
-			this._setAssetInfo(file, newInfo, oldInfo);
-			return;
-		}
-		this.assets[file] = source;
-		this._setAssetInfo(file, assetInfo, undefined);
+/***/ 66443:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+class HookCodeFactory {
+	constructor(config) {
+		this.config = config;
+		this.options = undefined;
+		this._args = undefined;
 	}
 
-	_setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
-		if (newInfo === undefined) {
-			this.assetsInfo.delete(file);
-		} else {
-			this.assetsInfo.set(file, newInfo);
-		}
-		const oldRelated = oldInfo && oldInfo.related;
-		const newRelated = newInfo && newInfo.related;
-		if (oldRelated) {
-			for (const key of Object.keys(oldRelated)) {
-				const remove = name => {
-					const relatedIn = this._assetsRelatedIn.get(name);
-					if (relatedIn === undefined) return;
-					const entry = relatedIn.get(key);
-					if (entry === undefined) return;
-					entry.delete(file);
-					if (entry.size !== 0) return;
-					relatedIn.delete(key);
-					if (relatedIn.size === 0) this._assetsRelatedIn.delete(name);
-				};
-				const entry = oldRelated[key];
-				if (Array.isArray(entry)) {
-					entry.forEach(remove);
-				} else if (entry) {
-					remove(entry);
+	create(options) {
+		this.init(options);
+		let fn;
+		switch (this.options.type) {
+			case "sync":
+				fn = new Function(
+					this.args(),
+					'"use strict";\n' +
+						this.header() +
+						this.contentWithInterceptors({
+							onError: err => `throw ${err};\n`,
+							onResult: result => `return ${result};\n`,
+							resultReturns: true,
+							onDone: () => "",
+							rethrowIfPossible: true
+						})
+				);
+				break;
+			case "async":
+				fn = new Function(
+					this.args({
+						after: "_callback"
+					}),
+					'"use strict";\n' +
+						this.header() +
+						this.contentWithInterceptors({
+							onError: err => `_callback(${err});\n`,
+							onResult: result => `_callback(null, ${result});\n`,
+							onDone: () => "_callback();\n"
+						})
+				);
+				break;
+			case "promise":
+				let errorHelperUsed = false;
+				const content = this.contentWithInterceptors({
+					onError: err => {
+						errorHelperUsed = true;
+						return `_error(${err});\n`;
+					},
+					onResult: result => `_resolve(${result});\n`,
+					onDone: () => "_resolve();\n"
+				});
+				let code = "";
+				code += '"use strict";\n';
+				code += this.header();
+				code += "return new Promise((function(_resolve, _reject) {\n";
+				if (errorHelperUsed) {
+					code += "var _sync = true;\n";
+					code += "function _error(_err) {\n";
+					code += "if(_sync)\n";
+					code +=
+						"_resolve(Promise.resolve().then((function() { throw _err; })));\n";
+					code += "else\n";
+					code += "_reject(_err);\n";
+					code += "};\n";
 				}
-			}
-		}
-		if (newRelated) {
-			for (const key of Object.keys(newRelated)) {
-				const add = name => {
-					let relatedIn = this._assetsRelatedIn.get(name);
-					if (relatedIn === undefined) {
-						this._assetsRelatedIn.set(name, (relatedIn = new Map()));
-					}
-					let entry = relatedIn.get(key);
-					if (entry === undefined) {
-						relatedIn.set(key, (entry = new Set()));
-					}
-					entry.add(file);
-				};
-				const entry = newRelated[key];
-				if (Array.isArray(entry)) {
-					entry.forEach(add);
-				} else if (entry) {
-					add(entry);
+				code += content;
+				if (errorHelperUsed) {
+					code += "_sync = false;\n";
 				}
-			}
+				code += "}));\n";
+				fn = new Function(this.args(), code);
+				break;
 		}
+		this.deinit();
+		return fn;
+	}
+
+	setup(instance, options) {
+		instance._x = options.taps.map(t => t.fn);
 	}
 
 	/**
-	 * @param {string} file file name
-	 * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
-	 * @param {AssetInfo | function(AssetInfo | undefined): AssetInfo} assetInfoUpdateOrFunction new asset info or function converting old to new
+	 * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
 	 */
-	updateAsset(
-		file,
-		newSourceOrFunction,
-		assetInfoUpdateOrFunction = undefined
-	) {
-		if (!this.assets[file]) {
-			throw new Error(
-				`Called Compilation.updateAsset for not existing filename ${file}`
-			);
-		}
-		if (typeof newSourceOrFunction === "function") {
-			this.assets[file] = newSourceOrFunction(this.assets[file]);
-		} else {
-			this.assets[file] = newSourceOrFunction;
-		}
-		if (assetInfoUpdateOrFunction !== undefined) {
-			const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
-			if (typeof assetInfoUpdateOrFunction === "function") {
-				this._setAssetInfo(file, assetInfoUpdateOrFunction(oldInfo), oldInfo);
-			} else {
-				this._setAssetInfo(
-					file,
-					cachedCleverMerge(oldInfo, assetInfoUpdateOrFunction),
-					oldInfo
-				);
-			}
-		}
+	init(options) {
+		this.options = options;
+		this._args = options.args.slice();
 	}
 
-	renameAsset(file, newFile) {
-		const source = this.assets[file];
-		if (!source) {
-			throw new Error(
-				`Called Compilation.renameAsset for not existing filename ${file}`
-			);
-		}
-		if (this.assets[newFile]) {
-			if (!isSourceEqual(this.assets[file], source)) {
-				this.errors.push(
-					new WebpackError(
-						`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
-					)
-				);
-			}
-		}
-		const assetInfo = this.assetsInfo.get(file);
-		// Update related in all other assets
-		const relatedInInfo = this._assetsRelatedIn.get(file);
-		if (relatedInInfo) {
-			for (const [key, assets] of relatedInInfo) {
-				for (const name of assets) {
-					const info = this.assetsInfo.get(name);
-					if (!info) continue;
-					const related = info.related;
-					if (!related) continue;
-					const entry = related[key];
-					let newEntry;
-					if (Array.isArray(entry)) {
-						newEntry = entry.map(x => (x === file ? newFile : x));
-					} else if (entry === file) {
-						newEntry = newFile;
-					} else continue;
-					this.assetsInfo.set(name, {
-						...info,
-						related: {
-							...related,
-							[key]: newEntry
-						}
-					});
-				}
-			}
-		}
-		this._setAssetInfo(file, undefined, assetInfo);
-		this._setAssetInfo(newFile, assetInfo);
-		delete this.assets[file];
-		this.assets[newFile] = source;
-		for (const chunk of this.chunks) {
-			{
-				const size = chunk.files.size;
-				chunk.files.delete(file);
-				if (size !== chunk.files.size) {
-					chunk.files.add(newFile);
-				}
-			}
-			{
-				const size = chunk.auxiliaryFiles.size;
-				chunk.auxiliaryFiles.delete(file);
-				if (size !== chunk.auxiliaryFiles.size) {
-					chunk.auxiliaryFiles.add(newFile);
-				}
-			}
-		}
+	deinit() {
+		this.options = undefined;
+		this._args = undefined;
 	}
 
-	/**
-	 * @param {string} file file name
-	 */
-	deleteAsset(file) {
-		if (!this.assets[file]) {
-			return;
-		}
-		delete this.assets[file];
-		const assetInfo = this.assetsInfo.get(file);
-		this._setAssetInfo(file, undefined, assetInfo);
-		const related = assetInfo && assetInfo.related;
-		if (related) {
-			for (const key of Object.keys(related)) {
-				const checkUsedAndDelete = file => {
-					if (!this._assetsRelatedIn.has(file)) {
-						this.deleteAsset(file);
-					}
-				};
-				const items = related[key];
-				if (Array.isArray(items)) {
-					items.forEach(checkUsedAndDelete);
-				} else if (items) {
-					checkUsedAndDelete(items);
+	contentWithInterceptors(options) {
+		if (this.options.interceptors.length > 0) {
+			const onError = options.onError;
+			const onResult = options.onResult;
+			const onDone = options.onDone;
+			let code = "";
+			for (let i = 0; i < this.options.interceptors.length; i++) {
+				const interceptor = this.options.interceptors[i];
+				if (interceptor.call) {
+					code += `${this.getInterceptor(i)}.call(${this.args({
+						before: interceptor.context ? "_context" : undefined
+					})});\n`;
 				}
 			}
-		}
-		// TODO If this becomes a performance problem
-		// store a reverse mapping from asset to chunk
-		for (const chunk of this.chunks) {
-			chunk.files.delete(file);
-			chunk.auxiliaryFiles.delete(file);
+			code += this.content(
+				Object.assign(options, {
+					onError:
+						onError &&
+						(err => {
+							let code = "";
+							for (let i = 0; i < this.options.interceptors.length; i++) {
+								const interceptor = this.options.interceptors[i];
+								if (interceptor.error) {
+									code += `${this.getInterceptor(i)}.error(${err});\n`;
+								}
+							}
+							code += onError(err);
+							return code;
+						}),
+					onResult:
+						onResult &&
+						(result => {
+							let code = "";
+							for (let i = 0; i < this.options.interceptors.length; i++) {
+								const interceptor = this.options.interceptors[i];
+								if (interceptor.result) {
+									code += `${this.getInterceptor(i)}.result(${result});\n`;
+								}
+							}
+							code += onResult(result);
+							return code;
+						}),
+					onDone:
+						onDone &&
+						(() => {
+							let code = "";
+							for (let i = 0; i < this.options.interceptors.length; i++) {
+								const interceptor = this.options.interceptors[i];
+								if (interceptor.done) {
+									code += `${this.getInterceptor(i)}.done();\n`;
+								}
+							}
+							code += onDone();
+							return code;
+						})
+				})
+			);
+			return code;
+		} else {
+			return this.content(options);
 		}
 	}
 
-	getAssets() {
-		/** @type {Readonly<Asset>[]} */
-		const array = [];
-		for (const assetName of Object.keys(this.assets)) {
-			if (Object.prototype.hasOwnProperty.call(this.assets, assetName)) {
-				array.push({
-					name: assetName,
-					source: this.assets[assetName],
-					info: this.assetsInfo.get(assetName) || EMPTY_ASSET_INFO
-				});
-			}
+	header() {
+		let code = "";
+		if (this.needContext()) {
+			code += "var _context = {};\n";
+		} else {
+			code += "var _context;\n";
 		}
-		return array;
+		code += "var _x = this._x;\n";
+		if (this.options.interceptors.length > 0) {
+			code += "var _taps = this.taps;\n";
+			code += "var _interceptors = this.interceptors;\n";
+		}
+		return code;
 	}
 
-	/**
-	 * @param {string} name the name of the asset
-	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
-	 */
-	getAsset(name) {
-		if (!Object.prototype.hasOwnProperty.call(this.assets, name))
-			return undefined;
-		return {
-			name,
-			source: this.assets[name],
-			info: this.assetsInfo.get(name) || EMPTY_ASSET_INFO
-		};
+	needContext() {
+		for (const tap of this.options.taps) if (tap.context) return true;
+		return false;
 	}
 
-	clearAssets() {
-		for (const chunk of this.chunks) {
-			chunk.files.clear();
-			chunk.auxiliaryFiles.clear();
+	callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
+		let code = "";
+		let hasTapCached = false;
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.tap) {
+				if (!hasTapCached) {
+					code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};\n`;
+					hasTapCached = true;
+				}
+				code += `${this.getInterceptor(i)}.tap(${
+					interceptor.context ? "_context, " : ""
+				}_tap${tapIndex});\n`;
+			}
 		}
-	}
-
-	createModuleAssets() {
-		const { chunkGraph } = this;
-		for (const module of this.modules) {
-			if (module.buildInfo.assets) {
-				const assetsInfo = module.buildInfo.assetsInfo;
-				for (const assetName of Object.keys(module.buildInfo.assets)) {
-					const fileName = this.getPath(assetName, {
-						chunkGraph: this.chunkGraph,
-						module
-					});
-					for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-						chunk.auxiliaryFiles.add(fileName);
-					}
-					this.emitAsset(
-						fileName,
-						module.buildInfo.assets[assetName],
-						assetsInfo ? assetsInfo.get(assetName) : undefined
-					);
-					this.hooks.moduleAsset.call(module, fileName);
+		code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};\n`;
+		const tap = this.options.taps[tapIndex];
+		switch (tap.type) {
+			case "sync":
+				if (!rethrowIfPossible) {
+					code += `var _hasError${tapIndex} = false;\n`;
+					code += "try {\n";
+				}
+				if (onResult) {
+					code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
+						before: tap.context ? "_context" : undefined
+					})});\n`;
+				} else {
+					code += `_fn${tapIndex}(${this.args({
+						before: tap.context ? "_context" : undefined
+					})});\n`;
+				}
+				if (!rethrowIfPossible) {
+					code += "} catch(_err) {\n";
+					code += `_hasError${tapIndex} = true;\n`;
+					code += onError("_err");
+					code += "}\n";
+					code += `if(!_hasError${tapIndex}) {\n`;
+				}
+				if (onResult) {
+					code += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					code += onDone();
+				}
+				if (!rethrowIfPossible) {
+					code += "}\n";
+				}
+				break;
+			case "async":
+				let cbCode = "";
+				if (onResult)
+					cbCode += `(function(_err${tapIndex}, _result${tapIndex}) {\n`;
+				else cbCode += `(function(_err${tapIndex}) {\n`;
+				cbCode += `if(_err${tapIndex}) {\n`;
+				cbCode += onError(`_err${tapIndex}`);
+				cbCode += "} else {\n";
+				if (onResult) {
+					cbCode += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					cbCode += onDone();
 				}
+				cbCode += "}\n";
+				cbCode += "})";
+				code += `_fn${tapIndex}(${this.args({
+					before: tap.context ? "_context" : undefined,
+					after: cbCode
+				})});\n`;
+				break;
+			case "promise":
+				code += `var _hasResult${tapIndex} = false;\n`;
+				code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
+					before: tap.context ? "_context" : undefined
+				})});\n`;
+				code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)\n`;
+				code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');\n`;
+				code += `_promise${tapIndex}.then((function(_result${tapIndex}) {\n`;
+				code += `_hasResult${tapIndex} = true;\n`;
+				if (onResult) {
+					code += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					code += onDone();
+				}
+				code += `}), function(_err${tapIndex}) {\n`;
+				code += `if(_hasResult${tapIndex}) throw _err${tapIndex};\n`;
+				code += onError(`_err${tapIndex}`);
+				code += "});\n";
+				break;
+		}
+		return code;
+	}
+
+	callTapsSeries({
+		onError,
+		onResult,
+		resultReturns,
+		onDone,
+		doneReturns,
+		rethrowIfPossible
+	}) {
+		if (this.options.taps.length === 0) return onDone();
+		const firstAsync = this.options.taps.findIndex(t => t.type !== "sync");
+		const somethingReturns = resultReturns || doneReturns;
+		let code = "";
+		let current = onDone;
+		let unrollCounter = 0;
+		for (let j = this.options.taps.length - 1; j >= 0; j--) {
+			const i = j;
+			const unroll =
+				current !== onDone &&
+				(this.options.taps[i].type !== "sync" || unrollCounter++ > 20);
+			if (unroll) {
+				unrollCounter = 0;
+				code += `function _next${i}() {\n`;
+				code += current();
+				code += `}\n`;
+				current = () => `${somethingReturns ? "return " : ""}_next${i}();\n`;
 			}
+			const done = current;
+			const doneBreak = skipDone => {
+				if (skipDone) return "";
+				return onDone();
+			};
+			const content = this.callTap(i, {
+				onError: error => onError(i, error, done, doneBreak),
+				onResult:
+					onResult &&
+					(result => {
+						return onResult(i, result, done, doneBreak);
+					}),
+				onDone: !onResult && done,
+				rethrowIfPossible:
+					rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
+			});
+			current = () => content;
 		}
+		code += current();
+		return code;
 	}
 
-	/**
-	 * @param {RenderManifestOptions} options options object
-	 * @returns {RenderManifestEntry[]} manifest entries
-	 */
-	getRenderManifest(options) {
-		return this.hooks.renderManifest.call([], options);
+	callTapsLooping({ onError, onDone, rethrowIfPossible }) {
+		if (this.options.taps.length === 0) return onDone();
+		const syncOnly = this.options.taps.every(t => t.type === "sync");
+		let code = "";
+		if (!syncOnly) {
+			code += "var _looper = (function() {\n";
+			code += "var _loopAsync = false;\n";
+		}
+		code += "var _loop;\n";
+		code += "do {\n";
+		code += "_loop = false;\n";
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.loop) {
+				code += `${this.getInterceptor(i)}.loop(${this.args({
+					before: interceptor.context ? "_context" : undefined
+				})});\n`;
+			}
+		}
+		code += this.callTapsSeries({
+			onError,
+			onResult: (i, result, next, doneBreak) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += "_loop = true;\n";
+				if (!syncOnly) code += "if(_loopAsync) _looper();\n";
+				code += doneBreak(true);
+				code += `} else {\n`;
+				code += next();
+				code += `}\n`;
+				return code;
+			},
+			onDone:
+				onDone &&
+				(() => {
+					let code = "";
+					code += "if(!_loop) {\n";
+					code += onDone();
+					code += "}\n";
+					return code;
+				}),
+			rethrowIfPossible: rethrowIfPossible && syncOnly
+		});
+		code += "} while(_loop);\n";
+		if (!syncOnly) {
+			code += "_loopAsync = true;\n";
+			code += "});\n";
+			code += "_looper();\n";
+		}
+		return code;
 	}
 
-	/**
-	 * @param {Callback} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	createChunkAssets(callback) {
-		const outputOptions = this.outputOptions;
-		const cachedSourceMap = new WeakMap();
-		/** @type {Map<string, {hash: string, source: Source, chunk: Chunk}>} */
-		const alreadyWrittenFiles = new Map();
+	callTapsParallel({
+		onError,
+		onResult,
+		onDone,
+		rethrowIfPossible,
+		onTap = (i, run) => run()
+	}) {
+		if (this.options.taps.length <= 1) {
+			return this.callTapsSeries({
+				onError,
+				onResult,
+				onDone,
+				rethrowIfPossible
+			});
+		}
+		let code = "";
+		code += "do {\n";
+		code += `var _counter = ${this.options.taps.length};\n`;
+		if (onDone) {
+			code += "var _done = (function() {\n";
+			code += onDone();
+			code += "});\n";
+		}
+		for (let i = 0; i < this.options.taps.length; i++) {
+			const done = () => {
+				if (onDone) return "if(--_counter === 0) _done();\n";
+				else return "--_counter;";
+			};
+			const doneBreak = skipDone => {
+				if (skipDone || !onDone) return "_counter = 0;\n";
+				else return "_counter = 0;\n_done();\n";
+			};
+			code += "if(_counter <= 0) break;\n";
+			code += onTap(
+				i,
+				() =>
+					this.callTap(i, {
+						onError: error => {
+							let code = "";
+							code += "if(_counter > 0) {\n";
+							code += onError(i, error, done, doneBreak);
+							code += "}\n";
+							return code;
+						},
+						onResult:
+							onResult &&
+							(result => {
+								let code = "";
+								code += "if(_counter > 0) {\n";
+								code += onResult(i, result, done, doneBreak);
+								code += "}\n";
+								return code;
+							}),
+						onDone:
+							!onResult &&
+							(() => {
+								return done();
+							}),
+						rethrowIfPossible
+					}),
+				done,
+				doneBreak
+			);
+		}
+		code += "} while(false);\n";
+		return code;
+	}
 
-		asyncLib.forEachLimit(
-			this.chunks,
-			15,
-			(chunk, callback) => {
-				/** @type {RenderManifestEntry[]} */
-				let manifest;
-				try {
-					manifest = this.getRenderManifest({
-						chunk,
-						hash: this.hash,
-						fullHash: this.fullHash,
-						outputOptions,
-						codeGenerationResults: this.codeGenerationResults,
-						moduleTemplates: this.moduleTemplates,
-						dependencyTemplates: this.dependencyTemplates,
-						chunkGraph: this.chunkGraph,
-						moduleGraph: this.moduleGraph,
-						runtimeTemplate: this.runtimeTemplate
-					});
-				} catch (err) {
-					this.errors.push(new ChunkRenderError(chunk, "", err));
-					return callback();
-				}
-				asyncLib.forEach(
-					manifest,
-					(fileManifest, callback) => {
-						const ident = fileManifest.identifier;
-						const usedHash = fileManifest.hash;
+	args({ before, after } = {}) {
+		let allArgs = this._args;
+		if (before) allArgs = [before].concat(allArgs);
+		if (after) allArgs = allArgs.concat(after);
+		if (allArgs.length === 0) {
+			return "";
+		} else {
+			return allArgs.join(", ");
+		}
+	}
 
-						const assetCacheItem = this._assetsCache.getItemCache(
-							ident,
-							usedHash
-						);
+	getTapFn(idx) {
+		return `_x[${idx}]`;
+	}
 
-						assetCacheItem.get((err, sourceFromCache) => {
-							/** @type {string | function(PathData, AssetInfo=): string} */
-							let filenameTemplate;
-							/** @type {string} */
-							let file;
-							/** @type {AssetInfo} */
-							let assetInfo;
+	getTap(idx) {
+		return `_taps[${idx}]`;
+	}
 
-							let inTry = true;
-							const errorAndCallback = err => {
-								const filename =
-									file ||
-									(typeof file === "string"
-										? file
-										: typeof filenameTemplate === "string"
-										? filenameTemplate
-										: "");
+	getInterceptor(idx) {
+		return `_interceptors[${idx}]`;
+	}
+}
 
-								this.errors.push(new ChunkRenderError(chunk, filename, err));
-								inTry = false;
-								return callback();
-							};
+module.exports = HookCodeFactory;
 
-							try {
-								if ("filename" in fileManifest) {
-									file = fileManifest.filename;
-									assetInfo = fileManifest.info;
-								} else {
-									filenameTemplate = fileManifest.filenameTemplate;
-									const pathAndInfo = this.getPathWithInfo(
-										filenameTemplate,
-										fileManifest.pathOptions
-									);
-									file = pathAndInfo.path;
-									assetInfo = fileManifest.info
-										? {
-												...pathAndInfo.info,
-												...fileManifest.info
-										  }
-										: pathAndInfo.info;
-								}
 
-								if (err) {
-									return errorAndCallback(err);
-								}
+/***/ }),
 
-								let source = sourceFromCache;
+/***/ 77079:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-								// check if the same filename was already written by another chunk
-								const alreadyWritten = alreadyWrittenFiles.get(file);
-								if (alreadyWritten !== undefined) {
-									if (alreadyWritten.hash !== usedHash) {
-										inTry = false;
-										return callback(
-											new WebpackError(
-												`Conflict: Multiple chunks emit assets to the same filename ${file}` +
-													` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
-											)
-										);
-									} else {
-										source = alreadyWritten.source;
-									}
-								} else if (!source) {
-									// render the asset
-									source = fileManifest.render();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-									// Ensure that source is a cached source to avoid additional cost because of repeated access
-									if (!(source instanceof CachedSource)) {
-										const cacheEntry = cachedSourceMap.get(source);
-										if (cacheEntry) {
-											source = cacheEntry;
-										} else {
-											const cachedSource = new CachedSource(source);
-											cachedSourceMap.set(source, cachedSource);
-											source = cachedSource;
-										}
-									}
-								}
-								this.emitAsset(file, source, assetInfo);
-								if (fileManifest.auxiliary) {
-									chunk.auxiliaryFiles.add(file);
-								} else {
-									chunk.files.add(file);
-								}
-								this.hooks.chunkAsset.call(chunk, file);
-								alreadyWrittenFiles.set(file, {
-									hash: usedHash,
-									source,
-									chunk
-								});
-								if (source !== sourceFromCache) {
-									assetCacheItem.store(source, err => {
-										if (err) return errorAndCallback(err);
-										inTry = false;
-										return callback();
-									});
-								} else {
-									inTry = false;
-									callback();
-								}
-							} catch (err) {
-								if (!inTry) throw err;
-								errorAndCallback(err);
-							}
-						});
-					},
-					callback
-				);
-			},
-			callback
-		);
+
+const util = __webpack_require__(73837);
+
+const defaultFactory = (key, hook) => hook;
+
+class HookMap {
+	constructor(factory, name = undefined) {
+		this._map = new Map();
+		this.name = name;
+		this._factory = factory;
+		this._interceptors = [];
 	}
 
-	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {string} interpolated path
-	 */
-	getPath(filename, data = {}) {
-		if (!data.hash) {
-			data = {
-				hash: this.hash,
-				...data
-			};
-		}
-		return this.getAssetPath(filename, data);
+	get(key) {
+		return this._map.get(key);
 	}
 
-	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
-	 */
-	getPathWithInfo(filename, data = {}) {
-		if (!data.hash) {
-			data = {
-				hash: this.hash,
-				...data
-			};
+	for(key) {
+		const hook = this.get(key);
+		if (hook !== undefined) {
+			return hook;
 		}
-		return this.getAssetPathWithInfo(filename, data);
+		let newHook = this._factory(key);
+		const interceptors = this._interceptors;
+		for (let i = 0; i < interceptors.length; i++) {
+			newHook = interceptors[i].factory(key, newHook);
+		}
+		this._map.set(key, newHook);
+		return newHook;
 	}
 
-	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {string} interpolated path
-	 */
-	getAssetPath(filename, data) {
-		return this.hooks.assetPath.call(
-			typeof filename === "function" ? filename(data) : filename,
-			data,
-			undefined
+	intercept(interceptor) {
+		this._interceptors.push(
+			Object.assign(
+				{
+					factory: defaultFactory
+				},
+				interceptor
+			)
 		);
 	}
+}
 
-	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
-	 */
-	getAssetPathWithInfo(filename, data) {
-		const assetInfo = {};
-		// TODO webpack 5: refactor assetPath hook to receive { path, info } object
-		const newPath = this.hooks.assetPath.call(
-			typeof filename === "function" ? filename(data, assetInfo) : filename,
-			data,
-			assetInfo
-		);
-		return { path: newPath, info: assetInfo };
+HookMap.prototype.tap = util.deprecate(function(key, options, fn) {
+	return this.for(key).tap(options, fn);
+}, "HookMap#tap(key,…) is deprecated. Use HookMap#for(key).tap(…) instead.");
+
+HookMap.prototype.tapAsync = util.deprecate(function(key, options, fn) {
+	return this.for(key).tapAsync(options, fn);
+}, "HookMap#tapAsync(key,…) is deprecated. Use HookMap#for(key).tapAsync(…) instead.");
+
+HookMap.prototype.tapPromise = util.deprecate(function(key, options, fn) {
+	return this.for(key).tapPromise(options, fn);
+}, "HookMap#tapPromise(key,…) is deprecated. Use HookMap#for(key).tapPromise(…) instead.");
+
+module.exports = HookMap;
+
+
+/***/ }),
+
+/***/ 13103:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+const Hook = __webpack_require__(21468);
+
+class MultiHook {
+	constructor(hooks, name = undefined) {
+		this.hooks = hooks;
+		this.name = name;
 	}
 
-	getWarnings() {
-		return this.hooks.processWarnings.call(this.warnings);
+	tap(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tap(options, fn);
+		}
 	}
 
-	getErrors() {
-		return this.hooks.processErrors.call(this.errors);
+	tapAsync(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapAsync(options, fn);
+		}
 	}
 
-	/**
-	 * This function allows you to run another instance of webpack inside of webpack however as
-	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
-	 * from parent (or top level compiler) and creates a child Compilation
-	 *
-	 * @param {string} name name of the child compiler
-	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
-	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
-	 * @returns {Compiler} creates a child Compiler instance
-	 */
-	createChildCompiler(name, outputOptions, plugins) {
-		const idx = this.childrenCounters[name] || 0;
-		this.childrenCounters[name] = idx + 1;
-		return this.compiler.createChildCompiler(
-			this,
-			name,
-			idx,
-			outputOptions,
-			plugins
+	tapPromise(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapPromise(options, fn);
+		}
+	}
+
+	isUsed() {
+		for (const hook of this.hooks) {
+			if (hook.isUsed()) return true;
+		}
+		return false;
+	}
+
+	intercept(interceptor) {
+		for (const hook of this.hooks) {
+			hook.intercept(interceptor);
+		}
+	}
+
+	withOptions(options) {
+		return new MultiHook(
+			this.hooks.map(h => h.withOptions(options)),
+			this.name
 		);
 	}
+}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {ExecuteModuleOptions} options options
-	 * @param {ExecuteModuleCallback} callback callback
-	 */
-	executeModule(module, options, callback) {
-		// Aggregate all referenced modules and ensure they are ready
-		const modules = new Set([module]);
-		processAsyncTree(
-			modules,
-			10,
-			/**
-			 * @param {Module} module the module
-			 * @param {function(Module): void} push push more jobs
-			 * @param {Callback} callback callback
-			 * @returns {void}
-			 */
-			(module, push, callback) => {
-				this.buildQueue.waitFor(module, err => {
-					if (err) return callback(err);
-					this.processDependenciesQueue.waitFor(module, err => {
-						if (err) return callback(err);
-						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
-							module
-						)) {
-							const size = modules.size;
-							modules.add(m);
-							if (modules.size !== size) push(m);
-						}
-						callback();
-					});
-				});
-			},
-			err => {
-				if (err) return callback(err);
+module.exports = MultiHook;
 
-				// Create new chunk graph, chunk and entrypoint for the build time execution
-				const chunkGraph = new ChunkGraph(
-					this.moduleGraph,
-					this.outputOptions.hashFunction
-				);
-				const runtime = "build time";
-				const { hashFunction, hashDigest, hashDigestLength } =
-					this.outputOptions;
-				const runtimeTemplate = this.runtimeTemplate;
 
-				const chunk = new Chunk("build time chunk", this._backCompat);
-				chunk.id = chunk.name;
-				chunk.ids = [chunk.id];
-				chunk.runtime = runtime;
+/***/ }),
 
-				const entrypoint = new Entrypoint({
-					runtime,
-					chunkLoading: false,
-					...options.entryOptions
-				});
-				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-				connectChunkGroupAndChunk(entrypoint, chunk);
-				entrypoint.setRuntimeChunk(chunk);
-				entrypoint.setEntrypointChunk(chunk);
+/***/ 1626:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				const chunks = new Set([chunk]);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				// Assign ids to modules and modules to the chunk
-				for (const module of modules) {
-					const id = module.identifier();
-					chunkGraph.setModuleId(module, id);
-					chunkGraph.connectChunkAndModule(chunk, module);
-				}
 
-				// Hash modules
-				for (const module of modules) {
-					this._createModuleHash(
-						module,
-						chunkGraph,
-						runtime,
-						hashFunction,
-						runtimeTemplate,
-						hashDigest,
-						hashDigestLength
-					);
-				}
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-				const codeGenerationResults = new CodeGenerationResults(
-					this.outputOptions.hashFunction
-				);
-				/** @type {WebpackError[]} */
-				const errors = [];
-				/**
-				 * @param {Module} module the module
-				 * @param {Callback} callback callback
-				 * @returns {void}
-				 */
-				const codeGen = (module, callback) => {
-					this._codeGenerationModule(
-						module,
-						runtime,
-						[runtime],
-						chunkGraph.getModuleHash(module, runtime),
-						this.dependencyTemplates,
-						chunkGraph,
-						this.moduleGraph,
-						runtimeTemplate,
-						errors,
-						codeGenerationResults,
-						(err, codeGenerated) => {
-							callback(err);
-						}
-					);
-				};
+class SyncBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)};\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
 
-				const reportErrors = () => {
-					if (errors.length > 0) {
-						errors.sort(
-							compareSelect(err => err.module, compareModulesByIdentifier)
-						);
-						for (const error of errors) {
-							this.errors.push(error);
-						}
-						errors.length = 0;
-					}
-				};
+const factory = new SyncBailHookCodeFactory();
 
-				// Generate code for all aggregated modules
-				asyncLib.eachLimit(modules, 10, codeGen, err => {
-					if (err) return callback(err);
-					reportErrors();
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncBailHook");
+};
 
-					// for backward-compat temporary set the chunk graph
-					// TODO webpack 6
-					const old = this.chunkGraph;
-					this.chunkGraph = chunkGraph;
-					this.processRuntimeRequirements({
-						chunkGraph,
-						modules,
-						chunks,
-						codeGenerationResults,
-						chunkGraphEntries: chunks
-					});
-					this.chunkGraph = old;
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncBailHook");
+};
 
-					const runtimeModules =
-						chunkGraph.getChunkRuntimeModulesIterable(chunk);
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-					// Hash runtime modules
-					for (const module of runtimeModules) {
-						modules.add(module);
-						this._createModuleHash(
-							module,
-							chunkGraph,
-							runtime,
-							hashFunction,
-							runtimeTemplate,
-							hashDigest,
-							hashDigestLength
-						);
-					}
+function SyncBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncBailHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
 
-					// Generate code for all runtime modules
-					asyncLib.eachLimit(runtimeModules, 10, codeGen, err => {
-						if (err) return callback(err);
-						reportErrors();
+SyncBailHook.prototype = null;
 
-						/** @type {Map<Module, ExecuteModuleArgument>} */
-						const moduleArgumentsMap = new Map();
-						/** @type {Map<string, ExecuteModuleArgument>} */
-						const moduleArgumentsById = new Map();
+module.exports = SyncBailHook;
 
-						/** @type {ExecuteModuleResult["fileDependencies"]} */
-						const fileDependencies = new LazySet();
-						/** @type {ExecuteModuleResult["contextDependencies"]} */
-						const contextDependencies = new LazySet();
-						/** @type {ExecuteModuleResult["missingDependencies"]} */
-						const missingDependencies = new LazySet();
-						/** @type {ExecuteModuleResult["buildDependencies"]} */
-						const buildDependencies = new LazySet();
 
-						/** @type {ExecuteModuleResult["assets"]} */
-						const assets = new Map();
+/***/ }),
 
-						let cacheable = true;
+/***/ 69689:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						/** @type {ExecuteModuleContext} */
-						const context = {
-							assets,
-							__webpack_require__: undefined,
-							chunk,
-							chunkGraph
-						};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						// Prepare execution
-						asyncLib.eachLimit(
-							modules,
-							10,
-							(module, callback) => {
-								const codeGenerationResult = codeGenerationResults.get(
-									module,
-									runtime
-								);
-								/** @type {ExecuteModuleArgument} */
-								const moduleArgument = {
-									module,
-									codeGenerationResult,
-									preparedInfo: undefined,
-									moduleObject: undefined
-								};
-								moduleArgumentsMap.set(module, moduleArgument);
-								moduleArgumentsById.set(module.identifier(), moduleArgument);
-								module.addCacheDependencies(
-									fileDependencies,
-									contextDependencies,
-									missingDependencies,
-									buildDependencies
-								);
-								if (module.buildInfo.cacheable === false) {
-									cacheable = false;
-								}
-								if (module.buildInfo && module.buildInfo.assets) {
-									const { assets: moduleAssets, assetsInfo } = module.buildInfo;
-									for (const assetName of Object.keys(moduleAssets)) {
-										assets.set(assetName, {
-											source: moduleAssets[assetName],
-											info: assetsInfo ? assetsInfo.get(assetName) : undefined
-										});
-									}
-								}
-								this.hooks.prepareModuleExecution.callAsync(
-									moduleArgument,
-									context,
-									callback
-								);
-							},
-							err => {
-								if (err) return callback(err);
 
-								let exports;
-								try {
-									const {
-										strictModuleErrorHandling,
-										strictModuleExceptionHandling
-									} = this.outputOptions;
-									const __nested_webpack_require_152290__ = id => {
-										const cached = moduleCache[id];
-										if (cached !== undefined) {
-											if (cached.error) throw cached.error;
-											return cached.exports;
-										}
-										const moduleArgument = moduleArgumentsById.get(id);
-										return __webpack_require_module__(moduleArgument, id);
-									};
-									const interceptModuleExecution = (__nested_webpack_require_152290__[
-										RuntimeGlobals.interceptModuleExecution.replace(
-											"__webpack_require__.",
-											""
-										)
-									] = []);
-									const moduleCache = (__nested_webpack_require_152290__[
-										RuntimeGlobals.moduleCache.replace(
-											"__webpack_require__.",
-											""
-										)
-									] = {});
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-									context.__webpack_require__ = __nested_webpack_require_152290__;
+class SyncHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
 
-									/**
-									 * @param {ExecuteModuleArgument} moduleArgument the module argument
-									 * @param {string=} id id
-									 * @returns {any} exports
-									 */
-									const __webpack_require_module__ = (moduleArgument, id) => {
-										var execOptions = {
-											id,
-											module: {
-												id,
-												exports: {},
-												loaded: false,
-												error: undefined
-											},
-											require: __nested_webpack_require_152290__
-										};
-										interceptModuleExecution.forEach(handler =>
-											handler(execOptions)
-										);
-										const module = moduleArgument.module;
-										this.buildTimeExecutedModules.add(module);
-										const moduleObject = execOptions.module;
-										moduleArgument.moduleObject = moduleObject;
-										try {
-											if (id) moduleCache[id] = moduleObject;
+const factory = new SyncHookCodeFactory();
 
-											tryRunOrWebpackError(
-												() =>
-													this.hooks.executeModule.call(
-														moduleArgument,
-														context
-													),
-												"Compilation.hooks.executeModule"
-											);
-											moduleObject.loaded = true;
-											return moduleObject.exports;
-										} catch (e) {
-											if (strictModuleExceptionHandling) {
-												if (id) delete moduleCache[id];
-											} else if (strictModuleErrorHandling) {
-												moduleObject.error = e;
-											}
-											if (!e.module) e.module = module;
-											throw e;
-										}
-									};
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncHook");
+};
 
-									for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
-										chunk
-									)) {
-										__webpack_require_module__(
-											moduleArgumentsMap.get(runtimeModule)
-										);
-									}
-									exports = __nested_webpack_require_152290__(module.identifier());
-								} catch (e) {
-									const err = new WebpackError(
-										`Execution of module code from module graph (${module.readableIdentifier(
-											this.requestShortener
-										)}) failed: ${e.message}`
-									);
-									err.stack = e.stack;
-									err.module = e.module;
-									return callback(err);
-								}
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncHook");
+};
 
-								callback(null, {
-									exports,
-									assets,
-									cacheable,
-									fileDependencies,
-									contextDependencies,
-									missingDependencies,
-									buildDependencies
-								});
-							}
-						);
-					});
-				});
-			}
-		);
-	}
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-	checkConstraints() {
-		const chunkGraph = this.chunkGraph;
+function SyncHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
 
-		/** @type {Set<number|string>} */
-		const usedIds = new Set();
+SyncHook.prototype = null;
 
-		for (const module of this.modules) {
-			if (module.type === "runtime") continue;
-			const moduleId = chunkGraph.getModuleId(module);
-			if (moduleId === null) continue;
-			if (usedIds.has(moduleId)) {
-				throw new Error(`checkConstraints: duplicate module id ${moduleId}`);
-			}
-			usedIds.add(moduleId);
-		}
+module.exports = SyncHook;
 
-		for (const chunk of this.chunks) {
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!this.modules.has(module)) {
-					throw new Error(
-						"checkConstraints: module in chunk but not in compilation " +
-							` ${chunk.debugId} ${module.debugId}`
-					);
-				}
-			}
-			for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
-				if (!this.modules.has(module)) {
-					throw new Error(
-						"checkConstraints: entry module in chunk but not in compilation " +
-							` ${chunk.debugId} ${module.debugId}`
-					);
-				}
-			}
-		}
 
-		for (const chunkGroup of this.chunkGroups) {
-			chunkGroup.checkConstraints();
-		}
-	}
-}
+/***/ }),
 
-/**
- * @typedef {Object} FactorizeModuleOptions
- * @property {ModuleProfile} currentProfile
- * @property {ModuleFactory} factory
- * @property {Dependency[]} dependencies
- * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module
- * @property {Module | null} originModule
- * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
- * @property {string=} context
- */
+/***/ 50179:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * @param {FactorizeModuleOptions} options options object
- * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
- * @returns {void}
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-// Workaround for typescript as it doesn't support function overloading in jsdoc within a class
-Compilation.prototype.factorizeModule = /** @type {{
-	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
-	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
-}} */ (
-	function (options, callback) {
-		this.factorizeQueue.add(options, callback);
-	}
-);
 
-// Hide from typescript
-const compilationPrototype = Compilation.prototype;
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-// TODO webpack 6 remove
-Object.defineProperty(compilationPrototype, "modifyHash", {
-	writable: false,
-	enumerable: false,
-	configurable: false,
-	value: () => {
-		throw new Error(
-			"Compilation.modifyHash was removed in favor of Compilation.hooks.fullHash"
-		);
+class SyncLoopHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsLooping({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
 	}
-});
-
-// TODO webpack 6 remove
-Object.defineProperty(compilationPrototype, "cache", {
-	enumerable: false,
-	configurable: false,
-	get: util.deprecate(
-		/**
-		 * @this {Compilation} the compilation
-		 * @returns {Cache} the cache
-		 */
-		function () {
-			return this.compiler.cache;
-		},
-		"Compilation.cache was removed in favor of Compilation.getCache()",
-		"DEP_WEBPACK_COMPILATION_CACHE"
-	),
-	set: util.deprecate(
-		v => {},
-		"Compilation.cache was removed in favor of Compilation.getCache()",
-		"DEP_WEBPACK_COMPILATION_CACHE"
-	)
-});
-
-/**
- * Add additional assets to the compilation.
- */
-Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000;
-
-/**
- * Basic preprocessing of assets.
- */
-Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1000;
-
-/**
- * Derive new assets from existing assets.
- * Existing assets should not be treated as complete.
- */
-Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200;
-
-/**
- * Add additional sections to existing assets, like a banner or initialization code.
- */
-Compilation.PROCESS_ASSETS_STAGE_ADDITIONS = -100;
-
-/**
- * Optimize existing assets in a general way.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100;
-
-/**
- * Optimize the count of existing assets, e. g. by merging them.
- * Only assets of the same type should be merged.
- * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200;
-
-/**
- * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300;
-
-/**
- * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400;
-
-/**
- * Add development tooling to assets, e. g. by extracting a SourceMap.
- */
-Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500;
+}
 
-/**
- * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
- * Only assets of different types should be inlined.
- * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700;
+const factory = new SyncLoopHookCodeFactory();
 
-/**
- * Summarize the list of existing assets
- * e. g. creating an assets manifest of Service Workers.
- */
-Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncLoopHook");
+};
 
-/**
- * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncLoopHook");
+};
 
-/**
- * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-/**
- * Analyse existing assets.
- */
-Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
+function SyncLoopHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncLoopHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
 
-/**
- * Creating assets for reporting purposes.
- */
-Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
+SyncLoopHook.prototype = null;
 
-module.exports = Compilation;
+module.exports = SyncLoopHook;
 
 
 /***/ }),
 
-/***/ 70845:
+/***/ 36093:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -27575,1223 +24008,928 @@ module.exports = Compilation;
 */
 
 
+const Hook = __webpack_require__(21468);
+const HookCodeFactory = __webpack_require__(66443);
 
-const parseJson = __webpack_require__(15235);
-const asyncLib = __webpack_require__(78175);
-const {
-	SyncHook,
-	SyncBailHook,
-	AsyncParallelHook,
-	AsyncSeriesHook
-} = __webpack_require__(6967);
-const { SizeOnlySource } = __webpack_require__(51255);
-const webpack = __webpack_require__(91919);
-const Cache = __webpack_require__(7592);
-const CacheFacade = __webpack_require__(55392);
-const ChunkGraph = __webpack_require__(64971);
-const Compilation = __webpack_require__(85720);
-const ConcurrentCompilationError = __webpack_require__(95735);
-const ContextModuleFactory = __webpack_require__(62471);
-const ModuleGraph = __webpack_require__(99988);
-const NormalModuleFactory = __webpack_require__(68860);
-const RequestShortener = __webpack_require__(73406);
-const ResolverFactory = __webpack_require__(30217);
-const Stats = __webpack_require__(31743);
-const Watching = __webpack_require__(84275);
-const WebpackError = __webpack_require__(53799);
-const { Logger } = __webpack_require__(32597);
-const { join, dirname, mkdirp } = __webpack_require__(17139);
-const { makePathsRelative } = __webpack_require__(82186);
-const { isSourceEqual } = __webpack_require__(41245);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
-
-/**
- * @typedef {Object} CompilationParams
- * @property {NormalModuleFactory} normalModuleFactory
- * @property {ContextModuleFactory} contextModuleFactory
- */
-
-/**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
- */
-
-/**
- * @callback RunAsChildCallback
- * @param {(Error | null)=} err
- * @param {Chunk[]=} entries
- * @param {Compilation=} compilation
- */
+class SyncWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0]),
+			doneReturns: resultReturns,
+			rethrowIfPossible
+		});
+	}
+}
 
-/**
- * @typedef {Object} AssetEmittedInfo
- * @property {Buffer} content
- * @property {Source} source
- * @property {Compilation} compilation
- * @property {string} outputPath
- * @property {string} targetPath
- */
+const factory = new SyncWaterfallHookCodeFactory();
 
-/**
- * @param {string[]} array an array
- * @returns {boolean} true, if the array is sorted
- */
-const isSorted = array => {
-	for (let i = 1; i < array.length; i++) {
-		if (array[i - 1] > array[i]) return false;
-	}
-	return true;
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncWaterfallHook");
 };
 
-/**
- * @param {Object} obj an object
- * @param {string[]} keys the keys of the object
- * @returns {Object} the object with properties sorted by property name
- */
-const sortObject = (obj, keys) => {
-	const o = {};
-	for (const k of keys.sort()) {
-		o[k] = obj[k];
-	}
-	return o;
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncWaterfallHook");
 };
 
-/**
- * @param {string} filename filename
- * @param {string | string[] | undefined} hashes list of hashes
- * @returns {boolean} true, if the filename contains any hash
- */
-const includesHash = (filename, hashes) => {
-	if (!hashes) return false;
-	if (Array.isArray(hashes)) {
-		return hashes.some(hash => filename.includes(hash));
-	} else {
-		return filename.includes(hashes);
-	}
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
 };
 
-class Compiler {
-	/**
-	 * @param {string} context the compilation path
-	 * @param {WebpackOptions} options options
-	 */
-	constructor(context, options = /** @type {WebpackOptions} */ ({})) {
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[]>} */
-			initialize: new SyncHook([]),
-
-			/** @type {SyncBailHook<[Compilation], boolean>} */
-			shouldEmit: new SyncBailHook(["compilation"]),
-			/** @type {AsyncSeriesHook<[Stats]>} */
-			done: new AsyncSeriesHook(["stats"]),
-			/** @type {SyncHook<[Stats]>} */
-			afterDone: new SyncHook(["stats"]),
-			/** @type {AsyncSeriesHook<[]>} */
-			additionalPass: new AsyncSeriesHook([]),
-			/** @type {AsyncSeriesHook<[Compiler]>} */
-			beforeRun: new AsyncSeriesHook(["compiler"]),
-			/** @type {AsyncSeriesHook<[Compiler]>} */
-			run: new AsyncSeriesHook(["compiler"]),
-			/** @type {AsyncSeriesHook<[Compilation]>} */
-			emit: new AsyncSeriesHook(["compilation"]),
-			/** @type {AsyncSeriesHook<[string, AssetEmittedInfo]>} */
-			assetEmitted: new AsyncSeriesHook(["file", "info"]),
-			/** @type {AsyncSeriesHook<[Compilation]>} */
-			afterEmit: new AsyncSeriesHook(["compilation"]),
-
-			/** @type {SyncHook<[Compilation, CompilationParams]>} */
-			thisCompilation: new SyncHook(["compilation", "params"]),
-			/** @type {SyncHook<[Compilation, CompilationParams]>} */
-			compilation: new SyncHook(["compilation", "params"]),
-			/** @type {SyncHook<[NormalModuleFactory]>} */
-			normalModuleFactory: new SyncHook(["normalModuleFactory"]),
-			/** @type {SyncHook<[ContextModuleFactory]>}  */
-			contextModuleFactory: new SyncHook(["contextModuleFactory"]),
-
-			/** @type {AsyncSeriesHook<[CompilationParams]>} */
-			beforeCompile: new AsyncSeriesHook(["params"]),
-			/** @type {SyncHook<[CompilationParams]>} */
-			compile: new SyncHook(["params"]),
-			/** @type {AsyncParallelHook<[Compilation]>} */
-			make: new AsyncParallelHook(["compilation"]),
-			/** @type {AsyncParallelHook<[Compilation]>} */
-			finishMake: new AsyncSeriesHook(["compilation"]),
-			/** @type {AsyncSeriesHook<[Compilation]>} */
-			afterCompile: new AsyncSeriesHook(["compilation"]),
-
-			/** @type {AsyncSeriesHook<[]>} */
-			readRecords: new AsyncSeriesHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
-			emitRecords: new AsyncSeriesHook([]),
-
-			/** @type {AsyncSeriesHook<[Compiler]>} */
-			watchRun: new AsyncSeriesHook(["compiler"]),
-			/** @type {SyncHook<[Error]>} */
-			failed: new SyncHook(["error"]),
-			/** @type {SyncHook<[string | null, number]>} */
-			invalid: new SyncHook(["filename", "changeTime"]),
-			/** @type {SyncHook<[]>} */
-			watchClose: new SyncHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
-			shutdown: new AsyncSeriesHook([]),
-
-			/** @type {SyncBailHook<[string, string, any[]], true>} */
-			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
-
-			// TODO the following hooks are weirdly located here
-			// TODO move them for webpack 5
-			/** @type {SyncHook<[]>} */
-			environment: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterEnvironment: new SyncHook([]),
-			/** @type {SyncHook<[Compiler]>} */
-			afterPlugins: new SyncHook(["compiler"]),
-			/** @type {SyncHook<[Compiler]>} */
-			afterResolvers: new SyncHook(["compiler"]),
-			/** @type {SyncBailHook<[string, Entry], boolean>} */
-			entryOption: new SyncBailHook(["context", "entry"])
-		});
-
-		this.webpack = webpack;
-
-		/** @type {string=} */
-		this.name = undefined;
-		/** @type {Compilation=} */
-		this.parentCompilation = undefined;
-		/** @type {Compiler} */
-		this.root = this;
-		/** @type {string} */
-		this.outputPath = "";
-		/** @type {Watching} */
-		this.watching = undefined;
-
-		/** @type {OutputFileSystem} */
-		this.outputFileSystem = null;
-		/** @type {IntermediateFileSystem} */
-		this.intermediateFileSystem = null;
-		/** @type {InputFileSystem} */
-		this.inputFileSystem = null;
-		/** @type {WatchFileSystem} */
-		this.watchFileSystem = null;
+function SyncWaterfallHook(args = [], name = undefined) {
+	if (args.length < 1)
+		throw new Error("Waterfall hooks must have at least one argument");
+	const hook = new Hook(args, name);
+	hook.constructor = SyncWaterfallHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
 
-		/** @type {string|null} */
-		this.recordsInputPath = null;
-		/** @type {string|null} */
-		this.recordsOutputPath = null;
-		this.records = {};
-		/** @type {Set<string | RegExp>} */
-		this.managedPaths = new Set();
-		/** @type {Set<string | RegExp>} */
-		this.immutablePaths = new Set();
+SyncWaterfallHook.prototype = null;
 
-		/** @type {ReadonlySet<string>} */
-		this.modifiedFiles = undefined;
-		/** @type {ReadonlySet<string>} */
-		this.removedFiles = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
-		this.fileTimestamps = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
-		this.contextTimestamps = undefined;
-		/** @type {number} */
-		this.fsStartTime = undefined;
+module.exports = SyncWaterfallHook;
 
-		/** @type {ResolverFactory} */
-		this.resolverFactory = new ResolverFactory();
 
-		this.infrastructureLogger = undefined;
+/***/ }),
 
-		this.options = options;
+/***/ 41242:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-		this.context = context;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		this.requestShortener = new RequestShortener(context, this.root);
 
-		this.cache = new Cache();
+exports.__esModule = true;
+exports.SyncHook = __webpack_require__(69689);
+exports.SyncBailHook = __webpack_require__(1626);
+exports.SyncWaterfallHook = __webpack_require__(36093);
+exports.SyncLoopHook = __webpack_require__(50179);
+exports.AsyncParallelHook = __webpack_require__(31684);
+exports.AsyncParallelBailHook = __webpack_require__(18151);
+exports.AsyncSeriesHook = __webpack_require__(96496);
+exports.AsyncSeriesBailHook = __webpack_require__(95734);
+exports.AsyncSeriesLoopHook = __webpack_require__(95999);
+exports.AsyncSeriesWaterfallHook = __webpack_require__(58118);
+exports.HookMap = __webpack_require__(77079);
+exports.MultiHook = __webpack_require__(13103);
 
-		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
-		this.moduleMemCaches = undefined;
 
-		this.compilerPath = "";
+/***/ }),
 
-		/** @type {boolean} */
-		this.running = false;
+/***/ 74315:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		/** @type {boolean} */
-		this.idle = false;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		/** @type {boolean} */
-		this.watchMode = false;
 
-		this._backCompat = this.options.experiments.backCompat !== false;
 
-		/** @type {Compilation} */
-		this._lastCompilation = undefined;
-		/** @type {NormalModuleFactory} */
-		this._lastNormalModuleFactory = undefined;
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const ConstDependency = __webpack_require__(76911);
+const BasicEvaluatedExpression = __webpack_require__(950);
+const {
+	toConstantDependency,
+	evaluateToString
+} = __webpack_require__(93998);
+const ChunkNameRuntimeModule = __webpack_require__(84519);
+const GetFullHashRuntimeModule = __webpack_require__(88732);
 
-		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
-		this._assetEmittingSourceCache = new WeakMap();
-		/** @private @type {Map<string, number>} */
-		this._assetEmittingWrittenFiles = new Map();
-		/** @private @type {Set<string>} */
-		this._assetEmittingPreviousFiles = new Set();
-	}
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-	/**
-	 * @param {string} name cache name
-	 * @returns {CacheFacade} the cache facade instance
-	 */
-	getCache(name) {
-		return new CacheFacade(
-			this.cache,
-			`${this.compilerPath}${name}`,
-			this.options.output.hashFunction
-		);
+/* eslint-disable camelcase */
+const REPLACEMENTS = {
+	__webpack_require__: {
+		expr: RuntimeGlobals.require,
+		req: [RuntimeGlobals.require],
+		type: "function",
+		assign: false
+	},
+	__webpack_public_path__: {
+		expr: RuntimeGlobals.publicPath,
+		req: [RuntimeGlobals.publicPath],
+		type: "string",
+		assign: true
+	},
+	__webpack_base_uri__: {
+		expr: RuntimeGlobals.baseURI,
+		req: [RuntimeGlobals.baseURI],
+		type: "string",
+		assign: true
+	},
+	__webpack_modules__: {
+		expr: RuntimeGlobals.moduleFactories,
+		req: [RuntimeGlobals.moduleFactories],
+		type: "object",
+		assign: false
+	},
+	__webpack_chunk_load__: {
+		expr: RuntimeGlobals.ensureChunk,
+		req: [RuntimeGlobals.ensureChunk],
+		type: "function",
+		assign: true
+	},
+	__non_webpack_require__: {
+		expr: "require",
+		req: null,
+		type: undefined, // type is not known, depends on environment
+		assign: true
+	},
+	__webpack_nonce__: {
+		expr: RuntimeGlobals.scriptNonce,
+		req: [RuntimeGlobals.scriptNonce],
+		type: "string",
+		assign: true
+	},
+	__webpack_hash__: {
+		expr: `${RuntimeGlobals.getFullHash}()`,
+		req: [RuntimeGlobals.getFullHash],
+		type: "string",
+		assign: false
+	},
+	__webpack_chunkname__: {
+		expr: RuntimeGlobals.chunkName,
+		req: [RuntimeGlobals.chunkName],
+		type: "string",
+		assign: false
+	},
+	__webpack_get_script_filename__: {
+		expr: RuntimeGlobals.getChunkScriptFilename,
+		req: [RuntimeGlobals.getChunkScriptFilename],
+		type: "function",
+		assign: true
+	},
+	__webpack_runtime_id__: {
+		expr: RuntimeGlobals.runtimeId,
+		req: [RuntimeGlobals.runtimeId],
+		assign: false
+	},
+	"require.onError": {
+		expr: RuntimeGlobals.uncaughtErrorHandler,
+		req: [RuntimeGlobals.uncaughtErrorHandler],
+		type: undefined, // type is not known, could be function or undefined
+		assign: true // is never a pattern
+	},
+	__system_context__: {
+		expr: RuntimeGlobals.systemContext,
+		req: [RuntimeGlobals.systemContext],
+		type: "object",
+		assign: false
+	},
+	__webpack_share_scopes__: {
+		expr: RuntimeGlobals.shareScopeMap,
+		req: [RuntimeGlobals.shareScopeMap],
+		type: "object",
+		assign: false
+	},
+	__webpack_init_sharing__: {
+		expr: RuntimeGlobals.initializeSharing,
+		req: [RuntimeGlobals.initializeSharing],
+		type: "function",
+		assign: true
 	}
+};
+/* eslint-enable camelcase */
 
+class APIPlugin {
 	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
-	 * @returns {Logger} a logger with that name
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getInfrastructureLogger(name) {
-		if (!name) {
-			throw new TypeError(
-				"Compiler.getInfrastructureLogger(name) called without a name"
-			);
-		}
-		return new Logger(
-			(type, args) => {
-				if (typeof name === "function") {
-					name = name();
-					if (!name) {
-						throw new TypeError(
-							"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"APIPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.chunkName)
+					.tap("APIPlugin", chunk => {
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkNameRuntimeModule(chunk.name)
 						);
-					}
-				}
-				if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
-					if (this.infrastructureLogger !== undefined) {
-						this.infrastructureLogger(name, type, args);
-					}
-				}
-			},
-			childName => {
-				if (typeof name === "function") {
-					if (typeof childName === "function") {
-						return this.getInfrastructureLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
+						return true;
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.getFullHash)
+					.tap("APIPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new GetFullHashRuntimeModule());
+						return true;
+					});
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 */
+				const handler = parser => {
+					Object.keys(REPLACEMENTS).forEach(key => {
+						const info = REPLACEMENTS[key];
+						parser.hooks.expression
+							.for(key)
+							.tap(
+								"APIPlugin",
+								toConstantDependency(parser, info.expr, info.req)
+							);
+						if (info.assign === false) {
+							parser.hooks.assign.for(key).tap("APIPlugin", expr => {
+								const err = new WebpackError(`${key} must not be assigned`);
+								err.loc = expr.loc;
+								throw err;
+							});
+						}
+						if (info.type) {
+							parser.hooks.evaluateTypeof
+								.for(key)
+								.tap("APIPlugin", evaluateToString(info.type));
+						}
+					});
+
+					parser.hooks.expression
+						.for("__webpack_layer__")
+						.tap("APIPlugin", expr => {
+							const dep = new ConstDependency(
+								JSON.stringify(parser.state.module.layer),
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
 						});
-					} else {
-						return this.getInfrastructureLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
+					parser.hooks.evaluateIdentifier
+						.for("__webpack_layer__")
+						.tap("APIPlugin", expr =>
+							(parser.state.module.layer === null
+								? new BasicEvaluatedExpression().setNull()
+								: new BasicEvaluatedExpression().setString(
+										parser.state.module.layer
+								  )
+							).setRange(expr.range)
+						);
+					parser.hooks.evaluateTypeof
+						.for("__webpack_layer__")
+						.tap("APIPlugin", expr =>
+							new BasicEvaluatedExpression()
+								.setString(
+									parser.state.module.layer === null ? "object" : "string"
+								)
+								.setRange(expr.range)
+						);
+
+					parser.hooks.expression
+						.for("__webpack_module__.id")
+						.tap("APIPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"__webpack_module__.id";
+							const dep = new ConstDependency(
+								parser.state.module.moduleArgument + ".id",
+								expr.range,
+								[RuntimeGlobals.moduleId]
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
 						});
-					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getInfrastructureLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
+
+					parser.hooks.expression
+						.for("__webpack_module__")
+						.tap("APIPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"__webpack_module__";
+							const dep = new ConstDependency(
+								parser.state.module.moduleArgument,
+								expr.range,
+								[RuntimeGlobals.module]
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
 						});
-					} else {
-						return this.getInfrastructureLogger(`${name}/${childName}`);
-					}
-				}
-			}
-		);
-	}
+					parser.hooks.evaluateTypeof
+						.for("__webpack_module__")
+						.tap("APIPlugin", evaluateToString("object"));
+				};
 
-	// TODO webpack 6: solve this in a better way
-	// e.g. move compilation specific info from Modules into ModuleGraph
-	_cleanupLastCompilation() {
-		if (this._lastCompilation !== undefined) {
-			for (const module of this._lastCompilation.modules) {
-				ChunkGraph.clearChunkGraphForModule(module);
-				ModuleGraph.clearModuleGraphForModule(module);
-				module.cleanupForCache();
-			}
-			for (const chunk of this._lastCompilation.chunks) {
-				ChunkGraph.clearChunkGraphForChunk(chunk);
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("APIPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("APIPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("APIPlugin", handler);
 			}
-			this._lastCompilation = undefined;
-		}
-	}
-
-	// TODO webpack 6: solve this in a better way
-	_cleanupLastNormalModuleFactory() {
-		if (this._lastNormalModuleFactory !== undefined) {
-			this._lastNormalModuleFactory.cleanupForCache();
-			this._lastNormalModuleFactory = undefined;
-		}
+		);
 	}
+}
 
-	/**
-	 * @param {WatchOptions} watchOptions the watcher's options
-	 * @param {Callback<Stats>} handler signals when the call finishes
-	 * @returns {Watching} a compiler watcher
-	 */
-	watch(watchOptions, handler) {
-		if (this.running) {
-			return handler(new ConcurrentCompilationError());
-		}
+module.exports = APIPlugin;
 
-		this.running = true;
-		this.watchMode = true;
-		this.watching = new Watching(this, watchOptions, handler);
-		return this.watching;
-	}
 
-	/**
-	 * @param {Callback<Stats>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	run(callback) {
-		if (this.running) {
-			return callback(new ConcurrentCompilationError());
-		}
+/***/ }),
 
-		let logger;
+/***/ 77198:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const finalCallback = (err, stats) => {
-			if (logger) logger.time("beginIdle");
-			this.idle = true;
-			this.cache.beginIdle();
-			this.idle = true;
-			if (logger) logger.timeEnd("beginIdle");
-			this.running = false;
-			if (err) {
-				this.hooks.failed.call(err);
-			}
-			if (callback !== undefined) callback(err, stats);
-			this.hooks.afterDone.call(stats);
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-		const startTime = Date.now();
 
-		this.running = true;
 
-		const onCompiled = (err, compilation) => {
-			if (err) return finalCallback(err);
+const WebpackError = __webpack_require__(53799);
+const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
 
-			if (this.hooks.shouldEmit.call(compilation) === false) {
-				compilation.startTime = startTime;
-				compilation.endTime = Date.now();
-				const stats = new Stats(compilation);
-				this.hooks.done.callAsync(stats, err => {
-					if (err) return finalCallback(err);
-					return finalCallback(null, stats);
-				});
-				return;
-			}
+/**
+ * @param {string=} method method name
+ * @returns {string} message
+ */
+function createMessage(method) {
+	return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
+}
 
-			process.nextTick(() => {
-				logger = compilation.getLogger("webpack.Compiler");
-				logger.time("emitAssets");
-				this.emitAssets(compilation, err => {
-					logger.timeEnd("emitAssets");
-					if (err) return finalCallback(err);
+/**
+ * @constructor
+ */
+function Message() {
+	/** @type {string} */
+	this.stack = undefined;
+	Error.captureStackTrace(this);
+	/** @type {RegExpMatchArray} */
+	const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
 
-					if (compilation.hooks.needAdditionalPass.call()) {
-						compilation.needAdditionalPass = true;
+	this.message = match && match[1] ? createMessage(match[1]) : createMessage();
+}
 
-						compilation.startTime = startTime;
-						compilation.endTime = Date.now();
-						logger.time("done hook");
-						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
-							logger.timeEnd("done hook");
-							if (err) return finalCallback(err);
+/**
+ * Error for abstract method
+ * @example
+ * class FooClass {
+ *     abstractMethod() {
+ *         throw new AbstractMethodError(); // error message: Abstract method FooClass.abstractMethod. Must be overridden.
+ *     }
+ * }
+ *
+ */
+class AbstractMethodError extends WebpackError {
+	constructor() {
+		super(new Message().message);
+		this.name = "AbstractMethodError";
+	}
+}
 
-							this.hooks.additionalPass.callAsync(err => {
-								if (err) return finalCallback(err);
-								this.compile(onCompiled);
-							});
-						});
-						return;
-					}
+module.exports = AbstractMethodError;
 
-					logger.time("emitRecords");
-					this.emitRecords(err => {
-						logger.timeEnd("emitRecords");
-						if (err) return finalCallback(err);
 
-						compilation.startTime = startTime;
-						compilation.endTime = Date.now();
-						logger.time("done hook");
-						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
-							logger.timeEnd("done hook");
-							if (err) return finalCallback(err);
-							this.cache.storeBuildDependencies(
-								compilation.buildDependencies,
-								err => {
-									if (err) return finalCallback(err);
-									return finalCallback(null, stats);
-								}
-							);
-						});
-					});
-				});
-			});
-		};
+/***/ }),
 
-		const run = () => {
-			this.hooks.beforeRun.callAsync(this, err => {
-				if (err) return finalCallback(err);
+/***/ 47736:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				this.hooks.run.callAsync(this, err => {
-					if (err) return finalCallback(err);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					this.readRecords(err => {
-						if (err) return finalCallback(err);
 
-						this.compile(onCompiled);
-					});
-				});
-			});
-		};
 
-		if (this.idle) {
-			this.cache.endIdle(err => {
-				if (err) return finalCallback(err);
+const DependenciesBlock = __webpack_require__(71040);
+const makeSerializable = __webpack_require__(33032);
 
-				this.idle = false;
-				run();
-			});
-		} else {
-			run();
-		}
-	}
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/Hash")} Hash */
 
+class AsyncDependenciesBlock extends DependenciesBlock {
 	/**
-	 * @param {RunAsChildCallback} callback signals when the call finishes
-	 * @returns {void}
+	 * @param {ChunkGroupOptions & { entryOptions?: EntryOptions }} groupOptions options for the group
+	 * @param {DependencyLocation=} loc the line of code
+	 * @param {string=} request the request
 	 */
-	runAsChild(callback) {
-		const startTime = Date.now();
-		this.compile((err, compilation) => {
-			if (err) return callback(err);
-
-			this.parentCompilation.children.push(compilation);
-			for (const { name, source, info } of compilation.getAssets()) {
-				this.parentCompilation.emitAsset(name, source, info);
-			}
-
-			const entries = [];
-			for (const ep of compilation.entrypoints.values()) {
-				entries.push(...ep.chunks);
-			}
-
-			compilation.startTime = startTime;
-			compilation.endTime = Date.now();
+	constructor(groupOptions, loc, request) {
+		super();
+		if (typeof groupOptions === "string") {
+			groupOptions = { name: groupOptions };
+		} else if (!groupOptions) {
+			groupOptions = { name: undefined };
+		}
+		this.groupOptions = groupOptions;
+		this.loc = loc;
+		this.request = request;
+		this._stringifiedGroupOptions = undefined;
+	}
 
-			return callback(null, entries, compilation);
-		});
+	/**
+	 * @returns {string} The name of the chunk
+	 */
+	get chunkName() {
+		return this.groupOptions.name;
 	}
 
-	purgeInputFileSystem() {
-		if (this.inputFileSystem && this.inputFileSystem.purge) {
-			this.inputFileSystem.purge();
+	/**
+	 * @param {string} value The new chunk name
+	 * @returns {void}
+	 */
+	set chunkName(value) {
+		if (this.groupOptions.name !== value) {
+			this.groupOptions.name = value;
+			this._stringifiedGroupOptions = undefined;
 		}
 	}
 
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {Callback<void>} callback signals when the assets are emitted
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	emitAssets(compilation, callback) {
-		let outputPath;
+	updateHash(hash, context) {
+		const { chunkGraph } = context;
+		if (this._stringifiedGroupOptions === undefined) {
+			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+		}
+		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
+		hash.update(
+			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
+		);
+		super.updateHash(hash, context);
+	}
 
-		const emitFiles = err => {
-			if (err) return callback(err);
+	serialize(context) {
+		const { write } = context;
+		write(this.groupOptions);
+		write(this.loc);
+		write(this.request);
+		super.serialize(context);
+	}
 
-			const assets = compilation.getAssets();
-			compilation.assets = { ...compilation.assets };
-			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
-			const caseInsensitiveMap = new Map();
-			/** @type {Set<string>} */
-			const allTargetPaths = new Set();
-			asyncLib.forEachLimit(
-				assets,
-				15,
-				({ name: file, source, info }, callback) => {
-					let targetFile = file;
-					let immutable = info.immutable;
-					const queryStringIdx = targetFile.indexOf("?");
-					if (queryStringIdx >= 0) {
-						targetFile = targetFile.substr(0, queryStringIdx);
-						// We may remove the hash, which is in the query string
-						// So we recheck if the file is immutable
-						// This doesn't cover all cases, but immutable is only a performance optimization anyway
-						immutable =
-							immutable &&
-							(includesHash(targetFile, info.contenthash) ||
-								includesHash(targetFile, info.chunkhash) ||
-								includesHash(targetFile, info.modulehash) ||
-								includesHash(targetFile, info.fullhash));
-					}
+	deserialize(context) {
+		const { read } = context;
+		this.groupOptions = read();
+		this.loc = read();
+		this.request = read();
+		super.deserialize(context);
+	}
+}
 
-					const writeOut = err => {
-						if (err) return callback(err);
-						const targetPath = join(
-							this.outputFileSystem,
-							outputPath,
-							targetFile
-						);
-						allTargetPaths.add(targetPath);
+makeSerializable(AsyncDependenciesBlock, "webpack/lib/AsyncDependenciesBlock");
 
-						// check if the target file has already been written by this Compiler
-						const targetFileGeneration =
-							this._assetEmittingWrittenFiles.get(targetPath);
+Object.defineProperty(AsyncDependenciesBlock.prototype, "module", {
+	get() {
+		throw new Error(
+			"module property was removed from AsyncDependenciesBlock (it's not needed)"
+		);
+	},
+	set() {
+		throw new Error(
+			"module property was removed from AsyncDependenciesBlock (it's not needed)"
+		);
+	}
+});
 
-						// create an cache entry for this Source if not already existing
-						let cacheEntry = this._assetEmittingSourceCache.get(source);
-						if (cacheEntry === undefined) {
-							cacheEntry = {
-								sizeOnlySource: undefined,
-								writtenTo: new Map()
-							};
-							this._assetEmittingSourceCache.set(source, cacheEntry);
-						}
+module.exports = AsyncDependenciesBlock;
 
-						let similarEntry;
 
-						const checkSimilarFile = () => {
-							const caseInsensitiveTargetPath = targetPath.toLowerCase();
-							similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath);
-							if (similarEntry !== undefined) {
-								const { path: other, source: otherSource } = similarEntry;
-								if (isSourceEqual(otherSource, source)) {
-									// Size may or may not be available at this point.
-									// If it's not available add to "waiting" list and it will be updated once available
-									if (similarEntry.size !== undefined) {
-										updateWithReplacementSource(similarEntry.size);
-									} else {
-										if (!similarEntry.waiting) similarEntry.waiting = [];
-										similarEntry.waiting.push({ file, cacheEntry });
-									}
-									alreadyWritten();
-								} else {
-									const err =
-										new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file.
-This will lead to a race-condition and corrupted files on case-insensitive file systems.
-${targetPath}
-${other}`);
-									err.file = file;
-									callback(err);
-								}
-								return true;
-							} else {
-								caseInsensitiveMap.set(
-									caseInsensitiveTargetPath,
-									(similarEntry = {
-										path: targetPath,
-										source,
-										size: undefined,
-										waiting: undefined
-									})
-								);
-								return false;
-							}
-						};
+/***/ }),
 
-						/**
-						 * get the binary (Buffer) content from the Source
-						 * @returns {Buffer} content for the source
-						 */
-						const getContent = () => {
-							if (typeof source.buffer === "function") {
-								return source.buffer();
-							} else {
-								const bufferOrString = source.source();
-								if (Buffer.isBuffer(bufferOrString)) {
-									return bufferOrString;
-								} else {
-									return Buffer.from(bufferOrString, "utf8");
-								}
-							}
-						};
+/***/ 30111:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						const alreadyWritten = () => {
-							// cache the information that the Source has been already been written to that location
-							if (targetFileGeneration === undefined) {
-								const newGeneration = 1;
-								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								cacheEntry.writtenTo.set(targetPath, newGeneration);
-							} else {
-								cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
-							}
-							callback();
-						};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
 
-						/**
-						 * Write the file to output file system
-						 * @param {Buffer} content content to be written
-						 * @returns {void}
-						 */
-						const doWrite = content => {
-							this.outputFileSystem.writeFile(targetPath, content, err => {
-								if (err) return callback(err);
 
-								// information marker that the asset has been emitted
-								compilation.emittedAssets.add(file);
 
-								// cache the information that the Source has been written to that location
-								const newGeneration =
-									targetFileGeneration === undefined
-										? 1
-										: targetFileGeneration + 1;
-								cacheEntry.writtenTo.set(targetPath, newGeneration);
-								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								this.hooks.assetEmitted.callAsync(
-									file,
-									{
-										content,
-										source,
-										outputPath,
-										compilation,
-										targetPath
-									},
-									callback
-								);
-							});
-						};
+const WebpackError = __webpack_require__(53799);
 
-						const updateWithReplacementSource = size => {
-							updateFileWithReplacementSource(file, cacheEntry, size);
-							similarEntry.size = size;
-							if (similarEntry.waiting !== undefined) {
-								for (const { file, cacheEntry } of similarEntry.waiting) {
-									updateFileWithReplacementSource(file, cacheEntry, size);
-								}
-							}
-						};
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
-						const updateFileWithReplacementSource = (
-							file,
-							cacheEntry,
-							size
-						) => {
-							// Create a replacement resource which only allows to ask for size
-							// This allows to GC all memory allocated by the Source
-							// (expect when the Source is stored in any other cache)
-							if (!cacheEntry.sizeOnlySource) {
-								cacheEntry.sizeOnlySource = new SizeOnlySource(size);
-							}
-							compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
-								size
-							});
-						};
+class AsyncDependencyToInitialChunkError extends WebpackError {
+	/**
+	 * Creates an instance of AsyncDependencyToInitialChunkError.
+	 * @param {string} chunkName Name of Chunk
+	 * @param {Module} module module tied to dependency
+	 * @param {DependencyLocation} loc location of dependency
+	 */
+	constructor(chunkName, module, loc) {
+		super(
+			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
+		);
 
-						const processExistingFile = stats => {
-							// skip emitting if it's already there and an immutable file
-							if (immutable) {
-								updateWithReplacementSource(stats.size);
-								return alreadyWritten();
-							}
+		this.name = "AsyncDependencyToInitialChunkError";
+		this.module = module;
+		this.loc = loc;
+	}
+}
 
-							const content = getContent();
+module.exports = AsyncDependencyToInitialChunkError;
 
-							updateWithReplacementSource(content.length);
 
-							// if it exists and content on disk matches content
-							// skip writing the same content again
-							// (to keep mtime and don't trigger watchers)
-							// for a fast negative match file size is compared first
-							if (content.length === stats.size) {
-								compilation.comparedForEmitAssets.add(file);
-								return this.outputFileSystem.readFile(
-									targetPath,
-									(err, existingContent) => {
-										if (
-											err ||
-											!content.equals(/** @type {Buffer} */ (existingContent))
-										) {
-											return doWrite(content);
-										} else {
-											return alreadyWritten();
-										}
-									}
-								);
-							}
+/***/ }),
 
-							return doWrite(content);
-						};
+/***/ 17714:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						const processMissingFile = () => {
-							const content = getContent();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-							updateWithReplacementSource(content.length);
 
-							return doWrite(content);
-						};
 
-						// if the target file has already been written
-						if (targetFileGeneration !== undefined) {
-							// check if the Source has been written to this target file
-							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
-							if (writtenGeneration === targetFileGeneration) {
-								// if yes, we may skip writing the file
-								// if it's already there
-								// (we assume one doesn't modify files while the Compiler is running, other then removing them)
+const asyncLib = __webpack_require__(78175);
+const NormalModule = __webpack_require__(39);
+const PrefetchDependency = __webpack_require__(31618);
 
-								if (this._assetEmittingPreviousFiles.has(targetPath)) {
-									// We assume that assets from the last compilation say intact on disk (they are not removed)
-									compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
-										size: cacheEntry.sizeOnlySource.size()
-									});
+/** @typedef {import("./Compiler")} Compiler */
 
-									return callback();
-								} else {
-									// Settings immutable will make it accept file content without comparing when file exist
-									immutable = true;
-								}
-							} else if (!immutable) {
-								if (checkSimilarFile()) return;
-								// We wrote to this file before which has very likely a different content
-								// skip comparing and assume content is different for performance
-								// This case happens often during watch mode.
-								return processMissingFile();
-							}
-						}
+class AutomaticPrefetchPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"AutomaticPrefetchPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					PrefetchDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		let lastModules = null;
+		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
+			lastModules = [];
 
-						if (checkSimilarFile()) return;
-						if (this.options.output.compareBeforeEmit) {
-							this.outputFileSystem.stat(targetPath, (err, stats) => {
-								const exists = !err && stats.isFile();
+			for (const m of compilation.modules) {
+				if (m instanceof NormalModule) {
+					lastModules.push({
+						context: m.context,
+						request: m.request
+					});
+				}
+			}
+		});
+		compiler.hooks.make.tapAsync(
+			"AutomaticPrefetchPlugin",
+			(compilation, callback) => {
+				if (!lastModules) return callback();
+				asyncLib.forEach(
+					lastModules,
+					(m, callback) => {
+						compilation.addModuleChain(
+							m.context || compiler.context,
+							new PrefetchDependency(`!!${m.request}`),
+							callback
+						);
+					},
+					err => {
+						lastModules = null;
+						callback(err);
+					}
+				);
+			}
+		);
+	}
+}
+module.exports = AutomaticPrefetchPlugin;
 
-								if (exists) {
-									processExistingFile(stats);
-								} else {
-									processMissingFile();
-								}
-							});
-						} else {
-							processMissingFile();
-						}
-					};
 
-					if (targetFile.match(/\/|\\/)) {
-						const fs = this.outputFileSystem;
-						const dir = dirname(fs, join(fs, outputPath, targetFile));
-						mkdirp(fs, dir, writeOut);
-					} else {
-						writeOut();
-					}
-				},
-				err => {
-					// Clear map to free up memory
-					caseInsensitiveMap.clear();
-					if (err) {
-						this._assetEmittingPreviousFiles.clear();
-						return callback(err);
-					}
+/***/ }),
 
-					this._assetEmittingPreviousFiles = allTargetPaths;
+/***/ 21242:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					this.hooks.afterEmit.callAsync(compilation, err => {
-						if (err) return callback(err);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						return callback();
-					});
-				}
-			);
-		};
 
-		this.hooks.emit.callAsync(compilation, err => {
-			if (err) return callback(err);
-			outputPath = compilation.getPath(this.outputPath, {});
-			mkdirp(this.outputFileSystem, outputPath, emitFiles);
-		});
+
+const { ConcatSource } = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const Template = __webpack_require__(39722);
+const createSchemaValidation = __webpack_require__(32540);
+
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
+
+const validate = createSchemaValidation(
+	__webpack_require__(42173),
+	() => __webpack_require__(49052),
+	{
+		name: "Banner Plugin",
+		baseDataPath: "options"
 	}
+);
 
-	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	emitRecords(callback) {
-		if (this.hooks.emitRecords.isUsed()) {
-			if (this.recordsOutputPath) {
-				asyncLib.parallel(
-					[
-						cb => this.hooks.emitRecords.callAsync(cb),
-						this._emitRecords.bind(this)
-					],
-					err => callback(err)
-				);
-			} else {
-				this.hooks.emitRecords.callAsync(callback);
-			}
-		} else {
-			if (this.recordsOutputPath) {
-				this._emitRecords(callback);
-			} else {
-				callback();
-			}
-		}
+const wrapComment = str => {
+	if (!str.includes("\n")) {
+		return Template.toComment(str);
 	}
+	return `/*!\n * ${str
+		.replace(/\*\//g, "* /")
+		.split("\n")
+		.join("\n * ")
+		.replace(/\s+\n/g, "\n")
+		.trimRight()}\n */`;
+};
 
+class BannerPlugin {
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
+	 * @param {BannerPluginArgument} options options object
 	 */
-	_emitRecords(callback) {
-		const writeFile = () => {
-			this.outputFileSystem.writeFile(
-				this.recordsOutputPath,
-				JSON.stringify(
-					this.records,
-					(n, value) => {
-						if (
-							typeof value === "object" &&
-							value !== null &&
-							!Array.isArray(value)
-						) {
-							const keys = Object.keys(value);
-							if (!isSorted(keys)) {
-								return sortObject(value, keys);
-							}
-						}
-						return value;
-					},
-					2
-				),
-				callback
-			);
-		};
-
-		const recordsOutputPathDirectory = dirname(
-			this.outputFileSystem,
-			this.recordsOutputPath
-		);
-		if (!recordsOutputPathDirectory) {
-			return writeFile();
+	constructor(options) {
+		if (typeof options === "string" || typeof options === "function") {
+			options = {
+				banner: options
+			};
 		}
-		mkdirp(this.outputFileSystem, recordsOutputPathDirectory, err => {
-			if (err) return callback(err);
-			writeFile();
-		});
-	}
 
-	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	readRecords(callback) {
-		if (this.hooks.readRecords.isUsed()) {
-			if (this.recordsInputPath) {
-				asyncLib.parallel([
-					cb => this.hooks.readRecords.callAsync(cb),
-					this._readRecords.bind(this)
-				]);
-			} else {
-				this.records = {};
-				this.hooks.readRecords.callAsync(callback);
-			}
+		validate(options);
+
+		this.options = options;
+
+		const bannerOption = options.banner;
+		if (typeof bannerOption === "function") {
+			const getBanner = bannerOption;
+			this.banner = this.options.raw
+				? getBanner
+				: data => wrapComment(getBanner(data));
 		} else {
-			if (this.recordsInputPath) {
-				this._readRecords(callback);
-			} else {
-				this.records = {};
-				callback();
-			}
+			const banner = this.options.raw
+				? bannerOption
+				: wrapComment(bannerOption);
+			this.banner = () => banner;
 		}
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the call finishes
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	_readRecords(callback) {
-		if (!this.recordsInputPath) {
-			this.records = {};
-			return callback();
-		}
-		this.inputFileSystem.stat(this.recordsInputPath, err => {
-			// It doesn't exist
-			// We can ignore this.
-			if (err) return callback();
+	apply(compiler) {
+		const options = this.options;
+		const banner = this.banner;
+		const matchObject = ModuleFilenameHelpers.matchObject.bind(
+			undefined,
+			options
+		);
 
-			this.inputFileSystem.readFile(this.recordsInputPath, (err, content) => {
-				if (err) return callback(err);
+		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
+			compilation.hooks.processAssets.tap(
+				{
+					name: "BannerPlugin",
+					stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+				},
+				() => {
+					for (const chunk of compilation.chunks) {
+						if (options.entryOnly && !chunk.canBeInitial()) {
+							continue;
+						}
 
-				try {
-					this.records = parseJson(content.toString("utf-8"));
-				} catch (e) {
-					e.message = "Cannot parse records: " + e.message;
-					return callback(e);
-				}
+						for (const file of chunk.files) {
+							if (!matchObject(file)) {
+								continue;
+							}
 
-				return callback();
-			});
+							const data = {
+								chunk,
+								filename: file
+							};
+
+							const comment = compilation.getPath(banner, data);
+
+							compilation.updateAsset(
+								file,
+								old => new ConcatSource(comment, "\n", old)
+							);
+						}
+					}
+				}
+			);
 		});
 	}
+}
 
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {string} compilerName the compiler's name
-	 * @param {number} compilerIndex the compiler's index
-	 * @param {OutputOptions=} outputOptions the output options
-	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
-	 * @returns {Compiler} a child compiler
-	 */
-	createChildCompiler(
-		compilation,
-		compilerName,
-		compilerIndex,
-		outputOptions,
-		plugins
-	) {
-		const childCompiler = new Compiler(this.context, {
-			...this.options,
-			output: {
-				...this.options.output,
-				...outputOptions
-			}
-		});
-		childCompiler.name = compilerName;
-		childCompiler.outputPath = this.outputPath;
-		childCompiler.inputFileSystem = this.inputFileSystem;
-		childCompiler.outputFileSystem = null;
-		childCompiler.resolverFactory = this.resolverFactory;
-		childCompiler.modifiedFiles = this.modifiedFiles;
-		childCompiler.removedFiles = this.removedFiles;
-		childCompiler.fileTimestamps = this.fileTimestamps;
-		childCompiler.contextTimestamps = this.contextTimestamps;
-		childCompiler.fsStartTime = this.fsStartTime;
-		childCompiler.cache = this.cache;
-		childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
-		childCompiler._backCompat = this._backCompat;
+module.exports = BannerPlugin;
 
-		const relativeCompilerName = makePathsRelative(
-			this.context,
-			compilerName,
-			this.root
-		);
-		if (!this.records[relativeCompilerName]) {
-			this.records[relativeCompilerName] = [];
-		}
-		if (this.records[relativeCompilerName][compilerIndex]) {
-			childCompiler.records = this.records[relativeCompilerName][compilerIndex];
-		} else {
-			this.records[relativeCompilerName].push((childCompiler.records = {}));
-		}
 
-		childCompiler.parentCompilation = compilation;
-		childCompiler.root = this.root;
-		if (Array.isArray(plugins)) {
-			for (const plugin of plugins) {
-				plugin.apply(childCompiler);
-			}
-		}
-		for (const name in this.hooks) {
-			if (
-				![
-					"make",
-					"compile",
-					"emit",
-					"afterEmit",
-					"invalid",
-					"done",
-					"thisCompilation"
-				].includes(name)
-			) {
-				if (childCompiler.hooks[name]) {
-					childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
-				}
-			}
-		}
+/***/ }),
 
-		compilation.hooks.childCompiler.call(
-			childCompiler,
-			compilerName,
-			compilerIndex
-		);
+/***/ 7592:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		return childCompiler;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	isChild() {
-		return !!this.parentCompilation;
-	}
 
-	createCompilation(params) {
-		this._cleanupLastCompilation();
-		return (this._lastCompilation = new Compilation(this, params));
+
+const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = __webpack_require__(41242);
+const {
+	makeWebpackError,
+	makeWebpackErrorCallback
+} = __webpack_require__(11351);
+
+/** @typedef {import("./WebpackError")} WebpackError */
+
+/**
+ * @typedef {Object} Etag
+ * @property {function(): string} toString
+ */
+
+/**
+ * @template T
+ * @callback CallbackCache
+ * @param {(WebpackError | null)=} err
+ * @param {T=} result
+ * @returns {void}
+ */
+
+/**
+ * @callback GotHandler
+ * @param {any} result
+ * @param {function(Error=): void} callback
+ * @returns {void}
+ */
+
+const needCalls = (times, callback) => {
+	return err => {
+		if (--times === 0) {
+			return callback(err);
+		}
+		if (err && times > 0) {
+			times = 0;
+			return callback(err);
+		}
+	};
+};
+
+class Cache {
+	constructor() {
+		this.hooks = {
+			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
+			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
+			/** @type {AsyncParallelHook<[string, Etag | null, any]>} */
+			store: new AsyncParallelHook(["identifier", "etag", "data"]),
+			/** @type {AsyncParallelHook<[Iterable<string>]>} */
+			storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
+			/** @type {SyncHook<[]>} */
+			beginIdle: new SyncHook([]),
+			/** @type {AsyncParallelHook<[]>} */
+			endIdle: new AsyncParallelHook([]),
+			/** @type {AsyncParallelHook<[]>} */
+			shutdown: new AsyncParallelHook([])
+		};
 	}
 
 	/**
-	 * @param {CompilationParams} params the compilation parameters
-	 * @returns {Compilation} the created compilation
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
 	 */
-	newCompilation(params) {
-		const compilation = this.createCompilation(params);
-		compilation.name = this.name;
-		compilation.records = this.records;
-		this.hooks.thisCompilation.call(compilation, params);
-		this.hooks.compilation.call(compilation, params);
-		return compilation;
-	}
-
-	createNormalModuleFactory() {
-		this._cleanupLastNormalModuleFactory();
-		const normalModuleFactory = new NormalModuleFactory({
-			context: this.options.context,
-			fs: this.inputFileSystem,
-			resolverFactory: this.resolverFactory,
-			options: this.options.module,
-			associatedObjectForCache: this.root,
-			layers: this.options.experiments.layers
+	get(identifier, etag, callback) {
+		const gotHandlers = [];
+		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
+			if (err) {
+				callback(makeWebpackError(err, "Cache.hooks.get"));
+				return;
+			}
+			if (result === null) {
+				result = undefined;
+			}
+			if (gotHandlers.length > 1) {
+				const innerCallback = needCalls(gotHandlers.length, () =>
+					callback(null, result)
+				);
+				for (const gotHandler of gotHandlers) {
+					gotHandler(result, innerCallback);
+				}
+			} else if (gotHandlers.length === 1) {
+				gotHandlers[0](result, () => callback(null, result));
+			} else {
+				callback(null, result);
+			}
 		});
-		this._lastNormalModuleFactory = normalModuleFactory;
-		this.hooks.normalModuleFactory.call(normalModuleFactory);
-		return normalModuleFactory;
 	}
 
-	createContextModuleFactory() {
-		const contextModuleFactory = new ContextModuleFactory(this.resolverFactory);
-		this.hooks.contextModuleFactory.call(contextModuleFactory);
-		return contextModuleFactory;
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(identifier, etag, data, callback) {
+		this.hooks.store.callAsync(
+			identifier,
+			etag,
+			data,
+			makeWebpackErrorCallback(callback, "Cache.hooks.store")
+		);
 	}
 
-	newCompilationParams() {
-		const params = {
-			normalModuleFactory: this.createNormalModuleFactory(),
-			contextModuleFactory: this.createContextModuleFactory()
-		};
-		return params;
+	/**
+	 * After this method has succeeded the cache can only be restored when build dependencies are
+	 * @param {Iterable<string>} dependencies list of all build dependencies
+	 * @param {CallbackCache<void>} callback signals when the dependencies are stored
+	 * @returns {void}
+	 */
+	storeBuildDependencies(dependencies, callback) {
+		this.hooks.storeBuildDependencies.callAsync(
+			dependencies,
+			makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies")
+		);
 	}
 
 	/**
-	 * @param {Callback<Compilation>} callback signals when the compilation finishes
 	 * @returns {void}
 	 */
-	compile(callback) {
-		const params = this.newCompilationParams();
-		this.hooks.beforeCompile.callAsync(params, err => {
-			if (err) return callback(err);
-
-			this.hooks.compile.call(params);
-
-			const compilation = this.newCompilation(params);
-
-			const logger = compilation.getLogger("webpack.Compiler");
-
-			logger.time("make hook");
-			this.hooks.make.callAsync(compilation, err => {
-				logger.timeEnd("make hook");
-				if (err) return callback(err);
-
-				logger.time("finish make hook");
-				this.hooks.finishMake.callAsync(compilation, err => {
-					logger.timeEnd("finish make hook");
-					if (err) return callback(err);
-
-					process.nextTick(() => {
-						logger.time("finish compilation");
-						compilation.finish(err => {
-							logger.timeEnd("finish compilation");
-							if (err) return callback(err);
-
-							logger.time("seal compilation");
-							compilation.seal(err => {
-								logger.timeEnd("seal compilation");
-								if (err) return callback(err);
-
-								logger.time("afterCompile hook");
-								this.hooks.afterCompile.callAsync(compilation, err => {
-									logger.timeEnd("afterCompile hook");
-									if (err) return callback(err);
+	beginIdle() {
+		this.hooks.beginIdle.call();
+	}
 
-									return callback(null, compilation);
-								});
-							});
-						});
-					});
-				});
-			});
-		});
+	/**
+	 * @param {CallbackCache<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	endIdle(callback) {
+		this.hooks.endIdle.callAsync(
+			makeWebpackErrorCallback(callback, "Cache.hooks.endIdle")
+		);
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the compiler closes
+	 * @param {CallbackCache<void>} callback signals when the call finishes
 	 * @returns {void}
 	 */
-	close(callback) {
-		if (this.watching) {
-			// When there is still an active watching, close this first
-			this.watching.close(err => {
-				this.close(callback);
-			});
-			return;
-		}
-		this.hooks.shutdown.callAsync(err => {
-			if (err) return callback(err);
-			// Get rid of reference to last compilation to avoid leaking memory
-			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid of the reference to the cache instead.
-			this._lastCompilation = undefined;
-			this._lastNormalModuleFactory = undefined;
-			this.cache.shutdown(callback);
-		});
+	shutdown(callback) {
+		this.hooks.shutdown.callAsync(
+			makeWebpackErrorCallback(callback, "Cache.hooks.shutdown")
+		);
 	}
 }
 
-module.exports = Compiler;
+Cache.STAGE_MEMORY = -10;
+Cache.STAGE_DEFAULT = 0;
+Cache.STAGE_DISK = 10;
+Cache.STAGE_NETWORK = 20;
+
+module.exports = Cache;
 
 
 /***/ }),
 
-/***/ 98229:
-/***/ (function(module) {
+/***/ 55392:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -28801,189 +24939,349 @@ module.exports = Compiler;
 
 
 
-/** @typedef {import("./Module")} Module */
-
-const MODULE_REFERENCE_REGEXP =
-	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(?:_asiSafe(\d))?__$/;
-
-const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
-const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
+const { forEachBail } = __webpack_require__(30662);
+const asyncLib = __webpack_require__(78175);
+const getLazyHashedEtag = __webpack_require__(94075);
+const mergeEtags = __webpack_require__(54980);
 
-/**
- * @typedef {Object} ExternalModuleInfo
- * @property {number} index
- * @property {Module} module
- */
+/** @typedef {import("./Cache")} Cache */
+/** @typedef {import("./Cache").Etag} Etag */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
+/** @typedef {typeof import("./util/Hash")} HashConstructor */
 
 /**
- * @typedef {Object} ConcatenatedModuleInfo
- * @property {number} index
- * @property {Module} module
- * @property {Map<string, string>} exportMap mapping from export name to symbol
- * @property {Map<string, string>} rawExportMap mapping from export name to symbol
- * @property {string=} namespaceExportSymbol
+ * @template T
+ * @callback CallbackCache
+ * @param {(WebpackError | null)=} err
+ * @param {T=} result
+ * @returns {void}
  */
 
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo} ModuleInfo */
-
 /**
- * @typedef {Object} ModuleReferenceOptions
- * @property {string[]} ids the properties/exports of the module
- * @property {boolean} call true, when this referenced export is called
- * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
- * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
+ * @template T
+ * @callback CallbackNormalErrorCache
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ * @returns {void}
  */
 
-class ConcatenationScope {
+class MultiItemCache {
 	/**
-	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
-	 * @param {ConcatenatedModuleInfo} currentModule the current module info
+	 * @param {ItemCacheFacade[]} items item caches
 	 */
-	constructor(modulesMap, currentModule) {
-		this._currentModule = currentModule;
-		if (Array.isArray(modulesMap)) {
-			const map = new Map();
-			for (const info of modulesMap) {
-				map.set(info.module, info);
-			}
-			modulesMap = map;
-		}
-		this._modulesMap = modulesMap;
+	constructor(items) {
+		this._items = items;
+		if (items.length === 1) return /** @type {any} */ (items[0]);
 	}
 
 	/**
-	 * @param {Module} module the referenced module
-	 * @returns {boolean} true, when it's in the scope
+	 * @template T
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
 	 */
-	isModuleInScope(module) {
-		return this._modulesMap.has(module);
+	get(callback) {
+		forEachBail(this._items, (item, callback) => item.get(callback), callback);
 	}
 
 	/**
-	 *
-	 * @param {string} exportName name of the export
-	 * @param {string} symbol identifier of the export in source code
+	 * @template T
+	 * @returns {Promise<T>} promise with the data
 	 */
-	registerExport(exportName, symbol) {
-		if (!this._currentModule.exportMap) {
-			this._currentModule.exportMap = new Map();
-		}
-		if (!this._currentModule.exportMap.has(exportName)) {
-			this._currentModule.exportMap.set(exportName, symbol);
-		}
+	getPromise() {
+		const next = i => {
+			return this._items[i].getPromise().then(result => {
+				if (result !== undefined) return result;
+				if (++i < this._items.length) return next(i);
+			});
+		};
+		return next(0);
 	}
 
 	/**
-	 *
-	 * @param {string} exportName name of the export
-	 * @param {string} expression expression to be used
+	 * @template T
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
 	 */
-	registerRawExport(exportName, expression) {
-		if (!this._currentModule.rawExportMap) {
-			this._currentModule.rawExportMap = new Map();
-		}
-		if (!this._currentModule.rawExportMap.has(exportName)) {
-			this._currentModule.rawExportMap.set(exportName, expression);
-		}
+	store(data, callback) {
+		asyncLib.each(
+			this._items,
+			(item, callback) => item.store(data, callback),
+			callback
+		);
 	}
 
 	/**
-	 * @param {string} symbol identifier of the export in source code
+	 * @template T
+	 * @param {T} data the value to store
+	 * @returns {Promise<void>} promise signals when the value is stored
 	 */
-	registerNamespaceExport(symbol) {
-		this._currentModule.namespaceExportSymbol = symbol;
+	storePromise(data) {
+		return Promise.all(this._items.map(item => item.storePromise(data))).then(
+			() => {}
+		);
 	}
+}
 
+class ItemCacheFacade {
 	/**
-	 *
-	 * @param {Module} module the referenced module
-	 * @param {Partial<ModuleReferenceOptions>} options options
-	 * @returns {string} the reference as identifier
+	 * @param {Cache} cache the root cache
+	 * @param {string} name the child cache item name
+	 * @param {Etag | null} etag the etag
 	 */
-	createModuleReference(
-		module,
-		{ ids = undefined, call = false, directImport = false, asiSafe = false }
-	) {
-		const info = this._modulesMap.get(module);
-		const callFlag = call ? "_call" : "";
-		const directImportFlag = directImport ? "_directImport" : "";
-		const asiSafeFlag = asiSafe
-			? "_asiSafe1"
-			: asiSafe === false
-			? "_asiSafe0"
-			: "";
-		const exportData = ids
-			? Buffer.from(JSON.stringify(ids), "utf-8").toString("hex")
-			: "ns";
-		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
-		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${asiSafeFlag}__._`;
+	constructor(cache, name, etag) {
+		this._cache = cache;
+		this._name = name;
+		this._etag = etag;
 	}
 
 	/**
-	 * @param {string} name the identifier
-	 * @returns {boolean} true, when it's an module reference
+	 * @template T
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
 	 */
-	static isModuleReference(name) {
-		return MODULE_REFERENCE_REGEXP.test(name);
+	get(callback) {
+		this._cache.get(this._name, this._etag, callback);
 	}
 
 	/**
-	 * @param {string} name the identifier
-	 * @returns {ModuleReferenceOptions & { index: number }} parsed options and index
+	 * @template T
+	 * @returns {Promise<T>} promise with the data
 	 */
-	static matchModuleReference(name) {
-		const match = MODULE_REFERENCE_REGEXP.exec(name);
-		if (!match) return null;
-		const index = +match[1];
-		const asiSafe = match[5];
-		return {
-			index,
-			ids:
-				match[2] === "ns"
-					? []
-					: JSON.parse(Buffer.from(match[2], "hex").toString("utf-8")),
-			call: !!match[3],
-			directImport: !!match[4],
-			asiSafe: asiSafe ? asiSafe === "1" : undefined
-		};
+	getPromise() {
+		return new Promise((resolve, reject) => {
+			this._cache.get(this._name, this._etag, (err, data) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(data);
+				}
+			});
+		});
+	}
+
+	/**
+	 * @template T
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(data, callback) {
+		this._cache.store(this._name, this._etag, data, callback);
+	}
+
+	/**
+	 * @template T
+	 * @param {T} data the value to store
+	 * @returns {Promise<void>} promise signals when the value is stored
+	 */
+	storePromise(data) {
+		return new Promise((resolve, reject) => {
+			this._cache.store(this._name, this._etag, data, err => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	}
+
+	/**
+	 * @template T
+	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
+	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	provide(computer, callback) {
+		this.get((err, cacheEntry) => {
+			if (err) return callback(err);
+			if (cacheEntry !== undefined) return cacheEntry;
+			computer((err, result) => {
+				if (err) return callback(err);
+				this.store(result, err => {
+					if (err) return callback(err);
+					callback(null, result);
+				});
+			});
+		});
+	}
+
+	/**
+	 * @template T
+	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
+	 * @returns {Promise<T>} promise with the data
+	 */
+	async providePromise(computer) {
+		const cacheEntry = await this.getPromise();
+		if (cacheEntry !== undefined) return cacheEntry;
+		const result = await computer();
+		await this.storePromise(result);
+		return result;
 	}
 }
 
-ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
-ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
+class CacheFacade {
+	/**
+	 * @param {Cache} cache the root cache
+	 * @param {string} name the child cache name
+	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 */
+	constructor(cache, name, hashFunction) {
+		this._cache = cache;
+		this._name = name;
+		this._hashFunction = hashFunction;
+	}
 
-module.exports = ConcatenationScope;
+	/**
+	 * @param {string} name the child cache name#
+	 * @returns {CacheFacade} child cache
+	 */
+	getChildCache(name) {
+		return new CacheFacade(
+			this._cache,
+			`${this._name}|${name}`,
+			this._hashFunction
+		);
+	}
 
+	/**
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @returns {ItemCacheFacade} item cache
+	 */
+	getItemCache(identifier, etag) {
+		return new ItemCacheFacade(
+			this._cache,
+			`${this._name}|${identifier}`,
+			etag
+		);
+	}
 
-/***/ }),
+	/**
+	 * @param {HashableObject} obj an hashable object
+	 * @returns {Etag} an etag that is lazy hashed
+	 */
+	getLazyHashedEtag(obj) {
+		return getLazyHashedEtag(obj, this._hashFunction);
+	}
 
-/***/ 95735:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Etag} a an etag
+	 * @param {Etag} b another etag
+	 * @returns {Etag} an etag that represents both
+	 */
+	mergeEtags(a, b) {
+		return mergeEtags(a, b);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Maksim Nazarjev @acupofspirt
-*/
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	get(identifier, etag, callback) {
+		this._cache.get(`${this._name}|${identifier}`, etag, callback);
+	}
 
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @returns {Promise<T>} promise with the data
+	 */
+	getPromise(identifier, etag) {
+		return new Promise((resolve, reject) => {
+			this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(data);
+				}
+			});
+		});
+	}
 
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(identifier, etag, data, callback) {
+		this._cache.store(`${this._name}|${identifier}`, etag, data, callback);
+	}
 
-const WebpackError = __webpack_require__(53799);
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @returns {Promise<void>} promise signals when the value is stored
+	 */
+	storePromise(identifier, etag, data) {
+		return new Promise((resolve, reject) => {
+			this._cache.store(`${this._name}|${identifier}`, etag, data, err => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	}
 
-module.exports = class ConcurrentCompilationError extends WebpackError {
-	constructor() {
-		super();
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
+	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	provide(identifier, etag, computer, callback) {
+		this.get(identifier, etag, (err, cacheEntry) => {
+			if (err) return callback(err);
+			if (cacheEntry !== undefined) return cacheEntry;
+			computer((err, result) => {
+				if (err) return callback(err);
+				this.store(identifier, etag, result, err => {
+					if (err) return callback(err);
+					callback(null, result);
+				});
+			});
+		});
+	}
 
-		this.name = "ConcurrentCompilationError";
-		this.message =
-			"You ran Webpack twice. Each instance only supports a single concurrent compilation at a time.";
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
+	 * @returns {Promise<T>} promise with the data
+	 */
+	async providePromise(identifier, etag, computer) {
+		const cacheEntry = await this.getPromise(identifier, etag);
+		if (cacheEntry !== undefined) return cacheEntry;
+		const result = await computer();
+		await this.storePromise(identifier, etag, result);
+		return result;
 	}
-};
+}
+
+module.exports = CacheFacade;
+module.exports.ItemCacheFacade = ItemCacheFacade;
+module.exports.MultiItemCache = MultiItemCache;
 
 
 /***/ }),
 
-/***/ 61333:
+/***/ 77975:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -28994,116 +25292,75 @@ module.exports = class ConcurrentCompilationError extends WebpackError {
 
 
 
-const { ConcatSource, PrefixSource } = __webpack_require__(51255);
-const InitFragment = __webpack_require__(55870);
-const Template = __webpack_require__(1626);
-const { mergeRuntime } = __webpack_require__(17156);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
 
-const wrapInCondition = (condition, source) => {
-	if (typeof source === "string") {
-		return Template.asString([
-			`if (${condition}) {`,
-			Template.indent(source),
-			"}",
-			""
-		]);
-	} else {
-		return new ConcatSource(
-			`if (${condition}) {\n`,
-			new PrefixSource("\t", source),
-			"}\n"
-		);
-	}
+/**
+ * @param {Module[]} modules the modules to be sorted
+ * @returns {Module[]} sorted version of original modules
+ */
+const sortModules = modules => {
+	return modules.sort((a, b) => {
+		const aIdent = a.identifier();
+		const bIdent = b.identifier();
+		/* istanbul ignore next */
+		if (aIdent < bIdent) return -1;
+		/* istanbul ignore next */
+		if (aIdent > bIdent) return 1;
+		/* istanbul ignore next */
+		return 0;
+	});
 };
 
 /**
- * @typedef {GenerateContext} Context
+ * @param {Module[]} modules each module from throw
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {string} each message from provided modules
  */
-class ConditionalInitFragment extends InitFragment {
-	/**
-	 * @param {string|Source} content the source code that will be included as initialization code
-	 * @param {number} stage category of initialization code (contribute to order)
-	 * @param {number} position position in the category (contribute to order)
-	 * @param {string} key unique key to avoid emitting the same initialization code twice
-	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
-	 * @param {string|Source=} endContent the source code that will be included at the end of the module
-	 */
-	constructor(
-		content,
-		stage,
-		position,
-		key,
-		runtimeCondition = true,
-		endContent
-	) {
-		super(content, stage, position, key, endContent);
-		this.runtimeCondition = runtimeCondition;
-	}
+const createModulesListMessage = (modules, moduleGraph) => {
+	return modules
+		.map(m => {
+			let message = `* ${m.identifier()}`;
+			const validReasons = Array.from(
+				moduleGraph.getIncomingConnectionsByOriginModule(m).keys()
+			).filter(x => x);
 
-	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
-	 */
-	getContent(context) {
-		if (this.runtimeCondition === false || !this.content) return "";
-		if (this.runtimeCondition === true) return this.content;
-		const expr = context.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: context.chunkGraph,
-			runtimeRequirements: context.runtimeRequirements,
-			runtime: context.runtime,
-			runtimeCondition: this.runtimeCondition
-		});
-		if (expr === "true") return this.content;
-		return wrapInCondition(expr, this.content);
-	}
+			if (validReasons.length > 0) {
+				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
+				message += `\n    ${validReasons[0].identifier()}`;
+			}
+			return message;
+		})
+		.join("\n");
+};
 
+class CaseSensitiveModulesWarning extends WebpackError {
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 * Creates an instance of CaseSensitiveModulesWarning.
+	 * @param {Iterable<Module>} modules modules that were detected
+	 * @param {ModuleGraph} moduleGraph the module graph
 	 */
-	getEndContent(context) {
-		if (this.runtimeCondition === false || !this.endContent) return "";
-		if (this.runtimeCondition === true) return this.endContent;
-		const expr = context.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: context.chunkGraph,
-			runtimeRequirements: context.runtimeRequirements,
-			runtime: context.runtime,
-			runtimeCondition: this.runtimeCondition
-		});
-		if (expr === "true") return this.endContent;
-		return wrapInCondition(expr, this.endContent);
-	}
+	constructor(modules, moduleGraph) {
+		const sortedModules = sortModules(Array.from(modules));
+		const modulesList = createModulesListMessage(sortedModules, moduleGraph);
+		super(`There are multiple modules with names that only differ in casing.
+This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.
+Use equal casing. Compare these module identifiers:
+${modulesList}`);
 
-	merge(other) {
-		if (this.runtimeCondition === true) return this;
-		if (other.runtimeCondition === true) return other;
-		if (this.runtimeCondition === false) return other;
-		if (other.runtimeCondition === false) return this;
-		const runtimeCondition = mergeRuntime(
-			this.runtimeCondition,
-			other.runtimeCondition
-		);
-		return new ConditionalInitFragment(
-			this.content,
-			this.stage,
-			this.position,
-			this.key,
-			runtimeCondition,
-			this.endContent
-		);
+		this.name = "CaseSensitiveModulesWarning";
+		this.module = sortedModules[0];
 	}
 }
 
-module.exports = ConditionalInitFragment;
+module.exports = CaseSensitiveModulesWarning;
 
 
 /***/ }),
 
-/***/ 11146:
+/***/ 39385:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -29114,3054 +25371,2560 @@ module.exports = ConditionalInitFragment;
 
 
 
-const CachedConstDependency = __webpack_require__(57403);
-const ConstDependency = __webpack_require__(76911);
-const { evaluateToString } = __webpack_require__(93998);
-const { parseResource } = __webpack_require__(82186);
-
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Super} SuperNode */
-/** @typedef {import("./Compiler")} Compiler */
+const ChunkGraph = __webpack_require__(64971);
+const Entrypoint = __webpack_require__(13795);
+const { intersect } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
+const StringXor = __webpack_require__(40293);
+const {
+	compareModulesByIdentifier,
+	compareChunkGroupsByIndex,
+	compareModulesById
+} = __webpack_require__(29579);
+const { createArrayToSetDeprecationSet } = __webpack_require__(64518);
+const { mergeRuntime } = __webpack_require__(17156);
 
-const collectDeclaration = (declarations, pattern) => {
-	const stack = [pattern];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		switch (node.type) {
-			case "Identifier":
-				declarations.add(node.name);
-				break;
-			case "ArrayPattern":
-				for (const element of node.elements) {
-					if (element) {
-						stack.push(element);
-					}
-				}
-				break;
-			case "AssignmentPattern":
-				stack.push(node.left);
-				break;
-			case "ObjectPattern":
-				for (const property of node.properties) {
-					stack.push(property.value);
-				}
-				break;
-			case "RestElement":
-				stack.push(node.argument);
-				break;
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
+/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
+/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
+
+/**
+ * @typedef {Object} WithId an object who has an id property *
+ * @property {string | number} id the id of the object
+ */
+
+/**
+ * @deprecated
+ * @typedef {Object} ChunkMaps
+ * @property {Record<string|number, string>} hash
+ * @property {Record<string|number, Record<string, string>>} contentHash
+ * @property {Record<string|number, string>} name
+ */
+
+/**
+ * @deprecated
+ * @typedef {Object} ChunkModuleMaps
+ * @property {Record<string|number, (string|number)[]>} id
+ * @property {Record<string|number, string>} hash
+ */
+
+let debugId = 1000;
+
+/**
+ * A Chunk is a unit of encapsulation for Modules.
+ * Chunks are "rendered" into bundles that get emitted when the build completes.
+ */
+class Chunk {
+	/**
+	 * @param {string=} name of chunk being created, is optional (for subclasses)
+	 * @param {boolean} backCompat enable backward-compatibility
+	 */
+	constructor(name, backCompat = true) {
+		/** @type {number | string | null} */
+		this.id = null;
+		/** @type {(number|string)[] | null} */
+		this.ids = null;
+		/** @type {number} */
+		this.debugId = debugId++;
+		/** @type {string} */
+		this.name = name;
+		/** @type {SortableSet<string>} */
+		this.idNameHints = new SortableSet();
+		/** @type {boolean} */
+		this.preventIntegration = false;
+		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		this.filenameTemplate = undefined;
+		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		this.cssFilenameTemplate = undefined;
+		/** @private @type {SortableSet<ChunkGroup>} */
+		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
+		/** @type {RuntimeSpec} */
+		this.runtime = undefined;
+		/** @type {Set<string>} */
+		this.files = backCompat ? new ChunkFilesSet() : new Set();
+		/** @type {Set<string>} */
+		this.auxiliaryFiles = new Set();
+		/** @type {boolean} */
+		this.rendered = false;
+		/** @type {string=} */
+		this.hash = undefined;
+		/** @type {Record<string, string>} */
+		this.contentHash = Object.create(null);
+		/** @type {string=} */
+		this.renderedHash = undefined;
+		/** @type {string=} */
+		this.chunkReason = undefined;
+		/** @type {boolean} */
+		this.extraAsync = false;
+	}
+
+	// TODO remove in webpack 6
+	// BACKWARD-COMPAT START
+	get entryModule() {
+		const entryModules = Array.from(
+			ChunkGraph.getChunkGraphForChunk(
+				this,
+				"Chunk.entryModule",
+				"DEP_WEBPACK_CHUNK_ENTRY_MODULE"
+			).getChunkEntryModulesIterable(this)
+		);
+		if (entryModules.length === 0) {
+			return undefined;
+		} else if (entryModules.length === 1) {
+			return entryModules[0];
+		} else {
+			throw new Error(
+				"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
+			);
 		}
 	}
-};
 
-const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
-	const declarations = new Set();
-	const stack = [branch];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		// Some node could be `null` or `undefined`.
-		if (!node) continue;
-		switch (node.type) {
-			// Walk through control statements to look for hoisted declarations.
-			// Some branches are skipped since they do not allow declarations.
-			case "BlockStatement":
-				for (const stmt of node.body) {
-					stack.push(stmt);
-				}
-				break;
-			case "IfStatement":
-				stack.push(node.consequent);
-				stack.push(node.alternate);
-				break;
-			case "ForStatement":
-				stack.push(node.init);
-				stack.push(node.body);
-				break;
-			case "ForInStatement":
-			case "ForOfStatement":
-				stack.push(node.left);
-				stack.push(node.body);
-				break;
-			case "DoWhileStatement":
-			case "WhileStatement":
-			case "LabeledStatement":
-				stack.push(node.body);
-				break;
-			case "SwitchStatement":
-				for (const cs of node.cases) {
-					for (const consequent of cs.consequent) {
-						stack.push(consequent);
-					}
-				}
-				break;
-			case "TryStatement":
-				stack.push(node.block);
-				if (node.handler) {
-					stack.push(node.handler.body);
-				}
-				stack.push(node.finalizer);
-				break;
-			case "FunctionDeclaration":
-				if (includeFunctionDeclarations) {
-					collectDeclaration(declarations, node.id);
-				}
-				break;
-			case "VariableDeclaration":
-				if (node.kind === "var") {
-					for (const decl of node.declarations) {
-						collectDeclaration(declarations, decl.id);
+	/**
+	 * @returns {boolean} true, if the chunk contains an entry module
+	 */
+	hasEntryModule() {
+		return (
+			ChunkGraph.getChunkGraphForChunk(
+				this,
+				"Chunk.hasEntryModule",
+				"DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE"
+			).getNumberOfEntryModules(this) > 0
+		);
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the chunk could be added
+	 */
+	addModule(module) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.addModule",
+			"DEP_WEBPACK_CHUNK_ADD_MODULE"
+		);
+		if (chunkGraph.isModuleInChunk(module, this)) return false;
+		chunkGraph.connectChunkAndModule(this, module);
+		return true;
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	removeModule(module) {
+		ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.removeModule",
+			"DEP_WEBPACK_CHUNK_REMOVE_MODULE"
+		).disconnectChunkAndModule(this, module);
+	}
+
+	/**
+	 * @returns {number} the number of module which are contained in this chunk
+	 */
+	getNumberOfModules() {
+		return ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.getNumberOfModules",
+			"DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES"
+		).getNumberOfChunkModules(this);
+	}
+
+	get modulesIterable() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.modulesIterable",
+			"DEP_WEBPACK_CHUNK_MODULES_ITERABLE"
+		);
+		return chunkGraph.getOrderedChunkModulesIterable(
+			this,
+			compareModulesByIdentifier
+		);
+	}
+
+	/**
+	 * @param {Chunk} otherChunk the chunk to compare with
+	 * @returns {-1|0|1} the comparison result
+	 */
+	compareTo(otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.compareTo",
+			"DEP_WEBPACK_CHUNK_COMPARE_TO"
+		);
+		return chunkGraph.compareChunks(this, otherChunk);
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the chunk contains the module
+	 */
+	containsModule(module) {
+		return ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.containsModule",
+			"DEP_WEBPACK_CHUNK_CONTAINS_MODULE"
+		).isModuleInChunk(module, this);
+	}
+
+	/**
+	 * @returns {Module[]} the modules for this chunk
+	 */
+	getModules() {
+		return ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.getModules",
+			"DEP_WEBPACK_CHUNK_GET_MODULES"
+		).getChunkModules(this);
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	remove() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.remove",
+			"DEP_WEBPACK_CHUNK_REMOVE"
+		);
+		chunkGraph.disconnectChunk(this);
+		this.disconnectFromGroups();
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {Chunk} otherChunk the target chunk
+	 * @returns {void}
+	 */
+	moveModule(module, otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.moveModule",
+			"DEP_WEBPACK_CHUNK_MOVE_MODULE"
+		);
+		chunkGraph.disconnectChunkAndModule(this, module);
+		chunkGraph.connectChunkAndModule(otherChunk, module);
+	}
+
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @returns {boolean} true, if the specified chunk has been integrated
+	 */
+	integrate(otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.integrate",
+			"DEP_WEBPACK_CHUNK_INTEGRATE"
+		);
+		if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
+			chunkGraph.integrateChunks(this, otherChunk);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @returns {boolean} true, if chunks could be integrated
+	 */
+	canBeIntegrated(otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.canBeIntegrated",
+			"DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED"
+		);
+		return chunkGraph.canChunksBeIntegrated(this, otherChunk);
+	}
+
+	/**
+	 * @returns {boolean} true, if this chunk contains no module
+	 */
+	isEmpty() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.isEmpty",
+			"DEP_WEBPACK_CHUNK_IS_EMPTY"
+		);
+		return chunkGraph.getNumberOfChunkModules(this) === 0;
+	}
+
+	/**
+	 * @returns {number} total size of all modules in this chunk
+	 */
+	modulesSize() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.modulesSize",
+			"DEP_WEBPACK_CHUNK_MODULES_SIZE"
+		);
+		return chunkGraph.getChunkModulesSize(this);
+	}
+
+	/**
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of this chunk
+	 */
+	size(options = {}) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.size",
+			"DEP_WEBPACK_CHUNK_SIZE"
+		);
+		return chunkGraph.getChunkSize(this, options);
+	}
+
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of the chunk or false if the chunk can't be integrated
+	 */
+	integratedSize(otherChunk, options) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.integratedSize",
+			"DEP_WEBPACK_CHUNK_INTEGRATED_SIZE"
+		);
+		return chunkGraph.getIntegratedChunksSize(this, otherChunk, options);
+	}
+
+	/**
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @returns {ChunkModuleMaps} module map information
+	 */
+	getChunkModuleMaps(filterFn) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.getChunkModuleMaps",
+			"DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS"
+		);
+		/** @type {Record<string|number, (string|number)[]>} */
+		const chunkModuleIdMap = Object.create(null);
+		/** @type {Record<string|number, string>} */
+		const chunkModuleHashMap = Object.create(null);
+
+		for (const asyncChunk of this.getAllAsyncChunks()) {
+			/** @type {(string|number)[]} */
+			let array;
+			for (const module of chunkGraph.getOrderedChunkModulesIterable(
+				asyncChunk,
+				compareModulesById(chunkGraph)
+			)) {
+				if (filterFn(module)) {
+					if (array === undefined) {
+						array = [];
+						chunkModuleIdMap[asyncChunk.id] = array;
 					}
+					const moduleId = chunkGraph.getModuleId(module);
+					array.push(moduleId);
+					chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash(
+						module,
+						undefined
+					);
 				}
-				break;
+			}
 		}
+
+		return {
+			id: chunkModuleIdMap,
+			hash: chunkModuleHashMap
+		};
 	}
-	return Array.from(declarations);
-};
 
-class ConstPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
+	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
+	 * @returns {boolean} return true if module exists in graph
 	 */
-	apply(compiler) {
-		const cachedParseResource = parseResource.bindCache(compiler.root);
-		compiler.hooks.compilation.tap(
-			"ConstPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
+	hasModuleInGraph(filterFn, filterChunkFn) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.hasModuleInGraph",
+			"DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH"
+		);
+		return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn);
+	}
 
-				compilation.dependencyTemplates.set(
-					CachedConstDependency,
-					new CachedConstDependency.Template()
-				);
+	/**
+	 * @deprecated
+	 * @param {boolean} realHash whether the full hash or the rendered hash is to be used
+	 * @returns {ChunkMaps} the chunk map information
+	 */
+	getChunkMaps(realHash) {
+		/** @type {Record<string|number, string>} */
+		const chunkHashMap = Object.create(null);
+		/** @type {Record<string|number, Record<string, string>>} */
+		const chunkContentHashMap = Object.create(null);
+		/** @type {Record<string|number, string>} */
+		const chunkNameMap = Object.create(null);
 
-				const handler = parser => {
-					parser.hooks.statementIf.tap("ConstPlugin", statement => {
-						if (parser.scope.isAsmJs) return;
-						const param = parser.evaluateExpression(statement.test);
-						const bool = param.asBool();
-						if (typeof bool === "boolean") {
-							if (!param.couldHaveSideEffects()) {
-								const dep = new ConstDependency(`${bool}`, param.range);
-								dep.loc = statement.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							} else {
-								parser.walkExpression(statement.test);
-							}
-							const branchToRemove = bool
-								? statement.alternate
-								: statement.consequent;
-							if (branchToRemove) {
-								// Before removing the dead branch, the hoisted declarations
-								// must be collected.
-								//
-								// Given the following code:
-								//
-								//     if (true) f() else g()
-								//     if (false) {
-								//       function f() {}
-								//       const g = function g() {}
-								//       if (someTest) {
-								//         let a = 1
-								//         var x, {y, z} = obj
-								//       }
-								//     } else {
-								//       …
-								//     }
-								//
-								// the generated code is:
-								//
-								//     if (true) f() else {}
-								//     if (false) {
-								//       var f, x, y, z;   (in loose mode)
-								//       var x, y, z;      (in strict mode)
-								//     } else {
-								//       …
-								//     }
-								//
-								// NOTE: When code runs in strict mode, `var` declarations
-								// are hoisted but `function` declarations don't.
-								//
-								let declarations;
-								if (parser.scope.isStrict) {
-									// If the code runs in strict mode, variable declarations
-									// using `var` must be hoisted.
-									declarations = getHoistedDeclarations(branchToRemove, false);
-								} else {
-									// Otherwise, collect all hoisted declaration.
-									declarations = getHoistedDeclarations(branchToRemove, true);
-								}
-								let replacement;
-								if (declarations.length > 0) {
-									replacement = `{ var ${declarations.join(", ")}; }`;
-								} else {
-									replacement = "{}";
-								}
-								const dep = new ConstDependency(
-									replacement,
-									branchToRemove.range
-								);
-								dep.loc = branchToRemove.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
-							return bool;
-						}
-					});
-					parser.hooks.expressionConditionalOperator.tap(
-						"ConstPlugin",
-						expression => {
-							if (parser.scope.isAsmJs) return;
-							const param = parser.evaluateExpression(expression.test);
-							const bool = param.asBool();
-							if (typeof bool === "boolean") {
-								if (!param.couldHaveSideEffects()) {
-									const dep = new ConstDependency(` ${bool}`, param.range);
-									dep.loc = expression.loc;
-									parser.state.module.addPresentationalDependency(dep);
-								} else {
-									parser.walkExpression(expression.test);
-								}
-								// Expressions do not hoist.
-								// It is safe to remove the dead branch.
-								//
-								// Given the following code:
-								//
-								//   false ? someExpression() : otherExpression();
-								//
-								// the generated code is:
-								//
-								//   false ? 0 : otherExpression();
-								//
-								const branchToRemove = bool
-									? expression.alternate
-									: expression.consequent;
-								const dep = new ConstDependency("0", branchToRemove.range);
-								dep.loc = branchToRemove.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								return bool;
-							}
-						}
-					);
-					parser.hooks.expressionLogicalOperator.tap(
-						"ConstPlugin",
-						expression => {
-							if (parser.scope.isAsmJs) return;
-							if (
-								expression.operator === "&&" ||
-								expression.operator === "||"
-							) {
-								const param = parser.evaluateExpression(expression.left);
-								const bool = param.asBool();
-								if (typeof bool === "boolean") {
-									// Expressions do not hoist.
-									// It is safe to remove the dead branch.
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   falsyExpression() && false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   true && someExpression();
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   truthyExpression() || false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   false && someExpression();
-									//
-									const keepRight =
-										(expression.operator === "&&" && bool) ||
-										(expression.operator === "||" && !bool);
-
-									if (
-										!param.couldHaveSideEffects() &&
-										(param.isBoolean() || keepRight)
-									) {
-										// for case like
-										//
-										//   return'development'===process.env.NODE_ENV&&'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnfalse&&'foo'
-										//
-										const dep = new ConstDependency(` ${bool}`, param.range);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-									} else {
-										parser.walkExpression(expression.left);
-									}
-									if (!keepRight) {
-										const dep = new ConstDependency(
-											"0",
-											expression.right.range
-										);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-									}
-									return keepRight;
-								}
-							} else if (expression.operator === "??") {
-								const param = parser.evaluateExpression(expression.left);
-								const keepRight = param && param.asNullish();
-								if (typeof keepRight === "boolean") {
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nonNullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   nonNullish ?? 0;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   null ?? someExpression();
-									//
-									if (!param.couldHaveSideEffects() && keepRight) {
-										// cspell:word returnnull
-										// for case like
-										//
-										//   return('development'===process.env.NODE_ENV&&null)??'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnnull??'foo'
-										//
-										const dep = new ConstDependency(" null", param.range);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-									} else {
-										const dep = new ConstDependency(
-											"0",
-											expression.right.range
-										);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-										parser.walkExpression(expression.left);
-									}
-
-									return keepRight;
-								}
-							}
-						}
-					);
-					parser.hooks.optionalChaining.tap("ConstPlugin", expr => {
-						/** @type {ExpressionNode[]} */
-						const optionalExpressionsStack = [];
-						/** @type {ExpressionNode|SuperNode} */
-						let next = expr.expression;
-
-						while (
-							next.type === "MemberExpression" ||
-							next.type === "CallExpression"
-						) {
-							if (next.type === "MemberExpression") {
-								if (next.optional) {
-									// SuperNode can not be optional
-									optionalExpressionsStack.push(
-										/** @type {ExpressionNode} */ (next.object)
-									);
-								}
-								next = next.object;
-							} else {
-								if (next.optional) {
-									// SuperNode can not be optional
-									optionalExpressionsStack.push(
-										/** @type {ExpressionNode} */ (next.callee)
-									);
-								}
-								next = next.callee;
-							}
-						}
-
-						while (optionalExpressionsStack.length) {
-							const expression = optionalExpressionsStack.pop();
-							const evaluated = parser.evaluateExpression(expression);
-
-							if (evaluated && evaluated.asNullish()) {
-								// ------------------------------------------
-								//
-								// Given the following code:
-								//
-								//   nullishMemberChain?.a.b();
-								//
-								// the generated code is:
-								//
-								//   undefined;
-								//
-								// ------------------------------------------
-								//
-								const dep = new ConstDependency(" undefined", expr.range);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								return true;
-							}
-						}
-					});
-					parser.hooks.evaluateIdentifier
-						.for("__resourceQuery")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							return evaluateToString(
-								cachedParseResource(parser.state.module.resource).query
-							)(expr);
-						});
-					parser.hooks.expression
-						.for("__resourceQuery")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							const dep = new CachedConstDependency(
-								JSON.stringify(
-									cachedParseResource(parser.state.module.resource).query
-								),
-								expr.range,
-								"__resourceQuery"
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
+		for (const chunk of this.getAllAsyncChunks()) {
+			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
+			for (const key of Object.keys(chunk.contentHash)) {
+				if (!chunkContentHashMap[key]) {
+					chunkContentHashMap[key] = Object.create(null);
+				}
+				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
+			}
+			if (chunk.name) {
+				chunkNameMap[chunk.id] = chunk.name;
+			}
+		}
 
-					parser.hooks.evaluateIdentifier
-						.for("__resourceFragment")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							return evaluateToString(
-								cachedParseResource(parser.state.module.resource).fragment
-							)(expr);
-						});
-					parser.hooks.expression
-						.for("__resourceFragment")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							const dep = new CachedConstDependency(
-								JSON.stringify(
-									cachedParseResource(parser.state.module.resource).fragment
-								),
-								expr.range,
-								"__resourceFragment"
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-				};
+		return {
+			hash: chunkHashMap,
+			contentHash: chunkContentHashMap,
+			name: chunkNameMap
+		};
+	}
+	// BACKWARD-COMPAT END
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ConstPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ConstPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ConstPlugin", handler);
+	/**
+	 * @returns {boolean} whether or not the Chunk will have a runtime
+	 */
+	hasRuntime() {
+		for (const chunkGroup of this._groups) {
+			if (
+				chunkGroup instanceof Entrypoint &&
+				chunkGroup.getRuntimeChunk() === this
+			) {
+				return true;
 			}
-		);
+		}
+		return false;
 	}
-}
-
-module.exports = ConstPlugin;
 
+	/**
+	 * @returns {boolean} whether or not this chunk can be an initial chunk
+	 */
+	canBeInitial() {
+		for (const chunkGroup of this._groups) {
+			if (chunkGroup.isInitial()) return true;
+		}
+		return false;
+	}
 
-/***/ }),
+	/**
+	 * @returns {boolean} whether this chunk can only be an initial chunk
+	 */
+	isOnlyInitial() {
+		if (this._groups.size <= 0) return false;
+		for (const chunkGroup of this._groups) {
+			if (!chunkGroup.isInitial()) return false;
+		}
+		return true;
+	}
 
-/***/ 21411:
-/***/ (function(module) {
+	/**
+	 * @returns {EntryOptions | undefined} the entry options for this chunk
+	 */
+	getEntryOptions() {
+		for (const chunkGroup of this._groups) {
+			if (chunkGroup instanceof Entrypoint) {
+				return chunkGroup.options;
+			}
+		}
+		return undefined;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
+	 * @returns {void}
+	 */
+	addGroup(chunkGroup) {
+		this._groups.add(chunkGroup);
+	}
 
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
+	 * @returns {void}
+	 */
+	removeGroup(chunkGroup) {
+		this._groups.delete(chunkGroup);
+	}
 
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup to check
+	 * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup
+	 */
+	isInGroup(chunkGroup) {
+		return this._groups.has(chunkGroup);
+	}
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
+	/**
+	 * @returns {number} the amount of groups that the said chunk is in
+	 */
+	getNumberOfGroups() {
+		return this._groups.size;
+	}
 
-class ContextExclusionPlugin {
 	/**
-	 * @param {RegExp} negativeMatcher Matcher regular expression
+	 * @returns {Iterable<ChunkGroup>} the chunkGroups that the said chunk is referenced in
 	 */
-	constructor(negativeMatcher) {
-		this.negativeMatcher = negativeMatcher;
+	get groupsIterable() {
+		this._groups.sort();
+		return this._groups;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files => {
-				return files.filter(filePath => !this.negativeMatcher.test(filePath));
-			});
-		});
+	disconnectFromGroups() {
+		for (const chunkGroup of this._groups) {
+			chunkGroup.removeChunk(this);
+		}
 	}
-}
-
-module.exports = ContextExclusionPlugin;
 
+	/**
+	 * @param {Chunk} newChunk the new chunk that will be split out of
+	 * @returns {void}
+	 */
+	split(newChunk) {
+		for (const chunkGroup of this._groups) {
+			chunkGroup.insertChunk(newChunk, this);
+			newChunk.addGroup(chunkGroup);
+		}
+		for (const idHint of this.idNameHints) {
+			newChunk.idNameHints.add(idHint);
+		}
+		newChunk.runtime = mergeRuntime(newChunk.runtime, this.runtime);
+	}
 
-/***/ }),
+	/**
+	 * @param {Hash} hash hash (will be modified)
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	updateHash(hash, chunkGraph) {
+		hash.update(
+			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
+		);
+		const xor = new StringXor();
+		for (const m of chunkGraph.getChunkModulesIterable(this)) {
+			xor.add(chunkGraph.getModuleHash(m, this.runtime));
+		}
+		xor.updateHash(hash);
+		const entryModules =
+			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
+		for (const [m, chunkGroup] of entryModules) {
+			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
+		}
+	}
 
-/***/ 76729:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @returns {Set<Chunk>} a set of all the async chunks
+	 */
+	getAllAsyncChunks() {
+		const queue = new Set();
+		const chunks = new Set();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const initialChunks = intersect(
+			Array.from(this.groupsIterable, g => new Set(g.chunks))
+		);
 
+		const initialQueue = new Set(this.groupsIterable);
 
-
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const { makeWebpackError } = __webpack_require__(11351);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const WebpackError = __webpack_require__(53799);
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	keepOriginalOrder,
-	compareModulesById
-} = __webpack_require__(29579);
-const { contextify, parseResource } = __webpack_require__(82186);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").BuildMeta} BuildMeta */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
-/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-/** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
-
-/**
- * @typedef {Object} ContextOptions
- * @property {ContextMode} mode
- * @property {boolean} recursive
- * @property {RegExp} regExp
- * @property {"strict"|boolean=} namespaceObject
- * @property {string=} addon
- * @property {string=} chunkName
- * @property {RegExp=} include
- * @property {RegExp=} exclude
- * @property {RawChunkGroupOptions=} groupOptions
- * @property {string=} typePrefix
- * @property {string=} category
- * @property {string[][]=} referencedExports exports referenced from modules (won't be mangled)
- */
-
-/**
- * @typedef {Object} ContextModuleOptionsExtras
- * @property {string} resource
- * @property {string=} resourceQuery
- * @property {string=} resourceFragment
- * @property {TODO} resolveOptions
- */
-
-/** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */
-
-/**
- * @callback ResolveDependenciesCallback
- * @param {(Error | null)=} err
- * @param {ContextElementDependency[]=} dependencies
- */
-
-/**
- * @callback ResolveDependencies
- * @param {InputFileSystem} fs
- * @param {ContextModuleOptions} options
- * @param {ResolveDependenciesCallback} callback
- */
-
-const SNAPSHOT_OPTIONS = { timestamp: true };
-
-const TYPES = new Set(["javascript"]);
-
-class ContextModule extends Module {
-	/**
-	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
-	 * @param {ContextModuleOptions} options options object
-	 */
-	constructor(resolveDependencies, options) {
-		const parsed = parseResource(options ? options.resource : "");
-		const resource = parsed.path;
-		const resourceQuery = (options && options.resourceQuery) || parsed.query;
-		const resourceFragment =
-			(options && options.resourceFragment) || parsed.fragment;
-
-		super("javascript/dynamic", resource);
-
-		// Info from Factory
-		this.resolveDependencies = resolveDependencies;
-		/** @type {ContextModuleOptions} */
-		this.options = {
-			...options,
-			resource,
-			resourceQuery,
-			resourceFragment
-		};
-		if (options && options.resolveOptions !== undefined) {
-			this.resolveOptions = options.resolveOptions;
+		for (const chunkGroup of initialQueue) {
+			for (const child of chunkGroup.childrenIterable) {
+				if (child instanceof Entrypoint) {
+					initialQueue.add(child);
+				} else {
+					queue.add(child);
+				}
+			}
 		}
 
-		if (options && typeof options.mode !== "string") {
-			throw new Error("options.mode is a required option");
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				if (!initialChunks.has(chunk)) {
+					chunks.add(chunk);
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
 		}
 
-		this._identifier = this._createIdentifier();
-		this._forceBuild = true;
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
+		return chunks;
 	}
 
 	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
+	 * @returns {Set<Chunk>} a set of all the initial chunks (including itself)
 	 */
-	updateCacheModule(module) {
-		const m = /** @type {ContextModule} */ (module);
-		this.resolveDependencies = m.resolveDependencies;
-		this.options = m.options;
+	getAllInitialChunks() {
+		const chunks = new Set();
+		const queue = new Set(this.groupsIterable);
+		for (const group of queue) {
+			if (group.isInitial()) {
+				for (const c of group.chunks) chunks.add(c);
+				for (const g of group.childrenIterable) queue.add(g);
+			}
+		}
+		return chunks;
 	}
 
 	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 * @returns {Set<Chunk>} a set of all the referenced chunks (including itself)
 	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.resolveDependencies = undefined;
-	}
-
-	_prettyRegExp(regexString, stripSlash = true) {
-		const str = (regexString + "").replace(/!/g, "%21").replace(/\|/g, "%7C");
-		return stripSlash ? str.substring(1, str.length - 1) : str;
-	}
+	getAllReferencedChunks() {
+		const queue = new Set(this.groupsIterable);
+		const chunks = new Set();
 
-	_createIdentifier() {
-		let identifier = this.context;
-		if (this.options.resourceQuery) {
-			identifier += `|${this.options.resourceQuery}`;
-		}
-		if (this.options.resourceFragment) {
-			identifier += `|${this.options.resourceFragment}`;
-		}
-		if (this.options.mode) {
-			identifier += `|${this.options.mode}`;
-		}
-		if (!this.options.recursive) {
-			identifier += "|nonrecursive";
-		}
-		if (this.options.addon) {
-			identifier += `|${this.options.addon}`;
-		}
-		if (this.options.regExp) {
-			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
-		}
-		if (this.options.include) {
-			identifier += `|include: ${this._prettyRegExp(
-				this.options.include,
-				false
-			)}`;
-		}
-		if (this.options.exclude) {
-			identifier += `|exclude: ${this._prettyRegExp(
-				this.options.exclude,
-				false
-			)}`;
-		}
-		if (this.options.referencedExports) {
-			identifier += `|referencedExports: ${JSON.stringify(
-				this.options.referencedExports
-			)}`;
-		}
-		if (this.options.chunkName) {
-			identifier += `|chunkName: ${this.options.chunkName}`;
-		}
-		if (this.options.groupOptions) {
-			identifier += `|groupOptions: ${JSON.stringify(
-				this.options.groupOptions
-			)}`;
-		}
-		if (this.options.namespaceObject === "strict") {
-			identifier += "|strict namespace object";
-		} else if (this.options.namespaceObject) {
-			identifier += "|namespace object";
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				chunks.add(chunk);
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
 		}
 
-		return identifier;
+		return chunks;
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @returns {Set<Entrypoint>} a set of all the referenced entrypoints
 	 */
-	identifier() {
-		return this._identifier;
-	}
+	getAllReferencedAsyncEntrypoints() {
+		const queue = new Set(this.groupsIterable);
+		const entrypoints = new Set();
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		let identifier = requestShortener.shorten(this.context) + "/";
-		if (this.options.resourceQuery) {
-			identifier += ` ${this.options.resourceQuery}`;
-		}
-		if (this.options.mode) {
-			identifier += ` ${this.options.mode}`;
-		}
-		if (!this.options.recursive) {
-			identifier += " nonrecursive";
-		}
-		if (this.options.addon) {
-			identifier += ` ${requestShortener.shorten(this.options.addon)}`;
-		}
-		if (this.options.regExp) {
-			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
-		}
-		if (this.options.include) {
-			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
-		}
-		if (this.options.exclude) {
-			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
-		}
-		if (this.options.referencedExports) {
-			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
-				.join(", ")}`;
-		}
-		if (this.options.chunkName) {
-			identifier += ` chunkName: ${this.options.chunkName}`;
-		}
-		if (this.options.groupOptions) {
-			const groupOptions = this.options.groupOptions;
-			for (const key of Object.keys(groupOptions)) {
-				identifier += ` ${key}: ${groupOptions[key]}`;
+		for (const chunkGroup of queue) {
+			for (const entrypoint of chunkGroup.asyncEntrypointsIterable) {
+				entrypoints.add(entrypoint);
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
 			}
-		}
-		if (this.options.namespaceObject === "strict") {
-			identifier += " strict namespace object";
-		} else if (this.options.namespaceObject) {
-			identifier += " namespace object";
 		}
 
-		return identifier;
+		return entrypoints;
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {boolean} true, if the chunk references async chunks
 	 */
-	libIdent(options) {
-		let identifier = contextify(
-			options.context,
-			this.context,
-			options.associatedObjectForCache
+	hasAsyncChunks() {
+		const queue = new Set();
+
+		const initialChunks = intersect(
+			Array.from(this.groupsIterable, g => new Set(g.chunks))
 		);
-		if (this.layer) identifier = `(${this.layer})/${identifier}`;
-		if (this.options.mode) {
-			identifier += ` ${this.options.mode}`;
-		}
-		if (this.options.recursive) {
-			identifier += " recursive";
-		}
-		if (this.options.addon) {
-			identifier += ` ${contextify(
-				options.context,
-				this.options.addon,
-				options.associatedObjectForCache
-			)}`;
-		}
-		if (this.options.regExp) {
-			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
-		}
-		if (this.options.include) {
-			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
-		}
-		if (this.options.exclude) {
-			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+
+		for (const chunkGroup of this.groupsIterable) {
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
 		}
-		if (this.options.referencedExports) {
-			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
-				.join(", ")}`;
+
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				if (!initialChunks.has(chunk)) {
+					return true;
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
 		}
 
-		return identifier;
+		return false;
 	}
 
 	/**
-	 * @returns {void}
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
+	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
 	 */
-	invalidateBuild() {
-		this._forceBuild = true;
+	getChildIdsByOrders(chunkGraph, filterFn) {
+		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
+		const lists = new Map();
+		for (const group of this.groupsIterable) {
+			if (group.chunks[group.chunks.length - 1] === this) {
+				for (const childGroup of group.childrenIterable) {
+					for (const key of Object.keys(childGroup.options)) {
+						if (key.endsWith("Order")) {
+							const name = key.substr(0, key.length - "Order".length);
+							let list = lists.get(name);
+							if (list === undefined) {
+								list = [];
+								lists.set(name, list);
+							}
+							list.push({
+								order: childGroup.options[key],
+								group: childGroup
+							});
+						}
+					}
+				}
+			}
+		}
+		/** @type {Record<string, (string | number)[]>} */
+		const result = Object.create(null);
+		for (const [name, list] of lists) {
+			list.sort((a, b) => {
+				const cmp = b.order - a.order;
+				if (cmp !== 0) return cmp;
+				return a.group.compareTo(chunkGraph, b.group);
+			});
+			/** @type {Set<string | number>} */
+			const chunkIdSet = new Set();
+			for (const item of list) {
+				for (const chunk of item.group.chunks) {
+					if (filterFn && !filterFn(chunk, chunkGraph)) continue;
+					chunkIdSet.add(chunk.id);
+				}
+			}
+			if (chunkIdSet.size > 0) {
+				result[name] = Array.from(chunkIdSet);
+			}
+		}
+		return result;
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {string} type option name
+	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
 	 */
-	needBuild({ fileSystemInfo }, callback) {
-		// build if enforced
-		if (this._forceBuild) return callback(null, true);
-
-		// always build when we have no snapshot
-		if (!this.buildInfo.snapshot) return callback(null, true);
-
-		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
-			callback(err, !valid);
+	getChildrenOfTypeInOrder(chunkGraph, type) {
+		const list = [];
+		for (const group of this.groupsIterable) {
+			for (const childGroup of group.childrenIterable) {
+				const order = childGroup.options[type];
+				if (order === undefined) continue;
+				list.push({
+					order,
+					group,
+					childGroup
+				});
+			}
+		}
+		if (list.length === 0) return undefined;
+		list.sort((a, b) => {
+			const cmp = b.order - a.order;
+			if (cmp !== 0) return cmp;
+			return a.group.compareTo(chunkGraph, b.group);
 		});
+		const result = [];
+		let lastEntry;
+		for (const { group, childGroup } of list) {
+			if (lastEntry && lastEntry.onChunks === group.chunks) {
+				for (const chunk of childGroup.chunks) {
+					lastEntry.chunks.add(chunk);
+				}
+			} else {
+				result.push(
+					(lastEntry = {
+						onChunks: group.chunks,
+						chunks: new Set(childGroup.chunks)
+					})
+				);
+			}
+		}
+		return result;
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
+	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
+	 * @returns {Record<string|number, Record<string, (string | number)[]>>} a record object of names to lists of child ids(?) by chunk id
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this._forceBuild = false;
-		/** @type {BuildMeta} */
-		this.buildMeta = {
-			exportsType: "default",
-			defaultObject: "redirect-warn"
-		};
-		this.buildInfo = {
-			snapshot: undefined
-		};
-		this.dependencies.length = 0;
-		this.blocks.length = 0;
-		const startTime = Date.now();
-		this.resolveDependencies(fs, this.options, (err, dependencies) => {
-			if (err) {
-				return callback(
-					makeWebpackError(err, "ContextModule.resolveDependencies")
-				);
-			}
+	getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
+		/** @type {Record<string|number, Record<string, (string | number)[]>>} */
+		const chunkMaps = Object.create(null);
 
-			// abort if something failed
-			// this will create an empty context
-			if (!dependencies) {
-				callback();
-				return;
+		/**
+		 * @param {Chunk} chunk a chunk
+		 * @returns {void}
+		 */
+		const addChildIdsByOrdersToMap = chunk => {
+			const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
+			for (const key of Object.keys(data)) {
+				let chunkMap = chunkMaps[key];
+				if (chunkMap === undefined) {
+					chunkMaps[key] = chunkMap = Object.create(null);
+				}
+				chunkMap[chunk.id] = data[key];
 			}
+		};
 
-			// enhance dependencies with meta info
-			for (const dep of dependencies) {
-				dep.loc = {
-					name: dep.userRequest
-				};
-				dep.request = this.options.addon + dep.request;
+		if (includeDirectChildren) {
+			/** @type {Set<Chunk>} */
+			const chunks = new Set();
+			for (const chunkGroup of this.groupsIterable) {
+				for (const chunk of chunkGroup.chunks) {
+					chunks.add(chunk);
+				}
 			}
-			dependencies.sort(
-				concatComparators(
-					compareSelect(a => a.loc, compareLocations),
-					keepOriginalOrder(this.dependencies)
-				)
-			);
-
-			if (this.options.mode === "sync" || this.options.mode === "eager") {
-				// if we have an sync or eager context
-				// just add all dependencies and continue
-				this.dependencies = dependencies;
-			} else if (this.options.mode === "lazy-once") {
-				// for the lazy-once mode create a new async dependency block
-				// and add that block to this context
-				if (dependencies.length > 0) {
-					const block = new AsyncDependenciesBlock({
-						...this.options.groupOptions,
-						name: this.options.chunkName
-					});
-					for (const dep of dependencies) {
-						block.addDependency(dep);
-					}
-					this.addBlock(block);
-				}
-			} else if (
-				this.options.mode === "weak" ||
-				this.options.mode === "async-weak"
-			) {
-				// we mark all dependencies as weak
-				for (const dep of dependencies) {
-					dep.weak = true;
-				}
-				this.dependencies = dependencies;
-			} else if (this.options.mode === "lazy") {
-				// if we are lazy create a new async dependency block per dependency
-				// and add all blocks to this context
-				let index = 0;
-				for (const dep of dependencies) {
-					let chunkName = this.options.chunkName;
-					if (chunkName) {
-						if (!/\[(index|request)\]/.test(chunkName)) {
-							chunkName += "[index]";
-						}
-						chunkName = chunkName.replace(/\[index\]/g, `${index++}`);
-						chunkName = chunkName.replace(
-							/\[request\]/g,
-							Template.toPath(dep.userRequest)
-						);
-					}
-					const block = new AsyncDependenciesBlock(
-						{
-							...this.options.groupOptions,
-							name: chunkName
-						},
-						dep.loc,
-						dep.userRequest
-					);
-					block.addDependency(dep);
-					this.addBlock(block);
-				}
-			} else {
-				callback(
-					new WebpackError(`Unsupported mode "${this.options.mode}" in context`)
-				);
-				return;
+			for (const chunk of chunks) {
+				addChildIdsByOrdersToMap(chunk);
 			}
-			compilation.fileSystemInfo.createSnapshot(
-				startTime,
-				null,
-				[this.context],
-				null,
-				SNAPSHOT_OPTIONS,
-				(err, snapshot) => {
-					if (err) return callback(err);
-					this.buildInfo.snapshot = snapshot;
-					callback();
-				}
-			);
-		});
+		}
+
+		for (const chunk of this.getAllAsyncChunks()) {
+			addChildIdsByOrdersToMap(chunk);
+		}
+
+		return chunkMaps;
 	}
+}
 
-	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
-	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {
-		contextDependencies.add(this.context);
+module.exports = Chunk;
+
+
+/***/ }),
+
+/***/ 64971:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const util = __webpack_require__(73837);
+const Entrypoint = __webpack_require__(13795);
+const ModuleGraphConnection = __webpack_require__(40639);
+const { first } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
+const {
+	compareModulesById,
+	compareIterables,
+	compareModulesByIdentifier,
+	concatComparators,
+	compareSelect,
+	compareIds
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const findGraphRoots = __webpack_require__(6261);
+const {
+	RuntimeSpecMap,
+	RuntimeSpecSet,
+	runtimeToString,
+	mergeRuntime,
+	forEachRuntime
+} = __webpack_require__(17156);
+
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+/** @type {ReadonlySet<string>} */
+const EMPTY_SET = new Set();
+
+const ZERO_BIG_INT = BigInt(0);
+
+const compareModuleIterables = compareIterables(compareModulesByIdentifier);
+
+/** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
+/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
+
+/**
+ * @typedef {Object} ChunkSizeOptions
+ * @property {number=} chunkOverhead constant overhead for a chunk
+ * @property {number=} entryChunkMultiplicator multiplicator for initial chunks
+ */
+
+class ModuleHashInfo {
+	constructor(hash, renderedHash) {
+		this.hash = hash;
+		this.renderedHash = renderedHash;
 	}
+}
 
-	/**
-	 * @param {ContextElementDependency[]} dependencies all dependencies
-	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {TODO} TODO
-	 */
-	getUserRequestMap(dependencies, chunkGraph) {
-		const moduleGraph = chunkGraph.moduleGraph;
-		// if we filter first we get a new array
-		// therefore we don't need to create a clone of dependencies explicitly
-		// therefore the order of this is !important!
-		const sortedDependencies = dependencies
-			.filter(dependency => moduleGraph.getModule(dependency))
-			.sort((a, b) => {
-				if (a.userRequest === b.userRequest) {
-					return 0;
-				}
-				return a.userRequest < b.userRequest ? -1 : 1;
-			});
-		const map = Object.create(null);
-		for (const dep of sortedDependencies) {
-			const module = moduleGraph.getModule(dep);
-			map[dep.userRequest] = chunkGraph.getModuleId(module);
-		}
-		return map;
+/** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
+
+/**
+ * @template T
+ * @param {SortableSet<T>} set the set
+ * @returns {T[]} set as array
+ */
+const getArray = set => {
+	return Array.from(set);
+};
+
+/**
+ * @param {SortableSet<Chunk>} chunks the chunks
+ * @returns {RuntimeSpecSet} runtimes
+ */
+const getModuleRuntimes = chunks => {
+	const runtimes = new RuntimeSpecSet();
+	for (const chunk of chunks) {
+		runtimes.add(chunk.runtime);
 	}
+	return runtimes;
+};
 
-	/**
-	 * @param {ContextElementDependency[]} dependencies all dependencies
-	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {TODO} TODO
-	 */
-	getFakeMap(dependencies, chunkGraph) {
-		if (!this.options.namespaceObject) {
-			return 9;
-		}
-		const moduleGraph = chunkGraph.moduleGraph;
-		// bitfield
-		let hasType = 0;
-		const comparator = compareModulesById(chunkGraph);
-		// if we filter first we get a new array
-		// therefore we don't need to create a clone of dependencies explicitly
-		// therefore the order of this is !important!
-		const sortedModules = dependencies
-			.map(dependency => moduleGraph.getModule(dependency))
-			.filter(Boolean)
-			.sort(comparator);
-		const fakeMap = Object.create(null);
-		for (const module of sortedModules) {
-			const exportsType = module.getExportsType(
-				moduleGraph,
-				this.options.namespaceObject === "strict"
-			);
-			const id = chunkGraph.getModuleId(module);
-			switch (exportsType) {
-				case "namespace":
-					fakeMap[id] = 9;
-					hasType |= 1;
-					break;
-				case "dynamic":
-					fakeMap[id] = 7;
-					hasType |= 2;
-					break;
-				case "default-only":
-					fakeMap[id] = 1;
-					hasType |= 4;
-					break;
-				case "default-with-named":
-					fakeMap[id] = 3;
-					hasType |= 8;
-					break;
-				default:
-					throw new Error(`Unexpected exports type ${exportsType}`);
+/**
+ * @param {SortableSet<Module>} set the set
+ * @returns {Map<string, SortableSet<Module>>} modules by source type
+ */
+const modulesBySourceType = set => {
+	/** @type {Map<string, SortableSet<Module>>} */
+	const map = new Map();
+	for (const module of set) {
+		for (const sourceType of module.getSourceTypes()) {
+			let innerSet = map.get(sourceType);
+			if (innerSet === undefined) {
+				innerSet = new SortableSet();
+				map.set(sourceType, innerSet);
 			}
+			innerSet.add(module);
 		}
-		if (hasType === 1) {
-			return 9;
-		}
-		if (hasType === 2) {
-			return 7;
-		}
-		if (hasType === 4) {
-			return 1;
-		}
-		if (hasType === 8) {
-			return 3;
-		}
-		if (hasType === 0) {
-			return 9;
+	}
+	for (const [key, innerSet] of map) {
+		// When all modules have the source type, we reuse the original SortableSet
+		// to benefit from the shared cache (especially for sorting)
+		if (innerSet.size === set.size) {
+			map.set(key, set);
 		}
-		return fakeMap;
 	}
+	return map;
+};
 
-	getFakeMapInitStatement(fakeMap) {
-		return typeof fakeMap === "object"
-			? `var fakeMap = ${JSON.stringify(fakeMap, null, "\t")};`
-			: "";
-	}
+/** @type {WeakMap<Function, any>} */
+const createOrderedArrayFunctionMap = new WeakMap();
 
-	getReturn(type, asyncModule) {
-		if (type === 9) {
-			return "__webpack_require__(id)";
+/**
+ * @template T
+ * @param {function(T, T): -1|0|1} comparator comparator function
+ * @returns {SetToArrayFunction<T>} set as ordered array
+ */
+const createOrderedArrayFunction = comparator => {
+	/** @type {SetToArrayFunction<T>} */
+	let fn = createOrderedArrayFunctionMap.get(comparator);
+	if (fn !== undefined) return fn;
+	fn = set => {
+		set.sortWith(comparator);
+		return Array.from(set);
+	};
+	createOrderedArrayFunctionMap.set(comparator, fn);
+	return fn;
+};
+
+/**
+ * @param {Iterable<Module>} modules the modules to get the count/size of
+ * @returns {number} the size of the modules
+ */
+const getModulesSize = modules => {
+	let size = 0;
+	for (const module of modules) {
+		for (const type of module.getSourceTypes()) {
+			size += module.size(type);
 		}
-		return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${
-			asyncModule ? " | 16" : ""
-		})`;
 	}
+	return size;
+};
 
-	getReturnModuleObjectSource(
-		fakeMap,
-		asyncModule,
-		fakeMapDataExpression = "fakeMap[id]"
-	) {
-		if (typeof fakeMap === "number") {
-			return `return ${this.getReturn(fakeMap, asyncModule)};`;
+/**
+ * @param {Iterable<Module>} modules the sortable Set to get the size of
+ * @returns {Record<string, number>} the sizes of the modules
+ */
+const getModulesSizes = modules => {
+	let sizes = Object.create(null);
+	for (const module of modules) {
+		for (const type of module.getSourceTypes()) {
+			sizes[type] = (sizes[type] || 0) + module.size(type);
 		}
-		return `return ${
-			RuntimeGlobals.createFakeNamespaceObject
-		}(id, ${fakeMapDataExpression}${asyncModule ? " | 16" : ""})`;
 	}
+	return sizes;
+};
 
-	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {string} source code
-	 */
-	getSyncSource(dependencies, id, chunkGraph) {
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
+/**
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {boolean} true, if a is always a parent of b
+ */
+const isAvailableChunk = (a, b) => {
+	const queue = new Set(b.groupsIterable);
+	for (const chunkGroup of queue) {
+		if (a.isInGroup(chunkGroup)) continue;
+		if (chunkGroup.isInitial()) return false;
+		for (const parent of chunkGroup.parentsIterable) {
+			queue.add(parent);
+		}
+	}
+	return true;
+};
 
-function webpackContext(req) {
-	var id = webpackContextResolve(req);
-	${returnModuleObject}
-}
-function webpackContextResolve(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		var e = new Error("Cannot find module '" + req + "'");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
+class ChunkGraphModule {
+	constructor() {
+		/** @type {SortableSet<Chunk>} */
+		this.chunks = new SortableSet();
+		/** @type {Set<Chunk> | undefined} */
+		this.entryInChunks = undefined;
+		/** @type {Set<Chunk> | undefined} */
+		this.runtimeInChunks = undefined;
+		/** @type {RuntimeSpecMap<ModuleHashInfo>} */
+		this.hashes = undefined;
+		/** @type {string | number} */
+		this.id = null;
+		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
+		this.runtimeRequirements = undefined;
+		/** @type {RuntimeSpecMap<string>} */
+		this.graphHashes = undefined;
+		/** @type {RuntimeSpecMap<string>} */
+		this.graphHashesWithConnections = undefined;
 	}
-	return map[req];
 }
-webpackContext.keys = function webpackContextKeys() {
-	return Object.keys(map);
-};
-webpackContext.resolve = webpackContextResolve;
-module.exports = webpackContext;
-webpackContext.id = ${JSON.stringify(id)};`;
+
+class ChunkGraphChunk {
+	constructor() {
+		/** @type {SortableSet<Module>} */
+		this.modules = new SortableSet();
+		/** @type {Map<Module, Entrypoint>} */
+		this.entryModules = new Map();
+		/** @type {SortableSet<RuntimeModule>} */
+		this.runtimeModules = new SortableSet();
+		/** @type {Set<RuntimeModule> | undefined} */
+		this.fullHashModules = undefined;
+		/** @type {Set<RuntimeModule> | undefined} */
+		this.dependentHashModules = undefined;
+		/** @type {Set<string> | undefined} */
+		this.runtimeRequirements = undefined;
+		/** @type {Set<string>} */
+		this.runtimeRequirementsInTree = new Set();
 	}
+}
 
+class ChunkGraph {
 	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {string} source code
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	getWeakSyncSource(dependencies, id, chunkGraph) {
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+	constructor(moduleGraph, hashFunction = "md4") {
+		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
+		this._modules = new WeakMap();
+		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
+		this._chunks = new WeakMap();
+		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
+		this._blockChunkGroups = new WeakMap();
+		/** @private @type {Map<string, string | number>} */
+		this._runtimeIds = new Map();
+		/** @type {ModuleGraph} */
+		this.moduleGraph = moduleGraph;
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
+		this._hashFunction = hashFunction;
 
-function webpackContext(req) {
-	var id = webpackContextResolve(req);
-	if(!${RuntimeGlobals.moduleFactories}[id]) {
-		var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	}
-	${returnModuleObject}
-}
-function webpackContextResolve(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		var e = new Error("Cannot find module '" + req + "'");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	}
-	return map[req];
-}
-webpackContext.keys = function webpackContextKeys() {
-	return Object.keys(map);
-};
-webpackContext.resolve = webpackContextResolve;
-webpackContext.id = ${JSON.stringify(id)};
-module.exports = webpackContext;`;
+		this._getGraphRoots = this._getGraphRoots.bind(this);
 	}
 
 	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} context context
-	 * @param {ChunkGraph} context.chunkGraph the chunk graph
-	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
-	 * @returns {string} source code
+	 * @private
+	 * @param {Module} module the module
+	 * @returns {ChunkGraphModule} internal module
 	 */
-	getAsyncWeakSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap, true);
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
+	_getChunkGraphModule(module) {
+		let cgm = this._modules.get(module);
+		if (cgm === undefined) {
+			cgm = new ChunkGraphModule();
+			this._modules.set(module, cgm);
+		}
+		return cgm;
+	}
 
-function webpackAsyncContext(req) {
-	return webpackAsyncContextResolve(req).then(${
-		arrow ? "id =>" : "function(id)"
-	} {
-		if(!${RuntimeGlobals.moduleFactories}[id]) {
-			var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
-		}
-		${returnModuleObject}
-	});
-}
-function webpackAsyncContextResolve(req) {
-	// Here Promise.resolve().then() is used instead of new Promise() to prevent
-	// uncaught exception popping up in devtools
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
+	/**
+	 * @private
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ChunkGraphChunk} internal chunk
+	 */
+	_getChunkGraphChunk(chunk) {
+		let cgc = this._chunks.get(chunk);
+		if (cgc === undefined) {
+			cgc = new ChunkGraphChunk();
+			this._chunks.set(chunk, cgc);
 		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
+		return cgc;
 	}
 
 	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} context context
-	 * @param {ChunkGraph} context.chunkGraph the chunk graph
-	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
-	 * @returns {string} source code
+	 * @param {SortableSet<Module>} set the sortable Set to get the roots of
+	 * @returns {Module[]} the graph roots
 	 */
-	getEagerSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const thenFunction =
-			fakeMap !== 9
-				? `${arrow ? "id =>" : "function(id)"} {
-		${this.getReturnModuleObjectSource(fakeMap)}
-	}`
-				: "__webpack_require__";
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-
-function webpackAsyncContext(req) {
-	return webpackAsyncContextResolve(req).then(${thenFunction});
-}
-function webpackAsyncContextResolve(req) {
-	// Here Promise.resolve().then() is used instead of new Promise() to prevent
-	// uncaught exception popping up in devtools
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
-		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
+	_getGraphRoots(set) {
+		const { moduleGraph } = this;
+		return Array.from(
+			findGraphRoots(set, module => {
+				/** @type {Set<Module>} */
+				const set = new Set();
+				const addDependencies = module => {
+					for (const connection of moduleGraph.getOutgoingConnections(module)) {
+						if (!connection.module) continue;
+						const activeState = connection.getActiveState(undefined);
+						if (activeState === false) continue;
+						if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
+							addDependencies(connection.module);
+							continue;
+						}
+						set.add(connection.module);
+					}
+				};
+				addDependencies(module);
+				return set;
+			})
+		).sort(compareModulesByIdentifier);
 	}
 
 	/**
-	 * @param {TODO} block TODO
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} options options object
-	 * @param {RuntimeTemplate} options.runtimeTemplate the runtime template
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @returns {string} source code
+	 * @param {Chunk} chunk the new chunk
+	 * @param {Module} module the module
+	 * @returns {void}
 	 */
-	getLazyOnceSource(block, dependencies, id, { runtimeTemplate, chunkGraph }) {
-		const promise = runtimeTemplate.blockPromise({
-			chunkGraph,
-			block,
-			message: "lazy-once context",
-			runtimeRequirements: new Set()
-		});
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const thenFunction =
-			fakeMap !== 9
-				? `${arrow ? "id =>" : "function(id)"} {
-		${this.getReturnModuleObjectSource(fakeMap, true)};
-	}`
-				: "__webpack_require__";
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
+	connectChunkAndModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgm.chunks.add(chunk);
+		cgc.modules.add(module);
+	}
 
-function webpackAsyncContext(req) {
-	return webpackAsyncContextResolve(req).then(${thenFunction});
-}
-function webpackAsyncContextResolve(req) {
-	return ${promise}.then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
-		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	disconnectChunkAndModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgc.modules.delete(module);
+		cgm.chunks.delete(chunk);
 	}
 
 	/**
-	 * @param {TODO} blocks TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} context context
-	 * @param {ChunkGraph} context.chunkGraph the chunk graph
-	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
-	 * @returns {string} source code
+	 * @param {Chunk} chunk the chunk which will be disconnected
+	 * @returns {void}
 	 */
-	getLazySource(blocks, id, { chunkGraph, runtimeTemplate }) {
-		const moduleGraph = chunkGraph.moduleGraph;
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		let hasMultipleOrNoChunks = false;
-		let hasNoChunk = true;
-		const fakeMap = this.getFakeMap(
-			blocks.map(b => b.dependencies[0]),
-			chunkGraph
-		);
-		const hasFakeMap = typeof fakeMap === "object";
-		const items = blocks
-			.map(block => {
-				const dependency = block.dependencies[0];
-				return {
-					dependency: dependency,
-					module: moduleGraph.getModule(dependency),
-					block: block,
-					userRequest: dependency.userRequest,
-					chunks: undefined
-				};
-			})
-			.filter(item => item.module);
-		for (const item of items) {
-			const chunkGroup = chunkGraph.getBlockChunkGroup(item.block);
-			const chunks = (chunkGroup && chunkGroup.chunks) || [];
-			item.chunks = chunks;
-			if (chunks.length > 0) {
-				hasNoChunk = false;
-			}
-			if (chunks.length !== 1) {
-				hasMultipleOrNoChunks = true;
-			}
-		}
-		const shortMode = hasNoChunk && !hasFakeMap;
-		const sortedItems = items.sort((a, b) => {
-			if (a.userRequest === b.userRequest) return 0;
-			return a.userRequest < b.userRequest ? -1 : 1;
-		});
-		const map = Object.create(null);
-		for (const item of sortedItems) {
-			const moduleId = chunkGraph.getModuleId(item.module);
-			if (shortMode) {
-				map[item.userRequest] = moduleId;
-			} else {
-				const arrayStart = [moduleId];
-				if (hasFakeMap) {
-					arrayStart.push(fakeMap[moduleId]);
-				}
-				map[item.userRequest] = arrayStart.concat(
-					item.chunks.map(chunk => chunk.id)
-				);
-			}
+	disconnectChunk(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of cgc.modules) {
+			const cgm = this._getChunkGraphModule(module);
+			cgm.chunks.delete(chunk);
 		}
+		cgc.modules.clear();
+		chunk.disconnectFromGroups();
+		ChunkGraph.clearChunkGraphForChunk(chunk);
+	}
 
-		const chunksStartPosition = hasFakeMap ? 2 : 1;
-		const requestPrefix = hasNoChunk
-			? "Promise.resolve()"
-			: hasMultipleOrNoChunks
-			? `Promise.all(ids.slice(${chunksStartPosition}).map(${RuntimeGlobals.ensureChunk}))`
-			: `${RuntimeGlobals.ensureChunk}(ids[${chunksStartPosition}])`;
-		const returnModuleObject = this.getReturnModuleObjectSource(
-			fakeMap,
-			true,
-			shortMode ? "invalid" : "ids[1]"
-		);
-
-		const webpackAsyncContext =
-			requestPrefix === "Promise.resolve()"
-				? `
-function webpackAsyncContext(req) {
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<Module>} modules the modules
+	 * @returns {void}
+	 */
+	attachModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of modules) {
+			cgc.modules.add(module);
 		}
-
-		${shortMode ? "var id = map[req];" : "var ids = map[req], id = ids[0];"}
-		${returnModuleObject}
-	});
-}`
-				: `function webpackAsyncContext(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
-		});
 	}
 
-	var ids = map[req], id = ids[0];
-	return ${requestPrefix}.then(${arrow ? "() =>" : "function()"} {
-		${returnModuleObject}
-	});
-}`;
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${webpackAsyncContext}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the runtime modules
+	 * @returns {void}
+	 */
+	attachRuntimeModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of modules) {
+			cgc.runtimeModules.add(module);
+		}
 	}
 
-	getSourceForEmptyContext(id, runtimeTemplate) {
-		return `function webpackEmptyContext(req) {
-	var e = new Error("Cannot find module '" + req + "'");
-	e.code = 'MODULE_NOT_FOUND';
-	throw e;
-}
-webpackEmptyContext.keys = ${runtimeTemplate.returningFunction("[]")};
-webpackEmptyContext.resolve = webpackEmptyContext;
-webpackEmptyContext.id = ${JSON.stringify(id)};
-module.exports = webpackEmptyContext;`;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
+	 * @returns {void}
+	 */
+	attachFullHashModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
+		for (const module of modules) {
+			cgc.fullHashModules.add(module);
+		}
 	}
 
-	getSourceForEmptyAsyncContext(id, runtimeTemplate) {
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		return `function webpackEmptyAsyncContext(req) {
-	// Here Promise.resolve().then() is used instead of new Promise() to prevent
-	// uncaught exception popping up in devtools
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		var e = new Error("Cannot find module '" + req + "'");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	});
-}
-webpackEmptyAsyncContext.keys = ${runtimeTemplate.returningFunction("[]")};
-webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
-webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackEmptyAsyncContext;`;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
+	 * @returns {void}
+	 */
+	attachDependentHashModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined)
+			cgc.dependentHashModules = new Set();
+		for (const module of modules) {
+			cgc.dependentHashModules.add(module);
+		}
 	}
 
 	/**
-	 * @param {string} asyncMode module mode
-	 * @param {CodeGenerationContext} context context info
-	 * @returns {string} the source code
+	 * @param {Module} oldModule the replaced module
+	 * @param {Module} newModule the replacing module
+	 * @returns {void}
 	 */
-	getSourceString(asyncMode, { runtimeTemplate, chunkGraph }) {
-		const id = chunkGraph.getModuleId(this);
-		if (asyncMode === "lazy") {
-			if (this.blocks && this.blocks.length > 0) {
-				return this.getLazySource(this.blocks, id, {
-					runtimeTemplate,
-					chunkGraph
-				});
-			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+	replaceModule(oldModule, newModule) {
+		const oldCgm = this._getChunkGraphModule(oldModule);
+		const newCgm = this._getChunkGraphModule(newModule);
+
+		for (const chunk of oldCgm.chunks) {
+			const cgc = this._getChunkGraphChunk(chunk);
+			cgc.modules.delete(oldModule);
+			cgc.modules.add(newModule);
+			newCgm.chunks.add(chunk);
 		}
-		if (asyncMode === "eager") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getEagerSource(this.dependencies, id, {
-					chunkGraph,
-					runtimeTemplate
-				});
+		oldCgm.chunks.clear();
+
+		if (oldCgm.entryInChunks !== undefined) {
+			if (newCgm.entryInChunks === undefined) {
+				newCgm.entryInChunks = new Set();
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
-		}
-		if (asyncMode === "lazy-once") {
-			const block = this.blocks[0];
-			if (block) {
-				return this.getLazyOnceSource(block, block.dependencies, id, {
-					runtimeTemplate,
-					chunkGraph
-				});
+			for (const chunk of oldCgm.entryInChunks) {
+				const cgc = this._getChunkGraphChunk(chunk);
+				const old = cgc.entryModules.get(oldModule);
+				/** @type {Map<Module, Entrypoint>} */
+				const newEntryModules = new Map();
+				for (const [m, cg] of cgc.entryModules) {
+					if (m === oldModule) {
+						newEntryModules.set(newModule, old);
+					} else {
+						newEntryModules.set(m, cg);
+					}
+				}
+				cgc.entryModules = newEntryModules;
+				newCgm.entryInChunks.add(chunk);
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+			oldCgm.entryInChunks = undefined;
 		}
-		if (asyncMode === "async-weak") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getAsyncWeakSource(this.dependencies, id, {
-					chunkGraph,
-					runtimeTemplate
-				});
+
+		if (oldCgm.runtimeInChunks !== undefined) {
+			if (newCgm.runtimeInChunks === undefined) {
+				newCgm.runtimeInChunks = new Set();
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
-		}
-		if (asyncMode === "weak") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
+			for (const chunk of oldCgm.runtimeInChunks) {
+				const cgc = this._getChunkGraphChunk(chunk);
+				cgc.runtimeModules.delete(/** @type {RuntimeModule} */ (oldModule));
+				cgc.runtimeModules.add(/** @type {RuntimeModule} */ (newModule));
+				newCgm.runtimeInChunks.add(chunk);
+				if (
+					cgc.fullHashModules !== undefined &&
+					cgc.fullHashModules.has(/** @type {RuntimeModule} */ (oldModule))
+				) {
+					cgc.fullHashModules.delete(/** @type {RuntimeModule} */ (oldModule));
+					cgc.fullHashModules.add(/** @type {RuntimeModule} */ (newModule));
+				}
+				if (
+					cgc.dependentHashModules !== undefined &&
+					cgc.dependentHashModules.has(/** @type {RuntimeModule} */ (oldModule))
+				) {
+					cgc.dependentHashModules.delete(
+						/** @type {RuntimeModule} */ (oldModule)
+					);
+					cgc.dependentHashModules.add(
+						/** @type {RuntimeModule} */ (newModule)
+					);
+				}
 			}
+			oldCgm.runtimeInChunks = undefined;
 		}
-		if (this.dependencies && this.dependencies.length > 0) {
-			return this.getSyncSource(this.dependencies, id, chunkGraph);
-		}
-		return this.getSourceForEmptyContext(id, runtimeTemplate);
 	}
 
-	getSource(sourceString) {
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(sourceString, this.identifier());
-		}
-		return new RawSource(sourceString);
+	/**
+	 * @param {Module} module the checked module
+	 * @param {Chunk} chunk the checked chunk
+	 * @returns {boolean} true, if the chunk contains the module
+	 */
+	isModuleInChunk(module, chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.has(module);
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {Module} module the checked module
+	 * @param {ChunkGroup} chunkGroup the checked chunk group
+	 * @returns {boolean} true, if the chunk contains the module
 	 */
-	codeGeneration(context) {
-		const { chunkGraph } = context;
-		const sources = new Map();
-		sources.set(
-			"javascript",
-			this.getSource(this.getSourceString(this.options.mode, context))
-		);
-		const set = new Set();
-		const allDeps = /** @type {ContextElementDependency[]} */ (
-			this.dependencies.concat(this.blocks.map(b => b.dependencies[0]))
-		);
-		set.add(RuntimeGlobals.module);
-		set.add(RuntimeGlobals.hasOwnProperty);
-		if (allDeps.length > 0) {
-			const asyncMode = this.options.mode;
-			set.add(RuntimeGlobals.require);
-			if (asyncMode === "weak") {
-				set.add(RuntimeGlobals.moduleFactories);
-			} else if (asyncMode === "async-weak") {
-				set.add(RuntimeGlobals.moduleFactories);
-				set.add(RuntimeGlobals.ensureChunk);
-			} else if (asyncMode === "lazy" || asyncMode === "lazy-once") {
-				set.add(RuntimeGlobals.ensureChunk);
-			}
-			if (this.getFakeMap(allDeps, chunkGraph) !== 9) {
-				set.add(RuntimeGlobals.createFakeNamespaceObject);
-			}
+	isModuleInChunkGroup(module, chunkGroup) {
+		for (const chunk of chunkGroup.chunks) {
+			if (this.isModuleInChunk(module, chunk)) return true;
 		}
-		return {
-			sources,
-			runtimeRequirements: set
-		};
+		return false;
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {Module} module the checked module
+	 * @returns {boolean} true, if the module is entry of any chunk
 	 */
-	size(type) {
-		// base penalty
-		let size = 160;
-
-		// if we don't have dependencies we stop here.
-		for (const dependency of this.dependencies) {
-			const element = /** @type {ContextElementDependency} */ (dependency);
-			size += 5 + element.userRequest.length;
-		}
-		return size;
+	isEntryModule(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.entryInChunks !== undefined;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this._identifier);
-		write(this._forceBuild);
-		super.serialize(context);
+	/**
+	 * @param {Module} module the module
+	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
+	 */
+	getModuleChunksIterable(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this._identifier = read();
-		this._forceBuild = read();
-		super.deserialize(context);
+	/**
+	 * @param {Module} module the module
+	 * @param {function(Chunk, Chunk): -1|0|1} sortFn sort function
+	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
+	 */
+	getOrderedModuleChunksIterable(module, sortFn) {
+		const cgm = this._getChunkGraphModule(module);
+		cgm.chunks.sortWith(sortFn);
+		return cgm.chunks;
 	}
-}
 
-makeSerializable(ContextModule, "webpack/lib/ContextModule");
-
-module.exports = ContextModule;
+	/**
+	 * @param {Module} module the module
+	 * @returns {Chunk[]} array of chunks (cached, do not modify)
+	 */
+	getModuleChunks(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks.getFromCache(getArray);
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the number of chunk which contain the module
+	 */
+	getNumberOfModuleChunks(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks.size;
+	}
 
-/***/ }),
+	/**
+	 * @param {Module} module the module
+	 * @returns {RuntimeSpecSet} runtimes
+	 */
+	getModuleRuntimes(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
+	}
 
-/***/ 62471:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the number of modules which are contained in this chunk
+	 */
+	getNumberOfChunkModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.size;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the number of full hash modules which are contained in this chunk
+	 */
+	getNumberOfChunkFullHashModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size;
+	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Module>} return the modules for this chunk
+	 */
+	getChunkModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules;
+	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} sourceType source type
+	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
+	 */
+	getChunkModulesIterableBySourceType(chunk, sourceType) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const modulesWithSourceType = cgc.modules
+			.getFromUnorderedCache(modulesBySourceType)
+			.get(sourceType);
+		return modulesWithSourceType;
+	}
 
-const asyncLib = __webpack_require__(78175);
-const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = __webpack_require__(6967);
-const ContextModule = __webpack_require__(76729);
-const ModuleFactory = __webpack_require__(51010);
-const ContextElementDependency = __webpack_require__(58477);
-const LazySet = __webpack_require__(38938);
-const { cachedSetProperty } = __webpack_require__(60839);
-const { createFakeHook } = __webpack_require__(64518);
-const { join } = __webpack_require__(17139);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @returns {Iterable<Module>} return the modules for this chunk
+	 */
+	getOrderedChunkModulesIterable(chunk, comparator) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgc.modules.sortWith(comparator);
+		return cgc.modules;
+	}
 
-/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
-/** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} sourceType source type
+	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
+	 */
+	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const modulesWithSourceType = cgc.modules
+			.getFromUnorderedCache(modulesBySourceType)
+			.get(sourceType);
+		if (modulesWithSourceType === undefined) return undefined;
+		modulesWithSourceType.sortWith(comparator);
+		return modulesWithSourceType;
+	}
 
-const EMPTY_RESOLVE_OPTIONS = {};
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
+	 */
+	getChunkModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(getArray);
+	}
 
-module.exports = class ContextModuleFactory extends ModuleFactory {
 	/**
-	 * @param {ResolverFactory} resolverFactory resolverFactory
+	 * @param {Chunk} chunk the chunk
+	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
 	 */
-	constructor(resolverFactory) {
-		super();
-		/** @type {AsyncSeriesWaterfallHook<[TODO[], ContextModuleOptions]>} */
-		const alternativeRequests = new AsyncSeriesWaterfallHook([
-			"modules",
-			"options"
-		]);
-		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
-			beforeResolve: new AsyncSeriesWaterfallHook(["data"]),
-			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
-			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
-			/** @type {SyncWaterfallHook<[string[]]>} */
-			contextModuleFiles: new SyncWaterfallHook(["files"]),
-			/** @type {FakeHook<Pick<AsyncSeriesWaterfallHook<[TODO[]]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
-			alternatives: createFakeHook(
-				{
-					name: "alternatives",
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["intercept"]} */
-					intercept: interceptor => {
-						throw new Error(
-							"Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead"
-						);
-					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tap"]} */
-					tap: (options, fn) => {
-						alternativeRequests.tap(options, fn);
-					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapAsync"]} */
-					tapAsync: (options, fn) => {
-						alternativeRequests.tapAsync(options, (items, _options, callback) =>
-							fn(items, callback)
-						);
-					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapPromise"]} */
-					tapPromise: (options, fn) => {
-						alternativeRequests.tapPromise(options, fn);
-					}
-				},
-				"ContextModuleFactory.hooks.alternatives has deprecated in favor of ContextModuleFactory.hooks.alternativeRequests with an additional options argument.",
-				"DEP_WEBPACK_CONTEXT_MODULE_FACTORY_ALTERNATIVES"
-			),
-			alternativeRequests
-		});
-		this.resolverFactory = resolverFactory;
+	getOrderedChunkModules(chunk, comparator) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const arrayFunction = createOrderedArrayFunction(comparator);
+		return cgc.modules.getFromUnorderedCache(arrayFunction);
 	}
 
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
+	 * @param {Chunk} chunk the chunk
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @param {boolean} includeAllChunks all chunks or only async chunks
+	 * @returns {Record<string|number, (string|number)[]>} chunk to module ids object
 	 */
-	create(data, callback) {
-		const context = data.context;
-		const dependencies = data.dependencies;
-		const resolveOptions = data.resolveOptions;
-		const dependency = /** @type {ContextDependency} */ (dependencies[0]);
-		const fileDependencies = new LazySet();
-		const missingDependencies = new LazySet();
-		const contextDependencies = new LazySet();
-		this.hooks.beforeResolve.callAsync(
-			{
-				context: context,
-				dependencies: dependencies,
-				resolveOptions,
-				fileDependencies,
-				missingDependencies,
-				contextDependencies,
-				...dependency.options
-			},
-			(err, beforeResolveResult) => {
-				if (err) {
-					return callback(err, {
-						fileDependencies,
-						missingDependencies,
-						contextDependencies
-					});
-				}
+	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
+		/** @type {Record<string|number, (string|number)[]>} */
+		const chunkModuleIdMap = Object.create(null);
 
-				// Ignored
-				if (!beforeResolveResult) {
-					return callback(null, {
-						fileDependencies,
-						missingDependencies,
-						contextDependencies
-					});
+		for (const asyncChunk of includeAllChunks
+			? chunk.getAllReferencedChunks()
+			: chunk.getAllAsyncChunks()) {
+			/** @type {(string|number)[]} */
+			let array;
+			for (const module of this.getOrderedChunkModulesIterable(
+				asyncChunk,
+				compareModulesById(this)
+			)) {
+				if (filterFn(module)) {
+					if (array === undefined) {
+						array = [];
+						chunkModuleIdMap[asyncChunk.id] = array;
+					}
+					const moduleId = this.getModuleId(module);
+					array.push(moduleId);
 				}
+			}
+		}
 
-				const context = beforeResolveResult.context;
-				const request = beforeResolveResult.request;
-				const resolveOptions = beforeResolveResult.resolveOptions;
+		return chunkModuleIdMap;
+	}
 
-				let loaders,
-					resource,
-					loadersPrefix = "";
-				const idx = request.lastIndexOf("!");
-				if (idx >= 0) {
-					let loadersRequest = request.substr(0, idx + 1);
-					let i;
-					for (
-						i = 0;
-						i < loadersRequest.length && loadersRequest[i] === "!";
-						i++
-					) {
-						loadersPrefix += "!";
-					}
-					loadersRequest = loadersRequest
-						.substr(i)
-						.replace(/!+$/, "")
-						.replace(/!!+/g, "!");
-					if (loadersRequest === "") {
-						loaders = [];
-					} else {
-						loaders = loadersRequest.split("!");
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @param {number} hashLength length of the hash
+	 * @param {boolean} includeAllChunks all chunks or only async chunks
+	 * @returns {Record<string|number, Record<string|number, string>>} chunk to module id to module hash object
+	 */
+	getChunkModuleRenderedHashMap(
+		chunk,
+		filterFn,
+		hashLength = 0,
+		includeAllChunks = false
+	) {
+		/** @type {Record<string|number, Record<string|number, string>>} */
+		const chunkModuleHashMap = Object.create(null);
+
+		for (const asyncChunk of includeAllChunks
+			? chunk.getAllReferencedChunks()
+			: chunk.getAllAsyncChunks()) {
+			/** @type {Record<string|number, string>} */
+			let idToHashMap;
+			for (const module of this.getOrderedChunkModulesIterable(
+				asyncChunk,
+				compareModulesById(this)
+			)) {
+				if (filterFn(module)) {
+					if (idToHashMap === undefined) {
+						idToHashMap = Object.create(null);
+						chunkModuleHashMap[asyncChunk.id] = idToHashMap;
 					}
-					resource = request.substr(idx + 1);
-				} else {
-					loaders = [];
-					resource = request;
+					const moduleId = this.getModuleId(module);
+					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
+					idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
 				}
+			}
+		}
 
-				const contextResolver = this.resolverFactory.get(
-					"context",
-					dependencies.length > 0
-						? cachedSetProperty(
-								resolveOptions || EMPTY_RESOLVE_OPTIONS,
-								"dependencyType",
-								dependencies[0].category
-						  )
-						: resolveOptions
-				);
-				const loaderResolver = this.resolverFactory.get("loader");
-
-				asyncLib.parallel(
-					[
-						callback => {
-							contextResolver.resolve(
-								{},
-								context,
-								resource,
-								{
-									fileDependencies,
-									missingDependencies,
-									contextDependencies
-								},
-								(err, result) => {
-									if (err) return callback(err);
-									callback(null, result);
-								}
-							);
-						},
-						callback => {
-							asyncLib.map(
-								loaders,
-								(loader, callback) => {
-									loaderResolver.resolve(
-										{},
-										context,
-										loader,
-										{
-											fileDependencies,
-											missingDependencies,
-											contextDependencies
-										},
-										(err, result) => {
-											if (err) return callback(err);
-											callback(null, result);
-										}
-									);
-								},
-								callback
-							);
-						}
-					],
-					(err, result) => {
-						if (err) {
-							return callback(err, {
-								fileDependencies,
-								missingDependencies,
-								contextDependencies
-							});
-						}
+		return chunkModuleHashMap;
+	}
 
-						this.hooks.afterResolve.callAsync(
-							{
-								addon:
-									loadersPrefix +
-									result[1].join("!") +
-									(result[1].length > 0 ? "!" : ""),
-								resource: result[0],
-								resolveDependencies: this.resolveDependencies.bind(this),
-								...beforeResolveResult
-							},
-							(err, result) => {
-								if (err) {
-									return callback(err, {
-										fileDependencies,
-										missingDependencies,
-										contextDependencies
-									});
-								}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
+	 * @returns {Record<string|number, boolean>} chunk map
+	 */
+	getChunkConditionMap(chunk, filterFn) {
+		const map = Object.create(null);
+		for (const c of chunk.getAllReferencedChunks()) {
+			map[c.id] = filterFn(c, this);
+		}
+		return map;
+	}
 
-								// Ignored
-								if (!result) {
-									return callback(null, {
-										fileDependencies,
-										missingDependencies,
-										contextDependencies
-									});
-								}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
+	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
+	 * @returns {boolean} return true if module exists in graph
+	 */
+	hasModuleInGraph(chunk, filterFn, filterChunkFn) {
+		const queue = new Set(chunk.groupsIterable);
+		const chunksProcessed = new Set();
 
-								return callback(null, {
-									module: new ContextModule(result.resolveDependencies, result),
-									fileDependencies,
-									missingDependencies,
-									contextDependencies
-								});
+		for (const chunkGroup of queue) {
+			for (const innerChunk of chunkGroup.chunks) {
+				if (!chunksProcessed.has(innerChunk)) {
+					chunksProcessed.add(innerChunk);
+					if (!filterChunkFn || filterChunkFn(innerChunk, this)) {
+						for (const module of this.getChunkModulesIterable(innerChunk)) {
+							if (filterFn(module)) {
+								return true;
 							}
-						);
+						}
 					}
-				);
+				}
 			}
-		);
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
+		return false;
 	}
 
 	/**
-	 * @param {InputFileSystem} fs file system
-	 * @param {ContextModuleOptions} options options
-	 * @param {ResolveDependenciesCallback} callback callback function
-	 * @returns {void}
+	 * @param {Chunk} chunkA first chunk
+	 * @param {Chunk} chunkB second chunk
+	 * @returns {-1|0|1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
 	 */
-	resolveDependencies(fs, options, callback) {
-		const cmf = this;
-		const {
-			resource,
-			resourceQuery,
-			resourceFragment,
-			recursive,
-			regExp,
-			include,
-			exclude,
-			referencedExports,
-			category,
-			typePrefix
-		} = options;
-		if (!regExp || !resource) return callback(null, []);
+	compareChunks(chunkA, chunkB) {
+		const cgcA = this._getChunkGraphChunk(chunkA);
+		const cgcB = this._getChunkGraphChunk(chunkB);
+		if (cgcA.modules.size > cgcB.modules.size) return -1;
+		if (cgcA.modules.size < cgcB.modules.size) return 1;
+		cgcA.modules.sortWith(compareModulesByIdentifier);
+		cgcB.modules.sortWith(compareModulesByIdentifier);
+		return compareModuleIterables(cgcA.modules, cgcB.modules);
+	}
 
-		const addDirectoryChecked = (directory, visited, callback) => {
-			fs.realpath(directory, (err, realPath) => {
-				if (err) return callback(err);
-				if (visited.has(realPath)) return callback(null, []);
-				let recursionStack;
-				addDirectory(
-					directory,
-					(dir, callback) => {
-						if (recursionStack === undefined) {
-							recursionStack = new Set(visited);
-							recursionStack.add(realPath);
-						}
-						addDirectoryChecked(dir, recursionStack, callback);
-					},
-					callback
-				);
-			});
-		};
-
-		const addDirectory = (directory, addSubDirectory, callback) => {
-			fs.readdir(directory, (err, files) => {
-				if (err) return callback(err);
-				const processedFiles = cmf.hooks.contextModuleFiles.call(
-					/** @type {string[]} */ (files).map(file => file.normalize("NFC"))
-				);
-				if (!processedFiles || processedFiles.length === 0)
-					return callback(null, []);
-				asyncLib.map(
-					processedFiles.filter(p => p.indexOf(".") !== 0),
-					(segment, callback) => {
-						const subResource = join(fs, directory, segment);
-
-						if (!exclude || !subResource.match(exclude)) {
-							fs.stat(subResource, (err, stat) => {
-								if (err) {
-									if (err.code === "ENOENT") {
-										// ENOENT is ok here because the file may have been deleted between
-										// the readdir and stat calls.
-										return callback();
-									} else {
-										return callback(err);
-									}
-								}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} total size of all modules in the chunk
+	 */
+	getChunkModulesSize(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(getModulesSize);
+	}
 
-								if (stat.isDirectory()) {
-									if (!recursive) return callback();
-									addSubDirectory(subResource, callback);
-								} else if (
-									stat.isFile() &&
-									(!include || subResource.match(include))
-								) {
-									const obj = {
-										context: resource,
-										request:
-											"." +
-											subResource.substr(resource.length).replace(/\\/g, "/")
-									};
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Record<string, number>} total sizes of all modules in the chunk by source type
+	 */
+	getChunkModulesSizes(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(getModulesSizes);
+	}
 
-									this.hooks.alternativeRequests.callAsync(
-										[obj],
-										options,
-										(err, alternatives) => {
-											if (err) return callback(err);
-											alternatives = alternatives
-												.filter(obj => regExp.test(obj.request))
-												.map(obj => {
-													const dep = new ContextElementDependency(
-														obj.request + resourceQuery + resourceFragment,
-														obj.request,
-														typePrefix,
-														category,
-														referencedExports
-													);
-													dep.optional = true;
-													return dep;
-												});
-											callback(null, alternatives);
-										}
-									);
-								} else {
-									callback();
-								}
-							});
-						} else {
-							callback();
-						}
-					},
-					(err, result) => {
-						if (err) return callback(err);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Module[]} root modules of the chunks (ordered by identifier)
+	 */
+	getChunkRootModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(this._getGraphRoots);
+	}
 
-						if (!result) return callback(null, []);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of the chunk
+	 */
+	getChunkSize(chunk, options = {}) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const modulesSize = cgc.modules.getFromUnorderedCache(getModulesSize);
+		const chunkOverhead =
+			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
+		const entryChunkMultiplicator =
+			typeof options.entryChunkMultiplicator === "number"
+				? options.entryChunkMultiplicator
+				: 10;
+		return (
+			chunkOverhead +
+			modulesSize * (chunk.canBeInitial() ? entryChunkMultiplicator : 1)
+		);
+	}
 
-						const flattenedResult = [];
+	/**
+	 * @param {Chunk} chunkA chunk
+	 * @param {Chunk} chunkB chunk
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of the chunk or false if chunks can't be integrated
+	 */
+	getIntegratedChunksSize(chunkA, chunkB, options = {}) {
+		const cgcA = this._getChunkGraphChunk(chunkA);
+		const cgcB = this._getChunkGraphChunk(chunkB);
+		const allModules = new Set(cgcA.modules);
+		for (const m of cgcB.modules) allModules.add(m);
+		let modulesSize = getModulesSize(allModules);
+		const chunkOverhead =
+			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
+		const entryChunkMultiplicator =
+			typeof options.entryChunkMultiplicator === "number"
+				? options.entryChunkMultiplicator
+				: 10;
+		return (
+			chunkOverhead +
+			modulesSize *
+				(chunkA.canBeInitial() || chunkB.canBeInitial()
+					? entryChunkMultiplicator
+					: 1)
+		);
+	}
 
-						for (const item of result) {
-							if (item) flattenedResult.push(...item);
-						}
+	/**
+	 * @param {Chunk} chunkA chunk
+	 * @param {Chunk} chunkB chunk
+	 * @returns {boolean} true, if chunks could be integrated
+	 */
+	canChunksBeIntegrated(chunkA, chunkB) {
+		if (chunkA.preventIntegration || chunkB.preventIntegration) {
+			return false;
+		}
 
-						callback(null, flattenedResult);
-					}
-				);
-			});
-		};
+		const hasRuntimeA = chunkA.hasRuntime();
+		const hasRuntimeB = chunkB.hasRuntime();
 
-		if (typeof fs.realpath === "function") {
-			addDirectoryChecked(resource, new Set(), callback);
-		} else {
-			const addSubDirectory = (dir, callback) =>
-				addDirectory(dir, addSubDirectory, callback);
-			addDirectory(resource, addSubDirectory, callback);
+		if (hasRuntimeA !== hasRuntimeB) {
+			if (hasRuntimeA) {
+				return isAvailableChunk(chunkA, chunkB);
+			} else if (hasRuntimeB) {
+				return isAvailableChunk(chunkB, chunkA);
+			} else {
+				return false;
+			}
 		}
-	}
-};
 
+		if (
+			this.getNumberOfEntryModules(chunkA) > 0 ||
+			this.getNumberOfEntryModules(chunkB) > 0
+		) {
+			return false;
+		}
 
-/***/ }),
+		return true;
+	}
 
-/***/ 12206:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Chunk} chunkA the target chunk
+	 * @param {Chunk} chunkB the chunk to integrate
+	 * @returns {void}
+	 */
+	integrateChunks(chunkA, chunkB) {
+		// Decide for one name (deterministic)
+		if (chunkA.name && chunkB.name) {
+			if (
+				this.getNumberOfEntryModules(chunkA) > 0 ===
+				this.getNumberOfEntryModules(chunkB) > 0
+			) {
+				// When both chunks have entry modules or none have one, use
+				// shortest name
+				if (chunkA.name.length !== chunkB.name.length) {
+					chunkA.name =
+						chunkA.name.length < chunkB.name.length ? chunkA.name : chunkB.name;
+				} else {
+					chunkA.name = chunkA.name < chunkB.name ? chunkA.name : chunkB.name;
+				}
+			} else if (this.getNumberOfEntryModules(chunkB) > 0) {
+				// Pick the name of the chunk with the entry module
+				chunkA.name = chunkB.name;
+			}
+		} else if (chunkB.name) {
+			chunkA.name = chunkB.name;
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		// Merge id name hints
+		for (const hint of chunkB.idNameHints) {
+			chunkA.idNameHints.add(hint);
+		}
 
+		// Merge runtime
+		chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime);
 
+		// getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
+		for (const module of this.getChunkModules(chunkB)) {
+			this.disconnectChunkAndModule(chunkB, module);
+			this.connectChunkAndModule(chunkA, module);
+		}
 
-const ContextElementDependency = __webpack_require__(58477);
-const { join } = __webpack_require__(17139);
+		for (const [module, chunkGroup] of Array.from(
+			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
+		)) {
+			this.disconnectChunkAndEntryModule(chunkB, module);
+			this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
+		}
 
-class ContextReplacementPlugin {
-	constructor(
-		resourceRegExp,
-		newContentResource,
-		newContentRecursive,
-		newContentRegExp
-	) {
-		this.resourceRegExp = resourceRegExp;
+		for (const chunkGroup of chunkB.groupsIterable) {
+			chunkGroup.replaceChunk(chunkB, chunkA);
+			chunkA.addGroup(chunkGroup);
+			chunkB.removeGroup(chunkGroup);
+		}
+		ChunkGraph.clearChunkGraphForChunk(chunkB);
+	}
 
-		if (typeof newContentResource === "function") {
-			this.newContentCallback = newContentResource;
-		} else if (
-			typeof newContentResource === "string" &&
-			typeof newContentRecursive === "object"
-		) {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = (fs, callback) => {
-				callback(null, newContentRecursive);
-			};
-		} else if (
-			typeof newContentResource === "string" &&
-			typeof newContentRecursive === "function"
-		) {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = newContentRecursive;
+	/**
+	 * @param {Chunk} chunk the chunk to upgrade
+	 * @returns {void}
+	 */
+	upgradeDependentToFullHashModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined) return;
+		if (cgc.fullHashModules === undefined) {
+			cgc.fullHashModules = cgc.dependentHashModules;
 		} else {
-			if (typeof newContentResource !== "string") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = newContentResource;
-				newContentResource = undefined;
-			}
-			if (typeof newContentRecursive !== "boolean") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = undefined;
+			for (const m of cgc.dependentHashModules) {
+				cgc.fullHashModules.add(m);
 			}
-			this.newContentResource = newContentResource;
-			this.newContentRecursive = newContentRecursive;
-			this.newContentRegExp = newContentRegExp;
+			cgc.dependentHashModules = undefined;
 		}
 	}
 
-	apply(compiler) {
-		const resourceRegExp = this.resourceRegExp;
-		const newContentCallback = this.newContentCallback;
-		const newContentResource = this.newContentResource;
-		const newContentRecursive = this.newContentRecursive;
-		const newContentRegExp = this.newContentRegExp;
-		const newContentCreateContextMap = this.newContentCreateContextMap;
-
-		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
-				if (!result) return;
-				if (resourceRegExp.test(result.request)) {
-					if (newContentResource !== undefined) {
-						result.request = newContentResource;
-					}
-					if (newContentRecursive !== undefined) {
-						result.recursive = newContentRecursive;
-					}
-					if (newContentRegExp !== undefined) {
-						result.regExp = newContentRegExp;
-					}
-					if (typeof newContentCallback === "function") {
-						newContentCallback(result);
-					} else {
-						for (const d of result.dependencies) {
-							if (d.critical) d.critical = false;
-						}
-					}
-				}
-				return result;
-			});
-			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
-				if (!result) return;
-				if (resourceRegExp.test(result.resource)) {
-					if (newContentResource !== undefined) {
-						if (
-							newContentResource.startsWith("/") ||
-							(newContentResource.length > 1 && newContentResource[1] === ":")
-						) {
-							result.resource = newContentResource;
-						} else {
-							result.resource = join(
-								compiler.inputFileSystem,
-								result.resource,
-								newContentResource
-							);
-						}
-					}
-					if (newContentRecursive !== undefined) {
-						result.recursive = newContentRecursive;
-					}
-					if (newContentRegExp !== undefined) {
-						result.regExp = newContentRegExp;
-					}
-					if (typeof newContentCreateContextMap === "function") {
-						result.resolveDependencies =
-							createResolveDependenciesFromContextMap(
-								newContentCreateContextMap
-							);
-					}
-					if (typeof newContentCallback === "function") {
-						const origResource = result.resource;
-						newContentCallback(result);
-						if (
-							result.resource !== origResource &&
-							!result.resource.startsWith("/") &&
-							(result.resource.length <= 1 || result.resource[1] !== ":")
-						) {
-							// When the function changed it to an relative path
-							result.resource = join(
-								compiler.inputFileSystem,
-								origResource,
-								result.resource
-							);
-						}
-					} else {
-						for (const d of result.dependencies) {
-							if (d.critical) d.critical = false;
-						}
-					}
-				}
-				return result;
-			});
-		});
+	/**
+	 * @param {Module} module the checked module
+	 * @param {Chunk} chunk the checked chunk
+	 * @returns {boolean} true, if the chunk contains the module as entry
+	 */
+	isEntryModuleInChunk(module, chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules.has(module);
 	}
-}
-
-const createResolveDependenciesFromContextMap = createContextMap => {
-	const resolveDependenciesFromContextMap = (fs, options, callback) => {
-		createContextMap(fs, (err, map) => {
-			if (err) return callback(err);
-			const dependencies = Object.keys(map).map(key => {
-				return new ContextElementDependency(
-					map[key] + options.resourceQuery + options.resourceFragment,
-					key,
-					options.category,
-					options.referencedExports
-				);
-			});
-			callback(null, dependencies);
-		});
-	};
-	return resolveDependenciesFromContextMap;
-};
-
-module.exports = ContextReplacementPlugin;
-
-
-/***/ }),
 
-/***/ 79065:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const ConstDependency = __webpack_require__(76911);
-const BasicEvaluatedExpression = __webpack_require__(950);
-const {
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
-const createHash = __webpack_require__(49835);
-
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-
-/** @typedef {null|undefined|RegExp|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
-/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive|RuntimeValue>} CodeValue */
-
-/**
- * @typedef {Object} RuntimeValueOptions
- * @property {string[]=} fileDependencies
- * @property {string[]=} contextDependencies
- * @property {string[]=} missingDependencies
- * @property {string[]=} buildDependencies
- * @property {string|function(): string=} version
- */
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {Module} module the entry module
+	 * @param {Entrypoint=} entrypoint the chunk group which must be loaded before the module is executed
+	 * @returns {void}
+	 */
+	connectChunkAndEntryModule(chunk, module, entrypoint) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgm.entryInChunks === undefined) {
+			cgm.entryInChunks = new Set();
+		}
+		cgm.entryInChunks.add(chunk);
+		cgc.entryModules.set(module, entrypoint);
+	}
 
-class RuntimeValue {
 	/**
-	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
-	 * @param {true | string[] | RuntimeValueOptions=} options options
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the runtime module
+	 * @returns {void}
 	 */
-	constructor(fn, options) {
-		this.fn = fn;
-		if (Array.isArray(options)) {
-			options = {
-				fileDependencies: options
-			};
+	connectChunkAndRuntimeModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgm.runtimeInChunks === undefined) {
+			cgm.runtimeInChunks = new Set();
 		}
-		this.options = options || {};
+		cgm.runtimeInChunks.add(chunk);
+		cgc.runtimeModules.add(module);
 	}
 
-	get fileDependencies() {
-		return this.options === true ? true : this.options.fileDependencies;
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the module that require a full hash
+	 * @returns {void}
+	 */
+	addFullHashModuleToChunk(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
+		cgc.fullHashModules.add(module);
 	}
 
 	/**
-	 * @param {JavascriptParser} parser the parser
-	 * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
-	 * @param {string} key the defined key
-	 * @returns {CodeValuePrimitive} code
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the module that require a full hash
+	 * @returns {void}
 	 */
-	exec(parser, valueCacheVersions, key) {
-		const buildInfo = parser.state.module.buildInfo;
-		if (this.options === true) {
-			buildInfo.cacheable = false;
-		} else {
-			if (this.options.fileDependencies) {
-				for (const dep of this.options.fileDependencies) {
-					buildInfo.fileDependencies.add(dep);
-				}
-			}
-			if (this.options.contextDependencies) {
-				for (const dep of this.options.contextDependencies) {
-					buildInfo.contextDependencies.add(dep);
-				}
-			}
-			if (this.options.missingDependencies) {
-				for (const dep of this.options.missingDependencies) {
-					buildInfo.missingDependencies.add(dep);
-				}
-			}
-			if (this.options.buildDependencies) {
-				for (const dep of this.options.buildDependencies) {
-					buildInfo.buildDependencies.add(dep);
-				}
-			}
-		}
+	addDependentHashModuleToChunk(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined)
+			cgc.dependentHashModules = new Set();
+		cgc.dependentHashModules.add(module);
+	}
 
-		return this.fn({
-			module: parser.state.module,
-			key,
-			get version() {
-				return /** @type {string} */ (
-					valueCacheVersions.get(VALUE_DEP_PREFIX + key)
-				);
-			}
-		});
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {Module} module the entry module
+	 * @returns {void}
+	 */
+	disconnectChunkAndEntryModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgm.entryInChunks.delete(chunk);
+		if (cgm.entryInChunks.size === 0) {
+			cgm.entryInChunks = undefined;
+		}
+		cgc.entryModules.delete(module);
 	}
 
-	getCacheVersion() {
-		return this.options === true
-			? undefined
-			: (typeof this.options.version === "function"
-					? this.options.version()
-					: this.options.version) || "unset";
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the runtime module
+	 * @returns {void}
+	 */
+	disconnectChunkAndRuntimeModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgm.runtimeInChunks.delete(chunk);
+		if (cgm.runtimeInChunks.size === 0) {
+			cgm.runtimeInChunks = undefined;
+		}
+		cgc.runtimeModules.delete(module);
 	}
-}
 
-/**
- * @param {any[]|{[k: string]: any}} obj obj
- * @param {JavascriptParser} parser Parser
- * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
- * @param {string} key the defined key
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
- * @returns {string} code converted to string that evaluates
- */
-const stringifyObj = (
-	obj,
-	parser,
-	valueCacheVersions,
-	key,
-	runtimeTemplate,
-	asiSafe
-) => {
-	let code;
-	let arr = Array.isArray(obj);
-	if (arr) {
-		code = `[${obj
-			.map(code =>
-				toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
-			)
-			.join(",")}]`;
-	} else {
-		code = `{${Object.keys(obj)
-			.map(key => {
-				const code = obj[key];
-				return (
-					JSON.stringify(key) +
-					":" +
-					toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
-				);
-			})
-			.join(",")}}`;
+	/**
+	 * @param {Module} module the entry module, it will no longer be entry
+	 * @returns {void}
+	 */
+	disconnectEntryModule(module) {
+		const cgm = this._getChunkGraphModule(module);
+		for (const chunk of cgm.entryInChunks) {
+			const cgc = this._getChunkGraphChunk(chunk);
+			cgc.entryModules.delete(module);
+		}
+		cgm.entryInChunks = undefined;
 	}
 
-	switch (asiSafe) {
-		case null:
-			return code;
-		case true:
-			return arr ? code : `(${code})`;
-		case false:
-			return arr ? `;${code}` : `;(${code})`;
-		default:
-			return `/*#__PURE__*/Object(${code})`;
+	/**
+	 * @param {Chunk} chunk the chunk, for which all entries will be removed
+	 * @returns {void}
+	 */
+	disconnectEntries(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of cgc.entryModules.keys()) {
+			const cgm = this._getChunkGraphModule(module);
+			cgm.entryInChunks.delete(chunk);
+			if (cgm.entryInChunks.size === 0) {
+				cgm.entryInChunks = undefined;
+			}
+		}
+		cgc.entryModules.clear();
 	}
-};
 
-/**
- * Convert code to a string that evaluates
- * @param {CodeValue} code Code to evaluate
- * @param {JavascriptParser} parser Parser
- * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
- * @param {string} key the defined key
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
- * @returns {string} code converted to string that evaluates
- */
-const toCode = (
-	code,
-	parser,
-	valueCacheVersions,
-	key,
-	runtimeTemplate,
-	asiSafe
-) => {
-	if (code === null) {
-		return "null";
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the amount of entry modules in chunk
+	 */
+	getNumberOfEntryModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules.size;
 	}
-	if (code === undefined) {
-		return "undefined";
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the amount of entry modules in chunk
+	 */
+	getNumberOfRuntimeModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.runtimeModules.size;
 	}
-	if (Object.is(code, -0)) {
-		return "-0";
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Module>} iterable of modules (do not modify)
+	 */
+	getChunkEntryModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules.keys();
 	}
-	if (code instanceof RuntimeValue) {
-		return toCode(
-			code.exec(parser, valueCacheVersions, key),
-			parser,
-			valueCacheVersions,
-			key,
-			runtimeTemplate,
-			asiSafe
-		);
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Chunk>} iterable of chunks
+	 */
+	getChunkEntryDependentChunksIterable(chunk) {
+		/** @type {Set<Chunk>} */
+		const set = new Set();
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (chunkGroup instanceof Entrypoint) {
+				const entrypointChunk = chunkGroup.getEntrypointChunk();
+				const cgc = this._getChunkGraphChunk(entrypointChunk);
+				for (const chunkGroup of cgc.entryModules.values()) {
+					for (const c of chunkGroup.chunks) {
+						if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+							set.add(c);
+						}
+					}
+				}
+			}
+		}
+
+		return set;
 	}
-	if (code instanceof RegExp && code.toString) {
-		return code.toString();
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {boolean} true, when it has dependent chunks
+	 */
+	hasChunkEntryDependentChunks(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const chunkGroup of cgc.entryModules.values()) {
+			for (const c of chunkGroup.chunks) {
+				if (c !== chunk) {
+					return true;
+				}
+			}
+		}
+		return false;
 	}
-	if (typeof code === "function" && code.toString) {
-		return "(" + code.toString() + ")";
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule>} iterable of modules (do not modify)
+	 */
+	getChunkRuntimeModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.runtimeModules;
 	}
-	if (typeof code === "object") {
-		return stringifyObj(
-			code,
-			parser,
-			valueCacheVersions,
-			key,
-			runtimeTemplate,
-			asiSafe
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {RuntimeModule[]} array of modules in order of execution
+	 */
+	getChunkRuntimeModulesInOrder(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const array = Array.from(cgc.runtimeModules);
+		array.sort(
+			concatComparators(
+				compareSelect(
+					/**
+					 * @param {RuntimeModule} r runtime module
+					 * @returns {number=} stage
+					 */
+					r => r.stage,
+					compareIds
+				),
+				compareModulesByIdentifier
+			)
 		);
+		return array;
 	}
-	if (typeof code === "bigint") {
-		return runtimeTemplate.supportsBigIntLiteral()
-			? `${code}n`
-			: `BigInt("${code}")`;
-	}
-	return code + "";
-};
 
-const toCacheVersion = code => {
-	if (code === null) {
-		return "null";
-	}
-	if (code === undefined) {
-		return "undefined";
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
+	 */
+	getChunkFullHashModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules;
 	}
-	if (Object.is(code, -0)) {
-		return "-0";
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<RuntimeModule> | undefined} set of modules (do not modify)
+	 */
+	getChunkFullHashModulesSet(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules;
 	}
-	if (code instanceof RuntimeValue) {
-		return code.getCacheVersion();
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
+	 */
+	getChunkDependentHashModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.dependentHashModules;
 	}
-	if (code instanceof RegExp && code.toString) {
-		return code.toString();
+
+	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<EntryModuleWithChunkGroup>} iterable of modules (do not modify)
+	 */
+	getChunkEntryModulesWithChunkGroupIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules;
 	}
-	if (typeof code === "function" && code.toString) {
-		return "(" + code.toString() + ")";
+
+	/**
+	 * @param {AsyncDependenciesBlock} depBlock the async block
+	 * @returns {ChunkGroup} the chunk group
+	 */
+	getBlockChunkGroup(depBlock) {
+		return this._blockChunkGroups.get(depBlock);
 	}
-	if (typeof code === "object") {
-		const items = Object.keys(code).map(key => ({
-			key,
-			value: toCacheVersion(code[key])
-		}));
-		if (items.some(({ value }) => value === undefined)) return undefined;
-		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
+
+	/**
+	 * @param {AsyncDependenciesBlock} depBlock the async block
+	 * @param {ChunkGroup} chunkGroup the chunk group
+	 * @returns {void}
+	 */
+	connectBlockAndChunkGroup(depBlock, chunkGroup) {
+		this._blockChunkGroups.set(depBlock, chunkGroup);
+		chunkGroup.addBlock(depBlock);
 	}
-	if (typeof code === "bigint") {
-		return `${code}n`;
+
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunk group
+	 * @returns {void}
+	 */
+	disconnectChunkGroup(chunkGroup) {
+		for (const block of chunkGroup.blocksIterable) {
+			this._blockChunkGroups.delete(block);
+		}
+		// TODO refactor by moving blocks list into ChunkGraph
+		chunkGroup._blocks.clear();
 	}
-	return code + "";
-};
 
-const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
-const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
+	/**
+	 * @param {Module} module the module
+	 * @returns {string | number} the id of the module
+	 */
+	getModuleId(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.id;
+	}
 
-class DefinePlugin {
 	/**
-	 * Create a new define plugin
-	 * @param {Record<string, CodeValue>} definitions A map of global object definitions
+	 * @param {Module} module the module
+	 * @param {string | number} id the id of the module
+	 * @returns {void}
 	 */
-	constructor(definitions) {
-		this.definitions = definitions;
+	setModuleId(module, id) {
+		const cgm = this._getChunkGraphModule(module);
+		cgm.id = id;
 	}
 
 	/**
-	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
-	 * @param {true | string[] | RuntimeValueOptions=} options options
-	 * @returns {RuntimeValue} runtime value
+	 * @param {string} runtime runtime
+	 * @returns {string | number} the id of the runtime
 	 */
-	static runtimeValue(fn, options) {
-		return new RuntimeValue(fn, options);
+	getRuntimeId(runtime) {
+		return this._runtimeIds.get(runtime);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {string} runtime runtime
+	 * @param {string | number} id the id of the runtime
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const definitions = this.definitions;
-		compiler.hooks.compilation.tap(
-			"DefinePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
-				const { runtimeTemplate } = compilation;
+	setRuntimeId(runtime, id) {
+		this._runtimeIds.set(runtime, id);
+	}
 
-				const mainHash = createHash(compilation.outputOptions.hashFunction);
-				mainHash.update(
-					/** @type {string} */ (
-						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
-					) || ""
+	/**
+	 * @template T
+	 * @param {Module} module the module
+	 * @param {RuntimeSpecMap<T>} hashes hashes data
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {T} hash
+	 */
+	_getModuleHashInfo(module, hashes, runtime) {
+		if (!hashes) {
+			throw new Error(
+				`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
+					runtime
+				)} (hashes not set at all)`
+			);
+		} else if (runtime === undefined) {
+			const hashInfoItems = new Set(hashes.values());
+			if (hashInfoItems.size !== 1) {
+				throw new Error(
+					`No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
+						hashes.keys(),
+						r => runtimeToString(r)
+					).join(", ")}).
+Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 				);
+			}
+			return first(hashInfoItems);
+		} else {
+			const hashInfo = hashes.get(runtime);
+			if (!hashInfo) {
+				throw new Error(
+					`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
+						runtime
+					)} (available runtimes ${Array.from(
+						hashes.keys(),
+						runtimeToString
+					).join(", ")})`
+				);
+			}
+			return hashInfo;
+		}
+	}
 
-				/**
-				 * Handler
-				 * @param {JavascriptParser} parser Parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
-					parser.hooks.program.tap("DefinePlugin", () => {
-						const { buildInfo } = parser.state.module;
-						if (!buildInfo.valueDependencies)
-							buildInfo.valueDependencies = new Map();
-						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
-					});
-
-					const addValueDependency = key => {
-						const { buildInfo } = parser.state.module;
-						buildInfo.valueDependencies.set(
-							VALUE_DEP_PREFIX + key,
-							compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)
-						);
-					};
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, if the module has hashes for this runtime
+	 */
+	hasModuleHashes(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return hashes && hashes.has(runtime);
+	}
 
-					const withValueDependency =
-						(key, fn) =>
-						(...args) => {
-							addValueDependency(key);
-							return fn(...args);
-						};
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
+	 */
+	getModuleHash(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return this._getModuleHashInfo(module, hashes, runtime).hash;
+	}
 
-					/**
-					 * Walk definitions
-					 * @param {Object} definitions Definitions map
-					 * @param {string} prefix Prefix string
-					 * @returns {void}
-					 */
-					const walkDefinitions = (definitions, prefix) => {
-						Object.keys(definitions).forEach(key => {
-							const code = definitions[key];
-							if (
-								code &&
-								typeof code === "object" &&
-								!(code instanceof RuntimeValue) &&
-								!(code instanceof RegExp)
-							) {
-								walkDefinitions(code, prefix + key + ".");
-								applyObjectDefine(prefix + key, code);
-								return;
-							}
-							applyDefineKey(prefix, key);
-							applyDefine(prefix + key, code);
-						});
-					};
-
-					/**
-					 * Apply define key
-					 * @param {string} prefix Prefix
-					 * @param {string} key Key
-					 * @returns {void}
-					 */
-					const applyDefineKey = (prefix, key) => {
-						const splittedKey = key.split(".");
-						splittedKey.slice(1).forEach((_, i) => {
-							const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
-							parser.hooks.canRename.for(fullKey).tap("DefinePlugin", () => {
-								addValueDependency(key);
-								return true;
-							});
-						});
-					};
-
-					/**
-					 * Apply Code
-					 * @param {string} key Key
-					 * @param {CodeValue} code Code
-					 * @returns {void}
-					 */
-					const applyDefine = (key, code) => {
-						const originalKey = key;
-						const isTypeof = /^typeof\s+/.test(key);
-						if (isTypeof) key = key.replace(/^typeof\s+/, "");
-						let recurse = false;
-						let recurseTypeof = false;
-						if (!isTypeof) {
-							parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
-								addValueDependency(originalKey);
-								return true;
-							});
-							parser.hooks.evaluateIdentifier
-								.for(key)
-								.tap("DefinePlugin", expr => {
-									/**
-									 * this is needed in case there is a recursion in the DefinePlugin
-									 * to prevent an endless recursion
-									 * e.g.: new DefinePlugin({
-									 * "a": "b",
-									 * "b": "a"
-									 * });
-									 */
-									if (recurse) return;
-									addValueDependency(originalKey);
-									recurse = true;
-									const res = parser.evaluate(
-										toCode(
-											code,
-											parser,
-											compilation.valueCacheVersions,
-											key,
-											runtimeTemplate,
-											null
-										)
-									);
-									recurse = false;
-									res.setRange(expr.range);
-									return res;
-								});
-							parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
-								addValueDependency(originalKey);
-								const strCode = toCode(
-									code,
-									parser,
-									compilation.valueCacheVersions,
-									originalKey,
-									runtimeTemplate,
-									!parser.isAsiPosition(expr.range[0])
-								);
-								if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
-									return toConstantDependency(parser, strCode, [
-										RuntimeGlobals.require
-									])(expr);
-								} else if (/__webpack_require__/.test(strCode)) {
-									return toConstantDependency(parser, strCode, [
-										RuntimeGlobals.requireScope
-									])(expr);
-								} else {
-									return toConstantDependency(parser, strCode)(expr);
-								}
-							});
-						}
-						parser.hooks.evaluateTypeof.for(key).tap("DefinePlugin", expr => {
-							/**
-							 * this is needed in case there is a recursion in the DefinePlugin
-							 * to prevent an endless recursion
-							 * e.g.: new DefinePlugin({
-							 * "typeof a": "typeof b",
-							 * "typeof b": "typeof a"
-							 * });
-							 */
-							if (recurseTypeof) return;
-							recurseTypeof = true;
-							addValueDependency(originalKey);
-							const codeCode = toCode(
-								code,
-								parser,
-								compilation.valueCacheVersions,
-								originalKey,
-								runtimeTemplate,
-								null
-							);
-							const typeofCode = isTypeof
-								? codeCode
-								: "typeof (" + codeCode + ")";
-							const res = parser.evaluate(typeofCode);
-							recurseTypeof = false;
-							res.setRange(expr.range);
-							return res;
-						});
-						parser.hooks.typeof.for(key).tap("DefinePlugin", expr => {
-							addValueDependency(originalKey);
-							const codeCode = toCode(
-								code,
-								parser,
-								compilation.valueCacheVersions,
-								originalKey,
-								runtimeTemplate,
-								null
-							);
-							const typeofCode = isTypeof
-								? codeCode
-								: "typeof (" + codeCode + ")";
-							const res = parser.evaluate(typeofCode);
-							if (!res.isString()) return;
-							return toConstantDependency(
-								parser,
-								JSON.stringify(res.string)
-							).bind(parser)(expr);
-						});
-					};
-
-					/**
-					 * Apply Object
-					 * @param {string} key Key
-					 * @param {Object} obj Object
-					 * @returns {void}
-					 */
-					const applyObjectDefine = (key, obj) => {
-						parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
-							addValueDependency(key);
-							return true;
-						});
-						parser.hooks.evaluateIdentifier
-							.for(key)
-							.tap("DefinePlugin", expr => {
-								addValueDependency(key);
-								return new BasicEvaluatedExpression()
-									.setTruthy()
-									.setSideEffects(false)
-									.setRange(expr.range);
-							});
-						parser.hooks.evaluateTypeof
-							.for(key)
-							.tap(
-								"DefinePlugin",
-								withValueDependency(key, evaluateToString("object"))
-							);
-						parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
-							addValueDependency(key);
-							const strCode = stringifyObj(
-								obj,
-								parser,
-								compilation.valueCacheVersions,
-								key,
-								runtimeTemplate,
-								!parser.isAsiPosition(expr.range[0])
-							);
-
-							if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
-								return toConstantDependency(parser, strCode, [
-									RuntimeGlobals.require
-								])(expr);
-							} else if (/__webpack_require__/.test(strCode)) {
-								return toConstantDependency(parser, strCode, [
-									RuntimeGlobals.requireScope
-								])(expr);
-							} else {
-								return toConstantDependency(parser, strCode)(expr);
-							}
-						});
-						parser.hooks.typeof
-							.for(key)
-							.tap(
-								"DefinePlugin",
-								withValueDependency(
-									key,
-									toConstantDependency(parser, JSON.stringify("object"))
-								)
-							);
-					};
-
-					walkDefinitions(definitions, "");
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("DefinePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("DefinePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("DefinePlugin", handler);
-
-				/**
-				 * Walk definitions
-				 * @param {Object} definitions Definitions map
-				 * @param {string} prefix Prefix string
-				 * @returns {void}
-				 */
-				const walkDefinitionsForValues = (definitions, prefix) => {
-					Object.keys(definitions).forEach(key => {
-						const code = definitions[key];
-						const version = toCacheVersion(code);
-						const name = VALUE_DEP_PREFIX + prefix + key;
-						mainHash.update("|" + prefix + key);
-						const oldVersion = compilation.valueCacheVersions.get(name);
-						if (oldVersion === undefined) {
-							compilation.valueCacheVersions.set(name, version);
-						} else if (oldVersion !== version) {
-							const warning = new WebpackError(
-								`DefinePlugin\nConflicting values for '${prefix + key}'`
-							);
-							warning.details = `'${oldVersion}' !== '${version}'`;
-							warning.hideStack = true;
-							compilation.warnings.push(warning);
-						}
-						if (
-							code &&
-							typeof code === "object" &&
-							!(code instanceof RuntimeValue) &&
-							!(code instanceof RegExp)
-						) {
-							walkDefinitionsForValues(code, prefix + key + ".");
-						}
-					});
-				};
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
+	 */
+	getRenderedModuleHash(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
+	}
 
-				walkDefinitionsForValues(definitions, "");
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {string} hash the full hash
+	 * @param {string} renderedHash the shortened hash for rendering
+	 * @returns {void}
+	 */
+	setModuleHashes(module, runtime, hash, renderedHash) {
+		const cgm = this._getChunkGraphModule(module);
+		if (cgm.hashes === undefined) {
+			cgm.hashes = new RuntimeSpecMap();
+		}
+		cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash));
+	}
 
-				compilation.valueCacheVersions.set(
-					VALUE_DEP_MAIN,
-					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
-				);
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
+	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
+	 * @returns {void}
+	 */
+	addModuleRuntimeRequirements(
+		module,
+		runtime,
+		items,
+		transferOwnership = true
+	) {
+		const cgm = this._getChunkGraphModule(module);
+		const runtimeRequirementsMap = cgm.runtimeRequirements;
+		if (runtimeRequirementsMap === undefined) {
+			const map = new RuntimeSpecMap();
+			// TODO avoid cloning item and track ownership instead
+			map.set(runtime, transferOwnership ? items : new Set(items));
+			cgm.runtimeRequirements = map;
+			return;
+		}
+		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
+			if (runtimeRequirements === undefined) {
+				return transferOwnership ? items : new Set(items);
+			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
+				for (const item of items) runtimeRequirements.add(item);
+				return runtimeRequirements;
+			} else {
+				for (const item of runtimeRequirements) items.add(item);
+				return items;
 			}
-		);
+		});
 	}
-}
-module.exports = DefinePlugin;
-
-
-/***/ }),
-
-/***/ 28623:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const DelegatedSourceDependency = __webpack_require__(22914);
-const StaticExportsDependency = __webpack_require__(91418);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceContext} SourceContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([
-	RuntimeGlobals.module,
-	RuntimeGlobals.require
-]);
-
-class DelegatedModule extends Module {
-	constructor(sourceRequest, data, type, userRequest, originalRequest) {
-		super("javascript/dynamic", null);
-
-		// Info from Factory
-		this.sourceRequest = sourceRequest;
-		this.request = data.id;
-		this.delegationType = type;
-		this.userRequest = userRequest;
-		this.originalRequest = originalRequest;
-		/** @type {ManifestModuleData} */
-		this.delegateData = data;
 
-		// Build info
-		this.delegatedSourceDependency = undefined;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
+	 * @returns {void}
+	 */
+	addChunkRuntimeRequirements(chunk, items) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const runtimeRequirements = cgc.runtimeRequirements;
+		if (runtimeRequirements === undefined) {
+			cgc.runtimeRequirements = items;
+		} else if (runtimeRequirements.size >= items.size) {
+			for (const item of items) runtimeRequirements.add(item);
+		} else {
+			for (const item of runtimeRequirements) items.add(item);
+			cgc.runtimeRequirements = items;
+		}
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<string>} items runtime requirements to be added
+	 * @returns {void}
 	 */
-	getSourceTypes() {
-		return TYPES;
+	addTreeRuntimeRequirements(chunk, items) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const runtimeRequirements = cgc.runtimeRequirementsInTree;
+		for (const item of items) runtimeRequirements.add(item);
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ReadonlySet<string>} runtime requirements
 	 */
-	libIdent(options) {
-		return typeof this.originalRequest === "string"
-			? this.originalRequest
-			: this.originalRequest.libIdent(options);
+	getModuleRuntimeRequirements(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const runtimeRequirements =
+			cgm.runtimeRequirements && cgm.runtimeRequirements.get(runtime);
+		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<string>} runtime requirements
 	 */
-	identifier() {
-		return `delegated ${JSON.stringify(this.request)} from ${
-			this.sourceRequest
-		}`;
+	getChunkRuntimeRequirements(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const runtimeRequirements = cgc.runtimeRequirements;
+		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {boolean} withConnections include connections
+	 * @returns {string} hash
 	 */
-	readableIdentifier(requestShortener) {
-		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
+	getModuleGraphHash(module, runtime, withConnections = true) {
+		const cgm = this._getChunkGraphModule(module);
+		return withConnections
+			? this._getModuleGraphHashWithConnections(cgm, module, runtime)
+			: this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {boolean} withConnections include connections
+	 * @returns {bigint} hash
 	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
+	getModuleGraphHashBigInt(module, runtime, withConnections = true) {
+		const cgm = this._getChunkGraphModule(module);
+		return withConnections
+			? BigInt(
+					`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`
+			  )
+			: this._getModuleGraphHashBigInt(cgm, module, runtime);
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {bigint} hash as big int
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = { ...this.delegateData.buildMeta };
-		this.buildInfo = {};
-		this.dependencies.length = 0;
-		this.delegatedSourceDependency = new DelegatedSourceDependency(
-			this.sourceRequest
-		);
-		this.addDependency(this.delegatedSourceDependency);
-		this.addDependency(
-			new StaticExportsDependency(this.delegateData.exports || true, false)
-		);
-		callback();
+	_getModuleGraphHashBigInt(cgm, module, runtime) {
+		if (cgm.graphHashes === undefined) {
+			cgm.graphHashes = new RuntimeSpecMap();
+		}
+		const graphHash = cgm.graphHashes.provide(runtime, () => {
+			const hash = createHash(this._hashFunction);
+			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
+			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
+			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
+		});
+		return graphHash;
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
 	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const dep = /** @type {DelegatedSourceDependency} */ (this.dependencies[0]);
-		const sourceModule = moduleGraph.getModule(dep);
-		let str;
-
-		if (!sourceModule) {
-			str = runtimeTemplate.throwMissingModuleErrorBlock({
-				request: this.sourceRequest
-			});
-		} else {
-			str = `module.exports = (${runtimeTemplate.moduleExports({
-				module: sourceModule,
-				chunkGraph,
-				request: dep.request,
-				runtimeRequirements: new Set()
-			})})`;
-
-			switch (this.delegationType) {
-				case "require":
-					str += `(${JSON.stringify(this.request)})`;
-					break;
-				case "object":
-					str += `[${JSON.stringify(this.request)}]`;
-					break;
-			}
-
-			str += ";";
-		}
-
-		const sources = new Map();
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			sources.set("javascript", new OriginalSource(str, this.identifier()));
-		} else {
-			sources.set("javascript", new RawSource(str));
+	_getModuleGraphHashWithConnections(cgm, module, runtime) {
+		if (cgm.graphHashesWithConnections === undefined) {
+			cgm.graphHashesWithConnections = new RuntimeSpecMap();
 		}
-
-		return {
-			sources,
-			runtimeRequirements: RUNTIME_REQUIREMENTS
+		const activeStateToString = state => {
+			if (state === false) return "F";
+			if (state === true) return "T";
+			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
+			throw new Error("Not implemented active state");
 		};
+		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
+		return cgm.graphHashesWithConnections.provide(runtime, () => {
+			const graphHash = this._getModuleGraphHashBigInt(
+				cgm,
+				module,
+				runtime
+			).toString(16);
+			const connections = this.moduleGraph.getOutgoingConnections(module);
+			/** @type {Set<Module>} */
+			const activeNamespaceModules = new Set();
+			/** @type {Map<string, Module | Set<Module>>} */
+			const connectedModules = new Map();
+			const processConnection = (connection, stateInfo) => {
+				const module = connection.module;
+				stateInfo += module.getExportsType(this.moduleGraph, strict);
+				// cspell:word Tnamespace
+				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
+				else {
+					const oldModule = connectedModules.get(stateInfo);
+					if (oldModule === undefined) {
+						connectedModules.set(stateInfo, module);
+					} else if (oldModule instanceof Set) {
+						oldModule.add(module);
+					} else if (oldModule !== module) {
+						connectedModules.set(stateInfo, new Set([oldModule, module]));
+					}
+				}
+			};
+			if (runtime === undefined || typeof runtime === "string") {
+				for (const connection of connections) {
+					const state = connection.getActiveState(runtime);
+					if (state === false) continue;
+					processConnection(connection, state === true ? "T" : "O");
+				}
+			} else {
+				// cspell:word Tnamespace
+				for (const connection of connections) {
+					const states = new Set();
+					let stateInfo = "";
+					forEachRuntime(
+						runtime,
+						runtime => {
+							const state = connection.getActiveState(runtime);
+							states.add(state);
+							stateInfo += activeStateToString(state) + runtime;
+						},
+						true
+					);
+					if (states.size === 1) {
+						const state = first(states);
+						if (state === false) continue;
+						stateInfo = activeStateToString(state);
+					}
+					processConnection(connection, stateInfo);
+				}
+			}
+			// cspell:word Tnamespace
+			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+				return graphHash;
+			const connectedModulesInOrder =
+				connectedModules.size > 1
+					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
+					: connectedModules;
+			const hash = createHash(this._hashFunction);
+			const addModuleToHash = module => {
+				hash.update(
+					this._getModuleGraphHashBigInt(
+						this._getChunkGraphModule(module),
+						module,
+						runtime
+					).toString(16)
+				);
+			};
+			const addModulesToHash = modules => {
+				let xor = ZERO_BIG_INT;
+				for (const m of modules) {
+					xor =
+						xor ^
+						this._getModuleGraphHashBigInt(
+							this._getChunkGraphModule(m),
+							m,
+							runtime
+						);
+				}
+				hash.update(xor.toString(16));
+			};
+			if (activeNamespaceModules.size === 1)
+				addModuleToHash(activeNamespaceModules.values().next().value);
+			else if (activeNamespaceModules.size > 1)
+				addModulesToHash(activeNamespaceModules);
+			for (const [stateInfo, modules] of connectedModulesInOrder) {
+				hash.update(stateInfo);
+				if (modules instanceof Set) {
+					addModulesToHash(modules);
+				} else {
+					addModuleToHash(modules);
+				}
+			}
+			hash.update(graphHash);
+			return /** @type {string} */ (hash.digest("hex"));
+		});
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<string>} runtime requirements
 	 */
-	size(type) {
-		return 42;
+	getTreeRuntimeRequirements(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.runtimeRequirementsInTree;
 	}
 
+	// TODO remove in webpack 6
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * @param {Module} module the module
+	 * @param {string} deprecateMessage message for the deprecation message
+	 * @param {string} deprecationCode code for the deprecation
+	 * @returns {ChunkGraph} the chunk graph
+	 */
+	static getChunkGraphForModule(module, deprecateMessage, deprecationCode) {
+		const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage);
+		if (fn) return fn(module);
+		const newFn = util.deprecate(
+			/**
+			 * @param {Module} module the module
+			 * @returns {ChunkGraph} the chunk graph
+			 */
+			module => {
+				const chunkGraph = chunkGraphForModuleMap.get(module);
+				if (!chunkGraph)
+					throw new Error(
+						deprecateMessage +
+							": There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)"
+					);
+				return chunkGraph;
+			},
+			deprecateMessage + ": Use new ChunkGraph API",
+			deprecationCode
+		);
+		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
+		return newFn(module);
+	}
+
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		hash.update(this.delegationType);
-		hash.update(JSON.stringify(this.request));
-		super.updateHash(hash, context);
+	static setChunkGraphForModule(module, chunkGraph) {
+		chunkGraphForModuleMap.set(module, chunkGraph);
 	}
 
-	serialize(context) {
-		const { write } = context;
-		// constructor
-		write(this.sourceRequest);
-		write(this.delegateData);
-		write(this.delegationType);
-		write(this.userRequest);
-		write(this.originalRequest);
-		super.serialize(context);
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	static clearChunkGraphForModule(module) {
+		chunkGraphForModuleMap.delete(module);
 	}
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new DelegatedModule(
-			read(), // sourceRequest
-			read(), // delegateData
-			read(), // delegationType
-			read(), // userRequest
-			read() // originalRequest
+	// TODO remove in webpack 6
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} deprecateMessage message for the deprecation message
+	 * @param {string} deprecationCode code for the deprecation
+	 * @returns {ChunkGraph} the chunk graph
+	 */
+	static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) {
+		const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage);
+		if (fn) return fn(chunk);
+		const newFn = util.deprecate(
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @returns {ChunkGraph} the chunk graph
+			 */
+			chunk => {
+				const chunkGraph = chunkGraphForChunkMap.get(chunk);
+				if (!chunkGraph)
+					throw new Error(
+						deprecateMessage +
+							"There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)"
+					);
+				return chunkGraph;
+			},
+			deprecateMessage + ": Use new ChunkGraph API",
+			deprecationCode
 		);
-		obj.deserialize(context);
-		return obj;
+		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);
+		return newFn(chunk);
 	}
 
+	// TODO remove in webpack 6
 	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @returns {void}
 	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {DelegatedModule} */ (module);
-		this.delegationType = m.delegationType;
-		this.userRequest = m.userRequest;
-		this.originalRequest = m.originalRequest;
-		this.delegateData = m.delegateData;
+	static setChunkGraphForChunk(chunk, chunkGraph) {
+		chunkGraphForChunkMap.set(chunk, chunkGraph);
 	}
 
+	// TODO remove in webpack 6
 	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 * @param {Chunk} chunk the chunk
+	 * @returns {void}
 	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.delegateData = undefined;
+	static clearChunkGraphForChunk(chunk) {
+		chunkGraphForChunkMap.delete(chunk);
 	}
 }
 
-makeSerializable(DelegatedModule, "webpack/lib/DelegatedModule");
+// TODO remove in webpack 6
+/** @type {WeakMap<Module, ChunkGraph>} */
+const chunkGraphForModuleMap = new WeakMap();
 
-module.exports = DelegatedModule;
+// TODO remove in webpack 6
+/** @type {WeakMap<Chunk, ChunkGraph>} */
+const chunkGraphForChunkMap = new WeakMap();
+
+// TODO remove in webpack 6
+/** @type {Map<string, (module: Module) => ChunkGraph>} */
+const deprecateGetChunkGraphForModuleMap = new Map();
+
+// TODO remove in webpack 6
+/** @type {Map<string, (chunk: Chunk) => ChunkGraph>} */
+const deprecateGetChunkGraphForChunkMap = new Map();
+
+module.exports = ChunkGraph;
 
 
 /***/ }),
 
-/***/ 51387:
+/***/ 15626:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -32172,682 +27935,588 @@ module.exports = DelegatedModule;
 
 
 
-const DelegatedModule = __webpack_require__(28623);
-
-// options.source
-// options.type
-// options.context
-// options.scope
-// options.content
-// options.associatedObjectForCache
-class DelegatedModuleFactoryPlugin {
-	constructor(options) {
-		this.options = options;
-		options.type = options.type || "require";
-		options.extensions = options.extensions || ["", ".js", ".json", ".wasm"];
-	}
-
-	apply(normalModuleFactory) {
-		const scope = this.options.scope;
-		if (scope) {
-			normalModuleFactory.hooks.factorize.tapAsync(
-				"DelegatedModuleFactoryPlugin",
-				(data, callback) => {
-					const [dependency] = data.dependencies;
-					const { request } = dependency;
-					if (request && request.startsWith(`${scope}/`)) {
-						const innerRequest = "." + request.substr(scope.length);
-						let resolved;
-						if (innerRequest in this.options.content) {
-							resolved = this.options.content[innerRequest];
-							return callback(
-								null,
-								new DelegatedModule(
-									this.options.source,
-									resolved,
-									this.options.type,
-									innerRequest,
-									request
-								)
-							);
-						}
-						for (let i = 0; i < this.options.extensions.length; i++) {
-							const extension = this.options.extensions[i];
-							const requestPlusExt = innerRequest + extension;
-							if (requestPlusExt in this.options.content) {
-								resolved = this.options.content[requestPlusExt];
-								return callback(
-									null,
-									new DelegatedModule(
-										this.options.source,
-										resolved,
-										this.options.type,
-										requestPlusExt,
-										request + extension
-									)
-								);
-							}
-						}
-					}
-					return callback();
-				}
-			);
-		} else {
-			normalModuleFactory.hooks.module.tap(
-				"DelegatedModuleFactoryPlugin",
-				module => {
-					const request = module.libIdent(this.options);
-					if (request) {
-						if (request in this.options.content) {
-							const resolved = this.options.content[request];
-							return new DelegatedModule(
-								this.options.source,
-								resolved,
-								this.options.type,
-								request,
-								module
-							);
-						}
-					}
-					return module;
-				}
-			);
-		}
-	}
-}
-module.exports = DelegatedModuleFactoryPlugin;
+const util = __webpack_require__(73837);
+const SortableSet = __webpack_require__(13098);
+const {
+	compareLocations,
+	compareChunks,
+	compareIterables
+} = __webpack_require__(29579);
 
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
 
-/***/ }),
+/** @typedef {{id: number}} HasId */
+/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */
 
-/***/ 80632:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @typedef {Object} RawChunkGroupOptions
+ * @property {number=} preloadOrder
+ * @property {number=} prefetchOrder
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
 
+let debugId = 5000;
 
+/**
+ * @template T
+ * @param {SortableSet<T>} set set to convert to array.
+ * @returns {T[]} the array format of existing set
+ */
+const getArray = set => Array.from(set);
 
-const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
-const DelegatedSourceDependency = __webpack_require__(22914);
+/**
+ * A convenience method used to sort chunks based on their id's
+ * @param {ChunkGroup} a first sorting comparator
+ * @param {ChunkGroup} b second sorting comparator
+ * @returns {1|0|-1} a sorting index to determine order
+ */
+const sortById = (a, b) => {
+	if (a.id < b.id) return -1;
+	if (b.id < a.id) return 1;
+	return 0;
+};
 
-/** @typedef {import("./Compiler")} Compiler */
+/**
+ * @param {OriginRecord} a the first comparator in sort
+ * @param {OriginRecord} b the second comparator in sort
+ * @returns {1|-1|0} returns sorting order as index
+ */
+const sortOrigin = (a, b) => {
+	const aIdent = a.module ? a.module.identifier() : "";
+	const bIdent = b.module ? b.module.identifier() : "";
+	if (aIdent < bIdent) return -1;
+	if (aIdent > bIdent) return 1;
+	return compareLocations(a.loc, b.loc);
+};
 
-class DelegatedPlugin {
+class ChunkGroup {
+	/**
+	 * Creates an instance of ChunkGroup.
+	 * @param {string|ChunkGroupOptions=} options chunk group options passed to chunkGroup
+	 */
 	constructor(options) {
+		if (typeof options === "string") {
+			options = { name: options };
+		} else if (!options) {
+			options = { name: undefined };
+		}
+		/** @type {number} */
+		this.groupDebugId = debugId++;
 		this.options = options;
+		/** @type {SortableSet<ChunkGroup>} */
+		this._children = new SortableSet(undefined, sortById);
+		/** @type {SortableSet<ChunkGroup>} */
+		this._parents = new SortableSet(undefined, sortById);
+		/** @type {SortableSet<ChunkGroup>} */
+		this._asyncEntrypoints = new SortableSet(undefined, sortById);
+		this._blocks = new SortableSet();
+		/** @type {Chunk[]} */
+		this.chunks = [];
+		/** @type {OriginRecord[]} */
+		this.origins = [];
+		/** Indices in top-down order */
+		/** @private @type {Map<Module, number>} */
+		this._modulePreOrderIndices = new Map();
+		/** Indices in bottom-up order */
+		/** @private @type {Map<Module, number>} */
+		this._modulePostOrderIndices = new Map();
+		/** @type {number} */
+		this.index = undefined;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * when a new chunk is added to a chunkGroup, addingOptions will occur.
+	 * @param {ChunkGroupOptions} options the chunkGroup options passed to addOptions
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DelegatedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					DelegatedSourceDependency,
-					normalModuleFactory
-				);
+	addOptions(options) {
+		for (const key of Object.keys(options)) {
+			if (this.options[key] === undefined) {
+				this.options[key] = options[key];
+			} else if (this.options[key] !== options[key]) {
+				if (key.endsWith("Order")) {
+					this.options[key] = Math.max(this.options[key], options[key]);
+				} else {
+					throw new Error(
+						`ChunkGroup.addOptions: No option merge strategy for ${key}`
+					);
+				}
 			}
-		);
-
-		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
-			new DelegatedModuleFactoryPlugin({
-				associatedObjectForCache: compiler.root,
-				...this.options
-			}).apply(normalModuleFactory);
-		});
+		}
 	}
-}
-
-module.exports = DelegatedPlugin;
 
-
-/***/ }),
-
-/***/ 71040:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./util/Hash")} Hash */
-
-/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
-
-class DependenciesBlock {
-	constructor() {
-		/** @type {Dependency[]} */
-		this.dependencies = [];
-		/** @type {AsyncDependenciesBlock[]} */
-		this.blocks = [];
-		/** @type {DependenciesBlock} */
-		this.parent = undefined;
-	}
-
-	getRootBlock() {
-		/** @type {DependenciesBlock} */
-		let current = this;
-		while (current.parent) current = current.parent;
-		return current;
-	}
+	/**
+	 * returns the name of current ChunkGroup
+	 * @returns {string|undefined} returns the ChunkGroup name
+	 */
+	get name() {
+		return this.options.name;
+	}
 
 	/**
-	 * Adds a DependencyBlock to DependencyBlock relationship.
-	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
-	 *
-	 * @param {AsyncDependenciesBlock} block block being added
+	 * sets a new name for current ChunkGroup
+	 * @param {string} value the new name for ChunkGroup
 	 * @returns {void}
 	 */
-	addBlock(block) {
-		this.blocks.push(block);
-		block.parent = this;
+	set name(value) {
+		this.options.name = value;
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {Dependency} dependency dependency being tied to block.
-	 * This is an "edge" pointing to another "node" on module graph.
-	 * @returns {void}
+	 * get a uniqueId for ChunkGroup, made up of its member Chunk debugId's
+	 * @returns {string} a unique concatenation of chunk debugId's
 	 */
-	addDependency(dependency) {
-		this.dependencies.push(dependency);
+	get debugId() {
+		return Array.from(this.chunks, x => x.debugId).join("+");
 	}
 
 	/**
-	 * @param {Dependency} dependency dependency being removed
-	 * @returns {void}
+	 * get a unique id for ChunkGroup, made up of its member Chunk id's
+	 * @returns {string} a unique concatenation of chunk ids
 	 */
-	removeDependency(dependency) {
-		const idx = this.dependencies.indexOf(dependency);
-		if (idx >= 0) {
-			this.dependencies.splice(idx, 1);
-		}
+	get id() {
+		return Array.from(this.chunks, x => x.id).join("+");
 	}
 
 	/**
-	 * Removes all dependencies and blocks
-	 * @returns {void}
+	 * Performs an unshift of a specific chunk
+	 * @param {Chunk} chunk chunk being unshifted
+	 * @returns {boolean} returns true if attempted chunk shift is accepted
 	 */
-	clearDependenciesAndBlocks() {
-		this.dependencies.length = 0;
-		this.blocks.length = 0;
+	unshiftChunk(chunk) {
+		const oldIdx = this.chunks.indexOf(chunk);
+		if (oldIdx > 0) {
+			this.chunks.splice(oldIdx, 1);
+			this.chunks.unshift(chunk);
+		} else if (oldIdx < 0) {
+			this.chunks.unshift(chunk);
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * inserts a chunk before another existing chunk in group
+	 * @param {Chunk} chunk Chunk being inserted
+	 * @param {Chunk} before Placeholder/target chunk marking new chunk insertion point
+	 * @returns {boolean} return true if insertion was successful
 	 */
-	updateHash(hash, context) {
-		for (const dep of this.dependencies) {
-			dep.updateHash(hash, context);
+	insertChunk(chunk, before) {
+		const oldIdx = this.chunks.indexOf(chunk);
+		const idx = this.chunks.indexOf(before);
+		if (idx < 0) {
+			throw new Error("before chunk not found");
 		}
-		for (const block of this.blocks) {
-			block.updateHash(hash, context);
+		if (oldIdx >= 0 && oldIdx > idx) {
+			this.chunks.splice(oldIdx, 1);
+			this.chunks.splice(idx, 0, chunk);
+		} else if (oldIdx < 0) {
+			this.chunks.splice(idx, 0, chunk);
+			return true;
 		}
+		return false;
 	}
 
-	serialize({ write }) {
-		write(this.dependencies);
-		write(this.blocks);
+	/**
+	 * add a chunk into ChunkGroup. Is pushed on or prepended
+	 * @param {Chunk} chunk chunk being pushed into ChunkGroupS
+	 * @returns {boolean} returns true if chunk addition was successful.
+	 */
+	pushChunk(chunk) {
+		const oldIdx = this.chunks.indexOf(chunk);
+		if (oldIdx >= 0) {
+			return false;
+		}
+		this.chunks.push(chunk);
+		return true;
 	}
 
-	deserialize({ read }) {
-		this.dependencies = read();
-		this.blocks = read();
-		for (const block of this.blocks) {
-			block.parent = this;
+	/**
+	 * @param {Chunk} oldChunk chunk to be replaced
+	 * @param {Chunk} newChunk New chunk that will be replaced with
+	 * @returns {boolean} returns true if the replacement was successful
+	 */
+	replaceChunk(oldChunk, newChunk) {
+		const oldIdx = this.chunks.indexOf(oldChunk);
+		if (oldIdx < 0) return false;
+		const newIdx = this.chunks.indexOf(newChunk);
+		if (newIdx < 0) {
+			this.chunks[oldIdx] = newChunk;
+			return true;
+		}
+		if (newIdx < oldIdx) {
+			this.chunks.splice(oldIdx, 1);
+			return true;
+		} else if (newIdx !== oldIdx) {
+			this.chunks[oldIdx] = newChunk;
+			this.chunks.splice(newIdx, 1);
+			return true;
 		}
 	}
-}
-
-makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock");
-
-module.exports = DependenciesBlock;
-
-
-/***/ }),
-
-/***/ 54912:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
-/**
- * @typedef {Object} UpdateHashContext
- * @property {ChunkGraph} chunkGraph
- * @property {RuntimeSpec} runtime
- * @property {RuntimeTemplate=} runtimeTemplate
- */
-
-/**
- * @typedef {Object} SourcePosition
- * @property {number} line
- * @property {number=} column
- */
-
-/**
- * @typedef {Object} RealDependencyLocation
- * @property {SourcePosition} start
- * @property {SourcePosition=} end
- * @property {number=} index
- */
-
-/**
- * @typedef {Object} SyntheticDependencyLocation
- * @property {string} name
- * @property {number=} index
- */
-
-/** @typedef {SyntheticDependencyLocation|RealDependencyLocation} DependencyLocation */
-
-/**
- * @typedef {Object} ExportSpec
- * @property {string} name the name of the export
- * @property {boolean=} canMangle can the export be renamed (defaults to true)
- * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts
- * @property {(string | ExportSpec)[]=} exports nested exports
- * @property {ModuleGraphConnection=} from when reexported: from which module
- * @property {string[] | null=} export when reexported: from which export
- * @property {number=} priority when reexported: with which priority
- * @property {boolean=} hidden export is not visible, because another export blends over it
- */
-
-/**
- * @typedef {Object} ExportsSpec
- * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
- * @property {Set<string>=} excludeExports when exports = true, list of unaffected exports
- * @property {Set<string>=} hideExports list of maybe prior exposed, but now hidden exports
- * @property {ModuleGraphConnection=} from when reexported: from which module
- * @property {number=} priority when reexported: with which priority
- * @property {boolean=} canMangle can the export be renamed (defaults to true)
- * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts
- * @property {Module[]=} dependencies module on which the result depends on
- */
 
-/**
- * @typedef {Object} ReferencedExport
- * @property {string[]} name name of the referenced export
- * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
- */
-
-const TRANSITIVE = Symbol("transitive");
-
-const getIgnoredModule = memoize(() => {
-	const RawModule = __webpack_require__(84929);
-	return new RawModule("/* (ignored) */", `ignored`, `(ignored)`);
-});
-
-class Dependency {
-	constructor() {
-		/** @type {Module} */
-		this._parentModule = undefined;
-		/** @type {DependenciesBlock} */
-		this._parentDependenciesBlock = undefined;
-		/** @type {number} */
-		this._parentDependenciesBlockIndex = -1;
-		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
-		this.weak = false;
-		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
-		this.optional = false;
-		this._locSL = 0;
-		this._locSC = 0;
-		this._locEL = 0;
-		this._locEC = 0;
-		this._locI = undefined;
-		this._locN = undefined;
-		this._loc = undefined;
+	/**
+	 * @param {Chunk} chunk chunk to remove
+	 * @returns {boolean} returns true if chunk was removed
+	 */
+	removeChunk(chunk) {
+		const idx = this.chunks.indexOf(chunk);
+		if (idx >= 0) {
+			this.chunks.splice(idx, 1);
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * @returns {string} a display name for the type of dependency
+	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
 	 */
-	get type() {
-		return "unknown";
+	isInitial() {
+		return false;
 	}
 
 	/**
-	 * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm"
+	 * @param {ChunkGroup} group chunk group to add
+	 * @returns {boolean} returns true if chunk group was added
 	 */
-	get category() {
-		return "unknown";
+	addChild(group) {
+		const size = this._children.size;
+		this._children.add(group);
+		return size !== this._children.size;
 	}
 
 	/**
-	 * @returns {DependencyLocation} location
+	 * @returns {ChunkGroup[]} returns the children of this group
 	 */
-	get loc() {
-		if (this._loc !== undefined) return this._loc;
-		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
-		const loc = {};
-		if (this._locSL > 0) {
-			loc.start = { line: this._locSL, column: this._locSC };
-		}
-		if (this._locEL > 0) {
-			loc.end = { line: this._locEL, column: this._locEC };
-		}
-		if (this._locN !== undefined) {
-			loc.name = this._locN;
-		}
-		if (this._locI !== undefined) {
-			loc.index = this._locI;
-		}
-		return (this._loc = loc);
+	getChildren() {
+		return this._children.getFromCache(getArray);
 	}
 
-	set loc(loc) {
-		if ("start" in loc && typeof loc.start === "object") {
-			this._locSL = loc.start.line || 0;
-			this._locSC = loc.start.column || 0;
-		} else {
-			this._locSL = 0;
-			this._locSC = 0;
-		}
-		if ("end" in loc && typeof loc.end === "object") {
-			this._locEL = loc.end.line || 0;
-			this._locEC = loc.end.column || 0;
-		} else {
-			this._locEL = 0;
-			this._locEC = 0;
-		}
-		if ("index" in loc) {
-			this._locI = loc.index;
-		} else {
-			this._locI = undefined;
-		}
-		if ("name" in loc) {
-			this._locN = loc.name;
-		} else {
-			this._locN = undefined;
-		}
-		this._loc = loc;
+	getNumberOfChildren() {
+		return this._children.size;
 	}
 
-	setLoc(startLine, startColumn, endLine, endColumn) {
-		this._locSL = startLine;
-		this._locSC = startColumn;
-		this._locEL = endLine;
-		this._locEC = endColumn;
-		this._locI = undefined;
-		this._locN = undefined;
-		this._loc = undefined;
+	get childrenIterable() {
+		return this._children;
 	}
 
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * @param {ChunkGroup} group the chunk group to remove
+	 * @returns {boolean} returns true if the chunk group was removed
 	 */
-	getResourceIdentifier() {
-		return null;
+	removeChild(group) {
+		if (!this._children.has(group)) {
+			return false;
+		}
+
+		this._children.delete(group);
+		group.removeParent(this);
+		return true;
 	}
 
 	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 * @param {ChunkGroup} parentChunk the parent group to be added into
+	 * @returns {boolean} returns true if this chunk group was added to the parent group
 	 */
-	couldAffectReferencingModule() {
-		return TRANSITIVE;
+	addParent(parentChunk) {
+		if (!this._parents.has(parentChunk)) {
+			this._parents.add(parentChunk);
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * Returns the referenced module and export
-	 * @deprecated
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {never} throws error
+	 * @returns {ChunkGroup[]} returns the parents of this group
 	 */
-	getReference(moduleGraph) {
-		throw new Error(
-			"Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule and ModuleGraph.getConnection().active"
-		);
+	getParents() {
+		return this._parents.getFromCache(getArray);
 	}
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return Dependency.EXPORTS_OBJECT_REFERENCED;
+	getNumberOfParents() {
+		return this._parents.size;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @param {ChunkGroup} parent the parent group
+	 * @returns {boolean} returns true if the parent group contains this group
 	 */
-	getCondition(moduleGraph) {
-		return null;
+	hasParent(parent) {
+		return this._parents.has(parent);
+	}
+
+	get parentsIterable() {
+		return this._parents;
 	}
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @param {ChunkGroup} chunkGroup the parent group
+	 * @returns {boolean} returns true if this group has been removed from the parent
 	 */
-	getExports(moduleGraph) {
-		return undefined;
+	removeParent(chunkGroup) {
+		if (this._parents.delete(chunkGroup)) {
+			chunkGroup.removeChild(this);
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
+	 * @param {Entrypoint} entrypoint entrypoint to add
+	 * @returns {boolean} returns true if entrypoint was added
 	 */
-	getWarnings(moduleGraph) {
-		return null;
+	addAsyncEntrypoint(entrypoint) {
+		const size = this._asyncEntrypoints.size;
+		this._asyncEntrypoints.add(entrypoint);
+		return size !== this._asyncEntrypoints.size;
+	}
+
+	get asyncEntrypointsIterable() {
+		return this._asyncEntrypoints;
 	}
 
 	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
+	 * @returns {Array} an array containing the blocks
 	 */
-	getErrors(moduleGraph) {
-		return null;
+	getBlocks() {
+		return this._blocks.getFromCache(getArray);
+	}
+
+	getNumberOfBlocks() {
+		return this._blocks.size;
+	}
+
+	hasBlock(block) {
+		return this._blocks.has(block);
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @returns {Iterable<AsyncDependenciesBlock>} blocks
 	 */
-	updateHash(hash, context) {}
+	get blocksIterable() {
+		return this._blocks;
+	}
 
 	/**
-	 * implement this method to allow the occurrence order plugin to count correctly
-	 * @returns {number} count how often the id is used in this dependency
+	 * @param {AsyncDependenciesBlock} block a block
+	 * @returns {boolean} false, if block was already added
 	 */
-	getNumberOfIdOccurrences() {
-		return 1;
+	addBlock(block) {
+		if (!this._blocks.has(block)) {
+			this._blocks.add(block);
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @param {Module} module origin module
+	 * @param {DependencyLocation} loc location of the reference in the origin module
+	 * @param {string} request request name of the reference
+	 * @returns {void}
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return true;
+	addOrigin(module, loc, request) {
+		this.origins.push({
+			module,
+			loc,
+			request
+		});
 	}
 
 	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {string[]} the files contained this chunk group
 	 */
-	createIgnoredModule(context) {
-		return getIgnoredModule();
+	getFiles() {
+		const files = new Set();
+
+		for (const chunk of this.chunks) {
+			for (const file of chunk.files) {
+				files.add(file);
+			}
+		}
+
+		return Array.from(files);
 	}
 
-	serialize({ write }) {
-		write(this.weak);
-		write(this.optional);
-		write(this._locSL);
-		write(this._locSC);
-		write(this._locEL);
-		write(this._locEC);
-		write(this._locI);
-		write(this._locN);
-	}
+	/**
+	 * @returns {void}
+	 */
+	remove() {
+		// cleanup parents
+		for (const parentChunkGroup of this._parents) {
+			// remove this chunk from its parents
+			parentChunkGroup._children.delete(this);
 
-	deserialize({ read }) {
-		this.weak = read();
-		this.optional = read();
-		this._locSL = read();
-		this._locSC = read();
-		this._locEL = read();
-		this._locEC = read();
-		this._locI = read();
-		this._locN = read();
+			// cleanup "sub chunks"
+			for (const chunkGroup of this._children) {
+				/**
+				 * remove this chunk as "intermediary" and connect
+				 * it "sub chunks" and parents directly
+				 */
+				// add parent to each "sub chunk"
+				chunkGroup.addParent(parentChunkGroup);
+				// add "sub chunk" to parent
+				parentChunkGroup.addChild(chunkGroup);
+			}
+		}
+
+		/**
+		 * we need to iterate again over the children
+		 * to remove this from the child's parents.
+		 * This can not be done in the above loop
+		 * as it is not guaranteed that `this._parents` contains anything.
+		 */
+		for (const chunkGroup of this._children) {
+			// remove this as parent of every "sub chunk"
+			chunkGroup._parents.delete(this);
+		}
+
+		// remove chunks
+		for (const chunk of this.chunks) {
+			chunk.removeGroup(this);
+		}
 	}
-}
 
-/** @type {string[][]} */
-Dependency.NO_EXPORTS_REFERENCED = [];
-/** @type {string[][]} */
-Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+	sortItems() {
+		this.origins.sort(sortOrigin);
+	}
 
-Object.defineProperty(Dependency.prototype, "module", {
 	/**
-	 * @deprecated
-	 * @returns {never} throws
+	 * Sorting predicate which allows current ChunkGroup to be compared against another.
+	 * Sorting values are based off of number of chunks in ChunkGroup.
+	 *
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
+	 * @returns {-1|0|1} sort position for comparison
 	 */
-	get() {
-		throw new Error(
-			"module property was removed from Dependency (use compilation.moduleGraph.getModule(dependency) instead)"
+	compareTo(chunkGraph, otherGroup) {
+		if (this.chunks.length > otherGroup.chunks.length) return -1;
+		if (this.chunks.length < otherGroup.chunks.length) return 1;
+		return compareIterables(compareChunks(chunkGraph))(
+			this.chunks,
+			otherGroup.chunks
 		);
-	},
+	}
 
 	/**
-	 * @deprecated
-	 * @returns {never} throws
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {Record<string, ChunkGroup[]>} mapping from children type to ordered list of ChunkGroups
 	 */
-	set() {
-		throw new Error(
-			"module property was removed from Dependency (use compilation.moduleGraph.updateModule(dependency, module) instead)"
-		);
+	getChildrenByOrders(moduleGraph, chunkGraph) {
+		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
+		const lists = new Map();
+		for (const childGroup of this._children) {
+			for (const key of Object.keys(childGroup.options)) {
+				if (key.endsWith("Order")) {
+					const name = key.substr(0, key.length - "Order".length);
+					let list = lists.get(name);
+					if (list === undefined) {
+						lists.set(name, (list = []));
+					}
+					list.push({
+						order: childGroup.options[key],
+						group: childGroup
+					});
+				}
+			}
+		}
+		/** @type {Record<string, ChunkGroup[]>} */
+		const result = Object.create(null);
+		for (const [name, list] of lists) {
+			list.sort((a, b) => {
+				const cmp = b.order - a.order;
+				if (cmp !== 0) return cmp;
+				return a.group.compareTo(chunkGraph, b.group);
+			});
+			result[name] = list.map(i => i.group);
+		}
+		return result;
 	}
-});
 
-Object.defineProperty(Dependency.prototype, "disconnect", {
-	get() {
-		throw new Error(
-			"disconnect was removed from Dependency (Dependency no longer carries graph specific information)"
-		);
+	/**
+	 * Sets the top-down index of a module in this ChunkGroup
+	 * @param {Module} module module for which the index should be set
+	 * @param {number} index the index of the module
+	 * @returns {void}
+	 */
+	setModulePreOrderIndex(module, index) {
+		this._modulePreOrderIndices.set(module, index);
 	}
-});
-
-Dependency.TRANSITIVE = TRANSITIVE;
-
-module.exports = Dependency;
-
-
-/***/ }),
-
-/***/ 5160:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @template T @typedef {import("./InitFragment")<T>} InitFragment */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-
-/**
- * @typedef {Object} DependencyTemplateContext
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {Set<string>} runtimeRequirements the requirements for runtime
- * @property {Module} module current module
- * @property {RuntimeSpec} runtime current runtimes, for which code is generated
- * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
- * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults} codeGenerationResults the code generation results
- */
-
-/**
- * @typedef {Object} CssDependencyTemplateContextExtras
- * @property {Map<string, string>} cssExports the css exports
- */
 
-/** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */
+	/**
+	 * Gets the top-down index of a module in this ChunkGroup
+	 * @param {Module} module the module
+	 * @returns {number} index
+	 */
+	getModulePreOrderIndex(module) {
+		return this._modulePreOrderIndices.get(module);
+	}
 
-class DependencyTemplate {
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * Sets the bottom-up index of a module in this ChunkGroup
+	 * @param {Module} module module for which the index should be set
+	 * @param {number} index the index of the module
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	setModulePostOrderIndex(module, index) {
+		this._modulePostOrderIndices.set(module, index);
+	}
+
+	/**
+	 * Gets the bottom-up index of a module in this ChunkGroup
+	 * @param {Module} module the module
+	 * @returns {number} index
+	 */
+	getModulePostOrderIndex(module) {
+		return this._modulePostOrderIndices.get(module);
+	}
+
+	/* istanbul ignore next */
+	checkConstraints() {
+		const chunk = this;
+		for (const child of chunk._children) {
+			if (!child._parents.has(chunk)) {
+				throw new Error(
+					`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`
+				);
+			}
+		}
+		for (const parentChunk of chunk._parents) {
+			if (!parentChunk._children.has(chunk)) {
+				throw new Error(
+					`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`
+				);
+			}
+		}
 	}
 }
 
-module.exports = DependencyTemplate;
+ChunkGroup.prototype.getModuleIndex = util.deprecate(
+	ChunkGroup.prototype.getModulePreOrderIndex,
+	"ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex",
+	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX"
+);
+
+ChunkGroup.prototype.getModuleIndex2 = util.deprecate(
+	ChunkGroup.prototype.getModulePostOrderIndex,
+	"ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex",
+	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2"
+);
+
+module.exports = ChunkGroup;
 
 
 /***/ }),
 
-/***/ 9163:
+/***/ 918:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -32858,71 +28527,35 @@ module.exports = DependencyTemplate;
 
 
 
-const createHash = __webpack_require__(49835);
-
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
-/** @typedef {typeof import("./util/Hash")} Hash */
-
-/** @typedef {new (...args: any[]) => Dependency} DependencyConstructor */
-
-class DependencyTemplates {
-	/**
-	 * @param {string | Hash} hashFunction the hash function to use
-	 */
-	constructor(hashFunction = "md4") {
-		/** @type {Map<Function, DependencyTemplate>} */
-		this._map = new Map();
-		/** @type {string} */
-		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
-		this._hashFunction = hashFunction;
-	}
-
-	/**
-	 * @param {DependencyConstructor} dependency Constructor of Dependency
-	 * @returns {DependencyTemplate} template for this dependency
-	 */
-	get(dependency) {
-		return this._map.get(dependency);
-	}
+const WebpackError = __webpack_require__(53799);
 
-	/**
-	 * @param {DependencyConstructor} dependency Constructor of Dependency
-	 * @param {DependencyTemplate} dependencyTemplate template for this dependency
-	 * @returns {void}
-	 */
-	set(dependency, dependencyTemplate) {
-		this._map.set(dependency, dependencyTemplate);
-	}
+/** @typedef {import("./Chunk")} Chunk */
 
+class ChunkRenderError extends WebpackError {
 	/**
-	 * @param {string} part additional hash contributor
-	 * @returns {void}
+	 * Create a new ChunkRenderError
+	 * @param {Chunk} chunk A chunk
+	 * @param {string} file Related file
+	 * @param {Error} error Original error
 	 */
-	updateHash(part) {
-		const hash = createHash(this._hashFunction);
-		hash.update(`${this._hash}${part}`);
-		this._hash = /** @type {string} */ (hash.digest("hex"));
-	}
-
-	getHash() {
-		return this._hash;
-	}
+	constructor(chunk, file, error) {
+		super();
 
-	clone() {
-		const newInstance = new DependencyTemplates(this._hashFunction);
-		newInstance._map = new Map(this._map);
-		newInstance._hash = this._hash;
-		return newInstance;
+		this.name = "ChunkRenderError";
+		this.error = error;
+		this.message = error.message;
+		this.details = error.stack;
+		this.file = file;
+		this.chunk = chunk;
 	}
 }
 
-module.exports = DependencyTemplates;
+module.exports = ChunkRenderError;
 
 
 /***/ }),
 
-/***/ 62790:
+/***/ 46341:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -32933,224 +28566,524 @@ module.exports = DependencyTemplates;
 
 
 
-const DllModuleFactory = __webpack_require__(68703);
-const DllEntryDependency = __webpack_require__(95666);
-const EntryDependency = __webpack_require__(3979);
+const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
 
-class DllEntryPlugin {
-	constructor(context, entries, options) {
-		this.context = context;
-		this.entries = entries;
-		this.options = options;
-	}
+/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./Compilation")} Compilation */
 
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DllEntryPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const dllModuleFactory = new DllModuleFactory();
-				compilation.dependencyFactories.set(
-					DllEntryDependency,
-					dllModuleFactory
-				);
-				compilation.dependencyFactories.set(
-					EntryDependency,
-					normalModuleFactory
-				);
+const getJavascriptModulesPlugin = memoize(() =>
+	__webpack_require__(89464)
+);
+
+// TODO webpack 6 remove this class
+class ChunkTemplate {
+	/**
+	 * @param {OutputOptions} outputOptions output options
+	 * @param {Compilation} compilation the compilation
+	 */
+	constructor(outputOptions, compilation) {
+		this._outputOptions = outputOptions || {};
+		this.hooks = Object.freeze({
+			renderManifest: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.renderManifest.tap(
+							options,
+							(entries, options) => {
+								if (options.chunk.hasRuntime()) return entries;
+								return fn(entries, options);
+							}
+						);
+					},
+					"ChunkTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_MANIFEST"
+				)
+			},
+			modules: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderChunk.tap(options, (source, renderContext) =>
+								fn(
+									source,
+									compilation.moduleTemplates.javascript,
+									renderContext
+								)
+							);
+					},
+					"ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_MODULES"
+				)
+			},
+			render: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderChunk.tap(options, (source, renderContext) =>
+								fn(
+									source,
+									compilation.moduleTemplates.javascript,
+									renderContext
+								)
+							);
+					},
+					"ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER"
+				)
+			},
+			renderWithEntry: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.render.tap(options, (source, renderContext) => {
+								if (
+									renderContext.chunkGraph.getNumberOfEntryModules(
+										renderContext.chunk
+									) === 0 ||
+									renderContext.chunk.hasRuntime()
+								) {
+									return source;
+								}
+								return fn(source, renderContext.chunk);
+							});
+					},
+					"ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY"
+				)
+			},
+			hash: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.fullHash.tap(options, fn);
+					},
+					"ChunkTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH"
+				)
+			},
+			hashForChunk: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.chunkHash.tap(options, (chunk, hash, context) => {
+								if (chunk.hasRuntime()) return;
+								fn(hash, chunk, context);
+							});
+					},
+					"ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK"
+				)
 			}
-		);
-		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
-			compilation.addEntry(
-				this.context,
-				new DllEntryDependency(
-					this.entries.map((e, idx) => {
-						const dep = new EntryDependency(e);
-						dep.loc = {
-							name: this.options.name,
-							index: idx
-						};
-						return dep;
-					}),
-					this.options.name
-				),
-				this.options,
-				callback
-			);
 		});
 	}
 }
 
-module.exports = DllEntryPlugin;
+Object.defineProperty(ChunkTemplate.prototype, "outputOptions", {
+	get: util.deprecate(
+		/**
+		 * @this {ChunkTemplate}
+		 * @returns {OutputOptions} output options
+		 */
+		function () {
+			return this._outputOptions;
+		},
+		"ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
+		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
+
+module.exports = ChunkTemplate;
 
 
 /***/ }),
 
-/***/ 28280:
+/***/ 31085:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
+const asyncLib = __webpack_require__(78175);
+const { SyncBailHook } = __webpack_require__(41242);
+const Compilation = __webpack_require__(85720);
+const createSchemaValidation = __webpack_require__(32540);
+const { join } = __webpack_require__(17139);
+const processAsyncTree = __webpack_require__(42791);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceContext} SourceContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").StatsCallback} StatsCallback */
 
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([
-	RuntimeGlobals.require,
-	RuntimeGlobals.module
-]);
+/** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
+/** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
 
-class DllModule extends Module {
-	constructor(context, dependencies, name) {
-		super("javascript/dynamic", context);
+/**
+ * @typedef {Object} CleanPluginCompilationHooks
+ * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
+ */
 
-		// Info from Factory
-		this.dependencies = dependencies;
-		this.name = name;
+const validate = createSchemaValidation(
+	undefined,
+	() => {
+		const { definitions } = __webpack_require__(73342);
+		return {
+			definitions,
+			oneOf: [{ $ref: "#/definitions/CleanOptions" }]
+		};
+	},
+	{
+		name: "Clean Plugin",
+		baseDataPath: "options"
 	}
+);
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
+/**
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} outputPath output path
+ * @param {Set<string>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
+ * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
+ * @returns {void}
+ */
+const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
+	const directories = new Set();
+	// get directories of assets
+	for (const asset of currentAssets) {
+		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
+	}
+	// and all parent directories
+	for (const directory of directories) {
+		directories.add(directory.replace(/(^|\/)[^/]*$/, ""));
 	}
+	const diff = new Set();
+	asyncLib.forEachLimit(
+		directories,
+		10,
+		(directory, callback) => {
+			fs.readdir(join(fs, outputPath, directory), (err, entries) => {
+				if (err) {
+					if (err.code === "ENOENT") return callback();
+					if (err.code === "ENOTDIR") {
+						diff.add(directory);
+						return callback();
+					}
+					return callback(err);
+				}
+				for (const entry of entries) {
+					const file = /** @type {string} */ (entry);
+					const filename = directory ? `${directory}/${file}` : file;
+					if (!directories.has(filename) && !currentAssets.has(filename)) {
+						diff.add(filename);
+					}
+				}
+				callback();
+			});
+		},
+		err => {
+			if (err) return callback(err);
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `dll ${this.name}`;
+			callback(null, diff);
+		}
+	);
+};
+
+/**
+ * @param {Set<string>} currentAssets assets list
+ * @param {Set<string>} oldAssets old assets list
+ * @returns {Set<string>} diff
+ */
+const getDiffToOldAssets = (currentAssets, oldAssets) => {
+	const diff = new Set();
+	for (const asset of oldAssets) {
+		if (!currentAssets.has(asset)) diff.add(asset);
 	}
+	return diff;
+};
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `dll ${this.name}`;
+/**
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} filename path to file
+ * @param {StatsCallback} callback callback for provided filename
+ * @returns {void}
+ */
+const doStat = (fs, filename, callback) => {
+	if ("lstat" in fs) {
+		fs.lstat(filename, callback);
+	} else {
+		fs.stat(filename, callback);
 	}
+};
+
+/**
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} outputPath output path
+ * @param {boolean} dry only log instead of fs modification
+ * @param {Logger} logger logger
+ * @param {Set<string>} diff filenames of the assets that shouldn't be there
+ * @param {function(string): boolean} isKept check if the entry is ignored
+ * @param {function(Error=): void} callback callback
+ * @returns {void}
+ */
+const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
+	const log = msg => {
+		if (dry) {
+			logger.info(msg);
+		} else {
+			logger.log(msg);
+		}
+	};
+	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
+	/** @type {Job[]} */
+	const jobs = Array.from(diff, filename => ({
+		type: "check",
+		filename,
+		parent: undefined
+	}));
+	processAsyncTree(
+		jobs,
+		10,
+		({ type, filename, parent }, push, callback) => {
+			const handleError = err => {
+				if (err.code === "ENOENT") {
+					log(`${filename} was removed during cleaning by something else`);
+					handleParent();
+					return callback();
+				}
+				return callback(err);
+			};
+			const handleParent = () => {
+				if (parent && --parent.remaining === 0) push(parent.job);
+			};
+			const path = join(fs, outputPath, filename);
+			switch (type) {
+				case "check":
+					if (isKept(filename)) {
+						// do not decrement parent entry as we don't want to delete the parent
+						log(`${filename} will be kept`);
+						return process.nextTick(callback);
+					}
+					doStat(fs, path, (err, stats) => {
+						if (err) return handleError(err);
+						if (!stats.isDirectory()) {
+							push({
+								type: "unlink",
+								filename,
+								parent
+							});
+							return callback();
+						}
+						fs.readdir(path, (err, entries) => {
+							if (err) return handleError(err);
+							/** @type {Job} */
+							const deleteJob = {
+								type: "rmdir",
+								filename,
+								parent
+							};
+							if (entries.length === 0) {
+								push(deleteJob);
+							} else {
+								const parentToken = {
+									remaining: entries.length,
+									job: deleteJob
+								};
+								for (const entry of entries) {
+									const file = /** @type {string} */ (entry);
+									if (file.startsWith(".")) {
+										log(
+											`${filename} will be kept (dot-files will never be removed)`
+										);
+										continue;
+									}
+									push({
+										type: "check",
+										filename: `${filename}/${file}`,
+										parent: parentToken
+									});
+								}
+							}
+							return callback();
+						});
+					});
+					break;
+				case "rmdir":
+					log(`${filename} will be removed`);
+					if (dry) {
+						handleParent();
+						return process.nextTick(callback);
+					}
+					if (!fs.rmdir) {
+						logger.warn(
+							`${filename} can't be removed because output file system doesn't support removing directories (rmdir)`
+						);
+						return process.nextTick(callback);
+					}
+					fs.rmdir(path, err => {
+						if (err) return handleError(err);
+						handleParent();
+						callback();
+					});
+					break;
+				case "unlink":
+					log(`${filename} will be removed`);
+					if (dry) {
+						handleParent();
+						return process.nextTick(callback);
+					}
+					if (!fs.unlink) {
+						logger.warn(
+							`${filename} can't be removed because output file system doesn't support removing files (rmdir)`
+						);
+						return process.nextTick(callback);
+					}
+					fs.unlink(path, err => {
+						if (err) return handleError(err);
+						handleParent();
+						callback();
+					});
+					break;
+			}
+		},
+		callback
+	);
+};
+
+/** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
+class CleanPlugin {
 	/**
-	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @returns {CleanPluginCompilationHooks} the attached hooks
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {};
-		return callback();
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				/** @type {SyncBailHook<[string], boolean>} */
+				keep: new SyncBailHook(["ignore"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		const sources = new Map();
-		sources.set(
-			"javascript",
-			new RawSource("module.exports = __webpack_require__;")
-		);
-		return {
-			sources,
-			runtimeRequirements: RUNTIME_REQUIREMENTS
-		};
+	/** @param {CleanOptions} options options */
+	constructor(options = {}) {
+		validate(options);
+		this.options = { dry: false, ...options };
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
-	}
+	apply(compiler) {
+		const { dry, keep } = this.options;
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 12;
-	}
+		const keepFn =
+			typeof keep === "function"
+				? keep
+				: typeof keep === "string"
+				? path => path.startsWith(keep)
+				: typeof keep === "object" && keep.test
+				? path => keep.test(path)
+				: () => false;
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(`dll module${this.name || ""}`);
-		super.updateHash(hash, context);
-	}
+		// We assume that no external modification happens while the compiler is active
+		// So we can store the old assets and only diff to them to avoid fs access on
+		// incremental builds
+		let oldAssets;
 
-	serialize(context) {
-		context.write(this.name);
-		super.serialize(context);
-	}
+		compiler.hooks.emit.tapAsync(
+			{
+				name: "CleanPlugin",
+				stage: 100
+			},
+			(compilation, callback) => {
+				const hooks = CleanPlugin.getCompilationHooks(compilation);
+				const logger = compilation.getLogger("webpack.CleanPlugin");
+				const fs = compiler.outputFileSystem;
 
-	deserialize(context) {
-		this.name = context.read();
-		super.deserialize(context);
-	}
+				if (!fs.readdir) {
+					return callback(
+						new Error(
+							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
+						)
+					);
+				}
 
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		this.dependencies = module.dependencies;
-	}
+				const currentAssets = new Set();
+				for (const asset of Object.keys(compilation.assets)) {
+					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
+					let normalizedAsset;
+					let newNormalizedAsset = asset.replace(/\\/g, "/");
+					do {
+						normalizedAsset = newNormalizedAsset;
+						newNormalizedAsset = normalizedAsset.replace(
+							/(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
+							"$1"
+						);
+					} while (newNormalizedAsset !== normalizedAsset);
+					if (normalizedAsset.startsWith("../")) continue;
+					currentAssets.add(normalizedAsset);
+				}
 
-	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
-	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.dependencies = undefined;
+				const outputPath = compilation.getPath(compiler.outputPath, {});
+
+				const isKept = path => {
+					const result = hooks.keep.call(path);
+					if (result !== undefined) return result;
+					return keepFn(path);
+				};
+
+				const diffCallback = (err, diff) => {
+					if (err) {
+						oldAssets = undefined;
+						return callback(err);
+					}
+					applyDiff(fs, outputPath, dry, logger, diff, isKept, err => {
+						if (err) {
+							oldAssets = undefined;
+						} else {
+							oldAssets = currentAssets;
+						}
+						callback(err);
+					});
+				};
+
+				if (oldAssets) {
+					diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets));
+				} else {
+					getDiffToFs(fs, outputPath, currentAssets, diffCallback);
+				}
+			}
+		);
 	}
 }
 
-makeSerializable(DllModule, "webpack/lib/DllModule");
-
-module.exports = DllModule;
+module.exports = CleanPlugin;
 
 
 /***/ }),
 
-/***/ 68703:
+/***/ 2102:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -33161,41 +29094,33 @@ module.exports = DllModule;
 
 
 
-const DllModule = __webpack_require__(28280);
-const ModuleFactory = __webpack_require__(51010);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./dependencies/DllEntryDependency")} DllEntryDependency */
+/** @typedef {import("./Module")} Module */
 
-class DllModuleFactory extends ModuleFactory {
-	constructor() {
-		super();
-		this.hooks = Object.freeze({});
-	}
+class CodeGenerationError extends WebpackError {
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
+	 * Create a new CodeGenerationError
+	 * @param {Module} module related module
+	 * @param {Error} error Original error
 	 */
-	create(data, callback) {
-		const dependency = /** @type {DllEntryDependency} */ (data.dependencies[0]);
-		callback(null, {
-			module: new DllModule(
-				data.context,
-				dependency.dependencies,
-				dependency.name
-			)
-		});
+	constructor(module, error) {
+		super();
+
+		this.name = "CodeGenerationError";
+		this.error = error;
+		this.message = error.message;
+		this.details = error.stack;
+		this.module = module;
 	}
 }
 
-module.exports = DllModuleFactory;
+module.exports = CodeGenerationError;
 
 
 /***/ }),
 
-/***/ 40038:
+/***/ 71426:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -33206,72 +29131,159 @@ module.exports = DllModuleFactory;
 
 
 
-const DllEntryPlugin = __webpack_require__(62790);
-const FlagAllModulesAsUsedPlugin = __webpack_require__(58727);
-const LibManifestPlugin = __webpack_require__(93837);
-const createSchemaValidation = __webpack_require__(32540);
-
-/** @typedef {import("../declarations/plugins/DllPlugin").DllPluginOptions} DllPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
+const { provide } = __webpack_require__(82482);
+const { first } = __webpack_require__(93347);
+const createHash = __webpack_require__(49835);
+const { runtimeToString, RuntimeSpecMap } = __webpack_require__(17156);
 
-const validate = createSchemaValidation(
-	__webpack_require__(9667),
-	() => __webpack_require__(99926),
-	{
-		name: "Dll Plugin",
-		baseDataPath: "options"
-	}
-);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-class DllPlugin {
+class CodeGenerationResults {
 	/**
-	 * @param {DllPluginOptions} options options object
+	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(options) {
-		validate(options);
-		this.options = {
-			...options,
-			entryOnly: options.entryOnly !== false
-		};
+	constructor(hashFunction = "md4") {
+		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
+		this.map = new Map();
+		this._hashFunction = hashFunction;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {CodeGenerationResult} the CodeGenerationResult
 	 */
-	apply(compiler) {
-		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
-			if (typeof entry !== "function") {
-				for (const name of Object.keys(entry)) {
-					const options = {
-						name,
-						filename: entry.filename
-					};
-					new DllEntryPlugin(context, entry[name].import, options).apply(
-						compiler
+	get(module, runtime) {
+		const entry = this.map.get(module);
+		if (entry === undefined) {
+			throw new Error(
+				`No code generation entry for ${module.identifier()} (existing entries: ${Array.from(
+					this.map.keys(),
+					m => m.identifier()
+				).join(", ")})`
+			);
+		}
+		if (runtime === undefined) {
+			if (entry.size > 1) {
+				const results = new Set(entry.values());
+				if (results.size !== 1) {
+					throw new Error(
+						`No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
+							entry.keys(),
+							r => runtimeToString(r)
+						).join(", ")}).
+Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
 					);
 				}
-			} else {
-				throw new Error(
-					"DllPlugin doesn't support dynamic entry (function) yet"
-				);
+				return first(results);
 			}
-			return true;
-		});
-		new LibManifestPlugin(this.options).apply(compiler);
-		if (!this.options.entryOnly) {
-			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+			return entry.values().next().value;
+		}
+		const result = entry.get(runtime);
+		if (result === undefined) {
+			throw new Error(
+				`No code generation entry for runtime ${runtimeToString(
+					runtime
+				)} for ${module.identifier()} (existing runtimes: ${Array.from(
+					entry.keys(),
+					r => runtimeToString(r)
+				).join(", ")})`
+			);
+		}
+		return result;
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {boolean} true, when we have data for this
+	 */
+	has(module, runtime) {
+		const entry = this.map.get(module);
+		if (entry === undefined) {
+			return false;
+		}
+		if (runtime !== undefined) {
+			return entry.has(runtime);
+		} else if (entry.size > 1) {
+			const results = new Set(entry.values());
+			return results.size === 1;
+		} else {
+			return entry.size === 1;
+		}
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @param {string} sourceType the source type
+	 * @returns {Source} a source
+	 */
+	getSource(module, runtime, sourceType) {
+		return this.get(module, runtime).sources.get(sourceType);
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {ReadonlySet<string>} runtime requirements
+	 */
+	getRuntimeRequirements(module, runtime) {
+		return this.get(module, runtime).runtimeRequirements;
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @param {string} key data key
+	 * @returns {any} data generated by code generation
+	 */
+	getData(module, runtime, key) {
+		const data = this.get(module, runtime).data;
+		return data === undefined ? undefined : data.get(key);
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {any} hash of the code generation
+	 */
+	getHash(module, runtime) {
+		const info = this.get(module, runtime);
+		if (info.hash !== undefined) return info.hash;
+		const hash = createHash(this._hashFunction);
+		for (const [type, source] of info.sources) {
+			hash.update(type);
+			source.updateHash(hash);
 		}
+		if (info.runtimeRequirements) {
+			for (const rr of info.runtimeRequirements) hash.update(rr);
+		}
+		return (info.hash = /** @type {string} */ (hash.digest("hex")));
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @param {CodeGenerationResult} result result from module
+	 * @returns {void}
+	 */
+	add(module, runtime, result) {
+		const map = provide(this.map, module, () => new RuntimeSpecMap());
+		map.set(runtime, result);
 	}
 }
 
-module.exports = DllPlugin;
+module.exports = CodeGenerationResults;
 
 
 /***/ }),
 
-/***/ 90999:
+/***/ 98427:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -33282,195 +29294,55 @@ module.exports = DllPlugin;
 
 
 
-const parseJson = __webpack_require__(15235);
-const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
-const ExternalModuleFactoryPlugin = __webpack_require__(62153);
 const WebpackError = __webpack_require__(53799);
-const DelegatedSourceDependency = __webpack_require__(22914);
-const createSchemaValidation = __webpack_require__(32540);
-const makePathsRelative = (__webpack_require__(82186).makePathsRelative);
-
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
+const makeSerializable = __webpack_require__(33032);
 
-const validate = createSchemaValidation(
-	__webpack_require__(28534),
-	() => __webpack_require__(46552),
-	{
-		name: "Dll Reference Plugin",
-		baseDataPath: "options"
-	}
-);
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 
-class DllReferencePlugin {
+class CommentCompilationWarning extends WebpackError {
 	/**
-	 * @param {DllReferencePluginOptions} options options object
+	 *
+	 * @param {string} message warning message
+	 * @param {DependencyLocation} loc affected lines of code
 	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
-		/** @type {WeakMap<Object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
-		this._compilationData = new WeakMap();
-	}
-
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					DelegatedSourceDependency,
-					normalModuleFactory
-				);
-			}
-		);
-
-		compiler.hooks.beforeCompile.tapAsync(
-			"DllReferencePlugin",
-			(params, callback) => {
-				if ("manifest" in this.options) {
-					const manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						compiler.inputFileSystem.readFile(manifest, (err, result) => {
-							if (err) return callback(err);
-							const data = {
-								path: manifest,
-								data: undefined,
-								error: undefined
-							};
-							// Catch errors parsing the manifest so that blank
-							// or malformed manifest files don't kill the process.
-							try {
-								data.data = parseJson(result.toString("utf-8"));
-							} catch (e) {
-								// Store the error in the params so that it can
-								// be added as a compilation error later on.
-								const manifestPath = makePathsRelative(
-									compiler.options.context,
-									manifest,
-									compiler.root
-								);
-								data.error = new DllManifestError(manifestPath, e.message);
-							}
-							this._compilationData.set(params, data);
-							return callback();
-						});
-						return;
-					}
-				}
-				return callback();
-			}
-		);
+	constructor(message, loc) {
+		super(message);
 
-		compiler.hooks.compile.tap("DllReferencePlugin", params => {
-			let name = this.options.name;
-			let sourceType = this.options.sourceType;
-			let content =
-				"content" in this.options ? this.options.content : undefined;
-			if ("manifest" in this.options) {
-				let manifestParameter = this.options.manifest;
-				let manifest;
-				if (typeof manifestParameter === "string") {
-					const data = this._compilationData.get(params);
-					// If there was an error parsing the manifest
-					// file, exit now because the error will be added
-					// as a compilation error in the "compilation" hook.
-					if (data.error) {
-						return;
-					}
-					manifest = data.data;
-				} else {
-					manifest = manifestParameter;
-				}
-				if (manifest) {
-					if (!name) name = manifest.name;
-					if (!sourceType) sourceType = manifest.type;
-					if (!content) content = manifest.content;
-				}
-			}
-			/** @type {Externals} */
-			const externals = {};
-			const source = "dll-reference " + name;
-			externals[source] = name;
-			const normalModuleFactory = params.normalModuleFactory;
-			new ExternalModuleFactoryPlugin(sourceType || "var", externals).apply(
-				normalModuleFactory
-			);
-			new DelegatedModuleFactoryPlugin({
-				source: source,
-				type: this.options.type,
-				scope: this.options.scope,
-				context: this.options.context || compiler.options.context,
-				content,
-				extensions: this.options.extensions,
-				associatedObjectForCache: compiler.root
-			}).apply(normalModuleFactory);
-		});
+		this.name = "CommentCompilationWarning";
 
-		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
-			(compilation, params) => {
-				if ("manifest" in this.options) {
-					let manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						const data = this._compilationData.get(params);
-						// If there was an error parsing the manifest file, add the
-						// error as a compilation error to make the compilation fail.
-						if (data.error) {
-							compilation.errors.push(data.error);
-						}
-						compilation.fileDependencies.add(manifest);
-					}
-				}
-			}
-		);
+		this.loc = loc;
 	}
 }
 
-class DllManifestError extends WebpackError {
-	constructor(filename, message) {
-		super();
-
-		this.name = "DllManifestError";
-		this.message = `Dll manifest ${filename}\n${message}`;
-	}
-}
+makeSerializable(
+	CommentCompilationWarning,
+	"webpack/lib/CommentCompilationWarning"
+);
 
-module.exports = DllReferencePlugin;
+module.exports = CommentCompilationWarning;
 
 
 /***/ }),
 
-/***/ 96475:
+/***/ 94258:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Naoyuki Kanezawa @nkzawa
+	Author Tobias Koppers @sokra
 */
 
 
 
-const EntryOptionPlugin = __webpack_require__(9909);
-const EntryPlugin = __webpack_require__(96953);
-const EntryDependency = __webpack_require__(3979);
+const ConstDependency = __webpack_require__(76911);
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDynamicNormalized} EntryDynamic */
-/** @typedef {import("../declarations/WebpackOptions").EntryItem} EntryItem */
-/** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStatic */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-class DynamicEntryPlugin {
-	/**
-	 * @param {string} context the context path
-	 * @param {EntryDynamic} entry the entry value
-	 */
-	constructor(context, entry) {
-		this.context = context;
-		this.entry = entry;
-	}
+const nestedWebpackRequireTag = Symbol("nested __webpack_require__");
 
+class CompatibilityPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -33478,57 +29350,141 @@ class DynamicEntryPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DynamicEntryPlugin",
+			"CompatibilityPlugin",
 			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					EntryDependency,
-					normalModuleFactory
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
 				);
-			}
-		);
 
-		compiler.hooks.make.tapPromise(
-			"DynamicEntryPlugin",
-			(compilation, callback) =>
-				Promise.resolve(this.entry())
-					.then(entry => {
-						const promises = [];
-						for (const name of Object.keys(entry)) {
-							const desc = entry[name];
-							const options = EntryOptionPlugin.entryDescriptionToOptions(
-								compiler,
-								name,
-								desc
-							);
-							for (const entry of desc.import) {
-								promises.push(
-									new Promise((resolve, reject) => {
-										compilation.addEntry(
-											this.context,
-											EntryPlugin.createDependency(entry, options),
-											options,
-											err => {
-												if (err) return reject(err);
-												resolve();
-											}
-										);
-									})
-								);
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("CompatibilityPlugin", (parser, parserOptions) => {
+						if (
+							parserOptions.browserify !== undefined &&
+							!parserOptions.browserify
+						)
+							return;
+
+						parser.hooks.call
+							.for("require")
+							.tap("CompatibilityPlugin", expr => {
+								// support for browserify style require delegator: "require(o, !0)"
+								if (expr.arguments.length !== 2) return;
+								const second = parser.evaluateExpression(expr.arguments[1]);
+								if (!second.isBoolean()) return;
+								if (second.asBool() !== true) return;
+								const dep = new ConstDependency("require", expr.callee.range);
+								dep.loc = expr.loc;
+								if (parser.state.current.dependencies.length > 0) {
+									const last =
+										parser.state.current.dependencies[
+											parser.state.current.dependencies.length - 1
+										];
+									if (
+										last.critical &&
+										last.options &&
+										last.options.request === "." &&
+										last.userRequest === "." &&
+										last.options.recursive
+									)
+										parser.state.current.dependencies.pop();
+								}
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+					});
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					// Handle nested requires
+					parser.hooks.preStatement.tap("CompatibilityPlugin", statement => {
+						if (
+							statement.type === "FunctionDeclaration" &&
+							statement.id &&
+							statement.id.name === "__webpack_require__"
+						) {
+							const newName = `__nested_webpack_require_${statement.range[0]}__`;
+							parser.tagVariable(statement.id.name, nestedWebpackRequireTag, {
+								name: newName,
+								declaration: {
+									updated: false,
+									loc: statement.id.loc,
+									range: statement.id.range
+								}
+							});
+							return true;
+						}
+					});
+					parser.hooks.pattern
+						.for("__webpack_require__")
+						.tap("CompatibilityPlugin", pattern => {
+							const newName = `__nested_webpack_require_${pattern.range[0]}__`;
+							parser.tagVariable(pattern.name, nestedWebpackRequireTag, {
+								name: newName,
+								declaration: {
+									updated: false,
+									loc: pattern.loc,
+									range: pattern.range
+								}
+							});
+							return true;
+						});
+					parser.hooks.expression
+						.for(nestedWebpackRequireTag)
+						.tap("CompatibilityPlugin", expr => {
+							const { name, declaration } = parser.currentTagData;
+							if (!declaration.updated) {
+								const dep = new ConstDependency(name, declaration.range);
+								dep.loc = declaration.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								declaration.updated = true;
+							}
+							const dep = new ConstDependency(name, expr.range);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					// Handle hashbang
+					parser.hooks.program.tap(
+						"CompatibilityPlugin",
+						(program, comments) => {
+							if (comments.length === 0) return;
+							const c = comments[0];
+							if (c.type === "Line" && c.range[0] === 0) {
+								if (parser.state.source.slice(0, 2).toString() !== "#!") return;
+								// this is a hashbang comment
+								const dep = new ConstDependency("//", 0);
+								dep.loc = c.loc;
+								parser.state.module.addPresentationalDependency(dep);
 							}
 						}
-						return Promise.all(promises);
-					})
-					.then(x => {})
+					);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("CompatibilityPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("CompatibilityPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("CompatibilityPlugin", handler);
+			}
 		);
 	}
 }
-
-module.exports = DynamicEntryPlugin;
+module.exports = CompatibilityPlugin;
 
 
 /***/ }),
 
-/***/ 9909:
+/***/ 85720:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -33539,7072 +29495,6688 @@ module.exports = DynamicEntryPlugin;
 
 
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-
-class EntryOptionPlugin {
-	/**
-	 * @param {Compiler} compiler the compiler instance one is tapping into
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
-			EntryOptionPlugin.applyEntryOption(compiler, context, entry);
-			return true;
-		});
-	}
-
-	/**
-	 * @param {Compiler} compiler the compiler
-	 * @param {string} context context directory
-	 * @param {Entry} entry request
-	 * @returns {void}
-	 */
-	static applyEntryOption(compiler, context, entry) {
-		if (typeof entry === "function") {
-			const DynamicEntryPlugin = __webpack_require__(96475);
-			new DynamicEntryPlugin(context, entry).apply(compiler);
-		} else {
-			const EntryPlugin = __webpack_require__(96953);
-			for (const name of Object.keys(entry)) {
-				const desc = entry[name];
-				const options = EntryOptionPlugin.entryDescriptionToOptions(
-					compiler,
-					name,
-					desc
-				);
-				for (const entry of desc.import) {
-					new EntryPlugin(context, entry, options).apply(compiler);
-				}
-			}
-		}
-	}
-
-	/**
-	 * @param {Compiler} compiler the compiler
-	 * @param {string} name entry name
-	 * @param {EntryDescription} desc entry description
-	 * @returns {EntryOptions} options for the entry
-	 */
-	static entryDescriptionToOptions(compiler, name, desc) {
-		/** @type {EntryOptions} */
-		const options = {
-			name,
-			filename: desc.filename,
-			runtime: desc.runtime,
-			layer: desc.layer,
-			dependOn: desc.dependOn,
-			publicPath: desc.publicPath,
-			chunkLoading: desc.chunkLoading,
-			asyncChunks: desc.asyncChunks,
-			wasmLoading: desc.wasmLoading,
-			library: desc.library
-		};
-		if (desc.layer !== undefined && !compiler.options.experiments.layers) {
-			throw new Error(
-				"'entryOptions.layer' is only allowed when 'experiments.layers' is enabled"
-			);
-		}
-		if (desc.chunkLoading) {
-			const EnableChunkLoadingPlugin = __webpack_require__(61291);
-			EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading);
-		}
-		if (desc.wasmLoading) {
-			const EnableWasmLoadingPlugin = __webpack_require__(78613);
-			EnableWasmLoadingPlugin.checkEnabled(compiler, desc.wasmLoading);
-		}
-		if (desc.library) {
-			const EnableLibraryPlugin = __webpack_require__(91452);
-			EnableLibraryPlugin.checkEnabled(compiler, desc.library.type);
-		}
-		return options;
-	}
-}
-
-module.exports = EntryOptionPlugin;
+const asyncLib = __webpack_require__(78175);
+const {
+	HookMap,
+	SyncHook,
+	SyncBailHook,
+	SyncWaterfallHook,
+	AsyncSeriesHook,
+	AsyncSeriesBailHook,
+	AsyncParallelHook
+} = __webpack_require__(41242);
+const util = __webpack_require__(73837);
+const { CachedSource } = __webpack_require__(51255);
+const { MultiItemCache } = __webpack_require__(55392);
+const Chunk = __webpack_require__(39385);
+const ChunkGraph = __webpack_require__(64971);
+const ChunkGroup = __webpack_require__(15626);
+const ChunkRenderError = __webpack_require__(918);
+const ChunkTemplate = __webpack_require__(46341);
+const CodeGenerationError = __webpack_require__(2102);
+const CodeGenerationResults = __webpack_require__(71426);
+const Dependency = __webpack_require__(54912);
+const DependencyTemplates = __webpack_require__(9163);
+const Entrypoint = __webpack_require__(13795);
+const ErrorHelpers = __webpack_require__(59985);
+const FileSystemInfo = __webpack_require__(79453);
+const {
+	connectChunkGroupAndChunk,
+	connectChunkGroupParentAndChild
+} = __webpack_require__(37234);
+const {
+	makeWebpackError,
+	tryRunOrWebpackError
+} = __webpack_require__(11351);
+const MainTemplate = __webpack_require__(12856);
+const Module = __webpack_require__(73208);
+const ModuleDependencyError = __webpack_require__(67409);
+const ModuleDependencyWarning = __webpack_require__(29656);
+const ModuleGraph = __webpack_require__(99988);
+const ModuleNotFoundError = __webpack_require__(32882);
+const ModuleProfile = __webpack_require__(36418);
+const ModuleRestoreError = __webpack_require__(94560);
+const ModuleStoreError = __webpack_require__(59001);
+const ModuleTemplate = __webpack_require__(62677);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeTemplate = __webpack_require__(18777);
+const Stats = __webpack_require__(31743);
+const WebpackError = __webpack_require__(53799);
+const buildChunkGraph = __webpack_require__(79233);
+const BuildCycleError = __webpack_require__(22273);
+const { Logger, LogType } = __webpack_require__(32597);
+const StatsFactory = __webpack_require__(92629);
+const StatsPrinter = __webpack_require__(30198);
+const { equals: arrayEquals } = __webpack_require__(84953);
+const AsyncQueue = __webpack_require__(12260);
+const LazySet = __webpack_require__(38938);
+const { provide } = __webpack_require__(82482);
+const WeakTupleMap = __webpack_require__(28745);
+const { cachedCleverMerge } = __webpack_require__(60839);
+const {
+	compareLocations,
+	concatComparators,
+	compareSelect,
+	compareIds,
+	compareStringsNumeric,
+	compareModulesByIdentifier
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const {
+	arrayToSetDeprecation,
+	soonFrozenObjectDeprecation,
+	createFakeHook
+} = __webpack_require__(64518);
+const processAsyncTree = __webpack_require__(42791);
+const { getRuntimeKey } = __webpack_require__(17156);
+const { isSourceEqual } = __webpack_require__(41245);
 
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Cache")} Cache */
+/** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./util/Hash")} Hash */
+/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/***/ }),
+/**
+ * @callback Callback
+ * @param {(WebpackError | null)=} err
+ * @returns {void}
+ */
 
-/***/ 96953:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @callback ModuleCallback
+ * @param {(WebpackError | null)=} err
+ * @param {Module=} result
+ * @returns {void}
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @callback ModuleFactoryResultCallback
+ * @param {(WebpackError | null)=} err
+ * @param {ModuleFactoryResult=} result
+ * @returns {void}
+ */
 
+/**
+ * @callback ModuleOrFactoryResultCallback
+ * @param {(WebpackError | null)=} err
+ * @param {Module | ModuleFactoryResult=} result
+ * @returns {void}
+ */
 
+/**
+ * @callback ExecuteModuleCallback
+ * @param {(WebpackError | null)=} err
+ * @param {ExecuteModuleResult=} result
+ * @returns {void}
+ */
 
-const EntryDependency = __webpack_require__(3979);
+/**
+ * @callback DepBlockVarDependenciesCallback
+ * @param {Dependency} dependency
+ * @returns {any}
+ */
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {new (...args: any[]) => Dependency} DepConstructor */
+/** @typedef {Record<string, Source>} CompilationAssets */
 
-class EntryPlugin {
-	/**
-	 * An entry plugin which will handle
-	 * creation of the EntryDependency
-	 *
-	 * @param {string} context context path
-	 * @param {string} entry entry path
-	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
-	 */
-	constructor(context, entry, options) {
-		this.context = context;
-		this.entry = entry;
-		this.options = options || "";
-	}
+/**
+ * @typedef {Object} AvailableModulesChunkGroupMapping
+ * @property {ChunkGroup} chunkGroup
+ * @property {Set<Module>} availableModules
+ * @property {boolean} needCopy
+ */
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EntryPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					EntryDependency,
-					normalModuleFactory
-				);
-			}
-		);
+/**
+ * @typedef {Object} DependenciesBlockLike
+ * @property {Dependency[]} dependencies
+ * @property {AsyncDependenciesBlock[]} blocks
+ */
 
-		const { entry, options, context } = this;
-		const dep = EntryPlugin.createDependency(entry, options);
+/**
+ * @typedef {Object} ChunkPathData
+ * @property {string|number} id
+ * @property {string=} name
+ * @property {string} hash
+ * @property {function(number): string=} hashWithLength
+ * @property {(Record<string, string>)=} contentHash
+ * @property {(Record<string, (length: number) => string>)=} contentHashWithLength
+ */
 
-		compiler.hooks.make.tapAsync("EntryPlugin", (compilation, callback) => {
-			compilation.addEntry(context, dep, options, err => {
-				callback(err);
-			});
-		});
-	}
+/**
+ * @typedef {Object} ChunkHashContext
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ */
 
-	/**
-	 * @param {string} entry entry request
-	 * @param {EntryOptions | string} options entry options (passing string is deprecated)
-	 * @returns {EntryDependency} the dependency
-	 */
-	static createDependency(entry, options) {
-		const dep = new EntryDependency(entry);
-		// TODO webpack 6 remove string option
-		dep.loc = { name: typeof options === "object" ? options.name : options };
-		return dep;
-	}
-}
+/**
+ * @typedef {Object} RuntimeRequirementsContext
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults the code generation results
+ */
 
-module.exports = EntryPlugin;
+/**
+ * @typedef {Object} ExecuteModuleOptions
+ * @property {EntryOptions=} entryOptions
+ */
 
+/**
+ * @typedef {Object} ExecuteModuleResult
+ * @property {any} exports
+ * @property {boolean} cacheable
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} buildDependencies
+ */
 
-/***/ }),
+/**
+ * @typedef {Object} ExecuteModuleArgument
+ * @property {Module} module
+ * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
+ * @property {any} preparedInfo
+ * @property {CodeGenerationResult} codeGenerationResult
+ */
 
-/***/ 13795:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @typedef {Object} ExecuteModuleContext
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {Chunk} chunk
+ * @property {ChunkGraph} chunkGraph
+ * @property {function(string): any=} __webpack_require__
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @typedef {Object} EntryData
+ * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
+ * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated
+ * @property {EntryOptions} options options of the entrypoint
+ */
 
+/**
+ * @typedef {Object} LogEntry
+ * @property {string} type
+ * @property {any[]} args
+ * @property {number} time
+ * @property {string[]=} trace
+ */
 
+/**
+ * @typedef {Object} KnownAssetInfo
+ * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
+ * @property {boolean=} minimized whether the asset is minimized
+ * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset
+ * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
+ * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
+ * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
+ * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
+ * @property {number=} size size in bytes, only set after asset has been emitted
+ * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
+ * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
+ * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
+ * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
+ */
 
-const ChunkGroup = __webpack_require__(15626);
+/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("./Chunk")} Chunk */
+/**
+ * @typedef {Object} Asset
+ * @property {string} name the filename of the asset
+ * @property {Source} source source of the asset
+ * @property {AssetInfo} info info about the asset
+ */
 
-/** @typedef {{ name?: string } & Omit<EntryDescription, "import">} EntryOptions */
+/**
+ * @typedef {Object} ModulePathData
+ * @property {string|number} id
+ * @property {string} hash
+ * @property {function(number): string=} hashWithLength
+ */
 
 /**
- * Entrypoint serves as an encapsulation primitive for chunks that are
- * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
- * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
- * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ * @typedef {Object} PathData
+ * @property {ChunkGraph=} chunkGraph
+ * @property {string=} hash
+ * @property {function(number): string=} hashWithLength
+ * @property {(Chunk|ChunkPathData)=} chunk
+ * @property {(Module|ModulePathData)=} module
+ * @property {RuntimeSpec=} runtime
+ * @property {string=} filename
+ * @property {string=} basename
+ * @property {string=} query
+ * @property {string=} contentHashType
+ * @property {string=} contentHash
+ * @property {function(number): string=} contentHashWithLength
+ * @property {boolean=} noChunkHash
+ * @property {string=} url
  */
-class Entrypoint extends ChunkGroup {
-	/**
-	 * Creates an instance of Entrypoint.
-	 * @param {EntryOptions | string} entryOptions the options for the entrypoint (or name)
-	 * @param {boolean=} initial false, when the entrypoint is not initial loaded
-	 */
-	constructor(entryOptions, initial = true) {
-		if (typeof entryOptions === "string") {
-			entryOptions = { name: entryOptions };
-		}
-		super({
-			name: entryOptions.name
-		});
-		this.options = entryOptions;
-		/** @type {Chunk=} */
-		this._runtimeChunk = undefined;
-		/** @type {Chunk=} */
-		this._entrypointChunk = undefined;
-		/** @type {boolean} */
-		this._initial = initial;
-	}
 
-	/**
-	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
-	 */
-	isInitial() {
-		return this._initial;
-	}
+/**
+ * @typedef {Object} KnownNormalizedStatsOptions
+ * @property {string} context
+ * @property {RequestShortener} requestShortener
+ * @property {string} chunksSort
+ * @property {string} modulesSort
+ * @property {string} chunkModulesSort
+ * @property {string} nestedModulesSort
+ * @property {string} assetsSort
+ * @property {boolean} ids
+ * @property {boolean} cachedAssets
+ * @property {boolean} groupAssetsByEmitStatus
+ * @property {boolean} groupAssetsByPath
+ * @property {boolean} groupAssetsByExtension
+ * @property {number} assetsSpace
+ * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
+ * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
+ * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
+ * @property {boolean} cachedModules
+ * @property {boolean} orphanModules
+ * @property {boolean} dependentModules
+ * @property {boolean} runtimeModules
+ * @property {boolean} groupModulesByCacheStatus
+ * @property {boolean} groupModulesByLayer
+ * @property {boolean} groupModulesByAttributes
+ * @property {boolean} groupModulesByPath
+ * @property {boolean} groupModulesByExtension
+ * @property {boolean} groupModulesByType
+ * @property {boolean | "auto"} entrypoints
+ * @property {boolean} chunkGroups
+ * @property {boolean} chunkGroupAuxiliary
+ * @property {boolean} chunkGroupChildren
+ * @property {number} chunkGroupMaxAssets
+ * @property {number} modulesSpace
+ * @property {number} chunkModulesSpace
+ * @property {number} nestedModulesSpace
+ * @property {false|"none"|"error"|"warn"|"info"|"log"|"verbose"} logging
+ * @property {((value: string) => boolean)[]} loggingDebug
+ * @property {boolean} loggingTrace
+ * @property {any} _env
+ */
 
-	/**
-	 * Sets the runtimeChunk for an entrypoint.
-	 * @param {Chunk} chunk the chunk being set as the runtime chunk.
-	 * @returns {void}
-	 */
-	setRuntimeChunk(chunk) {
-		this._runtimeChunk = chunk;
-	}
+/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
 
-	/**
-	 * Fetches the chunk reference containing the webpack bootstrap code
-	 * @returns {Chunk | null} returns the runtime chunk or null if there is none
-	 */
-	getRuntimeChunk() {
-		if (this._runtimeChunk) return this._runtimeChunk;
-		for (const parent of this.parentsIterable) {
-			if (parent instanceof Entrypoint) return parent.getRuntimeChunk();
-		}
-		return null;
-	}
+/**
+ * @typedef {Object} KnownCreateStatsOptionsContext
+ * @property {boolean=} forToString
+ */
 
-	/**
-	 * Sets the chunk with the entrypoint modules for an entrypoint.
-	 * @param {Chunk} chunk the chunk being set as the entrypoint chunk.
-	 * @returns {void}
-	 */
-	setEntrypointChunk(chunk) {
-		this._entrypointChunk = chunk;
-	}
+/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
 
-	/**
-	 * Returns the chunk which contains the entrypoint modules
-	 * (or at least the execution of them)
-	 * @returns {Chunk} chunk
-	 */
-	getEntrypointChunk() {
-		return this._entrypointChunk;
-	}
+/** @type {AssetInfo} */
+const EMPTY_ASSET_INFO = Object.freeze({});
 
-	/**
-	 * @param {Chunk} oldChunk chunk to be replaced
-	 * @param {Chunk} newChunk New chunk that will be replaced with
-	 * @returns {boolean} returns true if the replacement was successful
-	 */
-	replaceChunk(oldChunk, newChunk) {
-		if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk;
-		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
-		return super.replaceChunk(oldChunk, newChunk);
-	}
-}
-
-module.exports = Entrypoint;
+const esmDependencyCategory = "esm";
+// TODO webpack 6: remove
+const deprecatedNormalModuleLoaderHook = util.deprecate(
+	compilation => {
+		return (__webpack_require__(39).getCompilationHooks)(compilation).loader;
+	},
+	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
+	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
+);
 
+// TODO webpack 6: remove
+const defineRemovedModuleTemplates = moduleTemplates => {
+	Object.defineProperties(moduleTemplates, {
+		asset: {
+			enumerable: false,
+			configurable: false,
+			get: () => {
+				throw new WebpackError(
+					"Compilation.moduleTemplates.asset has been removed"
+				);
+			}
+		},
+		webassembly: {
+			enumerable: false,
+			configurable: false,
+			get: () => {
+				throw new WebpackError(
+					"Compilation.moduleTemplates.webassembly has been removed"
+				);
+			}
+		}
+	});
+	moduleTemplates = undefined;
+};
 
-/***/ }),
+const byId = compareSelect(
+	/**
+	 * @param {Chunk} c chunk
+	 * @returns {number | string} id
+	 */ c => c.id,
+	compareIds
+);
 
-/***/ 22070:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const byNameOrHash = concatComparators(
+	compareSelect(
+		/**
+		 * @param {Compilation} c compilation
+		 * @returns {string} name
+		 */
+		c => c.name,
+		compareIds
+	),
+	compareSelect(
+		/**
+		 * @param {Compilation} c compilation
+		 * @returns {string} hash
+		 */ c => c.fullHash,
+		compareIds
+	)
+);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Authors Simen Brekken @simenbrekken, Einar Löve @einarlove
-*/
+const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
 
+const byModule = compareSelect(
+	err => (err.module && err.module.identifier()) || "",
+	compareStringsNumeric
+);
 
+const byLocation = compareSelect(err => err.loc, compareLocations);
 
-const DefinePlugin = __webpack_require__(79065);
-const WebpackError = __webpack_require__(53799);
+const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DefinePlugin").CodeValue} CodeValue */
+/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
+const unsafeCacheDependencies = new WeakMap();
 
-class EnvironmentPlugin {
-	constructor(...keys) {
-		if (keys.length === 1 && Array.isArray(keys[0])) {
-			this.keys = keys[0];
-			this.defaultValues = {};
-		} else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
-			this.keys = Object.keys(keys[0]);
-			this.defaultValues = keys[0];
-		} else {
-			this.keys = keys;
-			this.defaultValues = {};
-		}
-	}
+/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
+const unsafeCacheData = new WeakMap();
 
+class Compilation {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * Creates an instance of Compilation.
+	 * @param {Compiler} compiler the compiler which created the compilation
+	 * @param {CompilationParams} params the compilation parameters
 	 */
-	apply(compiler) {
-		/** @type {Record<string, CodeValue>} */
-		const definitions = {};
-		for (const key of this.keys) {
-			const value =
-				process.env[key] !== undefined
-					? process.env[key]
-					: this.defaultValues[key];
+	constructor(compiler, params) {
+		this._backCompat = compiler._backCompat;
 
-			if (value === undefined) {
-				compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
-					const error = new WebpackError(
-						`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
-							"You can pass an object with default values to suppress this warning.\n" +
-							"See https://webpack.js.org/plugins/environment-plugin for example."
-					);
+		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
+		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
+		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
+		const processAssetsHook = new AsyncSeriesHook(["assets"]);
 
-					error.name = "EnvVariableNotDefinedError";
-					compilation.errors.push(error);
-				});
+		let savedAssets = new Set();
+		const popNewAssets = assets => {
+			let newAssets = undefined;
+			for (const file of Object.keys(assets)) {
+				if (savedAssets.has(file)) continue;
+				if (newAssets === undefined) {
+					newAssets = Object.create(null);
+				}
+				newAssets[file] = assets[file];
+				savedAssets.add(file);
 			}
+			return newAssets;
+		};
+		processAssetsHook.intercept({
+			name: "Compilation",
+			call: () => {
+				savedAssets = new Set(Object.keys(this.assets));
+			},
+			register: tap => {
+				const { type, name } = tap;
+				const { fn, additionalAssets, ...remainingTap } = tap;
+				const additionalAssetsFn =
+					additionalAssets === true ? fn : additionalAssets;
+				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
+				switch (type) {
+					case "sync":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tap(name, assets => {
+								if (processedAssets.has(this.assets))
+									additionalAssetsFn(assets);
+							});
+						}
+						return {
+							...remainingTap,
+							type: "async",
+							fn: (assets, callback) => {
+								try {
+									fn(assets);
+								} catch (e) {
+									return callback(e);
+								}
+								if (processedAssets !== undefined)
+									processedAssets.add(this.assets);
+								const newAssets = popNewAssets(assets);
+								if (newAssets !== undefined) {
+									this.hooks.processAdditionalAssets.callAsync(
+										newAssets,
+										callback
+									);
+									return;
+								}
+								callback();
+							}
+						};
+					case "async":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tapAsync(
+								name,
+								(assets, callback) => {
+									if (processedAssets.has(this.assets))
+										return additionalAssetsFn(assets, callback);
+									callback();
+								}
+							);
+						}
+						return {
+							...remainingTap,
+							fn: (assets, callback) => {
+								fn(assets, err => {
+									if (err) return callback(err);
+									if (processedAssets !== undefined)
+										processedAssets.add(this.assets);
+									const newAssets = popNewAssets(assets);
+									if (newAssets !== undefined) {
+										this.hooks.processAdditionalAssets.callAsync(
+											newAssets,
+											callback
+										);
+										return;
+									}
+									callback();
+								});
+							}
+						};
+					case "promise":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tapPromise(name, assets => {
+								if (processedAssets.has(this.assets))
+									return additionalAssetsFn(assets);
+								return Promise.resolve();
+							});
+						}
+						return {
+							...remainingTap,
+							fn: assets => {
+								const p = fn(assets);
+								if (!p || !p.then) return p;
+								return p.then(() => {
+									if (processedAssets !== undefined)
+										processedAssets.add(this.assets);
+									const newAssets = popNewAssets(assets);
+									if (newAssets !== undefined) {
+										return this.hooks.processAdditionalAssets.promise(
+											newAssets
+										);
+									}
+								});
+							}
+						};
+				}
+			}
+		});
 
-			definitions[`process.env.${key}`] =
-				value === undefined ? "undefined" : JSON.stringify(value);
-		}
-
-		new DefinePlugin(definitions).apply(compiler);
-	}
-}
+		/** @type {SyncHook<[CompilationAssets]>} */
+		const afterProcessAssetsHook = new SyncHook(["assets"]);
 
-module.exports = EnvironmentPlugin;
+		/**
+		 * @template T
+		 * @param {string} name name of the hook
+		 * @param {number} stage new stage
+		 * @param {function(): AsArray<T>} getArgs get old hook function args
+		 * @param {string=} code deprecation code (not deprecated when unset)
+		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
+		 */
+		const createProcessAssetsHook = (name, stage, getArgs, code) => {
+			if (!this._backCompat && code) return undefined;
+			const errorMessage =
+				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
+BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
+			const getOptions = options => {
+				if (typeof options === "string") options = { name: options };
+				if (options.stage) {
+					throw new Error(errorMessage("it's using the 'stage' option"));
+				}
+				return { ...options, stage: stage };
+			};
+			return createFakeHook(
+				{
+					name,
+					/** @type {AsyncSeriesHook<T>["intercept"]} */
+					intercept(interceptor) {
+						throw new Error(errorMessage("it's using 'intercept'"));
+					},
+					/** @type {AsyncSeriesHook<T>["tap"]} */
+					tap: (options, fn) => {
+						processAssetsHook.tap(getOptions(options), () => fn(...getArgs()));
+					},
+					/** @type {AsyncSeriesHook<T>["tapAsync"]} */
+					tapAsync: (options, fn) => {
+						processAssetsHook.tapAsync(
+							getOptions(options),
+							(assets, callback) =>
+								/** @type {any} */ (fn)(...getArgs(), callback)
+						);
+					},
+					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
+					tapPromise: (options, fn) => {
+						processAssetsHook.tapPromise(getOptions(options), () =>
+							fn(...getArgs())
+						);
+					}
+				},
+				`${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,
+				code
+			);
+		};
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[Module]>} */
+			buildModule: new SyncHook(["module"]),
+			/** @type {SyncHook<[Module]>} */
+			rebuildModule: new SyncHook(["module"]),
+			/** @type {SyncHook<[Module, WebpackError]>} */
+			failedModule: new SyncHook(["module", "error"]),
+			/** @type {SyncHook<[Module]>} */
+			succeedModule: new SyncHook(["module"]),
+			/** @type {SyncHook<[Module]>} */
+			stillValidModule: new SyncHook(["module"]),
 
+			/** @type {SyncHook<[Dependency, EntryOptions]>} */
+			addEntry: new SyncHook(["entry", "options"]),
+			/** @type {SyncHook<[Dependency, EntryOptions, Error]>} */
+			failedEntry: new SyncHook(["entry", "options", "error"]),
+			/** @type {SyncHook<[Dependency, EntryOptions, Module]>} */
+			succeedEntry: new SyncHook(["entry", "options", "module"]),
 
-/***/ }),
+			/** @type {SyncWaterfallHook<[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]>} */
+			dependencyReferencedExports: new SyncWaterfallHook([
+				"referencedExports",
+				"dependency",
+				"runtime"
+			]),
 
-/***/ 59985:
-/***/ (function(__unused_webpack_module, exports) {
+			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			executeModule: new SyncHook(["options", "context"]),
+			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
+			finishModules: new AsyncSeriesHook(["modules"]),
+			/** @type {AsyncSeriesHook<[Module]>} */
+			finishRebuildingModule: new AsyncSeriesHook(["module"]),
+			/** @type {SyncHook<[]>} */
+			unseal: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			seal: new SyncHook([]),
 
+			/** @type {SyncHook<[]>} */
+			beforeChunks: new SyncHook([]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			afterChunks: new SyncHook(["chunks"]),
 
+			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			optimizeDependencies: new SyncBailHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			afterOptimizeDependencies: new SyncHook(["modules"]),
 
-const loaderFlag = "LOADER_EXECUTION";
+			/** @type {SyncHook<[]>} */
+			optimize: new SyncHook([]),
+			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			optimizeModules: new SyncBailHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			afterOptimizeModules: new SyncHook(["modules"]),
 
-const webpackOptionsFlag = "WEBPACK_OPTIONS";
+			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+			optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),
+			/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+			afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),
 
-exports.cutOffByFlag = (stack, flag) => {
-	stack = stack.split("\n");
-	for (let i = 0; i < stack.length; i++) {
-		if (stack[i].includes(flag)) {
-			stack.length = i;
-		}
-	}
-	return stack.join("\n");
-};
+			/** @type {AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			optimizeTree: new AsyncSeriesHook(["chunks", "modules"]),
+			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			afterOptimizeTree: new SyncHook(["chunks", "modules"]),
 
-exports.cutOffLoaderExecution = stack =>
-	exports.cutOffByFlag(stack, loaderFlag);
+			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
+			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
+			/** @type {SyncBailHook<[], boolean>} */
+			shouldRecord: new SyncBailHook([]),
 
-exports.cutOffWebpackOptions = stack =>
-	exports.cutOffByFlag(stack, webpackOptionsFlag);
+			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+			additionalChunkRuntimeRequirements: new SyncHook([
+				"chunk",
+				"runtimeRequirements",
+				"context"
+			]),
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			runtimeRequirementInChunk: new HookMap(
+				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
+			),
+			/** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
+			additionalModuleRuntimeRequirements: new SyncHook([
+				"module",
+				"runtimeRequirements",
+				"context"
+			]),
+			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
+			runtimeRequirementInModule: new HookMap(
+				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
+			),
+			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+			additionalTreeRuntimeRequirements: new SyncHook([
+				"chunk",
+				"runtimeRequirements",
+				"context"
+			]),
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			runtimeRequirementInTree: new HookMap(
+				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
+			),
 
-exports.cutOffMultilineMessage = (stack, message) => {
-	stack = stack.split("\n");
-	message = message.split("\n");
+			/** @type {SyncHook<[RuntimeModule, Chunk]>} */
+			runtimeModule: new SyncHook(["module", "chunk"]),
 
-	const result = [];
+			/** @type {SyncHook<[Iterable<Module>, any]>} */
+			reviveModules: new SyncHook(["modules", "records"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			beforeModuleIds: new SyncHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			moduleIds: new SyncHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			optimizeModuleIds: new SyncHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			afterOptimizeModuleIds: new SyncHook(["modules"]),
 
-	stack.forEach((line, idx) => {
-		if (!line.includes(message[idx])) result.push(line);
-	});
+			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
+			reviveChunks: new SyncHook(["chunks", "records"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			beforeChunkIds: new SyncHook(["chunks"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			chunkIds: new SyncHook(["chunks"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			optimizeChunkIds: new SyncHook(["chunks"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			afterOptimizeChunkIds: new SyncHook(["chunks"]),
 
-	return result.join("\n");
-};
+			/** @type {SyncHook<[Iterable<Module>, any]>} */
+			recordModules: new SyncHook(["modules", "records"]),
+			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
+			recordChunks: new SyncHook(["chunks", "records"]),
 
-exports.cutOffMessage = (stack, message) => {
-	const nextLine = stack.indexOf("\n");
-	if (nextLine === -1) {
-		return stack === message ? "" : stack;
-	} else {
-		const firstLine = stack.substr(0, nextLine);
-		return firstLine === message ? stack.substr(nextLine + 1) : stack;
-	}
-};
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			optimizeCodeGeneration: new SyncHook(["modules"]),
 
-exports.cleanUp = (stack, message) => {
-	stack = exports.cutOffLoaderExecution(stack);
-	stack = exports.cutOffMessage(stack, message);
-	return stack;
-};
+			/** @type {SyncHook<[]>} */
+			beforeModuleHash: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterModuleHash: new SyncHook([]),
 
-exports.cleanUpWebpackOptions = (stack, message) => {
-	stack = exports.cutOffWebpackOptions(stack);
-	stack = exports.cutOffMultilineMessage(stack, message);
-	return stack;
-};
+			/** @type {SyncHook<[]>} */
+			beforeCodeGeneration: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterCodeGeneration: new SyncHook([]),
 
+			/** @type {SyncHook<[]>} */
+			beforeRuntimeRequirements: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterRuntimeRequirements: new SyncHook([]),
 
-/***/ }),
+			/** @type {SyncHook<[]>} */
+			beforeHash: new SyncHook([]),
+			/** @type {SyncHook<[Chunk]>} */
+			contentHash: new SyncHook(["chunk"]),
+			/** @type {SyncHook<[]>} */
+			afterHash: new SyncHook([]),
+			/** @type {SyncHook<[any]>} */
+			recordHash: new SyncHook(["records"]),
+			/** @type {SyncHook<[Compilation, any]>} */
+			record: new SyncHook(["compilation", "records"]),
 
-/***/ 65218:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			/** @type {SyncHook<[]>} */
+			beforeModuleAssets: new SyncHook([]),
+			/** @type {SyncBailHook<[], boolean>} */
+			shouldGenerateChunkAssets: new SyncBailHook([]),
+			/** @type {SyncHook<[]>} */
+			beforeChunkAssets: new SyncHook([]),
+			// TODO webpack 6 remove
+			/** @deprecated */
+			additionalChunkAssets: createProcessAssetsHook(
+				"additionalChunkAssets",
+				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+				() => [this.chunks],
+				"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
+			),
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			// TODO webpack 6 deprecate
+			/** @deprecated */
+			additionalAssets: createProcessAssetsHook(
+				"additionalAssets",
+				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+				() => []
+			),
+			// TODO webpack 6 remove
+			/** @deprecated */
+			optimizeChunkAssets: createProcessAssetsHook(
+				"optimizeChunkAssets",
+				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
+				() => [this.chunks],
+				"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
+			),
+			// TODO webpack 6 remove
+			/** @deprecated */
+			afterOptimizeChunkAssets: createProcessAssetsHook(
+				"afterOptimizeChunkAssets",
+				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
+				() => [this.chunks],
+				"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
+			),
+			// TODO webpack 6 deprecate
+			/** @deprecated */
+			optimizeAssets: processAssetsHook,
+			// TODO webpack 6 deprecate
+			/** @deprecated */
+			afterOptimizeAssets: afterProcessAssetsHook,
 
+			processAssets: processAssetsHook,
+			afterProcessAssets: afterProcessAssetsHook,
+			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
+			/** @type {SyncBailHook<[], boolean>} */
+			needAdditionalSeal: new SyncBailHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			afterSeal: new AsyncSeriesHook([]),
 
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const ExternalModule = __webpack_require__(73071);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const RuntimeGlobals = __webpack_require__(16475);
-const JavascriptModulesPlugin = __webpack_require__(89464);
+			/** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */
+			renderManifest: new SyncWaterfallHook(["result", "options"]),
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Compiler")} Compiler */
+			/** @type {SyncHook<[Hash]>} */
+			fullHash: new SyncHook(["hash"]),
+			/** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */
+			chunkHash: new SyncHook(["chunk", "chunkHash", "ChunkHashContext"]),
 
-/** @type {WeakMap<Source, Source>} */
-const cache = new WeakMap();
+			/** @type {SyncHook<[Module, string]>} */
+			moduleAsset: new SyncHook(["module", "filename"]),
+			/** @type {SyncHook<[Chunk, string]>} */
+			chunkAsset: new SyncHook(["chunk", "filename"]),
 
-const devtoolWarning = new RawSource(`/*
- * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
- * This devtool is neither made for production nor for readable output files.
- * It uses "eval()" calls to create a separate source file in the browser devtools.
- * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
- * or disable the default devtool with "devtool: false".
- * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
- */
-`);
+			/** @type {SyncWaterfallHook<[string, object, AssetInfo]>} */
+			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
 
-class EvalDevToolModulePlugin {
-	constructor(options) {
-		this.namespace = options.namespace || "";
-		this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]";
-		this.moduleFilenameTemplate =
-			options.moduleFilenameTemplate ||
-			"webpack://[namespace]/[resourcePath]?[loaders]";
-	}
+			/** @type {SyncBailHook<[], boolean>} */
+			needAdditionalPass: new SyncBailHook([]),
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("EvalDevToolModulePlugin", compilation => {
-			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-			hooks.renderModuleContent.tap(
-				"EvalDevToolModulePlugin",
-				(source, module, { runtimeTemplate, chunkGraph }) => {
-					const cacheEntry = cache.get(source);
-					if (cacheEntry !== undefined) return cacheEntry;
-					if (module instanceof ExternalModule) {
-						cache.set(source, source);
-						return source;
-					}
-					const content = source.source();
-					const str = ModuleFilenameHelpers.createFilename(
-						module,
-						{
-							moduleFilenameTemplate: this.moduleFilenameTemplate,
-							namespace: this.namespace
-						},
-						{
-							requestShortener: runtimeTemplate.requestShortener,
-							chunkGraph,
-							hashFunction: compilation.outputOptions.hashFunction
-						}
-					);
-					const footer =
-						"\n" +
-						this.sourceUrlComment.replace(
-							/\[url\]/g,
-							encodeURI(str)
-								.replace(/%2F/g, "/")
-								.replace(/%20/g, "_")
-								.replace(/%5E/g, "^")
-								.replace(/%5C/g, "\\")
-								.replace(/^\//, "")
-						);
-					const result = new RawSource(
-						`eval(${
-							compilation.outputOptions.trustedTypes
-								? `${RuntimeGlobals.createScript}(${JSON.stringify(
-										content + footer
-								  )})`
-								: JSON.stringify(content + footer)
-						});`
-					);
-					cache.set(source, result);
-					return result;
-				}
-			);
-			hooks.inlineInRuntimeBailout.tap(
-				"EvalDevToolModulePlugin",
-				() => "the eval devtool is used."
-			);
-			hooks.render.tap(
-				"EvalDevToolModulePlugin",
-				source => new ConcatSource(devtoolWarning, source)
-			);
-			hooks.chunkHash.tap("EvalDevToolModulePlugin", (chunk, hash) => {
-				hash.update("EvalDevToolModulePlugin");
-				hash.update("2");
-			});
-			if (compilation.outputOptions.trustedTypes) {
-				compilation.hooks.additionalModuleRuntimeRequirements.tap(
-					"EvalDevToolModulePlugin",
-					(module, set, context) => {
-						set.add(RuntimeGlobals.createScript);
-					}
-				);
+			/** @type {SyncHook<[Compiler, string, number]>} */
+			childCompiler: new SyncHook([
+				"childCompiler",
+				"compilerName",
+				"compilerIndex"
+			]),
+
+			/** @type {SyncBailHook<[string, LogEntry], true>} */
+			log: new SyncBailHook(["origin", "logEntry"]),
+
+			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			processWarnings: new SyncWaterfallHook(["warnings"]),
+			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			processErrors: new SyncWaterfallHook(["errors"]),
+
+			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
+			statsPreset: new HookMap(() => new SyncHook(["options", "context"])),
+			/** @type {SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>} */
+			statsNormalize: new SyncHook(["options", "context"]),
+			/** @type {SyncHook<[StatsFactory, NormalizedStatsOptions]>} */
+			statsFactory: new SyncHook(["statsFactory", "options"]),
+			/** @type {SyncHook<[StatsPrinter, NormalizedStatsOptions]>} */
+			statsPrinter: new SyncHook(["statsPrinter", "options"]),
+
+			get normalModuleLoader() {
+				return getNormalModuleLoader();
 			}
 		});
-	}
-}
-
-module.exports = EvalDevToolModulePlugin;
+		/** @type {string=} */
+		this.name = undefined;
+		this.startTime = undefined;
+		this.endTime = undefined;
+		/** @type {Compiler} */
+		this.compiler = compiler;
+		this.resolverFactory = compiler.resolverFactory;
+		this.inputFileSystem = compiler.inputFileSystem;
+		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
+			managedPaths: compiler.managedPaths,
+			immutablePaths: compiler.immutablePaths,
+			logger: this.getLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
+		});
+		if (compiler.fileTimestamps) {
+			this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
+		}
+		if (compiler.contextTimestamps) {
+			this.fileSystemInfo.addContextTimestamps(
+				compiler.contextTimestamps,
+				true
+			);
+		}
+		/** @type {Map<string, string | Set<string>>} */
+		this.valueCacheVersions = new Map();
+		this.requestShortener = compiler.requestShortener;
+		this.compilerPath = compiler.compilerPath;
 
+		this.logger = this.getLogger("webpack.Compilation");
 
-/***/ }),
+		const options = compiler.options;
+		this.options = options;
+		this.outputOptions = options && options.output;
+		/** @type {boolean} */
+		this.bail = (options && options.bail) || false;
+		/** @type {boolean} */
+		this.profile = (options && options.profile) || false;
 
-/***/ 14790:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		this.params = params;
+		this.mainTemplate = new MainTemplate(this.outputOptions, this);
+		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
+		this.runtimeTemplate = new RuntimeTemplate(
+			this,
+			this.outputOptions,
+			this.requestShortener
+		);
+		/** @type {{javascript: ModuleTemplate}} */
+		this.moduleTemplates = {
+			javascript: new ModuleTemplate(this.runtimeTemplate, this)
+		};
+		defineRemovedModuleTemplates(this.moduleTemplates);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches = undefined;
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches2 = undefined;
+		this.moduleGraph = new ModuleGraph();
+		/** @type {ChunkGraph} */
+		this.chunkGraph = undefined;
+		/** @type {CodeGenerationResults} */
+		this.codeGenerationResults = undefined;
 
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.processDependenciesQueue = new AsyncQueue({
+			name: "processDependencies",
+			parallelism: options.parallelism || 100,
+			processor: this._processModuleDependencies.bind(this)
+		});
+		/** @type {AsyncQueue<Module, string, Module>} */
+		this.addModuleQueue = new AsyncQueue({
+			name: "addModule",
+			parent: this.processDependenciesQueue,
+			getKey: module => module.identifier(),
+			processor: this._addModule.bind(this)
+		});
+		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
+		this.factorizeQueue = new AsyncQueue({
+			name: "factorize",
+			parent: this.addModuleQueue,
+			processor: this._factorizeModule.bind(this)
+		});
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.buildQueue = new AsyncQueue({
+			name: "build",
+			parent: this.factorizeQueue,
+			processor: this._buildModule.bind(this)
+		});
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.rebuildQueue = new AsyncQueue({
+			name: "rebuild",
+			parallelism: options.parallelism || 100,
+			processor: this._rebuildModule.bind(this)
+		});
 
+		/**
+		 * Modules in value are building during the build of Module in key.
+		 * Means value blocking key from finishing.
+		 * Needed to detect build cycles.
+		 * @type {WeakMap<Module, Set<Module>>}
+		 */
+		this.creatingModuleDuringBuild = new WeakMap();
 
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const NormalModule = __webpack_require__(39);
-const RuntimeGlobals = __webpack_require__(16475);
-const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const ConcatenatedModule = __webpack_require__(97198);
-const { makePathsAbsolute } = __webpack_require__(82186);
+		/** @type {Map<string, EntryData>} */
+		this.entries = new Map();
+		/** @type {EntryData} */
+		this.globalEntry = {
+			dependencies: [],
+			includeDependencies: [],
+			options: {
+				name: undefined
+			}
+		};
+		/** @type {Map<string, Entrypoint>} */
+		this.entrypoints = new Map();
+		/** @type {Entrypoint[]} */
+		this.asyncEntrypoints = [];
+		/** @type {Set<Chunk>} */
+		this.chunks = new Set();
+		/** @type {ChunkGroup[]} */
+		this.chunkGroups = [];
+		/** @type {Map<string, ChunkGroup>} */
+		this.namedChunkGroups = new Map();
+		/** @type {Map<string, Chunk>} */
+		this.namedChunks = new Map();
+		/** @type {Set<Module>} */
+		this.modules = new Set();
+		if (this._backCompat) {
+			arrayToSetDeprecation(this.chunks, "Compilation.chunks");
+			arrayToSetDeprecation(this.modules, "Compilation.modules");
+		}
+		/** @private @type {Map<string, Module>} */
+		this._modules = new Map();
+		this.records = null;
+		/** @type {string[]} */
+		this.additionalChunkAssets = [];
+		/** @type {CompilationAssets} */
+		this.assets = {};
+		/** @type {Map<string, AssetInfo>} */
+		this.assetsInfo = new Map();
+		/** @type {Map<string, Map<string, Set<string>>>} */
+		this._assetsRelatedIn = new Map();
+		/** @type {WebpackError[]} */
+		this.errors = [];
+		/** @type {WebpackError[]} */
+		this.warnings = [];
+		/** @type {Compilation[]} */
+		this.children = [];
+		/** @type {Map<string, LogEntry[]>} */
+		this.logging = new Map();
+		/** @type {Map<DepConstructor, ModuleFactory>} */
+		this.dependencyFactories = new Map();
+		/** @type {DependencyTemplates} */
+		this.dependencyTemplates = new DependencyTemplates(
+			this.outputOptions.hashFunction
+		);
+		this.childrenCounters = {};
+		/** @type {Set<number|string>} */
+		this.usedChunkIds = null;
+		/** @type {Set<number>} */
+		this.usedModuleIds = null;
+		/** @type {boolean} */
+		this.needAdditionalPass = false;
+		/** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheModuleEntries = new Set();
+		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheEntries = new Map();
+		/** @type {WeakSet<Module>} */
+		this.builtModules = new WeakSet();
+		/** @type {WeakSet<Module>} */
+		this.codeGeneratedModules = new WeakSet();
+		/** @type {WeakSet<Module>} */
+		this.buildTimeExecutedModules = new WeakSet();
+		/** @private @type {Map<Module, Callback[]>} */
+		this._rebuildingModules = new Map();
+		/** @type {Set<string>} */
+		this.emittedAssets = new Set();
+		/** @type {Set<string>} */
+		this.comparedForEmitAssets = new Set();
+		/** @type {LazySet<string>} */
+		this.fileDependencies = new LazySet();
+		/** @type {LazySet<string>} */
+		this.contextDependencies = new LazySet();
+		/** @type {LazySet<string>} */
+		this.missingDependencies = new LazySet();
+		/** @type {LazySet<string>} */
+		this.buildDependencies = new LazySet();
+		// TODO webpack 6 remove
+		this.compilationDependencies = {
+			add: util.deprecate(
+				item => this.fileDependencies.add(item),
+				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
+				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
+			)
+		};
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").DevTool} DevToolOptions */
-/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
+		this._modulesCache = this.getCache("Compilation/modules");
+		this._assetsCache = this.getCache("Compilation/assets");
+		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
 
-/** @type {WeakMap<Source, Source>} */
-const cache = new WeakMap();
+		const unsafeCache = options.module.unsafeCache;
+		this._unsafeCache = !!unsafeCache;
+		this._unsafeCachePredicate =
+			typeof unsafeCache === "function" ? unsafeCache : () => true;
+	}
 
-const devtoolWarning = new RawSource(`/*
- * ATTENTION: An "eval-source-map" devtool has been used.
- * This devtool is neither made for production nor for readable output files.
- * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
- * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
- * or disable the default devtool with "devtool: false".
- * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
- */
-`);
+	getStats() {
+		return new Stats(this);
+	}
 
-class EvalSourceMapDevToolPlugin {
 	/**
-	 * @param {SourceMapDevToolPluginOptions|string} inputOptions Options object
+	 * @param {StatsOptions | string} optionsOrPreset stats option value
+	 * @param {CreateStatsOptionsContext} context context
+	 * @returns {NormalizedStatsOptions} normalized options
 	 */
-	constructor(inputOptions) {
-		/** @type {SourceMapDevToolPluginOptions} */
-		let options;
-		if (typeof inputOptions === "string") {
-			options = {
-				append: inputOptions
-			};
+	createStatsOptions(optionsOrPreset, context = {}) {
+		if (
+			typeof optionsOrPreset === "boolean" ||
+			typeof optionsOrPreset === "string"
+		) {
+			optionsOrPreset = { preset: optionsOrPreset };
+		}
+		if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
+			// We use this method of shallow cloning this object to include
+			// properties in the prototype chain
+			/** @type {Partial<NormalizedStatsOptions>} */
+			const options = {};
+			for (const key in optionsOrPreset) {
+				options[key] = optionsOrPreset[key];
+			}
+			if (options.preset !== undefined) {
+				this.hooks.statsPreset.for(options.preset).call(options, context);
+			}
+			this.hooks.statsNormalize.call(options, context);
+			return /** @type {NormalizedStatsOptions} */ (options);
 		} else {
-			options = inputOptions;
+			/** @type {Partial<NormalizedStatsOptions>} */
+			const options = {};
+			this.hooks.statsNormalize.call(options, context);
+			return /** @type {NormalizedStatsOptions} */ (options);
 		}
-		this.sourceMapComment =
-			options.append || "//# sourceURL=[module]\n//# sourceMappingURL=[url]";
-		this.moduleFilenameTemplate =
-			options.moduleFilenameTemplate ||
-			"webpack://[namespace]/[resource-path]?[hash]";
-		this.namespace = options.namespace || "";
-		this.options = options;
+	}
+
+	createStatsFactory(options) {
+		const statsFactory = new StatsFactory();
+		this.hooks.statsFactory.call(statsFactory, options);
+		return statsFactory;
+	}
+
+	createStatsPrinter(options) {
+		const statsPrinter = new StatsPrinter();
+		this.hooks.statsPrinter.call(statsPrinter, options);
+		return statsPrinter;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string} name cache name
+	 * @returns {CacheFacade} the cache facade instance
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap(
-			"EvalSourceMapDevToolPlugin",
-			compilation => {
-				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
-				const matchModule = ModuleFilenameHelpers.matchObject.bind(
-					ModuleFilenameHelpers,
-					options
-				);
-				hooks.renderModuleContent.tap(
-					"EvalSourceMapDevToolPlugin",
-					(source, m, { runtimeTemplate, chunkGraph }) => {
-						const cachedSource = cache.get(source);
-						if (cachedSource !== undefined) {
-							return cachedSource;
-						}
-
-						const result = r => {
-							cache.set(source, r);
-							return r;
-						};
+	getCache(name) {
+		return this.compiler.getCache(name);
+	}
 
-						if (m instanceof NormalModule) {
-							const module = /** @type {NormalModule} */ (m);
-							if (!matchModule(module.resource)) {
-								return result(source);
-							}
-						} else if (m instanceof ConcatenatedModule) {
-							const concatModule = /** @type {ConcatenatedModule} */ (m);
-							if (concatModule.rootModule instanceof NormalModule) {
-								const module = /** @type {NormalModule} */ (
-									concatModule.rootModule
-								);
-								if (!matchModule(module.resource)) {
-									return result(source);
-								}
-							} else {
-								return result(source);
-							}
-						} else {
-							return result(source);
+	/**
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
+	 */
+	getLogger(name) {
+		if (!name) {
+			throw new TypeError("Compilation.getLogger(name) called without a name");
+		}
+		/** @type {LogEntry[] | undefined} */
+		let logEntries;
+		return new Logger(
+			(type, args) => {
+				if (typeof name === "function") {
+					name = name();
+					if (!name) {
+						throw new TypeError(
+							"Compilation.getLogger(name) called with a function not returning a name"
+						);
+					}
+				}
+				let trace;
+				switch (type) {
+					case LogType.warn:
+					case LogType.error:
+					case LogType.trace:
+						trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+							.split("\n")
+							.slice(3);
+						break;
+				}
+				/** @type {LogEntry} */
+				const logEntry = {
+					time: Date.now(),
+					type,
+					args,
+					trace
+				};
+				if (this.hooks.log.call(name, logEntry) === undefined) {
+					if (logEntry.type === LogType.profileEnd) {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						if (typeof console.profileEnd === "function") {
+							// eslint-disable-next-line node/no-unsupported-features/node-builtins
+							console.profileEnd(`[${name}] ${logEntry.args[0]}`);
 						}
-
-						/** @type {{ [key: string]: TODO; }} */
-						let sourceMap;
-						let content;
-						if (source.sourceAndMap) {
-							const sourceAndMap = source.sourceAndMap(options);
-							sourceMap = sourceAndMap.map;
-							content = sourceAndMap.source;
-						} else {
-							sourceMap = source.map(options);
-							content = source.source();
+					}
+					if (logEntries === undefined) {
+						logEntries = this.logging.get(name);
+						if (logEntries === undefined) {
+							logEntries = [];
+							this.logging.set(name, logEntries);
 						}
-						if (!sourceMap) {
-							return result(source);
+					}
+					logEntries.push(logEntry);
+					if (logEntry.type === LogType.profile) {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						if (typeof console.profile === "function") {
+							// eslint-disable-next-line node/no-unsupported-features/node-builtins
+							console.profile(`[${name}] ${logEntry.args[0]}`);
 						}
-
-						// Clone (flat) the sourcemap to ensure that the mutations below do not persist.
-						sourceMap = { ...sourceMap };
-						const context = compiler.options.context;
-						const root = compiler.root;
-						const modules = sourceMap.sources.map(source => {
-							if (!source.startsWith("webpack://")) return source;
-							source = makePathsAbsolute(context, source.slice(10), root);
-							const module = compilation.findModule(source);
-							return module || source;
+					}
+				}
+			},
+			childName => {
+				if (typeof name === "function") {
+					if (typeof childName === "function") {
+						return this.getLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compilation.getLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
 						});
-						let moduleFilenames = modules.map(module => {
-							return ModuleFilenameHelpers.createFilename(
-								module,
-								{
-									moduleFilenameTemplate: this.moduleFilenameTemplate,
-									namespace: this.namespace
-								},
-								{
-									requestShortener: runtimeTemplate.requestShortener,
-									chunkGraph,
-									hashFunction: compilation.outputOptions.hashFunction
+					} else {
+						return this.getLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compilation.getLogger(name) called with a function not returning a name"
+									);
 								}
-							);
+							}
+							return `${name}/${childName}`;
 						});
-						moduleFilenames = ModuleFilenameHelpers.replaceDuplicates(
-							moduleFilenames,
-							(filename, i, n) => {
-								for (let j = 0; j < n; j++) filename += "*";
-								return filename;
+					}
+				} else {
+					if (typeof childName === "function") {
+						return this.getLogger(() => {
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
 							}
-						);
-						sourceMap.sources = moduleFilenames;
-						sourceMap.sourceRoot = options.sourceRoot || "";
-						const moduleId = chunkGraph.getModuleId(m);
-						sourceMap.file = `${moduleId}.js`;
-
-						const footer =
-							this.sourceMapComment.replace(
-								/\[url\]/g,
-								`data:application/json;charset=utf-8;base64,${Buffer.from(
-									JSON.stringify(sourceMap),
-									"utf8"
-								).toString("base64")}`
-							) + `\n//# sourceURL=webpack-internal:///${moduleId}\n`; // workaround for chrome bug
-
-						return result(
-							new RawSource(
-								`eval(${
-									compilation.outputOptions.trustedTypes
-										? `${RuntimeGlobals.createScript}(${JSON.stringify(
-												content + footer
-										  )})`
-										: JSON.stringify(content + footer)
-								});`
-							)
-						);
+							return `${name}/${childName}`;
+						});
+					} else {
+						return this.getLogger(`${name}/${childName}`);
 					}
-				);
-				hooks.inlineInRuntimeBailout.tap(
-					"EvalDevToolModulePlugin",
-					() => "the eval-source-map devtool is used."
-				);
-				hooks.render.tap(
-					"EvalSourceMapDevToolPlugin",
-					source => new ConcatSource(devtoolWarning, source)
-				);
-				hooks.chunkHash.tap("EvalSourceMapDevToolPlugin", (chunk, hash) => {
-					hash.update("EvalSourceMapDevToolPlugin");
-					hash.update("2");
-				});
-				if (compilation.outputOptions.trustedTypes) {
-					compilation.hooks.additionalModuleRuntimeRequirements.tap(
-						"EvalSourceMapDevToolPlugin",
-						(module, set, context) => {
-							set.add(RuntimeGlobals.createScript);
-						}
-					);
 				}
 			}
 		);
 	}
-}
-
-module.exports = EvalSourceMapDevToolPlugin;
-
-
-/***/ }),
-
-/***/ 63686:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { equals } = __webpack_require__(84953);
-const SortableSet = __webpack_require__(13098);
-const makeSerializable = __webpack_require__(33032);
-const { forEachRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./util/Hash")} Hash */
-
-/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
-/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
-
-const UsageState = Object.freeze({
-	Unused: /** @type {0} */ (0),
-	OnlyPropertiesUsed: /** @type {1} */ (1),
-	NoInfo: /** @type {2} */ (2),
-	Unknown: /** @type {3} */ (3),
-	Used: /** @type {4} */ (4)
-});
 
-const RETURNS_TRUE = () => true;
+	/**
+	 * @param {Module} module module to be added that was created
+	 * @param {ModuleCallback} callback returns the module in the compilation,
+	 * it could be the passed one (if new), or an already existing in the compilation
+	 * @returns {void}
+	 */
+	addModule(module, callback) {
+		this.addModuleQueue.add(module, callback);
+	}
 
-const CIRCULAR = Symbol("circular target");
+	/**
+	 * @param {Module} module module to be added that was created
+	 * @param {ModuleCallback} callback returns the module in the compilation,
+	 * it could be the passed one (if new), or an already existing in the compilation
+	 * @returns {void}
+	 */
+	_addModule(module, callback) {
+		const identifier = module.identifier();
+		const alreadyAddedModule = this._modules.get(identifier);
+		if (alreadyAddedModule) {
+			return callback(null, alreadyAddedModule);
+		}
 
-class RestoreProvidedData {
-	constructor(
-		exports,
-		otherProvided,
-		otherCanMangleProvide,
-		otherTerminalBinding
-	) {
-		this.exports = exports;
-		this.otherProvided = otherProvided;
-		this.otherCanMangleProvide = otherCanMangleProvide;
-		this.otherTerminalBinding = otherTerminalBinding;
-	}
+		const currentProfile = this.profile
+			? this.moduleGraph.getProfile(module)
+			: undefined;
+		if (currentProfile !== undefined) {
+			currentProfile.markRestoringStart();
+		}
 
-	serialize({ write }) {
-		write(this.exports);
-		write(this.otherProvided);
-		write(this.otherCanMangleProvide);
-		write(this.otherTerminalBinding);
-	}
+		this._modulesCache.get(identifier, null, (err, cacheModule) => {
+			if (err) return callback(new ModuleRestoreError(module, err));
 
-	static deserialize({ read }) {
-		return new RestoreProvidedData(read(), read(), read(), read());
-	}
-}
+			if (currentProfile !== undefined) {
+				currentProfile.markRestoringEnd();
+				currentProfile.markIntegrationStart();
+			}
 
-makeSerializable(
-	RestoreProvidedData,
-	"webpack/lib/ModuleGraph",
-	"RestoreProvidedData"
-);
+			if (cacheModule) {
+				cacheModule.updateCacheModule(module);
 
-class ExportsInfo {
-	constructor() {
-		/** @type {Map<string, ExportInfo>} */
-		this._exports = new Map();
-		this._otherExportsInfo = new ExportInfo(null);
-		this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
-		this._exportsAreOrdered = false;
-		/** @type {ExportsInfo=} */
-		this._redirectTo = undefined;
+				module = cacheModule;
+			}
+			this._modules.set(identifier, module);
+			this.modules.add(module);
+			if (this._backCompat)
+				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+			if (currentProfile !== undefined) {
+				currentProfile.markIntegrationEnd();
+			}
+			callback(null, module);
+		});
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all owned exports in any order
+	 * Fetches a module from a compilation by its identifier
+	 * @param {Module} module the module provided
+	 * @returns {Module} the module requested
 	 */
-	get ownedExports() {
-		return this._exports.values();
+	getModule(module) {
+		const identifier = module.identifier();
+		return this._modules.get(identifier);
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all owned exports in order
+	 * Attempts to search for a module by its identifier
+	 * @param {string} identifier identifier (usually path) for module
+	 * @returns {Module|undefined} attempt to search for module and return it, else undefined
 	 */
-	get orderedOwnedExports() {
-		if (!this._exportsAreOrdered) {
-			this._sortExports();
-		}
-		return this._exports.values();
+	findModule(identifier) {
+		return this._modules.get(identifier);
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all exports in any order
+	 * Schedules a build of the module object
+	 *
+	 * @param {Module} module module to be built
+	 * @param {ModuleCallback} callback the callback
+	 * @returns {void}
 	 */
-	get exports() {
-		if (this._redirectTo !== undefined) {
-			const map = new Map(this._redirectTo._exports);
-			for (const [key, value] of this._exports) {
-				map.set(key, value);
-			}
-			return map.values();
-		}
-		return this._exports.values();
+	buildModule(module, callback) {
+		this.buildQueue.add(module, callback);
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all exports in order
+	 * Builds the module object
+	 *
+	 * @param {Module} module module to be built
+	 * @param {ModuleCallback} callback the callback
+	 * @returns {void}
 	 */
-	get orderedExports() {
-		if (!this._exportsAreOrdered) {
-			this._sortExports();
+	_buildModule(module, callback) {
+		const currentProfile = this.profile
+			? this.moduleGraph.getProfile(module)
+			: undefined;
+		if (currentProfile !== undefined) {
+			currentProfile.markBuildingStart();
 		}
-		if (this._redirectTo !== undefined) {
-			const map = new Map(
-				Array.from(this._redirectTo.orderedExports, item => [item.name, item])
-			);
-			for (const [key, value] of this._exports) {
-				map.set(key, value);
+
+		module.needBuild(
+			{
+				compilation: this,
+				fileSystemInfo: this.fileSystemInfo,
+				valueCacheVersions: this.valueCacheVersions
+			},
+			(err, needBuild) => {
+				if (err) return callback(err);
+
+				if (!needBuild) {
+					if (currentProfile !== undefined) {
+						currentProfile.markBuildingEnd();
+					}
+					this.hooks.stillValidModule.call(module);
+					return callback();
+				}
+
+				this.hooks.buildModule.call(module);
+				this.builtModules.add(module);
+				module.build(
+					this.options,
+					this,
+					this.resolverFactory.get("normal", module.resolveOptions),
+					this.inputFileSystem,
+					err => {
+						if (currentProfile !== undefined) {
+							currentProfile.markBuildingEnd();
+						}
+						if (err) {
+							this.hooks.failedModule.call(module, err);
+							return callback(err);
+						}
+						if (currentProfile !== undefined) {
+							currentProfile.markStoringStart();
+						}
+						this._modulesCache.store(module.identifier(), null, module, err => {
+							if (currentProfile !== undefined) {
+								currentProfile.markStoringEnd();
+							}
+							if (err) {
+								this.hooks.failedModule.call(module, err);
+								return callback(new ModuleStoreError(module, err));
+							}
+							this.hooks.succeedModule.call(module);
+							return callback();
+						});
+					}
+				);
 			}
-			// sorting should be pretty fast as map contains
-			// a lot of presorted items
-			this._sortExportsMap(map);
-			return map.values();
-		}
-		return this._exports.values();
+		);
 	}
 
 	/**
-	 * @returns {ExportInfo} the export info of unlisted exports
+	 * @param {Module} module to be processed for deps
+	 * @param {ModuleCallback} callback callback to be triggered
+	 * @returns {void}
 	 */
-	get otherExportsInfo() {
-		if (this._redirectTo !== undefined)
-			return this._redirectTo.otherExportsInfo;
-		return this._otherExportsInfo;
+	processModuleDependencies(module, callback) {
+		this.processDependenciesQueue.add(module, callback);
 	}
 
-	_sortExportsMap(exports) {
-		if (exports.size > 1) {
-			const namesInOrder = [];
-			for (const entry of exports.values()) {
-				namesInOrder.push(entry.name);
-			}
-			namesInOrder.sort();
-			let i = 0;
-			for (const entry of exports.values()) {
-				const name = namesInOrder[i];
-				if (entry.name !== name) break;
-				i++;
+	/**
+	 * @param {Module} module to be processed for deps
+	 * @returns {void}
+	 */
+	processModuleDependenciesNonRecursive(module) {
+		const processDependenciesBlock = block => {
+			if (block.dependencies) {
+				let i = 0;
+				for (const dep of block.dependencies) {
+					this.moduleGraph.setParents(dep, block, module, i++);
+				}
 			}
-			for (; i < namesInOrder.length; i++) {
-				const name = namesInOrder[i];
-				const correctEntry = exports.get(name);
-				exports.delete(name);
-				exports.set(name, correctEntry);
+			if (block.blocks) {
+				for (const b of block.blocks) processDependenciesBlock(b);
 			}
-		}
-	}
+		};
 
-	_sortExports() {
-		this._sortExportsMap(this._exports);
-		this._exportsAreOrdered = true;
+		processDependenciesBlock(module);
 	}
 
-	setRedirectNamedTo(exportsInfo) {
-		if (this._redirectTo === exportsInfo) return false;
-		this._redirectTo = exportsInfo;
-		return true;
-	}
+	/**
+	 * @param {Module} module to be processed for deps
+	 * @param {ModuleCallback} callback callback to be triggered
+	 * @returns {void}
+	 */
+	_processModuleDependencies(module, callback) {
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
+		const sortedDependencies = [];
 
-	setHasProvideInfo() {
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.provided === undefined) {
-				exportInfo.provided = false;
-			}
-			if (exportInfo.canMangleProvide === undefined) {
-				exportInfo.canMangleProvide = true;
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			this._redirectTo.setHasProvideInfo();
-		} else {
-			if (this._otherExportsInfo.provided === undefined) {
-				this._otherExportsInfo.provided = false;
-			}
-			if (this._otherExportsInfo.canMangleProvide === undefined) {
-				this._otherExportsInfo.canMangleProvide = true;
-			}
-		}
-	}
-
-	setHasUseInfo() {
-		for (const exportInfo of this._exports.values()) {
-			exportInfo.setHasUseInfo();
-		}
-		this._sideEffectsOnlyInfo.setHasUseInfo();
-		if (this._redirectTo !== undefined) {
-			this._redirectTo.setHasUseInfo();
-		} else {
-			this._otherExportsInfo.setHasUseInfo();
-			if (this._otherExportsInfo.canMangleUse === undefined) {
-				this._otherExportsInfo.canMangleUse = true;
-			}
-		}
-	}
+		/** @type {DependenciesBlock} */
+		let currentBlock;
 
-	/**
-	 * @param {string} name export name
-	 * @returns {ExportInfo} export info for this name
-	 */
-	getOwnExportInfo(name) {
-		const info = this._exports.get(name);
-		if (info !== undefined) return info;
-		const newInfo = new ExportInfo(name, this._otherExportsInfo);
-		this._exports.set(name, newInfo);
-		this._exportsAreOrdered = false;
-		return newInfo;
-	}
+		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
+		let dependencies;
+		/** @type {DepConstructor} */
+		let factoryCacheKey;
+		/** @type {ModuleFactory} */
+		let factoryCacheKey2;
+		/** @type {Map<string, Dependency[]>} */
+		let factoryCacheValue;
+		/** @type {string} */
+		let listCacheKey1;
+		/** @type {string} */
+		let listCacheKey2;
+		/** @type {Dependency[]} */
+		let listCacheValue;
 
-	/**
-	 * @param {string} name export name
-	 * @returns {ExportInfo} export info for this name
-	 */
-	getExportInfo(name) {
-		const info = this._exports.get(name);
-		if (info !== undefined) return info;
-		if (this._redirectTo !== undefined)
-			return this._redirectTo.getExportInfo(name);
-		const newInfo = new ExportInfo(name, this._otherExportsInfo);
-		this._exports.set(name, newInfo);
-		this._exportsAreOrdered = false;
-		return newInfo;
-	}
+		let inProgressSorting = 1;
+		let inProgressTransitive = 1;
 
-	/**
-	 * @param {string} name export name
-	 * @returns {ExportInfo} export info for this name
-	 */
-	getReadOnlyExportInfo(name) {
-		const info = this._exports.get(name);
-		if (info !== undefined) return info;
-		if (this._redirectTo !== undefined)
-			return this._redirectTo.getReadOnlyExportInfo(name);
-		return this._otherExportsInfo;
-	}
+		const onDependenciesSorted = err => {
+			if (err) return callback(err);
 
-	/**
-	 * @param {string[]} name export name
-	 * @returns {ExportInfo | undefined} export info for this name
-	 */
-	getReadOnlyExportInfoRecursive(name) {
-		const exportInfo = this.getReadOnlyExportInfo(name[0]);
-		if (name.length === 1) return exportInfo;
-		if (!exportInfo.exportsInfo) return undefined;
-		return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
-	}
+			// early exit without changing parallelism back and forth
+			if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
+				return callback();
+			}
 
-	/**
-	 * @param {string[]=} name the export name
-	 * @returns {ExportsInfo | undefined} the nested exports info
-	 */
-	getNestedExportsInfo(name) {
-		if (Array.isArray(name) && name.length > 0) {
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (!info.exportsInfo) return undefined;
-			return info.exportsInfo.getNestedExportsInfo(name.slice(1));
-		}
-		return this;
-	}
+			// This is nested so we need to allow one additional task
+			this.processDependenciesQueue.increaseParallelism();
 
-	/**
-	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
-	 * @param {Set<string>=} excludeExports list of unaffected exports
-	 * @param {any=} targetKey use this as key for the target
-	 * @param {ModuleGraphConnection=} targetModule set this module as target
-	 * @param {number=} priority priority
-	 * @returns {boolean} true, if this call changed something
-	 */
-	setUnknownExportsProvided(
-		canMangle,
-		excludeExports,
-		targetKey,
-		targetModule,
-		priority
-	) {
-		let changed = false;
-		if (excludeExports) {
-			for (const name of excludeExports) {
-				// Make sure these entries exist, so they can get different info
-				this.getExportInfo(name);
-			}
-		}
-		for (const exportInfo of this._exports.values()) {
-			if (excludeExports && excludeExports.has(exportInfo.name)) continue;
-			if (exportInfo.provided !== true && exportInfo.provided !== null) {
-				exportInfo.provided = null;
-				changed = true;
-			}
-			if (!canMangle && exportInfo.canMangleProvide !== false) {
-				exportInfo.canMangleProvide = false;
-				changed = true;
-			}
-			if (targetKey) {
-				exportInfo.setTarget(targetKey, targetModule, [exportInfo.name], -1);
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			if (
-				this._redirectTo.setUnknownExportsProvided(
-					canMangle,
-					excludeExports,
-					targetKey,
-					targetModule,
-					priority
-				)
-			) {
-				changed = true;
-			}
-		} else {
-			if (
-				this._otherExportsInfo.provided !== true &&
-				this._otherExportsInfo.provided !== null
-			) {
-				this._otherExportsInfo.provided = null;
-				changed = true;
-			}
-			if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) {
-				this._otherExportsInfo.canMangleProvide = false;
-				changed = true;
-			}
-			if (targetKey) {
-				this._otherExportsInfo.setTarget(
-					targetKey,
-					targetModule,
-					undefined,
-					priority
-				);
+			for (const item of sortedDependencies) {
+				inProgressTransitive++;
+				this.handleModuleCreation(item, err => {
+					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
+					// errors are created inside closures that keep a reference to the Compilation, so errors are
+					// leaking the Compilation object.
+					if (err && this.bail) {
+						if (inProgressTransitive <= 0) return;
+						inProgressTransitive = -1;
+						// eslint-disable-next-line no-self-assign
+						err.stack = err.stack;
+						onTransitiveTasksFinished(err);
+						return;
+					}
+					if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+				});
 			}
-		}
-		return changed;
-	}
+			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+		};
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
-	 */
-	setUsedInUnknownWay(runtime) {
-		let changed = false;
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.setUsedInUnknownWay(runtime)) {
-				changed = true;
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			if (this._redirectTo.setUsedInUnknownWay(runtime)) {
-				changed = true;
-			}
-		} else {
-			if (
-				this._otherExportsInfo.setUsedConditionally(
-					used => used < UsageState.Unknown,
-					UsageState.Unknown,
-					runtime
-				)
-			) {
-				changed = true;
+		const onTransitiveTasksFinished = err => {
+			if (err) return callback(err);
+			this.processDependenciesQueue.decreaseParallelism();
+
+			return callback();
+		};
+
+		/**
+		 * @param {Dependency} dep dependency
+		 * @param {number} index index in block
+		 * @returns {void}
+		 */
+		const processDependency = (dep, index) => {
+			this.moduleGraph.setParents(dep, currentBlock, module, index);
+			if (this._unsafeCache) {
+				try {
+					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
+					if (unsafeCachedModule === null) return;
+					if (unsafeCachedModule !== undefined) {
+						if (
+							this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
+						) {
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								unsafeCachedModule
+							);
+							return;
+						}
+						const identifier = unsafeCachedModule.identifier();
+						const cachedModule =
+							this._restoredUnsafeCacheEntries.get(identifier);
+						if (cachedModule !== undefined) {
+							// update unsafe cache to new module
+							unsafeCacheDependencies.set(dep, cachedModule);
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								cachedModule
+							);
+							return;
+						}
+						inProgressSorting++;
+						this._modulesCache.get(identifier, null, (err, cachedModule) => {
+							if (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
+								return;
+							}
+							try {
+								if (!this._restoredUnsafeCacheEntries.has(identifier)) {
+									const data = unsafeCacheData.get(cachedModule);
+									if (data === undefined) {
+										processDependencyForResolving(dep);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+									if (cachedModule !== unsafeCachedModule) {
+										unsafeCacheDependencies.set(dep, cachedModule);
+									}
+									cachedModule.restoreFromUnsafeCache(
+										data,
+										this.params.normalModuleFactory,
+										this.params
+									);
+									this._restoredUnsafeCacheEntries.set(
+										identifier,
+										cachedModule
+									);
+									this._restoredUnsafeCacheModuleEntries.add(cachedModule);
+									if (!this.modules.has(cachedModule)) {
+										inProgressTransitive++;
+										this._handleNewModuleFromUnsafeCache(
+											module,
+											dep,
+											cachedModule,
+											err => {
+												if (err) {
+													if (inProgressTransitive <= 0) return;
+													inProgressTransitive = -1;
+													onTransitiveTasksFinished(err);
+												}
+												if (--inProgressTransitive === 0)
+													return onTransitiveTasksFinished();
+											}
+										);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+								}
+								if (unsafeCachedModule !== cachedModule) {
+									unsafeCacheDependencies.set(dep, cachedModule);
+								}
+								this._handleExistingModuleFromUnsafeCache(
+									module,
+									dep,
+									cachedModule
+								); // a3
+							} catch (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
+								return;
+							}
+							if (--inProgressSorting === 0) onDependenciesSorted();
+						});
+						return;
+					}
+				} catch (e) {
+					console.error(e);
+				}
 			}
-			if (this._otherExportsInfo.canMangleUse !== false) {
-				this._otherExportsInfo.canMangleUse = false;
-				changed = true;
+			processDependencyForResolving(dep);
+		};
+
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
+		const processDependencyForResolving = dep => {
+			const resourceIdent = dep.getResourceIdentifier();
+			if (resourceIdent !== undefined && resourceIdent !== null) {
+				const category = dep.category;
+				const constructor = /** @type {DepConstructor} */ (dep.constructor);
+				if (factoryCacheKey === constructor) {
+					// Fast path 1: same constructor as prev item
+					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+						// Super fast path 1: also same resource
+						listCacheValue.push(dep);
+						return;
+					}
+				} else {
+					const factory = this.dependencyFactories.get(constructor);
+					if (factory === undefined) {
+						throw new Error(
+							`No module factory available for dependency type: ${constructor.name}`
+						);
+					}
+					if (factoryCacheKey2 === factory) {
+						// Fast path 2: same factory as prev item
+						factoryCacheKey = constructor;
+						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+							// Super fast path 2: also same resource
+							listCacheValue.push(dep);
+							return;
+						}
+					} else {
+						// Slow path
+						if (factoryCacheKey2 !== undefined) {
+							// Archive last cache entry
+							if (dependencies === undefined) dependencies = new Map();
+							dependencies.set(factoryCacheKey2, factoryCacheValue);
+							factoryCacheValue = dependencies.get(factory);
+							if (factoryCacheValue === undefined) {
+								factoryCacheValue = new Map();
+							}
+						} else {
+							factoryCacheValue = new Map();
+						}
+						factoryCacheKey = constructor;
+						factoryCacheKey2 = factory;
+					}
+				}
+				// Here webpack is using heuristic that assumes
+				// mostly esm dependencies would be used
+				// so we don't allocate extra string for them
+				const cacheKey =
+					category === esmDependencyCategory
+						? resourceIdent
+						: `${category}${resourceIdent}`;
+				let list = factoryCacheValue.get(cacheKey);
+				if (list === undefined) {
+					factoryCacheValue.set(cacheKey, (list = []));
+					sortedDependencies.push({
+						factory: factoryCacheKey2,
+						dependencies: list,
+						originModule: module
+					});
+				}
+				list.push(dep);
+				listCacheKey1 = category;
+				listCacheKey2 = resourceIdent;
+				listCacheValue = list;
 			}
+		};
+
+		try {
+			/** @type {DependenciesBlock[]} */
+			const queue = [module];
+			do {
+				const block = queue.pop();
+				if (block.dependencies) {
+					currentBlock = block;
+					let i = 0;
+					for (const dep of block.dependencies) processDependency(dep, i++);
+				}
+				if (block.blocks) {
+					for (const b of block.blocks) queue.push(b);
+				}
+			} while (queue.length !== 0);
+		} catch (e) {
+			return callback(e);
 		}
-		return changed;
+
+		if (--inProgressSorting === 0) onDependenciesSorted();
 	}
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
-	 */
-	setUsedWithoutInfo(runtime) {
-		let changed = false;
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.setUsedWithoutInfo(runtime)) {
-				changed = true;
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			if (this._redirectTo.setUsedWithoutInfo(runtime)) {
-				changed = true;
-			}
-		} else {
-			if (this._otherExportsInfo.setUsed(UsageState.NoInfo, runtime)) {
-				changed = true;
-			}
-			if (this._otherExportsInfo.canMangleUse !== false) {
-				this._otherExportsInfo.canMangleUse = false;
-				changed = true;
-			}
-		}
-		return changed;
+	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
+		const moduleGraph = this.moduleGraph;
+
+		moduleGraph.setResolvedModule(originModule, dependency, module);
+
+		moduleGraph.setIssuerIfUnset(
+			module,
+			originModule !== undefined ? originModule : null
+		);
+
+		this._modules.set(module.identifier(), module);
+		this.modules.add(module);
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+
+		this._handleModuleBuildAndDependencies(
+			originModule,
+			module,
+			true,
+			callback
+		);
 	}
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
-	 */
-	setAllKnownExportsUsed(runtime) {
-		let changed = false;
-		for (const exportInfo of this._exports.values()) {
-			if (!exportInfo.provided) continue;
-			if (exportInfo.setUsed(UsageState.Used, runtime)) {
-				changed = true;
-			}
-		}
-		return changed;
+	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
+		const moduleGraph = this.moduleGraph;
+
+		moduleGraph.setResolvedModule(originModule, dependency, module);
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
+	 * @typedef {Object} HandleModuleCreationOptions
+	 * @property {ModuleFactory} factory
+	 * @property {Dependency[]} dependencies
+	 * @property {Module | null} originModule
+	 * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+	 * @property {string=} context
+	 * @property {boolean=} recursive recurse into dependencies of the created module
+	 * @property {boolean=} connectOrigin connect the resolved module with the origin module
 	 */
-	setUsedForSideEffectsOnly(runtime) {
-		return this._sideEffectsOnlyInfo.setUsedConditionally(
-			used => used === UsageState.Unused,
-			UsageState.Used,
-			runtime
-		);
-	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when the module exports are used in any way
+	 * @param {HandleModuleCreationOptions} options options object
+	 * @param {ModuleCallback} callback callback
+	 * @returns {void}
 	 */
-	isUsed(runtime) {
-		if (this._redirectTo !== undefined) {
-			if (this._redirectTo.isUsed(runtime)) {
-				return true;
-			}
-		} else {
-			if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
-				return true;
-			}
-		}
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.getUsed(runtime) !== UsageState.Unused) {
-				return true;
+	handleModuleCreation(
+		{
+			factory,
+			dependencies,
+			originModule,
+			contextInfo,
+			context,
+			recursive = true,
+			connectOrigin = recursive
+		},
+		callback
+	) {
+		const moduleGraph = this.moduleGraph;
+
+		const currentProfile = this.profile ? new ModuleProfile() : undefined;
+
+		this.factorizeModule(
+			{
+				currentProfile,
+				factory,
+				dependencies,
+				factoryResult: true,
+				originModule,
+				contextInfo,
+				context
+			},
+			(err, factoryResult) => {
+				const applyFactoryResultDependencies = () => {
+					const { fileDependencies, contextDependencies, missingDependencies } =
+						factoryResult;
+					if (fileDependencies) {
+						this.fileDependencies.addAll(fileDependencies);
+					}
+					if (contextDependencies) {
+						this.contextDependencies.addAll(contextDependencies);
+					}
+					if (missingDependencies) {
+						this.missingDependencies.addAll(missingDependencies);
+					}
+				};
+				if (err) {
+					if (factoryResult) applyFactoryResultDependencies();
+					if (dependencies.every(d => d.optional)) {
+						this.warnings.push(err);
+						return callback();
+					} else {
+						this.errors.push(err);
+						return callback(err);
+					}
+				}
+
+				const newModule = factoryResult.module;
+
+				if (!newModule) {
+					applyFactoryResultDependencies();
+					return callback();
+				}
+
+				if (currentProfile !== undefined) {
+					moduleGraph.setProfile(newModule, currentProfile);
+				}
+
+				this.addModule(newModule, (err, module) => {
+					if (err) {
+						applyFactoryResultDependencies();
+						if (!err.module) {
+							err.module = module;
+						}
+						this.errors.push(err);
+
+						return callback(err);
+					}
+
+					if (
+						this._unsafeCache &&
+						factoryResult.cacheable !== false &&
+						/** @type {any} */ (module).restoreFromUnsafeCache &&
+						this._unsafeCachePredicate(module)
+					) {
+						const unsafeCacheableModule =
+							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
+								module
+							);
+						for (let i = 0; i < dependencies.length; i++) {
+							const dependency = dependencies[i];
+							moduleGraph.setResolvedModule(
+								connectOrigin ? originModule : null,
+								dependency,
+								unsafeCacheableModule
+							);
+							unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
+						}
+						if (!unsafeCacheData.has(unsafeCacheableModule)) {
+							unsafeCacheData.set(
+								unsafeCacheableModule,
+								unsafeCacheableModule.getUnsafeCacheData()
+							);
+						}
+					} else {
+						applyFactoryResultDependencies();
+						for (let i = 0; i < dependencies.length; i++) {
+							const dependency = dependencies[i];
+							moduleGraph.setResolvedModule(
+								connectOrigin ? originModule : null,
+								dependency,
+								module
+							);
+						}
+					}
+
+					moduleGraph.setIssuerIfUnset(
+						module,
+						originModule !== undefined ? originModule : null
+					);
+					if (module !== newModule) {
+						if (currentProfile !== undefined) {
+							const otherProfile = moduleGraph.getProfile(module);
+							if (otherProfile !== undefined) {
+								currentProfile.mergeInto(otherProfile);
+							} else {
+								moduleGraph.setProfile(module, currentProfile);
+							}
+						}
+					}
+
+					this._handleModuleBuildAndDependencies(
+						originModule,
+						module,
+						recursive,
+						callback
+					);
+				});
 			}
-		}
-		return false;
+		);
 	}
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when the module is used in any way
-	 */
-	isModuleUsed(runtime) {
-		if (this.isUsed(runtime)) return true;
-		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
-			return true;
-		return false;
-	}
+	_handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
+		// Check for cycles when build is trigger inside another build
+		let creatingModuleDuringBuildSet = undefined;
+		if (!recursive && this.buildQueue.isProcessing(originModule)) {
+			// Track build dependency
+			creatingModuleDuringBuildSet =
+				this.creatingModuleDuringBuild.get(originModule);
+			if (creatingModuleDuringBuildSet === undefined) {
+				creatingModuleDuringBuildSet = new Set();
+				this.creatingModuleDuringBuild.set(
+					originModule,
+					creatingModuleDuringBuildSet
+				);
+			}
+			creatingModuleDuringBuildSet.add(module);
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
-	 */
-	getUsedExports(runtime) {
-		if (!this._redirectTo !== undefined) {
-			switch (this._otherExportsInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unknown:
-				case UsageState.OnlyPropertiesUsed:
-				case UsageState.Used:
-					return true;
+			// When building is blocked by another module
+			// search for a cycle, cancel the cycle by throwing
+			// an error (otherwise this would deadlock)
+			const blockReasons = this.creatingModuleDuringBuild.get(module);
+			if (blockReasons !== undefined) {
+				const set = new Set(blockReasons);
+				for (const item of set) {
+					const blockReasons = this.creatingModuleDuringBuild.get(item);
+					if (blockReasons !== undefined) {
+						for (const m of blockReasons) {
+							if (m === module) {
+								return callback(new BuildCycleError(module));
+							}
+							set.add(m);
+						}
+					}
+				}
 			}
 		}
-		const array = [];
-		if (!this._exportsAreOrdered) this._sortExports();
-		for (const exportInfo of this._exports.values()) {
-			switch (exportInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unknown:
-					return true;
-				case UsageState.OnlyPropertiesUsed:
-				case UsageState.Used:
-					array.push(exportInfo.name);
+
+		this.buildModule(module, err => {
+			if (creatingModuleDuringBuildSet !== undefined) {
+				creatingModuleDuringBuildSet.delete(module);
 			}
-		}
-		if (this._redirectTo !== undefined) {
-			const inner = this._redirectTo.getUsedExports(runtime);
-			if (inner === null) return null;
-			if (inner === true) return true;
-			if (inner !== false) {
-				for (const item of inner) {
-					array.push(item);
+			if (err) {
+				if (!err.module) {
+					err.module = module;
 				}
+				this.errors.push(err);
+
+				return callback(err);
 			}
-		}
-		if (array.length === 0) {
-			switch (this._sideEffectsOnlyInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unused:
-					return false;
-			}
-		}
-		return new SortableSet(array);
-	}
 
-	/**
-	 * @returns {null | true | string[]} list of exports when known
-	 */
-	getProvidedExports() {
-		if (!this._redirectTo !== undefined) {
-			switch (this._otherExportsInfo.provided) {
-				case undefined:
-					return null;
-				case null:
-					return true;
-				case true:
-					return true;
+			if (!recursive) {
+				this.processModuleDependenciesNonRecursive(module);
+				callback(null, module);
+				return;
 			}
-		}
-		const array = [];
-		if (!this._exportsAreOrdered) this._sortExports();
-		for (const exportInfo of this._exports.values()) {
-			switch (exportInfo.provided) {
-				case undefined:
-					return null;
-				case null:
-					return true;
-				case true:
-					array.push(exportInfo.name);
+
+			// This avoids deadlocks for circular dependencies
+			if (this.processDependenciesQueue.isProcessing(module)) {
+				return callback();
 			}
-		}
-		if (this._redirectTo !== undefined) {
-			const inner = this._redirectTo.getProvidedExports();
-			if (inner === null) return null;
-			if (inner === true) return true;
-			for (const item of inner) {
-				if (!array.includes(item)) {
-					array.push(item);
+
+			this.processModuleDependencies(module, err => {
+				if (err) {
+					return callback(err);
 				}
-			}
-		}
-		return array;
+				callback(null, module);
+			});
+		});
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ExportInfo[]} exports that are relevant (not unused and potential provided)
+	 * @param {FactorizeModuleOptions} options options object
+	 * @param {ModuleOrFactoryResultCallback} callback callback
+	 * @returns {void}
 	 */
-	getRelevantExports(runtime) {
-		const list = [];
-		for (const exportInfo of this._exports.values()) {
-			const used = exportInfo.getUsed(runtime);
-			if (used === UsageState.Unused) continue;
-			if (exportInfo.provided === false) continue;
-			list.push(exportInfo);
-		}
-		if (this._redirectTo !== undefined) {
-			for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) {
-				if (!this._exports.has(exportInfo.name)) list.push(exportInfo);
-			}
-		}
-		if (
-			this._otherExportsInfo.provided !== false &&
-			this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused
-		) {
-			list.push(this._otherExportsInfo);
+	_factorizeModule(
+		{
+			currentProfile,
+			factory,
+			dependencies,
+			originModule,
+			factoryResult,
+			contextInfo,
+			context
+		},
+		callback
+	) {
+		if (currentProfile !== undefined) {
+			currentProfile.markFactoryStart();
 		}
-		return list;
-	}
+		factory.create(
+			{
+				contextInfo: {
+					issuer: originModule ? originModule.nameForCondition() : "",
+					issuerLayer: originModule ? originModule.layer : null,
+					compiler: this.compiler.name,
+					...contextInfo
+				},
+				resolveOptions: originModule ? originModule.resolveOptions : undefined,
+				context: context
+					? context
+					: originModule
+					? originModule.context
+					: this.compiler.context,
+				dependencies: dependencies
+			},
+			(err, result) => {
+				if (result) {
+					// TODO webpack 6: remove
+					// For backward-compat
+					if (result.module === undefined && result instanceof Module) {
+						result = {
+							module: result
+						};
+					}
+					if (!factoryResult) {
+						const {
+							fileDependencies,
+							contextDependencies,
+							missingDependencies
+						} = result;
+						if (fileDependencies) {
+							this.fileDependencies.addAll(fileDependencies);
+						}
+						if (contextDependencies) {
+							this.contextDependencies.addAll(contextDependencies);
+						}
+						if (missingDependencies) {
+							this.missingDependencies.addAll(missingDependencies);
+						}
+					}
+				}
+				if (err) {
+					const notFoundError = new ModuleNotFoundError(
+						originModule,
+						err,
+						dependencies.map(d => d.loc).filter(Boolean)[0]
+					);
+					return callback(notFoundError, factoryResult ? result : undefined);
+				}
+				if (!result) {
+					return callback();
+				}
 
-	/**
-	 * @param {string | string[]} name the name of the export
-	 * @returns {boolean | undefined | null} if the export is provided
-	 */
-	isExportProvided(name) {
-		if (Array.isArray(name)) {
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (info.exportsInfo && name.length > 1) {
-				return info.exportsInfo.isExportProvided(name.slice(1));
+				if (currentProfile !== undefined) {
+					currentProfile.markFactoryEnd();
+				}
+
+				callback(null, factoryResult ? result : result.module);
 			}
-			return info.provided;
-		}
-		const info = this.getReadOnlyExportInfo(name);
-		return info.provided;
+		);
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {string} key representing the usage
+	 * @param {string} context context string path
+	 * @param {Dependency} dependency dependency used to create Module chain
+	 * @param {ModuleCallback} callback callback for when module chain is complete
+	 * @returns {void} will throw if dependency instance is not a valid Dependency
 	 */
-	getUsageKey(runtime) {
-		const key = [];
-		if (this._redirectTo !== undefined) {
-			key.push(this._redirectTo.getUsageKey(runtime));
-		} else {
-			key.push(this._otherExportsInfo.getUsed(runtime));
-		}
-		key.push(this._sideEffectsOnlyInfo.getUsed(runtime));
-		for (const exportInfo of this.orderedOwnedExports) {
-			key.push(exportInfo.getUsed(runtime));
-		}
-		return key.join("|");
+	addModuleChain(context, dependency, callback) {
+		return this.addModuleTree({ context, dependency }, callback);
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtimeA first runtime
-	 * @param {RuntimeSpec} runtimeB second runtime
-	 * @returns {boolean} true, when equally used
+	 * @param {Object} options options
+	 * @param {string} options.context context string path
+	 * @param {Dependency} options.dependency dependency used to create Module chain
+	 * @param {Partial<ModuleFactoryCreateDataContextInfo>=} options.contextInfo additional context info for the root module
+	 * @param {ModuleCallback} callback callback for when module chain is complete
+	 * @returns {void} will throw if dependency instance is not a valid Dependency
 	 */
-	isEquallyUsed(runtimeA, runtimeB) {
-		if (this._redirectTo !== undefined) {
-			if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false;
-		} else {
-			if (
-				this._otherExportsInfo.getUsed(runtimeA) !==
-				this._otherExportsInfo.getUsed(runtimeB)
-			) {
-				return false;
-			}
-		}
+	addModuleTree({ context, dependency, contextInfo }, callback) {
 		if (
-			this._sideEffectsOnlyInfo.getUsed(runtimeA) !==
-			this._sideEffectsOnlyInfo.getUsed(runtimeB)
+			typeof dependency !== "object" ||
+			dependency === null ||
+			!dependency.constructor
 		) {
-			return false;
+			return callback(
+				new WebpackError("Parameter 'dependency' must be a Dependency")
+			);
 		}
-		for (const exportInfo of this.ownedExports) {
-			if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB))
-				return false;
+		const Dep = /** @type {DepConstructor} */ (dependency.constructor);
+		const moduleFactory = this.dependencyFactories.get(Dep);
+		if (!moduleFactory) {
+			return callback(
+				new WebpackError(
+					`No dependency factory available for this dependency type: ${dependency.constructor.name}`
+				)
+			);
 		}
-		return true;
+
+		this.handleModuleCreation(
+			{
+				factory: moduleFactory,
+				dependencies: [dependency],
+				originModule: null,
+				contextInfo,
+				context
+			},
+			(err, result) => {
+				if (err && this.bail) {
+					callback(err);
+					this.buildQueue.stop();
+					this.rebuildQueue.stop();
+					this.processDependenciesQueue.stop();
+					this.factorizeQueue.stop();
+				} else if (!err && result) {
+					callback(null, result);
+				} else {
+					callback();
+				}
+			}
+		);
 	}
 
 	/**
-	 * @param {string | string[]} name export name
-	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {UsageStateType} usage status
+	 * @param {string} context context path for entry
+	 * @param {Dependency} entry entry dependency that should be followed
+	 * @param {string | EntryOptions} optionsOrName options or deprecated name of entry
+	 * @param {ModuleCallback} callback callback function
+	 * @returns {void} returns
 	 */
-	getUsed(name, runtime) {
-		if (Array.isArray(name)) {
-			if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);
-			let info = this.getReadOnlyExportInfo(name[0]);
-			if (info.exportsInfo && name.length > 1) {
-				return info.exportsInfo.getUsed(name.slice(1), runtime);
-			}
-			return info.getUsed(runtime);
-		}
-		let info = this.getReadOnlyExportInfo(name);
-		return info.getUsed(runtime);
+	addEntry(context, entry, optionsOrName, callback) {
+		// TODO webpack 6 remove
+		const options =
+			typeof optionsOrName === "object"
+				? optionsOrName
+				: { name: optionsOrName };
+
+		this._addEntryItem(context, entry, "dependencies", options, callback);
 	}
 
 	/**
-	 * @param {string | string[]} name the export name
-	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {string | string[] | false} the used name
-	 */
-	getUsedName(name, runtime) {
-		if (Array.isArray(name)) {
-			// TODO improve this
-			if (name.length === 0) {
-				if (!this.isUsed(runtime)) return false;
-				return name;
-			}
-			let info = this.getReadOnlyExportInfo(name[0]);
-			const x = info.getUsedName(name[0], runtime);
-			if (x === false) return false;
-			const arr = x === name[0] && name.length === 1 ? name : [x];
-			if (name.length === 1) {
-				return arr;
-			}
-			if (
-				info.exportsInfo &&
-				info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
-			) {
-				const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
-				if (!nested) return false;
-				return arr.concat(nested);
-			} else {
-				return arr.concat(name.slice(1));
-			}
-		} else {
-			let info = this.getReadOnlyExportInfo(name);
-			const usedName = info.getUsedName(name, runtime);
-			return usedName;
-		}
-	}
-
-	/**
-	 * @param {Hash} hash the hash
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {void}
-	 */
-	updateHash(hash, runtime) {
-		this._updateHash(hash, runtime, new Set());
-	}
-
-	/**
-	 * @param {Hash} hash the hash
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
-	 * @returns {void}
+	 * @param {string} context context path for entry
+	 * @param {Dependency} dependency dependency that should be followed
+	 * @param {EntryOptions} options options
+	 * @param {ModuleCallback} callback callback function
+	 * @returns {void} returns
 	 */
-	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		const set = new Set(alreadyVisitedExportsInfo);
-		set.add(this);
-		for (const exportInfo of this.orderedExports) {
-			if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {
-				exportInfo._updateHash(hash, runtime, set);
-			}
-		}
-		this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);
-		this._otherExportsInfo._updateHash(hash, runtime, set);
-		if (this._redirectTo !== undefined) {
-			this._redirectTo._updateHash(hash, runtime, set);
-		}
-	}
-
-	getRestoreProvidedData() {
-		const otherProvided = this._otherExportsInfo.provided;
-		const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
-		const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
-		const exports = [];
-		for (const exportInfo of this.orderedExports) {
-			if (
-				exportInfo.provided !== otherProvided ||
-				exportInfo.canMangleProvide !== otherCanMangleProvide ||
-				exportInfo.terminalBinding !== otherTerminalBinding ||
-				exportInfo.exportsInfoOwned
-			) {
-				exports.push({
-					name: exportInfo.name,
-					provided: exportInfo.provided,
-					canMangleProvide: exportInfo.canMangleProvide,
-					terminalBinding: exportInfo.terminalBinding,
-					exportsInfo: exportInfo.exportsInfoOwned
-						? exportInfo.exportsInfo.getRestoreProvidedData()
-						: undefined
-				});
-			}
-		}
-		return new RestoreProvidedData(
-			exports,
-			otherProvided,
-			otherCanMangleProvide,
-			otherTerminalBinding
+	addInclude(context, dependency, options, callback) {
+		this._addEntryItem(
+			context,
+			dependency,
+			"includeDependencies",
+			options,
+			callback
 		);
 	}
 
-	restoreProvided({
-		otherProvided,
-		otherCanMangleProvide,
-		otherTerminalBinding,
-		exports
-	}) {
-		let wasEmpty = true;
-		for (const exportInfo of this._exports.values()) {
-			wasEmpty = false;
-			exportInfo.provided = otherProvided;
-			exportInfo.canMangleProvide = otherCanMangleProvide;
-			exportInfo.terminalBinding = otherTerminalBinding;
-		}
-		this._otherExportsInfo.provided = otherProvided;
-		this._otherExportsInfo.canMangleProvide = otherCanMangleProvide;
-		this._otherExportsInfo.terminalBinding = otherTerminalBinding;
-		for (const exp of exports) {
-			const exportInfo = this.getExportInfo(exp.name);
-			exportInfo.provided = exp.provided;
-			exportInfo.canMangleProvide = exp.canMangleProvide;
-			exportInfo.terminalBinding = exp.terminalBinding;
-			if (exp.exportsInfo) {
-				const exportsInfo = exportInfo.createNestedExportsInfo();
-				exportsInfo.restoreProvided(exp.exportsInfo);
-			}
-		}
-		if (wasEmpty) this._exportsAreOrdered = true;
-	}
-}
-
-class ExportInfo {
 	/**
-	 * @param {string} name the original name of the export
-	 * @param {ExportInfo=} initFrom init values from this ExportInfo
+	 * @param {string} context context path for entry
+	 * @param {Dependency} entry entry dependency that should be followed
+	 * @param {"dependencies" | "includeDependencies"} target type of entry
+	 * @param {EntryOptions} options options
+	 * @param {ModuleCallback} callback callback function
+	 * @returns {void} returns
 	 */
-	constructor(name, initFrom) {
-		/** @type {string} */
-		this.name = name;
-		/** @private @type {string | null} */
-		this._usedName = initFrom ? initFrom._usedName : null;
-		/** @private @type {UsageStateType} */
-		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
-		/** @private @type {Map<string, RuntimeUsageStateType>} */
-		this._usedInRuntime =
-			initFrom && initFrom._usedInRuntime
-				? new Map(initFrom._usedInRuntime)
-				: undefined;
-		/** @private @type {boolean} */
-		this._hasUseInRuntimeInfo = initFrom
-			? initFrom._hasUseInRuntimeInfo
-			: false;
-		/**
-		 * true: it is provided
-		 * false: it is not provided
-		 * null: only the runtime knows if it is provided
-		 * undefined: it was not determined if it is provided
-		 * @type {boolean | null | undefined}
-		 */
-		this.provided = initFrom ? initFrom.provided : undefined;
-		/**
-		 * is the export a terminal binding that should be checked for export star conflicts
-		 * @type {boolean}
-		 */
-		this.terminalBinding = initFrom ? initFrom.terminalBinding : false;
-		/**
-		 * true: it can be mangled
-		 * false: is can not be mangled
-		 * undefined: it was not determined if it can be mangled
-		 * @type {boolean | undefined}
-		 */
-		this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
-		/**
-		 * true: it can be mangled
-		 * false: is can not be mangled
-		 * undefined: it was not determined if it can be mangled
-		 * @type {boolean | undefined}
-		 */
-		this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
-		/** @type {boolean} */
-		this.exportsInfoOwned = false;
-		/** @type {ExportsInfo=} */
-		this.exportsInfo = undefined;
-		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
-		this._target = undefined;
-		if (initFrom && initFrom._target) {
-			this._target = new Map();
-			for (const [key, value] of initFrom._target) {
-				this._target.set(key, {
-					connection: value.connection,
-					export: value.export || [name],
-					priority: value.priority
-				});
+	_addEntryItem(context, entry, target, options, callback) {
+		const { name } = options;
+		let entryData =
+			name !== undefined ? this.entries.get(name) : this.globalEntry;
+		if (entryData === undefined) {
+			entryData = {
+				dependencies: [],
+				includeDependencies: [],
+				options: {
+					name: undefined,
+					...options
+				}
+			};
+			entryData[target].push(entry);
+			this.entries.set(name, entryData);
+		} else {
+			entryData[target].push(entry);
+			for (const key of Object.keys(options)) {
+				if (options[key] === undefined) continue;
+				if (entryData.options[key] === options[key]) continue;
+				if (
+					Array.isArray(entryData.options[key]) &&
+					Array.isArray(options[key]) &&
+					arrayEquals(entryData.options[key], options[key])
+				) {
+					continue;
+				}
+				if (entryData.options[key] === undefined) {
+					entryData.options[key] = options[key];
+				} else {
+					return callback(
+						new WebpackError(
+							`Conflicting entry option ${key} = ${entryData.options[key]} vs ${options[key]}`
+						)
+					);
+				}
 			}
 		}
-		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
-		this._maxTarget = undefined;
-	}
 
-	// TODO webpack 5 remove
-	/** @private */
-	get used() {
-		throw new Error("REMOVED");
-	}
-	/** @private */
-	get usedName() {
-		throw new Error("REMOVED");
-	}
-	/**
-	 * @private
-	 * @param {*} v v
-	 */
-	set used(v) {
-		throw new Error("REMOVED");
-	}
-	/**
-	 * @private
-	 * @param {*} v v
-	 */
-	set usedName(v) {
-		throw new Error("REMOVED");
-	}
+		this.hooks.addEntry.call(entry, options);
 
-	get canMangle() {
-		switch (this.canMangleProvide) {
-			case undefined:
-				return this.canMangleUse === false ? false : undefined;
-			case false:
-				return false;
-			case true:
-				switch (this.canMangleUse) {
-					case undefined:
-						return undefined;
-					case false:
-						return false;
-					case true:
-						return true;
+		this.addModuleTree(
+			{
+				context,
+				dependency: entry,
+				contextInfo: entryData.options.layer
+					? { issuerLayer: entryData.options.layer }
+					: undefined
+			},
+			(err, module) => {
+				if (err) {
+					this.hooks.failedEntry.call(entry, options, err);
+					return callback(err);
 				}
-		}
-		throw new Error(
-			`Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}`
+				this.hooks.succeedEntry.call(entry, options, module);
+				return callback(null, module);
+			}
 		);
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true, when something changed
+	 * @param {Module} module module to be rebuilt
+	 * @param {ModuleCallback} callback callback when module finishes rebuilding
+	 * @returns {void}
 	 */
-	setUsedInUnknownWay(runtime) {
-		let changed = false;
-		if (
-			this.setUsedConditionally(
-				used => used < UsageState.Unknown,
-				UsageState.Unknown,
-				runtime
-			)
-		) {
-			changed = true;
-		}
-		if (this.canMangleUse !== false) {
-			this.canMangleUse = false;
-			changed = true;
-		}
-		return changed;
+	rebuildModule(module, callback) {
+		this.rebuildQueue.add(module, callback);
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true, when something changed
+	 * @param {Module} module module to be rebuilt
+	 * @param {ModuleCallback} callback callback when module finishes rebuilding
+	 * @returns {void}
 	 */
-	setUsedWithoutInfo(runtime) {
-		let changed = false;
-		if (this.setUsed(UsageState.NoInfo, runtime)) {
-			changed = true;
-		}
-		if (this.canMangleUse !== false) {
-			this.canMangleUse = false;
-			changed = true;
-		}
-		return changed;
+	_rebuildModule(module, callback) {
+		this.hooks.rebuildModule.call(module);
+		const oldDependencies = module.dependencies.slice();
+		const oldBlocks = module.blocks.slice();
+		module.invalidateBuild();
+		this.buildQueue.invalidate(module);
+		this.buildModule(module, err => {
+			if (err) {
+				return this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+					if (err2) {
+						callback(
+							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
+						);
+						return;
+					}
+					callback(err);
+				});
+			}
+
+			this.processDependenciesQueue.invalidate(module);
+			this.moduleGraph.unfreeze();
+			this.processModuleDependencies(module, err => {
+				if (err) return callback(err);
+				this.removeReasonsOfDependencyBlock(module, {
+					dependencies: oldDependencies,
+					blocks: oldBlocks
+				});
+				this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+					if (err2) {
+						callback(
+							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
+						);
+						return;
+					}
+					callback(null, module);
+				});
+			});
+		});
 	}
 
-	setHasUseInfo() {
-		if (!this._hasUseInRuntimeInfo) {
-			this._hasUseInRuntimeInfo = true;
-		}
-		if (this.canMangleUse === undefined) {
-			this.canMangleUse = true;
-		}
-		if (this.exportsInfoOwned) {
-			this.exportsInfo.setHasUseInfo();
+	_computeAffectedModules(modules) {
+		const moduleMemCacheCache = this.compiler.moduleMemCaches;
+		if (!moduleMemCacheCache) return;
+		if (!this.moduleMemCaches) {
+			this.moduleMemCaches = new Map();
+			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
 		}
-	}
+		const { moduleGraph, moduleMemCaches } = this;
+		const affectedModules = new Set();
+		const infectedModules = new Set();
+		let statNew = 0;
+		let statChanged = 0;
+		let statUnchanged = 0;
+		let statReferencesChanged = 0;
+		let statWithoutBuild = 0;
 
-	/**
-	 * @param {function(UsageStateType): boolean} condition compare with old value
-	 * @param {UsageStateType} newValue set when condition is true
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true when something has changed
-	 */
-	setUsedConditionally(condition, newValue, runtime) {
-		if (runtime === undefined) {
-			if (this._globalUsed === undefined) {
-				this._globalUsed = newValue;
-				return true;
-			} else {
-				if (this._globalUsed !== newValue && condition(this._globalUsed)) {
-					this._globalUsed = newValue;
-					return true;
-				}
+		const computeReferences = module => {
+			/** @type {WeakMap<Dependency, Module>} */
+			let references = undefined;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				const m = connection.module;
+				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
+				if (references === undefined) references = new WeakMap();
+				references.set(d, m);
 			}
-		} else if (this._usedInRuntime === undefined) {
-			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
-				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(runtime, newValue)
-				);
-				return true;
+			return references;
+		};
+
+		/**
+		 * @param {Module} module the module
+		 * @param {WeakMap<Dependency, Module>} references references
+		 * @returns {boolean} true, when the references differ
+		 */
+		const compareReferences = (module, references) => {
+			if (references === undefined) return true;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				if (!d) continue;
+				const entry = references.get(d);
+				if (entry === undefined) continue;
+				if (entry !== connection.module) return false;
 			}
-		} else {
-			let changed = false;
-			forEachRuntime(runtime, runtime => {
-				/** @type {UsageStateType} */
-				let oldValue = this._usedInRuntime.get(runtime);
-				if (oldValue === undefined) oldValue = UsageState.Unused;
-				if (newValue !== oldValue && condition(oldValue)) {
-					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
+			return true;
+		};
+
+		const modulesWithoutCache = new Set(modules);
+		for (const [module, cachedMemCache] of moduleMemCacheCache) {
+			if (modulesWithoutCache.has(module)) {
+				const buildInfo = module.buildInfo;
+				if (buildInfo) {
+					if (cachedMemCache.buildInfo !== buildInfo) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.buildInfo = buildInfo;
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statChanged++;
+					} else if (!compareReferences(module, cachedMemCache.references)) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statReferencesChanged++;
 					} else {
-						this._usedInRuntime.set(runtime, newValue);
+						// keep the old mem cache
+						moduleMemCaches.set(module, cachedMemCache.memCache);
+						statUnchanged++;
 					}
-					changed = true;
+				} else {
+					infectedModules.add(module);
+					moduleMemCacheCache.delete(module);
+					statWithoutBuild++;
 				}
-			});
-			if (changed) {
-				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
-				return true;
+				modulesWithoutCache.delete(module);
+			} else {
+				moduleMemCacheCache.delete(module);
 			}
 		}
-		return false;
-	}
 
-	/**
-	 * @param {UsageStateType} newValue new value of the used state
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true when something has changed
-	 */
-	setUsed(newValue, runtime) {
-		if (runtime === undefined) {
-			if (this._globalUsed !== newValue) {
-				this._globalUsed = newValue;
-				return true;
-			}
-		} else if (this._usedInRuntime === undefined) {
-			if (newValue !== UsageState.Unused) {
-				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(runtime, newValue)
-				);
-				return true;
-			}
-		} else {
-			let changed = false;
-			forEachRuntime(runtime, runtime => {
-				/** @type {UsageStateType} */
-				let oldValue = this._usedInRuntime.get(runtime);
-				if (oldValue === undefined) oldValue = UsageState.Unused;
-				if (newValue !== oldValue) {
-					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
-					} else {
-						this._usedInRuntime.set(runtime, newValue);
-					}
-					changed = true;
-				}
-			});
-			if (changed) {
-				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
-				return true;
+		for (const module of modulesWithoutCache) {
+			const buildInfo = module.buildInfo;
+			if (buildInfo) {
+				// create a new entry
+				const memCache = new WeakTupleMap();
+				moduleMemCacheCache.set(module, {
+					buildInfo,
+					references: computeReferences(module),
+					memCache
+				});
+				moduleMemCaches.set(module, memCache);
+				affectedModules.add(module);
+				statNew++;
+			} else {
+				infectedModules.add(module);
+				statWithoutBuild++;
 			}
 		}
-		return false;
-	}
-
-	/**
-	 * @param {any} key the key
-	 * @returns {boolean} true, if something has changed
-	 */
-	unsetTarget(key) {
-		if (!this._target) return false;
-		if (this._target.delete(key)) {
-			this._maxTarget = undefined;
-			return true;
-		}
-		return false;
-	}
 
-	/**
-	 * @param {any} key the key
-	 * @param {ModuleGraphConnection} connection the target module if a single one
-	 * @param {string[]=} exportName the exported name
-	 * @param {number=} priority priority
-	 * @returns {boolean} true, if something has changed
-	 */
-	setTarget(key, connection, exportName, priority = 0) {
-		if (exportName) exportName = [...exportName];
-		if (!this._target) {
-			this._target = new Map();
-			this._target.set(key, { connection, export: exportName, priority });
-			return true;
-		}
-		const oldTarget = this._target.get(key);
-		if (!oldTarget) {
-			if (oldTarget === null && !connection) return false;
-			this._target.set(key, { connection, export: exportName, priority });
-			this._maxTarget = undefined;
-			return true;
+		const reduceAffectType = connections => {
+			let affected = false;
+			for (const { dependency } of connections) {
+				if (!dependency) continue;
+				const type = dependency.couldAffectReferencingModule();
+				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
+				if (type === false) continue;
+				affected = true;
+			}
+			return affected;
+		};
+		const directOnlyInfectedModules = new Set();
+		for (const module of infectedModules) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				const type = reduceAffectType(connections);
+				if (!type) continue;
+				if (type === true) {
+					directOnlyInfectedModules.add(referencingModule);
+				} else {
+					infectedModules.add(referencingModule);
+				}
+			}
 		}
-		if (
-			oldTarget.connection !== connection ||
-			oldTarget.priority !== priority ||
-			(exportName
-				? !oldTarget.export || !equals(oldTarget.export, exportName)
-				: oldTarget.export)
-		) {
-			oldTarget.connection = connection;
-			oldTarget.export = exportName;
-			oldTarget.priority = priority;
-			this._maxTarget = undefined;
-			return true;
+		for (const module of directOnlyInfectedModules) infectedModules.add(module);
+		const directOnlyAffectModules = new Set();
+		for (const module of affectedModules) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				if (affectedModules.has(referencingModule)) continue;
+				const type = reduceAffectType(connections);
+				if (!type) continue;
+				if (type === true) {
+					directOnlyAffectModules.add(referencingModule);
+				} else {
+					affectedModules.add(referencingModule);
+				}
+				const memCache = new WeakTupleMap();
+				const cache = moduleMemCacheCache.get(referencingModule);
+				cache.memCache = memCache;
+				moduleMemCaches.set(referencingModule, memCache);
+			}
 		}
-		return false;
+		for (const module of directOnlyAffectModules) affectedModules.add(module);
+		this.logger.log(
+			`${Math.round(
+				(100 * (affectedModules.size + infectedModules.size)) /
+					this.modules.size
+			)}% (${affectedModules.size} affected + ${
+				infectedModules.size
+			} infected of ${
+				this.modules.size
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
+		);
 	}
 
-	/**
-	 * @param {RuntimeSpec} runtime for this runtime
-	 * @returns {UsageStateType} usage state
-	 */
-	getUsed(runtime) {
-		if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
-		if (this._globalUsed !== undefined) return this._globalUsed;
-		if (this._usedInRuntime === undefined) {
-			return UsageState.Unused;
-		} else if (typeof runtime === "string") {
-			const value = this._usedInRuntime.get(runtime);
-			return value === undefined ? UsageState.Unused : value;
-		} else if (runtime === undefined) {
-			/** @type {UsageStateType} */
-			let max = UsageState.Unused;
-			for (const value of this._usedInRuntime.values()) {
-				if (value === UsageState.Used) {
-					return UsageState.Used;
+	_computeAffectedModulesWithChunkGraph() {
+		const { moduleMemCaches } = this;
+		if (!moduleMemCaches) return;
+		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
+		const { moduleGraph, chunkGraph } = this;
+		const key = "memCache2";
+		let statUnchanged = 0;
+		let statChanged = 0;
+		let statNew = 0;
+		/**
+		 * @param {Module} module module
+		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+		 */
+		const computeReferences = module => {
+			const id = chunkGraph.getModuleId(module);
+			/** @type {Map<Module, string | number | undefined>} */
+			let modules = undefined;
+			/** @type {(string | number)[] | undefined} */
+			let blocks = undefined;
+			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
+			if (outgoing !== undefined) {
+				for (const m of outgoing.keys()) {
+					if (!m) continue;
+					if (modules === undefined) modules = new Map();
+					modules.set(m, chunkGraph.getModuleId(m));
 				}
-				if (max < value) max = value;
 			}
-			return max;
-		} else {
-			/** @type {UsageStateType} */
-			let max = UsageState.Unused;
-			for (const item of runtime) {
-				const value = this._usedInRuntime.get(item);
-				if (value !== undefined) {
-					if (value === UsageState.Used) {
-						return UsageState.Used;
+			if (module.blocks.length > 0) {
+				blocks = [];
+				const queue = Array.from(module.blocks);
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							blocks.push(chunk.id);
+						}
+					} else {
+						blocks.push(null);
 					}
-					if (max < value) max = value;
+					queue.push.apply(queue, block.blocks);
 				}
 			}
-			return max;
-		}
-	}
-
-	/**
-	 * get used name
-	 * @param {string | undefined} fallbackName fallback name for used exports with no name
-	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {string | false} used name
-	 */
-	getUsedName(fallbackName, runtime) {
-		if (this._hasUseInRuntimeInfo) {
-			if (this._globalUsed !== undefined) {
-				if (this._globalUsed === UsageState.Unused) return false;
-			} else {
-				if (this._usedInRuntime === undefined) return false;
-				if (typeof runtime === "string") {
-					if (!this._usedInRuntime.has(runtime)) {
-						return false;
-					}
-				} else if (runtime !== undefined) {
-					if (
-						Array.from(runtime).every(
-							runtime => !this._usedInRuntime.has(runtime)
-						)
-					) {
-						return false;
-					}
+			return { id, modules, blocks };
+		};
+		/**
+		 * @param {Module} module module
+		 * @param {Object} references references
+		 * @param {string | number} references.id id
+		 * @param {Map<Module, string | number>=} references.modules modules
+		 * @param {(string | number)[]=} references.blocks blocks
+		 * @returns {boolean} ok?
+		 */
+		const compareReferences = (module, { id, modules, blocks }) => {
+			if (id !== chunkGraph.getModuleId(module)) return false;
+			if (modules !== undefined) {
+				for (const [module, id] of modules) {
+					if (chunkGraph.getModuleId(module) !== id) return false;
 				}
 			}
-		}
-		if (this._usedName !== null) return this._usedName;
-		return this.name || fallbackName;
-	}
-
-	/**
-	 * @returns {boolean} true, when a mangled name of this export is set
-	 */
-	hasUsedName() {
-		return this._usedName !== null;
-	}
-
-	/**
-	 * Sets the mangled name of this export
-	 * @param {string} name the new name
-	 * @returns {void}
-	 */
-	setUsedName(name) {
-		this._usedName = name;
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
-	 */
-	getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
-		if (this.terminalBinding) return this;
-		const target = this.getTarget(moduleGraph, resolveTargetFilter);
-		if (!target) return undefined;
-		const exportsInfo = moduleGraph.getExportsInfo(target.module);
-		if (!target.export) return exportsInfo;
-		return exportsInfo.getReadOnlyExportInfoRecursive(target.export);
-	}
-
-	isReexport() {
-		return !this.terminalBinding && this._target && this._target.size > 0;
-	}
-
-	_getMaxTarget() {
-		if (this._maxTarget !== undefined) return this._maxTarget;
-		if (this._target.size <= 1) return (this._maxTarget = this._target);
-		let maxPriority = -Infinity;
-		let minPriority = Infinity;
-		for (const { priority } of this._target.values()) {
-			if (maxPriority < priority) maxPriority = priority;
-			if (minPriority > priority) minPriority = priority;
-		}
-		// This should be very common
-		if (maxPriority === minPriority) return (this._maxTarget = this._target);
-
-		// This is an edge case
-		const map = new Map();
-		for (const [key, value] of this._target) {
-			if (maxPriority === value.priority) {
-				map.set(key, value);
+			if (blocks !== undefined) {
+				const queue = Array.from(module.blocks);
+				let i = 0;
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
+						}
+					} else {
+						if (i >= blocks.length || blocks[i++] !== null) return false;
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+				if (i !== blocks.length) return false;
 			}
-		}
-		this._maxTarget = map;
-		return map;
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
-	 */
-	findTarget(moduleGraph, validTargetModuleFilter) {
-		return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
-	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
-	 */
-	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
-		if (!this._target || this._target.size === 0) return undefined;
-		let rawTarget = this._getMaxTarget().values().next().value;
-		if (!rawTarget) return undefined;
-		/** @type {{ module: Module, export: string[] | undefined }} */
-		let target = {
-			module: rawTarget.connection.module,
-			export: rawTarget.export
+			return true;
 		};
-		for (;;) {
-			if (validTargetModuleFilter(target.module)) return target;
-			const exportsInfo = moduleGraph.getExportsInfo(target.module);
-			const exportInfo = exportsInfo.getExportInfo(target.export[0]);
-			if (alreadyVisited.has(exportInfo)) return null;
-			const newTarget = exportInfo._findTarget(
-				moduleGraph,
-				validTargetModuleFilter,
-				alreadyVisited
-			);
-			if (!newTarget) return false;
-			if (target.export.length === 1) {
-				target = newTarget;
+
+		for (const [module, memCache] of moduleMemCaches) {
+			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+			const cache = memCache.get(key);
+			if (cache === undefined) {
+				const memCache2 = new WeakTupleMap();
+				memCache.set(key, {
+					references: computeReferences(module),
+					memCache: memCache2
+				});
+				moduleMemCaches2.set(module, memCache2);
+				statNew++;
+			} else if (!compareReferences(module, cache.references)) {
+				const memCache = new WeakTupleMap();
+				cache.references = computeReferences(module);
+				cache.memCache = memCache;
+				moduleMemCaches2.set(module, memCache);
+				statChanged++;
 			} else {
-				target = {
-					module: newTarget.module,
-					export: newTarget.export
-						? newTarget.export.concat(target.export.slice(1))
-						: target.export.slice(1)
-				};
+				moduleMemCaches2.set(module, cache.memCache);
+				statUnchanged++;
 			}
 		}
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the target
-	 */
-	getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
-		const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
-		if (result === CIRCULAR) return undefined;
-		return result;
+		this.logger.log(
+			`${Math.round(
+				(100 * statChanged) / (statNew + statChanged + statUnchanged)
+			)}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)`
+		);
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | undefined} the target
-	 */
-	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
-		/**
-		 * @param {{ connection: ModuleGraphConnection, export: string[] | undefined } | null} inputTarget unresolved target
-		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
-		 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | null} resolved target
-		 */
-		const resolveTarget = (inputTarget, alreadyVisited) => {
-			if (!inputTarget) return null;
-			if (!inputTarget.export) {
-				return {
-					module: inputTarget.connection.module,
-					connection: inputTarget.connection,
-					export: undefined
-				};
-			}
-			/** @type {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} */
-			let target = {
-				module: inputTarget.connection.module,
-				connection: inputTarget.connection,
-				export: inputTarget.export
-			};
-			if (!resolveTargetFilter(target)) return target;
-			let alreadyVisitedOwned = false;
-			for (;;) {
-				const exportsInfo = moduleGraph.getExportsInfo(target.module);
-				const exportInfo = exportsInfo.getExportInfo(target.export[0]);
-				if (!exportInfo) return target;
-				if (alreadyVisited.has(exportInfo)) return CIRCULAR;
-				const newTarget = exportInfo._getTarget(
-					moduleGraph,
-					resolveTargetFilter,
-					alreadyVisited
+	finish(callback) {
+		this.factorizeQueue.clear();
+		if (this.profile) {
+			this.logger.time("finish module profiles");
+			const ParallelismFactorCalculator = __webpack_require__(50780);
+			const p = new ParallelismFactorCalculator();
+			const moduleGraph = this.moduleGraph;
+			const modulesWithProfiles = new Map();
+			for (const module of this.modules) {
+				const profile = moduleGraph.getProfile(module);
+				if (!profile) continue;
+				modulesWithProfiles.set(module, profile);
+				p.range(
+					profile.buildingStartTime,
+					profile.buildingEndTime,
+					f => (profile.buildingParallelismFactor = f)
 				);
-				if (newTarget === CIRCULAR) return CIRCULAR;
-				if (!newTarget) return target;
-				if (target.export.length === 1) {
-					target = newTarget;
-					if (!target.export) return target;
-				} else {
-					target = {
-						module: newTarget.module,
-						connection: newTarget.connection,
-						export: newTarget.export
-							? newTarget.export.concat(target.export.slice(1))
-							: target.export.slice(1)
-					};
-				}
-				if (!resolveTargetFilter(target)) return target;
-				if (!alreadyVisitedOwned) {
-					alreadyVisited = new Set(alreadyVisited);
-					alreadyVisitedOwned = true;
+				p.range(
+					profile.factoryStartTime,
+					profile.factoryEndTime,
+					f => (profile.factoryParallelismFactor = f)
+				);
+				p.range(
+					profile.integrationStartTime,
+					profile.integrationEndTime,
+					f => (profile.integrationParallelismFactor = f)
+				);
+				p.range(
+					profile.storingStartTime,
+					profile.storingEndTime,
+					f => (profile.storingParallelismFactor = f)
+				);
+				p.range(
+					profile.restoringStartTime,
+					profile.restoringEndTime,
+					f => (profile.restoringParallelismFactor = f)
+				);
+				if (profile.additionalFactoryTimes) {
+					for (const { start, end } of profile.additionalFactoryTimes) {
+						const influence = (end - start) / profile.additionalFactories;
+						p.range(
+							start,
+							end,
+							f =>
+								(profile.additionalFactoriesParallelismFactor += f * influence)
+						);
+					}
 				}
-				alreadyVisited.add(exportInfo);
 			}
-		};
+			p.calculate();
 
-		if (!this._target || this._target.size === 0) return undefined;
-		if (alreadyVisited && alreadyVisited.has(this)) return CIRCULAR;
-		const newAlreadyVisited = new Set(alreadyVisited);
-		newAlreadyVisited.add(this);
-		const values = this._getMaxTarget().values();
-		const target = resolveTarget(values.next().value, newAlreadyVisited);
-		if (target === CIRCULAR) return CIRCULAR;
-		if (target === null) return undefined;
-		let result = values.next();
-		while (!result.done) {
-			const t = resolveTarget(result.value, newAlreadyVisited);
-			if (t === CIRCULAR) return CIRCULAR;
-			if (t === null) return undefined;
-			if (t.module !== target.module) return undefined;
-			if (!t.export !== !target.export) return undefined;
-			if (target.export && !equals(t.export, target.export)) return undefined;
-			result = values.next();
-		}
-		return target;
-	}
+			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
+			const logByValue = (value, msg) => {
+				if (value > 1000) {
+					logger.error(msg);
+				} else if (value > 500) {
+					logger.warn(msg);
+				} else if (value > 200) {
+					logger.info(msg);
+				} else if (value > 30) {
+					logger.log(msg);
+				} else {
+					logger.debug(msg);
+				}
+			};
+			const logNormalSummary = (category, getDuration, getParallelism) => {
+				let sum = 0;
+				let max = 0;
+				for (const [module, profile] of modulesWithProfiles) {
+					const p = getParallelism(profile);
+					const d = getDuration(profile);
+					if (d === 0 || p === 0) continue;
+					const t = d / p;
+					sum += t;
+					if (t <= 10) continue;
+					logByValue(
+						t,
+						` | ${Math.round(t)} ms${
+							p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+						} ${category} > ${module.readableIdentifier(this.requestShortener)}`
+					);
+					max = Math.max(max, t);
+				}
+				if (sum <= 10) return;
+				logByValue(
+					Math.max(sum / 10, max),
+					`${Math.round(sum)} ms ${category}`
+				);
+			};
+			const logByLoadersSummary = (category, getDuration, getParallelism) => {
+				const map = new Map();
+				for (const [module, profile] of modulesWithProfiles) {
+					const list = provide(
+						map,
+						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
+						() => []
+					);
+					list.push({ module, profile });
+				}
 
-	/**
-	 * Move the target forward as long resolveTargetFilter is fulfilled
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {function({ module: Module, export: string[] | undefined }): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the resolved target when moved
-	 */
-	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
-		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
-		if (target === CIRCULAR) return undefined;
-		if (!target) return undefined;
-		const originalTarget = this._getMaxTarget().values().next().value;
-		if (
-			originalTarget.connection === target.connection &&
-			originalTarget.export === target.export
-		) {
-			return undefined;
+				let sum = 0;
+				let max = 0;
+				for (const [key, modules] of map) {
+					let innerSum = 0;
+					let innerMax = 0;
+					for (const { module, profile } of modules) {
+						const p = getParallelism(profile);
+						const d = getDuration(profile);
+						if (d === 0 || p === 0) continue;
+						const t = d / p;
+						innerSum += t;
+						if (t <= 10) continue;
+						logByValue(
+							t,
+							` |  | ${Math.round(t)} ms${
+								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+							} ${category} > ${module.readableIdentifier(
+								this.requestShortener
+							)}`
+						);
+						innerMax = Math.max(innerMax, t);
+					}
+					sum += innerSum;
+					if (innerSum <= 10) continue;
+					const idx = key.indexOf("!");
+					const loaders = key.slice(idx + 1);
+					const moduleType = key.slice(0, idx);
+					const t = Math.max(innerSum / 10, innerMax);
+					logByValue(
+						t,
+						` | ${Math.round(innerSum)} ms ${category} > ${
+							loaders
+								? `${
+										modules.length
+								  } x ${moduleType} with ${this.requestShortener.shorten(
+										loaders
+								  )}`
+								: `${modules.length} x ${moduleType}`
+						}`
+					);
+					max = Math.max(max, t);
+				}
+				if (sum <= 10) return;
+				logByValue(
+					Math.max(sum / 10, max),
+					`${Math.round(sum)} ms ${category}`
+				);
+			};
+			logNormalSummary(
+				"resolve to new modules",
+				p => p.factory,
+				p => p.factoryParallelismFactor
+			);
+			logNormalSummary(
+				"resolve to existing modules",
+				p => p.additionalFactories,
+				p => p.additionalFactoriesParallelismFactor
+			);
+			logNormalSummary(
+				"integrate modules",
+				p => p.restoring,
+				p => p.restoringParallelismFactor
+			);
+			logByLoadersSummary(
+				"build modules",
+				p => p.building,
+				p => p.buildingParallelismFactor
+			);
+			logNormalSummary(
+				"store modules",
+				p => p.storing,
+				p => p.storingParallelismFactor
+			);
+			logNormalSummary(
+				"restore modules",
+				p => p.restoring,
+				p => p.restoringParallelismFactor
+			);
+			this.logger.timeEnd("finish module profiles");
 		}
-		this._target.clear();
-		this._target.set(undefined, {
-			connection: updateOriginalConnection
-				? updateOriginalConnection(target)
-				: target.connection,
-			export: target.export,
-			priority: 0
-		});
-		return target;
-	}
+		this.logger.time("compute affected modules");
+		this._computeAffectedModules(this.modules);
+		this.logger.timeEnd("compute affected modules");
+		this.logger.time("finish modules");
+		const { modules, moduleMemCaches } = this;
+		this.hooks.finishModules.callAsync(modules, err => {
+			this.logger.timeEnd("finish modules");
+			if (err) return callback(err);
 
-	createNestedExportsInfo() {
-		if (this.exportsInfoOwned) return this.exportsInfo;
-		this.exportsInfoOwned = true;
-		const oldExportsInfo = this.exportsInfo;
-		this.exportsInfo = new ExportsInfo();
-		this.exportsInfo.setHasProvideInfo();
-		if (oldExportsInfo) {
-			this.exportsInfo.setRedirectNamedTo(oldExportsInfo);
-		}
-		return this.exportsInfo;
+			// extract warnings and errors from modules
+			this.moduleGraph.freeze("dependency errors");
+			// TODO keep a cacheToken (= {}) for each module in the graph
+			// create a new one per compilation and flag all updated files
+			// and parents with it
+			this.logger.time("report dependency errors and warnings");
+			for (const module of modules) {
+				// TODO only run for modules with changed cacheToken
+				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
+				const memCache = moduleMemCaches && moduleMemCaches.get(module);
+				if (memCache && memCache.get("noWarningsOrErrors")) continue;
+				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
+					module
+				]);
+				const errors = module.getErrors();
+				if (errors !== undefined) {
+					for (const error of errors) {
+						if (!error.module) {
+							error.module = module;
+						}
+						this.errors.push(error);
+						hasProblems = true;
+					}
+				}
+				const warnings = module.getWarnings();
+				if (warnings !== undefined) {
+					for (const warning of warnings) {
+						if (!warning.module) {
+							warning.module = module;
+						}
+						this.warnings.push(warning);
+						hasProblems = true;
+					}
+				}
+				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
+			}
+			this.moduleGraph.unfreeze();
+			this.logger.timeEnd("report dependency errors and warnings");
+
+			callback();
+		});
 	}
 
-	getNestedExportsInfo() {
-		return this.exportsInfo;
+	unseal() {
+		this.hooks.unseal.call();
+		this.chunks.clear();
+		this.chunkGroups.length = 0;
+		this.namedChunks.clear();
+		this.namedChunkGroups.clear();
+		this.entrypoints.clear();
+		this.additionalChunkAssets.length = 0;
+		this.assets = {};
+		this.assetsInfo.clear();
+		this.moduleGraph.removeAllModuleAttributes();
+		this.moduleGraph.unfreeze();
+		this.moduleMemCaches2 = undefined;
 	}
 
-	hasInfo(baseInfo, runtime) {
-		return (
-			(this._usedName && this._usedName !== this.name) ||
-			this.provided ||
-			this.terminalBinding ||
-			this.getUsed(runtime) !== baseInfo.getUsed(runtime)
+	/**
+	 * @param {Callback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	seal(callback) {
+		const finalCallback = err => {
+			this.factorizeQueue.clear();
+			this.buildQueue.clear();
+			this.rebuildQueue.clear();
+			this.processDependenciesQueue.clear();
+			this.addModuleQueue.clear();
+			return callback(err);
+		};
+		const chunkGraph = new ChunkGraph(
+			this.moduleGraph,
+			this.outputOptions.hashFunction
 		);
-	}
+		this.chunkGraph = chunkGraph;
 
-	updateHash(hash, runtime) {
-		this._updateHash(hash, runtime, new Set());
-	}
+		if (this._backCompat) {
+			for (const module of this.modules) {
+				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+			}
+		}
 
-	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		hash.update(
-			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
-				this.terminalBinding
-			}`
-		);
-		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
-			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
+		this.hooks.seal.call();
+
+		this.logger.time("optimize dependencies");
+		while (this.hooks.optimizeDependencies.call(this.modules)) {
+			/* empty */
 		}
-	}
+		this.hooks.afterOptimizeDependencies.call(this.modules);
+		this.logger.timeEnd("optimize dependencies");
 
-	getUsedInfo() {
-		if (this._globalUsed !== undefined) {
-			switch (this._globalUsed) {
-				case UsageState.Unused:
-					return "unused";
-				case UsageState.NoInfo:
-					return "no usage info";
-				case UsageState.Unknown:
-					return "maybe used (runtime-defined)";
-				case UsageState.Used:
-					return "used";
-				case UsageState.OnlyPropertiesUsed:
-					return "only properties used";
+		this.logger.time("create chunks");
+		this.hooks.beforeChunks.call();
+		this.moduleGraph.freeze("seal");
+		/** @type {Map<Entrypoint, Module[]>} */
+		const chunkGraphInit = new Map();
+		for (const [name, { dependencies, includeDependencies, options }] of this
+			.entries) {
+			const chunk = this.addChunk(name);
+			if (options.filename) {
+				chunk.filenameTemplate = options.filename;
 			}
-		} else if (this._usedInRuntime !== undefined) {
-			/** @type {Map<RuntimeUsageStateType, string[]>} */
-			const map = new Map();
-			for (const [runtime, used] of this._usedInRuntime) {
-				const list = map.get(used);
-				if (list !== undefined) list.push(runtime);
-				else map.set(used, [runtime]);
+			const entrypoint = new Entrypoint(options);
+			if (!options.dependOn && !options.runtime) {
+				entrypoint.setRuntimeChunk(chunk);
 			}
-			const specificInfo = Array.from(map, ([used, runtimes]) => {
-				switch (used) {
-					case UsageState.NoInfo:
-						return `no usage info in ${runtimes.join(", ")}`;
-					case UsageState.Unknown:
-						return `maybe used in ${runtimes.join(", ")} (runtime-defined)`;
-					case UsageState.Used:
-						return `used in ${runtimes.join(", ")}`;
-					case UsageState.OnlyPropertiesUsed:
-						return `only properties used in ${runtimes.join(", ")}`;
+			entrypoint.setEntrypointChunk(chunk);
+			this.namedChunkGroups.set(name, entrypoint);
+			this.entrypoints.set(name, entrypoint);
+			this.chunkGroups.push(entrypoint);
+			connectChunkGroupAndChunk(entrypoint, chunk);
+
+			const entryModules = new Set();
+			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
+				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
+
+				const module = this.moduleGraph.getModule(dep);
+				if (module) {
+					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+					entryModules.add(module);
+					const modulesList = chunkGraphInit.get(entrypoint);
+					if (modulesList === undefined) {
+						chunkGraphInit.set(entrypoint, [module]);
+					} else {
+						modulesList.push(module);
+					}
 				}
-			});
-			if (specificInfo.length > 0) {
-				return specificInfo.join("; ");
 			}
-		}
-		return this._hasUseInRuntimeInfo ? "unused" : "no usage info";
-	}
 
-	getProvidedInfo() {
-		switch (this.provided) {
-			case undefined:
-				return "no provided info";
-			case null:
-				return "maybe provided (runtime-defined)";
-			case true:
-				return "provided";
-			case false:
-				return "not provided";
-		}
-	}
+			this.assignDepths(entryModules);
 
-	getRenameInfo() {
-		if (this._usedName !== null && this._usedName !== this.name) {
-			return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`;
+			const mapAndSort = deps =>
+				deps
+					.map(dep => this.moduleGraph.getModule(dep))
+					.filter(Boolean)
+					.sort(compareModulesByIdentifier);
+			const includedModules = [
+				...mapAndSort(this.globalEntry.includeDependencies),
+				...mapAndSort(includeDependencies)
+			];
+
+			let modulesList = chunkGraphInit.get(entrypoint);
+			if (modulesList === undefined) {
+				chunkGraphInit.set(entrypoint, (modulesList = []));
+			}
+			for (const module of includedModules) {
+				this.assignDepth(module);
+				modulesList.push(module);
+			}
 		}
-		switch (this.canMangleProvide) {
-			case undefined:
-				switch (this.canMangleUse) {
-					case undefined:
-						return "missing provision and use info prevents renaming";
-					case false:
-						return "usage prevents renaming (no provision info)";
-					case true:
-						return "missing provision info prevents renaming";
+		const runtimeChunks = new Set();
+		outer: for (const [
+			name,
+			{
+				options: { dependOn, runtime }
+			}
+		] of this.entries) {
+			if (dependOn && runtime) {
+				const err =
+					new WebpackError(`Entrypoint '${name}' has 'dependOn' and 'runtime' specified. This is not valid.
+Entrypoints that depend on other entrypoints do not have their own runtime.
+They will use the runtime(s) from referenced entrypoints instead.
+Remove the 'runtime' option from the entrypoint.`);
+				const entry = this.entrypoints.get(name);
+				err.chunk = entry.getEntrypointChunk();
+				this.errors.push(err);
+			}
+			if (dependOn) {
+				const entry = this.entrypoints.get(name);
+				const referencedChunks = entry
+					.getEntrypointChunk()
+					.getAllReferencedChunks();
+				const dependOnEntries = [];
+				for (const dep of dependOn) {
+					const dependency = this.entrypoints.get(dep);
+					if (!dependency) {
+						throw new Error(
+							`Entry ${name} depends on ${dep}, but this entry was not found`
+						);
+					}
+					if (referencedChunks.has(dependency.getEntrypointChunk())) {
+						const err = new WebpackError(
+							`Entrypoints '${name}' and '${dep}' use 'dependOn' to depend on each other in a circular way.`
+						);
+						const entryChunk = entry.getEntrypointChunk();
+						err.chunk = entryChunk;
+						this.errors.push(err);
+						entry.setRuntimeChunk(entryChunk);
+						continue outer;
+					}
+					dependOnEntries.push(dependency);
 				}
-				break;
-			case true:
-				switch (this.canMangleUse) {
-					case undefined:
-						return "missing usage info prevents renaming";
-					case false:
-						return "usage prevents renaming";
-					case true:
-						return "could be renamed";
+				for (const dependency of dependOnEntries) {
+					connectChunkGroupParentAndChild(dependency, entry);
 				}
-				break;
-			case false:
-				switch (this.canMangleUse) {
-					case undefined:
-						return "provision prevents renaming (no use info)";
-					case false:
-						return "usage and provision prevents renaming";
-					case true:
-						return "provision prevents renaming";
+			} else if (runtime) {
+				const entry = this.entrypoints.get(name);
+				let chunk = this.namedChunks.get(runtime);
+				if (chunk) {
+					if (!runtimeChunks.has(chunk)) {
+						const err =
+							new WebpackError(`Entrypoint '${name}' has a 'runtime' option which points to another entrypoint named '${runtime}'.
+It's not valid to use other entrypoints as runtime chunk.
+Did you mean to use 'dependOn: ${JSON.stringify(
+								runtime
+							)}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
+Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
+						const entryChunk = entry.getEntrypointChunk();
+						err.chunk = entryChunk;
+						this.errors.push(err);
+						entry.setRuntimeChunk(entryChunk);
+						continue;
+					}
+				} else {
+					chunk = this.addChunk(runtime);
+					chunk.preventIntegration = true;
+					runtimeChunks.add(chunk);
 				}
-				break;
+				entry.unshiftChunk(chunk);
+				chunk.addGroup(entry);
+				entry.setRuntimeChunk(chunk);
+			}
 		}
-		throw new Error(
-			`Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}`
-		);
-	}
-}
+		buildChunkGraph(this, chunkGraphInit);
+		this.hooks.afterChunks.call(this.chunks);
+		this.logger.timeEnd("create chunks");
 
-module.exports = ExportsInfo;
-module.exports.ExportInfo = ExportInfo;
-module.exports.UsageState = UsageState;
+		this.logger.time("optimize");
+		this.hooks.optimize.call();
 
+		while (this.hooks.optimizeModules.call(this.modules)) {
+			/* empty */
+		}
+		this.hooks.afterOptimizeModules.call(this.modules);
 
-/***/ }),
+		while (this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups)) {
+			/* empty */
+		}
+		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
 
-/***/ 7145:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {
+			if (err) {
+				return finalCallback(
+					makeWebpackError(err, "Compilation.hooks.optimizeTree")
+				);
+			}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			this.hooks.afterOptimizeTree.call(this.chunks, this.modules);
 
+			this.hooks.optimizeChunkModules.callAsync(
+				this.chunks,
+				this.modules,
+				err => {
+					if (err) {
+						return finalCallback(
+							makeWebpackError(err, "Compilation.hooks.optimizeChunkModules")
+						);
+					}
 
+					this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);
 
-const ConstDependency = __webpack_require__(76911);
-const ExportsInfoDependency = __webpack_require__(78988);
+					const shouldRecord = this.hooks.shouldRecord.call() !== false;
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+					this.hooks.reviveModules.call(this.modules, this.records);
+					this.hooks.beforeModuleIds.call(this.modules);
+					this.hooks.moduleIds.call(this.modules);
+					this.hooks.optimizeModuleIds.call(this.modules);
+					this.hooks.afterOptimizeModuleIds.call(this.modules);
 
-class ExportsInfoApiPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ExportsInfoApiPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ExportsInfoDependency,
-					new ExportsInfoDependency.Template()
-				);
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					parser.hooks.expressionMemberChain
-						.for("__webpack_exports_info__")
-						.tap("ExportsInfoApiPlugin", (expr, members) => {
-							const dep =
-								members.length >= 2
-									? new ExportsInfoDependency(
-											expr.range,
-											members.slice(0, -1),
-											members[members.length - 1]
-									  )
-									: new ExportsInfoDependency(expr.range, null, members[0]);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-							return true;
-						});
-					parser.hooks.expression
-						.for("__webpack_exports_info__")
-						.tap("ExportsInfoApiPlugin", expr => {
-							const dep = new ConstDependency("true", expr.range);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ExportsInfoApiPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ExportsInfoApiPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ExportsInfoApiPlugin", handler);
-			}
-		);
-	}
-}
+					this.hooks.reviveChunks.call(this.chunks, this.records);
+					this.hooks.beforeChunkIds.call(this.chunks);
+					this.hooks.chunkIds.call(this.chunks);
+					this.hooks.optimizeChunkIds.call(this.chunks);
+					this.hooks.afterOptimizeChunkIds.call(this.chunks);
 
-module.exports = ExportsInfoApiPlugin;
+					this.assignRuntimeIds();
 
+					this.logger.time("compute affected modules with chunk graph");
+					this._computeAffectedModulesWithChunkGraph();
+					this.logger.timeEnd("compute affected modules with chunk graph");
 
-/***/ }),
+					this.sortItemsWithChunkIds();
 
-/***/ 73071:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					if (shouldRecord) {
+						this.hooks.recordModules.call(this.modules, this.records);
+						this.hooks.recordChunks.call(this.chunks, this.records);
+					}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					this.hooks.optimizeCodeGeneration.call(this.modules);
+					this.logger.timeEnd("optimize");
 
+					this.logger.time("module hashing");
+					this.hooks.beforeModuleHash.call();
+					this.createModuleHashes();
+					this.hooks.afterModuleHash.call();
+					this.logger.timeEnd("module hashing");
 
+					this.logger.time("code generation");
+					this.hooks.beforeCodeGeneration.call();
+					this.codeGeneration(err => {
+						if (err) {
+							return finalCallback(err);
+						}
+						this.hooks.afterCodeGeneration.call();
+						this.logger.timeEnd("code generation");
 
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const ConcatenationScope = __webpack_require__(98229);
-const { UsageState } = __webpack_require__(63686);
-const InitFragment = __webpack_require__(55870);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const StaticExportsDependency = __webpack_require__(91418);
-const createHash = __webpack_require__(49835);
-const extractUrlAndGlobal = __webpack_require__(11850);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { register } = __webpack_require__(8282);
+						this.logger.time("runtime requirements");
+						this.hooks.beforeRuntimeRequirements.call();
+						this.processRuntimeRequirements();
+						this.hooks.afterRuntimeRequirements.call();
+						this.logger.timeEnd("runtime requirements");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {typeof import("./util/Hash")} HashConstructor */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+						this.logger.time("hashing");
+						this.hooks.beforeHash.call();
+						const codeGenerationJobs = this.createHash();
+						this.hooks.afterHash.call();
+						this.logger.timeEnd("hashing");
 
-/**
- * @typedef {Object} SourceData
- * @property {boolean=} iife
- * @property {string=} init
- * @property {string} expression
- * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {ReadonlySet<string>=} runtimeRequirements
- */
+						this._runCodeGenerationJobs(codeGenerationJobs, err => {
+							if (err) {
+								return finalCallback(err);
+							}
 
-const TYPES = new Set(["javascript"]);
-const CSS_TYPES = new Set(["css-import"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
-const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
-const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
-	RuntimeGlobals.definePropertyGetters
-]);
-const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
+							if (shouldRecord) {
+								this.logger.time("record hash");
+								this.hooks.recordHash.call(this.records);
+								this.logger.timeEnd("record hash");
+							}
 
-/**
- * @param {string|string[]} variableName the variable name or path
- * @param {string} type the module system
- * @returns {SourceData} the generated source
- */
-const getSourceForGlobalVariableExternal = (variableName, type) => {
-	if (!Array.isArray(variableName)) {
-		// make it an array as the look up works the same basically
-		variableName = [variableName];
-	}
+							this.logger.time("module assets");
+							this.clearAssets();
 
-	// needed for e.g. window["some"]["thing"]
-	const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join("");
-	return {
-		iife: type === "this",
-		expression: `${type}${objectLookup}`
-	};
-};
+							this.hooks.beforeModuleAssets.call();
+							this.createModuleAssets();
+							this.logger.timeEnd("module assets");
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @returns {SourceData} the generated source
- */
-const getSourceForCommonJsExternal = moduleAndSpecifiers => {
-	if (!Array.isArray(moduleAndSpecifiers)) {
-		return {
-			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
-		};
-	}
-	const moduleName = moduleAndSpecifiers[0];
-	return {
-		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
-			moduleAndSpecifiers,
-			1
-		)}`
-	};
-};
+							const cont = () => {
+								this.logger.time("process assets");
+								this.hooks.processAssets.callAsync(this.assets, err => {
+									if (err) {
+										return finalCallback(
+											makeWebpackError(err, "Compilation.hooks.processAssets")
+										);
+									}
+									this.hooks.afterProcessAssets.call(this.assets);
+									this.logger.timeEnd("process assets");
+									this.assets = this._backCompat
+										? soonFrozenObjectDeprecation(
+												this.assets,
+												"Compilation.assets",
+												"DEP_WEBPACK_COMPILATION_ASSETS",
+												`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
+	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
+										  )
+										: Object.freeze(this.assets);
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @returns {SourceData} the generated source
- */
-const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
-	const chunkInitFragments = [
-		new InitFragment(
-			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
-			InitFragment.STAGE_HARMONY_IMPORTS,
-			0,
-			"external module node-commonjs"
-		)
-	];
-	if (!Array.isArray(moduleAndSpecifiers)) {
-		return {
-			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
-				moduleAndSpecifiers
-			)})`,
-			chunkInitFragments
-		};
-	}
-	const moduleName = moduleAndSpecifiers[0];
-	return {
-		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
-			moduleName
-		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
-		chunkInitFragments
-	};
-};
+									this.summarizeDependencies();
+									if (shouldRecord) {
+										this.hooks.record.call(this, this.records);
+									}
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
- */
-const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
-	const importName = runtimeTemplate.outputOptions.importFunctionName;
-	if (!runtimeTemplate.supportsDynamicImport() && importName === "import") {
-		throw new Error(
-			"The target environment doesn't support 'import()' so it's not possible to use external type 'import'"
-		);
-	}
-	if (!Array.isArray(moduleAndSpecifiers)) {
-		return {
-			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers)});`
-		};
-	}
-	if (moduleAndSpecifiers.length === 1) {
-		return {
-			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers[0])});`
-		};
+									if (this.hooks.needAdditionalSeal.call()) {
+										this.unseal();
+										return this.seal(callback);
+									}
+									return this.hooks.afterSeal.callAsync(err => {
+										if (err) {
+											return finalCallback(
+												makeWebpackError(err, "Compilation.hooks.afterSeal")
+											);
+										}
+										this.fileSystemInfo.logStatistics();
+										finalCallback();
+									});
+								});
+							};
+
+							this.logger.time("create chunk assets");
+							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
+								this.hooks.beforeChunkAssets.call();
+								this.createChunkAssets(err => {
+									this.logger.timeEnd("create chunk assets");
+									if (err) {
+										return finalCallback(err);
+									}
+									cont();
+								});
+							} else {
+								this.logger.timeEnd("create chunk assets");
+								cont();
+							}
+						});
+					});
+				}
+			);
+		});
 	}
-	const moduleName = moduleAndSpecifiers[0];
-	return {
-		expression: `${importName}(${JSON.stringify(
-			moduleName
-		)}).then(${runtimeTemplate.returningFunction(
-			`module${propertyAccess(moduleAndSpecifiers, 1)}`,
-			"module"
-		)});`
-	};
-};
 
-class ModuleExternalInitFragment extends InitFragment {
 	/**
-	 * @param {string} request import source
-	 * @param {string=} ident recomputed ident
-	 * @param {string | HashConstructor=} hashFunction the hash function to use
+	 * @param {Module} module module to report from
+	 * @param {DependenciesBlock[]} blocks blocks to report from
+	 * @returns {boolean} true, when it has warnings or errors
 	 */
-	constructor(request, ident, hashFunction = "md4") {
-		if (ident === undefined) {
-			ident = Template.toIdentifier(request);
-			if (ident !== request) {
-				ident += `_${createHash(hashFunction)
-					.update(request)
-					.digest("hex")
-					.slice(0, 8)}`;
-			}
-		}
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
-		super(
-			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
-			InitFragment.STAGE_HARMONY_IMPORTS,
-			0,
-			`external module import ${ident}`
-		);
-		this._ident = ident;
-		this._identifier = identifier;
-		this._request = request;
-	}
+	reportDependencyErrorsAndWarnings(module, blocks) {
+		let hasProblems = false;
+		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+			const block = blocks[indexBlock];
+			const dependencies = block.dependencies;
 
-	getNamespaceIdentifier() {
-		return this._identifier;
-	}
-}
+			for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {
+				const d = dependencies[indexDep];
 
-register(
-	ModuleExternalInitFragment,
-	"webpack/lib/ExternalModule",
-	"ModuleExternalInitFragment",
-	{
-		serialize(obj, { write }) {
-			write(obj._request);
-			write(obj._ident);
-		},
-		deserialize({ read }) {
-			return new ModuleExternalInitFragment(read(), read());
+				const warnings = d.getWarnings(this.moduleGraph);
+				if (warnings) {
+					for (let indexWar = 0; indexWar < warnings.length; indexWar++) {
+						const w = warnings[indexWar];
+
+						const warning = new ModuleDependencyWarning(module, w, d.loc);
+						this.warnings.push(warning);
+						hasProblems = true;
+					}
+				}
+				const errors = d.getErrors(this.moduleGraph);
+				if (errors) {
+					for (let indexErr = 0; indexErr < errors.length; indexErr++) {
+						const e = errors[indexErr];
+
+						const error = new ModuleDependencyError(module, e, d.loc);
+						this.errors.push(error);
+						hasProblems = true;
+					}
+				}
+			}
+
+			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
+				hasProblems = true;
 		}
+		return hasProblems;
 	}
-);
 
-const generateModuleRemapping = (input, exportsInfo, runtime) => {
-	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
-		const properties = [];
-		for (const exportInfo of exportsInfo.orderedExports) {
-			const used = exportInfo.getUsedName(exportInfo.name, runtime);
-			if (!used) continue;
-			const nestedInfo = exportInfo.getNestedExportsInfo();
-			if (nestedInfo) {
-				const nestedExpr = generateModuleRemapping(
-					`${input}${propertyAccess([exportInfo.name])}`,
-					nestedInfo
-				);
-				if (nestedExpr) {
-					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
-					continue;
+	codeGeneration(callback) {
+		const { chunkGraph } = this;
+		this.codeGenerationResults = new CodeGenerationResults(
+			this.outputOptions.hashFunction
+		);
+		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		const jobs = [];
+		for (const module of this.modules) {
+			const runtimes = chunkGraph.getModuleRuntimes(module);
+			if (runtimes.size === 1) {
+				for (const runtime of runtimes) {
+					const hash = chunkGraph.getModuleHash(module, runtime);
+					jobs.push({ module, hash, runtime, runtimes: [runtime] });
+				}
+			} else if (runtimes.size > 1) {
+				/** @type {Map<string, { runtimes: RuntimeSpec[] }>} */
+				const map = new Map();
+				for (const runtime of runtimes) {
+					const hash = chunkGraph.getModuleHash(module, runtime);
+					const job = map.get(hash);
+					if (job === undefined) {
+						const newJob = { module, hash, runtime, runtimes: [runtime] };
+						jobs.push(newJob);
+						map.set(hash, newJob);
+					} else {
+						job.runtimes.push(runtime);
+					}
 				}
 			}
-			properties.push(
-				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
-					exportInfo.name
-				])}`
-			);
 		}
-		return `x({ ${properties.join(", ")} })`;
+
+		this._runCodeGenerationJobs(jobs, callback);
 	}
-};
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @param {ExportsInfo} exportsInfo exports info of this module
- * @param {RuntimeSpec} runtime the runtime
- * @param {string | HashConstructor=} hashFunction the hash function to use
- * @returns {SourceData} the generated source
- */
-const getSourceForModuleExternal = (
-	moduleAndSpecifiers,
-	exportsInfo,
-	runtime,
-	hashFunction
-) => {
-	if (!Array.isArray(moduleAndSpecifiers))
-		moduleAndSpecifiers = [moduleAndSpecifiers];
-	const initFragment = new ModuleExternalInitFragment(
-		moduleAndSpecifiers[0],
-		undefined,
-		hashFunction
-	);
-	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
-		moduleAndSpecifiers,
-		1
-	)}`;
-	const moduleRemapping = generateModuleRemapping(
-		baseAccess,
-		exportsInfo,
-		runtime
-	);
-	let expression = moduleRemapping || baseAccess;
-	return {
-		expression,
-		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
-		runtimeRequirements: moduleRemapping
-			? RUNTIME_REQUIREMENTS_FOR_MODULE
-			: undefined,
-		chunkInitFragments: [initFragment]
-	};
-};
-
-/**
- * @param {string|string[]} urlAndGlobal the script request
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
- */
-const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
-	if (typeof urlAndGlobal === "string") {
-		urlAndGlobal = extractUrlAndGlobal(urlAndGlobal);
-	}
-	const url = urlAndGlobal[0];
-	const globalName = urlAndGlobal[1];
-	return {
-		init: "var __webpack_error__ = new Error();",
-		expression: `new Promise(${runtimeTemplate.basicFunction(
-			"resolve, reject",
-			[
-				`if(typeof ${globalName} !== "undefined") return resolve();`,
-				`${RuntimeGlobals.loadScript}(${JSON.stringify(
-					url
-				)}, ${runtimeTemplate.basicFunction("event", [
-					`if(typeof ${globalName} !== "undefined") return resolve();`,
-					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-					"var realSrc = event && event.target && event.target.src;",
-					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
-					"__webpack_error__.name = 'ScriptExternalLoadError';",
-					"__webpack_error__.type = errorType;",
-					"__webpack_error__.request = realSrc;",
-					"reject(__webpack_error__);"
-				])}, ${JSON.stringify(globalName)});`
-			]
-		)}).then(${runtimeTemplate.returningFunction(
-			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
-		)})`,
-		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
-	};
-};
-
-/**
- * @param {string} variableName the variable name to check
- * @param {string} request the request path
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {string} the generated source
- */
-const checkExternalVariable = (variableName, request, runtimeTemplate) => {
-	return `if(typeof ${variableName} === 'undefined') { ${runtimeTemplate.throwMissingModuleErrorBlock(
-		{ request }
-	)} }\n`;
-};
-
-/**
- * @param {string|number} id the module id
- * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
- */
-const getSourceForAmdOrUmdExternal = (
-	id,
-	optional,
-	request,
-	runtimeTemplate
-) => {
-	const externalVariable = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-		`${id}`
-	)}__`;
-	return {
-		init: optional
-			? checkExternalVariable(
-					externalVariable,
-					Array.isArray(request) ? request.join(".") : request,
-					runtimeTemplate
-			  )
-			: undefined,
-		expression: externalVariable
-	};
-};
-
-/**
- * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
- */
-const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
-	if (!Array.isArray(request)) {
-		// make it an array as the look up works the same basically
-		request = [request];
-	}
-
-	const variableName = request[0];
-	const objectLookup = propertyAccess(request, 1);
-	return {
-		init: optional
-			? checkExternalVariable(variableName, request.join("."), runtimeTemplate)
-			: undefined,
-		expression: `${variableName}${objectLookup}`
-	};
-};
-
-class ExternalModule extends Module {
-	constructor(request, type, userRequest) {
-		super("javascript/dynamic", null);
-
-		// Info from Factory
-		/** @type {string | string[] | Record<string, string | string[]>} */
-		this.request = request;
-		/** @type {string} */
-		this.externalType = type;
-		/** @type {string} */
-		this.userRequest = userRequest;
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return this.externalType === "css-import" ? CSS_TYPES : TYPES;
-	}
-
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return this.userRequest;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk which condition should be checked
-	 * @param {Compilation} compilation the compilation
-	 * @returns {boolean} true, if the chunk is ok for the module
-	 */
-	chunkCondition(chunk, { chunkGraph }) {
-		return this.externalType === "css-import"
-			? true
-			: chunkGraph.getNumberOfEntryModules(chunk) > 0;
+	_runCodeGenerationJobs(jobs, callback) {
+		let statModulesFromCache = 0;
+		let statModulesGenerated = 0;
+		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
+			this;
+		const results = this.codeGenerationResults;
+		const errors = [];
+		/** @type {Set<Module> | undefined} */
+		let notCodeGeneratedModules = undefined;
+		const runIteration = () => {
+			let delayedJobs = [];
+			let delayedModules = new Set();
+			asyncLib.eachLimit(
+				jobs,
+				this.options.parallelism,
+				(job, callback) => {
+					const { module } = job;
+					const { codeGenerationDependencies } = module;
+					if (codeGenerationDependencies !== undefined) {
+						if (
+							notCodeGeneratedModules === undefined ||
+							codeGenerationDependencies.some(dep => {
+								const referencedModule = moduleGraph.getModule(dep);
+								return notCodeGeneratedModules.has(referencedModule);
+							})
+						) {
+							delayedJobs.push(job);
+							delayedModules.add(module);
+							return callback();
+						}
+					}
+					const { hash, runtime, runtimes } = job;
+					this._codeGenerationModule(
+						module,
+						runtime,
+						runtimes,
+						hash,
+						dependencyTemplates,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						errors,
+						results,
+						(err, codeGenerated) => {
+							if (codeGenerated) statModulesGenerated++;
+							else statModulesFromCache++;
+							callback(err);
+						}
+					);
+				},
+				err => {
+					if (err) return callback(err);
+					if (delayedJobs.length > 0) {
+						if (delayedJobs.length === jobs.length) {
+							return callback(
+								new Error(
+									`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
+										delayedModules,
+										m => m.identifier()
+									).join(", ")}`
+								)
+							);
+						}
+						jobs = delayedJobs;
+						delayedJobs = [];
+						notCodeGeneratedModules = delayedModules;
+						delayedModules = new Set();
+						return runIteration();
+					}
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
+						}
+					}
+					this.logger.log(
+						`${Math.round(
+							(100 * statModulesGenerated) /
+								(statModulesGenerated + statModulesFromCache)
+						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
+					);
+					callback();
+				}
+			);
+		};
+		runIteration();
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {Module} module module
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {RuntimeSpec[]} runtimes runtimes
+	 * @param {string} hash hash
+	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
+	 * @param {ChunkGraph} chunkGraph chunkGraph
+	 * @param {ModuleGraph} moduleGraph moduleGraph
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+	 * @param {WebpackError[]} errors errors
+	 * @param {CodeGenerationResults} results results
+	 * @param {function(WebpackError=, boolean=): void} callback callback
 	 */
-	identifier() {
-		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
+	_codeGenerationModule(
+		module,
+		runtime,
+		runtimes,
+		hash,
+		dependencyTemplates,
+		chunkGraph,
+		moduleGraph,
+		runtimeTemplate,
+		errors,
+		results,
+		callback
+	) {
+		let codeGenerated = false;
+		const cache = new MultiItemCache(
+			runtimes.map(runtime =>
+				this._codeGenerationCache.getItemCache(
+					`${module.identifier()}|${getRuntimeKey(runtime)}`,
+					`${hash}|${dependencyTemplates.getHash()}`
+				)
+			)
+		);
+		cache.get((err, cachedResult) => {
+			if (err) return callback(err);
+			let result;
+			if (!cachedResult) {
+				try {
+					codeGenerated = true;
+					this.codeGeneratedModules.add(module);
+					result = module.codeGeneration({
+						chunkGraph,
+						moduleGraph,
+						dependencyTemplates,
+						runtimeTemplate,
+						runtime,
+						codeGenerationResults: results
+					});
+				} catch (err) {
+					errors.push(new CodeGenerationError(module, err));
+					result = cachedResult = {
+						sources: new Map(),
+						runtimeRequirements: null
+					};
+				}
+			} else {
+				result = cachedResult;
+			}
+			for (const runtime of runtimes) {
+				results.add(module, runtime, result);
+			}
+			if (!cachedResult) {
+				cache.store(result, err => callback(err, codeGenerated));
+			} else {
+				callback(null, codeGenerated);
+			}
+		});
 	}
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return "external " + JSON.stringify(this.request);
+	_getChunkGraphEntries() {
+		/** @type {Set<Chunk>} */
+		const treeEntries = new Set();
+		for (const ep of this.entrypoints.values()) {
+			const chunk = ep.getRuntimeChunk();
+			if (chunk) treeEntries.add(chunk);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			const chunk = ep.getRuntimeChunk();
+			if (chunk) treeEntries.add(chunk);
+		}
+		return treeEntries;
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {Object} options options
+	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
+	 * @param {Iterable<Module>=} options.modules modules
+	 * @param {Iterable<Chunk>=} options.chunks chunks
+	 * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults
+	 * @param {Iterable<Chunk>=} options.chunkGraphEntries chunkGraphEntries
 	 * @returns {void}
 	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
-	}
+	processRuntimeRequirements({
+		chunkGraph = this.chunkGraph,
+		modules = this.modules,
+		chunks = this.chunks,
+		codeGenerationResults = this.codeGenerationResults,
+		chunkGraphEntries = this._getChunkGraphEntries()
+	} = {}) {
+		const context = { chunkGraph, codeGenerationResults };
+		const { moduleMemCaches2 } = this;
+		this.logger.time("runtime requirements.modules");
+		const additionalModuleRuntimeRequirements =
+			this.hooks.additionalModuleRuntimeRequirements;
+		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
+		for (const module of modules) {
+			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
+				const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
+				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+					if (memCache) {
+						const cached = memCache.get(
+							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
+						);
+						if (cached !== undefined) {
+							if (cached !== null) {
+								chunkGraph.addModuleRuntimeRequirements(
+									module,
+									runtime,
+									cached,
+									false
+								);
+							}
+							continue;
+						}
+					}
+					let set;
+					const runtimeRequirements =
+						codeGenerationResults.getRuntimeRequirements(module, runtime);
+					if (runtimeRequirements && runtimeRequirements.size > 0) {
+						set = new Set(runtimeRequirements);
+					} else if (additionalModuleRuntimeRequirements.isUsed()) {
+						set = new Set();
+					} else {
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
+						}
+						continue;
+					}
+					additionalModuleRuntimeRequirements.call(module, set, context);
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {
-			async: false,
-			exportsType: undefined
-		};
-		this.buildInfo = {
-			strict: true,
-			topLevelDeclarations: new Set(),
-			module: compilation.outputOptions.module
-		};
-		const { request, externalType } = this._getRequestAndExternalType();
-		this.buildMeta.exportsType = "dynamic";
-		let canMangle = false;
-		this.clearDependenciesAndBlocks();
-		switch (externalType) {
-			case "this":
-				this.buildInfo.strict = false;
-				break;
-			case "system":
-				if (!Array.isArray(request) || request.length === 1) {
-					this.buildMeta.exportsType = "namespace";
-					canMangle = true;
-				}
-				break;
-			case "module":
-				if (this.buildInfo.module) {
-					if (!Array.isArray(request) || request.length === 1) {
-						this.buildMeta.exportsType = "namespace";
-						canMangle = true;
+					for (const r of set) {
+						const hook = runtimeRequirementInModule.get(r);
+						if (hook !== undefined) hook.call(module, set, context);
 					}
-				} else {
-					this.buildMeta.async = true;
-					if (!Array.isArray(request) || request.length === 1) {
-						this.buildMeta.exportsType = "namespace";
-						canMangle = false;
+					if (set.size === 0) {
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
+						}
+					} else {
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								set
+							);
+							chunkGraph.addModuleRuntimeRequirements(
+								module,
+								runtime,
+								set,
+								false
+							);
+						} else {
+							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+						}
 					}
 				}
-				break;
-			case "script":
-			case "promise":
-				this.buildMeta.async = true;
-				break;
-			case "import":
-				this.buildMeta.async = true;
-				if (!Array.isArray(request) || request.length === 1) {
-					this.buildMeta.exportsType = "namespace";
-					canMangle = false;
-				}
-				break;
+			}
 		}
-		this.addDependency(new StaticExportsDependency(true, canMangle));
-		callback();
-	}
+		this.logger.timeEnd("runtime requirements.modules");
 
-	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
-	}
+		this.logger.time("runtime requirements.chunks");
+		for (const chunk of chunks) {
+			const set = new Set();
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+					module,
+					chunk.runtime
+				);
+				for (const r of runtimeRequirements) set.add(r);
+			}
+			this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context);
 
-	/**
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason({ moduleGraph }) {
-		switch (this.externalType) {
-			case "amd":
-			case "amd-require":
-			case "umd":
-			case "umd2":
-			case "system":
-			case "jsonp":
-				return `${this.externalType} externals can't be concatenated`;
+			for (const r of set) {
+				this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context);
+			}
+
+			chunkGraph.addChunkRuntimeRequirements(chunk, set);
 		}
-		return undefined;
-	}
+		this.logger.timeEnd("runtime requirements.chunks");
 
-	_getRequestAndExternalType() {
-		let { request, externalType } = this;
-		if (typeof request === "object" && !Array.isArray(request))
-			request = request[externalType];
-		return { request, externalType };
-	}
-
-	_getSourceData(
-		request,
-		externalType,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime
-	) {
-		switch (externalType) {
-			case "this":
-			case "window":
-			case "self":
-				return getSourceForGlobalVariableExternal(request, this.externalType);
-			case "global":
-				return getSourceForGlobalVariableExternal(
-					request,
-					runtimeTemplate.globalObject
-				);
-			case "commonjs":
-			case "commonjs2":
-			case "commonjs-module":
-			case "commonjs-static":
-				return getSourceForCommonJsExternal(request);
-			case "node-commonjs":
-				return this.buildInfo.module
-					? getSourceForCommonJsExternalInNodeModule(request)
-					: getSourceForCommonJsExternal(request);
-			case "amd":
-			case "amd-require":
-			case "umd":
-			case "umd2":
-			case "system":
-			case "jsonp": {
-				const id = chunkGraph.getModuleId(this);
-				return getSourceForAmdOrUmdExternal(
-					id !== null ? id : this.identifier(),
-					this.isOptional(moduleGraph),
-					request,
-					runtimeTemplate
-				);
+		this.logger.time("runtime requirements.entries");
+		for (const treeEntry of chunkGraphEntries) {
+			const set = new Set();
+			for (const chunk of treeEntry.getAllReferencedChunks()) {
+				const runtimeRequirements =
+					chunkGraph.getChunkRuntimeRequirements(chunk);
+				for (const r of runtimeRequirements) set.add(r);
 			}
-			case "import":
-				return getSourceForImportExternal(request, runtimeTemplate);
-			case "script":
-				return getSourceForScriptExternal(request, runtimeTemplate);
-			case "module": {
-				if (!this.buildInfo.module) {
-					if (!runtimeTemplate.supportsDynamicImport()) {
-						throw new Error(
-							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
-								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
-									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
-									: "")
-						);
-					}
-					return getSourceForImportExternal(request, runtimeTemplate);
-				}
-				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
-					throw new Error(
-						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
-					);
-				}
-				return getSourceForModuleExternal(
-					request,
-					moduleGraph.getExportsInfo(this),
-					runtime,
-					runtimeTemplate.outputOptions.hashFunction
-				);
+
+			this.hooks.additionalTreeRuntimeRequirements.call(
+				treeEntry,
+				set,
+				context
+			);
+
+			for (const r of set) {
+				this.hooks.runtimeRequirementInTree
+					.for(r)
+					.call(treeEntry, set, context);
 			}
-			case "var":
-			case "promise":
-			case "const":
-			case "let":
-			case "assign":
-			default:
-				return getSourceForDefaultCase(
-					this.isOptional(moduleGraph),
-					request,
-					runtimeTemplate
-				);
+
+			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
 		}
+		this.logger.timeEnd("runtime requirements.entries");
 	}
 
+	// TODO webpack 6 make chunkGraph argument non-optional
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {Chunk} chunk target chunk
+	 * @param {RuntimeModule} module runtime module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
 	 */
-	codeGeneration({
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime,
-		concatenationScope
-	}) {
-		const { request, externalType } = this._getRequestAndExternalType();
-		switch (externalType) {
-			case "asset": {
-				const sources = new Map();
-				sources.set(
-					"javascript",
-					new RawSource(`module.exports = ${JSON.stringify(request)};`)
-				);
-				const data = new Map();
-				data.set("url", request);
-				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
-			}
-			case "css-import": {
-				const sources = new Map();
-				sources.set(
-					"css-import",
-					new RawSource(`@import url(${JSON.stringify(request)});`)
-				);
-				return {
-					sources,
-					runtimeRequirements: EMPTY_RUNTIME_REQUIREMENTS
-				};
+	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
+		// Deprecated ModuleGraph association
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+
+		// add it to the list
+		this.modules.add(module);
+		this._modules.set(module.identifier(), module);
+
+		// connect to the chunk graph
+		chunkGraph.connectChunkAndModule(chunk, module);
+		chunkGraph.connectChunkAndRuntimeModule(chunk, module);
+		if (module.fullHash) {
+			chunkGraph.addFullHashModuleToChunk(chunk, module);
+		} else if (module.dependentHash) {
+			chunkGraph.addDependentHashModuleToChunk(chunk, module);
+		}
+
+		// attach runtime module
+		module.attach(this, chunk, chunkGraph);
+
+		// Setup internals
+		const exportsInfo = this.moduleGraph.getExportsInfo(module);
+		exportsInfo.setHasProvideInfo();
+		if (typeof chunk.runtime === "string") {
+			exportsInfo.setUsedForSideEffectsOnly(chunk.runtime);
+		} else if (chunk.runtime === undefined) {
+			exportsInfo.setUsedForSideEffectsOnly(undefined);
+		} else {
+			for (const runtime of chunk.runtime) {
+				exportsInfo.setUsedForSideEffectsOnly(runtime);
 			}
-			default: {
-				const sourceData = this._getSourceData(
-					request,
-					externalType,
-					runtimeTemplate,
-					moduleGraph,
-					chunkGraph,
-					runtime
-				);
+		}
+		chunkGraph.addModuleRuntimeRequirements(
+			module,
+			chunk.runtime,
+			new Set([RuntimeGlobals.requireScope])
+		);
 
-				let sourceString = sourceData.expression;
-				if (sourceData.iife)
-					sourceString = `(function() { return ${sourceString}; }())`;
-				if (concatenationScope) {
-					sourceString = `${
-						runtimeTemplate.supportsConst() ? "const" : "var"
-					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
-					concatenationScope.registerNamespaceExport(
-						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-					);
-				} else {
-					sourceString = `module.exports = ${sourceString};`;
-				}
-				if (sourceData.init)
-					sourceString = `${sourceData.init}\n${sourceString}`;
+		// runtime modules don't need ids
+		chunkGraph.setModuleId(module, "");
 
-				let data = undefined;
-				if (sourceData.chunkInitFragments) {
-					data = new Map();
-					data.set("chunkInitFragments", sourceData.chunkInitFragments);
-				}
+		// Call hook
+		this.hooks.runtimeModule.call(module, chunk);
+	}
 
-				const sources = new Map();
-				if (this.useSourceMap || this.useSimpleSourceMap) {
-					sources.set(
-						"javascript",
-						new OriginalSource(sourceString, this.identifier())
-					);
-				} else {
-					sources.set("javascript", new RawSource(sourceString));
+	/**
+	 * If `module` is passed, `loc` and `request` must also be passed.
+	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
+	 * @param {Module=} module the module the references the chunk group
+	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
+	 * @param {string=} request the request from which the the chunk group is referenced
+	 * @returns {ChunkGroup} the new or existing chunk group
+	 */
+	addChunkInGroup(groupOptions, module, loc, request) {
+		if (typeof groupOptions === "string") {
+			groupOptions = { name: groupOptions };
+		}
+		const name = groupOptions.name;
+
+		if (name) {
+			const chunkGroup = this.namedChunkGroups.get(name);
+			if (chunkGroup !== undefined) {
+				chunkGroup.addOptions(groupOptions);
+				if (module) {
+					chunkGroup.addOrigin(module, loc, request);
 				}
+				return chunkGroup;
+			}
+		}
+		const chunkGroup = new ChunkGroup(groupOptions);
+		if (module) chunkGroup.addOrigin(module, loc, request);
+		const chunk = this.addChunk(name);
 
-				let runtimeRequirements = sourceData.runtimeRequirements;
-				if (!concatenationScope) {
-					if (!runtimeRequirements) {
-						runtimeRequirements = RUNTIME_REQUIREMENTS;
-					} else {
-						const set = new Set(runtimeRequirements);
-						set.add(RuntimeGlobals.module);
-						runtimeRequirements = set;
+		connectChunkGroupAndChunk(chunkGroup, chunk);
+
+		this.chunkGroups.push(chunkGroup);
+		if (name) {
+			this.namedChunkGroups.set(name, chunkGroup);
+		}
+		return chunkGroup;
+	}
+
+	/**
+	 * @param {EntryOptions} options options for the entrypoint
+	 * @param {Module} module the module the references the chunk group
+	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
+	 * @param {string} request the request from which the the chunk group is referenced
+	 * @returns {Entrypoint} the new or existing entrypoint
+	 */
+	addAsyncEntrypoint(options, module, loc, request) {
+		const name = options.name;
+		if (name) {
+			const entrypoint = this.namedChunkGroups.get(name);
+			if (entrypoint instanceof Entrypoint) {
+				if (entrypoint !== undefined) {
+					if (module) {
+						entrypoint.addOrigin(module, loc, request);
 					}
+					return entrypoint;
 				}
-
-				return {
-					sources,
-					runtimeRequirements:
-						runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
-					data
-				};
+			} else if (entrypoint) {
+				throw new Error(
+					`Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name`
+				);
 			}
 		}
+		const chunk = this.addChunk(name);
+		if (options.filename) {
+			chunk.filenameTemplate = options.filename;
+		}
+		const entrypoint = new Entrypoint(options, false);
+		entrypoint.setRuntimeChunk(chunk);
+		entrypoint.setEntrypointChunk(chunk);
+		if (name) {
+			this.namedChunkGroups.set(name, entrypoint);
+		}
+		this.chunkGroups.push(entrypoint);
+		this.asyncEntrypoints.push(entrypoint);
+		connectChunkGroupAndChunk(entrypoint, chunk);
+		if (module) {
+			entrypoint.addOrigin(module, loc, request);
+		}
+		return entrypoint;
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * This method first looks to see if a name is provided for a new chunk,
+	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
+	 *
+	 * @param {string=} name optional chunk name to be provided
+	 * @returns {Chunk} create a chunk (invoked during seal event)
 	 */
-	size(type) {
-		return 42;
+	addChunk(name) {
+		if (name) {
+			const chunk = this.namedChunks.get(name);
+			if (chunk !== undefined) {
+				return chunk;
+			}
+		}
+		const chunk = new Chunk(name, this._backCompat);
+		this.chunks.add(chunk);
+		if (this._backCompat)
+			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
+		if (name) {
+			this.namedChunks.set(name, chunk);
+		}
+		return chunk;
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * @deprecated
+	 * @param {Module} module module to assign depth
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		const { chunkGraph } = context;
-		hash.update(
-			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
-				chunkGraph.moduleGraph
-			)}`
-		);
-		super.updateHash(hash, context);
-	}
-
-	serialize(context) {
-		const { write } = context;
+	assignDepth(module) {
+		const moduleGraph = this.moduleGraph;
 
-		write(this.request);
-		write(this.externalType);
-		write(this.userRequest);
+		const queue = new Set([module]);
+		let depth;
 
-		super.serialize(context);
-	}
+		moduleGraph.setDepth(module, 0);
 
-	deserialize(context) {
-		const { read } = context;
+		/**
+		 * @param {Module} module module for processing
+		 * @returns {void}
+		 */
+		const processModule = module => {
+			if (!moduleGraph.setDepthIfLower(module, depth)) return;
+			queue.add(module);
+		};
 
-		this.request = read();
-		this.externalType = read();
-		this.userRequest = read();
+		for (module of queue) {
+			queue.delete(module);
+			depth = moduleGraph.getDepth(module) + 1;
 
-		super.deserialize(context);
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const refModule = connection.module;
+				if (refModule) {
+					processModule(refModule);
+				}
+			}
+		}
 	}
-}
-
-makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
-
-module.exports = ExternalModule;
 
+	/**
+	 * @param {Set<Module>} modules module to assign depth
+	 * @returns {void}
+	 */
+	assignDepths(modules) {
+		const moduleGraph = this.moduleGraph;
 
-/***/ }),
-
-/***/ 62153:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const util = __webpack_require__(73837);
-const ExternalModule = __webpack_require__(73071);
-const { resolveByProperty, cachedSetProperty } = __webpack_require__(60839);
-
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-
-const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
-const EMPTY_RESOLVE_OPTIONS = {};
-
-// TODO webpack 6 remove this
-const callDeprecatedExternals = util.deprecate(
-	(externalsFunction, context, request, cb) => {
-		externalsFunction.call(null, context, request, cb);
-	},
-	"The externals-function should be defined like ({context, request}, cb) => { ... }",
-	"DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS"
-);
-
-const cache = new WeakMap();
+		/** @type {Set<Module | number>} */
+		const queue = new Set(modules);
+		queue.add(1);
+		let depth = 0;
 
-const resolveLayer = (obj, layer) => {
-	let map = cache.get(obj);
-	if (map === undefined) {
-		map = new Map();
-		cache.set(obj, map);
-	} else {
-		const cacheEntry = map.get(layer);
-		if (cacheEntry !== undefined) return cacheEntry;
+		let i = 0;
+		for (const module of queue) {
+			i++;
+			if (typeof module === "number") {
+				depth = module;
+				if (queue.size === i) return;
+				queue.add(depth + 1);
+			} else {
+				moduleGraph.setDepth(module, depth);
+				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
+					module
+				)) {
+					if (refModule) {
+						queue.add(refModule);
+					}
+				}
+			}
+		}
 	}
-	const result = resolveByProperty(obj, "byLayer", layer);
-	map.set(layer, result);
-	return result;
-};
 
-class ExternalModuleFactoryPlugin {
 	/**
-	 * @param {string | undefined} type default external type
-	 * @param {Externals} externals externals config
+	 * @param {Dependency} dependency the dependency
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	constructor(type, externals) {
-		this.type = type;
-		this.externals = externals;
+	getDependencyReferencedExports(dependency, runtime) {
+		const referencedExports = dependency.getReferencedExports(
+			this.moduleGraph,
+			runtime
+		);
+		return this.hooks.dependencyReferencedExports.call(
+			referencedExports,
+			dependency,
+			runtime
+		);
 	}
 
 	/**
-	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+	 *
+	 * @param {Module} module module relationship for removal
+	 * @param {DependenciesBlockLike} block //TODO: good description
 	 * @returns {void}
 	 */
-	apply(normalModuleFactory) {
-		const globalType = this.type;
-		normalModuleFactory.hooks.factorize.tapAsync(
-			"ExternalModuleFactoryPlugin",
-			(data, callback) => {
-				const context = data.context;
-				const contextInfo = data.contextInfo;
-				const dependency = data.dependencies[0];
-				const dependencyType = data.dependencyType;
+	removeReasonsOfDependencyBlock(module, block) {
+		if (block.blocks) {
+			for (const b of block.blocks) {
+				this.removeReasonsOfDependencyBlock(module, b);
+			}
+		}
 
-				/**
-				 * @param {string|string[]|boolean|Record<string, string|string[]>} value the external config
-				 * @param {string|undefined} type type of external
-				 * @param {function(Error=, ExternalModule=): void} callback callback
-				 * @returns {void}
-				 */
-				const handleExternal = (value, type, callback) => {
-					if (value === false) {
-						// Not externals, fallback to original factory
-						return callback();
-					}
-					/** @type {string | string[] | Record<string, string|string[]>} */
-					let externalConfig;
-					if (value === true) {
-						externalConfig = dependency.request;
-					} else {
-						externalConfig = value;
-					}
-					// When no explicit type is specified, extract it from the externalConfig
-					if (type === undefined) {
-						if (
-							typeof externalConfig === "string" &&
-							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig)
-						) {
-							const idx = externalConfig.indexOf(" ");
-							type = externalConfig.substr(0, idx);
-							externalConfig = externalConfig.substr(idx + 1);
-						} else if (
-							Array.isArray(externalConfig) &&
-							externalConfig.length > 0 &&
-							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig[0])
-						) {
-							const firstItem = externalConfig[0];
-							const idx = firstItem.indexOf(" ");
-							type = firstItem.substr(0, idx);
-							externalConfig = [
-								firstItem.substr(idx + 1),
-								...externalConfig.slice(1)
-							];
-						}
-					}
-					callback(
-						null,
-						new ExternalModule(
-							externalConfig,
-							type || globalType,
-							dependency.request
-						)
-					);
-				};
-
-				/**
-				 * @param {Externals} externals externals config
-				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
-				 * @returns {void}
-				 */
-				const handleExternals = (externals, callback) => {
-					if (typeof externals === "string") {
-						if (externals === dependency.request) {
-							return handleExternal(dependency.request, undefined, callback);
-						}
-					} else if (Array.isArray(externals)) {
-						let i = 0;
-						const next = () => {
-							let asyncFlag;
-							const handleExternalsAndCallback = (err, module) => {
-								if (err) return callback(err);
-								if (!module) {
-									if (asyncFlag) {
-										asyncFlag = false;
-										return;
-									}
-									return next();
-								}
-								callback(null, module);
-							};
-
-							do {
-								asyncFlag = true;
-								if (i >= externals.length) return callback();
-								handleExternals(externals[i++], handleExternalsAndCallback);
-							} while (!asyncFlag);
-							asyncFlag = false;
-						};
+		if (block.dependencies) {
+			for (const dep of block.dependencies) {
+				const originalModule = this.moduleGraph.getModule(dep);
+				if (originalModule) {
+					this.moduleGraph.removeConnection(dep);
 
-						next();
-						return;
-					} else if (externals instanceof RegExp) {
-						if (externals.test(dependency.request)) {
-							return handleExternal(dependency.request, undefined, callback);
-						}
-					} else if (typeof externals === "function") {
-						const cb = (err, value, type) => {
-							if (err) return callback(err);
-							if (value !== undefined) {
-								handleExternal(value, type, callback);
-							} else {
-								callback();
-							}
-						};
-						if (externals.length === 3) {
-							// TODO webpack 6 remove this
-							callDeprecatedExternals(
-								externals,
-								context,
-								dependency.request,
-								cb
-							);
-						} else {
-							const promise = externals(
-								{
-									context,
-									request: dependency.request,
-									dependencyType,
-									contextInfo,
-									getResolve: options => (context, request, callback) => {
-										const resolveContext = {
-											fileDependencies: data.fileDependencies,
-											missingDependencies: data.missingDependencies,
-											contextDependencies: data.contextDependencies
-										};
-										let resolver = normalModuleFactory.getResolver(
-											"normal",
-											dependencyType
-												? cachedSetProperty(
-														data.resolveOptions || EMPTY_RESOLVE_OPTIONS,
-														"dependencyType",
-														dependencyType
-												  )
-												: data.resolveOptions
-										);
-										if (options) resolver = resolver.withOptions(options);
-										if (callback) {
-											resolver.resolve(
-												{},
-												context,
-												request,
-												resolveContext,
-												callback
-											);
-										} else {
-											return new Promise((resolve, reject) => {
-												resolver.resolve(
-													{},
-													context,
-													request,
-													resolveContext,
-													(err, result) => {
-														if (err) reject(err);
-														else resolve(result);
-													}
-												);
-											});
-										}
-									}
-								},
-								cb
-							);
-							if (promise && promise.then) promise.then(r => cb(null, r), cb);
-						}
-						return;
-					} else if (typeof externals === "object") {
-						const resolvedExternals = resolveLayer(
-							externals,
-							contextInfo.issuerLayer
-						);
-						if (
-							Object.prototype.hasOwnProperty.call(
-								resolvedExternals,
-								dependency.request
-							)
-						) {
-							return handleExternal(
-								resolvedExternals[dependency.request],
-								undefined,
-								callback
-							);
+					if (this.chunkGraph) {
+						for (const chunk of this.chunkGraph.getModuleChunks(
+							originalModule
+						)) {
+							this.patchChunksAfterReasonRemoval(originalModule, chunk);
 						}
 					}
-					callback();
-				};
-
-				handleExternals(this.externals, callback);
+				}
 			}
-		);
+		}
 	}
-}
-module.exports = ExternalModuleFactoryPlugin;
-
-
-/***/ }),
-
-/***/ 6652:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
 
-const ExternalModuleFactoryPlugin = __webpack_require__(62153);
-
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./Compiler")} Compiler */
-
-class ExternalsPlugin {
 	/**
-	 * @param {string | undefined} type default external type
-	 * @param {Externals} externals externals config
+	 * @param {Module} module module to patch tie
+	 * @param {Chunk} chunk chunk to patch tie
+	 * @returns {void}
 	 */
-	constructor(type, externals) {
-		this.type = type;
-		this.externals = externals;
+	patchChunksAfterReasonRemoval(module, chunk) {
+		if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
+			this.removeReasonsOfDependencyBlock(module, module);
+		}
+		if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
+			if (this.chunkGraph.isModuleInChunk(module, chunk)) {
+				this.chunkGraph.disconnectChunkAndModule(chunk, module);
+				this.removeChunkFromDependencies(module, chunk);
+			}
+		}
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 *
+	 * @param {DependenciesBlock} block block tie for Chunk
+	 * @param {Chunk} chunk chunk to remove from dep
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
-			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
-				normalModuleFactory
-			);
-		});
-	}
-}
-
-module.exports = ExternalsPlugin;
-
-
-/***/ }),
-
-/***/ 79453:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { create: createResolver } = __webpack_require__(9256);
-const asyncLib = __webpack_require__(78175);
-const AsyncQueue = __webpack_require__(12260);
-const StackedCacheMap = __webpack_require__(64985);
-const createHash = __webpack_require__(49835);
-const { join, dirname, relative, lstatReadlinkAbsolute } = __webpack_require__(17139);
-const makeSerializable = __webpack_require__(33032);
-const processAsyncTree = __webpack_require__(42791);
-
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {typeof import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").IStats} IStats */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const supportsEsm = +process.versions.modules >= 83;
-
-let FS_ACCURACY = 2000;
-
-const EMPTY_SET = new Set();
-
-const RBDT_RESOLVE_CJS = 0;
-const RBDT_RESOLVE_ESM = 1;
-const RBDT_RESOLVE_DIRECTORY = 2;
-const RBDT_RESOLVE_CJS_FILE = 3;
-const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4;
-const RBDT_RESOLVE_ESM_FILE = 5;
-const RBDT_DIRECTORY = 6;
-const RBDT_FILE = 7;
-const RBDT_DIRECTORY_DEPENDENCIES = 8;
-const RBDT_FILE_DEPENDENCIES = 9;
-
-const INVALID = Symbol("invalid");
-
-/**
- * @typedef {Object} FileSystemInfoEntry
- * @property {number} safeTime
- * @property {number=} timestamp
- */
-
-/**
- * @typedef {Object} ResolvedContextFileSystemInfoEntry
- * @property {number} safeTime
- * @property {string=} timestampHash
- */
-
-/**
- * @typedef {Object} ContextFileSystemInfoEntry
- * @property {number} safeTime
- * @property {string=} timestampHash
- * @property {ResolvedContextFileSystemInfoEntry=} resolved
- * @property {Set<string>=} symlinks
- */
+	removeChunkFromDependencies(block, chunk) {
+		/**
+		 * @param {Dependency} d dependency to (maybe) patch up
+		 */
+		const iteratorDependency = d => {
+			const depModule = this.moduleGraph.getModule(d);
+			if (!depModule) {
+				return;
+			}
+			this.patchChunksAfterReasonRemoval(depModule, chunk);
+		};
 
-/**
- * @typedef {Object} TimestampAndHash
- * @property {number} safeTime
- * @property {number=} timestamp
- * @property {string} hash
- */
+		const blocks = block.blocks;
+		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+			const asyncBlock = blocks[indexBlock];
+			const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
+			// Grab all chunks from the first Block's AsyncDepBlock
+			const chunks = chunkGroup.chunks;
+			// For each chunk in chunkGroup
+			for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+				const iteratedChunk = chunks[indexChunk];
+				chunkGroup.removeChunk(iteratedChunk);
+				// Recurse
+				this.removeChunkFromDependencies(block, iteratedChunk);
+			}
+		}
 
-/**
- * @typedef {Object} ResolvedContextTimestampAndHash
- * @property {number} safeTime
- * @property {string=} timestampHash
- * @property {string} hash
- */
+		if (block.dependencies) {
+			for (const dep of block.dependencies) iteratorDependency(dep);
+		}
+	}
 
-/**
- * @typedef {Object} ContextTimestampAndHash
- * @property {number} safeTime
- * @property {string=} timestampHash
- * @property {string} hash
- * @property {ResolvedContextTimestampAndHash=} resolved
- * @property {Set<string>=} symlinks
- */
+	assignRuntimeIds() {
+		const { chunkGraph } = this;
+		const processEntrypoint = ep => {
+			const runtime = ep.options.runtime || ep.name;
+			const chunk = ep.getRuntimeChunk();
+			chunkGraph.setRuntimeId(runtime, chunk.id);
+		};
+		for (const ep of this.entrypoints.values()) {
+			processEntrypoint(ep);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			processEntrypoint(ep);
+		}
+	}
 
-/**
- * @typedef {Object} ContextHash
- * @property {string} hash
- * @property {string=} resolved
- * @property {Set<string>=} symlinks
- */
+	sortItemsWithChunkIds() {
+		for (const chunkGroup of this.chunkGroups) {
+			chunkGroup.sortItems();
+		}
 
-/**
- * @typedef {Object} SnapshotOptimizationEntry
- * @property {Snapshot} snapshot
- * @property {number} shared
- * @property {Set<string>} snapshotContent
- * @property {Set<SnapshotOptimizationEntry>} children
- */
+		this.errors.sort(compareErrors);
+		this.warnings.sort(compareErrors);
+		this.children.sort(byNameOrHash);
+	}
 
-/**
- * @typedef {Object} ResolveBuildDependenciesResult
- * @property {Set<string>} files list of files
- * @property {Set<string>} directories list of directories
- * @property {Set<string>} missing list of missing entries
- * @property {Map<string, string | false>} resolveResults stored resolve results
- * @property {Object} resolveDependencies dependencies of the resolving
- * @property {Set<string>} resolveDependencies.files list of files
- * @property {Set<string>} resolveDependencies.directories list of directories
- * @property {Set<string>} resolveDependencies.missing list of missing entries
- */
+	summarizeDependencies() {
+		for (
+			let indexChildren = 0;
+			indexChildren < this.children.length;
+			indexChildren++
+		) {
+			const child = this.children[indexChildren];
 
-const DONE_ITERATOR_RESULT = new Set().keys().next();
+			this.fileDependencies.addAll(child.fileDependencies);
+			this.contextDependencies.addAll(child.contextDependencies);
+			this.missingDependencies.addAll(child.missingDependencies);
+			this.buildDependencies.addAll(child.buildDependencies);
+		}
 
-// cspell:word tshs
-// Tsh = Timestamp + Hash
-// Tshs = Timestamp + Hash combinations
+		for (const module of this.modules) {
+			module.addCacheDependencies(
+				this.fileDependencies,
+				this.contextDependencies,
+				this.missingDependencies,
+				this.buildDependencies
+			);
+		}
+	}
 
-class SnapshotIterator {
-	constructor(next) {
-		this.next = next;
+	createModuleHashes() {
+		let statModulesHashed = 0;
+		let statModulesFromCache = 0;
+		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
+		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
+		for (const module of this.modules) {
+			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
+			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				if (memCache) {
+					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
+					if (digest !== undefined) {
+						chunkGraph.setModuleHashes(
+							module,
+							runtime,
+							digest,
+							digest.substr(0, hashDigestLength)
+						);
+						statModulesFromCache++;
+						continue;
+					}
+				}
+				statModulesHashed++;
+				const digest = this._createModuleHash(
+					module,
+					chunkGraph,
+					runtime,
+					hashFunction,
+					runtimeTemplate,
+					hashDigest,
+					hashDigestLength
+				);
+				if (memCache) {
+					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+				}
+			}
+		}
+		this.logger.log(
+			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
+				Math.round(
+					(100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
+				) / 100
+			} variants per module in average)`
+		);
 	}
-}
 
-class SnapshotIterable {
-	constructor(snapshot, getMaps) {
-		this.snapshot = snapshot;
-		this.getMaps = getMaps;
+	_createModuleHash(
+		module,
+		chunkGraph,
+		runtime,
+		hashFunction,
+		runtimeTemplate,
+		hashDigest,
+		hashDigestLength
+	) {
+		const moduleHash = createHash(hashFunction);
+		module.updateHash(moduleHash, {
+			chunkGraph,
+			runtime,
+			runtimeTemplate
+		});
+		const moduleHashDigest = /** @type {string} */ (
+			moduleHash.digest(hashDigest)
+		);
+		chunkGraph.setModuleHashes(
+			module,
+			runtime,
+			moduleHashDigest,
+			moduleHashDigest.substr(0, hashDigestLength)
+		);
+		return moduleHashDigest;
 	}
 
-	[Symbol.iterator]() {
-		let state = 0;
-		/** @type {IterableIterator<string>} */
-		let it;
-		/** @type {(Snapshot) => (Map<string, any> | Set<string>)[]} */
-		let getMaps;
-		/** @type {(Map<string, any> | Set<string>)[]} */
-		let maps;
-		/** @type {Snapshot} */
-		let snapshot;
-		let queue;
-		return new SnapshotIterator(() => {
-			for (;;) {
-				switch (state) {
-					case 0:
-						snapshot = this.snapshot;
-						getMaps = this.getMaps;
-						maps = getMaps(snapshot);
-						state = 1;
-					/* falls through */
-					case 1:
-						if (maps.length > 0) {
-							const map = maps.pop();
-							if (map !== undefined) {
-								it = map.keys();
-								state = 2;
-							} else {
-								break;
-							}
-						} else {
-							state = 3;
-							break;
-						}
-					/* falls through */
-					case 2: {
-						const result = it.next();
-						if (!result.done) return result;
-						state = 1;
-						break;
+	createHash() {
+		this.logger.time("hashing: initialize hash");
+		const chunkGraph = this.chunkGraph;
+		const runtimeTemplate = this.runtimeTemplate;
+		const outputOptions = this.outputOptions;
+		const hashFunction = outputOptions.hashFunction;
+		const hashDigest = outputOptions.hashDigest;
+		const hashDigestLength = outputOptions.hashDigestLength;
+		const hash = createHash(hashFunction);
+		if (outputOptions.hashSalt) {
+			hash.update(outputOptions.hashSalt);
+		}
+		this.logger.timeEnd("hashing: initialize hash");
+		if (this.children.length > 0) {
+			this.logger.time("hashing: hash child compilations");
+			for (const child of this.children) {
+				hash.update(child.hash);
+			}
+			this.logger.timeEnd("hashing: hash child compilations");
+		}
+		if (this.warnings.length > 0) {
+			this.logger.time("hashing: hash warnings");
+			for (const warning of this.warnings) {
+				hash.update(`${warning.message}`);
+			}
+			this.logger.timeEnd("hashing: hash warnings");
+		}
+		if (this.errors.length > 0) {
+			this.logger.time("hashing: hash errors");
+			for (const error of this.errors) {
+				hash.update(`${error.message}`);
+			}
+			this.logger.timeEnd("hashing: hash errors");
+		}
+
+		this.logger.time("hashing: sort chunks");
+		/*
+		 * all non-runtime chunks need to be hashes first,
+		 * since runtime chunk might use their hashes.
+		 * runtime chunks need to be hashed in the correct order
+		 * since they may depend on each other (for async entrypoints).
+		 * So we put all non-runtime chunks first and hash them in any order.
+		 * And order runtime chunks according to referenced between each other.
+		 * Chunks need to be in deterministic order since we add hashes to full chunk
+		 * during these hashing.
+		 */
+		/** @type {Chunk[]} */
+		const unorderedRuntimeChunks = [];
+		/** @type {Chunk[]} */
+		const otherChunks = [];
+		for (const c of this.chunks) {
+			if (c.hasRuntime()) {
+				unorderedRuntimeChunks.push(c);
+			} else {
+				otherChunks.push(c);
+			}
+		}
+		unorderedRuntimeChunks.sort(byId);
+		otherChunks.sort(byId);
+
+		/** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
+		/** @type {Map<Chunk, RuntimeChunkInfo>} */
+		const runtimeChunksMap = new Map();
+		for (const chunk of unorderedRuntimeChunks) {
+			runtimeChunksMap.set(chunk, {
+				chunk,
+				referencedBy: [],
+				remaining: 0
+			});
+		}
+		let remaining = 0;
+		for (const info of runtimeChunksMap.values()) {
+			for (const other of new Set(
+				Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
+					e => e.chunks[e.chunks.length - 1]
+				)
+			)) {
+				const otherInfo = runtimeChunksMap.get(other);
+				otherInfo.referencedBy.push(info);
+				info.remaining++;
+				remaining++;
+			}
+		}
+		/** @type {Chunk[]} */
+		const runtimeChunks = [];
+		for (const info of runtimeChunksMap.values()) {
+			if (info.remaining === 0) {
+				runtimeChunks.push(info.chunk);
+			}
+		}
+		// If there are any references between chunks
+		// make sure to follow these chains
+		if (remaining > 0) {
+			const readyChunks = [];
+			for (const chunk of runtimeChunks) {
+				const hasFullHashModules =
+					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
+				const info = runtimeChunksMap.get(chunk);
+				for (const otherInfo of info.referencedBy) {
+					if (hasFullHashModules) {
+						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
 					}
-					case 3: {
-						const children = snapshot.children;
-						if (children !== undefined) {
-							if (children.size === 1) {
-								// shortcut for a single child
-								// avoids allocation of queue
-								for (const child of children) snapshot = child;
-								maps = getMaps(snapshot);
-								state = 1;
-								break;
-							}
-							if (queue === undefined) queue = [];
-							for (const child of children) {
-								queue.push(child);
-							}
-						}
-						if (queue !== undefined && queue.length > 0) {
-							snapshot = queue.pop();
-							maps = getMaps(snapshot);
-							state = 1;
-							break;
-						} else {
-							state = 4;
+					remaining--;
+					if (--otherInfo.remaining === 0) {
+						readyChunks.push(otherInfo.chunk);
+					}
+				}
+				if (readyChunks.length > 0) {
+					// This ensures deterministic ordering, since referencedBy is non-deterministic
+					readyChunks.sort(byId);
+					for (const c of readyChunks) runtimeChunks.push(c);
+					readyChunks.length = 0;
+				}
+			}
+		}
+		// If there are still remaining references we have cycles and want to create a warning
+		if (remaining > 0) {
+			let circularRuntimeChunkInfo = [];
+			for (const info of runtimeChunksMap.values()) {
+				if (info.remaining !== 0) {
+					circularRuntimeChunkInfo.push(info);
+				}
+			}
+			circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
+			const err =
+				new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
+					circularRuntimeChunkInfo,
+					c => c.chunk.name || c.chunk.id
+				).join(", ")})
+This prevents using hashes of each other and should be avoided.`);
+			err.chunk = circularRuntimeChunkInfo[0].chunk;
+			this.warnings.push(err);
+			for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
+		}
+		this.logger.timeEnd("hashing: sort chunks");
+
+		const fullHashChunks = new Set();
+		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		const codeGenerationJobs = [];
+		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
+		const codeGenerationJobsMap = new Map();
+
+		const processChunk = chunk => {
+			// Last minute module hash generation for modules that depend on chunk hashes
+			this.logger.time("hashing: hash runtime modules");
+			const runtime = chunk.runtime;
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!chunkGraph.hasModuleHashes(module, runtime)) {
+					const hash = this._createModuleHash(
+						module,
+						chunkGraph,
+						runtime,
+						hashFunction,
+						runtimeTemplate,
+						hashDigest,
+						hashDigestLength
+					);
+					let hashMap = codeGenerationJobsMap.get(hash);
+					if (hashMap) {
+						const moduleJob = hashMap.get(module);
+						if (moduleJob) {
+							moduleJob.runtimes.push(runtime);
+							continue;
 						}
+					} else {
+						hashMap = new Map();
+						codeGenerationJobsMap.set(hash, hashMap);
 					}
-					/* falls through */
-					case 4:
-						return DONE_ITERATOR_RESULT;
+					const job = {
+						module,
+						hash,
+						runtime,
+						runtimes: [runtime]
+					};
+					hashMap.set(module, job);
+					codeGenerationJobs.push(job);
 				}
 			}
-		});
-	}
-}
+			this.logger.timeAggregate("hashing: hash runtime modules");
+			this.logger.time("hashing: hash chunks");
+			const chunkHash = createHash(hashFunction);
+			try {
+				if (outputOptions.hashSalt) {
+					chunkHash.update(outputOptions.hashSalt);
+				}
+				chunk.updateHash(chunkHash, chunkGraph);
+				this.hooks.chunkHash.call(chunk, chunkHash, {
+					chunkGraph,
+					moduleGraph: this.moduleGraph,
+					runtimeTemplate: this.runtimeTemplate
+				});
+				const chunkHashDigest = /** @type {string} */ (
+					chunkHash.digest(hashDigest)
+				);
+				hash.update(chunkHashDigest);
+				chunk.hash = chunkHashDigest;
+				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+				const fullHashModules =
+					chunkGraph.getChunkFullHashModulesIterable(chunk);
+				if (fullHashModules) {
+					fullHashChunks.add(chunk);
+				} else {
+					this.hooks.contentHash.call(chunk);
+				}
+			} catch (err) {
+				this.errors.push(new ChunkRenderError(chunk, "", err));
+			}
+			this.logger.timeAggregate("hashing: hash chunks");
+		};
+		otherChunks.forEach(processChunk);
+		for (const chunk of runtimeChunks) processChunk(chunk);
 
-class Snapshot {
-	constructor() {
-		this._flags = 0;
-		/** @type {number | undefined} */
-		this.startTime = undefined;
-		/** @type {Map<string, FileSystemInfoEntry | null> | undefined} */
-		this.fileTimestamps = undefined;
-		/** @type {Map<string, string | null> | undefined} */
-		this.fileHashes = undefined;
-		/** @type {Map<string, TimestampAndHash | string | null> | undefined} */
-		this.fileTshs = undefined;
-		/** @type {Map<string, ResolvedContextFileSystemInfoEntry | null> | undefined} */
-		this.contextTimestamps = undefined;
-		/** @type {Map<string, string | null> | undefined} */
-		this.contextHashes = undefined;
-		/** @type {Map<string, ResolvedContextTimestampAndHash | null> | undefined} */
-		this.contextTshs = undefined;
-		/** @type {Map<string, boolean> | undefined} */
-		this.missingExistence = undefined;
-		/** @type {Map<string, string> | undefined} */
-		this.managedItemInfo = undefined;
-		/** @type {Set<string> | undefined} */
-		this.managedFiles = undefined;
-		/** @type {Set<string> | undefined} */
-		this.managedContexts = undefined;
-		/** @type {Set<string> | undefined} */
-		this.managedMissing = undefined;
-		/** @type {Set<Snapshot> | undefined} */
-		this.children = undefined;
-	}
+		this.logger.timeAggregateEnd("hashing: hash runtime modules");
+		this.logger.timeAggregateEnd("hashing: hash chunks");
+		this.logger.time("hashing: hash digest");
+		this.hooks.fullHash.call(hash);
+		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
+		this.hash = this.fullHash.substr(0, hashDigestLength);
+		this.logger.timeEnd("hashing: hash digest");
 
-	hasStartTime() {
-		return (this._flags & 1) !== 0;
+		this.logger.time("hashing: process full hash modules");
+		for (const chunk of fullHashChunks) {
+			for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
+				const moduleHash = createHash(hashFunction);
+				module.updateHash(moduleHash, {
+					chunkGraph,
+					runtime: chunk.runtime,
+					runtimeTemplate
+				});
+				const moduleHashDigest = /** @type {string} */ (
+					moduleHash.digest(hashDigest)
+				);
+				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
+				chunkGraph.setModuleHashes(
+					module,
+					chunk.runtime,
+					moduleHashDigest,
+					moduleHashDigest.substr(0, hashDigestLength)
+				);
+				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
+			}
+			const chunkHash = createHash(hashFunction);
+			chunkHash.update(chunk.hash);
+			chunkHash.update(this.hash);
+			const chunkHashDigest = /** @type {string} */ (
+				chunkHash.digest(hashDigest)
+			);
+			chunk.hash = chunkHashDigest;
+			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+			this.hooks.contentHash.call(chunk);
+		}
+		this.logger.timeEnd("hashing: process full hash modules");
+		return codeGenerationJobs;
 	}
 
-	setStartTime(value) {
-		this._flags = this._flags | 1;
-		this.startTime = value;
+	/**
+	 * @param {string} file file name
+	 * @param {Source} source asset source
+	 * @param {AssetInfo} assetInfo extra asset information
+	 * @returns {void}
+	 */
+	emitAsset(file, source, assetInfo = {}) {
+		if (this.assets[file]) {
+			if (!isSourceEqual(this.assets[file], source)) {
+				this.errors.push(
+					new WebpackError(
+						`Conflict: Multiple assets emit different content to the same filename ${file}`
+					)
+				);
+				this.assets[file] = source;
+				this._setAssetInfo(file, assetInfo);
+				return;
+			}
+			const oldInfo = this.assetsInfo.get(file);
+			const newInfo = Object.assign({}, oldInfo, assetInfo);
+			this._setAssetInfo(file, newInfo, oldInfo);
+			return;
+		}
+		this.assets[file] = source;
+		this._setAssetInfo(file, assetInfo, undefined);
 	}
 
-	setMergedStartTime(value, snapshot) {
-		if (value) {
-			if (snapshot.hasStartTime()) {
-				this.setStartTime(Math.min(value, snapshot.startTime));
-			} else {
-				this.setStartTime(value);
-			}
+	_setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
+		if (newInfo === undefined) {
+			this.assetsInfo.delete(file);
 		} else {
-			if (snapshot.hasStartTime()) this.setStartTime(snapshot.startTime);
+			this.assetsInfo.set(file, newInfo);
+		}
+		const oldRelated = oldInfo && oldInfo.related;
+		const newRelated = newInfo && newInfo.related;
+		if (oldRelated) {
+			for (const key of Object.keys(oldRelated)) {
+				const remove = name => {
+					const relatedIn = this._assetsRelatedIn.get(name);
+					if (relatedIn === undefined) return;
+					const entry = relatedIn.get(key);
+					if (entry === undefined) return;
+					entry.delete(file);
+					if (entry.size !== 0) return;
+					relatedIn.delete(key);
+					if (relatedIn.size === 0) this._assetsRelatedIn.delete(name);
+				};
+				const entry = oldRelated[key];
+				if (Array.isArray(entry)) {
+					entry.forEach(remove);
+				} else if (entry) {
+					remove(entry);
+				}
+			}
+		}
+		if (newRelated) {
+			for (const key of Object.keys(newRelated)) {
+				const add = name => {
+					let relatedIn = this._assetsRelatedIn.get(name);
+					if (relatedIn === undefined) {
+						this._assetsRelatedIn.set(name, (relatedIn = new Map()));
+					}
+					let entry = relatedIn.get(key);
+					if (entry === undefined) {
+						relatedIn.set(key, (entry = new Set()));
+					}
+					entry.add(file);
+				};
+				const entry = newRelated[key];
+				if (Array.isArray(entry)) {
+					entry.forEach(add);
+				} else if (entry) {
+					add(entry);
+				}
+			}
 		}
 	}
 
-	hasFileTimestamps() {
-		return (this._flags & 2) !== 0;
+	/**
+	 * @param {string} file file name
+	 * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
+	 * @param {AssetInfo | function(AssetInfo | undefined): AssetInfo} assetInfoUpdateOrFunction new asset info or function converting old to new
+	 */
+	updateAsset(
+		file,
+		newSourceOrFunction,
+		assetInfoUpdateOrFunction = undefined
+	) {
+		if (!this.assets[file]) {
+			throw new Error(
+				`Called Compilation.updateAsset for not existing filename ${file}`
+			);
+		}
+		if (typeof newSourceOrFunction === "function") {
+			this.assets[file] = newSourceOrFunction(this.assets[file]);
+		} else {
+			this.assets[file] = newSourceOrFunction;
+		}
+		if (assetInfoUpdateOrFunction !== undefined) {
+			const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
+			if (typeof assetInfoUpdateOrFunction === "function") {
+				this._setAssetInfo(file, assetInfoUpdateOrFunction(oldInfo), oldInfo);
+			} else {
+				this._setAssetInfo(
+					file,
+					cachedCleverMerge(oldInfo, assetInfoUpdateOrFunction),
+					oldInfo
+				);
+			}
+		}
 	}
 
-	setFileTimestamps(value) {
-		this._flags = this._flags | 2;
-		this.fileTimestamps = value;
+	renameAsset(file, newFile) {
+		const source = this.assets[file];
+		if (!source) {
+			throw new Error(
+				`Called Compilation.renameAsset for not existing filename ${file}`
+			);
+		}
+		if (this.assets[newFile]) {
+			if (!isSourceEqual(this.assets[file], source)) {
+				this.errors.push(
+					new WebpackError(
+						`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
+					)
+				);
+			}
+		}
+		const assetInfo = this.assetsInfo.get(file);
+		// Update related in all other assets
+		const relatedInInfo = this._assetsRelatedIn.get(file);
+		if (relatedInInfo) {
+			for (const [key, assets] of relatedInInfo) {
+				for (const name of assets) {
+					const info = this.assetsInfo.get(name);
+					if (!info) continue;
+					const related = info.related;
+					if (!related) continue;
+					const entry = related[key];
+					let newEntry;
+					if (Array.isArray(entry)) {
+						newEntry = entry.map(x => (x === file ? newFile : x));
+					} else if (entry === file) {
+						newEntry = newFile;
+					} else continue;
+					this.assetsInfo.set(name, {
+						...info,
+						related: {
+							...related,
+							[key]: newEntry
+						}
+					});
+				}
+			}
+		}
+		this._setAssetInfo(file, undefined, assetInfo);
+		this._setAssetInfo(newFile, assetInfo);
+		delete this.assets[file];
+		this.assets[newFile] = source;
+		for (const chunk of this.chunks) {
+			{
+				const size = chunk.files.size;
+				chunk.files.delete(file);
+				if (size !== chunk.files.size) {
+					chunk.files.add(newFile);
+				}
+			}
+			{
+				const size = chunk.auxiliaryFiles.size;
+				chunk.auxiliaryFiles.delete(file);
+				if (size !== chunk.auxiliaryFiles.size) {
+					chunk.auxiliaryFiles.add(newFile);
+				}
+			}
+		}
 	}
 
-	hasFileHashes() {
-		return (this._flags & 4) !== 0;
-	}
-
-	setFileHashes(value) {
-		this._flags = this._flags | 4;
-		this.fileHashes = value;
-	}
-
-	hasFileTshs() {
-		return (this._flags & 8) !== 0;
-	}
-
-	setFileTshs(value) {
-		this._flags = this._flags | 8;
-		this.fileTshs = value;
-	}
-
-	hasContextTimestamps() {
-		return (this._flags & 0x10) !== 0;
-	}
-
-	setContextTimestamps(value) {
-		this._flags = this._flags | 0x10;
-		this.contextTimestamps = value;
-	}
-
-	hasContextHashes() {
-		return (this._flags & 0x20) !== 0;
-	}
-
-	setContextHashes(value) {
-		this._flags = this._flags | 0x20;
-		this.contextHashes = value;
-	}
-
-	hasContextTshs() {
-		return (this._flags & 0x40) !== 0;
+	/**
+	 * @param {string} file file name
+	 */
+	deleteAsset(file) {
+		if (!this.assets[file]) {
+			return;
+		}
+		delete this.assets[file];
+		const assetInfo = this.assetsInfo.get(file);
+		this._setAssetInfo(file, undefined, assetInfo);
+		const related = assetInfo && assetInfo.related;
+		if (related) {
+			for (const key of Object.keys(related)) {
+				const checkUsedAndDelete = file => {
+					if (!this._assetsRelatedIn.has(file)) {
+						this.deleteAsset(file);
+					}
+				};
+				const items = related[key];
+				if (Array.isArray(items)) {
+					items.forEach(checkUsedAndDelete);
+				} else if (items) {
+					checkUsedAndDelete(items);
+				}
+			}
+		}
+		// TODO If this becomes a performance problem
+		// store a reverse mapping from asset to chunk
+		for (const chunk of this.chunks) {
+			chunk.files.delete(file);
+			chunk.auxiliaryFiles.delete(file);
+		}
 	}
 
-	setContextTshs(value) {
-		this._flags = this._flags | 0x40;
-		this.contextTshs = value;
+	getAssets() {
+		/** @type {Readonly<Asset>[]} */
+		const array = [];
+		for (const assetName of Object.keys(this.assets)) {
+			if (Object.prototype.hasOwnProperty.call(this.assets, assetName)) {
+				array.push({
+					name: assetName,
+					source: this.assets[assetName],
+					info: this.assetsInfo.get(assetName) || EMPTY_ASSET_INFO
+				});
+			}
+		}
+		return array;
 	}
 
-	hasMissingExistence() {
-		return (this._flags & 0x80) !== 0;
+	/**
+	 * @param {string} name the name of the asset
+	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
+	 */
+	getAsset(name) {
+		if (!Object.prototype.hasOwnProperty.call(this.assets, name))
+			return undefined;
+		return {
+			name,
+			source: this.assets[name],
+			info: this.assetsInfo.get(name) || EMPTY_ASSET_INFO
+		};
 	}
 
-	setMissingExistence(value) {
-		this._flags = this._flags | 0x80;
-		this.missingExistence = value;
+	clearAssets() {
+		for (const chunk of this.chunks) {
+			chunk.files.clear();
+			chunk.auxiliaryFiles.clear();
+		}
 	}
 
-	hasManagedItemInfo() {
-		return (this._flags & 0x100) !== 0;
+	createModuleAssets() {
+		const { chunkGraph } = this;
+		for (const module of this.modules) {
+			if (module.buildInfo.assets) {
+				const assetsInfo = module.buildInfo.assetsInfo;
+				for (const assetName of Object.keys(module.buildInfo.assets)) {
+					const fileName = this.getPath(assetName, {
+						chunkGraph: this.chunkGraph,
+						module
+					});
+					for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+						chunk.auxiliaryFiles.add(fileName);
+					}
+					this.emitAsset(
+						fileName,
+						module.buildInfo.assets[assetName],
+						assetsInfo ? assetsInfo.get(assetName) : undefined
+					);
+					this.hooks.moduleAsset.call(module, fileName);
+				}
+			}
+		}
 	}
 
-	setManagedItemInfo(value) {
-		this._flags = this._flags | 0x100;
-		this.managedItemInfo = value;
+	/**
+	 * @param {RenderManifestOptions} options options object
+	 * @returns {RenderManifestEntry[]} manifest entries
+	 */
+	getRenderManifest(options) {
+		return this.hooks.renderManifest.call([], options);
 	}
 
-	hasManagedFiles() {
-		return (this._flags & 0x200) !== 0;
-	}
+	/**
+	 * @param {Callback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	createChunkAssets(callback) {
+		const outputOptions = this.outputOptions;
+		const cachedSourceMap = new WeakMap();
+		/** @type {Map<string, {hash: string, source: Source, chunk: Chunk}>} */
+		const alreadyWrittenFiles = new Map();
 
-	setManagedFiles(value) {
-		this._flags = this._flags | 0x200;
-		this.managedFiles = value;
-	}
+		asyncLib.forEachLimit(
+			this.chunks,
+			15,
+			(chunk, callback) => {
+				/** @type {RenderManifestEntry[]} */
+				let manifest;
+				try {
+					manifest = this.getRenderManifest({
+						chunk,
+						hash: this.hash,
+						fullHash: this.fullHash,
+						outputOptions,
+						codeGenerationResults: this.codeGenerationResults,
+						moduleTemplates: this.moduleTemplates,
+						dependencyTemplates: this.dependencyTemplates,
+						chunkGraph: this.chunkGraph,
+						moduleGraph: this.moduleGraph,
+						runtimeTemplate: this.runtimeTemplate
+					});
+				} catch (err) {
+					this.errors.push(new ChunkRenderError(chunk, "", err));
+					return callback();
+				}
+				asyncLib.forEach(
+					manifest,
+					(fileManifest, callback) => {
+						const ident = fileManifest.identifier;
+						const usedHash = fileManifest.hash;
 
-	hasManagedContexts() {
-		return (this._flags & 0x400) !== 0;
-	}
+						const assetCacheItem = this._assetsCache.getItemCache(
+							ident,
+							usedHash
+						);
 
-	setManagedContexts(value) {
-		this._flags = this._flags | 0x400;
-		this.managedContexts = value;
-	}
+						assetCacheItem.get((err, sourceFromCache) => {
+							/** @type {string | function(PathData, AssetInfo=): string} */
+							let filenameTemplate;
+							/** @type {string} */
+							let file;
+							/** @type {AssetInfo} */
+							let assetInfo;
 
-	hasManagedMissing() {
-		return (this._flags & 0x800) !== 0;
-	}
+							let inTry = true;
+							const errorAndCallback = err => {
+								const filename =
+									file ||
+									(typeof file === "string"
+										? file
+										: typeof filenameTemplate === "string"
+										? filenameTemplate
+										: "");
 
-	setManagedMissing(value) {
-		this._flags = this._flags | 0x800;
-		this.managedMissing = value;
-	}
+								this.errors.push(new ChunkRenderError(chunk, filename, err));
+								inTry = false;
+								return callback();
+							};
 
-	hasChildren() {
-		return (this._flags & 0x1000) !== 0;
-	}
+							try {
+								if ("filename" in fileManifest) {
+									file = fileManifest.filename;
+									assetInfo = fileManifest.info;
+								} else {
+									filenameTemplate = fileManifest.filenameTemplate;
+									const pathAndInfo = this.getPathWithInfo(
+										filenameTemplate,
+										fileManifest.pathOptions
+									);
+									file = pathAndInfo.path;
+									assetInfo = fileManifest.info
+										? {
+												...pathAndInfo.info,
+												...fileManifest.info
+										  }
+										: pathAndInfo.info;
+								}
 
-	setChildren(value) {
-		this._flags = this._flags | 0x1000;
-		this.children = value;
-	}
+								if (err) {
+									return errorAndCallback(err);
+								}
 
-	addChild(child) {
-		if (!this.hasChildren()) {
-			this.setChildren(new Set());
-		}
-		this.children.add(child);
-	}
+								let source = sourceFromCache;
 
-	serialize({ write }) {
-		write(this._flags);
-		if (this.hasStartTime()) write(this.startTime);
-		if (this.hasFileTimestamps()) write(this.fileTimestamps);
-		if (this.hasFileHashes()) write(this.fileHashes);
-		if (this.hasFileTshs()) write(this.fileTshs);
-		if (this.hasContextTimestamps()) write(this.contextTimestamps);
-		if (this.hasContextHashes()) write(this.contextHashes);
-		if (this.hasContextTshs()) write(this.contextTshs);
-		if (this.hasMissingExistence()) write(this.missingExistence);
-		if (this.hasManagedItemInfo()) write(this.managedItemInfo);
-		if (this.hasManagedFiles()) write(this.managedFiles);
-		if (this.hasManagedContexts()) write(this.managedContexts);
-		if (this.hasManagedMissing()) write(this.managedMissing);
-		if (this.hasChildren()) write(this.children);
-	}
+								// check if the same filename was already written by another chunk
+								const alreadyWritten = alreadyWrittenFiles.get(file);
+								if (alreadyWritten !== undefined) {
+									if (alreadyWritten.hash !== usedHash) {
+										inTry = false;
+										return callback(
+											new WebpackError(
+												`Conflict: Multiple chunks emit assets to the same filename ${file}` +
+													` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
+											)
+										);
+									} else {
+										source = alreadyWritten.source;
+									}
+								} else if (!source) {
+									// render the asset
+									source = fileManifest.render();
 
-	deserialize({ read }) {
-		this._flags = read();
-		if (this.hasStartTime()) this.startTime = read();
-		if (this.hasFileTimestamps()) this.fileTimestamps = read();
-		if (this.hasFileHashes()) this.fileHashes = read();
-		if (this.hasFileTshs()) this.fileTshs = read();
-		if (this.hasContextTimestamps()) this.contextTimestamps = read();
-		if (this.hasContextHashes()) this.contextHashes = read();
-		if (this.hasContextTshs()) this.contextTshs = read();
-		if (this.hasMissingExistence()) this.missingExistence = read();
-		if (this.hasManagedItemInfo()) this.managedItemInfo = read();
-		if (this.hasManagedFiles()) this.managedFiles = read();
-		if (this.hasManagedContexts()) this.managedContexts = read();
-		if (this.hasManagedMissing()) this.managedMissing = read();
-		if (this.hasChildren()) this.children = read();
+									// Ensure that source is a cached source to avoid additional cost because of repeated access
+									if (!(source instanceof CachedSource)) {
+										const cacheEntry = cachedSourceMap.get(source);
+										if (cacheEntry) {
+											source = cacheEntry;
+										} else {
+											const cachedSource = new CachedSource(source);
+											cachedSourceMap.set(source, cachedSource);
+											source = cachedSource;
+										}
+									}
+								}
+								this.emitAsset(file, source, assetInfo);
+								if (fileManifest.auxiliary) {
+									chunk.auxiliaryFiles.add(file);
+								} else {
+									chunk.files.add(file);
+								}
+								this.hooks.chunkAsset.call(chunk, file);
+								alreadyWrittenFiles.set(file, {
+									hash: usedHash,
+									source,
+									chunk
+								});
+								if (source !== sourceFromCache) {
+									assetCacheItem.store(source, err => {
+										if (err) return errorAndCallback(err);
+										inTry = false;
+										return callback();
+									});
+								} else {
+									inTry = false;
+									callback();
+								}
+							} catch (err) {
+								if (!inTry) throw err;
+								errorAndCallback(err);
+							}
+						});
+					},
+					callback
+				);
+			},
+			callback
+		);
 	}
 
 	/**
-	 * @param {function(Snapshot): (ReadonlyMap<string, any> | ReadonlySet<string>)[]} getMaps first
-	 * @returns {Iterable<string>} iterable
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {string} interpolated path
 	 */
-	_createIterable(getMaps) {
-		return new SnapshotIterable(this, getMaps);
+	getPath(filename, data = {}) {
+		if (!data.hash) {
+			data = {
+				hash: this.hash,
+				...data
+			};
+		}
+		return this.getAssetPath(filename, data);
 	}
 
 	/**
-	 * @returns {Iterable<string>} iterable
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
 	 */
-	getFileIterable() {
-		return this._createIterable(s => [
-			s.fileTimestamps,
-			s.fileHashes,
-			s.fileTshs,
-			s.managedFiles
-		]);
+	getPathWithInfo(filename, data = {}) {
+		if (!data.hash) {
+			data = {
+				hash: this.hash,
+				...data
+			};
+		}
+		return this.getAssetPathWithInfo(filename, data);
 	}
 
 	/**
-	 * @returns {Iterable<string>} iterable
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {string} interpolated path
 	 */
-	getContextIterable() {
-		return this._createIterable(s => [
-			s.contextTimestamps,
-			s.contextHashes,
-			s.contextTshs,
-			s.managedContexts
-		]);
+	getAssetPath(filename, data) {
+		return this.hooks.assetPath.call(
+			typeof filename === "function" ? filename(data) : filename,
+			data,
+			undefined
+		);
 	}
 
 	/**
-	 * @returns {Iterable<string>} iterable
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
 	 */
-	getMissingIterable() {
-		return this._createIterable(s => [s.missingExistence, s.managedMissing]);
+	getAssetPathWithInfo(filename, data) {
+		const assetInfo = {};
+		// TODO webpack 5: refactor assetPath hook to receive { path, info } object
+		const newPath = this.hooks.assetPath.call(
+			typeof filename === "function" ? filename(data, assetInfo) : filename,
+			data,
+			assetInfo
+		);
+		return { path: newPath, info: assetInfo };
 	}
-}
-
-makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot");
-
-const MIN_COMMON_SNAPSHOT_SIZE = 3;
 
-/**
- * @template T
- */
-class SnapshotOptimization {
-	/**
-	 * @param {function(Snapshot): boolean} has has value
-	 * @param {function(Snapshot): Map<string, T> | Set<string>} get get value
-	 * @param {function(Snapshot, Map<string, T> | Set<string>): void} set set value
-	 * @param {boolean=} useStartTime use the start time of snapshots
-	 * @param {boolean=} isSet value is an Set instead of a Map
-	 */
-	constructor(has, get, set, useStartTime = true, isSet = false) {
-		this._has = has;
-		this._get = get;
-		this._set = set;
-		this._useStartTime = useStartTime;
-		this._isSet = isSet;
-		/** @type {Map<string, SnapshotOptimizationEntry>} */
-		this._map = new Map();
-		this._statItemsShared = 0;
-		this._statItemsUnshared = 0;
-		this._statSharedSnapshots = 0;
-		this._statReusedSharedSnapshots = 0;
+	getWarnings() {
+		return this.hooks.processWarnings.call(this.warnings);
 	}
 
-	getStatisticMessage() {
-		const total = this._statItemsShared + this._statItemsUnshared;
-		if (total === 0) return undefined;
-		return `${
-			this._statItemsShared && Math.round((this._statItemsShared * 100) / total)
-		}% (${this._statItemsShared}/${total}) entries shared via ${
-			this._statSharedSnapshots
-		} shared snapshots (${
-			this._statReusedSharedSnapshots + this._statSharedSnapshots
-		} times referenced)`;
+	getErrors() {
+		return this.hooks.processErrors.call(this.errors);
 	}
 
-	clear() {
-		this._map.clear();
-		this._statItemsShared = 0;
-		this._statItemsUnshared = 0;
-		this._statSharedSnapshots = 0;
-		this._statReusedSharedSnapshots = 0;
+	/**
+	 * This function allows you to run another instance of webpack inside of webpack however as
+	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
+	 * from parent (or top level compiler) and creates a child Compilation
+	 *
+	 * @param {string} name name of the child compiler
+	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
+	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
+	 * @returns {Compiler} creates a child Compiler instance
+	 */
+	createChildCompiler(name, outputOptions, plugins) {
+		const idx = this.childrenCounters[name] || 0;
+		this.childrenCounters[name] = idx + 1;
+		return this.compiler.createChildCompiler(
+			this,
+			name,
+			idx,
+			outputOptions,
+			plugins
+		);
 	}
 
 	/**
-	 * @param {Snapshot} newSnapshot snapshot
-	 * @param {Set<string>} capturedFiles files to snapshot/share
-	 * @returns {void}
+	 * @param {Module} module the module
+	 * @param {ExecuteModuleOptions} options options
+	 * @param {ExecuteModuleCallback} callback callback
 	 */
-	optimize(newSnapshot, capturedFiles) {
-		/**
-		 * @param {SnapshotOptimizationEntry} entry optimization entry
-		 * @returns {void}
-		 */
-		const increaseSharedAndStoreOptimizationEntry = entry => {
-			if (entry.children !== undefined) {
-				entry.children.forEach(increaseSharedAndStoreOptimizationEntry);
-			}
-			entry.shared++;
-			storeOptimizationEntry(entry);
-		};
-		/**
-		 * @param {SnapshotOptimizationEntry} entry optimization entry
-		 * @returns {void}
-		 */
-		const storeOptimizationEntry = entry => {
-			for (const path of entry.snapshotContent) {
-				const old = this._map.get(path);
-				if (old.shared < entry.shared) {
-					this._map.set(path, entry);
-				}
-				capturedFiles.delete(path);
-			}
-		};
+	executeModule(module, options, callback) {
+		// Aggregate all referenced modules and ensure they are ready
+		const modules = new Set([module]);
+		processAsyncTree(
+			modules,
+			10,
+			/**
+			 * @param {Module} module the module
+			 * @param {function(Module): void} push push more jobs
+			 * @param {Callback} callback callback
+			 * @returns {void}
+			 */
+			(module, push, callback) => {
+				this.buildQueue.waitFor(module, err => {
+					if (err) return callback(err);
+					this.processDependenciesQueue.waitFor(module, err => {
+						if (err) return callback(err);
+						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
+							module
+						)) {
+							const size = modules.size;
+							modules.add(m);
+							if (modules.size !== size) push(m);
+						}
+						callback();
+					});
+				});
+			},
+			err => {
+				if (err) return callback(err);
 
-		/** @type {SnapshotOptimizationEntry} */
-		let newOptimizationEntry = undefined;
+				// Create new chunk graph, chunk and entrypoint for the build time execution
+				const chunkGraph = new ChunkGraph(
+					this.moduleGraph,
+					this.outputOptions.hashFunction
+				);
+				const runtime = "build time";
+				const { hashFunction, hashDigest, hashDigestLength } =
+					this.outputOptions;
+				const runtimeTemplate = this.runtimeTemplate;
 
-		const capturedFilesSize = capturedFiles.size;
+				const chunk = new Chunk("build time chunk", this._backCompat);
+				chunk.id = chunk.name;
+				chunk.ids = [chunk.id];
+				chunk.runtime = runtime;
 
-		/** @type {Set<SnapshotOptimizationEntry> | undefined} */
-		const optimizationEntries = new Set();
+				const entrypoint = new Entrypoint({
+					runtime,
+					chunkLoading: false,
+					...options.entryOptions
+				});
+				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+				connectChunkGroupAndChunk(entrypoint, chunk);
+				entrypoint.setRuntimeChunk(chunk);
+				entrypoint.setEntrypointChunk(chunk);
 
-		for (const path of capturedFiles) {
-			const optimizationEntry = this._map.get(path);
-			if (optimizationEntry === undefined) {
-				if (newOptimizationEntry === undefined) {
-					newOptimizationEntry = {
-						snapshot: newSnapshot,
-						shared: 0,
-						snapshotContent: undefined,
-						children: undefined
-					};
-				}
-				this._map.set(path, newOptimizationEntry);
-				continue;
-			} else {
-				optimizationEntries.add(optimizationEntry);
-			}
-		}
+				const chunks = new Set([chunk]);
 
-		optimizationEntries: for (const optimizationEntry of optimizationEntries) {
-			const snapshot = optimizationEntry.snapshot;
-			if (optimizationEntry.shared > 0) {
-				// It's a shared snapshot
-				// We can't change it, so we can only use it when all files match
-				// and startTime is compatible
-				if (
-					this._useStartTime &&
-					newSnapshot.startTime &&
-					(!snapshot.startTime || snapshot.startTime > newSnapshot.startTime)
-				) {
-					continue;
-				}
-				const nonSharedFiles = new Set();
-				const snapshotContent = optimizationEntry.snapshotContent;
-				const snapshotEntries = this._get(snapshot);
-				for (const path of snapshotContent) {
-					if (!capturedFiles.has(path)) {
-						if (!snapshotEntries.has(path)) {
-							// File is not shared and can't be removed from the snapshot
-							// because it's in a child of the snapshot
-							continue optimizationEntries;
-						}
-						nonSharedFiles.add(path);
-						continue;
-					}
-				}
-				if (nonSharedFiles.size === 0) {
-					// The complete snapshot is shared
-					// add it as child
-					newSnapshot.addChild(snapshot);
-					increaseSharedAndStoreOptimizationEntry(optimizationEntry);
-					this._statReusedSharedSnapshots++;
-				} else {
-					// Only a part of the snapshot is shared
-					const sharedCount = snapshotContent.size - nonSharedFiles.size;
-					if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {
-						// Common part it too small
-						continue optimizationEntries;
-					}
-					// Extract common timestamps from both snapshots
-					let commonMap;
-					if (this._isSet) {
-						commonMap = new Set();
-						for (const path of /** @type {Set<string>} */ (snapshotEntries)) {
-							if (nonSharedFiles.has(path)) continue;
-							commonMap.add(path);
-							snapshotEntries.delete(path);
-						}
-					} else {
-						commonMap = new Map();
-						const map = /** @type {Map<string, T>} */ (snapshotEntries);
-						for (const [path, value] of map) {
-							if (nonSharedFiles.has(path)) continue;
-							commonMap.set(path, value);
-							snapshotEntries.delete(path);
-						}
-					}
-					// Create and attach snapshot
-					const commonSnapshot = new Snapshot();
-					if (this._useStartTime) {
-						commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
-					}
-					this._set(commonSnapshot, commonMap);
-					newSnapshot.addChild(commonSnapshot);
-					snapshot.addChild(commonSnapshot);
-					// Create optimization entry
-					const newEntry = {
-						snapshot: commonSnapshot,
-						shared: optimizationEntry.shared + 1,
-						snapshotContent: new Set(commonMap.keys()),
-						children: undefined
-					};
-					if (optimizationEntry.children === undefined)
-						optimizationEntry.children = new Set();
-					optimizationEntry.children.add(newEntry);
-					storeOptimizationEntry(newEntry);
-					this._statSharedSnapshots++;
+				// Assign ids to modules and modules to the chunk
+				for (const module of modules) {
+					const id = module.identifier();
+					chunkGraph.setModuleId(module, id);
+					chunkGraph.connectChunkAndModule(chunk, module);
 				}
-			} else {
-				// It's a unshared snapshot
-				// We can extract a common shared snapshot
-				// with all common files
-				const snapshotEntries = this._get(snapshot);
-				if (snapshotEntries === undefined) {
-					// Incomplete snapshot, that can't be used
-					continue optimizationEntries;
+
+				// Hash modules
+				for (const module of modules) {
+					this._createModuleHash(
+						module,
+						chunkGraph,
+						runtime,
+						hashFunction,
+						runtimeTemplate,
+						hashDigest,
+						hashDigestLength
+					);
 				}
-				let commonMap;
-				if (this._isSet) {
-					commonMap = new Set();
-					const set = /** @type {Set<string>} */ (snapshotEntries);
-					if (capturedFiles.size < set.size) {
-						for (const path of capturedFiles) {
-							if (set.has(path)) commonMap.add(path);
+
+				const codeGenerationResults = new CodeGenerationResults(
+					this.outputOptions.hashFunction
+				);
+				/** @type {WebpackError[]} */
+				const errors = [];
+				/**
+				 * @param {Module} module the module
+				 * @param {Callback} callback callback
+				 * @returns {void}
+				 */
+				const codeGen = (module, callback) => {
+					this._codeGenerationModule(
+						module,
+						runtime,
+						[runtime],
+						chunkGraph.getModuleHash(module, runtime),
+						this.dependencyTemplates,
+						chunkGraph,
+						this.moduleGraph,
+						runtimeTemplate,
+						errors,
+						codeGenerationResults,
+						(err, codeGenerated) => {
+							callback(err);
 						}
-					} else {
-						for (const path of set) {
-							if (capturedFiles.has(path)) commonMap.add(path);
+					);
+				};
+
+				const reportErrors = () => {
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
 						}
+						errors.length = 0;
 					}
-				} else {
-					commonMap = new Map();
-					const map = /** @type {Map<string, T>} */ (snapshotEntries);
-					for (const path of capturedFiles) {
-						const ts = map.get(path);
-						if (ts === undefined) continue;
-						commonMap.set(path, ts);
-					}
-				}
+				};
 
-				if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {
-					// Common part it too small
-					continue optimizationEntries;
-				}
-				// Create and attach snapshot
-				const commonSnapshot = new Snapshot();
-				if (this._useStartTime) {
-					commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
-				}
-				this._set(commonSnapshot, commonMap);
-				newSnapshot.addChild(commonSnapshot);
-				snapshot.addChild(commonSnapshot);
-				// Remove files from snapshot
-				for (const path of commonMap.keys()) snapshotEntries.delete(path);
-				const sharedCount = commonMap.size;
-				this._statItemsUnshared -= sharedCount;
-				this._statItemsShared += sharedCount;
-				// Create optimization entry
-				storeOptimizationEntry({
-					snapshot: commonSnapshot,
-					shared: 2,
-					snapshotContent: new Set(commonMap.keys()),
-					children: undefined
-				});
-				this._statSharedSnapshots++;
-			}
-		}
-		const unshared = capturedFiles.size;
-		this._statItemsUnshared += unshared;
-		this._statItemsShared += capturedFilesSize - unshared;
-	}
-}
+				// Generate code for all aggregated modules
+				asyncLib.eachLimit(modules, 10, codeGen, err => {
+					if (err) return callback(err);
+					reportErrors();
 
-const parseString = str => {
-	if (str[0] === "'") str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
-	return JSON.parse(str);
-};
+					// for backward-compat temporary set the chunk graph
+					// TODO webpack 6
+					const old = this.chunkGraph;
+					this.chunkGraph = chunkGraph;
+					this.processRuntimeRequirements({
+						chunkGraph,
+						modules,
+						chunks,
+						codeGenerationResults,
+						chunkGraphEntries: chunks
+					});
+					this.chunkGraph = old;
 
-/* istanbul ignore next */
-/**
- * @param {number} mtime mtime
- */
-const applyMtime = mtime => {
-	if (FS_ACCURACY > 1 && mtime % 2 !== 0) FS_ACCURACY = 1;
-	else if (FS_ACCURACY > 10 && mtime % 20 !== 0) FS_ACCURACY = 10;
-	else if (FS_ACCURACY > 100 && mtime % 200 !== 0) FS_ACCURACY = 100;
-	else if (FS_ACCURACY > 1000 && mtime % 2000 !== 0) FS_ACCURACY = 1000;
-};
+					const runtimeModules =
+						chunkGraph.getChunkRuntimeModulesIterable(chunk);
 
-/**
- * @template T
- * @template K
- * @param {Map<T, K>} a source map
- * @param {Map<T, K>} b joining map
- * @returns {Map<T, K>} joined map
- */
-const mergeMaps = (a, b) => {
-	if (!b || b.size === 0) return a;
-	if (!a || a.size === 0) return b;
-	const map = new Map(a);
-	for (const [key, value] of b) {
-		map.set(key, value);
-	}
-	return map;
-};
+					// Hash runtime modules
+					for (const module of runtimeModules) {
+						modules.add(module);
+						this._createModuleHash(
+							module,
+							chunkGraph,
+							runtime,
+							hashFunction,
+							runtimeTemplate,
+							hashDigest,
+							hashDigestLength
+						);
+					}
 
-/**
- * @template T
- * @template K
- * @param {Set<T, K>} a source map
- * @param {Set<T, K>} b joining map
- * @returns {Set<T, K>} joined map
- */
-const mergeSets = (a, b) => {
-	if (!b || b.size === 0) return a;
-	if (!a || a.size === 0) return b;
-	const map = new Set(a);
-	for (const item of b) {
-		map.add(item);
-	}
-	return map;
-};
+					// Generate code for all runtime modules
+					asyncLib.eachLimit(runtimeModules, 10, codeGen, err => {
+						if (err) return callback(err);
+						reportErrors();
 
-/**
- * Finding file or directory to manage
- * @param {string} managedPath path that is managing by {@link FileSystemInfo}
- * @param {string} path path to file or directory
- * @returns {string|null} managed item
- * @example
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/package/index.js'
- * ) === '/Users/user/my-project/node_modules/package'
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/package1/node_modules/package2'
- * ) === '/Users/user/my-project/node_modules/package1/node_modules/package2'
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/.bin/script.js'
- * ) === null // hidden files are disallowed as managed items
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/package'
- * ) === '/Users/user/my-project/node_modules/package'
- */
-const getManagedItem = (managedPath, path) => {
-	let i = managedPath.length;
-	let slashes = 1;
-	let startingPosition = true;
-	loop: while (i < path.length) {
-		switch (path.charCodeAt(i)) {
-			case 47: // slash
-			case 92: // backslash
-				if (--slashes === 0) break loop;
-				startingPosition = true;
-				break;
-			case 46: // .
-				// hidden files are disallowed as managed items
-				// it's probably .yarn-integrity or .cache
-				if (startingPosition) return null;
-				break;
-			case 64: // @
-				if (!startingPosition) return null;
-				slashes++;
-				break;
-			default:
-				startingPosition = false;
-				break;
-		}
-		i++;
-	}
-	if (i === path.length) slashes--;
-	// return null when path is incomplete
-	if (slashes !== 0) return null;
-	// if (path.slice(i + 1, i + 13) === "node_modules")
-	if (
-		path.length >= i + 13 &&
-		path.charCodeAt(i + 1) === 110 &&
-		path.charCodeAt(i + 2) === 111 &&
-		path.charCodeAt(i + 3) === 100 &&
-		path.charCodeAt(i + 4) === 101 &&
-		path.charCodeAt(i + 5) === 95 &&
-		path.charCodeAt(i + 6) === 109 &&
-		path.charCodeAt(i + 7) === 111 &&
-		path.charCodeAt(i + 8) === 100 &&
-		path.charCodeAt(i + 9) === 117 &&
-		path.charCodeAt(i + 10) === 108 &&
-		path.charCodeAt(i + 11) === 101 &&
-		path.charCodeAt(i + 12) === 115
-	) {
-		// if this is the end of the path
-		if (path.length === i + 13) {
-			// return the node_modules directory
-			// it's special
-			return path;
-		}
-		const c = path.charCodeAt(i + 13);
-		// if next symbol is slash or backslash
-		if (c === 47 || c === 92) {
-			// Managed subpath
-			return getManagedItem(path.slice(0, i + 14), path);
-		}
-	}
-	return path.slice(0, i);
-};
+						/** @type {Map<Module, ExecuteModuleArgument>} */
+						const moduleArgumentsMap = new Map();
+						/** @type {Map<string, ExecuteModuleArgument>} */
+						const moduleArgumentsById = new Map();
 
-/**
- * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
- * @param {T} entry entry
- * @returns {T["resolved"] | undefined} the resolved entry
- */
-const getResolvedTimestamp = entry => {
-	if (entry === null) return null;
-	if (entry.resolved !== undefined) return entry.resolved;
-	return entry.symlinks === undefined ? entry : undefined;
-};
+						/** @type {ExecuteModuleResult["fileDependencies"]} */
+						const fileDependencies = new LazySet();
+						/** @type {ExecuteModuleResult["contextDependencies"]} */
+						const contextDependencies = new LazySet();
+						/** @type {ExecuteModuleResult["missingDependencies"]} */
+						const missingDependencies = new LazySet();
+						/** @type {ExecuteModuleResult["buildDependencies"]} */
+						const buildDependencies = new LazySet();
 
-/**
- * @param {ContextHash} entry entry
- * @returns {string | undefined} the resolved entry
- */
-const getResolvedHash = entry => {
-	if (entry === null) return null;
-	if (entry.resolved !== undefined) return entry.resolved;
-	return entry.symlinks === undefined ? entry.hash : undefined;
-};
+						/** @type {ExecuteModuleResult["assets"]} */
+						const assets = new Map();
 
-const addAll = (source, target) => {
-	for (const key of source) target.add(key);
-};
+						let cacheable = true;
 
-/**
- * Used to access information about the filesystem in a cached way
- */
-class FileSystemInfo {
-	/**
-	 * @param {InputFileSystem} fs file system
-	 * @param {Object} options options
-	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
-	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
-	 * @param {Logger=} options.logger logger used to log invalid snapshots
-	 * @param {string | Hash=} options.hashFunction the hash function to use
-	 */
-	constructor(
-		fs,
-		{
-			managedPaths = [],
-			immutablePaths = [],
-			logger,
-			hashFunction = "md4"
-		} = {}
-	) {
-		this.fs = fs;
-		this.logger = logger;
-		this._remainingLogs = logger ? 40 : 0;
-		this._loggedPaths = logger ? new Set() : undefined;
-		this._hashFunction = hashFunction;
-		/** @type {WeakMap<Snapshot, boolean | (function(WebpackError=, boolean=): void)[]>} */
-		this._snapshotCache = new WeakMap();
-		this._fileTimestampsOptimization = new SnapshotOptimization(
-			s => s.hasFileTimestamps(),
-			s => s.fileTimestamps,
-			(s, v) => s.setFileTimestamps(v)
-		);
-		this._fileHashesOptimization = new SnapshotOptimization(
-			s => s.hasFileHashes(),
-			s => s.fileHashes,
-			(s, v) => s.setFileHashes(v),
-			false
-		);
-		this._fileTshsOptimization = new SnapshotOptimization(
-			s => s.hasFileTshs(),
-			s => s.fileTshs,
-			(s, v) => s.setFileTshs(v)
-		);
-		this._contextTimestampsOptimization = new SnapshotOptimization(
-			s => s.hasContextTimestamps(),
-			s => s.contextTimestamps,
-			(s, v) => s.setContextTimestamps(v)
-		);
-		this._contextHashesOptimization = new SnapshotOptimization(
-			s => s.hasContextHashes(),
-			s => s.contextHashes,
-			(s, v) => s.setContextHashes(v),
-			false
-		);
-		this._contextTshsOptimization = new SnapshotOptimization(
-			s => s.hasContextTshs(),
-			s => s.contextTshs,
-			(s, v) => s.setContextTshs(v)
-		);
-		this._missingExistenceOptimization = new SnapshotOptimization(
-			s => s.hasMissingExistence(),
-			s => s.missingExistence,
-			(s, v) => s.setMissingExistence(v),
-			false
-		);
-		this._managedItemInfoOptimization = new SnapshotOptimization(
-			s => s.hasManagedItemInfo(),
-			s => s.managedItemInfo,
-			(s, v) => s.setManagedItemInfo(v),
-			false
-		);
-		this._managedFilesOptimization = new SnapshotOptimization(
-			s => s.hasManagedFiles(),
-			s => s.managedFiles,
-			(s, v) => s.setManagedFiles(v),
-			false,
-			true
-		);
-		this._managedContextsOptimization = new SnapshotOptimization(
-			s => s.hasManagedContexts(),
-			s => s.managedContexts,
-			(s, v) => s.setManagedContexts(v),
-			false,
-			true
-		);
-		this._managedMissingOptimization = new SnapshotOptimization(
-			s => s.hasManagedMissing(),
-			s => s.managedMissing,
-			(s, v) => s.setManagedMissing(v),
-			false,
-			true
-		);
-		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
-		this._fileTimestamps = new StackedCacheMap();
-		/** @type {Map<string, string>} */
-		this._fileHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string>} */
-		this._fileTshs = new Map();
-		/** @type {StackedCacheMap<string, ContextFileSystemInfoEntry | "ignore" | null>} */
-		this._contextTimestamps = new StackedCacheMap();
-		/** @type {Map<string, ContextHash>} */
-		this._contextHashes = new Map();
-		/** @type {Map<string, ContextTimestampAndHash>} */
-		this._contextTshs = new Map();
-		/** @type {Map<string, string>} */
-		this._managedItems = new Map();
-		/** @type {AsyncQueue<string, string, FileSystemInfoEntry | null>} */
-		this.fileTimestampQueue = new AsyncQueue({
-			name: "file timestamp",
-			parallelism: 30,
-			processor: this._readFileTimestamp.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, string | null>} */
-		this.fileHashQueue = new AsyncQueue({
-			name: "file hash",
-			parallelism: 10,
-			processor: this._readFileHash.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry | null>} */
-		this.contextTimestampQueue = new AsyncQueue({
-			name: "context timestamp",
-			parallelism: 2,
-			processor: this._readContextTimestamp.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, ContextHash | null>} */
-		this.contextHashQueue = new AsyncQueue({
-			name: "context hash",
-			parallelism: 2,
-			processor: this._readContextHash.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, ContextTimestampAndHash | null>} */
-		this.contextTshQueue = new AsyncQueue({
-			name: "context hash and timestamp",
-			parallelism: 2,
-			processor: this._readContextTimestampAndHash.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, string | null>} */
-		this.managedItemQueue = new AsyncQueue({
-			name: "managed item info",
-			parallelism: 10,
-			processor: this._getManagedItemInfo.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, Set<string>>} */
-		this.managedItemDirectoryQueue = new AsyncQueue({
-			name: "managed item directory info",
-			parallelism: 10,
-			processor: this._getManagedItemDirectoryInfo.bind(this)
-		});
-		this.managedPaths = Array.from(managedPaths);
-		this.managedPathsWithSlash = /** @type {string[]} */ (
-			this.managedPaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
+						/** @type {ExecuteModuleContext} */
+						const context = {
+							assets,
+							__webpack_require__: undefined,
+							chunk,
+							chunkGraph
+						};
 
-		this.managedPathsRegExps = /** @type {RegExp[]} */ (
-			this.managedPaths.filter(p => typeof p !== "string")
-		);
-		this.immutablePaths = Array.from(immutablePaths);
-		this.immutablePathsWithSlash = /** @type {string[]} */ (
-			this.immutablePaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
-		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
-			this.immutablePaths.filter(p => typeof p !== "string")
-		);
+						// Prepare execution
+						asyncLib.eachLimit(
+							modules,
+							10,
+							(module, callback) => {
+								const codeGenerationResult = codeGenerationResults.get(
+									module,
+									runtime
+								);
+								/** @type {ExecuteModuleArgument} */
+								const moduleArgument = {
+									module,
+									codeGenerationResult,
+									preparedInfo: undefined,
+									moduleObject: undefined
+								};
+								moduleArgumentsMap.set(module, moduleArgument);
+								moduleArgumentsById.set(module.identifier(), moduleArgument);
+								module.addCacheDependencies(
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								);
+								if (module.buildInfo.cacheable === false) {
+									cacheable = false;
+								}
+								if (module.buildInfo && module.buildInfo.assets) {
+									const { assets: moduleAssets, assetsInfo } = module.buildInfo;
+									for (const assetName of Object.keys(moduleAssets)) {
+										assets.set(assetName, {
+											source: moduleAssets[assetName],
+											info: assetsInfo ? assetsInfo.get(assetName) : undefined
+										});
+									}
+								}
+								this.hooks.prepareModuleExecution.callAsync(
+									moduleArgument,
+									context,
+									callback
+								);
+							},
+							err => {
+								if (err) return callback(err);
 
-		this._cachedDeprecatedFileTimestamps = undefined;
-		this._cachedDeprecatedContextTimestamps = undefined;
+								let exports;
+								try {
+									const {
+										strictModuleErrorHandling,
+										strictModuleExceptionHandling
+									} = this.outputOptions;
+									const __nested_webpack_require_152290__ = id => {
+										const cached = moduleCache[id];
+										if (cached !== undefined) {
+											if (cached.error) throw cached.error;
+											return cached.exports;
+										}
+										const moduleArgument = moduleArgumentsById.get(id);
+										return __webpack_require_module__(moduleArgument, id);
+									};
+									const interceptModuleExecution = (__nested_webpack_require_152290__[
+										RuntimeGlobals.interceptModuleExecution.replace(
+											"__webpack_require__.",
+											""
+										)
+									] = []);
+									const moduleCache = (__nested_webpack_require_152290__[
+										RuntimeGlobals.moduleCache.replace(
+											"__webpack_require__.",
+											""
+										)
+									] = {});
 
-		this._warnAboutExperimentalEsmTracking = false;
+									context.__webpack_require__ = __nested_webpack_require_152290__;
 
-		this._statCreatedSnapshots = 0;
-		this._statTestedSnapshotsCached = 0;
-		this._statTestedSnapshotsNotCached = 0;
-		this._statTestedChildrenCached = 0;
-		this._statTestedChildrenNotCached = 0;
-		this._statTestedEntries = 0;
-	}
+									/**
+									 * @param {ExecuteModuleArgument} moduleArgument the module argument
+									 * @param {string=} id id
+									 * @returns {any} exports
+									 */
+									const __webpack_require_module__ = (moduleArgument, id) => {
+										var execOptions = {
+											id,
+											module: {
+												id,
+												exports: {},
+												loaded: false,
+												error: undefined
+											},
+											require: __nested_webpack_require_152290__
+										};
+										interceptModuleExecution.forEach(handler =>
+											handler(execOptions)
+										);
+										const module = moduleArgument.module;
+										this.buildTimeExecutedModules.add(module);
+										const moduleObject = execOptions.module;
+										moduleArgument.moduleObject = moduleObject;
+										try {
+											if (id) moduleCache[id] = moduleObject;
 
-	logStatistics() {
-		const logWhenMessage = (header, message) => {
-			if (message) {
-				this.logger.log(`${header}: ${message}`);
+											tryRunOrWebpackError(
+												() =>
+													this.hooks.executeModule.call(
+														moduleArgument,
+														context
+													),
+												"Compilation.hooks.executeModule"
+											);
+											moduleObject.loaded = true;
+											return moduleObject.exports;
+										} catch (e) {
+											if (strictModuleExceptionHandling) {
+												if (id) delete moduleCache[id];
+											} else if (strictModuleErrorHandling) {
+												moduleObject.error = e;
+											}
+											if (!e.module) e.module = module;
+											throw e;
+										}
+									};
+
+									for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
+										chunk
+									)) {
+										__webpack_require_module__(
+											moduleArgumentsMap.get(runtimeModule)
+										);
+									}
+									exports = __nested_webpack_require_152290__(module.identifier());
+								} catch (e) {
+									const err = new WebpackError(
+										`Execution of module code from module graph (${module.readableIdentifier(
+											this.requestShortener
+										)}) failed: ${e.message}`
+									);
+									err.stack = e.stack;
+									err.module = e.module;
+									return callback(err);
+								}
+
+								callback(null, {
+									exports,
+									assets,
+									cacheable,
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								});
+							}
+						);
+					});
+				});
 			}
-		};
-		this.logger.log(`${this._statCreatedSnapshots} new snapshots created`);
-		this.logger.log(
-			`${
-				this._statTestedSnapshotsNotCached &&
-				Math.round(
-					(this._statTestedSnapshotsNotCached * 100) /
-						(this._statTestedSnapshotsCached +
-							this._statTestedSnapshotsNotCached)
-				)
-			}% root snapshot uncached (${this._statTestedSnapshotsNotCached} / ${
-				this._statTestedSnapshotsCached + this._statTestedSnapshotsNotCached
-			})`
-		);
-		this.logger.log(
-			`${
-				this._statTestedChildrenNotCached &&
-				Math.round(
-					(this._statTestedChildrenNotCached * 100) /
-						(this._statTestedChildrenCached + this._statTestedChildrenNotCached)
-				)
-			}% children snapshot uncached (${this._statTestedChildrenNotCached} / ${
-				this._statTestedChildrenCached + this._statTestedChildrenNotCached
-			})`
-		);
-		this.logger.log(`${this._statTestedEntries} entries tested`);
-		this.logger.log(
-			`File info in cache: ${this._fileTimestamps.size} timestamps ${this._fileHashes.size} hashes ${this._fileTshs.size} timestamp hash combinations`
-		);
-		logWhenMessage(
-			`File timestamp snapshot optimization`,
-			this._fileTimestampsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`File hash snapshot optimization`,
-			this._fileHashesOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`File timestamp hash combination snapshot optimization`,
-			this._fileTshsOptimization.getStatisticMessage()
-		);
-		this.logger.log(
-			`Directory info in cache: ${this._contextTimestamps.size} timestamps ${this._contextHashes.size} hashes ${this._contextTshs.size} timestamp hash combinations`
-		);
-		logWhenMessage(
-			`Directory timestamp snapshot optimization`,
-			this._contextTimestampsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Directory hash snapshot optimization`,
-			this._contextHashesOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Directory timestamp hash combination snapshot optimization`,
-			this._contextTshsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Missing items snapshot optimization`,
-			this._missingExistenceOptimization.getStatisticMessage()
-		);
-		this.logger.log(
-			`Managed items info in cache: ${this._managedItems.size} items`
-		);
-		logWhenMessage(
-			`Managed items snapshot optimization`,
-			this._managedItemInfoOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Managed files snapshot optimization`,
-			this._managedFilesOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Managed contexts snapshot optimization`,
-			this._managedContextsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Managed missing snapshot optimization`,
-			this._managedMissingOptimization.getStatisticMessage()
 		);
 	}
 
-	_log(path, reason, ...args) {
-		const key = path + reason;
-		if (this._loggedPaths.has(key)) return;
-		this._loggedPaths.add(key);
-		this.logger.debug(`${path} invalidated because ${reason}`, ...args);
-		if (--this._remainingLogs === 0) {
-			this.logger.debug(
-				"Logging limit has been reached and no further logging will be emitted by FileSystemInfo"
-			);
-		}
-	}
+	checkConstraints() {
+		const chunkGraph = this.chunkGraph;
 
-	clear() {
-		this._remainingLogs = this.logger ? 40 : 0;
-		if (this._loggedPaths !== undefined) this._loggedPaths.clear();
+		/** @type {Set<number|string>} */
+		const usedIds = new Set();
 
-		this._snapshotCache = new WeakMap();
-		this._fileTimestampsOptimization.clear();
-		this._fileHashesOptimization.clear();
-		this._fileTshsOptimization.clear();
-		this._contextTimestampsOptimization.clear();
-		this._contextHashesOptimization.clear();
-		this._contextTshsOptimization.clear();
-		this._missingExistenceOptimization.clear();
-		this._managedItemInfoOptimization.clear();
-		this._managedFilesOptimization.clear();
-		this._managedContextsOptimization.clear();
-		this._managedMissingOptimization.clear();
-		this._fileTimestamps.clear();
-		this._fileHashes.clear();
-		this._fileTshs.clear();
-		this._contextTimestamps.clear();
-		this._contextHashes.clear();
-		this._contextTshs.clear();
-		this._managedItems.clear();
-		this._managedItems.clear();
+		for (const module of this.modules) {
+			if (module.type === "runtime") continue;
+			const moduleId = chunkGraph.getModuleId(module);
+			if (moduleId === null) continue;
+			if (usedIds.has(moduleId)) {
+				throw new Error(`checkConstraints: duplicate module id ${moduleId}`);
+			}
+			usedIds.add(moduleId);
+		}
 
-		this._cachedDeprecatedFileTimestamps = undefined;
-		this._cachedDeprecatedContextTimestamps = undefined;
+		for (const chunk of this.chunks) {
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!this.modules.has(module)) {
+					throw new Error(
+						"checkConstraints: module in chunk but not in compilation " +
+							` ${chunk.debugId} ${module.debugId}`
+					);
+				}
+			}
+			for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+				if (!this.modules.has(module)) {
+					throw new Error(
+						"checkConstraints: entry module in chunk but not in compilation " +
+							` ${chunk.debugId} ${module.debugId}`
+					);
+				}
+			}
+		}
 
-		this._statCreatedSnapshots = 0;
-		this._statTestedSnapshotsCached = 0;
-		this._statTestedSnapshotsNotCached = 0;
-		this._statTestedChildrenCached = 0;
-		this._statTestedChildrenNotCached = 0;
-		this._statTestedEntries = 0;
+		for (const chunkGroup of this.chunkGroups) {
+			chunkGroup.checkConstraints();
+		}
 	}
+}
 
-	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
-	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
-	 * @returns {void}
-	 */
-	addFileTimestamps(map, immutable) {
-		this._fileTimestamps.addAll(map, immutable);
-		this._cachedDeprecatedFileTimestamps = undefined;
-	}
+/**
+ * @typedef {Object} FactorizeModuleOptions
+ * @property {ModuleProfile} currentProfile
+ * @property {ModuleFactory} factory
+ * @property {Dependency[]} dependencies
+ * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module
+ * @property {Module | null} originModule
+ * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+ * @property {string=} context
+ */
 
-	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
-	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
-	 * @returns {void}
-	 */
-	addContextTimestamps(map, immutable) {
-		this._contextTimestamps.addAll(map, immutable);
-		this._cachedDeprecatedContextTimestamps = undefined;
+/**
+ * @param {FactorizeModuleOptions} options options object
+ * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
+ * @returns {void}
+ */
+
+// Workaround for typescript as it doesn't support function overloading in jsdoc within a class
+Compilation.prototype.factorizeModule = /** @type {{
+	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
+	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
+}} */ (
+	function (options, callback) {
+		this.factorizeQueue.add(options, callback);
 	}
+);
 
-	/**
-	 * @param {string} path file path
-	 * @param {function((WebpackError | null)=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
-	 * @returns {void}
-	 */
-	getFileTimestamp(path, callback) {
-		const cache = this._fileTimestamps.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.fileTimestampQueue.add(path, callback);
+// Hide from typescript
+const compilationPrototype = Compilation.prototype;
+
+// TODO webpack 6 remove
+Object.defineProperty(compilationPrototype, "modifyHash", {
+	writable: false,
+	enumerable: false,
+	configurable: false,
+	value: () => {
+		throw new Error(
+			"Compilation.modifyHash was removed in favor of Compilation.hooks.fullHash"
+		);
 	}
+});
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
-	 * @returns {void}
-	 */
-	getContextTimestamp(path, callback) {
-		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined) {
-			if (cache === "ignore") return callback(null, "ignore");
-			const resolved = getResolvedTimestamp(cache);
-			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextTimestamp(cache, callback);
-		}
-		this.contextTimestampQueue.add(path, (err, entry) => {
-			if (err) return callback(err);
-			const resolved = getResolvedTimestamp(entry);
-			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextTimestamp(entry, callback);
-		});
-	}
+// TODO webpack 6 remove
+Object.defineProperty(compilationPrototype, "cache", {
+	enumerable: false,
+	configurable: false,
+	get: util.deprecate(
+		/**
+		 * @this {Compilation} the compilation
+		 * @returns {Cache} the cache
+		 */
+		function () {
+			return this.compiler.cache;
+		},
+		"Compilation.cache was removed in favor of Compilation.getCache()",
+		"DEP_WEBPACK_COMPILATION_CACHE"
+	),
+	set: util.deprecate(
+		v => {},
+		"Compilation.cache was removed in favor of Compilation.getCache()",
+		"DEP_WEBPACK_COMPILATION_CACHE"
+	)
+});
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
-	 * @returns {void}
-	 */
-	_getUnresolvedContextTimestamp(path, callback) {
-		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.contextTimestampQueue.add(path, callback);
-	}
+/**
+ * Add additional assets to the compilation.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000;
 
-	/**
-	 * @param {string} path file path
-	 * @param {function((WebpackError | null)=, string=): void} callback callback function
-	 * @returns {void}
-	 */
-	getFileHash(path, callback) {
-		const cache = this._fileHashes.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.fileHashQueue.add(path, callback);
+/**
+ * Basic preprocessing of assets.
+ */
+Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1000;
+
+/**
+ * Derive new assets from existing assets.
+ * Existing assets should not be treated as complete.
+ */
+Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200;
+
+/**
+ * Add additional sections to existing assets, like a banner or initialization code.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ADDITIONS = -100;
+
+/**
+ * Optimize existing assets in a general way.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100;
+
+/**
+ * Optimize the count of existing assets, e. g. by merging them.
+ * Only assets of the same type should be merged.
+ * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200;
+
+/**
+ * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300;
+
+/**
+ * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400;
+
+/**
+ * Add development tooling to assets, e. g. by extracting a SourceMap.
+ */
+Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500;
+
+/**
+ * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
+ * Only assets of different types should be inlined.
+ * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700;
+
+/**
+ * Summarize the list of existing assets
+ * e. g. creating an assets manifest of Service Workers.
+ */
+Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
+
+/**
+ * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
+
+/**
+ * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
+
+/**
+ * Analyse existing assets.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
+
+/**
+ * Creating assets for reporting purposes.
+ */
+Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
+
+module.exports = Compilation;
+
+
+/***/ }),
+
+/***/ 70845:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const parseJson = __webpack_require__(15235);
+const asyncLib = __webpack_require__(78175);
+const {
+	SyncHook,
+	SyncBailHook,
+	AsyncParallelHook,
+	AsyncSeriesHook
+} = __webpack_require__(41242);
+const { SizeOnlySource } = __webpack_require__(51255);
+const webpack = __webpack_require__(91919);
+const Cache = __webpack_require__(7592);
+const CacheFacade = __webpack_require__(55392);
+const ChunkGraph = __webpack_require__(64971);
+const Compilation = __webpack_require__(85720);
+const ConcurrentCompilationError = __webpack_require__(95735);
+const ContextModuleFactory = __webpack_require__(62471);
+const ModuleGraph = __webpack_require__(99988);
+const NormalModuleFactory = __webpack_require__(68860);
+const RequestShortener = __webpack_require__(73406);
+const ResolverFactory = __webpack_require__(30217);
+const Stats = __webpack_require__(31743);
+const Watching = __webpack_require__(84275);
+const WebpackError = __webpack_require__(53799);
+const { Logger } = __webpack_require__(32597);
+const { join, dirname, mkdirp } = __webpack_require__(17139);
+const { makePathsRelative } = __webpack_require__(82186);
+const { isSourceEqual } = __webpack_require__(41245);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+
+/**
+ * @typedef {Object} CompilationParams
+ * @property {NormalModuleFactory} normalModuleFactory
+ * @property {ContextModuleFactory} contextModuleFactory
+ */
+
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
+
+/**
+ * @callback RunAsChildCallback
+ * @param {(Error | null)=} err
+ * @param {Chunk[]=} entries
+ * @param {Compilation=} compilation
+ */
+
+/**
+ * @typedef {Object} AssetEmittedInfo
+ * @property {Buffer} content
+ * @property {Source} source
+ * @property {Compilation} compilation
+ * @property {string} outputPath
+ * @property {string} targetPath
+ */
+
+/**
+ * @param {string[]} array an array
+ * @returns {boolean} true, if the array is sorted
+ */
+const isSorted = array => {
+	for (let i = 1; i < array.length; i++) {
+		if (array[i - 1] > array[i]) return false;
 	}
+	return true;
+};
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, string=): void} callback callback function
-	 * @returns {void}
-	 */
-	getContextHash(path, callback) {
-		const cache = this._contextHashes.get(path);
-		if (cache !== undefined) {
-			const resolved = getResolvedHash(cache);
-			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextHash(cache, callback);
-		}
-		this.contextHashQueue.add(path, (err, entry) => {
-			if (err) return callback(err);
-			const resolved = getResolvedHash(entry);
-			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextHash(entry, callback);
-		});
+/**
+ * @param {Object} obj an object
+ * @param {string[]} keys the keys of the object
+ * @returns {Object} the object with properties sorted by property name
+ */
+const sortObject = (obj, keys) => {
+	const o = {};
+	for (const k of keys.sort()) {
+		o[k] = obj[k];
 	}
+	return o;
+};
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, ContextHash=): void} callback callback function
-	 * @returns {void}
-	 */
-	_getUnresolvedContextHash(path, callback) {
-		const cache = this._contextHashes.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.contextHashQueue.add(path, callback);
+/**
+ * @param {string} filename filename
+ * @param {string | string[] | undefined} hashes list of hashes
+ * @returns {boolean} true, if the filename contains any hash
+ */
+const includesHash = (filename, hashes) => {
+	if (!hashes) return false;
+	if (Array.isArray(hashes)) {
+		return hashes.some(hash => filename.includes(hash));
+	} else {
+		return filename.includes(hashes);
 	}
+};
 
+class Compiler {
 	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, ResolvedContextTimestampAndHash=): void} callback callback function
-	 * @returns {void}
+	 * @param {string} context the compilation path
+	 * @param {WebpackOptions} options options
 	 */
-	getContextTsh(path, callback) {
-		const cache = this._contextTshs.get(path);
-		if (cache !== undefined) {
-			const resolved = getResolvedTimestamp(cache);
-			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextTsh(cache, callback);
-		}
-		this.contextTshQueue.add(path, (err, entry) => {
-			if (err) return callback(err);
-			const resolved = getResolvedTimestamp(entry);
-			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextTsh(entry, callback);
+	constructor(context, options = /** @type {WebpackOptions} */ ({})) {
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[]>} */
+			initialize: new SyncHook([]),
+
+			/** @type {SyncBailHook<[Compilation], boolean>} */
+			shouldEmit: new SyncBailHook(["compilation"]),
+			/** @type {AsyncSeriesHook<[Stats]>} */
+			done: new AsyncSeriesHook(["stats"]),
+			/** @type {SyncHook<[Stats]>} */
+			afterDone: new SyncHook(["stats"]),
+			/** @type {AsyncSeriesHook<[]>} */
+			additionalPass: new AsyncSeriesHook([]),
+			/** @type {AsyncSeriesHook<[Compiler]>} */
+			beforeRun: new AsyncSeriesHook(["compiler"]),
+			/** @type {AsyncSeriesHook<[Compiler]>} */
+			run: new AsyncSeriesHook(["compiler"]),
+			/** @type {AsyncSeriesHook<[Compilation]>} */
+			emit: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<[string, AssetEmittedInfo]>} */
+			assetEmitted: new AsyncSeriesHook(["file", "info"]),
+			/** @type {AsyncSeriesHook<[Compilation]>} */
+			afterEmit: new AsyncSeriesHook(["compilation"]),
+
+			/** @type {SyncHook<[Compilation, CompilationParams]>} */
+			thisCompilation: new SyncHook(["compilation", "params"]),
+			/** @type {SyncHook<[Compilation, CompilationParams]>} */
+			compilation: new SyncHook(["compilation", "params"]),
+			/** @type {SyncHook<[NormalModuleFactory]>} */
+			normalModuleFactory: new SyncHook(["normalModuleFactory"]),
+			/** @type {SyncHook<[ContextModuleFactory]>}  */
+			contextModuleFactory: new SyncHook(["contextModuleFactory"]),
+
+			/** @type {AsyncSeriesHook<[CompilationParams]>} */
+			beforeCompile: new AsyncSeriesHook(["params"]),
+			/** @type {SyncHook<[CompilationParams]>} */
+			compile: new SyncHook(["params"]),
+			/** @type {AsyncParallelHook<[Compilation]>} */
+			make: new AsyncParallelHook(["compilation"]),
+			/** @type {AsyncParallelHook<[Compilation]>} */
+			finishMake: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<[Compilation]>} */
+			afterCompile: new AsyncSeriesHook(["compilation"]),
+
+			/** @type {AsyncSeriesHook<[]>} */
+			readRecords: new AsyncSeriesHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			emitRecords: new AsyncSeriesHook([]),
+
+			/** @type {AsyncSeriesHook<[Compiler]>} */
+			watchRun: new AsyncSeriesHook(["compiler"]),
+			/** @type {SyncHook<[Error]>} */
+			failed: new SyncHook(["error"]),
+			/** @type {SyncHook<[string | null, number]>} */
+			invalid: new SyncHook(["filename", "changeTime"]),
+			/** @type {SyncHook<[]>} */
+			watchClose: new SyncHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			shutdown: new AsyncSeriesHook([]),
+
+			/** @type {SyncBailHook<[string, string, any[]], true>} */
+			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
+
+			// TODO the following hooks are weirdly located here
+			// TODO move them for webpack 5
+			/** @type {SyncHook<[]>} */
+			environment: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterEnvironment: new SyncHook([]),
+			/** @type {SyncHook<[Compiler]>} */
+			afterPlugins: new SyncHook(["compiler"]),
+			/** @type {SyncHook<[Compiler]>} */
+			afterResolvers: new SyncHook(["compiler"]),
+			/** @type {SyncBailHook<[string, Entry], boolean>} */
+			entryOption: new SyncBailHook(["context", "entry"])
 		});
+
+		this.webpack = webpack;
+
+		/** @type {string=} */
+		this.name = undefined;
+		/** @type {Compilation=} */
+		this.parentCompilation = undefined;
+		/** @type {Compiler} */
+		this.root = this;
+		/** @type {string} */
+		this.outputPath = "";
+		/** @type {Watching} */
+		this.watching = undefined;
+
+		/** @type {OutputFileSystem} */
+		this.outputFileSystem = null;
+		/** @type {IntermediateFileSystem} */
+		this.intermediateFileSystem = null;
+		/** @type {InputFileSystem} */
+		this.inputFileSystem = null;
+		/** @type {WatchFileSystem} */
+		this.watchFileSystem = null;
+
+		/** @type {string|null} */
+		this.recordsInputPath = null;
+		/** @type {string|null} */
+		this.recordsOutputPath = null;
+		this.records = {};
+		/** @type {Set<string | RegExp>} */
+		this.managedPaths = new Set();
+		/** @type {Set<string | RegExp>} */
+		this.immutablePaths = new Set();
+
+		/** @type {ReadonlySet<string>} */
+		this.modifiedFiles = undefined;
+		/** @type {ReadonlySet<string>} */
+		this.removedFiles = undefined;
+		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		this.fileTimestamps = undefined;
+		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		this.contextTimestamps = undefined;
+		/** @type {number} */
+		this.fsStartTime = undefined;
+
+		/** @type {ResolverFactory} */
+		this.resolverFactory = new ResolverFactory();
+
+		this.infrastructureLogger = undefined;
+
+		this.options = options;
+
+		this.context = context;
+
+		this.requestShortener = new RequestShortener(context, this.root);
+
+		this.cache = new Cache();
+
+		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
+		this.moduleMemCaches = undefined;
+
+		this.compilerPath = "";
+
+		/** @type {boolean} */
+		this.running = false;
+
+		/** @type {boolean} */
+		this.idle = false;
+
+		/** @type {boolean} */
+		this.watchMode = false;
+
+		this._backCompat = this.options.experiments.backCompat !== false;
+
+		/** @type {Compilation} */
+		this._lastCompilation = undefined;
+		/** @type {NormalModuleFactory} */
+		this._lastNormalModuleFactory = undefined;
+
+		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
+		this._assetEmittingSourceCache = new WeakMap();
+		/** @private @type {Map<string, number>} */
+		this._assetEmittingWrittenFiles = new Map();
+		/** @private @type {Set<string>} */
+		this._assetEmittingPreviousFiles = new Set();
 	}
 
 	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, ContextTimestampAndHash=): void} callback callback function
-	 * @returns {void}
+	 * @param {string} name cache name
+	 * @returns {CacheFacade} the cache facade instance
 	 */
-	_getUnresolvedContextTsh(path, callback) {
-		const cache = this._contextTshs.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.contextTshQueue.add(path, callback);
-	}
-
-	_createBuildDependenciesResolvers() {
-		const resolveContext = createResolver({
-			resolveToContext: true,
-			exportsFields: [],
-			fileSystem: this.fs
-		});
-		const resolveCjs = createResolver({
-			extensions: [".js", ".json", ".node"],
-			conditionNames: ["require", "node"],
-			exportsFields: ["exports"],
-			fileSystem: this.fs
-		});
-		const resolveCjsAsChild = createResolver({
-			extensions: [".js", ".json", ".node"],
-			conditionNames: ["require", "node"],
-			exportsFields: [],
-			fileSystem: this.fs
-		});
-		const resolveEsm = createResolver({
-			extensions: [".js", ".json", ".node"],
-			fullySpecified: true,
-			conditionNames: ["import", "node"],
-			exportsFields: ["exports"],
-			fileSystem: this.fs
-		});
-		return { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild };
+	getCache(name) {
+		return new CacheFacade(
+			this.cache,
+			`${this.compilerPath}${name}`,
+			this.options.output.hashFunction
+		);
 	}
 
 	/**
-	 * @param {string} context context directory
-	 * @param {Iterable<string>} deps dependencies
-	 * @param {function((Error | null)=, ResolveBuildDependenciesResult=): void} callback callback function
-	 * @returns {void}
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
 	 */
-	resolveBuildDependencies(context, deps, callback) {
-		const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } =
-			this._createBuildDependenciesResolvers();
-
-		/** @type {Set<string>} */
-		const files = new Set();
-		/** @type {Set<string>} */
-		const fileSymlinks = new Set();
-		/** @type {Set<string>} */
-		const directories = new Set();
-		/** @type {Set<string>} */
-		const directorySymlinks = new Set();
-		/** @type {Set<string>} */
-		const missing = new Set();
-		/** @type {Set<string>} */
-		const resolveFiles = new Set();
-		/** @type {Set<string>} */
-		const resolveDirectories = new Set();
-		/** @type {Set<string>} */
-		const resolveMissing = new Set();
-		/** @type {Map<string, string | false>} */
-		const resolveResults = new Map();
-		const invalidResolveResults = new Set();
-		const resolverContext = {
-			fileDependencies: resolveFiles,
-			contextDependencies: resolveDirectories,
-			missingDependencies: resolveMissing
-		};
-		const expectedToString = expected => {
-			return expected ? ` (expected ${expected})` : "";
-		};
-		const jobToString = job => {
-			switch (job.type) {
-				case RBDT_RESOLVE_CJS:
-					return `resolve commonjs ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_RESOLVE_ESM:
-					return `resolve esm ${job.path}${expectedToString(job.expected)}`;
-				case RBDT_RESOLVE_DIRECTORY:
-					return `resolve directory ${job.path}`;
-				case RBDT_RESOLVE_CJS_FILE:
-					return `resolve commonjs file ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_RESOLVE_ESM_FILE:
-					return `resolve esm file ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_DIRECTORY:
-					return `directory ${job.path}`;
-				case RBDT_FILE:
-					return `file ${job.path}`;
-				case RBDT_DIRECTORY_DEPENDENCIES:
-					return `directory dependencies ${job.path}`;
-				case RBDT_FILE_DEPENDENCIES:
-					return `file dependencies ${job.path}`;
-			}
-			return `unknown ${job.type} ${job.path}`;
-		};
-		const pathToString = job => {
-			let result = ` at ${jobToString(job)}`;
-			job = job.issuer;
-			while (job !== undefined) {
-				result += `\n at ${jobToString(job)}`;
-				job = job.issuer;
-			}
-			return result;
-		};
-		processAsyncTree(
-			Array.from(deps, dep => ({
-				type: RBDT_RESOLVE_CJS,
-				context,
-				path: dep,
-				expected: undefined,
-				issuer: undefined
-			})),
-			20,
-			(job, push, callback) => {
-				const { type, context, path, expected } = job;
-				const resolveDirectory = path => {
-					const key = `d\n${context}\n${path}`;
-					if (resolveResults.has(key)) {
-						return callback();
+	getInfrastructureLogger(name) {
+		if (!name) {
+			throw new TypeError(
+				"Compiler.getInfrastructureLogger(name) called without a name"
+			);
+		}
+		return new Logger(
+			(type, args) => {
+				if (typeof name === "function") {
+					name = name();
+					if (!name) {
+						throw new TypeError(
+							"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+						);
 					}
-					resolveResults.set(key, undefined);
-					resolveContext(context, path, resolverContext, (err, _, result) => {
-						if (err) {
-							if (expected === false) {
-								resolveResults.set(key, false);
-								return callback();
-							}
-							invalidResolveResults.add(key);
-							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
-							return callback(err);
-						}
-						const resultPath = result.path;
-						resolveResults.set(key, resultPath);
-						push({
-							type: RBDT_DIRECTORY,
-							context: undefined,
-							path: resultPath,
-							expected: undefined,
-							issuer: job
-						});
-						callback();
-					});
-				};
-				const resolveFile = (path, symbol, resolve) => {
-					const key = `${symbol}\n${context}\n${path}`;
-					if (resolveResults.has(key)) {
-						return callback();
+				}
+				if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+					if (this.infrastructureLogger !== undefined) {
+						this.infrastructureLogger(name, type, args);
 					}
-					resolveResults.set(key, undefined);
-					resolve(context, path, resolverContext, (err, _, result) => {
-						if (typeof expected === "string") {
-							if (!err && result && result.path === expected) {
-								resolveResults.set(key, result.path);
-							} else {
-								invalidResolveResults.add(key);
-								this.logger.warn(
-									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
-										err || (result && result.path)
-									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
-										job
-									)}`
-								);
-							}
-						} else {
-							if (err) {
-								if (expected === false) {
-									resolveResults.set(key, false);
-									return callback();
+				}
+			},
+			childName => {
+				if (typeof name === "function") {
+					if (typeof childName === "function") {
+						return this.getInfrastructureLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+									);
 								}
-								invalidResolveResults.add(key);
-								err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString(
-									job
-								)}`;
-								return callback(err);
-							}
-							const resultPath = result.path;
-							resolveResults.set(key, resultPath);
-							push({
-								type: RBDT_FILE,
-								context: undefined,
-								path: resultPath,
-								expected: undefined,
-								issuer: job
-							});
-						}
-						callback();
-					});
-				};
-				switch (type) {
-					case RBDT_RESOLVE_CJS: {
-						const isDirectory = /[\\/]$/.test(path);
-						if (isDirectory) {
-							resolveDirectory(path.slice(0, path.length - 1));
-						} else {
-							resolveFile(path, "f", resolveCjs);
-						}
-						break;
-					}
-					case RBDT_RESOLVE_ESM: {
-						const isDirectory = /[\\/]$/.test(path);
-						if (isDirectory) {
-							resolveDirectory(path.slice(0, path.length - 1));
-						} else {
-							resolveFile(path);
-						}
-						break;
-					}
-					case RBDT_RESOLVE_DIRECTORY: {
-						resolveDirectory(path);
-						break;
-					}
-					case RBDT_RESOLVE_CJS_FILE: {
-						resolveFile(path, "f", resolveCjs);
-						break;
-					}
-					case RBDT_RESOLVE_CJS_FILE_AS_CHILD: {
-						resolveFile(path, "c", resolveCjsAsChild);
-						break;
-					}
-					case RBDT_RESOLVE_ESM_FILE: {
-						resolveFile(path, "e", resolveEsm);
-						break;
-					}
-					case RBDT_FILE: {
-						if (files.has(path)) {
-							callback();
-							break;
-						}
-						files.add(path);
-						this.fs.realpath(path, (err, _realPath) => {
-							if (err) return callback(err);
-							const realPath = /** @type {string} */ (_realPath);
-							if (realPath !== path) {
-								fileSymlinks.add(path);
-								resolveFiles.add(path);
-								if (files.has(realPath)) return callback();
-								files.add(realPath);
 							}
-							push({
-								type: RBDT_FILE_DEPENDENCIES,
-								context: undefined,
-								path: realPath,
-								expected: undefined,
-								issuer: job
-							});
-							callback();
-						});
-						break;
-					}
-					case RBDT_DIRECTORY: {
-						if (directories.has(path)) {
-							callback();
-							break;
-						}
-						directories.add(path);
-						this.fs.realpath(path, (err, _realPath) => {
-							if (err) return callback(err);
-							const realPath = /** @type {string} */ (_realPath);
-							if (realPath !== path) {
-								directorySymlinks.add(path);
-								resolveFiles.add(path);
-								if (directories.has(realPath)) return callback();
-								directories.add(realPath);
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
 							}
-							push({
-								type: RBDT_DIRECTORY_DEPENDENCIES,
-								context: undefined,
-								path: realPath,
-								expected: undefined,
-								issuer: job
-							});
-							callback();
+							return `${name}/${childName}`;
 						});
-						break;
-					}
-					case RBDT_FILE_DEPENDENCIES: {
-						// Check for known files without dependencies
-						if (/\.json5?$|\.yarn-integrity$|yarn\.lock$|\.ya?ml/.test(path)) {
-							process.nextTick(callback);
-							break;
-						}
-						// Check commonjs cache for the module
-						/** @type {NodeModule} */
-						const module = require.cache[path];
-						if (module && Array.isArray(module.children)) {
-							children: for (const child of module.children) {
-								let childPath = child.filename;
-								if (childPath) {
-									push({
-										type: RBDT_FILE,
-										context: undefined,
-										path: childPath,
-										expected: undefined,
-										issuer: job
-									});
-									const context = dirname(this.fs, path);
-									for (const modulePath of module.paths) {
-										if (childPath.startsWith(modulePath)) {
-											let subPath = childPath.slice(modulePath.length + 1);
-											const packageMatch = /^(@[^\\/]+[\\/])[^\\/]+/.exec(
-												subPath
-											);
-											if (packageMatch) {
-												push({
-													type: RBDT_FILE,
-													context: undefined,
-													path:
-														modulePath +
-														childPath[modulePath.length] +
-														packageMatch[0] +
-														childPath[modulePath.length] +
-														"package.json",
-													expected: false,
-													issuer: job
-												});
-											}
-											let request = subPath.replace(/\\/g, "/");
-											if (request.endsWith(".js"))
-												request = request.slice(0, -3);
-											push({
-												type: RBDT_RESOLVE_CJS_FILE_AS_CHILD,
-												context,
-												path: request,
-												expected: child.filename,
-												issuer: job
-											});
-											continue children;
-										}
-									}
-									let request = relative(this.fs, context, childPath);
-									if (request.endsWith(".js")) request = request.slice(0, -3);
-									request = request.replace(/\\/g, "/");
-									if (!request.startsWith("../")) request = `./${request}`;
-									push({
-										type: RBDT_RESOLVE_CJS_FILE,
-										context,
-										path: request,
-										expected: child.filename,
-										issuer: job
-									});
+					} else {
+						return this.getInfrastructureLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+									);
 								}
 							}
-						} else if (supportsEsm && /\.m?js$/.test(path)) {
-							if (!this._warnAboutExperimentalEsmTracking) {
-								this.logger.log(
-									"Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" +
-										"Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" +
-										"As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking."
-								);
-								this._warnAboutExperimentalEsmTracking = true;
-							}
-							const lexer = __webpack_require__(54392);
-							lexer.init.then(() => {
-								this.fs.readFile(path, (err, content) => {
-									if (err) return callback(err);
-									try {
-										const context = dirname(this.fs, path);
-										const source = content.toString();
-										const [imports] = lexer.parse(source);
-										for (const imp of imports) {
-											try {
-												let dependency;
-												if (imp.d === -1) {
-													// import ... from "..."
-													dependency = parseString(
-														source.substring(imp.s - 1, imp.e + 1)
-													);
-												} else if (imp.d > -1) {
-													// import()
-													let expr = source.substring(imp.s, imp.e).trim();
-													dependency = parseString(expr);
-												} else {
-													// e.g. import.meta
-													continue;
-												}
-												push({
-													type: RBDT_RESOLVE_ESM_FILE,
-													context,
-													path: dependency,
-													expected: undefined,
-													issuer: job
-												});
-											} catch (e) {
-												this.logger.warn(
-													`Parsing of ${path} for build dependencies failed at 'import(${source.substring(
-														imp.s,
-														imp.e
-													)})'.\n` +
-														"Build dependencies behind this expression are ignored and might cause incorrect cache invalidation."
-												);
-												this.logger.debug(pathToString(job));
-												this.logger.debug(e.stack);
-											}
-										}
-									} catch (e) {
-										this.logger.warn(
-											`Parsing of ${path} for build dependencies failed and all dependencies of this file are ignored, which might cause incorrect cache invalidation..`
-										);
-										this.logger.debug(pathToString(job));
-										this.logger.debug(e.stack);
-									}
-									process.nextTick(callback);
-								});
-							}, callback);
-							break;
-						} else {
-							this.logger.log(
-								`Assuming ${path} has no dependencies as we were unable to assign it to any module system.`
-							);
-							this.logger.debug(pathToString(job));
-						}
-						process.nextTick(callback);
-						break;
+							return `${name}/${childName}`;
+						});
 					}
-					case RBDT_DIRECTORY_DEPENDENCIES: {
-						const match =
-							/(^.+[\\/]node_modules[\\/](?:@[^\\/]+[\\/])?[^\\/]+)/.exec(path);
-						const packagePath = match ? match[1] : path;
-						const packageJson = join(this.fs, packagePath, "package.json");
-						this.fs.readFile(packageJson, (err, content) => {
-							if (err) {
-								if (err.code === "ENOENT") {
-									resolveMissing.add(packageJson);
-									const parent = dirname(this.fs, packagePath);
-									if (parent !== packagePath) {
-										push({
-											type: RBDT_DIRECTORY_DEPENDENCIES,
-											context: undefined,
-											path: parent,
-											expected: undefined,
-											issuer: job
-										});
-									}
-									callback();
-									return;
-								}
-								return callback(err);
-							}
-							resolveFiles.add(packageJson);
-							let packageData;
-							try {
-								packageData = JSON.parse(content.toString("utf-8"));
-							} catch (e) {
-								return callback(e);
-							}
-							const depsObject = packageData.dependencies;
-							const optionalDepsObject = packageData.optionalDependencies;
-							const allDeps = new Set();
-							const optionalDeps = new Set();
-							if (typeof depsObject === "object" && depsObject) {
-								for (const dep of Object.keys(depsObject)) {
-									allDeps.add(dep);
-								}
-							}
-							if (
-								typeof optionalDepsObject === "object" &&
-								optionalDepsObject
-							) {
-								for (const dep of Object.keys(optionalDepsObject)) {
-									allDeps.add(dep);
-									optionalDeps.add(dep);
+				} else {
+					if (typeof childName === "function") {
+						return this.getInfrastructureLogger(() => {
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
 								}
 							}
-							for (const dep of allDeps) {
-								push({
-									type: RBDT_RESOLVE_DIRECTORY,
-									context: packagePath,
-									path: dep,
-									expected: !optionalDeps.has(dep),
-									issuer: job
-								});
-							}
-							callback();
+							return `${name}/${childName}`;
 						});
-						break;
+					} else {
+						return this.getInfrastructureLogger(`${name}/${childName}`);
 					}
 				}
-			},
-			err => {
-				if (err) return callback(err);
-				for (const l of fileSymlinks) files.delete(l);
-				for (const l of directorySymlinks) directories.delete(l);
-				for (const k of invalidResolveResults) resolveResults.delete(k);
-				callback(null, {
-					files,
-					directories,
-					missing,
-					resolveResults,
-					resolveDependencies: {
-						files: resolveFiles,
-						directories: resolveDirectories,
-						missing: resolveMissing
-					}
-				});
 			}
 		);
 	}
 
-	/**
-	 * @param {Map<string, string | false>} resolveResults results from resolving
-	 * @param {function((Error | null)=, boolean=): void} callback callback with true when resolveResults resolve the same way
-	 * @returns {void}
-	 */
-	checkResolveResultsValid(resolveResults, callback) {
-		const { resolveCjs, resolveCjsAsChild, resolveEsm, resolveContext } =
-			this._createBuildDependenciesResolvers();
-		asyncLib.eachLimit(
-			resolveResults,
-			20,
-			([key, expectedResult], callback) => {
-				const [type, context, path] = key.split("\n");
-				switch (type) {
-					case "d":
-						resolveContext(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					case "f":
-						resolveCjs(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					case "c":
-						resolveCjsAsChild(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					case "e":
-						resolveEsm(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					default:
-						callback(new Error("Unexpected type in resolve result key"));
-						break;
-				}
-			},
-			/**
-			 * @param {Error | typeof INVALID=} err error or invalid flag
-			 * @returns {void}
-			 */
-			err => {
-				if (err === INVALID) {
-					return callback(null, false);
-				}
-				if (err) {
-					return callback(err);
-				}
-				return callback(null, true);
+	// TODO webpack 6: solve this in a better way
+	// e.g. move compilation specific info from Modules into ModuleGraph
+	_cleanupLastCompilation() {
+		if (this._lastCompilation !== undefined) {
+			for (const module of this._lastCompilation.modules) {
+				ChunkGraph.clearChunkGraphForModule(module);
+				ModuleGraph.clearModuleGraphForModule(module);
+				module.cleanupForCache();
 			}
-		);
+			for (const chunk of this._lastCompilation.chunks) {
+				ChunkGraph.clearChunkGraphForChunk(chunk);
+			}
+			this._lastCompilation = undefined;
+		}
+	}
+
+	// TODO webpack 6: solve this in a better way
+	_cleanupLastNormalModuleFactory() {
+		if (this._lastNormalModuleFactory !== undefined) {
+			this._lastNormalModuleFactory.cleanupForCache();
+			this._lastNormalModuleFactory = undefined;
+		}
 	}
 
 	/**
-	 *
-	 * @param {number} startTime when processing the files has started
-	 * @param {Iterable<string>} files all files
-	 * @param {Iterable<string>} directories all directories
-	 * @param {Iterable<string>} missing all missing files or directories
-	 * @param {Object} options options object (for future extensions)
-	 * @param {boolean=} options.hash should use hash to snapshot
-	 * @param {boolean=} options.timestamp should use timestamp to snapshot
-	 * @param {function((WebpackError | null)=, (Snapshot | null)=): void} callback callback function
+	 * @param {WatchOptions} watchOptions the watcher's options
+	 * @param {Callback<Stats>} handler signals when the call finishes
+	 * @returns {Watching} a compiler watcher
+	 */
+	watch(watchOptions, handler) {
+		if (this.running) {
+			return handler(new ConcurrentCompilationError());
+		}
+
+		this.running = true;
+		this.watchMode = true;
+		this.watching = new Watching(this, watchOptions, handler);
+		return this.watching;
+	}
+
+	/**
+	 * @param {Callback<Stats>} callback signals when the call finishes
 	 * @returns {void}
 	 */
-	createSnapshot(startTime, files, directories, missing, options, callback) {
-		/** @type {Map<string, FileSystemInfoEntry | null>} */
-		const fileTimestamps = new Map();
-		/** @type {Map<string, string | null>} */
-		const fileHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string | null>} */
-		const fileTshs = new Map();
-		/** @type {Map<string, FileSystemInfoEntry | null>} */
-		const contextTimestamps = new Map();
-		/** @type {Map<string, string | null>} */
-		const contextHashes = new Map();
-		/** @type {Map<string, ResolvedContextTimestampAndHash | null>} */
-		const contextTshs = new Map();
-		/** @type {Map<string, boolean>} */
-		const missingExistence = new Map();
-		/** @type {Map<string, string>} */
-		const managedItemInfo = new Map();
-		/** @type {Set<string>} */
-		const managedFiles = new Set();
-		/** @type {Set<string>} */
-		const managedContexts = new Set();
-		/** @type {Set<string>} */
-		const managedMissing = new Set();
-		/** @type {Set<Snapshot>} */
-		const children = new Set();
+	run(callback) {
+		if (this.running) {
+			return callback(new ConcurrentCompilationError());
+		}
 
-		const snapshot = new Snapshot();
-		if (startTime) snapshot.setStartTime(startTime);
+		let logger;
 
-		/** @type {Set<string>} */
-		const managedItems = new Set();
+		const finalCallback = (err, stats) => {
+			if (logger) logger.time("beginIdle");
+			this.idle = true;
+			this.cache.beginIdle();
+			this.idle = true;
+			if (logger) logger.timeEnd("beginIdle");
+			this.running = false;
+			if (err) {
+				this.hooks.failed.call(err);
+			}
+			if (callback !== undefined) callback(err, stats);
+			this.hooks.afterDone.call(stats);
+		};
 
-		/** 1 = timestamp, 2 = hash, 3 = timestamp + hash */
-		const mode = options && options.hash ? (options.timestamp ? 3 : 2) : 1;
+		const startTime = Date.now();
 
-		let jobs = 1;
-		const jobDone = () => {
-			if (--jobs === 0) {
-				if (fileTimestamps.size !== 0) {
-					snapshot.setFileTimestamps(fileTimestamps);
-				}
-				if (fileHashes.size !== 0) {
-					snapshot.setFileHashes(fileHashes);
-				}
-				if (fileTshs.size !== 0) {
-					snapshot.setFileTshs(fileTshs);
-				}
-				if (contextTimestamps.size !== 0) {
-					snapshot.setContextTimestamps(contextTimestamps);
-				}
-				if (contextHashes.size !== 0) {
-					snapshot.setContextHashes(contextHashes);
-				}
-				if (contextTshs.size !== 0) {
-					snapshot.setContextTshs(contextTshs);
-				}
-				if (missingExistence.size !== 0) {
-					snapshot.setMissingExistence(missingExistence);
-				}
-				if (managedItemInfo.size !== 0) {
-					snapshot.setManagedItemInfo(managedItemInfo);
-				}
-				this._managedFilesOptimization.optimize(snapshot, managedFiles);
-				if (managedFiles.size !== 0) {
-					snapshot.setManagedFiles(managedFiles);
-				}
-				this._managedContextsOptimization.optimize(snapshot, managedContexts);
-				if (managedContexts.size !== 0) {
-					snapshot.setManagedContexts(managedContexts);
-				}
-				this._managedMissingOptimization.optimize(snapshot, managedMissing);
-				if (managedMissing.size !== 0) {
-					snapshot.setManagedMissing(managedMissing);
-				}
-				if (children.size !== 0) {
-					snapshot.setChildren(children);
-				}
-				this._snapshotCache.set(snapshot, true);
-				this._statCreatedSnapshots++;
+		this.running = true;
 
-				callback(null, snapshot);
+		const onCompiled = (err, compilation) => {
+			if (err) return finalCallback(err);
+
+			if (this.hooks.shouldEmit.call(compilation) === false) {
+				compilation.startTime = startTime;
+				compilation.endTime = Date.now();
+				const stats = new Stats(compilation);
+				this.hooks.done.callAsync(stats, err => {
+					if (err) return finalCallback(err);
+					return finalCallback(null, stats);
+				});
+				return;
 			}
+
+			process.nextTick(() => {
+				logger = compilation.getLogger("webpack.Compiler");
+				logger.time("emitAssets");
+				this.emitAssets(compilation, err => {
+					logger.timeEnd("emitAssets");
+					if (err) return finalCallback(err);
+
+					if (compilation.hooks.needAdditionalPass.call()) {
+						compilation.needAdditionalPass = true;
+
+						compilation.startTime = startTime;
+						compilation.endTime = Date.now();
+						logger.time("done hook");
+						const stats = new Stats(compilation);
+						this.hooks.done.callAsync(stats, err => {
+							logger.timeEnd("done hook");
+							if (err) return finalCallback(err);
+
+							this.hooks.additionalPass.callAsync(err => {
+								if (err) return finalCallback(err);
+								this.compile(onCompiled);
+							});
+						});
+						return;
+					}
+
+					logger.time("emitRecords");
+					this.emitRecords(err => {
+						logger.timeEnd("emitRecords");
+						if (err) return finalCallback(err);
+
+						compilation.startTime = startTime;
+						compilation.endTime = Date.now();
+						logger.time("done hook");
+						const stats = new Stats(compilation);
+						this.hooks.done.callAsync(stats, err => {
+							logger.timeEnd("done hook");
+							if (err) return finalCallback(err);
+							this.cache.storeBuildDependencies(
+								compilation.buildDependencies,
+								err => {
+									if (err) return finalCallback(err);
+									return finalCallback(null, stats);
+								}
+							);
+						});
+					});
+				});
+			});
 		};
-		const jobError = () => {
-			if (jobs > 0) {
-				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
-				jobs = -100000000;
-				callback(null, null);
-			}
+
+		const run = () => {
+			this.hooks.beforeRun.callAsync(this, err => {
+				if (err) return finalCallback(err);
+
+				this.hooks.run.callAsync(this, err => {
+					if (err) return finalCallback(err);
+
+					this.readRecords(err => {
+						if (err) return finalCallback(err);
+
+						this.compile(onCompiled);
+					});
+				});
+			});
 		};
-		const checkManaged = (path, managedSet) => {
-			for (const immutablePath of this.immutablePathsRegExps) {
-				if (immutablePath.test(path)) {
-					managedSet.add(path);
-					return true;
-				}
-			}
-			for (const immutablePath of this.immutablePathsWithSlash) {
-				if (path.startsWith(immutablePath)) {
-					managedSet.add(path);
-					return true;
-				}
+
+		if (this.idle) {
+			this.cache.endIdle(err => {
+				if (err) return finalCallback(err);
+
+				this.idle = false;
+				run();
+			});
+		} else {
+			run();
+		}
+	}
+
+	/**
+	 * @param {RunAsChildCallback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	runAsChild(callback) {
+		const startTime = Date.now();
+		this.compile((err, compilation) => {
+			if (err) return callback(err);
+
+			this.parentCompilation.children.push(compilation);
+			for (const { name, source, info } of compilation.getAssets()) {
+				this.parentCompilation.emitAsset(name, source, info);
 			}
-			for (const managedPath of this.managedPathsRegExps) {
-				const match = managedPath.exec(path);
-				if (match) {
-					const managedItem = getManagedItem(match[1], path);
-					if (managedItem) {
-						managedItems.add(managedItem);
-						managedSet.add(path);
-						return true;
-					}
-				}
+
+			const entries = [];
+			for (const ep of compilation.entrypoints.values()) {
+				entries.push(...ep.chunks);
 			}
-			for (const managedPath of this.managedPathsWithSlash) {
-				if (path.startsWith(managedPath)) {
-					const managedItem = getManagedItem(managedPath, path);
-					if (managedItem) {
-						managedItems.add(managedItem);
-						managedSet.add(path);
-						return true;
+
+			compilation.startTime = startTime;
+			compilation.endTime = Date.now();
+
+			return callback(null, entries, compilation);
+		});
+	}
+
+	purgeInputFileSystem() {
+		if (this.inputFileSystem && this.inputFileSystem.purge) {
+			this.inputFileSystem.purge();
+		}
+	}
+
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @param {Callback<void>} callback signals when the assets are emitted
+	 * @returns {void}
+	 */
+	emitAssets(compilation, callback) {
+		let outputPath;
+
+		const emitFiles = err => {
+			if (err) return callback(err);
+
+			const assets = compilation.getAssets();
+			compilation.assets = { ...compilation.assets };
+			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
+			const caseInsensitiveMap = new Map();
+			/** @type {Set<string>} */
+			const allTargetPaths = new Set();
+			asyncLib.forEachLimit(
+				assets,
+				15,
+				({ name: file, source, info }, callback) => {
+					let targetFile = file;
+					let immutable = info.immutable;
+					const queryStringIdx = targetFile.indexOf("?");
+					if (queryStringIdx >= 0) {
+						targetFile = targetFile.substr(0, queryStringIdx);
+						// We may remove the hash, which is in the query string
+						// So we recheck if the file is immutable
+						// This doesn't cover all cases, but immutable is only a performance optimization anyway
+						immutable =
+							immutable &&
+							(includesHash(targetFile, info.contenthash) ||
+								includesHash(targetFile, info.chunkhash) ||
+								includesHash(targetFile, info.modulehash) ||
+								includesHash(targetFile, info.fullhash));
 					}
-				}
-			}
-			return false;
-		};
-		const captureNonManaged = (items, managedSet) => {
-			const capturedItems = new Set();
-			for (const path of items) {
-				if (!checkManaged(path, managedSet)) capturedItems.add(path);
-			}
-			return capturedItems;
-		};
-		const processCapturedFiles = capturedFiles => {
-			switch (mode) {
-				case 3:
-					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
-					for (const path of capturedFiles) {
-						const cache = this._fileTshs.get(path);
-						if (cache !== undefined) {
-							fileTshs.set(path, cache);
-						} else {
-							jobs++;
-							this._getFileTimestampAndHash(path, (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting file timestamp hash combination of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									fileTshs.set(path, entry);
-									jobDone();
-								}
-							});
+
+					const writeOut = err => {
+						if (err) return callback(err);
+						const targetPath = join(
+							this.outputFileSystem,
+							outputPath,
+							targetFile
+						);
+						allTargetPaths.add(targetPath);
+
+						// check if the target file has already been written by this Compiler
+						const targetFileGeneration =
+							this._assetEmittingWrittenFiles.get(targetPath);
+
+						// create an cache entry for this Source if not already existing
+						let cacheEntry = this._assetEmittingSourceCache.get(source);
+						if (cacheEntry === undefined) {
+							cacheEntry = {
+								sizeOnlySource: undefined,
+								writtenTo: new Map()
+							};
+							this._assetEmittingSourceCache.set(source, cacheEntry);
 						}
-					}
-					break;
-				case 2:
-					this._fileHashesOptimization.optimize(snapshot, capturedFiles);
-					for (const path of capturedFiles) {
-						const cache = this._fileHashes.get(path);
-						if (cache !== undefined) {
-							fileHashes.set(path, cache);
-						} else {
-							jobs++;
-							this.fileHashQueue.add(path, (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting file hash of ${path}: ${err.stack}`
-										);
+
+						let similarEntry;
+
+						const checkSimilarFile = () => {
+							const caseInsensitiveTargetPath = targetPath.toLowerCase();
+							similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath);
+							if (similarEntry !== undefined) {
+								const { path: other, source: otherSource } = similarEntry;
+								if (isSourceEqual(otherSource, source)) {
+									// Size may or may not be available at this point.
+									// If it's not available add to "waiting" list and it will be updated once available
+									if (similarEntry.size !== undefined) {
+										updateWithReplacementSource(similarEntry.size);
+									} else {
+										if (!similarEntry.waiting) similarEntry.waiting = [];
+										similarEntry.waiting.push({ file, cacheEntry });
 									}
-									jobError();
+									alreadyWritten();
 								} else {
-									fileHashes.set(path, entry);
-									jobDone();
+									const err =
+										new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file.
+This will lead to a race-condition and corrupted files on case-insensitive file systems.
+${targetPath}
+${other}`);
+									err.file = file;
+									callback(err);
 								}
-							});
-						}
-					}
-					break;
-				case 1:
-					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
-					for (const path of capturedFiles) {
-						const cache = this._fileTimestamps.get(path);
-						if (cache !== undefined) {
-							if (cache !== "ignore") {
-								fileTimestamps.set(path, cache);
-							}
-						} else {
-							jobs++;
-							this.fileTimestampQueue.add(path, (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting file timestamp of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
+								return true;
+							} else {
+								caseInsensitiveMap.set(
+									caseInsensitiveTargetPath,
+									(similarEntry = {
+										path: targetPath,
+										source,
+										size: undefined,
+										waiting: undefined
+									})
+								);
+								return false;
+							}
+						};
+
+						/**
+						 * get the binary (Buffer) content from the Source
+						 * @returns {Buffer} content for the source
+						 */
+						const getContent = () => {
+							if (typeof source.buffer === "function") {
+								return source.buffer();
+							} else {
+								const bufferOrString = source.source();
+								if (Buffer.isBuffer(bufferOrString)) {
+									return bufferOrString;
 								} else {
-									fileTimestamps.set(path, entry);
-									jobDone();
+									return Buffer.from(bufferOrString, "utf8");
 								}
+							}
+						};
+
+						const alreadyWritten = () => {
+							// cache the information that the Source has been already been written to that location
+							if (targetFileGeneration === undefined) {
+								const newGeneration = 1;
+								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
+								cacheEntry.writtenTo.set(targetPath, newGeneration);
+							} else {
+								cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
+							}
+							callback();
+						};
+
+						/**
+						 * Write the file to output file system
+						 * @param {Buffer} content content to be written
+						 * @returns {void}
+						 */
+						const doWrite = content => {
+							this.outputFileSystem.writeFile(targetPath, content, err => {
+								if (err) return callback(err);
+
+								// information marker that the asset has been emitted
+								compilation.emittedAssets.add(file);
+
+								// cache the information that the Source has been written to that location
+								const newGeneration =
+									targetFileGeneration === undefined
+										? 1
+										: targetFileGeneration + 1;
+								cacheEntry.writtenTo.set(targetPath, newGeneration);
+								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
+								this.hooks.assetEmitted.callAsync(
+									file,
+									{
+										content,
+										source,
+										outputPath,
+										compilation,
+										targetPath
+									},
+									callback
+								);
 							});
-						}
-					}
-					break;
-			}
-		};
-		if (files) {
-			processCapturedFiles(captureNonManaged(files, managedFiles));
-		}
-		const processCapturedDirectories = capturedDirectories => {
-			switch (mode) {
-				case 3:
-					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
-					for (const path of capturedDirectories) {
-						const cache = this._contextTshs.get(path);
-						/** @type {ResolvedContextTimestampAndHash} */
-						let resolved;
-						if (
-							cache !== undefined &&
-							(resolved = getResolvedTimestamp(cache)) !== undefined
-						) {
-							contextTshs.set(path, resolved);
-						} else {
-							jobs++;
-							/**
-							 * @param {Error=} err error
-							 * @param {ResolvedContextTimestampAndHash=} entry entry
-							 * @returns {void}
-							 */
-							const callback = (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting context timestamp hash combination of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									contextTshs.set(path, entry);
-									jobDone();
+						};
+
+						const updateWithReplacementSource = size => {
+							updateFileWithReplacementSource(file, cacheEntry, size);
+							similarEntry.size = size;
+							if (similarEntry.waiting !== undefined) {
+								for (const { file, cacheEntry } of similarEntry.waiting) {
+									updateFileWithReplacementSource(file, cacheEntry, size);
 								}
-							};
-							if (cache !== undefined) {
-								this._resolveContextTsh(cache, callback);
-							} else {
-								this.getContextTsh(path, callback);
 							}
-						}
-					}
-					break;
-				case 2:
-					this._contextHashesOptimization.optimize(
-						snapshot,
-						capturedDirectories
-					);
-					for (const path of capturedDirectories) {
-						const cache = this._contextHashes.get(path);
-						let resolved;
-						if (
-							cache !== undefined &&
-							(resolved = getResolvedHash(cache)) !== undefined
-						) {
-							contextHashes.set(path, resolved);
-						} else {
-							jobs++;
-							const callback = (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting context hash of ${path}: ${err.stack}`
-										);
+						};
+
+						const updateFileWithReplacementSource = (
+							file,
+							cacheEntry,
+							size
+						) => {
+							// Create a replacement resource which only allows to ask for size
+							// This allows to GC all memory allocated by the Source
+							// (expect when the Source is stored in any other cache)
+							if (!cacheEntry.sizeOnlySource) {
+								cacheEntry.sizeOnlySource = new SizeOnlySource(size);
+							}
+							compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+								size
+							});
+						};
+
+						const processExistingFile = stats => {
+							// skip emitting if it's already there and an immutable file
+							if (immutable) {
+								updateWithReplacementSource(stats.size);
+								return alreadyWritten();
+							}
+
+							const content = getContent();
+
+							updateWithReplacementSource(content.length);
+
+							// if it exists and content on disk matches content
+							// skip writing the same content again
+							// (to keep mtime and don't trigger watchers)
+							// for a fast negative match file size is compared first
+							if (content.length === stats.size) {
+								compilation.comparedForEmitAssets.add(file);
+								return this.outputFileSystem.readFile(
+									targetPath,
+									(err, existingContent) => {
+										if (
+											err ||
+											!content.equals(/** @type {Buffer} */ (existingContent))
+										) {
+											return doWrite(content);
+										} else {
+											return alreadyWritten();
+										}
 									}
-									jobError();
+								);
+							}
+
+							return doWrite(content);
+						};
+
+						const processMissingFile = () => {
+							const content = getContent();
+
+							updateWithReplacementSource(content.length);
+
+							return doWrite(content);
+						};
+
+						// if the target file has already been written
+						if (targetFileGeneration !== undefined) {
+							// check if the Source has been written to this target file
+							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
+							if (writtenGeneration === targetFileGeneration) {
+								// if yes, we may skip writing the file
+								// if it's already there
+								// (we assume one doesn't modify files while the Compiler is running, other then removing them)
+
+								if (this._assetEmittingPreviousFiles.has(targetPath)) {
+									// We assume that assets from the last compilation say intact on disk (they are not removed)
+									compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+										size: cacheEntry.sizeOnlySource.size()
+									});
+
+									return callback();
 								} else {
-									contextHashes.set(path, entry);
-									jobDone();
+									// Settings immutable will make it accept file content without comparing when file exist
+									immutable = true;
 								}
-							};
-							if (cache !== undefined) {
-								this._resolveContextHash(cache, callback);
-							} else {
-								this.getContextHash(path, callback);
+							} else if (!immutable) {
+								if (checkSimilarFile()) return;
+								// We wrote to this file before which has very likely a different content
+								// skip comparing and assume content is different for performance
+								// This case happens often during watch mode.
+								return processMissingFile();
 							}
 						}
-					}
-					break;
-				case 1:
-					this._contextTimestampsOptimization.optimize(
-						snapshot,
-						capturedDirectories
-					);
-					for (const path of capturedDirectories) {
-						const cache = this._contextTimestamps.get(path);
-						if (cache === "ignore") continue;
-						let resolved;
-						if (
-							cache !== undefined &&
-							(resolved = getResolvedTimestamp(cache)) !== undefined
-						) {
-							contextTimestamps.set(path, resolved);
-						} else {
-							jobs++;
-							/**
-							 * @param {Error=} err error
-							 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
-							 * @returns {void}
-							 */
-							const callback = (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting context timestamp of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
+
+						if (checkSimilarFile()) return;
+						if (this.options.output.compareBeforeEmit) {
+							this.outputFileSystem.stat(targetPath, (err, stats) => {
+								const exists = !err && stats.isFile();
+
+								if (exists) {
+									processExistingFile(stats);
 								} else {
-									contextTimestamps.set(path, entry);
-									jobDone();
+									processMissingFile();
 								}
-							};
-							if (cache !== undefined) {
-								this._resolveContextTimestamp(cache, callback);
-							} else {
-								this.getContextTimestamp(path, callback);
-							}
+							});
+						} else {
+							processMissingFile();
 						}
+					};
+
+					if (targetFile.match(/\/|\\/)) {
+						const fs = this.outputFileSystem;
+						const dir = dirname(fs, join(fs, outputPath, targetFile));
+						mkdirp(fs, dir, writeOut);
+					} else {
+						writeOut();
 					}
-					break;
-			}
-		};
-		if (directories) {
-			processCapturedDirectories(
-				captureNonManaged(directories, managedContexts)
-			);
-		}
-		const processCapturedMissing = capturedMissing => {
-			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
-			for (const path of capturedMissing) {
-				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (cache !== "ignore") {
-						missingExistence.set(path, Boolean(cache));
+				},
+				err => {
+					// Clear map to free up memory
+					caseInsensitiveMap.clear();
+					if (err) {
+						this._assetEmittingPreviousFiles.clear();
+						return callback(err);
 					}
-				} else {
-					jobs++;
-					this.fileTimestampQueue.add(path, (err, entry) => {
-						if (err) {
-							if (this.logger) {
-								this.logger.debug(
-									`Error snapshotting missing timestamp of ${path}: ${err.stack}`
-								);
-							}
-							jobError();
-						} else {
-							missingExistence.set(path, Boolean(entry));
-							jobDone();
-						}
+
+					this._assetEmittingPreviousFiles = allTargetPaths;
+
+					this.hooks.afterEmit.callAsync(compilation, err => {
+						if (err) return callback(err);
+
+						return callback();
 					});
 				}
-			}
+			);
 		};
-		if (missing) {
-			processCapturedMissing(captureNonManaged(missing, managedMissing));
-		}
-		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
-		for (const path of managedItems) {
-			const cache = this._managedItems.get(path);
-			if (cache !== undefined) {
-				if (!cache.startsWith("*")) {
-					managedFiles.add(join(this.fs, path, "package.json"));
-				} else if (cache === "*nested") {
-					managedMissing.add(join(this.fs, path, "package.json"));
-				}
-				managedItemInfo.set(path, cache);
-			} else {
-				jobs++;
-				this.managedItemQueue.add(path, (err, entry) => {
-					if (err) {
-						if (this.logger) {
-							this.logger.debug(
-								`Error snapshotting managed item ${path}: ${err.stack}`
-							);
-						}
-						jobError();
-					} else if (entry) {
-						if (!entry.startsWith("*")) {
-							managedFiles.add(join(this.fs, path, "package.json"));
-						} else if (cache === "*nested") {
-							managedMissing.add(join(this.fs, path, "package.json"));
-						}
-						managedItemInfo.set(path, entry);
-						jobDone();
-					} else {
-						// Fallback to normal snapshotting
-						const process = (set, fn) => {
-							if (set.size === 0) return;
-							const captured = new Set();
-							for (const file of set) {
-								if (file.startsWith(path)) captured.add(file);
-							}
-							if (captured.size > 0) fn(captured);
-						};
-						process(managedFiles, processCapturedFiles);
-						process(managedContexts, processCapturedDirectories);
-						process(managedMissing, processCapturedMissing);
-						jobDone();
-					}
-				});
-			}
-		}
-		jobDone();
-	}
 
-	/**
-	 * @param {Snapshot} snapshot1 a snapshot
-	 * @param {Snapshot} snapshot2 a snapshot
-	 * @returns {Snapshot} merged snapshot
-	 */
-	mergeSnapshots(snapshot1, snapshot2) {
-		const snapshot = new Snapshot();
-		if (snapshot1.hasStartTime() && snapshot2.hasStartTime())
-			snapshot.setStartTime(Math.min(snapshot1.startTime, snapshot2.startTime));
-		else if (snapshot2.hasStartTime()) snapshot.startTime = snapshot2.startTime;
-		else if (snapshot1.hasStartTime()) snapshot.startTime = snapshot1.startTime;
-		if (snapshot1.hasFileTimestamps() || snapshot2.hasFileTimestamps()) {
-			snapshot.setFileTimestamps(
-				mergeMaps(snapshot1.fileTimestamps, snapshot2.fileTimestamps)
-			);
-		}
-		if (snapshot1.hasFileHashes() || snapshot2.hasFileHashes()) {
-			snapshot.setFileHashes(
-				mergeMaps(snapshot1.fileHashes, snapshot2.fileHashes)
-			);
-		}
-		if (snapshot1.hasFileTshs() || snapshot2.hasFileTshs()) {
-			snapshot.setFileTshs(mergeMaps(snapshot1.fileTshs, snapshot2.fileTshs));
-		}
-		if (snapshot1.hasContextTimestamps() || snapshot2.hasContextTimestamps()) {
-			snapshot.setContextTimestamps(
-				mergeMaps(snapshot1.contextTimestamps, snapshot2.contextTimestamps)
-			);
-		}
-		if (snapshot1.hasContextHashes() || snapshot2.hasContextHashes()) {
-			snapshot.setContextHashes(
-				mergeMaps(snapshot1.contextHashes, snapshot2.contextHashes)
-			);
-		}
-		if (snapshot1.hasContextTshs() || snapshot2.hasContextTshs()) {
-			snapshot.setContextTshs(
-				mergeMaps(snapshot1.contextTshs, snapshot2.contextTshs)
-			);
-		}
-		if (snapshot1.hasMissingExistence() || snapshot2.hasMissingExistence()) {
-			snapshot.setMissingExistence(
-				mergeMaps(snapshot1.missingExistence, snapshot2.missingExistence)
-			);
-		}
-		if (snapshot1.hasManagedItemInfo() || snapshot2.hasManagedItemInfo()) {
-			snapshot.setManagedItemInfo(
-				mergeMaps(snapshot1.managedItemInfo, snapshot2.managedItemInfo)
-			);
-		}
-		if (snapshot1.hasManagedFiles() || snapshot2.hasManagedFiles()) {
-			snapshot.setManagedFiles(
-				mergeSets(snapshot1.managedFiles, snapshot2.managedFiles)
-			);
-		}
-		if (snapshot1.hasManagedContexts() || snapshot2.hasManagedContexts()) {
-			snapshot.setManagedContexts(
-				mergeSets(snapshot1.managedContexts, snapshot2.managedContexts)
-			);
-		}
-		if (snapshot1.hasManagedMissing() || snapshot2.hasManagedMissing()) {
-			snapshot.setManagedMissing(
-				mergeSets(snapshot1.managedMissing, snapshot2.managedMissing)
-			);
-		}
-		if (snapshot1.hasChildren() || snapshot2.hasChildren()) {
-			snapshot.setChildren(mergeSets(snapshot1.children, snapshot2.children));
-		}
-		if (
-			this._snapshotCache.get(snapshot1) === true &&
-			this._snapshotCache.get(snapshot2) === true
-		) {
-			this._snapshotCache.set(snapshot, true);
-		}
-		return snapshot;
+		this.hooks.emit.callAsync(compilation, err => {
+			if (err) return callback(err);
+			outputPath = compilation.getPath(this.outputPath, {});
+			mkdirp(this.outputFileSystem, outputPath, emitFiles);
+		});
 	}
 
 	/**
-	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @param {Callback<void>} callback signals when the call finishes
 	 * @returns {void}
 	 */
-	checkSnapshotValid(snapshot, callback) {
-		const cachedResult = this._snapshotCache.get(snapshot);
-		if (cachedResult !== undefined) {
-			this._statTestedSnapshotsCached++;
-			if (typeof cachedResult === "boolean") {
-				callback(null, cachedResult);
+	emitRecords(callback) {
+		if (this.hooks.emitRecords.isUsed()) {
+			if (this.recordsOutputPath) {
+				asyncLib.parallel(
+					[
+						cb => this.hooks.emitRecords.callAsync(cb),
+						this._emitRecords.bind(this)
+					],
+					err => callback(err)
+				);
 			} else {
-				cachedResult.push(callback);
+				this.hooks.emitRecords.callAsync(callback);
+			}
+		} else {
+			if (this.recordsOutputPath) {
+				this._emitRecords(callback);
+			} else {
+				callback();
 			}
-			return;
 		}
-		this._statTestedSnapshotsNotCached++;
-		this._checkSnapshotValidNoCache(snapshot, callback);
 	}
 
 	/**
-	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @param {Callback<void>} callback signals when the call finishes
 	 * @returns {void}
 	 */
-	_checkSnapshotValidNoCache(snapshot, callback) {
-		/** @type {number | undefined} */
-		let startTime = undefined;
-		if (snapshot.hasStartTime()) {
-			startTime = snapshot.startTime;
-		}
-		let jobs = 1;
-		const jobDone = () => {
-			if (--jobs === 0) {
-				this._snapshotCache.set(snapshot, true);
-				callback(null, true);
-			}
-		};
-		const invalid = () => {
-			if (jobs > 0) {
-				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
-				jobs = -100000000;
-				this._snapshotCache.set(snapshot, false);
-				callback(null, false);
-			}
-		};
-		const invalidWithError = (path, err) => {
-			if (this._remainingLogs > 0) {
-				this._log(path, `error occurred: %s`, err);
-			}
-			invalid();
-		};
-		/**
-		 * @param {string} path file path
-		 * @param {string} current current hash
-		 * @param {string} snap snapshot hash
-		 * @returns {boolean} true, if ok
-		 */
-		const checkHash = (path, current, snap) => {
-			if (current !== snap) {
-				// If hash differ it's invalid
-				if (this._remainingLogs > 0) {
-					this._log(path, `hashes differ (%s != %s)`, current, snap);
-				}
-				return false;
-			}
-			return true;
-		};
-		/**
-		 * @param {string} path file path
-		 * @param {boolean} current current entry
-		 * @param {boolean} snap entry from snapshot
-		 * @returns {boolean} true, if ok
-		 */
-		const checkExistence = (path, current, snap) => {
-			if (!current !== !snap) {
-				// If existence of item differs
-				// it's invalid
-				if (this._remainingLogs > 0) {
-					this._log(
-						path,
-						current ? "it didn't exist before" : "it does no longer exist"
-					);
-				}
-				return false;
-			}
-			return true;
-		};
-		/**
-		 * @param {string} path file path
-		 * @param {FileSystemInfoEntry} current current entry
-		 * @param {FileSystemInfoEntry} snap entry from snapshot
-		 * @param {boolean} log log reason
-		 * @returns {boolean} true, if ok
-		 */
-		const checkFile = (path, current, snap, log = true) => {
-			if (current === snap) return true;
-			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
-			if (current) {
-				// For existing items only
-				if (typeof startTime === "number" && current.safeTime > startTime) {
-					// If a change happened after starting reading the item
-					// this may no longer be valid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`it may have changed (%d) after the start time of the snapshot (%d)`,
-							current.safeTime,
-							startTime
-						);
-					}
-					return false;
-				}
-				if (
-					snap.timestamp !== undefined &&
-					current.timestamp !== snap.timestamp
-				) {
-					// If we have a timestamp (it was a file or symlink) and it differs from current timestamp
-					// it's invalid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`timestamps differ (%d != %d)`,
-							current.timestamp,
-							snap.timestamp
-						);
-					}
-					return false;
-				}
-			}
-			return true;
-		};
-		/**
-		 * @param {string} path file path
-		 * @param {ResolvedContextFileSystemInfoEntry} current current entry
-		 * @param {ResolvedContextFileSystemInfoEntry} snap entry from snapshot
-		 * @param {boolean} log log reason
-		 * @returns {boolean} true, if ok
-		 */
-		const checkContext = (path, current, snap, log = true) => {
-			if (current === snap) return true;
-			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
-			if (current) {
-				// For existing items only
-				if (typeof startTime === "number" && current.safeTime > startTime) {
-					// If a change happened after starting reading the item
-					// this may no longer be valid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`it may have changed (%d) after the start time of the snapshot (%d)`,
-							current.safeTime,
-							startTime
-						);
-					}
-					return false;
-				}
-				if (
-					snap.timestampHash !== undefined &&
-					current.timestampHash !== snap.timestampHash
-				) {
-					// If we have a timestampHash (it was a directory) and it differs from current timestampHash
-					// it's invalid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`timestamps hashes differ (%s != %s)`,
-							current.timestampHash,
-							snap.timestampHash
-						);
-					}
-					return false;
-				}
-			}
-			return true;
-		};
-		if (snapshot.hasChildren()) {
-			const childCallback = (err, result) => {
-				if (err || !result) return invalid();
-				else jobDone();
-			};
-			for (const child of snapshot.children) {
-				const cache = this._snapshotCache.get(child);
-				if (cache !== undefined) {
-					this._statTestedChildrenCached++;
-					/* istanbul ignore else */
-					if (typeof cache === "boolean") {
-						if (cache === false) {
-							invalid();
-							return;
-						}
-					} else {
-						jobs++;
-						cache.push(childCallback);
-					}
-				} else {
-					this._statTestedChildrenNotCached++;
-					jobs++;
-					this._checkSnapshotValidNoCache(child, childCallback);
-				}
-			}
-		}
-		if (snapshot.hasFileTimestamps()) {
-			const { fileTimestamps } = snapshot;
-			this._statTestedEntries += fileTimestamps.size;
-			for (const [path, ts] of fileTimestamps) {
-				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (cache !== "ignore" && !checkFile(path, cache, ts)) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					this.fileTimestampQueue.add(path, (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkFile(path, entry, ts)) {
-							invalid();
-						} else {
-							jobDone();
+	_emitRecords(callback) {
+		const writeFile = () => {
+			this.outputFileSystem.writeFile(
+				this.recordsOutputPath,
+				JSON.stringify(
+					this.records,
+					(n, value) => {
+						if (
+							typeof value === "object" &&
+							value !== null &&
+							!Array.isArray(value)
+						) {
+							const keys = Object.keys(value);
+							if (!isSorted(keys)) {
+								return sortObject(value, keys);
+							}
 						}
-					});
-				}
-			}
+						return value;
+					},
+					2
+				),
+				callback
+			);
+		};
+
+		const recordsOutputPathDirectory = dirname(
+			this.outputFileSystem,
+			this.recordsOutputPath
+		);
+		if (!recordsOutputPathDirectory) {
+			return writeFile();
 		}
-		const processFileHashSnapshot = (path, hash) => {
-			const cache = this._fileHashes.get(path);
-			if (cache !== undefined) {
-				if (cache !== "ignore" && !checkHash(path, cache, hash)) {
-					invalid();
-					return;
-				}
+		mkdirp(this.outputFileSystem, recordsOutputPathDirectory, err => {
+			if (err) return callback(err);
+			writeFile();
+		});
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	readRecords(callback) {
+		if (this.hooks.readRecords.isUsed()) {
+			if (this.recordsInputPath) {
+				asyncLib.parallel([
+					cb => this.hooks.readRecords.callAsync(cb),
+					this._readRecords.bind(this)
+				]);
 			} else {
-				jobs++;
-				this.fileHashQueue.add(path, (err, entry) => {
-					if (err) return invalidWithError(path, err);
-					if (!checkHash(path, entry, hash)) {
-						invalid();
-					} else {
-						jobDone();
-					}
-				});
+				this.records = {};
+				this.hooks.readRecords.callAsync(callback);
 			}
-		};
-		if (snapshot.hasFileHashes()) {
-			const { fileHashes } = snapshot;
-			this._statTestedEntries += fileHashes.size;
-			for (const [path, hash] of fileHashes) {
-				processFileHashSnapshot(path, hash);
+		} else {
+			if (this.recordsInputPath) {
+				this._readRecords(callback);
+			} else {
+				this.records = {};
+				callback();
 			}
 		}
-		if (snapshot.hasFileTshs()) {
-			const { fileTshs } = snapshot;
-			this._statTestedEntries += fileTshs.size;
-			for (const [path, tsh] of fileTshs) {
-				if (typeof tsh === "string") {
-					processFileHashSnapshot(path, tsh);
-				} else {
-					const cache = this._fileTimestamps.get(path);
-					if (cache !== undefined) {
-						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
-							processFileHashSnapshot(path, tsh && tsh.hash);
-						}
-					} else {
-						jobs++;
-						this.fileTimestampQueue.add(path, (err, entry) => {
-							if (err) return invalidWithError(path, err);
-							if (!checkFile(path, entry, tsh, false)) {
-								processFileHashSnapshot(path, tsh && tsh.hash);
-							}
-							jobDone();
-						});
-					}
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_readRecords(callback) {
+		if (!this.recordsInputPath) {
+			this.records = {};
+			return callback();
+		}
+		this.inputFileSystem.stat(this.recordsInputPath, err => {
+			// It doesn't exist
+			// We can ignore this.
+			if (err) return callback();
+
+			this.inputFileSystem.readFile(this.recordsInputPath, (err, content) => {
+				if (err) return callback(err);
+
+				try {
+					this.records = parseJson(content.toString("utf-8"));
+				} catch (e) {
+					e.message = "Cannot parse records: " + e.message;
+					return callback(e);
 				}
+
+				return callback();
+			});
+		});
+	}
+
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @param {string} compilerName the compiler's name
+	 * @param {number} compilerIndex the compiler's index
+	 * @param {OutputOptions=} outputOptions the output options
+	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
+	 * @returns {Compiler} a child compiler
+	 */
+	createChildCompiler(
+		compilation,
+		compilerName,
+		compilerIndex,
+		outputOptions,
+		plugins
+	) {
+		const childCompiler = new Compiler(this.context, {
+			...this.options,
+			output: {
+				...this.options.output,
+				...outputOptions
 			}
+		});
+		childCompiler.name = compilerName;
+		childCompiler.outputPath = this.outputPath;
+		childCompiler.inputFileSystem = this.inputFileSystem;
+		childCompiler.outputFileSystem = null;
+		childCompiler.resolverFactory = this.resolverFactory;
+		childCompiler.modifiedFiles = this.modifiedFiles;
+		childCompiler.removedFiles = this.removedFiles;
+		childCompiler.fileTimestamps = this.fileTimestamps;
+		childCompiler.contextTimestamps = this.contextTimestamps;
+		childCompiler.fsStartTime = this.fsStartTime;
+		childCompiler.cache = this.cache;
+		childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
+		childCompiler._backCompat = this._backCompat;
+
+		const relativeCompilerName = makePathsRelative(
+			this.context,
+			compilerName,
+			this.root
+		);
+		if (!this.records[relativeCompilerName]) {
+			this.records[relativeCompilerName] = [];
 		}
-		if (snapshot.hasContextTimestamps()) {
-			const { contextTimestamps } = snapshot;
-			this._statTestedEntries += contextTimestamps.size;
-			for (const [path, ts] of contextTimestamps) {
-				const cache = this._contextTimestamps.get(path);
-				if (cache === "ignore") continue;
-				let resolved;
-				if (
-					cache !== undefined &&
-					(resolved = getResolvedTimestamp(cache)) !== undefined
-				) {
-					if (!checkContext(path, resolved, ts)) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					/**
-					 * @param {Error=} err error
-					 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
-					 * @returns {void}
-					 */
-					const callback = (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkContext(path, entry, ts)) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					};
-					if (cache !== undefined) {
-						this._resolveContextTimestamp(cache, callback);
-					} else {
-						this.getContextTimestamp(path, callback);
-					}
-				}
+		if (this.records[relativeCompilerName][compilerIndex]) {
+			childCompiler.records = this.records[relativeCompilerName][compilerIndex];
+		} else {
+			this.records[relativeCompilerName].push((childCompiler.records = {}));
+		}
+
+		childCompiler.parentCompilation = compilation;
+		childCompiler.root = this.root;
+		if (Array.isArray(plugins)) {
+			for (const plugin of plugins) {
+				plugin.apply(childCompiler);
 			}
 		}
-		const processContextHashSnapshot = (path, hash) => {
-			const cache = this._contextHashes.get(path);
-			let resolved;
+		for (const name in this.hooks) {
 			if (
-				cache !== undefined &&
-				(resolved = getResolvedHash(cache)) !== undefined
+				![
+					"make",
+					"compile",
+					"emit",
+					"afterEmit",
+					"invalid",
+					"done",
+					"thisCompilation"
+				].includes(name)
 			) {
-				if (!checkHash(path, resolved, hash)) {
-					invalid();
-					return;
-				}
-			} else {
-				jobs++;
-				const callback = (err, entry) => {
-					if (err) return invalidWithError(path, err);
-					if (!checkHash(path, entry, hash)) {
-						invalid();
-					} else {
-						jobDone();
-					}
-				};
-				if (cache !== undefined) {
-					this._resolveContextHash(cache, callback);
-				} else {
-					this.getContextHash(path, callback);
-				}
-			}
-		};
-		if (snapshot.hasContextHashes()) {
-			const { contextHashes } = snapshot;
-			this._statTestedEntries += contextHashes.size;
-			for (const [path, hash] of contextHashes) {
-				processContextHashSnapshot(path, hash);
-			}
-		}
-		if (snapshot.hasContextTshs()) {
-			const { contextTshs } = snapshot;
-			this._statTestedEntries += contextTshs.size;
-			for (const [path, tsh] of contextTshs) {
-				if (typeof tsh === "string") {
-					processContextHashSnapshot(path, tsh);
-				} else {
-					const cache = this._contextTimestamps.get(path);
-					if (cache === "ignore") continue;
-					let resolved;
-					if (
-						cache !== undefined &&
-						(resolved = getResolvedTimestamp(cache)) !== undefined
-					) {
-						if (!checkContext(path, resolved, tsh, false)) {
-							processContextHashSnapshot(path, tsh && tsh.hash);
-						}
-					} else {
-						jobs++;
-						/**
-						 * @param {Error=} err error
-						 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
-						 * @returns {void}
-						 */
-						const callback = (err, entry) => {
-							if (err) return invalidWithError(path, err);
-							if (!checkContext(path, entry, tsh, false)) {
-								processContextHashSnapshot(path, tsh && tsh.hash);
-							}
-							jobDone();
-						};
-						if (cache !== undefined) {
-							this._resolveContextTimestamp(cache, callback);
-						} else {
-							this.getContextTimestamp(path, callback);
-						}
-					}
+				if (childCompiler.hooks[name]) {
+					childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
 				}
 			}
 		}
-		if (snapshot.hasMissingExistence()) {
-			const { missingExistence } = snapshot;
-			this._statTestedEntries += missingExistence.size;
-			for (const [path, existence] of missingExistence) {
-				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (
-						cache !== "ignore" &&
-						!checkExistence(path, Boolean(cache), Boolean(existence))
-					) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					this.fileTimestampQueue.add(path, (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkExistence(path, Boolean(entry), Boolean(existence))) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					});
-				}
-			}
-		}
-		if (snapshot.hasManagedItemInfo()) {
-			const { managedItemInfo } = snapshot;
-			this._statTestedEntries += managedItemInfo.size;
-			for (const [path, info] of managedItemInfo) {
-				const cache = this._managedItems.get(path);
-				if (cache !== undefined) {
-					if (!checkHash(path, cache, info)) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					this.managedItemQueue.add(path, (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkHash(path, entry, info)) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					});
-				}
-			}
-		}
-		jobDone();
 
-		// if there was an async action
-		// try to join multiple concurrent request for this snapshot
-		if (jobs > 0) {
-			const callbacks = [callback];
-			callback = (err, result) => {
-				for (const callback of callbacks) callback(err, result);
-			};
-			this._snapshotCache.set(snapshot, callbacks);
-		}
+		compilation.hooks.childCompiler.call(
+			childCompiler,
+			compilerName,
+			compilerIndex
+		);
+
+		return childCompiler;
 	}
 
-	_readFileTimestamp(path, callback) {
-		this.fs.stat(path, (err, stat) => {
-			if (err) {
-				if (err.code === "ENOENT") {
-					this._fileTimestamps.set(path, null);
-					this._cachedDeprecatedFileTimestamps = undefined;
-					return callback(null, null);
-				}
-				return callback(err);
-			}
+	isChild() {
+		return !!this.parentCompilation;
+	}
 
-			let ts;
-			if (stat.isDirectory()) {
-				ts = {
-					safeTime: 0,
-					timestamp: undefined
-				};
-			} else {
-				const mtime = +stat.mtime;
+	createCompilation(params) {
+		this._cleanupLastCompilation();
+		return (this._lastCompilation = new Compilation(this, params));
+	}
 
-				if (mtime) applyMtime(mtime);
+	/**
+	 * @param {CompilationParams} params the compilation parameters
+	 * @returns {Compilation} the created compilation
+	 */
+	newCompilation(params) {
+		const compilation = this.createCompilation(params);
+		compilation.name = this.name;
+		compilation.records = this.records;
+		this.hooks.thisCompilation.call(compilation, params);
+		this.hooks.compilation.call(compilation, params);
+		return compilation;
+	}
 
-				ts = {
-					safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
-					timestamp: mtime
-				};
-			}
+	createNormalModuleFactory() {
+		this._cleanupLastNormalModuleFactory();
+		const normalModuleFactory = new NormalModuleFactory({
+			context: this.options.context,
+			fs: this.inputFileSystem,
+			resolverFactory: this.resolverFactory,
+			options: this.options.module,
+			associatedObjectForCache: this.root,
+			layers: this.options.experiments.layers
+		});
+		this._lastNormalModuleFactory = normalModuleFactory;
+		this.hooks.normalModuleFactory.call(normalModuleFactory);
+		return normalModuleFactory;
+	}
 
-			this._fileTimestamps.set(path, ts);
-			this._cachedDeprecatedFileTimestamps = undefined;
+	createContextModuleFactory() {
+		const contextModuleFactory = new ContextModuleFactory(this.resolverFactory);
+		this.hooks.contextModuleFactory.call(contextModuleFactory);
+		return contextModuleFactory;
+	}
 
-			callback(null, ts);
-		});
+	newCompilationParams() {
+		const params = {
+			normalModuleFactory: this.createNormalModuleFactory(),
+			contextModuleFactory: this.createContextModuleFactory()
+		};
+		return params;
 	}
 
-	_readFileHash(path, callback) {
-		this.fs.readFile(path, (err, content) => {
-			if (err) {
-				if (err.code === "EISDIR") {
-					this._fileHashes.set(path, "directory");
-					return callback(null, "directory");
-				}
-				if (err.code === "ENOENT") {
-					this._fileHashes.set(path, null);
-					return callback(null, null);
-				}
-				if (err.code === "ERR_FS_FILE_TOO_LARGE") {
-					this.logger.warn(`Ignoring ${path} for hashing as it's very large`);
-					this._fileHashes.set(path, "too large");
-					return callback(null, "too large");
-				}
-				return callback(err);
-			}
+	/**
+	 * @param {Callback<Compilation>} callback signals when the compilation finishes
+	 * @returns {void}
+	 */
+	compile(callback) {
+		const params = this.newCompilationParams();
+		this.hooks.beforeCompile.callAsync(params, err => {
+			if (err) return callback(err);
 
-			const hash = createHash(this._hashFunction);
+			this.hooks.compile.call(params);
 
-			hash.update(content);
+			const compilation = this.newCompilation(params);
 
-			const digest = /** @type {string} */ (hash.digest("hex"));
+			const logger = compilation.getLogger("webpack.Compiler");
 
-			this._fileHashes.set(path, digest);
+			logger.time("make hook");
+			this.hooks.make.callAsync(compilation, err => {
+				logger.timeEnd("make hook");
+				if (err) return callback(err);
 
-			callback(null, digest);
-		});
-	}
+				logger.time("finish make hook");
+				this.hooks.finishMake.callAsync(compilation, err => {
+					logger.timeEnd("finish make hook");
+					if (err) return callback(err);
 
-	_getFileTimestampAndHash(path, callback) {
-		const continueWithHash = hash => {
-			const cache = this._fileTimestamps.get(path);
-			if (cache !== undefined) {
-				if (cache !== "ignore") {
-					const result = {
-						...cache,
-						hash
-					};
-					this._fileTshs.set(path, result);
-					return callback(null, result);
-				} else {
-					this._fileTshs.set(path, hash);
-					return callback(null, hash);
-				}
-			} else {
-				this.fileTimestampQueue.add(path, (err, entry) => {
-					if (err) {
-						return callback(err);
-					}
-					const result = {
-						...entry,
-						hash
-					};
-					this._fileTshs.set(path, result);
-					return callback(null, result);
-				});
-			}
-		};
+					process.nextTick(() => {
+						logger.time("finish compilation");
+						compilation.finish(err => {
+							logger.timeEnd("finish compilation");
+							if (err) return callback(err);
 
-		const cache = this._fileHashes.get(path);
-		if (cache !== undefined) {
-			continueWithHash(cache);
-		} else {
-			this.fileHashQueue.add(path, (err, entry) => {
-				if (err) {
-					return callback(err);
-				}
-				continueWithHash(entry);
+							logger.time("seal compilation");
+							compilation.seal(err => {
+								logger.timeEnd("seal compilation");
+								if (err) return callback(err);
+
+								logger.time("afterCompile hook");
+								this.hooks.afterCompile.callAsync(compilation, err => {
+									logger.timeEnd("afterCompile hook");
+									if (err) return callback(err);
+
+									return callback(null, compilation);
+								});
+							});
+						});
+					});
+				});
 			});
-		}
+		});
 	}
 
 	/**
-	 * @template T
-	 * @template ItemType
-	 * @param {Object} options options
-	 * @param {string} options.path path
-	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
-	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
-	 * @param {function(string, string, function(Error=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
-	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromFile called when context item is a file
-	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromDirectory called when context item is a directory
-	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
-	 * @param {function((Error | null)=, (T)=): void} callback callback
+	 * @param {Callback<void>} callback signals when the compiler closes
+	 * @returns {void}
 	 */
-	_readContext(
-		{
-			path,
-			fromImmutablePath,
-			fromManagedItem,
-			fromSymlink,
-			fromFile,
-			fromDirectory,
-			reduce
-		},
-		callback
-	) {
-		this.fs.readdir(path, (err, _files) => {
-			if (err) {
-				if (err.code === "ENOENT") {
-					return callback(null, null);
-				}
-				return callback(err);
-			}
-			const files = /** @type {string[]} */ (_files)
-				.map(file => file.normalize("NFC"))
-				.filter(file => !/^\./.test(file))
-				.sort();
-			asyncLib.map(
-				files,
-				(file, callback) => {
-					const child = join(this.fs, path, file);
-					for (const immutablePath of this.immutablePathsRegExps) {
-						if (immutablePath.test(path)) {
-							// ignore any immutable path for timestamping
-							return callback(null, fromImmutablePath(path));
-						}
-					}
-					for (const immutablePath of this.immutablePathsWithSlash) {
-						if (path.startsWith(immutablePath)) {
-							// ignore any immutable path for timestamping
-							return callback(null, fromImmutablePath(path));
-						}
-					}
-					for (const managedPath of this.managedPathsRegExps) {
-						const match = managedPath.exec(path);
-						if (match) {
-							const managedItem = getManagedItem(match[1], path);
-							if (managedItem) {
-								// construct timestampHash from managed info
-								return this.managedItemQueue.add(managedItem, (err, info) => {
-									if (err) return callback(err);
-									return callback(null, fromManagedItem(info));
-								});
-							}
-						}
-					}
-					for (const managedPath of this.managedPathsWithSlash) {
-						if (path.startsWith(managedPath)) {
-							const managedItem = getManagedItem(managedPath, child);
-							if (managedItem) {
-								// construct timestampHash from managed info
-								return this.managedItemQueue.add(managedItem, (err, info) => {
-									if (err) return callback(err);
-									return callback(null, fromManagedItem(info));
-								});
-							}
-						}
-					}
+	close(callback) {
+		if (this.watching) {
+			// When there is still an active watching, close this first
+			this.watching.close(err => {
+				this.close(callback);
+			});
+			return;
+		}
+		this.hooks.shutdown.callAsync(err => {
+			if (err) return callback(err);
+			// Get rid of reference to last compilation to avoid leaking memory
+			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
+			// might be still in use. We try to get rid of the reference to the cache instead.
+			this._lastCompilation = undefined;
+			this._lastNormalModuleFactory = undefined;
+			this.cache.shutdown(callback);
+		});
+	}
+}
 
-					lstatReadlinkAbsolute(this.fs, child, (err, stat) => {
-						if (err) return callback(err);
+module.exports = Compiler;
 
-						if (typeof stat === "string") {
-							return fromSymlink(child, stat, callback);
-						}
 
-						if (stat.isFile()) {
-							return fromFile(child, stat, callback);
-						}
-						if (stat.isDirectory()) {
-							return fromDirectory(child, stat, callback);
-						}
-						callback(null, null);
-					});
-				},
-				(err, results) => {
-					if (err) return callback(err);
-					const result = reduce(files, results);
-					callback(null, result);
-				}
-			);
-		});
-	}
+/***/ }),
 
-	_readContextTimestamp(path, callback) {
-		this._readContext(
-			{
-				path,
-				fromImmutablePath: () => null,
-				fromManagedItem: info => ({
-					safeTime: 0,
-					timestampHash: info
-				}),
-				fromSymlink: (file, target, callback) => {
-					callback(null, {
-						timestampHash: target,
-						symlinks: new Set([target])
-					});
-				},
-				fromFile: (file, stat, callback) => {
-					// Prefer the cached value over our new stat to report consistent results
-					const cache = this._fileTimestamps.get(file);
-					if (cache !== undefined)
-						return callback(null, cache === "ignore" ? null : cache);
+/***/ 98229:
+/***/ (function(module) {
 
-					const mtime = +stat.mtime;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					if (mtime) applyMtime(mtime);
 
-					const ts = {
-						safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
-						timestamp: mtime
-					};
 
-					this._fileTimestamps.set(file, ts);
-					this._cachedDeprecatedFileTimestamps = undefined;
-					callback(null, ts);
-				},
-				fromDirectory: (directory, stat, callback) => {
-					this.contextTimestampQueue.increaseParallelism();
-					this._getUnresolvedContextTimestamp(directory, (err, tsEntry) => {
-						this.contextTimestampQueue.decreaseParallelism();
-						callback(err, tsEntry);
-					});
-				},
-				reduce: (files, tsEntries) => {
-					let symlinks = undefined;
+/** @typedef {import("./Module")} Module */
 
-					const hash = createHash(this._hashFunction);
+const MODULE_REFERENCE_REGEXP =
+	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(?:_asiSafe(\d))?__$/;
 
-					for (const file of files) hash.update(file);
-					let safeTime = 0;
-					for (const entry of tsEntries) {
-						if (!entry) {
-							hash.update("n");
-							continue;
-						}
-						if (entry.timestamp) {
-							hash.update("f");
-							hash.update(`${entry.timestamp}`);
-						} else if (entry.timestampHash) {
-							hash.update("d");
-							hash.update(`${entry.timestampHash}`);
-						}
-						if (entry.symlinks !== undefined) {
-							if (symlinks === undefined) symlinks = new Set();
-							addAll(entry.symlinks, symlinks);
-						}
-						if (entry.safeTime) {
-							safeTime = Math.max(safeTime, entry.safeTime);
-						}
-					}
+const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
+const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
 
-					const digest = /** @type {string} */ (hash.digest("hex"));
+/**
+ * @typedef {Object} ExternalModuleInfo
+ * @property {number} index
+ * @property {Module} module
+ */
 
-					const result = {
-						safeTime,
-						timestampHash: digest
-					};
-					if (symlinks) result.symlinks = symlinks;
-					return result;
-				}
-			},
-			(err, result) => {
-				if (err) return callback(err);
-				this._contextTimestamps.set(path, result);
-				this._cachedDeprecatedContextTimestamps = undefined;
+/**
+ * @typedef {Object} ConcatenatedModuleInfo
+ * @property {number} index
+ * @property {Module} module
+ * @property {Map<string, string>} exportMap mapping from export name to symbol
+ * @property {Map<string, string>} rawExportMap mapping from export name to symbol
+ * @property {string=} namespaceExportSymbol
+ */
 
-				callback(null, result);
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo} ModuleInfo */
+
+/**
+ * @typedef {Object} ModuleReferenceOptions
+ * @property {string[]} ids the properties/exports of the module
+ * @property {boolean} call true, when this referenced export is called
+ * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
+ * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
+ */
+
+class ConcatenationScope {
+	/**
+	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
+	 * @param {ConcatenatedModuleInfo} currentModule the current module info
+	 */
+	constructor(modulesMap, currentModule) {
+		this._currentModule = currentModule;
+		if (Array.isArray(modulesMap)) {
+			const map = new Map();
+			for (const info of modulesMap) {
+				map.set(info.module, info);
 			}
-		);
+			modulesMap = map;
+		}
+		this._modulesMap = modulesMap;
 	}
 
 	/**
-	 * @param {ContextFileSystemInfoEntry} entry entry
-	 * @param {function((Error | null)=, ResolvedContextFileSystemInfoEntry=): void} callback callback
-	 * @returns {void}
+	 * @param {Module} module the referenced module
+	 * @returns {boolean} true, when it's in the scope
 	 */
-	_resolveContextTimestamp(entry, callback) {
-		const hashes = [];
-		let safeTime = 0;
-		processAsyncTree(
-			entry.symlinks,
-			10,
-			(target, push, callback) => {
-				this._getUnresolvedContextTimestamp(target, (err, entry) => {
-					if (err) return callback(err);
-					if (entry && entry !== "ignore") {
-						hashes.push(entry.timestampHash);
-						if (entry.safeTime) {
-							safeTime = Math.max(safeTime, entry.safeTime);
-						}
-						if (entry.symlinks !== undefined) {
-							for (const target of entry.symlinks) push(target);
-						}
-					}
-					callback();
-				});
-			},
-			err => {
-				if (err) return callback(err);
-				const hash = createHash(this._hashFunction);
-				hash.update(entry.timestampHash);
-				if (entry.safeTime) {
-					safeTime = Math.max(safeTime, entry.safeTime);
-				}
-				hashes.sort();
-				for (const h of hashes) {
-					hash.update(h);
-				}
-				callback(
-					null,
-					(entry.resolved = {
-						safeTime,
-						timestampHash: /** @type {string} */ (hash.digest("hex"))
-					})
-				);
-			}
-		);
-	}
-
-	_readContextHash(path, callback) {
-		this._readContext(
-			{
-				path,
-				fromImmutablePath: () => "",
-				fromManagedItem: info => info || "",
-				fromSymlink: (file, target, callback) => {
-					callback(null, {
-						hash: target,
-						symlinks: new Set([target])
-					});
-				},
-				fromFile: (file, stat, callback) =>
-					this.getFileHash(file, (err, hash) => {
-						callback(err, hash || "");
-					}),
-				fromDirectory: (directory, stat, callback) => {
-					this.contextHashQueue.increaseParallelism();
-					this._getUnresolvedContextHash(directory, (err, hash) => {
-						this.contextHashQueue.decreaseParallelism();
-						callback(err, hash || "");
-					});
-				},
-				/**
-				 * @param {string[]} files files
-				 * @param {(string | ContextHash)[]} fileHashes hashes
-				 * @returns {ContextHash} reduced hash
-				 */
-				reduce: (files, fileHashes) => {
-					let symlinks = undefined;
-					const hash = createHash(this._hashFunction);
-
-					for (const file of files) hash.update(file);
-					for (const entry of fileHashes) {
-						if (typeof entry === "string") {
-							hash.update(entry);
-						} else {
-							hash.update(entry.hash);
-							if (entry.symlinks) {
-								if (symlinks === undefined) symlinks = new Set();
-								addAll(entry.symlinks, symlinks);
-							}
-						}
-					}
-
-					const result = {
-						hash: /** @type {string} */ (hash.digest("hex"))
-					};
-					if (symlinks) result.symlinks = symlinks;
-					return result;
-				}
-			},
-			(err, result) => {
-				if (err) return callback(err);
-				this._contextHashes.set(path, result);
-				return callback(null, result);
-			}
-		);
+	isModuleInScope(module) {
+		return this._modulesMap.has(module);
 	}
 
 	/**
-	 * @param {ContextHash} entry context hash
-	 * @param {function((Error | null)=, string=): void} callback callback
-	 * @returns {void}
+	 *
+	 * @param {string} exportName name of the export
+	 * @param {string} symbol identifier of the export in source code
 	 */
-	_resolveContextHash(entry, callback) {
-		const hashes = [];
-		processAsyncTree(
-			entry.symlinks,
-			10,
-			(target, push, callback) => {
-				this._getUnresolvedContextHash(target, (err, hash) => {
-					if (err) return callback(err);
-					if (hash) {
-						hashes.push(hash.hash);
-						if (hash.symlinks !== undefined) {
-							for (const target of hash.symlinks) push(target);
-						}
-					}
-					callback();
-				});
-			},
-			err => {
-				if (err) return callback(err);
-				const hash = createHash(this._hashFunction);
-				hash.update(entry.hash);
-				hashes.sort();
-				for (const h of hashes) {
-					hash.update(h);
-				}
-				callback(
-					null,
-					(entry.resolved = /** @type {string} */ (hash.digest("hex")))
-				);
-			}
-		);
-	}
-
-	_readContextTimestampAndHash(path, callback) {
-		const finalize = (timestamp, hash) => {
-			const result =
-				timestamp === "ignore"
-					? hash
-					: {
-							...timestamp,
-							...hash
-					  };
-			this._contextTshs.set(path, result);
-			callback(null, result);
-		};
-		const cachedHash = this._contextHashes.get(path);
-		const cachedTimestamp = this._contextTimestamps.get(path);
-		if (cachedHash !== undefined) {
-			if (cachedTimestamp !== undefined) {
-				finalize(cachedTimestamp, cachedHash);
-			} else {
-				this.contextTimestampQueue.add(path, (err, entry) => {
-					if (err) return callback(err);
-					finalize(entry, cachedHash);
-				});
-			}
-		} else {
-			if (cachedTimestamp !== undefined) {
-				this.contextHashQueue.add(path, (err, entry) => {
-					if (err) return callback(err);
-					finalize(cachedTimestamp, entry);
-				});
-			} else {
-				this._readContext(
-					{
-						path,
-						fromImmutablePath: () => null,
-						fromManagedItem: info => ({
-							safeTime: 0,
-							timestampHash: info,
-							hash: info || ""
-						}),
-						fromSymlink: (fle, target, callback) => {
-							callback(null, {
-								timestampHash: target,
-								hash: target,
-								symlinks: new Set([target])
-							});
-						},
-						fromFile: (file, stat, callback) => {
-							this._getFileTimestampAndHash(file, callback);
-						},
-						fromDirectory: (directory, stat, callback) => {
-							this.contextTshQueue.increaseParallelism();
-							this.contextTshQueue.add(directory, (err, result) => {
-								this.contextTshQueue.decreaseParallelism();
-								callback(err, result);
-							});
-						},
-						/**
-						 * @param {string[]} files files
-						 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
-						 * @returns {ContextTimestampAndHash} tsh
-						 */
-						reduce: (files, results) => {
-							let symlinks = undefined;
-
-							const tsHash = createHash(this._hashFunction);
-							const hash = createHash(this._hashFunction);
-
-							for (const file of files) {
-								tsHash.update(file);
-								hash.update(file);
-							}
-							let safeTime = 0;
-							for (const entry of results) {
-								if (!entry) {
-									tsHash.update("n");
-									continue;
-								}
-								if (typeof entry === "string") {
-									tsHash.update("n");
-									hash.update(entry);
-									continue;
-								}
-								if (entry.timestamp) {
-									tsHash.update("f");
-									tsHash.update(`${entry.timestamp}`);
-								} else if (entry.timestampHash) {
-									tsHash.update("d");
-									tsHash.update(`${entry.timestampHash}`);
-								}
-								if (entry.symlinks !== undefined) {
-									if (symlinks === undefined) symlinks = new Set();
-									addAll(entry.symlinks, symlinks);
-								}
-								if (entry.safeTime) {
-									safeTime = Math.max(safeTime, entry.safeTime);
-								}
-								hash.update(entry.hash);
-							}
-
-							const result = {
-								safeTime,
-								timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-								hash: /** @type {string} */ (hash.digest("hex"))
-							};
-							if (symlinks) result.symlinks = symlinks;
-							return result;
-						}
-					},
-					(err, result) => {
-						if (err) return callback(err);
-						this._contextTshs.set(path, result);
-						return callback(null, result);
-					}
-				);
-			}
+	registerExport(exportName, symbol) {
+		if (!this._currentModule.exportMap) {
+			this._currentModule.exportMap = new Map();
+		}
+		if (!this._currentModule.exportMap.has(exportName)) {
+			this._currentModule.exportMap.set(exportName, symbol);
 		}
 	}
 
 	/**
-	 * @param {ContextTimestampAndHash} entry entry
-	 * @param {function((Error | null)=, ResolvedContextTimestampAndHash=): void} callback callback
-	 * @returns {void}
+	 *
+	 * @param {string} exportName name of the export
+	 * @param {string} expression expression to be used
 	 */
-	_resolveContextTsh(entry, callback) {
-		const hashes = [];
-		const tsHashes = [];
-		let safeTime = 0;
-		processAsyncTree(
-			entry.symlinks,
-			10,
-			(target, push, callback) => {
-				this._getUnresolvedContextTsh(target, (err, entry) => {
-					if (err) return callback(err);
-					if (entry) {
-						hashes.push(entry.hash);
-						if (entry.timestampHash) tsHashes.push(entry.timestampHash);
-						if (entry.safeTime) {
-							safeTime = Math.max(safeTime, entry.safeTime);
-						}
-						if (entry.symlinks !== undefined) {
-							for (const target of entry.symlinks) push(target);
-						}
-					}
-					callback();
-				});
-			},
-			err => {
-				if (err) return callback(err);
-				const hash = createHash(this._hashFunction);
-				const tsHash = createHash(this._hashFunction);
-				hash.update(entry.hash);
-				if (entry.timestampHash) tsHash.update(entry.timestampHash);
-				if (entry.safeTime) {
-					safeTime = Math.max(safeTime, entry.safeTime);
-				}
-				hashes.sort();
-				for (const h of hashes) {
-					hash.update(h);
-				}
-				tsHashes.sort();
-				for (const h of tsHashes) {
-					tsHash.update(h);
-				}
-				callback(
-					null,
-					(entry.resolved = {
-						safeTime,
-						timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-						hash: /** @type {string} */ (hash.digest("hex"))
-					})
-				);
-			}
-		);
+	registerRawExport(exportName, expression) {
+		if (!this._currentModule.rawExportMap) {
+			this._currentModule.rawExportMap = new Map();
+		}
+		if (!this._currentModule.rawExportMap.has(exportName)) {
+			this._currentModule.rawExportMap.set(exportName, expression);
+		}
 	}
 
-	_getManagedItemDirectoryInfo(path, callback) {
-		this.fs.readdir(path, (err, elements) => {
-			if (err) {
-				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
-					return callback(null, EMPTY_SET);
-				}
-				return callback(err);
-			}
-			const set = new Set(
-				/** @type {string[]} */ (elements).map(element =>
-					join(this.fs, path, element)
-				)
-			);
-			callback(null, set);
-		});
+	/**
+	 * @param {string} symbol identifier of the export in source code
+	 */
+	registerNamespaceExport(symbol) {
+		this._currentModule.namespaceExportSymbol = symbol;
 	}
 
-	_getManagedItemInfo(path, callback) {
-		const dir = dirname(this.fs, path);
-		this.managedItemDirectoryQueue.add(dir, (err, elements) => {
-			if (err) {
-				return callback(err);
-			}
-			if (!elements.has(path)) {
-				// file or directory doesn't exist
-				this._managedItems.set(path, "*missing");
-				return callback(null, "*missing");
-			}
-			// something exists
-			// it may be a file or directory
-			if (
-				path.endsWith("node_modules") &&
-				(path.endsWith("/node_modules") || path.endsWith("\\node_modules"))
-			) {
-				// we are only interested in existence of this special directory
-				this._managedItems.set(path, "*node_modules");
-				return callback(null, "*node_modules");
-			}
-
-			// we assume it's a directory, as files shouldn't occur in managed paths
-			const packageJsonPath = join(this.fs, path, "package.json");
-			this.fs.readFile(packageJsonPath, (err, content) => {
-				if (err) {
-					if (err.code === "ENOENT" || err.code === "ENOTDIR") {
-						// no package.json or path is not a directory
-						this.fs.readdir(path, (err, elements) => {
-							if (
-								!err &&
-								elements.length === 1 &&
-								elements[0] === "node_modules"
-							) {
-								// This is only a grouping folder e. g. used by yarn
-								// we are only interested in existence of this special directory
-								this._managedItems.set(path, "*nested");
-								return callback(null, "*nested");
-							}
-							this.logger.warn(
-								`Managed item ${path} isn't a directory or doesn't contain a package.json (see snapshot.managedPaths option)`
-							);
-							return callback();
-						});
-						return;
-					}
-					return callback(err);
-				}
-				let data;
-				try {
-					data = JSON.parse(content.toString("utf-8"));
-				} catch (e) {
-					return callback(e);
-				}
-				if (!data.name) {
-					this.logger.warn(
-						`${packageJsonPath} doesn't contain a "name" property (see snapshot.managedPaths option)`
-					);
-					return callback();
-				}
-				const info = `${data.name || ""}@${data.version || ""}`;
-				this._managedItems.set(path, info);
-				callback(null, info);
-			});
-		});
+	/**
+	 *
+	 * @param {Module} module the referenced module
+	 * @param {Partial<ModuleReferenceOptions>} options options
+	 * @returns {string} the reference as identifier
+	 */
+	createModuleReference(
+		module,
+		{ ids = undefined, call = false, directImport = false, asiSafe = false }
+	) {
+		const info = this._modulesMap.get(module);
+		const callFlag = call ? "_call" : "";
+		const directImportFlag = directImport ? "_directImport" : "";
+		const asiSafeFlag = asiSafe
+			? "_asiSafe1"
+			: asiSafe === false
+			? "_asiSafe0"
+			: "";
+		const exportData = ids
+			? Buffer.from(JSON.stringify(ids), "utf-8").toString("hex")
+			: "ns";
+		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
+		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${asiSafeFlag}__._`;
 	}
 
-	getDeprecatedFileTimestamps() {
-		if (this._cachedDeprecatedFileTimestamps !== undefined)
-			return this._cachedDeprecatedFileTimestamps;
-		const map = new Map();
-		for (const [path, info] of this._fileTimestamps) {
-			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
-		}
-		return (this._cachedDeprecatedFileTimestamps = map);
+	/**
+	 * @param {string} name the identifier
+	 * @returns {boolean} true, when it's an module reference
+	 */
+	static isModuleReference(name) {
+		return MODULE_REFERENCE_REGEXP.test(name);
 	}
 
-	getDeprecatedContextTimestamps() {
-		if (this._cachedDeprecatedContextTimestamps !== undefined)
-			return this._cachedDeprecatedContextTimestamps;
-		const map = new Map();
-		for (const [path, info] of this._contextTimestamps) {
-			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
-		}
-		return (this._cachedDeprecatedContextTimestamps = map);
+	/**
+	 * @param {string} name the identifier
+	 * @returns {ModuleReferenceOptions & { index: number }} parsed options and index
+	 */
+	static matchModuleReference(name) {
+		const match = MODULE_REFERENCE_REGEXP.exec(name);
+		if (!match) return null;
+		const index = +match[1];
+		const asiSafe = match[5];
+		return {
+			index,
+			ids:
+				match[2] === "ns"
+					? []
+					: JSON.parse(Buffer.from(match[2], "hex").toString("utf-8")),
+			call: !!match[3],
+			directImport: !!match[4],
+			asiSafe: asiSafe ? asiSafe === "1" : undefined
+		};
 	}
 }
 
-module.exports = FileSystemInfo;
-module.exports.Snapshot = Snapshot;
+ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
+ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
+
+module.exports = ConcatenationScope;
 
 
 /***/ }),
 
-/***/ 58727:
+/***/ 95735:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Maksim Nazarjev @acupofspirt
 */
 
 
 
-const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+const WebpackError = __webpack_require__(53799);
 
-class FlagAllModulesAsUsedPlugin {
-	constructor(explanation) {
-		this.explanation = explanation;
-	}
+module.exports = class ConcurrentCompilationError extends WebpackError {
+	constructor() {
+		super();
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FlagAllModulesAsUsedPlugin",
-			compilation => {
-				const moduleGraph = compilation.moduleGraph;
-				compilation.hooks.optimizeDependencies.tap(
-					"FlagAllModulesAsUsedPlugin",
-					modules => {
-						/** @type {RuntimeSpec} */
-						let runtime = undefined;
-						for (const [name, { options }] of compilation.entries) {
-							runtime = mergeRuntimeOwned(
-								runtime,
-								getEntryRuntime(compilation, name, options)
-							);
-						}
-						for (const module of modules) {
-							const exportsInfo = moduleGraph.getExportsInfo(module);
-							exportsInfo.setUsedInUnknownWay(runtime);
-							moduleGraph.addExtraReason(module, this.explanation);
-							if (module.factoryMeta === undefined) {
-								module.factoryMeta = {};
-							}
-							module.factoryMeta.sideEffectFree = false;
-						}
-					}
-				);
-			}
-		);
+		this.name = "ConcurrentCompilationError";
+		this.message =
+			"You ran Webpack twice. Each instance only supports a single concurrent compilation at a time.";
 	}
-}
-
-module.exports = FlagAllModulesAsUsedPlugin;
+};
 
 
 /***/ }),
 
-/***/ 84506:
+/***/ 61333:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40615,421 +36187,116 @@ module.exports = FlagAllModulesAsUsedPlugin;
 
 
 
-const asyncLib = __webpack_require__(78175);
-const Queue = __webpack_require__(65930);
+const { ConcatSource, PrefixSource } = __webpack_require__(51255);
+const InitFragment = __webpack_require__(55870);
+const Template = __webpack_require__(39722);
+const { mergeRuntime } = __webpack_require__(17156);
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-class FlagDependencyExportsPlugin {
+const wrapInCondition = (condition, source) => {
+	if (typeof source === "string") {
+		return Template.asString([
+			`if (${condition}) {`,
+			Template.indent(source),
+			"}",
+			""
+		]);
+	} else {
+		return new ConcatSource(
+			`if (${condition}) {\n`,
+			new PrefixSource("\t", source),
+			"}\n"
+		);
+	}
+};
+
+/**
+ * @typedef {GenerateContext} Context
+ */
+class ConditionalInitFragment extends InitFragment {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {string} key unique key to avoid emitting the same initialization code twice
+	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
+	 * @param {string|Source=} endContent the source code that will be included at the end of the module
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FlagDependencyExportsPlugin",
-			compilation => {
-				const moduleGraph = compilation.moduleGraph;
-				const cache = compilation.getCache("FlagDependencyExportsPlugin");
-				compilation.hooks.finishModules.tapAsync(
-					"FlagDependencyExportsPlugin",
-					(modules, callback) => {
-						const logger = compilation.getLogger(
-							"webpack.FlagDependencyExportsPlugin"
-						);
-						let statRestoredFromMemCache = 0;
-						let statRestoredFromCache = 0;
-						let statNoExports = 0;
-						let statFlaggedUncached = 0;
-						let statNotCached = 0;
-						let statQueueItemsProcessed = 0;
-
-						const { moduleMemCaches } = compilation;
-
-						/** @type {Queue<Module>} */
-						const queue = new Queue();
-
-						// Step 1: Try to restore cached provided export info from cache
-						logger.time("restore cached provided exports");
-						asyncLib.each(
-							modules,
-							(module, callback) => {
-								const exportsInfo = moduleGraph.getExportsInfo(module);
-								if (!module.buildMeta || !module.buildMeta.exportsType) {
-									if (exportsInfo.otherExportsInfo.provided !== null) {
-										// It's a module without declared exports
-										statNoExports++;
-										exportsInfo.setHasProvideInfo();
-										exportsInfo.setUnknownExportsProvided();
-										return callback();
-									}
-								}
-								if (typeof module.buildInfo.hash !== "string") {
-									statFlaggedUncached++;
-									// Enqueue uncacheable module for determining the exports
-									queue.enqueue(module);
-									exportsInfo.setHasProvideInfo();
-									return callback();
-								}
-								const memCache = moduleMemCaches && moduleMemCaches.get(module);
-								const memCacheValue = memCache && memCache.get(this);
-								if (memCacheValue !== undefined) {
-									statRestoredFromMemCache++;
-									exportsInfo.restoreProvided(memCacheValue);
-									return callback();
-								}
-								cache.get(
-									module.identifier(),
-									module.buildInfo.hash,
-									(err, result) => {
-										if (err) return callback(err);
-
-										if (result !== undefined) {
-											statRestoredFromCache++;
-											exportsInfo.restoreProvided(result);
-										} else {
-											statNotCached++;
-											// Without cached info enqueue module for determining the exports
-											queue.enqueue(module);
-											exportsInfo.setHasProvideInfo();
-										}
-										callback();
-									}
-								);
-							},
-							err => {
-								logger.timeEnd("restore cached provided exports");
-								if (err) return callback(err);
-
-								/** @type {Set<Module>} */
-								const modulesToStore = new Set();
-
-								/** @type {Map<Module, Set<Module>>} */
-								const dependencies = new Map();
-
-								/** @type {Module} */
-								let module;
-
-								/** @type {ExportsInfo} */
-								let exportsInfo;
-
-								/** @type {Map<Dependency, ExportsSpec>} */
-								const exportsSpecsFromDependencies = new Map();
-
-								let cacheable = true;
-								let changed = false;
-
-								/**
-								 * @param {DependenciesBlock} depBlock the dependencies block
-								 * @returns {void}
-								 */
-								const processDependenciesBlock = depBlock => {
-									for (const dep of depBlock.dependencies) {
-										processDependency(dep);
-									}
-									for (const block of depBlock.blocks) {
-										processDependenciesBlock(block);
-									}
-								};
-
-								/**
-								 * @param {Dependency} dep the dependency
-								 * @returns {void}
-								 */
-								const processDependency = dep => {
-									const exportDesc = dep.getExports(moduleGraph);
-									if (!exportDesc) return;
-									exportsSpecsFromDependencies.set(dep, exportDesc);
-								};
-
-								/**
-								 * @param {Dependency} dep dependency
-								 * @param {ExportsSpec} exportDesc info
-								 * @returns {void}
-								 */
-								const processExportsSpec = (dep, exportDesc) => {
-									const exports = exportDesc.exports;
-									const globalCanMangle = exportDesc.canMangle;
-									const globalFrom = exportDesc.from;
-									const globalPriority = exportDesc.priority;
-									const globalTerminalBinding =
-										exportDesc.terminalBinding || false;
-									const exportDeps = exportDesc.dependencies;
-									if (exportDesc.hideExports) {
-										for (const name of exportDesc.hideExports) {
-											const exportInfo = exportsInfo.getExportInfo(name);
-											exportInfo.unsetTarget(dep);
-										}
-									}
-									if (exports === true) {
-										// unknown exports
-										if (
-											exportsInfo.setUnknownExportsProvided(
-												globalCanMangle,
-												exportDesc.excludeExports,
-												globalFrom && dep,
-												globalFrom,
-												globalPriority
-											)
-										) {
-											changed = true;
-										}
-									} else if (Array.isArray(exports)) {
-										/**
-										 * merge in new exports
-										 * @param {ExportsInfo} exportsInfo own exports info
-										 * @param {(ExportSpec | string)[]} exports list of exports
-										 */
-										const mergeExports = (exportsInfo, exports) => {
-											for (const exportNameOrSpec of exports) {
-												let name;
-												let canMangle = globalCanMangle;
-												let terminalBinding = globalTerminalBinding;
-												let exports = undefined;
-												let from = globalFrom;
-												let fromExport = undefined;
-												let priority = globalPriority;
-												let hidden = false;
-												if (typeof exportNameOrSpec === "string") {
-													name = exportNameOrSpec;
-												} else {
-													name = exportNameOrSpec.name;
-													if (exportNameOrSpec.canMangle !== undefined)
-														canMangle = exportNameOrSpec.canMangle;
-													if (exportNameOrSpec.export !== undefined)
-														fromExport = exportNameOrSpec.export;
-													if (exportNameOrSpec.exports !== undefined)
-														exports = exportNameOrSpec.exports;
-													if (exportNameOrSpec.from !== undefined)
-														from = exportNameOrSpec.from;
-													if (exportNameOrSpec.priority !== undefined)
-														priority = exportNameOrSpec.priority;
-													if (exportNameOrSpec.terminalBinding !== undefined)
-														terminalBinding = exportNameOrSpec.terminalBinding;
-													if (exportNameOrSpec.hidden !== undefined)
-														hidden = exportNameOrSpec.hidden;
-												}
-												const exportInfo = exportsInfo.getExportInfo(name);
-
-												if (
-													exportInfo.provided === false ||
-													exportInfo.provided === null
-												) {
-													exportInfo.provided = true;
-													changed = true;
-												}
-
-												if (
-													exportInfo.canMangleProvide !== false &&
-													canMangle === false
-												) {
-													exportInfo.canMangleProvide = false;
-													changed = true;
-												}
-
-												if (terminalBinding && !exportInfo.terminalBinding) {
-													exportInfo.terminalBinding = true;
-													changed = true;
-												}
-
-												if (exports) {
-													const nestedExportsInfo =
-														exportInfo.createNestedExportsInfo();
-													mergeExports(nestedExportsInfo, exports);
-												}
-
-												if (
-													from &&
-													(hidden
-														? exportInfo.unsetTarget(dep)
-														: exportInfo.setTarget(
-																dep,
-																from,
-																fromExport === undefined ? [name] : fromExport,
-																priority
-														  ))
-												) {
-													changed = true;
-												}
-
-												// Recalculate target exportsInfo
-												const target = exportInfo.getTarget(moduleGraph);
-												let targetExportsInfo = undefined;
-												if (target) {
-													const targetModuleExportsInfo =
-														moduleGraph.getExportsInfo(target.module);
-													targetExportsInfo =
-														targetModuleExportsInfo.getNestedExportsInfo(
-															target.export
-														);
-													// add dependency for this module
-													const set = dependencies.get(target.module);
-													if (set === undefined) {
-														dependencies.set(target.module, new Set([module]));
-													} else {
-														set.add(module);
-													}
-												}
-
-												if (exportInfo.exportsInfoOwned) {
-													if (
-														exportInfo.exportsInfo.setRedirectNamedTo(
-															targetExportsInfo
-														)
-													) {
-														changed = true;
-													}
-												} else if (
-													exportInfo.exportsInfo !== targetExportsInfo
-												) {
-													exportInfo.exportsInfo = targetExportsInfo;
-													changed = true;
-												}
-											}
-										};
-										mergeExports(exportsInfo, exports);
-									}
-									// store dependencies
-									if (exportDeps) {
-										cacheable = false;
-										for (const exportDependency of exportDeps) {
-											// add dependency for this module
-											const set = dependencies.get(exportDependency);
-											if (set === undefined) {
-												dependencies.set(exportDependency, new Set([module]));
-											} else {
-												set.add(module);
-											}
-										}
-									}
-								};
-
-								const notifyDependencies = () => {
-									const deps = dependencies.get(module);
-									if (deps !== undefined) {
-										for (const dep of deps) {
-											queue.enqueue(dep);
-										}
-									}
-								};
-
-								logger.time("figure out provided exports");
-								while (queue.length > 0) {
-									module = queue.dequeue();
-
-									statQueueItemsProcessed++;
-
-									exportsInfo = moduleGraph.getExportsInfo(module);
-
-									cacheable = true;
-									changed = false;
-
-									exportsSpecsFromDependencies.clear();
-									moduleGraph.freeze();
-									processDependenciesBlock(module);
-									moduleGraph.unfreeze();
-									for (const [
-										dep,
-										exportsSpec
-									] of exportsSpecsFromDependencies) {
-										processExportsSpec(dep, exportsSpec);
-									}
-
-									if (cacheable) {
-										modulesToStore.add(module);
-									}
-
-									if (changed) {
-										notifyDependencies();
-									}
-								}
-								logger.timeEnd("figure out provided exports");
+	constructor(
+		content,
+		stage,
+		position,
+		key,
+		runtimeCondition = true,
+		endContent
+	) {
+		super(content, stage, position, key, endContent);
+		this.runtimeCondition = runtimeCondition;
+	}
 
-								logger.log(
-									`${Math.round(
-										(100 * (statFlaggedUncached + statNotCached)) /
-											(statRestoredFromMemCache +
-												statRestoredFromCache +
-												statNotCached +
-												statFlaggedUncached +
-												statNoExports)
-									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${
-										statQueueItemsProcessed -
-										statNotCached -
-										statFlaggedUncached
-									} additional calculations due to dependencies)`
-								);
+	/**
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
+	 */
+	getContent(context) {
+		if (this.runtimeCondition === false || !this.content) return "";
+		if (this.runtimeCondition === true) return this.content;
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.content;
+		return wrapInCondition(expr, this.content);
+	}
 
-								logger.time("store provided exports into cache");
-								asyncLib.each(
-									modulesToStore,
-									(module, callback) => {
-										if (typeof module.buildInfo.hash !== "string") {
-											// not cacheable
-											return callback();
-										}
-										const cachedData = moduleGraph
-											.getExportsInfo(module)
-											.getRestoreProvidedData();
-										const memCache =
-											moduleMemCaches && moduleMemCaches.get(module);
-										if (memCache) {
-											memCache.set(this, cachedData);
-										}
-										cache.store(
-											module.identifier(),
-											module.buildInfo.hash,
-											cachedData,
-											callback
-										);
-									},
-									err => {
-										logger.timeEnd("store provided exports into cache");
-										callback(err);
-									}
-								);
-							}
-						);
-					}
-				);
+	/**
+	 * @param {Context} context context
+	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 */
+	getEndContent(context) {
+		if (this.runtimeCondition === false || !this.endContent) return "";
+		if (this.runtimeCondition === true) return this.endContent;
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.endContent;
+		return wrapInCondition(expr, this.endContent);
+	}
 
-				/** @type {WeakMap<Module, any>} */
-				const providedExportsCache = new WeakMap();
-				compilation.hooks.rebuildModule.tap(
-					"FlagDependencyExportsPlugin",
-					module => {
-						providedExportsCache.set(
-							module,
-							moduleGraph.getExportsInfo(module).getRestoreProvidedData()
-						);
-					}
-				);
-				compilation.hooks.finishRebuildingModule.tap(
-					"FlagDependencyExportsPlugin",
-					module => {
-						moduleGraph
-							.getExportsInfo(module)
-							.restoreProvided(providedExportsCache.get(module));
-					}
-				);
-			}
+	merge(other) {
+		if (this.runtimeCondition === true) return this;
+		if (other.runtimeCondition === true) return other;
+		if (this.runtimeCondition === false) return other;
+		if (other.runtimeCondition === false) return this;
+		const runtimeCondition = mergeRuntime(
+			this.runtimeCondition,
+			other.runtimeCondition
+		);
+		return new ConditionalInitFragment(
+			this.content,
+			this.stage,
+			this.position,
+			this.key,
+			runtimeCondition,
+			this.endContent
 		);
 	}
 }
 
-module.exports = FlagDependencyExportsPlugin;
+module.exports = ConditionalInitFragment;
 
 
 /***/ }),
 
-/***/ 58812:
+/***/ 11146:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -41040,351 +36307,541 @@ module.exports = FlagDependencyExportsPlugin;
 
 
 
-const Dependency = __webpack_require__(54912);
-const { UsageState } = __webpack_require__(63686);
-const ModuleGraphConnection = __webpack_require__(40639);
-const { STAGE_DEFAULT } = __webpack_require__(80057);
-const ArrayQueue = __webpack_require__(41792);
-const TupleQueue = __webpack_require__(38415);
-const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
+const CachedConstDependency = __webpack_require__(57403);
+const ConstDependency = __webpack_require__(76911);
+const { evaluateToString } = __webpack_require__(93998);
+const { parseResource } = __webpack_require__(82186);
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Super} SuperNode */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency;
+const collectDeclaration = (declarations, pattern) => {
+	const stack = [pattern];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		switch (node.type) {
+			case "Identifier":
+				declarations.add(node.name);
+				break;
+			case "ArrayPattern":
+				for (const element of node.elements) {
+					if (element) {
+						stack.push(element);
+					}
+				}
+				break;
+			case "AssignmentPattern":
+				stack.push(node.left);
+				break;
+			case "ObjectPattern":
+				for (const property of node.properties) {
+					stack.push(property.value);
+				}
+				break;
+			case "RestElement":
+				stack.push(node.argument);
+				break;
+		}
+	}
+};
 
-class FlagDependencyUsagePlugin {
-	/**
-	 * @param {boolean} global do a global analysis instead of per runtime
-	 */
-	constructor(global) {
-		this.global = global;
+const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
+	const declarations = new Set();
+	const stack = [branch];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		// Some node could be `null` or `undefined`.
+		if (!node) continue;
+		switch (node.type) {
+			// Walk through control statements to look for hoisted declarations.
+			// Some branches are skipped since they do not allow declarations.
+			case "BlockStatement":
+				for (const stmt of node.body) {
+					stack.push(stmt);
+				}
+				break;
+			case "IfStatement":
+				stack.push(node.consequent);
+				stack.push(node.alternate);
+				break;
+			case "ForStatement":
+				stack.push(node.init);
+				stack.push(node.body);
+				break;
+			case "ForInStatement":
+			case "ForOfStatement":
+				stack.push(node.left);
+				stack.push(node.body);
+				break;
+			case "DoWhileStatement":
+			case "WhileStatement":
+			case "LabeledStatement":
+				stack.push(node.body);
+				break;
+			case "SwitchStatement":
+				for (const cs of node.cases) {
+					for (const consequent of cs.consequent) {
+						stack.push(consequent);
+					}
+				}
+				break;
+			case "TryStatement":
+				stack.push(node.block);
+				if (node.handler) {
+					stack.push(node.handler.body);
+				}
+				stack.push(node.finalizer);
+				break;
+			case "FunctionDeclaration":
+				if (includeFunctionDeclarations) {
+					collectDeclaration(declarations, node.id);
+				}
+				break;
+			case "VariableDeclaration":
+				if (node.kind === "var") {
+					for (const decl of node.declarations) {
+						collectDeclaration(declarations, decl.id);
+					}
+				}
+				break;
+		}
 	}
+	return Array.from(declarations);
+};
 
+class ConstPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagDependencyUsagePlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.optimizeDependencies.tap(
-				{
-					name: "FlagDependencyUsagePlugin",
-					stage: STAGE_DEFAULT
-				},
-				modules => {
-					if (compilation.moduleMemCaches) {
-						throw new Error(
-							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
-						);
-					}
-
-					const logger = compilation.getLogger(
-						"webpack.FlagDependencyUsagePlugin"
-					);
-					/** @type {Map<ExportsInfo, Module>} */
-					const exportInfoToModuleMap = new Map();
+		const cachedParseResource = parseResource.bindCache(compiler.root);
+		compiler.hooks.compilation.tap(
+			"ConstPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
 
-					/** @type {TupleQueue<[Module, RuntimeSpec]>} */
-					const queue = new TupleQueue();
+				compilation.dependencyTemplates.set(
+					CachedConstDependency,
+					new CachedConstDependency.Template()
+				);
 
-					/**
-					 * @param {Module} module module to process
-					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
-					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
-					 * @returns {void}
-					 */
-					const processReferencedModule = (
-						module,
-						usedExports,
-						runtime,
-						forceSideEffects
-					) => {
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						if (usedExports.length > 0) {
-							if (!module.buildMeta || !module.buildMeta.exportsType) {
-								if (exportsInfo.setUsedWithoutInfo(runtime)) {
-									queue.enqueue(module, runtime);
-								}
-								return;
+				const handler = parser => {
+					parser.hooks.statementIf.tap("ConstPlugin", statement => {
+						if (parser.scope.isAsmJs) return;
+						const param = parser.evaluateExpression(statement.test);
+						const bool = param.asBool();
+						if (typeof bool === "boolean") {
+							if (!param.couldHaveSideEffects()) {
+								const dep = new ConstDependency(`${bool}`, param.range);
+								dep.loc = statement.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							} else {
+								parser.walkExpression(statement.test);
 							}
-							for (const usedExportInfo of usedExports) {
-								let usedExport;
-								let canMangle = true;
-								if (Array.isArray(usedExportInfo)) {
-									usedExport = usedExportInfo;
+							const branchToRemove = bool
+								? statement.alternate
+								: statement.consequent;
+							if (branchToRemove) {
+								// Before removing the dead branch, the hoisted declarations
+								// must be collected.
+								//
+								// Given the following code:
+								//
+								//     if (true) f() else g()
+								//     if (false) {
+								//       function f() {}
+								//       const g = function g() {}
+								//       if (someTest) {
+								//         let a = 1
+								//         var x, {y, z} = obj
+								//       }
+								//     } else {
+								//       …
+								//     }
+								//
+								// the generated code is:
+								//
+								//     if (true) f() else {}
+								//     if (false) {
+								//       var f, x, y, z;   (in loose mode)
+								//       var x, y, z;      (in strict mode)
+								//     } else {
+								//       …
+								//     }
+								//
+								// NOTE: When code runs in strict mode, `var` declarations
+								// are hoisted but `function` declarations don't.
+								//
+								let declarations;
+								if (parser.scope.isStrict) {
+									// If the code runs in strict mode, variable declarations
+									// using `var` must be hoisted.
+									declarations = getHoistedDeclarations(branchToRemove, false);
 								} else {
-									usedExport = usedExportInfo.name;
-									canMangle = usedExportInfo.canMangle !== false;
+									// Otherwise, collect all hoisted declaration.
+									declarations = getHoistedDeclarations(branchToRemove, true);
 								}
-								if (usedExport.length === 0) {
-									if (exportsInfo.setUsedInUnknownWay(runtime)) {
-										queue.enqueue(module, runtime);
-									}
+								let replacement;
+								if (declarations.length > 0) {
+									replacement = `{ var ${declarations.join(", ")}; }`;
 								} else {
-									let currentExportsInfo = exportsInfo;
-									for (let i = 0; i < usedExport.length; i++) {
-										const exportInfo = currentExportsInfo.getExportInfo(
-											usedExport[i]
-										);
-										if (canMangle === false) {
-											exportInfo.canMangleUse = false;
-										}
-										const lastOne = i === usedExport.length - 1;
-										if (!lastOne) {
-											const nestedInfo = exportInfo.getNestedExportsInfo();
-											if (nestedInfo) {
-												if (
-													exportInfo.setUsedConditionally(
-														used => used === UsageState.Unused,
-														UsageState.OnlyPropertiesUsed,
-														runtime
-													)
-												) {
-													const currentModule =
-														currentExportsInfo === exportsInfo
-															? module
-															: exportInfoToModuleMap.get(currentExportsInfo);
-													if (currentModule) {
-														queue.enqueue(currentModule, runtime);
-													}
-												}
-												currentExportsInfo = nestedInfo;
-												continue;
-											}
-										}
-										if (
-											exportInfo.setUsedConditionally(
-												v => v !== UsageState.Used,
-												UsageState.Used,
-												runtime
-											)
-										) {
-											const currentModule =
-												currentExportsInfo === exportsInfo
-													? module
-													: exportInfoToModuleMap.get(currentExportsInfo);
-											if (currentModule) {
-												queue.enqueue(currentModule, runtime);
-											}
-										}
-										break;
-									}
+									replacement = "{}";
 								}
+								const dep = new ConstDependency(
+									replacement,
+									branchToRemove.range
+								);
+								dep.loc = branchToRemove.loc;
+								parser.state.module.addPresentationalDependency(dep);
 							}
-						} else {
-							// for a module without side effects we stop tracking usage here when no export is used
-							// This module won't be evaluated in this case
-							// TODO webpack 6 remove this check
-							if (
-								!forceSideEffects &&
-								module.factoryMeta !== undefined &&
-								module.factoryMeta.sideEffectFree
-							) {
-								return;
-							}
-							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
-								queue.enqueue(module, runtime);
-							}
+							return bool;
 						}
-					};
-
-					/**
-					 * @param {DependenciesBlock} module the module
-					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
-					 * @returns {void}
-					 */
-					const processModule = (module, runtime, forceSideEffects) => {
-						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
-						const map = new Map();
-
-						/** @type {ArrayQueue<DependenciesBlock>} */
-						const queue = new ArrayQueue();
-						queue.enqueue(module);
-						for (;;) {
-							const block = queue.dequeue();
-							if (block === undefined) break;
-							for (const b of block.blocks) {
-								if (
-									!this.global &&
-									b.groupOptions &&
-									b.groupOptions.entryOptions
-								) {
-									processModule(
-										b,
-										b.groupOptions.entryOptions.runtime || undefined,
-										true
-									);
+					});
+					parser.hooks.expressionConditionalOperator.tap(
+						"ConstPlugin",
+						expression => {
+							if (parser.scope.isAsmJs) return;
+							const param = parser.evaluateExpression(expression.test);
+							const bool = param.asBool();
+							if (typeof bool === "boolean") {
+								if (!param.couldHaveSideEffects()) {
+									const dep = new ConstDependency(` ${bool}`, param.range);
+									dep.loc = expression.loc;
+									parser.state.module.addPresentationalDependency(dep);
 								} else {
-									queue.enqueue(b);
+									parser.walkExpression(expression.test);
 								}
+								// Expressions do not hoist.
+								// It is safe to remove the dead branch.
+								//
+								// Given the following code:
+								//
+								//   false ? someExpression() : otherExpression();
+								//
+								// the generated code is:
+								//
+								//   false ? 0 : otherExpression();
+								//
+								const branchToRemove = bool
+									? expression.alternate
+									: expression.consequent;
+								const dep = new ConstDependency("0", branchToRemove.range);
+								dep.loc = branchToRemove.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return bool;
 							}
-							for (const dep of block.dependencies) {
-								const connection = moduleGraph.getConnection(dep);
-								if (!connection || !connection.module) {
-									continue;
-								}
-								const activeState = connection.getActiveState(runtime);
-								if (activeState === false) continue;
-								const { module } = connection;
-								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-									processModule(module, runtime, false);
-									continue;
-								}
-								const oldReferencedExports = map.get(module);
-								if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
-									continue;
-								}
-								const referencedExports =
-									compilation.getDependencyReferencedExports(dep, runtime);
-								if (
-									oldReferencedExports === undefined ||
-									oldReferencedExports === NO_EXPORTS_REFERENCED ||
-									referencedExports === EXPORTS_OBJECT_REFERENCED
-								) {
-									map.set(module, referencedExports);
-								} else if (
-									oldReferencedExports !== undefined &&
-									referencedExports === NO_EXPORTS_REFERENCED
-								) {
-									continue;
-								} else {
-									let exportsMap;
-									if (Array.isArray(oldReferencedExports)) {
-										exportsMap = new Map();
-										for (const item of oldReferencedExports) {
-											if (Array.isArray(item)) {
-												exportsMap.set(item.join("\n"), item);
-											} else {
-												exportsMap.set(item.name.join("\n"), item);
-											}
-										}
-										map.set(module, exportsMap);
+						}
+					);
+					parser.hooks.expressionLogicalOperator.tap(
+						"ConstPlugin",
+						expression => {
+							if (parser.scope.isAsmJs) return;
+							if (
+								expression.operator === "&&" ||
+								expression.operator === "||"
+							) {
+								const param = parser.evaluateExpression(expression.left);
+								const bool = param.asBool();
+								if (typeof bool === "boolean") {
+									// Expressions do not hoist.
+									// It is safe to remove the dead branch.
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   falsyExpression() && someExpression();
+									//
+									// the generated code is:
+									//
+									//   falsyExpression() && false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   truthyExpression() && someExpression();
+									//
+									// the generated code is:
+									//
+									//   true && someExpression();
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   truthyExpression() || someExpression();
+									//
+									// the generated code is:
+									//
+									//   truthyExpression() || false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   falsyExpression() || someExpression();
+									//
+									// the generated code is:
+									//
+									//   false && someExpression();
+									//
+									const keepRight =
+										(expression.operator === "&&" && bool) ||
+										(expression.operator === "||" && !bool);
+
+									if (
+										!param.couldHaveSideEffects() &&
+										(param.isBoolean() || keepRight)
+									) {
+										// for case like
+										//
+										//   return'development'===process.env.NODE_ENV&&'foo'
+										//
+										// we need a space before the bool to prevent result like
+										//
+										//   returnfalse&&'foo'
+										//
+										const dep = new ConstDependency(` ${bool}`, param.range);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
 									} else {
-										exportsMap = oldReferencedExports;
+										parser.walkExpression(expression.left);
 									}
-									for (const item of referencedExports) {
-										if (Array.isArray(item)) {
-											const key = item.join("\n");
-											const oldItem = exportsMap.get(key);
-											if (oldItem === undefined) {
-												exportsMap.set(key, item);
-											}
-											// if oldItem is already an array we have to do nothing
-											// if oldItem is an ReferencedExport object, we don't have to do anything
-											// as canMangle defaults to true for arrays
-										} else {
-											const key = item.name.join("\n");
-											const oldItem = exportsMap.get(key);
-											if (oldItem === undefined || Array.isArray(oldItem)) {
-												exportsMap.set(key, item);
-											} else {
-												exportsMap.set(key, {
-													name: item.name,
-													canMangle: item.canMangle && oldItem.canMangle
-												});
-											}
-										}
+									if (!keepRight) {
+										const dep = new ConstDependency(
+											"0",
+											expression.right.range
+										);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
 									}
+									return keepRight;
+								}
+							} else if (expression.operator === "??") {
+								const param = parser.evaluateExpression(expression.left);
+								const keepRight = param && param.asNullish();
+								if (typeof keepRight === "boolean") {
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   nonNullish ?? someExpression();
+									//
+									// the generated code is:
+									//
+									//   nonNullish ?? 0;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   nullish ?? someExpression();
+									//
+									// the generated code is:
+									//
+									//   null ?? someExpression();
+									//
+									if (!param.couldHaveSideEffects() && keepRight) {
+										// cspell:word returnnull
+										// for case like
+										//
+										//   return('development'===process.env.NODE_ENV&&null)??'foo'
+										//
+										// we need a space before the bool to prevent result like
+										//
+										//   returnnull??'foo'
+										//
+										const dep = new ConstDependency(" null", param.range);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+									} else {
+										const dep = new ConstDependency(
+											"0",
+											expression.right.range
+										);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+										parser.walkExpression(expression.left);
+									}
+
+									return keepRight;
 								}
 							}
 						}
+					);
+					parser.hooks.optionalChaining.tap("ConstPlugin", expr => {
+						/** @type {ExpressionNode[]} */
+						const optionalExpressionsStack = [];
+						/** @type {ExpressionNode|SuperNode} */
+						let next = expr.expression;
 
-						for (const [module, referencedExports] of map) {
-							if (Array.isArray(referencedExports)) {
-								processReferencedModule(
-									module,
-									referencedExports,
-									runtime,
-									forceSideEffects
-								);
-							} else {
-								processReferencedModule(
-									module,
-									Array.from(referencedExports.values()),
-									runtime,
-									forceSideEffects
-								);
-							}
-						}
-					};
-
-					logger.time("initialize exports usage");
-					for (const module of modules) {
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						exportInfoToModuleMap.set(exportsInfo, module);
-						exportsInfo.setHasUseInfo();
-					}
-					logger.timeEnd("initialize exports usage");
+						while (
+							next.type === "MemberExpression" ||
+							next.type === "CallExpression"
+						) {
+							if (next.type === "MemberExpression") {
+								if (next.optional) {
+									// SuperNode can not be optional
+									optionalExpressionsStack.push(
+										/** @type {ExpressionNode} */ (next.object)
+									);
+								}
+								next = next.object;
+							} else {
+								if (next.optional) {
+									// SuperNode can not be optional
+									optionalExpressionsStack.push(
+										/** @type {ExpressionNode} */ (next.callee)
+									);
+								}
+								next = next.callee;
+							}
+						}
 
-					logger.time("trace exports usage in graph");
+						while (optionalExpressionsStack.length) {
+							const expression = optionalExpressionsStack.pop();
+							const evaluated = parser.evaluateExpression(expression);
 
-					/**
-					 * @param {Dependency} dep dependency
-					 * @param {RuntimeSpec} runtime runtime
-					 */
-					const processEntryDependency = (dep, runtime) => {
-						const module = moduleGraph.getModule(dep);
-						if (module) {
-							processReferencedModule(
-								module,
-								NO_EXPORTS_REFERENCED,
-								runtime,
-								true
-							);
-						}
-					};
-					/** @type {RuntimeSpec} */
-					let globalRuntime = undefined;
-					for (const [
-						entryName,
-						{ dependencies: deps, includeDependencies: includeDeps, options }
-					] of compilation.entries) {
-						const runtime = this.global
-							? undefined
-							: getEntryRuntime(compilation, entryName, options);
-						for (const dep of deps) {
-							processEntryDependency(dep, runtime);
-						}
-						for (const dep of includeDeps) {
-							processEntryDependency(dep, runtime);
+							if (evaluated && evaluated.asNullish()) {
+								// ------------------------------------------
+								//
+								// Given the following code:
+								//
+								//   nullishMemberChain?.a.b();
+								//
+								// the generated code is:
+								//
+								//   undefined;
+								//
+								// ------------------------------------------
+								//
+								const dep = new ConstDependency(" undefined", expr.range);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
 						}
-						globalRuntime = mergeRuntimeOwned(globalRuntime, runtime);
-					}
-					for (const dep of compilation.globalEntry.dependencies) {
-						processEntryDependency(dep, globalRuntime);
-					}
-					for (const dep of compilation.globalEntry.includeDependencies) {
-						processEntryDependency(dep, globalRuntime);
-					}
+					});
+					parser.hooks.evaluateIdentifier
+						.for("__resourceQuery")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							return evaluateToString(
+								cachedParseResource(parser.state.module.resource).query
+							)(expr);
+						});
+					parser.hooks.expression
+						.for("__resourceQuery")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							const dep = new CachedConstDependency(
+								JSON.stringify(
+									cachedParseResource(parser.state.module.resource).query
+								),
+								expr.range,
+								"__resourceQuery"
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
-					while (queue.length) {
-						const [module, runtime] = queue.dequeue();
-						processModule(module, runtime, false);
-					}
-					logger.timeEnd("trace exports usage in graph");
-				}
-			);
+					parser.hooks.evaluateIdentifier
+						.for("__resourceFragment")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							return evaluateToString(
+								cachedParseResource(parser.state.module.resource).fragment
+							)(expr);
+						});
+					parser.hooks.expression
+						.for("__resourceFragment")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							const dep = new CachedConstDependency(
+								JSON.stringify(
+									cachedParseResource(parser.state.module.resource).fragment
+								),
+								expr.range,
+								"__resourceFragment"
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ConstPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ConstPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ConstPlugin", handler);
+			}
+		);
+	}
+}
+
+module.exports = ConstPlugin;
+
+
+/***/ }),
+
+/***/ 21411:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
+
+class ContextExclusionPlugin {
+	/**
+	 * @param {RegExp} negativeMatcher Matcher regular expression
+	 */
+	constructor(negativeMatcher) {
+		this.negativeMatcher = negativeMatcher;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
+			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files => {
+				return files.filter(filePath => !this.negativeMatcher.test(filePath));
+			});
 		});
 	}
 }
 
-module.exports = FlagDependencyUsagePlugin;
+module.exports = ContextExclusionPlugin;
 
 
 /***/ }),
 
-/***/ 93401:
+/***/ 76729:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -41395,1108 +36852,1488 @@ module.exports = FlagDependencyUsagePlugin;
 
 
 
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const { makeWebpackError } = __webpack_require__(11351);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const WebpackError = __webpack_require__(53799);
+const {
+	compareLocations,
+	concatComparators,
+	compareSelect,
+	keepOriginalOrder,
+	compareModulesById
+} = __webpack_require__(29579);
+const { contextify, parseResource } = __webpack_require__(82186);
+const makeSerializable = __webpack_require__(33032);
+
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./NormalModule")} NormalModule */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
+/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+/** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
 
 /**
- * @typedef {Object} GenerateContext
- * @property {DependencyTemplates} dependencyTemplates mapping from dependencies to templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {Set<string>} runtimeRequirements the requirements for runtime
- * @property {RuntimeSpec} runtime the runtime
- * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults=} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
- * @property {string} type which kind of code should be generated
- * @property {function(): Map<string, any>=} getData get access to the code generation data
+ * @typedef {Object} ContextOptions
+ * @property {ContextMode} mode
+ * @property {boolean} recursive
+ * @property {RegExp} regExp
+ * @property {"strict"|boolean=} namespaceObject
+ * @property {string=} addon
+ * @property {string=} chunkName
+ * @property {RegExp=} include
+ * @property {RegExp=} exclude
+ * @property {RawChunkGroupOptions=} groupOptions
+ * @property {string=} typePrefix
+ * @property {string=} category
+ * @property {string[][]=} referencedExports exports referenced from modules (won't be mangled)
  */
 
 /**
- * @typedef {Object} UpdateHashContext
- * @property {NormalModule} module the module
- * @property {ChunkGraph} chunkGraph
- * @property {RuntimeSpec} runtime
+ * @typedef {Object} ContextModuleOptionsExtras
+ * @property {string} resource
+ * @property {string=} resourceQuery
+ * @property {string=} resourceFragment
+ * @property {TODO} resolveOptions
  */
 
+/** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */
+
 /**
- *
+ * @callback ResolveDependenciesCallback
+ * @param {(Error | null)=} err
+ * @param {ContextElementDependency[]=} dependencies
  */
-class Generator {
-	static byType(map) {
-		return new ByTypeGenerator(map);
-	}
 
-	/* istanbul ignore next */
+/**
+ * @callback ResolveDependencies
+ * @param {InputFileSystem} fs
+ * @param {ContextModuleOptions} options
+ * @param {ResolveDependenciesCallback} callback
+ */
+
+const SNAPSHOT_OPTIONS = { timestamp: true };
+
+const TYPES = new Set(["javascript"]);
+
+class ContextModule extends Module {
 	/**
-	 * @abstract
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
+	 * @param {ContextModuleOptions} options options object
 	 */
-	getTypes(module) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	constructor(resolveDependencies, options) {
+		const parsed = parseResource(options ? options.resource : "");
+		const resource = parsed.path;
+		const resourceQuery = (options && options.resourceQuery) || parsed.query;
+		const resourceFragment =
+			(options && options.resourceFragment) || parsed.fragment;
+
+		super("javascript/dynamic", resource);
+
+		// Info from Factory
+		this.resolveDependencies = resolveDependencies;
+		/** @type {ContextModuleOptions} */
+		this.options = {
+			...options,
+			resource,
+			resourceQuery,
+			resourceFragment
+		};
+		if (options && options.resolveOptions !== undefined) {
+			this.resolveOptions = options.resolveOptions;
+		}
+
+		if (options && typeof options.mode !== "string") {
+			throw new Error("options.mode is a required option");
+		}
+
+		this._identifier = this._createIdentifier();
+		this._forceBuild = true;
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	getSize(module, type) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	getSourceTypes() {
+		return TYPES;
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
 	 */
-	generate(
-		module,
-		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
-	) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	updateCacheModule(module) {
+		const m = /** @type {ContextModule} */ (module);
+		this.resolveDependencies = m.resolveDependencies;
+		this.options = m.options;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the bailout reason should be determined
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
 	 */
-	getConcatenationBailoutReason(module, context) {
-		return `Module Concatenation is not implemented for ${this.constructor.name}`;
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.resolveDependencies = undefined;
 	}
 
-	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
-	 */
-	updateHash(hash, { module, runtime }) {
-		// no nothing
+	_prettyRegExp(regexString, stripSlash = true) {
+		const str = (regexString + "").replace(/!/g, "%21").replace(/\|/g, "%7C");
+		return stripSlash ? str.substring(1, str.length - 1) : str;
 	}
-}
 
-class ByTypeGenerator extends Generator {
-	constructor(map) {
-		super();
-		this.map = map;
-		this._types = new Set(Object.keys(map));
+	_createIdentifier() {
+		let identifier = this.context;
+		if (this.options.resourceQuery) {
+			identifier += `|${this.options.resourceQuery}`;
+		}
+		if (this.options.resourceFragment) {
+			identifier += `|${this.options.resourceFragment}`;
+		}
+		if (this.options.mode) {
+			identifier += `|${this.options.mode}`;
+		}
+		if (!this.options.recursive) {
+			identifier += "|nonrecursive";
+		}
+		if (this.options.addon) {
+			identifier += `|${this.options.addon}`;
+		}
+		if (this.options.regExp) {
+			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
+		}
+		if (this.options.include) {
+			identifier += `|include: ${this._prettyRegExp(
+				this.options.include,
+				false
+			)}`;
+		}
+		if (this.options.exclude) {
+			identifier += `|exclude: ${this._prettyRegExp(
+				this.options.exclude,
+				false
+			)}`;
+		}
+		if (this.options.referencedExports) {
+			identifier += `|referencedExports: ${JSON.stringify(
+				this.options.referencedExports
+			)}`;
+		}
+		if (this.options.chunkName) {
+			identifier += `|chunkName: ${this.options.chunkName}`;
+		}
+		if (this.options.groupOptions) {
+			identifier += `|groupOptions: ${JSON.stringify(
+				this.options.groupOptions
+			)}`;
+		}
+		if (this.options.namespaceObject === "strict") {
+			identifier += "|strict namespace object";
+		} else if (this.options.namespaceObject) {
+			identifier += "|namespace object";
+		}
+
+		return identifier;
 	}
 
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @returns {string} a unique identifier of the module
 	 */
-	getTypes(module) {
-		return this._types;
+	identifier() {
+		return this._identifier;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	getSize(module, type) {
-		const t = type || "javascript";
-		const generator = this.map[t];
-		return generator ? generator.getSize(module, t) : 0;
+	readableIdentifier(requestShortener) {
+		let identifier = requestShortener.shorten(this.context) + "/";
+		if (this.options.resourceQuery) {
+			identifier += ` ${this.options.resourceQuery}`;
+		}
+		if (this.options.mode) {
+			identifier += ` ${this.options.mode}`;
+		}
+		if (!this.options.recursive) {
+			identifier += " nonrecursive";
+		}
+		if (this.options.addon) {
+			identifier += ` ${requestShortener.shorten(this.options.addon)}`;
+		}
+		if (this.options.regExp) {
+			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		}
+		if (this.options.include) {
+			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
+		}
+		if (this.options.exclude) {
+			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+		}
+		if (this.options.referencedExports) {
+			identifier += ` referencedExports: ${this.options.referencedExports
+				.map(e => e.join("."))
+				.join(", ")}`;
+		}
+		if (this.options.chunkName) {
+			identifier += ` chunkName: ${this.options.chunkName}`;
+		}
+		if (this.options.groupOptions) {
+			const groupOptions = this.options.groupOptions;
+			for (const key of Object.keys(groupOptions)) {
+				identifier += ` ${key}: ${groupOptions[key]}`;
+			}
+		}
+		if (this.options.namespaceObject === "strict") {
+			identifier += " strict namespace object";
+		} else if (this.options.namespaceObject) {
+			identifier += " namespace object";
+		}
+
+		return identifier;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	generate(module, generateContext) {
-		const type = generateContext.type;
-		const generator = this.map[type];
-		if (!generator) {
-			throw new Error(`Generator.byType: no generator specified for ${type}`);
+	libIdent(options) {
+		let identifier = contextify(
+			options.context,
+			this.context,
+			options.associatedObjectForCache
+		);
+		if (this.layer) identifier = `(${this.layer})/${identifier}`;
+		if (this.options.mode) {
+			identifier += ` ${this.options.mode}`;
+		}
+		if (this.options.recursive) {
+			identifier += " recursive";
+		}
+		if (this.options.addon) {
+			identifier += ` ${contextify(
+				options.context,
+				this.options.addon,
+				options.associatedObjectForCache
+			)}`;
+		}
+		if (this.options.regExp) {
+			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		}
+		if (this.options.include) {
+			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
+		}
+		if (this.options.exclude) {
+			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+		}
+		if (this.options.referencedExports) {
+			identifier += ` referencedExports: ${this.options.referencedExports
+				.map(e => e.join("."))
+				.join(", ")}`;
 		}
-		return generator.generate(module, generateContext);
-	}
-}
 
-module.exports = Generator;
+		return identifier;
+	}
 
+	/**
+	 * @returns {void}
+	 */
+	invalidateBuild() {
+		this._forceBuild = true;
+	}
 
-/***/ }),
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild({ fileSystemInfo }, callback) {
+		// build if enforced
+		if (this._forceBuild) return callback(null, true);
 
-/***/ 37234:
-/***/ (function(__unused_webpack_module, exports) {
+		// always build when we have no snapshot
+		if (!this.buildInfo.snapshot) return callback(null, true);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+			callback(err, !valid);
+		});
+	}
 
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this._forceBuild = false;
+		/** @type {BuildMeta} */
+		this.buildMeta = {
+			exportsType: "default",
+			defaultObject: "redirect-warn"
+		};
+		this.buildInfo = {
+			snapshot: undefined
+		};
+		this.dependencies.length = 0;
+		this.blocks.length = 0;
+		const startTime = Date.now();
+		this.resolveDependencies(fs, this.options, (err, dependencies) => {
+			if (err) {
+				return callback(
+					makeWebpackError(err, "ContextModule.resolveDependencies")
+				);
+			}
 
+			// abort if something failed
+			// this will create an empty context
+			if (!dependencies) {
+				callback();
+				return;
+			}
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Module")} Module */
+			// enhance dependencies with meta info
+			for (const dep of dependencies) {
+				dep.loc = {
+					name: dep.userRequest
+				};
+				dep.request = this.options.addon + dep.request;
+			}
+			dependencies.sort(
+				concatComparators(
+					compareSelect(a => a.loc, compareLocations),
+					keepOriginalOrder(this.dependencies)
+				)
+			);
 
-/**
- * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
- * @param {Chunk} chunk chunk to tie to ChunkGroup
- * @returns {void}
- */
-const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
-	if (chunkGroup.pushChunk(chunk)) {
-		chunk.addGroup(chunkGroup);
+			if (this.options.mode === "sync" || this.options.mode === "eager") {
+				// if we have an sync or eager context
+				// just add all dependencies and continue
+				this.dependencies = dependencies;
+			} else if (this.options.mode === "lazy-once") {
+				// for the lazy-once mode create a new async dependency block
+				// and add that block to this context
+				if (dependencies.length > 0) {
+					const block = new AsyncDependenciesBlock({
+						...this.options.groupOptions,
+						name: this.options.chunkName
+					});
+					for (const dep of dependencies) {
+						block.addDependency(dep);
+					}
+					this.addBlock(block);
+				}
+			} else if (
+				this.options.mode === "weak" ||
+				this.options.mode === "async-weak"
+			) {
+				// we mark all dependencies as weak
+				for (const dep of dependencies) {
+					dep.weak = true;
+				}
+				this.dependencies = dependencies;
+			} else if (this.options.mode === "lazy") {
+				// if we are lazy create a new async dependency block per dependency
+				// and add all blocks to this context
+				let index = 0;
+				for (const dep of dependencies) {
+					let chunkName = this.options.chunkName;
+					if (chunkName) {
+						if (!/\[(index|request)\]/.test(chunkName)) {
+							chunkName += "[index]";
+						}
+						chunkName = chunkName.replace(/\[index\]/g, `${index++}`);
+						chunkName = chunkName.replace(
+							/\[request\]/g,
+							Template.toPath(dep.userRequest)
+						);
+					}
+					const block = new AsyncDependenciesBlock(
+						{
+							...this.options.groupOptions,
+							name: chunkName
+						},
+						dep.loc,
+						dep.userRequest
+					);
+					block.addDependency(dep);
+					this.addBlock(block);
+				}
+			} else {
+				callback(
+					new WebpackError(`Unsupported mode "${this.options.mode}" in context`)
+				);
+				return;
+			}
+			compilation.fileSystemInfo.createSnapshot(
+				startTime,
+				null,
+				[this.context],
+				null,
+				SNAPSHOT_OPTIONS,
+				(err, snapshot) => {
+					if (err) return callback(err);
+					this.buildInfo.snapshot = snapshot;
+					callback();
+				}
+			);
+		});
 	}
-};
 
-/**
- * @param {ChunkGroup} parent parent ChunkGroup to connect
- * @param {ChunkGroup} child child ChunkGroup to connect
- * @returns {void}
- */
-const connectChunkGroupParentAndChild = (parent, child) => {
-	if (parent.addChild(child)) {
-		child.addParent(parent);
+	/**
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 */
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {
+		contextDependencies.add(this.context);
 	}
-};
-
-exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
-exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;
 
+	/**
+	 * @param {ContextElementDependency[]} dependencies all dependencies
+	 * @param {ChunkGraph} chunkGraph chunk graph
+	 * @returns {TODO} TODO
+	 */
+	getUserRequestMap(dependencies, chunkGraph) {
+		const moduleGraph = chunkGraph.moduleGraph;
+		// if we filter first we get a new array
+		// therefore we don't need to create a clone of dependencies explicitly
+		// therefore the order of this is !important!
+		const sortedDependencies = dependencies
+			.filter(dependency => moduleGraph.getModule(dependency))
+			.sort((a, b) => {
+				if (a.userRequest === b.userRequest) {
+					return 0;
+				}
+				return a.userRequest < b.userRequest ? -1 : 1;
+			});
+		const map = Object.create(null);
+		for (const dep of sortedDependencies) {
+			const module = moduleGraph.getModule(dep);
+			map[dep.userRequest] = chunkGraph.getModuleId(module);
+		}
+		return map;
+	}
 
-/***/ }),
+	/**
+	 * @param {ContextElementDependency[]} dependencies all dependencies
+	 * @param {ChunkGraph} chunkGraph chunk graph
+	 * @returns {TODO} TODO
+	 */
+	getFakeMap(dependencies, chunkGraph) {
+		if (!this.options.namespaceObject) {
+			return 9;
+		}
+		const moduleGraph = chunkGraph.moduleGraph;
+		// bitfield
+		let hasType = 0;
+		const comparator = compareModulesById(chunkGraph);
+		// if we filter first we get a new array
+		// therefore we don't need to create a clone of dependencies explicitly
+		// therefore the order of this is !important!
+		const sortedModules = dependencies
+			.map(dependency => moduleGraph.getModule(dependency))
+			.filter(Boolean)
+			.sort(comparator);
+		const fakeMap = Object.create(null);
+		for (const module of sortedModules) {
+			const exportsType = module.getExportsType(
+				moduleGraph,
+				this.options.namespaceObject === "strict"
+			);
+			const id = chunkGraph.getModuleId(module);
+			switch (exportsType) {
+				case "namespace":
+					fakeMap[id] = 9;
+					hasType |= 1;
+					break;
+				case "dynamic":
+					fakeMap[id] = 7;
+					hasType |= 2;
+					break;
+				case "default-only":
+					fakeMap[id] = 1;
+					hasType |= 4;
+					break;
+				case "default-with-named":
+					fakeMap[id] = 3;
+					hasType |= 8;
+					break;
+				default:
+					throw new Error(`Unexpected exports type ${exportsType}`);
+			}
+		}
+		if (hasType === 1) {
+			return 9;
+		}
+		if (hasType === 2) {
+			return 7;
+		}
+		if (hasType === 4) {
+			return 1;
+		}
+		if (hasType === 8) {
+			return 3;
+		}
+		if (hasType === 0) {
+			return 9;
+		}
+		return fakeMap;
+	}
 
-/***/ 97511:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	getFakeMapInitStatement(fakeMap) {
+		return typeof fakeMap === "object"
+			? `var fakeMap = ${JSON.stringify(fakeMap, null, "\t")};`
+			: "";
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	getReturn(type, asyncModule) {
+		if (type === 9) {
+			return "__webpack_require__(id)";
+		}
+		return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${
+			asyncModule ? " | 16" : ""
+		})`;
+	}
 
+	getReturnModuleObjectSource(
+		fakeMap,
+		asyncModule,
+		fakeMapDataExpression = "fakeMap[id]"
+	) {
+		if (typeof fakeMap === "number") {
+			return `return ${this.getReturn(fakeMap, asyncModule)};`;
+		}
+		return `return ${
+			RuntimeGlobals.createFakeNamespaceObject
+		}(id, ${fakeMapDataExpression}${asyncModule ? " | 16" : ""})`;
+	}
 
+	/**
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string} source code
+	 */
+	getSyncSource(dependencies, id, chunkGraph) {
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
 
-const WebpackError = __webpack_require__(53799);
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
 
-module.exports = class HarmonyLinkingError extends WebpackError {
-	/** @param {string} message Error message */
-	constructor(message) {
-		super(message);
-		this.name = "HarmonyLinkingError";
-		this.hideStack = true;
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	${returnModuleObject}
+}
+function webpackContextResolve(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
 	}
+	return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
 };
+webpackContext.resolve = webpackContextResolve;
+module.exports = webpackContext;
+webpackContext.id = ${JSON.stringify(id)};`;
+	}
 
-
-/***/ }),
-
-/***/ 11351:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Module")} Module */
-
-/**
- * @template T
- * @callback Callback
- * @param {Error=} err
- * @param {T=} stats
- * @returns {void}
- */
-
-class HookWebpackError extends WebpackError {
 	/**
-	 * Creates an instance of HookWebpackError.
-	 * @param {Error} error inner error
-	 * @param {string} hook name of hook
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string} source code
 	 */
-	constructor(error, hook) {
-		super(error.message);
+	getWeakSyncSource(dependencies, id, chunkGraph) {
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
 
-		this.name = "HookWebpackError";
-		this.hook = hook;
-		this.error = error;
-		this.hideStack = true;
-		this.details = `caused by plugins in ${hook}\n${error.stack}`;
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
 
-		this.stack += `\n-- inner error --\n${error.stack}`;
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	if(!${RuntimeGlobals.moduleFactories}[id]) {
+		var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
 	}
+	${returnModuleObject}
 }
+function webpackContextResolve(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+webpackContext.id = ${JSON.stringify(id)};
+module.exports = webpackContext;`;
+	}
 
-module.exports = HookWebpackError;
-
-/**
- * @param {Error} error an error
- * @param {string} hook name of the hook
- * @returns {WebpackError} a webpack error
- */
-const makeWebpackError = (error, hook) => {
-	if (error instanceof WebpackError) return error;
-	return new HookWebpackError(error, hook);
-};
-module.exports.makeWebpackError = makeWebpackError;
+	/**
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} context context
+	 * @param {ChunkGraph} context.chunkGraph the chunk graph
+	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @returns {string} source code
+	 */
+	getAsyncWeakSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap, true);
 
-/**
- * @template T
- * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
- * @param {string} hook name of hook
- * @returns {Callback<T>} generic callback
- */
-const makeWebpackErrorCallback = (callback, hook) => {
-	return (err, result) => {
-		if (err) {
-			if (err instanceof WebpackError) {
-				callback(err);
-				return;
-			}
-			callback(new HookWebpackError(err, hook));
-			return;
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${
+		arrow ? "id =>" : "function(id)"
+	} {
+		if(!${RuntimeGlobals.moduleFactories}[id]) {
+			var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
 		}
-		callback(null, result);
-	};
-};
+		${returnModuleObject}
+	});
+}
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+	}
 
-module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
+	/**
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} context context
+	 * @param {ChunkGraph} context.chunkGraph the chunk graph
+	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @returns {string} source code
+	 */
+	getEagerSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const thenFunction =
+			fakeMap !== 9
+				? `${arrow ? "id =>" : "function(id)"} {
+		${this.getReturnModuleObjectSource(fakeMap)}
+	}`
+				: "__webpack_require__";
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
 
-/**
- * @template T
- * @param {function(): T} fn function which will be wrapping in try catch
- * @param {string} hook name of hook
- * @returns {T} the result
- */
-const tryRunOrWebpackError = (fn, hook) => {
-	let r;
-	try {
-		r = fn();
-	} catch (err) {
-		if (err instanceof WebpackError) {
-			throw err;
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${thenFunction});
+}
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
 		}
-		throw new HookWebpackError(err, hook);
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
-	return r;
-};
 
-module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
+	/**
+	 * @param {TODO} block TODO
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} options options object
+	 * @param {RuntimeTemplate} options.runtimeTemplate the runtime template
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @returns {string} source code
+	 */
+	getLazyOnceSource(block, dependencies, id, { runtimeTemplate, chunkGraph }) {
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block,
+			message: "lazy-once context",
+			runtimeRequirements: new Set()
+		});
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const thenFunction =
+			fakeMap !== 9
+				? `${arrow ? "id =>" : "function(id)"} {
+		${this.getReturnModuleObjectSource(fakeMap, true)};
+	}`
+				: "__webpack_require__";
 
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
 
-/***/ }),
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${thenFunction});
+}
+function webpackAsyncContextResolve(req) {
+	return ${promise}.then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+	}
 
-/***/ 6404:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {TODO} blocks TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} context context
+	 * @param {ChunkGraph} context.chunkGraph the chunk graph
+	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @returns {string} source code
+	 */
+	getLazySource(blocks, id, { chunkGraph, runtimeTemplate }) {
+		const moduleGraph = chunkGraph.moduleGraph;
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		let hasMultipleOrNoChunks = false;
+		let hasNoChunk = true;
+		const fakeMap = this.getFakeMap(
+			blocks.map(b => b.dependencies[0]),
+			chunkGraph
+		);
+		const hasFakeMap = typeof fakeMap === "object";
+		const items = blocks
+			.map(block => {
+				const dependency = block.dependencies[0];
+				return {
+					dependency: dependency,
+					module: moduleGraph.getModule(dependency),
+					block: block,
+					userRequest: dependency.userRequest,
+					chunks: undefined
+				};
+			})
+			.filter(item => item.module);
+		for (const item of items) {
+			const chunkGroup = chunkGraph.getBlockChunkGroup(item.block);
+			const chunks = (chunkGroup && chunkGroup.chunks) || [];
+			item.chunks = chunks;
+			if (chunks.length > 0) {
+				hasNoChunk = false;
+			}
+			if (chunks.length !== 1) {
+				hasMultipleOrNoChunks = true;
+			}
+		}
+		const shortMode = hasNoChunk && !hasFakeMap;
+		const sortedItems = items.sort((a, b) => {
+			if (a.userRequest === b.userRequest) return 0;
+			return a.userRequest < b.userRequest ? -1 : 1;
+		});
+		const map = Object.create(null);
+		for (const item of sortedItems) {
+			const moduleId = chunkGraph.getModuleId(item.module);
+			if (shortMode) {
+				map[item.userRequest] = moduleId;
+			} else {
+				const arrayStart = [moduleId];
+				if (hasFakeMap) {
+					arrayStart.push(fakeMap[moduleId]);
+				}
+				map[item.userRequest] = arrayStart.concat(
+					item.chunks.map(chunk => chunk.id)
+				);
+			}
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const chunksStartPosition = hasFakeMap ? 2 : 1;
+		const requestPrefix = hasNoChunk
+			? "Promise.resolve()"
+			: hasMultipleOrNoChunks
+			? `Promise.all(ids.slice(${chunksStartPosition}).map(${RuntimeGlobals.ensureChunk}))`
+			: `${RuntimeGlobals.ensureChunk}(ids[${chunksStartPosition}])`;
+		const returnModuleObject = this.getReturnModuleObjectSource(
+			fakeMap,
+			true,
+			shortMode ? "invalid" : "ids[1]"
+		);
 
+		const webpackAsyncContext =
+			requestPrefix === "Promise.resolve()"
+				? `
+function webpackAsyncContext(req) {
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
 
+		${shortMode ? "var id = map[req];" : "var ids = map[req], id = ids[0];"}
+		${returnModuleObject}
+	});
+}`
+				: `function webpackAsyncContext(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		});
+	}
 
-const { SyncBailHook } = __webpack_require__(6967);
-const { RawSource } = __webpack_require__(51255);
-const ChunkGraph = __webpack_require__(64971);
-const Compilation = __webpack_require__(85720);
-const HotUpdateChunk = __webpack_require__(9597);
-const NormalModule = __webpack_require__(39);
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const ConstDependency = __webpack_require__(76911);
-const ImportMetaHotAcceptDependency = __webpack_require__(51274);
-const ImportMetaHotDeclineDependency = __webpack_require__(53141);
-const ModuleHotAcceptDependency = __webpack_require__(47511);
-const ModuleHotDeclineDependency = __webpack_require__(86301);
-const HotModuleReplacementRuntimeModule = __webpack_require__(27899);
-const JavascriptParser = __webpack_require__(29050);
-const {
-	evaluateToIdentifier
-} = __webpack_require__(93998);
-const { find, isSubset } = __webpack_require__(93347);
-const TupleSet = __webpack_require__(76455);
-const { compareModulesById } = __webpack_require__(29579);
-const {
-	getRuntimeKey,
-	keyToRuntime,
-	forEachRuntime,
-	mergeRuntimeOwned,
-	subtractRuntime,
-	intersectRuntime
-} = __webpack_require__(17156);
+	var ids = map[req], id = ids[0];
+	return ${requestPrefix}.then(${arrow ? "() =>" : "function()"} {
+		${returnModuleObject}
+	});
+}`;
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${webpackAsyncContext}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
+	}
 
-/**
- * @typedef {Object} HMRJavascriptParserHooks
- * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptCallback
- * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptWithoutCallback
- */
+	getSourceForEmptyContext(id, runtimeTemplate) {
+		return `function webpackEmptyContext(req) {
+	var e = new Error("Cannot find module '" + req + "'");
+	e.code = 'MODULE_NOT_FOUND';
+	throw e;
+}
+webpackEmptyContext.keys = ${runtimeTemplate.returningFunction("[]")};
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = ${JSON.stringify(id)};
+module.exports = webpackEmptyContext;`;
+	}
 
-/** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
-const parserHooksMap = new WeakMap();
+	getSourceForEmptyAsyncContext(id, runtimeTemplate) {
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		return `function webpackEmptyAsyncContext(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	});
+}
+webpackEmptyAsyncContext.keys = ${runtimeTemplate.returningFunction("[]")};
+webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
+webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackEmptyAsyncContext;`;
+	}
 
-class HotModuleReplacementPlugin {
 	/**
-	 * @param {JavascriptParser} parser the parser
-	 * @returns {HMRJavascriptParserHooks} the attached hooks
+	 * @param {string} asyncMode module mode
+	 * @param {CodeGenerationContext} context context info
+	 * @returns {string} the source code
 	 */
-	static getParserHooks(parser) {
-		if (!(parser instanceof JavascriptParser)) {
-			throw new TypeError(
-				"The 'parser' argument must be an instance of JavascriptParser"
-			);
+	getSourceString(asyncMode, { runtimeTemplate, chunkGraph }) {
+		const id = chunkGraph.getModuleId(this);
+		if (asyncMode === "lazy") {
+			if (this.blocks && this.blocks.length > 0) {
+				return this.getLazySource(this.blocks, id, {
+					runtimeTemplate,
+					chunkGraph
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		let hooks = parserHooksMap.get(parser);
-		if (hooks === undefined) {
-			hooks = {
-				hotAcceptCallback: new SyncBailHook(["expression", "requests"]),
-				hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"])
-			};
-			parserHooksMap.set(parser, hooks);
+		if (asyncMode === "eager") {
+			if (this.dependencies && this.dependencies.length > 0) {
+				return this.getEagerSource(this.dependencies, id, {
+					chunkGraph,
+					runtimeTemplate
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		return hooks;
+		if (asyncMode === "lazy-once") {
+			const block = this.blocks[0];
+			if (block) {
+				return this.getLazyOnceSource(block, block.dependencies, id, {
+					runtimeTemplate,
+					chunkGraph
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+		}
+		if (asyncMode === "async-weak") {
+			if (this.dependencies && this.dependencies.length > 0) {
+				return this.getAsyncWeakSource(this.dependencies, id, {
+					chunkGraph,
+					runtimeTemplate
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+		}
+		if (asyncMode === "weak") {
+			if (this.dependencies && this.dependencies.length > 0) {
+				return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
+			}
+		}
+		if (this.dependencies && this.dependencies.length > 0) {
+			return this.getSyncSource(this.dependencies, id, chunkGraph);
+		}
+		return this.getSourceForEmptyContext(id, runtimeTemplate);
 	}
 
-	constructor(options) {
-		this.options = options || {};
+	getSource(sourceString) {
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			return new OriginalSource(sourceString, this.identifier());
+		}
+		return new RawSource(sourceString);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	apply(compiler) {
-		const { _backCompat: backCompat } = compiler;
-		if (compiler.options.output.strictModuleErrorHandling === undefined)
-			compiler.options.output.strictModuleErrorHandling = true;
-		const runtimeRequirements = [RuntimeGlobals.module];
+	codeGeneration(context) {
+		const { chunkGraph } = context;
+		const sources = new Map();
+		sources.set(
+			"javascript",
+			this.getSource(this.getSourceString(this.options.mode, context))
+		);
+		const set = new Set();
+		const allDeps = /** @type {ContextElementDependency[]} */ (
+			this.dependencies.concat(this.blocks.map(b => b.dependencies[0]))
+		);
+		set.add(RuntimeGlobals.module);
+		set.add(RuntimeGlobals.hasOwnProperty);
+		if (allDeps.length > 0) {
+			const asyncMode = this.options.mode;
+			set.add(RuntimeGlobals.require);
+			if (asyncMode === "weak") {
+				set.add(RuntimeGlobals.moduleFactories);
+			} else if (asyncMode === "async-weak") {
+				set.add(RuntimeGlobals.moduleFactories);
+				set.add(RuntimeGlobals.ensureChunk);
+			} else if (asyncMode === "lazy" || asyncMode === "lazy-once") {
+				set.add(RuntimeGlobals.ensureChunk);
+			}
+			if (this.getFakeMap(allDeps, chunkGraph) !== 9) {
+				set.add(RuntimeGlobals.createFakeNamespaceObject);
+			}
+		}
+		return {
+			sources,
+			runtimeRequirements: set
+		};
+	}
 
-		const createAcceptHandler = (parser, ParamDependency) => {
-			const { hotAcceptCallback, hotAcceptWithoutCallback } =
-				HotModuleReplacementPlugin.getParserHooks(parser);
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		// base penalty
+		let size = 160;
 
-			return expr => {
-				const module = parser.state.module;
-				const dep = new ConstDependency(
-					`${module.moduleArgument}.hot.accept`,
-					expr.callee.range,
-					runtimeRequirements
-				);
-				dep.loc = expr.loc;
-				module.addPresentationalDependency(dep);
-				module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
-				if (expr.arguments.length >= 1) {
-					const arg = parser.evaluateExpression(expr.arguments[0]);
-					let params = [];
-					let requests = [];
-					if (arg.isString()) {
-						params = [arg];
-					} else if (arg.isArray()) {
-						params = arg.items.filter(param => param.isString());
-					}
-					if (params.length > 0) {
-						params.forEach((param, idx) => {
-							const request = param.string;
-							const dep = new ParamDependency(request, param.range);
-							dep.optional = true;
-							dep.loc = Object.create(expr.loc);
-							dep.loc.index = idx;
-							module.addDependency(dep);
-							requests.push(request);
-						});
-						if (expr.arguments.length > 1) {
-							hotAcceptCallback.call(expr.arguments[1], requests);
-							for (let i = 1; i < expr.arguments.length; i++) {
-								parser.walkExpression(expr.arguments[i]);
-							}
-							return true;
-						} else {
-							hotAcceptWithoutCallback.call(expr, requests);
-							return true;
-						}
+		// if we don't have dependencies we stop here.
+		for (const dependency of this.dependencies) {
+			const element = /** @type {ContextElementDependency} */ (dependency);
+			size += 5 + element.userRequest.length;
+		}
+		return size;
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this._identifier);
+		write(this._forceBuild);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this._identifier = read();
+		this._forceBuild = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(ContextModule, "webpack/lib/ContextModule");
+
+module.exports = ContextModule;
+
+
+/***/ }),
+
+/***/ 62471:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const asyncLib = __webpack_require__(78175);
+const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = __webpack_require__(41242);
+const ContextModule = __webpack_require__(76729);
+const ModuleFactory = __webpack_require__(51010);
+const ContextElementDependency = __webpack_require__(58477);
+const LazySet = __webpack_require__(38938);
+const { cachedSetProperty } = __webpack_require__(60839);
+const { createFakeHook } = __webpack_require__(64518);
+const { join } = __webpack_require__(17139);
+
+/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
+/** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ResolverFactory")} ResolverFactory */
+/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
+/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+const EMPTY_RESOLVE_OPTIONS = {};
+
+module.exports = class ContextModuleFactory extends ModuleFactory {
+	/**
+	 * @param {ResolverFactory} resolverFactory resolverFactory
+	 */
+	constructor(resolverFactory) {
+		super();
+		/** @type {AsyncSeriesWaterfallHook<[TODO[], ContextModuleOptions]>} */
+		const alternativeRequests = new AsyncSeriesWaterfallHook([
+			"modules",
+			"options"
+		]);
+		this.hooks = Object.freeze({
+			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
+			beforeResolve: new AsyncSeriesWaterfallHook(["data"]),
+			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
+			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
+			/** @type {SyncWaterfallHook<[string[]]>} */
+			contextModuleFiles: new SyncWaterfallHook(["files"]),
+			/** @type {FakeHook<Pick<AsyncSeriesWaterfallHook<[TODO[]]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+			alternatives: createFakeHook(
+				{
+					name: "alternatives",
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["intercept"]} */
+					intercept: interceptor => {
+						throw new Error(
+							"Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead"
+						);
+					},
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tap"]} */
+					tap: (options, fn) => {
+						alternativeRequests.tap(options, fn);
+					},
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapAsync"]} */
+					tapAsync: (options, fn) => {
+						alternativeRequests.tapAsync(options, (items, _options, callback) =>
+							fn(items, callback)
+						);
+					},
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapPromise"]} */
+					tapPromise: (options, fn) => {
+						alternativeRequests.tapPromise(options, fn);
 					}
+				},
+				"ContextModuleFactory.hooks.alternatives has deprecated in favor of ContextModuleFactory.hooks.alternativeRequests with an additional options argument.",
+				"DEP_WEBPACK_CONTEXT_MODULE_FACTORY_ALTERNATIVES"
+			),
+			alternativeRequests
+		});
+		this.resolverFactory = resolverFactory;
+	}
+
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const context = data.context;
+		const dependencies = data.dependencies;
+		const resolveOptions = data.resolveOptions;
+		const dependency = /** @type {ContextDependency} */ (dependencies[0]);
+		const fileDependencies = new LazySet();
+		const missingDependencies = new LazySet();
+		const contextDependencies = new LazySet();
+		this.hooks.beforeResolve.callAsync(
+			{
+				context: context,
+				dependencies: dependencies,
+				resolveOptions,
+				fileDependencies,
+				missingDependencies,
+				contextDependencies,
+				...dependency.options
+			},
+			(err, beforeResolveResult) => {
+				if (err) {
+					return callback(err, {
+						fileDependencies,
+						missingDependencies,
+						contextDependencies
+					});
 				}
-				parser.walkExpressions(expr.arguments);
-				return true;
-			};
-		};
 
-		const createDeclineHandler = (parser, ParamDependency) => expr => {
-			const module = parser.state.module;
-			const dep = new ConstDependency(
-				`${module.moduleArgument}.hot.decline`,
-				expr.callee.range,
-				runtimeRequirements
-			);
-			dep.loc = expr.loc;
-			module.addPresentationalDependency(dep);
-			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
-			if (expr.arguments.length === 1) {
-				const arg = parser.evaluateExpression(expr.arguments[0]);
-				let params = [];
-				if (arg.isString()) {
-					params = [arg];
-				} else if (arg.isArray()) {
-					params = arg.items.filter(param => param.isString());
+				// Ignored
+				if (!beforeResolveResult) {
+					return callback(null, {
+						fileDependencies,
+						missingDependencies,
+						contextDependencies
+					});
 				}
-				params.forEach((param, idx) => {
-					const dep = new ParamDependency(param.string, param.range);
-					dep.optional = true;
-					dep.loc = Object.create(expr.loc);
-					dep.loc.index = idx;
-					module.addDependency(dep);
-				});
-			}
-			return true;
-		};
 
-		const createHMRExpressionHandler = parser => expr => {
-			const module = parser.state.module;
-			const dep = new ConstDependency(
-				`${module.moduleArgument}.hot`,
-				expr.range,
-				runtimeRequirements
-			);
-			dep.loc = expr.loc;
-			module.addPresentationalDependency(dep);
-			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
-			return true;
-		};
+				const context = beforeResolveResult.context;
+				const request = beforeResolveResult.request;
+				const resolveOptions = beforeResolveResult.resolveOptions;
 
-		const applyModuleHot = parser => {
-			parser.hooks.evaluateIdentifier.for("module.hot").tap(
-				{
-					name: "HotModuleReplacementPlugin",
-					before: "NodeStuffPlugin"
-				},
-				expr => {
-					return evaluateToIdentifier(
-						"module.hot",
-						"module",
-						() => ["hot"],
-						true
-					)(expr);
+				let loaders,
+					resource,
+					loadersPrefix = "";
+				const idx = request.lastIndexOf("!");
+				if (idx >= 0) {
+					let loadersRequest = request.substr(0, idx + 1);
+					let i;
+					for (
+						i = 0;
+						i < loadersRequest.length && loadersRequest[i] === "!";
+						i++
+					) {
+						loadersPrefix += "!";
+					}
+					loadersRequest = loadersRequest
+						.substr(i)
+						.replace(/!+$/, "")
+						.replace(/!!+/g, "!");
+					if (loadersRequest === "") {
+						loaders = [];
+					} else {
+						loaders = loadersRequest.split("!");
+					}
+					resource = request.substr(idx + 1);
+				} else {
+					loaders = [];
+					resource = request;
 				}
-			);
-			parser.hooks.call
-				.for("module.hot.accept")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createAcceptHandler(parser, ModuleHotAcceptDependency)
-				);
-			parser.hooks.call
-				.for("module.hot.decline")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createDeclineHandler(parser, ModuleHotDeclineDependency)
-				);
-			parser.hooks.expression
-				.for("module.hot")
-				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
-		};
 
-		const applyImportMetaHot = parser => {
-			parser.hooks.evaluateIdentifier
-				.for("import.meta.webpackHot")
-				.tap("HotModuleReplacementPlugin", expr => {
-					return evaluateToIdentifier(
-						"import.meta.webpackHot",
-						"import.meta",
-						() => ["webpackHot"],
-						true
-					)(expr);
-				});
-			parser.hooks.call
-				.for("import.meta.webpackHot.accept")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createAcceptHandler(parser, ImportMetaHotAcceptDependency)
-				);
-			parser.hooks.call
-				.for("import.meta.webpackHot.decline")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createDeclineHandler(parser, ImportMetaHotDeclineDependency)
+				const contextResolver = this.resolverFactory.get(
+					"context",
+					dependencies.length > 0
+						? cachedSetProperty(
+								resolveOptions || EMPTY_RESOLVE_OPTIONS,
+								"dependencyType",
+								dependencies[0].category
+						  )
+						: resolveOptions
 				);
-			parser.hooks.expression
-				.for("import.meta.webpackHot")
-				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
-		};
+				const loaderResolver = this.resolverFactory.get("loader");
 
-		compiler.hooks.compilation.tap(
-			"HotModuleReplacementPlugin",
-			(compilation, { normalModuleFactory }) => {
-				// This applies the HMR plugin only to the targeted compiler
-				// It should not affect child compilations
-				if (compilation.compiler !== compiler) return;
+				asyncLib.parallel(
+					[
+						callback => {
+							contextResolver.resolve(
+								{},
+								context,
+								resource,
+								{
+									fileDependencies,
+									missingDependencies,
+									contextDependencies
+								},
+								(err, result) => {
+									if (err) return callback(err);
+									callback(null, result);
+								}
+							);
+						},
+						callback => {
+							asyncLib.map(
+								loaders,
+								(loader, callback) => {
+									loaderResolver.resolve(
+										{},
+										context,
+										loader,
+										{
+											fileDependencies,
+											missingDependencies,
+											contextDependencies
+										},
+										(err, result) => {
+											if (err) return callback(err);
+											callback(null, result);
+										}
+									);
+								},
+								callback
+							);
+						}
+					],
+					(err, result) => {
+						if (err) {
+							return callback(err, {
+								fileDependencies,
+								missingDependencies,
+								contextDependencies
+							});
+						}
 
-				//#region module.hot.* API
-				compilation.dependencyFactories.set(
-					ModuleHotAcceptDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ModuleHotAcceptDependency,
-					new ModuleHotAcceptDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					ModuleHotDeclineDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ModuleHotDeclineDependency,
-					new ModuleHotDeclineDependency.Template()
-				);
-				//#endregion
+						this.hooks.afterResolve.callAsync(
+							{
+								addon:
+									loadersPrefix +
+									result[1].join("!") +
+									(result[1].length > 0 ? "!" : ""),
+								resource: result[0],
+								resolveDependencies: this.resolveDependencies.bind(this),
+								...beforeResolveResult
+							},
+							(err, result) => {
+								if (err) {
+									return callback(err, {
+										fileDependencies,
+										missingDependencies,
+										contextDependencies
+									});
+								}
 
-				//#region import.meta.webpackHot.* API
-				compilation.dependencyFactories.set(
-					ImportMetaHotAcceptDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportMetaHotAcceptDependency,
-					new ImportMetaHotAcceptDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					ImportMetaHotDeclineDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportMetaHotDeclineDependency,
-					new ImportMetaHotDeclineDependency.Template()
+								// Ignored
+								if (!result) {
+									return callback(null, {
+										fileDependencies,
+										missingDependencies,
+										contextDependencies
+									});
+								}
+
+								return callback(null, {
+									module: new ContextModule(result.resolveDependencies, result),
+									fileDependencies,
+									missingDependencies,
+									contextDependencies
+								});
+							}
+						);
+					}
 				);
-				//#endregion
+			}
+		);
+	}
 
-				let hotIndex = 0;
-				const fullHashChunkModuleHashes = {};
-				const chunkModuleHashes = {};
+	/**
+	 * @param {InputFileSystem} fs file system
+	 * @param {ContextModuleOptions} options options
+	 * @param {ResolveDependenciesCallback} callback callback function
+	 * @returns {void}
+	 */
+	resolveDependencies(fs, options, callback) {
+		const cmf = this;
+		const {
+			resource,
+			resourceQuery,
+			resourceFragment,
+			recursive,
+			regExp,
+			include,
+			exclude,
+			referencedExports,
+			category,
+			typePrefix
+		} = options;
+		if (!regExp || !resource) return callback(null, []);
 
-				compilation.hooks.record.tap(
-					"HotModuleReplacementPlugin",
-					(compilation, records) => {
-						if (records.hash === compilation.hash) return;
-						const chunkGraph = compilation.chunkGraph;
-						records.hash = compilation.hash;
-						records.hotIndex = hotIndex;
-						records.fullHashChunkModuleHashes = fullHashChunkModuleHashes;
-						records.chunkModuleHashes = chunkModuleHashes;
-						records.chunkHashes = {};
-						records.chunkRuntime = {};
-						for (const chunk of compilation.chunks) {
-							records.chunkHashes[chunk.id] = chunk.hash;
-							records.chunkRuntime[chunk.id] = getRuntimeKey(chunk.runtime);
-						}
-						records.chunkModuleIds = {};
-						for (const chunk of compilation.chunks) {
-							records.chunkModuleIds[chunk.id] = Array.from(
-								chunkGraph.getOrderedChunkModulesIterable(
-									chunk,
-									compareModulesById(chunkGraph)
-								),
-								m => chunkGraph.getModuleId(m)
-							);
+		const addDirectoryChecked = (directory, visited, callback) => {
+			fs.realpath(directory, (err, realPath) => {
+				if (err) return callback(err);
+				if (visited.has(realPath)) return callback(null, []);
+				let recursionStack;
+				addDirectory(
+					directory,
+					(dir, callback) => {
+						if (recursionStack === undefined) {
+							recursionStack = new Set(visited);
+							recursionStack.add(realPath);
 						}
-					}
+						addDirectoryChecked(dir, recursionStack, callback);
+					},
+					callback
 				);
-				/** @type {TupleSet<[Module, Chunk]>} */
-				const updatedModules = new TupleSet();
-				/** @type {TupleSet<[Module, Chunk]>} */
-				const fullHashModules = new TupleSet();
-				/** @type {TupleSet<[Module, RuntimeSpec]>} */
-				const nonCodeGeneratedModules = new TupleSet();
-				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
-					const chunkGraph = compilation.chunkGraph;
-					const records = compilation.records;
-					for (const chunk of compilation.chunks) {
-						const getModuleHash = module => {
-							if (
-								compilation.codeGenerationResults.has(module, chunk.runtime)
-							) {
-								return compilation.codeGenerationResults.getHash(
-									module,
-									chunk.runtime
-								);
-							} else {
-								nonCodeGeneratedModules.add(module, chunk.runtime);
-								return chunkGraph.getModuleHash(module, chunk.runtime);
-							}
-						};
-						const fullHashModulesInThisChunk =
-							chunkGraph.getChunkFullHashModulesSet(chunk);
-						if (fullHashModulesInThisChunk !== undefined) {
-							for (const module of fullHashModulesInThisChunk) {
-								fullHashModules.add(module, chunk);
-							}
-						}
-						const modules = chunkGraph.getChunkModulesIterable(chunk);
-						if (modules !== undefined) {
-							if (records.chunkModuleHashes) {
-								if (fullHashModulesInThisChunk !== undefined) {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (
-											fullHashModulesInThisChunk.has(
-												/** @type {RuntimeModule} */ (module)
-											)
-										) {
-											if (records.fullHashChunkModuleHashes[key] !== hash) {
-												updatedModules.add(module, chunk);
-											}
-											fullHashChunkModuleHashes[key] = hash;
-										} else {
-											if (records.chunkModuleHashes[key] !== hash) {
-												updatedModules.add(module, chunk);
-											}
-											chunkModuleHashes[key] = hash;
-										}
-									}
-								} else {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (records.chunkModuleHashes[key] !== hash) {
-											updatedModules.add(module, chunk);
-										}
-										chunkModuleHashes[key] = hash;
-									}
-								}
-							} else {
-								if (fullHashModulesInThisChunk !== undefined) {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (
-											fullHashModulesInThisChunk.has(
-												/** @type {RuntimeModule} */ (module)
-											)
-										) {
-											fullHashChunkModuleHashes[key] = hash;
-										} else {
-											chunkModuleHashes[key] = hash;
-										}
-									}
-								} else {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										chunkModuleHashes[key] = hash;
-									}
-								}
-							}
-						}
-					}
-
-					hotIndex = records.hotIndex || 0;
-					if (updatedModules.size > 0) hotIndex++;
+			});
+		};
 
-					hash.update(`${hotIndex}`);
-				});
-				compilation.hooks.processAssets.tap(
-					{
-						name: "HotModuleReplacementPlugin",
-						stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
-					},
-					() => {
-						const chunkGraph = compilation.chunkGraph;
-						const records = compilation.records;
-						if (records.hash === compilation.hash) return;
-						if (
-							!records.chunkModuleHashes ||
-							!records.chunkHashes ||
-							!records.chunkModuleIds
-						) {
-							return;
-						}
-						for (const [module, chunk] of fullHashModules) {
-							const key = `${chunk.id}|${module.identifier()}`;
-							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
-								? chunkGraph.getModuleHash(module, chunk.runtime)
-								: compilation.codeGenerationResults.getHash(
-										module,
-										chunk.runtime
-								  );
-							if (records.chunkModuleHashes[key] !== hash) {
-								updatedModules.add(module, chunk);
-							}
-							chunkModuleHashes[key] = hash;
-						}
+		const addDirectory = (directory, addSubDirectory, callback) => {
+			fs.readdir(directory, (err, files) => {
+				if (err) return callback(err);
+				const processedFiles = cmf.hooks.contextModuleFiles.call(
+					/** @type {string[]} */ (files).map(file => file.normalize("NFC"))
+				);
+				if (!processedFiles || processedFiles.length === 0)
+					return callback(null, []);
+				asyncLib.map(
+					processedFiles.filter(p => p.indexOf(".") !== 0),
+					(segment, callback) => {
+						const subResource = join(fs, directory, segment);
 
-						/** @type {Map<string, { updatedChunkIds: Set<string|number>, removedChunkIds: Set<string|number>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }>} */
-						const hotUpdateMainContentByRuntime = new Map();
-						let allOldRuntime;
-						for (const key of Object.keys(records.chunkRuntime)) {
-							const runtime = keyToRuntime(records.chunkRuntime[key]);
-							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
-						}
-						forEachRuntime(allOldRuntime, runtime => {
-							const { path: filename, info: assetInfo } =
-								compilation.getPathWithInfo(
-									compilation.outputOptions.hotUpdateMainFilename,
-									{
-										hash: records.hash,
-										runtime
+						if (!exclude || !subResource.match(exclude)) {
+							fs.stat(subResource, (err, stat) => {
+								if (err) {
+									if (err.code === "ENOENT") {
+										// ENOENT is ok here because the file may have been deleted between
+										// the readdir and stat calls.
+										return callback();
+									} else {
+										return callback(err);
 									}
-								);
-							hotUpdateMainContentByRuntime.set(runtime, {
-								updatedChunkIds: new Set(),
-								removedChunkIds: new Set(),
-								removedModules: new Set(),
-								filename,
-								assetInfo
-							});
-						});
-						if (hotUpdateMainContentByRuntime.size === 0) return;
-
-						// Create a list of all active modules to verify which modules are removed completely
-						/** @type {Map<number|string, Module>} */
-						const allModules = new Map();
-						for (const module of compilation.modules) {
-							const id = chunkGraph.getModuleId(module);
-							allModules.set(id, module);
-						}
-
-						// List of completely removed modules
-						/** @type {Set<string | number>} */
-						const completelyRemovedModules = new Set();
-
-						for (const key of Object.keys(records.chunkHashes)) {
-							const oldRuntime = keyToRuntime(records.chunkRuntime[key]);
-							/** @type {Module[]} */
-							const remainingModules = [];
-							// Check which modules are removed
-							for (const id of records.chunkModuleIds[key]) {
-								const module = allModules.get(id);
-								if (module === undefined) {
-									completelyRemovedModules.add(id);
-								} else {
-									remainingModules.push(module);
 								}
-							}
 
-							let chunkId;
-							let newModules;
-							let newRuntimeModules;
-							let newFullHashModules;
-							let newDependentHashModules;
-							let newRuntime;
-							let removedFromRuntime;
-							const currentChunk = find(
-								compilation.chunks,
-								chunk => `${chunk.id}` === key
-							);
-							if (currentChunk) {
-								chunkId = currentChunk.id;
-								newRuntime = intersectRuntime(
-									currentChunk.runtime,
-									allOldRuntime
-								);
-								if (newRuntime === undefined) continue;
-								newModules = chunkGraph
-									.getChunkModules(currentChunk)
-									.filter(module => updatedModules.has(module, currentChunk));
-								newRuntimeModules = Array.from(
-									chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
-								).filter(module => updatedModules.has(module, currentChunk));
-								const fullHashModules =
-									chunkGraph.getChunkFullHashModulesIterable(currentChunk);
-								newFullHashModules =
-									fullHashModules &&
-									Array.from(fullHashModules).filter(module =>
-										updatedModules.has(module, currentChunk)
-									);
-								const dependentHashModules =
-									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
-								newDependentHashModules =
-									dependentHashModules &&
-									Array.from(dependentHashModules).filter(module =>
-										updatedModules.has(module, currentChunk)
-									);
-								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
-							} else {
-								// chunk has completely removed
-								chunkId = `${+key}` === key ? +key : key;
-								removedFromRuntime = oldRuntime;
-								newRuntime = oldRuntime;
-							}
-							if (removedFromRuntime) {
-								// chunk was removed from some runtimes
-								forEachRuntime(removedFromRuntime, runtime => {
-									hotUpdateMainContentByRuntime
-										.get(runtime)
-										.removedChunkIds.add(chunkId);
-								});
-								// dispose modules from the chunk in these runtimes
-								// where they are no longer in this runtime
-								for (const module of remainingModules) {
-									const moduleKey = `${key}|${module.identifier()}`;
-									const oldHash = records.chunkModuleHashes[moduleKey];
-									const runtimes = chunkGraph.getModuleRuntimes(module);
-									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
-										// Module is still in the same runtime combination
-										const hash = nonCodeGeneratedModules.has(module, newRuntime)
-											? chunkGraph.getModuleHash(module, newRuntime)
-											: compilation.codeGenerationResults.getHash(
-													module,
-													newRuntime
-											  );
-										if (hash !== oldHash) {
-											if (module.type === "runtime") {
-												newRuntimeModules = newRuntimeModules || [];
-												newRuntimeModules.push(
-													/** @type {RuntimeModule} */ (module)
-												);
-											} else {
-												newModules = newModules || [];
-												newModules.push(module);
-											}
+								if (stat.isDirectory()) {
+									if (!recursive) return callback();
+									addSubDirectory(subResource, callback);
+								} else if (
+									stat.isFile() &&
+									(!include || subResource.match(include))
+								) {
+									const obj = {
+										context: resource,
+										request:
+											"." +
+											subResource.substr(resource.length).replace(/\\/g, "/")
+									};
+
+									this.hooks.alternativeRequests.callAsync(
+										[obj],
+										options,
+										(err, alternatives) => {
+											if (err) return callback(err);
+											alternatives = alternatives
+												.filter(obj => regExp.test(obj.request))
+												.map(obj => {
+													const dep = new ContextElementDependency(
+														obj.request + resourceQuery + resourceFragment,
+														obj.request,
+														typePrefix,
+														category,
+														referencedExports
+													);
+													dep.optional = true;
+													return dep;
+												});
+											callback(null, alternatives);
 										}
-									} else {
-										// module is no longer in this runtime combination
-										// We (incorrectly) assume that it's not in an overlapping runtime combination
-										// and dispose it from the main runtimes the chunk was removed from
-										forEachRuntime(removedFromRuntime, runtime => {
-											// If the module is still used in this runtime, do not dispose it
-											// This could create a bad runtime state where the module is still loaded,
-											// but no chunk which contains it. This means we don't receive further HMR updates
-											// to this module and that's bad.
-											// TODO force load one of the chunks which contains the module
-											for (const moduleRuntime of runtimes) {
-												if (typeof moduleRuntime === "string") {
-													if (moduleRuntime === runtime) return;
-												} else if (moduleRuntime !== undefined) {
-													if (moduleRuntime.has(runtime)) return;
-												}
-											}
-											hotUpdateMainContentByRuntime
-												.get(runtime)
-												.removedModules.add(module);
-										});
-									}
-								}
-							}
-							if (
-								(newModules && newModules.length > 0) ||
-								(newRuntimeModules && newRuntimeModules.length > 0)
-							) {
-								const hotUpdateChunk = new HotUpdateChunk();
-								if (backCompat)
-									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
-								hotUpdateChunk.id = chunkId;
-								hotUpdateChunk.runtime = newRuntime;
-								if (currentChunk) {
-									for (const group of currentChunk.groupsIterable)
-										hotUpdateChunk.addGroup(group);
-								}
-								chunkGraph.attachModules(hotUpdateChunk, newModules || []);
-								chunkGraph.attachRuntimeModules(
-									hotUpdateChunk,
-									newRuntimeModules || []
-								);
-								if (newFullHashModules) {
-									chunkGraph.attachFullHashModules(
-										hotUpdateChunk,
-										newFullHashModules
-									);
-								}
-								if (newDependentHashModules) {
-									chunkGraph.attachDependentHashModules(
-										hotUpdateChunk,
-										newDependentHashModules
 									);
+								} else {
+									callback();
 								}
-								const renderManifest = compilation.getRenderManifest({
-									chunk: hotUpdateChunk,
-									hash: records.hash,
-									fullHash: records.hash,
-									outputOptions: compilation.outputOptions,
-									moduleTemplates: compilation.moduleTemplates,
-									dependencyTemplates: compilation.dependencyTemplates,
-									codeGenerationResults: compilation.codeGenerationResults,
-									runtimeTemplate: compilation.runtimeTemplate,
-									moduleGraph: compilation.moduleGraph,
-									chunkGraph
-								});
-								for (const entry of renderManifest) {
-									/** @type {string} */
-									let filename;
-									/** @type {AssetInfo} */
-									let assetInfo;
-									if ("filename" in entry) {
-										filename = entry.filename;
-										assetInfo = entry.info;
-									} else {
-										({ path: filename, info: assetInfo } =
-											compilation.getPathWithInfo(
-												entry.filenameTemplate,
-												entry.pathOptions
-											));
-									}
-									const source = entry.render();
-									compilation.additionalChunkAssets.push(filename);
-									compilation.emitAsset(filename, source, {
-										hotModuleReplacement: true,
-										...assetInfo
-									});
-									if (currentChunk) {
-										currentChunk.files.add(filename);
-										compilation.hooks.chunkAsset.call(currentChunk, filename);
-									}
-								}
-								forEachRuntime(newRuntime, runtime => {
-									hotUpdateMainContentByRuntime
-										.get(runtime)
-										.updatedChunkIds.add(chunkId);
-								});
-							}
-						}
-						const completelyRemovedModulesArray = Array.from(
-							completelyRemovedModules
-						);
-						const hotUpdateMainContentByFilename = new Map();
-						for (const {
-							removedChunkIds,
-							removedModules,
-							updatedChunkIds,
-							filename,
-							assetInfo
-						} of hotUpdateMainContentByRuntime.values()) {
-							const old = hotUpdateMainContentByFilename.get(filename);
-							if (
-								old &&
-								(!isSubset(old.removedChunkIds, removedChunkIds) ||
-									!isSubset(old.removedModules, removedModules) ||
-									!isSubset(old.updatedChunkIds, updatedChunkIds))
-							) {
-								compilation.warnings.push(
-									new WebpackError(`HotModuleReplacementPlugin
-The configured output.hotUpdateMainFilename doesn't lead to unique filenames per runtime and HMR update differs between runtimes.
-This might lead to incorrect runtime behavior of the applied update.
-To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`)
-								);
-								for (const chunkId of removedChunkIds)
-									old.removedChunkIds.add(chunkId);
-								for (const chunkId of removedModules)
-									old.removedModules.add(chunkId);
-								for (const chunkId of updatedChunkIds)
-									old.updatedChunkIds.add(chunkId);
-								continue;
-							}
-							hotUpdateMainContentByFilename.set(filename, {
-								removedChunkIds,
-								removedModules,
-								updatedChunkIds,
-								assetInfo
 							});
+						} else {
+							callback();
 						}
-						for (const [
-							filename,
-							{ removedChunkIds, removedModules, updatedChunkIds, assetInfo }
-						] of hotUpdateMainContentByFilename) {
-							const hotUpdateMainJson = {
-								c: Array.from(updatedChunkIds),
-								r: Array.from(removedChunkIds),
-								m:
-									removedModules.size === 0
-										? completelyRemovedModulesArray
-										: completelyRemovedModulesArray.concat(
-												Array.from(removedModules, m =>
-													chunkGraph.getModuleId(m)
-												)
-										  )
-							};
+					},
+					(err, result) => {
+						if (err) return callback(err);
 
-							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
-							compilation.emitAsset(filename, source, {
-								hotModuleReplacement: true,
-								...assetInfo
-							});
-						}
-					}
-				);
+						if (!result) return callback(null, []);
 
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"HotModuleReplacementPlugin",
-					(chunk, runtimeRequirements) => {
-						runtimeRequirements.add(RuntimeGlobals.hmrDownloadManifest);
-						runtimeRequirements.add(RuntimeGlobals.hmrDownloadUpdateHandlers);
-						runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
-						runtimeRequirements.add(RuntimeGlobals.moduleCache);
-						compilation.addRuntimeModule(
-							chunk,
-							new HotModuleReplacementRuntimeModule()
-						);
-					}
-				);
+						const flattenedResult = [];
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("HotModuleReplacementPlugin", parser => {
-						applyModuleHot(parser);
-						applyImportMetaHot(parser);
-					});
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("HotModuleReplacementPlugin", parser => {
-						applyModuleHot(parser);
-					});
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("HotModuleReplacementPlugin", parser => {
-						applyImportMetaHot(parser);
-					});
+						for (const item of result) {
+							if (item) flattenedResult.push(...item);
+						}
 
-				NormalModule.getCompilationHooks(compilation).loader.tap(
-					"HotModuleReplacementPlugin",
-					context => {
-						context.hot = true;
+						callback(null, flattenedResult);
 					}
 				);
-			}
-		);
-	}
-}
+			});
+		};
 
-module.exports = HotModuleReplacementPlugin;
+		if (typeof fs.realpath === "function") {
+			addDirectoryChecked(resource, new Set(), callback);
+		} else {
+			const addSubDirectory = (dir, callback) =>
+				addDirectory(dir, addSubDirectory, callback);
+			addDirectory(resource, addSubDirectory, callback);
+		}
+	}
+};
 
 
 /***/ }),
 
-/***/ 9597:
+/***/ 12206:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -42507,70 +38344,161 @@ module.exports = HotModuleReplacementPlugin;
 
 
 
-const Chunk = __webpack_require__(39385);
-
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./util/Hash")} Hash */
+const ContextElementDependency = __webpack_require__(58477);
+const { join } = __webpack_require__(17139);
 
-class HotUpdateChunk extends Chunk {
-	constructor() {
-		super();
-	}
-}
-
-module.exports = HotUpdateChunk;
-
-
-/***/ }),
-
-/***/ 3:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const ModuleFactory = __webpack_require__(51010);
-
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-
-/**
- * Ignores error when module is unresolved
- */
-class IgnoreErrorModuleFactory extends ModuleFactory {
-	/**
-	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
-	 */
-	constructor(normalModuleFactory) {
-		super();
+class ContextReplacementPlugin {
+	constructor(
+		resourceRegExp,
+		newContentResource,
+		newContentRecursive,
+		newContentRegExp
+	) {
+		this.resourceRegExp = resourceRegExp;
 
-		this.normalModuleFactory = normalModuleFactory;
+		if (typeof newContentResource === "function") {
+			this.newContentCallback = newContentResource;
+		} else if (
+			typeof newContentResource === "string" &&
+			typeof newContentRecursive === "object"
+		) {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = (fs, callback) => {
+				callback(null, newContentRecursive);
+			};
+		} else if (
+			typeof newContentResource === "string" &&
+			typeof newContentRecursive === "function"
+		) {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = newContentRecursive;
+		} else {
+			if (typeof newContentResource !== "string") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = newContentResource;
+				newContentResource = undefined;
+			}
+			if (typeof newContentRecursive !== "boolean") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = undefined;
+			}
+			this.newContentResource = newContentResource;
+			this.newContentRecursive = newContentRecursive;
+			this.newContentRegExp = newContentRegExp;
+		}
 	}
 
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		this.normalModuleFactory.create(data, (err, result) => {
-			return callback(null, result);
+	apply(compiler) {
+		const resourceRegExp = this.resourceRegExp;
+		const newContentCallback = this.newContentCallback;
+		const newContentResource = this.newContentResource;
+		const newContentRecursive = this.newContentRecursive;
+		const newContentRegExp = this.newContentRegExp;
+		const newContentCreateContextMap = this.newContentCreateContextMap;
+
+		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
+			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
+				if (!result) return;
+				if (resourceRegExp.test(result.request)) {
+					if (newContentResource !== undefined) {
+						result.request = newContentResource;
+					}
+					if (newContentRecursive !== undefined) {
+						result.recursive = newContentRecursive;
+					}
+					if (newContentRegExp !== undefined) {
+						result.regExp = newContentRegExp;
+					}
+					if (typeof newContentCallback === "function") {
+						newContentCallback(result);
+					} else {
+						for (const d of result.dependencies) {
+							if (d.critical) d.critical = false;
+						}
+					}
+				}
+				return result;
+			});
+			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
+				if (!result) return;
+				if (resourceRegExp.test(result.resource)) {
+					if (newContentResource !== undefined) {
+						if (
+							newContentResource.startsWith("/") ||
+							(newContentResource.length > 1 && newContentResource[1] === ":")
+						) {
+							result.resource = newContentResource;
+						} else {
+							result.resource = join(
+								compiler.inputFileSystem,
+								result.resource,
+								newContentResource
+							);
+						}
+					}
+					if (newContentRecursive !== undefined) {
+						result.recursive = newContentRecursive;
+					}
+					if (newContentRegExp !== undefined) {
+						result.regExp = newContentRegExp;
+					}
+					if (typeof newContentCreateContextMap === "function") {
+						result.resolveDependencies =
+							createResolveDependenciesFromContextMap(
+								newContentCreateContextMap
+							);
+					}
+					if (typeof newContentCallback === "function") {
+						const origResource = result.resource;
+						newContentCallback(result);
+						if (
+							result.resource !== origResource &&
+							!result.resource.startsWith("/") &&
+							(result.resource.length <= 1 || result.resource[1] !== ":")
+						) {
+							// When the function changed it to an relative path
+							result.resource = join(
+								compiler.inputFileSystem,
+								origResource,
+								result.resource
+							);
+						}
+					} else {
+						for (const d of result.dependencies) {
+							if (d.critical) d.critical = false;
+						}
+					}
+				}
+				return result;
+			});
 		});
 	}
 }
 
-module.exports = IgnoreErrorModuleFactory;
+const createResolveDependenciesFromContextMap = createContextMap => {
+	const resolveDependenciesFromContextMap = (fs, options, callback) => {
+		createContextMap(fs, (err, map) => {
+			if (err) return callback(err);
+			const dependencies = Object.keys(map).map(key => {
+				return new ContextElementDependency(
+					map[key] + options.resourceQuery + options.resourceFragment,
+					key,
+					options.category,
+					options.referencedExports
+				);
+			});
+			callback(null, dependencies);
+		});
+	};
+	return resolveDependenciesFromContextMap;
+};
+
+module.exports = ContextReplacementPlugin;
 
 
 /***/ }),
 
-/***/ 84808:
+/***/ 79065:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -42581,431 +38509,951 @@ module.exports = IgnoreErrorModuleFactory;
 
 
 
-const createSchemaValidation = __webpack_require__(32540);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const ConstDependency = __webpack_require__(76911);
+const BasicEvaluatedExpression = __webpack_require__(950);
+const {
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
+const createHash = __webpack_require__(49835);
 
-/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
+/** @typedef {import("./NormalModule")} NormalModule */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-const validate = createSchemaValidation(
-	__webpack_require__(20858),
-	() => __webpack_require__(3098),
-	{
-		name: "Ignore Plugin",
-		baseDataPath: "options"
-	}
-);
+/** @typedef {null|undefined|RegExp|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
+/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive|RuntimeValue>} CodeValue */
 
-class IgnorePlugin {
+/**
+ * @typedef {Object} RuntimeValueOptions
+ * @property {string[]=} fileDependencies
+ * @property {string[]=} contextDependencies
+ * @property {string[]=} missingDependencies
+ * @property {string[]=} buildDependencies
+ * @property {string|function(): string=} version
+ */
+
+class RuntimeValue {
 	/**
-	 * @param {IgnorePluginOptions} options IgnorePlugin options
+	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
+	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
+	constructor(fn, options) {
+		this.fn = fn;
+		if (Array.isArray(options)) {
+			options = {
+				fileDependencies: options
+			};
+		}
+		this.options = options || {};
+	}
 
-		/** @private @type {Function} */
-		this.checkIgnore = this.checkIgnore.bind(this);
+	get fileDependencies() {
+		return this.options === true ? true : this.options.fileDependencies;
 	}
 
 	/**
-	 * Note that if "contextRegExp" is given, both the "resourceRegExp"
-	 * and "contextRegExp" have to match.
-	 *
-	 * @param {ResolveData} resolveData resolve data
-	 * @returns {false|undefined} returns false when the request should be ignored, otherwise undefined
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+	 * @param {string} key the defined key
+	 * @returns {CodeValuePrimitive} code
 	 */
-	checkIgnore(resolveData) {
-		if (
-			"checkResource" in this.options &&
-			this.options.checkResource &&
-			this.options.checkResource(resolveData.request, resolveData.context)
-		) {
-			return false;
-		}
-
-		if (
-			"resourceRegExp" in this.options &&
-			this.options.resourceRegExp &&
-			this.options.resourceRegExp.test(resolveData.request)
-		) {
-			if ("contextRegExp" in this.options && this.options.contextRegExp) {
-				// if "contextRegExp" is given,
-				// both the "resourceRegExp" and "contextRegExp" have to match.
-				if (this.options.contextRegExp.test(resolveData.context)) {
-					return false;
+	exec(parser, valueCacheVersions, key) {
+		const buildInfo = parser.state.module.buildInfo;
+		if (this.options === true) {
+			buildInfo.cacheable = false;
+		} else {
+			if (this.options.fileDependencies) {
+				for (const dep of this.options.fileDependencies) {
+					buildInfo.fileDependencies.add(dep);
+				}
+			}
+			if (this.options.contextDependencies) {
+				for (const dep of this.options.contextDependencies) {
+					buildInfo.contextDependencies.add(dep);
+				}
+			}
+			if (this.options.missingDependencies) {
+				for (const dep of this.options.missingDependencies) {
+					buildInfo.missingDependencies.add(dep);
+				}
+			}
+			if (this.options.buildDependencies) {
+				for (const dep of this.options.buildDependencies) {
+					buildInfo.buildDependencies.add(dep);
 				}
-			} else {
-				return false;
 			}
 		}
-	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.normalModuleFactory.tap("IgnorePlugin", nmf => {
-			nmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
-		});
-		compiler.hooks.contextModuleFactory.tap("IgnorePlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+		return this.fn({
+			module: parser.state.module,
+			key,
+			get version() {
+				return /** @type {string} */ (
+					valueCacheVersions.get(VALUE_DEP_PREFIX + key)
+				);
+			}
 		});
 	}
-}
-
-module.exports = IgnorePlugin;
 
+	getCacheVersion() {
+		return this.options === true
+			? undefined
+			: (typeof this.options.version === "function"
+					? this.options.version()
+					: this.options.version) || "unset";
+	}
+}
 
-/***/ }),
+/**
+ * @param {any[]|{[k: string]: any}} obj obj
+ * @param {JavascriptParser} parser Parser
+ * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+ * @param {string} key the defined key
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @returns {string} code converted to string that evaluates
+ */
+const stringifyObj = (
+	obj,
+	parser,
+	valueCacheVersions,
+	key,
+	runtimeTemplate,
+	asiSafe
+) => {
+	let code;
+	let arr = Array.isArray(obj);
+	if (arr) {
+		code = `[${obj
+			.map(code =>
+				toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
+			)
+			.join(",")}]`;
+	} else {
+		code = `{${Object.keys(obj)
+			.map(key => {
+				const code = obj[key];
+				return (
+					JSON.stringify(key) +
+					":" +
+					toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
+				);
+			})
+			.join(",")}}`;
+	}
 
-/***/ 7373:
-/***/ (function(module) {
+	switch (asiSafe) {
+		case null:
+			return code;
+		case true:
+			return arr ? code : `(${code})`;
+		case false:
+			return arr ? `;${code}` : `;(${code})`;
+		default:
+			return `/*#__PURE__*/Object(${code})`;
+	}
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * Convert code to a string that evaluates
+ * @param {CodeValue} code Code to evaluate
+ * @param {JavascriptParser} parser Parser
+ * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+ * @param {string} key the defined key
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @returns {string} code converted to string that evaluates
+ */
+const toCode = (
+	code,
+	parser,
+	valueCacheVersions,
+	key,
+	runtimeTemplate,
+	asiSafe
+) => {
+	if (code === null) {
+		return "null";
+	}
+	if (code === undefined) {
+		return "undefined";
+	}
+	if (Object.is(code, -0)) {
+		return "-0";
+	}
+	if (code instanceof RuntimeValue) {
+		return toCode(
+			code.exec(parser, valueCacheVersions, key),
+			parser,
+			valueCacheVersions,
+			key,
+			runtimeTemplate,
+			asiSafe
+		);
+	}
+	if (code instanceof RegExp && code.toString) {
+		return code.toString();
+	}
+	if (typeof code === "function" && code.toString) {
+		return "(" + code.toString() + ")";
+	}
+	if (typeof code === "object") {
+		return stringifyObj(
+			code,
+			parser,
+			valueCacheVersions,
+			key,
+			runtimeTemplate,
+			asiSafe
+		);
+	}
+	if (typeof code === "bigint") {
+		return runtimeTemplate.supportsBigIntLiteral()
+			? `${code}n`
+			: `BigInt("${code}")`;
+	}
+	return code + "";
+};
 
+const toCacheVersion = code => {
+	if (code === null) {
+		return "null";
+	}
+	if (code === undefined) {
+		return "undefined";
+	}
+	if (Object.is(code, -0)) {
+		return "-0";
+	}
+	if (code instanceof RuntimeValue) {
+		return code.getCacheVersion();
+	}
+	if (code instanceof RegExp && code.toString) {
+		return code.toString();
+	}
+	if (typeof code === "function" && code.toString) {
+		return "(" + code.toString() + ")";
+	}
+	if (typeof code === "object") {
+		const items = Object.keys(code).map(key => ({
+			key,
+			value: toCacheVersion(code[key])
+		}));
+		if (items.some(({ value }) => value === undefined)) return undefined;
+		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
+	}
+	if (typeof code === "bigint") {
+		return `${code}n`;
+	}
+	return code + "";
+};
 
+const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
+const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
 
-/** @typedef {import("../declarations/WebpackOptions").IgnoreWarningsNormalized} IgnoreWarningsNormalized */
-/** @typedef {import("./Compiler")} Compiler */
+class DefinePlugin {
+	/**
+	 * Create a new define plugin
+	 * @param {Record<string, CodeValue>} definitions A map of global object definitions
+	 */
+	constructor(definitions) {
+		this.definitions = definitions;
+	}
 
-class IgnoreWarningsPlugin {
 	/**
-	 * @param {IgnoreWarningsNormalized} ignoreWarnings conditions to ignore warnings
+	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
+	 * @param {true | string[] | RuntimeValueOptions=} options options
+	 * @returns {RuntimeValue} runtime value
 	 */
-	constructor(ignoreWarnings) {
-		this._ignoreWarnings = ignoreWarnings;
+	static runtimeValue(fn, options) {
+		return new RuntimeValue(fn, options);
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("IgnoreWarningsPlugin", compilation => {
-			compilation.hooks.processWarnings.tap(
-				"IgnoreWarningsPlugin",
-				warnings => {
-					return warnings.filter(warning => {
-						return !this._ignoreWarnings.some(ignore =>
-							ignore(warning, compilation)
-						);
-					});
-				}
-			);
-		});
-	}
-}
+		const definitions = this.definitions;
+		compiler.hooks.compilation.tap(
+			"DefinePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				const { runtimeTemplate } = compilation;
 
-module.exports = IgnoreWarningsPlugin;
+				const mainHash = createHash(compilation.outputOptions.hashFunction);
+				mainHash.update(
+					/** @type {string} */ (
+						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
+					) || ""
+				);
+
+				/**
+				 * Handler
+				 * @param {JavascriptParser} parser Parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
+					parser.hooks.program.tap("DefinePlugin", () => {
+						const { buildInfo } = parser.state.module;
+						if (!buildInfo.valueDependencies)
+							buildInfo.valueDependencies = new Map();
+						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
+					});
+
+					const addValueDependency = key => {
+						const { buildInfo } = parser.state.module;
+						buildInfo.valueDependencies.set(
+							VALUE_DEP_PREFIX + key,
+							compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)
+						);
+					};
+
+					const withValueDependency =
+						(key, fn) =>
+						(...args) => {
+							addValueDependency(key);
+							return fn(...args);
+						};
+
+					/**
+					 * Walk definitions
+					 * @param {Object} definitions Definitions map
+					 * @param {string} prefix Prefix string
+					 * @returns {void}
+					 */
+					const walkDefinitions = (definitions, prefix) => {
+						Object.keys(definitions).forEach(key => {
+							const code = definitions[key];
+							if (
+								code &&
+								typeof code === "object" &&
+								!(code instanceof RuntimeValue) &&
+								!(code instanceof RegExp)
+							) {
+								walkDefinitions(code, prefix + key + ".");
+								applyObjectDefine(prefix + key, code);
+								return;
+							}
+							applyDefineKey(prefix, key);
+							applyDefine(prefix + key, code);
+						});
+					};
+
+					/**
+					 * Apply define key
+					 * @param {string} prefix Prefix
+					 * @param {string} key Key
+					 * @returns {void}
+					 */
+					const applyDefineKey = (prefix, key) => {
+						const splittedKey = key.split(".");
+						splittedKey.slice(1).forEach((_, i) => {
+							const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
+							parser.hooks.canRename.for(fullKey).tap("DefinePlugin", () => {
+								addValueDependency(key);
+								return true;
+							});
+						});
+					};
+
+					/**
+					 * Apply Code
+					 * @param {string} key Key
+					 * @param {CodeValue} code Code
+					 * @returns {void}
+					 */
+					const applyDefine = (key, code) => {
+						const originalKey = key;
+						const isTypeof = /^typeof\s+/.test(key);
+						if (isTypeof) key = key.replace(/^typeof\s+/, "");
+						let recurse = false;
+						let recurseTypeof = false;
+						if (!isTypeof) {
+							parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
+								addValueDependency(originalKey);
+								return true;
+							});
+							parser.hooks.evaluateIdentifier
+								.for(key)
+								.tap("DefinePlugin", expr => {
+									/**
+									 * this is needed in case there is a recursion in the DefinePlugin
+									 * to prevent an endless recursion
+									 * e.g.: new DefinePlugin({
+									 * "a": "b",
+									 * "b": "a"
+									 * });
+									 */
+									if (recurse) return;
+									addValueDependency(originalKey);
+									recurse = true;
+									const res = parser.evaluate(
+										toCode(
+											code,
+											parser,
+											compilation.valueCacheVersions,
+											key,
+											runtimeTemplate,
+											null
+										)
+									);
+									recurse = false;
+									res.setRange(expr.range);
+									return res;
+								});
+							parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
+								addValueDependency(originalKey);
+								const strCode = toCode(
+									code,
+									parser,
+									compilation.valueCacheVersions,
+									originalKey,
+									runtimeTemplate,
+									!parser.isAsiPosition(expr.range[0])
+								);
+								if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
+									return toConstantDependency(parser, strCode, [
+										RuntimeGlobals.require
+									])(expr);
+								} else if (/__webpack_require__/.test(strCode)) {
+									return toConstantDependency(parser, strCode, [
+										RuntimeGlobals.requireScope
+									])(expr);
+								} else {
+									return toConstantDependency(parser, strCode)(expr);
+								}
+							});
+						}
+						parser.hooks.evaluateTypeof.for(key).tap("DefinePlugin", expr => {
+							/**
+							 * this is needed in case there is a recursion in the DefinePlugin
+							 * to prevent an endless recursion
+							 * e.g.: new DefinePlugin({
+							 * "typeof a": "typeof b",
+							 * "typeof b": "typeof a"
+							 * });
+							 */
+							if (recurseTypeof) return;
+							recurseTypeof = true;
+							addValueDependency(originalKey);
+							const codeCode = toCode(
+								code,
+								parser,
+								compilation.valueCacheVersions,
+								originalKey,
+								runtimeTemplate,
+								null
+							);
+							const typeofCode = isTypeof
+								? codeCode
+								: "typeof (" + codeCode + ")";
+							const res = parser.evaluate(typeofCode);
+							recurseTypeof = false;
+							res.setRange(expr.range);
+							return res;
+						});
+						parser.hooks.typeof.for(key).tap("DefinePlugin", expr => {
+							addValueDependency(originalKey);
+							const codeCode = toCode(
+								code,
+								parser,
+								compilation.valueCacheVersions,
+								originalKey,
+								runtimeTemplate,
+								null
+							);
+							const typeofCode = isTypeof
+								? codeCode
+								: "typeof (" + codeCode + ")";
+							const res = parser.evaluate(typeofCode);
+							if (!res.isString()) return;
+							return toConstantDependency(
+								parser,
+								JSON.stringify(res.string)
+							).bind(parser)(expr);
+						});
+					};
+
+					/**
+					 * Apply Object
+					 * @param {string} key Key
+					 * @param {Object} obj Object
+					 * @returns {void}
+					 */
+					const applyObjectDefine = (key, obj) => {
+						parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
+							addValueDependency(key);
+							return true;
+						});
+						parser.hooks.evaluateIdentifier
+							.for(key)
+							.tap("DefinePlugin", expr => {
+								addValueDependency(key);
+								return new BasicEvaluatedExpression()
+									.setTruthy()
+									.setSideEffects(false)
+									.setRange(expr.range);
+							});
+						parser.hooks.evaluateTypeof
+							.for(key)
+							.tap(
+								"DefinePlugin",
+								withValueDependency(key, evaluateToString("object"))
+							);
+						parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
+							addValueDependency(key);
+							const strCode = stringifyObj(
+								obj,
+								parser,
+								compilation.valueCacheVersions,
+								key,
+								runtimeTemplate,
+								!parser.isAsiPosition(expr.range[0])
+							);
+
+							if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
+								return toConstantDependency(parser, strCode, [
+									RuntimeGlobals.require
+								])(expr);
+							} else if (/__webpack_require__/.test(strCode)) {
+								return toConstantDependency(parser, strCode, [
+									RuntimeGlobals.requireScope
+								])(expr);
+							} else {
+								return toConstantDependency(parser, strCode)(expr);
+							}
+						});
+						parser.hooks.typeof
+							.for(key)
+							.tap(
+								"DefinePlugin",
+								withValueDependency(
+									key,
+									toConstantDependency(parser, JSON.stringify("object"))
+								)
+							);
+					};
+
+					walkDefinitions(definitions, "");
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("DefinePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("DefinePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("DefinePlugin", handler);
+
+				/**
+				 * Walk definitions
+				 * @param {Object} definitions Definitions map
+				 * @param {string} prefix Prefix string
+				 * @returns {void}
+				 */
+				const walkDefinitionsForValues = (definitions, prefix) => {
+					Object.keys(definitions).forEach(key => {
+						const code = definitions[key];
+						const version = toCacheVersion(code);
+						const name = VALUE_DEP_PREFIX + prefix + key;
+						mainHash.update("|" + prefix + key);
+						const oldVersion = compilation.valueCacheVersions.get(name);
+						if (oldVersion === undefined) {
+							compilation.valueCacheVersions.set(name, version);
+						} else if (oldVersion !== version) {
+							const warning = new WebpackError(
+								`DefinePlugin\nConflicting values for '${prefix + key}'`
+							);
+							warning.details = `'${oldVersion}' !== '${version}'`;
+							warning.hideStack = true;
+							compilation.warnings.push(warning);
+						}
+						if (
+							code &&
+							typeof code === "object" &&
+							!(code instanceof RuntimeValue) &&
+							!(code instanceof RegExp)
+						) {
+							walkDefinitionsForValues(code, prefix + key + ".");
+						}
+					});
+				};
+
+				walkDefinitionsForValues(definitions, "");
+
+				compilation.valueCacheVersions.set(
+					VALUE_DEP_MAIN,
+					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
+				);
+			}
+		);
+	}
+}
+module.exports = DefinePlugin;
 
 
 /***/ }),
 
-/***/ 55870:
+/***/ 28623:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const DelegatedSourceDependency = __webpack_require__(22914);
+const StaticExportsDependency = __webpack_require__(91418);
 const makeSerializable = __webpack_require__(33032);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").SourceContext} SourceContext */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/**
- * @param {InitFragment} fragment the init fragment
- * @param {number} index index
- * @returns {[InitFragment, number]} tuple with both
- */
-const extractFragmentIndex = (fragment, index) => [fragment, index];
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([
+	RuntimeGlobals.module,
+	RuntimeGlobals.require
+]);
 
-/**
- * @param {[InitFragment, number]} a first pair
- * @param {[InitFragment, number]} b second pair
- * @returns {number} sort value
- */
-const sortFragmentWithIndex = ([a, i], [b, j]) => {
-	const stageCmp = a.stage - b.stage;
-	if (stageCmp !== 0) return stageCmp;
-	const positionCmp = a.position - b.position;
-	if (positionCmp !== 0) return positionCmp;
-	return i - j;
-};
+class DelegatedModule extends Module {
+	constructor(sourceRequest, data, type, userRequest, originalRequest) {
+		super("javascript/dynamic", null);
+
+		// Info from Factory
+		this.sourceRequest = sourceRequest;
+		this.request = data.id;
+		this.delegationType = type;
+		this.userRequest = userRequest;
+		this.originalRequest = originalRequest;
+		/** @type {ManifestModuleData} */
+		this.delegateData = data;
+
+		// Build info
+		this.delegatedSourceDependency = undefined;
+	}
 
-/**
- * @template Context
- */
-class InitFragment {
 	/**
-	 * @param {string|Source} content the source code that will be included as initialization code
-	 * @param {number} stage category of initialization code (contribute to order)
-	 * @param {number} position position in the category (contribute to order)
-	 * @param {string=} key unique key to avoid emitting the same initialization code twice
-	 * @param {string|Source=} endContent the source code that will be included at the end of the module
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	constructor(content, stage, position, key, endContent) {
-		this.content = content;
-		this.stage = stage;
-		this.position = position;
-		this.key = key;
-		this.endContent = endContent;
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	getContent(context) {
-		return this.content;
+	libIdent(options) {
+		return typeof this.originalRequest === "string"
+			? this.originalRequest
+			: this.originalRequest.libIdent(options);
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 * @returns {string} a unique identifier of the module
 	 */
-	getEndContent(context) {
-		return this.endContent;
+	identifier() {
+		return `delegated ${JSON.stringify(this.request)} from ${
+			this.sourceRequest
+		}`;
 	}
 
-	static addToSource(source, initFragments, context) {
-		if (initFragments.length > 0) {
-			// Sort fragments by position. If 2 fragments have the same position,
-			// use their index.
-			const sortedFragments = initFragments
-				.map(extractFragmentIndex)
-				.sort(sortFragmentWithIndex);
-
-			// Deduplicate fragments. If a fragment has no key, it is always included.
-			const keyedFragments = new Map();
-			for (const [fragment] of sortedFragments) {
-				if (typeof fragment.mergeAll === "function") {
-					if (!fragment.key) {
-						throw new Error(
-							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
-						);
-					}
-					const oldValue = keyedFragments.get(fragment.key);
-					if (oldValue === undefined) {
-						keyedFragments.set(fragment.key, fragment);
-					} else if (Array.isArray(oldValue)) {
-						oldValue.push(fragment);
-					} else {
-						keyedFragments.set(fragment.key, [oldValue, fragment]);
-					}
-					continue;
-				} else if (typeof fragment.merge === "function") {
-					const oldValue = keyedFragments.get(fragment.key);
-					if (oldValue !== undefined) {
-						keyedFragments.set(fragment.key, fragment.merge(oldValue));
-						continue;
-					}
-				}
-				keyedFragments.set(fragment.key || Symbol(), fragment);
-			}
-
-			const concatSource = new ConcatSource();
-			const endContents = [];
-			for (let fragment of keyedFragments.values()) {
-				if (Array.isArray(fragment)) {
-					fragment = fragment[0].mergeAll(fragment);
-				}
-				concatSource.add(fragment.getContent(context));
-				const endContent = fragment.getEndContent(context);
-				if (endContent) {
-					endContents.push(endContent);
-				}
-			}
-
-			concatSource.add(source);
-			for (const content of endContents.reverse()) {
-				concatSource.add(content);
-			}
-			return concatSource;
-		} else {
-			return source;
-		}
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.content);
-		write(this.stage);
-		write(this.position);
-		write(this.key);
-		write(this.endContent);
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.content = read();
-		this.stage = read();
-		this.position = read();
-		this.key = read();
-		this.endContent = read();
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = { ...this.delegateData.buildMeta };
+		this.buildInfo = {};
+		this.dependencies.length = 0;
+		this.delegatedSourceDependency = new DelegatedSourceDependency(
+			this.sourceRequest
+		);
+		this.addDependency(this.delegatedSourceDependency);
+		this.addDependency(
+			new StaticExportsDependency(this.delegateData.exports || true, false)
+		);
+		callback();
 	}
-}
-
-makeSerializable(InitFragment, "webpack/lib/InitFragment");
-
-InitFragment.prototype.merge = undefined;
 
-InitFragment.STAGE_CONSTANTS = 10;
-InitFragment.STAGE_ASYNC_BOUNDARY = 20;
-InitFragment.STAGE_HARMONY_EXPORTS = 30;
-InitFragment.STAGE_HARMONY_IMPORTS = 40;
-InitFragment.STAGE_PROVIDES = 50;
-InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
-InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70;
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const dep = /** @type {DelegatedSourceDependency} */ (this.dependencies[0]);
+		const sourceModule = moduleGraph.getModule(dep);
+		let str;
 
-module.exports = InitFragment;
+		if (!sourceModule) {
+			str = runtimeTemplate.throwMissingModuleErrorBlock({
+				request: this.sourceRequest
+			});
+		} else {
+			str = `module.exports = (${runtimeTemplate.moduleExports({
+				module: sourceModule,
+				chunkGraph,
+				request: dep.request,
+				runtimeRequirements: new Set()
+			})})`;
 
+			switch (this.delegationType) {
+				case "require":
+					str += `(${JSON.stringify(this.request)})`;
+					break;
+				case "object":
+					str += `[${JSON.stringify(this.request)}]`;
+					break;
+			}
 
-/***/ }),
+			str += ";";
+		}
 
-/***/ 68257:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const sources = new Map();
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			sources.set("javascript", new OriginalSource(str, this.identifier()));
+		} else {
+			sources.set("javascript", new RawSource(str));
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		return {
+			sources,
+			runtimeRequirements: RUNTIME_REQUIREMENTS
+		};
+	}
 
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
+	}
 
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(this.delegationType);
+		hash.update(JSON.stringify(this.request));
+		super.updateHash(hash, context);
+	}
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+	serialize(context) {
+		const { write } = context;
+		// constructor
+		write(this.sourceRequest);
+		write(this.delegateData);
+		write(this.delegationType);
+		write(this.userRequest);
+		write(this.originalRequest);
+		super.serialize(context);
+	}
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new DelegatedModule(
+			read(), // sourceRequest
+			read(), // delegateData
+			read(), // delegationType
+			read(), // userRequest
+			read() // originalRequest
+		);
+		obj.deserialize(context);
+		return obj;
+	}
 
-class InvalidDependenciesModuleWarning extends WebpackError {
 	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {Iterable<string>} deps invalid dependencies
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
 	 */
-	constructor(module, deps) {
-		const orderedDeps = deps ? Array.from(deps).sort() : [];
-		const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
-		super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
-Invalid dependencies may lead to broken watching and caching.
-As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.
-Loaders: Pass absolute paths to this.addDependency (existing files), this.addMissingDependency (not existing files), and this.addContextDependency (directories).
-Plugins: Pass absolute paths to fileDependencies (existing files), missingDependencies (not existing files), and contextDependencies (directories).
-Globs: They are not supported. Pass absolute path to the directory as context dependencies.
-The following invalid values have been reported:
-${depsList.slice(0, 3).join("\n")}${
-			depsList.length > 3 ? "\n * and more ..." : ""
-		}`);
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {DelegatedModule} */ (module);
+		this.delegationType = m.delegationType;
+		this.userRequest = m.userRequest;
+		this.originalRequest = m.originalRequest;
+		this.delegateData = m.delegateData;
+	}
 
-		this.name = "InvalidDependenciesModuleWarning";
-		this.details = depsList.slice(3).join("\n");
-		this.module = module;
+	/**
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.delegateData = undefined;
 	}
 }
 
-makeSerializable(
-	InvalidDependenciesModuleWarning,
-	"webpack/lib/InvalidDependenciesModuleWarning"
-);
+makeSerializable(DelegatedModule, "webpack/lib/DelegatedModule");
 
-module.exports = InvalidDependenciesModuleWarning;
+module.exports = DelegatedModule;
 
 
 /***/ }),
 
-/***/ 52329:
+/***/ 51387:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra
 */
 
 
 
-const InnerGraph = __webpack_require__(38988);
+const DelegatedModule = __webpack_require__(28623);
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+// options.source
+// options.type
+// options.context
+// options.scope
+// options.content
+// options.associatedObjectForCache
+class DelegatedModuleFactoryPlugin {
+	constructor(options) {
+		this.options = options;
+		options.type = options.type || "require";
+		options.extensions = options.extensions || ["", ".js", ".json", ".wasm"];
+	}
 
-class JavascriptMetaInfoPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"JavascriptMetaInfoPlugin",
-			(compilation, { normalModuleFactory }) => {
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
-						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
-						parser.state.module.buildInfo.usingEval = true;
-						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
-						if (currentSymbol) {
-							InnerGraph.addUsage(parser.state, null, currentSymbol);
-						} else {
-							InnerGraph.bailout(parser.state);
-						}
-					});
-					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
-						let topLevelDeclarations =
-							parser.state.module.buildInfo.topLevelDeclarations;
-						if (topLevelDeclarations === undefined) {
-							topLevelDeclarations =
-								parser.state.module.buildInfo.topLevelDeclarations = new Set();
+	apply(normalModuleFactory) {
+		const scope = this.options.scope;
+		if (scope) {
+			normalModuleFactory.hooks.factorize.tapAsync(
+				"DelegatedModuleFactoryPlugin",
+				(data, callback) => {
+					const [dependency] = data.dependencies;
+					const { request } = dependency;
+					if (request && request.startsWith(`${scope}/`)) {
+						const innerRequest = "." + request.substr(scope.length);
+						let resolved;
+						if (innerRequest in this.options.content) {
+							resolved = this.options.content[innerRequest];
+							return callback(
+								null,
+								new DelegatedModule(
+									this.options.source,
+									resolved,
+									this.options.type,
+									innerRequest,
+									request
+								)
+							);
 						}
-						for (const name of parser.scope.definitions.asSet()) {
-							const freeInfo = parser.getFreeInfoFromVariable(name);
-							if (freeInfo === undefined) {
-								topLevelDeclarations.add(name);
+						for (let i = 0; i < this.options.extensions.length; i++) {
+							const extension = this.options.extensions[i];
+							const requestPlusExt = innerRequest + extension;
+							if (requestPlusExt in this.options.content) {
+								resolved = this.options.content[requestPlusExt];
+								return callback(
+									null,
+									new DelegatedModule(
+										this.options.source,
+										resolved,
+										this.options.type,
+										requestPlusExt,
+										request + extension
+									)
+								);
 							}
 						}
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("JavascriptMetaInfoPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("JavascriptMetaInfoPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("JavascriptMetaInfoPlugin", handler);
-			}
-		);
+					}
+					return callback();
+				}
+			);
+		} else {
+			normalModuleFactory.hooks.module.tap(
+				"DelegatedModuleFactoryPlugin",
+				module => {
+					const request = module.libIdent(this.options);
+					if (request) {
+						if (request in this.options.content) {
+							const resolved = this.options.content[request];
+							return new DelegatedModule(
+								this.options.source,
+								resolved,
+								this.options.type,
+								request,
+								module
+							);
+						}
+					}
+					return module;
+				}
+			);
+		}
 	}
 }
-
-module.exports = JavascriptMetaInfoPlugin;
+module.exports = DelegatedModuleFactoryPlugin;
 
 
 /***/ }),
 
-/***/ 93837:
+/***/ 80632:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -43016,22 +39464,12 @@ module.exports = JavascriptMetaInfoPlugin;
 
 
 
-const asyncLib = __webpack_require__(78175);
-const EntryDependency = __webpack_require__(3979);
-const { someInIterable } = __webpack_require__(39104);
-const { compareModulesById } = __webpack_require__(29579);
-const { dirname, mkdirp } = __webpack_require__(17139);
+const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
+const DelegatedSourceDependency = __webpack_require__(22914);
 
 /** @typedef {import("./Compiler")} Compiler */
 
-/**
- * @typedef {Object} ManifestModuleData
- * @property {string | number} id
- * @property {Object} buildMeta
- * @property {boolean | string[]} exports
- */
-
-class LibManifestPlugin {
+class DelegatedPlugin {
 	constructor(options) {
 		this.options = options;
 	}
@@ -43042,93 +39480,31 @@ class LibManifestPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.emit.tapAsync(
-			"LibManifestPlugin",
-			(compilation, callback) => {
-				const moduleGraph = compilation.moduleGraph;
-				asyncLib.forEach(
-					Array.from(compilation.chunks),
-					(chunk, callback) => {
-						if (!chunk.canBeInitial()) {
-							callback();
-							return;
-						}
-						const chunkGraph = compilation.chunkGraph;
-						const targetPath = compilation.getPath(this.options.path, {
-							chunk
-						});
-						const name =
-							this.options.name &&
-							compilation.getPath(this.options.name, {
-								chunk
-							});
-						const content = Object.create(null);
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesById(chunkGraph)
-						)) {
-							if (
-								this.options.entryOnly &&
-								!someInIterable(
-									moduleGraph.getIncomingConnections(module),
-									c => c.dependency instanceof EntryDependency
-								)
-							) {
-								continue;
-							}
-							const ident = module.libIdent({
-								context: this.options.context || compiler.options.context,
-								associatedObjectForCache: compiler.root
-							});
-							if (ident) {
-								const exportsInfo = moduleGraph.getExportsInfo(module);
-								const providedExports = exportsInfo.getProvidedExports();
-								/** @type {ManifestModuleData} */
-								const data = {
-									id: chunkGraph.getModuleId(module),
-									buildMeta: module.buildMeta,
-									exports: Array.isArray(providedExports)
-										? providedExports
-										: undefined
-								};
-								content[ident] = data;
-							}
-						}
-						const manifest = {
-							name,
-							type: this.options.type,
-							content
-						};
-						// Apply formatting to content if format flag is true;
-						const manifestContent = this.options.format
-							? JSON.stringify(manifest, null, 2)
-							: JSON.stringify(manifest);
-						const buffer = Buffer.from(manifestContent, "utf8");
-						mkdirp(
-							compiler.intermediateFileSystem,
-							dirname(compiler.intermediateFileSystem, targetPath),
-							err => {
-								if (err) return callback(err);
-								compiler.intermediateFileSystem.writeFile(
-									targetPath,
-									buffer,
-									callback
-								);
-							}
-						);
-					},
-					callback
+		compiler.hooks.compilation.tap(
+			"DelegatedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					DelegatedSourceDependency,
+					normalModuleFactory
 				);
 			}
 		);
+
+		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
+			new DelegatedModuleFactoryPlugin({
+				associatedObjectForCache: compiler.root,
+				...this.options
+			}).apply(normalModuleFactory);
+		});
 	}
 }
-module.exports = LibManifestPlugin;
+
+module.exports = DelegatedPlugin;
 
 
 /***/ }),
 
-/***/ 14157:
+/***/ 71040:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -43139,131 +39515,467 @@ module.exports = LibManifestPlugin;
 
 
 
-const EnableLibraryPlugin = __webpack_require__(91452);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("../declarations/WebpackOptions").AuxiliaryComment} AuxiliaryComment */
-/** @typedef {import("../declarations/WebpackOptions").LibraryExport} LibraryExport */
-/** @typedef {import("../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../declarations/WebpackOptions").UmdNamedDefine} UmdNamedDefine */
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./util/Hash")} Hash */
+
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+
+class DependenciesBlock {
+	constructor() {
+		/** @type {Dependency[]} */
+		this.dependencies = [];
+		/** @type {AsyncDependenciesBlock[]} */
+		this.blocks = [];
+		/** @type {DependenciesBlock} */
+		this.parent = undefined;
+	}
+
+	getRootBlock() {
+		/** @type {DependenciesBlock} */
+		let current = this;
+		while (current.parent) current = current.parent;
+		return current;
+	}
 
-// TODO webpack 6 remove
-class LibraryTemplatePlugin {
 	/**
-	 * @param {LibraryName} name name of library
-	 * @param {LibraryType} target type of library
-	 * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module
-	 * @param {AuxiliaryComment} auxiliaryComment comment in the UMD wrapper
-	 * @param {LibraryExport} exportProperty which export should be exposed as library
+	 * Adds a DependencyBlock to DependencyBlock relationship.
+	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
+	 *
+	 * @param {AsyncDependenciesBlock} block block being added
+	 * @returns {void}
 	 */
-	constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) {
-		this.library = {
-			type: target || "var",
-			name,
-			umdNamedDefine,
-			auxiliaryComment,
-			export: exportProperty
-		};
+	addBlock(block) {
+		this.blocks.push(block);
+		block.parent = this;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Dependency} dependency dependency being tied to block.
+	 * This is an "edge" pointing to another "node" on module graph.
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const { output } = compiler.options;
-		output.library = this.library;
-		new EnableLibraryPlugin(this.library.type).apply(compiler);
+	addDependency(dependency) {
+		this.dependencies.push(dependency);
 	}
-}
-
-module.exports = LibraryTemplatePlugin;
-
 
-/***/ }),
+	/**
+	 * @param {Dependency} dependency dependency being removed
+	 * @returns {void}
+	 */
+	removeDependency(dependency) {
+		const idx = this.dependencies.indexOf(dependency);
+		if (idx >= 0) {
+			this.dependencies.splice(idx, 1);
+		}
+	}
 
-/***/ 22078:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * Removes all dependencies and blocks
+	 * @returns {void}
+	 */
+	clearDependenciesAndBlocks() {
+		this.dependencies.length = 0;
+		this.blocks.length = 0;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		for (const dep of this.dependencies) {
+			dep.updateHash(hash, context);
+		}
+		for (const block of this.blocks) {
+			block.updateHash(hash, context);
+		}
+	}
+
+	serialize({ write }) {
+		write(this.dependencies);
+		write(this.blocks);
+	}
+
+	deserialize({ read }) {
+		this.dependencies = read();
+		this.blocks = read();
+		for (const block of this.blocks) {
+			block.parent = this;
+		}
+	}
+}
+
+makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock");
+
+module.exports = DependenciesBlock;
+
+
+/***/ }),
+
+/***/ 54912:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
 */
 
 
 
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const NormalModule = __webpack_require__(39);
-const createSchemaValidation = __webpack_require__(32540);
+const memoize = __webpack_require__(78676);
 
-/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-const validate = createSchemaValidation(
-	__webpack_require__(24160),
-	() => __webpack_require__(15965),
-	{
-		name: "Loader Options Plugin",
-		baseDataPath: "options"
+/**
+ * @typedef {Object} UpdateHashContext
+ * @property {ChunkGraph} chunkGraph
+ * @property {RuntimeSpec} runtime
+ * @property {RuntimeTemplate=} runtimeTemplate
+ */
+
+/**
+ * @typedef {Object} SourcePosition
+ * @property {number} line
+ * @property {number=} column
+ */
+
+/**
+ * @typedef {Object} RealDependencyLocation
+ * @property {SourcePosition} start
+ * @property {SourcePosition=} end
+ * @property {number=} index
+ */
+
+/**
+ * @typedef {Object} SyntheticDependencyLocation
+ * @property {string} name
+ * @property {number=} index
+ */
+
+/** @typedef {SyntheticDependencyLocation|RealDependencyLocation} DependencyLocation */
+
+/**
+ * @typedef {Object} ExportSpec
+ * @property {string} name the name of the export
+ * @property {boolean=} canMangle can the export be renamed (defaults to true)
+ * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts
+ * @property {(string | ExportSpec)[]=} exports nested exports
+ * @property {ModuleGraphConnection=} from when reexported: from which module
+ * @property {string[] | null=} export when reexported: from which export
+ * @property {number=} priority when reexported: with which priority
+ * @property {boolean=} hidden export is not visible, because another export blends over it
+ */
+
+/**
+ * @typedef {Object} ExportsSpec
+ * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
+ * @property {Set<string>=} excludeExports when exports = true, list of unaffected exports
+ * @property {Set<string>=} hideExports list of maybe prior exposed, but now hidden exports
+ * @property {ModuleGraphConnection=} from when reexported: from which module
+ * @property {number=} priority when reexported: with which priority
+ * @property {boolean=} canMangle can the export be renamed (defaults to true)
+ * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts
+ * @property {Module[]=} dependencies module on which the result depends on
+ */
+
+/**
+ * @typedef {Object} ReferencedExport
+ * @property {string[]} name name of the referenced export
+ * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
+ */
+
+const TRANSITIVE = Symbol("transitive");
+
+const getIgnoredModule = memoize(() => {
+	const RawModule = __webpack_require__(84929);
+	return new RawModule("/* (ignored) */", `ignored`, `(ignored)`);
+});
+
+class Dependency {
+	constructor() {
+		/** @type {Module} */
+		this._parentModule = undefined;
+		/** @type {DependenciesBlock} */
+		this._parentDependenciesBlock = undefined;
+		/** @type {number} */
+		this._parentDependenciesBlockIndex = -1;
+		// TODO check if this can be moved into ModuleDependency
+		/** @type {boolean} */
+		this.weak = false;
+		// TODO check if this can be moved into ModuleDependency
+		/** @type {boolean} */
+		this.optional = false;
+		this._locSL = 0;
+		this._locSC = 0;
+		this._locEL = 0;
+		this._locEC = 0;
+		this._locI = undefined;
+		this._locN = undefined;
+		this._loc = undefined;
 	}
-);
-class LoaderOptionsPlugin {
+
 	/**
-	 * @param {LoaderOptionsPluginOptions} options options object
+	 * @returns {string} a display name for the type of dependency
 	 */
-	constructor(options = {}) {
-		validate(options);
-		if (typeof options !== "object") options = {};
-		if (!options.test) {
-			options.test = {
-				test: () => true
-			};
+	get type() {
+		return "unknown";
+	}
+
+	/**
+	 * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm"
+	 */
+	get category() {
+		return "unknown";
+	}
+
+	/**
+	 * @returns {DependencyLocation} location
+	 */
+	get loc() {
+		if (this._loc !== undefined) return this._loc;
+		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
+		const loc = {};
+		if (this._locSL > 0) {
+			loc.start = { line: this._locSL, column: this._locSC };
 		}
-		this.options = options;
+		if (this._locEL > 0) {
+			loc.end = { line: this._locEL, column: this._locEC };
+		}
+		if (this._locN !== undefined) {
+			loc.name = this._locN;
+		}
+		if (this._locI !== undefined) {
+			loc.index = this._locI;
+		}
+		return (this._loc = loc);
+	}
+
+	set loc(loc) {
+		if ("start" in loc && typeof loc.start === "object") {
+			this._locSL = loc.start.line || 0;
+			this._locSC = loc.start.column || 0;
+		} else {
+			this._locSL = 0;
+			this._locSC = 0;
+		}
+		if ("end" in loc && typeof loc.end === "object") {
+			this._locEL = loc.end.line || 0;
+			this._locEC = loc.end.column || 0;
+		} else {
+			this._locEL = 0;
+			this._locEC = 0;
+		}
+		if ("index" in loc) {
+			this._locI = loc.index;
+		} else {
+			this._locI = undefined;
+		}
+		if ("name" in loc) {
+			this._locN = loc.name;
+		} else {
+			this._locN = undefined;
+		}
+		this._loc = loc;
+	}
+
+	setLoc(startLine, startColumn, endLine, endColumn) {
+		this._locSL = startLine;
+		this._locSC = startColumn;
+		this._locEL = endLine;
+		this._locEC = endColumn;
+		this._locI = undefined;
+		this._locN = undefined;
+		this._loc = undefined;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return null;
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return TRANSITIVE;
+	}
+
+	/**
+	 * Returns the referenced module and export
+	 * @deprecated
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {never} throws error
+	 */
+	getReference(moduleGraph) {
+		throw new Error(
+			"Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule and ModuleGraph.getConnection().active"
+		);
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.EXPORTS_OBJECT_REFERENCED;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return null;
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return undefined;
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
+	 */
+	getWarnings(moduleGraph) {
+		return null;
+	}
+
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
+	 */
+	getErrors(moduleGraph) {
+		return null;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
-			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderOptionsPlugin",
-				(context, module) => {
-					const resource = module.resource;
-					if (!resource) return;
-					const i = resource.indexOf("?");
-					if (
-						ModuleFilenameHelpers.matchObject(
-							options,
-							i < 0 ? resource : resource.substr(0, i)
-						)
-					) {
-						for (const key of Object.keys(options)) {
-							if (key === "include" || key === "exclude" || key === "test") {
-								continue;
-							}
-							context[key] = options[key];
-						}
-					}
-				}
-			);
-		});
+	updateHash(hash, context) {}
+
+	/**
+	 * implement this method to allow the occurrence order plugin to count correctly
+	 * @returns {number} count how often the id is used in this dependency
+	 */
+	getNumberOfIdOccurrences() {
+		return 1;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return true;
+	}
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} a module
+	 */
+	createIgnoredModule(context) {
+		return getIgnoredModule();
+	}
+
+	serialize({ write }) {
+		write(this.weak);
+		write(this.optional);
+		write(this._locSL);
+		write(this._locSC);
+		write(this._locEL);
+		write(this._locEC);
+		write(this._locI);
+		write(this._locN);
+	}
+
+	deserialize({ read }) {
+		this.weak = read();
+		this.optional = read();
+		this._locSL = read();
+		this._locSC = read();
+		this._locEL = read();
+		this._locEC = read();
+		this._locI = read();
+		this._locN = read();
 	}
 }
 
-module.exports = LoaderOptionsPlugin;
+/** @type {string[][]} */
+Dependency.NO_EXPORTS_REFERENCED = [];
+/** @type {string[][]} */
+Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+
+Object.defineProperty(Dependency.prototype, "module", {
+	/**
+	 * @deprecated
+	 * @returns {never} throws
+	 */
+	get() {
+		throw new Error(
+			"module property was removed from Dependency (use compilation.moduleGraph.getModule(dependency) instead)"
+		);
+	},
+
+	/**
+	 * @deprecated
+	 * @returns {never} throws
+	 */
+	set() {
+		throw new Error(
+			"module property was removed from Dependency (use compilation.moduleGraph.updateModule(dependency, module) instead)"
+		);
+	}
+});
+
+Object.defineProperty(Dependency.prototype, "disconnect", {
+	get() {
+		throw new Error(
+			"disconnect was removed from Dependency (Dependency no longer carries graph specific information)"
+		);
+	}
+});
+
+Dependency.TRANSITIVE = TRANSITIVE;
+
+module.exports = Dependency;
 
 
 /***/ }),
 
-/***/ 86738:
+/***/ 5160:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -43274,41 +39986,61 @@ module.exports = LoaderOptionsPlugin;
 
 
 
-const NormalModule = __webpack_require__(39);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @template T @typedef {import("./InitFragment")<T>} InitFragment */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 
-/** @typedef {import("./Compiler")} Compiler */
+/**
+ * @typedef {Object} DependencyTemplateContext
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {Set<string>} runtimeRequirements the requirements for runtime
+ * @property {Module} module current module
+ * @property {RuntimeSpec} runtime current runtimes, for which code is generated
+ * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
+ * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults} codeGenerationResults the code generation results
+ */
 
-class LoaderTargetPlugin {
-	/**
-	 * @param {string} target the target
-	 */
-	constructor(target) {
-		this.target = target;
-	}
+/**
+ * @typedef {Object} CssDependencyTemplateContextExtras
+ * @property {Map<string, string>} cssExports the css exports
+ */
+
+/** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */
 
+class DependencyTemplate {
+	/* istanbul ignore next */
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @abstract
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("LoaderTargetPlugin", compilation => {
-			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderTargetPlugin",
-				loaderContext => {
-					loaderContext.target = this.target;
-				}
-			);
-		});
+	apply(dependency, source, templateContext) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 }
 
-module.exports = LoaderTargetPlugin;
+module.exports = DependencyTemplate;
 
 
 /***/ }),
 
-/***/ 12856:
+/***/ 9163:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -43319,333 +40051,134 @@ module.exports = LoaderTargetPlugin;
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(6967);
-const util = __webpack_require__(73837);
-const RuntimeGlobals = __webpack_require__(16475);
-const memoize = __webpack_require__(78676);
+const createHash = __webpack_require__(49835);
 
-/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Module")} Module} */
-/** @typedef {import("./util/Hash")} Hash} */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
-/** @typedef {import("./ModuleGraph")} ModuleGraph} */
-/** @typedef {import("./ChunkGraph")} ChunkGraph} */
-/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions} */
-/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry} */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {typeof import("./util/Hash")} Hash */
 
-const getJavascriptModulesPlugin = memoize(() =>
-	__webpack_require__(89464)
-);
-const getJsonpTemplatePlugin = memoize(() =>
-	__webpack_require__(4607)
-);
-const getLoadScriptRuntimeModule = memoize(() =>
-	__webpack_require__(19942)
-);
+/** @typedef {new (...args: any[]) => Dependency} DependencyConstructor */
 
-// TODO webpack 6 remove this class
-class MainTemplate {
+class DependencyTemplates {
 	/**
-	 *
-	 * @param {OutputOptions} outputOptions output options for the MainTemplate
-	 * @param {Compilation} compilation the compilation
+	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(outputOptions, compilation) {
-		/** @type {OutputOptions} */
-		this._outputOptions = outputOptions || {};
-		this.hooks = Object.freeze({
-			renderManifest: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.renderManifest.tap(
-							options,
-							(entries, options) => {
-								if (!options.chunk.hasRuntime()) return entries;
-								return fn(entries, options);
-							}
-						);
-					},
-					"MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST"
-				)
-			},
-			modules: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)"
-					);
-				}
-			},
-			moduleObj: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)"
-					);
-				}
-			},
-			require: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderRequire.tap(options, fn);
-					},
-					"MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE"
-				)
-			},
-			beforeStartup: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)"
-					);
-				}
-			},
-			startup: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)"
-					);
-				}
-			},
-			afterStartup: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)"
-					);
-				}
-			},
-			render: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
-								if (
-									renderContext.chunkGraph.getNumberOfEntryModules(
-										renderContext.chunk
-									) === 0 ||
-									!renderContext.chunk.hasRuntime()
-								) {
-									return source;
-								}
-								return fn(
-									source,
-									renderContext.chunk,
-									compilation.hash,
-									compilation.moduleTemplates.javascript,
-									compilation.dependencyTemplates
-								);
-							});
-					},
-					"MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER"
-				)
-			},
-			renderWithEntry: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
-								if (
-									renderContext.chunkGraph.getNumberOfEntryModules(
-										renderContext.chunk
-									) === 0 ||
-									!renderContext.chunk.hasRuntime()
-								) {
-									return source;
-								}
-								return fn(source, renderContext.chunk, compilation.hash);
-							});
-					},
-					"MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY"
-				)
-			},
-			assetPath: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.assetPath.tap(options, fn);
-					},
-					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
-				),
-				call: util.deprecate(
-					(filename, options) => {
-						return compilation.getAssetPath(filename, options);
-					},
-					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
-				)
-			},
-			hash: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.fullHash.tap(options, fn);
-					},
-					"MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH"
-				)
-			},
-			hashForChunk: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.chunkHash.tap(options, (chunk, hash) => {
-								if (!chunk.hasRuntime()) return;
-								return fn(hash, chunk);
-							});
-					},
-					"MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			},
-			globalHashPaths: {
-				tap: util.deprecate(
-					() => {},
-					"MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			},
-			globalHash: {
-				tap: util.deprecate(
-					() => {},
-					"MainTemplate.hooks.globalHash has been removed (it's no longer needed)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			},
-			hotBootstrap: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)"
-					);
-				}
-			},
+	constructor(hashFunction = "md4") {
+		/** @type {Map<Function, DependencyTemplate>} */
+		this._map = new Map();
+		/** @type {string} */
+		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
+		this._hashFunction = hashFunction;
+	}
 
-			// for compatibility:
-			/** @type {SyncWaterfallHook<[string, Chunk, string, ModuleTemplate, DependencyTemplates]>} */
-			bootstrap: new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash",
-				"moduleTemplate",
-				"dependencyTemplates"
-			]),
-			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
-			localVars: new SyncWaterfallHook(["source", "chunk", "hash"]),
-			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
-			requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]),
-			/** @type {SyncWaterfallHook<[string, Chunk, string, string]>} */
-			requireEnsure: new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash",
-				"chunkIdExpression"
-			]),
-			get jsonpScript() {
-				const hooks =
-					getLoadScriptRuntimeModule().getCompilationHooks(compilation);
-				return hooks.createScript;
-			},
-			get linkPrefetch() {
-				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
-				return hooks.linkPrefetch;
-			},
-			get linkPreload() {
-				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
-				return hooks.linkPreload;
-			}
-		});
+	/**
+	 * @param {DependencyConstructor} dependency Constructor of Dependency
+	 * @returns {DependencyTemplate} template for this dependency
+	 */
+	get(dependency) {
+		return this._map.get(dependency);
+	}
 
-		this.renderCurrentHashCode = util.deprecate(
-			/**
-			 * @deprecated
-			 * @param {string} hash the hash
-			 * @param {number=} length length of the hash
-			 * @returns {string} generated code
-			 */ (hash, length) => {
-				if (length) {
-					return `${RuntimeGlobals.getFullHash} ? ${
-						RuntimeGlobals.getFullHash
-					}().slice(0, ${length}) : ${hash.slice(0, length)}`;
-				}
-				return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`;
-			},
-			"MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE"
-		);
+	/**
+	 * @param {DependencyConstructor} dependency Constructor of Dependency
+	 * @param {DependencyTemplate} dependencyTemplate template for this dependency
+	 * @returns {void}
+	 */
+	set(dependency, dependencyTemplate) {
+		this._map.set(dependency, dependencyTemplate);
+	}
 
-		this.getPublicPath = util.deprecate(
-			/**
-			 *
-			 * @param {object} options get public path options
-			 * @returns {string} hook call
-			 */ options => {
-				return compilation.getAssetPath(
-					compilation.outputOptions.publicPath,
-					options
-				);
-			},
-			"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
-		);
+	/**
+	 * @param {string} part additional hash contributor
+	 * @returns {void}
+	 */
+	updateHash(part) {
+		const hash = createHash(this._hashFunction);
+		hash.update(`${this._hash}${part}`);
+		this._hash = /** @type {string} */ (hash.digest("hex"));
+	}
 
-		this.getAssetPath = util.deprecate(
-			(path, options) => {
-				return compilation.getAssetPath(path, options);
-			},
-			"MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH"
-		);
+	getHash() {
+		return this._hash;
+	}
 
-		this.getAssetPathWithInfo = util.deprecate(
-			(path, options) => {
-				return compilation.getAssetPathWithInfo(path, options);
-			},
-			"MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO"
-		);
+	clone() {
+		const newInstance = new DependencyTemplates(this._hashFunction);
+		newInstance._map = new Map(this._map);
+		newInstance._hash = this._hash;
+		return newInstance;
 	}
 }
 
-Object.defineProperty(MainTemplate.prototype, "requireFn", {
-	get: util.deprecate(
-		() => "__webpack_require__",
-		'MainTemplate.requireFn is deprecated (use "__webpack_require__")',
-		"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN"
-	)
-});
+module.exports = DependencyTemplates;
 
-Object.defineProperty(MainTemplate.prototype, "outputOptions", {
-	get: util.deprecate(
-		/**
-		 * @this {MainTemplate}
-		 * @returns {OutputOptions} output options
-		 */
-		function () {
-			return this._outputOptions;
-		},
-		"MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
-		"DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS"
-	)
-});
 
-module.exports = MainTemplate;
+/***/ }),
+
+/***/ 62790:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const DllModuleFactory = __webpack_require__(68703);
+const DllEntryDependency = __webpack_require__(95666);
+const EntryDependency = __webpack_require__(3979);
+
+class DllEntryPlugin {
+	constructor(context, entries, options) {
+		this.context = context;
+		this.entries = entries;
+		this.options = options;
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DllEntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const dllModuleFactory = new DllModuleFactory();
+				compilation.dependencyFactories.set(
+					DllEntryDependency,
+					dllModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					EntryDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
+			compilation.addEntry(
+				this.context,
+				new DllEntryDependency(
+					this.entries.map((e, idx) => {
+						const dep = new EntryDependency(e);
+						dep.loc = {
+							name: this.options.name,
+							index: idx
+						};
+						return dep;
+					}),
+					this.options.name
+				),
+				this.options,
+				callback
+			);
+		});
+	}
+}
+
+module.exports = DllEntryPlugin;
 
 
 /***/ }),
 
-/***/ 73208:
+/***/ 28280:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -43656,1181 +40189,895 @@ module.exports = MainTemplate;
 
 
 
-const util = __webpack_require__(73837);
-const ChunkGraph = __webpack_require__(64971);
-const DependenciesBlock = __webpack_require__(71040);
-const ModuleGraph = __webpack_require__(99988);
+const { RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
 const RuntimeGlobals = __webpack_require__(16475);
-const { first } = __webpack_require__(93347);
-const { compareChunksById } = __webpack_require__(29579);
 const makeSerializable = __webpack_require__(33032);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./ExportsInfo").UsageStateType} UsageStateType */
-/** @typedef {import("./FileSystemInfo")} FileSystemInfo */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").SourceContext} SourceContext */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
-/** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @typedef {Object} SourceContext
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {RuntimeSpec} runtime the runtimes code should be generated for
- * @property {string=} type the type of source that should be generated
- */
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([
+	RuntimeGlobals.require,
+	RuntimeGlobals.module
+]);
 
-/**
- * @typedef {Object} CodeGenerationContext
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {RuntimeSpec} runtime the runtimes code should be generated for
- * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
- */
+class DllModule extends Module {
+	constructor(context, dependencies, name) {
+		super("javascript/dynamic", context);
 
-/**
- * @typedef {Object} ConcatenationBailoutReasonContext
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- */
+		// Info from Factory
+		this.dependencies = dependencies;
+		this.name = name;
+	}
 
-/**
- * @typedef {Object} CodeGenerationResult
- * @property {Map<string, Source>} sources the resulting sources for all source types
- * @property {Map<string, any>=} data the resulting data for all source types
- * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
- * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
- */
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
 
-/**
- * @typedef {Object} LibIdentOptions
- * @property {string} context absolute context path to which lib ident is relative to
- * @property {Object=} associatedObjectForCache object for caching
- */
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `dll ${this.name}`;
+	}
 
-/**
- * @typedef {Object} KnownBuildMeta
- * @property {string=} moduleArgument
- * @property {string=} exportsArgument
- * @property {boolean=} strict
- * @property {string=} moduleConcatenationBailout
- * @property {("default" | "namespace" | "flagged" | "dynamic")=} exportsType
- * @property {(false | "redirect" | "redirect-warn")=} defaultObject
- * @property {boolean=} strictHarmonyModule
- * @property {boolean=} async
- * @property {boolean=} sideEffectFree
- */
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `dll ${this.name}`;
+	}
 
-/**
- * @typedef {Object} NeedBuildContext
- * @property {Compilation} compilation
- * @property {FileSystemInfo} fileSystemInfo
- * @property {Map<string, string | Set<string>>} valueCacheVersions
- */
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {};
+		return callback();
+	}
 
-/** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
-
-const EMPTY_RESOLVE_OPTIONS = {};
-
-let debugId = 1000;
-
-const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
-const DEFAULT_TYPES_JS = new Set(["javascript"]);
-
-const deprecatedNeedRebuild = util.deprecate(
-	(module, context) => {
-		return module.needRebuild(
-			context.fileSystemInfo.getDeprecatedFileTimestamps(),
-			context.fileSystemInfo.getDeprecatedContextTimestamps()
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		const sources = new Map();
+		sources.set(
+			"javascript",
+			new RawSource("module.exports = __webpack_require__;")
 		);
-	},
-	"Module.needRebuild is deprecated in favor of Module.needBuild",
-	"DEP_WEBPACK_MODULE_NEED_REBUILD"
-);
-
-/** @typedef {(requestShortener: RequestShortener) => string} OptimizationBailoutFunction */
+		return {
+			sources,
+			runtimeRequirements: RUNTIME_REQUIREMENTS
+		};
+	}
 
-class Module extends DependenciesBlock {
 	/**
-	 * @param {string} type the module type
-	 * @param {string=} context an optional context
-	 * @param {string=} layer an optional layer in which the module is
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
 	 */
-	constructor(type, context = null, layer = null) {
-		super();
-
-		/** @type {string} */
-		this.type = type;
-		/** @type {string | null} */
-		this.context = context;
-		/** @type {string | null} */
-		this.layer = layer;
-		/** @type {boolean} */
-		this.needId = true;
-
-		// Unique Id
-		/** @type {number} */
-		this.debugId = debugId++;
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
 
-		// Info from Factory
-		/** @type {ResolveOptions} */
-		this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
-		/** @type {object | undefined} */
-		this.factoryMeta = undefined;
-		// TODO refactor this -> options object filled from Factory
-		// TODO webpack 6: use an enum
-		/** @type {boolean} */
-		this.useSourceMap = false;
-		/** @type {boolean} */
-		this.useSimpleSourceMap = false;
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 12;
+	}
 
-		// Info from Build
-		/** @type {WebpackError[] | undefined} */
-		this._warnings = undefined;
-		/** @type {WebpackError[] | undefined} */
-		this._errors = undefined;
-		/** @type {BuildMeta} */
-		this.buildMeta = undefined;
-		/** @type {Record<string, any>} */
-		this.buildInfo = undefined;
-		/** @type {Dependency[] | undefined} */
-		this.presentationalDependencies = undefined;
-		/** @type {Dependency[] | undefined} */
-		this.codeGenerationDependencies = undefined;
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(`dll module${this.name || ""}`);
+		super.updateHash(hash, context);
 	}
 
-	// TODO remove in webpack 6
-	// BACKWARD-COMPAT START
-	get id() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.id",
-			"DEP_WEBPACK_MODULE_ID"
-		).getModuleId(this);
+	serialize(context) {
+		context.write(this.name);
+		super.serialize(context);
 	}
 
-	set id(value) {
-		if (value === "") {
-			this.needId = false;
-			return;
-		}
-		ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.id",
-			"DEP_WEBPACK_MODULE_ID"
-		).setModuleId(this, value);
+	deserialize(context) {
+		this.name = context.read();
+		super.deserialize(context);
 	}
 
 	/**
-	 * @returns {string} the hash of the module
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
 	 */
-	get hash() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.hash",
-			"DEP_WEBPACK_MODULE_HASH"
-		).getModuleHash(this, undefined);
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		this.dependencies = module.dependencies;
 	}
 
 	/**
-	 * @returns {string} the shortened hash of the module
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
 	 */
-	get renderedHash() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.renderedHash",
-			"DEP_WEBPACK_MODULE_RENDERED_HASH"
-		).getRenderedModuleHash(this, undefined);
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.dependencies = undefined;
 	}
+}
 
-	get profile() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.profile",
-			"DEP_WEBPACK_MODULE_PROFILE"
-		).getProfile(this);
-	}
+makeSerializable(DllModule, "webpack/lib/DllModule");
 
-	set profile(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.profile",
-			"DEP_WEBPACK_MODULE_PROFILE"
-		).setProfile(this, value);
-	}
+module.exports = DllModule;
 
-	get index() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index",
-			"DEP_WEBPACK_MODULE_INDEX"
-		).getPreOrderIndex(this);
-	}
 
-	set index(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index",
-			"DEP_WEBPACK_MODULE_INDEX"
-		).setPreOrderIndex(this, value);
-	}
+/***/ }),
 
-	get index2() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index2",
-			"DEP_WEBPACK_MODULE_INDEX2"
-		).getPostOrderIndex(this);
-	}
+/***/ 68703:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	set index2(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index2",
-			"DEP_WEBPACK_MODULE_INDEX2"
-		).setPostOrderIndex(this, value);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	get depth() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.depth",
-			"DEP_WEBPACK_MODULE_DEPTH"
-		).getDepth(this);
-	}
 
-	set depth(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.depth",
-			"DEP_WEBPACK_MODULE_DEPTH"
-		).setDepth(this, value);
-	}
 
-	get issuer() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.issuer",
-			"DEP_WEBPACK_MODULE_ISSUER"
-		).getIssuer(this);
-	}
+const DllModule = __webpack_require__(28280);
+const ModuleFactory = __webpack_require__(51010);
 
-	set issuer(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.issuer",
-			"DEP_WEBPACK_MODULE_ISSUER"
-		).setIssuer(this, value);
-	}
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./dependencies/DllEntryDependency")} DllEntryDependency */
 
-	get usedExports() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.usedExports",
-			"DEP_WEBPACK_MODULE_USED_EXPORTS"
-		).getUsedExports(this, undefined);
+class DllModuleFactory extends ModuleFactory {
+	constructor() {
+		super();
+		this.hooks = Object.freeze({});
 	}
-
 	/**
-	 * @deprecated
-	 * @returns {(string | OptimizationBailoutFunction)[]} list
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
 	 */
-	get optimizationBailout() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.optimizationBailout",
-			"DEP_WEBPACK_MODULE_OPTIMIZATION_BAILOUT"
-		).getOptimizationBailout(this);
-	}
-
-	get optional() {
-		return this.isOptional(
-			ModuleGraph.getModuleGraphForModule(
-				this,
-				"Module.optional",
-				"DEP_WEBPACK_MODULE_OPTIONAL"
+	create(data, callback) {
+		const dependency = /** @type {DllEntryDependency} */ (data.dependencies[0]);
+		callback(null, {
+			module: new DllModule(
+				data.context,
+				dependency.dependencies,
+				dependency.name
 			)
-		);
+		});
 	}
+}
 
-	addChunk(chunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.addChunk",
-			"DEP_WEBPACK_MODULE_ADD_CHUNK"
-		);
-		if (chunkGraph.isModuleInChunk(this, chunk)) return false;
-		chunkGraph.connectChunkAndModule(chunk, this);
-		return true;
-	}
+module.exports = DllModuleFactory;
 
-	removeChunk(chunk) {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.removeChunk",
-			"DEP_WEBPACK_MODULE_REMOVE_CHUNK"
-		).disconnectChunkAndModule(chunk, this);
-	}
 
-	isInChunk(chunk) {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.isInChunk",
-			"DEP_WEBPACK_MODULE_IS_IN_CHUNK"
-		).isModuleInChunk(this, chunk);
-	}
+/***/ }),
 
-	isEntryModule() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.isEntryModule",
-			"DEP_WEBPACK_MODULE_IS_ENTRY_MODULE"
-		).isEntryModule(this);
-	}
+/***/ 40038:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	getChunks() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.getChunks",
-			"DEP_WEBPACK_MODULE_GET_CHUNKS"
-		).getModuleChunks(this);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	getNumberOfChunks() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.getNumberOfChunks",
-			"DEP_WEBPACK_MODULE_GET_NUMBER_OF_CHUNKS"
-		).getNumberOfModuleChunks(this);
-	}
 
-	get chunksIterable() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.chunksIterable",
-			"DEP_WEBPACK_MODULE_CHUNKS_ITERABLE"
-		).getOrderedModuleChunksIterable(this, compareChunksById);
-	}
 
-	/**
-	 * @param {string} exportName a name of an export
-	 * @returns {boolean | null} true, if the export is provided why the module.
-	 * null, if it's unknown.
-	 * false, if it's not provided.
-	 */
-	isProvided(exportName) {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.usedExports",
-			"DEP_WEBPACK_MODULE_USED_EXPORTS"
-		).isExportProvided(this, exportName);
-	}
-	// BACKWARD-COMPAT END
+const DllEntryPlugin = __webpack_require__(62790);
+const FlagAllModulesAsUsedPlugin = __webpack_require__(58727);
+const LibManifestPlugin = __webpack_require__(93837);
+const createSchemaValidation = __webpack_require__(32540);
 
-	/**
-	 * @returns {string} name of the exports argument
-	 */
-	get exportsArgument() {
-		return (this.buildInfo && this.buildInfo.exportsArgument) || "exports";
+/** @typedef {import("../declarations/plugins/DllPlugin").DllPluginOptions} DllPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
+
+const validate = createSchemaValidation(
+	__webpack_require__(9667),
+	() => __webpack_require__(99926),
+	{
+		name: "Dll Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class DllPlugin {
 	/**
-	 * @returns {string} name of the module argument
+	 * @param {DllPluginOptions} options options object
 	 */
-	get moduleArgument() {
-		return (this.buildInfo && this.buildInfo.moduleArgument) || "module";
+	constructor(options) {
+		validate(options);
+		this.options = {
+			...options,
+			entryOnly: options.entryOnly !== false
+		};
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {boolean} strict the importing module is strict
-	 * @returns {"namespace" | "default-only" | "default-with-named" | "dynamic"} export type
-	 * "namespace": Exports is already a namespace object. namespace = exports.
-	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
-	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
-	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getExportsType(moduleGraph, strict) {
-		switch (this.buildMeta && this.buildMeta.exportsType) {
-			case "flagged":
-				return strict ? "default-with-named" : "namespace";
-			case "namespace":
-				return "namespace";
-			case "default":
-				switch (this.buildMeta.defaultObject) {
-					case "redirect":
-						return "default-with-named";
-					case "redirect-warn":
-						return strict ? "default-only" : "default-with-named";
-					default:
-						return "default-only";
+	apply(compiler) {
+		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
+			if (typeof entry !== "function") {
+				for (const name of Object.keys(entry)) {
+					const options = {
+						name,
+						filename: entry.filename
+					};
+					new DllEntryPlugin(context, entry[name].import, options).apply(
+						compiler
+					);
 				}
-			case "dynamic": {
-				if (strict) return "default-with-named";
-				// Try to figure out value of __esModule by following reexports
-				const handleDefault = () => {
-					switch (this.buildMeta.defaultObject) {
-						case "redirect":
-						case "redirect-warn":
-							return "default-with-named";
-						default:
-							return "default-only";
-					}
-				};
-				const exportInfo = moduleGraph.getReadOnlyExportInfo(
-					this,
-					"__esModule"
+			} else {
+				throw new Error(
+					"DllPlugin doesn't support dynamic entry (function) yet"
 				);
-				if (exportInfo.provided === false) {
-					return handleDefault();
-				}
-				const target = exportInfo.getTarget(moduleGraph);
-				if (
-					!target ||
-					!target.export ||
-					target.export.length !== 1 ||
-					target.export[0] !== "__esModule"
-				) {
-					return "dynamic";
-				}
-				switch (
-					target.module.buildMeta &&
-					target.module.buildMeta.exportsType
-				) {
-					case "flagged":
-					case "namespace":
-						return "namespace";
-					case "default":
-						return handleDefault();
-					default:
-						return "dynamic";
-				}
 			}
-			default:
-				return strict ? "default-with-named" : "dynamic";
+			return true;
+		});
+		new LibManifestPlugin(this.options).apply(compiler);
+		if (!this.options.entryOnly) {
+			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
 		}
 	}
+}
 
-	/**
-	 * @param {Dependency} presentationalDependency dependency being tied to module.
-	 * This is a Dependency without edge in the module graph. It's only for presentation.
-	 * @returns {void}
-	 */
-	addPresentationalDependency(presentationalDependency) {
-		if (this.presentationalDependencies === undefined) {
-			this.presentationalDependencies = [];
-		}
-		this.presentationalDependencies.push(presentationalDependency);
-	}
+module.exports = DllPlugin;
 
-	/**
-	 * @param {Dependency} codeGenerationDependency dependency being tied to module.
-	 * This is a Dependency where the code generation result of the referenced module is needed during code generation.
-	 * The Dependency should also be added to normal dependencies via addDependency.
-	 * @returns {void}
-	 */
-	addCodeGenerationDependency(codeGenerationDependency) {
-		if (this.codeGenerationDependencies === undefined) {
-			this.codeGenerationDependencies = [];
-		}
-		this.codeGenerationDependencies.push(codeGenerationDependency);
-	}
 
-	/**
-	 * Removes all dependencies and blocks
-	 * @returns {void}
-	 */
-	clearDependenciesAndBlocks() {
-		if (this.presentationalDependencies !== undefined) {
-			this.presentationalDependencies.length = 0;
-		}
-		if (this.codeGenerationDependencies !== undefined) {
-			this.codeGenerationDependencies.length = 0;
-		}
-		super.clearDependenciesAndBlocks();
-	}
+/***/ }),
 
-	/**
-	 * @param {WebpackError} warning the warning
-	 * @returns {void}
-	 */
-	addWarning(warning) {
-		if (this._warnings === undefined) {
-			this._warnings = [];
-		}
-		this._warnings.push(warning);
-	}
+/***/ 90999:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @returns {Iterable<WebpackError> | undefined} list of warnings if any
-	 */
-	getWarnings() {
-		return this._warnings;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @returns {number} number of warnings
-	 */
-	getNumberOfWarnings() {
-		return this._warnings !== undefined ? this._warnings.length : 0;
-	}
 
-	/**
-	 * @param {WebpackError} error the error
-	 * @returns {void}
-	 */
-	addError(error) {
-		if (this._errors === undefined) {
-			this._errors = [];
-		}
-		this._errors.push(error);
-	}
 
-	/**
-	 * @returns {Iterable<WebpackError> | undefined} list of errors if any
-	 */
-	getErrors() {
-		return this._errors;
-	}
+const parseJson = __webpack_require__(15235);
+const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
+const ExternalModuleFactoryPlugin = __webpack_require__(62153);
+const WebpackError = __webpack_require__(53799);
+const DelegatedSourceDependency = __webpack_require__(22914);
+const createSchemaValidation = __webpack_require__(32540);
+const makePathsRelative = (__webpack_require__(82186).makePathsRelative);
 
-	/**
-	 * @returns {number} number of errors
-	 */
-	getNumberOfErrors() {
-		return this._errors !== undefined ? this._errors.length : 0;
-	}
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
 
-	/**
-	 * removes all warnings and errors
-	 * @returns {void}
-	 */
-	clearWarningsAndErrors() {
-		if (this._warnings !== undefined) {
-			this._warnings.length = 0;
-		}
-		if (this._errors !== undefined) {
-			this._errors.length = 0;
-		}
+const validate = createSchemaValidation(
+	__webpack_require__(28534),
+	() => __webpack_require__(46552),
+	{
+		name: "Dll Reference Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class DllReferencePlugin {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {boolean} true, if the module is optional
+	 * @param {DllReferencePluginOptions} options options object
 	 */
-	isOptional(moduleGraph) {
-		let hasConnections = false;
-		for (const r of moduleGraph.getIncomingConnections(this)) {
-			if (
-				!r.dependency ||
-				!r.dependency.optional ||
-				!r.isTargetActive(undefined)
-			) {
-				return false;
-			}
-			hasConnections = true;
-		}
-		return hasConnections;
+	constructor(options) {
+		validate(options);
+		this.options = options;
+		/** @type {WeakMap<Object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
+		this._compilationData = new WeakMap();
 	}
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {Chunk} chunk a chunk
-	 * @param {Chunk=} ignoreChunk chunk to be ignored
-	 * @returns {boolean} true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
-	 */
-	isAccessibleInChunk(chunkGraph, chunk, ignoreChunk) {
-		// Check if module is accessible in ALL chunk groups
-		for (const chunkGroup of chunk.groupsIterable) {
-			if (!this.isAccessibleInChunkGroup(chunkGraph, chunkGroup)) return false;
-		}
-		return true;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DllReferencePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					DelegatedSourceDependency,
+					normalModuleFactory
+				);
+			}
+		);
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkGroup} chunkGroup a chunk group
-	 * @param {Chunk=} ignoreChunk chunk to be ignored
-	 * @returns {boolean} true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"
-	 */
-	isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk) {
-		const queue = new Set([chunkGroup]);
+		compiler.hooks.beforeCompile.tapAsync(
+			"DllReferencePlugin",
+			(params, callback) => {
+				if ("manifest" in this.options) {
+					const manifest = this.options.manifest;
+					if (typeof manifest === "string") {
+						compiler.inputFileSystem.readFile(manifest, (err, result) => {
+							if (err) return callback(err);
+							const data = {
+								path: manifest,
+								data: undefined,
+								error: undefined
+							};
+							// Catch errors parsing the manifest so that blank
+							// or malformed manifest files don't kill the process.
+							try {
+								data.data = parseJson(result.toString("utf-8"));
+							} catch (e) {
+								// Store the error in the params so that it can
+								// be added as a compilation error later on.
+								const manifestPath = makePathsRelative(
+									compiler.options.context,
+									manifest,
+									compiler.root
+								);
+								data.error = new DllManifestError(manifestPath, e.message);
+							}
+							this._compilationData.set(params, data);
+							return callback();
+						});
+						return;
+					}
+				}
+				return callback();
+			}
+		);
 
-		// Check if module is accessible from all items of the queue
-		queueFor: for (const cg of queue) {
-			// 1. If module is in one of the chunks of the group we can continue checking the next items
-			//    because it's accessible.
-			for (const chunk of cg.chunks) {
-				if (chunk !== ignoreChunk && chunkGraph.isModuleInChunk(this, chunk))
-					continue queueFor;
+		compiler.hooks.compile.tap("DllReferencePlugin", params => {
+			let name = this.options.name;
+			let sourceType = this.options.sourceType;
+			let content =
+				"content" in this.options ? this.options.content : undefined;
+			if ("manifest" in this.options) {
+				let manifestParameter = this.options.manifest;
+				let manifest;
+				if (typeof manifestParameter === "string") {
+					const data = this._compilationData.get(params);
+					// If there was an error parsing the manifest
+					// file, exit now because the error will be added
+					// as a compilation error in the "compilation" hook.
+					if (data.error) {
+						return;
+					}
+					manifest = data.data;
+				} else {
+					manifest = manifestParameter;
+				}
+				if (manifest) {
+					if (!name) name = manifest.name;
+					if (!sourceType) sourceType = manifest.type;
+					if (!content) content = manifest.content;
+				}
 			}
-			// 2. If the chunk group is initial, we can break here because it's not accessible.
-			if (chunkGroup.isInitial()) return false;
-			// 3. Enqueue all parents because it must be accessible from ALL parents
-			for (const parent of chunkGroup.parentsIterable) queue.add(parent);
-		}
-		// When we processed through the whole list and we didn't bailout, the module is accessible
-		return true;
-	}
+			/** @type {Externals} */
+			const externals = {};
+			const source = "dll-reference " + name;
+			externals[source] = name;
+			const normalModuleFactory = params.normalModuleFactory;
+			new ExternalModuleFactoryPlugin(sourceType || "var", externals).apply(
+				normalModuleFactory
+			);
+			new DelegatedModuleFactoryPlugin({
+				source: source,
+				type: this.options.type,
+				scope: this.options.scope,
+				context: this.options.context || compiler.options.context,
+				content,
+				extensions: this.options.extensions,
+				associatedObjectForCache: compiler.root
+			}).apply(normalModuleFactory);
+		});
 
-	/**
-	 * @param {Chunk} chunk a chunk
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {boolean} true, if the module has any reason why "chunk" should be included
-	 */
-	hasReasonForChunk(chunk, moduleGraph, chunkGraph) {
-		// check for each reason if we need the chunk
-		for (const [
-			fromModule,
-			connections
-		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
-			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
-			for (const originChunk of chunkGraph.getModuleChunksIterable(
-				fromModule
-			)) {
-				// return true if module this is not reachable from originChunk when ignoring chunk
-				if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk))
-					return true;
+		compiler.hooks.compilation.tap(
+			"DllReferencePlugin",
+			(compilation, params) => {
+				if ("manifest" in this.options) {
+					let manifest = this.options.manifest;
+					if (typeof manifest === "string") {
+						const data = this._compilationData.get(params);
+						// If there was an error parsing the manifest file, add the
+						// error as a compilation error to make the compilation fail.
+						if (data.error) {
+							compilation.errors.push(data.error);
+						}
+						compilation.fileDependencies.add(manifest);
+					}
+				}
 			}
-		}
-		return false;
+		);
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true if at least one other module depends on this module
-	 */
-	hasReasons(moduleGraph, runtime) {
-		for (const c of moduleGraph.getIncomingConnections(this)) {
-			if (c.isTargetActive(runtime)) return true;
-		}
-		return false;
+class DllManifestError extends WebpackError {
+	constructor(filename, message) {
+		super();
+
+		this.name = "DllManifestError";
+		this.message = `Dll manifest ${filename}\n${message}`;
 	}
+}
+
+module.exports = DllReferencePlugin;
+
+
+/***/ }),
+
+/***/ 96475:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Naoyuki Kanezawa @nkzawa
+*/
+
+
+
+const EntryOptionPlugin = __webpack_require__(9909);
+const EntryPlugin = __webpack_require__(96953);
+const EntryDependency = __webpack_require__(3979);
+
+/** @typedef {import("../declarations/WebpackOptions").EntryDynamicNormalized} EntryDynamic */
+/** @typedef {import("../declarations/WebpackOptions").EntryItem} EntryItem */
+/** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStatic */
+/** @typedef {import("./Compiler")} Compiler */
 
+class DynamicEntryPlugin {
 	/**
-	 * @returns {string} for debugging
+	 * @param {string} context the context path
+	 * @param {EntryDynamic} entry the entry value
 	 */
-	toString() {
-		return `Module[${this.debugId}: ${this.identifier()}]`;
+	constructor(context, entry) {
+		this.context = context;
+		this.entry = entry;
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	needBuild(context, callback) {
-		callback(
-			null,
-			!this.buildMeta ||
-				this.needRebuild === Module.prototype.needRebuild ||
-				deprecatedNeedRebuild(this, context)
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DynamicEntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					EntryDependency,
+					normalModuleFactory
+				);
+			}
+		);
+
+		compiler.hooks.make.tapPromise(
+			"DynamicEntryPlugin",
+			(compilation, callback) =>
+				Promise.resolve(this.entry())
+					.then(entry => {
+						const promises = [];
+						for (const name of Object.keys(entry)) {
+							const desc = entry[name];
+							const options = EntryOptionPlugin.entryDescriptionToOptions(
+								compiler,
+								name,
+								desc
+							);
+							for (const entry of desc.import) {
+								promises.push(
+									new Promise((resolve, reject) => {
+										compilation.addEntry(
+											this.context,
+											EntryPlugin.createDependency(entry, options),
+											options,
+											err => {
+												if (err) return reject(err);
+												resolve();
+											}
+										);
+									})
+								);
+							}
+						}
+						return Promise.all(promises);
+					})
+					.then(x => {})
 		);
 	}
+}
+
+module.exports = DynamicEntryPlugin;
+
+
+/***/ }),
+
+/***/ 9909:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
+class EntryOptionPlugin {
 	/**
-	 * @deprecated Use needBuild instead
-	 * @param {Map<string, number|null>} fileTimestamps timestamps of files
-	 * @param {Map<string, number|null>} contextTimestamps timestamps of directories
-	 * @returns {boolean} true, if the module needs a rebuild
+	 * @param {Compiler} compiler the compiler instance one is tapping into
+	 * @returns {void}
 	 */
-	needRebuild(fileTimestamps, contextTimestamps) {
-		return true;
+	apply(compiler) {
+		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
+			EntryOptionPlugin.applyEntryOption(compiler, context, entry);
+			return true;
+		});
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * @param {Compiler} compiler the compiler
+	 * @param {string} context context directory
+	 * @param {Entry} entry request
 	 * @returns {void}
 	 */
-	updateHash(
-		hash,
-		context = {
-			chunkGraph: ChunkGraph.getChunkGraphForModule(
-				this,
-				"Module.updateHash",
-				"DEP_WEBPACK_MODULE_UPDATE_HASH"
-			),
-			runtime: undefined
-		}
-	) {
-		const { chunkGraph, runtime } = context;
-		hash.update(chunkGraph.getModuleGraphHash(this, runtime));
-		if (this.presentationalDependencies !== undefined) {
-			for (const dep of this.presentationalDependencies) {
-				dep.updateHash(hash, context);
+	static applyEntryOption(compiler, context, entry) {
+		if (typeof entry === "function") {
+			const DynamicEntryPlugin = __webpack_require__(96475);
+			new DynamicEntryPlugin(context, entry).apply(compiler);
+		} else {
+			const EntryPlugin = __webpack_require__(96953);
+			for (const name of Object.keys(entry)) {
+				const desc = entry[name];
+				const options = EntryOptionPlugin.entryDescriptionToOptions(
+					compiler,
+					name,
+					desc
+				);
+				for (const entry of desc.import) {
+					new EntryPlugin(context, entry, options).apply(compiler);
+				}
 			}
 		}
-		super.updateHash(hash, context);
 	}
 
 	/**
-	 * @returns {void}
+	 * @param {Compiler} compiler the compiler
+	 * @param {string} name entry name
+	 * @param {EntryDescription} desc entry description
+	 * @returns {EntryOptions} options for the entry
 	 */
-	invalidateBuild() {
-		// should be overridden to support this feature
+	static entryDescriptionToOptions(compiler, name, desc) {
+		/** @type {EntryOptions} */
+		const options = {
+			name,
+			filename: desc.filename,
+			runtime: desc.runtime,
+			layer: desc.layer,
+			dependOn: desc.dependOn,
+			publicPath: desc.publicPath,
+			chunkLoading: desc.chunkLoading,
+			asyncChunks: desc.asyncChunks,
+			wasmLoading: desc.wasmLoading,
+			library: desc.library
+		};
+		if (desc.layer !== undefined && !compiler.options.experiments.layers) {
+			throw new Error(
+				"'entryOptions.layer' is only allowed when 'experiments.layers' is enabled"
+			);
+		}
+		if (desc.chunkLoading) {
+			const EnableChunkLoadingPlugin = __webpack_require__(61291);
+			EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading);
+		}
+		if (desc.wasmLoading) {
+			const EnableWasmLoadingPlugin = __webpack_require__(78613);
+			EnableWasmLoadingPlugin.checkEnabled(compiler, desc.wasmLoading);
+		}
+		if (desc.library) {
+			const EnableLibraryPlugin = __webpack_require__(91452);
+			EnableLibraryPlugin.checkEnabled(compiler, desc.library.type);
+		}
+		return options;
 	}
+}
 
-	/* istanbul ignore next */
+module.exports = EntryOptionPlugin;
+
+
+/***/ }),
+
+/***/ 96953:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const EntryDependency = __webpack_require__(3979);
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+
+class EntryPlugin {
 	/**
-	 * @abstract
-	 * @returns {string} a unique identifier of the module
+	 * An entry plugin which will handle
+	 * creation of the EntryDependency
+	 *
+	 * @param {string} context context path
+	 * @param {string} entry entry path
+	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
 	 */
-	identifier() {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	constructor(context, entry, options) {
+		this.context = context;
+		this.entry = entry;
+		this.options = options || "";
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
-
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"EntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					EntryDependency,
+					normalModuleFactory
+				);
+			}
+		);
 
-	/**
-	 * @abstract
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		// Better override this method to return the correct types
-		if (this.source === Module.prototype.source) {
-			return DEFAULT_TYPES_UNKNOWN;
-		} else {
-			return DEFAULT_TYPES_JS;
-		}
-	}
+		const { entry, options, context } = this;
+		const dep = EntryPlugin.createDependency(entry, options);
 
-	/**
-	 * @abstract
-	 * @deprecated Use codeGeneration() instead
-	 * @param {DependencyTemplates} dependencyTemplates the dependency templates
-	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {string=} type the type of source that should be generated
-	 * @returns {Source} generated source
-	 */
-	source(dependencyTemplates, runtimeTemplate, type = "javascript") {
-		if (this.codeGeneration === Module.prototype.codeGeneration) {
-			const AbstractMethodError = __webpack_require__(77198);
-			throw new AbstractMethodError();
-		}
-		const chunkGraph = ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.source() is deprecated. Use Compilation.codeGenerationResults.getSource(module, runtime, type) instead",
-			"DEP_WEBPACK_MODULE_SOURCE"
-		);
-		/** @type {CodeGenerationContext} */
-		const codeGenContext = {
-			dependencyTemplates,
-			runtimeTemplate,
-			moduleGraph: chunkGraph.moduleGraph,
-			chunkGraph,
-			runtime: undefined,
-			codeGenerationResults: undefined
-		};
-		const sources = this.codeGeneration(codeGenContext).sources;
-		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
+		compiler.hooks.make.tapAsync("EntryPlugin", (compilation, callback) => {
+			compilation.addEntry(context, dep, options, err => {
+				callback(err);
+			});
+		});
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {string} entry entry request
+	 * @param {EntryOptions | string} options entry options (passing string is deprecated)
+	 * @returns {EntryDependency} the dependency
 	 */
-	size(type) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	static createDependency(entry, options) {
+		const dep = new EntryDependency(entry);
+		// TODO webpack 6 remove string option
+		dep.loc = { name: typeof options === "object" ? options.name : options };
+		return dep;
 	}
+}
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return null;
-	}
+module.exports = EntryPlugin;
 
-	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
-	 */
-	nameForCondition() {
-		return null;
-	}
 
-	/**
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(context) {
-		return `Module Concatenation is not implemented for ${this.constructor.name}`;
-	}
+/***/ }),
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
-	 */
-	getSideEffectsConnectionState(moduleGraph) {
-		return true;
-	}
+/***/ 13795:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ChunkGroup = __webpack_require__(15626);
+
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("./Chunk")} Chunk */
 
+/** @typedef {{ name?: string } & Omit<EntryDescription, "import">} EntryOptions */
+
+/**
+ * Entrypoint serves as an encapsulation primitive for chunks that are
+ * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
+ * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
+ * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ */
+class Entrypoint extends ChunkGroup {
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * Creates an instance of Entrypoint.
+	 * @param {EntryOptions | string} entryOptions the options for the entrypoint (or name)
+	 * @param {boolean=} initial false, when the entrypoint is not initial loaded
 	 */
-	codeGeneration(context) {
-		// Best override this method
-		const sources = new Map();
-		for (const type of this.getSourceTypes()) {
-			if (type !== "unknown") {
-				sources.set(
-					type,
-					this.source(
-						context.dependencyTemplates,
-						context.runtimeTemplate,
-						type
-					)
-				);
-			}
+	constructor(entryOptions, initial = true) {
+		if (typeof entryOptions === "string") {
+			entryOptions = { name: entryOptions };
 		}
-		return {
-			sources,
-			runtimeRequirements: new Set([
-				RuntimeGlobals.module,
-				RuntimeGlobals.exports,
-				RuntimeGlobals.require
-			])
-		};
+		super({
+			name: entryOptions.name
+		});
+		this.options = entryOptions;
+		/** @type {Chunk=} */
+		this._runtimeChunk = undefined;
+		/** @type {Chunk=} */
+		this._entrypointChunk = undefined;
+		/** @type {boolean} */
+		this._initial = initial;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk which condition should be checked
-	 * @param {Compilation} compilation the compilation
-	 * @returns {boolean} true, if the chunk is ok for the module
+	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
 	 */
-	chunkCondition(chunk, compilation) {
-		return true;
-	}
-
-	hasChunkCondition() {
-		return this.chunkCondition !== Module.prototype.chunkCondition;
+	isInitial() {
+		return this._initial;
 	}
 
 	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
+	 * Sets the runtimeChunk for an entrypoint.
+	 * @param {Chunk} chunk the chunk being set as the runtime chunk.
 	 * @returns {void}
 	 */
-	updateCacheModule(module) {
-		this.type = module.type;
-		this.layer = module.layer;
-		this.context = module.context;
-		this.factoryMeta = module.factoryMeta;
-		this.resolveOptions = module.resolveOptions;
-	}
-
-	/**
-	 * Module should be unsafe cached. Get data that's needed for that.
-	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
-	 */
-	getUnsafeCacheData() {
-		return {
-			factoryMeta: this.factoryMeta,
-			resolveOptions: this.resolveOptions
-		};
+	setRuntimeChunk(chunk) {
+		this._runtimeChunk = chunk;
 	}
 
 	/**
-	 * restore unsafe cache data
-	 * @param {object} unsafeCacheData data from getUnsafeCacheData
-	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 * Fetches the chunk reference containing the webpack bootstrap code
+	 * @returns {Chunk | null} returns the runtime chunk or null if there is none
 	 */
-	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		this.factoryMeta = unsafeCacheData.factoryMeta;
-		this.resolveOptions = unsafeCacheData.resolveOptions;
+	getRuntimeChunk() {
+		if (this._runtimeChunk) return this._runtimeChunk;
+		for (const parent of this.parentsIterable) {
+			if (parent instanceof Entrypoint) return parent.getRuntimeChunk();
+		}
+		return null;
 	}
 
 	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 * Sets the chunk with the entrypoint modules for an entrypoint.
+	 * @param {Chunk} chunk the chunk being set as the entrypoint chunk.
+	 * @returns {void}
 	 */
-	cleanupForCache() {
-		this.factoryMeta = undefined;
-		this.resolveOptions = undefined;
+	setEntrypointChunk(chunk) {
+		this._entrypointChunk = chunk;
 	}
 
 	/**
-	 * @returns {Source | null} the original source for the module before webpack transformation
+	 * Returns the chunk which contains the entrypoint modules
+	 * (or at least the execution of them)
+	 * @returns {Chunk} chunk
 	 */
-	originalSource() {
-		return null;
+	getEntrypointChunk() {
+		return this._entrypointChunk;
 	}
 
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {Chunk} oldChunk chunk to be replaced
+	 * @param {Chunk} newChunk New chunk that will be replaced with
+	 * @returns {boolean} returns true if the replacement was successful
 	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.type);
-		write(this.layer);
-		write(this.context);
-		write(this.resolveOptions);
-		write(this.factoryMeta);
-		write(this.useSourceMap);
-		write(this.useSimpleSourceMap);
-		write(
-			this._warnings !== undefined && this._warnings.length === 0
-				? undefined
-				: this._warnings
-		);
-		write(
-			this._errors !== undefined && this._errors.length === 0
-				? undefined
-				: this._errors
-		);
-		write(this.buildMeta);
-		write(this.buildInfo);
-		write(this.presentationalDependencies);
-		write(this.codeGenerationDependencies);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.type = read();
-		this.layer = read();
-		this.context = read();
-		this.resolveOptions = read();
-		this.factoryMeta = read();
-		this.useSourceMap = read();
-		this.useSimpleSourceMap = read();
-		this._warnings = read();
-		this._errors = read();
-		this.buildMeta = read();
-		this.buildInfo = read();
-		this.presentationalDependencies = read();
-		this.codeGenerationDependencies = read();
-		super.deserialize(context);
+	replaceChunk(oldChunk, newChunk) {
+		if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk;
+		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
+		return super.replaceChunk(oldChunk, newChunk);
 	}
 }
 
-makeSerializable(Module, "webpack/lib/Module");
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "hasEqualsChunks", {
-	get() {
-		throw new Error(
-			"Module.hasEqualsChunks was renamed (use hasEqualChunks instead)"
-		);
-	}
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "isUsed", {
-	get() {
-		throw new Error(
-			"Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)"
-		);
-	}
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "errors", {
-	get: util.deprecate(
-		/**
-		 * @this {Module}
-		 * @returns {WebpackError[]} array
-		 */
-		function () {
-			if (this._errors === undefined) {
-				this._errors = [];
-			}
-			return this._errors;
-		},
-		"Module.errors was removed (use getErrors instead)",
-		"DEP_WEBPACK_MODULE_ERRORS"
-	)
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "warnings", {
-	get: util.deprecate(
-		/**
-		 * @this {Module}
-		 * @returns {WebpackError[]} array
-		 */
-		function () {
-			if (this._warnings === undefined) {
-				this._warnings = [];
-			}
-			return this._warnings;
-		},
-		"Module.warnings was removed (use getWarnings instead)",
-		"DEP_WEBPACK_MODULE_WARNINGS"
-	)
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "used", {
-	get() {
-		throw new Error(
-			"Module.used was refactored (use ModuleGraph.getUsedExports instead)"
-		);
-	},
-	set(value) {
-		throw new Error(
-			"Module.used was refactored (use ModuleGraph.setUsedExports instead)"
-		);
-	}
-});
-
-module.exports = Module;
+module.exports = Entrypoint;
 
 
 /***/ }),
 
-/***/ 21305:
+/***/ 22070:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Authors Simen Brekken @simenbrekken, Einar Löve @einarlove
 */
 
 
 
-const { cutOffLoaderExecution } = __webpack_require__(59985);
+const DefinePlugin = __webpack_require__(79065);
 const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-class ModuleBuildError extends WebpackError {
-	/**
-	 * @param {string | Error&any} err error thrown
-	 * @param {{from?: string|null}} info additional info
-	 */
-	constructor(err, { from = null } = {}) {
-		let message = "Module build failed";
-		let details = undefined;
-
-		if (from) {
-			message += ` (from ${from}):\n`;
-		} else {
-			message += ": ";
-		}
-
-		if (err !== null && typeof err === "object") {
-			if (typeof err.stack === "string" && err.stack) {
-				const stack = cutOffLoaderExecution(err.stack);
 
-				if (!err.hideStack) {
-					message += stack;
-				} else {
-					details = stack;
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./DefinePlugin").CodeValue} CodeValue */
 
-					if (typeof err.message === "string" && err.message) {
-						message += err.message;
-					} else {
-						message += err;
-					}
-				}
-			} else if (typeof err.message === "string" && err.message) {
-				message += err.message;
-			} else {
-				message += String(err);
-			}
+class EnvironmentPlugin {
+	constructor(...keys) {
+		if (keys.length === 1 && Array.isArray(keys[0])) {
+			this.keys = keys[0];
+			this.defaultValues = {};
+		} else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
+			this.keys = Object.keys(keys[0]);
+			this.defaultValues = keys[0];
 		} else {
-			message += String(err);
+			this.keys = keys;
+			this.defaultValues = {};
 		}
-
-		super(message);
-
-		this.name = "ModuleBuildError";
-		this.details = details;
-		this.error = err;
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Record<string, CodeValue>} */
+		const definitions = {};
+		for (const key of this.keys) {
+			const value =
+				process.env[key] !== undefined
+					? process.env[key]
+					: this.defaultValues[key];
 
-		super.serialize(context);
-	}
+			if (value === undefined) {
+				compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
+					const error = new WebpackError(
+						`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
+							"You can pass an object with default values to suppress this warning.\n" +
+							"See https://webpack.js.org/plugins/environment-plugin for example."
+					);
 
-	deserialize(context) {
-		const { read } = context;
+					error.name = "EnvVariableNotDefinedError";
+					compilation.errors.push(error);
+				});
+			}
 
-		this.error = read();
+			definitions[`process.env.${key}`] =
+				value === undefined ? "undefined" : JSON.stringify(value);
+		}
 
-		super.deserialize(context);
+		new DefinePlugin(definitions).apply(compiler);
 	}
 }
 
-makeSerializable(ModuleBuildError, "webpack/lib/ModuleBuildError");
-
-module.exports = ModuleBuildError;
+module.exports = EnvironmentPlugin;
 
 
 /***/ }),
 
-/***/ 67409:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 59985:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -44840,97 +41087,65 @@ module.exports = ModuleBuildError;
 
 
 
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+const loaderFlag = "LOADER_EXECUTION";
 
-class ModuleDependencyError extends WebpackError {
-	/**
-	 * Creates an instance of ModuleDependencyError.
-	 * @param {Module} module module tied to dependency
-	 * @param {Error} err error thrown
-	 * @param {DependencyLocation} loc location of dependency
-	 */
-	constructor(module, err, loc) {
-		super(err.message);
+const webpackOptionsFlag = "WEBPACK_OPTIONS";
 
-		this.name = "ModuleDependencyError";
-		this.details =
-			err && !(/** @type {any} */ (err).hideStack)
-				? err.stack.split("\n").slice(1).join("\n")
-				: undefined;
-		this.module = module;
-		this.loc = loc;
-		/** error is not (de)serialized, so it might be undefined after deserialization */
-		this.error = err;
-
-		if (err && /** @type {any} */ (err).hideStack) {
-			this.stack =
-				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
+exports.cutOffByFlag = (stack, flag) => {
+	stack = stack.split("\n");
+	for (let i = 0; i < stack.length; i++) {
+		if (stack[i].includes(flag)) {
+			stack.length = i;
 		}
 	}
-}
-
-module.exports = ModuleDependencyError;
-
-
-/***/ }),
-
-/***/ 29656:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	return stack.join("\n");
+};
 
+exports.cutOffLoaderExecution = stack =>
+	exports.cutOffByFlag(stack, loaderFlag);
 
+exports.cutOffWebpackOptions = stack =>
+	exports.cutOffByFlag(stack, webpackOptionsFlag);
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+exports.cutOffMultilineMessage = (stack, message) => {
+	stack = stack.split("\n");
+	message = message.split("\n");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+	const result = [];
 
-class ModuleDependencyWarning extends WebpackError {
-	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {Error} err error thrown
-	 * @param {DependencyLocation} loc location of dependency
-	 */
-	constructor(module, err, loc) {
-		super(err ? err.message : "");
+	stack.forEach((line, idx) => {
+		if (!line.includes(message[idx])) result.push(line);
+	});
 
-		this.name = "ModuleDependencyWarning";
-		this.details =
-			err && !(/** @type {any} */ (err).hideStack)
-				? err.stack.split("\n").slice(1).join("\n")
-				: undefined;
-		this.module = module;
-		this.loc = loc;
-		/** error is not (de)serialized, so it might be undefined after deserialization */
-		this.error = err;
+	return result.join("\n");
+};
 
-		if (err && /** @type {any} */ (err).hideStack) {
-			this.stack =
-				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
-		}
+exports.cutOffMessage = (stack, message) => {
+	const nextLine = stack.indexOf("\n");
+	if (nextLine === -1) {
+		return stack === message ? "" : stack;
+	} else {
+		const firstLine = stack.substr(0, nextLine);
+		return firstLine === message ? stack.substr(nextLine + 1) : stack;
 	}
-}
+};
 
-makeSerializable(
-	ModuleDependencyWarning,
-	"webpack/lib/ModuleDependencyWarning"
-);
+exports.cleanUp = (stack, message) => {
+	stack = exports.cutOffLoaderExecution(stack);
+	stack = exports.cutOffMessage(stack, message);
+	return stack;
+};
 
-module.exports = ModuleDependencyWarning;
+exports.cleanUpWebpackOptions = (stack, message) => {
+	stack = exports.cutOffWebpackOptions(stack);
+	stack = exports.cutOffMultilineMessage(stack, message);
+	return stack;
+};
 
 
 /***/ }),
 
-/***/ 23744:
+/***/ 65218:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -44941,65 +41156,121 @@ module.exports = ModuleDependencyWarning;
 
 
 
-const { cleanUp } = __webpack_require__(59985);
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-class ModuleError extends WebpackError {
-	/**
-	 * @param {Error} err error thrown
-	 * @param {{from?: string|null}} info additional info
-	 */
-	constructor(err, { from = null } = {}) {
-		let message = "Module Error";
-
-		if (from) {
-			message += ` (from ${from}):\n`;
-		} else {
-			message += ": ";
-		}
-
-		if (err && typeof err === "object" && err.message) {
-			message += err.message;
-		} else if (err) {
-			message += err;
-		}
-
-		super(message);
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const ExternalModule = __webpack_require__(73071);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const RuntimeGlobals = __webpack_require__(16475);
+const JavascriptModulesPlugin = __webpack_require__(89464);
 
-		this.name = "ModuleError";
-		this.error = err;
-		this.details =
-			err && typeof err === "object" && err.stack
-				? cleanUp(err.stack, this.message)
-				: undefined;
-	}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Compiler")} Compiler */
 
-	serialize(context) {
-		const { write } = context;
+/** @type {WeakMap<Source, Source>} */
+const cache = new WeakMap();
 
-		write(this.error);
+const devtoolWarning = new RawSource(`/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+`);
 
-		super.serialize(context);
+class EvalDevToolModulePlugin {
+	constructor(options) {
+		this.namespace = options.namespace || "";
+		this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]";
+		this.moduleFilenameTemplate =
+			options.moduleFilenameTemplate ||
+			"webpack://[namespace]/[resourcePath]?[loaders]";
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
-
-		super.deserialize(context);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("EvalDevToolModulePlugin", compilation => {
+			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+			hooks.renderModuleContent.tap(
+				"EvalDevToolModulePlugin",
+				(source, module, { runtimeTemplate, chunkGraph }) => {
+					const cacheEntry = cache.get(source);
+					if (cacheEntry !== undefined) return cacheEntry;
+					if (module instanceof ExternalModule) {
+						cache.set(source, source);
+						return source;
+					}
+					const content = source.source();
+					const str = ModuleFilenameHelpers.createFilename(
+						module,
+						{
+							moduleFilenameTemplate: this.moduleFilenameTemplate,
+							namespace: this.namespace
+						},
+						{
+							requestShortener: runtimeTemplate.requestShortener,
+							chunkGraph,
+							hashFunction: compilation.outputOptions.hashFunction
+						}
+					);
+					const footer =
+						"\n" +
+						this.sourceUrlComment.replace(
+							/\[url\]/g,
+							encodeURI(str)
+								.replace(/%2F/g, "/")
+								.replace(/%20/g, "_")
+								.replace(/%5E/g, "^")
+								.replace(/%5C/g, "\\")
+								.replace(/^\//, "")
+						);
+					const result = new RawSource(
+						`eval(${
+							compilation.outputOptions.trustedTypes
+								? `${RuntimeGlobals.createScript}(${JSON.stringify(
+										content + footer
+								  )})`
+								: JSON.stringify(content + footer)
+						});`
+					);
+					cache.set(source, result);
+					return result;
+				}
+			);
+			hooks.inlineInRuntimeBailout.tap(
+				"EvalDevToolModulePlugin",
+				() => "the eval devtool is used."
+			);
+			hooks.render.tap(
+				"EvalDevToolModulePlugin",
+				source => new ConcatSource(devtoolWarning, source)
+			);
+			hooks.chunkHash.tap("EvalDevToolModulePlugin", (chunk, hash) => {
+				hash.update("EvalDevToolModulePlugin");
+				hash.update("2");
+			});
+			if (compilation.outputOptions.trustedTypes) {
+				compilation.hooks.additionalModuleRuntimeRequirements.tap(
+					"EvalDevToolModulePlugin",
+					(module, set, context) => {
+						set.add(RuntimeGlobals.createScript);
+					}
+				);
+			}
+		});
 	}
 }
 
-makeSerializable(ModuleError, "webpack/lib/ModuleError");
-
-module.exports = ModuleError;
+module.exports = EvalDevToolModulePlugin;
 
 
 /***/ }),
 
-/***/ 51010:
+/***/ 14790:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -45010,55 +41281,211 @@ module.exports = ModuleError;
 
 
 
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const NormalModule = __webpack_require__(39);
+const RuntimeGlobals = __webpack_require__(16475);
+const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const ConcatenatedModule = __webpack_require__(97198);
+const { makePathsAbsolute } = __webpack_require__(82186);
 
-/**
- * @typedef {Object} ModuleFactoryResult
- * @property {Module=} module the created module or unset if no module was created
- * @property {Set<string>=} fileDependencies
- * @property {Set<string>=} contextDependencies
- * @property {Set<string>=} missingDependencies
- * @property {boolean=} cacheable allow to use the unsafe cache
- */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").DevTool} DevToolOptions */
+/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
 
-/**
- * @typedef {Object} ModuleFactoryCreateDataContextInfo
- * @property {string} issuer
- * @property {string | null=} issuerLayer
- * @property {string} compiler
- */
+/** @type {WeakMap<Source, Source>} */
+const cache = new WeakMap();
 
-/**
- * @typedef {Object} ModuleFactoryCreateData
- * @property {ModuleFactoryCreateDataContextInfo} contextInfo
- * @property {ResolveOptions=} resolveOptions
- * @property {string} context
- * @property {Dependency[]} dependencies
+const devtoolWarning = new RawSource(`/*
+ * ATTENTION: An "eval-source-map" devtool has been used.
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
  */
+`);
 
-class ModuleFactory {
-	/* istanbul ignore next */
+class EvalSourceMapDevToolPlugin {
 	/**
-	 * @abstract
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {SourceMapDevToolPluginOptions|string} inputOptions Options object
+	 */
+	constructor(inputOptions) {
+		/** @type {SourceMapDevToolPluginOptions} */
+		let options;
+		if (typeof inputOptions === "string") {
+			options = {
+				append: inputOptions
+			};
+		} else {
+			options = inputOptions;
+		}
+		this.sourceMapComment =
+			options.append || "//# sourceURL=[module]\n//# sourceMappingURL=[url]";
+		this.moduleFilenameTemplate =
+			options.moduleFilenameTemplate ||
+			"webpack://[namespace]/[resource-path]?[hash]";
+		this.namespace = options.namespace || "";
+		this.options = options;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	create(data, callback) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap(
+			"EvalSourceMapDevToolPlugin",
+			compilation => {
+				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+				new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
+				const matchModule = ModuleFilenameHelpers.matchObject.bind(
+					ModuleFilenameHelpers,
+					options
+				);
+				hooks.renderModuleContent.tap(
+					"EvalSourceMapDevToolPlugin",
+					(source, m, { runtimeTemplate, chunkGraph }) => {
+						const cachedSource = cache.get(source);
+						if (cachedSource !== undefined) {
+							return cachedSource;
+						}
+
+						const result = r => {
+							cache.set(source, r);
+							return r;
+						};
+
+						if (m instanceof NormalModule) {
+							const module = /** @type {NormalModule} */ (m);
+							if (!matchModule(module.resource)) {
+								return result(source);
+							}
+						} else if (m instanceof ConcatenatedModule) {
+							const concatModule = /** @type {ConcatenatedModule} */ (m);
+							if (concatModule.rootModule instanceof NormalModule) {
+								const module = /** @type {NormalModule} */ (
+									concatModule.rootModule
+								);
+								if (!matchModule(module.resource)) {
+									return result(source);
+								}
+							} else {
+								return result(source);
+							}
+						} else {
+							return result(source);
+						}
+
+						/** @type {{ [key: string]: TODO; }} */
+						let sourceMap;
+						let content;
+						if (source.sourceAndMap) {
+							const sourceAndMap = source.sourceAndMap(options);
+							sourceMap = sourceAndMap.map;
+							content = sourceAndMap.source;
+						} else {
+							sourceMap = source.map(options);
+							content = source.source();
+						}
+						if (!sourceMap) {
+							return result(source);
+						}
+
+						// Clone (flat) the sourcemap to ensure that the mutations below do not persist.
+						sourceMap = { ...sourceMap };
+						const context = compiler.options.context;
+						const root = compiler.root;
+						const modules = sourceMap.sources.map(source => {
+							if (!source.startsWith("webpack://")) return source;
+							source = makePathsAbsolute(context, source.slice(10), root);
+							const module = compilation.findModule(source);
+							return module || source;
+						});
+						let moduleFilenames = modules.map(module => {
+							return ModuleFilenameHelpers.createFilename(
+								module,
+								{
+									moduleFilenameTemplate: this.moduleFilenameTemplate,
+									namespace: this.namespace
+								},
+								{
+									requestShortener: runtimeTemplate.requestShortener,
+									chunkGraph,
+									hashFunction: compilation.outputOptions.hashFunction
+								}
+							);
+						});
+						moduleFilenames = ModuleFilenameHelpers.replaceDuplicates(
+							moduleFilenames,
+							(filename, i, n) => {
+								for (let j = 0; j < n; j++) filename += "*";
+								return filename;
+							}
+						);
+						sourceMap.sources = moduleFilenames;
+						sourceMap.sourceRoot = options.sourceRoot || "";
+						const moduleId = chunkGraph.getModuleId(m);
+						sourceMap.file = `${moduleId}.js`;
+
+						const footer =
+							this.sourceMapComment.replace(
+								/\[url\]/g,
+								`data:application/json;charset=utf-8;base64,${Buffer.from(
+									JSON.stringify(sourceMap),
+									"utf8"
+								).toString("base64")}`
+							) + `\n//# sourceURL=webpack-internal:///${moduleId}\n`; // workaround for chrome bug
+
+						return result(
+							new RawSource(
+								`eval(${
+									compilation.outputOptions.trustedTypes
+										? `${RuntimeGlobals.createScript}(${JSON.stringify(
+												content + footer
+										  )})`
+										: JSON.stringify(content + footer)
+								});`
+							)
+						);
+					}
+				);
+				hooks.inlineInRuntimeBailout.tap(
+					"EvalDevToolModulePlugin",
+					() => "the eval-source-map devtool is used."
+				);
+				hooks.render.tap(
+					"EvalSourceMapDevToolPlugin",
+					source => new ConcatSource(devtoolWarning, source)
+				);
+				hooks.chunkHash.tap("EvalSourceMapDevToolPlugin", (chunk, hash) => {
+					hash.update("EvalSourceMapDevToolPlugin");
+					hash.update("2");
+				});
+				if (compilation.outputOptions.trustedTypes) {
+					compilation.hooks.additionalModuleRuntimeRequirements.tap(
+						"EvalSourceMapDevToolPlugin",
+						(module, set, context) => {
+							set.add(RuntimeGlobals.createScript);
+						}
+					);
+				}
+			}
+		);
 	}
 }
 
-module.exports = ModuleFactory;
+module.exports = EvalSourceMapDevToolPlugin;
 
 
 /***/ }),
 
-/***/ 88821:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 63686:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -45068,1344 +41495,1606 @@ module.exports = ModuleFactory;
 
 
 
-const NormalModule = __webpack_require__(39);
-const createHash = __webpack_require__(49835);
-const memoize = __webpack_require__(78676);
+const { equals } = __webpack_require__(84953);
+const SortableSet = __webpack_require__(13098);
+const makeSerializable = __webpack_require__(33032);
+const { forEachRuntime } = __webpack_require__(17156);
 
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./Module")} Module */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("./util/Hash")} Hash */
 
-const ModuleFilenameHelpers = exports;
+/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
+/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
 
-// TODO webpack 6: consider removing these
-ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
-ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE =
-	/\[all-?loaders\]\[resource\]/gi;
-ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
-ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
-ModuleFilenameHelpers.RESOURCE = "[resource]";
-ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
-ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
-// cSpell:words olute
-ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH =
-	/\[abs(olute)?-?resource-?path\]/gi;
-ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
-ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
-ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
-ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
-ModuleFilenameHelpers.LOADERS = "[loaders]";
-ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
-ModuleFilenameHelpers.QUERY = "[query]";
-ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
-ModuleFilenameHelpers.ID = "[id]";
-ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
-ModuleFilenameHelpers.HASH = "[hash]";
-ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
-ModuleFilenameHelpers.NAMESPACE = "[namespace]";
-ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
-
-const getAfter = (strFn, token) => {
-	return () => {
-		const str = strFn();
-		const idx = str.indexOf(token);
-		return idx < 0 ? "" : str.substr(idx);
-	};
-};
+const UsageState = Object.freeze({
+	Unused: /** @type {0} */ (0),
+	OnlyPropertiesUsed: /** @type {1} */ (1),
+	NoInfo: /** @type {2} */ (2),
+	Unknown: /** @type {3} */ (3),
+	Used: /** @type {4} */ (4)
+});
 
-const getBefore = (strFn, token) => {
-	return () => {
-		const str = strFn();
-		const idx = str.lastIndexOf(token);
-		return idx < 0 ? "" : str.substr(0, idx);
-	};
-};
+const RETURNS_TRUE = () => true;
 
-const getHash = (strFn, hashFunction) => {
-	return () => {
-		const hash = createHash(hashFunction);
-		hash.update(strFn());
-		const digest = /** @type {string} */ (hash.digest("hex"));
-		return digest.substr(0, 4);
-	};
-};
+const CIRCULAR = Symbol("circular target");
 
-const asRegExp = test => {
-	if (typeof test === "string") {
-		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
+class RestoreProvidedData {
+	constructor(
+		exports,
+		otherProvided,
+		otherCanMangleProvide,
+		otherTerminalBinding
+	) {
+		this.exports = exports;
+		this.otherProvided = otherProvided;
+		this.otherCanMangleProvide = otherCanMangleProvide;
+		this.otherTerminalBinding = otherTerminalBinding;
 	}
-	return test;
-};
 
-const lazyObject = obj => {
-	const newObj = {};
-	for (const key of Object.keys(obj)) {
-		const fn = obj[key];
-		Object.defineProperty(newObj, key, {
-			get: () => fn(),
-			set: v => {
-				Object.defineProperty(newObj, key, {
-					value: v,
-					enumerable: true,
-					writable: true
-				});
-			},
-			enumerable: true,
-			configurable: true
-		});
+	serialize({ write }) {
+		write(this.exports);
+		write(this.otherProvided);
+		write(this.otherCanMangleProvide);
+		write(this.otherTerminalBinding);
 	}
-	return newObj;
-};
 
-const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+	static deserialize({ read }) {
+		return new RestoreProvidedData(read(), read(), read(), read());
+	}
+}
 
-/**
- *
- * @param {Module | string} module the module
- * @param {TODO} options options
- * @param {Object} contextInfo context info
- * @param {RequestShortener} contextInfo.requestShortener requestShortener
- * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
- * @param {string | Hash} contextInfo.hashFunction the hash function to use
- * @returns {string} the filename
- */
-ModuleFilenameHelpers.createFilename = (
-	module = "",
-	options,
-	{ requestShortener, chunkGraph, hashFunction = "md4" }
-) => {
-	const opts = {
-		namespace: "",
-		moduleFilenameTemplate: "",
-		...(typeof options === "object"
-			? options
-			: {
-					moduleFilenameTemplate: options
-			  })
-	};
+makeSerializable(
+	RestoreProvidedData,
+	"webpack/lib/ModuleGraph",
+	"RestoreProvidedData"
+);
 
-	let absoluteResourcePath;
-	let hash;
-	let identifier;
-	let moduleId;
-	let shortIdentifier;
-	if (typeof module === "string") {
-		shortIdentifier = memoize(() => requestShortener.shorten(module));
-		identifier = shortIdentifier;
-		moduleId = () => "";
-		absoluteResourcePath = () => module.split("!").pop();
-		hash = getHash(identifier, hashFunction);
-	} else {
-		shortIdentifier = memoize(() =>
-			module.readableIdentifier(requestShortener)
-		);
-		identifier = memoize(() => requestShortener.shorten(module.identifier()));
-		moduleId = () => chunkGraph.getModuleId(module);
-		absoluteResourcePath = () =>
-			module instanceof NormalModule
-				? module.resource
-				: module.identifier().split("!").pop();
-		hash = getHash(identifier, hashFunction);
+class ExportsInfo {
+	constructor() {
+		/** @type {Map<string, ExportInfo>} */
+		this._exports = new Map();
+		this._otherExportsInfo = new ExportInfo(null);
+		this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
+		this._exportsAreOrdered = false;
+		/** @type {ExportsInfo=} */
+		this._redirectTo = undefined;
 	}
-	const resource = memoize(() => shortIdentifier().split("!").pop());
 
-	const loaders = getBefore(shortIdentifier, "!");
-	const allLoaders = getBefore(identifier, "!");
-	const query = getAfter(resource, "?");
-	const resourcePath = () => {
-		const q = query().length;
-		return q === 0 ? resource() : resource().slice(0, -q);
-	};
-	if (typeof opts.moduleFilenameTemplate === "function") {
-		return opts.moduleFilenameTemplate(
-			lazyObject({
-				identifier: identifier,
-				shortIdentifier: shortIdentifier,
-				resource: resource,
-				resourcePath: memoize(resourcePath),
-				absoluteResourcePath: memoize(absoluteResourcePath),
-				allLoaders: memoize(allLoaders),
-				query: memoize(query),
-				moduleId: memoize(moduleId),
-				hash: memoize(hash),
-				namespace: () => opts.namespace
-			})
-		);
+	/**
+	 * @returns {Iterable<ExportInfo>} all owned exports in any order
+	 */
+	get ownedExports() {
+		return this._exports.values();
 	}
 
-	// TODO webpack 6: consider removing alternatives without dashes
-	/** @type {Map<string, function(): string>} */
-	const replacements = new Map([
-		["identifier", identifier],
-		["short-identifier", shortIdentifier],
-		["resource", resource],
-		["resource-path", resourcePath],
-		// cSpell:words resourcepath
-		["resourcepath", resourcePath],
-		["absolute-resource-path", absoluteResourcePath],
-		["abs-resource-path", absoluteResourcePath],
-		// cSpell:words absoluteresource
-		["absoluteresource-path", absoluteResourcePath],
-		// cSpell:words absresource
-		["absresource-path", absoluteResourcePath],
-		// cSpell:words resourcepath
-		["absolute-resourcepath", absoluteResourcePath],
-		// cSpell:words resourcepath
-		["abs-resourcepath", absoluteResourcePath],
-		// cSpell:words absoluteresourcepath
-		["absoluteresourcepath", absoluteResourcePath],
-		// cSpell:words absresourcepath
-		["absresourcepath", absoluteResourcePath],
-		["all-loaders", allLoaders],
-		// cSpell:words allloaders
-		["allloaders", allLoaders],
-		["loaders", loaders],
-		["query", query],
-		["id", moduleId],
-		["hash", hash],
-		["namespace", () => opts.namespace]
-	]);
-
-	// TODO webpack 6: consider removing weird double placeholders
-	return opts.moduleFilenameTemplate
-		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
-		.replace(
-			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
-			"[short-identifier]"
-		)
-		.replace(REGEXP, (match, content) => {
-			if (content.length + 2 === match.length) {
-				const replacement = replacements.get(content.toLowerCase());
-				if (replacement !== undefined) {
-					return replacement();
-				}
-			} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
-				return `[${match.slice(2, -2)}]`;
-			}
-			return match;
-		});
-};
-
-ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
-	const countMap = Object.create(null);
-	const posMap = Object.create(null);
-	array.forEach((item, idx) => {
-		countMap[item] = countMap[item] || [];
-		countMap[item].push(idx);
-		posMap[item] = 0;
-	});
-	if (comparator) {
-		Object.keys(countMap).forEach(item => {
-			countMap[item].sort(comparator);
-		});
-	}
-	return array.map((item, i) => {
-		if (countMap[item].length > 1) {
-			if (comparator && countMap[item][0] === i) return item;
-			return fn(item, i, posMap[item]++);
-		} else {
-			return item;
+	/**
+	 * @returns {Iterable<ExportInfo>} all owned exports in order
+	 */
+	get orderedOwnedExports() {
+		if (!this._exportsAreOrdered) {
+			this._sortExports();
 		}
-	});
-};
-
-ModuleFilenameHelpers.matchPart = (str, test) => {
-	if (!test) return true;
-	test = asRegExp(test);
-	if (Array.isArray(test)) {
-		return test.map(asRegExp).some(regExp => regExp.test(str));
-	} else {
-		return test.test(str);
+		return this._exports.values();
 	}
-};
 
-ModuleFilenameHelpers.matchObject = (obj, str) => {
-	if (obj.test) {
-		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
-			return false;
+	/**
+	 * @returns {Iterable<ExportInfo>} all exports in any order
+	 */
+	get exports() {
+		if (this._redirectTo !== undefined) {
+			const map = new Map(this._redirectTo._exports);
+			for (const [key, value] of this._exports) {
+				map.set(key, value);
+			}
+			return map.values();
 		}
+		return this._exports.values();
 	}
-	if (obj.include) {
-		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
-			return false;
+
+	/**
+	 * @returns {Iterable<ExportInfo>} all exports in order
+	 */
+	get orderedExports() {
+		if (!this._exportsAreOrdered) {
+			this._sortExports();
 		}
-	}
-	if (obj.exclude) {
-		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
-			return false;
+		if (this._redirectTo !== undefined) {
+			const map = new Map(
+				Array.from(this._redirectTo.orderedExports, item => [item.name, item])
+			);
+			for (const [key, value] of this._exports) {
+				map.set(key, value);
+			}
+			// sorting should be pretty fast as map contains
+			// a lot of presorted items
+			this._sortExportsMap(map);
+			return map.values();
 		}
+		return this._exports.values();
 	}
-	return true;
-};
-
-
-/***/ }),
-
-/***/ 99988:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const util = __webpack_require__(73837);
-const ExportsInfo = __webpack_require__(63686);
-const ModuleGraphConnection = __webpack_require__(40639);
-const SortableSet = __webpack_require__(13098);
-const WeakTupleMap = __webpack_require__(28745);
+	/**
+	 * @returns {ExportInfo} the export info of unlisted exports
+	 */
+	get otherExportsInfo() {
+		if (this._redirectTo !== undefined)
+			return this._redirectTo.otherExportsInfo;
+		return this._otherExportsInfo;
+	}
 
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleProfile")} ModuleProfile */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+	_sortExportsMap(exports) {
+		if (exports.size > 1) {
+			const namesInOrder = [];
+			for (const entry of exports.values()) {
+				namesInOrder.push(entry.name);
+			}
+			namesInOrder.sort();
+			let i = 0;
+			for (const entry of exports.values()) {
+				const name = namesInOrder[i];
+				if (entry.name !== name) break;
+				i++;
+			}
+			for (; i < namesInOrder.length; i++) {
+				const name = namesInOrder[i];
+				const correctEntry = exports.get(name);
+				exports.delete(name);
+				exports.set(name, correctEntry);
+			}
+		}
+	}
 
-/**
- * @callback OptimizationBailoutFunction
- * @param {RequestShortener} requestShortener
- * @returns {string}
- */
+	_sortExports() {
+		this._sortExportsMap(this._exports);
+		this._exportsAreOrdered = true;
+	}
 
-const EMPTY_SET = new Set();
+	setRedirectNamedTo(exportsInfo) {
+		if (this._redirectTo === exportsInfo) return false;
+		this._redirectTo = exportsInfo;
+		return true;
+	}
 
-/**
- * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
- */
-const getConnectionsByOriginModule = set => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[]} */
-	let lastList = undefined;
-	for (const connection of set) {
-		const { originModule } = connection;
-		if (lastModule === originModule) {
-			lastList.push(connection);
+	setHasProvideInfo() {
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.provided === undefined) {
+				exportInfo.provided = false;
+			}
+			if (exportInfo.canMangleProvide === undefined) {
+				exportInfo.canMangleProvide = true;
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			this._redirectTo.setHasProvideInfo();
 		} else {
-			lastModule = originModule;
-			const list = map.get(originModule);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(originModule, list);
+			if (this._otherExportsInfo.provided === undefined) {
+				this._otherExportsInfo.provided = false;
+			}
+			if (this._otherExportsInfo.canMangleProvide === undefined) {
+				this._otherExportsInfo.canMangleProvide = true;
 			}
 		}
 	}
-	return map;
-};
 
-/**
- * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
- */
-const getConnectionsByModule = set => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[]} */
-	let lastList = undefined;
-	for (const connection of set) {
-		const { module } = connection;
-		if (lastModule === module) {
-			lastList.push(connection);
+	setHasUseInfo() {
+		for (const exportInfo of this._exports.values()) {
+			exportInfo.setHasUseInfo();
+		}
+		this._sideEffectsOnlyInfo.setHasUseInfo();
+		if (this._redirectTo !== undefined) {
+			this._redirectTo.setHasUseInfo();
 		} else {
-			lastModule = module;
-			const list = map.get(module);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(module, list);
+			this._otherExportsInfo.setHasUseInfo();
+			if (this._otherExportsInfo.canMangleUse === undefined) {
+				this._otherExportsInfo.canMangleUse = true;
 			}
 		}
 	}
-	return map;
-};
-
-class ModuleGraphModule {
-	constructor() {
-		/** @type {SortableSet<ModuleGraphConnection>} */
-		this.incomingConnections = new SortableSet();
-		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
-		this.outgoingConnections = undefined;
-		/** @type {Module | null} */
-		this.issuer = undefined;
-		/** @type {(string | OptimizationBailoutFunction)[]} */
-		this.optimizationBailout = [];
-		/** @type {ExportsInfo} */
-		this.exports = new ExportsInfo();
-		/** @type {number} */
-		this.preOrderIndex = null;
-		/** @type {number} */
-		this.postOrderIndex = null;
-		/** @type {number} */
-		this.depth = null;
-		/** @type {ModuleProfile} */
-		this.profile = undefined;
-		/** @type {boolean} */
-		this.async = false;
-		/** @type {ModuleGraphConnection[]} */
-		this._unassignedConnections = undefined;
-	}
-}
-
-class ModuleGraph {
-	constructor() {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
-		this._dependencyMap = new WeakMap();
-		/** @type {Map<Module, ModuleGraphModule>} */
-		this._moduleMap = new Map();
-		/** @type {WeakMap<any, Object>} */
-		this._metaMap = new WeakMap();
-
-		/** @type {WeakTupleMap<any[], any>} */
-		this._cache = undefined;
-
-		/** @type {Map<Module, WeakTupleMap<any, any>>} */
-		this._moduleMemCaches = undefined;
-	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {ModuleGraphModule} the internal module
+	 * @param {string} name export name
+	 * @returns {ExportInfo} export info for this name
 	 */
-	_getModuleGraphModule(module) {
-		let mgm = this._moduleMap.get(module);
-		if (mgm === undefined) {
-			mgm = new ModuleGraphModule();
-			this._moduleMap.set(module, mgm);
-		}
-		return mgm;
+	getOwnExportInfo(name) {
+		const info = this._exports.get(name);
+		if (info !== undefined) return info;
+		const newInfo = new ExportInfo(name, this._otherExportsInfo);
+		this._exports.set(name, newInfo);
+		this._exportsAreOrdered = false;
+		return newInfo;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @param {DependenciesBlock} block parent block
-	 * @param {Module} module parent module
-	 * @param {number=} indexInBlock position in block
-	 * @returns {void}
+	 * @param {string} name export name
+	 * @returns {ExportInfo} export info for this name
 	 */
-	setParents(dependency, block, module, indexInBlock = -1) {
-		dependency._parentDependenciesBlockIndex = indexInBlock;
-		dependency._parentDependenciesBlock = block;
-		dependency._parentModule = module;
+	getExportInfo(name) {
+		const info = this._exports.get(name);
+		if (info !== undefined) return info;
+		if (this._redirectTo !== undefined)
+			return this._redirectTo.getExportInfo(name);
+		const newInfo = new ExportInfo(name, this._otherExportsInfo);
+		this._exports.set(name, newInfo);
+		this._exportsAreOrdered = false;
+		return newInfo;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {Module} parent module
+	 * @param {string} name export name
+	 * @returns {ExportInfo} export info for this name
 	 */
-	getParentModule(dependency) {
-		return dependency._parentModule;
+	getReadOnlyExportInfo(name) {
+		const info = this._exports.get(name);
+		if (info !== undefined) return info;
+		if (this._redirectTo !== undefined)
+			return this._redirectTo.getReadOnlyExportInfo(name);
+		return this._otherExportsInfo;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {DependenciesBlock} parent block
+	 * @param {string[]} name export name
+	 * @returns {ExportInfo | undefined} export info for this name
 	 */
-	getParentBlock(dependency) {
-		return dependency._parentDependenciesBlock;
+	getReadOnlyExportInfoRecursive(name) {
+		const exportInfo = this.getReadOnlyExportInfo(name[0]);
+		if (name.length === 1) return exportInfo;
+		if (!exportInfo.exportsInfo) return undefined;
+		return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {number} index
+	 * @param {string[]=} name the export name
+	 * @returns {ExportsInfo | undefined} the nested exports info
 	 */
-	getParentBlockIndex(dependency) {
-		return dependency._parentDependenciesBlockIndex;
+	getNestedExportsInfo(name) {
+		if (Array.isArray(name) && name.length > 0) {
+			const info = this.getReadOnlyExportInfo(name[0]);
+			if (!info.exportsInfo) return undefined;
+			return info.exportsInfo.getNestedExportsInfo(name.slice(1));
+		}
+		return this;
 	}
 
 	/**
-	 * @param {Module} originModule the referencing module
-	 * @param {Dependency} dependency the referencing dependency
-	 * @param {Module} module the referenced module
-	 * @returns {void}
+	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
+	 * @param {Set<string>=} excludeExports list of unaffected exports
+	 * @param {any=} targetKey use this as key for the target
+	 * @param {ModuleGraphConnection=} targetModule set this module as target
+	 * @param {number=} priority priority
+	 * @returns {boolean} true, if this call changed something
 	 */
-	setResolvedModule(originModule, dependency, module) {
-		const connection = new ModuleGraphConnection(
-			originModule,
-			dependency,
-			module,
-			undefined,
-			dependency.weak,
-			dependency.getCondition(this)
-		);
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		connections.add(connection);
-		if (originModule) {
-			const mgm = this._getModuleGraphModule(originModule);
-			if (mgm._unassignedConnections === undefined) {
-				mgm._unassignedConnections = [];
+	setUnknownExportsProvided(
+		canMangle,
+		excludeExports,
+		targetKey,
+		targetModule,
+		priority
+	) {
+		let changed = false;
+		if (excludeExports) {
+			for (const name of excludeExports) {
+				// Make sure these entries exist, so they can get different info
+				this.getExportInfo(name);
 			}
-			mgm._unassignedConnections.push(connection);
-			if (mgm.outgoingConnections === undefined) {
-				mgm.outgoingConnections = new SortableSet();
+		}
+		for (const exportInfo of this._exports.values()) {
+			if (excludeExports && excludeExports.has(exportInfo.name)) continue;
+			if (exportInfo.provided !== true && exportInfo.provided !== null) {
+				exportInfo.provided = null;
+				changed = true;
+			}
+			if (!canMangle && exportInfo.canMangleProvide !== false) {
+				exportInfo.canMangleProvide = false;
+				changed = true;
+			}
+			if (targetKey) {
+				exportInfo.setTarget(targetKey, targetModule, [exportInfo.name], -1);
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			if (
+				this._redirectTo.setUnknownExportsProvided(
+					canMangle,
+					excludeExports,
+					targetKey,
+					targetModule,
+					priority
+				)
+			) {
+				changed = true;
 			}
-			mgm.outgoingConnections.add(connection);
 		} else {
-			this._dependencyMap.set(dependency, connection);
+			if (
+				this._otherExportsInfo.provided !== true &&
+				this._otherExportsInfo.provided !== null
+			) {
+				this._otherExportsInfo.provided = null;
+				changed = true;
+			}
+			if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) {
+				this._otherExportsInfo.canMangleProvide = false;
+				changed = true;
+			}
+			if (targetKey) {
+				this._otherExportsInfo.setTarget(
+					targetKey,
+					targetModule,
+					undefined,
+					priority
+				);
+			}
 		}
+		return changed;
 	}
 
 	/**
-	 * @param {Dependency} dependency the referencing dependency
-	 * @param {Module} module the referenced module
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	updateModule(dependency, module) {
-		const connection = this.getConnection(dependency);
-		if (connection.module === module) return;
-		const newConnection = connection.clone();
-		newConnection.module = module;
-		this._dependencyMap.set(dependency, newConnection);
-		connection.setActive(false);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.add(newConnection);
-		const targetMgm = this._getModuleGraphModule(module);
-		targetMgm.incomingConnections.add(newConnection);
+	setUsedInUnknownWay(runtime) {
+		let changed = false;
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.setUsedInUnknownWay(runtime)) {
+				changed = true;
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			if (this._redirectTo.setUsedInUnknownWay(runtime)) {
+				changed = true;
+			}
+		} else {
+			if (
+				this._otherExportsInfo.setUsedConditionally(
+					used => used < UsageState.Unknown,
+					UsageState.Unknown,
+					runtime
+				)
+			) {
+				changed = true;
+			}
+			if (this._otherExportsInfo.canMangleUse !== false) {
+				this._otherExportsInfo.canMangleUse = false;
+				changed = true;
+			}
+		}
+		return changed;
 	}
 
 	/**
-	 * @param {Dependency} dependency the referencing dependency
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	removeConnection(dependency) {
-		const connection = this.getConnection(dependency);
-		const targetMgm = this._getModuleGraphModule(connection.module);
-		targetMgm.incomingConnections.delete(connection);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.delete(connection);
-		this._dependencyMap.set(dependency, null);
+	setUsedWithoutInfo(runtime) {
+		let changed = false;
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.setUsedWithoutInfo(runtime)) {
+				changed = true;
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			if (this._redirectTo.setUsedWithoutInfo(runtime)) {
+				changed = true;
+			}
+		} else {
+			if (this._otherExportsInfo.setUsed(UsageState.NoInfo, runtime)) {
+				changed = true;
+			}
+			if (this._otherExportsInfo.canMangleUse !== false) {
+				this._otherExportsInfo.canMangleUse = false;
+				changed = true;
+			}
+		}
+		return changed;
 	}
 
 	/**
-	 * @param {Dependency} dependency the referencing dependency
-	 * @param {string} explanation an explanation
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	addExplanation(dependency, explanation) {
-		const connection = this.getConnection(dependency);
-		connection.addExplanation(explanation);
+	setAllKnownExportsUsed(runtime) {
+		let changed = false;
+		for (const exportInfo of this._exports.values()) {
+			if (!exportInfo.provided) continue;
+			if (exportInfo.setUsed(UsageState.Used, runtime)) {
+				changed = true;
+			}
+		}
+		return changed;
 	}
 
 	/**
-	 * @param {Module} sourceModule the source module
-	 * @param {Module} targetModule the target module
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	cloneModuleAttributes(sourceModule, targetModule) {
-		const oldMgm = this._getModuleGraphModule(sourceModule);
-		const newMgm = this._getModuleGraphModule(targetModule);
-		newMgm.postOrderIndex = oldMgm.postOrderIndex;
-		newMgm.preOrderIndex = oldMgm.preOrderIndex;
-		newMgm.depth = oldMgm.depth;
-		newMgm.exports = oldMgm.exports;
-		newMgm.async = oldMgm.async;
+	setUsedForSideEffectsOnly(runtime) {
+		return this._sideEffectsOnlyInfo.setUsedConditionally(
+			used => used === UsageState.Unused,
+			UsageState.Used,
+			runtime
+		);
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when the module exports are used in any way
 	 */
-	removeModuleAttributes(module) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.postOrderIndex = null;
-		mgm.preOrderIndex = null;
-		mgm.depth = null;
-		mgm.async = false;
+	isUsed(runtime) {
+		if (this._redirectTo !== undefined) {
+			if (this._redirectTo.isUsed(runtime)) {
+				return true;
+			}
+		} else {
+			if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+				return true;
+			}
+		}
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.getUsed(runtime) !== UsageState.Unused) {
+				return true;
+			}
+		}
+		return false;
 	}
 
 	/**
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when the module is used in any way
 	 */
-	removeAllModuleAttributes() {
-		for (const mgm of this._moduleMap.values()) {
-			mgm.postOrderIndex = null;
-			mgm.preOrderIndex = null;
-			mgm.depth = null;
-			mgm.async = false;
-		}
+	isModuleUsed(runtime) {
+		if (this.isUsed(runtime)) return true;
+		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
+			return true;
+		return false;
 	}
 
 	/**
-	 * @param {Module} oldModule the old referencing module
-	 * @param {Module} newModule the new referencing module
-	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
 	 */
-	moveModuleConnections(oldModule, newModule, filterConnection) {
-		if (oldModule === newModule) return;
-		const oldMgm = this._getModuleGraphModule(oldModule);
-		const newMgm = this._getModuleGraphModule(newModule);
-		// Outgoing connections
-		const oldConnections = oldMgm.outgoingConnections;
-		if (oldConnections !== undefined) {
-			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new SortableSet();
+	getUsedExports(runtime) {
+		if (!this._redirectTo !== undefined) {
+			switch (this._otherExportsInfo.getUsed(runtime)) {
+				case UsageState.NoInfo:
+					return null;
+				case UsageState.Unknown:
+				case UsageState.OnlyPropertiesUsed:
+				case UsageState.Used:
+					return true;
 			}
-			const newConnections = newMgm.outgoingConnections;
-			for (const connection of oldConnections) {
-				if (filterConnection(connection)) {
-					connection.originModule = newModule;
-					newConnections.add(connection);
-					oldConnections.delete(connection);
+		}
+		const array = [];
+		if (!this._exportsAreOrdered) this._sortExports();
+		for (const exportInfo of this._exports.values()) {
+			switch (exportInfo.getUsed(runtime)) {
+				case UsageState.NoInfo:
+					return null;
+				case UsageState.Unknown:
+					return true;
+				case UsageState.OnlyPropertiesUsed:
+				case UsageState.Used:
+					array.push(exportInfo.name);
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			const inner = this._redirectTo.getUsedExports(runtime);
+			if (inner === null) return null;
+			if (inner === true) return true;
+			if (inner !== false) {
+				for (const item of inner) {
+					array.push(item);
 				}
 			}
 		}
-		// Incoming connections
-		const oldConnections2 = oldMgm.incomingConnections;
-		const newConnections2 = newMgm.incomingConnections;
-		for (const connection of oldConnections2) {
-			if (filterConnection(connection)) {
-				connection.module = newModule;
-				newConnections2.add(connection);
-				oldConnections2.delete(connection);
+		if (array.length === 0) {
+			switch (this._sideEffectsOnlyInfo.getUsed(runtime)) {
+				case UsageState.NoInfo:
+					return null;
+				case UsageState.Unused:
+					return false;
 			}
 		}
+		return new SortableSet(array);
 	}
 
 	/**
-	 * @param {Module} oldModule the old referencing module
-	 * @param {Module} newModule the new referencing module
-	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
-	 * @returns {void}
+	 * @returns {null | true | string[]} list of exports when known
 	 */
-	copyOutgoingModuleConnections(oldModule, newModule, filterConnection) {
-		if (oldModule === newModule) return;
-		const oldMgm = this._getModuleGraphModule(oldModule);
-		const newMgm = this._getModuleGraphModule(newModule);
-		// Outgoing connections
-		const oldConnections = oldMgm.outgoingConnections;
-		if (oldConnections !== undefined) {
-			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new SortableSet();
+	getProvidedExports() {
+		if (!this._redirectTo !== undefined) {
+			switch (this._otherExportsInfo.provided) {
+				case undefined:
+					return null;
+				case null:
+					return true;
+				case true:
+					return true;
 			}
-			const newConnections = newMgm.outgoingConnections;
-			for (const connection of oldConnections) {
-				if (filterConnection(connection)) {
-					const newConnection = connection.clone();
-					newConnection.originModule = newModule;
-					newConnections.add(newConnection);
-					if (newConnection.module !== undefined) {
-						const otherMgm = this._getModuleGraphModule(newConnection.module);
-						otherMgm.incomingConnections.add(newConnection);
-					}
+		}
+		const array = [];
+		if (!this._exportsAreOrdered) this._sortExports();
+		for (const exportInfo of this._exports.values()) {
+			switch (exportInfo.provided) {
+				case undefined:
+					return null;
+				case null:
+					return true;
+				case true:
+					array.push(exportInfo.name);
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			const inner = this._redirectTo.getProvidedExports();
+			if (inner === null) return null;
+			if (inner === true) return true;
+			for (const item of inner) {
+				if (!array.includes(item)) {
+					array.push(item);
 				}
 			}
 		}
+		return array;
 	}
 
 	/**
-	 * @param {Module} module the referenced module
-	 * @param {string} explanation an explanation why it's referenced
-	 * @returns {void}
-	 */
-	addExtraReason(module, explanation) {
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		connections.add(new ModuleGraphConnection(null, null, module, explanation));
-	}
-
-	/**
-	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {Module} the referenced module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ExportInfo[]} exports that are relevant (not unused and potential provided)
 	 */
-	getResolvedModule(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.resolvedModule : null;
+	getRelevantExports(runtime) {
+		const list = [];
+		for (const exportInfo of this._exports.values()) {
+			const used = exportInfo.getUsed(runtime);
+			if (used === UsageState.Unused) continue;
+			if (exportInfo.provided === false) continue;
+			list.push(exportInfo);
+		}
+		if (this._redirectTo !== undefined) {
+			for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) {
+				if (!this._exports.has(exportInfo.name)) list.push(exportInfo);
+			}
+		}
+		if (
+			this._otherExportsInfo.provided !== false &&
+			this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused
+		) {
+			list.push(this._otherExportsInfo);
+		}
+		return list;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {ModuleGraphConnection | undefined} the connection
+	 * @param {string | string[]} name the name of the export
+	 * @returns {boolean | undefined | null} if the export is provided
 	 */
-	getConnection(dependency) {
-		const connection = this._dependencyMap.get(dependency);
-		if (connection === undefined) {
-			const module = this.getParentModule(dependency);
-			if (module !== undefined) {
-				const mgm = this._getModuleGraphModule(module);
-				if (
-					mgm._unassignedConnections &&
-					mgm._unassignedConnections.length !== 0
-				) {
-					let foundConnection;
-					for (const connection of mgm._unassignedConnections) {
-						this._dependencyMap.set(connection.dependency, connection);
-						if (connection.dependency === dependency)
-							foundConnection = connection;
-					}
-					mgm._unassignedConnections.length = 0;
-					if (foundConnection !== undefined) {
-						return foundConnection;
-					}
-				}
+	isExportProvided(name) {
+		if (Array.isArray(name)) {
+			const info = this.getReadOnlyExportInfo(name[0]);
+			if (info.exportsInfo && name.length > 1) {
+				return info.exportsInfo.isExportProvided(name.slice(1));
 			}
-			this._dependencyMap.set(dependency, null);
-			return undefined;
+			return info.provided;
 		}
-		return connection === null ? undefined : connection;
+		const info = this.getReadOnlyExportInfo(name);
+		return info.provided;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {Module} the referenced module
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {string} key representing the usage
 	 */
-	getModule(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.module : null;
+	getUsageKey(runtime) {
+		const key = [];
+		if (this._redirectTo !== undefined) {
+			key.push(this._redirectTo.getUsageKey(runtime));
+		} else {
+			key.push(this._otherExportsInfo.getUsed(runtime));
+		}
+		key.push(this._sideEffectsOnlyInfo.getUsed(runtime));
+		for (const exportInfo of this.orderedOwnedExports) {
+			key.push(exportInfo.getUsed(runtime));
+		}
+		return key.join("|");
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referencing module
-	 * @returns {Module} the referencing module
+	 * @param {RuntimeSpec} runtimeA first runtime
+	 * @param {RuntimeSpec} runtimeB second runtime
+	 * @returns {boolean} true, when equally used
 	 */
-	getOrigin(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.originModule : null;
-	}
-
-	/**
-	 * @param {Dependency} dependency the dependency to look for a referencing module
-	 * @returns {Module} the original referencing module
-	 */
-	getResolvedOrigin(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.resolvedOriginModule : null;
+	isEquallyUsed(runtimeA, runtimeB) {
+		if (this._redirectTo !== undefined) {
+			if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false;
+		} else {
+			if (
+				this._otherExportsInfo.getUsed(runtimeA) !==
+				this._otherExportsInfo.getUsed(runtimeB)
+			) {
+				return false;
+			}
+		}
+		if (
+			this._sideEffectsOnlyInfo.getUsed(runtimeA) !==
+			this._sideEffectsOnlyInfo.getUsed(runtimeB)
+		) {
+			return false;
+		}
+		for (const exportInfo of this.ownedExports) {
+			if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB))
+				return false;
+		}
+		return true;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {Iterable<ModuleGraphConnection>} reasons why a module is included
+	 * @param {string | string[]} name export name
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {UsageStateType} usage status
 	 */
-	getIncomingConnections(module) {
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		return connections;
+	getUsed(name, runtime) {
+		if (Array.isArray(name)) {
+			if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);
+			let info = this.getReadOnlyExportInfo(name[0]);
+			if (info.exportsInfo && name.length > 1) {
+				return info.exportsInfo.getUsed(name.slice(1), runtime);
+			}
+			return info.getUsed(runtime);
+		}
+		let info = this.getReadOnlyExportInfo(name);
+		return info.getUsed(runtime);
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {Iterable<ModuleGraphConnection>} list of outgoing connections
+	 * @param {string | string[]} name the export name
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {string | string[] | false} the used name
 	 */
-	getOutgoingConnections(module) {
-		const connections = this._getModuleGraphModule(module).outgoingConnections;
-		return connections === undefined ? EMPTY_SET : connections;
+	getUsedName(name, runtime) {
+		if (Array.isArray(name)) {
+			// TODO improve this
+			if (name.length === 0) {
+				if (!this.isUsed(runtime)) return false;
+				return name;
+			}
+			let info = this.getReadOnlyExportInfo(name[0]);
+			const x = info.getUsedName(name[0], runtime);
+			if (x === false) return false;
+			const arr = x === name[0] && name.length === 1 ? name : [x];
+			if (name.length === 1) {
+				return arr;
+			}
+			if (
+				info.exportsInfo &&
+				info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
+			) {
+				const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
+				if (!nested) return false;
+				return arr.concat(nested);
+			} else {
+				return arr.concat(name.slice(1));
+			}
+		} else {
+			let info = this.getReadOnlyExportInfo(name);
+			const usedName = info.getUsedName(name, runtime);
+			return usedName;
+		}
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @param {Hash} hash the hash
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {void}
 	 */
-	getIncomingConnectionsByOriginModule(module) {
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
+	updateHash(hash, runtime) {
+		this._updateHash(hash, runtime, new Set());
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
+	 * @param {Hash} hash the hash
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
+	 * @returns {void}
 	 */
-	getOutgoingConnectionsByModule(module) {
-		const connections = this._getModuleGraphModule(module).outgoingConnections;
-		return connections === undefined
-			? undefined
-			: connections.getFromUnorderedCache(getConnectionsByModule);
+	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+		const set = new Set(alreadyVisitedExportsInfo);
+		set.add(this);
+		for (const exportInfo of this.orderedExports) {
+			if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {
+				exportInfo._updateHash(hash, runtime, set);
+			}
+		}
+		this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);
+		this._otherExportsInfo._updateHash(hash, runtime, set);
+		if (this._redirectTo !== undefined) {
+			this._redirectTo._updateHash(hash, runtime, set);
+		}
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {ModuleProfile | null} the module profile
-	 */
-	getProfile(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.profile;
+	getRestoreProvidedData() {
+		const otherProvided = this._otherExportsInfo.provided;
+		const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
+		const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
+		const exports = [];
+		for (const exportInfo of this.orderedExports) {
+			if (
+				exportInfo.provided !== otherProvided ||
+				exportInfo.canMangleProvide !== otherCanMangleProvide ||
+				exportInfo.terminalBinding !== otherTerminalBinding ||
+				exportInfo.exportsInfoOwned
+			) {
+				exports.push({
+					name: exportInfo.name,
+					provided: exportInfo.provided,
+					canMangleProvide: exportInfo.canMangleProvide,
+					terminalBinding: exportInfo.terminalBinding,
+					exportsInfo: exportInfo.exportsInfoOwned
+						? exportInfo.exportsInfo.getRestoreProvidedData()
+						: undefined
+				});
+			}
+		}
+		return new RestoreProvidedData(
+			exports,
+			otherProvided,
+			otherCanMangleProvide,
+			otherTerminalBinding
+		);
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {ModuleProfile | null} profile the module profile
-	 * @returns {void}
-	 */
-	setProfile(module, profile) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.profile = profile;
+	restoreProvided({
+		otherProvided,
+		otherCanMangleProvide,
+		otherTerminalBinding,
+		exports
+	}) {
+		let wasEmpty = true;
+		for (const exportInfo of this._exports.values()) {
+			wasEmpty = false;
+			exportInfo.provided = otherProvided;
+			exportInfo.canMangleProvide = otherCanMangleProvide;
+			exportInfo.terminalBinding = otherTerminalBinding;
+		}
+		this._otherExportsInfo.provided = otherProvided;
+		this._otherExportsInfo.canMangleProvide = otherCanMangleProvide;
+		this._otherExportsInfo.terminalBinding = otherTerminalBinding;
+		for (const exp of exports) {
+			const exportInfo = this.getExportInfo(exp.name);
+			exportInfo.provided = exp.provided;
+			exportInfo.canMangleProvide = exp.canMangleProvide;
+			exportInfo.terminalBinding = exp.terminalBinding;
+			if (exp.exportsInfo) {
+				const exportsInfo = exportInfo.createNestedExportsInfo();
+				exportsInfo.restoreProvided(exp.exportsInfo);
+			}
+		}
+		if (wasEmpty) this._exportsAreOrdered = true;
 	}
+}
 
+class ExportInfo {
 	/**
-	 * @param {Module} module the module
-	 * @returns {Module | null} the issuer module
+	 * @param {string} name the original name of the export
+	 * @param {ExportInfo=} initFrom init values from this ExportInfo
 	 */
-	getIssuer(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.issuer;
+	constructor(name, initFrom) {
+		/** @type {string} */
+		this.name = name;
+		/** @private @type {string | null} */
+		this._usedName = initFrom ? initFrom._usedName : null;
+		/** @private @type {UsageStateType} */
+		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
+		/** @private @type {Map<string, RuntimeUsageStateType>} */
+		this._usedInRuntime =
+			initFrom && initFrom._usedInRuntime
+				? new Map(initFrom._usedInRuntime)
+				: undefined;
+		/** @private @type {boolean} */
+		this._hasUseInRuntimeInfo = initFrom
+			? initFrom._hasUseInRuntimeInfo
+			: false;
+		/**
+		 * true: it is provided
+		 * false: it is not provided
+		 * null: only the runtime knows if it is provided
+		 * undefined: it was not determined if it is provided
+		 * @type {boolean | null | undefined}
+		 */
+		this.provided = initFrom ? initFrom.provided : undefined;
+		/**
+		 * is the export a terminal binding that should be checked for export star conflicts
+		 * @type {boolean}
+		 */
+		this.terminalBinding = initFrom ? initFrom.terminalBinding : false;
+		/**
+		 * true: it can be mangled
+		 * false: is can not be mangled
+		 * undefined: it was not determined if it can be mangled
+		 * @type {boolean | undefined}
+		 */
+		this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
+		/**
+		 * true: it can be mangled
+		 * false: is can not be mangled
+		 * undefined: it was not determined if it can be mangled
+		 * @type {boolean | undefined}
+		 */
+		this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
+		/** @type {boolean} */
+		this.exportsInfoOwned = false;
+		/** @type {ExportsInfo=} */
+		this.exportsInfo = undefined;
+		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
+		this._target = undefined;
+		if (initFrom && initFrom._target) {
+			this._target = new Map();
+			for (const [key, value] of initFrom._target) {
+				this._target.set(key, {
+					connection: value.connection,
+					export: value.export || [name],
+					priority: value.priority
+				});
+			}
+		}
+		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
+		this._maxTarget = undefined;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {Module | null} issuer the issuer module
-	 * @returns {void}
-	 */
-	setIssuer(module, issuer) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.issuer = issuer;
+	// TODO webpack 5 remove
+	/** @private */
+	get used() {
+		throw new Error("REMOVED");
 	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {Module | null} issuer the issuer module
-	 * @returns {void}
-	 */
-	setIssuerIfUnset(module, issuer) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.issuer === undefined) mgm.issuer = issuer;
+	/** @private */
+	get usedName() {
+		throw new Error("REMOVED");
 	}
-
 	/**
-	 * @param {Module} module the module
-	 * @returns {(string | OptimizationBailoutFunction)[]} optimization bailouts
+	 * @private
+	 * @param {*} v v
 	 */
-	getOptimizationBailout(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.optimizationBailout;
+	set used(v) {
+		throw new Error("REMOVED");
 	}
-
 	/**
-	 * @param {Module} module the module
-	 * @returns {true | string[] | null} the provided exports
+	 * @private
+	 * @param {*} v v
 	 */
-	getProvidedExports(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getProvidedExports();
+	set usedName(v) {
+		throw new Error("REMOVED");
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {string | string[]} exportName a name of an export
-	 * @returns {boolean | null} true, if the export is provided by the module.
-	 * null, if it's unknown.
-	 * false, if it's not provided.
-	 */
-	isExportProvided(module, exportName) {
-		const mgm = this._getModuleGraphModule(module);
-		const result = mgm.exports.isExportProvided(exportName);
-		return result === undefined ? null : result;
+	get canMangle() {
+		switch (this.canMangleProvide) {
+			case undefined:
+				return this.canMangleUse === false ? false : undefined;
+			case false:
+				return false;
+			case true:
+				switch (this.canMangleUse) {
+					case undefined:
+						return undefined;
+					case false:
+						return false;
+					case true:
+						return true;
+				}
+		}
+		throw new Error(
+			`Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}`
+		);
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {ExportsInfo} info about the exports
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	getExportsInfo(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports;
+	setUsedInUnknownWay(runtime) {
+		let changed = false;
+		if (
+			this.setUsedConditionally(
+				used => used < UsageState.Unknown,
+				UsageState.Unknown,
+				runtime
+			)
+		) {
+			changed = true;
+		}
+		if (this.canMangleUse !== false) {
+			this.canMangleUse = false;
+			changed = true;
+		}
+		return changed;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {string} exportName the export
-	 * @returns {ExportInfo} info about the export
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	getExportInfo(module, exportName) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getExportInfo(exportName);
+	setUsedWithoutInfo(runtime) {
+		let changed = false;
+		if (this.setUsed(UsageState.NoInfo, runtime)) {
+			changed = true;
+		}
+		if (this.canMangleUse !== false) {
+			this.canMangleUse = false;
+			changed = true;
+		}
+		return changed;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {string} exportName the export
-	 * @returns {ExportInfo} info about the export (do not modify)
-	 */
-	getReadOnlyExportInfo(module, exportName) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getReadOnlyExportInfo(exportName);
+	setHasUseInfo() {
+		if (!this._hasUseInRuntimeInfo) {
+			this._hasUseInRuntimeInfo = true;
+		}
+		if (this.canMangleUse === undefined) {
+			this.canMangleUse = true;
+		}
+		if (this.exportsInfoOwned) {
+			this.exportsInfo.setHasUseInfo();
+		}
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {false | true | SortableSet<string> | null} the used exports
-	 * false: module is not used at all.
-	 * true: the module namespace/object export is used.
-	 * SortableSet<string>: these export names are used.
-	 * empty SortableSet<string>: module is used but no export.
-	 * null: unknown, worst case should be assumed.
+	 * @param {function(UsageStateType): boolean} condition compare with old value
+	 * @param {UsageStateType} newValue set when condition is true
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true when something has changed
 	 */
-	getUsedExports(module, runtime) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getUsedExports(runtime);
+	setUsedConditionally(condition, newValue, runtime) {
+		if (runtime === undefined) {
+			if (this._globalUsed === undefined) {
+				this._globalUsed = newValue;
+				return true;
+			} else {
+				if (this._globalUsed !== newValue && condition(this._globalUsed)) {
+					this._globalUsed = newValue;
+					return true;
+				}
+			}
+		} else if (this._usedInRuntime === undefined) {
+			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
+				this._usedInRuntime = new Map();
+				forEachRuntime(runtime, runtime =>
+					this._usedInRuntime.set(runtime, newValue)
+				);
+				return true;
+			}
+		} else {
+			let changed = false;
+			forEachRuntime(runtime, runtime => {
+				/** @type {UsageStateType} */
+				let oldValue = this._usedInRuntime.get(runtime);
+				if (oldValue === undefined) oldValue = UsageState.Unused;
+				if (newValue !== oldValue && condition(oldValue)) {
+					if (newValue === UsageState.Unused) {
+						this._usedInRuntime.delete(runtime);
+					} else {
+						this._usedInRuntime.set(runtime, newValue);
+					}
+					changed = true;
+				}
+			});
+			if (changed) {
+				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
+				return true;
+			}
+		}
+		return false;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {number} the index of the module
+	 * @param {UsageStateType} newValue new value of the used state
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true when something has changed
 	 */
-	getPreOrderIndex(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.preOrderIndex;
+	setUsed(newValue, runtime) {
+		if (runtime === undefined) {
+			if (this._globalUsed !== newValue) {
+				this._globalUsed = newValue;
+				return true;
+			}
+		} else if (this._usedInRuntime === undefined) {
+			if (newValue !== UsageState.Unused) {
+				this._usedInRuntime = new Map();
+				forEachRuntime(runtime, runtime =>
+					this._usedInRuntime.set(runtime, newValue)
+				);
+				return true;
+			}
+		} else {
+			let changed = false;
+			forEachRuntime(runtime, runtime => {
+				/** @type {UsageStateType} */
+				let oldValue = this._usedInRuntime.get(runtime);
+				if (oldValue === undefined) oldValue = UsageState.Unused;
+				if (newValue !== oldValue) {
+					if (newValue === UsageState.Unused) {
+						this._usedInRuntime.delete(runtime);
+					} else {
+						this._usedInRuntime.set(runtime, newValue);
+					}
+					changed = true;
+				}
+			});
+			if (changed) {
+				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
+				return true;
+			}
+		}
+		return false;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {number} the index of the module
+	 * @param {any} key the key
+	 * @returns {boolean} true, if something has changed
 	 */
-	getPostOrderIndex(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.postOrderIndex;
+	unsetTarget(key) {
+		if (!this._target) return false;
+		if (this._target.delete(key)) {
+			this._maxTarget = undefined;
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {void}
+	 * @param {any} key the key
+	 * @param {ModuleGraphConnection} connection the target module if a single one
+	 * @param {string[]=} exportName the exported name
+	 * @param {number=} priority priority
+	 * @returns {boolean} true, if something has changed
 	 */
-	setPreOrderIndex(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.preOrderIndex = index;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {boolean} true, if the index was set
-	 */
-	setPreOrderIndexIfUnset(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.preOrderIndex === null) {
-			mgm.preOrderIndex = index;
+	setTarget(key, connection, exportName, priority = 0) {
+		if (exportName) exportName = [...exportName];
+		if (!this._target) {
+			this._target = new Map();
+			this._target.set(key, { connection, export: exportName, priority });
 			return true;
 		}
-		return false;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {void}
-	 */
-	setPostOrderIndex(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.postOrderIndex = index;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {boolean} true, if the index was set
-	 */
-	setPostOrderIndexIfUnset(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.postOrderIndex === null) {
-			mgm.postOrderIndex = index;
+		const oldTarget = this._target.get(key);
+		if (!oldTarget) {
+			if (oldTarget === null && !connection) return false;
+			this._target.set(key, { connection, export: exportName, priority });
+			this._maxTarget = undefined;
+			return true;
+		}
+		if (
+			oldTarget.connection !== connection ||
+			oldTarget.priority !== priority ||
+			(exportName
+				? !oldTarget.export || !equals(oldTarget.export, exportName)
+				: oldTarget.export)
+		) {
+			oldTarget.connection = connection;
+			oldTarget.export = exportName;
+			oldTarget.priority = priority;
+			this._maxTarget = undefined;
 			return true;
 		}
 		return false;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {number} the depth of the module
-	 */
-	getDepth(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.depth;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {number} depth the depth of the module
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime for this runtime
+	 * @returns {UsageStateType} usage state
 	 */
-	setDepth(module, depth) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.depth = depth;
+	getUsed(runtime) {
+		if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
+		if (this._globalUsed !== undefined) return this._globalUsed;
+		if (this._usedInRuntime === undefined) {
+			return UsageState.Unused;
+		} else if (typeof runtime === "string") {
+			const value = this._usedInRuntime.get(runtime);
+			return value === undefined ? UsageState.Unused : value;
+		} else if (runtime === undefined) {
+			/** @type {UsageStateType} */
+			let max = UsageState.Unused;
+			for (const value of this._usedInRuntime.values()) {
+				if (value === UsageState.Used) {
+					return UsageState.Used;
+				}
+				if (max < value) max = value;
+			}
+			return max;
+		} else {
+			/** @type {UsageStateType} */
+			let max = UsageState.Unused;
+			for (const item of runtime) {
+				const value = this._usedInRuntime.get(item);
+				if (value !== undefined) {
+					if (value === UsageState.Used) {
+						return UsageState.Used;
+					}
+					if (max < value) max = value;
+				}
+			}
+			return max;
+		}
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {number} depth the depth of the module
-	 * @returns {boolean} true, if the depth was set
+	 * get used name
+	 * @param {string | undefined} fallbackName fallback name for used exports with no name
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {string | false} used name
 	 */
-	setDepthIfLower(module, depth) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.depth === null || mgm.depth > depth) {
-			mgm.depth = depth;
-			return true;
+	getUsedName(fallbackName, runtime) {
+		if (this._hasUseInRuntimeInfo) {
+			if (this._globalUsed !== undefined) {
+				if (this._globalUsed === UsageState.Unused) return false;
+			} else {
+				if (this._usedInRuntime === undefined) return false;
+				if (typeof runtime === "string") {
+					if (!this._usedInRuntime.has(runtime)) {
+						return false;
+					}
+				} else if (runtime !== undefined) {
+					if (
+						Array.from(runtime).every(
+							runtime => !this._usedInRuntime.has(runtime)
+						)
+					) {
+						return false;
+					}
+				}
+			}
 		}
-		return false;
+		if (this._usedName !== null) return this._usedName;
+		return this.name || fallbackName;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the module is async
+	 * @returns {boolean} true, when a mangled name of this export is set
 	 */
-	isAsync(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.async;
+	hasUsedName() {
+		return this._usedName !== null;
 	}
 
 	/**
-	 * @param {Module} module the module
+	 * Sets the mangled name of this export
+	 * @param {string} name the new name
 	 * @returns {void}
 	 */
-	setAsync(module) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.async = true;
-	}
-
-	/**
-	 * @param {any} thing any thing
-	 * @returns {Object} metadata
-	 */
-	getMeta(thing) {
-		let meta = this._metaMap.get(thing);
-		if (meta === undefined) {
-			meta = Object.create(null);
-			this._metaMap.set(thing, meta);
-		}
-		return meta;
+	setUsedName(name) {
+		this._usedName = name;
 	}
 
 	/**
-	 * @param {any} thing any thing
-	 * @returns {Object} metadata
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
 	 */
-	getMetaIfExisting(thing) {
-		return this._metaMap.get(thing);
+	getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
+		if (this.terminalBinding) return this;
+		const target = this.getTarget(moduleGraph, resolveTargetFilter);
+		if (!target) return undefined;
+		const exportsInfo = moduleGraph.getExportsInfo(target.module);
+		if (!target.export) return exportsInfo;
+		return exportsInfo.getReadOnlyExportInfoRecursive(target.export);
 	}
 
-	/**
-	 * @param {string=} cacheStage a persistent stage name for caching
-	 */
-	freeze(cacheStage) {
-		this._cache = new WeakTupleMap();
-		this._cacheStage = cacheStage;
+	isReexport() {
+		return !this.terminalBinding && this._target && this._target.size > 0;
 	}
 
-	unfreeze() {
-		this._cache = undefined;
-		this._cacheStage = undefined;
-	}
+	_getMaxTarget() {
+		if (this._maxTarget !== undefined) return this._maxTarget;
+		if (this._target.size <= 1) return (this._maxTarget = this._target);
+		let maxPriority = -Infinity;
+		let minPriority = Infinity;
+		for (const { priority } of this._target.values()) {
+			if (maxPriority < priority) maxPriority = priority;
+			if (minPriority > priority) minPriority = priority;
+		}
+		// This should be very common
+		if (maxPriority === minPriority) return (this._maxTarget = this._target);
 
-	/**
-	 * @template {any[]} T
-	 * @template V
-	 * @param {(moduleGraph: ModuleGraph, ...args: T) => V} fn computer
-	 * @param {T} args arguments
-	 * @returns {V} computed value or cached
-	 */
-	cached(fn, ...args) {
-		if (this._cache === undefined) return fn(this, ...args);
-		return this._cache.provide(fn, ...args, () => fn(this, ...args));
+		// This is an edge case
+		const map = new Map();
+		for (const [key, value] of this._target) {
+			if (maxPriority === value.priority) {
+				map.set(key, value);
+			}
+		}
+		this._maxTarget = map;
+		return map;
 	}
 
 	/**
-	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
-	setModuleMemCaches(moduleMemCaches) {
-		this._moduleMemCaches = moduleMemCaches;
+	findTarget(moduleGraph, validTargetModuleFilter) {
+		return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
 	}
 
 	/**
-	 * @param {Dependency} dependency dependency
-	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
-	 * @returns {any} computed value or cached
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
-	dependencyCacheProvide(dependency, ...args) {
-		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
-		const fn = args.pop();
-		if (this._moduleMemCaches && this._cacheStage) {
-			const memCache = this._moduleMemCaches.get(
-				this.getParentModule(dependency)
+	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
+		if (!this._target || this._target.size === 0) return undefined;
+		let rawTarget = this._getMaxTarget().values().next().value;
+		if (!rawTarget) return undefined;
+		/** @type {{ module: Module, export: string[] | undefined }} */
+		let target = {
+			module: rawTarget.connection.module,
+			export: rawTarget.export
+		};
+		for (;;) {
+			if (validTargetModuleFilter(target.module)) return target;
+			const exportsInfo = moduleGraph.getExportsInfo(target.module);
+			const exportInfo = exportsInfo.getExportInfo(target.export[0]);
+			if (alreadyVisited.has(exportInfo)) return null;
+			const newTarget = exportInfo._findTarget(
+				moduleGraph,
+				validTargetModuleFilter,
+				alreadyVisited
 			);
-			if (memCache !== undefined) {
-				return memCache.provide(dependency, this._cacheStage, ...args, () =>
-					fn(this, dependency, ...args)
-				);
+			if (!newTarget) return false;
+			if (target.export.length === 1) {
+				target = newTarget;
+			} else {
+				target = {
+					module: newTarget.module,
+					export: newTarget.export
+						? newTarget.export.concat(target.export.slice(1))
+						: target.export.slice(1)
+				};
 			}
 		}
-		if (this._cache === undefined) return fn(this, dependency, ...args);
-		return this._cache.provide(dependency, ...args, () =>
-			fn(this, dependency, ...args)
-		);
 	}
 
-	// TODO remove in webpack 6
 	/**
-	 * @param {Module} module the module
-	 * @param {string} deprecateMessage message for the deprecation message
-	 * @param {string} deprecationCode code for the deprecation
-	 * @returns {ModuleGraph} the module graph
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the target
 	 */
-	static getModuleGraphForModule(module, deprecateMessage, deprecationCode) {
-		const fn = deprecateMap.get(deprecateMessage);
-		if (fn) return fn(module);
-		const newFn = util.deprecate(
-			/**
-			 * @param {Module} module the module
-			 * @returns {ModuleGraph} the module graph
-			 */
-			module => {
-				const moduleGraph = moduleGraphForModuleMap.get(module);
-				if (!moduleGraph)
-					throw new Error(
-						deprecateMessage +
-							"There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)"
-					);
-				return moduleGraph;
-			},
-			deprecateMessage + ": Use new ModuleGraph API",
-			deprecationCode
-		);
-		deprecateMap.set(deprecateMessage, newFn);
-		return newFn(module);
+	getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
+		const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
+		if (result === CIRCULAR) return undefined;
+		return result;
 	}
 
-	// TODO remove in webpack 6
 	/**
-	 * @param {Module} module the module
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {void}
+	 * @param {function({ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
+	 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | undefined} the target
 	 */
-	static setModuleGraphForModule(module, moduleGraph) {
-		moduleGraphForModuleMap.set(module, moduleGraph);
+	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
+		/**
+		 * @param {{ connection: ModuleGraphConnection, export: string[] | undefined } | null} inputTarget unresolved target
+		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
+		 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | null} resolved target
+		 */
+		const resolveTarget = (inputTarget, alreadyVisited) => {
+			if (!inputTarget) return null;
+			if (!inputTarget.export) {
+				return {
+					module: inputTarget.connection.module,
+					connection: inputTarget.connection,
+					export: undefined
+				};
+			}
+			/** @type {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} */
+			let target = {
+				module: inputTarget.connection.module,
+				connection: inputTarget.connection,
+				export: inputTarget.export
+			};
+			if (!resolveTargetFilter(target)) return target;
+			let alreadyVisitedOwned = false;
+			for (;;) {
+				const exportsInfo = moduleGraph.getExportsInfo(target.module);
+				const exportInfo = exportsInfo.getExportInfo(target.export[0]);
+				if (!exportInfo) return target;
+				if (alreadyVisited.has(exportInfo)) return CIRCULAR;
+				const newTarget = exportInfo._getTarget(
+					moduleGraph,
+					resolveTargetFilter,
+					alreadyVisited
+				);
+				if (newTarget === CIRCULAR) return CIRCULAR;
+				if (!newTarget) return target;
+				if (target.export.length === 1) {
+					target = newTarget;
+					if (!target.export) return target;
+				} else {
+					target = {
+						module: newTarget.module,
+						connection: newTarget.connection,
+						export: newTarget.export
+							? newTarget.export.concat(target.export.slice(1))
+							: target.export.slice(1)
+					};
+				}
+				if (!resolveTargetFilter(target)) return target;
+				if (!alreadyVisitedOwned) {
+					alreadyVisited = new Set(alreadyVisited);
+					alreadyVisitedOwned = true;
+				}
+				alreadyVisited.add(exportInfo);
+			}
+		};
+
+		if (!this._target || this._target.size === 0) return undefined;
+		if (alreadyVisited && alreadyVisited.has(this)) return CIRCULAR;
+		const newAlreadyVisited = new Set(alreadyVisited);
+		newAlreadyVisited.add(this);
+		const values = this._getMaxTarget().values();
+		const target = resolveTarget(values.next().value, newAlreadyVisited);
+		if (target === CIRCULAR) return CIRCULAR;
+		if (target === null) return undefined;
+		let result = values.next();
+		while (!result.done) {
+			const t = resolveTarget(result.value, newAlreadyVisited);
+			if (t === CIRCULAR) return CIRCULAR;
+			if (t === null) return undefined;
+			if (t.module !== target.module) return undefined;
+			if (!t.export !== !target.export) return undefined;
+			if (target.export && !equals(t.export, target.export)) return undefined;
+			result = values.next();
+		}
+		return target;
 	}
 
-	// TODO remove in webpack 6
 	/**
-	 * @param {Module} module the module
-	 * @returns {void}
+	 * Move the target forward as long resolveTargetFilter is fulfilled
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {function({ module: Module, export: string[] | undefined }): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the resolved target when moved
 	 */
-	static clearModuleGraphForModule(module) {
-		moduleGraphForModuleMap.delete(module);
+	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
+		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
+		if (target === CIRCULAR) return undefined;
+		if (!target) return undefined;
+		const originalTarget = this._getMaxTarget().values().next().value;
+		if (
+			originalTarget.connection === target.connection &&
+			originalTarget.export === target.export
+		) {
+			return undefined;
+		}
+		this._target.clear();
+		this._target.set(undefined, {
+			connection: updateOriginalConnection
+				? updateOriginalConnection(target)
+				: target.connection,
+			export: target.export,
+			priority: 0
+		});
+		return target;
 	}
-}
-
-// TODO remove in webpack 6
-/** @type {WeakMap<Module, ModuleGraph>} */
-const moduleGraphForModuleMap = new WeakMap();
-
-// TODO remove in webpack 6
-/** @type {Map<string, (module: Module) => ModuleGraph>} */
-const deprecateMap = new Map();
-
-module.exports = ModuleGraph;
-module.exports.ModuleGraphConnection = ModuleGraphConnection;
-
-
-/***/ }),
-
-/***/ 40639:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	createNestedExportsInfo() {
+		if (this.exportsInfoOwned) return this.exportsInfo;
+		this.exportsInfoOwned = true;
+		const oldExportsInfo = this.exportsInfo;
+		this.exportsInfo = new ExportsInfo();
+		this.exportsInfo.setHasProvideInfo();
+		if (oldExportsInfo) {
+			this.exportsInfo.setRedirectNamedTo(oldExportsInfo);
+		}
+		return this.exportsInfo;
+	}
 
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+	getNestedExportsInfo() {
+		return this.exportsInfo;
+	}
 
-/**
- * Module itself is not connected, but transitive modules are connected transitively.
- */
-const TRANSITIVE_ONLY = Symbol("transitive only");
+	hasInfo(baseInfo, runtime) {
+		return (
+			(this._usedName && this._usedName !== this.name) ||
+			this.provided ||
+			this.terminalBinding ||
+			this.getUsed(runtime) !== baseInfo.getUsed(runtime)
+		);
+	}
 
-/**
- * While determining the active state, this flag is used to signal a circular connection.
- */
-const CIRCULAR_CONNECTION = Symbol("circular connection");
+	updateHash(hash, runtime) {
+		this._updateHash(hash, runtime, new Set());
+	}
 
-/** @typedef {boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION} ConnectionState */
+	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+		hash.update(
+			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
+				this.terminalBinding
+			}`
+		);
+		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
+			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
+		}
+	}
 
-/**
- * @param {ConnectionState} a first
- * @param {ConnectionState} b second
- * @returns {ConnectionState} merged
- */
-const addConnectionStates = (a, b) => {
-	if (a === true || b === true) return true;
-	if (a === false) return b;
-	if (b === false) return a;
-	if (a === TRANSITIVE_ONLY) return b;
-	if (b === TRANSITIVE_ONLY) return a;
-	return a;
-};
-
-/**
- * @param {ConnectionState} a first
- * @param {ConnectionState} b second
- * @returns {ConnectionState} intersected
- */
-const intersectConnectionStates = (a, b) => {
-	if (a === false || b === false) return false;
-	if (a === true) return b;
-	if (b === true) return a;
-	if (a === CIRCULAR_CONNECTION) return b;
-	if (b === CIRCULAR_CONNECTION) return a;
-	return a;
-};
-
-class ModuleGraphConnection {
-	/**
-	 * @param {Module|null} originModule the referencing module
-	 * @param {Dependency|null} dependency the referencing dependency
-	 * @param {Module} module the referenced module
-	 * @param {string=} explanation some extra detail
-	 * @param {boolean=} weak the reference is weak
-	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
-	 */
-	constructor(
-		originModule,
-		dependency,
-		module,
-		explanation,
-		weak = false,
-		condition = undefined
-	) {
-		this.originModule = originModule;
-		this.resolvedOriginModule = originModule;
-		this.dependency = dependency;
-		this.resolvedModule = module;
-		this.module = module;
-		this.weak = weak;
-		this.conditional = !!condition;
-		this._active = condition !== false;
-		/** @type {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} */
-		this.condition = condition || undefined;
-		/** @type {Set<string>} */
-		this.explanations = undefined;
-		if (explanation) {
-			this.explanations = new Set();
-			this.explanations.add(explanation);
+	getUsedInfo() {
+		if (this._globalUsed !== undefined) {
+			switch (this._globalUsed) {
+				case UsageState.Unused:
+					return "unused";
+				case UsageState.NoInfo:
+					return "no usage info";
+				case UsageState.Unknown:
+					return "maybe used (runtime-defined)";
+				case UsageState.Used:
+					return "used";
+				case UsageState.OnlyPropertiesUsed:
+					return "only properties used";
+			}
+		} else if (this._usedInRuntime !== undefined) {
+			/** @type {Map<RuntimeUsageStateType, string[]>} */
+			const map = new Map();
+			for (const [runtime, used] of this._usedInRuntime) {
+				const list = map.get(used);
+				if (list !== undefined) list.push(runtime);
+				else map.set(used, [runtime]);
+			}
+			const specificInfo = Array.from(map, ([used, runtimes]) => {
+				switch (used) {
+					case UsageState.NoInfo:
+						return `no usage info in ${runtimes.join(", ")}`;
+					case UsageState.Unknown:
+						return `maybe used in ${runtimes.join(", ")} (runtime-defined)`;
+					case UsageState.Used:
+						return `used in ${runtimes.join(", ")}`;
+					case UsageState.OnlyPropertiesUsed:
+						return `only properties used in ${runtimes.join(", ")}`;
+				}
+			});
+			if (specificInfo.length > 0) {
+				return specificInfo.join("; ");
+			}
 		}
+		return this._hasUseInRuntimeInfo ? "unused" : "no usage info";
 	}
 
-	clone() {
-		const clone = new ModuleGraphConnection(
-			this.resolvedOriginModule,
-			this.dependency,
-			this.resolvedModule,
-			undefined,
-			this.weak,
-			this.condition
-		);
-		clone.originModule = this.originModule;
-		clone.module = this.module;
-		clone.conditional = this.conditional;
-		clone._active = this._active;
-		if (this.explanations) clone.explanations = new Set(this.explanations);
-		return clone;
-	}
-
-	/**
-	 * @param {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} condition condition for the connection
-	 * @returns {void}
-	 */
-	addCondition(condition) {
-		if (this.conditional) {
-			const old = this.condition;
-			this.condition = (c, r) =>
-				intersectConnectionStates(old(c, r), condition(c, r));
-		} else if (this._active) {
-			this.conditional = true;
-			this.condition = condition;
+	getProvidedInfo() {
+		switch (this.provided) {
+			case undefined:
+				return "no provided info";
+			case null:
+				return "maybe provided (runtime-defined)";
+			case true:
+				return "provided";
+			case false:
+				return "not provided";
 		}
 	}
 
-	/**
-	 * @param {string} explanation the explanation to add
-	 * @returns {void}
-	 */
-	addExplanation(explanation) {
-		if (this.explanations === undefined) {
-			this.explanations = new Set();
+	getRenameInfo() {
+		if (this._usedName !== null && this._usedName !== this.name) {
+			return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`;
 		}
-		this.explanations.add(explanation);
+		switch (this.canMangleProvide) {
+			case undefined:
+				switch (this.canMangleUse) {
+					case undefined:
+						return "missing provision and use info prevents renaming";
+					case false:
+						return "usage prevents renaming (no provision info)";
+					case true:
+						return "missing provision info prevents renaming";
+				}
+				break;
+			case true:
+				switch (this.canMangleUse) {
+					case undefined:
+						return "missing usage info prevents renaming";
+					case false:
+						return "usage prevents renaming";
+					case true:
+						return "could be renamed";
+				}
+				break;
+			case false:
+				switch (this.canMangleUse) {
+					case undefined:
+						return "provision prevents renaming (no use info)";
+					case false:
+						return "usage and provision prevents renaming";
+					case true:
+						return "provision prevents renaming";
+				}
+				break;
+		}
+		throw new Error(
+			`Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}`
+		);
 	}
+}
 
-	get explanation() {
-		if (this.explanations === undefined) return "";
-		return Array.from(this.explanations).join(" ");
-	}
+module.exports = ExportsInfo;
+module.exports.ExportInfo = ExportInfo;
+module.exports.UsageState = UsageState;
 
-	// TODO webpack 5 remove
-	get active() {
-		throw new Error("Use getActiveState instead");
-	}
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, if the connection is active
-	 */
-	isActive(runtime) {
-		if (!this.conditional) return this._active;
-		return this.condition(this, runtime) !== false;
-	}
+/***/ }),
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, if the connection is active
-	 */
-	isTargetActive(runtime) {
-		if (!this.conditional) return this._active;
-		return this.condition(this, runtime) === true;
-	}
+/***/ 7145:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ConnectionState} true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active
-	 */
-	getActiveState(runtime) {
-		if (!this.conditional) return this._active;
-		return this.condition(this, runtime);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ConstDependency = __webpack_require__(76911);
+const ExportsInfoDependency = __webpack_require__(78988);
 
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class ExportsInfoApiPlugin {
 	/**
-	 * @param {boolean} value active or not
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	setActive(value) {
-		this.conditional = false;
-		this._active = value;
-	}
-
-	set active(value) {
-		throw new Error("Use setActive instead");
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ExportsInfoApiPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ExportsInfoDependency,
+					new ExportsInfoDependency.Template()
+				);
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.expressionMemberChain
+						.for("__webpack_exports_info__")
+						.tap("ExportsInfoApiPlugin", (expr, members) => {
+							const dep =
+								members.length >= 2
+									? new ExportsInfoDependency(
+											expr.range,
+											members.slice(0, -1),
+											members[members.length - 1]
+									  )
+									: new ExportsInfoDependency(expr.range, null, members[0]);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+					parser.hooks.expression
+						.for("__webpack_exports_info__")
+						.tap("ExportsInfoApiPlugin", expr => {
+							const dep = new ConstDependency("true", expr.range);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ExportsInfoApiPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ExportsInfoApiPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ExportsInfoApiPlugin", handler);
+			}
+		);
 	}
 }
 
-/** @typedef {typeof TRANSITIVE_ONLY} TRANSITIVE_ONLY */
-/** @typedef {typeof CIRCULAR_CONNECTION} CIRCULAR_CONNECTION */
-
-module.exports = ModuleGraphConnection;
-module.exports.addConnectionStates = addConnectionStates;
-module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ (
-	TRANSITIVE_ONLY
-);
-module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ (
-	CIRCULAR_CONNECTION
-);
+module.exports = ExportsInfoApiPlugin;
 
 
 /***/ }),
 
-/***/ 3454:
+/***/ 73071:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -46416,449 +43105,739 @@ module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ (
 
 
 
-const { ConcatSource, RawSource, CachedSource } = __webpack_require__(51255);
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const ConcatenationScope = __webpack_require__(98229);
 const { UsageState } = __webpack_require__(63686);
-const Template = __webpack_require__(1626);
-const JavascriptModulesPlugin = __webpack_require__(89464);
+const InitFragment = __webpack_require__(55870);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const StaticExportsDependency = __webpack_require__(91418);
+const createHash = __webpack_require__(49835);
+const extractUrlAndGlobal = __webpack_require__(11850);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { register } = __webpack_require__(8282);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./RequestShortener")} RequestShortener */
-
-const joinIterableWithComma = iterable => {
-	// This is more performant than Array.from().join(", ")
-	// as it doesn't create an array
-	let str = "";
-	let first = true;
-	for (const item of iterable) {
-		if (first) {
-			first = false;
-		} else {
-			str += ", ";
-		}
-		str += item;
-	}
-	return str;
-};
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {typeof import("./util/Hash")} HashConstructor */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @param {ConcatSource} source output
- * @param {string} indent spacing
- * @param {ExportsInfo} exportsInfo data
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @param {RequestShortener} requestShortener requestShortener
- * @param {Set<ExportInfo>} alreadyPrinted deduplication set
- * @returns {void}
+ * @typedef {Object} SourceData
+ * @property {boolean=} iife
+ * @property {string=} init
+ * @property {string} expression
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {ReadonlySet<string>=} runtimeRequirements
  */
-const printExportsInfoToSource = (
-	source,
-	indent,
-	exportsInfo,
-	moduleGraph,
-	requestShortener,
-	alreadyPrinted = new Set()
-) => {
-	const otherExportsInfo = exportsInfo.otherExportsInfo;
 
-	let alreadyPrintedExports = 0;
+const TYPES = new Set(["javascript"]);
+const CSS_TYPES = new Set(["css-import"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
+const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
+	RuntimeGlobals.definePropertyGetters
+]);
+const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
 
-	// determine exports to print
-	const printedExports = [];
-	for (const exportInfo of exportsInfo.orderedExports) {
-		if (!alreadyPrinted.has(exportInfo)) {
-			alreadyPrinted.add(exportInfo);
-			printedExports.push(exportInfo);
-		} else {
-			alreadyPrintedExports++;
-		}
+/**
+ * @param {string|string[]} variableName the variable name or path
+ * @param {string} type the module system
+ * @returns {SourceData} the generated source
+ */
+const getSourceForGlobalVariableExternal = (variableName, type) => {
+	if (!Array.isArray(variableName)) {
+		// make it an array as the look up works the same basically
+		variableName = [variableName];
 	}
-	let showOtherExports = false;
-	if (!alreadyPrinted.has(otherExportsInfo)) {
-		alreadyPrinted.add(otherExportsInfo);
-		showOtherExports = true;
-	} else {
-		alreadyPrintedExports++;
+
+	// needed for e.g. window["some"]["thing"]
+	const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join("");
+	return {
+		iife: type === "this",
+		expression: `${type}${objectLookup}`
+	};
+};
+
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
+ */
+const getSourceForCommonJsExternal = moduleAndSpecifiers => {
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
+		};
 	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
+			moduleAndSpecifiers,
+			1
+		)}`
+	};
+};
 
-	// print the exports
-	for (const exportInfo of printedExports) {
-		const target = exportInfo.getTarget(moduleGraph);
-		source.add(
-			Template.toComment(
-				`${indent}export ${JSON.stringify(exportInfo.name).slice(
-					1,
-					-1
-				)} [${exportInfo.getProvidedInfo()}] [${exportInfo.getUsedInfo()}] [${exportInfo.getRenameInfo()}]${
-					target
-						? ` -> ${target.module.readableIdentifier(requestShortener)}${
-								target.export
-									? ` .${target.export
-											.map(e => JSON.stringify(e).slice(1, -1))
-											.join(".")}`
-									: ""
-						  }`
-						: ""
-				}`
-			) + "\n"
-		);
-		if (exportInfo.exportsInfo) {
-			printExportsInfoToSource(
-				source,
-				indent + "  ",
-				exportInfo.exportsInfo,
-				moduleGraph,
-				requestShortener,
-				alreadyPrinted
-			);
-		}
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
+ */
+const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
+	const chunkInitFragments = [
+		new InitFragment(
+			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		)
+	];
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+				moduleAndSpecifiers
+			)})`,
+			chunkInitFragments
+		};
 	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+			moduleName
+		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
+		chunkInitFragments
+	};
+};
 
-	if (alreadyPrintedExports) {
-		source.add(
-			Template.toComment(
-				`${indent}... (${alreadyPrintedExports} already listed exports)`
-			) + "\n"
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
+ */
+const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
+	const importName = runtimeTemplate.outputOptions.importFunctionName;
+	if (!runtimeTemplate.supportsDynamicImport() && importName === "import") {
+		throw new Error(
+			"The target environment doesn't support 'import()' so it's not possible to use external type 'import'"
 		);
 	}
-
-	if (showOtherExports) {
-		const target = otherExportsInfo.getTarget(moduleGraph);
-		if (
-			target ||
-			otherExportsInfo.provided !== false ||
-			otherExportsInfo.getUsed(undefined) !== UsageState.Unused
-		) {
-			const title =
-				printedExports.length > 0 || alreadyPrintedExports > 0
-					? "other exports"
-					: "exports";
-			source.add(
-				Template.toComment(
-					`${indent}${title} [${otherExportsInfo.getProvidedInfo()}] [${otherExportsInfo.getUsedInfo()}]${
-						target
-							? ` -> ${target.module.readableIdentifier(requestShortener)}`
-							: ""
-					}`
-				) + "\n"
-			);
-		}
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers)});`
+		};
+	}
+	if (moduleAndSpecifiers.length === 1) {
+		return {
+			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers[0])});`
+		};
 	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `${importName}(${JSON.stringify(
+			moduleName
+		)}).then(${runtimeTemplate.returningFunction(
+			`module${propertyAccess(moduleAndSpecifiers, 1)}`,
+			"module"
+		)});`
+	};
 };
 
-/** @type {WeakMap<RequestShortener, WeakMap<Module, { header: RawSource, full: WeakMap<Source, CachedSource> }>>} */
-const caches = new WeakMap();
-
-class ModuleInfoHeaderPlugin {
+class ModuleExternalInitFragment extends InitFragment {
 	/**
-	 * @param {boolean=} verbose add more information like exports, runtime requirements and bailouts
+	 * @param {string} request import source
+	 * @param {string=} ident recomputed ident
+	 * @param {string | HashConstructor=} hashFunction the hash function to use
 	 */
-	constructor(verbose = true) {
-		this._verbose = verbose;
+	constructor(request, ident, hashFunction = "md4") {
+		if (ident === undefined) {
+			ident = Template.toIdentifier(request);
+			if (ident !== request) {
+				ident += `_${createHash(hashFunction)
+					.update(request)
+					.digest("hex")
+					.slice(0, 8)}`;
+			}
+		}
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
+		super(
+			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			`external module import ${ident}`
+		);
+		this._ident = ident;
+		this._identifier = identifier;
+		this._request = request;
 	}
-	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { _verbose: verbose } = this;
-		compiler.hooks.compilation.tap("ModuleInfoHeaderPlugin", compilation => {
-			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-			hooks.renderModulePackage.tap(
-				"ModuleInfoHeaderPlugin",
-				(
-					moduleSource,
-					module,
-					{ chunk, chunkGraph, moduleGraph, runtimeTemplate }
-				) => {
-					const { requestShortener } = runtimeTemplate;
-					let cacheEntry;
-					let cache = caches.get(requestShortener);
-					if (cache === undefined) {
-						caches.set(requestShortener, (cache = new WeakMap()));
-						cache.set(
-							module,
-							(cacheEntry = { header: undefined, full: new WeakMap() })
-						);
-					} else {
-						cacheEntry = cache.get(module);
-						if (cacheEntry === undefined) {
-							cache.set(
-								module,
-								(cacheEntry = { header: undefined, full: new WeakMap() })
-							);
-						} else if (!verbose) {
-							const cachedSource = cacheEntry.full.get(moduleSource);
-							if (cachedSource !== undefined) return cachedSource;
-						}
-					}
-					const source = new ConcatSource();
-					let header = cacheEntry.header;
-					if (header === undefined) {
-						const req = module.readableIdentifier(requestShortener);
-						const reqStr = req.replace(/\*\//g, "*_/");
-						const reqStrStar = "*".repeat(reqStr.length);
-						const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
-						header = new RawSource(headerStr);
-						cacheEntry.header = header;
-					}
-					source.add(header);
-					if (verbose) {
-						const exportsType = module.buildMeta.exportsType;
-						source.add(
-							Template.toComment(
-								exportsType
-									? `${exportsType} exports`
-									: "unknown exports (runtime-defined)"
-							) + "\n"
-						);
-						if (exportsType) {
-							const exportsInfo = moduleGraph.getExportsInfo(module);
-							printExportsInfoToSource(
-								source,
-								"",
-								exportsInfo,
-								moduleGraph,
-								requestShortener
-							);
-						}
-						source.add(
-							Template.toComment(
-								`runtime requirements: ${joinIterableWithComma(
-									chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime)
-								)}`
-							) + "\n"
-						);
-						const optimizationBailout =
-							moduleGraph.getOptimizationBailout(module);
-						if (optimizationBailout) {
-							for (const text of optimizationBailout) {
-								let code;
-								if (typeof text === "function") {
-									code = text(requestShortener);
-								} else {
-									code = text;
-								}
-								source.add(Template.toComment(`${code}`) + "\n");
-							}
-						}
-						source.add(moduleSource);
-						return source;
-					} else {
-						source.add(moduleSource);
-						const cachedSource = new CachedSource(source);
-						cacheEntry.full.set(moduleSource, cachedSource);
-						return cachedSource;
-					}
-				}
-			);
-			hooks.chunkHash.tap("ModuleInfoHeaderPlugin", (chunk, hash) => {
-				hash.update("ModuleInfoHeaderPlugin");
-				hash.update("1");
-			});
-		});
+
+	getNamespaceIdentifier() {
+		return this._identifier;
 	}
 }
-module.exports = ModuleInfoHeaderPlugin;
-
-
-/***/ }),
 
-/***/ 32882:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
+register(
+	ModuleExternalInitFragment,
+	"webpack/lib/ExternalModule",
+	"ModuleExternalInitFragment",
+	{
+		serialize(obj, { write }) {
+			write(obj._request);
+			write(obj._ident);
+		},
+		deserialize({ read }) {
+			return new ModuleExternalInitFragment(read(), read());
+		}
+	}
+);
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+const generateModuleRemapping = (input, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
+		const properties = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const used = exportInfo.getUsedName(exportInfo.name, runtime);
+			if (!used) continue;
+			const nestedInfo = exportInfo.getNestedExportsInfo();
+			if (nestedInfo) {
+				const nestedExpr = generateModuleRemapping(
+					`${input}${propertyAccess([exportInfo.name])}`,
+					nestedInfo
+				);
+				if (nestedExpr) {
+					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
+					continue;
+				}
+			}
+			properties.push(
+				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
+					exportInfo.name
+				])}`
+			);
+		}
+		return `x({ ${properties.join(", ")} })`;
+	}
+};
 
-const previouslyPolyfilledBuiltinModules = {
-	assert: "assert/",
-	buffer: "buffer/",
-	console: "console-browserify",
-	constants: "constants-browserify",
-	crypto: "crypto-browserify",
-	domain: "domain-browser",
-	events: "events/",
-	http: "stream-http",
-	https: "https-browserify",
-	os: "os-browserify/browser",
-	path: "path-browserify",
-	punycode: "punycode/",
-	process: "process/browser",
-	querystring: "querystring-es3",
-	stream: "stream-browserify",
-	_stream_duplex: "readable-stream/duplex",
-	_stream_passthrough: "readable-stream/passthrough",
-	_stream_readable: "readable-stream/readable",
-	_stream_transform: "readable-stream/transform",
-	_stream_writable: "readable-stream/writable",
-	string_decoder: "string_decoder/",
-	sys: "util/",
-	timers: "timers-browserify",
-	tty: "tty-browserify",
-	url: "url/",
-	util: "util/",
-	vm: "vm-browserify",
-	zlib: "browserify-zlib"
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ExportsInfo} exportsInfo exports info of this module
+ * @param {RuntimeSpec} runtime the runtime
+ * @param {string | HashConstructor=} hashFunction the hash function to use
+ * @returns {SourceData} the generated source
+ */
+const getSourceForModuleExternal = (
+	moduleAndSpecifiers,
+	exportsInfo,
+	runtime,
+	hashFunction
+) => {
+	if (!Array.isArray(moduleAndSpecifiers))
+		moduleAndSpecifiers = [moduleAndSpecifiers];
+	const initFragment = new ModuleExternalInitFragment(
+		moduleAndSpecifiers[0],
+		undefined,
+		hashFunction
+	);
+	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
+		moduleAndSpecifiers,
+		1
+	)}`;
+	const moduleRemapping = generateModuleRemapping(
+		baseAccess,
+		exportsInfo,
+		runtime
+	);
+	let expression = moduleRemapping || baseAccess;
+	return {
+		expression,
+		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
+		runtimeRequirements: moduleRemapping
+			? RUNTIME_REQUIREMENTS_FOR_MODULE
+			: undefined,
+		chunkInitFragments: [initFragment]
+	};
 };
 
-class ModuleNotFoundError extends WebpackError {
-	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {Error&any} err error thrown
-	 * @param {DependencyLocation} loc location of dependency
-	 */
-	constructor(module, err, loc) {
-		let message = `Module not found: ${err.toString()}`;
+/**
+ * @param {string|string[]} urlAndGlobal the script request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
+ */
+const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
+	if (typeof urlAndGlobal === "string") {
+		urlAndGlobal = extractUrlAndGlobal(urlAndGlobal);
+	}
+	const url = urlAndGlobal[0];
+	const globalName = urlAndGlobal[1];
+	return {
+		init: "var __webpack_error__ = new Error();",
+		expression: `new Promise(${runtimeTemplate.basicFunction(
+			"resolve, reject",
+			[
+				`if(typeof ${globalName} !== "undefined") return resolve();`,
+				`${RuntimeGlobals.loadScript}(${JSON.stringify(
+					url
+				)}, ${runtimeTemplate.basicFunction("event", [
+					`if(typeof ${globalName} !== "undefined") return resolve();`,
+					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+					"var realSrc = event && event.target && event.target.src;",
+					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
+					"__webpack_error__.name = 'ScriptExternalLoadError';",
+					"__webpack_error__.type = errorType;",
+					"__webpack_error__.request = realSrc;",
+					"reject(__webpack_error__);"
+				])}, ${JSON.stringify(globalName)});`
+			]
+		)}).then(${runtimeTemplate.returningFunction(
+			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
+		)})`,
+		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
+	};
+};
 
-		// TODO remove in webpack 6
-		const match = err.message.match(/Can't resolve '([^']+)'/);
-		if (match) {
-			const request = match[1];
-			const alias = previouslyPolyfilledBuiltinModules[request];
-			if (alias) {
-				const pathIndex = alias.indexOf("/");
-				const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
-				message +=
-					"\n\n" +
-					"BREAKING CHANGE: " +
-					"webpack < 5 used to include polyfills for node.js core modules by default.\n" +
-					"This is no longer the case. Verify if you need this module and configure a polyfill for it.\n\n";
-				message +=
-					"If you want to include a polyfill, you need to:\n" +
-					`\t- add a fallback 'resolve.fallback: { "${request}": require.resolve("${alias}") }'\n` +
-					`\t- install '${dependency}'\n`;
-				message +=
-					"If you don't want to include a polyfill, you can use an empty module like this:\n" +
-					`\tresolve.fallback: { "${request}": false }`;
-			}
-		}
+/**
+ * @param {string} variableName the variable name to check
+ * @param {string} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {string} the generated source
+ */
+const checkExternalVariable = (variableName, request, runtimeTemplate) => {
+	return `if(typeof ${variableName} === 'undefined') { ${runtimeTemplate.throwMissingModuleErrorBlock(
+		{ request }
+	)} }\n`;
+};
 
-		super(message);
+/**
+ * @param {string|number} id the module id
+ * @param {boolean} optional true, if the module is optional
+ * @param {string|string[]} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
+ */
+const getSourceForAmdOrUmdExternal = (
+	id,
+	optional,
+	request,
+	runtimeTemplate
+) => {
+	const externalVariable = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+		`${id}`
+	)}__`;
+	return {
+		init: optional
+			? checkExternalVariable(
+					externalVariable,
+					Array.isArray(request) ? request.join(".") : request,
+					runtimeTemplate
+			  )
+			: undefined,
+		expression: externalVariable
+	};
+};
 
-		this.name = "ModuleNotFoundError";
-		this.details = err.details;
-		this.module = module;
-		this.error = err;
-		this.loc = loc;
+/**
+ * @param {boolean} optional true, if the module is optional
+ * @param {string|string[]} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
+ */
+const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
+	if (!Array.isArray(request)) {
+		// make it an array as the look up works the same basically
+		request = [request];
 	}
-}
-
-module.exports = ModuleNotFoundError;
 
+	const variableName = request[0];
+	const objectLookup = propertyAccess(request, 1);
+	return {
+		init: optional
+			? checkExternalVariable(variableName, request.join("."), runtimeTemplate)
+			: undefined,
+		expression: `${variableName}${objectLookup}`
+	};
+};
 
-/***/ }),
+class ExternalModule extends Module {
+	constructor(request, type, userRequest) {
+		super("javascript/dynamic", null);
 
-/***/ 58443:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// Info from Factory
+		/** @type {string | string[] | Record<string, string | string[]>} */
+		this.request = request;
+		/** @type {string} */
+		this.externalType = type;
+		/** @type {string} */
+		this.userRequest = userRequest;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return this.externalType === "css-import" ? CSS_TYPES : TYPES;
+	}
 
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return this.userRequest;
+	}
 
+	/**
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
+	 */
+	chunkCondition(chunk, { chunkGraph }) {
+		return this.externalType === "css-import"
+			? true
+			: chunkGraph.getNumberOfEntryModules(chunk) > 0;
+	}
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
+	}
 
-const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return "external " + JSON.stringify(this.request);
+	}
 
-class ModuleParseError extends WebpackError {
 	/**
-	 * @param {string | Buffer} source source code
-	 * @param {Error&any} err the parse error
-	 * @param {string[]} loaders the loaders used
-	 * @param {string} type module type
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
 	 */
-	constructor(source, err, loaders, type) {
-		let message = "Module parse failed: " + (err && err.message);
-		let loc = undefined;
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
 
-		if (
-			((Buffer.isBuffer(source) && source.slice(0, 4).equals(WASM_HEADER)) ||
-				(typeof source === "string" && /^\0asm/.test(source))) &&
-			!type.startsWith("webassembly")
-		) {
-			message +=
-				"\nThe module seem to be a WebAssembly module, but module is not flagged as WebAssembly module for webpack.";
-			message +=
-				"\nBREAKING CHANGE: Since webpack 5 WebAssembly is not enabled by default and flagged as experimental feature.";
-			message +=
-				"\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
-			message +=
-				"\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
-		} else if (!loaders) {
-			message +=
-				"\nYou may need an appropriate loader to handle this file type.";
-		} else if (loaders.length >= 1) {
-			message += `\nFile was processed with these loaders:${loaders
-				.map(loader => `\n * ${loader}`)
-				.join("")}`;
-			message +=
-				"\nYou may need an additional loader to handle the result of these loaders.";
-		} else {
-			message +=
-				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {
+			async: false,
+			exportsType: undefined
+		};
+		this.buildInfo = {
+			strict: true,
+			topLevelDeclarations: new Set(),
+			module: compilation.outputOptions.module
+		};
+		const { request, externalType } = this._getRequestAndExternalType();
+		this.buildMeta.exportsType = "dynamic";
+		let canMangle = false;
+		this.clearDependenciesAndBlocks();
+		switch (externalType) {
+			case "this":
+				this.buildInfo.strict = false;
+				break;
+			case "system":
+				if (!Array.isArray(request) || request.length === 1) {
+					this.buildMeta.exportsType = "namespace";
+					canMangle = true;
+				}
+				break;
+			case "module":
+				if (this.buildInfo.module) {
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = true;
+					}
+				} else {
+					this.buildMeta.async = true;
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = false;
+					}
+				}
+				break;
+			case "script":
+			case "promise":
+				this.buildMeta.async = true;
+				break;
+			case "import":
+				this.buildMeta.async = true;
+				if (!Array.isArray(request) || request.length === 1) {
+					this.buildMeta.exportsType = "namespace";
+					canMangle = false;
+				}
+				break;
 		}
+		this.addDependency(new StaticExportsDependency(true, canMangle));
+		callback();
+	}
 
-		if (
-			err &&
-			err.loc &&
-			typeof err.loc === "object" &&
-			typeof err.loc.line === "number"
-		) {
-			var lineNumber = err.loc.line;
+	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+	}
 
-			if (
-				Buffer.isBuffer(source) ||
-				/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)
-			) {
-				// binary file
-				message += "\n(Source code omitted for this binary file)";
-			} else {
-				const sourceLines = source.split(/\r?\n/);
-				const start = Math.max(0, lineNumber - 3);
-				const linesBefore = sourceLines.slice(start, lineNumber - 1);
-				const theLine = sourceLines[lineNumber - 1];
-				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
+	/**
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason({ moduleGraph }) {
+		switch (this.externalType) {
+			case "amd":
+			case "amd-require":
+			case "umd":
+			case "umd2":
+			case "system":
+			case "jsonp":
+				return `${this.externalType} externals can't be concatenated`;
+		}
+		return undefined;
+	}
 
-				message +=
-					linesBefore.map(l => `\n| ${l}`).join("") +
-					`\n> ${theLine}` +
-					linesAfter.map(l => `\n| ${l}`).join("");
+	_getRequestAndExternalType() {
+		let { request, externalType } = this;
+		if (typeof request === "object" && !Array.isArray(request))
+			request = request[externalType];
+		return { request, externalType };
+	}
+
+	_getSourceData(
+		request,
+		externalType,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime
+	) {
+		switch (externalType) {
+			case "this":
+			case "window":
+			case "self":
+				return getSourceForGlobalVariableExternal(request, this.externalType);
+			case "global":
+				return getSourceForGlobalVariableExternal(
+					request,
+					runtimeTemplate.globalObject
+				);
+			case "commonjs":
+			case "commonjs2":
+			case "commonjs-module":
+			case "commonjs-static":
+				return getSourceForCommonJsExternal(request);
+			case "node-commonjs":
+				return this.buildInfo.module
+					? getSourceForCommonJsExternalInNodeModule(request)
+					: getSourceForCommonJsExternal(request);
+			case "amd":
+			case "amd-require":
+			case "umd":
+			case "umd2":
+			case "system":
+			case "jsonp": {
+				const id = chunkGraph.getModuleId(this);
+				return getSourceForAmdOrUmdExternal(
+					id !== null ? id : this.identifier(),
+					this.isOptional(moduleGraph),
+					request,
+					runtimeTemplate
+				);
+			}
+			case "import":
+				return getSourceForImportExternal(request, runtimeTemplate);
+			case "script":
+				return getSourceForScriptExternal(request, runtimeTemplate);
+			case "module": {
+				if (!this.buildInfo.module) {
+					if (!runtimeTemplate.supportsDynamicImport()) {
+						throw new Error(
+							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
+								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
+									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+									: "")
+						);
+					}
+					return getSourceForImportExternal(request, runtimeTemplate);
+				}
+				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
+					throw new Error(
+						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
+					);
+				}
+				return getSourceForModuleExternal(
+					request,
+					moduleGraph.getExportsInfo(this),
+					runtime,
+					runtimeTemplate.outputOptions.hashFunction
+				);
+			}
+			case "var":
+			case "promise":
+			case "const":
+			case "let":
+			case "assign":
+			default:
+				return getSourceForDefaultCase(
+					this.isOptional(moduleGraph),
+					request,
+					runtimeTemplate
+				);
+		}
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime,
+		concatenationScope
+	}) {
+		const { request, externalType } = this._getRequestAndExternalType();
+		switch (externalType) {
+			case "asset": {
+				const sources = new Map();
+				sources.set(
+					"javascript",
+					new RawSource(`module.exports = ${JSON.stringify(request)};`)
+				);
+				const data = new Map();
+				data.set("url", request);
+				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
+			}
+			case "css-import": {
+				const sources = new Map();
+				sources.set(
+					"css-import",
+					new RawSource(`@import url(${JSON.stringify(request)});`)
+				);
+				return {
+					sources,
+					runtimeRequirements: EMPTY_RUNTIME_REQUIREMENTS
+				};
 			}
+			default: {
+				const sourceData = this._getSourceData(
+					request,
+					externalType,
+					runtimeTemplate,
+					moduleGraph,
+					chunkGraph,
+					runtime
+				);
 
-			loc = { start: err.loc };
-		} else if (err && err.stack) {
-			message += "\n" + err.stack;
+				let sourceString = sourceData.expression;
+				if (sourceData.iife)
+					sourceString = `(function() { return ${sourceString}; }())`;
+				if (concatenationScope) {
+					sourceString = `${
+						runtimeTemplate.supportsConst() ? "const" : "var"
+					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+					concatenationScope.registerNamespaceExport(
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					);
+				} else {
+					sourceString = `module.exports = ${sourceString};`;
+				}
+				if (sourceData.init)
+					sourceString = `${sourceData.init}\n${sourceString}`;
+
+				let data = undefined;
+				if (sourceData.chunkInitFragments) {
+					data = new Map();
+					data.set("chunkInitFragments", sourceData.chunkInitFragments);
+				}
+
+				const sources = new Map();
+				if (this.useSourceMap || this.useSimpleSourceMap) {
+					sources.set(
+						"javascript",
+						new OriginalSource(sourceString, this.identifier())
+					);
+				} else {
+					sources.set("javascript", new RawSource(sourceString));
+				}
+
+				let runtimeRequirements = sourceData.runtimeRequirements;
+				if (!concatenationScope) {
+					if (!runtimeRequirements) {
+						runtimeRequirements = RUNTIME_REQUIREMENTS;
+					} else {
+						const set = new Set(runtimeRequirements);
+						set.add(RuntimeGlobals.module);
+						runtimeRequirements = set;
+					}
+				}
+
+				return {
+					sources,
+					runtimeRequirements:
+						runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
+					data
+				};
+			}
 		}
+	}
 
-		super(message);
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
+	}
 
-		this.name = "ModuleParseError";
-		this.loc = loc;
-		this.error = err;
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph } = context;
+		hash.update(
+			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
+				chunkGraph.moduleGraph
+			)}`
+		);
+		super.updateHash(hash, context);
 	}
 
 	serialize(context) {
 		const { write } = context;
 
-		write(this.error);
+		write(this.request);
+		write(this.externalType);
+		write(this.userRequest);
 
 		super.serialize(context);
 	}
@@ -46866,21 +43845,23 @@ class ModuleParseError extends WebpackError {
 	deserialize(context) {
 		const { read } = context;
 
-		this.error = read();
+		this.request = read();
+		this.externalType = read();
+		this.userRequest = read();
 
 		super.deserialize(context);
 	}
 }
 
-makeSerializable(ModuleParseError, "webpack/lib/ModuleParseError");
+makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
-module.exports = ModuleParseError;
+module.exports = ExternalModule;
 
 
 /***/ }),
 
-/***/ 36418:
-/***/ (function(module) {
+/***/ 62153:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -46890,211 +43871,258 @@ module.exports = ModuleParseError;
 
 
 
-class ModuleProfile {
-	constructor() {
-		this.startTime = Date.now();
-
-		this.factoryStartTime = 0;
-		this.factoryEndTime = 0;
-		this.factory = 0;
-		this.factoryParallelismFactor = 0;
-
-		this.restoringStartTime = 0;
-		this.restoringEndTime = 0;
-		this.restoring = 0;
-		this.restoringParallelismFactor = 0;
-
-		this.integrationStartTime = 0;
-		this.integrationEndTime = 0;
-		this.integration = 0;
-		this.integrationParallelismFactor = 0;
-
-		this.buildingStartTime = 0;
-		this.buildingEndTime = 0;
-		this.building = 0;
-		this.buildingParallelismFactor = 0;
-
-		this.storingStartTime = 0;
-		this.storingEndTime = 0;
-		this.storing = 0;
-		this.storingParallelismFactor = 0;
-
-		this.additionalFactoryTimes = undefined;
-		this.additionalFactories = 0;
-		this.additionalFactoriesParallelismFactor = 0;
-
-		/** @deprecated */
-		this.additionalIntegration = 0;
-	}
-
-	markFactoryStart() {
-		this.factoryStartTime = Date.now();
-	}
-
-	markFactoryEnd() {
-		this.factoryEndTime = Date.now();
-		this.factory = this.factoryEndTime - this.factoryStartTime;
-	}
-
-	markRestoringStart() {
-		this.restoringStartTime = Date.now();
-	}
-
-	markRestoringEnd() {
-		this.restoringEndTime = Date.now();
-		this.restoring = this.restoringEndTime - this.restoringStartTime;
-	}
-
-	markIntegrationStart() {
-		this.integrationStartTime = Date.now();
-	}
+const util = __webpack_require__(73837);
+const ExternalModule = __webpack_require__(73071);
+const { resolveByProperty, cachedSetProperty } = __webpack_require__(60839);
 
-	markIntegrationEnd() {
-		this.integrationEndTime = Date.now();
-		this.integration = this.integrationEndTime - this.integrationStartTime;
-	}
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
-	markBuildingStart() {
-		this.buildingStartTime = Date.now();
-	}
+const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
+const EMPTY_RESOLVE_OPTIONS = {};
 
-	markBuildingEnd() {
-		this.buildingEndTime = Date.now();
-		this.building = this.buildingEndTime - this.buildingStartTime;
-	}
+// TODO webpack 6 remove this
+const callDeprecatedExternals = util.deprecate(
+	(externalsFunction, context, request, cb) => {
+		externalsFunction.call(null, context, request, cb);
+	},
+	"The externals-function should be defined like ({context, request}, cb) => { ... }",
+	"DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS"
+);
 
-	markStoringStart() {
-		this.storingStartTime = Date.now();
-	}
+const cache = new WeakMap();
 
-	markStoringEnd() {
-		this.storingEndTime = Date.now();
-		this.storing = this.storingEndTime - this.storingStartTime;
+const resolveLayer = (obj, layer) => {
+	let map = cache.get(obj);
+	if (map === undefined) {
+		map = new Map();
+		cache.set(obj, map);
+	} else {
+		const cacheEntry = map.get(layer);
+		if (cacheEntry !== undefined) return cacheEntry;
 	}
+	const result = resolveByProperty(obj, "byLayer", layer);
+	map.set(layer, result);
+	return result;
+};
 
-	// This depends on timing so we ignore it for coverage
-	/* istanbul ignore next */
+class ExternalModuleFactoryPlugin {
 	/**
-	 * Merge this profile into another one
-	 * @param {ModuleProfile} realProfile the profile to merge into
-	 * @returns {void}
+	 * @param {string | undefined} type default external type
+	 * @param {Externals} externals externals config
 	 */
-	mergeInto(realProfile) {
-		realProfile.additionalFactories = this.factory;
-		(realProfile.additionalFactoryTimes =
-			realProfile.additionalFactoryTimes || []).push({
-			start: this.factoryStartTime,
-			end: this.factoryEndTime
-		});
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
 	}
-}
-
-module.exports = ModuleProfile;
-
-
-/***/ }),
-
-/***/ 94560:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
 
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Module")} Module */
-
-class ModuleRestoreError extends WebpackError {
 	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {string | Error} err error thrown
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+	 * @returns {void}
 	 */
-	constructor(module, err) {
-		let message = "Module restore failed: ";
-		let details = undefined;
-		if (err !== null && typeof err === "object") {
-			if (typeof err.stack === "string" && err.stack) {
-				const stack = err.stack;
-				message += stack;
-			} else if (typeof err.message === "string" && err.message) {
-				message += err.message;
-			} else {
-				message += err;
-			}
-		} else {
-			message += String(err);
-		}
-
-		super(message);
-
-		this.name = "ModuleRestoreError";
-		this.details = details;
-		this.module = module;
-		this.error = err;
-	}
-}
-
-module.exports = ModuleRestoreError;
-
-
-/***/ }),
-
-/***/ 59001:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	apply(normalModuleFactory) {
+		const globalType = this.type;
+		normalModuleFactory.hooks.factorize.tapAsync(
+			"ExternalModuleFactoryPlugin",
+			(data, callback) => {
+				const context = data.context;
+				const contextInfo = data.contextInfo;
+				const dependency = data.dependencies[0];
+				const dependencyType = data.dependencyType;
 
+				/**
+				 * @param {string|string[]|boolean|Record<string, string|string[]>} value the external config
+				 * @param {string|undefined} type type of external
+				 * @param {function(Error=, ExternalModule=): void} callback callback
+				 * @returns {void}
+				 */
+				const handleExternal = (value, type, callback) => {
+					if (value === false) {
+						// Not externals, fallback to original factory
+						return callback();
+					}
+					/** @type {string | string[] | Record<string, string|string[]>} */
+					let externalConfig;
+					if (value === true) {
+						externalConfig = dependency.request;
+					} else {
+						externalConfig = value;
+					}
+					// When no explicit type is specified, extract it from the externalConfig
+					if (type === undefined) {
+						if (
+							typeof externalConfig === "string" &&
+							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig)
+						) {
+							const idx = externalConfig.indexOf(" ");
+							type = externalConfig.substr(0, idx);
+							externalConfig = externalConfig.substr(idx + 1);
+						} else if (
+							Array.isArray(externalConfig) &&
+							externalConfig.length > 0 &&
+							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig[0])
+						) {
+							const firstItem = externalConfig[0];
+							const idx = firstItem.indexOf(" ");
+							type = firstItem.substr(0, idx);
+							externalConfig = [
+								firstItem.substr(idx + 1),
+								...externalConfig.slice(1)
+							];
+						}
+					}
+					callback(
+						null,
+						new ExternalModule(
+							externalConfig,
+							type || globalType,
+							dependency.request
+						)
+					);
+				};
 
+				/**
+				 * @param {Externals} externals externals config
+				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
+				 * @returns {void}
+				 */
+				const handleExternals = (externals, callback) => {
+					if (typeof externals === "string") {
+						if (externals === dependency.request) {
+							return handleExternal(dependency.request, undefined, callback);
+						}
+					} else if (Array.isArray(externals)) {
+						let i = 0;
+						const next = () => {
+							let asyncFlag;
+							const handleExternalsAndCallback = (err, module) => {
+								if (err) return callback(err);
+								if (!module) {
+									if (asyncFlag) {
+										asyncFlag = false;
+										return;
+									}
+									return next();
+								}
+								callback(null, module);
+							};
 
-const WebpackError = __webpack_require__(53799);
+							do {
+								asyncFlag = true;
+								if (i >= externals.length) return callback();
+								handleExternals(externals[i++], handleExternalsAndCallback);
+							} while (!asyncFlag);
+							asyncFlag = false;
+						};
 
-/** @typedef {import("./Module")} Module */
+						next();
+						return;
+					} else if (externals instanceof RegExp) {
+						if (externals.test(dependency.request)) {
+							return handleExternal(dependency.request, undefined, callback);
+						}
+					} else if (typeof externals === "function") {
+						const cb = (err, value, type) => {
+							if (err) return callback(err);
+							if (value !== undefined) {
+								handleExternal(value, type, callback);
+							} else {
+								callback();
+							}
+						};
+						if (externals.length === 3) {
+							// TODO webpack 6 remove this
+							callDeprecatedExternals(
+								externals,
+								context,
+								dependency.request,
+								cb
+							);
+						} else {
+							const promise = externals(
+								{
+									context,
+									request: dependency.request,
+									dependencyType,
+									contextInfo,
+									getResolve: options => (context, request, callback) => {
+										const resolveContext = {
+											fileDependencies: data.fileDependencies,
+											missingDependencies: data.missingDependencies,
+											contextDependencies: data.contextDependencies
+										};
+										let resolver = normalModuleFactory.getResolver(
+											"normal",
+											dependencyType
+												? cachedSetProperty(
+														data.resolveOptions || EMPTY_RESOLVE_OPTIONS,
+														"dependencyType",
+														dependencyType
+												  )
+												: data.resolveOptions
+										);
+										if (options) resolver = resolver.withOptions(options);
+										if (callback) {
+											resolver.resolve(
+												{},
+												context,
+												request,
+												resolveContext,
+												callback
+											);
+										} else {
+											return new Promise((resolve, reject) => {
+												resolver.resolve(
+													{},
+													context,
+													request,
+													resolveContext,
+													(err, result) => {
+														if (err) reject(err);
+														else resolve(result);
+													}
+												);
+											});
+										}
+									}
+								},
+								cb
+							);
+							if (promise && promise.then) promise.then(r => cb(null, r), cb);
+						}
+						return;
+					} else if (typeof externals === "object") {
+						const resolvedExternals = resolveLayer(
+							externals,
+							contextInfo.issuerLayer
+						);
+						if (
+							Object.prototype.hasOwnProperty.call(
+								resolvedExternals,
+								dependency.request
+							)
+						) {
+							return handleExternal(
+								resolvedExternals[dependency.request],
+								undefined,
+								callback
+							);
+						}
+					}
+					callback();
+				};
 
-class ModuleStoreError extends WebpackError {
-	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {string | Error} err error thrown
-	 */
-	constructor(module, err) {
-		let message = "Module storing failed: ";
-		let details = undefined;
-		if (err !== null && typeof err === "object") {
-			if (typeof err.stack === "string" && err.stack) {
-				const stack = err.stack;
-				message += stack;
-			} else if (typeof err.message === "string" && err.message) {
-				message += err.message;
-			} else {
-				message += err;
+				handleExternals(this.externals, callback);
 			}
-		} else {
-			message += String(err);
-		}
-
-		super(message);
-
-		this.name = "ModuleStoreError";
-		this.details = details;
-		this.module = module;
-		this.error = err;
+		);
 	}
 }
-
-module.exports = ModuleStoreError;
+module.exports = ExternalModuleFactoryPlugin;
 
 
 /***/ }),
 
-/***/ 62677:
+/***/ 6652:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -47105,146 +44133,41 @@ module.exports = ModuleStoreError;
 
 
 
-const util = __webpack_require__(73837);
-const memoize = __webpack_require__(78676);
+const ExternalModuleFactoryPlugin = __webpack_require__(62153);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("./Compiler")} Compiler */
 
-const getJavascriptModulesPlugin = memoize(() =>
-	__webpack_require__(89464)
-);
+class ExternalsPlugin {
+	/**
+	 * @param {string | undefined} type default external type
+	 * @param {Externals} externals externals config
+	 */
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
+	}
 
-// TODO webpack 6: remove this class
-class ModuleTemplate {
 	/**
-	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {Compilation} compilation the compilation
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(runtimeTemplate, compilation) {
-		this._runtimeTemplate = runtimeTemplate;
-		this.type = "javascript";
-		this.hooks = Object.freeze({
-			content: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContent.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
-					"DEP_MODULE_TEMPLATE_CONTENT"
-				)
-			},
-			module: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContent.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
-					"DEP_MODULE_TEMPLATE_MODULE"
-				)
-			},
-			render: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContainer.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)",
-					"DEP_MODULE_TEMPLATE_RENDER"
-				)
-			},
-			package: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModulePackage.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)",
-					"DEP_MODULE_TEMPLATE_PACKAGE"
-				)
-			},
-			hash: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.fullHash.tap(options, fn);
-					},
-					"ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
-					"DEP_MODULE_TEMPLATE_HASH"
-				)
-			}
+	apply(compiler) {
+		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
+			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
+				normalModuleFactory
+			);
 		});
 	}
 }
 
-Object.defineProperty(ModuleTemplate.prototype, "runtimeTemplate", {
-	get: util.deprecate(
-		/**
-		 * @this {ModuleTemplate}
-		 * @returns {TODO} output options
-		 */
-		function () {
-			return this._runtimeTemplate;
-		},
-		"ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)",
-		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
-	)
-});
-
-module.exports = ModuleTemplate;
+module.exports = ExternalsPlugin;
 
 
 /***/ }),
 
-/***/ 11234:
+/***/ 79453:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -47255,5363 +44178,3564 @@ module.exports = ModuleTemplate;
 
 
 
-const { cleanUp } = __webpack_require__(59985);
-const WebpackError = __webpack_require__(53799);
+const { create: createResolver } = __webpack_require__(30662);
+const asyncLib = __webpack_require__(78175);
+const AsyncQueue = __webpack_require__(12260);
+const StackedCacheMap = __webpack_require__(64985);
+const createHash = __webpack_require__(49835);
+const { join, dirname, relative, lstatReadlinkAbsolute } = __webpack_require__(17139);
 const makeSerializable = __webpack_require__(33032);
+const processAsyncTree = __webpack_require__(42791);
 
-class ModuleWarning extends WebpackError {
-	/**
-	 * @param {Error} warning error thrown
-	 * @param {{from?: string|null}} info additional info
-	 */
-	constructor(warning, { from = null } = {}) {
-		let message = "Module Warning";
-
-		if (from) {
-			message += ` (from ${from}):\n`;
-		} else {
-			message += ": ";
-		}
-
-		if (warning && typeof warning === "object" && warning.message) {
-			message += warning.message;
-		} else if (warning) {
-			message += String(warning);
-		}
-
-		super(message);
-
-		this.name = "ModuleWarning";
-		this.warning = warning;
-		this.details =
-			warning && typeof warning === "object" && warning.stack
-				? cleanUp(warning.stack, this.message)
-				: undefined;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.warning);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.warning = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(ModuleWarning, "webpack/lib/ModuleWarning");
-
-module.exports = ModuleWarning;
-
-
-/***/ }),
-
-/***/ 33370:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").IStats} IStats */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
+const supportsEsm = +process.versions.modules >= 83;
 
+let FS_ACCURACY = 2000;
 
-const asyncLib = __webpack_require__(78175);
-const { SyncHook, MultiHook } = __webpack_require__(6967);
+const EMPTY_SET = new Set();
 
-const ConcurrentCompilationError = __webpack_require__(95735);
-const MultiStats = __webpack_require__(24170);
-const MultiWatching = __webpack_require__(81128);
-const ArrayQueue = __webpack_require__(41792);
+const RBDT_RESOLVE_CJS = 0;
+const RBDT_RESOLVE_ESM = 1;
+const RBDT_RESOLVE_DIRECTORY = 2;
+const RBDT_RESOLVE_CJS_FILE = 3;
+const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4;
+const RBDT_RESOLVE_ESM_FILE = 5;
+const RBDT_DIRECTORY = 6;
+const RBDT_FILE = 7;
+const RBDT_DIRECTORY_DEPENDENCIES = 8;
+const RBDT_FILE_DEPENDENCIES = 9;
 
-/** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
-/** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Stats")} Stats */
-/** @typedef {import("./Watching")} Watching */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+const INVALID = Symbol("invalid");
 
 /**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
+ * @typedef {Object} FileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {number=} timestamp
  */
 
 /**
- * @callback RunWithDependenciesHandler
- * @param {Compiler} compiler
- * @param {Callback<MultiStats>} callback
+ * @typedef {Object} ResolvedContextFileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {string=} timestampHash
  */
 
 /**
- * @typedef {Object} MultiCompilerOptions
- * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
+ * @typedef {Object} ContextFileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {ResolvedContextFileSystemInfoEntry=} resolved
+ * @property {Set<string>=} symlinks
  */
 
-module.exports = class MultiCompiler {
-	/**
-	 * @param {Compiler[] | Record<string, Compiler>} compilers child compilers
-	 * @param {MultiCompilerOptions} options options
-	 */
-	constructor(compilers, options) {
-		if (!Array.isArray(compilers)) {
-			compilers = Object.keys(compilers).map(name => {
-				compilers[name].name = name;
-				return compilers[name];
-			});
-		}
+/**
+ * @typedef {Object} TimestampAndHash
+ * @property {number} safeTime
+ * @property {number=} timestamp
+ * @property {string} hash
+ */
 
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[MultiStats]>} */
-			done: new SyncHook(["stats"]),
-			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
-			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
-			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			run: new MultiHook(compilers.map(c => c.hooks.run)),
-			/** @type {SyncHook<[]>} */
-			watchClose: new SyncHook([]),
-			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
-			/** @type {MultiHook<SyncBailHook<[string, string, any[]], true>>} */
-			infrastructureLog: new MultiHook(
-				compilers.map(c => c.hooks.infrastructureLog)
-			)
-		});
-		this.compilers = compilers;
-		/** @type {MultiCompilerOptions} */
-		this._options = {
-			parallelism: options.parallelism || Infinity
-		};
-		/** @type {WeakMap<Compiler, string[]>} */
-		this.dependencies = new WeakMap();
-		this.running = false;
+/**
+ * @typedef {Object} ResolvedContextTimestampAndHash
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {string} hash
+ */
 
-		/** @type {Stats[]} */
-		const compilerStats = this.compilers.map(() => null);
-		let doneCompilers = 0;
-		for (let index = 0; index < this.compilers.length; index++) {
-			const compiler = this.compilers[index];
-			const compilerIndex = index;
-			let compilerDone = false;
-			compiler.hooks.done.tap("MultiCompiler", stats => {
-				if (!compilerDone) {
-					compilerDone = true;
-					doneCompilers++;
-				}
-				compilerStats[compilerIndex] = stats;
-				if (doneCompilers === this.compilers.length) {
-					this.hooks.done.call(new MultiStats(compilerStats));
-				}
-			});
-			compiler.hooks.invalid.tap("MultiCompiler", () => {
-				if (compilerDone) {
-					compilerDone = false;
-					doneCompilers--;
+/**
+ * @typedef {Object} ContextTimestampAndHash
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {string} hash
+ * @property {ResolvedContextTimestampAndHash=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
+/**
+ * @typedef {Object} ContextHash
+ * @property {string} hash
+ * @property {string=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
+/**
+ * @typedef {Object} SnapshotOptimizationEntry
+ * @property {Snapshot} snapshot
+ * @property {number} shared
+ * @property {Set<string>} snapshotContent
+ * @property {Set<SnapshotOptimizationEntry>} children
+ */
+
+/**
+ * @typedef {Object} ResolveBuildDependenciesResult
+ * @property {Set<string>} files list of files
+ * @property {Set<string>} directories list of directories
+ * @property {Set<string>} missing list of missing entries
+ * @property {Map<string, string | false>} resolveResults stored resolve results
+ * @property {Object} resolveDependencies dependencies of the resolving
+ * @property {Set<string>} resolveDependencies.files list of files
+ * @property {Set<string>} resolveDependencies.directories list of directories
+ * @property {Set<string>} resolveDependencies.missing list of missing entries
+ */
+
+const DONE_ITERATOR_RESULT = new Set().keys().next();
+
+// cspell:word tshs
+// Tsh = Timestamp + Hash
+// Tshs = Timestamp + Hash combinations
+
+class SnapshotIterator {
+	constructor(next) {
+		this.next = next;
+	}
+}
+
+class SnapshotIterable {
+	constructor(snapshot, getMaps) {
+		this.snapshot = snapshot;
+		this.getMaps = getMaps;
+	}
+
+	[Symbol.iterator]() {
+		let state = 0;
+		/** @type {IterableIterator<string>} */
+		let it;
+		/** @type {(Snapshot) => (Map<string, any> | Set<string>)[]} */
+		let getMaps;
+		/** @type {(Map<string, any> | Set<string>)[]} */
+		let maps;
+		/** @type {Snapshot} */
+		let snapshot;
+		let queue;
+		return new SnapshotIterator(() => {
+			for (;;) {
+				switch (state) {
+					case 0:
+						snapshot = this.snapshot;
+						getMaps = this.getMaps;
+						maps = getMaps(snapshot);
+						state = 1;
+					/* falls through */
+					case 1:
+						if (maps.length > 0) {
+							const map = maps.pop();
+							if (map !== undefined) {
+								it = map.keys();
+								state = 2;
+							} else {
+								break;
+							}
+						} else {
+							state = 3;
+							break;
+						}
+					/* falls through */
+					case 2: {
+						const result = it.next();
+						if (!result.done) return result;
+						state = 1;
+						break;
+					}
+					case 3: {
+						const children = snapshot.children;
+						if (children !== undefined) {
+							if (children.size === 1) {
+								// shortcut for a single child
+								// avoids allocation of queue
+								for (const child of children) snapshot = child;
+								maps = getMaps(snapshot);
+								state = 1;
+								break;
+							}
+							if (queue === undefined) queue = [];
+							for (const child of children) {
+								queue.push(child);
+							}
+						}
+						if (queue !== undefined && queue.length > 0) {
+							snapshot = queue.pop();
+							maps = getMaps(snapshot);
+							state = 1;
+							break;
+						} else {
+							state = 4;
+						}
+					}
+					/* falls through */
+					case 4:
+						return DONE_ITERATOR_RESULT;
 				}
-			});
-		}
+			}
+		});
 	}
+}
 
-	get options() {
-		return Object.assign(
-			this.compilers.map(c => c.options),
-			this._options
-		);
+class Snapshot {
+	constructor() {
+		this._flags = 0;
+		/** @type {number | undefined} */
+		this.startTime = undefined;
+		/** @type {Map<string, FileSystemInfoEntry | null> | undefined} */
+		this.fileTimestamps = undefined;
+		/** @type {Map<string, string | null> | undefined} */
+		this.fileHashes = undefined;
+		/** @type {Map<string, TimestampAndHash | string | null> | undefined} */
+		this.fileTshs = undefined;
+		/** @type {Map<string, ResolvedContextFileSystemInfoEntry | null> | undefined} */
+		this.contextTimestamps = undefined;
+		/** @type {Map<string, string | null> | undefined} */
+		this.contextHashes = undefined;
+		/** @type {Map<string, ResolvedContextTimestampAndHash | null> | undefined} */
+		this.contextTshs = undefined;
+		/** @type {Map<string, boolean> | undefined} */
+		this.missingExistence = undefined;
+		/** @type {Map<string, string> | undefined} */
+		this.managedItemInfo = undefined;
+		/** @type {Set<string> | undefined} */
+		this.managedFiles = undefined;
+		/** @type {Set<string> | undefined} */
+		this.managedContexts = undefined;
+		/** @type {Set<string> | undefined} */
+		this.managedMissing = undefined;
+		/** @type {Set<Snapshot> | undefined} */
+		this.children = undefined;
 	}
 
-	get outputPath() {
-		let commonPath = this.compilers[0].outputPath;
-		for (const compiler of this.compilers) {
-			while (
-				compiler.outputPath.indexOf(commonPath) !== 0 &&
-				/[/\\]/.test(commonPath)
-			) {
-				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
+	hasStartTime() {
+		return (this._flags & 1) !== 0;
+	}
+
+	setStartTime(value) {
+		this._flags = this._flags | 1;
+		this.startTime = value;
+	}
+
+	setMergedStartTime(value, snapshot) {
+		if (value) {
+			if (snapshot.hasStartTime()) {
+				this.setStartTime(Math.min(value, snapshot.startTime));
+			} else {
+				this.setStartTime(value);
 			}
+		} else {
+			if (snapshot.hasStartTime()) this.setStartTime(snapshot.startTime);
 		}
+	}
 
-		if (!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
-		return commonPath;
+	hasFileTimestamps() {
+		return (this._flags & 2) !== 0;
 	}
 
-	get inputFileSystem() {
-		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
+	setFileTimestamps(value) {
+		this._flags = this._flags | 2;
+		this.fileTimestamps = value;
 	}
 
-	get outputFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	hasFileHashes() {
+		return (this._flags & 4) !== 0;
 	}
 
-	get watchFileSystem() {
-		throw new Error("Cannot read watchFileSystem of a MultiCompiler");
+	setFileHashes(value) {
+		this._flags = this._flags | 4;
+		this.fileHashes = value;
 	}
 
-	get intermediateFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	hasFileTshs() {
+		return (this._flags & 8) !== 0;
 	}
 
-	/**
-	 * @param {InputFileSystem} value the new input file system
-	 */
-	set inputFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.inputFileSystem = value;
+	setFileTshs(value) {
+		this._flags = this._flags | 8;
+		this.fileTshs = value;
+	}
+
+	hasContextTimestamps() {
+		return (this._flags & 0x10) !== 0;
+	}
+
+	setContextTimestamps(value) {
+		this._flags = this._flags | 0x10;
+		this.contextTimestamps = value;
+	}
+
+	hasContextHashes() {
+		return (this._flags & 0x20) !== 0;
+	}
+
+	setContextHashes(value) {
+		this._flags = this._flags | 0x20;
+		this.contextHashes = value;
+	}
+
+	hasContextTshs() {
+		return (this._flags & 0x40) !== 0;
+	}
+
+	setContextTshs(value) {
+		this._flags = this._flags | 0x40;
+		this.contextTshs = value;
+	}
+
+	hasMissingExistence() {
+		return (this._flags & 0x80) !== 0;
+	}
+
+	setMissingExistence(value) {
+		this._flags = this._flags | 0x80;
+		this.missingExistence = value;
+	}
+
+	hasManagedItemInfo() {
+		return (this._flags & 0x100) !== 0;
+	}
+
+	setManagedItemInfo(value) {
+		this._flags = this._flags | 0x100;
+		this.managedItemInfo = value;
+	}
+
+	hasManagedFiles() {
+		return (this._flags & 0x200) !== 0;
+	}
+
+	setManagedFiles(value) {
+		this._flags = this._flags | 0x200;
+		this.managedFiles = value;
+	}
+
+	hasManagedContexts() {
+		return (this._flags & 0x400) !== 0;
+	}
+
+	setManagedContexts(value) {
+		this._flags = this._flags | 0x400;
+		this.managedContexts = value;
+	}
+
+	hasManagedMissing() {
+		return (this._flags & 0x800) !== 0;
+	}
+
+	setManagedMissing(value) {
+		this._flags = this._flags | 0x800;
+		this.managedMissing = value;
+	}
+
+	hasChildren() {
+		return (this._flags & 0x1000) !== 0;
+	}
+
+	setChildren(value) {
+		this._flags = this._flags | 0x1000;
+		this.children = value;
+	}
+
+	addChild(child) {
+		if (!this.hasChildren()) {
+			this.setChildren(new Set());
 		}
+		this.children.add(child);
+	}
+
+	serialize({ write }) {
+		write(this._flags);
+		if (this.hasStartTime()) write(this.startTime);
+		if (this.hasFileTimestamps()) write(this.fileTimestamps);
+		if (this.hasFileHashes()) write(this.fileHashes);
+		if (this.hasFileTshs()) write(this.fileTshs);
+		if (this.hasContextTimestamps()) write(this.contextTimestamps);
+		if (this.hasContextHashes()) write(this.contextHashes);
+		if (this.hasContextTshs()) write(this.contextTshs);
+		if (this.hasMissingExistence()) write(this.missingExistence);
+		if (this.hasManagedItemInfo()) write(this.managedItemInfo);
+		if (this.hasManagedFiles()) write(this.managedFiles);
+		if (this.hasManagedContexts()) write(this.managedContexts);
+		if (this.hasManagedMissing()) write(this.managedMissing);
+		if (this.hasChildren()) write(this.children);
+	}
+
+	deserialize({ read }) {
+		this._flags = read();
+		if (this.hasStartTime()) this.startTime = read();
+		if (this.hasFileTimestamps()) this.fileTimestamps = read();
+		if (this.hasFileHashes()) this.fileHashes = read();
+		if (this.hasFileTshs()) this.fileTshs = read();
+		if (this.hasContextTimestamps()) this.contextTimestamps = read();
+		if (this.hasContextHashes()) this.contextHashes = read();
+		if (this.hasContextTshs()) this.contextTshs = read();
+		if (this.hasMissingExistence()) this.missingExistence = read();
+		if (this.hasManagedItemInfo()) this.managedItemInfo = read();
+		if (this.hasManagedFiles()) this.managedFiles = read();
+		if (this.hasManagedContexts()) this.managedContexts = read();
+		if (this.hasManagedMissing()) this.managedMissing = read();
+		if (this.hasChildren()) this.children = read();
 	}
 
 	/**
-	 * @param {OutputFileSystem} value the new output file system
+	 * @param {function(Snapshot): (ReadonlyMap<string, any> | ReadonlySet<string>)[]} getMaps first
+	 * @returns {Iterable<string>} iterable
 	 */
-	set outputFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.outputFileSystem = value;
-		}
+	_createIterable(getMaps) {
+		return new SnapshotIterable(this, getMaps);
 	}
 
 	/**
-	 * @param {WatchFileSystem} value the new watch file system
+	 * @returns {Iterable<string>} iterable
 	 */
-	set watchFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.watchFileSystem = value;
-		}
+	getFileIterable() {
+		return this._createIterable(s => [
+			s.fileTimestamps,
+			s.fileHashes,
+			s.fileTshs,
+			s.managedFiles
+		]);
 	}
 
 	/**
-	 * @param {IntermediateFileSystem} value the new intermediate file system
+	 * @returns {Iterable<string>} iterable
 	 */
-	set intermediateFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.intermediateFileSystem = value;
-		}
+	getContextIterable() {
+		return this._createIterable(s => [
+			s.contextTimestamps,
+			s.contextHashes,
+			s.contextTshs,
+			s.managedContexts
+		]);
 	}
 
-	getInfrastructureLogger(name) {
-		return this.compilers[0].getInfrastructureLogger(name);
+	/**
+	 * @returns {Iterable<string>} iterable
+	 */
+	getMissingIterable() {
+		return this._createIterable(s => [s.missingExistence, s.managedMissing]);
 	}
+}
+
+makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot");
+
+const MIN_COMMON_SNAPSHOT_SIZE = 3;
 
+/**
+ * @template T
+ */
+class SnapshotOptimization {
 	/**
-	 * @param {Compiler} compiler the child compiler
-	 * @param {string[]} dependencies its dependencies
-	 * @returns {void}
+	 * @param {function(Snapshot): boolean} has has value
+	 * @param {function(Snapshot): Map<string, T> | Set<string>} get get value
+	 * @param {function(Snapshot, Map<string, T> | Set<string>): void} set set value
+	 * @param {boolean=} useStartTime use the start time of snapshots
+	 * @param {boolean=} isSet value is an Set instead of a Map
 	 */
-	setDependencies(compiler, dependencies) {
-		this.dependencies.set(compiler, dependencies);
+	constructor(has, get, set, useStartTime = true, isSet = false) {
+		this._has = has;
+		this._get = get;
+		this._set = set;
+		this._useStartTime = useStartTime;
+		this._isSet = isSet;
+		/** @type {Map<string, SnapshotOptimizationEntry>} */
+		this._map = new Map();
+		this._statItemsShared = 0;
+		this._statItemsUnshared = 0;
+		this._statSharedSnapshots = 0;
+		this._statReusedSharedSnapshots = 0;
+	}
+
+	getStatisticMessage() {
+		const total = this._statItemsShared + this._statItemsUnshared;
+		if (total === 0) return undefined;
+		return `${
+			this._statItemsShared && Math.round((this._statItemsShared * 100) / total)
+		}% (${this._statItemsShared}/${total}) entries shared via ${
+			this._statSharedSnapshots
+		} shared snapshots (${
+			this._statReusedSharedSnapshots + this._statSharedSnapshots
+		} times referenced)`;
+	}
+
+	clear() {
+		this._map.clear();
+		this._statItemsShared = 0;
+		this._statItemsUnshared = 0;
+		this._statSharedSnapshots = 0;
+		this._statReusedSharedSnapshots = 0;
 	}
 
 	/**
-	 * @param {Callback<MultiStats>} callback signals when the validation is complete
-	 * @returns {boolean} true if the dependencies are valid
+	 * @param {Snapshot} newSnapshot snapshot
+	 * @param {Set<string>} capturedFiles files to snapshot/share
+	 * @returns {void}
 	 */
-	validateDependencies(callback) {
-		/** @type {Set<{source: Compiler, target: Compiler}>} */
-		const edges = new Set();
-		/** @type {string[]} */
-		const missing = [];
-		const targetFound = compiler => {
-			for (const edge of edges) {
-				if (edge.target === compiler) {
-					return true;
-				}
-			}
-			return false;
-		};
-		const sortEdges = (e1, e2) => {
-			return (
-				e1.source.name.localeCompare(e2.source.name) ||
-				e1.target.name.localeCompare(e2.target.name)
-			);
-		};
-		for (const source of this.compilers) {
-			const dependencies = this.dependencies.get(source);
-			if (dependencies) {
-				for (const dep of dependencies) {
-					const target = this.compilers.find(c => c.name === dep);
-					if (!target) {
-						missing.push(dep);
-					} else {
-						edges.add({
-							source,
-							target
-						});
-					}
-				}
-			}
-		}
-		/** @type {string[]} */
-		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
-		const stack = this.compilers.filter(c => !targetFound(c));
-		while (stack.length > 0) {
-			const current = stack.pop();
-			for (const edge of edges) {
-				if (edge.source === current) {
-					edges.delete(edge);
-					const target = edge.target;
-					if (!targetFound(target)) {
-						stack.push(target);
-					}
-				}
-			}
-		}
-		if (edges.size > 0) {
-			/** @type {string[]} */
-			const lines = Array.from(edges)
-				.sort(sortEdges)
-				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
-			lines.unshift("Circular dependency found in compiler dependencies.");
-			errors.unshift(lines.join("\n"));
-		}
-		if (errors.length > 0) {
-			const message = errors.join("\n");
-			callback(new Error(message));
-			return false;
-		}
-		return true;
-	}
-
-	// TODO webpack 6 remove
-	/**
-	 * @deprecated This method should have been private
-	 * @param {Compiler[]} compilers the child compilers
-	 * @param {RunWithDependenciesHandler} fn a handler to run for each compiler
-	 * @param {Callback<MultiStats>} callback the compiler's handler
-	 * @returns {void}
-	 */
-	runWithDependencies(compilers, fn, callback) {
-		const fulfilledNames = new Set();
-		let remainingCompilers = compilers;
-		const isDependencyFulfilled = d => fulfilledNames.has(d);
-		const getReadyCompilers = () => {
-			let readyCompilers = [];
-			let list = remainingCompilers;
-			remainingCompilers = [];
-			for (const c of list) {
-				const dependencies = this.dependencies.get(c);
-				const ready =
-					!dependencies || dependencies.every(isDependencyFulfilled);
-				if (ready) {
-					readyCompilers.push(c);
-				} else {
-					remainingCompilers.push(c);
-				}
-			}
-			return readyCompilers;
-		};
-		const runCompilers = callback => {
-			if (remainingCompilers.length === 0) return callback();
-			asyncLib.map(
-				getReadyCompilers(),
-				(compiler, callback) => {
-					fn(compiler, err => {
-						if (err) return callback(err);
-						fulfilledNames.add(compiler.name);
-						runCompilers(callback);
-					});
-				},
-				callback
-			);
-		};
-		runCompilers(callback);
-	}
-
-	/**
-	 * @template SetupResult
-	 * @param {function(Compiler, number, Callback<Stats>, function(): boolean, function(): void, function(): void): SetupResult} setup setup a single compiler
-	 * @param {function(Compiler, SetupResult, Callback<Stats>): void} run run/continue a single compiler
-	 * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
-	 * @returns {SetupResult[]} result of setup
-	 */
-	_runGraph(setup, run, callback) {
-		/** @typedef {{ compiler: Compiler, setupResult: SetupResult, result: Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
-
-		// State transitions for nodes:
-		// -> blocked (initial)
-		// blocked -> starting [running++] (when all parents done)
-		// queued -> starting [running++] (when processing the queue)
-		// starting -> running (when run has been called)
-		// running -> done [running--] (when compilation is done)
-		// done -> pending (when invalidated from file change)
-		// pending -> blocked [add to queue] (when invalidated from aggregated changes)
-		// done -> blocked [add to queue] (when invalidated, from parent invalidation)
-		// running -> running-outdated (when invalidated, either from change or parent invalidation)
-		// running-outdated -> blocked [running--] (when compilation is done)
-
-		/** @type {Node[]} */
-		const nodes = this.compilers.map(compiler => ({
-			compiler,
-			setupResult: undefined,
-			result: undefined,
-			state: "blocked",
-			children: [],
-			parents: []
-		}));
-		/** @type {Map<string, Node>} */
-		const compilerToNode = new Map();
-		for (const node of nodes) compilerToNode.set(node.compiler.name, node);
-		for (const node of nodes) {
-			const dependencies = this.dependencies.get(node.compiler);
-			if (!dependencies) continue;
-			for (const dep of dependencies) {
-				const parent = compilerToNode.get(dep);
-				node.parents.push(parent);
-				parent.children.push(node);
-			}
-		}
-		/** @type {ArrayQueue<Node>} */
-		const queue = new ArrayQueue();
-		for (const node of nodes) {
-			if (node.parents.length === 0) {
-				node.state = "queued";
-				queue.enqueue(node);
-			}
-		}
-		let errored = false;
-		let running = 0;
-		const parallelism = this._options.parallelism;
-		/**
-		 * @param {Node} node node
-		 * @param {Error=} err error
-		 * @param {Stats=} stats result
-		 * @returns {void}
-		 */
-		const nodeDone = (node, err, stats) => {
-			if (errored) return;
-			if (err) {
-				errored = true;
-				return asyncLib.each(
-					nodes,
-					(node, callback) => {
-						if (node.compiler.watching) {
-							node.compiler.watching.close(callback);
-						} else {
-							callback();
-						}
-					},
-					() => callback(err)
-				);
-			}
-			node.result = stats;
-			running--;
-			if (node.state === "running") {
-				node.state = "done";
-				for (const child of node.children) {
-					if (child.state === "blocked") queue.enqueue(child);
-				}
-			} else if (node.state === "running-outdated") {
-				node.state = "blocked";
-				queue.enqueue(node);
-			}
-			processQueue();
-		};
+	optimize(newSnapshot, capturedFiles) {
 		/**
-		 * @param {Node} node node
+		 * @param {SnapshotOptimizationEntry} entry optimization entry
 		 * @returns {void}
 		 */
-		const nodeInvalidFromParent = node => {
-			if (node.state === "done") {
-				node.state = "blocked";
-			} else if (node.state === "running") {
-				node.state = "running-outdated";
-			}
-			for (const child of node.children) {
-				nodeInvalidFromParent(child);
+		const increaseSharedAndStoreOptimizationEntry = entry => {
+			if (entry.children !== undefined) {
+				entry.children.forEach(increaseSharedAndStoreOptimizationEntry);
 			}
+			entry.shared++;
+			storeOptimizationEntry(entry);
 		};
 		/**
-		 * @param {Node} node node
+		 * @param {SnapshotOptimizationEntry} entry optimization entry
 		 * @returns {void}
 		 */
-		const nodeInvalid = node => {
-			if (node.state === "done") {
-				node.state = "pending";
-			} else if (node.state === "running") {
-				node.state = "running-outdated";
-			}
-			for (const child of node.children) {
-				nodeInvalidFromParent(child);
+		const storeOptimizationEntry = entry => {
+			for (const path of entry.snapshotContent) {
+				const old = this._map.get(path);
+				if (old.shared < entry.shared) {
+					this._map.set(path, entry);
+				}
+				capturedFiles.delete(path);
 			}
 		};
-		/**
-		 * @param {Node} node node
-		 * @returns {void}
-		 */
-		const nodeChange = node => {
-			nodeInvalid(node);
-			if (node.state === "pending") {
-				node.state = "blocked";
-			}
-			if (node.state === "blocked") {
-				queue.enqueue(node);
-				processQueue();
+
+		/** @type {SnapshotOptimizationEntry} */
+		let newOptimizationEntry = undefined;
+
+		const capturedFilesSize = capturedFiles.size;
+
+		/** @type {Set<SnapshotOptimizationEntry> | undefined} */
+		const optimizationEntries = new Set();
+
+		for (const path of capturedFiles) {
+			const optimizationEntry = this._map.get(path);
+			if (optimizationEntry === undefined) {
+				if (newOptimizationEntry === undefined) {
+					newOptimizationEntry = {
+						snapshot: newSnapshot,
+						shared: 0,
+						snapshotContent: undefined,
+						children: undefined
+					};
+				}
+				this._map.set(path, newOptimizationEntry);
+				continue;
+			} else {
+				optimizationEntries.add(optimizationEntry);
 			}
-		};
+		}
 
-		const setupResults = [];
-		nodes.forEach((node, i) => {
-			setupResults.push(
-				(node.setupResult = setup(
-					node.compiler,
-					i,
-					nodeDone.bind(null, node),
-					() => node.state !== "starting" && node.state !== "running",
-					() => nodeChange(node),
-					() => nodeInvalid(node)
-				))
-			);
-		});
-		let processing = true;
-		const processQueue = () => {
-			if (processing) return;
-			processing = true;
-			process.nextTick(processQueueWorker);
-		};
-		const processQueueWorker = () => {
-			while (running < parallelism && queue.length > 0 && !errored) {
-				const node = queue.dequeue();
+		optimizationEntries: for (const optimizationEntry of optimizationEntries) {
+			const snapshot = optimizationEntry.snapshot;
+			if (optimizationEntry.shared > 0) {
+				// It's a shared snapshot
+				// We can't change it, so we can only use it when all files match
+				// and startTime is compatible
 				if (
-					node.state === "queued" ||
-					(node.state === "blocked" &&
-						node.parents.every(p => p.state === "done"))
+					this._useStartTime &&
+					newSnapshot.startTime &&
+					(!snapshot.startTime || snapshot.startTime > newSnapshot.startTime)
 				) {
-					running++;
-					node.state = "starting";
-					run(node.compiler, node.setupResult, nodeDone.bind(null, node));
-					node.state = "running";
+					continue;
 				}
-			}
-			processing = false;
-			if (
-				!errored &&
-				running === 0 &&
-				nodes.every(node => node.state === "done")
-			) {
-				const stats = [];
-				for (const node of nodes) {
-					const result = node.result;
-					if (result) {
-						node.result = undefined;
-						stats.push(result);
+				const nonSharedFiles = new Set();
+				const snapshotContent = optimizationEntry.snapshotContent;
+				const snapshotEntries = this._get(snapshot);
+				for (const path of snapshotContent) {
+					if (!capturedFiles.has(path)) {
+						if (!snapshotEntries.has(path)) {
+							// File is not shared and can't be removed from the snapshot
+							// because it's in a child of the snapshot
+							continue optimizationEntries;
+						}
+						nonSharedFiles.add(path);
+						continue;
 					}
 				}
-				if (stats.length > 0) {
-					callback(null, new MultiStats(stats));
+				if (nonSharedFiles.size === 0) {
+					// The complete snapshot is shared
+					// add it as child
+					newSnapshot.addChild(snapshot);
+					increaseSharedAndStoreOptimizationEntry(optimizationEntry);
+					this._statReusedSharedSnapshots++;
+				} else {
+					// Only a part of the snapshot is shared
+					const sharedCount = snapshotContent.size - nonSharedFiles.size;
+					if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {
+						// Common part it too small
+						continue optimizationEntries;
+					}
+					// Extract common timestamps from both snapshots
+					let commonMap;
+					if (this._isSet) {
+						commonMap = new Set();
+						for (const path of /** @type {Set<string>} */ (snapshotEntries)) {
+							if (nonSharedFiles.has(path)) continue;
+							commonMap.add(path);
+							snapshotEntries.delete(path);
+						}
+					} else {
+						commonMap = new Map();
+						const map = /** @type {Map<string, T>} */ (snapshotEntries);
+						for (const [path, value] of map) {
+							if (nonSharedFiles.has(path)) continue;
+							commonMap.set(path, value);
+							snapshotEntries.delete(path);
+						}
+					}
+					// Create and attach snapshot
+					const commonSnapshot = new Snapshot();
+					if (this._useStartTime) {
+						commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
+					}
+					this._set(commonSnapshot, commonMap);
+					newSnapshot.addChild(commonSnapshot);
+					snapshot.addChild(commonSnapshot);
+					// Create optimization entry
+					const newEntry = {
+						snapshot: commonSnapshot,
+						shared: optimizationEntry.shared + 1,
+						snapshotContent: new Set(commonMap.keys()),
+						children: undefined
+					};
+					if (optimizationEntry.children === undefined)
+						optimizationEntry.children = new Set();
+					optimizationEntry.children.add(newEntry);
+					storeOptimizationEntry(newEntry);
+					this._statSharedSnapshots++;
 				}
-			}
-		};
-		processQueueWorker();
-		return setupResults;
-	}
-
-	/**
-	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
-	 * @param {Callback<MultiStats>} handler signals when the call finishes
-	 * @returns {MultiWatching} a compiler watcher
-	 */
-	watch(watchOptions, handler) {
-		if (this.running) {
-			return handler(new ConcurrentCompilationError());
-		}
-		this.running = true;
-
-		if (this.validateDependencies(handler)) {
-			const watchings = this._runGraph(
-				(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
-					const watching = compiler.watch(
-						Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
-						callback
-					);
-					if (watching) {
-						watching._onInvalid = setInvalid;
-						watching._onChange = setChanged;
-						watching._isBlocked = isBlocked;
+			} else {
+				// It's a unshared snapshot
+				// We can extract a common shared snapshot
+				// with all common files
+				const snapshotEntries = this._get(snapshot);
+				if (snapshotEntries === undefined) {
+					// Incomplete snapshot, that can't be used
+					continue optimizationEntries;
+				}
+				let commonMap;
+				if (this._isSet) {
+					commonMap = new Set();
+					const set = /** @type {Set<string>} */ (snapshotEntries);
+					if (capturedFiles.size < set.size) {
+						for (const path of capturedFiles) {
+							if (set.has(path)) commonMap.add(path);
+						}
+					} else {
+						for (const path of set) {
+							if (capturedFiles.has(path)) commonMap.add(path);
+						}
 					}
-					return watching;
-				},
-				(compiler, watching, callback) => {
-					if (compiler.watching !== watching) return;
-					if (!watching.running) watching.invalidate();
-				},
-				handler
-			);
-			return new MultiWatching(watchings, this);
-		}
-
-		return new MultiWatching([], this);
-	}
-
-	/**
-	 * @param {Callback<MultiStats>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	run(callback) {
-		if (this.running) {
-			return callback(new ConcurrentCompilationError());
-		}
-		this.running = true;
-
-		if (this.validateDependencies(callback)) {
-			this._runGraph(
-				() => {},
-				(compiler, setupResult, callback) => compiler.run(callback),
-				(err, stats) => {
-					this.running = false;
-
-					if (callback !== undefined) {
-						return callback(err, stats);
+				} else {
+					commonMap = new Map();
+					const map = /** @type {Map<string, T>} */ (snapshotEntries);
+					for (const path of capturedFiles) {
+						const ts = map.get(path);
+						if (ts === undefined) continue;
+						commonMap.set(path, ts);
 					}
 				}
-			);
-		}
-	}
 
-	purgeInputFileSystem() {
-		for (const compiler of this.compilers) {
-			if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
-				compiler.inputFileSystem.purge();
+				if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {
+					// Common part it too small
+					continue optimizationEntries;
+				}
+				// Create and attach snapshot
+				const commonSnapshot = new Snapshot();
+				if (this._useStartTime) {
+					commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
+				}
+				this._set(commonSnapshot, commonMap);
+				newSnapshot.addChild(commonSnapshot);
+				snapshot.addChild(commonSnapshot);
+				// Remove files from snapshot
+				for (const path of commonMap.keys()) snapshotEntries.delete(path);
+				const sharedCount = commonMap.size;
+				this._statItemsUnshared -= sharedCount;
+				this._statItemsShared += sharedCount;
+				// Create optimization entry
+				storeOptimizationEntry({
+					snapshot: commonSnapshot,
+					shared: 2,
+					snapshotContent: new Set(commonMap.keys()),
+					children: undefined
+				});
+				this._statSharedSnapshots++;
 			}
 		}
+		const unshared = capturedFiles.size;
+		this._statItemsUnshared += unshared;
+		this._statItemsShared += capturedFilesSize - unshared;
 	}
+}
 
-	/**
-	 * @param {Callback<void>} callback signals when the compiler closes
-	 * @returns {void}
-	 */
-	close(callback) {
-		asyncLib.each(
-			this.compilers,
-			(compiler, callback) => {
-				compiler.close(callback);
-			},
-			callback
-		);
-	}
+const parseString = str => {
+	if (str[0] === "'") str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
+	return JSON.parse(str);
 };
 
-
-/***/ }),
-
-/***/ 24170:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const identifierUtils = __webpack_require__(82186);
-
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("./Stats")} Stats */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-
-const indent = (str, prefix) => {
-	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
-	return prefix + rem;
+/* istanbul ignore next */
+/**
+ * @param {number} mtime mtime
+ */
+const applyMtime = mtime => {
+	if (FS_ACCURACY > 1 && mtime % 2 !== 0) FS_ACCURACY = 1;
+	else if (FS_ACCURACY > 10 && mtime % 20 !== 0) FS_ACCURACY = 10;
+	else if (FS_ACCURACY > 100 && mtime % 200 !== 0) FS_ACCURACY = 100;
+	else if (FS_ACCURACY > 1000 && mtime % 2000 !== 0) FS_ACCURACY = 1000;
 };
 
-class MultiStats {
-	/**
-	 * @param {Stats[]} stats the child stats
-	 */
-	constructor(stats) {
-		this.stats = stats;
-	}
-
-	get hash() {
-		return this.stats.map(stat => stat.hash).join("");
-	}
-
-	/**
-	 * @returns {boolean} true if a child compilation encountered an error
-	 */
-	hasErrors() {
-		return this.stats.some(stat => stat.hasErrors());
-	}
-
-	/**
-	 * @returns {boolean} true if a child compilation had a warning
-	 */
-	hasWarnings() {
-		return this.stats.some(stat => stat.hasWarnings());
-	}
-
-	_createChildOptions(options, context) {
-		if (!options) {
-			options = {};
-		}
-		const { children: childrenOptions = undefined, ...baseOptions } =
-			typeof options === "string" ? { preset: options } : options;
-		const children = this.stats.map((stat, idx) => {
-			const childOptions = Array.isArray(childrenOptions)
-				? childrenOptions[idx]
-				: childrenOptions;
-			return stat.compilation.createStatsOptions(
-				{
-					...baseOptions,
-					...(typeof childOptions === "string"
-						? { preset: childOptions }
-						: childOptions && typeof childOptions === "object"
-						? childOptions
-						: undefined)
-				},
-				context
-			);
-		});
-		return {
-			version: children.every(o => o.version),
-			hash: children.every(o => o.hash),
-			errorsCount: children.every(o => o.errorsCount),
-			warningsCount: children.every(o => o.warningsCount),
-			errors: children.every(o => o.errors),
-			warnings: children.every(o => o.warnings),
-			children
-		};
-	}
-
-	/**
-	 * @param {any} options stats options
-	 * @returns {StatsCompilation} json output
-	 */
-	toJson(options) {
-		options = this._createChildOptions(options, { forToString: false });
-		/** @type {KnownStatsCompilation} */
-		const obj = {};
-		obj.children = this.stats.map((stat, idx) => {
-			const obj = stat.toJson(options.children[idx]);
-			const compilationName = stat.compilation.name;
-			const name =
-				compilationName &&
-				identifierUtils.makePathsRelative(
-					options.context,
-					compilationName,
-					stat.compilation.compiler.root
-				);
-			obj.name = name;
-			return obj;
-		});
-		if (options.version) {
-			obj.version = obj.children[0].version;
-		}
-		if (options.hash) {
-			obj.hash = obj.children.map(j => j.hash).join("");
-		}
-		const mapError = (j, obj) => {
-			return {
-				...obj,
-				compilerPath: obj.compilerPath
-					? `${j.name}.${obj.compilerPath}`
-					: j.name
-			};
-		};
-		if (options.errors) {
-			obj.errors = [];
-			for (const j of obj.children) {
-				for (const i of j.errors) {
-					obj.errors.push(mapError(j, i));
-				}
-			}
-		}
-		if (options.warnings) {
-			obj.warnings = [];
-			for (const j of obj.children) {
-				for (const i of j.warnings) {
-					obj.warnings.push(mapError(j, i));
-				}
-			}
-		}
-		if (options.errorsCount) {
-			obj.errorsCount = 0;
-			for (const j of obj.children) {
-				obj.errorsCount += j.errorsCount;
-			}
-		}
-		if (options.warningsCount) {
-			obj.warningsCount = 0;
-			for (const j of obj.children) {
-				obj.warningsCount += j.warningsCount;
-			}
-		}
-		return obj;
-	}
-
-	toString(options) {
-		options = this._createChildOptions(options, { forToString: true });
-		const results = this.stats.map((stat, idx) => {
-			const str = stat.toString(options.children[idx]);
-			const compilationName = stat.compilation.name;
-			const name =
-				compilationName &&
-				identifierUtils
-					.makePathsRelative(
-						options.context,
-						compilationName,
-						stat.compilation.compiler.root
-					)
-					.replace(/\|/g, " ");
-			if (!str) return str;
-			return name ? `${name}:\n${indent(str, "  ")}` : str;
-		});
-		return results.filter(Boolean).join("\n\n");
+/**
+ * @template T
+ * @template K
+ * @param {Map<T, K>} a source map
+ * @param {Map<T, K>} b joining map
+ * @returns {Map<T, K>} joined map
+ */
+const mergeMaps = (a, b) => {
+	if (!b || b.size === 0) return a;
+	if (!a || a.size === 0) return b;
+	const map = new Map(a);
+	for (const [key, value] of b) {
+		map.set(key, value);
 	}
-}
-
-module.exports = MultiStats;
-
-
-/***/ }),
-
-/***/ 81128:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const asyncLib = __webpack_require__(78175);
-
-/** @typedef {import("./MultiCompiler")} MultiCompiler */
-/** @typedef {import("./Watching")} Watching */
+	return map;
+};
 
 /**
  * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
+ * @template K
+ * @param {Set<T, K>} a source map
+ * @param {Set<T, K>} b joining map
+ * @returns {Set<T, K>} joined map
  */
-
-class MultiWatching {
-	/**
-	 * @param {Watching[]} watchings child compilers' watchers
-	 * @param {MultiCompiler} compiler the compiler
-	 */
-	constructor(watchings, compiler) {
-		this.watchings = watchings;
-		this.compiler = compiler;
+const mergeSets = (a, b) => {
+	if (!b || b.size === 0) return a;
+	if (!a || a.size === 0) return b;
+	const map = new Set(a);
+	for (const item of b) {
+		map.add(item);
 	}
+	return map;
+};
 
-	invalidate(callback) {
-		if (callback) {
-			asyncLib.each(
-				this.watchings,
-				(watching, callback) => watching.invalidate(callback),
-				callback
-			);
-		} else {
-			for (const watching of this.watchings) {
-				watching.invalidate();
-			}
+/**
+ * Finding file or directory to manage
+ * @param {string} managedPath path that is managing by {@link FileSystemInfo}
+ * @param {string} path path to file or directory
+ * @returns {string|null} managed item
+ * @example
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/package/index.js'
+ * ) === '/Users/user/my-project/node_modules/package'
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/package1/node_modules/package2'
+ * ) === '/Users/user/my-project/node_modules/package1/node_modules/package2'
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/.bin/script.js'
+ * ) === null // hidden files are disallowed as managed items
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/package'
+ * ) === '/Users/user/my-project/node_modules/package'
+ */
+const getManagedItem = (managedPath, path) => {
+	let i = managedPath.length;
+	let slashes = 1;
+	let startingPosition = true;
+	loop: while (i < path.length) {
+		switch (path.charCodeAt(i)) {
+			case 47: // slash
+			case 92: // backslash
+				if (--slashes === 0) break loop;
+				startingPosition = true;
+				break;
+			case 46: // .
+				// hidden files are disallowed as managed items
+				// it's probably .yarn-integrity or .cache
+				if (startingPosition) return null;
+				break;
+			case 64: // @
+				if (!startingPosition) return null;
+				slashes++;
+				break;
+			default:
+				startingPosition = false;
+				break;
 		}
+		i++;
 	}
-
-	suspend() {
-		for (const watching of this.watchings) {
-			watching.suspend();
+	if (i === path.length) slashes--;
+	// return null when path is incomplete
+	if (slashes !== 0) return null;
+	// if (path.slice(i + 1, i + 13) === "node_modules")
+	if (
+		path.length >= i + 13 &&
+		path.charCodeAt(i + 1) === 110 &&
+		path.charCodeAt(i + 2) === 111 &&
+		path.charCodeAt(i + 3) === 100 &&
+		path.charCodeAt(i + 4) === 101 &&
+		path.charCodeAt(i + 5) === 95 &&
+		path.charCodeAt(i + 6) === 109 &&
+		path.charCodeAt(i + 7) === 111 &&
+		path.charCodeAt(i + 8) === 100 &&
+		path.charCodeAt(i + 9) === 117 &&
+		path.charCodeAt(i + 10) === 108 &&
+		path.charCodeAt(i + 11) === 101 &&
+		path.charCodeAt(i + 12) === 115
+	) {
+		// if this is the end of the path
+		if (path.length === i + 13) {
+			// return the node_modules directory
+			// it's special
+			return path;
 		}
-	}
-
-	resume() {
-		for (const watching of this.watchings) {
-			watching.resume();
+		const c = path.charCodeAt(i + 13);
+		// if next symbol is slash or backslash
+		if (c === 47 || c === 92) {
+			// Managed subpath
+			return getManagedItem(path.slice(0, i + 14), path);
 		}
 	}
-
-	/**
-	 * @param {Callback<void>} callback signals when the watcher is closed
-	 * @returns {void}
-	 */
-	close(callback) {
-		asyncLib.forEach(
-			this.watchings,
-			(watching, finishedCallback) => {
-				watching.close(finishedCallback);
-			},
-			err => {
-				this.compiler.hooks.watchClose.call();
-				if (typeof callback === "function") {
-					this.compiler.running = false;
-					callback(err);
-				}
-			}
-		);
-	}
-}
-
-module.exports = MultiWatching;
-
-
-/***/ }),
-
-/***/ 50169:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class NoEmitOnErrorsPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.shouldEmit.tap("NoEmitOnErrorsPlugin", compilation => {
-			if (compilation.getStats().hasErrors()) return false;
-		});
-		compiler.hooks.compilation.tap("NoEmitOnErrorsPlugin", compilation => {
-			compilation.hooks.shouldRecord.tap("NoEmitOnErrorsPlugin", () => {
-				if (compilation.getStats().hasErrors()) return false;
-			});
-		});
-	}
-}
-
-module.exports = NoEmitOnErrorsPlugin;
-
-
-/***/ }),
-
-/***/ 80832:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-
-module.exports = class NoModeWarning extends WebpackError {
-	constructor() {
-		super();
-
-		this.name = "NoModeWarning";
-		this.message =
-			"configuration\n" +
-			"The 'mode' option has not been set, webpack will fallback to 'production' for this value.\n" +
-			"Set 'mode' option to 'development' or 'production' to enable defaults for each environment.\n" +
-			"You can also set it to 'none' to disable any default behavior. " +
-			"Learn more: https://webpack.js.org/configuration/mode/";
-	}
+	return path.slice(0, i);
 };
 
+/**
+ * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
+ * @param {T} entry entry
+ * @returns {T["resolved"] | undefined} the resolved entry
+ */
+const getResolvedTimestamp = entry => {
+	if (entry === null) return null;
+	if (entry.resolved !== undefined) return entry.resolved;
+	return entry.symlinks === undefined ? entry : undefined;
+};
 
-/***/ }),
-
-/***/ 6325:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+/**
+ * @param {ContextHash} entry entry
+ * @returns {string | undefined} the resolved entry
+ */
+const getResolvedHash = entry => {
+	if (entry === null) return null;
+	if (entry.resolved !== undefined) return entry.resolved;
+	return entry.symlinks === undefined ? entry.hash : undefined;
+};
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+const addAll = (source, target) => {
+	for (const key of source) target.add(key);
+};
 
-class NodeStuffInWebError extends WebpackError {
+/**
+ * Used to access information about the filesystem in a cached way
+ */
+class FileSystemInfo {
 	/**
-	 * @param {DependencyLocation} loc loc
-	 * @param {string} expression expression
-	 * @param {string} description description
+	 * @param {InputFileSystem} fs file system
+	 * @param {Object} options options
+	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
+	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
+	 * @param {Logger=} options.logger logger used to log invalid snapshots
+	 * @param {string | Hash=} options.hashFunction the hash function to use
 	 */
-	constructor(loc, expression, description) {
-		super(
-			`${JSON.stringify(
-				expression
-			)} has been used, it will be undefined in next major version.
-${description}`
+	constructor(
+		fs,
+		{
+			managedPaths = [],
+			immutablePaths = [],
+			logger,
+			hashFunction = "md4"
+		} = {}
+	) {
+		this.fs = fs;
+		this.logger = logger;
+		this._remainingLogs = logger ? 40 : 0;
+		this._loggedPaths = logger ? new Set() : undefined;
+		this._hashFunction = hashFunction;
+		/** @type {WeakMap<Snapshot, boolean | (function(WebpackError=, boolean=): void)[]>} */
+		this._snapshotCache = new WeakMap();
+		this._fileTimestampsOptimization = new SnapshotOptimization(
+			s => s.hasFileTimestamps(),
+			s => s.fileTimestamps,
+			(s, v) => s.setFileTimestamps(v)
 		);
+		this._fileHashesOptimization = new SnapshotOptimization(
+			s => s.hasFileHashes(),
+			s => s.fileHashes,
+			(s, v) => s.setFileHashes(v),
+			false
+		);
+		this._fileTshsOptimization = new SnapshotOptimization(
+			s => s.hasFileTshs(),
+			s => s.fileTshs,
+			(s, v) => s.setFileTshs(v)
+		);
+		this._contextTimestampsOptimization = new SnapshotOptimization(
+			s => s.hasContextTimestamps(),
+			s => s.contextTimestamps,
+			(s, v) => s.setContextTimestamps(v)
+		);
+		this._contextHashesOptimization = new SnapshotOptimization(
+			s => s.hasContextHashes(),
+			s => s.contextHashes,
+			(s, v) => s.setContextHashes(v),
+			false
+		);
+		this._contextTshsOptimization = new SnapshotOptimization(
+			s => s.hasContextTshs(),
+			s => s.contextTshs,
+			(s, v) => s.setContextTshs(v)
+		);
+		this._missingExistenceOptimization = new SnapshotOptimization(
+			s => s.hasMissingExistence(),
+			s => s.missingExistence,
+			(s, v) => s.setMissingExistence(v),
+			false
+		);
+		this._managedItemInfoOptimization = new SnapshotOptimization(
+			s => s.hasManagedItemInfo(),
+			s => s.managedItemInfo,
+			(s, v) => s.setManagedItemInfo(v),
+			false
+		);
+		this._managedFilesOptimization = new SnapshotOptimization(
+			s => s.hasManagedFiles(),
+			s => s.managedFiles,
+			(s, v) => s.setManagedFiles(v),
+			false,
+			true
+		);
+		this._managedContextsOptimization = new SnapshotOptimization(
+			s => s.hasManagedContexts(),
+			s => s.managedContexts,
+			(s, v) => s.setManagedContexts(v),
+			false,
+			true
+		);
+		this._managedMissingOptimization = new SnapshotOptimization(
+			s => s.hasManagedMissing(),
+			s => s.managedMissing,
+			(s, v) => s.setManagedMissing(v),
+			false,
+			true
+		);
+		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		this._fileTimestamps = new StackedCacheMap();
+		/** @type {Map<string, string>} */
+		this._fileHashes = new Map();
+		/** @type {Map<string, TimestampAndHash | string>} */
+		this._fileTshs = new Map();
+		/** @type {StackedCacheMap<string, ContextFileSystemInfoEntry | "ignore" | null>} */
+		this._contextTimestamps = new StackedCacheMap();
+		/** @type {Map<string, ContextHash>} */
+		this._contextHashes = new Map();
+		/** @type {Map<string, ContextTimestampAndHash>} */
+		this._contextTshs = new Map();
+		/** @type {Map<string, string>} */
+		this._managedItems = new Map();
+		/** @type {AsyncQueue<string, string, FileSystemInfoEntry | null>} */
+		this.fileTimestampQueue = new AsyncQueue({
+			name: "file timestamp",
+			parallelism: 30,
+			processor: this._readFileTimestamp.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, string | null>} */
+		this.fileHashQueue = new AsyncQueue({
+			name: "file hash",
+			parallelism: 10,
+			processor: this._readFileHash.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry | null>} */
+		this.contextTimestampQueue = new AsyncQueue({
+			name: "context timestamp",
+			parallelism: 2,
+			processor: this._readContextTimestamp.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, ContextHash | null>} */
+		this.contextHashQueue = new AsyncQueue({
+			name: "context hash",
+			parallelism: 2,
+			processor: this._readContextHash.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, ContextTimestampAndHash | null>} */
+		this.contextTshQueue = new AsyncQueue({
+			name: "context hash and timestamp",
+			parallelism: 2,
+			processor: this._readContextTimestampAndHash.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, string | null>} */
+		this.managedItemQueue = new AsyncQueue({
+			name: "managed item info",
+			parallelism: 10,
+			processor: this._getManagedItemInfo.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, Set<string>>} */
+		this.managedItemDirectoryQueue = new AsyncQueue({
+			name: "managed item directory info",
+			parallelism: 10,
+			processor: this._getManagedItemDirectoryInfo.bind(this)
+		});
+		this.managedPaths = Array.from(managedPaths);
+		this.managedPathsWithSlash = /** @type {string[]} */ (
+			this.managedPaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
 
-		this.name = "NodeStuffInWebError";
-		this.loc = loc;
-	}
-}
-
-makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
+		this.managedPathsRegExps = /** @type {RegExp[]} */ (
+			this.managedPaths.filter(p => typeof p !== "string")
+		);
+		this.immutablePaths = Array.from(immutablePaths);
+		this.immutablePathsWithSlash = /** @type {string[]} */ (
+			this.immutablePaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
+			this.immutablePaths.filter(p => typeof p !== "string")
+		);
 
-module.exports = NodeStuffInWebError;
+		this._cachedDeprecatedFileTimestamps = undefined;
+		this._cachedDeprecatedContextTimestamps = undefined;
 
+		this._warnAboutExperimentalEsmTracking = false;
 
-/***/ }),
+		this._statCreatedSnapshots = 0;
+		this._statTestedSnapshotsCached = 0;
+		this._statTestedSnapshotsNotCached = 0;
+		this._statTestedChildrenCached = 0;
+		this._statTestedChildrenNotCached = 0;
+		this._statTestedEntries = 0;
+	}
 
-/***/ 95287:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	logStatistics() {
+		const logWhenMessage = (header, message) => {
+			if (message) {
+				this.logger.log(`${header}: ${message}`);
+			}
+		};
+		this.logger.log(`${this._statCreatedSnapshots} new snapshots created`);
+		this.logger.log(
+			`${
+				this._statTestedSnapshotsNotCached &&
+				Math.round(
+					(this._statTestedSnapshotsNotCached * 100) /
+						(this._statTestedSnapshotsCached +
+							this._statTestedSnapshotsNotCached)
+				)
+			}% root snapshot uncached (${this._statTestedSnapshotsNotCached} / ${
+				this._statTestedSnapshotsCached + this._statTestedSnapshotsNotCached
+			})`
+		);
+		this.logger.log(
+			`${
+				this._statTestedChildrenNotCached &&
+				Math.round(
+					(this._statTestedChildrenNotCached * 100) /
+						(this._statTestedChildrenCached + this._statTestedChildrenNotCached)
+				)
+			}% children snapshot uncached (${this._statTestedChildrenNotCached} / ${
+				this._statTestedChildrenCached + this._statTestedChildrenNotCached
+			})`
+		);
+		this.logger.log(`${this._statTestedEntries} entries tested`);
+		this.logger.log(
+			`File info in cache: ${this._fileTimestamps.size} timestamps ${this._fileHashes.size} hashes ${this._fileTshs.size} timestamp hash combinations`
+		);
+		logWhenMessage(
+			`File timestamp snapshot optimization`,
+			this._fileTimestampsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`File hash snapshot optimization`,
+			this._fileHashesOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`File timestamp hash combination snapshot optimization`,
+			this._fileTshsOptimization.getStatisticMessage()
+		);
+		this.logger.log(
+			`Directory info in cache: ${this._contextTimestamps.size} timestamps ${this._contextHashes.size} hashes ${this._contextTshs.size} timestamp hash combinations`
+		);
+		logWhenMessage(
+			`Directory timestamp snapshot optimization`,
+			this._contextTimestampsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Directory hash snapshot optimization`,
+			this._contextHashesOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Directory timestamp hash combination snapshot optimization`,
+			this._contextTshsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Missing items snapshot optimization`,
+			this._missingExistenceOptimization.getStatisticMessage()
+		);
+		this.logger.log(
+			`Managed items info in cache: ${this._managedItems.size} items`
+		);
+		logWhenMessage(
+			`Managed items snapshot optimization`,
+			this._managedItemInfoOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Managed files snapshot optimization`,
+			this._managedFilesOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Managed contexts snapshot optimization`,
+			this._managedContextsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Managed missing snapshot optimization`,
+			this._managedMissingOptimization.getStatisticMessage()
+		);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	_log(path, reason, ...args) {
+		const key = path + reason;
+		if (this._loggedPaths.has(key)) return;
+		this._loggedPaths.add(key);
+		this.logger.debug(`${path} invalidated because ${reason}`, ...args);
+		if (--this._remainingLogs === 0) {
+			this.logger.debug(
+				"Logging limit has been reached and no further logging will be emitted by FileSystemInfo"
+			);
+		}
+	}
 
+	clear() {
+		this._remainingLogs = this.logger ? 40 : 0;
+		if (this._loggedPaths !== undefined) this._loggedPaths.clear();
 
+		this._snapshotCache = new WeakMap();
+		this._fileTimestampsOptimization.clear();
+		this._fileHashesOptimization.clear();
+		this._fileTshsOptimization.clear();
+		this._contextTimestampsOptimization.clear();
+		this._contextHashesOptimization.clear();
+		this._contextTshsOptimization.clear();
+		this._missingExistenceOptimization.clear();
+		this._managedItemInfoOptimization.clear();
+		this._managedFilesOptimization.clear();
+		this._managedContextsOptimization.clear();
+		this._managedMissingOptimization.clear();
+		this._fileTimestamps.clear();
+		this._fileHashes.clear();
+		this._fileTshs.clear();
+		this._contextTimestamps.clear();
+		this._contextHashes.clear();
+		this._contextTshs.clear();
+		this._managedItems.clear();
+		this._managedItems.clear();
 
-const NodeStuffInWebError = __webpack_require__(6325);
-const RuntimeGlobals = __webpack_require__(16475);
-const CachedConstDependency = __webpack_require__(57403);
-const ConstDependency = __webpack_require__(76911);
-const {
-	evaluateToString,
-	expressionIsUnsupported
-} = __webpack_require__(93998);
-const { relative } = __webpack_require__(17139);
-const { parseResource } = __webpack_require__(82186);
+		this._cachedDeprecatedFileTimestamps = undefined;
+		this._cachedDeprecatedContextTimestamps = undefined;
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+		this._statCreatedSnapshots = 0;
+		this._statTestedSnapshotsCached = 0;
+		this._statTestedSnapshotsNotCached = 0;
+		this._statTestedChildrenCached = 0;
+		this._statTestedChildrenNotCached = 0;
+		this._statTestedEntries = 0;
+	}
 
-class NodeStuffPlugin {
-	constructor(options) {
-		this.options = options;
+	/**
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
+	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
+	 * @returns {void}
+	 */
+	addFileTimestamps(map, immutable) {
+		this._fileTimestamps.addAll(map, immutable);
+		this._cachedDeprecatedFileTimestamps = undefined;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
+	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap(
-			"NodeStuffPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.node === false) return;
+	addContextTimestamps(map, immutable) {
+		this._contextTimestamps.addAll(map, immutable);
+		this._cachedDeprecatedContextTimestamps = undefined;
+	}
 
-					let localOptions = options;
-					if (parserOptions.node) {
-						localOptions = { ...localOptions, ...parserOptions.node };
-					}
+	/**
+	 * @param {string} path file path
+	 * @param {function((WebpackError | null)=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @returns {void}
+	 */
+	getFileTimestamp(path, callback) {
+		const cache = this._fileTimestamps.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.fileTimestampQueue.add(path, callback);
+	}
 
-					if (localOptions.global !== false) {
-						const withWarning = localOptions.global === "warn";
-						parser.hooks.expression
-							.for("global")
-							.tap("NodeStuffPlugin", expr => {
-								const dep = new ConstDependency(
-									RuntimeGlobals.global,
-									expr.range,
-									[RuntimeGlobals.global]
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
+	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @returns {void}
+	 */
+	getContextTimestamp(path, callback) {
+		const cache = this._contextTimestamps.get(path);
+		if (cache !== undefined) {
+			if (cache === "ignore") return callback(null, "ignore");
+			const resolved = getResolvedTimestamp(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextTimestamp(cache, callback);
+		}
+		this.contextTimestampQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedTimestamp(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextTimestamp(entry, callback);
+		});
+	}
 
-								// TODO webpack 6 remove
-								if (withWarning) {
-									parser.state.module.addWarning(
-										new NodeStuffInWebError(
-											dep.loc,
-											"global",
-											"The global namespace object is Node.js feature and doesn't present in browser."
-										)
-									);
-								}
-							});
-					}
+	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @returns {void}
+	 */
+	_getUnresolvedContextTimestamp(path, callback) {
+		const cache = this._contextTimestamps.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextTimestampQueue.add(path, callback);
+	}
 
-					const setModuleConstant = (expressionName, fn, warning) => {
-						parser.hooks.expression
-							.for(expressionName)
-							.tap("NodeStuffPlugin", expr => {
-								const dep = new CachedConstDependency(
-									JSON.stringify(fn(parser.state.module)),
-									expr.range,
-									expressionName
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
+	/**
+	 * @param {string} path file path
+	 * @param {function((WebpackError | null)=, string=): void} callback callback function
+	 * @returns {void}
+	 */
+	getFileHash(path, callback) {
+		const cache = this._fileHashes.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.fileHashQueue.add(path, callback);
+	}
 
-								// TODO webpack 6 remove
-								if (warning) {
-									parser.state.module.addWarning(
-										new NodeStuffInWebError(dep.loc, expressionName, warning)
-									);
-								}
+	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, string=): void} callback callback function
+	 * @returns {void}
+	 */
+	getContextHash(path, callback) {
+		const cache = this._contextHashes.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedHash(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextHash(cache, callback);
+		}
+		this.contextHashQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedHash(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextHash(entry, callback);
+		});
+	}
 
-								return true;
-							});
-					};
+	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, ContextHash=): void} callback callback function
+	 * @returns {void}
+	 */
+	_getUnresolvedContextHash(path, callback) {
+		const cache = this._contextHashes.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextHashQueue.add(path, callback);
+	}
 
-					const setConstant = (expressionName, value, warning) =>
-						setModuleConstant(expressionName, () => value, warning);
+	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, ResolvedContextTimestampAndHash=): void} callback callback function
+	 * @returns {void}
+	 */
+	getContextTsh(path, callback) {
+		const cache = this._contextTshs.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedTimestamp(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextTsh(cache, callback);
+		}
+		this.contextTshQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedTimestamp(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextTsh(entry, callback);
+		});
+	}
 
-					const context = compiler.context;
-					if (localOptions.__filename) {
-						switch (localOptions.__filename) {
-							case "mock":
-								setConstant("__filename", "/index.js");
-								break;
-							case "warn-mock":
-								setConstant(
-									"__filename",
-									"/index.js",
-									"The __filename is Node.js feature and doesn't present in browser."
-								);
-								break;
-							case true:
-								setModuleConstant("__filename", module =>
-									relative(compiler.inputFileSystem, context, module.resource)
-								);
-								break;
-						}
+	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, ContextTimestampAndHash=): void} callback callback function
+	 * @returns {void}
+	 */
+	_getUnresolvedContextTsh(path, callback) {
+		const cache = this._contextTshs.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextTshQueue.add(path, callback);
+	}
 
-						parser.hooks.evaluateIdentifier
-							.for("__filename")
-							.tap("NodeStuffPlugin", expr => {
-								if (!parser.state.module) return;
-								const resource = parseResource(parser.state.module.resource);
-								return evaluateToString(resource.path)(expr);
-							});
-					}
-					if (localOptions.__dirname) {
-						switch (localOptions.__dirname) {
-							case "mock":
-								setConstant("__dirname", "/");
-								break;
-							case "warn-mock":
-								setConstant(
-									"__dirname",
-									"/",
-									"The __dirname is Node.js feature and doesn't present in browser."
-								);
-								break;
-							case true:
-								setModuleConstant("__dirname", module =>
-									relative(compiler.inputFileSystem, context, module.context)
-								);
-								break;
-						}
-
-						parser.hooks.evaluateIdentifier
-							.for("__dirname")
-							.tap("NodeStuffPlugin", expr => {
-								if (!parser.state.module) return;
-								return evaluateToString(parser.state.module.context)(expr);
-							});
-					}
-					parser.hooks.expression
-						.for("require.extensions")
-						.tap(
-							"NodeStuffPlugin",
-							expressionIsUnsupported(
-								parser,
-								"require.extensions is not supported by webpack. Use a loader instead."
-							)
-						);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("NodeStuffPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("NodeStuffPlugin", handler);
-			}
-		);
-	}
-}
-
-module.exports = NodeStuffPlugin;
-
-
-/***/ }),
-
-/***/ 39:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const parseJson = __webpack_require__(15235);
-const { getContext, runLoaders } = __webpack_require__(8255);
-const querystring = __webpack_require__(63477);
-const { HookMap, SyncHook, AsyncSeriesBailHook } = __webpack_require__(6967);
-const {
-	CachedSource,
-	OriginalSource,
-	RawSource,
-	SourceMapSource
-} = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const HookWebpackError = __webpack_require__(11351);
-const Module = __webpack_require__(73208);
-const ModuleBuildError = __webpack_require__(21305);
-const ModuleError = __webpack_require__(23744);
-const ModuleGraphConnection = __webpack_require__(40639);
-const ModuleParseError = __webpack_require__(58443);
-const ModuleWarning = __webpack_require__(11234);
-const RuntimeGlobals = __webpack_require__(16475);
-const UnhandledSchemeError = __webpack_require__(68099);
-const WebpackError = __webpack_require__(53799);
-const formatLocation = __webpack_require__(16734);
-const LazySet = __webpack_require__(38938);
-const { isSubset } = __webpack_require__(93347);
-const { getScheme } = __webpack_require__(54500);
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	keepOriginalOrder
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const { createFakeHook } = __webpack_require__(64518);
-const { join } = __webpack_require__(17139);
-const {
-	contextify,
-	absolutify,
-	makePathsRelative
-} = __webpack_require__(82186);
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
-/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Generator")} Generator */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./Parser")} Parser */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
-/**
- * @typedef {Object} SourceMap
- * @property {number} version
- * @property {string[]} sources
- * @property {string} mappings
- * @property {string=} file
- * @property {string=} sourceRoot
- * @property {string[]=} sourcesContent
- * @property {string[]=} names
- */
-
-const getInvalidDependenciesModuleWarning = memoize(() =>
-	__webpack_require__(68257)
-);
-const getValidate = memoize(() => (__webpack_require__(38476).validate));
-
-const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
-
-/**
- * @typedef {Object} LoaderItem
- * @property {string} loader
- * @property {any} options
- * @property {string?} ident
- * @property {string?} type
- */
-
-/**
- * @param {string} context absolute context path
- * @param {string} source a source path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} new source path
- */
-const contextifySourceUrl = (context, source, associatedObjectForCache) => {
-	if (source.startsWith("webpack://")) return source;
-	return `webpack://${makePathsRelative(
-		context,
-		source,
-		associatedObjectForCache
-	)}`;
-};
-
-/**
- * @param {string} context absolute context path
- * @param {SourceMap} sourceMap a source map
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {SourceMap} new source map
- */
-const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
-	if (!Array.isArray(sourceMap.sources)) return sourceMap;
-	const { sourceRoot } = sourceMap;
-	/** @type {function(string): string} */
-	const mapper = !sourceRoot
-		? source => source
-		: sourceRoot.endsWith("/")
-		? source =>
-				source.startsWith("/")
-					? `${sourceRoot.slice(0, -1)}${source}`
-					: `${sourceRoot}${source}`
-		: source =>
-				source.startsWith("/")
-					? `${sourceRoot}${source}`
-					: `${sourceRoot}/${source}`;
-	const newSources = sourceMap.sources.map(source =>
-		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
-	);
-	return {
-		...sourceMap,
-		file: "x",
-		sourceRoot: undefined,
-		sources: newSources
-	};
-};
-
-/**
- * @param {string | Buffer} input the input
- * @returns {string} the converted string
- */
-const asString = input => {
-	if (Buffer.isBuffer(input)) {
-		return input.toString("utf-8");
-	}
-	return input;
-};
-
-/**
- * @param {string | Buffer} input the input
- * @returns {Buffer} the converted buffer
- */
-const asBuffer = input => {
-	if (!Buffer.isBuffer(input)) {
-		return Buffer.from(input, "utf-8");
-	}
-	return input;
-};
-
-class NonErrorEmittedError extends WebpackError {
-	constructor(error) {
-		super();
-
-		this.name = "NonErrorEmittedError";
-		this.message = "(Emitted value instead of an instance of Error) " + error;
-	}
-}
-
-makeSerializable(
-	NonErrorEmittedError,
-	"webpack/lib/NormalModule",
-	"NonErrorEmittedError"
-);
-
-/**
- * @typedef {Object} NormalModuleCompilationHooks
- * @property {SyncHook<[object, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
- * @property {SyncHook<[NormalModule]>} beforeParse
- * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
- * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
- */
-
-/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class NormalModule extends Module {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {NormalModuleCompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				loader: new SyncHook(["loaderContext", "module"]),
-				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				beforeParse: new SyncHook(["module"]),
-				beforeSnapshot: new SyncHook(["module"]),
-				// TODO webpack 6 deprecate
-				readResourceForScheme: new HookMap(scheme => {
-					const hook = hooks.readResource.for(scheme);
-					return createFakeHook(
-						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
-							tap: (options, fn) =>
-								hook.tap(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
-								),
-							tapAsync: (options, fn) =>
-								hook.tapAsync(options, (loaderContext, callback) =>
-									fn(loaderContext.resource, loaderContext._module, callback)
-								),
-							tapPromise: (options, fn) =>
-								hook.tapPromise(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
-								)
-						})
-					);
-				}),
-				readResource: new HookMap(
-					() => new AsyncSeriesBailHook(["loaderContext"])
-				),
-				needBuild: new AsyncSeriesBailHook(["module", "context"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.layer an optional layer in which the module is
-	 * @param {string} options.type module type
-	 * @param {string} options.request request string
-	 * @param {string} options.userRequest request intended by user (without loaders from config)
-	 * @param {string} options.rawRequest request without resolving
-	 * @param {LoaderItem[]} options.loaders list of loaders
-	 * @param {string} options.resource path + query of the real resource
-	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
-	 * @param {string} options.context context directory for resolving
-	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
-	 * @param {Parser} options.parser the parser used
-	 * @param {object} options.parserOptions the options of the parser used
-	 * @param {Generator} options.generator the generator used
-	 * @param {object} options.generatorOptions the options of the generator used
-	 * @param {Object} options.resolveOptions options used for resolving requests from this module
-	 */
-	constructor({
-		layer,
-		type,
-		request,
-		userRequest,
-		rawRequest,
-		loaders,
-		resource,
-		resourceResolveData,
-		context,
-		matchResource,
-		parser,
-		parserOptions,
-		generator,
-		generatorOptions,
-		resolveOptions
-	}) {
-		super(type, context || getContext(resource), layer);
-
-		// Info from Factory
-		/** @type {string} */
-		this.request = request;
-		/** @type {string} */
-		this.userRequest = userRequest;
-		/** @type {string} */
-		this.rawRequest = rawRequest;
-		/** @type {boolean} */
-		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {Parser} */
-		this.parser = parser;
-		this.parserOptions = parserOptions;
-		/** @type {Generator} */
-		this.generator = generator;
-		this.generatorOptions = generatorOptions;
-		/** @type {string} */
-		this.resource = resource;
-		this.resourceResolveData = resourceResolveData;
-		/** @type {string | undefined} */
-		this.matchResource = matchResource;
-		/** @type {LoaderItem[]} */
-		this.loaders = loaders;
-		if (resolveOptions !== undefined) {
-			// already declared in super class
-			this.resolveOptions = resolveOptions;
-		}
-
-		// Info from Build
-		/** @type {(WebpackError | null)=} */
-		this.error = null;
-		/** @private @type {Source=} */
-		this._source = null;
-		/** @private @type {Map<string, number> | undefined} **/
-		this._sourceSizes = undefined;
-		/** @private @type {Set<string>} */
-		this._sourceTypes = undefined;
-
-		// Cache
-		this._lastSuccessfulBuildMeta = {};
-		this._forceBuild = true;
-		this._isEvaluatingSideEffects = false;
-		/** @type {WeakSet<ModuleGraph> | undefined} */
-		this._addedSideEffectsBailout = undefined;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		if (this.layer === null) {
-			if (this.type === "javascript/auto") {
-				return this.request;
-			} else {
-				return `${this.type}|${this.request}`;
-			}
-		} else {
-			return `${this.type}|${this.request}|${this.layer}`;
-		}
-	}
-
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.userRequest);
-	}
-
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		let ident = contextify(
-			options.context,
-			this.userRequest,
-			options.associatedObjectForCache
-		);
-		if (this.layer) ident = `(${this.layer})/${ident}`;
-		return ident;
-	}
-
-	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
-	 */
-	nameForCondition() {
-		const resource = this.matchResource || this.resource;
-		const idx = resource.indexOf("?");
-		if (idx >= 0) return resource.substr(0, idx);
-		return resource;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {NormalModule} */ (module);
-		this.binary = m.binary;
-		this.request = m.request;
-		this.userRequest = m.userRequest;
-		this.rawRequest = m.rawRequest;
-		this.parser = m.parser;
-		this.parserOptions = m.parserOptions;
-		this.generator = m.generator;
-		this.generatorOptions = m.generatorOptions;
-		this.resource = m.resource;
-		this.resourceResolveData = m.resourceResolveData;
-		this.context = m.context;
-		this.matchResource = m.matchResource;
-		this.loaders = m.loaders;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
-	 */
-	cleanupForCache() {
-		// Make sure to cache types and sizes before cleanup when this module has been built
-		// They are accessed by the stats and we don't want them to crash after cleanup
-		// TODO reconsider this for webpack 6
-		if (this.buildInfo) {
-			if (this._sourceTypes === undefined) this.getSourceTypes();
-			for (const type of this._sourceTypes) {
-				this.size(type);
-			}
-		}
-		super.cleanupForCache();
-		this.parser = undefined;
-		this.parserOptions = undefined;
-		this.generator = undefined;
-		this.generatorOptions = undefined;
-	}
-
-	/**
-	 * Module should be unsafe cached. Get data that's needed for that.
-	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
-	 */
-	getUnsafeCacheData() {
-		const data = super.getUnsafeCacheData();
-		data.parserOptions = this.parserOptions;
-		data.generatorOptions = this.generatorOptions;
-		return data;
-	}
-
-	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
-	}
-
-	/**
-	 * restore unsafe cache data
-	 * @param {object} unsafeCacheData data from getUnsafeCacheData
-	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
-	 */
-	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
-		this.parserOptions = unsafeCacheData.parserOptions;
-		this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);
-		this.generatorOptions = unsafeCacheData.generatorOptions;
-		this.generator = normalModuleFactory.getGenerator(
-			this.type,
-			this.generatorOptions
-		);
-		// we assume the generator behaves identically and keep cached sourceTypes/Sizes
-	}
-
-	/**
-	 * @param {string} context the compilation context
-	 * @param {string} name the asset name
-	 * @param {string} content the content
-	 * @param {string | TODO} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @returns {Source} the created source
-	 */
-	createSourceForAsset(
-		context,
-		name,
-		content,
-		sourceMap,
-		associatedObjectForCache
-	) {
-		if (sourceMap) {
-			if (
-				typeof sourceMap === "string" &&
-				(this.useSourceMap || this.useSimpleSourceMap)
-			) {
-				return new OriginalSource(
-					content,
-					contextifySourceUrl(context, sourceMap, associatedObjectForCache)
-				);
-			}
-
-			if (this.useSourceMap) {
-				return new SourceMapSource(
-					content,
-					name,
-					contextifySourceMap(context, sourceMap, associatedObjectForCache)
-				);
-			}
-		}
-
-		return new RawSource(content);
-	}
-
-	/**
-	 * @param {ResolverWithOptions} resolver a resolver
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {InputFileSystem} fs file system from reading
-	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {NormalModuleLoaderContext} loader context
-	 */
-	_createLoaderContext(resolver, options, compilation, fs, hooks) {
-		const { requestShortener } = compilation.runtimeTemplate;
-		const getCurrentLoaderName = () => {
-			const currentLoader = this.getCurrentLoader(loaderContext);
-			if (!currentLoader) return "(not in loader scope)";
-			return requestShortener.shorten(currentLoader.loader);
-		};
-		const getResolveContext = () => {
-			return {
-				fileDependencies: {
-					add: d => loaderContext.addDependency(d)
-				},
-				contextDependencies: {
-					add: d => loaderContext.addContextDependency(d)
-				},
-				missingDependencies: {
-					add: d => loaderContext.addMissingDependency(d)
-				}
-			};
-		};
-		const getAbsolutify = memoize(() =>
-			absolutify.bindCache(compilation.compiler.root)
-		);
-		const getAbsolutifyInContext = memoize(() =>
-			absolutify.bindContextCache(this.context, compilation.compiler.root)
-		);
-		const getContextify = memoize(() =>
-			contextify.bindCache(compilation.compiler.root)
-		);
-		const getContextifyInContext = memoize(() =>
-			contextify.bindContextCache(this.context, compilation.compiler.root)
-		);
-		const utils = {
-			absolutify: (context, request) => {
-				return context === this.context
-					? getAbsolutifyInContext()(request)
-					: getAbsolutify()(context, request);
-			},
-			contextify: (context, request) => {
-				return context === this.context
-					? getContextifyInContext()(request)
-					: getContextify()(context, request);
-			},
-			createHash: type => {
-				return createHash(type || compilation.outputOptions.hashFunction);
-			}
-		};
-		const loaderContext = {
-			version: 2,
-			getOptions: schema => {
-				const loader = this.getCurrentLoader(loaderContext);
-
-				let { options } = loader;
-
-				if (typeof options === "string") {
-					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
-						try {
-							options = parseJson(options);
-						} catch (e) {
-							throw new Error(`Cannot parse string options: ${e.message}`);
-						}
-					} else {
-						options = querystring.parse(options, "&", "=", {
-							maxKeys: 0
-						});
-					}
-				}
-
-				if (options === null || options === undefined) {
-					options = {};
-				}
-
-				if (schema) {
-					let name = "Loader";
-					let baseDataPath = "options";
-					let match;
-					if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
-						[, name, baseDataPath] = match;
-					}
-					getValidate()(schema, options, {
-						name,
-						baseDataPath
-					});
-				}
-
-				return options;
-			},
-			emitWarning: warning => {
-				if (!(warning instanceof Error)) {
-					warning = new NonErrorEmittedError(warning);
-				}
-				this.addWarning(
-					new ModuleWarning(warning, {
-						from: getCurrentLoaderName()
-					})
-				);
-			},
-			emitError: error => {
-				if (!(error instanceof Error)) {
-					error = new NonErrorEmittedError(error);
-				}
-				this.addError(
-					new ModuleError(error, {
-						from: getCurrentLoaderName()
-					})
-				);
-			},
-			getLogger: name => {
-				const currentLoader = this.getCurrentLoader(loaderContext);
-				return compilation.getLogger(() =>
-					[currentLoader && currentLoader.loader, name, this.identifier()]
-						.filter(Boolean)
-						.join("|")
-				);
-			},
-			resolve(context, request, callback) {
-				resolver.resolve({}, context, request, getResolveContext(), callback);
-			},
-			getResolve(options) {
-				const child = options ? resolver.withOptions(options) : resolver;
-				return (context, request, callback) => {
-					if (callback) {
-						child.resolve({}, context, request, getResolveContext(), callback);
-					} else {
-						return new Promise((resolve, reject) => {
-							child.resolve(
-								{},
-								context,
-								request,
-								getResolveContext(),
-								(err, result) => {
-									if (err) reject(err);
-									else resolve(result);
-								}
-							);
-						});
-					}
-				};
-			},
-			emitFile: (name, content, sourceMap, assetInfo) => {
-				if (!this.buildInfo.assets) {
-					this.buildInfo.assets = Object.create(null);
-					this.buildInfo.assetsInfo = new Map();
-				}
-				this.buildInfo.assets[name] = this.createSourceForAsset(
-					options.context,
-					name,
-					content,
-					sourceMap,
-					compilation.compiler.root
-				);
-				this.buildInfo.assetsInfo.set(name, assetInfo);
-			},
-			addBuildDependency: dep => {
-				if (this.buildInfo.buildDependencies === undefined) {
-					this.buildInfo.buildDependencies = new LazySet();
-				}
-				this.buildInfo.buildDependencies.add(dep);
-			},
-			utils,
-			rootContext: options.context,
-			webpack: true,
-			sourceMap: !!this.useSourceMap,
-			mode: options.mode || "production",
-			_module: this,
-			_compilation: compilation,
-			_compiler: compilation.compiler,
-			fs: fs
-		};
-
-		Object.assign(loaderContext, options.loader);
-
-		hooks.loader.call(loaderContext, this);
-
-		return loaderContext;
-	}
-
-	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
-		if (
-			this.loaders &&
-			this.loaders.length &&
-			index < this.loaders.length &&
-			index >= 0 &&
-			this.loaders[index]
-		) {
-			return this.loaders[index];
-		}
-		return null;
-	}
-
-	/**
-	 * @param {string} context the compilation context
-	 * @param {string | Buffer} content the content
-	 * @param {string | TODO} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @returns {Source} the created source
-	 */
-	createSource(context, content, sourceMap, associatedObjectForCache) {
-		if (Buffer.isBuffer(content)) {
-			return new RawSource(content);
-		}
-
-		// if there is no identifier return raw source
-		if (!this.identifier) {
-			return new RawSource(content);
-		}
-
-		// from here on we assume we have an identifier
-		const identifier = this.identifier();
-
-		if (this.useSourceMap && sourceMap) {
-			return new SourceMapSource(
-				content,
-				contextifySourceUrl(context, identifier, associatedObjectForCache),
-				contextifySourceMap(context, sourceMap, associatedObjectForCache)
-			);
-		}
-
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(
-				content,
-				contextifySourceUrl(context, identifier, associatedObjectForCache)
-			);
-		}
-
-		return new RawSource(content);
-	}
-
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @param {function((WebpackError | null)=): void} callback callback function
-	 * @returns {void}
-	 */
-	_doBuild(options, compilation, resolver, fs, hooks, callback) {
-		const loaderContext = this._createLoaderContext(
-			resolver,
-			options,
-			compilation,
-			fs,
-			hooks
-		);
-
-		const processResult = (err, result) => {
-			if (err) {
-				if (!(err instanceof Error)) {
-					err = new NonErrorEmittedError(err);
-				}
-				const currentLoader = this.getCurrentLoader(loaderContext);
-				const error = new ModuleBuildError(err, {
-					from:
-						currentLoader &&
-						compilation.runtimeTemplate.requestShortener.shorten(
-							currentLoader.loader
-						)
-				});
-				return callback(error);
-			}
-
-			const source = result[0];
-			const sourceMap = result.length >= 1 ? result[1] : null;
-			const extraInfo = result.length >= 2 ? result[2] : null;
-
-			if (!Buffer.isBuffer(source) && typeof source !== "string") {
-				const currentLoader = this.getCurrentLoader(loaderContext, 0);
-				const err = new Error(
-					`Final loader (${
-						currentLoader
-							? compilation.runtimeTemplate.requestShortener.shorten(
-									currentLoader.loader
-							  )
-							: "unknown"
-					}) didn't return a Buffer or String`
-				);
-				const error = new ModuleBuildError(err);
-				return callback(error);
-			}
-
-			this._source = this.createSource(
-				options.context,
-				this.binary ? asBuffer(source) : asString(source),
-				sourceMap,
-				compilation.compiler.root
-			);
-			if (this._sourceSizes !== undefined) this._sourceSizes.clear();
-			this._ast =
-				typeof extraInfo === "object" &&
-				extraInfo !== null &&
-				extraInfo.webpackAST !== undefined
-					? extraInfo.webpackAST
-					: null;
-			return callback();
-		};
-
-		this.buildInfo.fileDependencies = new LazySet();
-		this.buildInfo.contextDependencies = new LazySet();
-		this.buildInfo.missingDependencies = new LazySet();
-		this.buildInfo.cacheable = true;
-
-		try {
-			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
-		} catch (err) {
-			processResult(err);
-			return;
-		}
-
-		if (this.loaders.length > 0) {
-			this.buildInfo.buildDependencies = new LazySet();
-		}
-
-		runLoaders(
-			{
-				resource: this.resource,
-				loaders: this.loaders,
-				context: loaderContext,
-				processResource: (loaderContext, resourcePath, callback) => {
-					const resource = loaderContext.resource;
-					const scheme = getScheme(resource);
-					hooks.readResource
-						.for(scheme)
-						.callAsync(loaderContext, (err, result) => {
-							if (err) return callback(err);
-							if (typeof result !== "string" && !result) {
-								return callback(new UnhandledSchemeError(scheme, resource));
-							}
-							return callback(null, result);
-						});
-				}
-			},
-			(err, result) => {
-				// Cleanup loaderContext to avoid leaking memory in ICs
-				loaderContext._compilation =
-					loaderContext._compiler =
-					loaderContext._module =
-					loaderContext.fs =
-						undefined;
-
-				if (!result) {
-					this.buildInfo.cacheable = false;
-					return processResult(
-						err || new Error("No result from loader-runner processing"),
-						null
-					);
-				}
-				this.buildInfo.fileDependencies.addAll(result.fileDependencies);
-				this.buildInfo.contextDependencies.addAll(result.contextDependencies);
-				this.buildInfo.missingDependencies.addAll(result.missingDependencies);
-				for (const loader of this.loaders) {
-					this.buildInfo.buildDependencies.add(loader.loader);
-				}
-				this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
-				processResult(err, result.result);
-			}
-		);
-	}
-
-	/**
-	 * @param {WebpackError} error the error
-	 * @returns {void}
-	 */
-	markModuleAsErrored(error) {
-		// Restore build meta from successful build to keep importing state
-		this.buildMeta = { ...this._lastSuccessfulBuildMeta };
-		this.error = error;
-		this.addError(error);
-	}
-
-	applyNoParseRule(rule, content) {
-		// must start with "rule" if rule is a string
-		if (typeof rule === "string") {
-			return content.startsWith(rule);
-		}
-
-		if (typeof rule === "function") {
-			return rule(content);
-		}
-		// we assume rule is a regexp
-		return rule.test(content);
-	}
-
-	// check if module should not be parsed
-	// returns "true" if the module should !not! be parsed
-	// returns "false" if the module !must! be parsed
-	shouldPreventParsing(noParseRule, request) {
-		// if no noParseRule exists, return false
-		// the module !must! be parsed.
-		if (!noParseRule) {
-			return false;
-		}
-
-		// we only have one rule to check
-		if (!Array.isArray(noParseRule)) {
-			// returns "true" if the module is !not! to be parsed
-			return this.applyNoParseRule(noParseRule, request);
-		}
-
-		for (let i = 0; i < noParseRule.length; i++) {
-			const rule = noParseRule[i];
-			// early exit on first truthy match
-			// this module is !not! to be parsed
-			if (this.applyNoParseRule(rule, request)) {
-				return true;
-			}
-		}
-		// no match found, so this module !should! be parsed
-		return false;
-	}
-
-	_initBuildHash(compilation) {
-		const hash = createHash(compilation.outputOptions.hashFunction);
-		if (this._source) {
-			hash.update("source");
-			this._source.updateHash(hash);
-		}
-		hash.update("meta");
-		hash.update(JSON.stringify(this.buildMeta));
-		this.buildInfo.hash = /** @type {string} */ (hash.digest("hex"));
-	}
-
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this._forceBuild = false;
-		this._source = null;
-		if (this._sourceSizes !== undefined) this._sourceSizes.clear();
-		this._sourceTypes = undefined;
-		this._ast = null;
-		this.error = null;
-		this.clearWarningsAndErrors();
-		this.clearDependenciesAndBlocks();
-		this.buildMeta = {};
-		this.buildInfo = {
-			cacheable: false,
-			parsed: true,
-			fileDependencies: undefined,
-			contextDependencies: undefined,
-			missingDependencies: undefined,
-			buildDependencies: undefined,
-			valueDependencies: undefined,
-			hash: undefined,
-			assets: undefined,
-			assetsInfo: undefined
-		};
-
-		const startTime = compilation.compiler.fsStartTime || Date.now();
-
-		const hooks = NormalModule.getCompilationHooks(compilation);
-
-		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
-			// if we have an error mark module as failed and exit
-			if (err) {
-				this.markModuleAsErrored(err);
-				this._initBuildHash(compilation);
-				return callback();
-			}
-
-			const handleParseError = e => {
-				const source = this._source.source();
-				const loaders = this.loaders.map(item =>
-					contextify(options.context, item.loader, compilation.compiler.root)
-				);
-				const error = new ModuleParseError(source, e, loaders, this.type);
-				this.markModuleAsErrored(error);
-				this._initBuildHash(compilation);
-				return callback();
-			};
-
-			const handleParseResult = result => {
-				this.dependencies.sort(
-					concatComparators(
-						compareSelect(a => a.loc, compareLocations),
-						keepOriginalOrder(this.dependencies)
-					)
-				);
-				this._initBuildHash(compilation);
-				this._lastSuccessfulBuildMeta = this.buildMeta;
-				return handleBuildDone();
-			};
-
-			const handleBuildDone = () => {
-				try {
-					hooks.beforeSnapshot.call(this);
-				} catch (err) {
-					this.markModuleAsErrored(err);
-					return callback();
-				}
-
-				const snapshotOptions = compilation.options.snapshot.module;
-				if (!this.buildInfo.cacheable || !snapshotOptions) {
-					return callback();
-				}
-				// add warning for all non-absolute paths in fileDependencies, etc
-				// This makes it easier to find problems with watching and/or caching
-				let nonAbsoluteDependencies = undefined;
-				const checkDependencies = deps => {
-					for (const dep of deps) {
-						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
-							if (nonAbsoluteDependencies === undefined)
-								nonAbsoluteDependencies = new Set();
-							nonAbsoluteDependencies.add(dep);
-							deps.delete(dep);
-							try {
-								const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, "");
-								const absolute = join(
-									compilation.fileSystemInfo.fs,
-									this.context,
-									depWithoutGlob
-								);
-								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
-									(depWithoutGlob !== dep
-										? this.buildInfo.contextDependencies
-										: deps
-									).add(absolute);
-								}
-							} catch (e) {
-								// ignore
-							}
-						}
-					}
-				};
-				checkDependencies(this.buildInfo.fileDependencies);
-				checkDependencies(this.buildInfo.missingDependencies);
-				checkDependencies(this.buildInfo.contextDependencies);
-				if (nonAbsoluteDependencies !== undefined) {
-					const InvalidDependenciesModuleWarning =
-						getInvalidDependenciesModuleWarning();
-					this.addWarning(
-						new InvalidDependenciesModuleWarning(this, nonAbsoluteDependencies)
-					);
-				}
-				// convert file/context/missingDependencies into filesystem snapshot
-				compilation.fileSystemInfo.createSnapshot(
-					startTime,
-					this.buildInfo.fileDependencies,
-					this.buildInfo.contextDependencies,
-					this.buildInfo.missingDependencies,
-					snapshotOptions,
-					(err, snapshot) => {
-						if (err) {
-							this.markModuleAsErrored(err);
-							return;
-						}
-						this.buildInfo.fileDependencies = undefined;
-						this.buildInfo.contextDependencies = undefined;
-						this.buildInfo.missingDependencies = undefined;
-						this.buildInfo.snapshot = snapshot;
-						return callback();
-					}
-				);
-			};
-
-			try {
-				hooks.beforeParse.call(this);
-			} catch (err) {
-				this.markModuleAsErrored(err);
-				this._initBuildHash(compilation);
-				return callback();
-			}
-
-			// check if this module should !not! be parsed.
-			// if so, exit here;
-			const noParseRule = options.module && options.module.noParse;
-			if (this.shouldPreventParsing(noParseRule, this.request)) {
-				// We assume that we need module and exports
-				this.buildInfo.parsed = false;
-				this._initBuildHash(compilation);
-				return handleBuildDone();
-			}
-
-			let result;
-			try {
-				const source = this._source.source();
-				result = this.parser.parse(this._ast || source, {
-					source,
-					current: this,
-					module: this,
-					compilation: compilation,
-					options: options
-				});
-			} catch (e) {
-				handleParseError(e);
-				return;
-			}
-			handleParseResult(result);
-		});
-	}
-
-	/**
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(context) {
-		return this.generator.getConcatenationBailoutReason(this, context);
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
-	 */
-	getSideEffectsConnectionState(moduleGraph) {
-		if (this.factoryMeta !== undefined) {
-			if (this.factoryMeta.sideEffectFree) return false;
-			if (this.factoryMeta.sideEffectFree === false) return true;
-		}
-		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
-			if (this._isEvaluatingSideEffects)
-				return ModuleGraphConnection.CIRCULAR_CONNECTION;
-			this._isEvaluatingSideEffects = true;
-			/** @type {ConnectionState} */
-			let current = false;
-			for (const dep of this.dependencies) {
-				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
-				if (state === true) {
-					if (
-						this._addedSideEffectsBailout === undefined
-							? ((this._addedSideEffectsBailout = new WeakSet()), true)
-							: !this._addedSideEffectsBailout.has(moduleGraph)
-					) {
-						this._addedSideEffectsBailout.add(moduleGraph);
-						moduleGraph
-							.getOptimizationBailout(this)
-							.push(
-								() =>
-									`Dependency (${
-										dep.type
-									}) with side effects at ${formatLocation(dep.loc)}`
-							);
-					}
-					this._isEvaluatingSideEffects = false;
-					return true;
-				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
-					current = ModuleGraphConnection.addConnectionStates(current, state);
-				}
-			}
-			this._isEvaluatingSideEffects = false;
-			// When caching is implemented here, make sure to not cache when
-			// at least one circular connection was in the loop above
-			return current;
-		} else {
-			return true;
-		}
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		if (this._sourceTypes === undefined) {
-			this._sourceTypes = this.generator.getTypes(this);
-		}
-		return this._sourceTypes;
-	}
-
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({
-		dependencyTemplates,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime,
-		concatenationScope,
-		codeGenerationResults
-	}) {
-		/** @type {Set<string>} */
-		const runtimeRequirements = new Set();
-
-		if (!this.buildInfo.parsed) {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-		}
-
-		/** @type {Map<string, any>} */
-		let data;
-		const getData = () => {
-			if (data === undefined) data = new Map();
-			return data;
-		};
-
-		const sources = new Map();
-		for (const type of this.generator.getTypes(this)) {
-			const source = this.error
-				? new RawSource(
-						"throw new Error(" + JSON.stringify(this.error.message) + ");"
-				  )
-				: this.generator.generate(this, {
-						dependencyTemplates,
-						runtimeTemplate,
-						moduleGraph,
-						chunkGraph,
-						runtimeRequirements,
-						runtime,
-						concatenationScope,
-						codeGenerationResults,
-						getData,
-						type
-				  });
-
-			if (source) {
-				sources.set(type, new CachedSource(source));
-			}
-		}
-
-		/** @type {CodeGenerationResult} */
-		const resultEntry = {
-			sources,
-			runtimeRequirements,
-			data
-		};
-		return resultEntry;
-	}
-
-	/**
-	 * @returns {Source | null} the original source for the module before webpack transformation
-	 */
-	originalSource() {
-		return this._source;
-	}
-
-	/**
-	 * @returns {void}
-	 */
-	invalidateBuild() {
-		this._forceBuild = true;
-	}
-
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		const { fileSystemInfo, compilation, valueCacheVersions } = context;
-		// build if enforced
-		if (this._forceBuild) return callback(null, true);
-
-		// always try to build in case of an error
-		if (this.error) return callback(null, true);
-
-		// always build when module is not cacheable
-		if (!this.buildInfo.cacheable) return callback(null, true);
-
-		// build when there is no snapshot to check
-		if (!this.buildInfo.snapshot) return callback(null, true);
-
-		// build when valueDependencies have changed
-		/** @type {Map<string, string | Set<string>>} */
-		const valueDependencies = this.buildInfo.valueDependencies;
-		if (valueDependencies) {
-			if (!valueCacheVersions) return callback(null, true);
-			for (const [key, value] of valueDependencies) {
-				if (value === undefined) return callback(null, true);
-				const current = valueCacheVersions.get(key);
-				if (
-					value !== current &&
-					(typeof value === "string" ||
-						typeof current === "string" ||
-						current === undefined ||
-						!isSubset(value, current))
-				) {
-					return callback(null, true);
-				}
-			}
-		}
-
-		// check snapshot for validity
-		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
-			if (err) return callback(err);
-			if (!valid) return callback(null, true);
-			const hooks = NormalModule.getCompilationHooks(compilation);
-			hooks.needBuild.callAsync(this, context, (err, needBuild) => {
-				if (err) {
-					return callback(
-						HookWebpackError.makeWebpackError(
-							err,
-							"NormalModule.getCompilationHooks().needBuild"
-						)
-					);
-				}
-				callback(null, !!needBuild);
-			});
-		});
-	}
-
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		const cachedSize =
-			this._sourceSizes === undefined ? undefined : this._sourceSizes.get(type);
-		if (cachedSize !== undefined) {
-			return cachedSize;
-		}
-		const size = Math.max(1, this.generator.getSize(this, type));
-		if (this._sourceSizes === undefined) {
-			this._sourceSizes = new Map();
-		}
-		this._sourceSizes.set(type, size);
-		return size;
-	}
-
-	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
-	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {
-		const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
-		if (snapshot) {
-			fileDependencies.addAll(snapshot.getFileIterable());
-			contextDependencies.addAll(snapshot.getContextIterable());
-			missingDependencies.addAll(snapshot.getMissingIterable());
-		} else {
-			const {
-				fileDependencies: fileDeps,
-				contextDependencies: contextDeps,
-				missingDependencies: missingDeps
-			} = this.buildInfo;
-			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
-			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
-			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
-		}
-		if (buildDeps !== undefined) {
-			buildDependencies.addAll(buildDeps);
-		}
-	}
-
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(this.buildInfo.hash);
-		this.generator.updateHash(hash, {
-			module: this,
-			...context
-		});
-		super.updateHash(hash, context);
-	}
-
-	serialize(context) {
-		const { write } = context;
-		// deserialize
-		write(this._source);
-		write(this.error);
-		write(this._lastSuccessfulBuildMeta);
-		write(this._forceBuild);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const obj = new NormalModule({
-			// will be deserialized by Module
-			layer: null,
-			type: "",
-			// will be filled by updateCacheModule
-			resource: "",
-			context: "",
-			request: null,
-			userRequest: null,
-			rawRequest: null,
-			loaders: null,
-			matchResource: null,
-			parser: null,
-			parserOptions: null,
-			generator: null,
-			generatorOptions: null,
-			resolveOptions: null
-		});
-		obj.deserialize(context);
-		return obj;
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this._source = read();
-		this.error = read();
-		this._lastSuccessfulBuildMeta = read();
-		this._forceBuild = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(NormalModule, "webpack/lib/NormalModule");
-
-module.exports = NormalModule;
-
-
-/***/ }),
-
-/***/ 68860:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { getContext } = __webpack_require__(8255);
-const asyncLib = __webpack_require__(78175);
-const {
-	AsyncSeriesBailHook,
-	SyncWaterfallHook,
-	SyncBailHook,
-	SyncHook,
-	HookMap
-} = __webpack_require__(6967);
-const ChunkGraph = __webpack_require__(64971);
-const Module = __webpack_require__(73208);
-const ModuleFactory = __webpack_require__(51010);
-const ModuleGraph = __webpack_require__(99988);
-const NormalModule = __webpack_require__(39);
-const BasicEffectRulePlugin = __webpack_require__(30318);
-const BasicMatcherRulePlugin = __webpack_require__(94215);
-const ObjectMatcherRulePlugin = __webpack_require__(72021);
-const RuleSetCompiler = __webpack_require__(83349);
-const UseEffectRulePlugin = __webpack_require__(84977);
-const LazySet = __webpack_require__(38938);
-const { getScheme } = __webpack_require__(54500);
-const { cachedCleverMerge, cachedSetProperty } = __webpack_require__(60839);
-const { join } = __webpack_require__(17139);
-const { parseResource } = __webpack_require__(82186);
-
-/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("./Generator")} Generator */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./Parser")} Parser */
-/** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-/**
- * @typedef {Object} ResolveData
- * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
- * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
- * @property {string} context
- * @property {string} request
- * @property {Record<string, any> | undefined} assertions
- * @property {ModuleDependency[]} dependencies
- * @property {string} dependencyType
- * @property {Object} createData
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} contextDependencies
- * @property {boolean} cacheable allow to use the unsafe cache
- */
-
-/**
- * @typedef {Object} ResourceData
- * @property {string} resource
- * @property {string} path
- * @property {string} query
- * @property {string} fragment
- * @property {string=} context
- */
-
-/** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
-
-const EMPTY_RESOLVE_OPTIONS = {};
-const EMPTY_PARSER_OPTIONS = {};
-const EMPTY_GENERATOR_OPTIONS = {};
-const EMPTY_ELEMENTS = [];
-
-const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
-
-const loaderToIdent = data => {
-	if (!data.options) {
-		return data.loader;
-	}
-	if (typeof data.options === "string") {
-		return data.loader + "?" + data.options;
-	}
-	if (typeof data.options !== "object") {
-		throw new Error("loader options must be string or object");
-	}
-	if (data.ident) {
-		return data.loader + "??" + data.ident;
-	}
-	return data.loader + "?" + JSON.stringify(data.options);
-};
-
-const stringifyLoadersAndResource = (loaders, resource) => {
-	let str = "";
-	for (const loader of loaders) {
-		str += loaderToIdent(loader) + "!";
-	}
-	return str + resource;
-};
-
-/**
- * @param {string} resultString resultString
- * @returns {{loader: string, options: string|undefined}} parsed loader request
- */
-const identToLoaderRequest = resultString => {
-	const idx = resultString.indexOf("?");
-	if (idx >= 0) {
-		const loader = resultString.substr(0, idx);
-		const options = resultString.substr(idx + 1);
-		return {
-			loader,
-			options
-		};
-	} else {
-		return {
-			loader: resultString,
-			options: undefined
-		};
-	}
-};
-
-const needCalls = (times, callback) => {
-	return err => {
-		if (--times === 0) {
-			return callback(err);
-		}
-		if (err && times > 0) {
-			times = NaN;
-			return callback(err);
-		}
-	};
-};
-
-const mergeGlobalOptions = (globalOptions, type, localOptions) => {
-	const parts = type.split("/");
-	let result;
-	let current = "";
-	for (const part of parts) {
-		current = current ? `${current}/${part}` : part;
-		const options = globalOptions[current];
-		if (typeof options === "object") {
-			if (result === undefined) {
-				result = options;
-			} else {
-				result = cachedCleverMerge(result, options);
-			}
-		}
-	}
-	if (result === undefined) {
-		return localOptions;
-	} else {
-		return cachedCleverMerge(result, localOptions);
-	}
-};
-
-// TODO webpack 6 remove
-const deprecationChangedHookMessage = (name, hook) => {
-	const names = hook.taps
-		.map(tapped => {
-			return tapped.name;
-		})
-		.join(", ");
-
-	return (
-		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
-		"Do not return the passed object, but modify it instead. " +
-		"Returning false will ignore the request and results in no module created."
-	);
-};
-
-const ruleSetCompiler = new RuleSetCompiler([
-	new BasicMatcherRulePlugin("test", "resource"),
-	new BasicMatcherRulePlugin("scheme"),
-	new BasicMatcherRulePlugin("mimetype"),
-	new BasicMatcherRulePlugin("dependency"),
-	new BasicMatcherRulePlugin("include", "resource"),
-	new BasicMatcherRulePlugin("exclude", "resource", true),
-	new BasicMatcherRulePlugin("resource"),
-	new BasicMatcherRulePlugin("resourceQuery"),
-	new BasicMatcherRulePlugin("resourceFragment"),
-	new BasicMatcherRulePlugin("realResource"),
-	new BasicMatcherRulePlugin("issuer"),
-	new BasicMatcherRulePlugin("compiler"),
-	new BasicMatcherRulePlugin("issuerLayer"),
-	new ObjectMatcherRulePlugin("assert", "assertions"),
-	new ObjectMatcherRulePlugin("descriptionData"),
-	new BasicEffectRulePlugin("type"),
-	new BasicEffectRulePlugin("sideEffects"),
-	new BasicEffectRulePlugin("parser"),
-	new BasicEffectRulePlugin("resolve"),
-	new BasicEffectRulePlugin("generator"),
-	new BasicEffectRulePlugin("layer"),
-	new UseEffectRulePlugin()
-]);
-
-class NormalModuleFactory extends ModuleFactory {
-	/**
-	 * @param {Object} param params
-	 * @param {string=} param.context context
-	 * @param {InputFileSystem} param.fs file system
-	 * @param {ResolverFactory} param.resolverFactory resolverFactory
-	 * @param {ModuleOptions} param.options options
-	 * @param {Object=} param.associatedObjectForCache an object to which the cache will be attached
-	 * @param {boolean=} param.layers enable layers
-	 */
-	constructor({
-		context,
-		fs,
-		resolverFactory,
-		options,
-		associatedObjectForCache,
-		layers = false
-	}) {
-		super();
-		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			resolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-			resolveForScheme: new HookMap(
-				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
-			),
-			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-			resolveInScheme: new HookMap(
-				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
-			),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			factorize: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
-			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
-			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
-			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-			createGenerator: new HookMap(
-				() => new SyncBailHook(["generatorOptions"])
-			),
-			generator: new HookMap(
-				() => new SyncHook(["generator", "generatorOptions"])
-			)
-		});
-		this.resolverFactory = resolverFactory;
-		this.ruleSet = ruleSetCompiler.compile([
-			{
-				rules: options.defaultRules
-			},
-			{
-				rules: options.rules
-			}
-		]);
-		this.context = context || "";
-		this.fs = fs;
-		this._globalParserOptions = options.parser;
-		this._globalGeneratorOptions = options.generator;
-		/** @type {Map<string, WeakMap<Object, TODO>>} */
-		this.parserCache = new Map();
-		/** @type {Map<string, WeakMap<Object, Generator>>} */
-		this.generatorCache = new Map();
-		/** @type {Set<Module>} */
-		this._restoredUnsafeCacheEntries = new Set();
-
-		const cacheParseResource = parseResource.bindCache(
-			associatedObjectForCache
-		);
-
-		this.hooks.factorize.tapAsync(
-			{
-				name: "NormalModuleFactory",
-				stage: 100
-			},
-			(resolveData, callback) => {
-				this.hooks.resolve.callAsync(resolveData, (err, result) => {
-					if (err) return callback(err);
-
-					// Ignored
-					if (result === false) return callback();
-
-					// direct module
-					if (result instanceof Module) return callback(null, result);
-
-					if (typeof result === "object")
-						throw new Error(
-							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
-								" Returning a Module object will result in this module used as result."
-						);
-
-					this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
-						if (err) return callback(err);
-
-						if (typeof result === "object")
-							throw new Error(
-								deprecationChangedHookMessage(
-									"afterResolve",
-									this.hooks.afterResolve
-								)
-							);
-
-						// Ignored
-						if (result === false) return callback();
-
-						const createData = resolveData.createData;
-
-						this.hooks.createModule.callAsync(
-							createData,
-							resolveData,
-							(err, createdModule) => {
-								if (!createdModule) {
-									if (!resolveData.request) {
-										return callback(new Error("Empty dependency (no request)"));
-									}
-
-									createdModule = new NormalModule(createData);
-								}
-
-								createdModule = this.hooks.module.call(
-									createdModule,
-									createData,
-									resolveData
-								);
-
-								return callback(null, createdModule);
-							}
-						);
-					});
-				});
-			}
-		);
-		this.hooks.resolve.tapAsync(
-			{
-				name: "NormalModuleFactory",
-				stage: 100
-			},
-			(data, callback) => {
-				const {
-					contextInfo,
-					context,
-					dependencies,
-					dependencyType,
-					request,
-					assertions,
-					resolveOptions,
-					fileDependencies,
-					missingDependencies,
-					contextDependencies
-				} = data;
-				const loaderResolver = this.getResolver("loader");
-
-				/** @type {ResourceData | undefined} */
-				let matchResourceData = undefined;
-				/** @type {string} */
-				let unresolvedResource;
-				/** @type {{loader: string, options: string|undefined}[]} */
-				let elements;
-				let noPreAutoLoaders = false;
-				let noAutoLoaders = false;
-				let noPrePostAutoLoaders = false;
-
-				const contextScheme = getScheme(context);
-				/** @type {string | undefined} */
-				let scheme = getScheme(request);
-
-				if (!scheme) {
-					/** @type {string} */
-					let requestWithoutMatchResource = request;
-					const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
-					if (matchResourceMatch) {
-						let matchResource = matchResourceMatch[1];
-						if (matchResource.charCodeAt(0) === 46) {
-							// 46 === ".", 47 === "/"
-							const secondChar = matchResource.charCodeAt(1);
-							if (
-								secondChar === 47 ||
-								(secondChar === 46 && matchResource.charCodeAt(2) === 47)
-							) {
-								// if matchResources startsWith ../ or ./
-								matchResource = join(this.fs, context, matchResource);
-							}
-						}
-						matchResourceData = {
-							resource: matchResource,
-							...cacheParseResource(matchResource)
-						};
-						requestWithoutMatchResource = request.substr(
-							matchResourceMatch[0].length
-						);
-					}
-
-					scheme = getScheme(requestWithoutMatchResource);
-
-					if (!scheme && !contextScheme) {
-						const firstChar = requestWithoutMatchResource.charCodeAt(0);
-						const secondChar = requestWithoutMatchResource.charCodeAt(1);
-						noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!"
-						noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!"
-						noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!";
-						const rawElements = requestWithoutMatchResource
-							.slice(
-								noPreAutoLoaders || noPrePostAutoLoaders
-									? 2
-									: noAutoLoaders
-									? 1
-									: 0
-							)
-							.split(/!+/);
-						unresolvedResource = rawElements.pop();
-						elements = rawElements.map(identToLoaderRequest);
-						scheme = getScheme(unresolvedResource);
-					} else {
-						unresolvedResource = requestWithoutMatchResource;
-						elements = EMPTY_ELEMENTS;
-					}
-				} else {
-					unresolvedResource = request;
-					elements = EMPTY_ELEMENTS;
-				}
-
-				const resolveContext = {
-					fileDependencies,
-					missingDependencies,
-					contextDependencies
-				};
-
-				/** @type {ResourceDataWithData} */
-				let resourceData;
-
-				let loaders;
-
-				const continueCallback = needCalls(2, err => {
-					if (err) return callback(err);
-
-					// translate option idents
-					try {
-						for (const item of loaders) {
-							if (typeof item.options === "string" && item.options[0] === "?") {
-								const ident = item.options.substr(1);
-								if (ident === "[[missing ident]]") {
-									throw new Error(
-										"No ident is provided by referenced loader. " +
-											"When using a function for Rule.use in config you need to " +
-											"provide an 'ident' property for referenced loader options."
-									);
-								}
-								item.options = this.ruleSet.references.get(ident);
-								if (item.options === undefined) {
-									throw new Error(
-										"Invalid ident is provided by referenced loader"
-									);
-								}
-								item.ident = ident;
-							}
-						}
-					} catch (e) {
-						return callback(e);
-					}
-
-					if (!resourceData) {
-						// ignored
-						return callback(null, dependencies[0].createIgnoredModule(context));
-					}
-
-					const userRequest =
-						(matchResourceData !== undefined
-							? `${matchResourceData.resource}!=!`
-							: "") +
-						stringifyLoadersAndResource(loaders, resourceData.resource);
-
-					const settings = {};
-					const useLoadersPost = [];
-					const useLoaders = [];
-					const useLoadersPre = [];
-
-					// handle .webpack[] suffix
-					let resource;
-					let match;
-					if (
-						matchResourceData &&
-						typeof (resource = matchResourceData.resource) === "string" &&
-						(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
-					) {
-						settings.type = match[1];
-						matchResourceData.resource = matchResourceData.resource.slice(
-							0,
-							-settings.type.length - 10
-						);
-					} else {
-						settings.type = "javascript/auto";
-						const resourceDataForRules = matchResourceData || resourceData;
-						const result = this.ruleSet.exec({
-							resource: resourceDataForRules.path,
-							realResource: resourceData.path,
-							resourceQuery: resourceDataForRules.query,
-							resourceFragment: resourceDataForRules.fragment,
-							scheme,
-							assertions,
-							mimetype: matchResourceData
-								? ""
-								: resourceData.data.mimetype || "",
-							dependency: dependencyType,
-							descriptionData: matchResourceData
-								? undefined
-								: resourceData.data.descriptionFileData,
-							issuer: contextInfo.issuer,
-							compiler: contextInfo.compiler,
-							issuerLayer: contextInfo.issuerLayer || ""
-						});
-						for (const r of result) {
-							if (r.type === "use") {
-								if (!noAutoLoaders && !noPrePostAutoLoaders) {
-									useLoaders.push(r.value);
-								}
-							} else if (r.type === "use-post") {
-								if (!noPrePostAutoLoaders) {
-									useLoadersPost.push(r.value);
-								}
-							} else if (r.type === "use-pre") {
-								if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
-									useLoadersPre.push(r.value);
-								}
-							} else if (
-								typeof r.value === "object" &&
-								r.value !== null &&
-								typeof settings[r.type] === "object" &&
-								settings[r.type] !== null
-							) {
-								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
-							} else {
-								settings[r.type] = r.value;
-							}
-						}
-					}
-
-					let postLoaders, normalLoaders, preLoaders;
-
-					const continueCallback = needCalls(3, err => {
-						if (err) {
-							return callback(err);
-						}
-						const allLoaders = postLoaders;
-						if (matchResourceData === undefined) {
-							for (const loader of loaders) allLoaders.push(loader);
-							for (const loader of normalLoaders) allLoaders.push(loader);
-						} else {
-							for (const loader of normalLoaders) allLoaders.push(loader);
-							for (const loader of loaders) allLoaders.push(loader);
-						}
-						for (const loader of preLoaders) allLoaders.push(loader);
-						let type = settings.type;
-						const resolveOptions = settings.resolve;
-						const layer = settings.layer;
-						if (layer !== undefined && !layers) {
-							return callback(
-								new Error(
-									"'Rule.layer' is only allowed when 'experiments.layers' is enabled"
-								)
-							);
-						}
-						try {
-							Object.assign(data.createData, {
-								layer:
-									layer === undefined ? contextInfo.issuerLayer || null : layer,
-								request: stringifyLoadersAndResource(
-									allLoaders,
-									resourceData.resource
-								),
-								userRequest,
-								rawRequest: request,
-								loaders: allLoaders,
-								resource: resourceData.resource,
-								context:
-									resourceData.context || getContext(resourceData.resource),
-								matchResource: matchResourceData
-									? matchResourceData.resource
-									: undefined,
-								resourceResolveData: resourceData.data,
-								settings,
-								type,
-								parser: this.getParser(type, settings.parser),
-								parserOptions: settings.parser,
-								generator: this.getGenerator(type, settings.generator),
-								generatorOptions: settings.generator,
-								resolveOptions
-							});
-						} catch (e) {
-							return callback(e);
-						}
-						callback();
-					});
-					this.resolveRequestArray(
-						contextInfo,
-						this.context,
-						useLoadersPost,
-						loaderResolver,
-						resolveContext,
-						(err, result) => {
-							postLoaders = result;
-							continueCallback(err);
-						}
-					);
-					this.resolveRequestArray(
-						contextInfo,
-						this.context,
-						useLoaders,
-						loaderResolver,
-						resolveContext,
-						(err, result) => {
-							normalLoaders = result;
-							continueCallback(err);
-						}
-					);
-					this.resolveRequestArray(
-						contextInfo,
-						this.context,
-						useLoadersPre,
-						loaderResolver,
-						resolveContext,
-						(err, result) => {
-							preLoaders = result;
-							continueCallback(err);
-						}
-					);
-				});
-
-				this.resolveRequestArray(
-					contextInfo,
-					contextScheme ? this.context : context,
-					elements,
-					loaderResolver,
-					resolveContext,
-					(err, result) => {
-						if (err) return continueCallback(err);
-						loaders = result;
-						continueCallback();
-					}
-				);
-
-				const defaultResolve = context => {
-					if (/^($|\?)/.test(unresolvedResource)) {
-						resourceData = {
-							resource: unresolvedResource,
-							data: {},
-							...cacheParseResource(unresolvedResource)
-						};
-						continueCallback();
-					}
-
-					// resource without scheme and with path
-					else {
-						const normalResolver = this.getResolver(
-							"normal",
-							dependencyType
-								? cachedSetProperty(
-										resolveOptions || EMPTY_RESOLVE_OPTIONS,
-										"dependencyType",
-										dependencyType
-								  )
-								: resolveOptions
-						);
-						this.resolveResource(
-							contextInfo,
-							context,
-							unresolvedResource,
-							normalResolver,
-							resolveContext,
-							(err, resolvedResource, resolvedResourceResolveData) => {
-								if (err) return continueCallback(err);
-								if (resolvedResource !== false) {
-									resourceData = {
-										resource: resolvedResource,
-										data: resolvedResourceResolveData,
-										...cacheParseResource(resolvedResource)
-									};
-								}
-								continueCallback();
-							}
-						);
-					}
-				};
-
-				// resource with scheme
-				if (scheme) {
-					resourceData = {
-						resource: unresolvedResource,
-						data: {},
-						path: undefined,
-						query: undefined,
-						fragment: undefined,
-						context: undefined
-					};
-					this.hooks.resolveForScheme
-						.for(scheme)
-						.callAsync(resourceData, data, err => {
-							if (err) return continueCallback(err);
-							continueCallback();
-						});
-				}
-
-				// resource within scheme
-				else if (contextScheme) {
-					resourceData = {
-						resource: unresolvedResource,
-						data: {},
-						path: undefined,
-						query: undefined,
-						fragment: undefined,
-						context: undefined
-					};
-					this.hooks.resolveInScheme
-						.for(contextScheme)
-						.callAsync(resourceData, data, (err, handled) => {
-							if (err) return continueCallback(err);
-							if (!handled) return defaultResolve(this.context);
-							continueCallback();
-						});
-				}
-
-				// resource without scheme and without path
-				else defaultResolve(context);
-			}
-		);
-	}
-
-	cleanupForCache() {
-		for (const module of this._restoredUnsafeCacheEntries) {
-			ChunkGraph.clearChunkGraphForModule(module);
-			ModuleGraph.clearModuleGraphForModule(module);
-			module.cleanupForCache();
-		}
+	_createBuildDependenciesResolvers() {
+		const resolveContext = createResolver({
+			resolveToContext: true,
+			exportsFields: [],
+			fileSystem: this.fs
+		});
+		const resolveCjs = createResolver({
+			extensions: [".js", ".json", ".node"],
+			conditionNames: ["require", "node"],
+			exportsFields: ["exports"],
+			fileSystem: this.fs
+		});
+		const resolveCjsAsChild = createResolver({
+			extensions: [".js", ".json", ".node"],
+			conditionNames: ["require", "node"],
+			exportsFields: [],
+			fileSystem: this.fs
+		});
+		const resolveEsm = createResolver({
+			extensions: [".js", ".json", ".node"],
+			fullySpecified: true,
+			conditionNames: ["import", "node"],
+			exportsFields: ["exports"],
+			fileSystem: this.fs
+		});
+		return { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild };
 	}
 
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {string} context context directory
+	 * @param {Iterable<string>} deps dependencies
+	 * @param {function((Error | null)=, ResolveBuildDependenciesResult=): void} callback callback function
 	 * @returns {void}
 	 */
-	create(data, callback) {
-		const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies);
-		const context = data.context || this.context;
-		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
-		const dependency = dependencies[0];
-		const request = dependency.request;
-		const assertions = dependency.assertions;
-		const contextInfo = data.contextInfo;
-		const fileDependencies = new LazySet();
-		const missingDependencies = new LazySet();
-		const contextDependencies = new LazySet();
-		const dependencyType =
-			(dependencies.length > 0 && dependencies[0].category) || "";
-		/** @type {ResolveData} */
-		const resolveData = {
-			contextInfo,
-			resolveOptions,
-			context,
-			request,
-			assertions,
-			dependencies,
-			dependencyType,
-			fileDependencies,
-			missingDependencies,
-			contextDependencies,
-			createData: {},
-			cacheable: true
+	resolveBuildDependencies(context, deps, callback) {
+		const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } =
+			this._createBuildDependenciesResolvers();
+
+		/** @type {Set<string>} */
+		const files = new Set();
+		/** @type {Set<string>} */
+		const fileSymlinks = new Set();
+		/** @type {Set<string>} */
+		const directories = new Set();
+		/** @type {Set<string>} */
+		const directorySymlinks = new Set();
+		/** @type {Set<string>} */
+		const missing = new Set();
+		/** @type {Set<string>} */
+		const resolveFiles = new Set();
+		/** @type {Set<string>} */
+		const resolveDirectories = new Set();
+		/** @type {Set<string>} */
+		const resolveMissing = new Set();
+		/** @type {Map<string, string | false>} */
+		const resolveResults = new Map();
+		const invalidResolveResults = new Set();
+		const resolverContext = {
+			fileDependencies: resolveFiles,
+			contextDependencies: resolveDirectories,
+			missingDependencies: resolveMissing
 		};
-		this.hooks.beforeResolve.callAsync(resolveData, (err, result) => {
-			if (err) {
-				return callback(err, {
-					fileDependencies,
-					missingDependencies,
-					contextDependencies,
-					cacheable: false
-				});
+		const expectedToString = expected => {
+			return expected ? ` (expected ${expected})` : "";
+		};
+		const jobToString = job => {
+			switch (job.type) {
+				case RBDT_RESOLVE_CJS:
+					return `resolve commonjs ${job.path}${expectedToString(
+						job.expected
+					)}`;
+				case RBDT_RESOLVE_ESM:
+					return `resolve esm ${job.path}${expectedToString(job.expected)}`;
+				case RBDT_RESOLVE_DIRECTORY:
+					return `resolve directory ${job.path}`;
+				case RBDT_RESOLVE_CJS_FILE:
+					return `resolve commonjs file ${job.path}${expectedToString(
+						job.expected
+					)}`;
+				case RBDT_RESOLVE_ESM_FILE:
+					return `resolve esm file ${job.path}${expectedToString(
+						job.expected
+					)}`;
+				case RBDT_DIRECTORY:
+					return `directory ${job.path}`;
+				case RBDT_FILE:
+					return `file ${job.path}`;
+				case RBDT_DIRECTORY_DEPENDENCIES:
+					return `directory dependencies ${job.path}`;
+				case RBDT_FILE_DEPENDENCIES:
+					return `file dependencies ${job.path}`;
 			}
-
-			// Ignored
-			if (result === false) {
-				return callback(null, {
-					fileDependencies,
-					missingDependencies,
-					contextDependencies,
-					cacheable: resolveData.cacheable
-				});
+			return `unknown ${job.type} ${job.path}`;
+		};
+		const pathToString = job => {
+			let result = ` at ${jobToString(job)}`;
+			job = job.issuer;
+			while (job !== undefined) {
+				result += `\n at ${jobToString(job)}`;
+				job = job.issuer;
 			}
-
-			if (typeof result === "object")
-				throw new Error(
-					deprecationChangedHookMessage(
-						"beforeResolve",
-						this.hooks.beforeResolve
-					)
-				);
-
-			this.hooks.factorize.callAsync(resolveData, (err, module) => {
-				if (err) {
-					return callback(err, {
-						fileDependencies,
-						missingDependencies,
-						contextDependencies,
-						cacheable: false
+			return result;
+		};
+		processAsyncTree(
+			Array.from(deps, dep => ({
+				type: RBDT_RESOLVE_CJS,
+				context,
+				path: dep,
+				expected: undefined,
+				issuer: undefined
+			})),
+			20,
+			(job, push, callback) => {
+				const { type, context, path, expected } = job;
+				const resolveDirectory = path => {
+					const key = `d\n${context}\n${path}`;
+					if (resolveResults.has(key)) {
+						return callback();
+					}
+					resolveResults.set(key, undefined);
+					resolveContext(context, path, resolverContext, (err, _, result) => {
+						if (err) {
+							if (expected === false) {
+								resolveResults.set(key, false);
+								return callback();
+							}
+							invalidResolveResults.add(key);
+							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
+							return callback(err);
+						}
+						const resultPath = result.path;
+						resolveResults.set(key, resultPath);
+						push({
+							type: RBDT_DIRECTORY,
+							context: undefined,
+							path: resultPath,
+							expected: undefined,
+							issuer: job
+						});
+						callback();
 					});
-				}
-
-				const factoryResult = {
-					module,
-					fileDependencies,
-					missingDependencies,
-					contextDependencies,
-					cacheable: resolveData.cacheable
 				};
-
-				callback(null, factoryResult);
-			});
-		});
-	}
-
-	resolveResource(
-		contextInfo,
-		context,
-		unresolvedResource,
-		resolver,
-		resolveContext,
-		callback
-	) {
-		resolver.resolve(
-			contextInfo,
-			context,
-			unresolvedResource,
-			resolveContext,
-			(err, resolvedResource, resolvedResourceResolveData) => {
-				if (err) {
-					return this._resolveResourceErrorHints(
-						err,
-						contextInfo,
-						context,
-						unresolvedResource,
-						resolver,
-						resolveContext,
-						(err2, hints) => {
-							if (err2) {
-								err.message += `
-An fatal error happened during resolving additional hints for this error: ${err2.message}`;
-								err.stack += `
-
-An fatal error happened during resolving additional hints for this error:
-${err2.stack}`;
+				const resolveFile = (path, symbol, resolve) => {
+					const key = `${symbol}\n${context}\n${path}`;
+					if (resolveResults.has(key)) {
+						return callback();
+					}
+					resolveResults.set(key, undefined);
+					resolve(context, path, resolverContext, (err, _, result) => {
+						if (typeof expected === "string") {
+							if (!err && result && result.path === expected) {
+								resolveResults.set(key, result.path);
+							} else {
+								invalidResolveResults.add(key);
+								this.logger.warn(
+									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
+										err || (result && result.path)
+									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
+										job
+									)}`
+								);
+							}
+						} else {
+							if (err) {
+								if (expected === false) {
+									resolveResults.set(key, false);
+									return callback();
+								}
+								invalidResolveResults.add(key);
+								err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString(
+									job
+								)}`;
 								return callback(err);
 							}
-							if (hints && hints.length > 0) {
-								err.message += `
-${hints.join("\n\n")}`;
+							const resultPath = result.path;
+							resolveResults.set(key, resultPath);
+							push({
+								type: RBDT_FILE,
+								context: undefined,
+								path: resultPath,
+								expected: undefined,
+								issuer: job
+							});
+						}
+						callback();
+					});
+				};
+				switch (type) {
+					case RBDT_RESOLVE_CJS: {
+						const isDirectory = /[\\/]$/.test(path);
+						if (isDirectory) {
+							resolveDirectory(path.slice(0, path.length - 1));
+						} else {
+							resolveFile(path, "f", resolveCjs);
+						}
+						break;
+					}
+					case RBDT_RESOLVE_ESM: {
+						const isDirectory = /[\\/]$/.test(path);
+						if (isDirectory) {
+							resolveDirectory(path.slice(0, path.length - 1));
+						} else {
+							resolveFile(path);
+						}
+						break;
+					}
+					case RBDT_RESOLVE_DIRECTORY: {
+						resolveDirectory(path);
+						break;
+					}
+					case RBDT_RESOLVE_CJS_FILE: {
+						resolveFile(path, "f", resolveCjs);
+						break;
+					}
+					case RBDT_RESOLVE_CJS_FILE_AS_CHILD: {
+						resolveFile(path, "c", resolveCjsAsChild);
+						break;
+					}
+					case RBDT_RESOLVE_ESM_FILE: {
+						resolveFile(path, "e", resolveEsm);
+						break;
+					}
+					case RBDT_FILE: {
+						if (files.has(path)) {
+							callback();
+							break;
+						}
+						files.add(path);
+						this.fs.realpath(path, (err, _realPath) => {
+							if (err) return callback(err);
+							const realPath = /** @type {string} */ (_realPath);
+							if (realPath !== path) {
+								fileSymlinks.add(path);
+								resolveFiles.add(path);
+								if (files.has(realPath)) return callback();
+								files.add(realPath);
 							}
-							callback(err);
+							push({
+								type: RBDT_FILE_DEPENDENCIES,
+								context: undefined,
+								path: realPath,
+								expected: undefined,
+								issuer: job
+							});
+							callback();
+						});
+						break;
+					}
+					case RBDT_DIRECTORY: {
+						if (directories.has(path)) {
+							callback();
+							break;
 						}
-					);
-				}
-				callback(err, resolvedResource, resolvedResourceResolveData);
-			}
-		);
-	}
-
-	_resolveResourceErrorHints(
-		error,
-		contextInfo,
-		context,
-		unresolvedResource,
-		resolver,
-		resolveContext,
-		callback
-	) {
-		asyncLib.parallel(
-			[
-				callback => {
-					if (!resolver.options.fullySpecified) return callback();
-					resolver
-						.withOptions({
-							fullySpecified: false
-						})
-						.resolve(
-							contextInfo,
-							context,
-							unresolvedResource,
-							resolveContext,
-							(err, resolvedResource) => {
-								if (!err && resolvedResource) {
-									const resource = parseResource(resolvedResource).path.replace(
-										/^.*[\\/]/,
-										""
-									);
-									return callback(
-										null,
-										`Did you mean '${resource}'?
-BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified
-(probably because the origin is strict EcmaScript Module, e. g. a module with javascript mimetype, a '*.mjs' file, or a '*.js' file where the package.json contains '"type": "module"').
-The extension in the request is mandatory for it to be fully specified.
-Add the extension to the request.`
-									);
-								}
-								callback();
+						directories.add(path);
+						this.fs.realpath(path, (err, _realPath) => {
+							if (err) return callback(err);
+							const realPath = /** @type {string} */ (_realPath);
+							if (realPath !== path) {
+								directorySymlinks.add(path);
+								resolveFiles.add(path);
+								if (directories.has(realPath)) return callback();
+								directories.add(realPath);
 							}
-						);
-				},
-				callback => {
-					if (!resolver.options.enforceExtension) return callback();
-					resolver
-						.withOptions({
-							enforceExtension: false,
-							extensions: []
-						})
-						.resolve(
-							contextInfo,
-							context,
-							unresolvedResource,
-							resolveContext,
-							(err, resolvedResource) => {
-								if (!err && resolvedResource) {
-									let hint = "";
-									const match = /(\.[^.]+)(\?|$)/.exec(unresolvedResource);
-									if (match) {
-										const fixedRequest = unresolvedResource.replace(
-											/(\.[^.]+)(\?|$)/,
-											"$2"
-										);
-										if (resolver.options.extensions.has(match[1])) {
-											hint = `Did you mean '${fixedRequest}'?`;
-										} else {
-											hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
+							push({
+								type: RBDT_DIRECTORY_DEPENDENCIES,
+								context: undefined,
+								path: realPath,
+								expected: undefined,
+								issuer: job
+							});
+							callback();
+						});
+						break;
+					}
+					case RBDT_FILE_DEPENDENCIES: {
+						// Check for known files without dependencies
+						if (/\.json5?$|\.yarn-integrity$|yarn\.lock$|\.ya?ml/.test(path)) {
+							process.nextTick(callback);
+							break;
+						}
+						// Check commonjs cache for the module
+						/** @type {NodeModule} */
+						const module = require.cache[path];
+						if (module && Array.isArray(module.children)) {
+							children: for (const child of module.children) {
+								let childPath = child.filename;
+								if (childPath) {
+									push({
+										type: RBDT_FILE,
+										context: undefined,
+										path: childPath,
+										expected: undefined,
+										issuer: job
+									});
+									const context = dirname(this.fs, path);
+									for (const modulePath of module.paths) {
+										if (childPath.startsWith(modulePath)) {
+											let subPath = childPath.slice(modulePath.length + 1);
+											const packageMatch = /^(@[^\\/]+[\\/])[^\\/]+/.exec(
+												subPath
+											);
+											if (packageMatch) {
+												push({
+													type: RBDT_FILE,
+													context: undefined,
+													path:
+														modulePath +
+														childPath[modulePath.length] +
+														packageMatch[0] +
+														childPath[modulePath.length] +
+														"package.json",
+													expected: false,
+													issuer: job
+												});
+											}
+											let request = subPath.replace(/\\/g, "/");
+											if (request.endsWith(".js"))
+												request = request.slice(0, -3);
+											push({
+												type: RBDT_RESOLVE_CJS_FILE_AS_CHILD,
+												context,
+												path: request,
+												expected: child.filename,
+												issuer: job
+											});
+											continue children;
 										}
-									} else {
-										hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
 									}
-									return callback(
-										null,
-										`The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified.
-${hint}
-Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?`
-									);
+									let request = relative(this.fs, context, childPath);
+									if (request.endsWith(".js")) request = request.slice(0, -3);
+									request = request.replace(/\\/g, "/");
+									if (!request.startsWith("../")) request = `./${request}`;
+									push({
+										type: RBDT_RESOLVE_CJS_FILE,
+										context,
+										path: request,
+										expected: child.filename,
+										issuer: job
+									});
 								}
-								callback();
 							}
-						);
-				},
-				callback => {
-					if (
-						/^\.\.?\//.test(unresolvedResource) ||
-						resolver.options.preferRelative
-					) {
-						return callback();
-					}
-					resolver.resolve(
-						contextInfo,
-						context,
-						`./${unresolvedResource}`,
-						resolveContext,
-						(err, resolvedResource) => {
-							if (err || !resolvedResource) return callback();
-							const moduleDirectories = resolver.options.modules
-								.map(m => (Array.isArray(m) ? m.join(", ") : m))
-								.join(", ");
-							callback(
-								null,
-								`Did you mean './${unresolvedResource}'?
-Requests that should resolve in the current directory need to start with './'.
-Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}).
-If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.`
-							);
-						}
-					);
-				}
-			],
-			(err, hints) => {
-				if (err) return callback(err);
-				callback(null, hints.filter(Boolean));
-			}
-		);
-	}
-
-	resolveRequestArray(
-		contextInfo,
-		context,
-		array,
-		resolver,
-		resolveContext,
-		callback
-	) {
-		if (array.length === 0) return callback(null, array);
-		asyncLib.map(
-			array,
-			(item, callback) => {
-				resolver.resolve(
-					contextInfo,
-					context,
-					item.loader,
-					resolveContext,
-					(err, result) => {
-						if (
-							err &&
-							/^[^/]*$/.test(item.loader) &&
-							!/-loader$/.test(item.loader)
-						) {
-							return resolver.resolve(
-								contextInfo,
-								context,
-								item.loader + "-loader",
-								resolveContext,
-								err2 => {
-									if (!err2) {
-										err.message =
-											err.message +
-											"\n" +
-											"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
-											`                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
-											"                 see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed";
+						} else if (supportsEsm && /\.m?js$/.test(path)) {
+							if (!this._warnAboutExperimentalEsmTracking) {
+								this.logger.log(
+									"Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" +
+										"Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" +
+										"As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking."
+								);
+								this._warnAboutExperimentalEsmTracking = true;
+							}
+							const lexer = __webpack_require__(54392);
+							lexer.init.then(() => {
+								this.fs.readFile(path, (err, content) => {
+									if (err) return callback(err);
+									try {
+										const context = dirname(this.fs, path);
+										const source = content.toString();
+										const [imports] = lexer.parse(source);
+										for (const imp of imports) {
+											try {
+												let dependency;
+												if (imp.d === -1) {
+													// import ... from "..."
+													dependency = parseString(
+														source.substring(imp.s - 1, imp.e + 1)
+													);
+												} else if (imp.d > -1) {
+													// import()
+													let expr = source.substring(imp.s, imp.e).trim();
+													dependency = parseString(expr);
+												} else {
+													// e.g. import.meta
+													continue;
+												}
+												push({
+													type: RBDT_RESOLVE_ESM_FILE,
+													context,
+													path: dependency,
+													expected: undefined,
+													issuer: job
+												});
+											} catch (e) {
+												this.logger.warn(
+													`Parsing of ${path} for build dependencies failed at 'import(${source.substring(
+														imp.s,
+														imp.e
+													)})'.\n` +
+														"Build dependencies behind this expression are ignored and might cause incorrect cache invalidation."
+												);
+												this.logger.debug(pathToString(job));
+												this.logger.debug(e.stack);
+											}
+										}
+									} catch (e) {
+										this.logger.warn(
+											`Parsing of ${path} for build dependencies failed and all dependencies of this file are ignored, which might cause incorrect cache invalidation..`
+										);
+										this.logger.debug(pathToString(job));
+										this.logger.debug(e.stack);
 									}
-									callback(err);
-								}
-							);
-						}
-						if (err) return callback(err);
-
-						const parsedResult = identToLoaderRequest(result);
-						const resolved = {
-							loader: parsedResult.loader,
-							options:
-								item.options === undefined
-									? parsedResult.options
-									: item.options,
-							ident: item.options === undefined ? undefined : item.ident
-						};
-						return callback(null, resolved);
-					}
-				);
-			},
-			callback
-		);
-	}
-
-	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
-		let cache = this.parserCache.get(type);
-
-		if (cache === undefined) {
-			cache = new WeakMap();
-			this.parserCache.set(type, cache);
-		}
-
-		let parser = cache.get(parserOptions);
-
-		if (parser === undefined) {
-			parser = this.createParser(type, parserOptions);
-			cache.set(parserOptions, parser);
-		}
-
-		return parser;
-	}
-
-	/**
-	 * @param {string} type type
-	 * @param {{[k: string]: any}} parserOptions parser options
-	 * @returns {Parser} parser
-	 */
-	createParser(type, parserOptions = {}) {
-		parserOptions = mergeGlobalOptions(
-			this._globalParserOptions,
-			type,
-			parserOptions
-		);
-		const parser = this.hooks.createParser.for(type).call(parserOptions);
-		if (!parser) {
-			throw new Error(`No parser registered for ${type}`);
-		}
-		this.hooks.parser.for(type).call(parser, parserOptions);
-		return parser;
-	}
-
-	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
-		let cache = this.generatorCache.get(type);
-
-		if (cache === undefined) {
-			cache = new WeakMap();
-			this.generatorCache.set(type, cache);
-		}
-
-		let generator = cache.get(generatorOptions);
-
-		if (generator === undefined) {
-			generator = this.createGenerator(type, generatorOptions);
-			cache.set(generatorOptions, generator);
-		}
-
-		return generator;
-	}
-
-	createGenerator(type, generatorOptions = {}) {
-		generatorOptions = mergeGlobalOptions(
-			this._globalGeneratorOptions,
-			type,
-			generatorOptions
-		);
-		const generator = this.hooks.createGenerator
-			.for(type)
-			.call(generatorOptions);
-		if (!generator) {
-			throw new Error(`No generator registered for ${type}`);
-		}
-		this.hooks.generator.for(type).call(generator, generatorOptions);
-		return generator;
-	}
-
-	getResolver(type, resolveOptions) {
-		return this.resolverFactory.get(type, resolveOptions);
-	}
-}
-
-module.exports = NormalModuleFactory;
-
-
-/***/ }),
-
-/***/ 30633:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { join, dirname } = __webpack_require__(17139);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {function(TODO): void} ModuleReplacer */
-
-class NormalModuleReplacementPlugin {
-	/**
-	 * Create an instance of the plugin
-	 * @param {RegExp} resourceRegExp the resource matcher
-	 * @param {string|ModuleReplacer} newResource the resource replacement
-	 */
-	constructor(resourceRegExp, newResource) {
-		this.resourceRegExp = resourceRegExp;
-		this.newResource = newResource;
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const resourceRegExp = this.resourceRegExp;
-		const newResource = this.newResource;
-		compiler.hooks.normalModuleFactory.tap(
-			"NormalModuleReplacementPlugin",
-			nmf => {
-				nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", result => {
-					if (resourceRegExp.test(result.request)) {
-						if (typeof newResource === "function") {
-							newResource(result);
+									process.nextTick(callback);
+								});
+							}, callback);
+							break;
 						} else {
-							result.request = newResource;
+							this.logger.log(
+								`Assuming ${path} has no dependencies as we were unable to assign it to any module system.`
+							);
+							this.logger.debug(pathToString(job));
 						}
+						process.nextTick(callback);
+						break;
 					}
-				});
-				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
-					const createData = result.createData;
-					if (resourceRegExp.test(createData.resource)) {
-						if (typeof newResource === "function") {
-							newResource(result);
-						} else {
-							const fs = compiler.inputFileSystem;
+					case RBDT_DIRECTORY_DEPENDENCIES: {
+						const match =
+							/(^.+[\\/]node_modules[\\/](?:@[^\\/]+[\\/])?[^\\/]+)/.exec(path);
+						const packagePath = match ? match[1] : path;
+						const packageJson = join(this.fs, packagePath, "package.json");
+						this.fs.readFile(packageJson, (err, content) => {
+							if (err) {
+								if (err.code === "ENOENT") {
+									resolveMissing.add(packageJson);
+									const parent = dirname(this.fs, packagePath);
+									if (parent !== packagePath) {
+										push({
+											type: RBDT_DIRECTORY_DEPENDENCIES,
+											context: undefined,
+											path: parent,
+											expected: undefined,
+											issuer: job
+										});
+									}
+									callback();
+									return;
+								}
+								return callback(err);
+							}
+							resolveFiles.add(packageJson);
+							let packageData;
+							try {
+								packageData = JSON.parse(content.toString("utf-8"));
+							} catch (e) {
+								return callback(e);
+							}
+							const depsObject = packageData.dependencies;
+							const optionalDepsObject = packageData.optionalDependencies;
+							const allDeps = new Set();
+							const optionalDeps = new Set();
+							if (typeof depsObject === "object" && depsObject) {
+								for (const dep of Object.keys(depsObject)) {
+									allDeps.add(dep);
+								}
+							}
 							if (
-								newResource.startsWith("/") ||
-								(newResource.length > 1 && newResource[1] === ":")
+								typeof optionalDepsObject === "object" &&
+								optionalDepsObject
 							) {
-								createData.resource = newResource;
-							} else {
-								createData.resource = join(
-									fs,
-									dirname(fs, createData.resource),
-									newResource
-								);
+								for (const dep of Object.keys(optionalDepsObject)) {
+									allDeps.add(dep);
+									optionalDeps.add(dep);
+								}
 							}
-						}
+							for (const dep of allDeps) {
+								push({
+									type: RBDT_RESOLVE_DIRECTORY,
+									context: packagePath,
+									path: dep,
+									expected: !optionalDeps.has(dep),
+									issuer: job
+								});
+							}
+							callback();
+						});
+						break;
+					}
+				}
+			},
+			err => {
+				if (err) return callback(err);
+				for (const l of fileSymlinks) files.delete(l);
+				for (const l of directorySymlinks) directories.delete(l);
+				for (const k of invalidResolveResults) resolveResults.delete(k);
+				callback(null, {
+					files,
+					directories,
+					missing,
+					resolveResults,
+					resolveDependencies: {
+						files: resolveFiles,
+						directories: resolveDirectories,
+						missing: resolveMissing
 					}
 				});
 			}
 		);
 	}
-}
-
-module.exports = NormalModuleReplacementPlugin;
-
-
-/***/ }),
-
-/***/ 80057:
-/***/ (function(__unused_webpack_module, exports) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
-
-
-
-exports.STAGE_BASIC = -10;
-exports.STAGE_DEFAULT = 0;
-exports.STAGE_ADVANCED = 10;
-
-
-/***/ }),
-
-/***/ 81426:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-class OptionsApply {
-	process(options, compiler) {}
-}
-module.exports = OptionsApply;
-
-
-/***/ }),
-
-/***/ 11715:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./NormalModule")} NormalModule */
-
-/** @typedef {Record<string, any>} PreparsedAst */
-
-/**
- * @typedef {Object} ParserStateBase
- * @property {string | Buffer} source
- * @property {NormalModule} current
- * @property {NormalModule} module
- * @property {Compilation} compilation
- * @property {{[k: string]: any}} options
- */
-
-/** @typedef {Record<string, any> & ParserStateBase} ParserState */
-
-class Parser {
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
-}
-
-module.exports = Parser;
-
-
-/***/ }),
-
-/***/ 73850:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const PrefetchDependency = __webpack_require__(31618);
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class PrefetchPlugin {
-	constructor(context, request) {
-		if (request) {
-			this.context = context;
-			this.request = request;
-		} else {
-			this.context = null;
-			this.request = context;
-		}
-	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Map<string, string | false>} resolveResults results from resolving
+	 * @param {function((Error | null)=, boolean=): void} callback callback with true when resolveResults resolve the same way
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"PrefetchPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					PrefetchDependency,
-					normalModuleFactory
-				);
-			}
-		);
-		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
-			compilation.addModuleChain(
-				this.context || compiler.context,
-				new PrefetchDependency(this.request),
-				err => {
-					callback(err);
+	checkResolveResultsValid(resolveResults, callback) {
+		const { resolveCjs, resolveCjsAsChild, resolveEsm, resolveContext } =
+			this._createBuildDependenciesResolvers();
+		asyncLib.eachLimit(
+			resolveResults,
+			20,
+			([key, expectedResult], callback) => {
+				const [type, context, path] = key.split("\n");
+				switch (type) {
+					case "d":
+						resolveContext(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "f":
+						resolveCjs(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "c":
+						resolveCjsAsChild(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "e":
+						resolveEsm(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					default:
+						callback(new Error("Unexpected type in resolve result key"));
+						break;
 				}
-			);
-		});
-	}
-}
-
-module.exports = PrefetchPlugin;
-
-
-/***/ }),
-
-/***/ 13216:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Compiler = __webpack_require__(70845);
-const MultiCompiler = __webpack_require__(33370);
-const NormalModule = __webpack_require__(39);
-const createSchemaValidation = __webpack_require__(32540);
-const { contextify } = __webpack_require__(82186);
-
-/** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
-/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
-/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
-
-const validate = createSchemaValidation(
-	__webpack_require__(57647),
-	() => __webpack_require__(75202),
-	{
-		name: "Progress Plugin",
-		baseDataPath: "options"
-	}
-);
-const median3 = (a, b, c) => {
-	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
-};
-
-const createDefaultHandler = (profile, logger) => {
-	/** @type {{ value: string, time: number }[]} */
-	const lastStateInfo = [];
-
-	const defaultHandler = (percentage, msg, ...args) => {
-		if (profile) {
-			if (percentage === 0) {
-				lastStateInfo.length = 0;
-			}
-			const fullState = [msg, ...args];
-			const state = fullState.map(s => s.replace(/\d+\/\d+ /g, ""));
-			const now = Date.now();
-			const len = Math.max(state.length, lastStateInfo.length);
-			for (let i = len; i >= 0; i--) {
-				const stateItem = i < state.length ? state[i] : undefined;
-				const lastStateItem =
-					i < lastStateInfo.length ? lastStateInfo[i] : undefined;
-				if (lastStateItem) {
-					if (stateItem !== lastStateItem.value) {
-						const diff = now - lastStateItem.time;
-						if (lastStateItem.value) {
-							let reportState = lastStateItem.value;
-							if (i > 0) {
-								reportState = lastStateInfo[i - 1].value + " > " + reportState;
-							}
-							const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
-							const d = diff;
-							// This depends on timing so we ignore it for coverage
-							/* istanbul ignore next */
-							{
-								if (d > 10000) {
-									logger.error(stateMsg);
-								} else if (d > 1000) {
-									logger.warn(stateMsg);
-								} else if (d > 10) {
-									logger.info(stateMsg);
-								} else if (d > 5) {
-									logger.log(stateMsg);
-								} else {
-									logger.debug(stateMsg);
-								}
-							}
-						}
-						if (stateItem === undefined) {
-							lastStateInfo.length = i;
-						} else {
-							lastStateItem.value = stateItem;
-							lastStateItem.time = now;
-							lastStateInfo.length = i + 1;
-						}
-					}
-				} else {
-					lastStateInfo[i] = {
-						value: stateItem,
-						time: now
-					};
+			},
+			/**
+			 * @param {Error | typeof INVALID=} err error or invalid flag
+			 * @returns {void}
+			 */
+			err => {
+				if (err === INVALID) {
+					return callback(null, false);
+				}
+				if (err) {
+					return callback(err);
 				}
+				return callback(null, true);
 			}
-		}
-		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
-		if (percentage === 1 || (!msg && args.length === 0)) logger.status();
-	};
-
-	return defaultHandler;
-};
-
-/**
- * @callback ReportProgress
- * @param {number} p
- * @param {...string[]} [args]
- * @returns {void}
- */
-
-/** @type {WeakMap<Compiler,ReportProgress>} */
-const progressReporters = new WeakMap();
-
-class ProgressPlugin {
-	/**
-	 * @param {Compiler} compiler the current compiler
-	 * @returns {ReportProgress} a progress reporter, if any
-	 */
-	static getReporter(compiler) {
-		return progressReporters.get(compiler);
-	}
-
-	/**
-	 * @param {ProgressPluginArgument} options options
-	 */
-	constructor(options = {}) {
-		if (typeof options === "function") {
-			options = {
-				handler: options
-			};
-		}
-
-		validate(options);
-		options = { ...ProgressPlugin.defaultOptions, ...options };
-
-		this.profile = options.profile;
-		this.handler = options.handler;
-		this.modulesCount = options.modulesCount;
-		this.dependenciesCount = options.dependenciesCount;
-		this.showEntries = options.entries;
-		this.showModules = options.modules;
-		this.showDependencies = options.dependencies;
-		this.showActiveModules = options.activeModules;
-		this.percentBy = options.percentBy;
-	}
-
-	/**
-	 * @param {Compiler | MultiCompiler} compiler webpack compiler
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const handler =
-			this.handler ||
-			createDefaultHandler(
-				this.profile,
-				compiler.getInfrastructureLogger("webpack.Progress")
-			);
-		if (compiler instanceof MultiCompiler) {
-			this._applyOnMultiCompiler(compiler, handler);
-		} else if (compiler instanceof Compiler) {
-			this._applyOnCompiler(compiler, handler);
-		}
-	}
-
-	/**
-	 * @param {MultiCompiler} compiler webpack multi-compiler
-	 * @param {HandlerFunction} handler function that executes for every progress step
-	 * @returns {void}
-	 */
-	_applyOnMultiCompiler(compiler, handler) {
-		const states = compiler.compilers.map(
-			() => /** @type {[number, ...string[]]} */ ([0])
 		);
-		compiler.compilers.forEach((compiler, idx) => {
-			new ProgressPlugin((p, msg, ...args) => {
-				states[idx] = [p, msg, ...args];
-				let sum = 0;
-				for (const [p] of states) sum += p;
-				handler(sum / states.length, `[${idx}] ${msg}`, ...args);
-			}).apply(compiler);
-		});
-	}
-
-	/**
-	 * @param {Compiler} compiler webpack compiler
-	 * @param {HandlerFunction} handler function that executes for every progress step
-	 * @returns {void}
-	 */
-	_applyOnCompiler(compiler, handler) {
-		const showEntries = this.showEntries;
-		const showModules = this.showModules;
-		const showDependencies = this.showDependencies;
-		const showActiveModules = this.showActiveModules;
-		let lastActiveModule = "";
-		let currentLoader = "";
-		let lastModulesCount = 0;
-		let lastDependenciesCount = 0;
-		let lastEntriesCount = 0;
-		let modulesCount = 0;
-		let dependenciesCount = 0;
-		let entriesCount = 1;
-		let doneModules = 0;
-		let doneDependencies = 0;
-		let doneEntries = 0;
-		const activeModules = new Set();
-		let lastUpdate = 0;
+	}
 
-		const updateThrottled = () => {
-			if (lastUpdate + 500 < Date.now()) update();
-		};
+	/**
+	 *
+	 * @param {number} startTime when processing the files has started
+	 * @param {Iterable<string>} files all files
+	 * @param {Iterable<string>} directories all directories
+	 * @param {Iterable<string>} missing all missing files or directories
+	 * @param {Object} options options object (for future extensions)
+	 * @param {boolean=} options.hash should use hash to snapshot
+	 * @param {boolean=} options.timestamp should use timestamp to snapshot
+	 * @param {function((WebpackError | null)=, (Snapshot | null)=): void} callback callback function
+	 * @returns {void}
+	 */
+	createSnapshot(startTime, files, directories, missing, options, callback) {
+		/** @type {Map<string, FileSystemInfoEntry | null>} */
+		const fileTimestamps = new Map();
+		/** @type {Map<string, string | null>} */
+		const fileHashes = new Map();
+		/** @type {Map<string, TimestampAndHash | string | null>} */
+		const fileTshs = new Map();
+		/** @type {Map<string, FileSystemInfoEntry | null>} */
+		const contextTimestamps = new Map();
+		/** @type {Map<string, string | null>} */
+		const contextHashes = new Map();
+		/** @type {Map<string, ResolvedContextTimestampAndHash | null>} */
+		const contextTshs = new Map();
+		/** @type {Map<string, boolean>} */
+		const missingExistence = new Map();
+		/** @type {Map<string, string>} */
+		const managedItemInfo = new Map();
+		/** @type {Set<string>} */
+		const managedFiles = new Set();
+		/** @type {Set<string>} */
+		const managedContexts = new Set();
+		/** @type {Set<string>} */
+		const managedMissing = new Set();
+		/** @type {Set<Snapshot>} */
+		const children = new Set();
 
-		const update = () => {
-			/** @type {string[]} */
-			const items = [];
-			const percentByModules =
-				doneModules /
-				Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);
-			const percentByEntries =
-				doneEntries /
-				Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);
-			const percentByDependencies =
-				doneDependencies /
-				Math.max(lastDependenciesCount || 1, dependenciesCount);
-			let percentageFactor;
+		const snapshot = new Snapshot();
+		if (startTime) snapshot.setStartTime(startTime);
 
-			switch (this.percentBy) {
-				case "entries":
-					percentageFactor = percentByEntries;
-					break;
-				case "dependencies":
-					percentageFactor = percentByDependencies;
-					break;
-				case "modules":
-					percentageFactor = percentByModules;
-					break;
-				default:
-					percentageFactor = median3(
-						percentByModules,
-						percentByEntries,
-						percentByDependencies
-					);
-			}
+		/** @type {Set<string>} */
+		const managedItems = new Set();
 
-			const percentage = 0.1 + percentageFactor * 0.55;
+		/** 1 = timestamp, 2 = hash, 3 = timestamp + hash */
+		const mode = options && options.hash ? (options.timestamp ? 3 : 2) : 1;
 
-			if (currentLoader) {
-				items.push(
-					`import loader ${contextify(
-						compiler.context,
-						currentLoader,
-						compiler.root
-					)}`
-				);
-			} else {
-				const statItems = [];
-				if (showEntries) {
-					statItems.push(`${doneEntries}/${entriesCount} entries`);
+		let jobs = 1;
+		const jobDone = () => {
+			if (--jobs === 0) {
+				if (fileTimestamps.size !== 0) {
+					snapshot.setFileTimestamps(fileTimestamps);
 				}
-				if (showDependencies) {
-					statItems.push(
-						`${doneDependencies}/${dependenciesCount} dependencies`
-					);
+				if (fileHashes.size !== 0) {
+					snapshot.setFileHashes(fileHashes);
 				}
-				if (showModules) {
-					statItems.push(`${doneModules}/${modulesCount} modules`);
+				if (fileTshs.size !== 0) {
+					snapshot.setFileTshs(fileTshs);
 				}
-				if (showActiveModules) {
-					statItems.push(`${activeModules.size} active`);
+				if (contextTimestamps.size !== 0) {
+					snapshot.setContextTimestamps(contextTimestamps);
 				}
-				if (statItems.length > 0) {
-					items.push(statItems.join(" "));
+				if (contextHashes.size !== 0) {
+					snapshot.setContextHashes(contextHashes);
 				}
-				if (showActiveModules) {
-					items.push(lastActiveModule);
+				if (contextTshs.size !== 0) {
+					snapshot.setContextTshs(contextTshs);
 				}
-			}
-			handler(percentage, "building", ...items);
-			lastUpdate = Date.now();
-		};
-
-		const factorizeAdd = () => {
-			dependenciesCount++;
-			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
-				updateThrottled();
-		};
-
-		const factorizeDone = () => {
-			doneDependencies++;
-			if (doneDependencies < 50 || doneDependencies % 100 === 0)
-				updateThrottled();
-		};
-
-		const moduleAdd = () => {
-			modulesCount++;
-			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
-		};
+				if (missingExistence.size !== 0) {
+					snapshot.setMissingExistence(missingExistence);
+				}
+				if (managedItemInfo.size !== 0) {
+					snapshot.setManagedItemInfo(managedItemInfo);
+				}
+				this._managedFilesOptimization.optimize(snapshot, managedFiles);
+				if (managedFiles.size !== 0) {
+					snapshot.setManagedFiles(managedFiles);
+				}
+				this._managedContextsOptimization.optimize(snapshot, managedContexts);
+				if (managedContexts.size !== 0) {
+					snapshot.setManagedContexts(managedContexts);
+				}
+				this._managedMissingOptimization.optimize(snapshot, managedMissing);
+				if (managedMissing.size !== 0) {
+					snapshot.setManagedMissing(managedMissing);
+				}
+				if (children.size !== 0) {
+					snapshot.setChildren(children);
+				}
+				this._snapshotCache.set(snapshot, true);
+				this._statCreatedSnapshots++;
 
-		// only used when showActiveModules is set
-		const moduleBuild = module => {
-			const ident = module.identifier();
-			if (ident) {
-				activeModules.add(ident);
-				lastActiveModule = ident;
-				update();
+				callback(null, snapshot);
 			}
 		};
-
-		const entryAdd = (entry, options) => {
-			entriesCount++;
-			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
+		const jobError = () => {
+			if (jobs > 0) {
+				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
+				jobs = -100000000;
+				callback(null, null);
+			}
 		};
-
-		const moduleDone = module => {
-			doneModules++;
-			if (showActiveModules) {
-				const ident = module.identifier();
-				if (ident) {
-					activeModules.delete(ident);
-					if (lastActiveModule === ident) {
-						lastActiveModule = "";
-						for (const m of activeModules) {
-							lastActiveModule = m;
-						}
-						update();
-						return;
+		const checkManaged = (path, managedSet) => {
+			for (const immutablePath of this.immutablePathsRegExps) {
+				if (immutablePath.test(path)) {
+					managedSet.add(path);
+					return true;
+				}
+			}
+			for (const immutablePath of this.immutablePathsWithSlash) {
+				if (path.startsWith(immutablePath)) {
+					managedSet.add(path);
+					return true;
+				}
+			}
+			for (const managedPath of this.managedPathsRegExps) {
+				const match = managedPath.exec(path);
+				if (match) {
+					const managedItem = getManagedItem(match[1], path);
+					if (managedItem) {
+						managedItems.add(managedItem);
+						managedSet.add(path);
+						return true;
 					}
 				}
 			}
-			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
+			for (const managedPath of this.managedPathsWithSlash) {
+				if (path.startsWith(managedPath)) {
+					const managedItem = getManagedItem(managedPath, path);
+					if (managedItem) {
+						managedItems.add(managedItem);
+						managedSet.add(path);
+						return true;
+					}
+				}
+			}
+			return false;
 		};
-
-		const entryDone = (entry, options) => {
-			doneEntries++;
-			update();
+		const captureNonManaged = (items, managedSet) => {
+			const capturedItems = new Set();
+			for (const path of items) {
+				if (!checkManaged(path, managedSet)) capturedItems.add(path);
+			}
+			return capturedItems;
 		};
-
-		const cache = compiler
-			.getCache("ProgressPlugin")
-			.getItemCache("counts", null);
-
-		let cacheGetPromise;
-
-		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
-			if (!cacheGetPromise) {
-				cacheGetPromise = cache.getPromise().then(
-					data => {
-						if (data) {
-							lastModulesCount = lastModulesCount || data.modulesCount;
-							lastDependenciesCount =
-								lastDependenciesCount || data.dependenciesCount;
+		const processCapturedFiles = capturedFiles => {
+			switch (mode) {
+				case 3:
+					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
+					for (const path of capturedFiles) {
+						const cache = this._fileTshs.get(path);
+						if (cache !== undefined) {
+							fileTshs.set(path, cache);
+						} else {
+							jobs++;
+							this._getFileTimestampAndHash(path, (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting file timestamp hash combination of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									fileTshs.set(path, entry);
+									jobDone();
+								}
+							});
 						}
-						return data;
-					},
-					err => {
-						// Ignore error
 					}
-				);
-			}
-		});
-
-		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
-			if (compilation.compiler.isChild()) return Promise.resolve();
-			return cacheGetPromise.then(async oldData => {
-				if (
-					!oldData ||
-					oldData.modulesCount !== modulesCount ||
-					oldData.dependenciesCount !== dependenciesCount
-				) {
-					await cache.storePromise({ modulesCount, dependenciesCount });
-				}
-			});
-		});
-
-		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
-			if (compilation.compiler.isChild()) return;
-			lastModulesCount = modulesCount;
-			lastEntriesCount = entriesCount;
-			lastDependenciesCount = dependenciesCount;
-			modulesCount = dependenciesCount = entriesCount = 0;
-			doneModules = doneDependencies = doneEntries = 0;
-
-			compilation.factorizeQueue.hooks.added.tap(
-				"ProgressPlugin",
-				factorizeAdd
-			);
-			compilation.factorizeQueue.hooks.result.tap(
-				"ProgressPlugin",
-				factorizeDone
-			);
-
-			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", moduleAdd);
-			compilation.processDependenciesQueue.hooks.result.tap(
-				"ProgressPlugin",
-				moduleDone
-			);
-
-			if (showActiveModules) {
-				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+					break;
+				case 2:
+					this._fileHashesOptimization.optimize(snapshot, capturedFiles);
+					for (const path of capturedFiles) {
+						const cache = this._fileHashes.get(path);
+						if (cache !== undefined) {
+							fileHashes.set(path, cache);
+						} else {
+							jobs++;
+							this.fileHashQueue.add(path, (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting file hash of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									fileHashes.set(path, entry);
+									jobDone();
+								}
+							});
+						}
+					}
+					break;
+				case 1:
+					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
+					for (const path of capturedFiles) {
+						const cache = this._fileTimestamps.get(path);
+						if (cache !== undefined) {
+							if (cache !== "ignore") {
+								fileTimestamps.set(path, cache);
+							}
+						} else {
+							jobs++;
+							this.fileTimestampQueue.add(path, (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting file timestamp of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									fileTimestamps.set(path, entry);
+									jobDone();
+								}
+							});
+						}
+					}
+					break;
 			}
-
-			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
-			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
-			compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
-
-			// avoid dynamic require if bundled with webpack
-			// @ts-expect-error
-			if (false) {}
-
-			const hooks = {
-				finishModules: "finish module graph",
-				seal: "plugins",
-				optimizeDependencies: "dependencies optimization",
-				afterOptimizeDependencies: "after dependencies optimization",
-				beforeChunks: "chunk graph",
-				afterChunks: "after chunk graph",
-				optimize: "optimizing",
-				optimizeModules: "module optimization",
-				afterOptimizeModules: "after module optimization",
-				optimizeChunks: "chunk optimization",
-				afterOptimizeChunks: "after chunk optimization",
-				optimizeTree: "module and chunk tree optimization",
-				afterOptimizeTree: "after module and chunk tree optimization",
-				optimizeChunkModules: "chunk modules optimization",
-				afterOptimizeChunkModules: "after chunk modules optimization",
-				reviveModules: "module reviving",
-				beforeModuleIds: "before module ids",
-				moduleIds: "module ids",
-				optimizeModuleIds: "module id optimization",
-				afterOptimizeModuleIds: "module id optimization",
-				reviveChunks: "chunk reviving",
-				beforeChunkIds: "before chunk ids",
-				chunkIds: "chunk ids",
-				optimizeChunkIds: "chunk id optimization",
-				afterOptimizeChunkIds: "after chunk id optimization",
-				recordModules: "record modules",
-				recordChunks: "record chunks",
-				beforeModuleHash: "module hashing",
-				beforeCodeGeneration: "code generation",
-				beforeRuntimeRequirements: "runtime requirements",
-				beforeHash: "hashing",
-				afterHash: "after hashing",
-				recordHash: "record hash",
-				beforeModuleAssets: "module assets processing",
-				beforeChunkAssets: "chunk assets processing",
-				processAssets: "asset processing",
-				afterProcessAssets: "after asset optimization",
-				record: "recording",
-				afterSeal: "after seal"
-			};
-			const numberOfHooks = Object.keys(hooks).length;
-			Object.keys(hooks).forEach((name, idx) => {
-				const title = hooks[name];
-				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
-				compilation.hooks[name].intercept({
-					name: "ProgressPlugin",
-					call() {
-						handler(percentage, "sealing", title);
-					},
-					done() {
-						progressReporters.set(compiler, undefined);
-						handler(percentage, "sealing", title);
-					},
-					result() {
-						handler(percentage, "sealing", title);
-					},
-					error() {
-						handler(percentage, "sealing", title);
-					},
-					tap(tap) {
-						// p is percentage from 0 to 1
-						// args is any number of messages in a hierarchical matter
-						progressReporters.set(compilation.compiler, (p, ...args) => {
-							handler(percentage, "sealing", title, tap.name, ...args);
-						});
-						handler(percentage, "sealing", title, tap.name);
+		};
+		if (files) {
+			processCapturedFiles(captureNonManaged(files, managedFiles));
+		}
+		const processCapturedDirectories = capturedDirectories => {
+			switch (mode) {
+				case 3:
+					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
+					for (const path of capturedDirectories) {
+						const cache = this._contextTshs.get(path);
+						/** @type {ResolvedContextTimestampAndHash} */
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedTimestamp(cache)) !== undefined
+						) {
+							contextTshs.set(path, resolved);
+						} else {
+							jobs++;
+							/**
+							 * @param {Error=} err error
+							 * @param {ResolvedContextTimestampAndHash=} entry entry
+							 * @returns {void}
+							 */
+							const callback = (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting context timestamp hash combination of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									contextTshs.set(path, entry);
+									jobDone();
+								}
+							};
+							if (cache !== undefined) {
+								this._resolveContextTsh(cache, callback);
+							} else {
+								this.getContextTsh(path, callback);
+							}
+						}
+					}
+					break;
+				case 2:
+					this._contextHashesOptimization.optimize(
+						snapshot,
+						capturedDirectories
+					);
+					for (const path of capturedDirectories) {
+						const cache = this._contextHashes.get(path);
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedHash(cache)) !== undefined
+						) {
+							contextHashes.set(path, resolved);
+						} else {
+							jobs++;
+							const callback = (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting context hash of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									contextHashes.set(path, entry);
+									jobDone();
+								}
+							};
+							if (cache !== undefined) {
+								this._resolveContextHash(cache, callback);
+							} else {
+								this.getContextHash(path, callback);
+							}
+						}
 					}
-				});
-			});
-		});
-		compiler.hooks.make.intercept({
-			name: "ProgressPlugin",
-			call() {
-				handler(0.1, "building");
-			},
-			done() {
-				handler(0.65, "building");
+					break;
+				case 1:
+					this._contextTimestampsOptimization.optimize(
+						snapshot,
+						capturedDirectories
+					);
+					for (const path of capturedDirectories) {
+						const cache = this._contextTimestamps.get(path);
+						if (cache === "ignore") continue;
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedTimestamp(cache)) !== undefined
+						) {
+							contextTimestamps.set(path, resolved);
+						} else {
+							jobs++;
+							/**
+							 * @param {Error=} err error
+							 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+							 * @returns {void}
+							 */
+							const callback = (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting context timestamp of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									contextTimestamps.set(path, entry);
+									jobDone();
+								}
+							};
+							if (cache !== undefined) {
+								this._resolveContextTimestamp(cache, callback);
+							} else {
+								this.getContextTimestamp(path, callback);
+							}
+						}
+					}
+					break;
 			}
-		});
-		const interceptHook = (hook, progress, category, name) => {
-			hook.intercept({
-				name: "ProgressPlugin",
-				call() {
-					handler(progress, category, name);
-				},
-				done() {
-					progressReporters.set(compiler, undefined);
-					handler(progress, category, name);
-				},
-				result() {
-					handler(progress, category, name);
-				},
-				error() {
-					handler(progress, category, name);
-				},
-				tap(tap) {
-					progressReporters.set(compiler, (p, ...args) => {
-						handler(progress, category, name, tap.name, ...args);
+		};
+		if (directories) {
+			processCapturedDirectories(
+				captureNonManaged(directories, managedContexts)
+			);
+		}
+		const processCapturedMissing = capturedMissing => {
+			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
+			for (const path of capturedMissing) {
+				const cache = this._fileTimestamps.get(path);
+				if (cache !== undefined) {
+					if (cache !== "ignore") {
+						missingExistence.set(path, Boolean(cache));
+					}
+				} else {
+					jobs++;
+					this.fileTimestampQueue.add(path, (err, entry) => {
+						if (err) {
+							if (this.logger) {
+								this.logger.debug(
+									`Error snapshotting missing timestamp of ${path}: ${err.stack}`
+								);
+							}
+							jobError();
+						} else {
+							missingExistence.set(path, Boolean(entry));
+							jobDone();
+						}
 					});
-					handler(progress, category, name, tap.name);
 				}
-			});
-		};
-		compiler.cache.hooks.endIdle.intercept({
-			name: "ProgressPlugin",
-			call() {
-				handler(0, "");
-			}
-		});
-		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
-		compiler.hooks.initialize.intercept({
-			name: "ProgressPlugin",
-			call() {
-				handler(0, "");
-			}
-		});
-		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
-		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
-		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
-		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
-		interceptHook(
-			compiler.hooks.normalModuleFactory,
-			0.04,
-			"setup",
-			"normal module factory"
-		);
-		interceptHook(
-			compiler.hooks.contextModuleFactory,
-			0.05,
-			"setup",
-			"context module factory"
-		);
-		interceptHook(
-			compiler.hooks.beforeCompile,
-			0.06,
-			"setup",
-			"before compile"
-		);
-		interceptHook(compiler.hooks.compile, 0.07, "setup", "compile");
-		interceptHook(compiler.hooks.thisCompilation, 0.08, "setup", "compilation");
-		interceptHook(compiler.hooks.compilation, 0.09, "setup", "compilation");
-		interceptHook(compiler.hooks.finishMake, 0.69, "building", "finish");
-		interceptHook(compiler.hooks.emit, 0.95, "emitting", "emit");
-		interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit");
-		interceptHook(compiler.hooks.done, 0.99, "done", "plugins");
-		compiler.hooks.done.intercept({
-			name: "ProgressPlugin",
-			done() {
-				handler(0.99, "");
-			}
-		});
-		interceptHook(
-			compiler.cache.hooks.storeBuildDependencies,
-			0.99,
-			"cache",
-			"store build dependencies"
-		);
-		interceptHook(compiler.cache.hooks.shutdown, 0.99, "cache", "shutdown");
-		interceptHook(compiler.cache.hooks.beginIdle, 0.99, "cache", "begin idle");
-		interceptHook(
-			compiler.hooks.watchClose,
-			0.99,
-			"end",
-			"closing watch compilation"
-		);
-		compiler.cache.hooks.beginIdle.intercept({
-			name: "ProgressPlugin",
-			done() {
-				handler(1, "");
 			}
-		});
-		compiler.cache.hooks.shutdown.intercept({
-			name: "ProgressPlugin",
-			done() {
-				handler(1, "");
-			}
-		});
-	}
-}
-
-ProgressPlugin.defaultOptions = {
-	profile: false,
-	modulesCount: 5000,
-	dependenciesCount: 10000,
-	modules: true,
-	dependencies: true,
-	activeModules: false,
-	entries: true
-};
-
-module.exports = ProgressPlugin;
-
-
-/***/ }),
-
-/***/ 38309:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ConstDependency = __webpack_require__(76911);
-const ProvidedDependency = __webpack_require__(95770);
-const { approve } = __webpack_require__(93998);
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class ProvidePlugin {
-	/**
-	 * @param {Record<string, string | string[]>} definitions the provided identifiers
-	 */
-	constructor(definitions) {
-		this.definitions = definitions;
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const definitions = this.definitions;
-		compiler.hooks.compilation.tap(
-			"ProvidePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					ProvidedDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ProvidedDependency,
-					new ProvidedDependency.Template()
-				);
-				const handler = (parser, parserOptions) => {
-					Object.keys(definitions).forEach(name => {
-						const request = [].concat(definitions[name]);
-						const splittedName = name.split(".");
-						if (splittedName.length > 0) {
-							splittedName.slice(1).forEach((_, i) => {
-								const name = splittedName.slice(0, i + 1).join(".");
-								parser.hooks.canRename.for(name).tap("ProvidePlugin", approve);
-							});
-						}
-
-						parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
-							const nameIdentifier = name.includes(".")
-								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
-								: name;
-							const dep = new ProvidedDependency(
-								request[0],
-								nameIdentifier,
-								request.slice(1),
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-							return true;
-						});
-
-						parser.hooks.call.for(name).tap("ProvidePlugin", expr => {
-							const nameIdentifier = name.includes(".")
-								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
-								: name;
-							const dep = new ProvidedDependency(
-								request[0],
-								nameIdentifier,
-								request.slice(1),
-								expr.callee.range
+		};
+		if (missing) {
+			processCapturedMissing(captureNonManaged(missing, managedMissing));
+		}
+		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
+		for (const path of managedItems) {
+			const cache = this._managedItems.get(path);
+			if (cache !== undefined) {
+				if (!cache.startsWith("*")) {
+					managedFiles.add(join(this.fs, path, "package.json"));
+				} else if (cache === "*nested") {
+					managedMissing.add(join(this.fs, path, "package.json"));
+				}
+				managedItemInfo.set(path, cache);
+			} else {
+				jobs++;
+				this.managedItemQueue.add(path, (err, entry) => {
+					if (err) {
+						if (this.logger) {
+							this.logger.debug(
+								`Error snapshotting managed item ${path}: ${err.stack}`
 							);
-							dep.loc = expr.callee.loc;
-							parser.state.module.addDependency(dep);
-							parser.walkExpressions(expr.arguments);
-							return true;
-						});
-					});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ProvidePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ProvidePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ProvidePlugin", handler);
+						}
+						jobError();
+					} else if (entry) {
+						if (!entry.startsWith("*")) {
+							managedFiles.add(join(this.fs, path, "package.json"));
+						} else if (cache === "*nested") {
+							managedMissing.add(join(this.fs, path, "package.json"));
+						}
+						managedItemInfo.set(path, entry);
+						jobDone();
+					} else {
+						// Fallback to normal snapshotting
+						const process = (set, fn) => {
+							if (set.size === 0) return;
+							const captured = new Set();
+							for (const file of set) {
+								if (file.startsWith(path)) captured.add(file);
+							}
+							if (captured.size > 0) fn(captured);
+						};
+						process(managedFiles, processCapturedFiles);
+						process(managedContexts, processCapturedDirectories);
+						process(managedMissing, processCapturedMissing);
+						jobDone();
+					}
+				});
 			}
-		);
-	}
-}
-
-module.exports = ProvidePlugin;
-
-
-/***/ }),
-
-/***/ 84929:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["javascript"]);
-
-class RawModule extends Module {
-	/**
-	 * @param {string} source source code
-	 * @param {string} identifier unique identifier
-	 * @param {string=} readableIdentifier readable identifier
-	 * @param {ReadonlySet<string>=} runtimeRequirements runtime requirements needed for the source code
-	 */
-	constructor(source, identifier, readableIdentifier, runtimeRequirements) {
-		super("javascript/dynamic", null);
-		this.sourceStr = source;
-		this.identifierStr = identifier || this.sourceStr;
-		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
-		this.runtimeRequirements = runtimeRequirements || null;
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return this.identifierStr;
-	}
-
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return Math.max(1, this.sourceStr.length);
-	}
-
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.readableIdentifierStr);
+		}
+		jobDone();
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {Snapshot} snapshot1 a snapshot
+	 * @param {Snapshot} snapshot2 a snapshot
+	 * @returns {Snapshot} merged snapshot
 	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
+	mergeSnapshots(snapshot1, snapshot2) {
+		const snapshot = new Snapshot();
+		if (snapshot1.hasStartTime() && snapshot2.hasStartTime())
+			snapshot.setStartTime(Math.min(snapshot1.startTime, snapshot2.startTime));
+		else if (snapshot2.hasStartTime()) snapshot.startTime = snapshot2.startTime;
+		else if (snapshot1.hasStartTime()) snapshot.startTime = snapshot1.startTime;
+		if (snapshot1.hasFileTimestamps() || snapshot2.hasFileTimestamps()) {
+			snapshot.setFileTimestamps(
+				mergeMaps(snapshot1.fileTimestamps, snapshot2.fileTimestamps)
+			);
+		}
+		if (snapshot1.hasFileHashes() || snapshot2.hasFileHashes()) {
+			snapshot.setFileHashes(
+				mergeMaps(snapshot1.fileHashes, snapshot2.fileHashes)
+			);
+		}
+		if (snapshot1.hasFileTshs() || snapshot2.hasFileTshs()) {
+			snapshot.setFileTshs(mergeMaps(snapshot1.fileTshs, snapshot2.fileTshs));
+		}
+		if (snapshot1.hasContextTimestamps() || snapshot2.hasContextTimestamps()) {
+			snapshot.setContextTimestamps(
+				mergeMaps(snapshot1.contextTimestamps, snapshot2.contextTimestamps)
+			);
+		}
+		if (snapshot1.hasContextHashes() || snapshot2.hasContextHashes()) {
+			snapshot.setContextHashes(
+				mergeMaps(snapshot1.contextHashes, snapshot2.contextHashes)
+			);
+		}
+		if (snapshot1.hasContextTshs() || snapshot2.hasContextTshs()) {
+			snapshot.setContextTshs(
+				mergeMaps(snapshot1.contextTshs, snapshot2.contextTshs)
+			);
+		}
+		if (snapshot1.hasMissingExistence() || snapshot2.hasMissingExistence()) {
+			snapshot.setMissingExistence(
+				mergeMaps(snapshot1.missingExistence, snapshot2.missingExistence)
+			);
+		}
+		if (snapshot1.hasManagedItemInfo() || snapshot2.hasManagedItemInfo()) {
+			snapshot.setManagedItemInfo(
+				mergeMaps(snapshot1.managedItemInfo, snapshot2.managedItemInfo)
+			);
+		}
+		if (snapshot1.hasManagedFiles() || snapshot2.hasManagedFiles()) {
+			snapshot.setManagedFiles(
+				mergeSets(snapshot1.managedFiles, snapshot2.managedFiles)
+			);
+		}
+		if (snapshot1.hasManagedContexts() || snapshot2.hasManagedContexts()) {
+			snapshot.setManagedContexts(
+				mergeSets(snapshot1.managedContexts, snapshot2.managedContexts)
+			);
+		}
+		if (snapshot1.hasManagedMissing() || snapshot2.hasManagedMissing()) {
+			snapshot.setManagedMissing(
+				mergeSets(snapshot1.managedMissing, snapshot2.managedMissing)
+			);
+		}
+		if (snapshot1.hasChildren() || snapshot2.hasChildren()) {
+			snapshot.setChildren(mergeSets(snapshot1.children, snapshot2.children));
+		}
+		if (
+			this._snapshotCache.get(snapshot1) === true &&
+			this._snapshotCache.get(snapshot2) === true
+		) {
+			this._snapshotCache.set(snapshot, true);
+		}
+		return snapshot;
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {Snapshot} snapshot the snapshot made
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			cacheable: true
-		};
-		callback();
-	}
-
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		const sources = new Map();
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			sources.set(
-				"javascript",
-				new OriginalSource(this.sourceStr, this.identifier())
-			);
-		} else {
-			sources.set("javascript", new RawSource(this.sourceStr));
+	checkSnapshotValid(snapshot, callback) {
+		const cachedResult = this._snapshotCache.get(snapshot);
+		if (cachedResult !== undefined) {
+			this._statTestedSnapshotsCached++;
+			if (typeof cachedResult === "boolean") {
+				callback(null, cachedResult);
+			} else {
+				cachedResult.push(callback);
+			}
+			return;
 		}
-		return { sources, runtimeRequirements: this.runtimeRequirements };
+		this._statTestedSnapshotsNotCached++;
+		this._checkSnapshotValidNoCache(snapshot, callback);
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * @param {Snapshot} snapshot the snapshot made
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		hash.update(this.sourceStr);
-		super.updateHash(hash, context);
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.sourceStr);
-		write(this.identifierStr);
-		write(this.readableIdentifierStr);
-		write(this.runtimeRequirements);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.sourceStr = read();
-		this.identifierStr = read();
-		this.readableIdentifierStr = read();
-		this.runtimeRequirements = read();
+	_checkSnapshotValidNoCache(snapshot, callback) {
+		/** @type {number | undefined} */
+		let startTime = undefined;
+		if (snapshot.hasStartTime()) {
+			startTime = snapshot.startTime;
+		}
+		let jobs = 1;
+		const jobDone = () => {
+			if (--jobs === 0) {
+				this._snapshotCache.set(snapshot, true);
+				callback(null, true);
+			}
+		};
+		const invalid = () => {
+			if (jobs > 0) {
+				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
+				jobs = -100000000;
+				this._snapshotCache.set(snapshot, false);
+				callback(null, false);
+			}
+		};
+		const invalidWithError = (path, err) => {
+			if (this._remainingLogs > 0) {
+				this._log(path, `error occurred: %s`, err);
+			}
+			invalid();
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {string} current current hash
+		 * @param {string} snap snapshot hash
+		 * @returns {boolean} true, if ok
+		 */
+		const checkHash = (path, current, snap) => {
+			if (current !== snap) {
+				// If hash differ it's invalid
+				if (this._remainingLogs > 0) {
+					this._log(path, `hashes differ (%s != %s)`, current, snap);
+				}
+				return false;
+			}
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {boolean} current current entry
+		 * @param {boolean} snap entry from snapshot
+		 * @returns {boolean} true, if ok
+		 */
+		const checkExistence = (path, current, snap) => {
+			if (!current !== !snap) {
+				// If existence of item differs
+				// it's invalid
+				if (this._remainingLogs > 0) {
+					this._log(
+						path,
+						current ? "it didn't exist before" : "it does no longer exist"
+					);
+				}
+				return false;
+			}
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {FileSystemInfoEntry} current current entry
+		 * @param {FileSystemInfoEntry} snap entry from snapshot
+		 * @param {boolean} log log reason
+		 * @returns {boolean} true, if ok
+		 */
+		const checkFile = (path, current, snap, log = true) => {
+			if (current === snap) return true;
+			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
+			if (current) {
+				// For existing items only
+				if (typeof startTime === "number" && current.safeTime > startTime) {
+					// If a change happened after starting reading the item
+					// this may no longer be valid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`it may have changed (%d) after the start time of the snapshot (%d)`,
+							current.safeTime,
+							startTime
+						);
+					}
+					return false;
+				}
+				if (
+					snap.timestamp !== undefined &&
+					current.timestamp !== snap.timestamp
+				) {
+					// If we have a timestamp (it was a file or symlink) and it differs from current timestamp
+					// it's invalid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`timestamps differ (%d != %d)`,
+							current.timestamp,
+							snap.timestamp
+						);
+					}
+					return false;
+				}
+			}
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {ResolvedContextFileSystemInfoEntry} current current entry
+		 * @param {ResolvedContextFileSystemInfoEntry} snap entry from snapshot
+		 * @param {boolean} log log reason
+		 * @returns {boolean} true, if ok
+		 */
+		const checkContext = (path, current, snap, log = true) => {
+			if (current === snap) return true;
+			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
+			if (current) {
+				// For existing items only
+				if (typeof startTime === "number" && current.safeTime > startTime) {
+					// If a change happened after starting reading the item
+					// this may no longer be valid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`it may have changed (%d) after the start time of the snapshot (%d)`,
+							current.safeTime,
+							startTime
+						);
+					}
+					return false;
+				}
+				if (
+					snap.timestampHash !== undefined &&
+					current.timestampHash !== snap.timestampHash
+				) {
+					// If we have a timestampHash (it was a directory) and it differs from current timestampHash
+					// it's invalid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`timestamps hashes differ (%s != %s)`,
+							current.timestampHash,
+							snap.timestampHash
+						);
+					}
+					return false;
+				}
+			}
+			return true;
+		};
+		if (snapshot.hasChildren()) {
+			const childCallback = (err, result) => {
+				if (err || !result) return invalid();
+				else jobDone();
+			};
+			for (const child of snapshot.children) {
+				const cache = this._snapshotCache.get(child);
+				if (cache !== undefined) {
+					this._statTestedChildrenCached++;
+					/* istanbul ignore else */
+					if (typeof cache === "boolean") {
+						if (cache === false) {
+							invalid();
+							return;
+						}
+					} else {
+						jobs++;
+						cache.push(childCallback);
+					}
+				} else {
+					this._statTestedChildrenNotCached++;
+					jobs++;
+					this._checkSnapshotValidNoCache(child, childCallback);
+				}
+			}
+		}
+		if (snapshot.hasFileTimestamps()) {
+			const { fileTimestamps } = snapshot;
+			this._statTestedEntries += fileTimestamps.size;
+			for (const [path, ts] of fileTimestamps) {
+				const cache = this._fileTimestamps.get(path);
+				if (cache !== undefined) {
+					if (cache !== "ignore" && !checkFile(path, cache, ts)) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					this.fileTimestampQueue.add(path, (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkFile(path, entry, ts)) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					});
+				}
+			}
+		}
+		const processFileHashSnapshot = (path, hash) => {
+			const cache = this._fileHashes.get(path);
+			if (cache !== undefined) {
+				if (cache !== "ignore" && !checkHash(path, cache, hash)) {
+					invalid();
+					return;
+				}
+			} else {
+				jobs++;
+				this.fileHashQueue.add(path, (err, entry) => {
+					if (err) return invalidWithError(path, err);
+					if (!checkHash(path, entry, hash)) {
+						invalid();
+					} else {
+						jobDone();
+					}
+				});
+			}
+		};
+		if (snapshot.hasFileHashes()) {
+			const { fileHashes } = snapshot;
+			this._statTestedEntries += fileHashes.size;
+			for (const [path, hash] of fileHashes) {
+				processFileHashSnapshot(path, hash);
+			}
+		}
+		if (snapshot.hasFileTshs()) {
+			const { fileTshs } = snapshot;
+			this._statTestedEntries += fileTshs.size;
+			for (const [path, tsh] of fileTshs) {
+				if (typeof tsh === "string") {
+					processFileHashSnapshot(path, tsh);
+				} else {
+					const cache = this._fileTimestamps.get(path);
+					if (cache !== undefined) {
+						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
+							processFileHashSnapshot(path, tsh && tsh.hash);
+						}
+					} else {
+						jobs++;
+						this.fileTimestampQueue.add(path, (err, entry) => {
+							if (err) return invalidWithError(path, err);
+							if (!checkFile(path, entry, tsh, false)) {
+								processFileHashSnapshot(path, tsh && tsh.hash);
+							}
+							jobDone();
+						});
+					}
+				}
+			}
+		}
+		if (snapshot.hasContextTimestamps()) {
+			const { contextTimestamps } = snapshot;
+			this._statTestedEntries += contextTimestamps.size;
+			for (const [path, ts] of contextTimestamps) {
+				const cache = this._contextTimestamps.get(path);
+				if (cache === "ignore") continue;
+				let resolved;
+				if (
+					cache !== undefined &&
+					(resolved = getResolvedTimestamp(cache)) !== undefined
+				) {
+					if (!checkContext(path, resolved, ts)) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					/**
+					 * @param {Error=} err error
+					 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+					 * @returns {void}
+					 */
+					const callback = (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkContext(path, entry, ts)) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					};
+					if (cache !== undefined) {
+						this._resolveContextTimestamp(cache, callback);
+					} else {
+						this.getContextTimestamp(path, callback);
+					}
+				}
+			}
+		}
+		const processContextHashSnapshot = (path, hash) => {
+			const cache = this._contextHashes.get(path);
+			let resolved;
+			if (
+				cache !== undefined &&
+				(resolved = getResolvedHash(cache)) !== undefined
+			) {
+				if (!checkHash(path, resolved, hash)) {
+					invalid();
+					return;
+				}
+			} else {
+				jobs++;
+				const callback = (err, entry) => {
+					if (err) return invalidWithError(path, err);
+					if (!checkHash(path, entry, hash)) {
+						invalid();
+					} else {
+						jobDone();
+					}
+				};
+				if (cache !== undefined) {
+					this._resolveContextHash(cache, callback);
+				} else {
+					this.getContextHash(path, callback);
+				}
+			}
+		};
+		if (snapshot.hasContextHashes()) {
+			const { contextHashes } = snapshot;
+			this._statTestedEntries += contextHashes.size;
+			for (const [path, hash] of contextHashes) {
+				processContextHashSnapshot(path, hash);
+			}
+		}
+		if (snapshot.hasContextTshs()) {
+			const { contextTshs } = snapshot;
+			this._statTestedEntries += contextTshs.size;
+			for (const [path, tsh] of contextTshs) {
+				if (typeof tsh === "string") {
+					processContextHashSnapshot(path, tsh);
+				} else {
+					const cache = this._contextTimestamps.get(path);
+					if (cache === "ignore") continue;
+					let resolved;
+					if (
+						cache !== undefined &&
+						(resolved = getResolvedTimestamp(cache)) !== undefined
+					) {
+						if (!checkContext(path, resolved, tsh, false)) {
+							processContextHashSnapshot(path, tsh && tsh.hash);
+						}
+					} else {
+						jobs++;
+						/**
+						 * @param {Error=} err error
+						 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+						 * @returns {void}
+						 */
+						const callback = (err, entry) => {
+							if (err) return invalidWithError(path, err);
+							if (!checkContext(path, entry, tsh, false)) {
+								processContextHashSnapshot(path, tsh && tsh.hash);
+							}
+							jobDone();
+						};
+						if (cache !== undefined) {
+							this._resolveContextTimestamp(cache, callback);
+						} else {
+							this.getContextTimestamp(path, callback);
+						}
+					}
+				}
+			}
+		}
+		if (snapshot.hasMissingExistence()) {
+			const { missingExistence } = snapshot;
+			this._statTestedEntries += missingExistence.size;
+			for (const [path, existence] of missingExistence) {
+				const cache = this._fileTimestamps.get(path);
+				if (cache !== undefined) {
+					if (
+						cache !== "ignore" &&
+						!checkExistence(path, Boolean(cache), Boolean(existence))
+					) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					this.fileTimestampQueue.add(path, (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkExistence(path, Boolean(entry), Boolean(existence))) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					});
+				}
+			}
+		}
+		if (snapshot.hasManagedItemInfo()) {
+			const { managedItemInfo } = snapshot;
+			this._statTestedEntries += managedItemInfo.size;
+			for (const [path, info] of managedItemInfo) {
+				const cache = this._managedItems.get(path);
+				if (cache !== undefined) {
+					if (!checkHash(path, cache, info)) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					this.managedItemQueue.add(path, (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkHash(path, entry, info)) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					});
+				}
+			}
+		}
+		jobDone();
 
-		super.deserialize(context);
+		// if there was an async action
+		// try to join multiple concurrent request for this snapshot
+		if (jobs > 0) {
+			const callbacks = [callback];
+			callback = (err, result) => {
+				for (const callback of callbacks) callback(err, result);
+			};
+			this._snapshotCache.set(snapshot, callbacks);
+		}
 	}
-}
 
-makeSerializable(RawModule, "webpack/lib/RawModule");
+	_readFileTimestamp(path, callback) {
+		this.fs.stat(path, (err, stat) => {
+			if (err) {
+				if (err.code === "ENOENT") {
+					this._fileTimestamps.set(path, null);
+					this._cachedDeprecatedFileTimestamps = undefined;
+					return callback(null, null);
+				}
+				return callback(err);
+			}
 
-module.exports = RawModule;
+			let ts;
+			if (stat.isDirectory()) {
+				ts = {
+					safeTime: 0,
+					timestamp: undefined
+				};
+			} else {
+				const mtime = +stat.mtime;
 
+				if (mtime) applyMtime(mtime);
 
-/***/ }),
+				ts = {
+					safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
+					timestamp: mtime
+				};
+			}
 
-/***/ 11094:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			this._fileTimestamps.set(path, ts);
+			this._cachedDeprecatedFileTimestamps = undefined;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			callback(null, ts);
+		});
+	}
 
+	_readFileHash(path, callback) {
+		this.fs.readFile(path, (err, content) => {
+			if (err) {
+				if (err.code === "EISDIR") {
+					this._fileHashes.set(path, "directory");
+					return callback(null, "directory");
+				}
+				if (err.code === "ENOENT") {
+					this._fileHashes.set(path, null);
+					return callback(null, null);
+				}
+				if (err.code === "ERR_FS_FILE_TOO_LARGE") {
+					this.logger.warn(`Ignoring ${path} for hashing as it's very large`);
+					this._fileHashes.set(path, "too large");
+					return callback(null, "too large");
+				}
+				return callback(err);
+			}
 
+			const hash = createHash(this._hashFunction);
 
-const { compareNumbers } = __webpack_require__(29579);
-const identifierUtils = __webpack_require__(82186);
+			hash.update(content);
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
+			const digest = /** @type {string} */ (hash.digest("hex"));
 
-/**
- * @typedef {Object} RecordsChunks
- * @property {Record<string, number>=} byName
- * @property {Record<string, number>=} bySource
- * @property {number[]=} usedIds
- */
+			this._fileHashes.set(path, digest);
 
-/**
- * @typedef {Object} RecordsModules
- * @property {Record<string, number>=} byIdentifier
- * @property {Record<string, number>=} bySource
- * @property {number[]=} usedIds
- */
+			callback(null, digest);
+		});
+	}
 
-/**
- * @typedef {Object} Records
- * @property {RecordsChunks=} chunks
- * @property {RecordsModules=} modules
- */
+	_getFileTimestampAndHash(path, callback) {
+		const continueWithHash = hash => {
+			const cache = this._fileTimestamps.get(path);
+			if (cache !== undefined) {
+				if (cache !== "ignore") {
+					const result = {
+						...cache,
+						hash
+					};
+					this._fileTshs.set(path, result);
+					return callback(null, result);
+				} else {
+					this._fileTshs.set(path, hash);
+					return callback(null, hash);
+				}
+			} else {
+				this.fileTimestampQueue.add(path, (err, entry) => {
+					if (err) {
+						return callback(err);
+					}
+					const result = {
+						...entry,
+						hash
+					};
+					this._fileTshs.set(path, result);
+					return callback(null, result);
+				});
+			}
+		};
 
-class RecordIdsPlugin {
-	/**
-	 * @param {Object} options Options object
-	 * @param {boolean=} options.portableIds true, when ids need to be portable
-	 */
-	constructor(options) {
-		this.options = options || {};
+		const cache = this._fileHashes.get(path);
+		if (cache !== undefined) {
+			continueWithHash(cache);
+		} else {
+			this.fileHashQueue.add(path, (err, entry) => {
+				if (err) {
+					return callback(err);
+				}
+				continueWithHash(entry);
+			});
+		}
 	}
 
 	/**
-	 * @param {Compiler} compiler the Compiler
-	 * @returns {void}
+	 * @template T
+	 * @template ItemType
+	 * @param {Object} options options
+	 * @param {string} options.path path
+	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
+	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
+	 * @param {function(string, string, function(Error=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
+	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromFile called when context item is a file
+	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromDirectory called when context item is a directory
+	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
+	 * @param {function((Error | null)=, (T)=): void} callback callback
 	 */
-	apply(compiler) {
-		const portableIds = this.options.portableIds;
-
-		const makePathsRelative =
-			identifierUtils.makePathsRelative.bindContextCache(
-				compiler.context,
-				compiler.root
-			);
-
-		/**
-		 * @param {Module} module the module
-		 * @returns {string} the (portable) identifier
-		 */
-		const getModuleIdentifier = module => {
-			if (portableIds) {
-				return makePathsRelative(module.identifier());
+	_readContext(
+		{
+			path,
+			fromImmutablePath,
+			fromManagedItem,
+			fromSymlink,
+			fromFile,
+			fromDirectory,
+			reduce
+		},
+		callback
+	) {
+		this.fs.readdir(path, (err, _files) => {
+			if (err) {
+				if (err.code === "ENOENT") {
+					return callback(null, null);
+				}
+				return callback(err);
 			}
-			return module.identifier();
-		};
-
-		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
-			compilation.hooks.recordModules.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Module[]} modules the modules array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(modules, records) => {
-					const chunkGraph = compilation.chunkGraph;
-					if (!records.modules) records.modules = {};
-					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
-					/** @type {Set<number>} */
-					const usedIds = new Set();
-					for (const module of modules) {
-						const moduleId = chunkGraph.getModuleId(module);
-						if (typeof moduleId !== "number") continue;
-						const identifier = getModuleIdentifier(module);
-						records.modules.byIdentifier[identifier] = moduleId;
-						usedIds.add(moduleId);
+			const files = /** @type {string[]} */ (_files)
+				.map(file => file.normalize("NFC"))
+				.filter(file => !/^\./.test(file))
+				.sort();
+			asyncLib.map(
+				files,
+				(file, callback) => {
+					const child = join(this.fs, path, file);
+					for (const immutablePath of this.immutablePathsRegExps) {
+						if (immutablePath.test(path)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(path));
+						}
 					}
-					records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
-				}
-			);
-			compilation.hooks.reviveModules.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Module[]} modules the modules array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(modules, records) => {
-					if (!records.modules) return;
-					if (records.modules.byIdentifier) {
-						const chunkGraph = compilation.chunkGraph;
-						/** @type {Set<number>} */
-						const usedIds = new Set();
-						for (const module of modules) {
-							const moduleId = chunkGraph.getModuleId(module);
-							if (moduleId !== null) continue;
-							const identifier = getModuleIdentifier(module);
-							const id = records.modules.byIdentifier[identifier];
-							if (id === undefined) continue;
-							if (usedIds.has(id)) continue;
-							usedIds.add(id);
-							chunkGraph.setModuleId(module, id);
+					for (const immutablePath of this.immutablePathsWithSlash) {
+						if (path.startsWith(immutablePath)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(path));
 						}
 					}
-					if (Array.isArray(records.modules.usedIds)) {
-						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					for (const managedPath of this.managedPathsRegExps) {
+						const match = managedPath.exec(path);
+						if (match) {
+							const managedItem = getManagedItem(match[1], path);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
+							}
+						}
 					}
-				}
-			);
-
-			/**
-			 * @param {Chunk} chunk the chunk
-			 * @returns {string[]} sources of the chunk
-			 */
-			const getChunkSources = chunk => {
-				/** @type {string[]} */
-				const sources = [];
-				for (const chunkGroup of chunk.groupsIterable) {
-					const index = chunkGroup.chunks.indexOf(chunk);
-					if (chunkGroup.name) {
-						sources.push(`${index} ${chunkGroup.name}`);
-					} else {
-						for (const origin of chunkGroup.origins) {
-							if (origin.module) {
-								if (origin.request) {
-									sources.push(
-										`${index} ${getModuleIdentifier(origin.module)} ${
-											origin.request
-										}`
-									);
-								} else if (typeof origin.loc === "string") {
-									sources.push(
-										`${index} ${getModuleIdentifier(origin.module)} ${
-											origin.loc
-										}`
-									);
-								} else if (
-									origin.loc &&
-									typeof origin.loc === "object" &&
-									"start" in origin.loc
-								) {
-									sources.push(
-										`${index} ${getModuleIdentifier(
-											origin.module
-										)} ${JSON.stringify(origin.loc.start)}`
-									);
-								}
+					for (const managedPath of this.managedPathsWithSlash) {
+						if (path.startsWith(managedPath)) {
+							const managedItem = getManagedItem(managedPath, child);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
 							}
 						}
 					}
-				}
-				return sources;
-			};
 
-			compilation.hooks.recordChunks.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Chunk[]} chunks the chunks array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(chunks, records) => {
-					if (!records.chunks) records.chunks = {};
-					if (!records.chunks.byName) records.chunks.byName = {};
-					if (!records.chunks.bySource) records.chunks.bySource = {};
-					/** @type {Set<number>} */
-					const usedIds = new Set();
-					for (const chunk of chunks) {
-						if (typeof chunk.id !== "number") continue;
-						const name = chunk.name;
-						if (name) records.chunks.byName[name] = chunk.id;
-						const sources = getChunkSources(chunk);
-						for (const source of sources) {
-							records.chunks.bySource[source] = chunk.id;
+					lstatReadlinkAbsolute(this.fs, child, (err, stat) => {
+						if (err) return callback(err);
+
+						if (typeof stat === "string") {
+							return fromSymlink(child, stat, callback);
 						}
-						usedIds.add(chunk.id);
-					}
-					records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
+
+						if (stat.isFile()) {
+							return fromFile(child, stat, callback);
+						}
+						if (stat.isDirectory()) {
+							return fromDirectory(child, stat, callback);
+						}
+						callback(null, null);
+					});
+				},
+				(err, results) => {
+					if (err) return callback(err);
+					const result = reduce(files, results);
+					callback(null, result);
 				}
 			);
-			compilation.hooks.reviveChunks.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Chunk[]} chunks the chunks array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(chunks, records) => {
-					if (!records.chunks) return;
-					/** @type {Set<number>} */
-					const usedIds = new Set();
-					if (records.chunks.byName) {
-						for (const chunk of chunks) {
-							if (chunk.id !== null) continue;
-							if (!chunk.name) continue;
-							const id = records.chunks.byName[chunk.name];
-							if (id === undefined) continue;
-							if (usedIds.has(id)) continue;
-							usedIds.add(id);
-							chunk.id = id;
-							chunk.ids = [id];
+		});
+	}
+
+	_readContextTimestamp(path, callback) {
+		this._readContext(
+			{
+				path,
+				fromImmutablePath: () => null,
+				fromManagedItem: info => ({
+					safeTime: 0,
+					timestampHash: info
+				}),
+				fromSymlink: (file, target, callback) => {
+					callback(null, {
+						timestampHash: target,
+						symlinks: new Set([target])
+					});
+				},
+				fromFile: (file, stat, callback) => {
+					// Prefer the cached value over our new stat to report consistent results
+					const cache = this._fileTimestamps.get(file);
+					if (cache !== undefined)
+						return callback(null, cache === "ignore" ? null : cache);
+
+					const mtime = +stat.mtime;
+
+					if (mtime) applyMtime(mtime);
+
+					const ts = {
+						safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
+						timestamp: mtime
+					};
+
+					this._fileTimestamps.set(file, ts);
+					this._cachedDeprecatedFileTimestamps = undefined;
+					callback(null, ts);
+				},
+				fromDirectory: (directory, stat, callback) => {
+					this.contextTimestampQueue.increaseParallelism();
+					this._getUnresolvedContextTimestamp(directory, (err, tsEntry) => {
+						this.contextTimestampQueue.decreaseParallelism();
+						callback(err, tsEntry);
+					});
+				},
+				reduce: (files, tsEntries) => {
+					let symlinks = undefined;
+
+					const hash = createHash(this._hashFunction);
+
+					for (const file of files) hash.update(file);
+					let safeTime = 0;
+					for (const entry of tsEntries) {
+						if (!entry) {
+							hash.update("n");
+							continue;
 						}
-					}
-					if (records.chunks.bySource) {
-						for (const chunk of chunks) {
-							if (chunk.id !== null) continue;
-							const sources = getChunkSources(chunk);
-							for (const source of sources) {
-								const id = records.chunks.bySource[source];
-								if (id === undefined) continue;
-								if (usedIds.has(id)) continue;
-								usedIds.add(id);
-								chunk.id = id;
-								chunk.ids = [id];
-								break;
-							}
+						if (entry.timestamp) {
+							hash.update("f");
+							hash.update(`${entry.timestamp}`);
+						} else if (entry.timestampHash) {
+							hash.update("d");
+							hash.update(`${entry.timestampHash}`);
+						}
+						if (entry.symlinks !== undefined) {
+							if (symlinks === undefined) symlinks = new Set();
+							addAll(entry.symlinks, symlinks);
+						}
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
 						}
 					}
-					if (Array.isArray(records.chunks.usedIds)) {
-						compilation.usedChunkIds = new Set(records.chunks.usedIds);
+
+					const digest = /** @type {string} */ (hash.digest("hex"));
+
+					const result = {
+						safeTime,
+						timestampHash: digest
+					};
+					if (symlinks) result.symlinks = symlinks;
+					return result;
+				}
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				this._contextTimestamps.set(path, result);
+				this._cachedDeprecatedContextTimestamps = undefined;
+
+				callback(null, result);
+			}
+		);
+	}
+
+	/**
+	 * @param {ContextFileSystemInfoEntry} entry entry
+	 * @param {function((Error | null)=, ResolvedContextFileSystemInfoEntry=): void} callback callback
+	 * @returns {void}
+	 */
+	_resolveContextTimestamp(entry, callback) {
+		const hashes = [];
+		let safeTime = 0;
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextTimestamp(target, (err, entry) => {
+					if (err) return callback(err);
+					if (entry && entry !== "ignore") {
+						hashes.push(entry.timestampHash);
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
+						}
+						if (entry.symlinks !== undefined) {
+							for (const target of entry.symlinks) push(target);
+						}
 					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash(this._hashFunction);
+				hash.update(entry.timestampHash);
+				if (entry.safeTime) {
+					safeTime = Math.max(safeTime, entry.safeTime);
 				}
-			);
-		});
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = {
+						safeTime,
+						timestampHash: /** @type {string} */ (hash.digest("hex"))
+					})
+				);
+			}
+		);
 	}
-}
-module.exports = RecordIdsPlugin;
-
-
-/***/ }),
-
-/***/ 73406:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	_readContextHash(path, callback) {
+		this._readContext(
+			{
+				path,
+				fromImmutablePath: () => "",
+				fromManagedItem: info => info || "",
+				fromSymlink: (file, target, callback) => {
+					callback(null, {
+						hash: target,
+						symlinks: new Set([target])
+					});
+				},
+				fromFile: (file, stat, callback) =>
+					this.getFileHash(file, (err, hash) => {
+						callback(err, hash || "");
+					}),
+				fromDirectory: (directory, stat, callback) => {
+					this.contextHashQueue.increaseParallelism();
+					this._getUnresolvedContextHash(directory, (err, hash) => {
+						this.contextHashQueue.decreaseParallelism();
+						callback(err, hash || "");
+					});
+				},
+				/**
+				 * @param {string[]} files files
+				 * @param {(string | ContextHash)[]} fileHashes hashes
+				 * @returns {ContextHash} reduced hash
+				 */
+				reduce: (files, fileHashes) => {
+					let symlinks = undefined;
+					const hash = createHash(this._hashFunction);
 
-const { contextify } = __webpack_require__(82186);
+					for (const file of files) hash.update(file);
+					for (const entry of fileHashes) {
+						if (typeof entry === "string") {
+							hash.update(entry);
+						} else {
+							hash.update(entry.hash);
+							if (entry.symlinks) {
+								if (symlinks === undefined) symlinks = new Set();
+								addAll(entry.symlinks, symlinks);
+							}
+						}
+					}
 
-class RequestShortener {
-	/**
-	 * @param {string} dir the directory
-	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
-	 */
-	constructor(dir, associatedObjectForCache) {
-		this.contextify = contextify.bindContextCache(
-			dir,
-			associatedObjectForCache
+					const result = {
+						hash: /** @type {string} */ (hash.digest("hex"))
+					};
+					if (symlinks) result.symlinks = symlinks;
+					return result;
+				}
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				this._contextHashes.set(path, result);
+				return callback(null, result);
+			}
 		);
 	}
 
 	/**
-	 * @param {string | undefined | null} request the request to shorten
-	 * @returns {string | undefined | null} the shortened request
+	 * @param {ContextHash} entry context hash
+	 * @param {function((Error | null)=, string=): void} callback callback
+	 * @returns {void}
 	 */
-	shorten(request) {
-		if (!request) {
-			return request;
-		}
-		return this.contextify(request);
+	_resolveContextHash(entry, callback) {
+		const hashes = [];
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextHash(target, (err, hash) => {
+					if (err) return callback(err);
+					if (hash) {
+						hashes.push(hash.hash);
+						if (hash.symlinks !== undefined) {
+							for (const target of hash.symlinks) push(target);
+						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash(this._hashFunction);
+				hash.update(entry.hash);
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = /** @type {string} */ (hash.digest("hex")))
+				);
+			}
+		);
 	}
-}
-
-module.exports = RequestShortener;
-
-
-/***/ }),
-
-/***/ 88846:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+	_readContextTimestampAndHash(path, callback) {
+		const finalize = (timestamp, hash) => {
+			const result =
+				timestamp === "ignore"
+					? hash
+					: {
+							...timestamp,
+							...hash
+					  };
+			this._contextTshs.set(path, result);
+			callback(null, result);
+		};
+		const cachedHash = this._contextHashes.get(path);
+		const cachedTimestamp = this._contextTimestamps.get(path);
+		if (cachedHash !== undefined) {
+			if (cachedTimestamp !== undefined) {
+				finalize(cachedTimestamp, cachedHash);
+			} else {
+				this.contextTimestampQueue.add(path, (err, entry) => {
+					if (err) return callback(err);
+					finalize(entry, cachedHash);
+				});
+			}
+		} else {
+			if (cachedTimestamp !== undefined) {
+				this.contextHashQueue.add(path, (err, entry) => {
+					if (err) return callback(err);
+					finalize(cachedTimestamp, entry);
+				});
+			} else {
+				this._readContext(
+					{
+						path,
+						fromImmutablePath: () => null,
+						fromManagedItem: info => ({
+							safeTime: 0,
+							timestampHash: info,
+							hash: info || ""
+						}),
+						fromSymlink: (fle, target, callback) => {
+							callback(null, {
+								timestampHash: target,
+								hash: target,
+								symlinks: new Set([target])
+							});
+						},
+						fromFile: (file, stat, callback) => {
+							this._getFileTimestampAndHash(file, callback);
+						},
+						fromDirectory: (directory, stat, callback) => {
+							this.contextTshQueue.increaseParallelism();
+							this.contextTshQueue.add(directory, (err, result) => {
+								this.contextTshQueue.decreaseParallelism();
+								callback(err, result);
+							});
+						},
+						/**
+						 * @param {string[]} files files
+						 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
+						 * @returns {ContextTimestampAndHash} tsh
+						 */
+						reduce: (files, results) => {
+							let symlinks = undefined;
 
+							const tsHash = createHash(this._hashFunction);
+							const hash = createHash(this._hashFunction);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const ConstDependency = __webpack_require__(76911);
-const {
-	toConstantDependency
-} = __webpack_require__(93998);
+							for (const file of files) {
+								tsHash.update(file);
+								hash.update(file);
+							}
+							let safeTime = 0;
+							for (const entry of results) {
+								if (!entry) {
+									tsHash.update("n");
+									continue;
+								}
+								if (typeof entry === "string") {
+									tsHash.update("n");
+									hash.update(entry);
+									continue;
+								}
+								if (entry.timestamp) {
+									tsHash.update("f");
+									tsHash.update(`${entry.timestamp}`);
+								} else if (entry.timestampHash) {
+									tsHash.update("d");
+									tsHash.update(`${entry.timestampHash}`);
+								}
+								if (entry.symlinks !== undefined) {
+									if (symlinks === undefined) symlinks = new Set();
+									addAll(entry.symlinks, symlinks);
+								}
+								if (entry.safeTime) {
+									safeTime = Math.max(safeTime, entry.safeTime);
+								}
+								hash.update(entry.hash);
+							}
 
-/** @typedef {import("./Compiler")} Compiler */
+							const result = {
+								safeTime,
+								timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+								hash: /** @type {string} */ (hash.digest("hex"))
+							};
+							if (symlinks) result.symlinks = symlinks;
+							return result;
+						}
+					},
+					(err, result) => {
+						if (err) return callback(err);
+						this._contextTshs.set(path, result);
+						return callback(null, result);
+					}
+				);
+			}
+		}
+	}
 
-module.exports = class RequireJsStuffPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ContextTimestampAndHash} entry entry
+	 * @param {function((Error | null)=, ResolvedContextTimestampAndHash=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireJsStuffPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
-				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.requireJs === undefined ||
-						!parserOptions.requireJs
-					) {
-						return;
+	_resolveContextTsh(entry, callback) {
+		const hashes = [];
+		const tsHashes = [];
+		let safeTime = 0;
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextTsh(target, (err, entry) => {
+					if (err) return callback(err);
+					if (entry) {
+						hashes.push(entry.hash);
+						if (entry.timestampHash) tsHashes.push(entry.timestampHash);
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
+						}
+						if (entry.symlinks !== undefined) {
+							for (const target of entry.symlinks) push(target);
+						}
 					}
-
-					parser.hooks.call
-						.for("require.config")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(parser, "undefined")
-						);
-					parser.hooks.call
-						.for("requirejs.config")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(parser, "undefined")
-						);
-
-					parser.hooks.expression
-						.for("require.version")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(parser, JSON.stringify("0.0.0"))
-						);
-					parser.hooks.expression
-						.for("requirejs.onError")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(
-								parser,
-								RuntimeGlobals.uncaughtErrorHandler,
-								[RuntimeGlobals.uncaughtErrorHandler]
-							)
-						);
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireJsStuffPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireJsStuffPlugin", handler);
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash(this._hashFunction);
+				const tsHash = createHash(this._hashFunction);
+				hash.update(entry.hash);
+				if (entry.timestampHash) tsHash.update(entry.timestampHash);
+				if (entry.safeTime) {
+					safeTime = Math.max(safeTime, entry.safeTime);
+				}
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				tsHashes.sort();
+				for (const h of tsHashes) {
+					tsHash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = {
+						safeTime,
+						timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+						hash: /** @type {string} */ (hash.digest("hex"))
+					})
+				);
 			}
 		);
 	}
-};
-
-
-/***/ }),
-
-/***/ 30217:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Factory = (__webpack_require__(9256).ResolverFactory);
-const { HookMap, SyncHook, SyncWaterfallHook } = __webpack_require__(6967);
-const {
-	cachedCleverMerge,
-	removeOperations,
-	resolveByProperty
-} = __webpack_require__(60839);
-
-/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */
-/** @typedef {import("enhanced-resolve").Resolver} Resolver */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} WebpackResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
-
-/** @typedef {WebpackResolveOptions & {dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
-/**
- * @typedef {Object} WithOptions
- * @property {function(Partial<ResolveOptionsWithDependencyType>): ResolverWithOptions} withOptions create a resolver with additional/different options
- */
-
-/** @typedef {Resolver & WithOptions} ResolverWithOptions */
-
-// need to be hoisted on module level for caching identity
-const EMPTY_RESOLVE_OPTIONS = {};
-
-/**
- * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType enhanced options
- * @returns {ResolveOptions} merged options
- */
-const convertToResolveOptions = resolveOptionsWithDepType => {
-	const { dependencyType, plugins, ...remaining } = resolveOptionsWithDepType;
-
-	// check type compat
-	/** @type {Partial<ResolveOptions>} */
-	const partialOptions = {
-		...remaining,
-		plugins:
-			plugins &&
-			/** @type {ResolvePluginInstance[]} */ (
-				plugins.filter(item => item !== "...")
-			)
-	};
 
-	if (!partialOptions.fileSystem) {
-		throw new Error(
-			"fileSystem is missing in resolveOptions, but it's required for enhanced-resolve"
-		);
+	_getManagedItemDirectoryInfo(path, callback) {
+		this.fs.readdir(path, (err, elements) => {
+			if (err) {
+				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
+					return callback(null, EMPTY_SET);
+				}
+				return callback(err);
+			}
+			const set = new Set(
+				/** @type {string[]} */ (elements).map(element =>
+					join(this.fs, path, element)
+				)
+			);
+			callback(null, set);
+		});
 	}
-	// These weird types validate that we checked all non-optional properties
-	const options =
-		/** @type {Partial<ResolveOptions> & Pick<ResolveOptions, "fileSystem">} */ (
-			partialOptions
-		);
-
-	return removeOperations(
-		resolveByProperty(options, "byDependency", dependencyType)
-	);
-};
 
-/**
- * @typedef {Object} ResolverCache
- * @property {WeakMap<Object, ResolverWithOptions>} direct
- * @property {Map<string, ResolverWithOptions>} stringified
- */
+	_getManagedItemInfo(path, callback) {
+		const dir = dirname(this.fs, path);
+		this.managedItemDirectoryQueue.add(dir, (err, elements) => {
+			if (err) {
+				return callback(err);
+			}
+			if (!elements.has(path)) {
+				// file or directory doesn't exist
+				this._managedItems.set(path, "*missing");
+				return callback(null, "*missing");
+			}
+			// something exists
+			// it may be a file or directory
+			if (
+				path.endsWith("node_modules") &&
+				(path.endsWith("/node_modules") || path.endsWith("\\node_modules"))
+			) {
+				// we are only interested in existence of this special directory
+				this._managedItems.set(path, "*node_modules");
+				return callback(null, "*node_modules");
+			}
 
-module.exports = class ResolverFactory {
-	constructor() {
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>} */
-			resolveOptions: new HookMap(
-				() => new SyncWaterfallHook(["resolveOptions"])
-			),
-			/** @type {HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>} */
-			resolver: new HookMap(
-				() => new SyncHook(["resolver", "resolveOptions", "userResolveOptions"])
-			)
+			// we assume it's a directory, as files shouldn't occur in managed paths
+			const packageJsonPath = join(this.fs, path, "package.json");
+			this.fs.readFile(packageJsonPath, (err, content) => {
+				if (err) {
+					if (err.code === "ENOENT" || err.code === "ENOTDIR") {
+						// no package.json or path is not a directory
+						this.fs.readdir(path, (err, elements) => {
+							if (
+								!err &&
+								elements.length === 1 &&
+								elements[0] === "node_modules"
+							) {
+								// This is only a grouping folder e. g. used by yarn
+								// we are only interested in existence of this special directory
+								this._managedItems.set(path, "*nested");
+								return callback(null, "*nested");
+							}
+							this.logger.warn(
+								`Managed item ${path} isn't a directory or doesn't contain a package.json (see snapshot.managedPaths option)`
+							);
+							return callback();
+						});
+						return;
+					}
+					return callback(err);
+				}
+				let data;
+				try {
+					data = JSON.parse(content.toString("utf-8"));
+				} catch (e) {
+					return callback(e);
+				}
+				if (!data.name) {
+					this.logger.warn(
+						`${packageJsonPath} doesn't contain a "name" property (see snapshot.managedPaths option)`
+					);
+					return callback();
+				}
+				const info = `${data.name || ""}@${data.version || ""}`;
+				this._managedItems.set(path, info);
+				callback(null, info);
+			});
 		});
-		/** @type {Map<string, ResolverCache>} */
-		this.cache = new Map();
 	}
 
-	/**
-	 * @param {string} type type of resolver
-	 * @param {ResolveOptionsWithDependencyType=} resolveOptions options
-	 * @returns {ResolverWithOptions} the resolver
-	 */
-	get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
-		let typedCaches = this.cache.get(type);
-		if (!typedCaches) {
-			typedCaches = {
-				direct: new WeakMap(),
-				stringified: new Map()
-			};
-			this.cache.set(type, typedCaches);
-		}
-		const cachedResolver = typedCaches.direct.get(resolveOptions);
-		if (cachedResolver) {
-			return cachedResolver;
-		}
-		const ident = JSON.stringify(resolveOptions);
-		const resolver = typedCaches.stringified.get(ident);
-		if (resolver) {
-			typedCaches.direct.set(resolveOptions, resolver);
-			return resolver;
+	getDeprecatedFileTimestamps() {
+		if (this._cachedDeprecatedFileTimestamps !== undefined)
+			return this._cachedDeprecatedFileTimestamps;
+		const map = new Map();
+		for (const [path, info] of this._fileTimestamps) {
+			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
 		}
-		const newResolver = this._create(type, resolveOptions);
-		typedCaches.direct.set(resolveOptions, newResolver);
-		typedCaches.stringified.set(ident, newResolver);
-		return newResolver;
+		return (this._cachedDeprecatedFileTimestamps = map);
 	}
 
-	/**
-	 * @param {string} type type of resolver
-	 * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options
-	 * @returns {ResolverWithOptions} the resolver
-	 */
-	_create(type, resolveOptionsWithDepType) {
-		/** @type {ResolveOptionsWithDependencyType} */
-		const originalResolveOptions = { ...resolveOptionsWithDepType };
-
-		const resolveOptions = convertToResolveOptions(
-			this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType)
-		);
-		const resolver = /** @type {ResolverWithOptions} */ (
-			Factory.createResolver(resolveOptions)
-		);
-		if (!resolver) {
-			throw new Error("No resolver created");
+	getDeprecatedContextTimestamps() {
+		if (this._cachedDeprecatedContextTimestamps !== undefined)
+			return this._cachedDeprecatedContextTimestamps;
+		const map = new Map();
+		for (const [path, info] of this._contextTimestamps) {
+			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
 		}
-		/** @type {WeakMap<Partial<ResolveOptionsWithDependencyType>, ResolverWithOptions>} */
-		const childCache = new WeakMap();
-		resolver.withOptions = options => {
-			const cacheEntry = childCache.get(options);
-			if (cacheEntry !== undefined) return cacheEntry;
-			const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
-			const resolver = this.get(type, mergedOptions);
-			childCache.set(options, resolver);
-			return resolver;
-		};
-		this.hooks.resolver
-			.for(type)
-			.call(resolver, resolveOptions, originalResolveOptions);
-		return resolver;
+		return (this._cachedDeprecatedContextTimestamps = map);
 	}
-};
+}
+
+module.exports = FileSystemInfo;
+module.exports.Snapshot = Snapshot;
 
 
 /***/ }),
 
-/***/ 16475:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 58727:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -52621,606 +47745,484 @@ module.exports = class ResolverFactory {
 
 
 
-/**
- * the internal require function
- */
-exports.require = "__webpack_require__";
-
-/**
- * access to properties of the internal require function/object
- */
-exports.requireScope = "__webpack_require__.*";
-
-/**
- * the internal exports object
- */
-exports.exports = "__webpack_exports__";
-
-/**
- * top-level this need to be the exports object
- */
-exports.thisAsExports = "top-level-this-exports";
-
-/**
- * runtime need to return the exports of the last entry module
- */
-exports.returnExportsFromRuntime = "return-exports-from-runtime";
-
-/**
- * the internal module object
- */
-exports.module = "module";
-
-/**
- * the internal module object
- */
-exports.moduleId = "module.id";
-
-/**
- * the internal module object
- */
-exports.moduleLoaded = "module.loaded";
-
-/**
- * the bundle public path
- */
-exports.publicPath = "__webpack_require__.p";
-
-/**
- * the module id of the entry point
- */
-exports.entryModuleId = "__webpack_require__.s";
-
-/**
- * the module cache
- */
-exports.moduleCache = "__webpack_require__.c";
-
-/**
- * the module functions
- */
-exports.moduleFactories = "__webpack_require__.m";
-
-/**
- * the module functions, with only write access
- */
-exports.moduleFactoriesAddOnly = "__webpack_require__.m (add only)";
-
-/**
- * the chunk ensure function
- */
-exports.ensureChunk = "__webpack_require__.e";
-
-/**
- * an object with handlers to ensure a chunk
- */
-exports.ensureChunkHandlers = "__webpack_require__.f";
-
-/**
- * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
- */
-exports.ensureChunkIncludeEntries = "__webpack_require__.f (include entries)";
-
-/**
- * the chunk prefetch function
- */
-exports.prefetchChunk = "__webpack_require__.E";
-
-/**
- * an object with handlers to prefetch a chunk
- */
-exports.prefetchChunkHandlers = "__webpack_require__.F";
-
-/**
- * the chunk preload function
- */
-exports.preloadChunk = "__webpack_require__.G";
-
-/**
- * an object with handlers to preload a chunk
- */
-exports.preloadChunkHandlers = "__webpack_require__.H";
-
-/**
- * the exported property define getters function
- */
-exports.definePropertyGetters = "__webpack_require__.d";
-
-/**
- * define compatibility on export
- */
-exports.makeNamespaceObject = "__webpack_require__.r";
-
-/**
- * create a fake namespace object
- */
-exports.createFakeNamespaceObject = "__webpack_require__.t";
-
-/**
- * compatibility get default export
- */
-exports.compatGetDefaultExport = "__webpack_require__.n";
-
-/**
- * harmony module decorator
- */
-exports.harmonyModuleDecorator = "__webpack_require__.hmd";
-
-/**
- * node.js module decorator
- */
-exports.nodeModuleDecorator = "__webpack_require__.nmd";
-
-/**
- * the webpack hash
- */
-exports.getFullHash = "__webpack_require__.h";
-
-/**
- * an object containing all installed WebAssembly.Instance export objects keyed by module id
- */
-exports.wasmInstances = "__webpack_require__.w";
-
-/**
- * instantiate a wasm instance from module exports object, id, hash and importsObject
- */
-exports.instantiateWasm = "__webpack_require__.v";
-
-/**
- * the uncaught error handler for the webpack runtime
- */
-exports.uncaughtErrorHandler = "__webpack_require__.oe";
-
-/**
- * the script nonce
- */
-exports.scriptNonce = "__webpack_require__.nc";
-
-/**
- * function to load a script tag.
- * Arguments: (url: string, done: (event) => void), key?: string | number, chunkId?: string | number) => void
- * done function is called when loading has finished or timeout occurred.
- * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
- */
-exports.loadScript = "__webpack_require__.l";
-
-/**
- * function to promote a string to a TrustedScript using webpack's Trusted
- * Types policy
- * Arguments: (script: string) => TrustedScript
- */
-exports.createScript = "__webpack_require__.ts";
-
-/**
- * function to promote a string to a TrustedScriptURL using webpack's Trusted
- * Types policy
- * Arguments: (url: string) => TrustedScriptURL
- */
-exports.createScriptUrl = "__webpack_require__.tu";
-
-/**
- * function to return webpack's Trusted Types policy
- * Arguments: () => TrustedTypePolicy
- */
-exports.getTrustedTypesPolicy = "__webpack_require__.tt";
-
-/**
- * the chunk name of the chunk with the runtime
- */
-exports.chunkName = "__webpack_require__.cn";
-
-/**
- * the runtime id of the current runtime
- */
-exports.runtimeId = "__webpack_require__.j";
-
-/**
- * the filename of the script part of the chunk
- */
-exports.getChunkScriptFilename = "__webpack_require__.u";
-
-/**
- * the filename of the css part of the chunk
- */
-exports.getChunkCssFilename = "__webpack_require__.k";
-
-/**
- * a flag when a module/chunk/tree has css modules
- */
-exports.hasCssModules = "has css modules";
-
-/**
- * the filename of the script part of the hot update chunk
- */
-exports.getChunkUpdateScriptFilename = "__webpack_require__.hu";
-
-/**
- * the filename of the css part of the hot update chunk
- */
-exports.getChunkUpdateCssFilename = "__webpack_require__.hk";
-
-/**
- * startup signal from runtime
- * This will be called when the runtime chunk has been loaded.
- */
-exports.startup = "__webpack_require__.x";
-
-/**
- * @deprecated
- * creating a default startup function with the entry modules
- */
-exports.startupNoDefault = "__webpack_require__.x (no default handler)";
-
-/**
- * startup signal from runtime but only used to add logic after the startup
- */
-exports.startupOnlyAfter = "__webpack_require__.x (only after)";
-
-/**
- * startup signal from runtime but only used to add sync logic before the startup
- */
-exports.startupOnlyBefore = "__webpack_require__.x (only before)";
-
-/**
- * global callback functions for installing chunks
- */
-exports.chunkCallback = "webpackChunk";
-
-/**
- * method to startup an entrypoint with needed chunks.
- * Signature: (moduleId: Id, chunkIds: Id[]) => any.
- * Returns the exports of the module or a Promise
- */
-exports.startupEntrypoint = "__webpack_require__.X";
+const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
 
-/**
- * register deferred code, which will run when certain
- * chunks are loaded.
- * Signature: (chunkIds: Id[], fn: () => any, priority: int >= 0 = 0) => any
- * Returned value will be returned directly when all chunks are already loaded
- * When (priority & 1) it will wait for all other handlers with lower priority to
- * be executed before itself is executed
- */
-exports.onChunksLoaded = "__webpack_require__.O";
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * method to install a chunk that was loaded somehow
- * Signature: ({ id, ids, modules, runtime }) => void
- */
-exports.externalInstallChunk = "__webpack_require__.C";
+class FlagAllModulesAsUsedPlugin {
+	constructor(explanation) {
+		this.explanation = explanation;
+	}
 
-/**
- * interceptor for module executions
- */
-exports.interceptModuleExecution = "__webpack_require__.i";
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FlagAllModulesAsUsedPlugin",
+			compilation => {
+				const moduleGraph = compilation.moduleGraph;
+				compilation.hooks.optimizeDependencies.tap(
+					"FlagAllModulesAsUsedPlugin",
+					modules => {
+						/** @type {RuntimeSpec} */
+						let runtime = undefined;
+						for (const [name, { options }] of compilation.entries) {
+							runtime = mergeRuntimeOwned(
+								runtime,
+								getEntryRuntime(compilation, name, options)
+							);
+						}
+						for (const module of modules) {
+							const exportsInfo = moduleGraph.getExportsInfo(module);
+							exportsInfo.setUsedInUnknownWay(runtime);
+							moduleGraph.addExtraReason(module, this.explanation);
+							if (module.factoryMeta === undefined) {
+								module.factoryMeta = {};
+							}
+							module.factoryMeta.sideEffectFree = false;
+						}
+					}
+				);
+			}
+		);
+	}
+}
 
-/**
- * the global object
- */
-exports.global = "__webpack_require__.g";
+module.exports = FlagAllModulesAsUsedPlugin;
 
-/**
- * an object with all share scopes
- */
-exports.shareScopeMap = "__webpack_require__.S";
 
-/**
- * The sharing init sequence function (only runs once per share scope).
- * Has one argument, the name of the share scope.
- * Creates a share scope if not existing
- */
-exports.initializeSharing = "__webpack_require__.I";
+/***/ }),
 
-/**
- * The current scope when getting a module from a remote
- */
-exports.currentRemoteGetScope = "__webpack_require__.R";
+/***/ 84506:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * the filename of the HMR manifest
- */
-exports.getUpdateManifestFilename = "__webpack_require__.hmrF";
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * function downloading the update manifest
- */
-exports.hmrDownloadManifest = "__webpack_require__.hmrM";
 
-/**
- * array with handler functions to download chunk updates
- */
-exports.hmrDownloadUpdateHandlers = "__webpack_require__.hmrC";
 
-/**
- * object with all hmr module data for all modules
- */
-exports.hmrModuleData = "__webpack_require__.hmrD";
+const asyncLib = __webpack_require__(78175);
+const Queue = __webpack_require__(65930);
 
-/**
- * array with handler functions when a module should be invalidated
- */
-exports.hmrInvalidateModuleHandlers = "__webpack_require__.hmrI";
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").ExportSpec} ExportSpec */
+/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./Module")} Module */
 
-/**
- * the prefix for storing state of runtime modules when hmr is enabled
- */
-exports.hmrRuntimeStatePrefix = "__webpack_require__.hmrS";
+class FlagDependencyExportsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FlagDependencyExportsPlugin",
+			compilation => {
+				const moduleGraph = compilation.moduleGraph;
+				const cache = compilation.getCache("FlagDependencyExportsPlugin");
+				compilation.hooks.finishModules.tapAsync(
+					"FlagDependencyExportsPlugin",
+					(modules, callback) => {
+						const logger = compilation.getLogger(
+							"webpack.FlagDependencyExportsPlugin"
+						);
+						let statRestoredFromMemCache = 0;
+						let statRestoredFromCache = 0;
+						let statNoExports = 0;
+						let statFlaggedUncached = 0;
+						let statNotCached = 0;
+						let statQueueItemsProcessed = 0;
 
-/**
- * the AMD define function
- */
-exports.amdDefine = "__webpack_require__.amdD";
+						const { moduleMemCaches } = compilation;
 
-/**
- * the AMD options
- */
-exports.amdOptions = "__webpack_require__.amdO";
+						/** @type {Queue<Module>} */
+						const queue = new Queue();
 
-/**
- * the System polyfill object
- */
-exports.system = "__webpack_require__.System";
+						// Step 1: Try to restore cached provided export info from cache
+						logger.time("restore cached provided exports");
+						asyncLib.each(
+							modules,
+							(module, callback) => {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								if (!module.buildMeta || !module.buildMeta.exportsType) {
+									if (exportsInfo.otherExportsInfo.provided !== null) {
+										// It's a module without declared exports
+										statNoExports++;
+										exportsInfo.setHasProvideInfo();
+										exportsInfo.setUnknownExportsProvided();
+										return callback();
+									}
+								}
+								if (typeof module.buildInfo.hash !== "string") {
+									statFlaggedUncached++;
+									// Enqueue uncacheable module for determining the exports
+									queue.enqueue(module);
+									exportsInfo.setHasProvideInfo();
+									return callback();
+								}
+								const memCache = moduleMemCaches && moduleMemCaches.get(module);
+								const memCacheValue = memCache && memCache.get(this);
+								if (memCacheValue !== undefined) {
+									statRestoredFromMemCache++;
+									exportsInfo.restoreProvided(memCacheValue);
+									return callback();
+								}
+								cache.get(
+									module.identifier(),
+									module.buildInfo.hash,
+									(err, result) => {
+										if (err) return callback(err);
 
-/**
- * the shorthand for Object.prototype.hasOwnProperty
- * using of it decreases the compiled bundle size
- */
-exports.hasOwnProperty = "__webpack_require__.o";
+										if (result !== undefined) {
+											statRestoredFromCache++;
+											exportsInfo.restoreProvided(result);
+										} else {
+											statNotCached++;
+											// Without cached info enqueue module for determining the exports
+											queue.enqueue(module);
+											exportsInfo.setHasProvideInfo();
+										}
+										callback();
+									}
+								);
+							},
+							err => {
+								logger.timeEnd("restore cached provided exports");
+								if (err) return callback(err);
 
-/**
- * the System.register context object
- */
-exports.systemContext = "__webpack_require__.y";
+								/** @type {Set<Module>} */
+								const modulesToStore = new Set();
 
-/**
- * the baseURI of current document
- */
-exports.baseURI = "__webpack_require__.b";
+								/** @type {Map<Module, Set<Module>>} */
+								const dependencies = new Map();
 
-/**
- * a RelativeURL class when relative URLs are used
- */
-exports.relativeUrl = "__webpack_require__.U";
+								/** @type {Module} */
+								let module;
 
-/**
- * Creates an async module. The body function must be a async function.
- * "module.exports" will be decorated with an AsyncModulePromise.
- * The body function will be called.
- * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
- * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
- * Signature: function(
- * module: Module,
- * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise<any[]> & () => void,
- * hasAwaitAfterDependencies?: boolean
- * ) => void
- */
-exports.asyncModule = "__webpack_require__.a";
+								/** @type {ExportsInfo} */
+								let exportsInfo;
 
+								/** @type {Map<Dependency, ExportsSpec>} */
+								const exportsSpecsFromDependencies = new Map();
 
-/***/ }),
+								let cacheable = true;
+								let changed = false;
 
-/***/ 16963:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+								/**
+								 * @param {DependenciesBlock} depBlock the dependencies block
+								 * @returns {void}
+								 */
+								const processDependenciesBlock = depBlock => {
+									for (const dep of depBlock.dependencies) {
+										processDependency(dep);
+									}
+									for (const block of depBlock.blocks) {
+										processDependenciesBlock(block);
+									}
+								};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+								/**
+								 * @param {Dependency} dep the dependency
+								 * @returns {void}
+								 */
+								const processDependency = dep => {
+									const exportDesc = dep.getExports(moduleGraph);
+									if (!exportDesc) return;
+									exportsSpecsFromDependencies.set(dep, exportDesc);
+								};
 
+								/**
+								 * @param {Dependency} dep dependency
+								 * @param {ExportsSpec} exportDesc info
+								 * @returns {void}
+								 */
+								const processExportsSpec = (dep, exportDesc) => {
+									const exports = exportDesc.exports;
+									const globalCanMangle = exportDesc.canMangle;
+									const globalFrom = exportDesc.from;
+									const globalPriority = exportDesc.priority;
+									const globalTerminalBinding =
+										exportDesc.terminalBinding || false;
+									const exportDeps = exportDesc.dependencies;
+									if (exportDesc.hideExports) {
+										for (const name of exportDesc.hideExports) {
+											const exportInfo = exportsInfo.getExportInfo(name);
+											exportInfo.unsetTarget(dep);
+										}
+									}
+									if (exports === true) {
+										// unknown exports
+										if (
+											exportsInfo.setUnknownExportsProvided(
+												globalCanMangle,
+												exportDesc.excludeExports,
+												globalFrom && dep,
+												globalFrom,
+												globalPriority
+											)
+										) {
+											changed = true;
+										}
+									} else if (Array.isArray(exports)) {
+										/**
+										 * merge in new exports
+										 * @param {ExportsInfo} exportsInfo own exports info
+										 * @param {(ExportSpec | string)[]} exports list of exports
+										 */
+										const mergeExports = (exportsInfo, exports) => {
+											for (const exportNameOrSpec of exports) {
+												let name;
+												let canMangle = globalCanMangle;
+												let terminalBinding = globalTerminalBinding;
+												let exports = undefined;
+												let from = globalFrom;
+												let fromExport = undefined;
+												let priority = globalPriority;
+												let hidden = false;
+												if (typeof exportNameOrSpec === "string") {
+													name = exportNameOrSpec;
+												} else {
+													name = exportNameOrSpec.name;
+													if (exportNameOrSpec.canMangle !== undefined)
+														canMangle = exportNameOrSpec.canMangle;
+													if (exportNameOrSpec.export !== undefined)
+														fromExport = exportNameOrSpec.export;
+													if (exportNameOrSpec.exports !== undefined)
+														exports = exportNameOrSpec.exports;
+													if (exportNameOrSpec.from !== undefined)
+														from = exportNameOrSpec.from;
+													if (exportNameOrSpec.priority !== undefined)
+														priority = exportNameOrSpec.priority;
+													if (exportNameOrSpec.terminalBinding !== undefined)
+														terminalBinding = exportNameOrSpec.terminalBinding;
+													if (exportNameOrSpec.hidden !== undefined)
+														hidden = exportNameOrSpec.hidden;
+												}
+												const exportInfo = exportsInfo.getExportInfo(name);
 
+												if (
+													exportInfo.provided === false ||
+													exportInfo.provided === null
+												) {
+													exportInfo.provided = true;
+													changed = true;
+												}
 
-const { RawSource } = __webpack_require__(51255);
-const OriginalSource = (__webpack_require__(51255).OriginalSource);
-const Module = __webpack_require__(73208);
+												if (
+													exportInfo.canMangleProvide !== false &&
+													canMangle === false
+												) {
+													exportInfo.canMangleProvide = false;
+													changed = true;
+												}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+												if (terminalBinding && !exportInfo.terminalBinding) {
+													exportInfo.terminalBinding = true;
+													changed = true;
+												}
 
-const TYPES = new Set(["runtime"]);
+												if (exports) {
+													const nestedExportsInfo =
+														exportInfo.createNestedExportsInfo();
+													mergeExports(nestedExportsInfo, exports);
+												}
 
-class RuntimeModule extends Module {
-	/**
-	 * @param {string} name a readable name
-	 * @param {number=} stage an optional stage
-	 */
-	constructor(name, stage = 0) {
-		super("runtime");
-		this.name = name;
-		this.stage = stage;
-		this.buildMeta = {};
-		this.buildInfo = {};
-		/** @type {Compilation} */
-		this.compilation = undefined;
-		/** @type {Chunk} */
-		this.chunk = undefined;
-		/** @type {ChunkGraph} */
-		this.chunkGraph = undefined;
-		this.fullHash = false;
-		this.dependentHash = false;
-		/** @type {string} */
-		this._cachedGeneratedCode = undefined;
-	}
+												if (
+													from &&
+													(hidden
+														? exportInfo.unsetTarget(dep)
+														: exportInfo.setTarget(
+																dep,
+																from,
+																fromExport === undefined ? [name] : fromExport,
+																priority
+														  ))
+												) {
+													changed = true;
+												}
 
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	attach(compilation, chunk, chunkGraph = compilation.chunkGraph) {
-		this.compilation = compilation;
-		this.chunk = chunk;
-		this.chunkGraph = chunkGraph;
-	}
+												// Recalculate target exportsInfo
+												const target = exportInfo.getTarget(moduleGraph);
+												let targetExportsInfo = undefined;
+												if (target) {
+													const targetModuleExportsInfo =
+														moduleGraph.getExportsInfo(target.module);
+													targetExportsInfo =
+														targetModuleExportsInfo.getNestedExportsInfo(
+															target.export
+														);
+													// add dependency for this module
+													const set = dependencies.get(target.module);
+													if (set === undefined) {
+														dependencies.set(target.module, new Set([module]));
+													} else {
+														set.add(module);
+													}
+												}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `webpack/runtime/${this.name}`;
-	}
+												if (exportInfo.exportsInfoOwned) {
+													if (
+														exportInfo.exportsInfo.setRedirectNamedTo(
+															targetExportsInfo
+														)
+													) {
+														changed = true;
+													}
+												} else if (
+													exportInfo.exportsInfo !== targetExportsInfo
+												) {
+													exportInfo.exportsInfo = targetExportsInfo;
+													changed = true;
+												}
+											}
+										};
+										mergeExports(exportsInfo, exports);
+									}
+									// store dependencies
+									if (exportDeps) {
+										cacheable = false;
+										for (const exportDependency of exportDeps) {
+											// add dependency for this module
+											const set = dependencies.get(exportDependency);
+											if (set === undefined) {
+												dependencies.set(exportDependency, new Set([module]));
+											} else {
+												set.add(module);
+											}
+										}
+									}
+								};
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `webpack/runtime/${this.name}`;
-	}
+								const notifyDependencies = () => {
+									const deps = dependencies.get(module);
+									if (deps !== undefined) {
+										for (const dep of deps) {
+											queue.enqueue(dep);
+										}
+									}
+								};
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		return callback(null, false);
-	}
+								logger.time("figure out provided exports");
+								while (queue.length > 0) {
+									module = queue.dequeue();
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		// do nothing
-		// should not be called as runtime modules are added later to the compilation
-		callback();
-	}
+									statQueueItemsProcessed++;
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(this.name);
-		hash.update(`${this.stage}`);
-		try {
-			if (this.fullHash || this.dependentHash) {
-				// Do not use getGeneratedCode here, because i. e. compilation hash might be not
-				// ready at this point. We will cache it later instead.
-				hash.update(this.generate());
-			} else {
-				hash.update(this.getGeneratedCode());
-			}
-		} catch (err) {
-			hash.update(err.message);
-		}
-		super.updateHash(hash, context);
-	}
+									exportsInfo = moduleGraph.getExportsInfo(module);
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+									cacheable = true;
+									changed = false;
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		const sources = new Map();
-		const generatedCode = this.getGeneratedCode();
-		if (generatedCode) {
-			sources.set(
-				"runtime",
-				this.useSourceMap || this.useSimpleSourceMap
-					? new OriginalSource(generatedCode, this.identifier())
-					: new RawSource(generatedCode)
-			);
-		}
-		return {
-			sources,
-			runtimeRequirements: null
-		};
-	}
+									exportsSpecsFromDependencies.clear();
+									moduleGraph.freeze();
+									processDependenciesBlock(module);
+									moduleGraph.unfreeze();
+									for (const [
+										dep,
+										exportsSpec
+									] of exportsSpecsFromDependencies) {
+										processExportsSpec(dep, exportsSpec);
+									}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		try {
-			const source = this.getGeneratedCode();
-			return source ? source.length : 0;
-		} catch (e) {
-			return 0;
-		}
-	}
+									if (cacheable) {
+										modulesToStore.add(module);
+									}
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+									if (changed) {
+										notifyDependencies();
+									}
+								}
+								logger.timeEnd("figure out provided exports");
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	getGeneratedCode() {
-		if (this._cachedGeneratedCode) {
-			return this._cachedGeneratedCode;
-		}
-		return (this._cachedGeneratedCode = this.generate());
-	}
+								logger.log(
+									`${Math.round(
+										(100 * (statFlaggedUncached + statNotCached)) /
+											(statRestoredFromMemCache +
+												statRestoredFromCache +
+												statNotCached +
+												statFlaggedUncached +
+												statNoExports)
+									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${
+										statQueueItemsProcessed -
+										statNotCached -
+										statFlaggedUncached
+									} additional calculations due to dependencies)`
+								);
 
-	/**
-	 * @returns {boolean} true, if the runtime module should get it's own scope
-	 */
-	shouldIsolate() {
-		return true;
+								logger.time("store provided exports into cache");
+								asyncLib.each(
+									modulesToStore,
+									(module, callback) => {
+										if (typeof module.buildInfo.hash !== "string") {
+											// not cacheable
+											return callback();
+										}
+										const cachedData = moduleGraph
+											.getExportsInfo(module)
+											.getRestoreProvidedData();
+										const memCache =
+											moduleMemCaches && moduleMemCaches.get(module);
+										if (memCache) {
+											memCache.set(this, cachedData);
+										}
+										cache.store(
+											module.identifier(),
+											module.buildInfo.hash,
+											cachedData,
+											callback
+										);
+									},
+									err => {
+										logger.timeEnd("store provided exports into cache");
+										callback(err);
+									}
+								);
+							}
+						);
+					}
+				);
+
+				/** @type {WeakMap<Module, any>} */
+				const providedExportsCache = new WeakMap();
+				compilation.hooks.rebuildModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						providedExportsCache.set(
+							module,
+							moduleGraph.getExportsInfo(module).getRestoreProvidedData()
+						);
+					}
+				);
+				compilation.hooks.finishRebuildingModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						moduleGraph
+							.getExportsInfo(module)
+							.restoreProvided(providedExportsCache.get(module));
+					}
+				);
+			}
+		);
 	}
 }
 
-/**
- * Runtime modules without any dependencies to other runtime modules
- */
-RuntimeModule.STAGE_NORMAL = 0;
-
-/**
- * Runtime modules with simple dependencies on other runtime modules
- */
-RuntimeModule.STAGE_BASIC = 5;
-
-/**
- * Runtime modules which attach to handlers of other runtime modules
- */
-RuntimeModule.STAGE_ATTACH = 10;
-
-/**
- * Runtime modules which trigger actions on bootstrap
- */
-RuntimeModule.STAGE_TRIGGER = 20;
-
-module.exports = RuntimeModule;
+module.exports = FlagDependencyExportsPlugin;
 
 
 /***/ }),
 
-/***/ 2307:
+/***/ 58812:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -53231,448 +48233,351 @@ module.exports = RuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const { getChunkFilenameTemplate } = __webpack_require__(47283);
-const RuntimeRequirementsDependency = __webpack_require__(24187);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const AsyncModuleRuntimeModule = __webpack_require__(63672);
-const AutoPublicPathRuntimeModule = __webpack_require__(66532);
-const CompatGetDefaultExportRuntimeModule = __webpack_require__(44793);
-const CompatRuntimeModule = __webpack_require__(88234);
-const CreateFakeNamespaceObjectRuntimeModule = __webpack_require__(94669);
-const CreateScriptRuntimeModule = __webpack_require__(2759);
-const CreateScriptUrlRuntimeModule = __webpack_require__(21213);
-const DefinePropertyGettersRuntimeModule = __webpack_require__(75481);
-const EnsureChunkRuntimeModule = __webpack_require__(71519);
-const GetChunkFilenameRuntimeModule = __webpack_require__(34277);
-const GetMainFilenameRuntimeModule = __webpack_require__(10029);
-const GetTrustedTypesPolicyRuntimeModule = __webpack_require__(38713);
-const GlobalRuntimeModule = __webpack_require__(23255);
-const HasOwnPropertyRuntimeModule = __webpack_require__(8011);
-const LoadScriptRuntimeModule = __webpack_require__(19942);
-const MakeNamespaceObjectRuntimeModule = __webpack_require__(65714);
-const OnChunksLoadedRuntimeModule = __webpack_require__(44518);
-const PublicPathRuntimeModule = __webpack_require__(56030);
-const RelativeUrlRuntimeModule = __webpack_require__(4537);
-const RuntimeIdRuntimeModule = __webpack_require__(97115);
-const SystemContextRuntimeModule = __webpack_require__(80655);
-const ShareRuntimeModule = __webpack_require__(96066);
-const StringXor = __webpack_require__(40293);
+const Dependency = __webpack_require__(54912);
+const { UsageState } = __webpack_require__(63686);
+const ModuleGraphConnection = __webpack_require__(40639);
+const { STAGE_DEFAULT } = __webpack_require__(80057);
+const ArrayQueue = __webpack_require__(41792);
+const TupleQueue = __webpack_require__(38415);
+const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
 
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-const GLOBALS_ON_REQUIRE = [
-	RuntimeGlobals.chunkName,
-	RuntimeGlobals.runtimeId,
-	RuntimeGlobals.compatGetDefaultExport,
-	RuntimeGlobals.createFakeNamespaceObject,
-	RuntimeGlobals.createScript,
-	RuntimeGlobals.createScriptUrl,
-	RuntimeGlobals.getTrustedTypesPolicy,
-	RuntimeGlobals.definePropertyGetters,
-	RuntimeGlobals.ensureChunk,
-	RuntimeGlobals.entryModuleId,
-	RuntimeGlobals.getFullHash,
-	RuntimeGlobals.global,
-	RuntimeGlobals.makeNamespaceObject,
-	RuntimeGlobals.moduleCache,
-	RuntimeGlobals.moduleFactories,
-	RuntimeGlobals.moduleFactoriesAddOnly,
-	RuntimeGlobals.interceptModuleExecution,
-	RuntimeGlobals.publicPath,
-	RuntimeGlobals.baseURI,
-	RuntimeGlobals.relativeUrl,
-	RuntimeGlobals.scriptNonce,
-	RuntimeGlobals.uncaughtErrorHandler,
-	RuntimeGlobals.asyncModule,
-	RuntimeGlobals.wasmInstances,
-	RuntimeGlobals.instantiateWasm,
-	RuntimeGlobals.shareScopeMap,
-	RuntimeGlobals.initializeSharing,
-	RuntimeGlobals.loadScript,
-	RuntimeGlobals.systemContext,
-	RuntimeGlobals.onChunksLoaded
-];
-
-const MODULE_DEPENDENCIES = {
-	[RuntimeGlobals.moduleLoaded]: [RuntimeGlobals.module],
-	[RuntimeGlobals.moduleId]: [RuntimeGlobals.module]
-};
+const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency;
 
-const TREE_DEPENDENCIES = {
-	[RuntimeGlobals.definePropertyGetters]: [RuntimeGlobals.hasOwnProperty],
-	[RuntimeGlobals.compatGetDefaultExport]: [
-		RuntimeGlobals.definePropertyGetters
-	],
-	[RuntimeGlobals.createFakeNamespaceObject]: [
-		RuntimeGlobals.definePropertyGetters,
-		RuntimeGlobals.makeNamespaceObject,
-		RuntimeGlobals.require
-	],
-	[RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
-	[RuntimeGlobals.shareScopeMap]: [RuntimeGlobals.hasOwnProperty]
-};
+class FlagDependencyUsagePlugin {
+	/**
+	 * @param {boolean} global do a global analysis instead of per runtime
+	 */
+	constructor(global) {
+		this.global = global;
+	}
 
-class RuntimePlugin {
 	/**
-	 * @param {Compiler} compiler the Compiler
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RuntimePlugin", compilation => {
-			compilation.dependencyTemplates.set(
-				RuntimeRequirementsDependency,
-				new RuntimeRequirementsDependency.Template()
-			);
-			for (const req of GLOBALS_ON_REQUIRE) {
-				compilation.hooks.runtimeRequirementInModule
-					.for(req)
-					.tap("RuntimePlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(req)
-					.tap("RuntimePlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
-			}
-			for (const req of Object.keys(TREE_DEPENDENCIES)) {
-				const deps = TREE_DEPENDENCIES[req];
-				compilation.hooks.runtimeRequirementInTree
-					.for(req)
-					.tap("RuntimePlugin", (chunk, set) => {
-						for (const dep of deps) set.add(dep);
-					});
-			}
-			for (const req of Object.keys(MODULE_DEPENDENCIES)) {
-				const deps = MODULE_DEPENDENCIES[req];
-				compilation.hooks.runtimeRequirementInModule
-					.for(req)
-					.tap("RuntimePlugin", (chunk, set) => {
-						for (const dep of deps) set.add(dep);
-					});
-			}
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.definePropertyGetters)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new DefinePropertyGettersRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.makeNamespaceObject)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new MakeNamespaceObjectRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.createFakeNamespaceObject)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new CreateFakeNamespaceObjectRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hasOwnProperty)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new HasOwnPropertyRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.compatGetDefaultExport)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new CompatGetDefaultExportRuntimeModule()
+		compiler.hooks.compilation.tap("FlagDependencyUsagePlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			compilation.hooks.optimizeDependencies.tap(
+				{
+					name: "FlagDependencyUsagePlugin",
+					stage: STAGE_DEFAULT
+				},
+				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
+						);
+					}
+
+					const logger = compilation.getLogger(
+						"webpack.FlagDependencyUsagePlugin"
 					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.runtimeId)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.publicPath)
-				.tap("RuntimePlugin", (chunk, set) => {
-					const { outputOptions } = compilation;
-					const { publicPath: globalPublicPath, scriptType } = outputOptions;
-					const entryOptions = chunk.getEntryOptions();
-					const publicPath =
-						entryOptions && entryOptions.publicPath !== undefined
-							? entryOptions.publicPath
-							: globalPublicPath;
+					/** @type {Map<ExportsInfo, Module>} */
+					const exportInfoToModuleMap = new Map();
 
-					if (publicPath === "auto") {
-						const module = new AutoPublicPathRuntimeModule();
-						if (scriptType !== "module") set.add(RuntimeGlobals.global);
-						compilation.addRuntimeModule(chunk, module);
-					} else {
-						const module = new PublicPathRuntimeModule(publicPath);
+					/** @type {TupleQueue<[Module, RuntimeSpec]>} */
+					const queue = new TupleQueue();
 
-						if (
-							typeof publicPath !== "string" ||
-							/\[(full)?hash\]/.test(publicPath)
-						) {
-							module.fullHash = true;
+					/**
+					 * @param {Module} module module to process
+					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
+					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
+					 * @returns {void}
+					 */
+					const processReferencedModule = (
+						module,
+						usedExports,
+						runtime,
+						forceSideEffects
+					) => {
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						if (usedExports.length > 0) {
+							if (!module.buildMeta || !module.buildMeta.exportsType) {
+								if (exportsInfo.setUsedWithoutInfo(runtime)) {
+									queue.enqueue(module, runtime);
+								}
+								return;
+							}
+							for (const usedExportInfo of usedExports) {
+								let usedExport;
+								let canMangle = true;
+								if (Array.isArray(usedExportInfo)) {
+									usedExport = usedExportInfo;
+								} else {
+									usedExport = usedExportInfo.name;
+									canMangle = usedExportInfo.canMangle !== false;
+								}
+								if (usedExport.length === 0) {
+									if (exportsInfo.setUsedInUnknownWay(runtime)) {
+										queue.enqueue(module, runtime);
+									}
+								} else {
+									let currentExportsInfo = exportsInfo;
+									for (let i = 0; i < usedExport.length; i++) {
+										const exportInfo = currentExportsInfo.getExportInfo(
+											usedExport[i]
+										);
+										if (canMangle === false) {
+											exportInfo.canMangleUse = false;
+										}
+										const lastOne = i === usedExport.length - 1;
+										if (!lastOne) {
+											const nestedInfo = exportInfo.getNestedExportsInfo();
+											if (nestedInfo) {
+												if (
+													exportInfo.setUsedConditionally(
+														used => used === UsageState.Unused,
+														UsageState.OnlyPropertiesUsed,
+														runtime
+													)
+												) {
+													const currentModule =
+														currentExportsInfo === exportsInfo
+															? module
+															: exportInfoToModuleMap.get(currentExportsInfo);
+													if (currentModule) {
+														queue.enqueue(currentModule, runtime);
+													}
+												}
+												currentExportsInfo = nestedInfo;
+												continue;
+											}
+										}
+										if (
+											exportInfo.setUsedConditionally(
+												v => v !== UsageState.Used,
+												UsageState.Used,
+												runtime
+											)
+										) {
+											const currentModule =
+												currentExportsInfo === exportsInfo
+													? module
+													: exportInfoToModuleMap.get(currentExportsInfo);
+											if (currentModule) {
+												queue.enqueue(currentModule, runtime);
+											}
+										}
+										break;
+									}
+								}
+							}
+						} else {
+							// for a module without side effects we stop tracking usage here when no export is used
+							// This module won't be evaluated in this case
+							// TODO webpack 6 remove this check
+							if (
+								!forceSideEffects &&
+								module.factoryMeta !== undefined &&
+								module.factoryMeta.sideEffectFree
+							) {
+								return;
+							}
+							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+								queue.enqueue(module, runtime);
+							}
 						}
+					};
 
-						compilation.addRuntimeModule(chunk, module);
-					}
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.global)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(chunk, new GlobalRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.asyncModule)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(chunk, new AsyncModuleRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.systemContext)
-				.tap("RuntimePlugin", chunk => {
-					const { outputOptions } = compilation;
-					const { library: globalLibrary } = outputOptions;
-					const entryOptions = chunk.getEntryOptions();
-					const libraryType =
-						entryOptions && entryOptions.library !== undefined
-							? entryOptions.library.type
-							: globalLibrary.type;
+					/**
+					 * @param {DependenciesBlock} module the module
+					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
+					 * @returns {void}
+					 */
+					const processModule = (module, runtime, forceSideEffects) => {
+						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
+						const map = new Map();
+
+						/** @type {ArrayQueue<DependenciesBlock>} */
+						const queue = new ArrayQueue();
+						queue.enqueue(module);
+						for (;;) {
+							const block = queue.dequeue();
+							if (block === undefined) break;
+							for (const b of block.blocks) {
+								if (
+									!this.global &&
+									b.groupOptions &&
+									b.groupOptions.entryOptions
+								) {
+									processModule(
+										b,
+										b.groupOptions.entryOptions.runtime || undefined,
+										true
+									);
+								} else {
+									queue.enqueue(b);
+								}
+							}
+							for (const dep of block.dependencies) {
+								const connection = moduleGraph.getConnection(dep);
+								if (!connection || !connection.module) {
+									continue;
+								}
+								const activeState = connection.getActiveState(runtime);
+								if (activeState === false) continue;
+								const { module } = connection;
+								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
+									processModule(module, runtime, false);
+									continue;
+								}
+								const oldReferencedExports = map.get(module);
+								if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
+									continue;
+								}
+								const referencedExports =
+									compilation.getDependencyReferencedExports(dep, runtime);
+								if (
+									oldReferencedExports === undefined ||
+									oldReferencedExports === NO_EXPORTS_REFERENCED ||
+									referencedExports === EXPORTS_OBJECT_REFERENCED
+								) {
+									map.set(module, referencedExports);
+								} else if (
+									oldReferencedExports !== undefined &&
+									referencedExports === NO_EXPORTS_REFERENCED
+								) {
+									continue;
+								} else {
+									let exportsMap;
+									if (Array.isArray(oldReferencedExports)) {
+										exportsMap = new Map();
+										for (const item of oldReferencedExports) {
+											if (Array.isArray(item)) {
+												exportsMap.set(item.join("\n"), item);
+											} else {
+												exportsMap.set(item.name.join("\n"), item);
+											}
+										}
+										map.set(module, exportsMap);
+									} else {
+										exportsMap = oldReferencedExports;
+									}
+									for (const item of referencedExports) {
+										if (Array.isArray(item)) {
+											const key = item.join("\n");
+											const oldItem = exportsMap.get(key);
+											if (oldItem === undefined) {
+												exportsMap.set(key, item);
+											}
+											// if oldItem is already an array we have to do nothing
+											// if oldItem is an ReferencedExport object, we don't have to do anything
+											// as canMangle defaults to true for arrays
+										} else {
+											const key = item.name.join("\n");
+											const oldItem = exportsMap.get(key);
+											if (oldItem === undefined || Array.isArray(oldItem)) {
+												exportsMap.set(key, item);
+											} else {
+												exportsMap.set(key, {
+													name: item.name,
+													canMangle: item.canMangle && oldItem.canMangle
+												});
+											}
+										}
+									}
+								}
+							}
+						}
+
+						for (const [module, referencedExports] of map) {
+							if (Array.isArray(referencedExports)) {
+								processReferencedModule(
+									module,
+									referencedExports,
+									runtime,
+									forceSideEffects
+								);
+							} else {
+								processReferencedModule(
+									module,
+									Array.from(referencedExports.values()),
+									runtime,
+									forceSideEffects
+								);
+							}
+						}
+					};
 
-					if (libraryType === "system") {
-						compilation.addRuntimeModule(
-							chunk,
-							new SystemContextRuntimeModule()
-						);
-					}
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getChunkScriptFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						typeof compilation.outputOptions.chunkFilename === "string" &&
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.chunkFilename
-						)
-					) {
-						set.add(RuntimeGlobals.getFullHash);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new GetChunkFilenameRuntimeModule(
-							"javascript",
-							"javascript",
-							RuntimeGlobals.getChunkScriptFilename,
-							chunk =>
-								chunk.filenameTemplate ||
-								(chunk.canBeInitial()
-									? compilation.outputOptions.filename
-									: compilation.outputOptions.chunkFilename),
-							false
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getChunkCssFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						typeof compilation.outputOptions.cssChunkFilename === "string" &&
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.cssChunkFilename
-						)
-					) {
-						set.add(RuntimeGlobals.getFullHash);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new GetChunkFilenameRuntimeModule(
-							"css",
-							"css",
-							RuntimeGlobals.getChunkCssFilename,
-							chunk =>
-								getChunkFilenameTemplate(chunk, compilation.outputOptions),
-							set.has(RuntimeGlobals.hmrDownloadUpdateHandlers)
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getChunkUpdateScriptFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.hotUpdateChunkFilename
-						)
-					)
-						set.add(RuntimeGlobals.getFullHash);
-					compilation.addRuntimeModule(
-						chunk,
-						new GetChunkFilenameRuntimeModule(
-							"javascript",
-							"javascript update",
-							RuntimeGlobals.getChunkUpdateScriptFilename,
-							c => compilation.outputOptions.hotUpdateChunkFilename,
-							true
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getUpdateManifestFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.hotUpdateMainFilename
-						)
-					) {
-						set.add(RuntimeGlobals.getFullHash);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new GetMainFilenameRuntimeModule(
-							"update manifest",
-							RuntimeGlobals.getUpdateManifestFilename,
-							compilation.outputOptions.hotUpdateMainFilename
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunk)
-				.tap("RuntimePlugin", (chunk, set) => {
-					const hasAsyncChunks = chunk.hasAsyncChunks();
-					if (hasAsyncChunks) {
-						set.add(RuntimeGlobals.ensureChunkHandlers);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new EnsureChunkRuntimeModule(set)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkIncludeEntries)
-				.tap("RuntimePlugin", (chunk, set) => {
-					set.add(RuntimeGlobals.ensureChunkHandlers);
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.shareScopeMap)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(chunk, new ShareRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.loadScript)
-				.tap("RuntimePlugin", (chunk, set) => {
-					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
-					if (withCreateScriptUrl) {
-						set.add(RuntimeGlobals.createScriptUrl);
+					logger.time("initialize exports usage");
+					for (const module of modules) {
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						exportInfoToModuleMap.set(exportsInfo, module);
+						exportsInfo.setHasUseInfo();
 					}
-					compilation.addRuntimeModule(
-						chunk,
-						new LoadScriptRuntimeModule(withCreateScriptUrl)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.createScript)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (compilation.outputOptions.trustedTypes) {
-						set.add(RuntimeGlobals.getTrustedTypesPolicy);
+					logger.timeEnd("initialize exports usage");
+
+					logger.time("trace exports usage in graph");
+
+					/**
+					 * @param {Dependency} dep dependency
+					 * @param {RuntimeSpec} runtime runtime
+					 */
+					const processEntryDependency = (dep, runtime) => {
+						const module = moduleGraph.getModule(dep);
+						if (module) {
+							processReferencedModule(
+								module,
+								NO_EXPORTS_REFERENCED,
+								runtime,
+								true
+							);
+						}
+					};
+					/** @type {RuntimeSpec} */
+					let globalRuntime = undefined;
+					for (const [
+						entryName,
+						{ dependencies: deps, includeDependencies: includeDeps, options }
+					] of compilation.entries) {
+						const runtime = this.global
+							? undefined
+							: getEntryRuntime(compilation, entryName, options);
+						for (const dep of deps) {
+							processEntryDependency(dep, runtime);
+						}
+						for (const dep of includeDeps) {
+							processEntryDependency(dep, runtime);
+						}
+						globalRuntime = mergeRuntimeOwned(globalRuntime, runtime);
 					}
-					compilation.addRuntimeModule(chunk, new CreateScriptRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.createScriptUrl)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (compilation.outputOptions.trustedTypes) {
-						set.add(RuntimeGlobals.getTrustedTypesPolicy);
+					for (const dep of compilation.globalEntry.dependencies) {
+						processEntryDependency(dep, globalRuntime);
 					}
-					compilation.addRuntimeModule(
-						chunk,
-						new CreateScriptUrlRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getTrustedTypesPolicy)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(
-						chunk,
-						new GetTrustedTypesPolicyRuntimeModule(set)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.relativeUrl)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(
-						chunk,
-						new OnChunksLoadedRuntimeModule()
-					);
-					return true;
-				});
-			// TODO webpack 6: remove CompatRuntimeModule
-			compilation.hooks.additionalTreeRuntimeRequirements.tap(
-				"RuntimePlugin",
-				(chunk, set) => {
-					const { mainTemplate } = compilation;
-					if (
-						mainTemplate.hooks.bootstrap.isUsed() ||
-						mainTemplate.hooks.localVars.isUsed() ||
-						mainTemplate.hooks.requireEnsure.isUsed() ||
-						mainTemplate.hooks.requireExtensions.isUsed()
-					) {
-						compilation.addRuntimeModule(chunk, new CompatRuntimeModule());
+					for (const dep of compilation.globalEntry.includeDependencies) {
+						processEntryDependency(dep, globalRuntime);
 					}
-				}
-			);
-			JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(
-				"RuntimePlugin",
-				(chunk, hash, { chunkGraph }) => {
-					const xor = new StringXor();
-					for (const m of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
-						xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+
+					while (queue.length) {
+						const [module, runtime] = queue.dequeue();
+						processModule(module, runtime, false);
 					}
-					xor.updateHash(hash);
+					logger.timeEnd("trace exports usage in graph");
 				}
 			);
 		});
 	}
 }
-module.exports = RuntimePlugin;
+
+module.exports = FlagDependencyUsagePlugin;
 
 
 /***/ }),
 
-/***/ 18777:
+/***/ 93401:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -53683,1045 +48588,1109 @@ module.exports = RuntimePlugin;
 
 
 
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const { equals } = __webpack_require__(84953);
-const compileBooleanMatcher = __webpack_require__(29404);
-const propertyAccess = __webpack_require__(54190);
-const { forEachRuntime, subtractRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./NormalModule")} NormalModule */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @param {Module} module the module
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @returns {string} error message
+ * @typedef {Object} GenerateContext
+ * @property {DependencyTemplates} dependencyTemplates mapping from dependencies to templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {Set<string>} runtimeRequirements the requirements for runtime
+ * @property {RuntimeSpec} runtime the runtime
+ * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults=} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
+ * @property {string} type which kind of code should be generated
+ * @property {function(): Map<string, any>=} getData get access to the code generation data
  */
-const noModuleIdErrorMessage = (module, chunkGraph) => {
-	return `Module ${module.identifier()} has no id assigned.
-This should not happen.
-It's in these chunks: ${
-		Array.from(
-			chunkGraph.getModuleChunksIterable(module),
-			c => c.name || c.id || c.debugId
-		).join(", ") || "none"
-	} (If module is in no chunk this indicates a bug in some chunk/module optimization logic)
-Module has these incoming connections: ${Array.from(
-		chunkGraph.moduleGraph.getIncomingConnections(module),
-		connection =>
-			`\n - ${
-				connection.originModule && connection.originModule.identifier()
-			} ${connection.dependency && connection.dependency.type} ${
-				(connection.explanations &&
-					Array.from(connection.explanations).join(", ")) ||
-				""
-			}`
-	).join("")}`;
-};
 
 /**
- * @param {string|undefined} definition global object definition
- * @returns {string} save to use global object
+ * @typedef {Object} UpdateHashContext
+ * @property {NormalModule} module the module
+ * @property {ChunkGraph} chunkGraph
+ * @property {RuntimeSpec} runtime
  */
-function getGlobalObject(definition) {
-	if (!definition) return definition;
-	const trimmed = definition.trim();
-
-	if (
-		// identifier, we do not need real identifier regarding ECMAScript/Unicode
-		trimmed.match(/^[_\p{L}][_0-9\p{L}]*$/iu) ||
-		// iife
-		// call expression
-		// expression in parentheses
-		trimmed.match(/^([_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu)
-	)
-		return trimmed;
-
-	return `Object(${trimmed})`;
-}
-
-class RuntimeTemplate {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {OutputOptions} outputOptions the compilation output options
-	 * @param {RequestShortener} requestShortener the request shortener
-	 */
-	constructor(compilation, outputOptions, requestShortener) {
-		this.compilation = compilation;
-		this.outputOptions = outputOptions || {};
-		this.requestShortener = requestShortener;
-		this.globalObject = getGlobalObject(outputOptions.globalObject);
-	}
-
-	isIIFE() {
-		return this.outputOptions.iife;
-	}
-
-	isModule() {
-		return this.outputOptions.module;
-	}
-
-	supportsConst() {
-		return this.outputOptions.environment.const;
-	}
-
-	supportsArrowFunction() {
-		return this.outputOptions.environment.arrowFunction;
-	}
-
-	supportsOptionalChaining() {
-		return this.outputOptions.environment.optionalChaining;
-	}
-
-	supportsForOf() {
-		return this.outputOptions.environment.forOf;
-	}
-
-	supportsDestructuring() {
-		return this.outputOptions.environment.destructuring;
-	}
-
-	supportsBigIntLiteral() {
-		return this.outputOptions.environment.bigIntLiteral;
-	}
-
-	supportsDynamicImport() {
-		return this.outputOptions.environment.dynamicImport;
-	}
-
-	supportsEcmaScriptModuleSyntax() {
-		return this.outputOptions.environment.module;
-	}
-
-	supportTemplateLiteral() {
-		return this.outputOptions.environment.templateLiteral;
-	}
-
-	returningFunction(returnValue, args = "") {
-		return this.supportsArrowFunction()
-			? `(${args}) => (${returnValue})`
-			: `function(${args}) { return ${returnValue}; }`;
-	}
-
-	basicFunction(args, body) {
-		return this.supportsArrowFunction()
-			? `(${args}) => {\n${Template.indent(body)}\n}`
-			: `function(${args}) {\n${Template.indent(body)}\n}`;
-	}
-
-	/**
-	 * @param {Array<string|{expr: string}>} args args
-	 * @returns {string} result expression
-	 */
-	concatenation(...args) {
-		const len = args.length;
-
-		if (len === 2) return this._es5Concatenation(args);
-		if (len === 0) return '""';
-		if (len === 1) {
-			return typeof args[0] === "string"
-				? JSON.stringify(args[0])
-				: `"" + ${args[0].expr}`;
-		}
-		if (!this.supportTemplateLiteral()) return this._es5Concatenation(args);
-
-		// cost comparison between template literal and concatenation:
-		// both need equal surroundings: `xxx` vs "xxx"
-		// template literal has constant cost of 3 chars for each expression
-		// es5 concatenation has cost of 3 + n chars for n expressions in row
-		// when a es5 concatenation ends with an expression it reduces cost by 3
-		// when a es5 concatenation starts with an single expression it reduces cost by 3
-		// e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
-		// e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
-
-		let templateCost = 0;
-		let concatenationCost = 0;
-
-		let lastWasExpr = false;
-		for (const arg of args) {
-			const isExpr = typeof arg !== "string";
-			if (isExpr) {
-				templateCost += 3;
-				concatenationCost += lastWasExpr ? 1 : 4;
-			}
-			lastWasExpr = isExpr;
-		}
-		if (lastWasExpr) concatenationCost -= 3;
-		if (typeof args[0] !== "string" && typeof args[1] === "string")
-			concatenationCost -= 3;
-
-		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
-
-		return `\`${args
-			.map(arg => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
-			.join("")}\``;
-	}
-
-	/**
-	 * @param {Array<string|{expr: string}>} args args (len >= 2)
-	 * @returns {string} result expression
-	 * @private
-	 */
-	_es5Concatenation(args) {
-		const str = args
-			.map(arg => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
-			.join(" + ");
-
-		// when the first two args are expression, we need to prepend "" + to force string
-		// concatenation instead of number addition.
-		return typeof args[0] !== "string" && typeof args[1] !== "string"
-			? `"" + ${str}`
-			: str;
-	}
-
-	expressionFunction(expression, args = "") {
-		return this.supportsArrowFunction()
-			? `(${args}) => (${expression})`
-			: `function(${args}) { ${expression}; }`;
-	}
-
-	emptyFunction() {
-		return this.supportsArrowFunction() ? "x => {}" : "function() {}";
-	}
-
-	destructureArray(items, value) {
-		return this.supportsDestructuring()
-			? `var [${items.join(", ")}] = ${value};`
-			: Template.asString(
-					items.map((item, i) => `var ${item} = ${value}[${i}];`)
-			  );
-	}
-
-	destructureObject(items, value) {
-		return this.supportsDestructuring()
-			? `var {${items.join(", ")}} = ${value};`
-			: Template.asString(
-					items.map(item => `var ${item} = ${value}${propertyAccess([item])};`)
-			  );
-	}
-
-	iife(args, body) {
-		return `(${this.basicFunction(args, body)})()`;
-	}
 
-	forEach(variable, array, body) {
-		return this.supportsForOf()
-			? `for(const ${variable} of ${array}) {\n${Template.indent(body)}\n}`
-			: `${array}.forEach(function(${variable}) {\n${Template.indent(
-					body
-			  )}\n});`;
+/**
+ *
+ */
+class Generator {
+	static byType(map) {
+		return new ByTypeGenerator(map);
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * Add a comment
-	 * @param {object} options Information content of the comment
-	 * @param {string=} options.request request string used originally
-	 * @param {string=} options.chunkName name of the chunk referenced
-	 * @param {string=} options.chunkReason reason information of the chunk
-	 * @param {string=} options.message additional message
-	 * @param {string=} options.exportName name of the export
-	 * @returns {string} comment
+	 * @abstract
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	comment({ request, chunkName, chunkReason, message, exportName }) {
-		let content;
-		if (this.outputOptions.pathinfo) {
-			content = [message, request, chunkName, chunkReason]
-				.filter(Boolean)
-				.map(item => this.requestShortener.shorten(item))
-				.join(" | ");
-		} else {
-			content = [message, chunkName, chunkReason]
-				.filter(Boolean)
-				.map(item => this.requestShortener.shorten(item))
-				.join(" | ");
-		}
-		if (!content) return "";
-		if (this.outputOptions.pathinfo) {
-			return Template.toComment(content) + " ";
-		} else {
-			return Template.toNormalComment(content) + " ";
-		}
+	getTypes(module) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error block
+	 * @abstract
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	throwMissingModuleErrorBlock({ request }) {
-		const err = `Cannot find module '${request}'`;
-		return `var e = new Error(${JSON.stringify(
-			err
-		)}); e.code = 'MODULE_NOT_FOUND'; throw e;`;
+	getSize(module, type) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error function
+	 * @abstract
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	throwMissingModuleErrorFunction({ request }) {
-		return `function webpackMissingModule() { ${this.throwMissingModuleErrorBlock(
-			{ request }
-		)} }`;
+	generate(
+		module,
+		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
+	) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
 	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error IIFE
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
-	missingModule({ request }) {
-		return `Object(${this.throwMissingModuleErrorFunction({ request })}())`;
+	getConcatenationBailoutReason(module, context) {
+		return `Module Concatenation is not implemented for ${this.constructor.name}`;
 	}
 
 	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error statement
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	missingModuleStatement({ request }) {
-		return `${this.missingModule({ request })};\n`;
+	updateHash(hash, { module, runtime }) {
+		// no nothing
 	}
+}
 
-	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error code
-	 */
-	missingModulePromise({ request }) {
-		return `Promise.resolve().then(${this.throwMissingModuleErrorFunction({
-			request
-		})})`;
+class ByTypeGenerator extends Generator {
+	constructor(map) {
+		super();
+		this.map = map;
+		this._types = new Set(Object.keys(map));
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Module} options.module the module
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {string=} options.idExpr expression to use as id expression
-	 * @param {"expression" | "promise" | "statements"} options.type which kind of code should be returned
-	 * @returns {string} the code
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	weakError({ module, chunkGraph, request, idExpr, type }) {
-		const moduleId = chunkGraph.getModuleId(module);
-		const errorMessage =
-			moduleId === null
-				? JSON.stringify("Module is not available (weak dependency)")
-				: idExpr
-				? `"Module '" + ${idExpr} + "' is not available (weak dependency)"`
-				: JSON.stringify(
-						`Module '${moduleId}' is not available (weak dependency)`
-				  );
-		const comment = request ? Template.toNormalComment(request) + " " : "";
-		const errorStatements =
-			`var e = new Error(${errorMessage}); ` +
-			comment +
-			"e.code = 'MODULE_NOT_FOUND'; throw e;";
-		switch (type) {
-			case "statements":
-				return errorStatements;
-			case "promise":
-				return `Promise.resolve().then(${this.basicFunction(
-					"",
-					errorStatements
-				)})`;
-			case "expression":
-				return this.iife("", errorStatements);
-		}
+	getTypes(module) {
+		return this._types;
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @returns {string} the expression
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	moduleId({ module, chunkGraph, request, weak }) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId === null) {
-			if (weak) {
-				return "null /* weak dependency, without id */";
-			}
-			throw new Error(
-				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
-			);
-		}
-		return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
+	getSize(module, type) {
+		const t = type || "javascript";
+		const generator = this.map[t];
+		return generator ? generator.getSize(module, t) : 0;
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the expression
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return this.weakError({
-					module,
-					chunkGraph,
-					request,
-					type: "expression"
-				});
-			}
-			throw new Error(
-				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
-			);
+	generate(module, generateContext) {
+		const type = generateContext.type;
+		const generator = this.map[type];
+		if (!generator) {
+			throw new Error(`Generator.byType: no generator specified for ${type}`);
 		}
-		runtimeRequirements.add(RuntimeGlobals.require);
-		return `__webpack_require__(${this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		})})`;
+		return generator.generate(module, generateContext);
 	}
+}
 
-	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the expression
-	 */
-	moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }) {
-		return this.moduleRaw({
-			module,
-			chunkGraph,
-			request,
-			weak,
-			runtimeRequirements
-		});
+module.exports = Generator;
+
+
+/***/ }),
+
+/***/ 37234:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Module")} Module */
+
+/**
+ * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
+ * @param {Chunk} chunk chunk to tie to ChunkGroup
+ * @returns {void}
+ */
+const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
+	if (chunkGroup.pushChunk(chunk)) {
+		chunk.addGroup(chunkGroup);
+	}
+};
+
+/**
+ * @param {ChunkGroup} parent parent ChunkGroup to connect
+ * @param {ChunkGroup} child child ChunkGroup to connect
+ * @returns {void}
+ */
+const connectChunkGroupParentAndChild = (parent, child) => {
+	if (parent.addChild(child)) {
+		child.addParent(parent);
+	}
+};
+
+exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
+exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;
+
+
+/***/ }),
+
+/***/ 97511:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+module.exports = class HarmonyLinkingError extends WebpackError {
+	/** @param {string} message Error message */
+	constructor(message) {
+		super(message);
+		this.name = "HarmonyLinkingError";
+		this.hideStack = true;
 	}
+};
+
+
+/***/ }),
+
+/***/ 11351:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+
+
 
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Module")} Module */
+
+/**
+ * @template T
+ * @callback Callback
+ * @param {Error=} err
+ * @param {T=} stats
+ * @returns {void}
+ */
+
+class HookWebpackError extends WebpackError {
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.strict if the current module is in strict esm mode
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the expression
+	 * Creates an instance of HookWebpackError.
+	 * @param {Error} error inner error
+	 * @param {string} hook name of hook
 	 */
-	moduleNamespace({
-		module,
-		chunkGraph,
-		request,
-		strict,
-		weak,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		if (chunkGraph.getModuleId(module) === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return this.weakError({
-					module,
-					chunkGraph,
-					request,
-					type: "expression"
-				});
+	constructor(error, hook) {
+		super(error.message);
+
+		this.name = "HookWebpackError";
+		this.hook = hook;
+		this.error = error;
+		this.hideStack = true;
+		this.details = `caused by plugins in ${hook}\n${error.stack}`;
+
+		this.stack += `\n-- inner error --\n${error.stack}`;
+	}
+}
+
+module.exports = HookWebpackError;
+
+/**
+ * @param {Error} error an error
+ * @param {string} hook name of the hook
+ * @returns {WebpackError} a webpack error
+ */
+const makeWebpackError = (error, hook) => {
+	if (error instanceof WebpackError) return error;
+	return new HookWebpackError(error, hook);
+};
+module.exports.makeWebpackError = makeWebpackError;
+
+/**
+ * @template T
+ * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
+ * @param {string} hook name of hook
+ * @returns {Callback<T>} generic callback
+ */
+const makeWebpackErrorCallback = (callback, hook) => {
+	return (err, result) => {
+		if (err) {
+			if (err instanceof WebpackError) {
+				callback(err);
+				return;
 			}
-			throw new Error(
-				`RuntimeTemplate.moduleNamespace(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
-			);
+			callback(new HookWebpackError(err, hook));
+			return;
 		}
-		const moduleId = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
-		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		switch (exportsType) {
-			case "namespace":
-				return this.moduleRaw({
-					module,
-					chunkGraph,
-					request,
-					weak,
-					runtimeRequirements
-				});
-			case "default-with-named":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`;
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 1)`;
-			case "dynamic":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 7)`;
+		callback(null, result);
+	};
+};
+
+module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
+
+/**
+ * @template T
+ * @param {function(): T} fn function which will be wrapping in try catch
+ * @param {string} hook name of hook
+ * @returns {T} the result
+ */
+const tryRunOrWebpackError = (fn, hook) => {
+	let r;
+	try {
+		r = fn();
+	} catch (err) {
+		if (err instanceof WebpackError) {
+			throw err;
 		}
+		throw new HookWebpackError(err, hook);
 	}
+	return r;
+};
+
+module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
+
+
+/***/ }),
+
+/***/ 6404:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { SyncBailHook } = __webpack_require__(41242);
+const { RawSource } = __webpack_require__(51255);
+const ChunkGraph = __webpack_require__(64971);
+const Compilation = __webpack_require__(85720);
+const HotUpdateChunk = __webpack_require__(9597);
+const NormalModule = __webpack_require__(39);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const ConstDependency = __webpack_require__(76911);
+const ImportMetaHotAcceptDependency = __webpack_require__(51274);
+const ImportMetaHotDeclineDependency = __webpack_require__(53141);
+const ModuleHotAcceptDependency = __webpack_require__(47511);
+const ModuleHotDeclineDependency = __webpack_require__(86301);
+const HotModuleReplacementRuntimeModule = __webpack_require__(27899);
+const JavascriptParser = __webpack_require__(29050);
+const {
+	evaluateToIdentifier
+} = __webpack_require__(93998);
+const { find, isSubset } = __webpack_require__(93347);
+const TupleSet = __webpack_require__(76455);
+const { compareModulesById } = __webpack_require__(29579);
+const {
+	getRuntimeKey,
+	keyToRuntime,
+	forEachRuntime,
+	mergeRuntimeOwned,
+	subtractRuntime,
+	intersectRuntime
+} = __webpack_require__(17156);
+
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @typedef {Object} HMRJavascriptParserHooks
+ * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptCallback
+ * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptWithoutCallback
+ */
+
+/** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
+const parserHooksMap = new WeakMap();
+
+class HotModuleReplacementPlugin {
 	/**
-	 * @param {Object} options options object
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {AsyncDependenciesBlock=} options.block the current dependencies block
-	 * @param {Module} options.module the module
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {string} options.message a message for the comment
-	 * @param {boolean=} options.strict if the current module is in strict esm mode
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the promise expression
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {HMRJavascriptParserHooks} the attached hooks
 	 */
-	moduleNamespacePromise({
-		chunkGraph,
-		block,
-		module,
-		request,
-		message,
-		strict,
-		weak,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return this.missingModulePromise({
-				request
-			});
-		}
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return this.weakError({
-					module,
-					chunkGraph,
-					request,
-					type: "promise"
-				});
-			}
-			throw new Error(
-				`RuntimeTemplate.moduleNamespacePromise(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
+	static getParserHooks(parser) {
+		if (!(parser instanceof JavascriptParser)) {
+			throw new TypeError(
+				"The 'parser' argument must be an instance of JavascriptParser"
 			);
 		}
-		const promise = this.blockPromise({
-			chunkGraph,
-			block,
-			message,
-			runtimeRequirements
-		});
-
-		let appending;
-		let idExpr = JSON.stringify(chunkGraph.getModuleId(module));
-		const comment = this.comment({
-			request
-		});
-		let header = "";
-		if (weak) {
-			if (idExpr.length > 8) {
-				// 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"'
-				header += `var id = ${idExpr}; `;
-				idExpr = "id";
-			}
-			runtimeRequirements.add(RuntimeGlobals.moduleFactories);
-			header += `if(!${
-				RuntimeGlobals.moduleFactories
-			}[${idExpr}]) { ${this.weakError({
-				module,
-				chunkGraph,
-				request,
-				idExpr,
-				type: "statements"
-			})} } `;
-		}
-		const moduleIdExpr = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
-		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		let fakeType = 16;
-		switch (exportsType) {
-			case "namespace":
-				if (header) {
-					const rawModule = this.moduleRaw({
-						module,
-						chunkGraph,
-						request,
-						weak,
-						runtimeRequirements
-					});
-					appending = `.then(${this.basicFunction(
-						"",
-						`${header}return ${rawModule};`
-					)})`;
-				} else {
-					runtimeRequirements.add(RuntimeGlobals.require);
-					appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
-				}
-				break;
-			case "dynamic":
-				fakeType |= 4;
-			/* fall through */
-			case "default-with-named":
-				fakeType |= 2;
-			/* fall through */
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				if (chunkGraph.moduleGraph.isAsync(module)) {
-					if (header) {
-						const rawModule = this.moduleRaw({
-							module,
-							chunkGraph,
-							request,
-							weak,
-							runtimeRequirements
-						});
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${rawModule};`
-						)})`;
-					} else {
-						runtimeRequirements.add(RuntimeGlobals.require);
-						appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
-					}
-					appending += `.then(${this.returningFunction(
-						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
-						"m"
-					)})`;
-				} else {
-					fakeType |= 1;
-					if (header) {
-						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${returnExpression};`
-						)})`;
-					} else {
-						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(__webpack_require__, ${comment}${idExpr}, ${fakeType}))`;
-					}
-				}
-				break;
+		let hooks = parserHooksMap.get(parser);
+		if (hooks === undefined) {
+			hooks = {
+				hotAcceptCallback: new SyncBailHook(["expression", "requests"]),
+				hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"])
+			};
+			parserHooksMap.set(parser, hooks);
 		}
-
-		return `${promise || "Promise.resolve()"}${appending}`;
+		return hooks;
 	}
 
-	/**
-	 * @param {Object} options options object
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
-	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} expression
-	 */
-	runtimeConditionExpression({
-		chunkGraph,
-		runtimeCondition,
-		runtime,
-		runtimeRequirements
-	}) {
-		if (runtimeCondition === undefined) return "true";
-		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
-		/** @type {Set<string>} */
-		const positiveRuntimeIds = new Set();
-		forEachRuntime(runtimeCondition, runtime =>
-			positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
-		);
-		/** @type {Set<string>} */
-		const negativeRuntimeIds = new Set();
-		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
-			negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
-		);
-		runtimeRequirements.add(RuntimeGlobals.runtimeId);
-		return compileBooleanMatcher.fromLists(
-			Array.from(positiveRuntimeIds),
-			Array.from(negativeRuntimeIds)
-		)(RuntimeGlobals.runtimeId);
+	constructor(options) {
+		this.options = options || {};
 	}
 
 	/**
-	 *
-	 * @param {Object} options options object
-	 * @param {boolean=} options.update whether a new variable should be created or the existing one updated
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {string} options.importVar name of the import variable
-	 * @param {Module} options.originModule module in which the statement is emitted
-	 * @param {boolean=} options.weak true, if this is a weak dependency
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {[string, string]} the import statement and the compat statement
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	importStatement({
-		update,
-		module,
-		chunkGraph,
-		request,
-		importVar,
-		originModule,
-		weak,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return [
-				this.missingModuleStatement({
-					request
-				}),
-				""
-			];
-		}
-		if (chunkGraph.getModuleId(module) === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return [
-					this.weakError({
-						module,
-						chunkGraph,
-						request,
-						type: "statements"
-					}),
-					""
-				];
+	apply(compiler) {
+		const { _backCompat: backCompat } = compiler;
+		if (compiler.options.output.strictModuleErrorHandling === undefined)
+			compiler.options.output.strictModuleErrorHandling = true;
+		const runtimeRequirements = [RuntimeGlobals.module];
+
+		const createAcceptHandler = (parser, ParamDependency) => {
+			const { hotAcceptCallback, hotAcceptWithoutCallback } =
+				HotModuleReplacementPlugin.getParserHooks(parser);
+
+			return expr => {
+				const module = parser.state.module;
+				const dep = new ConstDependency(
+					`${module.moduleArgument}.hot.accept`,
+					expr.callee.range,
+					runtimeRequirements
+				);
+				dep.loc = expr.loc;
+				module.addPresentationalDependency(dep);
+				module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+				if (expr.arguments.length >= 1) {
+					const arg = parser.evaluateExpression(expr.arguments[0]);
+					let params = [];
+					let requests = [];
+					if (arg.isString()) {
+						params = [arg];
+					} else if (arg.isArray()) {
+						params = arg.items.filter(param => param.isString());
+					}
+					if (params.length > 0) {
+						params.forEach((param, idx) => {
+							const request = param.string;
+							const dep = new ParamDependency(request, param.range);
+							dep.optional = true;
+							dep.loc = Object.create(expr.loc);
+							dep.loc.index = idx;
+							module.addDependency(dep);
+							requests.push(request);
+						});
+						if (expr.arguments.length > 1) {
+							hotAcceptCallback.call(expr.arguments[1], requests);
+							for (let i = 1; i < expr.arguments.length; i++) {
+								parser.walkExpression(expr.arguments[i]);
+							}
+							return true;
+						} else {
+							hotAcceptWithoutCallback.call(expr, requests);
+							return true;
+						}
+					}
+				}
+				parser.walkExpressions(expr.arguments);
+				return true;
+			};
+		};
+
+		const createDeclineHandler = (parser, ParamDependency) => expr => {
+			const module = parser.state.module;
+			const dep = new ConstDependency(
+				`${module.moduleArgument}.hot.decline`,
+				expr.callee.range,
+				runtimeRequirements
+			);
+			dep.loc = expr.loc;
+			module.addPresentationalDependency(dep);
+			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+			if (expr.arguments.length === 1) {
+				const arg = parser.evaluateExpression(expr.arguments[0]);
+				let params = [];
+				if (arg.isString()) {
+					params = [arg];
+				} else if (arg.isArray()) {
+					params = arg.items.filter(param => param.isString());
+				}
+				params.forEach((param, idx) => {
+					const dep = new ParamDependency(param.string, param.range);
+					dep.optional = true;
+					dep.loc = Object.create(expr.loc);
+					dep.loc.index = idx;
+					module.addDependency(dep);
+				});
 			}
-			throw new Error(
-				`RuntimeTemplate.importStatement(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
+			return true;
+		};
+
+		const createHMRExpressionHandler = parser => expr => {
+			const module = parser.state.module;
+			const dep = new ConstDependency(
+				`${module.moduleArgument}.hot`,
+				expr.range,
+				runtimeRequirements
 			);
-		}
-		const moduleId = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
-		const optDeclaration = update ? "" : "var ";
+			dep.loc = expr.loc;
+			module.addPresentationalDependency(dep);
+			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+			return true;
+		};
+
+		const applyModuleHot = parser => {
+			parser.hooks.evaluateIdentifier.for("module.hot").tap(
+				{
+					name: "HotModuleReplacementPlugin",
+					before: "NodeStuffPlugin"
+				},
+				expr => {
+					return evaluateToIdentifier(
+						"module.hot",
+						"module",
+						() => ["hot"],
+						true
+					)(expr);
+				}
+			);
+			parser.hooks.call
+				.for("module.hot.accept")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createAcceptHandler(parser, ModuleHotAcceptDependency)
+				);
+			parser.hooks.call
+				.for("module.hot.decline")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createDeclineHandler(parser, ModuleHotDeclineDependency)
+				);
+			parser.hooks.expression
+				.for("module.hot")
+				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
+		};
+
+		const applyImportMetaHot = parser => {
+			parser.hooks.evaluateIdentifier
+				.for("import.meta.webpackHot")
+				.tap("HotModuleReplacementPlugin", expr => {
+					return evaluateToIdentifier(
+						"import.meta.webpackHot",
+						"import.meta",
+						() => ["webpackHot"],
+						true
+					)(expr);
+				});
+			parser.hooks.call
+				.for("import.meta.webpackHot.accept")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createAcceptHandler(parser, ImportMetaHotAcceptDependency)
+				);
+			parser.hooks.call
+				.for("import.meta.webpackHot.decline")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createDeclineHandler(parser, ImportMetaHotDeclineDependency)
+				);
+			parser.hooks.expression
+				.for("import.meta.webpackHot")
+				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
+		};
+
+		compiler.hooks.compilation.tap(
+			"HotModuleReplacementPlugin",
+			(compilation, { normalModuleFactory }) => {
+				// This applies the HMR plugin only to the targeted compiler
+				// It should not affect child compilations
+				if (compilation.compiler !== compiler) return;
+
+				//#region module.hot.* API
+				compilation.dependencyFactories.set(
+					ModuleHotAcceptDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleHotAcceptDependency,
+					new ModuleHotAcceptDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ModuleHotDeclineDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleHotDeclineDependency,
+					new ModuleHotDeclineDependency.Template()
+				);
+				//#endregion
+
+				//#region import.meta.webpackHot.* API
+				compilation.dependencyFactories.set(
+					ImportMetaHotAcceptDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaHotAcceptDependency,
+					new ImportMetaHotAcceptDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ImportMetaHotDeclineDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaHotDeclineDependency,
+					new ImportMetaHotDeclineDependency.Template()
+				);
+				//#endregion
+
+				let hotIndex = 0;
+				const fullHashChunkModuleHashes = {};
+				const chunkModuleHashes = {};
+
+				compilation.hooks.record.tap(
+					"HotModuleReplacementPlugin",
+					(compilation, records) => {
+						if (records.hash === compilation.hash) return;
+						const chunkGraph = compilation.chunkGraph;
+						records.hash = compilation.hash;
+						records.hotIndex = hotIndex;
+						records.fullHashChunkModuleHashes = fullHashChunkModuleHashes;
+						records.chunkModuleHashes = chunkModuleHashes;
+						records.chunkHashes = {};
+						records.chunkRuntime = {};
+						for (const chunk of compilation.chunks) {
+							records.chunkHashes[chunk.id] = chunk.hash;
+							records.chunkRuntime[chunk.id] = getRuntimeKey(chunk.runtime);
+						}
+						records.chunkModuleIds = {};
+						for (const chunk of compilation.chunks) {
+							records.chunkModuleIds[chunk.id] = Array.from(
+								chunkGraph.getOrderedChunkModulesIterable(
+									chunk,
+									compareModulesById(chunkGraph)
+								),
+								m => chunkGraph.getModuleId(m)
+							);
+						}
+					}
+				);
+				/** @type {TupleSet<[Module, Chunk]>} */
+				const updatedModules = new TupleSet();
+				/** @type {TupleSet<[Module, Chunk]>} */
+				const fullHashModules = new TupleSet();
+				/** @type {TupleSet<[Module, RuntimeSpec]>} */
+				const nonCodeGeneratedModules = new TupleSet();
+				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
+					const chunkGraph = compilation.chunkGraph;
+					const records = compilation.records;
+					for (const chunk of compilation.chunks) {
+						const getModuleHash = module => {
+							if (
+								compilation.codeGenerationResults.has(module, chunk.runtime)
+							) {
+								return compilation.codeGenerationResults.getHash(
+									module,
+									chunk.runtime
+								);
+							} else {
+								nonCodeGeneratedModules.add(module, chunk.runtime);
+								return chunkGraph.getModuleHash(module, chunk.runtime);
+							}
+						};
+						const fullHashModulesInThisChunk =
+							chunkGraph.getChunkFullHashModulesSet(chunk);
+						if (fullHashModulesInThisChunk !== undefined) {
+							for (const module of fullHashModulesInThisChunk) {
+								fullHashModules.add(module, chunk);
+							}
+						}
+						const modules = chunkGraph.getChunkModulesIterable(chunk);
+						if (modules !== undefined) {
+							if (records.chunkModuleHashes) {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											if (records.fullHashChunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											if (records.chunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											chunkModuleHashes[key] = hash;
+										}
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (records.chunkModuleHashes[key] !== hash) {
+											updatedModules.add(module, chunk);
+										}
+										chunkModuleHashes[key] = hash;
+									}
+								}
+							} else {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											chunkModuleHashes[key] = hash;
+										}
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										chunkModuleHashes[key] = hash;
+									}
+								}
+							}
+						}
+					}
 
-		const exportsType = module.getExportsType(
-			chunkGraph.moduleGraph,
-			originModule.buildMeta.strictHarmonyModule
-		);
-		runtimeRequirements.add(RuntimeGlobals.require);
-		const importContent = `/* harmony import */ ${optDeclaration}${importVar} = __webpack_require__(${moduleId});\n`;
+					hotIndex = records.hotIndex || 0;
+					if (updatedModules.size > 0) hotIndex++;
 
-		if (exportsType === "dynamic") {
-			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
-			return [
-				importContent,
-				`/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${importVar});\n`
-			];
-		}
-		return [importContent, ""];
-	}
+					hash.update(`${hotIndex}`);
+				});
+				compilation.hooks.processAssets.tap(
+					{
+						name: "HotModuleReplacementPlugin",
+						stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+					},
+					() => {
+						const chunkGraph = compilation.chunkGraph;
+						const records = compilation.records;
+						if (records.hash === compilation.hash) return;
+						if (
+							!records.chunkModuleHashes ||
+							!records.chunkHashes ||
+							!records.chunkModuleIds
+						) {
+							return;
+						}
+						for (const [module, chunk] of fullHashModules) {
+							const key = `${chunk.id}|${module.identifier()}`;
+							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
+								? chunkGraph.getModuleHash(module, chunk.runtime)
+								: compilation.codeGenerationResults.getHash(
+										module,
+										chunk.runtime
+								  );
+							if (records.chunkModuleHashes[key] !== hash) {
+								updatedModules.add(module, chunk);
+							}
+							chunkModuleHashes[key] = hash;
+						}
 
-	/**
-	 * @param {Object} options options
-	 * @param {ModuleGraph} options.moduleGraph the module graph
-	 * @param {Module} options.module the module
-	 * @param {string} options.request the request
-	 * @param {string | string[]} options.exportName the export name
-	 * @param {Module} options.originModule the origin module
-	 * @param {boolean|undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
-	 * @param {boolean} options.isCall true, if expression will be called
-	 * @param {boolean} options.callContext when false, call context will not be preserved
-	 * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated
-	 * @param {string} options.importVar the identifier name of the import variable
-	 * @param {InitFragment[]} options.initFragments init fragments will be added here
-	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} expression
-	 */
-	exportFromImport({
-		moduleGraph,
-		module,
-		request,
-		exportName,
-		originModule,
-		asiSafe,
-		isCall,
-		callContext,
-		defaultInterop,
-		importVar,
-		initFragments,
-		runtime,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		if (!Array.isArray(exportName)) {
-			exportName = exportName ? [exportName] : [];
-		}
-		const exportsType = module.getExportsType(
-			moduleGraph,
-			originModule.buildMeta.strictHarmonyModule
-		);
+						/** @type {Map<string, { updatedChunkIds: Set<string|number>, removedChunkIds: Set<string|number>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }>} */
+						const hotUpdateMainContentByRuntime = new Map();
+						let allOldRuntime;
+						for (const key of Object.keys(records.chunkRuntime)) {
+							const runtime = keyToRuntime(records.chunkRuntime[key]);
+							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
+						}
+						forEachRuntime(allOldRuntime, runtime => {
+							const { path: filename, info: assetInfo } =
+								compilation.getPathWithInfo(
+									compilation.outputOptions.hotUpdateMainFilename,
+									{
+										hash: records.hash,
+										runtime
+									}
+								);
+							hotUpdateMainContentByRuntime.set(runtime, {
+								updatedChunkIds: new Set(),
+								removedChunkIds: new Set(),
+								removedModules: new Set(),
+								filename,
+								assetInfo
+							});
+						});
+						if (hotUpdateMainContentByRuntime.size === 0) return;
 
-		if (defaultInterop) {
-			if (exportName.length > 0 && exportName[0] === "default") {
-				switch (exportsType) {
-					case "dynamic":
-						if (isCall) {
-							return `${importVar}_default()${propertyAccess(exportName, 1)}`;
-						} else {
-							return asiSafe
-								? `(${importVar}_default()${propertyAccess(exportName, 1)})`
-								: asiSafe === false
-								? `;(${importVar}_default()${propertyAccess(exportName, 1)})`
-								: `${importVar}_default.a${propertyAccess(exportName, 1)}`;
+						// Create a list of all active modules to verify which modules are removed completely
+						/** @type {Map<number|string, Module>} */
+						const allModules = new Map();
+						for (const module of compilation.modules) {
+							const id = chunkGraph.getModuleId(module);
+							allModules.set(id, module);
 						}
-					case "default-only":
-					case "default-with-named":
-						exportName = exportName.slice(1);
-						break;
-				}
-			} else if (exportName.length > 0) {
-				if (exportsType === "default-only") {
-					return (
-						"/* non-default import from non-esm module */undefined" +
-						propertyAccess(exportName, 1)
-					);
-				} else if (
-					exportsType !== "namespace" &&
-					exportName[0] === "__esModule"
-				) {
-					return "/* __esModule */true";
-				}
-			} else if (
-				exportsType === "default-only" ||
-				exportsType === "default-with-named"
-			) {
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				initFragments.push(
-					new InitFragment(
-						`var ${importVar}_namespace_cache;\n`,
-						InitFragment.STAGE_CONSTANTS,
-						-1,
-						`${importVar}_namespace_cache`
-					)
-				);
-				return `/*#__PURE__*/ ${
-					asiSafe ? "" : asiSafe === false ? ";" : "Object"
-				}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${
-					RuntimeGlobals.createFakeNamespaceObject
-				}(${importVar}${exportsType === "default-only" ? "" : ", 2"})))`;
-			}
-		}
 
-		if (exportName.length > 0) {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const used = exportsInfo.getUsedName(exportName, runtime);
-			if (!used) {
-				const comment = Template.toNormalComment(
-					`unused export ${propertyAccess(exportName)}`
-				);
-				return `${comment} undefined`;
-			}
-			const comment = equals(used, exportName)
-				? ""
-				: Template.toNormalComment(propertyAccess(exportName)) + " ";
-			const access = `${importVar}${comment}${propertyAccess(used)}`;
-			if (isCall && callContext === false) {
-				return asiSafe
-					? `(0,${access})`
-					: asiSafe === false
-					? `;(0,${access})`
-					: `/*#__PURE__*/Object(${access})`;
-			}
-			return access;
-		} else {
-			return importVar;
-		}
-	}
+						// List of completely removed modules
+						/** @type {Set<string | number>} */
+						const completelyRemovedModules = new Set();
 
-	/**
-	 * @param {Object} options options
-	 * @param {AsyncDependenciesBlock} options.block the async block
-	 * @param {string} options.message the message
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} expression
-	 */
-	blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
-		if (!block) {
-			const comment = this.comment({
-				message
-			});
-			return `Promise.resolve(${comment.trim()})`;
-		}
-		const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-		if (!chunkGroup || chunkGroup.chunks.length === 0) {
-			const comment = this.comment({
-				message
-			});
-			return `Promise.resolve(${comment.trim()})`;
-		}
-		const chunks = chunkGroup.chunks.filter(
-			chunk => !chunk.hasRuntime() && chunk.id !== null
-		);
-		const comment = this.comment({
-			message,
-			chunkName: block.chunkName
-		});
-		if (chunks.length === 1) {
-			const chunkId = JSON.stringify(chunks[0].id);
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId})`;
-		} else if (chunks.length > 0) {
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-			const requireChunkId = chunk =>
-				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`;
-			return `Promise.all(${comment.trim()}[${chunks
-				.map(requireChunkId)
-				.join(", ")}])`;
-		} else {
-			return `Promise.resolve(${comment.trim()})`;
-		}
-	}
+						for (const key of Object.keys(records.chunkHashes)) {
+							const oldRuntime = keyToRuntime(records.chunkRuntime[key]);
+							/** @type {Module[]} */
+							const remainingModules = [];
+							// Check which modules are removed
+							for (const id of records.chunkModuleIds[key]) {
+								const module = allModules.get(id);
+								if (module === undefined) {
+									completelyRemovedModules.add(id);
+								} else {
+									remainingModules.push(module);
+								}
+							}
+
+							let chunkId;
+							let newModules;
+							let newRuntimeModules;
+							let newFullHashModules;
+							let newDependentHashModules;
+							let newRuntime;
+							let removedFromRuntime;
+							const currentChunk = find(
+								compilation.chunks,
+								chunk => `${chunk.id}` === key
+							);
+							if (currentChunk) {
+								chunkId = currentChunk.id;
+								newRuntime = intersectRuntime(
+									currentChunk.runtime,
+									allOldRuntime
+								);
+								if (newRuntime === undefined) continue;
+								newModules = chunkGraph
+									.getChunkModules(currentChunk)
+									.filter(module => updatedModules.has(module, currentChunk));
+								newRuntimeModules = Array.from(
+									chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
+								).filter(module => updatedModules.has(module, currentChunk));
+								const fullHashModules =
+									chunkGraph.getChunkFullHashModulesIterable(currentChunk);
+								newFullHashModules =
+									fullHashModules &&
+									Array.from(fullHashModules).filter(module =>
+										updatedModules.has(module, currentChunk)
+									);
+								const dependentHashModules =
+									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
+								newDependentHashModules =
+									dependentHashModules &&
+									Array.from(dependentHashModules).filter(module =>
+										updatedModules.has(module, currentChunk)
+									);
+								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
+							} else {
+								// chunk has completely removed
+								chunkId = `${+key}` === key ? +key : key;
+								removedFromRuntime = oldRuntime;
+								newRuntime = oldRuntime;
+							}
+							if (removedFromRuntime) {
+								// chunk was removed from some runtimes
+								forEachRuntime(removedFromRuntime, runtime => {
+									hotUpdateMainContentByRuntime
+										.get(runtime)
+										.removedChunkIds.add(chunkId);
+								});
+								// dispose modules from the chunk in these runtimes
+								// where they are no longer in this runtime
+								for (const module of remainingModules) {
+									const moduleKey = `${key}|${module.identifier()}`;
+									const oldHash = records.chunkModuleHashes[moduleKey];
+									const runtimes = chunkGraph.getModuleRuntimes(module);
+									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
+										// Module is still in the same runtime combination
+										const hash = nonCodeGeneratedModules.has(module, newRuntime)
+											? chunkGraph.getModuleHash(module, newRuntime)
+											: compilation.codeGenerationResults.getHash(
+													module,
+													newRuntime
+											  );
+										if (hash !== oldHash) {
+											if (module.type === "runtime") {
+												newRuntimeModules = newRuntimeModules || [];
+												newRuntimeModules.push(
+													/** @type {RuntimeModule} */ (module)
+												);
+											} else {
+												newModules = newModules || [];
+												newModules.push(module);
+											}
+										}
+									} else {
+										// module is no longer in this runtime combination
+										// We (incorrectly) assume that it's not in an overlapping runtime combination
+										// and dispose it from the main runtimes the chunk was removed from
+										forEachRuntime(removedFromRuntime, runtime => {
+											// If the module is still used in this runtime, do not dispose it
+											// This could create a bad runtime state where the module is still loaded,
+											// but no chunk which contains it. This means we don't receive further HMR updates
+											// to this module and that's bad.
+											// TODO force load one of the chunks which contains the module
+											for (const moduleRuntime of runtimes) {
+												if (typeof moduleRuntime === "string") {
+													if (moduleRuntime === runtime) return;
+												} else if (moduleRuntime !== undefined) {
+													if (moduleRuntime.has(runtime)) return;
+												}
+											}
+											hotUpdateMainContentByRuntime
+												.get(runtime)
+												.removedModules.add(module);
+										});
+									}
+								}
+							}
+							if (
+								(newModules && newModules.length > 0) ||
+								(newRuntimeModules && newRuntimeModules.length > 0)
+							) {
+								const hotUpdateChunk = new HotUpdateChunk();
+								if (backCompat)
+									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
+								hotUpdateChunk.id = chunkId;
+								hotUpdateChunk.runtime = newRuntime;
+								if (currentChunk) {
+									for (const group of currentChunk.groupsIterable)
+										hotUpdateChunk.addGroup(group);
+								}
+								chunkGraph.attachModules(hotUpdateChunk, newModules || []);
+								chunkGraph.attachRuntimeModules(
+									hotUpdateChunk,
+									newRuntimeModules || []
+								);
+								if (newFullHashModules) {
+									chunkGraph.attachFullHashModules(
+										hotUpdateChunk,
+										newFullHashModules
+									);
+								}
+								if (newDependentHashModules) {
+									chunkGraph.attachDependentHashModules(
+										hotUpdateChunk,
+										newDependentHashModules
+									);
+								}
+								const renderManifest = compilation.getRenderManifest({
+									chunk: hotUpdateChunk,
+									hash: records.hash,
+									fullHash: records.hash,
+									outputOptions: compilation.outputOptions,
+									moduleTemplates: compilation.moduleTemplates,
+									dependencyTemplates: compilation.dependencyTemplates,
+									codeGenerationResults: compilation.codeGenerationResults,
+									runtimeTemplate: compilation.runtimeTemplate,
+									moduleGraph: compilation.moduleGraph,
+									chunkGraph
+								});
+								for (const entry of renderManifest) {
+									/** @type {string} */
+									let filename;
+									/** @type {AssetInfo} */
+									let assetInfo;
+									if ("filename" in entry) {
+										filename = entry.filename;
+										assetInfo = entry.info;
+									} else {
+										({ path: filename, info: assetInfo } =
+											compilation.getPathWithInfo(
+												entry.filenameTemplate,
+												entry.pathOptions
+											));
+									}
+									const source = entry.render();
+									compilation.additionalChunkAssets.push(filename);
+									compilation.emitAsset(filename, source, {
+										hotModuleReplacement: true,
+										...assetInfo
+									});
+									if (currentChunk) {
+										currentChunk.files.add(filename);
+										compilation.hooks.chunkAsset.call(currentChunk, filename);
+									}
+								}
+								forEachRuntime(newRuntime, runtime => {
+									hotUpdateMainContentByRuntime
+										.get(runtime)
+										.updatedChunkIds.add(chunkId);
+								});
+							}
+						}
+						const completelyRemovedModulesArray = Array.from(
+							completelyRemovedModules
+						);
+						const hotUpdateMainContentByFilename = new Map();
+						for (const {
+							removedChunkIds,
+							removedModules,
+							updatedChunkIds,
+							filename,
+							assetInfo
+						} of hotUpdateMainContentByRuntime.values()) {
+							const old = hotUpdateMainContentByFilename.get(filename);
+							if (
+								old &&
+								(!isSubset(old.removedChunkIds, removedChunkIds) ||
+									!isSubset(old.removedModules, removedModules) ||
+									!isSubset(old.updatedChunkIds, updatedChunkIds))
+							) {
+								compilation.warnings.push(
+									new WebpackError(`HotModuleReplacementPlugin
+The configured output.hotUpdateMainFilename doesn't lead to unique filenames per runtime and HMR update differs between runtimes.
+This might lead to incorrect runtime behavior of the applied update.
+To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`)
+								);
+								for (const chunkId of removedChunkIds)
+									old.removedChunkIds.add(chunkId);
+								for (const chunkId of removedModules)
+									old.removedModules.add(chunkId);
+								for (const chunkId of updatedChunkIds)
+									old.updatedChunkIds.add(chunkId);
+								continue;
+							}
+							hotUpdateMainContentByFilename.set(filename, {
+								removedChunkIds,
+								removedModules,
+								updatedChunkIds,
+								assetInfo
+							});
+						}
+						for (const [
+							filename,
+							{ removedChunkIds, removedModules, updatedChunkIds, assetInfo }
+						] of hotUpdateMainContentByFilename) {
+							const hotUpdateMainJson = {
+								c: Array.from(updatedChunkIds),
+								r: Array.from(removedChunkIds),
+								m:
+									removedModules.size === 0
+										? completelyRemovedModulesArray
+										: completelyRemovedModulesArray.concat(
+												Array.from(removedModules, m =>
+													chunkGraph.getModuleId(m)
+												)
+										  )
+							};
 
-	/**
-	 * @param {Object} options options
-	 * @param {AsyncDependenciesBlock} options.block the async block
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} expression
-	 */
-	asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) {
-		const dep = block.dependencies[0];
-		const module = chunkGraph.moduleGraph.getModule(dep);
-		const ensureChunk = this.blockPromise({
-			block,
-			message: "",
-			chunkGraph,
-			runtimeRequirements
-		});
-		const factory = this.returningFunction(
-			this.moduleRaw({
-				module,
-				chunkGraph,
-				request,
-				runtimeRequirements
-			})
-		);
-		return this.returningFunction(
-			ensureChunk.startsWith("Promise.resolve(")
-				? `${factory}`
-				: `${ensureChunk}.then(${this.returningFunction(factory)})`
-		);
-	}
+							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
+							compilation.emitAsset(filename, source, {
+								hotModuleReplacement: true,
+								...assetInfo
+							});
+						}
+					}
+				);
 
-	/**
-	 * @param {Object} options options
-	 * @param {Dependency} options.dependency the dependency
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} expression
-	 */
-	syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }) {
-		const module = chunkGraph.moduleGraph.getModule(dependency);
-		const factory = this.returningFunction(
-			this.moduleRaw({
-				module,
-				chunkGraph,
-				request,
-				runtimeRequirements
-			})
-		);
-		return this.returningFunction(factory);
-	}
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"HotModuleReplacementPlugin",
+					(chunk, runtimeRequirements) => {
+						runtimeRequirements.add(RuntimeGlobals.hmrDownloadManifest);
+						runtimeRequirements.add(RuntimeGlobals.hmrDownloadUpdateHandlers);
+						runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+						runtimeRequirements.add(RuntimeGlobals.moduleCache);
+						compilation.addRuntimeModule(
+							chunk,
+							new HotModuleReplacementRuntimeModule()
+						);
+					}
+				);
 
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.exportsArgument the name of the exports object
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} statement
-	 */
-	defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
-	}
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("HotModuleReplacementPlugin", parser => {
+						applyModuleHot(parser);
+						applyImportMetaHot(parser);
+					});
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("HotModuleReplacementPlugin", parser => {
+						applyModuleHot(parser);
+					});
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("HotModuleReplacementPlugin", parser => {
+						applyImportMetaHot(parser);
+					});
 
-	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {string} options.publicPath the public path
-	 * @param {RuntimeSpec=} options.runtime runtime
-	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
-	 * @returns {string} the url of the asset
-	 */
-	assetUrl({ publicPath, runtime, module, codeGenerationResults }) {
-		if (!module) {
-			return "data:,";
-		}
-		const codeGen = codeGenerationResults.get(module, runtime);
-		const { data } = codeGen;
-		const url = data.get("url");
-		if (url) return url.toString();
-		const filename = data.get("filename");
-		return publicPath + filename;
+				NormalModule.getCompilationHooks(compilation).loader.tap(
+					"HotModuleReplacementPlugin",
+					context => {
+						context.hot = true;
+					}
+				);
+			}
+		);
 	}
 }
 
-module.exports = RuntimeTemplate;
+module.exports = HotModuleReplacementPlugin;
 
 
 /***/ }),
 
-/***/ 63560:
-/***/ (function(module) {
+/***/ 9597:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -54731,141 +49700,70 @@ module.exports = RuntimeTemplate;
 
 
 
-class SelfModuleFactory {
-	constructor(moduleGraph) {
-		this.moduleGraph = moduleGraph;
-	}
+const Chunk = __webpack_require__(39385);
 
-	create(data, callback) {
-		const module = this.moduleGraph.getParentModule(data.dependencies[0]);
-		callback(null, {
-			module
-		});
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./util/Hash")} Hash */
+
+class HotUpdateChunk extends Chunk {
+	constructor() {
+		super();
 	}
 }
 
-module.exports = SelfModuleFactory;
+module.exports = HotUpdateChunk;
 
 
 /***/ }),
 
-/***/ 48076:
+/***/ 3:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-module.exports = __webpack_require__(96953);
-
-
-/***/ }),
-
-/***/ 71070:
-/***/ (function(__unused_webpack_module, exports) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-
+const ModuleFactory = __webpack_require__(51010);
 
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 /**
- * @param {number} size the size in bytes
- * @returns {string} the formatted size
+ * Ignores error when module is unresolved
  */
-exports.formatSize = size => {
-	if (typeof size !== "number" || Number.isNaN(size) === true) {
-		return "unknown size";
-	}
-
-	if (size <= 0) {
-		return "0 bytes";
-	}
-
-	const abbreviations = ["bytes", "KiB", "MiB", "GiB"];
-	const index = Math.floor(Math.log(size) / Math.log(1024));
-
-	return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${
-		abbreviations[index]
-	}`;
-};
-
-
-/***/ }),
-
-/***/ 97513:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const JavascriptModulesPlugin = __webpack_require__(89464);
-
-/** @typedef {import("./Compilation")} Compilation */
+class IgnoreErrorModuleFactory extends ModuleFactory {
+	/**
+	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
+	 */
+	constructor(normalModuleFactory) {
+		super();
 
-class SourceMapDevToolModuleOptionsPlugin {
-	constructor(options) {
-		this.options = options;
+		this.normalModuleFactory = normalModuleFactory;
 	}
 
 	/**
-	 * @param {Compilation} compilation the compiler instance
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(compilation) {
-		const options = this.options;
-		if (options.module !== false) {
-			compilation.hooks.buildModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSourceMap = true;
-				}
-			);
-			compilation.hooks.runtimeModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSourceMap = true;
-				}
-			);
-		} else {
-			compilation.hooks.buildModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSimpleSourceMap = true;
-				}
-			);
-			compilation.hooks.runtimeModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSimpleSourceMap = true;
-				}
-			);
-		}
-		JavascriptModulesPlugin.getCompilationHooks(compilation).useSourceMap.tap(
-			"SourceMapDevToolModuleOptionsPlugin",
-			() => true
-		);
+	create(data, callback) {
+		this.normalModuleFactory.create(data, (err, result) => {
+			return callback(null, result);
+		});
 	}
 }
 
-module.exports = SourceMapDevToolModuleOptionsPlugin;
+module.exports = IgnoreErrorModuleFactory;
 
 
 /***/ }),
 
-/***/ 63872:
+/***/ 84808:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -54876,565 +49774,304 @@ module.exports = SourceMapDevToolModuleOptionsPlugin;
 
 
 
-const asyncLib = __webpack_require__(78175);
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const ProgressPlugin = __webpack_require__(13216);
-const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
 const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const { relative, dirname } = __webpack_require__(17139);
-const { makePathsAbsolute } = __webpack_require__(82186);
 
-/** @typedef {import("webpack-sources").MapOptions} MapOptions */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./NormalModule").SourceMap} SourceMap */
-/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 
 const validate = createSchemaValidation(
-	__webpack_require__(2885),
-	() => __webpack_require__(30501),
+	__webpack_require__(20858),
+	() => __webpack_require__(3098),
 	{
-		name: "SourceMap DevTool Plugin",
+		name: "Ignore Plugin",
 		baseDataPath: "options"
 	}
 );
-/**
- * @typedef {object} SourceMapTask
- * @property {Source} asset
- * @property {AssetInfo} assetInfo
- * @property {(string | Module)[]} modules
- * @property {string} source
- * @property {string} file
- * @property {SourceMap} sourceMap
- * @property {ItemCacheFacade} cacheItem cache item
- */
-
-/**
- * Escapes regular expression metacharacters
- * @param {string} str String to quote
- * @returns {string} Escaped string
- */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
 
-/**
- * Creating {@link SourceMapTask} for given file
- * @param {string} file current compiled file
- * @param {Source} asset the asset
- * @param {AssetInfo} assetInfo the asset info
- * @param {MapOptions} options source map options
- * @param {Compilation} compilation compilation instance
- * @param {ItemCacheFacade} cacheItem cache item
- * @returns {SourceMapTask | undefined} created task instance or `undefined`
- */
-const getTaskForFile = (
-	file,
-	asset,
-	assetInfo,
-	options,
-	compilation,
-	cacheItem
-) => {
-	let source;
-	/** @type {SourceMap} */
-	let sourceMap;
+class IgnorePlugin {
 	/**
-	 * Check if asset can build source map
+	 * @param {IgnorePluginOptions} options IgnorePlugin options
 	 */
-	if (asset.sourceAndMap) {
-		const sourceAndMap = asset.sourceAndMap(options);
-		sourceMap = /** @type {SourceMap} */ (sourceAndMap.map);
-		source = sourceAndMap.source;
-	} else {
-		sourceMap = /** @type {SourceMap} */ (asset.map(options));
-		source = asset.source();
-	}
-	if (!sourceMap || typeof source !== "string") return;
-	const context = compilation.options.context;
-	const root = compilation.compiler.root;
-	const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root);
-	const modules = sourceMap.sources.map(source => {
-		if (!source.startsWith("webpack://")) return source;
-		source = cachedAbsolutify(source.slice(10));
-		const module = compilation.findModule(source);
-		return module || source;
-	});
+	constructor(options) {
+		validate(options);
+		this.options = options;
 
-	return {
-		file,
-		asset,
-		source,
-		assetInfo,
-		sourceMap,
-		modules,
-		cacheItem
-	};
-};
+		/** @private @type {Function} */
+		this.checkIgnore = this.checkIgnore.bind(this);
+	}
 
-class SourceMapDevToolPlugin {
 	/**
-	 * @param {SourceMapDevToolPluginOptions} [options] options object
-	 * @throws {Error} throws error, if got more than 1 arguments
+	 * Note that if "contextRegExp" is given, both the "resourceRegExp"
+	 * and "contextRegExp" have to match.
+	 *
+	 * @param {ResolveData} resolveData resolve data
+	 * @returns {false|undefined} returns false when the request should be ignored, otherwise undefined
 	 */
-	constructor(options = {}) {
-		validate(options);
+	checkIgnore(resolveData) {
+		if (
+			"checkResource" in this.options &&
+			this.options.checkResource &&
+			this.options.checkResource(resolveData.request, resolveData.context)
+		) {
+			return false;
+		}
 
-		/** @type {string | false} */
-		this.sourceMapFilename = options.filename;
-		/** @type {string | false} */
-		this.sourceMappingURLComment =
-			options.append === false
-				? false
-				: options.append || "\n//# source" + "MappingURL=[url]";
-		/** @type {string | Function} */
-		this.moduleFilenameTemplate =
-			options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]";
-		/** @type {string | Function} */
-		this.fallbackModuleFilenameTemplate =
-			options.fallbackModuleFilenameTemplate ||
-			"webpack://[namespace]/[resourcePath]?[hash]";
-		/** @type {string} */
-		this.namespace = options.namespace || "";
-		/** @type {SourceMapDevToolPluginOptions} */
-		this.options = options;
+		if (
+			"resourceRegExp" in this.options &&
+			this.options.resourceRegExp &&
+			this.options.resourceRegExp.test(resolveData.request)
+		) {
+			if ("contextRegExp" in this.options && this.options.contextRegExp) {
+				// if "contextRegExp" is given,
+				// both the "resourceRegExp" and "contextRegExp" have to match.
+				if (this.options.contextRegExp.test(resolveData.context)) {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
 	}
 
 	/**
 	 * Apply the plugin
-	 * @param {Compiler} compiler compiler instance
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const outputFs = compiler.outputFileSystem;
-		const sourceMapFilename = this.sourceMapFilename;
-		const sourceMappingURLComment = this.sourceMappingURLComment;
-		const moduleFilenameTemplate = this.moduleFilenameTemplate;
-		const namespace = this.namespace;
-		const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate;
-		const requestShortener = compiler.requestShortener;
-		const options = this.options;
-		options.test = options.test || /\.((c|m)?js|css)($|\?)/i;
-
-		const matchObject = ModuleFilenameHelpers.matchObject.bind(
-			undefined,
-			options
-		);
-
-		compiler.hooks.compilation.tap("SourceMapDevToolPlugin", compilation => {
-			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
-
-			compilation.hooks.processAssets.tapAsync(
-				{
-					name: "SourceMapDevToolPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
-					additionalAssets: true
-				},
-				(assets, callback) => {
-					const chunkGraph = compilation.chunkGraph;
-					const cache = compilation.getCache("SourceMapDevToolPlugin");
-					/** @type {Map<string | Module, string>} */
-					const moduleToSourceNameMapping = new Map();
-					/**
-					 * @type {Function}
-					 * @returns {void}
-					 */
-					const reportProgress =
-						ProgressPlugin.getReporter(compilation.compiler) || (() => {});
-
-					/** @type {Map<string, Chunk>} */
-					const fileToChunk = new Map();
-					for (const chunk of compilation.chunks) {
-						for (const file of chunk.files) {
-							fileToChunk.set(file, chunk);
-						}
-						for (const file of chunk.auxiliaryFiles) {
-							fileToChunk.set(file, chunk);
-						}
-					}
+		compiler.hooks.normalModuleFactory.tap("IgnorePlugin", nmf => {
+			nmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+		});
+		compiler.hooks.contextModuleFactory.tap("IgnorePlugin", cmf => {
+			cmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+		});
+	}
+}
 
-					/** @type {string[]} */
-					const files = [];
-					for (const file of Object.keys(assets)) {
-						if (matchObject(file)) {
-							files.push(file);
-						}
-					}
+module.exports = IgnorePlugin;
 
-					reportProgress(0.0);
-					/** @type {SourceMapTask[]} */
-					const tasks = [];
-					let fileIndex = 0;
 
-					asyncLib.each(
-						files,
-						(file, callback) => {
-							const asset = compilation.getAsset(file);
-							if (asset.info.related && asset.info.related.sourceMap) {
-								fileIndex++;
-								return callback();
-							}
-							const cacheItem = cache.getItemCache(
-								file,
-								cache.mergeEtags(
-									cache.getLazyHashedEtag(asset.source),
-									namespace
-								)
-							);
+/***/ }),
 
-							cacheItem.get((err, cacheEntry) => {
-								if (err) {
-									return callback(err);
-								}
-								/**
-								 * If presented in cache, reassigns assets. Cache assets already have source maps.
-								 */
-								if (cacheEntry) {
-									const { assets, assetsInfo } = cacheEntry;
-									for (const cachedFile of Object.keys(assets)) {
-										if (cachedFile === file) {
-											compilation.updateAsset(
-												cachedFile,
-												assets[cachedFile],
-												assetsInfo[cachedFile]
-											);
-										} else {
-											compilation.emitAsset(
-												cachedFile,
-												assets[cachedFile],
-												assetsInfo[cachedFile]
-											);
-										}
-										/**
-										 * Add file to chunk, if not presented there
-										 */
-										if (cachedFile !== file) {
-											const chunk = fileToChunk.get(file);
-											if (chunk !== undefined)
-												chunk.auxiliaryFiles.add(cachedFile);
-										}
-									}
+/***/ 41606:
+/***/ (function(module) {
 
-									reportProgress(
-										(0.5 * ++fileIndex) / files.length,
-										file,
-										"restored cached SourceMap"
-									);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-									return callback();
-								}
 
-								reportProgress(
-									(0.5 * fileIndex) / files.length,
-									file,
-									"generate SourceMap"
-								);
 
-								/** @type {SourceMapTask | undefined} */
-								const task = getTaskForFile(
-									file,
-									asset.source,
-									asset.info,
-									{
-										module: options.module,
-										columns: options.columns
-									},
-									compilation,
-									cacheItem
-								);
+/** @typedef {import("../declarations/WebpackOptions").IgnoreWarningsNormalized} IgnoreWarningsNormalized */
+/** @typedef {import("./Compiler")} Compiler */
 
-								if (task) {
-									const modules = task.modules;
+class IgnoreWarningsPlugin {
+	/**
+	 * @param {IgnoreWarningsNormalized} ignoreWarnings conditions to ignore warnings
+	 */
+	constructor(ignoreWarnings) {
+		this._ignoreWarnings = ignoreWarnings;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("IgnoreWarningsPlugin", compilation => {
+			compilation.hooks.processWarnings.tap(
+				"IgnoreWarningsPlugin",
+				warnings => {
+					return warnings.filter(warning => {
+						return !this._ignoreWarnings.some(ignore =>
+							ignore(warning, compilation)
+						);
+					});
+				}
+			);
+		});
+	}
+}
 
-									for (let idx = 0; idx < modules.length; idx++) {
-										const module = modules[idx];
-										if (!moduleToSourceNameMapping.get(module)) {
-											moduleToSourceNameMapping.set(
-												module,
-												ModuleFilenameHelpers.createFilename(
-													module,
-													{
-														moduleFilenameTemplate: moduleFilenameTemplate,
-														namespace: namespace
-													},
-													{
-														requestShortener,
-														chunkGraph,
-														hashFunction: compilation.outputOptions.hashFunction
-													}
-												)
-											);
-										}
-									}
+module.exports = IgnoreWarningsPlugin;
 
-									tasks.push(task);
-								}
 
-								reportProgress(
-									(0.5 * ++fileIndex) / files.length,
-									file,
-									"generated SourceMap"
-								);
+/***/ }),
 
-								callback();
-							});
-						},
-						err => {
-							if (err) {
-								return callback(err);
-							}
+/***/ 55870:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-							reportProgress(0.5, "resolve sources");
-							/** @type {Set<string>} */
-							const usedNamesSet = new Set(moduleToSourceNameMapping.values());
-							/** @type {Set<string>} */
-							const conflictDetectionSet = new Set();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
 
-							/**
-							 * all modules in defined order (longest identifier first)
-							 * @type {Array<string | Module>}
-							 */
-							const allModules = Array.from(
-								moduleToSourceNameMapping.keys()
-							).sort((a, b) => {
-								const ai = typeof a === "string" ? a : a.identifier();
-								const bi = typeof b === "string" ? b : b.identifier();
-								return ai.length - bi.length;
-							});
 
-							// find modules with conflicting source names
-							for (let idx = 0; idx < allModules.length; idx++) {
-								const module = allModules[idx];
-								let sourceName = moduleToSourceNameMapping.get(module);
-								let hasName = conflictDetectionSet.has(sourceName);
-								if (!hasName) {
-									conflictDetectionSet.add(sourceName);
-									continue;
-								}
 
-								// try the fallback name first
-								sourceName = ModuleFilenameHelpers.createFilename(
-									module,
-									{
-										moduleFilenameTemplate: fallbackModuleFilenameTemplate,
-										namespace: namespace
-									},
-									{
-										requestShortener,
-										chunkGraph,
-										hashFunction: compilation.outputOptions.hashFunction
-									}
-								);
-								hasName = usedNamesSet.has(sourceName);
-								if (!hasName) {
-									moduleToSourceNameMapping.set(module, sourceName);
-									usedNamesSet.add(sourceName);
-									continue;
-								}
+const { ConcatSource } = __webpack_require__(51255);
+const makeSerializable = __webpack_require__(33032);
 
-								// otherwise just append stars until we have a valid name
-								while (hasName) {
-									sourceName += "*";
-									hasName = usedNamesSet.has(sourceName);
-								}
-								moduleToSourceNameMapping.set(module, sourceName);
-								usedNamesSet.add(sourceName);
-							}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
 
-							let taskIndex = 0;
+/**
+ * @param {InitFragment} fragment the init fragment
+ * @param {number} index index
+ * @returns {[InitFragment, number]} tuple with both
+ */
+const extractFragmentIndex = (fragment, index) => [fragment, index];
 
-							asyncLib.each(
-								tasks,
-								(task, callback) => {
-									const assets = Object.create(null);
-									const assetsInfo = Object.create(null);
-									const file = task.file;
-									const chunk = fileToChunk.get(file);
-									const sourceMap = task.sourceMap;
-									const source = task.source;
-									const modules = task.modules;
+/**
+ * @param {[InitFragment, number]} a first pair
+ * @param {[InitFragment, number]} b second pair
+ * @returns {number} sort value
+ */
+const sortFragmentWithIndex = ([a, i], [b, j]) => {
+	const stageCmp = a.stage - b.stage;
+	if (stageCmp !== 0) return stageCmp;
+	const positionCmp = a.position - b.position;
+	if (positionCmp !== 0) return positionCmp;
+	return i - j;
+};
 
-									reportProgress(
-										0.5 + (0.5 * taskIndex) / tasks.length,
-										file,
-										"attach SourceMap"
-									);
+/**
+ * @template Context
+ */
+class InitFragment {
+	/**
+	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {string=} key unique key to avoid emitting the same initialization code twice
+	 * @param {string|Source=} endContent the source code that will be included at the end of the module
+	 */
+	constructor(content, stage, position, key, endContent) {
+		this.content = content;
+		this.stage = stage;
+		this.position = position;
+		this.key = key;
+		this.endContent = endContent;
+	}
 
-									const moduleFilenames = modules.map(m =>
-										moduleToSourceNameMapping.get(m)
-									);
-									sourceMap.sources = moduleFilenames;
-									if (options.noSources) {
-										sourceMap.sourcesContent = undefined;
-									}
-									sourceMap.sourceRoot = options.sourceRoot || "";
-									sourceMap.file = file;
-									const usesContentHash =
-										sourceMapFilename &&
-										/\[contenthash(:\w+)?\]/.test(sourceMapFilename);
+	/**
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
+	 */
+	getContent(context) {
+		return this.content;
+	}
 
-									// If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file`
-									if (usesContentHash && task.assetInfo.contenthash) {
-										const contenthash = task.assetInfo.contenthash;
-										let pattern;
-										if (Array.isArray(contenthash)) {
-											pattern = contenthash.map(quoteMeta).join("|");
-										} else {
-											pattern = quoteMeta(contenthash);
-										}
-										sourceMap.file = sourceMap.file.replace(
-											new RegExp(pattern, "g"),
-											m => "x".repeat(m.length)
-										);
-									}
+	/**
+	 * @param {Context} context context
+	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 */
+	getEndContent(context) {
+		return this.endContent;
+	}
 
-									/** @type {string | false} */
-									let currentSourceMappingURLComment = sourceMappingURLComment;
-									if (
-										currentSourceMappingURLComment !== false &&
-										/\.css($|\?)/i.test(file)
-									) {
-										currentSourceMappingURLComment =
-											currentSourceMappingURLComment.replace(
-												/^\n\/\/(.*)$/,
-												"\n/*$1*/"
-											);
-									}
-									const sourceMapString = JSON.stringify(sourceMap);
-									if (sourceMapFilename) {
-										let filename = file;
-										const sourceMapContentHash =
-											usesContentHash &&
-											/** @type {string} */ (
-												createHash(compilation.outputOptions.hashFunction)
-													.update(sourceMapString)
-													.digest("hex")
-											);
-										const pathParams = {
-											chunk,
-											filename: options.fileContext
-												? relative(
-														outputFs,
-														`/${options.fileContext}`,
-														`/${filename}`
-												  )
-												: filename,
-											contentHash: sourceMapContentHash
-										};
-										const { path: sourceMapFile, info: sourceMapInfo } =
-											compilation.getPathWithInfo(
-												sourceMapFilename,
-												pathParams
-											);
-										const sourceMapUrl = options.publicPath
-											? options.publicPath + sourceMapFile
-											: relative(
-													outputFs,
-													dirname(outputFs, `/${file}`),
-													`/${sourceMapFile}`
-											  );
-										/** @type {Source} */
-										let asset = new RawSource(source);
-										if (currentSourceMappingURLComment !== false) {
-											// Add source map url to compilation asset, if currentSourceMappingURLComment is set
-											asset = new ConcatSource(
-												asset,
-												compilation.getPath(
-													currentSourceMappingURLComment,
-													Object.assign({ url: sourceMapUrl }, pathParams)
-												)
-											);
-										}
-										const assetInfo = {
-											related: { sourceMap: sourceMapFile }
-										};
-										assets[file] = asset;
-										assetsInfo[file] = assetInfo;
-										compilation.updateAsset(file, asset, assetInfo);
-										// Add source map file to compilation assets and chunk files
-										const sourceMapAsset = new RawSource(sourceMapString);
-										const sourceMapAssetInfo = {
-											...sourceMapInfo,
-											development: true
-										};
-										assets[sourceMapFile] = sourceMapAsset;
-										assetsInfo[sourceMapFile] = sourceMapAssetInfo;
-										compilation.emitAsset(
-											sourceMapFile,
-											sourceMapAsset,
-											sourceMapAssetInfo
-										);
-										if (chunk !== undefined)
-											chunk.auxiliaryFiles.add(sourceMapFile);
-									} else {
-										if (currentSourceMappingURLComment === false) {
-											throw new Error(
-												"SourceMapDevToolPlugin: append can't be false when no filename is provided"
-											);
-										}
-										/**
-										 * Add source map as data url to asset
-										 */
-										const asset = new ConcatSource(
-											new RawSource(source),
-											currentSourceMappingURLComment
-												.replace(/\[map\]/g, () => sourceMapString)
-												.replace(
-													/\[url\]/g,
-													() =>
-														`data:application/json;charset=utf-8;base64,${Buffer.from(
-															sourceMapString,
-															"utf-8"
-														).toString("base64")}`
-												)
-										);
-										assets[file] = asset;
-										assetsInfo[file] = undefined;
-										compilation.updateAsset(file, asset);
-									}
+	static addToSource(source, initFragments, context) {
+		if (initFragments.length > 0) {
+			// Sort fragments by position. If 2 fragments have the same position,
+			// use their index.
+			const sortedFragments = initFragments
+				.map(extractFragmentIndex)
+				.sort(sortFragmentWithIndex);
 
-									task.cacheItem.store({ assets, assetsInfo }, err => {
-										reportProgress(
-											0.5 + (0.5 * ++taskIndex) / tasks.length,
-											task.file,
-											"attached SourceMap"
-										);
+			// Deduplicate fragments. If a fragment has no key, it is always included.
+			const keyedFragments = new Map();
+			for (const [fragment] of sortedFragments) {
+				if (typeof fragment.mergeAll === "function") {
+					if (!fragment.key) {
+						throw new Error(
+							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
+						);
+					}
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue === undefined) {
+						keyedFragments.set(fragment.key, fragment);
+					} else if (Array.isArray(oldValue)) {
+						oldValue.push(fragment);
+					} else {
+						keyedFragments.set(fragment.key, [oldValue, fragment]);
+					}
+					continue;
+				} else if (typeof fragment.merge === "function") {
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue !== undefined) {
+						keyedFragments.set(fragment.key, fragment.merge(oldValue));
+						continue;
+					}
+				}
+				keyedFragments.set(fragment.key || Symbol(), fragment);
+			}
 
-										if (err) {
-											return callback(err);
-										}
-										callback();
-									});
-								},
-								err => {
-									reportProgress(1.0);
-									callback(err);
-								}
-							);
-						}
-					);
+			const concatSource = new ConcatSource();
+			const endContents = [];
+			for (let fragment of keyedFragments.values()) {
+				if (Array.isArray(fragment)) {
+					fragment = fragment[0].mergeAll(fragment);
 				}
-			);
-		});
+				concatSource.add(fragment.getContent(context));
+				const endContent = fragment.getEndContent(context);
+				if (endContent) {
+					endContents.push(endContent);
+				}
+			}
+
+			concatSource.add(source);
+			for (const content of endContents.reverse()) {
+				concatSource.add(content);
+			}
+			return concatSource;
+		} else {
+			return source;
+		}
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.content);
+		write(this.stage);
+		write(this.position);
+		write(this.key);
+		write(this.endContent);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.content = read();
+		this.stage = read();
+		this.position = read();
+		this.key = read();
+		this.endContent = read();
 	}
 }
 
-module.exports = SourceMapDevToolPlugin;
+makeSerializable(InitFragment, "webpack/lib/InitFragment");
+
+InitFragment.prototype.merge = undefined;
+
+InitFragment.STAGE_CONSTANTS = 10;
+InitFragment.STAGE_ASYNC_BOUNDARY = 20;
+InitFragment.STAGE_HARMONY_EXPORTS = 30;
+InitFragment.STAGE_HARMONY_IMPORTS = 40;
+InitFragment.STAGE_PROVIDES = 50;
+InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
+InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70;
+
+module.exports = InitFragment;
 
 
 /***/ }),
 
-/***/ 31743:
-/***/ (function(module) {
+/***/ 68257:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -55444,88 +50081,124 @@ module.exports = SourceMapDevToolPlugin;
 
 
 
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-class Stats {
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
+
+class InvalidDependenciesModuleWarning extends WebpackError {
 	/**
-	 * @param {Compilation} compilation webpack compilation
+	 * @param {Module} module module tied to dependency
+	 * @param {Iterable<string>} deps invalid dependencies
 	 */
-	constructor(compilation) {
-		this.compilation = compilation;
-	}
+	constructor(module, deps) {
+		const orderedDeps = deps ? Array.from(deps).sort() : [];
+		const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
+		super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
+Invalid dependencies may lead to broken watching and caching.
+As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.
+Loaders: Pass absolute paths to this.addDependency (existing files), this.addMissingDependency (not existing files), and this.addContextDependency (directories).
+Plugins: Pass absolute paths to fileDependencies (existing files), missingDependencies (not existing files), and contextDependencies (directories).
+Globs: They are not supported. Pass absolute path to the directory as context dependencies.
+The following invalid values have been reported:
+${depsList.slice(0, 3).join("\n")}${
+			depsList.length > 3 ? "\n * and more ..." : ""
+		}`);
 
-	get hash() {
-		return this.compilation.hash;
+		this.name = "InvalidDependenciesModuleWarning";
+		this.details = depsList.slice(3).join("\n");
+		this.module = module;
 	}
+}
 
-	get startTime() {
-		return this.compilation.startTime;
-	}
+makeSerializable(
+	InvalidDependenciesModuleWarning,
+	"webpack/lib/InvalidDependenciesModuleWarning"
+);
 
-	get endTime() {
-		return this.compilation.endTime;
-	}
+module.exports = InvalidDependenciesModuleWarning;
 
-	/**
-	 * @returns {boolean} true if the compilation had a warning
-	 */
-	hasWarnings() {
-		return (
-			this.compilation.warnings.length > 0 ||
-			this.compilation.children.some(child => child.getStats().hasWarnings())
-		);
-	}
 
-	/**
-	 * @returns {boolean} true if the compilation encountered an error
-	 */
-	hasErrors() {
-		return (
-			this.compilation.errors.length > 0 ||
-			this.compilation.children.some(child => child.getStats().hasErrors())
-		);
-	}
+/***/ }),
 
-	/**
-	 * @param {(string|StatsOptions)=} options stats options
-	 * @returns {StatsCompilation} json output
-	 */
-	toJson(options) {
-		options = this.compilation.createStatsOptions(options, {
-			forToString: false
-		});
+/***/ 52329:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const statsFactory = this.compilation.createStatsFactory(options);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
 
-		return statsFactory.create("compilation", this.compilation, {
-			compilation: this.compilation
-		});
-	}
 
-	toString(options) {
-		options = this.compilation.createStatsOptions(options, {
-			forToString: true
-		});
 
-		const statsFactory = this.compilation.createStatsFactory(options);
-		const statsPrinter = this.compilation.createStatsPrinter(options);
+const InnerGraph = __webpack_require__(38988);
 
-		const data = statsFactory.create("compilation", this.compilation, {
-			compilation: this.compilation
-		});
-		const result = statsPrinter.print("compilation", data);
-		return result === undefined ? "" : result;
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class JavascriptMetaInfoPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"JavascriptMetaInfoPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
+						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
+						parser.state.module.buildInfo.usingEval = true;
+						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+						if (currentSymbol) {
+							InnerGraph.addUsage(parser.state, null, currentSymbol);
+						} else {
+							InnerGraph.bailout(parser.state);
+						}
+					});
+					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
+						let topLevelDeclarations =
+							parser.state.module.buildInfo.topLevelDeclarations;
+						if (topLevelDeclarations === undefined) {
+							topLevelDeclarations =
+								parser.state.module.buildInfo.topLevelDeclarations = new Set();
+						}
+						for (const name of parser.scope.definitions.asSet()) {
+							const freeInfo = parser.getFreeInfoFromVariable(name);
+							if (freeInfo === undefined) {
+								topLevelDeclarations.add(name);
+							}
+						}
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("JavascriptMetaInfoPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("JavascriptMetaInfoPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("JavascriptMetaInfoPlugin", handler);
+			}
+		);
 	}
 }
 
-module.exports = Stats;
+module.exports = JavascriptMetaInfoPlugin;
 
 
 /***/ }),
 
-/***/ 1626:
+/***/ 93837:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -55536,1193 +50209,1735 @@ module.exports = Stats;
 
 
 
-const { ConcatSource, PrefixSource } = __webpack_require__(51255);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+const asyncLib = __webpack_require__(78175);
+const EntryDependency = __webpack_require__(3979);
+const { someInIterable } = __webpack_require__(39104);
+const { compareModulesById } = __webpack_require__(29579);
+const { dirname, mkdirp } = __webpack_require__(17139);
 
-const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);
-const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0);
-const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1;
-const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $
-const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
-	NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9
-const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g;
-const INDENT_MULTILINE_REGEX = /^\t/gm;
-const LINE_SEPARATOR_REGEX = /\r?\n/g;
-const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/;
-const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g;
-const COMMENT_END_REGEX = /\*\//g;
-const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
-const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
+/** @typedef {import("./Compiler")} Compiler */
 
 /**
- * @typedef {Object} RenderManifestOptions
- * @property {Chunk} chunk the chunk used to render
- * @property {string} hash
- * @property {string} fullHash
- * @property {OutputOptions} outputOptions
- * @property {CodeGenerationResults} codeGenerationResults
- * @property {{javascript: ModuleTemplate}} moduleTemplates
- * @property {DependencyTemplates} dependencyTemplates
- * @property {RuntimeTemplate} runtimeTemplate
- * @property {ModuleGraph} moduleGraph
- * @property {ChunkGraph} chunkGraph
+ * @typedef {Object} ManifestModuleData
+ * @property {string | number} id
+ * @property {Object} buildMeta
+ * @property {boolean | string[]} exports
  */
 
-/** @typedef {RenderManifestEntryTemplated | RenderManifestEntryStatic} RenderManifestEntry */
+class LibManifestPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-/**
- * @typedef {Object} RenderManifestEntryTemplated
- * @property {function(): Source} render
- * @property {string | function(PathData, AssetInfo=): string} filenameTemplate
- * @property {PathData=} pathOptions
- * @property {AssetInfo=} info
- * @property {string} identifier
- * @property {string=} hash
- * @property {boolean=} auxiliary
- */
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.emit.tapAsync(
+			"LibManifestPlugin",
+			(compilation, callback) => {
+				const moduleGraph = compilation.moduleGraph;
+				asyncLib.forEach(
+					Array.from(compilation.chunks),
+					(chunk, callback) => {
+						if (!chunk.canBeInitial()) {
+							callback();
+							return;
+						}
+						const chunkGraph = compilation.chunkGraph;
+						const targetPath = compilation.getPath(this.options.path, {
+							chunk
+						});
+						const name =
+							this.options.name &&
+							compilation.getPath(this.options.name, {
+								chunk
+							});
+						const content = Object.create(null);
+						for (const module of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesById(chunkGraph)
+						)) {
+							if (
+								this.options.entryOnly &&
+								!someInIterable(
+									moduleGraph.getIncomingConnections(module),
+									c => c.dependency instanceof EntryDependency
+								)
+							) {
+								continue;
+							}
+							const ident = module.libIdent({
+								context: this.options.context || compiler.options.context,
+								associatedObjectForCache: compiler.root
+							});
+							if (ident) {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								const providedExports = exportsInfo.getProvidedExports();
+								/** @type {ManifestModuleData} */
+								const data = {
+									id: chunkGraph.getModuleId(module),
+									buildMeta: module.buildMeta,
+									exports: Array.isArray(providedExports)
+										? providedExports
+										: undefined
+								};
+								content[ident] = data;
+							}
+						}
+						const manifest = {
+							name,
+							type: this.options.type,
+							content
+						};
+						// Apply formatting to content if format flag is true;
+						const manifestContent = this.options.format
+							? JSON.stringify(manifest, null, 2)
+							: JSON.stringify(manifest);
+						const buffer = Buffer.from(manifestContent, "utf8");
+						mkdirp(
+							compiler.intermediateFileSystem,
+							dirname(compiler.intermediateFileSystem, targetPath),
+							err => {
+								if (err) return callback(err);
+								compiler.intermediateFileSystem.writeFile(
+									targetPath,
+									buffer,
+									callback
+								);
+							}
+						);
+					},
+					callback
+				);
+			}
+		);
+	}
+}
+module.exports = LibManifestPlugin;
 
-/**
- * @typedef {Object} RenderManifestEntryStatic
- * @property {function(): Source} render
- * @property {string} filename
- * @property {AssetInfo} info
- * @property {string} identifier
- * @property {string=} hash
- * @property {boolean=} auxiliary
- */
 
-/**
- * @typedef {Object} HasId
- * @property {number | string} id
- */
+/***/ }),
 
-/**
- * @typedef {function(Module, number): boolean} ModuleFilterPredicate
- */
+/***/ 14157:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-class Template {
-	/**
-	 *
-	 * @param {Function} fn a runtime function (.runtime.js) "template"
-	 * @returns {string} the updated and normalized function string
-	 */
-	static getFunctionContent(fn) {
-		return fn
-			.toString()
-			.replace(FUNCTION_CONTENT_REGEX, "")
-			.replace(INDENT_MULTILINE_REGEX, "")
-			.replace(LINE_SEPARATOR_REGEX, "\n");
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
+
+
+const EnableLibraryPlugin = __webpack_require__(91452);
+
+/** @typedef {import("../declarations/WebpackOptions").AuxiliaryComment} AuxiliaryComment */
+/** @typedef {import("../declarations/WebpackOptions").LibraryExport} LibraryExport */
+/** @typedef {import("../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../declarations/WebpackOptions").UmdNamedDefine} UmdNamedDefine */
+/** @typedef {import("./Compiler")} Compiler */
+
+// TODO webpack 6 remove
+class LibraryTemplatePlugin {
 	/**
-	 * @param {string} str the string converted to identifier
-	 * @returns {string} created identifier
-	 */
-	static toIdentifier(str) {
-		if (typeof str !== "string") return "";
-		return str
-			.replace(IDENTIFIER_NAME_REPLACE_REGEX, "_$1")
-			.replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, "_");
-	}
-	/**
-	 *
-	 * @param {string} str string to be converted to commented in bundle code
-	 * @returns {string} returns a commented version of string
+	 * @param {LibraryName} name name of library
+	 * @param {LibraryType} target type of library
+	 * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module
+	 * @param {AuxiliaryComment} auxiliaryComment comment in the UMD wrapper
+	 * @param {LibraryExport} exportProperty which export should be exposed as library
 	 */
-	static toComment(str) {
-		if (!str) return "";
-		return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`;
+	constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) {
+		this.library = {
+			type: target || "var",
+			name,
+			umdNamedDefine,
+			auxiliaryComment,
+			export: exportProperty
+		};
 	}
 
 	/**
-	 *
-	 * @param {string} str string to be converted to "normal comment"
-	 * @returns {string} returns a commented version of string
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static toNormalComment(str) {
-		if (!str) return "";
-		return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`;
+	apply(compiler) {
+		const { output } = compiler.options;
+		output.library = this.library;
+		new EnableLibraryPlugin(this.library.type).apply(compiler);
 	}
+}
+
+module.exports = LibraryTemplatePlugin;
+
+
+/***/ }),
+
+/***/ 22078:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const NormalModule = __webpack_require__(39);
+const createSchemaValidation = __webpack_require__(32540);
+
+/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
 
+const validate = createSchemaValidation(
+	__webpack_require__(24160),
+	() => __webpack_require__(15965),
+	{
+		name: "Loader Options Plugin",
+		baseDataPath: "options"
+	}
+);
+class LoaderOptionsPlugin {
 	/**
-	 * @param {string} str string path to be normalized
-	 * @returns {string} normalized bundle-safe path
+	 * @param {LoaderOptionsPluginOptions} options options object
 	 */
-	static toPath(str) {
-		if (typeof str !== "string") return "";
-		return str
-			.replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, "-")
-			.replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, "");
+	constructor(options = {}) {
+		validate(options);
+		if (typeof options !== "object") options = {};
+		if (!options.test) {
+			options.test = {
+				test: () => true
+			};
+		}
+		this.options = options;
 	}
 
-	// map number to a single character a-z, A-Z or multiple characters if number is too big
 	/**
-	 * @param {number} n number to convert to ident
-	 * @returns {string} returns single character ident
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static numberToIdentifier(n) {
-		if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
-			// use multiple letters
-			return (
-				Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) +
-				Template.numberToIdentifierContinuation(
-					Math.floor(n / NUMBER_OF_IDENTIFIER_START_CHARS)
-				)
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				"LoaderOptionsPlugin",
+				(context, module) => {
+					const resource = module.resource;
+					if (!resource) return;
+					const i = resource.indexOf("?");
+					if (
+						ModuleFilenameHelpers.matchObject(
+							options,
+							i < 0 ? resource : resource.substr(0, i)
+						)
+					) {
+						for (const key of Object.keys(options)) {
+							if (key === "include" || key === "exclude" || key === "test") {
+								continue;
+							}
+							context[key] = options[key];
+						}
+					}
+				}
 			);
-		}
+		});
+	}
+}
 
-		// lower case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
-		}
-		n -= DELTA_A_TO_Z;
+module.exports = LoaderOptionsPlugin;
 
-		// upper case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
-		}
 
-		if (n === DELTA_A_TO_Z) return "_";
-		return "$";
-	}
+/***/ }),
 
-	/**
-	 * @param {number} n number to convert to ident
-	 * @returns {string} returns single character ident
-	 */
-	static numberToIdentifierContinuation(n) {
-		if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
-			// use multiple letters
-			return (
-				Template.numberToIdentifierContinuation(
-					n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
-				) +
-				Template.numberToIdentifierContinuation(
-					Math.floor(n / NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS)
-				)
-			);
-		}
+/***/ 86738:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// lower case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
-		}
-		n -= DELTA_A_TO_Z;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		// upper case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
-		}
-		n -= DELTA_A_TO_Z;
 
-		// numbers
-		if (n < 10) {
-			return `${n}`;
-		}
 
-		if (n === 10) return "_";
-		return "$";
-	}
+const NormalModule = __webpack_require__(39);
 
-	/**
-	 *
-	 * @param {string | string[]} s string to convert to identity
-	 * @returns {string} converted identity
-	 */
-	static indent(s) {
-		if (Array.isArray(s)) {
-			return s.map(Template.indent).join("\n");
-		} else {
-			const str = s.trimRight();
-			if (!str) return "";
-			const ind = str[0] === "\n" ? "" : "\t";
-			return ind + str.replace(/\n([^\n])/g, "\n\t$1");
-		}
-	}
+/** @typedef {import("./Compiler")} Compiler */
 
+class LoaderTargetPlugin {
 	/**
-	 *
-	 * @param {string|string[]} s string to create prefix for
-	 * @param {string} prefix prefix to compose
-	 * @returns {string} returns new prefix string
+	 * @param {string} target the target
 	 */
-	static prefix(s, prefix) {
-		const str = Template.asString(s).trim();
-		if (!str) return "";
-		const ind = str[0] === "\n" ? "" : prefix;
-		return ind + str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	constructor(target) {
+		this.target = target;
 	}
 
 	/**
-	 *
-	 * @param {string|string[]} str string or string collection
-	 * @returns {string} returns a single string from array
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static asString(str) {
-		if (Array.isArray(str)) {
-			return str.join("\n");
-		}
-		return str;
+	apply(compiler) {
+		compiler.hooks.compilation.tap("LoaderTargetPlugin", compilation => {
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				"LoaderTargetPlugin",
+				loaderContext => {
+					loaderContext.target = this.target;
+				}
+			);
+		});
 	}
+}
 
-	/**
-	 * @typedef {Object} WithId
-	 * @property {string|number} id
-	 */
+module.exports = LoaderTargetPlugin;
 
-	/**
-	 * @param {WithId[]} modules a collection of modules to get array bounds for
-	 * @returns {[number, number] | false} returns the upper and lower array bounds
-	 * or false if not every module has a number based id
-	 */
-	static getModulesArrayBounds(modules) {
-		let maxId = -Infinity;
-		let minId = Infinity;
-		for (const module of modules) {
-			const moduleId = module.id;
-			if (typeof moduleId !== "number") return false;
-			if (maxId < moduleId) maxId = moduleId;
-			if (minId > moduleId) minId = moduleId;
-		}
-		if (minId < 16 + ("" + minId).length) {
-			// add minId x ',' instead of 'Array(minId).concat(…)'
-			minId = 0;
-		}
-		// start with -1 because the first module needs no comma
-		let objectOverhead = -1;
-		for (const module of modules) {
-			// module id + colon + comma
-			objectOverhead += `${module.id}`.length + 2;
-		}
-		// number of commas, or when starting non-zero the length of Array(minId).concat()
-		const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId;
-		return arrayOverhead < objectOverhead ? [minId, maxId] : false;
-	}
 
+/***/ }),
+
+/***/ 12856:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { SyncWaterfallHook } = __webpack_require__(41242);
+const util = __webpack_require__(73837);
+const RuntimeGlobals = __webpack_require__(16475);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Module")} Module} */
+/** @typedef {import("./util/Hash")} Hash} */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
+/** @typedef {import("./ModuleGraph")} ModuleGraph} */
+/** @typedef {import("./ChunkGraph")} ChunkGraph} */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions} */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry} */
+
+const getJavascriptModulesPlugin = memoize(() =>
+	__webpack_require__(89464)
+);
+const getJsonpTemplatePlugin = memoize(() =>
+	__webpack_require__(4607)
+);
+const getLoadScriptRuntimeModule = memoize(() =>
+	__webpack_require__(19942)
+);
+
+// TODO webpack 6 remove this class
+class MainTemplate {
 	/**
-	 * @param {ChunkRenderContext} renderContext render context
-	 * @param {Module[]} modules modules to render (should be ordered by identifier)
-	 * @param {function(Module): Source} renderModule function to render a module
-	 * @param {string=} prefix applying prefix strings
-	 * @returns {Source} rendered chunk modules in a Source object
+	 *
+	 * @param {OutputOptions} outputOptions output options for the MainTemplate
+	 * @param {Compilation} compilation the compilation
 	 */
-	static renderChunkModules(renderContext, modules, renderModule, prefix = "") {
-		const { chunkGraph } = renderContext;
-		var source = new ConcatSource();
-		if (modules.length === 0) {
-			return null;
-		}
-		/** @type {{id: string|number, source: Source|string}[]} */
-		const allModules = modules.map(module => {
-			return {
-				id: chunkGraph.getModuleId(module),
-				source: renderModule(module) || "false"
-			};
-		});
-		const bounds = Template.getModulesArrayBounds(allModules);
-		if (bounds) {
-			// Render a spare array
-			const minId = bounds[0];
-			const maxId = bounds[1];
-			if (minId !== 0) {
-				source.add(`Array(${minId}).concat(`);
-			}
-			source.add("[\n");
-			/** @type {Map<string|number, {id: string|number, source: Source|string}>} */
-			const modules = new Map();
-			for (const module of allModules) {
-				modules.set(module.id, module);
-			}
-			for (let idx = minId; idx <= maxId; idx++) {
-				const module = modules.get(idx);
-				if (idx !== minId) {
-					source.add(",\n");
+	constructor(outputOptions, compilation) {
+		/** @type {OutputOptions} */
+		this._outputOptions = outputOptions || {};
+		this.hooks = Object.freeze({
+			renderManifest: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.renderManifest.tap(
+							options,
+							(entries, options) => {
+								if (!options.chunk.hasRuntime()) return entries;
+								return fn(entries, options);
+							}
+						);
+					},
+					"MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST"
+				)
+			},
+			modules: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)"
+					);
 				}
-				source.add(`/* ${idx} */`);
-				if (module) {
-					source.add("\n");
-					source.add(module.source);
+			},
+			moduleObj: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)"
+					);
 				}
-			}
-			source.add("\n" + prefix + "]");
-			if (minId !== 0) {
-				source.add(")");
-			}
-		} else {
-			// Render an object
-			source.add("{\n");
-			for (let i = 0; i < allModules.length; i++) {
-				const module = allModules[i];
-				if (i !== 0) {
-					source.add(",\n");
+			},
+			require: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderRequire.tap(options, fn);
+					},
+					"MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE"
+				)
+			},
+			beforeStartup: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)"
+					);
 				}
-				source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
-				source.add(module.source);
-			}
-			source.add(`\n\n${prefix}}`);
-		}
-		return source;
-	}
+			},
+			startup: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)"
+					);
+				}
+			},
+			afterStartup: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)"
+					);
+				}
+			},
+			render: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.render.tap(options, (source, renderContext) => {
+								if (
+									renderContext.chunkGraph.getNumberOfEntryModules(
+										renderContext.chunk
+									) === 0 ||
+									!renderContext.chunk.hasRuntime()
+								) {
+									return source;
+								}
+								return fn(
+									source,
+									renderContext.chunk,
+									compilation.hash,
+									compilation.moduleTemplates.javascript,
+									compilation.dependencyTemplates
+								);
+							});
+					},
+					"MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER"
+				)
+			},
+			renderWithEntry: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.render.tap(options, (source, renderContext) => {
+								if (
+									renderContext.chunkGraph.getNumberOfEntryModules(
+										renderContext.chunk
+									) === 0 ||
+									!renderContext.chunk.hasRuntime()
+								) {
+									return source;
+								}
+								return fn(source, renderContext.chunk, compilation.hash);
+							});
+					},
+					"MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY"
+				)
+			},
+			assetPath: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.assetPath.tap(options, fn);
+					},
+					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
+				),
+				call: util.deprecate(
+					(filename, options) => {
+						return compilation.getAssetPath(filename, options);
+					},
+					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
+				)
+			},
+			hash: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.fullHash.tap(options, fn);
+					},
+					"MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH"
+				)
+			},
+			hashForChunk: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.chunkHash.tap(options, (chunk, hash) => {
+								if (!chunk.hasRuntime()) return;
+								return fn(hash, chunk);
+							});
+					},
+					"MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			},
+			globalHashPaths: {
+				tap: util.deprecate(
+					() => {},
+					"MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			},
+			globalHash: {
+				tap: util.deprecate(
+					() => {},
+					"MainTemplate.hooks.globalHash has been removed (it's no longer needed)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			},
+			hotBootstrap: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)"
+					);
+				}
+			},
 
-	/**
-	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-	 * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
-	 * @returns {Source} rendered runtime modules in a Source object
-	 */
-	static renderRuntimeModules(runtimeModules, renderContext) {
-		const source = new ConcatSource();
-		for (const module of runtimeModules) {
-			const codeGenerationResults = renderContext.codeGenerationResults;
-			let runtimeSource;
-			if (codeGenerationResults) {
-				runtimeSource = codeGenerationResults.getSource(
-					module,
-					renderContext.chunk.runtime,
-					"runtime"
-				);
-			} else {
-				const codeGenResult = module.codeGeneration({
-					chunkGraph: renderContext.chunkGraph,
-					dependencyTemplates: renderContext.dependencyTemplates,
-					moduleGraph: renderContext.moduleGraph,
-					runtimeTemplate: renderContext.runtimeTemplate,
-					runtime: renderContext.chunk.runtime,
-					codeGenerationResults
-				});
-				if (!codeGenResult) continue;
-				runtimeSource = codeGenResult.sources.get("runtime");
+			// for compatibility:
+			/** @type {SyncWaterfallHook<[string, Chunk, string, ModuleTemplate, DependencyTemplates]>} */
+			bootstrap: new SyncWaterfallHook([
+				"source",
+				"chunk",
+				"hash",
+				"moduleTemplate",
+				"dependencyTemplates"
+			]),
+			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
+			localVars: new SyncWaterfallHook(["source", "chunk", "hash"]),
+			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
+			requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]),
+			/** @type {SyncWaterfallHook<[string, Chunk, string, string]>} */
+			requireEnsure: new SyncWaterfallHook([
+				"source",
+				"chunk",
+				"hash",
+				"chunkIdExpression"
+			]),
+			get jsonpScript() {
+				const hooks =
+					getLoadScriptRuntimeModule().getCompilationHooks(compilation);
+				return hooks.createScript;
+			},
+			get linkPrefetch() {
+				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
+				return hooks.linkPrefetch;
+			},
+			get linkPreload() {
+				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
+				return hooks.linkPreload;
 			}
-			if (runtimeSource) {
-				source.add(Template.toNormalComment(module.identifier()) + "\n");
-				if (!module.shouldIsolate()) {
-					source.add(runtimeSource);
-					source.add("\n\n");
-				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
-					source.add("(() => {\n");
-					source.add(new PrefixSource("\t", runtimeSource));
-					source.add("\n})();\n\n");
-				} else {
-					source.add("!function() {\n");
-					source.add(new PrefixSource("\t", runtimeSource));
-					source.add("\n}();\n\n");
+		});
+
+		this.renderCurrentHashCode = util.deprecate(
+			/**
+			 * @deprecated
+			 * @param {string} hash the hash
+			 * @param {number=} length length of the hash
+			 * @returns {string} generated code
+			 */ (hash, length) => {
+				if (length) {
+					return `${RuntimeGlobals.getFullHash} ? ${
+						RuntimeGlobals.getFullHash
+					}().slice(0, ${length}) : ${hash.slice(0, length)}`;
 				}
-			}
-		}
-		return source;
-	}
+				return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`;
+			},
+			"MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE"
+		);
 
-	/**
-	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-	 * @param {RenderContext} renderContext render context
-	 * @returns {Source} rendered chunk runtime modules in a Source object
-	 */
-	static renderChunkRuntimeModules(runtimeModules, renderContext) {
-		return new PrefixSource(
-			"/******/ ",
-			new ConcatSource(
-				"function(__webpack_require__) { // webpackRuntimeModules\n",
-				this.renderRuntimeModules(runtimeModules, renderContext),
-				"}\n"
-			)
+		this.getPublicPath = util.deprecate(
+			/**
+			 *
+			 * @param {object} options get public path options
+			 * @returns {string} hook call
+			 */ options => {
+				return compilation.getAssetPath(
+					compilation.outputOptions.publicPath,
+					options
+				);
+			},
+			"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
+		);
+
+		this.getAssetPath = util.deprecate(
+			(path, options) => {
+				return compilation.getAssetPath(path, options);
+			},
+			"MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH"
+		);
+
+		this.getAssetPathWithInfo = util.deprecate(
+			(path, options) => {
+				return compilation.getAssetPathWithInfo(path, options);
+			},
+			"MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO"
 		);
 	}
 }
 
-module.exports = Template;
-module.exports.NUMBER_OF_IDENTIFIER_START_CHARS =
-	NUMBER_OF_IDENTIFIER_START_CHARS;
-module.exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
-	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS;
+Object.defineProperty(MainTemplate.prototype, "requireFn", {
+	get: util.deprecate(
+		() => "__webpack_require__",
+		'MainTemplate.requireFn is deprecated (use "__webpack_require__")',
+		"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN"
+	)
+});
+
+Object.defineProperty(MainTemplate.prototype, "outputOptions", {
+	get: util.deprecate(
+		/**
+		 * @this {MainTemplate}
+		 * @returns {OutputOptions} output options
+		 */
+		function () {
+			return this._outputOptions;
+		},
+		"MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
+		"DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
+
+module.exports = MainTemplate;
 
 
 /***/ }),
 
-/***/ 80734:
+/***/ 73208:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Jason Anderson @diurnalist
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { basename, extname } = __webpack_require__(71017);
 const util = __webpack_require__(73837);
-const Chunk = __webpack_require__(39385);
-const Module = __webpack_require__(73208);
-const { parseResource } = __webpack_require__(82186);
+const ChunkGraph = __webpack_require__(64971);
+const DependenciesBlock = __webpack_require__(71040);
+const ModuleGraph = __webpack_require__(99988);
+const RuntimeGlobals = __webpack_require__(16475);
+const { first } = __webpack_require__(93347);
+const { compareChunksById } = __webpack_require__(29579);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ExportsInfo").UsageStateType} UsageStateType */
+/** @typedef {import("./FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
+/** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
+/**
+ * @typedef {Object} SourceContext
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {RuntimeSpec} runtime the runtimes code should be generated for
+ * @property {string=} type the type of source that should be generated
+ */
 
-const prepareId = id => {
-	if (typeof id !== "string") return id;
+/**
+ * @typedef {Object} CodeGenerationContext
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {RuntimeSpec} runtime the runtimes code should be generated for
+ * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
+ */
 
-	if (/^"\s\+*.*\+\s*"$/.test(id)) {
-		const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
+/**
+ * @typedef {Object} ConcatenationBailoutReasonContext
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ */
 
-		return `" + (${match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
-	}
+/**
+ * @typedef {Object} CodeGenerationResult
+ * @property {Map<string, Source>} sources the resulting sources for all source types
+ * @property {Map<string, any>=} data the resulting data for all source types
+ * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
+ * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
+ */
 
-	return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
-};
+/**
+ * @typedef {Object} LibIdentOptions
+ * @property {string} context absolute context path to which lib ident is relative to
+ * @property {Object=} associatedObjectForCache object for caching
+ */
 
-const hashLength = (replacer, handler, assetInfo, hashName) => {
-	const fn = (match, arg, input) => {
-		let result;
-		const length = arg && parseInt(arg, 10);
+/**
+ * @typedef {Object} KnownBuildMeta
+ * @property {string=} moduleArgument
+ * @property {string=} exportsArgument
+ * @property {boolean=} strict
+ * @property {string=} moduleConcatenationBailout
+ * @property {("default" | "namespace" | "flagged" | "dynamic")=} exportsType
+ * @property {(false | "redirect" | "redirect-warn")=} defaultObject
+ * @property {boolean=} strictHarmonyModule
+ * @property {boolean=} async
+ * @property {boolean=} sideEffectFree
+ */
 
-		if (length && handler) {
-			result = handler(length);
-		} else {
-			const hash = replacer(match, arg, input);
+/**
+ * @typedef {Object} NeedBuildContext
+ * @property {Compilation} compilation
+ * @property {FileSystemInfo} fileSystemInfo
+ * @property {Map<string, string | Set<string>>} valueCacheVersions
+ */
 
-			result = length ? hash.slice(0, length) : hash;
-		}
-		if (assetInfo) {
-			assetInfo.immutable = true;
-			if (Array.isArray(assetInfo[hashName])) {
-				assetInfo[hashName] = [...assetInfo[hashName], result];
-			} else if (assetInfo[hashName]) {
-				assetInfo[hashName] = [assetInfo[hashName], result];
-			} else {
-				assetInfo[hashName] = result;
-			}
-		}
-		return result;
-	};
+/** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
 
-	return fn;
-};
+const EMPTY_RESOLVE_OPTIONS = {};
 
-const replacer = (value, allowEmpty) => {
-	const fn = (match, arg, input) => {
-		if (typeof value === "function") {
-			value = value();
-		}
-		if (value === null || value === undefined) {
-			if (!allowEmpty) {
-				throw new Error(
-					`Path variable ${match} not implemented in this context: ${input}`
-				);
-			}
+let debugId = 1000;
 
-			return "";
-		} else {
-			return `${value}`;
-		}
-	};
+const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
+const DEFAULT_TYPES_JS = new Set(["javascript"]);
 
-	return fn;
-};
+const deprecatedNeedRebuild = util.deprecate(
+	(module, context) => {
+		return module.needRebuild(
+			context.fileSystemInfo.getDeprecatedFileTimestamps(),
+			context.fileSystemInfo.getDeprecatedContextTimestamps()
+		);
+	},
+	"Module.needRebuild is deprecated in favor of Module.needBuild",
+	"DEP_WEBPACK_MODULE_NEED_REBUILD"
+);
 
-const deprecationCache = new Map();
-const deprecatedFunction = (() => () => {})();
-const deprecated = (fn, message, code) => {
-	let d = deprecationCache.get(message);
-	if (d === undefined) {
-		d = util.deprecate(deprecatedFunction, message, code);
-		deprecationCache.set(message, d);
-	}
-	return (...args) => {
-		d();
-		return fn(...args);
-	};
-};
+/** @typedef {(requestShortener: RequestShortener) => string} OptimizationBailoutFunction */
 
-/**
- * @param {string | function(PathData, AssetInfo=): string} path the raw path
- * @param {PathData} data context data
- * @param {AssetInfo} assetInfo extra info about the asset (will be written to)
- * @returns {string} the interpolated path
- */
-const replacePathVariables = (path, data, assetInfo) => {
-	const chunkGraph = data.chunkGraph;
+class Module extends DependenciesBlock {
+	/**
+	 * @param {string} type the module type
+	 * @param {string=} context an optional context
+	 * @param {string=} layer an optional layer in which the module is
+	 */
+	constructor(type, context = null, layer = null) {
+		super();
 
-	/** @type {Map<string, Function>} */
-	const replacements = new Map();
+		/** @type {string} */
+		this.type = type;
+		/** @type {string | null} */
+		this.context = context;
+		/** @type {string | null} */
+		this.layer = layer;
+		/** @type {boolean} */
+		this.needId = true;
 
-	// Filename context
-	//
-	// Placeholders
-	//
-	// for /some/path/file.js?query#fragment:
-	// [file] - /some/path/file.js
-	// [query] - ?query
-	// [fragment] - #fragment
-	// [base] - file.js
-	// [path] - /some/path/
-	// [name] - file
-	// [ext] - .js
-	if (typeof data.filename === "string") {
-		const { path: file, query, fragment } = parseResource(data.filename);
+		// Unique Id
+		/** @type {number} */
+		this.debugId = debugId++;
 
-		const ext = extname(file);
-		const base = basename(file);
-		const name = base.slice(0, base.length - ext.length);
-		const path = file.slice(0, file.length - base.length);
+		// Info from Factory
+		/** @type {ResolveOptions} */
+		this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
+		/** @type {object | undefined} */
+		this.factoryMeta = undefined;
+		// TODO refactor this -> options object filled from Factory
+		// TODO webpack 6: use an enum
+		/** @type {boolean} */
+		this.useSourceMap = false;
+		/** @type {boolean} */
+		this.useSimpleSourceMap = false;
 
-		replacements.set("file", replacer(file));
-		replacements.set("query", replacer(query, true));
-		replacements.set("fragment", replacer(fragment, true));
-		replacements.set("path", replacer(path, true));
-		replacements.set("base", replacer(base));
-		replacements.set("name", replacer(name));
-		replacements.set("ext", replacer(ext, true));
-		// Legacy
-		replacements.set(
-			"filebase",
-			deprecated(
-				replacer(base),
-				"[filebase] is now [base]",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
-			)
-		);
+		// Info from Build
+		/** @type {WebpackError[] | undefined} */
+		this._warnings = undefined;
+		/** @type {WebpackError[] | undefined} */
+		this._errors = undefined;
+		/** @type {BuildMeta} */
+		this.buildMeta = undefined;
+		/** @type {Record<string, any>} */
+		this.buildInfo = undefined;
+		/** @type {Dependency[] | undefined} */
+		this.presentationalDependencies = undefined;
+		/** @type {Dependency[] | undefined} */
+		this.codeGenerationDependencies = undefined;
 	}
 
-	// Compilation context
-	//
-	// Placeholders
-	//
-	// [fullhash] - data.hash (3a4b5c6e7f)
-	//
-	// Legacy Placeholders
-	//
-	// [hash] - data.hash (3a4b5c6e7f)
-	if (data.hash) {
-		const hashReplacer = hashLength(
-			replacer(data.hash),
-			data.hashWithLength,
-			assetInfo,
-			"fullhash"
-		);
-
-		replacements.set("fullhash", hashReplacer);
-
-		// Legacy
-		replacements.set(
-			"hash",
-			deprecated(
-				hashReplacer,
-				"[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH"
-			)
-		);
+	// TODO remove in webpack 6
+	// BACKWARD-COMPAT START
+	get id() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.id",
+			"DEP_WEBPACK_MODULE_ID"
+		).getModuleId(this);
 	}
 
-	// Chunk Context
-	//
-	// Placeholders
-	//
-	// [id] - chunk.id (0.js)
-	// [name] - chunk.name (app.js)
-	// [chunkhash] - chunk.hash (7823t4t4.js)
-	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
-	if (data.chunk) {
-		const chunk = data.chunk;
+	set id(value) {
+		if (value === "") {
+			this.needId = false;
+			return;
+		}
+		ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.id",
+			"DEP_WEBPACK_MODULE_ID"
+		).setModuleId(this, value);
+	}
 
-		const contentHashType = data.contentHashType;
+	/**
+	 * @returns {string} the hash of the module
+	 */
+	get hash() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.hash",
+			"DEP_WEBPACK_MODULE_HASH"
+		).getModuleHash(this, undefined);
+	}
 
-		const idReplacer = replacer(chunk.id);
-		const nameReplacer = replacer(chunk.name || chunk.id);
-		const chunkhashReplacer = hashLength(
-			replacer(chunk instanceof Chunk ? chunk.renderedHash : chunk.hash),
-			"hashWithLength" in chunk ? chunk.hashWithLength : undefined,
-			assetInfo,
-			"chunkhash"
-		);
-		const contenthashReplacer = hashLength(
-			replacer(
-				data.contentHash ||
-					(contentHashType &&
-						chunk.contentHash &&
-						chunk.contentHash[contentHashType])
-			),
-			data.contentHashWithLength ||
-				("contentHashWithLength" in chunk && chunk.contentHashWithLength
-					? chunk.contentHashWithLength[contentHashType]
-					: undefined),
-			assetInfo,
-			"contenthash"
-		);
+	/**
+	 * @returns {string} the shortened hash of the module
+	 */
+	get renderedHash() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.renderedHash",
+			"DEP_WEBPACK_MODULE_RENDERED_HASH"
+		).getRenderedModuleHash(this, undefined);
+	}
 
-		replacements.set("id", idReplacer);
-		replacements.set("name", nameReplacer);
-		replacements.set("chunkhash", chunkhashReplacer);
-		replacements.set("contenthash", contenthashReplacer);
+	get profile() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.profile",
+			"DEP_WEBPACK_MODULE_PROFILE"
+		).getProfile(this);
 	}
 
-	// Module Context
-	//
-	// Placeholders
-	//
-	// [id] - module.id (2.png)
-	// [hash] - module.hash (6237543873.png)
-	//
-	// Legacy Placeholders
-	//
-	// [moduleid] - module.id (2.png)
-	// [modulehash] - module.hash (6237543873.png)
-	if (data.module) {
-		const module = data.module;
+	set profile(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.profile",
+			"DEP_WEBPACK_MODULE_PROFILE"
+		).setProfile(this, value);
+	}
 
-		const idReplacer = replacer(() =>
-			prepareId(
-				module instanceof Module ? chunkGraph.getModuleId(module) : module.id
-			)
-		);
-		const moduleHashReplacer = hashLength(
-			replacer(() =>
-				module instanceof Module
-					? chunkGraph.getRenderedModuleHash(module, data.runtime)
-					: module.hash
-			),
-			"hashWithLength" in module ? module.hashWithLength : undefined,
-			assetInfo,
-			"modulehash"
-		);
-		const contentHashReplacer = hashLength(
-			replacer(data.contentHash),
-			undefined,
-			assetInfo,
-			"contenthash"
-		);
+	get index() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index",
+			"DEP_WEBPACK_MODULE_INDEX"
+		).getPreOrderIndex(this);
+	}
 
-		replacements.set("id", idReplacer);
-		replacements.set("modulehash", moduleHashReplacer);
-		replacements.set("contenthash", contentHashReplacer);
-		replacements.set(
-			"hash",
-			data.contentHash ? contentHashReplacer : moduleHashReplacer
-		);
-		// Legacy
-		replacements.set(
-			"moduleid",
-			deprecated(
-				idReplacer,
-				"[moduleid] is now [id]",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID"
-			)
-		);
+	set index(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index",
+			"DEP_WEBPACK_MODULE_INDEX"
+		).setPreOrderIndex(this, value);
 	}
 
-	// Other things
-	if (data.url) {
-		replacements.set("url", replacer(data.url));
+	get index2() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index2",
+			"DEP_WEBPACK_MODULE_INDEX2"
+		).getPostOrderIndex(this);
 	}
-	if (typeof data.runtime === "string") {
-		replacements.set(
-			"runtime",
-			replacer(() => prepareId(data.runtime))
-		);
-	} else {
-		replacements.set("runtime", replacer("_"));
+
+	set index2(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index2",
+			"DEP_WEBPACK_MODULE_INDEX2"
+		).setPostOrderIndex(this, value);
 	}
 
-	if (typeof path === "function") {
-		path = path(data, assetInfo);
+	get depth() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.depth",
+			"DEP_WEBPACK_MODULE_DEPTH"
+		).getDepth(this);
 	}
 
-	path = path.replace(REGEXP, (match, content) => {
-		if (content.length + 2 === match.length) {
-			const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
-			if (!contentMatch) return match;
-			const [, kind, arg] = contentMatch;
-			const replacer = replacements.get(kind);
-			if (replacer !== undefined) {
-				return replacer(match, arg, path);
-			}
-		} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
-			return `[${match.slice(2, -2)}]`;
-		}
-		return match;
-	});
+	set depth(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.depth",
+			"DEP_WEBPACK_MODULE_DEPTH"
+		).setDepth(this, value);
+	}
 
-	return path;
-};
+	get issuer() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.issuer",
+			"DEP_WEBPACK_MODULE_ISSUER"
+		).getIssuer(this);
+	}
 
-const plugin = "TemplatedPathPlugin";
+	set issuer(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.issuer",
+			"DEP_WEBPACK_MODULE_ISSUER"
+		).setIssuer(this, value);
+	}
+
+	get usedExports() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.usedExports",
+			"DEP_WEBPACK_MODULE_USED_EXPORTS"
+		).getUsedExports(this, undefined);
+	}
 
-class TemplatedPathPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @deprecated
+	 * @returns {(string | OptimizationBailoutFunction)[]} list
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(plugin, compilation => {
-			compilation.hooks.assetPath.tap(plugin, replacePathVariables);
-		});
+	get optimizationBailout() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.optimizationBailout",
+			"DEP_WEBPACK_MODULE_OPTIMIZATION_BAILOUT"
+		).getOptimizationBailout(this);
 	}
-}
 
-module.exports = TemplatedPathPlugin;
+	get optional() {
+		return this.isOptional(
+			ModuleGraph.getModuleGraphForModule(
+				this,
+				"Module.optional",
+				"DEP_WEBPACK_MODULE_OPTIONAL"
+			)
+		);
+	}
 
+	addChunk(chunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.addChunk",
+			"DEP_WEBPACK_MODULE_ADD_CHUNK"
+		);
+		if (chunkGraph.isModuleInChunk(this, chunk)) return false;
+		chunkGraph.connectChunkAndModule(chunk, this);
+		return true;
+	}
 
-/***/ }),
+	removeChunk(chunk) {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.removeChunk",
+			"DEP_WEBPACK_MODULE_REMOVE_CHUNK"
+		).disconnectChunkAndModule(chunk, this);
+	}
 
-/***/ 68099:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	isInChunk(chunk) {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.isInChunk",
+			"DEP_WEBPACK_MODULE_IS_IN_CHUNK"
+		).isModuleInChunk(this, chunk);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+	isEntryModule() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.isEntryModule",
+			"DEP_WEBPACK_MODULE_IS_ENTRY_MODULE"
+		).isEntryModule(this);
+	}
 
+	getChunks() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.getChunks",
+			"DEP_WEBPACK_MODULE_GET_CHUNKS"
+		).getModuleChunks(this);
+	}
 
+	getNumberOfChunks() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.getNumberOfChunks",
+			"DEP_WEBPACK_MODULE_GET_NUMBER_OF_CHUNKS"
+		).getNumberOfModuleChunks(this);
+	}
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+	get chunksIterable() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.chunksIterable",
+			"DEP_WEBPACK_MODULE_CHUNKS_ITERABLE"
+		).getOrderedModuleChunksIterable(this, compareChunksById);
+	}
 
-class UnhandledSchemeError extends WebpackError {
 	/**
-	 * @param {string} scheme scheme
-	 * @param {string} resource resource
+	 * @param {string} exportName a name of an export
+	 * @returns {boolean | null} true, if the export is provided why the module.
+	 * null, if it's unknown.
+	 * false, if it's not provided.
 	 */
-	constructor(scheme, resource) {
-		super(
-			`Reading from "${resource}" is not handled by plugins (Unhandled scheme).` +
-				'\nWebpack supports "data:" and "file:" URIs by default.' +
-				`\nYou may need an additional plugin to handle "${scheme}:" URIs.`
-		);
-		this.file = resource;
-		this.name = "UnhandledSchemeError";
+	isProvided(exportName) {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.usedExports",
+			"DEP_WEBPACK_MODULE_USED_EXPORTS"
+		).isExportProvided(this, exportName);
 	}
-}
-
-makeSerializable(
-	UnhandledSchemeError,
-	"webpack/lib/UnhandledSchemeError",
-	"UnhandledSchemeError"
-);
-
-module.exports = UnhandledSchemeError;
-
-
-/***/ }),
-
-/***/ 42495:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	// BACKWARD-COMPAT END
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @returns {string} name of the exports argument
+	 */
+	get exportsArgument() {
+		return (this.buildInfo && this.buildInfo.exportsArgument) || "exports";
+	}
 
+	/**
+	 * @returns {string} name of the module argument
+	 */
+	get moduleArgument() {
+		return (this.buildInfo && this.buildInfo.moduleArgument) || "module";
+	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {boolean} strict the importing module is strict
+	 * @returns {"namespace" | "default-only" | "default-with-named" | "dynamic"} export type
+	 * "namespace": Exports is already a namespace object. namespace = exports.
+	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 */
+	getExportsType(moduleGraph, strict) {
+		switch (this.buildMeta && this.buildMeta.exportsType) {
+			case "flagged":
+				return strict ? "default-with-named" : "namespace";
+			case "namespace":
+				return "namespace";
+			case "default":
+				switch (this.buildMeta.defaultObject) {
+					case "redirect":
+						return "default-with-named";
+					case "redirect-warn":
+						return strict ? "default-only" : "default-with-named";
+					default:
+						return "default-only";
+				}
+			case "dynamic": {
+				if (strict) return "default-with-named";
+				// Try to figure out value of __esModule by following reexports
+				const handleDefault = () => {
+					switch (this.buildMeta.defaultObject) {
+						case "redirect":
+						case "redirect-warn":
+							return "default-with-named";
+						default:
+							return "default-only";
+					}
+				};
+				const exportInfo = moduleGraph.getReadOnlyExportInfo(
+					this,
+					"__esModule"
+				);
+				if (exportInfo.provided === false) {
+					return handleDefault();
+				}
+				const target = exportInfo.getTarget(moduleGraph);
+				if (
+					!target ||
+					!target.export ||
+					target.export.length !== 1 ||
+					target.export[0] !== "__esModule"
+				) {
+					return "dynamic";
+				}
+				switch (
+					target.module.buildMeta &&
+					target.module.buildMeta.exportsType
+				) {
+					case "flagged":
+					case "namespace":
+						return "namespace";
+					case "default":
+						return handleDefault();
+					default:
+						return "dynamic";
+				}
+			}
+			default:
+				return strict ? "default-with-named" : "dynamic";
+		}
+	}
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+	/**
+	 * @param {Dependency} presentationalDependency dependency being tied to module.
+	 * This is a Dependency without edge in the module graph. It's only for presentation.
+	 * @returns {void}
+	 */
+	addPresentationalDependency(presentationalDependency) {
+		if (this.presentationalDependencies === undefined) {
+			this.presentationalDependencies = [];
+		}
+		this.presentationalDependencies.push(presentationalDependency);
+	}
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+	/**
+	 * @param {Dependency} codeGenerationDependency dependency being tied to module.
+	 * This is a Dependency where the code generation result of the referenced module is needed during code generation.
+	 * The Dependency should also be added to normal dependencies via addDependency.
+	 * @returns {void}
+	 */
+	addCodeGenerationDependency(codeGenerationDependency) {
+		if (this.codeGenerationDependencies === undefined) {
+			this.codeGenerationDependencies = [];
+		}
+		this.codeGenerationDependencies.push(codeGenerationDependency);
+	}
 
-class UnsupportedFeatureWarning extends WebpackError {
 	/**
-	 * @param {string} message description of warning
-	 * @param {DependencyLocation} loc location start and end positions of the module
+	 * Removes all dependencies and blocks
+	 * @returns {void}
 	 */
-	constructor(message, loc) {
-		super(message);
+	clearDependenciesAndBlocks() {
+		if (this.presentationalDependencies !== undefined) {
+			this.presentationalDependencies.length = 0;
+		}
+		if (this.codeGenerationDependencies !== undefined) {
+			this.codeGenerationDependencies.length = 0;
+		}
+		super.clearDependenciesAndBlocks();
+	}
 
-		this.name = "UnsupportedFeatureWarning";
-		this.loc = loc;
-		this.hideStack = true;
+	/**
+	 * @param {WebpackError} warning the warning
+	 * @returns {void}
+	 */
+	addWarning(warning) {
+		if (this._warnings === undefined) {
+			this._warnings = [];
+		}
+		this._warnings.push(warning);
 	}
-}
 
-makeSerializable(
-	UnsupportedFeatureWarning,
-	"webpack/lib/UnsupportedFeatureWarning"
-);
+	/**
+	 * @returns {Iterable<WebpackError> | undefined} list of warnings if any
+	 */
+	getWarnings() {
+		return this._warnings;
+	}
 
-module.exports = UnsupportedFeatureWarning;
+	/**
+	 * @returns {number} number of warnings
+	 */
+	getNumberOfWarnings() {
+		return this._warnings !== undefined ? this._warnings.length : 0;
+	}
 
+	/**
+	 * @param {WebpackError} error the error
+	 * @returns {void}
+	 */
+	addError(error) {
+		if (this._errors === undefined) {
+			this._errors = [];
+		}
+		this._errors.push(error);
+	}
 
-/***/ }),
+	/**
+	 * @returns {Iterable<WebpackError> | undefined} list of errors if any
+	 */
+	getErrors() {
+		return this._errors;
+	}
 
-/***/ 36803:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @returns {number} number of errors
+	 */
+	getNumberOfErrors() {
+		return this._errors !== undefined ? this._errors.length : 0;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * removes all warnings and errors
+	 * @returns {void}
+	 */
+	clearWarningsAndErrors() {
+		if (this._warnings !== undefined) {
+			this._warnings.length = 0;
+		}
+		if (this._errors !== undefined) {
+			this._errors.length = 0;
+		}
+	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {boolean} true, if the module is optional
+	 */
+	isOptional(moduleGraph) {
+		let hasConnections = false;
+		for (const r of moduleGraph.getIncomingConnections(this)) {
+			if (
+				!r.dependency ||
+				!r.dependency.optional ||
+				!r.isTargetActive(undefined)
+			) {
+				return false;
+			}
+			hasConnections = true;
+		}
+		return hasConnections;
+	}
 
+	/**
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {Chunk} chunk a chunk
+	 * @param {Chunk=} ignoreChunk chunk to be ignored
+	 * @returns {boolean} true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
+	 */
+	isAccessibleInChunk(chunkGraph, chunk, ignoreChunk) {
+		// Check if module is accessible in ALL chunk groups
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (!this.isAccessibleInChunkGroup(chunkGraph, chunkGroup)) return false;
+		}
+		return true;
+	}
 
-const ConstDependency = __webpack_require__(76911);
+	/**
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ChunkGroup} chunkGroup a chunk group
+	 * @param {Chunk=} ignoreChunk chunk to be ignored
+	 * @returns {boolean} true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"
+	 */
+	isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk) {
+		const queue = new Set([chunkGroup]);
 
-/** @typedef {import("./Compiler")} Compiler */
+		// Check if module is accessible from all items of the queue
+		queueFor: for (const cg of queue) {
+			// 1. If module is in one of the chunks of the group we can continue checking the next items
+			//    because it's accessible.
+			for (const chunk of cg.chunks) {
+				if (chunk !== ignoreChunk && chunkGraph.isModuleInChunk(this, chunk))
+					continue queueFor;
+			}
+			// 2. If the chunk group is initial, we can break here because it's not accessible.
+			if (chunkGroup.isInitial()) return false;
+			// 3. Enqueue all parents because it must be accessible from ALL parents
+			for (const parent of chunkGroup.parentsIterable) queue.add(parent);
+		}
+		// When we processed through the whole list and we didn't bailout, the module is accessible
+		return true;
+	}
 
-class UseStrictPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Chunk} chunk a chunk
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {boolean} true, if the module has any reason why "chunk" should be included
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"UseStrictPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const handler = parser => {
-					parser.hooks.program.tap("UseStrictPlugin", ast => {
-						const firstNode = ast.body[0];
-						if (
-							firstNode &&
-							firstNode.type === "ExpressionStatement" &&
-							firstNode.expression.type === "Literal" &&
-							firstNode.expression.value === "use strict"
-						) {
-							// Remove "use strict" expression. It will be added later by the renderer again.
-							// This is necessary in order to not break the strict mode when webpack prepends code.
-							// @see https://github.com/webpack/webpack/issues/1970
-							const dep = new ConstDependency("", firstNode.range);
-							dep.loc = firstNode.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							parser.state.module.buildInfo.strict = true;
-						}
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("UseStrictPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("UseStrictPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("UseStrictPlugin", handler);
+	hasReasonForChunk(chunk, moduleGraph, chunkGraph) {
+		// check for each reason if we need the chunk
+		for (const [
+			fromModule,
+			connections
+		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
+			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
+			for (const originChunk of chunkGraph.getModuleChunksIterable(
+				fromModule
+			)) {
+				// return true if module this is not reachable from originChunk when ignoring chunk
+				if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk))
+					return true;
 			}
-		);
+		}
+		return false;
 	}
-}
-
-module.exports = UseStrictPlugin;
-
-
-/***/ }),
-
-/***/ 56504:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true if at least one other module depends on this module
+	 */
+	hasReasons(moduleGraph, runtime) {
+		for (const c of moduleGraph.getIncomingConnections(this)) {
+			if (c.isTargetActive(runtime)) return true;
+		}
+		return false;
+	}
 
-const CaseSensitiveModulesWarning = __webpack_require__(77975);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
+	/**
+	 * @returns {string} for debugging
+	 */
+	toString() {
+		return `Module[${this.debugId}: ${this.identifier()}]`;
+	}
 
-class WarnCaseSensitiveModulesPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WarnCaseSensitiveModulesPlugin",
-			compilation => {
-				compilation.hooks.seal.tap("WarnCaseSensitiveModulesPlugin", () => {
-					/** @type {Map<string, Map<string, Module>>} */
-					const moduleWithoutCase = new Map();
-					for (const module of compilation.modules) {
-						const identifier = module.identifier();
-						const lowerIdentifier = identifier.toLowerCase();
-						let map = moduleWithoutCase.get(lowerIdentifier);
-						if (map === undefined) {
-							map = new Map();
-							moduleWithoutCase.set(lowerIdentifier, map);
-						}
-						map.set(identifier, module);
-					}
-					for (const pair of moduleWithoutCase) {
-						const map = pair[1];
-						if (map.size > 1) {
-							compilation.warnings.push(
-								new CaseSensitiveModulesWarning(
-									map.values(),
-									compilation.moduleGraph
-								)
-							);
-						}
-					}
-				});
-			}
+	needBuild(context, callback) {
+		callback(
+			null,
+			!this.buildMeta ||
+				this.needRebuild === Module.prototype.needRebuild ||
+				deprecatedNeedRebuild(this, context)
 		);
 	}
-}
-
-module.exports = WarnCaseSensitiveModulesPlugin;
-
-
-/***/ }),
-
-/***/ 76537:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Compiler")} Compiler */
 
-class WarnDeprecatedOptionPlugin {
 	/**
-	 * Create an instance of the plugin
-	 * @param {string} option the target option
-	 * @param {string | number} value the deprecated option value
-	 * @param {string} suggestion the suggestion replacement
+	 * @deprecated Use needBuild instead
+	 * @param {Map<string, number|null>} fileTimestamps timestamps of files
+	 * @param {Map<string, number|null>} contextTimestamps timestamps of directories
+	 * @returns {boolean} true, if the module needs a rebuild
 	 */
-	constructor(option, value, suggestion) {
-		this.option = option;
-		this.value = value;
-		this.suggestion = suggestion;
+	needRebuild(fileTimestamps, contextTimestamps) {
+		return true;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"WarnDeprecatedOptionPlugin",
-			compilation => {
-				compilation.warnings.push(
-					new DeprecatedOptionWarning(this.option, this.value, this.suggestion)
-				);
+	updateHash(
+		hash,
+		context = {
+			chunkGraph: ChunkGraph.getChunkGraphForModule(
+				this,
+				"Module.updateHash",
+				"DEP_WEBPACK_MODULE_UPDATE_HASH"
+			),
+			runtime: undefined
+		}
+	) {
+		const { chunkGraph, runtime } = context;
+		hash.update(chunkGraph.getModuleGraphHash(this, runtime));
+		if (this.presentationalDependencies !== undefined) {
+			for (const dep of this.presentationalDependencies) {
+				dep.updateHash(hash, context);
 			}
-		);
+		}
+		super.updateHash(hash, context);
 	}
-}
-
-class DeprecatedOptionWarning extends WebpackError {
-	constructor(option, value, suggestion) {
-		super();
 
-		this.name = "DeprecatedOptionWarning";
-		this.message =
-			"configuration\n" +
-			`The value '${value}' for option '${option}' is deprecated. ` +
-			`Use '${suggestion}' instead.`;
+	/**
+	 * @returns {void}
+	 */
+	invalidateBuild() {
+		// should be overridden to support this feature
 	}
-}
-
-module.exports = WarnDeprecatedOptionPlugin;
-
-
-/***/ }),
-
-/***/ 25295:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const NoModeWarning = __webpack_require__(80832);
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
-/** @typedef {import("./Compiler")} Compiler */
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
-class WarnNoModeSetPlugin {
+	/* istanbul ignore next */
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @abstract
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("WarnNoModeSetPlugin", compilation => {
-			compilation.warnings.push(new NoModeWarning());
-		});
+	build(options, compilation, resolver, fs, callback) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
-}
 
-module.exports = WarnNoModeSetPlugin;
+	/**
+	 * @abstract
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		// Better override this method to return the correct types
+		if (this.source === Module.prototype.source) {
+			return DEFAULT_TYPES_UNKNOWN;
+		} else {
+			return DEFAULT_TYPES_JS;
+		}
+	}
 
+	/**
+	 * @abstract
+	 * @deprecated Use codeGeneration() instead
+	 * @param {DependencyTemplates} dependencyTemplates the dependency templates
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {string=} type the type of source that should be generated
+	 * @returns {Source} generated source
+	 */
+	source(dependencyTemplates, runtimeTemplate, type = "javascript") {
+		if (this.codeGeneration === Module.prototype.codeGeneration) {
+			const AbstractMethodError = __webpack_require__(77198);
+			throw new AbstractMethodError();
+		}
+		const chunkGraph = ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.source() is deprecated. Use Compilation.codeGenerationResults.getSource(module, runtime, type) instead",
+			"DEP_WEBPACK_MODULE_SOURCE"
+		);
+		/** @type {CodeGenerationContext} */
+		const codeGenContext = {
+			dependencyTemplates,
+			runtimeTemplate,
+			moduleGraph: chunkGraph.moduleGraph,
+			chunkGraph,
+			runtime: undefined,
+			codeGenerationResults: undefined
+		};
+		const sources = this.codeGeneration(codeGenContext).sources;
+		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
+	}
 
-/***/ }),
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
-/***/ 65193:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return null;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 */
+	nameForCondition() {
+		return null;
+	}
 
+	/**
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(context) {
+		return `Module Concatenation is not implemented for ${this.constructor.name}`;
+	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		return true;
+	}
 
-const { groupBy } = __webpack_require__(84953);
-const createSchemaValidation = __webpack_require__(32540);
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		// Best override this method
+		const sources = new Map();
+		for (const type of this.getSourceTypes()) {
+			if (type !== "unknown") {
+				sources.set(
+					type,
+					this.source(
+						context.dependencyTemplates,
+						context.runtimeTemplate,
+						type
+					)
+				);
+			}
+		}
+		return {
+			sources,
+			runtimeRequirements: new Set([
+				RuntimeGlobals.module,
+				RuntimeGlobals.exports,
+				RuntimeGlobals.require
+			])
+		};
+	}
 
-/** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+	/**
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
+	 */
+	chunkCondition(chunk, compilation) {
+		return true;
+	}
 
-const validate = createSchemaValidation(
-	__webpack_require__(16711),
-	() => __webpack_require__(44246),
-	{
-		name: "Watch Ignore Plugin",
-		baseDataPath: "options"
+	hasChunkCondition() {
+		return this.chunkCondition !== Module.prototype.chunkCondition;
 	}
-);
 
-const IGNORE_TIME_ENTRY = "ignore";
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		this.type = module.type;
+		this.layer = module.layer;
+		this.context = module.context;
+		this.factoryMeta = module.factoryMeta;
+		this.resolveOptions = module.resolveOptions;
+	}
 
-class IgnoringWatchFileSystem {
 	/**
-	 * @param {WatchFileSystem} wfs original file system
-	 * @param {(string|RegExp)[]} paths ignored paths
+	 * Module should be unsafe cached. Get data that's needed for that.
+	 * This data will be passed to restoreFromUnsafeCache later.
+	 * @returns {object} cached data
 	 */
-	constructor(wfs, paths) {
-		this.wfs = wfs;
-		this.paths = paths;
+	getUnsafeCacheData() {
+		return {
+			factoryMeta: this.factoryMeta,
+			resolveOptions: this.resolveOptions
+		};
 	}
 
-	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
-		files = Array.from(files);
-		dirs = Array.from(dirs);
-		const ignored = path =>
-			this.paths.some(p =>
-				p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0
-			);
+	/**
+	 * restore unsafe cache data
+	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 */
+	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this.factoryMeta = unsafeCacheData.factoryMeta;
+		this.resolveOptions = unsafeCacheData.resolveOptions;
+	}
 
-		const [ignoredFiles, notIgnoredFiles] = groupBy(files, ignored);
-		const [ignoredDirs, notIgnoredDirs] = groupBy(dirs, ignored);
+	/**
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		this.factoryMeta = undefined;
+		this.resolveOptions = undefined;
+	}
 
-		const watcher = this.wfs.watch(
-			notIgnoredFiles,
-			notIgnoredDirs,
-			missing,
-			startTime,
-			options,
-			(err, fileTimestamps, dirTimestamps, changedFiles, removedFiles) => {
-				if (err) return callback(err);
-				for (const path of ignoredFiles) {
-					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
+	/**
+	 * @returns {Source | null} the original source for the module before webpack transformation
+	 */
+	originalSource() {
+		return null;
+	}
 
-				for (const path of ignoredDirs) {
-					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
+	/**
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 */
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {}
 
-				callback(
-					err,
-					fileTimestamps,
-					dirTimestamps,
-					changedFiles,
-					removedFiles
-				);
-			},
-			callbackUndelayed
+	serialize(context) {
+		const { write } = context;
+		write(this.type);
+		write(this.layer);
+		write(this.context);
+		write(this.resolveOptions);
+		write(this.factoryMeta);
+		write(this.useSourceMap);
+		write(this.useSimpleSourceMap);
+		write(
+			this._warnings !== undefined && this._warnings.length === 0
+				? undefined
+				: this._warnings
+		);
+		write(
+			this._errors !== undefined && this._errors.length === 0
+				? undefined
+				: this._errors
 		);
+		write(this.buildMeta);
+		write(this.buildInfo);
+		write(this.presentationalDependencies);
+		write(this.codeGenerationDependencies);
+		super.serialize(context);
+	}
 
-		return {
-			close: () => watcher.close(),
-			pause: () => watcher.pause(),
-			getContextTimeInfoEntries: () => {
-				const dirTimestamps = watcher.getContextTimeInfoEntries();
-				for (const path of ignoredDirs) {
-					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
-				return dirTimestamps;
-			},
-			getFileTimeInfoEntries: () => {
-				const fileTimestamps = watcher.getFileTimeInfoEntries();
-				for (const path of ignoredFiles) {
-					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
-				return fileTimestamps;
-			},
-			getInfo:
-				watcher.getInfo &&
-				(() => {
-					const info = watcher.getInfo();
-					const { fileTimeInfoEntries, contextTimeInfoEntries } = info;
-					for (const path of ignoredFiles) {
-						fileTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
-					}
-					for (const path of ignoredDirs) {
-						contextTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
-					}
-					return info;
-				})
-		};
+	deserialize(context) {
+		const { read } = context;
+		this.type = read();
+		this.layer = read();
+		this.context = read();
+		this.resolveOptions = read();
+		this.factoryMeta = read();
+		this.useSourceMap = read();
+		this.useSimpleSourceMap = read();
+		this._warnings = read();
+		this._errors = read();
+		this.buildMeta = read();
+		this.buildInfo = read();
+		this.presentationalDependencies = read();
+		this.codeGenerationDependencies = read();
+		super.deserialize(context);
 	}
 }
 
-class WatchIgnorePlugin {
-	/**
-	 * @param {WatchIgnorePluginOptions} options options
-	 */
-	constructor(options) {
-		validate(options);
-		this.paths = options.paths;
+makeSerializable(Module, "webpack/lib/Module");
+
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "hasEqualsChunks", {
+	get() {
+		throw new Error(
+			"Module.hasEqualsChunks was renamed (use hasEqualChunks instead)"
+		);
 	}
+});
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.afterEnvironment.tap("WatchIgnorePlugin", () => {
-			compiler.watchFileSystem = new IgnoringWatchFileSystem(
-				compiler.watchFileSystem,
-				this.paths
-			);
-		});
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "isUsed", {
+	get() {
+		throw new Error(
+			"Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)"
+		);
 	}
-}
+});
 
-module.exports = WatchIgnorePlugin;
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "errors", {
+	get: util.deprecate(
+		/**
+		 * @this {Module}
+		 * @returns {WebpackError[]} array
+		 */
+		function () {
+			if (this._errors === undefined) {
+				this._errors = [];
+			}
+			return this._errors;
+		},
+		"Module.errors was removed (use getErrors instead)",
+		"DEP_WEBPACK_MODULE_ERRORS"
+	)
+});
+
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "warnings", {
+	get: util.deprecate(
+		/**
+		 * @this {Module}
+		 * @returns {WebpackError[]} array
+		 */
+		function () {
+			if (this._warnings === undefined) {
+				this._warnings = [];
+			}
+			return this._warnings;
+		},
+		"Module.warnings was removed (use getWarnings instead)",
+		"DEP_WEBPACK_MODULE_WARNINGS"
+	)
+});
+
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "used", {
+	get() {
+		throw new Error(
+			"Module.used was refactored (use ModuleGraph.getUsedExports instead)"
+		);
+	},
+	set(value) {
+		throw new Error(
+			"Module.used was refactored (use ModuleGraph.setUsedExports instead)"
+		);
+	}
+});
+
+module.exports = Module;
 
 
 /***/ }),
 
-/***/ 84275:
+/***/ 21305:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -56733,645 +51948,594 @@ module.exports = WatchIgnorePlugin;
 
 
 
-const Stats = __webpack_require__(31743);
-
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
-
-/**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
- */
+const { cutOffLoaderExecution } = __webpack_require__(59985);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-class Watching {
+class ModuleBuildError extends WebpackError {
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @param {WatchOptions} watchOptions options
-	 * @param {Callback<Stats>} handler completion handler
+	 * @param {string | Error&any} err error thrown
+	 * @param {{from?: string|null}} info additional info
 	 */
-	constructor(compiler, watchOptions, handler) {
-		this.startTime = null;
-		this.invalid = false;
-		this.handler = handler;
-		/** @type {Callback<void>[]} */
-		this.callbacks = [];
-		/** @type {Callback<void>[] | undefined} */
-		this._closeCallbacks = undefined;
-		this.closed = false;
-		this.suspended = false;
-		this.blocked = false;
-		this._isBlocked = () => false;
-		this._onChange = () => {};
-		this._onInvalid = () => {};
-		if (typeof watchOptions === "number") {
-			this.watchOptions = {
-				aggregateTimeout: watchOptions
-			};
-		} else if (watchOptions && typeof watchOptions === "object") {
-			this.watchOptions = { ...watchOptions };
-		} else {
-			this.watchOptions = {};
-		}
-		if (typeof this.watchOptions.aggregateTimeout !== "number") {
-			this.watchOptions.aggregateTimeout = 20;
-		}
-		this.compiler = compiler;
-		this.running = false;
-		this._initial = true;
-		this._invalidReported = true;
-		this._needRecords = true;
-		this.watcher = undefined;
-		this.pausedWatcher = undefined;
-		/** @type {Set<string>} */
-		this._collectedChangedFiles = undefined;
-		/** @type {Set<string>} */
-		this._collectedRemovedFiles = undefined;
-		this._done = this._done.bind(this);
-		process.nextTick(() => {
-			if (this._initial) this._invalidate();
-		});
-	}
+	constructor(err, { from = null } = {}) {
+		let message = "Module build failed";
+		let details = undefined;
 
-	/**
-	 * @param {ReadonlySet<string>} changedFiles changed files
-	 * @param {ReadonlySet<string>} removedFiles removed files
-	 */
-	_mergeWithCollected(changedFiles, removedFiles) {
-		if (!changedFiles) return;
-		if (!this._collectedChangedFiles) {
-			this._collectedChangedFiles = new Set(changedFiles);
-			this._collectedRemovedFiles = new Set(removedFiles);
+		if (from) {
+			message += ` (from ${from}):\n`;
 		} else {
-			for (const file of changedFiles) {
-				this._collectedChangedFiles.add(file);
-				this._collectedRemovedFiles.delete(file);
-			}
-			for (const file of removedFiles) {
-				this._collectedChangedFiles.delete(file);
-				this._collectedRemovedFiles.add(file);
-			}
+			message += ": ";
 		}
-	}
 
-	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
-	 * @param {ReadonlySet<string>=} changedFiles changed files
-	 * @param {ReadonlySet<string>=} removedFiles removed files
-	 * @returns {void}
-	 */
-	_go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
-		this._initial = false;
-		if (this.startTime === null) this.startTime = Date.now();
-		this.running = true;
-		if (this.watcher) {
-			this.pausedWatcher = this.watcher;
-			this.lastWatcherStartTime = Date.now();
-			this.watcher.pause();
-			this.watcher = null;
-		} else if (!this.lastWatcherStartTime) {
-			this.lastWatcherStartTime = Date.now();
-		}
-		this.compiler.fsStartTime = Date.now();
-		if (
-			changedFiles &&
-			removedFiles &&
-			fileTimeInfoEntries &&
-			contextTimeInfoEntries
-		) {
-			this._mergeWithCollected(changedFiles, removedFiles);
-			this.compiler.fileTimestamps = fileTimeInfoEntries;
-			this.compiler.contextTimestamps = contextTimeInfoEntries;
-		} else if (this.pausedWatcher) {
-			if (this.pausedWatcher.getInfo) {
-				const {
-					changes,
-					removals,
-					fileTimeInfoEntries,
-					contextTimeInfoEntries
-				} = this.pausedWatcher.getInfo();
-				this._mergeWithCollected(changes, removals);
-				this.compiler.fileTimestamps = fileTimeInfoEntries;
-				this.compiler.contextTimestamps = contextTimeInfoEntries;
+		if (err !== null && typeof err === "object") {
+			if (typeof err.stack === "string" && err.stack) {
+				const stack = cutOffLoaderExecution(err.stack);
+
+				if (!err.hideStack) {
+					message += stack;
+				} else {
+					details = stack;
+
+					if (typeof err.message === "string" && err.message) {
+						message += err.message;
+					} else {
+						message += err;
+					}
+				}
+			} else if (typeof err.message === "string" && err.message) {
+				message += err.message;
 			} else {
-				this._mergeWithCollected(
-					this.pausedWatcher.getAggregatedChanges &&
-						this.pausedWatcher.getAggregatedChanges(),
-					this.pausedWatcher.getAggregatedRemovals &&
-						this.pausedWatcher.getAggregatedRemovals()
-				);
-				this.compiler.fileTimestamps =
-					this.pausedWatcher.getFileTimeInfoEntries();
-				this.compiler.contextTimestamps =
-					this.pausedWatcher.getContextTimeInfoEntries();
+				message += String(err);
 			}
+		} else {
+			message += String(err);
 		}
-		this.compiler.modifiedFiles = this._collectedChangedFiles;
-		this._collectedChangedFiles = undefined;
-		this.compiler.removedFiles = this._collectedRemovedFiles;
-		this._collectedRemovedFiles = undefined;
-
-		const run = () => {
-			if (this.compiler.idle) {
-				return this.compiler.cache.endIdle(err => {
-					if (err) return this._done(err);
-					this.compiler.idle = false;
-					run();
-				});
-			}
-			if (this._needRecords) {
-				return this.compiler.readRecords(err => {
-					if (err) return this._done(err);
 
-					this._needRecords = false;
-					run();
-				});
-			}
-			this.invalid = false;
-			this._invalidReported = false;
-			this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
-				if (err) return this._done(err);
-				const onCompiled = (err, compilation) => {
-					if (err) return this._done(err, compilation);
-					if (this.invalid) return this._done(null, compilation);
+		super(message);
 
-					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
-						return this._done(null, compilation);
-					}
+		this.name = "ModuleBuildError";
+		this.details = details;
+		this.error = err;
+	}
 
-					process.nextTick(() => {
-						const logger = compilation.getLogger("webpack.Compiler");
-						logger.time("emitAssets");
-						this.compiler.emitAssets(compilation, err => {
-							logger.timeEnd("emitAssets");
-							if (err) return this._done(err, compilation);
-							if (this.invalid) return this._done(null, compilation);
+	serialize(context) {
+		const { write } = context;
 
-							logger.time("emitRecords");
-							this.compiler.emitRecords(err => {
-								logger.timeEnd("emitRecords");
-								if (err) return this._done(err, compilation);
+		write(this.error);
 
-								if (compilation.hooks.needAdditionalPass.call()) {
-									compilation.needAdditionalPass = true;
+		super.serialize(context);
+	}
 
-									compilation.startTime = this.startTime;
-									compilation.endTime = Date.now();
-									logger.time("done hook");
-									const stats = new Stats(compilation);
-									this.compiler.hooks.done.callAsync(stats, err => {
-										logger.timeEnd("done hook");
-										if (err) return this._done(err, compilation);
+	deserialize(context) {
+		const { read } = context;
 
-										this.compiler.hooks.additionalPass.callAsync(err => {
-											if (err) return this._done(err, compilation);
-											this.compiler.compile(onCompiled);
-										});
-									});
-									return;
-								}
-								return this._done(null, compilation);
-							});
-						});
-					});
-				};
-				this.compiler.compile(onCompiled);
-			});
-		};
+		this.error = read();
 
-		run();
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {Stats} the compilation stats
-	 */
-	_getStats(compilation) {
-		const stats = new Stats(compilation);
-		return stats;
-	}
+makeSerializable(ModuleBuildError, "webpack/lib/ModuleBuildError");
 
-	/**
-	 * @param {Error=} err an optional error
-	 * @param {Compilation=} compilation the compilation
-	 * @returns {void}
-	 */
-	_done(err, compilation) {
-		this.running = false;
+module.exports = ModuleBuildError;
 
-		const logger = compilation && compilation.getLogger("webpack.Watching");
 
-		let stats = null;
+/***/ }),
 
-		const handleError = (err, cbs) => {
-			this.compiler.hooks.failed.call(err);
-			this.compiler.cache.beginIdle();
-			this.compiler.idle = true;
-			this.handler(err, stats);
-			if (!cbs) {
-				cbs = this.callbacks;
-				this.callbacks = [];
-			}
-			for (const cb of cbs) cb(err);
-		};
+/***/ 67409:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (
-			this.invalid &&
-			!this.suspended &&
-			!this.blocked &&
-			!(this._isBlocked() && (this.blocked = true))
-		) {
-			if (compilation) {
-				logger.time("storeBuildDependencies");
-				this.compiler.cache.storeBuildDependencies(
-					compilation.buildDependencies,
-					err => {
-						logger.timeEnd("storeBuildDependencies");
-						if (err) return handleError(err);
-						this._go();
-					}
-				);
-			} else {
-				this._go();
-			}
-			return;
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (compilation) {
-			compilation.startTime = this.startTime;
-			compilation.endTime = Date.now();
-			stats = new Stats(compilation);
-		}
-		this.startTime = null;
-		if (err) return handleError(err);
 
-		const cbs = this.callbacks;
-		this.callbacks = [];
-		logger.time("done hook");
-		this.compiler.hooks.done.callAsync(stats, err => {
-			logger.timeEnd("done hook");
-			if (err) return handleError(err, cbs);
-			this.handler(null, stats);
-			logger.time("storeBuildDependencies");
-			this.compiler.cache.storeBuildDependencies(
-				compilation.buildDependencies,
-				err => {
-					logger.timeEnd("storeBuildDependencies");
-					if (err) return handleError(err, cbs);
-					logger.time("beginIdle");
-					this.compiler.cache.beginIdle();
-					this.compiler.idle = true;
-					logger.timeEnd("beginIdle");
-					process.nextTick(() => {
-						if (!this.closed) {
-							this.watch(
-								compilation.fileDependencies,
-								compilation.contextDependencies,
-								compilation.missingDependencies
-							);
-						}
-					});
-					for (const cb of cbs) cb(null);
-					this.compiler.hooks.afterDone.call(stats);
-				}
-			);
-		});
-	}
 
-	/**
-	 * @param {Iterable<string>} files watched files
-	 * @param {Iterable<string>} dirs watched directories
-	 * @param {Iterable<string>} missing watched existence entries
-	 * @returns {void}
-	 */
-	watch(files, dirs, missing) {
-		this.pausedWatcher = null;
-		this.watcher = this.compiler.watchFileSystem.watch(
-			files,
-			dirs,
-			missing,
-			this.lastWatcherStartTime,
-			this.watchOptions,
-			(
-				err,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changedFiles,
-				removedFiles
-			) => {
-				if (err) {
-					this.compiler.modifiedFiles = undefined;
-					this.compiler.removedFiles = undefined;
-					this.compiler.fileTimestamps = undefined;
-					this.compiler.contextTimestamps = undefined;
-					this.compiler.fsStartTime = undefined;
-					return this.handler(err);
-				}
-				this._invalidate(
-					fileTimeInfoEntries,
-					contextTimeInfoEntries,
-					changedFiles,
-					removedFiles
-				);
-				this._onChange();
-			},
-			(fileName, changeTime) => {
-				if (!this._invalidReported) {
-					this._invalidReported = true;
-					this.compiler.hooks.invalid.call(fileName, changeTime);
-				}
-				this._onInvalid();
-			}
-		);
-	}
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
+class ModuleDependencyError extends WebpackError {
 	/**
-	 * @param {Callback<void>=} callback signals when the build has completed again
-	 * @returns {void}
+	 * Creates an instance of ModuleDependencyError.
+	 * @param {Module} module module tied to dependency
+	 * @param {Error} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
 	 */
-	invalidate(callback) {
-		if (callback) {
-			this.callbacks.push(callback);
-		}
-		if (!this._invalidReported) {
-			this._invalidReported = true;
-			this.compiler.hooks.invalid.call(null, Date.now());
-		}
-		this._onChange();
-		this._invalidate();
-	}
+	constructor(module, err, loc) {
+		super(err.message);
 
-	_invalidate(
-		fileTimeInfoEntries,
-		contextTimeInfoEntries,
-		changedFiles,
-		removedFiles
-	) {
-		if (this.suspended || (this._isBlocked() && (this.blocked = true))) {
-			this._mergeWithCollected(changedFiles, removedFiles);
-			return;
-		}
+		this.name = "ModuleDependencyError";
+		this.details =
+			err && !(/** @type {any} */ (err).hideStack)
+				? err.stack.split("\n").slice(1).join("\n")
+				: undefined;
+		this.module = module;
+		this.loc = loc;
+		/** error is not (de)serialized, so it might be undefined after deserialization */
+		this.error = err;
 
-		if (this.running) {
-			this._mergeWithCollected(changedFiles, removedFiles);
-			this.invalid = true;
-		} else {
-			this._go(
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changedFiles,
-				removedFiles
-			);
+		if (err && /** @type {any} */ (err).hideStack) {
+			this.stack =
+				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
 		}
 	}
+}
 
-	suspend() {
-		this.suspended = true;
-	}
+module.exports = ModuleDependencyError;
+
+
+/***/ }),
+
+/***/ 29656:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	resume() {
-		if (this.suspended) {
-			this.suspended = false;
-			this._invalidate();
-		}
-	}
 
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
+
+class ModuleDependencyWarning extends WebpackError {
 	/**
-	 * @param {Callback<void>} callback signals when the watcher is closed
-	 * @returns {void}
+	 * @param {Module} module module tied to dependency
+	 * @param {Error} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
 	 */
-	close(callback) {
-		if (this._closeCallbacks) {
-			if (callback) {
-				this._closeCallbacks.push(callback);
-			}
-			return;
-		}
-		const finalCallback = (err, compilation) => {
-			this.running = false;
-			this.compiler.running = false;
-			this.compiler.watching = undefined;
-			this.compiler.watchMode = false;
-			this.compiler.modifiedFiles = undefined;
-			this.compiler.removedFiles = undefined;
-			this.compiler.fileTimestamps = undefined;
-			this.compiler.contextTimestamps = undefined;
-			this.compiler.fsStartTime = undefined;
-			const shutdown = err => {
-				this.compiler.hooks.watchClose.call();
-				const closeCallbacks = this._closeCallbacks;
-				this._closeCallbacks = undefined;
-				for (const cb of closeCallbacks) cb(err);
-			};
-			if (compilation) {
-				const logger = compilation.getLogger("webpack.Watching");
-				logger.time("storeBuildDependencies");
-				this.compiler.cache.storeBuildDependencies(
-					compilation.buildDependencies,
-					err2 => {
-						logger.timeEnd("storeBuildDependencies");
-						shutdown(err || err2);
-					}
-				);
-			} else {
-				shutdown(err);
-			}
-		};
+	constructor(module, err, loc) {
+		super(err ? err.message : "");
 
-		this.closed = true;
-		if (this.watcher) {
-			this.watcher.close();
-			this.watcher = null;
-		}
-		if (this.pausedWatcher) {
-			this.pausedWatcher.close();
-			this.pausedWatcher = null;
-		}
-		this._closeCallbacks = [];
-		if (callback) {
-			this._closeCallbacks.push(callback);
-		}
-		if (this.running) {
-			this.invalid = true;
-			this._done = finalCallback;
-		} else {
-			finalCallback();
+		this.name = "ModuleDependencyWarning";
+		this.details =
+			err && !(/** @type {any} */ (err).hideStack)
+				? err.stack.split("\n").slice(1).join("\n")
+				: undefined;
+		this.module = module;
+		this.loc = loc;
+		/** error is not (de)serialized, so it might be undefined after deserialization */
+		this.error = err;
+
+		if (err && /** @type {any} */ (err).hideStack) {
+			this.stack =
+				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
 		}
 	}
 }
 
-module.exports = Watching;
+makeSerializable(
+	ModuleDependencyWarning,
+	"webpack/lib/ModuleDependencyWarning"
+);
+
+module.exports = ModuleDependencyWarning;
 
 
 /***/ }),
 
-/***/ 53799:
+/***/ 23744:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Jarid Margolin @jaridmargolin
+	Author Tobias Koppers @sokra
 */
 
 
 
-const inspect = (__webpack_require__(73837).inspect.custom);
+const { cleanUp } = __webpack_require__(59985);
+const WebpackError = __webpack_require__(53799);
 const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-
-class WebpackError extends Error {
+class ModuleError extends WebpackError {
 	/**
-	 * Creates an instance of WebpackError.
-	 * @param {string=} message error message
+	 * @param {Error} err error thrown
+	 * @param {{from?: string|null}} info additional info
 	 */
-	constructor(message) {
+	constructor(err, { from = null } = {}) {
+		let message = "Module Error";
+
+		if (from) {
+			message += ` (from ${from}):\n`;
+		} else {
+			message += ": ";
+		}
+
+		if (err && typeof err === "object" && err.message) {
+			message += err.message;
+		} else if (err) {
+			message += err;
+		}
+
 		super(message);
 
-		this.details = undefined;
-		/** @type {Module} */
-		this.module = undefined;
-		/** @type {DependencyLocation} */
-		this.loc = undefined;
-		/** @type {boolean} */
-		this.hideStack = undefined;
-		/** @type {Chunk} */
-		this.chunk = undefined;
-		/** @type {string} */
-		this.file = undefined;
+		this.name = "ModuleError";
+		this.error = err;
+		this.details =
+			err && typeof err === "object" && err.stack
+				? cleanUp(err.stack, this.message)
+				: undefined;
 	}
 
-	[inspect]() {
-		return this.stack + (this.details ? `\n${this.details}` : "");
-	}
+	serialize(context) {
+		const { write } = context;
 
-	serialize({ write }) {
-		write(this.name);
-		write(this.message);
-		write(this.stack);
-		write(this.details);
-		write(this.loc);
-		write(this.hideStack);
+		write(this.error);
+
+		super.serialize(context);
 	}
 
-	deserialize({ read }) {
-		this.name = read();
-		this.message = read();
-		this.stack = read();
-		this.details = read();
-		this.loc = read();
-		this.hideStack = read();
+	deserialize(context) {
+		const { read } = context;
+
+		this.error = read();
+
+		super.deserialize(context);
 	}
 }
 
-makeSerializable(WebpackError, "webpack/lib/WebpackError");
+makeSerializable(ModuleError, "webpack/lib/ModuleError");
 
-module.exports = WebpackError;
+module.exports = ModuleError;
 
 
 /***/ }),
 
-/***/ 97017:
+/***/ 51010:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const IgnoreErrorModuleFactory = __webpack_require__(3);
-const WebpackIsIncludedDependency = __webpack_require__(26505);
-const {
-	toConstantDependency
-} = __webpack_require__(93998);
-
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Module")} Module */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-class WebpackIsIncludedPlugin {
+/**
+ * @typedef {Object} ModuleFactoryResult
+ * @property {Module=} module the created module or unset if no module was created
+ * @property {Set<string>=} fileDependencies
+ * @property {Set<string>=} contextDependencies
+ * @property {Set<string>=} missingDependencies
+ * @property {boolean=} cacheable allow to use the unsafe cache
+ */
+
+/**
+ * @typedef {Object} ModuleFactoryCreateDataContextInfo
+ * @property {string} issuer
+ * @property {string | null=} issuerLayer
+ * @property {string} compiler
+ */
+
+/**
+ * @typedef {Object} ModuleFactoryCreateData
+ * @property {ModuleFactoryCreateDataContextInfo} contextInfo
+ * @property {ResolveOptions=} resolveOptions
+ * @property {string} context
+ * @property {Dependency[]} dependencies
+ */
+
+class ModuleFactory {
+	/* istanbul ignore next */
 	/**
-	 * @param {Compiler} compiler the compiler instance
+	 * @abstract
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WebpackIsIncludedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WebpackIsIncludedDependency,
-					new IgnoreErrorModuleFactory(normalModuleFactory)
-				);
-				compilation.dependencyTemplates.set(
-					WebpackIsIncludedDependency,
-					new WebpackIsIncludedDependency.Template()
-				);
+	create(data, callback) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+}
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					parser.hooks.call
-						.for("__webpack_is_included__")
-						.tap("WebpackIsIncludedPlugin", expr => {
-							if (
-								expr.type !== "CallExpression" ||
-								expr.arguments.length !== 1 ||
-								expr.arguments[0].type === "SpreadElement"
-							)
-								return;
+module.exports = ModuleFactory;
+
+
+/***/ }),
+
+/***/ 88821:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const NormalModule = __webpack_require__(39);
+const createHash = __webpack_require__(49835);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {typeof import("./util/Hash")} Hash */
+
+const ModuleFilenameHelpers = exports;
+
+// TODO webpack 6: consider removing these
+ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
+ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE =
+	/\[all-?loaders\]\[resource\]/gi;
+ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
+ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
+ModuleFilenameHelpers.RESOURCE = "[resource]";
+ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
+ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
+// cSpell:words olute
+ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH =
+	/\[abs(olute)?-?resource-?path\]/gi;
+ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
+ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
+ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
+ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
+ModuleFilenameHelpers.LOADERS = "[loaders]";
+ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
+ModuleFilenameHelpers.QUERY = "[query]";
+ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
+ModuleFilenameHelpers.ID = "[id]";
+ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
+ModuleFilenameHelpers.HASH = "[hash]";
+ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
+ModuleFilenameHelpers.NAMESPACE = "[namespace]";
+ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
+
+const getAfter = (strFn, token) => {
+	return () => {
+		const str = strFn();
+		const idx = str.indexOf(token);
+		return idx < 0 ? "" : str.substr(idx);
+	};
+};
+
+const getBefore = (strFn, token) => {
+	return () => {
+		const str = strFn();
+		const idx = str.lastIndexOf(token);
+		return idx < 0 ? "" : str.substr(0, idx);
+	};
+};
+
+const getHash = (strFn, hashFunction) => {
+	return () => {
+		const hash = createHash(hashFunction);
+		hash.update(strFn());
+		const digest = /** @type {string} */ (hash.digest("hex"));
+		return digest.substr(0, 4);
+	};
+};
+
+const asRegExp = test => {
+	if (typeof test === "string") {
+		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
+	}
+	return test;
+};
+
+const lazyObject = obj => {
+	const newObj = {};
+	for (const key of Object.keys(obj)) {
+		const fn = obj[key];
+		Object.defineProperty(newObj, key, {
+			get: () => fn(),
+			set: v => {
+				Object.defineProperty(newObj, key, {
+					value: v,
+					enumerable: true,
+					writable: true
+				});
+			},
+			enumerable: true,
+			configurable: true
+		});
+	}
+	return newObj;
+};
+
+const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+
+/**
+ *
+ * @param {Module | string} module the module
+ * @param {TODO} options options
+ * @param {Object} contextInfo context info
+ * @param {RequestShortener} contextInfo.requestShortener requestShortener
+ * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
+ * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @returns {string} the filename
+ */
+ModuleFilenameHelpers.createFilename = (
+	module = "",
+	options,
+	{ requestShortener, chunkGraph, hashFunction = "md4" }
+) => {
+	const opts = {
+		namespace: "",
+		moduleFilenameTemplate: "",
+		...(typeof options === "object"
+			? options
+			: {
+					moduleFilenameTemplate: options
+			  })
+	};
+
+	let absoluteResourcePath;
+	let hash;
+	let identifier;
+	let moduleId;
+	let shortIdentifier;
+	if (typeof module === "string") {
+		shortIdentifier = memoize(() => requestShortener.shorten(module));
+		identifier = shortIdentifier;
+		moduleId = () => "";
+		absoluteResourcePath = () => module.split("!").pop();
+		hash = getHash(identifier, hashFunction);
+	} else {
+		shortIdentifier = memoize(() =>
+			module.readableIdentifier(requestShortener)
+		);
+		identifier = memoize(() => requestShortener.shorten(module.identifier()));
+		moduleId = () => chunkGraph.getModuleId(module);
+		absoluteResourcePath = () =>
+			module instanceof NormalModule
+				? module.resource
+				: module.identifier().split("!").pop();
+		hash = getHash(identifier, hashFunction);
+	}
+	const resource = memoize(() => shortIdentifier().split("!").pop());
+
+	const loaders = getBefore(shortIdentifier, "!");
+	const allLoaders = getBefore(identifier, "!");
+	const query = getAfter(resource, "?");
+	const resourcePath = () => {
+		const q = query().length;
+		return q === 0 ? resource() : resource().slice(0, -q);
+	};
+	if (typeof opts.moduleFilenameTemplate === "function") {
+		return opts.moduleFilenameTemplate(
+			lazyObject({
+				identifier: identifier,
+				shortIdentifier: shortIdentifier,
+				resource: resource,
+				resourcePath: memoize(resourcePath),
+				absoluteResourcePath: memoize(absoluteResourcePath),
+				allLoaders: memoize(allLoaders),
+				query: memoize(query),
+				moduleId: memoize(moduleId),
+				hash: memoize(hash),
+				namespace: () => opts.namespace
+			})
+		);
+	}
+
+	// TODO webpack 6: consider removing alternatives without dashes
+	/** @type {Map<string, function(): string>} */
+	const replacements = new Map([
+		["identifier", identifier],
+		["short-identifier", shortIdentifier],
+		["resource", resource],
+		["resource-path", resourcePath],
+		// cSpell:words resourcepath
+		["resourcepath", resourcePath],
+		["absolute-resource-path", absoluteResourcePath],
+		["abs-resource-path", absoluteResourcePath],
+		// cSpell:words absoluteresource
+		["absoluteresource-path", absoluteResourcePath],
+		// cSpell:words absresource
+		["absresource-path", absoluteResourcePath],
+		// cSpell:words resourcepath
+		["absolute-resourcepath", absoluteResourcePath],
+		// cSpell:words resourcepath
+		["abs-resourcepath", absoluteResourcePath],
+		// cSpell:words absoluteresourcepath
+		["absoluteresourcepath", absoluteResourcePath],
+		// cSpell:words absresourcepath
+		["absresourcepath", absoluteResourcePath],
+		["all-loaders", allLoaders],
+		// cSpell:words allloaders
+		["allloaders", allLoaders],
+		["loaders", loaders],
+		["query", query],
+		["id", moduleId],
+		["hash", hash],
+		["namespace", () => opts.namespace]
+	]);
 
-							const request = parser.evaluateExpression(expr.arguments[0]);
+	// TODO webpack 6: consider removing weird double placeholders
+	return opts.moduleFilenameTemplate
+		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
+		.replace(
+			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
+			"[short-identifier]"
+		)
+		.replace(REGEXP, (match, content) => {
+			if (content.length + 2 === match.length) {
+				const replacement = replacements.get(content.toLowerCase());
+				if (replacement !== undefined) {
+					return replacement();
+				}
+			} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
+				return `[${match.slice(2, -2)}]`;
+			}
+			return match;
+		});
+};
 
-							if (!request.isString()) return;
+ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
+	const countMap = Object.create(null);
+	const posMap = Object.create(null);
+	array.forEach((item, idx) => {
+		countMap[item] = countMap[item] || [];
+		countMap[item].push(idx);
+		posMap[item] = 0;
+	});
+	if (comparator) {
+		Object.keys(countMap).forEach(item => {
+			countMap[item].sort(comparator);
+		});
+	}
+	return array.map((item, i) => {
+		if (countMap[item].length > 1) {
+			if (comparator && countMap[item][0] === i) return item;
+			return fn(item, i, posMap[item]++);
+		} else {
+			return item;
+		}
+	});
+};
 
-							const dep = new WebpackIsIncludedDependency(
-								request.string,
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-							return true;
-						});
-					parser.hooks.typeof
-						.for("__webpack_is_included__")
-						.tap(
-							"WebpackIsIncludedPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WebpackIsIncludedPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("WebpackIsIncludedPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WebpackIsIncludedPlugin", handler);
-			}
-		);
+ModuleFilenameHelpers.matchPart = (str, test) => {
+	if (!test) return true;
+	test = asRegExp(test);
+	if (Array.isArray(test)) {
+		return test.map(asRegExp).some(regExp => regExp.test(str));
+	} else {
+		return test.test(str);
 	}
-}
+};
 
-module.exports = WebpackIsIncludedPlugin;
+ModuleFilenameHelpers.matchObject = (obj, str) => {
+	if (obj.test) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
+			return false;
+		}
+	}
+	if (obj.include) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
+			return false;
+		}
+	}
+	if (obj.exclude) {
+		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
+			return false;
+		}
+	}
+	return true;
+};
 
 
 /***/ }),
 
-/***/ 88422:
+/***/ 99988:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -57382,1522 +52546,1534 @@ module.exports = WebpackIsIncludedPlugin;
 
 
 
-const OptionsApply = __webpack_require__(81426);
-
-const AssetModulesPlugin = __webpack_require__(16109);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const JsonModulesPlugin = __webpack_require__(86770);
-
-const ChunkPrefetchPreloadPlugin = __webpack_require__(33895);
-
-const EntryOptionPlugin = __webpack_require__(9909);
-const RecordIdsPlugin = __webpack_require__(11094);
-
-const RuntimePlugin = __webpack_require__(2307);
-
-const APIPlugin = __webpack_require__(74315);
-const CompatibilityPlugin = __webpack_require__(94258);
-const ConstPlugin = __webpack_require__(11146);
-const ExportsInfoApiPlugin = __webpack_require__(7145);
-const WebpackIsIncludedPlugin = __webpack_require__(97017);
-
-const TemplatedPathPlugin = __webpack_require__(80734);
-const UseStrictPlugin = __webpack_require__(36803);
-const WarnCaseSensitiveModulesPlugin = __webpack_require__(56504);
-
-const DataUriPlugin = __webpack_require__(64820);
-const FileUriPlugin = __webpack_require__(57637);
-
-const ResolverCachePlugin = __webpack_require__(97347);
-
-const CommonJsPlugin = __webpack_require__(32406);
-const HarmonyModulesPlugin = __webpack_require__(39029);
-const ImportMetaPlugin = __webpack_require__(17228);
-const ImportPlugin = __webpack_require__(41293);
-const LoaderPlugin = __webpack_require__(24721);
-const RequireContextPlugin = __webpack_require__(2928);
-const RequireEnsurePlugin = __webpack_require__(8434);
-const RequireIncludePlugin = __webpack_require__(37378);
-const SystemPlugin = __webpack_require__(97981);
-const URLPlugin = __webpack_require__(14412);
-const WorkerPlugin = __webpack_require__(82509);
-
-const InferAsyncModulesPlugin = __webpack_require__(59498);
-
-const JavascriptMetaInfoPlugin = __webpack_require__(52329);
-const DefaultStatsFactoryPlugin = __webpack_require__(71760);
-const DefaultStatsPresetPlugin = __webpack_require__(55442);
-const DefaultStatsPrinterPlugin = __webpack_require__(58692);
-
-const { cleverMerge } = __webpack_require__(60839);
-
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Compiler")} Compiler */
-
-class WebpackOptionsApply extends OptionsApply {
-	constructor() {
-		super();
-	}
-
-	/**
-	 * @param {WebpackOptions} options options object
-	 * @param {Compiler} compiler compiler object
-	 * @returns {WebpackOptions} options object
-	 */
-	process(options, compiler) {
-		compiler.outputPath = options.output.path;
-		compiler.recordsInputPath = options.recordsInputPath || null;
-		compiler.recordsOutputPath = options.recordsOutputPath || null;
-		compiler.name = options.name;
-
-		if (options.externals) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin(options.externalsType, options.externals).apply(
-				compiler
-			);
-		}
-
-		if (options.externalsPresets.node) {
-			const NodeTargetPlugin = __webpack_require__(17916);
-			new NodeTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.electronMain) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin("main").apply(compiler);
-		}
-		if (options.externalsPresets.electronPreload) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin("preload").apply(compiler);
-		}
-		if (options.externalsPresets.electronRenderer) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin("renderer").apply(compiler);
-		}
-		if (
-			options.externalsPresets.electron &&
-			!options.externalsPresets.electronMain &&
-			!options.externalsPresets.electronPreload &&
-			!options.externalsPresets.electronRenderer
-		) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.nwjs) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
-		}
-		if (options.externalsPresets.webAsync) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin(
-				"import",
-				options.experiments.css
-					? ({ request, dependencyType }, callback) => {
-							if (dependencyType === "url") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `asset ${request}`);
-							} else if (dependencyType === "css-import") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `css-import ${request}`);
-							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-								if (/^\.css(\?|$)/.test(request))
-									return callback(null, `css-import ${request}`);
-								return callback(null, `import ${request}`);
-							}
-							callback();
-					  }
-					: /^(\/\/|https?:\/\/|std:)/
-			).apply(compiler);
-		} else if (options.externalsPresets.web) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin(
-				"module",
-				options.experiments.css
-					? ({ request, dependencyType }, callback) => {
-							if (dependencyType === "url") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `asset ${request}`);
-							} else if (dependencyType === "css-import") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `css-import ${request}`);
-							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-								if (/^\.css(\?|$)/.test(request))
-									return callback(null, `css-import ${request}`);
-								return callback(null, `module ${request}`);
-							}
-							callback();
-					  }
-					: /^(\/\/|https?:\/\/|std:)/
-			).apply(compiler);
-		}
-
-		new ChunkPrefetchPreloadPlugin().apply(compiler);
-
-		if (typeof options.output.chunkFormat === "string") {
-			switch (options.output.chunkFormat) {
-				case "array-push": {
-					const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
-					new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
-					break;
-				}
-				case "commonjs": {
-					const CommonJsChunkFormatPlugin = __webpack_require__(84508);
-					new CommonJsChunkFormatPlugin().apply(compiler);
-					break;
-				}
-				case "module": {
-					const ModuleChunkFormatPlugin = __webpack_require__(68927);
-					new ModuleChunkFormatPlugin().apply(compiler);
-					break;
-				}
-				default:
-					throw new Error(
-						"Unsupported chunk format '" + options.output.chunkFormat + "'."
-					);
-			}
-		}
-
-		if (options.output.enabledChunkLoadingTypes.length > 0) {
-			for (const type of options.output.enabledChunkLoadingTypes) {
-				const EnableChunkLoadingPlugin = __webpack_require__(61291);
-				new EnableChunkLoadingPlugin(type).apply(compiler);
-			}
-		}
-
-		if (options.output.enabledWasmLoadingTypes.length > 0) {
-			for (const type of options.output.enabledWasmLoadingTypes) {
-				const EnableWasmLoadingPlugin = __webpack_require__(78613);
-				new EnableWasmLoadingPlugin(type).apply(compiler);
-			}
-		}
+const util = __webpack_require__(73837);
+const ExportsInfo = __webpack_require__(63686);
+const ModuleGraphConnection = __webpack_require__(40639);
+const SortableSet = __webpack_require__(13098);
+const WeakTupleMap = __webpack_require__(28745);
 
-		if (options.output.enabledLibraryTypes.length > 0) {
-			for (const type of options.output.enabledLibraryTypes) {
-				const EnableLibraryPlugin = __webpack_require__(91452);
-				new EnableLibraryPlugin(type).apply(compiler);
-			}
-		}
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleProfile")} ModuleProfile */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-		if (options.output.pathinfo) {
-			const ModuleInfoHeaderPlugin = __webpack_require__(3454);
-			new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply(
-				compiler
-			);
-		}
+/**
+ * @callback OptimizationBailoutFunction
+ * @param {RequestShortener} requestShortener
+ * @returns {string}
+ */
 
-		if (options.output.clean) {
-			const CleanPlugin = __webpack_require__(31085);
-			new CleanPlugin(
-				options.output.clean === true ? {} : options.output.clean
-			).apply(compiler);
-		}
+const EMPTY_SET = new Set();
 
-		if (options.devtool) {
-			if (options.devtool.includes("source-map")) {
-				const hidden = options.devtool.includes("hidden");
-				const inline = options.devtool.includes("inline");
-				const evalWrapped = options.devtool.includes("eval");
-				const cheap = options.devtool.includes("cheap");
-				const moduleMaps = options.devtool.includes("module");
-				const noSources = options.devtool.includes("nosources");
-				const Plugin = evalWrapped
-					? __webpack_require__(14790)
-					: __webpack_require__(63872);
-				new Plugin({
-					filename: inline ? null : options.output.sourceMapFilename,
-					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
-					fallbackModuleFilenameTemplate:
-						options.output.devtoolFallbackModuleFilenameTemplate,
-					append: hidden ? false : undefined,
-					module: moduleMaps ? true : cheap ? false : true,
-					columns: cheap ? false : true,
-					noSources: noSources,
-					namespace: options.output.devtoolNamespace
-				}).apply(compiler);
-			} else if (options.devtool.includes("eval")) {
-				const EvalDevToolModulePlugin = __webpack_require__(65218);
-				new EvalDevToolModulePlugin({
-					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
-					namespace: options.output.devtoolNamespace
-				}).apply(compiler);
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
+ */
+const getConnectionsByOriginModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { originModule } = connection;
+		if (lastModule === originModule) {
+			lastList.push(connection);
+		} else {
+			lastModule = originModule;
+			const list = map.get(originModule);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(originModule, list);
 			}
 		}
+	}
+	return map;
+};
 
-		new JavascriptModulesPlugin().apply(compiler);
-		new JsonModulesPlugin().apply(compiler);
-		new AssetModulesPlugin().apply(compiler);
-
-		if (!options.experiments.outputModule) {
-			if (options.output.module) {
-				throw new Error(
-					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (options.output.enabledLibraryTypes.includes("module")) {
-				throw new Error(
-					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (options.externalsType === "module") {
-				throw new Error(
-					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
-				);
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
+ */
+const getConnectionsByModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { module } = connection;
+		if (lastModule === module) {
+			lastList.push(connection);
+		} else {
+			lastModule = module;
+			const list = map.get(module);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(module, list);
 			}
 		}
+	}
+	return map;
+};
 
-		if (options.experiments.syncWebAssembly) {
-			const WebAssemblyModulesPlugin = __webpack_require__(53639);
-			new WebAssemblyModulesPlugin({
-				mangleImports: options.optimization.mangleWasmImports
-			}).apply(compiler);
-		}
+class ModuleGraphModule {
+	constructor() {
+		/** @type {SortableSet<ModuleGraphConnection>} */
+		this.incomingConnections = new SortableSet();
+		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
+		this.outgoingConnections = undefined;
+		/** @type {Module | null} */
+		this.issuer = undefined;
+		/** @type {(string | OptimizationBailoutFunction)[]} */
+		this.optimizationBailout = [];
+		/** @type {ExportsInfo} */
+		this.exports = new ExportsInfo();
+		/** @type {number} */
+		this.preOrderIndex = null;
+		/** @type {number} */
+		this.postOrderIndex = null;
+		/** @type {number} */
+		this.depth = null;
+		/** @type {ModuleProfile} */
+		this.profile = undefined;
+		/** @type {boolean} */
+		this.async = false;
+		/** @type {ModuleGraphConnection[]} */
+		this._unassignedConnections = undefined;
+	}
+}
 
-		if (options.experiments.asyncWebAssembly) {
-			const AsyncWebAssemblyModulesPlugin = __webpack_require__(7538);
-			new AsyncWebAssemblyModulesPlugin({
-				mangleImports: options.optimization.mangleWasmImports
-			}).apply(compiler);
-		}
+class ModuleGraph {
+	constructor() {
+		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
+		this._dependencyMap = new WeakMap();
+		/** @type {Map<Module, ModuleGraphModule>} */
+		this._moduleMap = new Map();
+		/** @type {WeakMap<any, Object>} */
+		this._metaMap = new WeakMap();
 
-		if (options.experiments.css) {
-			const CssModulesPlugin = __webpack_require__(47283);
-			new CssModulesPlugin(options.experiments.css).apply(compiler);
-		}
+		/** @type {WeakTupleMap<any[], any>} */
+		this._cache = undefined;
 
-		if (options.experiments.lazyCompilation) {
-			const LazyCompilationPlugin = __webpack_require__(79040);
-			const lazyOptions =
-				typeof options.experiments.lazyCompilation === "object"
-					? options.experiments.lazyCompilation
-					: null;
-			new LazyCompilationPlugin({
-				backend:
-					typeof lazyOptions.backend === "function"
-						? lazyOptions.backend
-						: __webpack_require__(17781)({
-								...lazyOptions.backend,
-								client:
-									(lazyOptions.backend && lazyOptions.backend.client) ||
-									options.externalsPresets.node ? __webpack_require__.ab + "lazy-compilation-node.js" : __webpack_require__.ab + "lazy-compilation-web.js"
-						  }),
-				entries: !lazyOptions || lazyOptions.entries !== false,
-				imports: !lazyOptions || lazyOptions.imports !== false,
-				test: (lazyOptions && lazyOptions.test) || undefined
-			}).apply(compiler);
-		}
+		/** @type {Map<Module, WeakTupleMap<any, any>>} */
+		this._moduleMemCaches = undefined;
+	}
 
-		if (options.experiments.buildHttp) {
-			const HttpUriPlugin = __webpack_require__(42110);
-			const httpOptions = options.experiments.buildHttp;
-			new HttpUriPlugin(httpOptions).apply(compiler);
+	/**
+	 * @param {Module} module the module
+	 * @returns {ModuleGraphModule} the internal module
+	 */
+	_getModuleGraphModule(module) {
+		let mgm = this._moduleMap.get(module);
+		if (mgm === undefined) {
+			mgm = new ModuleGraphModule();
+			this._moduleMap.set(module, mgm);
 		}
+		return mgm;
+	}
 
-		new EntryOptionPlugin().apply(compiler);
-		compiler.hooks.entryOption.call(options.context, options.entry);
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @param {DependenciesBlock} block parent block
+	 * @param {Module} module parent module
+	 * @param {number=} indexInBlock position in block
+	 * @returns {void}
+	 */
+	setParents(dependency, block, module, indexInBlock = -1) {
+		dependency._parentDependenciesBlockIndex = indexInBlock;
+		dependency._parentDependenciesBlock = block;
+		dependency._parentModule = module;
+	}
 
-		new RuntimePlugin().apply(compiler);
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @returns {Module} parent module
+	 */
+	getParentModule(dependency) {
+		return dependency._parentModule;
+	}
 
-		new InferAsyncModulesPlugin().apply(compiler);
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @returns {DependenciesBlock} parent block
+	 */
+	getParentBlock(dependency) {
+		return dependency._parentDependenciesBlock;
+	}
 
-		new DataUriPlugin().apply(compiler);
-		new FileUriPlugin().apply(compiler);
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @returns {number} index
+	 */
+	getParentBlockIndex(dependency) {
+		return dependency._parentDependenciesBlockIndex;
+	}
 
-		new CompatibilityPlugin().apply(compiler);
-		new HarmonyModulesPlugin({
-			topLevelAwait: options.experiments.topLevelAwait
-		}).apply(compiler);
-		if (options.amd !== false) {
-			const AMDPlugin = __webpack_require__(50067);
-			const RequireJsStuffPlugin = __webpack_require__(88846);
-			new AMDPlugin(options.amd || {}).apply(compiler);
-			new RequireJsStuffPlugin().apply(compiler);
-		}
-		new CommonJsPlugin().apply(compiler);
-		new LoaderPlugin({}).apply(compiler);
-		if (options.node !== false) {
-			const NodeStuffPlugin = __webpack_require__(95287);
-			new NodeStuffPlugin(options.node).apply(compiler);
+	/**
+	 * @param {Module} originModule the referencing module
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {Module} module the referenced module
+	 * @returns {void}
+	 */
+	setResolvedModule(originModule, dependency, module) {
+		const connection = new ModuleGraphConnection(
+			originModule,
+			dependency,
+			module,
+			undefined,
+			dependency.weak,
+			dependency.getCondition(this)
+		);
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		connections.add(connection);
+		if (originModule) {
+			const mgm = this._getModuleGraphModule(originModule);
+			if (mgm._unassignedConnections === undefined) {
+				mgm._unassignedConnections = [];
+			}
+			mgm._unassignedConnections.push(connection);
+			if (mgm.outgoingConnections === undefined) {
+				mgm.outgoingConnections = new SortableSet();
+			}
+			mgm.outgoingConnections.add(connection);
+		} else {
+			this._dependencyMap.set(dependency, connection);
 		}
-		new APIPlugin().apply(compiler);
-		new ExportsInfoApiPlugin().apply(compiler);
-		new WebpackIsIncludedPlugin().apply(compiler);
-		new ConstPlugin().apply(compiler);
-		new UseStrictPlugin().apply(compiler);
-		new RequireIncludePlugin().apply(compiler);
-		new RequireEnsurePlugin().apply(compiler);
-		new RequireContextPlugin().apply(compiler);
-		new ImportPlugin().apply(compiler);
-		new SystemPlugin().apply(compiler);
-		new ImportMetaPlugin().apply(compiler);
-		new URLPlugin().apply(compiler);
-		new WorkerPlugin(
-			options.output.workerChunkLoading,
-			options.output.workerWasmLoading,
-			options.output.module
-		).apply(compiler);
+	}
 
-		new DefaultStatsFactoryPlugin().apply(compiler);
-		new DefaultStatsPresetPlugin().apply(compiler);
-		new DefaultStatsPrinterPlugin().apply(compiler);
+	/**
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {Module} module the referenced module
+	 * @returns {void}
+	 */
+	updateModule(dependency, module) {
+		const connection = this.getConnection(dependency);
+		if (connection.module === module) return;
+		const newConnection = connection.clone();
+		newConnection.module = module;
+		this._dependencyMap.set(dependency, newConnection);
+		connection.setActive(false);
+		const originMgm = this._getModuleGraphModule(connection.originModule);
+		originMgm.outgoingConnections.add(newConnection);
+		const targetMgm = this._getModuleGraphModule(module);
+		targetMgm.incomingConnections.add(newConnection);
+	}
 
-		new JavascriptMetaInfoPlugin().apply(compiler);
+	/**
+	 * @param {Dependency} dependency the referencing dependency
+	 * @returns {void}
+	 */
+	removeConnection(dependency) {
+		const connection = this.getConnection(dependency);
+		const targetMgm = this._getModuleGraphModule(connection.module);
+		targetMgm.incomingConnections.delete(connection);
+		const originMgm = this._getModuleGraphModule(connection.originModule);
+		originMgm.outgoingConnections.delete(connection);
+		this._dependencyMap.set(dependency, null);
+	}
 
-		if (typeof options.mode !== "string") {
-			const WarnNoModeSetPlugin = __webpack_require__(25295);
-			new WarnNoModeSetPlugin().apply(compiler);
-		}
+	/**
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {string} explanation an explanation
+	 * @returns {void}
+	 */
+	addExplanation(dependency, explanation) {
+		const connection = this.getConnection(dependency);
+		connection.addExplanation(explanation);
+	}
 
-		const EnsureChunkConditionsPlugin = __webpack_require__(96260);
-		new EnsureChunkConditionsPlugin().apply(compiler);
-		if (options.optimization.removeAvailableModules) {
-			const RemoveParentModulesPlugin = __webpack_require__(7081);
-			new RemoveParentModulesPlugin().apply(compiler);
-		}
-		if (options.optimization.removeEmptyChunks) {
-			const RemoveEmptyChunksPlugin = __webpack_require__(84760);
-			new RemoveEmptyChunksPlugin().apply(compiler);
-		}
-		if (options.optimization.mergeDuplicateChunks) {
-			const MergeDuplicateChunksPlugin = __webpack_require__(85067);
-			new MergeDuplicateChunksPlugin().apply(compiler);
-		}
-		if (options.optimization.flagIncludedChunks) {
-			const FlagIncludedChunksPlugin = __webpack_require__(50089);
-			new FlagIncludedChunksPlugin().apply(compiler);
-		}
-		if (options.optimization.sideEffects) {
-			const SideEffectsFlagPlugin = __webpack_require__(84800);
-			new SideEffectsFlagPlugin(
-				options.optimization.sideEffects === true
-			).apply(compiler);
-		}
-		if (options.optimization.providedExports) {
-			const FlagDependencyExportsPlugin = __webpack_require__(84506);
-			new FlagDependencyExportsPlugin().apply(compiler);
-		}
-		if (options.optimization.usedExports) {
-			const FlagDependencyUsagePlugin = __webpack_require__(58812);
-			new FlagDependencyUsagePlugin(
-				options.optimization.usedExports === "global"
-			).apply(compiler);
-		}
-		if (options.optimization.innerGraph) {
-			const InnerGraphPlugin = __webpack_require__(28758);
-			new InnerGraphPlugin().apply(compiler);
-		}
-		if (options.optimization.mangleExports) {
-			const MangleExportsPlugin = __webpack_require__(27868);
-			new MangleExportsPlugin(
-				options.optimization.mangleExports !== "size"
-			).apply(compiler);
-		}
-		if (options.optimization.concatenateModules) {
-			const ModuleConcatenationPlugin = __webpack_require__(74844);
-			new ModuleConcatenationPlugin().apply(compiler);
-		}
-		if (options.optimization.splitChunks) {
-			const SplitChunksPlugin = __webpack_require__(21478);
-			new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
-		}
-		if (options.optimization.runtimeChunk) {
-			const RuntimeChunkPlugin = __webpack_require__(2837);
-			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
-		}
-		if (!options.optimization.emitOnErrors) {
-			const NoEmitOnErrorsPlugin = __webpack_require__(50169);
-			new NoEmitOnErrorsPlugin().apply(compiler);
-		}
-		if (options.optimization.realContentHash) {
-			const RealContentHashPlugin = __webpack_require__(46043);
-			new RealContentHashPlugin({
-				hashFunction: options.output.hashFunction,
-				hashDigest: options.output.hashDigest
-			}).apply(compiler);
-		}
-		if (options.optimization.checkWasmTypes) {
-			const WasmFinalizeExportsPlugin = __webpack_require__(19810);
-			new WasmFinalizeExportsPlugin().apply(compiler);
+	/**
+	 * @param {Module} sourceModule the source module
+	 * @param {Module} targetModule the target module
+	 * @returns {void}
+	 */
+	cloneModuleAttributes(sourceModule, targetModule) {
+		const oldMgm = this._getModuleGraphModule(sourceModule);
+		const newMgm = this._getModuleGraphModule(targetModule);
+		newMgm.postOrderIndex = oldMgm.postOrderIndex;
+		newMgm.preOrderIndex = oldMgm.preOrderIndex;
+		newMgm.depth = oldMgm.depth;
+		newMgm.exports = oldMgm.exports;
+		newMgm.async = oldMgm.async;
+	}
+
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	removeModuleAttributes(module) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.postOrderIndex = null;
+		mgm.preOrderIndex = null;
+		mgm.depth = null;
+		mgm.async = false;
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	removeAllModuleAttributes() {
+		for (const mgm of this._moduleMap.values()) {
+			mgm.postOrderIndex = null;
+			mgm.preOrderIndex = null;
+			mgm.depth = null;
+			mgm.async = false;
 		}
-		const moduleIds = options.optimization.moduleIds;
-		if (moduleIds) {
-			switch (moduleIds) {
-				case "natural": {
-					const NaturalModuleIdsPlugin = __webpack_require__(83366);
-					new NaturalModuleIdsPlugin().apply(compiler);
-					break;
-				}
-				case "named": {
-					const NamedModuleIdsPlugin = __webpack_require__(24339);
-					new NamedModuleIdsPlugin().apply(compiler);
-					break;
-				}
-				case "hashed": {
-					const WarnDeprecatedOptionPlugin = __webpack_require__(76537);
-					const HashedModuleIdsPlugin = __webpack_require__(21825);
-					new WarnDeprecatedOptionPlugin(
-						"optimization.moduleIds",
-						"hashed",
-						"deterministic"
-					).apply(compiler);
-					new HashedModuleIdsPlugin({
-						hashFunction: options.output.hashFunction
-					}).apply(compiler);
-					break;
-				}
-				case "deterministic": {
-					const DeterministicModuleIdsPlugin = __webpack_require__(76692);
-					new DeterministicModuleIdsPlugin().apply(compiler);
-					break;
-				}
-				case "size": {
-					const OccurrenceModuleIdsPlugin = __webpack_require__(35371);
-					new OccurrenceModuleIdsPlugin({
-						prioritiseInitial: true
-					}).apply(compiler);
-					break;
-				}
-				default:
-					throw new Error(
-						`webpack bug: moduleIds: ${moduleIds} is not implemented`
-					);
+	}
+
+	/**
+	 * @param {Module} oldModule the old referencing module
+	 * @param {Module} newModule the new referencing module
+	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
+	 * @returns {void}
+	 */
+	moveModuleConnections(oldModule, newModule, filterConnection) {
+		if (oldModule === newModule) return;
+		const oldMgm = this._getModuleGraphModule(oldModule);
+		const newMgm = this._getModuleGraphModule(newModule);
+		// Outgoing connections
+		const oldConnections = oldMgm.outgoingConnections;
+		if (oldConnections !== undefined) {
+			if (newMgm.outgoingConnections === undefined) {
+				newMgm.outgoingConnections = new SortableSet();
 			}
-		}
-		const chunkIds = options.optimization.chunkIds;
-		if (chunkIds) {
-			switch (chunkIds) {
-				case "natural": {
-					const NaturalChunkIdsPlugin = __webpack_require__(86221);
-					new NaturalChunkIdsPlugin().apply(compiler);
-					break;
-				}
-				case "named": {
-					const NamedChunkIdsPlugin = __webpack_require__(6454);
-					new NamedChunkIdsPlugin().apply(compiler);
-					break;
-				}
-				case "deterministic": {
-					const DeterministicChunkIdsPlugin = __webpack_require__(8747);
-					new DeterministicChunkIdsPlugin().apply(compiler);
-					break;
-				}
-				case "size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
-					new OccurrenceChunkIdsPlugin({
-						prioritiseInitial: true
-					}).apply(compiler);
-					break;
-				}
-				case "total-size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
-					new OccurrenceChunkIdsPlugin({
-						prioritiseInitial: false
-					}).apply(compiler);
-					break;
+			const newConnections = newMgm.outgoingConnections;
+			for (const connection of oldConnections) {
+				if (filterConnection(connection)) {
+					connection.originModule = newModule;
+					newConnections.add(connection);
+					oldConnections.delete(connection);
 				}
-				default:
-					throw new Error(
-						`webpack bug: chunkIds: ${chunkIds} is not implemented`
-					);
 			}
 		}
-		if (options.optimization.nodeEnv) {
-			const DefinePlugin = __webpack_require__(79065);
-			new DefinePlugin({
-				"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
-			}).apply(compiler);
-		}
-		if (options.optimization.minimize) {
-			for (const minimizer of options.optimization.minimizer) {
-				if (typeof minimizer === "function") {
-					minimizer.call(compiler, compiler);
-				} else if (minimizer !== "...") {
-					minimizer.apply(compiler);
-				}
+		// Incoming connections
+		const oldConnections2 = oldMgm.incomingConnections;
+		const newConnections2 = newMgm.incomingConnections;
+		for (const connection of oldConnections2) {
+			if (filterConnection(connection)) {
+				connection.module = newModule;
+				newConnections2.add(connection);
+				oldConnections2.delete(connection);
 			}
 		}
+	}
 
-		if (options.performance) {
-			const SizeLimitsPlugin = __webpack_require__(32557);
-			new SizeLimitsPlugin(options.performance).apply(compiler);
-		}
-
-		new TemplatedPathPlugin().apply(compiler);
-
-		new RecordIdsPlugin({
-			portableIds: options.optimization.portableRecords
-		}).apply(compiler);
-
-		new WarnCaseSensitiveModulesPlugin().apply(compiler);
-
-		const AddManagedPathsPlugin = __webpack_require__(47942);
-		new AddManagedPathsPlugin(
-			options.snapshot.managedPaths,
-			options.snapshot.immutablePaths
-		).apply(compiler);
-
-		if (options.cache && typeof options.cache === "object") {
-			const cacheOptions = options.cache;
-			switch (cacheOptions.type) {
-				case "memory": {
-					if (isFinite(cacheOptions.maxGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryWithGcCachePlugin = __webpack_require__(99334);
-						new MemoryWithGcCachePlugin({
-							maxGenerations: cacheOptions.maxGenerations
-						}).apply(compiler);
-					} else {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryCachePlugin = __webpack_require__(52539);
-						new MemoryCachePlugin().apply(compiler);
-					}
-					if (cacheOptions.cacheUnaffected) {
-						if (!options.experiments.cacheUnaffected) {
-							throw new Error(
-								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
-							);
-						}
-						compiler.moduleMemCaches = new Map();
-					}
-					break;
-				}
-				case "filesystem": {
-					const AddBuildDependenciesPlugin = __webpack_require__(28034);
-					for (const key in cacheOptions.buildDependencies) {
-						const list = cacheOptions.buildDependencies[key];
-						new AddBuildDependenciesPlugin(list).apply(compiler);
-					}
-					if (!isFinite(cacheOptions.maxMemoryGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryCachePlugin = __webpack_require__(52539);
-						new MemoryCachePlugin().apply(compiler);
-					} else if (cacheOptions.maxMemoryGenerations !== 0) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryWithGcCachePlugin = __webpack_require__(99334);
-						new MemoryWithGcCachePlugin({
-							maxGenerations: cacheOptions.maxMemoryGenerations
-						}).apply(compiler);
-					}
-					if (cacheOptions.memoryCacheUnaffected) {
-						if (!options.experiments.cacheUnaffected) {
-							throw new Error(
-								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
-							);
-						}
-						compiler.moduleMemCaches = new Map();
-					}
-					switch (cacheOptions.store) {
-						case "pack": {
-							const IdleFileCachePlugin = __webpack_require__(71985);
-							const PackFileCacheStrategy = __webpack_require__(86180);
-							new IdleFileCachePlugin(
-								new PackFileCacheStrategy({
-									compiler,
-									fs: compiler.intermediateFileSystem,
-									context: options.context,
-									cacheLocation: cacheOptions.cacheLocation,
-									version: cacheOptions.version,
-									logger: compiler.getInfrastructureLogger(
-										"webpack.cache.PackFileCacheStrategy"
-									),
-									snapshot: options.snapshot,
-									maxAge: cacheOptions.maxAge,
-									profile: cacheOptions.profile,
-									allowCollectingMemory: cacheOptions.allowCollectingMemory,
-									compression: cacheOptions.compression
-								}),
-								cacheOptions.idleTimeout,
-								cacheOptions.idleTimeoutForInitialStore,
-								cacheOptions.idleTimeoutAfterLargeChanges
-							).apply(compiler);
-							break;
-						}
-						default:
-							throw new Error("Unhandled value for cache.store");
+	/**
+	 * @param {Module} oldModule the old referencing module
+	 * @param {Module} newModule the new referencing module
+	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
+	 * @returns {void}
+	 */
+	copyOutgoingModuleConnections(oldModule, newModule, filterConnection) {
+		if (oldModule === newModule) return;
+		const oldMgm = this._getModuleGraphModule(oldModule);
+		const newMgm = this._getModuleGraphModule(newModule);
+		// Outgoing connections
+		const oldConnections = oldMgm.outgoingConnections;
+		if (oldConnections !== undefined) {
+			if (newMgm.outgoingConnections === undefined) {
+				newMgm.outgoingConnections = new SortableSet();
+			}
+			const newConnections = newMgm.outgoingConnections;
+			for (const connection of oldConnections) {
+				if (filterConnection(connection)) {
+					const newConnection = connection.clone();
+					newConnection.originModule = newModule;
+					newConnections.add(newConnection);
+					if (newConnection.module !== undefined) {
+						const otherMgm = this._getModuleGraphModule(newConnection.module);
+						otherMgm.incomingConnections.add(newConnection);
 					}
-					break;
 				}
-				default:
-					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
-					throw new Error(`Unknown cache type ${cacheOptions.type}`);
 			}
 		}
-		new ResolverCachePlugin().apply(compiler);
-
-		if (options.ignoreWarnings && options.ignoreWarnings.length > 0) {
-			const IgnoreWarningsPlugin = __webpack_require__(7373);
-			new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler);
-		}
+	}
 
-		compiler.hooks.afterPlugins.call(compiler);
-		if (!compiler.inputFileSystem) {
-			throw new Error("No input filesystem provided");
-		}
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("normal")
-			.tap("WebpackOptionsApply", resolveOptions => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
-				return resolveOptions;
-			});
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("context")
-			.tap("WebpackOptionsApply", resolveOptions => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
-				resolveOptions.resolveToContext = true;
-				return resolveOptions;
-			});
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("loader")
-			.tap("WebpackOptionsApply", resolveOptions => {
-				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
-				return resolveOptions;
-			});
-		compiler.hooks.afterResolvers.call(compiler);
-		return options;
+	/**
+	 * @param {Module} module the referenced module
+	 * @param {string} explanation an explanation why it's referenced
+	 * @returns {void}
+	 */
+	addExtraReason(module, explanation) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		connections.add(new ModuleGraphConnection(null, null, module, explanation));
 	}
-}
 
-module.exports = WebpackOptionsApply;
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referenced module
+	 * @returns {Module} the referenced module
+	 */
+	getResolvedModule(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.resolvedModule : null;
+	}
 
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referenced module
+	 * @returns {ModuleGraphConnection | undefined} the connection
+	 */
+	getConnection(dependency) {
+		const connection = this._dependencyMap.get(dependency);
+		if (connection === undefined) {
+			const module = this.getParentModule(dependency);
+			if (module !== undefined) {
+				const mgm = this._getModuleGraphModule(module);
+				if (
+					mgm._unassignedConnections &&
+					mgm._unassignedConnections.length !== 0
+				) {
+					let foundConnection;
+					for (const connection of mgm._unassignedConnections) {
+						this._dependencyMap.set(connection.dependency, connection);
+						if (connection.dependency === dependency)
+							foundConnection = connection;
+					}
+					mgm._unassignedConnections.length = 0;
+					if (foundConnection !== undefined) {
+						return foundConnection;
+					}
+				}
+			}
+			this._dependencyMap.set(dependency, null);
+			return undefined;
+		}
+		return connection === null ? undefined : connection;
+	}
 
-/***/ }),
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referenced module
+	 * @returns {Module} the referenced module
+	 */
+	getModule(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.module : null;
+	}
 
-/***/ 14452:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referencing module
+	 * @returns {Module} the referencing module
+	 */
+	getOrigin(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.originModule : null;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referencing module
+	 * @returns {Module} the original referencing module
+	 */
+	getResolvedOrigin(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.resolvedOriginModule : null;
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {Iterable<ModuleGraphConnection>} reasons why a module is included
+	 */
+	getIncomingConnections(module) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		return connections;
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {Iterable<ModuleGraphConnection>} list of outgoing connections
+	 */
+	getOutgoingConnections(module) {
+		const connections = this._getModuleGraphModule(module).outgoingConnections;
+		return connections === undefined ? EMPTY_SET : connections;
+	}
 
-const { applyWebpackOptionsDefaults } = __webpack_require__(92988);
-const { getNormalizedWebpackOptions } = __webpack_require__(26693);
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 */
+	getIncomingConnectionsByOriginModule(module) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
+	}
 
-class WebpackOptionsDefaulter {
-	process(options) {
-		options = getNormalizedWebpackOptions(options);
-		applyWebpackOptionsDefaults(options);
-		return options;
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
+	 */
+	getOutgoingConnectionsByModule(module) {
+		const connections = this._getModuleGraphModule(module).outgoingConnections;
+		return connections === undefined
+			? undefined
+			: connections.getFromUnorderedCache(getConnectionsByModule);
 	}
-}
 
-module.exports = WebpackOptionsDefaulter;
+	/**
+	 * @param {Module} module the module
+	 * @returns {ModuleProfile | null} the module profile
+	 */
+	getProfile(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.profile;
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {ModuleProfile | null} profile the module profile
+	 * @returns {void}
+	 */
+	setProfile(module, profile) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.profile = profile;
+	}
 
-/***/ }),
+	/**
+	 * @param {Module} module the module
+	 * @returns {Module | null} the issuer module
+	 */
+	getIssuer(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.issuer;
+	}
 
-/***/ 98421:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | null} issuer the issuer module
+	 * @returns {void}
+	 */
+	setIssuer(module, issuer) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.issuer = issuer;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | null} issuer the issuer module
+	 * @returns {void}
+	 */
+	setIssuerIfUnset(module, issuer) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.issuer === undefined) mgm.issuer = issuer;
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {(string | OptimizationBailoutFunction)[]} optimization bailouts
+	 */
+	getOptimizationBailout(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.optimizationBailout;
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {true | string[] | null} the provided exports
+	 */
+	getProvidedExports(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getProvidedExports();
+	}
 
-const mimeTypes = __webpack_require__(78585);
-const path = __webpack_require__(71017);
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const RuntimeGlobals = __webpack_require__(16475);
-const createHash = __webpack_require__(49835);
-const { makePathsRelative } = __webpack_require__(82186);
+	/**
+	 * @param {Module} module the module
+	 * @param {string | string[]} exportName a name of an export
+	 * @returns {boolean | null} true, if the export is provided by the module.
+	 * null, if it's unknown.
+	 * false, if it's not provided.
+	 */
+	isExportProvided(module, exportName) {
+		const mgm = this._getModuleGraphModule(module);
+		const result = mgm.exports.isExportProvided(exportName);
+		return result === undefined ? null : result;
+	}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
-/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
+	/**
+	 * @param {Module} module the module
+	 * @returns {ExportsInfo} info about the exports
+	 */
+	getExportsInfo(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports;
+	}
 
-const mergeMaybeArrays = (a, b) => {
-	const set = new Set();
-	if (Array.isArray(a)) for (const item of a) set.add(item);
-	else set.add(a);
-	if (Array.isArray(b)) for (const item of b) set.add(item);
-	else set.add(b);
-	return Array.from(set);
-};
+	/**
+	 * @param {Module} module the module
+	 * @param {string} exportName the export
+	 * @returns {ExportInfo} info about the export
+	 */
+	getExportInfo(module, exportName) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getExportInfo(exportName);
+	}
 
-const mergeAssetInfo = (a, b) => {
-	const result = { ...a, ...b };
-	for (const key of Object.keys(a)) {
-		if (key in b) {
-			if (a[key] === b[key]) continue;
-			switch (key) {
-				case "fullhash":
-				case "chunkhash":
-				case "modulehash":
-				case "contenthash":
-					result[key] = mergeMaybeArrays(a[key], b[key]);
-					break;
-				case "immutable":
-				case "development":
-				case "hotModuleReplacement":
-				case "javascriptModule":
-					result[key] = a[key] || b[key];
-					break;
-				case "related":
-					result[key] = mergeRelatedInfo(a[key], b[key]);
-					break;
-				default:
-					throw new Error(`Can't handle conflicting asset info for ${key}`);
-			}
-		}
+	/**
+	 * @param {Module} module the module
+	 * @param {string} exportName the export
+	 * @returns {ExportInfo} info about the export (do not modify)
+	 */
+	getReadOnlyExportInfo(module, exportName) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getReadOnlyExportInfo(exportName);
 	}
-	return result;
-};
 
-const mergeRelatedInfo = (a, b) => {
-	const result = { ...a, ...b };
-	for (const key of Object.keys(a)) {
-		if (key in b) {
-			if (a[key] === b[key]) continue;
-			result[key] = mergeMaybeArrays(a[key], b[key]);
-		}
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {false | true | SortableSet<string> | null} the used exports
+	 * false: module is not used at all.
+	 * true: the module namespace/object export is used.
+	 * SortableSet<string>: these export names are used.
+	 * empty SortableSet<string>: module is used but no export.
+	 * null: unknown, worst case should be assumed.
+	 */
+	getUsedExports(module, runtime) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getUsedExports(runtime);
 	}
-	return result;
-};
 
-const encodeDataUri = (encoding, source) => {
-	let encodedContent;
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the index of the module
+	 */
+	getPreOrderIndex(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.preOrderIndex;
+	}
 
-	switch (encoding) {
-		case "base64": {
-			encodedContent = source.buffer().toString("base64");
-			break;
-		}
-		case false: {
-			const content = source.source();
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the index of the module
+	 */
+	getPostOrderIndex(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.postOrderIndex;
+	}
 
-			if (typeof content !== "string") {
-				encodedContent = content.toString("utf-8");
-			}
+	/**
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {void}
+	 */
+	setPreOrderIndex(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.preOrderIndex = index;
+	}
 
-			encodedContent = encodeURIComponent(encodedContent).replace(
-				/[!'()*]/g,
-				character => "%" + character.codePointAt(0).toString(16)
-			);
-			break;
+	/**
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {boolean} true, if the index was set
+	 */
+	setPreOrderIndexIfUnset(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.preOrderIndex === null) {
+			mgm.preOrderIndex = index;
+			return true;
 		}
-		default:
-			throw new Error(`Unsupported encoding '${encoding}'`);
+		return false;
 	}
 
-	return encodedContent;
-};
-
-const decodeDataUriContent = (encoding, content) => {
-	const isBase64 = encoding === "base64";
-	return isBase64
-		? Buffer.from(content, "base64")
-		: Buffer.from(decodeURIComponent(content), "ascii");
-};
-
-const JS_TYPES = new Set(["javascript"]);
-const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
-
-class AssetGenerator extends Generator {
 	/**
-	 * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url
-	 * @param {string=} filename override for output.assetModuleFilename
-	 * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath
-	 * @param {AssetModuleOutputPath=} outputPath the output path for the emitted file which is not included in the runtime import
-	 * @param {boolean=} emit generate output asset
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {void}
 	 */
-	constructor(dataUrlOptions, filename, publicPath, outputPath, emit) {
-		super();
-		this.dataUrlOptions = dataUrlOptions;
-		this.filename = filename;
-		this.publicPath = publicPath;
-		this.outputPath = outputPath;
-		this.emit = emit;
+	setPostOrderIndex(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.postOrderIndex = index;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {boolean} true, if the index was set
 	 */
-	generate(
-		module,
-		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
-	) {
-		switch (type) {
-			case "asset":
-				return module.originalSource();
-			default: {
-				runtimeRequirements.add(RuntimeGlobals.module);
+	setPostOrderIndexIfUnset(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.postOrderIndex === null) {
+			mgm.postOrderIndex = index;
+			return true;
+		}
+		return false;
+	}
 
-				const originalSource = module.originalSource();
-				if (module.buildInfo.dataUrl) {
-					let encodedSource;
-					if (typeof this.dataUrlOptions === "function") {
-						encodedSource = this.dataUrlOptions.call(
-							null,
-							originalSource.source(),
-							{
-								filename: module.matchResource || module.resource,
-								module
-							}
-						);
-					} else {
-						/** @type {string | false | undefined} */
-						let encoding = this.dataUrlOptions.encoding;
-						if (encoding === undefined) {
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.encoding !== undefined
-							) {
-								encoding = module.resourceResolveData.encoding;
-							}
-						}
-						if (encoding === undefined) {
-							encoding = "base64";
-						}
-						let ext;
-						let mimeType = this.dataUrlOptions.mimetype;
-						if (mimeType === undefined) {
-							ext = path.extname(module.nameForCondition());
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.mimetype !== undefined
-							) {
-								mimeType =
-									module.resourceResolveData.mimetype +
-									module.resourceResolveData.parameters;
-							} else if (ext) {
-								mimeType = mimeTypes.lookup(ext);
-							}
-						}
-						if (typeof mimeType !== "string") {
-							throw new Error(
-								"DataUrl can't be generated automatically, " +
-									`because there is no mimetype for "${ext}" in mimetype database. ` +
-									'Either pass a mimetype via "generator.mimetype" or ' +
-									'use type: "asset/resource" to create a resource file instead of a DataUrl'
-							);
-						}
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the depth of the module
+	 */
+	getDepth(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.depth;
+	}
 
-						let encodedContent;
+	/**
+	 * @param {Module} module the module
+	 * @param {number} depth the depth of the module
+	 * @returns {void}
+	 */
+	setDepth(module, depth) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.depth = depth;
+	}
 
-						if (
-							module.resourceResolveData &&
-							module.resourceResolveData.encoding === encoding &&
-							decodeDataUriContent(
-								module.resourceResolveData.encoding,
-								module.resourceResolveData.encodedContent
-							).equals(originalSource.buffer())
-						) {
-							encodedContent = module.resourceResolveData.encodedContent;
-						} else {
-							encodedContent = encodeDataUri(encoding, originalSource);
-						}
+	/**
+	 * @param {Module} module the module
+	 * @param {number} depth the depth of the module
+	 * @returns {boolean} true, if the depth was set
+	 */
+	setDepthIfLower(module, depth) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.depth === null || mgm.depth > depth) {
+			mgm.depth = depth;
+			return true;
+		}
+		return false;
+	}
 
-						encodedSource = `data:${mimeType}${
-							encoding ? `;${encoding}` : ""
-						},${encodedContent}`;
-					}
-					const data = getData();
-					data.set("url", Buffer.from(encodedSource));
-					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
-							encodedSource
-						)};`
-					);
-				} else {
-					const assetModuleFilename =
-						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
-					const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
-					if (runtimeTemplate.outputOptions.hashSalt) {
-						hash.update(runtimeTemplate.outputOptions.hashSalt);
-					}
-					hash.update(originalSource.buffer());
-					const fullHash = /** @type {string} */ (
-						hash.digest(runtimeTemplate.outputOptions.hashDigest)
-					);
-					const contentHash = fullHash.slice(
-						0,
-						runtimeTemplate.outputOptions.hashDigestLength
-					);
-					module.buildInfo.fullContentHash = fullHash;
-					const sourceFilename = makePathsRelative(
-						runtimeTemplate.compilation.compiler.context,
-						module.matchResource || module.resource,
-						runtimeTemplate.compilation.compiler.root
-					).replace(/^\.\//, "");
-					let { path: filename, info: assetInfo } =
-						runtimeTemplate.compilation.getAssetPathWithInfo(
-							assetModuleFilename,
-							{
-								module,
-								runtime,
-								filename: sourceFilename,
-								chunkGraph,
-								contentHash
-							}
-						);
-					let assetPath;
-					if (this.publicPath !== undefined) {
-						const { path, info } =
-							runtimeTemplate.compilation.getAssetPathWithInfo(
-								this.publicPath,
-								{
-									module,
-									runtime,
-									filename: sourceFilename,
-									chunkGraph,
-									contentHash
-								}
-							);
-						assetInfo = mergeAssetInfo(assetInfo, info);
-						assetPath = JSON.stringify(path + filename);
-					} else {
-						runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
-						assetPath = runtimeTemplate.concatenation(
-							{ expr: RuntimeGlobals.publicPath },
-							filename
-						);
-					}
-					assetInfo = {
-						sourceFilename,
-						...assetInfo
-					};
-					if (this.outputPath) {
-						const { path: outputPath, info } =
-							runtimeTemplate.compilation.getAssetPathWithInfo(
-								this.outputPath,
-								{
-									module,
-									runtime,
-									filename: sourceFilename,
-									chunkGraph,
-									contentHash
-								}
-							);
-						assetInfo = mergeAssetInfo(assetInfo, info);
-						filename = path.posix.join(outputPath, filename);
-					}
-					module.buildInfo.filename = filename;
-					module.buildInfo.assetInfo = assetInfo;
-					if (getData) {
-						// Due to code generation caching module.buildInfo.XXX can't used to store such information
-						// It need to be stored in the code generation results instead, where it's cached too
-						// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
-						const data = getData();
-						data.set("fullContentHash", fullHash);
-						data.set("filename", filename);
-						data.set("assetInfo", assetInfo);
-					}
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the module is async
+	 */
+	isAsync(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.async;
+	}
 
-					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${assetPath};`
-					);
-				}
-			}
-		}
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	setAsync(module) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.async = true;
 	}
 
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {any} thing any thing
+	 * @returns {Object} metadata
 	 */
-	getTypes(module) {
-		if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) {
-			return JS_TYPES;
-		} else {
-			return JS_AND_ASSET_TYPES;
+	getMeta(thing) {
+		let meta = this._metaMap.get(thing);
+		if (meta === undefined) {
+			meta = Object.create(null);
+			this._metaMap.set(thing, meta);
 		}
+		return meta;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {any} thing any thing
+	 * @returns {Object} metadata
 	 */
-	getSize(module, type) {
-		switch (type) {
-			case "asset": {
-				const originalSource = module.originalSource();
+	getMetaIfExisting(thing) {
+		return this._metaMap.get(thing);
+	}
 
-				if (!originalSource) {
-					return 0;
-				}
+	/**
+	 * @param {string=} cacheStage a persistent stage name for caching
+	 */
+	freeze(cacheStage) {
+		this._cache = new WeakTupleMap();
+		this._cacheStage = cacheStage;
+	}
 
-				return originalSource.size();
-			}
-			default:
-				if (module.buildInfo && module.buildInfo.dataUrl) {
-					const originalSource = module.originalSource();
+	unfreeze() {
+		this._cache = undefined;
+		this._cacheStage = undefined;
+	}
 
-					if (!originalSource) {
-						return 0;
-					}
+	/**
+	 * @template {any[]} T
+	 * @template V
+	 * @param {(moduleGraph: ModuleGraph, ...args: T) => V} fn computer
+	 * @param {T} args arguments
+	 * @returns {V} computed value or cached
+	 */
+	cached(fn, ...args) {
+		if (this._cache === undefined) return fn(this, ...args);
+		return this._cache.provide(fn, ...args, () => fn(this, ...args));
+	}
 
-					// roughly for data url
-					// Example: m.exports="data:image/png;base64,ag82/f+2=="
-					// 4/3 = base64 encoding
-					// 34 = ~ data url header + footer + rounding
-					return originalSource.size() * 1.34 + 36;
-				} else {
-					// it's only estimated so this number is probably fine
-					// Example: m.exports=r.p+"0123456789012345678901.ext"
-					return 42;
-				}
+	/**
+	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 */
+	setModuleMemCaches(moduleMemCaches) {
+		this._moduleMemCaches = moduleMemCaches;
+	}
+
+	/**
+	 * @param {Dependency} dependency dependency
+	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
+	 * @returns {any} computed value or cached
+	 */
+	dependencyCacheProvide(dependency, ...args) {
+		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
+		const fn = args.pop();
+		if (this._moduleMemCaches && this._cacheStage) {
+			const memCache = this._moduleMemCaches.get(
+				this.getParentModule(dependency)
+			);
+			if (memCache !== undefined) {
+				return memCache.provide(dependency, this._cacheStage, ...args, () =>
+					fn(this, dependency, ...args)
+				);
+			}
 		}
+		if (this._cache === undefined) return fn(this, dependency, ...args);
+		return this._cache.provide(dependency, ...args, () =>
+			fn(this, dependency, ...args)
+		);
 	}
 
+	// TODO remove in webpack 6
 	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {Module} module the module
+	 * @param {string} deprecateMessage message for the deprecation message
+	 * @param {string} deprecationCode code for the deprecation
+	 * @returns {ModuleGraph} the module graph
 	 */
-	updateHash(hash, { module }) {
-		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	static getModuleGraphForModule(module, deprecateMessage, deprecationCode) {
+		const fn = deprecateMap.get(deprecateMessage);
+		if (fn) return fn(module);
+		const newFn = util.deprecate(
+			/**
+			 * @param {Module} module the module
+			 * @returns {ModuleGraph} the module graph
+			 */
+			module => {
+				const moduleGraph = moduleGraphForModuleMap.get(module);
+				if (!moduleGraph)
+					throw new Error(
+						deprecateMessage +
+							"There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)"
+					);
+				return moduleGraph;
+			},
+			deprecateMessage + ": Use new ModuleGraph API",
+			deprecationCode
+		);
+		deprecateMap.set(deprecateMessage, newFn);
+		return newFn(module);
+	}
+
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {void}
+	 */
+	static setModuleGraphForModule(module, moduleGraph) {
+		moduleGraphForModuleMap.set(module, moduleGraph);
+	}
+
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	static clearModuleGraphForModule(module) {
+		moduleGraphForModuleMap.delete(module);
 	}
 }
 
-module.exports = AssetGenerator;
+// TODO remove in webpack 6
+/** @type {WeakMap<Module, ModuleGraph>} */
+const moduleGraphForModuleMap = new WeakMap();
+
+// TODO remove in webpack 6
+/** @type {Map<string, (module: Module) => ModuleGraph>} */
+const deprecateMap = new Map();
+
+module.exports = ModuleGraph;
+module.exports.ModuleGraphConnection = ModuleGraphConnection;
 
 
 /***/ }),
 
-/***/ 16109:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 40639:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Yuta Hiroto @hiroppy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { cleverMerge } = __webpack_require__(60839);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const memoize = __webpack_require__(78676);
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/**
+ * Module itself is not connected, but transitive modules are connected transitively.
+ */
+const TRANSITIVE_ONLY = Symbol("transitive only");
 
-const getSchema = name => {
-	const { definitions } = __webpack_require__(73342);
-	return {
-		definitions,
-		oneOf: [{ $ref: `#/definitions/${name}` }]
-	};
-};
+/**
+ * While determining the active state, this flag is used to signal a circular connection.
+ */
+const CIRCULAR_CONNECTION = Symbol("circular connection");
 
-const generatorValidationOptions = {
-	name: "Asset Modules Plugin",
-	baseDataPath: "generator"
+/** @typedef {boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION} ConnectionState */
+
+/**
+ * @param {ConnectionState} a first
+ * @param {ConnectionState} b second
+ * @returns {ConnectionState} merged
+ */
+const addConnectionStates = (a, b) => {
+	if (a === true || b === true) return true;
+	if (a === false) return b;
+	if (b === false) return a;
+	if (a === TRANSITIVE_ONLY) return b;
+	if (b === TRANSITIVE_ONLY) return a;
+	return a;
 };
-const validateGeneratorOptions = {
-	asset: createSchemaValidation(
-		__webpack_require__(55125),
-		() => getSchema("AssetGeneratorOptions"),
-		generatorValidationOptions
-	),
-	"asset/resource": createSchemaValidation(
-		__webpack_require__(4405),
-		() => getSchema("AssetResourceGeneratorOptions"),
-		generatorValidationOptions
-	),
-	"asset/inline": createSchemaValidation(
-		__webpack_require__(62368),
-		() => getSchema("AssetInlineGeneratorOptions"),
-		generatorValidationOptions
-	)
+
+/**
+ * @param {ConnectionState} a first
+ * @param {ConnectionState} b second
+ * @returns {ConnectionState} intersected
+ */
+const intersectConnectionStates = (a, b) => {
+	if (a === false || b === false) return false;
+	if (a === true) return b;
+	if (b === true) return a;
+	if (a === CIRCULAR_CONNECTION) return b;
+	if (b === CIRCULAR_CONNECTION) return a;
+	return a;
 };
 
-const validateParserOptions = createSchemaValidation(
-	__webpack_require__(45020),
-	() => getSchema("AssetParserOptions"),
-	{
-		name: "Asset Modules Plugin",
-		baseDataPath: "parser"
+class ModuleGraphConnection {
+	/**
+	 * @param {Module|null} originModule the referencing module
+	 * @param {Dependency|null} dependency the referencing dependency
+	 * @param {Module} module the referenced module
+	 * @param {string=} explanation some extra detail
+	 * @param {boolean=} weak the reference is weak
+	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
+	 */
+	constructor(
+		originModule,
+		dependency,
+		module,
+		explanation,
+		weak = false,
+		condition = undefined
+	) {
+		this.originModule = originModule;
+		this.resolvedOriginModule = originModule;
+		this.dependency = dependency;
+		this.resolvedModule = module;
+		this.module = module;
+		this.weak = weak;
+		this.conditional = !!condition;
+		this._active = condition !== false;
+		/** @type {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} */
+		this.condition = condition || undefined;
+		/** @type {Set<string>} */
+		this.explanations = undefined;
+		if (explanation) {
+			this.explanations = new Set();
+			this.explanations.add(explanation);
+		}
+	}
+
+	clone() {
+		const clone = new ModuleGraphConnection(
+			this.resolvedOriginModule,
+			this.dependency,
+			this.resolvedModule,
+			undefined,
+			this.weak,
+			this.condition
+		);
+		clone.originModule = this.originModule;
+		clone.module = this.module;
+		clone.conditional = this.conditional;
+		clone._active = this._active;
+		if (this.explanations) clone.explanations = new Set(this.explanations);
+		return clone;
+	}
+
+	/**
+	 * @param {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} condition condition for the connection
+	 * @returns {void}
+	 */
+	addCondition(condition) {
+		if (this.conditional) {
+			const old = this.condition;
+			this.condition = (c, r) =>
+				intersectConnectionStates(old(c, r), condition(c, r));
+		} else if (this._active) {
+			this.conditional = true;
+			this.condition = condition;
+		}
+	}
+
+	/**
+	 * @param {string} explanation the explanation to add
+	 * @returns {void}
+	 */
+	addExplanation(explanation) {
+		if (this.explanations === undefined) {
+			this.explanations = new Set();
+		}
+		this.explanations.add(explanation);
+	}
+
+	get explanation() {
+		if (this.explanations === undefined) return "";
+		return Array.from(this.explanations).join(" ");
+	}
+
+	// TODO webpack 5 remove
+	get active() {
+		throw new Error("Use getActiveState instead");
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, if the connection is active
+	 */
+	isActive(runtime) {
+		if (!this.conditional) return this._active;
+		return this.condition(this, runtime) !== false;
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, if the connection is active
+	 */
+	isTargetActive(runtime) {
+		if (!this.conditional) return this._active;
+		return this.condition(this, runtime) === true;
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ConnectionState} true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active
+	 */
+	getActiveState(runtime) {
+		if (!this.conditional) return this._active;
+		return this.condition(this, runtime);
+	}
+
+	/**
+	 * @param {boolean} value active or not
+	 * @returns {void}
+	 */
+	setActive(value) {
+		this.conditional = false;
+		this._active = value;
+	}
+
+	set active(value) {
+		throw new Error("Use setActive instead");
 	}
-);
+}
 
-const getAssetGenerator = memoize(() => __webpack_require__(98421));
-const getAssetParser = memoize(() => __webpack_require__(91112));
-const getAssetSourceParser = memoize(() => __webpack_require__(30953));
-const getAssetSourceGenerator = memoize(() =>
-	__webpack_require__(18749)
+/** @typedef {typeof TRANSITIVE_ONLY} TRANSITIVE_ONLY */
+/** @typedef {typeof CIRCULAR_CONNECTION} CIRCULAR_CONNECTION */
+
+module.exports = ModuleGraphConnection;
+module.exports.addConnectionStates = addConnectionStates;
+module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ (
+	TRANSITIVE_ONLY
+);
+module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ (
+	CIRCULAR_CONNECTION
 );
 
-const type = "asset";
-const plugin = "AssetModulesPlugin";
 
-class AssetModulesPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			plugin,
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.createParser
-					.for("asset")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						parserOptions = cleverMerge(
-							compiler.options.module.parser.asset,
-							parserOptions
-						);
+/***/ }),
 
-						let dataUrlCondition = parserOptions.dataUrlCondition;
-						if (!dataUrlCondition || typeof dataUrlCondition === "object") {
-							dataUrlCondition = {
-								maxSize: 8096,
-								...dataUrlCondition
-							};
-						}
+/***/ 3454:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						const AssetParser = getAssetParser();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						return new AssetParser(dataUrlCondition);
-					});
-				normalModuleFactory.hooks.createParser
-					.for("asset/inline")
-					.tap(plugin, parserOptions => {
-						const AssetParser = getAssetParser();
 
-						return new AssetParser(true);
-					});
-				normalModuleFactory.hooks.createParser
-					.for("asset/resource")
-					.tap(plugin, parserOptions => {
-						const AssetParser = getAssetParser();
 
-						return new AssetParser(false);
-					});
-				normalModuleFactory.hooks.createParser
-					.for("asset/source")
-					.tap(plugin, parserOptions => {
-						const AssetSourceParser = getAssetSourceParser();
+const { ConcatSource, RawSource, CachedSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Template = __webpack_require__(39722);
+const JavascriptModulesPlugin = __webpack_require__(89464);
 
-						return new AssetSourceParser();
-					});
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./RequestShortener")} RequestShortener */
 
-				for (const type of ["asset", "asset/inline", "asset/resource"]) {
-					normalModuleFactory.hooks.createGenerator
-						.for(type)
-						.tap(plugin, generatorOptions => {
-							validateGeneratorOptions[type](generatorOptions);
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
+	}
+	return str;
+};
 
-							let dataUrl = undefined;
-							if (type !== "asset/resource") {
-								dataUrl = generatorOptions.dataUrl;
-								if (!dataUrl || typeof dataUrl === "object") {
-									dataUrl = {
-										encoding: undefined,
-										mimetype: undefined,
-										...dataUrl
-									};
-								}
-							}
+/**
+ * @param {ConcatSource} source output
+ * @param {string} indent spacing
+ * @param {ExportsInfo} exportsInfo data
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RequestShortener} requestShortener requestShortener
+ * @param {Set<ExportInfo>} alreadyPrinted deduplication set
+ * @returns {void}
+ */
+const printExportsInfoToSource = (
+	source,
+	indent,
+	exportsInfo,
+	moduleGraph,
+	requestShortener,
+	alreadyPrinted = new Set()
+) => {
+	const otherExportsInfo = exportsInfo.otherExportsInfo;
 
-							let filename = undefined;
-							let publicPath = undefined;
-							let outputPath = undefined;
-							if (type !== "asset/inline") {
-								filename = generatorOptions.filename;
-								publicPath = generatorOptions.publicPath;
-								outputPath = generatorOptions.outputPath;
-							}
+	let alreadyPrintedExports = 0;
 
-							const AssetGenerator = getAssetGenerator();
+	// determine exports to print
+	const printedExports = [];
+	for (const exportInfo of exportsInfo.orderedExports) {
+		if (!alreadyPrinted.has(exportInfo)) {
+			alreadyPrinted.add(exportInfo);
+			printedExports.push(exportInfo);
+		} else {
+			alreadyPrintedExports++;
+		}
+	}
+	let showOtherExports = false;
+	if (!alreadyPrinted.has(otherExportsInfo)) {
+		alreadyPrinted.add(otherExportsInfo);
+		showOtherExports = true;
+	} else {
+		alreadyPrintedExports++;
+	}
 
-							return new AssetGenerator(
-								dataUrl,
-								filename,
-								publicPath,
-								outputPath,
-								generatorOptions.emit !== false
-							);
-						});
-				}
-				normalModuleFactory.hooks.createGenerator
-					.for("asset/source")
-					.tap(plugin, () => {
-						const AssetSourceGenerator = getAssetSourceGenerator();
+	// print the exports
+	for (const exportInfo of printedExports) {
+		const target = exportInfo.getTarget(moduleGraph);
+		source.add(
+			Template.toComment(
+				`${indent}export ${JSON.stringify(exportInfo.name).slice(
+					1,
+					-1
+				)} [${exportInfo.getProvidedInfo()}] [${exportInfo.getUsedInfo()}] [${exportInfo.getRenameInfo()}]${
+					target
+						? ` -> ${target.module.readableIdentifier(requestShortener)}${
+								target.export
+									? ` .${target.export
+											.map(e => JSON.stringify(e).slice(1, -1))
+											.join(".")}`
+									: ""
+						  }`
+						: ""
+				}`
+			) + "\n"
+		);
+		if (exportInfo.exportsInfo) {
+			printExportsInfoToSource(
+				source,
+				indent + "  ",
+				exportInfo.exportsInfo,
+				moduleGraph,
+				requestShortener,
+				alreadyPrinted
+			);
+		}
+	}
 
-						return new AssetSourceGenerator();
-					});
+	if (alreadyPrintedExports) {
+		source.add(
+			Template.toComment(
+				`${indent}... (${alreadyPrintedExports} already listed exports)`
+			) + "\n"
+		);
+	}
 
-				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
-					const { chunkGraph } = compilation;
-					const { chunk, codeGenerationResults } = options;
+	if (showOtherExports) {
+		const target = otherExportsInfo.getTarget(moduleGraph);
+		if (
+			target ||
+			otherExportsInfo.provided !== false ||
+			otherExportsInfo.getUsed(undefined) !== UsageState.Unused
+		) {
+			const title =
+				printedExports.length > 0 || alreadyPrintedExports > 0
+					? "other exports"
+					: "exports";
+			source.add(
+				Template.toComment(
+					`${indent}${title} [${otherExportsInfo.getProvidedInfo()}] [${otherExportsInfo.getUsedInfo()}]${
+						target
+							? ` -> ${target.module.readableIdentifier(requestShortener)}`
+							: ""
+					}`
+				) + "\n"
+			);
+		}
+	}
+};
 
-					const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
-						chunk,
-						"asset",
-						compareModulesByIdentifier
-					);
-					if (modules) {
-						for (const module of modules) {
-							try {
-								const codeGenResult = codeGenerationResults.get(
-									module,
-									chunk.runtime
-								);
-								result.push({
-									render: () => codeGenResult.sources.get(type),
-									filename:
-										module.buildInfo.filename ||
-										codeGenResult.data.get("filename"),
-									info:
-										module.buildInfo.assetInfo ||
-										codeGenResult.data.get("assetInfo"),
-									auxiliary: true,
-									identifier: `assetModule${chunkGraph.getModuleId(module)}`,
-									hash:
-										module.buildInfo.fullContentHash ||
-										codeGenResult.data.get("fullContentHash")
-								});
-							} catch (e) {
-								e.message += `\nduring rendering of asset ${module.identifier()}`;
-								throw e;
-							}
+/** @type {WeakMap<RequestShortener, WeakMap<Module, { header: RawSource, full: WeakMap<Source, CachedSource> }>>} */
+const caches = new WeakMap();
+
+class ModuleInfoHeaderPlugin {
+	/**
+	 * @param {boolean=} verbose add more information like exports, runtime requirements and bailouts
+	 */
+	constructor(verbose = true) {
+		this._verbose = verbose;
+	}
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _verbose: verbose } = this;
+		compiler.hooks.compilation.tap("ModuleInfoHeaderPlugin", compilation => {
+			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+			hooks.renderModulePackage.tap(
+				"ModuleInfoHeaderPlugin",
+				(
+					moduleSource,
+					module,
+					{ chunk, chunkGraph, moduleGraph, runtimeTemplate }
+				) => {
+					const { requestShortener } = runtimeTemplate;
+					let cacheEntry;
+					let cache = caches.get(requestShortener);
+					if (cache === undefined) {
+						caches.set(requestShortener, (cache = new WeakMap()));
+						cache.set(
+							module,
+							(cacheEntry = { header: undefined, full: new WeakMap() })
+						);
+					} else {
+						cacheEntry = cache.get(module);
+						if (cacheEntry === undefined) {
+							cache.set(
+								module,
+								(cacheEntry = { header: undefined, full: new WeakMap() })
+							);
+						} else if (!verbose) {
+							const cachedSource = cacheEntry.full.get(moduleSource);
+							if (cachedSource !== undefined) return cachedSource;
 						}
 					}
-
-					return result;
-				});
-
-				compilation.hooks.prepareModuleExecution.tap(
-					"AssetModulesPlugin",
-					(options, context) => {
-						const { codeGenerationResult } = options;
-						const source = codeGenerationResult.sources.get("asset");
-						if (source === undefined) return;
-						context.assets.set(codeGenerationResult.data.get("filename"), {
-							source,
-							info: codeGenerationResult.data.get("assetInfo")
-						});
+					const source = new ConcatSource();
+					let header = cacheEntry.header;
+					if (header === undefined) {
+						const req = module.readableIdentifier(requestShortener);
+						const reqStr = req.replace(/\*\//g, "*_/");
+						const reqStrStar = "*".repeat(reqStr.length);
+						const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
+						header = new RawSource(headerStr);
+						cacheEntry.header = header;
 					}
-				);
-			}
-		);
+					source.add(header);
+					if (verbose) {
+						const exportsType = module.buildMeta.exportsType;
+						source.add(
+							Template.toComment(
+								exportsType
+									? `${exportsType} exports`
+									: "unknown exports (runtime-defined)"
+							) + "\n"
+						);
+						if (exportsType) {
+							const exportsInfo = moduleGraph.getExportsInfo(module);
+							printExportsInfoToSource(
+								source,
+								"",
+								exportsInfo,
+								moduleGraph,
+								requestShortener
+							);
+						}
+						source.add(
+							Template.toComment(
+								`runtime requirements: ${joinIterableWithComma(
+									chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime)
+								)}`
+							) + "\n"
+						);
+						const optimizationBailout =
+							moduleGraph.getOptimizationBailout(module);
+						if (optimizationBailout) {
+							for (const text of optimizationBailout) {
+								let code;
+								if (typeof text === "function") {
+									code = text(requestShortener);
+								} else {
+									code = text;
+								}
+								source.add(Template.toComment(`${code}`) + "\n");
+							}
+						}
+						source.add(moduleSource);
+						return source;
+					} else {
+						source.add(moduleSource);
+						const cachedSource = new CachedSource(source);
+						cacheEntry.full.set(moduleSource, cachedSource);
+						return cachedSource;
+					}
+				}
+			);
+			hooks.chunkHash.tap("ModuleInfoHeaderPlugin", (chunk, hash) => {
+				hash.update("ModuleInfoHeaderPlugin");
+				hash.update("1");
+			});
+		});
 	}
 }
-
-module.exports = AssetModulesPlugin;
+module.exports = ModuleInfoHeaderPlugin;
 
 
 /***/ }),
 
-/***/ 91112:
+/***/ 32882:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Yuta Hiroto @hiroppy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const Parser = __webpack_require__(11715);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
-class AssetParser extends Parser {
-	/**
-	 * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl
-	 */
-	constructor(dataUrlCondition) {
-		super();
-		this.dataUrlCondition = dataUrlCondition;
-	}
+const previouslyPolyfilledBuiltinModules = {
+	assert: "assert/",
+	buffer: "buffer/",
+	console: "console-browserify",
+	constants: "constants-browserify",
+	crypto: "crypto-browserify",
+	domain: "domain-browser",
+	events: "events/",
+	http: "stream-http",
+	https: "https-browserify",
+	os: "os-browserify/browser",
+	path: "path-browserify",
+	punycode: "punycode/",
+	process: "process/browser",
+	querystring: "querystring-es3",
+	stream: "stream-browserify",
+	_stream_duplex: "readable-stream/duplex",
+	_stream_passthrough: "readable-stream/passthrough",
+	_stream_readable: "readable-stream/readable",
+	_stream_transform: "readable-stream/transform",
+	_stream_writable: "readable-stream/writable",
+	string_decoder: "string_decoder/",
+	sys: "util/",
+	timers: "timers-browserify",
+	tty: "tty-browserify",
+	url: "url/",
+	util: "util/",
+	vm: "vm-browserify",
+	zlib: "browserify-zlib"
+};
 
+class ModuleNotFoundError extends WebpackError {
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {Module} module module tied to dependency
+	 * @param {Error&any} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
 	 */
-	parse(source, state) {
-		if (typeof source === "object" && !Buffer.isBuffer(source)) {
-			throw new Error("AssetParser doesn't accept preparsed AST");
-		}
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
+	constructor(module, err, loc) {
+		let message = `Module not found: ${err.toString()}`;
 
-		if (typeof this.dataUrlCondition === "function") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
-				filename: state.module.matchResource || state.module.resource,
-				module: state.module
-			});
-		} else if (typeof this.dataUrlCondition === "boolean") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition;
-		} else if (
-			this.dataUrlCondition &&
-			typeof this.dataUrlCondition === "object"
-		) {
-			state.module.buildInfo.dataUrl =
-				Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
-		} else {
-			throw new Error("Unexpected dataUrlCondition type");
+		// TODO remove in webpack 6
+		const match = err.message.match(/Can't resolve '([^']+)'/);
+		if (match) {
+			const request = match[1];
+			const alias = previouslyPolyfilledBuiltinModules[request];
+			if (alias) {
+				const pathIndex = alias.indexOf("/");
+				const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
+				message +=
+					"\n\n" +
+					"BREAKING CHANGE: " +
+					"webpack < 5 used to include polyfills for node.js core modules by default.\n" +
+					"This is no longer the case. Verify if you need this module and configure a polyfill for it.\n\n";
+				message +=
+					"If you want to include a polyfill, you need to:\n" +
+					`\t- add a fallback 'resolve.fallback: { "${request}": require.resolve("${alias}") }'\n` +
+					`\t- install '${dependency}'\n`;
+				message +=
+					"If you don't want to include a polyfill, you can use an empty module like this:\n" +
+					`\tresolve.fallback: { "${request}": false }`;
+			}
 		}
 
-		return state;
+		super(message);
+
+		this.name = "ModuleNotFoundError";
+		this.details = err.details;
+		this.module = module;
+		this.error = err;
+		this.loc = loc;
 	}
 }
 
-module.exports = AssetParser;
+module.exports = ModuleNotFoundError;
 
 
 /***/ }),
 
-/***/ 18749:
+/***/ 58443:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const RuntimeGlobals = __webpack_require__(16475);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-const TYPES = new Set(["javascript"]);
+const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
 
-class AssetSourceGenerator extends Generator {
+class ModuleParseError extends WebpackError {
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {string | Buffer} source source code
+	 * @param {Error&any} err the parse error
+	 * @param {string[]} loaders the loaders used
+	 * @param {string} type module type
 	 */
-	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
-
-		const originalSource = module.originalSource();
-
-		if (!originalSource) {
-			return new RawSource("");
-		}
-
-		const content = originalSource.source();
+	constructor(source, err, loaders, type) {
+		let message = "Module parse failed: " + (err && err.message);
+		let loc = undefined;
 
-		let encodedSource;
-		if (typeof content === "string") {
-			encodedSource = content;
+		if (
+			((Buffer.isBuffer(source) && source.slice(0, 4).equals(WASM_HEADER)) ||
+				(typeof source === "string" && /^\0asm/.test(source))) &&
+			!type.startsWith("webassembly")
+		) {
+			message +=
+				"\nThe module seem to be a WebAssembly module, but module is not flagged as WebAssembly module for webpack.";
+			message +=
+				"\nBREAKING CHANGE: Since webpack 5 WebAssembly is not enabled by default and flagged as experimental feature.";
+			message +=
+				"\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
+			message +=
+				"\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
+		} else if (!loaders) {
+			message +=
+				"\nYou may need an appropriate loader to handle this file type.";
+		} else if (loaders.length >= 1) {
+			message += `\nFile was processed with these loaders:${loaders
+				.map(loader => `\n * ${loader}`)
+				.join("")}`;
+			message +=
+				"\nYou may need an additional loader to handle the result of these loaders.";
 		} else {
-			encodedSource = content.toString("utf-8");
-		}
-		return new RawSource(
-			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
-		);
-	}
-
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
-
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-
-		if (!originalSource) {
-			return 0;
+			message +=
+				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
 		}
 
-		// Example: m.exports="abcd"
-		return originalSource.size() + 12;
-	}
-}
+		if (
+			err &&
+			err.loc &&
+			typeof err.loc === "object" &&
+			typeof err.loc.line === "number"
+		) {
+			var lineNumber = err.loc.line;
 
-module.exports = AssetSourceGenerator;
+			if (
+				Buffer.isBuffer(source) ||
+				/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)
+			) {
+				// binary file
+				message += "\n(Source code omitted for this binary file)";
+			} else {
+				const sourceLines = source.split(/\r?\n/);
+				const start = Math.max(0, lineNumber - 3);
+				const linesBefore = sourceLines.slice(start, lineNumber - 1);
+				const theLine = sourceLines[lineNumber - 1];
+				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
 
+				message +=
+					linesBefore.map(l => `\n| ${l}`).join("") +
+					`\n> ${theLine}` +
+					linesAfter.map(l => `\n| ${l}`).join("");
+			}
 
-/***/ }),
+			loc = { start: err.loc };
+		} else if (err && err.stack) {
+			message += "\n" + err.stack;
+		}
 
-/***/ 30953:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		super(message);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Yuta Hiroto @hiroppy
-*/
+		this.name = "ModuleParseError";
+		this.loc = loc;
+		this.error = err;
+	}
 
+	serialize(context) {
+		const { write } = context;
 
+		write(this.error);
 
-const Parser = __webpack_require__(11715);
+		super.serialize(context);
+	}
 
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+	deserialize(context) {
+		const { read } = context;
 
-class AssetSourceParser extends Parser {
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (typeof source === "object" && !Buffer.isBuffer(source)) {
-			throw new Error("AssetSourceParser doesn't accept preparsed AST");
-		}
-		const { module } = state;
-		module.buildInfo.strict = true;
-		module.buildMeta.exportsType = "default";
+		this.error = read();
 
-		return state;
+		super.deserialize(context);
 	}
 }
 
-module.exports = AssetSourceParser;
+makeSerializable(ModuleParseError, "webpack/lib/ModuleParseError");
+
+module.exports = ModuleParseError;
 
 
 /***/ }),
 
-/***/ 19684:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 36418:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -58907,152 +54083,111 @@ module.exports = AssetSourceParser;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
+class ModuleProfile {
+	constructor() {
+		this.startTime = Date.now();
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+		this.factoryStartTime = 0;
+		this.factoryEndTime = 0;
+		this.factory = 0;
+		this.factoryParallelismFactor = 0;
 
-const TYPES = new Set(["javascript"]);
+		this.restoringStartTime = 0;
+		this.restoringEndTime = 0;
+		this.restoring = 0;
+		this.restoringParallelismFactor = 0;
 
-class RawDataUrlModule extends Module {
-	/**
-	 * @param {string} url raw url
-	 * @param {string} identifier unique identifier
-	 * @param {string=} readableIdentifier readable identifier
-	 */
-	constructor(url, identifier, readableIdentifier) {
-		super("asset/raw-data-url", null);
-		this.url = url;
-		this.urlBuffer = url ? Buffer.from(url) : undefined;
-		this.identifierStr = identifier || this.url;
-		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
-	}
+		this.integrationStartTime = 0;
+		this.integrationEndTime = 0;
+		this.integration = 0;
+		this.integrationParallelismFactor = 0;
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+		this.buildingStartTime = 0;
+		this.buildingEndTime = 0;
+		this.building = 0;
+		this.buildingParallelismFactor = 0;
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return this.identifierStr;
-	}
+		this.storingStartTime = 0;
+		this.storingEndTime = 0;
+		this.storing = 0;
+		this.storingParallelismFactor = 0;
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		if (this.url === undefined) this.url = this.urlBuffer.toString();
-		return Math.max(1, this.url.length);
+		this.additionalFactoryTimes = undefined;
+		this.additionalFactories = 0;
+		this.additionalFactoriesParallelismFactor = 0;
+
+		/** @deprecated */
+		this.additionalIntegration = 0;
 	}
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.readableIdentifierStr);
+	markFactoryStart() {
+		this.factoryStartTime = Date.now();
 	}
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
+	markFactoryEnd() {
+		this.factoryEndTime = Date.now();
+		this.factory = this.factoryEndTime - this.factoryStartTime;
 	}
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			cacheable: true
-		};
-		callback();
+	markRestoringStart() {
+		this.restoringStartTime = Date.now();
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		if (this.url === undefined) this.url = this.urlBuffer.toString();
-		const sources = new Map();
-		sources.set(
-			"javascript",
-			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
-		);
-		const data = new Map();
-		data.set("url", this.urlBuffer);
-		const runtimeRequirements = new Set();
-		runtimeRequirements.add(RuntimeGlobals.module);
-		return { sources, runtimeRequirements, data };
+	markRestoringEnd() {
+		this.restoringEndTime = Date.now();
+		this.restoring = this.restoringEndTime - this.restoringStartTime;
 	}
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(this.urlBuffer);
-		super.updateHash(hash, context);
+	markIntegrationStart() {
+		this.integrationStartTime = Date.now();
 	}
 
-	serialize(context) {
-		const { write } = context;
+	markIntegrationEnd() {
+		this.integrationEndTime = Date.now();
+		this.integration = this.integrationEndTime - this.integrationStartTime;
+	}
 
-		write(this.urlBuffer);
-		write(this.identifierStr);
-		write(this.readableIdentifierStr);
+	markBuildingStart() {
+		this.buildingStartTime = Date.now();
+	}
 
-		super.serialize(context);
+	markBuildingEnd() {
+		this.buildingEndTime = Date.now();
+		this.building = this.buildingEndTime - this.buildingStartTime;
 	}
 
-	deserialize(context) {
-		const { read } = context;
+	markStoringStart() {
+		this.storingStartTime = Date.now();
+	}
 
-		this.urlBuffer = read();
-		this.identifierStr = read();
-		this.readableIdentifierStr = read();
+	markStoringEnd() {
+		this.storingEndTime = Date.now();
+		this.storing = this.storingEndTime - this.storingStartTime;
+	}
 
-		super.deserialize(context);
+	// This depends on timing so we ignore it for coverage
+	/* istanbul ignore next */
+	/**
+	 * Merge this profile into another one
+	 * @param {ModuleProfile} realProfile the profile to merge into
+	 * @returns {void}
+	 */
+	mergeInto(realProfile) {
+		realProfile.additionalFactories = this.factory;
+		(realProfile.additionalFactoryTimes =
+			realProfile.additionalFactoryTimes || []).push({
+			start: this.factoryStartTime,
+			end: this.factoryEndTime
+		});
 	}
 }
 
-makeSerializable(RawDataUrlModule, "webpack/lib/asset/RawDataUrlModule");
-
-module.exports = RawDataUrlModule;
+module.exports = ModuleProfile;
 
 
 /***/ }),
 
-/***/ 41153:
+/***/ 94560:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -59063,73 +54198,46 @@ module.exports = RawDataUrlModule;
 
 
 
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-
-/**
- * @typedef {GenerateContext} Context
- */
-class AwaitDependenciesInitFragment extends InitFragment {
-	/**
-	 * @param {Set<string>} promises the promises that should be awaited
-	 */
-	constructor(promises) {
-		super(
-			undefined,
-			InitFragment.STAGE_ASYNC_DEPENDENCIES,
-			0,
-			"await-dependencies"
-		);
-		this.promises = promises;
-	}
+const WebpackError = __webpack_require__(53799);
 
-	merge(other) {
-		const promises = new Set(other.promises);
-		for (const p of this.promises) {
-			promises.add(p);
-		}
-		return new AwaitDependenciesInitFragment(promises);
-	}
+/** @typedef {import("./Module")} Module */
 
+class ModuleRestoreError extends WebpackError {
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {Module} module module tied to dependency
+	 * @param {string | Error} err error thrown
 	 */
-	getContent({ runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
-		const promises = this.promises;
-		if (promises.size === 0) {
-			return "";
-		}
-		if (promises.size === 1) {
-			for (const p of promises) {
-				return Template.asString([
-					`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
-					`${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
-					""
-				]);
+	constructor(module, err) {
+		let message = "Module restore failed: ";
+		let details = undefined;
+		if (err !== null && typeof err === "object") {
+			if (typeof err.stack === "string" && err.stack) {
+				const stack = err.stack;
+				message += stack;
+			} else if (typeof err.message === "string" && err.message) {
+				message += err.message;
+			} else {
+				message += err;
 			}
+		} else {
+			message += String(err);
 		}
-		const sepPromises = Array.from(promises).join(", ");
-		// TODO check if destructuring is supported
-		return Template.asString([
-			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
-			`([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
-			""
-		]);
+
+		super(message);
+
+		this.name = "ModuleRestoreError";
+		this.details = details;
+		this.module = module;
+		this.error = err;
 	}
 }
 
-module.exports = AwaitDependenciesInitFragment;
+module.exports = ModuleRestoreError;
 
 
 /***/ }),
 
-/***/ 59498:
+/***/ 59001:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -59140,59 +54248,46 @@ module.exports = AwaitDependenciesInitFragment;
 
 
 
-const HarmonyImportDependency = __webpack_require__(57154);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("./Module")} Module */
 
-class InferAsyncModulesPlugin {
+class ModuleStoreError extends WebpackError {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Module} module module tied to dependency
+	 * @param {string | Error} err error thrown
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("InferAsyncModulesPlugin", compilation => {
-			const { moduleGraph } = compilation;
-			compilation.hooks.finishModules.tap(
-				"InferAsyncModulesPlugin",
-				modules => {
-					/** @type {Set<Module>} */
-					const queue = new Set();
-					for (const module of modules) {
-						if (module.buildMeta && module.buildMeta.async) {
-							queue.add(module);
-						}
-					}
-					for (const module of queue) {
-						moduleGraph.setAsync(module);
-						for (const [
-							originModule,
-							connections
-						] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-							if (
-								connections.some(
-									c =>
-										c.dependency instanceof HarmonyImportDependency &&
-										c.isTargetActive(undefined)
-								)
-							) {
-								queue.add(originModule);
-							}
-						}
-					}
-				}
-			);
-		});
+	constructor(module, err) {
+		let message = "Module storing failed: ";
+		let details = undefined;
+		if (err !== null && typeof err === "object") {
+			if (typeof err.stack === "string" && err.stack) {
+				const stack = err.stack;
+				message += stack;
+			} else if (typeof err.message === "string" && err.message) {
+				message += err.message;
+			} else {
+				message += err;
+			}
+		} else {
+			message += String(err);
+		}
+
+		super(message);
+
+		this.name = "ModuleStoreError";
+		this.details = details;
+		this.module = module;
+		this.error = err;
 	}
 }
 
-module.exports = InferAsyncModulesPlugin;
+module.exports = ModuleStoreError;
 
 
 /***/ }),
 
-/***/ 79233:
+/***/ 62677:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -59203,1405 +54298,1064 @@ module.exports = InferAsyncModulesPlugin;
 
 
 
-const AsyncDependencyToInitialChunkError = __webpack_require__(30111);
-const { connectChunkGroupParentAndChild } = __webpack_require__(37234);
-const ModuleGraphConnection = __webpack_require__(40639);
-const { getEntryRuntime, mergeRuntime } = __webpack_require__(17156);
+const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./util/Hash")} Hash */
 
-/**
- * @typedef {Object} QueueItem
- * @property {number} action
- * @property {DependenciesBlock} block
- * @property {Module} module
- * @property {Chunk} chunk
- * @property {ChunkGroup} chunkGroup
- * @property {ChunkGroupInfo} chunkGroupInfo
- */
+const getJavascriptModulesPlugin = memoize(() =>
+	__webpack_require__(89464)
+);
 
-/** @typedef {Set<Module> & { plus: Set<Module> }} ModuleSetPlus */
+// TODO webpack 6: remove this class
+class ModuleTemplate {
+	/**
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {Compilation} compilation the compilation
+	 */
+	constructor(runtimeTemplate, compilation) {
+		this._runtimeTemplate = runtimeTemplate;
+		this.type = "javascript";
+		this.hooks = Object.freeze({
+			content: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModuleContent.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
+					"DEP_MODULE_TEMPLATE_CONTENT"
+				)
+			},
+			module: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModuleContent.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
+					"DEP_MODULE_TEMPLATE_MODULE"
+				)
+			},
+			render: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModuleContainer.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)",
+					"DEP_MODULE_TEMPLATE_RENDER"
+				)
+			},
+			package: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModulePackage.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)",
+					"DEP_MODULE_TEMPLATE_PACKAGE"
+				)
+			},
+			hash: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.fullHash.tap(options, fn);
+					},
+					"ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
+					"DEP_MODULE_TEMPLATE_HASH"
+				)
+			}
+		});
+	}
+}
 
-/**
- * @typedef {Object} ChunkGroupInfo
- * @property {ChunkGroup} chunkGroup the chunk group
- * @property {RuntimeSpec} runtime the runtimes
- * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
- * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
- * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
- * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
- * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
- * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
- * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
- * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
- * @property {number} preOrderIndex next pre order index
- * @property {number} postOrderIndex next post order index
- * @property {boolean} chunkLoading has a chunk loading mechanism
- * @property {boolean} asyncChunks create async chunks
- */
+Object.defineProperty(ModuleTemplate.prototype, "runtimeTemplate", {
+	get: util.deprecate(
+		/**
+		 * @this {ModuleTemplate}
+		 * @returns {TODO} output options
+		 */
+		function () {
+			return this._runtimeTemplate;
+		},
+		"ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)",
+		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
 
-/**
- * @typedef {Object} BlockChunkGroupConnection
- * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group
- * @property {ChunkGroup} chunkGroup referenced chunk group
- */
+module.exports = ModuleTemplate;
 
-const EMPTY_SET = /** @type {ModuleSetPlus} */ (new Set());
-EMPTY_SET.plus = EMPTY_SET;
 
-/**
- * @param {ModuleSetPlus} a first set
- * @param {ModuleSetPlus} b second set
- * @returns {number} cmp
- */
-const bySetSize = (a, b) => {
-	return b.size + b.plus.size - a.size - a.plus.size;
-};
+/***/ }),
 
-const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
-	let blockCache;
-	let modules;
+/***/ 11234:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	const arrays = [];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	const queue = [module];
-	while (queue.length > 0) {
-		const block = queue.pop();
-		const arr = [];
-		arrays.push(arr);
-		blockModulesMap.set(block, arr);
-		for (const b of block.blocks) {
-			queue.push(b);
-		}
-	}
 
-	for (const connection of moduleGraph.getOutgoingConnections(module)) {
-		const d = connection.dependency;
-		// We skip connections without dependency
-		if (!d) continue;
-		const m = connection.module;
-		// We skip connections without Module pointer
-		if (!m) continue;
-		// We skip weak connections
-		if (connection.weak) continue;
-		const state = connection.getActiveState(runtime);
-		// We skip inactive connections
-		if (state === false) continue;
 
-		const block = moduleGraph.getParentBlock(d);
-		let index = moduleGraph.getParentBlockIndex(d);
+const { cleanUp } = __webpack_require__(59985);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-		// deprecated fallback
-		if (index < 0) {
-			index = block.dependencies.indexOf(d);
-		}
+class ModuleWarning extends WebpackError {
+	/**
+	 * @param {Error} warning error thrown
+	 * @param {{from?: string|null}} info additional info
+	 */
+	constructor(warning, { from = null } = {}) {
+		let message = "Module Warning";
 
-		if (blockCache !== block) {
-			modules = blockModulesMap.get((blockCache = block));
+		if (from) {
+			message += ` (from ${from}):\n`;
+		} else {
+			message += ": ";
 		}
 
-		const i = index << 2;
-		modules[i] = m;
-		modules[i + 1] = state;
-	}
-
-	for (const modules of arrays) {
-		if (modules.length === 0) continue;
-		let indexMap;
-		let length = 0;
-		outer: for (let j = 0; j < modules.length; j += 2) {
-			const m = modules[j];
-			if (m === undefined) continue;
-			const state = modules[j + 1];
-			if (indexMap === undefined) {
-				let i = 0;
-				for (; i < length; i += 2) {
-					if (modules[i] === m) {
-						const merged = modules[i + 1];
-						if (merged === true) continue outer;
-						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
-							merged,
-							state
-						);
-					}
-				}
-				modules[length] = m;
-				length++;
-				modules[length] = state;
-				length++;
-				if (length > 30) {
-					// To avoid worse case performance, we will use an index map for
-					// linear cost access, which allows to maintain O(n) complexity
-					// while keeping allocations down to a minimum
-					indexMap = new Map();
-					for (let i = 0; i < length; i += 2) {
-						indexMap.set(modules[i], i + 1);
-					}
-				}
-			} else {
-				const idx = indexMap.get(m);
-				if (idx !== undefined) {
-					const merged = modules[idx];
-					if (merged === true) continue outer;
-					modules[idx] = ModuleGraphConnection.addConnectionStates(
-						merged,
-						state
-					);
-				} else {
-					modules[length] = m;
-					length++;
-					modules[length] = state;
-					indexMap.set(m, length);
-					length++;
-				}
-			}
+		if (warning && typeof warning === "object" && warning.message) {
+			message += warning.message;
+		} else if (warning) {
+			message += String(warning);
 		}
-		modules.length = length;
-	}
-};
 
-/**
- *
- * @param {Logger} logger a logger
- * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Set<ChunkGroup>} allCreatedChunkGroups filled with all chunk groups that are created here
- */
-const visitModules = (
-	logger,
-	compilation,
-	inputEntrypointsAndModules,
-	chunkGroupInfoMap,
-	blockConnections,
-	blocksWithNestedBlocks,
-	allCreatedChunkGroups
-) => {
-	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
+		super(message);
 
-	const blockModulesRuntimeMap = new Map();
+		this.name = "ModuleWarning";
+		this.warning = warning;
+		this.details =
+			warning && typeof warning === "object" && warning.stack
+				? cleanUp(warning.stack, this.message)
+				: undefined;
+	}
 
-	/** @type {RuntimeSpec | false} */
-	let blockModulesMapRuntime = false;
-	let blockModulesMap;
+	serialize(context) {
+		const { write } = context;
 
-	/**
-	 *
-	 * @param {DependenciesBlock} block block
-	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
-	 */
-	const getBlockModules = (block, runtime) => {
-		if (blockModulesMapRuntime !== runtime) {
-			blockModulesMap = blockModulesRuntimeMap.get(runtime);
-			if (blockModulesMap === undefined) {
-				blockModulesMap = new Map();
-				blockModulesRuntimeMap.set(runtime, blockModulesMap);
-			}
-		}
-		let blockModules = blockModulesMap.get(block);
-		if (blockModules !== undefined) return blockModules;
-		const module = /** @type {Module} */ (block.getRootBlock());
-		const memCache = moduleMemCaches && moduleMemCaches.get(module);
-		if (memCache !== undefined) {
-			const map = memCache.provide(
-				"bundleChunkGraph.blockModules",
-				runtime,
-				() => {
-					logger.time("visitModules: prepare");
-					const map = new Map();
-					extractBlockModules(module, moduleGraph, runtime, map);
-					logger.timeAggregate("visitModules: prepare");
-					return map;
-				}
-			);
-			for (const [block, blockModules] of map)
-				blockModulesMap.set(block, blockModules);
-			return map.get(block);
-		} else {
-			logger.time("visitModules: prepare");
-			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
-			blockModules = blockModulesMap.get(block);
-			logger.timeAggregate("visitModules: prepare");
-			return blockModules;
-		}
-	};
+		write(this.warning);
 
-	let statProcessedQueueItems = 0;
-	let statProcessedBlocks = 0;
-	let statConnectedChunkGroups = 0;
-	let statProcessedChunkGroupsForMerging = 0;
-	let statMergedAvailableModuleSets = 0;
-	let statForkedAvailableModules = 0;
-	let statForkedAvailableModulesCount = 0;
-	let statForkedAvailableModulesCountPlus = 0;
-	let statForkedMergedModulesCount = 0;
-	let statForkedMergedModulesCountPlus = 0;
-	let statForkedResultModulesCount = 0;
-	let statChunkGroupInfoUpdated = 0;
-	let statChildChunkGroupsReconnected = 0;
+		super.serialize(context);
+	}
 
-	let nextChunkGroupIndex = 0;
-	let nextFreeModulePreOrderIndex = 0;
-	let nextFreeModulePostOrderIndex = 0;
+	deserialize(context) {
+		const { read } = context;
 
-	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
-	const blockChunkGroups = new Map();
+		this.warning = read();
 
-	/** @type {Map<string, ChunkGroupInfo>} */
-	const namedChunkGroups = new Map();
+		super.deserialize(context);
+	}
+}
 
-	/** @type {Map<string, ChunkGroupInfo>} */
-	const namedAsyncEntrypoints = new Map();
+makeSerializable(ModuleWarning, "webpack/lib/ModuleWarning");
 
-	const ADD_AND_ENTER_ENTRY_MODULE = 0;
-	const ADD_AND_ENTER_MODULE = 1;
-	const ENTER_MODULE = 2;
-	const PROCESS_BLOCK = 3;
-	const PROCESS_ENTRY_BLOCK = 4;
-	const LEAVE_MODULE = 5;
+module.exports = ModuleWarning;
 
-	/** @type {QueueItem[]} */
-	let queue = [];
 
-	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
-	const queueConnect = new Map();
-	/** @type {Set<ChunkGroupInfo>} */
-	const chunkGroupsForCombining = new Set();
+/***/ }),
 
-	// Fill queue with entrypoint modules
-	// Create ChunkGroupInfo for entrypoints
-	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
-		const runtime = getEntryRuntime(
-			compilation,
-			chunkGroup.name,
-			chunkGroup.options
-		);
-		/** @type {ChunkGroupInfo} */
-		const chunkGroupInfo = {
-			chunkGroup,
-			runtime,
-			minAvailableModules: undefined,
-			minAvailableModulesOwned: false,
-			availableModulesToBeMerged: [],
-			skippedItems: undefined,
-			resultingAvailableModules: undefined,
-			children: undefined,
-			availableSources: undefined,
-			availableChildren: undefined,
-			preOrderIndex: 0,
-			postOrderIndex: 0,
-			chunkLoading:
-				chunkGroup.options.chunkLoading !== undefined
-					? chunkGroup.options.chunkLoading !== false
-					: compilation.outputOptions.chunkLoading !== false,
-			asyncChunks:
-				chunkGroup.options.asyncChunks !== undefined
-					? chunkGroup.options.asyncChunks
-					: compilation.outputOptions.asyncChunks !== false
-		};
-		chunkGroup.index = nextChunkGroupIndex++;
-		if (chunkGroup.getNumberOfParents() > 0) {
-			// minAvailableModules for child entrypoints are unknown yet, set to undefined.
-			// This means no module is added until other sets are merged into
-			// this minAvailableModules (by the parent entrypoints)
-			const skippedItems = new Set();
-			for (const module of modules) {
-				skippedItems.add(module);
-			}
-			chunkGroupInfo.skippedItems = skippedItems;
-			chunkGroupsForCombining.add(chunkGroupInfo);
-		} else {
-			// The application may start here: We start with an empty list of available modules
-			chunkGroupInfo.minAvailableModules = EMPTY_SET;
-			const chunk = chunkGroup.getEntrypointChunk();
-			for (const module of modules) {
-				queue.push({
-					action: ADD_AND_ENTER_MODULE,
-					block: module,
-					module,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			}
-		}
-		chunkGroupInfoMap.set(chunkGroup, chunkGroupInfo);
-		if (chunkGroup.name) {
-			namedChunkGroups.set(chunkGroup.name, chunkGroupInfo);
-		}
-	}
-	// Fill availableSources with parent-child dependencies between entrypoints
-	for (const chunkGroupInfo of chunkGroupsForCombining) {
-		const { chunkGroup } = chunkGroupInfo;
-		chunkGroupInfo.availableSources = new Set();
-		for (const parent of chunkGroup.parentsIterable) {
-			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
-			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
-			if (parentChunkGroupInfo.availableChildren === undefined) {
-				parentChunkGroupInfo.availableChildren = new Set();
-			}
-			parentChunkGroupInfo.availableChildren.add(chunkGroupInfo);
-		}
-	}
-	// pop() is used to read from the queue
-	// so it need to be reversed to be iterated in
-	// correct order
-	queue.reverse();
+/***/ 33370:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/** @type {Set<ChunkGroupInfo>} */
-	const outdatedChunkGroupInfo = new Set();
-	/** @type {Set<ChunkGroupInfo>} */
-	const chunkGroupsForMerging = new Set();
-	/** @type {QueueItem[]} */
-	let queueDelayed = [];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/** @type {[Module, ConnectionState][]} */
-	const skipConnectionBuffer = [];
-	/** @type {Module[]} */
-	const skipBuffer = [];
-	/** @type {QueueItem[]} */
-	const queueBuffer = [];
 
-	/** @type {Module} */
-	let module;
-	/** @type {Chunk} */
-	let chunk;
-	/** @type {ChunkGroup} */
-	let chunkGroup;
-	/** @type {DependenciesBlock} */
-	let block;
-	/** @type {ChunkGroupInfo} */
-	let chunkGroupInfo;
 
-	// For each async Block in graph
-	/**
-	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
-	 * @returns {void}
-	 */
-	const iteratorBlock = b => {
-		// 1. We create a chunk group with single chunk in it for this Block
-		// but only once (blockChunkGroups map)
-		let cgi = blockChunkGroups.get(b);
-		/** @type {ChunkGroup} */
-		let c;
-		/** @type {Entrypoint} */
-		let entrypoint;
-		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
-		if (cgi === undefined) {
-			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
-			if (entryOptions) {
-				cgi = namedAsyncEntrypoints.get(chunkName);
-				if (!cgi) {
-					entrypoint = compilation.addAsyncEntrypoint(
-						entryOptions,
-						module,
-						b.loc,
-						b.request
-					);
-					entrypoint.index = nextChunkGroupIndex++;
-					cgi = {
-						chunkGroup: entrypoint,
-						runtime: entrypoint.options.runtime || entrypoint.name,
-						minAvailableModules: EMPTY_SET,
-						minAvailableModulesOwned: false,
-						availableModulesToBeMerged: [],
-						skippedItems: undefined,
-						resultingAvailableModules: undefined,
-						children: undefined,
-						availableSources: undefined,
-						availableChildren: undefined,
-						preOrderIndex: 0,
-						postOrderIndex: 0,
-						chunkLoading:
-							entryOptions.chunkLoading !== undefined
-								? entryOptions.chunkLoading !== false
-								: chunkGroupInfo.chunkLoading,
-						asyncChunks:
-							entryOptions.asyncChunks !== undefined
-								? entryOptions.asyncChunks
-								: chunkGroupInfo.asyncChunks
-					};
-					chunkGroupInfoMap.set(entrypoint, cgi);
+const asyncLib = __webpack_require__(78175);
+const { SyncHook, MultiHook } = __webpack_require__(41242);
 
-					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
-					if (chunkName) {
-						namedAsyncEntrypoints.set(chunkName, cgi);
-					}
-				} else {
-					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// TODO merge entryOptions
-					entrypoint.addOrigin(module, b.loc, b.request);
-					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
-				}
+const ConcurrentCompilationError = __webpack_require__(95735);
+const MultiStats = __webpack_require__(24170);
+const MultiWatching = __webpack_require__(81128);
+const ArrayQueue = __webpack_require__(41792);
 
-				// 2. We enqueue the DependenciesBlock for traversal
-				queueDelayed.push({
-					action: PROCESS_ENTRY_BLOCK,
-					block: b,
-					module: module,
-					chunk: entrypoint.chunks[0],
-					chunkGroup: entrypoint,
-					chunkGroupInfo: cgi
-				});
-			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
-				// Just queue the block into the current chunk group
-				queue.push({
-					action: PROCESS_BLOCK,
-					block: b,
-					module: module,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			} else {
-				cgi = chunkName && namedChunkGroups.get(chunkName);
-				if (!cgi) {
-					c = compilation.addChunkInGroup(
-						b.groupOptions || b.chunkName,
-						module,
-						b.loc,
-						b.request
-					);
-					c.index = nextChunkGroupIndex++;
-					cgi = {
-						chunkGroup: c,
-						runtime: chunkGroupInfo.runtime,
-						minAvailableModules: undefined,
-						minAvailableModulesOwned: undefined,
-						availableModulesToBeMerged: [],
-						skippedItems: undefined,
-						resultingAvailableModules: undefined,
-						children: undefined,
-						availableSources: undefined,
-						availableChildren: undefined,
-						preOrderIndex: 0,
-						postOrderIndex: 0,
-						chunkLoading: chunkGroupInfo.chunkLoading,
-						asyncChunks: chunkGroupInfo.asyncChunks
-					};
-					allCreatedChunkGroups.add(c);
-					chunkGroupInfoMap.set(c, cgi);
-					if (chunkName) {
-						namedChunkGroups.set(chunkName, cgi);
-					}
-				} else {
-					c = cgi.chunkGroup;
-					if (c.isInitial()) {
-						compilation.errors.push(
-							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
-						);
-						c = chunkGroup;
-					}
-					c.addOptions(b.groupOptions);
-					c.addOrigin(module, b.loc, b.request);
-				}
-				blockConnections.set(b, []);
-			}
-			blockChunkGroups.set(b, cgi);
-		} else if (entryOptions) {
-			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-		} else {
-			c = cgi.chunkGroup;
-		}
+/** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
+/** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Stats")} Stats */
+/** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
-		if (c !== undefined) {
-			// 2. We store the connection for the block
-			// to connect it later if needed
-			blockConnections.get(b).push({
-				originChunkGroupInfo: chunkGroupInfo,
-				chunkGroup: c
-			});
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
 
-			// 3. We enqueue the chunk group info creation/updating
-			let connectList = queueConnect.get(chunkGroupInfo);
-			if (connectList === undefined) {
-				connectList = new Set();
-				queueConnect.set(chunkGroupInfo, connectList);
-			}
-			connectList.add(cgi);
+/**
+ * @callback RunWithDependenciesHandler
+ * @param {Compiler} compiler
+ * @param {Callback<MultiStats>} callback
+ */
 
-			// TODO check if this really need to be done for each traversal
-			// or if it is enough when it's queued when created
-			// 4. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module: module,
-				chunk: c.chunks[0],
-				chunkGroup: c,
-				chunkGroupInfo: cgi
-			});
-		} else if (entrypoint !== undefined) {
-			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
-		}
-	};
+/**
+ * @typedef {Object} MultiCompilerOptions
+ * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
+ */
 
+module.exports = class MultiCompiler {
 	/**
-	 * @param {DependenciesBlock} block the block
-	 * @returns {void}
+	 * @param {Compiler[] | Record<string, Compiler>} compilers child compilers
+	 * @param {MultiCompilerOptions} options options
 	 */
-	const processBlock = block => {
-		statProcessedBlocks++;
-		// get prepared block info
-		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
+	constructor(compilers, options) {
+		if (!Array.isArray(compilers)) {
+			compilers = Object.keys(compilers).map(name => {
+				compilers[name].name = name;
+				return compilers[name];
+			});
+		}
 
-		if (blockModules !== undefined) {
-			const { minAvailableModules } = chunkGroupInfo;
-			// Buffer items because order need to be reversed to get indices correct
-			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
-					// skip early if already connected
-					continue;
-				}
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
-				);
-				if (activeState !== true) {
-					skipConnectionBuffer.push([refModule, activeState]);
-					if (activeState === false) continue;
-				}
-				if (
-					activeState === true &&
-					(minAvailableModules.has(refModule) ||
-						minAvailableModules.plus.has(refModule))
-				) {
-					// already in parent chunks, skip it for now
-					skipBuffer.push(refModule);
-					continue;
-				}
-				// enqueue, then add and enter to be in the correct order
-				// this is relevant with circular dependencies
-				queueBuffer.push({
-					action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
-					block: refModule,
-					module: refModule,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			}
-			// Add buffered items in reverse order
-			if (skipConnectionBuffer.length > 0) {
-				let { skippedModuleConnections } = chunkGroupInfo;
-				if (skippedModuleConnections === undefined) {
-					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections =
-						new Set();
-				}
-				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
-					skippedModuleConnections.add(skipConnectionBuffer[i]);
-				}
-				skipConnectionBuffer.length = 0;
-			}
-			if (skipBuffer.length > 0) {
-				let { skippedItems } = chunkGroupInfo;
-				if (skippedItems === undefined) {
-					chunkGroupInfo.skippedItems = skippedItems = new Set();
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[MultiStats]>} */
+			done: new SyncHook(["stats"]),
+			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
+			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
+			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
+			run: new MultiHook(compilers.map(c => c.hooks.run)),
+			/** @type {SyncHook<[]>} */
+			watchClose: new SyncHook([]),
+			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
+			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
+			/** @type {MultiHook<SyncBailHook<[string, string, any[]], true>>} */
+			infrastructureLog: new MultiHook(
+				compilers.map(c => c.hooks.infrastructureLog)
+			)
+		});
+		this.compilers = compilers;
+		/** @type {MultiCompilerOptions} */
+		this._options = {
+			parallelism: options.parallelism || Infinity
+		};
+		/** @type {WeakMap<Compiler, string[]>} */
+		this.dependencies = new WeakMap();
+		this.running = false;
+
+		/** @type {Stats[]} */
+		const compilerStats = this.compilers.map(() => null);
+		let doneCompilers = 0;
+		for (let index = 0; index < this.compilers.length; index++) {
+			const compiler = this.compilers[index];
+			const compilerIndex = index;
+			let compilerDone = false;
+			compiler.hooks.done.tap("MultiCompiler", stats => {
+				if (!compilerDone) {
+					compilerDone = true;
+					doneCompilers++;
 				}
-				for (let i = skipBuffer.length - 1; i >= 0; i--) {
-					skippedItems.add(skipBuffer[i]);
+				compilerStats[compilerIndex] = stats;
+				if (doneCompilers === this.compilers.length) {
+					this.hooks.done.call(new MultiStats(compilerStats));
 				}
-				skipBuffer.length = 0;
-			}
-			if (queueBuffer.length > 0) {
-				for (let i = queueBuffer.length - 1; i >= 0; i--) {
-					queue.push(queueBuffer[i]);
+			});
+			compiler.hooks.invalid.tap("MultiCompiler", () => {
+				if (compilerDone) {
+					compilerDone = false;
+					doneCompilers--;
 				}
-				queueBuffer.length = 0;
-			}
+			});
 		}
+	}
 
-		// Traverse all Blocks
-		for (const b of block.blocks) {
-			iteratorBlock(b);
-		}
+	get options() {
+		return Object.assign(
+			this.compilers.map(c => c.options),
+			this._options
+		);
+	}
 
-		if (block.blocks.length > 0 && module !== block) {
-			blocksWithNestedBlocks.add(block);
+	get outputPath() {
+		let commonPath = this.compilers[0].outputPath;
+		for (const compiler of this.compilers) {
+			while (
+				compiler.outputPath.indexOf(commonPath) !== 0 &&
+				/[/\\]/.test(commonPath)
+			) {
+				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
+			}
 		}
-	};
+
+		if (!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
+		return commonPath;
+	}
+
+	get inputFileSystem() {
+		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
+	}
+
+	get outputFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
+
+	get watchFileSystem() {
+		throw new Error("Cannot read watchFileSystem of a MultiCompiler");
+	}
+
+	get intermediateFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
 
 	/**
-	 * @param {DependenciesBlock} block the block
-	 * @returns {void}
+	 * @param {InputFileSystem} value the new input file system
 	 */
-	const processEntryBlock = block => {
-		statProcessedBlocks++;
-		// get prepared block info
-		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
-
-		if (blockModules !== undefined) {
-			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
-				);
-				// enqueue, then add and enter to be in the correct order
-				// this is relevant with circular dependencies
-				queueBuffer.push({
-					action:
-						activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK,
-					block: refModule,
-					module: refModule,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			}
-			// Add buffered items in reverse order
-			if (queueBuffer.length > 0) {
-				for (let i = queueBuffer.length - 1; i >= 0; i--) {
-					queue.push(queueBuffer[i]);
-				}
-				queueBuffer.length = 0;
-			}
+	set inputFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.inputFileSystem = value;
 		}
+	}
 
-		// Traverse all Blocks
-		for (const b of block.blocks) {
-			iteratorBlock(b);
+	/**
+	 * @param {OutputFileSystem} value the new output file system
+	 */
+	set outputFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.outputFileSystem = value;
 		}
+	}
 
-		if (block.blocks.length > 0 && module !== block) {
-			blocksWithNestedBlocks.add(block);
+	/**
+	 * @param {WatchFileSystem} value the new watch file system
+	 */
+	set watchFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.watchFileSystem = value;
 		}
-	};
+	}
 
-	const processQueue = () => {
-		while (queue.length) {
-			statProcessedQueueItems++;
-			const queueItem = queue.pop();
-			module = queueItem.module;
-			block = queueItem.block;
-			chunk = queueItem.chunk;
-			chunkGroup = queueItem.chunkGroup;
-			chunkGroupInfo = queueItem.chunkGroupInfo;
+	/**
+	 * @param {IntermediateFileSystem} value the new intermediate file system
+	 */
+	set intermediateFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.intermediateFileSystem = value;
+		}
+	}
 
-			switch (queueItem.action) {
-				case ADD_AND_ENTER_ENTRY_MODULE:
-					chunkGraph.connectChunkAndEntryModule(
-						chunk,
-						module,
-						/** @type {Entrypoint} */ (chunkGroup)
-					);
-				// fallthrough
-				case ADD_AND_ENTER_MODULE: {
-					if (chunkGraph.isModuleInChunk(module, chunk)) {
-						// already connected, skip it
-						break;
-					}
-					// We connect Module and Chunk
-					chunkGraph.connectChunkAndModule(chunk, module);
-				}
-				// fallthrough
-				case ENTER_MODULE: {
-					const index = chunkGroup.getModulePreOrderIndex(module);
-					if (index === undefined) {
-						chunkGroup.setModulePreOrderIndex(
-							module,
-							chunkGroupInfo.preOrderIndex++
-						);
-					}
+	getInfrastructureLogger(name) {
+		return this.compilers[0].getInfrastructureLogger(name);
+	}
 
-					if (
-						moduleGraph.setPreOrderIndexIfUnset(
-							module,
-							nextFreeModulePreOrderIndex
-						)
-					) {
-						nextFreeModulePreOrderIndex++;
-					}
+	/**
+	 * @param {Compiler} compiler the child compiler
+	 * @param {string[]} dependencies its dependencies
+	 * @returns {void}
+	 */
+	setDependencies(compiler, dependencies) {
+		this.dependencies.set(compiler, dependencies);
+	}
 
-					// reuse queueItem
-					queueItem.action = LEAVE_MODULE;
-					queue.push(queueItem);
-				}
-				// fallthrough
-				case PROCESS_BLOCK: {
-					processBlock(block);
-					break;
-				}
-				case PROCESS_ENTRY_BLOCK: {
-					processEntryBlock(block);
-					break;
+	/**
+	 * @param {Callback<MultiStats>} callback signals when the validation is complete
+	 * @returns {boolean} true if the dependencies are valid
+	 */
+	validateDependencies(callback) {
+		/** @type {Set<{source: Compiler, target: Compiler}>} */
+		const edges = new Set();
+		/** @type {string[]} */
+		const missing = [];
+		const targetFound = compiler => {
+			for (const edge of edges) {
+				if (edge.target === compiler) {
+					return true;
 				}
-				case LEAVE_MODULE: {
-					const index = chunkGroup.getModulePostOrderIndex(module);
-					if (index === undefined) {
-						chunkGroup.setModulePostOrderIndex(
-							module,
-							chunkGroupInfo.postOrderIndex++
-						);
+			}
+			return false;
+		};
+		const sortEdges = (e1, e2) => {
+			return (
+				e1.source.name.localeCompare(e2.source.name) ||
+				e1.target.name.localeCompare(e2.target.name)
+			);
+		};
+		for (const source of this.compilers) {
+			const dependencies = this.dependencies.get(source);
+			if (dependencies) {
+				for (const dep of dependencies) {
+					const target = this.compilers.find(c => c.name === dep);
+					if (!target) {
+						missing.push(dep);
+					} else {
+						edges.add({
+							source,
+							target
+						});
 					}
-
-					if (
-						moduleGraph.setPostOrderIndexIfUnset(
-							module,
-							nextFreeModulePostOrderIndex
-						)
-					) {
-						nextFreeModulePostOrderIndex++;
+				}
+			}
+		}
+		/** @type {string[]} */
+		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
+		const stack = this.compilers.filter(c => !targetFound(c));
+		while (stack.length > 0) {
+			const current = stack.pop();
+			for (const edge of edges) {
+				if (edge.source === current) {
+					edges.delete(edge);
+					const target = edge.target;
+					if (!targetFound(target)) {
+						stack.push(target);
 					}
-					break;
 				}
 			}
 		}
-	};
-
-	const calculateResultingAvailableModules = chunkGroupInfo => {
-		if (chunkGroupInfo.resultingAvailableModules)
-			return chunkGroupInfo.resultingAvailableModules;
-
-		const minAvailableModules = chunkGroupInfo.minAvailableModules;
-
-		// Create a new Set of available modules at this point
-		// We want to be as lazy as possible. There are multiple ways doing this:
-		// Note that resultingAvailableModules is stored as "(a) + (b)" as it's a ModuleSetPlus
-		// - resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-		// - resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-		// We choose one depending on the size of minAvailableModules vs minAvailableModules.plus
-
-		let resultingAvailableModules;
-		if (minAvailableModules.size > minAvailableModules.plus.size) {
-			// resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-			resultingAvailableModules =
-				/** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
-			for (const module of minAvailableModules.plus)
-				minAvailableModules.add(module);
-			minAvailableModules.plus = EMPTY_SET;
-			resultingAvailableModules.plus = minAvailableModules;
-			chunkGroupInfo.minAvailableModulesOwned = false;
-		} else {
-			// resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-			resultingAvailableModules =
-				/** @type {Set<Module> & {plus: Set<Module>}} */ (
-					new Set(minAvailableModules)
-				);
-			resultingAvailableModules.plus = minAvailableModules.plus;
+		if (edges.size > 0) {
+			/** @type {string[]} */
+			const lines = Array.from(edges)
+				.sort(sortEdges)
+				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
+			lines.unshift("Circular dependency found in compiler dependencies.");
+			errors.unshift(lines.join("\n"));
 		}
-
-		// add the modules from the chunk group to the set
-		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
-			for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-				resultingAvailableModules.add(m);
-			}
+		if (errors.length > 0) {
+			const message = errors.join("\n");
+			callback(new Error(message));
+			return false;
 		}
-		return (chunkGroupInfo.resultingAvailableModules =
-			resultingAvailableModules);
-	};
+		return true;
+	}
 
-	const processConnectQueue = () => {
-		// Figure out new parents for chunk groups
-		// to get new available modules for these children
-		for (const [chunkGroupInfo, targets] of queueConnect) {
-			// 1. Add new targets to the list of children
-			if (chunkGroupInfo.children === undefined) {
-				chunkGroupInfo.children = targets;
-			} else {
-				for (const target of targets) {
-					chunkGroupInfo.children.add(target);
+	// TODO webpack 6 remove
+	/**
+	 * @deprecated This method should have been private
+	 * @param {Compiler[]} compilers the child compilers
+	 * @param {RunWithDependenciesHandler} fn a handler to run for each compiler
+	 * @param {Callback<MultiStats>} callback the compiler's handler
+	 * @returns {void}
+	 */
+	runWithDependencies(compilers, fn, callback) {
+		const fulfilledNames = new Set();
+		let remainingCompilers = compilers;
+		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		const getReadyCompilers = () => {
+			let readyCompilers = [];
+			let list = remainingCompilers;
+			remainingCompilers = [];
+			for (const c of list) {
+				const dependencies = this.dependencies.get(c);
+				const ready =
+					!dependencies || dependencies.every(isDependencyFulfilled);
+				if (ready) {
+					readyCompilers.push(c);
+				} else {
+					remainingCompilers.push(c);
 				}
 			}
+			return readyCompilers;
+		};
+		const runCompilers = callback => {
+			if (remainingCompilers.length === 0) return callback();
+			asyncLib.map(
+				getReadyCompilers(),
+				(compiler, callback) => {
+					fn(compiler, err => {
+						if (err) return callback(err);
+						fulfilledNames.add(compiler.name);
+						runCompilers(callback);
+					});
+				},
+				callback
+			);
+		};
+		runCompilers(callback);
+	}
 
-			// 2. Calculate resulting available modules
-			const resultingAvailableModules =
-				calculateResultingAvailableModules(chunkGroupInfo);
+	/**
+	 * @template SetupResult
+	 * @param {function(Compiler, number, Callback<Stats>, function(): boolean, function(): void, function(): void): SetupResult} setup setup a single compiler
+	 * @param {function(Compiler, SetupResult, Callback<Stats>): void} run run/continue a single compiler
+	 * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
+	 * @returns {SetupResult[]} result of setup
+	 */
+	_runGraph(setup, run, callback) {
+		/** @typedef {{ compiler: Compiler, setupResult: SetupResult, result: Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
 
-			const runtime = chunkGroupInfo.runtime;
+		// State transitions for nodes:
+		// -> blocked (initial)
+		// blocked -> starting [running++] (when all parents done)
+		// queued -> starting [running++] (when processing the queue)
+		// starting -> running (when run has been called)
+		// running -> done [running--] (when compilation is done)
+		// done -> pending (when invalidated from file change)
+		// pending -> blocked [add to queue] (when invalidated from aggregated changes)
+		// done -> blocked [add to queue] (when invalidated, from parent invalidation)
+		// running -> running-outdated (when invalidated, either from change or parent invalidation)
+		// running-outdated -> blocked [running--] (when compilation is done)
 
-			// 3. Update chunk group info
-			for (const target of targets) {
-				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add(target);
-				const oldRuntime = target.runtime;
-				const newRuntime = mergeRuntime(oldRuntime, runtime);
-				if (oldRuntime !== newRuntime) {
-					target.runtime = newRuntime;
-					outdatedChunkGroupInfo.add(target);
-				}
+		/** @type {Node[]} */
+		const nodes = this.compilers.map(compiler => ({
+			compiler,
+			setupResult: undefined,
+			result: undefined,
+			state: "blocked",
+			children: [],
+			parents: []
+		}));
+		/** @type {Map<string, Node>} */
+		const compilerToNode = new Map();
+		for (const node of nodes) compilerToNode.set(node.compiler.name, node);
+		for (const node of nodes) {
+			const dependencies = this.dependencies.get(node.compiler);
+			if (!dependencies) continue;
+			for (const dep of dependencies) {
+				const parent = compilerToNode.get(dep);
+				node.parents.push(parent);
+				parent.children.push(node);
 			}
-
-			statConnectedChunkGroups += targets.size;
 		}
-		queueConnect.clear();
-	};
-
-	const processChunkGroupsForMerging = () => {
-		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
-
-		// Execute the merge
-		for (const info of chunkGroupsForMerging) {
-			const availableModulesToBeMerged = info.availableModulesToBeMerged;
-			let cachedMinAvailableModules = info.minAvailableModules;
-
-			statMergedAvailableModuleSets += availableModulesToBeMerged.length;
-
-			// 1. Get minimal available modules
-			// It doesn't make sense to traverse a chunk again with more available modules.
-			// This step calculates the minimal available modules and skips traversal when
-			// the list didn't shrink.
-			if (availableModulesToBeMerged.length > 1) {
-				availableModulesToBeMerged.sort(bySetSize);
+		/** @type {ArrayQueue<Node>} */
+		const queue = new ArrayQueue();
+		for (const node of nodes) {
+			if (node.parents.length === 0) {
+				node.state = "queued";
+				queue.enqueue(node);
 			}
-			let changed = false;
-			merge: for (const availableModules of availableModulesToBeMerged) {
-				if (cachedMinAvailableModules === undefined) {
-					cachedMinAvailableModules = availableModules;
-					info.minAvailableModules = cachedMinAvailableModules;
-					info.minAvailableModulesOwned = false;
-					changed = true;
-				} else {
-					if (info.minAvailableModulesOwned) {
-						// We own it and can modify it
-						if (cachedMinAvailableModules.plus === availableModules.plus) {
-							for (const m of cachedMinAvailableModules) {
-								if (!availableModules.has(m)) {
-									cachedMinAvailableModules.delete(m);
-									changed = true;
-								}
-							}
+		}
+		let errored = false;
+		let running = 0;
+		const parallelism = this._options.parallelism;
+		/**
+		 * @param {Node} node node
+		 * @param {Error=} err error
+		 * @param {Stats=} stats result
+		 * @returns {void}
+		 */
+		const nodeDone = (node, err, stats) => {
+			if (errored) return;
+			if (err) {
+				errored = true;
+				return asyncLib.each(
+					nodes,
+					(node, callback) => {
+						if (node.compiler.watching) {
+							node.compiler.watching.close(callback);
 						} else {
-							for (const m of cachedMinAvailableModules) {
-								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-									cachedMinAvailableModules.delete(m);
-									changed = true;
-								}
-							}
-							for (const m of cachedMinAvailableModules.plus) {
-								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-									// We can't remove modules from the plus part
-									// so we need to merge plus into the normal part to allow modifying it
-									const iterator =
-										cachedMinAvailableModules.plus[Symbol.iterator]();
-									// fast forward add all modules until m
-									/** @type {IteratorResult<Module>} */
-									let it;
-									while (!(it = iterator.next()).done) {
-										const module = it.value;
-										if (module === m) break;
-										cachedMinAvailableModules.add(module);
-									}
-									// check the remaining modules before adding
-									while (!(it = iterator.next()).done) {
-										const module = it.value;
-										if (
-											availableModules.has(module) ||
-											availableModules.plus.has(m)
-										) {
-											cachedMinAvailableModules.add(module);
-										}
-									}
-									cachedMinAvailableModules.plus = EMPTY_SET;
-									changed = true;
-									continue merge;
-								}
-							}
-						}
-					} else if (cachedMinAvailableModules.plus === availableModules.plus) {
-						// Common and fast case when the plus part is shared
-						// We only need to care about the normal part
-						if (availableModules.size < cachedMinAvailableModules.size) {
-							// the new availableModules is smaller so it's faster to
-							// fork from the new availableModules
-							statForkedAvailableModules++;
-							statForkedAvailableModulesCount += availableModules.size;
-							statForkedMergedModulesCount += cachedMinAvailableModules.size;
-							// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-							const newSet = /** @type {ModuleSetPlus} */ (new Set());
-							newSet.plus = availableModules.plus;
-							for (const m of availableModules) {
-								if (cachedMinAvailableModules.has(m)) {
-									newSet.add(m);
-								}
-							}
-							statForkedResultModulesCount += newSet.size;
-							cachedMinAvailableModules = newSet;
-							info.minAvailableModulesOwned = true;
-							info.minAvailableModules = newSet;
-							changed = true;
-							continue merge;
-						}
-						for (const m of cachedMinAvailableModules) {
-							if (!availableModules.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedMergedModulesCount += availableModules.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								// as the plus part is equal we can just take over this one
-								const newSet = /** @type {ModuleSetPlus} */ (new Set());
-								newSet.plus = availableModules.plus;
-								const iterator = cachedMinAvailableModules[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (availableModules.has(module)) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-					} else {
-						for (const m of cachedMinAvailableModules) {
-							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedAvailableModulesCountPlus +=
-									cachedMinAvailableModules.plus.size;
-								statForkedMergedModulesCount += availableModules.size;
-								statForkedMergedModulesCountPlus += availableModules.plus.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								const newSet = /** @type {ModuleSetPlus} */ (new Set());
-								newSet.plus = EMPTY_SET;
-								const iterator = cachedMinAvailableModules[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								// also check all modules in cachedMinAvailableModules.plus
-								for (const module of cachedMinAvailableModules.plus) {
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-						for (const m of cachedMinAvailableModules.plus) {
-							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedAvailableModulesCountPlus +=
-									cachedMinAvailableModules.plus.size;
-								statForkedMergedModulesCount += availableModules.size;
-								statForkedMergedModulesCountPlus += availableModules.plus.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								// we already know that all modules directly from cachedMinAvailableModules are in availableModules too
-								const newSet = /** @type {ModuleSetPlus} */ (
-									new Set(cachedMinAvailableModules)
-								);
-								newSet.plus = EMPTY_SET;
-								const iterator =
-									cachedMinAvailableModules.plus[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
+							callback();
 						}
-					}
+					},
+					() => callback(err)
+				);
+			}
+			node.result = stats;
+			running--;
+			if (node.state === "running") {
+				node.state = "done";
+				for (const child of node.children) {
+					if (child.state === "blocked") queue.enqueue(child);
 				}
+			} else if (node.state === "running-outdated") {
+				node.state = "blocked";
+				queue.enqueue(node);
 			}
-			availableModulesToBeMerged.length = 0;
-			if (changed) {
-				info.resultingAvailableModules = undefined;
-				outdatedChunkGroupInfo.add(info);
+			processQueue();
+		};
+		/**
+		 * @param {Node} node node
+		 * @returns {void}
+		 */
+		const nodeInvalidFromParent = node => {
+			if (node.state === "done") {
+				node.state = "blocked";
+			} else if (node.state === "running") {
+				node.state = "running-outdated";
+			}
+			for (const child of node.children) {
+				nodeInvalidFromParent(child);
+			}
+		};
+		/**
+		 * @param {Node} node node
+		 * @returns {void}
+		 */
+		const nodeInvalid = node => {
+			if (node.state === "done") {
+				node.state = "pending";
+			} else if (node.state === "running") {
+				node.state = "running-outdated";
+			}
+			for (const child of node.children) {
+				nodeInvalidFromParent(child);
 			}
-		}
-		chunkGroupsForMerging.clear();
-	};
-
-	const processChunkGroupsForCombining = () => {
-		for (const info of chunkGroupsForCombining) {
-			for (const source of info.availableSources) {
-				if (!source.minAvailableModules) {
-					chunkGroupsForCombining.delete(info);
-					break;
-				}
+		};
+		/**
+		 * @param {Node} node node
+		 * @returns {void}
+		 */
+		const nodeChange = node => {
+			nodeInvalid(node);
+			if (node.state === "pending") {
+				node.state = "blocked";
 			}
-		}
-		for (const info of chunkGroupsForCombining) {
-			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
-			availableModules.plus = EMPTY_SET;
-			const mergeSet = set => {
-				if (set.size > availableModules.plus.size) {
-					for (const item of availableModules.plus) availableModules.add(item);
-					availableModules.plus = set;
-				} else {
-					for (const item of set) availableModules.add(item);
-				}
-			};
-			// combine minAvailableModules from all resultingAvailableModules
-			for (const source of info.availableSources) {
-				const resultingAvailableModules =
-					calculateResultingAvailableModules(source);
-				mergeSet(resultingAvailableModules);
-				mergeSet(resultingAvailableModules.plus);
+			if (node.state === "blocked") {
+				queue.enqueue(node);
+				processQueue();
 			}
-			info.minAvailableModules = availableModules;
-			info.minAvailableModulesOwned = false;
-			info.resultingAvailableModules = undefined;
-			outdatedChunkGroupInfo.add(info);
-		}
-		chunkGroupsForCombining.clear();
-	};
+		};
 
-	const processOutdatedChunkGroupInfo = () => {
-		statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
-		// Revisit skipped elements
-		for (const info of outdatedChunkGroupInfo) {
-			// 1. Reconsider skipped items
-			if (info.skippedItems !== undefined) {
-				const { minAvailableModules } = info;
-				for (const module of info.skippedItems) {
-					if (
-						!minAvailableModules.has(module) &&
-						!minAvailableModules.plus.has(module)
-					) {
-						queue.push({
-							action: ADD_AND_ENTER_MODULE,
-							block: module,
-							module,
-							chunk: info.chunkGroup.chunks[0],
-							chunkGroup: info.chunkGroup,
-							chunkGroupInfo: info
-						});
-						info.skippedItems.delete(module);
-					}
+		const setupResults = [];
+		nodes.forEach((node, i) => {
+			setupResults.push(
+				(node.setupResult = setup(
+					node.compiler,
+					i,
+					nodeDone.bind(null, node),
+					() => node.state !== "starting" && node.state !== "running",
+					() => nodeChange(node),
+					() => nodeInvalid(node)
+				))
+			);
+		});
+		let processing = true;
+		const processQueue = () => {
+			if (processing) return;
+			processing = true;
+			process.nextTick(processQueueWorker);
+		};
+		const processQueueWorker = () => {
+			while (running < parallelism && queue.length > 0 && !errored) {
+				const node = queue.dequeue();
+				if (
+					node.state === "queued" ||
+					(node.state === "blocked" &&
+						node.parents.every(p => p.state === "done"))
+				) {
+					running++;
+					node.state = "starting";
+					run(node.compiler, node.setupResult, nodeDone.bind(null, node));
+					node.state = "running";
 				}
 			}
-
-			// 2. Reconsider skipped connections
-			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules } = info;
-				for (const entry of info.skippedModuleConnections) {
-					const [module, activeState] = entry;
-					if (activeState === false) continue;
-					if (activeState === true) {
-						info.skippedModuleConnections.delete(entry);
-					}
-					if (
-						activeState === true &&
-						(minAvailableModules.has(module) ||
-							minAvailableModules.plus.has(module))
-					) {
-						info.skippedItems.add(module);
-						continue;
+			processing = false;
+			if (
+				!errored &&
+				running === 0 &&
+				nodes.every(node => node.state === "done")
+			) {
+				const stats = [];
+				for (const node of nodes) {
+					const result = node.result;
+					if (result) {
+						node.result = undefined;
+						stats.push(result);
 					}
-					queue.push({
-						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
-						block: module,
-						module,
-						chunk: info.chunkGroup.chunks[0],
-						chunkGroup: info.chunkGroup,
-						chunkGroupInfo: info
-					});
 				}
-			}
-
-			// 2. Reconsider children chunk groups
-			if (info.children !== undefined) {
-				statChildChunkGroupsReconnected += info.children.size;
-				for (const cgi of info.children) {
-					let connectList = queueConnect.get(info);
-					if (connectList === undefined) {
-						connectList = new Set();
-						queueConnect.set(info, connectList);
-					}
-					connectList.add(cgi);
+				if (stats.length > 0) {
+					callback(null, new MultiStats(stats));
 				}
 			}
+		};
+		processQueueWorker();
+		return setupResults;
+	}
 
-			// 3. Reconsider chunk groups for combining
-			if (info.availableChildren !== undefined) {
-				for (const cgi of info.availableChildren) {
-					chunkGroupsForCombining.add(cgi);
-				}
-			}
+	/**
+	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
+	 * @param {Callback<MultiStats>} handler signals when the call finishes
+	 * @returns {MultiWatching} a compiler watcher
+	 */
+	watch(watchOptions, handler) {
+		if (this.running) {
+			return handler(new ConcurrentCompilationError());
 		}
-		outdatedChunkGroupInfo.clear();
-	};
-
-	// Iterative traversal of the Module graph
-	// Recursive would be simpler to write but could result in Stack Overflows
-	while (queue.length || queueConnect.size) {
-		logger.time("visitModules: visiting");
-		processQueue();
-		logger.timeAggregateEnd("visitModules: prepare");
-		logger.timeEnd("visitModules: visiting");
+		this.running = true;
 
-		if (chunkGroupsForCombining.size > 0) {
-			logger.time("visitModules: combine available modules");
-			processChunkGroupsForCombining();
-			logger.timeEnd("visitModules: combine available modules");
+		if (this.validateDependencies(handler)) {
+			const watchings = this._runGraph(
+				(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
+					const watching = compiler.watch(
+						Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
+						callback
+					);
+					if (watching) {
+						watching._onInvalid = setInvalid;
+						watching._onChange = setChanged;
+						watching._isBlocked = isBlocked;
+					}
+					return watching;
+				},
+				(compiler, watching, callback) => {
+					if (compiler.watching !== watching) return;
+					if (!watching.running) watching.invalidate();
+				},
+				handler
+			);
+			return new MultiWatching(watchings, this);
 		}
 
-		if (queueConnect.size > 0) {
-			logger.time("visitModules: calculating available modules");
-			processConnectQueue();
-			logger.timeEnd("visitModules: calculating available modules");
+		return new MultiWatching([], this);
+	}
 
-			if (chunkGroupsForMerging.size > 0) {
-				logger.time("visitModules: merging available modules");
-				processChunkGroupsForMerging();
-				logger.timeEnd("visitModules: merging available modules");
-			}
+	/**
+	 * @param {Callback<MultiStats>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	run(callback) {
+		if (this.running) {
+			return callback(new ConcurrentCompilationError());
 		}
+		this.running = true;
 
-		if (outdatedChunkGroupInfo.size > 0) {
-			logger.time("visitModules: check modules for revisit");
-			processOutdatedChunkGroupInfo();
-			logger.timeEnd("visitModules: check modules for revisit");
+		if (this.validateDependencies(callback)) {
+			this._runGraph(
+				() => {},
+				(compiler, setupResult, callback) => compiler.run(callback),
+				(err, stats) => {
+					this.running = false;
+
+					if (callback !== undefined) {
+						return callback(err, stats);
+					}
+				}
+			);
 		}
+	}
 
-		// Run queueDelayed when all items of the queue are processed
-		// This is important to get the global indexing correct
-		// Async blocks should be processed after all sync blocks are processed
-		if (queue.length === 0) {
-			const tempQueue = queue;
-			queue = queueDelayed.reverse();
-			queueDelayed = tempQueue;
+	purgeInputFileSystem() {
+		for (const compiler of this.compilers) {
+			if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
+				compiler.inputFileSystem.purge();
+			}
 		}
 	}
 
-	logger.log(
-		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
-	);
-	logger.log(`${statConnectedChunkGroups} chunk groups connected`);
-	logger.log(
-		`${statProcessedChunkGroupsForMerging} chunk groups processed for merging (${statMergedAvailableModuleSets} module sets, ${statForkedAvailableModules} forked, ${statForkedAvailableModulesCount} + ${statForkedAvailableModulesCountPlus} modules forked, ${statForkedMergedModulesCount} + ${statForkedMergedModulesCountPlus} modules merged into fork, ${statForkedResultModulesCount} resulting modules)`
-	);
-	logger.log(
-		`${statChunkGroupInfoUpdated} chunk group info updated (${statChildChunkGroupsReconnected} already connected chunk groups reconnected)`
-	);
+	/**
+	 * @param {Callback<void>} callback signals when the compiler closes
+	 * @returns {void}
+	 */
+	close(callback) {
+		asyncLib.each(
+			this.compilers,
+			(compiler, callback) => {
+				compiler.close(callback);
+			},
+			callback
+		);
+	}
 };
 
-/**
- *
- * @param {Compilation} compilation the compilation
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
- */
-const connectChunkGroups = (
-	compilation,
-	blocksWithNestedBlocks,
-	blockConnections,
-	chunkGroupInfoMap
-) => {
-	const { chunkGraph } = compilation;
 
+/***/ }),
+
+/***/ 24170:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const identifierUtils = __webpack_require__(82186);
+
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("./Stats")} Stats */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+
+const indent = (str, prefix) => {
+	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	return prefix + rem;
+};
+
+class MultiStats {
 	/**
-	 * Helper function to check if all modules of a chunk are available
-	 *
-	 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
-	 * @param {ModuleSetPlus} availableModules the comparator set
-	 * @returns {boolean} return true if all modules of a chunk are available
+	 * @param {Stats[]} stats the child stats
 	 */
-	const areModulesAvailable = (chunkGroup, availableModules) => {
-		for (const chunk of chunkGroup.chunks) {
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!availableModules.has(module) && !availableModules.plus.has(module))
-					return false;
-			}
-		}
-		return true;
-	};
+	constructor(stats) {
+		this.stats = stats;
+	}
 
-	// For each edge in the basic chunk graph
-	for (const [block, connections] of blockConnections) {
-		// 1. Check if connection is needed
-		// When none of the dependencies need to be connected
-		// we can skip all of them
-		// It's not possible to filter each item so it doesn't create inconsistent
-		// connections and modules can only create one version
-		// TODO maybe decide this per runtime
-		if (
-			// TODO is this needed?
-			!blocksWithNestedBlocks.has(block) &&
-			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
-				areModulesAvailable(
-					chunkGroup,
-					originChunkGroupInfo.resultingAvailableModules
-				)
-			)
-		) {
-			continue;
-		}
+	get hash() {
+		return this.stats.map(stat => stat.hash).join("");
+	}
 
-		// 2. Foreach edge
-		for (let i = 0; i < connections.length; i++) {
-			const { chunkGroup, originChunkGroupInfo } = connections[i];
+	/**
+	 * @returns {boolean} true if a child compilation encountered an error
+	 */
+	hasErrors() {
+		return this.stats.some(stat => stat.hasErrors());
+	}
 
-			// 3. Connect block with chunk
-			chunkGraph.connectBlockAndChunkGroup(block, chunkGroup);
+	/**
+	 * @returns {boolean} true if a child compilation had a warning
+	 */
+	hasWarnings() {
+		return this.stats.some(stat => stat.hasWarnings());
+	}
 
-			// 4. Connect chunk with parent
-			connectChunkGroupParentAndChild(
-				originChunkGroupInfo.chunkGroup,
-				chunkGroup
-			);
+	_createChildOptions(options, context) {
+		if (!options) {
+			options = {};
 		}
+		const { children: childrenOptions = undefined, ...baseOptions } =
+			typeof options === "string" ? { preset: options } : options;
+		const children = this.stats.map((stat, idx) => {
+			const childOptions = Array.isArray(childrenOptions)
+				? childrenOptions[idx]
+				: childrenOptions;
+			return stat.compilation.createStatsOptions(
+				{
+					...baseOptions,
+					...(typeof childOptions === "string"
+						? { preset: childOptions }
+						: childOptions && typeof childOptions === "object"
+						? childOptions
+						: undefined)
+				},
+				context
+			);
+		});
+		return {
+			version: children.every(o => o.version),
+			hash: children.every(o => o.hash),
+			errorsCount: children.every(o => o.errorsCount),
+			warningsCount: children.every(o => o.warningsCount),
+			errors: children.every(o => o.errors),
+			warnings: children.every(o => o.warnings),
+			children
+		};
 	}
-};
-
-/**
- * Remove all unconnected chunk groups
- * @param {Compilation} compilation the compilation
- * @param {Iterable<ChunkGroup>} allCreatedChunkGroups all chunk groups that where created before
- */
-const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
-	const { chunkGraph } = compilation;
 
-	for (const chunkGroup of allCreatedChunkGroups) {
-		if (chunkGroup.getNumberOfParents() === 0) {
-			for (const chunk of chunkGroup.chunks) {
-				compilation.chunks.delete(chunk);
-				chunkGraph.disconnectChunk(chunk);
+	/**
+	 * @param {any} options stats options
+	 * @returns {StatsCompilation} json output
+	 */
+	toJson(options) {
+		options = this._createChildOptions(options, { forToString: false });
+		/** @type {KnownStatsCompilation} */
+		const obj = {};
+		obj.children = this.stats.map((stat, idx) => {
+			const obj = stat.toJson(options.children[idx]);
+			const compilationName = stat.compilation.name;
+			const name =
+				compilationName &&
+				identifierUtils.makePathsRelative(
+					options.context,
+					compilationName,
+					stat.compilation.compiler.root
+				);
+			obj.name = name;
+			return obj;
+		});
+		if (options.version) {
+			obj.version = obj.children[0].version;
+		}
+		if (options.hash) {
+			obj.hash = obj.children.map(j => j.hash).join("");
+		}
+		const mapError = (j, obj) => {
+			return {
+				...obj,
+				compilerPath: obj.compilerPath
+					? `${j.name}.${obj.compilerPath}`
+					: j.name
+			};
+		};
+		if (options.errors) {
+			obj.errors = [];
+			for (const j of obj.children) {
+				for (const i of j.errors) {
+					obj.errors.push(mapError(j, i));
+				}
+			}
+		}
+		if (options.warnings) {
+			obj.warnings = [];
+			for (const j of obj.children) {
+				for (const i of j.warnings) {
+					obj.warnings.push(mapError(j, i));
+				}
+			}
+		}
+		if (options.errorsCount) {
+			obj.errorsCount = 0;
+			for (const j of obj.children) {
+				obj.errorsCount += j.errorsCount;
+			}
+		}
+		if (options.warningsCount) {
+			obj.warningsCount = 0;
+			for (const j of obj.children) {
+				obj.warningsCount += j.warningsCount;
 			}
-			chunkGraph.disconnectChunkGroup(chunkGroup);
-			chunkGroup.remove();
 		}
+		return obj;
 	}
-};
 
-/**
- * This method creates the Chunk graph from the Module graph
- * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
- * @returns {void}
- */
-const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
-	const logger = compilation.getLogger("webpack.buildChunkGraph");
+	toString(options) {
+		options = this._createChildOptions(options, { forToString: true });
+		const results = this.stats.map((stat, idx) => {
+			const str = stat.toString(options.children[idx]);
+			const compilationName = stat.compilation.name;
+			const name =
+				compilationName &&
+				identifierUtils
+					.makePathsRelative(
+						options.context,
+						compilationName,
+						stat.compilation.compiler.root
+					)
+					.replace(/\|/g, " ");
+			if (!str) return str;
+			return name ? `${name}:\n${indent(str, "  ")}` : str;
+		});
+		return results.filter(Boolean).join("\n\n");
+	}
+}
+
+module.exports = MultiStats;
 
-	// SHARED STATE
 
-	/** @type {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} */
-	const blockConnections = new Map();
+/***/ }),
 
-	/** @type {Set<ChunkGroup>} */
-	const allCreatedChunkGroups = new Set();
+/***/ 81128:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
-	const chunkGroupInfoMap = new Map();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/** @type {Set<DependenciesBlock>} */
-	const blocksWithNestedBlocks = new Set();
 
-	// PART ONE
 
-	logger.time("visitModules");
-	visitModules(
-		logger,
-		compilation,
-		inputEntrypointsAndModules,
-		chunkGroupInfoMap,
-		blockConnections,
-		blocksWithNestedBlocks,
-		allCreatedChunkGroups
-	);
-	logger.timeEnd("visitModules");
+const asyncLib = __webpack_require__(78175);
 
-	// PART TWO
+/** @typedef {import("./MultiCompiler")} MultiCompiler */
+/** @typedef {import("./Watching")} Watching */
 
-	logger.time("connectChunkGroups");
-	connectChunkGroups(
-		compilation,
-		blocksWithNestedBlocks,
-		blockConnections,
-		chunkGroupInfoMap
-	);
-	logger.timeEnd("connectChunkGroups");
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
 
-	for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
-		for (const chunk of chunkGroup.chunks)
-			chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
+class MultiWatching {
+	/**
+	 * @param {Watching[]} watchings child compilers' watchers
+	 * @param {MultiCompiler} compiler the compiler
+	 */
+	constructor(watchings, compiler) {
+		this.watchings = watchings;
+		this.compiler = compiler;
 	}
 
-	// Cleanup work
+	invalidate(callback) {
+		if (callback) {
+			asyncLib.each(
+				this.watchings,
+				(watching, callback) => watching.invalidate(callback),
+				callback
+			);
+		} else {
+			for (const watching of this.watchings) {
+				watching.invalidate();
+			}
+		}
+	}
 
-	logger.time("cleanup");
-	cleanupUnconnectedGroups(compilation, allCreatedChunkGroups);
-	logger.timeEnd("cleanup");
-};
+	suspend() {
+		for (const watching of this.watchings) {
+			watching.suspend();
+		}
+	}
 
-module.exports = buildChunkGraph;
+	resume() {
+		for (const watching of this.watchings) {
+			watching.resume();
+		}
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the watcher is closed
+	 * @returns {void}
+	 */
+	close(callback) {
+		asyncLib.forEach(
+			this.watchings,
+			(watching, finishedCallback) => {
+				watching.close(finishedCallback);
+			},
+			err => {
+				this.compiler.hooks.watchClose.call();
+				if (typeof callback === "function") {
+					this.compiler.running = false;
+					callback(err);
+				}
+			}
+		);
+	}
+}
+
+module.exports = MultiWatching;
 
 
 /***/ }),
 
-/***/ 28034:
+/***/ 50169:
 /***/ (function(module) {
 
 "use strict";
@@ -60612,38 +55366,33 @@ module.exports = buildChunkGraph;
 
 
 
-/** @typedef {import("../Compiler")} Compiler */
-
-class AddBuildDependenciesPlugin {
-	/**
-	 * @param {Iterable<string>} buildDependencies list of build dependencies
-	 */
-	constructor(buildDependencies) {
-		this.buildDependencies = new Set(buildDependencies);
-	}
+/** @typedef {import("./Compiler")} Compiler */
 
+class NoEmitOnErrorsPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AddBuildDependenciesPlugin",
-			compilation => {
-				compilation.buildDependencies.addAll(this.buildDependencies);
-			}
-		);
+		compiler.hooks.shouldEmit.tap("NoEmitOnErrorsPlugin", compilation => {
+			if (compilation.getStats().hasErrors()) return false;
+		});
+		compiler.hooks.compilation.tap("NoEmitOnErrorsPlugin", compilation => {
+			compilation.hooks.shouldRecord.tap("NoEmitOnErrorsPlugin", () => {
+				if (compilation.getStats().hasErrors()) return false;
+			});
+		});
 	}
 }
 
-module.exports = AddBuildDependenciesPlugin;
+module.exports = NoEmitOnErrorsPlugin;
 
 
 /***/ }),
 
-/***/ 47942:
-/***/ (function(module) {
+/***/ 80832:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -60653,39 +55402,68 @@ module.exports = AddBuildDependenciesPlugin;
 
 
 
-/** @typedef {import("../Compiler")} Compiler */
+const WebpackError = __webpack_require__(53799);
 
-class AddManagedPathsPlugin {
-	/**
-	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
-	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
-	 */
-	constructor(managedPaths, immutablePaths) {
-		this.managedPaths = new Set(managedPaths);
-		this.immutablePaths = new Set(immutablePaths);
+module.exports = class NoModeWarning extends WebpackError {
+	constructor() {
+		super();
+
+		this.name = "NoModeWarning";
+		this.message =
+			"configuration\n" +
+			"The 'mode' option has not been set, webpack will fallback to 'production' for this value.\n" +
+			"Set 'mode' option to 'development' or 'production' to enable defaults for each environment.\n" +
+			"You can also set it to 'none' to disable any default behavior. " +
+			"Learn more: https://webpack.js.org/configuration/mode/";
 	}
+};
+
+
+/***/ }),
+
+/***/ 6325:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+
+class NodeStuffInWebError extends WebpackError {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {DependencyLocation} loc loc
+	 * @param {string} expression expression
+	 * @param {string} description description
 	 */
-	apply(compiler) {
-		for (const managedPath of this.managedPaths) {
-			compiler.managedPaths.add(managedPath);
-		}
-		for (const immutablePath of this.immutablePaths) {
-			compiler.immutablePaths.add(immutablePath);
-		}
+	constructor(loc, expression, description) {
+		super(
+			`${JSON.stringify(
+				expression
+			)} has been used, it will be undefined in next major version.
+${description}`
+		);
+
+		this.name = "NodeStuffInWebError";
+		this.loc = loc;
 	}
 }
 
-module.exports = AddManagedPathsPlugin;
+makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
+
+module.exports = NodeStuffInWebError;
 
 
 /***/ }),
 
-/***/ 71985:
+/***/ 95287:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -60696,30 +55474,26 @@ module.exports = AddManagedPathsPlugin;
 
 
 
-const Cache = __webpack_require__(7592);
-const ProgressPlugin = __webpack_require__(13216);
-
-/** @typedef {import("../Compiler")} Compiler */
+const NodeStuffInWebError = __webpack_require__(6325);
+const RuntimeGlobals = __webpack_require__(16475);
+const CachedConstDependency = __webpack_require__(57403);
+const ConstDependency = __webpack_require__(76911);
+const {
+	evaluateToString,
+	expressionIsUnsupported
+} = __webpack_require__(93998);
+const { relative } = __webpack_require__(17139);
+const { parseResource } = __webpack_require__(82186);
 
-const BUILD_DEPENDENCIES_KEY = Symbol();
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 
-class IdleFileCachePlugin {
-	/**
-	 * @param {TODO} strategy cache strategy
-	 * @param {number} idleTimeout timeout
-	 * @param {number} idleTimeoutForInitialStore initial timeout
-	 * @param {number} idleTimeoutAfterLargeChanges timeout after changes
-	 */
-	constructor(
-		strategy,
-		idleTimeout,
-		idleTimeoutForInitialStore,
-		idleTimeoutAfterLargeChanges
-	) {
-		this.strategy = strategy;
-		this.idleTimeout = idleTimeout;
-		this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
-		this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
+class NodeStuffPlugin {
+	constructor(options) {
+		this.options = options;
 	}
 
 	/**
@@ -60728,199 +55502,152 @@ class IdleFileCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		let strategy = this.strategy;
-		const idleTimeout = this.idleTimeout;
-		const idleTimeoutForInitialStore = Math.min(
-			idleTimeout,
-			this.idleTimeoutForInitialStore
-		);
-		const idleTimeoutAfterLargeChanges = this.idleTimeoutAfterLargeChanges;
-		const resolvedPromise = Promise.resolve();
+		const options = this.options;
+		compiler.hooks.compilation.tap(
+			"NodeStuffPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.node === false) return;
 
-		let timeSpendInBuild = 0;
-		let timeSpendInStore = 0;
-		let avgTimeSpendInStore = 0;
+					let localOptions = options;
+					if (parserOptions.node) {
+						localOptions = { ...localOptions, ...parserOptions.node };
+					}
 
-		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise>} */
-		const pendingIdleTasks = new Map();
+					if (localOptions.global !== false) {
+						const withWarning = localOptions.global === "warn";
+						parser.hooks.expression
+							.for("global")
+							.tap("NodeStuffPlugin", expr => {
+								const dep = new ConstDependency(
+									RuntimeGlobals.global,
+									expr.range,
+									[RuntimeGlobals.global]
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
 
-		compiler.cache.hooks.store.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			(identifier, etag, data) => {
-				pendingIdleTasks.set(identifier, () =>
-					strategy.store(identifier, etag, data)
-				);
-			}
-		);
+								// TODO webpack 6 remove
+								if (withWarning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(
+											dep.loc,
+											"global",
+											"The global namespace object is Node.js feature and doesn't present in browser."
+										)
+									);
+								}
+							});
+					}
 
-		compiler.cache.hooks.get.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			(identifier, etag, gotHandlers) => {
-				const restore = () =>
-					strategy.restore(identifier, etag).then(cacheEntry => {
-						if (cacheEntry === undefined) {
-							gotHandlers.push((result, callback) => {
-								if (result !== undefined) {
-									pendingIdleTasks.set(identifier, () =>
-										strategy.store(identifier, etag, result)
+					const setModuleConstant = (expressionName, fn, warning) => {
+						parser.hooks.expression
+							.for(expressionName)
+							.tap("NodeStuffPlugin", expr => {
+								const dep = new CachedConstDependency(
+									JSON.stringify(fn(parser.state.module)),
+									expr.range,
+									expressionName
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+
+								// TODO webpack 6 remove
+								if (warning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(dep.loc, expressionName, warning)
 									);
 								}
-								callback();
+
+								return true;
 							});
-						} else {
-							return cacheEntry;
-						}
-					});
-				const pendingTask = pendingIdleTasks.get(identifier);
-				if (pendingTask !== undefined) {
-					pendingIdleTasks.delete(identifier);
-					return pendingTask().then(restore);
-				}
-				return restore();
-			}
-		);
+					};
 
-		compiler.cache.hooks.storeBuildDependencies.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			dependencies => {
-				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
-					strategy.storeBuildDependencies(dependencies)
-				);
-			}
-		);
+					const setConstant = (expressionName, value, warning) =>
+						setModuleConstant(expressionName, () => value, warning);
 
-		compiler.cache.hooks.shutdown.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			() => {
-				if (idleTimer) {
-					clearTimeout(idleTimer);
-					idleTimer = undefined;
-				}
-				isIdle = false;
-				const reportProgress = ProgressPlugin.getReporter(compiler);
-				const jobs = Array.from(pendingIdleTasks.values());
-				if (reportProgress) reportProgress(0, "process pending cache items");
-				const promises = jobs.map(fn => fn());
-				pendingIdleTasks.clear();
-				promises.push(currentIdlePromise);
-				const promise = Promise.all(promises);
-				currentIdlePromise = promise.then(() => strategy.afterAllStored());
-				if (reportProgress) {
-					currentIdlePromise = currentIdlePromise.then(() => {
-						reportProgress(1, `stored`);
-					});
-				}
-				return currentIdlePromise.then(() => {
-					// Reset strategy
-					if (strategy.clear) strategy.clear();
-				});
-			}
-		);
+					const context = compiler.context;
+					if (localOptions.__filename) {
+						switch (localOptions.__filename) {
+							case "mock":
+								setConstant("__filename", "/index.js");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__filename",
+									"/index.js",
+									"The __filename is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__filename", module =>
+									relative(compiler.inputFileSystem, context, module.resource)
+								);
+								break;
+						}
 
-		/** @type {Promise<any>} */
-		let currentIdlePromise = resolvedPromise;
-		let isIdle = false;
-		let isInitialStore = true;
-		const processIdleTasks = () => {
-			if (isIdle) {
-				const startTime = Date.now();
-				if (pendingIdleTasks.size > 0) {
-					const promises = [currentIdlePromise];
-					const maxTime = startTime + 100;
-					let maxCount = 100;
-					for (const [filename, factory] of pendingIdleTasks) {
-						pendingIdleTasks.delete(filename);
-						promises.push(factory());
-						if (maxCount-- <= 0 || Date.now() > maxTime) break;
+						parser.hooks.evaluateIdentifier
+							.for("__filename")
+							.tap("NodeStuffPlugin", expr => {
+								if (!parser.state.module) return;
+								const resource = parseResource(parser.state.module.resource);
+								return evaluateToString(resource.path)(expr);
+							});
 					}
-					currentIdlePromise = Promise.all(promises);
-					currentIdlePromise.then(() => {
-						timeSpendInStore += Date.now() - startTime;
-						// Allow to exit the process between
-						idleTimer = setTimeout(processIdleTasks, 0);
-						idleTimer.unref();
-					});
-					return;
-				}
-				currentIdlePromise = currentIdlePromise
-					.then(async () => {
-						await strategy.afterAllStored();
-						timeSpendInStore += Date.now() - startTime;
-						avgTimeSpendInStore =
-							Math.max(avgTimeSpendInStore, timeSpendInStore) * 0.9 +
-							timeSpendInStore * 0.1;
-						timeSpendInStore = 0;
-						timeSpendInBuild = 0;
-					})
-					.catch(err => {
-						const logger = compiler.getInfrastructureLogger(
-							"IdleFileCachePlugin"
-						);
-						logger.warn(`Background tasks during idle failed: ${err.message}`);
-						logger.debug(err.stack);
-					});
-				isInitialStore = false;
-			}
-		};
-		let idleTimer = undefined;
-		compiler.cache.hooks.beginIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			() => {
-				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
-				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
-					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
-						.log(
-							`Initial cache was generated and cache will be persisted in ${
-								idleTimeoutForInitialStore / 1000
-							}s.`
-						);
-				} else if (
-					isLargeChange &&
-					idleTimeoutAfterLargeChanges < idleTimeout
-				) {
-					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
-						.log(
-							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
-								Math.round(avgTimeSpendInStore) / 1000
-							}s in average in cache store. This is considered as large change and cache will be persisted in ${
-								idleTimeoutAfterLargeChanges / 1000
-							}s.`
+					if (localOptions.__dirname) {
+						switch (localOptions.__dirname) {
+							case "mock":
+								setConstant("__dirname", "/");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__dirname",
+									"/",
+									"The __dirname is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__dirname", module =>
+									relative(compiler.inputFileSystem, context, module.context)
+								);
+								break;
+						}
+
+						parser.hooks.evaluateIdentifier
+							.for("__dirname")
+							.tap("NodeStuffPlugin", expr => {
+								if (!parser.state.module) return;
+								return evaluateToString(parser.state.module.context)(expr);
+							});
+					}
+					parser.hooks.expression
+						.for("require.extensions")
+						.tap(
+							"NodeStuffPlugin",
+							expressionIsUnsupported(
+								parser,
+								"require.extensions is not supported by webpack. Use a loader instead."
+							)
 						);
-				}
-				idleTimer = setTimeout(() => {
-					idleTimer = undefined;
-					isIdle = true;
-					resolvedPromise.then(processIdleTasks);
-				}, Math.min(isInitialStore ? idleTimeoutForInitialStore : Infinity, isLargeChange ? idleTimeoutAfterLargeChanges : Infinity, idleTimeout));
-				idleTimer.unref();
-			}
-		);
-		compiler.cache.hooks.endIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			() => {
-				if (idleTimer) {
-					clearTimeout(idleTimer);
-					idleTimer = undefined;
-				}
-				isIdle = false;
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("NodeStuffPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("NodeStuffPlugin", handler);
 			}
 		);
-		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
-			// 10% build overhead is ignored, as it's not cacheable
-			timeSpendInBuild *= 0.9;
-			timeSpendInBuild += stats.endTime - stats.startTime;
-		});
 	}
 }
 
-module.exports = IdleFileCachePlugin;
+module.exports = NodeStuffPlugin;
 
 
 /***/ }),
 
-/***/ 52539:
+/***/ 39:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -60931,2023 +55658,2532 @@ module.exports = IdleFileCachePlugin;
 
 
 
-const Cache = __webpack_require__(7592);
+const parseJson = __webpack_require__(15235);
+const { getContext, runLoaders } = __webpack_require__(68318);
+const querystring = __webpack_require__(63477);
+const { HookMap, SyncHook, AsyncSeriesBailHook } = __webpack_require__(41242);
+const {
+	CachedSource,
+	OriginalSource,
+	RawSource,
+	SourceMapSource
+} = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const HookWebpackError = __webpack_require__(11351);
+const Module = __webpack_require__(73208);
+const ModuleBuildError = __webpack_require__(21305);
+const ModuleError = __webpack_require__(23744);
+const ModuleGraphConnection = __webpack_require__(40639);
+const ModuleParseError = __webpack_require__(58443);
+const ModuleWarning = __webpack_require__(11234);
+const RuntimeGlobals = __webpack_require__(16475);
+const UnhandledSchemeError = __webpack_require__(68099);
+const WebpackError = __webpack_require__(53799);
+const formatLocation = __webpack_require__(16734);
+const LazySet = __webpack_require__(38938);
+const { isSubset } = __webpack_require__(93347);
+const { getScheme } = __webpack_require__(54500);
+const {
+	compareLocations,
+	concatComparators,
+	compareSelect,
+	keepOriginalOrder
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const { createFakeHook } = __webpack_require__(64518);
+const { join } = __webpack_require__(17139);
+const {
+	contextify,
+	absolutify,
+	makePathsRelative
+} = __webpack_require__(82186);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-
-class MemoryCachePlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
-		const cache = new Map();
-		compiler.cache.hooks.store.tap(
-			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, data) => {
-				cache.set(identifier, { etag, data });
-			}
-		);
-		compiler.cache.hooks.get.tap(
-			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, gotHandlers) => {
-				const cacheEntry = cache.get(identifier);
-				if (cacheEntry === null) {
-					return null;
-				} else if (cacheEntry !== undefined) {
-					return cacheEntry.etag === etag ? cacheEntry.data : null;
-				}
-				gotHandlers.push((result, callback) => {
-					if (result === undefined) {
-						cache.set(identifier, null);
-					} else {
-						cache.set(identifier, { etag, data: result });
-					}
-					return callback();
-				});
-			}
-		);
-		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
-			() => {
-				cache.clear();
-			}
-		);
-	}
-}
-module.exports = MemoryCachePlugin;
-
+/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
+/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./Parser")} Parser */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/***/ }),
+/**
+ * @typedef {Object} SourceMap
+ * @property {number} version
+ * @property {string[]} sources
+ * @property {string} mappings
+ * @property {string=} file
+ * @property {string=} sourceRoot
+ * @property {string[]=} sourcesContent
+ * @property {string[]=} names
+ */
 
-/***/ 99334:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const getInvalidDependenciesModuleWarning = memoize(() =>
+	__webpack_require__(68257)
+);
+const getValidate = memoize(() => (__webpack_require__(38476).validate));
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 
+/**
+ * @typedef {Object} LoaderItem
+ * @property {string} loader
+ * @property {any} options
+ * @property {string?} ident
+ * @property {string?} type
+ */
 
+/**
+ * @param {string} context absolute context path
+ * @param {string} source a source path
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} new source path
+ */
+const contextifySourceUrl = (context, source, associatedObjectForCache) => {
+	if (source.startsWith("webpack://")) return source;
+	return `webpack://${makePathsRelative(
+		context,
+		source,
+		associatedObjectForCache
+	)}`;
+};
 
-const Cache = __webpack_require__(7592);
+/**
+ * @param {string} context absolute context path
+ * @param {SourceMap} sourceMap a source map
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {SourceMap} new source map
+ */
+const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
+	if (!Array.isArray(sourceMap.sources)) return sourceMap;
+	const { sourceRoot } = sourceMap;
+	/** @type {function(string): string} */
+	const mapper = !sourceRoot
+		? source => source
+		: sourceRoot.endsWith("/")
+		? source =>
+				source.startsWith("/")
+					? `${sourceRoot.slice(0, -1)}${source}`
+					: `${sourceRoot}${source}`
+		: source =>
+				source.startsWith("/")
+					? `${sourceRoot}${source}`
+					: `${sourceRoot}/${source}`;
+	const newSources = sourceMap.sources.map(source =>
+		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
+	);
+	return {
+		...sourceMap,
+		file: "x",
+		sourceRoot: undefined,
+		sources: newSources
+	};
+};
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/**
+ * @param {string | Buffer} input the input
+ * @returns {string} the converted string
+ */
+const asString = input => {
+	if (Buffer.isBuffer(input)) {
+		return input.toString("utf-8");
+	}
+	return input;
+};
 
-class MemoryWithGcCachePlugin {
-	constructor({ maxGenerations }) {
-		this._maxGenerations = maxGenerations;
+/**
+ * @param {string | Buffer} input the input
+ * @returns {Buffer} the converted buffer
+ */
+const asBuffer = input => {
+	if (!Buffer.isBuffer(input)) {
+		return Buffer.from(input, "utf-8");
 	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const maxGenerations = this._maxGenerations;
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
-		const cache = new Map();
-		/** @type {Map<string, { entry: { etag: Etag | null, data: any }, until: number }>} */
-		const oldCache = new Map();
-		let generation = 0;
-		let cachePosition = 0;
-		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
-		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
-			generation++;
-			let clearedEntries = 0;
-			let lastClearedIdentifier;
-			for (const [identifier, entry] of oldCache) {
-				if (entry.until > generation) break;
+	return input;
+};
 
-				oldCache.delete(identifier);
-				if (cache.get(identifier) === undefined) {
-					cache.delete(identifier);
-					clearedEntries++;
-					lastClearedIdentifier = identifier;
-				}
-			}
-			if (clearedEntries > 0 || oldCache.size > 0) {
-				logger.log(
-					`${cache.size - oldCache.size} active entries, ${
-						oldCache.size
-					} recently unused cached entries${
-						clearedEntries > 0
-							? `, ${clearedEntries} old unused cache entries removed e. g. ${lastClearedIdentifier}`
-							: ""
-					}`
-				);
-			}
-			let i = (cache.size / maxGenerations) | 0;
-			let j = cachePosition >= cache.size ? 0 : cachePosition;
-			cachePosition = j + i;
-			for (const [identifier, entry] of cache) {
-				if (j !== 0) {
-					j--;
-					continue;
-				}
-				if (entry !== undefined) {
-					// We don't delete the cache entry, but set it to undefined instead
-					// This reserves the location in the data table and avoids rehashing
-					// when constantly adding and removing entries.
-					// It will be deleted when removed from oldCache.
-					cache.set(identifier, undefined);
-					oldCache.delete(identifier);
-					oldCache.set(identifier, {
-						entry,
-						until: generation + maxGenerations
-					});
-					if (i-- === 0) break;
-				}
-			}
-		});
-		compiler.cache.hooks.store.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, data) => {
-				cache.set(identifier, { etag, data });
-			}
-		);
-		compiler.cache.hooks.get.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, gotHandlers) => {
-				const cacheEntry = cache.get(identifier);
-				if (cacheEntry === null) {
-					return null;
-				} else if (cacheEntry !== undefined) {
-					return cacheEntry.etag === etag ? cacheEntry.data : null;
-				}
-				const oldCacheEntry = oldCache.get(identifier);
-				if (oldCacheEntry !== undefined) {
-					const cacheEntry = oldCacheEntry.entry;
-					if (cacheEntry === null) {
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return null;
-					} else {
-						if (cacheEntry.etag !== etag) return null;
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return cacheEntry.data;
-					}
-				}
-				gotHandlers.push((result, callback) => {
-					if (result === undefined) {
-						cache.set(identifier, null);
-					} else {
-						cache.set(identifier, { etag, data: result });
-					}
-					return callback();
-				});
-			}
-		);
-		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
-			() => {
-				cache.clear();
-				oldCache.clear();
-			}
-		);
+class NonErrorEmittedError extends WebpackError {
+	constructor(error) {
+		super();
+
+		this.name = "NonErrorEmittedError";
+		this.message = "(Emitted value instead of an instance of Error) " + error;
 	}
 }
-module.exports = MemoryWithGcCachePlugin;
 
+makeSerializable(
+	NonErrorEmittedError,
+	"webpack/lib/NormalModule",
+	"NonErrorEmittedError"
+);
 
-/***/ }),
+/**
+ * @typedef {Object} NormalModuleCompilationHooks
+ * @property {SyncHook<[object, NormalModule]>} loader
+ * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
+ * @property {SyncHook<[NormalModule]>} beforeParse
+ * @property {SyncHook<[NormalModule]>} beforeSnapshot
+ * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
+ * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
+ */
 
-/***/ 86180:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+class NormalModule extends Module {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {NormalModuleCompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				loader: new SyncHook(["loaderContext", "module"]),
+				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
+				beforeParse: new SyncHook(["module"]),
+				beforeSnapshot: new SyncHook(["module"]),
+				// TODO webpack 6 deprecate
+				readResourceForScheme: new HookMap(scheme => {
+					const hook = hooks.readResource.for(scheme);
+					return createFakeHook(
+						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
+							tap: (options, fn) =>
+								hook.tap(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								),
+							tapAsync: (options, fn) =>
+								hook.tapAsync(options, (loaderContext, callback) =>
+									fn(loaderContext.resource, loaderContext._module, callback)
+								),
+							tapPromise: (options, fn) =>
+								hook.tapPromise(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								)
+						})
+					);
+				}),
+				readResource: new HookMap(
+					() => new AsyncSeriesBailHook(["loaderContext"])
+				),
+				needBuild: new AsyncSeriesBailHook(["module", "context"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	/**
+	 * @param {Object} options options object
+	 * @param {string=} options.layer an optional layer in which the module is
+	 * @param {string} options.type module type
+	 * @param {string} options.request request string
+	 * @param {string} options.userRequest request intended by user (without loaders from config)
+	 * @param {string} options.rawRequest request without resolving
+	 * @param {LoaderItem[]} options.loaders list of loaders
+	 * @param {string} options.resource path + query of the real resource
+	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
+	 * @param {string} options.context context directory for resolving
+	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
+	 * @param {Parser} options.parser the parser used
+	 * @param {object} options.parserOptions the options of the parser used
+	 * @param {Generator} options.generator the generator used
+	 * @param {object} options.generatorOptions the options of the generator used
+	 * @param {Object} options.resolveOptions options used for resolving requests from this module
+	 */
+	constructor({
+		layer,
+		type,
+		request,
+		userRequest,
+		rawRequest,
+		loaders,
+		resource,
+		resourceResolveData,
+		context,
+		matchResource,
+		parser,
+		parserOptions,
+		generator,
+		generatorOptions,
+		resolveOptions
+	}) {
+		super(type, context || getContext(resource), layer);
 
+		// Info from Factory
+		/** @type {string} */
+		this.request = request;
+		/** @type {string} */
+		this.userRequest = userRequest;
+		/** @type {string} */
+		this.rawRequest = rawRequest;
+		/** @type {boolean} */
+		this.binary = /^(asset|webassembly)\b/.test(type);
+		/** @type {Parser} */
+		this.parser = parser;
+		this.parserOptions = parserOptions;
+		/** @type {Generator} */
+		this.generator = generator;
+		this.generatorOptions = generatorOptions;
+		/** @type {string} */
+		this.resource = resource;
+		this.resourceResolveData = resourceResolveData;
+		/** @type {string | undefined} */
+		this.matchResource = matchResource;
+		/** @type {LoaderItem[]} */
+		this.loaders = loaders;
+		if (resolveOptions !== undefined) {
+			// already declared in super class
+			this.resolveOptions = resolveOptions;
+		}
 
+		// Info from Build
+		/** @type {(WebpackError | null)=} */
+		this.error = null;
+		/** @private @type {Source=} */
+		this._source = null;
+		/** @private @type {Map<string, number> | undefined} **/
+		this._sourceSizes = undefined;
+		/** @private @type {Set<string>} */
+		this._sourceTypes = undefined;
 
-const FileSystemInfo = __webpack_require__(79453);
-const ProgressPlugin = __webpack_require__(13216);
-const { formatSize } = __webpack_require__(71070);
-const SerializerMiddleware = __webpack_require__(83137);
-const LazySet = __webpack_require__(38938);
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-const {
-	createFileSerializer,
-	NOT_SERIALIZABLE
-} = __webpack_require__(8282);
+		// Cache
+		this._lastSuccessfulBuildMeta = {};
+		this._forceBuild = true;
+		this._isEvaluatingSideEffects = false;
+		/** @type {WeakSet<ModuleGraph> | undefined} */
+		this._addedSideEffectsBailout = undefined;
+	}
 
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		if (this.layer === null) {
+			if (this.type === "javascript/auto") {
+				return this.request;
+			} else {
+				return `${this.type}|${this.request}`;
+			}
+		} else {
+			return `${this.type}|${this.request}|${this.layer}`;
+		}
+	}
 
-class PackContainer {
 	/**
-	 * @param {Object} data stored data
-	 * @param {string} version version identifier
-	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
-	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
-	 * @param {Map<string, string | false>} resolveResults result of the resolved build dependencies
-	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	constructor(
-		data,
-		version,
-		buildSnapshot,
-		buildDependencies,
-		resolveResults,
-		resolveBuildDependenciesSnapshot
-	) {
-		this.data = data;
-		this.version = version;
-		this.buildSnapshot = buildSnapshot;
-		this.buildDependencies = buildDependencies;
-		this.resolveResults = resolveResults;
-		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
+	readableIdentifier(requestShortener) {
+		return requestShortener.shorten(this.userRequest);
 	}
 
-	serialize({ write, writeLazy }) {
-		write(this.version);
-		write(this.buildSnapshot);
-		write(this.buildDependencies);
-		write(this.resolveResults);
-		write(this.resolveBuildDependenciesSnapshot);
-		writeLazy(this.data);
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		let ident = contextify(
+			options.context,
+			this.userRequest,
+			options.associatedObjectForCache
+		);
+		if (this.layer) ident = `(${this.layer})/${ident}`;
+		return ident;
 	}
 
-	deserialize({ read }) {
-		this.version = read();
-		this.buildSnapshot = read();
-		this.buildDependencies = read();
-		this.resolveResults = read();
-		this.resolveBuildDependenciesSnapshot = read();
-		this.data = read();
+	/**
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 */
+	nameForCondition() {
+		const resource = this.matchResource || this.resource;
+		const idx = resource.indexOf("?");
+		if (idx >= 0) return resource.substr(0, idx);
+		return resource;
 	}
-}
 
-makeSerializable(
-	PackContainer,
-	"webpack/lib/cache/PackFileCacheStrategy",
-	"PackContainer"
-);
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {NormalModule} */ (module);
+		this.binary = m.binary;
+		this.request = m.request;
+		this.userRequest = m.userRequest;
+		this.rawRequest = m.rawRequest;
+		this.parser = m.parser;
+		this.parserOptions = m.parserOptions;
+		this.generator = m.generator;
+		this.generatorOptions = m.generatorOptions;
+		this.resource = m.resource;
+		this.resourceResolveData = m.resourceResolveData;
+		this.context = m.context;
+		this.matchResource = m.matchResource;
+		this.loaders = m.loaders;
+	}
 
-const MIN_CONTENT_SIZE = 1024 * 1024; // 1 MB
-const CONTENT_COUNT_TO_MERGE = 10;
-const MIN_ITEMS_IN_FRESH_PACK = 100;
-const MAX_ITEMS_IN_FRESH_PACK = 50000;
-const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
+	/**
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		// Make sure to cache types and sizes before cleanup when this module has been built
+		// They are accessed by the stats and we don't want them to crash after cleanup
+		// TODO reconsider this for webpack 6
+		if (this.buildInfo) {
+			if (this._sourceTypes === undefined) this.getSourceTypes();
+			for (const type of this._sourceTypes) {
+				this.size(type);
+			}
+		}
+		super.cleanupForCache();
+		this.parser = undefined;
+		this.parserOptions = undefined;
+		this.generator = undefined;
+		this.generatorOptions = undefined;
+	}
 
-class PackItemInfo {
 	/**
-	 * @param {string} identifier identifier of item
-	 * @param {string | null} etag etag of item
-	 * @param {any} value fresh value of item
+	 * Module should be unsafe cached. Get data that's needed for that.
+	 * This data will be passed to restoreFromUnsafeCache later.
+	 * @returns {object} cached data
 	 */
-	constructor(identifier, etag, value) {
-		this.identifier = identifier;
-		this.etag = etag;
-		this.location = -1;
-		this.lastAccess = Date.now();
-		this.freshValue = value;
+	getUnsafeCacheData() {
+		const data = super.getUnsafeCacheData();
+		data.parserOptions = this.parserOptions;
+		data.generatorOptions = this.generatorOptions;
+		return data;
 	}
-}
 
-class Pack {
-	constructor(logger, maxAge) {
-		/** @type {Map<string, PackItemInfo>} */
-		this.itemInfo = new Map();
-		/** @type {string[]} */
-		this.requests = [];
-		this.requestsTimeout = undefined;
-		/** @type {Map<string, PackItemInfo>} */
-		this.freshContent = new Map();
-		/** @type {(undefined | PackContent)[]} */
-		this.content = [];
-		this.invalid = false;
-		this.logger = logger;
-		this.maxAge = maxAge;
+	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
 	}
 
-	_addRequest(identifier) {
-		this.requests.push(identifier);
-		if (this.requestsTimeout === undefined) {
-			this.requestsTimeout = setTimeout(() => {
-				this.requests.push(undefined);
-				this.requestsTimeout = undefined;
-			}, MAX_TIME_IN_FRESH_PACK);
-			if (this.requestsTimeout.unref) this.requestsTimeout.unref();
-		}
+	/**
+	 * restore unsafe cache data
+	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 */
+	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+		this.parserOptions = unsafeCacheData.parserOptions;
+		this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);
+		this.generatorOptions = unsafeCacheData.generatorOptions;
+		this.generator = normalModuleFactory.getGenerator(
+			this.type,
+			this.generatorOptions
+		);
+		// we assume the generator behaves identically and keep cached sourceTypes/Sizes
 	}
 
-	stopCapturingRequests() {
-		if (this.requestsTimeout !== undefined) {
-			clearTimeout(this.requestsTimeout);
-			this.requestsTimeout = undefined;
+	/**
+	 * @param {string} context the compilation context
+	 * @param {string} name the asset name
+	 * @param {string} content the content
+	 * @param {string | TODO} sourceMap an optional source map
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @returns {Source} the created source
+	 */
+	createSourceForAsset(
+		context,
+		name,
+		content,
+		sourceMap,
+		associatedObjectForCache
+	) {
+		if (sourceMap) {
+			if (
+				typeof sourceMap === "string" &&
+				(this.useSourceMap || this.useSimpleSourceMap)
+			) {
+				return new OriginalSource(
+					content,
+					contextifySourceUrl(context, sourceMap, associatedObjectForCache)
+				);
+			}
+
+			if (this.useSourceMap) {
+				return new SourceMapSource(
+					content,
+					name,
+					contextifySourceMap(context, sourceMap, associatedObjectForCache)
+				);
+			}
 		}
+
+		return new RawSource(content);
 	}
 
 	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {string | null} etag etag of the resource
-	 * @returns {any} cached content
+	 * @param {ResolverWithOptions} resolver a resolver
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {InputFileSystem} fs file system from reading
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
+	 * @returns {NormalModuleLoaderContext} loader context
 	 */
-	get(identifier, etag) {
-		const info = this.itemInfo.get(identifier);
-		this._addRequest(identifier);
-		if (info === undefined) {
-			return undefined;
-		}
-		if (info.etag !== etag) return null;
-		info.lastAccess = Date.now();
-		const loc = info.location;
-		if (loc === -1) {
-			return info.freshValue;
-		} else {
-			if (!this.content[loc]) {
-				return undefined;
+	_createLoaderContext(resolver, options, compilation, fs, hooks) {
+		const { requestShortener } = compilation.runtimeTemplate;
+		const getCurrentLoaderName = () => {
+			const currentLoader = this.getCurrentLoader(loaderContext);
+			if (!currentLoader) return "(not in loader scope)";
+			return requestShortener.shorten(currentLoader.loader);
+		};
+		const getResolveContext = () => {
+			return {
+				fileDependencies: {
+					add: d => loaderContext.addDependency(d)
+				},
+				contextDependencies: {
+					add: d => loaderContext.addContextDependency(d)
+				},
+				missingDependencies: {
+					add: d => loaderContext.addMissingDependency(d)
+				}
+			};
+		};
+		const getAbsolutify = memoize(() =>
+			absolutify.bindCache(compilation.compiler.root)
+		);
+		const getAbsolutifyInContext = memoize(() =>
+			absolutify.bindContextCache(this.context, compilation.compiler.root)
+		);
+		const getContextify = memoize(() =>
+			contextify.bindCache(compilation.compiler.root)
+		);
+		const getContextifyInContext = memoize(() =>
+			contextify.bindContextCache(this.context, compilation.compiler.root)
+		);
+		const utils = {
+			absolutify: (context, request) => {
+				return context === this.context
+					? getAbsolutifyInContext()(request)
+					: getAbsolutify()(context, request);
+			},
+			contextify: (context, request) => {
+				return context === this.context
+					? getContextifyInContext()(request)
+					: getContextify()(context, request);
+			},
+			createHash: type => {
+				return createHash(type || compilation.outputOptions.hashFunction);
 			}
-			return this.content[loc].get(identifier);
+		};
+		const loaderContext = {
+			version: 2,
+			getOptions: schema => {
+				const loader = this.getCurrentLoader(loaderContext);
+
+				let { options } = loader;
+
+				if (typeof options === "string") {
+					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
+						try {
+							options = parseJson(options);
+						} catch (e) {
+							throw new Error(`Cannot parse string options: ${e.message}`);
+						}
+					} else {
+						options = querystring.parse(options, "&", "=", {
+							maxKeys: 0
+						});
+					}
+				}
+
+				if (options === null || options === undefined) {
+					options = {};
+				}
+
+				if (schema) {
+					let name = "Loader";
+					let baseDataPath = "options";
+					let match;
+					if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
+						[, name, baseDataPath] = match;
+					}
+					getValidate()(schema, options, {
+						name,
+						baseDataPath
+					});
+				}
+
+				return options;
+			},
+			emitWarning: warning => {
+				if (!(warning instanceof Error)) {
+					warning = new NonErrorEmittedError(warning);
+				}
+				this.addWarning(
+					new ModuleWarning(warning, {
+						from: getCurrentLoaderName()
+					})
+				);
+			},
+			emitError: error => {
+				if (!(error instanceof Error)) {
+					error = new NonErrorEmittedError(error);
+				}
+				this.addError(
+					new ModuleError(error, {
+						from: getCurrentLoaderName()
+					})
+				);
+			},
+			getLogger: name => {
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				return compilation.getLogger(() =>
+					[currentLoader && currentLoader.loader, name, this.identifier()]
+						.filter(Boolean)
+						.join("|")
+				);
+			},
+			resolve(context, request, callback) {
+				resolver.resolve({}, context, request, getResolveContext(), callback);
+			},
+			getResolve(options) {
+				const child = options ? resolver.withOptions(options) : resolver;
+				return (context, request, callback) => {
+					if (callback) {
+						child.resolve({}, context, request, getResolveContext(), callback);
+					} else {
+						return new Promise((resolve, reject) => {
+							child.resolve(
+								{},
+								context,
+								request,
+								getResolveContext(),
+								(err, result) => {
+									if (err) reject(err);
+									else resolve(result);
+								}
+							);
+						});
+					}
+				};
+			},
+			emitFile: (name, content, sourceMap, assetInfo) => {
+				if (!this.buildInfo.assets) {
+					this.buildInfo.assets = Object.create(null);
+					this.buildInfo.assetsInfo = new Map();
+				}
+				this.buildInfo.assets[name] = this.createSourceForAsset(
+					options.context,
+					name,
+					content,
+					sourceMap,
+					compilation.compiler.root
+				);
+				this.buildInfo.assetsInfo.set(name, assetInfo);
+			},
+			addBuildDependency: dep => {
+				if (this.buildInfo.buildDependencies === undefined) {
+					this.buildInfo.buildDependencies = new LazySet();
+				}
+				this.buildInfo.buildDependencies.add(dep);
+			},
+			utils,
+			rootContext: options.context,
+			webpack: true,
+			sourceMap: !!this.useSourceMap,
+			mode: options.mode || "production",
+			_module: this,
+			_compilation: compilation,
+			_compiler: compilation.compiler,
+			fs: fs
+		};
+
+		Object.assign(loaderContext, options.loader);
+
+		hooks.loader.call(loaderContext, this);
+
+		return loaderContext;
+	}
+
+	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
+		if (
+			this.loaders &&
+			this.loaders.length &&
+			index < this.loaders.length &&
+			index >= 0 &&
+			this.loaders[index]
+		) {
+			return this.loaders[index];
 		}
+		return null;
 	}
 
 	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {string | null} etag etag of the resource
-	 * @param {any} data cached content
-	 * @returns {void}
+	 * @param {string} context the compilation context
+	 * @param {string | Buffer} content the content
+	 * @param {string | TODO} sourceMap an optional source map
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @returns {Source} the created source
 	 */
-	set(identifier, etag, data) {
-		if (!this.invalid) {
-			this.invalid = true;
-			this.logger.log(`Pack got invalid because of write to: ${identifier}`);
+	createSource(context, content, sourceMap, associatedObjectForCache) {
+		if (Buffer.isBuffer(content)) {
+			return new RawSource(content);
 		}
-		const info = this.itemInfo.get(identifier);
-		if (info === undefined) {
-			const newInfo = new PackItemInfo(identifier, etag, data);
-			this.itemInfo.set(identifier, newInfo);
-			this._addRequest(identifier);
-			this.freshContent.set(identifier, newInfo);
-		} else {
-			const loc = info.location;
-			if (loc >= 0) {
-				this._addRequest(identifier);
-				this.freshContent.set(identifier, info);
-				const content = this.content[loc];
-				content.delete(identifier);
-				if (content.items.size === 0) {
-					this.content[loc] = undefined;
-					this.logger.debug("Pack %d got empty and is removed", loc);
-				}
-			}
-			info.freshValue = data;
-			info.lastAccess = Date.now();
-			info.etag = etag;
-			info.location = -1;
+
+		// if there is no identifier return raw source
+		if (!this.identifier) {
+			return new RawSource(content);
+		}
+
+		// from here on we assume we have an identifier
+		const identifier = this.identifier();
+
+		if (this.useSourceMap && sourceMap) {
+			return new SourceMapSource(
+				content,
+				contextifySourceUrl(context, identifier, associatedObjectForCache),
+				contextifySourceMap(context, sourceMap, associatedObjectForCache)
+			);
 		}
-	}
 
-	getContentStats() {
-		let count = 0;
-		let size = 0;
-		for (const content of this.content) {
-			if (content !== undefined) {
-				count++;
-				const s = content.getSize();
-				if (s > 0) {
-					size += s;
-				}
-			}
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			return new OriginalSource(
+				content,
+				contextifySourceUrl(context, identifier, associatedObjectForCache)
+			);
 		}
-		return { count, size };
+
+		return new RawSource(content);
 	}
 
 	/**
-	 * @returns {number} new location of data entries
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
+	 * @param {function((WebpackError | null)=): void} callback callback function
+	 * @returns {void}
 	 */
-	_findLocation() {
-		let i;
-		for (i = 0; i < this.content.length && this.content[i] !== undefined; i++);
-		return i;
-	}
+	_doBuild(options, compilation, resolver, fs, hooks, callback) {
+		const loaderContext = this._createLoaderContext(
+			resolver,
+			options,
+			compilation,
+			fs,
+			hooks
+		);
 
-	_gcAndUpdateLocation(items, usedItems, newLoc) {
-		let count = 0;
-		let lastGC;
-		const now = Date.now();
-		for (const identifier of items) {
-			const info = this.itemInfo.get(identifier);
-			if (now - info.lastAccess > this.maxAge) {
-				this.itemInfo.delete(identifier);
-				items.delete(identifier);
-				usedItems.delete(identifier);
-				count++;
-				lastGC = identifier;
-			} else {
-				info.location = newLoc;
+		const processResult = (err, result) => {
+			if (err) {
+				if (!(err instanceof Error)) {
+					err = new NonErrorEmittedError(err);
+				}
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				const error = new ModuleBuildError(err, {
+					from:
+						currentLoader &&
+						compilation.runtimeTemplate.requestShortener.shorten(
+							currentLoader.loader
+						)
+				});
+				return callback(error);
 			}
-		}
-		if (count > 0) {
-			this.logger.log(
-				"Garbage Collected %d old items at pack %d (%d items remaining) e. g. %s",
-				count,
-				newLoc,
-				items.size,
-				lastGC
+
+			const source = result[0];
+			const sourceMap = result.length >= 1 ? result[1] : null;
+			const extraInfo = result.length >= 2 ? result[2] : null;
+
+			if (!Buffer.isBuffer(source) && typeof source !== "string") {
+				const currentLoader = this.getCurrentLoader(loaderContext, 0);
+				const err = new Error(
+					`Final loader (${
+						currentLoader
+							? compilation.runtimeTemplate.requestShortener.shorten(
+									currentLoader.loader
+							  )
+							: "unknown"
+					}) didn't return a Buffer or String`
+				);
+				const error = new ModuleBuildError(err);
+				return callback(error);
+			}
+
+			this._source = this.createSource(
+				options.context,
+				this.binary ? asBuffer(source) : asString(source),
+				sourceMap,
+				compilation.compiler.root
 			);
+			if (this._sourceSizes !== undefined) this._sourceSizes.clear();
+			this._ast =
+				typeof extraInfo === "object" &&
+				extraInfo !== null &&
+				extraInfo.webpackAST !== undefined
+					? extraInfo.webpackAST
+					: null;
+			return callback();
+		};
+
+		this.buildInfo.fileDependencies = new LazySet();
+		this.buildInfo.contextDependencies = new LazySet();
+		this.buildInfo.missingDependencies = new LazySet();
+		this.buildInfo.cacheable = true;
+
+		try {
+			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
+		} catch (err) {
+			processResult(err);
+			return;
 		}
-	}
 
-	_persistFreshContent() {
-		const itemsCount = this.freshContent.size;
-		if (itemsCount > 0) {
-			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
-			const itemsPerPack = Math.ceil(itemsCount / packCount);
-			const packs = [];
-			let i = 0;
-			let ignoreNextTimeTick = false;
-			const createNextPack = () => {
-				const loc = this._findLocation();
-				this.content[loc] = null; // reserve
-				const pack = {
-					/** @type {Set<string>} */
-					items: new Set(),
-					/** @type {Map<string, any>} */
-					map: new Map(),
-					loc
-				};
-				packs.push(pack);
-				return pack;
-			};
-			let pack = createNextPack();
-			if (this.requestsTimeout !== undefined)
-				clearTimeout(this.requestsTimeout);
-			for (const identifier of this.requests) {
-				if (identifier === undefined) {
-					if (ignoreNextTimeTick) {
-						ignoreNextTimeTick = false;
-					} else if (pack.items.size >= MIN_ITEMS_IN_FRESH_PACK) {
-						i = 0;
-						pack = createNextPack();
-					}
-					continue;
+		if (this.loaders.length > 0) {
+			this.buildInfo.buildDependencies = new LazySet();
+		}
+
+		runLoaders(
+			{
+				resource: this.resource,
+				loaders: this.loaders,
+				context: loaderContext,
+				processResource: (loaderContext, resourcePath, callback) => {
+					const resource = loaderContext.resource;
+					const scheme = getScheme(resource);
+					hooks.readResource
+						.for(scheme)
+						.callAsync(loaderContext, (err, result) => {
+							if (err) return callback(err);
+							if (typeof result !== "string" && !result) {
+								return callback(new UnhandledSchemeError(scheme, resource));
+							}
+							return callback(null, result);
+						});
 				}
-				const info = this.freshContent.get(identifier);
-				if (info === undefined) continue;
-				pack.items.add(identifier);
-				pack.map.set(identifier, info.freshValue);
-				info.location = pack.loc;
-				info.freshValue = undefined;
-				this.freshContent.delete(identifier);
-				if (++i > itemsPerPack) {
-					i = 0;
-					pack = createNextPack();
-					ignoreNextTimeTick = true;
+			},
+			(err, result) => {
+				// Cleanup loaderContext to avoid leaking memory in ICs
+				loaderContext._compilation =
+					loaderContext._compiler =
+					loaderContext._module =
+					loaderContext.fs =
+						undefined;
+
+				if (!result) {
+					this.buildInfo.cacheable = false;
+					return processResult(
+						err || new Error("No result from loader-runner processing"),
+						null
+					);
 				}
+				this.buildInfo.fileDependencies.addAll(result.fileDependencies);
+				this.buildInfo.contextDependencies.addAll(result.contextDependencies);
+				this.buildInfo.missingDependencies.addAll(result.missingDependencies);
+				for (const loader of this.loaders) {
+					this.buildInfo.buildDependencies.add(loader.loader);
+				}
+				this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
+				processResult(err, result.result);
 			}
-			this.requests.length = 0;
-			for (const pack of packs) {
-				this.content[pack.loc] = new PackContent(
-					pack.items,
-					new Set(pack.items),
-					new PackContentItems(pack.map)
-				);
-			}
-			this.logger.log(
-				`${itemsCount} fresh items in cache put into pack ${
-					packs.length > 1
-						? packs
-								.map(pack => `${pack.loc} (${pack.items.size} items)`)
-								.join(", ")
-						: packs[0].loc
-				}`
-			);
-		}
+		);
 	}
 
 	/**
-	 * Merges small content files to a single content file
+	 * @param {WebpackError} error the error
+	 * @returns {void}
 	 */
-	_optimizeSmallContent() {
-		// 1. Find all small content files
-		// Treat unused content files separately to avoid
-		// a merge-split cycle
-		/** @type {number[]} */
-		const smallUsedContents = [];
-		/** @type {number} */
-		let smallUsedContentSize = 0;
-		/** @type {number[]} */
-		const smallUnusedContents = [];
-		/** @type {number} */
-		let smallUnusedContentSize = 0;
-		for (let i = 0; i < this.content.length; i++) {
-			const content = this.content[i];
-			if (content === undefined) continue;
-			if (content.outdated) continue;
-			const size = content.getSize();
-			if (size < 0 || size > MIN_CONTENT_SIZE) continue;
-			if (content.used.size > 0) {
-				smallUsedContents.push(i);
-				smallUsedContentSize += size;
-			} else {
-				smallUnusedContents.push(i);
-				smallUnusedContentSize += size;
-			}
+	markModuleAsErrored(error) {
+		// Restore build meta from successful build to keep importing state
+		this.buildMeta = { ...this._lastSuccessfulBuildMeta };
+		this.error = error;
+		this.addError(error);
+	}
+
+	applyNoParseRule(rule, content) {
+		// must start with "rule" if rule is a string
+		if (typeof rule === "string") {
+			return content.startsWith(rule);
 		}
 
-		// 2. Check if minimum number is reached
-		let mergedIndices;
-		if (
-			smallUsedContents.length >= CONTENT_COUNT_TO_MERGE ||
-			smallUsedContentSize > MIN_CONTENT_SIZE
-		) {
-			mergedIndices = smallUsedContents;
-		} else if (
-			smallUnusedContents.length >= CONTENT_COUNT_TO_MERGE ||
-			smallUnusedContentSize > MIN_CONTENT_SIZE
-		) {
-			mergedIndices = smallUnusedContents;
-		} else return;
+		if (typeof rule === "function") {
+			return rule(content);
+		}
+		// we assume rule is a regexp
+		return rule.test(content);
+	}
 
-		const mergedContent = [];
+	// check if module should not be parsed
+	// returns "true" if the module should !not! be parsed
+	// returns "false" if the module !must! be parsed
+	shouldPreventParsing(noParseRule, request) {
+		// if no noParseRule exists, return false
+		// the module !must! be parsed.
+		if (!noParseRule) {
+			return false;
+		}
 
-		// 3. Remove old content entries
-		for (const i of mergedIndices) {
-			mergedContent.push(this.content[i]);
-			this.content[i] = undefined;
+		// we only have one rule to check
+		if (!Array.isArray(noParseRule)) {
+			// returns "true" if the module is !not! to be parsed
+			return this.applyNoParseRule(noParseRule, request);
 		}
 
-		// 4. Determine merged items
-		/** @type {Set<string>} */
-		const mergedItems = new Set();
-		/** @type {Set<string>} */
-		const mergedUsedItems = new Set();
-		/** @type {(function(Map<string, any>): Promise)[]} */
-		const addToMergedMap = [];
-		for (const content of mergedContent) {
-			for (const identifier of content.items) {
-				mergedItems.add(identifier);
-			}
-			for (const identifier of content.used) {
-				mergedUsedItems.add(identifier);
+		for (let i = 0; i < noParseRule.length; i++) {
+			const rule = noParseRule[i];
+			// early exit on first truthy match
+			// this module is !not! to be parsed
+			if (this.applyNoParseRule(rule, request)) {
+				return true;
 			}
-			addToMergedMap.push(async map => {
-				// unpack existing content
-				// after that values are accessible in .content
-				await content.unpack(
-					"it should be merged with other small pack contents"
-				);
-				for (const [identifier, value] of content.content) {
-					map.set(identifier, value);
-				}
-			});
 		}
+		// no match found, so this module !should! be parsed
+		return false;
+	}
 
-		// 5. GC and update location of merged items
-		const newLoc = this._findLocation();
-		this._gcAndUpdateLocation(mergedItems, mergedUsedItems, newLoc);
-
-		// 6. If not empty, store content somewhere
-		if (mergedItems.size > 0) {
-			this.content[newLoc] = new PackContent(
-				mergedItems,
-				mergedUsedItems,
-				memoize(async () => {
-					/** @type {Map<string, any>} */
-					const map = new Map();
-					await Promise.all(addToMergedMap.map(fn => fn(map)));
-					return new PackContentItems(map);
-				})
-			);
-			this.logger.log(
-				"Merged %d small files with %d cache items into pack %d",
-				mergedContent.length,
-				mergedItems.size,
-				newLoc
-			);
+	_initBuildHash(compilation) {
+		const hash = createHash(compilation.outputOptions.hashFunction);
+		if (this._source) {
+			hash.update("source");
+			this._source.updateHash(hash);
 		}
+		hash.update("meta");
+		hash.update(JSON.stringify(this.buildMeta));
+		this.buildInfo.hash = /** @type {string} */ (hash.digest("hex"));
 	}
 
 	/**
-	 * Split large content files with used and unused items
-	 * into two parts to separate used from unused items
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
 	 */
-	_optimizeUnusedContent() {
-		// 1. Find a large content file with used and unused items
-		for (let i = 0; i < this.content.length; i++) {
-			const content = this.content[i];
-			if (content === undefined) continue;
-			const size = content.getSize();
-			if (size < MIN_CONTENT_SIZE) continue;
-			const used = content.used.size;
-			const total = content.items.size;
-			if (used > 0 && used < total) {
-				// 2. Remove this content
-				this.content[i] = undefined;
+	build(options, compilation, resolver, fs, callback) {
+		this._forceBuild = false;
+		this._source = null;
+		if (this._sourceSizes !== undefined) this._sourceSizes.clear();
+		this._sourceTypes = undefined;
+		this._ast = null;
+		this.error = null;
+		this.clearWarningsAndErrors();
+		this.clearDependenciesAndBlocks();
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: false,
+			parsed: true,
+			fileDependencies: undefined,
+			contextDependencies: undefined,
+			missingDependencies: undefined,
+			buildDependencies: undefined,
+			valueDependencies: undefined,
+			hash: undefined,
+			assets: undefined,
+			assetsInfo: undefined
+		};
 
-				// 3. Determine items for the used content file
-				const usedItems = new Set(content.used);
-				const newLoc = this._findLocation();
-				this._gcAndUpdateLocation(usedItems, usedItems, newLoc);
+		const startTime = compilation.compiler.fsStartTime || Date.now();
 
-				// 4. Create content file for used items
-				if (usedItems.size > 0) {
-					this.content[newLoc] = new PackContent(
-						usedItems,
-						new Set(usedItems),
-						async () => {
-							await content.unpack(
-								"it should be splitted into used and unused items"
-							);
-							const map = new Map();
-							for (const identifier of usedItems) {
-								map.set(identifier, content.content.get(identifier));
-							}
-							return new PackContentItems(map);
-						}
-					);
-				}
+		const hooks = NormalModule.getCompilationHooks(compilation);
 
-				// 5. Determine items for the unused content file
-				const unusedItems = new Set(content.items);
-				const usedOfUnusedItems = new Set();
-				for (const identifier of usedItems) {
-					unusedItems.delete(identifier);
+		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
+			// if we have an error mark module as failed and exit
+			if (err) {
+				this.markModuleAsErrored(err);
+				this._initBuildHash(compilation);
+				return callback();
+			}
+
+			const handleParseError = e => {
+				const source = this._source.source();
+				const loaders = this.loaders.map(item =>
+					contextify(options.context, item.loader, compilation.compiler.root)
+				);
+				const error = new ModuleParseError(source, e, loaders, this.type);
+				this.markModuleAsErrored(error);
+				this._initBuildHash(compilation);
+				return callback();
+			};
+
+			const handleParseResult = result => {
+				this.dependencies.sort(
+					concatComparators(
+						compareSelect(a => a.loc, compareLocations),
+						keepOriginalOrder(this.dependencies)
+					)
+				);
+				this._initBuildHash(compilation);
+				this._lastSuccessfulBuildMeta = this.buildMeta;
+				return handleBuildDone();
+			};
+
+			const handleBuildDone = () => {
+				try {
+					hooks.beforeSnapshot.call(this);
+				} catch (err) {
+					this.markModuleAsErrored(err);
+					return callback();
 				}
-				const newUnusedLoc = this._findLocation();
-				this._gcAndUpdateLocation(unusedItems, usedOfUnusedItems, newUnusedLoc);
 
-				// 6. Create content file for unused items
-				if (unusedItems.size > 0) {
-					this.content[newUnusedLoc] = new PackContent(
-						unusedItems,
-						usedOfUnusedItems,
-						async () => {
-							await content.unpack(
-								"it should be splitted into used and unused items"
-							);
-							const map = new Map();
-							for (const identifier of unusedItems) {
-								map.set(identifier, content.content.get(identifier));
+				const snapshotOptions = compilation.options.snapshot.module;
+				if (!this.buildInfo.cacheable || !snapshotOptions) {
+					return callback();
+				}
+				// add warning for all non-absolute paths in fileDependencies, etc
+				// This makes it easier to find problems with watching and/or caching
+				let nonAbsoluteDependencies = undefined;
+				const checkDependencies = deps => {
+					for (const dep of deps) {
+						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
+							if (nonAbsoluteDependencies === undefined)
+								nonAbsoluteDependencies = new Set();
+							nonAbsoluteDependencies.add(dep);
+							deps.delete(dep);
+							try {
+								const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, "");
+								const absolute = join(
+									compilation.fileSystemInfo.fs,
+									this.context,
+									depWithoutGlob
+								);
+								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
+									(depWithoutGlob !== dep
+										? this.buildInfo.contextDependencies
+										: deps
+									).add(absolute);
+								}
+							} catch (e) {
+								// ignore
 							}
-							return new PackContentItems(map);
 						}
+					}
+				};
+				checkDependencies(this.buildInfo.fileDependencies);
+				checkDependencies(this.buildInfo.missingDependencies);
+				checkDependencies(this.buildInfo.contextDependencies);
+				if (nonAbsoluteDependencies !== undefined) {
+					const InvalidDependenciesModuleWarning =
+						getInvalidDependenciesModuleWarning();
+					this.addWarning(
+						new InvalidDependenciesModuleWarning(this, nonAbsoluteDependencies)
 					);
 				}
-
-				this.logger.log(
-					"Split pack %d into pack %d with %d used items and pack %d with %d unused items",
-					i,
-					newLoc,
-					usedItems.size,
-					newUnusedLoc,
-					unusedItems.size
+				// convert file/context/missingDependencies into filesystem snapshot
+				compilation.fileSystemInfo.createSnapshot(
+					startTime,
+					this.buildInfo.fileDependencies,
+					this.buildInfo.contextDependencies,
+					this.buildInfo.missingDependencies,
+					snapshotOptions,
+					(err, snapshot) => {
+						if (err) {
+							this.markModuleAsErrored(err);
+							return;
+						}
+						this.buildInfo.fileDependencies = undefined;
+						this.buildInfo.contextDependencies = undefined;
+						this.buildInfo.missingDependencies = undefined;
+						this.buildInfo.snapshot = snapshot;
+						return callback();
+					}
 				);
+			};
 
-				// optimizing only one of them is good enough and
-				// reduces the amount of serialization needed
-				return;
-			}
-		}
-	}
-
-	/**
-	 * Find the content with the oldest item and run GC on that.
-	 * Only runs for one content to avoid large invalidation.
-	 */
-	_gcOldestContent() {
-		/** @type {PackItemInfo} */
-		let oldest = undefined;
-		for (const info of this.itemInfo.values()) {
-			if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
-				oldest = info;
+			try {
+				hooks.beforeParse.call(this);
+			} catch (err) {
+				this.markModuleAsErrored(err);
+				this._initBuildHash(compilation);
+				return callback();
 			}
-		}
-		if (Date.now() - oldest.lastAccess > this.maxAge) {
-			const loc = oldest.location;
-			if (loc < 0) return;
-			const content = this.content[loc];
-			const items = new Set(content.items);
-			const usedItems = new Set(content.used);
-			this._gcAndUpdateLocation(items, usedItems, loc);
-
-			this.content[loc] =
-				items.size > 0
-					? new PackContent(items, usedItems, async () => {
-							await content.unpack(
-								"it contains old items that should be garbage collected"
-							);
-							const map = new Map();
-							for (const identifier of items) {
-								map.set(identifier, content.content.get(identifier));
-							}
-							return new PackContentItems(map);
-					  })
-					: undefined;
-		}
-	}
 
-	serialize({ write, writeSeparate }) {
-		this._persistFreshContent();
-		this._optimizeSmallContent();
-		this._optimizeUnusedContent();
-		this._gcOldestContent();
-		for (const identifier of this.itemInfo.keys()) {
-			write(identifier);
-		}
-		write(null); // null as marker of the end of keys
-		for (const info of this.itemInfo.values()) {
-			write(info.etag);
-		}
-		for (const info of this.itemInfo.values()) {
-			write(info.lastAccess);
-		}
-		for (let i = 0; i < this.content.length; i++) {
-			const content = this.content[i];
-			if (content !== undefined) {
-				write(content.items);
-				content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
-			} else {
-				write(undefined); // undefined marks an empty content slot
+			// check if this module should !not! be parsed.
+			// if so, exit here;
+			const noParseRule = options.module && options.module.noParse;
+			if (this.shouldPreventParsing(noParseRule, this.request)) {
+				// We assume that we need module and exports
+				this.buildInfo.parsed = false;
+				this._initBuildHash(compilation);
+				return handleBuildDone();
 			}
-		}
-		write(null); // null as marker of the end of items
-	}
 
-	deserialize({ read, logger }) {
-		this.logger = logger;
-		{
-			const items = [];
-			let item = read();
-			while (item !== null) {
-				items.push(item);
-				item = read();
-			}
-			this.itemInfo.clear();
-			const infoItems = items.map(identifier => {
-				const info = new PackItemInfo(identifier, undefined, undefined);
-				this.itemInfo.set(identifier, info);
-				return info;
-			});
-			for (const info of infoItems) {
-				info.etag = read();
-			}
-			for (const info of infoItems) {
-				info.lastAccess = read();
-			}
-		}
-		this.content.length = 0;
-		let items = read();
-		while (items !== null) {
-			if (items === undefined) {
-				this.content.push(items);
-			} else {
-				const idx = this.content.length;
-				const lazy = read();
-				this.content.push(
-					new PackContent(
-						items,
-						new Set(),
-						lazy,
-						logger,
-						`${this.content.length}`
-					)
-				);
-				for (const identifier of items) {
-					this.itemInfo.get(identifier).location = idx;
-				}
+			let result;
+			try {
+				const source = this._source.source();
+				result = this.parser.parse(this._ast || source, {
+					source,
+					current: this,
+					module: this,
+					compilation: compilation,
+					options: options
+				});
+			} catch (e) {
+				handleParseError(e);
+				return;
 			}
-			items = read();
-		}
+			handleParseResult(result);
+		});
 	}
-}
-
-makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
-class PackContentItems {
 	/**
-	 * @param {Map<string, any>} map items
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
-	constructor(map) {
-		this.map = map;
+	getConcatenationBailoutReason(context) {
+		return this.generator.getConcatenationBailoutReason(this, context);
 	}
 
-	serialize({ write, snapshot, rollback, logger, profile }) {
-		if (profile) {
-			write(false);
-			for (const [key, value] of this.map) {
-				const s = snapshot();
-				try {
-					write(key);
-					const start = process.hrtime();
-					write(value);
-					const durationHr = process.hrtime(start);
-					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
-					if (duration > 1) {
-						if (duration > 500)
-							logger.error(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 50)
-							logger.warn(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 10)
-							logger.info(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 5)
-							logger.log(`Serialization of '${key}': ${duration} ms`);
-						else logger.debug(`Serialization of '${key}': ${duration} ms`);
-					}
-				} catch (e) {
-					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
-				}
-			}
-			write(null);
-			return;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		if (this.factoryMeta !== undefined) {
+			if (this.factoryMeta.sideEffectFree) return false;
+			if (this.factoryMeta.sideEffectFree === false) return true;
 		}
-		// Try to serialize all at once
-		const s = snapshot();
-		try {
-			write(true);
-			write(this.map);
-		} catch (e) {
-			rollback(s);
-
-			// Try to serialize each item on it's own
-			write(false);
-			for (const [key, value] of this.map) {
-				const s = snapshot();
-				try {
-					write(key);
-					write(value);
-				} catch (e) {
-					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
+		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
+			if (this._isEvaluatingSideEffects)
+				return ModuleGraphConnection.CIRCULAR_CONNECTION;
+			this._isEvaluatingSideEffects = true;
+			/** @type {ConnectionState} */
+			let current = false;
+			for (const dep of this.dependencies) {
+				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+				if (state === true) {
+					if (
+						this._addedSideEffectsBailout === undefined
+							? ((this._addedSideEffectsBailout = new WeakSet()), true)
+							: !this._addedSideEffectsBailout.has(moduleGraph)
+					) {
+						this._addedSideEffectsBailout.add(moduleGraph);
+						moduleGraph
+							.getOptimizationBailout(this)
+							.push(
+								() =>
+									`Dependency (${
+										dep.type
+									}) with side effects at ${formatLocation(dep.loc)}`
+							);
+					}
+					this._isEvaluatingSideEffects = false;
+					return true;
+				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+					current = ModuleGraphConnection.addConnectionStates(current, state);
 				}
 			}
-			write(null);
+			this._isEvaluatingSideEffects = false;
+			// When caching is implemented here, make sure to not cache when
+			// at least one circular connection was in the loop above
+			return current;
+		} else {
+			return true;
 		}
 	}
 
-	deserialize({ read, logger, profile }) {
-		if (read()) {
-			this.map = read();
-		} else if (profile) {
-			const map = new Map();
-			let key = read();
-			while (key !== null) {
-				const start = process.hrtime();
-				const value = read();
-				const durationHr = process.hrtime(start);
-				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
-				if (duration > 1) {
-					if (duration > 100)
-						logger.error(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 20)
-						logger.warn(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 5)
-						logger.info(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 2)
-						logger.log(`Deserialization of '${key}': ${duration} ms`);
-					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
-				}
-				map.set(key, value);
-				key = read();
-			}
-			this.map = map;
-		} else {
-			const map = new Map();
-			let key = read();
-			while (key !== null) {
-				map.set(key, read());
-				key = read();
-			}
-			this.map = map;
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		if (this._sourceTypes === undefined) {
+			this._sourceTypes = this.generator.getTypes(this);
 		}
+		return this._sourceTypes;
 	}
-}
-
-makeSerializable(
-	PackContentItems,
-	"webpack/lib/cache/PackFileCacheStrategy",
-	"PackContentItems"
-);
-
-class PackContent {
-	/*
-		This class can be in these states:
-		   |   this.lazy    | this.content | this.outdated | state
-		A1 |   undefined    |     Map      |     false     | fresh content
-		A2 |   undefined    |     Map      |     true      | (will not happen)
-		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
-		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
-		C1 | lazy* () => {} |     Map      |     false     | deserialized
-		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
-
-		this.used is a subset of this.items.
-		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
-		When this.lazy and this.content is set, they contain the same data.
-		this.get must only be called with a valid item from this.items.
-		In state C this.lazy is unMemoized
-	*/
 
 	/**
-	 * @param {Set<string>} items keys
-	 * @param {Set<string>} usedItems used keys
-	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
-	 * @param {Logger=} logger logger for logging
-	 * @param {string=} lazyName name of dataOrFn for logging
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	constructor(items, usedItems, dataOrFn, logger, lazyName) {
-		this.items = items;
-		/** @type {function(): Promise<PackContentItems> | PackContentItems} */
-		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
-		/** @type {Map<string, any>} */
-		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
-		this.outdated = false;
-		this.used = usedItems;
-		this.logger = logger;
-		this.lazyName = lazyName;
-	}
+	codeGeneration({
+		dependencyTemplates,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime,
+		concatenationScope,
+		codeGenerationResults
+	}) {
+		/** @type {Set<string>} */
+		const runtimeRequirements = new Set();
 
-	get(identifier) {
-		this.used.add(identifier);
-		if (this.content) {
-			return this.content.get(identifier);
+		if (!this.buildInfo.parsed) {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
 		}
 
-		// We are in state B
-		const { lazyName } = this;
-		let timeMessage;
-		if (lazyName) {
-			// only log once
-			this.lazyName = undefined;
-			timeMessage = `restore cache content ${lazyName} (${formatSize(
-				this.getSize()
-			)})`;
-			this.logger.log(
-				`starting to restore cache content ${lazyName} (${formatSize(
-					this.getSize()
-				)}) because of request to: ${identifier}`
-			);
-			this.logger.time(timeMessage);
-		}
-		const value = this.lazy();
-		if ("then" in value) {
-			return value.then(data => {
-				const map = data.map;
-				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
-				}
-				// Move to state C
-				this.content = map;
-				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
-				return map.get(identifier);
-			});
-		} else {
-			const map = value.map;
-			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
-			}
-			// Move to state C
-			this.content = map;
-			this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
-			return map.get(identifier);
-		}
-	}
+		/** @type {Map<string, any>} */
+		let data;
+		const getData = () => {
+			if (data === undefined) data = new Map();
+			return data;
+		};
 
-	/**
-	 * @param {string} reason explanation why unpack is necessary
-	 * @returns {void | Promise} maybe a promise if lazy
-	 */
-	unpack(reason) {
-		if (this.content) return;
+		const sources = new Map();
+		for (const type of this.generator.getTypes(this)) {
+			const source = this.error
+				? new RawSource(
+						"throw new Error(" + JSON.stringify(this.error.message) + ");"
+				  )
+				: this.generator.generate(this, {
+						dependencyTemplates,
+						runtimeTemplate,
+						moduleGraph,
+						chunkGraph,
+						runtimeRequirements,
+						runtime,
+						concatenationScope,
+						codeGenerationResults,
+						getData,
+						type
+				  });
 
-		// Move from state B to C
-		if (this.lazy) {
-			const { lazyName } = this;
-			let timeMessage;
-			if (lazyName) {
-				// only log once
-				this.lazyName = undefined;
-				timeMessage = `unpack cache content ${lazyName} (${formatSize(
-					this.getSize()
-				)})`;
-				this.logger.log(
-					`starting to unpack cache content ${lazyName} (${formatSize(
-						this.getSize()
-					)}) because ${reason}`
-				);
-				this.logger.time(timeMessage);
-			}
-			const value = this.lazy();
-			if ("then" in value) {
-				return value.then(data => {
-					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
-					}
-					this.content = data.map;
-				});
-			} else {
-				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
-				}
-				this.content = value.map;
+			if (source) {
+				sources.set(type, new CachedSource(source));
 			}
 		}
+
+		/** @type {CodeGenerationResult} */
+		const resultEntry = {
+			sources,
+			runtimeRequirements,
+			data
+		};
+		return resultEntry;
 	}
 
 	/**
-	 * @returns {number} size of the content or -1 if not known
+	 * @returns {Source | null} the original source for the module before webpack transformation
 	 */
-	getSize() {
-		if (!this.lazy) return -1;
-		const options = /** @type {any} */ (this.lazy).options;
-		if (!options) return -1;
-		const size = options.size;
-		if (typeof size !== "number") return -1;
-		return size;
+	originalSource() {
+		return this._source;
 	}
 
-	delete(identifier) {
-		this.items.delete(identifier);
-		this.used.delete(identifier);
-		this.outdated = true;
+	/**
+	 * @returns {void}
+	 */
+	invalidateBuild() {
+		this._forceBuild = true;
 	}
 
 	/**
-	 * @template T
-	 * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
-	writeLazy(write) {
-		if (!this.outdated && this.lazy) {
-			// State B1 or C1
-			// this.lazy is still the valid deserialized version
-			write(this.lazy);
-			return;
-		}
-		if (!this.outdated && this.content) {
-			// State A1
-			const map = new Map(this.content);
-			// Move to state C1
-			this.lazy = SerializerMiddleware.unMemoizeLazy(
-				write(() => new PackContentItems(map))
-			);
-			return;
-		}
-		if (this.content) {
-			// State A2 or C2
-			/** @type {Map<string, any>} */
-			const map = new Map();
-			for (const item of this.items) {
-				map.set(item, this.content.get(item));
-			}
-			// Move to state C1
-			this.outdated = false;
-			this.content = map;
-			this.lazy = SerializerMiddleware.unMemoizeLazy(
-				write(() => new PackContentItems(map))
-			);
-			return;
-		}
-		// State B2
-		const { lazyName } = this;
-		let timeMessage;
-		if (lazyName) {
-			// only log once
-			this.lazyName = undefined;
-			timeMessage = `unpack cache content ${lazyName} (${formatSize(
-				this.getSize()
-			)})`;
-			this.logger.log(
-				`starting to unpack cache content ${lazyName} (${formatSize(
-					this.getSize()
-				)}) because it's outdated and need to be serialized`
-			);
-			this.logger.time(timeMessage);
-		}
-		const value = this.lazy();
-		this.outdated = false;
-		if ("then" in value) {
-			// Move to state B1
-			this.lazy = write(() =>
-				value.then(data => {
-					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
-					}
-					const oldMap = data.map;
-					/** @type {Map<string, any>} */
-					const map = new Map();
-					for (const item of this.items) {
-						map.set(item, oldMap.get(item));
-					}
-					// Move to state C1 (or maybe C2)
-					this.content = map;
-					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+	needBuild(context, callback) {
+		const { fileSystemInfo, compilation, valueCacheVersions } = context;
+		// build if enforced
+		if (this._forceBuild) return callback(null, true);
 
-					return new PackContentItems(map);
-				})
-			);
-		} else {
-			// Move to state C1
-			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
-			}
-			const oldMap = value.map;
-			/** @type {Map<string, any>} */
-			const map = new Map();
-			for (const item of this.items) {
-				map.set(item, oldMap.get(item));
+		// always try to build in case of an error
+		if (this.error) return callback(null, true);
+
+		// always build when module is not cacheable
+		if (!this.buildInfo.cacheable) return callback(null, true);
+
+		// build when there is no snapshot to check
+		if (!this.buildInfo.snapshot) return callback(null, true);
+
+		// build when valueDependencies have changed
+		/** @type {Map<string, string | Set<string>>} */
+		const valueDependencies = this.buildInfo.valueDependencies;
+		if (valueDependencies) {
+			if (!valueCacheVersions) return callback(null, true);
+			for (const [key, value] of valueDependencies) {
+				if (value === undefined) return callback(null, true);
+				const current = valueCacheVersions.get(key);
+				if (
+					value !== current &&
+					(typeof value === "string" ||
+						typeof current === "string" ||
+						current === undefined ||
+						!isSubset(value, current))
+				) {
+					return callback(null, true);
+				}
 			}
-			this.content = map;
-			this.lazy = write(() => new PackContentItems(map));
 		}
-	}
-}
 
-const allowCollectingMemory = buf => {
-	const wasted = buf.buffer.byteLength - buf.byteLength;
-	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
-		return Buffer.from(buf);
+		// check snapshot for validity
+		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+			if (err) return callback(err);
+			if (!valid) return callback(null, true);
+			const hooks = NormalModule.getCompilationHooks(compilation);
+			hooks.needBuild.callAsync(this, context, (err, needBuild) => {
+				if (err) {
+					return callback(
+						HookWebpackError.makeWebpackError(
+							err,
+							"NormalModule.getCompilationHooks().needBuild"
+						)
+					);
+				}
+				callback(null, !!needBuild);
+			});
+		});
 	}
-	return buf;
-};
 
-class PackFileCacheStrategy {
 	/**
-	 * @param {Object} options options
-	 * @param {Compiler} options.compiler the compiler
-	 * @param {IntermediateFileSystem} options.fs the filesystem
-	 * @param {string} options.context the context directory
-	 * @param {string} options.cacheLocation the location of the cache data
-	 * @param {string} options.version version identifier
-	 * @param {Logger} options.logger a logger
-	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
-	 * @param {number} options.maxAge max age of cache items
-	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
-	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
-	 * @param {false | "gzip" | "brotli"} options.compression compression used
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	constructor({
-		compiler,
-		fs,
-		context,
-		cacheLocation,
-		version,
-		logger,
-		snapshot,
-		maxAge,
-		profile,
-		allowCollectingMemory,
-		compression
-	}) {
-		this.fileSerializer = createFileSerializer(
-			fs,
-			compiler.options.output.hashFunction
-		);
-		this.fileSystemInfo = new FileSystemInfo(fs, {
-			managedPaths: snapshot.managedPaths,
-			immutablePaths: snapshot.immutablePaths,
-			logger: logger.getChildLogger("webpack.FileSystemInfo"),
-			hashFunction: compiler.options.output.hashFunction
-		});
-		this.compiler = compiler;
-		this.context = context;
-		this.cacheLocation = cacheLocation;
-		this.version = version;
-		this.logger = logger;
-		this.maxAge = maxAge;
-		this.profile = profile;
-		this.allowCollectingMemory = allowCollectingMemory;
-		this.compression = compression;
-		this._extension =
-			compression === "brotli"
-				? ".pack.br"
-				: compression === "gzip"
-				? ".pack.gz"
-				: ".pack";
-		this.snapshot = snapshot;
-		/** @type {Set<string>} */
-		this.buildDependencies = new Set();
-		/** @type {LazySet<string>} */
-		this.newBuildDependencies = new LazySet();
-		/** @type {Snapshot} */
-		this.resolveBuildDependenciesSnapshot = undefined;
-		/** @type {Map<string, string | false>} */
-		this.resolveResults = undefined;
-		/** @type {Snapshot} */
-		this.buildSnapshot = undefined;
-		/** @type {Promise<Pack>} */
-		this.packPromise = this._openPack();
-		this.storePromise = Promise.resolve();
+	size(type) {
+		const cachedSize =
+			this._sourceSizes === undefined ? undefined : this._sourceSizes.get(type);
+		if (cachedSize !== undefined) {
+			return cachedSize;
+		}
+		const size = Math.max(1, this.generator.getSize(this, type));
+		if (this._sourceSizes === undefined) {
+			this._sourceSizes = new Map();
+		}
+		this._sourceSizes.set(type, size);
+		return size;
 	}
 
-	_getPack() {
-		if (this.packPromise === undefined) {
-			this.packPromise = this.storePromise.then(() => this._openPack());
+	/**
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 */
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {
+		const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
+		if (snapshot) {
+			fileDependencies.addAll(snapshot.getFileIterable());
+			contextDependencies.addAll(snapshot.getContextIterable());
+			missingDependencies.addAll(snapshot.getMissingIterable());
+		} else {
+			const {
+				fileDependencies: fileDeps,
+				contextDependencies: contextDeps,
+				missingDependencies: missingDeps
+			} = this.buildInfo;
+			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
+			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
+			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
+		}
+		if (buildDeps !== undefined) {
+			buildDependencies.addAll(buildDeps);
 		}
-		return this.packPromise;
 	}
 
 	/**
-	 * @returns {Promise<Pack>} the pack
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
 	 */
-	_openPack() {
-		const { logger, profile, cacheLocation, version } = this;
-		/** @type {Snapshot} */
-		let buildSnapshot;
-		/** @type {Set<string>} */
-		let buildDependencies;
-		/** @type {Set<string>} */
-		let newBuildDependencies;
-		/** @type {Snapshot} */
-		let resolveBuildDependenciesSnapshot;
-		/** @type {Map<string, string | false>} */
-		let resolveResults;
-		logger.time("restore cache container");
-		return this.fileSerializer
-			.deserialize(null, {
-				filename: `${cacheLocation}/index${this._extension}`,
-				extension: `${this._extension}`,
-				logger,
-				profile,
-				retainedBuffer: this.allowCollectingMemory
-					? allowCollectingMemory
-					: undefined
-			})
-			.catch(err => {
-				if (err.code !== "ENOENT") {
-					logger.warn(
-						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
-					);
-					logger.debug(err.stack);
-				} else {
-					logger.debug(
-						`No pack exists at ${cacheLocation}${this._extension}: ${err}`
-					);
-				}
-				return undefined;
-			})
-			.then(packContainer => {
-				logger.timeEnd("restore cache container");
-				if (!packContainer) return undefined;
-				if (!(packContainer instanceof PackContainer)) {
-					logger.warn(
-						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
-						packContainer
-					);
-					return undefined;
-				}
-				if (packContainer.version !== version) {
-					logger.log(
-						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
-					);
-					return undefined;
-				}
-				logger.time("check build dependencies");
-				return Promise.all([
-					new Promise((resolve, reject) => {
-						this.fileSystemInfo.checkSnapshotValid(
-							packContainer.buildSnapshot,
-							(err, valid) => {
-								if (err) {
-									logger.log(
-										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.`
-									);
-									logger.debug(err.stack);
-									return resolve(false);
-								}
-								if (!valid) {
-									logger.log(
-										`Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.`
-									);
-									return resolve(false);
-								}
-								buildSnapshot = packContainer.buildSnapshot;
-								return resolve(true);
-							}
-						);
-					}),
-					new Promise((resolve, reject) => {
-						this.fileSystemInfo.checkSnapshotValid(
-							packContainer.resolveBuildDependenciesSnapshot,
-							(err, valid) => {
-								if (err) {
-									logger.log(
-										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.`
-									);
-									logger.debug(err.stack);
-									return resolve(false);
-								}
-								if (valid) {
-									resolveBuildDependenciesSnapshot =
-										packContainer.resolveBuildDependenciesSnapshot;
-									buildDependencies = packContainer.buildDependencies;
-									resolveResults = packContainer.resolveResults;
-									return resolve(true);
-								}
-								logger.log(
-									"resolving of build dependencies is invalid, will re-resolve build dependencies"
-								);
-								this.fileSystemInfo.checkResolveResultsValid(
-									packContainer.resolveResults,
-									(err, valid) => {
-										if (err) {
-											logger.log(
-												`Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.`
-											);
-											logger.debug(err.stack);
-											return resolve(false);
-										}
-										if (valid) {
-											newBuildDependencies = packContainer.buildDependencies;
-											resolveResults = packContainer.resolveResults;
-											return resolve(true);
-										}
-										logger.log(
-											`Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.`
-										);
-										return resolve(false);
-									}
-								);
-							}
-						);
-					})
-				])
-					.catch(err => {
-						logger.timeEnd("check build dependencies");
-						throw err;
-					})
-					.then(([buildSnapshotValid, resolveValid]) => {
-						logger.timeEnd("check build dependencies");
-						if (buildSnapshotValid && resolveValid) {
-							logger.time("restore cache content metadata");
-							const d = packContainer.data();
-							logger.timeEnd("restore cache content metadata");
-							return d;
-						}
-						return undefined;
-					});
-			})
-			.then(pack => {
-				if (pack) {
-					pack.maxAge = this.maxAge;
-					this.buildSnapshot = buildSnapshot;
-					if (buildDependencies) this.buildDependencies = buildDependencies;
-					if (newBuildDependencies)
-						this.newBuildDependencies.addAll(newBuildDependencies);
-					this.resolveResults = resolveResults;
-					this.resolveBuildDependenciesSnapshot =
-						resolveBuildDependenciesSnapshot;
-					return pack;
-				}
-				return new Pack(logger, this.maxAge);
-			})
-			.catch(err => {
-				this.logger.warn(
-					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
-				);
-				this.logger.debug(err.stack);
-				return new Pack(logger, this.maxAge);
-			});
+	updateHash(hash, context) {
+		hash.update(this.buildInfo.hash);
+		this.generator.updateHash(hash, {
+			module: this,
+			...context
+		});
+		super.updateHash(hash, context);
+	}
+
+	serialize(context) {
+		const { write } = context;
+		// deserialize
+		write(this._source);
+		write(this.error);
+		write(this._lastSuccessfulBuildMeta);
+		write(this._forceBuild);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const obj = new NormalModule({
+			// will be deserialized by Module
+			layer: null,
+			type: "",
+			// will be filled by updateCacheModule
+			resource: "",
+			context: "",
+			request: null,
+			userRequest: null,
+			rawRequest: null,
+			loaders: null,
+			matchResource: null,
+			parser: null,
+			parserOptions: null,
+			generator: null,
+			generatorOptions: null,
+			resolveOptions: null
+		});
+		obj.deserialize(context);
+		return obj;
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this._source = read();
+		this.error = read();
+		this._lastSuccessfulBuildMeta = read();
+		this._forceBuild = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(NormalModule, "webpack/lib/NormalModule");
+
+module.exports = NormalModule;
+
+
+/***/ }),
+
+/***/ 68860:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { getContext } = __webpack_require__(68318);
+const asyncLib = __webpack_require__(78175);
+const {
+	AsyncSeriesBailHook,
+	SyncWaterfallHook,
+	SyncBailHook,
+	SyncHook,
+	HookMap
+} = __webpack_require__(41242);
+const ChunkGraph = __webpack_require__(64971);
+const Module = __webpack_require__(73208);
+const ModuleFactory = __webpack_require__(51010);
+const ModuleGraph = __webpack_require__(99988);
+const NormalModule = __webpack_require__(39);
+const BasicEffectRulePlugin = __webpack_require__(30318);
+const BasicMatcherRulePlugin = __webpack_require__(94215);
+const ObjectMatcherRulePlugin = __webpack_require__(72021);
+const RuleSetCompiler = __webpack_require__(83349);
+const UseEffectRulePlugin = __webpack_require__(84977);
+const LazySet = __webpack_require__(38938);
+const { getScheme } = __webpack_require__(54500);
+const { cachedCleverMerge, cachedSetProperty } = __webpack_require__(60839);
+const { join } = __webpack_require__(17139);
+const { parseResource } = __webpack_require__(82186);
+
+/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./Parser")} Parser */
+/** @typedef {import("./ResolverFactory")} ResolverFactory */
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+/**
+ * @typedef {Object} ResolveData
+ * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
+ * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
+ * @property {string} context
+ * @property {string} request
+ * @property {Record<string, any> | undefined} assertions
+ * @property {ModuleDependency[]} dependencies
+ * @property {string} dependencyType
+ * @property {Object} createData
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {boolean} cacheable allow to use the unsafe cache
+ */
+
+/**
+ * @typedef {Object} ResourceData
+ * @property {string} resource
+ * @property {string} path
+ * @property {string} query
+ * @property {string} fragment
+ * @property {string=} context
+ */
+
+/** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
+
+const EMPTY_RESOLVE_OPTIONS = {};
+const EMPTY_PARSER_OPTIONS = {};
+const EMPTY_GENERATOR_OPTIONS = {};
+const EMPTY_ELEMENTS = [];
+
+const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
+
+const loaderToIdent = data => {
+	if (!data.options) {
+		return data.loader;
+	}
+	if (typeof data.options === "string") {
+		return data.loader + "?" + data.options;
+	}
+	if (typeof data.options !== "object") {
+		throw new Error("loader options must be string or object");
+	}
+	if (data.ident) {
+		return data.loader + "??" + data.ident;
 	}
+	return data.loader + "?" + JSON.stringify(data.options);
+};
 
-	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {Etag | null} etag etag of the resource
-	 * @param {any} data cached content
-	 * @returns {Promise<void>} promise
-	 */
-	store(identifier, etag, data) {
-		return this._getPack().then(pack => {
-			pack.set(identifier, etag === null ? null : etag.toString(), data);
-		});
+const stringifyLoadersAndResource = (loaders, resource) => {
+	let str = "";
+	for (const loader of loaders) {
+		str += loaderToIdent(loader) + "!";
+	}
+	return str + resource;
+};
+
+/**
+ * @param {string} resultString resultString
+ * @returns {{loader: string, options: string|undefined}} parsed loader request
+ */
+const identToLoaderRequest = resultString => {
+	const idx = resultString.indexOf("?");
+	if (idx >= 0) {
+		const loader = resultString.substr(0, idx);
+		const options = resultString.substr(idx + 1);
+		return {
+			loader,
+			options
+		};
+	} else {
+		return {
+			loader: resultString,
+			options: undefined
+		};
+	}
+};
+
+const needCalls = (times, callback) => {
+	return err => {
+		if (--times === 0) {
+			return callback(err);
+		}
+		if (err && times > 0) {
+			times = NaN;
+			return callback(err);
+		}
+	};
+};
+
+const mergeGlobalOptions = (globalOptions, type, localOptions) => {
+	const parts = type.split("/");
+	let result;
+	let current = "";
+	for (const part of parts) {
+		current = current ? `${current}/${part}` : part;
+		const options = globalOptions[current];
+		if (typeof options === "object") {
+			if (result === undefined) {
+				result = options;
+			} else {
+				result = cachedCleverMerge(result, options);
+			}
+		}
+	}
+	if (result === undefined) {
+		return localOptions;
+	} else {
+		return cachedCleverMerge(result, localOptions);
 	}
+};
+
+// TODO webpack 6 remove
+const deprecationChangedHookMessage = (name, hook) => {
+	const names = hook.taps
+		.map(tapped => {
+			return tapped.name;
+		})
+		.join(", ");
+
+	return (
+		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
+		"Do not return the passed object, but modify it instead. " +
+		"Returning false will ignore the request and results in no module created."
+	);
+};
 
+const ruleSetCompiler = new RuleSetCompiler([
+	new BasicMatcherRulePlugin("test", "resource"),
+	new BasicMatcherRulePlugin("scheme"),
+	new BasicMatcherRulePlugin("mimetype"),
+	new BasicMatcherRulePlugin("dependency"),
+	new BasicMatcherRulePlugin("include", "resource"),
+	new BasicMatcherRulePlugin("exclude", "resource", true),
+	new BasicMatcherRulePlugin("resource"),
+	new BasicMatcherRulePlugin("resourceQuery"),
+	new BasicMatcherRulePlugin("resourceFragment"),
+	new BasicMatcherRulePlugin("realResource"),
+	new BasicMatcherRulePlugin("issuer"),
+	new BasicMatcherRulePlugin("compiler"),
+	new BasicMatcherRulePlugin("issuerLayer"),
+	new ObjectMatcherRulePlugin("assert", "assertions"),
+	new ObjectMatcherRulePlugin("descriptionData"),
+	new BasicEffectRulePlugin("type"),
+	new BasicEffectRulePlugin("sideEffects"),
+	new BasicEffectRulePlugin("parser"),
+	new BasicEffectRulePlugin("resolve"),
+	new BasicEffectRulePlugin("generator"),
+	new BasicEffectRulePlugin("layer"),
+	new UseEffectRulePlugin()
+]);
+
+class NormalModuleFactory extends ModuleFactory {
 	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {Etag | null} etag etag of the resource
-	 * @returns {Promise<any>} promise to the cached content
+	 * @param {Object} param params
+	 * @param {string=} param.context context
+	 * @param {InputFileSystem} param.fs file system
+	 * @param {ResolverFactory} param.resolverFactory resolverFactory
+	 * @param {ModuleOptions} param.options options
+	 * @param {Object=} param.associatedObjectForCache an object to which the cache will be attached
+	 * @param {boolean=} param.layers enable layers
 	 */
-	restore(identifier, etag) {
-		return this._getPack()
-			.then(pack =>
-				pack.get(identifier, etag === null ? null : etag.toString())
+	constructor({
+		context,
+		fs,
+		resolverFactory,
+		options,
+		associatedObjectForCache,
+		layers = false
+	}) {
+		super();
+		this.hooks = Object.freeze({
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			resolve: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
+			resolveForScheme: new HookMap(
+				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
+			),
+			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
+			resolveInScheme: new HookMap(
+				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
+			),
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			factorize: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
+			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
+			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
+			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
+			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
+			createGenerator: new HookMap(
+				() => new SyncBailHook(["generatorOptions"])
+			),
+			generator: new HookMap(
+				() => new SyncHook(["generator", "generatorOptions"])
 			)
-			.catch(err => {
-				if (err && err.code !== "ENOENT") {
-					this.logger.warn(
-						`Restoring failed for ${identifier} from pack: ${err}`
-					);
-					this.logger.debug(err.stack);
-				}
-			});
-	}
+		});
+		this.resolverFactory = resolverFactory;
+		this.ruleSet = ruleSetCompiler.compile([
+			{
+				rules: options.defaultRules
+			},
+			{
+				rules: options.rules
+			}
+		]);
+		this.context = context || "";
+		this.fs = fs;
+		this._globalParserOptions = options.parser;
+		this._globalGeneratorOptions = options.generator;
+		/** @type {Map<string, WeakMap<Object, TODO>>} */
+		this.parserCache = new Map();
+		/** @type {Map<string, WeakMap<Object, Generator>>} */
+		this.generatorCache = new Map();
+		/** @type {Set<Module>} */
+		this._restoredUnsafeCacheEntries = new Set();
 
-	storeBuildDependencies(dependencies) {
-		this.newBuildDependencies.addAll(dependencies);
-	}
+		const cacheParseResource = parseResource.bindCache(
+			associatedObjectForCache
+		);
 
-	afterAllStored() {
-		const packPromise = this.packPromise;
-		if (packPromise === undefined) return Promise.resolve();
-		const reportProgress = ProgressPlugin.getReporter(this.compiler);
-		return (this.storePromise = packPromise
-			.then(pack => {
-				pack.stopCapturingRequests();
-				if (!pack.invalid) return;
-				this.packPromise = undefined;
-				this.logger.log(`Storing pack...`);
-				let promise;
-				const newBuildDependencies = new Set();
-				for (const dep of this.newBuildDependencies) {
-					if (!this.buildDependencies.has(dep)) {
-						newBuildDependencies.add(dep);
-					}
-				}
-				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
-					if (reportProgress) reportProgress(0.5, "resolve build dependencies");
-					this.logger.debug(
-						`Capturing build dependencies... (${Array.from(
-							newBuildDependencies
-						).join(", ")})`
-					);
-					promise = new Promise((resolve, reject) => {
-						this.logger.time("resolve build dependencies");
-						this.fileSystemInfo.resolveBuildDependencies(
-							this.context,
-							newBuildDependencies,
-							(err, result) => {
-								this.logger.timeEnd("resolve build dependencies");
-								if (err) return reject(err);
+		this.hooks.factorize.tapAsync(
+			{
+				name: "NormalModuleFactory",
+				stage: 100
+			},
+			(resolveData, callback) => {
+				this.hooks.resolve.callAsync(resolveData, (err, result) => {
+					if (err) return callback(err);
 
-								this.logger.time("snapshot build dependencies");
-								const {
-									files,
-									directories,
-									missing,
-									resolveResults,
-									resolveDependencies
-								} = result;
-								if (this.resolveResults) {
-									for (const [key, value] of resolveResults) {
-										this.resolveResults.set(key, value);
-									}
-								} else {
-									this.resolveResults = resolveResults;
-								}
-								if (reportProgress) {
-									reportProgress(
-										0.6,
-										"snapshot build dependencies",
-										"resolving"
-									);
-								}
-								this.fileSystemInfo.createSnapshot(
-									undefined,
-									resolveDependencies.files,
-									resolveDependencies.directories,
-									resolveDependencies.missing,
-									this.snapshot.resolveBuildDependencies,
-									(err, snapshot) => {
-										if (err) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(err);
-										}
-										if (!snapshot) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(
-												new Error("Unable to snapshot resolve dependencies")
-											);
-										}
-										if (this.resolveBuildDependenciesSnapshot) {
-											this.resolveBuildDependenciesSnapshot =
-												this.fileSystemInfo.mergeSnapshots(
-													this.resolveBuildDependenciesSnapshot,
-													snapshot
-												);
-										} else {
-											this.resolveBuildDependenciesSnapshot = snapshot;
-										}
-										if (reportProgress) {
-											reportProgress(
-												0.7,
-												"snapshot build dependencies",
-												"modules"
-											);
-										}
-										this.fileSystemInfo.createSnapshot(
-											undefined,
-											files,
-											directories,
-											missing,
-											this.snapshot.buildDependencies,
-											(err, snapshot) => {
-												this.logger.timeEnd("snapshot build dependencies");
-												if (err) return reject(err);
-												if (!snapshot) {
-													return reject(
-														new Error("Unable to snapshot build dependencies")
-													);
-												}
-												this.logger.debug("Captured build dependencies");
+					// Ignored
+					if (result === false) return callback();
 
-												if (this.buildSnapshot) {
-													this.buildSnapshot =
-														this.fileSystemInfo.mergeSnapshots(
-															this.buildSnapshot,
-															snapshot
-														);
-												} else {
-													this.buildSnapshot = snapshot;
-												}
+					// direct module
+					if (result instanceof Module) return callback(null, result);
 
-												resolve();
-											}
-										);
+					if (typeof result === "object")
+						throw new Error(
+							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
+								" Returning a Module object will result in this module used as result."
+						);
+
+					this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
+						if (err) return callback(err);
+
+						if (typeof result === "object")
+							throw new Error(
+								deprecationChangedHookMessage(
+									"afterResolve",
+									this.hooks.afterResolve
+								)
+							);
+
+						// Ignored
+						if (result === false) return callback();
+
+						const createData = resolveData.createData;
+
+						this.hooks.createModule.callAsync(
+							createData,
+							resolveData,
+							(err, createdModule) => {
+								if (!createdModule) {
+									if (!resolveData.request) {
+										return callback(new Error("Empty dependency (no request)"));
 									}
+
+									createdModule = new NormalModule(createData);
+								}
+
+								createdModule = this.hooks.module.call(
+									createdModule,
+									createData,
+									resolveData
 								);
+
+								return callback(null, createdModule);
 							}
 						);
 					});
+				});
+			}
+		);
+		this.hooks.resolve.tapAsync(
+			{
+				name: "NormalModuleFactory",
+				stage: 100
+			},
+			(data, callback) => {
+				const {
+					contextInfo,
+					context,
+					dependencies,
+					dependencyType,
+					request,
+					assertions,
+					resolveOptions,
+					fileDependencies,
+					missingDependencies,
+					contextDependencies
+				} = data;
+				const loaderResolver = this.getResolver("loader");
+
+				/** @type {ResourceData | undefined} */
+				let matchResourceData = undefined;
+				/** @type {string} */
+				let unresolvedResource;
+				/** @type {{loader: string, options: string|undefined}[]} */
+				let elements;
+				let noPreAutoLoaders = false;
+				let noAutoLoaders = false;
+				let noPrePostAutoLoaders = false;
+
+				const contextScheme = getScheme(context);
+				/** @type {string | undefined} */
+				let scheme = getScheme(request);
+
+				if (!scheme) {
+					/** @type {string} */
+					let requestWithoutMatchResource = request;
+					const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
+					if (matchResourceMatch) {
+						let matchResource = matchResourceMatch[1];
+						if (matchResource.charCodeAt(0) === 46) {
+							// 46 === ".", 47 === "/"
+							const secondChar = matchResource.charCodeAt(1);
+							if (
+								secondChar === 47 ||
+								(secondChar === 46 && matchResource.charCodeAt(2) === 47)
+							) {
+								// if matchResources startsWith ../ or ./
+								matchResource = join(this.fs, context, matchResource);
+							}
+						}
+						matchResourceData = {
+							resource: matchResource,
+							...cacheParseResource(matchResource)
+						};
+						requestWithoutMatchResource = request.substr(
+							matchResourceMatch[0].length
+						);
+					}
+
+					scheme = getScheme(requestWithoutMatchResource);
+
+					if (!scheme && !contextScheme) {
+						const firstChar = requestWithoutMatchResource.charCodeAt(0);
+						const secondChar = requestWithoutMatchResource.charCodeAt(1);
+						noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!"
+						noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!"
+						noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!";
+						const rawElements = requestWithoutMatchResource
+							.slice(
+								noPreAutoLoaders || noPrePostAutoLoaders
+									? 2
+									: noAutoLoaders
+									? 1
+									: 0
+							)
+							.split(/!+/);
+						unresolvedResource = rawElements.pop();
+						elements = rawElements.map(identToLoaderRequest);
+						scheme = getScheme(unresolvedResource);
+					} else {
+						unresolvedResource = requestWithoutMatchResource;
+						elements = EMPTY_ELEMENTS;
+					}
 				} else {
-					promise = Promise.resolve();
+					unresolvedResource = request;
+					elements = EMPTY_ELEMENTS;
 				}
-				return promise.then(() => {
-					if (reportProgress) reportProgress(0.8, "serialize pack");
-					this.logger.time(`store pack`);
-					const updatedBuildDependencies = new Set(this.buildDependencies);
-					for (const dep of newBuildDependencies) {
-						updatedBuildDependencies.add(dep);
-					}
-					const content = new PackContainer(
-						pack,
-						this.version,
-						this.buildSnapshot,
-						updatedBuildDependencies,
-						this.resolveResults,
-						this.resolveBuildDependenciesSnapshot
-					);
-					return this.fileSerializer
-						.serialize(content, {
-							filename: `${this.cacheLocation}/index${this._extension}`,
-							extension: `${this._extension}`,
-							logger: this.logger,
-							profile: this.profile
-						})
-						.then(() => {
-							for (const dep of newBuildDependencies) {
-								this.buildDependencies.add(dep);
-							}
-							this.newBuildDependencies.clear();
-							this.logger.timeEnd(`store pack`);
-							const stats = pack.getContentStats();
-							this.logger.log(
-								"Stored pack (%d items, %d files, %d MiB)",
-								pack.itemInfo.size,
-								stats.count,
-								Math.round(stats.size / 1024 / 1024)
-							);
-						})
-						.catch(err => {
-							this.logger.timeEnd(`store pack`);
-							this.logger.warn(`Caching failed for pack: ${err}`);
-							this.logger.debug(err.stack);
-						});
-				});
-			})
-			.catch(err => {
-				this.logger.warn(`Caching failed for pack: ${err}`);
-				this.logger.debug(err.stack);
-			}));
-	}
 
-	clear() {
-		this.fileSystemInfo.clear();
-		this.buildDependencies.clear();
-		this.newBuildDependencies.clear();
-		this.resolveBuildDependenciesSnapshot = undefined;
-		this.resolveResults = undefined;
-		this.buildSnapshot = undefined;
-		this.packPromise = undefined;
-	}
-}
+				const resolveContext = {
+					fileDependencies,
+					missingDependencies,
+					contextDependencies
+				};
 
-module.exports = PackFileCacheStrategy;
+				/** @type {ResourceDataWithData} */
+				let resourceData;
 
+				let loaders;
 
-/***/ }),
+				const continueCallback = needCalls(2, err => {
+					if (err) return callback(err);
 
-/***/ 97347:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					// translate option idents
+					try {
+						for (const item of loaders) {
+							if (typeof item.options === "string" && item.options[0] === "?") {
+								const ident = item.options.substr(1);
+								if (ident === "[[missing ident]]") {
+									throw new Error(
+										"No ident is provided by referenced loader. " +
+											"When using a function for Rule.use in config you need to " +
+											"provide an 'ident' property for referenced loader options."
+									);
+								}
+								item.options = this.ruleSet.references.get(ident);
+								if (item.options === undefined) {
+									throw new Error(
+										"Invalid ident is provided by referenced loader"
+									);
+								}
+								item.ident = ident;
+							}
+						}
+					} catch (e) {
+						return callback(e);
+					}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					if (!resourceData) {
+						// ignored
+						return callback(null, dependencies[0].createIgnoredModule(context));
+					}
 
+					const userRequest =
+						(matchResourceData !== undefined
+							? `${matchResourceData.resource}!=!`
+							: "") +
+						stringifyLoadersAndResource(loaders, resourceData.resource);
 
+					const settings = {};
+					const useLoadersPost = [];
+					const useLoaders = [];
+					const useLoadersPre = [];
 
-const LazySet = __webpack_require__(38938);
-const makeSerializable = __webpack_require__(33032);
+					// handle .webpack[] suffix
+					let resource;
+					let match;
+					if (
+						matchResourceData &&
+						typeof (resource = matchResourceData.resource) === "string" &&
+						(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
+					) {
+						settings.type = match[1];
+						matchResourceData.resource = matchResourceData.resource.slice(
+							0,
+							-settings.type.length - 10
+						);
+					} else {
+						settings.type = "javascript/auto";
+						const resourceDataForRules = matchResourceData || resourceData;
+						const result = this.ruleSet.exec({
+							resource: resourceDataForRules.path,
+							realResource: resourceData.path,
+							resourceQuery: resourceDataForRules.query,
+							resourceFragment: resourceDataForRules.fragment,
+							scheme,
+							assertions,
+							mimetype: matchResourceData
+								? ""
+								: resourceData.data.mimetype || "",
+							dependency: dependencyType,
+							descriptionData: matchResourceData
+								? undefined
+								: resourceData.data.descriptionFileData,
+							issuer: contextInfo.issuer,
+							compiler: contextInfo.compiler,
+							issuerLayer: contextInfo.issuerLayer || ""
+						});
+						for (const r of result) {
+							if (r.type === "use") {
+								if (!noAutoLoaders && !noPrePostAutoLoaders) {
+									useLoaders.push(r.value);
+								}
+							} else if (r.type === "use-post") {
+								if (!noPrePostAutoLoaders) {
+									useLoadersPost.push(r.value);
+								}
+							} else if (r.type === "use-pre") {
+								if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
+									useLoadersPre.push(r.value);
+								}
+							} else if (
+								typeof r.value === "object" &&
+								r.value !== null &&
+								typeof settings[r.type] === "object" &&
+								settings[r.type] !== null
+							) {
+								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
+							} else {
+								settings[r.type] = r.value;
+							}
+						}
+					}
 
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
-/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+					let postLoaders, normalLoaders, preLoaders;
 
-class CacheEntry {
-	constructor(result, snapshot) {
-		this.result = result;
-		this.snapshot = snapshot;
-	}
+					const continueCallback = needCalls(3, err => {
+						if (err) {
+							return callback(err);
+						}
+						const allLoaders = postLoaders;
+						if (matchResourceData === undefined) {
+							for (const loader of loaders) allLoaders.push(loader);
+							for (const loader of normalLoaders) allLoaders.push(loader);
+						} else {
+							for (const loader of normalLoaders) allLoaders.push(loader);
+							for (const loader of loaders) allLoaders.push(loader);
+						}
+						for (const loader of preLoaders) allLoaders.push(loader);
+						let type = settings.type;
+						const resolveOptions = settings.resolve;
+						const layer = settings.layer;
+						if (layer !== undefined && !layers) {
+							return callback(
+								new Error(
+									"'Rule.layer' is only allowed when 'experiments.layers' is enabled"
+								)
+							);
+						}
+						try {
+							Object.assign(data.createData, {
+								layer:
+									layer === undefined ? contextInfo.issuerLayer || null : layer,
+								request: stringifyLoadersAndResource(
+									allLoaders,
+									resourceData.resource
+								),
+								userRequest,
+								rawRequest: request,
+								loaders: allLoaders,
+								resource: resourceData.resource,
+								context:
+									resourceData.context || getContext(resourceData.resource),
+								matchResource: matchResourceData
+									? matchResourceData.resource
+									: undefined,
+								resourceResolveData: resourceData.data,
+								settings,
+								type,
+								parser: this.getParser(type, settings.parser),
+								parserOptions: settings.parser,
+								generator: this.getGenerator(type, settings.generator),
+								generatorOptions: settings.generator,
+								resolveOptions
+							});
+						} catch (e) {
+							return callback(e);
+						}
+						callback();
+					});
+					this.resolveRequestArray(
+						contextInfo,
+						this.context,
+						useLoadersPost,
+						loaderResolver,
+						resolveContext,
+						(err, result) => {
+							postLoaders = result;
+							continueCallback(err);
+						}
+					);
+					this.resolveRequestArray(
+						contextInfo,
+						this.context,
+						useLoaders,
+						loaderResolver,
+						resolveContext,
+						(err, result) => {
+							normalLoaders = result;
+							continueCallback(err);
+						}
+					);
+					this.resolveRequestArray(
+						contextInfo,
+						this.context,
+						useLoadersPre,
+						loaderResolver,
+						resolveContext,
+						(err, result) => {
+							preLoaders = result;
+							continueCallback(err);
+						}
+					);
+				});
 
-	serialize({ write }) {
-		write(this.result);
-		write(this.snapshot);
-	}
+				this.resolveRequestArray(
+					contextInfo,
+					contextScheme ? this.context : context,
+					elements,
+					loaderResolver,
+					resolveContext,
+					(err, result) => {
+						if (err) return continueCallback(err);
+						loaders = result;
+						continueCallback();
+					}
+				);
 
-	deserialize({ read }) {
-		this.result = read();
-		this.snapshot = read();
-	}
-}
+				const defaultResolve = context => {
+					if (/^($|\?)/.test(unresolvedResource)) {
+						resourceData = {
+							resource: unresolvedResource,
+							data: {},
+							...cacheParseResource(unresolvedResource)
+						};
+						continueCallback();
+					}
 
-makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin");
+					// resource without scheme and with path
+					else {
+						const normalResolver = this.getResolver(
+							"normal",
+							dependencyType
+								? cachedSetProperty(
+										resolveOptions || EMPTY_RESOLVE_OPTIONS,
+										"dependencyType",
+										dependencyType
+								  )
+								: resolveOptions
+						);
+						this.resolveResource(
+							contextInfo,
+							context,
+							unresolvedResource,
+							normalResolver,
+							resolveContext,
+							(err, resolvedResource, resolvedResourceResolveData) => {
+								if (err) return continueCallback(err);
+								if (resolvedResource !== false) {
+									resourceData = {
+										resource: resolvedResource,
+										data: resolvedResourceResolveData,
+										...cacheParseResource(resolvedResource)
+									};
+								}
+								continueCallback();
+							}
+						);
+					}
+				};
 
-/**
- * @template T
- * @param {Set<T> | LazySet<T>} set set to add items to
- * @param {Set<T> | LazySet<T>} otherSet set to add items from
- * @returns {void}
- */
-const addAllToSet = (set, otherSet) => {
-	if (set instanceof LazySet) {
-		set.addAll(otherSet);
-	} else {
-		for (const item of otherSet) {
-			set.add(item);
-		}
+				// resource with scheme
+				if (scheme) {
+					resourceData = {
+						resource: unresolvedResource,
+						data: {},
+						path: undefined,
+						query: undefined,
+						fragment: undefined,
+						context: undefined
+					};
+					this.hooks.resolveForScheme
+						.for(scheme)
+						.callAsync(resourceData, data, err => {
+							if (err) return continueCallback(err);
+							continueCallback();
+						});
+				}
+
+				// resource within scheme
+				else if (contextScheme) {
+					resourceData = {
+						resource: unresolvedResource,
+						data: {},
+						path: undefined,
+						query: undefined,
+						fragment: undefined,
+						context: undefined
+					};
+					this.hooks.resolveInScheme
+						.for(contextScheme)
+						.callAsync(resourceData, data, (err, handled) => {
+							if (err) return continueCallback(err);
+							if (!handled) return defaultResolve(this.context);
+							continueCallback();
+						});
+				}
+
+				// resource without scheme and without path
+				else defaultResolve(context);
+			}
+		);
 	}
-};
 
-/**
- * @param {Object} object an object
- * @param {boolean} excludeContext if true, context is not included in string
- * @returns {string} stringified version
- */
-const objectToString = (object, excludeContext) => {
-	let str = "";
-	for (const key in object) {
-		if (excludeContext && key === "context") continue;
-		const value = object[key];
-		if (typeof value === "object" && value !== null) {
-			str += `|${key}=[${objectToString(value, false)}|]`;
-		} else {
-			str += `|${key}=|${value}`;
+	cleanupForCache() {
+		for (const module of this._restoredUnsafeCacheEntries) {
+			ChunkGraph.clearChunkGraphForModule(module);
+			ModuleGraph.clearModuleGraphForModule(module);
+			module.cleanupForCache();
 		}
 	}
-	return str;
-};
 
-class ResolverCachePlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const cache = compiler.getCache("ResolverCachePlugin");
-		/** @type {FileSystemInfo} */
-		let fileSystemInfo;
-		let snapshotOptions;
-		let realResolves = 0;
-		let cachedResolves = 0;
-		let cacheInvalidResolves = 0;
-		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
-			snapshotOptions = compilation.options.snapshot.resolve;
-			fileSystemInfo = compilation.fileSystemInfo;
-			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
-				if (realResolves + cachedResolves > 0) {
-					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
-					logger.log(
-						`${Math.round(
-							(100 * realResolves) / (realResolves + cachedResolves)
-						)}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)`
-					);
-					realResolves = 0;
-					cachedResolves = 0;
-					cacheInvalidResolves = 0;
-					concurrentResolves = 0;
+	create(data, callback) {
+		const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies);
+		const context = data.context || this.context;
+		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
+		const dependency = dependencies[0];
+		const request = dependency.request;
+		const assertions = dependency.assertions;
+		const contextInfo = data.contextInfo;
+		const fileDependencies = new LazySet();
+		const missingDependencies = new LazySet();
+		const contextDependencies = new LazySet();
+		const dependencyType =
+			(dependencies.length > 0 && dependencies[0].category) || "";
+		/** @type {ResolveData} */
+		const resolveData = {
+			contextInfo,
+			resolveOptions,
+			context,
+			request,
+			assertions,
+			dependencies,
+			dependencyType,
+			fileDependencies,
+			missingDependencies,
+			contextDependencies,
+			createData: {},
+			cacheable: true
+		};
+		this.hooks.beforeResolve.callAsync(resolveData, (err, result) => {
+			if (err) {
+				return callback(err, {
+					fileDependencies,
+					missingDependencies,
+					contextDependencies,
+					cacheable: false
+				});
+			}
+
+			// Ignored
+			if (result === false) {
+				return callback(null, {
+					fileDependencies,
+					missingDependencies,
+					contextDependencies,
+					cacheable: resolveData.cacheable
+				});
+			}
+
+			if (typeof result === "object")
+				throw new Error(
+					deprecationChangedHookMessage(
+						"beforeResolve",
+						this.hooks.beforeResolve
+					)
+				);
+
+			this.hooks.factorize.callAsync(resolveData, (err, module) => {
+				if (err) {
+					return callback(err, {
+						fileDependencies,
+						missingDependencies,
+						contextDependencies,
+						cacheable: false
+					});
 				}
+
+				const factoryResult = {
+					module,
+					fileDependencies,
+					missingDependencies,
+					contextDependencies,
+					cacheable: resolveData.cacheable
+				};
+
+				callback(null, factoryResult);
 			});
 		});
-		/**
-		 * @param {ItemCacheFacade} itemCache cache
-		 * @param {Resolver} resolver the resolver
-		 * @param {Object} resolveContext context for resolving meta info
-		 * @param {Object} request the request info object
-		 * @param {function((Error | null)=, Object=): void} callback callback function
-		 * @returns {void}
-		 */
-		const doRealResolve = (
-			itemCache,
-			resolver,
+	}
+
+	resolveResource(
+		contextInfo,
+		context,
+		unresolvedResource,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		resolver.resolve(
+			contextInfo,
+			context,
+			unresolvedResource,
 			resolveContext,
-			request,
-			callback
-		) => {
-			realResolves++;
-			const newRequest = {
-				_ResolverCachePluginCacheMiss: true,
-				...request
-			};
-			const newResolveContext = {
-				...resolveContext,
-				stack: new Set(),
-				missingDependencies: new LazySet(),
-				fileDependencies: new LazySet(),
-				contextDependencies: new LazySet()
-			};
-			const propagate = key => {
-				if (resolveContext[key]) {
-					addAllToSet(resolveContext[key], newResolveContext[key]);
-				}
-			};
-			const resolveTime = Date.now();
-			resolver.doResolve(
-				resolver.hooks.resolve,
-				newRequest,
-				"Cache miss",
-				newResolveContext,
-				(err, result) => {
-					propagate("fileDependencies");
-					propagate("contextDependencies");
-					propagate("missingDependencies");
-					if (err) return callback(err);
-					const fileDependencies = newResolveContext.fileDependencies;
-					const contextDependencies = newResolveContext.contextDependencies;
-					const missingDependencies = newResolveContext.missingDependencies;
-					fileSystemInfo.createSnapshot(
-						resolveTime,
-						fileDependencies,
-						contextDependencies,
-						missingDependencies,
-						snapshotOptions,
-						(err, snapshot) => {
-							if (err) return callback(err);
-							if (!snapshot) {
-								if (result) return callback(null, result);
-								return callback();
+			(err, resolvedResource, resolvedResourceResolveData) => {
+				if (err) {
+					return this._resolveResourceErrorHints(
+						err,
+						contextInfo,
+						context,
+						unresolvedResource,
+						resolver,
+						resolveContext,
+						(err2, hints) => {
+							if (err2) {
+								err.message += `
+An fatal error happened during resolving additional hints for this error: ${err2.message}`;
+								err.stack += `
+
+An fatal error happened during resolving additional hints for this error:
+${err2.stack}`;
+								return callback(err);
 							}
-							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
-								if (storeErr) return callback(storeErr);
-								if (result) return callback(null, result);
-								callback();
-							});
+							if (hints && hints.length > 0) {
+								err.message += `
+${hints.join("\n\n")}`;
+							}
+							callback(err);
 						}
 					);
 				}
-			);
-		};
-		compiler.resolverFactory.hooks.resolver.intercept({
-			factory(type, hook) {
-				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
-				const activeRequests = new Map();
-				hook.tap(
-					"ResolverCachePlugin",
-					/**
-					 * @param {Resolver} resolver the resolver
-					 * @param {Object} options resolve options
-					 * @param {Object} userOptions resolve options passed by the user
-					 * @returns {void}
-					 */
-					(resolver, options, userOptions) => {
-						if (options.cache !== true) return;
-						const optionsIdent = objectToString(userOptions, false);
-						const cacheWithContext =
-							options.cacheWithContext !== undefined
-								? options.cacheWithContext
-								: false;
-						resolver.hooks.resolve.tapAsync(
-							{
-								name: "ResolverCachePlugin",
-								stage: -100
-							},
-							(request, resolveContext, callback) => {
-								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
-									return callback();
-								}
-								const identifier = `${type}${optionsIdent}${objectToString(
-									request,
-									!cacheWithContext
-								)}`;
-								const activeRequest = activeRequests.get(identifier);
-								if (activeRequest) {
-									activeRequest.push(callback);
-									return;
-								}
-								const itemCache = cache.getItemCache(identifier, null);
-								let callbacks;
-								const done = (err, result) => {
-									if (callbacks === undefined) {
-										callback(err, result);
-										callbacks = false;
-									} else {
-										for (const callback of callbacks) {
-											callback(err, result);
-										}
-										activeRequests.delete(identifier);
-										callbacks = false;
-									}
-								};
-								/**
-								 * @param {Error=} err error if any
-								 * @param {CacheEntry=} cacheEntry cache entry
-								 * @returns {void}
-								 */
-								const processCacheResult = (err, cacheEntry) => {
-									if (err) return done(err);
+				callback(err, resolvedResource, resolvedResourceResolveData);
+			}
+		);
+	}
 
-									if (cacheEntry) {
-										const { snapshot, result } = cacheEntry;
-										fileSystemInfo.checkSnapshotValid(
-											snapshot,
-											(err, valid) => {
-												if (err || !valid) {
-													cacheInvalidResolves++;
-													return doRealResolve(
-														itemCache,
-														resolver,
-														resolveContext,
-														request,
-														done
-													);
-												}
-												cachedResolves++;
-												if (resolveContext.missingDependencies) {
-													addAllToSet(
-														resolveContext.missingDependencies,
-														snapshot.getMissingIterable()
-													);
-												}
-												if (resolveContext.fileDependencies) {
-													addAllToSet(
-														resolveContext.fileDependencies,
-														snapshot.getFileIterable()
-													);
-												}
-												if (resolveContext.contextDependencies) {
-													addAllToSet(
-														resolveContext.contextDependencies,
-														snapshot.getContextIterable()
-													);
-												}
-												done(null, result);
-											}
+	_resolveResourceErrorHints(
+		error,
+		contextInfo,
+		context,
+		unresolvedResource,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		asyncLib.parallel(
+			[
+				callback => {
+					if (!resolver.options.fullySpecified) return callback();
+					resolver
+						.withOptions({
+							fullySpecified: false
+						})
+						.resolve(
+							contextInfo,
+							context,
+							unresolvedResource,
+							resolveContext,
+							(err, resolvedResource) => {
+								if (!err && resolvedResource) {
+									const resource = parseResource(resolvedResource).path.replace(
+										/^.*[\\/]/,
+										""
+									);
+									return callback(
+										null,
+										`Did you mean '${resource}'?
+BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified
+(probably because the origin is strict EcmaScript Module, e. g. a module with javascript mimetype, a '*.mjs' file, or a '*.js' file where the package.json contains '"type": "module"').
+The extension in the request is mandatory for it to be fully specified.
+Add the extension to the request.`
+									);
+								}
+								callback();
+							}
+						);
+				},
+				callback => {
+					if (!resolver.options.enforceExtension) return callback();
+					resolver
+						.withOptions({
+							enforceExtension: false,
+							extensions: []
+						})
+						.resolve(
+							contextInfo,
+							context,
+							unresolvedResource,
+							resolveContext,
+							(err, resolvedResource) => {
+								if (!err && resolvedResource) {
+									let hint = "";
+									const match = /(\.[^.]+)(\?|$)/.exec(unresolvedResource);
+									if (match) {
+										const fixedRequest = unresolvedResource.replace(
+											/(\.[^.]+)(\?|$)/,
+											"$2"
 										);
+										if (resolver.options.extensions.has(match[1])) {
+											hint = `Did you mean '${fixedRequest}'?`;
+										} else {
+											hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
+										}
 									} else {
-										doRealResolve(
-											itemCache,
-											resolver,
-											resolveContext,
-											request,
-											done
-										);
+										hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
 									}
-								};
-								itemCache.get(processCacheResult);
-								if (callbacks === undefined) {
-									callbacks = [callback];
-									activeRequests.set(identifier, callbacks);
+									return callback(
+										null,
+										`The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified.
+${hint}
+Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?`
+									);
 								}
+								callback();
 							}
 						);
+				},
+				callback => {
+					if (
+						/^\.\.?\//.test(unresolvedResource) ||
+						resolver.options.preferRelative
+					) {
+						return callback();
 					}
-				);
-				return hook;
+					resolver.resolve(
+						contextInfo,
+						context,
+						`./${unresolvedResource}`,
+						resolveContext,
+						(err, resolvedResource) => {
+							if (err || !resolvedResource) return callback();
+							const moduleDirectories = resolver.options.modules
+								.map(m => (Array.isArray(m) ? m.join(", ") : m))
+								.join(", ");
+							callback(
+								null,
+								`Did you mean './${unresolvedResource}'?
+Requests that should resolve in the current directory need to start with './'.
+Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}).
+If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.`
+							);
+						}
+					);
+				}
+			],
+			(err, hints) => {
+				if (err) return callback(err);
+				callback(null, hints.filter(Boolean));
 			}
-		});
+		);
 	}
-}
-
-module.exports = ResolverCachePlugin;
-
-
-/***/ }),
 
-/***/ 94075:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	resolveRequestArray(
+		contextInfo,
+		context,
+		array,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		if (array.length === 0) return callback(null, array);
+		asyncLib.map(
+			array,
+			(item, callback) => {
+				resolver.resolve(
+					contextInfo,
+					context,
+					item.loader,
+					resolveContext,
+					(err, result) => {
+						if (
+							err &&
+							/^[^/]*$/.test(item.loader) &&
+							!/-loader$/.test(item.loader)
+						) {
+							return resolver.resolve(
+								contextInfo,
+								context,
+								item.loader + "-loader",
+								resolveContext,
+								err2 => {
+									if (!err2) {
+										err.message =
+											err.message +
+											"\n" +
+											"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
+											`                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
+											"                 see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed";
+									}
+									callback(err);
+								}
+							);
+						}
+						if (err) return callback(err);
 
+						const parsedResult = identToLoaderRequest(result);
+						const resolved = {
+							loader: parsedResult.loader,
+							options:
+								item.options === undefined
+									? parsedResult.options
+									: item.options,
+							ident: item.options === undefined ? undefined : item.ident
+						};
+						return callback(null, resolved);
+					}
+				);
+			},
+			callback
+		);
+	}
 
+	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
+		let cache = this.parserCache.get(type);
 
-const createHash = __webpack_require__(49835);
+		if (cache === undefined) {
+			cache = new WeakMap();
+			this.parserCache.set(type, cache);
+		}
 
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {typeof import("../util/Hash")} HashConstructor */
+		let parser = cache.get(parserOptions);
 
-/**
- * @typedef {Object} HashableObject
- * @property {function(Hash): void} updateHash
- */
+		if (parser === undefined) {
+			parser = this.createParser(type, parserOptions);
+			cache.set(parserOptions, parser);
+		}
 
-class LazyHashedEtag {
-	/**
-	 * @param {HashableObject} obj object with updateHash method
-	 * @param {string | HashConstructor} hashFunction the hash function to use
-	 */
-	constructor(obj, hashFunction = "md4") {
-		this._obj = obj;
-		this._hash = undefined;
-		this._hashFunction = hashFunction;
+		return parser;
 	}
 
 	/**
-	 * @returns {string} hash of object
+	 * @param {string} type type
+	 * @param {{[k: string]: any}} parserOptions parser options
+	 * @returns {Parser} parser
 	 */
-	toString() {
-		if (this._hash === undefined) {
-			const hash = createHash(this._hashFunction);
-			this._obj.updateHash(hash);
-			this._hash = /** @type {string} */ (hash.digest("base64"));
+	createParser(type, parserOptions = {}) {
+		parserOptions = mergeGlobalOptions(
+			this._globalParserOptions,
+			type,
+			parserOptions
+		);
+		const parser = this.hooks.createParser.for(type).call(parserOptions);
+		if (!parser) {
+			throw new Error(`No parser registered for ${type}`);
 		}
-		return this._hash;
+		this.hooks.parser.for(type).call(parser, parserOptions);
+		return parser;
 	}
-}
 
-/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
-const mapStrings = new Map();
+	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
+		let cache = this.generatorCache.get(type);
 
-/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
-const mapObjects = new WeakMap();
+		if (cache === undefined) {
+			cache = new WeakMap();
+			this.generatorCache.set(type, cache);
+		}
 
-/**
- * @param {HashableObject} obj object with updateHash method
- * @param {string | HashConstructor} hashFunction the hash function to use
- * @returns {LazyHashedEtag} etag
- */
-const getter = (obj, hashFunction = "md4") => {
-	let innerMap;
-	if (typeof hashFunction === "string") {
-		innerMap = mapStrings.get(hashFunction);
-		if (innerMap === undefined) {
-			const newHash = new LazyHashedEtag(obj, hashFunction);
-			innerMap = new WeakMap();
-			innerMap.set(obj, newHash);
-			mapStrings.set(hashFunction, innerMap);
-			return newHash;
+		let generator = cache.get(generatorOptions);
+
+		if (generator === undefined) {
+			generator = this.createGenerator(type, generatorOptions);
+			cache.set(generatorOptions, generator);
 		}
-	} else {
-		innerMap = mapObjects.get(hashFunction);
-		if (innerMap === undefined) {
-			const newHash = new LazyHashedEtag(obj, hashFunction);
-			innerMap = new WeakMap();
-			innerMap.set(obj, newHash);
-			mapObjects.set(hashFunction, innerMap);
-			return newHash;
+
+		return generator;
+	}
+
+	createGenerator(type, generatorOptions = {}) {
+		generatorOptions = mergeGlobalOptions(
+			this._globalGeneratorOptions,
+			type,
+			generatorOptions
+		);
+		const generator = this.hooks.createGenerator
+			.for(type)
+			.call(generatorOptions);
+		if (!generator) {
+			throw new Error(`No generator registered for ${type}`);
 		}
+		this.hooks.generator.for(type).call(generator, generatorOptions);
+		return generator;
 	}
-	const hash = innerMap.get(obj);
-	if (hash !== undefined) return hash;
-	const newHash = new LazyHashedEtag(obj, hashFunction);
-	innerMap.set(obj, newHash);
-	return newHash;
-};
 
-module.exports = getter;
+	getResolver(type, resolveOptions) {
+		return this.resolverFactory.get(type, resolveOptions);
+	}
+}
+
+module.exports = NormalModuleFactory;
 
 
 /***/ }),
 
-/***/ 54980:
-/***/ (function(module) {
+/***/ 30633:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -62957,1085 +58193,817 @@ module.exports = getter;
 
 
 
-/** @typedef {import("../Cache").Etag} Etag */
+const { join, dirname } = __webpack_require__(17139);
 
-class MergedEtag {
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {function(TODO): void} ModuleReplacer */
+
+class NormalModuleReplacementPlugin {
 	/**
-	 * @param {Etag} a first
-	 * @param {Etag} b second
+	 * Create an instance of the plugin
+	 * @param {RegExp} resourceRegExp the resource matcher
+	 * @param {string|ModuleReplacer} newResource the resource replacement
 	 */
-	constructor(a, b) {
-		this.a = a;
-		this.b = b;
-	}
-
-	toString() {
-		return `${this.a.toString()}|${this.b.toString()}`;
+	constructor(resourceRegExp, newResource) {
+		this.resourceRegExp = resourceRegExp;
+		this.newResource = newResource;
 	}
-}
-
-const dualObjectMap = new WeakMap();
-const objectStringMap = new WeakMap();
 
-/**
- * @param {Etag} a first
- * @param {Etag} b second
- * @returns {Etag} result
- */
-const mergeEtags = (a, b) => {
-	if (typeof a === "string") {
-		if (typeof b === "string") {
-			return `${a}|${b}`;
-		} else {
-			const temp = b;
-			b = a;
-			a = temp;
-		}
-	} else {
-		if (typeof b !== "string") {
-			// both a and b are objects
-			let map = dualObjectMap.get(a);
-			if (map === undefined) {
-				dualObjectMap.set(a, (map = new WeakMap()));
-			}
-			const mergedEtag = map.get(b);
-			if (mergedEtag === undefined) {
-				const newMergedEtag = new MergedEtag(a, b);
-				map.set(b, newMergedEtag);
-				return newMergedEtag;
-			} else {
-				return mergedEtag;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const resourceRegExp = this.resourceRegExp;
+		const newResource = this.newResource;
+		compiler.hooks.normalModuleFactory.tap(
+			"NormalModuleReplacementPlugin",
+			nmf => {
+				nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", result => {
+					if (resourceRegExp.test(result.request)) {
+						if (typeof newResource === "function") {
+							newResource(result);
+						} else {
+							result.request = newResource;
+						}
+					}
+				});
+				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
+					const createData = result.createData;
+					if (resourceRegExp.test(createData.resource)) {
+						if (typeof newResource === "function") {
+							newResource(result);
+						} else {
+							const fs = compiler.inputFileSystem;
+							if (
+								newResource.startsWith("/") ||
+								(newResource.length > 1 && newResource[1] === ":")
+							) {
+								createData.resource = newResource;
+							} else {
+								createData.resource = join(
+									fs,
+									dirname(fs, createData.resource),
+									newResource
+								);
+							}
+						}
+					}
+				});
 			}
-		}
-	}
-	// a is object, b is string
-	let map = objectStringMap.get(a);
-	if (map === undefined) {
-		objectStringMap.set(a, (map = new Map()));
-	}
-	const mergedEtag = map.get(b);
-	if (mergedEtag === undefined) {
-		const newMergedEtag = new MergedEtag(a, b);
-		map.set(b, newMergedEtag);
-		return newMergedEtag;
-	} else {
-		return mergedEtag;
+		);
 	}
-};
+}
 
-module.exports = mergeEtags;
+module.exports = NormalModuleReplacementPlugin;
 
 
 /***/ }),
 
-/***/ 13462:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 80057:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const path = __webpack_require__(71017);
-const webpackSchema = __webpack_require__(73342);
-
-// TODO add originPath to PathItem for better errors
-/**
- * @typedef {Object} PathItem
- * @property {any} schema the part of the schema
- * @property {string} path the path in the config
- */
-
-/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
+exports.STAGE_BASIC = -10;
+exports.STAGE_DEFAULT = 0;
+exports.STAGE_ADVANCED = 10;
 
-/**
- * @typedef {Object} Problem
- * @property {ProblemType} type
- * @property {string} path
- * @property {string} argument
- * @property {any=} value
- * @property {number=} index
- * @property {string=} expected
- */
 
-/**
- * @typedef {Object} LocalProblem
- * @property {ProblemType} type
- * @property {string} path
- * @property {string=} expected
- */
+/***/ }),
 
-/**
- * @typedef {Object} ArgumentConfig
- * @property {string} description
- * @property {string} [negatedDescription]
- * @property {string} path
- * @property {boolean} multiple
- * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
- * @property {any[]=} values
- */
+/***/ 81426:
+/***/ (function(module) {
 
-/**
- * @typedef {Object} Argument
- * @property {string} description
- * @property {"string"|"number"|"boolean"} simpleType
- * @property {boolean} multiple
- * @property {ArgumentConfig[]} configs
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @param {any=} schema a json schema to create arguments for (by default webpack schema is used)
- * @returns {Record<string, Argument>} object of arguments
- */
-const getArguments = (schema = webpackSchema) => {
-	/** @type {Record<string, Argument>} */
-	const flags = {};
 
-	const pathToArgumentName = input => {
-		return input
-			.replace(/\./g, "-")
-			.replace(/\[\]/g, "")
-			.replace(
-				/(\p{Uppercase_Letter}+|\p{Lowercase_Letter}|\d)(\p{Uppercase_Letter}+)/gu,
-				"$1-$2"
-			)
-			.replace(/-?[^\p{Uppercase_Letter}\p{Lowercase_Letter}\d]+/gu, "-")
-			.toLowerCase();
-	};
 
-	const getSchemaPart = path => {
-		const newPath = path.split("/");
+class OptionsApply {
+	process(options, compiler) {}
+}
+module.exports = OptionsApply;
 
-		let schemaPart = schema;
 
-		for (let i = 1; i < newPath.length; i++) {
-			const inner = schemaPart[newPath[i]];
+/***/ }),
 
-			if (!inner) {
-				break;
-			}
+/***/ 11715:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			schemaPart = inner;
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		return schemaPart;
-	};
 
-	/**
-	 *
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {string | undefined} description
-	 */
-	const getDescription = path => {
-		for (const { schema } of path) {
-			if (schema.cli) {
-				if (schema.cli.helper) continue;
-				if (schema.cli.description) return schema.cli.description;
-			}
-			if (schema.description) return schema.description;
-		}
-	};
 
-	/**
-	 *
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {string | undefined} negative description
-	 */
-	const getNegatedDescription = path => {
-		for (const { schema } of path) {
-			if (schema.cli) {
-				if (schema.cli.helper) continue;
-				if (schema.cli.negatedDescription) return schema.cli.negatedDescription;
-			}
-		}
-	};
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./NormalModule")} NormalModule */
 
-	/**
-	 *
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {string | undefined} reset description
-	 */
-	const getResetDescription = path => {
-		for (const { schema } of path) {
-			if (schema.cli) {
-				if (schema.cli.helper) continue;
-				if (schema.cli.resetDescription) return schema.cli.resetDescription;
-			}
-		}
-	};
+/** @typedef {Record<string, any>} PreparsedAst */
 
-	/**
-	 *
-	 * @param {any} schemaPart schema
-	 * @returns {Pick<ArgumentConfig, "type"|"values">} partial argument config
-	 */
-	const schemaToArgumentConfig = schemaPart => {
-		if (schemaPart.enum) {
-			return {
-				type: "enum",
-				values: schemaPart.enum
-			};
-		}
-		switch (schemaPart.type) {
-			case "number":
-				return {
-					type: "number"
-				};
-			case "string":
-				return {
-					type: schemaPart.absolutePath ? "path" : "string"
-				};
-			case "boolean":
-				return {
-					type: "boolean"
-				};
-		}
-		if (schemaPart.instanceof === "RegExp") {
-			return {
-				type: "RegExp"
-			};
-		}
-		return undefined;
-	};
+/**
+ * @typedef {Object} ParserStateBase
+ * @property {string | Buffer} source
+ * @property {NormalModule} current
+ * @property {NormalModule} module
+ * @property {Compilation} compilation
+ * @property {{[k: string]: any}} options
+ */
 
-	/**
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {void}
-	 */
-	const addResetFlag = path => {
-		const schemaPath = path[0].path;
-		const name = pathToArgumentName(`${schemaPath}.reset`);
-		const description =
-			getResetDescription(path) ||
-			`Clear all items provided in '${schemaPath}' configuration. ${getDescription(
-				path
-			)}`;
-		flags[name] = {
-			configs: [
-				{
-					type: "reset",
-					multiple: false,
-					description,
-					path: schemaPath
-				}
-			],
-			description: undefined,
-			simpleType: undefined,
-			multiple: undefined
-		};
-	};
+/** @typedef {Record<string, any> & ParserStateBase} ParserState */
 
+class Parser {
+	/* istanbul ignore next */
 	/**
-	 * @param {PathItem[]} path full path in schema
-	 * @param {boolean} multiple inside of an array
-	 * @returns {number} number of arguments added
+	 * @abstract
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
 	 */
-	const addFlag = (path, multiple) => {
-		const argConfigBase = schemaToArgumentConfig(path[0].schema);
-		if (!argConfigBase) return 0;
-
-		const negatedDescription = getNegatedDescription(path);
-		const name = pathToArgumentName(path[0].path);
-		/** @type {ArgumentConfig} */
-		const argConfig = {
-			...argConfigBase,
-			multiple,
-			description: getDescription(path),
-			path: path[0].path
-		};
-
-		if (negatedDescription) {
-			argConfig.negatedDescription = negatedDescription;
-		}
-
-		if (!flags[name]) {
-			flags[name] = {
-				configs: [],
-				description: undefined,
-				simpleType: undefined,
-				multiple: undefined
-			};
-		}
-
-		if (
-			flags[name].configs.some(
-				item => JSON.stringify(item) === JSON.stringify(argConfig)
-			)
-		) {
-			return 0;
-		}
-
-		if (
-			flags[name].configs.some(
-				item => item.type === argConfig.type && item.multiple !== multiple
-			)
-		) {
-			if (multiple) {
-				throw new Error(
-					`Conflicting schema for ${path[0].path} with ${argConfig.type} type (array type must be before single item type)`
-				);
-			}
-			return 0;
-		}
+	parse(source, state) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+}
 
-		flags[name].configs.push(argConfig);
+module.exports = Parser;
 
-		return 1;
-	};
 
-	// TODO support `not` and `if/then/else`
-	// TODO support `const`, but we don't use it on our schema
-	/**
-	 *
-	 * @param {object} schemaPart the current schema
-	 * @param {string} schemaPath the current path in the schema
-	 * @param {{schema: object, path: string}[]} path all previous visited schemaParts
-	 * @param {string | null} inArray if inside of an array, the path to the array
-	 * @returns {number} added arguments
-	 */
-	const traverse = (schemaPart, schemaPath = "", path = [], inArray = null) => {
-		while (schemaPart.$ref) {
-			schemaPart = getSchemaPart(schemaPart.$ref);
-		}
+/***/ }),
 
-		const repetitions = path.filter(({ schema }) => schema === schemaPart);
-		if (
-			repetitions.length >= 2 ||
-			repetitions.some(({ path }) => path === schemaPath)
-		) {
-			return 0;
-		}
+/***/ 73850:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
 
-		let addedArguments = 0;
 
-		addedArguments += addFlag(fullPath, !!inArray);
+const PrefetchDependency = __webpack_require__(31618);
 
-		if (schemaPart.type === "object") {
-			if (schemaPart.properties) {
-				for (const property of Object.keys(schemaPart.properties)) {
-					addedArguments += traverse(
-						schemaPart.properties[property],
-						schemaPath ? `${schemaPath}.${property}` : property,
-						fullPath,
-						inArray
-					);
-				}
-			}
+/** @typedef {import("./Compiler")} Compiler */
 
-			return addedArguments;
+class PrefetchPlugin {
+	constructor(context, request) {
+		if (request) {
+			this.context = context;
+			this.request = request;
+		} else {
+			this.context = null;
+			this.request = context;
 		}
+	}
 
-		if (schemaPart.type === "array") {
-			if (inArray) {
-				return 0;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"PrefetchPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					PrefetchDependency,
+					normalModuleFactory
+				);
 			}
-			if (Array.isArray(schemaPart.items)) {
-				let i = 0;
-				for (const item of schemaPart.items) {
-					addedArguments += traverse(
-						item,
-						`${schemaPath}.${i}`,
-						fullPath,
-						schemaPath
-					);
+		);
+		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
+			compilation.addModuleChain(
+				this.context || compiler.context,
+				new PrefetchDependency(this.request),
+				err => {
+					callback(err);
 				}
-
-				return addedArguments;
-			}
-
-			addedArguments += traverse(
-				schemaPart.items,
-				`${schemaPath}[]`,
-				fullPath,
-				schemaPath
 			);
+		});
+	}
+}
 
-			if (addedArguments > 0) {
-				addResetFlag(fullPath);
-				addedArguments++;
-			}
+module.exports = PrefetchPlugin;
 
-			return addedArguments;
-		}
 
-		const maybeOf = schemaPart.oneOf || schemaPart.anyOf || schemaPart.allOf;
+/***/ }),
 
-		if (maybeOf) {
-			const items = maybeOf;
+/***/ 13216:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			for (let i = 0; i < items.length; i++) {
-				addedArguments += traverse(items[i], schemaPath, fullPath, inArray);
-			}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			return addedArguments;
-		}
 
-		return addedArguments;
-	};
 
-	traverse(schema);
+const Compiler = __webpack_require__(70845);
+const MultiCompiler = __webpack_require__(33370);
+const NormalModule = __webpack_require__(39);
+const createSchemaValidation = __webpack_require__(32540);
+const { contextify } = __webpack_require__(82186);
 
-	// Summarize flags
-	for (const name of Object.keys(flags)) {
-		const argument = flags[name];
-		argument.description = argument.configs.reduce((desc, { description }) => {
-			if (!desc) return description;
-			if (!description) return desc;
-			if (desc.includes(description)) return desc;
-			return `${desc} ${description}`;
-		}, /** @type {string | undefined} */ (undefined));
-		argument.simpleType = argument.configs.reduce((t, argConfig) => {
-			/** @type {"string" | "number" | "boolean"} */
-			let type = "string";
-			switch (argConfig.type) {
-				case "number":
-					type = "number";
-					break;
-				case "reset":
-				case "boolean":
-					type = "boolean";
-					break;
-				case "enum":
-					if (argConfig.values.every(v => typeof v === "boolean"))
-						type = "boolean";
-					if (argConfig.values.every(v => typeof v === "number"))
-						type = "number";
-					break;
-			}
-			if (t === undefined) return type;
-			return t === type ? t : "string";
-		}, /** @type {"string" | "number" | "boolean" | undefined} */ (undefined));
-		argument.multiple = argument.configs.some(c => c.multiple);
-	}
+/** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
 
-	return flags;
+const validate = createSchemaValidation(
+	__webpack_require__(57647),
+	() => __webpack_require__(75202),
+	{
+		name: "Progress Plugin",
+		baseDataPath: "options"
+	}
+);
+const median3 = (a, b, c) => {
+	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
 };
 
-const cliAddedItems = new WeakMap();
+const createDefaultHandler = (profile, logger) => {
+	/** @type {{ value: string, time: number }[]} */
+	const lastStateInfo = [];
 
-/**
- * @param {any} config configuration
- * @param {string} schemaPath path in the config
- * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {{ problem?: LocalProblem, object?: any, property?: string | number, value?: any }} problem or object with property and value
- */
-const getObjectAndProperty = (config, schemaPath, index = 0) => {
-	if (!schemaPath) return { value: config };
-	const parts = schemaPath.split(".");
-	let property = parts.pop();
-	let current = config;
-	let i = 0;
-	for (const part of parts) {
-		const isArray = part.endsWith("[]");
-		const name = isArray ? part.slice(0, -2) : part;
-		let value = current[name];
-		if (isArray) {
-			if (value === undefined) {
-				value = {};
-				current[name] = [...Array.from({ length: index }), value];
-				cliAddedItems.set(current[name], index + 1);
-			} else if (!Array.isArray(value)) {
-				return {
-					problem: {
-						type: "unexpected-non-array-in-path",
-						path: parts.slice(0, i).join(".")
-					}
-				};
-			} else {
-				let addedItems = cliAddedItems.get(value) || 0;
-				while (addedItems <= index) {
-					value.push(undefined);
-					addedItems++;
-				}
-				cliAddedItems.set(value, addedItems);
-				const x = value.length - addedItems + index;
-				if (value[x] === undefined) {
-					value[x] = {};
-				} else if (value[x] === null || typeof value[x] !== "object") {
-					return {
-						problem: {
-							type: "unexpected-non-object-in-path",
-							path: parts.slice(0, i).join(".")
+	const defaultHandler = (percentage, msg, ...args) => {
+		if (profile) {
+			if (percentage === 0) {
+				lastStateInfo.length = 0;
+			}
+			const fullState = [msg, ...args];
+			const state = fullState.map(s => s.replace(/\d+\/\d+ /g, ""));
+			const now = Date.now();
+			const len = Math.max(state.length, lastStateInfo.length);
+			for (let i = len; i >= 0; i--) {
+				const stateItem = i < state.length ? state[i] : undefined;
+				const lastStateItem =
+					i < lastStateInfo.length ? lastStateInfo[i] : undefined;
+				if (lastStateItem) {
+					if (stateItem !== lastStateItem.value) {
+						const diff = now - lastStateItem.time;
+						if (lastStateItem.value) {
+							let reportState = lastStateItem.value;
+							if (i > 0) {
+								reportState = lastStateInfo[i - 1].value + " > " + reportState;
+							}
+							const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
+							const d = diff;
+							// This depends on timing so we ignore it for coverage
+							/* istanbul ignore next */
+							{
+								if (d > 10000) {
+									logger.error(stateMsg);
+								} else if (d > 1000) {
+									logger.warn(stateMsg);
+								} else if (d > 10) {
+									logger.info(stateMsg);
+								} else if (d > 5) {
+									logger.log(stateMsg);
+								} else {
+									logger.debug(stateMsg);
+								}
+							}
+						}
+						if (stateItem === undefined) {
+							lastStateInfo.length = i;
+						} else {
+							lastStateItem.value = stateItem;
+							lastStateItem.time = now;
+							lastStateInfo.length = i + 1;
 						}
+					}
+				} else {
+					lastStateInfo[i] = {
+						value: stateItem,
+						time: now
 					};
 				}
-				value = value[x];
-			}
-		} else {
-			if (value === undefined) {
-				value = current[name] = {};
-			} else if (value === null || typeof value !== "object") {
-				return {
-					problem: {
-						type: "unexpected-non-object-in-path",
-						path: parts.slice(0, i).join(".")
-					}
-				};
-			}
-		}
-		current = value;
-		i++;
-	}
-	let value = current[property];
-	if (property.endsWith("[]")) {
-		const name = property.slice(0, -2);
-		const value = current[name];
-		if (value === undefined) {
-			current[name] = [...Array.from({ length: index }), undefined];
-			cliAddedItems.set(current[name], index + 1);
-			return { object: current[name], property: index, value: undefined };
-		} else if (!Array.isArray(value)) {
-			current[name] = [value, ...Array.from({ length: index }), undefined];
-			cliAddedItems.set(current[name], index + 1);
-			return { object: current[name], property: index + 1, value: undefined };
-		} else {
-			let addedItems = cliAddedItems.get(value) || 0;
-			while (addedItems <= index) {
-				value.push(undefined);
-				addedItems++;
 			}
-			cliAddedItems.set(value, addedItems);
-			const x = value.length - addedItems + index;
-			if (value[x] === undefined) {
-				value[x] = {};
-			} else if (value[x] === null || typeof value[x] !== "object") {
-				return {
-					problem: {
-						type: "unexpected-non-object-in-path",
-						path: schemaPath
-					}
-				};
-			}
-			return {
-				object: value,
-				property: x,
-				value: value[x]
-			};
 		}
-	}
-	return { object: current, property, value };
-};
+		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
+		if (percentage === 1 || (!msg && args.length === 0)) logger.status();
+	};
 
-/**
- * @param {any} config configuration
- * @param {string} schemaPath path in the config
- * @param {any} value parsed value
- * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {LocalProblem | null} problem or null for success
- */
-const setValue = (config, schemaPath, value, index) => {
-	const { problem, object, property } = getObjectAndProperty(
-		config,
-		schemaPath,
-		index
-	);
-	if (problem) return problem;
-	object[property] = value;
-	return null;
+	return defaultHandler;
 };
 
 /**
- * @param {ArgumentConfig} argConfig processing instructions
- * @param {any} config configuration
- * @param {any} value the value
- * @param {number | undefined} index the index if multiple values provided
- * @returns {LocalProblem | null} a problem if any
+ * @callback ReportProgress
+ * @param {number} p
+ * @param {...string[]} [args]
+ * @returns {void}
  */
-const processArgumentConfig = (argConfig, config, value, index) => {
-	if (index !== undefined && !argConfig.multiple) {
-		return {
-			type: "multiple-values-unexpected",
-			path: argConfig.path
-		};
+
+/** @type {WeakMap<Compiler,ReportProgress>} */
+const progressReporters = new WeakMap();
+
+class ProgressPlugin {
+	/**
+	 * @param {Compiler} compiler the current compiler
+	 * @returns {ReportProgress} a progress reporter, if any
+	 */
+	static getReporter(compiler) {
+		return progressReporters.get(compiler);
 	}
-	const parsed = parseValueForArgumentConfig(argConfig, value);
-	if (parsed === undefined) {
-		return {
-			type: "invalid-value",
-			path: argConfig.path,
-			expected: getExpectedValue(argConfig)
-		};
+
+	/**
+	 * @param {ProgressPluginArgument} options options
+	 */
+	constructor(options = {}) {
+		if (typeof options === "function") {
+			options = {
+				handler: options
+			};
+		}
+
+		validate(options);
+		options = { ...ProgressPlugin.defaultOptions, ...options };
+
+		this.profile = options.profile;
+		this.handler = options.handler;
+		this.modulesCount = options.modulesCount;
+		this.dependenciesCount = options.dependenciesCount;
+		this.showEntries = options.entries;
+		this.showModules = options.modules;
+		this.showDependencies = options.dependencies;
+		this.showActiveModules = options.activeModules;
+		this.percentBy = options.percentBy;
 	}
-	const problem = setValue(config, argConfig.path, parsed, index);
-	if (problem) return problem;
-	return null;
-};
 
-/**
- * @param {ArgumentConfig} argConfig processing instructions
- * @returns {string | undefined} expected message
- */
-const getExpectedValue = argConfig => {
-	switch (argConfig.type) {
-		default:
-			return argConfig.type;
-		case "boolean":
-			return "true | false";
-		case "RegExp":
-			return "regular expression (example: /ab?c*/)";
-		case "enum":
-			return argConfig.values.map(v => `${v}`).join(" | ");
-		case "reset":
-			return "true (will reset the previous value to an empty array)";
+	/**
+	 * @param {Compiler | MultiCompiler} compiler webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const handler =
+			this.handler ||
+			createDefaultHandler(
+				this.profile,
+				compiler.getInfrastructureLogger("webpack.Progress")
+			);
+		if (compiler instanceof MultiCompiler) {
+			this._applyOnMultiCompiler(compiler, handler);
+		} else if (compiler instanceof Compiler) {
+			this._applyOnCompiler(compiler, handler);
+		}
 	}
-};
 
-/**
- * @param {ArgumentConfig} argConfig processing instructions
- * @param {any} value the value
- * @returns {any | undefined} parsed value
- */
-const parseValueForArgumentConfig = (argConfig, value) => {
-	switch (argConfig.type) {
-		case "string":
-			if (typeof value === "string") {
-				return value;
-			}
-			break;
-		case "path":
-			if (typeof value === "string") {
-				return path.resolve(value);
-			}
-			break;
-		case "number":
-			if (typeof value === "number") return value;
-			if (typeof value === "string" && /^[+-]?\d*(\.\d*)[eE]\d+$/) {
-				const n = +value;
-				if (!isNaN(n)) return n;
-			}
-			break;
-		case "boolean":
-			if (typeof value === "boolean") return value;
-			if (value === "true") return true;
-			if (value === "false") return false;
-			break;
-		case "RegExp":
-			if (value instanceof RegExp) return value;
-			if (typeof value === "string") {
-				// cspell:word yugi
-				const match = /^\/(.*)\/([yugi]*)$/.exec(value);
-				if (match && !/[^\\]\//.test(match[1]))
-					return new RegExp(match[1], match[2]);
-			}
-			break;
-		case "enum":
-			if (argConfig.values.includes(value)) return value;
-			for (const item of argConfig.values) {
-				if (`${item}` === value) return item;
-			}
-			break;
-		case "reset":
-			if (value === true) return [];
-			break;
+	/**
+	 * @param {MultiCompiler} compiler webpack multi-compiler
+	 * @param {HandlerFunction} handler function that executes for every progress step
+	 * @returns {void}
+	 */
+	_applyOnMultiCompiler(compiler, handler) {
+		const states = compiler.compilers.map(
+			() => /** @type {[number, ...string[]]} */ ([0])
+		);
+		compiler.compilers.forEach((compiler, idx) => {
+			new ProgressPlugin((p, msg, ...args) => {
+				states[idx] = [p, msg, ...args];
+				let sum = 0;
+				for (const [p] of states) sum += p;
+				handler(sum / states.length, `[${idx}] ${msg}`, ...args);
+			}).apply(compiler);
+		});
 	}
-};
 
-/**
- * @param {Record<string, Argument>} args object of arguments
- * @param {any} config configuration
- * @param {Record<string, string | number | boolean | RegExp | (string | number | boolean | RegExp)[]>} values object with values
- * @returns {Problem[] | null} problems or null for success
- */
-const processArguments = (args, config, values) => {
-	/** @type {Problem[]} */
-	const problems = [];
-	for (const key of Object.keys(values)) {
-		const arg = args[key];
-		if (!arg) {
-			problems.push({
-				type: "unknown-argument",
-				path: "",
-				argument: key
-			});
-			continue;
-		}
-		const processValue = (value, i) => {
-			const currentProblems = [];
-			for (const argConfig of arg.configs) {
-				const problem = processArgumentConfig(argConfig, config, value, i);
-				if (!problem) {
-					return;
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @param {HandlerFunction} handler function that executes for every progress step
+	 * @returns {void}
+	 */
+	_applyOnCompiler(compiler, handler) {
+		const showEntries = this.showEntries;
+		const showModules = this.showModules;
+		const showDependencies = this.showDependencies;
+		const showActiveModules = this.showActiveModules;
+		let lastActiveModule = "";
+		let currentLoader = "";
+		let lastModulesCount = 0;
+		let lastDependenciesCount = 0;
+		let lastEntriesCount = 0;
+		let modulesCount = 0;
+		let dependenciesCount = 0;
+		let entriesCount = 1;
+		let doneModules = 0;
+		let doneDependencies = 0;
+		let doneEntries = 0;
+		const activeModules = new Set();
+		let lastUpdate = 0;
+
+		const updateThrottled = () => {
+			if (lastUpdate + 500 < Date.now()) update();
+		};
+
+		const update = () => {
+			/** @type {string[]} */
+			const items = [];
+			const percentByModules =
+				doneModules /
+				Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);
+			const percentByEntries =
+				doneEntries /
+				Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);
+			const percentByDependencies =
+				doneDependencies /
+				Math.max(lastDependenciesCount || 1, dependenciesCount);
+			let percentageFactor;
+
+			switch (this.percentBy) {
+				case "entries":
+					percentageFactor = percentByEntries;
+					break;
+				case "dependencies":
+					percentageFactor = percentByDependencies;
+					break;
+				case "modules":
+					percentageFactor = percentByModules;
+					break;
+				default:
+					percentageFactor = median3(
+						percentByModules,
+						percentByEntries,
+						percentByDependencies
+					);
+			}
+
+			const percentage = 0.1 + percentageFactor * 0.55;
+
+			if (currentLoader) {
+				items.push(
+					`import loader ${contextify(
+						compiler.context,
+						currentLoader,
+						compiler.root
+					)}`
+				);
+			} else {
+				const statItems = [];
+				if (showEntries) {
+					statItems.push(`${doneEntries}/${entriesCount} entries`);
+				}
+				if (showDependencies) {
+					statItems.push(
+						`${doneDependencies}/${dependenciesCount} dependencies`
+					);
+				}
+				if (showModules) {
+					statItems.push(`${doneModules}/${modulesCount} modules`);
+				}
+				if (showActiveModules) {
+					statItems.push(`${activeModules.size} active`);
+				}
+				if (statItems.length > 0) {
+					items.push(statItems.join(" "));
+				}
+				if (showActiveModules) {
+					items.push(lastActiveModule);
 				}
-				currentProblems.push({
-					...problem,
-					argument: key,
-					value: value,
-					index: i
-				});
 			}
-			problems.push(...currentProblems);
+			handler(percentage, "building", ...items);
+			lastUpdate = Date.now();
 		};
-		let value = values[key];
-		if (Array.isArray(value)) {
-			for (let i = 0; i < value.length; i++) {
-				processValue(value[i], i);
-			}
-		} else {
-			processValue(value, undefined);
-		}
-	}
-	if (problems.length === 0) return null;
-	return problems;
-};
-
-exports.getArguments = getArguments;
-exports.processArguments = processArguments;
-
-
-/***/ }),
 
-/***/ 43950:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const factorizeAdd = () => {
+			dependenciesCount++;
+			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
+				updateThrottled();
+		};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
+		const factorizeDone = () => {
+			doneDependencies++;
+			if (doneDependencies < 50 || doneDependencies % 100 === 0)
+				updateThrottled();
+		};
 
+		const moduleAdd = () => {
+			modulesCount++;
+			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
+		};
 
+		// only used when showActiveModules is set
+		const moduleBuild = module => {
+			const ident = module.identifier();
+			if (ident) {
+				activeModules.add(ident);
+				lastActiveModule = ident;
+				update();
+			}
+		};
 
-const browserslist = __webpack_require__(14907);
-const path = __webpack_require__(71017);
+		const entryAdd = (entry, options) => {
+			entriesCount++;
+			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
+		};
 
-/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
-/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
-/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
+		const moduleDone = module => {
+			doneModules++;
+			if (showActiveModules) {
+				const ident = module.identifier();
+				if (ident) {
+					activeModules.delete(ident);
+					if (lastActiveModule === ident) {
+						lastActiveModule = "";
+						for (const m of activeModules) {
+							lastActiveModule = m;
+						}
+						update();
+						return;
+					}
+				}
+			}
+			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
+		};
 
-// [[C:]/path/to/config][:env]
-const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
+		const entryDone = (entry, options) => {
+			doneEntries++;
+			update();
+		};
 
-/**
- * @typedef {Object} BrowserslistHandlerConfig
- * @property {string=} configPath
- * @property {string=} env
- * @property {string=} query
- */
+		const cache = compiler
+			.getCache("ProgressPlugin")
+			.getItemCache("counts", null);
 
-/**
- * @param {string} input input string
- * @param {string} context the context directory
- * @returns {BrowserslistHandlerConfig} config
- */
-const parse = (input, context) => {
-	if (!input) {
-		return {};
-	}
+		let cacheGetPromise;
 
-	if (path.isAbsolute(input)) {
-		const [, configPath, env] = inputRx.exec(input) || [];
-		return { configPath, env };
-	}
+		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
+			if (!cacheGetPromise) {
+				cacheGetPromise = cache.getPromise().then(
+					data => {
+						if (data) {
+							lastModulesCount = lastModulesCount || data.modulesCount;
+							lastDependenciesCount =
+								lastDependenciesCount || data.dependenciesCount;
+						}
+						return data;
+					},
+					err => {
+						// Ignore error
+					}
+				);
+			}
+		});
 
-	const config = browserslist.findConfig(context);
+		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
+			if (compilation.compiler.isChild()) return Promise.resolve();
+			return cacheGetPromise.then(async oldData => {
+				if (
+					!oldData ||
+					oldData.modulesCount !== modulesCount ||
+					oldData.dependenciesCount !== dependenciesCount
+				) {
+					await cache.storePromise({ modulesCount, dependenciesCount });
+				}
+			});
+		});
 
-	if (config && Object.keys(config).includes(input)) {
-		return { env: input };
-	}
+		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
+			if (compilation.compiler.isChild()) return;
+			lastModulesCount = modulesCount;
+			lastEntriesCount = entriesCount;
+			lastDependenciesCount = dependenciesCount;
+			modulesCount = dependenciesCount = entriesCount = 0;
+			doneModules = doneDependencies = doneEntries = 0;
 
-	return { query: input };
-};
+			compilation.factorizeQueue.hooks.added.tap(
+				"ProgressPlugin",
+				factorizeAdd
+			);
+			compilation.factorizeQueue.hooks.result.tap(
+				"ProgressPlugin",
+				factorizeDone
+			);
 
-/**
- * @param {string} input input string
- * @param {string} context the context directory
- * @returns {string[] | undefined} selected browsers
- */
-const load = (input, context) => {
-	const { configPath, env, query } = parse(input, context);
+			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", moduleAdd);
+			compilation.processDependenciesQueue.hooks.result.tap(
+				"ProgressPlugin",
+				moduleDone
+			);
 
-	// if a query is specified, then use it, else
-	// if a path to a config is specified then load it, else
-	// find a nearest config
-	const config = query
-		? query
-		: configPath
-		? browserslist.loadConfig({
-				config: configPath,
-				env
-		  })
-		: browserslist.loadConfig({ path: context, env });
+			if (showActiveModules) {
+				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+			}
 
-	if (!config) return null;
-	return browserslist(config);
-};
+			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
+			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
+			compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
 
-/**
- * @param {string[]} browsers supported browsers list
- * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
- */
-const resolve = browsers => {
-	/**
-	 * Checks all against a version number
-	 * @param {Record<string, number | [number, number]>} versions first supported version
-	 * @returns {boolean} true if supports
-	 */
-	const rawChecker = versions => {
-		return browsers.every(v => {
-			const [name, parsedVersion] = v.split(" ");
-			if (!name) return false;
-			const requiredVersion = versions[name];
-			if (!requiredVersion) return false;
-			const [parsedMajor, parserMinor] =
-				// safari TP supports all features for normal safari
-				parsedVersion === "TP"
-					? [Infinity, Infinity]
-					: parsedVersion.split(".");
-			if (typeof requiredVersion === "number") {
-				return +parsedMajor >= requiredVersion;
-			}
-			return requiredVersion[0] === +parsedMajor
-				? +parserMinor >= requiredVersion[1]
-				: +parsedMajor > requiredVersion[0];
-		});
-	};
-	const anyNode = browsers.some(b => /^node /.test(b));
-	const anyBrowser = browsers.some(b => /^(?!node)/.test(b));
-	const browserProperty = !anyBrowser ? false : anyNode ? null : true;
-	const nodeProperty = !anyNode ? false : anyBrowser ? null : true;
-	// Internet Explorer Mobile, Blackberry browser and Opera Mini are very old browsers, they do not support new features
-	const es6DynamicImport = rawChecker({
-		chrome: 63,
-		and_chr: 63,
-		edge: 79,
-		firefox: 67,
-		and_ff: 67,
-		// ie: Not supported
-		opera: 50,
-		op_mob: 46,
-		safari: [11, 1],
-		ios_saf: [11, 3],
-		samsung: [8, 2],
-		android: 63,
-		and_qq: [10, 4],
-		// baidu: Not supported
-		// and_uc: Not supported
-		// kaios: Not supported
-		// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
-		node: [13, 14]
-	});
+			// avoid dynamic require if bundled with webpack
+			// @ts-expect-error
+			if (false) {}
 
-	return {
-		const: rawChecker({
-			chrome: 49,
-			and_chr: 49,
-			edge: 12,
-			// Prior to Firefox 13, <code>const</code> is implemented, but re-assignment is not failing.
-			// Prior to Firefox 46, a <code>TypeError</code> was thrown on redeclaration instead of a <code>SyntaxError</code>.
-			firefox: 36,
-			and_ff: 36,
-			// Not supported in for-in and for-of loops
-			// ie: Not supported
-			opera: 36,
-			op_mob: 36,
-			safari: [10, 0],
-			ios_saf: [10, 0],
-			// Before 5.0 supported correctly in strict mode, otherwise supported without block scope
-			samsung: [5, 0],
-			android: 37,
-			and_qq: [10, 4],
-			// Supported correctly in strict mode, otherwise supported without block scope
-			// baidu: Not supported
-			and_uc: [12, 12],
-			kaios: [2, 5],
-			node: [6, 0]
-		}),
-		arrowFunction: rawChecker({
-			chrome: 45,
-			and_chr: 45,
-			edge: 12,
-			// The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of <code>'use strict';</code> is now required.
-			// Prior to Firefox 39, a line terminator (<code>\\n</code>) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like <code>() \\n => {}</code> will now throw a <code>SyntaxError</code> in this and later versions.
-			firefox: 39,
-			and_ff: 39,
-			// ie: Not supported,
-			opera: 32,
-			op_mob: 32,
-			safari: 10,
-			ios_saf: 10,
-			samsung: [5, 0],
-			android: 45,
-			and_qq: [10, 4],
-			baidu: [7, 12],
-			and_uc: [12, 12],
-			kaios: [2, 5],
-			node: [6, 0]
-		}),
-		forOf: rawChecker({
-			chrome: 38,
-			and_chr: 38,
-			edge: 12,
-			// Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration").
-			firefox: 51,
-			and_ff: 51,
-			// ie: Not supported,
-			opera: 25,
-			op_mob: 25,
-			safari: 7,
-			ios_saf: 7,
-			samsung: [3, 0],
-			android: 38,
-			// and_qq: Unknown support
-			// baidu: Unknown support
-			// and_uc: Unknown support
-			// kaios: Unknown support
-			node: [0, 12]
-		}),
-		destructuring: rawChecker({
-			chrome: 49,
-			and_chr: 49,
-			edge: 14,
-			firefox: 41,
-			and_ff: 41,
-			// ie: Not supported,
-			opera: 36,
-			op_mob: 36,
-			safari: 8,
-			ios_saf: 8,
-			samsung: [5, 0],
-			android: 49,
-			// and_qq: Unknown support
-			// baidu: Unknown support
-			// and_uc: Unknown support
-			// kaios: Unknown support
-			node: [6, 0]
-		}),
-		bigIntLiteral: rawChecker({
-			chrome: 67,
-			and_chr: 67,
-			edge: 79,
-			firefox: 68,
-			and_ff: 68,
-			// ie: Not supported,
-			opera: 54,
-			op_mob: 48,
-			safari: 14,
-			ios_saf: 14,
-			samsung: [9, 2],
-			android: 67,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
-			node: [10, 4]
-		}),
-		// Support syntax `import` and `export` and no limitations and bugs on Node.js
-		// Not include `export * as namespace`
-		module: rawChecker({
-			chrome: 61,
-			and_chr: 61,
-			edge: 16,
-			firefox: 60,
-			and_ff: 60,
-			// ie: Not supported,
-			opera: 48,
-			op_mob: 45,
-			safari: [10, 1],
-			ios_saf: [10, 3],
-			samsung: [8, 0],
-			android: 61,
-			and_qq: [10, 4],
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
-			// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
-			node: [13, 14]
-		}),
-		dynamicImport: es6DynamicImport,
-		dynamicImportInWorker: es6DynamicImport && !anyNode,
-		// browserslist does not have info about globalThis
-		// so this is based on mdn-browser-compat-data
-		globalThis: rawChecker({
-			chrome: 71,
-			and_chr: 71,
-			edge: 79,
-			firefox: 65,
-			and_ff: 65,
-			// ie: Not supported,
-			opera: 58,
-			op_mob: 50,
-			safari: [12, 1],
-			ios_saf: [12, 2],
-			samsung: [10, 1],
-			android: 71,
-			// and_qq: Unknown support
-			// baidu: Unknown support
-			// and_uc: Unknown support
-			// kaios: Unknown support
-			node: [12, 0]
-		}),
-		optionalChaining: rawChecker({
-			chrome: 80,
-			and_chr: 80,
-			edge: 80,
-			firefox: 74,
-			and_ff: 79,
-			// ie: Not supported,
-			opera: 67,
-			op_mob: 64,
-			safari: [13, 1],
-			ios_saf: [13, 4],
-			samsung: 13,
-			android: 80,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
-			node: 14
-		}),
-		templateLiteral: rawChecker({
-			chrome: 41,
-			and_chr: 41,
-			edge: 13,
-			firefox: 34,
-			and_ff: 34,
-			// ie: Not supported,
-			opera: 29,
-			op_mob: 64,
-			safari: [9, 1],
-			ios_saf: 9,
-			samsung: 4,
-			android: 41,
-			and_qq: [10, 4],
-			baidu: [7, 12],
-			and_uc: [12, 12],
-			kaios: [2, 5],
-			node: 4
-		}),
-		browser: browserProperty,
-		electron: false,
-		node: nodeProperty,
-		nwjs: false,
-		web: browserProperty,
-		webworker: false,
+			const hooks = {
+				finishModules: "finish module graph",
+				seal: "plugins",
+				optimizeDependencies: "dependencies optimization",
+				afterOptimizeDependencies: "after dependencies optimization",
+				beforeChunks: "chunk graph",
+				afterChunks: "after chunk graph",
+				optimize: "optimizing",
+				optimizeModules: "module optimization",
+				afterOptimizeModules: "after module optimization",
+				optimizeChunks: "chunk optimization",
+				afterOptimizeChunks: "after chunk optimization",
+				optimizeTree: "module and chunk tree optimization",
+				afterOptimizeTree: "after module and chunk tree optimization",
+				optimizeChunkModules: "chunk modules optimization",
+				afterOptimizeChunkModules: "after chunk modules optimization",
+				reviveModules: "module reviving",
+				beforeModuleIds: "before module ids",
+				moduleIds: "module ids",
+				optimizeModuleIds: "module id optimization",
+				afterOptimizeModuleIds: "module id optimization",
+				reviveChunks: "chunk reviving",
+				beforeChunkIds: "before chunk ids",
+				chunkIds: "chunk ids",
+				optimizeChunkIds: "chunk id optimization",
+				afterOptimizeChunkIds: "after chunk id optimization",
+				recordModules: "record modules",
+				recordChunks: "record chunks",
+				beforeModuleHash: "module hashing",
+				beforeCodeGeneration: "code generation",
+				beforeRuntimeRequirements: "runtime requirements",
+				beforeHash: "hashing",
+				afterHash: "after hashing",
+				recordHash: "record hash",
+				beforeModuleAssets: "module assets processing",
+				beforeChunkAssets: "chunk assets processing",
+				processAssets: "asset processing",
+				afterProcessAssets: "after asset optimization",
+				record: "recording",
+				afterSeal: "after seal"
+			};
+			const numberOfHooks = Object.keys(hooks).length;
+			Object.keys(hooks).forEach((name, idx) => {
+				const title = hooks[name];
+				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
+				compilation.hooks[name].intercept({
+					name: "ProgressPlugin",
+					call() {
+						handler(percentage, "sealing", title);
+					},
+					done() {
+						progressReporters.set(compiler, undefined);
+						handler(percentage, "sealing", title);
+					},
+					result() {
+						handler(percentage, "sealing", title);
+					},
+					error() {
+						handler(percentage, "sealing", title);
+					},
+					tap(tap) {
+						// p is percentage from 0 to 1
+						// args is any number of messages in a hierarchical matter
+						progressReporters.set(compilation.compiler, (p, ...args) => {
+							handler(percentage, "sealing", title, tap.name, ...args);
+						});
+						handler(percentage, "sealing", title, tap.name);
+					}
+				});
+			});
+		});
+		compiler.hooks.make.intercept({
+			name: "ProgressPlugin",
+			call() {
+				handler(0.1, "building");
+			},
+			done() {
+				handler(0.65, "building");
+			}
+		});
+		const interceptHook = (hook, progress, category, name) => {
+			hook.intercept({
+				name: "ProgressPlugin",
+				call() {
+					handler(progress, category, name);
+				},
+				done() {
+					progressReporters.set(compiler, undefined);
+					handler(progress, category, name);
+				},
+				result() {
+					handler(progress, category, name);
+				},
+				error() {
+					handler(progress, category, name);
+				},
+				tap(tap) {
+					progressReporters.set(compiler, (p, ...args) => {
+						handler(progress, category, name, tap.name, ...args);
+					});
+					handler(progress, category, name, tap.name);
+				}
+			});
+		};
+		compiler.cache.hooks.endIdle.intercept({
+			name: "ProgressPlugin",
+			call() {
+				handler(0, "");
+			}
+		});
+		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
+		compiler.hooks.initialize.intercept({
+			name: "ProgressPlugin",
+			call() {
+				handler(0, "");
+			}
+		});
+		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
+		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
+		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
+		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
+		interceptHook(
+			compiler.hooks.normalModuleFactory,
+			0.04,
+			"setup",
+			"normal module factory"
+		);
+		interceptHook(
+			compiler.hooks.contextModuleFactory,
+			0.05,
+			"setup",
+			"context module factory"
+		);
+		interceptHook(
+			compiler.hooks.beforeCompile,
+			0.06,
+			"setup",
+			"before compile"
+		);
+		interceptHook(compiler.hooks.compile, 0.07, "setup", "compile");
+		interceptHook(compiler.hooks.thisCompilation, 0.08, "setup", "compilation");
+		interceptHook(compiler.hooks.compilation, 0.09, "setup", "compilation");
+		interceptHook(compiler.hooks.finishMake, 0.69, "building", "finish");
+		interceptHook(compiler.hooks.emit, 0.95, "emitting", "emit");
+		interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit");
+		interceptHook(compiler.hooks.done, 0.99, "done", "plugins");
+		compiler.hooks.done.intercept({
+			name: "ProgressPlugin",
+			done() {
+				handler(0.99, "");
+			}
+		});
+		interceptHook(
+			compiler.cache.hooks.storeBuildDependencies,
+			0.99,
+			"cache",
+			"store build dependencies"
+		);
+		interceptHook(compiler.cache.hooks.shutdown, 0.99, "cache", "shutdown");
+		interceptHook(compiler.cache.hooks.beginIdle, 0.99, "cache", "begin idle");
+		interceptHook(
+			compiler.hooks.watchClose,
+			0.99,
+			"end",
+			"closing watch compilation"
+		);
+		compiler.cache.hooks.beginIdle.intercept({
+			name: "ProgressPlugin",
+			done() {
+				handler(1, "");
+			}
+		});
+		compiler.cache.hooks.shutdown.intercept({
+			name: "ProgressPlugin",
+			done() {
+				handler(1, "");
+			}
+		});
+	}
+}
 
-		document: browserProperty,
-		fetchWasm: browserProperty,
-		global: nodeProperty,
-		importScripts: false,
-		importScriptsInWorker: true,
-		nodeBuiltins: nodeProperty,
-		require: nodeProperty
-	};
+ProgressPlugin.defaultOptions = {
+	profile: false,
+	modulesCount: 5000,
+	dependenciesCount: 10000,
+	modules: true,
+	dependencies: true,
+	activeModules: false,
+	entries: true
 };
 
-module.exports = {
-	resolve,
-	load
-};
+module.exports = ProgressPlugin;
 
 
 /***/ }),
 
-/***/ 92988:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 38309:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -64045,1844 +59013,1187 @@ module.exports = {
 
 
 
-const fs = __webpack_require__(57147);
-const path = __webpack_require__(71017);
-const Template = __webpack_require__(1626);
-const { cleverMerge } = __webpack_require__(60839);
-const {
-	getTargetsProperties,
-	getTargetProperties,
-	getDefaultTarget
-} = __webpack_require__(52801);
+const ConstDependency = __webpack_require__(76911);
+const ProvidedDependency = __webpack_require__(95770);
+const { approve } = __webpack_require__(93998);
 
-/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
-/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
-/** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
-/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Library} Library */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
-/** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
-/** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
-/** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
-/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Target} Target */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./target").TargetProperties} TargetProperties */
+/** @typedef {import("./Compiler")} Compiler */
 
-const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
+class ProvidePlugin {
+	/**
+	 * @param {Record<string, string | string[]>} definitions the provided identifiers
+	 */
+	constructor(definitions) {
+		this.definitions = definitions;
+	}
 
-/**
- * Sets a constant default value when undefined
- * @template T
- * @template {keyof T} P
- * @param {T} obj an object
- * @param {P} prop a property of this object
- * @param {T[P]} value a default value of the property
- * @returns {void}
- */
-const D = (obj, prop, value) => {
-	if (obj[prop] === undefined) {
-		obj[prop] = value;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const definitions = this.definitions;
+		compiler.hooks.compilation.tap(
+			"ProvidePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ProvidedDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ProvidedDependency,
+					new ProvidedDependency.Template()
+				);
+				const handler = (parser, parserOptions) => {
+					Object.keys(definitions).forEach(name => {
+						const request = [].concat(definitions[name]);
+						const splittedName = name.split(".");
+						if (splittedName.length > 0) {
+							splittedName.slice(1).forEach((_, i) => {
+								const name = splittedName.slice(0, i + 1).join(".");
+								parser.hooks.canRename.for(name).tap("ProvidePlugin", approve);
+							});
+						}
+
+						parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
+							const nameIdentifier = name.includes(".")
+								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
+								: name;
+							const dep = new ProvidedDependency(
+								request[0],
+								nameIdentifier,
+								request.slice(1),
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+
+						parser.hooks.call.for(name).tap("ProvidePlugin", expr => {
+							const nameIdentifier = name.includes(".")
+								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
+								: name;
+							const dep = new ProvidedDependency(
+								request[0],
+								nameIdentifier,
+								request.slice(1),
+								expr.callee.range
+							);
+							dep.loc = expr.callee.loc;
+							parser.state.module.addDependency(dep);
+							parser.walkExpressions(expr.arguments);
+							return true;
+						});
+					});
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ProvidePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ProvidePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ProvidePlugin", handler);
+			}
+		);
 	}
-};
+}
 
-/**
- * Sets a dynamic default value when undefined, by calling the factory function
- * @template T
- * @template {keyof T} P
- * @param {T} obj an object
- * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
- * @returns {void}
- */
-const F = (obj, prop, factory) => {
-	if (obj[prop] === undefined) {
-		obj[prop] = factory();
+module.exports = ProvidePlugin;
+
+
+/***/ }),
+
+/***/ 84929:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["javascript"]);
+
+class RawModule extends Module {
+	/**
+	 * @param {string} source source code
+	 * @param {string} identifier unique identifier
+	 * @param {string=} readableIdentifier readable identifier
+	 * @param {ReadonlySet<string>=} runtimeRequirements runtime requirements needed for the source code
+	 */
+	constructor(source, identifier, readableIdentifier, runtimeRequirements) {
+		super("javascript/dynamic", null);
+		this.sourceStr = source;
+		this.identifierStr = identifier || this.sourceStr;
+		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+		this.runtimeRequirements = runtimeRequirements || null;
 	}
-};
 
-/**
- * Sets a dynamic default value when undefined, by calling the factory function.
- * factory must return an array or undefined
- * When the current value is already an array an contains "..." it's replaced with
- * the result of the factory function
- * @template T
- * @template {keyof T} P
- * @param {T} obj an object
- * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
- * @returns {void}
- */
-const A = (obj, prop, factory) => {
-	const value = obj[prop];
-	if (value === undefined) {
-		obj[prop] = factory();
-	} else if (Array.isArray(value)) {
-		/** @type {any[]} */
-		let newArray = undefined;
-		for (let i = 0; i < value.length; i++) {
-			const item = value[i];
-			if (item === "...") {
-				if (newArray === undefined) {
-					newArray = value.slice(0, i);
-					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
-				}
-				const items = /** @type {any[]} */ (/** @type {unknown} */ (factory()));
-				if (items !== undefined) {
-					for (const item of items) {
-						newArray.push(item);
-					}
-				}
-			} else if (newArray !== undefined) {
-				newArray.push(item);
-			}
-		}
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
-};
 
-/**
- * @param {WebpackOptions} options options to be modified
- * @returns {void}
- */
-const applyWebpackOptionsBaseDefaults = options => {
-	F(options, "context", () => process.cwd());
-	applyInfrastructureLoggingDefaults(options.infrastructureLogging);
-};
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this.identifierStr;
+	}
 
-/**
- * @param {WebpackOptions} options options to be modified
- * @returns {void}
- */
-const applyWebpackOptionsDefaults = options => {
-	F(options, "context", () => process.cwd());
-	F(options, "target", () => {
-		return getDefaultTarget(options.context);
-	});
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return Math.max(1, this.sourceStr.length);
+	}
 
-	const { mode, name, target } = options;
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return requestShortener.shorten(this.readableIdentifierStr);
+	}
 
-	let targetProperties =
-		target === false
-			? /** @type {false} */ (false)
-			: typeof target === "string"
-			? getTargetProperties(target, options.context)
-			: getTargetsProperties(target, options.context);
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
 
-	const development = mode === "development";
-	const production = mode === "production" || !mode;
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: true
+		};
+		callback();
+	}
 
-	if (typeof options.entry !== "function") {
-		for (const key of Object.keys(options.entry)) {
-			F(
-				options.entry[key],
-				"import",
-				() => /** @type {[string]} */ (["./src"])
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		const sources = new Map();
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			sources.set(
+				"javascript",
+				new OriginalSource(this.sourceStr, this.identifier())
 			);
+		} else {
+			sources.set("javascript", new RawSource(this.sourceStr));
 		}
+		return { sources, runtimeRequirements: this.runtimeRequirements };
 	}
 
-	F(options, "devtool", () => (development ? "eval" : false));
-	D(options, "watch", false);
-	D(options, "profile", false);
-	D(options, "parallelism", 100);
-	D(options, "recordsInputPath", false);
-	D(options, "recordsOutputPath", false);
-
-	applyExperimentsDefaults(options.experiments, {
-		production,
-		development,
-		targetProperties
-	});
-
-	const futureDefaults = options.experiments.futureDefaults;
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(this.sourceStr);
+		super.updateHash(hash, context);
+	}
 
-	F(options, "cache", () =>
-		development ? { type: /** @type {"memory"} */ ("memory") } : false
-	);
-	applyCacheDefaults(options.cache, {
-		name: name || "default",
-		mode: mode || "production",
-		development,
-		cacheUnaffected: options.experiments.cacheUnaffected
-	});
-	const cache = !!options.cache;
+	serialize(context) {
+		const { write } = context;
 
-	applySnapshotDefaults(options.snapshot, {
-		production,
-		futureDefaults
-	});
+		write(this.sourceStr);
+		write(this.identifierStr);
+		write(this.readableIdentifierStr);
+		write(this.runtimeRequirements);
 
-	applyModuleDefaults(options.module, {
-		cache,
-		syncWebAssembly: options.experiments.syncWebAssembly,
-		asyncWebAssembly: options.experiments.asyncWebAssembly,
-		css: options.experiments.css,
-		futureDefaults
-	});
+		super.serialize(context);
+	}
 
-	applyOutputDefaults(options.output, {
-		context: options.context,
-		targetProperties,
-		isAffectedByBrowserslist:
-			target === undefined ||
-			(typeof target === "string" && target.startsWith("browserslist")) ||
-			(Array.isArray(target) &&
-				target.some(target => target.startsWith("browserslist"))),
-		outputModule: options.experiments.outputModule,
-		development,
-		entry: options.entry,
-		module: options.module,
-		futureDefaults
-	});
+	deserialize(context) {
+		const { read } = context;
 
-	applyExternalsPresetsDefaults(options.externalsPresets, {
-		targetProperties,
-		buildHttp: !!options.experiments.buildHttp
-	});
+		this.sourceStr = read();
+		this.identifierStr = read();
+		this.readableIdentifierStr = read();
+		this.runtimeRequirements = read();
 
-	applyLoaderDefaults(options.loader, { targetProperties });
+		super.deserialize(context);
+	}
+}
 
-	F(options, "externalsType", () => {
-		const validExternalTypes = (__webpack_require__(73342).definitions.ExternalsType["enum"]);
-		return options.output.library &&
-			validExternalTypes.includes(options.output.library.type)
-			? /** @type {ExternalsType} */ (options.output.library.type)
-			: options.output.module
-			? "module"
-			: "var";
-	});
+makeSerializable(RawModule, "webpack/lib/RawModule");
 
-	applyNodeDefaults(options.node, {
-		futureDefaults: options.experiments.futureDefaults,
-		targetProperties
-	});
+module.exports = RawModule;
 
-	F(options, "performance", () =>
-		production &&
-		targetProperties &&
-		(targetProperties.browser || targetProperties.browser === null)
-			? {}
-			: false
-	);
-	applyPerformanceDefaults(options.performance, {
-		production
-	});
 
-	applyOptimizationDefaults(options.optimization, {
-		development,
-		production,
-		css: options.experiments.css,
-		records: !!(options.recordsInputPath || options.recordsOutputPath)
-	});
+/***/ }),
 
-	options.resolve = cleverMerge(
-		getResolveDefaults({
-			cache,
-			context: options.context,
-			targetProperties,
-			mode: options.mode
-		}),
-		options.resolve
-	);
+/***/ 11094:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	options.resolveLoader = cleverMerge(
-		getResolveLoaderDefaults({ cache }),
-		options.resolveLoader
-	);
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @param {ExperimentsNormalized} experiments options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @param {boolean} options.development is development mode
- * @param {TargetProperties | false} options.targetProperties target properties
- * @returns {void}
- */
-const applyExperimentsDefaults = (
-	experiments,
-	{ production, development, targetProperties }
-) => {
-	D(experiments, "futureDefaults", false);
-	D(experiments, "backCompat", !experiments.futureDefaults);
-	D(experiments, "topLevelAwait", experiments.futureDefaults);
-	D(experiments, "syncWebAssembly", false);
-	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
-	D(experiments, "outputModule", false);
-	D(experiments, "layers", false);
-	D(experiments, "lazyCompilation", undefined);
-	D(experiments, "buildHttp", undefined);
-	D(experiments, "cacheUnaffected", experiments.futureDefaults);
-	F(experiments, "css", () => (experiments.futureDefaults ? {} : undefined));
 
-	if (typeof experiments.buildHttp === "object") {
-		D(experiments.buildHttp, "frozen", production);
-		D(experiments.buildHttp, "upgrade", false);
-	}
 
-	if (typeof experiments.css === "object") {
-		D(
-			experiments.css,
-			"exportsOnly",
-			!targetProperties || !targetProperties.document
-		);
-	}
-};
+const { compareNumbers } = __webpack_require__(29579);
+const identifierUtils = __webpack_require__(82186);
 
-/**
- * @param {CacheOptions} cache options
- * @param {Object} options options
- * @param {string} options.name name
- * @param {string} options.mode mode
- * @param {boolean} options.development is development mode
- * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
- * @returns {void}
- */
-const applyCacheDefaults = (
-	cache,
-	{ name, mode, development, cacheUnaffected }
-) => {
-	if (cache === false) return;
-	switch (cache.type) {
-		case "filesystem":
-			F(cache, "name", () => name + "-" + mode);
-			D(cache, "version", "");
-			F(cache, "cacheDirectory", () => {
-				const cwd = process.cwd();
-				let dir = cwd;
-				for (;;) {
-					try {
-						if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
-						// eslint-disable-next-line no-empty
-					} catch (e) {}
-					const parent = path.dirname(dir);
-					if (dir === parent) {
-						dir = undefined;
-						break;
-					}
-					dir = parent;
-				}
-				if (!dir) {
-					return path.resolve(cwd, ".cache/webpack");
-				} else if (process.versions.pnp === "1") {
-					return path.resolve(dir, ".pnp/.cache/webpack");
-				} else if (process.versions.pnp === "3") {
-					return path.resolve(dir, ".yarn/.cache/webpack");
-				} else {
-					return path.resolve(dir, "node_modules/.cache/webpack");
-				}
-			});
-			F(cache, "cacheLocation", () =>
-				path.resolve(cache.cacheDirectory, cache.name)
-			);
-			D(cache, "hashAlgorithm", "md4");
-			D(cache, "store", "pack");
-			D(cache, "compression", false);
-			D(cache, "profile", false);
-			D(cache, "idleTimeout", 60000);
-			D(cache, "idleTimeoutForInitialStore", 5000);
-			D(cache, "idleTimeoutAfterLargeChanges", 1000);
-			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
-			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
-			D(cache, "allowCollectingMemory", development);
-			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
-			D(cache.buildDependencies, "defaultWebpack", [
-				path.resolve(__dirname, "..") + path.sep
-			]);
-			break;
-		case "memory":
-			D(cache, "maxGenerations", Infinity);
-			D(cache, "cacheUnaffected", development && cacheUnaffected);
-			break;
-	}
-};
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
 
 /**
- * @param {SnapshotOptions} snapshot options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
+ * @typedef {Object} RecordsChunks
+ * @property {Record<string, number>=} byName
+ * @property {Record<string, number>=} bySource
+ * @property {number[]=} usedIds
  */
-const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
-	if (futureDefaults) {
-		F(snapshot, "managedPaths", () =>
-			process.versions.pnp === "3"
-				? [
-						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
-				  ]
-				: [/^(.+?[\\/]node_modules[\\/])/]
-		);
-		F(snapshot, "immutablePaths", () =>
-			process.versions.pnp === "3"
-				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
-				: []
-		);
-	} else {
-		A(snapshot, "managedPaths", () => {
-			if (process.versions.pnp === "3") {
-				const match =
-					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-						/*require.resolve*/(36871)
-					);
-				if (match) {
-					return [path.resolve(match[1], "unplugged")];
-				}
-			} else {
-				const match = /^(.+?[\\/]node_modules[\\/])/.exec(
-					// eslint-disable-next-line node/no-extraneous-require
-					/*require.resolve*/(36871)
-				);
-				if (match) {
-					return [match[1]];
-				}
-			}
-			return [];
-		});
-		A(snapshot, "immutablePaths", () => {
-			if (process.versions.pnp === "1") {
-				const match =
-					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
-						/*require.resolve*/(36871)
-					);
-				if (match) {
-					return [match[1]];
-				}
-			} else if (process.versions.pnp === "3") {
-				const match =
-					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-						/*require.resolve*/(36871)
-					);
-				if (match) {
-					return [match[1]];
-				}
-			}
-			return [];
-		});
-	}
-	F(snapshot, "resolveBuildDependencies", () => ({
-		timestamp: true,
-		hash: true
-	}));
-	F(snapshot, "buildDependencies", () => ({ timestamp: true, hash: true }));
-	F(snapshot, "module", () =>
-		production ? { timestamp: true, hash: true } : { timestamp: true }
-	);
-	F(snapshot, "resolve", () =>
-		production ? { timestamp: true, hash: true } : { timestamp: true }
-	);
-};
 
 /**
- * @param {JavascriptParserOptions} parserOptions parser options
- * @param {Object} options options
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
+ * @typedef {Object} RecordsModules
+ * @property {Record<string, number>=} byIdentifier
+ * @property {Record<string, number>=} bySource
+ * @property {number[]=} usedIds
  */
-const applyJavascriptParserOptionsDefaults = (
-	parserOptions,
-	{ futureDefaults }
-) => {
-	D(parserOptions, "unknownContextRequest", ".");
-	D(parserOptions, "unknownContextRegExp", false);
-	D(parserOptions, "unknownContextRecursive", true);
-	D(parserOptions, "unknownContextCritical", true);
-	D(parserOptions, "exprContextRequest", ".");
-	D(parserOptions, "exprContextRegExp", false);
-	D(parserOptions, "exprContextRecursive", true);
-	D(parserOptions, "exprContextCritical", true);
-	D(parserOptions, "wrappedContextRegExp", /.*/);
-	D(parserOptions, "wrappedContextRecursive", true);
-	D(parserOptions, "wrappedContextCritical", false);
-	D(parserOptions, "strictThisContextOnImports", false);
-	D(parserOptions, "importMeta", true);
-	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
-};
 
 /**
- * @param {ModuleOptions} module options
- * @param {Object} options options
- * @param {boolean} options.cache is caching enabled
- * @param {boolean} options.syncWebAssembly is syncWebAssembly enabled
- * @param {boolean} options.asyncWebAssembly is asyncWebAssembly enabled
- * @param {CssExperimentOptions} options.css is css enabled
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
+ * @typedef {Object} Records
+ * @property {RecordsChunks=} chunks
+ * @property {RecordsModules=} modules
  */
-const applyModuleDefaults = (
-	module,
-	{ cache, syncWebAssembly, asyncWebAssembly, css, futureDefaults }
-) => {
-	if (cache) {
-		D(module, "unsafeCache", module => {
-			const name = module.nameForCondition();
-			return name && NODE_MODULES_REGEXP.test(name);
-		});
-	} else {
-		D(module, "unsafeCache", false);
-	}
 
-	F(module.parser, "asset", () => ({}));
-	F(module.parser.asset, "dataUrlCondition", () => ({}));
-	if (typeof module.parser.asset.dataUrlCondition === "object") {
-		D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
+class RecordIdsPlugin {
+	/**
+	 * @param {Object} options Options object
+	 * @param {boolean=} options.portableIds true, when ids need to be portable
+	 */
+	constructor(options) {
+		this.options = options || {};
 	}
 
-	F(module.parser, "javascript", () => ({}));
-	applyJavascriptParserOptionsDefaults(module.parser.javascript, {
-		futureDefaults
-	});
+	/**
+	 * @param {Compiler} compiler the Compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const portableIds = this.options.portableIds;
 
-	A(module, "defaultRules", () => {
-		const esm = {
-			type: "javascript/esm",
-			resolve: {
-				byDependency: {
-					esm: {
-						fullySpecified: true
-					}
-				}
+		const makePathsRelative =
+			identifierUtils.makePathsRelative.bindContextCache(
+				compiler.context,
+				compiler.root
+			);
+
+		/**
+		 * @param {Module} module the module
+		 * @returns {string} the (portable) identifier
+		 */
+		const getModuleIdentifier = module => {
+			if (portableIds) {
+				return makePathsRelative(module.identifier());
 			}
+			return module.identifier();
 		};
-		const commonjs = {
-			type: "javascript/dynamic"
-		};
-		/** @type {RuleSetRules} */
-		const rules = [
-			{
-				mimetype: "application/node",
-				type: "javascript/auto"
-			},
-			{
-				test: /\.json$/i,
-				type: "json"
-			},
-			{
-				mimetype: "application/json",
-				type: "json"
-			},
-			{
-				test: /\.mjs$/i,
-				...esm
-			},
-			{
-				test: /\.js$/i,
-				descriptionData: {
-					type: "module"
-				},
-				...esm
-			},
-			{
-				test: /\.cjs$/i,
-				...commonjs
-			},
-			{
-				test: /\.js$/i,
-				descriptionData: {
-					type: "commonjs"
-				},
-				...commonjs
-			},
-			{
-				mimetype: {
-					or: ["text/javascript", "application/javascript"]
-				},
-				...esm
-			}
-		];
-		if (asyncWebAssembly) {
-			const wasm = {
-				type: "webassembly/async",
-				rules: [
-					{
-						descriptionData: {
-							type: "module"
-						},
-						resolve: {
-							fullySpecified: true
+
+		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
+			compilation.hooks.recordModules.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(modules, records) => {
+					const chunkGraph = compilation.chunkGraph;
+					if (!records.modules) records.modules = {};
+					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					for (const module of modules) {
+						const moduleId = chunkGraph.getModuleId(module);
+						if (typeof moduleId !== "number") continue;
+						const identifier = getModuleIdentifier(module);
+						records.modules.byIdentifier[identifier] = moduleId;
+						usedIds.add(moduleId);
+					}
+					records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
+				}
+			);
+			compilation.hooks.reviveModules.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(modules, records) => {
+					if (!records.modules) return;
+					if (records.modules.byIdentifier) {
+						const chunkGraph = compilation.chunkGraph;
+						/** @type {Set<number>} */
+						const usedIds = new Set();
+						for (const module of modules) {
+							const moduleId = chunkGraph.getModuleId(module);
+							if (moduleId !== null) continue;
+							const identifier = getModuleIdentifier(module);
+							const id = records.modules.byIdentifier[identifier];
+							if (id === undefined) continue;
+							if (usedIds.has(id)) continue;
+							usedIds.add(id);
+							chunkGraph.setModuleId(module, id);
+						}
+					}
+					if (Array.isArray(records.modules.usedIds)) {
+						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					}
+				}
+			);
+
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @returns {string[]} sources of the chunk
+			 */
+			const getChunkSources = chunk => {
+				/** @type {string[]} */
+				const sources = [];
+				for (const chunkGroup of chunk.groupsIterable) {
+					const index = chunkGroup.chunks.indexOf(chunk);
+					if (chunkGroup.name) {
+						sources.push(`${index} ${chunkGroup.name}`);
+					} else {
+						for (const origin of chunkGroup.origins) {
+							if (origin.module) {
+								if (origin.request) {
+									sources.push(
+										`${index} ${getModuleIdentifier(origin.module)} ${
+											origin.request
+										}`
+									);
+								} else if (typeof origin.loc === "string") {
+									sources.push(
+										`${index} ${getModuleIdentifier(origin.module)} ${
+											origin.loc
+										}`
+									);
+								} else if (
+									origin.loc &&
+									typeof origin.loc === "object" &&
+									"start" in origin.loc
+								) {
+									sources.push(
+										`${index} ${getModuleIdentifier(
+											origin.module
+										)} ${JSON.stringify(origin.loc.start)}`
+									);
+								}
+							}
 						}
 					}
-				]
+				}
+				return sources;
 			};
-			rules.push({
-				test: /\.wasm$/i,
-				...wasm
-			});
-			rules.push({
-				mimetype: "application/wasm",
-				...wasm
-			});
-		} else if (syncWebAssembly) {
-			const wasm = {
-				type: "webassembly/sync",
-				rules: [
-					{
-						descriptionData: {
-							type: "module"
-						},
-						resolve: {
-							fullySpecified: true
+
+			compilation.hooks.recordChunks.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(chunks, records) => {
+					if (!records.chunks) records.chunks = {};
+					if (!records.chunks.byName) records.chunks.byName = {};
+					if (!records.chunks.bySource) records.chunks.bySource = {};
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					for (const chunk of chunks) {
+						if (typeof chunk.id !== "number") continue;
+						const name = chunk.name;
+						if (name) records.chunks.byName[name] = chunk.id;
+						const sources = getChunkSources(chunk);
+						for (const source of sources) {
+							records.chunks.bySource[source] = chunk.id;
 						}
+						usedIds.add(chunk.id);
 					}
-				]
-			};
-			rules.push({
-				test: /\.wasm$/i,
-				...wasm
-			});
-			rules.push({
-				mimetype: "application/wasm",
-				...wasm
-			});
-		}
-		if (css) {
-			const cssRule = {
-				type: "css",
-				resolve: {
-					fullySpecified: true,
-					preferRelative: true
-				}
-			};
-			const cssModulesRule = {
-				type: "css/module",
-				resolve: {
-					fullySpecified: true
+					records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
 				}
-			};
-			rules.push({
-				test: /\.css$/i,
-				oneOf: [
-					{
-						test: /\.module\.css$/i,
-						...cssModulesRule
-					},
-					{
-						...cssRule
+			);
+			compilation.hooks.reviveChunks.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(chunks, records) => {
+					if (!records.chunks) return;
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					if (records.chunks.byName) {
+						for (const chunk of chunks) {
+							if (chunk.id !== null) continue;
+							if (!chunk.name) continue;
+							const id = records.chunks.byName[chunk.name];
+							if (id === undefined) continue;
+							if (usedIds.has(id)) continue;
+							usedIds.add(id);
+							chunk.id = id;
+							chunk.ids = [id];
+						}
 					}
-				]
-			});
-			rules.push({
-				mimetype: "text/css+module",
-				...cssModulesRule
-			});
-			rules.push({
-				mimetype: "text/css",
-				...cssRule
-			});
-		}
-		rules.push(
-			{
-				dependency: "url",
-				oneOf: [
-					{
-						scheme: /^data$/,
-						type: "asset/inline"
-					},
-					{
-						type: "asset/resource"
+					if (records.chunks.bySource) {
+						for (const chunk of chunks) {
+							if (chunk.id !== null) continue;
+							const sources = getChunkSources(chunk);
+							for (const source of sources) {
+								const id = records.chunks.bySource[source];
+								if (id === undefined) continue;
+								if (usedIds.has(id)) continue;
+								usedIds.add(id);
+								chunk.id = id;
+								chunk.ids = [id];
+								break;
+							}
+						}
 					}
-				]
-			},
-			{
-				assert: { type: "json" },
-				type: "json"
-			}
-		);
-		return rules;
-	});
-};
+					if (Array.isArray(records.chunks.usedIds)) {
+						compilation.usedChunkIds = new Set(records.chunks.usedIds);
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = RecordIdsPlugin;
 
-/**
- * @param {Output} output options
- * @param {Object} options options
- * @param {string} options.context context
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
- * @param {boolean} options.outputModule is outputModule experiment enabled
- * @param {boolean} options.development is development mode
- * @param {Entry} options.entry entry option
- * @param {ModuleOptions} options.module module option
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
- */
-const applyOutputDefaults = (
-	output,
-	{
-		context,
-		targetProperties: tp,
-		isAffectedByBrowserslist,
-		outputModule,
-		development,
-		entry,
-		module,
-		futureDefaults
+
+/***/ }),
+
+/***/ 73406:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { contextify } = __webpack_require__(82186);
+
+class RequestShortener {
+	/**
+	 * @param {string} dir the directory
+	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
+	 */
+	constructor(dir, associatedObjectForCache) {
+		this.contextify = contextify.bindContextCache(
+			dir,
+			associatedObjectForCache
+		);
 	}
-) => {
+
 	/**
-	 * @param {Library=} library the library option
-	 * @returns {string} a readable library name
+	 * @param {string | undefined | null} request the request to shorten
+	 * @returns {string | undefined | null} the shortened request
 	 */
-	const getLibraryName = library => {
-		const libraryName =
-			typeof library === "object" &&
-			library &&
-			!Array.isArray(library) &&
-			"type" in library
-				? library.name
-				: /** @type {LibraryName=} */ (library);
-		if (Array.isArray(libraryName)) {
-			return libraryName.join(".");
-		} else if (typeof libraryName === "object") {
-			return getLibraryName(libraryName.root);
-		} else if (typeof libraryName === "string") {
-			return libraryName;
+	shorten(request) {
+		if (!request) {
+			return request;
 		}
-		return "";
-	};
+		return this.contextify(request);
+	}
+}
 
-	F(output, "uniqueName", () => {
-		const libraryName = getLibraryName(output.library);
-		if (libraryName) return libraryName;
-		const pkgPath = path.resolve(context, "package.json");
-		try {
-			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-			return packageInfo.name || "";
-		} catch (e) {
-			if (e.code !== "ENOENT") {
-				e.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
-				throw e;
-			}
-			return "";
-		}
-	});
+module.exports = RequestShortener;
 
-	F(output, "module", () => !!outputModule);
-	D(output, "filename", output.module ? "[name].mjs" : "[name].js");
-	F(output, "iife", () => !output.module);
-	D(output, "importFunctionName", "import");
-	D(output, "importMetaName", "import.meta");
-	F(output, "chunkFilename", () => {
-		const filename = output.filename;
-		if (typeof filename !== "function") {
-			const hasName = filename.includes("[name]");
-			const hasId = filename.includes("[id]");
-			const hasChunkHash = filename.includes("[chunkhash]");
-			const hasContentHash = filename.includes("[contenthash]");
-			// Anything changing depending on chunk is fine
-			if (hasChunkHash || hasContentHash || hasName || hasId) return filename;
-			// Otherwise prefix "[id]." in front of the basename to make it changing
-			return filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
-		}
-		return output.module ? "[id].mjs" : "[id].js";
-	});
-	F(output, "cssFilename", () => {
-		const filename = output.filename;
-		if (typeof filename !== "function") {
-			return filename.replace(/\.[mc]?js(\?|$)/, ".css$1");
-		}
-		return "[id].css";
-	});
-	F(output, "cssChunkFilename", () => {
-		const chunkFilename = output.chunkFilename;
-		if (typeof chunkFilename !== "function") {
-			return chunkFilename.replace(/\.[mc]?js(\?|$)/, ".css$1");
-		}
-		return "[id].css";
-	});
-	D(output, "assetModuleFilename", "[hash][ext][query]");
-	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
-	D(output, "compareBeforeEmit", true);
-	D(output, "charset", true);
-	F(output, "hotUpdateGlobal", () =>
-		Template.toIdentifier(
-			"webpackHotUpdate" + Template.toIdentifier(output.uniqueName)
-		)
-	);
-	F(output, "chunkLoadingGlobal", () =>
-		Template.toIdentifier(
-			"webpackChunk" + Template.toIdentifier(output.uniqueName)
-		)
-	);
-	F(output, "globalObject", () => {
-		if (tp) {
-			if (tp.global) return "global";
-			if (tp.globalThis) return "globalThis";
-		}
-		return "self";
-	});
-	F(output, "chunkFormat", () => {
-		if (tp) {
-			const helpMessage = isAffectedByBrowserslist
-				? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly."
-				: "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
-			if (output.module) {
-				if (tp.dynamicImport) return "module";
-				if (tp.document) return "array-push";
-				throw new Error(
-					"For the selected environment is no default ESM chunk format available:\n" +
-						"ESM exports can be chosen when 'import()' is available.\n" +
-						"JSONP Array push can be chosen when 'document' is available.\n" +
-						helpMessage
-				);
-			} else {
-				if (tp.document) return "array-push";
-				if (tp.require) return "commonjs";
-				if (tp.nodeBuiltins) return "commonjs";
-				if (tp.importScripts) return "array-push";
-				throw new Error(
-					"For the selected environment is no default script chunk format available:\n" +
-						"JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
-						"CommonJs exports can be chosen when 'require' or node builtins are available.\n" +
-						helpMessage
+
+/***/ }),
+
+/***/ 88846:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const ConstDependency = __webpack_require__(76911);
+const {
+	toConstantDependency
+} = __webpack_require__(93998);
+
+/** @typedef {import("./Compiler")} Compiler */
+
+module.exports = class RequireJsStuffPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireJsStuffPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
 				);
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireJs === undefined ||
+						!parserOptions.requireJs
+					) {
+						return;
+					}
+
+					parser.hooks.call
+						.for("require.config")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(parser, "undefined")
+						);
+					parser.hooks.call
+						.for("requirejs.config")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(parser, "undefined")
+						);
+
+					parser.hooks.expression
+						.for("require.version")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(parser, JSON.stringify("0.0.0"))
+						);
+					parser.hooks.expression
+						.for("requirejs.onError")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(
+								parser,
+								RuntimeGlobals.uncaughtErrorHandler,
+								[RuntimeGlobals.uncaughtErrorHandler]
+							)
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireJsStuffPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireJsStuffPlugin", handler);
 			}
-		}
-		throw new Error(
-			"Chunk format can't be selected by default when no target is specified"
 		);
-	});
-	D(output, "asyncChunks", true);
-	F(output, "chunkLoading", () => {
-		if (tp) {
-			switch (output.chunkFormat) {
-				case "array-push":
-					if (tp.document) return "jsonp";
-					if (tp.importScripts) return "import-scripts";
-					break;
-				case "commonjs":
-					if (tp.require) return "require";
-					if (tp.nodeBuiltins) return "async-node";
-					break;
-				case "module":
-					if (tp.dynamicImport) return "import";
-					break;
-			}
-			if (
-				tp.require === null ||
-				tp.nodeBuiltins === null ||
-				tp.document === null ||
-				tp.importScripts === null
-			) {
-				return "universal";
-			}
-		}
-		return false;
-	});
-	F(output, "workerChunkLoading", () => {
-		if (tp) {
-			switch (output.chunkFormat) {
-				case "array-push":
-					if (tp.importScriptsInWorker) return "import-scripts";
-					break;
-				case "commonjs":
-					if (tp.require) return "require";
-					if (tp.nodeBuiltins) return "async-node";
-					break;
-				case "module":
-					if (tp.dynamicImportInWorker) return "import";
-					break;
-			}
-			if (
-				tp.require === null ||
-				tp.nodeBuiltins === null ||
-				tp.importScriptsInWorker === null
-			) {
-				return "universal";
-			}
-		}
-		return false;
-	});
-	F(output, "wasmLoading", () => {
-		if (tp) {
-			if (tp.fetchWasm) return "fetch";
-			if (tp.nodeBuiltins)
-				return output.module ? "async-node-module" : "async-node";
-			if (tp.nodeBuiltins === null || tp.fetchWasm === null) {
-				return "universal";
-			}
-		}
-		return false;
-	});
-	F(output, "workerWasmLoading", () => output.wasmLoading);
-	F(output, "devtoolNamespace", () => output.uniqueName);
-	if (output.library) {
-		F(output.library, "type", () => (output.module ? "module" : "var"));
 	}
-	F(output, "path", () => path.join(process.cwd(), "dist"));
-	F(output, "pathinfo", () => development);
-	D(output, "sourceMapFilename", "[file].map[query]");
-	D(
-		output,
-		"hotUpdateChunkFilename",
-		`[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`
-	);
-	D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
-	D(output, "crossOriginLoading", false);
-	F(output, "scriptType", () => (output.module ? "module" : false));
-	D(
-		output,
-		"publicPath",
-		(tp && (tp.document || tp.importScripts)) || output.scriptType === "module"
-			? "auto"
-			: ""
-	);
-	D(output, "chunkLoadTimeout", 120000);
-	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
-	D(output, "hashDigest", "hex");
-	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
-	D(output, "strictModuleExceptionHandling", false);
+};
+
+
+/***/ }),
+
+/***/ 30217:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Factory = (__webpack_require__(30662).ResolverFactory);
+const { HookMap, SyncHook, SyncWaterfallHook } = __webpack_require__(41242);
+const {
+	cachedCleverMerge,
+	removeOperations,
+	resolveByProperty
+} = __webpack_require__(60839);
+
+/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} WebpackResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
+
+/** @typedef {WebpackResolveOptions & {dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
+/**
+ * @typedef {Object} WithOptions
+ * @property {function(Partial<ResolveOptionsWithDependencyType>): ResolverWithOptions} withOptions create a resolver with additional/different options
+ */
+
+/** @typedef {Resolver & WithOptions} ResolverWithOptions */
+
+// need to be hoisted on module level for caching identity
+const EMPTY_RESOLVE_OPTIONS = {};
+
+/**
+ * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType enhanced options
+ * @returns {ResolveOptions} merged options
+ */
+const convertToResolveOptions = resolveOptionsWithDepType => {
+	const { dependencyType, plugins, ...remaining } = resolveOptionsWithDepType;
+
+	// check type compat
+	/** @type {Partial<ResolveOptions>} */
+	const partialOptions = {
+		...remaining,
+		plugins:
+			plugins &&
+			/** @type {ResolvePluginInstance[]} */ (
+				plugins.filter(item => item !== "...")
+			)
+	};
+
+	if (!partialOptions.fileSystem) {
+		throw new Error(
+			"fileSystem is missing in resolveOptions, but it's required for enhanced-resolve"
+		);
+	}
+	// These weird types validate that we checked all non-optional properties
+	const options =
+		/** @type {Partial<ResolveOptions> & Pick<ResolveOptions, "fileSystem">} */ (
+			partialOptions
+		);
 
-	const optimistic = v => v || v === undefined;
-	F(
-		output.environment,
-		"arrowFunction",
-		() => tp && optimistic(tp.arrowFunction)
-	);
-	F(output.environment, "const", () => tp && optimistic(tp.const));
-	F(
-		output.environment,
-		"destructuring",
-		() => tp && optimistic(tp.destructuring)
+	return removeOperations(
+		resolveByProperty(options, "byDependency", dependencyType)
 	);
-	F(output.environment, "forOf", () => tp && optimistic(tp.forOf));
-	F(output.environment, "bigIntLiteral", () => tp && tp.bigIntLiteral);
-	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
-	F(output.environment, "module", () => tp && tp.module);
+};
 
-	const { trustedTypes } = output;
-	if (trustedTypes) {
-		F(
-			trustedTypes,
-			"policyName",
-			() =>
-				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
-		);
+/**
+ * @typedef {Object} ResolverCache
+ * @property {WeakMap<Object, ResolverWithOptions>} direct
+ * @property {Map<string, ResolverWithOptions>} stringified
+ */
+
+module.exports = class ResolverFactory {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>} */
+			resolveOptions: new HookMap(
+				() => new SyncWaterfallHook(["resolveOptions"])
+			),
+			/** @type {HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>} */
+			resolver: new HookMap(
+				() => new SyncHook(["resolver", "resolveOptions", "userResolveOptions"])
+			)
+		});
+		/** @type {Map<string, ResolverCache>} */
+		this.cache = new Map();
 	}
 
 	/**
-	 * @param {function(EntryDescription): void} fn iterator
-	 * @returns {void}
+	 * @param {string} type type of resolver
+	 * @param {ResolveOptionsWithDependencyType=} resolveOptions options
+	 * @returns {ResolverWithOptions} the resolver
 	 */
-	const forEachEntry = fn => {
-		for (const name of Object.keys(entry)) {
-			fn(entry[name]);
-		}
-	};
-	A(output, "enabledLibraryTypes", () => {
-		const enabledLibraryTypes = [];
-		if (output.library) {
-			enabledLibraryTypes.push(output.library.type);
+	get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
+		let typedCaches = this.cache.get(type);
+		if (!typedCaches) {
+			typedCaches = {
+				direct: new WeakMap(),
+				stringified: new Map()
+			};
+			this.cache.set(type, typedCaches);
 		}
-		forEachEntry(desc => {
-			if (desc.library) {
-				enabledLibraryTypes.push(desc.library.type);
-			}
-		});
-		return enabledLibraryTypes;
-	});
-
-	A(output, "enabledChunkLoadingTypes", () => {
-		const enabledChunkLoadingTypes = new Set();
-		if (output.chunkLoading) {
-			enabledChunkLoadingTypes.add(output.chunkLoading);
+		const cachedResolver = typedCaches.direct.get(resolveOptions);
+		if (cachedResolver) {
+			return cachedResolver;
 		}
-		if (output.workerChunkLoading) {
-			enabledChunkLoadingTypes.add(output.workerChunkLoading);
+		const ident = JSON.stringify(resolveOptions);
+		const resolver = typedCaches.stringified.get(ident);
+		if (resolver) {
+			typedCaches.direct.set(resolveOptions, resolver);
+			return resolver;
 		}
-		forEachEntry(desc => {
-			if (desc.chunkLoading) {
-				enabledChunkLoadingTypes.add(desc.chunkLoading);
-			}
-		});
-		return Array.from(enabledChunkLoadingTypes);
-	});
+		const newResolver = this._create(type, resolveOptions);
+		typedCaches.direct.set(resolveOptions, newResolver);
+		typedCaches.stringified.set(ident, newResolver);
+		return newResolver;
+	}
 
-	A(output, "enabledWasmLoadingTypes", () => {
-		const enabledWasmLoadingTypes = new Set();
-		if (output.wasmLoading) {
-			enabledWasmLoadingTypes.add(output.wasmLoading);
-		}
-		if (output.workerWasmLoading) {
-			enabledWasmLoadingTypes.add(output.workerWasmLoading);
+	/**
+	 * @param {string} type type of resolver
+	 * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options
+	 * @returns {ResolverWithOptions} the resolver
+	 */
+	_create(type, resolveOptionsWithDepType) {
+		/** @type {ResolveOptionsWithDependencyType} */
+		const originalResolveOptions = { ...resolveOptionsWithDepType };
+
+		const resolveOptions = convertToResolveOptions(
+			this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType)
+		);
+		const resolver = /** @type {ResolverWithOptions} */ (
+			Factory.createResolver(resolveOptions)
+		);
+		if (!resolver) {
+			throw new Error("No resolver created");
 		}
-		forEachEntry(desc => {
-			if (desc.wasmLoading) {
-				enabledWasmLoadingTypes.add(desc.wasmLoading);
-			}
-		});
-		return Array.from(enabledWasmLoadingTypes);
-	});
+		/** @type {WeakMap<Partial<ResolveOptionsWithDependencyType>, ResolverWithOptions>} */
+		const childCache = new WeakMap();
+		resolver.withOptions = options => {
+			const cacheEntry = childCache.get(options);
+			if (cacheEntry !== undefined) return cacheEntry;
+			const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
+			const resolver = this.get(type, mergedOptions);
+			childCache.set(options, resolver);
+			return resolver;
+		};
+		this.hooks.resolver
+			.for(type)
+			.call(resolver, resolveOptions, originalResolveOptions);
+		return resolver;
+	}
 };
 
+
+/***/ }),
+
+/***/ 16475:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
 /**
- * @param {ExternalsPresets} externalsPresets options
- * @param {Object} options options
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {boolean} options.buildHttp buildHttp experiment enabled
- * @returns {void}
+ * the internal require function
  */
-const applyExternalsPresetsDefaults = (
-	externalsPresets,
-	{ targetProperties, buildHttp }
-) => {
-	D(
-		externalsPresets,
-		"web",
-		!buildHttp && targetProperties && targetProperties.web
-	);
-	D(externalsPresets, "node", targetProperties && targetProperties.node);
-	D(externalsPresets, "nwjs", targetProperties && targetProperties.nwjs);
-	D(
-		externalsPresets,
-		"electron",
-		targetProperties && targetProperties.electron
-	);
-	D(
-		externalsPresets,
-		"electronMain",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronMain
-	);
-	D(
-		externalsPresets,
-		"electronPreload",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronPreload
-	);
-	D(
-		externalsPresets,
-		"electronRenderer",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronRenderer
-	);
-};
+exports.require = "__webpack_require__";
 
 /**
- * @param {Loader} loader options
- * @param {Object} options options
- * @param {TargetProperties | false} options.targetProperties target properties
- * @returns {void}
+ * access to properties of the internal require function/object
  */
-const applyLoaderDefaults = (loader, { targetProperties }) => {
-	F(loader, "target", () => {
-		if (targetProperties) {
-			if (targetProperties.electron) {
-				if (targetProperties.electronMain) return "electron-main";
-				if (targetProperties.electronPreload) return "electron-preload";
-				if (targetProperties.electronRenderer) return "electron-renderer";
-				return "electron";
-			}
-			if (targetProperties.nwjs) return "nwjs";
-			if (targetProperties.node) return "node";
-			if (targetProperties.web) return "web";
-		}
-	});
-};
+exports.requireScope = "__webpack_require__.*";
 
 /**
- * @param {WebpackNode} node options
- * @param {Object} options options
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
+ * the internal exports object
  */
-const applyNodeDefaults = (node, { futureDefaults, targetProperties }) => {
-	if (node === false) return;
-
-	F(node, "global", () => {
-		if (targetProperties && targetProperties.global) return false;
-		// TODO webpack 6 should always default to false
-		return futureDefaults ? "warn" : true;
-	});
-	F(node, "__filename", () => {
-		if (targetProperties && targetProperties.node) return "eval-only";
-		// TODO webpack 6 should always default to false
-		return futureDefaults ? "warn-mock" : "mock";
-	});
-	F(node, "__dirname", () => {
-		if (targetProperties && targetProperties.node) return "eval-only";
-		// TODO webpack 6 should always default to false
-		return futureDefaults ? "warn-mock" : "mock";
-	});
-};
+exports.exports = "__webpack_exports__";
 
 /**
- * @param {Performance} performance options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @returns {void}
+ * top-level this need to be the exports object
  */
-const applyPerformanceDefaults = (performance, { production }) => {
-	if (performance === false) return;
-	D(performance, "maxAssetSize", 250000);
-	D(performance, "maxEntrypointSize", 250000);
-	F(performance, "hints", () => (production ? "warning" : false));
-};
+exports.thisAsExports = "top-level-this-exports";
 
 /**
- * @param {Optimization} optimization options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @param {boolean} options.development is development
- * @param {CssExperimentOptions} options.css is css enabled
- * @param {boolean} options.records using records
- * @returns {void}
+ * runtime need to return the exports of the last entry module
  */
-const applyOptimizationDefaults = (
-	optimization,
-	{ production, development, css, records }
-) => {
-	D(optimization, "removeAvailableModules", false);
-	D(optimization, "removeEmptyChunks", true);
-	D(optimization, "mergeDuplicateChunks", true);
-	D(optimization, "flagIncludedChunks", production);
-	F(optimization, "moduleIds", () => {
-		if (production) return "deterministic";
-		if (development) return "named";
-		return "natural";
-	});
-	F(optimization, "chunkIds", () => {
-		if (production) return "deterministic";
-		if (development) return "named";
-		return "natural";
-	});
-	F(optimization, "sideEffects", () => (production ? true : "flag"));
-	D(optimization, "providedExports", true);
-	D(optimization, "usedExports", production);
-	D(optimization, "innerGraph", production);
-	D(optimization, "mangleExports", production);
-	D(optimization, "concatenateModules", production);
-	D(optimization, "runtimeChunk", false);
-	D(optimization, "emitOnErrors", !production);
-	D(optimization, "checkWasmTypes", production);
-	D(optimization, "mangleWasmImports", false);
-	D(optimization, "portableRecords", records);
-	D(optimization, "realContentHash", production);
-	D(optimization, "minimize", production);
-	A(optimization, "minimizer", () => [
-		{
-			apply: compiler => {
-				// Lazy load the Terser plugin
-				const TerserPlugin = __webpack_require__(55302);
-				new TerserPlugin({
-					terserOptions: {
-						compress: {
-							passes: 2
-						}
-					}
-				}).apply(compiler);
-			}
-		}
-	]);
-	F(optimization, "nodeEnv", () => {
-		if (production) return "production";
-		if (development) return "development";
-		return false;
-	});
-	const { splitChunks } = optimization;
-	if (splitChunks) {
-		A(splitChunks, "defaultSizeTypes", () =>
-			css ? ["javascript", "css", "unknown"] : ["javascript", "unknown"]
-		);
-		D(splitChunks, "hidePathInfo", production);
-		D(splitChunks, "chunks", "async");
-		D(splitChunks, "usedExports", optimization.usedExports === true);
-		D(splitChunks, "minChunks", 1);
-		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
-		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));
-		F(splitChunks, "enforceSizeThreshold", () => (production ? 50000 : 30000));
-		F(splitChunks, "maxAsyncRequests", () => (production ? 30 : Infinity));
-		F(splitChunks, "maxInitialRequests", () => (production ? 30 : Infinity));
-		D(splitChunks, "automaticNameDelimiter", "-");
-		const { cacheGroups } = splitChunks;
-		F(cacheGroups, "default", () => ({
-			idHint: "",
-			reuseExistingChunk: true,
-			minChunks: 2,
-			priority: -20
-		}));
-		F(cacheGroups, "defaultVendors", () => ({
-			idHint: "vendors",
-			reuseExistingChunk: true,
-			test: NODE_MODULES_REGEXP,
-			priority: -10
-		}));
-	}
-};
+exports.returnExportsFromRuntime = "return-exports-from-runtime";
 
 /**
- * @param {Object} options options
- * @param {boolean} options.cache is cache enable
- * @param {string} options.context build context
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {Mode} options.mode mode
- * @returns {ResolveOptions} resolve options
+ * the internal module object
  */
-const getResolveDefaults = ({ cache, context, targetProperties, mode }) => {
-	/** @type {string[]} */
-	const conditions = ["webpack"];
-
-	conditions.push(mode === "development" ? "development" : "production");
-
-	if (targetProperties) {
-		if (targetProperties.webworker) conditions.push("worker");
-		if (targetProperties.node) conditions.push("node");
-		if (targetProperties.web) conditions.push("browser");
-		if (targetProperties.electron) conditions.push("electron");
-		if (targetProperties.nwjs) conditions.push("nwjs");
-	}
-
-	const jsExtensions = [".js", ".json", ".wasm"];
+exports.module = "module";
 
-	const tp = targetProperties;
-	const browserField =
-		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
+/**
+ * the internal module object
+ */
+exports.moduleId = "module.id";
 
-	/** @type {function(): ResolveOptions} */
-	const cjsDeps = () => ({
-		aliasFields: browserField ? ["browser"] : [],
-		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
-		conditionNames: ["require", "module", "..."],
-		extensions: [...jsExtensions]
-	});
-	/** @type {function(): ResolveOptions} */
-	const esmDeps = () => ({
-		aliasFields: browserField ? ["browser"] : [],
-		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
-		conditionNames: ["import", "module", "..."],
-		extensions: [...jsExtensions]
-	});
+/**
+ * the internal module object
+ */
+exports.moduleLoaded = "module.loaded";
 
-	/** @type {ResolveOptions} */
-	const resolveOptions = {
-		cache,
-		modules: ["node_modules"],
-		conditionNames: conditions,
-		mainFiles: ["index"],
-		extensions: [],
-		aliasFields: [],
-		exportsFields: ["exports"],
-		roots: [context],
-		mainFields: ["main"],
-		byDependency: {
-			wasm: esmDeps(),
-			esm: esmDeps(),
-			loaderImport: esmDeps(),
-			url: {
-				preferRelative: true
-			},
-			worker: {
-				...esmDeps(),
-				preferRelative: true
-			},
-			commonjs: cjsDeps(),
-			amd: cjsDeps(),
-			// for backward-compat: loadModule
-			loader: cjsDeps(),
-			// for backward-compat: Custom Dependency
-			unknown: cjsDeps(),
-			// for backward-compat: getResolve without dependencyType
-			undefined: cjsDeps()
-		}
-	};
+/**
+ * the bundle public path
+ */
+exports.publicPath = "__webpack_require__.p";
 
-	return resolveOptions;
-};
+/**
+ * the module id of the entry point
+ */
+exports.entryModuleId = "__webpack_require__.s";
 
 /**
- * @param {Object} options options
- * @param {boolean} options.cache is cache enable
- * @returns {ResolveOptions} resolve options
+ * the module cache
  */
-const getResolveLoaderDefaults = ({ cache }) => {
-	/** @type {ResolveOptions} */
-	const resolveOptions = {
-		cache,
-		conditionNames: ["loader", "require", "node"],
-		exportsFields: ["exports"],
-		mainFields: ["loader", "main"],
-		extensions: [".js"],
-		mainFiles: ["index"]
-	};
-
-	return resolveOptions;
-};
+exports.moduleCache = "__webpack_require__.c";
 
 /**
- * @param {InfrastructureLogging} infrastructureLogging options
- * @returns {void}
+ * the module functions
  */
-const applyInfrastructureLoggingDefaults = infrastructureLogging => {
-	F(infrastructureLogging, "stream", () => process.stderr);
-	const tty =
-		/** @type {any} */ (infrastructureLogging.stream).isTTY &&
-		process.env.TERM !== "dumb";
-	D(infrastructureLogging, "level", "info");
-	D(infrastructureLogging, "debug", false);
-	D(infrastructureLogging, "colors", tty);
-	D(infrastructureLogging, "appendOnly", !tty);
-};
-
-exports.applyWebpackOptionsBaseDefaults = applyWebpackOptionsBaseDefaults;
-exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
+exports.moduleFactories = "__webpack_require__.m";
 
+/**
+ * the module functions, with only write access
+ */
+exports.moduleFactoriesAddOnly = "__webpack_require__.m (add only)";
 
-/***/ }),
+/**
+ * the chunk ensure function
+ */
+exports.ensureChunk = "__webpack_require__.e";
 
-/***/ 26693:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/**
+ * an object with handlers to ensure a chunk
+ */
+exports.ensureChunkHandlers = "__webpack_require__.f";
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
+ */
+exports.ensureChunkIncludeEntries = "__webpack_require__.f (include entries)";
 
+/**
+ * the chunk prefetch function
+ */
+exports.prefetchChunk = "__webpack_require__.E";
 
+/**
+ * an object with handlers to prefetch a chunk
+ */
+exports.prefetchChunkHandlers = "__webpack_require__.F";
 
-const util = __webpack_require__(73837);
+/**
+ * the chunk preload function
+ */
+exports.preloadChunk = "__webpack_require__.G";
 
-/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
-/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/**
+ * an object with handlers to preload a chunk
+ */
+exports.preloadChunkHandlers = "__webpack_require__.H";
 
-const handledDeprecatedNoEmitOnErrors = util.deprecate(
-	(noEmitOnErrors, emitOnErrors) => {
-		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
-			throw new Error(
-				"Conflicting use of 'optimization.noEmitOnErrors' and 'optimization.emitOnErrors'. Remove deprecated 'optimization.noEmitOnErrors' from config."
-			);
-		}
-		return !noEmitOnErrors;
-	},
-	"optimization.noEmitOnErrors is deprecated in favor of optimization.emitOnErrors",
-	"DEP_WEBPACK_CONFIGURATION_OPTIMIZATION_NO_EMIT_ON_ERRORS"
-);
+/**
+ * the exported property define getters function
+ */
+exports.definePropertyGetters = "__webpack_require__.d";
 
 /**
- * @template T
- * @template R
- * @param {T|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @returns {R} result value
+ * define compatibility on export
  */
-const nestedConfig = (value, fn) =>
-	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
+exports.makeNamespaceObject = "__webpack_require__.r";
 
 /**
- * @template T
- * @param {T|undefined} value value or not
- * @returns {T} result value
+ * create a fake namespace object
  */
-const cloneObject = value => {
-	return /** @type {T} */ ({ ...value });
-};
+exports.createFakeNamespaceObject = "__webpack_require__.t";
 
 /**
- * @template T
- * @template R
- * @param {T|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @returns {R|undefined} result value
+ * compatibility get default export
  */
-const optionalNestedConfig = (value, fn) =>
-	value === undefined ? undefined : fn(value);
+exports.compatGetDefaultExport = "__webpack_require__.n";
 
 /**
- * @template T
- * @template R
- * @param {T[]|undefined} value array or not
- * @param {function(T[]): R[]} fn nested handler
- * @returns {R[]|undefined} cloned value
+ * harmony module decorator
  */
-const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
+exports.harmonyModuleDecorator = "__webpack_require__.hmd";
 
 /**
- * @template T
- * @template R
- * @param {T[]|undefined} value array or not
- * @param {function(T[]): R[]} fn nested handler
- * @returns {R[]|undefined} cloned value
+ * node.js module decorator
  */
-const optionalNestedArray = (value, fn) =>
-	Array.isArray(value) ? fn(value) : undefined;
+exports.nodeModuleDecorator = "__webpack_require__.nmd";
 
 /**
- * @template T
- * @template R
- * @param {Record<string, T>|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @param {Record<string, function(T): R>=} customKeys custom nested handler for some keys
- * @returns {Record<string, R>} result value
+ * the webpack hash
  */
-const keyedNestedConfig = (value, fn, customKeys) => {
-	const result =
-		value === undefined
-			? {}
-			: Object.keys(value).reduce(
-					(obj, key) => (
-						(obj[key] = (
-							customKeys && key in customKeys ? customKeys[key] : fn
-						)(value[key])),
-						obj
-					),
-					/** @type {Record<string, R>} */ ({})
-			  );
-	if (customKeys) {
-		for (const key of Object.keys(customKeys)) {
-			if (!(key in result)) {
-				result[key] = customKeys[key](/** @type {T} */ ({}));
-			}
-		}
-	}
-	return result;
-};
+exports.getFullHash = "__webpack_require__.h";
 
 /**
- * @param {WebpackOptions} config input config
- * @returns {WebpackOptionsNormalized} normalized options
+ * an object containing all installed WebAssembly.Instance export objects keyed by module id
  */
-const getNormalizedWebpackOptions = config => {
-	return {
-		amd: config.amd,
-		bail: config.bail,
-		cache: optionalNestedConfig(config.cache, cache => {
-			if (cache === false) return false;
-			if (cache === true) {
-				return {
-					type: "memory",
-					maxGenerations: undefined
-				};
-			}
-			switch (cache.type) {
-				case "filesystem":
-					return {
-						type: "filesystem",
-						allowCollectingMemory: cache.allowCollectingMemory,
-						maxMemoryGenerations: cache.maxMemoryGenerations,
-						maxAge: cache.maxAge,
-						profile: cache.profile,
-						buildDependencies: cloneObject(cache.buildDependencies),
-						cacheDirectory: cache.cacheDirectory,
-						cacheLocation: cache.cacheLocation,
-						hashAlgorithm: cache.hashAlgorithm,
-						compression: cache.compression,
-						idleTimeout: cache.idleTimeout,
-						idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
-						idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
-						name: cache.name,
-						store: cache.store,
-						version: cache.version
-					};
-				case undefined:
-				case "memory":
-					return {
-						type: "memory",
-						maxGenerations: cache.maxGenerations
-					};
-				default:
-					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
-					throw new Error(`Not implemented cache.type ${cache.type}`);
-			}
-		}),
-		context: config.context,
-		dependencies: config.dependencies,
-		devServer: optionalNestedConfig(config.devServer, devServer => ({
-			...devServer
-		})),
-		devtool: config.devtool,
-		entry:
-			config.entry === undefined
-				? { main: {} }
-				: typeof config.entry === "function"
-				? (
-						fn => () =>
-							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
-				  )(config.entry)
-				: getNormalizedEntryStatic(config.entry),
-		experiments: nestedConfig(config.experiments, experiments => ({
-			...experiments,
-			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
-				Array.isArray(options) ? { allowedUris: options } : options
-			),
-			lazyCompilation: optionalNestedConfig(
-				experiments.lazyCompilation,
-				options =>
-					options === true ? {} : options === false ? undefined : options
-			),
-			css: optionalNestedConfig(experiments.css, options =>
-				options === true ? {} : options === false ? undefined : options
-			)
-		})),
-		externals: config.externals,
-		externalsPresets: cloneObject(config.externalsPresets),
-		externalsType: config.externalsType,
-		ignoreWarnings: config.ignoreWarnings
-			? config.ignoreWarnings.map(ignore => {
-					if (typeof ignore === "function") return ignore;
-					const i = ignore instanceof RegExp ? { message: ignore } : ignore;
-					return (warning, { requestShortener }) => {
-						if (!i.message && !i.module && !i.file) return false;
-						if (i.message && !i.message.test(warning.message)) {
-							return false;
-						}
-						if (
-							i.module &&
-							(!warning.module ||
-								!i.module.test(
-									warning.module.readableIdentifier(requestShortener)
-								))
-						) {
-							return false;
-						}
-						if (i.file && (!warning.file || !i.file.test(warning.file))) {
-							return false;
-						}
-						return true;
-					};
-			  })
-			: undefined,
-		infrastructureLogging: cloneObject(config.infrastructureLogging),
-		loader: cloneObject(config.loader),
-		mode: config.mode,
-		module: nestedConfig(config.module, module => ({
-			noParse: module.noParse,
-			unsafeCache: module.unsafeCache,
-			parser: keyedNestedConfig(module.parser, cloneObject, {
-				javascript: parserOptions => ({
-					unknownContextRequest: module.unknownContextRequest,
-					unknownContextRegExp: module.unknownContextRegExp,
-					unknownContextRecursive: module.unknownContextRecursive,
-					unknownContextCritical: module.unknownContextCritical,
-					exprContextRequest: module.exprContextRequest,
-					exprContextRegExp: module.exprContextRegExp,
-					exprContextRecursive: module.exprContextRecursive,
-					exprContextCritical: module.exprContextCritical,
-					wrappedContextRegExp: module.wrappedContextRegExp,
-					wrappedContextRecursive: module.wrappedContextRecursive,
-					wrappedContextCritical: module.wrappedContextCritical,
-					// TODO webpack 6 remove
-					strictExportPresence: module.strictExportPresence,
-					strictThisContextOnImports: module.strictThisContextOnImports,
-					...parserOptions
-				})
-			}),
-			generator: cloneObject(module.generator),
-			defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
-			rules: nestedArray(module.rules, r => [...r])
-		})),
-		name: config.name,
-		node: nestedConfig(
-			config.node,
-			node =>
-				node && {
-					...node
-				}
-		),
-		optimization: nestedConfig(config.optimization, optimization => {
-			return {
-				...optimization,
-				runtimeChunk: getNormalizedOptimizationRuntimeChunk(
-					optimization.runtimeChunk
-				),
-				splitChunks: nestedConfig(
-					optimization.splitChunks,
-					splitChunks =>
-						splitChunks && {
-							...splitChunks,
-							defaultSizeTypes: splitChunks.defaultSizeTypes
-								? [...splitChunks.defaultSizeTypes]
-								: ["..."],
-							cacheGroups: cloneObject(splitChunks.cacheGroups)
-						}
-				),
-				emitOnErrors:
-					optimization.noEmitOnErrors !== undefined
-						? handledDeprecatedNoEmitOnErrors(
-								optimization.noEmitOnErrors,
-								optimization.emitOnErrors
-						  )
-						: optimization.emitOnErrors
-			};
-		}),
-		output: nestedConfig(config.output, output => {
-			const { library } = output;
-			const libraryAsName = /** @type {LibraryName} */ (library);
-			const libraryBase =
-				typeof library === "object" &&
-				library &&
-				!Array.isArray(library) &&
-				"type" in library
-					? library
-					: libraryAsName || output.libraryTarget
-					? /** @type {LibraryOptions} */ ({
-							name: libraryAsName
-					  })
-					: undefined;
-			/** @type {OutputNormalized} */
-			const result = {
-				assetModuleFilename: output.assetModuleFilename,
-				asyncChunks: output.asyncChunks,
-				charset: output.charset,
-				chunkFilename: output.chunkFilename,
-				chunkFormat: output.chunkFormat,
-				chunkLoading: output.chunkLoading,
-				chunkLoadingGlobal: output.chunkLoadingGlobal,
-				chunkLoadTimeout: output.chunkLoadTimeout,
-				cssFilename: output.cssFilename,
-				cssChunkFilename: output.cssChunkFilename,
-				clean: output.clean,
-				compareBeforeEmit: output.compareBeforeEmit,
-				crossOriginLoading: output.crossOriginLoading,
-				devtoolFallbackModuleFilenameTemplate:
-					output.devtoolFallbackModuleFilenameTemplate,
-				devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
-				devtoolNamespace: output.devtoolNamespace,
-				environment: cloneObject(output.environment),
-				enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
-					? [...output.enabledChunkLoadingTypes]
-					: ["..."],
-				enabledLibraryTypes: output.enabledLibraryTypes
-					? [...output.enabledLibraryTypes]
-					: ["..."],
-				enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
-					? [...output.enabledWasmLoadingTypes]
-					: ["..."],
-				filename: output.filename,
-				globalObject: output.globalObject,
-				hashDigest: output.hashDigest,
-				hashDigestLength: output.hashDigestLength,
-				hashFunction: output.hashFunction,
-				hashSalt: output.hashSalt,
-				hotUpdateChunkFilename: output.hotUpdateChunkFilename,
-				hotUpdateGlobal: output.hotUpdateGlobal,
-				hotUpdateMainFilename: output.hotUpdateMainFilename,
-				iife: output.iife,
-				importFunctionName: output.importFunctionName,
-				importMetaName: output.importMetaName,
-				scriptType: output.scriptType,
-				library: libraryBase && {
-					type:
-						output.libraryTarget !== undefined
-							? output.libraryTarget
-							: libraryBase.type,
-					auxiliaryComment:
-						output.auxiliaryComment !== undefined
-							? output.auxiliaryComment
-							: libraryBase.auxiliaryComment,
-					export:
-						output.libraryExport !== undefined
-							? output.libraryExport
-							: libraryBase.export,
-					name: libraryBase.name,
-					umdNamedDefine:
-						output.umdNamedDefine !== undefined
-							? output.umdNamedDefine
-							: libraryBase.umdNamedDefine
-				},
-				module: output.module,
-				path: output.path,
-				pathinfo: output.pathinfo,
-				publicPath: output.publicPath,
-				sourceMapFilename: output.sourceMapFilename,
-				sourcePrefix: output.sourcePrefix,
-				strictModuleExceptionHandling: output.strictModuleExceptionHandling,
-				trustedTypes: optionalNestedConfig(
-					output.trustedTypes,
-					trustedTypes => {
-						if (trustedTypes === true) return {};
-						if (typeof trustedTypes === "string")
-							return { policyName: trustedTypes };
-						return { ...trustedTypes };
-					}
-				),
-				uniqueName: output.uniqueName,
-				wasmLoading: output.wasmLoading,
-				webassemblyModuleFilename: output.webassemblyModuleFilename,
-				workerChunkLoading: output.workerChunkLoading,
-				workerWasmLoading: output.workerWasmLoading
-			};
-			return result;
-		}),
-		parallelism: config.parallelism,
-		performance: optionalNestedConfig(config.performance, performance => {
-			if (performance === false) return false;
-			return {
-				...performance
-			};
-		}),
-		plugins: nestedArray(config.plugins, p => [...p]),
-		profile: config.profile,
-		recordsInputPath:
-			config.recordsInputPath !== undefined
-				? config.recordsInputPath
-				: config.recordsPath,
-		recordsOutputPath:
-			config.recordsOutputPath !== undefined
-				? config.recordsOutputPath
-				: config.recordsPath,
-		resolve: nestedConfig(config.resolve, resolve => ({
-			...resolve,
-			byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
-		})),
-		resolveLoader: cloneObject(config.resolveLoader),
-		snapshot: nestedConfig(config.snapshot, snapshot => ({
-			resolveBuildDependencies: optionalNestedConfig(
-				snapshot.resolveBuildDependencies,
-				resolveBuildDependencies => ({
-					timestamp: resolveBuildDependencies.timestamp,
-					hash: resolveBuildDependencies.hash
-				})
-			),
-			buildDependencies: optionalNestedConfig(
-				snapshot.buildDependencies,
-				buildDependencies => ({
-					timestamp: buildDependencies.timestamp,
-					hash: buildDependencies.hash
-				})
-			),
-			resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
-				timestamp: resolve.timestamp,
-				hash: resolve.hash
-			})),
-			module: optionalNestedConfig(snapshot.module, module => ({
-				timestamp: module.timestamp,
-				hash: module.hash
-			})),
-			immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
-			managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p])
-		})),
-		stats: nestedConfig(config.stats, stats => {
-			if (stats === false) {
-				return {
-					preset: "none"
-				};
-			}
-			if (stats === true) {
-				return {
-					preset: "normal"
-				};
-			}
-			if (typeof stats === "string") {
-				return {
-					preset: stats
-				};
-			}
-			return {
-				...stats
-			};
-		}),
-		target: config.target,
-		watch: config.watch,
-		watchOptions: cloneObject(config.watchOptions)
-	};
-};
+exports.wasmInstances = "__webpack_require__.w";
 
 /**
- * @param {EntryStatic} entry static entry options
- * @returns {EntryStaticNormalized} normalized static entry options
+ * instantiate a wasm instance from module exports object, id, hash and importsObject
  */
-const getNormalizedEntryStatic = entry => {
-	if (typeof entry === "string") {
-		return {
-			main: {
-				import: [entry]
-			}
-		};
-	}
-	if (Array.isArray(entry)) {
-		return {
-			main: {
-				import: entry
-			}
-		};
-	}
-	/** @type {EntryStaticNormalized} */
-	const result = {};
-	for (const key of Object.keys(entry)) {
-		const value = entry[key];
-		if (typeof value === "string") {
-			result[key] = {
-				import: [value]
-			};
-		} else if (Array.isArray(value)) {
-			result[key] = {
-				import: value
-			};
-		} else {
-			result[key] = {
-				import:
-					value.import &&
-					(Array.isArray(value.import) ? value.import : [value.import]),
-				filename: value.filename,
-				layer: value.layer,
-				runtime: value.runtime,
-				publicPath: value.publicPath,
-				chunkLoading: value.chunkLoading,
-				asyncChunks: value.asyncChunks,
-				wasmLoading: value.wasmLoading,
-				dependOn:
-					value.dependOn &&
-					(Array.isArray(value.dependOn) ? value.dependOn : [value.dependOn]),
-				library: value.library
-			};
-		}
-	}
-	return result;
-};
+exports.instantiateWasm = "__webpack_require__.v";
 
 /**
- * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
- * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
+ * the uncaught error handler for the webpack runtime
  */
-const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
-	if (runtimeChunk === undefined) return undefined;
-	if (runtimeChunk === false) return false;
-	if (runtimeChunk === "single") {
-		return {
-			name: () => "runtime"
-		};
-	}
-	if (runtimeChunk === true || runtimeChunk === "multiple") {
-		return {
-			name: entrypoint => `runtime~${entrypoint.name}`
-		};
-	}
-	const { name } = runtimeChunk;
-	return {
-		name: typeof name === "function" ? name : () => name
-	};
-};
+exports.uncaughtErrorHandler = "__webpack_require__.oe";
 
-exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
+/**
+ * the script nonce
+ */
+exports.scriptNonce = "__webpack_require__.nc";
+
+/**
+ * function to load a script tag.
+ * Arguments: (url: string, done: (event) => void), key?: string | number, chunkId?: string | number) => void
+ * done function is called when loading has finished or timeout occurred.
+ * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
+ */
+exports.loadScript = "__webpack_require__.l";
+
+/**
+ * function to promote a string to a TrustedScript using webpack's Trusted
+ * Types policy
+ * Arguments: (script: string) => TrustedScript
+ */
+exports.createScript = "__webpack_require__.ts";
+
+/**
+ * function to promote a string to a TrustedScriptURL using webpack's Trusted
+ * Types policy
+ * Arguments: (url: string) => TrustedScriptURL
+ */
+exports.createScriptUrl = "__webpack_require__.tu";
+
+/**
+ * function to return webpack's Trusted Types policy
+ * Arguments: () => TrustedTypePolicy
+ */
+exports.getTrustedTypesPolicy = "__webpack_require__.tt";
+
+/**
+ * the chunk name of the chunk with the runtime
+ */
+exports.chunkName = "__webpack_require__.cn";
+
+/**
+ * the runtime id of the current runtime
+ */
+exports.runtimeId = "__webpack_require__.j";
+
+/**
+ * the filename of the script part of the chunk
+ */
+exports.getChunkScriptFilename = "__webpack_require__.u";
+
+/**
+ * the filename of the css part of the chunk
+ */
+exports.getChunkCssFilename = "__webpack_require__.k";
+
+/**
+ * a flag when a module/chunk/tree has css modules
+ */
+exports.hasCssModules = "has css modules";
+
+/**
+ * the filename of the script part of the hot update chunk
+ */
+exports.getChunkUpdateScriptFilename = "__webpack_require__.hu";
+
+/**
+ * the filename of the css part of the hot update chunk
+ */
+exports.getChunkUpdateCssFilename = "__webpack_require__.hk";
+
+/**
+ * startup signal from runtime
+ * This will be called when the runtime chunk has been loaded.
+ */
+exports.startup = "__webpack_require__.x";
+
+/**
+ * @deprecated
+ * creating a default startup function with the entry modules
+ */
+exports.startupNoDefault = "__webpack_require__.x (no default handler)";
+
+/**
+ * startup signal from runtime but only used to add logic after the startup
+ */
+exports.startupOnlyAfter = "__webpack_require__.x (only after)";
+
+/**
+ * startup signal from runtime but only used to add sync logic before the startup
+ */
+exports.startupOnlyBefore = "__webpack_require__.x (only before)";
+
+/**
+ * global callback functions for installing chunks
+ */
+exports.chunkCallback = "webpackChunk";
+
+/**
+ * method to startup an entrypoint with needed chunks.
+ * Signature: (moduleId: Id, chunkIds: Id[]) => any.
+ * Returns the exports of the module or a Promise
+ */
+exports.startupEntrypoint = "__webpack_require__.X";
+
+/**
+ * register deferred code, which will run when certain
+ * chunks are loaded.
+ * Signature: (chunkIds: Id[], fn: () => any, priority: int >= 0 = 0) => any
+ * Returned value will be returned directly when all chunks are already loaded
+ * When (priority & 1) it will wait for all other handlers with lower priority to
+ * be executed before itself is executed
+ */
+exports.onChunksLoaded = "__webpack_require__.O";
+
+/**
+ * method to install a chunk that was loaded somehow
+ * Signature: ({ id, ids, modules, runtime }) => void
+ */
+exports.externalInstallChunk = "__webpack_require__.C";
+
+/**
+ * interceptor for module executions
+ */
+exports.interceptModuleExecution = "__webpack_require__.i";
+
+/**
+ * the global object
+ */
+exports.global = "__webpack_require__.g";
+
+/**
+ * an object with all share scopes
+ */
+exports.shareScopeMap = "__webpack_require__.S";
+
+/**
+ * The sharing init sequence function (only runs once per share scope).
+ * Has one argument, the name of the share scope.
+ * Creates a share scope if not existing
+ */
+exports.initializeSharing = "__webpack_require__.I";
+
+/**
+ * The current scope when getting a module from a remote
+ */
+exports.currentRemoteGetScope = "__webpack_require__.R";
+
+/**
+ * the filename of the HMR manifest
+ */
+exports.getUpdateManifestFilename = "__webpack_require__.hmrF";
+
+/**
+ * function downloading the update manifest
+ */
+exports.hmrDownloadManifest = "__webpack_require__.hmrM";
+
+/**
+ * array with handler functions to download chunk updates
+ */
+exports.hmrDownloadUpdateHandlers = "__webpack_require__.hmrC";
+
+/**
+ * object with all hmr module data for all modules
+ */
+exports.hmrModuleData = "__webpack_require__.hmrD";
+
+/**
+ * array with handler functions when a module should be invalidated
+ */
+exports.hmrInvalidateModuleHandlers = "__webpack_require__.hmrI";
+
+/**
+ * the prefix for storing state of runtime modules when hmr is enabled
+ */
+exports.hmrRuntimeStatePrefix = "__webpack_require__.hmrS";
+
+/**
+ * the AMD define function
+ */
+exports.amdDefine = "__webpack_require__.amdD";
+
+/**
+ * the AMD options
+ */
+exports.amdOptions = "__webpack_require__.amdO";
+
+/**
+ * the System polyfill object
+ */
+exports.system = "__webpack_require__.System";
+
+/**
+ * the shorthand for Object.prototype.hasOwnProperty
+ * using of it decreases the compiled bundle size
+ */
+exports.hasOwnProperty = "__webpack_require__.o";
+
+/**
+ * the System.register context object
+ */
+exports.systemContext = "__webpack_require__.y";
+
+/**
+ * the baseURI of current document
+ */
+exports.baseURI = "__webpack_require__.b";
+
+/**
+ * a RelativeURL class when relative URLs are used
+ */
+exports.relativeUrl = "__webpack_require__.U";
+
+/**
+ * Creates an async module. The body function must be a async function.
+ * "module.exports" will be decorated with an AsyncModulePromise.
+ * The body function will be called.
+ * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
+ * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
+ * Signature: function(
+ * module: Module,
+ * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise<any[]> & () => void,
+ * hasAwaitAfterDependencies?: boolean
+ * ) => void
+ */
+exports.asyncModule = "__webpack_require__.a";
 
 
 /***/ }),
 
-/***/ 52801:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 16963:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -65892,1057 +60203,1718 @@ exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
 
 
 
-const memoize = __webpack_require__(78676);
+const { RawSource } = __webpack_require__(51255);
+const OriginalSource = (__webpack_require__(51255).OriginalSource);
+const Module = __webpack_require__(73208);
 
-const getBrowserslistTargetHandler = memoize(() =>
-	__webpack_require__(43950)
-);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/**
- * @param {string} context the context directory
- * @returns {string} default target
- */
-const getDefaultTarget = context => {
-	const browsers = getBrowserslistTargetHandler().load(null, context);
-	return browsers ? "browserslist" : "web";
-};
+const TYPES = new Set(["runtime"]);
 
-/**
- * @typedef {Object} PlatformTargetProperties
- * @property {boolean | null} web web platform, importing of http(s) and std: is available
- * @property {boolean | null} browser browser platform, running in a normal web browser
- * @property {boolean | null} webworker (Web)Worker platform, running in a web/shared/service worker
- * @property {boolean | null} node node platform, require of node built-in modules is available
- * @property {boolean | null} nwjs nwjs platform, require of legacy nw.gui is available
- * @property {boolean | null} electron electron platform, require of some electron built-in modules is available
- */
+class RuntimeModule extends Module {
+	/**
+	 * @param {string} name a readable name
+	 * @param {number=} stage an optional stage
+	 */
+	constructor(name, stage = 0) {
+		super("runtime");
+		this.name = name;
+		this.stage = stage;
+		this.buildMeta = {};
+		this.buildInfo = {};
+		/** @type {Compilation} */
+		this.compilation = undefined;
+		/** @type {Chunk} */
+		this.chunk = undefined;
+		/** @type {ChunkGraph} */
+		this.chunkGraph = undefined;
+		this.fullHash = false;
+		this.dependentHash = false;
+		/** @type {string} */
+		this._cachedGeneratedCode = undefined;
+	}
+
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	attach(compilation, chunk, chunkGraph = compilation.chunkGraph) {
+		this.compilation = compilation;
+		this.chunk = chunk;
+		this.chunkGraph = chunkGraph;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `webpack/runtime/${this.name}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `webpack/runtime/${this.name}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, false);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		// do nothing
+		// should not be called as runtime modules are added later to the compilation
+		callback();
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(this.name);
+		hash.update(`${this.stage}`);
+		try {
+			if (this.fullHash || this.dependentHash) {
+				// Do not use getGeneratedCode here, because i. e. compilation hash might be not
+				// ready at this point. We will cache it later instead.
+				hash.update(this.generate());
+			} else {
+				hash.update(this.getGeneratedCode());
+			}
+		} catch (err) {
+			hash.update(err.message);
+		}
+		super.updateHash(hash, context);
+	}
+
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		const sources = new Map();
+		const generatedCode = this.getGeneratedCode();
+		if (generatedCode) {
+			sources.set(
+				"runtime",
+				this.useSourceMap || this.useSimpleSourceMap
+					? new OriginalSource(generatedCode, this.identifier())
+					: new RawSource(generatedCode)
+			);
+		}
+		return {
+			sources,
+			runtimeRequirements: null
+		};
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		try {
+			const source = this.getGeneratedCode();
+			return source ? source.length : 0;
+		} catch (e) {
+			return 0;
+		}
+	}
+
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	getGeneratedCode() {
+		if (this._cachedGeneratedCode) {
+			return this._cachedGeneratedCode;
+		}
+		return (this._cachedGeneratedCode = this.generate());
+	}
+
+	/**
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return true;
+	}
+}
 
 /**
- * @typedef {Object} ElectronContextTargetProperties
- * @property {boolean | null} electronMain in main context
- * @property {boolean | null} electronPreload in preload context
- * @property {boolean | null} electronRenderer in renderer context with node integration
+ * Runtime modules without any dependencies to other runtime modules
+ */
+RuntimeModule.STAGE_NORMAL = 0;
+
+/**
+ * Runtime modules with simple dependencies on other runtime modules
  */
+RuntimeModule.STAGE_BASIC = 5;
 
 /**
- * @typedef {Object} ApiTargetProperties
- * @property {boolean | null} require has require function available
- * @property {boolean | null} nodeBuiltins has node.js built-in modules available
- * @property {boolean | null} document has document available (allows script tags)
- * @property {boolean | null} importScripts has importScripts available
- * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
- * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
- * @property {boolean | null} global has global variable available
+ * Runtime modules which attach to handlers of other runtime modules
  */
+RuntimeModule.STAGE_ATTACH = 10;
 
 /**
- * @typedef {Object} EcmaTargetProperties
- * @property {boolean | null} globalThis has globalThis variable available
- * @property {boolean | null} bigIntLiteral big int literal syntax is available
- * @property {boolean | null} const const and let variable declarations are available
- * @property {boolean | null} arrowFunction arrow functions are available
- * @property {boolean | null} forOf for of iteration is available
- * @property {boolean | null} destructuring destructuring is available
- * @property {boolean | null} dynamicImport async import() is available
- * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
- * @property {boolean | null} module ESM syntax is available (when in module)
- * @property {boolean | null} optionalChaining optional chaining is available
- * @property {boolean | null} templateLiteral template literal is available
+ * Runtime modules which trigger actions on bootstrap
  */
+RuntimeModule.STAGE_TRIGGER = 20;
 
-///** @typedef {PlatformTargetProperties | ApiTargetProperties | EcmaTargetProperties | PlatformTargetProperties & ApiTargetProperties | PlatformTargetProperties & EcmaTargetProperties | ApiTargetProperties & EcmaTargetProperties} TargetProperties */
-/** @template T @typedef {{ [P in keyof T]?: never }} Never<T> */
-/** @template A @template B @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A,B> */
-/** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
+module.exports = RuntimeModule;
 
-const versionDependent = (major, minor) => {
-	if (!major) return () => /** @type {undefined} */ (undefined);
-	major = +major;
-	minor = minor ? +minor : 0;
-	return (vMajor, vMinor = 0) => {
-		return major > vMajor || (major === vMajor && minor >= vMinor);
-	};
+
+/***/ }),
+
+/***/ 2307:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const { getChunkFilenameTemplate } = __webpack_require__(47283);
+const RuntimeRequirementsDependency = __webpack_require__(24187);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const AsyncModuleRuntimeModule = __webpack_require__(63672);
+const AutoPublicPathRuntimeModule = __webpack_require__(66532);
+const CompatGetDefaultExportRuntimeModule = __webpack_require__(44793);
+const CompatRuntimeModule = __webpack_require__(88234);
+const CreateFakeNamespaceObjectRuntimeModule = __webpack_require__(94669);
+const CreateScriptRuntimeModule = __webpack_require__(2759);
+const CreateScriptUrlRuntimeModule = __webpack_require__(21213);
+const DefinePropertyGettersRuntimeModule = __webpack_require__(75481);
+const EnsureChunkRuntimeModule = __webpack_require__(71519);
+const GetChunkFilenameRuntimeModule = __webpack_require__(34277);
+const GetMainFilenameRuntimeModule = __webpack_require__(10029);
+const GetTrustedTypesPolicyRuntimeModule = __webpack_require__(38713);
+const GlobalRuntimeModule = __webpack_require__(23255);
+const HasOwnPropertyRuntimeModule = __webpack_require__(8011);
+const LoadScriptRuntimeModule = __webpack_require__(19942);
+const MakeNamespaceObjectRuntimeModule = __webpack_require__(65714);
+const OnChunksLoadedRuntimeModule = __webpack_require__(44518);
+const PublicPathRuntimeModule = __webpack_require__(56030);
+const RelativeUrlRuntimeModule = __webpack_require__(4537);
+const RuntimeIdRuntimeModule = __webpack_require__(97115);
+const SystemContextRuntimeModule = __webpack_require__(80655);
+const ShareRuntimeModule = __webpack_require__(96066);
+const StringXor = __webpack_require__(40293);
+
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+
+const GLOBALS_ON_REQUIRE = [
+	RuntimeGlobals.chunkName,
+	RuntimeGlobals.runtimeId,
+	RuntimeGlobals.compatGetDefaultExport,
+	RuntimeGlobals.createFakeNamespaceObject,
+	RuntimeGlobals.createScript,
+	RuntimeGlobals.createScriptUrl,
+	RuntimeGlobals.getTrustedTypesPolicy,
+	RuntimeGlobals.definePropertyGetters,
+	RuntimeGlobals.ensureChunk,
+	RuntimeGlobals.entryModuleId,
+	RuntimeGlobals.getFullHash,
+	RuntimeGlobals.global,
+	RuntimeGlobals.makeNamespaceObject,
+	RuntimeGlobals.moduleCache,
+	RuntimeGlobals.moduleFactories,
+	RuntimeGlobals.moduleFactoriesAddOnly,
+	RuntimeGlobals.interceptModuleExecution,
+	RuntimeGlobals.publicPath,
+	RuntimeGlobals.baseURI,
+	RuntimeGlobals.relativeUrl,
+	RuntimeGlobals.scriptNonce,
+	RuntimeGlobals.uncaughtErrorHandler,
+	RuntimeGlobals.asyncModule,
+	RuntimeGlobals.wasmInstances,
+	RuntimeGlobals.instantiateWasm,
+	RuntimeGlobals.shareScopeMap,
+	RuntimeGlobals.initializeSharing,
+	RuntimeGlobals.loadScript,
+	RuntimeGlobals.systemContext,
+	RuntimeGlobals.onChunksLoaded
+];
+
+const MODULE_DEPENDENCIES = {
+	[RuntimeGlobals.moduleLoaded]: [RuntimeGlobals.module],
+	[RuntimeGlobals.moduleId]: [RuntimeGlobals.module]
 };
 
-/** @type {[string, string, RegExp, (...args: string[]) => TargetProperties | false][]} */
-const TARGETS = [
-	[
-		"browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
-		"Resolve features from browserslist. Will resolve browserslist config automatically. Only browser or node queries are supported (electron is not supported). Examples: 'browserslist:modern' to use 'modern' environment from browserslist config",
-		/^browserslist(?::(.+))?$/,
-		(rest, context) => {
-			const browserslistTargetHandler = getBrowserslistTargetHandler();
-			const browsers = browserslistTargetHandler.load(
-				rest ? rest.trim() : null,
-				context
+const TREE_DEPENDENCIES = {
+	[RuntimeGlobals.definePropertyGetters]: [RuntimeGlobals.hasOwnProperty],
+	[RuntimeGlobals.compatGetDefaultExport]: [
+		RuntimeGlobals.definePropertyGetters
+	],
+	[RuntimeGlobals.createFakeNamespaceObject]: [
+		RuntimeGlobals.definePropertyGetters,
+		RuntimeGlobals.makeNamespaceObject,
+		RuntimeGlobals.require
+	],
+	[RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
+	[RuntimeGlobals.shareScopeMap]: [RuntimeGlobals.hasOwnProperty]
+};
+
+class RuntimePlugin {
+	/**
+	 * @param {Compiler} compiler the Compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RuntimePlugin", compilation => {
+			compilation.dependencyTemplates.set(
+				RuntimeRequirementsDependency,
+				new RuntimeRequirementsDependency.Template()
 			);
-			if (!browsers) {
-				throw new Error(`No browserslist config found to handle the 'browserslist' target.
-See https://github.com/browserslist/browserslist#queries for possible ways to provide a config.
-The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
-You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
+			for (const req of GLOBALS_ON_REQUIRE) {
+				compilation.hooks.runtimeRequirementInModule
+					.for(req)
+					.tap("RuntimePlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(req)
+					.tap("RuntimePlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
 			}
-			return browserslistTargetHandler.resolve(browsers);
-		}
-	],
-	[
-		"web",
-		"Web browser.",
-		/^web$/,
-		() => {
-			return {
-				web: true,
-				browser: true,
-				webworker: null,
-				node: false,
-				electron: false,
-				nwjs: false,
+			for (const req of Object.keys(TREE_DEPENDENCIES)) {
+				const deps = TREE_DEPENDENCIES[req];
+				compilation.hooks.runtimeRequirementInTree
+					.for(req)
+					.tap("RuntimePlugin", (chunk, set) => {
+						for (const dep of deps) set.add(dep);
+					});
+			}
+			for (const req of Object.keys(MODULE_DEPENDENCIES)) {
+				const deps = MODULE_DEPENDENCIES[req];
+				compilation.hooks.runtimeRequirementInModule
+					.for(req)
+					.tap("RuntimePlugin", (chunk, set) => {
+						for (const dep of deps) set.add(dep);
+					});
+			}
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.definePropertyGetters)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new DefinePropertyGettersRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.makeNamespaceObject)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new MakeNamespaceObjectRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createFakeNamespaceObject)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new CreateFakeNamespaceObjectRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hasOwnProperty)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new HasOwnPropertyRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.compatGetDefaultExport)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new CompatGetDefaultExportRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.runtimeId)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.publicPath)
+				.tap("RuntimePlugin", (chunk, set) => {
+					const { outputOptions } = compilation;
+					const { publicPath: globalPublicPath, scriptType } = outputOptions;
+					const entryOptions = chunk.getEntryOptions();
+					const publicPath =
+						entryOptions && entryOptions.publicPath !== undefined
+							? entryOptions.publicPath
+							: globalPublicPath;
+
+					if (publicPath === "auto") {
+						const module = new AutoPublicPathRuntimeModule();
+						if (scriptType !== "module") set.add(RuntimeGlobals.global);
+						compilation.addRuntimeModule(chunk, module);
+					} else {
+						const module = new PublicPathRuntimeModule(publicPath);
+
+						if (
+							typeof publicPath !== "string" ||
+							/\[(full)?hash\]/.test(publicPath)
+						) {
+							module.fullHash = true;
+						}
+
+						compilation.addRuntimeModule(chunk, module);
+					}
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.global)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new GlobalRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.asyncModule)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new AsyncModuleRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.systemContext)
+				.tap("RuntimePlugin", chunk => {
+					const { outputOptions } = compilation;
+					const { library: globalLibrary } = outputOptions;
+					const entryOptions = chunk.getEntryOptions();
+					const libraryType =
+						entryOptions && entryOptions.library !== undefined
+							? entryOptions.library.type
+							: globalLibrary.type;
+
+					if (libraryType === "system") {
+						compilation.addRuntimeModule(
+							chunk,
+							new SystemContextRuntimeModule()
+						);
+					}
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getChunkScriptFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						typeof compilation.outputOptions.chunkFilename === "string" &&
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.chunkFilename
+						)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new GetChunkFilenameRuntimeModule(
+							"javascript",
+							"javascript",
+							RuntimeGlobals.getChunkScriptFilename,
+							chunk =>
+								chunk.filenameTemplate ||
+								(chunk.canBeInitial()
+									? compilation.outputOptions.filename
+									: compilation.outputOptions.chunkFilename),
+							false
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getChunkCssFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						typeof compilation.outputOptions.cssChunkFilename === "string" &&
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.cssChunkFilename
+						)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new GetChunkFilenameRuntimeModule(
+							"css",
+							"css",
+							RuntimeGlobals.getChunkCssFilename,
+							chunk =>
+								getChunkFilenameTemplate(chunk, compilation.outputOptions),
+							set.has(RuntimeGlobals.hmrDownloadUpdateHandlers)
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getChunkUpdateScriptFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.hotUpdateChunkFilename
+						)
+					)
+						set.add(RuntimeGlobals.getFullHash);
+					compilation.addRuntimeModule(
+						chunk,
+						new GetChunkFilenameRuntimeModule(
+							"javascript",
+							"javascript update",
+							RuntimeGlobals.getChunkUpdateScriptFilename,
+							c => compilation.outputOptions.hotUpdateChunkFilename,
+							true
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getUpdateManifestFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.hotUpdateMainFilename
+						)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new GetMainFilenameRuntimeModule(
+							"update manifest",
+							RuntimeGlobals.getUpdateManifestFilename,
+							compilation.outputOptions.hotUpdateMainFilename
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunk)
+				.tap("RuntimePlugin", (chunk, set) => {
+					const hasAsyncChunks = chunk.hasAsyncChunks();
+					if (hasAsyncChunks) {
+						set.add(RuntimeGlobals.ensureChunkHandlers);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new EnsureChunkRuntimeModule(set)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkIncludeEntries)
+				.tap("RuntimePlugin", (chunk, set) => {
+					set.add(RuntimeGlobals.ensureChunkHandlers);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.shareScopeMap)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(chunk, new ShareRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.loadScript)
+				.tap("RuntimePlugin", (chunk, set) => {
+					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+					if (withCreateScriptUrl) {
+						set.add(RuntimeGlobals.createScriptUrl);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new LoadScriptRuntimeModule(withCreateScriptUrl)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createScript)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (compilation.outputOptions.trustedTypes) {
+						set.add(RuntimeGlobals.getTrustedTypesPolicy);
+					}
+					compilation.addRuntimeModule(chunk, new CreateScriptRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createScriptUrl)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (compilation.outputOptions.trustedTypes) {
+						set.add(RuntimeGlobals.getTrustedTypesPolicy);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new CreateScriptUrlRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getTrustedTypesPolicy)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new GetTrustedTypesPolicyRuntimeModule(set)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.relativeUrl)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new OnChunksLoadedRuntimeModule()
+					);
+					return true;
+				});
+			// TODO webpack 6: remove CompatRuntimeModule
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				"RuntimePlugin",
+				(chunk, set) => {
+					const { mainTemplate } = compilation;
+					if (
+						mainTemplate.hooks.bootstrap.isUsed() ||
+						mainTemplate.hooks.localVars.isUsed() ||
+						mainTemplate.hooks.requireEnsure.isUsed() ||
+						mainTemplate.hooks.requireExtensions.isUsed()
+					) {
+						compilation.addRuntimeModule(chunk, new CompatRuntimeModule());
+					}
+				}
+			);
+			JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(
+				"RuntimePlugin",
+				(chunk, hash, { chunkGraph }) => {
+					const xor = new StringXor();
+					for (const m of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
+						xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+					}
+					xor.updateHash(hash);
+				}
+			);
+		});
+	}
+}
+module.exports = RuntimePlugin;
 
-				document: true,
-				importScriptsInWorker: true,
-				fetchWasm: true,
-				nodeBuiltins: false,
-				importScripts: false,
-				require: false,
-				global: false
-			};
-		}
-	],
-	[
-		"webworker",
-		"Web Worker, SharedWorker or Service Worker.",
-		/^webworker$/,
-		() => {
-			return {
-				web: true,
-				browser: true,
-				webworker: true,
-				node: false,
-				electron: false,
-				nwjs: false,
 
-				importScripts: true,
-				importScriptsInWorker: true,
-				fetchWasm: true,
-				nodeBuiltins: false,
-				require: false,
-				document: false,
-				global: false
-			};
-		}
-	],
-	[
-		"[async-]node[X[.Y]]",
-		"Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
-		/^(async-)?node(\d+(?:\.(\d+))?)?$/,
-		(asyncFlag, major, minor) => {
-			const v = versionDependent(major, minor);
-			// see https://node.green/
-			return {
-				node: true,
-				electron: false,
-				nwjs: false,
-				web: false,
-				webworker: false,
-				browser: false,
+/***/ }),
 
-				require: !asyncFlag,
-				nodeBuiltins: true,
-				global: true,
-				document: false,
-				fetchWasm: false,
-				importScripts: false,
-				importScriptsInWorker: false,
+/***/ 18777:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				globalThis: v(12),
-				const: v(6),
-				templateLiteral: v(4),
-				optionalChaining: v(14),
-				arrowFunction: v(6),
-				forOf: v(5),
-				destructuring: v(6),
-				bigIntLiteral: v(10, 4),
-				dynamicImport: v(12, 17),
-				dynamicImportInWorker: major ? false : undefined,
-				module: v(12, 17)
-			};
-		}
-	],
-	[
-		"electron[X[.Y]]-main/preload/renderer",
-		"Electron in version X.Y. Script is running in main, preload resp. renderer context.",
-		/^electron(\d+(?:\.(\d+))?)?-(main|preload|renderer)$/,
-		(major, minor, context) => {
-			const v = versionDependent(major, minor);
-			// see https://node.green/ + https://github.com/electron/releases
-			return {
-				node: true,
-				electron: true,
-				web: context !== "main",
-				webworker: false,
-				browser: false,
-				nwjs: false,
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				electronMain: context === "main",
-				electronPreload: context === "preload",
-				electronRenderer: context === "renderer",
 
-				global: true,
-				nodeBuiltins: true,
-				require: true,
-				document: context === "renderer",
-				fetchWasm: context === "renderer",
-				importScripts: false,
-				importScriptsInWorker: true,
 
-				globalThis: v(5),
-				const: v(1, 1),
-				templateLiteral: v(1, 1),
-				optionalChaining: v(8),
-				arrowFunction: v(1, 1),
-				forOf: v(0, 36),
-				destructuring: v(1, 1),
-				bigIntLiteral: v(4),
-				dynamicImport: v(11),
-				dynamicImportInWorker: major ? false : undefined,
-				module: v(11)
-			};
-		}
-	],
-	[
-		"nwjs[X[.Y]] / node-webkit[X[.Y]]",
-		"NW.js in version X.Y.",
-		/^(?:nwjs|node-webkit)(\d+(?:\.(\d+))?)?$/,
-		(major, minor) => {
-			const v = versionDependent(major, minor);
-			// see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
-			return {
-				node: true,
-				web: true,
-				nwjs: true,
-				webworker: null,
-				browser: false,
-				electron: false,
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const { equals } = __webpack_require__(84953);
+const compileBooleanMatcher = __webpack_require__(29404);
+const propertyAccess = __webpack_require__(54190);
+const { forEachRuntime, subtractRuntime } = __webpack_require__(17156);
 
-				global: true,
-				nodeBuiltins: true,
-				document: false,
-				importScriptsInWorker: false,
-				fetchWasm: false,
-				importScripts: false,
-				require: false,
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-				globalThis: v(0, 43),
-				const: v(0, 15),
-				templateLiteral: v(0, 13),
-				optionalChaining: v(0, 44),
-				arrowFunction: v(0, 15),
-				forOf: v(0, 13),
-				destructuring: v(0, 15),
-				bigIntLiteral: v(0, 32),
-				dynamicImport: v(0, 43),
-				dynamicImportInWorker: major ? false : undefined,
-				module: v(0, 43)
-			};
-		}
-	],
-	[
-		"esX",
-		"EcmaScript in this version. Examples: es2020, es5.",
-		/^es(\d+)$/,
-		version => {
-			let v = +version;
-			if (v < 1000) v = v + 2009;
-			return {
-				const: v >= 2015,
-				templateLiteral: v >= 2015,
-				optionalChaining: v >= 2020,
-				arrowFunction: v >= 2015,
-				forOf: v >= 2015,
-				destructuring: v >= 2015,
-				module: v >= 2015,
-				globalThis: v >= 2020,
-				bigIntLiteral: v >= 2020,
-				dynamicImport: v >= 2020,
-				dynamicImportInWorker: v >= 2020
-			};
-		}
-	]
-];
+/**
+ * @param {Module} module the module
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {string} error message
+ */
+const noModuleIdErrorMessage = (module, chunkGraph) => {
+	return `Module ${module.identifier()} has no id assigned.
+This should not happen.
+It's in these chunks: ${
+		Array.from(
+			chunkGraph.getModuleChunksIterable(module),
+			c => c.name || c.id || c.debugId
+		).join(", ") || "none"
+	} (If module is in no chunk this indicates a bug in some chunk/module optimization logic)
+Module has these incoming connections: ${Array.from(
+		chunkGraph.moduleGraph.getIncomingConnections(module),
+		connection =>
+			`\n - ${
+				connection.originModule && connection.originModule.identifier()
+			} ${connection.dependency && connection.dependency.type} ${
+				(connection.explanations &&
+					Array.from(connection.explanations).join(", ")) ||
+				""
+			}`
+	).join("")}`;
+};
 
 /**
- * @param {string} target the target
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
+ * @param {string|undefined} definition global object definition
+ * @returns {string} save to use global object
  */
-const getTargetProperties = (target, context) => {
-	for (const [, , regExp, handler] of TARGETS) {
-		const match = regExp.exec(target);
-		if (match) {
-			const [, ...args] = match;
-			const result = handler(...args, context);
-			if (result) return result;
-		}
+function getGlobalObject(definition) {
+	if (!definition) return definition;
+	const trimmed = definition.trim();
+
+	if (
+		// identifier, we do not need real identifier regarding ECMAScript/Unicode
+		trimmed.match(/^[_\p{L}][_0-9\p{L}]*$/iu) ||
+		// iife
+		// call expression
+		// expression in parentheses
+		trimmed.match(/^([_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu)
+	)
+		return trimmed;
+
+	return `Object(${trimmed})`;
+}
+
+class RuntimeTemplate {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @param {OutputOptions} outputOptions the compilation output options
+	 * @param {RequestShortener} requestShortener the request shortener
+	 */
+	constructor(compilation, outputOptions, requestShortener) {
+		this.compilation = compilation;
+		this.outputOptions = outputOptions || {};
+		this.requestShortener = requestShortener;
+		this.globalObject = getGlobalObject(outputOptions.globalObject);
 	}
-	throw new Error(
-		`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(
-			([name, description]) => `* ${name}: ${description}`
-		).join("\n")}`
-	);
-};
 
-const mergeTargetProperties = targetProperties => {
-	const keys = new Set();
-	for (const tp of targetProperties) {
-		for (const key of Object.keys(tp)) {
-			keys.add(key);
-		}
+	isIIFE() {
+		return this.outputOptions.iife;
 	}
-	const result = {};
-	for (const key of keys) {
-		let hasTrue = false;
-		let hasFalse = false;
-		for (const tp of targetProperties) {
-			const value = tp[key];
-			switch (value) {
-				case true:
-					hasTrue = true;
-					break;
-				case false:
-					hasFalse = true;
-					break;
-			}
-		}
-		if (hasTrue || hasFalse)
-			result[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
+
+	isModule() {
+		return this.outputOptions.module;
 	}
-	return /** @type {TargetProperties} */ (result);
-};
 
-/**
- * @param {string[]} targets the targets
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
- */
-const getTargetsProperties = (targets, context) => {
-	return mergeTargetProperties(
-		targets.map(t => getTargetProperties(t, context))
-	);
-};
+	supportsConst() {
+		return this.outputOptions.environment.const;
+	}
 
-exports.getDefaultTarget = getDefaultTarget;
-exports.getTargetProperties = getTargetProperties;
-exports.getTargetsProperties = getTargetsProperties;
+	supportsArrowFunction() {
+		return this.outputOptions.environment.arrowFunction;
+	}
 
+	supportsOptionalChaining() {
+		return this.outputOptions.environment.optionalChaining;
+	}
 
-/***/ }),
+	supportsForOf() {
+		return this.outputOptions.environment.forOf;
+	}
 
-/***/ 64813:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	supportsDestructuring() {
+		return this.outputOptions.environment.destructuring;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
+	supportsBigIntLiteral() {
+		return this.outputOptions.environment.bigIntLiteral;
+	}
 
+	supportsDynamicImport() {
+		return this.outputOptions.environment.dynamicImport;
+	}
 
+	supportsEcmaScriptModuleSyntax() {
+		return this.outputOptions.environment.module;
+	}
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
+	supportTemplateLiteral() {
+		return this.outputOptions.environment.templateLiteral;
+	}
 
-/** @typedef {import("./ContainerEntryModule").ExposeOptions} ExposeOptions */
+	returningFunction(returnValue, args = "") {
+		return this.supportsArrowFunction()
+			? `(${args}) => (${returnValue})`
+			: `function(${args}) { return ${returnValue}; }`;
+	}
 
-class ContainerEntryDependency extends Dependency {
-	/**
-	 * @param {string} name entry name
-	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
-	 * @param {string} shareScope name of the share scope
-	 */
-	constructor(name, exposes, shareScope) {
-		super();
-		this.name = name;
-		this.exposes = exposes;
-		this.shareScope = shareScope;
+	basicFunction(args, body) {
+		return this.supportsArrowFunction()
+			? `(${args}) => {\n${Template.indent(body)}\n}`
+			: `function(${args}) {\n${Template.indent(body)}\n}`;
 	}
 
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * @param {Array<string|{expr: string}>} args args
+	 * @returns {string} result expression
 	 */
-	getResourceIdentifier() {
-		return `container-entry-${this.name}`;
-	}
+	concatenation(...args) {
+		const len = args.length;
 
-	get type() {
-		return "container entry";
-	}
+		if (len === 2) return this._es5Concatenation(args);
+		if (len === 0) return '""';
+		if (len === 1) {
+			return typeof args[0] === "string"
+				? JSON.stringify(args[0])
+				: `"" + ${args[0].expr}`;
+		}
+		if (!this.supportTemplateLiteral()) return this._es5Concatenation(args);
 
-	get category() {
-		return "esm";
-	}
-}
+		// cost comparison between template literal and concatenation:
+		// both need equal surroundings: `xxx` vs "xxx"
+		// template literal has constant cost of 3 chars for each expression
+		// es5 concatenation has cost of 3 + n chars for n expressions in row
+		// when a es5 concatenation ends with an expression it reduces cost by 3
+		// when a es5 concatenation starts with an single expression it reduces cost by 3
+		// e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
+		// e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
 
-makeSerializable(
-	ContainerEntryDependency,
-	"webpack/lib/container/ContainerEntryDependency"
-);
+		let templateCost = 0;
+		let concatenationCost = 0;
 
-module.exports = ContainerEntryDependency;
+		let lastWasExpr = false;
+		for (const arg of args) {
+			const isExpr = typeof arg !== "string";
+			if (isExpr) {
+				templateCost += 3;
+				concatenationCost += lastWasExpr ? 1 : 4;
+			}
+			lastWasExpr = isExpr;
+		}
+		if (lastWasExpr) concatenationCost -= 3;
+		if (typeof args[0] !== "string" && typeof args[1] === "string")
+			concatenationCost -= 3;
 
+		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
 
-/***/ }),
+		return `\`${args
+			.map(arg => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
+			.join("")}\``;
+	}
 
-/***/ 80580:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Array<string|{expr: string}>} args args (len >= 2)
+	 * @returns {string} result expression
+	 * @private
+	 */
+	_es5Concatenation(args) {
+		const str = args
+			.map(arg => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
+			.join(" + ");
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
+		// when the first two args are expression, we need to prepend "" + to force string
+		// concatenation instead of number addition.
+		return typeof args[0] !== "string" && typeof args[1] !== "string"
+			? `"" + ${str}`
+			: str;
+	}
+
+	expressionFunction(expression, args = "") {
+		return this.supportsArrowFunction()
+			? `(${args}) => (${expression})`
+			: `function(${args}) { ${expression}; }`;
+	}
 
+	emptyFunction() {
+		return this.supportsArrowFunction() ? "x => {}" : "function() {}";
+	}
 
+	destructureArray(items, value) {
+		return this.supportsDestructuring()
+			? `var [${items.join(", ")}] = ${value};`
+			: Template.asString(
+					items.map((item, i) => `var ${item} = ${value}[${i}];`)
+			  );
+	}
 
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const StaticExportsDependency = __webpack_require__(91418);
-const makeSerializable = __webpack_require__(33032);
-const ContainerExposedDependency = __webpack_require__(72374);
+	destructureObject(items, value) {
+		return this.supportsDestructuring()
+			? `var {${items.join(", ")}} = ${value};`
+			: Template.asString(
+					items.map(item => `var ${item} = ${value}${propertyAccess([item])};`)
+			  );
+	}
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
+	iife(args, body) {
+		return `(${this.basicFunction(args, body)})()`;
+	}
 
-/**
- * @typedef {Object} ExposeOptions
- * @property {string[]} import requests to exposed modules (last one is exported)
- * @property {string} name custom chunk name for the exposed module
- */
+	forEach(variable, array, body) {
+		return this.supportsForOf()
+			? `for(const ${variable} of ${array}) {\n${Template.indent(body)}\n}`
+			: `${array}.forEach(function(${variable}) {\n${Template.indent(
+					body
+			  )}\n});`;
+	}
 
-const SOURCE_TYPES = new Set(["javascript"]);
+	/**
+	 * Add a comment
+	 * @param {object} options Information content of the comment
+	 * @param {string=} options.request request string used originally
+	 * @param {string=} options.chunkName name of the chunk referenced
+	 * @param {string=} options.chunkReason reason information of the chunk
+	 * @param {string=} options.message additional message
+	 * @param {string=} options.exportName name of the export
+	 * @returns {string} comment
+	 */
+	comment({ request, chunkName, chunkReason, message, exportName }) {
+		let content;
+		if (this.outputOptions.pathinfo) {
+			content = [message, request, chunkName, chunkReason]
+				.filter(Boolean)
+				.map(item => this.requestShortener.shorten(item))
+				.join(" | ");
+		} else {
+			content = [message, chunkName, chunkReason]
+				.filter(Boolean)
+				.map(item => this.requestShortener.shorten(item))
+				.join(" | ");
+		}
+		if (!content) return "";
+		if (this.outputOptions.pathinfo) {
+			return Template.toComment(content) + " ";
+		} else {
+			return Template.toNormalComment(content) + " ";
+		}
+	}
 
-class ContainerEntryModule extends Module {
 	/**
-	 * @param {string} name container entry name
-	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
-	 * @param {string} shareScope name of the share scope
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error block
 	 */
-	constructor(name, exposes, shareScope) {
-		super("javascript/dynamic", null);
-		this._name = name;
-		this._exposes = exposes;
-		this._shareScope = shareScope;
+	throwMissingModuleErrorBlock({ request }) {
+		const err = `Cannot find module '${request}'`;
+		return `var e = new Error(${JSON.stringify(
+			err
+		)}); e.code = 'MODULE_NOT_FOUND'; throw e;`;
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error function
 	 */
-	getSourceTypes() {
-		return SOURCE_TYPES;
+	throwMissingModuleErrorFunction({ request }) {
+		return `function webpackMissingModule() { ${this.throwMissingModuleErrorBlock(
+			{ request }
+		)} }`;
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error IIFE
 	 */
-	identifier() {
-		return `container entry (${this._shareScope}) ${JSON.stringify(
-			this._exposes
-		)}`;
+	missingModule({ request }) {
+		return `Object(${this.throwMissingModuleErrorFunction({ request })}())`;
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error statement
 	 */
-	readableIdentifier(requestShortener) {
-		return `container entry`;
+	missingModuleStatement({ request }) {
+		return `${this.missingModule({ request })};\n`;
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error code
 	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/entry/${
-			this._name
-		}`;
+	missingModulePromise({ request }) {
+		return `Promise.resolve().then(${this.throwMissingModuleErrorFunction({
+			request
+		})})`;
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Module} options.module the module
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {string=} options.idExpr expression to use as id expression
+	 * @param {"expression" | "promise" | "statements"} options.type which kind of code should be returned
+	 * @returns {string} the code
 	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
+	weakError({ module, chunkGraph, request, idExpr, type }) {
+		const moduleId = chunkGraph.getModuleId(module);
+		const errorMessage =
+			moduleId === null
+				? JSON.stringify("Module is not available (weak dependency)")
+				: idExpr
+				? `"Module '" + ${idExpr} + "' is not available (weak dependency)"`
+				: JSON.stringify(
+						`Module '${moduleId}' is not available (weak dependency)`
+				  );
+		const comment = request ? Template.toNormalComment(request) + " " : "";
+		const errorStatements =
+			`var e = new Error(${errorMessage}); ` +
+			comment +
+			"e.code = 'MODULE_NOT_FOUND'; throw e;";
+		switch (type) {
+			case "statements":
+				return errorStatements;
+			case "promise":
+				return `Promise.resolve().then(${this.basicFunction(
+					"",
+					errorStatements
+				)})`;
+			case "expression":
+				return this.iife("", errorStatements);
+		}
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @returns {string} the expression
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true,
-			topLevelDeclarations: new Set(["moduleMap", "get", "init"])
-		};
-		this.buildMeta.exportsType = "namespace";
-
-		this.clearDependenciesAndBlocks();
-
-		for (const [name, options] of this._exposes) {
-			const block = new AsyncDependenciesBlock(
-				{
-					name: options.name
-				},
-				{ name },
-				options.import[options.import.length - 1]
+	moduleId({ module, chunkGraph, request, weak }) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
+		}
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId === null) {
+			if (weak) {
+				return "null /* weak dependency, without id */";
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
 			);
-			let idx = 0;
-			for (const request of options.import) {
-				const dep = new ContainerExposedDependency(name, request);
-				dep.loc = {
-					name,
-					index: idx++
-				};
+		}
+		return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
+	}
 
-				block.addDependency(dep);
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the expression
+	 */
+	moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
+		}
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return this.weakError({
+					module,
+					chunkGraph,
+					request,
+					type: "expression"
+				});
 			}
-			this.addBlock(block);
+			throw new Error(
+				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
+			);
 		}
-		this.addDependency(new StaticExportsDependency(["get", "init"], false));
-
-		callback();
+		runtimeRequirements.add(RuntimeGlobals.require);
+		return `__webpack_require__(${this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		})})`;
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the expression
 	 */
-	codeGeneration({ moduleGraph, chunkGraph, runtimeTemplate }) {
-		const sources = new Map();
-		const runtimeRequirements = new Set([
-			RuntimeGlobals.definePropertyGetters,
-			RuntimeGlobals.hasOwnProperty,
-			RuntimeGlobals.exports
-		]);
-		const getters = [];
-
-		for (const block of this.blocks) {
-			const { dependencies } = block;
+	moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }) {
+		return this.moduleRaw({
+			module,
+			chunkGraph,
+			request,
+			weak,
+			runtimeRequirements
+		});
+	}
 
-			const modules = dependencies.map(dependency => {
-				const dep = /** @type {ContainerExposedDependency} */ (dependency);
-				return {
-					name: dep.exposedName,
-					module: moduleGraph.getModule(dep),
-					request: dep.userRequest
-				};
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.strict if the current module is in strict esm mode
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the expression
+	 */
+	moduleNamespace({
+		module,
+		chunkGraph,
+		request,
+		strict,
+		weak,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return this.missingModule({
+				request
 			});
-
-			let str;
-
-			if (modules.some(m => !m.module)) {
-				str = runtimeTemplate.throwMissingModuleErrorBlock({
-					request: modules.map(m => m.request).join(", ")
+		}
+		if (chunkGraph.getModuleId(module) === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return this.weakError({
+					module,
+					chunkGraph,
+					request,
+					type: "expression"
 				});
-			} else {
-				str = `return ${runtimeTemplate.blockPromise({
-					block,
-					message: "",
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleNamespace(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
+			);
+		}
+		const moduleId = this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		});
+		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
+		switch (exportsType) {
+			case "namespace":
+				return this.moduleRaw({
+					module,
 					chunkGraph,
+					request,
+					weak,
 					runtimeRequirements
-				})}.then(${runtimeTemplate.returningFunction(
-					runtimeTemplate.returningFunction(
-						`(${modules
-							.map(({ module, request }) =>
-								runtimeTemplate.moduleRaw({
-									module,
-									chunkGraph,
-									request,
-									weak: false,
-									runtimeRequirements
-								})
-							)
-							.join(", ")})`
-					)
-				)});`;
-			}
+				});
+			case "default-with-named":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`;
+			case "default-only":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 1)`;
+			case "dynamic":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 7)`;
+		}
+	}
 
-			getters.push(
-				`${JSON.stringify(modules[0].name)}: ${runtimeTemplate.basicFunction(
-					"",
-					str
+	/**
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {AsyncDependenciesBlock=} options.block the current dependencies block
+	 * @param {Module} options.module the module
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {string} options.message a message for the comment
+	 * @param {boolean=} options.strict if the current module is in strict esm mode
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the promise expression
+	 */
+	moduleNamespacePromise({
+		chunkGraph,
+		block,
+		module,
+		request,
+		message,
+		strict,
+		weak,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return this.missingModulePromise({
+				request
+			});
+		}
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return this.weakError({
+					module,
+					chunkGraph,
+					request,
+					type: "promise"
+				});
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleNamespacePromise(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
 				)}`
 			);
 		}
+		const promise = this.blockPromise({
+			chunkGraph,
+			block,
+			message,
+			runtimeRequirements
+		});
 
-		const source = Template.asString([
-			`var moduleMap = {`,
-			Template.indent(getters.join(",\n")),
-			"};",
-			`var get = ${runtimeTemplate.basicFunction("module, getScope", [
-				`${RuntimeGlobals.currentRemoteGetScope} = getScope;`,
-				// reusing the getScope variable to avoid creating a new var (and module is also used later)
-				"getScope = (",
-				Template.indent([
-					`${RuntimeGlobals.hasOwnProperty}(moduleMap, module)`,
-					Template.indent([
-						"? moduleMap[module]()",
-						`: Promise.resolve().then(${runtimeTemplate.basicFunction(
+		let appending;
+		let idExpr = JSON.stringify(chunkGraph.getModuleId(module));
+		const comment = this.comment({
+			request
+		});
+		let header = "";
+		if (weak) {
+			if (idExpr.length > 8) {
+				// 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"'
+				header += `var id = ${idExpr}; `;
+				idExpr = "id";
+			}
+			runtimeRequirements.add(RuntimeGlobals.moduleFactories);
+			header += `if(!${
+				RuntimeGlobals.moduleFactories
+			}[${idExpr}]) { ${this.weakError({
+				module,
+				chunkGraph,
+				request,
+				idExpr,
+				type: "statements"
+			})} } `;
+		}
+		const moduleIdExpr = this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		});
+		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
+		let fakeType = 16;
+		switch (exportsType) {
+			case "namespace":
+				if (header) {
+					const rawModule = this.moduleRaw({
+						module,
+						chunkGraph,
+						request,
+						weak,
+						runtimeRequirements
+					});
+					appending = `.then(${this.basicFunction(
+						"",
+						`${header}return ${rawModule};`
+					)})`;
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.require);
+					appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
+				}
+				break;
+			case "dynamic":
+				fakeType |= 4;
+			/* fall through */
+			case "default-with-named":
+				fakeType |= 2;
+			/* fall through */
+			case "default-only":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				if (chunkGraph.moduleGraph.isAsync(module)) {
+					if (header) {
+						const rawModule = this.moduleRaw({
+							module,
+							chunkGraph,
+							request,
+							weak,
+							runtimeRequirements
+						});
+						appending = `.then(${this.basicFunction(
 							"",
-							"throw new Error('Module \"' + module + '\" does not exist in container.');"
-						)})`
-					])
-				]),
-				");",
-				`${RuntimeGlobals.currentRemoteGetScope} = undefined;`,
-				"return getScope;"
-			])};`,
-			`var init = ${runtimeTemplate.basicFunction("shareScope, initScope", [
-				`if (!${RuntimeGlobals.shareScopeMap}) return;`,
-				`var name = ${JSON.stringify(this._shareScope)}`,
-				`var oldScope = ${RuntimeGlobals.shareScopeMap}[name];`,
-				`if(oldScope && oldScope !== shareScope) throw new Error("Container initialization failed as it has already been initialized with a different share scope");`,
-				`${RuntimeGlobals.shareScopeMap}[name] = shareScope;`,
-				`return ${RuntimeGlobals.initializeSharing}(name, initScope);`
-			])};`,
-			"",
-			"// This exports getters to disallow modifications",
-			`${RuntimeGlobals.definePropertyGetters}(exports, {`,
-			Template.indent([
-				`get: ${runtimeTemplate.returningFunction("get")},`,
-				`init: ${runtimeTemplate.returningFunction("init")}`
-			]),
-			"});"
-		]);
-
-		sources.set(
-			"javascript",
-			this.useSourceMap || this.useSimpleSourceMap
-				? new OriginalSource(source, "webpack/container-entry")
-				: new RawSource(source)
-		);
+							`${header}return ${rawModule};`
+						)})`;
+					} else {
+						runtimeRequirements.add(RuntimeGlobals.require);
+						appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
+					}
+					appending += `.then(${this.returningFunction(
+						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
+						"m"
+					)})`;
+				} else {
+					fakeType |= 1;
+					if (header) {
+						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
+						appending = `.then(${this.basicFunction(
+							"",
+							`${header}return ${returnExpression};`
+						)})`;
+					} else {
+						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(__webpack_require__, ${comment}${idExpr}, ${fakeType}))`;
+					}
+				}
+				break;
+		}
 
-		return {
-			sources,
-			runtimeRequirements
-		};
+		return `${promise || "Promise.resolve()"}${appending}`;
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
+	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
 	 */
-	size(type) {
-		return 42;
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this._name);
-		write(this._exposes);
-		write(this._shareScope);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new ContainerEntryModule(read(), read(), read());
-		obj.deserialize(context);
-		return obj;
+	runtimeConditionExpression({
+		chunkGraph,
+		runtimeCondition,
+		runtime,
+		runtimeRequirements
+	}) {
+		if (runtimeCondition === undefined) return "true";
+		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
+		/** @type {Set<string>} */
+		const positiveRuntimeIds = new Set();
+		forEachRuntime(runtimeCondition, runtime =>
+			positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		/** @type {Set<string>} */
+		const negativeRuntimeIds = new Set();
+		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
+			negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		runtimeRequirements.add(RuntimeGlobals.runtimeId);
+		return compileBooleanMatcher.fromLists(
+			Array.from(positiveRuntimeIds),
+			Array.from(negativeRuntimeIds)
+		)(RuntimeGlobals.runtimeId);
 	}
-}
-
-makeSerializable(
-	ContainerEntryModule,
-	"webpack/lib/container/ContainerEntryModule"
-);
-
-module.exports = ContainerEntryModule;
-
-
-/***/ }),
-
-/***/ 76398:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
-
-
-
-const ModuleFactory = __webpack_require__(51010);
-const ContainerEntryModule = __webpack_require__(80580);
-
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
-module.exports = class ContainerEntryModuleFactory extends ModuleFactory {
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
+	 *
+	 * @param {Object} options options object
+	 * @param {boolean=} options.update whether a new variable should be created or the existing one updated
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {string} options.importVar name of the import variable
+	 * @param {Module} options.originModule module in which the statement is emitted
+	 * @param {boolean=} options.weak true, if this is a weak dependency
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {[string, string]} the import statement and the compat statement
 	 */
-	create({ dependencies: [dependency] }, callback) {
-		const dep = /** @type {ContainerEntryDependency} */ (dependency);
-		callback(null, {
-			module: new ContainerEntryModule(dep.name, dep.exposes, dep.shareScope)
+	importStatement({
+		update,
+		module,
+		chunkGraph,
+		request,
+		importVar,
+		originModule,
+		weak,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return [
+				this.missingModuleStatement({
+					request
+				}),
+				""
+			];
+		}
+		if (chunkGraph.getModuleId(module) === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return [
+					this.weakError({
+						module,
+						chunkGraph,
+						request,
+						type: "statements"
+					}),
+					""
+				];
+			}
+			throw new Error(
+				`RuntimeTemplate.importStatement(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
+			);
+		}
+		const moduleId = this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
 		});
-	}
-};
-
-
-/***/ }),
-
-/***/ 72374:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
-
-
-
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
-
-class ContainerExposedDependency extends ModuleDependency {
-	/**
-	 * @param {string} exposedName public name
-	 * @param {string} request request to module
-	 */
-	constructor(exposedName, request) {
-		super(request);
-		this.exposedName = exposedName;
-	}
-
-	get type() {
-		return "container exposed";
-	}
-
-	get category() {
-		return "esm";
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `exposed dependency ${this.exposedName}=${this.request}`;
-	}
-
-	serialize(context) {
-		context.write(this.exposedName);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		this.exposedName = context.read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	ContainerExposedDependency,
-	"webpack/lib/container/ContainerExposedDependency"
-);
-
-module.exports = ContainerExposedDependency;
-
-
-/***/ }),
-
-/***/ 9244:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
-
-
-
-const createSchemaValidation = __webpack_require__(32540);
-const ContainerEntryDependency = __webpack_require__(64813);
-const ContainerEntryModuleFactory = __webpack_require__(76398);
-const ContainerExposedDependency = __webpack_require__(72374);
-const { parseOptions } = __webpack_require__(3083);
-
-/** @typedef {import("../../declarations/plugins/container/ContainerPlugin").ContainerPluginOptions} ContainerPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-
-const validate = createSchemaValidation(
-	__webpack_require__(9504),
-	() => __webpack_require__(84899),
-	{
-		name: "Container Plugin",
-		baseDataPath: "options"
-	}
-);
-
-const PLUGIN_NAME = "ContainerPlugin";
+		const optDeclaration = update ? "" : "var ";
 
-class ContainerPlugin {
-	/**
-	 * @param {ContainerPluginOptions} options options
-	 */
-	constructor(options) {
-		validate(options);
+		const exportsType = module.getExportsType(
+			chunkGraph.moduleGraph,
+			originModule.buildMeta.strictHarmonyModule
+		);
+		runtimeRequirements.add(RuntimeGlobals.require);
+		const importContent = `/* harmony import */ ${optDeclaration}${importVar} = __webpack_require__(${moduleId});\n`;
 
-		this._options = {
-			name: options.name,
-			shareScope: options.shareScope || "default",
-			library: options.library || {
-				type: "var",
-				name: options.name
-			},
-			runtime: options.runtime,
-			filename: options.filename || undefined,
-			exposes: parseOptions(
-				options.exposes,
-				item => ({
-					import: Array.isArray(item) ? item : [item],
-					name: undefined
-				}),
-				item => ({
-					import: Array.isArray(item.import) ? item.import : [item.import],
-					name: item.name || undefined
-				})
-			)
-		};
+		if (exportsType === "dynamic") {
+			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+			return [
+				importContent,
+				`/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${importVar});\n`
+			];
+		}
+		return [importContent, ""];
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Object} options options
+	 * @param {ModuleGraph} options.moduleGraph the module graph
+	 * @param {Module} options.module the module
+	 * @param {string} options.request the request
+	 * @param {string | string[]} options.exportName the export name
+	 * @param {Module} options.originModule the origin module
+	 * @param {boolean|undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
+	 * @param {boolean} options.isCall true, if expression will be called
+	 * @param {boolean} options.callContext when false, call context will not be preserved
+	 * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated
+	 * @param {string} options.importVar the identifier name of the import variable
+	 * @param {InitFragment[]} options.initFragments init fragments will be added here
+	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
 	 */
-	apply(compiler) {
-		const { name, exposes, shareScope, filename, library, runtime } =
-			this._options;
-
-		compiler.options.output.enabledLibraryTypes.push(library.type);
+	exportFromImport({
+		moduleGraph,
+		module,
+		request,
+		exportName,
+		originModule,
+		asiSafe,
+		isCall,
+		callContext,
+		defaultInterop,
+		importVar,
+		initFragments,
+		runtime,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
+		}
+		if (!Array.isArray(exportName)) {
+			exportName = exportName ? [exportName] : [];
+		}
+		const exportsType = module.getExportsType(
+			moduleGraph,
+			originModule.buildMeta.strictHarmonyModule
+		);
 
-		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
-			const dep = new ContainerEntryDependency(name, exposes, shareScope);
-			dep.loc = { name };
-			compilation.addEntry(
-				compilation.options.context,
-				dep,
-				{
-					name,
-					filename,
-					runtime,
-					library
-				},
-				error => {
-					if (error) return callback(error);
-					callback();
+		if (defaultInterop) {
+			if (exportName.length > 0 && exportName[0] === "default") {
+				switch (exportsType) {
+					case "dynamic":
+						if (isCall) {
+							return `${importVar}_default()${propertyAccess(exportName, 1)}`;
+						} else {
+							return asiSafe
+								? `(${importVar}_default()${propertyAccess(exportName, 1)})`
+								: asiSafe === false
+								? `;(${importVar}_default()${propertyAccess(exportName, 1)})`
+								: `${importVar}_default.a${propertyAccess(exportName, 1)}`;
+						}
+					case "default-only":
+					case "default-with-named":
+						exportName = exportName.slice(1);
+						break;
 				}
-			);
-		});
-
-		compiler.hooks.thisCompilation.tap(
-			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ContainerEntryDependency,
-					new ContainerEntryModuleFactory()
+			} else if (exportName.length > 0) {
+				if (exportsType === "default-only") {
+					return (
+						"/* non-default import from non-esm module */undefined" +
+						propertyAccess(exportName, 1)
+					);
+				} else if (
+					exportsType !== "namespace" &&
+					exportName[0] === "__esModule"
+				) {
+					return "/* __esModule */true";
+				}
+			} else if (
+				exportsType === "default-only" ||
+				exportsType === "default-with-named"
+			) {
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				initFragments.push(
+					new InitFragment(
+						`var ${importVar}_namespace_cache;\n`,
+						InitFragment.STAGE_CONSTANTS,
+						-1,
+						`${importVar}_namespace_cache`
+					)
 				);
+				return `/*#__PURE__*/ ${
+					asiSafe ? "" : asiSafe === false ? ";" : "Object"
+				}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${
+					RuntimeGlobals.createFakeNamespaceObject
+				}(${importVar}${exportsType === "default-only" ? "" : ", 2"})))`;
+			}
+		}
 
-				compilation.dependencyFactories.set(
-					ContainerExposedDependency,
-					normalModuleFactory
+		if (exportName.length > 0) {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const used = exportsInfo.getUsedName(exportName, runtime);
+			if (!used) {
+				const comment = Template.toNormalComment(
+					`unused export ${propertyAccess(exportName)}`
 				);
+				return `${comment} undefined`;
 			}
-		);
+			const comment = equals(used, exportName)
+				? ""
+				: Template.toNormalComment(propertyAccess(exportName)) + " ";
+			const access = `${importVar}${comment}${propertyAccess(used)}`;
+			if (isCall && callContext === false) {
+				return asiSafe
+					? `(0,${access})`
+					: asiSafe === false
+					? `;(0,${access})`
+					: `/*#__PURE__*/Object(${access})`;
+			}
+			return access;
+		} else {
+			return importVar;
+		}
 	}
-}
-
-module.exports = ContainerPlugin;
-
-
-/***/ }),
-
-/***/ 95757:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
-*/
-
-
-
-const ExternalsPlugin = __webpack_require__(6652);
-const RuntimeGlobals = __webpack_require__(16475);
-const createSchemaValidation = __webpack_require__(32540);
-const FallbackDependency = __webpack_require__(57764);
-const FallbackItemDependency = __webpack_require__(29593);
-const FallbackModuleFactory = __webpack_require__(4112);
-const RemoteModule = __webpack_require__(62916);
-const RemoteRuntimeModule = __webpack_require__(88288);
-const RemoteToExternalDependency = __webpack_require__(14389);
-const { parseOptions } = __webpack_require__(3083);
-
-/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").ContainerReferencePluginOptions} ContainerReferencePluginOptions */
-/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").RemotesConfig} RemotesConfig */
-/** @typedef {import("../Compiler")} Compiler */
 
-const validate = createSchemaValidation(
-	__webpack_require__(95122),
-	() =>
-		__webpack_require__(66681),
-	{
-		name: "Container Reference Plugin",
-		baseDataPath: "options"
+	/**
+	 * @param {Object} options options
+	 * @param {AsyncDependenciesBlock} options.block the async block
+	 * @param {string} options.message the message
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
+	 */
+	blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
+		if (!block) {
+			const comment = this.comment({
+				message
+			});
+			return `Promise.resolve(${comment.trim()})`;
+		}
+		const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+		if (!chunkGroup || chunkGroup.chunks.length === 0) {
+			const comment = this.comment({
+				message
+			});
+			return `Promise.resolve(${comment.trim()})`;
+		}
+		const chunks = chunkGroup.chunks.filter(
+			chunk => !chunk.hasRuntime() && chunk.id !== null
+		);
+		const comment = this.comment({
+			message,
+			chunkName: block.chunkName
+		});
+		if (chunks.length === 1) {
+			const chunkId = JSON.stringify(chunks[0].id);
+			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId})`;
+		} else if (chunks.length > 0) {
+			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+			const requireChunkId = chunk =>
+				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`;
+			return `Promise.all(${comment.trim()}[${chunks
+				.map(requireChunkId)
+				.join(", ")}])`;
+		} else {
+			return `Promise.resolve(${comment.trim()})`;
+		}
 	}
-);
-
-const slashCode = "/".charCodeAt(0);
 
-class ContainerReferencePlugin {
 	/**
-	 * @param {ContainerReferencePluginOptions} options options
+	 * @param {Object} options options
+	 * @param {AsyncDependenciesBlock} options.block the async block
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} expression
 	 */
-	constructor(options) {
-		validate(options);
+	asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) {
+		const dep = block.dependencies[0];
+		const module = chunkGraph.moduleGraph.getModule(dep);
+		const ensureChunk = this.blockPromise({
+			block,
+			message: "",
+			chunkGraph,
+			runtimeRequirements
+		});
+		const factory = this.returningFunction(
+			this.moduleRaw({
+				module,
+				chunkGraph,
+				request,
+				runtimeRequirements
+			})
+		);
+		return this.returningFunction(
+			ensureChunk.startsWith("Promise.resolve(")
+				? `${factory}`
+				: `${ensureChunk}.then(${this.returningFunction(factory)})`
+		);
+	}
 
-		this._remoteType = options.remoteType;
-		this._remotes = parseOptions(
-			options.remotes,
-			item => ({
-				external: Array.isArray(item) ? item : [item],
-				shareScope: options.shareScope || "default"
-			}),
-			item => ({
-				external: Array.isArray(item.external)
-					? item.external
-					: [item.external],
-				shareScope: item.shareScope || options.shareScope || "default"
+	/**
+	 * @param {Object} options options
+	 * @param {Dependency} options.dependency the dependency
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} expression
+	 */
+	syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }) {
+		const module = chunkGraph.moduleGraph.getModule(dependency);
+		const factory = this.returningFunction(
+			this.moduleRaw({
+				module,
+				chunkGraph,
+				request,
+				runtimeRequirements
 			})
 		);
+		return this.returningFunction(factory);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Object} options options
+	 * @param {string} options.exportsArgument the name of the exports object
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} statement
 	 */
-	apply(compiler) {
-		const { _remotes: remotes, _remoteType: remoteType } = this;
+	defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
+	}
 
-		/** @type {Record<string, string>} */
-		const remoteExternals = {};
-		for (const [key, config] of remotes) {
-			let i = 0;
-			for (const external of config.external) {
-				if (external.startsWith("internal ")) continue;
-				remoteExternals[
-					`webpack/container/reference/${key}${i ? `/fallback-${i}` : ""}`
-				] = external;
-				i++;
-			}
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {string} options.publicPath the public path
+	 * @param {RuntimeSpec=} options.runtime runtime
+	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
+	 * @returns {string} the url of the asset
+	 */
+	assetUrl({ publicPath, runtime, module, codeGenerationResults }) {
+		if (!module) {
+			return "data:,";
 		}
-
-		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
-
-		compiler.hooks.compilation.tap(
-			"ContainerReferencePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RemoteToExternalDependency,
-					normalModuleFactory
-				);
-
-				compilation.dependencyFactories.set(
-					FallbackItemDependency,
-					normalModuleFactory
-				);
-
-				compilation.dependencyFactories.set(
-					FallbackDependency,
-					new FallbackModuleFactory()
-				);
-
-				normalModuleFactory.hooks.factorize.tap(
-					"ContainerReferencePlugin",
-					data => {
-						if (!data.request.includes("!")) {
-							for (const [key, config] of remotes) {
-								if (
-									data.request.startsWith(`${key}`) &&
-									(data.request.length === key.length ||
-										data.request.charCodeAt(key.length) === slashCode)
-								) {
-									return new RemoteModule(
-										data.request,
-										config.external.map((external, i) =>
-											external.startsWith("internal ")
-												? external.slice(9)
-												: `webpack/container/reference/${key}${
-														i ? `/fallback-${i}` : ""
-												  }`
-										),
-										`.${data.request.slice(key.length)}`,
-										config.shareScope
-									);
-								}
-							}
-						}
-					}
-				);
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ContainerReferencePlugin", (chunk, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-						set.add(RuntimeGlobals.hasOwnProperty);
-						set.add(RuntimeGlobals.initializeSharing);
-						set.add(RuntimeGlobals.shareScopeMap);
-						compilation.addRuntimeModule(chunk, new RemoteRuntimeModule());
-					});
-			}
-		);
+		const codeGen = codeGenerationResults.get(module, runtime);
+		const { data } = codeGen;
+		const url = data.get("url");
+		if (url) return url.toString();
+		const filename = data.get("filename");
+		return publicPath + filename;
 	}
 }
 
-module.exports = ContainerReferencePlugin;
+module.exports = RuntimeTemplate;
 
 
 /***/ }),
 
-/***/ 57764:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 63560:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -66952,725 +61924,710 @@ module.exports = ContainerReferencePlugin;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-
-class FallbackDependency extends Dependency {
-	constructor(requests) {
-		super();
-		this.requests = requests;
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `fallback ${this.requests.join(" ")}`;
-	}
-
-	get type() {
-		return "fallback";
-	}
-
-	get category() {
-		return "esm";
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.requests);
-		super.serialize(context);
+class SelfModuleFactory {
+	constructor(moduleGraph) {
+		this.moduleGraph = moduleGraph;
 	}
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new FallbackDependency(read());
-		obj.deserialize(context);
-		return obj;
+	create(data, callback) {
+		const module = this.moduleGraph.getParentModule(data.dependencies[0]);
+		callback(null, {
+			module
+		});
 	}
 }
 
-makeSerializable(
-	FallbackDependency,
-	"webpack/lib/container/FallbackDependency"
-);
-
-module.exports = FallbackDependency;
+module.exports = SelfModuleFactory;
 
 
 /***/ }),
 
-/***/ 29593:
+/***/ 48076:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
-
-class FallbackItemDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
-
-	get type() {
-		return "fallback item";
-	}
-
-	get category() {
-		return "esm";
-	}
-}
-
-makeSerializable(
-	FallbackItemDependency,
-	"webpack/lib/container/FallbackItemDependency"
-);
-
-module.exports = FallbackItemDependency;
+module.exports = __webpack_require__(96953);
 
 
 /***/ }),
 
-/***/ 82886:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 71070:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const makeSerializable = __webpack_require__(33032);
-const FallbackItemDependency = __webpack_require__(29593);
-
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
-
-class FallbackModule extends Module {
-	/**
-	 * @param {string[]} requests list of requests to choose one
-	 */
-	constructor(requests) {
-		super("fallback-module");
-		this.requests = requests;
-		this._identifier = `fallback ${this.requests.join(" ")}`;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return this._identifier;
-	}
-
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return this._identifier;
-	}
-
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/fallback/${
-			this.requests[0]
-		}/and ${this.requests.length - 1} more`;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk which condition should be checked
-	 * @param {Compilation} compilation the compilation
-	 * @returns {boolean} true, if the chunk is ok for the module
-	 */
-	chunkCondition(chunk, { chunkGraph }) {
-		return chunkGraph.getNumberOfEntryModules(chunk) > 0;
-	}
-
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
-	}
-
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true
-		};
-
-		this.clearDependenciesAndBlocks();
-		for (const request of this.requests)
-			this.addDependency(new FallbackItemDependency(request));
-
-		callback();
-	}
-
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return this.requests.length * 5 + 42;
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
-
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const ids = this.dependencies.map(dep =>
-			chunkGraph.getModuleId(moduleGraph.getModule(dep))
-		);
-		const code = Template.asString([
-			`var ids = ${JSON.stringify(ids)};`,
-			"var error, result, i = 0;",
-			`var loop = ${runtimeTemplate.basicFunction("next", [
-				"while(i < ids.length) {",
-				Template.indent([
-					"try { next = __webpack_require__(ids[i++]); } catch(e) { return handleError(e); }",
-					"if(next) return next.then ? next.then(handleResult, handleError) : handleResult(next);"
-				]),
-				"}",
-				"if(error) throw error;"
-			])}`,
-			`var handleResult = ${runtimeTemplate.basicFunction("result", [
-				"if(result) return result;",
-				"return loop();"
-			])};`,
-			`var handleError = ${runtimeTemplate.basicFunction("e", [
-				"error = e;",
-				"return loop();"
-			])};`,
-			"module.exports = loop();"
-		]);
-		const sources = new Map();
-		sources.set("javascript", new RawSource(code));
-		return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS };
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.requests);
-		super.serialize(context);
+/**
+ * @param {number} size the size in bytes
+ * @returns {string} the formatted size
+ */
+exports.formatSize = size => {
+	if (typeof size !== "number" || Number.isNaN(size) === true) {
+		return "unknown size";
 	}
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new FallbackModule(read());
-		obj.deserialize(context);
-		return obj;
+	if (size <= 0) {
+		return "0 bytes";
 	}
-}
 
-makeSerializable(FallbackModule, "webpack/lib/container/FallbackModule");
+	const abbreviations = ["bytes", "KiB", "MiB", "GiB"];
+	const index = Math.floor(Math.log(size) / Math.log(1024));
 
-module.exports = FallbackModule;
+	return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${
+		abbreviations[index]
+	}`;
+};
 
 
 /***/ }),
 
-/***/ 4112:
+/***/ 97513:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+	Author Tobias Koppers @sokra
 */
 
 
 
-const ModuleFactory = __webpack_require__(51010);
-const FallbackModule = __webpack_require__(82886);
+const JavascriptModulesPlugin = __webpack_require__(89464);
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./FallbackDependency")} FallbackDependency */
+/** @typedef {import("./Compilation")} Compilation */
+
+class SourceMapDevToolModuleOptionsPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-module.exports = class FallbackModuleFactory extends ModuleFactory {
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {Compilation} compilation the compiler instance
 	 * @returns {void}
 	 */
-	create({ dependencies: [dependency] }, callback) {
-		const dep = /** @type {FallbackDependency} */ (dependency);
-		callback(null, {
-			module: new FallbackModule(dep.requests)
-		});
+	apply(compilation) {
+		const options = this.options;
+		if (options.module !== false) {
+			compilation.hooks.buildModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSourceMap = true;
+				}
+			);
+			compilation.hooks.runtimeModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSourceMap = true;
+				}
+			);
+		} else {
+			compilation.hooks.buildModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSimpleSourceMap = true;
+				}
+			);
+			compilation.hooks.runtimeModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSimpleSourceMap = true;
+				}
+			);
+		}
+		JavascriptModulesPlugin.getCompilationHooks(compilation).useSourceMap.tap(
+			"SourceMapDevToolModuleOptionsPlugin",
+			() => true
+		);
 	}
-};
+}
+
+module.exports = SourceMapDevToolModuleOptionsPlugin;
 
 
 /***/ }),
 
-/***/ 30569:
+/***/ 63872:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const isValidExternalsType = __webpack_require__(62142);
-const SharePlugin = __webpack_require__(26335);
+const asyncLib = __webpack_require__(78175);
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const ProgressPlugin = __webpack_require__(13216);
+const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
 const createSchemaValidation = __webpack_require__(32540);
-const ContainerPlugin = __webpack_require__(9244);
-const ContainerReferencePlugin = __webpack_require__(95757);
+const createHash = __webpack_require__(49835);
+const { relative, dirname } = __webpack_require__(17139);
+const { makePathsAbsolute } = __webpack_require__(82186);
 
-/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ExternalsType} ExternalsType */
-/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ModuleFederationPluginOptions} ModuleFederationPluginOptions */
-/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").Shared} Shared */
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("webpack-sources").MapOptions} MapOptions */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
+/** @typedef {import("./Cache").Etag} Etag */
+/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule").SourceMap} SourceMap */
+/** @typedef {import("./util/Hash")} Hash */
 
 const validate = createSchemaValidation(
-	__webpack_require__(7467),
-	() => __webpack_require__(82601),
+	__webpack_require__(2885),
+	() => __webpack_require__(30501),
 	{
-		name: "Module Federation Plugin",
+		name: "SourceMap DevTool Plugin",
 		baseDataPath: "options"
 	}
 );
-class ModuleFederationPlugin {
+/**
+ * @typedef {object} SourceMapTask
+ * @property {Source} asset
+ * @property {AssetInfo} assetInfo
+ * @property {(string | Module)[]} modules
+ * @property {string} source
+ * @property {string} file
+ * @property {SourceMap} sourceMap
+ * @property {ItemCacheFacade} cacheItem cache item
+ */
+
+/**
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
+ */
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+};
+
+/**
+ * Creating {@link SourceMapTask} for given file
+ * @param {string} file current compiled file
+ * @param {Source} asset the asset
+ * @param {AssetInfo} assetInfo the asset info
+ * @param {MapOptions} options source map options
+ * @param {Compilation} compilation compilation instance
+ * @param {ItemCacheFacade} cacheItem cache item
+ * @returns {SourceMapTask | undefined} created task instance or `undefined`
+ */
+const getTaskForFile = (
+	file,
+	asset,
+	assetInfo,
+	options,
+	compilation,
+	cacheItem
+) => {
+	let source;
+	/** @type {SourceMap} */
+	let sourceMap;
 	/**
-	 * @param {ModuleFederationPluginOptions} options options
+	 * Check if asset can build source map
 	 */
-	constructor(options) {
+	if (asset.sourceAndMap) {
+		const sourceAndMap = asset.sourceAndMap(options);
+		sourceMap = /** @type {SourceMap} */ (sourceAndMap.map);
+		source = sourceAndMap.source;
+	} else {
+		sourceMap = /** @type {SourceMap} */ (asset.map(options));
+		source = asset.source();
+	}
+	if (!sourceMap || typeof source !== "string") return;
+	const context = compilation.options.context;
+	const root = compilation.compiler.root;
+	const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root);
+	const modules = sourceMap.sources.map(source => {
+		if (!source.startsWith("webpack://")) return source;
+		source = cachedAbsolutify(source.slice(10));
+		const module = compilation.findModule(source);
+		return module || source;
+	});
+
+	return {
+		file,
+		asset,
+		source,
+		assetInfo,
+		sourceMap,
+		modules,
+		cacheItem
+	};
+};
+
+class SourceMapDevToolPlugin {
+	/**
+	 * @param {SourceMapDevToolPluginOptions} [options] options object
+	 * @throws {Error} throws error, if got more than 1 arguments
+	 */
+	constructor(options = {}) {
 		validate(options);
 
-		this._options = options;
+		/** @type {string | false} */
+		this.sourceMapFilename = options.filename;
+		/** @type {string | false} */
+		this.sourceMappingURLComment =
+			options.append === false
+				? false
+				: options.append || "\n//# source" + "MappingURL=[url]";
+		/** @type {string | Function} */
+		this.moduleFilenameTemplate =
+			options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]";
+		/** @type {string | Function} */
+		this.fallbackModuleFilenameTemplate =
+			options.fallbackModuleFilenameTemplate ||
+			"webpack://[namespace]/[resourcePath]?[hash]";
+		/** @type {string} */
+		this.namespace = options.namespace || "";
+		/** @type {SourceMapDevToolPluginOptions} */
+		this.options = options;
 	}
 
 	/**
 	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Compiler} compiler compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { _options: options } = this;
-		const library = options.library || { type: "var", name: options.name };
-		const remoteType =
-			options.remoteType ||
-			(options.library && isValidExternalsType(options.library.type)
-				? /** @type {ExternalsType} */ (options.library.type)
-				: "script");
-		if (
-			library &&
-			!compiler.options.output.enabledLibraryTypes.includes(library.type)
-		) {
-			compiler.options.output.enabledLibraryTypes.push(library.type);
-		}
-		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
-			if (
-				options.exposes &&
-				(Array.isArray(options.exposes)
-					? options.exposes.length > 0
-					: Object.keys(options.exposes).length > 0)
-			) {
-				new ContainerPlugin({
-					name: options.name,
-					library,
-					filename: options.filename,
-					runtime: options.runtime,
-					exposes: options.exposes
-				}).apply(compiler);
-			}
-			if (
-				options.remotes &&
-				(Array.isArray(options.remotes)
-					? options.remotes.length > 0
-					: Object.keys(options.remotes).length > 0)
-			) {
-				new ContainerReferencePlugin({
-					remoteType,
-					remotes: options.remotes
-				}).apply(compiler);
-			}
-			if (options.shared) {
-				new SharePlugin({
-					shared: options.shared,
-					shareScope: options.shareScope
-				}).apply(compiler);
-			}
-		});
-	}
-}
-
-module.exports = ModuleFederationPlugin;
-
-
-/***/ }),
-
-/***/ 62916:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
-*/
-
-
+		const outputFs = compiler.outputFileSystem;
+		const sourceMapFilename = this.sourceMapFilename;
+		const sourceMappingURLComment = this.sourceMappingURLComment;
+		const moduleFilenameTemplate = this.moduleFilenameTemplate;
+		const namespace = this.namespace;
+		const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate;
+		const requestShortener = compiler.requestShortener;
+		const options = this.options;
+		options.test = options.test || /\.((c|m)?js|css)($|\?)/i;
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const FallbackDependency = __webpack_require__(57764);
-const RemoteToExternalDependency = __webpack_require__(14389);
+		const matchObject = ModuleFilenameHelpers.matchObject.bind(
+			undefined,
+			options
+		);
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+		compiler.hooks.compilation.tap("SourceMapDevToolPlugin", compilation => {
+			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
 
-const TYPES = new Set(["remote", "share-init"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+			compilation.hooks.processAssets.tapAsync(
+				{
+					name: "SourceMapDevToolPlugin",
+					stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+					additionalAssets: true
+				},
+				(assets, callback) => {
+					const chunkGraph = compilation.chunkGraph;
+					const cache = compilation.getCache("SourceMapDevToolPlugin");
+					/** @type {Map<string | Module, string>} */
+					const moduleToSourceNameMapping = new Map();
+					/**
+					 * @type {Function}
+					 * @returns {void}
+					 */
+					const reportProgress =
+						ProgressPlugin.getReporter(compilation.compiler) || (() => {});
 
-class RemoteModule extends Module {
-	/**
-	 * @param {string} request request string
-	 * @param {string[]} externalRequests list of external requests to containers
-	 * @param {string} internalRequest name of exposed module in container
-	 * @param {string} shareScope the used share scope name
-	 */
-	constructor(request, externalRequests, internalRequest, shareScope) {
-		super("remote-module");
-		this.request = request;
-		this.externalRequests = externalRequests;
-		this.internalRequest = internalRequest;
-		this.shareScope = shareScope;
-		this._identifier = `remote (${shareScope}) ${this.externalRequests.join(
-			" "
-		)} ${this.internalRequest}`;
-	}
+					/** @type {Map<string, Chunk>} */
+					const fileToChunk = new Map();
+					for (const chunk of compilation.chunks) {
+						for (const file of chunk.files) {
+							fileToChunk.set(file, chunk);
+						}
+						for (const file of chunk.auxiliaryFiles) {
+							fileToChunk.set(file, chunk);
+						}
+					}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return this._identifier;
-	}
+					/** @type {string[]} */
+					const files = [];
+					for (const file of Object.keys(assets)) {
+						if (matchObject(file)) {
+							files.push(file);
+						}
+					}
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `remote ${this.request}`;
-	}
+					reportProgress(0.0);
+					/** @type {SourceMapTask[]} */
+					const tasks = [];
+					let fileIndex = 0;
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/remote/${
-			this.request
-		}`;
-	}
+					asyncLib.each(
+						files,
+						(file, callback) => {
+							const asset = compilation.getAsset(file);
+							if (asset.info.related && asset.info.related.sourceMap) {
+								fileIndex++;
+								return callback();
+							}
+							const cacheItem = cache.getItemCache(
+								file,
+								cache.mergeEtags(
+									cache.getLazyHashedEtag(asset.source),
+									namespace
+								)
+							);
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
-	}
+							cacheItem.get((err, cacheEntry) => {
+								if (err) {
+									return callback(err);
+								}
+								/**
+								 * If presented in cache, reassigns assets. Cache assets already have source maps.
+								 */
+								if (cacheEntry) {
+									const { assets, assetsInfo } = cacheEntry;
+									for (const cachedFile of Object.keys(assets)) {
+										if (cachedFile === file) {
+											compilation.updateAsset(
+												cachedFile,
+												assets[cachedFile],
+												assetsInfo[cachedFile]
+											);
+										} else {
+											compilation.emitAsset(
+												cachedFile,
+												assets[cachedFile],
+												assetsInfo[cachedFile]
+											);
+										}
+										/**
+										 * Add file to chunk, if not presented there
+										 */
+										if (cachedFile !== file) {
+											const chunk = fileToChunk.get(file);
+											if (chunk !== undefined)
+												chunk.auxiliaryFiles.add(cachedFile);
+										}
+									}
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true
-		};
+									reportProgress(
+										(0.5 * ++fileIndex) / files.length,
+										file,
+										"restored cached SourceMap"
+									);
 
-		this.clearDependenciesAndBlocks();
-		if (this.externalRequests.length === 1) {
-			this.addDependency(
-				new RemoteToExternalDependency(this.externalRequests[0])
-			);
-		} else {
-			this.addDependency(new FallbackDependency(this.externalRequests));
-		}
+									return callback();
+								}
 
-		callback();
-	}
+								reportProgress(
+									(0.5 * fileIndex) / files.length,
+									file,
+									"generate SourceMap"
+								);
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 6;
-	}
+								/** @type {SourceMapTask | undefined} */
+								const task = getTaskForFile(
+									file,
+									asset.source,
+									asset.info,
+									{
+										module: options.module,
+										columns: options.columns
+									},
+									compilation,
+									cacheItem
+								);
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+								if (task) {
+									const modules = task.modules;
 
-	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
-	 */
-	nameForCondition() {
-		return this.request;
-	}
+									for (let idx = 0; idx < modules.length; idx++) {
+										const module = modules[idx];
+										if (!moduleToSourceNameMapping.get(module)) {
+											moduleToSourceNameMapping.set(
+												module,
+												ModuleFilenameHelpers.createFilename(
+													module,
+													{
+														moduleFilenameTemplate: moduleFilenameTemplate,
+														namespace: namespace
+													},
+													{
+														requestShortener,
+														chunkGraph,
+														hashFunction: compilation.outputOptions.hashFunction
+													}
+												)
+											);
+										}
+									}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const module = moduleGraph.getModule(this.dependencies[0]);
-		const id = module && chunkGraph.getModuleId(module);
-		const sources = new Map();
-		sources.set("remote", new RawSource(""));
-		const data = new Map();
-		data.set("share-init", [
-			{
-				shareScope: this.shareScope,
-				initStage: 20,
-				init: id === undefined ? "" : `initExternal(${JSON.stringify(id)});`
-			}
-		]);
-		return { sources, data, runtimeRequirements: RUNTIME_REQUIREMENTS };
-	}
+									tasks.push(task);
+								}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.request);
-		write(this.externalRequests);
-		write(this.internalRequest);
-		write(this.shareScope);
-		super.serialize(context);
-	}
+								reportProgress(
+									(0.5 * ++fileIndex) / files.length,
+									file,
+									"generated SourceMap"
+								);
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new RemoteModule(read(), read(), read(), read());
-		obj.deserialize(context);
-		return obj;
-	}
-}
+								callback();
+							});
+						},
+						err => {
+							if (err) {
+								return callback(err);
+							}
 
-makeSerializable(RemoteModule, "webpack/lib/container/RemoteModule");
+							reportProgress(0.5, "resolve sources");
+							/** @type {Set<string>} */
+							const usedNamesSet = new Set(moduleToSourceNameMapping.values());
+							/** @type {Set<string>} */
+							const conflictDetectionSet = new Set();
 
-module.exports = RemoteModule;
+							/**
+							 * all modules in defined order (longest identifier first)
+							 * @type {Array<string | Module>}
+							 */
+							const allModules = Array.from(
+								moduleToSourceNameMapping.keys()
+							).sort((a, b) => {
+								const ai = typeof a === "string" ? a : a.identifier();
+								const bi = typeof b === "string" ? b : b.identifier();
+								return ai.length - bi.length;
+							});
 
+							// find modules with conflicting source names
+							for (let idx = 0; idx < allModules.length; idx++) {
+								const module = allModules[idx];
+								let sourceName = moduleToSourceNameMapping.get(module);
+								let hasName = conflictDetectionSet.has(sourceName);
+								if (!hasName) {
+									conflictDetectionSet.add(sourceName);
+									continue;
+								}
 
-/***/ }),
+								// try the fallback name first
+								sourceName = ModuleFilenameHelpers.createFilename(
+									module,
+									{
+										moduleFilenameTemplate: fallbackModuleFilenameTemplate,
+										namespace: namespace
+									},
+									{
+										requestShortener,
+										chunkGraph,
+										hashFunction: compilation.outputOptions.hashFunction
+									}
+								);
+								hasName = usedNamesSet.has(sourceName);
+								if (!hasName) {
+									moduleToSourceNameMapping.set(module, sourceName);
+									usedNamesSet.add(sourceName);
+									continue;
+								}
 
-/***/ 88288:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+								// otherwise just append stars until we have a valid name
+								while (hasName) {
+									sourceName += "*";
+									hasName = usedNamesSet.has(sourceName);
+								}
+								moduleToSourceNameMapping.set(module, sourceName);
+								usedNamesSet.add(sourceName);
+							}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+							let taskIndex = 0;
 
+							asyncLib.each(
+								tasks,
+								(task, callback) => {
+									const assets = Object.create(null);
+									const assetsInfo = Object.create(null);
+									const file = task.file;
+									const chunk = fileToChunk.get(file);
+									const sourceMap = task.sourceMap;
+									const source = task.source;
+									const modules = task.modules;
 
+									reportProgress(
+										0.5 + (0.5 * taskIndex) / tasks.length,
+										file,
+										"attach SourceMap"
+									);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+									const moduleFilenames = modules.map(m =>
+										moduleToSourceNameMapping.get(m)
+									);
+									sourceMap.sources = moduleFilenames;
+									if (options.noSources) {
+										sourceMap.sourcesContent = undefined;
+									}
+									sourceMap.sourceRoot = options.sourceRoot || "";
+									sourceMap.file = file;
+									const usesContentHash =
+										sourceMapFilename &&
+										/\[contenthash(:\w+)?\]/.test(sourceMapFilename);
 
-/** @typedef {import("./RemoteModule")} RemoteModule */
+									// If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file`
+									if (usesContentHash && task.assetInfo.contenthash) {
+										const contenthash = task.assetInfo.contenthash;
+										let pattern;
+										if (Array.isArray(contenthash)) {
+											pattern = contenthash.map(quoteMeta).join("|");
+										} else {
+											pattern = quoteMeta(contenthash);
+										}
+										sourceMap.file = sourceMap.file.replace(
+											new RegExp(pattern, "g"),
+											m => "x".repeat(m.length)
+										);
+									}
 
-class RemoteRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("remotes loading");
-	}
+									/** @type {string | false} */
+									let currentSourceMappingURLComment = sourceMappingURLComment;
+									if (
+										currentSourceMappingURLComment !== false &&
+										/\.css($|\?)/i.test(file)
+									) {
+										currentSourceMappingURLComment =
+											currentSourceMappingURLComment.replace(
+												/^\n\/\/(.*)$/,
+												"\n/*$1*/"
+											);
+									}
+									const sourceMapString = JSON.stringify(sourceMap);
+									if (sourceMapFilename) {
+										let filename = file;
+										const sourceMapContentHash =
+											usesContentHash &&
+											/** @type {string} */ (
+												createHash(compilation.outputOptions.hashFunction)
+													.update(sourceMapString)
+													.digest("hex")
+											);
+										const pathParams = {
+											chunk,
+											filename: options.fileContext
+												? relative(
+														outputFs,
+														`/${options.fileContext}`,
+														`/${filename}`
+												  )
+												: filename,
+											contentHash: sourceMapContentHash
+										};
+										const { path: sourceMapFile, info: sourceMapInfo } =
+											compilation.getPathWithInfo(
+												sourceMapFilename,
+												pathParams
+											);
+										const sourceMapUrl = options.publicPath
+											? options.publicPath + sourceMapFile
+											: relative(
+													outputFs,
+													dirname(outputFs, `/${file}`),
+													`/${sourceMapFile}`
+											  );
+										/** @type {Source} */
+										let asset = new RawSource(source);
+										if (currentSourceMappingURLComment !== false) {
+											// Add source map url to compilation asset, if currentSourceMappingURLComment is set
+											asset = new ConcatSource(
+												asset,
+												compilation.getPath(
+													currentSourceMappingURLComment,
+													Object.assign({ url: sourceMapUrl }, pathParams)
+												)
+											);
+										}
+										const assetInfo = {
+											related: { sourceMap: sourceMapFile }
+										};
+										assets[file] = asset;
+										assetsInfo[file] = assetInfo;
+										compilation.updateAsset(file, asset, assetInfo);
+										// Add source map file to compilation assets and chunk files
+										const sourceMapAsset = new RawSource(sourceMapString);
+										const sourceMapAssetInfo = {
+											...sourceMapInfo,
+											development: true
+										};
+										assets[sourceMapFile] = sourceMapAsset;
+										assetsInfo[sourceMapFile] = sourceMapAssetInfo;
+										compilation.emitAsset(
+											sourceMapFile,
+											sourceMapAsset,
+											sourceMapAssetInfo
+										);
+										if (chunk !== undefined)
+											chunk.auxiliaryFiles.add(sourceMapFile);
+									} else {
+										if (currentSourceMappingURLComment === false) {
+											throw new Error(
+												"SourceMapDevToolPlugin: append can't be false when no filename is provided"
+											);
+										}
+										/**
+										 * Add source map as data url to asset
+										 */
+										const asset = new ConcatSource(
+											new RawSource(source),
+											currentSourceMappingURLComment
+												.replace(/\[map\]/g, () => sourceMapString)
+												.replace(
+													/\[url\]/g,
+													() =>
+														`data:application/json;charset=utf-8;base64,${Buffer.from(
+															sourceMapString,
+															"utf-8"
+														).toString("base64")}`
+												)
+										);
+										assets[file] = asset;
+										assetsInfo[file] = undefined;
+										compilation.updateAsset(file, asset);
+									}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, chunkGraph } = this;
-		const { runtimeTemplate, moduleGraph } = compilation;
-		const chunkToRemotesMapping = {};
-		const idToExternalAndNameMapping = {};
-		for (const chunk of this.chunk.getAllAsyncChunks()) {
-			const modules = chunkGraph.getChunkModulesIterableBySourceType(
-				chunk,
-				"remote"
+									task.cacheItem.store({ assets, assetsInfo }, err => {
+										reportProgress(
+											0.5 + (0.5 * ++taskIndex) / tasks.length,
+											task.file,
+											"attached SourceMap"
+										);
+
+										if (err) {
+											return callback(err);
+										}
+										callback();
+									});
+								},
+								err => {
+									reportProgress(1.0);
+									callback(err);
+								}
+							);
+						}
+					);
+				}
 			);
-			if (!modules) continue;
-			const remotes = (chunkToRemotesMapping[chunk.id] = []);
-			for (const m of modules) {
-				const module = /** @type {RemoteModule} */ (m);
-				const name = module.internalRequest;
-				const id = chunkGraph.getModuleId(module);
-				const shareScope = module.shareScope;
-				const dep = module.dependencies[0];
-				const externalModule = moduleGraph.getModule(dep);
-				const externalModuleId =
-					externalModule && chunkGraph.getModuleId(externalModule);
-				remotes.push(id);
-				idToExternalAndNameMapping[id] = [shareScope, name, externalModuleId];
-			}
-		}
-		return Template.asString([
-			`var chunkMapping = ${JSON.stringify(
-				chunkToRemotesMapping,
-				null,
-				"\t"
-			)};`,
-			`var idToExternalAndNameMapping = ${JSON.stringify(
-				idToExternalAndNameMapping,
-				null,
-				"\t"
-			)};`,
-			`${
-				RuntimeGlobals.ensureChunkHandlers
-			}.remotes = ${runtimeTemplate.basicFunction("chunkId, promises", [
-				`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
-				Template.indent([
-					`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction("id", [
-						`var getScope = ${RuntimeGlobals.currentRemoteGetScope};`,
-						"if(!getScope) getScope = [];",
-						"var data = idToExternalAndNameMapping[id];",
-						"if(getScope.indexOf(data) >= 0) return;",
-						"getScope.push(data);",
-						`if(data.p) return promises.push(data.p);`,
-						`var onError = ${runtimeTemplate.basicFunction("error", [
-							'if(!error) error = new Error("Container missing");',
-							'if(typeof error.message === "string")',
-							Template.indent(
-								`error.message += '\\nwhile loading "' + data[1] + '" from ' + data[2];`
-							),
-							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction("", [
-								"throw error;"
-							])}`,
-							"data.p = 0;"
-						])};`,
-						`var handleFunction = ${runtimeTemplate.basicFunction(
-							"fn, arg1, arg2, d, next, first",
-							[
-								"try {",
-								Template.indent([
-									"var promise = fn(arg1, arg2);",
-									"if(promise && promise.then) {",
-									Template.indent([
-										`var p = promise.then(${runtimeTemplate.returningFunction(
-											"next(result, d)",
-											"result"
-										)}, onError);`,
-										`if(first) promises.push(data.p = p); else return p;`
-									]),
-									"} else {",
-									Template.indent(["return next(promise, d, first);"]),
-									"}"
-								]),
-								"} catch(error) {",
-								Template.indent(["onError(error);"]),
-								"}"
-							]
-						)}`,
-						`var onExternal = ${runtimeTemplate.returningFunction(
-							`external ? handleFunction(${RuntimeGlobals.initializeSharing}, data[0], 0, external, onInitialized, first) : onError()`,
-							"external, _, first"
-						)};`,
-						`var onInitialized = ${runtimeTemplate.returningFunction(
-							`handleFunction(external.get, data[1], getScope, 0, onFactory, first)`,
-							"_, external, first"
-						)};`,
-						`var onFactory = ${runtimeTemplate.basicFunction("factory", [
-							"data.p = 1;",
-							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction(
-								"module",
-								["module.exports = factory();"]
-							)}`
-						])};`,
-						"handleFunction(__webpack_require__, data[2], 0, 0, onExternal, 1);"
-					])});`
-				]),
-				"}"
-			])}`
-		]);
+		});
 	}
 }
 
-module.exports = RemoteRuntimeModule;
+module.exports = SourceMapDevToolPlugin;
 
 
 /***/ }),
 
-/***/ 14389:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 31743:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -67680,1321 +62637,1112 @@ module.exports = RemoteRuntimeModule;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
 
-class RemoteToExternalDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
+class Stats {
+	/**
+	 * @param {Compilation} compilation webpack compilation
+	 */
+	constructor(compilation) {
+		this.compilation = compilation;
 	}
 
-	get type() {
-		return "remote to external";
+	get hash() {
+		return this.compilation.hash;
 	}
 
-	get category() {
-		return "esm";
+	get startTime() {
+		return this.compilation.startTime;
 	}
-}
-
-makeSerializable(
-	RemoteToExternalDependency,
-	"webpack/lib/container/RemoteToExternalDependency"
-);
 
-module.exports = RemoteToExternalDependency;
+	get endTime() {
+		return this.compilation.endTime;
+	}
 
+	/**
+	 * @returns {boolean} true if the compilation had a warning
+	 */
+	hasWarnings() {
+		return (
+			this.compilation.warnings.length > 0 ||
+			this.compilation.children.some(child => child.getStats().hasWarnings())
+		);
+	}
 
-/***/ }),
+	/**
+	 * @returns {boolean} true if the compilation encountered an error
+	 */
+	hasErrors() {
+		return (
+			this.compilation.errors.length > 0 ||
+			this.compilation.children.some(child => child.getStats().hasErrors())
+		);
+	}
 
-/***/ 3083:
-/***/ (function(__unused_webpack_module, exports) {
+	/**
+	 * @param {(string|StatsOptions)=} options stats options
+	 * @returns {StatsCompilation} json output
+	 */
+	toJson(options) {
+		options = this.compilation.createStatsOptions(options, {
+			forToString: false
+		});
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const statsFactory = this.compilation.createStatsFactory(options);
 
+		return statsFactory.create("compilation", this.compilation, {
+			compilation: this.compilation
+		});
+	}
 
+	toString(options) {
+		options = this.compilation.createStatsOptions(options, {
+			forToString: true
+		});
 
-/** @template T @typedef {(string | Record<string, string | string[] | T>)[] | Record<string, string | string[] | T>} ContainerOptionsFormat */
+		const statsFactory = this.compilation.createStatsFactory(options);
+		const statsPrinter = this.compilation.createStatsPrinter(options);
 
-/**
- * @template T
- * @template N
- * @param {ContainerOptionsFormat<T>} options options passed by the user
- * @param {function(string | string[], string) : N} normalizeSimple normalize a simple item
- * @param {function(T, string) : N} normalizeOptions normalize a complex item
- * @param {function(string, N): void} fn processing function
- * @returns {void}
- */
-const process = (options, normalizeSimple, normalizeOptions, fn) => {
-	const array = items => {
-		for (const item of items) {
-			if (typeof item === "string") {
-				fn(item, normalizeSimple(item, item));
-			} else if (item && typeof item === "object") {
-				object(item);
-			} else {
-				throw new Error("Unexpected options format");
-			}
-		}
-	};
-	const object = obj => {
-		for (const [key, value] of Object.entries(obj)) {
-			if (typeof value === "string" || Array.isArray(value)) {
-				fn(key, normalizeSimple(value, key));
-			} else {
-				fn(key, normalizeOptions(value, key));
-			}
-		}
-	};
-	if (!options) {
-		return;
-	} else if (Array.isArray(options)) {
-		array(options);
-	} else if (typeof options === "object") {
-		object(options);
-	} else {
-		throw new Error("Unexpected options format");
+		const data = statsFactory.create("compilation", this.compilation, {
+			compilation: this.compilation
+		});
+		const result = statsPrinter.print("compilation", data);
+		return result === undefined ? "" : result;
 	}
-};
-
-/**
- * @template T
- * @template R
- * @param {ContainerOptionsFormat<T>} options options passed by the user
- * @param {function(string | string[], string) : R} normalizeSimple normalize a simple item
- * @param {function(T, string) : R} normalizeOptions normalize a complex item
- * @returns {[string, R][]} parsed options
- */
-const parseOptions = (options, normalizeSimple, normalizeOptions) => {
-	/** @type {[string, R][]} */
-	const items = [];
-	process(options, normalizeSimple, normalizeOptions, (key, value) => {
-		items.push([key, value]);
-	});
-	return items;
-};
-
-/**
- * @template T
- * @param {string} scope scope name
- * @param {ContainerOptionsFormat<T>} options options passed by the user
- * @returns {Record<string, string | string[] | T>} options to spread or pass
- */
-const scope = (scope, options) => {
-	/** @type {Record<string, string | string[] | T>} */
-	const obj = {};
-	process(
-		options,
-		item => /** @type {string | string[] | T} */ (item),
-		item => /** @type {string | string[] | T} */ (item),
-		(key, value) => {
-			obj[
-				key.startsWith("./") ? `${scope}${key.slice(1)}` : `${scope}/${key}`
-			] = value;
-		}
-	);
-	return obj;
-};
+}
 
-exports.parseOptions = parseOptions;
-exports.scope = scope;
+module.exports = Stats;
 
 
 /***/ }),
 
-/***/ 91254:
+/***/ 39722:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { ReplaceSource, RawSource, ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Generator = __webpack_require__(93401);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
+const { ConcatSource, PrefixSource } = __webpack_require__(51255);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../util/Hash")} Hash */
-
-const TYPES = new Set(["javascript"]);
+/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
-class CssExportsGenerator extends Generator {
-	constructor() {
-		super();
-	}
+const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);
+const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0);
+const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1;
+const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $
+const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
+	NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9
+const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g;
+const INDENT_MULTILINE_REGEX = /^\t/gm;
+const LINE_SEPARATOR_REGEX = /\r?\n/g;
+const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/;
+const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g;
+const COMMENT_END_REGEX = /\*\//g;
+const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
+const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
 
-	// TODO add getConcatenationBailoutReason to allow concatenation
-	// but how to make it have a module id
+/**
+ * @typedef {Object} RenderManifestOptions
+ * @property {Chunk} chunk the chunk used to render
+ * @property {string} hash
+ * @property {string} fullHash
+ * @property {OutputOptions} outputOptions
+ * @property {CodeGenerationResults} codeGenerationResults
+ * @property {{javascript: ModuleTemplate}} moduleTemplates
+ * @property {DependencyTemplates} dependencyTemplates
+ * @property {RuntimeTemplate} runtimeTemplate
+ * @property {ModuleGraph} moduleGraph
+ * @property {ChunkGraph} chunkGraph
+ */
 
-	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(module, generateContext) {
-		const source = new ReplaceSource(new RawSource(""));
-		const initFragments = [];
-		const cssExports = new Map();
+/** @typedef {RenderManifestEntryTemplated | RenderManifestEntryStatic} RenderManifestEntry */
 
-		generateContext.runtimeRequirements.add(RuntimeGlobals.module);
+/**
+ * @typedef {Object} RenderManifestEntryTemplated
+ * @property {function(): Source} render
+ * @property {string | function(PathData, AssetInfo=): string} filenameTemplate
+ * @property {PathData=} pathOptions
+ * @property {AssetInfo=} info
+ * @property {string} identifier
+ * @property {string=} hash
+ * @property {boolean=} auxiliary
+ */
 
-		const runtimeRequirements = new Set();
+/**
+ * @typedef {Object} RenderManifestEntryStatic
+ * @property {function(): Source} render
+ * @property {string} filename
+ * @property {AssetInfo} info
+ * @property {string} identifier
+ * @property {string=} hash
+ * @property {boolean=} auxiliary
+ */
 
-		const templateContext = {
-			runtimeTemplate: generateContext.runtimeTemplate,
-			dependencyTemplates: generateContext.dependencyTemplates,
-			moduleGraph: generateContext.moduleGraph,
-			chunkGraph: generateContext.chunkGraph,
-			module,
-			runtime: generateContext.runtime,
-			runtimeRequirements: runtimeRequirements,
-			concatenationScope: generateContext.concatenationScope,
-			codeGenerationResults: generateContext.codeGenerationResults,
-			initFragments,
-			cssExports
-		};
+/**
+ * @typedef {Object} HasId
+ * @property {number | string} id
+ */
 
-		const handleDependency = dependency => {
-			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-				dependency.constructor
-			);
-			const template = generateContext.dependencyTemplates.get(constructor);
-			if (!template) {
-				throw new Error(
-					"No template for dependency: " + dependency.constructor.name
-				);
-			}
+/**
+ * @typedef {function(Module, number): boolean} ModuleFilterPredicate
+ */
 
-			template.apply(dependency, source, templateContext);
-		};
-		module.dependencies.forEach(handleDependency);
+class Template {
+	/**
+	 *
+	 * @param {Function} fn a runtime function (.runtime.js) "template"
+	 * @returns {string} the updated and normalized function string
+	 */
+	static getFunctionContent(fn) {
+		return fn
+			.toString()
+			.replace(FUNCTION_CONTENT_REGEX, "")
+			.replace(INDENT_MULTILINE_REGEX, "")
+			.replace(LINE_SEPARATOR_REGEX, "\n");
+	}
 
-		if (generateContext.concatenationScope) {
-			const source = new ConcatSource();
-			const usedIdentifiers = new Set();
-			for (const [k, v] of cssExports) {
-				let identifier = Template.toIdentifier(k);
-				let i = 0;
-				while (usedIdentifiers.has(identifier)) {
-					identifier = Template.toIdentifier(k + i);
-				}
-				usedIdentifiers.add(identifier);
-				generateContext.concatenationScope.registerExport(k, identifier);
-				source.add(
-					`${
-						generateContext.runtimeTemplate.supportsConst ? "const" : "var"
-					} ${identifier} = ${JSON.stringify(v)};\n`
-				);
-			}
-			return source;
-		} else {
-			const otherUsed =
-				generateContext.moduleGraph
-					.getExportsInfo(module)
-					.otherExportsInfo.getUsed(generateContext.runtime) !==
-				UsageState.Unused;
-			if (otherUsed) {
-				generateContext.runtimeRequirements.add(
-					RuntimeGlobals.makeNamespaceObject
-				);
-			}
-			return new RawSource(
-				`${otherUsed ? `${RuntimeGlobals.makeNamespaceObject}(` : ""}${
-					module.moduleArgument
-				}.exports = {\n${Array.from(
-					cssExports,
-					([k, v]) => `\t${JSON.stringify(k)}: ${JSON.stringify(v)}`
-				).join(",\n")}\n}${otherUsed ? ")" : ""};`
-			);
-		}
+	/**
+	 * @param {string} str the string converted to identifier
+	 * @returns {string} created identifier
+	 */
+	static toIdentifier(str) {
+		if (typeof str !== "string") return "";
+		return str
+			.replace(IDENTIFIER_NAME_REPLACE_REGEX, "_$1")
+			.replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, "_");
+	}
+	/**
+	 *
+	 * @param {string} str string to be converted to commented in bundle code
+	 * @returns {string} returns a commented version of string
+	 */
+	static toComment(str) {
+		if (!str) return "";
+		return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`;
 	}
 
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 *
+	 * @param {string} str string to be converted to "normal comment"
+	 * @returns {string} returns a commented version of string
 	 */
-	getTypes(module) {
-		return TYPES;
+	static toNormalComment(str) {
+		if (!str) return "";
+		return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {string} str string path to be normalized
+	 * @returns {string} normalized bundle-safe path
 	 */
-	getSize(module, type) {
-		return 42;
+	static toPath(str) {
+		if (typeof str !== "string") return "";
+		return str
+			.replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, "-")
+			.replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, "");
 	}
 
+	// map number to a single character a-z, A-Z or multiple characters if number is too big
 	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {number} n number to convert to ident
+	 * @returns {string} returns single character ident
 	 */
-	updateHash(hash, { module }) {}
-}
+	static numberToIdentifier(n) {
+		if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
+			// use multiple letters
+			return (
+				Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) +
+				Template.numberToIdentifierContinuation(
+					Math.floor(n / NUMBER_OF_IDENTIFIER_START_CHARS)
+				)
+			);
+		}
 
-module.exports = CssExportsGenerator;
+		// lower case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+		}
+		n -= DELTA_A_TO_Z;
 
+		// upper case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+		}
 
-/***/ }),
+		if (n === DELTA_A_TO_Z) return "_";
+		return "$";
+	}
 
-/***/ 46061:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {number} n number to convert to ident
+	 * @returns {string} returns single character ident
+	 */
+	static numberToIdentifierContinuation(n) {
+		if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
+			// use multiple letters
+			return (
+				Template.numberToIdentifierContinuation(
+					n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+				) +
+				Template.numberToIdentifierContinuation(
+					Math.floor(n / NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS)
+				)
+			);
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
+		// lower case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+		}
+		n -= DELTA_A_TO_Z;
 
+		// upper case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+		}
+		n -= DELTA_A_TO_Z;
 
+		// numbers
+		if (n < 10) {
+			return `${n}`;
+		}
 
-const { ReplaceSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
+		if (n === 10) return "_";
+		return "$";
+	}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../util/Hash")} Hash */
+	/**
+	 *
+	 * @param {string | string[]} s string to convert to identity
+	 * @returns {string} converted identity
+	 */
+	static indent(s) {
+		if (Array.isArray(s)) {
+			return s.map(Template.indent).join("\n");
+		} else {
+			const str = s.trimRight();
+			if (!str) return "";
+			const ind = str[0] === "\n" ? "" : "\t";
+			return ind + str.replace(/\n([^\n])/g, "\n\t$1");
+		}
+	}
 
-const TYPES = new Set(["css"]);
+	/**
+	 *
+	 * @param {string|string[]} s string to create prefix for
+	 * @param {string} prefix prefix to compose
+	 * @returns {string} returns new prefix string
+	 */
+	static prefix(s, prefix) {
+		const str = Template.asString(s).trim();
+		if (!str) return "";
+		const ind = str[0] === "\n" ? "" : prefix;
+		return ind + str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	}
 
-class CssGenerator extends Generator {
-	constructor() {
-		super();
+	/**
+	 *
+	 * @param {string|string[]} str string or string collection
+	 * @returns {string} returns a single string from array
+	 */
+	static asString(str) {
+		if (Array.isArray(str)) {
+			return str.join("\n");
+		}
+		return str;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @typedef {Object} WithId
+	 * @property {string|number} id
 	 */
-	generate(module, generateContext) {
-		const originalSource = module.originalSource();
-		const source = new ReplaceSource(originalSource);
-		const initFragments = [];
-		const cssExports = new Map();
 
-		generateContext.runtimeRequirements.add(RuntimeGlobals.hasCssModules);
+	/**
+	 * @param {WithId[]} modules a collection of modules to get array bounds for
+	 * @returns {[number, number] | false} returns the upper and lower array bounds
+	 * or false if not every module has a number based id
+	 */
+	static getModulesArrayBounds(modules) {
+		let maxId = -Infinity;
+		let minId = Infinity;
+		for (const module of modules) {
+			const moduleId = module.id;
+			if (typeof moduleId !== "number") return false;
+			if (maxId < moduleId) maxId = moduleId;
+			if (minId > moduleId) minId = moduleId;
+		}
+		if (minId < 16 + ("" + minId).length) {
+			// add minId x ',' instead of 'Array(minId).concat(…)'
+			minId = 0;
+		}
+		// start with -1 because the first module needs no comma
+		let objectOverhead = -1;
+		for (const module of modules) {
+			// module id + colon + comma
+			objectOverhead += `${module.id}`.length + 2;
+		}
+		// number of commas, or when starting non-zero the length of Array(minId).concat()
+		const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId;
+		return arrayOverhead < objectOverhead ? [minId, maxId] : false;
+	}
 
-		const templateContext = {
-			runtimeTemplate: generateContext.runtimeTemplate,
-			dependencyTemplates: generateContext.dependencyTemplates,
-			moduleGraph: generateContext.moduleGraph,
-			chunkGraph: generateContext.chunkGraph,
-			module,
-			runtime: generateContext.runtime,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			concatenationScope: generateContext.concatenationScope,
-			codeGenerationResults: generateContext.codeGenerationResults,
-			initFragments,
-			cssExports
-		};
+	/**
+	 * @param {ChunkRenderContext} renderContext render context
+	 * @param {Module[]} modules modules to render (should be ordered by identifier)
+	 * @param {function(Module): Source} renderModule function to render a module
+	 * @param {string=} prefix applying prefix strings
+	 * @returns {Source} rendered chunk modules in a Source object
+	 */
+	static renderChunkModules(renderContext, modules, renderModule, prefix = "") {
+		const { chunkGraph } = renderContext;
+		var source = new ConcatSource();
+		if (modules.length === 0) {
+			return null;
+		}
+		/** @type {{id: string|number, source: Source|string}[]} */
+		const allModules = modules.map(module => {
+			return {
+				id: chunkGraph.getModuleId(module),
+				source: renderModule(module) || "false"
+			};
+		});
+		const bounds = Template.getModulesArrayBounds(allModules);
+		if (bounds) {
+			// Render a spare array
+			const minId = bounds[0];
+			const maxId = bounds[1];
+			if (minId !== 0) {
+				source.add(`Array(${minId}).concat(`);
+			}
+			source.add("[\n");
+			/** @type {Map<string|number, {id: string|number, source: Source|string}>} */
+			const modules = new Map();
+			for (const module of allModules) {
+				modules.set(module.id, module);
+			}
+			for (let idx = minId; idx <= maxId; idx++) {
+				const module = modules.get(idx);
+				if (idx !== minId) {
+					source.add(",\n");
+				}
+				source.add(`/* ${idx} */`);
+				if (module) {
+					source.add("\n");
+					source.add(module.source);
+				}
+			}
+			source.add("\n" + prefix + "]");
+			if (minId !== 0) {
+				source.add(")");
+			}
+		} else {
+			// Render an object
+			source.add("{\n");
+			for (let i = 0; i < allModules.length; i++) {
+				const module = allModules[i];
+				if (i !== 0) {
+					source.add(",\n");
+				}
+				source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
+				source.add(module.source);
+			}
+			source.add(`\n\n${prefix}}`);
+		}
+		return source;
+	}
 
-		const handleDependency = dependency => {
-			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-				dependency.constructor
-			);
-			const template = generateContext.dependencyTemplates.get(constructor);
-			if (!template) {
-				throw new Error(
-					"No template for dependency: " + dependency.constructor.name
+	/**
+	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
+	 * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
+	 * @returns {Source} rendered runtime modules in a Source object
+	 */
+	static renderRuntimeModules(runtimeModules, renderContext) {
+		const source = new ConcatSource();
+		for (const module of runtimeModules) {
+			const codeGenerationResults = renderContext.codeGenerationResults;
+			let runtimeSource;
+			if (codeGenerationResults) {
+				runtimeSource = codeGenerationResults.getSource(
+					module,
+					renderContext.chunk.runtime,
+					"runtime"
 				);
+			} else {
+				const codeGenResult = module.codeGeneration({
+					chunkGraph: renderContext.chunkGraph,
+					dependencyTemplates: renderContext.dependencyTemplates,
+					moduleGraph: renderContext.moduleGraph,
+					runtimeTemplate: renderContext.runtimeTemplate,
+					runtime: renderContext.chunk.runtime,
+					codeGenerationResults
+				});
+				if (!codeGenResult) continue;
+				runtimeSource = codeGenResult.sources.get("runtime");
+			}
+			if (runtimeSource) {
+				source.add(Template.toNormalComment(module.identifier()) + "\n");
+				if (!module.shouldIsolate()) {
+					source.add(runtimeSource);
+					source.add("\n\n");
+				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
+					source.add("(() => {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n})();\n\n");
+				} else {
+					source.add("!function() {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n}();\n\n");
+				}
 			}
-
-			template.apply(dependency, source, templateContext);
-		};
-		module.dependencies.forEach(handleDependency);
-		if (module.presentationalDependencies !== undefined)
-			module.presentationalDependencies.forEach(handleDependency);
-
-		if (cssExports.size > 0) {
-			const data = generateContext.getData();
-			data.set("css-exports", cssExports);
 		}
-
-		return InitFragment.addToSource(source, initFragments, generateContext);
-	}
-
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
+		return source;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
+	 * @param {RenderContext} renderContext render context
+	 * @returns {Source} rendered chunk runtime modules in a Source object
 	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-
-		if (!originalSource) {
-			return 0;
-		}
-
-		return originalSource.size();
+	static renderChunkRuntimeModules(runtimeModules, renderContext) {
+		return new PrefixSource(
+			"/******/ ",
+			new ConcatSource(
+				"function(__webpack_require__) { // webpackRuntimeModules\n",
+				this.renderRuntimeModules(runtimeModules, renderContext),
+				"}\n"
+			)
+		);
 	}
-
-	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
-	 */
-	updateHash(hash, { module }) {}
 }
 
-module.exports = CssGenerator;
+module.exports = Template;
+module.exports.NUMBER_OF_IDENTIFIER_START_CHARS =
+	NUMBER_OF_IDENTIFIER_START_CHARS;
+module.exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
+	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS;
 
 
 /***/ }),
 
-/***/ 80806:
+/***/ 80734:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Jason Anderson @diurnalist
 */
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(6967);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { chunkHasCss } = __webpack_require__(47283);
-
-/** @typedef {import("../Chunk")} Chunk */
+const { basename, extname } = __webpack_require__(71017);
+const util = __webpack_require__(73837);
+const Chunk = __webpack_require__(39385);
+const Module = __webpack_require__(73208);
+const { parseResource } = __webpack_require__(82186);
 
-/**
- * @typedef {Object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
- */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Compiler")} Compiler */
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
+const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
 
-class CssLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				createStylesheet: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
+const prepareId = id => {
+	if (typeof id !== "string") return id;
 
-	constructor(runtimeRequirements, runtimeOptions) {
-		super("css loading", 10);
+	if (/^"\s\+*.*\+\s*"$/.test(id)) {
+		const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
 
-		this._runtimeRequirements = runtimeRequirements;
-		this.runtimeOptions = runtimeOptions;
+		return `" + (${match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, chunk, _runtimeRequirements } = this;
-		const {
-			chunkGraph,
-			runtimeTemplate,
-			outputOptions: {
-				crossOriginLoading,
-				uniqueName,
-				chunkLoadTimeout: loadTimeout
-			}
-		} = compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const conditionMap = chunkGraph.getChunkConditionMap(
-			chunk,
-			(chunk, chunkGraph) =>
-				!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css")
-		);
-		const hasCssMatcher = compileBooleanMatcher(conditionMap);
-
-		const withLoading =
-			_runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
-			hasCssMatcher !== false;
-		const withHmr = _runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const initialChunkIdsWithCss = new Set();
-		const initialChunkIdsWithoutCss = new Set();
-		for (const c of chunk.getAllInitialChunks()) {
-			(chunkHasCss(c, chunkGraph)
-				? initialChunkIdsWithCss
-				: initialChunkIdsWithoutCss
-			).add(c.id);
-		}
-
-		if (!withLoading && !withHmr && initialChunkIdsWithCss.size === 0) {
-			return null;
-		}
-
-		const { createStylesheet } =
-			CssLoadingRuntimeModule.getCompilationHooks(compilation);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_css`
-			: undefined;
+	return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+};
 
-		const code = Template.asString([
-			"link = document.createElement('link');",
-			uniqueName
-				? 'link.setAttribute("data-webpack", uniqueName + ":" + key);'
-				: "",
-			"link.setAttribute(loadingAttribute, 1);",
-			'link.rel = "stylesheet";',
-			"link.href = url;",
-			crossOriginLoading
-				? Template.asString([
-						"if (link.src.indexOf(window.location.origin + '/') !== 0) {",
-						Template.indent(
-							`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
-						),
-						"}"
-				  ])
-				: ""
-		]);
+const hashLength = (replacer, handler, assetInfo, hashName) => {
+	const fn = (match, arg, input) => {
+		let result;
+		const length = arg && parseInt(arg, 10);
 
-		const cc = str => str.charCodeAt(0);
+		if (length && handler) {
+			result = handler(length);
+		} else {
+			const hash = replacer(match, arg, input);
 
-		return Template.asString([
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{${Array.from(
-				initialChunkIdsWithoutCss,
-				id => `${JSON.stringify(id)}:0`
-			).join(",")}};`,
-			"",
-			uniqueName
-				? `var uniqueName = ${JSON.stringify(
-						runtimeTemplate.outputOptions.uniqueName
-				  )};`
-				: "// data-webpack is not used as build has no uniqueName",
-			`var loadCssChunkData = ${runtimeTemplate.basicFunction(
-				"target, link, chunkId",
-				[
-					`var data, token = "", token2, exports = {}, exportsWithId = [], exportsWithDashes = [], ${
-						withHmr ? "moduleIds = [], " : ""
-					}i = 0, cc = 1;`,
-					"try { if(!link) link = loadStylesheet(chunkId); data = link.sheet.cssRules; data = data[data.length - 1].style; } catch(e) { data = getComputedStyle(document.head); }",
-					`data = data.getPropertyValue(${
-						uniqueName
-							? runtimeTemplate.concatenation(
-									"--webpack-",
-									{ expr: "uniqueName" },
-									"-",
-									{ expr: "chunkId" }
-							  )
-							: runtimeTemplate.concatenation("--webpack-", { expr: "chunkId" })
-					});`,
-					"if(!data) return [];",
-					"for(; cc; i++) {",
-					Template.indent([
-						"cc = data.charCodeAt(i);",
-						`if(cc == ${cc("(")}) { token2 = token; token = ""; }`,
-						`else if(cc == ${cc(
-							")"
-						)}) { exports[token2.replace(/^_/, "")] = token.replace(/^_/, ""); token = ""; }`,
-						`else if(cc == ${cc("/")} || cc == ${cc(
-							"%"
-						)}) { token = token.replace(/^_/, ""); exports[token] = token; exportsWithId.push(token); if(cc == ${cc(
-							"%"
-						)}) exportsWithDashes.push(token); token = ""; }`,
-						`else if(!cc || cc == ${cc(
-							","
-						)}) { token = token.replace(/^_/, ""); exportsWithId.forEach(${runtimeTemplate.expressionFunction(
-							`exports[x] = ${
-								uniqueName
-									? runtimeTemplate.concatenation(
-											{ expr: "uniqueName" },
-											"-",
-											{ expr: "token" },
-											"-",
-											{ expr: "exports[x]" }
-									  )
-									: runtimeTemplate.concatenation({ expr: "token" }, "-", {
-											expr: "exports[x]"
-									  })
-							}`,
-							"x"
-						)}); exportsWithDashes.forEach(${runtimeTemplate.expressionFunction(
-							`exports[x] = "--" + exports[x]`,
-							"x"
-						)}); ${
-							RuntimeGlobals.makeNamespaceObject
-						}(exports); target[token] = (${runtimeTemplate.basicFunction(
-							"exports, module",
-							`module.exports = exports;`
-						)}).bind(null, exports); ${
-							withHmr ? "moduleIds.push(token); " : ""
-						}token = ""; exports = {}; exportsWithId.length = 0; }`,
-						`else if(cc == ${cc("\\")}) { token += data[++i] }`,
-						`else { token += data[i]; }`
-					]),
-					"}",
-					`${
-						withHmr ? `if(target == ${RuntimeGlobals.moduleFactories}) ` : ""
-					}installedChunks[chunkId] = 0;`,
-					withHmr ? "return moduleIds;" : ""
-				]
-			)}`,
-			'var loadingAttribute = "data-webpack-loading";',
-			`var loadStylesheet = ${runtimeTemplate.basicFunction(
-				"chunkId, url, done" + (withHmr ? ", hmr" : ""),
-				[
-					'var link, needAttach, key = "chunk-" + chunkId;',
-					withHmr ? "if(!hmr) {" : "",
-					'var links = document.getElementsByTagName("link");',
-					"for(var i = 0; i < links.length; i++) {",
-					Template.indent([
-						"var l = links[i];",
-						`if(l.rel == "stylesheet" && (${
-							withHmr
-								? 'l.href.startsWith(url) || l.getAttribute("href").startsWith(url)'
-								: 'l.href == url || l.getAttribute("href") == url'
-						}${
-							uniqueName
-								? ' || l.getAttribute("data-webpack") == uniqueName + ":" + key'
-								: ""
-						})) { link = l; break; }`
-					]),
-					"}",
-					"if(!done) return link;",
-					withHmr ? "}" : "",
-					"if(!link) {",
-					Template.indent([
-						"needAttach = true;",
-						createStylesheet.call(code, this.chunk)
-					]),
-					"}",
-					`var onLinkComplete = ${runtimeTemplate.basicFunction(
-						"prev, event",
-						Template.asString([
-							"link.onerror = link.onload = null;",
-							"link.removeAttribute(loadingAttribute);",
-							"clearTimeout(timeout);",
-							'if(event && event.type != "load") link.parentNode.removeChild(link)',
-							"done(event);",
-							"if(prev) return prev(event);"
-						])
-					)};`,
-					"if(link.getAttribute(loadingAttribute)) {",
-					Template.indent([
-						`var timeout = setTimeout(onLinkComplete.bind(null, undefined, { type: 'timeout', target: link }), ${loadTimeout});`,
-						"link.onerror = onLinkComplete.bind(null, link.onerror);",
-						"link.onload = onLinkComplete.bind(null, link.onload);"
-					]),
-					"} else onLinkComplete(undefined, { type: 'load', target: link });", // We assume any existing stylesheet is render blocking
-					withHmr ? "hmr ? document.head.insertBefore(link, hmr) :" : "",
-					"needAttach && document.head.appendChild(link);",
-					"return link;"
-				]
-			)};`,
-			initialChunkIdsWithCss.size > 2
-				? `${JSON.stringify(
-						Array.from(initialChunkIdsWithCss)
-				  )}.forEach(loadCssChunkData.bind(null, ${
-						RuntimeGlobals.moduleFactories
-				  }, 0));`
-				: initialChunkIdsWithCss.size > 0
-				? `${Array.from(
-						initialChunkIdsWithCss,
-						id =>
-							`loadCssChunkData(${
-								RuntimeGlobals.moduleFactories
-							}, 0, ${JSON.stringify(id)});`
-				  ).join("")}`
-				: "// no initial css",
-			"",
-			withLoading
-				? Template.asString([
-						`${fn}.css = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasCssMatcher !== false
-								? [
-										"// css chunk loading",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[2]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasCssMatcher === true
-													? "if(true) { // all chunks have CSS"
-													: `if(${hasCssMatcher("chunkId")}) {`,
-												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
-														"resolve, reject"
-													)});`,
-													"promises.push(installedChunkData[2] = promise);",
-													"",
-													"// start chunk loading",
-													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
-													"// create error before stack unwound to get useful stacktrace later",
-													"var error = new Error();",
-													`var loadingEnded = ${runtimeTemplate.basicFunction(
-														"event",
-														[
-															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
-															Template.indent([
-																"installedChunkData = installedChunks[chunkId];",
-																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
-																"if(installedChunkData) {",
-																Template.indent([
-																	'if(event.type !== "load") {',
-																	Template.indent([
-																		"var errorType = event && event.type;",
-																		"var realSrc = event && event.target && event.target.src;",
-																		"error.message = 'Loading css chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-																		"error.name = 'ChunkLoadError';",
-																		"error.type = errorType;",
-																		"error.request = realSrc;",
-																		"installedChunkData[1](error);"
-																	]),
-																	"} else {",
-																	Template.indent([
-																		`loadCssChunkData(${RuntimeGlobals.moduleFactories}, link, chunkId);`,
-																		"installedChunkData[0]();"
-																	]),
-																	"}"
-																]),
-																"}"
-															]),
-															"}"
-														]
-													)};`,
-													"var link = loadStylesheet(chunkId, url, loadingEnded);"
-												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 0;"
-						)};`
-				  ])
-				: "// no chunk loading",
-			"",
-			withHmr
-				? Template.asString([
-						"var oldTags = [];",
-						"var newTags = [];",
-						`var applyHandler = ${runtimeTemplate.basicFunction("options", [
-							`return { dispose: ${runtimeTemplate.basicFunction(
-								"",
-								[]
-							)}, apply: ${runtimeTemplate.basicFunction("", [
-								"var moduleIds = [];",
-								`newTags.forEach(${runtimeTemplate.expressionFunction(
-									"info[1].sheet.disabled = false",
-									"info"
-								)});`,
-								"while(oldTags.length) {",
-								Template.indent([
-									"var oldTag = oldTags.pop();",
-									"if(oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);"
-								]),
-								"}",
-								"while(newTags.length) {",
-								Template.indent([
-									`var info = newTags.pop();`,
-									`var chunkModuleIds = loadCssChunkData(${RuntimeGlobals.moduleFactories}, info[1], info[0]);`,
-									`chunkModuleIds.forEach(${runtimeTemplate.expressionFunction(
-										"moduleIds.push(id)",
-										"id"
-									)});`
-								]),
-								"}",
-								"return moduleIds;"
-							])} };`
-						])}`,
-						`var cssTextKey = ${runtimeTemplate.returningFunction(
-							`Array.from(link.sheet.cssRules, ${runtimeTemplate.returningFunction(
-								"r.cssText",
-								"r"
-							)}).join()`,
-							"link"
-						)}`,
-						`${
-							RuntimeGlobals.hmrDownloadUpdateHandlers
-						}.css = ${runtimeTemplate.basicFunction(
-							"chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList",
-							[
-								"applyHandlers.push(applyHandler);",
-								`chunkIds.forEach(${runtimeTemplate.basicFunction("chunkId", [
-									`var filename = ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
-									`var url = ${RuntimeGlobals.publicPath} + filename;`,
-									"var oldTag = loadStylesheet(chunkId, url);",
-									"if(!oldTag) return;",
-									`promises.push(new Promise(${runtimeTemplate.basicFunction(
-										"resolve, reject",
-										[
-											`var link = loadStylesheet(chunkId, url + (url.indexOf("?") < 0 ? "?" : "&") + "hmr=" + Date.now(), ${runtimeTemplate.basicFunction(
-												"event",
-												[
-													'if(event.type !== "load") {',
-													Template.indent([
-														"var errorType = event && event.type;",
-														"var realSrc = event && event.target && event.target.src;",
-														"error.message = 'Loading css hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-														"error.name = 'ChunkLoadError';",
-														"error.type = errorType;",
-														"error.request = realSrc;",
-														"reject(error);"
-													]),
-													"} else {",
-													Template.indent([
-														"try { if(cssTextKey(oldTag) == cssTextKey(link)) { if(link.parentNode) link.parentNode.removeChild(link); return resolve(); } } catch(e) {}",
-														"var factories = {};",
-														"loadCssChunkData(factories, link, chunkId);",
-														`Object.keys(factories).forEach(${runtimeTemplate.expressionFunction(
-															"updatedModulesList.push(id)",
-															"id"
-														)})`,
-														"link.sheet.disabled = true;",
-														"oldTags.push(oldTag);",
-														"newTags.push([chunkId, link]);",
-														"resolve();"
-													]),
-													"}"
-												]
-											)}, oldTag);`
-										]
-									)}));`
-								])});`
-							]
-						)}`
-				  ])
-				: "// no hmr"
-		]);
+			result = length ? hash.slice(0, length) : hash;
+		}
+		if (assetInfo) {
+			assetInfo.immutable = true;
+			if (Array.isArray(assetInfo[hashName])) {
+				assetInfo[hashName] = [...assetInfo[hashName], result];
+			} else if (assetInfo[hashName]) {
+				assetInfo[hashName] = [assetInfo[hashName], result];
+			} else {
+				assetInfo[hashName] = result;
+			}
+		}
+		return result;
+	};
+
+	return fn;
+};
+
+const replacer = (value, allowEmpty) => {
+	const fn = (match, arg, input) => {
+		if (typeof value === "function") {
+			value = value();
+		}
+		if (value === null || value === undefined) {
+			if (!allowEmpty) {
+				throw new Error(
+					`Path variable ${match} not implemented in this context: ${input}`
+				);
+			}
+
+			return "";
+		} else {
+			return `${value}`;
+		}
+	};
+
+	return fn;
+};
+
+const deprecationCache = new Map();
+const deprecatedFunction = (() => () => {})();
+const deprecated = (fn, message, code) => {
+	let d = deprecationCache.get(message);
+	if (d === undefined) {
+		d = util.deprecate(deprecatedFunction, message, code);
+		deprecationCache.set(message, d);
+	}
+	return (...args) => {
+		d();
+		return fn(...args);
+	};
+};
+
+/**
+ * @param {string | function(PathData, AssetInfo=): string} path the raw path
+ * @param {PathData} data context data
+ * @param {AssetInfo} assetInfo extra info about the asset (will be written to)
+ * @returns {string} the interpolated path
+ */
+const replacePathVariables = (path, data, assetInfo) => {
+	const chunkGraph = data.chunkGraph;
+
+	/** @type {Map<string, Function>} */
+	const replacements = new Map();
+
+	// Filename context
+	//
+	// Placeholders
+	//
+	// for /some/path/file.js?query#fragment:
+	// [file] - /some/path/file.js
+	// [query] - ?query
+	// [fragment] - #fragment
+	// [base] - file.js
+	// [path] - /some/path/
+	// [name] - file
+	// [ext] - .js
+	if (typeof data.filename === "string") {
+		const { path: file, query, fragment } = parseResource(data.filename);
+
+		const ext = extname(file);
+		const base = basename(file);
+		const name = base.slice(0, base.length - ext.length);
+		const path = file.slice(0, file.length - base.length);
+
+		replacements.set("file", replacer(file));
+		replacements.set("query", replacer(query, true));
+		replacements.set("fragment", replacer(fragment, true));
+		replacements.set("path", replacer(path, true));
+		replacements.set("base", replacer(base));
+		replacements.set("name", replacer(name));
+		replacements.set("ext", replacer(ext, true));
+		// Legacy
+		replacements.set(
+			"filebase",
+			deprecated(
+				replacer(base),
+				"[filebase] is now [base]",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+			)
+		);
+	}
+
+	// Compilation context
+	//
+	// Placeholders
+	//
+	// [fullhash] - data.hash (3a4b5c6e7f)
+	//
+	// Legacy Placeholders
+	//
+	// [hash] - data.hash (3a4b5c6e7f)
+	if (data.hash) {
+		const hashReplacer = hashLength(
+			replacer(data.hash),
+			data.hashWithLength,
+			assetInfo,
+			"fullhash"
+		);
+
+		replacements.set("fullhash", hashReplacer);
+
+		// Legacy
+		replacements.set(
+			"hash",
+			deprecated(
+				hashReplacer,
+				"[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH"
+			)
+		);
+	}
+
+	// Chunk Context
+	//
+	// Placeholders
+	//
+	// [id] - chunk.id (0.js)
+	// [name] - chunk.name (app.js)
+	// [chunkhash] - chunk.hash (7823t4t4.js)
+	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+	if (data.chunk) {
+		const chunk = data.chunk;
+
+		const contentHashType = data.contentHashType;
+
+		const idReplacer = replacer(chunk.id);
+		const nameReplacer = replacer(chunk.name || chunk.id);
+		const chunkhashReplacer = hashLength(
+			replacer(chunk instanceof Chunk ? chunk.renderedHash : chunk.hash),
+			"hashWithLength" in chunk ? chunk.hashWithLength : undefined,
+			assetInfo,
+			"chunkhash"
+		);
+		const contenthashReplacer = hashLength(
+			replacer(
+				data.contentHash ||
+					(contentHashType &&
+						chunk.contentHash &&
+						chunk.contentHash[contentHashType])
+			),
+			data.contentHashWithLength ||
+				("contentHashWithLength" in chunk && chunk.contentHashWithLength
+					? chunk.contentHashWithLength[contentHashType]
+					: undefined),
+			assetInfo,
+			"contenthash"
+		);
+
+		replacements.set("id", idReplacer);
+		replacements.set("name", nameReplacer);
+		replacements.set("chunkhash", chunkhashReplacer);
+		replacements.set("contenthash", contenthashReplacer);
+	}
+
+	// Module Context
+	//
+	// Placeholders
+	//
+	// [id] - module.id (2.png)
+	// [hash] - module.hash (6237543873.png)
+	//
+	// Legacy Placeholders
+	//
+	// [moduleid] - module.id (2.png)
+	// [modulehash] - module.hash (6237543873.png)
+	if (data.module) {
+		const module = data.module;
+
+		const idReplacer = replacer(() =>
+			prepareId(
+				module instanceof Module ? chunkGraph.getModuleId(module) : module.id
+			)
+		);
+		const moduleHashReplacer = hashLength(
+			replacer(() =>
+				module instanceof Module
+					? chunkGraph.getRenderedModuleHash(module, data.runtime)
+					: module.hash
+			),
+			"hashWithLength" in module ? module.hashWithLength : undefined,
+			assetInfo,
+			"modulehash"
+		);
+		const contentHashReplacer = hashLength(
+			replacer(data.contentHash),
+			undefined,
+			assetInfo,
+			"contenthash"
+		);
+
+		replacements.set("id", idReplacer);
+		replacements.set("modulehash", moduleHashReplacer);
+		replacements.set("contenthash", contentHashReplacer);
+		replacements.set(
+			"hash",
+			data.contentHash ? contentHashReplacer : moduleHashReplacer
+		);
+		// Legacy
+		replacements.set(
+			"moduleid",
+			deprecated(
+				idReplacer,
+				"[moduleid] is now [id]",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID"
+			)
+		);
+	}
+
+	// Other things
+	if (data.url) {
+		replacements.set("url", replacer(data.url));
+	}
+	if (typeof data.runtime === "string") {
+		replacements.set(
+			"runtime",
+			replacer(() => prepareId(data.runtime))
+		);
+	} else {
+		replacements.set("runtime", replacer("_"));
+	}
+
+	if (typeof path === "function") {
+		path = path(data, assetInfo);
+	}
+
+	path = path.replace(REGEXP, (match, content) => {
+		if (content.length + 2 === match.length) {
+			const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
+			if (!contentMatch) return match;
+			const [, kind, arg] = contentMatch;
+			const replacer = replacements.get(kind);
+			if (replacer !== undefined) {
+				return replacer(match, arg, path);
+			}
+		} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
+			return `[${match.slice(2, -2)}]`;
+		}
+		return match;
+	});
+
+	return path;
+};
+
+const plugin = "TemplatedPathPlugin";
+
+class TemplatedPathPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(plugin, compilation => {
+			compilation.hooks.assetPath.tap(plugin, replacePathVariables);
+		});
 	}
 }
 
-module.exports = CssLoadingRuntimeModule;
+module.exports = TemplatedPathPlugin;
 
 
 /***/ }),
 
-/***/ 47283:
+/***/ 68099:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const HotUpdateChunk = __webpack_require__(9597);
-const RuntimeGlobals = __webpack_require__(16475);
-const SelfModuleFactory = __webpack_require__(63560);
-const CssExportDependency = __webpack_require__(76760);
-const CssImportDependency = __webpack_require__(90542);
-const CssLocalIdentifierDependency = __webpack_require__(92328);
-const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
-const CssUrlDependency = __webpack_require__(70749);
-const StaticExportsDependency = __webpack_require__(91418);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const memoize = __webpack_require__(78676);
-const CssExportsGenerator = __webpack_require__(91254);
-const CssGenerator = __webpack_require__(46061);
-const CssParser = __webpack_require__(98305);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+class UnhandledSchemeError extends WebpackError {
+	/**
+	 * @param {string} scheme scheme
+	 * @param {string} resource resource
+	 */
+	constructor(scheme, resource) {
+		super(
+			`Reading from "${resource}" is not handled by plugins (Unhandled scheme).` +
+				'\nWebpack supports "data:" and "file:" URIs by default.' +
+				`\nYou may need an additional plugin to handle "${scheme}:" URIs.`
+		);
+		this.file = resource;
+		this.name = "UnhandledSchemeError";
+	}
+}
 
-const getCssLoadingRuntimeModule = memoize(() =>
-	__webpack_require__(80806)
+makeSerializable(
+	UnhandledSchemeError,
+	"webpack/lib/UnhandledSchemeError",
+	"UnhandledSchemeError"
 );
 
-const getSchema = name => {
-	const { definitions } = __webpack_require__(73342);
-	return {
-		definitions,
-		oneOf: [{ $ref: `#/definitions/${name}` }]
-	};
-};
+module.exports = UnhandledSchemeError;
 
-const validateGeneratorOptions = createSchemaValidation(
-	__webpack_require__(59170),
-	() => getSchema("CssGeneratorOptions"),
-	{
-		name: "Css Modules Plugin",
-		baseDataPath: "parser"
-	}
-);
-const validateParserOptions = createSchemaValidation(
-	__webpack_require__(38542),
-	() => getSchema("CssParserOptions"),
-	{
-		name: "Css Modules Plugin",
-		baseDataPath: "parser"
-	}
-);
 
-const escapeCss = (str, omitOptionalUnderscore) => {
-	const escaped = `${str}`.replace(
-		// cspell:word uffff
-		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
-		s => `\\${s}`
-	);
-	return !omitOptionalUnderscore && /^(?!--)[0-9_-]/.test(escaped)
-		? `_${escaped}`
-		: escaped;
-};
+/***/ }),
 
-const plugin = "CssModulesPlugin";
+/***/ 42495:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-class CssModulesPlugin {
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+
+class UnsupportedFeatureWarning extends WebpackError {
 	/**
-	 * @param {CssExperimentOptions} options options
+	 * @param {string} message description of warning
+	 * @param {DependencyLocation} loc location start and end positions of the module
 	 */
-	constructor({ exportsOnly = false }) {
-		this._exportsOnly = exportsOnly;
+	constructor(message, loc) {
+		super(message);
+
+		this.name = "UnsupportedFeatureWarning";
+		this.loc = loc;
+		this.hideStack = true;
 	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			plugin,
-			(compilation, { normalModuleFactory }) => {
-				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
-				compilation.dependencyFactories.set(
-					CssUrlDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CssUrlDependency,
-					new CssUrlDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					CssLocalIdentifierDependency,
-					new CssLocalIdentifierDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					CssSelfLocalIdentifierDependency,
-					selfFactory
-				);
-				compilation.dependencyTemplates.set(
-					CssSelfLocalIdentifierDependency,
-					new CssSelfLocalIdentifierDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					CssExportDependency,
-					new CssExportDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					CssImportDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CssImportDependency,
-					new CssImportDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					StaticExportsDependency,
-					new StaticExportsDependency.Template()
-				);
-				normalModuleFactory.hooks.createParser
-					.for("css")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						return new CssParser();
-					});
-				normalModuleFactory.hooks.createParser
-					.for("css/global")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						return new CssParser({
-							allowPseudoBlocks: false,
-							allowModeSwitch: false
-						});
-					});
-				normalModuleFactory.hooks.createParser
-					.for("css/module")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						return new CssParser({
-							defaultMode: "local"
-						});
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("css")
-					.tap(plugin, generatorOptions => {
-						validateGeneratorOptions(generatorOptions);
-						return this._exportsOnly
-							? new CssExportsGenerator()
-							: new CssGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("css/global")
-					.tap(plugin, generatorOptions => {
-						validateGeneratorOptions(generatorOptions);
-						return this._exportsOnly
-							? new CssExportsGenerator()
-							: new CssGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("css/module")
-					.tap(plugin, generatorOptions => {
-						validateGeneratorOptions(generatorOptions);
-						return this._exportsOnly
-							? new CssExportsGenerator()
-							: new CssGenerator();
-					});
-				const orderedCssModulesPerChunk = new WeakMap();
-				compilation.hooks.afterCodeGeneration.tap("CssModulesPlugin", () => {
-					const { chunkGraph } = compilation;
-					for (const chunk of compilation.chunks) {
-						if (CssModulesPlugin.chunkHasCss(chunk, chunkGraph)) {
-							orderedCssModulesPerChunk.set(
-								chunk,
-								this.getOrderedChunkCssModules(chunk, chunkGraph, compilation)
-							);
-						}
-					}
-				});
-				compilation.hooks.contentHash.tap("CssModulesPlugin", chunk => {
-					const {
-						chunkGraph,
-						outputOptions: {
-							hashSalt,
-							hashDigest,
-							hashDigestLength,
-							hashFunction
-						}
-					} = compilation;
-					const modules = orderedCssModulesPerChunk.get(chunk);
-					if (modules === undefined) return;
-					const hash = createHash(hashFunction);
-					if (hashSalt) hash.update(hashSalt);
-					for (const module of modules) {
-						hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
-					}
-					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.css = digest.substr(0, hashDigestLength);
-				});
-				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
-					const { chunkGraph } = compilation;
-					const { hash, chunk, codeGenerationResults } = options;
+}
 
-					if (chunk instanceof HotUpdateChunk) return result;
+makeSerializable(
+	UnsupportedFeatureWarning,
+	"webpack/lib/UnsupportedFeatureWarning"
+);
 
-					const modules = orderedCssModulesPerChunk.get(chunk);
-					if (modules !== undefined) {
-						result.push({
-							render: () =>
-								this.renderChunk({
-									chunk,
-									chunkGraph,
-									codeGenerationResults,
-									uniqueName: compilation.outputOptions.uniqueName,
-									modules
-								}),
-							filenameTemplate: CssModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								compilation.outputOptions
-							),
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "css"
-							},
-							identifier: `css${chunk.id}`,
-							hash: chunk.contentHash.css
-						});
-					}
-					return result;
-				});
-				const enabledChunks = new WeakSet();
-				const handler = (chunk, set) => {
-					if (enabledChunks.has(chunk)) {
-						return;
-					}
-					enabledChunks.add(chunk);
+module.exports = UnsupportedFeatureWarning;
 
-					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.getChunkCssFilename);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.makeNamespaceObject);
 
-					const CssLoadingRuntimeModule = getCssLoadingRuntimeModule();
-					compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
+/***/ }),
+
+/***/ 36803:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ConstDependency = __webpack_require__(76911);
+
+/** @typedef {import("./Compiler")} Compiler */
+
+class UseStrictPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"UseStrictPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const handler = parser => {
+					parser.hooks.program.tap("UseStrictPlugin", ast => {
+						const firstNode = ast.body[0];
+						if (
+							firstNode &&
+							firstNode.type === "ExpressionStatement" &&
+							firstNode.expression.type === "Literal" &&
+							firstNode.expression.value === "use strict"
+						) {
+							// Remove "use strict" expression. It will be added later by the renderer again.
+							// This is necessary in order to not break the strict mode when webpack prepends code.
+							// @see https://github.com/webpack/webpack/issues/1970
+							const dep = new ConstDependency("", firstNode.range);
+							dep.loc = firstNode.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							parser.state.module.buildInfo.strict = true;
+						}
+					});
 				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hasCssModules)
-					.tap(plugin, handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap(plugin, handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap(plugin, handler);
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("UseStrictPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("UseStrictPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("UseStrictPlugin", handler);
 			}
 		);
 	}
+}
 
-	getModulesInOrder(chunk, modules, compilation) {
-		if (!modules) return [];
+module.exports = UseStrictPlugin;
 
-		const modulesList = [...modules];
 
-		// Get ordered list of modules per chunk group
-		// Lists are in reverse order to allow to use Array.pop()
-		const modulesByChunkGroup = Array.from(chunk.groupsIterable, chunkGroup => {
-			const sortedModules = modulesList
-				.map(module => {
-					return {
-						module,
-						index: chunkGroup.getModulePostOrderIndex(module)
-					};
-				})
-				.filter(item => item.index !== undefined)
-				.sort((a, b) => b.index - a.index)
-				.map(item => item.module);
+/***/ }),
 
-			return { list: sortedModules, set: new Set(sortedModules) };
-		});
+/***/ 56504:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (modulesByChunkGroup.length === 1)
-			return modulesByChunkGroup[0].list.reverse();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const compareModuleLists = ({ list: a }, { list: b }) => {
-			if (a.length === 0) {
-				return b.length === 0 ? 0 : 1;
-			} else {
-				if (b.length === 0) return -1;
-				return compareModulesByIdentifier(a[a.length - 1], b[b.length - 1]);
-			}
-		};
 
-		modulesByChunkGroup.sort(compareModuleLists);
 
-		const finalModules = [];
+const CaseSensitiveModulesWarning = __webpack_require__(77975);
 
-		for (;;) {
-			const failedModules = new Set();
-			const list = modulesByChunkGroup[0].list;
-			if (list.length === 0) {
-				// done, everything empty
-				break;
-			}
-			let selectedModule = list[list.length - 1];
-			let hasFailed = undefined;
-			outer: for (;;) {
-				for (const { list, set } of modulesByChunkGroup) {
-					if (list.length === 0) continue;
-					const lastModule = list[list.length - 1];
-					if (lastModule === selectedModule) continue;
-					if (!set.has(selectedModule)) continue;
-					failedModules.add(selectedModule);
-					if (failedModules.has(lastModule)) {
-						// There is a conflict, try other alternatives
-						hasFailed = lastModule;
-						continue;
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+
+class WarnCaseSensitiveModulesPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WarnCaseSensitiveModulesPlugin",
+			compilation => {
+				compilation.hooks.seal.tap("WarnCaseSensitiveModulesPlugin", () => {
+					/** @type {Map<string, Map<string, Module>>} */
+					const moduleWithoutCase = new Map();
+					for (const module of compilation.modules) {
+						const identifier = module.identifier();
+						const lowerIdentifier = identifier.toLowerCase();
+						let map = moduleWithoutCase.get(lowerIdentifier);
+						if (map === undefined) {
+							map = new Map();
+							moduleWithoutCase.set(lowerIdentifier, map);
+						}
+						map.set(identifier, module);
 					}
-					selectedModule = lastModule;
-					hasFailed = false;
-					continue outer; // restart
-				}
-				break;
-			}
-			if (hasFailed) {
-				// There is a not resolve-able conflict with the selectedModule
-				if (compilation) {
-					// TODO print better warning
-					compilation.warnings.push(
-						new Error(
-							`chunk ${
-								chunk.name || chunk.id
-							}\nConflicting order between ${hasFailed.readableIdentifier(
-								compilation.requestShortener
-							)} and ${selectedModule.readableIdentifier(
-								compilation.requestShortener
-							)}`
-						)
-					);
-				}
-				selectedModule = hasFailed;
-			}
-			// Insert the selected module into the final modules list
-			finalModules.push(selectedModule);
-			// Remove the selected module from all lists
-			for (const { list, set } of modulesByChunkGroup) {
-				const lastModule = list[list.length - 1];
-				if (lastModule === selectedModule) list.pop();
-				else if (hasFailed && set.has(selectedModule)) {
-					const idx = list.indexOf(selectedModule);
-					if (idx >= 0) list.splice(idx, 1);
-				}
+					for (const pair of moduleWithoutCase) {
+						const map = pair[1];
+						if (map.size > 1) {
+							compilation.warnings.push(
+								new CaseSensitiveModulesWarning(
+									map.values(),
+									compilation.moduleGraph
+								)
+							);
+						}
+					}
+				});
 			}
-			modulesByChunkGroup.sort(compareModuleLists);
-		}
-		return finalModules;
+		);
 	}
+}
 
-	getOrderedChunkCssModules(chunk, chunkGraph, compilation) {
-		return [
-			...this.getModulesInOrder(
-				chunk,
-				chunkGraph.getOrderedChunkModulesIterableBySourceType(
-					chunk,
-					"css-import",
-					compareModulesByIdentifier
-				),
-				compilation
-			),
-			...this.getModulesInOrder(
-				chunk,
-				chunkGraph.getOrderedChunkModulesIterableBySourceType(
-					chunk,
-					"css",
-					compareModulesByIdentifier
-				),
-				compilation
-			)
-		];
-	}
+module.exports = WarnCaseSensitiveModulesPlugin;
 
-	renderChunk({
-		uniqueName,
-		chunk,
-		chunkGraph,
-		codeGenerationResults,
-		modules
-	}) {
-		const source = new ConcatSource();
-		const metaData = [];
-		for (const module of modules) {
-			try {
-				const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
 
-				const s =
-					codeGenResult.sources.get("css") ||
-					codeGenResult.sources.get("css-import");
-				if (s) {
-					source.add(s);
-					source.add("\n");
-				}
-				const exports =
-					codeGenResult.data && codeGenResult.data.get("css-exports");
-				const moduleId = chunkGraph.getModuleId(module) + "";
-				metaData.push(
-					`${
-						exports
-							? Array.from(exports, ([n, v]) => {
-									const shortcutValue = `${
-										uniqueName ? uniqueName + "-" : ""
-									}${moduleId}-${n}`;
-									return v === shortcutValue
-										? `${escapeCss(n)}/`
-										: v === "--" + shortcutValue
-										? `${escapeCss(n)}%`
-										: `${escapeCss(n)}(${escapeCss(v)})`;
-							  }).join("")
-							: ""
-					}${escapeCss(moduleId)}`
+/***/ }),
+
+/***/ 76537:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Compiler")} Compiler */
+
+class WarnDeprecatedOptionPlugin {
+	/**
+	 * Create an instance of the plugin
+	 * @param {string} option the target option
+	 * @param {string | number} value the deprecated option value
+	 * @param {string} suggestion the suggestion replacement
+	 */
+	constructor(option, value, suggestion) {
+		this.option = option;
+		this.value = value;
+		this.suggestion = suggestion;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"WarnDeprecatedOptionPlugin",
+			compilation => {
+				compilation.warnings.push(
+					new DeprecatedOptionWarning(this.option, this.value, this.suggestion)
 				);
-			} catch (e) {
-				e.message += `\nduring rendering of css ${module.identifier()}`;
-				throw e;
 			}
-		}
-		source.add(
-			`head{--webpack-${escapeCss(
-				(uniqueName ? uniqueName + "-" : "") + chunk.id,
-				true
-			)}:${metaData.join(",")};}`
 		);
-		return source;
 	}
+}
 
-	static getChunkFilenameTemplate(chunk, outputOptions) {
-		if (chunk.cssFilenameTemplate) {
-			return chunk.cssFilenameTemplate;
-		} else if (chunk.canBeInitial()) {
-			return outputOptions.cssFilename;
-		} else {
-			return outputOptions.cssChunkFilename;
-		}
-	}
+class DeprecatedOptionWarning extends WebpackError {
+	constructor(option, value, suggestion) {
+		super();
 
-	static chunkHasCss(chunk, chunkGraph) {
-		return (
-			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css") ||
-			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css-import")
-		);
+		this.name = "DeprecatedOptionWarning";
+		this.message =
+			"configuration\n" +
+			`The value '${value}' for option '${option}' is deprecated. ` +
+			`Use '${suggestion}' instead.`;
 	}
 }
 
-module.exports = CssModulesPlugin;
+module.exports = WarnDeprecatedOptionPlugin;
 
 
 /***/ }),
 
-/***/ 98305:
+/***/ 25295:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -69005,623 +63753,170 @@ module.exports = CssModulesPlugin;
 
 
 
-const Parser = __webpack_require__(11715);
-const ConstDependency = __webpack_require__(76911);
-const CssExportDependency = __webpack_require__(76760);
-const CssImportDependency = __webpack_require__(90542);
-const CssLocalIdentifierDependency = __webpack_require__(92328);
-const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
-const CssUrlDependency = __webpack_require__(70749);
-const StaticExportsDependency = __webpack_require__(91418);
-const walkCssTokens = __webpack_require__(44124);
+const NoModeWarning = __webpack_require__(80832);
 
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./Compiler")} Compiler */
 
-const CC_LEFT_CURLY = "{".charCodeAt(0);
-const CC_RIGHT_CURLY = "}".charCodeAt(0);
-const CC_COLON = ":".charCodeAt(0);
-const CC_SLASH = "/".charCodeAt(0);
-const CC_SEMICOLON = ";".charCodeAt(0);
+class WarnNoModeSetPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap("WarnNoModeSetPlugin", compilation => {
+			compilation.warnings.push(new NoModeWarning());
+		});
+	}
+}
 
-const cssUnescape = str => {
-	return str.replace(/\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g, match => {
-		if (match.length > 2) {
-			return String.fromCharCode(parseInt(match.slice(1).trim(), 16));
-		} else {
-			return match[1];
-		}
-	});
-};
+module.exports = WarnNoModeSetPlugin;
 
-class LocConverter {
-	constructor(input) {
-		this._input = input;
-		this.line = 1;
-		this.column = 0;
-		this.pos = 0;
-	}
 
-	get(pos) {
-		if (this.pos !== pos) {
-			if (this.pos < pos) {
-				const str = this._input.slice(this.pos, pos);
-				let i = str.lastIndexOf("\n");
-				if (i === -1) {
-					this.column += str.length;
-				} else {
-					this.column = str.length - i - 1;
-					this.line++;
-					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1)
-						this.line++;
-				}
-			} else {
-				let i = this._input.lastIndexOf("\n", this.pos);
-				while (i >= pos) {
-					this.line--;
-					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
-				}
-				this.column = pos - i;
-			}
-			this.pos = pos;
-		}
-		return this;
-	}
-}
+/***/ }),
 
-const CSS_MODE_TOP_LEVEL = 0;
-const CSS_MODE_IN_RULE = 1;
-const CSS_MODE_IN_LOCAL_RULE = 2;
-const CSS_MODE_AT_IMPORT_EXPECT_URL = 3;
-// TODO implement layer and supports for @import
-const CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS = 4;
-const CSS_MODE_AT_IMPORT_EXPECT_MEDIA = 5;
-const CSS_MODE_AT_OTHER = 6;
+/***/ 65193:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const explainMode = mode => {
-	switch (mode) {
-		case CSS_MODE_TOP_LEVEL:
-			return "parsing top level css";
-		case CSS_MODE_IN_RULE:
-			return "parsing css rule content (global)";
-		case CSS_MODE_IN_LOCAL_RULE:
-			return "parsing css rule content (local)";
-		case CSS_MODE_AT_IMPORT_EXPECT_URL:
-			return "parsing @import (expecting url)";
-		case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
-			return "parsing @import (expecting optionally supports or media query)";
-		case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
-			return "parsing @import (expecting optionally media query)";
-		case CSS_MODE_AT_OTHER:
-			return "parsing at-rule";
-		default:
-			return mode;
-	}
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-class CssParser extends Parser {
-	constructor({
-		allowPseudoBlocks = true,
-		allowModeSwitch = true,
-		defaultMode = "global"
-	} = {}) {
-		super();
-		this.allowPseudoBlocks = allowPseudoBlocks;
-		this.allowModeSwitch = allowModeSwitch;
-		this.defaultMode = defaultMode;
+
+
+const { groupBy } = __webpack_require__(84953);
+const createSchemaValidation = __webpack_require__(32540);
+
+/** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+
+const validate = createSchemaValidation(
+	__webpack_require__(16711),
+	() => __webpack_require__(44246),
+	{
+		name: "Watch Ignore Plugin",
+		baseDataPath: "options"
 	}
+);
 
+const IGNORE_TIME_ENTRY = "ignore";
+
+class IgnoringWatchFileSystem {
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {WatchFileSystem} wfs original file system
+	 * @param {(string|RegExp)[]} paths ignored paths
 	 */
-	parse(source, state) {
-		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
-		} else if (typeof source === "object") {
-			throw new Error("webpackAst is unexpected for the CssParser");
-		}
-		if (source[0] === "\ufeff") {
-			source = source.slice(1);
-		}
+	constructor(wfs, paths) {
+		this.wfs = wfs;
+		this.paths = paths;
+	}
 
-		const module = state.module;
+	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
+		files = Array.from(files);
+		dirs = Array.from(dirs);
+		const ignored = path =>
+			this.paths.some(p =>
+				p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0
+			);
 
-		const declaredCssVariables = new Set();
+		const [ignoredFiles, notIgnoredFiles] = groupBy(files, ignored);
+		const [ignoredDirs, notIgnoredDirs] = groupBy(dirs, ignored);
 
-		const locConverter = new LocConverter(source);
-		let mode = CSS_MODE_TOP_LEVEL;
-		let modePos = 0;
-		let modeNestingLevel = 0;
-		let modeData = undefined;
-		let singleClassSelector = undefined;
-		let lastIdentifier = undefined;
-		const modeStack = [];
-		const isTopLevelLocal = () =>
-			modeData === "local" ||
-			(this.defaultMode === "local" && modeData === undefined);
-		const eatWhiteLine = (input, pos) => {
-			for (;;) {
-				const cc = input.charCodeAt(pos);
-				if (cc === 32 || cc === 9) {
-					pos++;
-					continue;
-				}
-				if (cc === 10) pos++;
-				break;
-			}
-			return pos;
-		};
-		const eatUntil = chars => {
-			const charCodes = Array.from({ length: chars.length }, (_, i) =>
-				chars.charCodeAt(i)
-			);
-			const arr = Array.from(
-				{ length: charCodes.reduce((a, b) => Math.max(a, b), 0) + 1 },
-				() => false
-			);
-			charCodes.forEach(cc => (arr[cc] = true));
-			return (input, pos) => {
-				for (;;) {
-					const cc = input.charCodeAt(pos);
-					if (cc < arr.length && arr[cc]) {
-						return pos;
-					}
-					pos++;
-					if (pos === input.length) return pos;
-				}
-			};
-		};
-		const eatText = (input, pos, eater) => {
-			let text = "";
-			for (;;) {
-				if (input.charCodeAt(pos) === CC_SLASH) {
-					const newPos = walkCssTokens.eatComments(input, pos);
-					if (pos !== newPos) {
-						pos = newPos;
-						if (pos === input.length) break;
-					} else {
-						text += "/";
-						pos++;
-						if (pos === input.length) break;
-					}
-				}
-				const newPos = eater(input, pos);
-				if (pos !== newPos) {
-					text += input.slice(pos, newPos);
-					pos = newPos;
-				} else {
-					break;
-				}
-				if (pos === input.length) break;
-			}
-			return [pos, text.trimRight()];
-		};
-		const eatExportName = eatUntil(":};/");
-		const eatExportValue = eatUntil("};/");
-		const parseExports = (input, pos) => {
-			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-			const cc = input.charCodeAt(pos);
-			if (cc !== CC_LEFT_CURLY)
-				throw new Error(
-					`Unexpected ${input[pos]} at ${pos} during parsing of ':export' (expected '{')`
-				);
-			pos++;
-			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-			for (;;) {
-				if (input.charCodeAt(pos) === CC_RIGHT_CURLY) break;
-				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-				if (pos === input.length) return pos;
-				let start = pos;
-				let name;
-				[pos, name] = eatText(input, pos, eatExportName);
-				if (pos === input.length) return pos;
-				if (input.charCodeAt(pos) !== CC_COLON) {
-					throw new Error(
-						`Unexpected ${input[pos]} at ${pos} during parsing of export name in ':export' (expected ':')`
-					);
-				}
-				pos++;
-				if (pos === input.length) return pos;
-				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-				if (pos === input.length) return pos;
-				let value;
-				[pos, value] = eatText(input, pos, eatExportValue);
-				if (pos === input.length) return pos;
-				const cc = input.charCodeAt(pos);
-				if (cc === CC_SEMICOLON) {
-					pos++;
-					if (pos === input.length) return pos;
-					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-					if (pos === input.length) return pos;
-				} else if (cc !== CC_RIGHT_CURLY) {
-					throw new Error(
-						`Unexpected ${input[pos]} at ${pos} during parsing of export value in ':export' (expected ';' or '}')`
-					);
-				}
-				const dep = new CssExportDependency(name, value);
-				const { line: sl, column: sc } = locConverter.get(start);
-				const { line: el, column: ec } = locConverter.get(pos);
-				dep.setLoc(sl, sc, el, ec);
-				module.addDependency(dep);
-			}
-			pos++;
-			if (pos === input.length) return pos;
-			pos = eatWhiteLine(input, pos);
-			return pos;
-		};
-		const eatPropertyName = eatUntil(":{};");
-		const processLocalDeclaration = (input, pos) => {
-			modeData = undefined;
-			const start = pos;
-			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-			const propertyNameStart = pos;
-			const [propertyNameEnd, propertyName] = eatText(
-				input,
-				pos,
-				eatPropertyName
-			);
-			if (input.charCodeAt(propertyNameEnd) !== CC_COLON) return start;
-			pos = propertyNameEnd + 1;
-			if (propertyName.startsWith("--")) {
-				// CSS Variable
-				const { line: sl, column: sc } = locConverter.get(propertyNameStart);
-				const { line: el, column: ec } = locConverter.get(propertyNameEnd);
-				const name = propertyName.slice(2);
-				const dep = new CssLocalIdentifierDependency(
-					name,
-					[propertyNameStart, propertyNameEnd],
-					"--"
-				);
-				dep.setLoc(sl, sc, el, ec);
-				module.addDependency(dep);
-				declaredCssVariables.add(name);
-			} else if (
-				propertyName === "animation-name" ||
-				propertyName === "animation"
-			) {
-				modeData = "animation";
-				lastIdentifier = undefined;
-			}
-			return pos;
-		};
-		const processDeclarationValueDone = (input, pos) => {
-			if (modeData === "animation" && lastIdentifier) {
-				const { line: sl, column: sc } = locConverter.get(lastIdentifier[0]);
-				const { line: el, column: ec } = locConverter.get(lastIdentifier[1]);
-				const name = input.slice(lastIdentifier[0], lastIdentifier[1]);
-				const dep = new CssSelfLocalIdentifierDependency(name, lastIdentifier);
-				dep.setLoc(sl, sc, el, ec);
-				module.addDependency(dep);
-			}
-		};
-		const eatKeyframes = eatUntil("{};/");
-		const eatNameInVar = eatUntil(",)};/");
-		walkCssTokens(source, {
-			isSelector: () => {
-				return mode !== CSS_MODE_IN_RULE && mode !== CSS_MODE_IN_LOCAL_RULE;
-			},
-			url: (input, start, end, contentStart, contentEnd) => {
-				const value = cssUnescape(input.slice(contentStart, contentEnd));
-				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
-						modeData.url = value;
-						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
-						break;
-					}
-					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
-					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
-						throw new Error(
-							`Unexpected ${input.slice(
-								start,
-								end
-							)} at ${start} during ${explainMode(mode)}`
-						);
-					default: {
-						const dep = new CssUrlDependency(value, [start, end], "url");
-						const { line: sl, column: sc } = locConverter.get(start);
-						const { line: el, column: ec } = locConverter.get(end);
-						dep.setLoc(sl, sc, el, ec);
-						module.addDependency(dep);
-						module.addCodeGenerationDependency(dep);
-						break;
-					}
-				}
-				return end;
-			},
-			string: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
-						modeData.url = cssUnescape(input.slice(start + 1, end - 1));
-						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
-						break;
-					}
-				}
-				return end;
-			},
-			atKeyword: (input, start, end) => {
-				const name = input.slice(start, end);
-				if (name === "@namespace") {
-					throw new Error("@namespace is not supported in bundled CSS");
-				}
-				if (name === "@import") {
-					if (mode !== CSS_MODE_TOP_LEVEL) {
-						throw new Error(
-							`Unexpected @import at ${start} during ${explainMode(mode)}`
-						);
-					}
-					mode = CSS_MODE_AT_IMPORT_EXPECT_URL;
-					modePos = end;
-					modeData = {
-						start: start,
-						url: undefined,
-						supports: undefined
-					};
-				}
-				if (name === "@keyframes") {
-					let pos = end;
-					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-					if (pos === input.length) return pos;
-					const [newPos, name] = eatText(input, pos, eatKeyframes);
-					const { line: sl, column: sc } = locConverter.get(pos);
-					const { line: el, column: ec } = locConverter.get(newPos);
-					const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
-					dep.setLoc(sl, sc, el, ec);
-					module.addDependency(dep);
-					pos = newPos;
-					if (pos === input.length) return pos;
-					if (input.charCodeAt(pos) !== CC_LEFT_CURLY) {
-						throw new Error(
-							`Unexpected ${input[pos]} at ${pos} during parsing of @keyframes (expected '{')`
-						);
-					}
-					mode = CSS_MODE_IN_LOCAL_RULE;
-					modeNestingLevel = 1;
-					return pos + 1;
-				}
-				return end;
-			},
-			semicolon: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL:
-						throw new Error(`Expected URL for @import at ${start}`);
-					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
-					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS: {
-						const { line: sl, column: sc } = locConverter.get(modeData.start);
-						const { line: el, column: ec } = locConverter.get(end);
-						end = eatWhiteLine(input, end);
-						const media = input.slice(modePos, start).trim();
-						const dep = new CssImportDependency(
-							modeData.url,
-							[modeData.start, end],
-							modeData.supports,
-							media
-						);
-						dep.setLoc(sl, sc, el, ec);
-						module.addDependency(dep);
-						break;
-					}
-					case CSS_MODE_IN_LOCAL_RULE: {
-						processDeclarationValueDone(input, start);
-						return processLocalDeclaration(input, end);
-					}
-					case CSS_MODE_IN_RULE: {
-						return end;
-					}
-				}
-				mode = CSS_MODE_TOP_LEVEL;
-				modeData = undefined;
-				singleClassSelector = undefined;
-				return end;
-			},
-			leftCurlyBracket: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL:
-						mode = isTopLevelLocal()
-							? CSS_MODE_IN_LOCAL_RULE
-							: CSS_MODE_IN_RULE;
-						modeNestingLevel = 1;
-						if (mode === CSS_MODE_IN_LOCAL_RULE)
-							return processLocalDeclaration(input, end);
-						break;
-					case CSS_MODE_IN_RULE:
-					case CSS_MODE_IN_LOCAL_RULE:
-						modeNestingLevel++;
-						break;
-				}
-				return end;
-			},
-			rightCurlyBracket: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_IN_LOCAL_RULE:
-						processDeclarationValueDone(input, start);
-					/* falls through */
-					case CSS_MODE_IN_RULE:
-						if (--modeNestingLevel === 0) {
-							mode = CSS_MODE_TOP_LEVEL;
-							modeData = undefined;
-							singleClassSelector = undefined;
-						}
-						break;
-				}
-				return end;
-			},
-			id: (input, start, end) => {
-				singleClassSelector = false;
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL:
-						if (isTopLevelLocal()) {
-							const name = input.slice(start + 1, end);
-							const dep = new CssLocalIdentifierDependency(name, [
-								start + 1,
-								end
-							]);
-							const { line: sl, column: sc } = locConverter.get(start);
-							const { line: el, column: ec } = locConverter.get(end);
-							dep.setLoc(sl, sc, el, ec);
-							module.addDependency(dep);
-						}
-						break;
-				}
-				return end;
-			},
-			identifier: (input, start, end) => {
-				singleClassSelector = false;
-				switch (mode) {
-					case CSS_MODE_IN_LOCAL_RULE:
-						if (modeData === "animation") {
-							lastIdentifier = [start, end];
-						}
-						break;
-				}
-				return end;
-			},
-			class: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						if (isTopLevelLocal()) {
-							const name = input.slice(start + 1, end);
-							const dep = new CssLocalIdentifierDependency(name, [
-								start + 1,
-								end
-							]);
-							const { line: sl, column: sc } = locConverter.get(start);
-							const { line: el, column: ec } = locConverter.get(end);
-							dep.setLoc(sl, sc, el, ec);
-							module.addDependency(dep);
-							if (singleClassSelector === undefined) singleClassSelector = name;
-						} else {
-							singleClassSelector = false;
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			leftParenthesis: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						modeStack.push(false);
-						break;
-					}
-				}
-				return end;
-			},
-			rightParenthesis: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						const newModeData = modeStack.pop();
-						if (newModeData !== false) {
-							modeData = newModeData;
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			pseudoClass: (input, start, end) => {
-				singleClassSelector = false;
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						const name = input.slice(start, end);
-						if (this.allowModeSwitch && name === ":global") {
-							modeData = "global";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else if (this.allowModeSwitch && name === ":local") {
-							modeData = "local";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else if (this.allowPseudoBlocks && name === ":export") {
-							const pos = parseExports(input, end);
-							const dep = new ConstDependency("", [start, pos]);
-							module.addPresentationalDependency(dep);
-							return pos;
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			pseudoFunction: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						const name = input.slice(start, end - 1);
-						if (this.allowModeSwitch && name === ":global") {
-							modeStack.push(modeData);
-							modeData = "global";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else if (this.allowModeSwitch && name === ":local") {
-							modeStack.push(modeData);
-							modeData = "local";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else {
-							modeStack.push(false);
-						}
-						break;
-					}
+		const watcher = this.wfs.watch(
+			notIgnoredFiles,
+			notIgnoredDirs,
+			missing,
+			startTime,
+			options,
+			(err, fileTimestamps, dirTimestamps, changedFiles, removedFiles) => {
+				if (err) return callback(err);
+				for (const path of ignoredFiles) {
+					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
 				}
-				return end;
-			},
-			function: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_IN_LOCAL_RULE: {
-						const name = input.slice(start, end - 1);
-						if (name === "var") {
-							let pos = walkCssTokens.eatWhitespaceAndComments(input, end);
-							if (pos === input.length) return pos;
-							const [newPos, name] = eatText(input, pos, eatNameInVar);
-							if (!name.startsWith("--")) return end;
-							const { line: sl, column: sc } = locConverter.get(pos);
-							const { line: el, column: ec } = locConverter.get(newPos);
-							const dep = new CssSelfLocalIdentifierDependency(
-								name.slice(2),
-								[pos, newPos],
-								"--",
-								declaredCssVariables
-							);
-							dep.setLoc(sl, sc, el, ec);
-							module.addDependency(dep);
-							return newPos;
-						}
-						break;
-					}
+
+				for (const path of ignoredDirs) {
+					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
 				}
-				return end;
+
+				callback(
+					err,
+					fileTimestamps,
+					dirTimestamps,
+					changedFiles,
+					removedFiles
+				);
 			},
-			comma: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL:
-						modeData = undefined;
-						modeStack.length = 0;
-						break;
-					case CSS_MODE_IN_LOCAL_RULE:
-						processDeclarationValueDone(input, start);
-						break;
+			callbackUndelayed
+		);
+
+		return {
+			close: () => watcher.close(),
+			pause: () => watcher.pause(),
+			getContextTimeInfoEntries: () => {
+				const dirTimestamps = watcher.getContextTimeInfoEntries();
+				for (const path of ignoredDirs) {
+					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
 				}
-				return end;
-			}
-		});
+				return dirTimestamps;
+			},
+			getFileTimeInfoEntries: () => {
+				const fileTimestamps = watcher.getFileTimeInfoEntries();
+				for (const path of ignoredFiles) {
+					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
+				}
+				return fileTimestamps;
+			},
+			getInfo:
+				watcher.getInfo &&
+				(() => {
+					const info = watcher.getInfo();
+					const { fileTimeInfoEntries, contextTimeInfoEntries } = info;
+					for (const path of ignoredFiles) {
+						fileTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
+					}
+					for (const path of ignoredDirs) {
+						contextTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
+					}
+					return info;
+				})
+		};
+	}
+}
 
-		module.buildInfo.strict = true;
-		module.buildMeta.exportsType = "namespace";
-		module.addDependency(new StaticExportsDependency([], true));
-		return state;
+class WatchIgnorePlugin {
+	/**
+	 * @param {WatchIgnorePluginOptions} options options
+	 */
+	constructor(options) {
+		validate(options);
+		this.paths = options.paths;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.afterEnvironment.tap("WatchIgnorePlugin", () => {
+			compiler.watchFileSystem = new IgnoringWatchFileSystem(
+				compiler.watchFileSystem,
+				this.paths
+			);
+		});
 	}
 }
 
-module.exports = CssParser;
+module.exports = WatchIgnorePlugin;
 
 
 /***/ }),
 
-/***/ 44124:
-/***/ (function(module) {
+/***/ 84275:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -69631,1126 +63926,645 @@ module.exports = CssParser;
 
 
 
-/**
- * @typedef {Object} CssTokenCallbacks
- * @property {function(string, number): boolean} isSelector
- * @property {function(string, number, number, number, number): number=} url
- * @property {function(string, number, number): number=} string
- * @property {function(string, number, number): number=} leftParenthesis
- * @property {function(string, number, number): number=} rightParenthesis
- * @property {function(string, number, number): number=} pseudoFunction
- * @property {function(string, number, number): number=} function
- * @property {function(string, number, number): number=} pseudoClass
- * @property {function(string, number, number): number=} atKeyword
- * @property {function(string, number, number): number=} class
- * @property {function(string, number, number): number=} identifier
- * @property {function(string, number, number): number=} id
- * @property {function(string, number, number): number=} leftCurlyBracket
- * @property {function(string, number, number): number=} rightCurlyBracket
- * @property {function(string, number, number): number=} semicolon
- * @property {function(string, number, number): number=} comma
- */
-
-/** @typedef {function(string, number, CssTokenCallbacks): number} CharHandler */
-
-// spec: https://drafts.csswg.org/css-syntax/
-
-const CC_LINE_FEED = "\n".charCodeAt(0);
-const CC_CARRIAGE_RETURN = "\r".charCodeAt(0);
-const CC_FORM_FEED = "\f".charCodeAt(0);
-
-const CC_TAB = "\t".charCodeAt(0);
-const CC_SPACE = " ".charCodeAt(0);
-
-const CC_SLASH = "/".charCodeAt(0);
-const CC_BACK_SLASH = "\\".charCodeAt(0);
-const CC_ASTERISK = "*".charCodeAt(0);
-
-const CC_LEFT_PARENTHESIS = "(".charCodeAt(0);
-const CC_RIGHT_PARENTHESIS = ")".charCodeAt(0);
-const CC_LEFT_CURLY = "{".charCodeAt(0);
-const CC_RIGHT_CURLY = "}".charCodeAt(0);
-
-const CC_QUOTATION_MARK = '"'.charCodeAt(0);
-const CC_APOSTROPHE = "'".charCodeAt(0);
-
-const CC_FULL_STOP = ".".charCodeAt(0);
-const CC_COLON = ":".charCodeAt(0);
-const CC_SEMICOLON = ";".charCodeAt(0);
-const CC_COMMA = ",".charCodeAt(0);
-const CC_PERCENTAGE = "%".charCodeAt(0);
-const CC_AT_SIGN = "@".charCodeAt(0);
-
-const CC_LOW_LINE = "_".charCodeAt(0);
-const CC_LOWER_A = "a".charCodeAt(0);
-const CC_LOWER_U = "u".charCodeAt(0);
-const CC_LOWER_E = "e".charCodeAt(0);
-const CC_LOWER_Z = "z".charCodeAt(0);
-const CC_UPPER_A = "A".charCodeAt(0);
-const CC_UPPER_E = "E".charCodeAt(0);
-const CC_UPPER_Z = "Z".charCodeAt(0);
-const CC_0 = "0".charCodeAt(0);
-const CC_9 = "9".charCodeAt(0);
-
-const CC_NUMBER_SIGN = "#".charCodeAt(0);
-const CC_PLUS_SIGN = "+".charCodeAt(0);
-const CC_HYPHEN_MINUS = "-".charCodeAt(0);
-
-const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
-const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
-
-const _isNewLine = cc => {
-	return (
-		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
-	);
-};
-
-/** @type {CharHandler} */
-const consumeSpace = (input, pos, callbacks) => {
-	let cc;
-	do {
-		pos++;
-		cc = input.charCodeAt(pos);
-	} while (_isWhiteSpace(cc));
-	return pos;
-};
-
-const _isWhiteSpace = cc => {
-	return (
-		cc === CC_LINE_FEED ||
-		cc === CC_CARRIAGE_RETURN ||
-		cc === CC_FORM_FEED ||
-		cc === CC_TAB ||
-		cc === CC_SPACE
-	);
-};
-
-/** @type {CharHandler} */
-const consumeSingleCharToken = (input, pos, callbacks) => {
-	return pos + 1;
-};
+const Stats = __webpack_require__(31743);
 
-/** @type {CharHandler} */
-const consumePotentialComment = (input, pos, callbacks) => {
-	pos++;
-	if (pos === input.length) return pos;
-	let cc = input.charCodeAt(pos);
-	if (cc !== CC_ASTERISK) return pos;
-	for (;;) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
-		while (cc === CC_ASTERISK) {
-			pos++;
-			if (pos === input.length) return pos;
-			cc = input.charCodeAt(pos);
-			if (cc === CC_SLASH) return pos + 1;
-		}
-	}
-};
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 
-/** @type {function(number): CharHandler} */
-const consumeString = end => (input, pos, callbacks) => {
-	const start = pos;
-	pos = _consumeString(input, pos, end);
-	if (callbacks.string !== undefined) {
-		pos = callbacks.string(input, start, pos);
-	}
-	return pos;
-};
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
 
-const _consumeString = (input, pos, end) => {
-	pos++;
-	for (;;) {
-		if (pos === input.length) return pos;
-		const cc = input.charCodeAt(pos);
-		if (cc === end) return pos + 1;
-		if (_isNewLine(cc)) {
-			// bad string
-			return pos;
-		}
-		if (cc === CC_BACK_SLASH) {
-			// we don't need to fully parse the escaped code point
-			// just skip over a potential new line
-			pos++;
-			if (pos === input.length) return pos;
-			pos++;
+class Watching {
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @param {WatchOptions} watchOptions options
+	 * @param {Callback<Stats>} handler completion handler
+	 */
+	constructor(compiler, watchOptions, handler) {
+		this.startTime = null;
+		this.invalid = false;
+		this.handler = handler;
+		/** @type {Callback<void>[]} */
+		this.callbacks = [];
+		/** @type {Callback<void>[] | undefined} */
+		this._closeCallbacks = undefined;
+		this.closed = false;
+		this.suspended = false;
+		this.blocked = false;
+		this._isBlocked = () => false;
+		this._onChange = () => {};
+		this._onInvalid = () => {};
+		if (typeof watchOptions === "number") {
+			this.watchOptions = {
+				aggregateTimeout: watchOptions
+			};
+		} else if (watchOptions && typeof watchOptions === "object") {
+			this.watchOptions = { ...watchOptions };
 		} else {
-			pos++;
-		}
-	}
-};
-
-const _isIdentifierStartCode = cc => {
-	return (
-		cc === CC_LOW_LINE ||
-		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
-		cc > 0x80
-	);
-};
-
-const _isDigit = cc => {
-	return cc >= CC_0 && cc <= CC_9;
-};
-
-const _startsIdentifier = (input, pos) => {
-	const cc = input.charCodeAt(pos);
-	if (cc === CC_HYPHEN_MINUS) {
-		if (pos === input.length) return false;
-		const cc = input.charCodeAt(pos + 1);
-		if (cc === CC_HYPHEN_MINUS) return true;
-		if (cc === CC_BACK_SLASH) {
-			const cc = input.charCodeAt(pos + 2);
-			return !_isNewLine(cc);
+			this.watchOptions = {};
 		}
-		return _isIdentifierStartCode(cc);
-	}
-	if (cc === CC_BACK_SLASH) {
-		const cc = input.charCodeAt(pos + 1);
-		return !_isNewLine(cc);
-	}
-	return _isIdentifierStartCode(cc);
-};
-
-/** @type {CharHandler} */
-const consumeNumberSign = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.id !== undefined) {
-			return callbacks.id(input, start, pos);
+		if (typeof this.watchOptions.aggregateTimeout !== "number") {
+			this.watchOptions.aggregateTimeout = 20;
 		}
+		this.compiler = compiler;
+		this.running = false;
+		this._initial = true;
+		this._invalidReported = true;
+		this._needRecords = true;
+		this.watcher = undefined;
+		this.pausedWatcher = undefined;
+		/** @type {Set<string>} */
+		this._collectedChangedFiles = undefined;
+		/** @type {Set<string>} */
+		this._collectedRemovedFiles = undefined;
+		this._done = this._done.bind(this);
+		process.nextTick(() => {
+			if (this._initial) this._invalidate();
+		});
 	}
-	return pos;
-};
 
-/** @type {CharHandler} */
-const consumeMinus = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	const cc = input.charCodeAt(pos);
-	if (cc === CC_FULL_STOP || _isDigit(cc)) {
-		return consumeNumericToken(input, pos, callbacks);
-	} else if (cc === CC_HYPHEN_MINUS) {
-		pos++;
-		if (pos === input.length) return pos;
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_GREATER_THAN_SIGN) {
-			return pos + 1;
+	/**
+	 * @param {ReadonlySet<string>} changedFiles changed files
+	 * @param {ReadonlySet<string>} removedFiles removed files
+	 */
+	_mergeWithCollected(changedFiles, removedFiles) {
+		if (!changedFiles) return;
+		if (!this._collectedChangedFiles) {
+			this._collectedChangedFiles = new Set(changedFiles);
+			this._collectedRemovedFiles = new Set(removedFiles);
 		} else {
-			pos = _consumeIdentifier(input, pos);
-			if (callbacks.identifier !== undefined) {
-				return callbacks.identifier(input, start, pos);
+			for (const file of changedFiles) {
+				this._collectedChangedFiles.add(file);
+				this._collectedRemovedFiles.delete(file);
+			}
+			for (const file of removedFiles) {
+				this._collectedChangedFiles.delete(file);
+				this._collectedRemovedFiles.add(file);
 			}
-		}
-	} else if (cc === CC_BACK_SLASH) {
-		if (pos + 1 === input.length) return pos;
-		const cc = input.charCodeAt(pos + 1);
-		if (_isNewLine(cc)) return pos;
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
-	} else if (_isIdentifierStartCode(cc)) {
-		pos++;
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
-	}
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeDot = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	const cc = input.charCodeAt(pos);
-	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
-	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
-		return pos;
-	pos = _consumeIdentifier(input, pos);
-	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeNumericToken = (input, pos, callbacks) => {
-	pos = _consumeNumber(input, pos);
-	if (pos === input.length) return pos;
-	if (_startsIdentifier(input, pos)) return _consumeIdentifier(input, pos);
-	const cc = input.charCodeAt(pos);
-	if (cc === CC_PERCENTAGE) return pos + 1;
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeOtherIdentifier = (input, pos, callbacks) => {
-	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (
-		pos !== input.length &&
-		!callbacks.isSelector(input, pos) &&
-		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
-	) {
-		pos++;
-		if (callbacks.function !== undefined) {
-			return callbacks.function(input, start, pos);
-		}
-	} else {
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
 		}
 	}
-	return pos;
-};
 
-/** @type {CharHandler} */
-const consumePotentialUrl = (input, pos, callbacks) => {
-	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (pos === start + 3 && input.slice(start, pos + 1) === "url(") {
-		pos++;
-		let cc = input.charCodeAt(pos);
-		while (_isWhiteSpace(cc)) {
-			pos++;
-			if (pos === input.length) return pos;
-			cc = input.charCodeAt(pos);
+	/**
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
+	 * @returns {void}
+	 */
+	_go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
+		this._initial = false;
+		if (this.startTime === null) this.startTime = Date.now();
+		this.running = true;
+		if (this.watcher) {
+			this.pausedWatcher = this.watcher;
+			this.lastWatcherStartTime = Date.now();
+			this.watcher.pause();
+			this.watcher = null;
+		} else if (!this.lastWatcherStartTime) {
+			this.lastWatcherStartTime = Date.now();
 		}
-		if (cc === CC_QUOTATION_MARK || cc === CC_APOSTROPHE) {
-			pos++;
-			const contentStart = pos;
-			pos = _consumeString(input, pos, cc);
-			const contentEnd = pos - 1;
-			cc = input.charCodeAt(pos);
-			while (_isWhiteSpace(cc)) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-			}
-			if (cc !== CC_RIGHT_PARENTHESIS) return pos;
-			pos++;
-			if (callbacks.url !== undefined)
-				return callbacks.url(input, start, pos, contentStart, contentEnd);
-			return pos;
-		} else {
-			const contentStart = pos;
-			let contentEnd;
-			for (;;) {
-				if (cc === CC_BACK_SLASH) {
-					pos++;
-					if (pos === input.length) return pos;
-					pos++;
-				} else if (_isWhiteSpace(cc)) {
-					contentEnd = pos;
-					do {
-						pos++;
-						if (pos === input.length) return pos;
-						cc = input.charCodeAt(pos);
-					} while (_isWhiteSpace(cc));
-					if (cc !== CC_RIGHT_PARENTHESIS) return pos;
-					pos++;
-					if (callbacks.url !== undefined) {
-						return callbacks.url(input, start, pos, contentStart, contentEnd);
-					}
-					return pos;
-				} else if (cc === CC_RIGHT_PARENTHESIS) {
-					contentEnd = pos;
-					pos++;
-					if (callbacks.url !== undefined) {
-						return callbacks.url(input, start, pos, contentStart, contentEnd);
-					}
-					return pos;
-				} else if (cc === CC_LEFT_PARENTHESIS) {
-					return pos;
-				} else {
-					pos++;
-				}
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
+		this.compiler.fsStartTime = Date.now();
+		if (
+			changedFiles &&
+			removedFiles &&
+			fileTimeInfoEntries &&
+			contextTimeInfoEntries
+		) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			this.compiler.fileTimestamps = fileTimeInfoEntries;
+			this.compiler.contextTimestamps = contextTimeInfoEntries;
+		} else if (this.pausedWatcher) {
+			if (this.pausedWatcher.getInfo) {
+				const {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				} = this.pausedWatcher.getInfo();
+				this._mergeWithCollected(changes, removals);
+				this.compiler.fileTimestamps = fileTimeInfoEntries;
+				this.compiler.contextTimestamps = contextTimeInfoEntries;
+			} else {
+				this._mergeWithCollected(
+					this.pausedWatcher.getAggregatedChanges &&
+						this.pausedWatcher.getAggregatedChanges(),
+					this.pausedWatcher.getAggregatedRemovals &&
+						this.pausedWatcher.getAggregatedRemovals()
+				);
+				this.compiler.fileTimestamps =
+					this.pausedWatcher.getFileTimeInfoEntries();
+				this.compiler.contextTimestamps =
+					this.pausedWatcher.getContextTimeInfoEntries();
 			}
 		}
-	} else {
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
-		return pos;
-	}
-};
+		this.compiler.modifiedFiles = this._collectedChangedFiles;
+		this._collectedChangedFiles = undefined;
+		this.compiler.removedFiles = this._collectedRemovedFiles;
+		this._collectedRemovedFiles = undefined;
 
-/** @type {CharHandler} */
-const consumePotentialPseudo = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
-		return pos;
-	pos = _consumeIdentifier(input, pos);
-	let cc = input.charCodeAt(pos);
-	if (cc === CC_LEFT_PARENTHESIS) {
-		pos++;
-		if (callbacks.pseudoFunction !== undefined) {
-			return callbacks.pseudoFunction(input, start, pos);
-		}
-		return pos;
-	}
-	if (callbacks.pseudoClass !== undefined) {
-		return callbacks.pseudoClass(input, start, pos);
-	}
-	return pos;
-};
+		const run = () => {
+			if (this.compiler.idle) {
+				return this.compiler.cache.endIdle(err => {
+					if (err) return this._done(err);
+					this.compiler.idle = false;
+					run();
+				});
+			}
+			if (this._needRecords) {
+				return this.compiler.readRecords(err => {
+					if (err) return this._done(err);
 
-/** @type {CharHandler} */
-const consumeLeftParenthesis = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.leftParenthesis !== undefined) {
-		return callbacks.leftParenthesis(input, pos - 1, pos);
-	}
-	return pos;
-};
+					this._needRecords = false;
+					run();
+				});
+			}
+			this.invalid = false;
+			this._invalidReported = false;
+			this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
+				if (err) return this._done(err);
+				const onCompiled = (err, compilation) => {
+					if (err) return this._done(err, compilation);
+					if (this.invalid) return this._done(null, compilation);
 
-/** @type {CharHandler} */
-const consumeRightParenthesis = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.rightParenthesis !== undefined) {
-		return callbacks.rightParenthesis(input, pos - 1, pos);
-	}
-	return pos;
-};
+					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
+						return this._done(null, compilation);
+					}
 
-/** @type {CharHandler} */
-const consumeLeftCurlyBracket = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.leftCurlyBracket !== undefined) {
-		return callbacks.leftCurlyBracket(input, pos - 1, pos);
-	}
-	return pos;
-};
+					process.nextTick(() => {
+						const logger = compilation.getLogger("webpack.Compiler");
+						logger.time("emitAssets");
+						this.compiler.emitAssets(compilation, err => {
+							logger.timeEnd("emitAssets");
+							if (err) return this._done(err, compilation);
+							if (this.invalid) return this._done(null, compilation);
 
-/** @type {CharHandler} */
-const consumeRightCurlyBracket = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.rightCurlyBracket !== undefined) {
-		return callbacks.rightCurlyBracket(input, pos - 1, pos);
-	}
-	return pos;
-};
+							logger.time("emitRecords");
+							this.compiler.emitRecords(err => {
+								logger.timeEnd("emitRecords");
+								if (err) return this._done(err, compilation);
 
-/** @type {CharHandler} */
-const consumeSemicolon = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.semicolon !== undefined) {
-		return callbacks.semicolon(input, pos - 1, pos);
+								if (compilation.hooks.needAdditionalPass.call()) {
+									compilation.needAdditionalPass = true;
+
+									compilation.startTime = this.startTime;
+									compilation.endTime = Date.now();
+									logger.time("done hook");
+									const stats = new Stats(compilation);
+									this.compiler.hooks.done.callAsync(stats, err => {
+										logger.timeEnd("done hook");
+										if (err) return this._done(err, compilation);
+
+										this.compiler.hooks.additionalPass.callAsync(err => {
+											if (err) return this._done(err, compilation);
+											this.compiler.compile(onCompiled);
+										});
+									});
+									return;
+								}
+								return this._done(null, compilation);
+							});
+						});
+					});
+				};
+				this.compiler.compile(onCompiled);
+			});
+		};
+
+		run();
 	}
-	return pos;
-};
 
-/** @type {CharHandler} */
-const consumeComma = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.comma !== undefined) {
-		return callbacks.comma(input, pos - 1, pos);
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Stats} the compilation stats
+	 */
+	_getStats(compilation) {
+		const stats = new Stats(compilation);
+		return stats;
 	}
-	return pos;
-};
 
-const _consumeIdentifier = (input, pos) => {
-	for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_BACK_SLASH) {
-			pos++;
-			if (pos === input.length) return pos;
-			pos++;
-		} else if (
-			_isIdentifierStartCode(cc) ||
-			_isDigit(cc) ||
-			cc === CC_HYPHEN_MINUS
+	/**
+	 * @param {Error=} err an optional error
+	 * @param {Compilation=} compilation the compilation
+	 * @returns {void}
+	 */
+	_done(err, compilation) {
+		this.running = false;
+
+		const logger = compilation && compilation.getLogger("webpack.Watching");
+
+		let stats = null;
+
+		const handleError = (err, cbs) => {
+			this.compiler.hooks.failed.call(err);
+			this.compiler.cache.beginIdle();
+			this.compiler.idle = true;
+			this.handler(err, stats);
+			if (!cbs) {
+				cbs = this.callbacks;
+				this.callbacks = [];
+			}
+			for (const cb of cbs) cb(err);
+		};
+
+		if (
+			this.invalid &&
+			!this.suspended &&
+			!this.blocked &&
+			!(this._isBlocked() && (this.blocked = true))
 		) {
-			pos++;
-		} else {
-			return pos;
+			if (compilation) {
+				logger.time("storeBuildDependencies");
+				this.compiler.cache.storeBuildDependencies(
+					compilation.buildDependencies,
+					err => {
+						logger.timeEnd("storeBuildDependencies");
+						if (err) return handleError(err);
+						this._go();
+					}
+				);
+			} else {
+				this._go();
+			}
+			return;
 		}
-	}
-};
 
-const _consumeNumber = (input, pos) => {
-	pos++;
-	if (pos === input.length) return pos;
-	let cc = input.charCodeAt(pos);
-	while (_isDigit(cc)) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
-	}
-	if (cc === CC_FULL_STOP && pos + 1 !== input.length) {
-		const next = input.charCodeAt(pos + 1);
-		if (_isDigit(next)) {
-			pos += 2;
-			cc = input.charCodeAt(pos);
-			while (_isDigit(cc)) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-			}
+		if (compilation) {
+			compilation.startTime = this.startTime;
+			compilation.endTime = Date.now();
+			stats = new Stats(compilation);
 		}
+		this.startTime = null;
+		if (err) return handleError(err);
+
+		const cbs = this.callbacks;
+		this.callbacks = [];
+		logger.time("done hook");
+		this.compiler.hooks.done.callAsync(stats, err => {
+			logger.timeEnd("done hook");
+			if (err) return handleError(err, cbs);
+			this.handler(null, stats);
+			logger.time("storeBuildDependencies");
+			this.compiler.cache.storeBuildDependencies(
+				compilation.buildDependencies,
+				err => {
+					logger.timeEnd("storeBuildDependencies");
+					if (err) return handleError(err, cbs);
+					logger.time("beginIdle");
+					this.compiler.cache.beginIdle();
+					this.compiler.idle = true;
+					logger.timeEnd("beginIdle");
+					process.nextTick(() => {
+						if (!this.closed) {
+							this.watch(
+								compilation.fileDependencies,
+								compilation.contextDependencies,
+								compilation.missingDependencies
+							);
+						}
+					});
+					for (const cb of cbs) cb(null);
+					this.compiler.hooks.afterDone.call(stats);
+				}
+			);
+		});
 	}
-	if (cc === CC_LOWER_E || cc === CC_UPPER_E) {
-		if (pos + 1 !== input.length) {
-			const next = input.charCodeAt(pos + 2);
-			if (_isDigit(next)) {
-				pos += 2;
-			} else if (
-				(next === CC_HYPHEN_MINUS || next === CC_PLUS_SIGN) &&
-				pos + 2 !== input.length
-			) {
-				const next = input.charCodeAt(pos + 2);
-				if (_isDigit(next)) {
-					pos += 3;
-				} else {
-					return pos;
+
+	/**
+	 * @param {Iterable<string>} files watched files
+	 * @param {Iterable<string>} dirs watched directories
+	 * @param {Iterable<string>} missing watched existence entries
+	 * @returns {void}
+	 */
+	watch(files, dirs, missing) {
+		this.pausedWatcher = null;
+		this.watcher = this.compiler.watchFileSystem.watch(
+			files,
+			dirs,
+			missing,
+			this.lastWatcherStartTime,
+			this.watchOptions,
+			(
+				err,
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changedFiles,
+				removedFiles
+			) => {
+				if (err) {
+					this.compiler.modifiedFiles = undefined;
+					this.compiler.removedFiles = undefined;
+					this.compiler.fileTimestamps = undefined;
+					this.compiler.contextTimestamps = undefined;
+					this.compiler.fsStartTime = undefined;
+					return this.handler(err);
 				}
-			} else {
-				return pos;
+				this._invalidate(
+					fileTimeInfoEntries,
+					contextTimeInfoEntries,
+					changedFiles,
+					removedFiles
+				);
+				this._onChange();
+			},
+			(fileName, changeTime) => {
+				if (!this._invalidReported) {
+					this._invalidReported = true;
+					this.compiler.hooks.invalid.call(fileName, changeTime);
+				}
+				this._onInvalid();
 			}
-		}
-	} else {
-		return pos;
+		);
 	}
-	cc = input.charCodeAt(pos);
-	while (_isDigit(cc)) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
+
+	/**
+	 * @param {Callback<void>=} callback signals when the build has completed again
+	 * @returns {void}
+	 */
+	invalidate(callback) {
+		if (callback) {
+			this.callbacks.push(callback);
+		}
+		if (!this._invalidReported) {
+			this._invalidReported = true;
+			this.compiler.hooks.invalid.call(null, Date.now());
+		}
+		this._onChange();
+		this._invalidate();
 	}
-	return pos;
-};
 
-/** @type {CharHandler} */
-const consumeLessThan = (input, pos, callbacks) => {
-	if (input.slice(pos + 1, pos + 4) === "!--") return pos + 4;
-	return pos + 1;
-};
+	_invalidate(
+		fileTimeInfoEntries,
+		contextTimeInfoEntries,
+		changedFiles,
+		removedFiles
+	) {
+		if (this.suspended || (this._isBlocked() && (this.blocked = true))) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			return;
+		}
 
-/** @type {CharHandler} */
-const consumeAt = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	if (_startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.atKeyword !== undefined) {
-			pos = callbacks.atKeyword(input, start, pos);
+		if (this.running) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			this.invalid = true;
+		} else {
+			this._go(
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changedFiles,
+				removedFiles
+			);
 		}
 	}
-	return pos;
-};
 
-const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
-	// https://drafts.csswg.org/css-syntax/#consume-token
-	switch (cc) {
-		case CC_LINE_FEED:
-		case CC_CARRIAGE_RETURN:
-		case CC_FORM_FEED:
-		case CC_TAB:
-		case CC_SPACE:
-			return consumeSpace;
-		case CC_QUOTATION_MARK:
-		case CC_APOSTROPHE:
-			return consumeString(cc);
-		case CC_NUMBER_SIGN:
-			return consumeNumberSign;
-		case CC_SLASH:
-			return consumePotentialComment;
-		// case CC_LEFT_SQUARE:
-		// case CC_RIGHT_SQUARE:
-		// case CC_COMMA:
-		// case CC_COLON:
-		// 	return consumeSingleCharToken;
-		case CC_COMMA:
-			return consumeComma;
-		case CC_SEMICOLON:
-			return consumeSemicolon;
-		case CC_LEFT_PARENTHESIS:
-			return consumeLeftParenthesis;
-		case CC_RIGHT_PARENTHESIS:
-			return consumeRightParenthesis;
-		case CC_LEFT_CURLY:
-			return consumeLeftCurlyBracket;
-		case CC_RIGHT_CURLY:
-			return consumeRightCurlyBracket;
-		case CC_COLON:
-			return consumePotentialPseudo;
-		case CC_PLUS_SIGN:
-			return consumeNumericToken;
-		case CC_FULL_STOP:
-			return consumeDot;
-		case CC_HYPHEN_MINUS:
-			return consumeMinus;
-		case CC_LESS_THAN_SIGN:
-			return consumeLessThan;
-		case CC_AT_SIGN:
-			return consumeAt;
-		case CC_LOWER_U:
-			return consumePotentialUrl;
-		case CC_LOW_LINE:
-			return consumeOtherIdentifier;
-		default:
-			if (_isDigit(cc)) return consumeNumericToken;
-			if (
-				(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-				(cc >= CC_UPPER_A && cc <= CC_UPPER_Z)
-			) {
-				return consumeOtherIdentifier;
-			}
-			return consumeSingleCharToken;
+	suspend() {
+		this.suspended = true;
 	}
-});
 
-/**
- * @param {string} input input css
- * @param {CssTokenCallbacks} callbacks callbacks
- * @returns {void}
- */
-module.exports = (input, callbacks) => {
-	let pos = 0;
-	while (pos < input.length) {
-		const cc = input.charCodeAt(pos);
-		if (cc < 0x80) {
-			pos = CHAR_MAP[cc](input, pos, callbacks);
-		} else {
-			pos++;
+	resume() {
+		if (this.suspended) {
+			this.suspended = false;
+			this._invalidate();
 		}
 	}
-};
 
-module.exports.eatComments = (input, pos) => {
-	loop: for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
-			if (pos === input.length) return pos;
-			let cc = input.charCodeAt(pos + 1);
-			if (cc !== CC_ASTERISK) return pos;
-			pos++;
-			for (;;) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-				while (cc === CC_ASTERISK) {
-					pos++;
-					if (pos === input.length) return pos;
-					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
-						pos++;
-						continue loop;
-					}
-				}
+	/**
+	 * @param {Callback<void>} callback signals when the watcher is closed
+	 * @returns {void}
+	 */
+	close(callback) {
+		if (this._closeCallbacks) {
+			if (callback) {
+				this._closeCallbacks.push(callback);
 			}
+			return;
 		}
-		return pos;
-	}
-};
-
-module.exports.eatWhitespaceAndComments = (input, pos) => {
-	loop: for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
-			if (pos === input.length) return pos;
-			let cc = input.charCodeAt(pos + 1);
-			if (cc !== CC_ASTERISK) return pos;
-			pos++;
-			for (;;) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-				while (cc === CC_ASTERISK) {
-					pos++;
-					if (pos === input.length) return pos;
-					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
-						pos++;
-						continue loop;
+		const finalCallback = (err, compilation) => {
+			this.running = false;
+			this.compiler.running = false;
+			this.compiler.watching = undefined;
+			this.compiler.watchMode = false;
+			this.compiler.modifiedFiles = undefined;
+			this.compiler.removedFiles = undefined;
+			this.compiler.fileTimestamps = undefined;
+			this.compiler.contextTimestamps = undefined;
+			this.compiler.fsStartTime = undefined;
+			const shutdown = err => {
+				this.compiler.hooks.watchClose.call();
+				const closeCallbacks = this._closeCallbacks;
+				this._closeCallbacks = undefined;
+				for (const cb of closeCallbacks) cb(err);
+			};
+			if (compilation) {
+				const logger = compilation.getLogger("webpack.Watching");
+				logger.time("storeBuildDependencies");
+				this.compiler.cache.storeBuildDependencies(
+					compilation.buildDependencies,
+					err2 => {
+						logger.timeEnd("storeBuildDependencies");
+						shutdown(err || err2);
 					}
-				}
+				);
+			} else {
+				shutdown(err);
 			}
-		} else if (_isWhiteSpace(cc)) {
-			pos++;
-			continue;
+		};
+
+		this.closed = true;
+		if (this.watcher) {
+			this.watcher.close();
+			this.watcher = null;
+		}
+		if (this.pausedWatcher) {
+			this.pausedWatcher.close();
+			this.pausedWatcher = null;
+		}
+		this._closeCallbacks = [];
+		if (callback) {
+			this._closeCallbacks.push(callback);
+		}
+		if (this.running) {
+			this.invalid = true;
+			this._done = finalCallback;
+		} else {
+			finalCallback();
 		}
-		return pos;
 	}
-};
+}
+
+module.exports = Watching;
 
 
 /***/ }),
 
-/***/ 2757:
+/***/ 53799:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Jarid Margolin @jaridmargolin
 */
 
 
 
-const { Tracer } = __webpack_require__(5787);
-const createSchemaValidation = __webpack_require__(32540);
-const { dirname, mkdirpSync } = __webpack_require__(17139);
-
-/** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+const inspect = (__webpack_require__(73837).inspect.custom);
+const makeSerializable = __webpack_require__(33032);
 
-const validate = createSchemaValidation(
-	__webpack_require__(37134),
-	() => __webpack_require__(50686),
-	{
-		name: "Profiling Plugin",
-		baseDataPath: "options"
-	}
-);
-let inspector = undefined;
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
-try {
-	// eslint-disable-next-line node/no-unsupported-features/node-builtins
-	inspector = __webpack_require__(31405);
-} catch (e) {
-	console.log("Unable to CPU profile in < node 8.0");
-}
+class WebpackError extends Error {
+	/**
+	 * Creates an instance of WebpackError.
+	 * @param {string=} message error message
+	 */
+	constructor(message) {
+		super(message);
 
-class Profiler {
-	constructor(inspector) {
-		this.session = undefined;
-		this.inspector = inspector;
-		this._startTime = 0;
+		this.details = undefined;
+		/** @type {Module} */
+		this.module = undefined;
+		/** @type {DependencyLocation} */
+		this.loc = undefined;
+		/** @type {boolean} */
+		this.hideStack = undefined;
+		/** @type {Chunk} */
+		this.chunk = undefined;
+		/** @type {string} */
+		this.file = undefined;
 	}
 
-	hasSession() {
-		return this.session !== undefined;
+	[inspect]() {
+		return this.stack + (this.details ? `\n${this.details}` : "");
 	}
 
-	startProfiling() {
-		if (this.inspector === undefined) {
-			return Promise.resolve();
-		}
-
-		try {
-			this.session = new inspector.Session();
-			this.session.connect();
-		} catch (_) {
-			this.session = undefined;
-			return Promise.resolve();
-		}
-
-		const hrtime = process.hrtime();
-		this._startTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
-
-		return Promise.all([
-			this.sendCommand("Profiler.setSamplingInterval", {
-				interval: 100
-			}),
-			this.sendCommand("Profiler.enable"),
-			this.sendCommand("Profiler.start")
-		]);
+	serialize({ write }) {
+		write(this.name);
+		write(this.message);
+		write(this.stack);
+		write(this.details);
+		write(this.loc);
+		write(this.hideStack);
 	}
 
-	sendCommand(method, params) {
-		if (this.hasSession()) {
-			return new Promise((res, rej) => {
-				return this.session.post(method, params, (err, params) => {
-					if (err !== null) {
-						rej(err);
-					} else {
-						res(params);
-					}
-				});
-			});
-		} else {
-			return Promise.resolve();
-		}
+	deserialize({ read }) {
+		this.name = read();
+		this.message = read();
+		this.stack = read();
+		this.details = read();
+		this.loc = read();
+		this.hideStack = read();
 	}
+}
 
-	destroy() {
-		if (this.hasSession()) {
-			this.session.disconnect();
-		}
+makeSerializable(WebpackError, "webpack/lib/WebpackError");
 
-		return Promise.resolve();
-	}
+module.exports = WebpackError;
 
-	stopProfiling() {
-		return this.sendCommand("Profiler.stop").then(({ profile }) => {
-			const hrtime = process.hrtime();
-			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
-			if (profile.startTime < this._startTime || profile.endTime > endTime) {
-				// In some cases timestamps mismatch and we need to adjust them
-				// Both process.hrtime and the inspector timestamps claim to be relative
-				// to a unknown point in time. But they do not guarantee that this is the
-				// same point in time.
-				const duration = profile.endTime - profile.startTime;
-				const ownDuration = endTime - this._startTime;
-				const untracked = Math.max(0, ownDuration - duration);
-				profile.startTime = this._startTime + untracked / 2;
-				profile.endTime = endTime - untracked / 2;
-			}
-			return { profile };
-		});
-	}
-}
 
-/**
- * an object that wraps Tracer and Profiler with a counter
- * @typedef {Object} Trace
- * @property {Tracer} trace instance of Tracer
- * @property {number} counter Counter
- * @property {Profiler} profiler instance of Profiler
- * @property {Function} end the end function
- */
+/***/ }),
 
-/**
- * @param {IntermediateFileSystem} fs filesystem used for output
- * @param {string} outputPath The location where to write the log.
- * @returns {Trace} The trace object
- */
-const createTrace = (fs, outputPath) => {
-	const trace = new Tracer();
-	const profiler = new Profiler(inspector);
-	if (/\/|\\/.test(outputPath)) {
-		const dirPath = dirname(fs, outputPath);
-		mkdirpSync(fs, dirPath);
-	}
-	const fsStream = fs.createWriteStream(outputPath);
+/***/ 97017:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	let counter = 0;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-	trace.pipe(fsStream);
-	// These are critical events that need to be inserted so that tools like
-	// chrome dev tools can load the profile.
-	trace.instantEvent({
-		name: "TracingStartedInPage",
-		id: ++counter,
-		cat: ["disabled-by-default-devtools.timeline"],
-		args: {
-			data: {
-				sessionId: "-1",
-				page: "0xfff",
-				frames: [
-					{
-						frame: "0xfff",
-						url: "webpack",
-						name: ""
-					}
-				]
-			}
-		}
-	});
 
-	trace.instantEvent({
-		name: "TracingStartedInBrowser",
-		id: ++counter,
-		cat: ["disabled-by-default-devtools.timeline"],
-		args: {
-			data: {
-				sessionId: "-1"
-			}
-		}
-	});
 
-	return {
-		trace,
-		counter,
-		profiler,
-		end: callback => {
-			trace.push("]");
-			// Wait until the write stream finishes.
-			fsStream.on("close", () => {
-				callback();
-			});
-			// Tear down the readable trace stream.
-			trace.push(null);
-		}
-	};
-};
+const IgnoreErrorModuleFactory = __webpack_require__(3);
+const WebpackIsIncludedDependency = __webpack_require__(26505);
+const {
+	toConstantDependency
+} = __webpack_require__(93998);
 
-const pluginName = "ProfilingPlugin";
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-class ProfilingPlugin {
+class WebpackIsIncludedPlugin {
 	/**
-	 * @param {ProfilingPluginOptions=} options options object
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(options = {}) {
-		validate(options);
-		this.outputPath = options.outputPath || "events.json";
-	}
-
 	apply(compiler) {
-		const tracer = createTrace(
-			compiler.intermediateFileSystem,
-			this.outputPath
-		);
-		tracer.profiler.startProfiling();
-
-		// Compiler Hooks
-		Object.keys(compiler.hooks).forEach(hookName => {
-			const hook = compiler.hooks[hookName];
-			if (hook) {
-				hook.intercept(makeInterceptorFor("Compiler", tracer)(hookName));
-			}
-		});
-
-		Object.keys(compiler.resolverFactory.hooks).forEach(hookName => {
-			const hook = compiler.resolverFactory.hooks[hookName];
-			if (hook) {
-				hook.intercept(makeInterceptorFor("Resolver", tracer)(hookName));
-			}
-		});
-
 		compiler.hooks.compilation.tap(
-			pluginName,
-			(compilation, { normalModuleFactory, contextModuleFactory }) => {
-				interceptAllHooksFor(compilation, tracer, "Compilation");
-				interceptAllHooksFor(
-					normalModuleFactory,
-					tracer,
-					"Normal Module Factory"
+			"WebpackIsIncludedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebpackIsIncludedDependency,
+					new IgnoreErrorModuleFactory(normalModuleFactory)
 				);
-				interceptAllHooksFor(
-					contextModuleFactory,
-					tracer,
-					"Context Module Factory"
+				compilation.dependencyTemplates.set(
+					WebpackIsIncludedDependency,
+					new WebpackIsIncludedDependency.Template()
 				);
-				interceptAllParserHooks(normalModuleFactory, tracer);
-				interceptAllJavascriptModulesPluginHooks(compilation, tracer);
-			}
-		);
-
-		// We need to write out the CPU profile when we are all done.
-		compiler.hooks.done.tapAsync(
-			{
-				name: pluginName,
-				stage: Infinity
-			},
-			(stats, callback) => {
-				if (compiler.watchMode) return callback();
-				tracer.profiler.stopProfiling().then(parsedResults => {
-					if (parsedResults === undefined) {
-						tracer.profiler.destroy();
-						tracer.end(callback);
-						return;
-					}
-
-					const cpuStartTime = parsedResults.profile.startTime;
-					const cpuEndTime = parsedResults.profile.endTime;
-
-					tracer.trace.completeEvent({
-						name: "TaskQueueManager::ProcessTaskFromWorkQueue",
-						id: ++tracer.counter,
-						cat: ["toplevel"],
-						ts: cpuStartTime,
-						args: {
-							src_file: "../../ipc/ipc_moji_bootstrap.cc",
-							src_func: "Accept"
-						}
-					});
-
-					tracer.trace.completeEvent({
-						name: "EvaluateScript",
-						id: ++tracer.counter,
-						cat: ["devtools.timeline"],
-						ts: cpuStartTime,
-						dur: cpuEndTime - cpuStartTime,
-						args: {
-							data: {
-								url: "webpack",
-								lineNumber: 1,
-								columnNumber: 1,
-								frame: "0xFFF"
-							}
-						}
-					});
-
-					tracer.trace.instantEvent({
-						name: "CpuProfile",
-						id: ++tracer.counter,
-						cat: ["disabled-by-default-devtools.timeline"],
-						ts: cpuEndTime,
-						args: {
-							data: {
-								cpuProfile: parsedResults.profile
-							}
-						}
-					});
-
-					tracer.profiler.destroy();
-					tracer.end(callback);
-				});
-			}
-		);
-	}
-}
-
-const interceptAllHooksFor = (instance, tracer, logLabel) => {
-	if (Reflect.has(instance, "hooks")) {
-		Object.keys(instance.hooks).forEach(hookName => {
-			const hook = instance.hooks[hookName];
-			if (hook && !hook._fakeHook) {
-				hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
-			}
-		});
-	}
-};
-
-const interceptAllParserHooks = (moduleFactory, tracer) => {
-	const moduleTypes = [
-		"javascript/auto",
-		"javascript/dynamic",
-		"javascript/esm",
-		"json",
-		"webassembly/async",
-		"webassembly/sync"
-	];
-
-	moduleTypes.forEach(moduleType => {
-		moduleFactory.hooks.parser
-			.for(moduleType)
-			.tap("ProfilingPlugin", (parser, parserOpts) => {
-				interceptAllHooksFor(parser, tracer, "Parser");
-			});
-	});
-};
-
-const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
-	interceptAllHooksFor(
-		{
-			hooks:
-				(__webpack_require__(89464).getCompilationHooks)(
-					compilation
-				)
-		},
-		tracer,
-		"JavascriptModulesPlugin"
-	);
-};
-
-const makeInterceptorFor = (instance, tracer) => hookName => ({
-	register: ({ name, type, context, fn }) => {
-		const newFn =
-			// Don't tap our own hooks to ensure stream can close cleanly
-			name === pluginName
-				? fn
-				: makeNewProfiledTapFn(hookName, tracer, {
-						name,
-						type,
-						fn
-				  });
-		return {
-			name,
-			type,
-			context,
-			fn: newFn
-		};
-	}
-});
-
-// TODO improve typing
-/** @typedef {(...args: TODO[]) => void | Promise<TODO>} PluginFunction */
 
-/**
- * @param {string} hookName Name of the hook to profile.
- * @param {Trace} tracer The trace object.
- * @param {object} options Options for the profiled fn.
- * @param {string} options.name Plugin name
- * @param {string} options.type Plugin type (sync | async | promise)
- * @param {PluginFunction} options.fn Plugin function
- * @returns {PluginFunction} Chainable hooked function.
- */
-const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
-	const defaultCategory = ["blink.user_timing"];
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call
+						.for("__webpack_is_included__")
+						.tap("WebpackIsIncludedPlugin", expr => {
+							if (
+								expr.type !== "CallExpression" ||
+								expr.arguments.length !== 1 ||
+								expr.arguments[0].type === "SpreadElement"
+							)
+								return;
 
-	switch (type) {
-		case "promise":
-			return (...args) => {
-				const id = ++tracer.counter;
-				tracer.trace.begin({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				const promise = /** @type {Promise<*>} */ (fn(...args));
-				return promise.then(r => {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					return r;
-				});
-			};
-		case "async":
-			return (...args) => {
-				const id = ++tracer.counter;
-				tracer.trace.begin({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				const callback = args.pop();
-				fn(...args, (...r) => {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					callback(...r);
-				});
-			};
-		case "sync":
-			return (...args) => {
-				const id = ++tracer.counter;
-				// Do not instrument ourself due to the CPU
-				// profile needing to be the last event in the trace.
-				if (name === pluginName) {
-					return fn(...args);
-				}
+							const request = parser.evaluateExpression(expr.arguments[0]);
 
-				tracer.trace.begin({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				let r;
-				try {
-					r = fn(...args);
-				} catch (error) {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					throw error;
-				}
-				tracer.trace.end({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				return r;
-			};
-		default:
-			break;
+							if (!request.isString()) return;
+
+							const dep = new WebpackIsIncludedDependency(
+								request.string,
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+					parser.hooks.typeof
+						.for("__webpack_is_included__")
+						.tap(
+							"WebpackIsIncludedPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("WebpackIsIncludedPlugin", handler);
+			}
+		);
 	}
-};
+}
 
-module.exports = ProfilingPlugin;
-module.exports.Profiler = Profiler;
+module.exports = WebpackIsIncludedPlugin;
 
 
 /***/ }),
 
-/***/ 96816:
+/***/ 88422:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -70761,587 +64575,698 @@ module.exports.Profiler = Profiler;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const OptionsApply = __webpack_require__(81426);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+const AssetModulesPlugin = __webpack_require__(16109);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const JsonModulesPlugin = __webpack_require__(86770);
 
-/** @type {Record<string, { definition: string, content: string, requests: string[] }>} */
-const DEFINITIONS = {
-	f: {
-		definition: "var __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_RESULT__ = (#).call(exports, __webpack_require__, exports, module),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [
-			RuntimeGlobals.require,
-			RuntimeGlobals.exports,
-			RuntimeGlobals.module
-		]
-	},
-	o: {
-		definition: "",
-		content: "!(module.exports = #)",
-		requests: [RuntimeGlobals.module]
-	},
-	of: {
-		definition:
-			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#),
-		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-		(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
-		__WEBPACK_AMD_DEFINE_FACTORY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [
-			RuntimeGlobals.require,
-			RuntimeGlobals.exports,
-			RuntimeGlobals.module
-		]
-	},
-	af: {
-		definition:
-			"var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_RESULT__ = (#).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
-	},
-	ao: {
-		definition: "",
-		content: "!(#, module.exports = #)",
-		requests: [RuntimeGlobals.module]
-	},
-	aof: {
-		definition:
-			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#),
-		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
-	},
-	lf: {
-		definition: "var XXX, XXXmodule;",
-		content:
-			"!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = (#).call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))",
-		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
-	},
-	lo: {
-		definition: "var XXX;",
-		content: "!(XXX = #)",
-		requests: []
-	},
-	lof: {
-		definition: "var XXX, XXXfactory, XXXmodule;",
-		content:
-			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))",
-		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
-	},
-	laf: {
-		definition: "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX, XXXexports;",
-		content:
-			"!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#).apply(XXXexports = {}, __WEBPACK_AMD_DEFINE_ARRAY__), XXX === undefined && (XXX = XXXexports))",
-		requests: []
-	},
-	lao: {
-		definition: "var XXX;",
-		content: "!(#, XXX = #)",
-		requests: []
-	},
-	laof: {
-		definition: "var XXXarray, XXXfactory, XXXexports, XXX;",
-		content: `!(XXXarray = #, XXXfactory = (#),
-		(typeof XXXfactory === 'function' ?
-			((XXX = XXXfactory.apply(XXXexports = {}, XXXarray)), XXX === undefined && (XXX = XXXexports)) :
-			(XXX = XXXfactory)
-		))`,
-		requests: []
-	}
-};
+const ChunkPrefetchPreloadPlugin = __webpack_require__(33895);
 
-class AMDDefineDependency extends NullDependency {
-	constructor(range, arrayRange, functionRange, objectRange, namedModule) {
-		super();
-		this.range = range;
-		this.arrayRange = arrayRange;
-		this.functionRange = functionRange;
-		this.objectRange = objectRange;
-		this.namedModule = namedModule;
-		this.localModule = null;
-	}
+const EntryOptionPlugin = __webpack_require__(9909);
+const RecordIdsPlugin = __webpack_require__(11094);
 
-	get type() {
-		return "amd define";
-	}
+const RuntimePlugin = __webpack_require__(2307);
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.arrayRange);
-		write(this.functionRange);
-		write(this.objectRange);
-		write(this.namedModule);
-		write(this.localModule);
-		super.serialize(context);
-	}
+const APIPlugin = __webpack_require__(74315);
+const CompatibilityPlugin = __webpack_require__(94258);
+const ConstPlugin = __webpack_require__(11146);
+const ExportsInfoApiPlugin = __webpack_require__(7145);
+const WebpackIsIncludedPlugin = __webpack_require__(97017);
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.arrayRange = read();
-		this.functionRange = read();
-		this.objectRange = read();
-		this.namedModule = read();
-		this.localModule = read();
-		super.deserialize(context);
-	}
-}
+const TemplatedPathPlugin = __webpack_require__(80734);
+const UseStrictPlugin = __webpack_require__(36803);
+const WarnCaseSensitiveModulesPlugin = __webpack_require__(56504);
 
-makeSerializable(
-	AMDDefineDependency,
-	"webpack/lib/dependencies/AMDDefineDependency"
-);
+const DataUriPlugin = __webpack_require__(64820);
+const FileUriPlugin = __webpack_require__(57637);
+
+const ResolverCachePlugin = __webpack_require__(97347);
+
+const CommonJsPlugin = __webpack_require__(32406);
+const HarmonyModulesPlugin = __webpack_require__(39029);
+const ImportMetaPlugin = __webpack_require__(17228);
+const ImportPlugin = __webpack_require__(41293);
+const LoaderPlugin = __webpack_require__(24721);
+const RequireContextPlugin = __webpack_require__(2928);
+const RequireEnsurePlugin = __webpack_require__(8434);
+const RequireIncludePlugin = __webpack_require__(37378);
+const SystemPlugin = __webpack_require__(97981);
+const URLPlugin = __webpack_require__(14412);
+const WorkerPlugin = __webpack_require__(82509);
+
+const InferAsyncModulesPlugin = __webpack_require__(59498);
+
+const JavascriptMetaInfoPlugin = __webpack_require__(52329);
+const DefaultStatsFactoryPlugin = __webpack_require__(71760);
+const DefaultStatsPresetPlugin = __webpack_require__(55442);
+const DefaultStatsPrinterPlugin = __webpack_require__(58692);
+
+const { cleverMerge } = __webpack_require__(60839);
+
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Compiler")} Compiler */
+
+class WebpackOptionsApply extends OptionsApply {
+	constructor() {
+		super();
+	}
 
-AMDDefineDependency.Template = class AMDDefineDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {WebpackOptions} options options object
+	 * @param {Compiler} compiler compiler object
+	 * @returns {WebpackOptions} options object
 	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {AMDDefineDependency} */ (dependency);
-		const branch = this.branch(dep);
-		const { definition, content, requests } = DEFINITIONS[branch];
-		for (const req of requests) {
-			runtimeRequirements.add(req);
+	process(options, compiler) {
+		compiler.outputPath = options.output.path;
+		compiler.recordsInputPath = options.recordsInputPath || null;
+		compiler.recordsOutputPath = options.recordsOutputPath || null;
+		compiler.name = options.name;
+
+		if (options.externals) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin(options.externalsType, options.externals).apply(
+				compiler
+			);
 		}
-		this.replace(dep, source, definition, content);
-	}
 
-	localModuleVar(dependency) {
-		return (
-			dependency.localModule &&
-			dependency.localModule.used &&
-			dependency.localModule.variableName()
-		);
-	}
+		if (options.externalsPresets.node) {
+			const NodeTargetPlugin = __webpack_require__(17916);
+			new NodeTargetPlugin().apply(compiler);
+		}
+		if (options.externalsPresets.electronMain) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin("main").apply(compiler);
+		}
+		if (options.externalsPresets.electronPreload) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin("preload").apply(compiler);
+		}
+		if (options.externalsPresets.electronRenderer) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin("renderer").apply(compiler);
+		}
+		if (
+			options.externalsPresets.electron &&
+			!options.externalsPresets.electronMain &&
+			!options.externalsPresets.electronPreload &&
+			!options.externalsPresets.electronRenderer
+		) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin().apply(compiler);
+		}
+		if (options.externalsPresets.nwjs) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
+		}
+		if (options.externalsPresets.webAsync) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin(
+				"import",
+				options.experiments.css
+					? ({ request, dependencyType }, callback) => {
+							if (dependencyType === "url") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `asset ${request}`);
+							} else if (dependencyType === "css-import") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `css-import ${request}`);
+							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+								if (/^\.css(\?|$)/.test(request))
+									return callback(null, `css-import ${request}`);
+								return callback(null, `import ${request}`);
+							}
+							callback();
+					  }
+					: /^(\/\/|https?:\/\/|std:)/
+			).apply(compiler);
+		} else if (options.externalsPresets.web) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin(
+				"module",
+				options.experiments.css
+					? ({ request, dependencyType }, callback) => {
+							if (dependencyType === "url") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `asset ${request}`);
+							} else if (dependencyType === "css-import") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `css-import ${request}`);
+							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+								if (/^\.css(\?|$)/.test(request))
+									return callback(null, `css-import ${request}`);
+								return callback(null, `module ${request}`);
+							}
+							callback();
+					  }
+					: /^(\/\/|https?:\/\/|std:)/
+			).apply(compiler);
+		}
 
-	branch(dependency) {
-		const localModuleVar = this.localModuleVar(dependency) ? "l" : "";
-		const arrayRange = dependency.arrayRange ? "a" : "";
-		const objectRange = dependency.objectRange ? "o" : "";
-		const functionRange = dependency.functionRange ? "f" : "";
-		return localModuleVar + arrayRange + objectRange + functionRange;
-	}
+		new ChunkPrefetchPreloadPlugin().apply(compiler);
 
-	replace(dependency, source, definition, text) {
-		const localModuleVar = this.localModuleVar(dependency);
-		if (localModuleVar) {
-			text = text.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$"));
-			definition = definition.replace(
-				/XXX/g,
-				localModuleVar.replace(/\$/g, "$$$$")
+		if (typeof options.output.chunkFormat === "string") {
+			switch (options.output.chunkFormat) {
+				case "array-push": {
+					const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
+					new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+					break;
+				}
+				case "commonjs": {
+					const CommonJsChunkFormatPlugin = __webpack_require__(84508);
+					new CommonJsChunkFormatPlugin().apply(compiler);
+					break;
+				}
+				case "module": {
+					const ModuleChunkFormatPlugin = __webpack_require__(68927);
+					new ModuleChunkFormatPlugin().apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(
+						"Unsupported chunk format '" + options.output.chunkFormat + "'."
+					);
+			}
+		}
+
+		if (options.output.enabledChunkLoadingTypes.length > 0) {
+			for (const type of options.output.enabledChunkLoadingTypes) {
+				const EnableChunkLoadingPlugin = __webpack_require__(61291);
+				new EnableChunkLoadingPlugin(type).apply(compiler);
+			}
+		}
+
+		if (options.output.enabledWasmLoadingTypes.length > 0) {
+			for (const type of options.output.enabledWasmLoadingTypes) {
+				const EnableWasmLoadingPlugin = __webpack_require__(78613);
+				new EnableWasmLoadingPlugin(type).apply(compiler);
+			}
+		}
+
+		if (options.output.enabledLibraryTypes.length > 0) {
+			for (const type of options.output.enabledLibraryTypes) {
+				const EnableLibraryPlugin = __webpack_require__(91452);
+				new EnableLibraryPlugin(type).apply(compiler);
+			}
+		}
+
+		if (options.output.pathinfo) {
+			const ModuleInfoHeaderPlugin = __webpack_require__(3454);
+			new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply(
+				compiler
 			);
 		}
 
-		if (dependency.namedModule) {
-			text = text.replace(/YYY/g, JSON.stringify(dependency.namedModule));
+		if (options.output.clean) {
+			const CleanPlugin = __webpack_require__(31085);
+			new CleanPlugin(
+				options.output.clean === true ? {} : options.output.clean
+			).apply(compiler);
+		}
+
+		if (options.devtool) {
+			if (options.devtool.includes("source-map")) {
+				const hidden = options.devtool.includes("hidden");
+				const inline = options.devtool.includes("inline");
+				const evalWrapped = options.devtool.includes("eval");
+				const cheap = options.devtool.includes("cheap");
+				const moduleMaps = options.devtool.includes("module");
+				const noSources = options.devtool.includes("nosources");
+				const Plugin = evalWrapped
+					? __webpack_require__(14790)
+					: __webpack_require__(63872);
+				new Plugin({
+					filename: inline ? null : options.output.sourceMapFilename,
+					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
+					fallbackModuleFilenameTemplate:
+						options.output.devtoolFallbackModuleFilenameTemplate,
+					append: hidden ? false : undefined,
+					module: moduleMaps ? true : cheap ? false : true,
+					columns: cheap ? false : true,
+					noSources: noSources,
+					namespace: options.output.devtoolNamespace
+				}).apply(compiler);
+			} else if (options.devtool.includes("eval")) {
+				const EvalDevToolModulePlugin = __webpack_require__(65218);
+				new EvalDevToolModulePlugin({
+					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
+					namespace: options.output.devtoolNamespace
+				}).apply(compiler);
+			}
 		}
 
-		const texts = text.split("#");
-
-		if (definition) source.insert(0, definition);
+		new JavascriptModulesPlugin().apply(compiler);
+		new JsonModulesPlugin().apply(compiler);
+		new AssetModulesPlugin().apply(compiler);
 
-		let current = dependency.range[0];
-		if (dependency.arrayRange) {
-			source.replace(current, dependency.arrayRange[0] - 1, texts.shift());
-			current = dependency.arrayRange[1];
+		if (!options.experiments.outputModule) {
+			if (options.output.module) {
+				throw new Error(
+					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
+			if (options.output.enabledLibraryTypes.includes("module")) {
+				throw new Error(
+					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
+			if (options.externalsType === "module") {
+				throw new Error(
+					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
 		}
 
-		if (dependency.objectRange) {
-			source.replace(current, dependency.objectRange[0] - 1, texts.shift());
-			current = dependency.objectRange[1];
-		} else if (dependency.functionRange) {
-			source.replace(current, dependency.functionRange[0] - 1, texts.shift());
-			current = dependency.functionRange[1];
+		if (options.experiments.syncWebAssembly) {
+			const WebAssemblyModulesPlugin = __webpack_require__(53639);
+			new WebAssemblyModulesPlugin({
+				mangleImports: options.optimization.mangleWasmImports
+			}).apply(compiler);
 		}
-		source.replace(current, dependency.range[1] - 1, texts.shift());
-		if (texts.length > 0) throw new Error("Implementation error");
-	}
-};
-
-module.exports = AMDDefineDependency;
 
+		if (options.experiments.asyncWebAssembly) {
+			const AsyncWebAssemblyModulesPlugin = __webpack_require__(7538);
+			new AsyncWebAssemblyModulesPlugin({
+				mangleImports: options.optimization.mangleWasmImports
+			}).apply(compiler);
+		}
 
-/***/ }),
+		if (options.experiments.css) {
+			const CssModulesPlugin = __webpack_require__(47283);
+			new CssModulesPlugin(options.experiments.css).apply(compiler);
+		}
 
-/***/ 48519:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		if (options.experiments.lazyCompilation) {
+			const LazyCompilationPlugin = __webpack_require__(79040);
+			const lazyOptions =
+				typeof options.experiments.lazyCompilation === "object"
+					? options.experiments.lazyCompilation
+					: null;
+			new LazyCompilationPlugin({
+				backend:
+					typeof lazyOptions.backend === "function"
+						? lazyOptions.backend
+						: __webpack_require__(17781)({
+								...lazyOptions.backend,
+								client:
+									(lazyOptions.backend && lazyOptions.backend.client) ||
+									options.externalsPresets.node ? __webpack_require__.ab + "lazy-compilation-node.js" : __webpack_require__.ab + "lazy-compilation-web.js"
+						  }),
+				entries: !lazyOptions || lazyOptions.entries !== false,
+				imports: !lazyOptions || lazyOptions.imports !== false,
+				test: (lazyOptions && lazyOptions.test) || undefined
+			}).apply(compiler);
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		if (options.experiments.buildHttp) {
+			const HttpUriPlugin = __webpack_require__(42110);
+			const httpOptions = options.experiments.buildHttp;
+			new HttpUriPlugin(httpOptions).apply(compiler);
+		}
 
+		new EntryOptionPlugin().apply(compiler);
+		compiler.hooks.entryOption.call(options.context, options.entry);
 
+		new RuntimePlugin().apply(compiler);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const AMDDefineDependency = __webpack_require__(96816);
-const AMDRequireArrayDependency = __webpack_require__(33516);
-const AMDRequireContextDependency = __webpack_require__(96123);
-const AMDRequireItemDependency = __webpack_require__(71806);
-const ConstDependency = __webpack_require__(76911);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const DynamicExports = __webpack_require__(32006);
-const LocalModuleDependency = __webpack_require__(52805);
-const { addLocalModule, getLocalModule } = __webpack_require__(75827);
+		new InferAsyncModulesPlugin().apply(compiler);
 
-const isBoundFunctionExpression = expr => {
-	if (expr.type !== "CallExpression") return false;
-	if (expr.callee.type !== "MemberExpression") return false;
-	if (expr.callee.computed) return false;
-	if (expr.callee.object.type !== "FunctionExpression") return false;
-	if (expr.callee.property.type !== "Identifier") return false;
-	if (expr.callee.property.name !== "bind") return false;
-	return true;
-};
+		new DataUriPlugin().apply(compiler);
+		new FileUriPlugin().apply(compiler);
 
-const isUnboundFunctionExpression = expr => {
-	if (expr.type === "FunctionExpression") return true;
-	if (expr.type === "ArrowFunctionExpression") return true;
-	return false;
-};
+		new CompatibilityPlugin().apply(compiler);
+		new HarmonyModulesPlugin({
+			topLevelAwait: options.experiments.topLevelAwait
+		}).apply(compiler);
+		if (options.amd !== false) {
+			const AMDPlugin = __webpack_require__(50067);
+			const RequireJsStuffPlugin = __webpack_require__(88846);
+			new AMDPlugin(options.amd || {}).apply(compiler);
+			new RequireJsStuffPlugin().apply(compiler);
+		}
+		new CommonJsPlugin().apply(compiler);
+		new LoaderPlugin({}).apply(compiler);
+		if (options.node !== false) {
+			const NodeStuffPlugin = __webpack_require__(95287);
+			new NodeStuffPlugin(options.node).apply(compiler);
+		}
+		new APIPlugin().apply(compiler);
+		new ExportsInfoApiPlugin().apply(compiler);
+		new WebpackIsIncludedPlugin().apply(compiler);
+		new ConstPlugin().apply(compiler);
+		new UseStrictPlugin().apply(compiler);
+		new RequireIncludePlugin().apply(compiler);
+		new RequireEnsurePlugin().apply(compiler);
+		new RequireContextPlugin().apply(compiler);
+		new ImportPlugin().apply(compiler);
+		new SystemPlugin().apply(compiler);
+		new ImportMetaPlugin().apply(compiler);
+		new URLPlugin().apply(compiler);
+		new WorkerPlugin(
+			options.output.workerChunkLoading,
+			options.output.workerWasmLoading,
+			options.output.module
+		).apply(compiler);
 
-const isCallable = expr => {
-	if (isUnboundFunctionExpression(expr)) return true;
-	if (isBoundFunctionExpression(expr)) return true;
-	return false;
-};
+		new DefaultStatsFactoryPlugin().apply(compiler);
+		new DefaultStatsPresetPlugin().apply(compiler);
+		new DefaultStatsPrinterPlugin().apply(compiler);
 
-class AMDDefineDependencyParserPlugin {
-	constructor(options) {
-		this.options = options;
-	}
+		new JavascriptMetaInfoPlugin().apply(compiler);
 
-	apply(parser) {
-		parser.hooks.call
-			.for("define")
-			.tap(
-				"AMDDefineDependencyParserPlugin",
-				this.processCallDefine.bind(this, parser)
-			);
-	}
+		if (typeof options.mode !== "string") {
+			const WarnNoModeSetPlugin = __webpack_require__(25295);
+			new WarnNoModeSetPlugin().apply(compiler);
+		}
 
-	processArray(parser, expr, param, identifiers, namedModule) {
-		if (param.isArray()) {
-			param.items.forEach((param, idx) => {
-				if (
-					param.isString() &&
-					["require", "module", "exports"].includes(param.string)
-				)
-					identifiers[idx] = param.string;
-				const result = this.processItem(parser, expr, param, namedModule);
-				if (result === undefined) {
-					this.processContext(parser, expr, param);
-				}
-			});
-			return true;
-		} else if (param.isConstArray()) {
-			const deps = [];
-			param.array.forEach((request, idx) => {
-				let dep;
-				let localModule;
-				if (request === "require") {
-					identifiers[idx] = request;
-					dep = "__webpack_require__";
-				} else if (["exports", "module"].includes(request)) {
-					identifiers[idx] = request;
-					dep = request;
-				} else if ((localModule = getLocalModule(parser.state, request))) {
-					localModule.flagUsed();
-					dep = new LocalModuleDependency(localModule, undefined, false);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-				} else {
-					dep = this.newRequireItemDependency(request);
-					dep.loc = expr.loc;
-					dep.optional = !!parser.scope.inTry;
-					parser.state.current.addDependency(dep);
-				}
-				deps.push(dep);
-			});
-			const dep = this.newRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
+		const EnsureChunkConditionsPlugin = __webpack_require__(96260);
+		new EnsureChunkConditionsPlugin().apply(compiler);
+		if (options.optimization.removeAvailableModules) {
+			const RemoveParentModulesPlugin = __webpack_require__(7081);
+			new RemoveParentModulesPlugin().apply(compiler);
 		}
-	}
-	processItem(parser, expr, param, namedModule) {
-		if (param.isConditional()) {
-			param.options.forEach(param => {
-				const result = this.processItem(parser, expr, param);
-				if (result === undefined) {
-					this.processContext(parser, expr, param);
-				}
-			});
-			return true;
-		} else if (param.isString()) {
-			let dep, localModule;
-			if (param.string === "require") {
-				dep = new ConstDependency("__webpack_require__", param.range, [
-					RuntimeGlobals.require
-				]);
-			} else if (param.string === "exports") {
-				dep = new ConstDependency("exports", param.range, [
-					RuntimeGlobals.exports
-				]);
-			} else if (param.string === "module") {
-				dep = new ConstDependency("module", param.range, [
-					RuntimeGlobals.module
-				]);
-			} else if (
-				(localModule = getLocalModule(parser.state, param.string, namedModule))
-			) {
-				localModule.flagUsed();
-				dep = new LocalModuleDependency(localModule, param.range, false);
-			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
+		if (options.optimization.removeEmptyChunks) {
+			const RemoveEmptyChunksPlugin = __webpack_require__(84760);
+			new RemoveEmptyChunksPlugin().apply(compiler);
 		}
-	}
-	processContext(parser, expr, param) {
-		const dep = ContextDependencyHelpers.create(
-			AMDRequireContextDependency,
-			param.range,
-			param,
-			expr,
-			this.options,
-			{
-				category: "amd"
-			},
-			parser
-		);
-		if (!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!parser.scope.inTry;
-		parser.state.current.addDependency(dep);
-		return true;
-	}
-
-	processCallDefine(parser, expr) {
-		let array, fn, obj, namedModule;
-		switch (expr.arguments.length) {
-			case 1:
-				if (isCallable(expr.arguments[0])) {
-					// define(f() {…})
-					fn = expr.arguments[0];
-				} else if (expr.arguments[0].type === "ObjectExpression") {
-					// define({…})
-					obj = expr.arguments[0];
-				} else {
-					// define(expr)
-					// unclear if function or object
-					obj = fn = expr.arguments[0];
+		if (options.optimization.mergeDuplicateChunks) {
+			const MergeDuplicateChunksPlugin = __webpack_require__(85067);
+			new MergeDuplicateChunksPlugin().apply(compiler);
+		}
+		if (options.optimization.flagIncludedChunks) {
+			const FlagIncludedChunksPlugin = __webpack_require__(50089);
+			new FlagIncludedChunksPlugin().apply(compiler);
+		}
+		if (options.optimization.sideEffects) {
+			const SideEffectsFlagPlugin = __webpack_require__(84800);
+			new SideEffectsFlagPlugin(
+				options.optimization.sideEffects === true
+			).apply(compiler);
+		}
+		if (options.optimization.providedExports) {
+			const FlagDependencyExportsPlugin = __webpack_require__(84506);
+			new FlagDependencyExportsPlugin().apply(compiler);
+		}
+		if (options.optimization.usedExports) {
+			const FlagDependencyUsagePlugin = __webpack_require__(58812);
+			new FlagDependencyUsagePlugin(
+				options.optimization.usedExports === "global"
+			).apply(compiler);
+		}
+		if (options.optimization.innerGraph) {
+			const InnerGraphPlugin = __webpack_require__(28758);
+			new InnerGraphPlugin().apply(compiler);
+		}
+		if (options.optimization.mangleExports) {
+			const MangleExportsPlugin = __webpack_require__(27868);
+			new MangleExportsPlugin(
+				options.optimization.mangleExports !== "size"
+			).apply(compiler);
+		}
+		if (options.optimization.concatenateModules) {
+			const ModuleConcatenationPlugin = __webpack_require__(74844);
+			new ModuleConcatenationPlugin().apply(compiler);
+		}
+		if (options.optimization.splitChunks) {
+			const SplitChunksPlugin = __webpack_require__(21478);
+			new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
+		}
+		if (options.optimization.runtimeChunk) {
+			const RuntimeChunkPlugin = __webpack_require__(2837);
+			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
+		}
+		if (!options.optimization.emitOnErrors) {
+			const NoEmitOnErrorsPlugin = __webpack_require__(50169);
+			new NoEmitOnErrorsPlugin().apply(compiler);
+		}
+		if (options.optimization.realContentHash) {
+			const RealContentHashPlugin = __webpack_require__(46043);
+			new RealContentHashPlugin({
+				hashFunction: options.output.hashFunction,
+				hashDigest: options.output.hashDigest
+			}).apply(compiler);
+		}
+		if (options.optimization.checkWasmTypes) {
+			const WasmFinalizeExportsPlugin = __webpack_require__(19810);
+			new WasmFinalizeExportsPlugin().apply(compiler);
+		}
+		const moduleIds = options.optimization.moduleIds;
+		if (moduleIds) {
+			switch (moduleIds) {
+				case "natural": {
+					const NaturalModuleIdsPlugin = __webpack_require__(83366);
+					new NaturalModuleIdsPlugin().apply(compiler);
+					break;
 				}
-				break;
-			case 2:
-				if (expr.arguments[0].type === "Literal") {
-					namedModule = expr.arguments[0].value;
-					// define("…", …)
-					if (isCallable(expr.arguments[1])) {
-						// define("…", f() {…})
-						fn = expr.arguments[1];
-					} else if (expr.arguments[1].type === "ObjectExpression") {
-						// define("…", {…})
-						obj = expr.arguments[1];
-					} else {
-						// define("…", expr)
-						// unclear if function or object
-						obj = fn = expr.arguments[1];
-					}
-				} else {
-					array = expr.arguments[0];
-					if (isCallable(expr.arguments[1])) {
-						// define([…], f() {})
-						fn = expr.arguments[1];
-					} else if (expr.arguments[1].type === "ObjectExpression") {
-						// define([…], {…})
-						obj = expr.arguments[1];
-					} else {
-						// define([…], expr)
-						// unclear if function or object
-						obj = fn = expr.arguments[1];
-					}
+				case "named": {
+					const NamedModuleIdsPlugin = __webpack_require__(24339);
+					new NamedModuleIdsPlugin().apply(compiler);
+					break;
 				}
-				break;
-			case 3:
-				// define("…", […], f() {…})
-				namedModule = expr.arguments[0].value;
-				array = expr.arguments[1];
-				if (isCallable(expr.arguments[2])) {
-					// define("…", […], f() {})
-					fn = expr.arguments[2];
-				} else if (expr.arguments[2].type === "ObjectExpression") {
-					// define("…", […], {…})
-					obj = expr.arguments[2];
-				} else {
-					// define("…", […], expr)
-					// unclear if function or object
-					obj = fn = expr.arguments[2];
+				case "hashed": {
+					const WarnDeprecatedOptionPlugin = __webpack_require__(76537);
+					const HashedModuleIdsPlugin = __webpack_require__(21825);
+					new WarnDeprecatedOptionPlugin(
+						"optimization.moduleIds",
+						"hashed",
+						"deterministic"
+					).apply(compiler);
+					new HashedModuleIdsPlugin({
+						hashFunction: options.output.hashFunction
+					}).apply(compiler);
+					break;
 				}
-				break;
-			default:
-				return;
-		}
-		DynamicExports.bailout(parser.state);
-		let fnParams = null;
-		let fnParamsOffset = 0;
-		if (fn) {
-			if (isUnboundFunctionExpression(fn)) {
-				fnParams = fn.params;
-			} else if (isBoundFunctionExpression(fn)) {
-				fnParams = fn.callee.object.params;
-				fnParamsOffset = fn.arguments.length - 1;
-				if (fnParamsOffset < 0) {
-					fnParamsOffset = 0;
+				case "deterministic": {
+					const DeterministicModuleIdsPlugin = __webpack_require__(76692);
+					new DeterministicModuleIdsPlugin().apply(compiler);
+					break;
+				}
+				case "size": {
+					const OccurrenceModuleIdsPlugin = __webpack_require__(35371);
+					new OccurrenceModuleIdsPlugin({
+						prioritiseInitial: true
+					}).apply(compiler);
+					break;
 				}
+				default:
+					throw new Error(
+						`webpack bug: moduleIds: ${moduleIds} is not implemented`
+					);
 			}
 		}
-		let fnRenames = new Map();
-		if (array) {
-			const identifiers = {};
-			const param = parser.evaluateExpression(array);
-			const result = this.processArray(
-				parser,
-				expr,
-				param,
-				identifiers,
-				namedModule
-			);
-			if (!result) return;
-			if (fnParams) {
-				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
-					if (identifiers[idx]) {
-						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
-						return false;
-					}
-					return true;
-				});
-			}
-		} else {
-			const identifiers = ["require", "exports", "module"];
-			if (fnParams) {
-				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
-					if (identifiers[idx]) {
-						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
-						return false;
-					}
-					return true;
-				});
+		const chunkIds = options.optimization.chunkIds;
+		if (chunkIds) {
+			switch (chunkIds) {
+				case "natural": {
+					const NaturalChunkIdsPlugin = __webpack_require__(86221);
+					new NaturalChunkIdsPlugin().apply(compiler);
+					break;
+				}
+				case "named": {
+					const NamedChunkIdsPlugin = __webpack_require__(6454);
+					new NamedChunkIdsPlugin().apply(compiler);
+					break;
+				}
+				case "deterministic": {
+					const DeterministicChunkIdsPlugin = __webpack_require__(8747);
+					new DeterministicChunkIdsPlugin().apply(compiler);
+					break;
+				}
+				case "size": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
+					new OccurrenceChunkIdsPlugin({
+						prioritiseInitial: true
+					}).apply(compiler);
+					break;
+				}
+				case "total-size": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
+					new OccurrenceChunkIdsPlugin({
+						prioritiseInitial: false
+					}).apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(
+						`webpack bug: chunkIds: ${chunkIds} is not implemented`
+					);
 			}
 		}
-		let inTry;
-		if (fn && isUnboundFunctionExpression(fn)) {
-			inTry = parser.scope.inTry;
-			parser.inScope(fnParams, () => {
-				for (const [name, varInfo] of fnRenames) {
-					parser.setVariable(name, varInfo);
+		if (options.optimization.nodeEnv) {
+			const DefinePlugin = __webpack_require__(79065);
+			new DefinePlugin({
+				"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
+			}).apply(compiler);
+		}
+		if (options.optimization.minimize) {
+			for (const minimizer of options.optimization.minimizer) {
+				if (typeof minimizer === "function") {
+					minimizer.call(compiler, compiler);
+				} else if (minimizer !== "...") {
+					minimizer.apply(compiler);
 				}
-				parser.scope.inTry = inTry;
-				if (fn.body.type === "BlockStatement") {
-					parser.detectMode(fn.body.body);
-					const prev = parser.prevStatement;
-					parser.preWalkStatement(fn.body);
-					parser.prevStatement = prev;
-					parser.walkStatement(fn.body);
-				} else {
-					parser.walkExpression(fn.body);
+			}
+		}
+
+		if (options.performance) {
+			const SizeLimitsPlugin = __webpack_require__(32557);
+			new SizeLimitsPlugin(options.performance).apply(compiler);
+		}
+
+		new TemplatedPathPlugin().apply(compiler);
+
+		new RecordIdsPlugin({
+			portableIds: options.optimization.portableRecords
+		}).apply(compiler);
+
+		new WarnCaseSensitiveModulesPlugin().apply(compiler);
+
+		const AddManagedPathsPlugin = __webpack_require__(47942);
+		new AddManagedPathsPlugin(
+			options.snapshot.managedPaths,
+			options.snapshot.immutablePaths
+		).apply(compiler);
+
+		if (options.cache && typeof options.cache === "object") {
+			const cacheOptions = options.cache;
+			switch (cacheOptions.type) {
+				case "memory": {
+					if (isFinite(cacheOptions.maxGenerations)) {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryWithGcCachePlugin = __webpack_require__(99334);
+						new MemoryWithGcCachePlugin({
+							maxGenerations: cacheOptions.maxGenerations
+						}).apply(compiler);
+					} else {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryCachePlugin = __webpack_require__(52539);
+						new MemoryCachePlugin().apply(compiler);
+					}
+					if (cacheOptions.cacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new Map();
+					}
+					break;
 				}
-			});
-		} else if (fn && isBoundFunctionExpression(fn)) {
-			inTry = parser.scope.inTry;
-			parser.inScope(
-				fn.callee.object.params.filter(
-					i => !["require", "module", "exports"].includes(i.name)
-				),
-				() => {
-					for (const [name, varInfo] of fnRenames) {
-						parser.setVariable(name, varInfo);
+				case "filesystem": {
+					const AddBuildDependenciesPlugin = __webpack_require__(28034);
+					for (const key in cacheOptions.buildDependencies) {
+						const list = cacheOptions.buildDependencies[key];
+						new AddBuildDependenciesPlugin(list).apply(compiler);
 					}
-					parser.scope.inTry = inTry;
-					if (fn.callee.object.body.type === "BlockStatement") {
-						parser.detectMode(fn.callee.object.body.body);
-						const prev = parser.prevStatement;
-						parser.preWalkStatement(fn.callee.object.body);
-						parser.prevStatement = prev;
-						parser.walkStatement(fn.callee.object.body);
-					} else {
-						parser.walkExpression(fn.callee.object.body);
+					if (!isFinite(cacheOptions.maxMemoryGenerations)) {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryCachePlugin = __webpack_require__(52539);
+						new MemoryCachePlugin().apply(compiler);
+					} else if (cacheOptions.maxMemoryGenerations !== 0) {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryWithGcCachePlugin = __webpack_require__(99334);
+						new MemoryWithGcCachePlugin({
+							maxGenerations: cacheOptions.maxMemoryGenerations
+						}).apply(compiler);
+					}
+					if (cacheOptions.memoryCacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new Map();
 					}
+					switch (cacheOptions.store) {
+						case "pack": {
+							const IdleFileCachePlugin = __webpack_require__(71985);
+							const PackFileCacheStrategy = __webpack_require__(86180);
+							new IdleFileCachePlugin(
+								new PackFileCacheStrategy({
+									compiler,
+									fs: compiler.intermediateFileSystem,
+									context: options.context,
+									cacheLocation: cacheOptions.cacheLocation,
+									version: cacheOptions.version,
+									logger: compiler.getInfrastructureLogger(
+										"webpack.cache.PackFileCacheStrategy"
+									),
+									snapshot: options.snapshot,
+									maxAge: cacheOptions.maxAge,
+									profile: cacheOptions.profile,
+									allowCollectingMemory: cacheOptions.allowCollectingMemory,
+									compression: cacheOptions.compression
+								}),
+								cacheOptions.idleTimeout,
+								cacheOptions.idleTimeoutForInitialStore,
+								cacheOptions.idleTimeoutAfterLargeChanges
+							).apply(compiler);
+							break;
+						}
+						default:
+							throw new Error("Unhandled value for cache.store");
+					}
+					break;
 				}
-			);
-			if (fn.arguments) {
-				parser.walkExpressions(fn.arguments);
+				default:
+					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+					throw new Error(`Unknown cache type ${cacheOptions.type}`);
 			}
-		} else if (fn || obj) {
-			parser.walkExpression(fn || obj);
 		}
+		new ResolverCachePlugin().apply(compiler);
 
-		const dep = this.newDefineDependency(
-			expr.range,
-			array ? array.range : null,
-			fn ? fn.range : null,
-			obj ? obj.range : null,
-			namedModule ? namedModule : null
-		);
-		dep.loc = expr.loc;
-		if (namedModule) {
-			dep.localModule = addLocalModule(parser.state, namedModule);
+		if (options.ignoreWarnings && options.ignoreWarnings.length > 0) {
+			const IgnoreWarningsPlugin = __webpack_require__(41606);
+			new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler);
 		}
-		parser.state.module.addPresentationalDependency(dep);
-		return true;
-	}
 
-	newDefineDependency(
-		range,
-		arrayRange,
-		functionRange,
-		objectRange,
-		namedModule
-	) {
-		return new AMDDefineDependency(
-			range,
-			arrayRange,
-			functionRange,
-			objectRange,
-			namedModule
-		);
-	}
-	newRequireArrayDependency(depsArray, range) {
-		return new AMDRequireArrayDependency(depsArray, range);
-	}
-	newRequireItemDependency(request, range) {
-		return new AMDRequireItemDependency(request, range);
+		compiler.hooks.afterPlugins.call(compiler);
+		if (!compiler.inputFileSystem) {
+			throw new Error("No input filesystem provided");
+		}
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("normal")
+			.tap("WebpackOptionsApply", resolveOptions => {
+				resolveOptions = cleverMerge(options.resolve, resolveOptions);
+				resolveOptions.fileSystem = compiler.inputFileSystem;
+				return resolveOptions;
+			});
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("context")
+			.tap("WebpackOptionsApply", resolveOptions => {
+				resolveOptions = cleverMerge(options.resolve, resolveOptions);
+				resolveOptions.fileSystem = compiler.inputFileSystem;
+				resolveOptions.resolveToContext = true;
+				return resolveOptions;
+			});
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("loader")
+			.tap("WebpackOptionsApply", resolveOptions => {
+				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
+				resolveOptions.fileSystem = compiler.inputFileSystem;
+				return resolveOptions;
+			});
+		compiler.hooks.afterResolvers.call(compiler);
+		return options;
 	}
 }
-module.exports = AMDDefineDependencyParserPlugin;
+
+module.exports = WebpackOptionsApply;
 
 
 /***/ }),
 
-/***/ 50067:
+/***/ 14452:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -71352,887 +65277,819 @@ module.exports = AMDDefineDependencyParserPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const {
-	approve,
-	evaluateToIdentifier,
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
-
-const AMDDefineDependency = __webpack_require__(96816);
-const AMDDefineDependencyParserPlugin = __webpack_require__(48519);
-const AMDRequireArrayDependency = __webpack_require__(33516);
-const AMDRequireContextDependency = __webpack_require__(96123);
-const AMDRequireDependenciesBlockParserPlugin = __webpack_require__(66866);
-const AMDRequireDependency = __webpack_require__(43911);
-const AMDRequireItemDependency = __webpack_require__(71806);
-const {
-	AMDDefineRuntimeModule,
-	AMDOptionsRuntimeModule
-} = __webpack_require__(45242);
-const ConstDependency = __webpack_require__(76911);
-const LocalModuleDependency = __webpack_require__(52805);
-const UnsupportedDependency = __webpack_require__(51669);
-
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../Compiler")} Compiler */
+const { applyWebpackOptionsDefaults } = __webpack_require__(92988);
+const { getNormalizedWebpackOptions } = __webpack_require__(26693);
 
-class AMDPlugin {
-	/**
-	 * @param {Record<string, any>} amdOptions the AMD options
-	 */
-	constructor(amdOptions) {
-		this.amdOptions = amdOptions;
+class WebpackOptionsDefaulter {
+	process(options) {
+		options = getNormalizedWebpackOptions(options);
+		applyWebpackOptionsDefaults(options);
+		return options;
 	}
+}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const amdOptions = this.amdOptions;
-		compiler.hooks.compilation.tap(
-			"AMDPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					AMDRequireDependency,
-					new AMDRequireDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					AMDRequireItemDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					AMDRequireItemDependency,
-					new AMDRequireItemDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					AMDRequireArrayDependency,
-					new AMDRequireArrayDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					AMDRequireContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					AMDRequireContextDependency,
-					new AMDRequireContextDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					AMDDefineDependency,
-					new AMDDefineDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					UnsupportedDependency,
-					new UnsupportedDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					LocalModuleDependency,
-					new LocalModuleDependency.Template()
-				);
+module.exports = WebpackOptionsDefaulter;
 
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.amdDefine)
-					.tap("AMDPlugin", (module, set) => {
-						set.add(RuntimeGlobals.require);
-					});
 
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.amdOptions)
-					.tap("AMDPlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
+/***/ }),
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.amdDefine)
-					.tap("AMDPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
-					});
+/***/ 98421:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.amdOptions)
-					.tap("AMDPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new AMDOptionsRuntimeModule(amdOptions)
-						);
-					});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
 
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.amd !== undefined && !parserOptions.amd) return;
 
-					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
-						parser.hooks.expression
-							.for(optionExpr)
-							.tap(
-								"AMDPlugin",
-								toConstantDependency(parser, RuntimeGlobals.amdOptions, [
-									RuntimeGlobals.amdOptions
-								])
-							);
-						parser.hooks.evaluateIdentifier
-							.for(optionExpr)
-							.tap(
-								"AMDPlugin",
-								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
-							);
-						parser.hooks.evaluateTypeof
-							.for(optionExpr)
-							.tap("AMDPlugin", evaluateToString("object"));
-						parser.hooks.typeof
-							.for(optionExpr)
-							.tap(
-								"AMDPlugin",
-								toConstantDependency(parser, JSON.stringify("object"))
-							);
-					};
 
-					new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
-						parser
-					);
-					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
+const mimeTypes = __webpack_require__(78585);
+const path = __webpack_require__(71017);
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
+const createHash = __webpack_require__(49835);
+const { makePathsRelative } = __webpack_require__(82186);
 
-					tapOptionsHooks("define.amd", "define", () => "amd");
-					tapOptionsHooks("require.amd", "require", () => ["amd"]);
-					tapOptionsHooks(
-						"__webpack_amd_options__",
-						"__webpack_amd_options__",
-						() => []
-					);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
+/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
+/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
 
-					parser.hooks.expression.for("define").tap("AMDPlugin", expr => {
-						const dep = new ConstDependency(
-							RuntimeGlobals.amdDefine,
-							expr.range,
-							[RuntimeGlobals.amdDefine]
-						);
-						dep.loc = expr.loc;
-						parser.state.module.addPresentationalDependency(dep);
-						return true;
-					});
-					parser.hooks.typeof
-						.for("define")
-						.tap(
-							"AMDPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-					parser.hooks.evaluateTypeof
-						.for("define")
-						.tap("AMDPlugin", evaluateToString("function"));
-					parser.hooks.canRename.for("define").tap("AMDPlugin", approve);
-					parser.hooks.rename.for("define").tap("AMDPlugin", expr => {
-						const dep = new ConstDependency(
-							RuntimeGlobals.amdDefine,
-							expr.range,
-							[RuntimeGlobals.amdDefine]
-						);
-						dep.loc = expr.loc;
-						parser.state.module.addPresentationalDependency(dep);
-						return false;
-					});
-					parser.hooks.typeof
-						.for("require")
-						.tap(
-							"AMDPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-					parser.hooks.evaluateTypeof
-						.for("require")
-						.tap("AMDPlugin", evaluateToString("function"));
-				};
+const mergeMaybeArrays = (a, b) => {
+	const set = new Set();
+	if (Array.isArray(a)) for (const item of a) set.add(item);
+	else set.add(a);
+	if (Array.isArray(b)) for (const item of b) set.add(item);
+	else set.add(b);
+	return Array.from(set);
+};
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("AMDPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("AMDPlugin", handler);
+const mergeAssetInfo = (a, b) => {
+	const result = { ...a, ...b };
+	for (const key of Object.keys(a)) {
+		if (key in b) {
+			if (a[key] === b[key]) continue;
+			switch (key) {
+				case "fullhash":
+				case "chunkhash":
+				case "modulehash":
+				case "contenthash":
+					result[key] = mergeMaybeArrays(a[key], b[key]);
+					break;
+				case "immutable":
+				case "development":
+				case "hotModuleReplacement":
+				case "javascriptModule":
+					result[key] = a[key] || b[key];
+					break;
+				case "related":
+					result[key] = mergeRelatedInfo(a[key], b[key]);
+					break;
+				default:
+					throw new Error(`Can't handle conflicting asset info for ${key}`);
 			}
-		);
+		}
 	}
-}
-
-module.exports = AMDPlugin;
-
-
-/***/ }),
-
-/***/ 33516:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	return result;
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const mergeRelatedInfo = (a, b) => {
+	const result = { ...a, ...b };
+	for (const key of Object.keys(a)) {
+		if (key in b) {
+			if (a[key] === b[key]) continue;
+			result[key] = mergeMaybeArrays(a[key], b[key]);
+		}
+	}
+	return result;
+};
 
+const encodeDataUri = (encoding, source) => {
+	let encodedContent;
 
+	switch (encoding) {
+		case "base64": {
+			encodedContent = source.buffer().toString("base64");
+			break;
+		}
+		case false: {
+			const content = source.source();
 
-const DependencyTemplate = __webpack_require__(5160);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+			if (typeof content !== "string") {
+				encodedContent = content.toString("utf-8");
+			}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+			encodedContent = encodeURIComponent(encodedContent).replace(
+				/[!'()*]/g,
+				character => "%" + character.codePointAt(0).toString(16)
+			);
+			break;
+		}
+		default:
+			throw new Error(`Unsupported encoding '${encoding}'`);
+	}
 
-class AMDRequireArrayDependency extends NullDependency {
-	constructor(depsArray, range) {
-		super();
+	return encodedContent;
+};
 
-		this.depsArray = depsArray;
-		this.range = range;
-	}
+const decodeDataUriContent = (encoding, content) => {
+	const isBase64 = encoding === "base64";
+	return isBase64
+		? Buffer.from(content, "base64")
+		: Buffer.from(decodeURIComponent(content), "ascii");
+};
 
-	get type() {
-		return "amd require array";
-	}
+const JS_TYPES = new Set(["javascript"]);
+const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
 
-	get category() {
-		return "amd";
+class AssetGenerator extends Generator {
+	/**
+	 * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url
+	 * @param {string=} filename override for output.assetModuleFilename
+	 * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath
+	 * @param {AssetModuleOutputPath=} outputPath the output path for the emitted file which is not included in the runtime import
+	 * @param {boolean=} emit generate output asset
+	 */
+	constructor(dataUrlOptions, filename, publicPath, outputPath, emit) {
+		super();
+		this.dataUrlOptions = dataUrlOptions;
+		this.filename = filename;
+		this.publicPath = publicPath;
+		this.outputPath = outputPath;
+		this.emit = emit;
 	}
 
-	serialize(context) {
-		const { write } = context;
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(
+		module,
+		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
+	) {
+		switch (type) {
+			case "asset":
+				return module.originalSource();
+			default: {
+				runtimeRequirements.add(RuntimeGlobals.module);
 
-		write(this.depsArray);
-		write(this.range);
+				const originalSource = module.originalSource();
+				if (module.buildInfo.dataUrl) {
+					let encodedSource;
+					if (typeof this.dataUrlOptions === "function") {
+						encodedSource = this.dataUrlOptions.call(
+							null,
+							originalSource.source(),
+							{
+								filename: module.matchResource || module.resource,
+								module
+							}
+						);
+					} else {
+						/** @type {string | false | undefined} */
+						let encoding = this.dataUrlOptions.encoding;
+						if (encoding === undefined) {
+							if (
+								module.resourceResolveData &&
+								module.resourceResolveData.encoding !== undefined
+							) {
+								encoding = module.resourceResolveData.encoding;
+							}
+						}
+						if (encoding === undefined) {
+							encoding = "base64";
+						}
+						let ext;
+						let mimeType = this.dataUrlOptions.mimetype;
+						if (mimeType === undefined) {
+							ext = path.extname(module.nameForCondition());
+							if (
+								module.resourceResolveData &&
+								module.resourceResolveData.mimetype !== undefined
+							) {
+								mimeType =
+									module.resourceResolveData.mimetype +
+									module.resourceResolveData.parameters;
+							} else if (ext) {
+								mimeType = mimeTypes.lookup(ext);
+							}
+						}
+						if (typeof mimeType !== "string") {
+							throw new Error(
+								"DataUrl can't be generated automatically, " +
+									`because there is no mimetype for "${ext}" in mimetype database. ` +
+									'Either pass a mimetype via "generator.mimetype" or ' +
+									'use type: "asset/resource" to create a resource file instead of a DataUrl'
+							);
+						}
 
-		super.serialize(context);
-	}
+						let encodedContent;
 
-	deserialize(context) {
-		const { read } = context;
+						if (
+							module.resourceResolveData &&
+							module.resourceResolveData.encoding === encoding &&
+							decodeDataUriContent(
+								module.resourceResolveData.encoding,
+								module.resourceResolveData.encodedContent
+							).equals(originalSource.buffer())
+						) {
+							encodedContent = module.resourceResolveData.encodedContent;
+						} else {
+							encodedContent = encodeDataUri(encoding, originalSource);
+						}
 
-		this.depsArray = read();
-		this.range = read();
+						encodedSource = `data:${mimeType}${
+							encoding ? `;${encoding}` : ""
+						},${encodedContent}`;
+					}
+					const data = getData();
+					data.set("url", Buffer.from(encodedSource));
+					return new RawSource(
+						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
+							encodedSource
+						)};`
+					);
+				} else {
+					const assetModuleFilename =
+						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+					const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
+					if (runtimeTemplate.outputOptions.hashSalt) {
+						hash.update(runtimeTemplate.outputOptions.hashSalt);
+					}
+					hash.update(originalSource.buffer());
+					const fullHash = /** @type {string} */ (
+						hash.digest(runtimeTemplate.outputOptions.hashDigest)
+					);
+					const contentHash = fullHash.slice(
+						0,
+						runtimeTemplate.outputOptions.hashDigestLength
+					);
+					module.buildInfo.fullContentHash = fullHash;
+					const sourceFilename = makePathsRelative(
+						runtimeTemplate.compilation.compiler.context,
+						module.matchResource || module.resource,
+						runtimeTemplate.compilation.compiler.root
+					).replace(/^\.\//, "");
+					let { path: filename, info: assetInfo } =
+						runtimeTemplate.compilation.getAssetPathWithInfo(
+							assetModuleFilename,
+							{
+								module,
+								runtime,
+								filename: sourceFilename,
+								chunkGraph,
+								contentHash
+							}
+						);
+					let assetPath;
+					if (this.publicPath !== undefined) {
+						const { path, info } =
+							runtimeTemplate.compilation.getAssetPathWithInfo(
+								this.publicPath,
+								{
+									module,
+									runtime,
+									filename: sourceFilename,
+									chunkGraph,
+									contentHash
+								}
+							);
+						assetInfo = mergeAssetInfo(assetInfo, info);
+						assetPath = JSON.stringify(path + filename);
+					} else {
+						runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
+						assetPath = runtimeTemplate.concatenation(
+							{ expr: RuntimeGlobals.publicPath },
+							filename
+						);
+					}
+					assetInfo = {
+						sourceFilename,
+						...assetInfo
+					};
+					if (this.outputPath) {
+						const { path: outputPath, info } =
+							runtimeTemplate.compilation.getAssetPathWithInfo(
+								this.outputPath,
+								{
+									module,
+									runtime,
+									filename: sourceFilename,
+									chunkGraph,
+									contentHash
+								}
+							);
+						assetInfo = mergeAssetInfo(assetInfo, info);
+						filename = path.posix.join(outputPath, filename);
+					}
+					module.buildInfo.filename = filename;
+					module.buildInfo.assetInfo = assetInfo;
+					if (getData) {
+						// Due to code generation caching module.buildInfo.XXX can't used to store such information
+						// It need to be stored in the code generation results instead, where it's cached too
+						// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
+						const data = getData();
+						data.set("fullContentHash", fullHash);
+						data.set("filename", filename);
+						data.set("assetInfo", assetInfo);
+					}
 
-		super.deserialize(context);
+					return new RawSource(
+						`${RuntimeGlobals.module}.exports = ${assetPath};`
+					);
+				}
+			}
+		}
 	}
-}
-
-makeSerializable(
-	AMDRequireArrayDependency,
-	"webpack/lib/dependencies/AMDRequireArrayDependency"
-);
 
-AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate extends (
-	DependencyTemplate
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {AMDRequireArrayDependency} */ (dependency);
-		const content = this.getContent(dep, templateContext);
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+	getTypes(module) {
+		if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) {
+			return JS_TYPES;
+		} else {
+			return JS_AND_ASSET_TYPES;
+		}
 	}
 
-	getContent(dep, templateContext) {
-		const requires = dep.depsArray.map(dependency => {
-			return this.contentForDependency(dependency, templateContext);
-		});
-		return `[${requires.join(", ")}]`;
-	}
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		switch (type) {
+			case "asset": {
+				const originalSource = module.originalSource();
 
-	contentForDependency(
-		dep,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		if (typeof dep === "string") {
-			return dep;
-		}
+				if (!originalSource) {
+					return 0;
+				}
 
-		if (dep.localModule) {
-			return dep.localModule.variableName();
-		} else {
-			return runtimeTemplate.moduleExports({
-				module: moduleGraph.getModule(dep),
-				chunkGraph,
-				request: dep.request,
-				runtimeRequirements
-			});
+				return originalSource.size();
+			}
+			default:
+				if (module.buildInfo && module.buildInfo.dataUrl) {
+					const originalSource = module.originalSource();
+
+					if (!originalSource) {
+						return 0;
+					}
+
+					// roughly for data url
+					// Example: m.exports="data:image/png;base64,ag82/f+2=="
+					// 4/3 = base64 encoding
+					// 34 = ~ data url header + footer + rounding
+					return originalSource.size() * 1.34 + 36;
+				} else {
+					// it's only estimated so this number is probably fine
+					// Example: m.exports=r.p+"0123456789012345678901.ext"
+					return 42;
+				}
 		}
 	}
-};
 
-module.exports = AMDRequireArrayDependency;
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {
+		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	}
+}
+
+module.exports = AssetGenerator;
 
 
 /***/ }),
 
-/***/ 96123:
+/***/ 16109:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Yuta Hiroto @hiroppy
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
+const { cleverMerge } = __webpack_require__(60839);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const memoize = __webpack_require__(78676);
 
-class AMDRequireContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-		this.range = range;
-		this.valueRange = valueRange;
-	}
+const getSchema = name => {
+	const { definitions } = __webpack_require__(73342);
+	return {
+		definitions,
+		oneOf: [{ $ref: `#/definitions/${name}` }]
+	};
+};
 
-	get type() {
-		return "amd require context";
-	}
+const generatorValidationOptions = {
+	name: "Asset Modules Plugin",
+	baseDataPath: "generator"
+};
+const validateGeneratorOptions = {
+	asset: createSchemaValidation(
+		__webpack_require__(55125),
+		() => getSchema("AssetGeneratorOptions"),
+		generatorValidationOptions
+	),
+	"asset/resource": createSchemaValidation(
+		__webpack_require__(4405),
+		() => getSchema("AssetResourceGeneratorOptions"),
+		generatorValidationOptions
+	),
+	"asset/inline": createSchemaValidation(
+		__webpack_require__(62368),
+		() => getSchema("AssetInlineGeneratorOptions"),
+		generatorValidationOptions
+	)
+};
 
-	get category() {
-		return "amd";
+const validateParserOptions = createSchemaValidation(
+	__webpack_require__(45020),
+	() => getSchema("AssetParserOptions"),
+	{
+		name: "Asset Modules Plugin",
+		baseDataPath: "parser"
 	}
+);
 
-	serialize(context) {
-		const { write } = context;
+const getAssetGenerator = memoize(() => __webpack_require__(98421));
+const getAssetParser = memoize(() => __webpack_require__(91112));
+const getAssetSourceParser = memoize(() => __webpack_require__(30953));
+const getAssetSourceGenerator = memoize(() =>
+	__webpack_require__(18749)
+);
 
-		write(this.range);
-		write(this.valueRange);
+const type = "asset";
+const plugin = "AssetModulesPlugin";
 
-		super.serialize(context);
-	}
+class AssetModulesPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			plugin,
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("asset")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						parserOptions = cleverMerge(
+							compiler.options.module.parser.asset,
+							parserOptions
+						);
 
-	deserialize(context) {
-		const { read } = context;
+						let dataUrlCondition = parserOptions.dataUrlCondition;
+						if (!dataUrlCondition || typeof dataUrlCondition === "object") {
+							dataUrlCondition = {
+								maxSize: 8096,
+								...dataUrlCondition
+							};
+						}
 
-		this.range = read();
-		this.valueRange = read();
+						const AssetParser = getAssetParser();
 
-		super.deserialize(context);
-	}
-}
+						return new AssetParser(dataUrlCondition);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/inline")
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
 
-makeSerializable(
-	AMDRequireContextDependency,
-	"webpack/lib/dependencies/AMDRequireContextDependency"
-);
+						return new AssetParser(true);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/resource")
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
 
-AMDRequireContextDependency.Template = __webpack_require__(75815);
+						return new AssetParser(false);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/source")
+					.tap(plugin, parserOptions => {
+						const AssetSourceParser = getAssetSourceParser();
 
-module.exports = AMDRequireContextDependency;
+						return new AssetSourceParser();
+					});
 
+				for (const type of ["asset", "asset/inline", "asset/resource"]) {
+					normalModuleFactory.hooks.createGenerator
+						.for(type)
+						.tap(plugin, generatorOptions => {
+							validateGeneratorOptions[type](generatorOptions);
 
-/***/ }),
+							let dataUrl = undefined;
+							if (type !== "asset/resource") {
+								dataUrl = generatorOptions.dataUrl;
+								if (!dataUrl || typeof dataUrl === "object") {
+									dataUrl = {
+										encoding: undefined,
+										mimetype: undefined,
+										...dataUrl
+									};
+								}
+							}
 
-/***/ 76932:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+							let filename = undefined;
+							let publicPath = undefined;
+							let outputPath = undefined;
+							if (type !== "asset/inline") {
+								filename = generatorOptions.filename;
+								publicPath = generatorOptions.publicPath;
+								outputPath = generatorOptions.outputPath;
+							}
+
+							const AssetGenerator = getAssetGenerator();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+							return new AssetGenerator(
+								dataUrl,
+								filename,
+								publicPath,
+								outputPath,
+								generatorOptions.emit !== false
+							);
+						});
+				}
+				normalModuleFactory.hooks.createGenerator
+					.for("asset/source")
+					.tap(plugin, () => {
+						const AssetSourceGenerator = getAssetSourceGenerator();
 
+						return new AssetSourceGenerator();
+					});
 
+				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { chunk, codeGenerationResults } = options;
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const makeSerializable = __webpack_require__(33032);
+					const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+						chunk,
+						"asset",
+						compareModulesByIdentifier
+					);
+					if (modules) {
+						for (const module of modules) {
+							try {
+								const codeGenResult = codeGenerationResults.get(
+									module,
+									chunk.runtime
+								);
+								result.push({
+									render: () => codeGenResult.sources.get(type),
+									filename:
+										module.buildInfo.filename ||
+										codeGenResult.data.get("filename"),
+									info:
+										module.buildInfo.assetInfo ||
+										codeGenResult.data.get("assetInfo"),
+									auxiliary: true,
+									identifier: `assetModule${chunkGraph.getModuleId(module)}`,
+									hash:
+										module.buildInfo.fullContentHash ||
+										codeGenResult.data.get("fullContentHash")
+								});
+							} catch (e) {
+								e.message += `\nduring rendering of asset ${module.identifier()}`;
+								throw e;
+							}
+						}
+					}
 
-class AMDRequireDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(loc, request) {
-		super(null, loc, request);
+					return result;
+				});
+
+				compilation.hooks.prepareModuleExecution.tap(
+					"AssetModulesPlugin",
+					(options, context) => {
+						const { codeGenerationResult } = options;
+						const source = codeGenerationResult.sources.get("asset");
+						if (source === undefined) return;
+						context.assets.set(codeGenerationResult.data.get("filename"), {
+							source,
+							info: codeGenerationResult.data.get("assetInfo")
+						});
+					}
+				);
+			}
+		);
 	}
 }
 
-makeSerializable(
-	AMDRequireDependenciesBlock,
-	"webpack/lib/dependencies/AMDRequireDependenciesBlock"
-);
-
-module.exports = AMDRequireDependenciesBlock;
+module.exports = AssetModulesPlugin;
 
 
 /***/ }),
 
-/***/ 66866:
+/***/ 91112:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Yuta Hiroto @hiroppy
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const AMDRequireArrayDependency = __webpack_require__(33516);
-const AMDRequireContextDependency = __webpack_require__(96123);
-const AMDRequireDependenciesBlock = __webpack_require__(76932);
-const AMDRequireDependency = __webpack_require__(43911);
-const AMDRequireItemDependency = __webpack_require__(71806);
-const ConstDependency = __webpack_require__(76911);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const LocalModuleDependency = __webpack_require__(52805);
-const { getLocalModule } = __webpack_require__(75827);
-const UnsupportedDependency = __webpack_require__(51669);
-const getFunctionExpression = __webpack_require__(50396);
-
-class AMDRequireDependenciesBlockParserPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
-	processFunctionArgument(parser, expression) {
-		let bindThis = true;
-		const fnData = getFunctionExpression(expression);
-		if (fnData) {
-			parser.inScope(
-				fnData.fn.params.filter(i => {
-					return !["require", "module", "exports"].includes(i.name);
-				}),
-				() => {
-					if (fnData.fn.body.type === "BlockStatement") {
-						parser.walkStatement(fnData.fn.body);
-					} else {
-						parser.walkExpression(fnData.fn.body);
-					}
-				}
-			);
-			parser.walkExpressions(fnData.expressions);
-			if (fnData.needThis === false) {
-				bindThis = false;
-			}
-		} else {
-			parser.walkExpression(expression);
-		}
-		return bindThis;
-	}
-
-	apply(parser) {
-		parser.hooks.call
-			.for("require")
-			.tap(
-				"AMDRequireDependenciesBlockParserPlugin",
-				this.processCallRequire.bind(this, parser)
-			);
-	}
-
-	processArray(parser, expr, param) {
-		if (param.isArray()) {
-			for (const p of param.items) {
-				const result = this.processItem(parser, expr, p);
-				if (result === undefined) {
-					this.processContext(parser, expr, p);
-				}
-			}
-			return true;
-		} else if (param.isConstArray()) {
-			const deps = [];
-			for (const request of param.array) {
-				let dep, localModule;
-				if (request === "require") {
-					dep = "__webpack_require__";
-				} else if (["exports", "module"].includes(request)) {
-					dep = request;
-				} else if ((localModule = getLocalModule(parser.state, request))) {
-					localModule.flagUsed();
-					dep = new LocalModuleDependency(localModule, undefined, false);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-				} else {
-					dep = this.newRequireItemDependency(request);
-					dep.loc = expr.loc;
-					dep.optional = !!parser.scope.inTry;
-					parser.state.current.addDependency(dep);
-				}
-				deps.push(dep);
-			}
-			const dep = this.newRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		}
-	}
-	processItem(parser, expr, param) {
-		if (param.isConditional()) {
-			for (const p of param.options) {
-				const result = this.processItem(parser, expr, p);
-				if (result === undefined) {
-					this.processContext(parser, expr, p);
-				}
-			}
-			return true;
-		} else if (param.isString()) {
-			let dep, localModule;
-			if (param.string === "require") {
-				dep = new ConstDependency("__webpack_require__", param.string, [
-					RuntimeGlobals.require
-				]);
-			} else if (param.string === "module") {
-				dep = new ConstDependency(
-					parser.state.module.buildInfo.moduleArgument,
-					param.range,
-					[RuntimeGlobals.module]
-				);
-			} else if (param.string === "exports") {
-				dep = new ConstDependency(
-					parser.state.module.buildInfo.exportsArgument,
-					param.range,
-					[RuntimeGlobals.exports]
-				);
-			} else if ((localModule = getLocalModule(parser.state, param.string))) {
-				localModule.flagUsed();
-				dep = new LocalModuleDependency(localModule, param.range, false);
-			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		}
-	}
-	processContext(parser, expr, param) {
-		const dep = ContextDependencyHelpers.create(
-			AMDRequireContextDependency,
-			param.range,
-			param,
-			expr,
-			this.options,
-			{
-				category: "amd"
-			},
-			parser
-		);
-		if (!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!parser.scope.inTry;
-		parser.state.current.addDependency(dep);
-		return true;
-	}
+const Parser = __webpack_require__(11715);
 
-	processArrayForRequestString(param) {
-		if (param.isArray()) {
-			const result = param.items.map(item =>
-				this.processItemForRequestString(item)
-			);
-			if (result.every(Boolean)) return result.join(" ");
-		} else if (param.isConstArray()) {
-			return param.array.join(" ");
-		}
-	}
+/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-	processItemForRequestString(param) {
-		if (param.isConditional()) {
-			const result = param.options.map(item =>
-				this.processItemForRequestString(item)
-			);
-			if (result.every(Boolean)) return result.join("|");
-		} else if (param.isString()) {
-			return param.string;
-		}
+class AssetParser extends Parser {
+	/**
+	 * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl
+	 */
+	constructor(dataUrlCondition) {
+		super();
+		this.dataUrlCondition = dataUrlCondition;
 	}
 
-	processCallRequire(parser, expr) {
-		let param;
-		let depBlock;
-		let dep;
-		let result;
-
-		const old = parser.state.current;
-
-		if (expr.arguments.length >= 1) {
-			param = parser.evaluateExpression(expr.arguments[0]);
-			depBlock = this.newRequireDependenciesBlock(
-				expr.loc,
-				this.processArrayForRequestString(param)
-			);
-			dep = this.newRequireDependency(
-				expr.range,
-				param.range,
-				expr.arguments.length > 1 ? expr.arguments[1].range : null,
-				expr.arguments.length > 2 ? expr.arguments[2].range : null
-			);
-			dep.loc = expr.loc;
-			depBlock.addDependency(dep);
-
-			parser.state.current = depBlock;
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetParser doesn't accept preparsed AST");
 		}
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "default";
 
-		if (expr.arguments.length === 1) {
-			parser.inScope([], () => {
-				result = this.processArray(parser, expr, param);
+		if (typeof this.dataUrlCondition === "function") {
+			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
+				filename: state.module.matchResource || state.module.resource,
+				module: state.module
 			});
-			parser.state.current = old;
-			if (!result) return;
-			parser.state.current.addBlock(depBlock);
-			return true;
-		}
-
-		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
-			try {
-				parser.inScope([], () => {
-					result = this.processArray(parser, expr, param);
-				});
-				if (!result) {
-					const dep = new UnsupportedDependency("unsupported", expr.range);
-					old.addPresentationalDependency(dep);
-					if (parser.state.module) {
-						parser.state.module.addError(
-							new UnsupportedFeatureWarning(
-								"Cannot statically analyse 'require(…, …)' in line " +
-									expr.loc.start.line,
-								expr.loc
-							)
-						);
-					}
-					depBlock = null;
-					return true;
-				}
-				dep.functionBindThis = this.processFunctionArgument(
-					parser,
-					expr.arguments[1]
-				);
-				if (expr.arguments.length === 3) {
-					dep.errorCallbackBindThis = this.processFunctionArgument(
-						parser,
-						expr.arguments[2]
-					);
-				}
-			} finally {
-				parser.state.current = old;
-				if (depBlock) parser.state.current.addBlock(depBlock);
-			}
-			return true;
+		} else if (typeof this.dataUrlCondition === "boolean") {
+			state.module.buildInfo.dataUrl = this.dataUrlCondition;
+		} else if (
+			this.dataUrlCondition &&
+			typeof this.dataUrlCondition === "object"
+		) {
+			state.module.buildInfo.dataUrl =
+				Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
+		} else {
+			throw new Error("Unexpected dataUrlCondition type");
 		}
-	}
 
-	newRequireDependenciesBlock(loc, request) {
-		return new AMDRequireDependenciesBlock(loc, request);
-	}
-	newRequireDependency(
-		outerRange,
-		arrayRange,
-		functionRange,
-		errorCallbackRange
-	) {
-		return new AMDRequireDependency(
-			outerRange,
-			arrayRange,
-			functionRange,
-			errorCallbackRange
-		);
-	}
-	newRequireItemDependency(request, range) {
-		return new AMDRequireItemDependency(request, range);
-	}
-	newRequireArrayDependency(depsArray, range) {
-		return new AMDRequireArrayDependency(depsArray, range);
+		return state;
 	}
 }
-module.exports = AMDRequireDependenciesBlockParserPlugin;
+
+module.exports = AssetParser;
 
 
 /***/ }),
 
-/***/ 43911:
+/***/ 18749:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
 const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-
-class AMDRequireDependency extends NullDependency {
-	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
-		super();
-
-		this.outerRange = outerRange;
-		this.arrayRange = arrayRange;
-		this.functionRange = functionRange;
-		this.errorCallbackRange = errorCallbackRange;
-		this.functionBindThis = false;
-		this.errorCallbackBindThis = false;
-	}
-
-	get category() {
-		return "amd";
-	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.outerRange);
-		write(this.arrayRange);
-		write(this.functionRange);
-		write(this.errorCallbackRange);
-		write(this.functionBindThis);
-		write(this.errorCallbackBindThis);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.outerRange = read();
-		this.arrayRange = read();
-		this.functionRange = read();
-		this.errorCallbackRange = read();
-		this.functionBindThis = read();
-		this.errorCallbackBindThis = read();
-
-		super.deserialize(context);
-	}
-}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
 
-makeSerializable(
-	AMDRequireDependency,
-	"webpack/lib/dependencies/AMDRequireDependency"
-);
+const TYPES = new Set(["javascript"]);
 
-AMDRequireDependency.Template = class AMDRequireDependencyTemplate extends (
-	NullDependency.Template
-) {
+class AssetSourceGenerator extends Generator {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {AMDRequireDependency} */ (dependency);
-		const depBlock = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dep)
-		);
-		const promise = runtimeTemplate.blockPromise({
-			chunkGraph,
-			block: depBlock,
-			message: "AMD require",
-			runtimeRequirements
-		});
+	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.module);
 
-		// has array range but no function range
-		if (dep.arrayRange && !dep.functionRange) {
-			const startBlock = `${promise}.then(function() {`;
-			const endBlock = `;})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
-			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+		const originalSource = module.originalSource();
 
-			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+		if (!originalSource) {
+			return new RawSource("");
+		}
 
-			source.replace(dep.arrayRange[1], dep.outerRange[1] - 1, endBlock);
+		const content = originalSource.source();
 
-			return;
+		let encodedSource;
+		if (typeof content === "string") {
+			encodedSource = content;
+		} else {
+			encodedSource = content.toString("utf-8");
 		}
+		return new RawSource(
+			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
+		);
+	}
 
-		// has function range but no array range
-		if (dep.functionRange && !dep.arrayRange) {
-			const startBlock = `${promise}.then((`;
-			const endBlock = `).bind(exports, __webpack_require__, exports, module))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
-			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
-
-			source.replace(dep.outerRange[0], dep.functionRange[0] - 1, startBlock);
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
 
-			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
 
-			return;
+		if (!originalSource) {
+			return 0;
 		}
 
-		// has array range, function range, and errorCallbackRange
-		if (dep.arrayRange && dep.functionRange && dep.errorCallbackRange) {
-			const startBlock = `${promise}.then(function() { `;
-			const errorRangeBlock = `}${
-				dep.functionBindThis ? ".bind(this)" : ""
-			})['catch'](`;
-			const endBlock = `${dep.errorCallbackBindThis ? ".bind(this)" : ""})`;
-
-			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
-
-			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
-
-			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+		// Example: m.exports="abcd"
+		return originalSource.size() + 12;
+	}
+}
 
-			source.insert(
-				dep.functionRange[1],
-				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
-			);
+module.exports = AssetSourceGenerator;
 
-			source.replace(
-				dep.functionRange[1],
-				dep.errorCallbackRange[0] - 1,
-				errorRangeBlock
-			);
 
-			source.replace(
-				dep.errorCallbackRange[1],
-				dep.outerRange[1] - 1,
-				endBlock
-			);
+/***/ }),
 
-			return;
-		}
+/***/ 30953:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// has array range, function range, but no errorCallbackRange
-		if (dep.arrayRange && dep.functionRange) {
-			const startBlock = `${promise}.then(function() { `;
-			const endBlock = `}${
-				dep.functionBindThis ? ".bind(this)" : ""
-			})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
-			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Yuta Hiroto @hiroppy
+*/
 
-			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
 
-			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
 
-			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+const Parser = __webpack_require__(11715);
 
-			source.insert(
-				dep.functionRange[1],
-				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
-			);
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+class AssetSourceParser extends Parser {
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetSourceParser doesn't accept preparsed AST");
 		}
+		const { module } = state;
+		module.buildInfo.strict = true;
+		module.buildMeta.exportsType = "default";
+
+		return state;
 	}
-};
+}
 
-module.exports = AMDRequireDependency;
+module.exports = AssetSourceParser;
 
 
 /***/ }),
 
-/***/ 71806:
+/***/ 19684:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -72243,1161 +66100,1702 @@ module.exports = AMDRequireDependency;
 
 
 
+const { RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
 
-class AMDRequireItemDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-		this.range = range;
+const TYPES = new Set(["javascript"]);
+
+class RawDataUrlModule extends Module {
+	/**
+	 * @param {string} url raw url
+	 * @param {string} identifier unique identifier
+	 * @param {string=} readableIdentifier readable identifier
+	 */
+	constructor(url, identifier, readableIdentifier) {
+		super("asset/raw-data-url", null);
+		this.url = url;
+		this.urlBuffer = url ? Buffer.from(url) : undefined;
+		this.identifierStr = identifier || this.url;
+		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
 	}
 
-	get type() {
-		return "amd require";
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
 
-	get category() {
-		return "amd";
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this.identifierStr;
 	}
-}
 
-makeSerializable(
-	AMDRequireItemDependency,
-	"webpack/lib/dependencies/AMDRequireItemDependency"
-);
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		if (this.url === undefined) this.url = this.urlBuffer.toString();
+		return Math.max(1, this.url.length);
+	}
 
-AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return requestShortener.shorten(this.readableIdentifierStr);
+	}
 
-module.exports = AMDRequireItemDependency;
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: true
+		};
+		callback();
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		if (this.url === undefined) this.url = this.urlBuffer.toString();
+		const sources = new Map();
+		sources.set(
+			"javascript",
+			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
+		);
+		const data = new Map();
+		data.set("url", this.urlBuffer);
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		return { sources, runtimeRequirements, data };
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(this.urlBuffer);
+		super.updateHash(hash, context);
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.urlBuffer);
+		write(this.identifierStr);
+		write(this.readableIdentifierStr);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.urlBuffer = read();
+		this.identifierStr = read();
+		this.readableIdentifierStr = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(RawDataUrlModule, "webpack/lib/asset/RawDataUrlModule");
+
+module.exports = RawDataUrlModule;
 
 
 /***/ }),
 
-/***/ 45242:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 41153:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
+const InitFragment = __webpack_require__(55870);
 const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const Template = __webpack_require__(39722);
 
-class AMDDefineRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("amd define");
-	}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
+/**
+ * @typedef {GenerateContext} Context
+ */
+class AwaitDependenciesInitFragment extends InitFragment {
 	/**
-	 * @returns {string} runtime code
+	 * @param {Set<string>} promises the promises that should be awaited
 	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.amdDefine} = function () {`,
-			Template.indent("throw new Error('define cannot be used indirect');"),
-			"};"
-		]);
+	constructor(promises) {
+		super(
+			undefined,
+			InitFragment.STAGE_ASYNC_DEPENDENCIES,
+			0,
+			"await-dependencies"
+		);
+		this.promises = promises;
 	}
-}
 
-class AMDOptionsRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Record<string, boolean | number | string>} options the AMD options
-	 */
-	constructor(options) {
-		super("amd options");
-		this.options = options;
+	merge(other) {
+		const promises = new Set(other.promises);
+		for (const p of this.promises) {
+			promises.add(p);
+		}
+		return new AwaitDependenciesInitFragment(promises);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	generate() {
+	getContent({ runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.module);
+		const promises = this.promises;
+		if (promises.size === 0) {
+			return "";
+		}
+		if (promises.size === 1) {
+			for (const p of promises) {
+				return Template.asString([
+					`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
+					`${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
+					""
+				]);
+			}
+		}
+		const sepPromises = Array.from(promises).join(", ");
+		// TODO check if destructuring is supported
 		return Template.asString([
-			`${RuntimeGlobals.amdOptions} = ${JSON.stringify(this.options)};`
+			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
+			`([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
+			""
 		]);
 	}
 }
 
-exports.AMDDefineRuntimeModule = AMDDefineRuntimeModule;
-exports.AMDOptionsRuntimeModule = AMDOptionsRuntimeModule;
+module.exports = AwaitDependenciesInitFragment;
 
 
 /***/ }),
 
-/***/ 57403:
+/***/ 59498:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const DependencyTemplate = __webpack_require__(5160);
-const InitFragment = __webpack_require__(55870);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
-
-class CachedConstDependency extends NullDependency {
-	constructor(expression, range, identifier) {
-		super();
+const HarmonyImportDependency = __webpack_require__(57154);
 
-		this.expression = expression;
-		this.range = range;
-		this.identifier = identifier;
-		this._hashUpdate = undefined;
-	}
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
+class InferAsyncModulesPlugin {
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined)
-			this._hashUpdate = "" + this.identifier + this.range + this.expression;
-		hash.update(this._hashUpdate);
+	apply(compiler) {
+		compiler.hooks.compilation.tap("InferAsyncModulesPlugin", compilation => {
+			const { moduleGraph } = compilation;
+			compilation.hooks.finishModules.tap(
+				"InferAsyncModulesPlugin",
+				modules => {
+					/** @type {Set<Module>} */
+					const queue = new Set();
+					for (const module of modules) {
+						if (module.buildMeta && module.buildMeta.async) {
+							queue.add(module);
+						}
+					}
+					for (const module of queue) {
+						moduleGraph.setAsync(module);
+						for (const [
+							originModule,
+							connections
+						] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+							if (
+								connections.some(
+									c =>
+										c.dependency instanceof HarmonyImportDependency &&
+										c.isTargetActive(undefined)
+								)
+							) {
+								queue.add(originModule);
+							}
+						}
+					}
+				}
+			);
+		});
 	}
+}
 
-	serialize(context) {
-		const { write } = context;
+module.exports = InferAsyncModulesPlugin;
 
-		write(this.expression);
-		write(this.range);
-		write(this.identifier);
 
-		super.serialize(context);
-	}
+/***/ }),
 
-	deserialize(context) {
-		const { read } = context;
+/***/ 79233:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		this.expression = read();
-		this.range = read();
-		this.identifier = read();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		super.deserialize(context);
-	}
-}
 
-makeSerializable(
-	CachedConstDependency,
-	"webpack/lib/dependencies/CachedConstDependency"
-);
 
-CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
-	DependencyTemplate
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, dependencyTemplates, initFragments }
-	) {
-		const dep = /** @type {CachedConstDependency} */ (dependency);
+const AsyncDependencyToInitialChunkError = __webpack_require__(30111);
+const { connectChunkGroupParentAndChild } = __webpack_require__(37234);
+const ModuleGraphConnection = __webpack_require__(40639);
+const { getEntryRuntime, mergeRuntime } = __webpack_require__(17156);
 
-		initFragments.push(
-			new InitFragment(
-				`var ${dep.identifier} = ${dep.expression};\n`,
-				InitFragment.STAGE_CONSTANTS,
-				0,
-				`const ${dep.identifier}`
-			)
-		);
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-		if (typeof dep.range === "number") {
-			source.insert(dep.range, dep.identifier);
+/**
+ * @typedef {Object} QueueItem
+ * @property {number} action
+ * @property {DependenciesBlock} block
+ * @property {Module} module
+ * @property {Chunk} chunk
+ * @property {ChunkGroup} chunkGroup
+ * @property {ChunkGroupInfo} chunkGroupInfo
+ */
 
-			return;
-		}
+/** @typedef {Set<Module> & { plus: Set<Module> }} ModuleSetPlus */
 
-		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
-	}
-};
+/**
+ * @typedef {Object} ChunkGroupInfo
+ * @property {ChunkGroup} chunkGroup the chunk group
+ * @property {RuntimeSpec} runtime the runtimes
+ * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
+ * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
+ * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
+ * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
+ * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
+ * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
+ * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
+ * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
+ * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
+ * @property {number} preOrderIndex next pre order index
+ * @property {number} postOrderIndex next post order index
+ * @property {boolean} chunkLoading has a chunk loading mechanism
+ * @property {boolean} asyncChunks create async chunks
+ */
 
-module.exports = CachedConstDependency;
+/**
+ * @typedef {Object} BlockChunkGroupConnection
+ * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group
+ * @property {ChunkGroup} chunkGroup referenced chunk group
+ */
+
+const EMPTY_SET = /** @type {ModuleSetPlus} */ (new Set());
+EMPTY_SET.plus = EMPTY_SET;
+
+/**
+ * @param {ModuleSetPlus} a first set
+ * @param {ModuleSetPlus} b second set
+ * @returns {number} cmp
+ */
+const bySetSize = (a, b) => {
+	return b.size + b.plus.size - a.size - a.plus.size;
+};
 
+const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	let blockCache;
+	let modules;
 
-/***/ }),
+	const arrays = [];
 
-/***/ 59643:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = queue.pop();
+		const arr = [];
+		arrays.push(arr);
+		blockModulesMap.set(block, arr);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	for (const connection of moduleGraph.getOutgoingConnections(module)) {
+		const d = connection.dependency;
+		// We skip connections without dependency
+		if (!d) continue;
+		const m = connection.module;
+		// We skip connections without Module pointer
+		if (!m) continue;
+		// We skip weak connections
+		if (connection.weak) continue;
+		const state = connection.getActiveState(runtime);
+		// We skip inactive connections
+		if (state === false) continue;
 
+		const block = moduleGraph.getParentBlock(d);
+		let index = moduleGraph.getParentBlockIndex(d);
 
+		// deprecated fallback
+		if (index < 0) {
+			index = block.dependencies.indexOf(d);
+		}
 
-const RuntimeGlobals = __webpack_require__(16475);
+		if (blockCache !== block) {
+			modules = blockModulesMap.get((blockCache = block));
+		}
 
-exports.handleDependencyBase = (depBase, module, runtimeRequirements) => {
-	let base = undefined;
-	let type;
-	switch (depBase) {
-		case "exports":
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			base = module.exportsArgument;
-			type = "expression";
-			break;
-		case "module.exports":
-			runtimeRequirements.add(RuntimeGlobals.module);
-			base = `${module.moduleArgument}.exports`;
-			type = "expression";
-			break;
-		case "this":
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-			base = "this";
-			type = "expression";
-			break;
-		case "Object.defineProperty(exports)":
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			base = module.exportsArgument;
-			type = "Object.defineProperty";
-			break;
-		case "Object.defineProperty(module.exports)":
-			runtimeRequirements.add(RuntimeGlobals.module);
-			base = `${module.moduleArgument}.exports`;
-			type = "Object.defineProperty";
-			break;
-		case "Object.defineProperty(this)":
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-			base = "this";
-			type = "Object.defineProperty";
-			break;
-		default:
-			throw new Error(`Unsupported base ${depBase}`);
+		const i = index << 2;
+		modules[i] = m;
+		modules[i + 1] = state;
 	}
 
-	return [type, base];
+	for (const modules of arrays) {
+		if (modules.length === 0) continue;
+		let indexMap;
+		let length = 0;
+		outer: for (let j = 0; j < modules.length; j += 2) {
+			const m = modules[j];
+			if (m === undefined) continue;
+			const state = modules[j + 1];
+			if (indexMap === undefined) {
+				let i = 0;
+				for (; i < length; i += 2) {
+					if (modules[i] === m) {
+						const merged = modules[i + 1];
+						if (merged === true) continue outer;
+						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
+							merged,
+							state
+						);
+					}
+				}
+				modules[length] = m;
+				length++;
+				modules[length] = state;
+				length++;
+				if (length > 30) {
+					// To avoid worse case performance, we will use an index map for
+					// linear cost access, which allows to maintain O(n) complexity
+					// while keeping allocations down to a minimum
+					indexMap = new Map();
+					for (let i = 0; i < length; i += 2) {
+						indexMap.set(modules[i], i + 1);
+					}
+				}
+			} else {
+				const idx = indexMap.get(m);
+				if (idx !== undefined) {
+					const merged = modules[idx];
+					if (merged === true) continue outer;
+					modules[idx] = ModuleGraphConnection.addConnectionStates(
+						merged,
+						state
+					);
+				} else {
+					modules[length] = m;
+					length++;
+					modules[length] = state;
+					indexMap.set(m, length);
+					length++;
+				}
+			}
+		}
+		modules.length = length;
+	}
 };
 
+/**
+ *
+ * @param {Logger} logger a logger
+ * @param {Compilation} compilation the compilation
+ * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
+ * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
+ * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {Set<ChunkGroup>} allCreatedChunkGroups filled with all chunk groups that are created here
+ */
+const visitModules = (
+	logger,
+	compilation,
+	inputEntrypointsAndModules,
+	chunkGroupInfoMap,
+	blockConnections,
+	blocksWithNestedBlocks,
+	allCreatedChunkGroups
+) => {
+	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
-/***/ }),
+	const blockModulesRuntimeMap = new Map();
 
-/***/ 62892:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/** @type {RuntimeSpec | false} */
+	let blockModulesMapRuntime = false;
+	let blockModulesMap;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 *
+	 * @param {DependenciesBlock} block block
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 */
+	const getBlockModules = (block, runtime) => {
+		if (blockModulesMapRuntime !== runtime) {
+			blockModulesMap = blockModulesRuntimeMap.get(runtime);
+			if (blockModulesMap === undefined) {
+				blockModulesMap = new Map();
+				blockModulesRuntimeMap.set(runtime, blockModulesMap);
+			}
+		}
+		let blockModules = blockModulesMap.get(block);
+		if (blockModules !== undefined) return blockModules;
+		const module = /** @type {Module} */ (block.getRootBlock());
+		const memCache = moduleMemCaches && moduleMemCaches.get(module);
+		if (memCache !== undefined) {
+			const map = memCache.provide(
+				"bundleChunkGraph.blockModules",
+				runtime,
+				() => {
+					logger.time("visitModules: prepare");
+					const map = new Map();
+					extractBlockModules(module, moduleGraph, runtime, map);
+					logger.timeAggregate("visitModules: prepare");
+					return map;
+				}
+			);
+			for (const [block, blockModules] of map)
+				blockModulesMap.set(block, blockModules);
+			return map.get(block);
+		} else {
+			logger.time("visitModules: prepare");
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			blockModules = blockModulesMap.get(block);
+			logger.timeAggregate("visitModules: prepare");
+			return blockModules;
+		}
+	};
 
+	let statProcessedQueueItems = 0;
+	let statProcessedBlocks = 0;
+	let statConnectedChunkGroups = 0;
+	let statProcessedChunkGroupsForMerging = 0;
+	let statMergedAvailableModuleSets = 0;
+	let statForkedAvailableModules = 0;
+	let statForkedAvailableModulesCount = 0;
+	let statForkedAvailableModulesCountPlus = 0;
+	let statForkedMergedModulesCount = 0;
+	let statForkedMergedModulesCountPlus = 0;
+	let statForkedResultModulesCount = 0;
+	let statChunkGroupInfoUpdated = 0;
+	let statChildChunkGroupsReconnected = 0;
 
+	let nextChunkGroupIndex = 0;
+	let nextFreeModulePreOrderIndex = 0;
+	let nextFreeModulePostOrderIndex = 0;
 
-const Dependency = __webpack_require__(54912);
-const { UsageState } = __webpack_require__(63686);
-const Template = __webpack_require__(1626);
-const { equals } = __webpack_require__(84953);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { handleDependencyBase } = __webpack_require__(59643);
-const ModuleDependency = __webpack_require__(80321);
-const processExportInfo = __webpack_require__(55207);
+	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
+	const blockChunkGroups = new Map();
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+	/** @type {Map<string, ChunkGroupInfo>} */
+	const namedChunkGroups = new Map();
 
-const idsSymbol = Symbol("CommonJsExportRequireDependency.ids");
+	/** @type {Map<string, ChunkGroupInfo>} */
+	const namedAsyncEntrypoints = new Map();
 
-const EMPTY_OBJECT = {};
+	const ADD_AND_ENTER_ENTRY_MODULE = 0;
+	const ADD_AND_ENTER_MODULE = 1;
+	const ENTER_MODULE = 2;
+	const PROCESS_BLOCK = 3;
+	const PROCESS_ENTRY_BLOCK = 4;
+	const LEAVE_MODULE = 5;
 
-class CommonJsExportRequireDependency extends ModuleDependency {
-	constructor(range, valueRange, base, names, request, ids, resultUsed) {
-		super(request);
-		this.range = range;
-		this.valueRange = valueRange;
-		this.base = base;
-		this.names = names;
-		this.ids = ids;
-		this.resultUsed = resultUsed;
-		this.asiSafe = undefined;
-	}
+	/** @type {QueueItem[]} */
+	let queue = [];
 
-	get type() {
-		return "cjs export require";
-	}
+	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
+	const queueConnect = new Map();
+	/** @type {Set<ChunkGroupInfo>} */
+	const chunkGroupsForCombining = new Set();
 
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return Dependency.TRANSITIVE;
+	// Fill queue with entrypoint modules
+	// Create ChunkGroupInfo for entrypoints
+	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
+		const runtime = getEntryRuntime(
+			compilation,
+			chunkGroup.name,
+			chunkGroup.options
+		);
+		/** @type {ChunkGroupInfo} */
+		const chunkGroupInfo = {
+			chunkGroup,
+			runtime,
+			minAvailableModules: undefined,
+			minAvailableModulesOwned: false,
+			availableModulesToBeMerged: [],
+			skippedItems: undefined,
+			resultingAvailableModules: undefined,
+			children: undefined,
+			availableSources: undefined,
+			availableChildren: undefined,
+			preOrderIndex: 0,
+			postOrderIndex: 0,
+			chunkLoading:
+				chunkGroup.options.chunkLoading !== undefined
+					? chunkGroup.options.chunkLoading !== false
+					: compilation.outputOptions.chunkLoading !== false,
+			asyncChunks:
+				chunkGroup.options.asyncChunks !== undefined
+					? chunkGroup.options.asyncChunks
+					: compilation.outputOptions.asyncChunks !== false
+		};
+		chunkGroup.index = nextChunkGroupIndex++;
+		if (chunkGroup.getNumberOfParents() > 0) {
+			// minAvailableModules for child entrypoints are unknown yet, set to undefined.
+			// This means no module is added until other sets are merged into
+			// this minAvailableModules (by the parent entrypoints)
+			const skippedItems = new Set();
+			for (const module of modules) {
+				skippedItems.add(module);
+			}
+			chunkGroupInfo.skippedItems = skippedItems;
+			chunkGroupsForCombining.add(chunkGroupInfo);
+		} else {
+			// The application may start here: We start with an empty list of available modules
+			chunkGroupInfo.minAvailableModules = EMPTY_SET;
+			const chunk = chunkGroup.getEntrypointChunk();
+			for (const module of modules) {
+				queue.push({
+					action: ADD_AND_ENTER_MODULE,
+					block: module,
+					module,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
+			}
+		}
+		chunkGroupInfoMap.set(chunkGroup, chunkGroupInfo);
+		if (chunkGroup.name) {
+			namedChunkGroups.set(chunkGroup.name, chunkGroupInfo);
+		}
 	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported id
-	 */
-	getIds(moduleGraph) {
-		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	// Fill availableSources with parent-child dependencies between entrypoints
+	for (const chunkGroupInfo of chunkGroupsForCombining) {
+		const { chunkGroup } = chunkGroupInfo;
+		chunkGroupInfo.availableSources = new Set();
+		for (const parent of chunkGroup.parentsIterable) {
+			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
+			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
+			if (parentChunkGroupInfo.availableChildren === undefined) {
+				parentChunkGroupInfo.availableChildren = new Set();
+			}
+			parentChunkGroupInfo.availableChildren.add(chunkGroupInfo);
+		}
 	}
+	// pop() is used to read from the queue
+	// so it need to be reversed to be iterated in
+	// correct order
+	queue.reverse();
+
+	/** @type {Set<ChunkGroupInfo>} */
+	const outdatedChunkGroupInfo = new Set();
+	/** @type {Set<ChunkGroupInfo>} */
+	const chunkGroupsForMerging = new Set();
+	/** @type {QueueItem[]} */
+	let queueDelayed = [];
+
+	/** @type {[Module, ConnectionState][]} */
+	const skipConnectionBuffer = [];
+	/** @type {Module[]} */
+	const skipBuffer = [];
+	/** @type {QueueItem[]} */
+	const queueBuffer = [];
+
+	/** @type {Module} */
+	let module;
+	/** @type {Chunk} */
+	let chunk;
+	/** @type {ChunkGroup} */
+	let chunkGroup;
+	/** @type {DependenciesBlock} */
+	let block;
+	/** @type {ChunkGroupInfo} */
+	let chunkGroupInfo;
 
+	// For each async Block in graph
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
+	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
 	 * @returns {void}
 	 */
-	setIds(moduleGraph, ids) {
-		moduleGraph.getMeta(this)[idsSymbol] = ids;
-	}
+	const iteratorBlock = b => {
+		// 1. We create a chunk group with single chunk in it for this Block
+		// but only once (blockChunkGroups map)
+		let cgi = blockChunkGroups.get(b);
+		/** @type {ChunkGroup} */
+		let c;
+		/** @type {Entrypoint} */
+		let entrypoint;
+		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
+		if (cgi === undefined) {
+			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
+			if (entryOptions) {
+				cgi = namedAsyncEntrypoints.get(chunkName);
+				if (!cgi) {
+					entrypoint = compilation.addAsyncEntrypoint(
+						entryOptions,
+						module,
+						b.loc,
+						b.request
+					);
+					entrypoint.index = nextChunkGroupIndex++;
+					cgi = {
+						chunkGroup: entrypoint,
+						runtime: entrypoint.options.runtime || entrypoint.name,
+						minAvailableModules: EMPTY_SET,
+						minAvailableModulesOwned: false,
+						availableModulesToBeMerged: [],
+						skippedItems: undefined,
+						resultingAvailableModules: undefined,
+						children: undefined,
+						availableSources: undefined,
+						availableChildren: undefined,
+						preOrderIndex: 0,
+						postOrderIndex: 0,
+						chunkLoading:
+							entryOptions.chunkLoading !== undefined
+								? entryOptions.chunkLoading !== false
+								: chunkGroupInfo.chunkLoading,
+						asyncChunks:
+							entryOptions.asyncChunks !== undefined
+								? entryOptions.asyncChunks
+								: chunkGroupInfo.asyncChunks
+					};
+					chunkGroupInfoMap.set(entrypoint, cgi);
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		const ids = this.getIds(moduleGraph);
-		const getFullResult = () => {
-			if (ids.length === 0) {
-				return Dependency.EXPORTS_OBJECT_REFERENCED;
+					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
+					if (chunkName) {
+						namedAsyncEntrypoints.set(chunkName, cgi);
+					}
+				} else {
+					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
+					// TODO merge entryOptions
+					entrypoint.addOrigin(module, b.loc, b.request);
+					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
+				}
+
+				// 2. We enqueue the DependenciesBlock for traversal
+				queueDelayed.push({
+					action: PROCESS_ENTRY_BLOCK,
+					block: b,
+					module: module,
+					chunk: entrypoint.chunks[0],
+					chunkGroup: entrypoint,
+					chunkGroupInfo: cgi
+				});
+			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
+				// Just queue the block into the current chunk group
+				queue.push({
+					action: PROCESS_BLOCK,
+					block: b,
+					module: module,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
 			} else {
-				return [
-					{
-						name: ids,
-						canMangle: false
+				cgi = chunkName && namedChunkGroups.get(chunkName);
+				if (!cgi) {
+					c = compilation.addChunkInGroup(
+						b.groupOptions || b.chunkName,
+						module,
+						b.loc,
+						b.request
+					);
+					c.index = nextChunkGroupIndex++;
+					cgi = {
+						chunkGroup: c,
+						runtime: chunkGroupInfo.runtime,
+						minAvailableModules: undefined,
+						minAvailableModulesOwned: undefined,
+						availableModulesToBeMerged: [],
+						skippedItems: undefined,
+						resultingAvailableModules: undefined,
+						children: undefined,
+						availableSources: undefined,
+						availableChildren: undefined,
+						preOrderIndex: 0,
+						postOrderIndex: 0,
+						chunkLoading: chunkGroupInfo.chunkLoading,
+						asyncChunks: chunkGroupInfo.asyncChunks
+					};
+					allCreatedChunkGroups.add(c);
+					chunkGroupInfoMap.set(c, cgi);
+					if (chunkName) {
+						namedChunkGroups.set(chunkName, cgi);
 					}
-				];
+				} else {
+					c = cgi.chunkGroup;
+					if (c.isInitial()) {
+						compilation.errors.push(
+							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
+						);
+						c = chunkGroup;
+					}
+					c.addOptions(b.groupOptions);
+					c.addOrigin(module, b.loc, b.request);
+				}
+				blockConnections.set(b, []);
 			}
-		};
-		if (this.resultUsed) return getFullResult();
-		let exportsInfo = moduleGraph.getExportsInfo(
-			moduleGraph.getParentModule(this)
-		);
-		for (const name of this.names) {
-			const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-			const used = exportInfo.getUsed(runtime);
-			if (used === UsageState.Unused) return Dependency.NO_EXPORTS_REFERENCED;
-			if (used !== UsageState.OnlyPropertiesUsed) return getFullResult();
-			exportsInfo = exportInfo.exportsInfo;
-			if (!exportsInfo) return getFullResult();
-		}
-		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
-			return getFullResult();
-		}
-		/** @type {string[][]} */
-		const referencedExports = [];
-		for (const exportInfo of exportsInfo.orderedExports) {
-			processExportInfo(
-				runtime,
-				referencedExports,
-				ids.concat(exportInfo.name),
-				exportInfo,
-				false
-			);
+			blockChunkGroups.set(b, cgi);
+		} else if (entryOptions) {
+			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
+		} else {
+			c = cgi.chunkGroup;
 		}
-		return referencedExports.map(name => ({
-			name,
-			canMangle: false
-		}));
-	}
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		const ids = this.getIds(moduleGraph);
-		if (this.names.length === 1) {
-			const name = this.names[0];
-			const from = moduleGraph.getConnection(this);
-			if (!from) return;
-			return {
-				exports: [
-					{
-						name,
-						from,
-						export: ids.length === 0 ? null : ids,
-						// we can't mangle names that are in an empty object
-						// because one could access the prototype property
-						// when export isn't set yet
-						canMangle: !(name in EMPTY_OBJECT) && false
-					}
-				],
-				dependencies: [from.module]
-			};
-		} else if (this.names.length > 0) {
-			const name = this.names[0];
-			return {
-				exports: [
-					{
-						name,
-						// we can't mangle names that are in an empty object
-						// because one could access the prototype property
-						// when export isn't set yet
-						canMangle: !(name in EMPTY_OBJECT) && false
-					}
-				],
-				dependencies: undefined
-			};
-		} else {
-			const from = moduleGraph.getConnection(this);
-			if (!from) return;
-			const reexportInfo = this.getStarReexports(
-				moduleGraph,
-				undefined,
-				from.module
-			);
-			if (reexportInfo) {
-				return {
-					exports: Array.from(reexportInfo.exports, name => {
-						return {
-							name,
-							from,
-							export: ids.concat(name),
-							canMangle: !(name in EMPTY_OBJECT) && false
-						};
-					}),
-					// TODO handle deep reexports
-					dependencies: [from.module]
-				};
-			} else {
-				return {
-					exports: true,
-					from: ids.length === 0 ? from : undefined,
-					canMangle: false,
-					dependencies: [from.module]
-				};
+		if (c !== undefined) {
+			// 2. We store the connection for the block
+			// to connect it later if needed
+			blockConnections.get(b).push({
+				originChunkGroupInfo: chunkGroupInfo,
+				chunkGroup: c
+			});
+
+			// 3. We enqueue the chunk group info creation/updating
+			let connectList = queueConnect.get(chunkGroupInfo);
+			if (connectList === undefined) {
+				connectList = new Set();
+				queueConnect.set(chunkGroupInfo, connectList);
 			}
+			connectList.add(cgi);
+
+			// TODO check if this really need to be done for each traversal
+			// or if it is enough when it's queued when created
+			// 4. We enqueue the DependenciesBlock for traversal
+			queueDelayed.push({
+				action: PROCESS_BLOCK,
+				block: b,
+				module: module,
+				chunk: c.chunks[0],
+				chunkGroup: c,
+				chunkGroupInfo: cgi
+			});
+		} else if (entrypoint !== undefined) {
+			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
 		}
-	}
+	};
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Module} importedModule the imported module (optional)
-	 * @returns {{exports?: Set<string>, checked?: Set<string>}} information
+	 * @param {DependenciesBlock} block the block
+	 * @returns {void}
 	 */
-	getStarReexports(
-		moduleGraph,
-		runtime,
-		importedModule = moduleGraph.getModule(this)
-	) {
-		let importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
-		const ids = this.getIds(moduleGraph);
-		if (ids.length > 0)
-			importedExportsInfo = importedExportsInfo.getNestedExportsInfo(ids);
-		let exportsInfo = moduleGraph.getExportsInfo(
-			moduleGraph.getParentModule(this)
-		);
-		if (this.names.length > 0)
-			exportsInfo = exportsInfo.getNestedExportsInfo(this.names);
+	const processBlock = block => {
+		statProcessedBlocks++;
+		// get prepared block info
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
-		const noExtraExports =
-			importedExportsInfo &&
-			importedExportsInfo.otherExportsInfo.provided === false;
-		const noExtraImports =
-			exportsInfo &&
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
+		if (blockModules !== undefined) {
+			const { minAvailableModules } = chunkGroupInfo;
+			// Buffer items because order need to be reversed to get indices correct
+			// Traverse all referenced modules
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
+					// skip early if already connected
+					continue;
+				}
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
+				if (activeState !== true) {
+					skipConnectionBuffer.push([refModule, activeState]);
+					if (activeState === false) continue;
+				}
+				if (
+					activeState === true &&
+					(minAvailableModules.has(refModule) ||
+						minAvailableModules.plus.has(refModule))
+				) {
+					// already in parent chunks, skip it for now
+					skipBuffer.push(refModule);
+					continue;
+				}
+				// enqueue, then add and enter to be in the correct order
+				// this is relevant with circular dependencies
+				queueBuffer.push({
+					action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
+					block: refModule,
+					module: refModule,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
+			}
+			// Add buffered items in reverse order
+			if (skipConnectionBuffer.length > 0) {
+				let { skippedModuleConnections } = chunkGroupInfo;
+				if (skippedModuleConnections === undefined) {
+					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections =
+						new Set();
+				}
+				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
+					skippedModuleConnections.add(skipConnectionBuffer[i]);
+				}
+				skipConnectionBuffer.length = 0;
+			}
+			if (skipBuffer.length > 0) {
+				let { skippedItems } = chunkGroupInfo;
+				if (skippedItems === undefined) {
+					chunkGroupInfo.skippedItems = skippedItems = new Set();
+				}
+				for (let i = skipBuffer.length - 1; i >= 0; i--) {
+					skippedItems.add(skipBuffer[i]);
+				}
+				skipBuffer.length = 0;
+			}
+			if (queueBuffer.length > 0) {
+				for (let i = queueBuffer.length - 1; i >= 0; i--) {
+					queue.push(queueBuffer[i]);
+				}
+				queueBuffer.length = 0;
+			}
+		}
 
-		if (!noExtraExports && !noExtraImports) {
-			return;
+		// Traverse all Blocks
+		for (const b of block.blocks) {
+			iteratorBlock(b);
 		}
 
-		const isNamespaceImport =
-			importedModule.getExportsType(moduleGraph, false) === "namespace";
+		if (block.blocks.length > 0 && module !== block) {
+			blocksWithNestedBlocks.add(block);
+		}
+	};
 
-		/** @type {Set<string>} */
-		const exports = new Set();
-		/** @type {Set<string>} */
-		const checked = new Set();
+	/**
+	 * @param {DependenciesBlock} block the block
+	 * @returns {void}
+	 */
+	const processEntryBlock = block => {
+		statProcessedBlocks++;
+		// get prepared block info
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
-		if (noExtraImports) {
-			for (const exportInfo of exportsInfo.orderedExports) {
-				const name = exportInfo.name;
-				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				if (name === "__esModule" && isNamespaceImport) {
-					exports.add(name);
-				} else if (importedExportsInfo) {
-					const importedExportInfo =
-						importedExportsInfo.getReadOnlyExportInfo(name);
-					if (importedExportInfo.provided === false) continue;
-					exports.add(name);
-					if (importedExportInfo.provided === true) continue;
-					checked.add(name);
-				} else {
-					exports.add(name);
-					checked.add(name);
-				}
+		if (blockModules !== undefined) {
+			// Traverse all referenced modules
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
+				// enqueue, then add and enter to be in the correct order
+				// this is relevant with circular dependencies
+				queueBuffer.push({
+					action:
+						activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK,
+					block: refModule,
+					module: refModule,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
 			}
-		} else if (noExtraExports) {
-			for (const importedExportInfo of importedExportsInfo.orderedExports) {
-				const name = importedExportInfo.name;
-				if (importedExportInfo.provided === false) continue;
-				if (exportsInfo) {
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-					if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+			// Add buffered items in reverse order
+			if (queueBuffer.length > 0) {
+				for (let i = queueBuffer.length - 1; i >= 0; i--) {
+					queue.push(queueBuffer[i]);
 				}
-				exports.add(name);
-				if (importedExportInfo.provided === true) continue;
-				checked.add(name);
-			}
-			if (isNamespaceImport) {
-				exports.add("__esModule");
-				checked.delete("__esModule");
+				queueBuffer.length = 0;
 			}
 		}
 
-		return { exports, checked };
-	}
+		// Traverse all Blocks
+		for (const b of block.blocks) {
+			iteratorBlock(b);
+		}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.asiSafe);
-		write(this.range);
-		write(this.valueRange);
-		write(this.base);
-		write(this.names);
-		write(this.ids);
-		write(this.resultUsed);
-		super.serialize(context);
-	}
+		if (block.blocks.length > 0 && module !== block) {
+			blocksWithNestedBlocks.add(block);
+		}
+	};
 
-	deserialize(context) {
-		const { read } = context;
-		this.asiSafe = read();
-		this.range = read();
-		this.valueRange = read();
-		this.base = read();
-		this.names = read();
-		this.ids = read();
-		this.resultUsed = read();
-		super.deserialize(context);
-	}
-}
+	const processQueue = () => {
+		while (queue.length) {
+			statProcessedQueueItems++;
+			const queueItem = queue.pop();
+			module = queueItem.module;
+			block = queueItem.block;
+			chunk = queueItem.chunk;
+			chunkGroup = queueItem.chunkGroup;
+			chunkGroupInfo = queueItem.chunkGroupInfo;
 
-makeSerializable(
-	CommonJsExportRequireDependency,
-	"webpack/lib/dependencies/CommonJsExportRequireDependency"
-);
+			switch (queueItem.action) {
+				case ADD_AND_ENTER_ENTRY_MODULE:
+					chunkGraph.connectChunkAndEntryModule(
+						chunk,
+						module,
+						/** @type {Entrypoint} */ (chunkGroup)
+					);
+				// fallthrough
+				case ADD_AND_ENTER_MODULE: {
+					if (chunkGraph.isModuleInChunk(module, chunk)) {
+						// already connected, skip it
+						break;
+					}
+					// We connect Module and Chunk
+					chunkGraph.connectChunkAndModule(chunk, module);
+				}
+				// fallthrough
+				case ENTER_MODULE: {
+					const index = chunkGroup.getModulePreOrderIndex(module);
+					if (index === undefined) {
+						chunkGroup.setModulePreOrderIndex(
+							module,
+							chunkGroupInfo.preOrderIndex++
+						);
+					}
 
-CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			runtimeTemplate,
-			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
-			runtime
-		}
-	) {
-		const dep = /** @type {CommonJsExportRequireDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportsInfo(module)
-			.getUsedName(dep.names, runtime);
+					if (
+						moduleGraph.setPreOrderIndexIfUnset(
+							module,
+							nextFreeModulePreOrderIndex
+						)
+					) {
+						nextFreeModulePreOrderIndex++;
+					}
 
-		const [type, base] = handleDependencyBase(
-			dep.base,
-			module,
-			runtimeRequirements
-		);
+					// reuse queueItem
+					queueItem.action = LEAVE_MODULE;
+					queue.push(queueItem);
+				}
+				// fallthrough
+				case PROCESS_BLOCK: {
+					processBlock(block);
+					break;
+				}
+				case PROCESS_ENTRY_BLOCK: {
+					processEntryBlock(block);
+					break;
+				}
+				case LEAVE_MODULE: {
+					const index = chunkGroup.getModulePostOrderIndex(module);
+					if (index === undefined) {
+						chunkGroup.setModulePostOrderIndex(
+							module,
+							chunkGroupInfo.postOrderIndex++
+						);
+					}
 
-		const importedModule = moduleGraph.getModule(dep);
-		let requireExpr = runtimeTemplate.moduleExports({
-			module: importedModule,
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-		if (importedModule) {
-			const ids = dep.getIds(moduleGraph);
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(ids, runtime);
-			if (usedImported) {
-				const comment = equals(usedImported, ids)
-					? ""
-					: Template.toNormalComment(propertyAccess(ids)) + " ";
-				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+					if (
+						moduleGraph.setPostOrderIndexIfUnset(
+							module,
+							nextFreeModulePostOrderIndex
+						)
+					) {
+						nextFreeModulePostOrderIndex++;
+					}
+					break;
+				}
 			}
 		}
+	};
 
-		switch (type) {
-			case "expression":
-				source.replace(
-					dep.range[0],
-					dep.range[1] - 1,
-					used
-						? `${base}${propertyAccess(used)} = ${requireExpr}`
-						: `/* unused reexport */ ${requireExpr}`
+	const calculateResultingAvailableModules = chunkGroupInfo => {
+		if (chunkGroupInfo.resultingAvailableModules)
+			return chunkGroupInfo.resultingAvailableModules;
+
+		const minAvailableModules = chunkGroupInfo.minAvailableModules;
+
+		// Create a new Set of available modules at this point
+		// We want to be as lazy as possible. There are multiple ways doing this:
+		// Note that resultingAvailableModules is stored as "(a) + (b)" as it's a ModuleSetPlus
+		// - resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
+		// - resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
+		// We choose one depending on the size of minAvailableModules vs minAvailableModules.plus
+
+		let resultingAvailableModules;
+		if (minAvailableModules.size > minAvailableModules.plus.size) {
+			// resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
+			resultingAvailableModules =
+				/** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
+			for (const module of minAvailableModules.plus)
+				minAvailableModules.add(module);
+			minAvailableModules.plus = EMPTY_SET;
+			resultingAvailableModules.plus = minAvailableModules;
+			chunkGroupInfo.minAvailableModulesOwned = false;
+		} else {
+			// resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
+			resultingAvailableModules =
+				/** @type {Set<Module> & {plus: Set<Module>}} */ (
+					new Set(minAvailableModules)
 				);
-				return;
-			case "Object.defineProperty":
-				throw new Error("TODO");
-			default:
-				throw new Error("Unexpected type");
+			resultingAvailableModules.plus = minAvailableModules.plus;
 		}
-	}
-};
-
-module.exports = CommonJsExportRequireDependency;
 
+		// add the modules from the chunk group to the set
+		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
+			for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+				resultingAvailableModules.add(m);
+			}
+		}
+		return (chunkGroupInfo.resultingAvailableModules =
+			resultingAvailableModules);
+	};
 
-/***/ }),
-
-/***/ 45598:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	const processConnectQueue = () => {
+		// Figure out new parents for chunk groups
+		// to get new available modules for these children
+		for (const [chunkGroupInfo, targets] of queueConnect) {
+			// 1. Add new targets to the list of children
+			if (chunkGroupInfo.children === undefined) {
+				chunkGroupInfo.children = targets;
+			} else {
+				for (const target of targets) {
+					chunkGroupInfo.children.add(target);
+				}
+			}
 
+			// 2. Calculate resulting available modules
+			const resultingAvailableModules =
+				calculateResultingAvailableModules(chunkGroupInfo);
 
+			const runtime = chunkGroupInfo.runtime;
 
-const InitFragment = __webpack_require__(55870);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { handleDependencyBase } = __webpack_require__(59643);
-const NullDependency = __webpack_require__(31830);
+			// 3. Update chunk group info
+			for (const target of targets) {
+				target.availableModulesToBeMerged.push(resultingAvailableModules);
+				chunkGroupsForMerging.add(target);
+				const oldRuntime = target.runtime;
+				const newRuntime = mergeRuntime(oldRuntime, runtime);
+				if (oldRuntime !== newRuntime) {
+					target.runtime = newRuntime;
+					outdatedChunkGroupInfo.add(target);
+				}
+			}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+			statConnectedChunkGroups += targets.size;
+		}
+		queueConnect.clear();
+	};
 
-const EMPTY_OBJECT = {};
+	const processChunkGroupsForMerging = () => {
+		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
-class CommonJsExportsDependency extends NullDependency {
-	constructor(range, valueRange, base, names) {
-		super();
-		this.range = range;
-		this.valueRange = valueRange;
-		this.base = base;
-		this.names = names;
-	}
+		// Execute the merge
+		for (const info of chunkGroupsForMerging) {
+			const availableModulesToBeMerged = info.availableModulesToBeMerged;
+			let cachedMinAvailableModules = info.minAvailableModules;
 
-	get type() {
-		return "cjs exports";
-	}
+			statMergedAvailableModuleSets += availableModulesToBeMerged.length;
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		const name = this.names[0];
-		return {
-			exports: [
-				{
-					name,
-					// we can't mangle names that are in an empty object
-					// because one could access the prototype property
-					// when export isn't set yet
-					canMangle: !(name in EMPTY_OBJECT)
+			// 1. Get minimal available modules
+			// It doesn't make sense to traverse a chunk again with more available modules.
+			// This step calculates the minimal available modules and skips traversal when
+			// the list didn't shrink.
+			if (availableModulesToBeMerged.length > 1) {
+				availableModulesToBeMerged.sort(bySetSize);
+			}
+			let changed = false;
+			merge: for (const availableModules of availableModulesToBeMerged) {
+				if (cachedMinAvailableModules === undefined) {
+					cachedMinAvailableModules = availableModules;
+					info.minAvailableModules = cachedMinAvailableModules;
+					info.minAvailableModulesOwned = false;
+					changed = true;
+				} else {
+					if (info.minAvailableModulesOwned) {
+						// We own it and can modify it
+						if (cachedMinAvailableModules.plus === availableModules.plus) {
+							for (const m of cachedMinAvailableModules) {
+								if (!availableModules.has(m)) {
+									cachedMinAvailableModules.delete(m);
+									changed = true;
+								}
+							}
+						} else {
+							for (const m of cachedMinAvailableModules) {
+								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+									cachedMinAvailableModules.delete(m);
+									changed = true;
+								}
+							}
+							for (const m of cachedMinAvailableModules.plus) {
+								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+									// We can't remove modules from the plus part
+									// so we need to merge plus into the normal part to allow modifying it
+									const iterator =
+										cachedMinAvailableModules.plus[Symbol.iterator]();
+									// fast forward add all modules until m
+									/** @type {IteratorResult<Module>} */
+									let it;
+									while (!(it = iterator.next()).done) {
+										const module = it.value;
+										if (module === m) break;
+										cachedMinAvailableModules.add(module);
+									}
+									// check the remaining modules before adding
+									while (!(it = iterator.next()).done) {
+										const module = it.value;
+										if (
+											availableModules.has(module) ||
+											availableModules.plus.has(m)
+										) {
+											cachedMinAvailableModules.add(module);
+										}
+									}
+									cachedMinAvailableModules.plus = EMPTY_SET;
+									changed = true;
+									continue merge;
+								}
+							}
+						}
+					} else if (cachedMinAvailableModules.plus === availableModules.plus) {
+						// Common and fast case when the plus part is shared
+						// We only need to care about the normal part
+						if (availableModules.size < cachedMinAvailableModules.size) {
+							// the new availableModules is smaller so it's faster to
+							// fork from the new availableModules
+							statForkedAvailableModules++;
+							statForkedAvailableModulesCount += availableModules.size;
+							statForkedMergedModulesCount += cachedMinAvailableModules.size;
+							// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+							const newSet = /** @type {ModuleSetPlus} */ (new Set());
+							newSet.plus = availableModules.plus;
+							for (const m of availableModules) {
+								if (cachedMinAvailableModules.has(m)) {
+									newSet.add(m);
+								}
+							}
+							statForkedResultModulesCount += newSet.size;
+							cachedMinAvailableModules = newSet;
+							info.minAvailableModulesOwned = true;
+							info.minAvailableModules = newSet;
+							changed = true;
+							continue merge;
+						}
+						for (const m of cachedMinAvailableModules) {
+							if (!availableModules.has(m)) {
+								// cachedMinAvailableModules need to be modified
+								// but we don't own it
+								statForkedAvailableModules++;
+								statForkedAvailableModulesCount +=
+									cachedMinAvailableModules.size;
+								statForkedMergedModulesCount += availableModules.size;
+								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+								// as the plus part is equal we can just take over this one
+								const newSet = /** @type {ModuleSetPlus} */ (new Set());
+								newSet.plus = availableModules.plus;
+								const iterator = cachedMinAvailableModules[Symbol.iterator]();
+								// fast forward add all modules until m
+								/** @type {IteratorResult<Module>} */
+								let it;
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (module === m) break;
+									newSet.add(module);
+								}
+								// check the remaining modules before adding
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (availableModules.has(module)) {
+										newSet.add(module);
+									}
+								}
+								statForkedResultModulesCount += newSet.size;
+								cachedMinAvailableModules = newSet;
+								info.minAvailableModulesOwned = true;
+								info.minAvailableModules = newSet;
+								changed = true;
+								continue merge;
+							}
+						}
+					} else {
+						for (const m of cachedMinAvailableModules) {
+							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+								// cachedMinAvailableModules need to be modified
+								// but we don't own it
+								statForkedAvailableModules++;
+								statForkedAvailableModulesCount +=
+									cachedMinAvailableModules.size;
+								statForkedAvailableModulesCountPlus +=
+									cachedMinAvailableModules.plus.size;
+								statForkedMergedModulesCount += availableModules.size;
+								statForkedMergedModulesCountPlus += availableModules.plus.size;
+								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+								const newSet = /** @type {ModuleSetPlus} */ (new Set());
+								newSet.plus = EMPTY_SET;
+								const iterator = cachedMinAvailableModules[Symbol.iterator]();
+								// fast forward add all modules until m
+								/** @type {IteratorResult<Module>} */
+								let it;
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (module === m) break;
+									newSet.add(module);
+								}
+								// check the remaining modules before adding
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (
+										availableModules.has(module) ||
+										availableModules.plus.has(module)
+									) {
+										newSet.add(module);
+									}
+								}
+								// also check all modules in cachedMinAvailableModules.plus
+								for (const module of cachedMinAvailableModules.plus) {
+									if (
+										availableModules.has(module) ||
+										availableModules.plus.has(module)
+									) {
+										newSet.add(module);
+									}
+								}
+								statForkedResultModulesCount += newSet.size;
+								cachedMinAvailableModules = newSet;
+								info.minAvailableModulesOwned = true;
+								info.minAvailableModules = newSet;
+								changed = true;
+								continue merge;
+							}
+						}
+						for (const m of cachedMinAvailableModules.plus) {
+							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+								// cachedMinAvailableModules need to be modified
+								// but we don't own it
+								statForkedAvailableModules++;
+								statForkedAvailableModulesCount +=
+									cachedMinAvailableModules.size;
+								statForkedAvailableModulesCountPlus +=
+									cachedMinAvailableModules.plus.size;
+								statForkedMergedModulesCount += availableModules.size;
+								statForkedMergedModulesCountPlus += availableModules.plus.size;
+								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+								// we already know that all modules directly from cachedMinAvailableModules are in availableModules too
+								const newSet = /** @type {ModuleSetPlus} */ (
+									new Set(cachedMinAvailableModules)
+								);
+								newSet.plus = EMPTY_SET;
+								const iterator =
+									cachedMinAvailableModules.plus[Symbol.iterator]();
+								// fast forward add all modules until m
+								/** @type {IteratorResult<Module>} */
+								let it;
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (module === m) break;
+									newSet.add(module);
+								}
+								// check the remaining modules before adding
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (
+										availableModules.has(module) ||
+										availableModules.plus.has(module)
+									) {
+										newSet.add(module);
+									}
+								}
+								statForkedResultModulesCount += newSet.size;
+								cachedMinAvailableModules = newSet;
+								info.minAvailableModulesOwned = true;
+								info.minAvailableModules = newSet;
+								changed = true;
+								continue merge;
+							}
+						}
+					}
 				}
-			],
-			dependencies: undefined
-		};
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.valueRange);
-		write(this.base);
-		write(this.names);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.valueRange = read();
-		this.base = read();
-		this.names = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	CommonJsExportsDependency,
-	"webpack/lib/dependencies/CommonJsExportsDependency"
-);
+			}
+			availableModulesToBeMerged.length = 0;
+			if (changed) {
+				info.resultingAvailableModules = undefined;
+				outdatedChunkGroupInfo.add(info);
+			}
+		}
+		chunkGroupsForMerging.clear();
+	};
 
-CommonJsExportsDependency.Template = class CommonJsExportsDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, initFragments, runtimeRequirements, runtime }
-	) {
-		const dep = /** @type {CommonJsExportsDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportsInfo(module)
-			.getUsedName(dep.names, runtime);
+	const processChunkGroupsForCombining = () => {
+		for (const info of chunkGroupsForCombining) {
+			for (const source of info.availableSources) {
+				if (!source.minAvailableModules) {
+					chunkGroupsForCombining.delete(info);
+					break;
+				}
+			}
+		}
+		for (const info of chunkGroupsForCombining) {
+			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
+			availableModules.plus = EMPTY_SET;
+			const mergeSet = set => {
+				if (set.size > availableModules.plus.size) {
+					for (const item of availableModules.plus) availableModules.add(item);
+					availableModules.plus = set;
+				} else {
+					for (const item of set) availableModules.add(item);
+				}
+			};
+			// combine minAvailableModules from all resultingAvailableModules
+			for (const source of info.availableSources) {
+				const resultingAvailableModules =
+					calculateResultingAvailableModules(source);
+				mergeSet(resultingAvailableModules);
+				mergeSet(resultingAvailableModules.plus);
+			}
+			info.minAvailableModules = availableModules;
+			info.minAvailableModulesOwned = false;
+			info.resultingAvailableModules = undefined;
+			outdatedChunkGroupInfo.add(info);
+		}
+		chunkGroupsForCombining.clear();
+	};
 
-		const [type, base] = handleDependencyBase(
-			dep.base,
-			module,
-			runtimeRequirements
-		);
+	const processOutdatedChunkGroupInfo = () => {
+		statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
+		// Revisit skipped elements
+		for (const info of outdatedChunkGroupInfo) {
+			// 1. Reconsider skipped items
+			if (info.skippedItems !== undefined) {
+				const { minAvailableModules } = info;
+				for (const module of info.skippedItems) {
+					if (
+						!minAvailableModules.has(module) &&
+						!minAvailableModules.plus.has(module)
+					) {
+						queue.push({
+							action: ADD_AND_ENTER_MODULE,
+							block: module,
+							module,
+							chunk: info.chunkGroup.chunks[0],
+							chunkGroup: info.chunkGroup,
+							chunkGroupInfo: info
+						});
+						info.skippedItems.delete(module);
+					}
+				}
+			}
 
-		switch (type) {
-			case "expression":
-				if (!used) {
-					initFragments.push(
-						new InitFragment(
-							"var __webpack_unused_export__;\n",
-							InitFragment.STAGE_CONSTANTS,
-							0,
-							"__webpack_unused_export__"
-						)
-					);
-					source.replace(
-						dep.range[0],
-						dep.range[1] - 1,
-						"__webpack_unused_export__"
-					);
-					return;
+			// 2. Reconsider skipped connections
+			if (info.skippedModuleConnections !== undefined) {
+				const { minAvailableModules } = info;
+				for (const entry of info.skippedModuleConnections) {
+					const [module, activeState] = entry;
+					if (activeState === false) continue;
+					if (activeState === true) {
+						info.skippedModuleConnections.delete(entry);
+					}
+					if (
+						activeState === true &&
+						(minAvailableModules.has(module) ||
+							minAvailableModules.plus.has(module))
+					) {
+						info.skippedItems.add(module);
+						continue;
+					}
+					queue.push({
+						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
+						block: module,
+						module,
+						chunk: info.chunkGroup.chunks[0],
+						chunkGroup: info.chunkGroup,
+						chunkGroupInfo: info
+					});
 				}
-				source.replace(
-					dep.range[0],
-					dep.range[1] - 1,
-					`${base}${propertyAccess(used)}`
-				);
-				return;
-			case "Object.defineProperty":
-				if (!used) {
-					initFragments.push(
-						new InitFragment(
-							"var __webpack_unused_export__;\n",
-							InitFragment.STAGE_CONSTANTS,
-							0,
-							"__webpack_unused_export__"
-						)
-					);
-					source.replace(
-						dep.range[0],
-						dep.valueRange[0] - 1,
-						"__webpack_unused_export__ = ("
-					);
-					source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-					return;
+			}
+
+			// 2. Reconsider children chunk groups
+			if (info.children !== undefined) {
+				statChildChunkGroupsReconnected += info.children.size;
+				for (const cgi of info.children) {
+					let connectList = queueConnect.get(info);
+					if (connectList === undefined) {
+						connectList = new Set();
+						queueConnect.set(info, connectList);
+					}
+					connectList.add(cgi);
 				}
-				source.replace(
-					dep.range[0],
-					dep.valueRange[0] - 1,
-					`Object.defineProperty(${base}${propertyAccess(
-						used.slice(0, -1)
-					)}, ${JSON.stringify(used[used.length - 1])}, (`
-				);
-				source.replace(dep.valueRange[1], dep.range[1] - 1, "))");
-				return;
+			}
+
+			// 3. Reconsider chunk groups for combining
+			if (info.availableChildren !== undefined) {
+				for (const cgi of info.availableChildren) {
+					chunkGroupsForCombining.add(cgi);
+				}
+			}
 		}
-	}
-};
+		outdatedChunkGroupInfo.clear();
+	};
 
-module.exports = CommonJsExportsDependency;
+	// Iterative traversal of the Module graph
+	// Recursive would be simpler to write but could result in Stack Overflows
+	while (queue.length || queueConnect.size) {
+		logger.time("visitModules: visiting");
+		processQueue();
+		logger.timeAggregateEnd("visitModules: prepare");
+		logger.timeEnd("visitModules: visiting");
 
+		if (chunkGroupsForCombining.size > 0) {
+			logger.time("visitModules: combine available modules");
+			processChunkGroupsForCombining();
+			logger.timeEnd("visitModules: combine available modules");
+		}
 
-/***/ }),
+		if (queueConnect.size > 0) {
+			logger.time("visitModules: calculating available modules");
+			processConnectQueue();
+			logger.timeEnd("visitModules: calculating available modules");
 
-/***/ 97107:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			if (chunkGroupsForMerging.size > 0) {
+				logger.time("visitModules: merging available modules");
+				processChunkGroupsForMerging();
+				logger.timeEnd("visitModules: merging available modules");
+			}
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		if (outdatedChunkGroupInfo.size > 0) {
+			logger.time("visitModules: check modules for revisit");
+			processOutdatedChunkGroupInfo();
+			logger.timeEnd("visitModules: check modules for revisit");
+		}
 
+		// Run queueDelayed when all items of the queue are processed
+		// This is important to get the global indexing correct
+		// Async blocks should be processed after all sync blocks are processed
+		if (queue.length === 0) {
+			const tempQueue = queue;
+			queue = queueDelayed.reverse();
+			queueDelayed = tempQueue;
+		}
+	}
 
+	logger.log(
+		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
+	);
+	logger.log(`${statConnectedChunkGroups} chunk groups connected`);
+	logger.log(
+		`${statProcessedChunkGroupsForMerging} chunk groups processed for merging (${statMergedAvailableModuleSets} module sets, ${statForkedAvailableModules} forked, ${statForkedAvailableModulesCount} + ${statForkedAvailableModulesCountPlus} modules forked, ${statForkedMergedModulesCount} + ${statForkedMergedModulesCountPlus} modules merged into fork, ${statForkedResultModulesCount} resulting modules)`
+	);
+	logger.log(
+		`${statChunkGroupInfoUpdated} chunk group info updated (${statChildChunkGroupsReconnected} already connected chunk groups reconnected)`
+	);
+};
 
-const RuntimeGlobals = __webpack_require__(16475);
-const formatLocation = __webpack_require__(16734);
-const { evaluateToString } = __webpack_require__(93998);
-const propertyAccess = __webpack_require__(54190);
-const CommonJsExportRequireDependency = __webpack_require__(62892);
-const CommonJsExportsDependency = __webpack_require__(45598);
-const CommonJsSelfReferenceDependency = __webpack_require__(52225);
-const DynamicExports = __webpack_require__(32006);
-const HarmonyExports = __webpack_require__(39211);
-const ModuleDecoratorDependency = __webpack_require__(88488);
+/**
+ *
+ * @param {Compilation} compilation the compilation
+ * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
+ * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
+ */
+const connectChunkGroups = (
+	compilation,
+	blocksWithNestedBlocks,
+	blockConnections,
+	chunkGroupInfoMap
+) => {
+	const { chunkGraph } = compilation;
 
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+	/**
+	 * Helper function to check if all modules of a chunk are available
+	 *
+	 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
+	 * @param {ModuleSetPlus} availableModules the comparator set
+	 * @returns {boolean} return true if all modules of a chunk are available
+	 */
+	const areModulesAvailable = (chunkGroup, availableModules) => {
+		for (const chunk of chunkGroup.chunks) {
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!availableModules.has(module) && !availableModules.plus.has(module))
+					return false;
+			}
+		}
+		return true;
+	};
 
-const getValueOfPropertyDescription = expr => {
-	if (expr.type !== "ObjectExpression") return;
-	for (const property of expr.properties) {
-		if (property.computed) continue;
-		const key = property.key;
-		if (key.type !== "Identifier" || key.name !== "value") continue;
-		return property.value;
-	}
-};
+	// For each edge in the basic chunk graph
+	for (const [block, connections] of blockConnections) {
+		// 1. Check if connection is needed
+		// When none of the dependencies need to be connected
+		// we can skip all of them
+		// It's not possible to filter each item so it doesn't create inconsistent
+		// connections and modules can only create one version
+		// TODO maybe decide this per runtime
+		if (
+			// TODO is this needed?
+			!blocksWithNestedBlocks.has(block) &&
+			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
+				areModulesAvailable(
+					chunkGroup,
+					originChunkGroupInfo.resultingAvailableModules
+				)
+			)
+		) {
+			continue;
+		}
 
-const isTruthyLiteral = expr => {
-	switch (expr.type) {
-		case "Literal":
-			return !!expr.value;
-		case "UnaryExpression":
-			if (expr.operator === "!") return isFalsyLiteral(expr.argument);
-	}
-	return false;
-};
+		// 2. Foreach edge
+		for (let i = 0; i < connections.length; i++) {
+			const { chunkGroup, originChunkGroupInfo } = connections[i];
 
-const isFalsyLiteral = expr => {
-	switch (expr.type) {
-		case "Literal":
-			return !expr.value;
-		case "UnaryExpression":
-			if (expr.operator === "!") return isTruthyLiteral(expr.argument);
+			// 3. Connect block with chunk
+			chunkGraph.connectBlockAndChunkGroup(block, chunkGroup);
+
+			// 4. Connect chunk with parent
+			connectChunkGroupParentAndChild(
+				originChunkGroupInfo.chunkGroup,
+				chunkGroup
+			);
+		}
 	}
-	return false;
 };
 
 /**
- * @param {JavascriptParser} parser the parser
- * @param {ExpressionNode} expr expression
- * @returns {{ argument: BasicEvaluatedExpression, ids: string[] } | undefined} parsed call
+ * Remove all unconnected chunk groups
+ * @param {Compilation} compilation the compilation
+ * @param {Iterable<ChunkGroup>} allCreatedChunkGroups all chunk groups that where created before
  */
-const parseRequireCall = (parser, expr) => {
-	const ids = [];
-	while (expr.type === "MemberExpression") {
-		if (expr.object.type === "Super") return;
-		if (!expr.property) return;
-		const prop = expr.property;
-		if (expr.computed) {
-			if (prop.type !== "Literal") return;
-			ids.push(`${prop.value}`);
-		} else {
-			if (prop.type !== "Identifier") return;
-			ids.push(prop.name);
+const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
+	const { chunkGraph } = compilation;
+
+	for (const chunkGroup of allCreatedChunkGroups) {
+		if (chunkGroup.getNumberOfParents() === 0) {
+			for (const chunk of chunkGroup.chunks) {
+				compilation.chunks.delete(chunk);
+				chunkGraph.disconnectChunk(chunk);
+			}
+			chunkGraph.disconnectChunkGroup(chunkGroup);
+			chunkGroup.remove();
 		}
-		expr = expr.object;
-	}
-	if (expr.type !== "CallExpression" || expr.arguments.length !== 1) return;
-	const callee = expr.callee;
-	if (
-		callee.type !== "Identifier" ||
-		parser.getVariableInfo(callee.name) !== "require"
-	) {
-		return;
 	}
-	const arg = expr.arguments[0];
-	if (arg.type === "SpreadElement") return;
-	const argValue = parser.evaluateExpression(arg);
-	return { argument: argValue, ids: ids.reverse() };
 };
 
-class CommonJsExportsParserPlugin {
-	constructor(moduleGraph) {
-		this.moduleGraph = moduleGraph;
-	}
+/**
+ * This method creates the Chunk graph from the Module graph
+ * @param {Compilation} compilation the compilation
+ * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @returns {void}
+ */
+const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
+	const logger = compilation.getLogger("webpack.buildChunkGraph");
 
-	/**
-	 * @param {JavascriptParser} parser the parser
-	 */
-	apply(parser) {
-		const enableStructuredExports = () => {
-			DynamicExports.enable(parser.state);
-		};
-		const checkNamespace = (topLevel, members, valueExpr) => {
-			if (!DynamicExports.isEnabled(parser.state)) return;
-			if (members.length > 0 && members[0] === "__esModule") {
-				if (valueExpr && isTruthyLiteral(valueExpr) && topLevel) {
-					DynamicExports.setFlagged(parser.state);
-				} else {
-					DynamicExports.setDynamic(parser.state);
-				}
-			}
-		};
-		const bailout = reason => {
-			DynamicExports.bailout(parser.state);
-			if (reason) bailoutHint(reason);
-		};
-		const bailoutHint = reason => {
-			this.moduleGraph
-				.getOptimizationBailout(parser.state.module)
-				.push(`CommonJS bailout: ${reason}`);
-		};
+	// SHARED STATE
 
-		// metadata //
-		parser.hooks.evaluateTypeof
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", evaluateToString("object"));
-		parser.hooks.evaluateTypeof
-			.for("exports")
-			.tap("CommonJsPlugin", evaluateToString("object"));
+	/** @type {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} */
+	const blockConnections = new Map();
 
-		// exporting //
-		const handleAssignExport = (expr, base, members) => {
-			if (HarmonyExports.isEnabled(parser.state)) return;
-			// Handle reexporting
-			const requireCall = parseRequireCall(parser, expr.right);
-			if (
-				requireCall &&
-				requireCall.argument.isString() &&
-				(members.length === 0 || members[0] !== "__esModule")
-			) {
-				enableStructuredExports();
-				// It's possible to reexport __esModule, so we must convert to a dynamic module
-				if (members.length === 0) DynamicExports.setDynamic(parser.state);
-				const dep = new CommonJsExportRequireDependency(
-					expr.range,
-					null,
-					base,
-					members,
-					requireCall.argument.string,
-					requireCall.ids,
-					!parser.isStatementLevelExpression(expr)
-				);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.module.addDependency(dep);
-				return true;
-			}
-			if (members.length === 0) return;
-			enableStructuredExports();
-			const remainingMembers = members;
-			checkNamespace(
-				parser.statementPath.length === 1 &&
-					parser.isStatementLevelExpression(expr),
-				remainingMembers,
-				expr.right
-			);
-			const dep = new CommonJsExportsDependency(
-				expr.left.range,
-				null,
-				base,
-				remainingMembers
-			);
-			dep.loc = expr.loc;
-			parser.state.module.addDependency(dep);
-			parser.walkExpression(expr.right);
-			return true;
-		};
-		parser.hooks.assignMemberChain
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				return handleAssignExport(expr, "exports", members);
-			});
-		parser.hooks.assignMemberChain
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAssignExport(expr, "this", members);
-			});
-		parser.hooks.assignMemberChain
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (members[0] !== "exports") return;
-				return handleAssignExport(expr, "module.exports", members.slice(1));
-			});
-		parser.hooks.call
-			.for("Object.defineProperty")
-			.tap("CommonJsExportsParserPlugin", expression => {
-				const expr = /** @type {import("estree").CallExpression} */ (
-					expression
-				);
-				if (!parser.isStatementLevelExpression(expr)) return;
-				if (expr.arguments.length !== 3) return;
-				if (expr.arguments[0].type === "SpreadElement") return;
-				if (expr.arguments[1].type === "SpreadElement") return;
-				if (expr.arguments[2].type === "SpreadElement") return;
-				const exportsArg = parser.evaluateExpression(expr.arguments[0]);
-				if (!exportsArg || !exportsArg.isIdentifier()) return;
-				if (
-					exportsArg.identifier !== "exports" &&
-					exportsArg.identifier !== "module.exports" &&
-					(exportsArg.identifier !== "this" || !parser.scope.topLevelScope)
-				) {
-					return;
-				}
-				const propertyArg = parser.evaluateExpression(expr.arguments[1]);
-				if (!propertyArg) return;
-				const property = propertyArg.asString();
-				if (typeof property !== "string") return;
-				enableStructuredExports();
-				const descArg = expr.arguments[2];
-				checkNamespace(
-					parser.statementPath.length === 1,
-					[property],
-					getValueOfPropertyDescription(descArg)
-				);
-				const dep = new CommonJsExportsDependency(
-					expr.range,
-					expr.arguments[2].range,
-					`Object.defineProperty(${exportsArg.identifier})`,
-					[property]
-				);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
+	/** @type {Set<ChunkGroup>} */
+	const allCreatedChunkGroups = new Set();
 
-				parser.walkExpression(expr.arguments[2]);
-				return true;
-			});
+	/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
+	const chunkGroupInfoMap = new Map();
 
-		// Self reference //
-		const handleAccessExport = (expr, base, members, call = undefined) => {
-			if (HarmonyExports.isEnabled(parser.state)) return;
-			if (members.length === 0) {
-				bailout(`${base} is used directly at ${formatLocation(expr.loc)}`);
-			}
-			if (call && members.length === 1) {
-				bailoutHint(
-					`${base}${propertyAccess(
-						members
-					)}(...) prevents optimization as ${base} is passed as call context at ${formatLocation(
-						expr.loc
-					)}`
-				);
-			}
-			const dep = new CommonJsSelfReferenceDependency(
-				expr.range,
-				base,
-				members,
-				!!call
-			);
-			dep.loc = expr.loc;
-			parser.state.module.addDependency(dep);
-			if (call) {
-				parser.walkExpressions(call.arguments);
-			}
-			return true;
-		};
-		parser.hooks.callMemberChain
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				return handleAccessExport(expr.callee, "exports", members, expr);
-			});
-		parser.hooks.expressionMemberChain
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				return handleAccessExport(expr, "exports", members);
-			});
-		parser.hooks.expression
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", expr => {
-				return handleAccessExport(expr, "exports", []);
-			});
-		parser.hooks.callMemberChain
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (members[0] !== "exports") return;
-				return handleAccessExport(
-					expr.callee,
-					"module.exports",
-					members.slice(1),
-					expr
-				);
-			});
-		parser.hooks.expressionMemberChain
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (members[0] !== "exports") return;
-				return handleAccessExport(expr, "module.exports", members.slice(1));
-			});
-		parser.hooks.expression
-			.for("module.exports")
-			.tap("CommonJsExportsParserPlugin", expr => {
-				return handleAccessExport(expr, "module.exports", []);
-			});
-		parser.hooks.callMemberChain
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr.callee, "this", members, expr);
-			});
-		parser.hooks.expressionMemberChain
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr, "this", members);
-			});
-		parser.hooks.expression
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", expr => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr, "this", []);
-			});
+	/** @type {Set<DependenciesBlock>} */
+	const blocksWithNestedBlocks = new Set();
 
-		// Bailouts //
-		parser.hooks.expression.for("module").tap("CommonJsPlugin", expr => {
-			bailout();
-			const isHarmony = HarmonyExports.isEnabled(parser.state);
-			const dep = new ModuleDecoratorDependency(
-				isHarmony
-					? RuntimeGlobals.harmonyModuleDecorator
-					: RuntimeGlobals.nodeModuleDecorator,
-				!isHarmony
-			);
-			dep.loc = expr.loc;
-			parser.state.module.addDependency(dep);
-			return true;
-		});
+	// PART ONE
+
+	logger.time("visitModules");
+	visitModules(
+		logger,
+		compilation,
+		inputEntrypointsAndModules,
+		chunkGroupInfoMap,
+		blockConnections,
+		blocksWithNestedBlocks,
+		allCreatedChunkGroups
+	);
+	logger.timeEnd("visitModules");
+
+	// PART TWO
+
+	logger.time("connectChunkGroups");
+	connectChunkGroups(
+		compilation,
+		blocksWithNestedBlocks,
+		blockConnections,
+		chunkGroupInfoMap
+	);
+	logger.timeEnd("connectChunkGroups");
+
+	for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
+		for (const chunk of chunkGroup.chunks)
+			chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
 	}
-}
-module.exports = CommonJsExportsParserPlugin;
+
+	// Cleanup work
+
+	logger.time("cleanup");
+	cleanupUnconnectedGroups(compilation, allCreatedChunkGroups);
+	logger.timeEnd("cleanup");
+};
+
+module.exports = buildChunkGraph;
 
 
 /***/ }),
 
-/***/ 59440:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 28034:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -73407,140 +67805,80 @@ module.exports = CommonJsExportsParserPlugin;
 
 
 
-const Template = __webpack_require__(1626);
-const { equals } = __webpack_require__(84953);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../Compiler")} Compiler */
 
-class CommonJsFullRequireDependency extends ModuleDependency {
+class AddBuildDependenciesPlugin {
 	/**
-	 * @param {string} request the request string
-	 * @param {[number, number]} range location in source code
-	 * @param {string[]} names accessed properties on module
+	 * @param {Iterable<string>} buildDependencies list of build dependencies
 	 */
-	constructor(request, range, names) {
-		super(request);
-		this.range = range;
-		this.names = names;
-		this.call = false;
-		this.asiSafe = undefined;
+	constructor(buildDependencies) {
+		this.buildDependencies = new Set(buildDependencies);
 	}
 
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		if (this.call) {
-			const importedModule = moduleGraph.getModule(this);
-			if (
-				!importedModule ||
-				importedModule.getExportsType(moduleGraph, false) !== "namespace"
-			) {
-				return [this.names.slice(0, -1)];
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"AddBuildDependenciesPlugin",
+			compilation => {
+				compilation.buildDependencies.addAll(this.buildDependencies);
 			}
-		}
-		return [this.names];
+		);
 	}
+}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.names);
-		write(this.call);
-		write(this.asiSafe);
-		super.serialize(context);
-	}
+module.exports = AddBuildDependenciesPlugin;
 
-	deserialize(context) {
-		const { read } = context;
-		this.names = read();
-		this.call = read();
-		this.asiSafe = read();
-		super.deserialize(context);
-	}
 
-	get type() {
-		return "cjs full require";
-	}
+/***/ }),
 
-	get category() {
-		return "commonjs";
+/***/ 47942:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class AddManagedPathsPlugin {
+	/**
+	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
+	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
+	 */
+	constructor(managedPaths, immutablePaths) {
+		this.managedPaths = new Set(managedPaths);
+		this.immutablePaths = new Set(immutablePaths);
 	}
-}
 
-CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemplate extends (
-	ModuleDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph,
-			runtimeRequirements,
-			runtime,
-			initFragments
+	apply(compiler) {
+		for (const managedPath of this.managedPaths) {
+			compiler.managedPaths.add(managedPath);
 		}
-	) {
-		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
-		if (!dep.range) return;
-		const importedModule = moduleGraph.getModule(dep);
-		let requireExpr = runtimeTemplate.moduleExports({
-			module: importedModule,
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-		if (importedModule) {
-			const ids = dep.names;
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(ids, runtime);
-			if (usedImported) {
-				const comment = equals(usedImported, ids)
-					? ""
-					: Template.toNormalComment(propertyAccess(ids)) + " ";
-				const access = `${comment}${propertyAccess(usedImported)}`;
-				requireExpr =
-					dep.asiSafe === true
-						? `(${requireExpr}${access})`
-						: `${requireExpr}${access}`;
-			}
+		for (const immutablePath of this.immutablePaths) {
+			compiler.immutablePaths.add(immutablePath);
 		}
-		source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
 	}
-};
-
-makeSerializable(
-	CommonJsFullRequireDependency,
-	"webpack/lib/dependencies/CommonJsFullRequireDependency"
-);
+}
 
-module.exports = CommonJsFullRequireDependency;
+module.exports = AddManagedPathsPlugin;
 
 
 /***/ }),
 
-/***/ 36013:
+/***/ 71985:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -73551,392 +67889,231 @@ module.exports = CommonJsFullRequireDependency;
 
 
 
-const CommentCompilationWarning = __webpack_require__(98427);
-const RuntimeGlobals = __webpack_require__(16475);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const {
-	evaluateToIdentifier,
-	evaluateToString,
-	expressionIsUnsupported,
-	toConstantDependency
-} = __webpack_require__(93998);
-const CommonJsFullRequireDependency = __webpack_require__(59440);
-const CommonJsRequireContextDependency = __webpack_require__(23962);
-const CommonJsRequireDependency = __webpack_require__(21264);
-const ConstDependency = __webpack_require__(76911);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const LocalModuleDependency = __webpack_require__(52805);
-const { getLocalModule } = __webpack_require__(75827);
-const RequireHeaderDependency = __webpack_require__(89183);
-const RequireResolveContextDependency = __webpack_require__(55627);
-const RequireResolveDependency = __webpack_require__(68582);
-const RequireResolveHeaderDependency = __webpack_require__(9880);
+const Cache = __webpack_require__(7592);
+const ProgressPlugin = __webpack_require__(13216);
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
-class CommonJsImportsParserPlugin {
+const BUILD_DEPENDENCIES_KEY = Symbol();
+
+class IdleFileCachePlugin {
 	/**
-	 * @param {JavascriptParserOptions} options parser options
+	 * @param {TODO} strategy cache strategy
+	 * @param {number} idleTimeout timeout
+	 * @param {number} idleTimeoutForInitialStore initial timeout
+	 * @param {number} idleTimeoutAfterLargeChanges timeout after changes
 	 */
-	constructor(options) {
-		this.options = options;
+	constructor(
+		strategy,
+		idleTimeout,
+		idleTimeoutForInitialStore,
+		idleTimeoutAfterLargeChanges
+	) {
+		this.strategy = strategy;
+		this.idleTimeout = idleTimeout;
+		this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
+		this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
 	}
 
-	apply(parser) {
-		const options = this.options;
-
-		// metadata //
-		const tapRequireExpression = (expression, getMembers) => {
-			parser.hooks.typeof
-				.for(expression)
-				.tap(
-					"CommonJsPlugin",
-					toConstantDependency(parser, JSON.stringify("function"))
-				);
-			parser.hooks.evaluateTypeof
-				.for(expression)
-				.tap("CommonJsPlugin", evaluateToString("function"));
-			parser.hooks.evaluateIdentifier
-				.for(expression)
-				.tap(
-					"CommonJsPlugin",
-					evaluateToIdentifier(expression, "require", getMembers, true)
-				);
-		};
-		tapRequireExpression("require", () => []);
-		tapRequireExpression("require.resolve", () => ["resolve"]);
-		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
-
-		// Weird stuff //
-		parser.hooks.assign.for("require").tap("CommonJsPlugin", expr => {
-			// to not leak to global "require", we need to define a local require here.
-			const dep = new ConstDependency("var require;", 0);
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		});
-
-		// Unsupported //
-		parser.hooks.expression
-			.for("require.main.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"require.main.require is not supported by webpack."
-				)
-			);
-		parser.hooks.call
-			.for("require.main.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"require.main.require is not supported by webpack."
-				)
-			);
-		parser.hooks.expression
-			.for("module.parent.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"module.parent.require is not supported by webpack."
-				)
-			);
-		parser.hooks.call
-			.for("module.parent.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"module.parent.require is not supported by webpack."
-				)
-			);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		let strategy = this.strategy;
+		const idleTimeout = this.idleTimeout;
+		const idleTimeoutForInitialStore = Math.min(
+			idleTimeout,
+			this.idleTimeoutForInitialStore
+		);
+		const idleTimeoutAfterLargeChanges = this.idleTimeoutAfterLargeChanges;
+		const resolvedPromise = Promise.resolve();
 
-		// renaming //
-		parser.hooks.canRename.for("require").tap("CommonJsPlugin", () => true);
-		parser.hooks.rename.for("require").tap("CommonJsPlugin", expr => {
-			// To avoid "not defined" error, replace the value with undefined
-			const dep = new ConstDependency("undefined", expr.range);
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return false;
-		});
+		let timeSpendInBuild = 0;
+		let timeSpendInStore = 0;
+		let avgTimeSpendInStore = 0;
 
-		// inspection //
-		parser.hooks.expression
-			.for("require.cache")
-			.tap(
-				"CommonJsImportsParserPlugin",
-				toConstantDependency(parser, RuntimeGlobals.moduleCache, [
-					RuntimeGlobals.moduleCache,
-					RuntimeGlobals.moduleId,
-					RuntimeGlobals.moduleLoaded
-				])
-			);
+		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise>} */
+		const pendingIdleTasks = new Map();
 
-		// require as expression //
-		parser.hooks.expression
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", expr => {
-				const dep = new CommonJsRequireContextDependency(
-					{
-						request: options.unknownContextRequest,
-						recursive: options.unknownContextRecursive,
-						regExp: options.unknownContextRegExp,
-						mode: "sync"
-					},
-					expr.range,
-					undefined,
-					parser.scope.inShorthand
+		compiler.cache.hooks.store.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			(identifier, etag, data) => {
+				pendingIdleTasks.set(identifier, () =>
+					strategy.store(identifier, etag, data)
 				);
-				dep.critical =
-					options.unknownContextCritical &&
-					"require function is used in a way in which dependencies cannot be statically extracted";
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			});
-
-		// require //
-		const processRequireItem = (expr, param) => {
-			if (param.isString()) {
-				const dep = new CommonJsRequireDependency(param.string, param.range);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
 			}
-		};
-		const processRequireContext = (expr, param) => {
-			const dep = ContextDependencyHelpers.create(
-				CommonJsRequireContextDependency,
-				expr.range,
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs"
-				},
-				parser
-			);
-			if (!dep) return;
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.current.addDependency(dep);
-			return true;
-		};
-		const createRequireHandler = callNew => expr => {
-			if (options.commonjsMagicComments) {
-				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(expr.range);
+		);
 
-				if (commentErrors) {
-					for (const e of commentErrors) {
-						const { comment } = e;
-						parser.state.module.addWarning(
-							new CommentCompilationWarning(
-								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								comment.loc
-							)
-						);
-					}
-				}
-				if (requireOptions) {
-					if (requireOptions.webpackIgnore !== undefined) {
-						if (typeof requireOptions.webpackIgnore !== "boolean") {
-							parser.state.module.addWarning(
-								new UnsupportedFeatureWarning(
-									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-									expr.loc
-								)
-							);
+		compiler.cache.hooks.get.tapPromise(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			(identifier, etag, gotHandlers) => {
+				const restore = () =>
+					strategy.restore(identifier, etag).then(cacheEntry => {
+						if (cacheEntry === undefined) {
+							gotHandlers.push((result, callback) => {
+								if (result !== undefined) {
+									pendingIdleTasks.set(identifier, () =>
+										strategy.store(identifier, etag, result)
+									);
+								}
+								callback();
+							});
 						} else {
-							// Do not instrument `require()` if `webpackIgnore` is `true`
-							if (requireOptions.webpackIgnore) {
-								return true;
-							}
+							return cacheEntry;
 						}
-					}
-				}
-			}
-
-			if (expr.arguments.length !== 1) return;
-			let localModule;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				let isExpression = false;
-				for (const p of param.options) {
-					const result = processRequireItem(expr, p);
-					if (result === undefined) {
-						isExpression = true;
-					}
-				}
-				if (!isExpression) {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			}
-			if (
-				param.isString() &&
-				(localModule = getLocalModule(parser.state, param.string))
-			) {
-				localModule.flagUsed();
-				const dep = new LocalModuleDependency(localModule, expr.range, callNew);
-				dep.loc = expr.loc;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			} else {
-				const result = processRequireItem(expr, param);
-				if (result === undefined) {
-					processRequireContext(expr, param);
-				} else {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
+					});
+				const pendingTask = pendingIdleTasks.get(identifier);
+				if (pendingTask !== undefined) {
+					pendingIdleTasks.delete(identifier);
+					return pendingTask().then(restore);
 				}
-				return true;
+				return restore();
 			}
-		};
-		parser.hooks.call
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
-		parser.hooks.new
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
-		parser.hooks.call
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
-		parser.hooks.new
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
+		);
 
-		// require with property access //
-		const chainHandler = (expr, calleeMembers, callExpr, members) => {
-			if (callExpr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
-				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.range,
-					members
-				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.loc;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		const callChainHandler = (expr, calleeMembers, callExpr, members) => {
-			if (callExpr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
-				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.callee.range,
-					members
+		compiler.cache.hooks.storeBuildDependencies.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			dependencies => {
+				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
+					strategy.storeBuildDependencies(dependencies)
 				);
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.callee.loc;
-				parser.state.current.addDependency(dep);
-				parser.walkExpressions(expr.arguments);
-				return true;
 			}
-		};
-		parser.hooks.memberChainOfCallMemberChain
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", chainHandler);
-		parser.hooks.memberChainOfCallMemberChain
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", chainHandler);
-		parser.hooks.callMemberChainOfCallMemberChain
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", callChainHandler);
-		parser.hooks.callMemberChainOfCallMemberChain
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", callChainHandler);
+		);
 
-		// require.resolve //
-		const processResolve = (expr, weak) => {
-			if (expr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				for (const option of param.options) {
-					const result = processResolveItem(expr, option, weak);
-					if (result === undefined) {
-						processResolveContext(expr, option, weak);
-					}
+		compiler.cache.hooks.shutdown.tapPromise(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			() => {
+				if (idleTimer) {
+					clearTimeout(idleTimer);
+					idleTimer = undefined;
 				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			} else {
-				const result = processResolveItem(expr, param, weak);
-				if (result === undefined) {
-					processResolveContext(expr, param, weak);
+				isIdle = false;
+				const reportProgress = ProgressPlugin.getReporter(compiler);
+				const jobs = Array.from(pendingIdleTasks.values());
+				if (reportProgress) reportProgress(0, "process pending cache items");
+				const promises = jobs.map(fn => fn());
+				pendingIdleTasks.clear();
+				promises.push(currentIdlePromise);
+				const promise = Promise.all(promises);
+				currentIdlePromise = promise.then(() => strategy.afterAllStored());
+				if (reportProgress) {
+					currentIdlePromise = currentIdlePromise.then(() => {
+						reportProgress(1, `stored`);
+					});
 				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
+				return currentIdlePromise.then(() => {
+					// Reset strategy
+					if (strategy.clear) strategy.clear();
+				});
 			}
-		};
-		const processResolveItem = (expr, param, weak) => {
-			if (param.isString()) {
-				const dep = new RequireResolveDependency(param.string, param.range);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				dep.weak = weak;
-				parser.state.current.addDependency(dep);
-				return true;
+		);
+
+		/** @type {Promise<any>} */
+		let currentIdlePromise = resolvedPromise;
+		let isIdle = false;
+		let isInitialStore = true;
+		const processIdleTasks = () => {
+			if (isIdle) {
+				const startTime = Date.now();
+				if (pendingIdleTasks.size > 0) {
+					const promises = [currentIdlePromise];
+					const maxTime = startTime + 100;
+					let maxCount = 100;
+					for (const [filename, factory] of pendingIdleTasks) {
+						pendingIdleTasks.delete(filename);
+						promises.push(factory());
+						if (maxCount-- <= 0 || Date.now() > maxTime) break;
+					}
+					currentIdlePromise = Promise.all(promises);
+					currentIdlePromise.then(() => {
+						timeSpendInStore += Date.now() - startTime;
+						// Allow to exit the process between
+						idleTimer = setTimeout(processIdleTasks, 0);
+						idleTimer.unref();
+					});
+					return;
+				}
+				currentIdlePromise = currentIdlePromise
+					.then(async () => {
+						await strategy.afterAllStored();
+						timeSpendInStore += Date.now() - startTime;
+						avgTimeSpendInStore =
+							Math.max(avgTimeSpendInStore, timeSpendInStore) * 0.9 +
+							timeSpendInStore * 0.1;
+						timeSpendInStore = 0;
+						timeSpendInBuild = 0;
+					})
+					.catch(err => {
+						const logger = compiler.getInfrastructureLogger(
+							"IdleFileCachePlugin"
+						);
+						logger.warn(`Background tasks during idle failed: ${err.message}`);
+						logger.debug(err.stack);
+					});
+				isInitialStore = false;
 			}
 		};
-		const processResolveContext = (expr, param, weak) => {
-			const dep = ContextDependencyHelpers.create(
-				RequireResolveContextDependency,
-				param.range,
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs",
-					mode: weak ? "weak" : "sync"
-				},
-				parser
-			);
-			if (!dep) return;
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.current.addDependency(dep);
-			return true;
-		};
-
-		parser.hooks.call
-			.for("require.resolve")
-			.tap("RequireResolveDependencyParserPlugin", expr => {
-				return processResolve(expr, false);
-			});
-		parser.hooks.call
-			.for("require.resolveWeak")
-			.tap("RequireResolveDependencyParserPlugin", expr => {
-				return processResolve(expr, true);
-			});
+		let idleTimer = undefined;
+		compiler.cache.hooks.beginIdle.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			() => {
+				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
+				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
+					compiler
+						.getInfrastructureLogger("IdleFileCachePlugin")
+						.log(
+							`Initial cache was generated and cache will be persisted in ${
+								idleTimeoutForInitialStore / 1000
+							}s.`
+						);
+				} else if (
+					isLargeChange &&
+					idleTimeoutAfterLargeChanges < idleTimeout
+				) {
+					compiler
+						.getInfrastructureLogger("IdleFileCachePlugin")
+						.log(
+							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
+								Math.round(avgTimeSpendInStore) / 1000
+							}s in average in cache store. This is considered as large change and cache will be persisted in ${
+								idleTimeoutAfterLargeChanges / 1000
+							}s.`
+						);
+				}
+				idleTimer = setTimeout(() => {
+					idleTimer = undefined;
+					isIdle = true;
+					resolvedPromise.then(processIdleTasks);
+				}, Math.min(isInitialStore ? idleTimeoutForInitialStore : Infinity, isLargeChange ? idleTimeoutAfterLargeChanges : Infinity, idleTimeout));
+				idleTimer.unref();
+			}
+		);
+		compiler.cache.hooks.endIdle.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			() => {
+				if (idleTimer) {
+					clearTimeout(idleTimer);
+					idleTimer = undefined;
+				}
+				isIdle = false;
+			}
+		);
+		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+			// 10% build overhead is ignored, as it's not cacheable
+			timeSpendInBuild *= 0.9;
+			timeSpendInBuild += stats.endTime - stats.startTime;
+		});
 	}
 }
-module.exports = CommonJsImportsParserPlugin;
+
+module.exports = IdleFileCachePlugin;
 
 
 /***/ }),
 
-/***/ 32406:
+/***/ 52539:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -73947,284 +68124,198 @@ module.exports = CommonJsImportsParserPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const SelfModuleFactory = __webpack_require__(63560);
-const Template = __webpack_require__(1626);
-const CommonJsExportsDependency = __webpack_require__(45598);
-const CommonJsFullRequireDependency = __webpack_require__(59440);
-const CommonJsRequireContextDependency = __webpack_require__(23962);
-const CommonJsRequireDependency = __webpack_require__(21264);
-const CommonJsSelfReferenceDependency = __webpack_require__(52225);
-const ModuleDecoratorDependency = __webpack_require__(88488);
-const RequireHeaderDependency = __webpack_require__(89183);
-const RequireResolveContextDependency = __webpack_require__(55627);
-const RequireResolveDependency = __webpack_require__(68582);
-const RequireResolveHeaderDependency = __webpack_require__(9880);
-const RuntimeRequirementsDependency = __webpack_require__(24187);
-
-const CommonJsExportsParserPlugin = __webpack_require__(97107);
-const CommonJsImportsParserPlugin = __webpack_require__(36013);
+const Cache = __webpack_require__(7592);
 
-const {
-	evaluateToIdentifier,
-	toConstantDependency
-} = __webpack_require__(93998);
-const CommonJsExportRequireDependency = __webpack_require__(62892);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-class CommonJsPlugin {
+class MemoryCachePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"CommonJsPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					CommonJsRequireDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsRequireDependency,
-					new CommonJsRequireDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					CommonJsFullRequireDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsFullRequireDependency,
-					new CommonJsFullRequireDependency.Template()
-				);
+		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		const cache = new Map();
+		compiler.cache.hooks.store.tap(
+			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, data) => {
+				cache.set(identifier, { etag, data });
+			}
+		);
+		compiler.cache.hooks.get.tap(
+			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, gotHandlers) => {
+				const cacheEntry = cache.get(identifier);
+				if (cacheEntry === null) {
+					return null;
+				} else if (cacheEntry !== undefined) {
+					return cacheEntry.etag === etag ? cacheEntry.data : null;
+				}
+				gotHandlers.push((result, callback) => {
+					if (result === undefined) {
+						cache.set(identifier, null);
+					} else {
+						cache.set(identifier, { etag, data: result });
+					}
+					return callback();
+				});
+			}
+		);
+		compiler.cache.hooks.shutdown.tap(
+			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+			() => {
+				cache.clear();
+			}
+		);
+	}
+}
+module.exports = MemoryCachePlugin;
 
-				compilation.dependencyFactories.set(
-					CommonJsRequireContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsRequireContextDependency,
-					new CommonJsRequireContextDependency.Template()
-				);
 
-				compilation.dependencyFactories.set(
-					RequireResolveDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireResolveDependency,
-					new RequireResolveDependency.Template()
-				);
+/***/ }),
 
-				compilation.dependencyFactories.set(
-					RequireResolveContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireResolveContextDependency,
-					new RequireResolveContextDependency.Template()
-				);
+/***/ 99334:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				compilation.dependencyTemplates.set(
-					RequireResolveHeaderDependency,
-					new RequireResolveHeaderDependency.Template()
-				);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				compilation.dependencyTemplates.set(
-					RequireHeaderDependency,
-					new RequireHeaderDependency.Template()
-				);
 
-				compilation.dependencyTemplates.set(
-					CommonJsExportsDependency,
-					new CommonJsExportsDependency.Template()
-				);
 
-				compilation.dependencyFactories.set(
-					CommonJsExportRequireDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsExportRequireDependency,
-					new CommonJsExportRequireDependency.Template()
-				);
+const Cache = __webpack_require__(7592);
 
-				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-				compilation.dependencyFactories.set(
-					CommonJsSelfReferenceDependency,
-					selfFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsSelfReferenceDependency,
-					new CommonJsSelfReferenceDependency.Template()
-				);
+class MemoryWithGcCachePlugin {
+	constructor({ maxGenerations }) {
+		this._maxGenerations = maxGenerations;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const maxGenerations = this._maxGenerations;
+		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		const cache = new Map();
+		/** @type {Map<string, { entry: { etag: Etag | null, data: any }, until: number }>} */
+		const oldCache = new Map();
+		let generation = 0;
+		let cachePosition = 0;
+		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
+		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+			generation++;
+			let clearedEntries = 0;
+			let lastClearedIdentifier;
+			for (const [identifier, entry] of oldCache) {
+				if (entry.until > generation) break;
 
-				compilation.dependencyFactories.set(
-					ModuleDecoratorDependency,
-					selfFactory
-				);
-				compilation.dependencyTemplates.set(
-					ModuleDecoratorDependency,
-					new ModuleDecoratorDependency.Template()
+				oldCache.delete(identifier);
+				if (cache.get(identifier) === undefined) {
+					cache.delete(identifier);
+					clearedEntries++;
+					lastClearedIdentifier = identifier;
+				}
+			}
+			if (clearedEntries > 0 || oldCache.size > 0) {
+				logger.log(
+					`${cache.size - oldCache.size} active entries, ${
+						oldCache.size
+					} recently unused cached entries${
+						clearedEntries > 0
+							? `, ${clearedEntries} old unused cache entries removed e. g. ${lastClearedIdentifier}`
+							: ""
+					}`
 				);
-
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.harmonyModuleDecorator)
-					.tap("CommonJsPlugin", (module, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.nodeModuleDecorator)
-					.tap("CommonJsPlugin", (module, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.harmonyModuleDecorator)
-					.tap("CommonJsPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new HarmonyModuleDecoratorRuntimeModule()
-						);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.nodeModuleDecorator)
-					.tap("CommonJsPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new NodeModuleDecoratorRuntimeModule()
-						);
-					});
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.commonjs !== undefined && !parserOptions.commonjs)
-						return;
-					parser.hooks.typeof
-						.for("module")
-						.tap(
-							"CommonJsPlugin",
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-
-					parser.hooks.expression
-						.for("require.main")
-						.tap(
-							"CommonJsPlugin",
-							toConstantDependency(
-								parser,
-								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`,
-								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
-							)
-						);
-					parser.hooks.expression
-						.for("module.loaded")
-						.tap("CommonJsPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"module.loaded";
-							const dep = new RuntimeRequirementsDependency([
-								RuntimeGlobals.moduleLoaded
-							]);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-
-					parser.hooks.expression
-						.for("module.id")
-						.tap("CommonJsPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"module.id";
-							const dep = new RuntimeRequirementsDependency([
-								RuntimeGlobals.moduleId
-							]);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-
-					parser.hooks.evaluateIdentifier.for("module.hot").tap(
-						"CommonJsPlugin",
-						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
-					);
-
-					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
-					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
-						parser
-					);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("CommonJsPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("CommonJsPlugin", handler);
+			}
+			let i = (cache.size / maxGenerations) | 0;
+			let j = cachePosition >= cache.size ? 0 : cachePosition;
+			cachePosition = j + i;
+			for (const [identifier, entry] of cache) {
+				if (j !== 0) {
+					j--;
+					continue;
+				}
+				if (entry !== undefined) {
+					// We don't delete the cache entry, but set it to undefined instead
+					// This reserves the location in the data table and avoids rehashing
+					// when constantly adding and removing entries.
+					// It will be deleted when removed from oldCache.
+					cache.set(identifier, undefined);
+					oldCache.delete(identifier);
+					oldCache.set(identifier, {
+						entry,
+						until: generation + maxGenerations
+					});
+					if (i-- === 0) break;
+				}
+			}
+		});
+		compiler.cache.hooks.store.tap(
+			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, data) => {
+				cache.set(identifier, { etag, data });
+			}
+		);
+		compiler.cache.hooks.get.tap(
+			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, gotHandlers) => {
+				const cacheEntry = cache.get(identifier);
+				if (cacheEntry === null) {
+					return null;
+				} else if (cacheEntry !== undefined) {
+					return cacheEntry.etag === etag ? cacheEntry.data : null;
+				}
+				const oldCacheEntry = oldCache.get(identifier);
+				if (oldCacheEntry !== undefined) {
+					const cacheEntry = oldCacheEntry.entry;
+					if (cacheEntry === null) {
+						oldCache.delete(identifier);
+						cache.set(identifier, cacheEntry);
+						return null;
+					} else {
+						if (cacheEntry.etag !== etag) return null;
+						oldCache.delete(identifier);
+						cache.set(identifier, cacheEntry);
+						return cacheEntry.data;
+					}
+				}
+				gotHandlers.push((result, callback) => {
+					if (result === undefined) {
+						cache.set(identifier, null);
+					} else {
+						cache.set(identifier, { etag, data: result });
+					}
+					return callback();
+				});
+			}
+		);
+		compiler.cache.hooks.shutdown.tap(
+			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			() => {
+				cache.clear();
+				oldCache.clear();
 			}
 		);
 	}
 }
-
-class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("harmony module decorator");
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${
-				RuntimeGlobals.harmonyModuleDecorator
-			} = ${runtimeTemplate.basicFunction("module", [
-				"module = Object.create(module);",
-				"if (!module.children) module.children = [];",
-				"Object.defineProperty(module, 'exports', {",
-				Template.indent([
-					"enumerable: true,",
-					`set: ${runtimeTemplate.basicFunction("", [
-						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
-					])}`
-				]),
-				"});",
-				"return module;"
-			])};`
-		]);
-	}
-}
-
-class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("node module decorator");
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
-				"module",
-				[
-					"module.paths = [];",
-					"if (!module.children) module.children = [];",
-					"return module;"
-				]
-			)};`
-		]);
-	}
-}
-
-module.exports = CommonJsPlugin;
+module.exports = MemoryWithGcCachePlugin;
 
 
 /***/ }),
 
-/***/ 23962:
+/***/ 86180:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -74235,761 +68326,1430 @@ module.exports = CommonJsPlugin;
 
 
 
+const FileSystemInfo = __webpack_require__(79453);
+const ProgressPlugin = __webpack_require__(13216);
+const { formatSize } = __webpack_require__(71070);
+const SerializerMiddleware = __webpack_require__(83137);
+const LazySet = __webpack_require__(38938);
 const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
-
-class CommonJsRequireContextDependency extends ContextDependency {
-	constructor(options, range, valueRange, inShorthand) {
-		super(options);
+const memoize = __webpack_require__(78676);
+const {
+	createFileSerializer,
+	NOT_SERIALIZABLE
+} = __webpack_require__(8282);
 
-		this.range = range;
-		this.valueRange = valueRange;
-		// inShorthand must be serialized by subclasses that use it
-		this.inShorthand = inShorthand;
-	}
+/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+/** @typedef {import("../logging/Logger").Logger} Logger */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
-	get type() {
-		return "cjs require context";
+class PackContainer {
+	/**
+	 * @param {Object} data stored data
+	 * @param {string} version version identifier
+	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
+	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
+	 * @param {Map<string, string | false>} resolveResults result of the resolved build dependencies
+	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
+	 */
+	constructor(
+		data,
+		version,
+		buildSnapshot,
+		buildDependencies,
+		resolveResults,
+		resolveBuildDependenciesSnapshot
+	) {
+		this.data = data;
+		this.version = version;
+		this.buildSnapshot = buildSnapshot;
+		this.buildDependencies = buildDependencies;
+		this.resolveResults = resolveResults;
+		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-		write(this.valueRange);
-		write(this.inShorthand);
-
-		super.serialize(context);
+	serialize({ write, writeLazy }) {
+		write(this.version);
+		write(this.buildSnapshot);
+		write(this.buildDependencies);
+		write(this.resolveResults);
+		write(this.resolveBuildDependenciesSnapshot);
+		writeLazy(this.data);
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.range = read();
-		this.valueRange = read();
-		this.inShorthand = read();
-
-		super.deserialize(context);
+	deserialize({ read }) {
+		this.version = read();
+		this.buildSnapshot = read();
+		this.buildDependencies = read();
+		this.resolveResults = read();
+		this.resolveBuildDependenciesSnapshot = read();
+		this.data = read();
 	}
 }
 
 makeSerializable(
-	CommonJsRequireContextDependency,
-	"webpack/lib/dependencies/CommonJsRequireContextDependency"
+	PackContainer,
+	"webpack/lib/cache/PackFileCacheStrategy",
+	"PackContainer"
 );
 
-CommonJsRequireContextDependency.Template =
-	ContextDependencyTemplateAsRequireCall;
-
-module.exports = CommonJsRequireContextDependency;
+const MIN_CONTENT_SIZE = 1024 * 1024; // 1 MB
+const CONTENT_COUNT_TO_MERGE = 10;
+const MIN_ITEMS_IN_FRESH_PACK = 100;
+const MAX_ITEMS_IN_FRESH_PACK = 50000;
+const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
 
+class PackItemInfo {
+	/**
+	 * @param {string} identifier identifier of item
+	 * @param {string | null} etag etag of item
+	 * @param {any} value fresh value of item
+	 */
+	constructor(identifier, etag, value) {
+		this.identifier = identifier;
+		this.etag = etag;
+		this.location = -1;
+		this.lastAccess = Date.now();
+		this.freshValue = value;
+	}
+}
 
-/***/ }),
+class Pack {
+	constructor(logger, maxAge) {
+		/** @type {Map<string, PackItemInfo>} */
+		this.itemInfo = new Map();
+		/** @type {string[]} */
+		this.requests = [];
+		this.requestsTimeout = undefined;
+		/** @type {Map<string, PackItemInfo>} */
+		this.freshContent = new Map();
+		/** @type {(undefined | PackContent)[]} */
+		this.content = [];
+		this.invalid = false;
+		this.logger = logger;
+		this.maxAge = maxAge;
+	}
 
-/***/ 21264:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	_addRequest(identifier) {
+		this.requests.push(identifier);
+		if (this.requestsTimeout === undefined) {
+			this.requestsTimeout = setTimeout(() => {
+				this.requests.push(undefined);
+				this.requestsTimeout = undefined;
+			}, MAX_TIME_IN_FRESH_PACK);
+			if (this.requestsTimeout.unref) this.requestsTimeout.unref();
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	stopCapturingRequests() {
+		if (this.requestsTimeout !== undefined) {
+			clearTimeout(this.requestsTimeout);
+			this.requestsTimeout = undefined;
+		}
+	}
 
+	/**
+	 * @param {string} identifier unique name for the resource
+	 * @param {string | null} etag etag of the resource
+	 * @returns {any} cached content
+	 */
+	get(identifier, etag) {
+		const info = this.itemInfo.get(identifier);
+		this._addRequest(identifier);
+		if (info === undefined) {
+			return undefined;
+		}
+		if (info.etag !== etag) return null;
+		info.lastAccess = Date.now();
+		const loc = info.location;
+		if (loc === -1) {
+			return info.freshValue;
+		} else {
+			if (!this.content[loc]) {
+				return undefined;
+			}
+			return this.content[loc].get(identifier);
+		}
+	}
 
+	/**
+	 * @param {string} identifier unique name for the resource
+	 * @param {string | null} etag etag of the resource
+	 * @param {any} data cached content
+	 * @returns {void}
+	 */
+	set(identifier, etag, data) {
+		if (!this.invalid) {
+			this.invalid = true;
+			this.logger.log(`Pack got invalid because of write to: ${identifier}`);
+		}
+		const info = this.itemInfo.get(identifier);
+		if (info === undefined) {
+			const newInfo = new PackItemInfo(identifier, etag, data);
+			this.itemInfo.set(identifier, newInfo);
+			this._addRequest(identifier);
+			this.freshContent.set(identifier, newInfo);
+		} else {
+			const loc = info.location;
+			if (loc >= 0) {
+				this._addRequest(identifier);
+				this.freshContent.set(identifier, info);
+				const content = this.content[loc];
+				content.delete(identifier);
+				if (content.items.size === 0) {
+					this.content[loc] = undefined;
+					this.logger.debug("Pack %d got empty and is removed", loc);
+				}
+			}
+			info.freshValue = data;
+			info.lastAccess = Date.now();
+			info.etag = etag;
+			info.location = -1;
+		}
+	}
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+	getContentStats() {
+		let count = 0;
+		let size = 0;
+		for (const content of this.content) {
+			if (content !== undefined) {
+				count++;
+				const s = content.getSize();
+				if (s > 0) {
+					size += s;
+				}
+			}
+		}
+		return { count, size };
+	}
 
-class CommonJsRequireDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-		this.range = range;
+	/**
+	 * @returns {number} new location of data entries
+	 */
+	_findLocation() {
+		let i;
+		for (i = 0; i < this.content.length && this.content[i] !== undefined; i++);
+		return i;
 	}
 
-	get type() {
-		return "cjs require";
+	_gcAndUpdateLocation(items, usedItems, newLoc) {
+		let count = 0;
+		let lastGC;
+		const now = Date.now();
+		for (const identifier of items) {
+			const info = this.itemInfo.get(identifier);
+			if (now - info.lastAccess > this.maxAge) {
+				this.itemInfo.delete(identifier);
+				items.delete(identifier);
+				usedItems.delete(identifier);
+				count++;
+				lastGC = identifier;
+			} else {
+				info.location = newLoc;
+			}
+		}
+		if (count > 0) {
+			this.logger.log(
+				"Garbage Collected %d old items at pack %d (%d items remaining) e. g. %s",
+				count,
+				newLoc,
+				items.size,
+				lastGC
+			);
+		}
 	}
 
-	get category() {
-		return "commonjs";
+	_persistFreshContent() {
+		const itemsCount = this.freshContent.size;
+		if (itemsCount > 0) {
+			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
+			const itemsPerPack = Math.ceil(itemsCount / packCount);
+			const packs = [];
+			let i = 0;
+			let ignoreNextTimeTick = false;
+			const createNextPack = () => {
+				const loc = this._findLocation();
+				this.content[loc] = null; // reserve
+				const pack = {
+					/** @type {Set<string>} */
+					items: new Set(),
+					/** @type {Map<string, any>} */
+					map: new Map(),
+					loc
+				};
+				packs.push(pack);
+				return pack;
+			};
+			let pack = createNextPack();
+			if (this.requestsTimeout !== undefined)
+				clearTimeout(this.requestsTimeout);
+			for (const identifier of this.requests) {
+				if (identifier === undefined) {
+					if (ignoreNextTimeTick) {
+						ignoreNextTimeTick = false;
+					} else if (pack.items.size >= MIN_ITEMS_IN_FRESH_PACK) {
+						i = 0;
+						pack = createNextPack();
+					}
+					continue;
+				}
+				const info = this.freshContent.get(identifier);
+				if (info === undefined) continue;
+				pack.items.add(identifier);
+				pack.map.set(identifier, info.freshValue);
+				info.location = pack.loc;
+				info.freshValue = undefined;
+				this.freshContent.delete(identifier);
+				if (++i > itemsPerPack) {
+					i = 0;
+					pack = createNextPack();
+					ignoreNextTimeTick = true;
+				}
+			}
+			this.requests.length = 0;
+			for (const pack of packs) {
+				this.content[pack.loc] = new PackContent(
+					pack.items,
+					new Set(pack.items),
+					new PackContentItems(pack.map)
+				);
+			}
+			this.logger.log(
+				`${itemsCount} fresh items in cache put into pack ${
+					packs.length > 1
+						? packs
+								.map(pack => `${pack.loc} (${pack.items.size} items)`)
+								.join(", ")
+						: packs[0].loc
+				}`
+			);
+		}
 	}
-}
 
-CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+	/**
+	 * Merges small content files to a single content file
+	 */
+	_optimizeSmallContent() {
+		// 1. Find all small content files
+		// Treat unused content files separately to avoid
+		// a merge-split cycle
+		/** @type {number[]} */
+		const smallUsedContents = [];
+		/** @type {number} */
+		let smallUsedContentSize = 0;
+		/** @type {number[]} */
+		const smallUnusedContents = [];
+		/** @type {number} */
+		let smallUnusedContentSize = 0;
+		for (let i = 0; i < this.content.length; i++) {
+			const content = this.content[i];
+			if (content === undefined) continue;
+			if (content.outdated) continue;
+			const size = content.getSize();
+			if (size < 0 || size > MIN_CONTENT_SIZE) continue;
+			if (content.used.size > 0) {
+				smallUsedContents.push(i);
+				smallUsedContentSize += size;
+			} else {
+				smallUnusedContents.push(i);
+				smallUnusedContentSize += size;
+			}
+		}
 
-makeSerializable(
-	CommonJsRequireDependency,
-	"webpack/lib/dependencies/CommonJsRequireDependency"
-);
+		// 2. Check if minimum number is reached
+		let mergedIndices;
+		if (
+			smallUsedContents.length >= CONTENT_COUNT_TO_MERGE ||
+			smallUsedContentSize > MIN_CONTENT_SIZE
+		) {
+			mergedIndices = smallUsedContents;
+		} else if (
+			smallUnusedContents.length >= CONTENT_COUNT_TO_MERGE ||
+			smallUnusedContentSize > MIN_CONTENT_SIZE
+		) {
+			mergedIndices = smallUnusedContents;
+		} else return;
 
-module.exports = CommonJsRequireDependency;
+		const mergedContent = [];
 
+		// 3. Remove old content entries
+		for (const i of mergedIndices) {
+			mergedContent.push(this.content[i]);
+			this.content[i] = undefined;
+		}
 
-/***/ }),
+		// 4. Determine merged items
+		/** @type {Set<string>} */
+		const mergedItems = new Set();
+		/** @type {Set<string>} */
+		const mergedUsedItems = new Set();
+		/** @type {(function(Map<string, any>): Promise)[]} */
+		const addToMergedMap = [];
+		for (const content of mergedContent) {
+			for (const identifier of content.items) {
+				mergedItems.add(identifier);
+			}
+			for (const identifier of content.used) {
+				mergedUsedItems.add(identifier);
+			}
+			addToMergedMap.push(async map => {
+				// unpack existing content
+				// after that values are accessible in .content
+				await content.unpack(
+					"it should be merged with other small pack contents"
+				);
+				for (const [identifier, value] of content.content) {
+					map.set(identifier, value);
+				}
+			});
+		}
 
-/***/ 52225:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// 5. GC and update location of merged items
+		const newLoc = this._findLocation();
+		this._gcAndUpdateLocation(mergedItems, mergedUsedItems, newLoc);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		// 6. If not empty, store content somewhere
+		if (mergedItems.size > 0) {
+			this.content[newLoc] = new PackContent(
+				mergedItems,
+				mergedUsedItems,
+				memoize(async () => {
+					/** @type {Map<string, any>} */
+					const map = new Map();
+					await Promise.all(addToMergedMap.map(fn => fn(map)));
+					return new PackContentItems(map);
+				})
+			);
+			this.logger.log(
+				"Merged %d small files with %d cache items into pack %d",
+				mergedContent.length,
+				mergedItems.size,
+				newLoc
+			);
+		}
+	}
 
+	/**
+	 * Split large content files with used and unused items
+	 * into two parts to separate used from unused items
+	 */
+	_optimizeUnusedContent() {
+		// 1. Find a large content file with used and unused items
+		for (let i = 0; i < this.content.length; i++) {
+			const content = this.content[i];
+			if (content === undefined) continue;
+			const size = content.getSize();
+			if (size < MIN_CONTENT_SIZE) continue;
+			const used = content.used.size;
+			const total = content.items.size;
+			if (used > 0 && used < total) {
+				// 2. Remove this content
+				this.content[i] = undefined;
 
+				// 3. Determine items for the used content file
+				const usedItems = new Set(content.used);
+				const newLoc = this._findLocation();
+				this._gcAndUpdateLocation(usedItems, usedItems, newLoc);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const { equals } = __webpack_require__(84953);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const NullDependency = __webpack_require__(31830);
+				// 4. Create content file for used items
+				if (usedItems.size > 0) {
+					this.content[newLoc] = new PackContent(
+						usedItems,
+						new Set(usedItems),
+						async () => {
+							await content.unpack(
+								"it should be splitted into used and unused items"
+							);
+							const map = new Map();
+							for (const identifier of usedItems) {
+								map.set(identifier, content.content.get(identifier));
+							}
+							return new PackContentItems(map);
+						}
+					);
+				}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+				// 5. Determine items for the unused content file
+				const unusedItems = new Set(content.items);
+				const usedOfUnusedItems = new Set();
+				for (const identifier of usedItems) {
+					unusedItems.delete(identifier);
+				}
+				const newUnusedLoc = this._findLocation();
+				this._gcAndUpdateLocation(unusedItems, usedOfUnusedItems, newUnusedLoc);
 
-class CommonJsSelfReferenceDependency extends NullDependency {
-	constructor(range, base, names, call) {
-		super();
-		this.range = range;
-		this.base = base;
-		this.names = names;
-		this.call = call;
-	}
+				// 6. Create content file for unused items
+				if (unusedItems.size > 0) {
+					this.content[newUnusedLoc] = new PackContent(
+						unusedItems,
+						usedOfUnusedItems,
+						async () => {
+							await content.unpack(
+								"it should be splitted into used and unused items"
+							);
+							const map = new Map();
+							for (const identifier of unusedItems) {
+								map.set(identifier, content.content.get(identifier));
+							}
+							return new PackContentItems(map);
+						}
+					);
+				}
 
-	get type() {
-		return "cjs self exports reference";
-	}
+				this.logger.log(
+					"Split pack %d into pack %d with %d used items and pack %d with %d unused items",
+					i,
+					newLoc,
+					usedItems.size,
+					newUnusedLoc,
+					unusedItems.size
+				);
 
-	get category() {
-		return "self";
+				// optimizing only one of them is good enough and
+				// reduces the amount of serialization needed
+				return;
+			}
+		}
 	}
 
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * Find the content with the oldest item and run GC on that.
+	 * Only runs for one content to avoid large invalidation.
 	 */
-	getResourceIdentifier() {
-		return `self`;
-	}
+	_gcOldestContent() {
+		/** @type {PackItemInfo} */
+		let oldest = undefined;
+		for (const info of this.itemInfo.values()) {
+			if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
+				oldest = info;
+			}
+		}
+		if (Date.now() - oldest.lastAccess > this.maxAge) {
+			const loc = oldest.location;
+			if (loc < 0) return;
+			const content = this.content[loc];
+			const items = new Set(content.items);
+			const usedItems = new Set(content.used);
+			this._gcAndUpdateLocation(items, usedItems, loc);
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return [this.call ? this.names.slice(0, -1) : this.names];
+			this.content[loc] =
+				items.size > 0
+					? new PackContent(items, usedItems, async () => {
+							await content.unpack(
+								"it contains old items that should be garbage collected"
+							);
+							const map = new Map();
+							for (const identifier of items) {
+								map.set(identifier, content.content.get(identifier));
+							}
+							return new PackContentItems(map);
+					  })
+					: undefined;
+		}
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.base);
-		write(this.names);
-		write(this.call);
-		super.serialize(context);
+	serialize({ write, writeSeparate }) {
+		this._persistFreshContent();
+		this._optimizeSmallContent();
+		this._optimizeUnusedContent();
+		this._gcOldestContent();
+		for (const identifier of this.itemInfo.keys()) {
+			write(identifier);
+		}
+		write(null); // null as marker of the end of keys
+		for (const info of this.itemInfo.values()) {
+			write(info.etag);
+		}
+		for (const info of this.itemInfo.values()) {
+			write(info.lastAccess);
+		}
+		for (let i = 0; i < this.content.length; i++) {
+			const content = this.content[i];
+			if (content !== undefined) {
+				write(content.items);
+				content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
+			} else {
+				write(undefined); // undefined marks an empty content slot
+			}
+		}
+		write(null); // null as marker of the end of items
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.base = read();
-		this.names = read();
-		this.call = read();
-		super.deserialize(context);
+	deserialize({ read, logger }) {
+		this.logger = logger;
+		{
+			const items = [];
+			let item = read();
+			while (item !== null) {
+				items.push(item);
+				item = read();
+			}
+			this.itemInfo.clear();
+			const infoItems = items.map(identifier => {
+				const info = new PackItemInfo(identifier, undefined, undefined);
+				this.itemInfo.set(identifier, info);
+				return info;
+			});
+			for (const info of infoItems) {
+				info.etag = read();
+			}
+			for (const info of infoItems) {
+				info.lastAccess = read();
+			}
+		}
+		this.content.length = 0;
+		let items = read();
+		while (items !== null) {
+			if (items === undefined) {
+				this.content.push(items);
+			} else {
+				const idx = this.content.length;
+				const lazy = read();
+				this.content.push(
+					new PackContent(
+						items,
+						new Set(),
+						lazy,
+						logger,
+						`${this.content.length}`
+					)
+				);
+				for (const identifier of items) {
+					this.itemInfo.get(identifier).location = idx;
+				}
+			}
+			items = read();
+		}
 	}
 }
 
-makeSerializable(
-	CommonJsSelfReferenceDependency,
-	"webpack/lib/dependencies/CommonJsSelfReferenceDependency"
-);
+makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
-CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate extends (
-	NullDependency.Template
-) {
+class PackContentItems {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {Map<string, any>} map items
 	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, runtime, runtimeRequirements }
-	) {
-		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
-		let used;
-		if (dep.names.length === 0) {
-			used = dep.names;
-		} else {
-			used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
-		}
-		if (!used) {
-			throw new Error(
-				"Self-reference dependency has unused export name: This should not happen"
-			);
-		}
-
-		let base = undefined;
-		switch (dep.base) {
-			case "exports":
-				runtimeRequirements.add(RuntimeGlobals.exports);
-				base = module.exportsArgument;
-				break;
-			case "module.exports":
-				runtimeRequirements.add(RuntimeGlobals.module);
-				base = `${module.moduleArgument}.exports`;
-				break;
-			case "this":
-				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-				base = "this";
-				break;
-			default:
-				throw new Error(`Unsupported base ${dep.base}`);
-		}
+	constructor(map) {
+		this.map = map;
+	}
 
-		if (base === dep.base && equals(used, dep.names)) {
-			// Nothing has to be changed
-			// We don't use a replacement for compat reasons
-			// for plugins that update `module._source` which they
-			// shouldn't do!
+	serialize({ write, snapshot, rollback, logger, profile }) {
+		if (profile) {
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					const start = process.hrtime();
+					write(value);
+					const durationHr = process.hrtime(start);
+					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+					if (duration > 1) {
+						if (duration > 500)
+							logger.error(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 50)
+							logger.warn(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 10)
+							logger.info(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 5)
+							logger.log(`Serialization of '${key}': ${duration} ms`);
+						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+					}
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
+			}
+			write(null);
 			return;
 		}
+		// Try to serialize all at once
+		const s = snapshot();
+		try {
+			write(true);
+			write(this.map);
+		} catch (e) {
+			rollback(s);
 
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`${base}${propertyAccess(used)}`
-		);
+			// Try to serialize each item on it's own
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					write(value);
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
+			}
+			write(null);
+		}
 	}
-};
-
-module.exports = CommonJsSelfReferenceDependency;
-
-
-/***/ }),
-
-/***/ 76911:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+	deserialize({ read, logger, profile }) {
+		if (read()) {
+			this.map = read();
+		} else if (profile) {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				const start = process.hrtime();
+				const value = read();
+				const durationHr = process.hrtime(start);
+				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+				if (duration > 1) {
+					if (duration > 100)
+						logger.error(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 20)
+						logger.warn(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 5)
+						logger.info(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 2)
+						logger.log(`Deserialization of '${key}': ${duration} ms`);
+					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+				}
+				map.set(key, value);
+				key = read();
+			}
+			this.map = map;
+		} else {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				map.set(key, read());
+				key = read();
+			}
+			this.map = map;
+		}
+	}
+}
 
+makeSerializable(
+	PackContentItems,
+	"webpack/lib/cache/PackFileCacheStrategy",
+	"PackContentItems"
+);
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+class PackContent {
+	/*
+		This class can be in these states:
+		   |   this.lazy    | this.content | this.outdated | state
+		A1 |   undefined    |     Map      |     false     | fresh content
+		A2 |   undefined    |     Map      |     true      | (will not happen)
+		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
+		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
+		C1 | lazy* () => {} |     Map      |     false     | deserialized
+		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
+		this.used is a subset of this.items.
+		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
+		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
+		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
+		When this.lazy and this.content is set, they contain the same data.
+		this.get must only be called with a valid item from this.items.
+		In state C this.lazy is unMemoized
+	*/
 
-class ConstDependency extends NullDependency {
 	/**
-	 * @param {string} expression the expression
-	 * @param {number|[number, number]} range the source range
-	 * @param {string[]=} runtimeRequirements runtime requirements
+	 * @param {Set<string>} items keys
+	 * @param {Set<string>} usedItems used keys
+	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
+	 * @param {Logger=} logger logger for logging
+	 * @param {string=} lazyName name of dataOrFn for logging
 	 */
-	constructor(expression, range, runtimeRequirements) {
-		super();
-		this.expression = expression;
-		this.range = range;
-		this.runtimeRequirements = runtimeRequirements
-			? new Set(runtimeRequirements)
-			: null;
-		this._hashUpdate = undefined;
+	constructor(items, usedItems, dataOrFn, logger, lazyName) {
+		this.items = items;
+		/** @type {function(): Promise<PackContentItems> | PackContentItems} */
+		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
+		/** @type {Map<string, any>} */
+		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
+		this.outdated = false;
+		this.used = usedItems;
+		this.logger = logger;
+		this.lazyName = lazyName;
+	}
+
+	get(identifier) {
+		this.used.add(identifier);
+		if (this.content) {
+			return this.content.get(identifier);
+		}
+
+		// We are in state B
+		const { lazyName } = this;
+		let timeMessage;
+		if (lazyName) {
+			// only log once
+			this.lazyName = undefined;
+			timeMessage = `restore cache content ${lazyName} (${formatSize(
+				this.getSize()
+			)})`;
+			this.logger.log(
+				`starting to restore cache content ${lazyName} (${formatSize(
+					this.getSize()
+				)}) because of request to: ${identifier}`
+			);
+			this.logger.time(timeMessage);
+		}
+		const value = this.lazy();
+		if ("then" in value) {
+			return value.then(data => {
+				const map = data.map;
+				if (timeMessage) {
+					this.logger.timeEnd(timeMessage);
+				}
+				// Move to state C
+				this.content = map;
+				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+				return map.get(identifier);
+			});
+		} else {
+			const map = value.map;
+			if (timeMessage) {
+				this.logger.timeEnd(timeMessage);
+			}
+			// Move to state C
+			this.content = map;
+			this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+			return map.get(identifier);
+		}
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @param {string} reason explanation why unpack is necessary
+	 * @returns {void | Promise} maybe a promise if lazy
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			let hashUpdate = "" + this.range + "|" + this.expression;
-			if (this.runtimeRequirements) {
-				for (const item of this.runtimeRequirements) {
-					hashUpdate += "|";
-					hashUpdate += item;
+	unpack(reason) {
+		if (this.content) return;
+
+		// Move from state B to C
+		if (this.lazy) {
+			const { lazyName } = this;
+			let timeMessage;
+			if (lazyName) {
+				// only log once
+				this.lazyName = undefined;
+				timeMessage = `unpack cache content ${lazyName} (${formatSize(
+					this.getSize()
+				)})`;
+				this.logger.log(
+					`starting to unpack cache content ${lazyName} (${formatSize(
+						this.getSize()
+					)}) because ${reason}`
+				);
+				this.logger.time(timeMessage);
+			}
+			const value = this.lazy();
+			if ("then" in value) {
+				return value.then(data => {
+					if (timeMessage) {
+						this.logger.timeEnd(timeMessage);
+					}
+					this.content = data.map;
+				});
+			} else {
+				if (timeMessage) {
+					this.logger.timeEnd(timeMessage);
 				}
+				this.content = value.map;
 			}
-			this._hashUpdate = hashUpdate;
 		}
-		hash.update(this._hashUpdate);
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @returns {number} size of the content or -1 if not known
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.expression);
-		write(this.range);
-		write(this.runtimeRequirements);
-		super.serialize(context);
+	getSize() {
+		if (!this.lazy) return -1;
+		const options = /** @type {any} */ (this.lazy).options;
+		if (!options) return -1;
+		const size = options.size;
+		if (typeof size !== "number") return -1;
+		return size;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.expression = read();
-		this.range = read();
-		this.runtimeRequirements = read();
-		super.deserialize(context);
+	delete(identifier) {
+		this.items.delete(identifier);
+		this.used.delete(identifier);
+		this.outdated = true;
 	}
-}
-
-makeSerializable(ConstDependency, "webpack/lib/dependencies/ConstDependency");
 
-ConstDependency.Template = class ConstDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @template T
+	 * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {ConstDependency} */ (dependency);
-		if (dep.runtimeRequirements) {
-			for (const req of dep.runtimeRequirements) {
-				templateContext.runtimeRequirements.add(req);
-			}
+	writeLazy(write) {
+		if (!this.outdated && this.lazy) {
+			// State B1 or C1
+			// this.lazy is still the valid deserialized version
+			write(this.lazy);
+			return;
 		}
-		if (typeof dep.range === "number") {
-			source.insert(dep.range, dep.expression);
+		if (!this.outdated && this.content) {
+			// State A1
+			const map = new Map(this.content);
+			// Move to state C1
+			this.lazy = SerializerMiddleware.unMemoizeLazy(
+				write(() => new PackContentItems(map))
+			);
+			return;
+		}
+		if (this.content) {
+			// State A2 or C2
+			/** @type {Map<string, any>} */
+			const map = new Map();
+			for (const item of this.items) {
+				map.set(item, this.content.get(item));
+			}
+			// Move to state C1
+			this.outdated = false;
+			this.content = map;
+			this.lazy = SerializerMiddleware.unMemoizeLazy(
+				write(() => new PackContentItems(map))
+			);
 			return;
 		}
+		// State B2
+		const { lazyName } = this;
+		let timeMessage;
+		if (lazyName) {
+			// only log once
+			this.lazyName = undefined;
+			timeMessage = `unpack cache content ${lazyName} (${formatSize(
+				this.getSize()
+			)})`;
+			this.logger.log(
+				`starting to unpack cache content ${lazyName} (${formatSize(
+					this.getSize()
+				)}) because it's outdated and need to be serialized`
+			);
+			this.logger.time(timeMessage);
+		}
+		const value = this.lazy();
+		this.outdated = false;
+		if ("then" in value) {
+			// Move to state B1
+			this.lazy = write(() =>
+				value.then(data => {
+					if (timeMessage) {
+						this.logger.timeEnd(timeMessage);
+					}
+					const oldMap = data.map;
+					/** @type {Map<string, any>} */
+					const map = new Map();
+					for (const item of this.items) {
+						map.set(item, oldMap.get(item));
+					}
+					// Move to state C1 (or maybe C2)
+					this.content = map;
+					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 
-		source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
+					return new PackContentItems(map);
+				})
+			);
+		} else {
+			// Move to state C1
+			if (timeMessage) {
+				this.logger.timeEnd(timeMessage);
+			}
+			const oldMap = value.map;
+			/** @type {Map<string, any>} */
+			const map = new Map();
+			for (const item of this.items) {
+				map.set(item, oldMap.get(item));
+			}
+			this.content = map;
+			this.lazy = write(() => new PackContentItems(map));
+		}
 	}
-};
-
-module.exports = ConstDependency;
-
-
-/***/ }),
-
-/***/ 88101:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Dependency = __webpack_require__(54912);
-const DependencyTemplate = __webpack_require__(5160);
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
-
-const getCriticalDependencyWarning = memoize(() =>
-	__webpack_require__(15427)
-);
-
-/** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
+}
 
-const regExpToString = r => (r ? r + "" : "");
+const allowCollectingMemory = buf => {
+	const wasted = buf.buffer.byteLength - buf.byteLength;
+	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
+		return Buffer.from(buf);
+	}
+	return buf;
+};
 
-class ContextDependency extends Dependency {
+class PackFileCacheStrategy {
 	/**
-	 * @param {ContextDependencyOptions} options options for the context module
+	 * @param {Object} options options
+	 * @param {Compiler} options.compiler the compiler
+	 * @param {IntermediateFileSystem} options.fs the filesystem
+	 * @param {string} options.context the context directory
+	 * @param {string} options.cacheLocation the location of the cache data
+	 * @param {string} options.version version identifier
+	 * @param {Logger} options.logger a logger
+	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
+	 * @param {number} options.maxAge max age of cache items
+	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
+	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
+	 * @param {false | "gzip" | "brotli"} options.compression compression used
 	 */
-	constructor(options) {
-		super();
-
-		this.options = options;
-		this.userRequest = this.options && this.options.request;
-		/** @type {false | string} */
-		this.critical = false;
-		this.hadGlobalOrStickyRegExp = false;
-
-		if (
-			this.options &&
-			(this.options.regExp.global || this.options.regExp.sticky)
-		) {
-			this.options = { ...this.options, regExp: null };
-			this.hadGlobalOrStickyRegExp = true;
-		}
-
-		this.request = undefined;
-		this.range = undefined;
-		this.valueRange = undefined;
-		this.inShorthand = undefined;
-		// TODO refactor this
-		this.replaces = undefined;
+	constructor({
+		compiler,
+		fs,
+		context,
+		cacheLocation,
+		version,
+		logger,
+		snapshot,
+		maxAge,
+		profile,
+		allowCollectingMemory,
+		compression
+	}) {
+		this.fileSerializer = createFileSerializer(
+			fs,
+			compiler.options.output.hashFunction
+		);
+		this.fileSystemInfo = new FileSystemInfo(fs, {
+			managedPaths: snapshot.managedPaths,
+			immutablePaths: snapshot.immutablePaths,
+			logger: logger.getChildLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
+		});
+		this.compiler = compiler;
+		this.context = context;
+		this.cacheLocation = cacheLocation;
+		this.version = version;
+		this.logger = logger;
+		this.maxAge = maxAge;
+		this.profile = profile;
+		this.allowCollectingMemory = allowCollectingMemory;
+		this.compression = compression;
+		this._extension =
+			compression === "brotli"
+				? ".pack.br"
+				: compression === "gzip"
+				? ".pack.gz"
+				: ".pack";
+		this.snapshot = snapshot;
+		/** @type {Set<string>} */
+		this.buildDependencies = new Set();
+		/** @type {LazySet<string>} */
+		this.newBuildDependencies = new LazySet();
+		/** @type {Snapshot} */
+		this.resolveBuildDependenciesSnapshot = undefined;
+		/** @type {Map<string, string | false>} */
+		this.resolveResults = undefined;
+		/** @type {Snapshot} */
+		this.buildSnapshot = undefined;
+		/** @type {Promise<Pack>} */
+		this.packPromise = this._openPack();
+		this.storePromise = Promise.resolve();
 	}
 
-	get category() {
-		return "commonjs";
+	_getPack() {
+		if (this.packPromise === undefined) {
+			this.packPromise = this.storePromise.then(() => this._openPack());
+		}
+		return this.packPromise;
 	}
 
 	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 * @returns {Promise<Pack>} the pack
 	 */
-	couldAffectReferencingModule() {
-		return true;
+	_openPack() {
+		const { logger, profile, cacheLocation, version } = this;
+		/** @type {Snapshot} */
+		let buildSnapshot;
+		/** @type {Set<string>} */
+		let buildDependencies;
+		/** @type {Set<string>} */
+		let newBuildDependencies;
+		/** @type {Snapshot} */
+		let resolveBuildDependenciesSnapshot;
+		/** @type {Map<string, string | false>} */
+		let resolveResults;
+		logger.time("restore cache container");
+		return this.fileSerializer
+			.deserialize(null, {
+				filename: `${cacheLocation}/index${this._extension}`,
+				extension: `${this._extension}`,
+				logger,
+				profile,
+				retainedBuffer: this.allowCollectingMemory
+					? allowCollectingMemory
+					: undefined
+			})
+			.catch(err => {
+				if (err.code !== "ENOENT") {
+					logger.warn(
+						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
+					);
+					logger.debug(err.stack);
+				} else {
+					logger.debug(
+						`No pack exists at ${cacheLocation}${this._extension}: ${err}`
+					);
+				}
+				return undefined;
+			})
+			.then(packContainer => {
+				logger.timeEnd("restore cache container");
+				if (!packContainer) return undefined;
+				if (!(packContainer instanceof PackContainer)) {
+					logger.warn(
+						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
+						packContainer
+					);
+					return undefined;
+				}
+				if (packContainer.version !== version) {
+					logger.log(
+						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
+					);
+					return undefined;
+				}
+				logger.time("check build dependencies");
+				return Promise.all([
+					new Promise((resolve, reject) => {
+						this.fileSystemInfo.checkSnapshotValid(
+							packContainer.buildSnapshot,
+							(err, valid) => {
+								if (err) {
+									logger.log(
+										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.`
+									);
+									logger.debug(err.stack);
+									return resolve(false);
+								}
+								if (!valid) {
+									logger.log(
+										`Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.`
+									);
+									return resolve(false);
+								}
+								buildSnapshot = packContainer.buildSnapshot;
+								return resolve(true);
+							}
+						);
+					}),
+					new Promise((resolve, reject) => {
+						this.fileSystemInfo.checkSnapshotValid(
+							packContainer.resolveBuildDependenciesSnapshot,
+							(err, valid) => {
+								if (err) {
+									logger.log(
+										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.`
+									);
+									logger.debug(err.stack);
+									return resolve(false);
+								}
+								if (valid) {
+									resolveBuildDependenciesSnapshot =
+										packContainer.resolveBuildDependenciesSnapshot;
+									buildDependencies = packContainer.buildDependencies;
+									resolveResults = packContainer.resolveResults;
+									return resolve(true);
+								}
+								logger.log(
+									"resolving of build dependencies is invalid, will re-resolve build dependencies"
+								);
+								this.fileSystemInfo.checkResolveResultsValid(
+									packContainer.resolveResults,
+									(err, valid) => {
+										if (err) {
+											logger.log(
+												`Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.`
+											);
+											logger.debug(err.stack);
+											return resolve(false);
+										}
+										if (valid) {
+											newBuildDependencies = packContainer.buildDependencies;
+											resolveResults = packContainer.resolveResults;
+											return resolve(true);
+										}
+										logger.log(
+											`Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.`
+										);
+										return resolve(false);
+									}
+								);
+							}
+						);
+					})
+				])
+					.catch(err => {
+						logger.timeEnd("check build dependencies");
+						throw err;
+					})
+					.then(([buildSnapshotValid, resolveValid]) => {
+						logger.timeEnd("check build dependencies");
+						if (buildSnapshotValid && resolveValid) {
+							logger.time("restore cache content metadata");
+							const d = packContainer.data();
+							logger.timeEnd("restore cache content metadata");
+							return d;
+						}
+						return undefined;
+					});
+			})
+			.then(pack => {
+				if (pack) {
+					pack.maxAge = this.maxAge;
+					this.buildSnapshot = buildSnapshot;
+					if (buildDependencies) this.buildDependencies = buildDependencies;
+					if (newBuildDependencies)
+						this.newBuildDependencies.addAll(newBuildDependencies);
+					this.resolveResults = resolveResults;
+					this.resolveBuildDependenciesSnapshot =
+						resolveBuildDependenciesSnapshot;
+					return pack;
+				}
+				return new Pack(logger, this.maxAge);
+			})
+			.catch(err => {
+				this.logger.warn(
+					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
+				);
+				this.logger.debug(err.stack);
+				return new Pack(logger, this.maxAge);
+			});
 	}
 
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * @param {string} identifier unique name for the resource
+	 * @param {Etag | null} etag etag of the resource
+	 * @param {any} data cached content
+	 * @returns {Promise<void>} promise
 	 */
-	getResourceIdentifier() {
-		return (
-			`context${this.options.request} ${this.options.recursive} ` +
-			`${regExpToString(this.options.regExp)} ${regExpToString(
-				this.options.include
-			)} ${regExpToString(this.options.exclude)} ` +
-			`${this.options.mode} ${this.options.chunkName} ` +
-			`${JSON.stringify(this.options.groupOptions)}`
-		);
+	store(identifier, etag, data) {
+		return this._getPack().then(pack => {
+			pack.set(identifier, etag === null ? null : etag.toString(), data);
+		});
 	}
 
 	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
+	 * @param {string} identifier unique name for the resource
+	 * @param {Etag | null} etag etag of the resource
+	 * @returns {Promise<any>} promise to the cached content
 	 */
-	getWarnings(moduleGraph) {
-		let warnings = super.getWarnings(moduleGraph);
-
-		if (this.critical) {
-			if (!warnings) warnings = [];
-			const CriticalDependencyWarning = getCriticalDependencyWarning();
-			warnings.push(new CriticalDependencyWarning(this.critical));
-		}
-
-		if (this.hadGlobalOrStickyRegExp) {
-			if (!warnings) warnings = [];
-			const CriticalDependencyWarning = getCriticalDependencyWarning();
-			warnings.push(
-				new CriticalDependencyWarning(
-					"Contexts can't use RegExps with the 'g' or 'y' flags."
-				)
-			);
-		}
-
-		return warnings;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.options);
-		write(this.userRequest);
-		write(this.critical);
-		write(this.hadGlobalOrStickyRegExp);
-		write(this.request);
-		write(this.range);
-		write(this.valueRange);
-		write(this.prepend);
-		write(this.replaces);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.options = read();
-		this.userRequest = read();
-		this.critical = read();
-		this.hadGlobalOrStickyRegExp = read();
-		this.request = read();
-		this.range = read();
-		this.valueRange = read();
-		this.prepend = read();
-		this.replaces = read();
-
-		super.deserialize(context);
+	restore(identifier, etag) {
+		return this._getPack()
+			.then(pack =>
+				pack.get(identifier, etag === null ? null : etag.toString())
+			)
+			.catch(err => {
+				if (err && err.code !== "ENOENT") {
+					this.logger.warn(
+						`Restoring failed for ${identifier} from pack: ${err}`
+					);
+					this.logger.debug(err.stack);
+				}
+			});
 	}
-}
-
-makeSerializable(
-	ContextDependency,
-	"webpack/lib/dependencies/ContextDependency"
-);
-
-ContextDependency.Template = DependencyTemplate;
-
-module.exports = ContextDependency;
-
-
-/***/ }),
-
-/***/ 99630:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { parseResource } = __webpack_require__(82186);
-
-/** @typedef {import("estree").Node} EsTreeNode */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./ContextDependency")} ContextDependency */
-/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
-/**
- * Escapes regular expression metacharacters
- * @param {string} str String to quote
- * @returns {string} Escaped string
- */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
-
-const splitContextFromPrefix = prefix => {
-	const idx = prefix.lastIndexOf("/");
-	let context = ".";
-	if (idx >= 0) {
-		context = prefix.substr(0, idx);
-		prefix = `.${prefix.substr(idx)}`;
+	storeBuildDependencies(dependencies) {
+		this.newBuildDependencies.addAll(dependencies);
 	}
-	return {
-		context,
-		prefix
-	};
-};
-
-/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
-
-/** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
-
-/**
- * @param {ContextDependencyConstructor} Dep the Dependency class
- * @param {[number, number]} range source range
- * @param {BasicEvaluatedExpression} param context param
- * @param {EsTreeNode} expr expr
- * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
- * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
- * @param {JavascriptParser} parser the parser
- * @returns {ContextDependency} the created Dependency
- */
-exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
-	if (param.isTemplateString()) {
-		let prefixRaw = param.quasis[0].string;
-		let postfixRaw =
-			param.quasis.length > 1
-				? param.quasis[param.quasis.length - 1].string
-				: "";
 
-		const valueRange = param.range;
-		const { context, prefix } = splitContextFromPrefix(prefixRaw);
-		const {
-			path: postfix,
-			query,
-			fragment
-		} = parseResource(postfixRaw, parser);
+	afterAllStored() {
+		const packPromise = this.packPromise;
+		if (packPromise === undefined) return Promise.resolve();
+		const reportProgress = ProgressPlugin.getReporter(this.compiler);
+		return (this.storePromise = packPromise
+			.then(pack => {
+				pack.stopCapturingRequests();
+				if (!pack.invalid) return;
+				this.packPromise = undefined;
+				this.logger.log(`Storing pack...`);
+				let promise;
+				const newBuildDependencies = new Set();
+				for (const dep of this.newBuildDependencies) {
+					if (!this.buildDependencies.has(dep)) {
+						newBuildDependencies.add(dep);
+					}
+				}
+				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
+					if (reportProgress) reportProgress(0.5, "resolve build dependencies");
+					this.logger.debug(
+						`Capturing build dependencies... (${Array.from(
+							newBuildDependencies
+						).join(", ")})`
+					);
+					promise = new Promise((resolve, reject) => {
+						this.logger.time("resolve build dependencies");
+						this.fileSystemInfo.resolveBuildDependencies(
+							this.context,
+							newBuildDependencies,
+							(err, result) => {
+								this.logger.timeEnd("resolve build dependencies");
+								if (err) return reject(err);
 
-		// When there are more than two quasis, the generated RegExp can be more precise
-		// We join the quasis with the expression regexp
-		const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
-		const innerRegExp =
-			options.wrappedContextRegExp.source +
-			innerQuasis
-				.map(q => quoteMeta(q.string) + options.wrappedContextRegExp.source)
-				.join("");
+								this.logger.time("snapshot build dependencies");
+								const {
+									files,
+									directories,
+									missing,
+									resolveResults,
+									resolveDependencies
+								} = result;
+								if (this.resolveResults) {
+									for (const [key, value] of resolveResults) {
+										this.resolveResults.set(key, value);
+									}
+								} else {
+									this.resolveResults = resolveResults;
+								}
+								if (reportProgress) {
+									reportProgress(
+										0.6,
+										"snapshot build dependencies",
+										"resolving"
+									);
+								}
+								this.fileSystemInfo.createSnapshot(
+									undefined,
+									resolveDependencies.files,
+									resolveDependencies.directories,
+									resolveDependencies.missing,
+									this.snapshot.resolveBuildDependencies,
+									(err, snapshot) => {
+										if (err) {
+											this.logger.timeEnd("snapshot build dependencies");
+											return reject(err);
+										}
+										if (!snapshot) {
+											this.logger.timeEnd("snapshot build dependencies");
+											return reject(
+												new Error("Unable to snapshot resolve dependencies")
+											);
+										}
+										if (this.resolveBuildDependenciesSnapshot) {
+											this.resolveBuildDependenciesSnapshot =
+												this.fileSystemInfo.mergeSnapshots(
+													this.resolveBuildDependenciesSnapshot,
+													snapshot
+												);
+										} else {
+											this.resolveBuildDependenciesSnapshot = snapshot;
+										}
+										if (reportProgress) {
+											reportProgress(
+												0.7,
+												"snapshot build dependencies",
+												"modules"
+											);
+										}
+										this.fileSystemInfo.createSnapshot(
+											undefined,
+											files,
+											directories,
+											missing,
+											this.snapshot.buildDependencies,
+											(err, snapshot) => {
+												this.logger.timeEnd("snapshot build dependencies");
+												if (err) return reject(err);
+												if (!snapshot) {
+													return reject(
+														new Error("Unable to snapshot build dependencies")
+													);
+												}
+												this.logger.debug("Captured build dependencies");
 
-		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
-		// context: "./context"
-		// prefix: "./pre"
-		// innerQuasis: [BEE("inner"), BEE("inner2")]
-		// (BEE = BasicEvaluatedExpression)
-		// postfix: "post"
-		// query: "?query"
-		// fragment: "#frag"
-		// regExp: /^\.\/pre.*inner.*inner2.*post$/
-		const regExp = new RegExp(
-			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
-		);
-		const dep = new Dep(
-			{
-				request: context + query + fragment,
-				recursive: options.wrappedContextRecursive,
-				regExp,
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			valueRange
-		);
-		dep.loc = expr.loc;
-		const replaces = [];
+												if (this.buildSnapshot) {
+													this.buildSnapshot =
+														this.fileSystemInfo.mergeSnapshots(
+															this.buildSnapshot,
+															snapshot
+														);
+												} else {
+													this.buildSnapshot = snapshot;
+												}
 
-		param.parts.forEach((part, i) => {
-			if (i % 2 === 0) {
-				// Quasis or merged quasi
-				let range = part.range;
-				let value = part.string;
-				if (param.templateStringKind === "cooked") {
-					value = JSON.stringify(value);
-					value = value.slice(1, value.length - 1);
-				}
-				if (i === 0) {
-					// prefix
-					value = prefix;
-					range = [param.range[0], part.range[1]];
-					value =
-						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
-						value;
-				} else if (i === param.parts.length - 1) {
-					// postfix
-					value = postfix;
-					range = [part.range[0], param.range[1]];
-					value = value + "`";
-				} else if (
-					part.expression &&
-					part.expression.type === "TemplateElement" &&
-					part.expression.value.raw === value
-				) {
-					// Shortcut when it's a single quasi and doesn't need to be replaced
-					return;
+												resolve();
+											}
+										);
+									}
+								);
+							}
+						);
+					});
+				} else {
+					promise = Promise.resolve();
 				}
-				replaces.push({
-					range,
-					value
+				return promise.then(() => {
+					if (reportProgress) reportProgress(0.8, "serialize pack");
+					this.logger.time(`store pack`);
+					const updatedBuildDependencies = new Set(this.buildDependencies);
+					for (const dep of newBuildDependencies) {
+						updatedBuildDependencies.add(dep);
+					}
+					const content = new PackContainer(
+						pack,
+						this.version,
+						this.buildSnapshot,
+						updatedBuildDependencies,
+						this.resolveResults,
+						this.resolveBuildDependenciesSnapshot
+					);
+					return this.fileSerializer
+						.serialize(content, {
+							filename: `${this.cacheLocation}/index${this._extension}`,
+							extension: `${this._extension}`,
+							logger: this.logger,
+							profile: this.profile
+						})
+						.then(() => {
+							for (const dep of newBuildDependencies) {
+								this.buildDependencies.add(dep);
+							}
+							this.newBuildDependencies.clear();
+							this.logger.timeEnd(`store pack`);
+							const stats = pack.getContentStats();
+							this.logger.log(
+								"Stored pack (%d items, %d files, %d MiB)",
+								pack.itemInfo.size,
+								stats.count,
+								Math.round(stats.size / 1024 / 1024)
+							);
+						})
+						.catch(err => {
+							this.logger.timeEnd(`store pack`);
+							this.logger.warn(`Caching failed for pack: ${err}`);
+							this.logger.debug(err.stack);
+						});
 				});
-			} else {
-				// Expression
-				parser.walkExpression(part.expression);
-			}
-		});
-
-		dep.replaces = replaces;
-		dep.critical =
-			options.wrappedContextCritical &&
-			"a part of the request of a dependency is an expression";
-		return dep;
-	} else if (
-		param.isWrapped() &&
-		((param.prefix && param.prefix.isString()) ||
-			(param.postfix && param.postfix.isString()))
-	) {
-		let prefixRaw =
-			param.prefix && param.prefix.isString() ? param.prefix.string : "";
-		let postfixRaw =
-			param.postfix && param.postfix.isString() ? param.postfix.string : "";
-		const prefixRange =
-			param.prefix && param.prefix.isString() ? param.prefix.range : null;
-		const postfixRange =
-			param.postfix && param.postfix.isString() ? param.postfix.range : null;
-		const valueRange = param.range;
-		const { context, prefix } = splitContextFromPrefix(prefixRaw);
-		const {
-			path: postfix,
-			query,
-			fragment
-		} = parseResource(postfixRaw, parser);
-		const regExp = new RegExp(
-			`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(
-				postfix
-			)}$`
-		);
-		const dep = new Dep(
-			{
-				request: context + query + fragment,
-				recursive: options.wrappedContextRecursive,
-				regExp,
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			valueRange
-		);
-		dep.loc = expr.loc;
-		const replaces = [];
-		if (prefixRange) {
-			replaces.push({
-				range: prefixRange,
-				value: JSON.stringify(prefix)
-			});
-		}
-		if (postfixRange) {
-			replaces.push({
-				range: postfixRange,
-				value: JSON.stringify(postfix)
-			});
-		}
-		dep.replaces = replaces;
-		dep.critical =
-			options.wrappedContextCritical &&
-			"a part of the request of a dependency is an expression";
-
-		if (parser && param.wrappedInnerExpressions) {
-			for (const part of param.wrappedInnerExpressions) {
-				if (part.expression) parser.walkExpression(part.expression);
-			}
-		}
-
-		return dep;
-	} else {
-		const dep = new Dep(
-			{
-				request: options.exprContextRequest,
-				recursive: options.exprContextRecursive,
-				regExp: /** @type {RegExp} */ (options.exprContextRegExp),
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			param.range
-		);
-		dep.loc = expr.loc;
-		dep.critical =
-			options.exprContextCritical &&
-			"the request of a dependency is an expression";
-
-		parser.walkExpression(param.expression);
+			})
+			.catch(err => {
+				this.logger.warn(`Caching failed for pack: ${err}`);
+				this.logger.debug(err.stack);
+			}));
+	}
 
-		return dep;
+	clear() {
+		this.fileSystemInfo.clear();
+		this.buildDependencies.clear();
+		this.newBuildDependencies.clear();
+		this.resolveBuildDependenciesSnapshot = undefined;
+		this.resolveResults = undefined;
+		this.buildSnapshot = undefined;
+		this.packPromise = undefined;
 	}
-};
+}
+
+module.exports = PackFileCacheStrategy;
 
 
 /***/ }),
 
-/***/ 76081:
+/***/ 97347:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -75000,132 +69760,297 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 
 
 
-const ContextDependency = __webpack_require__(88101);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+const LazySet = __webpack_require__(38938);
+const makeSerializable = __webpack_require__(33032);
 
-class ContextDependencyTemplateAsId extends ContextDependency.Template {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ContextDependency} */ (dependency);
-		const moduleExports = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
 
-		if (moduleGraph.getModule(dep)) {
-			if (dep.valueRange) {
-				if (Array.isArray(dep.replaces)) {
-					for (let i = 0; i < dep.replaces.length; i++) {
-						const rep = dep.replaces[i];
-						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
-					}
-				}
-				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-				source.replace(
-					dep.range[0],
-					dep.valueRange[0] - 1,
-					`${moduleExports}.resolve(`
-				);
-			} else {
-				source.replace(
-					dep.range[0],
-					dep.range[1] - 1,
-					`${moduleExports}.resolve`
-				);
-			}
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
-		}
+class CacheEntry {
+	constructor(result, snapshot) {
+		this.result = result;
+		this.snapshot = snapshot;
 	}
-}
-module.exports = ContextDependencyTemplateAsId;
-
-
-/***/ }),
-
-/***/ 75815:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	serialize({ write }) {
+		write(this.result);
+		write(this.snapshot);
+	}
 
+	deserialize({ read }) {
+		this.result = read();
+		this.snapshot = read();
+	}
+}
 
+makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin");
 
-const ContextDependency = __webpack_require__(88101);
+/**
+ * @template T
+ * @param {Set<T> | LazySet<T>} set set to add items to
+ * @param {Set<T> | LazySet<T>} otherSet set to add items from
+ * @returns {void}
+ */
+const addAllToSet = (set, otherSet) => {
+	if (set instanceof LazySet) {
+		set.addAll(otherSet);
+	} else {
+		for (const item of otherSet) {
+			set.add(item);
+		}
+	}
+};
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/**
+ * @param {Object} object an object
+ * @param {boolean} excludeContext if true, context is not included in string
+ * @returns {string} stringified version
+ */
+const objectToString = (object, excludeContext) => {
+	let str = "";
+	for (const key in object) {
+		if (excludeContext && key === "context") continue;
+		const value = object[key];
+		if (typeof value === "object" && value !== null) {
+			str += `|${key}=[${objectToString(value, false)}|]`;
+		} else {
+			str += `|${key}=|${value}`;
+		}
+	}
+	return str;
+};
 
-class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template {
+class ResolverCachePlugin {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ContextDependency} */ (dependency);
-		let moduleExports = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			runtimeRequirements
+	apply(compiler) {
+		const cache = compiler.getCache("ResolverCachePlugin");
+		/** @type {FileSystemInfo} */
+		let fileSystemInfo;
+		let snapshotOptions;
+		let realResolves = 0;
+		let cachedResolves = 0;
+		let cacheInvalidResolves = 0;
+		let concurrentResolves = 0;
+		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+			snapshotOptions = compilation.options.snapshot.resolve;
+			fileSystemInfo = compilation.fileSystemInfo;
+			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+				if (realResolves + cachedResolves > 0) {
+					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					logger.log(
+						`${Math.round(
+							(100 * realResolves) / (realResolves + cachedResolves)
+						)}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)`
+					);
+					realResolves = 0;
+					cachedResolves = 0;
+					cacheInvalidResolves = 0;
+					concurrentResolves = 0;
+				}
+			});
 		});
+		/**
+		 * @param {ItemCacheFacade} itemCache cache
+		 * @param {Resolver} resolver the resolver
+		 * @param {Object} resolveContext context for resolving meta info
+		 * @param {Object} request the request info object
+		 * @param {function((Error | null)=, Object=): void} callback callback function
+		 * @returns {void}
+		 */
+		const doRealResolve = (
+			itemCache,
+			resolver,
+			resolveContext,
+			request,
+			callback
+		) => {
+			realResolves++;
+			const newRequest = {
+				_ResolverCachePluginCacheMiss: true,
+				...request
+			};
+			const newResolveContext = {
+				...resolveContext,
+				stack: new Set(),
+				missingDependencies: new LazySet(),
+				fileDependencies: new LazySet(),
+				contextDependencies: new LazySet()
+			};
+			const propagate = key => {
+				if (resolveContext[key]) {
+					addAllToSet(resolveContext[key], newResolveContext[key]);
+				}
+			};
+			const resolveTime = Date.now();
+			resolver.doResolve(
+				resolver.hooks.resolve,
+				newRequest,
+				"Cache miss",
+				newResolveContext,
+				(err, result) => {
+					propagate("fileDependencies");
+					propagate("contextDependencies");
+					propagate("missingDependencies");
+					if (err) return callback(err);
+					const fileDependencies = newResolveContext.fileDependencies;
+					const contextDependencies = newResolveContext.contextDependencies;
+					const missingDependencies = newResolveContext.missingDependencies;
+					fileSystemInfo.createSnapshot(
+						resolveTime,
+						fileDependencies,
+						contextDependencies,
+						missingDependencies,
+						snapshotOptions,
+						(err, snapshot) => {
+							if (err) return callback(err);
+							if (!snapshot) {
+								if (result) return callback(null, result);
+								return callback();
+							}
+							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
+								if (storeErr) return callback(storeErr);
+								if (result) return callback(null, result);
+								callback();
+							});
+						}
+					);
+				}
+			);
+		};
+		compiler.resolverFactory.hooks.resolver.intercept({
+			factory(type, hook) {
+				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
+				const activeRequests = new Map();
+				hook.tap(
+					"ResolverCachePlugin",
+					/**
+					 * @param {Resolver} resolver the resolver
+					 * @param {Object} options resolve options
+					 * @param {Object} userOptions resolve options passed by the user
+					 * @returns {void}
+					 */
+					(resolver, options, userOptions) => {
+						if (options.cache !== true) return;
+						const optionsIdent = objectToString(userOptions, false);
+						const cacheWithContext =
+							options.cacheWithContext !== undefined
+								? options.cacheWithContext
+								: false;
+						resolver.hooks.resolve.tapAsync(
+							{
+								name: "ResolverCachePlugin",
+								stage: -100
+							},
+							(request, resolveContext, callback) => {
+								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
+									return callback();
+								}
+								const identifier = `${type}${optionsIdent}${objectToString(
+									request,
+									!cacheWithContext
+								)}`;
+								const activeRequest = activeRequests.get(identifier);
+								if (activeRequest) {
+									activeRequest.push(callback);
+									return;
+								}
+								const itemCache = cache.getItemCache(identifier, null);
+								let callbacks;
+								const done = (err, result) => {
+									if (callbacks === undefined) {
+										callback(err, result);
+										callbacks = false;
+									} else {
+										for (const callback of callbacks) {
+											callback(err, result);
+										}
+										activeRequests.delete(identifier);
+										callbacks = false;
+									}
+								};
+								/**
+								 * @param {Error=} err error if any
+								 * @param {CacheEntry=} cacheEntry cache entry
+								 * @returns {void}
+								 */
+								const processCacheResult = (err, cacheEntry) => {
+									if (err) return done(err);
 
-		if (dep.inShorthand) {
-			moduleExports = `${dep.inShorthand}: ${moduleExports}`;
-		}
-		if (moduleGraph.getModule(dep)) {
-			if (dep.valueRange) {
-				if (Array.isArray(dep.replaces)) {
-					for (let i = 0; i < dep.replaces.length; i++) {
-						const rep = dep.replaces[i];
-						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+									if (cacheEntry) {
+										const { snapshot, result } = cacheEntry;
+										fileSystemInfo.checkSnapshotValid(
+											snapshot,
+											(err, valid) => {
+												if (err || !valid) {
+													cacheInvalidResolves++;
+													return doRealResolve(
+														itemCache,
+														resolver,
+														resolveContext,
+														request,
+														done
+													);
+												}
+												cachedResolves++;
+												if (resolveContext.missingDependencies) {
+													addAllToSet(
+														resolveContext.missingDependencies,
+														snapshot.getMissingIterable()
+													);
+												}
+												if (resolveContext.fileDependencies) {
+													addAllToSet(
+														resolveContext.fileDependencies,
+														snapshot.getFileIterable()
+													);
+												}
+												if (resolveContext.contextDependencies) {
+													addAllToSet(
+														resolveContext.contextDependencies,
+														snapshot.getContextIterable()
+													);
+												}
+												done(null, result);
+											}
+										);
+									} else {
+										doRealResolve(
+											itemCache,
+											resolver,
+											resolveContext,
+											request,
+											done
+										);
+									}
+								};
+								itemCache.get(processCacheResult);
+								if (callbacks === undefined) {
+									callbacks = [callback];
+									activeRequests.set(identifier, callbacks);
+								}
+							}
+						);
 					}
-				}
-				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-				source.replace(
-					dep.range[0],
-					dep.valueRange[0] - 1,
-					`${moduleExports}(`
 				);
-			} else {
-				source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+				return hook;
 			}
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
-		}
+		});
 	}
 }
-module.exports = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ResolverCachePlugin;
 
 
 /***/ }),
 
-/***/ 58477:
+/***/ 94075:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -75136,76 +70061,86 @@ module.exports = ContextDependencyTemplateAsRequireCall;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class ContextElementDependency extends ModuleDependency {
-	constructor(request, userRequest, typePrefix, category, referencedExports) {
-		super(request);
-		this.referencedExports = referencedExports;
-		this._typePrefix = typePrefix;
-		this._category = category;
-
-		if (userRequest) {
-			this.userRequest = userRequest;
-		}
-	}
+const createHash = __webpack_require__(49835);
 
-	get type() {
-		if (this._typePrefix) {
-			return `${this._typePrefix} context element`;
-		}
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
 
-		return "context element";
-	}
+/**
+ * @typedef {Object} HashableObject
+ * @property {function(Hash): void} updateHash
+ */
 
-	get category() {
-		return this._category;
+class LazyHashedEtag {
+	/**
+	 * @param {HashableObject} obj object with updateHash method
+	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 */
+	constructor(obj, hashFunction = "md4") {
+		this._obj = obj;
+		this._hash = undefined;
+		this._hashFunction = hashFunction;
 	}
 
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {string} hash of object
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return this.referencedExports
-			? this.referencedExports.map(e => ({
-					name: e,
-					canMangle: false
-			  }))
-			: Dependency.EXPORTS_OBJECT_REFERENCED;
+	toString() {
+		if (this._hash === undefined) {
+			const hash = createHash(this._hashFunction);
+			this._obj.updateHash(hash);
+			this._hash = /** @type {string} */ (hash.digest("base64"));
+		}
+		return this._hash;
 	}
+}
 
-	serialize(context) {
-		context.write(this.referencedExports);
-		super.serialize(context);
-	}
+/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapStrings = new Map();
 
-	deserialize(context) {
-		this.referencedExports = context.read();
-		super.deserialize(context);
-	}
-}
+/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapObjects = new WeakMap();
 
-makeSerializable(
-	ContextElementDependency,
-	"webpack/lib/dependencies/ContextElementDependency"
-);
+/**
+ * @param {HashableObject} obj object with updateHash method
+ * @param {string | HashConstructor} hashFunction the hash function to use
+ * @returns {LazyHashedEtag} etag
+ */
+const getter = (obj, hashFunction = "md4") => {
+	let innerMap;
+	if (typeof hashFunction === "string") {
+		innerMap = mapStrings.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapStrings.set(hashFunction, innerMap);
+			return newHash;
+		}
+	} else {
+		innerMap = mapObjects.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapObjects.set(hashFunction, innerMap);
+			return newHash;
+		}
+	}
+	const hash = innerMap.get(obj);
+	if (hash !== undefined) return hash;
+	const newHash = new LazyHashedEtag(obj, hashFunction);
+	innerMap.set(obj, newHash);
+	return newHash;
+};
 
-module.exports = ContextElementDependency;
+module.exports = getter;
 
 
 /***/ }),
 
-/***/ 79062:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 54980:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -75215,71 +70150,79 @@ module.exports = ContextElementDependency;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-
-class CreateScriptUrlDependency extends NullDependency {
-	/**
-	 * @param {[number, number]} range range
-	 */
-	constructor(range) {
-		super();
-		this.range = range;
-	}
-
-	get type() {
-		return "create script url";
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		super.serialize(context);
+/** @typedef {import("../Cache").Etag} Etag */
+
+class MergedEtag {
+	/**
+	 * @param {Etag} a first
+	 * @param {Etag} b second
+	 */
+	constructor(a, b) {
+		this.a = a;
+		this.b = b;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		super.deserialize(context);
+	toString() {
+		return `${this.a.toString()}|${this.b.toString()}`;
 	}
 }
 
-CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {CreateScriptUrlDependency} */ (dependency);
-
-		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+const dualObjectMap = new WeakMap();
+const objectStringMap = new WeakMap();
 
-		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
-		source.insert(dep.range[1], ")");
+/**
+ * @param {Etag} a first
+ * @param {Etag} b second
+ * @returns {Etag} result
+ */
+const mergeEtags = (a, b) => {
+	if (typeof a === "string") {
+		if (typeof b === "string") {
+			return `${a}|${b}`;
+		} else {
+			const temp = b;
+			b = a;
+			a = temp;
+		}
+	} else {
+		if (typeof b !== "string") {
+			// both a and b are objects
+			let map = dualObjectMap.get(a);
+			if (map === undefined) {
+				dualObjectMap.set(a, (map = new WeakMap()));
+			}
+			const mergedEtag = map.get(b);
+			if (mergedEtag === undefined) {
+				const newMergedEtag = new MergedEtag(a, b);
+				map.set(b, newMergedEtag);
+				return newMergedEtag;
+			} else {
+				return mergedEtag;
+			}
+		}
+	}
+	// a is object, b is string
+	let map = objectStringMap.get(a);
+	if (map === undefined) {
+		objectStringMap.set(a, (map = new Map()));
+	}
+	const mergedEtag = map.get(b);
+	if (mergedEtag === undefined) {
+		const newMergedEtag = new MergedEtag(a, b);
+		map.set(b, newMergedEtag);
+		return newMergedEtag;
+	} else {
+		return mergedEtag;
 	}
 };
 
-makeSerializable(
-	CreateScriptUrlDependency,
-	"webpack/lib/dependencies/CreateScriptUrlDependency"
-);
-
-module.exports = CreateScriptUrlDependency;
+module.exports = mergeEtags;
 
 
 /***/ }),
 
-/***/ 15427:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 13462:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -75289,1120 +70232,2314 @@ module.exports = CreateScriptUrlDependency;
 
 
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+const path = __webpack_require__(71017);
+const webpackSchema = __webpack_require__(73342);
 
-class CriticalDependencyWarning extends WebpackError {
-	constructor(message) {
-		super();
+// TODO add originPath to PathItem for better errors
+/**
+ * @typedef {Object} PathItem
+ * @property {any} schema the part of the schema
+ * @property {string} path the path in the config
+ */
 
-		this.name = "CriticalDependencyWarning";
-		this.message = "Critical dependency: " + message;
-	}
-}
+/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
 
-makeSerializable(
-	CriticalDependencyWarning,
-	"webpack/lib/dependencies/CriticalDependencyWarning"
-);
+/**
+ * @typedef {Object} Problem
+ * @property {ProblemType} type
+ * @property {string} path
+ * @property {string} argument
+ * @property {any=} value
+ * @property {number=} index
+ * @property {string=} expected
+ */
 
-module.exports = CriticalDependencyWarning;
+/**
+ * @typedef {Object} LocalProblem
+ * @property {ProblemType} type
+ * @property {string} path
+ * @property {string=} expected
+ */
 
+/**
+ * @typedef {Object} ArgumentConfig
+ * @property {string} description
+ * @property {string} [negatedDescription]
+ * @property {string} path
+ * @property {boolean} multiple
+ * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
+ * @property {any[]=} values
+ */
 
-/***/ }),
+/**
+ * @typedef {Object} Argument
+ * @property {string} description
+ * @property {"string"|"number"|"boolean"} simpleType
+ * @property {boolean} multiple
+ * @property {ArgumentConfig[]} configs
+ */
 
-/***/ 76760:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {any=} schema a json schema to create arguments for (by default webpack schema is used)
+ * @returns {Record<string, Argument>} object of arguments
+ */
+const getArguments = (schema = webpackSchema) => {
+	/** @type {Record<string, Argument>} */
+	const flags = {};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+	const pathToArgumentName = input => {
+		return input
+			.replace(/\./g, "-")
+			.replace(/\[\]/g, "")
+			.replace(
+				/(\p{Uppercase_Letter}+|\p{Lowercase_Letter}|\d)(\p{Uppercase_Letter}+)/gu,
+				"$1-$2"
+			)
+			.replace(/-?[^\p{Uppercase_Letter}\p{Lowercase_Letter}\d]+/gu, "-")
+			.toLowerCase();
+	};
 
+	const getSchemaPart = path => {
+		const newPath = path.split("/");
 
+		let schemaPart = schema;
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+		for (let i = 1; i < newPath.length; i++) {
+			const inner = schemaPart[newPath[i]];
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+			if (!inner) {
+				break;
+			}
+
+			schemaPart = inner;
+		}
+
+		return schemaPart;
+	};
 
-class CssExportDependency extends NullDependency {
 	/**
-	 * @param {string} name name
-	 * @param {string} value value
+	 *
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {string | undefined} description
 	 */
-	constructor(name, value) {
-		super();
-		this.name = name;
-		this.value = value;
-	}
+	const getDescription = path => {
+		for (const { schema } of path) {
+			if (schema.cli) {
+				if (schema.cli.helper) continue;
+				if (schema.cli.description) return schema.cli.description;
+			}
+			if (schema.description) return schema.description;
+		}
+	};
 
-	get type() {
-		return "css :export";
-	}
+	/**
+	 *
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {string | undefined} negative description
+	 */
+	const getNegatedDescription = path => {
+		for (const { schema } of path) {
+			if (schema.cli) {
+				if (schema.cli.helper) continue;
+				if (schema.cli.negatedDescription) return schema.cli.negatedDescription;
+			}
+		}
+	};
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 *
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {string | undefined} reset description
 	 */
-	getExports(moduleGraph) {
-		const name = this.name;
-		return {
-			exports: [
+	const getResetDescription = path => {
+		for (const { schema } of path) {
+			if (schema.cli) {
+				if (schema.cli.helper) continue;
+				if (schema.cli.resetDescription) return schema.cli.resetDescription;
+			}
+		}
+	};
+
+	/**
+	 *
+	 * @param {any} schemaPart schema
+	 * @returns {Pick<ArgumentConfig, "type"|"values">} partial argument config
+	 */
+	const schemaToArgumentConfig = schemaPart => {
+		if (schemaPart.enum) {
+			return {
+				type: "enum",
+				values: schemaPart.enum
+			};
+		}
+		switch (schemaPart.type) {
+			case "number":
+				return {
+					type: "number"
+				};
+			case "string":
+				return {
+					type: schemaPart.absolutePath ? "path" : "string"
+				};
+			case "boolean":
+				return {
+					type: "boolean"
+				};
+		}
+		if (schemaPart.instanceof === "RegExp") {
+			return {
+				type: "RegExp"
+			};
+		}
+		return undefined;
+	};
+
+	/**
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {void}
+	 */
+	const addResetFlag = path => {
+		const schemaPath = path[0].path;
+		const name = pathToArgumentName(`${schemaPath}.reset`);
+		const description =
+			getResetDescription(path) ||
+			`Clear all items provided in '${schemaPath}' configuration. ${getDescription(
+				path
+			)}`;
+		flags[name] = {
+			configs: [
 				{
-					name,
-					canMangle: true
+					type: "reset",
+					multiple: false,
+					description,
+					path: schemaPath
 				}
 			],
-			dependencies: undefined
+			description: undefined,
+			simpleType: undefined,
+			multiple: undefined
 		};
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.name);
-		write(this.value);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.name = read();
-		this.value = read();
-		super.deserialize(context);
-	}
-}
+	};
 
-CssExportDependency.Template = class CssExportDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {PathItem[]} path full path in schema
+	 * @param {boolean} multiple inside of an array
+	 * @returns {number} number of arguments added
 	 */
-	apply(dependency, source, { cssExports }) {
-		const dep = /** @type {CssExportDependency} */ (dependency);
-		cssExports.set(dep.name, dep.value);
-	}
-};
+	const addFlag = (path, multiple) => {
+		const argConfigBase = schemaToArgumentConfig(path[0].schema);
+		if (!argConfigBase) return 0;
 
-makeSerializable(
-	CssExportDependency,
-	"webpack/lib/dependencies/CssExportDependency"
-);
+		const negatedDescription = getNegatedDescription(path);
+		const name = pathToArgumentName(path[0].path);
+		/** @type {ArgumentConfig} */
+		const argConfig = {
+			...argConfigBase,
+			multiple,
+			description: getDescription(path),
+			path: path[0].path
+		};
 
-module.exports = CssExportDependency;
+		if (negatedDescription) {
+			argConfig.negatedDescription = negatedDescription;
+		}
 
+		if (!flags[name]) {
+			flags[name] = {
+				configs: [],
+				description: undefined,
+				simpleType: undefined,
+				multiple: undefined
+			};
+		}
 
-/***/ }),
+		if (
+			flags[name].configs.some(
+				item => JSON.stringify(item) === JSON.stringify(argConfig)
+			)
+		) {
+			return 0;
+		}
 
-/***/ 90542:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		if (
+			flags[name].configs.some(
+				item => item.type === argConfig.type && item.multiple !== multiple
+			)
+		) {
+			if (multiple) {
+				throw new Error(
+					`Conflicting schema for ${path[0].path} with ${argConfig.type} type (array type must be before single item type)`
+				);
+			}
+			return 0;
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+		flags[name].configs.push(argConfig);
 
+		return 1;
+	};
 
+	// TODO support `not` and `if/then/else`
+	// TODO support `const`, but we don't use it on our schema
+	/**
+	 *
+	 * @param {object} schemaPart the current schema
+	 * @param {string} schemaPath the current path in the schema
+	 * @param {{schema: object, path: string}[]} path all previous visited schemaParts
+	 * @param {string | null} inArray if inside of an array, the path to the array
+	 * @returns {number} added arguments
+	 */
+	const traverse = (schemaPart, schemaPath = "", path = [], inArray = null) => {
+		while (schemaPart.$ref) {
+			schemaPart = getSchemaPart(schemaPart.$ref);
+		}
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+		const repetitions = path.filter(({ schema }) => schema === schemaPart);
+		if (
+			repetitions.length >= 2 ||
+			repetitions.some(({ path }) => path === schemaPath)
+		) {
+			return 0;
+		}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
 
-class CssImportDependency extends ModuleDependency {
-	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range of the argument
-	 * @param {string | undefined} supports list of supports conditions
-	 * @param {string | undefined} media list of media conditions
-	 */
-	constructor(request, range, supports, media) {
-		super(request);
-		this.range = range;
-		this.supports = supports;
-		this.media = media;
-	}
+		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
 
-	get type() {
-		return "css @import";
-	}
+		let addedArguments = 0;
 
-	get category() {
-		return "css-import";
-	}
+		addedArguments += addFlag(fullPath, !!inArray);
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
-	 */
-	createIgnoredModule(context) {
-		return null;
-	}
-}
+		if (schemaPart.type === "object") {
+			if (schemaPart.properties) {
+				for (const property of Object.keys(schemaPart.properties)) {
+					addedArguments += traverse(
+						schemaPart.properties[property],
+						schemaPath ? `${schemaPath}.${property}` : property,
+						fullPath,
+						inArray
+					);
+				}
+			}
 
-CssImportDependency.Template = class CssImportDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {CssImportDependency} */ (dependency);
+			return addedArguments;
+		}
+
+		if (schemaPart.type === "array") {
+			if (inArray) {
+				return 0;
+			}
+			if (Array.isArray(schemaPart.items)) {
+				let i = 0;
+				for (const item of schemaPart.items) {
+					addedArguments += traverse(
+						item,
+						`${schemaPath}.${i}`,
+						fullPath,
+						schemaPath
+					);
+				}
+
+				return addedArguments;
+			}
+
+			addedArguments += traverse(
+				schemaPart.items,
+				`${schemaPath}[]`,
+				fullPath,
+				schemaPath
+			);
 
-		source.replace(dep.range[0], dep.range[1] - 1, "");
-	}
-};
+			if (addedArguments > 0) {
+				addResetFlag(fullPath);
+				addedArguments++;
+			}
 
-makeSerializable(
-	CssImportDependency,
-	"webpack/lib/dependencies/CssImportDependency"
-);
+			return addedArguments;
+		}
 
-module.exports = CssImportDependency;
+		const maybeOf = schemaPart.oneOf || schemaPart.anyOf || schemaPart.allOf;
 
+		if (maybeOf) {
+			const items = maybeOf;
 
-/***/ }),
+			for (let i = 0; i < items.length; i++) {
+				addedArguments += traverse(items[i], schemaPath, fullPath, inArray);
+			}
 
-/***/ 92328:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			return addedArguments;
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+		return addedArguments;
+	};
 
+	traverse(schema);
 
+	// Summarize flags
+	for (const name of Object.keys(flags)) {
+		const argument = flags[name];
+		argument.description = argument.configs.reduce((desc, { description }) => {
+			if (!desc) return description;
+			if (!description) return desc;
+			if (desc.includes(description)) return desc;
+			return `${desc} ${description}`;
+		}, /** @type {string | undefined} */ (undefined));
+		argument.simpleType = argument.configs.reduce((t, argConfig) => {
+			/** @type {"string" | "number" | "boolean"} */
+			let type = "string";
+			switch (argConfig.type) {
+				case "number":
+					type = "number";
+					break;
+				case "reset":
+				case "boolean":
+					type = "boolean";
+					break;
+				case "enum":
+					if (argConfig.values.every(v => typeof v === "boolean"))
+						type = "boolean";
+					if (argConfig.values.every(v => typeof v === "number"))
+						type = "number";
+					break;
+			}
+			if (t === undefined) return type;
+			return t === type ? t : "string";
+		}, /** @type {"string" | "number" | "boolean" | undefined} */ (undefined));
+		argument.multiple = argument.configs.some(c => c.multiple);
+	}
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+	return flags;
+};
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+const cliAddedItems = new WeakMap();
 
-class CssLocalIdentifierDependency extends NullDependency {
-	/**
-	 * @param {string} name name
-	 * @param {[number, number]} range range
-	 * @param {string=} prefix prefix
-	 */
-	constructor(name, range, prefix = "") {
-		super();
-		this.name = name;
-		this.range = range;
-		this.prefix = prefix;
+/**
+ * @param {any} config configuration
+ * @param {string} schemaPath path in the config
+ * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
+ * @returns {{ problem?: LocalProblem, object?: any, property?: string | number, value?: any }} problem or object with property and value
+ */
+const getObjectAndProperty = (config, schemaPath, index = 0) => {
+	if (!schemaPath) return { value: config };
+	const parts = schemaPath.split(".");
+	let property = parts.pop();
+	let current = config;
+	let i = 0;
+	for (const part of parts) {
+		const isArray = part.endsWith("[]");
+		const name = isArray ? part.slice(0, -2) : part;
+		let value = current[name];
+		if (isArray) {
+			if (value === undefined) {
+				value = {};
+				current[name] = [...Array.from({ length: index }), value];
+				cliAddedItems.set(current[name], index + 1);
+			} else if (!Array.isArray(value)) {
+				return {
+					problem: {
+						type: "unexpected-non-array-in-path",
+						path: parts.slice(0, i).join(".")
+					}
+				};
+			} else {
+				let addedItems = cliAddedItems.get(value) || 0;
+				while (addedItems <= index) {
+					value.push(undefined);
+					addedItems++;
+				}
+				cliAddedItems.set(value, addedItems);
+				const x = value.length - addedItems + index;
+				if (value[x] === undefined) {
+					value[x] = {};
+				} else if (value[x] === null || typeof value[x] !== "object") {
+					return {
+						problem: {
+							type: "unexpected-non-object-in-path",
+							path: parts.slice(0, i).join(".")
+						}
+					};
+				}
+				value = value[x];
+			}
+		} else {
+			if (value === undefined) {
+				value = current[name] = {};
+			} else if (value === null || typeof value !== "object") {
+				return {
+					problem: {
+						type: "unexpected-non-object-in-path",
+						path: parts.slice(0, i).join(".")
+					}
+				};
+			}
+		}
+		current = value;
+		i++;
 	}
-
-	get type() {
-		return "css local identifier";
+	let value = current[property];
+	if (property.endsWith("[]")) {
+		const name = property.slice(0, -2);
+		const value = current[name];
+		if (value === undefined) {
+			current[name] = [...Array.from({ length: index }), undefined];
+			cliAddedItems.set(current[name], index + 1);
+			return { object: current[name], property: index, value: undefined };
+		} else if (!Array.isArray(value)) {
+			current[name] = [value, ...Array.from({ length: index }), undefined];
+			cliAddedItems.set(current[name], index + 1);
+			return { object: current[name], property: index + 1, value: undefined };
+		} else {
+			let addedItems = cliAddedItems.get(value) || 0;
+			while (addedItems <= index) {
+				value.push(undefined);
+				addedItems++;
+			}
+			cliAddedItems.set(value, addedItems);
+			const x = value.length - addedItems + index;
+			if (value[x] === undefined) {
+				value[x] = {};
+			} else if (value[x] === null || typeof value[x] !== "object") {
+				return {
+					problem: {
+						type: "unexpected-non-object-in-path",
+						path: schemaPath
+					}
+				};
+			}
+			return {
+				object: value,
+				property: x,
+				value: value[x]
+			};
+		}
 	}
+	return { object: current, property, value };
+};
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		const name = this.name;
+/**
+ * @param {any} config configuration
+ * @param {string} schemaPath path in the config
+ * @param {any} value parsed value
+ * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
+ * @returns {LocalProblem | null} problem or null for success
+ */
+const setValue = (config, schemaPath, value, index) => {
+	const { problem, object, property } = getObjectAndProperty(
+		config,
+		schemaPath,
+		index
+	);
+	if (problem) return problem;
+	object[property] = value;
+	return null;
+};
+
+/**
+ * @param {ArgumentConfig} argConfig processing instructions
+ * @param {any} config configuration
+ * @param {any} value the value
+ * @param {number | undefined} index the index if multiple values provided
+ * @returns {LocalProblem | null} a problem if any
+ */
+const processArgumentConfig = (argConfig, config, value, index) => {
+	if (index !== undefined && !argConfig.multiple) {
 		return {
-			exports: [
-				{
-					name,
-					canMangle: true
-				}
-			],
-			dependencies: undefined
+			type: "multiple-values-unexpected",
+			path: argConfig.path
 		};
 	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.name);
-		write(this.range);
-		write(this.prefix);
-		super.serialize(context);
+	const parsed = parseValueForArgumentConfig(argConfig, value);
+	if (parsed === undefined) {
+		return {
+			type: "invalid-value",
+			path: argConfig.path,
+			expected: getExpectedValue(argConfig)
+		};
 	}
+	const problem = setValue(config, argConfig.path, parsed, index);
+	if (problem) return problem;
+	return null;
+};
 
-	deserialize(context) {
-		const { read } = context;
-		this.name = read();
-		this.range = read();
-		this.prefix = read();
-		super.deserialize(context);
+/**
+ * @param {ArgumentConfig} argConfig processing instructions
+ * @returns {string | undefined} expected message
+ */
+const getExpectedValue = argConfig => {
+	switch (argConfig.type) {
+		default:
+			return argConfig.type;
+		case "boolean":
+			return "true | false";
+		case "RegExp":
+			return "regular expression (example: /ab?c*/)";
+		case "enum":
+			return argConfig.values.map(v => `${v}`).join(" | ");
+		case "reset":
+			return "true (will reset the previous value to an empty array)";
 	}
-}
-
-const escapeCssIdentifier = (str, omitUnderscore) => {
-	const escaped = `${str}`.replace(
-		// cspell:word uffff
-		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
-		s => `\\${s}`
-	);
-	return !omitUnderscore && /^(?!--)[0-9-]/.test(escaped)
-		? `_${escaped}`
-		: escaped;
 };
 
-CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }
-	) {
-		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportInfo(module, dep.name)
-			.getUsedName(dep.name, runtime);
-		const moduleId = chunkGraph.getModuleId(module);
-		const identifier =
-			dep.prefix +
-			(runtimeTemplate.outputOptions.uniqueName
-				? runtimeTemplate.outputOptions.uniqueName + "-"
-				: "") +
-			(used ? moduleId + "-" + used : "-");
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			escapeCssIdentifier(identifier, dep.prefix)
-		);
-		if (used) cssExports.set(used, identifier);
+/**
+ * @param {ArgumentConfig} argConfig processing instructions
+ * @param {any} value the value
+ * @returns {any | undefined} parsed value
+ */
+const parseValueForArgumentConfig = (argConfig, value) => {
+	switch (argConfig.type) {
+		case "string":
+			if (typeof value === "string") {
+				return value;
+			}
+			break;
+		case "path":
+			if (typeof value === "string") {
+				return path.resolve(value);
+			}
+			break;
+		case "number":
+			if (typeof value === "number") return value;
+			if (typeof value === "string" && /^[+-]?\d*(\.\d*)[eE]\d+$/) {
+				const n = +value;
+				if (!isNaN(n)) return n;
+			}
+			break;
+		case "boolean":
+			if (typeof value === "boolean") return value;
+			if (value === "true") return true;
+			if (value === "false") return false;
+			break;
+		case "RegExp":
+			if (value instanceof RegExp) return value;
+			if (typeof value === "string") {
+				// cspell:word yugi
+				const match = /^\/(.*)\/([yugi]*)$/.exec(value);
+				if (match && !/[^\\]\//.test(match[1]))
+					return new RegExp(match[1], match[2]);
+			}
+			break;
+		case "enum":
+			if (argConfig.values.includes(value)) return value;
+			for (const item of argConfig.values) {
+				if (`${item}` === value) return item;
+			}
+			break;
+		case "reset":
+			if (value === true) return [];
+			break;
 	}
 };
 
-makeSerializable(
-	CssLocalIdentifierDependency,
-	"webpack/lib/dependencies/CssLocalIdentifierDependency"
-);
+/**
+ * @param {Record<string, Argument>} args object of arguments
+ * @param {any} config configuration
+ * @param {Record<string, string | number | boolean | RegExp | (string | number | boolean | RegExp)[]>} values object with values
+ * @returns {Problem[] | null} problems or null for success
+ */
+const processArguments = (args, config, values) => {
+	/** @type {Problem[]} */
+	const problems = [];
+	for (const key of Object.keys(values)) {
+		const arg = args[key];
+		if (!arg) {
+			problems.push({
+				type: "unknown-argument",
+				path: "",
+				argument: key
+			});
+			continue;
+		}
+		const processValue = (value, i) => {
+			const currentProblems = [];
+			for (const argConfig of arg.configs) {
+				const problem = processArgumentConfig(argConfig, config, value, i);
+				if (!problem) {
+					return;
+				}
+				currentProblems.push({
+					...problem,
+					argument: key,
+					value: value,
+					index: i
+				});
+			}
+			problems.push(...currentProblems);
+		};
+		let value = values[key];
+		if (Array.isArray(value)) {
+			for (let i = 0; i < value.length; i++) {
+				processValue(value[i], i);
+			}
+		} else {
+			processValue(value, undefined);
+		}
+	}
+	if (problems.length === 0) return null;
+	return problems;
+};
 
-module.exports = CssLocalIdentifierDependency;
+exports.getArguments = getArguments;
+exports.processArguments = processArguments;
 
 
 /***/ }),
 
-/***/ 29094:
+/***/ 43950:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const CssLocalIdentifierDependency = __webpack_require__(92328);
+const browserslist = __webpack_require__(14907);
+const path = __webpack_require__(71017);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
+/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
+/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
 
-class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
-	/**
-	 * @param {string} name name
-	 * @param {[number, number]} range range
-	 * @param {string=} prefix prefix
-	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
-	 */
-	constructor(name, range, prefix = "", declaredSet = undefined) {
-		super(name, range, prefix);
-		this.declaredSet = declaredSet;
-	}
+// [[C:]/path/to/config][:env]
+const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 
-	get type() {
-		return "css self local identifier";
-	}
+/**
+ * @typedef {Object} BrowserslistHandlerConfig
+ * @property {string=} configPath
+ * @property {string=} env
+ * @property {string=} query
+ */
 
-	get category() {
-		return "self";
+/**
+ * @param {string} input input string
+ * @param {string} context the context directory
+ * @returns {BrowserslistHandlerConfig} config
+ */
+const parse = (input, context) => {
+	if (!input) {
+		return {};
 	}
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `self`;
-	}
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
-		return super.getExports(moduleGraph);
+	if (path.isAbsolute(input)) {
+		const [, configPath, env] = inputRx.exec(input) || [];
+		return { configPath, env };
 	}
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		if (this.declaredSet && !this.declaredSet.has(this.name))
-			return Dependency.NO_EXPORTS_REFERENCED;
-		return [[this.name]];
-	}
+	const config = browserslist.findConfig(context);
 
-	serialize(context) {
-		const { write } = context;
-		write(this.declaredSet);
-		super.serialize(context);
+	if (config && Object.keys(config).includes(input)) {
+		return { env: input };
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.declaredSet = read();
-		super.deserialize(context);
-	}
-}
+	return { query: input };
+};
+
+/**
+ * @param {string} input input string
+ * @param {string} context the context directory
+ * @returns {string[] | undefined} selected browsers
+ */
+const load = (input, context) => {
+	const { configPath, env, query } = parse(input, context);
+
+	// if a query is specified, then use it, else
+	// if a path to a config is specified then load it, else
+	// find a nearest config
+	const config = query
+		? query
+		: configPath
+		? browserslist.loadConfig({
+				config: configPath,
+				env
+		  })
+		: browserslist.loadConfig({ path: context, env });
+
+	if (!config) return null;
+	return browserslist(config);
+};
 
-CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
-	CssLocalIdentifierDependency.Template
-) {
+/**
+ * @param {string[]} browsers supported browsers list
+ * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
+ */
+const resolve = browsers => {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * Checks all against a version number
+	 * @param {Record<string, number | [number, number]>} versions first supported version
+	 * @returns {boolean} true if supports
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {CssSelfLocalIdentifierDependency} */ (dependency);
-		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
-		super.apply(dependency, source, templateContext);
-	}
-};
+	const rawChecker = versions => {
+		return browsers.every(v => {
+			const [name, parsedVersion] = v.split(" ");
+			if (!name) return false;
+			const requiredVersion = versions[name];
+			if (!requiredVersion) return false;
+			const [parsedMajor, parserMinor] =
+				// safari TP supports all features for normal safari
+				parsedVersion === "TP"
+					? [Infinity, Infinity]
+					: parsedVersion.split(".");
+			if (typeof requiredVersion === "number") {
+				return +parsedMajor >= requiredVersion;
+			}
+			return requiredVersion[0] === +parsedMajor
+				? +parserMinor >= requiredVersion[1]
+				: +parsedMajor > requiredVersion[0];
+		});
+	};
+	const anyNode = browsers.some(b => /^node /.test(b));
+	const anyBrowser = browsers.some(b => /^(?!node)/.test(b));
+	const browserProperty = !anyBrowser ? false : anyNode ? null : true;
+	const nodeProperty = !anyNode ? false : anyBrowser ? null : true;
+	// Internet Explorer Mobile, Blackberry browser and Opera Mini are very old browsers, they do not support new features
+	const es6DynamicImport = rawChecker({
+		chrome: 63,
+		and_chr: 63,
+		edge: 79,
+		firefox: 67,
+		and_ff: 67,
+		// ie: Not supported
+		opera: 50,
+		op_mob: 46,
+		safari: [11, 1],
+		ios_saf: [11, 3],
+		samsung: [8, 2],
+		android: 63,
+		and_qq: [10, 4],
+		// baidu: Not supported
+		// and_uc: Not supported
+		// kaios: Not supported
+		// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
+		node: [13, 14]
+	});
 
-makeSerializable(
-	CssSelfLocalIdentifierDependency,
-	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
-);
+	return {
+		const: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 12,
+			// Prior to Firefox 13, <code>const</code> is implemented, but re-assignment is not failing.
+			// Prior to Firefox 46, a <code>TypeError</code> was thrown on redeclaration instead of a <code>SyntaxError</code>.
+			firefox: 36,
+			and_ff: 36,
+			// Not supported in for-in and for-of loops
+			// ie: Not supported
+			opera: 36,
+			op_mob: 36,
+			safari: [10, 0],
+			ios_saf: [10, 0],
+			// Before 5.0 supported correctly in strict mode, otherwise supported without block scope
+			samsung: [5, 0],
+			android: 37,
+			and_qq: [10, 4],
+			// Supported correctly in strict mode, otherwise supported without block scope
+			// baidu: Not supported
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		arrowFunction: rawChecker({
+			chrome: 45,
+			and_chr: 45,
+			edge: 12,
+			// The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of <code>'use strict';</code> is now required.
+			// Prior to Firefox 39, a line terminator (<code>\\n</code>) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like <code>() \\n => {}</code> will now throw a <code>SyntaxError</code> in this and later versions.
+			firefox: 39,
+			and_ff: 39,
+			// ie: Not supported,
+			opera: 32,
+			op_mob: 32,
+			safari: 10,
+			ios_saf: 10,
+			samsung: [5, 0],
+			android: 45,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		forOf: rawChecker({
+			chrome: 38,
+			and_chr: 38,
+			edge: 12,
+			// Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration").
+			firefox: 51,
+			and_ff: 51,
+			// ie: Not supported,
+			opera: 25,
+			op_mob: 25,
+			safari: 7,
+			ios_saf: 7,
+			samsung: [3, 0],
+			android: 38,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [0, 12]
+		}),
+		destructuring: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 14,
+			firefox: 41,
+			and_ff: 41,
+			// ie: Not supported,
+			opera: 36,
+			op_mob: 36,
+			safari: 8,
+			ios_saf: 8,
+			samsung: [5, 0],
+			android: 49,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [6, 0]
+		}),
+		bigIntLiteral: rawChecker({
+			chrome: 67,
+			and_chr: 67,
+			edge: 79,
+			firefox: 68,
+			and_ff: 68,
+			// ie: Not supported,
+			opera: 54,
+			op_mob: 48,
+			safari: 14,
+			ios_saf: 14,
+			samsung: [9, 2],
+			android: 67,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: [10, 4]
+		}),
+		// Support syntax `import` and `export` and no limitations and bugs on Node.js
+		// Not include `export * as namespace`
+		module: rawChecker({
+			chrome: 61,
+			and_chr: 61,
+			edge: 16,
+			firefox: 60,
+			and_ff: 60,
+			// ie: Not supported,
+			opera: 48,
+			op_mob: 45,
+			safari: [10, 1],
+			ios_saf: [10, 3],
+			samsung: [8, 0],
+			android: 61,
+			and_qq: [10, 4],
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
+			node: [13, 14]
+		}),
+		dynamicImport: es6DynamicImport,
+		dynamicImportInWorker: es6DynamicImport && !anyNode,
+		// browserslist does not have info about globalThis
+		// so this is based on mdn-browser-compat-data
+		globalThis: rawChecker({
+			chrome: 71,
+			and_chr: 71,
+			edge: 79,
+			firefox: 65,
+			and_ff: 65,
+			// ie: Not supported,
+			opera: 58,
+			op_mob: 50,
+			safari: [12, 1],
+			ios_saf: [12, 2],
+			samsung: [10, 1],
+			android: 71,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [12, 0]
+		}),
+		optionalChaining: rawChecker({
+			chrome: 80,
+			and_chr: 80,
+			edge: 80,
+			firefox: 74,
+			and_ff: 79,
+			// ie: Not supported,
+			opera: 67,
+			op_mob: 64,
+			safari: [13, 1],
+			ios_saf: [13, 4],
+			samsung: 13,
+			android: 80,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: 14
+		}),
+		templateLiteral: rawChecker({
+			chrome: 41,
+			and_chr: 41,
+			edge: 13,
+			firefox: 34,
+			and_ff: 34,
+			// ie: Not supported,
+			opera: 29,
+			op_mob: 64,
+			safari: [9, 1],
+			ios_saf: 9,
+			samsung: 4,
+			android: 41,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: 4
+		}),
+		browser: browserProperty,
+		electron: false,
+		node: nodeProperty,
+		nwjs: false,
+		web: browserProperty,
+		webworker: false,
 
-module.exports = CssSelfLocalIdentifierDependency;
+		document: browserProperty,
+		fetchWasm: browserProperty,
+		global: nodeProperty,
+		importScripts: false,
+		importScriptsInWorker: true,
+		nodeBuiltins: nodeProperty,
+		require: nodeProperty
+	};
+};
+
+module.exports = {
+	resolve,
+	load
+};
 
 
 /***/ }),
 
-/***/ 70749:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 92988:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
-
-class CssUrlDependency extends ModuleDependency {
-	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range of the argument
-	 * @param {string} cssFunctionKind kind of css function, e. g. url(), image()
-	 */
-	constructor(request, range, cssFunctionKind) {
-		super(request);
-		this.range = range;
-		this.cssFunctionKind = cssFunctionKind;
-	}
-
-	get type() {
-		return "css url()";
-	}
+const fs = __webpack_require__(57147);
+const path = __webpack_require__(71017);
+const Template = __webpack_require__(39722);
+const { cleverMerge } = __webpack_require__(60839);
+const {
+	getTargetsProperties,
+	getTargetProperties,
+	getDefaultTarget
+} = __webpack_require__(52801);
 
-	get category() {
-		return "url";
-	}
+/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
+/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
+/** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
+/** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
+/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Library} Library */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
+/** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
+/** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
+/** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
+/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
+/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Target} Target */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./target").TargetProperties} TargetProperties */
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
-	 */
-	createIgnoredModule(context) {
-		const RawDataUrlModule = getRawDataUrlModule();
-		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
-	}
+const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
 
-	serialize(context) {
-		const { write } = context;
-		write(this.cssFunctionKind);
-		super.serialize(context);
+/**
+ * Sets a constant default value when undefined
+ * @template T
+ * @template {keyof T} P
+ * @param {T} obj an object
+ * @param {P} prop a property of this object
+ * @param {T[P]} value a default value of the property
+ * @returns {void}
+ */
+const D = (obj, prop, value) => {
+	if (obj[prop] === undefined) {
+		obj[prop] = value;
 	}
+};
 
-	deserialize(context) {
-		const { read } = context;
-		this.cssFunctionKind = read();
-		super.deserialize(context);
+/**
+ * Sets a dynamic default value when undefined, by calling the factory function
+ * @template T
+ * @template {keyof T} P
+ * @param {T} obj an object
+ * @param {P} prop a property of this object
+ * @param {function(): T[P]} factory a default value factory for the property
+ * @returns {void}
+ */
+const F = (obj, prop, factory) => {
+	if (obj[prop] === undefined) {
+		obj[prop] = factory();
 	}
-}
+};
 
-const cssEscapeString = str => {
-	let countWhiteOrBracket = 0;
-	let countQuotation = 0;
-	let countApostrophe = 0;
-	for (let i = 0; i < str.length; i++) {
-		const cc = str.charCodeAt(i);
-		switch (cc) {
-			case 9: // tab
-			case 10: // nl
-			case 32: // space
-			case 40: // (
-			case 41: // )
-				countWhiteOrBracket++;
-				break;
-			case 34:
-				countQuotation++;
-				break;
-			case 39:
-				countApostrophe++;
-				break;
+/**
+ * Sets a dynamic default value when undefined, by calling the factory function.
+ * factory must return an array or undefined
+ * When the current value is already an array an contains "..." it's replaced with
+ * the result of the factory function
+ * @template T
+ * @template {keyof T} P
+ * @param {T} obj an object
+ * @param {P} prop a property of this object
+ * @param {function(): T[P]} factory a default value factory for the property
+ * @returns {void}
+ */
+const A = (obj, prop, factory) => {
+	const value = obj[prop];
+	if (value === undefined) {
+		obj[prop] = factory();
+	} else if (Array.isArray(value)) {
+		/** @type {any[]} */
+		let newArray = undefined;
+		for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			if (item === "...") {
+				if (newArray === undefined) {
+					newArray = value.slice(0, i);
+					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
+				}
+				const items = /** @type {any[]} */ (/** @type {unknown} */ (factory()));
+				if (items !== undefined) {
+					for (const item of items) {
+						newArray.push(item);
+					}
+				}
+			} else if (newArray !== undefined) {
+				newArray.push(item);
+			}
 		}
 	}
-	if (countWhiteOrBracket < 2) {
-		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
-	} else if (countQuotation <= countApostrophe) {
-		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
-	} else {
-		return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
-	}
 };
 
-CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtime, moduleGraph, runtimeTemplate, codeGenerationResults }
-	) {
-		const dep = /** @type {CssUrlDependency} */ (dependency);
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`${dep.cssFunctionKind}(${cssEscapeString(
-				runtimeTemplate.assetUrl({
-					publicPath: "",
-					runtime,
-					module: moduleGraph.getModule(dep),
-					codeGenerationResults
-				})
-			)})`
-		);
-	}
+/**
+ * @param {WebpackOptions} options options to be modified
+ * @returns {void}
+ */
+const applyWebpackOptionsBaseDefaults = options => {
+	F(options, "context", () => process.cwd());
+	applyInfrastructureLoggingDefaults(options.infrastructureLogging);
 };
 
-makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
-
-module.exports = CssUrlDependency;
+/**
+ * @param {WebpackOptions} options options to be modified
+ * @returns {void}
+ */
+const applyWebpackOptionsDefaults = options => {
+	F(options, "context", () => process.cwd());
+	F(options, "target", () => {
+		return getDefaultTarget(options.context);
+	});
 
+	const { mode, name, target } = options;
 
-/***/ }),
+	let targetProperties =
+		target === false
+			? /** @type {false} */ (false)
+			: typeof target === "string"
+			? getTargetProperties(target, options.context)
+			: getTargetsProperties(target, options.context);
 
-/***/ 22914:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	const development = mode === "development";
+	const production = mode === "production" || !mode;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	if (typeof options.entry !== "function") {
+		for (const key of Object.keys(options.entry)) {
+			F(
+				options.entry[key],
+				"import",
+				() => /** @type {[string]} */ (["./src"])
+			);
+		}
+	}
 
+	F(options, "devtool", () => (development ? "eval" : false));
+	D(options, "watch", false);
+	D(options, "profile", false);
+	D(options, "parallelism", 100);
+	D(options, "recordsInputPath", false);
+	D(options, "recordsOutputPath", false);
 
+	applyExperimentsDefaults(options.experiments, {
+		production,
+		development,
+		targetProperties
+	});
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+	const futureDefaults = options.experiments.futureDefaults;
 
-class DelegatedSourceDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
+	F(options, "cache", () =>
+		development ? { type: /** @type {"memory"} */ ("memory") } : false
+	);
+	applyCacheDefaults(options.cache, {
+		name: name || "default",
+		mode: mode || "production",
+		development,
+		cacheUnaffected: options.experiments.cacheUnaffected
+	});
+	const cache = !!options.cache;
 
-	get type() {
-		return "delegated source";
-	}
+	applySnapshotDefaults(options.snapshot, {
+		production,
+		futureDefaults
+	});
 
-	get category() {
-		return "esm";
-	}
-}
+	applyModuleDefaults(options.module, {
+		cache,
+		syncWebAssembly: options.experiments.syncWebAssembly,
+		asyncWebAssembly: options.experiments.asyncWebAssembly,
+		css: options.experiments.css,
+		futureDefaults
+	});
 
-makeSerializable(
-	DelegatedSourceDependency,
-	"webpack/lib/dependencies/DelegatedSourceDependency"
-);
+	applyOutputDefaults(options.output, {
+		context: options.context,
+		targetProperties,
+		isAffectedByBrowserslist:
+			target === undefined ||
+			(typeof target === "string" && target.startsWith("browserslist")) ||
+			(Array.isArray(target) &&
+				target.some(target => target.startsWith("browserslist"))),
+		outputModule: options.experiments.outputModule,
+		development,
+		entry: options.entry,
+		module: options.module,
+		futureDefaults
+	});
 
-module.exports = DelegatedSourceDependency;
+	applyExternalsPresetsDefaults(options.externalsPresets, {
+		targetProperties,
+		buildHttp: !!options.experiments.buildHttp
+	});
 
+	applyLoaderDefaults(options.loader, { targetProperties });
 
-/***/ }),
+	F(options, "externalsType", () => {
+		const validExternalTypes = (__webpack_require__(73342).definitions.ExternalsType["enum"]);
+		return options.output.library &&
+			validExternalTypes.includes(options.output.library.type)
+			? /** @type {ExternalsType} */ (options.output.library.type)
+			: options.output.module
+			? "module"
+			: "var";
+	});
 
-/***/ 95666:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	applyNodeDefaults(options.node, {
+		futureDefaults: options.experiments.futureDefaults,
+		targetProperties
+	});
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	F(options, "performance", () =>
+		production &&
+		targetProperties &&
+		(targetProperties.browser || targetProperties.browser === null)
+			? {}
+			: false
+	);
+	applyPerformanceDefaults(options.performance, {
+		production
+	});
 
+	applyOptimizationDefaults(options.optimization, {
+		development,
+		production,
+		css: options.experiments.css,
+		records: !!(options.recordsInputPath || options.recordsOutputPath)
+	});
 
+	options.resolve = cleverMerge(
+		getResolveDefaults({
+			cache,
+			context: options.context,
+			targetProperties,
+			mode: options.mode
+		}),
+		options.resolve
+	);
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
+	options.resolveLoader = cleverMerge(
+		getResolveLoaderDefaults({ cache }),
+		options.resolveLoader
+	);
+};
 
-class DllEntryDependency extends Dependency {
-	constructor(dependencies, name) {
-		super();
+/**
+ * @param {ExperimentsNormalized} experiments options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @param {boolean} options.development is development mode
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @returns {void}
+ */
+const applyExperimentsDefaults = (
+	experiments,
+	{ production, development, targetProperties }
+) => {
+	D(experiments, "futureDefaults", false);
+	D(experiments, "backCompat", !experiments.futureDefaults);
+	D(experiments, "topLevelAwait", experiments.futureDefaults);
+	D(experiments, "syncWebAssembly", false);
+	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
+	D(experiments, "outputModule", false);
+	D(experiments, "layers", false);
+	D(experiments, "lazyCompilation", undefined);
+	D(experiments, "buildHttp", undefined);
+	D(experiments, "cacheUnaffected", experiments.futureDefaults);
+	F(experiments, "css", () => (experiments.futureDefaults ? {} : undefined));
 
-		this.dependencies = dependencies;
-		this.name = name;
+	if (typeof experiments.buildHttp === "object") {
+		D(experiments.buildHttp, "frozen", production);
+		D(experiments.buildHttp, "upgrade", false);
 	}
 
-	get type() {
-		return "dll entry";
+	if (typeof experiments.css === "object") {
+		D(
+			experiments.css,
+			"exportsOnly",
+			!targetProperties || !targetProperties.document
+		);
 	}
+};
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.dependencies);
-		write(this.name);
-
-		super.serialize(context);
+/**
+ * @param {CacheOptions} cache options
+ * @param {Object} options options
+ * @param {string} options.name name
+ * @param {string} options.mode mode
+ * @param {boolean} options.development is development mode
+ * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
+ * @returns {void}
+ */
+const applyCacheDefaults = (
+	cache,
+	{ name, mode, development, cacheUnaffected }
+) => {
+	if (cache === false) return;
+	switch (cache.type) {
+		case "filesystem":
+			F(cache, "name", () => name + "-" + mode);
+			D(cache, "version", "");
+			F(cache, "cacheDirectory", () => {
+				const cwd = process.cwd();
+				let dir = cwd;
+				for (;;) {
+					try {
+						if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
+						// eslint-disable-next-line no-empty
+					} catch (e) {}
+					const parent = path.dirname(dir);
+					if (dir === parent) {
+						dir = undefined;
+						break;
+					}
+					dir = parent;
+				}
+				if (!dir) {
+					return path.resolve(cwd, ".cache/webpack");
+				} else if (process.versions.pnp === "1") {
+					return path.resolve(dir, ".pnp/.cache/webpack");
+				} else if (process.versions.pnp === "3") {
+					return path.resolve(dir, ".yarn/.cache/webpack");
+				} else {
+					return path.resolve(dir, "node_modules/.cache/webpack");
+				}
+			});
+			F(cache, "cacheLocation", () =>
+				path.resolve(cache.cacheDirectory, cache.name)
+			);
+			D(cache, "hashAlgorithm", "md4");
+			D(cache, "store", "pack");
+			D(cache, "compression", false);
+			D(cache, "profile", false);
+			D(cache, "idleTimeout", 60000);
+			D(cache, "idleTimeoutForInitialStore", 5000);
+			D(cache, "idleTimeoutAfterLargeChanges", 1000);
+			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
+			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
+			D(cache, "allowCollectingMemory", development);
+			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
+			D(cache.buildDependencies, "defaultWebpack", [
+				path.resolve(__dirname, "..") + path.sep
+			]);
+			break;
+		case "memory":
+			D(cache, "maxGenerations", Infinity);
+			D(cache, "cacheUnaffected", development && cacheUnaffected);
+			break;
 	}
+};
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.dependencies = read();
-		this.name = read();
-
-		super.deserialize(context);
+/**
+ * @param {SnapshotOptions} snapshot options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
+	if (futureDefaults) {
+		F(snapshot, "managedPaths", () =>
+			process.versions.pnp === "3"
+				? [
+						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
+				  ]
+				: [/^(.+?[\\/]node_modules[\\/])/]
+		);
+		F(snapshot, "immutablePaths", () =>
+			process.versions.pnp === "3"
+				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
+				: []
+		);
+	} else {
+		A(snapshot, "managedPaths", () => {
+			if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						/*require.resolve*/(36871)
+					);
+				if (match) {
+					return [path.resolve(match[1], "unplugged")];
+				}
+			} else {
+				const match = /^(.+?[\\/]node_modules[\\/])/.exec(
+					// eslint-disable-next-line node/no-extraneous-require
+					/*require.resolve*/(36871)
+				);
+				if (match) {
+					return [match[1]];
+				}
+			}
+			return [];
+		});
+		A(snapshot, "immutablePaths", () => {
+			if (process.versions.pnp === "1") {
+				const match =
+					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+						/*require.resolve*/(36871)
+					);
+				if (match) {
+					return [match[1]];
+				}
+			} else if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						/*require.resolve*/(36871)
+					);
+				if (match) {
+					return [match[1]];
+				}
+			}
+			return [];
+		});
 	}
-}
-
-makeSerializable(
-	DllEntryDependency,
-	"webpack/lib/dependencies/DllEntryDependency"
-);
-
-module.exports = DllEntryDependency;
-
-
-/***/ }),
-
-/***/ 32006:
-/***/ (function(__unused_webpack_module, exports) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("../Parser").ParserState} ParserState */
+	F(snapshot, "resolveBuildDependencies", () => ({
+		timestamp: true,
+		hash: true
+	}));
+	F(snapshot, "buildDependencies", () => ({ timestamp: true, hash: true }));
+	F(snapshot, "module", () =>
+		production ? { timestamp: true, hash: true } : { timestamp: true }
+	);
+	F(snapshot, "resolve", () =>
+		production ? { timestamp: true, hash: true } : { timestamp: true }
+	);
+};
 
-/** @type {WeakMap<ParserState, boolean>} */
-const parserStateExportsState = new WeakMap();
+/**
+ * @param {JavascriptParserOptions} parserOptions parser options
+ * @param {Object} options options
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applyJavascriptParserOptionsDefaults = (
+	parserOptions,
+	{ futureDefaults }
+) => {
+	D(parserOptions, "unknownContextRequest", ".");
+	D(parserOptions, "unknownContextRegExp", false);
+	D(parserOptions, "unknownContextRecursive", true);
+	D(parserOptions, "unknownContextCritical", true);
+	D(parserOptions, "exprContextRequest", ".");
+	D(parserOptions, "exprContextRegExp", false);
+	D(parserOptions, "exprContextRecursive", true);
+	D(parserOptions, "exprContextCritical", true);
+	D(parserOptions, "wrappedContextRegExp", /.*/);
+	D(parserOptions, "wrappedContextRecursive", true);
+	D(parserOptions, "wrappedContextCritical", false);
+	D(parserOptions, "strictThisContextOnImports", false);
+	D(parserOptions, "importMeta", true);
+	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
+};
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {ModuleOptions} module options
+ * @param {Object} options options
+ * @param {boolean} options.cache is caching enabled
+ * @param {boolean} options.syncWebAssembly is syncWebAssembly enabled
+ * @param {boolean} options.asyncWebAssembly is asyncWebAssembly enabled
+ * @param {CssExperimentOptions} options.css is css enabled
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
-exports.bailout = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	parserStateExportsState.set(parserState, false);
-	if (value === true) {
-		parserState.module.buildMeta.exportsType = undefined;
-		parserState.module.buildMeta.defaultObject = false;
+const applyModuleDefaults = (
+	module,
+	{ cache, syncWebAssembly, asyncWebAssembly, css, futureDefaults }
+) => {
+	if (cache) {
+		D(module, "unsafeCache", module => {
+			const name = module.nameForCondition();
+			return name && NODE_MODULES_REGEXP.test(name);
+		});
+	} else {
+		D(module, "unsafeCache", false);
+	}
+
+	F(module.parser, "asset", () => ({}));
+	F(module.parser.asset, "dataUrlCondition", () => ({}));
+	if (typeof module.parser.asset.dataUrlCondition === "object") {
+		D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
 	}
+
+	F(module.parser, "javascript", () => ({}));
+	applyJavascriptParserOptionsDefaults(module.parser.javascript, {
+		futureDefaults
+	});
+
+	A(module, "defaultRules", () => {
+		const esm = {
+			type: "javascript/esm",
+			resolve: {
+				byDependency: {
+					esm: {
+						fullySpecified: true
+					}
+				}
+			}
+		};
+		const commonjs = {
+			type: "javascript/dynamic"
+		};
+		/** @type {RuleSetRules} */
+		const rules = [
+			{
+				mimetype: "application/node",
+				type: "javascript/auto"
+			},
+			{
+				test: /\.json$/i,
+				type: "json"
+			},
+			{
+				mimetype: "application/json",
+				type: "json"
+			},
+			{
+				test: /\.mjs$/i,
+				...esm
+			},
+			{
+				test: /\.js$/i,
+				descriptionData: {
+					type: "module"
+				},
+				...esm
+			},
+			{
+				test: /\.cjs$/i,
+				...commonjs
+			},
+			{
+				test: /\.js$/i,
+				descriptionData: {
+					type: "commonjs"
+				},
+				...commonjs
+			},
+			{
+				mimetype: {
+					or: ["text/javascript", "application/javascript"]
+				},
+				...esm
+			}
+		];
+		if (asyncWebAssembly) {
+			const wasm = {
+				type: "webassembly/async",
+				rules: [
+					{
+						descriptionData: {
+							type: "module"
+						},
+						resolve: {
+							fullySpecified: true
+						}
+					}
+				]
+			};
+			rules.push({
+				test: /\.wasm$/i,
+				...wasm
+			});
+			rules.push({
+				mimetype: "application/wasm",
+				...wasm
+			});
+		} else if (syncWebAssembly) {
+			const wasm = {
+				type: "webassembly/sync",
+				rules: [
+					{
+						descriptionData: {
+							type: "module"
+						},
+						resolve: {
+							fullySpecified: true
+						}
+					}
+				]
+			};
+			rules.push({
+				test: /\.wasm$/i,
+				...wasm
+			});
+			rules.push({
+				mimetype: "application/wasm",
+				...wasm
+			});
+		}
+		if (css) {
+			const cssRule = {
+				type: "css",
+				resolve: {
+					fullySpecified: true,
+					preferRelative: true
+				}
+			};
+			const cssModulesRule = {
+				type: "css/module",
+				resolve: {
+					fullySpecified: true
+				}
+			};
+			rules.push({
+				test: /\.css$/i,
+				oneOf: [
+					{
+						test: /\.module\.css$/i,
+						...cssModulesRule
+					},
+					{
+						...cssRule
+					}
+				]
+			});
+			rules.push({
+				mimetype: "text/css+module",
+				...cssModulesRule
+			});
+			rules.push({
+				mimetype: "text/css",
+				...cssRule
+			});
+		}
+		rules.push(
+			{
+				dependency: "url",
+				oneOf: [
+					{
+						scheme: /^data$/,
+						type: "asset/inline"
+					},
+					{
+						type: "asset/resource"
+					}
+				]
+			},
+			{
+				assert: { type: "json" },
+				type: "json"
+			}
+		);
+		return rules;
+	});
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {Output} output options
+ * @param {Object} options options
+ * @param {string} options.context context
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
+ * @param {boolean} options.outputModule is outputModule experiment enabled
+ * @param {boolean} options.development is development mode
+ * @param {Entry} options.entry entry option
+ * @param {ModuleOptions} options.module module option
+ * @param {boolean} options.futureDefaults is future defaults enabled
  * @returns {void}
  */
-exports.enable = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	if (value === false) return;
-	parserStateExportsState.set(parserState, true);
-	if (value !== true) {
-		parserState.module.buildMeta.exportsType = "default";
-		parserState.module.buildMeta.defaultObject = "redirect";
+const applyOutputDefaults = (
+	output,
+	{
+		context,
+		targetProperties: tp,
+		isAffectedByBrowserslist,
+		outputModule,
+		development,
+		entry,
+		module,
+		futureDefaults
 	}
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.setFlagged = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	if (value !== true) return;
-	const buildMeta = parserState.module.buildMeta;
-	if (buildMeta.exportsType === "dynamic") return;
-	buildMeta.exportsType = "flagged";
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.setDynamic = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	if (value !== true) return;
-	parserState.module.buildMeta.exportsType = "dynamic";
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-exports.isEnabled = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	return value === true;
-};
-
-
-/***/ }),
-
-/***/ 3979:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-class EntryDependency extends ModuleDependency {
+) => {
 	/**
-	 * @param {string} request request path for entry
+	 * @param {Library=} library the library option
+	 * @returns {string} a readable library name
 	 */
-	constructor(request) {
-		super(request);
-	}
-
-	get type() {
-		return "entry";
-	}
-
-	get category() {
-		return "esm";
-	}
-}
-
-makeSerializable(EntryDependency, "webpack/lib/dependencies/EntryDependency");
-
-module.exports = EntryDependency;
-
-
-/***/ }),
-
-/***/ 78988:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { UsageState } = __webpack_require__(63686);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+	const getLibraryName = library => {
+		const libraryName =
+			typeof library === "object" &&
+			library &&
+			!Array.isArray(library) &&
+			"type" in library
+				? library.name
+				: /** @type {LibraryName=} */ (library);
+		if (Array.isArray(libraryName)) {
+			return libraryName.join(".");
+		} else if (typeof libraryName === "object") {
+			return getLibraryName(libraryName.root);
+		} else if (typeof libraryName === "string") {
+			return libraryName;
+		}
+		return "";
+	};
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+	F(output, "uniqueName", () => {
+		const libraryName = getLibraryName(output.library);
+		if (libraryName) return libraryName;
+		const pkgPath = path.resolve(context, "package.json");
+		try {
+			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+			return packageInfo.name || "";
+		} catch (e) {
+			if (e.code !== "ENOENT") {
+				e.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
+				throw e;
+			}
+			return "";
+		}
+	});
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} module the module
- * @param {string | null} exportName name of the export if any
- * @param {string | null} property name of the requested property
- * @param {RuntimeSpec} runtime for which runtime
- * @returns {any} value of the property
- */
-const getProperty = (moduleGraph, module, exportName, property, runtime) => {
-	if (!exportName) {
-		switch (property) {
-			case "usedExports": {
-				const usedExports = moduleGraph
-					.getExportsInfo(module)
-					.getUsedExports(runtime);
-				if (
-					typeof usedExports === "boolean" ||
-					usedExports === undefined ||
-					usedExports === null
-				) {
-					return usedExports;
-				}
-				return Array.from(usedExports).sort();
+	F(output, "module", () => !!outputModule);
+	D(output, "filename", output.module ? "[name].mjs" : "[name].js");
+	F(output, "iife", () => !output.module);
+	D(output, "importFunctionName", "import");
+	D(output, "importMetaName", "import.meta");
+	F(output, "chunkFilename", () => {
+		const filename = output.filename;
+		if (typeof filename !== "function") {
+			const hasName = filename.includes("[name]");
+			const hasId = filename.includes("[id]");
+			const hasChunkHash = filename.includes("[chunkhash]");
+			const hasContentHash = filename.includes("[contenthash]");
+			// Anything changing depending on chunk is fine
+			if (hasChunkHash || hasContentHash || hasName || hasId) return filename;
+			// Otherwise prefix "[id]." in front of the basename to make it changing
+			return filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
+		}
+		return output.module ? "[id].mjs" : "[id].js";
+	});
+	F(output, "cssFilename", () => {
+		const filename = output.filename;
+		if (typeof filename !== "function") {
+			return filename.replace(/\.[mc]?js(\?|$)/, ".css$1");
+		}
+		return "[id].css";
+	});
+	F(output, "cssChunkFilename", () => {
+		const chunkFilename = output.chunkFilename;
+		if (typeof chunkFilename !== "function") {
+			return chunkFilename.replace(/\.[mc]?js(\?|$)/, ".css$1");
+		}
+		return "[id].css";
+	});
+	D(output, "assetModuleFilename", "[hash][ext][query]");
+	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
+	D(output, "compareBeforeEmit", true);
+	D(output, "charset", true);
+	F(output, "hotUpdateGlobal", () =>
+		Template.toIdentifier(
+			"webpackHotUpdate" + Template.toIdentifier(output.uniqueName)
+		)
+	);
+	F(output, "chunkLoadingGlobal", () =>
+		Template.toIdentifier(
+			"webpackChunk" + Template.toIdentifier(output.uniqueName)
+		)
+	);
+	F(output, "globalObject", () => {
+		if (tp) {
+			if (tp.global) return "global";
+			if (tp.globalThis) return "globalThis";
+		}
+		return "self";
+	});
+	F(output, "chunkFormat", () => {
+		if (tp) {
+			const helpMessage = isAffectedByBrowserslist
+				? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly."
+				: "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
+			if (output.module) {
+				if (tp.dynamicImport) return "module";
+				if (tp.document) return "array-push";
+				throw new Error(
+					"For the selected environment is no default ESM chunk format available:\n" +
+						"ESM exports can be chosen when 'import()' is available.\n" +
+						"JSONP Array push can be chosen when 'document' is available.\n" +
+						helpMessage
+				);
+			} else {
+				if (tp.document) return "array-push";
+				if (tp.require) return "commonjs";
+				if (tp.nodeBuiltins) return "commonjs";
+				if (tp.importScripts) return "array-push";
+				throw new Error(
+					"For the selected environment is no default script chunk format available:\n" +
+						"JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
+						"CommonJs exports can be chosen when 'require' or node builtins are available.\n" +
+						helpMessage
+				);
 			}
 		}
-	}
-	switch (property) {
-		case "used":
-			return (
-				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
-				UsageState.Unused
-			);
-		case "useInfo": {
-			const state = moduleGraph
-				.getExportsInfo(module)
-				.getUsed(exportName, runtime);
-			switch (state) {
-				case UsageState.Used:
-				case UsageState.OnlyPropertiesUsed:
-					return true;
-				case UsageState.Unused:
-					return false;
-				case UsageState.NoInfo:
-					return undefined;
-				case UsageState.Unknown:
-					return null;
-				default:
-					throw new Error(`Unexpected UsageState ${state}`);
+		throw new Error(
+			"Chunk format can't be selected by default when no target is specified"
+		);
+	});
+	D(output, "asyncChunks", true);
+	F(output, "chunkLoading", () => {
+		if (tp) {
+			switch (output.chunkFormat) {
+				case "array-push":
+					if (tp.document) return "jsonp";
+					if (tp.importScripts) return "import-scripts";
+					break;
+				case "commonjs":
+					if (tp.require) return "require";
+					if (tp.nodeBuiltins) return "async-node";
+					break;
+				case "module":
+					if (tp.dynamicImport) return "import";
+					break;
+			}
+			if (
+				tp.require === null ||
+				tp.nodeBuiltins === null ||
+				tp.document === null ||
+				tp.importScripts === null
+			) {
+				return "universal";
 			}
 		}
-		case "provideInfo":
-			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
-	}
-	return undefined;
-};
-
-class ExportsInfoDependency extends NullDependency {
-	constructor(range, exportName, property) {
-		super();
-		this.range = range;
-		this.exportName = exportName;
-		this.property = property;
+		return false;
+	});
+	F(output, "workerChunkLoading", () => {
+		if (tp) {
+			switch (output.chunkFormat) {
+				case "array-push":
+					if (tp.importScriptsInWorker) return "import-scripts";
+					break;
+				case "commonjs":
+					if (tp.require) return "require";
+					if (tp.nodeBuiltins) return "async-node";
+					break;
+				case "module":
+					if (tp.dynamicImportInWorker) return "import";
+					break;
+			}
+			if (
+				tp.require === null ||
+				tp.nodeBuiltins === null ||
+				tp.importScriptsInWorker === null
+			) {
+				return "universal";
+			}
+		}
+		return false;
+	});
+	F(output, "wasmLoading", () => {
+		if (tp) {
+			if (tp.fetchWasm) return "fetch";
+			if (tp.nodeBuiltins)
+				return output.module ? "async-node-module" : "async-node";
+			if (tp.nodeBuiltins === null || tp.fetchWasm === null) {
+				return "universal";
+			}
+		}
+		return false;
+	});
+	F(output, "workerWasmLoading", () => output.wasmLoading);
+	F(output, "devtoolNamespace", () => output.uniqueName);
+	if (output.library) {
+		F(output.library, "type", () => (output.module ? "module" : "var"));
 	}
+	F(output, "path", () => path.join(process.cwd(), "dist"));
+	F(output, "pathinfo", () => development);
+	D(output, "sourceMapFilename", "[file].map[query]");
+	D(
+		output,
+		"hotUpdateChunkFilename",
+		`[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`
+	);
+	D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
+	D(output, "crossOriginLoading", false);
+	F(output, "scriptType", () => (output.module ? "module" : false));
+	D(
+		output,
+		"publicPath",
+		(tp && (tp.document || tp.importScripts)) || output.scriptType === "module"
+			? "auto"
+			: ""
+	);
+	D(output, "chunkLoadTimeout", 120000);
+	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
+	D(output, "hashDigest", "hex");
+	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
+	D(output, "strictModuleExceptionHandling", false);
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.exportName);
-		write(this.property);
-		super.serialize(context);
-	}
+	const optimistic = v => v || v === undefined;
+	F(
+		output.environment,
+		"arrowFunction",
+		() => tp && optimistic(tp.arrowFunction)
+	);
+	F(output.environment, "const", () => tp && optimistic(tp.const));
+	F(
+		output.environment,
+		"destructuring",
+		() => tp && optimistic(tp.destructuring)
+	);
+	F(output.environment, "forOf", () => tp && optimistic(tp.forOf));
+	F(output.environment, "bigIntLiteral", () => tp && tp.bigIntLiteral);
+	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
+	F(output.environment, "module", () => tp && tp.module);
 
-	static deserialize(context) {
-		const obj = new ExportsInfoDependency(
-			context.read(),
-			context.read(),
-			context.read()
+	const { trustedTypes } = output;
+	if (trustedTypes) {
+		F(
+			trustedTypes,
+			"policyName",
+			() =>
+				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
 		);
-		obj.deserialize(context);
-		return obj;
 	}
-}
-
-makeSerializable(
-	ExportsInfoDependency,
-	"webpack/lib/dependencies/ExportsInfoDependency"
-);
 
-ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @param {function(EntryDescription): void} fn iterator
 	 * @returns {void}
 	 */
-	apply(dependency, source, { module, moduleGraph, runtime }) {
-		const dep = /** @type {ExportsInfoDependency} */ (dependency);
-
-		const value = getProperty(
-			moduleGraph,
-			module,
-			dep.exportName,
-			dep.property,
-			runtime
-		);
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			value === undefined ? "undefined" : JSON.stringify(value)
-		);
-	}
-};
-
-module.exports = ExportsInfoDependency;
-
-
-/***/ }),
-
-/***/ 23624:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Template = __webpack_require__(1626);
-const makeSerializable = __webpack_require__(33032);
-const HarmonyImportDependency = __webpack_require__(57154);
-const NullDependency = __webpack_require__(31830);
+	const forEachEntry = fn => {
+		for (const name of Object.keys(entry)) {
+			fn(entry[name]);
+		}
+	};
+	A(output, "enabledLibraryTypes", () => {
+		const enabledLibraryTypes = [];
+		if (output.library) {
+			enabledLibraryTypes.push(output.library.type);
+		}
+		forEachEntry(desc => {
+			if (desc.library) {
+				enabledLibraryTypes.push(desc.library.type);
+			}
+		});
+		return enabledLibraryTypes;
+	});
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+	A(output, "enabledChunkLoadingTypes", () => {
+		const enabledChunkLoadingTypes = new Set();
+		if (output.chunkLoading) {
+			enabledChunkLoadingTypes.add(output.chunkLoading);
+		}
+		if (output.workerChunkLoading) {
+			enabledChunkLoadingTypes.add(output.workerChunkLoading);
+		}
+		forEachEntry(desc => {
+			if (desc.chunkLoading) {
+				enabledChunkLoadingTypes.add(desc.chunkLoading);
+			}
+		});
+		return Array.from(enabledChunkLoadingTypes);
+	});
 
-class HarmonyAcceptDependency extends NullDependency {
-	/**
-	 * @param {[number, number]} range expression range
-	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
-	 * @param {boolean} hasCallback true, if the range wraps an existing callback
-	 */
-	constructor(range, dependencies, hasCallback) {
-		super();
-		this.range = range;
-		this.dependencies = dependencies;
-		this.hasCallback = hasCallback;
-	}
+	A(output, "enabledWasmLoadingTypes", () => {
+		const enabledWasmLoadingTypes = new Set();
+		if (output.wasmLoading) {
+			enabledWasmLoadingTypes.add(output.wasmLoading);
+		}
+		if (output.workerWasmLoading) {
+			enabledWasmLoadingTypes.add(output.workerWasmLoading);
+		}
+		forEachEntry(desc => {
+			if (desc.wasmLoading) {
+				enabledWasmLoadingTypes.add(desc.wasmLoading);
+			}
+		});
+		return Array.from(enabledWasmLoadingTypes);
+	});
+};
 
-	get type() {
-		return "accepted harmony modules";
-	}
+/**
+ * @param {ExternalsPresets} externalsPresets options
+ * @param {Object} options options
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.buildHttp buildHttp experiment enabled
+ * @returns {void}
+ */
+const applyExternalsPresetsDefaults = (
+	externalsPresets,
+	{ targetProperties, buildHttp }
+) => {
+	D(
+		externalsPresets,
+		"web",
+		!buildHttp && targetProperties && targetProperties.web
+	);
+	D(externalsPresets, "node", targetProperties && targetProperties.node);
+	D(externalsPresets, "nwjs", targetProperties && targetProperties.nwjs);
+	D(
+		externalsPresets,
+		"electron",
+		targetProperties && targetProperties.electron
+	);
+	D(
+		externalsPresets,
+		"electronMain",
+		targetProperties &&
+			targetProperties.electron &&
+			targetProperties.electronMain
+	);
+	D(
+		externalsPresets,
+		"electronPreload",
+		targetProperties &&
+			targetProperties.electron &&
+			targetProperties.electronPreload
+	);
+	D(
+		externalsPresets,
+		"electronRenderer",
+		targetProperties &&
+			targetProperties.electron &&
+			targetProperties.electronRenderer
+	);
+};
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.dependencies);
-		write(this.hasCallback);
-		super.serialize(context);
-	}
+/**
+ * @param {Loader} loader options
+ * @param {Object} options options
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @returns {void}
+ */
+const applyLoaderDefaults = (loader, { targetProperties }) => {
+	F(loader, "target", () => {
+		if (targetProperties) {
+			if (targetProperties.electron) {
+				if (targetProperties.electronMain) return "electron-main";
+				if (targetProperties.electronPreload) return "electron-preload";
+				if (targetProperties.electronRenderer) return "electron-renderer";
+				return "electron";
+			}
+			if (targetProperties.nwjs) return "nwjs";
+			if (targetProperties.node) return "node";
+			if (targetProperties.web) return "web";
+		}
+	});
+};
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.dependencies = read();
-		this.hasCallback = read();
-		super.deserialize(context);
-	}
-}
+/**
+ * @param {WebpackNode} node options
+ * @param {Object} options options
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applyNodeDefaults = (node, { futureDefaults, targetProperties }) => {
+	if (node === false) return;
 
-makeSerializable(
-	HarmonyAcceptDependency,
-	"webpack/lib/dependencies/HarmonyAcceptDependency"
-);
+	F(node, "global", () => {
+		if (targetProperties && targetProperties.global) return false;
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn" : true;
+	});
+	F(node, "__filename", () => {
+		if (targetProperties && targetProperties.node) return "eval-only";
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn-mock" : "mock";
+	});
+	F(node, "__dirname", () => {
+		if (targetProperties && targetProperties.node) return "eval-only";
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn-mock" : "mock";
+	});
+};
 
-HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
-		const {
-			module,
-			runtime,
-			runtimeRequirements,
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph
-		} = templateContext;
-		const content = dep.dependencies
-			.map(dependency => {
-				const referencedModule = moduleGraph.getModule(dependency);
-				return {
-					dependency,
-					runtimeCondition: referencedModule
-						? HarmonyImportDependency.Template.getImportEmittedRuntime(
-								module,
-								referencedModule
-						  )
-						: false
-				};
-			})
-			.filter(({ runtimeCondition }) => runtimeCondition !== false)
-			.map(({ dependency, runtimeCondition }) => {
-				const condition = runtimeTemplate.runtimeConditionExpression({
-					chunkGraph,
-					runtime,
-					runtimeCondition,
-					runtimeRequirements
-				});
-				const s = dependency.getImportStatement(true, templateContext);
-				const code = s[0] + s[1];
-				if (condition !== "true") {
-					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
-				}
-				return code;
-			})
-			.join("");
+/**
+ * @param {Performance} performance options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @returns {void}
+ */
+const applyPerformanceDefaults = (performance, { production }) => {
+	if (performance === false) return;
+	D(performance, "maxAssetSize", 250000);
+	D(performance, "maxEntrypointSize", 250000);
+	F(performance, "hints", () => (production ? "warning" : false));
+};
 
-		if (dep.hasCallback) {
-			if (runtimeTemplate.supportsArrowFunction()) {
-				source.insert(
-					dep.range[0],
-					`__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`
-				);
-				source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
-			} else {
-				source.insert(
-					dep.range[0],
-					`function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`
-				);
-				source.insert(
-					dep.range[1],
-					")(__WEBPACK_OUTDATED_DEPENDENCIES__); }.bind(this)"
-				);
+/**
+ * @param {Optimization} optimization options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @param {boolean} options.development is development
+ * @param {CssExperimentOptions} options.css is css enabled
+ * @param {boolean} options.records using records
+ * @returns {void}
+ */
+const applyOptimizationDefaults = (
+	optimization,
+	{ production, development, css, records }
+) => {
+	D(optimization, "removeAvailableModules", false);
+	D(optimization, "removeEmptyChunks", true);
+	D(optimization, "mergeDuplicateChunks", true);
+	D(optimization, "flagIncludedChunks", production);
+	F(optimization, "moduleIds", () => {
+		if (production) return "deterministic";
+		if (development) return "named";
+		return "natural";
+	});
+	F(optimization, "chunkIds", () => {
+		if (production) return "deterministic";
+		if (development) return "named";
+		return "natural";
+	});
+	F(optimization, "sideEffects", () => (production ? true : "flag"));
+	D(optimization, "providedExports", true);
+	D(optimization, "usedExports", production);
+	D(optimization, "innerGraph", production);
+	D(optimization, "mangleExports", production);
+	D(optimization, "concatenateModules", production);
+	D(optimization, "runtimeChunk", false);
+	D(optimization, "emitOnErrors", !production);
+	D(optimization, "checkWasmTypes", production);
+	D(optimization, "mangleWasmImports", false);
+	D(optimization, "portableRecords", records);
+	D(optimization, "realContentHash", production);
+	D(optimization, "minimize", production);
+	A(optimization, "minimizer", () => [
+		{
+			apply: compiler => {
+				// Lazy load the Terser plugin
+				const TerserPlugin = __webpack_require__(55302);
+				new TerserPlugin({
+					terserOptions: {
+						compress: {
+							passes: 2
+						}
+					}
+				}).apply(compiler);
 			}
-			return;
 		}
-
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		source.insert(
-			dep.range[1] - 0.5,
-			`, ${arrow ? "() =>" : "function()"} { ${content} }`
+	]);
+	F(optimization, "nodeEnv", () => {
+		if (production) return "production";
+		if (development) return "development";
+		return false;
+	});
+	const { splitChunks } = optimization;
+	if (splitChunks) {
+		A(splitChunks, "defaultSizeTypes", () =>
+			css ? ["javascript", "css", "unknown"] : ["javascript", "unknown"]
 		);
+		D(splitChunks, "hidePathInfo", production);
+		D(splitChunks, "chunks", "async");
+		D(splitChunks, "usedExports", optimization.usedExports === true);
+		D(splitChunks, "minChunks", 1);
+		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
+		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));
+		F(splitChunks, "enforceSizeThreshold", () => (production ? 50000 : 30000));
+		F(splitChunks, "maxAsyncRequests", () => (production ? 30 : Infinity));
+		F(splitChunks, "maxInitialRequests", () => (production ? 30 : Infinity));
+		D(splitChunks, "automaticNameDelimiter", "-");
+		const { cacheGroups } = splitChunks;
+		F(cacheGroups, "default", () => ({
+			idHint: "",
+			reuseExistingChunk: true,
+			minChunks: 2,
+			priority: -20
+		}));
+		F(cacheGroups, "defaultVendors", () => ({
+			idHint: "vendors",
+			reuseExistingChunk: true,
+			test: NODE_MODULES_REGEXP,
+			priority: -10
+		}));
 	}
 };
 
-module.exports = HarmonyAcceptDependency;
-
-
-/***/ }),
-
-/***/ 99843:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {Object} options options
+ * @param {boolean} options.cache is cache enable
+ * @param {string} options.context build context
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {Mode} options.mode mode
+ * @returns {ResolveOptions} resolve options
+ */
+const getResolveDefaults = ({ cache, context, targetProperties, mode }) => {
+	/** @type {string[]} */
+	const conditions = ["webpack"];
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	conditions.push(mode === "development" ? "development" : "production");
 
+	if (targetProperties) {
+		if (targetProperties.webworker) conditions.push("worker");
+		if (targetProperties.node) conditions.push("node");
+		if (targetProperties.web) conditions.push("browser");
+		if (targetProperties.electron) conditions.push("electron");
+		if (targetProperties.nwjs) conditions.push("nwjs");
+	}
 
+	const jsExtensions = [".js", ".json", ".wasm"];
 
-const makeSerializable = __webpack_require__(33032);
-const HarmonyImportDependency = __webpack_require__(57154);
+	const tp = targetProperties;
+	const browserField =
+		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+	/** @type {function(): ResolveOptions} */
+	const cjsDeps = () => ({
+		aliasFields: browserField ? ["browser"] : [],
+		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
+		conditionNames: ["require", "module", "..."],
+		extensions: [...jsExtensions]
+	});
+	/** @type {function(): ResolveOptions} */
+	const esmDeps = () => ({
+		aliasFields: browserField ? ["browser"] : [],
+		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
+		conditionNames: ["import", "module", "..."],
+		extensions: [...jsExtensions]
+	});
 
-class HarmonyAcceptImportDependency extends HarmonyImportDependency {
-	constructor(request) {
-		super(request, NaN);
-		this.weak = true;
-	}
+	/** @type {ResolveOptions} */
+	const resolveOptions = {
+		cache,
+		modules: ["node_modules"],
+		conditionNames: conditions,
+		mainFiles: ["index"],
+		extensions: [],
+		aliasFields: [],
+		exportsFields: ["exports"],
+		roots: [context],
+		mainFields: ["main"],
+		byDependency: {
+			wasm: esmDeps(),
+			esm: esmDeps(),
+			loaderImport: esmDeps(),
+			url: {
+				preferRelative: true
+			},
+			worker: {
+				...esmDeps(),
+				preferRelative: true
+			},
+			commonjs: cjsDeps(),
+			amd: cjsDeps(),
+			// for backward-compat: loadModule
+			loader: cjsDeps(),
+			// for backward-compat: Custom Dependency
+			unknown: cjsDeps(),
+			// for backward-compat: getResolve without dependencyType
+			undefined: cjsDeps()
+		}
+	};
 
-	get type() {
-		return "harmony accept";
-	}
-}
+	return resolveOptions;
+};
 
-makeSerializable(
-	HarmonyAcceptImportDependency,
-	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
-);
+/**
+ * @param {Object} options options
+ * @param {boolean} options.cache is cache enable
+ * @returns {ResolveOptions} resolve options
+ */
+const getResolveLoaderDefaults = ({ cache }) => {
+	/** @type {ResolveOptions} */
+	const resolveOptions = {
+		cache,
+		conditionNames: ["loader", "require", "node"],
+		exportsFields: ["exports"],
+		mainFields: ["loader", "main"],
+		extensions: [".js"],
+		mainFiles: ["index"]
+	};
 
-HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {};
+	return resolveOptions;
+};
 
-module.exports = HarmonyAcceptImportDependency;
+/**
+ * @param {InfrastructureLogging} infrastructureLogging options
+ * @returns {void}
+ */
+const applyInfrastructureLoggingDefaults = infrastructureLogging => {
+	F(infrastructureLogging, "stream", () => process.stderr);
+	const tty =
+		/** @type {any} */ (infrastructureLogging.stream).isTTY &&
+		process.env.TERM !== "dumb";
+	D(infrastructureLogging, "level", "info");
+	D(infrastructureLogging, "debug", false);
+	D(infrastructureLogging, "colors", tty);
+	D(infrastructureLogging, "appendOnly", !tty);
+};
+
+exports.applyWebpackOptionsBaseDefaults = applyWebpackOptionsBaseDefaults;
+exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
 
 
 /***/ }),
 
-/***/ 72906:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 26693:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -76412,201 +72549,533 @@ module.exports = HarmonyAcceptImportDependency;
 
 
 
-const { UsageState } = __webpack_require__(63686);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-
-class HarmonyCompatibilityDependency extends NullDependency {
-	get type() {
-		return "harmony export header";
-	}
-}
+const util = __webpack_require__(73837);
 
-makeSerializable(
-	HarmonyCompatibilityDependency,
-	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
-);
+/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
+/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 
-HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			runtimeTemplate,
-			moduleGraph,
-			initFragments,
-			runtimeRequirements,
-			runtime,
-			concatenationScope
-		}
-	) {
-		if (concatenationScope) return;
-		const exportsInfo = moduleGraph.getExportsInfo(module);
-		if (
-			exportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
-			UsageState.Unused
-		) {
-			const content = runtimeTemplate.defineEsModuleFlagStatement({
-				exportsArgument: module.exportsArgument,
-				runtimeRequirements
-			});
-			initFragments.push(
-				new InitFragment(
-					content,
-					InitFragment.STAGE_HARMONY_EXPORTS,
-					0,
-					"harmony compatibility"
-				)
-			);
-		}
-		if (moduleGraph.isAsync(module)) {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			runtimeRequirements.add(RuntimeGlobals.asyncModule);
-			initFragments.push(
-				new InitFragment(
-					runtimeTemplate.supportsArrowFunction()
-						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
-						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
-					InitFragment.STAGE_ASYNC_BOUNDARY,
-					0,
-					undefined,
-					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
-						module.buildMeta.async ? ", 1" : ""
-					});`
-				)
+const handledDeprecatedNoEmitOnErrors = util.deprecate(
+	(noEmitOnErrors, emitOnErrors) => {
+		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
+			throw new Error(
+				"Conflicting use of 'optimization.noEmitOnErrors' and 'optimization.emitOnErrors'. Remove deprecated 'optimization.noEmitOnErrors' from config."
 			);
 		}
-	}
-};
-
-module.exports = HarmonyCompatibilityDependency;
-
-
-/***/ }),
+		return !noEmitOnErrors;
+	},
+	"optimization.noEmitOnErrors is deprecated in favor of optimization.emitOnErrors",
+	"DEP_WEBPACK_CONFIGURATION_OPTIMIZATION_NO_EMIT_ON_ERRORS"
+);
 
-/***/ 17223:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @template T
+ * @template R
+ * @param {T|undefined} value value or not
+ * @param {function(T): R} fn nested handler
+ * @returns {R} result value
+ */
+const nestedConfig = (value, fn) =>
+	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @template T
+ * @param {T|undefined} value value or not
+ * @returns {T} result value
+ */
+const cloneObject = value => {
+	return /** @type {T} */ ({ ...value });
+};
 
+/**
+ * @template T
+ * @template R
+ * @param {T|undefined} value value or not
+ * @param {function(T): R} fn nested handler
+ * @returns {R|undefined} result value
+ */
+const optionalNestedConfig = (value, fn) =>
+	value === undefined ? undefined : fn(value);
 
+/**
+ * @template T
+ * @template R
+ * @param {T[]|undefined} value array or not
+ * @param {function(T[]): R[]} fn nested handler
+ * @returns {R[]|undefined} cloned value
+ */
+const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
 
-const DynamicExports = __webpack_require__(32006);
-const HarmonyCompatibilityDependency = __webpack_require__(72906);
-const HarmonyExports = __webpack_require__(39211);
+/**
+ * @template T
+ * @template R
+ * @param {T[]|undefined} value array or not
+ * @param {function(T[]): R[]} fn nested handler
+ * @returns {R[]|undefined} cloned value
+ */
+const optionalNestedArray = (value, fn) =>
+	Array.isArray(value) ? fn(value) : undefined;
 
-module.exports = class HarmonyDetectionParserPlugin {
-	constructor(options) {
-		const { topLevelAwait = false } = options || {};
-		this.topLevelAwait = topLevelAwait;
+/**
+ * @template T
+ * @template R
+ * @param {Record<string, T>|undefined} value value or not
+ * @param {function(T): R} fn nested handler
+ * @param {Record<string, function(T): R>=} customKeys custom nested handler for some keys
+ * @returns {Record<string, R>} result value
+ */
+const keyedNestedConfig = (value, fn, customKeys) => {
+	const result =
+		value === undefined
+			? {}
+			: Object.keys(value).reduce(
+					(obj, key) => (
+						(obj[key] = (
+							customKeys && key in customKeys ? customKeys[key] : fn
+						)(value[key])),
+						obj
+					),
+					/** @type {Record<string, R>} */ ({})
+			  );
+	if (customKeys) {
+		for (const key of Object.keys(customKeys)) {
+			if (!(key in result)) {
+				result[key] = customKeys[key](/** @type {T} */ ({}));
+			}
+		}
 	}
+	return result;
+};
 
-	apply(parser) {
-		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
-			const isStrictHarmony = parser.state.module.type === "javascript/esm";
-			const isHarmony =
-				isStrictHarmony ||
-				ast.body.some(
-					statement =>
-						statement.type === "ImportDeclaration" ||
-						statement.type === "ExportDefaultDeclaration" ||
-						statement.type === "ExportNamedDeclaration" ||
-						statement.type === "ExportAllDeclaration"
-				);
-			if (isHarmony) {
-				const module = parser.state.module;
-				const compatDep = new HarmonyCompatibilityDependency();
-				compatDep.loc = {
-					start: {
-						line: -1,
-						column: 0
-					},
-					end: {
-						line: -1,
-						column: 0
-					},
-					index: -3
+/**
+ * @param {WebpackOptions} config input config
+ * @returns {WebpackOptionsNormalized} normalized options
+ */
+const getNormalizedWebpackOptions = config => {
+	return {
+		amd: config.amd,
+		bail: config.bail,
+		cache: optionalNestedConfig(config.cache, cache => {
+			if (cache === false) return false;
+			if (cache === true) {
+				return {
+					type: "memory",
+					maxGenerations: undefined
+				};
+			}
+			switch (cache.type) {
+				case "filesystem":
+					return {
+						type: "filesystem",
+						allowCollectingMemory: cache.allowCollectingMemory,
+						maxMemoryGenerations: cache.maxMemoryGenerations,
+						maxAge: cache.maxAge,
+						profile: cache.profile,
+						buildDependencies: cloneObject(cache.buildDependencies),
+						cacheDirectory: cache.cacheDirectory,
+						cacheLocation: cache.cacheLocation,
+						hashAlgorithm: cache.hashAlgorithm,
+						compression: cache.compression,
+						idleTimeout: cache.idleTimeout,
+						idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
+						idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
+						name: cache.name,
+						store: cache.store,
+						version: cache.version
+					};
+				case undefined:
+				case "memory":
+					return {
+						type: "memory",
+						maxGenerations: cache.maxGenerations
+					};
+				default:
+					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+					throw new Error(`Not implemented cache.type ${cache.type}`);
+			}
+		}),
+		context: config.context,
+		dependencies: config.dependencies,
+		devServer: optionalNestedConfig(config.devServer, devServer => ({
+			...devServer
+		})),
+		devtool: config.devtool,
+		entry:
+			config.entry === undefined
+				? { main: {} }
+				: typeof config.entry === "function"
+				? (
+						fn => () =>
+							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
+				  )(config.entry)
+				: getNormalizedEntryStatic(config.entry),
+		experiments: nestedConfig(config.experiments, experiments => ({
+			...experiments,
+			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
+				Array.isArray(options) ? { allowedUris: options } : options
+			),
+			lazyCompilation: optionalNestedConfig(
+				experiments.lazyCompilation,
+				options =>
+					options === true ? {} : options === false ? undefined : options
+			),
+			css: optionalNestedConfig(experiments.css, options =>
+				options === true ? {} : options === false ? undefined : options
+			)
+		})),
+		externals: config.externals,
+		externalsPresets: cloneObject(config.externalsPresets),
+		externalsType: config.externalsType,
+		ignoreWarnings: config.ignoreWarnings
+			? config.ignoreWarnings.map(ignore => {
+					if (typeof ignore === "function") return ignore;
+					const i = ignore instanceof RegExp ? { message: ignore } : ignore;
+					return (warning, { requestShortener }) => {
+						if (!i.message && !i.module && !i.file) return false;
+						if (i.message && !i.message.test(warning.message)) {
+							return false;
+						}
+						if (
+							i.module &&
+							(!warning.module ||
+								!i.module.test(
+									warning.module.readableIdentifier(requestShortener)
+								))
+						) {
+							return false;
+						}
+						if (i.file && (!warning.file || !i.file.test(warning.file))) {
+							return false;
+						}
+						return true;
+					};
+			  })
+			: undefined,
+		infrastructureLogging: cloneObject(config.infrastructureLogging),
+		loader: cloneObject(config.loader),
+		mode: config.mode,
+		module: nestedConfig(config.module, module => ({
+			noParse: module.noParse,
+			unsafeCache: module.unsafeCache,
+			parser: keyedNestedConfig(module.parser, cloneObject, {
+				javascript: parserOptions => ({
+					unknownContextRequest: module.unknownContextRequest,
+					unknownContextRegExp: module.unknownContextRegExp,
+					unknownContextRecursive: module.unknownContextRecursive,
+					unknownContextCritical: module.unknownContextCritical,
+					exprContextRequest: module.exprContextRequest,
+					exprContextRegExp: module.exprContextRegExp,
+					exprContextRecursive: module.exprContextRecursive,
+					exprContextCritical: module.exprContextCritical,
+					wrappedContextRegExp: module.wrappedContextRegExp,
+					wrappedContextRecursive: module.wrappedContextRecursive,
+					wrappedContextCritical: module.wrappedContextCritical,
+					// TODO webpack 6 remove
+					strictExportPresence: module.strictExportPresence,
+					strictThisContextOnImports: module.strictThisContextOnImports,
+					...parserOptions
+				})
+			}),
+			generator: cloneObject(module.generator),
+			defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
+			rules: nestedArray(module.rules, r => [...r])
+		})),
+		name: config.name,
+		node: nestedConfig(
+			config.node,
+			node =>
+				node && {
+					...node
+				}
+		),
+		optimization: nestedConfig(config.optimization, optimization => {
+			return {
+				...optimization,
+				runtimeChunk: getNormalizedOptimizationRuntimeChunk(
+					optimization.runtimeChunk
+				),
+				splitChunks: nestedConfig(
+					optimization.splitChunks,
+					splitChunks =>
+						splitChunks && {
+							...splitChunks,
+							defaultSizeTypes: splitChunks.defaultSizeTypes
+								? [...splitChunks.defaultSizeTypes]
+								: ["..."],
+							cacheGroups: cloneObject(splitChunks.cacheGroups)
+						}
+				),
+				emitOnErrors:
+					optimization.noEmitOnErrors !== undefined
+						? handledDeprecatedNoEmitOnErrors(
+								optimization.noEmitOnErrors,
+								optimization.emitOnErrors
+						  )
+						: optimization.emitOnErrors
+			};
+		}),
+		output: nestedConfig(config.output, output => {
+			const { library } = output;
+			const libraryAsName = /** @type {LibraryName} */ (library);
+			const libraryBase =
+				typeof library === "object" &&
+				library &&
+				!Array.isArray(library) &&
+				"type" in library
+					? library
+					: libraryAsName || output.libraryTarget
+					? /** @type {LibraryOptions} */ ({
+							name: libraryAsName
+					  })
+					: undefined;
+			/** @type {OutputNormalized} */
+			const result = {
+				assetModuleFilename: output.assetModuleFilename,
+				asyncChunks: output.asyncChunks,
+				charset: output.charset,
+				chunkFilename: output.chunkFilename,
+				chunkFormat: output.chunkFormat,
+				chunkLoading: output.chunkLoading,
+				chunkLoadingGlobal: output.chunkLoadingGlobal,
+				chunkLoadTimeout: output.chunkLoadTimeout,
+				cssFilename: output.cssFilename,
+				cssChunkFilename: output.cssChunkFilename,
+				clean: output.clean,
+				compareBeforeEmit: output.compareBeforeEmit,
+				crossOriginLoading: output.crossOriginLoading,
+				devtoolFallbackModuleFilenameTemplate:
+					output.devtoolFallbackModuleFilenameTemplate,
+				devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
+				devtoolNamespace: output.devtoolNamespace,
+				environment: cloneObject(output.environment),
+				enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
+					? [...output.enabledChunkLoadingTypes]
+					: ["..."],
+				enabledLibraryTypes: output.enabledLibraryTypes
+					? [...output.enabledLibraryTypes]
+					: ["..."],
+				enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
+					? [...output.enabledWasmLoadingTypes]
+					: ["..."],
+				filename: output.filename,
+				globalObject: output.globalObject,
+				hashDigest: output.hashDigest,
+				hashDigestLength: output.hashDigestLength,
+				hashFunction: output.hashFunction,
+				hashSalt: output.hashSalt,
+				hotUpdateChunkFilename: output.hotUpdateChunkFilename,
+				hotUpdateGlobal: output.hotUpdateGlobal,
+				hotUpdateMainFilename: output.hotUpdateMainFilename,
+				iife: output.iife,
+				importFunctionName: output.importFunctionName,
+				importMetaName: output.importMetaName,
+				scriptType: output.scriptType,
+				library: libraryBase && {
+					type:
+						output.libraryTarget !== undefined
+							? output.libraryTarget
+							: libraryBase.type,
+					auxiliaryComment:
+						output.auxiliaryComment !== undefined
+							? output.auxiliaryComment
+							: libraryBase.auxiliaryComment,
+					export:
+						output.libraryExport !== undefined
+							? output.libraryExport
+							: libraryBase.export,
+					name: libraryBase.name,
+					umdNamedDefine:
+						output.umdNamedDefine !== undefined
+							? output.umdNamedDefine
+							: libraryBase.umdNamedDefine
+				},
+				module: output.module,
+				path: output.path,
+				pathinfo: output.pathinfo,
+				publicPath: output.publicPath,
+				sourceMapFilename: output.sourceMapFilename,
+				sourcePrefix: output.sourcePrefix,
+				strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+				trustedTypes: optionalNestedConfig(
+					output.trustedTypes,
+					trustedTypes => {
+						if (trustedTypes === true) return {};
+						if (typeof trustedTypes === "string")
+							return { policyName: trustedTypes };
+						return { ...trustedTypes };
+					}
+				),
+				uniqueName: output.uniqueName,
+				wasmLoading: output.wasmLoading,
+				webassemblyModuleFilename: output.webassemblyModuleFilename,
+				workerChunkLoading: output.workerChunkLoading,
+				workerWasmLoading: output.workerWasmLoading
+			};
+			return result;
+		}),
+		parallelism: config.parallelism,
+		performance: optionalNestedConfig(config.performance, performance => {
+			if (performance === false) return false;
+			return {
+				...performance
+			};
+		}),
+		plugins: nestedArray(config.plugins, p => [...p]),
+		profile: config.profile,
+		recordsInputPath:
+			config.recordsInputPath !== undefined
+				? config.recordsInputPath
+				: config.recordsPath,
+		recordsOutputPath:
+			config.recordsOutputPath !== undefined
+				? config.recordsOutputPath
+				: config.recordsPath,
+		resolve: nestedConfig(config.resolve, resolve => ({
+			...resolve,
+			byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
+		})),
+		resolveLoader: cloneObject(config.resolveLoader),
+		snapshot: nestedConfig(config.snapshot, snapshot => ({
+			resolveBuildDependencies: optionalNestedConfig(
+				snapshot.resolveBuildDependencies,
+				resolveBuildDependencies => ({
+					timestamp: resolveBuildDependencies.timestamp,
+					hash: resolveBuildDependencies.hash
+				})
+			),
+			buildDependencies: optionalNestedConfig(
+				snapshot.buildDependencies,
+				buildDependencies => ({
+					timestamp: buildDependencies.timestamp,
+					hash: buildDependencies.hash
+				})
+			),
+			resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
+				timestamp: resolve.timestamp,
+				hash: resolve.hash
+			})),
+			module: optionalNestedConfig(snapshot.module, module => ({
+				timestamp: module.timestamp,
+				hash: module.hash
+			})),
+			immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
+			managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p])
+		})),
+		stats: nestedConfig(config.stats, stats => {
+			if (stats === false) {
+				return {
+					preset: "none"
 				};
-				module.addPresentationalDependency(compatDep);
-				DynamicExports.bailout(parser.state);
-				HarmonyExports.enable(parser.state, isStrictHarmony);
-				parser.scope.isStrict = true;
 			}
-		});
-
-		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
-			const module = parser.state.module;
-			if (!this.topLevelAwait) {
-				throw new Error(
-					"The top-level-await experiment is not enabled (set experiments.topLevelAwait: true to enabled it)"
-				);
+			if (stats === true) {
+				return {
+					preset: "normal"
+				};
 			}
-			if (!HarmonyExports.isEnabled(parser.state)) {
-				throw new Error(
-					"Top-level-await is only supported in EcmaScript Modules"
-				);
+			if (typeof stats === "string") {
+				return {
+					preset: stats
+				};
 			}
-			module.buildMeta.async = true;
-		});
+			return {
+				...stats
+			};
+		}),
+		target: config.target,
+		watch: config.watch,
+		watchOptions: cloneObject(config.watchOptions)
+	};
+};
 
-		const skipInHarmony = () => {
-			if (HarmonyExports.isEnabled(parser.state)) {
-				return true;
+/**
+ * @param {EntryStatic} entry static entry options
+ * @returns {EntryStaticNormalized} normalized static entry options
+ */
+const getNormalizedEntryStatic = entry => {
+	if (typeof entry === "string") {
+		return {
+			main: {
+				import: [entry]
 			}
 		};
-
-		const nullInHarmony = () => {
-			if (HarmonyExports.isEnabled(parser.state)) {
-				return null;
+	}
+	if (Array.isArray(entry)) {
+		return {
+			main: {
+				import: entry
 			}
 		};
-
-		const nonHarmonyIdentifiers = ["define", "exports"];
-		for (const identifier of nonHarmonyIdentifiers) {
-			parser.hooks.evaluateTypeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.typeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.evaluate
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.expression
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.call
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+	}
+	/** @type {EntryStaticNormalized} */
+	const result = {};
+	for (const key of Object.keys(entry)) {
+		const value = entry[key];
+		if (typeof value === "string") {
+			result[key] = {
+				import: [value]
+			};
+		} else if (Array.isArray(value)) {
+			result[key] = {
+				import: value
+			};
+		} else {
+			result[key] = {
+				import:
+					value.import &&
+					(Array.isArray(value.import) ? value.import : [value.import]),
+				filename: value.filename,
+				layer: value.layer,
+				runtime: value.runtime,
+				publicPath: value.publicPath,
+				chunkLoading: value.chunkLoading,
+				asyncChunks: value.asyncChunks,
+				wasmLoading: value.wasmLoading,
+				dependOn:
+					value.dependOn &&
+					(Array.isArray(value.dependOn) ? value.dependOn : [value.dependOn]),
+				library: value.library
+			};
 		}
 	}
+	return result;
+};
+
+/**
+ * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
+ * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
+ */
+const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
+	if (runtimeChunk === undefined) return undefined;
+	if (runtimeChunk === false) return false;
+	if (runtimeChunk === "single") {
+		return {
+			name: () => "runtime"
+		};
+	}
+	if (runtimeChunk === true || runtimeChunk === "multiple") {
+		return {
+			name: entrypoint => `runtime~${entrypoint.name}`
+		};
+	}
+	const { name } = runtimeChunk;
+	return {
+		name: typeof name === "function" ? name : () => name
+	};
 };
 
+exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
+
 
 /***/ }),
 
-/***/ 93466:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 52801:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -76616,2032 +73085,1649 @@ module.exports = class HarmonyDetectionParserPlugin {
 
 
 
-const InnerGraph = __webpack_require__(38988);
-const ConstDependency = __webpack_require__(76911);
-const HarmonyExportExpressionDependency = __webpack_require__(51340);
-const HarmonyExportHeaderDependency = __webpack_require__(38873);
-const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
-const HarmonyExportSpecifierDependency = __webpack_require__(48567);
-const { ExportPresenceModes } = __webpack_require__(57154);
-const {
-	harmonySpecifierTag,
-	getAssertions
-} = __webpack_require__(20862);
-const HarmonyImportSideEffectDependency = __webpack_require__(73132);
-
-const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
+const memoize = __webpack_require__(78676);
 
-module.exports = class HarmonyExportDependencyParserPlugin {
-	constructor(options) {
-		this.exportPresenceMode =
-			options.reexportExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
-				: options.exportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.exportsPresence)
-				: options.strictExportPresence
-				? ExportPresenceModes.ERROR
-				: ExportPresenceModes.AUTO;
-	}
+const getBrowserslistTargetHandler = memoize(() =>
+	__webpack_require__(43950)
+);
 
-	apply(parser) {
-		const { exportPresenceMode } = this;
-		parser.hooks.export.tap(
-			"HarmonyExportDependencyParserPlugin",
-			statement => {
-				const dep = new HarmonyExportHeaderDependency(
-					statement.declaration && statement.declaration.range,
-					statement.range
-				);
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = -1;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			}
-		);
-		parser.hooks.exportImport.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, source) => {
-				parser.state.lastHarmonyImportOrder =
-					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency("", statement.range);
-				clearDep.loc = Object.create(statement.loc);
-				clearDep.loc.index = -1;
-				parser.state.module.addPresentationalDependency(clearDep);
-				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					source,
-					parser.state.lastHarmonyImportOrder,
-					getAssertions(statement)
-				);
-				sideEffectDep.loc = Object.create(statement.loc);
-				sideEffectDep.loc.index = -1;
-				parser.state.current.addDependency(sideEffectDep);
-				return true;
-			}
-		);
-		parser.hooks.exportExpression.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, expr) => {
-				const isFunctionDeclaration = expr.type === "FunctionDeclaration";
-				const comments = parser.getComments([
-					statement.range[0],
-					expr.range[0]
-				]);
-				const dep = new HarmonyExportExpressionDependency(
-					expr.range,
-					statement.range,
-					comments
-						.map(c => {
-							switch (c.type) {
-								case "Block":
-									return `/*${c.value}*/`;
-								case "Line":
-									return `//${c.value}\n`;
-							}
-							return "";
-						})
-						.join(""),
-					expr.type.endsWith("Declaration") && expr.id
-						? expr.id.name
-						: isFunctionDeclaration
-						? {
-								id: expr.id ? expr.id.name : undefined,
-								range: [
-									expr.range[0],
-									expr.params.length > 0
-										? expr.params[0].range[0]
-										: expr.body.range[0]
-								],
-								prefix: `${expr.async ? "async " : ""}function${
-									expr.generator ? "*" : ""
-								} `,
-								suffix: `(${expr.params.length > 0 ? "" : ") "}`
-						  }
-						: undefined
-				);
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = -1;
-				parser.state.current.addDependency(dep);
-				InnerGraph.addVariableUsage(
-					parser,
-					expr.type.endsWith("Declaration") && expr.id
-						? expr.id.name
-						: "*default*",
-					"default"
-				);
-				return true;
-			}
-		);
-		parser.hooks.exportSpecifier.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, id, name, idx) => {
-				const settings = parser.getTagData(id, harmonySpecifierTag);
-				let dep;
-				const harmonyNamedExports = (parser.state.harmonyNamedExports =
-					parser.state.harmonyNamedExports || new Set());
-				harmonyNamedExports.add(name);
-				InnerGraph.addVariableUsage(parser, id, name);
-				if (settings) {
-					dep = new HarmonyExportImportedSpecifierDependency(
-						settings.source,
-						settings.sourceOrder,
-						settings.ids,
-						name,
-						harmonyNamedExports,
-						null,
-						exportPresenceMode,
-						null,
-						settings.assertions
-					);
-				} else {
-					dep = new HarmonyExportSpecifierDependency(id, name);
-				}
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = idx;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		);
-		parser.hooks.exportImportSpecifier.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, source, id, name, idx) => {
-				const harmonyNamedExports = (parser.state.harmonyNamedExports =
-					parser.state.harmonyNamedExports || new Set());
-				let harmonyStarExports = null;
-				if (name) {
-					harmonyNamedExports.add(name);
-				} else {
-					harmonyStarExports = parser.state.harmonyStarExports =
-						parser.state.harmonyStarExports || new HarmonyStarExportsList();
-				}
-				const dep = new HarmonyExportImportedSpecifierDependency(
-					source,
-					parser.state.lastHarmonyImportOrder,
-					id ? [id] : [],
-					name,
-					harmonyNamedExports,
-					harmonyStarExports && harmonyStarExports.slice(),
-					exportPresenceMode,
-					harmonyStarExports
-				);
-				if (harmonyStarExports) {
-					harmonyStarExports.push(dep);
-				}
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = idx;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		);
-	}
+/**
+ * @param {string} context the context directory
+ * @returns {string} default target
+ */
+const getDefaultTarget = context => {
+	const browsers = getBrowserslistTargetHandler().load(null, context);
+	return browsers ? "browserslist" : "web";
 };
 
+/**
+ * @typedef {Object} PlatformTargetProperties
+ * @property {boolean | null} web web platform, importing of http(s) and std: is available
+ * @property {boolean | null} browser browser platform, running in a normal web browser
+ * @property {boolean | null} webworker (Web)Worker platform, running in a web/shared/service worker
+ * @property {boolean | null} node node platform, require of node built-in modules is available
+ * @property {boolean | null} nwjs nwjs platform, require of legacy nw.gui is available
+ * @property {boolean | null} electron electron platform, require of some electron built-in modules is available
+ */
 
-/***/ }),
+/**
+ * @typedef {Object} ElectronContextTargetProperties
+ * @property {boolean | null} electronMain in main context
+ * @property {boolean | null} electronPreload in preload context
+ * @property {boolean | null} electronRenderer in renderer context with node integration
+ */
 
-/***/ 51340:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @typedef {Object} ApiTargetProperties
+ * @property {boolean | null} require has require function available
+ * @property {boolean | null} nodeBuiltins has node.js built-in modules available
+ * @property {boolean | null} document has document available (allows script tags)
+ * @property {boolean | null} importScripts has importScripts available
+ * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
+ * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
+ * @property {boolean | null} global has global variable available
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @typedef {Object} EcmaTargetProperties
+ * @property {boolean | null} globalThis has globalThis variable available
+ * @property {boolean | null} bigIntLiteral big int literal syntax is available
+ * @property {boolean | null} const const and let variable declarations are available
+ * @property {boolean | null} arrowFunction arrow functions are available
+ * @property {boolean | null} forOf for of iteration is available
+ * @property {boolean | null} destructuring destructuring is available
+ * @property {boolean | null} dynamicImport async import() is available
+ * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
+ * @property {boolean | null} module ESM syntax is available (when in module)
+ * @property {boolean | null} optionalChaining optional chaining is available
+ * @property {boolean | null} templateLiteral template literal is available
+ */
 
+///** @typedef {PlatformTargetProperties | ApiTargetProperties | EcmaTargetProperties | PlatformTargetProperties & ApiTargetProperties | PlatformTargetProperties & EcmaTargetProperties | ApiTargetProperties & EcmaTargetProperties} TargetProperties */
+/** @template T @typedef {{ [P in keyof T]?: never }} Never<T> */
+/** @template A @template B @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A,B> */
+/** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
 
+const versionDependent = (major, minor) => {
+	if (!major) return () => /** @type {undefined} */ (undefined);
+	major = +major;
+	minor = minor ? +minor : 0;
+	return (vMajor, vMinor = 0) => {
+		return major > vMajor || (major === vMajor && minor >= vMinor);
+	};
+};
 
-const ConcatenationScope = __webpack_require__(98229);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const HarmonyExportInitFragment = __webpack_require__(89500);
-const NullDependency = __webpack_require__(31830);
+/** @type {[string, string, RegExp, (...args: string[]) => TargetProperties | false][]} */
+const TARGETS = [
+	[
+		"browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
+		"Resolve features from browserslist. Will resolve browserslist config automatically. Only browser or node queries are supported (electron is not supported). Examples: 'browserslist:modern' to use 'modern' environment from browserslist config",
+		/^browserslist(?::(.+))?$/,
+		(rest, context) => {
+			const browserslistTargetHandler = getBrowserslistTargetHandler();
+			const browsers = browserslistTargetHandler.load(
+				rest ? rest.trim() : null,
+				context
+			);
+			if (!browsers) {
+				throw new Error(`No browserslist config found to handle the 'browserslist' target.
+See https://github.com/browserslist/browserslist#queries for possible ways to provide a config.
+The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
+You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
+			}
+			return browserslistTargetHandler.resolve(browsers);
+		}
+	],
+	[
+		"web",
+		"Web browser.",
+		/^web$/,
+		() => {
+			return {
+				web: true,
+				browser: true,
+				webworker: null,
+				node: false,
+				electron: false,
+				nwjs: false,
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+				document: true,
+				importScriptsInWorker: true,
+				fetchWasm: true,
+				nodeBuiltins: false,
+				importScripts: false,
+				require: false,
+				global: false
+			};
+		}
+	],
+	[
+		"webworker",
+		"Web Worker, SharedWorker or Service Worker.",
+		/^webworker$/,
+		() => {
+			return {
+				web: true,
+				browser: true,
+				webworker: true,
+				node: false,
+				electron: false,
+				nwjs: false,
 
-class HarmonyExportExpressionDependency extends NullDependency {
-	constructor(range, rangeStatement, prefix, declarationId) {
-		super();
-		this.range = range;
-		this.rangeStatement = rangeStatement;
-		this.prefix = prefix;
-		this.declarationId = declarationId;
-	}
+				importScripts: true,
+				importScriptsInWorker: true,
+				fetchWasm: true,
+				nodeBuiltins: false,
+				require: false,
+				document: false,
+				global: false
+			};
+		}
+	],
+	[
+		"[async-]node[X[.Y]]",
+		"Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
+		/^(async-)?node(\d+(?:\.(\d+))?)?$/,
+		(asyncFlag, major, minor) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/
+			return {
+				node: true,
+				electron: false,
+				nwjs: false,
+				web: false,
+				webworker: false,
+				browser: false,
 
-	get type() {
-		return "harmony export expression";
-	}
+				require: !asyncFlag,
+				nodeBuiltins: true,
+				global: true,
+				document: false,
+				fetchWasm: false,
+				importScripts: false,
+				importScriptsInWorker: false,
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: ["default"],
-			priority: 1,
-			terminalBinding: true,
-			dependencies: undefined
-		};
-	}
+				globalThis: v(12),
+				const: v(6),
+				templateLiteral: v(4),
+				optionalChaining: v(14),
+				arrowFunction: v(6),
+				forOf: v(5),
+				destructuring: v(6),
+				bigIntLiteral: v(10, 4),
+				dynamicImport: v(12, 17),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(12, 17)
+			};
+		}
+	],
+	[
+		"electron[X[.Y]]-main/preload/renderer",
+		"Electron in version X.Y. Script is running in main, preload resp. renderer context.",
+		/^electron(\d+(?:\.(\d+))?)?-(main|preload|renderer)$/,
+		(major, minor, context) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/ + https://github.com/electron/releases
+			return {
+				node: true,
+				electron: true,
+				web: context !== "main",
+				webworker: false,
+				browser: false,
+				nwjs: false,
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		// The expression/declaration is already covered by SideEffectsFlagPlugin
-		return false;
-	}
+				electronMain: context === "main",
+				electronPreload: context === "preload",
+				electronRenderer: context === "renderer",
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.rangeStatement);
-		write(this.prefix);
-		write(this.declarationId);
-		super.serialize(context);
-	}
+				global: true,
+				nodeBuiltins: true,
+				require: true,
+				document: context === "renderer",
+				fetchWasm: context === "renderer",
+				importScripts: false,
+				importScriptsInWorker: true,
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.rangeStatement = read();
-		this.prefix = read();
-		this.declarationId = read();
-		super.deserialize(context);
-	}
-}
+				globalThis: v(5),
+				const: v(1, 1),
+				templateLiteral: v(1, 1),
+				optionalChaining: v(8),
+				arrowFunction: v(1, 1),
+				forOf: v(0, 36),
+				destructuring: v(1, 1),
+				bigIntLiteral: v(4),
+				dynamicImport: v(11),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(11)
+			};
+		}
+	],
+	[
+		"nwjs[X[.Y]] / node-webkit[X[.Y]]",
+		"NW.js in version X.Y.",
+		/^(?:nwjs|node-webkit)(\d+(?:\.(\d+))?)?$/,
+		(major, minor) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
+			return {
+				node: true,
+				web: true,
+				nwjs: true,
+				webworker: null,
+				browser: false,
+				electron: false,
 
-makeSerializable(
-	HarmonyExportExpressionDependency,
-	"webpack/lib/dependencies/HarmonyExportExpressionDependency"
-);
+				global: true,
+				nodeBuiltins: true,
+				document: false,
+				importScriptsInWorker: false,
+				fetchWasm: false,
+				importScripts: false,
+				require: false,
 
-HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			moduleGraph,
-			runtimeTemplate,
-			runtimeRequirements,
-			initFragments,
-			runtime,
-			concatenationScope
+				globalThis: v(0, 43),
+				const: v(0, 15),
+				templateLiteral: v(0, 13),
+				optionalChaining: v(0, 44),
+				arrowFunction: v(0, 15),
+				forOf: v(0, 13),
+				destructuring: v(0, 15),
+				bigIntLiteral: v(0, 32),
+				dynamicImport: v(0, 43),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(0, 43)
+			};
 		}
-	) {
-		const dep = /** @type {HarmonyExportExpressionDependency} */ (dependency);
-		const { declarationId } = dep;
-		const exportsName = module.exportsArgument;
-		if (declarationId) {
-			let name;
-			if (typeof declarationId === "string") {
-				name = declarationId;
-			} else {
-				name = ConcatenationScope.DEFAULT_EXPORT;
-				source.replace(
-					declarationId.range[0],
-					declarationId.range[1] - 1,
-					`${declarationId.prefix}${name}${declarationId.suffix}`
-				);
-			}
-
-			if (concatenationScope) {
-				concatenationScope.registerExport("default", name);
-			} else {
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName("default", runtime);
-				if (used) {
-					const map = new Map();
-					map.set(used, `/* export default binding */ ${name}`);
-					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
-				}
-			}
+	],
+	[
+		"esX",
+		"EcmaScript in this version. Examples: es2020, es5.",
+		/^es(\d+)$/,
+		version => {
+			let v = +version;
+			if (v < 1000) v = v + 2009;
+			return {
+				const: v >= 2015,
+				templateLiteral: v >= 2015,
+				optionalChaining: v >= 2020,
+				arrowFunction: v >= 2015,
+				forOf: v >= 2015,
+				destructuring: v >= 2015,
+				module: v >= 2015,
+				globalThis: v >= 2020,
+				bigIntLiteral: v >= 2020,
+				dynamicImport: v >= 2020,
+				dynamicImportInWorker: v >= 2020
+			};
+		}
+	]
+];
 
-			source.replace(
-				dep.rangeStatement[0],
-				dep.range[0] - 1,
-				`/* harmony default export */ ${dep.prefix}`
-			);
-		} else {
-			let content;
-			const name = ConcatenationScope.DEFAULT_EXPORT;
-			if (runtimeTemplate.supportsConst()) {
-				content = `/* harmony default export */ const ${name} = `;
-				if (concatenationScope) {
-					concatenationScope.registerExport("default", name);
-				} else {
-					const used = moduleGraph
-						.getExportsInfo(module)
-						.getUsedName("default", runtime);
-					if (used) {
-						runtimeRequirements.add(RuntimeGlobals.exports);
-						const map = new Map();
-						map.set(used, name);
-						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
-					} else {
-						content = `/* unused harmony default export */ var ${name} = `;
-					}
-				}
-			} else if (concatenationScope) {
-				content = `/* harmony default export */ var ${name} = `;
-				concatenationScope.registerExport("default", name);
-			} else {
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName("default", runtime);
-				if (used) {
-					runtimeRequirements.add(RuntimeGlobals.exports);
-					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					content = `/* harmony default export */ ${exportsName}[${JSON.stringify(
-						used
-					)}] = `;
-				} else {
-					content = `/* unused harmony default export */ var ${name} = `;
-				}
-			}
+/**
+ * @param {string} target the target
+ * @param {string} context the context directory
+ * @returns {TargetProperties} target properties
+ */
+const getTargetProperties = (target, context) => {
+	for (const [, , regExp, handler] of TARGETS) {
+		const match = regExp.exec(target);
+		if (match) {
+			const [, ...args] = match;
+			const result = handler(...args, context);
+			if (result) return result;
+		}
+	}
+	throw new Error(
+		`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(
+			([name, description]) => `* ${name}: ${description}`
+		).join("\n")}`
+	);
+};
 
-			if (dep.range) {
-				source.replace(
-					dep.rangeStatement[0],
-					dep.range[0] - 1,
-					content + "(" + dep.prefix
-				);
-				source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
-				return;
+const mergeTargetProperties = targetProperties => {
+	const keys = new Set();
+	for (const tp of targetProperties) {
+		for (const key of Object.keys(tp)) {
+			keys.add(key);
+		}
+	}
+	const result = {};
+	for (const key of keys) {
+		let hasTrue = false;
+		let hasFalse = false;
+		for (const tp of targetProperties) {
+			const value = tp[key];
+			switch (value) {
+				case true:
+					hasTrue = true;
+					break;
+				case false:
+					hasFalse = true;
+					break;
 			}
-
-			source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
 		}
+		if (hasTrue || hasFalse)
+			result[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
 	}
+	return /** @type {TargetProperties} */ (result);
 };
 
-module.exports = HarmonyExportExpressionDependency;
+/**
+ * @param {string[]} targets the targets
+ * @param {string} context the context directory
+ * @returns {TargetProperties} target properties
+ */
+const getTargetsProperties = (targets, context) => {
+	return mergeTargetProperties(
+		targets.map(t => getTargetProperties(t, context))
+	);
+};
+
+exports.getDefaultTarget = getDefaultTarget;
+exports.getTargetProperties = getTargetProperties;
+exports.getTargetsProperties = getTargetsProperties;
 
 
 /***/ }),
 
-/***/ 38873:
+/***/ 64813:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
+const Dependency = __webpack_require__(54912);
 const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("./ContainerEntryModule").ExposeOptions} ExposeOptions */
 
-class HarmonyExportHeaderDependency extends NullDependency {
-	constructor(range, rangeStatement) {
+class ContainerEntryDependency extends Dependency {
+	/**
+	 * @param {string} name entry name
+	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
+	 * @param {string} shareScope name of the share scope
+	 */
+	constructor(name, exposes, shareScope) {
 		super();
-		this.range = range;
-		this.rangeStatement = rangeStatement;
+		this.name = name;
+		this.exposes = exposes;
+		this.shareScope = shareScope;
 	}
 
-	get type() {
-		return "harmony export header";
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `container-entry-${this.name}`;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.rangeStatement);
-		super.serialize(context);
+	get type() {
+		return "container entry";
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.rangeStatement = read();
-		super.deserialize(context);
+	get category() {
+		return "esm";
 	}
 }
 
 makeSerializable(
-	HarmonyExportHeaderDependency,
-	"webpack/lib/dependencies/HarmonyExportHeaderDependency"
+	ContainerEntryDependency,
+	"webpack/lib/container/ContainerEntryDependency"
 );
 
-HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyExportHeaderDependency} */ (dependency);
-		const content = "";
-		const replaceUntil = dep.range
-			? dep.range[0] - 1
-			: dep.rangeStatement[1] - 1;
-		source.replace(dep.rangeStatement[0], replaceUntil, content);
-	}
-};
-
-module.exports = HarmonyExportHeaderDependency;
+module.exports = ContainerEntryDependency;
 
 
 /***/ }),
 
-/***/ 67157:
+/***/ 80580:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const { UsageState } = __webpack_require__(63686);
-const HarmonyLinkingError = __webpack_require__(97511);
-const InitFragment = __webpack_require__(55870);
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Module = __webpack_require__(73208);
 const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const { countIterable } = __webpack_require__(39104);
-const { first, combine } = __webpack_require__(93347);
+const Template = __webpack_require__(39722);
+const StaticExportsDependency = __webpack_require__(91418);
 const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { getRuntimeKey, keyToRuntime } = __webpack_require__(17156);
-const HarmonyExportInitFragment = __webpack_require__(89500);
-const HarmonyImportDependency = __webpack_require__(57154);
-const processExportInfo = __webpack_require__(55207);
+const ContainerExposedDependency = __webpack_require__(72374);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
-/** @typedef {"missing"|"unused"|"empty-star"|"reexport-dynamic-default"|"reexport-named-default"|"reexport-namespace-object"|"reexport-fake-namespace-object"|"reexport-undefined"|"normal-reexport"|"dynamic-reexport"} ExportModeType */
+/**
+ * @typedef {Object} ExposeOptions
+ * @property {string[]} import requests to exposed modules (last one is exported)
+ * @property {string} name custom chunk name for the exposed module
+ */
 
-const { ExportPresenceModes } = HarmonyImportDependency;
+const SOURCE_TYPES = new Set(["javascript"]);
 
-const idsSymbol = Symbol("HarmonyExportImportedSpecifierDependency.ids");
+class ContainerEntryModule extends Module {
+	/**
+	 * @param {string} name container entry name
+	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
+	 * @param {string} shareScope name of the share scope
+	 */
+	constructor(name, exposes, shareScope) {
+		super("javascript/dynamic", null);
+		this._name = name;
+		this._exposes = exposes;
+		this._shareScope = shareScope;
+	}
 
-class NormalReexportItem {
 	/**
-	 * @param {string} name export name
-	 * @param {string[]} ids reexported ids from other module
-	 * @param {ExportInfo} exportInfo export info from other module
-	 * @param {boolean} checked true, if it should be checked at runtime if this export exists
-	 * @param {boolean} hidden true, if it is hidden behind another active export in the same module
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return SOURCE_TYPES;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `container entry (${this._shareScope}) ${JSON.stringify(
+			this._exposes
+		)}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `container entry`;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/entry/${
+			this._name
+		}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
 	 */
-	constructor(name, ids, exportInfo, checked, hidden) {
-		this.name = name;
-		this.ids = ids;
-		this.exportInfo = exportInfo;
-		this.checked = checked;
-		this.hidden = hidden;
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
 	}
-}
 
-class ExportMode {
 	/**
-	 * @param {ExportModeType} type type of the mode
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
 	 */
-	constructor(type) {
-		/** @type {ExportModeType} */
-		this.type = type;
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true,
+			topLevelDeclarations: new Set(["moduleMap", "get", "init"])
+		};
+		this.buildMeta.exportsType = "namespace";
 
-		// for "normal-reexport":
-		/** @type {NormalReexportItem[] | null} */
-		this.items = null;
+		this.clearDependenciesAndBlocks();
 
-		// for "reexport-named-default" | "reexport-fake-namespace-object" | "reexport-namespace-object"
-		/** @type {string|null} */
-		this.name = null;
-		/** @type {ExportInfo | null} */
-		this.partialNamespaceExportInfo = null;
+		for (const [name, options] of this._exposes) {
+			const block = new AsyncDependenciesBlock(
+				{
+					name: options.name
+				},
+				{ name },
+				options.import[options.import.length - 1]
+			);
+			let idx = 0;
+			for (const request of options.import) {
+				const dep = new ContainerExposedDependency(name, request);
+				dep.loc = {
+					name,
+					index: idx++
+				};
 
-		// for "dynamic-reexport":
-		/** @type {Set<string> | null} */
-		this.ignored = null;
+				block.addDependency(dep);
+			}
+			this.addBlock(block);
+		}
+		this.addDependency(new StaticExportsDependency(["get", "init"], false));
 
-		// for "dynamic-reexport" | "empty-star":
-		/** @type {Set<string> | null} */
-		this.hidden = null;
+		callback();
+	}
 
-		// for "missing":
-		/** @type {string | null} */
-		this.userRequest = null;
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ moduleGraph, chunkGraph, runtimeTemplate }) {
+		const sources = new Map();
+		const runtimeRequirements = new Set([
+			RuntimeGlobals.definePropertyGetters,
+			RuntimeGlobals.hasOwnProperty,
+			RuntimeGlobals.exports
+		]);
+		const getters = [];
 
-		// for "reexport-fake-namespace-object":
-		/** @type {number} */
-		this.fakeType = 0;
-	}
-}
+		for (const block of this.blocks) {
+			const { dependencies } = block;
 
-const determineExportAssignments = (
-	moduleGraph,
-	dependencies,
-	additionalDependency
-) => {
-	const names = new Set();
-	const dependencyIndices = [];
+			const modules = dependencies.map(dependency => {
+				const dep = /** @type {ContainerExposedDependency} */ (dependency);
+				return {
+					name: dep.exposedName,
+					module: moduleGraph.getModule(dep),
+					request: dep.userRequest
+				};
+			});
 
-	if (additionalDependency) {
-		dependencies = dependencies.concat(additionalDependency);
-	}
+			let str;
 
-	for (const dep of dependencies) {
-		const i = dependencyIndices.length;
-		dependencyIndices[i] = names.size;
-		const otherImportedModule = moduleGraph.getModule(dep);
-		if (otherImportedModule) {
-			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
-			for (const exportInfo of exportsInfo.exports) {
-				if (
-					exportInfo.provided === true &&
-					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name)
-				) {
-					names.add(exportInfo.name);
-					dependencyIndices[i] = names.size;
-				}
+			if (modules.some(m => !m.module)) {
+				str = runtimeTemplate.throwMissingModuleErrorBlock({
+					request: modules.map(m => m.request).join(", ")
+				});
+			} else {
+				str = `return ${runtimeTemplate.blockPromise({
+					block,
+					message: "",
+					chunkGraph,
+					runtimeRequirements
+				})}.then(${runtimeTemplate.returningFunction(
+					runtimeTemplate.returningFunction(
+						`(${modules
+							.map(({ module, request }) =>
+								runtimeTemplate.moduleRaw({
+									module,
+									chunkGraph,
+									request,
+									weak: false,
+									runtimeRequirements
+								})
+							)
+							.join(", ")})`
+					)
+				)});`;
 			}
-		}
-	}
-	dependencyIndices.push(names.size);
 
-	return { names: Array.from(names), dependencyIndices };
-};
-
-const findDependencyForName = (
-	{ names, dependencyIndices },
-	name,
-	dependencies
-) => {
-	const dependenciesIt = dependencies[Symbol.iterator]();
-	const dependencyIndicesIt = dependencyIndices[Symbol.iterator]();
-	let dependenciesItResult = dependenciesIt.next();
-	let dependencyIndicesItResult = dependencyIndicesIt.next();
-	if (dependencyIndicesItResult.done) return;
-	for (let i = 0; i < names.length; i++) {
-		while (i >= dependencyIndicesItResult.value) {
-			dependenciesItResult = dependenciesIt.next();
-			dependencyIndicesItResult = dependencyIndicesIt.next();
-			if (dependencyIndicesItResult.done) return;
+			getters.push(
+				`${JSON.stringify(modules[0].name)}: ${runtimeTemplate.basicFunction(
+					"",
+					str
+				)}`
+			);
 		}
-		if (names[i] === name) return dependenciesItResult.value;
-	}
-	return undefined;
-};
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {HarmonyExportImportedSpecifierDependency} dep the dependency
- * @param {string} runtimeKey the runtime key
- * @returns {ExportMode} the export mode
- */
-const getMode = (moduleGraph, dep, runtimeKey) => {
-	const importedModule = moduleGraph.getModule(dep);
-
-	if (!importedModule) {
-		const mode = new ExportMode("missing");
+		const source = Template.asString([
+			`var moduleMap = {`,
+			Template.indent(getters.join(",\n")),
+			"};",
+			`var get = ${runtimeTemplate.basicFunction("module, getScope", [
+				`${RuntimeGlobals.currentRemoteGetScope} = getScope;`,
+				// reusing the getScope variable to avoid creating a new var (and module is also used later)
+				"getScope = (",
+				Template.indent([
+					`${RuntimeGlobals.hasOwnProperty}(moduleMap, module)`,
+					Template.indent([
+						"? moduleMap[module]()",
+						`: Promise.resolve().then(${runtimeTemplate.basicFunction(
+							"",
+							"throw new Error('Module \"' + module + '\" does not exist in container.');"
+						)})`
+					])
+				]),
+				");",
+				`${RuntimeGlobals.currentRemoteGetScope} = undefined;`,
+				"return getScope;"
+			])};`,
+			`var init = ${runtimeTemplate.basicFunction("shareScope, initScope", [
+				`if (!${RuntimeGlobals.shareScopeMap}) return;`,
+				`var name = ${JSON.stringify(this._shareScope)}`,
+				`var oldScope = ${RuntimeGlobals.shareScopeMap}[name];`,
+				`if(oldScope && oldScope !== shareScope) throw new Error("Container initialization failed as it has already been initialized with a different share scope");`,
+				`${RuntimeGlobals.shareScopeMap}[name] = shareScope;`,
+				`return ${RuntimeGlobals.initializeSharing}(name, initScope);`
+			])};`,
+			"",
+			"// This exports getters to disallow modifications",
+			`${RuntimeGlobals.definePropertyGetters}(exports, {`,
+			Template.indent([
+				`get: ${runtimeTemplate.returningFunction("get")},`,
+				`init: ${runtimeTemplate.returningFunction("init")}`
+			]),
+			"});"
+		]);
 
-		mode.userRequest = dep.userRequest;
+		sources.set(
+			"javascript",
+			this.useSourceMap || this.useSimpleSourceMap
+				? new OriginalSource(source, "webpack/container-entry")
+				: new RawSource(source)
+		);
 
-		return mode;
+		return {
+			sources,
+			runtimeRequirements
+		};
 	}
 
-	const name = dep.name;
-	const runtime = keyToRuntime(runtimeKey);
-	const parentModule = moduleGraph.getParentModule(dep);
-	const exportsInfo = moduleGraph.getExportsInfo(parentModule);
-
-	if (
-		name
-			? exportsInfo.getUsed(name, runtime) === UsageState.Unused
-			: exportsInfo.isUsed(runtime) === false
-	) {
-		const mode = new ExportMode("unused");
-
-		mode.name = name || "*";
-
-		return mode;
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
 	}
 
-	const importedExportsType = importedModule.getExportsType(
-		moduleGraph,
-		parentModule.buildMeta.strictHarmonyModule
-	);
-
-	const ids = dep.getIds(moduleGraph);
+	serialize(context) {
+		const { write } = context;
+		write(this._name);
+		write(this._exposes);
+		write(this._shareScope);
+		super.serialize(context);
+	}
 
-	// Special handling for reexporting the default export
-	// from non-namespace modules
-	if (name && ids.length > 0 && ids[0] === "default") {
-		switch (importedExportsType) {
-			case "dynamic": {
-				const mode = new ExportMode("reexport-dynamic-default");
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new ContainerEntryModule(read(), read(), read());
+		obj.deserialize(context);
+		return obj;
+	}
+}
 
-				mode.name = name;
+makeSerializable(
+	ContainerEntryModule,
+	"webpack/lib/container/ContainerEntryModule"
+);
 
-				return mode;
-			}
-			case "default-only":
-			case "default-with-named": {
-				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-				const mode = new ExportMode("reexport-named-default");
+module.exports = ContainerEntryModule;
 
-				mode.name = name;
-				mode.partialNamespaceExportInfo = exportInfo;
 
-				return mode;
-			}
-		}
-	}
+/***/ }),
 
-	// reexporting with a fixed name
-	if (name) {
-		let mode;
-		const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+/***/ 76398:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (ids.length > 0) {
-			// export { name as name }
-			switch (importedExportsType) {
-				case "default-only":
-					mode = new ExportMode("reexport-undefined");
-					mode.name = name;
-					break;
-				default:
-					mode = new ExportMode("normal-reexport");
-					mode.items = [
-						new NormalReexportItem(name, ids, exportInfo, false, false)
-					];
-					break;
-			}
-		} else {
-			// export * as name
-			switch (importedExportsType) {
-				case "default-only":
-					mode = new ExportMode("reexport-fake-namespace-object");
-					mode.name = name;
-					mode.partialNamespaceExportInfo = exportInfo;
-					mode.fakeType = 0;
-					break;
-				case "default-with-named":
-					mode = new ExportMode("reexport-fake-namespace-object");
-					mode.name = name;
-					mode.partialNamespaceExportInfo = exportInfo;
-					mode.fakeType = 2;
-					break;
-				case "dynamic":
-				default:
-					mode = new ExportMode("reexport-namespace-object");
-					mode.name = name;
-					mode.partialNamespaceExportInfo = exportInfo;
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+*/
 
-		return mode;
-	}
 
-	// Star reexporting
 
-	const { ignoredExports, exports, checked, hidden } = dep.getStarReexports(
-		moduleGraph,
-		runtime,
-		exportsInfo,
-		importedModule
-	);
-	if (!exports) {
-		// We have too few info about the modules
-		// Delegate the logic to the runtime code
+const ModuleFactory = __webpack_require__(51010);
+const ContainerEntryModule = __webpack_require__(80580);
 
-		const mode = new ExportMode("dynamic-reexport");
-		mode.ignored = ignoredExports;
-		mode.hidden = hidden;
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
-		return mode;
+module.exports = class ContainerEntryModuleFactory extends ModuleFactory {
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create({ dependencies: [dependency] }, callback) {
+		const dep = /** @type {ContainerEntryDependency} */ (dependency);
+		callback(null, {
+			module: new ContainerEntryModule(dep.name, dep.exposes, dep.shareScope)
+		});
 	}
+};
 
-	if (exports.size === 0) {
-		const mode = new ExportMode("empty-star");
-		mode.hidden = hidden;
 
-		return mode;
-	}
+/***/ }),
 
-	const mode = new ExportMode("normal-reexport");
+/***/ 72374:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	mode.items = Array.from(
-		exports,
-		exportName =>
-			new NormalReexportItem(
-				exportName,
-				[exportName],
-				exportsInfo.getReadOnlyExportInfo(exportName),
-				checked.has(exportName),
-				false
-			)
-	);
-	if (hidden !== undefined) {
-		for (const exportName of hidden) {
-			mode.items.push(
-				new NormalReexportItem(
-					exportName,
-					[exportName],
-					exportsInfo.getReadOnlyExportInfo(exportName),
-					false,
-					true
-				)
-			);
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+*/
 
-	return mode;
-};
 
-class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
-	/**
-	 * @param {string} request the request string
-	 * @param {number} sourceOrder the order in the original source file
-	 * @param {string[]} ids the requested export name of the imported module
-	 * @param {string | null} name the export name of for this module
-	 * @param {Set<string>} activeExports other named exports in the module
-	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module before this import
-	 * @param {number} exportPresenceMode mode of checking export names
-	 * @param {HarmonyStarExportsList} allStarExports all star exports in the module
-	 * @param {Record<string, any>=} assertions import assertions
-	 */
-	constructor(
-		request,
-		sourceOrder,
-		ids,
-		name,
-		activeExports,
-		otherStarExports,
-		exportPresenceMode,
-		allStarExports,
-		assertions
-	) {
-		super(request, sourceOrder, assertions);
 
-		this.ids = ids;
-		this.name = name;
-		this.activeExports = activeExports;
-		this.otherStarExports = otherStarExports;
-		this.exportPresenceMode = exportPresenceMode;
-		this.allStarExports = allStarExports;
-	}
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
+class ContainerExposedDependency extends ModuleDependency {
 	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 * @param {string} exposedName public name
+	 * @param {string} request request to module
 	 */
-	couldAffectReferencingModule() {
-		return Dependency.TRANSITIVE;
-	}
-
-	// TODO webpack 6 remove
-	get id() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
-
-	// TODO webpack 6 remove
-	getId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
-
-	// TODO webpack 6 remove
-	setId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
+	constructor(exposedName, request) {
+		super(request);
+		this.exposedName = exposedName;
 	}
 
 	get type() {
-		return "harmony export imported specifier";
+		return "container exposed";
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported id
-	 */
-	getIds(moduleGraph) {
-		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	get category() {
+		return "esm";
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
-	 * @returns {void}
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	setIds(moduleGraph, ids) {
-		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	getResourceIdentifier() {
+		return `exposed dependency ${this.exposedName}=${this.request}`;
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ExportMode} the export mode
-	 */
-	getMode(moduleGraph, runtime) {
-		return moduleGraph.dependencyCacheProvide(
-			this,
-			getRuntimeKey(runtime),
-			getMode
-		);
+	serialize(context) {
+		context.write(this.exposedName);
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {ExportsInfo} exportsInfo exports info about the current module (optional)
-	 * @param {Module} importedModule the imported module (optional)
-	 * @returns {{exports?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden?: Set<string>}} information
-	 */
-	getStarReexports(
-		moduleGraph,
-		runtime,
-		exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this)),
-		importedModule = moduleGraph.getModule(this)
-	) {
-		const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+	deserialize(context) {
+		this.exposedName = context.read();
+		super.deserialize(context);
+	}
+}
 
-		const noExtraExports =
-			importedExportsInfo.otherExportsInfo.provided === false;
-		const noExtraImports =
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
+makeSerializable(
+	ContainerExposedDependency,
+	"webpack/lib/container/ContainerExposedDependency"
+);
 
-		const ignoredExports = new Set(["default", ...this.activeExports]);
+module.exports = ContainerExposedDependency;
 
-		let hiddenExports = undefined;
-		const otherStarExports =
-			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
-		if (otherStarExports !== undefined) {
-			hiddenExports = new Set();
-			for (let i = 0; i < otherStarExports.namesSlice; i++) {
-				hiddenExports.add(otherStarExports.names[i]);
-			}
-			for (const e of ignoredExports) hiddenExports.delete(e);
-		}
 
-		if (!noExtraExports && !noExtraImports) {
-			return {
-				ignoredExports,
-				hidden: hiddenExports
-			};
-		}
+/***/ }),
 
-		/** @type {Set<string>} */
-		const exports = new Set();
-		/** @type {Set<string>} */
-		const checked = new Set();
-		/** @type {Set<string>} */
-		const hidden = hiddenExports !== undefined ? new Set() : undefined;
+/***/ 9244:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (noExtraImports) {
-			for (const exportInfo of exportsInfo.orderedExports) {
-				const name = exportInfo.name;
-				if (ignoredExports.has(name)) continue;
-				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				const importedExportInfo =
-					importedExportsInfo.getReadOnlyExportInfo(name);
-				if (importedExportInfo.provided === false) continue;
-				if (hiddenExports !== undefined && hiddenExports.has(name)) {
-					hidden.add(name);
-					continue;
-				}
-				exports.add(name);
-				if (importedExportInfo.provided === true) continue;
-				checked.add(name);
-			}
-		} else if (noExtraExports) {
-			for (const importedExportInfo of importedExportsInfo.orderedExports) {
-				const name = importedExportInfo.name;
-				if (ignoredExports.has(name)) continue;
-				if (importedExportInfo.provided === false) continue;
-				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				if (hiddenExports !== undefined && hiddenExports.has(name)) {
-					hidden.add(name);
-					continue;
-				}
-				exports.add(name);
-				if (importedExportInfo.provided === true) continue;
-				checked.add(name);
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+*/
 
-		return { ignoredExports, exports, checked, hidden };
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
-	 */
-	getCondition(moduleGraph) {
-		return (connection, runtime) => {
-			const mode = this.getMode(moduleGraph, runtime);
-			return mode.type !== "unused" && mode.type !== "empty-star";
-		};
+
+const createSchemaValidation = __webpack_require__(32540);
+const ContainerEntryDependency = __webpack_require__(64813);
+const ContainerEntryModuleFactory = __webpack_require__(76398);
+const ContainerExposedDependency = __webpack_require__(72374);
+const { parseOptions } = __webpack_require__(3083);
+
+/** @typedef {import("../../declarations/plugins/container/ContainerPlugin").ContainerPluginOptions} ContainerPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
+
+const validate = createSchemaValidation(
+	__webpack_require__(9504),
+	() => __webpack_require__(84899),
+	{
+		name: "Container Plugin",
+		baseDataPath: "options"
 	}
+);
 
+const PLUGIN_NAME = "ContainerPlugin";
+
+class ContainerPlugin {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @param {ContainerPluginOptions} options options
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
+	constructor(options) {
+		validate(options);
+
+		this._options = {
+			name: options.name,
+			shareScope: options.shareScope || "default",
+			library: options.library || {
+				type: "var",
+				name: options.name
+			},
+			runtime: options.runtime,
+			filename: options.filename || undefined,
+			exposes: parseOptions(
+				options.exposes,
+				item => ({
+					import: Array.isArray(item) ? item : [item],
+					name: undefined
+				}),
+				item => ({
+					import: Array.isArray(item.import) ? item.import : [item.import],
+					name: item.name || undefined
+				})
+			)
+		};
 	}
 
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		const mode = this.getMode(moduleGraph, runtime);
-
-		switch (mode.type) {
-			case "missing":
-			case "unused":
-			case "empty-star":
-			case "reexport-undefined":
-				return Dependency.NO_EXPORTS_REFERENCED;
+	apply(compiler) {
+		const { name, exposes, shareScope, filename, library, runtime } =
+			this._options;
 
-			case "reexport-dynamic-default":
-				return Dependency.EXPORTS_OBJECT_REFERENCED;
+		compiler.options.output.enabledLibraryTypes.push(library.type);
 
-			case "reexport-named-default": {
-				if (!mode.partialNamespaceExportInfo)
-					return Dependency.EXPORTS_OBJECT_REFERENCED;
-				/** @type {string[][]} */
-				const referencedExports = [];
-				processExportInfo(
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+			const dep = new ContainerEntryDependency(name, exposes, shareScope);
+			dep.loc = { name };
+			compilation.addEntry(
+				compilation.options.context,
+				dep,
+				{
+					name,
+					filename,
 					runtime,
-					referencedExports,
-					[],
-					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo)
+					library
+				},
+				error => {
+					if (error) return callback(error);
+					callback();
+				}
+			);
+		});
+
+		compiler.hooks.thisCompilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ContainerEntryDependency,
+					new ContainerEntryModuleFactory()
 				);
-				return referencedExports;
-			}
 
-			case "reexport-namespace-object":
-			case "reexport-fake-namespace-object": {
-				if (!mode.partialNamespaceExportInfo)
-					return Dependency.EXPORTS_OBJECT_REFERENCED;
-				/** @type {string[][]} */
-				const referencedExports = [];
-				processExportInfo(
-					runtime,
-					referencedExports,
-					[],
-					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo),
-					mode.type === "reexport-fake-namespace-object"
+				compilation.dependencyFactories.set(
+					ContainerExposedDependency,
+					normalModuleFactory
 				);
-				return referencedExports;
 			}
+		);
+	}
+}
 
-			case "dynamic-reexport":
-				return Dependency.EXPORTS_OBJECT_REFERENCED;
+module.exports = ContainerPlugin;
 
-			case "normal-reexport": {
-				const referencedExports = [];
-				for (const { ids, exportInfo, hidden } of mode.items) {
-					if (hidden) continue;
-					processExportInfo(runtime, referencedExports, ids, exportInfo, false);
-				}
-				return referencedExports;
-			}
 
-			default:
-				throw new Error(`Unknown mode ${mode.type}`);
-		}
-	}
+/***/ }),
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {{ names: string[], namesSlice: number, dependencyIndices: number[], dependencyIndex: number } | undefined} exported names and their origin dependency
-	 */
-	_discoverActiveExportsFromOtherStarExports(moduleGraph) {
-		if (!this.otherStarExports) return undefined;
+/***/ 95757:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const i =
-			"length" in this.otherStarExports
-				? this.otherStarExports.length
-				: countIterable(this.otherStarExports);
-		if (i === 0) return undefined;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+*/
 
-		if (this.allStarExports) {
-			const { names, dependencyIndices } = moduleGraph.cached(
-				determineExportAssignments,
-				this.allStarExports.dependencies
-			);
 
-			return {
-				names,
-				namesSlice: dependencyIndices[i - 1],
-				dependencyIndices,
-				dependencyIndex: i
-			};
-		}
 
-		const { names, dependencyIndices } = moduleGraph.cached(
-			determineExportAssignments,
-			this.otherStarExports,
-			this
-		);
+const ExternalsPlugin = __webpack_require__(6652);
+const RuntimeGlobals = __webpack_require__(16475);
+const createSchemaValidation = __webpack_require__(32540);
+const FallbackDependency = __webpack_require__(57764);
+const FallbackItemDependency = __webpack_require__(29593);
+const FallbackModuleFactory = __webpack_require__(4112);
+const RemoteModule = __webpack_require__(62916);
+const RemoteRuntimeModule = __webpack_require__(88288);
+const RemoteToExternalDependency = __webpack_require__(14389);
+const { parseOptions } = __webpack_require__(3083);
 
-		return {
-			names,
-			namesSlice: dependencyIndices[i - 1],
-			dependencyIndices,
-			dependencyIndex: i
-		};
+/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").ContainerReferencePluginOptions} ContainerReferencePluginOptions */
+/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").RemotesConfig} RemotesConfig */
+/** @typedef {import("../Compiler")} Compiler */
+
+const validate = createSchemaValidation(
+	__webpack_require__(95122),
+	() =>
+		__webpack_require__(66681),
+	{
+		name: "Container Reference Plugin",
+		baseDataPath: "options"
 	}
+);
+
+const slashCode = "/".charCodeAt(0);
 
+class ContainerReferencePlugin {
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @param {ContainerReferencePluginOptions} options options
 	 */
-	getExports(moduleGraph) {
-		const mode = this.getMode(moduleGraph, undefined);
+	constructor(options) {
+		validate(options);
 
-		switch (mode.type) {
-			case "missing":
-				return undefined;
-			case "dynamic-reexport": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: true,
-					from,
-					canMangle: false,
-					excludeExports: mode.hidden
-						? combine(mode.ignored, mode.hidden)
-						: mode.ignored,
-					hideExports: mode.hidden,
-					dependencies: [from.module]
-				};
-			}
-			case "empty-star":
-				return {
-					exports: [],
-					hideExports: mode.hidden,
-					dependencies: [moduleGraph.getModule(this)]
-				};
-			// falls through
-			case "normal-reexport": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: Array.from(mode.items, item => ({
-						name: item.name,
-						from,
-						export: item.ids,
-						hidden: item.hidden
-					})),
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			case "reexport-dynamic-default": {
-				{
-					const from = moduleGraph.getConnection(this);
-					return {
-						exports: [
-							{
-								name: mode.name,
-								from,
-								export: ["default"]
-							}
-						],
-						priority: 1,
-						dependencies: [from.module]
-					};
-				}
+		this._remoteType = options.remoteType;
+		this._remotes = parseOptions(
+			options.remotes,
+			item => ({
+				external: Array.isArray(item) ? item : [item],
+				shareScope: options.shareScope || "default"
+			}),
+			item => ({
+				external: Array.isArray(item.external)
+					? item.external
+					: [item.external],
+				shareScope: item.shareScope || options.shareScope || "default"
+			})
+		);
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _remotes: remotes, _remoteType: remoteType } = this;
+
+		/** @type {Record<string, string>} */
+		const remoteExternals = {};
+		for (const [key, config] of remotes) {
+			let i = 0;
+			for (const external of config.external) {
+				if (external.startsWith("internal ")) continue;
+				remoteExternals[
+					`webpack/container/reference/${key}${i ? `/fallback-${i}` : ""}`
+				] = external;
+				i++;
 			}
-			case "reexport-undefined":
-				return {
-					exports: [mode.name],
-					dependencies: [moduleGraph.getModule(this)]
-				};
-			case "reexport-fake-namespace-object": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: [
-						{
-							name: mode.name,
-							from,
-							export: null,
-							exports: [
-								{
-									name: "default",
-									canMangle: false,
-									from,
-									export: null
+		}
+
+		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
+
+		compiler.hooks.compilation.tap(
+			"ContainerReferencePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RemoteToExternalDependency,
+					normalModuleFactory
+				);
+
+				compilation.dependencyFactories.set(
+					FallbackItemDependency,
+					normalModuleFactory
+				);
+
+				compilation.dependencyFactories.set(
+					FallbackDependency,
+					new FallbackModuleFactory()
+				);
+
+				normalModuleFactory.hooks.factorize.tap(
+					"ContainerReferencePlugin",
+					data => {
+						if (!data.request.includes("!")) {
+							for (const [key, config] of remotes) {
+								if (
+									data.request.startsWith(`${key}`) &&
+									(data.request.length === key.length ||
+										data.request.charCodeAt(key.length) === slashCode)
+								) {
+									return new RemoteModule(
+										data.request,
+										config.external.map((external, i) =>
+											external.startsWith("internal ")
+												? external.slice(9)
+												: `webpack/container/reference/${key}${
+														i ? `/fallback-${i}` : ""
+												  }`
+										),
+										`.${data.request.slice(key.length)}`,
+										config.shareScope
+									);
 								}
-							]
-						}
-					],
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			case "reexport-namespace-object": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: [
-						{
-							name: mode.name,
-							from,
-							export: null
-						}
-					],
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			case "reexport-named-default": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: [
-						{
-							name: mode.name,
-							from,
-							export: ["default"]
+							}
 						}
-					],
-					priority: 1,
-					dependencies: [from.module]
-				};
+					}
+				);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ContainerReferencePlugin", (chunk, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+						set.add(RuntimeGlobals.hasOwnProperty);
+						set.add(RuntimeGlobals.initializeSharing);
+						set.add(RuntimeGlobals.shareScopeMap);
+						compilation.addRuntimeModule(chunk, new RemoteRuntimeModule());
+					});
 			}
-			default:
-				throw new Error(`Unknown mode ${mode.type}`);
-		}
+		);
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {number} effective mode
-	 */
-	_getEffectiveExportPresenceLevel(moduleGraph) {
-		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
-			return this.exportPresenceMode;
-		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-			? ExportPresenceModes.ERROR
-			: ExportPresenceModes.WARN;
+module.exports = ContainerReferencePlugin;
+
+
+/***/ }),
+
+/***/ 57764:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+
+class FallbackDependency extends Dependency {
+	constructor(requests) {
+		super();
+		this.requests = requests;
 	}
 
 	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	getWarnings(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.WARN) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
+	getResourceIdentifier() {
+		return `fallback ${this.requests.join(" ")}`;
 	}
 
-	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
-	 */
-	getErrors(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
+	get type() {
+		return "fallback";
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[] | undefined} errors
-	 */
-	_getErrors(moduleGraph) {
-		const ids = this.getIds(moduleGraph);
-		let errors = this.getLinkingErrors(
-			moduleGraph,
-			ids,
-			`(reexported as '${this.name}')`
-		);
-		if (ids.length === 0 && this.name === null) {
-			const potentialConflicts =
-				this._discoverActiveExportsFromOtherStarExports(moduleGraph);
-			if (potentialConflicts && potentialConflicts.namesSlice > 0) {
-				const ownNames = new Set(
-					potentialConflicts.names.slice(
-						potentialConflicts.namesSlice,
-						potentialConflicts.dependencyIndices[
-							potentialConflicts.dependencyIndex
-						]
-					)
-				);
-				const importedModule = moduleGraph.getModule(this);
-				if (importedModule) {
-					const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-					const conflicts = new Map();
-					for (const exportInfo of exportsInfo.orderedExports) {
-						if (exportInfo.provided !== true) continue;
-						if (exportInfo.name === "default") continue;
-						if (this.activeExports.has(exportInfo.name)) continue;
-						if (ownNames.has(exportInfo.name)) continue;
-						const conflictingDependency = findDependencyForName(
-							potentialConflicts,
-							exportInfo.name,
-							this.allStarExports
-								? this.allStarExports.dependencies
-								: [...this.otherStarExports, this]
-						);
-						if (!conflictingDependency) continue;
-						const target = exportInfo.getTerminalBinding(moduleGraph);
-						if (!target) continue;
-						const conflictingModule = moduleGraph.getModule(
-							conflictingDependency
-						);
-						if (conflictingModule === importedModule) continue;
-						const conflictingExportInfo = moduleGraph.getExportInfo(
-							conflictingModule,
-							exportInfo.name
-						);
-						const conflictingTarget =
-							conflictingExportInfo.getTerminalBinding(moduleGraph);
-						if (!conflictingTarget) continue;
-						if (target === conflictingTarget) continue;
-						const list = conflicts.get(conflictingDependency.request);
-						if (list === undefined) {
-							conflicts.set(conflictingDependency.request, [exportInfo.name]);
-						} else {
-							list.push(exportInfo.name);
-						}
-					}
-					for (const [request, exports] of conflicts) {
-						if (!errors) errors = [];
-						errors.push(
-							new HarmonyLinkingError(
-								`The requested module '${
-									this.request
-								}' contains conflicting star exports for the ${
-									exports.length > 1 ? "names" : "name"
-								} ${exports
-									.map(e => `'${e}'`)
-									.join(", ")} with the previous requested module '${request}'`
-							)
-						);
-					}
-				}
-			}
-		}
-		return errors;
+	get category() {
+		return "esm";
 	}
 
 	serialize(context) {
-		const { write, setCircularReference } = context;
-
-		setCircularReference(this);
-		write(this.ids);
-		write(this.name);
-		write(this.activeExports);
-		write(this.otherStarExports);
-		write(this.exportPresenceMode);
-		write(this.allStarExports);
-
+		const { write } = context;
+		write(this.requests);
 		super.serialize(context);
 	}
 
-	deserialize(context) {
-		const { read, setCircularReference } = context;
-
-		setCircularReference(this);
-		this.ids = read();
-		this.name = read();
-		this.activeExports = read();
-		this.otherStarExports = read();
-		this.exportPresenceMode = read();
-		this.allStarExports = read();
-
-		super.deserialize(context);
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new FallbackDependency(read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
 makeSerializable(
-	HarmonyExportImportedSpecifierDependency,
-	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency"
+	FallbackDependency,
+	"webpack/lib/container/FallbackDependency"
 );
 
-module.exports = HarmonyExportImportedSpecifierDependency;
-
-HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const { moduleGraph, runtime, concatenationScope } = templateContext;
-
-		const dep = /** @type {HarmonyExportImportedSpecifierDependency} */ (
-			dependency
-		);
-
-		const mode = dep.getMode(moduleGraph, runtime);
-
-		if (concatenationScope) {
-			switch (mode.type) {
-				case "reexport-undefined":
-					concatenationScope.registerRawExport(
-						mode.name,
-						"/* reexport non-default export from non-harmony */ undefined"
-					);
-			}
-			return;
-		}
-
-		if (mode.type !== "unused" && mode.type !== "empty-star") {
-			super.apply(dependency, source, templateContext);
-
-			this._addExportFragments(
-				templateContext.initFragments,
-				dep,
-				mode,
-				templateContext.module,
-				moduleGraph,
-				runtime,
-				templateContext.runtimeTemplate,
-				templateContext.runtimeRequirements
-			);
-		}
-	}
+module.exports = FallbackDependency;
 
-	/**
-	 * @param {InitFragment[]} initFragments target array for init fragments
-	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
-	 * @param {ExportMode} mode the export mode
-	 * @param {Module} module the current module
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {Set<string>} runtimeRequirements runtime requirements
-	 * @returns {void}
-	 */
-	_addExportFragments(
-		initFragments,
-		dep,
-		mode,
-		module,
-		moduleGraph,
-		runtime,
-		runtimeTemplate,
-		runtimeRequirements
-	) {
-		const importedModule = moduleGraph.getModule(dep);
-		const importVar = dep.getImportVar(moduleGraph);
 
-		switch (mode.type) {
-			case "missing":
-			case "empty-star":
-				initFragments.push(
-					new InitFragment(
-						"/* empty/unused harmony star reexport */\n",
-						InitFragment.STAGE_HARMONY_EXPORTS,
-						1
-					)
-				);
-				break;
+/***/ }),
 
-			case "unused":
-				initFragments.push(
-					new InitFragment(
-						`${Template.toNormalComment(
-							`unused harmony reexport ${mode.name}`
-						)}\n`,
-						InitFragment.STAGE_HARMONY_EXPORTS,
-						1
-					)
-				);
-				break;
+/***/ 29593:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			case "reexport-dynamic-default":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport default from dynamic",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						null,
-						runtimeRequirements
-					)
-				);
-				break;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			case "reexport-fake-namespace-object":
-				initFragments.push(
-					...this.getReexportFakeNamespaceObjectFragments(
-						module,
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						mode.fakeType,
-						runtimeRequirements
-					)
-				);
-				break;
 
-			case "reexport-undefined":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport non-default export from non-harmony",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						"undefined",
-						"",
-						runtimeRequirements
-					)
-				);
-				break;
 
-			case "reexport-named-default":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport default export from named module",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						"",
-						runtimeRequirements
-					)
-				);
-				break;
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-			case "reexport-namespace-object":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport module object",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						"",
-						runtimeRequirements
-					)
-				);
-				break;
+class FallbackItemDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
 
-			case "normal-reexport":
-				for (const { name, ids, checked, hidden } of mode.items) {
-					if (hidden) continue;
-					if (checked) {
-						initFragments.push(
-							new InitFragment(
-								"/* harmony reexport (checked) */ " +
-									this.getConditionalReexportStatement(
-										module,
-										name,
-										importVar,
-										ids,
-										runtimeRequirements
-									),
-								moduleGraph.isAsync(importedModule)
-									? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
-									: InitFragment.STAGE_HARMONY_IMPORTS,
-								dep.sourceOrder
-							)
-						);
-					} else {
-						initFragments.push(
-							this.getReexportFragment(
-								module,
-								"reexport safe",
-								moduleGraph.getExportsInfo(module).getUsedName(name, runtime),
-								importVar,
-								moduleGraph
-									.getExportsInfo(importedModule)
-									.getUsedName(ids, runtime),
-								runtimeRequirements
-							)
-						);
-					}
-				}
-				break;
+	get type() {
+		return "fallback item";
+	}
 
-			case "dynamic-reexport": {
-				const ignored = mode.hidden
-					? combine(mode.ignored, mode.hidden)
-					: mode.ignored;
-				const modern =
-					runtimeTemplate.supportsConst() &&
-					runtimeTemplate.supportsArrowFunction();
-				let content =
-					"/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};\n" +
-					`/* harmony reexport (unknown) */ for(${
-						modern ? "const" : "var"
-					} __WEBPACK_IMPORT_KEY__ in ${importVar}) `;
+	get category() {
+		return "esm";
+	}
+}
 
-				// Filter out exports which are defined by other exports
-				// and filter out default export because it cannot be reexported with *
-				if (ignored.size > 1) {
-					content +=
-						"if(" +
-						JSON.stringify(Array.from(ignored)) +
-						".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
-				} else if (ignored.size === 1) {
-					content += `if(__WEBPACK_IMPORT_KEY__ !== ${JSON.stringify(
-						first(ignored)
-					)}) `;
-				}
+makeSerializable(
+	FallbackItemDependency,
+	"webpack/lib/container/FallbackItemDependency"
+);
 
-				content += `__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = `;
-				if (modern) {
-					content += `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`;
-				} else {
-					content += `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
-				}
+module.exports = FallbackItemDependency;
 
-				runtimeRequirements.add(RuntimeGlobals.exports);
-				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-				const exportsName = module.exportsArgument;
-				initFragments.push(
-					new InitFragment(
-						`${content}\n/* harmony reexport (unknown) */ ${RuntimeGlobals.definePropertyGetters}(${exportsName}, __WEBPACK_REEXPORT_OBJECT__);\n`,
-						moduleGraph.isAsync(importedModule)
-							? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
-							: InitFragment.STAGE_HARMONY_IMPORTS,
-						dep.sourceOrder
-					)
-				);
-				break;
-			}
+/***/ }),
 
-			default:
-				throw new Error(`Unknown mode ${mode.type}`);
-		}
-	}
+/***/ 82886:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	getReexportFragment(
-		module,
-		comment,
-		key,
-		name,
-		valueKey,
-		runtimeRequirements
-	) {
-		const returnValue = this.getReturnValue(name, valueKey);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+*/
 
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-		const map = new Map();
-		map.set(key, `/* ${comment} */ ${returnValue}`);
 
-		return new HarmonyExportInitFragment(module.exportsArgument, map);
-	}
+const { RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const makeSerializable = __webpack_require__(33032);
+const FallbackItemDependency = __webpack_require__(29593);
 
-	getReexportFakeNamespaceObjectFragments(
-		module,
-		key,
-		name,
-		fakeType,
-		runtimeRequirements
-	) {
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-		runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-		const map = new Map();
-		map.set(
-			key,
-			`/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
-				RuntimeGlobals.createFakeNamespaceObject
-			}(${name}${fakeType ? `, ${fakeType}` : ""}))`
-		);
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 
-		return [
-			new InitFragment(
-				`var ${name}_namespace_cache;\n`,
-				InitFragment.STAGE_CONSTANTS,
-				-1,
-				`${name}_namespace_cache`
-			),
-			new HarmonyExportInitFragment(module.exportsArgument, map)
-		];
+class FallbackModule extends Module {
+	/**
+	 * @param {string[]} requests list of requests to choose one
+	 */
+	constructor(requests) {
+		super("fallback-module");
+		this.requests = requests;
+		this._identifier = `fallback ${this.requests.join(" ")}`;
 	}
 
-	getConditionalReexportStatement(
-		module,
-		key,
-		name,
-		valueKey,
-		runtimeRequirements
-	) {
-		if (valueKey === false) {
-			return "/* unused export */\n";
-		}
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this._identifier;
+	}
 
-		const exportsName = module.exportsArgument;
-		const returnValue = this.getReturnValue(name, valueKey);
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return this._identifier;
+	}
 
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-		runtimeRequirements.add(RuntimeGlobals.hasOwnProperty);
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/fallback/${
+			this.requests[0]
+		}/and ${this.requests.length - 1} more`;
+	}
 
-		return `if(${RuntimeGlobals.hasOwnProperty}(${name}, ${JSON.stringify(
-			valueKey[0]
-		)})) ${
-			RuntimeGlobals.definePropertyGetters
-		}(${exportsName}, { ${JSON.stringify(
-			key
-		)}: function() { return ${returnValue}; } });\n`;
+	/**
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
+	 */
+	chunkCondition(chunk, { chunkGraph }) {
+		return chunkGraph.getNumberOfEntryModules(chunk) > 0;
 	}
 
-	getReturnValue(name, valueKey) {
-		if (valueKey === null) {
-			return `${name}_default.a`;
-		}
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
 
-		if (valueKey === "") {
-			return name;
-		}
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true
+		};
 
-		if (valueKey === false) {
-			return "/* unused export */ undefined";
-		}
+		this.clearDependenciesAndBlocks();
+		for (const request of this.requests)
+			this.addDependency(new FallbackItemDependency(request));
 
-		return `${name}${propertyAccess(valueKey)}`;
+		callback();
 	}
-};
 
-class HarmonyStarExportsList {
-	constructor() {
-		/** @type {HarmonyExportImportedSpecifierDependency[]} */
-		this.dependencies = [];
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return this.requests.length * 5 + 42;
 	}
 
 	/**
-	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
-	 * @returns {void}
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	push(dep) {
-		this.dependencies.push(dep);
+	getSourceTypes() {
+		return TYPES;
 	}
 
-	slice() {
-		return this.dependencies.slice();
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const ids = this.dependencies.map(dep =>
+			chunkGraph.getModuleId(moduleGraph.getModule(dep))
+		);
+		const code = Template.asString([
+			`var ids = ${JSON.stringify(ids)};`,
+			"var error, result, i = 0;",
+			`var loop = ${runtimeTemplate.basicFunction("next", [
+				"while(i < ids.length) {",
+				Template.indent([
+					"try { next = __webpack_require__(ids[i++]); } catch(e) { return handleError(e); }",
+					"if(next) return next.then ? next.then(handleResult, handleError) : handleResult(next);"
+				]),
+				"}",
+				"if(error) throw error;"
+			])}`,
+			`var handleResult = ${runtimeTemplate.basicFunction("result", [
+				"if(result) return result;",
+				"return loop();"
+			])};`,
+			`var handleError = ${runtimeTemplate.basicFunction("e", [
+				"error = e;",
+				"return loop();"
+			])};`,
+			"module.exports = loop();"
+		]);
+		const sources = new Map();
+		sources.set("javascript", new RawSource(code));
+		return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS };
 	}
 
-	serialize({ write, setCircularReference }) {
-		setCircularReference(this);
-		write(this.dependencies);
+	serialize(context) {
+		const { write } = context;
+		write(this.requests);
+		super.serialize(context);
 	}
 
-	deserialize({ read, setCircularReference }) {
-		setCircularReference(this);
-		this.dependencies = read();
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new FallbackModule(read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-makeSerializable(
-	HarmonyStarExportsList,
-	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency",
-	"HarmonyStarExportsList"
-);
+makeSerializable(FallbackModule, "webpack/lib/container/FallbackModule");
 
-module.exports.HarmonyStarExportsList = HarmonyStarExportsList;
+module.exports = FallbackModule;
 
 
 /***/ }),
 
-/***/ 89500:
+/***/ 4112:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const { first } = __webpack_require__(93347);
+const ModuleFactory = __webpack_require__(51010);
+const FallbackModule = __webpack_require__(82886);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./FallbackDependency")} FallbackDependency */
 
-const joinIterableWithComma = iterable => {
-	// This is more performant than Array.from().join(", ")
-	// as it doesn't create an array
-	let str = "";
-	let first = true;
-	for (const item of iterable) {
-		if (first) {
-			first = false;
-		} else {
-			str += ", ";
-		}
-		str += item;
+module.exports = class FallbackModuleFactory extends ModuleFactory {
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create({ dependencies: [dependency] }, callback) {
+		const dep = /** @type {FallbackDependency} */ (dependency);
+		callback(null, {
+			module: new FallbackModule(dep.requests)
+		});
 	}
-	return str;
 };
 
-const EMPTY_MAP = new Map();
-const EMPTY_SET = new Set();
 
-/**
- * @typedef {GenerateContext} Context
- */
-class HarmonyExportInitFragment extends InitFragment {
-	/**
-	 * @param {string} exportsArgument the exports identifier
-	 * @param {Map<string, string>} exportMap mapping from used name to exposed variable name
-	 * @param {Set<string>} unusedExports list of unused export names
-	 */
-	constructor(
-		exportsArgument,
-		exportMap = EMPTY_MAP,
-		unusedExports = EMPTY_SET
-	) {
-		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
-		this.exportsArgument = exportsArgument;
-		this.exportMap = exportMap;
-		this.unusedExports = unusedExports;
-	}
+/***/ }),
 
-	/**
-	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
-	 * @returns {HarmonyExportInitFragment} merged fragment
-	 */
-	mergeAll(fragments) {
-		let exportMap;
-		let exportMapOwned = false;
-		let unusedExports;
-		let unusedExportsOwned = false;
+/***/ 30569:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		for (const fragment of fragments) {
-			if (fragment.exportMap.size !== 0) {
-				if (exportMap === undefined) {
-					exportMap = fragment.exportMap;
-					exportMapOwned = false;
-				} else {
-					if (!exportMapOwned) {
-						exportMap = new Map(exportMap);
-						exportMapOwned = true;
-					}
-					for (const [key, value] of fragment.exportMap) {
-						if (!exportMap.has(key)) exportMap.set(key, value);
-					}
-				}
-			}
-			if (fragment.unusedExports.size !== 0) {
-				if (unusedExports === undefined) {
-					unusedExports = fragment.unusedExports;
-					unusedExportsOwned = false;
-				} else {
-					if (!unusedExportsOwned) {
-						unusedExports = new Set(unusedExports);
-						unusedExportsOwned = true;
-					}
-					for (const value of fragment.unusedExports) {
-						unusedExports.add(value);
-					}
-				}
-			}
-		}
-		return new HarmonyExportInitFragment(
-			this.exportsArgument,
-			exportMap,
-			unusedExports
-		);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+*/
+
+
+
+const isValidExternalsType = __webpack_require__(62142);
+const SharePlugin = __webpack_require__(26335);
+const createSchemaValidation = __webpack_require__(32540);
+const ContainerPlugin = __webpack_require__(9244);
+const ContainerReferencePlugin = __webpack_require__(95757);
+
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ExternalsType} ExternalsType */
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ModuleFederationPluginOptions} ModuleFederationPluginOptions */
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").Shared} Shared */
+/** @typedef {import("../Compiler")} Compiler */
+
+const validate = createSchemaValidation(
+	__webpack_require__(7467),
+	() => __webpack_require__(82601),
+	{
+		name: "Module Federation Plugin",
+		baseDataPath: "options"
 	}
+);
+class ModuleFederationPlugin {
+	/**
+	 * @param {ModuleFederationPluginOptions} options options
+	 */
+	constructor(options) {
+		validate(options);
 
-	merge(other) {
-		let exportMap;
-		if (this.exportMap.size === 0) {
-			exportMap = other.exportMap;
-		} else if (other.exportMap.size === 0) {
-			exportMap = this.exportMap;
-		} else {
-			exportMap = new Map(other.exportMap);
-			for (const [key, value] of this.exportMap) {
-				if (!exportMap.has(key)) exportMap.set(key, value);
-			}
-		}
-		let unusedExports;
-		if (this.unusedExports.size === 0) {
-			unusedExports = other.unusedExports;
-		} else if (other.unusedExports.size === 0) {
-			unusedExports = this.unusedExports;
-		} else {
-			unusedExports = new Set(other.unusedExports);
-			for (const value of this.unusedExports) {
-				unusedExports.add(value);
-			}
-		}
-		return new HarmonyExportInitFragment(
-			this.exportsArgument,
-			exportMap,
-			unusedExports
-		);
+		this._options = options;
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getContent({ runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-
-		const unusedPart =
-			this.unusedExports.size > 1
-				? `/* unused harmony exports ${joinIterableWithComma(
-						this.unusedExports
-				  )} */\n`
-				: this.unusedExports.size > 0
-				? `/* unused harmony export ${first(this.unusedExports)} */\n`
-				: "";
-		const definitions = [];
-		for (const [key, value] of this.exportMap) {
-			definitions.push(
-				`\n/* harmony export */   ${JSON.stringify(
-					key
-				)}: ${runtimeTemplate.returningFunction(value)}`
-			);
+	apply(compiler) {
+		const { _options: options } = this;
+		const library = options.library || { type: "var", name: options.name };
+		const remoteType =
+			options.remoteType ||
+			(options.library && isValidExternalsType(options.library.type)
+				? /** @type {ExternalsType} */ (options.library.type)
+				: "script");
+		if (
+			library &&
+			!compiler.options.output.enabledLibraryTypes.includes(library.type)
+		) {
+			compiler.options.output.enabledLibraryTypes.push(library.type);
 		}
-		const definePart =
-			this.exportMap.size > 0
-				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
-						this.exportsArgument
-				  }, {${definitions.join(",")}\n/* harmony export */ });\n`
-				: "";
-		return `${definePart}${unusedPart}`;
+		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
+			if (
+				options.exposes &&
+				(Array.isArray(options.exposes)
+					? options.exposes.length > 0
+					: Object.keys(options.exposes).length > 0)
+			) {
+				new ContainerPlugin({
+					name: options.name,
+					library,
+					filename: options.filename,
+					runtime: options.runtime,
+					exposes: options.exposes
+				}).apply(compiler);
+			}
+			if (
+				options.remotes &&
+				(Array.isArray(options.remotes)
+					? options.remotes.length > 0
+					: Object.keys(options.remotes).length > 0)
+			) {
+				new ContainerReferencePlugin({
+					remoteType,
+					remotes: options.remotes
+				}).apply(compiler);
+			}
+			if (options.shared) {
+				new SharePlugin({
+					shared: options.shared,
+					shareScope: options.shareScope
+				}).apply(compiler);
+			}
+		});
 	}
 }
 
-module.exports = HarmonyExportInitFragment;
+module.exports = ModuleFederationPlugin;
 
 
 /***/ }),
 
-/***/ 48567:
+/***/ 62916:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
+const { RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
-const HarmonyExportInitFragment = __webpack_require__(89500);
-const NullDependency = __webpack_require__(31830);
+const FallbackDependency = __webpack_require__(57764);
+const RemoteToExternalDependency = __webpack_require__(14389);
+
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["remote", "share-init"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+
+class RemoteModule extends Module {
+	/**
+	 * @param {string} request request string
+	 * @param {string[]} externalRequests list of external requests to containers
+	 * @param {string} internalRequest name of exposed module in container
+	 * @param {string} shareScope the used share scope name
+	 */
+	constructor(request, externalRequests, internalRequest, shareScope) {
+		super("remote-module");
+		this.request = request;
+		this.externalRequests = externalRequests;
+		this.internalRequest = internalRequest;
+		this.shareScope = shareScope;
+		this._identifier = `remote (${shareScope}) ${this.externalRequests.join(
+			" "
+		)} ${this.internalRequest}`;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this._identifier;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `remote ${this.request}`;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/remote/${
+			this.request
+		}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true
+		};
+
+		this.clearDependenciesAndBlocks();
+		if (this.externalRequests.length === 1) {
+			this.addDependency(
+				new RemoteToExternalDependency(this.externalRequests[0])
+			);
+		} else {
+			this.addDependency(new FallbackDependency(this.externalRequests));
+		}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+		callback();
+	}
 
-class HarmonyExportSpecifierDependency extends NullDependency {
-	constructor(id, name) {
-		super();
-		this.id = id;
-		this.name = name;
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 6;
 	}
 
-	get type() {
-		return "harmony export specifier";
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
-	getExports(moduleGraph) {
-		return {
-			exports: [this.name],
-			priority: 1,
-			terminalBinding: true,
-			dependencies: undefined
-		};
+	nameForCondition() {
+		return this.request;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const module = moduleGraph.getModule(this.dependencies[0]);
+		const id = module && chunkGraph.getModuleId(module);
+		const sources = new Map();
+		sources.set("remote", new RawSource(""));
+		const data = new Map();
+		data.set("share-init", [
+			{
+				shareScope: this.shareScope,
+				initStage: 20,
+				init: id === undefined ? "" : `initExternal(${JSON.stringify(id)});`
+			}
+		]);
+		return { sources, data, runtimeRequirements: RUNTIME_REQUIREMENTS };
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.id);
-		write(this.name);
+		write(this.request);
+		write(this.externalRequests);
+		write(this.internalRequest);
+		write(this.shareScope);
 		super.serialize(context);
 	}
 
-	deserialize(context) {
+	static deserialize(context) {
 		const { read } = context;
-		this.id = read();
-		this.name = read();
-		super.deserialize(context);
+		const obj = new RemoteModule(read(), read(), read(), read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-makeSerializable(
-	HarmonyExportSpecifierDependency,
-	"webpack/lib/dependencies/HarmonyExportSpecifierDependency"
-);
-
-HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, initFragments, runtime, concatenationScope }
-	) {
-		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
-		if (concatenationScope) {
-			concatenationScope.registerExport(dep.name, dep.id);
-			return;
-		}
-		const used = moduleGraph
-			.getExportsInfo(module)
-			.getUsedName(dep.name, runtime);
-		if (!used) {
-			const set = new Set();
-			set.add(dep.name || "namespace");
-			initFragments.push(
-				new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
-			);
-			return;
-		}
-
-		const map = new Map();
-		map.set(used, `/* binding */ ${dep.id}`);
-		initFragments.push(
-			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
-		);
-	}
-};
+makeSerializable(RemoteModule, "webpack/lib/container/RemoteModule");
 
-module.exports = HarmonyExportSpecifierDependency;
+module.exports = RemoteModule;
 
 
 /***/ }),
 
-/***/ 39211:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 88288:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -78651,44 +74737,132 @@ module.exports = HarmonyExportSpecifierDependency;
 
 
 
-/** @typedef {import("../Parser").ParserState} ParserState */
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-/** @type {WeakMap<ParserState, boolean>} */
-const parserStateExportsState = new WeakMap();
+/** @typedef {import("./RemoteModule")} RemoteModule */
 
-/**
- * @param {ParserState} parserState parser state
- * @param {boolean} isStrictHarmony strict harmony mode should be enabled
- * @returns {void}
- */
-exports.enable = (parserState, isStrictHarmony) => {
-	const value = parserStateExportsState.get(parserState);
-	if (value === false) return;
-	parserStateExportsState.set(parserState, true);
-	if (value !== true) {
-		parserState.module.buildMeta.exportsType = "namespace";
-		parserState.module.buildInfo.strict = true;
-		parserState.module.buildInfo.exportsArgument = "__webpack_exports__";
-		if (isStrictHarmony) {
-			parserState.module.buildMeta.strictHarmonyModule = true;
-			parserState.module.buildInfo.moduleArgument = "__webpack_module__";
+class RemoteRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("remotes loading");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunkGraph } = this;
+		const { runtimeTemplate, moduleGraph } = compilation;
+		const chunkToRemotesMapping = {};
+		const idToExternalAndNameMapping = {};
+		for (const chunk of this.chunk.getAllAsyncChunks()) {
+			const modules = chunkGraph.getChunkModulesIterableBySourceType(
+				chunk,
+				"remote"
+			);
+			if (!modules) continue;
+			const remotes = (chunkToRemotesMapping[chunk.id] = []);
+			for (const m of modules) {
+				const module = /** @type {RemoteModule} */ (m);
+				const name = module.internalRequest;
+				const id = chunkGraph.getModuleId(module);
+				const shareScope = module.shareScope;
+				const dep = module.dependencies[0];
+				const externalModule = moduleGraph.getModule(dep);
+				const externalModuleId =
+					externalModule && chunkGraph.getModuleId(externalModule);
+				remotes.push(id);
+				idToExternalAndNameMapping[id] = [shareScope, name, externalModuleId];
+			}
 		}
+		return Template.asString([
+			`var chunkMapping = ${JSON.stringify(
+				chunkToRemotesMapping,
+				null,
+				"\t"
+			)};`,
+			`var idToExternalAndNameMapping = ${JSON.stringify(
+				idToExternalAndNameMapping,
+				null,
+				"\t"
+			)};`,
+			`${
+				RuntimeGlobals.ensureChunkHandlers
+			}.remotes = ${runtimeTemplate.basicFunction("chunkId, promises", [
+				`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
+				Template.indent([
+					`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction("id", [
+						`var getScope = ${RuntimeGlobals.currentRemoteGetScope};`,
+						"if(!getScope) getScope = [];",
+						"var data = idToExternalAndNameMapping[id];",
+						"if(getScope.indexOf(data) >= 0) return;",
+						"getScope.push(data);",
+						`if(data.p) return promises.push(data.p);`,
+						`var onError = ${runtimeTemplate.basicFunction("error", [
+							'if(!error) error = new Error("Container missing");',
+							'if(typeof error.message === "string")',
+							Template.indent(
+								`error.message += '\\nwhile loading "' + data[1] + '" from ' + data[2];`
+							),
+							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction("", [
+								"throw error;"
+							])}`,
+							"data.p = 0;"
+						])};`,
+						`var handleFunction = ${runtimeTemplate.basicFunction(
+							"fn, arg1, arg2, d, next, first",
+							[
+								"try {",
+								Template.indent([
+									"var promise = fn(arg1, arg2);",
+									"if(promise && promise.then) {",
+									Template.indent([
+										`var p = promise.then(${runtimeTemplate.returningFunction(
+											"next(result, d)",
+											"result"
+										)}, onError);`,
+										`if(first) promises.push(data.p = p); else return p;`
+									]),
+									"} else {",
+									Template.indent(["return next(promise, d, first);"]),
+									"}"
+								]),
+								"} catch(error) {",
+								Template.indent(["onError(error);"]),
+								"}"
+							]
+						)}`,
+						`var onExternal = ${runtimeTemplate.returningFunction(
+							`external ? handleFunction(${RuntimeGlobals.initializeSharing}, data[0], 0, external, onInitialized, first) : onError()`,
+							"external, _, first"
+						)};`,
+						`var onInitialized = ${runtimeTemplate.returningFunction(
+							`handleFunction(external.get, data[1], getScope, 0, onFactory, first)`,
+							"_, external, first"
+						)};`,
+						`var onFactory = ${runtimeTemplate.basicFunction("factory", [
+							"data.p = 1;",
+							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction(
+								"module",
+								["module.exports = factory();"]
+							)}`
+						])};`,
+						"handleFunction(__webpack_require__, data[2], 0, 0, onExternal, 1);"
+					])});`
+				]),
+				"}"
+			])}`
+		]);
 	}
-};
+}
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-exports.isEnabled = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	return value === true;
-};
+module.exports = RemoteRuntimeModule;
 
 
 /***/ }),
 
-/***/ 57154:
+/***/ 14389:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -78699,627 +74873,397 @@ exports.isEnabled = parserState => {
 
 
 
-const ConditionalInitFragment = __webpack_require__(61333);
-const Dependency = __webpack_require__(54912);
-const HarmonyLinkingError = __webpack_require__(97511);
-const InitFragment = __webpack_require__(55870);
-const Template = __webpack_require__(1626);
-const AwaitDependenciesInitFragment = __webpack_require__(41153);
-const { filterRuntime, mergeRuntime } = __webpack_require__(17156);
 const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-const ExportPresenceModes = {
-	NONE: /** @type {0} */ (0),
-	WARN: /** @type {1} */ (1),
-	AUTO: /** @type {2} */ (2),
-	ERROR: /** @type {3} */ (3),
-	fromUserOption(str) {
-		switch (str) {
-			case "error":
-				return ExportPresenceModes.ERROR;
-			case "warn":
-				return ExportPresenceModes.WARN;
-			case "auto":
-				return ExportPresenceModes.AUTO;
-			case false:
-				return ExportPresenceModes.NONE;
-			default:
-				throw new Error(`Invalid export presence value ${str}`);
-		}
+class RemoteToExternalDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
-};
 
-class HarmonyImportDependency extends ModuleDependency {
-	/**
-	 *
-	 * @param {string} request request string
-	 * @param {number} sourceOrder source order
-	 * @param {Record<string, any>=} assertions import assertions
-	 */
-	constructor(request, sourceOrder, assertions) {
-		super(request);
-		this.sourceOrder = sourceOrder;
-		this.assertions = assertions;
+	get type() {
+		return "remote to external";
 	}
 
 	get category() {
 		return "esm";
 	}
+}
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return Dependency.NO_EXPORTS_REFERENCED;
-	}
+makeSerializable(
+	RemoteToExternalDependency,
+	"webpack/lib/container/RemoteToExternalDependency"
+);
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string} name of the variable for the import
-	 */
-	getImportVar(moduleGraph) {
-		const module = moduleGraph.getParentModule(this);
-		const meta = moduleGraph.getMeta(module);
-		let importVarMap = meta.importVarMap;
-		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
-		let importVar = importVarMap.get(moduleGraph.getModule(this));
-		if (importVar) return importVar;
-		importVar = `${Template.toIdentifier(
-			`${this.userRequest}`
-		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
-		importVarMap.set(moduleGraph.getModule(this), importVar);
-		return importVar;
-	}
+module.exports = RemoteToExternalDependency;
 
-	/**
-	 * @param {boolean} update create new variables or update existing one
-	 * @param {DependencyTemplateContext} templateContext the template context
-	 * @returns {[string, string]} the import statement and the compat statement
-	 */
-	getImportStatement(
-		update,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		return runtimeTemplate.importStatement({
-			update,
-			module: moduleGraph.getModule(this),
-			chunkGraph,
-			importVar: this.getImportVar(moduleGraph),
-			request: this.request,
-			originModule: module,
-			runtimeRequirements
-		});
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {string[]} ids imported ids
-	 * @param {string} additionalMessage extra info included in the error message
-	 * @returns {WebpackError[] | undefined} errors
-	 */
-	getLinkingErrors(moduleGraph, ids, additionalMessage) {
-		const importedModule = moduleGraph.getModule(this);
-		// ignore errors for missing or failed modules
-		if (!importedModule || importedModule.getNumberOfErrors() > 0) {
-			return;
-		}
+/***/ }),
 
-		const parentModule = moduleGraph.getParentModule(this);
-		const exportsType = importedModule.getExportsType(
-			moduleGraph,
-			parentModule.buildMeta.strictHarmonyModule
-		);
-		if (exportsType === "namespace" || exportsType === "default-with-named") {
-			if (ids.length === 0) {
-				return;
-			}
+/***/ 3083:
+/***/ (function(__unused_webpack_module, exports) {
 
-			if (
-				(exportsType !== "default-with-named" || ids[0] !== "default") &&
-				moduleGraph.isExportProvided(importedModule, ids) === false
-			) {
-				// We are sure that it's not provided
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				// Try to provide detailed info in the error message
-				let pos = 0;
-				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
-				while (pos < ids.length && exportsInfo) {
-					const id = ids[pos++];
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
-					if (exportInfo.provided === false) {
-						// We are sure that it's not provided
-						const providedExports = exportsInfo.getProvidedExports();
-						const moreInfo = !Array.isArray(providedExports)
-							? " (possible exports unknown)"
-							: providedExports.length === 0
-							? " (module has no exports)"
-							: ` (possible exports: ${providedExports.join(", ")})`;
-						return [
-							new HarmonyLinkingError(
-								`export ${ids
-									.slice(0, pos)
-									.map(id => `'${id}'`)
-									.join(".")} ${additionalMessage} was not found in '${
-									this.userRequest
-								}'${moreInfo}`
-							)
-						];
-					}
-					exportsInfo = exportInfo.getNestedExportsInfo();
-				}
 
-				// General error message
-				return [
-					new HarmonyLinkingError(
-						`export ${ids
-							.map(id => `'${id}'`)
-							.join(".")} ${additionalMessage} was not found in '${
-							this.userRequest
-						}'`
-					)
-				];
+
+/** @template T @typedef {(string | Record<string, string | string[] | T>)[] | Record<string, string | string[] | T>} ContainerOptionsFormat */
+
+/**
+ * @template T
+ * @template N
+ * @param {ContainerOptionsFormat<T>} options options passed by the user
+ * @param {function(string | string[], string) : N} normalizeSimple normalize a simple item
+ * @param {function(T, string) : N} normalizeOptions normalize a complex item
+ * @param {function(string, N): void} fn processing function
+ * @returns {void}
+ */
+const process = (options, normalizeSimple, normalizeOptions, fn) => {
+	const array = items => {
+		for (const item of items) {
+			if (typeof item === "string") {
+				fn(item, normalizeSimple(item, item));
+			} else if (item && typeof item === "object") {
+				object(item);
+			} else {
+				throw new Error("Unexpected options format");
 			}
 		}
-		switch (exportsType) {
-			case "default-only":
-				// It's has only a default export
-				if (ids.length > 0 && ids[0] !== "default") {
-					// In strict harmony modules we only support the default export
-					return [
-						new HarmonyLinkingError(
-							`Can't import the named export ${ids
-								.map(id => `'${id}'`)
-								.join(
-									"."
-								)} ${additionalMessage} from default-exporting module (only default export is available)`
-						)
-					];
-				}
-				break;
-			case "default-with-named":
-				// It has a default export and named properties redirect
-				// In some cases we still want to warn here
-				if (
-					ids.length > 0 &&
-					ids[0] !== "default" &&
-					importedModule.buildMeta.defaultObject === "redirect-warn"
-				) {
-					// For these modules only the default export is supported
-					return [
-						new HarmonyLinkingError(
-							`Should not import the named export ${ids
-								.map(id => `'${id}'`)
-								.join(
-									"."
-								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
-						)
-					];
-				}
-				break;
+	};
+	const object = obj => {
+		for (const [key, value] of Object.entries(obj)) {
+			if (typeof value === "string" || Array.isArray(value)) {
+				fn(key, normalizeSimple(value, key));
+			} else {
+				fn(key, normalizeOptions(value, key));
+			}
 		}
+	};
+	if (!options) {
+		return;
+	} else if (Array.isArray(options)) {
+		array(options);
+	} else if (typeof options === "object") {
+		object(options);
+	} else {
+		throw new Error("Unexpected options format");
 	}
+};
 
-	serialize(context) {
-		const { write } = context;
-		write(this.sourceOrder);
-		write(this.assertions);
-		super.serialize(context);
-	}
+/**
+ * @template T
+ * @template R
+ * @param {ContainerOptionsFormat<T>} options options passed by the user
+ * @param {function(string | string[], string) : R} normalizeSimple normalize a simple item
+ * @param {function(T, string) : R} normalizeOptions normalize a complex item
+ * @returns {[string, R][]} parsed options
+ */
+const parseOptions = (options, normalizeSimple, normalizeOptions) => {
+	/** @type {[string, R][]} */
+	const items = [];
+	process(options, normalizeSimple, normalizeOptions, (key, value) => {
+		items.push([key, value]);
+	});
+	return items;
+};
 
-	deserialize(context) {
-		const { read } = context;
-		this.sourceOrder = read();
-		this.assertions = read();
-		super.deserialize(context);
-	}
-}
+/**
+ * @template T
+ * @param {string} scope scope name
+ * @param {ContainerOptionsFormat<T>} options options passed by the user
+ * @returns {Record<string, string | string[] | T>} options to spread or pass
+ */
+const scope = (scope, options) => {
+	/** @type {Record<string, string | string[] | T>} */
+	const obj = {};
+	process(
+		options,
+		item => /** @type {string | string[] | T} */ (item),
+		item => /** @type {string | string[] | T} */ (item),
+		(key, value) => {
+			obj[
+				key.startsWith("./") ? `${scope}${key.slice(1)}` : `${scope}/${key}`
+			] = value;
+		}
+	);
+	return obj;
+};
 
-module.exports = HarmonyImportDependency;
+exports.parseOptions = parseOptions;
+exports.scope = scope;
 
-/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
-const importEmittedMap = new WeakMap();
 
-HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends (
-	ModuleDependency.Template
-) {
+/***/ }),
+
+/***/ 91254:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+
+
+const { ReplaceSource, RawSource, ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/Hash")} Hash */
+
+const TYPES = new Set(["javascript"]);
+
+class CssExportsGenerator extends Generator {
+	constructor() {
+		super();
+	}
+
+	// TODO add getConcatenationBailoutReason to allow concatenation
+	// but how to make it have a module id
+
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyImportDependency} */ (dependency);
-		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
+	generate(module, generateContext) {
+		const source = new ReplaceSource(new RawSource(""));
+		const initFragments = [];
+		const cssExports = new Map();
 
-		const connection = moduleGraph.getConnection(dep);
-		if (connection && !connection.isTargetActive(runtime)) return;
+		generateContext.runtimeRequirements.add(RuntimeGlobals.module);
 
-		const referencedModule = connection && connection.module;
+		const runtimeRequirements = new Set();
 
-		if (
-			connection &&
-			connection.weak &&
-			referencedModule &&
-			chunkGraph.getModuleId(referencedModule) === null
-		) {
-			// in weak references, module might not be in any chunk
-			// but that's ok, we don't need that logic in this case
-			return;
-		}
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
+			initFragments,
+			cssExports
+		};
 
-		const moduleKey = referencedModule
-			? referencedModule.identifier()
-			: dep.request;
-		const key = `harmony import ${moduleKey}`;
+		const handleDependency = dependency => {
+			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
+				dependency.constructor
+			);
+			const template = generateContext.dependencyTemplates.get(constructor);
+			if (!template) {
+				throw new Error(
+					"No template for dependency: " + dependency.constructor.name
+				);
+			}
 
-		const runtimeCondition = dep.weak
-			? false
-			: connection
-			? filterRuntime(runtime, r => connection.isTargetActive(r))
-			: true;
+			template.apply(dependency, source, templateContext);
+		};
+		module.dependencies.forEach(handleDependency);
 
-		if (module && referencedModule) {
-			let emittedModules = importEmittedMap.get(module);
-			if (emittedModules === undefined) {
-				emittedModules = new WeakMap();
-				importEmittedMap.set(module, emittedModules);
-			}
-			let mergedRuntimeCondition = runtimeCondition;
-			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
-			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
-				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
-					mergedRuntimeCondition = oldRuntimeCondition;
-				} else {
-					mergedRuntimeCondition = mergeRuntime(
-						oldRuntimeCondition,
-						mergedRuntimeCondition
-					);
+		if (generateContext.concatenationScope) {
+			const source = new ConcatSource();
+			const usedIdentifiers = new Set();
+			for (const [k, v] of cssExports) {
+				let identifier = Template.toIdentifier(k);
+				let i = 0;
+				while (usedIdentifiers.has(identifier)) {
+					identifier = Template.toIdentifier(k + i);
 				}
+				usedIdentifiers.add(identifier);
+				generateContext.concatenationScope.registerExport(k, identifier);
+				source.add(
+					`${
+						generateContext.runtimeTemplate.supportsConst ? "const" : "var"
+					} ${identifier} = ${JSON.stringify(v)};\n`
+				);
 			}
-			emittedModules.set(referencedModule, mergedRuntimeCondition);
-		}
-
-		const importStatement = dep.getImportStatement(false, templateContext);
-		if (
-			referencedModule &&
-			templateContext.moduleGraph.isAsync(referencedModule)
-		) {
-			templateContext.initFragments.push(
-				new ConditionalInitFragment(
-					importStatement[0],
-					InitFragment.STAGE_HARMONY_IMPORTS,
-					dep.sourceOrder,
-					key,
-					runtimeCondition
-				)
-			);
-			templateContext.initFragments.push(
-				new AwaitDependenciesInitFragment(
-					new Set([dep.getImportVar(templateContext.moduleGraph)])
-				)
-			);
-			templateContext.initFragments.push(
-				new ConditionalInitFragment(
-					importStatement[1],
-					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
-					dep.sourceOrder,
-					key + " compat",
-					runtimeCondition
-				)
-			);
+			return source;
 		} else {
-			templateContext.initFragments.push(
-				new ConditionalInitFragment(
-					importStatement[0] + importStatement[1],
-					InitFragment.STAGE_HARMONY_IMPORTS,
-					dep.sourceOrder,
-					key,
-					runtimeCondition
-				)
+			const otherUsed =
+				generateContext.moduleGraph
+					.getExportsInfo(module)
+					.otherExportsInfo.getUsed(generateContext.runtime) !==
+				UsageState.Unused;
+			if (otherUsed) {
+				generateContext.runtimeRequirements.add(
+					RuntimeGlobals.makeNamespaceObject
+				);
+			}
+			return new RawSource(
+				`${otherUsed ? `${RuntimeGlobals.makeNamespaceObject}(` : ""}${
+					module.moduleArgument
+				}.exports = {\n${Array.from(
+					cssExports,
+					([k, v]) => `\t${JSON.stringify(k)}: ${JSON.stringify(v)}`
+				).join(",\n")}\n}${otherUsed ? ")" : ""};`
 			);
 		}
 	}
 
 	/**
-	 *
-	 * @param {Module} module the module
-	 * @param {Module} referencedModule the referenced module
-	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	static getImportEmittedRuntime(module, referencedModule) {
-		const emittedModules = importEmittedMap.get(module);
-		if (emittedModules === undefined) return false;
-		return emittedModules.get(referencedModule) || false;
+	getTypes(module) {
+		return TYPES;
 	}
-};
 
-module.exports.ExportPresenceModes = ExportPresenceModes;
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 42;
+	}
+
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {}
+}
+
+module.exports = CssExportsGenerator;
 
 
 /***/ }),
 
-/***/ 20862:
+/***/ 46061:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const HotModuleReplacementPlugin = __webpack_require__(6404);
-const InnerGraph = __webpack_require__(38988);
-const ConstDependency = __webpack_require__(76911);
-const HarmonyAcceptDependency = __webpack_require__(23624);
-const HarmonyAcceptImportDependency = __webpack_require__(99843);
-const HarmonyExports = __webpack_require__(39211);
-const { ExportPresenceModes } = __webpack_require__(57154);
-const HarmonyImportSideEffectDependency = __webpack_require__(73132);
-const HarmonyImportSpecifierDependency = __webpack_require__(14077);
-
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("estree").ImportExpression} ImportExpression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
-/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
-/** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
+const { ReplaceSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
 
-const harmonySpecifierTag = Symbol("harmony import");
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/Hash")} Hash */
 
-/**
- * @typedef {Object} HarmonySettings
- * @property {string[]} ids
- * @property {string} source
- * @property {number} sourceOrder
- * @property {string} name
- * @property {boolean} await
- * @property {Record<string, any> | undefined} assertions
- */
+const TYPES = new Set(["css"]);
 
-/**
- * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
- * @returns {Record<string, any> | undefined} assertions
- */
-function getAssertions(node) {
-	// TODO remove cast when @types/estree has been updated to import assertions
-	const assertions = /** @type {{ assertions?: ImportAttributeNode[] }} */ (
-		node
-	).assertions;
-	if (assertions === undefined) {
-		return undefined;
-	}
-	const result = {};
-	for (const assertion of assertions) {
-		const key =
-			assertion.key.type === "Identifier"
-				? assertion.key.name
-				: assertion.key.value;
-		result[key] = assertion.value.value;
+class CssGenerator extends Generator {
+	constructor() {
+		super();
 	}
-	return result;
-}
 
-module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
-	 * @param {JavascriptParserOptions} options options
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	constructor(options) {
-		this.exportPresenceMode =
-			options.importExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
-				: options.exportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.exportsPresence)
-				: options.strictExportPresence
-				? ExportPresenceModes.ERROR
-				: ExportPresenceModes.AUTO;
-		this.strictThisContextOnImports = options.strictThisContextOnImports;
-	}
+	generate(module, generateContext) {
+		const originalSource = module.originalSource();
+		const source = new ReplaceSource(originalSource);
+		const initFragments = [];
+		const cssExports = new Map();
 
-	/**
-	 * @param {JavascriptParser} parser the parser
-	 * @returns {void}
-	 */
-	apply(parser) {
-		const { exportPresenceMode } = this;
-		parser.hooks.isPure
-			.for("Identifier")
-			.tap("HarmonyImportDependencyParserPlugin", expression => {
-				const expr = /** @type {Identifier} */ (expression);
-				if (
-					parser.isVariableDefined(expr.name) ||
-					parser.getTagData(expr.name, harmonySpecifierTag)
-				) {
-					return true;
-				}
-			});
-		parser.hooks.import.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(statement, source) => {
-				parser.state.lastHarmonyImportOrder =
-					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency(
-					parser.isAsiPosition(statement.range[0]) ? ";" : "",
-					statement.range
-				);
-				clearDep.loc = statement.loc;
-				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(statement.range[1]);
-				const assertions = getAssertions(statement);
-				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					source,
-					parser.state.lastHarmonyImportOrder,
-					assertions
-				);
-				sideEffectDep.loc = statement.loc;
-				parser.state.module.addDependency(sideEffectDep);
-				return true;
-			}
-		);
-		parser.hooks.importSpecifier.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(statement, source, id, name) => {
-				const ids = id === null ? [] : [id];
-				parser.tagVariable(name, harmonySpecifierTag, {
-					name,
-					source,
-					ids,
-					sourceOrder: parser.state.lastHarmonyImportOrder,
-					assertions: getAssertions(statement)
-				});
-				return true;
-			}
-		);
-		parser.hooks.expression
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					settings.ids,
-					settings.name,
-					expr.range,
-					exportPresenceMode,
-					settings.assertions
-				);
-				dep.shorthand = parser.scope.inShorthand;
-				dep.directImport = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
-		parser.hooks.expressionMemberChain
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					expr.range,
-					exportPresenceMode,
-					settings.assertions
-				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
-		parser.hooks.callMemberChain
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const { arguments: args, callee } = expr;
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					callee.range,
-					exportPresenceMode,
-					settings.assertions
+		generateContext.runtimeRequirements.add(RuntimeGlobals.hasCssModules);
+
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
+			initFragments,
+			cssExports
+		};
+
+		const handleDependency = dependency => {
+			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
+				dependency.constructor
+			);
+			const template = generateContext.dependencyTemplates.get(constructor);
+			if (!template) {
+				throw new Error(
+					"No template for dependency: " + dependency.constructor.name
 				);
-				dep.directImport = members.length === 0;
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
-				// only in case when we strictly follow the spec we need a special case here
-				dep.namespaceObjectAsContext =
-					members.length > 0 && this.strictThisContextOnImports;
-				dep.loc = callee.loc;
-				parser.state.module.addDependency(dep);
-				if (args) parser.walkExpressions(args);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
-		const { hotAcceptCallback, hotAcceptWithoutCallback } =
-			HotModuleReplacementPlugin.getParserHooks(parser);
-		hotAcceptCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						expr.range,
-						dependencies,
-						true
-					);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-				}
-			}
-		);
-		hotAcceptWithoutCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						expr.range,
-						dependencies,
-						false
-					);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-				}
 			}
-		);
+
+			template.apply(dependency, source, templateContext);
+		};
+		module.dependencies.forEach(handleDependency);
+		if (module.presentationalDependencies !== undefined)
+			module.presentationalDependencies.forEach(handleDependency);
+
+		if (cssExports.size > 0) {
+			const data = generateContext.getData();
+			data.set("css-exports", cssExports);
+		}
+
+		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
-};
 
-module.exports.harmonySpecifierTag = harmonySpecifierTag;
-module.exports.getAssertions = getAssertions;
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+
+		if (!originalSource) {
+			return 0;
+		}
+
+		return originalSource.size();
+	}
+
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {}
+}
+
+module.exports = CssGenerator;
 
 
 /***/ }),
 
-/***/ 73132:
+/***/ 80806:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -79330,84 +75274,451 @@ module.exports.getAssertions = getAssertions;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const HarmonyImportDependency = __webpack_require__(57154);
+const { SyncWaterfallHook } = __webpack_require__(41242);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { chunkHasCss } = __webpack_require__(47283);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../InitFragment")} InitFragment */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../Chunk")} Chunk */
 
-class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
-	constructor(request, sourceOrder, assertions) {
-		super(request, sourceOrder, assertions);
-	}
+/**
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
+ */
 
-	get type() {
-		return "harmony side effect evaluation";
-	}
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
 
+class CssLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
 	 */
-	getCondition(moduleGraph) {
-		return connection => {
-			const refModule = connection.resolvedModule;
-			if (!refModule) return true;
-			return refModule.getSideEffectsConnectionState(moduleGraph);
-		};
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				createStylesheet: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	constructor(runtimeRequirements, runtimeOptions) {
+		super("css loading", 10);
+
+		this._runtimeRequirements = runtimeRequirements;
+		this.runtimeOptions = runtimeOptions;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @returns {string} runtime code
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		const refModule = moduleGraph.getModule(this);
-		if (!refModule) return true;
-		return refModule.getSideEffectsConnectionState(moduleGraph);
+	generate() {
+		const { compilation, chunk, _runtimeRequirements } = this;
+		const {
+			chunkGraph,
+			runtimeTemplate,
+			outputOptions: {
+				crossOriginLoading,
+				uniqueName,
+				chunkLoadTimeout: loadTimeout
+			}
+		} = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const conditionMap = chunkGraph.getChunkConditionMap(
+			chunk,
+			(chunk, chunkGraph) =>
+				!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css")
+		);
+		const hasCssMatcher = compileBooleanMatcher(conditionMap);
+
+		const withLoading =
+			_runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
+			hasCssMatcher !== false;
+		const withHmr = _runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const initialChunkIdsWithCss = new Set();
+		const initialChunkIdsWithoutCss = new Set();
+		for (const c of chunk.getAllInitialChunks()) {
+			(chunkHasCss(c, chunkGraph)
+				? initialChunkIdsWithCss
+				: initialChunkIdsWithoutCss
+			).add(c.id);
+		}
+
+		if (!withLoading && !withHmr && initialChunkIdsWithCss.size === 0) {
+			return null;
+		}
+
+		const { createStylesheet } =
+			CssLoadingRuntimeModule.getCompilationHooks(compilation);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_css`
+			: undefined;
+
+		const code = Template.asString([
+			"link = document.createElement('link');",
+			uniqueName
+				? 'link.setAttribute("data-webpack", uniqueName + ":" + key);'
+				: "",
+			"link.setAttribute(loadingAttribute, 1);",
+			'link.rel = "stylesheet";',
+			"link.href = url;",
+			crossOriginLoading
+				? Template.asString([
+						"if (link.src.indexOf(window.location.origin + '/') !== 0) {",
+						Template.indent(
+							`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+						),
+						"}"
+				  ])
+				: ""
+		]);
+
+		const cc = str => str.charCodeAt(0);
+
+		return Template.asString([
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{${Array.from(
+				initialChunkIdsWithoutCss,
+				id => `${JSON.stringify(id)}:0`
+			).join(",")}};`,
+			"",
+			uniqueName
+				? `var uniqueName = ${JSON.stringify(
+						runtimeTemplate.outputOptions.uniqueName
+				  )};`
+				: "// data-webpack is not used as build has no uniqueName",
+			`var loadCssChunkData = ${runtimeTemplate.basicFunction(
+				"target, link, chunkId",
+				[
+					`var data, token = "", token2, exports = {}, exportsWithId = [], exportsWithDashes = [], ${
+						withHmr ? "moduleIds = [], " : ""
+					}i = 0, cc = 1;`,
+					"try { if(!link) link = loadStylesheet(chunkId); data = link.sheet.cssRules; data = data[data.length - 1].style; } catch(e) { data = getComputedStyle(document.head); }",
+					`data = data.getPropertyValue(${
+						uniqueName
+							? runtimeTemplate.concatenation(
+									"--webpack-",
+									{ expr: "uniqueName" },
+									"-",
+									{ expr: "chunkId" }
+							  )
+							: runtimeTemplate.concatenation("--webpack-", { expr: "chunkId" })
+					});`,
+					"if(!data) return [];",
+					"for(; cc; i++) {",
+					Template.indent([
+						"cc = data.charCodeAt(i);",
+						`if(cc == ${cc("(")}) { token2 = token; token = ""; }`,
+						`else if(cc == ${cc(
+							")"
+						)}) { exports[token2.replace(/^_/, "")] = token.replace(/^_/, ""); token = ""; }`,
+						`else if(cc == ${cc("/")} || cc == ${cc(
+							"%"
+						)}) { token = token.replace(/^_/, ""); exports[token] = token; exportsWithId.push(token); if(cc == ${cc(
+							"%"
+						)}) exportsWithDashes.push(token); token = ""; }`,
+						`else if(!cc || cc == ${cc(
+							","
+						)}) { token = token.replace(/^_/, ""); exportsWithId.forEach(${runtimeTemplate.expressionFunction(
+							`exports[x] = ${
+								uniqueName
+									? runtimeTemplate.concatenation(
+											{ expr: "uniqueName" },
+											"-",
+											{ expr: "token" },
+											"-",
+											{ expr: "exports[x]" }
+									  )
+									: runtimeTemplate.concatenation({ expr: "token" }, "-", {
+											expr: "exports[x]"
+									  })
+							}`,
+							"x"
+						)}); exportsWithDashes.forEach(${runtimeTemplate.expressionFunction(
+							`exports[x] = "--" + exports[x]`,
+							"x"
+						)}); ${
+							RuntimeGlobals.makeNamespaceObject
+						}(exports); target[token] = (${runtimeTemplate.basicFunction(
+							"exports, module",
+							`module.exports = exports;`
+						)}).bind(null, exports); ${
+							withHmr ? "moduleIds.push(token); " : ""
+						}token = ""; exports = {}; exportsWithId.length = 0; }`,
+						`else if(cc == ${cc("\\")}) { token += data[++i] }`,
+						`else { token += data[i]; }`
+					]),
+					"}",
+					`${
+						withHmr ? `if(target == ${RuntimeGlobals.moduleFactories}) ` : ""
+					}installedChunks[chunkId] = 0;`,
+					withHmr ? "return moduleIds;" : ""
+				]
+			)}`,
+			'var loadingAttribute = "data-webpack-loading";',
+			`var loadStylesheet = ${runtimeTemplate.basicFunction(
+				"chunkId, url, done" + (withHmr ? ", hmr" : ""),
+				[
+					'var link, needAttach, key = "chunk-" + chunkId;',
+					withHmr ? "if(!hmr) {" : "",
+					'var links = document.getElementsByTagName("link");',
+					"for(var i = 0; i < links.length; i++) {",
+					Template.indent([
+						"var l = links[i];",
+						`if(l.rel == "stylesheet" && (${
+							withHmr
+								? 'l.href.startsWith(url) || l.getAttribute("href").startsWith(url)'
+								: 'l.href == url || l.getAttribute("href") == url'
+						}${
+							uniqueName
+								? ' || l.getAttribute("data-webpack") == uniqueName + ":" + key'
+								: ""
+						})) { link = l; break; }`
+					]),
+					"}",
+					"if(!done) return link;",
+					withHmr ? "}" : "",
+					"if(!link) {",
+					Template.indent([
+						"needAttach = true;",
+						createStylesheet.call(code, this.chunk)
+					]),
+					"}",
+					`var onLinkComplete = ${runtimeTemplate.basicFunction(
+						"prev, event",
+						Template.asString([
+							"link.onerror = link.onload = null;",
+							"link.removeAttribute(loadingAttribute);",
+							"clearTimeout(timeout);",
+							'if(event && event.type != "load") link.parentNode.removeChild(link)',
+							"done(event);",
+							"if(prev) return prev(event);"
+						])
+					)};`,
+					"if(link.getAttribute(loadingAttribute)) {",
+					Template.indent([
+						`var timeout = setTimeout(onLinkComplete.bind(null, undefined, { type: 'timeout', target: link }), ${loadTimeout});`,
+						"link.onerror = onLinkComplete.bind(null, link.onerror);",
+						"link.onload = onLinkComplete.bind(null, link.onload);"
+					]),
+					"} else onLinkComplete(undefined, { type: 'load', target: link });", // We assume any existing stylesheet is render blocking
+					withHmr ? "hmr ? document.head.insertBefore(link, hmr) :" : "",
+					"needAttach && document.head.appendChild(link);",
+					"return link;"
+				]
+			)};`,
+			initialChunkIdsWithCss.size > 2
+				? `${JSON.stringify(
+						Array.from(initialChunkIdsWithCss)
+				  )}.forEach(loadCssChunkData.bind(null, ${
+						RuntimeGlobals.moduleFactories
+				  }, 0));`
+				: initialChunkIdsWithCss.size > 0
+				? `${Array.from(
+						initialChunkIdsWithCss,
+						id =>
+							`loadCssChunkData(${
+								RuntimeGlobals.moduleFactories
+							}, 0, ${JSON.stringify(id)});`
+				  ).join("")}`
+				: "// no initial css",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.css = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasCssMatcher !== false
+								? [
+										"// css chunk loading",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[2]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasCssMatcher === true
+													? "if(true) { // all chunks have CSS"
+													: `if(${hasCssMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
+														"resolve, reject"
+													)});`,
+													"promises.push(installedChunkData[2] = promise);",
+													"",
+													"// start chunk loading",
+													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
+													"// create error before stack unwound to get useful stacktrace later",
+													"var error = new Error();",
+													`var loadingEnded = ${runtimeTemplate.basicFunction(
+														"event",
+														[
+															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
+															Template.indent([
+																"installedChunkData = installedChunks[chunkId];",
+																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
+																"if(installedChunkData) {",
+																Template.indent([
+																	'if(event.type !== "load") {',
+																	Template.indent([
+																		"var errorType = event && event.type;",
+																		"var realSrc = event && event.target && event.target.src;",
+																		"error.message = 'Loading css chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+																		"error.name = 'ChunkLoadError';",
+																		"error.type = errorType;",
+																		"error.request = realSrc;",
+																		"installedChunkData[1](error);"
+																	]),
+																	"} else {",
+																	Template.indent([
+																		`loadCssChunkData(${RuntimeGlobals.moduleFactories}, link, chunkId);`,
+																		"installedChunkData[0]();"
+																	]),
+																	"}"
+																]),
+																"}"
+															]),
+															"}"
+														]
+													)};`,
+													"var link = loadStylesheet(chunkId, url, loadingEnded);"
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ]
+								: "installedChunks[chunkId] = 0;"
+						)};`
+				  ])
+				: "// no chunk loading",
+			"",
+			withHmr
+				? Template.asString([
+						"var oldTags = [];",
+						"var newTags = [];",
+						`var applyHandler = ${runtimeTemplate.basicFunction("options", [
+							`return { dispose: ${runtimeTemplate.basicFunction(
+								"",
+								[]
+							)}, apply: ${runtimeTemplate.basicFunction("", [
+								"var moduleIds = [];",
+								`newTags.forEach(${runtimeTemplate.expressionFunction(
+									"info[1].sheet.disabled = false",
+									"info"
+								)});`,
+								"while(oldTags.length) {",
+								Template.indent([
+									"var oldTag = oldTags.pop();",
+									"if(oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);"
+								]),
+								"}",
+								"while(newTags.length) {",
+								Template.indent([
+									`var info = newTags.pop();`,
+									`var chunkModuleIds = loadCssChunkData(${RuntimeGlobals.moduleFactories}, info[1], info[0]);`,
+									`chunkModuleIds.forEach(${runtimeTemplate.expressionFunction(
+										"moduleIds.push(id)",
+										"id"
+									)});`
+								]),
+								"}",
+								"return moduleIds;"
+							])} };`
+						])}`,
+						`var cssTextKey = ${runtimeTemplate.returningFunction(
+							`Array.from(link.sheet.cssRules, ${runtimeTemplate.returningFunction(
+								"r.cssText",
+								"r"
+							)}).join()`,
+							"link"
+						)}`,
+						`${
+							RuntimeGlobals.hmrDownloadUpdateHandlers
+						}.css = ${runtimeTemplate.basicFunction(
+							"chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList",
+							[
+								"applyHandlers.push(applyHandler);",
+								`chunkIds.forEach(${runtimeTemplate.basicFunction("chunkId", [
+									`var filename = ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
+									`var url = ${RuntimeGlobals.publicPath} + filename;`,
+									"var oldTag = loadStylesheet(chunkId, url);",
+									"if(!oldTag) return;",
+									`promises.push(new Promise(${runtimeTemplate.basicFunction(
+										"resolve, reject",
+										[
+											`var link = loadStylesheet(chunkId, url + (url.indexOf("?") < 0 ? "?" : "&") + "hmr=" + Date.now(), ${runtimeTemplate.basicFunction(
+												"event",
+												[
+													'if(event.type !== "load") {',
+													Template.indent([
+														"var errorType = event && event.type;",
+														"var realSrc = event && event.target && event.target.src;",
+														"error.message = 'Loading css hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+														"error.name = 'ChunkLoadError';",
+														"error.type = errorType;",
+														"error.request = realSrc;",
+														"reject(error);"
+													]),
+													"} else {",
+													Template.indent([
+														"try { if(cssTextKey(oldTag) == cssTextKey(link)) { if(link.parentNode) link.parentNode.removeChild(link); return resolve(); } } catch(e) {}",
+														"var factories = {};",
+														"loadCssChunkData(factories, link, chunkId);",
+														`Object.keys(factories).forEach(${runtimeTemplate.expressionFunction(
+															"updatedModulesList.push(id)",
+															"id"
+														)})`,
+														"link.sheet.disabled = true;",
+														"oldTags.push(oldTag);",
+														"newTags.push([chunkId, link]);",
+														"resolve();"
+													]),
+													"}"
+												]
+											)}, oldTag);`
+										]
+									)}));`
+								])});`
+							]
+						)}`
+				  ])
+				: "// no hmr"
+		]);
 	}
 }
 
-makeSerializable(
-	HarmonyImportSideEffectDependency,
-	"webpack/lib/dependencies/HarmonyImportSideEffectDependency"
-);
-
-HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const { moduleGraph, concatenationScope } = templateContext;
-		if (concatenationScope) {
-			const module = moduleGraph.getModule(dependency);
-			if (concatenationScope.isModuleInScope(module)) {
-				return;
-			}
-		}
-		super.apply(dependency, source, templateContext);
-	}
-};
-
-module.exports = HarmonyImportSideEffectDependency;
+module.exports = CssLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 14077:
+/***/ 47283:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -79418,367 +75729,79 @@ module.exports = HarmonyImportSideEffectDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const {
-	getDependencyUsedByExportsCondition
-} = __webpack_require__(38988);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const HarmonyImportDependency = __webpack_require__(57154);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
-
-const { ExportPresenceModes } = HarmonyImportDependency;
-
-class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
-	constructor(
-		request,
-		sourceOrder,
-		ids,
-		name,
-		range,
-		exportPresenceMode,
-		assertions
-	) {
-		super(request, sourceOrder, assertions);
-		this.ids = ids;
-		this.name = name;
-		this.range = range;
-		this.exportPresenceMode = exportPresenceMode;
-		this.namespaceObjectAsContext = false;
-		this.call = undefined;
-		this.directImport = undefined;
-		this.shorthand = undefined;
-		this.asiSafe = undefined;
-		/** @type {Set<string> | boolean} */
-		this.usedByExports = undefined;
-	}
-
-	// TODO webpack 6 remove
-	get id() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
-
-	// TODO webpack 6 remove
-	getId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
-
-	// TODO webpack 6 remove
-	setId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
-
-	get type() {
-		return "harmony import specifier";
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported ids
-	 */
-	getIds(moduleGraph) {
-		const meta = moduleGraph.getMetaIfExisting(this);
-		if (meta === undefined) return this.ids;
-		const ids = meta[idsSymbol];
-		return ids !== undefined ? ids : this.ids;
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
-	 * @returns {void}
-	 */
-	setIds(moduleGraph, ids) {
-		moduleGraph.getMeta(this)[idsSymbol] = ids;
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
-	 */
-	getCondition(moduleGraph) {
-		return getDependencyUsedByExportsCondition(
-			this,
-			this.usedByExports,
-			moduleGraph
-		);
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		let ids = this.getIds(moduleGraph);
-		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
-		let namespaceObjectAsContext = this.namespaceObjectAsContext;
-		if (ids[0] === "default") {
-			const selfModule = moduleGraph.getParentModule(this);
-			const importedModule = moduleGraph.getModule(this);
-			switch (
-				importedModule.getExportsType(
-					moduleGraph,
-					selfModule.buildMeta.strictHarmonyModule
-				)
-			) {
-				case "default-only":
-				case "default-with-named":
-					if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
-					ids = ids.slice(1);
-					namespaceObjectAsContext = true;
-					break;
-				case "dynamic":
-					return Dependency.EXPORTS_OBJECT_REFERENCED;
-			}
-		}
-
-		if (
-			this.call &&
-			!this.directImport &&
-			(namespaceObjectAsContext || ids.length > 1)
-		) {
-			if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
-			ids = ids.slice(0, -1);
-		}
-
-		return [ids];
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {number} effective mode
-	 */
-	_getEffectiveExportPresenceLevel(moduleGraph) {
-		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
-			return this.exportPresenceMode;
-		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-			? ExportPresenceModes.ERROR
-			: ExportPresenceModes.WARN;
-	}
-
-	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
-	 */
-	getWarnings(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.WARN) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
-	}
+const { ConcatSource } = __webpack_require__(51255);
+const HotUpdateChunk = __webpack_require__(9597);
+const RuntimeGlobals = __webpack_require__(16475);
+const SelfModuleFactory = __webpack_require__(63560);
+const CssExportDependency = __webpack_require__(76760);
+const CssImportDependency = __webpack_require__(90542);
+const CssLocalIdentifierDependency = __webpack_require__(92328);
+const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
+const CssUrlDependency = __webpack_require__(70749);
+const StaticExportsDependency = __webpack_require__(91418);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const memoize = __webpack_require__(78676);
+const CssExportsGenerator = __webpack_require__(91254);
+const CssGenerator = __webpack_require__(46061);
+const CssParser = __webpack_require__(98305);
 
-	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
-	 */
-	getErrors(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
-	}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[] | undefined} errors
-	 */
-	_getErrors(moduleGraph) {
-		const ids = this.getIds(moduleGraph);
-		return this.getLinkingErrors(
-			moduleGraph,
-			ids,
-			`(imported as '${this.name}')`
-		);
-	}
+const getCssLoadingRuntimeModule = memoize(() =>
+	__webpack_require__(80806)
+);
 
-	/**
-	 * implement this method to allow the occurrence order plugin to count correctly
-	 * @returns {number} count how often the id is used in this dependency
-	 */
-	getNumberOfIdOccurrences() {
-		return 0;
-	}
+const getSchema = name => {
+	const { definitions } = __webpack_require__(73342);
+	return {
+		definitions,
+		oneOf: [{ $ref: `#/definitions/${name}` }]
+	};
+};
 
-	serialize(context) {
-		const { write } = context;
-		write(this.ids);
-		write(this.name);
-		write(this.range);
-		write(this.exportPresenceMode);
-		write(this.namespaceObjectAsContext);
-		write(this.call);
-		write(this.directImport);
-		write(this.shorthand);
-		write(this.asiSafe);
-		write(this.usedByExports);
-		super.serialize(context);
+const validateGeneratorOptions = createSchemaValidation(
+	__webpack_require__(59170),
+	() => getSchema("CssGeneratorOptions"),
+	{
+		name: "Css Modules Plugin",
+		baseDataPath: "parser"
 	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.ids = read();
-		this.name = read();
-		this.range = read();
-		this.exportPresenceMode = read();
-		this.namespaceObjectAsContext = read();
-		this.call = read();
-		this.directImport = read();
-		this.shorthand = read();
-		this.asiSafe = read();
-		this.usedByExports = read();
-		super.deserialize(context);
+);
+const validateParserOptions = createSchemaValidation(
+	__webpack_require__(38542),
+	() => getSchema("CssParserOptions"),
+	{
+		name: "Css Modules Plugin",
+		baseDataPath: "parser"
 	}
-}
-
-makeSerializable(
-	HarmonyImportSpecifierDependency,
-	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
 );
 
-HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
-		const { moduleGraph, module, runtime, concatenationScope } =
-			templateContext;
-		const connection = moduleGraph.getConnection(dep);
-		// Skip rendering depending when dependency is conditional
-		if (connection && !connection.isTargetActive(runtime)) return;
-
-		const ids = dep.getIds(moduleGraph);
-
-		let exportExpr;
-		if (
-			connection &&
-			concatenationScope &&
-			concatenationScope.isModuleInScope(connection.module)
-		) {
-			if (ids.length === 0) {
-				exportExpr = concatenationScope.createModuleReference(
-					connection.module,
-					{
-						asiSafe: dep.asiSafe
-					}
-				);
-			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
-				exportExpr =
-					concatenationScope.createModuleReference(connection.module, {
-						asiSafe: dep.asiSafe
-					}) + propertyAccess(ids);
-			} else {
-				exportExpr = concatenationScope.createModuleReference(
-					connection.module,
-					{
-						ids,
-						call: dep.call,
-						directImport: dep.directImport,
-						asiSafe: dep.asiSafe
-					}
-				);
-			}
-		} else {
-			super.apply(dependency, source, templateContext);
-
-			const { runtimeTemplate, initFragments, runtimeRequirements } =
-				templateContext;
-
-			exportExpr = runtimeTemplate.exportFromImport({
-				moduleGraph,
-				module: moduleGraph.getModule(dep),
-				request: dep.request,
-				exportName: ids,
-				originModule: module,
-				asiSafe: dep.shorthand ? true : dep.asiSafe,
-				isCall: dep.call,
-				callContext: !dep.directImport,
-				defaultInterop: true,
-				importVar: dep.getImportVar(moduleGraph),
-				initFragments,
-				runtime,
-				runtimeRequirements
-			});
-		}
-		if (dep.shorthand) {
-			source.insert(dep.range[1], `: ${exportExpr}`);
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, exportExpr);
-		}
-	}
+const escapeCss = (str, omitOptionalUnderscore) => {
+	const escaped = `${str}`.replace(
+		// cspell:word uffff
+		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
+		s => `\\${s}`
+	);
+	return !omitOptionalUnderscore && /^(?!--)[0-9_-]/.test(escaped)
+		? `_${escaped}`
+		: escaped;
 };
 
-module.exports = HarmonyImportSpecifierDependency;
-
-
-/***/ }),
-
-/***/ 39029:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const HarmonyAcceptDependency = __webpack_require__(23624);
-const HarmonyAcceptImportDependency = __webpack_require__(99843);
-const HarmonyCompatibilityDependency = __webpack_require__(72906);
-const HarmonyExportExpressionDependency = __webpack_require__(51340);
-const HarmonyExportHeaderDependency = __webpack_require__(38873);
-const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
-const HarmonyExportSpecifierDependency = __webpack_require__(48567);
-const HarmonyImportSideEffectDependency = __webpack_require__(73132);
-const HarmonyImportSpecifierDependency = __webpack_require__(14077);
-
-const HarmonyDetectionParserPlugin = __webpack_require__(17223);
-const HarmonyExportDependencyParserPlugin = __webpack_require__(93466);
-const HarmonyImportDependencyParserPlugin = __webpack_require__(20862);
-const HarmonyTopLevelThisParserPlugin = __webpack_require__(63232);
-
-/** @typedef {import("../Compiler")} Compiler */
+const plugin = "CssModulesPlugin";
 
-class HarmonyModulesPlugin {
-	constructor(options) {
-		this.options = options;
+class CssModulesPlugin {
+	/**
+	 * @param {CssExperimentOptions} options options
+	 */
+	constructor({ exportsOnly = false }) {
+		this._exportsOnly = exportsOnly;
 	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -79786,131 +75809,385 @@ class HarmonyModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"HarmonyModulesPlugin",
+			plugin,
 			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					HarmonyCompatibilityDependency,
-					new HarmonyCompatibilityDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyImportSideEffectDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyImportSideEffectDependency,
-					new HarmonyImportSideEffectDependency.Template()
-				);
-
+				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
 				compilation.dependencyFactories.set(
-					HarmonyImportSpecifierDependency,
+					CssUrlDependency,
 					normalModuleFactory
 				);
 				compilation.dependencyTemplates.set(
-					HarmonyImportSpecifierDependency,
-					new HarmonyImportSpecifierDependency.Template()
+					CssUrlDependency,
+					new CssUrlDependency.Template()
 				);
-
 				compilation.dependencyTemplates.set(
-					HarmonyExportHeaderDependency,
-					new HarmonyExportHeaderDependency.Template()
+					CssLocalIdentifierDependency,
+					new CssLocalIdentifierDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					CssSelfLocalIdentifierDependency,
+					selfFactory
 				);
-
 				compilation.dependencyTemplates.set(
-					HarmonyExportExpressionDependency,
-					new HarmonyExportExpressionDependency.Template()
+					CssSelfLocalIdentifierDependency,
+					new CssSelfLocalIdentifierDependency.Template()
 				);
-
 				compilation.dependencyTemplates.set(
-					HarmonyExportSpecifierDependency,
-					new HarmonyExportSpecifierDependency.Template()
+					CssExportDependency,
+					new CssExportDependency.Template()
 				);
-
 				compilation.dependencyFactories.set(
-					HarmonyExportImportedSpecifierDependency,
+					CssImportDependency,
 					normalModuleFactory
 				);
 				compilation.dependencyTemplates.set(
-					HarmonyExportImportedSpecifierDependency,
-					new HarmonyExportImportedSpecifierDependency.Template()
+					CssImportDependency,
+					new CssImportDependency.Template()
 				);
-
 				compilation.dependencyTemplates.set(
-					HarmonyAcceptDependency,
-					new HarmonyAcceptDependency.Template()
+					StaticExportsDependency,
+					new StaticExportsDependency.Template()
 				);
+				normalModuleFactory.hooks.createParser
+					.for("css")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						return new CssParser();
+					});
+				normalModuleFactory.hooks.createParser
+					.for("css/global")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						return new CssParser({
+							allowPseudoBlocks: false,
+							allowModeSwitch: false
+						});
+					});
+				normalModuleFactory.hooks.createParser
+					.for("css/module")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						return new CssParser({
+							defaultMode: "local"
+						});
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("css")
+					.tap(plugin, generatorOptions => {
+						validateGeneratorOptions(generatorOptions);
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("css/global")
+					.tap(plugin, generatorOptions => {
+						validateGeneratorOptions(generatorOptions);
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("css/module")
+					.tap(plugin, generatorOptions => {
+						validateGeneratorOptions(generatorOptions);
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
+					});
+				const orderedCssModulesPerChunk = new WeakMap();
+				compilation.hooks.afterCodeGeneration.tap("CssModulesPlugin", () => {
+					const { chunkGraph } = compilation;
+					for (const chunk of compilation.chunks) {
+						if (CssModulesPlugin.chunkHasCss(chunk, chunkGraph)) {
+							orderedCssModulesPerChunk.set(
+								chunk,
+								this.getOrderedChunkCssModules(chunk, chunkGraph, compilation)
+							);
+						}
+					}
+				});
+				compilation.hooks.contentHash.tap("CssModulesPlugin", chunk => {
+					const {
+						chunkGraph,
+						outputOptions: {
+							hashSalt,
+							hashDigest,
+							hashDigestLength,
+							hashFunction
+						}
+					} = compilation;
+					const modules = orderedCssModulesPerChunk.get(chunk);
+					if (modules === undefined) return;
+					const hash = createHash(hashFunction);
+					if (hashSalt) hash.update(hashSalt);
+					for (const module of modules) {
+						hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
+					}
+					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					chunk.contentHash.css = digest.substr(0, hashDigestLength);
+				});
+				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { hash, chunk, codeGenerationResults } = options;
 
-				compilation.dependencyFactories.set(
-					HarmonyAcceptImportDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyAcceptImportDependency,
-					new HarmonyAcceptImportDependency.Template()
-				);
+					if (chunk instanceof HotUpdateChunk) return result;
 
-				const handler = (parser, parserOptions) => {
-					// TODO webpack 6: rename harmony to esm or module
-					if (parserOptions.harmony !== undefined && !parserOptions.harmony)
+					const modules = orderedCssModulesPerChunk.get(chunk);
+					if (modules !== undefined) {
+						result.push({
+							render: () =>
+								this.renderChunk({
+									chunk,
+									chunkGraph,
+									codeGenerationResults,
+									uniqueName: compilation.outputOptions.uniqueName,
+									modules
+								}),
+							filenameTemplate: CssModulesPlugin.getChunkFilenameTemplate(
+								chunk,
+								compilation.outputOptions
+							),
+							pathOptions: {
+								hash,
+								runtime: chunk.runtime,
+								chunk,
+								contentHashType: "css"
+							},
+							identifier: `css${chunk.id}`,
+							hash: chunk.contentHash.css
+						});
+					}
+					return result;
+				});
+				const enabledChunks = new WeakSet();
+				const handler = (chunk, set) => {
+					if (enabledChunks.has(chunk)) {
 						return;
+					}
+					enabledChunks.add(chunk);
 
-					new HarmonyDetectionParserPlugin(this.options).apply(parser);
-					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
-					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
-					new HarmonyTopLevelThisParserPlugin().apply(parser);
-				};
+					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkCssFilename);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.makeNamespaceObject);
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("HarmonyModulesPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("HarmonyModulesPlugin", handler);
+					const CssLoadingRuntimeModule = getCssLoadingRuntimeModule();
+					compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hasCssModules)
+					.tap(plugin, handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap(plugin, handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap(plugin, handler);
 			}
 		);
 	}
-}
-module.exports = HarmonyModulesPlugin;
 
+	getModulesInOrder(chunk, modules, compilation) {
+		if (!modules) return [];
 
-/***/ }),
+		const modulesList = [...modules];
 
-/***/ 63232:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// Get ordered list of modules per chunk group
+		// Lists are in reverse order to allow to use Array.pop()
+		const modulesByChunkGroup = Array.from(chunk.groupsIterable, chunkGroup => {
+			const sortedModules = modulesList
+				.map(module => {
+					return {
+						module,
+						index: chunkGroup.getModulePostOrderIndex(module)
+					};
+				})
+				.filter(item => item.index !== undefined)
+				.sort((a, b) => b.index - a.index)
+				.map(item => item.module);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
+			return { list: sortedModules, set: new Set(sortedModules) };
+		});
 
+		if (modulesByChunkGroup.length === 1)
+			return modulesByChunkGroup[0].list.reverse();
+
+		const compareModuleLists = ({ list: a }, { list: b }) => {
+			if (a.length === 0) {
+				return b.length === 0 ? 0 : 1;
+			} else {
+				if (b.length === 0) return -1;
+				return compareModulesByIdentifier(a[a.length - 1], b[b.length - 1]);
+			}
+		};
 
+		modulesByChunkGroup.sort(compareModuleLists);
 
-const ConstDependency = __webpack_require__(76911);
-const HarmonyExports = __webpack_require__(39211);
+		const finalModules = [];
 
-class HarmonyTopLevelThisParserPlugin {
-	apply(parser) {
-		parser.hooks.expression
-			.for("this")
-			.tap("HarmonyTopLevelThisParserPlugin", node => {
-				if (!parser.scope.topLevelScope) return;
-				if (HarmonyExports.isEnabled(parser.state)) {
-					const dep = new ConstDependency("undefined", node.range, null);
-					dep.loc = node.loc;
-					parser.state.module.addPresentationalDependency(dep);
-					return this;
+		for (;;) {
+			const failedModules = new Set();
+			const list = modulesByChunkGroup[0].list;
+			if (list.length === 0) {
+				// done, everything empty
+				break;
+			}
+			let selectedModule = list[list.length - 1];
+			let hasFailed = undefined;
+			outer: for (;;) {
+				for (const { list, set } of modulesByChunkGroup) {
+					if (list.length === 0) continue;
+					const lastModule = list[list.length - 1];
+					if (lastModule === selectedModule) continue;
+					if (!set.has(selectedModule)) continue;
+					failedModules.add(selectedModule);
+					if (failedModules.has(lastModule)) {
+						// There is a conflict, try other alternatives
+						hasFailed = lastModule;
+						continue;
+					}
+					selectedModule = lastModule;
+					hasFailed = false;
+					continue outer; // restart
 				}
-			});
+				break;
+			}
+			if (hasFailed) {
+				// There is a not resolve-able conflict with the selectedModule
+				if (compilation) {
+					// TODO print better warning
+					compilation.warnings.push(
+						new Error(
+							`chunk ${
+								chunk.name || chunk.id
+							}\nConflicting order between ${hasFailed.readableIdentifier(
+								compilation.requestShortener
+							)} and ${selectedModule.readableIdentifier(
+								compilation.requestShortener
+							)}`
+						)
+					);
+				}
+				selectedModule = hasFailed;
+			}
+			// Insert the selected module into the final modules list
+			finalModules.push(selectedModule);
+			// Remove the selected module from all lists
+			for (const { list, set } of modulesByChunkGroup) {
+				const lastModule = list[list.length - 1];
+				if (lastModule === selectedModule) list.pop();
+				else if (hasFailed && set.has(selectedModule)) {
+					const idx = list.indexOf(selectedModule);
+					if (idx >= 0) list.splice(idx, 1);
+				}
+			}
+			modulesByChunkGroup.sort(compareModuleLists);
+		}
+		return finalModules;
+	}
+
+	getOrderedChunkCssModules(chunk, chunkGraph, compilation) {
+		return [
+			...this.getModulesInOrder(
+				chunk,
+				chunkGraph.getOrderedChunkModulesIterableBySourceType(
+					chunk,
+					"css-import",
+					compareModulesByIdentifier
+				),
+				compilation
+			),
+			...this.getModulesInOrder(
+				chunk,
+				chunkGraph.getOrderedChunkModulesIterableBySourceType(
+					chunk,
+					"css",
+					compareModulesByIdentifier
+				),
+				compilation
+			)
+		];
+	}
+
+	renderChunk({
+		uniqueName,
+		chunk,
+		chunkGraph,
+		codeGenerationResults,
+		modules
+	}) {
+		const source = new ConcatSource();
+		const metaData = [];
+		for (const module of modules) {
+			try {
+				const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+
+				const s =
+					codeGenResult.sources.get("css") ||
+					codeGenResult.sources.get("css-import");
+				if (s) {
+					source.add(s);
+					source.add("\n");
+				}
+				const exports =
+					codeGenResult.data && codeGenResult.data.get("css-exports");
+				const moduleId = chunkGraph.getModuleId(module) + "";
+				metaData.push(
+					`${
+						exports
+							? Array.from(exports, ([n, v]) => {
+									const shortcutValue = `${
+										uniqueName ? uniqueName + "-" : ""
+									}${moduleId}-${n}`;
+									return v === shortcutValue
+										? `${escapeCss(n)}/`
+										: v === "--" + shortcutValue
+										? `${escapeCss(n)}%`
+										: `${escapeCss(n)}(${escapeCss(v)})`;
+							  }).join("")
+							: ""
+					}${escapeCss(moduleId)}`
+				);
+			} catch (e) {
+				e.message += `\nduring rendering of css ${module.identifier()}`;
+				throw e;
+			}
+		}
+		source.add(
+			`head{--webpack-${escapeCss(
+				(uniqueName ? uniqueName + "-" : "") + chunk.id,
+				true
+			)}:${metaData.join(",")};}`
+		);
+		return source;
+	}
+
+	static getChunkFilenameTemplate(chunk, outputOptions) {
+		if (chunk.cssFilenameTemplate) {
+			return chunk.cssFilenameTemplate;
+		} else if (chunk.canBeInitial()) {
+			return outputOptions.cssFilename;
+		} else {
+			return outputOptions.cssChunkFilename;
+		}
+	}
+
+	static chunkHasCss(chunk, chunkGraph) {
+		return (
+			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css") ||
+			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css-import")
+		);
 	}
 }
 
-module.exports = HarmonyTopLevelThisParserPlugin;
+module.exports = CssModulesPlugin;
 
 
 /***/ }),
 
-/***/ 1902:
+/***/ 98305:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -79921,59 +76198,623 @@ module.exports = HarmonyTopLevelThisParserPlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
+const Parser = __webpack_require__(11715);
+const ConstDependency = __webpack_require__(76911);
+const CssExportDependency = __webpack_require__(76760);
+const CssImportDependency = __webpack_require__(90542);
+const CssLocalIdentifierDependency = __webpack_require__(92328);
+const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
+const CssUrlDependency = __webpack_require__(70749);
+const StaticExportsDependency = __webpack_require__(91418);
+const walkCssTokens = __webpack_require__(44124);
 
-class ImportContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-		this.range = range;
-		this.valueRange = valueRange;
-	}
+const CC_LEFT_CURLY = "{".charCodeAt(0);
+const CC_RIGHT_CURLY = "}".charCodeAt(0);
+const CC_COLON = ":".charCodeAt(0);
+const CC_SLASH = "/".charCodeAt(0);
+const CC_SEMICOLON = ";".charCodeAt(0);
 
-	get type() {
-		return `import() context ${this.options.mode}`;
+const cssUnescape = str => {
+	return str.replace(/\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g, match => {
+		if (match.length > 2) {
+			return String.fromCharCode(parseInt(match.slice(1).trim(), 16));
+		} else {
+			return match[1];
+		}
+	});
+};
+
+class LocConverter {
+	constructor(input) {
+		this._input = input;
+		this.line = 1;
+		this.column = 0;
+		this.pos = 0;
 	}
 
-	get category() {
-		return "esm";
+	get(pos) {
+		if (this.pos !== pos) {
+			if (this.pos < pos) {
+				const str = this._input.slice(this.pos, pos);
+				let i = str.lastIndexOf("\n");
+				if (i === -1) {
+					this.column += str.length;
+				} else {
+					this.column = str.length - i - 1;
+					this.line++;
+					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1)
+						this.line++;
+				}
+			} else {
+				let i = this._input.lastIndexOf("\n", this.pos);
+				while (i >= pos) {
+					this.line--;
+					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
+				}
+				this.column = pos - i;
+			}
+			this.pos = pos;
+		}
+		return this;
 	}
+}
 
-	serialize(context) {
-		const { write } = context;
+const CSS_MODE_TOP_LEVEL = 0;
+const CSS_MODE_IN_RULE = 1;
+const CSS_MODE_IN_LOCAL_RULE = 2;
+const CSS_MODE_AT_IMPORT_EXPECT_URL = 3;
+// TODO implement layer and supports for @import
+const CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS = 4;
+const CSS_MODE_AT_IMPORT_EXPECT_MEDIA = 5;
+const CSS_MODE_AT_OTHER = 6;
 
-		write(this.range);
-		write(this.valueRange);
+const explainMode = mode => {
+	switch (mode) {
+		case CSS_MODE_TOP_LEVEL:
+			return "parsing top level css";
+		case CSS_MODE_IN_RULE:
+			return "parsing css rule content (global)";
+		case CSS_MODE_IN_LOCAL_RULE:
+			return "parsing css rule content (local)";
+		case CSS_MODE_AT_IMPORT_EXPECT_URL:
+			return "parsing @import (expecting url)";
+		case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
+			return "parsing @import (expecting optionally supports or media query)";
+		case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
+			return "parsing @import (expecting optionally media query)";
+		case CSS_MODE_AT_OTHER:
+			return "parsing at-rule";
+		default:
+			return mode;
+	}
+};
 
-		super.serialize(context);
+class CssParser extends Parser {
+	constructor({
+		allowPseudoBlocks = true,
+		allowModeSwitch = true,
+		defaultMode = "global"
+	} = {}) {
+		super();
+		this.allowPseudoBlocks = allowPseudoBlocks;
+		this.allowModeSwitch = allowModeSwitch;
+		this.defaultMode = defaultMode;
 	}
 
-	deserialize(context) {
-		const { read } = context;
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		} else if (typeof source === "object") {
+			throw new Error("webpackAst is unexpected for the CssParser");
+		}
+		if (source[0] === "\ufeff") {
+			source = source.slice(1);
+		}
 
-		this.range = read();
-		this.valueRange = read();
+		const module = state.module;
 
-		super.deserialize(context);
-	}
-}
+		const declaredCssVariables = new Set();
 
-makeSerializable(
-	ImportContextDependency,
-	"webpack/lib/dependencies/ImportContextDependency"
-);
+		const locConverter = new LocConverter(source);
+		let mode = CSS_MODE_TOP_LEVEL;
+		let modePos = 0;
+		let modeNestingLevel = 0;
+		let modeData = undefined;
+		let singleClassSelector = undefined;
+		let lastIdentifier = undefined;
+		const modeStack = [];
+		const isTopLevelLocal = () =>
+			modeData === "local" ||
+			(this.defaultMode === "local" && modeData === undefined);
+		const eatWhiteLine = (input, pos) => {
+			for (;;) {
+				const cc = input.charCodeAt(pos);
+				if (cc === 32 || cc === 9) {
+					pos++;
+					continue;
+				}
+				if (cc === 10) pos++;
+				break;
+			}
+			return pos;
+		};
+		const eatUntil = chars => {
+			const charCodes = Array.from({ length: chars.length }, (_, i) =>
+				chars.charCodeAt(i)
+			);
+			const arr = Array.from(
+				{ length: charCodes.reduce((a, b) => Math.max(a, b), 0) + 1 },
+				() => false
+			);
+			charCodes.forEach(cc => (arr[cc] = true));
+			return (input, pos) => {
+				for (;;) {
+					const cc = input.charCodeAt(pos);
+					if (cc < arr.length && arr[cc]) {
+						return pos;
+					}
+					pos++;
+					if (pos === input.length) return pos;
+				}
+			};
+		};
+		const eatText = (input, pos, eater) => {
+			let text = "";
+			for (;;) {
+				if (input.charCodeAt(pos) === CC_SLASH) {
+					const newPos = walkCssTokens.eatComments(input, pos);
+					if (pos !== newPos) {
+						pos = newPos;
+						if (pos === input.length) break;
+					} else {
+						text += "/";
+						pos++;
+						if (pos === input.length) break;
+					}
+				}
+				const newPos = eater(input, pos);
+				if (pos !== newPos) {
+					text += input.slice(pos, newPos);
+					pos = newPos;
+				} else {
+					break;
+				}
+				if (pos === input.length) break;
+			}
+			return [pos, text.trimRight()];
+		};
+		const eatExportName = eatUntil(":};/");
+		const eatExportValue = eatUntil("};/");
+		const parseExports = (input, pos) => {
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			const cc = input.charCodeAt(pos);
+			if (cc !== CC_LEFT_CURLY)
+				throw new Error(
+					`Unexpected ${input[pos]} at ${pos} during parsing of ':export' (expected '{')`
+				);
+			pos++;
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			for (;;) {
+				if (input.charCodeAt(pos) === CC_RIGHT_CURLY) break;
+				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+				if (pos === input.length) return pos;
+				let start = pos;
+				let name;
+				[pos, name] = eatText(input, pos, eatExportName);
+				if (pos === input.length) return pos;
+				if (input.charCodeAt(pos) !== CC_COLON) {
+					throw new Error(
+						`Unexpected ${input[pos]} at ${pos} during parsing of export name in ':export' (expected ':')`
+					);
+				}
+				pos++;
+				if (pos === input.length) return pos;
+				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+				if (pos === input.length) return pos;
+				let value;
+				[pos, value] = eatText(input, pos, eatExportValue);
+				if (pos === input.length) return pos;
+				const cc = input.charCodeAt(pos);
+				if (cc === CC_SEMICOLON) {
+					pos++;
+					if (pos === input.length) return pos;
+					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+					if (pos === input.length) return pos;
+				} else if (cc !== CC_RIGHT_CURLY) {
+					throw new Error(
+						`Unexpected ${input[pos]} at ${pos} during parsing of export value in ':export' (expected ';' or '}')`
+					);
+				}
+				const dep = new CssExportDependency(name, value);
+				const { line: sl, column: sc } = locConverter.get(start);
+				const { line: el, column: ec } = locConverter.get(pos);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+			}
+			pos++;
+			if (pos === input.length) return pos;
+			pos = eatWhiteLine(input, pos);
+			return pos;
+		};
+		const eatPropertyName = eatUntil(":{};");
+		const processLocalDeclaration = (input, pos) => {
+			modeData = undefined;
+			const start = pos;
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			const propertyNameStart = pos;
+			const [propertyNameEnd, propertyName] = eatText(
+				input,
+				pos,
+				eatPropertyName
+			);
+			if (input.charCodeAt(propertyNameEnd) !== CC_COLON) return start;
+			pos = propertyNameEnd + 1;
+			if (propertyName.startsWith("--")) {
+				// CSS Variable
+				const { line: sl, column: sc } = locConverter.get(propertyNameStart);
+				const { line: el, column: ec } = locConverter.get(propertyNameEnd);
+				const name = propertyName.slice(2);
+				const dep = new CssLocalIdentifierDependency(
+					name,
+					[propertyNameStart, propertyNameEnd],
+					"--"
+				);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+				declaredCssVariables.add(name);
+			} else if (
+				propertyName === "animation-name" ||
+				propertyName === "animation"
+			) {
+				modeData = "animation";
+				lastIdentifier = undefined;
+			}
+			return pos;
+		};
+		const processDeclarationValueDone = (input, pos) => {
+			if (modeData === "animation" && lastIdentifier) {
+				const { line: sl, column: sc } = locConverter.get(lastIdentifier[0]);
+				const { line: el, column: ec } = locConverter.get(lastIdentifier[1]);
+				const name = input.slice(lastIdentifier[0], lastIdentifier[1]);
+				const dep = new CssSelfLocalIdentifierDependency(name, lastIdentifier);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+			}
+		};
+		const eatKeyframes = eatUntil("{};/");
+		const eatNameInVar = eatUntil(",)};/");
+		walkCssTokens(source, {
+			isSelector: () => {
+				return mode !== CSS_MODE_IN_RULE && mode !== CSS_MODE_IN_LOCAL_RULE;
+			},
+			url: (input, start, end, contentStart, contentEnd) => {
+				const value = cssUnescape(input.slice(contentStart, contentEnd));
+				switch (mode) {
+					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
+						modeData.url = value;
+						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
+						break;
+					}
+					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
+					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
+						throw new Error(
+							`Unexpected ${input.slice(
+								start,
+								end
+							)} at ${start} during ${explainMode(mode)}`
+						);
+					default: {
+						const dep = new CssUrlDependency(value, [start, end], "url");
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+						module.addCodeGenerationDependency(dep);
+						break;
+					}
+				}
+				return end;
+			},
+			string: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
+						modeData.url = cssUnescape(input.slice(start + 1, end - 1));
+						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
+						break;
+					}
+				}
+				return end;
+			},
+			atKeyword: (input, start, end) => {
+				const name = input.slice(start, end);
+				if (name === "@namespace") {
+					throw new Error("@namespace is not supported in bundled CSS");
+				}
+				if (name === "@import") {
+					if (mode !== CSS_MODE_TOP_LEVEL) {
+						throw new Error(
+							`Unexpected @import at ${start} during ${explainMode(mode)}`
+						);
+					}
+					mode = CSS_MODE_AT_IMPORT_EXPECT_URL;
+					modePos = end;
+					modeData = {
+						start: start,
+						url: undefined,
+						supports: undefined
+					};
+				}
+				if (name === "@keyframes") {
+					let pos = end;
+					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+					if (pos === input.length) return pos;
+					const [newPos, name] = eatText(input, pos, eatKeyframes);
+					const { line: sl, column: sc } = locConverter.get(pos);
+					const { line: el, column: ec } = locConverter.get(newPos);
+					const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
+					dep.setLoc(sl, sc, el, ec);
+					module.addDependency(dep);
+					pos = newPos;
+					if (pos === input.length) return pos;
+					if (input.charCodeAt(pos) !== CC_LEFT_CURLY) {
+						throw new Error(
+							`Unexpected ${input[pos]} at ${pos} during parsing of @keyframes (expected '{')`
+						);
+					}
+					mode = CSS_MODE_IN_LOCAL_RULE;
+					modeNestingLevel = 1;
+					return pos + 1;
+				}
+				return end;
+			},
+			semicolon: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_AT_IMPORT_EXPECT_URL:
+						throw new Error(`Expected URL for @import at ${start}`);
+					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
+					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS: {
+						const { line: sl, column: sc } = locConverter.get(modeData.start);
+						const { line: el, column: ec } = locConverter.get(end);
+						end = eatWhiteLine(input, end);
+						const media = input.slice(modePos, start).trim();
+						const dep = new CssImportDependency(
+							modeData.url,
+							[modeData.start, end],
+							modeData.supports,
+							media
+						);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+						break;
+					}
+					case CSS_MODE_IN_LOCAL_RULE: {
+						processDeclarationValueDone(input, start);
+						return processLocalDeclaration(input, end);
+					}
+					case CSS_MODE_IN_RULE: {
+						return end;
+					}
+				}
+				mode = CSS_MODE_TOP_LEVEL;
+				modeData = undefined;
+				singleClassSelector = undefined;
+				return end;
+			},
+			leftCurlyBracket: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL:
+						mode = isTopLevelLocal()
+							? CSS_MODE_IN_LOCAL_RULE
+							: CSS_MODE_IN_RULE;
+						modeNestingLevel = 1;
+						if (mode === CSS_MODE_IN_LOCAL_RULE)
+							return processLocalDeclaration(input, end);
+						break;
+					case CSS_MODE_IN_RULE:
+					case CSS_MODE_IN_LOCAL_RULE:
+						modeNestingLevel++;
+						break;
+				}
+				return end;
+			},
+			rightCurlyBracket: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_IN_LOCAL_RULE:
+						processDeclarationValueDone(input, start);
+					/* falls through */
+					case CSS_MODE_IN_RULE:
+						if (--modeNestingLevel === 0) {
+							mode = CSS_MODE_TOP_LEVEL;
+							modeData = undefined;
+							singleClassSelector = undefined;
+						}
+						break;
+				}
+				return end;
+			},
+			id: (input, start, end) => {
+				singleClassSelector = false;
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL:
+						if (isTopLevelLocal()) {
+							const name = input.slice(start + 1, end);
+							const dep = new CssLocalIdentifierDependency(name, [
+								start + 1,
+								end
+							]);
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+						}
+						break;
+				}
+				return end;
+			},
+			identifier: (input, start, end) => {
+				singleClassSelector = false;
+				switch (mode) {
+					case CSS_MODE_IN_LOCAL_RULE:
+						if (modeData === "animation") {
+							lastIdentifier = [start, end];
+						}
+						break;
+				}
+				return end;
+			},
+			class: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						if (isTopLevelLocal()) {
+							const name = input.slice(start + 1, end);
+							const dep = new CssLocalIdentifierDependency(name, [
+								start + 1,
+								end
+							]);
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+							if (singleClassSelector === undefined) singleClassSelector = name;
+						} else {
+							singleClassSelector = false;
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			leftParenthesis: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						modeStack.push(false);
+						break;
+					}
+				}
+				return end;
+			},
+			rightParenthesis: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						const newModeData = modeStack.pop();
+						if (newModeData !== false) {
+							modeData = newModeData;
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			pseudoClass: (input, start, end) => {
+				singleClassSelector = false;
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						const name = input.slice(start, end);
+						if (this.allowModeSwitch && name === ":global") {
+							modeData = "global";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else if (this.allowModeSwitch && name === ":local") {
+							modeData = "local";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else if (this.allowPseudoBlocks && name === ":export") {
+							const pos = parseExports(input, end);
+							const dep = new ConstDependency("", [start, pos]);
+							module.addPresentationalDependency(dep);
+							return pos;
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			pseudoFunction: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						const name = input.slice(start, end - 1);
+						if (this.allowModeSwitch && name === ":global") {
+							modeStack.push(modeData);
+							modeData = "global";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else if (this.allowModeSwitch && name === ":local") {
+							modeStack.push(modeData);
+							modeData = "local";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else {
+							modeStack.push(false);
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			function: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_IN_LOCAL_RULE: {
+						const name = input.slice(start, end - 1);
+						if (name === "var") {
+							let pos = walkCssTokens.eatWhitespaceAndComments(input, end);
+							if (pos === input.length) return pos;
+							const [newPos, name] = eatText(input, pos, eatNameInVar);
+							if (!name.startsWith("--")) return end;
+							const { line: sl, column: sc } = locConverter.get(pos);
+							const { line: el, column: ec } = locConverter.get(newPos);
+							const dep = new CssSelfLocalIdentifierDependency(
+								name.slice(2),
+								[pos, newPos],
+								"--",
+								declaredCssVariables
+							);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+							return newPos;
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			comma: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL:
+						modeData = undefined;
+						modeStack.length = 0;
+						break;
+					case CSS_MODE_IN_LOCAL_RULE:
+						processDeclarationValueDone(input, start);
+						break;
+				}
+				return end;
+			}
+		});
 
-ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+		module.buildInfo.strict = true;
+		module.buildMeta.exportsType = "namespace";
+		module.addDependency(new StaticExportsDependency([], true));
+		return state;
+	}
+}
 
-module.exports = ImportContextDependency;
+module.exports = CssParser;
 
 
 /***/ }),
 
-/***/ 89376:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 44124:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -79983,920 +76824,1126 @@ module.exports = ImportContextDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class ImportDependency extends ModuleDependency {
-	/**
-	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
-	 */
-	constructor(request, range, referencedExports) {
-		super(request);
-		this.range = range;
-		this.referencedExports = referencedExports;
-	}
-
-	get type() {
-		return "import()";
-	}
-
-	get category() {
-		return "esm";
-	}
+/**
+ * @typedef {Object} CssTokenCallbacks
+ * @property {function(string, number): boolean} isSelector
+ * @property {function(string, number, number, number, number): number=} url
+ * @property {function(string, number, number): number=} string
+ * @property {function(string, number, number): number=} leftParenthesis
+ * @property {function(string, number, number): number=} rightParenthesis
+ * @property {function(string, number, number): number=} pseudoFunction
+ * @property {function(string, number, number): number=} function
+ * @property {function(string, number, number): number=} pseudoClass
+ * @property {function(string, number, number): number=} atKeyword
+ * @property {function(string, number, number): number=} class
+ * @property {function(string, number, number): number=} identifier
+ * @property {function(string, number, number): number=} id
+ * @property {function(string, number, number): number=} leftCurlyBracket
+ * @property {function(string, number, number): number=} rightCurlyBracket
+ * @property {function(string, number, number): number=} semicolon
+ * @property {function(string, number, number): number=} comma
+ */
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return this.referencedExports
-			? this.referencedExports.map(e => ({
-					name: e,
-					canMangle: false
-			  }))
-			: Dependency.EXPORTS_OBJECT_REFERENCED;
-	}
+/** @typedef {function(string, number, CssTokenCallbacks): number} CharHandler */
 
-	serialize(context) {
-		context.write(this.range);
-		context.write(this.referencedExports);
-		super.serialize(context);
-	}
+// spec: https://drafts.csswg.org/css-syntax/
 
-	deserialize(context) {
-		this.range = context.read();
-		this.referencedExports = context.read();
-		super.deserialize(context);
-	}
-}
+const CC_LINE_FEED = "\n".charCodeAt(0);
+const CC_CARRIAGE_RETURN = "\r".charCodeAt(0);
+const CC_FORM_FEED = "\f".charCodeAt(0);
 
-makeSerializable(ImportDependency, "webpack/lib/dependencies/ImportDependency");
+const CC_TAB = "\t".charCodeAt(0);
+const CC_SPACE = " ".charCodeAt(0);
 
-ImportDependency.Template = class ImportDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ImportDependency} */ (dependency);
-		const block = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dep)
-		);
-		const content = runtimeTemplate.moduleNamespacePromise({
-			chunkGraph,
-			block: block,
-			module: moduleGraph.getModule(dep),
-			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
-			message: "import()",
-			runtimeRequirements
-		});
+const CC_SLASH = "/".charCodeAt(0);
+const CC_BACK_SLASH = "\\".charCodeAt(0);
+const CC_ASTERISK = "*".charCodeAt(0);
 
-		source.replace(dep.range[0], dep.range[1] - 1, content);
-	}
-};
+const CC_LEFT_PARENTHESIS = "(".charCodeAt(0);
+const CC_RIGHT_PARENTHESIS = ")".charCodeAt(0);
+const CC_LEFT_CURLY = "{".charCodeAt(0);
+const CC_RIGHT_CURLY = "}".charCodeAt(0);
 
-module.exports = ImportDependency;
+const CC_QUOTATION_MARK = '"'.charCodeAt(0);
+const CC_APOSTROPHE = "'".charCodeAt(0);
 
+const CC_FULL_STOP = ".".charCodeAt(0);
+const CC_COLON = ":".charCodeAt(0);
+const CC_SEMICOLON = ";".charCodeAt(0);
+const CC_COMMA = ",".charCodeAt(0);
+const CC_PERCENTAGE = "%".charCodeAt(0);
+const CC_AT_SIGN = "@".charCodeAt(0);
 
-/***/ }),
+const CC_LOW_LINE = "_".charCodeAt(0);
+const CC_LOWER_A = "a".charCodeAt(0);
+const CC_LOWER_U = "u".charCodeAt(0);
+const CC_LOWER_E = "e".charCodeAt(0);
+const CC_LOWER_Z = "z".charCodeAt(0);
+const CC_UPPER_A = "A".charCodeAt(0);
+const CC_UPPER_E = "E".charCodeAt(0);
+const CC_UPPER_Z = "Z".charCodeAt(0);
+const CC_0 = "0".charCodeAt(0);
+const CC_9 = "9".charCodeAt(0);
 
-/***/ 50718:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const CC_NUMBER_SIGN = "#".charCodeAt(0);
+const CC_PLUS_SIGN = "+".charCodeAt(0);
+const CC_HYPHEN_MINUS = "-".charCodeAt(0);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
+const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
 
+const _isNewLine = cc => {
+	return (
+		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
+	);
+};
 
+/** @type {CharHandler} */
+const consumeSpace = (input, pos, callbacks) => {
+	let cc;
+	do {
+		pos++;
+		cc = input.charCodeAt(pos);
+	} while (_isWhiteSpace(cc));
+	return pos;
+};
 
-const makeSerializable = __webpack_require__(33032);
-const ImportDependency = __webpack_require__(89376);
+const _isWhiteSpace = cc => {
+	return (
+		cc === CC_LINE_FEED ||
+		cc === CC_CARRIAGE_RETURN ||
+		cc === CC_FORM_FEED ||
+		cc === CC_TAB ||
+		cc === CC_SPACE
+	);
+};
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @type {CharHandler} */
+const consumeSingleCharToken = (input, pos, callbacks) => {
+	return pos + 1;
+};
 
-class ImportEagerDependency extends ImportDependency {
-	/**
-	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
-	 */
-	constructor(request, range, referencedExports) {
-		super(request, range, referencedExports);
+/** @type {CharHandler} */
+const consumePotentialComment = (input, pos, callbacks) => {
+	pos++;
+	if (pos === input.length) return pos;
+	let cc = input.charCodeAt(pos);
+	if (cc !== CC_ASTERISK) return pos;
+	for (;;) {
+		pos++;
+		if (pos === input.length) return pos;
+		cc = input.charCodeAt(pos);
+		while (cc === CC_ASTERISK) {
+			pos++;
+			if (pos === input.length) return pos;
+			cc = input.charCodeAt(pos);
+			if (cc === CC_SLASH) return pos + 1;
+		}
 	}
+};
 
-	get type() {
-		return "import() eager";
+/** @type {function(number): CharHandler} */
+const consumeString = end => (input, pos, callbacks) => {
+	const start = pos;
+	pos = _consumeString(input, pos, end);
+	if (callbacks.string !== undefined) {
+		pos = callbacks.string(input, start, pos);
 	}
+	return pos;
+};
 
-	get category() {
-		return "esm";
+const _consumeString = (input, pos, end) => {
+	pos++;
+	for (;;) {
+		if (pos === input.length) return pos;
+		const cc = input.charCodeAt(pos);
+		if (cc === end) return pos + 1;
+		if (_isNewLine(cc)) {
+			// bad string
+			return pos;
+		}
+		if (cc === CC_BACK_SLASH) {
+			// we don't need to fully parse the escaped code point
+			// just skip over a potential new line
+			pos++;
+			if (pos === input.length) return pos;
+			pos++;
+		} else {
+			pos++;
+		}
 	}
-}
+};
 
-makeSerializable(
-	ImportEagerDependency,
-	"webpack/lib/dependencies/ImportEagerDependency"
-);
+const _isIdentifierStartCode = cc => {
+	return (
+		cc === CC_LOW_LINE ||
+		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
+		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
+		cc > 0x80
+	);
+};
 
-ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
-	ImportDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ImportEagerDependency} */ (dependency);
-		const content = runtimeTemplate.moduleNamespacePromise({
-			chunkGraph,
-			module: moduleGraph.getModule(dep),
-			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
-			message: "import() eager",
-			runtimeRequirements
-		});
+const _isDigit = cc => {
+	return cc >= CC_0 && cc <= CC_9;
+};
 
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+const _startsIdentifier = (input, pos) => {
+	const cc = input.charCodeAt(pos);
+	if (cc === CC_HYPHEN_MINUS) {
+		if (pos === input.length) return false;
+		const cc = input.charCodeAt(pos + 1);
+		if (cc === CC_HYPHEN_MINUS) return true;
+		if (cc === CC_BACK_SLASH) {
+			const cc = input.charCodeAt(pos + 2);
+			return !_isNewLine(cc);
+		}
+		return _isIdentifierStartCode(cc);
+	}
+	if (cc === CC_BACK_SLASH) {
+		const cc = input.charCodeAt(pos + 1);
+		return !_isNewLine(cc);
 	}
+	return _isIdentifierStartCode(cc);
 };
 
-module.exports = ImportEagerDependency;
-
+/** @type {CharHandler} */
+const consumeNumberSign = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.id !== undefined) {
+			return callbacks.id(input, start, pos);
+		}
+	}
+	return pos;
+};
 
-/***/ }),
+/** @type {CharHandler} */
+const consumeMinus = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	const cc = input.charCodeAt(pos);
+	if (cc === CC_FULL_STOP || _isDigit(cc)) {
+		return consumeNumericToken(input, pos, callbacks);
+	} else if (cc === CC_HYPHEN_MINUS) {
+		pos++;
+		if (pos === input.length) return pos;
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_GREATER_THAN_SIGN) {
+			return pos + 1;
+		} else {
+			pos = _consumeIdentifier(input, pos);
+			if (callbacks.identifier !== undefined) {
+				return callbacks.identifier(input, start, pos);
+			}
+		}
+	} else if (cc === CC_BACK_SLASH) {
+		if (pos + 1 === input.length) return pos;
+		const cc = input.charCodeAt(pos + 1);
+		if (_isNewLine(cc)) return pos;
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
+		}
+	} else if (_isIdentifierStartCode(cc)) {
+		pos++;
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
+		}
+	}
+	return pos;
+};
 
-/***/ 51274:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/** @type {CharHandler} */
+const consumeDot = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	const cc = input.charCodeAt(pos);
+	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
+	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
+		return pos;
+	pos = _consumeIdentifier(input, pos);
+	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
+	return pos;
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+/** @type {CharHandler} */
+const consumeNumericToken = (input, pos, callbacks) => {
+	pos = _consumeNumber(input, pos);
+	if (pos === input.length) return pos;
+	if (_startsIdentifier(input, pos)) return _consumeIdentifier(input, pos);
+	const cc = input.charCodeAt(pos);
+	if (cc === CC_PERCENTAGE) return pos + 1;
+	return pos;
+};
 
+/** @type {CharHandler} */
+const consumeOtherIdentifier = (input, pos, callbacks) => {
+	const start = pos;
+	pos = _consumeIdentifier(input, pos);
+	if (
+		pos !== input.length &&
+		!callbacks.isSelector(input, pos) &&
+		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
+	) {
+		pos++;
+		if (callbacks.function !== undefined) {
+			return callbacks.function(input, start, pos);
+		}
+	} else {
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
+		}
+	}
+	return pos;
+};
 
+/** @type {CharHandler} */
+const consumePotentialUrl = (input, pos, callbacks) => {
+	const start = pos;
+	pos = _consumeIdentifier(input, pos);
+	if (pos === start + 3 && input.slice(start, pos + 1) === "url(") {
+		pos++;
+		let cc = input.charCodeAt(pos);
+		while (_isWhiteSpace(cc)) {
+			pos++;
+			if (pos === input.length) return pos;
+			cc = input.charCodeAt(pos);
+		}
+		if (cc === CC_QUOTATION_MARK || cc === CC_APOSTROPHE) {
+			pos++;
+			const contentStart = pos;
+			pos = _consumeString(input, pos, cc);
+			const contentEnd = pos - 1;
+			cc = input.charCodeAt(pos);
+			while (_isWhiteSpace(cc)) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+			}
+			if (cc !== CC_RIGHT_PARENTHESIS) return pos;
+			pos++;
+			if (callbacks.url !== undefined)
+				return callbacks.url(input, start, pos, contentStart, contentEnd);
+			return pos;
+		} else {
+			const contentStart = pos;
+			let contentEnd;
+			for (;;) {
+				if (cc === CC_BACK_SLASH) {
+					pos++;
+					if (pos === input.length) return pos;
+					pos++;
+				} else if (_isWhiteSpace(cc)) {
+					contentEnd = pos;
+					do {
+						pos++;
+						if (pos === input.length) return pos;
+						cc = input.charCodeAt(pos);
+					} while (_isWhiteSpace(cc));
+					if (cc !== CC_RIGHT_PARENTHESIS) return pos;
+					pos++;
+					if (callbacks.url !== undefined) {
+						return callbacks.url(input, start, pos, contentStart, contentEnd);
+					}
+					return pos;
+				} else if (cc === CC_RIGHT_PARENTHESIS) {
+					contentEnd = pos;
+					pos++;
+					if (callbacks.url !== undefined) {
+						return callbacks.url(input, start, pos, contentStart, contentEnd);
+					}
+					return pos;
+				} else if (cc === CC_LEFT_PARENTHESIS) {
+					return pos;
+				} else {
+					pos++;
+				}
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+			}
+		}
+	} else {
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
+		}
+		return pos;
+	}
+};
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+/** @type {CharHandler} */
+const consumePotentialPseudo = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
+		return pos;
+	pos = _consumeIdentifier(input, pos);
+	let cc = input.charCodeAt(pos);
+	if (cc === CC_LEFT_PARENTHESIS) {
+		pos++;
+		if (callbacks.pseudoFunction !== undefined) {
+			return callbacks.pseudoFunction(input, start, pos);
+		}
+		return pos;
+	}
+	if (callbacks.pseudoClass !== undefined) {
+		return callbacks.pseudoClass(input, start, pos);
+	}
+	return pos;
+};
 
-class ImportMetaHotAcceptDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-		this.range = range;
-		this.weak = true;
+/** @type {CharHandler} */
+const consumeLeftParenthesis = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.leftParenthesis !== undefined) {
+		return callbacks.leftParenthesis(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	get type() {
-		return "import.meta.webpackHot.accept";
+/** @type {CharHandler} */
+const consumeRightParenthesis = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.rightParenthesis !== undefined) {
+		return callbacks.rightParenthesis(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	get category() {
-		return "esm";
+/** @type {CharHandler} */
+const consumeLeftCurlyBracket = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.leftCurlyBracket !== undefined) {
+		return callbacks.leftCurlyBracket(input, pos - 1, pos);
 	}
-}
-
-makeSerializable(
-	ImportMetaHotAcceptDependency,
-	"webpack/lib/dependencies/ImportMetaHotAcceptDependency"
-);
-
-ImportMetaHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
-
-module.exports = ImportMetaHotAcceptDependency;
-
-
-/***/ }),
-
-/***/ 53141:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
-
-class ImportMetaHotDeclineDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+	return pos;
+};
 
-		this.range = range;
-		this.weak = true;
+/** @type {CharHandler} */
+const consumeRightCurlyBracket = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.rightCurlyBracket !== undefined) {
+		return callbacks.rightCurlyBracket(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	get type() {
-		return "import.meta.webpackHot.decline";
+/** @type {CharHandler} */
+const consumeSemicolon = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.semicolon !== undefined) {
+		return callbacks.semicolon(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	get category() {
-		return "esm";
+/** @type {CharHandler} */
+const consumeComma = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.comma !== undefined) {
+		return callbacks.comma(input, pos - 1, pos);
 	}
-}
-
-makeSerializable(
-	ImportMetaHotDeclineDependency,
-	"webpack/lib/dependencies/ImportMetaHotDeclineDependency"
-);
-
-ImportMetaHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
-
-module.exports = ImportMetaHotDeclineDependency;
-
-
-/***/ }),
-
-/***/ 17228:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+	return pos;
+};
 
+const _consumeIdentifier = (input, pos) => {
+	for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_BACK_SLASH) {
+			pos++;
+			if (pos === input.length) return pos;
+			pos++;
+		} else if (
+			_isIdentifierStartCode(cc) ||
+			_isDigit(cc) ||
+			cc === CC_HYPHEN_MINUS
+		) {
+			pos++;
+		} else {
+			return pos;
+		}
+	}
+};
 
+const _consumeNumber = (input, pos) => {
+	pos++;
+	if (pos === input.length) return pos;
+	let cc = input.charCodeAt(pos);
+	while (_isDigit(cc)) {
+		pos++;
+		if (pos === input.length) return pos;
+		cc = input.charCodeAt(pos);
+	}
+	if (cc === CC_FULL_STOP && pos + 1 !== input.length) {
+		const next = input.charCodeAt(pos + 1);
+		if (_isDigit(next)) {
+			pos += 2;
+			cc = input.charCodeAt(pos);
+			while (_isDigit(cc)) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+			}
+		}
+	}
+	if (cc === CC_LOWER_E || cc === CC_UPPER_E) {
+		if (pos + 1 !== input.length) {
+			const next = input.charCodeAt(pos + 2);
+			if (_isDigit(next)) {
+				pos += 2;
+			} else if (
+				(next === CC_HYPHEN_MINUS || next === CC_PLUS_SIGN) &&
+				pos + 2 !== input.length
+			) {
+				const next = input.charCodeAt(pos + 2);
+				if (_isDigit(next)) {
+					pos += 3;
+				} else {
+					return pos;
+				}
+			} else {
+				return pos;
+			}
+		}
+	} else {
+		return pos;
+	}
+	cc = input.charCodeAt(pos);
+	while (_isDigit(cc)) {
+		pos++;
+		if (pos === input.length) return pos;
+		cc = input.charCodeAt(pos);
+	}
+	return pos;
+};
 
-const { pathToFileURL } = __webpack_require__(57310);
-const ModuleDependencyWarning = __webpack_require__(29656);
-const Template = __webpack_require__(1626);
-const BasicEvaluatedExpression = __webpack_require__(950);
-const {
-	evaluateToIdentifier,
-	toConstantDependency,
-	evaluateToString,
-	evaluateToNumber
-} = __webpack_require__(93998);
-const memoize = __webpack_require__(78676);
-const propertyAccess = __webpack_require__(54190);
-const ConstDependency = __webpack_require__(76911);
+/** @type {CharHandler} */
+const consumeLessThan = (input, pos, callbacks) => {
+	if (input.slice(pos + 1, pos + 4) === "!--") return pos + 4;
+	return pos + 1;
+};
 
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @type {CharHandler} */
+const consumeAt = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	if (_startsIdentifier(input, pos)) {
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.atKeyword !== undefined) {
+			pos = callbacks.atKeyword(input, start, pos);
+		}
+	}
+	return pos;
+};
 
-const getCriticalDependencyWarning = memoize(() =>
-	__webpack_require__(15427)
-);
+const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
+	// https://drafts.csswg.org/css-syntax/#consume-token
+	switch (cc) {
+		case CC_LINE_FEED:
+		case CC_CARRIAGE_RETURN:
+		case CC_FORM_FEED:
+		case CC_TAB:
+		case CC_SPACE:
+			return consumeSpace;
+		case CC_QUOTATION_MARK:
+		case CC_APOSTROPHE:
+			return consumeString(cc);
+		case CC_NUMBER_SIGN:
+			return consumeNumberSign;
+		case CC_SLASH:
+			return consumePotentialComment;
+		// case CC_LEFT_SQUARE:
+		// case CC_RIGHT_SQUARE:
+		// case CC_COMMA:
+		// case CC_COLON:
+		// 	return consumeSingleCharToken;
+		case CC_COMMA:
+			return consumeComma;
+		case CC_SEMICOLON:
+			return consumeSemicolon;
+		case CC_LEFT_PARENTHESIS:
+			return consumeLeftParenthesis;
+		case CC_RIGHT_PARENTHESIS:
+			return consumeRightParenthesis;
+		case CC_LEFT_CURLY:
+			return consumeLeftCurlyBracket;
+		case CC_RIGHT_CURLY:
+			return consumeRightCurlyBracket;
+		case CC_COLON:
+			return consumePotentialPseudo;
+		case CC_PLUS_SIGN:
+			return consumeNumericToken;
+		case CC_FULL_STOP:
+			return consumeDot;
+		case CC_HYPHEN_MINUS:
+			return consumeMinus;
+		case CC_LESS_THAN_SIGN:
+			return consumeLessThan;
+		case CC_AT_SIGN:
+			return consumeAt;
+		case CC_LOWER_U:
+			return consumePotentialUrl;
+		case CC_LOW_LINE:
+			return consumeOtherIdentifier;
+		default:
+			if (_isDigit(cc)) return consumeNumericToken;
+			if (
+				(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
+				(cc >= CC_UPPER_A && cc <= CC_UPPER_Z)
+			) {
+				return consumeOtherIdentifier;
+			}
+			return consumeSingleCharToken;
+	}
+});
 
-class ImportMetaPlugin {
-	/**
-	 * @param {Compiler} compiler compiler
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ImportMetaPlugin",
-			(compilation, { normalModuleFactory }) => {
-				/**
-				 * @param {NormalModule} module module
-				 * @returns {string} file url
-				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource).toString();
-				};
-				/**
-				 * @param {Parser} parser parser parser
-				 * @param {JavascriptParserOptions} parserOptions parserOptions
-				 * @returns {void}
-				 */
-				const parserHandler = (parser, { importMeta }) => {
-					if (importMeta === false) {
-						const { importMetaName } = compilation.outputOptions;
-						if (importMetaName === "import.meta") return;
+/**
+ * @param {string} input input css
+ * @param {CssTokenCallbacks} callbacks callbacks
+ * @returns {void}
+ */
+module.exports = (input, callbacks) => {
+	let pos = 0;
+	while (pos < input.length) {
+		const cc = input.charCodeAt(pos);
+		if (cc < 0x80) {
+			pos = CHAR_MAP[cc](input, pos, callbacks);
+		} else {
+			pos++;
+		}
+	}
+};
 
-						parser.hooks.expression
-							.for("import.meta")
-							.tap("ImportMetaPlugin", metaProperty => {
-								const dep = new ConstDependency(
-									importMetaName,
-									metaProperty.range
-								);
-								dep.loc = metaProperty.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								return true;
-							});
-						return;
+module.exports.eatComments = (input, pos) => {
+	loop: for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_SLASH) {
+			if (pos === input.length) return pos;
+			let cc = input.charCodeAt(pos + 1);
+			if (cc !== CC_ASTERISK) return pos;
+			pos++;
+			for (;;) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+				while (cc === CC_ASTERISK) {
+					pos++;
+					if (pos === input.length) return pos;
+					cc = input.charCodeAt(pos);
+					if (cc === CC_SLASH) {
+						pos++;
+						continue loop;
 					}
-
-					/// import.meta direct ///
-					parser.hooks.typeof
-						.for("import.meta")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-					parser.hooks.expression
-						.for("import.meta")
-						.tap("ImportMetaPlugin", metaProperty => {
-							const CriticalDependencyWarning = getCriticalDependencyWarning();
-							parser.state.module.addWarning(
-								new ModuleDependencyWarning(
-									parser.state.module,
-									new CriticalDependencyWarning(
-										"Accessing import.meta directly is unsupported (only property access is supported)"
-									),
-									metaProperty.loc
-								)
-							);
-							const dep = new ConstDependency(
-								`${parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""}({})`,
-								metaProperty.range
-							);
-							dep.loc = metaProperty.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for("import.meta")
-						.tap("ImportMetaPlugin", evaluateToString("object"));
-					parser.hooks.evaluateIdentifier.for("import.meta").tap(
-						"ImportMetaPlugin",
-						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
-					);
-
-					/// import.meta.url ///
-					parser.hooks.typeof
-						.for("import.meta.url")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify("string"))
-						);
-					parser.hooks.expression
-						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
-							const dep = new ConstDependency(
-								JSON.stringify(getUrl(parser.state.module)),
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for("import.meta.url")
-						.tap("ImportMetaPlugin", evaluateToString("string"));
-					parser.hooks.evaluateIdentifier
-						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
-							return new BasicEvaluatedExpression()
-								.setString(getUrl(parser.state.module))
-								.setRange(expr.range);
-						});
-
-					/// import.meta.webpack ///
-					const webpackVersion = parseInt(
-						(__webpack_require__(32702)/* .version */ .i8),
-						10
-					);
-					parser.hooks.typeof
-						.for("import.meta.webpack")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify("number"))
-						);
-					parser.hooks.expression
-						.for("import.meta.webpack")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify(webpackVersion))
-						);
-					parser.hooks.evaluateTypeof
-						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToString("number"));
-					parser.hooks.evaluateIdentifier
-						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToNumber(webpackVersion));
-
-					/// Unknown properties ///
-					parser.hooks.unhandledExpressionMemberChain
-						.for("import.meta")
-						.tap("ImportMetaPlugin", (expr, members) => {
-							const dep = new ConstDependency(
-								`${Template.toNormalComment(
-									"unsupported import.meta." + members.join(".")
-								)} undefined${propertyAccess(members, 1)}`,
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluate
-						.for("MemberExpression")
-						.tap("ImportMetaPlugin", expression => {
-							const expr = /** @type {MemberExpression} */ (expression);
-							if (
-								expr.object.type === "MetaProperty" &&
-								expr.object.meta.name === "import" &&
-								expr.object.property.name === "meta" &&
-								expr.property.type ===
-									(expr.computed ? "Literal" : "Identifier")
-							) {
-								return new BasicEvaluatedExpression()
-									.setUndefined()
-									.setRange(expr.range);
-							}
-						});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportMetaPlugin", parserHandler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportMetaPlugin", parserHandler);
+				}
 			}
-		);
+		}
+		return pos;
 	}
-}
+};
 
-module.exports = ImportMetaPlugin;
+module.exports.eatWhitespaceAndComments = (input, pos) => {
+	loop: for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_SLASH) {
+			if (pos === input.length) return pos;
+			let cc = input.charCodeAt(pos + 1);
+			if (cc !== CC_ASTERISK) return pos;
+			pos++;
+			for (;;) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+				while (cc === CC_ASTERISK) {
+					pos++;
+					if (pos === input.length) return pos;
+					cc = input.charCodeAt(pos);
+					if (cc === CC_SLASH) {
+						pos++;
+						continue loop;
+					}
+				}
+			}
+		} else if (_isWhiteSpace(cc)) {
+			pos++;
+			continue;
+		}
+		return pos;
+	}
+};
 
 
 /***/ }),
 
-/***/ 88130:
+/***/ 2757:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const CommentCompilationWarning = __webpack_require__(98427);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const ImportContextDependency = __webpack_require__(1902);
-const ImportDependency = __webpack_require__(89376);
-const ImportEagerDependency = __webpack_require__(50718);
-const ImportWeakDependency = __webpack_require__(82483);
+const { Tracer } = __webpack_require__(5787);
+const createSchemaValidation = __webpack_require__(32540);
+const { dirname, mkdirpSync } = __webpack_require__(17139);
+
+/** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+
+const validate = createSchemaValidation(
+	__webpack_require__(37134),
+	() => __webpack_require__(50686),
+	{
+		name: "Profiling Plugin",
+		baseDataPath: "options"
+	}
+);
+let inspector = undefined;
+
+try {
+	// eslint-disable-next-line node/no-unsupported-features/node-builtins
+	inspector = __webpack_require__(31405);
+} catch (e) {
+	console.log("Unable to CPU profile in < node 8.0");
+}
 
-/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
-/** @typedef {import("../ContextModule").ContextMode} ContextMode */
+class Profiler {
+	constructor(inspector) {
+		this.session = undefined;
+		this.inspector = inspector;
+		this._startTime = 0;
+	}
 
-class ImportParserPlugin {
-	constructor(options) {
-		this.options = options;
+	hasSession() {
+		return this.session !== undefined;
 	}
 
-	apply(parser) {
-		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
-			const param = parser.evaluateExpression(expr.source);
+	startProfiling() {
+		if (this.inspector === undefined) {
+			return Promise.resolve();
+		}
 
-			let chunkName = null;
-			/** @type {ContextMode} */
-			let mode = "lazy";
-			let include = null;
-			let exclude = null;
-			/** @type {string[][] | null} */
-			let exports = null;
-			/** @type {RawChunkGroupOptions} */
-			const groupOptions = {};
+		try {
+			this.session = new inspector.Session();
+			this.session.connect();
+		} catch (_) {
+			this.session = undefined;
+			return Promise.resolve();
+		}
 
-			const { options: importOptions, errors: commentErrors } =
-				parser.parseCommentOptions(expr.range);
+		const hrtime = process.hrtime();
+		this._startTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
 
-			if (commentErrors) {
-				for (const e of commentErrors) {
-					const { comment } = e;
-					parser.state.module.addWarning(
-						new CommentCompilationWarning(
-							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							comment.loc
-						)
-					);
-				}
-			}
+		return Promise.all([
+			this.sendCommand("Profiler.setSamplingInterval", {
+				interval: 100
+			}),
+			this.sendCommand("Profiler.enable"),
+			this.sendCommand("Profiler.start")
+		]);
+	}
 
-			if (importOptions) {
-				if (importOptions.webpackIgnore !== undefined) {
-					if (typeof importOptions.webpackIgnore !== "boolean") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								expr.loc
-							)
-						);
-					} else {
-						// Do not instrument `import()` if `webpackIgnore` is `true`
-						if (importOptions.webpackIgnore) {
-							return false;
-						}
-					}
-				}
-				if (importOptions.webpackChunkName !== undefined) {
-					if (typeof importOptions.webpackChunkName !== "string") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								expr.loc
-							)
-						);
-					} else {
-						chunkName = importOptions.webpackChunkName;
-					}
-				}
-				if (importOptions.webpackMode !== undefined) {
-					if (typeof importOptions.webpackMode !== "string") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								expr.loc
-							)
-						);
-					} else {
-						mode = importOptions.webpackMode;
-					}
-				}
-				if (importOptions.webpackPrefetch !== undefined) {
-					if (importOptions.webpackPrefetch === true) {
-						groupOptions.prefetchOrder = 0;
-					} else if (typeof importOptions.webpackPrefetch === "number") {
-						groupOptions.prefetchOrder = importOptions.webpackPrefetch;
-					} else {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								expr.loc
-							)
-						);
-					}
-				}
-				if (importOptions.webpackPreload !== undefined) {
-					if (importOptions.webpackPreload === true) {
-						groupOptions.preloadOrder = 0;
-					} else if (typeof importOptions.webpackPreload === "number") {
-						groupOptions.preloadOrder = importOptions.webpackPreload;
-					} else {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								expr.loc
-							)
-						);
-					}
-				}
-				if (importOptions.webpackInclude !== undefined) {
-					if (
-						!importOptions.webpackInclude ||
-						importOptions.webpackInclude.constructor.name !== "RegExp"
-					) {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								expr.loc
-							)
-						);
-					} else {
-						include = new RegExp(importOptions.webpackInclude);
-					}
-				}
-				if (importOptions.webpackExclude !== undefined) {
-					if (
-						!importOptions.webpackExclude ||
-						importOptions.webpackExclude.constructor.name !== "RegExp"
-					) {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								expr.loc
-							)
-						);
-					} else {
-						exclude = new RegExp(importOptions.webpackExclude);
-					}
-				}
-				if (importOptions.webpackExports !== undefined) {
-					if (
-						!(
-							typeof importOptions.webpackExports === "string" ||
-							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
-									item => typeof item === "string"
-								))
-						)
-					) {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								expr.loc
-							)
-						);
+	sendCommand(method, params) {
+		if (this.hasSession()) {
+			return new Promise((res, rej) => {
+				return this.session.post(method, params, (err, params) => {
+					if (err !== null) {
+						rej(err);
 					} else {
-						if (typeof importOptions.webpackExports === "string") {
-							exports = [[importOptions.webpackExports]];
-						} else {
-							exports = Array.from(importOptions.webpackExports, e => [e]);
-						}
+						res(params);
 					}
-				}
-			}
+				});
+			});
+		} else {
+			return Promise.resolve();
+		}
+	}
 
-			if (param.isString()) {
-				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-				}
+	destroy() {
+		if (this.hasSession()) {
+			this.session.disconnect();
+		}
 
-				if (mode === "eager") {
-					const dep = new ImportEagerDependency(
-						param.string,
-						expr.range,
-						exports
-					);
-					parser.state.current.addDependency(dep);
-				} else if (mode === "weak") {
-					const dep = new ImportWeakDependency(
-						param.string,
-						expr.range,
-						exports
-					);
-					parser.state.current.addDependency(dep);
-				} else {
-					const depBlock = new AsyncDependenciesBlock(
-						{
-							...groupOptions,
-							name: chunkName
-						},
-						expr.loc,
-						param.string
-					);
-					const dep = new ImportDependency(param.string, expr.range, exports);
-					dep.loc = expr.loc;
-					depBlock.addDependency(dep);
-					parser.state.current.addBlock(depBlock);
-				}
-				return true;
-			} else {
-				if (
-					mode !== "lazy" &&
-					mode !== "lazy-once" &&
-					mode !== "eager" &&
-					mode !== "weak"
-				) {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-					mode = "lazy";
-				}
+		return Promise.resolve();
+	}
 
-				if (mode === "weak") {
-					mode = "async-weak";
-				}
-				const dep = ContextDependencyHelpers.create(
-					ImportContextDependency,
-					expr.range,
-					param,
-					expr,
-					this.options,
-					{
-						chunkName,
-						groupOptions,
-						include,
-						exclude,
-						mode,
-						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
-							? "strict"
-							: true,
-						typePrefix: "import()",
-						category: "esm",
-						referencedExports: exports
-					},
-					parser
-				);
-				if (!dep) return;
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
+	stopProfiling() {
+		return this.sendCommand("Profiler.stop").then(({ profile }) => {
+			const hrtime = process.hrtime();
+			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+			if (profile.startTime < this._startTime || profile.endTime > endTime) {
+				// In some cases timestamps mismatch and we need to adjust them
+				// Both process.hrtime and the inspector timestamps claim to be relative
+				// to a unknown point in time. But they do not guarantee that this is the
+				// same point in time.
+				const duration = profile.endTime - profile.startTime;
+				const ownDuration = endTime - this._startTime;
+				const untracked = Math.max(0, ownDuration - duration);
+				profile.startTime = this._startTime + untracked / 2;
+				profile.endTime = endTime - untracked / 2;
 			}
+			return { profile };
 		});
 	}
 }
 
-module.exports = ImportParserPlugin;
-
-
-/***/ }),
+/**
+ * an object that wraps Tracer and Profiler with a counter
+ * @typedef {Object} Trace
+ * @property {Tracer} trace instance of Tracer
+ * @property {number} counter Counter
+ * @property {Profiler} profiler instance of Profiler
+ * @property {Function} end the end function
+ */
 
-/***/ 41293:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {IntermediateFileSystem} fs filesystem used for output
+ * @param {string} outputPath The location where to write the log.
+ * @returns {Trace} The trace object
+ */
+const createTrace = (fs, outputPath) => {
+	const trace = new Tracer();
+	const profiler = new Profiler(inspector);
+	if (/\/|\\/.test(outputPath)) {
+		const dirPath = dirname(fs, outputPath);
+		mkdirpSync(fs, dirPath);
+	}
+	const fsStream = fs.createWriteStream(outputPath);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	let counter = 0;
 
+	trace.pipe(fsStream);
+	// These are critical events that need to be inserted so that tools like
+	// chrome dev tools can load the profile.
+	trace.instantEvent({
+		name: "TracingStartedInPage",
+		id: ++counter,
+		cat: ["disabled-by-default-devtools.timeline"],
+		args: {
+			data: {
+				sessionId: "-1",
+				page: "0xfff",
+				frames: [
+					{
+						frame: "0xfff",
+						url: "webpack",
+						name: ""
+					}
+				]
+			}
+		}
+	});
 
+	trace.instantEvent({
+		name: "TracingStartedInBrowser",
+		id: ++counter,
+		cat: ["disabled-by-default-devtools.timeline"],
+		args: {
+			data: {
+				sessionId: "-1"
+			}
+		}
+	});
 
-const ImportContextDependency = __webpack_require__(1902);
-const ImportDependency = __webpack_require__(89376);
-const ImportEagerDependency = __webpack_require__(50718);
-const ImportParserPlugin = __webpack_require__(88130);
-const ImportWeakDependency = __webpack_require__(82483);
+	return {
+		trace,
+		counter,
+		profiler,
+		end: callback => {
+			trace.push("]");
+			// Wait until the write stream finishes.
+			fsStream.on("close", () => {
+				callback();
+			});
+			// Tear down the readable trace stream.
+			trace.push(null);
+		}
+	};
+};
 
-/** @typedef {import("../Compiler")} Compiler */
+const pluginName = "ProfilingPlugin";
 
-class ImportPlugin {
+class ProfilingPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {ProfilingPluginOptions=} options options object
 	 */
+	constructor(options = {}) {
+		validate(options);
+		this.outputPath = options.outputPath || "events.json";
+	}
+
 	apply(compiler) {
+		const tracer = createTrace(
+			compiler.intermediateFileSystem,
+			this.outputPath
+		);
+		tracer.profiler.startProfiling();
+
+		// Compiler Hooks
+		Object.keys(compiler.hooks).forEach(hookName => {
+			const hook = compiler.hooks[hookName];
+			if (hook) {
+				hook.intercept(makeInterceptorFor("Compiler", tracer)(hookName));
+			}
+		});
+
+		Object.keys(compiler.resolverFactory.hooks).forEach(hookName => {
+			const hook = compiler.resolverFactory.hooks[hookName];
+			if (hook) {
+				hook.intercept(makeInterceptorFor("Resolver", tracer)(hookName));
+			}
+		});
+
 		compiler.hooks.compilation.tap(
-			"ImportPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ImportDependency,
-					normalModuleFactory
+			pluginName,
+			(compilation, { normalModuleFactory, contextModuleFactory }) => {
+				interceptAllHooksFor(compilation, tracer, "Compilation");
+				interceptAllHooksFor(
+					normalModuleFactory,
+					tracer,
+					"Normal Module Factory"
 				);
-				compilation.dependencyTemplates.set(
-					ImportDependency,
-					new ImportDependency.Template()
+				interceptAllHooksFor(
+					contextModuleFactory,
+					tracer,
+					"Context Module Factory"
 				);
+				interceptAllParserHooks(normalModuleFactory, tracer);
+				interceptAllJavascriptModulesPluginHooks(compilation, tracer);
+			}
+		);
 
-				compilation.dependencyFactories.set(
-					ImportEagerDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportEagerDependency,
-					new ImportEagerDependency.Template()
-				);
+		// We need to write out the CPU profile when we are all done.
+		compiler.hooks.done.tapAsync(
+			{
+				name: pluginName,
+				stage: Infinity
+			},
+			(stats, callback) => {
+				if (compiler.watchMode) return callback();
+				tracer.profiler.stopProfiling().then(parsedResults => {
+					if (parsedResults === undefined) {
+						tracer.profiler.destroy();
+						tracer.end(callback);
+						return;
+					}
 
-				compilation.dependencyFactories.set(
-					ImportWeakDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportWeakDependency,
-					new ImportWeakDependency.Template()
-				);
+					const cpuStartTime = parsedResults.profile.startTime;
+					const cpuEndTime = parsedResults.profile.endTime;
 
-				compilation.dependencyFactories.set(
-					ImportContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportContextDependency,
-					new ImportContextDependency.Template()
-				);
+					tracer.trace.completeEvent({
+						name: "TaskQueueManager::ProcessTaskFromWorkQueue",
+						id: ++tracer.counter,
+						cat: ["toplevel"],
+						ts: cpuStartTime,
+						args: {
+							src_file: "../../ipc/ipc_moji_bootstrap.cc",
+							src_func: "Accept"
+						}
+					});
 
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.import !== undefined && !parserOptions.import)
-						return;
+					tracer.trace.completeEvent({
+						name: "EvaluateScript",
+						id: ++tracer.counter,
+						cat: ["devtools.timeline"],
+						ts: cpuStartTime,
+						dur: cpuEndTime - cpuStartTime,
+						args: {
+							data: {
+								url: "webpack",
+								lineNumber: 1,
+								columnNumber: 1,
+								frame: "0xFFF"
+							}
+						}
+					});
 
-					new ImportParserPlugin(parserOptions).apply(parser);
-				};
+					tracer.trace.instantEvent({
+						name: "CpuProfile",
+						id: ++tracer.counter,
+						cat: ["disabled-by-default-devtools.timeline"],
+						ts: cpuEndTime,
+						args: {
+							data: {
+								cpuProfile: parsedResults.profile
+							}
+						}
+					});
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ImportPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportPlugin", handler);
+					tracer.profiler.destroy();
+					tracer.end(callback);
+				});
 			}
 		);
 	}
 }
-module.exports = ImportPlugin;
-
-
-/***/ }),
-
-/***/ 82483:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+const interceptAllHooksFor = (instance, tracer, logLabel) => {
+	if (Reflect.has(instance, "hooks")) {
+		Object.keys(instance.hooks).forEach(hookName => {
+			const hook = instance.hooks[hookName];
+			if (hook && !hook._fakeHook) {
+				hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
+			}
+		});
+	}
+};
 
+const interceptAllParserHooks = (moduleFactory, tracer) => {
+	const moduleTypes = [
+		"javascript/auto",
+		"javascript/dynamic",
+		"javascript/esm",
+		"json",
+		"webassembly/async",
+		"webassembly/sync"
+	];
 
-const makeSerializable = __webpack_require__(33032);
-const ImportDependency = __webpack_require__(89376);
+	moduleTypes.forEach(moduleType => {
+		moduleFactory.hooks.parser
+			.for(moduleType)
+			.tap("ProfilingPlugin", (parser, parserOpts) => {
+				interceptAllHooksFor(parser, tracer, "Parser");
+			});
+	});
+};
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
+	interceptAllHooksFor(
+		{
+			hooks:
+				(__webpack_require__(89464).getCompilationHooks)(
+					compilation
+				)
+		},
+		tracer,
+		"JavascriptModulesPlugin"
+	);
+};
 
-class ImportWeakDependency extends ImportDependency {
-	/**
-	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
-	 */
-	constructor(request, range, referencedExports) {
-		super(request, range, referencedExports);
-		this.weak = true;
+const makeInterceptorFor = (instance, tracer) => hookName => ({
+	register: ({ name, type, context, fn }) => {
+		const newFn =
+			// Don't tap our own hooks to ensure stream can close cleanly
+			name === pluginName
+				? fn
+				: makeNewProfiledTapFn(hookName, tracer, {
+						name,
+						type,
+						fn
+				  });
+		return {
+			name,
+			type,
+			context,
+			fn: newFn
+		};
 	}
+});
 
-	get type() {
-		return "import() weak";
-	}
-}
+// TODO improve typing
+/** @typedef {(...args: TODO[]) => void | Promise<TODO>} PluginFunction */
 
-makeSerializable(
-	ImportWeakDependency,
-	"webpack/lib/dependencies/ImportWeakDependency"
-);
+/**
+ * @param {string} hookName Name of the hook to profile.
+ * @param {Trace} tracer The trace object.
+ * @param {object} options Options for the profiled fn.
+ * @param {string} options.name Plugin name
+ * @param {string} options.type Plugin type (sync | async | promise)
+ * @param {PluginFunction} options.fn Plugin function
+ * @returns {PluginFunction} Chainable hooked function.
+ */
+const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
+	const defaultCategory = ["blink.user_timing"];
 
-ImportWeakDependency.Template = class ImportDependencyTemplate extends (
-	ImportDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ImportWeakDependency} */ (dependency);
-		const content = runtimeTemplate.moduleNamespacePromise({
-			chunkGraph,
-			module: moduleGraph.getModule(dep),
-			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
-			message: "import() weak",
-			weak: true,
-			runtimeRequirements
-		});
+	switch (type) {
+		case "promise":
+			return (...args) => {
+				const id = ++tracer.counter;
+				tracer.trace.begin({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				const promise = /** @type {Promise<*>} */ (fn(...args));
+				return promise.then(r => {
+					tracer.trace.end({
+						name,
+						id,
+						cat: defaultCategory
+					});
+					return r;
+				});
+			};
+		case "async":
+			return (...args) => {
+				const id = ++tracer.counter;
+				tracer.trace.begin({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				const callback = args.pop();
+				fn(...args, (...r) => {
+					tracer.trace.end({
+						name,
+						id,
+						cat: defaultCategory
+					});
+					callback(...r);
+				});
+			};
+		case "sync":
+			return (...args) => {
+				const id = ++tracer.counter;
+				// Do not instrument ourself due to the CPU
+				// profile needing to be the last event in the trace.
+				if (name === pluginName) {
+					return fn(...args);
+				}
 
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+				tracer.trace.begin({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				let r;
+				try {
+					r = fn(...args);
+				} catch (error) {
+					tracer.trace.end({
+						name,
+						id,
+						cat: defaultCategory
+					});
+					throw error;
+				}
+				tracer.trace.end({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				return r;
+			};
+		default:
+			break;
 	}
 };
 
-module.exports = ImportWeakDependency;
+module.exports = ProfilingPlugin;
+module.exports.Profiler = Profiler;
 
 
 /***/ }),
 
-/***/ 750:
+/***/ 96816:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -80907,178 +77954,225 @@ module.exports = ImportWeakDependency;
 
 
 
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
 const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-const getExportsFromData = data => {
-	if (data && typeof data === "object") {
-		if (Array.isArray(data)) {
-			return data.map((item, idx) => {
-				return {
-					name: `${idx}`,
-					canMangle: true,
-					exports: getExportsFromData(item)
-				};
-			});
-		} else {
-			const exports = [];
-			for (const key of Object.keys(data)) {
-				exports.push({
-					name: key,
-					canMangle: true,
-					exports: getExportsFromData(data[key])
-				});
-			}
-			return exports;
-		}
+/** @type {Record<string, { definition: string, content: string, requests: string[] }>} */
+const DEFINITIONS = {
+	f: {
+		definition: "var __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_RESULT__ = (#).call(exports, __webpack_require__, exports, module),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [
+			RuntimeGlobals.require,
+			RuntimeGlobals.exports,
+			RuntimeGlobals.module
+		]
+	},
+	o: {
+		definition: "",
+		content: "!(module.exports = #)",
+		requests: [RuntimeGlobals.module]
+	},
+	of: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
+		__WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [
+			RuntimeGlobals.require,
+			RuntimeGlobals.exports,
+			RuntimeGlobals.module
+		]
+	},
+	af: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_RESULT__ = (#).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
+	},
+	ao: {
+		definition: "",
+		content: "!(#, module.exports = #)",
+		requests: [RuntimeGlobals.module]
+	},
+	aof: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
+	},
+	lf: {
+		definition: "var XXX, XXXmodule;",
+		content:
+			"!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = (#).call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))",
+		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
+	},
+	lo: {
+		definition: "var XXX;",
+		content: "!(XXX = #)",
+		requests: []
+	},
+	lof: {
+		definition: "var XXX, XXXfactory, XXXmodule;",
+		content:
+			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))",
+		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
+	},
+	laf: {
+		definition: "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX, XXXexports;",
+		content:
+			"!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#).apply(XXXexports = {}, __WEBPACK_AMD_DEFINE_ARRAY__), XXX === undefined && (XXX = XXXexports))",
+		requests: []
+	},
+	lao: {
+		definition: "var XXX;",
+		content: "!(#, XXX = #)",
+		requests: []
+	},
+	laof: {
+		definition: "var XXXarray, XXXfactory, XXXexports, XXX;",
+		content: `!(XXXarray = #, XXXfactory = (#),
+		(typeof XXXfactory === 'function' ?
+			((XXX = XXXfactory.apply(XXXexports = {}, XXXarray)), XXX === undefined && (XXX = XXXexports)) :
+			(XXX = XXXfactory)
+		))`,
+		requests: []
 	}
-	return undefined;
 };
 
-class JsonExportsDependency extends NullDependency {
-	/**
-	 * @param {(string | ExportSpec)[]} exports json exports
-	 */
-	constructor(exports) {
+class AMDDefineDependency extends NullDependency {
+	constructor(range, arrayRange, functionRange, objectRange, namedModule) {
 		super();
-		this.exports = exports;
-		this._hashUpdate = undefined;
+		this.range = range;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.objectRange = objectRange;
+		this.namedModule = namedModule;
+		this.localModule = null;
 	}
 
 	get type() {
-		return "json exports";
-	}
-
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: this.exports,
-			dependencies: undefined
-		};
-	}
-
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = this.exports
-				? JSON.stringify(this.exports)
-				: "undefined";
-		}
-		hash.update(this._hashUpdate);
+		return "amd define";
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.exports);
+		write(this.range);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.objectRange);
+		write(this.namedModule);
+		write(this.localModule);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.exports = read();
+		this.range = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.objectRange = read();
+		this.namedModule = read();
+		this.localModule = read();
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	JsonExportsDependency,
-	"webpack/lib/dependencies/JsonExportsDependency"
+	AMDDefineDependency,
+	"webpack/lib/dependencies/AMDDefineDependency"
 );
 
-module.exports = JsonExportsDependency;
-module.exports.getExportsFromData = getExportsFromData;
-
-
-/***/ }),
-
-/***/ 71693:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ModuleDependency = __webpack_require__(80321);
-
-class LoaderDependency extends ModuleDependency {
+AMDDefineDependency.Template = class AMDDefineDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {string} request request string
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	constructor(request) {
-		super(request);
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {AMDDefineDependency} */ (dependency);
+		const branch = this.branch(dep);
+		const { definition, content, requests } = DEFINITIONS[branch];
+		for (const req of requests) {
+			runtimeRequirements.add(req);
+		}
+		this.replace(dep, source, definition, content);
 	}
 
-	get type() {
-		return "loader";
+	localModuleVar(dependency) {
+		return (
+			dependency.localModule &&
+			dependency.localModule.used &&
+			dependency.localModule.variableName()
+		);
 	}
 
-	get category() {
-		return "loader";
+	branch(dependency) {
+		const localModuleVar = this.localModuleVar(dependency) ? "l" : "";
+		const arrayRange = dependency.arrayRange ? "a" : "";
+		const objectRange = dependency.objectRange ? "o" : "";
+		const functionRange = dependency.functionRange ? "f" : "";
+		return localModuleVar + arrayRange + objectRange + functionRange;
 	}
-}
-
-module.exports = LoaderDependency;
-
-
-/***/ }),
-
-/***/ 223:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+	replace(dependency, source, definition, text) {
+		const localModuleVar = this.localModuleVar(dependency);
+		if (localModuleVar) {
+			text = text.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$"));
+			definition = definition.replace(
+				/XXX/g,
+				localModuleVar.replace(/\$/g, "$$$$")
+			);
+		}
 
+		if (dependency.namedModule) {
+			text = text.replace(/YYY/g, JSON.stringify(dependency.namedModule));
+		}
 
-const ModuleDependency = __webpack_require__(80321);
+		const texts = text.split("#");
 
-class LoaderImportDependency extends ModuleDependency {
-	/**
-	 * @param {string} request request string
-	 */
-	constructor(request) {
-		super(request);
-		this.weak = true;
-	}
+		if (definition) source.insert(0, definition);
 
-	get type() {
-		return "loader import";
-	}
+		let current = dependency.range[0];
+		if (dependency.arrayRange) {
+			source.replace(current, dependency.arrayRange[0] - 1, texts.shift());
+			current = dependency.arrayRange[1];
+		}
 
-	get category() {
-		return "loaderImport";
+		if (dependency.objectRange) {
+			source.replace(current, dependency.objectRange[0] - 1, texts.shift());
+			current = dependency.objectRange[1];
+		} else if (dependency.functionRange) {
+			source.replace(current, dependency.functionRange[0] - 1, texts.shift());
+			current = dependency.functionRange[1];
+		}
+		source.replace(current, dependency.range[1] - 1, texts.shift());
+		if (texts.length > 0) throw new Error("Implementation error");
 	}
-}
+};
 
-module.exports = LoaderImportDependency;
+module.exports = AMDDefineDependency;
 
 
 /***/ }),
 
-/***/ 24721:
+/***/ 48519:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81089,263 +78183,358 @@ module.exports = LoaderImportDependency;
 
 
 
-const NormalModule = __webpack_require__(39);
-const LazySet = __webpack_require__(38938);
-const LoaderDependency = __webpack_require__(71693);
-const LoaderImportDependency = __webpack_require__(223);
+const RuntimeGlobals = __webpack_require__(16475);
+const AMDDefineDependency = __webpack_require__(96816);
+const AMDRequireArrayDependency = __webpack_require__(33516);
+const AMDRequireContextDependency = __webpack_require__(96123);
+const AMDRequireItemDependency = __webpack_require__(71806);
+const ConstDependency = __webpack_require__(76911);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const DynamicExports = __webpack_require__(32006);
+const LocalModuleDependency = __webpack_require__(52805);
+const { addLocalModule, getLocalModule } = __webpack_require__(75827);
 
-/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+const isBoundFunctionExpression = expr => {
+	if (expr.type !== "CallExpression") return false;
+	if (expr.callee.type !== "MemberExpression") return false;
+	if (expr.callee.computed) return false;
+	if (expr.callee.object.type !== "FunctionExpression") return false;
+	if (expr.callee.property.type !== "Identifier") return false;
+	if (expr.callee.property.name !== "bind") return false;
+	return true;
+};
 
-/**
- * @callback LoadModuleCallback
- * @param {(Error | null)=} err error object
- * @param {string | Buffer=} source source code
- * @param {object=} map source map
- * @param {Module=} module loaded module if successful
- */
+const isUnboundFunctionExpression = expr => {
+	if (expr.type === "FunctionExpression") return true;
+	if (expr.type === "ArrowFunctionExpression") return true;
+	return false;
+};
 
-/**
- * @callback ImportModuleCallback
- * @param {(Error | null)=} err error object
- * @param {any=} exports exports of the evaluated module
- */
+const isCallable = expr => {
+	if (isUnboundFunctionExpression(expr)) return true;
+	if (isBoundFunctionExpression(expr)) return true;
+	return false;
+};
 
-/**
- * @typedef {Object} ImportModuleOptions
- * @property {string=} layer the target layer
- * @property {string=} publicPath the target public path
- */
+class AMDDefineDependencyParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-class LoaderPlugin {
-	/**
-	 * @param {Object} options options
-	 */
-	constructor(options = {}) {}
+	apply(parser) {
+		parser.hooks.call
+			.for("define")
+			.tap(
+				"AMDDefineDependencyParserPlugin",
+				this.processCallDefine.bind(this, parser)
+			);
+	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"LoaderPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					LoaderDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyFactories.set(
-					LoaderImportDependency,
-					normalModuleFactory
-				);
+	processArray(parser, expr, param, identifiers, namedModule) {
+		if (param.isArray()) {
+			param.items.forEach((param, idx) => {
+				if (
+					param.isString() &&
+					["require", "module", "exports"].includes(param.string)
+				)
+					identifiers[idx] = param.string;
+				const result = this.processItem(parser, expr, param, namedModule);
+				if (result === undefined) {
+					this.processContext(parser, expr, param);
+				}
+			});
+			return true;
+		} else if (param.isConstArray()) {
+			const deps = [];
+			param.array.forEach((request, idx) => {
+				let dep;
+				let localModule;
+				if (request === "require") {
+					identifiers[idx] = request;
+					dep = "__webpack_require__";
+				} else if (["exports", "module"].includes(request)) {
+					identifiers[idx] = request;
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = expr.loc;
+					dep.optional = !!parser.scope.inTry;
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			});
+			const dep = this.newRequireArrayDependency(deps, param.range);
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processItem(parser, expr, param, namedModule) {
+		if (param.isConditional()) {
+			param.options.forEach(param => {
+				const result = this.processItem(parser, expr, param);
+				if (result === undefined) {
+					this.processContext(parser, expr, param);
+				}
+			});
+			return true;
+		} else if (param.isString()) {
+			let dep, localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency("__webpack_require__", param.range, [
+					RuntimeGlobals.require
+				]);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency("exports", param.range, [
+					RuntimeGlobals.exports
+				]);
+			} else if (param.string === "module") {
+				dep = new ConstDependency("module", param.range, [
+					RuntimeGlobals.module
+				]);
+			} else if (
+				(localModule = getLocalModule(parser.state, param.string, namedModule))
+			) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(param.string, param.range);
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
 			}
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			param.range,
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
 		);
+		if (!dep) return;
+		dep.loc = expr.loc;
+		dep.optional = !!parser.scope.inTry;
+		parser.state.current.addDependency(dep);
+		return true;
+	}
 
-		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderPlugin",
-				loaderContext => {
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
-					 * @returns {void}
-					 */
-					loaderContext.loadModule = (request, callback) => {
-						const dep = new LoaderDependency(request);
-						dep.loc = {
-							name: request
-						};
-						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
-						);
-						if (factory === undefined) {
-							return callback(
-								new Error(
-									`No module factory available for dependency type: ${dep.constructor.name}`
-								)
-							);
-						}
-						compilation.buildQueue.increaseParallelism();
-						compilation.handleModuleCreation(
-							{
-								factory,
-								dependencies: [dep],
-								originModule: loaderContext._module,
-								context: loaderContext.context,
-								recursive: false
-							},
-							err => {
-								compilation.buildQueue.decreaseParallelism();
-								if (err) {
-									return callback(err);
-								}
-								const referencedModule = moduleGraph.getModule(dep);
-								if (!referencedModule) {
-									return callback(new Error("Cannot load the module"));
-								}
-								if (referencedModule.getNumberOfErrors() > 0) {
-									return callback(
-										new Error("The loaded module contains errors")
-									);
-								}
-								const moduleSource = referencedModule.originalSource();
-								if (!moduleSource) {
-									return callback(
-										new Error(
-											"The module created for a LoaderDependency must have an original source"
-										)
-									);
-								}
-								let source, map;
-								if (moduleSource.sourceAndMap) {
-									const sourceAndMap = moduleSource.sourceAndMap();
-									map = sourceAndMap.map;
-									source = sourceAndMap.source;
-								} else {
-									map = moduleSource.map();
-									source = moduleSource.source();
-								}
-								const fileDependencies = new LazySet();
-								const contextDependencies = new LazySet();
-								const missingDependencies = new LazySet();
-								const buildDependencies = new LazySet();
-								referencedModule.addCacheDependencies(
-									fileDependencies,
-									contextDependencies,
-									missingDependencies,
-									buildDependencies
-								);
-
-								for (const d of fileDependencies) {
-									loaderContext.addDependency(d);
-								}
-								for (const d of contextDependencies) {
-									loaderContext.addContextDependency(d);
-								}
-								for (const d of missingDependencies) {
-									loaderContext.addMissingDependency(d);
-								}
-								for (const d of buildDependencies) {
-									loaderContext.addBuildDependency(d);
-								}
-								return callback(null, source, map, referencedModule);
-							}
-						);
-					};
-
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions=} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {void}
-					 */
-					const importModule = (request, options, callback) => {
-						const dep = new LoaderImportDependency(request);
-						dep.loc = {
-							name: request
-						};
-						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
-						);
-						if (factory === undefined) {
-							return callback(
-								new Error(
-									`No module factory available for dependency type: ${dep.constructor.name}`
-								)
-							);
-						}
-						compilation.buildQueue.increaseParallelism();
-						compilation.handleModuleCreation(
-							{
-								factory,
-								dependencies: [dep],
-								originModule: loaderContext._module,
-								contextInfo: {
-									issuerLayer: options.layer
-								},
-								context: loaderContext.context,
-								connectOrigin: false
-							},
-							err => {
-								compilation.buildQueue.decreaseParallelism();
-								if (err) {
-									return callback(err);
-								}
-								const referencedModule = moduleGraph.getModule(dep);
-								if (!referencedModule) {
-									return callback(new Error("Cannot load the module"));
-								}
-								compilation.executeModule(
-									referencedModule,
-									{
-										entryOptions: {
-											publicPath: options.publicPath
-										}
-									},
-									(err, result) => {
-										if (err) return callback(err);
-										for (const d of result.fileDependencies) {
-											loaderContext.addDependency(d);
-										}
-										for (const d of result.contextDependencies) {
-											loaderContext.addContextDependency(d);
-										}
-										for (const d of result.missingDependencies) {
-											loaderContext.addMissingDependency(d);
-										}
-										for (const d of result.buildDependencies) {
-											loaderContext.addBuildDependency(d);
-										}
-										if (result.cacheable === false)
-											loaderContext.cacheable(false);
-										for (const [name, { source, info }] of result.assets) {
-											const { buildInfo } = loaderContext._module;
-											if (!buildInfo.assets) {
-												buildInfo.assets = Object.create(null);
-												buildInfo.assetsInfo = new Map();
-											}
-											buildInfo.assets[name] = source;
-											buildInfo.assetsInfo.set(name, info);
-										}
-										callback(null, result.exports);
-									}
-								);
-							}
-						);
-					};
-
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {Promise<any> | void} exports
-					 */
-					loaderContext.importModule = (request, options, callback) => {
-						if (!callback) {
-							return new Promise((resolve, reject) => {
-								importModule(request, options || {}, (err, result) => {
-									if (err) reject(err);
-									else resolve(result);
-								});
-							});
-						}
-						return importModule(request, options || {}, callback);
-					};
+	processCallDefine(parser, expr) {
+		let array, fn, obj, namedModule;
+		switch (expr.arguments.length) {
+			case 1:
+				if (isCallable(expr.arguments[0])) {
+					// define(f() {…})
+					fn = expr.arguments[0];
+				} else if (expr.arguments[0].type === "ObjectExpression") {
+					// define({…})
+					obj = expr.arguments[0];
+				} else {
+					// define(expr)
+					// unclear if function or object
+					obj = fn = expr.arguments[0];
+				}
+				break;
+			case 2:
+				if (expr.arguments[0].type === "Literal") {
+					namedModule = expr.arguments[0].value;
+					// define("…", …)
+					if (isCallable(expr.arguments[1])) {
+						// define("…", f() {…})
+						fn = expr.arguments[1];
+					} else if (expr.arguments[1].type === "ObjectExpression") {
+						// define("…", {…})
+						obj = expr.arguments[1];
+					} else {
+						// define("…", expr)
+						// unclear if function or object
+						obj = fn = expr.arguments[1];
+					}
+				} else {
+					array = expr.arguments[0];
+					if (isCallable(expr.arguments[1])) {
+						// define([…], f() {})
+						fn = expr.arguments[1];
+					} else if (expr.arguments[1].type === "ObjectExpression") {
+						// define([…], {…})
+						obj = expr.arguments[1];
+					} else {
+						// define([…], expr)
+						// unclear if function or object
+						obj = fn = expr.arguments[1];
+					}
+				}
+				break;
+			case 3:
+				// define("…", […], f() {…})
+				namedModule = expr.arguments[0].value;
+				array = expr.arguments[1];
+				if (isCallable(expr.arguments[2])) {
+					// define("…", […], f() {})
+					fn = expr.arguments[2];
+				} else if (expr.arguments[2].type === "ObjectExpression") {
+					// define("…", […], {…})
+					obj = expr.arguments[2];
+				} else {
+					// define("…", […], expr)
+					// unclear if function or object
+					obj = fn = expr.arguments[2];
+				}
+				break;
+			default:
+				return;
+		}
+		DynamicExports.bailout(parser.state);
+		let fnParams = null;
+		let fnParamsOffset = 0;
+		if (fn) {
+			if (isUnboundFunctionExpression(fn)) {
+				fnParams = fn.params;
+			} else if (isBoundFunctionExpression(fn)) {
+				fnParams = fn.callee.object.params;
+				fnParamsOffset = fn.arguments.length - 1;
+				if (fnParamsOffset < 0) {
+					fnParamsOffset = 0;
+				}
+			}
+		}
+		let fnRenames = new Map();
+		if (array) {
+			const identifiers = {};
+			const param = parser.evaluateExpression(array);
+			const result = this.processArray(
+				parser,
+				expr,
+				param,
+				identifiers,
+				namedModule
+			);
+			if (!result) return;
+			if (fnParams) {
+				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+					if (identifiers[idx]) {
+						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
+						return false;
+					}
+					return true;
+				});
+			}
+		} else {
+			const identifiers = ["require", "exports", "module"];
+			if (fnParams) {
+				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+					if (identifiers[idx]) {
+						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
+						return false;
+					}
+					return true;
+				});
+			}
+		}
+		let inTry;
+		if (fn && isUnboundFunctionExpression(fn)) {
+			inTry = parser.scope.inTry;
+			parser.inScope(fnParams, () => {
+				for (const [name, varInfo] of fnRenames) {
+					parser.setVariable(name, varInfo);
+				}
+				parser.scope.inTry = inTry;
+				if (fn.body.type === "BlockStatement") {
+					parser.detectMode(fn.body.body);
+					const prev = parser.prevStatement;
+					parser.preWalkStatement(fn.body);
+					parser.prevStatement = prev;
+					parser.walkStatement(fn.body);
+				} else {
+					parser.walkExpression(fn.body);
+				}
+			});
+		} else if (fn && isBoundFunctionExpression(fn)) {
+			inTry = parser.scope.inTry;
+			parser.inScope(
+				fn.callee.object.params.filter(
+					i => !["require", "module", "exports"].includes(i.name)
+				),
+				() => {
+					for (const [name, varInfo] of fnRenames) {
+						parser.setVariable(name, varInfo);
+					}
+					parser.scope.inTry = inTry;
+					if (fn.callee.object.body.type === "BlockStatement") {
+						parser.detectMode(fn.callee.object.body.body);
+						const prev = parser.prevStatement;
+						parser.preWalkStatement(fn.callee.object.body);
+						parser.prevStatement = prev;
+						parser.walkStatement(fn.callee.object.body);
+					} else {
+						parser.walkExpression(fn.callee.object.body);
+					}
 				}
 			);
-		});
+			if (fn.arguments) {
+				parser.walkExpressions(fn.arguments);
+			}
+		} else if (fn || obj) {
+			parser.walkExpression(fn || obj);
+		}
+
+		const dep = this.newDefineDependency(
+			expr.range,
+			array ? array.range : null,
+			fn ? fn.range : null,
+			obj ? obj.range : null,
+			namedModule ? namedModule : null
+		);
+		dep.loc = expr.loc;
+		if (namedModule) {
+			dep.localModule = addLocalModule(parser.state, namedModule);
+		}
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	}
+
+	newDefineDependency(
+		range,
+		arrayRange,
+		functionRange,
+		objectRange,
+		namedModule
+	) {
+		return new AMDDefineDependency(
+			range,
+			arrayRange,
+			functionRange,
+			objectRange,
+			namedModule
+		);
+	}
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
 	}
 }
-module.exports = LoaderPlugin;
+module.exports = AMDDefineDependencyParserPlugin;
 
 
 /***/ }),
 
-/***/ 5826:
+/***/ 50067:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81356,48 +78545,220 @@ module.exports = LoaderPlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
+const RuntimeGlobals = __webpack_require__(16475);
+const {
+	approve,
+	evaluateToIdentifier,
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
 
-class LocalModule {
-	constructor(name, idx) {
-		this.name = name;
-		this.idx = idx;
-		this.used = false;
-	}
+const AMDDefineDependency = __webpack_require__(96816);
+const AMDDefineDependencyParserPlugin = __webpack_require__(48519);
+const AMDRequireArrayDependency = __webpack_require__(33516);
+const AMDRequireContextDependency = __webpack_require__(96123);
+const AMDRequireDependenciesBlockParserPlugin = __webpack_require__(66866);
+const AMDRequireDependency = __webpack_require__(43911);
+const AMDRequireItemDependency = __webpack_require__(71806);
+const {
+	AMDDefineRuntimeModule,
+	AMDOptionsRuntimeModule
+} = __webpack_require__(45242);
+const ConstDependency = __webpack_require__(76911);
+const LocalModuleDependency = __webpack_require__(52805);
+const UnsupportedDependency = __webpack_require__(51669);
 
-	flagUsed() {
-		this.used = true;
-	}
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
-	variableName() {
-		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+class AMDPlugin {
+	/**
+	 * @param {Record<string, any>} amdOptions the AMD options
+	 */
+	constructor(amdOptions) {
+		this.amdOptions = amdOptions;
 	}
 
-	serialize(context) {
-		const { write } = context;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const amdOptions = this.amdOptions;
+		compiler.hooks.compilation.tap(
+			"AMDPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					AMDRequireDependency,
+					new AMDRequireDependency.Template()
+				);
 
-		write(this.name);
-		write(this.idx);
-		write(this.used);
-	}
+				compilation.dependencyFactories.set(
+					AMDRequireItemDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					AMDRequireItemDependency,
+					new AMDRequireItemDependency.Template()
+				);
 
-	deserialize(context) {
-		const { read } = context;
+				compilation.dependencyTemplates.set(
+					AMDRequireArrayDependency,
+					new AMDRequireArrayDependency.Template()
+				);
 
-		this.name = read();
-		this.idx = read();
-		this.used = read();
+				compilation.dependencyFactories.set(
+					AMDRequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					AMDRequireContextDependency,
+					new AMDRequireContextDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					AMDDefineDependency,
+					new AMDDefineDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					UnsupportedDependency,
+					new UnsupportedDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					LocalModuleDependency,
+					new LocalModuleDependency.Template()
+				);
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.amdDefine)
+					.tap("AMDPlugin", (module, set) => {
+						set.add(RuntimeGlobals.require);
+					});
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.amdOptions)
+					.tap("AMDPlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.amdDefine)
+					.tap("AMDPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.amdOptions)
+					.tap("AMDPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new AMDOptionsRuntimeModule(amdOptions)
+						);
+					});
+
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.amd !== undefined && !parserOptions.amd) return;
+
+					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
+						parser.hooks.expression
+							.for(optionExpr)
+							.tap(
+								"AMDPlugin",
+								toConstantDependency(parser, RuntimeGlobals.amdOptions, [
+									RuntimeGlobals.amdOptions
+								])
+							);
+						parser.hooks.evaluateIdentifier
+							.for(optionExpr)
+							.tap(
+								"AMDPlugin",
+								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
+							);
+						parser.hooks.evaluateTypeof
+							.for(optionExpr)
+							.tap("AMDPlugin", evaluateToString("object"));
+						parser.hooks.typeof
+							.for(optionExpr)
+							.tap(
+								"AMDPlugin",
+								toConstantDependency(parser, JSON.stringify("object"))
+							);
+					};
+
+					new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
+						parser
+					);
+					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
+
+					tapOptionsHooks("define.amd", "define", () => "amd");
+					tapOptionsHooks("require.amd", "require", () => ["amd"]);
+					tapOptionsHooks(
+						"__webpack_amd_options__",
+						"__webpack_amd_options__",
+						() => []
+					);
+
+					parser.hooks.expression.for("define").tap("AMDPlugin", expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.amdDefine,
+							expr.range,
+							[RuntimeGlobals.amdDefine]
+						);
+						dep.loc = expr.loc;
+						parser.state.module.addPresentationalDependency(dep);
+						return true;
+					});
+					parser.hooks.typeof
+						.for("define")
+						.tap(
+							"AMDPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("define")
+						.tap("AMDPlugin", evaluateToString("function"));
+					parser.hooks.canRename.for("define").tap("AMDPlugin", approve);
+					parser.hooks.rename.for("define").tap("AMDPlugin", expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.amdDefine,
+							expr.range,
+							[RuntimeGlobals.amdDefine]
+						);
+						dep.loc = expr.loc;
+						parser.state.module.addPresentationalDependency(dep);
+						return false;
+					});
+					parser.hooks.typeof
+						.for("require")
+						.tap(
+							"AMDPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("require")
+						.tap("AMDPlugin", evaluateToString("function"));
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("AMDPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("AMDPlugin", handler);
+			}
+		);
 	}
 }
 
-makeSerializable(LocalModule, "webpack/lib/dependencies/LocalModule");
-
-module.exports = LocalModule;
+module.exports = AMDPlugin;
 
 
 /***/ }),
 
-/***/ 52805:
+/***/ 33516:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81408,6 +78769,7 @@ module.exports = LocalModule;
 
 
 
+const DependencyTemplate = __webpack_require__(5160);
 const makeSerializable = __webpack_require__(33032);
 const NullDependency = __webpack_require__(31830);
 
@@ -81415,21 +78777,27 @@ const NullDependency = __webpack_require__(31830);
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class LocalModuleDependency extends NullDependency {
-	constructor(localModule, range, callNew) {
+class AMDRequireArrayDependency extends NullDependency {
+	constructor(depsArray, range) {
 		super();
 
-		this.localModule = localModule;
+		this.depsArray = depsArray;
 		this.range = range;
-		this.callNew = callNew;
+	}
+
+	get type() {
+		return "amd require array";
+	}
+
+	get category() {
+		return "amd";
 	}
 
 	serialize(context) {
 		const { write } = context;
 
-		write(this.localModule);
+		write(this.depsArray);
 		write(this.range);
-		write(this.callNew);
 
 		super.serialize(context);
 	}
@@ -81437,21 +78805,20 @@ class LocalModuleDependency extends NullDependency {
 	deserialize(context) {
 		const { read } = context;
 
-		this.localModule = read();
+		this.depsArray = read();
 		this.range = read();
-		this.callNew = read();
 
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	LocalModuleDependency,
-	"webpack/lib/dependencies/LocalModuleDependency"
+	AMDRequireArrayDependency,
+	"webpack/lib/dependencies/AMDRequireArrayDependency"
 );
 
-LocalModuleDependency.Template = class LocalModuleDependencyTemplate extends (
-	NullDependency.Template
+AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate extends (
+	DependencyTemplate
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -81460,79 +78827,45 @@ LocalModuleDependency.Template = class LocalModuleDependencyTemplate extends (
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const dep = /** @type {LocalModuleDependency} */ (dependency);
-		if (!dep.range) return;
-		const moduleInstance = dep.callNew
-			? `new (function () { return ${dep.localModule.variableName()}; })()`
-			: dep.localModule.variableName();
-		source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
+		const dep = /** @type {AMDRequireArrayDependency} */ (dependency);
+		const content = this.getContent(dep, templateContext);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
-};
-
-module.exports = LocalModuleDependency;
-
-
-/***/ }),
-
-/***/ 75827:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const LocalModule = __webpack_require__(5826);
-
-const lookup = (parent, mod) => {
-	if (mod.charAt(0) !== ".") return mod;
-
-	var path = parent.split("/");
-	var segments = mod.split("/");
-	path.pop();
 
-	for (let i = 0; i < segments.length; i++) {
-		const seg = segments[i];
-		if (seg === "..") {
-			path.pop();
-		} else if (seg !== ".") {
-			path.push(seg);
-		}
+	getContent(dep, templateContext) {
+		const requires = dep.depsArray.map(dependency => {
+			return this.contentForDependency(dependency, templateContext);
+		});
+		return `[${requires.join(", ")}]`;
 	}
 
-	return path.join("/");
-};
-
-exports.addLocalModule = (state, name) => {
-	if (!state.localModules) {
-		state.localModules = [];
-	}
-	const m = new LocalModule(name, state.localModules.length);
-	state.localModules.push(m);
-	return m;
-};
+	contentForDependency(
+		dep,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		if (typeof dep === "string") {
+			return dep;
+		}
 
-exports.getLocalModule = (state, name, namedModule) => {
-	if (!state.localModules) return null;
-	if (namedModule) {
-		// resolve dependency name relative to the defining named module
-		name = lookup(namedModule, name);
-	}
-	for (let i = 0; i < state.localModules.length; i++) {
-		if (state.localModules[i].name === name) {
-			return state.localModules[i];
+		if (dep.localModule) {
+			return dep.localModule.variableName();
+		} else {
+			return runtimeTemplate.moduleExports({
+				module: moduleGraph.getModule(dep),
+				chunkGraph,
+				request: dep.request,
+				runtimeRequirements
+			});
 		}
 	}
-	return null;
 };
 
+module.exports = AMDRequireArrayDependency;
+
 
 /***/ }),
 
-/***/ 88488:
+/***/ 96123:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81543,133 +78876,57 @@ exports.getLocalModule = (state, name, namedModule) => {
 
 
 
-const Dependency = __webpack_require__(54912);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const ContextDependency = __webpack_require__(88101);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+class AMDRequireContextDependency extends ContextDependency {
+	constructor(options, range, valueRange) {
+		super(options);
 
-class ModuleDecoratorDependency extends NullDependency {
-	/**
-	 * @param {string} decorator the decorator requirement
-	 * @param {boolean} allowExportsAccess allow to access exports from module
-	 */
-	constructor(decorator, allowExportsAccess) {
-		super();
-		this.decorator = decorator;
-		this.allowExportsAccess = allowExportsAccess;
-		this._hashUpdate = undefined;
+		this.range = range;
+		this.valueRange = valueRange;
 	}
 
-	/**
-	 * @returns {string} a display name for the type of dependency
-	 */
 	get type() {
-		return "module decorator";
+		return "amd require context";
 	}
 
 	get category() {
-		return "self";
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `self`;
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return this.allowExportsAccess
-			? Dependency.EXPORTS_OBJECT_REFERENCED
-			: Dependency.NO_EXPORTS_REFERENCED;
-	}
-
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
-		}
-		hash.update(this._hashUpdate);
+		return "amd";
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.decorator);
-		write(this.allowExportsAccess);
+
+		write(this.range);
+		write(this.valueRange);
+
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.decorator = read();
-		this.allowExportsAccess = read();
+
+		this.range = read();
+		this.valueRange = read();
+
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	ModuleDecoratorDependency,
-	"webpack/lib/dependencies/ModuleDecoratorDependency"
+	AMDRequireContextDependency,
+	"webpack/lib/dependencies/AMDRequireContextDependency"
 );
 
-ModuleDecoratorDependency.Template = class ModuleDecoratorDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ module, chunkGraph, initFragments, runtimeRequirements }
-	) {
-		const dep = /** @type {ModuleDecoratorDependency} */ (dependency);
-		runtimeRequirements.add(RuntimeGlobals.moduleLoaded);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(dep.decorator);
-		initFragments.push(
-			new InitFragment(
-				`/* module decorator */ ${module.moduleArgument} = ${dep.decorator}(${module.moduleArgument});\n`,
-				InitFragment.STAGE_PROVIDES,
-				0,
-				`module decorator ${chunkGraph.getModuleId(module)}`
-			)
-		);
-	}
-};
+AMDRequireContextDependency.Template = __webpack_require__(75815);
 
-module.exports = ModuleDecoratorDependency;
+module.exports = AMDRequireContextDependency;
 
 
 /***/ }),
 
-/***/ 80321:
+/***/ 76932:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81680,85 +78937,313 @@ module.exports = ModuleDecoratorDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const DependencyTemplate = __webpack_require__(5160);
-const memoize = __webpack_require__(78676);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../Module")} Module */
+class AMDRequireDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(loc, request) {
+		super(null, loc, request);
+	}
+}
 
-const getRawModule = memoize(() => __webpack_require__(84929));
+makeSerializable(
+	AMDRequireDependenciesBlock,
+	"webpack/lib/dependencies/AMDRequireDependenciesBlock"
+);
 
-class ModuleDependency extends Dependency {
-	/**
-	 * @param {string} request request path which needs resolving
-	 */
-	constructor(request) {
-		super();
-		this.request = request;
-		this.userRequest = request;
-		this.range = undefined;
-		// assertions must be serialized by subclasses that use it
-		/** @type {Record<string, any> | undefined} */
-		this.assertions = undefined;
+module.exports = AMDRequireDependenciesBlock;
+
+
+/***/ }),
+
+/***/ 66866:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const AMDRequireArrayDependency = __webpack_require__(33516);
+const AMDRequireContextDependency = __webpack_require__(96123);
+const AMDRequireDependenciesBlock = __webpack_require__(76932);
+const AMDRequireDependency = __webpack_require__(43911);
+const AMDRequireItemDependency = __webpack_require__(71806);
+const ConstDependency = __webpack_require__(76911);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const LocalModuleDependency = __webpack_require__(52805);
+const { getLocalModule } = __webpack_require__(75827);
+const UnsupportedDependency = __webpack_require__(51669);
+const getFunctionExpression = __webpack_require__(50396);
+
+class AMDRequireDependenciesBlockParserPlugin {
+	constructor(options) {
+		this.options = options;
 	}
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		let str = `module${this.request}`;
-		if (this.assertions !== undefined) {
-			str += JSON.stringify(this.assertions);
+	processFunctionArgument(parser, expression) {
+		let bindThis = true;
+		const fnData = getFunctionExpression(expression);
+		if (fnData) {
+			parser.inScope(
+				fnData.fn.params.filter(i => {
+					return !["require", "module", "exports"].includes(i.name);
+				}),
+				() => {
+					if (fnData.fn.body.type === "BlockStatement") {
+						parser.walkStatement(fnData.fn.body);
+					} else {
+						parser.walkExpression(fnData.fn.body);
+					}
+				}
+			);
+			parser.walkExpressions(fnData.expressions);
+			if (fnData.needThis === false) {
+				bindThis = false;
+			}
+		} else {
+			parser.walkExpression(expression);
 		}
-		return str;
+		return bindThis;
 	}
 
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return true;
+	apply(parser) {
+		parser.hooks.call
+			.for("require")
+			.tap(
+				"AMDRequireDependenciesBlockParserPlugin",
+				this.processCallRequire.bind(this, parser)
+			);
 	}
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
-	 */
-	createIgnoredModule(context) {
-		const RawModule = getRawModule();
-		return new RawModule(
-			"/* (ignored) */",
-			`ignored|${context}|${this.request}`,
-			`${this.request} (ignored)`
+	processArray(parser, expr, param) {
+		if (param.isArray()) {
+			for (const p of param.items) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isConstArray()) {
+			const deps = [];
+			for (const request of param.array) {
+				let dep, localModule;
+				if (request === "require") {
+					dep = "__webpack_require__";
+				} else if (["exports", "module"].includes(request)) {
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = expr.loc;
+					dep.optional = !!parser.scope.inTry;
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			}
+			const dep = this.newRequireArrayDependency(deps, param.range);
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processItem(parser, expr, param) {
+		if (param.isConditional()) {
+			for (const p of param.options) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isString()) {
+			let dep, localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency("__webpack_require__", param.string, [
+					RuntimeGlobals.require
+				]);
+			} else if (param.string === "module") {
+				dep = new ConstDependency(
+					parser.state.module.buildInfo.moduleArgument,
+					param.range,
+					[RuntimeGlobals.module]
+				);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency(
+					parser.state.module.buildInfo.exportsArgument,
+					param.range,
+					[RuntimeGlobals.exports]
+				);
+			} else if ((localModule = getLocalModule(parser.state, param.string))) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			param.range,
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
 		);
+		if (!dep) return;
+		dep.loc = expr.loc;
+		dep.optional = !!parser.scope.inTry;
+		parser.state.current.addDependency(dep);
+		return true;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.request);
-		write(this.userRequest);
-		write(this.range);
-		super.serialize(context);
+	processArrayForRequestString(param) {
+		if (param.isArray()) {
+			const result = param.items.map(item =>
+				this.processItemForRequestString(item)
+			);
+			if (result.every(Boolean)) return result.join(" ");
+		} else if (param.isConstArray()) {
+			return param.array.join(" ");
+		}
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.request = read();
-		this.userRequest = read();
-		this.range = read();
-		super.deserialize(context);
+	processItemForRequestString(param) {
+		if (param.isConditional()) {
+			const result = param.options.map(item =>
+				this.processItemForRequestString(item)
+			);
+			if (result.every(Boolean)) return result.join("|");
+		} else if (param.isString()) {
+			return param.string;
+		}
 	}
-}
 
-ModuleDependency.Template = DependencyTemplate;
+	processCallRequire(parser, expr) {
+		let param;
+		let depBlock;
+		let dep;
+		let result;
 
-module.exports = ModuleDependency;
+		const old = parser.state.current;
+
+		if (expr.arguments.length >= 1) {
+			param = parser.evaluateExpression(expr.arguments[0]);
+			depBlock = this.newRequireDependenciesBlock(
+				expr.loc,
+				this.processArrayForRequestString(param)
+			);
+			dep = this.newRequireDependency(
+				expr.range,
+				param.range,
+				expr.arguments.length > 1 ? expr.arguments[1].range : null,
+				expr.arguments.length > 2 ? expr.arguments[2].range : null
+			);
+			dep.loc = expr.loc;
+			depBlock.addDependency(dep);
+
+			parser.state.current = depBlock;
+		}
+
+		if (expr.arguments.length === 1) {
+			parser.inScope([], () => {
+				result = this.processArray(parser, expr, param);
+			});
+			parser.state.current = old;
+			if (!result) return;
+			parser.state.current.addBlock(depBlock);
+			return true;
+		}
+
+		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
+			try {
+				parser.inScope([], () => {
+					result = this.processArray(parser, expr, param);
+				});
+				if (!result) {
+					const dep = new UnsupportedDependency("unsupported", expr.range);
+					old.addPresentationalDependency(dep);
+					if (parser.state.module) {
+						parser.state.module.addError(
+							new UnsupportedFeatureWarning(
+								"Cannot statically analyse 'require(…, …)' in line " +
+									expr.loc.start.line,
+								expr.loc
+							)
+						);
+					}
+					depBlock = null;
+					return true;
+				}
+				dep.functionBindThis = this.processFunctionArgument(
+					parser,
+					expr.arguments[1]
+				);
+				if (expr.arguments.length === 3) {
+					dep.errorCallbackBindThis = this.processFunctionArgument(
+						parser,
+						expr.arguments[2]
+					);
+				}
+			} finally {
+				parser.state.current = old;
+				if (depBlock) parser.state.current.addBlock(depBlock);
+			}
+			return true;
+		}
+	}
+
+	newRequireDependenciesBlock(loc, request) {
+		return new AMDRequireDependenciesBlock(loc, request);
+	}
+	newRequireDependency(
+		outerRange,
+		arrayRange,
+		functionRange,
+		errorCallbackRange
+	) {
+		return new AMDRequireDependency(
+			outerRange,
+			arrayRange,
+			functionRange,
+			errorCallbackRange
+		);
+	}
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+}
+module.exports = AMDRequireDependenciesBlockParserPlugin;
 
 
 /***/ }),
 
-/***/ 80825:
+/***/ 43911:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81769,55 +79254,66 @@ module.exports = ModuleDependency;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph }) {
-		const dep = /** @type {ModuleDependency} */ (dependency);
-		if (!dep.range) return;
-		const content = runtimeTemplate.moduleId({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak
-		});
-		source.replace(dep.range[0], dep.range[1] - 1, content);
-	}
-}
+class AMDRequireDependency extends NullDependency {
+	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
+		super();
 
-module.exports = ModuleDependencyTemplateAsId;
+		this.outerRange = outerRange;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.errorCallbackRange = errorCallbackRange;
+		this.functionBindThis = false;
+		this.errorCallbackBindThis = false;
+	}
 
+	get category() {
+		return "amd";
+	}
 
-/***/ }),
+	serialize(context) {
+		const { write } = context;
 
-/***/ 36873:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		write(this.outerRange);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.errorCallbackRange);
+		write(this.functionBindThis);
+		write(this.errorCallbackBindThis);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		super.serialize(context);
+	}
 
+	deserialize(context) {
+		const { read } = context;
 
+		this.outerRange = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.errorCallbackRange = read();
+		this.functionBindThis = read();
+		this.errorCallbackBindThis = read();
 
-const ModuleDependency = __webpack_require__(80321);
+		super.deserialize(context);
+	}
+}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+makeSerializable(
+	AMDRequireDependency,
+	"webpack/lib/dependencies/AMDRequireDependency"
+);
 
-class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
+AMDRequireDependency.Template = class AMDRequireDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
@@ -81829,67 +79325,107 @@ class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
 		source,
 		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
-		const dep = /** @type {ModuleDependency} */ (dependency);
-		if (!dep.range) return;
-		const content = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
+		const dep = /** @type {AMDRequireDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
 			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
+			block: depBlock,
+			message: "AMD require",
 			runtimeRequirements
 		});
-		source.replace(dep.range[0], dep.range[1] - 1, content);
-	}
-}
-module.exports = ModuleDependencyTemplateAsRequireId;
 
+		// has array range but no function range
+		if (dep.arrayRange && !dep.functionRange) {
+			const startBlock = `${promise}.then(function() {`;
+			const endBlock = `;})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.replace(dep.arrayRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
+
+		// has function range but no array range
+		if (dep.functionRange && !dep.arrayRange) {
+			const startBlock = `${promise}.then((`;
+			const endBlock = `).bind(exports, __webpack_require__, exports, module))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.functionRange[0] - 1, startBlock);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
 
-/***/ }),
+		// has array range, function range, and errorCallbackRange
+		if (dep.arrayRange && dep.functionRange && dep.errorCallbackRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const errorRangeBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](`;
+			const endBlock = `${dep.errorCallbackBindThis ? ".bind(this)" : ""})`;
 
-/***/ 47511:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
 
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
 
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+			source.replace(
+				dep.functionRange[1],
+				dep.errorCallbackRange[0] - 1,
+				errorRangeBlock
+			);
 
-class ModuleHotAcceptDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-		this.range = range;
-		this.weak = true;
-	}
+			source.replace(
+				dep.errorCallbackRange[1],
+				dep.outerRange[1] - 1,
+				endBlock
+			);
 
-	get type() {
-		return "module.hot.accept";
-	}
+			return;
+		}
 
-	get category() {
-		return "commonjs";
-	}
-}
+		// has array range, function range, but no errorCallbackRange
+		if (dep.arrayRange && dep.functionRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const endBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
 
-makeSerializable(
-	ModuleHotAcceptDependency,
-	"webpack/lib/dependencies/ModuleHotAcceptDependency"
-);
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
 
-ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
 
-module.exports = ModuleHotAcceptDependency;
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+		}
+	}
+};
+
+module.exports = AMDRequireDependency;
 
 
 /***/ }),
 
-/***/ 86301:
+/***/ 71806:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81902,118 +79438,93 @@ module.exports = ModuleHotAcceptDependency;
 
 const makeSerializable = __webpack_require__(33032);
 const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
 
-class ModuleHotDeclineDependency extends ModuleDependency {
+class AMDRequireItemDependency extends ModuleDependency {
 	constructor(request, range) {
 		super(request);
 
 		this.range = range;
-		this.weak = true;
 	}
 
 	get type() {
-		return "module.hot.decline";
+		return "amd require";
 	}
 
 	get category() {
-		return "commonjs";
+		return "amd";
 	}
 }
 
 makeSerializable(
-	ModuleHotDeclineDependency,
-	"webpack/lib/dependencies/ModuleHotDeclineDependency"
+	AMDRequireItemDependency,
+	"webpack/lib/dependencies/AMDRequireItemDependency"
 );
 
-ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
 
-module.exports = ModuleHotDeclineDependency;
+module.exports = AMDRequireItemDependency;
 
 
 /***/ }),
 
-/***/ 31830:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 45242:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const DependencyTemplate = __webpack_require__(5160);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-class NullDependency extends Dependency {
-	get type() {
-		return "null";
+class AMDDefineRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("amd define");
 	}
 
 	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 * @returns {string} runtime code
 	 */
-	couldAffectReferencingModule() {
-		return false;
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdDefine} = function () {`,
+			Template.indent("throw new Error('define cannot be used indirect');"),
+			"};"
+		]);
 	}
 }
 
-NullDependency.Template = class NullDependencyTemplate extends (
-	DependencyTemplate
-) {
+class AMDOptionsRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {Record<string, boolean | number | string>} options the AMD options
 	 */
-	apply(dependency, source, templateContext) {}
-};
-
-module.exports = NullDependency;
-
-
-/***/ }),
-
-/***/ 31618:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ModuleDependency = __webpack_require__(80321);
-
-class PrefetchDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
-
-	get type() {
-		return "prefetch";
+	constructor(options) {
+		super("amd options");
+		this.options = options;
 	}
 
-	get category() {
-		return "esm";
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdOptions} = ${JSON.stringify(this.options)};`
+		]);
 	}
 }
 
-module.exports = PrefetchDependency;
+exports.AMDDefineRuntimeModule = AMDDefineRuntimeModule;
+exports.AMDOptionsRuntimeModule = AMDOptionsRuntimeModule;
 
 
 /***/ }),
 
-/***/ 95770:
+/***/ 57403:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82024,9 +79535,10 @@ module.exports = PrefetchDependency;
 
 
 
+const DependencyTemplate = __webpack_require__(5160);
 const InitFragment = __webpack_require__(55870);
 const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
@@ -82038,32 +79550,16 @@ const ModuleDependency = __webpack_require__(80321);
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
 
-/**
- * @param {string[]|null} path the property path array
- * @returns {string} the converted path
- */
-const pathToString = path =>
-	path !== null && path.length > 0
-		? path.map(part => `[${JSON.stringify(part)}]`).join("")
-		: "";
+class CachedConstDependency extends NullDependency {
+	constructor(expression, range, identifier) {
+		super();
 
-class ProvidedDependency extends ModuleDependency {
-	constructor(request, identifier, path, range) {
-		super(request);
-		this.identifier = identifier;
-		this.path = path;
+		this.expression = expression;
 		this.range = range;
+		this.identifier = identifier;
 		this._hashUpdate = undefined;
 	}
 
-	get type() {
-		return "provided";
-	}
-
-	get category() {
-		return "esm";
-	}
-
 	/**
 	 * Update the hash
 	 * @param {Hash} hash hash to be updated
@@ -82071,34 +79567,40 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate =
-				this.identifier + (this.path ? this.path.join(",") : "null");
-		}
+		if (this._hashUpdate === undefined)
+			this._hashUpdate = "" + this.identifier + this.range + this.expression;
 		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {
 		const { write } = context;
+
+		write(this.expression);
+		write(this.range);
 		write(this.identifier);
-		write(this.path);
+
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
+
+		this.expression = read();
+		this.range = read();
 		this.identifier = read();
-		this.path = read();
+
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	ProvidedDependency,
-	"webpack/lib/dependencies/ProvidedDependency"
+	CachedConstDependency,
+	"webpack/lib/dependencies/CachedConstDependency"
 );
 
-class ProvidedDependencyTemplate extends ModuleDependency.Template {
+CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
+	DependencyTemplate
+) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
@@ -82108,42 +79610,92 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 	apply(
 		dependency,
 		source,
-		{
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph,
-			initFragments,
-			runtimeRequirements
-		}
+		{ runtimeTemplate, dependencyTemplates, initFragments }
 	) {
-		const dep = /** @type {ProvidedDependency} */ (dependency);
+		const dep = /** @type {CachedConstDependency} */ (dependency);
+
 		initFragments.push(
 			new InitFragment(
-				`/* provided dependency */ var ${
-					dep.identifier
-				} = ${runtimeTemplate.moduleExports({
-					module: moduleGraph.getModule(dep),
-					chunkGraph,
-					request: dep.request,
-					runtimeRequirements
-				})}${pathToString(dep.path)};\n`,
-				InitFragment.STAGE_PROVIDES,
-				1,
-				`provided ${dep.identifier}`
+				`var ${dep.identifier} = ${dep.expression};\n`,
+				InitFragment.STAGE_CONSTANTS,
+				0,
+				`const ${dep.identifier}`
 			)
 		);
+
+		if (typeof dep.range === "number") {
+			source.insert(dep.range, dep.identifier);
+
+			return;
+		}
+
 		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
-}
+};
 
-ProvidedDependency.Template = ProvidedDependencyTemplate;
+module.exports = CachedConstDependency;
 
-module.exports = ProvidedDependency;
+
+/***/ }),
+
+/***/ 59643:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+
+exports.handleDependencyBase = (depBase, module, runtimeRequirements) => {
+	let base = undefined;
+	let type;
+	switch (depBase) {
+		case "exports":
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			base = module.exportsArgument;
+			type = "expression";
+			break;
+		case "module.exports":
+			runtimeRequirements.add(RuntimeGlobals.module);
+			base = `${module.moduleArgument}.exports`;
+			type = "expression";
+			break;
+		case "this":
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+			base = "this";
+			type = "expression";
+			break;
+		case "Object.defineProperty(exports)":
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			base = module.exportsArgument;
+			type = "Object.defineProperty";
+			break;
+		case "Object.defineProperty(module.exports)":
+			runtimeRequirements.add(RuntimeGlobals.module);
+			base = `${module.moduleArgument}.exports`;
+			type = "Object.defineProperty";
+			break;
+		case "Object.defineProperty(this)":
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+			base = "this";
+			type = "Object.defineProperty";
+			break;
+		default:
+			throw new Error(`Unsupported base ${depBase}`);
+	}
+
+	return [type, base];
+};
 
 
 /***/ }),
 
-/***/ 55799:
+/***/ 62892:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82154,75 +79706,303 @@ module.exports = ProvidedDependency;
 
 
 
-const { UsageState } = __webpack_require__(63686);
-const makeSerializable = __webpack_require__(33032);
-const { filterRuntime } = __webpack_require__(17156);
-const NullDependency = __webpack_require__(31830);
+const Dependency = __webpack_require__(54912);
+const { UsageState } = __webpack_require__(63686);
+const Template = __webpack_require__(39722);
+const { equals } = __webpack_require__(84953);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { handleDependencyBase } = __webpack_require__(59643);
+const ModuleDependency = __webpack_require__(80321);
+const processExportInfo = __webpack_require__(55207);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const idsSymbol = Symbol("CommonJsExportRequireDependency.ids");
+
+const EMPTY_OBJECT = {};
+
+class CommonJsExportRequireDependency extends ModuleDependency {
+	constructor(range, valueRange, base, names, request, ids, resultUsed) {
+		super(request);
+		this.range = range;
+		this.valueRange = valueRange;
+		this.base = base;
+		this.names = names;
+		this.ids = ids;
+		this.resultUsed = resultUsed;
+		this.asiSafe = undefined;
+	}
+
+	get type() {
+		return "cjs export require";
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported id
+	 */
+	getIds(moduleGraph) {
+		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		const ids = this.getIds(moduleGraph);
+		const getFullResult = () => {
+			if (ids.length === 0) {
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
+			} else {
+				return [
+					{
+						name: ids,
+						canMangle: false
+					}
+				];
+			}
+		};
+		if (this.resultUsed) return getFullResult();
+		let exportsInfo = moduleGraph.getExportsInfo(
+			moduleGraph.getParentModule(this)
+		);
+		for (const name of this.names) {
+			const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+			const used = exportInfo.getUsed(runtime);
+			if (used === UsageState.Unused) return Dependency.NO_EXPORTS_REFERENCED;
+			if (used !== UsageState.OnlyPropertiesUsed) return getFullResult();
+			exportsInfo = exportInfo.exportsInfo;
+			if (!exportsInfo) return getFullResult();
+		}
+		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+			return getFullResult();
+		}
+		/** @type {string[][]} */
+		const referencedExports = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			processExportInfo(
+				runtime,
+				referencedExports,
+				ids.concat(exportInfo.name),
+				exportInfo,
+				false
+			);
+		}
+		return referencedExports.map(name => ({
+			name,
+			canMangle: false
+		}));
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		if (this.names.length === 1) {
+			const name = this.names[0];
+			const from = moduleGraph.getConnection(this);
+			if (!from) return;
+			return {
+				exports: [
+					{
+						name,
+						from,
+						export: ids.length === 0 ? null : ids,
+						// we can't mangle names that are in an empty object
+						// because one could access the prototype property
+						// when export isn't set yet
+						canMangle: !(name in EMPTY_OBJECT) && false
+					}
+				],
+				dependencies: [from.module]
+			};
+		} else if (this.names.length > 0) {
+			const name = this.names[0];
+			return {
+				exports: [
+					{
+						name,
+						// we can't mangle names that are in an empty object
+						// because one could access the prototype property
+						// when export isn't set yet
+						canMangle: !(name in EMPTY_OBJECT) && false
+					}
+				],
+				dependencies: undefined
+			};
+		} else {
+			const from = moduleGraph.getConnection(this);
+			if (!from) return;
+			const reexportInfo = this.getStarReexports(
+				moduleGraph,
+				undefined,
+				from.module
+			);
+			if (reexportInfo) {
+				return {
+					exports: Array.from(reexportInfo.exports, name => {
+						return {
+							name,
+							from,
+							export: ids.concat(name),
+							canMangle: !(name in EMPTY_OBJECT) && false
+						};
+					}),
+					// TODO handle deep reexports
+					dependencies: [from.module]
+				};
+			} else {
+				return {
+					exports: true,
+					from: ids.length === 0 ? from : undefined,
+					canMangle: false,
+					dependencies: [from.module]
+				};
+			}
+		}
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Module} importedModule the imported module (optional)
+	 * @returns {{exports?: Set<string>, checked?: Set<string>}} information
+	 */
+	getStarReexports(
+		moduleGraph,
+		runtime,
+		importedModule = moduleGraph.getModule(this)
+	) {
+		let importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+		const ids = this.getIds(moduleGraph);
+		if (ids.length > 0)
+			importedExportsInfo = importedExportsInfo.getNestedExportsInfo(ids);
+		let exportsInfo = moduleGraph.getExportsInfo(
+			moduleGraph.getParentModule(this)
+		);
+		if (this.names.length > 0)
+			exportsInfo = exportsInfo.getNestedExportsInfo(this.names);
+
+		const noExtraExports =
+			importedExportsInfo &&
+			importedExportsInfo.otherExportsInfo.provided === false;
+		const noExtraImports =
+			exportsInfo &&
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
+
+		if (!noExtraExports && !noExtraImports) {
+			return;
+		}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
+		const isNamespaceImport =
+			importedModule.getExportsType(moduleGraph, false) === "namespace";
 
-class PureExpressionDependency extends NullDependency {
-	/**
-	 * @param {[number, number]} range the source range
-	 */
-	constructor(range) {
-		super();
-		this.range = range;
-		/** @type {Set<string> | false} */
-		this.usedByExports = false;
-		this._hashUpdate = undefined;
-	}
+		/** @type {Set<string>} */
+		const exports = new Set();
+		/** @type {Set<string>} */
+		const checked = new Set();
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = this.range + "";
+		if (noExtraImports) {
+			for (const exportInfo of exportsInfo.orderedExports) {
+				const name = exportInfo.name;
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				if (name === "__esModule" && isNamespaceImport) {
+					exports.add(name);
+				} else if (importedExportsInfo) {
+					const importedExportInfo =
+						importedExportsInfo.getReadOnlyExportInfo(name);
+					if (importedExportInfo.provided === false) continue;
+					exports.add(name);
+					if (importedExportInfo.provided === true) continue;
+					checked.add(name);
+				} else {
+					exports.add(name);
+					checked.add(name);
+				}
+			}
+		} else if (noExtraExports) {
+			for (const importedExportInfo of importedExportsInfo.orderedExports) {
+				const name = importedExportInfo.name;
+				if (importedExportInfo.provided === false) continue;
+				if (exportsInfo) {
+					const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+					if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
+			}
+			if (isNamespaceImport) {
+				exports.add("__esModule");
+				checked.delete("__esModule");
+			}
 		}
-		hash.update(this._hashUpdate);
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
+		return { exports, checked };
 	}
 
 	serialize(context) {
 		const { write } = context;
+		write(this.asiSafe);
 		write(this.range);
-		write(this.usedByExports);
+		write(this.valueRange);
+		write(this.base);
+		write(this.names);
+		write(this.ids);
+		write(this.resultUsed);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
+		this.asiSafe = read();
 		this.range = read();
-		this.usedByExports = read();
+		this.valueRange = read();
+		this.base = read();
+		this.names = read();
+		this.ids = read();
+		this.resultUsed = read();
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	PureExpressionDependency,
-	"webpack/lib/dependencies/PureExpressionDependency"
+	CommonJsExportRequireDependency,
+	"webpack/lib/dependencies/CommonJsExportRequireDependency"
 );
 
-PureExpressionDependency.Template = class PureExpressionDependencyTemplate extends (
-	NullDependency.Template
+CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependencyTemplate extends (
+	ModuleDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -82233,53 +80013,71 @@ PureExpressionDependency.Template = class PureExpressionDependencyTemplate exten
 	apply(
 		dependency,
 		source,
-		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+		{
+			module,
+			runtimeTemplate,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtime
+		}
 	) {
-		const dep = /** @type {PureExpressionDependency} */ (dependency);
+		const dep = /** @type {CommonJsExportRequireDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.names, runtime);
 
-		const usedByExports = dep.usedByExports;
-		if (usedByExports !== false) {
-			const selfModule = moduleGraph.getParentModule(dep);
-			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			const runtimeCondition = filterRuntime(runtime, runtime => {
-				for (const exportName of usedByExports) {
-					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
-						return true;
-					}
-				}
-				return false;
-			});
-			if (runtimeCondition === true) return;
-			if (runtimeCondition !== false) {
-				const condition = runtimeTemplate.runtimeConditionExpression({
-					chunkGraph,
-					runtime,
-					runtimeCondition,
-					runtimeRequirements
-				});
-				source.insert(
+		const [type, base] = handleDependencyBase(
+			dep.base,
+			module,
+			runtimeRequirements
+		);
+
+		const importedModule = moduleGraph.getModule(dep);
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+		if (importedModule) {
+			const ids = dep.getIds(moduleGraph);
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			}
+		}
+
+		switch (type) {
+			case "expression":
+				source.replace(
 					dep.range[0],
-					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
+					dep.range[1] - 1,
+					used
+						? `${base}${propertyAccess(used)} = ${requireExpr}`
+						: `/* unused reexport */ ${requireExpr}`
 				);
-				source.insert(dep.range[1], ") : null)");
 				return;
-			}
+			case "Object.defineProperty":
+				throw new Error("TODO");
+			default:
+				throw new Error("Unexpected type");
 		}
-
-		source.insert(
-			dep.range[0],
-			`(/* unused pure expression or super */ null && (`
-		);
-		source.insert(dep.range[1], "))");
 	}
 };
 
-module.exports = PureExpressionDependency;
+module.exports = CommonJsExportRequireDependency;
 
 
 /***/ }),
 
-/***/ 46917:
+/***/ 45598:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82290,275 +80088,164 @@ module.exports = PureExpressionDependency;
 
 
 
+const InitFragment = __webpack_require__(55870);
 const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
+const propertyAccess = __webpack_require__(54190);
+const { handleDependencyBase } = __webpack_require__(59643);
+const NullDependency = __webpack_require__(31830);
 
-class RequireContextDependency extends ContextDependency {
-	constructor(options, range) {
-		super(options);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+const EMPTY_OBJECT = {};
 
+class CommonJsExportsDependency extends NullDependency {
+	constructor(range, valueRange, base, names) {
+		super();
 		this.range = range;
+		this.valueRange = valueRange;
+		this.base = base;
+		this.names = names;
 	}
 
 	get type() {
-		return "require.context";
+		return "cjs exports";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.names[0];
+		return {
+			exports: [
+				{
+					name,
+					// we can't mangle names that are in an empty object
+					// because one could access the prototype property
+					// when export isn't set yet
+					canMangle: !(name in EMPTY_OBJECT)
+				}
+			],
+			dependencies: undefined
+		};
 	}
 
 	serialize(context) {
 		const { write } = context;
-
 		write(this.range);
-
+		write(this.valueRange);
+		write(this.base);
+		write(this.names);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-
 		this.range = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	RequireContextDependency,
-	"webpack/lib/dependencies/RequireContextDependency"
-);
-
-RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
-
-module.exports = RequireContextDependency;
-
-
-/***/ }),
-
-/***/ 18851:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RequireContextDependency = __webpack_require__(46917);
-
-module.exports = class RequireContextDependencyParserPlugin {
-	apply(parser) {
-		parser.hooks.call
-			.for("require.context")
-			.tap("RequireContextDependencyParserPlugin", expr => {
-				let regExp = /^\.\/.*$/;
-				let recursive = true;
-				let mode = "sync";
-				switch (expr.arguments.length) {
-					case 4: {
-						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!modeExpr.isString()) return;
-						mode = modeExpr.string;
-					}
-					// falls through
-					case 3: {
-						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
-						if (!regExpExpr.isRegExp()) return;
-						regExp = regExpExpr.regExp;
-					}
-					// falls through
-					case 2: {
-						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
-						if (!recursiveExpr.isBoolean()) return;
-						recursive = recursiveExpr.bool;
-					}
-					// falls through
-					case 1: {
-						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
-						if (!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(
-							{
-								request: requestExpr.string,
-								recursive,
-								regExp,
-								mode,
-								category: "commonjs"
-							},
-							expr.range
-						);
-						dep.loc = expr.loc;
-						dep.optional = !!parser.scope.inTry;
-						parser.state.current.addDependency(dep);
-						return true;
-					}
-				}
-			});
-	}
-};
-
-
-/***/ }),
-
-/***/ 2928:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { cachedSetProperty } = __webpack_require__(60839);
-const ContextElementDependency = __webpack_require__(58477);
-const RequireContextDependency = __webpack_require__(46917);
-const RequireContextDependencyParserPlugin = __webpack_require__(18851);
-
-/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../Compiler")} Compiler */
-
-/** @type {ResolveOptions} */
-const EMPTY_RESOLVE_OPTIONS = {};
-
-class RequireContextPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireContextPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RequireContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireContextDependency,
-					new RequireContextDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					ContextElementDependency,
-					normalModuleFactory
-				);
-
-				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.requireContext !== undefined &&
-						!parserOptions.requireContext
-					)
-						return;
-
-					new RequireContextDependencyParserPlugin().apply(parser);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireContextPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireContextPlugin", handler);
-
-				contextModuleFactory.hooks.alternativeRequests.tap(
-					"RequireContextPlugin",
-					(items, options) => {
-						if (items.length === 0) return items;
-
-						const finalResolveOptions = compiler.resolverFactory.get(
-							"normal",
-							cachedSetProperty(
-								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
-								"dependencyType",
-								options.category
-							)
-						).options;
-
-						let newItems;
-						if (!finalResolveOptions.fullySpecified) {
-							newItems = [];
-							for (const item of items) {
-								const { request, context } = item;
-								for (const ext of finalResolveOptions.extensions) {
-									if (request.endsWith(ext)) {
-										newItems.push({
-											context,
-											request: request.slice(0, -ext.length)
-										});
-									}
-								}
-								if (!finalResolveOptions.enforceExtension) {
-									newItems.push(item);
-								}
-							}
-							items = newItems;
-
-							newItems = [];
-							for (const obj of items) {
-								const { request, context } = obj;
-								for (const mainFile of finalResolveOptions.mainFiles) {
-									if (request.endsWith(`/${mainFile}`)) {
-										newItems.push({
-											context,
-											request: request.slice(0, -mainFile.length)
-										});
-										newItems.push({
-											context,
-											request: request.slice(0, -mainFile.length - 1)
-										});
-									}
-								}
-								newItems.push(obj);
-							}
-							items = newItems;
-						}
-
-						newItems = [];
-						for (const item of items) {
-							let hideOriginal = false;
-							for (const modulesItems of finalResolveOptions.modules) {
-								if (Array.isArray(modulesItems)) {
-									for (const dir of modulesItems) {
-										if (item.request.startsWith(`./${dir}/`)) {
-											newItems.push({
-												context: item.context,
-												request: item.request.slice(dir.length + 3)
-											});
-											hideOriginal = true;
-										}
-									}
-								} else {
-									const dir = modulesItems.replace(/\\/g, "/");
-									const fullPath =
-										item.context.replace(/\\/g, "/") + item.request.slice(1);
-									if (fullPath.startsWith(dir)) {
-										newItems.push({
-											context: item.context,
-											request: fullPath.slice(dir.length + 1)
-										});
-									}
-								}
-							}
-							if (!hideOriginal) {
-								newItems.push(item);
-							}
-						}
-						return newItems;
-					}
-				);
-			}
-		);
+		this.valueRange = read();
+		this.base = read();
+		this.names = read();
+		super.deserialize(context);
 	}
 }
-module.exports = RequireContextPlugin;
+
+makeSerializable(
+	CommonJsExportsDependency,
+	"webpack/lib/dependencies/CommonJsExportsDependency"
+);
+
+CommonJsExportsDependency.Template = class CommonJsExportsDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, initFragments, runtimeRequirements, runtime }
+	) {
+		const dep = /** @type {CommonJsExportsDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.names, runtime);
+
+		const [type, base] = handleDependencyBase(
+			dep.base,
+			module,
+			runtimeRequirements
+		);
+
+		switch (type) {
+			case "expression":
+				if (!used) {
+					initFragments.push(
+						new InitFragment(
+							"var __webpack_unused_export__;\n",
+							InitFragment.STAGE_CONSTANTS,
+							0,
+							"__webpack_unused_export__"
+						)
+					);
+					source.replace(
+						dep.range[0],
+						dep.range[1] - 1,
+						"__webpack_unused_export__"
+					);
+					return;
+				}
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					`${base}${propertyAccess(used)}`
+				);
+				return;
+			case "Object.defineProperty":
+				if (!used) {
+					initFragments.push(
+						new InitFragment(
+							"var __webpack_unused_export__;\n",
+							InitFragment.STAGE_CONSTANTS,
+							0,
+							"__webpack_unused_export__"
+						)
+					);
+					source.replace(
+						dep.range[0],
+						dep.valueRange[0] - 1,
+						"__webpack_unused_export__ = ("
+					);
+					source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+					return;
+				}
+				source.replace(
+					dep.range[0],
+					dep.valueRange[0] - 1,
+					`Object.defineProperty(${base}${propertyAccess(
+						used.slice(0, -1)
+					)}, ${JSON.stringify(used[used.length - 1])}, (`
+				);
+				source.replace(dep.valueRange[1], dep.range[1] - 1, "))");
+				return;
+		}
+	}
+};
+
+module.exports = CommonJsExportsDependency;
 
 
 /***/ }),
 
-/***/ 27153:
+/***/ 97107:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82569,155 +80256,340 @@ module.exports = RequireContextPlugin;
 
 
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const makeSerializable = __webpack_require__(33032);
-
-class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(chunkName, loc) {
-		super(chunkName, loc, null);
-	}
-}
-
-makeSerializable(
-	RequireEnsureDependenciesBlock,
-	"webpack/lib/dependencies/RequireEnsureDependenciesBlock"
-);
+const RuntimeGlobals = __webpack_require__(16475);
+const formatLocation = __webpack_require__(16734);
+const { evaluateToString } = __webpack_require__(93998);
+const propertyAccess = __webpack_require__(54190);
+const CommonJsExportRequireDependency = __webpack_require__(62892);
+const CommonJsExportsDependency = __webpack_require__(45598);
+const CommonJsSelfReferenceDependency = __webpack_require__(52225);
+const DynamicExports = __webpack_require__(32006);
+const HarmonyExports = __webpack_require__(39211);
+const ModuleDecoratorDependency = __webpack_require__(88488);
 
-module.exports = RequireEnsureDependenciesBlock;
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
+const getValueOfPropertyDescription = expr => {
+	if (expr.type !== "ObjectExpression") return;
+	for (const property of expr.properties) {
+		if (property.computed) continue;
+		const key = property.key;
+		if (key.type !== "Identifier" || key.name !== "value") continue;
+		return property.value;
+	}
+};
 
-/***/ }),
+const isTruthyLiteral = expr => {
+	switch (expr.type) {
+		case "Literal":
+			return !!expr.value;
+		case "UnaryExpression":
+			if (expr.operator === "!") return isFalsyLiteral(expr.argument);
+	}
+	return false;
+};
 
-/***/ 7235:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const isFalsyLiteral = expr => {
+	switch (expr.type) {
+		case "Literal":
+			return !expr.value;
+		case "UnaryExpression":
+			if (expr.operator === "!") return isTruthyLiteral(expr.argument);
+	}
+	return false;
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {ExpressionNode} expr expression
+ * @returns {{ argument: BasicEvaluatedExpression, ids: string[] } | undefined} parsed call
+ */
+const parseRequireCall = (parser, expr) => {
+	const ids = [];
+	while (expr.type === "MemberExpression") {
+		if (expr.object.type === "Super") return;
+		if (!expr.property) return;
+		const prop = expr.property;
+		if (expr.computed) {
+			if (prop.type !== "Literal") return;
+			ids.push(`${prop.value}`);
+		} else {
+			if (prop.type !== "Identifier") return;
+			ids.push(prop.name);
+		}
+		expr = expr.object;
+	}
+	if (expr.type !== "CallExpression" || expr.arguments.length !== 1) return;
+	const callee = expr.callee;
+	if (
+		callee.type !== "Identifier" ||
+		parser.getVariableInfo(callee.name) !== "require"
+	) {
+		return;
+	}
+	const arg = expr.arguments[0];
+	if (arg.type === "SpreadElement") return;
+	const argValue = parser.evaluateExpression(arg);
+	return { argument: argValue, ids: ids.reverse() };
+};
 
+class CommonJsExportsParserPlugin {
+	constructor(moduleGraph) {
+		this.moduleGraph = moduleGraph;
+	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 */
+	apply(parser) {
+		const enableStructuredExports = () => {
+			DynamicExports.enable(parser.state);
+		};
+		const checkNamespace = (topLevel, members, valueExpr) => {
+			if (!DynamicExports.isEnabled(parser.state)) return;
+			if (members.length > 0 && members[0] === "__esModule") {
+				if (valueExpr && isTruthyLiteral(valueExpr) && topLevel) {
+					DynamicExports.setFlagged(parser.state);
+				} else {
+					DynamicExports.setDynamic(parser.state);
+				}
+			}
+		};
+		const bailout = reason => {
+			DynamicExports.bailout(parser.state);
+			if (reason) bailoutHint(reason);
+		};
+		const bailoutHint = reason => {
+			this.moduleGraph
+				.getOptimizationBailout(parser.state.module)
+				.push(`CommonJS bailout: ${reason}`);
+		};
 
-const RequireEnsureDependenciesBlock = __webpack_require__(27153);
-const RequireEnsureDependency = __webpack_require__(27223);
-const RequireEnsureItemDependency = __webpack_require__(50329);
-const getFunctionExpression = __webpack_require__(50396);
+		// metadata //
+		parser.hooks.evaluateTypeof
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", evaluateToString("object"));
+		parser.hooks.evaluateTypeof
+			.for("exports")
+			.tap("CommonJsPlugin", evaluateToString("object"));
 
-module.exports = class RequireEnsureDependenciesBlockParserPlugin {
-	apply(parser) {
+		// exporting //
+		const handleAssignExport = (expr, base, members) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			// Handle reexporting
+			const requireCall = parseRequireCall(parser, expr.right);
+			if (
+				requireCall &&
+				requireCall.argument.isString() &&
+				(members.length === 0 || members[0] !== "__esModule")
+			) {
+				enableStructuredExports();
+				// It's possible to reexport __esModule, so we must convert to a dynamic module
+				if (members.length === 0) DynamicExports.setDynamic(parser.state);
+				const dep = new CommonJsExportRequireDependency(
+					expr.range,
+					null,
+					base,
+					members,
+					requireCall.argument.string,
+					requireCall.ids,
+					!parser.isStatementLevelExpression(expr)
+				);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.module.addDependency(dep);
+				return true;
+			}
+			if (members.length === 0) return;
+			enableStructuredExports();
+			const remainingMembers = members;
+			checkNamespace(
+				parser.statementPath.length === 1 &&
+					parser.isStatementLevelExpression(expr),
+				remainingMembers,
+				expr.right
+			);
+			const dep = new CommonJsExportsDependency(
+				expr.left.range,
+				null,
+				base,
+				remainingMembers
+			);
+			dep.loc = expr.loc;
+			parser.state.module.addDependency(dep);
+			parser.walkExpression(expr.right);
+			return true;
+		};
+		parser.hooks.assignMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				return handleAssignExport(expr, "exports", members);
+			});
+		parser.hooks.assignMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAssignExport(expr, "this", members);
+			});
+		parser.hooks.assignMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAssignExport(expr, "module.exports", members.slice(1));
+			});
 		parser.hooks.call
-			.for("require.ensure")
-			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
-				let chunkName = null;
-				let errorExpressionArg = null;
-				let errorExpression = null;
-				switch (expr.arguments.length) {
-					case 4: {
-						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!chunkNameExpr.isString()) return;
-						chunkName = chunkNameExpr.string;
-					}
-					// falls through
-					case 3: {
-						errorExpressionArg = expr.arguments[2];
-						errorExpression = getFunctionExpression(errorExpressionArg);
-
-						if (!errorExpression && !chunkName) {
-							const chunkNameExpr = parser.evaluateExpression(
-								expr.arguments[2]
-							);
-							if (!chunkNameExpr.isString()) return;
-							chunkName = chunkNameExpr.string;
-						}
-					}
-					// falls through
-					case 2: {
-						const dependenciesExpr = parser.evaluateExpression(
-							expr.arguments[0]
-						);
-						const dependenciesItems = dependenciesExpr.isArray()
-							? dependenciesExpr.items
-							: [dependenciesExpr];
-						const successExpressionArg = expr.arguments[1];
-						const successExpression =
-							getFunctionExpression(successExpressionArg);
+			.for("Object.defineProperty")
+			.tap("CommonJsExportsParserPlugin", expression => {
+				const expr = /** @type {import("estree").CallExpression} */ (
+					expression
+				);
+				if (!parser.isStatementLevelExpression(expr)) return;
+				if (expr.arguments.length !== 3) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				if (expr.arguments[1].type === "SpreadElement") return;
+				if (expr.arguments[2].type === "SpreadElement") return;
+				const exportsArg = parser.evaluateExpression(expr.arguments[0]);
+				if (!exportsArg || !exportsArg.isIdentifier()) return;
+				if (
+					exportsArg.identifier !== "exports" &&
+					exportsArg.identifier !== "module.exports" &&
+					(exportsArg.identifier !== "this" || !parser.scope.topLevelScope)
+				) {
+					return;
+				}
+				const propertyArg = parser.evaluateExpression(expr.arguments[1]);
+				if (!propertyArg) return;
+				const property = propertyArg.asString();
+				if (typeof property !== "string") return;
+				enableStructuredExports();
+				const descArg = expr.arguments[2];
+				checkNamespace(
+					parser.statementPath.length === 1,
+					[property],
+					getValueOfPropertyDescription(descArg)
+				);
+				const dep = new CommonJsExportsDependency(
+					expr.range,
+					expr.arguments[2].range,
+					`Object.defineProperty(${exportsArg.identifier})`,
+					[property]
+				);
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
 
-						if (successExpression) {
-							parser.walkExpressions(successExpression.expressions);
-						}
-						if (errorExpression) {
-							parser.walkExpressions(errorExpression.expressions);
-						}
+				parser.walkExpression(expr.arguments[2]);
+				return true;
+			});
 
-						const depBlock = new RequireEnsureDependenciesBlock(
-							chunkName,
-							expr.loc
-						);
-						const errorCallbackExists =
-							expr.arguments.length === 4 ||
-							(!chunkName && expr.arguments.length === 3);
-						const dep = new RequireEnsureDependency(
-							expr.range,
-							expr.arguments[1].range,
-							errorCallbackExists && expr.arguments[2].range
-						);
-						dep.loc = expr.loc;
-						depBlock.addDependency(dep);
-						const old = parser.state.current;
-						parser.state.current = depBlock;
-						try {
-							let failed = false;
-							parser.inScope([], () => {
-								for (const ee of dependenciesItems) {
-									if (ee.isString()) {
-										const ensureDependency = new RequireEnsureItemDependency(
-											ee.string
-										);
-										ensureDependency.loc = ee.loc || expr.loc;
-										depBlock.addDependency(ensureDependency);
-									} else {
-										failed = true;
-									}
-								}
-							});
-							if (failed) {
-								return;
-							}
-							if (successExpression) {
-								if (successExpression.fn.body.type === "BlockStatement") {
-									parser.walkStatement(successExpression.fn.body);
-								} else {
-									parser.walkExpression(successExpression.fn.body);
-								}
-							}
-							old.addBlock(depBlock);
-						} finally {
-							parser.state.current = old;
-						}
-						if (!successExpression) {
-							parser.walkExpression(successExpressionArg);
-						}
-						if (errorExpression) {
-							if (errorExpression.fn.body.type === "BlockStatement") {
-								parser.walkStatement(errorExpression.fn.body);
-							} else {
-								parser.walkExpression(errorExpression.fn.body);
-							}
-						} else if (errorExpressionArg) {
-							parser.walkExpression(errorExpressionArg);
-						}
-						return true;
-					}
-				}
+		// Self reference //
+		const handleAccessExport = (expr, base, members, call = undefined) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			if (members.length === 0) {
+				bailout(`${base} is used directly at ${formatLocation(expr.loc)}`);
+			}
+			if (call && members.length === 1) {
+				bailoutHint(
+					`${base}${propertyAccess(
+						members
+					)}(...) prevents optimization as ${base} is passed as call context at ${formatLocation(
+						expr.loc
+					)}`
+				);
+			}
+			const dep = new CommonJsSelfReferenceDependency(
+				expr.range,
+				base,
+				members,
+				!!call
+			);
+			dep.loc = expr.loc;
+			parser.state.module.addDependency(dep);
+			if (call) {
+				parser.walkExpressions(call.arguments);
+			}
+			return true;
+		};
+		parser.hooks.callMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				return handleAccessExport(expr.callee, "exports", members, expr);
+			});
+		parser.hooks.expressionMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				return handleAccessExport(expr, "exports", members);
+			});
+		parser.hooks.expression
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				return handleAccessExport(expr, "exports", []);
+			});
+		parser.hooks.callMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAccessExport(
+					expr.callee,
+					"module.exports",
+					members.slice(1),
+					expr
+				);
+			});
+		parser.hooks.expressionMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAccessExport(expr, "module.exports", members.slice(1));
+			});
+		parser.hooks.expression
+			.for("module.exports")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				return handleAccessExport(expr, "module.exports", []);
+			});
+		parser.hooks.callMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr.callee, "this", members, expr);
+			});
+		parser.hooks.expressionMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr, "this", members);
 			});
+		parser.hooks.expression
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr, "this", []);
+			});
+
+		// Bailouts //
+		parser.hooks.expression.for("module").tap("CommonJsPlugin", expr => {
+			bailout();
+			const isHarmony = HarmonyExports.isEnabled(parser.state);
+			const dep = new ModuleDecoratorDependency(
+				isHarmony
+					? RuntimeGlobals.harmonyModuleDecorator
+					: RuntimeGlobals.nodeModuleDecorator,
+				!isHarmony
+			);
+			dep.loc = expr.loc;
+			parser.state.module.addDependency(dep);
+			return true;
+		});
 	}
-};
+}
+module.exports = CommonJsExportsParserPlugin;
 
 
 /***/ }),
 
-/***/ 27223:
+/***/ 59440:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82728,56 +80600,79 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const { equals } = __webpack_require__(84953);
 const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const propertyAccess = __webpack_require__(54190);
+const ModuleDependency = __webpack_require__(80321);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class RequireEnsureDependency extends NullDependency {
-	constructor(range, contentRange, errorHandlerRange) {
-		super();
-
+class CommonJsFullRequireDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {[number, number]} range location in source code
+	 * @param {string[]} names accessed properties on module
+	 */
+	constructor(request, range, names) {
+		super(request);
 		this.range = range;
-		this.contentRange = contentRange;
-		this.errorHandlerRange = errorHandlerRange;
+		this.names = names;
+		this.call = false;
+		this.asiSafe = undefined;
 	}
 
-	get type() {
-		return "require.ensure";
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (this.call) {
+			const importedModule = moduleGraph.getModule(this);
+			if (
+				!importedModule ||
+				importedModule.getExportsType(moduleGraph, false) !== "namespace"
+			) {
+				return [this.names.slice(0, -1)];
+			}
+		}
+		return [this.names];
 	}
 
 	serialize(context) {
 		const { write } = context;
-
-		write(this.range);
-		write(this.contentRange);
-		write(this.errorHandlerRange);
-
+		write(this.names);
+		write(this.call);
+		write(this.asiSafe);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
+		this.names = read();
+		this.call = read();
+		this.asiSafe = read();
+		super.deserialize(context);
+	}
 
-		this.range = read();
-		this.contentRange = read();
-		this.errorHandlerRange = read();
+	get type() {
+		return "cjs full require";
+	}
 
-		super.deserialize(context);
+	get category() {
+		return "commonjs";
 	}
 }
 
-makeSerializable(
-	RequireEnsureDependency,
-	"webpack/lib/dependencies/RequireEnsureDependency"
-);
-
-RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate extends (
-	NullDependency.Template
+CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemplate extends (
+	ModuleDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -82788,45 +80683,57 @@ RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate extends
 	apply(
 		dependency,
 		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+		{
+			module,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime,
+			initFragments
+		}
 	) {
-		const dep = /** @type {RequireEnsureDependency} */ (dependency);
-		const depBlock = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dep)
-		);
-		const promise = runtimeTemplate.blockPromise({
+		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
+		if (!dep.range) return;
+		const importedModule = moduleGraph.getModule(dep);
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
 			chunkGraph,
-			block: depBlock,
-			message: "require.ensure",
+			request: dep.request,
+			weak: dep.weak,
 			runtimeRequirements
 		});
-		const range = dep.range;
-		const contentRange = dep.contentRange;
-		const errorHandlerRange = dep.errorHandlerRange;
-		source.replace(range[0], contentRange[0] - 1, `${promise}.then((`);
-		if (errorHandlerRange) {
-			source.replace(
-				contentRange[1],
-				errorHandlerRange[0] - 1,
-				").bind(null, __webpack_require__))['catch']("
-			);
-			source.replace(errorHandlerRange[1], range[1] - 1, ")");
-		} else {
-			source.replace(
-				contentRange[1],
-				range[1] - 1,
-				`).bind(null, __webpack_require__))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`
-			);
+		if (importedModule) {
+			const ids = dep.names;
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				const access = `${comment}${propertyAccess(usedImported)}`;
+				requireExpr =
+					dep.asiSafe === true
+						? `(${requireExpr}${access})`
+						: `${requireExpr}${access}`;
+			}
 		}
+		source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
 	}
 };
 
-module.exports = RequireEnsureDependency;
+makeSerializable(
+	CommonJsFullRequireDependency,
+	"webpack/lib/dependencies/CommonJsFullRequireDependency"
+);
+
+module.exports = CommonJsFullRequireDependency;
 
 
 /***/ }),
 
-/***/ 50329:
+/***/ 36013:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82837,37 +80744,392 @@ module.exports = RequireEnsureDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const NullDependency = __webpack_require__(31830);
+const CommentCompilationWarning = __webpack_require__(98427);
+const RuntimeGlobals = __webpack_require__(16475);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const {
+	evaluateToIdentifier,
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = __webpack_require__(93998);
+const CommonJsFullRequireDependency = __webpack_require__(59440);
+const CommonJsRequireContextDependency = __webpack_require__(23962);
+const CommonJsRequireDependency = __webpack_require__(21264);
+const ConstDependency = __webpack_require__(76911);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const LocalModuleDependency = __webpack_require__(52805);
+const { getLocalModule } = __webpack_require__(75827);
+const RequireHeaderDependency = __webpack_require__(89183);
+const RequireResolveContextDependency = __webpack_require__(55627);
+const RequireResolveDependency = __webpack_require__(68582);
+const RequireResolveHeaderDependency = __webpack_require__(9880);
 
-class RequireEnsureItemDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 
-	get type() {
-		return "require.ensure item";
+class CommonJsImportsParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parser options
+	 */
+	constructor(options) {
+		this.options = options;
 	}
 
-	get category() {
-		return "commonjs";
+	apply(parser) {
+		const options = this.options;
+
+		// metadata //
+		const tapRequireExpression = (expression, getMembers) => {
+			parser.hooks.typeof
+				.for(expression)
+				.tap(
+					"CommonJsPlugin",
+					toConstantDependency(parser, JSON.stringify("function"))
+				);
+			parser.hooks.evaluateTypeof
+				.for(expression)
+				.tap("CommonJsPlugin", evaluateToString("function"));
+			parser.hooks.evaluateIdentifier
+				.for(expression)
+				.tap(
+					"CommonJsPlugin",
+					evaluateToIdentifier(expression, "require", getMembers, true)
+				);
+		};
+		tapRequireExpression("require", () => []);
+		tapRequireExpression("require.resolve", () => ["resolve"]);
+		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
+
+		// Weird stuff //
+		parser.hooks.assign.for("require").tap("CommonJsPlugin", expr => {
+			// to not leak to global "require", we need to define a local require here.
+			const dep = new ConstDependency("var require;", 0);
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		});
+
+		// Unsupported //
+		parser.hooks.expression
+			.for("require.main.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"require.main.require is not supported by webpack."
+				)
+			);
+		parser.hooks.call
+			.for("require.main.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"require.main.require is not supported by webpack."
+				)
+			);
+		parser.hooks.expression
+			.for("module.parent.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"module.parent.require is not supported by webpack."
+				)
+			);
+		parser.hooks.call
+			.for("module.parent.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"module.parent.require is not supported by webpack."
+				)
+			);
+
+		// renaming //
+		parser.hooks.canRename.for("require").tap("CommonJsPlugin", () => true);
+		parser.hooks.rename.for("require").tap("CommonJsPlugin", expr => {
+			// To avoid "not defined" error, replace the value with undefined
+			const dep = new ConstDependency("undefined", expr.range);
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return false;
+		});
+
+		// inspection //
+		parser.hooks.expression
+			.for("require.cache")
+			.tap(
+				"CommonJsImportsParserPlugin",
+				toConstantDependency(parser, RuntimeGlobals.moduleCache, [
+					RuntimeGlobals.moduleCache,
+					RuntimeGlobals.moduleId,
+					RuntimeGlobals.moduleLoaded
+				])
+			);
+
+		// require as expression //
+		parser.hooks.expression
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", expr => {
+				const dep = new CommonJsRequireContextDependency(
+					{
+						request: options.unknownContextRequest,
+						recursive: options.unknownContextRecursive,
+						regExp: options.unknownContextRegExp,
+						mode: "sync"
+					},
+					expr.range,
+					undefined,
+					parser.scope.inShorthand
+				);
+				dep.critical =
+					options.unknownContextCritical &&
+					"require function is used in a way in which dependencies cannot be statically extracted";
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			});
+
+		// require //
+		const processRequireItem = (expr, param) => {
+			if (param.isString()) {
+				const dep = new CommonJsRequireDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		const processRequireContext = (expr, param) => {
+			const dep = ContextDependencyHelpers.create(
+				CommonJsRequireContextDependency,
+				expr.range,
+				param,
+				expr,
+				options,
+				{
+					category: "commonjs"
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
+			return true;
+		};
+		const createRequireHandler = callNew => expr => {
+			if (options.commonjsMagicComments) {
+				const { options: requireOptions, errors: commentErrors } =
+					parser.parseCommentOptions(expr.range);
+
+				if (commentErrors) {
+					for (const e of commentErrors) {
+						const { comment } = e;
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								comment.loc
+							)
+						);
+					}
+				}
+				if (requireOptions) {
+					if (requireOptions.webpackIgnore !== undefined) {
+						if (typeof requireOptions.webpackIgnore !== "boolean") {
+							parser.state.module.addWarning(
+								new UnsupportedFeatureWarning(
+									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+									expr.loc
+								)
+							);
+						} else {
+							// Do not instrument `require()` if `webpackIgnore` is `true`
+							if (requireOptions.webpackIgnore) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+
+			if (expr.arguments.length !== 1) return;
+			let localModule;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (param.isConditional()) {
+				let isExpression = false;
+				for (const p of param.options) {
+					const result = processRequireItem(expr, p);
+					if (result === undefined) {
+						isExpression = true;
+					}
+				}
+				if (!isExpression) {
+					const dep = new RequireHeaderDependency(expr.callee.range);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+					return true;
+				}
+			}
+			if (
+				param.isString() &&
+				(localModule = getLocalModule(parser.state, param.string))
+			) {
+				localModule.flagUsed();
+				const dep = new LocalModuleDependency(localModule, expr.range, callNew);
+				dep.loc = expr.loc;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			} else {
+				const result = processRequireItem(expr, param);
+				if (result === undefined) {
+					processRequireContext(expr, param);
+				} else {
+					const dep = new RequireHeaderDependency(expr.callee.range);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				}
+				return true;
+			}
+		};
+		parser.hooks.call
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		parser.hooks.new
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
+		parser.hooks.call
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		parser.hooks.new
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
+
+		// require with property access //
+		const chainHandler = (expr, calleeMembers, callExpr, members) => {
+			if (callExpr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(callExpr.arguments[0]);
+			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+				const dep = new CommonJsFullRequireDependency(
+					param.string,
+					expr.range,
+					members
+				);
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.optional = !!parser.scope.inTry;
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		const callChainHandler = (expr, calleeMembers, callExpr, members) => {
+			if (callExpr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(callExpr.arguments[0]);
+			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+				const dep = new CommonJsFullRequireDependency(
+					param.string,
+					expr.callee.range,
+					members
+				);
+				dep.call = true;
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.optional = !!parser.scope.inTry;
+				dep.loc = expr.callee.loc;
+				parser.state.current.addDependency(dep);
+				parser.walkExpressions(expr.arguments);
+				return true;
+			}
+		};
+		parser.hooks.memberChainOfCallMemberChain
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", chainHandler);
+		parser.hooks.memberChainOfCallMemberChain
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", chainHandler);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", callChainHandler);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", callChainHandler);
+
+		// require.resolve //
+		const processResolve = (expr, weak) => {
+			if (expr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (param.isConditional()) {
+				for (const option of param.options) {
+					const result = processResolveItem(expr, option, weak);
+					if (result === undefined) {
+						processResolveContext(expr, option, weak);
+					}
+				}
+				const dep = new RequireResolveHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			} else {
+				const result = processResolveItem(expr, param, weak);
+				if (result === undefined) {
+					processResolveContext(expr, param, weak);
+				}
+				const dep = new RequireResolveHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		};
+		const processResolveItem = (expr, param, weak) => {
+			if (param.isString()) {
+				const dep = new RequireResolveDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				dep.weak = weak;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		const processResolveContext = (expr, param, weak) => {
+			const dep = ContextDependencyHelpers.create(
+				RequireResolveContextDependency,
+				param.range,
+				param,
+				expr,
+				options,
+				{
+					category: "commonjs",
+					mode: weak ? "weak" : "sync"
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
+			return true;
+		};
+
+		parser.hooks.call
+			.for("require.resolve")
+			.tap("RequireResolveDependencyParserPlugin", expr => {
+				return processResolve(expr, false);
+			});
+		parser.hooks.call
+			.for("require.resolveWeak")
+			.tap("RequireResolveDependencyParserPlugin", expr => {
+				return processResolve(expr, true);
+			});
 	}
 }
-
-makeSerializable(
-	RequireEnsureItemDependency,
-	"webpack/lib/dependencies/RequireEnsureItemDependency"
-);
-
-RequireEnsureItemDependency.Template = NullDependency.Template;
-
-module.exports = RequireEnsureItemDependency;
+module.exports = CommonJsImportsParserPlugin;
 
 
 /***/ }),
 
-/***/ 8434:
+/***/ 32406:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82878,352 +81140,284 @@ module.exports = RequireEnsureItemDependency;
 
 
 
-const RequireEnsureDependency = __webpack_require__(27223);
-const RequireEnsureItemDependency = __webpack_require__(50329);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const SelfModuleFactory = __webpack_require__(63560);
+const Template = __webpack_require__(39722);
+const CommonJsExportsDependency = __webpack_require__(45598);
+const CommonJsFullRequireDependency = __webpack_require__(59440);
+const CommonJsRequireContextDependency = __webpack_require__(23962);
+const CommonJsRequireDependency = __webpack_require__(21264);
+const CommonJsSelfReferenceDependency = __webpack_require__(52225);
+const ModuleDecoratorDependency = __webpack_require__(88488);
+const RequireHeaderDependency = __webpack_require__(89183);
+const RequireResolveContextDependency = __webpack_require__(55627);
+const RequireResolveDependency = __webpack_require__(68582);
+const RequireResolveHeaderDependency = __webpack_require__(9880);
+const RuntimeRequirementsDependency = __webpack_require__(24187);
 
-const RequireEnsureDependenciesBlockParserPlugin = __webpack_require__(7235);
+const CommonJsExportsParserPlugin = __webpack_require__(97107);
+const CommonJsImportsParserPlugin = __webpack_require__(36013);
 
 const {
-	evaluateToString,
+	evaluateToIdentifier,
 	toConstantDependency
 } = __webpack_require__(93998);
+const CommonJsExportRequireDependency = __webpack_require__(62892);
 
-class RequireEnsurePlugin {
+class CommonJsPlugin {
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"RequireEnsurePlugin",
-			(compilation, { normalModuleFactory }) => {
+			"CommonJsPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
-					RequireEnsureItemDependency,
+					CommonJsRequireDependency,
 					normalModuleFactory
 				);
 				compilation.dependencyTemplates.set(
-					RequireEnsureItemDependency,
-					new RequireEnsureItemDependency.Template()
+					CommonJsRequireDependency,
+					new CommonJsRequireDependency.Template()
 				);
 
+				compilation.dependencyFactories.set(
+					CommonJsFullRequireDependency,
+					normalModuleFactory
+				);
 				compilation.dependencyTemplates.set(
-					RequireEnsureDependency,
-					new RequireEnsureDependency.Template()
+					CommonJsFullRequireDependency,
+					new CommonJsFullRequireDependency.Template()
 				);
 
-				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.requireEnsure !== undefined &&
-						!parserOptions.requireEnsure
-					)
-						return;
-
-					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);
-					parser.hooks.evaluateTypeof
-						.for("require.ensure")
-						.tap("RequireEnsurePlugin", evaluateToString("function"));
-					parser.hooks.typeof
-						.for("require.ensure")
-						.tap(
-							"RequireEnsurePlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireEnsurePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireEnsurePlugin", handler);
-			}
-		);
-	}
-}
-module.exports = RequireEnsurePlugin;
-
-
-/***/ }),
-
-/***/ 89183:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-
-class RequireHeaderDependency extends NullDependency {
-	constructor(range) {
-		super();
-		if (!Array.isArray(range)) throw new Error("range must be valid");
-		this.range = range;
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const obj = new RequireHeaderDependency(context.read());
-		obj.deserialize(context);
-		return obj;
-	}
-}
-
-makeSerializable(
-	RequireHeaderDependency,
-	"webpack/lib/dependencies/RequireHeaderDependency"
-);
-
-RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {RequireHeaderDependency} */ (dependency);
-		runtimeRequirements.add(RuntimeGlobals.require);
-		source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__");
-	}
-};
-
-module.exports = RequireHeaderDependency;
-
-
-/***/ }),
-
-/***/ 71284:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Dependency = __webpack_require__(54912);
-const Template = __webpack_require__(1626);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class RequireIncludeDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+				compilation.dependencyFactories.set(
+					CommonJsRequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsRequireContextDependency,
+					new CommonJsRequireContextDependency.Template()
+				);
 
-		this.range = range;
-	}
+				compilation.dependencyFactories.set(
+					RequireResolveDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireResolveDependency,
+					new RequireResolveDependency.Template()
+				);
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		// This doesn't use any export
-		return Dependency.NO_EXPORTS_REFERENCED;
-	}
+				compilation.dependencyFactories.set(
+					RequireResolveContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireResolveContextDependency,
+					new RequireResolveContextDependency.Template()
+				);
 
-	get type() {
-		return "require.include";
-	}
+				compilation.dependencyTemplates.set(
+					RequireResolveHeaderDependency,
+					new RequireResolveHeaderDependency.Template()
+				);
 
-	get category() {
-		return "commonjs";
-	}
-}
+				compilation.dependencyTemplates.set(
+					RequireHeaderDependency,
+					new RequireHeaderDependency.Template()
+				);
 
-makeSerializable(
-	RequireIncludeDependency,
-	"webpack/lib/dependencies/RequireIncludeDependency"
-);
+				compilation.dependencyTemplates.set(
+					CommonJsExportsDependency,
+					new CommonJsExportsDependency.Template()
+				);
 
-RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeTemplate }) {
-		const dep = /** @type {RequireIncludeDependency} */ (dependency);
-		const comment = runtimeTemplate.outputOptions.pathinfo
-			? Template.toComment(
-					`require.include ${runtimeTemplate.requestShortener.shorten(
-						dep.request
-					)}`
-			  )
-			: "";
+				compilation.dependencyFactories.set(
+					CommonJsExportRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsExportRequireDependency,
+					new CommonJsExportRequireDependency.Template()
+				);
 
-		source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`);
-	}
-};
+				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
 
-module.exports = RequireIncludeDependency;
+				compilation.dependencyFactories.set(
+					CommonJsSelfReferenceDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsSelfReferenceDependency,
+					new CommonJsSelfReferenceDependency.Template()
+				);
 
+				compilation.dependencyFactories.set(
+					ModuleDecoratorDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleDecoratorDependency,
+					new ModuleDecoratorDependency.Template()
+				);
 
-/***/ }),
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap("CommonJsPlugin", (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
 
-/***/ 35768:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap("CommonJsPlugin", (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap("CommonJsPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new HarmonyModuleDecoratorRuntimeModule()
+						);
+					});
 
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap("CommonJsPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new NodeModuleDecoratorRuntimeModule()
+						);
+					});
 
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.commonjs !== undefined && !parserOptions.commonjs)
+						return;
+					parser.hooks.typeof
+						.for("module")
+						.tap(
+							"CommonJsPlugin",
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
 
-const WebpackError = __webpack_require__(53799);
-const {
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
-const makeSerializable = __webpack_require__(33032);
-const RequireIncludeDependency = __webpack_require__(71284);
+					parser.hooks.expression
+						.for("require.main")
+						.tap(
+							"CommonJsPlugin",
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`,
+								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
+							)
+						);
+					parser.hooks.expression
+						.for("module.loaded")
+						.tap("CommonJsPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"module.loaded";
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleLoaded
+							]);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
-module.exports = class RequireIncludeDependencyParserPlugin {
-	constructor(warn) {
-		this.warn = warn;
-	}
-	apply(parser) {
-		const { warn } = this;
-		parser.hooks.call
-			.for("require.include")
-			.tap("RequireIncludeDependencyParserPlugin", expr => {
-				if (expr.arguments.length !== 1) return;
-				const param = parser.evaluateExpression(expr.arguments[0]);
-				if (!param.isString()) return;
+					parser.hooks.expression
+						.for("module.id")
+						.tap("CommonJsPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"module.id";
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleId
+							]);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
+					parser.hooks.evaluateIdentifier.for("module.hot").tap(
+						"CommonJsPlugin",
+						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
 					);
-				}
 
-				const dep = new RequireIncludeDependency(param.string, expr.range);
-				dep.loc = expr.loc;
-				parser.state.current.addDependency(dep);
-				return true;
-			});
-		parser.hooks.evaluateTypeof
-			.for("require.include")
-			.tap("RequireIncludePlugin", expr => {
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
-					);
-				}
-				return evaluateToString("function")(expr);
-			});
-		parser.hooks.typeof
-			.for("require.include")
-			.tap("RequireIncludePlugin", expr => {
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
+					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
+					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
+						parser
 					);
-				}
-				return toConstantDependency(parser, JSON.stringify("function"))(expr);
-			});
-	}
-};
-
-class RequireIncludeDeprecationWarning extends WebpackError {
-	constructor(loc) {
-		super("require.include() is deprecated and will be removed soon.");
-
-		this.name = "RequireIncludeDeprecationWarning";
-
-		this.loc = loc;
-	}
-}
-
-makeSerializable(
-	RequireIncludeDeprecationWarning,
-	"webpack/lib/dependencies/RequireIncludeDependencyParserPlugin",
-	"RequireIncludeDeprecationWarning"
-);
-
-
-/***/ }),
-
-/***/ 37378:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RequireIncludeDependency = __webpack_require__(71284);
-const RequireIncludeDependencyParserPlugin = __webpack_require__(35768);
-
-class RequireIncludePlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireIncludePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RequireIncludeDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireIncludeDependency,
-					new RequireIncludeDependency.Template()
-				);
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.requireInclude === false) return;
-					const warn = parserOptions.requireInclude === undefined;
-
-					new RequireIncludeDependencyParserPlugin(warn).apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser
 					.for("javascript/auto")
-					.tap("RequireIncludePlugin", handler);
+					.tap("CommonJsPlugin", handler);
 				normalModuleFactory.hooks.parser
 					.for("javascript/dynamic")
-					.tap("RequireIncludePlugin", handler);
+					.tap("CommonJsPlugin", handler);
 			}
 		);
 	}
 }
-module.exports = RequireIncludePlugin;
+
+class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("harmony module decorator");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${
+				RuntimeGlobals.harmonyModuleDecorator
+			} = ${runtimeTemplate.basicFunction("module", [
+				"module = Object.create(module);",
+				"if (!module.children) module.children = [];",
+				"Object.defineProperty(module, 'exports', {",
+				Template.indent([
+					"enumerable: true,",
+					`set: ${runtimeTemplate.basicFunction("", [
+						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
+					])}`
+				]),
+				"});",
+				"return module;"
+			])};`
+		]);
+	}
+}
+
+class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("node module decorator");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
+				"module",
+				[
+					"module.paths = [];",
+					"if (!module.children) module.children = [];",
+					"return module;"
+				]
+			)};`
+		]);
+	}
+}
+
+module.exports = CommonJsPlugin;
 
 
 /***/ }),
 
-/***/ 55627:
+/***/ 23962:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83236,18 +81430,20 @@ module.exports = RequireIncludePlugin;
 
 const makeSerializable = __webpack_require__(33032);
 const ContextDependency = __webpack_require__(88101);
-const ContextDependencyTemplateAsId = __webpack_require__(76081);
+const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
 
-class RequireResolveContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
+class CommonJsRequireContextDependency extends ContextDependency {
+	constructor(options, range, valueRange, inShorthand) {
 		super(options);
 
 		this.range = range;
 		this.valueRange = valueRange;
+		// inShorthand must be serialized by subclasses that use it
+		this.inShorthand = inShorthand;
 	}
 
 	get type() {
-		return "amd require context";
+		return "cjs require context";
 	}
 
 	serialize(context) {
@@ -83255,6 +81451,7 @@ class RequireResolveContextDependency extends ContextDependency {
 
 		write(this.range);
 		write(this.valueRange);
+		write(this.inShorthand);
 
 		super.serialize(context);
 	}
@@ -83264,24 +81461,26 @@ class RequireResolveContextDependency extends ContextDependency {
 
 		this.range = read();
 		this.valueRange = read();
+		this.inShorthand = read();
 
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	RequireResolveContextDependency,
-	"webpack/lib/dependencies/RequireResolveContextDependency"
+	CommonJsRequireContextDependency,
+	"webpack/lib/dependencies/CommonJsRequireContextDependency"
 );
 
-RequireResolveContextDependency.Template = ContextDependencyTemplateAsId;
+CommonJsRequireContextDependency.Template =
+	ContextDependencyTemplateAsRequireCall;
 
-module.exports = RequireResolveContextDependency;
+module.exports = CommonJsRequireContextDependency;
 
 
 /***/ }),
 
-/***/ 68582:
+/***/ 21264:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83292,55 +81491,38 @@ module.exports = RequireResolveContextDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
 const makeSerializable = __webpack_require__(33032);
 const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyAsId = __webpack_require__(80825);
-
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-class RequireResolveDependency extends ModuleDependency {
+class CommonJsRequireDependency extends ModuleDependency {
 	constructor(request, range) {
 		super(request);
-
 		this.range = range;
 	}
 
 	get type() {
-		return "require.resolve";
+		return "cjs require";
 	}
 
 	get category() {
 		return "commonjs";
 	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		// This doesn't use any export
-		return Dependency.NO_EXPORTS_REFERENCED;
-	}
 }
 
+CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+
 makeSerializable(
-	RequireResolveDependency,
-	"webpack/lib/dependencies/RequireResolveDependency"
+	CommonJsRequireDependency,
+	"webpack/lib/dependencies/CommonJsRequireDependency"
 );
 
-RequireResolveDependency.Template = ModuleDependencyAsId;
-
-module.exports = RequireResolveDependency;
+module.exports = CommonJsRequireDependency;
 
 
 /***/ }),
 
-/***/ 9880:
+/***/ 52225:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83351,130 +81533,79 @@ module.exports = RequireResolveDependency;
 
 
 
+const RuntimeGlobals = __webpack_require__(16475);
+const { equals } = __webpack_require__(84953);
 const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
 const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class RequireResolveHeaderDependency extends NullDependency {
-	constructor(range) {
+class CommonJsSelfReferenceDependency extends NullDependency {
+	constructor(range, base, names, call) {
 		super();
-
-		if (!Array.isArray(range)) throw new Error("range must be valid");
-
 		this.range = range;
+		this.base = base;
+		this.names = names;
+		this.call = call;
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const obj = new RequireResolveHeaderDependency(context.read());
-		obj.deserialize(context);
-		return obj;
-	}
-}
-
-makeSerializable(
-	RequireResolveHeaderDependency,
-	"webpack/lib/dependencies/RequireResolveHeaderDependency"
-);
-
-RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {RequireResolveHeaderDependency} */ (dependency);
-		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	get type() {
+		return "cjs self exports reference";
 	}
 
-	applyAsTemplateArgument(name, dep, source) {
-		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	get category() {
+		return "self";
 	}
-};
-
-module.exports = RequireResolveHeaderDependency;
-
-
-/***/ }),
-
-/***/ 24187:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
 
-class RuntimeRequirementsDependency extends NullDependency {
 	/**
-	 * @param {string[]} runtimeRequirements runtime requirements
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	constructor(runtimeRequirements) {
-		super();
-		this.runtimeRequirements = new Set(runtimeRequirements);
-		this._hashUpdate = undefined;
+	getResourceIdentifier() {
+		return `self`;
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
-		}
-		hash.update(this._hashUpdate);
+	getReferencedExports(moduleGraph, runtime) {
+		return [this.call ? this.names.slice(0, -1) : this.names];
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.runtimeRequirements);
+		write(this.range);
+		write(this.base);
+		write(this.names);
+		write(this.call);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.runtimeRequirements = read();
+		this.range = read();
+		this.base = read();
+		this.names = read();
+		this.call = read();
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	RuntimeRequirementsDependency,
-	"webpack/lib/dependencies/RuntimeRequirementsDependency"
+	CommonJsSelfReferenceDependency,
+	"webpack/lib/dependencies/CommonJsSelfReferenceDependency"
 );
 
-RuntimeRequirementsDependency.Template = class RuntimeRequirementsDependencyTemplate extends (
+CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -83483,381 +81614,151 @@ RuntimeRequirementsDependency.Template = class RuntimeRequirementsDependencyTemp
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {RuntimeRequirementsDependency} */ (dependency);
-		for (const req of dep.runtimeRequirements) {
-			runtimeRequirements.add(req);
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, runtime, runtimeRequirements }
+	) {
+		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
+		let used;
+		if (dep.names.length === 0) {
+			used = dep.names;
+		} else {
+			used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+		}
+		if (!used) {
+			throw new Error(
+				"Self-reference dependency has unused export name: This should not happen"
+			);
 		}
-	}
-};
-
-module.exports = RuntimeRequirementsDependency;
-
-
-/***/ }),
-
-/***/ 91418:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
-
-class StaticExportsDependency extends NullDependency {
-	/**
-	 * @param {string[] | true} exports export names
-	 * @param {boolean} canMangle true, if mangling exports names is allowed
-	 */
-	constructor(exports, canMangle) {
-		super();
-		this.exports = exports;
-		this.canMangle = canMangle;
-	}
-
-	get type() {
-		return "static exports";
-	}
-
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: this.exports,
-			canMangle: this.canMangle,
-			dependencies: undefined
-		};
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.exports);
-		write(this.canMangle);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.exports = read();
-		this.canMangle = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	StaticExportsDependency,
-	"webpack/lib/dependencies/StaticExportsDependency"
-);
-
-module.exports = StaticExportsDependency;
-
-
-/***/ }),
-
-/***/ 97981:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const {
-	evaluateToString,
-	expressionIsUnsupported,
-	toConstantDependency
-} = __webpack_require__(93998);
-const makeSerializable = __webpack_require__(33032);
-const ConstDependency = __webpack_require__(76911);
-const SystemRuntimeModule = __webpack_require__(85439);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-class SystemPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"SystemPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
-					});
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.system === undefined || !parserOptions.system) {
-						return;
-					}
-
-					const setNotSupported = name => {
-						parser.hooks.evaluateTypeof
-							.for(name)
-							.tap("SystemPlugin", evaluateToString("undefined"));
-						parser.hooks.expression
-							.for(name)
-							.tap(
-								"SystemPlugin",
-								expressionIsUnsupported(
-									parser,
-									name + " is not supported by webpack."
-								)
-							);
-					};
-
-					parser.hooks.typeof
-						.for("System.import")
-						.tap(
-							"SystemPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-					parser.hooks.evaluateTypeof
-						.for("System.import")
-						.tap("SystemPlugin", evaluateToString("function"));
-					parser.hooks.typeof
-						.for("System")
-						.tap(
-							"SystemPlugin",
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-					parser.hooks.evaluateTypeof
-						.for("System")
-						.tap("SystemPlugin", evaluateToString("object"));
-
-					setNotSupported("System.set");
-					setNotSupported("System.get");
-					setNotSupported("System.register");
-
-					parser.hooks.expression.for("System").tap("SystemPlugin", expr => {
-						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
-							RuntimeGlobals.system
-						]);
-						dep.loc = expr.loc;
-						parser.state.module.addPresentationalDependency(dep);
-						return true;
-					});
-
-					parser.hooks.call.for("System.import").tap("SystemPlugin", expr => {
-						parser.state.module.addWarning(
-							new SystemImportDeprecationWarning(expr.loc)
-						);
-
-						return parser.hooks.importCall.call({
-							type: "ImportExpression",
-							source: expr.arguments[0],
-							loc: expr.loc,
-							range: expr.range
-						});
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("SystemPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("SystemPlugin", handler);
-			}
-		);
-	}
-}
-
-class SystemImportDeprecationWarning extends WebpackError {
-	constructor(loc) {
-		super(
-			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +
-				"For more info visit https://webpack.js.org/guides/code-splitting/"
-		);
-
-		this.name = "SystemImportDeprecationWarning";
-
-		this.loc = loc;
-	}
-}
-
-makeSerializable(
-	SystemImportDeprecationWarning,
-	"webpack/lib/dependencies/SystemPlugin",
-	"SystemImportDeprecationWarning"
-);
-
-module.exports = SystemPlugin;
-module.exports.SystemImportDeprecationWarning = SystemImportDeprecationWarning;
-
-
-/***/ }),
-
-/***/ 85439:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
-
-
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+		let base = undefined;
+		switch (dep.base) {
+			case "exports":
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				base = module.exportsArgument;
+				break;
+			case "module.exports":
+				runtimeRequirements.add(RuntimeGlobals.module);
+				base = `${module.moduleArgument}.exports`;
+				break;
+			case "this":
+				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+				base = "this";
+				break;
+			default:
+				throw new Error(`Unsupported base ${dep.base}`);
+		}
 
-class SystemRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("system");
-	}
+		if (base === dep.base && equals(used, dep.names)) {
+			// Nothing has to be changed
+			// We don't use a replacement for compat reasons
+			// for plugins that update `module._source` which they
+			// shouldn't do!
+			return;
+		}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.system} = {`,
-			Template.indent([
-				"import: function () {",
-				Template.indent(
-					"throw new Error('System.import cannot be used indirectly');"
-				),
-				"}"
-			]),
-			"};"
-		]);
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${base}${propertyAccess(used)}`
+		);
 	}
-}
+};
 
-module.exports = SystemRuntimeModule;
+module.exports = CommonJsSelfReferenceDependency;
 
 
 /***/ }),
 
-/***/ 58612:
+/***/ 76911:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const {
-	getDependencyUsedByExportsCondition
-} = __webpack_require__(38988);
 const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-const ModuleDependency = __webpack_require__(80321);
+const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
 
-class URLDependency extends ModuleDependency {
+class ConstDependency extends NullDependency {
 	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
-	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
-	 * @param {boolean=} relative use relative urls instead of absolute with base uri
+	 * @param {string} expression the expression
+	 * @param {number|[number, number]} range the source range
+	 * @param {string[]=} runtimeRequirements runtime requirements
 	 */
-	constructor(request, range, outerRange, relative) {
-		super(request);
+	constructor(expression, range, runtimeRequirements) {
+		super();
+		this.expression = expression;
 		this.range = range;
-		this.outerRange = outerRange;
-		this.relative = relative || false;
-		/** @type {Set<string> | boolean} */
-		this.usedByExports = undefined;
-	}
-
-	get type() {
-		return "new URL()";
-	}
-
-	get category() {
-		return "url";
+		this.runtimeRequirements = runtimeRequirements
+			? new Set(runtimeRequirements)
+			: null;
+		this._hashUpdate = undefined;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
 	 */
-	getCondition(moduleGraph) {
-		return getDependencyUsedByExportsCondition(
-			this,
-			this.usedByExports,
-			moduleGraph
-		);
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = "" + this.range + "|" + this.expression;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
 	 */
-	createIgnoredModule(context) {
-		const RawDataUrlModule = getRawDataUrlModule();
-		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.outerRange);
-		write(this.relative);
-		write(this.usedByExports);
+		write(this.expression);
+		write(this.range);
+		write(this.runtimeRequirements);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.outerRange = read();
-		this.relative = read();
-		this.usedByExports = read();
+		this.expression = read();
+		this.range = read();
+		this.runtimeRequirements = read();
 		super.deserialize(context);
 	}
 }
 
-URLDependency.Template = class URLDependencyTemplate extends (
-	ModuleDependency.Template
+makeSerializable(ConstDependency, "webpack/lib/dependencies/ConstDependency");
+
+ConstDependency.Template = class ConstDependencyTemplate extends (
+	NullDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -83866,190 +81767,422 @@ URLDependency.Template = class URLDependencyTemplate extends (
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const {
-			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
-			runtimeTemplate,
-			runtime
-		} = templateContext;
-		const dep = /** @type {URLDependency} */ (dependency);
-		const connection = moduleGraph.getConnection(dep);
-		// Skip rendering depending when dependency is conditional
-		if (connection && !connection.isTargetActive(runtime)) {
-			source.replace(
-				dep.outerRange[0],
-				dep.outerRange[1] - 1,
-				"/* unused asset import */ undefined"
-			);
+		const dep = /** @type {ConstDependency} */ (dependency);
+		if (dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		if (typeof dep.range === "number") {
+			source.insert(dep.range, dep.expression);
 			return;
 		}
 
-		runtimeRequirements.add(RuntimeGlobals.require);
-
-		if (dep.relative) {
-			runtimeRequirements.add(RuntimeGlobals.relativeUrl);
-			source.replace(
-				dep.outerRange[0],
-				dep.outerRange[1] - 1,
-				`/* asset import */ new ${
-					RuntimeGlobals.relativeUrl
-				}(${runtimeTemplate.moduleRaw({
-					chunkGraph,
-					module: moduleGraph.getModule(dep),
-					request: dep.request,
-					runtimeRequirements,
-					weak: false
-				})})`
-			);
-		} else {
-			runtimeRequirements.add(RuntimeGlobals.baseURI);
-
-			source.replace(
-				dep.range[0],
-				dep.range[1] - 1,
-				`/* asset import */ ${runtimeTemplate.moduleRaw({
-					chunkGraph,
-					module: moduleGraph.getModule(dep),
-					request: dep.request,
-					runtimeRequirements,
-					weak: false
-				})}, ${RuntimeGlobals.baseURI}`
-			);
-		}
+		source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
 	}
 };
 
-makeSerializable(URLDependency, "webpack/lib/dependencies/URLDependency");
-
-module.exports = URLDependency;
+module.exports = ConstDependency;
 
 
 /***/ }),
 
-/***/ 14412:
+/***/ 88101:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { approve } = __webpack_require__(93998);
-const InnerGraph = __webpack_require__(38988);
-const URLDependency = __webpack_require__(58612);
+const Dependency = __webpack_require__(54912);
+const DependencyTemplate = __webpack_require__(5160);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
 
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../WebpackError")} WebpackError */
 
-class URLPlugin {
+const getCriticalDependencyWarning = memoize(() =>
+	__webpack_require__(15427)
+);
+
+/** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
+
+const regExpToString = r => (r ? r + "" : "");
+
+class ContextDependency extends Dependency {
 	/**
-	 * @param {Compiler} compiler compiler
+	 * @param {ContextDependencyOptions} options options for the context module
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"URLPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
-				compilation.dependencyTemplates.set(
-					URLDependency,
-					new URLDependency.Template()
-				);
+	constructor(options) {
+		super();
 
-				/**
-				 * @param {JavascriptParser} parser parser
-				 * @param {object} parserOptions options
-				 */
-				const parserCallback = (parser, parserOptions) => {
-					if (parserOptions.url === false) return;
-					const relative = parserOptions.url === "relative";
+		this.options = options;
+		this.userRequest = this.options && this.options.request;
+		/** @type {false | string} */
+		this.critical = false;
+		this.hadGlobalOrStickyRegExp = false;
 
-					/**
-					 * @param {NewExpressionNode} expr expression
-					 * @returns {undefined | string} request
-					 */
-					const getUrlRequest = expr => {
-						if (expr.arguments.length !== 2) return;
+		if (
+			this.options &&
+			(this.options.regExp.global || this.options.regExp.sticky)
+		) {
+			this.options = { ...this.options, regExp: null };
+			this.hadGlobalOrStickyRegExp = true;
+		}
 
-						const [arg1, arg2] = expr.arguments;
+		this.request = undefined;
+		this.range = undefined;
+		this.valueRange = undefined;
+		this.inShorthand = undefined;
+		// TODO refactor this
+		this.replaces = undefined;
+	}
 
-						if (
-							arg2.type !== "MemberExpression" ||
-							arg1.type === "SpreadElement"
-						)
-							return;
+	get category() {
+		return "commonjs";
+	}
 
-						const chain = parser.extractMemberExpressionChain(arg2);
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
+	}
 
-						if (
-							chain.members.length !== 1 ||
-							chain.object.type !== "MetaProperty" ||
-							chain.object.meta.name !== "import" ||
-							chain.object.property.name !== "meta" ||
-							chain.members[0] !== "url"
-						)
-							return;
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return (
+			`context${this.options.request} ${this.options.recursive} ` +
+			`${regExpToString(this.options.regExp)} ${regExpToString(
+				this.options.include
+			)} ${regExpToString(this.options.exclude)} ` +
+			`${this.options.mode} ${this.options.chunkName} ` +
+			`${JSON.stringify(this.options.groupOptions)}`
+		);
+	}
 
-						const request = parser.evaluateExpression(arg1).asString();
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
+	 */
+	getWarnings(moduleGraph) {
+		let warnings = super.getWarnings(moduleGraph);
 
-						return request;
-					};
+		if (this.critical) {
+			if (!warnings) warnings = [];
+			const CriticalDependencyWarning = getCriticalDependencyWarning();
+			warnings.push(new CriticalDependencyWarning(this.critical));
+		}
 
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
+		if (this.hadGlobalOrStickyRegExp) {
+			if (!warnings) warnings = [];
+			const CriticalDependencyWarning = getCriticalDependencyWarning();
+			warnings.push(
+				new CriticalDependencyWarning(
+					"Contexts can't use RegExps with the 'g' or 'y' flags."
+				)
+			);
+		}
 
-						const request = getUrlRequest(expr);
+		return warnings;
+	}
 
-						if (!request) return;
+	serialize(context) {
+		const { write } = context;
 
-						const [arg1, arg2] = expr.arguments;
-						const dep = new URLDependency(
-							request,
-							[arg1.range[0], arg2.range[1]],
-							expr.range,
-							relative
-						);
-						dep.loc = expr.loc;
-						parser.state.current.addDependency(dep);
-						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-						return true;
-					});
-					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
-						const { callee } = expr;
-						if (callee.type !== "Identifier") return;
-						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
-						if (!calleeInfo || calleeInfo.name !== "URL") return;
+		write(this.options);
+		write(this.userRequest);
+		write(this.critical);
+		write(this.hadGlobalOrStickyRegExp);
+		write(this.request);
+		write(this.range);
+		write(this.valueRange);
+		write(this.prepend);
+		write(this.replaces);
 
-						const request = getUrlRequest(expr);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.options = read();
+		this.userRequest = read();
+		this.critical = read();
+		this.hadGlobalOrStickyRegExp = read();
+		this.request = read();
+		this.range = read();
+		this.valueRange = read();
+		this.prepend = read();
+		this.replaces = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	ContextDependency,
+	"webpack/lib/dependencies/ContextDependency"
+);
+
+ContextDependency.Template = DependencyTemplate;
+
+module.exports = ContextDependency;
+
+
+/***/ }),
+
+/***/ 99630:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { parseResource } = __webpack_require__(82186);
+
+/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./ContextDependency")} ContextDependency */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+/**
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
+ */
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+};
+
+const splitContextFromPrefix = prefix => {
+	const idx = prefix.lastIndexOf("/");
+	let context = ".";
+	if (idx >= 0) {
+		context = prefix.substr(0, idx);
+		prefix = `.${prefix.substr(idx)}`;
+	}
+	return {
+		context,
+		prefix
+	};
+};
+
+/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
+
+/** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
+
+/**
+ * @param {ContextDependencyConstructor} Dep the Dependency class
+ * @param {[number, number]} range source range
+ * @param {BasicEvaluatedExpression} param context param
+ * @param {EsTreeNode} expr expr
+ * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
+ * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
+ * @param {JavascriptParser} parser the parser
+ * @returns {ContextDependency} the created Dependency
+ */
+exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
+	if (param.isTemplateString()) {
+		let prefixRaw = param.quasis[0].string;
+		let postfixRaw =
+			param.quasis.length > 1
+				? param.quasis[param.quasis.length - 1].string
+				: "";
+
+		const valueRange = param.range;
+		const { context, prefix } = splitContextFromPrefix(prefixRaw);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
+
+		// When there are more than two quasis, the generated RegExp can be more precise
+		// We join the quasis with the expression regexp
+		const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
+		const innerRegExp =
+			options.wrappedContextRegExp.source +
+			innerQuasis
+				.map(q => quoteMeta(q.string) + options.wrappedContextRegExp.source)
+				.join("");
+
+		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
+		// context: "./context"
+		// prefix: "./pre"
+		// innerQuasis: [BEE("inner"), BEE("inner2")]
+		// (BEE = BasicEvaluatedExpression)
+		// postfix: "post"
+		// query: "?query"
+		// fragment: "#frag"
+		// regExp: /^\.\/pre.*inner.*inner2.*post$/
+		const regExp = new RegExp(
+			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
+		);
+		const dep = new Dep(
+			{
+				request: context + query + fragment,
+				recursive: options.wrappedContextRecursive,
+				regExp,
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			valueRange
+		);
+		dep.loc = expr.loc;
+		const replaces = [];
 
-						if (request) return true;
-					});
-				};
+		param.parts.forEach((part, i) => {
+			if (i % 2 === 0) {
+				// Quasis or merged quasi
+				let range = part.range;
+				let value = part.string;
+				if (param.templateStringKind === "cooked") {
+					value = JSON.stringify(value);
+					value = value.slice(1, value.length - 1);
+				}
+				if (i === 0) {
+					// prefix
+					value = prefix;
+					range = [param.range[0], part.range[1]];
+					value =
+						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
+						value;
+				} else if (i === param.parts.length - 1) {
+					// postfix
+					value = postfix;
+					range = [part.range[0], param.range[1]];
+					value = value + "`";
+				} else if (
+					part.expression &&
+					part.expression.type === "TemplateElement" &&
+					part.expression.value.raw === value
+				) {
+					// Shortcut when it's a single quasi and doesn't need to be replaced
+					return;
+				}
+				replaces.push({
+					range,
+					value
+				});
+			} else {
+				// Expression
+				parser.walkExpression(part.expression);
+			}
+		});
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("URLPlugin", parserCallback);
+		dep.replaces = replaces;
+		dep.critical =
+			options.wrappedContextCritical &&
+			"a part of the request of a dependency is an expression";
+		return dep;
+	} else if (
+		param.isWrapped() &&
+		((param.prefix && param.prefix.isString()) ||
+			(param.postfix && param.postfix.isString()))
+	) {
+		let prefixRaw =
+			param.prefix && param.prefix.isString() ? param.prefix.string : "";
+		let postfixRaw =
+			param.postfix && param.postfix.isString() ? param.postfix.string : "";
+		const prefixRange =
+			param.prefix && param.prefix.isString() ? param.prefix.range : null;
+		const postfixRange =
+			param.postfix && param.postfix.isString() ? param.postfix.range : null;
+		const valueRange = param.range;
+		const { context, prefix } = splitContextFromPrefix(prefixRaw);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
+		const regExp = new RegExp(
+			`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(
+				postfix
+			)}$`
+		);
+		const dep = new Dep(
+			{
+				request: context + query + fragment,
+				recursive: options.wrappedContextRecursive,
+				regExp,
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			valueRange
+		);
+		dep.loc = expr.loc;
+		const replaces = [];
+		if (prefixRange) {
+			replaces.push({
+				range: prefixRange,
+				value: JSON.stringify(prefix)
+			});
+		}
+		if (postfixRange) {
+			replaces.push({
+				range: postfixRange,
+				value: JSON.stringify(postfix)
+			});
+		}
+		dep.replaces = replaces;
+		dep.critical =
+			options.wrappedContextCritical &&
+			"a part of the request of a dependency is an expression";
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("URLPlugin", parserCallback);
+		if (parser && param.wrappedInnerExpressions) {
+			for (const part of param.wrappedInnerExpressions) {
+				if (part.expression) parser.walkExpression(part.expression);
 			}
+		}
+
+		return dep;
+	} else {
+		const dep = new Dep(
+			{
+				request: options.exprContextRequest,
+				recursive: options.exprContextRecursive,
+				regExp: /** @type {RegExp} */ (options.exprContextRegExp),
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			param.range
 		);
-	}
-}
+		dep.loc = expr.loc;
+		dep.critical =
+			options.exprContextCritical &&
+			"the request of a dependency is an expression";
 
-module.exports = URLPlugin;
+		parser.walkExpression(param.expression);
+
+		return dep;
+	}
+};
 
 
 /***/ }),
 
-/***/ 51669:
+/***/ 76081:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -84060,73 +82193,65 @@ module.exports = URLPlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const ContextDependency = __webpack_require__(88101);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class UnsupportedDependency extends NullDependency {
-	constructor(request, range) {
-		super();
-
-		this.request = request;
-		this.range = range;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.request);
-		write(this.range);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.request = read();
-		this.range = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	UnsupportedDependency,
-	"webpack/lib/dependencies/UnsupportedDependency"
-);
-
-UnsupportedDependency.Template = class UnsupportedDependencyTemplate extends (
-	NullDependency.Template
-) {
+class ContextDependencyTemplateAsId extends ContextDependency.Template {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { runtimeTemplate }) {
-		const dep = /** @type {UnsupportedDependency} */ (dependency);
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ContextDependency} */ (dependency);
+		const moduleExports = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
 
-		source.replace(
-			dep.range[0],
-			dep.range[1],
-			runtimeTemplate.missingModule({
-				request: dep.request
-			})
-		);
+		if (moduleGraph.getModule(dep)) {
+			if (dep.valueRange) {
+				if (Array.isArray(dep.replaces)) {
+					for (let i = 0; i < dep.replaces.length; i++) {
+						const rep = dep.replaces[i];
+						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+					}
+				}
+				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+				source.replace(
+					dep.range[0],
+					dep.valueRange[0] - 1,
+					`${moduleExports}.resolve(`
+				);
+			} else {
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					`${moduleExports}.resolve`
+				);
+			}
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+		}
 	}
-};
-
-module.exports = UnsupportedDependency;
+}
+module.exports = ContextDependencyTemplateAsId;
 
 
 /***/ }),
 
-/***/ 52204:
+/***/ 75815:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -84137,83 +82262,63 @@ module.exports = UnsupportedDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class WebAssemblyExportImportedDependency extends ModuleDependency {
-	constructor(exportName, request, name, valueType) {
-		super(request);
-		/** @type {string} */
-		this.exportName = exportName;
-		/** @type {string} */
-		this.name = name;
-		/** @type {string} */
-		this.valueType = valueType;
-	}
+const ContextDependency = __webpack_require__(88101);
 
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return Dependency.TRANSITIVE;
-	}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
+class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template {
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
-	}
-
-	get type() {
-		return "wasm export import";
-	}
-
-	get category() {
-		return "wasm";
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.exportName);
-		write(this.name);
-		write(this.valueType);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.exportName = read();
-		this.name = read();
-		this.valueType = read();
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ContextDependency} */ (dependency);
+		let moduleExports = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			runtimeRequirements
+		});
 
-		super.deserialize(context);
+		if (dep.inShorthand) {
+			moduleExports = `${dep.inShorthand}: ${moduleExports}`;
+		}
+		if (moduleGraph.getModule(dep)) {
+			if (dep.valueRange) {
+				if (Array.isArray(dep.replaces)) {
+					for (let i = 0; i < dep.replaces.length; i++) {
+						const rep = dep.replaces[i];
+						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+					}
+				}
+				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+				source.replace(
+					dep.range[0],
+					dep.valueRange[0] - 1,
+					`${moduleExports}(`
+				);
+			} else {
+				source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+			}
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+		}
 	}
 }
-
-makeSerializable(
-	WebAssemblyExportImportedDependency,
-	"webpack/lib/dependencies/WebAssemblyExportImportedDependency"
-);
-
-module.exports = WebAssemblyExportImportedDependency;
+module.exports = ContextDependencyTemplateAsRequireCall;
 
 
 /***/ }),
 
-/***/ 5239:
+/***/ 58477:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -84224,39 +82329,36 @@ module.exports = WebAssemblyExportImportedDependency;
 
 
 
+const Dependency = __webpack_require__(54912);
 const makeSerializable = __webpack_require__(33032);
-const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
 const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class WebAssemblyImportDependency extends ModuleDependency {
-	/**
-	 * @param {string} request the request
-	 * @param {string} name the imported name
-	 * @param {ModuleImportDescription} description the WASM ast node
-	 * @param {false | string} onlyDirectImport if only direct imports are allowed
-	 */
-	constructor(request, name, description, onlyDirectImport) {
+class ContextElementDependency extends ModuleDependency {
+	constructor(request, userRequest, typePrefix, category, referencedExports) {
 		super(request);
-		/** @type {string} */
-		this.name = name;
-		/** @type {ModuleImportDescription} */
-		this.description = description;
-		/** @type {false | string} */
-		this.onlyDirectImport = onlyDirectImport;
+		this.referencedExports = referencedExports;
+		this._typePrefix = typePrefix;
+		this._category = category;
+
+		if (userRequest) {
+			this.userRequest = userRequest;
+		}
 	}
 
 	get type() {
-		return "wasm import";
+		if (this._typePrefix) {
+			return `${this._typePrefix} context element`;
+		}
+
+		return "context element";
 	}
 
 	get category() {
-		return "wasm";
+		return this._category;
 	}
 
 	/**
@@ -84266,207 +82368,82 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
-	}
-
-	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
-	 */
-	getErrors(moduleGraph) {
-		const module = moduleGraph.getModule(this);
-
-		if (
-			this.onlyDirectImport &&
-			module &&
-			!module.type.startsWith("webassembly")
-		) {
-			return [
-				new UnsupportedWebAssemblyFeatureError(
-					`Import "${this.name}" from "${this.request}" with ${this.onlyDirectImport} can only be used for direct wasm to wasm dependencies`
-				)
-			];
-		}
+		return this.referencedExports
+			? this.referencedExports.map(e => ({
+					name: e,
+					canMangle: false
+			  }))
+			: Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
 	serialize(context) {
-		const { write } = context;
-
-		write(this.name);
-		write(this.description);
-		write(this.onlyDirectImport);
-
+		context.write(this.referencedExports);
 		super.serialize(context);
 	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.name = read();
-		this.description = read();
-		this.onlyDirectImport = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	WebAssemblyImportDependency,
-	"webpack/lib/dependencies/WebAssemblyImportDependency"
-);
-
-module.exports = WebAssemblyImportDependency;
-
-
-/***/ }),
-
-/***/ 26505:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const Dependency = __webpack_require__(54912);
-const Template = __webpack_require__(1626);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class WebpackIsIncludedDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-
-		this.weak = true;
-		this.range = range;
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		// This doesn't use any export
-		return Dependency.NO_EXPORTS_REFERENCED;
-	}
-
-	get type() {
-		return "__webpack_is_included__";
-	}
-}
-
-makeSerializable(
-	WebpackIsIncludedDependency,
-	"webpack/lib/dependencies/WebpackIsIncludedDependency"
-);
-
-WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeTemplate, chunkGraph, moduleGraph }) {
-		const dep = /** @type {WebpackIsIncludedDependency} */ (dependency);
-		const connection = moduleGraph.getConnection(dep);
-		const included = connection
-			? chunkGraph.getNumberOfModuleChunks(connection.module) > 0
-			: false;
-		const comment = runtimeTemplate.outputOptions.pathinfo
-			? Template.toComment(
-					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
-						dep.request
-					)}`
-			  )
-			: "";
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`${comment}${JSON.stringify(included)}`
-		);
+
+	deserialize(context) {
+		this.referencedExports = context.read();
+		super.deserialize(context);
 	}
-};
+}
 
-module.exports = WebpackIsIncludedDependency;
+makeSerializable(
+	ContextElementDependency,
+	"webpack/lib/dependencies/ContextElementDependency"
+);
+
+module.exports = ContextElementDependency;
 
 
 /***/ }),
 
-/***/ 1466:
+/***/ 79062:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const Dependency = __webpack_require__(54912);
 const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class WorkerDependency extends ModuleDependency {
+class CreateScriptUrlDependency extends NullDependency {
 	/**
-	 * @param {string} request request
 	 * @param {[number, number]} range range
 	 */
-	constructor(request, range) {
-		super(request);
+	constructor(range) {
+		super();
 		this.range = range;
 	}
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return Dependency.NO_EXPORTS_REFERENCED;
+	get type() {
+		return "create script url";
 	}
 
-	get type() {
-		return "new Worker()";
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
 	}
 
-	get category() {
-		return "worker";
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		super.deserialize(context);
 	}
 }
 
-WorkerDependency.Template = class WorkerDependencyTemplate extends (
-	ModuleDependency.Template
+CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (
+	NullDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -84474,747 +82451,650 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
-		const dep = /** @type {WorkerDependency} */ (dependency);
-		const block = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dependency)
-		);
-		const entrypoint = /** @type {Entrypoint} */ (
-			chunkGraph.getBlockChunkGroup(block)
-		);
-		const chunk = entrypoint.getEntrypointChunk();
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {CreateScriptUrlDependency} */ (dependency);
 
-		runtimeRequirements.add(RuntimeGlobals.publicPath);
-		runtimeRequirements.add(RuntimeGlobals.baseURI);
-		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
 
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`/* worker import */ ${RuntimeGlobals.publicPath} + ${
-				RuntimeGlobals.getChunkScriptFilename
-			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
-		);
+		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
+		source.insert(dep.range[1], ")");
 	}
 };
 
-makeSerializable(WorkerDependency, "webpack/lib/dependencies/WorkerDependency");
+makeSerializable(
+	CreateScriptUrlDependency,
+	"webpack/lib/dependencies/CreateScriptUrlDependency"
+);
 
-module.exports = WorkerDependency;
+module.exports = CreateScriptUrlDependency;
 
 
 /***/ }),
 
-/***/ 82509:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { pathToFileURL } = __webpack_require__(57310);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const CommentCompilationWarning = __webpack_require__(98427);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
-const { equals } = __webpack_require__(84953);
-const createHash = __webpack_require__(49835);
-const { contextify } = __webpack_require__(82186);
-const EnableWasmLoadingPlugin = __webpack_require__(78613);
-const ConstDependency = __webpack_require__(76911);
-const CreateScriptUrlDependency = __webpack_require__(79062);
-const {
-	harmonySpecifierTag
-} = __webpack_require__(20862);
-const WorkerDependency = __webpack_require__(1466);
-
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").Pattern} Pattern */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
-
-const getUrl = module => {
-	return pathToFileURL(module.resource).toString();
-};
-
-const DEFAULT_SYNTAX = [
-	"Worker",
-	"SharedWorker",
-	"navigator.serviceWorker.register()",
-	"Worker from worker_threads"
-];
-
-/** @type {WeakMap<ParserState, number>} */
-const workerIndexMap = new WeakMap();
-
-class WorkerPlugin {
-	constructor(chunkLoading, wasmLoading, module) {
-		this._chunkLoading = chunkLoading;
-		this._wasmLoading = wasmLoading;
-		this._module = module;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		if (this._chunkLoading) {
-			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
-		}
-		if (this._wasmLoading) {
-			new EnableWasmLoadingPlugin(this._wasmLoading).apply(compiler);
-		}
-		const cachedContextify = contextify.bindContextCache(
-			compiler.context,
-			compiler.root
-		);
-		compiler.hooks.thisCompilation.tap(
-			"WorkerPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WorkerDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					WorkerDependency,
-					new WorkerDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					CreateScriptUrlDependency,
-					new CreateScriptUrlDependency.Template()
-				);
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
-				 */
-				const parseModuleUrl = (parser, expr) => {
-					if (
-						expr.type !== "NewExpression" ||
-						expr.callee.type === "Super" ||
-						expr.arguments.length !== 2
-					)
-						return;
-					const [arg1, arg2] = expr.arguments;
-					if (arg1.type === "SpreadElement") return;
-					if (arg2.type === "SpreadElement") return;
-					const callee = parser.evaluateExpression(expr.callee);
-					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
-					const arg2Value = parser.evaluateExpression(arg2);
-					if (
-						!arg2Value.isString() ||
-						!arg2Value.string.startsWith("file://") ||
-						arg2Value.string !== getUrl(parser.state.module)
-					) {
-						return;
-					}
-					const arg1Value = parser.evaluateExpression(arg1);
-					return [arg1Value, [arg1.range[0], arg2.range[1]]];
-				};
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {ObjectExpression} expr expression
-				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
-				 */
-				const parseObjectExpression = (parser, expr) => {
-					/** @type {Record<string, any>} */
-					const values = {};
-					/** @type {Record<string, Expression | Pattern>} */
-					const expressions = {};
-					/** @type {(Property | SpreadElement)[]} */
-					const otherElements = [];
-					let spread = false;
-					for (const prop of expr.properties) {
-						if (prop.type === "SpreadElement") {
-							spread = true;
-						} else if (
-							prop.type === "Property" &&
-							!prop.method &&
-							!prop.computed &&
-							prop.key.type === "Identifier"
-						) {
-							expressions[prop.key.name] = prop.value;
-							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
-								const value = parser.evaluateExpression(
-									/** @type {Expression} */ (prop.value)
-								);
-								if (value.isCompileTimeValue())
-									values[prop.key.name] = value.asCompileTimeValue();
-							}
-						} else {
-							otherElements.push(prop);
-						}
-					}
-					const insertType = expr.properties.length > 0 ? "comma" : "single";
-					const insertLocation =
-						expr.properties[expr.properties.length - 1].range[1];
-					return {
-						expressions,
-						otherElements,
-						values,
-						spread,
-						insertType,
-						insertLocation
-					};
-				};
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {object} parserOptions options
-				 */
-				const parserPlugin = (parser, parserOptions) => {
-					if (parserOptions.worker === false) return;
-					const options = !Array.isArray(parserOptions.worker)
-						? ["..."]
-						: parserOptions.worker;
-					const handleNewWorker = expr => {
-						if (expr.arguments.length === 0 || expr.arguments.length > 2)
-							return;
-						const [arg1, arg2] = expr.arguments;
-						if (arg1.type === "SpreadElement") return;
-						if (arg2 && arg2.type === "SpreadElement") return;
-						const parsedUrl = parseModuleUrl(parser, arg1);
-						if (!parsedUrl) return;
-						const [url, range] = parsedUrl;
-						if (!url.isString()) return;
-						const {
-							expressions,
-							otherElements,
-							values: options,
-							spread: hasSpreadInOptions,
-							insertType,
-							insertLocation
-						} = arg2 && arg2.type === "ObjectExpression"
-							? parseObjectExpression(parser, arg2)
-							: {
-									expressions: {},
-									otherElements: [],
-									values: {},
-									spread: false,
-									insertType: arg2 ? "spread" : "argument",
-									insertLocation: arg2 ? arg2.range : arg1.range[1]
-							  };
-						const { options: importOptions, errors: commentErrors } =
-							parser.parseCommentOptions(expr.range);
-
-						if (commentErrors) {
-							for (const e of commentErrors) {
-								const { comment } = e;
-								parser.state.module.addWarning(
-									new CommentCompilationWarning(
-										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-										comment.loc
-									)
-								);
-							}
-						}
-
-						/** @type {EntryOptions} */
-						let entryOptions = {};
-
-						if (importOptions) {
-							if (importOptions.webpackIgnore !== undefined) {
-								if (typeof importOptions.webpackIgnore !== "boolean") {
-									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
-											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-											expr.loc
-										)
-									);
-								} else {
-									if (importOptions.webpackIgnore) {
-										return false;
-									}
-								}
-							}
-							if (importOptions.webpackEntryOptions !== undefined) {
-								if (
-									typeof importOptions.webpackEntryOptions !== "object" ||
-									importOptions.webpackEntryOptions === null
-								) {
-									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
-											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
-											expr.loc
-										)
-									);
-								} else {
-									Object.assign(
-										entryOptions,
-										importOptions.webpackEntryOptions
-									);
-								}
-							}
-							if (importOptions.webpackChunkName !== undefined) {
-								if (typeof importOptions.webpackChunkName !== "string") {
-									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
-											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-											expr.loc
-										)
-									);
-								} else {
-									entryOptions.name = importOptions.webpackChunkName;
-								}
-							}
-						}
-
-						if (
-							!Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
-							options &&
-							typeof options.name === "string"
-						) {
-							entryOptions.name = options.name;
-						}
-
-						if (entryOptions.runtime === undefined) {
-							let i = workerIndexMap.get(parser.state) || 0;
-							workerIndexMap.set(parser.state, i + 1);
-							let name = `${cachedContextify(
-								parser.state.module.identifier()
-							)}|${i}`;
-							const hash = createHash(compilation.outputOptions.hashFunction);
-							hash.update(name);
-							const digest = /** @type {string} */ (
-								hash.digest(compilation.outputOptions.hashDigest)
-							);
-							entryOptions.runtime = digest.slice(
-								0,
-								compilation.outputOptions.hashDigestLength
-							);
-						}
-
-						const block = new AsyncDependenciesBlock({
-							name: entryOptions.name,
-							entryOptions: {
-								chunkLoading: this._chunkLoading,
-								wasmLoading: this._wasmLoading,
-								...entryOptions
-							}
-						});
-						block.loc = expr.loc;
-						const dep = new WorkerDependency(url.string, range);
-						dep.loc = expr.loc;
-						block.addDependency(dep);
-						parser.state.module.addBlock(block);
-
-						if (compilation.outputOptions.trustedTypes) {
-							const dep = new CreateScriptUrlDependency(
-								expr.arguments[0].range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-						}
-
-						if (expressions.type) {
-							const expr = expressions.type;
-							if (options.type !== false) {
-								const dep = new ConstDependency(
-									this._module ? '"module"' : "undefined",
-									expr.range
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								expressions.type = undefined;
-							}
-						} else if (insertType === "comma") {
-							if (this._module || hasSpreadInOptions) {
-								const dep = new ConstDependency(
-									`, type: ${this._module ? '"module"' : "undefined"}`,
-									insertLocation
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
-						} else if (insertType === "spread") {
-							const dep1 = new ConstDependency(
-								"Object.assign({}, ",
-								insertLocation[0]
-							);
-							const dep2 = new ConstDependency(
-								`, { type: ${this._module ? '"module"' : "undefined"} })`,
-								insertLocation[1]
-							);
-							dep1.loc = expr.loc;
-							dep2.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep1);
-							parser.state.module.addPresentationalDependency(dep2);
-						} else if (insertType === "argument") {
-							if (this._module) {
-								const dep = new ConstDependency(
-									', { type: "module" }',
-									insertLocation
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
-						}
-
-						parser.walkExpression(expr.callee);
-						for (const key of Object.keys(expressions)) {
-							if (expressions[key]) parser.walkExpression(expressions[key]);
-						}
-						for (const prop of otherElements) {
-							parser.walkProperty(prop);
-						}
-						if (insertType === "spread") {
-							parser.walkExpression(arg2);
-						}
-
-						return true;
-					};
-					const processItem = item => {
-						if (item.endsWith("()")) {
-							parser.hooks.call
-								.for(item.slice(0, -2))
-								.tap("WorkerPlugin", handleNewWorker);
-						} else {
-							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
-							if (match) {
-								const ids = match[1].split(".");
-								const call = match[2];
-								const source = match[3];
-								(call ? parser.hooks.call : parser.hooks.new)
-									.for(harmonySpecifierTag)
-									.tap("WorkerPlugin", expr => {
-										const settings = /** @type {HarmonySettings} */ (
-											parser.currentTagData
-										);
-										if (
-											!settings ||
-											settings.source !== source ||
-											!equals(settings.ids, ids)
-										) {
-											return;
-										}
-										return handleNewWorker(expr);
-									});
-							} else {
-								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
-							}
-						}
-					};
-					for (const item of options) {
-						if (item === "...") {
-							DEFAULT_SYNTAX.forEach(processItem);
-						} else processItem(item);
-					}
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WorkerPlugin", parserPlugin);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WorkerPlugin", parserPlugin);
-			}
-		);
+/***/ 15427:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+class CriticalDependencyWarning extends WebpackError {
+	constructor(message) {
+		super();
+
+		this.name = "CriticalDependencyWarning";
+		this.message = "Critical dependency: " + message;
 	}
 }
-module.exports = WorkerPlugin;
+
+makeSerializable(
+	CriticalDependencyWarning,
+	"webpack/lib/dependencies/CriticalDependencyWarning"
+);
+
+module.exports = CriticalDependencyWarning;
 
 
 /***/ }),
 
-/***/ 50396:
-/***/ (function(module) {
+/***/ 76760:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-module.exports = expr => {
-	// <FunctionExpression>
-	if (
-		expr.type === "FunctionExpression" ||
-		expr.type === "ArrowFunctionExpression"
-	) {
-		return {
-			fn: expr,
-			expressions: [],
-			needThis: false
-		};
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+class CssExportDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 */
+	constructor(name, value) {
+		super();
+		this.name = name;
+		this.value = value;
 	}
 
-	// <FunctionExpression>.bind(<Expression>)
-	if (
-		expr.type === "CallExpression" &&
-		expr.callee.type === "MemberExpression" &&
-		expr.callee.object.type === "FunctionExpression" &&
-		expr.callee.property.type === "Identifier" &&
-		expr.callee.property.name === "bind" &&
-		expr.arguments.length === 1
-	) {
-		return {
-			fn: expr.callee.object,
-			expressions: [expr.arguments[0]],
-			needThis: undefined
-		};
+	get type() {
+		return "css :export";
 	}
-	// (function(_this) {return <FunctionExpression>})(this) (Coffeescript)
-	if (
-		expr.type === "CallExpression" &&
-		expr.callee.type === "FunctionExpression" &&
-		expr.callee.body.type === "BlockStatement" &&
-		expr.arguments.length === 1 &&
-		expr.arguments[0].type === "ThisExpression" &&
-		expr.callee.body.body &&
-		expr.callee.body.body.length === 1 &&
-		expr.callee.body.body[0].type === "ReturnStatement" &&
-		expr.callee.body.body[0].argument &&
-		expr.callee.body.body[0].argument.type === "FunctionExpression"
-	) {
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.name;
 		return {
-			fn: expr.callee.body.body[0].argument,
-			expressions: [],
-			needThis: true
+			exports: [
+				{
+					name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
 		};
 	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		super.deserialize(context);
+	}
+}
+
+CssExportDependency.Template = class CssExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { cssExports }) {
+		const dep = /** @type {CssExportDependency} */ (dependency);
+		cssExports.set(dep.name, dep.value);
+	}
 };
 
+makeSerializable(
+	CssExportDependency,
+	"webpack/lib/dependencies/CssExportDependency"
+);
+
+module.exports = CssExportDependency;
+
 
 /***/ }),
 
-/***/ 55207:
+/***/ 90542:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { UsageState } = __webpack_require__(63686);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @param {RuntimeSpec} runtime the runtime
- * @param {string[][]} referencedExports list of referenced exports, will be added to
- * @param {string[]} prefix export prefix
- * @param {ExportInfo=} exportInfo the export info
- * @param {boolean} defaultPointsToSelf when true, using default will reference itself
- * @param {Set<ExportInfo>} alreadyVisited already visited export info (to handle circular reexports)
- */
-const processExportInfo = (
-	runtime,
-	referencedExports,
-	prefix,
-	exportInfo,
-	defaultPointsToSelf = false,
-	alreadyVisited = new Set()
-) => {
-	if (!exportInfo) {
-		referencedExports.push(prefix);
-		return;
+class CssImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the argument
+	 * @param {string | undefined} supports list of supports conditions
+	 * @param {string | undefined} media list of media conditions
+	 */
+	constructor(request, range, supports, media) {
+		super(request);
+		this.range = range;
+		this.supports = supports;
+		this.media = media;
 	}
-	const used = exportInfo.getUsed(runtime);
-	if (used === UsageState.Unused) return;
-	if (alreadyVisited.has(exportInfo)) {
-		referencedExports.push(prefix);
-		return;
+
+	get type() {
+		return "css @import";
 	}
-	alreadyVisited.add(exportInfo);
-	if (
-		used !== UsageState.OnlyPropertiesUsed ||
-		!exportInfo.exportsInfo ||
-		exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !==
-			UsageState.Unused
-	) {
-		alreadyVisited.delete(exportInfo);
-		referencedExports.push(prefix);
-		return;
+
+	get category() {
+		return "css-import";
 	}
-	const exportsInfo = exportInfo.exportsInfo;
-	for (const exportInfo of exportsInfo.orderedExports) {
-		processExportInfo(
-			runtime,
-			referencedExports,
-			defaultPointsToSelf && exportInfo.name === "default"
-				? prefix
-				: prefix.concat(exportInfo.name),
-			exportInfo,
-			false,
-			alreadyVisited
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} a module
+	 */
+	createIgnoredModule(context) {
+		return null;
+	}
+}
+
+CssImportDependency.Template = class CssImportDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {CssImportDependency} */ (dependency);
+
+		source.replace(dep.range[0], dep.range[1] - 1, "");
+	}
+};
+
+makeSerializable(
+	CssImportDependency,
+	"webpack/lib/dependencies/CssImportDependency"
+);
+
+module.exports = CssImportDependency;
+
+
+/***/ }),
+
+/***/ 92328:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+class CssLocalIdentifierDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {[number, number]} range range
+	 * @param {string=} prefix prefix
+	 */
+	constructor(name, range, prefix = "") {
+		super();
+		this.name = name;
+		this.range = range;
+		this.prefix = prefix;
+	}
+
+	get type() {
+		return "css local identifier";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.name;
+		return {
+			exports: [
+				{
+					name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
+		};
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.range);
+		write(this.prefix);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.range = read();
+		this.prefix = read();
+		super.deserialize(context);
+	}
+}
+
+const escapeCssIdentifier = (str, omitUnderscore) => {
+	const escaped = `${str}`.replace(
+		// cspell:word uffff
+		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
+		s => `\\${s}`
+	);
+	return !omitUnderscore && /^(?!--)[0-9-]/.test(escaped)
+		? `_${escaped}`
+		: escaped;
+};
+
+CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }
+	) {
+		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportInfo(module, dep.name)
+			.getUsedName(dep.name, runtime);
+		const moduleId = chunkGraph.getModuleId(module);
+		const identifier =
+			dep.prefix +
+			(runtimeTemplate.outputOptions.uniqueName
+				? runtimeTemplate.outputOptions.uniqueName + "-"
+				: "") +
+			(used ? moduleId + "-" + used : "-");
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			escapeCssIdentifier(identifier, dep.prefix)
 		);
+		if (used) cssExports.set(used, identifier);
 	}
-	alreadyVisited.delete(exportInfo);
 };
-module.exports = processExportInfo;
+
+makeSerializable(
+	CssLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssLocalIdentifierDependency"
+);
+
+module.exports = CssLocalIdentifierDependency;
 
 
 /***/ }),
 
-/***/ 32277:
+/***/ 29094:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const ExternalsPlugin = __webpack_require__(6652);
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const CssLocalIdentifierDependency = __webpack_require__(92328);
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class ElectronTargetPlugin {
+class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	/**
-	 * @param {"main" | "preload" | "renderer"=} context in main, preload or renderer context?
+	 * @param {string} name name
+	 * @param {[number, number]} range range
+	 * @param {string=} prefix prefix
+	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
 	 */
-	constructor(context) {
-		this._context = context;
+	constructor(name, range, prefix = "", declaredSet = undefined) {
+		super(name, range, prefix);
+		this.declaredSet = declaredSet;
+	}
+
+	get type() {
+		return "css self local identifier";
+	}
+
+	get category() {
+		return "self";
 	}
+
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `self`;
+	}
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
+		return super.getExports(moduleGraph);
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (this.declaredSet && !this.declaredSet.has(this.name))
+			return Dependency.NO_EXPORTS_REFERENCED;
+		return [[this.name]];
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.declaredSet);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.declaredSet = read();
+		super.deserialize(context);
+	}
+}
+
+CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
+	CssLocalIdentifierDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", [
-			"clipboard",
-			"crash-reporter",
-			"electron",
-			"ipc",
-			"native-image",
-			"original-fs",
-			"screen",
-			"shell"
-		]).apply(compiler);
-		switch (this._context) {
-			case "main":
-				new ExternalsPlugin("node-commonjs", [
-					"app",
-					"auto-updater",
-					"browser-window",
-					"content-tracing",
-					"dialog",
-					"global-shortcut",
-					"ipc-main",
-					"menu",
-					"menu-item",
-					"power-monitor",
-					"power-save-blocker",
-					"protocol",
-					"session",
-					"tray",
-					"web-contents"
-				]).apply(compiler);
-				break;
-			case "preload":
-			case "renderer":
-				new ExternalsPlugin("node-commonjs", [
-					"desktop-capturer",
-					"ipc-renderer",
-					"remote",
-					"web-frame"
-				]).apply(compiler);
-				break;
-		}
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {CssSelfLocalIdentifierDependency} */ (dependency);
+		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
+		super.apply(dependency, source, templateContext);
 	}
-}
+};
 
-module.exports = ElectronTargetPlugin;
+makeSerializable(
+	CssSelfLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
+);
+
+module.exports = CssSelfLocalIdentifierDependency;
 
 
 /***/ }),
 
-/***/ 22273:
+/***/ 70749:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
+const ModuleDependency = __webpack_require__(80321);
 
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class BuildCycleError extends WebpackError {
+const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
+
+class CssUrlDependency extends ModuleDependency {
 	/**
-	 * Creates an instance of ModuleDependencyError.
-	 * @param {Module} module the module starting the cycle
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the argument
+	 * @param {string} cssFunctionKind kind of css function, e. g. url(), image()
 	 */
-	constructor(module) {
-		super(
-			"There is a circular build dependency, which makes it impossible to create this module"
-		);
+	constructor(request, range, cssFunctionKind) {
+		super(request);
+		this.range = range;
+		this.cssFunctionKind = cssFunctionKind;
+	}
 
-		this.name = "BuildCycleError";
-		this.module = module;
+	get type() {
+		return "css url()";
+	}
+
+	get category() {
+		return "url";
+	}
+
+	/**
+	 * @param {string} context context directory
+	 * @returns {Module} a module
+	 */
+	createIgnoredModule(context) {
+		const RawDataUrlModule = getRawDataUrlModule();
+		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.cssFunctionKind);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.cssFunctionKind = read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = BuildCycleError;
+const cssEscapeString = str => {
+	let countWhiteOrBracket = 0;
+	let countQuotation = 0;
+	let countApostrophe = 0;
+	for (let i = 0; i < str.length; i++) {
+		const cc = str.charCodeAt(i);
+		switch (cc) {
+			case 9: // tab
+			case 10: // nl
+			case 32: // space
+			case 40: // (
+			case 41: // )
+				countWhiteOrBracket++;
+				break;
+			case 34:
+				countQuotation++;
+				break;
+			case 39:
+				countApostrophe++;
+				break;
+		}
+	}
+	if (countWhiteOrBracket < 2) {
+		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
+	} else if (countQuotation <= countApostrophe) {
+		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
+	} else {
+		return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
+	}
+};
+
+CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtime, moduleGraph, runtimeTemplate, codeGenerationResults }
+	) {
+		const dep = /** @type {CssUrlDependency} */ (dependency);
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${dep.cssFunctionKind}(${cssEscapeString(
+				runtimeTemplate.assetUrl({
+					publicPath: "",
+					runtime,
+					module: moduleGraph.getModule(dep),
+					codeGenerationResults
+				})
+			)})`
+		);
+	}
+};
+
+makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
+
+module.exports = CssUrlDependency;
 
 
 /***/ }),
 
-/***/ 5294:
+/***/ 22914:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeModule = __webpack_require__(16963);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-class ExportWebpackRequireRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("export webpack runtime", RuntimeModule.STAGE_ATTACH);
+class DelegatedSourceDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
 
-	/**
-	 * @returns {boolean} true, if the runtime module should get it's own scope
-	 */
-	shouldIsolate() {
-		return false;
+	get type() {
+		return "delegated source";
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return "export default __webpack_require__;";
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = ExportWebpackRequireRuntimeModule;
+makeSerializable(
+	DelegatedSourceDependency,
+	"webpack/lib/dependencies/DelegatedSourceDependency"
+);
+
+module.exports = DelegatedSourceDependency;
 
 
 /***/ }),
 
-/***/ 68927:
+/***/ 95666:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -85225,207 +83105,52 @@ module.exports = ExportWebpackRequireRuntimeModule;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const { RuntimeGlobals } = __webpack_require__(91919);
-const HotUpdateChunk = __webpack_require__(9597);
-const Template = __webpack_require__(1626);
-const { getAllChunks } = __webpack_require__(91145);
-const {
-	getCompilationHooks,
-	getChunkFilenameTemplate
-} = __webpack_require__(89464);
-const { updateHashForEntryStartup } = __webpack_require__(98124);
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("../Compiler")} Compiler */
+class DllEntryDependency extends Dependency {
+	constructor(dependencies, name) {
+		super();
 
-class ModuleChunkFormatPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ModuleChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ModuleChunkFormatPlugin",
-					(chunk, set) => {
-						if (chunk.hasRuntime()) return;
-						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.require);
-							set.add(RuntimeGlobals.startupEntrypoint);
-							set.add(RuntimeGlobals.externalInstallChunk);
-						}
-					}
-				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"ModuleChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
-						const source = new ConcatSource();
-						if (hotUpdateChunk) {
-							throw new Error(
-								"HMR is not implemented for module chunk format yet"
-							);
-						} else {
-							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
-							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
-							source.add(`export const modules = `);
-							source.add(modules);
-							source.add(`;\n`);
-							const runtimeModules =
-								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-							if (runtimeModules.length > 0) {
-								source.add("export const runtime =\n");
-								source.add(
-									Template.renderChunkRuntimeModules(
-										runtimeModules,
-										renderContext
-									)
-								);
-							}
-							const entries = Array.from(
-								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-							);
-							if (entries.length > 0) {
-								const runtimeChunk = entries[0][1].getRuntimeChunk();
-								const currentOutputName = compilation
-									.getPath(
-										getChunkFilenameTemplate(chunk, compilation.outputOptions),
-										{
-											chunk,
-											contentHashType: "javascript"
-										}
-									)
-									.split("/");
+		this.dependencies = dependencies;
+		this.name = name;
+	}
 
-								// remove filename, we only need the directory
-								currentOutputName.pop();
+	get type() {
+		return "dll entry";
+	}
 
-								const getRelativePath = chunk => {
-									const baseOutputName = currentOutputName.slice();
-									const chunkOutputName = compilation
-										.getPath(
-											getChunkFilenameTemplate(
-												chunk,
-												compilation.outputOptions
-											),
-											{
-												chunk: chunk,
-												contentHashType: "javascript"
-											}
-										)
-										.split("/");
+	serialize(context) {
+		const { write } = context;
 
-									// remove common parts
-									while (
-										baseOutputName.length > 0 &&
-										chunkOutputName.length > 0 &&
-										baseOutputName[0] === chunkOutputName[0]
-									) {
-										baseOutputName.shift();
-										chunkOutputName.shift();
-									}
-									// create final path
-									return (
-										(baseOutputName.length > 0
-											? "../".repeat(baseOutputName.length)
-											: "./") + chunkOutputName.join("/")
-									);
-								};
+		write(this.dependencies);
+		write(this.name);
 
-								const entrySource = new ConcatSource();
-								entrySource.add(source);
-								entrySource.add(";\n\n// load runtime\n");
-								entrySource.add(
-									`import __webpack_require__ from ${JSON.stringify(
-										getRelativePath(runtimeChunk)
-									)};\n`
-								);
+		super.serialize(context);
+	}
 
-								const startupSource = new ConcatSource();
-								startupSource.add(
-									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-										`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
-										"moduleId"
-									)}\n`
-								);
+	deserialize(context) {
+		const { read } = context;
 
-								const loadedChunks = new Set();
-								let index = 0;
-								for (let i = 0; i < entries.length; i++) {
-									const [module, entrypoint] = entries[i];
-									const final = i + 1 === entries.length;
-									const moduleId = chunkGraph.getModuleId(module);
-									const chunks = getAllChunks(
-										entrypoint,
-										runtimeChunk,
-										undefined
-									);
-									for (const chunk of chunks) {
-										if (loadedChunks.has(chunk)) continue;
-										loadedChunks.add(chunk);
-										startupSource.add(
-											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
-												getRelativePath(chunk)
-											)};\n`
-										);
-										startupSource.add(
-											`${RuntimeGlobals.externalInstallChunk}(__webpack_chunk_${index}__);\n`
-										);
-										index++;
-									}
-									startupSource.add(
-										`${
-											final ? "var __webpack_exports__ = " : ""
-										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
-									);
-								}
+		this.dependencies = read();
+		this.name = read();
 
-								entrySource.add(
-									hooks.renderStartup.call(
-										startupSource,
-										entries[entries.length - 1][0],
-										{
-											...renderContext,
-											inlined: false
-										}
-									)
-								);
-								return entrySource;
-							}
-						}
-						return source;
-					}
-				);
-				hooks.chunkHash.tap(
-					"ModuleChunkFormatPlugin",
-					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update("ModuleChunkFormatPlugin");
-						hash.update("1");
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-					}
-				);
-			}
-		);
+		super.deserialize(context);
 	}
 }
 
-module.exports = ModuleChunkFormatPlugin;
+makeSerializable(
+	DllEntryDependency,
+	"webpack/lib/dependencies/DllEntryDependency"
+);
+
+module.exports = DllEntryDependency;
 
 
 /***/ }),
 
-/***/ 89831:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 32006:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -85435,315 +83160,257 @@ module.exports = ModuleChunkFormatPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const ExportWebpackRequireRuntimeModule = __webpack_require__(5294);
-const ModuleChunkLoadingRuntimeModule = __webpack_require__(64747);
+/** @typedef {import("../Parser").ParserState} ParserState */
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @type {WeakMap<ParserState, boolean>} */
+const parserStateExportsState = new WeakMap();
 
-class ModuleChunkLoadingPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ModuleChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						(options && options.chunkLoading) || globalChunkLoading;
-					return chunkLoading === "import";
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new ModuleChunkLoadingRuntimeModule(set)
-					);
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						compilation.addRuntimeModule(
-							chunk,
-							new ExportWebpackRequireRuntimeModule()
-						);
-					});
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.bailout = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	parserStateExportsState.set(parserState, false);
+	if (value === true) {
+		parserState.module.buildMeta.exportsType = undefined;
+		parserState.module.buildMeta.defaultObject = false;
+	}
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.enable = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value === false) return;
+	parserStateExportsState.set(parserState, true);
+	if (value !== true) {
+		parserState.module.buildMeta.exportsType = "default";
+		parserState.module.buildMeta.defaultObject = "redirect";
+	}
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.setFlagged = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value !== true) return;
+	const buildMeta = parserState.module.buildMeta;
+	if (buildMeta.exportsType === "dynamic") return;
+	buildMeta.exportsType = "flagged";
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.setDynamic = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value !== true) return;
+	parserState.module.buildMeta.exportsType = "dynamic";
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+exports.isEnabled = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	return value === true;
+};
+
+
+/***/ }),
+
+/***/ 3979:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-			}
-		);
+
+
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+
+class EntryDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request path for entry
+	 */
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "entry";
+	}
+
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = ModuleChunkLoadingPlugin;
+makeSerializable(EntryDependency, "webpack/lib/dependencies/EntryDependency");
+
+module.exports = EntryDependency;
 
 
 /***/ }),
 
-/***/ 64747:
+/***/ 78988:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(6967);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const {
-	getChunkFilenameTemplate,
-	chunkHasJs
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
+const { UsageState } = __webpack_require__(63686);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the module
+ * @param {string | null} exportName name of the export if any
+ * @param {string | null} property name of the requested property
+ * @param {RuntimeSpec} runtime for which runtime
+ * @returns {any} value of the property
  */
-
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
+const getProperty = (moduleGraph, module, exportName, property, runtime) => {
+	if (!exportName) {
+		switch (property) {
+			case "usedExports": {
+				const usedExports = moduleGraph
+					.getExportsInfo(module)
+					.getUsedExports(runtime);
+				if (
+					typeof usedExports === "boolean" ||
+					usedExports === undefined ||
+					usedExports === null
+				) {
+					return usedExports;
+				}
+				return Array.from(usedExports).sort();
+			}
 		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
+	}
+	switch (property) {
+		case "used":
+			return (
+				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
+				UsageState.Unused
+			);
+		case "useInfo": {
+			const state = moduleGraph
+				.getExportsInfo(module)
+				.getUsed(exportName, runtime);
+			switch (state) {
+				case UsageState.Used:
+				case UsageState.OnlyPropertiesUsed:
+					return true;
+				case UsageState.Unused:
+					return false;
+				case UsageState.NoInfo:
+					return undefined;
+				case UsageState.Unknown:
+					return null;
+				default:
+					throw new Error(`Unexpected UsageState ${state}`);
+			}
 		}
-		return hooks;
+		case "provideInfo":
+			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
 	}
+	return undefined;
+};
 
-	constructor(runtimeRequirements) {
-		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
-		this._runtimeRequirements = runtimeRequirements;
+class ExportsInfoDependency extends NullDependency {
+	constructor(range, exportName, property) {
+		super();
+		this.range = range;
+		this.exportName = exportName;
+		this.property = property;
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.exportName);
+		write(this.property);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const obj = new ExportsInfoDependency(
+			context.read(),
+			context.read(),
+			context.read()
+		);
+		obj.deserialize(context);
+		return obj;
 	}
+}
+
+makeSerializable(
+	ExportsInfoDependency,
+	"webpack/lib/dependencies/ExportsInfoDependency"
+);
 
+ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @returns {string} runtime code
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation, chunk } = this;
-		const {
-			runtimeTemplate,
-			chunkGraph,
-			outputOptions: { importFunctionName, importMetaName }
-		} = compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withExternalInstallChunk = this._runtimeRequirements.has(
-			RuntimeGlobals.externalInstallChunk
-		);
-		const withLoading = this._runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withOnChunkLoad = this._runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withHmr = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+	apply(dependency, source, { module, moduleGraph, runtime }) {
+		const dep = /** @type {ExportsInfoDependency} */ (dependency);
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
+		const value = getProperty(
+			moduleGraph,
+			module,
+			dep.exportName,
+			dep.property,
+			runtime
 		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			true
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			value === undefined ? "undefined" : JSON.stringify(value)
 		);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_module`
-			: undefined;
-
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
-							rootOutputDir
-						)}, ${importMetaName}.url);`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
-						runtimeTemplate.destructureObject(
-							["ids", "modules", "runtime"],
-							"data"
-						),
-						'// add "modules" to the modules object,',
-						'// then flag all "ids" as loaded and fire callback',
-						"var moduleId, chunkId, i = 0;",
-						"for(moduleId in modules) {",
-						Template.indent([
-							`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
-							Template.indent(
-								`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
-							),
-							"}"
-						]),
-						"}",
-						"if(runtime) runtime(__webpack_require__);",
-						"for(;i < ids.length; i++) {",
-						Template.indent([
-							"chunkId = ids[i];",
-							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
-							Template.indent("installedChunks[chunkId][0]();"),
-							"}",
-							"installedChunks[ids[i]] = 0;"
-						]),
-						"}",
-						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
-				  ])}`
-				: "// no install chunk",
-			"",
-			withLoading
-				? Template.asString([
-						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? Template.indent([
-										"// import() chunk loading for javascript",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[1]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasJsMatcher === true
-													? "if(true) { // all chunks have JS"
-													: `if(${hasJsMatcher("chunkId")}) {`,
-												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = ${importFunctionName}(${JSON.stringify(
-														rootOutputDir
-													)} + ${
-														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
-														"e",
-														[
-															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
-															"throw e;"
-														]
-													)});`,
-													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve]`,
-														"resolve"
-													)})])`,
-													`promises.push(installedChunkData[1] = promise);`
-												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ])
-								: Template.indent(["installedChunks[chunkId] = 0;"])
-						)};`
-				  ])
-				: "// no chunk on demand loading",
-			"",
-			withExternalInstallChunk
-				? Template.asString([
-						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
-				  ])
-				: "// no external install chunk",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.j = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId] === 0",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded"
-		]);
 	}
-}
+};
 
-module.exports = ModuleChunkLoadingRuntimeModule;
+module.exports = ExportsInfoDependency;
 
 
 /***/ }),
 
-/***/ 16734:
-/***/ (function(module) {
+/***/ 23624:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -85753,72 +83420,138 @@ module.exports = ModuleChunkLoadingRuntimeModule;
 
 
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
+const Template = __webpack_require__(39722);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyImportDependency = __webpack_require__(57154);
+const NullDependency = __webpack_require__(31830);
 
-/**
- * @param {SourcePosition} pos position
- * @returns {string} formatted position
- */
-const formatPosition = pos => {
-	if (pos && typeof pos === "object") {
-		if ("line" in pos && "column" in pos) {
-			return `${pos.line}:${pos.column}`;
-		} else if ("line" in pos) {
-			return `${pos.line}:?`;
-		}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+
+class HarmonyAcceptDependency extends NullDependency {
+	/**
+	 * @param {[number, number]} range expression range
+	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
+	 * @param {boolean} hasCallback true, if the range wraps an existing callback
+	 */
+	constructor(range, dependencies, hasCallback) {
+		super();
+		this.range = range;
+		this.dependencies = dependencies;
+		this.hasCallback = hasCallback;
 	}
-	return "";
-};
 
-/**
- * @param {DependencyLocation} loc location
- * @returns {string} formatted location
- */
-const formatLocation = loc => {
-	if (loc && typeof loc === "object") {
-		if ("start" in loc && loc.start && "end" in loc && loc.end) {
-			if (
-				typeof loc.start === "object" &&
-				typeof loc.start.line === "number" &&
-				typeof loc.end === "object" &&
-				typeof loc.end.line === "number" &&
-				typeof loc.end.column === "number" &&
-				loc.start.line === loc.end.line
-			) {
-				return `${formatPosition(loc.start)}-${loc.end.column}`;
-			} else if (
-				typeof loc.start === "object" &&
-				typeof loc.start.line === "number" &&
-				typeof loc.start.column !== "number" &&
-				typeof loc.end === "object" &&
-				typeof loc.end.line === "number" &&
-				typeof loc.end.column !== "number"
-			) {
-				return `${loc.start.line}-${loc.end.line}`;
+	get type() {
+		return "accepted harmony modules";
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.dependencies);
+		write(this.hasCallback);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.dependencies = read();
+		this.hasCallback = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyAcceptDependency,
+	"webpack/lib/dependencies/HarmonyAcceptDependency"
+);
+
+HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
+		const {
+			module,
+			runtime,
+			runtimeRequirements,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph
+		} = templateContext;
+		const content = dep.dependencies
+			.map(dependency => {
+				const referencedModule = moduleGraph.getModule(dependency);
+				return {
+					dependency,
+					runtimeCondition: referencedModule
+						? HarmonyImportDependency.Template.getImportEmittedRuntime(
+								module,
+								referencedModule
+						  )
+						: false
+				};
+			})
+			.filter(({ runtimeCondition }) => runtimeCondition !== false)
+			.map(({ dependency, runtimeCondition }) => {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				const s = dependency.getImportStatement(true, templateContext);
+				const code = s[0] + s[1];
+				if (condition !== "true") {
+					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
+				}
+				return code;
+			})
+			.join("");
+
+		if (dep.hasCallback) {
+			if (runtimeTemplate.supportsArrowFunction()) {
+				source.insert(
+					dep.range[0],
+					`__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`
+				);
+				source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
 			} else {
-				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
-			}
-		}
-		if ("start" in loc && loc.start) {
-			return formatPosition(loc.start);
-		}
-		if ("name" in loc && "index" in loc) {
-			return `${loc.name}[${loc.index}]`;
-		}
-		if ("name" in loc) {
-			return loc.name;
+				source.insert(
+					dep.range[0],
+					`function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`
+				);
+				source.insert(
+					dep.range[1],
+					")(__WEBPACK_OUTDATED_DEPENDENCIES__); }.bind(this)"
+				);
+			}
+			return;
 		}
+
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		source.insert(
+			dep.range[1] - 0.5,
+			`, ${arrow ? "() =>" : "function()"} { ${content} }`
+		);
 	}
-	return "";
 };
 
-module.exports = formatLocation;
+module.exports = HarmonyAcceptDependency;
 
 
 /***/ }),
 
-/***/ 27899:
+/***/ 99843:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -85829,46 +83562,39 @@ module.exports = formatLocation;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyImportDependency = __webpack_require__(57154);
 
-class HotModuleReplacementRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("hot module replacement", RuntimeModule.STAGE_BASIC);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class HarmonyAcceptImportDependency extends HarmonyImportDependency {
+	constructor(request) {
+		super(request, NaN);
+		this.weak = true;
 	}
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return Template.getFunctionContent(
-			require('./HotModuleReplacement.runtime.js')
-		)
-			.replace(/\$getFullHash\$/g, RuntimeGlobals.getFullHash)
-			.replace(
-				/\$interceptModuleExecution\$/g,
-				RuntimeGlobals.interceptModuleExecution
-			)
-			.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-			.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-			.replace(/\$hmrDownloadManifest\$/g, RuntimeGlobals.hmrDownloadManifest)
-			.replace(
-				/\$hmrInvalidateModuleHandlers\$/g,
-				RuntimeGlobals.hmrInvalidateModuleHandlers
-			)
-			.replace(
-				/\$hmrDownloadUpdateHandlers\$/g,
-				RuntimeGlobals.hmrDownloadUpdateHandlers
-			);
+
+	get type() {
+		return "harmony accept";
 	}
 }
 
-module.exports = HotModuleReplacementRuntimeModule;
+makeSerializable(
+	HarmonyAcceptImportDependency,
+	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
+);
+
+HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {};
+
+module.exports = HarmonyAcceptImportDependency;
 
 
 /***/ }),
 
-/***/ 79040:
+/***/ 72906:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -85879,422 +83605,95 @@ module.exports = HotModuleReplacementRuntimeModule;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Dependency = __webpack_require__(54912);
-const Module = __webpack_require__(73208);
-const ModuleFactory = __webpack_require__(51010);
+const { UsageState } = __webpack_require__(63686);
+const InitFragment = __webpack_require__(55870);
 const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const CommonJsRequireDependency = __webpack_require__(21264);
-const { registerNotSerializable } = __webpack_require__(8282);
-
-/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-
-/**
- * @typedef {Object} BackendApi
- * @property {function(Error=): void} dispose
- * @property {function(Module): { client: string, data: string, active: boolean }} module
- */
-
-const HMR_DEPENDENCY_TYPES = new Set([
-	"import.meta.webpackHot.accept",
-	"import.meta.webpackHot.decline",
-	"module.hot.accept",
-	"module.hot.decline"
-]);
-
-/**
- * @param {undefined|string|RegExp|Function} test test option
- * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
- */
-const checkTest = (test, module) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module);
-	}
-	if (typeof test === "string") {
-		const name = module.nameForCondition();
-		return name && name.startsWith(test);
-	}
-	if (test instanceof RegExp) {
-		const name = module.nameForCondition();
-		return name && test.test(name);
-	}
-	return false;
-};
-
-const TYPES = new Set(["javascript"]);
-
-class LazyCompilationDependency extends Dependency {
-	constructor(proxyModule) {
-		super();
-		this.proxyModule = proxyModule;
-	}
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-	get category() {
-		return "esm";
-	}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
 
+class HarmonyCompatibilityDependency extends NullDependency {
 	get type() {
-		return "lazy import()";
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return this.proxyModule.originalModule.identifier();
+		return "harmony export header";
 	}
 }
 
-registerNotSerializable(LazyCompilationDependency);
-
-class LazyCompilationProxyModule extends Module {
-	constructor(context, originalModule, request, client, data, active) {
-		super("lazy-compilation-proxy", context, originalModule.layer);
-		this.originalModule = originalModule;
-		this.request = request;
-		this.client = client;
-		this.data = data;
-		this.active = active;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
-	}
-
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
-			requestShortener
-		)}`;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {LazyCompilationProxyModule} */ (module);
-		this.originalModule = m.originalModule;
-		this.request = m.request;
-		this.client = m.client;
-		this.data = m.data;
-		this.active = m.active;
-	}
-
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
-	}
-
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo || this.buildInfo.active !== this.active);
-	}
+makeSerializable(
+	HarmonyCompatibilityDependency,
+	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
+);
 
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildInfo = {
-			active: this.active
-		};
-		/** @type {BuildMeta} */
-		this.buildMeta = {};
-		this.clearDependenciesAndBlocks();
-		const dep = new CommonJsRequireDependency(this.client);
-		this.addDependency(dep);
-		if (this.active) {
-			const dep = new LazyCompilationDependency(this);
-			const block = new AsyncDependenciesBlock({});
-			block.addDependency(dep);
-			this.addBlock(block);
+	apply(
+		dependency,
+		source,
+		{
+			module,
+			runtimeTemplate,
+			moduleGraph,
+			initFragments,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
 		}
-		callback();
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
-
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 200;
-	}
-
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
-		const sources = new Map();
-		const runtimeRequirements = new Set();
-		runtimeRequirements.add(RuntimeGlobals.module);
-		const clientDep = /** @type {CommonJsRequireDependency} */ (
-			this.dependencies[0]
-		);
-		const clientModule = moduleGraph.getModule(clientDep);
-		const block = this.blocks[0];
-		const client = Template.asString([
-			`var client = ${runtimeTemplate.moduleExports({
-				module: clientModule,
-				chunkGraph,
-				request: clientDep.userRequest,
+	) {
+		if (concatenationScope) return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		if (
+			exportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
+			UsageState.Unused
+		) {
+			const content = runtimeTemplate.defineEsModuleFlagStatement({
+				exportsArgument: module.exportsArgument,
 				runtimeRequirements
-			})}`,
-			`var data = ${JSON.stringify(this.data)};`
-		]);
-		const keepActive = Template.asString([
-			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
-				!!block
-			)}, module: module, onError: onError });`
-		]);
-		let source;
-		if (block) {
-			const dep = block.dependencies[0];
-			const module = moduleGraph.getModule(dep);
-			source = Template.asString([
-				client,
-				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
-					chunkGraph,
-					block,
-					module,
-					request: this.request,
-					strict: false, // TODO this should be inherited from the original module
-					message: "import()",
-					runtimeRequirements
-				})};`,
-				"if (module.hot) {",
-				Template.indent([
-					"module.hot.accept();",
-					`module.hot.accept(${JSON.stringify(
-						chunkGraph.getModuleId(module)
-					)}, function() { module.hot.invalidate(); });`,
-					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
-				]),
-				"}",
-				"function onError() { /* ignore */ }",
-				keepActive
-			]);
-		} else {
-			source = Template.asString([
-				client,
-				"var resolveSelf, onError;",
-				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
-				"if (module.hot) {",
-				Template.indent([
-					"module.hot.accept();",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
-					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
-				]),
-				"}",
-				keepActive
-			]);
-		}
-		sources.set("javascript", new RawSource(source));
-		return {
-			sources,
-			runtimeRequirements
-		};
-	}
-
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		super.updateHash(hash, context);
-		hash.update(this.active ? "active" : "");
-		hash.update(JSON.stringify(this.data));
-	}
-}
-
-registerNotSerializable(LazyCompilationProxyModule);
-
-class LazyCompilationDependencyFactory extends ModuleFactory {
-	constructor(factory) {
-		super();
-		this._factory = factory;
-	}
-
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		const dependency = /** @type {LazyCompilationDependency} */ (
-			data.dependencies[0]
-		);
-		callback(null, {
-			module: dependency.proxyModule.originalModule
-		});
-	}
-}
-
-class LazyCompilationPlugin {
-	/**
-	 * @param {Object} options options
-	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
-	 * @param {boolean} options.entries true, when entries are lazy compiled
-	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
-	 */
-	constructor({ backend, entries, imports, test }) {
-		this.backend = backend;
-		this.entries = entries;
-		this.imports = imports;
-		this.test = test;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		let backend;
-		compiler.hooks.beforeCompile.tapAsync(
-			"LazyCompilationPlugin",
-			(params, callback) => {
-				if (backend !== undefined) return callback();
-				const promise = this.backend(compiler, (err, result) => {
-					if (err) return callback(err);
-					backend = result;
-					callback();
-				});
-				if (promise && promise.then) {
-					promise.then(b => {
-						backend = b;
-						callback();
-					}, callback);
-				}
-			}
-		);
-		compiler.hooks.thisCompilation.tap(
-			"LazyCompilationPlugin",
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.module.tap(
-					"LazyCompilationPlugin",
-					(originalModule, createData, resolveData) => {
-						if (
-							resolveData.dependencies.every(dep =>
-								HMR_DEPENDENCY_TYPES.has(dep.type)
-							)
-						) {
-							// for HMR only resolving, try to determine if the HMR accept/decline refers to
-							// an import() or not
-							const hmrDep = resolveData.dependencies[0];
-							const originModule =
-								compilation.moduleGraph.getParentModule(hmrDep);
-							const isReferringToDynamicImport = originModule.blocks.some(
-								block =>
-									block.dependencies.some(
-										dep =>
-											dep.type === "import()" &&
-											/** @type {HarmonyImportDependency} */ (dep).request ===
-												hmrDep.request
-									)
-							);
-							if (!isReferringToDynamicImport) return;
-						} else if (
-							!resolveData.dependencies.every(
-								dep =>
-									HMR_DEPENDENCY_TYPES.has(dep.type) ||
-									(this.imports &&
-										(dep.type === "import()" ||
-											dep.type === "import() context element")) ||
-									(this.entries && dep.type === "entry")
-							)
-						)
-							return;
-						if (
-							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
-								resolveData.request
-							) ||
-							!checkTest(this.test, originalModule)
-						)
-							return;
-						const moduleInfo = backend.module(originalModule);
-						if (!moduleInfo) return;
-						const { client, data, active } = moduleInfo;
-
-						return new LazyCompilationProxyModule(
-							compiler.context,
-							originalModule,
-							resolveData.request,
-							client,
-							data,
-							active
-						);
-					}
-				);
-				compilation.dependencyFactories.set(
-					LazyCompilationDependency,
-					new LazyCompilationDependencyFactory()
-				);
-			}
-		);
-		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
-			backend.dispose(callback);
-		});
+			});
+			initFragments.push(
+				new InitFragment(
+					content,
+					InitFragment.STAGE_HARMONY_EXPORTS,
+					0,
+					"harmony compatibility"
+				)
+			);
+		}
+		if (moduleGraph.isAsync(module)) {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+			initFragments.push(
+				new InitFragment(
+					runtimeTemplate.supportsArrowFunction()
+						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+					InitFragment.STAGE_ASYNC_BOUNDARY,
+					0,
+					undefined,
+					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
+						module.buildMeta.async ? ", 1" : ""
+					});`
+				)
+			);
+		}
 	}
-}
+};
 
-module.exports = LazyCompilationPlugin;
+module.exports = HarmonyCompatibilityDependency;
 
 
 /***/ }),
 
-/***/ 17781:
+/***/ 17223:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -86305,147 +83704,101 @@ module.exports = LazyCompilationPlugin;
 
 
 
-/** @typedef {import("http").ServerOptions} HttpServerOptions */
-/** @typedef {import("https").ServerOptions} HttpsServerOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
-/** @typedef {import("../Compiler")} Compiler */
-
-/**
- * @callback BackendHandler
- * @param {Compiler} compiler compiler
- * @param {function((Error | null)=, any=): void} callback callback
- * @returns {void}
- */
-
-/**
- * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
- * @returns {BackendHandler} backend
- */
-module.exports = options => (compiler, callback) => {
-	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
-	const activeModules = new Map();
-	const prefix = "/lazy-compilation-using-";
-
-	const isHttps =
-		options.protocol === "https" ||
-		(typeof options.server === "object" &&
-			("key" in options.server || "pfx" in options.server));
-
-	const createServer =
-		typeof options.server === "function"
-			? options.server
-			: (() => {
-					const http = isHttps ? __webpack_require__(95687) : __webpack_require__(13685);
-					return http.createServer.bind(http, options.server);
-			  })();
-	const listen =
-		typeof options.listen === "function"
-			? options.listen
-			: server => {
-					let listen = options.listen;
-					if (typeof listen === "object" && !("port" in listen))
-						listen = { ...listen, port: undefined };
-					server.listen(listen);
-			  };
+const DynamicExports = __webpack_require__(32006);
+const HarmonyCompatibilityDependency = __webpack_require__(72906);
+const HarmonyExports = __webpack_require__(39211);
 
-	const protocol = options.protocol || (isHttps ? "https" : "http");
+module.exports = class HarmonyDetectionParserPlugin {
+	constructor(options) {
+		const { topLevelAwait = false } = options || {};
+		this.topLevelAwait = topLevelAwait;
+	}
 
-	const requestListener = (req, res) => {
-		const keys = req.url.slice(prefix.length).split("@");
-		req.socket.on("close", () => {
-			setTimeout(() => {
-				for (const key of keys) {
-					const oldValue = activeModules.get(key) || 0;
-					activeModules.set(key, oldValue - 1);
-					if (oldValue === 1) {
-						logger.log(
-							`${key} is no longer in use. Next compilation will skip this module.`
-						);
-					}
-				}
-			}, 120000);
-		});
-		req.socket.setNoDelay(true);
-		res.writeHead(200, {
-			"content-type": "text/event-stream",
-			"Access-Control-Allow-Origin": "*",
-			"Access-Control-Allow-Methods": "*",
-			"Access-Control-Allow-Headers": "*"
+	apply(parser) {
+		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
+			const isStrictHarmony = parser.state.module.type === "javascript/esm";
+			const isHarmony =
+				isStrictHarmony ||
+				ast.body.some(
+					statement =>
+						statement.type === "ImportDeclaration" ||
+						statement.type === "ExportDefaultDeclaration" ||
+						statement.type === "ExportNamedDeclaration" ||
+						statement.type === "ExportAllDeclaration"
+				);
+			if (isHarmony) {
+				const module = parser.state.module;
+				const compatDep = new HarmonyCompatibilityDependency();
+				compatDep.loc = {
+					start: {
+						line: -1,
+						column: 0
+					},
+					end: {
+						line: -1,
+						column: 0
+					},
+					index: -3
+				};
+				module.addPresentationalDependency(compatDep);
+				DynamicExports.bailout(parser.state);
+				HarmonyExports.enable(parser.state, isStrictHarmony);
+				parser.scope.isStrict = true;
+			}
 		});
-		res.write("\n");
-		let moduleActivated = false;
-		for (const key of keys) {
-			const oldValue = activeModules.get(key) || 0;
-			activeModules.set(key, oldValue + 1);
-			if (oldValue === 0) {
-				logger.log(`${key} is now in use and will be compiled.`);
-				moduleActivated = true;
+
+		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
+			const module = parser.state.module;
+			if (!this.topLevelAwait) {
+				throw new Error(
+					"The top-level-await experiment is not enabled (set experiments.topLevelAwait: true to enabled it)"
+				);
 			}
-		}
-		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
-	};
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				throw new Error(
+					"Top-level-await is only supported in EcmaScript Modules"
+				);
+			}
+			module.buildMeta.async = true;
+		});
 
-	const server = /** @type {import("net").Server} */ (createServer());
-	server.on("request", requestListener);
+		const skipInHarmony = () => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				return true;
+			}
+		};
 
-	let isClosing = false;
-	/** @type {Set<import("net").Socket>} */
-	const sockets = new Set();
-	server.on("connection", socket => {
-		sockets.add(socket);
-		socket.on("close", () => {
-			sockets.delete(socket);
-		});
-		if (isClosing) socket.destroy();
-	});
-	server.on("clientError", e => {
-		if (e.message !== "Server is disposing") logger.warn(e);
-	});
-	server.on("listening", err => {
-		if (err) return callback(err);
-		const addr = server.address();
-		if (typeof addr === "string") throw new Error("addr must not be a string");
-		const urlBase =
-			addr.address === "::" || addr.address === "0.0.0.0"
-				? `${protocol}://localhost:${addr.port}`
-				: addr.family === "IPv6"
-				? `${protocol}://[${addr.address}]:${addr.port}`
-				: `${protocol}://${addr.address}:${addr.port}`;
-		logger.log(
-			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
-		);
-		callback(null, {
-			dispose(callback) {
-				isClosing = true;
-				// Removing the listener is a workaround for a memory leak in node.js
-				server.off("request", requestListener);
-				server.close(err => {
-					callback(err);
-				});
-				for (const socket of sockets) {
-					socket.destroy(new Error("Server is disposing"));
-				}
-			},
-			module(originalModule) {
-				const key = `${encodeURIComponent(
-					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
-				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
-				const active = activeModules.get(key) > 0;
-				return {
-					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
-					data: key,
-					active
-				};
+		const nullInHarmony = () => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				return null;
 			}
-		});
-	});
-	listen(server);
+		};
+
+		const nonHarmonyIdentifiers = ["define", "exports"];
+		for (const identifier of nonHarmonyIdentifiers) {
+			parser.hooks.evaluateTypeof
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
+			parser.hooks.typeof
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+			parser.hooks.evaluate
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
+			parser.hooks.expression
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+			parser.hooks.call
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+		}
+	}
 };
 
 
 /***/ }),
 
-/***/ 64618:
+/***/ 93466:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -86456,263 +83809,387 @@ module.exports = options => (compiler, callback) => {
 
 
 
-const { find } = __webpack_require__(93347);
+const InnerGraph = __webpack_require__(38988);
+const ConstDependency = __webpack_require__(76911);
+const HarmonyExportExpressionDependency = __webpack_require__(51340);
+const HarmonyExportHeaderDependency = __webpack_require__(38873);
+const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
+const HarmonyExportSpecifierDependency = __webpack_require__(48567);
+const { ExportPresenceModes } = __webpack_require__(57154);
 const {
-	compareModulesByPreOrderIndexOrIdentifier,
-	compareModulesByPostOrderIndexOrIdentifier
-} = __webpack_require__(29579);
+	harmonySpecifierTag,
+	getAssertions
+} = __webpack_require__(20862);
+const HarmonyImportSideEffectDependency = __webpack_require__(73132);
 
-/** @typedef {import("../Compiler")} Compiler */
+const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
 
-class ChunkModuleIdRangePlugin {
+module.exports = class HarmonyExportDependencyParserPlugin {
 	constructor(options) {
-		this.options = options;
+		this.exportPresenceMode =
+			options.reexportExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("ChunkModuleIdRangePlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.moduleIds.tap("ChunkModuleIdRangePlugin", modules => {
-				const chunkGraph = compilation.chunkGraph;
-				const chunk = find(
-					compilation.chunks,
-					chunk => chunk.name === options.name
+	apply(parser) {
+		const { exportPresenceMode } = this;
+		parser.hooks.export.tap(
+			"HarmonyExportDependencyParserPlugin",
+			statement => {
+				const dep = new HarmonyExportHeaderDependency(
+					statement.declaration && statement.declaration.range,
+					statement.range
 				);
-				if (!chunk) {
-					throw new Error(
-						`ChunkModuleIdRangePlugin: Chunk with name '${options.name}"' was not found`
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = -1;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		);
+		parser.hooks.exportImport.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency("", statement.range);
+				clearDep.loc = Object.create(statement.loc);
+				clearDep.loc.index = -1;
+				parser.state.module.addPresentationalDependency(clearDep);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					source,
+					parser.state.lastHarmonyImportOrder,
+					getAssertions(statement)
+				);
+				sideEffectDep.loc = Object.create(statement.loc);
+				sideEffectDep.loc.index = -1;
+				parser.state.current.addDependency(sideEffectDep);
+				return true;
+			}
+		);
+		parser.hooks.exportExpression.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, expr) => {
+				const isFunctionDeclaration = expr.type === "FunctionDeclaration";
+				const comments = parser.getComments([
+					statement.range[0],
+					expr.range[0]
+				]);
+				const dep = new HarmonyExportExpressionDependency(
+					expr.range,
+					statement.range,
+					comments
+						.map(c => {
+							switch (c.type) {
+								case "Block":
+									return `/*${c.value}*/`;
+								case "Line":
+									return `//${c.value}\n`;
+							}
+							return "";
+						})
+						.join(""),
+					expr.type.endsWith("Declaration") && expr.id
+						? expr.id.name
+						: isFunctionDeclaration
+						? {
+								id: expr.id ? expr.id.name : undefined,
+								range: [
+									expr.range[0],
+									expr.params.length > 0
+										? expr.params[0].range[0]
+										: expr.body.range[0]
+								],
+								prefix: `${expr.async ? "async " : ""}function${
+									expr.generator ? "*" : ""
+								} `,
+								suffix: `(${expr.params.length > 0 ? "" : ") "}`
+						  }
+						: undefined
+				);
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = -1;
+				parser.state.current.addDependency(dep);
+				InnerGraph.addVariableUsage(
+					parser,
+					expr.type.endsWith("Declaration") && expr.id
+						? expr.id.name
+						: "*default*",
+					"default"
+				);
+				return true;
+			}
+		);
+		parser.hooks.exportSpecifier.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, id, name, idx) => {
+				const settings = parser.getTagData(id, harmonySpecifierTag);
+				let dep;
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				harmonyNamedExports.add(name);
+				InnerGraph.addVariableUsage(parser, id, name);
+				if (settings) {
+					dep = new HarmonyExportImportedSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						settings.ids,
+						name,
+						harmonyNamedExports,
+						null,
+						exportPresenceMode,
+						null,
+						settings.assertions
 					);
-				}
-
-				let chunkModules;
-				if (options.order) {
-					let cmpFn;
-					switch (options.order) {
-						case "index":
-						case "preOrderIndex":
-							cmpFn = compareModulesByPreOrderIndexOrIdentifier(moduleGraph);
-							break;
-						case "index2":
-						case "postOrderIndex":
-							cmpFn = compareModulesByPostOrderIndexOrIdentifier(moduleGraph);
-							break;
-						default:
-							throw new Error(
-								"ChunkModuleIdRangePlugin: unexpected value of order"
-							);
-					}
-					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
 				} else {
-					chunkModules = Array.from(modules)
-						.filter(m => {
-							return chunkGraph.isModuleInChunk(m, chunk);
-						})
-						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
-				}
-
-				let currentId = options.start || 0;
-				for (let i = 0; i < chunkModules.length; i++) {
-					const m = chunkModules[i];
-					if (m.needId && chunkGraph.getModuleId(m) === null) {
-						chunkGraph.setModuleId(m, currentId++);
-					}
-					if (options.end && currentId > options.end) break;
+					dep = new HarmonyExportSpecifierDependency(id, name);
 				}
-			});
-		});
-	}
-}
-module.exports = ChunkModuleIdRangePlugin;
-
-
-/***/ }),
-
-/***/ 8747:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
-
-
-
-const { compareChunksNatural } = __webpack_require__(29579);
-const {
-	getFullChunkName,
-	getUsedChunkIds,
-	assignDeterministicIds
-} = __webpack_require__(63290);
-
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-
-class DeterministicChunkIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DeterministicChunkIdsPlugin",
-			compilation => {
-				compilation.hooks.chunkIds.tap(
-					"DeterministicChunkIdsPlugin",
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						const context = this.options.context
-							? this.options.context
-							: compiler.context;
-						const maxLength = this.options.maxLength || 3;
-
-						const compareNatural = compareChunksNatural(chunkGraph);
-
-						const usedIds = getUsedChunkIds(compilation);
-						assignDeterministicIds(
-							Array.from(chunks).filter(chunk => {
-								return chunk.id === null;
-							}),
-							chunk =>
-								getFullChunkName(chunk, chunkGraph, context, compiler.root),
-							compareNatural,
-							(chunk, id) => {
-								const size = usedIds.size;
-								usedIds.add(`${id}`);
-								if (size === usedIds.size) return false;
-								chunk.id = id;
-								chunk.ids = [id];
-								return true;
-							},
-							[Math.pow(10, maxLength)],
-							10,
-							usedIds.size
-						);
-					}
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = idx;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		);
+		parser.hooks.exportImportSpecifier.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, source, id, name, idx) => {
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				let harmonyStarExports = null;
+				if (name) {
+					harmonyNamedExports.add(name);
+				} else {
+					harmonyStarExports = parser.state.harmonyStarExports =
+						parser.state.harmonyStarExports || new HarmonyStarExportsList();
+				}
+				const dep = new HarmonyExportImportedSpecifierDependency(
+					source,
+					parser.state.lastHarmonyImportOrder,
+					id ? [id] : [],
+					name,
+					harmonyNamedExports,
+					harmonyStarExports && harmonyStarExports.slice(),
+					exportPresenceMode,
+					harmonyStarExports
 				);
+				if (harmonyStarExports) {
+					harmonyStarExports.push(dep);
+				}
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = idx;
+				parser.state.current.addDependency(dep);
+				return true;
 			}
 		);
 	}
-}
-
-module.exports = DeterministicChunkIdsPlugin;
+};
 
 
 /***/ }),
 
-/***/ 76692:
+/***/ 51340:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const {
-	getUsedModuleIdsAndModules,
-	getFullModuleName,
-	assignDeterministicIds
-} = __webpack_require__(63290);
+const ConcatenationScope = __webpack_require__(98229);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyExportInitFragment = __webpack_require__(89500);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+
+class HarmonyExportExpressionDependency extends NullDependency {
+	constructor(range, rangeStatement, prefix, declarationId) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
+		this.prefix = prefix;
+		this.declarationId = declarationId;
+	}
+
+	get type() {
+		return "harmony export expression";
+	}
 
-class DeterministicModuleIdsPlugin {
 	/**
-	 * @param {Object} options options
-	 * @param {string=} options.context context relative to which module identifiers are computed
-	 * @param {function(Module): boolean=} options.test selector function for modules
-	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
-	 * @param {number=} options.salt hash salt for ids
-	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
-	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
 	 */
-	constructor(options = {}) {
-		this.options = options;
+	getExports(moduleGraph) {
+		return {
+			exports: ["default"],
+			priority: 1,
+			terminalBinding: true,
+			dependencies: undefined
+		};
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		// The expression/declaration is already covered by SideEffectsFlagPlugin
+		return false;
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.rangeStatement);
+		write(this.prefix);
+		write(this.declarationId);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.rangeStatement = read();
+		this.prefix = read();
+		this.declarationId = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyExportExpressionDependency,
+	"webpack/lib/dependencies/HarmonyExportExpressionDependency"
+);
+
+HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DeterministicModuleIdsPlugin",
-			compilation => {
-				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
-					const chunkGraph = compilation.chunkGraph;
-					const context = this.options.context
-						? this.options.context
-						: compiler.context;
-					const maxLength = this.options.maxLength || 3;
-					const failOnConflict = this.options.failOnConflict || false;
-					const fixedLength = this.options.fixedLength || false;
-					const salt = this.options.salt || 0;
-					let conflicts = 0;
+	apply(
+		dependency,
+		source,
+		{
+			module,
+			moduleGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			initFragments,
+			runtime,
+			concatenationScope
+		}
+	) {
+		const dep = /** @type {HarmonyExportExpressionDependency} */ (dependency);
+		const { declarationId } = dep;
+		const exportsName = module.exportsArgument;
+		if (declarationId) {
+			let name;
+			if (typeof declarationId === "string") {
+				name = declarationId;
+			} else {
+				name = ConcatenationScope.DEFAULT_EXPORT;
+				source.replace(
+					declarationId.range[0],
+					declarationId.range[1] - 1,
+					`${declarationId.prefix}${name}${declarationId.suffix}`
+				);
+			}
 
-					const [usedIds, modules] = getUsedModuleIdsAndModules(
-						compilation,
-						this.options.test
-					);
-					assignDeterministicIds(
-						modules,
-						module => getFullModuleName(module, context, compiler.root),
-						failOnConflict
-							? () => 0
-							: compareModulesByPreOrderIndexOrIdentifier(
-									compilation.moduleGraph
-							  ),
-						(module, id) => {
-							const size = usedIds.size;
-							usedIds.add(`${id}`);
-							if (size === usedIds.size) {
-								conflicts++;
-								return false;
-							}
-							chunkGraph.setModuleId(module, id);
-							return true;
-						},
-						[Math.pow(10, maxLength)],
-						fixedLength ? 0 : 10,
-						usedIds.size,
-						salt
-					);
-					if (failOnConflict && conflicts)
-						throw new Error(
-							`Assigning deterministic module ids has lead to ${conflicts} conflict${
-								conflicts > 1 ? "s" : ""
-							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
-						);
-				});
+			if (concatenationScope) {
+				concatenationScope.registerExport("default", name);
+			} else {
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName("default", runtime);
+				if (used) {
+					const map = new Map();
+					map.set(used, `/* export default binding */ ${name}`);
+					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+				}
 			}
-		);
+
+			source.replace(
+				dep.rangeStatement[0],
+				dep.range[0] - 1,
+				`/* harmony default export */ ${dep.prefix}`
+			);
+		} else {
+			let content;
+			const name = ConcatenationScope.DEFAULT_EXPORT;
+			if (runtimeTemplate.supportsConst()) {
+				content = `/* harmony default export */ const ${name} = `;
+				if (concatenationScope) {
+					concatenationScope.registerExport("default", name);
+				} else {
+					const used = moduleGraph
+						.getExportsInfo(module)
+						.getUsedName("default", runtime);
+					if (used) {
+						runtimeRequirements.add(RuntimeGlobals.exports);
+						const map = new Map();
+						map.set(used, name);
+						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+					} else {
+						content = `/* unused harmony default export */ var ${name} = `;
+					}
+				}
+			} else if (concatenationScope) {
+				content = `/* harmony default export */ var ${name} = `;
+				concatenationScope.registerExport("default", name);
+			} else {
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName("default", runtime);
+				if (used) {
+					runtimeRequirements.add(RuntimeGlobals.exports);
+					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
+					content = `/* harmony default export */ ${exportsName}[${JSON.stringify(
+						used
+					)}] = `;
+				} else {
+					content = `/* unused harmony default export */ var ${name} = `;
+				}
+			}
+
+			if (dep.range) {
+				source.replace(
+					dep.rangeStatement[0],
+					dep.range[0] - 1,
+					content + "(" + dep.prefix
+				);
+				source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
+				return;
+			}
+
+			source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
+		}
 	}
-}
+};
 
-module.exports = DeterministicModuleIdsPlugin;
+module.exports = HarmonyExportExpressionDependency;
 
 
 /***/ }),
 
-/***/ 21825:
+/***/ 38873:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -86723,82 +84200,70 @@ module.exports = DeterministicModuleIdsPlugin;
 
 
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const {
-	getUsedModuleIdsAndModules,
-	getFullModuleName
-} = __webpack_require__(63290);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-const validate = createSchemaValidation(
-	__webpack_require__(52210),
-	() => __webpack_require__(59106),
-	{
-		name: "Hashed Module Ids Plugin",
-		baseDataPath: "options"
+class HarmonyExportHeaderDependency extends NullDependency {
+	constructor(range, rangeStatement) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
 	}
-);
-
-class HashedModuleIdsPlugin {
-	/**
-	 * @param {HashedModuleIdsPluginOptions=} options options object
-	 */
-	constructor(options = {}) {
-		validate(options);
 
-		/** @type {HashedModuleIdsPluginOptions} */
-		this.options = {
-			context: null,
-			hashFunction: "md4",
-			hashDigest: "base64",
-			hashDigestLength: 4,
-			...options
-		};
+	get type() {
+		return "harmony export header";
 	}
 
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
-				const chunkGraph = compilation.chunkGraph;
-				const context = this.options.context
-					? this.options.context
-					: compiler.context;
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.rangeStatement);
+		super.serialize(context);
+	}
 
-				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
-				const modulesInNaturalOrder = modules.sort(
-					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-				);
-				for (const module of modulesInNaturalOrder) {
-					const ident = getFullModuleName(module, context, compiler.root);
-					const hash = createHash(options.hashFunction);
-					hash.update(ident || "");
-					const hashId = /** @type {string} */ (
-						hash.digest(options.hashDigest)
-					);
-					let len = options.hashDigestLength;
-					while (usedIds.has(hashId.substr(0, len))) len++;
-					const moduleId = hashId.substr(0, len);
-					chunkGraph.setModuleId(module, moduleId);
-					usedIds.add(moduleId);
-				}
-			});
-		});
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.rangeStatement = read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = HashedModuleIdsPlugin;
+makeSerializable(
+	HarmonyExportHeaderDependency,
+	"webpack/lib/dependencies/HarmonyExportHeaderDependency"
+);
+
+HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyExportHeaderDependency} */ (dependency);
+		const content = "";
+		const replaceUntil = dep.range
+			? dep.range[0] - 1
+			: dep.rangeStatement[1] - 1;
+		source.replace(dep.rangeStatement[0], replaceUntil, content);
+	}
+};
+
+module.exports = HarmonyExportHeaderDependency;
 
 
 /***/ }),
 
-/***/ 63290:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 67157:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -86808,979 +84273,1275 @@ module.exports = HashedModuleIdsPlugin;
 
 
 
-const createHash = __webpack_require__(49835);
-const { makePathsRelative } = __webpack_require__(82186);
-const numberHash = __webpack_require__(70002);
+const Dependency = __webpack_require__(54912);
+const { UsageState } = __webpack_require__(63686);
+const HarmonyLinkingError = __webpack_require__(97511);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const { countIterable } = __webpack_require__(39104);
+const { first, combine } = __webpack_require__(93347);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { getRuntimeKey, keyToRuntime } = __webpack_require__(17156);
+const HarmonyExportInitFragment = __webpack_require__(89500);
+const HarmonyImportDependency = __webpack_require__(57154);
+const processExportInfo = __webpack_require__(55207);
 
-/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
 /** @typedef {import("../Module")} Module */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/** @typedef {"missing"|"unused"|"empty-star"|"reexport-dynamic-default"|"reexport-named-default"|"reexport-namespace-object"|"reexport-fake-namespace-object"|"reexport-undefined"|"normal-reexport"|"dynamic-reexport"} ExportModeType */
+
+const { ExportPresenceModes } = HarmonyImportDependency;
+
+const idsSymbol = Symbol("HarmonyExportImportedSpecifierDependency.ids");
+
+class NormalReexportItem {
+	/**
+	 * @param {string} name export name
+	 * @param {string[]} ids reexported ids from other module
+	 * @param {ExportInfo} exportInfo export info from other module
+	 * @param {boolean} checked true, if it should be checked at runtime if this export exists
+	 * @param {boolean} hidden true, if it is hidden behind another active export in the same module
+	 */
+	constructor(name, ids, exportInfo, checked, hidden) {
+		this.name = name;
+		this.ids = ids;
+		this.exportInfo = exportInfo;
+		this.checked = checked;
+		this.hidden = hidden;
+	}
+}
+
+class ExportMode {
+	/**
+	 * @param {ExportModeType} type type of the mode
+	 */
+	constructor(type) {
+		/** @type {ExportModeType} */
+		this.type = type;
+
+		// for "normal-reexport":
+		/** @type {NormalReexportItem[] | null} */
+		this.items = null;
+
+		// for "reexport-named-default" | "reexport-fake-namespace-object" | "reexport-namespace-object"
+		/** @type {string|null} */
+		this.name = null;
+		/** @type {ExportInfo | null} */
+		this.partialNamespaceExportInfo = null;
+
+		// for "dynamic-reexport":
+		/** @type {Set<string> | null} */
+		this.ignored = null;
+
+		// for "dynamic-reexport" | "empty-star":
+		/** @type {Set<string> | null} */
+		this.hidden = null;
+
+		// for "missing":
+		/** @type {string | null} */
+		this.userRequest = null;
+
+		// for "reexport-fake-namespace-object":
+		/** @type {number} */
+		this.fakeType = 0;
+	}
+}
+
+const determineExportAssignments = (
+	moduleGraph,
+	dependencies,
+	additionalDependency
+) => {
+	const names = new Set();
+	const dependencyIndices = [];
+
+	if (additionalDependency) {
+		dependencies = dependencies.concat(additionalDependency);
+	}
+
+	for (const dep of dependencies) {
+		const i = dependencyIndices.length;
+		dependencyIndices[i] = names.size;
+		const otherImportedModule = moduleGraph.getModule(dep);
+		if (otherImportedModule) {
+			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
+			for (const exportInfo of exportsInfo.exports) {
+				if (
+					exportInfo.provided === true &&
+					exportInfo.name !== "default" &&
+					!names.has(exportInfo.name)
+				) {
+					names.add(exportInfo.name);
+					dependencyIndices[i] = names.size;
+				}
+			}
+		}
+	}
+	dependencyIndices.push(names.size);
 
-/**
- * @param {string} str string to hash
- * @param {number} len max length of the hash
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const getHash = (str, len, hashFunction) => {
-	const hash = createHash(hashFunction);
-	hash.update(str);
-	const digest = /** @type {string} */ (hash.digest("hex"));
-	return digest.substr(0, len);
+	return { names: Array.from(names), dependencyIndices };
 };
 
-/**
- * @param {string} str the string
- * @returns {string} string prefixed by an underscore if it is a number
- */
-const avoidNumber = str => {
-	// max length of a number is 21 chars, bigger numbers a written as "...e+xx"
-	if (str.length > 21) return str;
-	const firstChar = str.charCodeAt(0);
-	// skip everything that doesn't look like a number
-	// charCodes: "-": 45, "1": 49, "9": 57
-	if (firstChar < 49) {
-		if (firstChar !== 45) return str;
-	} else if (firstChar > 57) {
-		return str;
-	}
-	if (str === +str + "") {
-		return `_${str}`;
+const findDependencyForName = (
+	{ names, dependencyIndices },
+	name,
+	dependencies
+) => {
+	const dependenciesIt = dependencies[Symbol.iterator]();
+	const dependencyIndicesIt = dependencyIndices[Symbol.iterator]();
+	let dependenciesItResult = dependenciesIt.next();
+	let dependencyIndicesItResult = dependencyIndicesIt.next();
+	if (dependencyIndicesItResult.done) return;
+	for (let i = 0; i < names.length; i++) {
+		while (i >= dependencyIndicesItResult.value) {
+			dependenciesItResult = dependenciesIt.next();
+			dependencyIndicesItResult = dependencyIndicesIt.next();
+			if (dependencyIndicesItResult.done) return;
+		}
+		if (names[i] === name) return dependenciesItResult.value;
 	}
-	return str;
+	return undefined;
 };
 
 /**
- * @param {string} request the request
- * @returns {string} id representation
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {HarmonyExportImportedSpecifierDependency} dep the dependency
+ * @param {string} runtimeKey the runtime key
+ * @returns {ExportMode} the export mode
  */
-const requestToId = request => {
-	return request
-		.replace(/^(\.\.?\/)+/, "")
-		.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
-};
-exports.requestToId = requestToId;
+const getMode = (moduleGraph, dep, runtimeKey) => {
+	const importedModule = moduleGraph.getModule(dep);
 
-/**
- * @param {string} string the string
- * @param {string} delimiter separator for string and hash
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} string with limited max length to 100 chars
- */
-const shortenLongString = (string, delimiter, hashFunction) => {
-	if (string.length < 100) return string;
-	return (
-		string.slice(0, 100 - 6 - delimiter.length) +
-		delimiter +
-		getHash(string, 6, hashFunction)
-	);
-};
+	if (!importedModule) {
+		const mode = new ExportMode("missing");
 
-/**
- * @param {Module} module the module
- * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} short module name
- */
-const getShortModuleName = (module, context, associatedObjectForCache) => {
-	const libIdent = module.libIdent({ context, associatedObjectForCache });
-	if (libIdent) return avoidNumber(libIdent);
-	const nameForCondition = module.nameForCondition();
-	if (nameForCondition)
-		return avoidNumber(
-			makePathsRelative(context, nameForCondition, associatedObjectForCache)
-		);
-	return "";
-};
-exports.getShortModuleName = getShortModuleName;
+		mode.userRequest = dep.userRequest;
 
-/**
- * @param {string} shortName the short name
- * @param {Module} module the module
- * @param {string} context context directory
- * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} long module name
- */
-const getLongModuleName = (
-	shortName,
-	module,
-	context,
-	hashFunction,
-	associatedObjectForCache
-) => {
-	const fullName = getFullModuleName(module, context, associatedObjectForCache);
-	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
-};
-exports.getLongModuleName = getLongModuleName;
+		return mode;
+	}
 
-/**
- * @param {Module} module the module
- * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} full module name
- */
-const getFullModuleName = (module, context, associatedObjectForCache) => {
-	return makePathsRelative(
-		context,
-		module.identifier(),
-		associatedObjectForCache
-	);
-};
-exports.getFullModuleName = getFullModuleName;
+	const name = dep.name;
+	const runtime = keyToRuntime(runtimeKey);
+	const parentModule = moduleGraph.getParentModule(dep);
+	const exportsInfo = moduleGraph.getExportsInfo(parentModule);
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {string} context context directory
- * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} short chunk name
- */
-const getShortChunkName = (
-	chunk,
-	chunkGraph,
-	context,
-	delimiter,
-	hashFunction,
-	associatedObjectForCache
-) => {
-	const modules = chunkGraph.getChunkRootModules(chunk);
-	const shortModuleNames = modules.map(m =>
-		requestToId(getShortModuleName(m, context, associatedObjectForCache))
-	);
-	chunk.idNameHints.sort();
-	const chunkName = Array.from(chunk.idNameHints)
-		.concat(shortModuleNames)
-		.filter(Boolean)
-		.join(delimiter);
-	return shortenLongString(chunkName, delimiter, hashFunction);
-};
-exports.getShortChunkName = getShortChunkName;
+	if (
+		name
+			? exportsInfo.getUsed(name, runtime) === UsageState.Unused
+			: exportsInfo.isUsed(runtime) === false
+	) {
+		const mode = new ExportMode("unused");
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {string} context context directory
- * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} short chunk name
- */
-const getLongChunkName = (
-	chunk,
-	chunkGraph,
-	context,
-	delimiter,
-	hashFunction,
-	associatedObjectForCache
-) => {
-	const modules = chunkGraph.getChunkRootModules(chunk);
-	const shortModuleNames = modules.map(m =>
-		requestToId(getShortModuleName(m, context, associatedObjectForCache))
-	);
-	const longModuleNames = modules.map(m =>
-		requestToId(
-			getLongModuleName("", m, context, hashFunction, associatedObjectForCache)
-		)
-	);
-	chunk.idNameHints.sort();
-	const chunkName = Array.from(chunk.idNameHints)
-		.concat(shortModuleNames, longModuleNames)
-		.filter(Boolean)
-		.join(delimiter);
-	return shortenLongString(chunkName, delimiter, hashFunction);
-};
-exports.getLongChunkName = getLongChunkName;
+		mode.name = name || "*";
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} full chunk name
- */
-const getFullChunkName = (
-	chunk,
-	chunkGraph,
-	context,
-	associatedObjectForCache
-) => {
-	if (chunk.name) return chunk.name;
-	const modules = chunkGraph.getChunkRootModules(chunk);
-	const fullModuleNames = modules.map(m =>
-		makePathsRelative(context, m.identifier(), associatedObjectForCache)
+		return mode;
+	}
+
+	const importedExportsType = importedModule.getExportsType(
+		moduleGraph,
+		parentModule.buildMeta.strictHarmonyModule
 	);
-	return fullModuleNames.join();
-};
-exports.getFullChunkName = getFullChunkName;
 
-/**
- * @template K
- * @template V
- * @param {Map<K, V[]>} map a map from key to values
- * @param {K} key key
- * @param {V} value value
- * @returns {void}
- */
-const addToMapOfItems = (map, key, value) => {
-	let array = map.get(key);
-	if (array === undefined) {
-		array = [];
-		map.set(key, array);
-	}
-	array.push(value);
-};
+	const ids = dep.getIds(moduleGraph);
 
-/**
- * @param {Compilation} compilation the compilation
- * @param {function(Module): boolean=} filter filter modules
- * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
- */
-const getUsedModuleIdsAndModules = (compilation, filter) => {
-	const chunkGraph = compilation.chunkGraph;
+	// Special handling for reexporting the default export
+	// from non-namespace modules
+	if (name && ids.length > 0 && ids[0] === "default") {
+		switch (importedExportsType) {
+			case "dynamic": {
+				const mode = new ExportMode("reexport-dynamic-default");
 
-	const modules = [];
+				mode.name = name;
 
-	/** @type {Set<string>} */
-	const usedIds = new Set();
-	if (compilation.usedModuleIds) {
-		for (const id of compilation.usedModuleIds) {
-			usedIds.add(id + "");
-		}
-	}
+				return mode;
+			}
+			case "default-only":
+			case "default-with-named": {
+				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+				const mode = new ExportMode("reexport-named-default");
 
-	for (const module of compilation.modules) {
-		if (!module.needId) continue;
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId !== null) {
-			usedIds.add(moduleId + "");
-		} else {
-			if (
-				(!filter || filter(module)) &&
-				chunkGraph.getNumberOfModuleChunks(module) !== 0
-			) {
-				modules.push(module);
+				mode.name = name;
+				mode.partialNamespaceExportInfo = exportInfo;
+
+				return mode;
 			}
 		}
 	}
 
-	return [usedIds, modules];
-};
-exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
+	// reexporting with a fixed name
+	if (name) {
+		let mode;
+		const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
 
-/**
- * @param {Compilation} compilation the compilation
- * @returns {Set<string>} used chunk ids as strings
- */
-const getUsedChunkIds = compilation => {
-	/** @type {Set<string>} */
-	const usedIds = new Set();
-	if (compilation.usedChunkIds) {
-		for (const id of compilation.usedChunkIds) {
-			usedIds.add(id + "");
+		if (ids.length > 0) {
+			// export { name as name }
+			switch (importedExportsType) {
+				case "default-only":
+					mode = new ExportMode("reexport-undefined");
+					mode.name = name;
+					break;
+				default:
+					mode = new ExportMode("normal-reexport");
+					mode.items = [
+						new NormalReexportItem(name, ids, exportInfo, false, false)
+					];
+					break;
+			}
+		} else {
+			// export * as name
+			switch (importedExportsType) {
+				case "default-only":
+					mode = new ExportMode("reexport-fake-namespace-object");
+					mode.name = name;
+					mode.partialNamespaceExportInfo = exportInfo;
+					mode.fakeType = 0;
+					break;
+				case "default-with-named":
+					mode = new ExportMode("reexport-fake-namespace-object");
+					mode.name = name;
+					mode.partialNamespaceExportInfo = exportInfo;
+					mode.fakeType = 2;
+					break;
+				case "dynamic":
+				default:
+					mode = new ExportMode("reexport-namespace-object");
+					mode.name = name;
+					mode.partialNamespaceExportInfo = exportInfo;
+			}
 		}
-	}
 
-	for (const chunk of compilation.chunks) {
-		const chunkId = chunk.id;
-		if (chunkId !== null) {
-			usedIds.add(chunkId + "");
-		}
+		return mode;
 	}
 
-	return usedIds;
-};
-exports.getUsedChunkIds = getUsedChunkIds;
+	// Star reexporting
 
-/**
- * @template T
- * @param {Iterable<T>} items list of items to be named
- * @param {function(T): string} getShortName get a short name for an item
- * @param {function(T, string): string} getLongName get a long name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {Set<string>} usedIds already used ids, will not be assigned
- * @param {function(T, string): void} assignName assign a name to an item
- * @returns {T[]} list of items without a name
- */
-const assignNames = (
-	items,
-	getShortName,
-	getLongName,
-	comparator,
-	usedIds,
-	assignName
-) => {
-	/** @type {Map<string, T[]>} */
-	const nameToItems = new Map();
+	const { ignoredExports, exports, checked, hidden } = dep.getStarReexports(
+		moduleGraph,
+		runtime,
+		exportsInfo,
+		importedModule
+	);
+	if (!exports) {
+		// We have too few info about the modules
+		// Delegate the logic to the runtime code
 
-	for (const item of items) {
-		const name = getShortName(item);
-		addToMapOfItems(nameToItems, name, item);
+		const mode = new ExportMode("dynamic-reexport");
+		mode.ignored = ignoredExports;
+		mode.hidden = hidden;
+
+		return mode;
 	}
 
-	/** @type {Map<string, T[]>} */
-	const nameToItems2 = new Map();
+	if (exports.size === 0) {
+		const mode = new ExportMode("empty-star");
+		mode.hidden = hidden;
 
-	for (const [name, items] of nameToItems) {
-		if (items.length > 1 || !name) {
-			for (const item of items) {
-				const longName = getLongName(item, name);
-				addToMapOfItems(nameToItems2, longName, item);
-			}
-		} else {
-			addToMapOfItems(nameToItems2, name, items[0]);
-		}
+		return mode;
 	}
 
-	/** @type {T[]} */
-	const unnamedItems = [];
+	const mode = new ExportMode("normal-reexport");
 
-	for (const [name, items] of nameToItems2) {
-		if (!name) {
-			for (const item of items) {
-				unnamedItems.push(item);
-			}
-		} else if (items.length === 1 && !usedIds.has(name)) {
-			assignName(items[0], name);
-			usedIds.add(name);
-		} else {
-			items.sort(comparator);
-			let i = 0;
-			for (const item of items) {
-				while (nameToItems2.has(name + i) && usedIds.has(name + i)) i++;
-				assignName(item, name + i);
-				usedIds.add(name + i);
-				i++;
-			}
+	mode.items = Array.from(
+		exports,
+		exportName =>
+			new NormalReexportItem(
+				exportName,
+				[exportName],
+				exportsInfo.getReadOnlyExportInfo(exportName),
+				checked.has(exportName),
+				false
+			)
+	);
+	if (hidden !== undefined) {
+		for (const exportName of hidden) {
+			mode.items.push(
+				new NormalReexportItem(
+					exportName,
+					[exportName],
+					exportsInfo.getReadOnlyExportInfo(exportName),
+					false,
+					true
+				)
+			);
 		}
 	}
 
-	unnamedItems.sort(comparator);
-	return unnamedItems;
+	return mode;
 };
-exports.assignNames = assignNames;
 
-/**
- * @template T
- * @param {T[]} items list of items to be named
- * @param {function(T): string} getName get a name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {function(T, number): boolean} assignId assign an id to an item
- * @param {number[]} ranges usable ranges for ids
- * @param {number} expandFactor factor to create more ranges
- * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
- * @param {number} salt salting number to initialize hashing
- * @returns {void}
- */
-const assignDeterministicIds = (
-	items,
-	getName,
-	comparator,
-	assignId,
-	ranges = [10],
-	expandFactor = 10,
-	extraSpace = 0,
-	salt = 0
-) => {
-	items.sort(comparator);
+class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder the order in the original source file
+	 * @param {string[]} ids the requested export name of the imported module
+	 * @param {string | null} name the export name of for this module
+	 * @param {Set<string>} activeExports other named exports in the module
+	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module before this import
+	 * @param {number} exportPresenceMode mode of checking export names
+	 * @param {HarmonyStarExportsList} allStarExports all star exports in the module
+	 * @param {Record<string, any>=} assertions import assertions
+	 */
+	constructor(
+		request,
+		sourceOrder,
+		ids,
+		name,
+		activeExports,
+		otherStarExports,
+		exportPresenceMode,
+		allStarExports,
+		assertions
+	) {
+		super(request, sourceOrder, assertions);
 
-	// max 5% fill rate
-	const optimalRange = Math.min(
-		Math.ceil(items.length * 20) + extraSpace,
-		Number.MAX_SAFE_INTEGER
-	);
+		this.ids = ids;
+		this.name = name;
+		this.activeExports = activeExports;
+		this.otherStarExports = otherStarExports;
+		this.exportPresenceMode = exportPresenceMode;
+		this.allStarExports = allStarExports;
+	}
 
-	let i = 0;
-	let range = ranges[i];
-	while (range < optimalRange) {
-		i++;
-		if (i < ranges.length) {
-			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
-		} else if (expandFactor) {
-			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
-		} else {
-			break;
-		}
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
 	}
 
-	for (const item of items) {
-		const ident = getName(item);
-		let id;
-		let i = salt;
-		do {
-			id = numberHash(ident + i++, range);
-		} while (!assignId(item, id));
+	// TODO webpack 6 remove
+	get id() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
-};
-exports.assignDeterministicIds = assignDeterministicIds;
 
-/**
- * @param {Set<string>} usedIds used ids
- * @param {Iterable<Module>} modules the modules
- * @param {Compilation} compilation the compilation
- * @returns {void}
- */
-const assignAscendingModuleIds = (usedIds, modules, compilation) => {
-	const chunkGraph = compilation.chunkGraph;
+	// TODO webpack 6 remove
+	getId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
 
-	let nextId = 0;
-	let assignId;
-	if (usedIds.size > 0) {
-		assignId = module => {
-			if (chunkGraph.getModuleId(module) === null) {
-				while (usedIds.has(nextId + "")) nextId++;
-				chunkGraph.setModuleId(module, nextId++);
-			}
-		};
-	} else {
-		assignId = module => {
-			if (chunkGraph.getModuleId(module) === null) {
-				chunkGraph.setModuleId(module, nextId++);
-			}
-		};
+	// TODO webpack 6 remove
+	setId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
-	for (const module of modules) {
-		assignId(module);
+
+	get type() {
+		return "harmony export imported specifier";
 	}
-};
-exports.assignAscendingModuleIds = assignAscendingModuleIds;
 
-/**
- * @param {Iterable<Chunk>} chunks the chunks
- * @param {Compilation} compilation the compilation
- * @returns {void}
- */
-const assignAscendingChunkIds = (chunks, compilation) => {
-	const usedIds = getUsedChunkIds(compilation);
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported id
+	 */
+	getIds(moduleGraph) {
+		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	}
 
-	let nextId = 0;
-	if (usedIds.size > 0) {
-		for (const chunk of chunks) {
-			if (chunk.id === null) {
-				while (usedIds.has(nextId + "")) nextId++;
-				chunk.id = nextId;
-				chunk.ids = [nextId];
-				nextId++;
-			}
-		}
-	} else {
-		for (const chunk of chunks) {
-			if (chunk.id === null) {
-				chunk.id = nextId;
-				chunk.ids = [nextId];
-				nextId++;
-			}
-		}
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
 	}
-};
-exports.assignAscendingChunkIds = assignAscendingChunkIds;
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ExportMode} the export mode
+	 */
+	getMode(moduleGraph, runtime) {
+		return moduleGraph.dependencyCacheProvide(
+			this,
+			getRuntimeKey(runtime),
+			getMode
+		);
+	}
 
-/***/ }),
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {ExportsInfo} exportsInfo exports info about the current module (optional)
+	 * @param {Module} importedModule the imported module (optional)
+	 * @returns {{exports?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden?: Set<string>}} information
+	 */
+	getStarReexports(
+		moduleGraph,
+		runtime,
+		exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this)),
+		importedModule = moduleGraph.getModule(this)
+	) {
+		const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
 
-/***/ 6454:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const noExtraExports =
+			importedExportsInfo.otherExportsInfo.provided === false;
+		const noExtraImports =
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const ignoredExports = new Set(["default", ...this.activeExports]);
 
+		let hiddenExports = undefined;
+		const otherStarExports =
+			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
+		if (otherStarExports !== undefined) {
+			hiddenExports = new Set();
+			for (let i = 0; i < otherStarExports.namesSlice; i++) {
+				hiddenExports.add(otherStarExports.names[i]);
+			}
+			for (const e of ignoredExports) hiddenExports.delete(e);
+		}
 
+		if (!noExtraExports && !noExtraImports) {
+			return {
+				ignoredExports,
+				hidden: hiddenExports
+			};
+		}
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const {
-	getShortChunkName,
-	getLongChunkName,
-	assignNames,
-	getUsedChunkIds,
-	assignAscendingChunkIds
-} = __webpack_require__(63290);
+		/** @type {Set<string>} */
+		const exports = new Set();
+		/** @type {Set<string>} */
+		const checked = new Set();
+		/** @type {Set<string>} */
+		const hidden = hiddenExports !== undefined ? new Set() : undefined;
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+		if (noExtraImports) {
+			for (const exportInfo of exportsInfo.orderedExports) {
+				const name = exportInfo.name;
+				if (ignoredExports.has(name)) continue;
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				const importedExportInfo =
+					importedExportsInfo.getReadOnlyExportInfo(name);
+				if (importedExportInfo.provided === false) continue;
+				if (hiddenExports !== undefined && hiddenExports.has(name)) {
+					hidden.add(name);
+					continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
+			}
+		} else if (noExtraExports) {
+			for (const importedExportInfo of importedExportsInfo.orderedExports) {
+				const name = importedExportInfo.name;
+				if (ignoredExports.has(name)) continue;
+				if (importedExportInfo.provided === false) continue;
+				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				if (hiddenExports !== undefined && hiddenExports.has(name)) {
+					hidden.add(name);
+					continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
+			}
+		}
 
-class NamedChunkIdsPlugin {
-	constructor(options) {
-		this.delimiter = (options && options.delimiter) || "-";
-		this.context = options && options.context;
+		return { ignoredExports, exports, checked, hidden };
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
-				const chunkGraph = compilation.chunkGraph;
-				const context = this.context ? this.context : compiler.context;
-				const delimiter = this.delimiter;
+	getCondition(moduleGraph) {
+		return (connection, runtime) => {
+			const mode = this.getMode(moduleGraph, runtime);
+			return mode.type !== "unused" && mode.type !== "empty-star";
+		};
+	}
 
-				const unnamedChunks = assignNames(
-					Array.from(chunks).filter(chunk => {
-						if (chunk.name) {
-							chunk.id = chunk.name;
-							chunk.ids = [chunk.name];
-						}
-						return chunk.id === null;
-					}),
-					chunk =>
-						getShortChunkName(
-							chunk,
-							chunkGraph,
-							context,
-							delimiter,
-							hashFunction,
-							compiler.root
-						),
-					chunk =>
-						getLongChunkName(
-							chunk,
-							chunkGraph,
-							context,
-							delimiter,
-							hashFunction,
-							compiler.root
-						),
-					compareChunksNatural(chunkGraph),
-					getUsedChunkIds(compilation),
-					(chunk, name) => {
-						chunk.id = name;
-						chunk.ids = [name];
-					}
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		const mode = this.getMode(moduleGraph, runtime);
+
+		switch (mode.type) {
+			case "missing":
+			case "unused":
+			case "empty-star":
+			case "reexport-undefined":
+				return Dependency.NO_EXPORTS_REFERENCED;
+
+			case "reexport-dynamic-default":
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
+
+			case "reexport-named-default": {
+				if (!mode.partialNamespaceExportInfo)
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				/** @type {string[][]} */
+				const referencedExports = [];
+				processExportInfo(
+					runtime,
+					referencedExports,
+					[],
+					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo)
 				);
-				if (unnamedChunks.length > 0) {
-					assignAscendingChunkIds(unnamedChunks, compilation);
+				return referencedExports;
+			}
+
+			case "reexport-namespace-object":
+			case "reexport-fake-namespace-object": {
+				if (!mode.partialNamespaceExportInfo)
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				/** @type {string[][]} */
+				const referencedExports = [];
+				processExportInfo(
+					runtime,
+					referencedExports,
+					[],
+					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo),
+					mode.type === "reexport-fake-namespace-object"
+				);
+				return referencedExports;
+			}
+
+			case "dynamic-reexport":
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
+
+			case "normal-reexport": {
+				const referencedExports = [];
+				for (const { ids, exportInfo, hidden } of mode.items) {
+					if (hidden) continue;
+					processExportInfo(runtime, referencedExports, ids, exportInfo, false);
 				}
-			});
-		});
+				return referencedExports;
+			}
+
+			default:
+				throw new Error(`Unknown mode ${mode.type}`);
+		}
 	}
-}
 
-module.exports = NamedChunkIdsPlugin;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {{ names: string[], namesSlice: number, dependencyIndices: number[], dependencyIndex: number } | undefined} exported names and their origin dependency
+	 */
+	_discoverActiveExportsFromOtherStarExports(moduleGraph) {
+		if (!this.otherStarExports) return undefined;
 
+		const i =
+			"length" in this.otherStarExports
+				? this.otherStarExports.length
+				: countIterable(this.otherStarExports);
+		if (i === 0) return undefined;
 
-/***/ }),
+		if (this.allStarExports) {
+			const { names, dependencyIndices } = moduleGraph.cached(
+				determineExportAssignments,
+				this.allStarExports.dependencies
+			);
 
-/***/ 24339:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			return {
+				names,
+				namesSlice: dependencyIndices[i - 1],
+				dependencyIndices,
+				dependencyIndex: i
+			};
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const { names, dependencyIndices } = moduleGraph.cached(
+			determineExportAssignments,
+			this.otherStarExports,
+			this
+		);
 
+		return {
+			names,
+			namesSlice: dependencyIndices[i - 1],
+			dependencyIndices,
+			dependencyIndex: i
+		};
+	}
 
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const mode = this.getMode(moduleGraph, undefined);
 
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const {
-	getShortModuleName,
-	getLongModuleName,
-	assignNames,
-	getUsedModuleIdsAndModules,
-	assignAscendingModuleIds
-} = __webpack_require__(63290);
+		switch (mode.type) {
+			case "missing":
+				return undefined;
+			case "dynamic-reexport": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: true,
+					from,
+					canMangle: false,
+					excludeExports: mode.hidden
+						? combine(mode.ignored, mode.hidden)
+						: mode.ignored,
+					hideExports: mode.hidden,
+					dependencies: [from.module]
+				};
+			}
+			case "empty-star":
+				return {
+					exports: [],
+					hideExports: mode.hidden,
+					dependencies: [moduleGraph.getModule(this)]
+				};
+			// falls through
+			case "normal-reexport": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: Array.from(mode.items, item => ({
+						name: item.name,
+						from,
+						export: item.ids,
+						hidden: item.hidden
+					})),
+					priority: 1,
+					dependencies: [from.module]
+				};
+			}
+			case "reexport-dynamic-default": {
+				{
+					const from = moduleGraph.getConnection(this);
+					return {
+						exports: [
+							{
+								name: mode.name,
+								from,
+								export: ["default"]
+							}
+						],
+						priority: 1,
+						dependencies: [from.module]
+					};
+				}
+			}
+			case "reexport-undefined":
+				return {
+					exports: [mode.name],
+					dependencies: [moduleGraph.getModule(this)]
+				};
+			case "reexport-fake-namespace-object": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: [
+						{
+							name: mode.name,
+							from,
+							export: null,
+							exports: [
+								{
+									name: "default",
+									canMangle: false,
+									from,
+									export: null
+								}
+							]
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
+			}
+			case "reexport-namespace-object": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: [
+						{
+							name: mode.name,
+							from,
+							export: null
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
+			}
+			case "reexport-named-default": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: [
+						{
+							name: mode.name,
+							from,
+							export: ["default"]
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
+			}
+			default:
+				throw new Error(`Unknown mode ${mode.type}`);
+		}
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {number} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
 
-class NamedModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
+	 */
+	getWarnings(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
 	 */
-	apply(compiler) {
-		const { root } = compiler;
-		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
-				const chunkGraph = compilation.chunkGraph;
-				const context = this.options.context
-					? this.options.context
-					: compiler.context;
+	getErrors(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
+	}
 
-				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
-				const unnamedModules = assignNames(
-					modules,
-					m => getShortModuleName(m, context, root),
-					(m, shortName) =>
-						getLongModuleName(shortName, m, context, hashFunction, root),
-					compareModulesByIdentifier,
-					usedIds,
-					(m, name) => chunkGraph.setModuleId(m, name)
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		let errors = this.getLinkingErrors(
+			moduleGraph,
+			ids,
+			`(reexported as '${this.name}')`
+		);
+		if (ids.length === 0 && this.name === null) {
+			const potentialConflicts =
+				this._discoverActiveExportsFromOtherStarExports(moduleGraph);
+			if (potentialConflicts && potentialConflicts.namesSlice > 0) {
+				const ownNames = new Set(
+					potentialConflicts.names.slice(
+						potentialConflicts.namesSlice,
+						potentialConflicts.dependencyIndices[
+							potentialConflicts.dependencyIndex
+						]
+					)
 				);
-				if (unnamedModules.length > 0) {
-					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
+				const importedModule = moduleGraph.getModule(this);
+				if (importedModule) {
+					const exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					const conflicts = new Map();
+					for (const exportInfo of exportsInfo.orderedExports) {
+						if (exportInfo.provided !== true) continue;
+						if (exportInfo.name === "default") continue;
+						if (this.activeExports.has(exportInfo.name)) continue;
+						if (ownNames.has(exportInfo.name)) continue;
+						const conflictingDependency = findDependencyForName(
+							potentialConflicts,
+							exportInfo.name,
+							this.allStarExports
+								? this.allStarExports.dependencies
+								: [...this.otherStarExports, this]
+						);
+						if (!conflictingDependency) continue;
+						const target = exportInfo.getTerminalBinding(moduleGraph);
+						if (!target) continue;
+						const conflictingModule = moduleGraph.getModule(
+							conflictingDependency
+						);
+						if (conflictingModule === importedModule) continue;
+						const conflictingExportInfo = moduleGraph.getExportInfo(
+							conflictingModule,
+							exportInfo.name
+						);
+						const conflictingTarget =
+							conflictingExportInfo.getTerminalBinding(moduleGraph);
+						if (!conflictingTarget) continue;
+						if (target === conflictingTarget) continue;
+						const list = conflicts.get(conflictingDependency.request);
+						if (list === undefined) {
+							conflicts.set(conflictingDependency.request, [exportInfo.name]);
+						} else {
+							list.push(exportInfo.name);
+						}
+					}
+					for (const [request, exports] of conflicts) {
+						if (!errors) errors = [];
+						errors.push(
+							new HarmonyLinkingError(
+								`The requested module '${
+									this.request
+								}' contains conflicting star exports for the ${
+									exports.length > 1 ? "names" : "name"
+								} ${exports
+									.map(e => `'${e}'`)
+									.join(", ")} with the previous requested module '${request}'`
+							)
+						);
+					}
 				}
-			});
-		});
+			}
+		}
+		return errors;
 	}
-}
-
-module.exports = NamedModuleIdsPlugin;
 
+	serialize(context) {
+		const { write, setCircularReference } = context;
 
-/***/ }),
+		setCircularReference(this);
+		write(this.ids);
+		write(this.name);
+		write(this.activeExports);
+		write(this.otherStarExports);
+		write(this.exportPresenceMode);
+		write(this.allStarExports);
 
-/***/ 86221:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		super.serialize(context);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	deserialize(context) {
+		const { read, setCircularReference } = context;
 
+		setCircularReference(this);
+		this.ids = read();
+		this.name = read();
+		this.activeExports = read();
+		this.otherStarExports = read();
+		this.exportPresenceMode = read();
+		this.allStarExports = read();
 
+		super.deserialize(context);
+	}
+}
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const { assignAscendingChunkIds } = __webpack_require__(63290);
+makeSerializable(
+	HarmonyExportImportedSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency"
+);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+module.exports = HarmonyExportImportedSpecifierDependency;
 
-class NaturalChunkIdsPlugin {
+HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("NaturalChunkIdsPlugin", compilation => {
-			compilation.hooks.chunkIds.tap("NaturalChunkIdsPlugin", chunks => {
-				const chunkGraph = compilation.chunkGraph;
-				const compareNatural = compareChunksNatural(chunkGraph);
-				const chunksInNaturalOrder = Array.from(chunks).sort(compareNatural);
-				assignAscendingChunkIds(chunksInNaturalOrder, compilation);
-			});
-		});
-	}
-}
-
-module.exports = NaturalChunkIdsPlugin;
-
-
-/***/ }),
-
-/***/ 83366:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	apply(dependency, source, templateContext) {
+		const { moduleGraph, runtime, concatenationScope } = templateContext;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
+		const dep = /** @type {HarmonyExportImportedSpecifierDependency} */ (
+			dependency
+		);
 
+		const mode = dep.getMode(moduleGraph, runtime);
 
+		if (concatenationScope) {
+			switch (mode.type) {
+				case "reexport-undefined":
+					concatenationScope.registerRawExport(
+						mode.name,
+						"/* reexport non-default export from non-harmony */ undefined"
+					);
+			}
+			return;
+		}
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const {
-	assignAscendingModuleIds,
-	getUsedModuleIdsAndModules
-} = __webpack_require__(63290);
+		if (mode.type !== "unused" && mode.type !== "empty-star") {
+			super.apply(dependency, source, templateContext);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+			this._addExportFragments(
+				templateContext.initFragments,
+				dep,
+				mode,
+				templateContext.module,
+				moduleGraph,
+				runtime,
+				templateContext.runtimeTemplate,
+				templateContext.runtimeRequirements
+			);
+		}
+	}
 
-class NaturalModuleIdsPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {InitFragment[]} initFragments target array for init fragments
+	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
+	 * @param {ExportMode} mode the export mode
+	 * @param {Module} module the current module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {Set<string>} runtimeRequirements runtime requirements
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
-				const [usedIds, modulesInNaturalOrder] =
-					getUsedModuleIdsAndModules(compilation);
-				modulesInNaturalOrder.sort(
-					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-				);
-				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
-			});
-		});
-	}
-}
-
-module.exports = NaturalModuleIdsPlugin;
-
-
-/***/ }),
-
-/***/ 51020:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	_addExportFragments(
+		initFragments,
+		dep,
+		mode,
+		module,
+		moduleGraph,
+		runtime,
+		runtimeTemplate,
+		runtimeRequirements
+	) {
+		const importedModule = moduleGraph.getModule(dep);
+		const importVar = dep.getImportVar(moduleGraph);
 
+		switch (mode.type) {
+			case "missing":
+			case "empty-star":
+				initFragments.push(
+					new InitFragment(
+						"/* empty/unused harmony star reexport */\n",
+						InitFragment.STAGE_HARMONY_EXPORTS,
+						1
+					)
+				);
+				break;
 
+			case "unused":
+				initFragments.push(
+					new InitFragment(
+						`${Template.toNormalComment(
+							`unused harmony reexport ${mode.name}`
+						)}\n`,
+						InitFragment.STAGE_HARMONY_EXPORTS,
+						1
+					)
+				);
+				break;
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const { assignAscendingChunkIds } = __webpack_require__(63290);
+			case "reexport-dynamic-default":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport default from dynamic",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						null,
+						runtimeRequirements
+					)
+				);
+				break;
 
-/** @typedef {import("../../declarations/plugins/ids/OccurrenceChunkIdsPlugin").OccurrenceChunkIdsPluginOptions} OccurrenceChunkIdsPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+			case "reexport-fake-namespace-object":
+				initFragments.push(
+					...this.getReexportFakeNamespaceObjectFragments(
+						module,
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						mode.fakeType,
+						runtimeRequirements
+					)
+				);
+				break;
 
-const validate = createSchemaValidation(
-	__webpack_require__(24344),
-	() => __webpack_require__(53576),
-	{
-		name: "Occurrence Order Chunk Ids Plugin",
-		baseDataPath: "options"
-	}
-);
+			case "reexport-undefined":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport non-default export from non-harmony",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						"undefined",
+						"",
+						runtimeRequirements
+					)
+				);
+				break;
 
-class OccurrenceChunkIdsPlugin {
-	/**
-	 * @param {OccurrenceChunkIdsPluginOptions=} options options object
-	 */
-	constructor(options = {}) {
-		validate(options);
-		this.options = options;
-	}
+			case "reexport-named-default":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport default export from named module",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						"",
+						runtimeRequirements
+					)
+				);
+				break;
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const prioritiseInitial = this.options.prioritiseInitial;
-		compiler.hooks.compilation.tap("OccurrenceChunkIdsPlugin", compilation => {
-			compilation.hooks.chunkIds.tap("OccurrenceChunkIdsPlugin", chunks => {
-				const chunkGraph = compilation.chunkGraph;
+			case "reexport-namespace-object":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport module object",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						"",
+						runtimeRequirements
+					)
+				);
+				break;
 
-				/** @type {Map<Chunk, number>} */
-				const occursInInitialChunksMap = new Map();
+			case "normal-reexport":
+				for (const { name, ids, checked, hidden } of mode.items) {
+					if (hidden) continue;
+					if (checked) {
+						initFragments.push(
+							new InitFragment(
+								"/* harmony reexport (checked) */ " +
+									this.getConditionalReexportStatement(
+										module,
+										name,
+										importVar,
+										ids,
+										runtimeRequirements
+									),
+								moduleGraph.isAsync(importedModule)
+									? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
+									: InitFragment.STAGE_HARMONY_IMPORTS,
+								dep.sourceOrder
+							)
+						);
+					} else {
+						initFragments.push(
+							this.getReexportFragment(
+								module,
+								"reexport safe",
+								moduleGraph.getExportsInfo(module).getUsedName(name, runtime),
+								importVar,
+								moduleGraph
+									.getExportsInfo(importedModule)
+									.getUsedName(ids, runtime),
+								runtimeRequirements
+							)
+						);
+					}
+				}
+				break;
 
-				const compareNatural = compareChunksNatural(chunkGraph);
+			case "dynamic-reexport": {
+				const ignored = mode.hidden
+					? combine(mode.ignored, mode.hidden)
+					: mode.ignored;
+				const modern =
+					runtimeTemplate.supportsConst() &&
+					runtimeTemplate.supportsArrowFunction();
+				let content =
+					"/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};\n" +
+					`/* harmony reexport (unknown) */ for(${
+						modern ? "const" : "var"
+					} __WEBPACK_IMPORT_KEY__ in ${importVar}) `;
 
-				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);
+				// Filter out exports which are defined by other exports
+				// and filter out default export because it cannot be reexported with *
+				if (ignored.size > 1) {
+					content +=
+						"if(" +
+						JSON.stringify(Array.from(ignored)) +
+						".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
+				} else if (ignored.size === 1) {
+					content += `if(__WEBPACK_IMPORT_KEY__ !== ${JSON.stringify(
+						first(ignored)
+					)}) `;
 				}
 
-				const chunksInOccurrenceOrder = Array.from(chunks).sort((a, b) => {
-					if (prioritiseInitial) {
-						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;
-					return compareNatural(a, b);
-				});
-				assignAscendingChunkIds(chunksInOccurrenceOrder, compilation);
-			});
-		});
-	}
-}
+				content += `__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = `;
+				if (modern) {
+					content += `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`;
+				} else {
+					content += `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
+				}
 
-module.exports = OccurrenceChunkIdsPlugin;
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
+				const exportsName = module.exportsArgument;
+				initFragments.push(
+					new InitFragment(
+						`${content}\n/* harmony reexport (unknown) */ ${RuntimeGlobals.definePropertyGetters}(${exportsName}, __WEBPACK_REEXPORT_OBJECT__);\n`,
+						moduleGraph.isAsync(importedModule)
+							? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
+							: InitFragment.STAGE_HARMONY_IMPORTS,
+						dep.sourceOrder
+					)
+				);
+				break;
+			}
 
-/***/ }),
+			default:
+				throw new Error(`Unknown mode ${mode.type}`);
+		}
+	}
 
-/***/ 35371:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	getReexportFragment(
+		module,
+		comment,
+		key,
+		name,
+		valueKey,
+		runtimeRequirements
+	) {
+		const returnValue = this.getReturnValue(name, valueKey);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
+		const map = new Map();
+		map.set(key, `/* ${comment} */ ${returnValue}`);
 
+		return new HarmonyExportInitFragment(module.exportsArgument, map);
+	}
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const {
-	assignAscendingModuleIds,
-	getUsedModuleIdsAndModules
-} = __webpack_require__(63290);
+	getReexportFakeNamespaceObjectFragments(
+		module,
+		key,
+		name,
+		fakeType,
+		runtimeRequirements
+	) {
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 
-/** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+		const map = new Map();
+		map.set(
+			key,
+			`/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
+				RuntimeGlobals.createFakeNamespaceObject
+			}(${name}${fakeType ? `, ${fakeType}` : ""}))`
+		);
 
-const validate = createSchemaValidation(
-	__webpack_require__(14916),
-	() => __webpack_require__(19330),
-	{
-		name: "Occurrence Order Module Ids Plugin",
-		baseDataPath: "options"
+		return [
+			new InitFragment(
+				`var ${name}_namespace_cache;\n`,
+				InitFragment.STAGE_CONSTANTS,
+				-1,
+				`${name}_namespace_cache`
+			),
+			new HarmonyExportInitFragment(module.exportsArgument, map)
+		];
 	}
-);
 
-class OccurrenceModuleIdsPlugin {
-	/**
-	 * @param {OccurrenceModuleIdsPluginOptions=} options options object
-	 */
-	constructor(options = {}) {
-		validate(options);
-		this.options = options;
-	}
+	getConditionalReexportStatement(
+		module,
+		key,
+		name,
+		valueKey,
+		runtimeRequirements
+	) {
+		if (valueKey === false) {
+			return "/* unused export */\n";
+		}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const prioritiseInitial = this.options.prioritiseInitial;
-		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
+		const exportsName = module.exportsArgument;
+		const returnValue = this.getReturnValue(name, valueKey);
 
-			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
-				const chunkGraph = compilation.chunkGraph;
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		runtimeRequirements.add(RuntimeGlobals.hasOwnProperty);
 
-				const [usedIds, modulesInOccurrenceOrder] =
-					getUsedModuleIdsAndModules(compilation);
+		return `if(${RuntimeGlobals.hasOwnProperty}(${name}, ${JSON.stringify(
+			valueKey[0]
+		)})) ${
+			RuntimeGlobals.definePropertyGetters
+		}(${exportsName}, { ${JSON.stringify(
+			key
+		)}: function() { return ${returnValue}; } });\n`;
+	}
 
-				const occursInInitialChunksMap = new Map();
-				const occursInAllChunksMap = new Map();
+	getReturnValue(name, valueKey) {
+		if (valueKey === null) {
+			return `${name}_default.a`;
+		}
 
-				const initialChunkChunkMap = new Map();
-				const entryCountMap = new Map();
-				for (const m of modulesInOccurrenceOrder) {
-					let initial = 0;
-					let entry = 0;
-					for (const c of chunkGraph.getModuleChunksIterable(m)) {
-						if (c.canBeInitial()) initial++;
-						if (chunkGraph.isEntryModuleInChunk(m, c)) entry++;
-					}
-					initialChunkChunkMap.set(m, initial);
-					entryCountMap.set(m, entry);
-				}
+		if (valueKey === "") {
+			return name;
+		}
 
-				/**
-				 * @param {Module} module module
-				 * @returns {number} count of occurs
-				 */
-				const countOccursInEntry = module => {
-					let sum = 0;
-					for (const [
-						originModule,
-						connections
-					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-						if (!originModule) continue;
-						if (!connections.some(c => c.isTargetActive(undefined))) continue;
-						sum += initialChunkChunkMap.get(originModule);
-					}
-					return sum;
-				};
+		if (valueKey === false) {
+			return "/* unused export */ undefined";
+		}
 
-				/**
-				 * @param {Module} module module
-				 * @returns {number} count of occurs
-				 */
-				const countOccurs = module => {
-					let sum = 0;
-					for (const [
-						originModule,
-						connections
-					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-						if (!originModule) continue;
-						const chunkModules =
-							chunkGraph.getNumberOfModuleChunks(originModule);
-						for (const c of connections) {
-							if (!c.isTargetActive(undefined)) continue;
-							if (!c.dependency) continue;
-							const factor = c.dependency.getNumberOfIdOccurrences();
-							if (factor === 0) continue;
-							sum += factor * chunkModules;
-						}
-					}
-					return sum;
-				};
+		return `${name}${propertyAccess(valueKey)}`;
+	}
+};
 
-				if (prioritiseInitial) {
-					for (const m of modulesInOccurrenceOrder) {
-						const result =
-							countOccursInEntry(m) +
-							initialChunkChunkMap.get(m) +
-							entryCountMap.get(m);
-						occursInInitialChunksMap.set(m, result);
-					}
-				}
+class HarmonyStarExportsList {
+	constructor() {
+		/** @type {HarmonyExportImportedSpecifierDependency[]} */
+		this.dependencies = [];
+	}
 
-				for (const m of modulesInOccurrenceOrder) {
-					const result =
-						countOccurs(m) +
-						chunkGraph.getNumberOfModuleChunks(m) +
-						entryCountMap.get(m);
-					occursInAllChunksMap.set(m, result);
-				}
+	/**
+	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
+	 * @returns {void}
+	 */
+	push(dep) {
+		this.dependencies.push(dep);
+	}
 
-				const naturalCompare = compareModulesByPreOrderIndexOrIdentifier(
-					compilation.moduleGraph
-				);
+	slice() {
+		return this.dependencies.slice();
+	}
 
-				modulesInOccurrenceOrder.sort((a, b) => {
-					if (prioritiseInitial) {
-						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;
-					return naturalCompare(a, b);
-				});
+	serialize({ write, setCircularReference }) {
+		setCircularReference(this);
+		write(this.dependencies);
+	}
 
-				assignAscendingModuleIds(
-					usedIds,
-					modulesInOccurrenceOrder,
-					compilation
-				);
-			});
-		});
+	deserialize({ read, setCircularReference }) {
+		setCircularReference(this);
+		this.dependencies = read();
 	}
 }
 
-module.exports = OccurrenceModuleIdsPlugin;
+makeSerializable(
+	HarmonyStarExportsList,
+	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency",
+	"HarmonyStarExportsList"
+);
+
+module.exports.HarmonyStarExportsList = HarmonyStarExportsList;
 
 
 /***/ }),
 
-/***/ 8635:
+/***/ 89500:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -87791,144 +85552,169 @@ module.exports = OccurrenceModuleIdsPlugin;
 
 
 
-const { WebpackError } = __webpack_require__(91919);
-const { getUsedModuleIdsAndModules } = __webpack_require__(63290);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const { first } = __webpack_require__(93347);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
-const plugin = "SyncModuleIdsPlugin";
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
+	}
+	return str;
+};
 
-class SyncModuleIdsPlugin {
+const EMPTY_MAP = new Map();
+const EMPTY_SET = new Set();
+
+/**
+ * @typedef {GenerateContext} Context
+ */
+class HarmonyExportInitFragment extends InitFragment {
 	/**
-	 * @param {Object} options options
-	 * @param {string} options.path path to file
-	 * @param {string=} options.context context for module names
-	 * @param {function(Module): boolean} options.test selector for modules
-	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 * @param {string} exportsArgument the exports identifier
+	 * @param {Map<string, string>} exportMap mapping from used name to exposed variable name
+	 * @param {Set<string>} unusedExports list of unused export names
 	 */
-	constructor({ path, context, test, mode }) {
-		this._path = path;
-		this._context = context;
-		this._test = test || (() => true);
-		const readAndWrite = !mode || mode === "merge" || mode === "update";
-		this._read = readAndWrite || mode === "read";
-		this._write = readAndWrite || mode === "create";
-		this._prune = mode === "update";
+	constructor(
+		exportsArgument,
+		exportMap = EMPTY_MAP,
+		unusedExports = EMPTY_SET
+	) {
+		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
+		this.exportsArgument = exportsArgument;
+		this.exportMap = exportMap;
+		this.unusedExports = unusedExports;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
+	 * @returns {HarmonyExportInitFragment} merged fragment
 	 */
-	apply(compiler) {
-		/** @type {Map<string, string | number>} */
-		let data;
-		let dataChanged = false;
-		if (this._read) {
-			compiler.hooks.readRecords.tapAsync(plugin, callback => {
-				const fs = compiler.intermediateFileSystem;
-				fs.readFile(this._path, (err, buffer) => {
-					if (err) {
-						if (err.code !== "ENOENT") {
-							return callback(err);
-						}
-						return callback();
+	mergeAll(fragments) {
+		let exportMap;
+		let exportMapOwned = false;
+		let unusedExports;
+		let unusedExportsOwned = false;
+
+		for (const fragment of fragments) {
+			if (fragment.exportMap.size !== 0) {
+				if (exportMap === undefined) {
+					exportMap = fragment.exportMap;
+					exportMapOwned = false;
+				} else {
+					if (!exportMapOwned) {
+						exportMap = new Map(exportMap);
+						exportMapOwned = true;
 					}
-					const json = JSON.parse(buffer.toString());
-					data = new Map();
-					for (const key of Object.keys(json)) {
-						data.set(key, json[key]);
+					for (const [key, value] of fragment.exportMap) {
+						if (!exportMap.has(key)) exportMap.set(key, value);
 					}
-					dataChanged = false;
-					return callback();
-				});
-			});
-		}
-		if (this._write) {
-			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
-				if (!data || !dataChanged) return callback();
-				const json = {};
-				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
-				for (const [key, value] of sorted) {
-					json[key] = value;
 				}
-				const fs = compiler.intermediateFileSystem;
-				fs.writeFile(this._path, JSON.stringify(json), callback);
-			});
-		}
-		compiler.hooks.thisCompilation.tap(plugin, compilation => {
-			const associatedObjectForCache = compiler.root;
-			const context = this._context || compiler.context;
-			if (this._read) {
-				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
-					if (!data) return;
-					const { chunkGraph } = compilation;
-					const [usedIds, modules] = getUsedModuleIdsAndModules(
-						compilation,
-						this._test
-					);
-					for (const module of modules) {
-						const name = module.libIdent({
-							context,
-							associatedObjectForCache
-						});
-						if (!name) continue;
-						const id = data.get(name);
-						const idAsString = `${id}`;
-						if (usedIds.has(idAsString)) {
-							const err = new WebpackError(
-								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
-							);
-							err.module = module;
-							compilation.errors.push(err);
-						}
-						chunkGraph.setModuleId(module, id);
-						usedIds.add(idAsString);
-					}
-				});
 			}
-			if (this._write) {
-				compilation.hooks.recordModules.tap(plugin, modules => {
-					const { chunkGraph } = compilation;
-					let oldData = data;
-					if (!oldData) {
-						oldData = data = new Map();
-					} else if (this._prune) {
-						data = new Map();
+			if (fragment.unusedExports.size !== 0) {
+				if (unusedExports === undefined) {
+					unusedExports = fragment.unusedExports;
+					unusedExportsOwned = false;
+				} else {
+					if (!unusedExportsOwned) {
+						unusedExports = new Set(unusedExports);
+						unusedExportsOwned = true;
 					}
-					for (const module of modules) {
-						if (this._test(module)) {
-							const name = module.libIdent({
-								context,
-								associatedObjectForCache
-							});
-							if (!name) continue;
-							const id = chunkGraph.getModuleId(module);
-							if (id === null) continue;
-							const oldId = oldData.get(name);
-							if (oldId !== id) {
-								dataChanged = true;
-							} else if (data === oldData) {
-								continue;
-							}
-							data.set(name, id);
-						}
+					for (const value of fragment.unusedExports) {
+						unusedExports.add(value);
 					}
-					if (data.size !== oldData.size) dataChanged = true;
-				});
+				}
 			}
-		});
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
+	merge(other) {
+		let exportMap;
+		if (this.exportMap.size === 0) {
+			exportMap = other.exportMap;
+		} else if (other.exportMap.size === 0) {
+			exportMap = this.exportMap;
+		} else {
+			exportMap = new Map(other.exportMap);
+			for (const [key, value] of this.exportMap) {
+				if (!exportMap.has(key)) exportMap.set(key, value);
+			}
+		}
+		let unusedExports;
+		if (this.unusedExports.size === 0) {
+			unusedExports = other.unusedExports;
+		} else if (other.unusedExports.size === 0) {
+			unusedExports = this.unusedExports;
+		} else {
+			unusedExports = new Set(other.unusedExports);
+			for (const value of this.unusedExports) {
+				unusedExports.add(value);
+			}
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
+	/**
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
+	 */
+	getContent({ runtimeTemplate, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+
+		const unusedPart =
+			this.unusedExports.size > 1
+				? `/* unused harmony exports ${joinIterableWithComma(
+						this.unusedExports
+				  )} */\n`
+				: this.unusedExports.size > 0
+				? `/* unused harmony export ${first(this.unusedExports)} */\n`
+				: "";
+		const definitions = [];
+		for (const [key, value] of this.exportMap) {
+			definitions.push(
+				`\n/* harmony export */   ${JSON.stringify(
+					key
+				)}: ${runtimeTemplate.returningFunction(value)}`
+			);
+		}
+		const definePart =
+			this.exportMap.size > 0
+				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+				  }, {${definitions.join(",")}\n/* harmony export */ });\n`
+				: "";
+		return `${definePart}${unusedPart}`;
 	}
 }
 
-module.exports = SyncModuleIdsPlugin;
+module.exports = HarmonyExportInitFragment;
 
 
 /***/ }),
 
-/***/ 91919:
+/***/ 48567:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -87939,578 +85725,163 @@ module.exports = SyncModuleIdsPlugin;
 
 
 
-const util = __webpack_require__(73837);
-const memoize = __webpack_require__(78676);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyExportInitFragment = __webpack_require__(89500);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
-/** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
-/** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetCondition} RuleSetCondition */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
-/** @typedef {import("./Compilation").Asset} Asset */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./MultiStats")} MultiStats */
-/** @typedef {import("./Parser").ParserState} ParserState */
-/** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
-/** @typedef {import("./ResolverFactory").Resolver} Resolver */
-/** @typedef {import("./Watching")} Watching */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLogging} StatsLogging */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLoggingEntry} StatsLoggingEntry */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 
-/**
- * @template {Function} T
- * @param {function(): T} factory factory function
- * @returns {T} function
- */
-const lazyFunction = factory => {
-	const fac = memoize(factory);
-	const f = /** @type {any} */ (
-		(...args) => {
-			return fac()(...args);
-		}
-	);
-	return /** @type {T} */ (f);
-};
+class HarmonyExportSpecifierDependency extends NullDependency {
+	constructor(id, name) {
+		super();
+		this.id = id;
+		this.name = name;
+	}
 
-/**
- * @template A
- * @template B
- * @param {A} obj input a
- * @param {B} exports input b
- * @returns {A & B} merged
- */
-const mergeExports = (obj, exports) => {
-	const descriptors = Object.getOwnPropertyDescriptors(exports);
-	for (const name of Object.keys(descriptors)) {
-		const descriptor = descriptors[name];
-		if (descriptor.get) {
-			const fn = descriptor.get;
-			Object.defineProperty(obj, name, {
-				configurable: false,
-				enumerable: true,
-				get: memoize(fn)
-			});
-		} else if (typeof descriptor.value === "object") {
-			Object.defineProperty(obj, name, {
-				configurable: false,
-				enumerable: true,
-				writable: false,
-				value: mergeExports({}, descriptor.value)
-			});
-		} else {
-			throw new Error(
-				"Exposed values must be either a getter or an nested object"
-			);
-		}
+	get type() {
+		return "harmony export specifier";
 	}
-	return /** @type {A & B} */ (Object.freeze(obj));
-};
 
-const fn = lazyFunction(() => __webpack_require__(36243));
-module.exports = mergeExports(fn, {
-	get webpack() {
-		return __webpack_require__(36243);
-	},
-	get validate() {
-		const webpackOptionsSchemaCheck = __webpack_require__(10382);
-		const getRealValidate = memoize(() => {
-			const validateSchema = __webpack_require__(12047);
-			const webpackOptionsSchema = __webpack_require__(73342);
-			return options => validateSchema(webpackOptionsSchema, options);
-		});
-		return options => {
-			if (!webpackOptionsSchemaCheck(options)) getRealValidate()(options);
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: [this.name],
+			priority: 1,
+			terminalBinding: true,
+			dependencies: undefined
 		};
-	},
-	get validateSchema() {
-		const validateSchema = __webpack_require__(12047);
-		return validateSchema;
-	},
-	get version() {
-		return /** @type {string} */ ((__webpack_require__(32702)/* .version */ .i8));
-	},
-
-	get cli() {
-		return __webpack_require__(13462);
-	},
-	get AutomaticPrefetchPlugin() {
-		return __webpack_require__(17714);
-	},
-	get AsyncDependenciesBlock() {
-		return __webpack_require__(47736);
-	},
-	get BannerPlugin() {
-		return __webpack_require__(21242);
-	},
-	get Cache() {
-		return __webpack_require__(7592);
-	},
-	get Chunk() {
-		return __webpack_require__(39385);
-	},
-	get ChunkGraph() {
-		return __webpack_require__(64971);
-	},
-	get CleanPlugin() {
-		return __webpack_require__(31085);
-	},
-	get Compilation() {
-		return __webpack_require__(85720);
-	},
-	get Compiler() {
-		return __webpack_require__(70845);
-	},
-	get ConcatenationScope() {
-		return __webpack_require__(98229);
-	},
-	get ContextExclusionPlugin() {
-		return __webpack_require__(21411);
-	},
-	get ContextReplacementPlugin() {
-		return __webpack_require__(12206);
-	},
-	get DefinePlugin() {
-		return __webpack_require__(79065);
-	},
-	get DelegatedPlugin() {
-		return __webpack_require__(80632);
-	},
-	get Dependency() {
-		return __webpack_require__(54912);
-	},
-	get DllPlugin() {
-		return __webpack_require__(40038);
-	},
-	get DllReferencePlugin() {
-		return __webpack_require__(90999);
-	},
-	get DynamicEntryPlugin() {
-		return __webpack_require__(96475);
-	},
-	get EntryOptionPlugin() {
-		return __webpack_require__(9909);
-	},
-	get EntryPlugin() {
-		return __webpack_require__(96953);
-	},
-	get EnvironmentPlugin() {
-		return __webpack_require__(22070);
-	},
-	get EvalDevToolModulePlugin() {
-		return __webpack_require__(65218);
-	},
-	get EvalSourceMapDevToolPlugin() {
-		return __webpack_require__(14790);
-	},
-	get ExternalModule() {
-		return __webpack_require__(73071);
-	},
-	get ExternalsPlugin() {
-		return __webpack_require__(6652);
-	},
-	get Generator() {
-		return __webpack_require__(93401);
-	},
-	get HotUpdateChunk() {
-		return __webpack_require__(9597);
-	},
-	get HotModuleReplacementPlugin() {
-		return __webpack_require__(6404);
-	},
-	get IgnorePlugin() {
-		return __webpack_require__(84808);
-	},
-	get JavascriptModulesPlugin() {
-		return util.deprecate(
-			() => __webpack_require__(89464),
-			"webpack.JavascriptModulesPlugin has moved to webpack.javascript.JavascriptModulesPlugin",
-			"DEP_WEBPACK_JAVASCRIPT_MODULES_PLUGIN"
-		)();
-	},
-	get LibManifestPlugin() {
-		return __webpack_require__(93837);
-	},
-	get LibraryTemplatePlugin() {
-		return util.deprecate(
-			() => __webpack_require__(14157),
-			"webpack.LibraryTemplatePlugin is deprecated and has been replaced by compilation.outputOptions.library or compilation.addEntry + passing a library option",
-			"DEP_WEBPACK_LIBRARY_TEMPLATE_PLUGIN"
-		)();
-	},
-	get LoaderOptionsPlugin() {
-		return __webpack_require__(22078);
-	},
-	get LoaderTargetPlugin() {
-		return __webpack_require__(86738);
-	},
-	get Module() {
-		return __webpack_require__(73208);
-	},
-	get ModuleFilenameHelpers() {
-		return __webpack_require__(88821);
-	},
-	get ModuleGraph() {
-		return __webpack_require__(99988);
-	},
-	get ModuleGraphConnection() {
-		return __webpack_require__(40639);
-	},
-	get NoEmitOnErrorsPlugin() {
-		return __webpack_require__(50169);
-	},
-	get NormalModule() {
-		return __webpack_require__(39);
-	},
-	get NormalModuleReplacementPlugin() {
-		return __webpack_require__(30633);
-	},
-	get MultiCompiler() {
-		return __webpack_require__(33370);
-	},
-	get Parser() {
-		return __webpack_require__(11715);
-	},
-	get PrefetchPlugin() {
-		return __webpack_require__(73850);
-	},
-	get ProgressPlugin() {
-		return __webpack_require__(13216);
-	},
-	get ProvidePlugin() {
-		return __webpack_require__(38309);
-	},
-	get RuntimeGlobals() {
-		return __webpack_require__(16475);
-	},
-	get RuntimeModule() {
-		return __webpack_require__(16963);
-	},
-	get SingleEntryPlugin() {
-		return util.deprecate(
-			() => __webpack_require__(96953),
-			"SingleEntryPlugin was renamed to EntryPlugin",
-			"DEP_WEBPACK_SINGLE_ENTRY_PLUGIN"
-		)();
-	},
-	get SourceMapDevToolPlugin() {
-		return __webpack_require__(63872);
-	},
-	get Stats() {
-		return __webpack_require__(31743);
-	},
-	get Template() {
-		return __webpack_require__(1626);
-	},
-	get UsageState() {
-		return (__webpack_require__(63686).UsageState);
-	},
-	get WatchIgnorePlugin() {
-		return __webpack_require__(65193);
-	},
-	get WebpackError() {
-		return __webpack_require__(53799);
-	},
-	get WebpackOptionsApply() {
-		return __webpack_require__(88422);
-	},
-	get WebpackOptionsDefaulter() {
-		return util.deprecate(
-			() => __webpack_require__(14452),
-			"webpack.WebpackOptionsDefaulter is deprecated and has been replaced by webpack.config.getNormalizedWebpackOptions and webpack.config.applyWebpackOptionsDefaults",
-			"DEP_WEBPACK_OPTIONS_DEFAULTER"
-		)();
-	},
-	// TODO webpack 6 deprecate
-	get WebpackOptionsValidationError() {
-		return (__webpack_require__(38476).ValidationError);
-	},
-	get ValidationError() {
-		return (__webpack_require__(38476).ValidationError);
-	},
-
-	cache: {
-		get MemoryCachePlugin() {
-			return __webpack_require__(52539);
-		}
-	},
-
-	config: {
-		get getNormalizedWebpackOptions() {
-			return (__webpack_require__(26693).getNormalizedWebpackOptions);
-		},
-		get applyWebpackOptionsDefaults() {
-			return (__webpack_require__(92988).applyWebpackOptionsDefaults);
-		}
-	},
-
-	dependencies: {
-		get ModuleDependency() {
-			return __webpack_require__(80321);
-		},
-		get ConstDependency() {
-			return __webpack_require__(76911);
-		},
-		get NullDependency() {
-			return __webpack_require__(31830);
-		}
-	},
-
-	ids: {
-		get ChunkModuleIdRangePlugin() {
-			return __webpack_require__(64618);
-		},
-		get NaturalModuleIdsPlugin() {
-			return __webpack_require__(83366);
-		},
-		get OccurrenceModuleIdsPlugin() {
-			return __webpack_require__(35371);
-		},
-		get NamedModuleIdsPlugin() {
-			return __webpack_require__(24339);
-		},
-		get DeterministicChunkIdsPlugin() {
-			return __webpack_require__(8747);
-		},
-		get DeterministicModuleIdsPlugin() {
-			return __webpack_require__(76692);
-		},
-		get NamedChunkIdsPlugin() {
-			return __webpack_require__(6454);
-		},
-		get OccurrenceChunkIdsPlugin() {
-			return __webpack_require__(51020);
-		},
-		get HashedModuleIdsPlugin() {
-			return __webpack_require__(21825);
-		}
-	},
+	}
 
-	javascript: {
-		get EnableChunkLoadingPlugin() {
-			return __webpack_require__(61291);
-		},
-		get JavascriptModulesPlugin() {
-			return __webpack_require__(89464);
-		},
-		get JavascriptParser() {
-			return __webpack_require__(29050);
-		}
-	},
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
 
-	optimize: {
-		get AggressiveMergingPlugin() {
-			return __webpack_require__(64395);
-		},
-		get AggressiveSplittingPlugin() {
-			return util.deprecate(
-				() => __webpack_require__(15543),
-				"AggressiveSplittingPlugin is deprecated in favor of SplitChunksPlugin",
-				"DEP_WEBPACK_AGGRESSIVE_SPLITTING_PLUGIN"
-			)();
-		},
-		get InnerGraph() {
-			return __webpack_require__(38988);
-		},
-		get LimitChunkCountPlugin() {
-			return __webpack_require__(83608);
-		},
-		get MinChunkSizePlugin() {
-			return __webpack_require__(53912);
-		},
-		get ModuleConcatenationPlugin() {
-			return __webpack_require__(74844);
-		},
-		get RealContentHashPlugin() {
-			return __webpack_require__(46043);
-		},
-		get RuntimeChunkPlugin() {
-			return __webpack_require__(2837);
-		},
-		get SideEffectsFlagPlugin() {
-			return __webpack_require__(84800);
-		},
-		get SplitChunksPlugin() {
-			return __webpack_require__(21478);
-		}
-	},
+	serialize(context) {
+		const { write } = context;
+		write(this.id);
+		write(this.name);
+		super.serialize(context);
+	}
 
-	runtime: {
-		get GetChunkFilenameRuntimeModule() {
-			return __webpack_require__(34277);
-		},
-		get LoadScriptRuntimeModule() {
-			return __webpack_require__(19942);
-		}
-	},
+	deserialize(context) {
+		const { read } = context;
+		this.id = read();
+		this.name = read();
+		super.deserialize(context);
+	}
+}
 
-	prefetch: {
-		get ChunkPrefetchPreloadPlugin() {
-			return __webpack_require__(33895);
-		}
-	},
+makeSerializable(
+	HarmonyExportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyExportSpecifierDependency"
+);
 
-	web: {
-		get FetchCompileAsyncWasmPlugin() {
-			return __webpack_require__(8437);
-		},
-		get FetchCompileWasmPlugin() {
-			return __webpack_require__(35537);
-		},
-		get JsonpChunkLoadingRuntimeModule() {
-			return __webpack_require__(84154);
-		},
-		get JsonpTemplatePlugin() {
-			return __webpack_require__(4607);
+HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
+	) {
+		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
+		if (concatenationScope) {
+			concatenationScope.registerExport(dep.name, dep.id);
+			return;
 		}
-	},
-
-	webworker: {
-		get WebWorkerTemplatePlugin() {
-			return __webpack_require__(68693);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.name, runtime);
+		if (!used) {
+			const set = new Set();
+			set.add(dep.name || "namespace");
+			initFragments.push(
+				new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
+			);
+			return;
 		}
-	},
 
-	node: {
-		get NodeEnvironmentPlugin() {
-			return __webpack_require__(7553);
-		},
-		get NodeSourcePlugin() {
-			return __webpack_require__(7103);
-		},
-		get NodeTargetPlugin() {
-			return __webpack_require__(17916);
-		},
-		get NodeTemplatePlugin() {
-			return __webpack_require__(61052);
-		},
-		get ReadFileCompileWasmPlugin() {
-			return __webpack_require__(98939);
-		}
-	},
+		const map = new Map();
+		map.set(used, `/* binding */ ${dep.id}`);
+		initFragments.push(
+			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
+		);
+	}
+};
 
-	electron: {
-		get ElectronTargetPlugin() {
-			return __webpack_require__(32277);
-		}
-	},
+module.exports = HarmonyExportSpecifierDependency;
 
-	wasm: {
-		get AsyncWebAssemblyModulesPlugin() {
-			return __webpack_require__(7538);
-		}
-	},
 
-	library: {
-		get AbstractLibraryPlugin() {
-			return __webpack_require__(26030);
-		},
-		get EnableLibraryPlugin() {
-			return __webpack_require__(91452);
-		}
-	},
+/***/ }),
 
-	container: {
-		get ContainerPlugin() {
-			return __webpack_require__(9244);
-		},
-		get ContainerReferencePlugin() {
-			return __webpack_require__(95757);
-		},
-		get ModuleFederationPlugin() {
-			return __webpack_require__(30569);
-		},
-		get scope() {
-			return (__webpack_require__(3083).scope);
-		}
-	},
+/***/ 39211:
+/***/ (function(__unused_webpack_module, exports) {
 
-	sharing: {
-		get ConsumeSharedPlugin() {
-			return __webpack_require__(15046);
-		},
-		get ProvideSharedPlugin() {
-			return __webpack_require__(31225);
-		},
-		get SharePlugin() {
-			return __webpack_require__(26335);
-		},
-		get scope() {
-			return (__webpack_require__(3083).scope);
-		}
-	},
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	debug: {
-		get ProfilingPlugin() {
-			return __webpack_require__(2757);
-		}
-	},
 
-	util: {
-		get createHash() {
-			return __webpack_require__(49835);
-		},
-		get comparators() {
-			return __webpack_require__(29579);
-		},
-		get runtime() {
-			return __webpack_require__(17156);
-		},
-		get serialization() {
-			return __webpack_require__(8282);
-		},
-		get cleverMerge() {
-			return (__webpack_require__(60839).cachedCleverMerge);
-		},
-		get LazySet() {
-			return __webpack_require__(38938);
-		}
-	},
 
-	get sources() {
-		return __webpack_require__(51255);
-	},
+/** @typedef {import("../Parser").ParserState} ParserState */
 
-	experiments: {
-		schemes: {
-			get HttpUriPlugin() {
-				return __webpack_require__(42110);
-			}
-		},
-		ids: {
-			get SyncModuleIdsPlugin() {
-				return __webpack_require__(8635);
-			}
+/** @type {WeakMap<ParserState, boolean>} */
+const parserStateExportsState = new WeakMap();
+
+/**
+ * @param {ParserState} parserState parser state
+ * @param {boolean} isStrictHarmony strict harmony mode should be enabled
+ * @returns {void}
+ */
+exports.enable = (parserState, isStrictHarmony) => {
+	const value = parserStateExportsState.get(parserState);
+	if (value === false) return;
+	parserStateExportsState.set(parserState, true);
+	if (value !== true) {
+		parserState.module.buildMeta.exportsType = "namespace";
+		parserState.module.buildInfo.strict = true;
+		parserState.module.buildInfo.exportsArgument = "__webpack_exports__";
+		if (isStrictHarmony) {
+			parserState.module.buildMeta.strictHarmonyModule = true;
+			parserState.module.buildInfo.moduleArgument = "__webpack_module__";
 		}
 	}
-});
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+exports.isEnabled = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	return value === true;
+};
 
 
 /***/ }),
 
-/***/ 18535:
+/***/ 57154:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -88521,687 +85892,1054 @@ module.exports = mergeExports(fn, {
 
 
 
-const { ConcatSource, PrefixSource, RawSource } = __webpack_require__(51255);
-const { RuntimeGlobals } = __webpack_require__(91919);
-const HotUpdateChunk = __webpack_require__(9597);
-const Template = __webpack_require__(1626);
-const { getCompilationHooks } = __webpack_require__(89464);
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = __webpack_require__(98124);
+const ConditionalInitFragment = __webpack_require__(61333);
+const Dependency = __webpack_require__(54912);
+const HarmonyLinkingError = __webpack_require__(97511);
+const InitFragment = __webpack_require__(55870);
+const Template = __webpack_require__(39722);
+const AwaitDependenciesInitFragment = __webpack_require__(41153);
+const { filterRuntime, mergeRuntime } = __webpack_require__(17156);
+const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class ArrayPushCallbackChunkFormatPlugin {
+const ExportPresenceModes = {
+	NONE: /** @type {0} */ (0),
+	WARN: /** @type {1} */ (1),
+	AUTO: /** @type {2} */ (2),
+	ERROR: /** @type {3} */ (3),
+	fromUserOption(str) {
+		switch (str) {
+			case "error":
+				return ExportPresenceModes.ERROR;
+			case "warn":
+				return ExportPresenceModes.WARN;
+			case "auto":
+				return ExportPresenceModes.AUTO;
+			case false:
+				return ExportPresenceModes.NONE;
+			default:
+				throw new Error(`Invalid export presence value ${str}`);
+		}
+	}
+};
+
+class HarmonyImportDependency extends ModuleDependency {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 *
+	 * @param {string} request request string
+	 * @param {number} sourceOrder source order
+	 * @param {Record<string, any>=} assertions import assertions
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ArrayPushCallbackChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.require);
-						}
-						set.add(RuntimeGlobals.chunkCallback);
-					}
-				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
-						const globalObject = runtimeTemplate.globalObject;
-						const source = new ConcatSource();
-						const runtimeModules =
-							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-						if (hotUpdateChunk) {
-							const hotUpdateGlobal =
-								runtimeTemplate.outputOptions.hotUpdateGlobal;
-							source.add(
-								`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`
-							);
-							source.add(`${JSON.stringify(chunk.id)},`);
-							source.add(modules);
-							if (runtimeModules.length > 0) {
-								source.add(",\n");
-								const runtimePart = Template.renderChunkRuntimeModules(
-									runtimeModules,
-									renderContext
-								);
-								source.add(runtimePart);
-							}
-							source.add(")");
-						} else {
-							const chunkLoadingGlobal =
-								runtimeTemplate.outputOptions.chunkLoadingGlobal;
-							source.add(
-								`(${globalObject}[${JSON.stringify(
-									chunkLoadingGlobal
-								)}] = ${globalObject}[${JSON.stringify(
-									chunkLoadingGlobal
-								)}] || []).push([`
-							);
-							source.add(`${JSON.stringify(chunk.ids)},`);
-							source.add(modules);
-							const entries = Array.from(
-								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-							);
-							if (runtimeModules.length > 0 || entries.length > 0) {
-								const runtime = new ConcatSource(
-									(runtimeTemplate.supportsArrowFunction()
-										? "__webpack_require__ =>"
-										: "function(__webpack_require__)") +
-										" { // webpackRuntimeModules\n"
-								);
-								if (runtimeModules.length > 0) {
-									runtime.add(
-										Template.renderRuntimeModules(runtimeModules, {
-											...renderContext,
-											codeGenerationResults: compilation.codeGenerationResults
-										})
-									);
-								}
-								if (entries.length > 0) {
-									const startupSource = new RawSource(
-										generateEntryStartup(
-											chunkGraph,
-											runtimeTemplate,
-											entries,
-											chunk,
-											true
-										)
-									);
-									runtime.add(
-										hooks.renderStartup.call(
-											startupSource,
-											entries[entries.length - 1][0],
-											{
-												...renderContext,
-												inlined: false
-											}
-										)
-									);
-									if (
-										chunkGraph
-											.getChunkRuntimeRequirements(chunk)
-											.has(RuntimeGlobals.returnExportsFromRuntime)
-									) {
-										runtime.add("return __webpack_exports__;\n");
-									}
-								}
-								runtime.add("}\n");
-								source.add(",\n");
-								source.add(new PrefixSource("/******/ ", runtime));
-							}
-							source.add("])");
-						}
-						return source;
-					}
-				);
-				hooks.chunkHash.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update(
-							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
-						);
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+	constructor(request, sourceOrder, assertions) {
+		super(request);
+		this.sourceOrder = sourceOrder;
+		this.assertions = assertions;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string} name of the variable for the import
+	 */
+	getImportVar(moduleGraph) {
+		const module = moduleGraph.getParentModule(this);
+		const meta = moduleGraph.getMeta(module);
+		let importVarMap = meta.importVarMap;
+		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
+		let importVar = importVarMap.get(moduleGraph.getModule(this));
+		if (importVar) return importVar;
+		importVar = `${Template.toIdentifier(
+			`${this.userRequest}`
+		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
+		importVarMap.set(moduleGraph.getModule(this), importVar);
+		return importVar;
+	}
+
+	/**
+	 * @param {boolean} update create new variables or update existing one
+	 * @param {DependencyTemplateContext} templateContext the template context
+	 * @returns {[string, string]} the import statement and the compat statement
+	 */
+	getImportStatement(
+		update,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		return runtimeTemplate.importStatement({
+			update,
+			module: moduleGraph.getModule(this),
+			chunkGraph,
+			importVar: this.getImportVar(moduleGraph),
+			request: this.request,
+			originModule: module,
+			runtimeRequirements
+		});
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {string[]} ids imported ids
+	 * @param {string} additionalMessage extra info included in the error message
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	getLinkingErrors(moduleGraph, ids, additionalMessage) {
+		const importedModule = moduleGraph.getModule(this);
+		// ignore errors for missing or failed modules
+		if (!importedModule || importedModule.getNumberOfErrors() > 0) {
+			return;
+		}
+
+		const parentModule = moduleGraph.getParentModule(this);
+		const exportsType = importedModule.getExportsType(
+			moduleGraph,
+			parentModule.buildMeta.strictHarmonyModule
+		);
+		if (exportsType === "namespace" || exportsType === "default-with-named") {
+			if (ids.length === 0) {
+				return;
+			}
+
+			if (
+				(exportsType !== "default-with-named" || ids[0] !== "default") &&
+				moduleGraph.isExportProvided(importedModule, ids) === false
+			) {
+				// We are sure that it's not provided
+
+				// Try to provide detailed info in the error message
+				let pos = 0;
+				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+				while (pos < ids.length && exportsInfo) {
+					const id = ids[pos++];
+					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+					if (exportInfo.provided === false) {
+						// We are sure that it's not provided
+						const providedExports = exportsInfo.getProvidedExports();
+						const moreInfo = !Array.isArray(providedExports)
+							? " (possible exports unknown)"
+							: providedExports.length === 0
+							? " (module has no exports)"
+							: ` (possible exports: ${providedExports.join(", ")})`;
+						return [
+							new HarmonyLinkingError(
+								`export ${ids
+									.slice(0, pos)
+									.map(id => `'${id}'`)
+									.join(".")} ${additionalMessage} was not found in '${
+									this.userRequest
+								}'${moreInfo}`
+							)
+						];
 					}
-				);
+					exportsInfo = exportInfo.getNestedExportsInfo();
+				}
+
+				// General error message
+				return [
+					new HarmonyLinkingError(
+						`export ${ids
+							.map(id => `'${id}'`)
+							.join(".")} ${additionalMessage} was not found in '${
+							this.userRequest
+						}'`
+					)
+				];
 			}
-		);
+		}
+		switch (exportsType) {
+			case "default-only":
+				// It's has only a default export
+				if (ids.length > 0 && ids[0] !== "default") {
+					// In strict harmony modules we only support the default export
+					return [
+						new HarmonyLinkingError(
+							`Can't import the named export ${ids
+								.map(id => `'${id}'`)
+								.join(
+									"."
+								)} ${additionalMessage} from default-exporting module (only default export is available)`
+						)
+					];
+				}
+				break;
+			case "default-with-named":
+				// It has a default export and named properties redirect
+				// In some cases we still want to warn here
+				if (
+					ids.length > 0 &&
+					ids[0] !== "default" &&
+					importedModule.buildMeta.defaultObject === "redirect-warn"
+				) {
+					// For these modules only the default export is supported
+					return [
+						new HarmonyLinkingError(
+							`Should not import the named export ${ids
+								.map(id => `'${id}'`)
+								.join(
+									"."
+								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
+						)
+					];
+				}
+				break;
+		}
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.sourceOrder);
+		write(this.assertions);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.sourceOrder = read();
+		this.assertions = read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = ArrayPushCallbackChunkFormatPlugin;
+module.exports = HarmonyImportDependency;
 
+/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
+const importEmittedMap = new WeakMap();
 
-/***/ }),
+HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyImportDependency} */ (dependency);
+		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
 
-/***/ 950:
-/***/ (function(module) {
+		const connection = moduleGraph.getConnection(dep);
+		if (connection && !connection.isTargetActive(runtime)) return;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const referencedModule = connection && connection.module;
 
+		if (
+			connection &&
+			connection.weak &&
+			referencedModule &&
+			chunkGraph.getModuleId(referencedModule) === null
+		) {
+			// in weak references, module might not be in any chunk
+			// but that's ok, we don't need that logic in this case
+			return;
+		}
 
+		const moduleKey = referencedModule
+			? referencedModule.identifier()
+			: dep.request;
+		const key = `harmony import ${moduleKey}`;
 
-/** @typedef {import("estree").Node} EsTreeNode */
-/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
+		const runtimeCondition = dep.weak
+			? false
+			: connection
+			? filterRuntime(runtime, r => connection.isTargetActive(r))
+			: true;
 
-const TypeUnknown = 0;
-const TypeUndefined = 1;
-const TypeNull = 2;
-const TypeString = 3;
-const TypeNumber = 4;
-const TypeBoolean = 5;
-const TypeRegExp = 6;
-const TypeConditional = 7;
-const TypeArray = 8;
-const TypeConstArray = 9;
-const TypeIdentifier = 10;
-const TypeWrapped = 11;
-const TypeTemplateString = 12;
-const TypeBigInt = 13;
+		if (module && referencedModule) {
+			let emittedModules = importEmittedMap.get(module);
+			if (emittedModules === undefined) {
+				emittedModules = new WeakMap();
+				importEmittedMap.set(module, emittedModules);
+			}
+			let mergedRuntimeCondition = runtimeCondition;
+			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+					mergedRuntimeCondition = oldRuntimeCondition;
+				} else {
+					mergedRuntimeCondition = mergeRuntime(
+						oldRuntimeCondition,
+						mergedRuntimeCondition
+					);
+				}
+			}
+			emittedModules.set(referencedModule, mergedRuntimeCondition);
+		}
 
-class BasicEvaluatedExpression {
-	constructor() {
-		this.type = TypeUnknown;
-		/** @type {[number, number]} */
-		this.range = undefined;
-		/** @type {boolean} */
-		this.falsy = false;
-		/** @type {boolean} */
-		this.truthy = false;
-		/** @type {boolean | undefined} */
-		this.nullish = undefined;
-		/** @type {boolean} */
-		this.sideEffects = true;
-		/** @type {boolean | undefined} */
-		this.bool = undefined;
-		/** @type {number | undefined} */
-		this.number = undefined;
-		/** @type {bigint | undefined} */
-		this.bigint = undefined;
-		/** @type {RegExp | undefined} */
-		this.regExp = undefined;
-		/** @type {string | undefined} */
-		this.string = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.quasis = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.parts = undefined;
-		/** @type {any[] | undefined} */
-		this.array = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.items = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.options = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
-		this.prefix = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
-		this.postfix = undefined;
-		this.wrappedInnerExpressions = undefined;
-		/** @type {string | undefined} */
-		this.identifier = undefined;
-		/** @type {VariableInfoInterface} */
-		this.rootInfo = undefined;
-		/** @type {() => string[]} */
-		this.getMembers = undefined;
-		/** @type {EsTreeNode} */
-		this.expression = undefined;
+		const importStatement = dep.getImportStatement(false, templateContext);
+		if (
+			referencedModule &&
+			templateContext.moduleGraph.isAsync(referencedModule)
+		) {
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[0],
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key,
+					runtimeCondition
+				)
+			);
+			templateContext.initFragments.push(
+				new AwaitDependenciesInitFragment(
+					new Set([dep.getImportVar(templateContext.moduleGraph)])
+				)
+			);
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[1],
+					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key + " compat",
+					runtimeCondition
+				)
+			);
+		} else {
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[0] + importStatement[1],
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key,
+					runtimeCondition
+				)
+			);
+		}
 	}
 
-	isUnknown() {
-		return this.type === TypeUnknown;
+	/**
+	 *
+	 * @param {Module} module the module
+	 * @param {Module} referencedModule the referenced module
+	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
+	 */
+	static getImportEmittedRuntime(module, referencedModule) {
+		const emittedModules = importEmittedMap.get(module);
+		if (emittedModules === undefined) return false;
+		return emittedModules.get(referencedModule) || false;
 	}
+};
 
-	isNull() {
-		return this.type === TypeNull;
-	}
+module.exports.ExportPresenceModes = ExportPresenceModes;
 
-	isUndefined() {
-		return this.type === TypeUndefined;
-	}
 
-	isString() {
-		return this.type === TypeString;
-	}
+/***/ }),
 
-	isNumber() {
-		return this.type === TypeNumber;
-	}
+/***/ 20862:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	isBigInt() {
-		return this.type === TypeBigInt;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	isBoolean() {
-		return this.type === TypeBoolean;
-	}
 
-	isRegExp() {
-		return this.type === TypeRegExp;
-	}
 
-	isConditional() {
-		return this.type === TypeConditional;
-	}
+const HotModuleReplacementPlugin = __webpack_require__(6404);
+const InnerGraph = __webpack_require__(38988);
+const ConstDependency = __webpack_require__(76911);
+const HarmonyAcceptDependency = __webpack_require__(23624);
+const HarmonyAcceptImportDependency = __webpack_require__(99843);
+const HarmonyExports = __webpack_require__(39211);
+const { ExportPresenceModes } = __webpack_require__(57154);
+const HarmonyImportSideEffectDependency = __webpack_require__(73132);
+const HarmonyImportSpecifierDependency = __webpack_require__(14077);
 
-	isArray() {
-		return this.type === TypeArray;
-	}
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
+/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
+/** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
 
-	isConstArray() {
-		return this.type === TypeConstArray;
-	}
+const harmonySpecifierTag = Symbol("harmony import");
 
-	isIdentifier() {
-		return this.type === TypeIdentifier;
-	}
+/**
+ * @typedef {Object} HarmonySettings
+ * @property {string[]} ids
+ * @property {string} source
+ * @property {number} sourceOrder
+ * @property {string} name
+ * @property {boolean} await
+ * @property {Record<string, any> | undefined} assertions
+ */
 
-	isWrapped() {
-		return this.type === TypeWrapped;
+/**
+ * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
+ * @returns {Record<string, any> | undefined} assertions
+ */
+function getAssertions(node) {
+	// TODO remove cast when @types/estree has been updated to import assertions
+	const assertions = /** @type {{ assertions?: ImportAttributeNode[] }} */ (
+		node
+	).assertions;
+	if (assertions === undefined) {
+		return undefined;
+	}
+	const result = {};
+	for (const assertion of assertions) {
+		const key =
+			assertion.key.type === "Identifier"
+				? assertion.key.name
+				: assertion.key.value;
+		result[key] = assertion.value.value;
 	}
+	return result;
+}
 
-	isTemplateString() {
-		return this.type === TypeTemplateString;
+module.exports = class HarmonyImportDependencyParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
+	constructor(options) {
+		this.exportPresenceMode =
+			options.importExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
+		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
 	/**
-	 * Is expression a primitive or an object type value?
-	 * @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
 	 */
-	isPrimitiveType() {
-		switch (this.type) {
-			case TypeUndefined:
-			case TypeNull:
-			case TypeString:
-			case TypeNumber:
-			case TypeBoolean:
-			case TypeBigInt:
-			case TypeWrapped:
-			case TypeTemplateString:
+	apply(parser) {
+		const { exportPresenceMode } = this;
+		parser.hooks.isPure
+			.for("Identifier")
+			.tap("HarmonyImportDependencyParserPlugin", expression => {
+				const expr = /** @type {Identifier} */ (expression);
+				if (
+					parser.isVariableDefined(expr.name) ||
+					parser.getTagData(expr.name, harmonySpecifierTag)
+				) {
+					return true;
+				}
+			});
+		parser.hooks.import.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(statement.range[0]) ? ";" : "",
+					statement.range
+				);
+				clearDep.loc = statement.loc;
+				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(statement.range[1]);
+				const assertions = getAssertions(statement);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					source,
+					parser.state.lastHarmonyImportOrder,
+					assertions
+				);
+				sideEffectDep.loc = statement.loc;
+				parser.state.module.addDependency(sideEffectDep);
 				return true;
-			case TypeRegExp:
-			case TypeArray:
-			case TypeConstArray:
-				return false;
-			default:
-				return undefined;
-		}
+			}
+		);
+		parser.hooks.importSpecifier.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source, id, name) => {
+				const ids = id === null ? [] : [id];
+				parser.tagVariable(name, harmonySpecifierTag, {
+					name,
+					source,
+					ids,
+					sourceOrder: parser.state.lastHarmonyImportOrder,
+					assertions: getAssertions(statement)
+				});
+				return true;
+			}
+		);
+		parser.hooks.expression
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					settings.ids,
+					settings.name,
+					expr.range,
+					exportPresenceMode,
+					settings.assertions
+				);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		parser.hooks.expressionMemberChain
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const ids = settings.ids.concat(members);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					ids,
+					settings.name,
+					expr.range,
+					exportPresenceMode,
+					settings.assertions
+				);
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		parser.hooks.callMemberChain
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+				const { arguments: args, callee } = expr;
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const ids = settings.ids.concat(members);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					ids,
+					settings.name,
+					callee.range,
+					exportPresenceMode,
+					settings.assertions
+				);
+				dep.directImport = members.length === 0;
+				dep.call = true;
+				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
+				// only in case when we strictly follow the spec we need a special case here
+				dep.namespaceObjectAsContext =
+					members.length > 0 && this.strictThisContextOnImports;
+				dep.loc = callee.loc;
+				parser.state.module.addDependency(dep);
+				if (args) parser.walkExpressions(args);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		const { hotAcceptCallback, hotAcceptWithoutCallback } =
+			HotModuleReplacementPlugin.getParserHooks(parser);
+		hotAcceptCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				if (!HarmonyExports.isEnabled(parser.state)) {
+					// This is not a harmony module, skip it
+					return;
+				}
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(request);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						expr.range,
+						dependencies,
+						true
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+		hotAcceptWithoutCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				if (!HarmonyExports.isEnabled(parser.state)) {
+					// This is not a harmony module, skip it
+					return;
+				}
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(request);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						expr.range,
+						dependencies,
+						false
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+	}
+};
+
+module.exports.harmonySpecifierTag = harmonySpecifierTag;
+module.exports.getAssertions = getAssertions;
+
+
+/***/ }),
+
+/***/ 73132:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const HarmonyImportDependency = __webpack_require__(57154);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../InitFragment")} InitFragment */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
+	constructor(request, sourceOrder, assertions) {
+		super(request, sourceOrder, assertions);
 	}
 
-	/**
-	 * Is expression a runtime or compile-time value?
-	 * @returns {boolean} true: compile time value, false: runtime value
-	 */
-	isCompileTimeValue() {
-		switch (this.type) {
-			case TypeUndefined:
-			case TypeNull:
-			case TypeString:
-			case TypeNumber:
-			case TypeBoolean:
-			case TypeRegExp:
-			case TypeConstArray:
-			case TypeBigInt:
-				return true;
-			default:
-				return false;
-		}
+	get type() {
+		return "harmony side effect evaluation";
 	}
 
 	/**
-	 * Gets the compile-time value of the expression
-	 * @returns {any} the javascript value
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
-	asCompileTimeValue() {
-		switch (this.type) {
-			case TypeUndefined:
-				return undefined;
-			case TypeNull:
-				return null;
-			case TypeString:
-				return this.string;
-			case TypeNumber:
-				return this.number;
-			case TypeBoolean:
-				return this.bool;
-			case TypeRegExp:
-				return this.regExp;
-			case TypeConstArray:
-				return this.array;
-			case TypeBigInt:
-				return this.bigint;
-			default:
-				throw new Error(
-					"asCompileTimeValue must only be called for compile-time values"
-				);
-		}
-	}
-
-	isTruthy() {
-		return this.truthy;
+	getCondition(moduleGraph) {
+		return connection => {
+			const refModule = connection.resolvedModule;
+			if (!refModule) return true;
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
 	}
 
-	isFalsy() {
-		return this.falsy;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		const refModule = moduleGraph.getModule(this);
+		if (!refModule) return true;
+		return refModule.getSideEffectsConnectionState(moduleGraph);
 	}
+}
 
-	isNullish() {
-		return this.nullish;
-	}
+makeSerializable(
+	HarmonyImportSideEffectDependency,
+	"webpack/lib/dependencies/HarmonyImportSideEffectDependency"
+);
 
+HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {
 	/**
-	 * Can this expression have side effects?
-	 * @returns {boolean} false: never has side effects
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	couldHaveSideEffects() {
-		return this.sideEffects;
-	}
-
-	asBool() {
-		if (this.truthy) return true;
-		if (this.falsy || this.nullish) return false;
-		if (this.isBoolean()) return this.bool;
-		if (this.isNull()) return false;
-		if (this.isUndefined()) return false;
-		if (this.isString()) return this.string !== "";
-		if (this.isNumber()) return this.number !== 0;
-		if (this.isBigInt()) return this.bigint !== BigInt(0);
-		if (this.isRegExp()) return true;
-		if (this.isArray()) return true;
-		if (this.isConstArray()) return true;
-		if (this.isWrapped()) {
-			return (this.prefix && this.prefix.asBool()) ||
-				(this.postfix && this.postfix.asBool())
-				? true
-				: undefined;
-		}
-		if (this.isTemplateString()) {
-			const str = this.asString();
-			if (typeof str === "string") return str !== "";
+	apply(dependency, source, templateContext) {
+		const { moduleGraph, concatenationScope } = templateContext;
+		if (concatenationScope) {
+			const module = moduleGraph.getModule(dependency);
+			if (concatenationScope.isModuleInScope(module)) {
+				return;
+			}
 		}
-		return undefined;
+		super.apply(dependency, source, templateContext);
 	}
+};
 
-	asNullish() {
-		const nullish = this.isNullish();
-
-		if (nullish === true || this.isNull() || this.isUndefined()) return true;
+module.exports = HarmonyImportSideEffectDependency;
 
-		if (nullish === false) return false;
-		if (this.isTruthy()) return false;
-		if (this.isBoolean()) return false;
-		if (this.isString()) return false;
-		if (this.isNumber()) return false;
-		if (this.isBigInt()) return false;
-		if (this.isRegExp()) return false;
-		if (this.isArray()) return false;
-		if (this.isConstArray()) return false;
-		if (this.isTemplateString()) return false;
-		if (this.isRegExp()) return false;
 
-		return undefined;
-	}
+/***/ }),
 
-	asString() {
-		if (this.isBoolean()) return `${this.bool}`;
-		if (this.isNull()) return "null";
-		if (this.isUndefined()) return "undefined";
-		if (this.isString()) return this.string;
-		if (this.isNumber()) return `${this.number}`;
-		if (this.isBigInt()) return `${this.bigint}`;
-		if (this.isRegExp()) return `${this.regExp}`;
-		if (this.isArray()) {
-			let array = [];
-			for (const item of this.items) {
-				const itemStr = item.asString();
-				if (itemStr === undefined) return undefined;
-				array.push(itemStr);
-			}
-			return `${array}`;
-		}
-		if (this.isConstArray()) return `${this.array}`;
-		if (this.isTemplateString()) {
-			let str = "";
-			for (const part of this.parts) {
-				const partStr = part.asString();
-				if (partStr === undefined) return undefined;
-				str += partStr;
-			}
-			return str;
-		}
-		return undefined;
-	}
+/***/ 14077:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	setString(string) {
-		this.type = TypeString;
-		this.string = string;
-		this.sideEffects = false;
-		return this;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	setUndefined() {
-		this.type = TypeUndefined;
-		this.sideEffects = false;
-		return this;
-	}
 
-	setNull() {
-		this.type = TypeNull;
-		this.sideEffects = false;
-		return this;
-	}
 
-	setNumber(number) {
-		this.type = TypeNumber;
-		this.number = number;
-		this.sideEffects = false;
-		return this;
-	}
+const Dependency = __webpack_require__(54912);
+const {
+	getDependencyUsedByExportsCondition
+} = __webpack_require__(38988);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const HarmonyImportDependency = __webpack_require__(57154);
 
-	setBigInt(bigint) {
-		this.type = TypeBigInt;
-		this.bigint = bigint;
-		this.sideEffects = false;
-		return this;
-	}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-	setBoolean(bool) {
-		this.type = TypeBoolean;
-		this.bool = bool;
-		this.sideEffects = false;
-		return this;
-	}
+const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
 
-	setRegExp(regExp) {
-		this.type = TypeRegExp;
-		this.regExp = regExp;
-		this.sideEffects = false;
-		return this;
-	}
+const { ExportPresenceModes } = HarmonyImportDependency;
 
-	setIdentifier(identifier, rootInfo, getMembers) {
-		this.type = TypeIdentifier;
-		this.identifier = identifier;
-		this.rootInfo = rootInfo;
-		this.getMembers = getMembers;
-		this.sideEffects = true;
-		return this;
+class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
+	constructor(
+		request,
+		sourceOrder,
+		ids,
+		name,
+		range,
+		exportPresenceMode,
+		assertions
+	) {
+		super(request, sourceOrder, assertions);
+		this.ids = ids;
+		this.name = name;
+		this.range = range;
+		this.exportPresenceMode = exportPresenceMode;
+		this.namespaceObjectAsContext = false;
+		this.call = undefined;
+		this.directImport = undefined;
+		this.shorthand = undefined;
+		this.asiSafe = undefined;
+		/** @type {Set<string> | boolean} */
+		this.usedByExports = undefined;
 	}
 
-	setWrapped(prefix, postfix, innerExpressions) {
-		this.type = TypeWrapped;
-		this.prefix = prefix;
-		this.postfix = postfix;
-		this.wrappedInnerExpressions = innerExpressions;
-		this.sideEffects = true;
-		return this;
+	// TODO webpack 6 remove
+	get id() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	setOptions(options) {
-		this.type = TypeConditional;
-		this.options = options;
-		this.sideEffects = true;
-		return this;
+	// TODO webpack 6 remove
+	getId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	addOptions(options) {
-		if (!this.options) {
-			this.type = TypeConditional;
-			this.options = [];
-			this.sideEffects = true;
-		}
-		for (const item of options) {
-			this.options.push(item);
-		}
-		return this;
+	// TODO webpack 6 remove
+	setId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	setItems(items) {
-		this.type = TypeArray;
-		this.items = items;
-		this.sideEffects = items.some(i => i.couldHaveSideEffects());
-		return this;
+	get type() {
+		return "harmony import specifier";
 	}
 
-	setArray(array) {
-		this.type = TypeConstArray;
-		this.array = array;
-		this.sideEffects = false;
-		return this;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported ids
+	 */
+	getIds(moduleGraph) {
+		const meta = moduleGraph.getMetaIfExisting(this);
+		if (meta === undefined) return this.ids;
+		const ids = meta[idsSymbol];
+		return ids !== undefined ? ids : this.ids;
 	}
 
-	setTemplateString(quasis, parts, kind) {
-		this.type = TypeTemplateString;
-		this.quasis = quasis;
-		this.parts = parts;
-		this.templateStringKind = kind;
-		this.sideEffects = parts.some(p => p.sideEffects);
-		return this;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
 	}
 
-	setTruthy() {
-		this.falsy = false;
-		this.truthy = true;
-		this.nullish = false;
-		return this;
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
 	}
 
-	setFalsy() {
-		this.falsy = true;
-		this.truthy = false;
-		return this;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
-	setNullish(value) {
-		this.nullish = value;
-
-		if (value) return this.setFalsy();
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		let ids = this.getIds(moduleGraph);
+		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		let namespaceObjectAsContext = this.namespaceObjectAsContext;
+		if (ids[0] === "default") {
+			const selfModule = moduleGraph.getParentModule(this);
+			const importedModule = moduleGraph.getModule(this);
+			switch (
+				importedModule.getExportsType(
+					moduleGraph,
+					selfModule.buildMeta.strictHarmonyModule
+				)
+			) {
+				case "default-only":
+				case "default-with-named":
+					if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
+					ids = ids.slice(1);
+					namespaceObjectAsContext = true;
+					break;
+				case "dynamic":
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+			}
+		}
 
-		return this;
-	}
+		if (
+			this.call &&
+			!this.directImport &&
+			(namespaceObjectAsContext || ids.length > 1)
+		) {
+			if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
+			ids = ids.slice(0, -1);
+		}
 
-	setRange(range) {
-		this.range = range;
-		return this;
+		return [ids];
 	}
 
-	setSideEffects(sideEffects = true) {
-		this.sideEffects = sideEffects;
-		return this;
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {number} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
 	}
 
-	setExpression(expression) {
-		this.expression = expression;
-		return this;
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
+	 */
+	getWarnings(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
 	}
-}
-
-/**
- * @param {string} flags regexp flags
- * @returns {boolean} is valid flags
- */
-BasicEvaluatedExpression.isValidRegExpFlags = flags => {
-	const len = flags.length;
-
-	if (len === 0) return true;
-	if (len > 4) return false;
 
-	// cspell:word gimy
-	let remaining = 0b0000; // bit per RegExp flag: gimy
-
-	for (let i = 0; i < len; i++)
-		switch (flags.charCodeAt(i)) {
-			case 103 /* g */:
-				if (remaining & 0b1000) return false;
-				remaining |= 0b1000;
-				break;
-			case 105 /* i */:
-				if (remaining & 0b0100) return false;
-				remaining |= 0b0100;
-				break;
-			case 109 /* m */:
-				if (remaining & 0b0010) return false;
-				remaining |= 0b0010;
-				break;
-			case 121 /* y */:
-				if (remaining & 0b0001) return false;
-				remaining |= 0b0001;
-				break;
-			default:
-				return false;
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
+	 */
+	getErrors(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
+			return this._getErrors(moduleGraph);
 		}
+		return null;
+	}
 
-	return true;
-};
-
-module.exports = BasicEvaluatedExpression;
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		return this.getLinkingErrors(
+			moduleGraph,
+			ids,
+			`(imported as '${this.name}')`
+		);
+	}
 
+	/**
+	 * implement this method to allow the occurrence order plugin to count correctly
+	 * @returns {number} count how often the id is used in this dependency
+	 */
+	getNumberOfIdOccurrences() {
+		return 0;
+	}
 
-/***/ }),
+	serialize(context) {
+		const { write } = context;
+		write(this.ids);
+		write(this.name);
+		write(this.range);
+		write(this.exportPresenceMode);
+		write(this.namespaceObjectAsContext);
+		write(this.call);
+		write(this.directImport);
+		write(this.shorthand);
+		write(this.asiSafe);
+		write(this.usedByExports);
+		super.serialize(context);
+	}
 
-/***/ 91145:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+	deserialize(context) {
+		const { read } = context;
+		this.ids = read();
+		this.name = read();
+		this.range = read();
+		this.exportPresenceMode = read();
+		this.namespaceObjectAsContext = read();
+		this.call = read();
+		this.directImport = read();
+		this.shorthand = read();
+		this.asiSafe = read();
+		this.usedByExports = read();
+		super.deserialize(context);
+	}
+}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+makeSerializable(
+	HarmonyImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
+);
 
+HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
+		const { moduleGraph, module, runtime, concatenationScope } =
+			templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) return;
 
+		const ids = dep.getIds(moduleGraph);
 
-const Entrypoint = __webpack_require__(13795);
+		let exportExpr;
+		if (
+			connection &&
+			concatenationScope &&
+			concatenationScope.isModuleInScope(connection.module)
+		) {
+			if (ids.length === 0) {
+				exportExpr = concatenationScope.createModuleReference(
+					connection.module,
+					{
+						asiSafe: dep.asiSafe
+					}
+				);
+			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
+				exportExpr =
+					concatenationScope.createModuleReference(connection.module, {
+						asiSafe: dep.asiSafe
+					}) + propertyAccess(ids);
+			} else {
+				exportExpr = concatenationScope.createModuleReference(
+					connection.module,
+					{
+						ids,
+						call: dep.call,
+						directImport: dep.directImport,
+						asiSafe: dep.asiSafe
+					}
+				);
+			}
+		} else {
+			super.apply(dependency, source, templateContext);
 
-/** @typedef {import("../Chunk")} Chunk */
+			const { runtimeTemplate, initFragments, runtimeRequirements } =
+				templateContext;
 
-/**
- * @param {Entrypoint} entrypoint a chunk group
- * @param {Chunk} excludedChunk1 current chunk which is excluded
- * @param {Chunk} excludedChunk2 runtime chunk which is excluded
- * @returns {Set<Chunk>} chunks
- */
-const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
-	const queue = new Set([entrypoint]);
-	const chunks = new Set();
-	for (const entrypoint of queue) {
-		for (const chunk of entrypoint.chunks) {
-			if (chunk === excludedChunk1) continue;
-			if (chunk === excludedChunk2) continue;
-			chunks.add(chunk);
+			exportExpr = runtimeTemplate.exportFromImport({
+				moduleGraph,
+				module: moduleGraph.getModule(dep),
+				request: dep.request,
+				exportName: ids,
+				originModule: module,
+				asiSafe: dep.shorthand ? true : dep.asiSafe,
+				isCall: dep.call,
+				callContext: !dep.directImport,
+				defaultInterop: true,
+				importVar: dep.getImportVar(moduleGraph),
+				initFragments,
+				runtime,
+				runtimeRequirements
+			});
 		}
-		for (const parent of entrypoint.parentsIterable) {
-			if (parent instanceof Entrypoint) queue.add(parent);
+		if (dep.shorthand) {
+			source.insert(dep.range[1], `: ${exportExpr}`);
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, exportExpr);
 		}
 	}
-	return chunks;
 };
-exports.getAllChunks = getAllChunks;
+
+module.exports = HarmonyImportSpecifierDependency;
 
 
 /***/ }),
 
-/***/ 84508:
+/***/ 39029:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89212,302 +86950,222 @@ exports.getAllChunks = getAllChunks;
 
 
 
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const {
-	getChunkFilenameTemplate,
-	getCompilationHooks
-} = __webpack_require__(89464);
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = __webpack_require__(98124);
+const HarmonyAcceptDependency = __webpack_require__(23624);
+const HarmonyAcceptImportDependency = __webpack_require__(99843);
+const HarmonyCompatibilityDependency = __webpack_require__(72906);
+const HarmonyExportExpressionDependency = __webpack_require__(51340);
+const HarmonyExportHeaderDependency = __webpack_require__(38873);
+const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
+const HarmonyExportSpecifierDependency = __webpack_require__(48567);
+const HarmonyImportSideEffectDependency = __webpack_require__(73132);
+const HarmonyImportSpecifierDependency = __webpack_require__(14077);
+
+const HarmonyDetectionParserPlugin = __webpack_require__(17223);
+const HarmonyExportDependencyParserPlugin = __webpack_require__(93466);
+const HarmonyImportDependencyParserPlugin = __webpack_require__(20862);
+const HarmonyTopLevelThisParserPlugin = __webpack_require__(63232);
 
 /** @typedef {import("../Compiler")} Compiler */
 
-class CommonJsChunkFormatPlugin {
+class HarmonyModulesPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"CommonJsChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"CommonJsChunkLoadingPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.require);
-							set.add(RuntimeGlobals.startupEntrypoint);
-							set.add(RuntimeGlobals.externalInstallChunk);
-						}
-					}
+		compiler.hooks.compilation.tap(
+			"HarmonyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					HarmonyCompatibilityDependency,
+					new HarmonyCompatibilityDependency.Template()
 				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"CommonJsChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const source = new ConcatSource();
-						source.add(`exports.id = ${JSON.stringify(chunk.id)};\n`);
-						source.add(`exports.ids = ${JSON.stringify(chunk.ids)};\n`);
-						source.add(`exports.modules = `);
-						source.add(modules);
-						source.add(";\n");
-						const runtimeModules =
-							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-						if (runtimeModules.length > 0) {
-							source.add("exports.runtime =\n");
-							source.add(
-								Template.renderChunkRuntimeModules(
-									runtimeModules,
-									renderContext
-								)
-							);
-						}
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						if (entries.length > 0) {
-							const runtimeChunk = entries[0][1].getRuntimeChunk();
-							const currentOutputName = compilation
-								.getPath(
-									getChunkFilenameTemplate(chunk, compilation.outputOptions),
-									{
-										chunk,
-										contentHashType: "javascript"
-									}
-								)
-								.split("/");
-							const runtimeOutputName = compilation
-								.getPath(
-									getChunkFilenameTemplate(
-										runtimeChunk,
-										compilation.outputOptions
-									),
-									{
-										chunk: runtimeChunk,
-										contentHashType: "javascript"
-									}
-								)
-								.split("/");
 
-							// remove filename, we only need the directory
-							currentOutputName.pop();
+				compilation.dependencyFactories.set(
+					HarmonyImportSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportSideEffectDependency,
+					new HarmonyImportSideEffectDependency.Template()
+				);
 
-							// remove common parts
-							while (
-								currentOutputName.length > 0 &&
-								runtimeOutputName.length > 0 &&
-								currentOutputName[0] === runtimeOutputName[0]
-							) {
-								currentOutputName.shift();
-								runtimeOutputName.shift();
-							}
+				compilation.dependencyFactories.set(
+					HarmonyImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportSpecifierDependency,
+					new HarmonyImportSpecifierDependency.Template()
+				);
 
-							// create final path
-							const runtimePath =
-								(currentOutputName.length > 0
-									? "../".repeat(currentOutputName.length)
-									: "./") + runtimeOutputName.join("/");
+				compilation.dependencyTemplates.set(
+					HarmonyExportHeaderDependency,
+					new HarmonyExportHeaderDependency.Template()
+				);
 
-							const entrySource = new ConcatSource();
-							entrySource.add(
-								`(${
-									runtimeTemplate.supportsArrowFunction()
-										? "() => "
-										: "function() "
-								}{\n`
-							);
-							entrySource.add("var exports = {};\n");
-							entrySource.add(source);
-							entrySource.add(";\n\n// load runtime\n");
-							entrySource.add(
-								`var __webpack_require__ = require(${JSON.stringify(
-									runtimePath
-								)});\n`
-							);
-							entrySource.add(
-								`${RuntimeGlobals.externalInstallChunk}(exports);\n`
-							);
-							const startupSource = new RawSource(
-								generateEntryStartup(
-									chunkGraph,
-									runtimeTemplate,
-									entries,
-									chunk,
-									false
-								)
-							);
-							entrySource.add(
-								hooks.renderStartup.call(
-									startupSource,
-									entries[entries.length - 1][0],
-									{
-										...renderContext,
-										inlined: false
-									}
-								)
-							);
-							entrySource.add("\n})()");
-							return entrySource;
-						}
-						return source;
-					}
+				compilation.dependencyTemplates.set(
+					HarmonyExportExpressionDependency,
+					new HarmonyExportExpressionDependency.Template()
 				);
-				hooks.chunkHash.tap(
-					"CommonJsChunkFormatPlugin",
-					(chunk, hash, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update("CommonJsChunkFormatPlugin");
-						hash.update("1");
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-					}
+
+				compilation.dependencyTemplates.set(
+					HarmonyExportSpecifierDependency,
+					new HarmonyExportSpecifierDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyExportImportedSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyExportImportedSpecifierDependency,
+					new HarmonyExportImportedSpecifierDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					HarmonyAcceptDependency,
+					new HarmonyAcceptDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					HarmonyAcceptImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyAcceptImportDependency,
+					new HarmonyAcceptImportDependency.Template()
 				);
+
+				const handler = (parser, parserOptions) => {
+					// TODO webpack 6: rename harmony to esm or module
+					if (parserOptions.harmony !== undefined && !parserOptions.harmony)
+						return;
+
+					new HarmonyDetectionParserPlugin(this.options).apply(parser);
+					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyTopLevelThisParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("HarmonyModulesPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("HarmonyModulesPlugin", handler);
 			}
 		);
 	}
 }
-
-module.exports = CommonJsChunkFormatPlugin;
+module.exports = HarmonyModulesPlugin;
 
 
 /***/ }),
 
-/***/ 61291:
+/***/ 63232:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-/** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
-/** @typedef {import("../Compiler")} Compiler */
-
-/** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
-const enabledTypes = new WeakMap();
+const ConstDependency = __webpack_require__(76911);
+const HarmonyExports = __webpack_require__(39211);
 
-const getEnabledTypes = compiler => {
-	let set = enabledTypes.get(compiler);
-	if (set === undefined) {
-		set = new Set();
-		enabledTypes.set(compiler, set);
+class HarmonyTopLevelThisParserPlugin {
+	apply(parser) {
+		parser.hooks.expression
+			.for("this")
+			.tap("HarmonyTopLevelThisParserPlugin", node => {
+				if (!parser.scope.topLevelScope) return;
+				if (HarmonyExports.isEnabled(parser.state)) {
+					const dep = new ConstDependency("undefined", node.range, null);
+					dep.loc = node.loc;
+					parser.state.module.addPresentationalDependency(dep);
+					return this;
+				}
+			});
 	}
-	return set;
-};
+}
 
-class EnableChunkLoadingPlugin {
-	/**
-	 * @param {ChunkLoadingType} type library type that should be available
-	 */
-	constructor(type) {
-		this.type = type;
-	}
+module.exports = HarmonyTopLevelThisParserPlugin;
 
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {ChunkLoadingType} type type of library
-	 * @returns {void}
-	 */
-	static setEnabled(compiler, type) {
-		getEnabledTypes(compiler).add(type);
-	}
 
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {ChunkLoadingType} type type of library
-	 * @returns {void}
-	 */
-	static checkEnabled(compiler, type) {
-		if (!getEnabledTypes(compiler).has(type)) {
-			throw new Error(
-				`Chunk loading type "${type}" is not enabled. ` +
-					"EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. " +
-					'This usually happens through the "output.enabledChunkLoadingTypes" option. ' +
-					'If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". ' +
-					"These types are enabled: " +
-					Array.from(getEnabledTypes(compiler)).join(", ")
-			);
-		}
-	}
+/***/ }),
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { type } = this;
+/***/ 1902:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// Only enable once
-		const enabled = getEnabledTypes(compiler);
-		if (enabled.has(type)) return;
-		enabled.add(type);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (typeof type === "string") {
-			switch (type) {
-				case "jsonp": {
-					const JsonpChunkLoadingPlugin = __webpack_require__(83121);
-					new JsonpChunkLoadingPlugin().apply(compiler);
-					break;
-				}
-				case "import-scripts": {
-					const ImportScriptsChunkLoadingPlugin = __webpack_require__(54182);
-					new ImportScriptsChunkLoadingPlugin().apply(compiler);
-					break;
-				}
-				case "require": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
-					new CommonJsChunkLoadingPlugin({
-						asyncChunkLoading: false
-					}).apply(compiler);
-					break;
-				}
-				case "async-node": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
-					new CommonJsChunkLoadingPlugin({
-						asyncChunkLoading: true
-					}).apply(compiler);
-					break;
-				}
-				case "import": {
-					const ModuleChunkLoadingPlugin = __webpack_require__(89831);
-					new ModuleChunkLoadingPlugin().apply(compiler);
-					break;
-				}
-				case "universal":
-					// TODO implement universal chunk loading
-					throw new Error("Universal Chunk Loading is not implemented yet");
-				default:
-					throw new Error(`Unsupported chunk loading type ${type}.
-Plugins which provide custom chunk loading types must call EnableChunkLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
-			}
-		} else {
-			// TODO support plugin instances here
-			// apply them to the compiler
-		}
+
+
+const makeSerializable = __webpack_require__(33032);
+const ContextDependency = __webpack_require__(88101);
+const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
+
+class ImportContextDependency extends ContextDependency {
+	constructor(options, range, valueRange) {
+		super(options);
+
+		this.range = range;
+		this.valueRange = valueRange;
+	}
+
+	get type() {
+		return `import() context ${this.options.mode}`;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+		write(this.valueRange);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+		this.valueRange = read();
+
+		super.deserialize(context);
 	}
 }
 
-module.exports = EnableChunkLoadingPlugin;
+makeSerializable(
+	ImportContextDependency,
+	"webpack/lib/dependencies/ImportContextDependency"
+);
+
+ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = ImportContextDependency;
 
 
 /***/ }),
 
-/***/ 77106:
+/***/ 89376:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89518,229 +87176,105 @@ module.exports = EnableChunkLoadingPlugin;
 
 
 
-const util = __webpack_require__(73837);
-const { RawSource, ReplaceSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const HarmonyCompatibilityDependency = __webpack_require__(72906);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-// TODO: clean up this file
-// replace with newer constructs
-
-const deprecatedGetInitFragments = util.deprecate(
-	(template, dependency, templateContext) =>
-		template.getInitFragments(dependency, templateContext),
-	"DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)",
-	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
-);
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-const TYPES = new Set(["javascript"]);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class JavascriptGenerator extends Generator {
+class ImportDependency extends ModuleDependency {
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {string} request the request
+	 * @param {[number, number]} range expression range
+	 * @param {string[][]=} referencedExports list of referenced exports
 	 */
-	getTypes(module) {
-		return TYPES;
+	constructor(request, range, referencedExports) {
+		super(request);
+		this.range = range;
+		this.referencedExports = referencedExports;
 	}
 
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 39;
-		}
-		return originalSource.size();
+	get type() {
+		return "import()";
 	}
 
-	/**
-	 * @param {NormalModule} module module for which the bailout reason should be determined
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(module, context) {
-		// Only harmony modules are valid for optimization
-		if (
-			!module.buildMeta ||
-			module.buildMeta.exportsType !== "namespace" ||
-			module.presentationalDependencies === undefined ||
-			!module.presentationalDependencies.some(
-				d => d instanceof HarmonyCompatibilityDependency
-			)
-		) {
-			return "Module is not an ECMAScript module";
-		}
-
-		// 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.buildInfo && module.buildInfo.moduleConcatenationBailout) {
-			return `Module uses ${module.buildInfo.moduleConcatenationBailout}`;
-		}
+	get category() {
+		return "esm";
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	generate(module, generateContext) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return new RawSource("throw new Error('No source available');");
-		}
-
-		const source = new ReplaceSource(originalSource);
-		const initFragments = [];
-
-		this.sourceModule(module, initFragments, source, generateContext);
-
-		return InitFragment.addToSource(source, initFragments, generateContext);
+	getReferencedExports(moduleGraph, runtime) {
+		return this.referencedExports
+			? this.referencedExports.map(e => ({
+					name: e,
+					canMangle: false
+			  }))
+			: Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
-	/**
-	 * @param {Module} module the module to generate
-	 * @param {InitFragment[]} initFragments mutable list of init fragments
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {GenerateContext} generateContext the generateContext
-	 * @returns {void}
-	 */
-	sourceModule(module, initFragments, source, generateContext) {
-		for (const dependency of module.dependencies) {
-			this.sourceDependency(
-				module,
-				dependency,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
-
-		if (module.presentationalDependencies !== undefined) {
-			for (const dependency of module.presentationalDependencies) {
-				this.sourceDependency(
-					module,
-					dependency,
-					initFragments,
-					source,
-					generateContext
-				);
-			}
-		}
-
-		for (const childBlock of module.blocks) {
-			this.sourceBlock(
-				module,
-				childBlock,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
+	serialize(context) {
+		context.write(this.range);
+		context.write(this.referencedExports);
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {Module} module the module to generate
-	 * @param {DependenciesBlock} block the dependencies block which will be processed
-	 * @param {InitFragment[]} initFragments mutable list of init fragments
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {GenerateContext} generateContext the generateContext
-	 * @returns {void}
-	 */
-	sourceBlock(module, block, initFragments, source, generateContext) {
-		for (const dependency of block.dependencies) {
-			this.sourceDependency(
-				module,
-				dependency,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
-
-		for (const childBlock of block.blocks) {
-			this.sourceBlock(
-				module,
-				childBlock,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
+	deserialize(context) {
+		this.range = context.read();
+		this.referencedExports = context.read();
+		super.deserialize(context);
 	}
+}
+
+makeSerializable(ImportDependency, "webpack/lib/dependencies/ImportDependency");
 
+ImportDependency.Template = class ImportDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @param {Module} module the current module
-	 * @param {Dependency} dependency the dependency to generate
-	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {GenerateContext} generateContext the render context
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	sourceDependency(module, dependency, initFragments, source, generateContext) {
-		const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-			dependency.constructor
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
 		);
-		const template = generateContext.dependencyTemplates.get(constructor);
-		if (!template) {
-			throw new Error(
-				"No template for dependency: " + dependency.constructor.name
-			);
-		}
-
-		const templateContext = {
-			runtimeTemplate: generateContext.runtimeTemplate,
-			dependencyTemplates: generateContext.dependencyTemplates,
-			moduleGraph: generateContext.moduleGraph,
-			chunkGraph: generateContext.chunkGraph,
-			module,
-			runtime: generateContext.runtime,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			concatenationScope: generateContext.concatenationScope,
-			codeGenerationResults: generateContext.codeGenerationResults,
-			initFragments
-		};
-
-		template.apply(dependency, source, templateContext);
-
-		// TODO remove in webpack 6
-		if ("getInitFragments" in template) {
-			const fragments = deprecatedGetInitFragments(
-				template,
-				dependency,
-				templateContext
-			);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			block: block,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			strict: module.buildMeta.strictHarmonyModule,
+			message: "import()",
+			runtimeRequirements
+		});
 
-			if (fragments) {
-				for (const fragment of fragments) {
-					initFragments.push(fragment);
-				}
-			}
-		}
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
-}
+};
 
-module.exports = JavascriptGenerator;
+module.exports = ImportDependency;
 
 
 /***/ }),
 
-/***/ 89464:
+/***/ 50718:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89751,1349 +87285,646 @@ module.exports = JavascriptGenerator;
 
 
 
-const { SyncWaterfallHook, SyncHook, SyncBailHook } = __webpack_require__(6967);
-const vm = __webpack_require__(26144);
-const {
-	ConcatSource,
-	OriginalSource,
-	PrefixSource,
-	RawSource,
-	CachedSource
-} = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const { tryRunOrWebpackError } = __webpack_require__(11351);
-const HotUpdateChunk = __webpack_require__(9597);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const { last, someInIterable } = __webpack_require__(39104);
-const StringXor = __webpack_require__(40293);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const { intersectRuntime } = __webpack_require__(17156);
-const JavascriptGenerator = __webpack_require__(77106);
-const JavascriptParser = __webpack_require__(29050);
+const makeSerializable = __webpack_require__(33032);
+const ImportDependency = __webpack_require__(89376);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
-
-/**
- * @param {Chunk} chunk a chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @returns {boolean} true, when a JS file is needed for this chunk
- */
-const chunkHasJs = (chunk, chunkGraph) => {
-	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
-
-	return chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
-		? true
-		: false;
-};
-
-const printGeneratedCodeForStack = (module, code) => {
-	const lines = code.split("\n");
-	const n = `${lines.length}`.length;
-	return `\n\nGenerated code for ${module.identifier()}\n${lines
-		.map((line, i, lines) => {
-			const iStr = `${i + 1}`;
-			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
-		})
-		.join("\n")}`;
-};
-
-/**
- * @typedef {Object} RenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {boolean} strictMode rendering in strict context
- */
-
-/**
- * @typedef {Object} MainRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {string} hash hash to be used for render call
- * @property {boolean} strictMode rendering in strict context
- */
-
-/**
- * @typedef {Object} ChunkRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
- * @property {boolean} strictMode rendering in strict context
- */
 
-/**
- * @typedef {Object} RenderBootstrapContext
- * @property {Chunk} chunk the chunk
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {string} hash hash to be used for render call
- */
+class ImportEagerDependency extends ImportDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {[number, number]} range expression range
+	 * @param {string[][]=} referencedExports list of referenced exports
+	 */
+	constructor(request, range, referencedExports) {
+		super(request, range, referencedExports);
+	}
 
-/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
+	get type() {
+		return "import() eager";
+	}
 
-/**
- * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
- * @property {SyncWaterfallHook<[Source, RenderContext]>} render
- * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
- * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
- * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
- * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
- * @property {SyncBailHook<[RenderContext], string>} strictRuntimeBailout
- * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
- */
+	get category() {
+		return "esm";
+	}
+}
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+makeSerializable(
+	ImportEagerDependency,
+	"webpack/lib/dependencies/ImportEagerDependency"
+);
 
-class JavascriptModulesPlugin {
+ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
+	ImportDependency.Template
+) {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				]),
-				renderModuleContainer: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				]),
-				renderModulePackage: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				]),
-				render: new SyncWaterfallHook(["source", "renderContext"]),
-				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
-				renderStartup: new SyncWaterfallHook([
-					"source",
-					"module",
-					"startupRenderContext"
-				]),
-				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
-				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
-				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
-				inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-				embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-				strictRuntimeBailout: new SyncBailHook(["renderContext"]),
-				chunkHash: new SyncHook(["chunk", "hash", "context"]),
-				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportEagerDependency} */ (dependency);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			strict: module.buildMeta.strictHarmonyModule,
+			message: "import() eager",
+			runtimeRequirements
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
+};
 
-	constructor(options = {}) {
-		this.options = options;
-		/** @type {WeakMap<Source, TODO>} */
-		this._moduleFactoryCache = new WeakMap();
-	}
+module.exports = ImportEagerDependency;
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"JavascriptModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				normalModuleFactory.hooks.createParser
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("auto");
-					});
-				normalModuleFactory.hooks.createParser
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("script");
-					});
-				normalModuleFactory.hooks.createParser
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("module");
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				compilation.hooks.renderManifest.tap(
-					"JavascriptModulesPlugin",
-					(result, options) => {
-						const {
-							hash,
-							chunk,
-							chunkGraph,
-							moduleGraph,
-							runtimeTemplate,
-							dependencyTemplates,
-							outputOptions,
-							codeGenerationResults
-						} = options;
 
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
+/***/ }),
 
-						let render;
-						const filenameTemplate =
-							JavascriptModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								outputOptions
-							);
-						if (hotUpdateChunk) {
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						} else if (chunk.hasRuntime()) {
-							render = () =>
-								this.renderMain(
-									{
-										hash,
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks,
-									compilation
-								);
-						} else {
-							if (!chunkHasJs(chunk, chunkGraph)) {
-								return result;
-							}
+/***/ 51274:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-						result.push({
-							render,
-							filenameTemplate,
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "javascript"
-							},
-							info: {
-								javascriptModule: compilation.runtimeTemplate.isModule()
-							},
-							identifier: hotUpdateChunk
-								? `hotupdatechunk${chunk.id}`
-								: `chunk${chunk.id}`,
-							hash: chunk.contentHash.javascript
-						});
 
-						return result;
-					}
-				);
-				compilation.hooks.chunkHash.tap(
-					"JavascriptModulesPlugin",
-					(chunk, hash, context) => {
-						hooks.chunkHash.call(chunk, hash, context);
-						if (chunk.hasRuntime()) {
-							this.updateHashWithBootstrap(
-								hash,
-								{
-									hash: "0000",
-									chunk,
-									chunkGraph: context.chunkGraph,
-									moduleGraph: context.moduleGraph,
-									runtimeTemplate: context.runtimeTemplate
-								},
-								hooks
-							);
-						}
-					}
-				);
-				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
-					const {
-						chunkGraph,
-						moduleGraph,
-						runtimeTemplate,
-						outputOptions: {
-							hashSalt,
-							hashDigest,
-							hashDigestLength,
-							hashFunction
-						}
-					} = compilation;
-					const hash = createHash(hashFunction);
-					if (hashSalt) hash.update(hashSalt);
-					if (chunk.hasRuntime()) {
-						this.updateHashWithBootstrap(
-							hash,
-							{
-								hash: "0000",
-								chunk,
-								chunkGraph: compilation.chunkGraph,
-								moduleGraph: compilation.moduleGraph,
-								runtimeTemplate: compilation.runtimeTemplate
-							},
-							hooks
-						);
-					} else {
-						hash.update(`${chunk.id} `);
-						hash.update(chunk.ids ? chunk.ids.join(",") : "");
-					}
-					hooks.chunkHash.call(chunk, hash, {
-						chunkGraph,
-						moduleGraph,
-						runtimeTemplate
-					});
-					const modules = chunkGraph.getChunkModulesIterableBySourceType(
-						chunk,
-						"javascript"
-					);
-					if (modules) {
-						const xor = new StringXor();
-						for (const m of modules) {
-							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
-						}
-						xor.updateHash(hash);
-					}
-					const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(
-						chunk,
-						"runtime"
-					);
-					if (runtimeModules) {
-						const xor = new StringXor();
-						for (const m of runtimeModules) {
-							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
-						}
-						xor.updateHash(hash);
-					}
-					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
-				});
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"JavascriptModulesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (
-							!set.has(RuntimeGlobals.startupNoDefault) &&
-							chunkGraph.hasChunkEntryDependentChunks(chunk)
-						) {
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.require);
-						}
-					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source =
-							options.codeGenerationResult.sources.get("javascript");
-						if (source === undefined) return;
-						const { module, moduleObject } = options;
-						const code = source.source();
 
-						const fn = vm.runInThisContext(
-							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(
-								moduleObject.exports,
-								moduleObject,
-								moduleObject.exports,
-								context.__webpack_require__
-							);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
-						}
-					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source = options.codeGenerationResult.sources.get("runtime");
-						if (source === undefined) return;
-						let code = source.source();
-						if (typeof code !== "string") code = code.toString();
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-						const fn = vm.runInThisContext(
-							`(function(__webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: options.module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(null, context.__webpack_require__);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
-						}
-					}
-				);
-			}
-		);
+class ImportMetaHotAcceptDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
 	}
 
-	static getChunkFilenameTemplate(chunk, outputOptions) {
-		if (chunk.filenameTemplate) {
-			return chunk.filenameTemplate;
-		} else if (chunk instanceof HotUpdateChunk) {
-			return outputOptions.hotUpdateChunkFilename;
-		} else if (chunk.canBeInitial()) {
-			return outputOptions.filename;
-		} else {
-			return outputOptions.chunkFilename;
-		}
+	get type() {
+		return "import.meta.webpackHot.accept";
 	}
 
-	/**
-	 * @param {Module} module the rendered module
-	 * @param {ChunkRenderContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @param {boolean} factory true: renders as factory method, false: pure module content
-	 * @returns {Source} the newly generated source from rendering
-	 */
-	renderModule(module, renderContext, hooks, factory) {
-		const {
-			chunk,
-			chunkGraph,
-			runtimeTemplate,
-			codeGenerationResults,
-			strictMode
-		} = renderContext;
-		try {
-			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
-			const moduleSource = codeGenResult.sources.get("javascript");
-			if (!moduleSource) return null;
-			if (codeGenResult.data !== undefined) {
-				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
-				if (chunkInitFragments) {
-					for (const i of chunkInitFragments)
-						renderContext.chunkInitFragments.push(i);
-				}
-			}
-			const moduleSourcePostContent = tryRunOrWebpackError(
-				() =>
-					hooks.renderModuleContent.call(moduleSource, module, renderContext),
-				"JavascriptModulesPlugin.getCompilationHooks().renderModuleContent"
-			);
-			let moduleSourcePostContainer;
-			if (factory) {
-				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-					module,
-					chunk.runtime
-				);
-				const needModule = runtimeRequirements.has(RuntimeGlobals.module);
-				const needExports = runtimeRequirements.has(RuntimeGlobals.exports);
-				const needRequire =
-					runtimeRequirements.has(RuntimeGlobals.require) ||
-					runtimeRequirements.has(RuntimeGlobals.requireScope);
-				const needThisAsExports = runtimeRequirements.has(
-					RuntimeGlobals.thisAsExports
-				);
-				const needStrict = module.buildInfo.strict && !strictMode;
-				const cacheEntry = this._moduleFactoryCache.get(
-					moduleSourcePostContent
-				);
-				let source;
-				if (
-					cacheEntry &&
-					cacheEntry.needModule === needModule &&
-					cacheEntry.needExports === needExports &&
-					cacheEntry.needRequire === needRequire &&
-					cacheEntry.needThisAsExports === needThisAsExports &&
-					cacheEntry.needStrict === needStrict
-				) {
-					source = cacheEntry.source;
-				} else {
-					const factorySource = new ConcatSource();
-					const args = [];
-					if (needExports || needRequire || needModule)
-						args.push(
-							needModule
-								? module.moduleArgument
-								: "__unused_webpack_" + module.moduleArgument
-						);
-					if (needExports || needRequire)
-						args.push(
-							needExports
-								? module.exportsArgument
-								: "__unused_webpack_" + module.exportsArgument
-						);
-					if (needRequire) args.push("__webpack_require__");
-					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
-						factorySource.add("/***/ ((" + args.join(", ") + ") => {\n\n");
-					} else {
-						factorySource.add("/***/ (function(" + args.join(", ") + ") {\n\n");
-					}
-					if (needStrict) {
-						factorySource.add('"use strict";\n');
-					}
-					factorySource.add(moduleSourcePostContent);
-					factorySource.add("\n\n/***/ })");
-					source = new CachedSource(factorySource);
-					this._moduleFactoryCache.set(moduleSourcePostContent, {
-						source,
-						needModule,
-						needExports,
-						needRequire,
-						needThisAsExports,
-						needStrict
-					});
-				}
-				moduleSourcePostContainer = tryRunOrWebpackError(
-					() => hooks.renderModuleContainer.call(source, module, renderContext),
-					"JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer"
-				);
-			} else {
-				moduleSourcePostContainer = moduleSourcePostContent;
-			}
-			return tryRunOrWebpackError(
-				() =>
-					hooks.renderModulePackage.call(
-						moduleSourcePostContainer,
-						module,
-						renderContext
-					),
-				"JavascriptModulesPlugin.getCompilationHooks().renderModulePackage"
-			);
-		} catch (e) {
-			e.module = module;
-			throw e;
-		}
+	get category() {
+		return "esm";
 	}
+}
 
-	/**
-	 * @param {RenderContext} renderContext the render context
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {Source} the rendered source
-	 */
-	renderChunk(renderContext, hooks) {
-		const { chunk, chunkGraph } = renderContext;
-		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
-			chunk,
-			"javascript",
-			compareModulesByIdentifier
-		);
-		const allModules = modules ? Array.from(modules) : [];
-		let strictHeader;
-		let allStrict = renderContext.strictMode;
-		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
-			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
-			strictHeader = strictBailout
-				? `// runtime can't be in strict mode because ${strictBailout}.\n`
-				: '"use strict";\n';
-			if (!strictBailout) allStrict = true;
-		}
-		/** @type {ChunkRenderContext} */
-		const chunkRenderContext = {
-			...renderContext,
-			chunkInitFragments: [],
-			strictMode: allStrict
-		};
-		const moduleSources =
-			Template.renderChunkModules(chunkRenderContext, allModules, module =>
-				this.renderModule(module, chunkRenderContext, hooks, true)
-			) || new RawSource("{}");
-		let source = tryRunOrWebpackError(
-			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderChunk"
-		);
-		source = tryRunOrWebpackError(
-			() => hooks.renderContent.call(source, chunkRenderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
-		);
-		if (!source) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
-			);
-		}
-		source = InitFragment.addToSource(
-			source,
-			chunkRenderContext.chunkInitFragments,
-			chunkRenderContext
-		);
-		source = tryRunOrWebpackError(
-			() => hooks.render.call(source, chunkRenderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().render"
-		);
-		if (!source) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
-			);
-		}
-		chunk.rendered = true;
-		return strictHeader
-			? new ConcatSource(strictHeader, source, ";")
-			: renderContext.runtimeTemplate.isModule()
-			? source
-			: new ConcatSource(source, ";");
+makeSerializable(
+	ImportMetaHotAcceptDependency,
+	"webpack/lib/dependencies/ImportMetaHotAcceptDependency"
+);
+
+ImportMetaHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ImportMetaHotAcceptDependency;
+
+
+/***/ }),
+
+/***/ 53141:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+
+class ImportMetaHotDeclineDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+		this.weak = true;
 	}
 
-	/**
-	 * @param {MainRenderContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @param {Compilation} compilation the compilation
-	 * @returns {Source} the newly generated source from rendering
-	 */
-	renderMain(renderContext, hooks, compilation) {
-		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+	get type() {
+		return "import.meta.webpackHot.decline";
+	}
 
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
-		const iife = runtimeTemplate.isIIFE();
+	get category() {
+		return "esm";
+	}
+}
 
-		const bootstrap = this.renderBootstrap(renderContext, hooks);
-		const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
+makeSerializable(
+	ImportMetaHotDeclineDependency,
+	"webpack/lib/dependencies/ImportMetaHotDeclineDependency"
+);
 
-		const allModules = Array.from(
-			chunkGraph.getOrderedChunkModulesIterableBySourceType(
-				chunk,
-				"javascript",
-				compareModulesByIdentifier
-			) || []
-		);
+ImportMetaHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
 
-		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
-		let inlinedModules;
-		if (bootstrap.allowInlineStartup && hasEntryModules) {
-			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
-		}
+module.exports = ImportMetaHotDeclineDependency;
 
-		let source = new ConcatSource();
-		let prefix;
-		if (iife) {
-			if (runtimeTemplate.supportsArrowFunction()) {
-				source.add("/******/ (() => { // webpackBootstrap\n");
-			} else {
-				source.add("/******/ (function() { // webpackBootstrap\n");
-			}
-			prefix = "/******/ \t";
-		} else {
-			prefix = "/******/ ";
-		}
-		let allStrict = renderContext.strictMode;
-		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
-			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
-			if (strictBailout) {
-				source.add(
-					prefix +
-						`// runtime can't be in strict mode because ${strictBailout}.\n`
-				);
-			} else {
-				allStrict = true;
-				source.add(prefix + '"use strict";\n');
-			}
-		}
 
-		/** @type {ChunkRenderContext} */
-		const chunkRenderContext = {
-			...renderContext,
-			chunkInitFragments: [],
-			strictMode: allStrict
-		};
+/***/ }),
 
-		const chunkModules = Template.renderChunkModules(
-			chunkRenderContext,
-			inlinedModules
-				? allModules.filter(m => !inlinedModules.has(m))
-				: allModules,
-			module => this.renderModule(module, chunkRenderContext, hooks, true),
-			prefix
-		);
-		if (
-			chunkModules ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
-			runtimeRequirements.has(RuntimeGlobals.require)
-		) {
-			source.add(prefix + "var __webpack_modules__ = (");
-			source.add(chunkModules || "{}");
-			source.add(");\n");
-			source.add(
-				"/************************************************************************/\n"
-			);
-		}
+/***/ 17228:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (bootstrap.header.length > 0) {
-			const header = Template.asString(bootstrap.header) + "\n";
-			source.add(
-				new PrefixSource(
-					prefix,
-					useSourceMap
-						? new OriginalSource(header, "webpack/bootstrap")
-						: new RawSource(header)
-				)
-			);
-			source.add(
-				"/************************************************************************/\n"
-			);
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-		const runtimeModules =
-			renderContext.chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 
-		if (runtimeModules.length > 0) {
-			source.add(
-				new PrefixSource(
-					prefix,
-					Template.renderRuntimeModules(runtimeModules, chunkRenderContext)
-				)
-			);
-			source.add(
-				"/************************************************************************/\n"
-			);
-			// runtimeRuntimeModules calls codeGeneration
-			for (const module of runtimeModules) {
-				compilation.codeGeneratedModules.add(module);
-			}
-		}
-		if (inlinedModules) {
-			if (bootstrap.beforeStartup.length > 0) {
-				const beforeStartup = Template.asString(bootstrap.beforeStartup) + "\n";
-				source.add(
-					new PrefixSource(
-						prefix,
-						useSourceMap
-							? new OriginalSource(beforeStartup, "webpack/before-startup")
-							: new RawSource(beforeStartup)
-					)
-				);
-			}
-			const lastInlinedModule = last(inlinedModules);
-			const startupSource = new ConcatSource();
-			startupSource.add(`var __webpack_exports__ = {};\n`);
-			for (const m of inlinedModules) {
-				const renderedModule = this.renderModule(
-					m,
-					chunkRenderContext,
-					hooks,
-					false
-				);
-				if (renderedModule) {
-					const innerStrict = !allStrict && m.buildInfo.strict;
-					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-						m,
-						chunk.runtime
+
+const { pathToFileURL } = __webpack_require__(57310);
+const ModuleDependencyWarning = __webpack_require__(29656);
+const Template = __webpack_require__(39722);
+const BasicEvaluatedExpression = __webpack_require__(950);
+const {
+	evaluateToIdentifier,
+	toConstantDependency,
+	evaluateToString,
+	evaluateToNumber
+} = __webpack_require__(93998);
+const memoize = __webpack_require__(78676);
+const propertyAccess = __webpack_require__(54190);
+const ConstDependency = __webpack_require__(76911);
+
+/** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const getCriticalDependencyWarning = memoize(() =>
+	__webpack_require__(15427)
+);
+
+class ImportMetaPlugin {
+	/**
+	 * @param {Compiler} compiler compiler
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ImportMetaPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {NormalModule} module module
+				 * @returns {string} file url
+				 */
+				const getUrl = module => {
+					return pathToFileURL(module.resource).toString();
+				};
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const parserHandler = (parser, { importMeta }) => {
+					if (importMeta === false) {
+						const { importMetaName } = compilation.outputOptions;
+						if (importMetaName === "import.meta") return;
+
+						parser.hooks.expression
+							.for("import.meta")
+							.tap("ImportMetaPlugin", metaProperty => {
+								const dep = new ConstDependency(
+									importMetaName,
+									metaProperty.range
+								);
+								dep.loc = metaProperty.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+						return;
+					}
+
+					/// import.meta direct ///
+					parser.hooks.typeof
+						.for("import.meta")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.expression
+						.for("import.meta")
+						.tap("ImportMetaPlugin", metaProperty => {
+							const CriticalDependencyWarning = getCriticalDependencyWarning();
+							parser.state.module.addWarning(
+								new ModuleDependencyWarning(
+									parser.state.module,
+									new CriticalDependencyWarning(
+										"Accessing import.meta directly is unsupported (only property access is supported)"
+									),
+									metaProperty.loc
+								)
+							);
+							const dep = new ConstDependency(
+								`${parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""}({})`,
+								metaProperty.range
+							);
+							dep.loc = metaProperty.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta")
+						.tap("ImportMetaPlugin", evaluateToString("object"));
+					parser.hooks.evaluateIdentifier.for("import.meta").tap(
+						"ImportMetaPlugin",
+						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
 					);
-					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
-					const webpackExports =
-						exports && m.exportsArgument === "__webpack_exports__";
-					let iife = innerStrict
-						? "it need to be in strict mode."
-						: inlinedModules.size > 1
-						? // TODO check globals and top-level declarations of other entries and chunk modules
-						  // to make a better decision
-						  "it need to be isolated against other entry modules."
-						: chunkModules
-						? "it need to be isolated against other modules in the chunk."
-						: exports && !webpackExports
-						? `it uses a non-standard name for the exports (${m.exportsArgument}).`
-						: hooks.embedInRuntimeBailout.call(m, renderContext);
-					let footer;
-					if (iife !== undefined) {
-						startupSource.add(
-							`// This entry need to be wrapped in an IIFE because ${iife}\n`
+
+					/// import.meta.url ///
+					parser.hooks.typeof
+						.for("import.meta.url")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify("string"))
 						);
-						const arrow = runtimeTemplate.supportsArrowFunction();
-						if (arrow) {
-							startupSource.add("(() => {\n");
-							footer = "\n})();\n\n";
-						} else {
-							startupSource.add("!function() {\n");
-							footer = "\n}();\n";
-						}
-						if (innerStrict) startupSource.add('"use strict";\n');
-					} else {
-						footer = "\n";
-					}
-					if (exports) {
-						if (m !== lastInlinedModule)
-							startupSource.add(`var ${m.exportsArgument} = {};\n`);
-						else if (m.exportsArgument !== "__webpack_exports__")
-							startupSource.add(
-								`var ${m.exportsArgument} = __webpack_exports__;\n`
+					parser.hooks.expression
+						.for("import.meta.url")
+						.tap("ImportMetaPlugin", expr => {
+							const dep = new ConstDependency(
+								JSON.stringify(getUrl(parser.state.module)),
+								expr.range
 							);
-					}
-					startupSource.add(renderedModule);
-					startupSource.add(footer);
-				}
-			}
-			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
-				startupSource.add(
-					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
-				);
-			}
-			source.add(
-				hooks.renderStartup.call(startupSource, lastInlinedModule, {
-					...renderContext,
-					inlined: true
-				})
-			);
-			if (bootstrap.afterStartup.length > 0) {
-				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
-				source.add(
-					new PrefixSource(
-						prefix,
-						useSourceMap
-							? new OriginalSource(afterStartup, "webpack/after-startup")
-							: new RawSource(afterStartup)
-					)
-				);
-			}
-		} else {
-			const lastEntryModule = last(
-				chunkGraph.getChunkEntryModulesIterable(chunk)
-			);
-			const toSource = useSourceMap
-				? (content, name) =>
-						new OriginalSource(Template.asString(content), name)
-				: content => new RawSource(Template.asString(content));
-			source.add(
-				new PrefixSource(
-					prefix,
-					new ConcatSource(
-						toSource(bootstrap.beforeStartup, "webpack/before-startup"),
-						"\n",
-						hooks.renderStartup.call(
-							toSource(bootstrap.startup.concat(""), "webpack/startup"),
-							lastEntryModule,
-							{
-								...renderContext,
-								inlined: false
-							}
-						),
-						toSource(bootstrap.afterStartup, "webpack/after-startup"),
-						"\n"
-					)
-				)
-			);
-		}
-		if (
-			hasEntryModules &&
-			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
-		) {
-			source.add(`${prefix}return __webpack_exports__;\n`);
-		}
-		if (iife) {
-			source.add("/******/ })()\n");
-		}
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta.url")
+						.tap("ImportMetaPlugin", evaluateToString("string"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.url")
+						.tap("ImportMetaPlugin", expr => {
+							return new BasicEvaluatedExpression()
+								.setString(getUrl(parser.state.module))
+								.setRange(expr.range);
+						});
 
-		/** @type {Source} */
-		let finalSource = tryRunOrWebpackError(
-			() => hooks.renderMain.call(source, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderMain"
-		);
-		if (!finalSource) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something"
-			);
-		}
-		finalSource = tryRunOrWebpackError(
-			() => hooks.renderContent.call(finalSource, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
-		);
-		if (!finalSource) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
-			);
-		}
-		finalSource = InitFragment.addToSource(
-			finalSource,
-			chunkRenderContext.chunkInitFragments,
-			chunkRenderContext
-		);
-		finalSource = tryRunOrWebpackError(
-			() => hooks.render.call(finalSource, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().render"
-		);
-		if (!finalSource) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
-			);
-		}
-		chunk.rendered = true;
-		return iife ? new ConcatSource(finalSource, ";") : finalSource;
-	}
+					/// import.meta.webpack ///
+					const webpackVersion = parseInt(
+						(__webpack_require__(32702)/* .version */ .i8),
+						10
+					);
+					parser.hooks.typeof
+						.for("import.meta.webpack")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify("number"))
+						);
+					parser.hooks.expression
+						.for("import.meta.webpack")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify(webpackVersion))
+						);
+					parser.hooks.evaluateTypeof
+						.for("import.meta.webpack")
+						.tap("ImportMetaPlugin", evaluateToString("number"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.webpack")
+						.tap("ImportMetaPlugin", evaluateToNumber(webpackVersion));
 
-	/**
-	 * @param {Hash} hash the hash to be updated
-	 * @param {RenderBootstrapContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 */
-	updateHashWithBootstrap(hash, renderContext, hooks) {
-		const bootstrap = this.renderBootstrap(renderContext, hooks);
-		for (const key of Object.keys(bootstrap)) {
-			hash.update(key);
-			if (Array.isArray(bootstrap[key])) {
-				for (const line of bootstrap[key]) {
-					hash.update(line);
-				}
-			} else {
-				hash.update(JSON.stringify(bootstrap[key]));
+					/// Unknown properties ///
+					parser.hooks.unhandledExpressionMemberChain
+						.for("import.meta")
+						.tap("ImportMetaPlugin", (expr, members) => {
+							const dep = new ConstDependency(
+								`${Template.toNormalComment(
+									"unsupported import.meta." + members.join(".")
+								)} undefined${propertyAccess(members, 1)}`,
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluate
+						.for("MemberExpression")
+						.tap("ImportMetaPlugin", expression => {
+							const expr = /** @type {MemberExpression} */ (expression);
+							if (
+								expr.object.type === "MetaProperty" &&
+								expr.object.meta.name === "import" &&
+								expr.object.property.name === "meta" &&
+								expr.property.type ===
+									(expr.computed ? "Literal" : "Identifier")
+							) {
+								return new BasicEvaluatedExpression()
+									.setUndefined()
+									.setRange(expr.range);
+							}
+						});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ImportMetaPlugin", parserHandler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ImportMetaPlugin", parserHandler);
 			}
-		}
+		);
 	}
+}
 
-	/**
-	 * @param {RenderBootstrapContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
-	 */
-	renderBootstrap(renderContext, hooks) {
-		const { chunkGraph, moduleGraph, chunk, runtimeTemplate } = renderContext;
+module.exports = ImportMetaPlugin;
 
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
-		const requireFunction = runtimeRequirements.has(RuntimeGlobals.require);
-		const moduleCache = runtimeRequirements.has(RuntimeGlobals.moduleCache);
-		const moduleFactories = runtimeRequirements.has(
-			RuntimeGlobals.moduleFactories
-		);
-		const moduleUsed = runtimeRequirements.has(RuntimeGlobals.module);
-		const requireScopeUsed = runtimeRequirements.has(
-			RuntimeGlobals.requireScope
-		);
-		const interceptModuleExecution = runtimeRequirements.has(
-			RuntimeGlobals.interceptModuleExecution
-		);
+/***/ }),
 
-		const useRequire =
-			requireFunction || interceptModuleExecution || moduleUsed;
+/***/ 88130:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const result = {
-			header: [],
-			beforeStartup: [],
-			startup: [],
-			afterStartup: [],
-			allowInlineStartup: true
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		let { header: buf, startup, beforeStartup, afterStartup } = result;
 
-		if (result.allowInlineStartup && moduleFactories) {
-			startup.push(
-				"// module factories are used so entry inlining is disabled"
-			);
-			result.allowInlineStartup = false;
-		}
-		if (result.allowInlineStartup && moduleCache) {
-			startup.push("// module cache are used so entry inlining is disabled");
-			result.allowInlineStartup = false;
-		}
-		if (result.allowInlineStartup && interceptModuleExecution) {
-			startup.push(
-				"// module execution is intercepted so entry inlining is disabled"
-			);
-			result.allowInlineStartup = false;
-		}
 
-		if (useRequire || moduleCache) {
-			buf.push("// The module cache");
-			buf.push("var __webpack_module_cache__ = {};");
-			buf.push("");
-		}
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const CommentCompilationWarning = __webpack_require__(98427);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const ImportContextDependency = __webpack_require__(1902);
+const ImportDependency = __webpack_require__(89376);
+const ImportEagerDependency = __webpack_require__(50718);
+const ImportWeakDependency = __webpack_require__(82483);
 
-		if (useRequire) {
-			buf.push("// The require function");
-			buf.push(`function __webpack_require__(moduleId) {`);
-			buf.push(Template.indent(this.renderRequire(renderContext, hooks)));
-			buf.push("}");
-			buf.push("");
-		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
-			buf.push("// The require scope");
-			buf.push("var __webpack_require__ = {};");
-			buf.push("");
-		}
+/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
 
-		if (
-			moduleFactories ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)
-		) {
-			buf.push("// expose the modules object (__webpack_modules__)");
-			buf.push(`${RuntimeGlobals.moduleFactories} = __webpack_modules__;`);
-			buf.push("");
-		}
+class ImportParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-		if (moduleCache) {
-			buf.push("// expose the module cache");
-			buf.push(`${RuntimeGlobals.moduleCache} = __webpack_module_cache__;`);
-			buf.push("");
-		}
+	apply(parser) {
+		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
+			const param = parser.evaluateExpression(expr.source);
 
-		if (interceptModuleExecution) {
-			buf.push("// expose the module execution interceptor");
-			buf.push(`${RuntimeGlobals.interceptModuleExecution} = [];`);
-			buf.push("");
-		}
+			let chunkName = null;
+			/** @type {ContextMode} */
+			let mode = "lazy";
+			let include = null;
+			let exclude = null;
+			/** @type {string[][] | null} */
+			let exports = null;
+			/** @type {RawChunkGroupOptions} */
+			const groupOptions = {};
 
-		if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
-			if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-				/** @type {string[]} */
-				const buf2 = [];
-				const runtimeRequirements =
-					chunkGraph.getTreeRuntimeRequirements(chunk);
-				buf2.push("// Load entry module and return exports");
-				let i = chunkGraph.getNumberOfEntryModules(chunk);
-				for (const [
-					entryModule,
-					entrypoint
-				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-					const chunks = entrypoint.chunks.filter(c => c !== chunk);
-					if (result.allowInlineStartup && chunks.length > 0) {
-						buf2.push(
-							"// This entry module depends on other loaded chunks and execution need to be delayed"
+			const { options: importOptions, errors: commentErrors } =
+				parser.parseCommentOptions(expr.range);
+
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							comment.loc
+						)
+					);
+				}
+			}
+
+			if (importOptions) {
+				if (importOptions.webpackIgnore !== undefined) {
+					if (typeof importOptions.webpackIgnore !== "boolean") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+								expr.loc
+							)
 						);
-						result.allowInlineStartup = false;
+					} else {
+						// Do not instrument `import()` if `webpackIgnore` is `true`
+						if (importOptions.webpackIgnore) {
+							return false;
+						}
 					}
-					if (
-						result.allowInlineStartup &&
-						someInIterable(
-							moduleGraph.getIncomingConnectionsByOriginModule(entryModule),
-							([originModule, connections]) =>
-								originModule &&
-								connections.some(c => c.isTargetActive(chunk.runtime)) &&
-								someInIterable(
-									chunkGraph.getModuleRuntimes(originModule),
-									runtime =>
-										intersectRuntime(runtime, chunk.runtime) !== undefined
-								)
-						)
-					) {
-						buf2.push(
-							"// This entry module is referenced by other modules so it can't be inlined"
+				}
+				if (importOptions.webpackChunkName !== undefined) {
+					if (typeof importOptions.webpackChunkName !== "string") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
+								expr.loc
+							)
 						);
-						result.allowInlineStartup = false;
+					} else {
+						chunkName = importOptions.webpackChunkName;
 					}
-					if (
-						result.allowInlineStartup &&
-						(!entryModule.buildInfo ||
-							!entryModule.buildInfo.topLevelDeclarations)
-					) {
-						buf2.push(
-							"// This entry module doesn't tell about it's top-level declarations so it can't be inlined"
+				}
+				if (importOptions.webpackMode !== undefined) {
+					if (typeof importOptions.webpackMode !== "string") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
+								expr.loc
+							)
 						);
-						result.allowInlineStartup = false;
+					} else {
+						mode = importOptions.webpackMode;
 					}
-					if (result.allowInlineStartup) {
-						const bailout = hooks.inlineInRuntimeBailout.call(
-							entryModule,
-							renderContext
+				}
+				if (importOptions.webpackPrefetch !== undefined) {
+					if (importOptions.webpackPrefetch === true) {
+						groupOptions.prefetchOrder = 0;
+					} else if (typeof importOptions.webpackPrefetch === "number") {
+						groupOptions.prefetchOrder = importOptions.webpackPrefetch;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
+								expr.loc
+							)
 						);
-						if (bailout !== undefined) {
-							buf2.push(
-								`// This entry module can't be inlined because ${bailout}`
-							);
-							result.allowInlineStartup = false;
-						}
 					}
-					i--;
-					const moduleId = chunkGraph.getModuleId(entryModule);
-					const entryRuntimeRequirements =
-						chunkGraph.getModuleRuntimeRequirements(entryModule, chunk.runtime);
-					let moduleIdExpr = JSON.stringify(moduleId);
-					if (runtimeRequirements.has(RuntimeGlobals.entryModuleId)) {
-						moduleIdExpr = `${RuntimeGlobals.entryModuleId} = ${moduleIdExpr}`;
+				}
+				if (importOptions.webpackPreload !== undefined) {
+					if (importOptions.webpackPreload === true) {
+						groupOptions.preloadOrder = 0;
+					} else if (typeof importOptions.webpackPreload === "number") {
+						groupOptions.preloadOrder = importOptions.webpackPreload;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
+								expr.loc
+							)
+						);
 					}
+				}
+				if (importOptions.webpackInclude !== undefined) {
 					if (
-						result.allowInlineStartup &&
-						entryRuntimeRequirements.has(RuntimeGlobals.module)
+						!importOptions.webpackInclude ||
+						importOptions.webpackInclude.constructor.name !== "RegExp"
 					) {
-						result.allowInlineStartup = false;
-						buf2.push(
-							"// This entry module used 'module' so it can't be inlined"
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
+								expr.loc
+							)
 						);
+					} else {
+						include = new RegExp(importOptions.webpackInclude);
 					}
-					if (chunks.length > 0) {
-						buf2.push(
-							`${i === 0 ? "var __webpack_exports__ = " : ""}${
-								RuntimeGlobals.onChunksLoaded
-							}(undefined, ${JSON.stringify(
-								chunks.map(c => c.id)
-							)}, ${runtimeTemplate.returningFunction(
-								`__webpack_require__(${moduleIdExpr})`
-							)})`
+				}
+				if (importOptions.webpackExclude !== undefined) {
+					if (
+						!importOptions.webpackExclude ||
+						importOptions.webpackExclude.constructor.name !== "RegExp"
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
+								expr.loc
+							)
 						);
-					} else if (useRequire) {
-						buf2.push(
-							`${
-								i === 0 ? "var __webpack_exports__ = " : ""
-							}__webpack_require__(${moduleIdExpr});`
+					} else {
+						exclude = new RegExp(importOptions.webpackExclude);
+					}
+				}
+				if (importOptions.webpackExports !== undefined) {
+					if (
+						!(
+							typeof importOptions.webpackExports === "string" ||
+							(Array.isArray(importOptions.webpackExports) &&
+								importOptions.webpackExports.every(
+									item => typeof item === "string"
+								))
+						)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
+								expr.loc
+							)
 						);
 					} else {
-						if (i === 0) buf2.push("var __webpack_exports__ = {};");
-						if (requireScopeUsed) {
-							buf2.push(
-								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
-								}, __webpack_require__);`
-							);
-						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
-							buf2.push(
-								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
-								});`
-							);
+						if (typeof importOptions.webpackExports === "string") {
+							exports = [[importOptions.webpackExports]];
 						} else {
-							buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+							exports = Array.from(importOptions.webpackExports, e => [e]);
 						}
 					}
 				}
-				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
-					buf2.push(
-						`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);`
+			}
+
+			if (param.isString()) {
+				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
+							expr.loc
+						)
 					);
 				}
-				if (
-					runtimeRequirements.has(RuntimeGlobals.startup) ||
-					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
-						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))
-				) {
-					result.allowInlineStartup = false;
-					buf.push("// the startup function");
-					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
-							...buf2,
-							"return __webpack_exports__;"
-						])};`
-					);
-					buf.push("");
-					startup.push("// run startup");
-					startup.push(
-						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
-					);
-				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
-					buf.push("// the startup function");
-					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+
+				if (mode === "eager") {
+					const dep = new ImportEagerDependency(
+						param.string,
+						expr.range,
+						exports
 					);
-					beforeStartup.push("// run runtime startup");
-					beforeStartup.push(`${RuntimeGlobals.startup}();`);
-					startup.push("// startup");
-					startup.push(Template.asString(buf2));
-				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
-					buf.push("// the startup function");
-					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+					parser.state.current.addDependency(dep);
+				} else if (mode === "weak") {
+					const dep = new ImportWeakDependency(
+						param.string,
+						expr.range,
+						exports
 					);
-					startup.push("// startup");
-					startup.push(Template.asString(buf2));
-					afterStartup.push("// run runtime startup");
-					afterStartup.push(`${RuntimeGlobals.startup}();`);
+					parser.state.current.addDependency(dep);
 				} else {
-					startup.push("// startup");
-					startup.push(Template.asString(buf2));
+					const depBlock = new AsyncDependenciesBlock(
+						{
+							...groupOptions,
+							name: chunkName
+						},
+						expr.loc,
+						param.string
+					);
+					const dep = new ImportDependency(param.string, expr.range, exports);
+					dep.loc = expr.loc;
+					depBlock.addDependency(dep);
+					parser.state.current.addBlock(depBlock);
 				}
-			} else if (
-				runtimeRequirements.has(RuntimeGlobals.startup) ||
-				runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
-				runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
-			) {
-				buf.push(
-					"// the startup function",
-					"// It's empty as no entry modules are in this chunk",
-					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`,
-					""
-				);
-			}
-		} else if (
-			runtimeRequirements.has(RuntimeGlobals.startup) ||
-			runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
-			runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
-		) {
-			result.allowInlineStartup = false;
-			buf.push(
-				"// the startup function",
-				"// It's empty as some runtime module handles the default behavior",
-				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
-			);
-			startup.push("// run startup");
-			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
-		}
-		return result;
-	}
-
-	/**
-	 * @param {RenderBootstrapContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {string} the generated source of the require function
-	 */
-	renderRequire(renderContext, hooks) {
-		const {
-			chunk,
-			chunkGraph,
-			runtimeTemplate: { outputOptions }
-		} = renderContext;
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
-		const moduleExecution = runtimeRequirements.has(
-			RuntimeGlobals.interceptModuleExecution
-		)
-			? Template.asString([
-					"var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };",
-					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
-					"module = execOptions.module;",
-					"execOptions.factory.call(module.exports, module, module.exports, execOptions.require);"
-			  ])
-			: runtimeRequirements.has(RuntimeGlobals.thisAsExports)
-			? Template.asString([
-					"__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);"
-			  ])
-			: Template.asString([
-					"__webpack_modules__[moduleId](module, module.exports, __webpack_require__);"
-			  ]);
-		const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
-		const needModuleLoaded = runtimeRequirements.has(
-			RuntimeGlobals.moduleLoaded
-		);
-		const content = Template.asString([
-			"// Check if module is in cache",
-			"var cachedModule = __webpack_module_cache__[moduleId];",
-			"if (cachedModule !== undefined) {",
-			outputOptions.strictModuleErrorHandling
-				? Template.indent([
-						"if (cachedModule.error !== undefined) throw cachedModule.error;",
-						"return cachedModule.exports;"
-				  ])
-				: Template.indent("return cachedModule.exports;"),
-			"}",
-			"// Create a new module (and put it into the cache)",
-			"var module = __webpack_module_cache__[moduleId] = {",
-			Template.indent([
-				needModuleId ? "id: moduleId," : "// no module.id needed",
-				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
-				"exports: {}"
-			]),
-			"};",
-			"",
-			outputOptions.strictModuleExceptionHandling
-				? Template.asString([
-						"// Execute the module function",
-						"var threw = true;",
-						"try {",
-						Template.indent([moduleExecution, "threw = false;"]),
-						"} finally {",
-						Template.indent([
-							"if(threw) delete __webpack_module_cache__[moduleId];"
-						]),
-						"}"
-				  ])
-				: outputOptions.strictModuleErrorHandling
-				? Template.asString([
-						"// Execute the module function",
-						"try {",
-						Template.indent(moduleExecution),
-						"} catch(e) {",
-						Template.indent(["module.error = e;", "throw e;"]),
-						"}"
-				  ])
-				: Template.asString([
-						"// Execute the module function",
-						moduleExecution
-				  ]),
-			needModuleLoaded
-				? Template.asString([
-						"",
-						"// Flag the module as loaded",
-						"module.loaded = true;",
-						""
-				  ])
-				: "",
-			"// Return the exports of the module",
-			"return module.exports;"
-		]);
-		return tryRunOrWebpackError(
-			() => hooks.renderRequire.call(content, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderRequire"
-		);
+				return true;
+			} else {
+				if (
+					mode !== "lazy" &&
+					mode !== "lazy-once" &&
+					mode !== "eager" &&
+					mode !== "weak"
+				) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+							expr.loc
+						)
+					);
+					mode = "lazy";
+				}
+
+				if (mode === "weak") {
+					mode = "async-weak";
+				}
+				const dep = ContextDependencyHelpers.create(
+					ImportContextDependency,
+					expr.range,
+					param,
+					expr,
+					this.options,
+					{
+						chunkName,
+						groupOptions,
+						include,
+						exclude,
+						mode,
+						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
+							? "strict"
+							: true,
+						typePrefix: "import()",
+						category: "esm",
+						referencedExports: exports
+					},
+					parser
+				);
+				if (!dep) return;
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		});
 	}
 }
 
-module.exports = JavascriptModulesPlugin;
-module.exports.chunkHasJs = chunkHasJs;
+module.exports = ImportParserPlugin;
 
 
 /***/ }),
 
-/***/ 29050:
+/***/ 41293:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -91104,3781 +87935,2762 @@ module.exports.chunkHasJs = chunkHasJs;
 
 
 
-const { Parser: AcornParser } = __webpack_require__(31988);
-const { importAssertions } = __webpack_require__(72617);
-const { SyncBailHook, HookMap } = __webpack_require__(6967);
-const vm = __webpack_require__(26144);
-const Parser = __webpack_require__(11715);
-const StackedMap = __webpack_require__(58845);
-const binarySearchBounds = __webpack_require__(92229);
-const memoize = __webpack_require__(78676);
-const BasicEvaluatedExpression = __webpack_require__(950);
+const ImportContextDependency = __webpack_require__(1902);
+const ImportDependency = __webpack_require__(89376);
+const ImportEagerDependency = __webpack_require__(50718);
+const ImportParserPlugin = __webpack_require__(88130);
+const ImportWeakDependency = __webpack_require__(82483);
 
-/** @typedef {import("acorn").Options} AcornOptions */
-/** @typedef {import("estree").ArrayExpression} ArrayExpressionNode */
-/** @typedef {import("estree").BinaryExpression} BinaryExpressionNode */
-/** @typedef {import("estree").BlockStatement} BlockStatementNode */
-/** @typedef {import("estree").SequenceExpression} SequenceExpressionNode */
-/** @typedef {import("estree").CallExpression} CallExpressionNode */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
-/** @typedef {import("estree").Comment} CommentNode */
-/** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
-/** @typedef {import("estree").Declaration} DeclarationNode */
-/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
-/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Identifier} IdentifierNode */
-/** @typedef {import("estree").IfStatement} IfStatementNode */
-/** @typedef {import("estree").LabeledStatement} LabeledStatementNode */
-/** @typedef {import("estree").Literal} LiteralNode */
-/** @typedef {import("estree").LogicalExpression} LogicalExpressionNode */
-/** @typedef {import("estree").ChainExpression} ChainExpressionNode */
-/** @typedef {import("estree").MemberExpression} MemberExpressionNode */
-/** @typedef {import("estree").MetaProperty} MetaPropertyNode */
-/** @typedef {import("estree").MethodDefinition} MethodDefinitionNode */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclarationNode */
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
-/** @typedef {import("estree").Node} AnyNode */
-/** @typedef {import("estree").Program} ProgramNode */
-/** @typedef {import("estree").Statement} StatementNode */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
-/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
-/** @typedef {import("estree").Super} SuperNode */
-/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
-/** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
-/** @typedef {import("estree").ThisExpression} ThisExpressionNode */
-/** @typedef {import("estree").UnaryExpression} UnaryExpressionNode */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
-/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[] }} GetInfoResult */
+/** @typedef {import("../Compiler")} Compiler */
 
-const EMPTY_ARRAY = [];
-const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
-const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
-const ALLOWED_MEMBER_TYPES_ALL = 0b11;
+class ImportPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ImportPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportDependency,
+					new ImportDependency.Template()
+				);
 
-// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
+				compilation.dependencyFactories.set(
+					ImportEagerDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportEagerDependency,
+					new ImportEagerDependency.Template()
+				);
 
-const parser = AcornParser.extend(importAssertions);
+				compilation.dependencyFactories.set(
+					ImportWeakDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportWeakDependency,
+					new ImportWeakDependency.Template()
+				);
 
-class VariableInfo {
-	/**
-	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true} freeName which free name the variable aliases, or true when none
-	 * @param {TagInfo | undefined} tagInfo info about tags
-	 */
-	constructor(declaredScope, freeName, tagInfo) {
-		this.declaredScope = declaredScope;
-		this.freeName = freeName;
-		this.tagInfo = tagInfo;
+				compilation.dependencyFactories.set(
+					ImportContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportContextDependency,
+					new ImportContextDependency.Template()
+				);
+
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.import !== undefined && !parserOptions.import)
+						return;
+
+					new ImportParserPlugin(parserOptions).apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ImportPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ImportPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ImportPlugin", handler);
+			}
+		);
 	}
 }
+module.exports = ImportPlugin;
 
-/** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
-/** @typedef {LiteralNode | string | null | undefined} ImportSource */
-/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
 
-/**
- * @typedef {Object} TagInfo
- * @property {any} tag
- * @property {any} data
- * @property {TagInfo | undefined} next
- */
+/***/ }),
 
-/**
- * @typedef {Object} ScopeInfo
- * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
- * @property {boolean | "arrow"} topLevelScope
- * @property {boolean} inShorthand
- * @property {boolean} isStrict
- * @property {boolean} isAsmJs
- * @property {boolean} inTry
- */
+/***/ 82483:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const joinRanges = (startRange, endRange) => {
-	if (!endRange) return startRange;
-	if (!startRange) return endRange;
-	return [startRange[0], endRange[1]];
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-const objectAndMembersToName = (object, membersReversed) => {
-	let name = object;
-	for (let i = membersReversed.length - 1; i >= 0; i--) {
-		name = name + "." + membersReversed[i];
+
+
+const makeSerializable = __webpack_require__(33032);
+const ImportDependency = __webpack_require__(89376);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+class ImportWeakDependency extends ImportDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {[number, number]} range expression range
+	 * @param {string[][]=} referencedExports list of referenced exports
+	 */
+	constructor(request, range, referencedExports) {
+		super(request, range, referencedExports);
+		this.weak = true;
 	}
-	return name;
-};
 
-const getRootName = expression => {
-	switch (expression.type) {
-		case "Identifier":
-			return expression.name;
-		case "ThisExpression":
-			return "this";
-		case "MetaProperty":
-			return `${expression.meta.name}.${expression.property.name}`;
-		default:
-			return undefined;
+	get type() {
+		return "import() weak";
 	}
-};
+}
 
-/** @type {AcornOptions} */
-const defaultParserOptions = {
-	ranges: true,
-	locations: true,
-	ecmaVersion: "latest",
-	sourceType: "module",
-	// https://github.com/tc39/proposal-hashbang
-	allowHashBang: true,
-	onComment: null
-};
+makeSerializable(
+	ImportWeakDependency,
+	"webpack/lib/dependencies/ImportWeakDependency"
+);
 
-// regexp to match at least one "magic comment"
-const webpackCommentRegExp = new RegExp(/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/);
+ImportWeakDependency.Template = class ImportDependencyTemplate extends (
+	ImportDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportWeakDependency} */ (dependency);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			strict: module.buildMeta.strictHarmonyModule,
+			message: "import() weak",
+			weak: true,
+			runtimeRequirements
+		});
 
-const EMPTY_COMMENT_OPTIONS = {
-	options: null,
-	errors: null
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
 };
 
-class JavascriptParser extends Parser {
-	/**
-	 * @param {"module" | "script" | "auto"} sourceType default source type
-	 */
-	constructor(sourceType = "auto") {
-		super();
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[UnaryExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode | MetaPropertyNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateDefinedIdentifier: new HookMap(
-				() => new SyncBailHook(["expression"])
-			),
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateCallExpressionMember: new HookMap(
-				() => new SyncBailHook(["expression", "param"])
-			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
-			isPure: new HookMap(
-				() => new SyncBailHook(["expression", "commentsStartPosition"])
-			),
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
-			preStatement: new SyncBailHook(["statement"]),
+module.exports = ImportWeakDependency;
 
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
-			blockPreStatement: new SyncBailHook(["declaration"]),
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
-			statement: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
-			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classExtendsExpression: new SyncBailHook([
-				"expression",
-				"classDefinition"
-			]),
-			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classBodyValue: new SyncBailHook([
-				"expression",
-				"element",
-				"classDefinition"
-			]),
-			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
-			label: new HookMap(() => new SyncBailHook(["statement"])),
-			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
-			import: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
-			importSpecifier: new SyncBailHook([
-				"statement",
-				"source",
-				"exportName",
-				"identifierName"
-			]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
-			export: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
-			exportImport: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
-			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
-			exportExpression: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
-			exportSpecifier: new SyncBailHook([
-				"statement",
-				"identifierName",
-				"exportName",
-				"index"
-			]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
-			exportImportSpecifier: new SyncBailHook([
-				"statement",
-				"source",
-				"identifierName",
-				"exportName",
-				"index"
-			]),
-			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
-			preDeclarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
-			declarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
-			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
-			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression], boolean | void>>} */
-			assign: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression, string[]], boolean | void>>} */
-			assignMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
-			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			typeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			importCall: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			topLevelAwait: new SyncBailHook(["expression"]),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			call: new HookMap(() => new SyncBailHook(["expression"])),
-			/** Something like "a.b()" */
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode, string[]], boolean | void>>} */
-			callMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
-			),
-			/** Something like "a.b().c.d" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
-			memberChainOfCallMemberChain: new HookMap(
-				() =>
-					new SyncBailHook([
-						"expression",
-						"calleeMembers",
-						"callExpression",
-						"members"
-					])
-			),
-			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
-			callMemberChainOfCallMemberChain: new HookMap(
-				() =>
-					new SyncBailHook([
-						"expression",
-						"calleeMembers",
-						"innerCallExpression",
-						"members"
-					])
-			),
-			/** @type {SyncBailHook<[ChainExpressionNode], boolean | void>} */
-			optionalChaining: new SyncBailHook(["optionalChaining"]),
-			/** @type {HookMap<SyncBailHook<[NewExpressionNode], boolean | void>>} */
-			new: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
-			expressionMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
-			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
-			unhandledExpressionMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
-			),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			expressionConditionalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			expressionLogicalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
-			program: new SyncBailHook(["ast", "comments"]),
-			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
-			finish: new SyncBailHook(["ast", "comments"])
-		});
-		this.sourceType = sourceType;
-		/** @type {ScopeInfo} */
-		this.scope = undefined;
-		/** @type {ParserState} */
-		this.state = undefined;
-		this.comments = undefined;
-		this.semicolons = undefined;
-		/** @type {(StatementNode|ExpressionNode)[]} */
-		this.statementPath = undefined;
-		this.prevStatement = undefined;
-		this.currentTagData = undefined;
-		this._initializeEvaluating();
+
+/***/ }),
+
+/***/ 750:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+
+const getExportsFromData = data => {
+	if (data && typeof data === "object") {
+		if (Array.isArray(data)) {
+			return data.map((item, idx) => {
+				return {
+					name: `${idx}`,
+					canMangle: true,
+					exports: getExportsFromData(item)
+				};
+			});
+		} else {
+			const exports = [];
+			for (const key of Object.keys(data)) {
+				exports.push({
+					name: key,
+					canMangle: true,
+					exports: getExportsFromData(data[key])
+				});
+			}
+			return exports;
+		}
 	}
+	return undefined;
+};
 
-	_initializeEvaluating() {
-		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
-			const expr = /** @type {LiteralNode} */ (_expr);
+class JsonExportsDependency extends NullDependency {
+	/**
+	 * @param {(string | ExportSpec)[]} exports json exports
+	 */
+	constructor(exports) {
+		super();
+		this.exports = exports;
+		this._hashUpdate = undefined;
+	}
 
-			switch (typeof expr.value) {
-				case "number":
-					return new BasicEvaluatedExpression()
-						.setNumber(expr.value)
-						.setRange(expr.range);
-				case "bigint":
-					return new BasicEvaluatedExpression()
-						.setBigInt(expr.value)
-						.setRange(expr.range);
-				case "string":
-					return new BasicEvaluatedExpression()
-						.setString(expr.value)
-						.setRange(expr.range);
-				case "boolean":
-					return new BasicEvaluatedExpression()
-						.setBoolean(expr.value)
-						.setRange(expr.range);
-			}
-			if (expr.value === null) {
-				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
-			}
-			if (expr.value instanceof RegExp) {
-				return new BasicEvaluatedExpression()
-					.setRegExp(expr.value)
-					.setRange(expr.range);
-			}
-		});
-		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
-			const expr = /** @type {NewExpressionNode} */ (_expr);
-			const callee = expr.callee;
-			if (
-				callee.type !== "Identifier" ||
-				callee.name !== "RegExp" ||
-				expr.arguments.length > 2 ||
-				this.getVariableInfo("RegExp") !== "RegExp"
-			)
-				return;
+	get type() {
+		return "json exports";
+	}
 
-			let regExp, flags;
-			const arg1 = expr.arguments[0];
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: this.exports,
+			dependencies: undefined
+		};
+	}
 
-			if (arg1) {
-				if (arg1.type === "SpreadElement") return;
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.exports
+				? JSON.stringify(this.exports)
+				: "undefined";
+		}
+		hash.update(this._hashUpdate);
+	}
 
-				const evaluatedRegExp = this.evaluateExpression(arg1);
+	serialize(context) {
+		const { write } = context;
+		write(this.exports);
+		super.serialize(context);
+	}
 
-				if (!evaluatedRegExp) return;
+	deserialize(context) {
+		const { read } = context;
+		this.exports = read();
+		super.deserialize(context);
+	}
+}
 
-				regExp = evaluatedRegExp.asString();
+makeSerializable(
+	JsonExportsDependency,
+	"webpack/lib/dependencies/JsonExportsDependency"
+);
 
-				if (!regExp) return;
-			} else {
-				return new BasicEvaluatedExpression()
-					.setRegExp(new RegExp(""))
-					.setRange(expr.range);
-			}
+module.exports = JsonExportsDependency;
+module.exports.getExportsFromData = getExportsFromData;
 
-			const arg2 = expr.arguments[1];
 
-			if (arg2) {
-				if (arg2.type === "SpreadElement") return;
+/***/ }),
 
-				const evaluatedFlags = this.evaluateExpression(arg2);
+/***/ 71693:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				if (!evaluatedFlags) return;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				if (!evaluatedFlags.isUndefined()) {
-					flags = evaluatedFlags.asString();
 
-					if (
-						flags === undefined ||
-						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
-					)
-						return;
-				}
-			}
 
-			return new BasicEvaluatedExpression()
-				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
-				.setRange(expr.range);
-		});
-		this.hooks.evaluate
-			.for("LogicalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {LogicalExpressionNode} */ (_expr);
+const ModuleDependency = __webpack_require__(80321);
 
-				const left = this.evaluateExpression(expr.left);
-				if (!left) return;
-				let returnRight = false;
-				/** @type {boolean|undefined} */
-				let allowedRight;
-				if (expr.operator === "&&") {
-					const leftAsBool = left.asBool();
-					if (leftAsBool === false) return left.setRange(expr.range);
-					returnRight = leftAsBool === true;
-					allowedRight = false;
-				} else if (expr.operator === "||") {
-					const leftAsBool = left.asBool();
-					if (leftAsBool === true) return left.setRange(expr.range);
-					returnRight = leftAsBool === false;
-					allowedRight = true;
-				} else if (expr.operator === "??") {
-					const leftAsNullish = left.asNullish();
-					if (leftAsNullish === false) return left.setRange(expr.range);
-					if (leftAsNullish !== true) return;
-					returnRight = true;
-				} else return;
-				const right = this.evaluateExpression(expr.right);
-				if (!right) return;
-				if (returnRight) {
-					if (left.couldHaveSideEffects()) right.setSideEffects();
-					return right.setRange(expr.range);
-				}
+class LoaderDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 */
+	constructor(request) {
+		super(request);
+	}
 
-				const asBool = right.asBool();
+	get type() {
+		return "loader";
+	}
 
-				if (allowedRight === true && asBool === true) {
-					return new BasicEvaluatedExpression()
-						.setRange(expr.range)
-						.setTruthy();
-				} else if (allowedRight === false && asBool === false) {
-					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
-				}
-			});
+	get category() {
+		return "loader";
+	}
+}
 
-		const valueAsExpression = (value, expr, sideEffects) => {
-			switch (typeof value) {
-				case "boolean":
-					return new BasicEvaluatedExpression()
-						.setBoolean(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
-				case "number":
-					return new BasicEvaluatedExpression()
-						.setNumber(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
-				case "bigint":
-					return new BasicEvaluatedExpression()
-						.setBigInt(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
-				case "string":
-					return new BasicEvaluatedExpression()
-						.setString(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+module.exports = LoaderDependency;
+
+
+/***/ }),
+
+/***/ 223:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleDependency = __webpack_require__(80321);
+
+class LoaderImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request string
+	 */
+	constructor(request) {
+		super(request);
+		this.weak = true;
+	}
+
+	get type() {
+		return "loader import";
+	}
+
+	get category() {
+		return "loaderImport";
+	}
+}
+
+module.exports = LoaderImportDependency;
+
+
+/***/ }),
+
+/***/ 24721:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const NormalModule = __webpack_require__(39);
+const LazySet = __webpack_require__(38938);
+const LoaderDependency = __webpack_require__(71693);
+const LoaderImportDependency = __webpack_require__(223);
+
+/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+/**
+ * @callback LoadModuleCallback
+ * @param {(Error | null)=} err error object
+ * @param {string | Buffer=} source source code
+ * @param {object=} map source map
+ * @param {Module=} module loaded module if successful
+ */
+
+/**
+ * @callback ImportModuleCallback
+ * @param {(Error | null)=} err error object
+ * @param {any=} exports exports of the evaluated module
+ */
+
+/**
+ * @typedef {Object} ImportModuleOptions
+ * @property {string=} layer the target layer
+ * @property {string=} publicPath the target public path
+ */
+
+class LoaderPlugin {
+	/**
+	 * @param {Object} options options
+	 */
+	constructor(options = {}) {}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"LoaderPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					LoaderDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					LoaderImportDependency,
+					normalModuleFactory
+				);
 			}
-		};
+		);
+
+		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				"LoaderPlugin",
+				loaderContext => {
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
+					 * @returns {void}
+					 */
+					loaderContext.loadModule = (request, callback) => {
+						const dep = new LoaderDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule: loaderContext._module,
+								context: loaderContext.context,
+								recursive: false
+							},
+							err => {
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								if (referencedModule.getNumberOfErrors() > 0) {
+									return callback(
+										new Error("The loaded module contains errors")
+									);
+								}
+								const moduleSource = referencedModule.originalSource();
+								if (!moduleSource) {
+									return callback(
+										new Error(
+											"The module created for a LoaderDependency must have an original source"
+										)
+									);
+								}
+								let source, map;
+								if (moduleSource.sourceAndMap) {
+									const sourceAndMap = moduleSource.sourceAndMap();
+									map = sourceAndMap.map;
+									source = sourceAndMap.source;
+								} else {
+									map = moduleSource.map();
+									source = moduleSource.source();
+								}
+								const fileDependencies = new LazySet();
+								const contextDependencies = new LazySet();
+								const missingDependencies = new LazySet();
+								const buildDependencies = new LazySet();
+								referencedModule.addCacheDependencies(
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								);
+
+								for (const d of fileDependencies) {
+									loaderContext.addDependency(d);
+								}
+								for (const d of contextDependencies) {
+									loaderContext.addContextDependency(d);
+								}
+								for (const d of missingDependencies) {
+									loaderContext.addMissingDependency(d);
+								}
+								for (const d of buildDependencies) {
+									loaderContext.addBuildDependency(d);
+								}
+								return callback(null, source, map, referencedModule);
+							}
+						);
+					};
+
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions=} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {void}
+					 */
+					const importModule = (request, options, callback) => {
+						const dep = new LoaderImportDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule: loaderContext._module,
+								contextInfo: {
+									issuerLayer: options.layer
+								},
+								context: loaderContext.context,
+								connectOrigin: false
+							},
+							err => {
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								compilation.executeModule(
+									referencedModule,
+									{
+										entryOptions: {
+											publicPath: options.publicPath
+										}
+									},
+									(err, result) => {
+										if (err) return callback(err);
+										for (const d of result.fileDependencies) {
+											loaderContext.addDependency(d);
+										}
+										for (const d of result.contextDependencies) {
+											loaderContext.addContextDependency(d);
+										}
+										for (const d of result.missingDependencies) {
+											loaderContext.addMissingDependency(d);
+										}
+										for (const d of result.buildDependencies) {
+											loaderContext.addBuildDependency(d);
+										}
+										if (result.cacheable === false)
+											loaderContext.cacheable(false);
+										for (const [name, { source, info }] of result.assets) {
+											const { buildInfo } = loaderContext._module;
+											if (!buildInfo.assets) {
+												buildInfo.assets = Object.create(null);
+												buildInfo.assetsInfo = new Map();
+											}
+											buildInfo.assets[name] = source;
+											buildInfo.assetsInfo.set(name, info);
+										}
+										callback(null, result.exports);
+									}
+								);
+							}
+						);
+					};
+
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {Promise<any> | void} exports
+					 */
+					loaderContext.importModule = (request, options, callback) => {
+						if (!callback) {
+							return new Promise((resolve, reject) => {
+								importModule(request, options || {}, (err, result) => {
+									if (err) reject(err);
+									else resolve(result);
+								});
+							});
+						}
+						return importModule(request, options || {}, callback);
+					};
+				}
+			);
+		});
+	}
+}
+module.exports = LoaderPlugin;
 
-		this.hooks.evaluate
-			.for("BinaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {BinaryExpressionNode} */ (_expr);
 
-				const handleConstOperation = fn => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left || !left.isCompileTimeValue()) return;
+/***/ }),
 
-					const right = this.evaluateExpression(expr.right);
-					if (!right || !right.isCompileTimeValue()) return;
+/***/ 5826:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					const result = fn(
-						left.asCompileTimeValue(),
-						right.asCompileTimeValue()
-					);
-					return valueAsExpression(
-						result,
-						expr,
-						left.couldHaveSideEffects() || right.couldHaveSideEffects()
-					);
-				};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				const isAlwaysDifferent = (a, b) =>
-					(a === true && b === false) || (a === false && b === true);
 
-				const handleTemplateStringCompare = (left, right, res, eql) => {
-					const getPrefix = parts => {
-						let value = "";
-						for (const p of parts) {
-							const v = p.asString();
-							if (v !== undefined) value += v;
-							else break;
-						}
-						return value;
-					};
-					const getSuffix = parts => {
-						let value = "";
-						for (let i = parts.length - 1; i >= 0; i--) {
-							const v = parts[i].asString();
-							if (v !== undefined) value = v + value;
-							else break;
-						}
-						return value;
-					};
-					const leftPrefix = getPrefix(left.parts);
-					const rightPrefix = getPrefix(right.parts);
-					const leftSuffix = getSuffix(left.parts);
-					const rightSuffix = getSuffix(right.parts);
-					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
-					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
-					if (
-						leftPrefix.slice(0, lenPrefix) !==
-							rightPrefix.slice(0, lenPrefix) ||
-						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
-					) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-				};
 
-				const handleStrictEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
-					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
-					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+const makeSerializable = __webpack_require__(33032);
 
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
+class LocalModule {
+	constructor(name, idx) {
+		this.name = name;
+		this.idx = idx;
+		this.used = false;
+	}
 
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									(left.asCompileTimeValue() === right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
+	flagUsed() {
+		this.used = true;
+	}
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
+	variableName() {
+		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+	}
 
-					const leftPrimitive = left.isPrimitiveType();
-					const rightPrimitive = right.isPrimitiveType();
+	serialize(context) {
+		const { write } = context;
 
-					if (
-						// Primitive !== Object or
-						// compile-time object types are never equal to something at runtime
-						(leftPrimitive === false &&
-							(leftConst || rightPrimitive === true)) ||
-						(rightPrimitive === false &&
-							(rightConst || leftPrimitive === true)) ||
-						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(left.asBool(), right.asBool()) ||
-						isAlwaysDifferent(left.asNullish(), right.asNullish())
-					) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-				};
+		write(this.name);
+		write(this.idx);
+		write(this.used);
+	}
 
-				const handleAbstractEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
-					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
-					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+	deserialize(context) {
+		const { read } = context;
 
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
+		this.name = read();
+		this.idx = read();
+		this.used = read();
+	}
+}
 
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									// eslint-disable-next-line eqeqeq
-									(left.asCompileTimeValue() == right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
+makeSerializable(LocalModule, "webpack/lib/dependencies/LocalModule");
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
-				};
+module.exports = LocalModule;
 
-				if (expr.operator === "+") {
-					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
-					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
-					const res = new BasicEvaluatedExpression();
-					if (left.isString()) {
-						if (right.isString()) {
-							res.setString(left.string + right.string);
-						} else if (right.isNumber()) {
-							res.setString(left.string + right.number);
-						} else if (
-							right.isWrapped() &&
-							right.prefix &&
-							right.prefix.isString()
-						) {
-							// "left" + ("prefix" + inner + "postfix")
-							// => ("leftPrefix" + inner + "postfix")
-							res.setWrapped(
-								new BasicEvaluatedExpression()
-									.setString(left.string + right.prefix.string)
-									.setRange(joinRanges(left.range, right.prefix.range)),
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// "left" + ([null] + inner + "postfix")
-							// => ("left" + inner + "postfix")
-							res.setWrapped(
-								left,
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else {
-							// "left" + expr
-							// => ("left" + expr + "")
-							res.setWrapped(left, null, [right]);
-						}
-					} else if (left.isNumber()) {
-						if (right.isString()) {
-							res.setString(left.number + right.string);
-						} else if (right.isNumber()) {
-							res.setNumber(left.number + right.number);
-						} else {
-							return;
-						}
-					} else if (left.isBigInt()) {
-						if (right.isBigInt()) {
-							res.setBigInt(left.bigint + right.bigint);
-						}
-					} else if (left.isWrapped()) {
-						if (left.postfix && left.postfix.isString() && right.isString()) {
-							// ("prefix" + inner + "postfix") + "right"
-							// => ("prefix" + inner + "postfixRight")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.string)
-									.setRange(joinRanges(left.postfix.range, right.range)),
-								left.wrappedInnerExpressions
-							);
-						} else if (
-							left.postfix &&
-							left.postfix.isString() &&
-							right.isNumber()
-						) {
-							// ("prefix" + inner + "postfix") + 123
-							// => ("prefix" + inner + "postfix123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.number)
-									.setRange(joinRanges(left.postfix.range, right.range)),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isString()) {
-							// ("prefix" + inner + [null]) + "right"
-							// => ("prefix" + inner + "right")
-							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
-						} else if (right.isNumber()) {
-							// ("prefix" + inner + [null]) + 123
-							// => ("prefix" + inner + "123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(right.number + "")
-									.setRange(right.range),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
-							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
-							res.setWrapped(
-								left.prefix,
-								right.postfix,
-								left.wrappedInnerExpressions &&
-									right.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions
-										.concat(left.postfix ? [left.postfix] : [])
-										.concat(right.prefix ? [right.prefix] : [])
-										.concat(right.wrappedInnerExpressions)
-							);
-						} else {
-							// ("prefix" + inner + postfix) + expr
-							// => ("prefix" + inner + postfix + expr + [null])
-							res.setWrapped(
-								left.prefix,
-								null,
-								left.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions.concat(
-										left.postfix ? [left.postfix, right] : [right]
-									)
-							);
-						}
-					} else {
-						if (right.isString()) {
-							// left + "right"
-							// => ([null] + left + "right")
-							res.setWrapped(null, right, [left]);
-						} else if (right.isWrapped()) {
-							// left + (prefix + inner + "postfix")
-							// => ([null] + left + prefix + inner + "postfix")
-							res.setWrapped(
-								null,
-								right.postfix,
-								right.wrappedInnerExpressions &&
-									(right.prefix ? [left, right.prefix] : [left]).concat(
-										right.wrappedInnerExpressions
-									)
-							);
-						} else {
-							return;
-						}
-					}
-					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
-						res.setSideEffects();
-					res.setRange(expr.range);
-					return res;
-				} else if (expr.operator === "-") {
-					return handleConstOperation((l, r) => l - r);
-				} else if (expr.operator === "*") {
-					return handleConstOperation((l, r) => l * r);
-				} else if (expr.operator === "/") {
-					return handleConstOperation((l, r) => l / r);
-				} else if (expr.operator === "**") {
-					return handleConstOperation((l, r) => l ** r);
-				} else if (expr.operator === "===") {
-					return handleStrictEqualityComparison(true);
-				} else if (expr.operator === "==") {
-					return handleAbstractEqualityComparison(true);
-				} else if (expr.operator === "!==") {
-					return handleStrictEqualityComparison(false);
-				} else if (expr.operator === "!=") {
-					return handleAbstractEqualityComparison(false);
-				} else if (expr.operator === "&") {
-					return handleConstOperation((l, r) => l & r);
-				} else if (expr.operator === "|") {
-					return handleConstOperation((l, r) => l | r);
-				} else if (expr.operator === "^") {
-					return handleConstOperation((l, r) => l ^ r);
-				} else if (expr.operator === ">>>") {
-					return handleConstOperation((l, r) => l >>> r);
-				} else if (expr.operator === ">>") {
-					return handleConstOperation((l, r) => l >> r);
-				} else if (expr.operator === "<<") {
-					return handleConstOperation((l, r) => l << r);
-				} else if (expr.operator === "<") {
-					return handleConstOperation((l, r) => l < r);
-				} else if (expr.operator === ">") {
-					return handleConstOperation((l, r) => l > r);
-				} else if (expr.operator === "<=") {
-					return handleConstOperation((l, r) => l <= r);
-				} else if (expr.operator === ">=") {
-					return handleConstOperation((l, r) => l >= r);
-				}
-			});
-		this.hooks.evaluate
-			.for("UnaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {UnaryExpressionNode} */ (_expr);
 
-				const handleConstOperation = fn => {
-					const argument = this.evaluateExpression(expr.argument);
-					if (!argument || !argument.isCompileTimeValue()) return;
-					const result = fn(argument.asCompileTimeValue());
-					return valueAsExpression(
-						result,
-						expr,
-						argument.couldHaveSideEffects()
-					);
-				};
+/***/ }),
 
-				if (expr.operator === "typeof") {
-					switch (expr.argument.type) {
-						case "Identifier": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								expr.argument.name,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MetaProperty": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								getRootName(expr.argument),
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MemberExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "ChainExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument.expression,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "FunctionExpression": {
-							return new BasicEvaluatedExpression()
-								.setString("function")
-								.setRange(expr.range);
-						}
-					}
-					const arg = this.evaluateExpression(expr.argument);
-					if (arg.isUnknown()) return;
-					if (arg.isString()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setRange(expr.range);
-					}
-					if (arg.isWrapped()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setSideEffects()
-							.setRange(expr.range);
-					}
-					if (arg.isUndefined()) {
-						return new BasicEvaluatedExpression()
-							.setString("undefined")
-							.setRange(expr.range);
-					}
-					if (arg.isNumber()) {
-						return new BasicEvaluatedExpression()
-							.setString("number")
-							.setRange(expr.range);
-					}
-					if (arg.isBigInt()) {
-						return new BasicEvaluatedExpression()
-							.setString("bigint")
-							.setRange(expr.range);
-					}
-					if (arg.isBoolean()) {
-						return new BasicEvaluatedExpression()
-							.setString("boolean")
-							.setRange(expr.range);
-					}
-					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
-						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setRange(expr.range);
-					}
-					if (arg.isArray()) {
-						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setSideEffects(arg.couldHaveSideEffects())
-							.setRange(expr.range);
-					}
-				} else if (expr.operator === "!") {
-					const argument = this.evaluateExpression(expr.argument);
-					if (!argument) return;
-					const bool = argument.asBool();
-					if (typeof bool !== "boolean") return;
-					return new BasicEvaluatedExpression()
-						.setBoolean(!bool)
-						.setSideEffects(argument.couldHaveSideEffects())
-						.setRange(expr.range);
-				} else if (expr.operator === "~") {
-					return handleConstOperation(v => ~v);
-				} else if (expr.operator === "+") {
-					return handleConstOperation(v => +v);
-				} else if (expr.operator === "-") {
-					return handleConstOperation(v => -v);
-				}
-			});
-		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
-			return new BasicEvaluatedExpression()
-				.setString("undefined")
-				.setRange(expr.range);
-		});
-		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
-			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
-				return new BasicEvaluatedExpression()
-					.setUndefined()
-					.setRange(expr.range);
-			}
-		});
-		/**
-		 * @param {string} exprType expression type name
-		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
-		 * @returns {void}
-		 */
-		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
-			/** @type {ExpressionNode | undefined} */
-			let cachedExpression = undefined;
-			/** @type {GetInfoResult | undefined} */
-			let cachedInfo = undefined;
-			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
-				const expression = /** @type {MemberExpressionNode} */ (expr);
+/***/ 52805:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				const info = getInfo(expr);
-				if (info !== undefined) {
-					return this.callHooksForInfoWithFallback(
-						this.hooks.evaluateIdentifier,
-						info.name,
-						name => {
-							cachedExpression = expression;
-							cachedInfo = info;
-						},
-						name => {
-							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
-							if (hook !== undefined) {
-								return hook.call(expression);
-							}
-						},
-						expression
-					);
-				}
-			});
-			this.hooks.evaluate
-				.for(exprType)
-				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
-					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
-					if (info !== undefined) {
-						return new BasicEvaluatedExpression()
-							.setIdentifier(info.name, info.rootInfo, info.getMembers)
-							.setRange(expr.range);
-					}
-				});
-			this.hooks.finish.tap("JavascriptParser", () => {
-				// Cleanup for GC
-				cachedExpression = cachedInfo = undefined;
-			});
-		};
-		tapEvaluateWithVariableInfo("Identifier", expr => {
-			const info = this.getVariableInfo(
-				/** @type {IdentifierNode} */ (expr).name
-			);
-			if (
-				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
-			) {
-				return { name: info, rootInfo: info, getMembers: () => [] };
-			}
-		});
-		tapEvaluateWithVariableInfo("ThisExpression", expr => {
-			const info = this.getVariableInfo("this");
-			if (
-				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
-			) {
-				return { name: info, rootInfo: info, getMembers: () => [] };
-			}
-		});
-		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
-			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
 
-			return this.callHooksForName(
-				this.hooks.evaluateIdentifier,
-				getRootName(expr),
-				metaProperty
-			);
-		});
-		tapEvaluateWithVariableInfo("MemberExpression", expr =>
-			this.getMemberExpressionInfo(
-				/** @type {MemberExpressionNode} */ (expr),
-				ALLOWED_MEMBER_TYPES_EXPRESSION
-			)
-		);
 
-		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
-			const expr = /** @type {CallExpressionNode} */ (_expr);
-			if (
-				expr.callee.type !== "MemberExpression" ||
-				expr.callee.property.type !==
-					(expr.callee.computed ? "Literal" : "Identifier")
-			) {
-				return;
-			}
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-			// type Super also possible here
-			const param = this.evaluateExpression(
-				/** @type {ExpressionNode} */ (expr.callee.object)
-			);
-			if (!param) return;
-			const property =
-				expr.callee.property.type === "Literal"
-					? `${expr.callee.property.value}`
-					: expr.callee.property.name;
-			const hook = this.hooks.evaluateCallExpressionMember.get(property);
-			if (hook !== undefined) {
-				return hook.call(expr, param);
-			}
-		});
-		this.hooks.evaluateCallExpressionMember
-			.for("indexOf")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString()) return;
-				if (expr.arguments.length === 0) return;
-				const [arg1, arg2] = expr.arguments;
-				if (arg1.type === "SpreadElement") return;
-				const arg1Eval = this.evaluateExpression(arg1);
-				if (!arg1Eval.isString()) return;
-				const arg1Value = arg1Eval.string;
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-				let result;
-				if (arg2) {
-					if (arg2.type === "SpreadElement") return;
-					const arg2Eval = this.evaluateExpression(arg2);
-					if (!arg2Eval.isNumber()) return;
-					result = param.string.indexOf(arg1Value, arg2Eval.number);
-				} else {
-					result = param.string.indexOf(arg1Value);
-				}
-				return new BasicEvaluatedExpression()
-					.setNumber(result)
-					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
-			});
-		this.hooks.evaluateCallExpressionMember
-			.for("replace")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString()) return;
-				if (expr.arguments.length !== 2) return;
-				if (expr.arguments[0].type === "SpreadElement") return;
-				if (expr.arguments[1].type === "SpreadElement") return;
-				let arg1 = this.evaluateExpression(expr.arguments[0]);
-				let arg2 = this.evaluateExpression(expr.arguments[1]);
-				if (!arg1.isString() && !arg1.isRegExp()) return;
-				const arg1Value = arg1.regExp || arg1.string;
-				if (!arg2.isString()) return;
-				const arg2Value = arg2.string;
-				return new BasicEvaluatedExpression()
-					.setString(param.string.replace(arg1Value, arg2Value))
-					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
-			});
-		["substr", "substring", "slice"].forEach(fn => {
-			this.hooks.evaluateCallExpressionMember
-				.for(fn)
-				.tap("JavascriptParser", (expr, param) => {
-					if (!param.isString()) return;
-					let arg1;
-					let result,
-						str = param.string;
-					switch (expr.arguments.length) {
-						case 1:
-							if (expr.arguments[0].type === "SpreadElement") return;
-							arg1 = this.evaluateExpression(expr.arguments[0]);
-							if (!arg1.isNumber()) return;
-							result = str[fn](arg1.number);
-							break;
-						case 2: {
-							if (expr.arguments[0].type === "SpreadElement") return;
-							if (expr.arguments[1].type === "SpreadElement") return;
-							arg1 = this.evaluateExpression(expr.arguments[0]);
-							const arg2 = this.evaluateExpression(expr.arguments[1]);
-							if (!arg1.isNumber()) return;
-							if (!arg2.isNumber()) return;
-							result = str[fn](arg1.number, arg2.number);
-							break;
-						}
-						default:
-							return;
-					}
-					return new BasicEvaluatedExpression()
-						.setString(result)
-						.setSideEffects(param.couldHaveSideEffects())
-						.setRange(expr.range);
-				});
-		});
+class LocalModuleDependency extends NullDependency {
+	constructor(localModule, range, callNew) {
+		super();
 
-		/**
-		 * @param {"cooked" | "raw"} kind kind of values to get
-		 * @param {TemplateLiteralNode} templateLiteralExpr TemplateLiteral expr
-		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
-		 */
-		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
-			/** @type {BasicEvaluatedExpression[]} */
-			const quasis = [];
-			/** @type {BasicEvaluatedExpression[]} */
-			const parts = [];
+		this.localModule = localModule;
+		this.range = range;
+		this.callNew = callNew;
+	}
 
-			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
-				const quasiExpr = templateLiteralExpr.quasis[i];
-				const quasi = quasiExpr.value[kind];
+	serialize(context) {
+		const { write } = context;
 
-				if (i > 0) {
-					const prevExpr = parts[parts.length - 1];
-					const expr = this.evaluateExpression(
-						templateLiteralExpr.expressions[i - 1]
-					);
-					const exprAsString = expr.asString();
-					if (
-						typeof exprAsString === "string" &&
-						!expr.couldHaveSideEffects()
-					) {
-						// We can merge quasi + expr + quasi when expr
-						// is a const string
+		write(this.localModule);
+		write(this.range);
+		write(this.callNew);
 
-						prevExpr.setString(prevExpr.string + exprAsString + quasi);
-						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
-						// We unset the expression as it doesn't match to a single expression
-						prevExpr.setExpression(undefined);
-						continue;
-					}
-					parts.push(expr);
-				}
+		super.serialize(context);
+	}
 
-				const part = new BasicEvaluatedExpression()
-					.setString(quasi)
-					.setRange(quasiExpr.range)
-					.setExpression(quasiExpr);
-				quasis.push(part);
-				parts.push(part);
-			}
-			return {
-				quasis,
-				parts
-			};
-		};
+	deserialize(context) {
+		const { read } = context;
 
-		this.hooks.evaluate
-			.for("TemplateLiteral")
-			.tap("JavascriptParser", _node => {
-				const node = /** @type {TemplateLiteralNode} */ (_node);
+		this.localModule = read();
+		this.range = read();
+		this.callNew = read();
 
-				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
-				if (parts.length === 1) {
-					return parts[0].setRange(node.range);
-				}
-				return new BasicEvaluatedExpression()
-					.setTemplateString(quasis, parts, "cooked")
-					.setRange(node.range);
-			});
-		this.hooks.evaluate
-			.for("TaggedTemplateExpression")
-			.tap("JavascriptParser", _node => {
-				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
-				const tag = this.evaluateExpression(node.tag);
+		super.deserialize(context);
+	}
+}
 
-				if (tag.isIdentifier() && tag.identifier === "String.raw") {
-					const { quasis, parts } = getSimplifiedTemplateResult(
-						"raw",
-						node.quasi
-					);
-					return new BasicEvaluatedExpression()
-						.setTemplateString(quasis, parts, "raw")
-						.setRange(node.range);
-				}
-			});
+makeSerializable(
+	LocalModuleDependency,
+	"webpack/lib/dependencies/LocalModuleDependency"
+);
 
-		this.hooks.evaluateCallExpressionMember
-			.for("concat")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString() && !param.isWrapped()) return;
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {LocalModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const moduleInstance = dep.callNew
+			? `new (function () { return ${dep.localModule.variableName()}; })()`
+			: dep.localModule.variableName();
+		source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
+	}
+};
 
-				let stringSuffix = null;
-				let hasUnknownParams = false;
-				const innerExpressions = [];
-				for (let i = expr.arguments.length - 1; i >= 0; i--) {
-					const arg = expr.arguments[i];
-					if (arg.type === "SpreadElement") return;
-					const argExpr = this.evaluateExpression(arg);
-					if (
-						hasUnknownParams ||
-						(!argExpr.isString() && !argExpr.isNumber())
-					) {
-						hasUnknownParams = true;
-						innerExpressions.push(argExpr);
-						continue;
-					}
+module.exports = LocalModuleDependency;
 
-					const value = argExpr.isString()
-						? argExpr.string
-						: "" + argExpr.number;
 
-					const newString = value + (stringSuffix ? stringSuffix.string : "");
-					const newRange = [
-						argExpr.range[0],
-						(stringSuffix || argExpr).range[1]
-					];
-					stringSuffix = new BasicEvaluatedExpression()
-						.setString(newString)
-						.setSideEffects(
-							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
-								argExpr.couldHaveSideEffects()
-						)
-						.setRange(newRange);
-				}
+/***/ }),
 
-				if (hasUnknownParams) {
-					const prefix = param.isString() ? param : param.prefix;
-					const inner =
-						param.isWrapped() && param.wrappedInnerExpressions
-							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
-							: innerExpressions.reverse();
-					return new BasicEvaluatedExpression()
-						.setWrapped(prefix, stringSuffix, inner)
-						.setRange(expr.range);
-				} else if (param.isWrapped()) {
-					const postfix = stringSuffix || param.postfix;
-					const inner = param.wrappedInnerExpressions
-						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
-						: innerExpressions.reverse();
-					return new BasicEvaluatedExpression()
-						.setWrapped(param.prefix, postfix, inner)
-						.setRange(expr.range);
-				} else {
-					const newString =
-						param.string + (stringSuffix ? stringSuffix.string : "");
-					return new BasicEvaluatedExpression()
-						.setString(newString)
-						.setSideEffects(
-							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
-								param.couldHaveSideEffects()
-						)
-						.setRange(expr.range);
-				}
-			});
-		this.hooks.evaluateCallExpressionMember
-			.for("split")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString()) return;
-				if (expr.arguments.length !== 1) return;
-				if (expr.arguments[0].type === "SpreadElement") return;
-				let result;
-				const arg = this.evaluateExpression(expr.arguments[0]);
-				if (arg.isString()) {
-					result = param.string.split(arg.string);
-				} else if (arg.isRegExp()) {
-					result = param.string.split(arg.regExp);
-				} else {
-					return;
-				}
-				return new BasicEvaluatedExpression()
-					.setArray(result)
-					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
-			});
-		this.hooks.evaluate
-			.for("ConditionalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ConditionalExpressionNode} */ (_expr);
+/***/ 75827:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-				const condition = this.evaluateExpression(expr.test);
-				const conditionValue = condition.asBool();
-				let res;
-				if (conditionValue === undefined) {
-					const consequent = this.evaluateExpression(expr.consequent);
-					const alternate = this.evaluateExpression(expr.alternate);
-					if (!consequent || !alternate) return;
-					res = new BasicEvaluatedExpression();
-					if (consequent.isConditional()) {
-						res.setOptions(consequent.options);
-					} else {
-						res.setOptions([consequent]);
-					}
-					if (alternate.isConditional()) {
-						res.addOptions(alternate.options);
-					} else {
-						res.addOptions([alternate]);
-					}
-				} else {
-					res = this.evaluateExpression(
-						conditionValue ? expr.consequent : expr.alternate
-					);
-					if (condition.couldHaveSideEffects()) res.setSideEffects();
-				}
-				res.setRange(expr.range);
-				return res;
-			});
-		this.hooks.evaluate
-			.for("ArrayExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ArrayExpressionNode} */ (_expr);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				const items = expr.elements.map(element => {
-					return (
-						element !== null &&
-						element.type !== "SpreadElement" &&
-						this.evaluateExpression(element)
-					);
-				});
-				if (!items.every(Boolean)) return;
-				return new BasicEvaluatedExpression()
-					.setItems(items)
-					.setRange(expr.range);
-			});
-		this.hooks.evaluate
-			.for("ChainExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ChainExpressionNode} */ (_expr);
-				/** @type {ExpressionNode[]} */
-				const optionalExpressionsStack = [];
-				/** @type {ExpressionNode|SuperNode} */
-				let next = expr.expression;
 
-				while (
-					next.type === "MemberExpression" ||
-					next.type === "CallExpression"
-				) {
-					if (next.type === "MemberExpression") {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {ExpressionNode} */ (next.object)
-							);
-						}
-						next = next.object;
-					} else {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {ExpressionNode} */ (next.callee)
-							);
-						}
-						next = next.callee;
-					}
-				}
 
-				while (optionalExpressionsStack.length > 0) {
-					const expression = optionalExpressionsStack.pop();
-					const evaluated = this.evaluateExpression(expression);
+const LocalModule = __webpack_require__(5826);
+
+const lookup = (parent, mod) => {
+	if (mod.charAt(0) !== ".") return mod;
+
+	var path = parent.split("/");
+	var segments = mod.split("/");
+	path.pop();
+
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (seg === "..") {
+			path.pop();
+		} else if (seg !== ".") {
+			path.push(seg);
+		}
+	}
+
+	return path.join("/");
+};
+
+exports.addLocalModule = (state, name) => {
+	if (!state.localModules) {
+		state.localModules = [];
+	}
+	const m = new LocalModule(name, state.localModules.length);
+	state.localModules.push(m);
+	return m;
+};
+
+exports.getLocalModule = (state, name, namedModule) => {
+	if (!state.localModules) return null;
+	if (namedModule) {
+		// resolve dependency name relative to the defining named module
+		name = lookup(namedModule, name);
+	}
+	for (let i = 0; i < state.localModules.length; i++) {
+		if (state.localModules[i].name === name) {
+			return state.localModules[i];
+		}
+	}
+	return null;
+};
+
+
+/***/ }),
+
+/***/ 88488:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ModuleDecoratorDependency extends NullDependency {
+	/**
+	 * @param {string} decorator the decorator requirement
+	 * @param {boolean} allowExportsAccess allow to access exports from module
+	 */
+	constructor(decorator, allowExportsAccess) {
+		super();
+		this.decorator = decorator;
+		this.allowExportsAccess = allowExportsAccess;
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * @returns {string} a display name for the type of dependency
+	 */
+	get type() {
+		return "module decorator";
+	}
 
-					if (evaluated && evaluated.asNullish()) {
-						return evaluated.setRange(_expr.range);
-					}
-				}
-				return this.evaluateExpression(expr.expression);
-			});
+	get category() {
+		return "self";
 	}
 
-	getRenameIdentifier(expr) {
-		const result = this.evaluateExpression(expr);
-		if (result && result.isIdentifier()) {
-			return result.identifier;
-		}
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `self`;
 	}
 
 	/**
-	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return this.allowExportsAccess
+			? Dependency.EXPORTS_OBJECT_REFERENCED
+			: Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	walkClass(classy) {
-		if (classy.superClass) {
-			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
-				this.walkExpression(classy.superClass);
-			}
-		}
-		if (classy.body && classy.body.type === "ClassBody") {
-			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
-				if (!this.hooks.classBodyElement.call(classElement, classy)) {
-					if (classElement.computed && classElement.key) {
-						this.walkExpression(classElement.key);
-					}
-					if (classElement.value) {
-						if (
-							!this.hooks.classBodyValue.call(
-								classElement.value,
-								classElement,
-								classy
-							)
-						) {
-							const wasTopLevel = this.scope.topLevelScope;
-							this.scope.topLevelScope = false;
-							this.walkExpression(classElement.value);
-							this.scope.topLevelScope = wasTopLevel;
-						}
-					}
-				}
-			}
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
 		}
+		hash.update(this._hashUpdate);
 	}
 
-	// Pre walking iterates the scope for variable declarations
-	preWalkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
-			this.preWalkStatement(statement);
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.decorator);
+		write(this.allowExportsAccess);
+		super.serialize(context);
 	}
 
-	// Block pre walking iterates the scope for block variable declarations
-	blockPreWalkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
-			this.blockPreWalkStatement(statement);
-		}
+	deserialize(context) {
+		const { read } = context;
+		this.decorator = read();
+		this.allowExportsAccess = read();
+		super.deserialize(context);
 	}
+}
 
-	// Walking iterates the statements and expressions and processes them
-	walkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
-			this.walkStatement(statement);
-		}
+makeSerializable(
+	ModuleDecoratorDependency,
+	"webpack/lib/dependencies/ModuleDecoratorDependency"
+);
+
+ModuleDecoratorDependency.Template = class ModuleDecoratorDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ module, chunkGraph, initFragments, runtimeRequirements }
+	) {
+		const dep = /** @type {ModuleDecoratorDependency} */ (dependency);
+		runtimeRequirements.add(RuntimeGlobals.moduleLoaded);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(dep.decorator);
+		initFragments.push(
+			new InitFragment(
+				`/* module decorator */ ${module.moduleArgument} = ${dep.decorator}(${module.moduleArgument});\n`,
+				InitFragment.STAGE_PROVIDES,
+				0,
+				`module decorator ${chunkGraph.getModuleId(module)}`
+			)
+		);
 	}
+};
 
-	preWalkStatement(statement) {
-		this.statementPath.push(statement);
-		if (this.hooks.preStatement.call(statement)) {
-			this.prevStatement = this.statementPath.pop();
-			return;
-		}
-		switch (statement.type) {
-			case "BlockStatement":
-				this.preWalkBlockStatement(statement);
-				break;
-			case "DoWhileStatement":
-				this.preWalkDoWhileStatement(statement);
-				break;
-			case "ForInStatement":
-				this.preWalkForInStatement(statement);
-				break;
-			case "ForOfStatement":
-				this.preWalkForOfStatement(statement);
-				break;
-			case "ForStatement":
-				this.preWalkForStatement(statement);
-				break;
-			case "FunctionDeclaration":
-				this.preWalkFunctionDeclaration(statement);
-				break;
-			case "IfStatement":
-				this.preWalkIfStatement(statement);
-				break;
-			case "LabeledStatement":
-				this.preWalkLabeledStatement(statement);
-				break;
-			case "SwitchStatement":
-				this.preWalkSwitchStatement(statement);
-				break;
-			case "TryStatement":
-				this.preWalkTryStatement(statement);
-				break;
-			case "VariableDeclaration":
-				this.preWalkVariableDeclaration(statement);
-				break;
-			case "WhileStatement":
-				this.preWalkWhileStatement(statement);
-				break;
-			case "WithStatement":
-				this.preWalkWithStatement(statement);
-				break;
-		}
-		this.prevStatement = this.statementPath.pop();
+module.exports = ModuleDecoratorDependency;
+
+
+/***/ }),
+
+/***/ 80321:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const DependencyTemplate = __webpack_require__(5160);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../Module")} Module */
+
+const getRawModule = memoize(() => __webpack_require__(84929));
+
+class ModuleDependency extends Dependency {
+	/**
+	 * @param {string} request request path which needs resolving
+	 */
+	constructor(request) {
+		super();
+		this.request = request;
+		this.userRequest = request;
+		this.range = undefined;
+		// assertions must be serialized by subclasses that use it
+		/** @type {Record<string, any> | undefined} */
+		this.assertions = undefined;
 	}
 
-	blockPreWalkStatement(statement) {
-		this.statementPath.push(statement);
-		if (this.hooks.blockPreStatement.call(statement)) {
-			this.prevStatement = this.statementPath.pop();
-			return;
-		}
-		switch (statement.type) {
-			case "ImportDeclaration":
-				this.blockPreWalkImportDeclaration(statement);
-				break;
-			case "ExportAllDeclaration":
-				this.blockPreWalkExportAllDeclaration(statement);
-				break;
-			case "ExportDefaultDeclaration":
-				this.blockPreWalkExportDefaultDeclaration(statement);
-				break;
-			case "ExportNamedDeclaration":
-				this.blockPreWalkExportNamedDeclaration(statement);
-				break;
-			case "VariableDeclaration":
-				this.blockPreWalkVariableDeclaration(statement);
-				break;
-			case "ClassDeclaration":
-				this.blockPreWalkClassDeclaration(statement);
-				break;
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = `module${this.request}`;
+		if (this.assertions !== undefined) {
+			str += JSON.stringify(this.assertions);
 		}
-		this.prevStatement = this.statementPath.pop();
+		return str;
 	}
 
-	walkStatement(statement) {
-		this.statementPath.push(statement);
-		if (this.hooks.statement.call(statement) !== undefined) {
-			this.prevStatement = this.statementPath.pop();
-			return;
-		}
-		switch (statement.type) {
-			case "BlockStatement":
-				this.walkBlockStatement(statement);
-				break;
-			case "ClassDeclaration":
-				this.walkClassDeclaration(statement);
-				break;
-			case "DoWhileStatement":
-				this.walkDoWhileStatement(statement);
-				break;
-			case "ExportDefaultDeclaration":
-				this.walkExportDefaultDeclaration(statement);
-				break;
-			case "ExportNamedDeclaration":
-				this.walkExportNamedDeclaration(statement);
-				break;
-			case "ExpressionStatement":
-				this.walkExpressionStatement(statement);
-				break;
-			case "ForInStatement":
-				this.walkForInStatement(statement);
-				break;
-			case "ForOfStatement":
-				this.walkForOfStatement(statement);
-				break;
-			case "ForStatement":
-				this.walkForStatement(statement);
-				break;
-			case "FunctionDeclaration":
-				this.walkFunctionDeclaration(statement);
-				break;
-			case "IfStatement":
-				this.walkIfStatement(statement);
-				break;
-			case "LabeledStatement":
-				this.walkLabeledStatement(statement);
-				break;
-			case "ReturnStatement":
-				this.walkReturnStatement(statement);
-				break;
-			case "SwitchStatement":
-				this.walkSwitchStatement(statement);
-				break;
-			case "ThrowStatement":
-				this.walkThrowStatement(statement);
-				break;
-			case "TryStatement":
-				this.walkTryStatement(statement);
-				break;
-			case "VariableDeclaration":
-				this.walkVariableDeclaration(statement);
-				break;
-			case "WhileStatement":
-				this.walkWhileStatement(statement);
-				break;
-			case "WithStatement":
-				this.walkWithStatement(statement);
-				break;
-		}
-		this.prevStatement = this.statementPath.pop();
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
 	}
 
 	/**
-	 * Walks a statements that is nested within a parent statement
-	 * and can potentially be a non-block statement.
-	 * This enforces the nested statement to never be in ASI position.
-	 * @param {StatementNode} statement the nested statement
-	 * @returns {void}
+	 * @param {string} context context directory
+	 * @returns {Module} a module
 	 */
-	walkNestedStatement(statement) {
-		this.prevStatement = undefined;
-		this.walkStatement(statement);
+	createIgnoredModule(context) {
+		const RawModule = getRawModule();
+		return new RawModule(
+			"/* (ignored) */",
+			`ignored|${context}|${this.request}`,
+			`${this.request} (ignored)`
+		);
 	}
 
-	// Real Statements
-	preWalkBlockStatement(statement) {
-		this.preWalkStatements(statement.body);
+	serialize(context) {
+		const { write } = context;
+		write(this.request);
+		write(this.userRequest);
+		write(this.range);
+		super.serialize(context);
 	}
 
-	walkBlockStatement(statement) {
-		this.inBlockScope(() => {
-			const body = statement.body;
-			const prev = this.prevStatement;
-			this.blockPreWalkStatements(body);
-			this.prevStatement = prev;
-			this.walkStatements(body);
+	deserialize(context) {
+		const { read } = context;
+		this.request = read();
+		this.userRequest = read();
+		this.range = read();
+		super.deserialize(context);
+	}
+}
+
+ModuleDependency.Template = DependencyTemplate;
+
+module.exports = ModuleDependency;
+
+
+/***/ }),
+
+/***/ 80825:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph }) {
+		const dep = /** @type {ModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const content = runtimeTemplate.moduleId({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+}
+
+module.exports = ModuleDependencyTemplateAsId;
+
+
+/***/ }),
+
+/***/ 36873:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const content = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
 		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
+}
+module.exports = ModuleDependencyTemplateAsRequireId;
+
+
+/***/ }),
+
+/***/ 47511:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-	walkExpressionStatement(statement) {
-		this.walkExpression(statement.expression);
+class ModuleHotAcceptDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
 	}
 
-	preWalkIfStatement(statement) {
-		this.preWalkStatement(statement.consequent);
-		if (statement.alternate) {
-			this.preWalkStatement(statement.alternate);
-		}
+	get type() {
+		return "module.hot.accept";
 	}
 
-	walkIfStatement(statement) {
-		const result = this.hooks.statementIf.call(statement);
-		if (result === undefined) {
-			this.walkExpression(statement.test);
-			this.walkNestedStatement(statement.consequent);
-			if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
-		} else {
-			if (result) {
-				this.walkNestedStatement(statement.consequent);
-			} else if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
-		}
+	get category() {
+		return "commonjs";
 	}
+}
 
-	preWalkLabeledStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
+makeSerializable(
+	ModuleHotAcceptDependency,
+	"webpack/lib/dependencies/ModuleHotAcceptDependency"
+);
 
-	walkLabeledStatement(statement) {
-		const hook = this.hooks.label.get(statement.label.name);
-		if (hook !== undefined) {
-			const result = hook.call(statement);
-			if (result === true) return;
-		}
-		this.walkNestedStatement(statement.body);
-	}
+ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
 
-	preWalkWithStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
+module.exports = ModuleHotAcceptDependency;
 
-	walkWithStatement(statement) {
-		this.walkExpression(statement.object);
-		this.walkNestedStatement(statement.body);
-	}
 
-	preWalkSwitchStatement(statement) {
-		this.preWalkSwitchCases(statement.cases);
-	}
+/***/ }),
 
-	walkSwitchStatement(statement) {
-		this.walkExpression(statement.discriminant);
-		this.walkSwitchCases(statement.cases);
-	}
+/***/ 86301:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkTerminatingStatement(statement) {
-		if (statement.argument) this.walkExpression(statement.argument);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	walkReturnStatement(statement) {
-		this.walkTerminatingStatement(statement);
-	}
 
-	walkThrowStatement(statement) {
-		this.walkTerminatingStatement(statement);
-	}
 
-	preWalkTryStatement(statement) {
-		this.preWalkStatement(statement.block);
-		if (statement.handler) this.preWalkCatchClause(statement.handler);
-		if (statement.finializer) this.preWalkStatement(statement.finializer);
-	}
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-	walkTryStatement(statement) {
-		if (this.scope.inTry) {
-			this.walkStatement(statement.block);
-		} else {
-			this.scope.inTry = true;
-			this.walkStatement(statement.block);
-			this.scope.inTry = false;
-		}
-		if (statement.handler) this.walkCatchClause(statement.handler);
-		if (statement.finalizer) this.walkStatement(statement.finalizer);
+class ModuleHotDeclineDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
+		this.weak = true;
 	}
 
-	preWalkWhileStatement(statement) {
-		this.preWalkStatement(statement.body);
+	get type() {
+		return "module.hot.decline";
 	}
 
-	walkWhileStatement(statement) {
-		this.walkExpression(statement.test);
-		this.walkNestedStatement(statement.body);
+	get category() {
+		return "commonjs";
 	}
+}
 
-	preWalkDoWhileStatement(statement) {
-		this.preWalkStatement(statement.body);
+makeSerializable(
+	ModuleHotDeclineDependency,
+	"webpack/lib/dependencies/ModuleHotDeclineDependency"
+);
+
+ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotDeclineDependency;
+
+
+/***/ }),
+
+/***/ 31830:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const DependencyTemplate = __webpack_require__(5160);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class NullDependency extends Dependency {
+	get type() {
+		return "null";
 	}
 
-	walkDoWhileStatement(statement) {
-		this.walkNestedStatement(statement.body);
-		this.walkExpression(statement.test);
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return false;
 	}
+}
 
-	preWalkForStatement(statement) {
-		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration") {
-				this.preWalkStatement(statement.init);
-			}
-		}
-		this.preWalkStatement(statement.body);
+NullDependency.Template = class NullDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {}
+};
+
+module.exports = NullDependency;
+
+
+/***/ }),
+
+/***/ 31618:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleDependency = __webpack_require__(80321);
+
+class PrefetchDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
 
-	walkForStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.init) {
-				if (statement.init.type === "VariableDeclaration") {
-					this.blockPreWalkVariableDeclaration(statement.init);
-					this.prevStatement = undefined;
-					this.walkStatement(statement.init);
-				} else {
-					this.walkExpression(statement.init);
-				}
-			}
-			if (statement.test) {
-				this.walkExpression(statement.test);
-			}
-			if (statement.update) {
-				this.walkExpression(statement.update);
-			}
-			const body = statement.body;
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
+	get type() {
+		return "prefetch";
 	}
 
-	preWalkForInStatement(statement) {
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
-		}
-		this.preWalkStatement(statement.body);
+	get category() {
+		return "esm";
 	}
+}
 
-	walkForInStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.left.type === "VariableDeclaration") {
-				this.blockPreWalkVariableDeclaration(statement.left);
-				this.walkVariableDeclaration(statement.left);
-			} else {
-				this.walkPattern(statement.left);
-			}
-			this.walkExpression(statement.right);
-			const body = statement.body;
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
+module.exports = PrefetchDependency;
+
+
+/***/ }),
+
+/***/ 95770:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+
+
+const InitFragment = __webpack_require__(55870);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
+
+/**
+ * @param {string[]|null} path the property path array
+ * @returns {string} the converted path
+ */
+const pathToString = path =>
+	path !== null && path.length > 0
+		? path.map(part => `[${JSON.stringify(part)}]`).join("")
+		: "";
+
+class ProvidedDependency extends ModuleDependency {
+	constructor(request, identifier, path, range) {
+		super(request);
+		this.identifier = identifier;
+		this.path = path;
+		this.range = range;
+		this._hashUpdate = undefined;
 	}
 
-	preWalkForOfStatement(statement) {
-		if (statement.await && this.scope.topLevelScope === true) {
-			this.hooks.topLevelAwait.call(statement);
-		}
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
-		}
-		this.preWalkStatement(statement.body);
+	get type() {
+		return "provided";
 	}
 
-	walkForOfStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.left.type === "VariableDeclaration") {
-				this.blockPreWalkVariableDeclaration(statement.left);
-				this.walkVariableDeclaration(statement.left);
-			} else {
-				this.walkPattern(statement.left);
-			}
-			this.walkExpression(statement.right);
-			const body = statement.body;
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
+	get category() {
+		return "esm";
 	}
 
-	// Declarations
-	preWalkFunctionDeclaration(statement) {
-		if (statement.id) {
-			this.defineVariable(statement.id.name);
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate =
+				this.identifier + (this.path ? this.path.join(",") : "null");
 		}
+		hash.update(this._hashUpdate);
 	}
 
-	walkFunctionDeclaration(statement) {
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = false;
-		this.inFunctionScope(true, statement.params, () => {
-			for (const param of statement.params) {
-				this.walkPattern(param);
-			}
-			if (statement.body.type === "BlockStatement") {
-				this.detectMode(statement.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.body);
-				this.prevStatement = prev;
-				this.walkStatement(statement.body);
-			} else {
-				this.walkExpression(statement.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
+	serialize(context) {
+		const { write } = context;
+		write(this.identifier);
+		write(this.path);
+		super.serialize(context);
 	}
 
-	blockPreWalkImportDeclaration(statement) {
-		const source = statement.source.value;
-		this.hooks.import.call(statement, source);
-		for (const specifier of statement.specifiers) {
-			const name = specifier.local.name;
-			switch (specifier.type) {
-				case "ImportDefaultSpecifier":
-					if (
-						!this.hooks.importSpecifier.call(statement, source, "default", name)
-					) {
-						this.defineVariable(name);
-					}
-					break;
-				case "ImportSpecifier":
-					if (
-						!this.hooks.importSpecifier.call(
-							statement,
-							source,
-							specifier.imported.name,
-							name
-						)
-					) {
-						this.defineVariable(name);
-					}
-					break;
-				case "ImportNamespaceSpecifier":
-					if (!this.hooks.importSpecifier.call(statement, source, null, name)) {
-						this.defineVariable(name);
-					}
-					break;
-				default:
-					this.defineVariable(name);
-			}
-		}
+	deserialize(context) {
+		const { read } = context;
+		this.identifier = read();
+		this.path = read();
+		super.deserialize(context);
 	}
+}
 
-	enterDeclaration(declaration, onIdent) {
-		switch (declaration.type) {
-			case "VariableDeclaration":
-				for (const declarator of declaration.declarations) {
-					switch (declarator.type) {
-						case "VariableDeclarator": {
-							this.enterPattern(declarator.id, onIdent);
-							break;
-						}
-					}
-				}
-				break;
-			case "FunctionDeclaration":
-				this.enterPattern(declaration.id, onIdent);
-				break;
-			case "ClassDeclaration":
-				this.enterPattern(declaration.id, onIdent);
-				break;
-		}
-	}
+makeSerializable(
+	ProvidedDependency,
+	"webpack/lib/dependencies/ProvidedDependency"
+);
 
-	blockPreWalkExportNamedDeclaration(statement) {
-		let source;
-		if (statement.source) {
-			source = statement.source.value;
-			this.hooks.exportImport.call(statement, source);
-		} else {
-			this.hooks.export.call(statement);
-		}
-		if (statement.declaration) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.declaration);
-				this.prevStatement = prev;
-				this.blockPreWalkStatement(statement.declaration);
-				let index = 0;
-				this.enterDeclaration(statement.declaration, def => {
-					this.hooks.exportSpecifier.call(statement, def, def, index++);
-				});
-			}
-		}
-		if (statement.specifiers) {
-			for (
-				let specifierIndex = 0;
-				specifierIndex < statement.specifiers.length;
-				specifierIndex++
-			) {
-				const specifier = statement.specifiers[specifierIndex];
-				switch (specifier.type) {
-					case "ExportSpecifier": {
-						const name = specifier.exported.name;
-						if (source) {
-							this.hooks.exportImportSpecifier.call(
-								statement,
-								source,
-								specifier.local.name,
-								name,
-								specifierIndex
-							);
-						} else {
-							this.hooks.exportSpecifier.call(
-								statement,
-								specifier.local.name,
-								name,
-								specifierIndex
-							);
-						}
-						break;
-					}
-				}
-			}
+class ProvidedDependencyTemplate extends ModuleDependency.Template {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			initFragments,
+			runtimeRequirements
 		}
+	) {
+		const dep = /** @type {ProvidedDependency} */ (dependency);
+		initFragments.push(
+			new InitFragment(
+				`/* provided dependency */ var ${
+					dep.identifier
+				} = ${runtimeTemplate.moduleExports({
+					module: moduleGraph.getModule(dep),
+					chunkGraph,
+					request: dep.request,
+					runtimeRequirements
+				})}${pathToString(dep.path)};\n`,
+				InitFragment.STAGE_PROVIDES,
+				1,
+				`provided ${dep.identifier}`
+			)
+		);
+		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
+}
 
-	walkExportNamedDeclaration(statement) {
-		if (statement.declaration) {
-			this.walkStatement(statement.declaration);
-		}
-	}
+ProvidedDependency.Template = ProvidedDependencyTemplate;
 
-	blockPreWalkExportDefaultDeclaration(statement) {
-		const prev = this.prevStatement;
-		this.preWalkStatement(statement.declaration);
-		this.prevStatement = prev;
-		this.blockPreWalkStatement(statement.declaration);
-		if (
-			statement.declaration.id &&
-			statement.declaration.type !== "FunctionExpression" &&
-			statement.declaration.type !== "ClassExpression"
-		) {
-			this.hooks.exportSpecifier.call(
-				statement,
-				statement.declaration.id.name,
-				"default",
-				undefined
-			);
-		}
+module.exports = ProvidedDependency;
+
+
+/***/ }),
+
+/***/ 55799:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { UsageState } = __webpack_require__(63686);
+const makeSerializable = __webpack_require__(33032);
+const { filterRuntime } = __webpack_require__(17156);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+
+class PureExpressionDependency extends NullDependency {
+	/**
+	 * @param {[number, number]} range the source range
+	 */
+	constructor(range) {
+		super();
+		this.range = range;
+		/** @type {Set<string> | false} */
+		this.usedByExports = false;
+		this._hashUpdate = undefined;
 	}
 
-	walkExportDefaultDeclaration(statement) {
-		this.hooks.export.call(statement);
-		if (
-			statement.declaration.id &&
-			statement.declaration.type !== "FunctionExpression" &&
-			statement.declaration.type !== "ClassExpression"
-		) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				this.walkStatement(statement.declaration);
-			}
-		} else {
-			// Acorn parses `export default function() {}` as `FunctionDeclaration` and
-			// `export default class {}` as `ClassDeclaration`, both with `id = null`.
-			// These nodes must be treated as expressions.
-			if (
-				statement.declaration.type === "FunctionDeclaration" ||
-				statement.declaration.type === "ClassDeclaration"
-			) {
-				this.walkStatement(statement.declaration);
-			} else {
-				this.walkExpression(statement.declaration);
-			}
-			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
-				this.hooks.exportSpecifier.call(
-					statement,
-					statement.declaration,
-					"default",
-					undefined
-				);
-			}
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.range + "";
 		}
+		hash.update(this._hashUpdate);
 	}
 
-	blockPreWalkExportAllDeclaration(statement) {
-		const source = statement.source.value;
-		const name = statement.exported ? statement.exported.name : null;
-		this.hooks.exportImport.call(statement, source);
-		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
-	preWalkVariableDeclaration(statement) {
-		if (statement.kind !== "var") return;
-		this._preWalkVariableDeclaration(statement, this.hooks.varDeclarationVar);
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.usedByExports);
+		super.serialize(context);
 	}
 
-	blockPreWalkVariableDeclaration(statement) {
-		if (statement.kind === "var") return;
-		const hookMap =
-			statement.kind === "const"
-				? this.hooks.varDeclarationConst
-				: this.hooks.varDeclarationLet;
-		this._preWalkVariableDeclaration(statement, hookMap);
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.usedByExports = read();
+		super.deserialize(context);
 	}
+}
 
-	_preWalkVariableDeclaration(statement, hookMap) {
-		for (const declarator of statement.declarations) {
-			switch (declarator.type) {
-				case "VariableDeclarator": {
-					if (!this.hooks.preDeclarator.call(declarator, statement)) {
-						this.enterPattern(declarator.id, (name, decl) => {
-							let hook = hookMap.get(name);
-							if (hook === undefined || !hook.call(decl)) {
-								hook = this.hooks.varDeclaration.get(name);
-								if (hook === undefined || !hook.call(decl)) {
-									this.defineVariable(name);
-								}
-							}
-						});
+makeSerializable(
+	PureExpressionDependency,
+	"webpack/lib/dependencies/PureExpressionDependency"
+);
+
+PureExpressionDependency.Template = class PureExpressionDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+	) {
+		const dep = /** @type {PureExpressionDependency} */ (dependency);
+
+		const usedByExports = dep.usedByExports;
+		if (usedByExports !== false) {
+			const selfModule = moduleGraph.getParentModule(dep);
+			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+			const runtimeCondition = filterRuntime(runtime, runtime => {
+				for (const exportName of usedByExports) {
+					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+						return true;
 					}
-					break;
 				}
+				return false;
+			});
+			if (runtimeCondition === true) return;
+			if (runtimeCondition !== false) {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				source.insert(
+					dep.range[0],
+					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
+				);
+				source.insert(dep.range[1], ") : null)");
+				return;
 			}
 		}
+
+		source.insert(
+			dep.range[0],
+			`(/* unused pure expression or super */ null && (`
+		);
+		source.insert(dep.range[1], "))");
 	}
+};
 
-	walkVariableDeclaration(statement) {
-		for (const declarator of statement.declarations) {
-			switch (declarator.type) {
-				case "VariableDeclarator": {
-					const renameIdentifier =
-						declarator.init && this.getRenameIdentifier(declarator.init);
-					if (renameIdentifier && declarator.id.type === "Identifier") {
-						const hook = this.hooks.canRename.get(renameIdentifier);
-						if (hook !== undefined && hook.call(declarator.init)) {
-							// renaming with "var a = b;"
-							const hook = this.hooks.rename.get(renameIdentifier);
-							if (hook === undefined || !hook.call(declarator.init)) {
-								this.setVariable(declarator.id.name, renameIdentifier);
-							}
-							break;
-						}
-					}
-					if (!this.hooks.declarator.call(declarator, statement)) {
-						this.walkPattern(declarator.id);
-						if (declarator.init) this.walkExpression(declarator.init);
-					}
-					break;
-				}
-			}
-		}
+module.exports = PureExpressionDependency;
+
+
+/***/ }),
+
+/***/ 46917:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const ContextDependency = __webpack_require__(88101);
+const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
+
+class RequireContextDependency extends ContextDependency {
+	constructor(options, range) {
+		super(options);
+
+		this.range = range;
 	}
 
-	blockPreWalkClassDeclaration(statement) {
-		if (statement.id) {
-			this.defineVariable(statement.id.name);
-		}
+	get type() {
+		return "require.context";
 	}
 
-	walkClassDeclaration(statement) {
-		this.walkClass(statement);
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+
+		super.serialize(context);
 	}
 
-	preWalkSwitchCases(switchCases) {
-		for (let index = 0, len = switchCases.length; index < len; index++) {
-			const switchCase = switchCases[index];
-			this.preWalkStatements(switchCase.consequent);
-		}
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+
+		super.deserialize(context);
 	}
+}
 
-	walkSwitchCases(switchCases) {
-		this.inBlockScope(() => {
-			const len = switchCases.length;
+makeSerializable(
+	RequireContextDependency,
+	"webpack/lib/dependencies/RequireContextDependency"
+);
 
-			// we need to pre walk all statements first since we can have invalid code
-			// import A from "module";
-			// switch(1) {
-			//    case 1:
-			//      console.log(A); // should fail at runtime
-			//    case 2:
-			//      const A = 1;
-			// }
-			for (let index = 0; index < len; index++) {
-				const switchCase = switchCases[index];
+RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
 
-				if (switchCase.consequent.length > 0) {
-					const prev = this.prevStatement;
-					this.blockPreWalkStatements(switchCase.consequent);
-					this.prevStatement = prev;
-				}
-			}
+module.exports = RequireContextDependency;
 
-			for (let index = 0; index < len; index++) {
-				const switchCase = switchCases[index];
 
-				if (switchCase.test) {
-					this.walkExpression(switchCase.test);
-				}
-				if (switchCase.consequent.length > 0) {
-					this.walkStatements(switchCase.consequent);
+/***/ }),
+
+/***/ 18851:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RequireContextDependency = __webpack_require__(46917);
+
+module.exports = class RequireContextDependencyParserPlugin {
+	apply(parser) {
+		parser.hooks.call
+			.for("require.context")
+			.tap("RequireContextDependencyParserPlugin", expr => {
+				let regExp = /^\.\/.*$/;
+				let recursive = true;
+				let mode = "sync";
+				switch (expr.arguments.length) {
+					case 4: {
+						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+						if (!modeExpr.isString()) return;
+						mode = modeExpr.string;
+					}
+					// falls through
+					case 3: {
+						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+						if (!regExpExpr.isRegExp()) return;
+						regExp = regExpExpr.regExp;
+					}
+					// falls through
+					case 2: {
+						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+						if (!recursiveExpr.isBoolean()) return;
+						recursive = recursiveExpr.bool;
+					}
+					// falls through
+					case 1: {
+						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+						if (!requestExpr.isString()) return;
+						const dep = new RequireContextDependency(
+							{
+								request: requestExpr.string,
+								recursive,
+								regExp,
+								mode,
+								category: "commonjs"
+							},
+							expr.range
+						);
+						dep.loc = expr.loc;
+						dep.optional = !!parser.scope.inTry;
+						parser.state.current.addDependency(dep);
+						return true;
+					}
 				}
-			}
-		});
+			});
 	}
+};
 
-	preWalkCatchClause(catchClause) {
-		this.preWalkStatement(catchClause.body);
-	}
 
-	walkCatchClause(catchClause) {
-		this.inBlockScope(() => {
-			// Error binding is optional in catch clause since ECMAScript 2019
-			if (catchClause.param !== null) {
-				this.enterPattern(catchClause.param, ident => {
-					this.defineVariable(ident);
-				});
-				this.walkPattern(catchClause.param);
-			}
-			const prev = this.prevStatement;
-			this.blockPreWalkStatement(catchClause.body);
-			this.prevStatement = prev;
-			this.walkStatement(catchClause.body);
-		});
-	}
+/***/ }),
 
-	walkPattern(pattern) {
-		switch (pattern.type) {
-			case "ArrayPattern":
-				this.walkArrayPattern(pattern);
-				break;
-			case "AssignmentPattern":
-				this.walkAssignmentPattern(pattern);
-				break;
-			case "MemberExpression":
-				this.walkMemberExpression(pattern);
-				break;
-			case "ObjectPattern":
-				this.walkObjectPattern(pattern);
-				break;
-			case "RestElement":
-				this.walkRestElement(pattern);
-				break;
-		}
-	}
+/***/ 2928:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { cachedSetProperty } = __webpack_require__(60839);
+const ContextElementDependency = __webpack_require__(58477);
+const RequireContextDependency = __webpack_require__(46917);
+const RequireContextDependencyParserPlugin = __webpack_require__(18851);
+
+/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../Compiler")} Compiler */
+
+/** @type {ResolveOptions} */
+const EMPTY_RESOLVE_OPTIONS = {};
+
+class RequireContextPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireContextPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireContextDependency,
+					new RequireContextDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					ContextElementDependency,
+					normalModuleFactory
+				);
+
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireContext !== undefined &&
+						!parserOptions.requireContext
+					)
+						return;
+
+					new RequireContextDependencyParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireContextPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireContextPlugin", handler);
+
+				contextModuleFactory.hooks.alternativeRequests.tap(
+					"RequireContextPlugin",
+					(items, options) => {
+						if (items.length === 0) return items;
+
+						const finalResolveOptions = compiler.resolverFactory.get(
+							"normal",
+							cachedSetProperty(
+								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
+								"dependencyType",
+								options.category
+							)
+						).options;
+
+						let newItems;
+						if (!finalResolveOptions.fullySpecified) {
+							newItems = [];
+							for (const item of items) {
+								const { request, context } = item;
+								for (const ext of finalResolveOptions.extensions) {
+									if (request.endsWith(ext)) {
+										newItems.push({
+											context,
+											request: request.slice(0, -ext.length)
+										});
+									}
+								}
+								if (!finalResolveOptions.enforceExtension) {
+									newItems.push(item);
+								}
+							}
+							items = newItems;
 
-	walkAssignmentPattern(pattern) {
-		this.walkExpression(pattern.right);
-		this.walkPattern(pattern.left);
-	}
+							newItems = [];
+							for (const obj of items) {
+								const { request, context } = obj;
+								for (const mainFile of finalResolveOptions.mainFiles) {
+									if (request.endsWith(`/${mainFile}`)) {
+										newItems.push({
+											context,
+											request: request.slice(0, -mainFile.length)
+										});
+										newItems.push({
+											context,
+											request: request.slice(0, -mainFile.length - 1)
+										});
+									}
+								}
+								newItems.push(obj);
+							}
+							items = newItems;
+						}
 
-	walkObjectPattern(pattern) {
-		for (let i = 0, len = pattern.properties.length; i < len; i++) {
-			const prop = pattern.properties[i];
-			if (prop) {
-				if (prop.computed) this.walkExpression(prop.key);
-				if (prop.value) this.walkPattern(prop.value);
+						newItems = [];
+						for (const item of items) {
+							let hideOriginal = false;
+							for (const modulesItems of finalResolveOptions.modules) {
+								if (Array.isArray(modulesItems)) {
+									for (const dir of modulesItems) {
+										if (item.request.startsWith(`./${dir}/`)) {
+											newItems.push({
+												context: item.context,
+												request: item.request.slice(dir.length + 3)
+											});
+											hideOriginal = true;
+										}
+									}
+								} else {
+									const dir = modulesItems.replace(/\\/g, "/");
+									const fullPath =
+										item.context.replace(/\\/g, "/") + item.request.slice(1);
+									if (fullPath.startsWith(dir)) {
+										newItems.push({
+											context: item.context,
+											request: fullPath.slice(dir.length + 1)
+										});
+									}
+								}
+							}
+							if (!hideOriginal) {
+								newItems.push(item);
+							}
+						}
+						return newItems;
+					}
+				);
 			}
-		}
+		);
 	}
+}
+module.exports = RequireContextPlugin;
 
-	walkArrayPattern(pattern) {
-		for (let i = 0, len = pattern.elements.length; i < len; i++) {
-			const element = pattern.elements[i];
-			if (element) this.walkPattern(element);
-		}
-	}
 
-	walkRestElement(pattern) {
-		this.walkPattern(pattern.argument);
-	}
+/***/ }),
 
-	walkExpressions(expressions) {
-		for (const expression of expressions) {
-			if (expression) {
-				this.walkExpression(expression);
-			}
-		}
-	}
+/***/ 27153:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkExpression(expression) {
-		switch (expression.type) {
-			case "ArrayExpression":
-				this.walkArrayExpression(expression);
-				break;
-			case "ArrowFunctionExpression":
-				this.walkArrowFunctionExpression(expression);
-				break;
-			case "AssignmentExpression":
-				this.walkAssignmentExpression(expression);
-				break;
-			case "AwaitExpression":
-				this.walkAwaitExpression(expression);
-				break;
-			case "BinaryExpression":
-				this.walkBinaryExpression(expression);
-				break;
-			case "CallExpression":
-				this.walkCallExpression(expression);
-				break;
-			case "ChainExpression":
-				this.walkChainExpression(expression);
-				break;
-			case "ClassExpression":
-				this.walkClassExpression(expression);
-				break;
-			case "ConditionalExpression":
-				this.walkConditionalExpression(expression);
-				break;
-			case "FunctionExpression":
-				this.walkFunctionExpression(expression);
-				break;
-			case "Identifier":
-				this.walkIdentifier(expression);
-				break;
-			case "ImportExpression":
-				this.walkImportExpression(expression);
-				break;
-			case "LogicalExpression":
-				this.walkLogicalExpression(expression);
-				break;
-			case "MetaProperty":
-				this.walkMetaProperty(expression);
-				break;
-			case "MemberExpression":
-				this.walkMemberExpression(expression);
-				break;
-			case "NewExpression":
-				this.walkNewExpression(expression);
-				break;
-			case "ObjectExpression":
-				this.walkObjectExpression(expression);
-				break;
-			case "SequenceExpression":
-				this.walkSequenceExpression(expression);
-				break;
-			case "SpreadElement":
-				this.walkSpreadElement(expression);
-				break;
-			case "TaggedTemplateExpression":
-				this.walkTaggedTemplateExpression(expression);
-				break;
-			case "TemplateLiteral":
-				this.walkTemplateLiteral(expression);
-				break;
-			case "ThisExpression":
-				this.walkThisExpression(expression);
-				break;
-			case "UnaryExpression":
-				this.walkUnaryExpression(expression);
-				break;
-			case "UpdateExpression":
-				this.walkUpdateExpression(expression);
-				break;
-			case "YieldExpression":
-				this.walkYieldExpression(expression);
-				break;
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	walkAwaitExpression(expression) {
-		if (this.scope.topLevelScope === true)
-			this.hooks.topLevelAwait.call(expression);
-		this.walkExpression(expression.argument);
-	}
 
-	walkArrayExpression(expression) {
-		if (expression.elements) {
-			this.walkExpressions(expression.elements);
-		}
-	}
 
-	walkSpreadElement(expression) {
-		if (expression.argument) {
-			this.walkExpression(expression.argument);
-		}
-	}
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const makeSerializable = __webpack_require__(33032);
 
-	walkObjectExpression(expression) {
-		for (
-			let propIndex = 0, len = expression.properties.length;
-			propIndex < len;
-			propIndex++
-		) {
-			const prop = expression.properties[propIndex];
-			this.walkProperty(prop);
-		}
+class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(chunkName, loc) {
+		super(chunkName, loc, null);
 	}
+}
 
-	walkProperty(prop) {
-		if (prop.type === "SpreadElement") {
-			this.walkExpression(prop.argument);
-			return;
-		}
-		if (prop.computed) {
-			this.walkExpression(prop.key);
-		}
-		if (prop.shorthand && prop.value && prop.value.type === "Identifier") {
-			this.scope.inShorthand = prop.value.name;
-			this.walkIdentifier(prop.value);
-			this.scope.inShorthand = false;
-		} else {
-			this.walkExpression(prop.value);
-		}
-	}
+makeSerializable(
+	RequireEnsureDependenciesBlock,
+	"webpack/lib/dependencies/RequireEnsureDependenciesBlock"
+);
 
-	walkFunctionExpression(expression) {
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = false;
-		const scopeParams = expression.params;
+module.exports = RequireEnsureDependenciesBlock;
 
-		// Add function name in scope for recursive calls
-		if (expression.id) {
-			scopeParams.push(expression.id.name);
-		}
 
-		this.inFunctionScope(true, scopeParams, () => {
-			for (const param of expression.params) {
-				this.walkPattern(param);
-			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
-	}
+/***/ }),
 
-	walkArrowFunctionExpression(expression) {
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
-		this.inFunctionScope(false, expression.params, () => {
-			for (const param of expression.params) {
-				this.walkPattern(param);
-			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
-	}
+/***/ 7235:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {SequenceExpressionNode} expression the sequence
-	 */
-	walkSequenceExpression(expression) {
-		if (!expression.expressions) return;
-		// We treat sequence expressions like statements when they are one statement level
-		// This has some benefits for optimizations that only work on statement level
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
-		if (
-			currentStatement === expression ||
-			(currentStatement.type === "ExpressionStatement" &&
-				currentStatement.expression === expression)
-		) {
-			const old = this.statementPath.pop();
-			for (const expr of expression.expressions) {
-				this.statementPath.push(expr);
-				this.walkExpression(expr);
-				this.statementPath.pop();
-			}
-			this.statementPath.push(old);
-		} else {
-			this.walkExpressions(expression.expressions);
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	walkUpdateExpression(expression) {
-		this.walkExpression(expression.argument);
-	}
 
-	walkUnaryExpression(expression) {
-		if (expression.operator === "typeof") {
-			const result = this.callHooksForExpression(
-				this.hooks.typeof,
-				expression.argument,
-				expression
-			);
-			if (result === true) return;
-			if (expression.argument.type === "ChainExpression") {
-				const result = this.callHooksForExpression(
-					this.hooks.typeof,
-					expression.argument.expression,
-					expression
-				);
-				if (result === true) return;
-			}
-		}
-		this.walkExpression(expression.argument);
-	}
 
-	walkLeftRightExpression(expression) {
-		this.walkExpression(expression.left);
-		this.walkExpression(expression.right);
-	}
+const RequireEnsureDependenciesBlock = __webpack_require__(27153);
+const RequireEnsureDependency = __webpack_require__(27223);
+const RequireEnsureItemDependency = __webpack_require__(50329);
+const getFunctionExpression = __webpack_require__(50396);
 
-	walkBinaryExpression(expression) {
-		this.walkLeftRightExpression(expression);
-	}
+module.exports = class RequireEnsureDependenciesBlockParserPlugin {
+	apply(parser) {
+		parser.hooks.call
+			.for("require.ensure")
+			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
+				let chunkName = null;
+				let errorExpressionArg = null;
+				let errorExpression = null;
+				switch (expr.arguments.length) {
+					case 4: {
+						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+						if (!chunkNameExpr.isString()) return;
+						chunkName = chunkNameExpr.string;
+					}
+					// falls through
+					case 3: {
+						errorExpressionArg = expr.arguments[2];
+						errorExpression = getFunctionExpression(errorExpressionArg);
 
-	walkLogicalExpression(expression) {
-		const result = this.hooks.expressionLogicalOperator.call(expression);
-		if (result === undefined) {
-			this.walkLeftRightExpression(expression);
-		} else {
-			if (result) {
-				this.walkExpression(expression.right);
-			}
-		}
-	}
+						if (!errorExpression && !chunkName) {
+							const chunkNameExpr = parser.evaluateExpression(
+								expr.arguments[2]
+							);
+							if (!chunkNameExpr.isString()) return;
+							chunkName = chunkNameExpr.string;
+						}
+					}
+					// falls through
+					case 2: {
+						const dependenciesExpr = parser.evaluateExpression(
+							expr.arguments[0]
+						);
+						const dependenciesItems = dependenciesExpr.isArray()
+							? dependenciesExpr.items
+							: [dependenciesExpr];
+						const successExpressionArg = expr.arguments[1];
+						const successExpression =
+							getFunctionExpression(successExpressionArg);
 
-	walkAssignmentExpression(expression) {
-		if (expression.left.type === "Identifier") {
-			const renameIdentifier = this.getRenameIdentifier(expression.right);
-			if (renameIdentifier) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
-						renameIdentifier,
-						expression.right
-					)
-				) {
-					// renaming "a = b;"
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							expression.right
-						)
-					) {
-						this.setVariable(
-							expression.left.name,
-							this.getVariableInfo(renameIdentifier)
+						if (successExpression) {
+							parser.walkExpressions(successExpression.expressions);
+						}
+						if (errorExpression) {
+							parser.walkExpressions(errorExpression.expressions);
+						}
+
+						const depBlock = new RequireEnsureDependenciesBlock(
+							chunkName,
+							expr.loc
 						);
+						const errorCallbackExists =
+							expr.arguments.length === 4 ||
+							(!chunkName && expr.arguments.length === 3);
+						const dep = new RequireEnsureDependency(
+							expr.range,
+							expr.arguments[1].range,
+							errorCallbackExists && expr.arguments[2].range
+						);
+						dep.loc = expr.loc;
+						depBlock.addDependency(dep);
+						const old = parser.state.current;
+						parser.state.current = depBlock;
+						try {
+							let failed = false;
+							parser.inScope([], () => {
+								for (const ee of dependenciesItems) {
+									if (ee.isString()) {
+										const ensureDependency = new RequireEnsureItemDependency(
+											ee.string
+										);
+										ensureDependency.loc = ee.loc || expr.loc;
+										depBlock.addDependency(ensureDependency);
+									} else {
+										failed = true;
+									}
+								}
+							});
+							if (failed) {
+								return;
+							}
+							if (successExpression) {
+								if (successExpression.fn.body.type === "BlockStatement") {
+									parser.walkStatement(successExpression.fn.body);
+								} else {
+									parser.walkExpression(successExpression.fn.body);
+								}
+							}
+							old.addBlock(depBlock);
+						} finally {
+							parser.state.current = old;
+						}
+						if (!successExpression) {
+							parser.walkExpression(successExpressionArg);
+						}
+						if (errorExpression) {
+							if (errorExpression.fn.body.type === "BlockStatement") {
+								parser.walkStatement(errorExpression.fn.body);
+							} else {
+								parser.walkExpression(errorExpression.fn.body);
+							}
+						} else if (errorExpressionArg) {
+							parser.walkExpression(errorExpressionArg);
+						}
+						return true;
 					}
-					return;
-				}
-			}
-			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
-				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.walkExpression(expression.left);
-				}
-			});
-			return;
-		}
-		if (expression.left.type.endsWith("Pattern")) {
-			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
-				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.defineVariable(name);
-				}
-			});
-			this.walkPattern(expression.left);
-		} else if (expression.left.type === "MemberExpression") {
-			const exprName = this.getMemberExpressionInfo(
-				expression.left,
-				ALLOWED_MEMBER_TYPES_EXPRESSION
-			);
-			if (exprName) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.assignMemberChain,
-						exprName.rootInfo,
-						expression,
-						exprName.getMembers()
-					)
-				) {
-					return;
-				}
-			}
-			this.walkExpression(expression.right);
-			this.walkExpression(expression.left);
-		} else {
-			this.walkExpression(expression.right);
-			this.walkExpression(expression.left);
-		}
+				}
+			});
 	}
+};
 
-	walkConditionalExpression(expression) {
-		const result = this.hooks.expressionConditionalOperator.call(expression);
-		if (result === undefined) {
-			this.walkExpression(expression.test);
-			this.walkExpression(expression.consequent);
-			if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
-		} else {
-			if (result) {
-				this.walkExpression(expression.consequent);
-			} else if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
-		}
-	}
 
-	walkNewExpression(expression) {
-		const result = this.callHooksForExpression(
-			this.hooks.new,
-			expression.callee,
-			expression
-		);
-		if (result === true) return;
-		this.walkExpression(expression.callee);
-		if (expression.arguments) {
-			this.walkExpressions(expression.arguments);
-		}
-	}
+/***/ }),
 
-	walkYieldExpression(expression) {
-		if (expression.argument) {
-			this.walkExpression(expression.argument);
-		}
-	}
+/***/ 27223:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkTemplateLiteral(expression) {
-		if (expression.expressions) {
-			this.walkExpressions(expression.expressions);
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	walkTaggedTemplateExpression(expression) {
-		if (expression.tag) {
-			this.walkExpression(expression.tag);
-		}
-		if (expression.quasi && expression.quasi.expressions) {
-			this.walkExpressions(expression.quasi.expressions);
-		}
-	}
 
-	walkClassExpression(expression) {
-		this.walkClass(expression);
-	}
 
-	/**
-	 * @param {ChainExpressionNode} expression expression
-	 */
-	walkChainExpression(expression) {
-		const result = this.hooks.optionalChaining.call(expression);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-		if (result === undefined) {
-			if (expression.expression.type === "CallExpression") {
-				this.walkCallExpression(expression.expression);
-			} else {
-				this.walkMemberExpression(expression.expression);
-			}
-		}
-	}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-	_walkIIFE(functionExpression, options, currentThis) {
-		const getVarInfo = argOrThis => {
-			const renameIdentifier = this.getRenameIdentifier(argOrThis);
-			if (renameIdentifier) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
-						renameIdentifier,
-						argOrThis
-					)
-				) {
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							argOrThis
-						)
-					) {
-						return this.getVariableInfo(renameIdentifier);
-					}
-				}
-			}
-			this.walkExpression(argOrThis);
-		};
-		const { params, type } = functionExpression;
-		const arrow = type === "ArrowFunctionExpression";
-		const renameThis = currentThis ? getVarInfo(currentThis) : null;
-		const varInfoForArgs = options.map(getVarInfo);
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = wasTopLevel && arrow ? "arrow" : false;
-		const scopeParams = params.filter(
-			(identifier, idx) => !varInfoForArgs[idx]
-		);
+class RequireEnsureDependency extends NullDependency {
+	constructor(range, contentRange, errorHandlerRange) {
+		super();
 
-		// Add function name in scope for recursive calls
-		if (functionExpression.id) {
-			scopeParams.push(functionExpression.id.name);
-		}
+		this.range = range;
+		this.contentRange = contentRange;
+		this.errorHandlerRange = errorHandlerRange;
+	}
 
-		this.inFunctionScope(true, scopeParams, () => {
-			if (renameThis && !arrow) {
-				this.setVariable("this", renameThis);
-			}
-			for (let i = 0; i < varInfoForArgs.length; i++) {
-				const varInfo = varInfoForArgs[i];
-				if (!varInfo) continue;
-				if (!params[i] || params[i].type !== "Identifier") continue;
-				this.setVariable(params[i].name, varInfo);
-			}
-			if (functionExpression.body.type === "BlockStatement") {
-				this.detectMode(functionExpression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(functionExpression.body);
-				this.prevStatement = prev;
-				this.walkStatement(functionExpression.body);
-			} else {
-				this.walkExpression(functionExpression.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
+	get type() {
+		return "require.ensure";
 	}
 
-	walkImportExpression(expression) {
-		let result = this.hooks.importCall.call(expression);
-		if (result === true) return;
+	serialize(context) {
+		const { write } = context;
 
-		this.walkExpression(expression.source);
+		write(this.range);
+		write(this.contentRange);
+		write(this.errorHandlerRange);
+
+		super.serialize(context);
 	}
 
-	walkCallExpression(expression) {
-		const isSimpleFunction = fn => {
-			return fn.params.every(p => p.type === "Identifier");
-		};
-		if (
-			expression.callee.type === "MemberExpression" &&
-			expression.callee.object.type.endsWith("FunctionExpression") &&
-			!expression.callee.computed &&
-			(expression.callee.property.name === "call" ||
-				expression.callee.property.name === "bind") &&
-			expression.arguments.length > 0 &&
-			isSimpleFunction(expression.callee.object)
-		) {
-			// (function(…) { }.call/bind(?, …))
-			this._walkIIFE(
-				expression.callee.object,
-				expression.arguments.slice(1),
-				expression.arguments[0]
-			);
-		} else if (
-			expression.callee.type.endsWith("FunctionExpression") &&
-			isSimpleFunction(expression.callee)
-		) {
-			// (function(…) { }(…))
-			this._walkIIFE(expression.callee, expression.arguments, null);
-		} else {
-			if (expression.callee.type === "MemberExpression") {
-				const exprInfo = this.getMemberExpressionInfo(
-					expression.callee,
-					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
-				);
-				if (exprInfo && exprInfo.type === "call") {
-					const result = this.callHooksForInfo(
-						this.hooks.callMemberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers()
-					);
-					if (result === true) return;
-				}
-			}
-			const callee = this.evaluateExpression(expression.callee);
-			if (callee.isIdentifier()) {
-				const result1 = this.callHooksForInfo(
-					this.hooks.callMemberChain,
-					callee.rootInfo,
-					expression,
-					callee.getMembers()
-				);
-				if (result1 === true) return;
-				const result2 = this.callHooksForInfo(
-					this.hooks.call,
-					callee.identifier,
-					expression
-				);
-				if (result2 === true) return;
-			}
+	deserialize(context) {
+		const { read } = context;
 
-			if (expression.callee) {
-				if (expression.callee.type === "MemberExpression") {
-					// because of call context we need to walk the call context as expression
-					this.walkExpression(expression.callee.object);
-					if (expression.callee.computed === true)
-						this.walkExpression(expression.callee.property);
-				} else {
-					this.walkExpression(expression.callee);
-				}
-			}
-			if (expression.arguments) this.walkExpressions(expression.arguments);
-		}
-	}
+		this.range = read();
+		this.contentRange = read();
+		this.errorHandlerRange = read();
 
-	walkMemberExpression(expression) {
-		const exprInfo = this.getMemberExpressionInfo(
-			expression,
-			ALLOWED_MEMBER_TYPES_ALL
-		);
-		if (exprInfo) {
-			switch (exprInfo.type) {
-				case "expression": {
-					const result1 = this.callHooksForInfo(
-						this.hooks.expression,
-						exprInfo.name,
-						expression
-					);
-					if (result1 === true) return;
-					const members = exprInfo.getMembers();
-					const result2 = this.callHooksForInfo(
-						this.hooks.expressionMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						members
-					);
-					if (result2 === true) return;
-					this.walkMemberExpressionWithExpressionName(
-						expression,
-						exprInfo.name,
-						exprInfo.rootInfo,
-						members.slice(),
-						() =>
-							this.callHooksForInfo(
-								this.hooks.unhandledExpressionMemberChain,
-								exprInfo.rootInfo,
-								expression,
-								members
-							)
-					);
-					return;
-				}
-				case "call": {
-					const result = this.callHooksForInfo(
-						this.hooks.memberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers()
-					);
-					if (result === true) return;
-					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
-					// and call computed property are literals anyway
-					this.walkExpression(exprInfo.call);
-					return;
-				}
-			}
-		}
-		this.walkExpression(expression.object);
-		if (expression.computed === true) this.walkExpression(expression.property);
+		super.deserialize(context);
 	}
+}
 
-	walkMemberExpressionWithExpressionName(
-		expression,
-		name,
-		rootInfo,
-		members,
-		onUnhandled
+makeSerializable(
+	RequireEnsureDependency,
+	"webpack/lib/dependencies/RequireEnsureDependency"
+);
+
+RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
-		if (expression.object.type === "MemberExpression") {
-			// optimize the case where expression.object is a MemberExpression too.
-			// we can keep info here when calling walkMemberExpression directly
-			const property =
-				expression.property.name || `${expression.property.value}`;
-			name = name.slice(0, -property.length - 1);
-			members.pop();
-			const result = this.callHooksForInfo(
-				this.hooks.expression,
-				name,
-				expression.object
+		const dep = /** @type {RequireEnsureDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block: depBlock,
+			message: "require.ensure",
+			runtimeRequirements
+		});
+		const range = dep.range;
+		const contentRange = dep.contentRange;
+		const errorHandlerRange = dep.errorHandlerRange;
+		source.replace(range[0], contentRange[0] - 1, `${promise}.then((`);
+		if (errorHandlerRange) {
+			source.replace(
+				contentRange[1],
+				errorHandlerRange[0] - 1,
+				").bind(null, __webpack_require__))['catch']("
 			);
-			if (result === true) return;
-			this.walkMemberExpressionWithExpressionName(
-				expression.object,
-				name,
-				rootInfo,
-				members,
-				onUnhandled
+			source.replace(errorHandlerRange[1], range[1] - 1, ")");
+		} else {
+			source.replace(
+				contentRange[1],
+				range[1] - 1,
+				`).bind(null, __webpack_require__))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`
 			);
-		} else if (!onUnhandled || !onUnhandled()) {
-			this.walkExpression(expression.object);
 		}
-		if (expression.computed === true) this.walkExpression(expression.property);
 	}
+};
 
-	walkThisExpression(expression) {
-		this.callHooksForName(this.hooks.expression, "this", expression);
-	}
+module.exports = RequireEnsureDependency;
 
-	walkIdentifier(expression) {
-		this.callHooksForName(this.hooks.expression, expression.name, expression);
-	}
 
-	/**
-	 * @param {MetaPropertyNode} metaProperty meta property
-	 */
-	walkMetaProperty(metaProperty) {
-		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
+/***/ }),
+
+/***/ 50329:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const NullDependency = __webpack_require__(31830);
+
+class RequireEnsureItemDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
 
-	callHooksForExpression(hookMap, expr, ...args) {
-		return this.callHooksForExpressionWithFallback(
-			hookMap,
-			expr,
-			undefined,
-			undefined,
-			...args
-		);
+	get type() {
+		return "require.ensure item";
 	}
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {MemberExpressionNode} expr expression info
-	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
-	 * @param {function(string): any} defined callback when variable is defined
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForExpressionWithFallback(
-		hookMap,
-		expr,
-		fallback,
-		defined,
-		...args
-	) {
-		const exprName = this.getMemberExpressionInfo(
-			expr,
-			ALLOWED_MEMBER_TYPES_EXPRESSION
-		);
-		if (exprName !== undefined) {
-			const members = exprName.getMembers();
-			return this.callHooksForInfoWithFallback(
-				hookMap,
-				members.length === 0 ? exprName.rootInfo : exprName.name,
-				fallback &&
-					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
-				defined && (() => defined(exprName.name)),
-				...args
-			);
-		}
+	get category() {
+		return "commonjs";
 	}
+}
+
+makeSerializable(
+	RequireEnsureItemDependency,
+	"webpack/lib/dependencies/RequireEnsureItemDependency"
+);
+
+RequireEnsureItemDependency.Template = NullDependency.Template;
+
+module.exports = RequireEnsureItemDependency;
+
+
+/***/ }),
+
+/***/ 8434:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RequireEnsureDependency = __webpack_require__(27223);
+const RequireEnsureItemDependency = __webpack_require__(50329);
+
+const RequireEnsureDependenciesBlockParserPlugin = __webpack_require__(7235);
+
+const {
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
+
+class RequireEnsurePlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireEnsurePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireEnsureItemDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireEnsureItemDependency,
+					new RequireEnsureItemDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					RequireEnsureDependency,
+					new RequireEnsureDependency.Template()
+				);
+
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireEnsure !== undefined &&
+						!parserOptions.requireEnsure
+					)
+						return;
+
+					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);
+					parser.hooks.evaluateTypeof
+						.for("require.ensure")
+						.tap("RequireEnsurePlugin", evaluateToString("function"));
+					parser.hooks.typeof
+						.for("require.ensure")
+						.tap(
+							"RequireEnsurePlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {string} name key in map
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForName(hookMap, name, ...args) {
-		return this.callHooksForNameWithFallback(
-			hookMap,
-			name,
-			undefined,
-			undefined,
-			...args
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireEnsurePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireEnsurePlugin", handler);
+			}
 		);
 	}
+}
+module.exports = RequireEnsurePlugin;
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
-	 * @param {ExportedVariableInfo} info variable info
-	 * @param  {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForInfo(hookMap, info, ...args) {
-		return this.callHooksForInfoWithFallback(
-			hookMap,
-			info,
-			undefined,
-			undefined,
-			...args
-		);
+
+/***/ }),
+
+/***/ 89183:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class RequireHeaderDependency extends NullDependency {
+	constructor(range) {
+		super();
+		if (!Array.isArray(range)) throw new Error("range must be valid");
+		this.range = range;
 	}
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {ExportedVariableInfo} info variable info
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
-		let name;
-		if (typeof info === "string") {
-			name = info;
-		} else {
-			if (!(info instanceof VariableInfo)) {
-				if (defined !== undefined) {
-					return defined();
-				}
-				return;
-			}
-			let tagInfo = info.tagInfo;
-			while (tagInfo !== undefined) {
-				const hook = hookMap.get(tagInfo.tag);
-				if (hook !== undefined) {
-					this.currentTagData = tagInfo.data;
-					const result = hook.call(...args);
-					this.currentTagData = undefined;
-					if (result !== undefined) return result;
-				}
-				tagInfo = tagInfo.next;
-			}
-			if (info.freeName === true) {
-				if (defined !== undefined) {
-					return defined();
-				}
-				return;
-			}
-			name = info.freeName;
-		}
-		const hook = hookMap.get(name);
-		if (hook !== undefined) {
-			const result = hook.call(...args);
-			if (result !== undefined) return result;
-		}
-		if (fallback !== undefined) {
-			return fallback(name);
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
 	}
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {string} name key in map
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
-		return this.callHooksForInfoWithFallback(
-			hookMap,
-			this.getVariableInfo(name),
-			fallback,
-			defined,
-			...args
-		);
+	static deserialize(context) {
+		const obj = new RequireHeaderDependency(context.read());
+		obj.deserialize(context);
+		return obj;
 	}
+}
+
+makeSerializable(
+	RequireHeaderDependency,
+	"webpack/lib/dependencies/RequireHeaderDependency"
+);
 
+RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @deprecated
-	 * @param {any} params scope params
-	 * @param {function(): void} fn inner function
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	inScope(params, fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: false,
-			inShorthand: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			definitions: oldScope.definitions.createChild()
-		};
-
-		this.undefineVariable("this");
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {RequireHeaderDependency} */ (dependency);
+		runtimeRequirements.add(RuntimeGlobals.require);
+		source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__");
+	}
+};
 
-		this.enterPatterns(params, (ident, pattern) => {
-			this.defineVariable(ident);
-		});
+module.exports = RequireHeaderDependency;
 
-		fn();
 
-		this.scope = oldScope;
-	}
+/***/ }),
 
-	inFunctionScope(hasThis, params, fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: false,
-			inShorthand: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			definitions: oldScope.definitions.createChild()
-		};
+/***/ 71284:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (hasThis) {
-			this.undefineVariable("this");
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		this.enterPatterns(params, (ident, pattern) => {
-			this.defineVariable(ident);
-		});
 
-		fn();
 
-		this.scope = oldScope;
-	}
+const Dependency = __webpack_require__(54912);
+const Template = __webpack_require__(39722);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-	inBlockScope(fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: oldScope.inTry,
-			inShorthand: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			definitions: oldScope.definitions.createChild()
-		};
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-		fn();
+class RequireIncludeDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
 
-		this.scope = oldScope;
+		this.range = range;
 	}
 
-	detectMode(statements) {
-		const isLiteral =
-			statements.length >= 1 &&
-			statements[0].type === "ExpressionStatement" &&
-			statements[0].expression.type === "Literal";
-		if (isLiteral && statements[0].expression.value === "use strict") {
-			this.scope.isStrict = true;
-		}
-		if (isLiteral && statements[0].expression.value === "use asm") {
-			this.scope.isAsmJs = true;
-		}
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
 
-	enterPatterns(patterns, onIdent) {
-		for (const pattern of patterns) {
-			if (typeof pattern !== "string") {
-				this.enterPattern(pattern, onIdent);
-			} else if (pattern) {
-				onIdent(pattern);
-			}
-		}
+	get type() {
+		return "require.include";
 	}
 
-	enterPattern(pattern, onIdent) {
-		if (!pattern) return;
-		switch (pattern.type) {
-			case "ArrayPattern":
-				this.enterArrayPattern(pattern, onIdent);
-				break;
-			case "AssignmentPattern":
-				this.enterAssignmentPattern(pattern, onIdent);
-				break;
-			case "Identifier":
-				this.enterIdentifier(pattern, onIdent);
-				break;
-			case "ObjectPattern":
-				this.enterObjectPattern(pattern, onIdent);
-				break;
-			case "RestElement":
-				this.enterRestElement(pattern, onIdent);
-				break;
-			case "Property":
-				if (pattern.shorthand && pattern.value.type === "Identifier") {
-					this.scope.inShorthand = pattern.value.name;
-					this.enterIdentifier(pattern.value, onIdent);
-					this.scope.inShorthand = false;
-				} else {
-					this.enterPattern(pattern.value, onIdent);
-				}
-				break;
-		}
+	get category() {
+		return "commonjs";
 	}
+}
 
-	enterIdentifier(pattern, onIdent) {
-		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
-			onIdent(pattern.name, pattern);
-		}
-	}
+makeSerializable(
+	RequireIncludeDependency,
+	"webpack/lib/dependencies/RequireIncludeDependency"
+);
 
-	enterObjectPattern(pattern, onIdent) {
-		for (
-			let propIndex = 0, len = pattern.properties.length;
-			propIndex < len;
-			propIndex++
-		) {
-			const prop = pattern.properties[propIndex];
-			this.enterPattern(prop, onIdent);
-		}
-	}
+RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeTemplate }) {
+		const dep = /** @type {RequireIncludeDependency} */ (dependency);
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`require.include ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
+			  )
+			: "";
 
-	enterArrayPattern(pattern, onIdent) {
-		for (
-			let elementIndex = 0, len = pattern.elements.length;
-			elementIndex < len;
-			elementIndex++
-		) {
-			const element = pattern.elements[elementIndex];
-			this.enterPattern(element, onIdent);
-		}
+		source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`);
 	}
+};
 
-	enterRestElement(pattern, onIdent) {
-		this.enterPattern(pattern.argument, onIdent);
-	}
+module.exports = RequireIncludeDependency;
 
-	enterAssignmentPattern(pattern, onIdent) {
-		this.enterPattern(pattern.left, onIdent);
-	}
 
-	/**
-	 * @param {ExpressionNode} expression expression node
-	 * @returns {BasicEvaluatedExpression | undefined} evaluation result
-	 */
-	evaluateExpression(expression) {
-		try {
-			const hook = this.hooks.evaluate.get(expression.type);
-			if (hook !== undefined) {
-				const result = hook.call(expression);
-				if (result !== undefined) {
-					if (result) {
-						result.setExpression(expression);
-					}
-					return result;
-				}
-			}
-		} catch (e) {
-			console.warn(e);
-			// ignore error
-		}
-		return new BasicEvaluatedExpression()
-			.setRange(expression.range)
-			.setExpression(expression);
+/***/ }),
+
+/***/ 35768:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const {
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
+const makeSerializable = __webpack_require__(33032);
+const RequireIncludeDependency = __webpack_require__(71284);
+
+module.exports = class RequireIncludeDependencyParserPlugin {
+	constructor(warn) {
+		this.warn = warn;
 	}
+	apply(parser) {
+		const { warn } = this;
+		parser.hooks.call
+			.for("require.include")
+			.tap("RequireIncludeDependencyParserPlugin", expr => {
+				if (expr.arguments.length !== 1) return;
+				const param = parser.evaluateExpression(expr.arguments[0]);
+				if (!param.isString()) return;
 
-	parseString(expression) {
-		switch (expression.type) {
-			case "BinaryExpression":
-				if (expression.operator === "+") {
-					return (
-						this.parseString(expression.left) +
-						this.parseString(expression.right)
+				if (warn) {
+					parser.state.module.addWarning(
+						new RequireIncludeDeprecationWarning(expr.loc)
 					);
 				}
-				break;
-			case "Literal":
-				return expression.value + "";
-		}
-		throw new Error(
-			expression.type + " is not supported as parameter for require"
-		);
-	}
 
-	parseCalculatedString(expression) {
-		switch (expression.type) {
-			case "BinaryExpression":
-				if (expression.operator === "+") {
-					const left = this.parseCalculatedString(expression.left);
-					const right = this.parseCalculatedString(expression.right);
-					if (left.code) {
-						return {
-							range: left.range,
-							value: left.value,
-							code: true,
-							conditional: false
-						};
-					} else if (right.code) {
-						return {
-							range: [
-								left.range[0],
-								right.range ? right.range[1] : left.range[1]
-							],
-							value: left.value + right.value,
-							code: true,
-							conditional: false
-						};
-					} else {
-						return {
-							range: [left.range[0], right.range[1]],
-							value: left.value + right.value,
-							code: false,
-							conditional: false
-						};
-					}
-				}
-				break;
-			case "ConditionalExpression": {
-				const consequent = this.parseCalculatedString(expression.consequent);
-				const alternate = this.parseCalculatedString(expression.alternate);
-				const items = [];
-				if (consequent.conditional) {
-					items.push(...consequent.conditional);
-				} else if (!consequent.code) {
-					items.push(consequent);
-				} else {
-					break;
+				const dep = new RequireIncludeDependency(param.string, expr.range);
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
+			});
+		parser.hooks.evaluateTypeof
+			.for("require.include")
+			.tap("RequireIncludePlugin", expr => {
+				if (warn) {
+					parser.state.module.addWarning(
+						new RequireIncludeDeprecationWarning(expr.loc)
+					);
 				}
-				if (alternate.conditional) {
-					items.push(...alternate.conditional);
-				} else if (!alternate.code) {
-					items.push(alternate);
-				} else {
-					break;
+				return evaluateToString("function")(expr);
+			});
+		parser.hooks.typeof
+			.for("require.include")
+			.tap("RequireIncludePlugin", expr => {
+				if (warn) {
+					parser.state.module.addWarning(
+						new RequireIncludeDeprecationWarning(expr.loc)
+					);
 				}
-				return {
-					range: undefined,
-					value: "",
-					code: true,
-					conditional: items
-				};
-			}
-			case "Literal":
-				return {
-					range: expression.range,
-					value: expression.value + "",
-					code: false,
-					conditional: false
-				};
-		}
-		return {
-			range: undefined,
-			value: "",
-			code: true,
-			conditional: false
-		};
+				return toConstantDependency(parser, JSON.stringify("function"))(expr);
+			});
 	}
+};
 
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		let ast;
-		let comments;
-		const semicolons = new Set();
-		if (source === null) {
-			throw new Error("source must not be null");
-		}
-		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
-		}
-		if (typeof source === "object") {
-			ast = /** @type {ProgramNode} */ (source);
-			comments = source.comments;
-		} else {
-			comments = [];
-			ast = JavascriptParser._parse(source, {
-				sourceType: this.sourceType,
-				onComment: comments,
-				onInsertedSemicolon: pos => semicolons.add(pos)
-			});
-		}
+class RequireIncludeDeprecationWarning extends WebpackError {
+	constructor(loc) {
+		super("require.include() is deprecated and will be removed soon.");
 
-		const oldScope = this.scope;
-		const oldState = this.state;
-		const oldComments = this.comments;
-		const oldSemicolons = this.semicolons;
-		const oldStatementPath = this.statementPath;
-		const oldPrevStatement = this.prevStatement;
-		this.scope = {
-			topLevelScope: true,
-			inTry: false,
-			inShorthand: false,
-			isStrict: false,
-			isAsmJs: false,
-			definitions: new StackedMap()
-		};
-		/** @type {ParserState} */
-		this.state = state;
-		this.comments = comments;
-		this.semicolons = semicolons;
-		this.statementPath = [];
-		this.prevStatement = undefined;
-		if (this.hooks.program.call(ast, comments) === undefined) {
-			this.detectMode(ast.body);
-			this.preWalkStatements(ast.body);
-			this.prevStatement = undefined;
-			this.blockPreWalkStatements(ast.body);
-			this.prevStatement = undefined;
-			this.walkStatements(ast.body);
-		}
-		this.hooks.finish.call(ast, comments);
-		this.scope = oldScope;
-		/** @type {ParserState} */
-		this.state = oldState;
-		this.comments = oldComments;
-		this.semicolons = oldSemicolons;
-		this.statementPath = oldStatementPath;
-		this.prevStatement = oldPrevStatement;
-		return state;
-	}
+		this.name = "RequireIncludeDeprecationWarning";
 
-	evaluate(source) {
-		const ast = JavascriptParser._parse("(" + source + ")", {
-			sourceType: this.sourceType,
-			locations: false
-		});
-		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
-			throw new Error("evaluate: Source is not a expression");
-		}
-		return this.evaluateExpression(ast.body[0].expression);
+		this.loc = loc;
 	}
+}
 
-	/**
-	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
-	 * @param {number} commentsStartPos source position from which annotation comments are checked
-	 * @returns {boolean} true, when the expression is pure
-	 */
-	isPure(expr, commentsStartPos) {
-		if (!expr) return true;
-		const result = this.hooks.isPure
-			.for(expr.type)
-			.call(expr, commentsStartPos);
-		if (typeof result === "boolean") return result;
-		switch (expr.type) {
-			case "ClassDeclaration":
-			case "ClassExpression": {
-				if (expr.body.type !== "ClassBody") return false;
-				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
-					return false;
-				}
-				const items =
-					/** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (
-						expr.body.body
-					);
-				return items.every(
-					item =>
-						(!item.computed ||
-							!item.key ||
-							this.isPure(item.key, item.range[0])) &&
-						(!item.static ||
-							!item.value ||
-							this.isPure(
-								item.value,
-								item.key ? item.key.range[1] : item.range[0]
-							))
-				);
-			}
+makeSerializable(
+	RequireIncludeDeprecationWarning,
+	"webpack/lib/dependencies/RequireIncludeDependencyParserPlugin",
+	"RequireIncludeDeprecationWarning"
+);
 
-			case "FunctionDeclaration":
-			case "FunctionExpression":
-			case "ArrowFunctionExpression":
-			case "Literal":
-			case "PrivateIdentifier":
-				return true;
 
-			case "VariableDeclaration":
-				return expr.declarations.every(decl =>
-					this.isPure(decl.init, decl.range[0])
-				);
+/***/ }),
 
-			case "ConditionalExpression":
-				return (
-					this.isPure(expr.test, commentsStartPos) &&
-					this.isPure(expr.consequent, expr.test.range[1]) &&
-					this.isPure(expr.alternate, expr.consequent.range[1])
+/***/ 37378:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RequireIncludeDependency = __webpack_require__(71284);
+const RequireIncludeDependencyParserPlugin = __webpack_require__(35768);
+
+class RequireIncludePlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireIncludePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireIncludeDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireIncludeDependency,
+					new RequireIncludeDependency.Template()
 				);
 
-			case "SequenceExpression":
-				return expr.expressions.every(expr => {
-					const pureFlag = this.isPure(expr, commentsStartPos);
-					commentsStartPos = expr.range[1];
-					return pureFlag;
-				});
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.requireInclude === false) return;
+					const warn = parserOptions.requireInclude === undefined;
 
-			case "CallExpression": {
-				const pureFlag =
-					expr.range[0] - commentsStartPos > 12 &&
-					this.getComments([commentsStartPos, expr.range[0]]).some(
-						comment =>
-							comment.type === "Block" &&
-							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
-					);
-				if (!pureFlag) return false;
-				commentsStartPos = expr.callee.range[1];
-				return expr.arguments.every(arg => {
-					if (arg.type === "SpreadElement") return false;
-					const pureFlag = this.isPure(arg, commentsStartPos);
-					commentsStartPos = arg.range[1];
-					return pureFlag;
-				});
+					new RequireIncludeDependencyParserPlugin(warn).apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireIncludePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireIncludePlugin", handler);
 			}
-		}
-		const evaluated = this.evaluateExpression(expr);
-		return !evaluated.couldHaveSideEffects();
+		);
 	}
+}
+module.exports = RequireIncludePlugin;
 
-	getComments(range) {
-		const [rangeStart, rangeEnd] = range;
-		const compare = (comment, needle) => comment.range[0] - needle;
-		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
-		let commentsInRange = [];
-		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
-			commentsInRange.push(this.comments[idx]);
-			idx++;
-		}
 
-		return commentsInRange;
-	}
+/***/ }),
 
-	/**
-	 * @param {number} pos source code position
-	 * @returns {boolean} true when a semicolon has been inserted before this position, false if not
-	 */
-	isAsiPosition(pos) {
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
-		if (currentStatement === undefined) throw new Error("Not in statement");
-		return (
-			// Either asking directly for the end position of the current statement
-			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
-			// Or asking for the start position of the current statement,
-			// here we have to check multiple things
-			(currentStatement.range[0] === pos &&
-				// is there a previous statement which might be relevant?
-				this.prevStatement !== undefined &&
-				// is the end position of the previous statement an ASI position?
-				this.semicolons.has(this.prevStatement.range[1]))
-		);
-	}
+/***/ 55627:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {number} pos source code position
-	 * @returns {void}
-	 */
-	unsetAsiPosition(pos) {
-		this.semicolons.delete(pos);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	isStatementLevelExpression(expr) {
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
-		return (
-			expr === currentStatement ||
-			(currentStatement.type === "ExpressionStatement" &&
-				currentStatement.expression === expr)
-		);
+
+
+const makeSerializable = __webpack_require__(33032);
+const ContextDependency = __webpack_require__(88101);
+const ContextDependencyTemplateAsId = __webpack_require__(76081);
+
+class RequireResolveContextDependency extends ContextDependency {
+	constructor(options, range, valueRange) {
+		super(options);
+
+		this.range = range;
+		this.valueRange = valueRange;
 	}
 
-	getTagData(name, tag) {
-		const info = this.scope.definitions.get(name);
-		if (info instanceof VariableInfo) {
-			let tagInfo = info.tagInfo;
-			while (tagInfo !== undefined) {
-				if (tagInfo.tag === tag) return tagInfo.data;
-				tagInfo = tagInfo.next;
-			}
-		}
+	get type() {
+		return "amd require context";
 	}
 
-	tagVariable(name, tag, data) {
-		const oldInfo = this.scope.definitions.get(name);
-		/** @type {VariableInfo} */
-		let newInfo;
-		if (oldInfo === undefined) {
-			newInfo = new VariableInfo(this.scope, name, {
-				tag,
-				data,
-				next: undefined
-			});
-		} else if (oldInfo instanceof VariableInfo) {
-			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
-				tag,
-				data,
-				next: oldInfo.tagInfo
-			});
-		} else {
-			newInfo = new VariableInfo(oldInfo, true, {
-				tag,
-				data,
-				next: undefined
-			});
-		}
-		this.scope.definitions.set(name, newInfo);
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+		write(this.valueRange);
+
+		super.serialize(context);
 	}
 
-	defineVariable(name) {
-		const oldInfo = this.scope.definitions.get(name);
-		// Don't redefine variable in same scope to keep existing tags
-		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
-			return;
-		this.scope.definitions.set(name, this.scope);
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+		this.valueRange = read();
+
+		super.deserialize(context);
 	}
+}
 
-	undefineVariable(name) {
-		this.scope.definitions.delete(name);
+makeSerializable(
+	RequireResolveContextDependency,
+	"webpack/lib/dependencies/RequireResolveContextDependency"
+);
+
+RequireResolveContextDependency.Template = ContextDependencyTemplateAsId;
+
+module.exports = RequireResolveContextDependency;
+
+
+/***/ }),
+
+/***/ 68582:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyAsId = __webpack_require__(80825);
+
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class RequireResolveDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
 	}
 
-	isVariableDefined(name) {
-		const info = this.scope.definitions.get(name);
-		if (info === undefined) return false;
-		if (info instanceof VariableInfo) {
-			return info.freeName === true;
-		}
-		return true;
+	get type() {
+		return "require.resolve";
 	}
 
-	/**
-	 * @param {string} name variable name
-	 * @returns {ExportedVariableInfo} info for this variable
-	 */
-	getVariableInfo(name) {
-		const value = this.scope.definitions.get(name);
-		if (value === undefined) {
-			return name;
-		} else {
-			return value;
-		}
+	get category() {
+		return "commonjs";
 	}
 
 	/**
-	 * @param {string} name variable name
-	 * @param {ExportedVariableInfo} variableInfo new info for this variable
-	 * @returns {void}
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	setVariable(name, variableInfo) {
-		if (typeof variableInfo === "string") {
-			if (variableInfo === name) {
-				this.scope.definitions.delete(name);
-			} else {
-				this.scope.definitions.set(
-					name,
-					new VariableInfo(this.scope, variableInfo, undefined)
-				);
-			}
-		} else {
-			this.scope.definitions.set(name, variableInfo);
-		}
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
+}
 
-	parseCommentOptions(range) {
-		const comments = this.getComments(range);
-		if (comments.length === 0) {
-			return EMPTY_COMMENT_OPTIONS;
-		}
-		let options = {};
-		let errors = [];
-		for (const comment of comments) {
-			const { value } = comment;
-			if (value && webpackCommentRegExp.test(value)) {
-				// try compile only if webpack options comment is present
-				try {
-					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
-					Object.assign(options, val);
-				} catch (e) {
-					e.comment = comment;
-					errors.push(e);
-				}
-			}
-		}
-		return { options, errors };
-	}
+makeSerializable(
+	RequireResolveDependency,
+	"webpack/lib/dependencies/RequireResolveDependency"
+);
 
-	/**
-	 * @param {MemberExpressionNode} expression a member expression
-	 * @returns {{ members: string[], object: ExpressionNode | SuperNode }} member names (reverse order) and remaining object
-	 */
-	extractMemberExpressionChain(expression) {
-		/** @type {AnyNode} */
-		let expr = expression;
-		const members = [];
-		while (expr.type === "MemberExpression") {
-			if (expr.computed) {
-				if (expr.property.type !== "Literal") break;
-				members.push(`${expr.property.value}`);
-			} else {
-				if (expr.property.type !== "Identifier") break;
-				members.push(expr.property.name);
-			}
-			expr = expr.object;
-		}
-		return {
-			members,
-			object: expr
-		};
+RequireResolveDependency.Template = ModuleDependencyAsId;
+
+module.exports = RequireResolveDependency;
+
+
+/***/ }),
+
+/***/ 9880:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class RequireResolveHeaderDependency extends NullDependency {
+	constructor(range) {
+		super();
+
+		if (!Array.isArray(range)) throw new Error("range must be valid");
+
+		this.range = range;
 	}
 
-	/**
-	 * @param {string} varName variable name
-	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
-	 */
-	getFreeInfoFromVariable(varName) {
-		const info = this.getVariableInfo(varName);
-		let name;
-		if (info instanceof VariableInfo) {
-			name = info.freeName;
-			if (typeof name !== "string") return undefined;
-		} else if (typeof info !== "string") {
-			return undefined;
-		} else {
-			name = info;
-		}
-		return { info, name };
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const obj = new RequireResolveHeaderDependency(context.read());
+		obj.deserialize(context);
+		return obj;
 	}
+}
 
-	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[]}} CallExpressionInfo */
-	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[]}} ExpressionExpressionInfo */
+makeSerializable(
+	RequireResolveHeaderDependency,
+	"webpack/lib/dependencies/RequireResolveHeaderDependency"
+);
 
+RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {MemberExpressionNode} expression a member expression
-	 * @param {number} allowedTypes which types should be returned, presented in bit mask
-	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	getMemberExpressionInfo(expression, allowedTypes) {
-		const { object, members } = this.extractMemberExpressionChain(expression);
-		switch (object.type) {
-			case "CallExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
-					return undefined;
-				let callee = object.callee;
-				let rootMembers = EMPTY_ARRAY;
-				if (callee.type === "MemberExpression") {
-					({ object: callee, members: rootMembers } =
-						this.extractMemberExpressionChain(callee));
-				}
-				const rootName = getRootName(callee);
-				if (!rootName) return undefined;
-				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
-				const { info: rootInfo, name: resolvedRoot } = result;
-				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
-				return {
-					type: "call",
-					call: object,
-					calleeName,
-					rootInfo,
-					getCalleeMembers: memoize(() => rootMembers.reverse()),
-					name: objectAndMembersToName(`${calleeName}()`, members),
-					getMembers: memoize(() => members.reverse())
-				};
-			}
-			case "Identifier":
-			case "MetaProperty":
-			case "ThisExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
-					return undefined;
-				const rootName = getRootName(object);
-				if (!rootName) return undefined;
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {RequireResolveHeaderDependency} */ (dependency);
+		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	}
 
-				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
-				const { info: rootInfo, name: resolvedRoot } = result;
-				return {
-					type: "expression",
-					name: objectAndMembersToName(resolvedRoot, members),
-					rootInfo,
-					getMembers: memoize(() => members.reverse())
-				};
-			}
-		}
+	applyAsTemplateArgument(name, dep, source) {
+		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
 	}
+};
+
+module.exports = RequireResolveHeaderDependency;
+
+
+/***/ }),
+
+/***/ 24187:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
 
+class RuntimeRequirementsDependency extends NullDependency {
 	/**
-	 * @param {MemberExpressionNode} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 * @param {string[]} runtimeRequirements runtime requirements
 	 */
-	getNameForExpression(expression) {
-		return this.getMemberExpressionInfo(
-			expression,
-			ALLOWED_MEMBER_TYPES_EXPRESSION
-		);
+	constructor(runtimeRequirements) {
+		super();
+		this.runtimeRequirements = new Set(runtimeRequirements);
+		this._hashUpdate = undefined;
 	}
 
 	/**
-	 * @param {string} code source code
-	 * @param {ParseOptions} options parsing options
-	 * @returns {ProgramNode} parsed ast
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
 	 */
-	static _parse(code, options) {
-		const type = options ? options.sourceType : "module";
-		/** @type {AcornOptions} */
-		const parserOptions = {
-			...defaultParserOptions,
-			allowReturnOutsideFunction: type === "script",
-			...options,
-			sourceType: type === "auto" ? "module" : type
-		};
-
-		/** @type {AnyNode} */
-		let ast;
-		let error;
-		let threw = false;
-		try {
-			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
-		} catch (e) {
-			error = e;
-			threw = true;
-		}
-
-		if (threw && type === "auto") {
-			parserOptions.sourceType = "script";
-			if (!("allowReturnOutsideFunction" in options)) {
-				parserOptions.allowReturnOutsideFunction = true;
-			}
-			if (Array.isArray(parserOptions.onComment)) {
-				parserOptions.onComment.length = 0;
-			}
-			try {
-				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
-				threw = false;
-			} catch (e) {
-				// we use the error from first parse try
-				// so nothing to do here
-			}
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
 		}
+		hash.update(this._hashUpdate);
+	}
 
-		if (threw) {
-			throw error;
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.runtimeRequirements);
+		super.serialize(context);
+	}
 
-		return /** @type {ProgramNode} */ (ast);
+	deserialize(context) {
+		const { read } = context;
+		this.runtimeRequirements = read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = JavascriptParser;
-module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
-module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
-	ALLOWED_MEMBER_TYPES_EXPRESSION;
-module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
-	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
+makeSerializable(
+	RuntimeRequirementsDependency,
+	"webpack/lib/dependencies/RuntimeRequirementsDependency"
+);
+
+RuntimeRequirementsDependency.Template = class RuntimeRequirementsDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {RuntimeRequirementsDependency} */ (dependency);
+		for (const req of dep.runtimeRequirements) {
+			runtimeRequirements.add(req);
+		}
+	}
+};
+
+module.exports = RuntimeRequirementsDependency;
 
 
 /***/ }),
 
-/***/ 93998:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 91418:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -94888,112 +90700,71 @@ module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
 
 
 
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const ConstDependency = __webpack_require__(76911);
-const BasicEvaluatedExpression = __webpack_require__(950);
-
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("./JavascriptParser")} JavascriptParser */
-
-/**
- * @param {JavascriptParser} parser the parser
- * @param {string} value the const value
- * @param {string[]=} runtimeRequirements runtime requirements
- * @returns {function(ExpressionNode): true} plugin function
- */
-exports.toConstantDependency = (parser, value, runtimeRequirements) => {
-	return function constDependency(expr) {
-		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
-		dep.loc = expr.loc;
-		parser.state.module.addPresentationalDependency(dep);
-		return true;
-	};
-};
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/**
- * @param {string} value the string value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
- */
-exports.evaluateToString = value => {
-	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
-	};
-};
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
 
-/**
- * @param {number} value the number value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
- */
-exports.evaluateToNumber = value => {
-	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
-	};
-};
+class StaticExportsDependency extends NullDependency {
+	/**
+	 * @param {string[] | true} exports export names
+	 * @param {boolean} canMangle true, if mangling exports names is allowed
+	 */
+	constructor(exports, canMangle) {
+		super();
+		this.exports = exports;
+		this.canMangle = canMangle;
+	}
 
-/**
- * @param {boolean} value the boolean value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
- */
-exports.evaluateToBoolean = value => {
-	return function booleanExpression(expr) {
-		return new BasicEvaluatedExpression()
-			.setBoolean(value)
-			.setRange(expr.range);
-	};
-};
+	get type() {
+		return "static exports";
+	}
 
-/**
- * @param {string} identifier identifier
- * @param {string} rootInfo rootInfo
- * @param {function(): string[]} getMembers getMembers
- * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
- */
-exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
-	return function identifierExpression(expr) {
-		let evaluatedExpression = new BasicEvaluatedExpression()
-			.setIdentifier(identifier, rootInfo, getMembers)
-			.setSideEffects(false)
-			.setRange(expr.range);
-		switch (truthy) {
-			case true:
-				evaluatedExpression.setTruthy();
-				break;
-			case null:
-				evaluatedExpression.setNullish(true);
-				break;
-			case false:
-				evaluatedExpression.setFalsy();
-				break;
-		}
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: this.exports,
+			canMangle: this.canMangle,
+			dependencies: undefined
+		};
+	}
 
-		return evaluatedExpression;
-	};
-};
+	serialize(context) {
+		const { write } = context;
+		write(this.exports);
+		write(this.canMangle);
+		super.serialize(context);
+	}
 
-exports.expressionIsUnsupported = (parser, message) => {
-	return function unsupportedExpression(expr) {
-		const dep = new ConstDependency("(void 0)", expr.range, null);
-		dep.loc = expr.loc;
-		parser.state.module.addPresentationalDependency(dep);
-		if (!parser.state.module) return;
-		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, expr.loc)
-		);
-		return true;
-	};
-};
+	deserialize(context) {
+		const { read } = context;
+		this.exports = read();
+		this.canMangle = read();
+		super.deserialize(context);
+	}
+}
 
-exports.skipTraversal = () => true;
+makeSerializable(
+	StaticExportsDependency,
+	"webpack/lib/dependencies/StaticExportsDependency"
+);
 
-exports.approve = () => true;
+module.exports = StaticExportsDependency;
 
 
 /***/ }),
 
-/***/ 98124:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 97981:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -95004,505 +90775,474 @@ exports.approve = () => true;
 
 
 const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const { isSubset } = __webpack_require__(93347);
-const { getAllChunks } = __webpack_require__(91145);
+const WebpackError = __webpack_require__(53799);
+const {
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = __webpack_require__(93998);
+const makeSerializable = __webpack_require__(33032);
+const ConstDependency = __webpack_require__(76911);
+const SystemRuntimeModule = __webpack_require__(85439);
 
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {(string|number)[]} EntryItem */
+/** @typedef {import("../Compiler")} Compiler */
 
-const EXPORT_PREFIX = "var __webpack_exports__ = ";
+class SystemPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"SystemPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.system)
+					.tap("SystemPlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
 
-/**
- * @param {ChunkGraph} chunkGraph chunkGraph
- * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
- * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
- * @param {Chunk} chunk chunk
- * @param {boolean} passive true: passive startup with on chunks loaded
- * @returns {string} runtime code
- */
-exports.generateEntryStartup = (
-	chunkGraph,
-	runtimeTemplate,
-	entries,
-	chunk,
-	passive
-) => {
-	/** @type {string[]} */
-	const runtime = [
-		`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-			`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
-			"moduleId"
-		)}`
-	];
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.system)
+					.tap("SystemPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
+					});
 
-	const runModule = id => {
-		return `__webpack_exec__(${JSON.stringify(id)})`;
-	};
-	const outputCombination = (chunks, moduleIds, final) => {
-		if (chunks.size === 0) {
-			runtime.push(
-				`${final ? EXPORT_PREFIX : ""}(${moduleIds.map(runModule).join(", ")});`
-			);
-		} else {
-			const fn = runtimeTemplate.returningFunction(
-				moduleIds.map(runModule).join(", ")
-			);
-			runtime.push(
-				`${final && !passive ? EXPORT_PREFIX : ""}${
-					passive
-						? RuntimeGlobals.onChunksLoaded
-						: RuntimeGlobals.startupEntrypoint
-				}(0, ${JSON.stringify(Array.from(chunks, c => c.id))}, ${fn});`
-			);
-			if (final && passive) {
-				runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);
-			}
-		}
-	};
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.system === undefined || !parserOptions.system) {
+						return;
+					}
 
-	let currentChunks = undefined;
-	let currentModuleIds = undefined;
+					const setNotSupported = name => {
+						parser.hooks.evaluateTypeof
+							.for(name)
+							.tap("SystemPlugin", evaluateToString("undefined"));
+						parser.hooks.expression
+							.for(name)
+							.tap(
+								"SystemPlugin",
+								expressionIsUnsupported(
+									parser,
+									name + " is not supported by webpack."
+								)
+							);
+					};
 
-	for (const [module, entrypoint] of entries) {
-		const runtimeChunk = entrypoint.getRuntimeChunk();
-		const moduleId = chunkGraph.getModuleId(module);
-		const chunks = getAllChunks(entrypoint, chunk, runtimeChunk);
-		if (
-			currentChunks &&
-			currentChunks.size === chunks.size &&
-			isSubset(currentChunks, chunks)
-		) {
-			currentModuleIds.push(moduleId);
-		} else {
-			if (currentChunks) {
-				outputCombination(currentChunks, currentModuleIds);
+					parser.hooks.typeof
+						.for("System.import")
+						.tap(
+							"SystemPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("System.import")
+						.tap("SystemPlugin", evaluateToString("function"));
+					parser.hooks.typeof
+						.for("System")
+						.tap(
+							"SystemPlugin",
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("System")
+						.tap("SystemPlugin", evaluateToString("object"));
+
+					setNotSupported("System.set");
+					setNotSupported("System.get");
+					setNotSupported("System.register");
+
+					parser.hooks.expression.for("System").tap("SystemPlugin", expr => {
+						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
+							RuntimeGlobals.system
+						]);
+						dep.loc = expr.loc;
+						parser.state.module.addPresentationalDependency(dep);
+						return true;
+					});
+
+					parser.hooks.call.for("System.import").tap("SystemPlugin", expr => {
+						parser.state.module.addWarning(
+							new SystemImportDeprecationWarning(expr.loc)
+						);
+
+						return parser.hooks.importCall.call({
+							type: "ImportExpression",
+							source: expr.arguments[0],
+							loc: expr.loc,
+							range: expr.range
+						});
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("SystemPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("SystemPlugin", handler);
 			}
-			currentChunks = chunks;
-			currentModuleIds = [moduleId];
-		}
+		);
 	}
+}
 
-	// output current modules with export prefix
-	if (currentChunks) {
-		outputCombination(currentChunks, currentModuleIds, true);
-	}
-	runtime.push("");
-	return Template.asString(runtime);
-};
+class SystemImportDeprecationWarning extends WebpackError {
+	constructor(loc) {
+		super(
+			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +
+				"For more info visit https://webpack.js.org/guides/code-splitting/"
+		);
 
-/**
- * @param {Hash} hash the hash to update
- * @param {ChunkGraph} chunkGraph chunkGraph
- * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
- * @param {Chunk} chunk chunk
- * @returns {void}
- */
-exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
-	for (const [module, entrypoint] of entries) {
-		const runtimeChunk = entrypoint.getRuntimeChunk();
-		const moduleId = chunkGraph.getModuleId(module);
-		hash.update(`${moduleId}`);
-		for (const c of getAllChunks(entrypoint, chunk, runtimeChunk))
-			hash.update(`${c.id}`);
-	}
-};
+		this.name = "SystemImportDeprecationWarning";
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
- * @returns {Set<number | string>} initially fulfilled chunk ids
- */
-exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
-	const initialChunkIds = new Set(chunk.ids);
-	for (const c of chunk.getAllInitialChunks()) {
-		if (c === chunk || filterFn(c, chunkGraph)) continue;
-		for (const id of c.ids) initialChunkIds.add(id);
+		this.loc = loc;
 	}
-	return initialChunkIds;
-};
+}
+
+makeSerializable(
+	SystemImportDeprecationWarning,
+	"webpack/lib/dependencies/SystemPlugin",
+	"SystemImportDeprecationWarning"
+);
+
+module.exports = SystemPlugin;
+module.exports.SystemImportDeprecationWarning = SystemImportDeprecationWarning;
 
 
 /***/ }),
 
-/***/ 90490:
+/***/ 85439:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const { register } = __webpack_require__(8282);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-class JsonData {
-	constructor(data) {
-		this._buffer = undefined;
-		this._data = undefined;
-		if (Buffer.isBuffer(data)) {
-			this._buffer = data;
-		} else {
-			this._data = data;
-		}
+class SystemRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("system");
 	}
 
-	get() {
-		if (this._data === undefined && this._buffer !== undefined) {
-			this._data = JSON.parse(this._buffer.toString());
-		}
-		return this._data;
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.system} = {`,
+			Template.indent([
+				"import: function () {",
+				Template.indent(
+					"throw new Error('System.import cannot be used indirectly');"
+				),
+				"}"
+			]),
+			"};"
+		]);
 	}
 }
 
-register(JsonData, "webpack/lib/json/JsonData", null, {
-	serialize(obj, { write }) {
-		if (obj._buffer === undefined && obj._data !== undefined) {
-			obj._buffer = Buffer.from(JSON.stringify(obj._data));
-		}
-		write(obj._buffer);
-	},
-	deserialize({ read }) {
-		return new JsonData(read());
-	}
-});
-
-module.exports = JsonData;
+module.exports = SystemRuntimeModule;
 
 
 /***/ }),
 
-/***/ 70393:
+/***/ 58612:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const ConcatenationScope = __webpack_require__(98229);
-const { UsageState } = __webpack_require__(63686);
-const Generator = __webpack_require__(93401);
 const RuntimeGlobals = __webpack_require__(16475);
+const {
+	getDependencyUsedByExportsCondition
+} = __webpack_require__(38988);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
+const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const stringifySafe = data => {
-	const stringified = JSON.stringify(data);
-	if (!stringified) {
-		return undefined; // Invalid JSON
-	}
-
-	return stringified.replace(/\u2028|\u2029/g, str =>
-		str === "\u2029" ? "\\u2029" : "\\u2028"
-	); // invalid in JavaScript but valid JSON
-};
-
-/**
- * @param {Object} data data (always an object or array)
- * @param {ExportsInfo} exportsInfo exports info
- * @param {RuntimeSpec} runtime the runtime
- * @returns {Object} reduced data
- */
-const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
-	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
-		return data;
-	const isArray = Array.isArray(data);
-	const reducedData = isArray ? [] : {};
-	for (const key of Object.keys(data)) {
-		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
-		const used = exportInfo.getUsed(runtime);
-		if (used === UsageState.Unused) continue;
+const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
 
-		let value;
-		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
-			value = createObjectForExportsInfo(
-				data[key],
-				exportInfo.exportsInfo,
-				runtime
-			);
-		} else {
-			value = data[key];
-		}
-		const name = exportInfo.getUsedName(key, runtime);
-		reducedData[name] = value;
+class URLDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
+	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
+	 * @param {boolean=} relative use relative urls instead of absolute with base uri
+	 */
+	constructor(request, range, outerRange, relative) {
+		super(request);
+		this.range = range;
+		this.outerRange = outerRange;
+		this.relative = relative || false;
+		/** @type {Set<string> | boolean} */
+		this.usedByExports = undefined;
 	}
-	if (isArray) {
-		let arrayLengthWhenUsed =
-			exportsInfo.getReadOnlyExportInfo("length").getUsed(runtime) !==
-			UsageState.Unused
-				? data.length
-				: undefined;
 
-		let sizeObjectMinusArray = 0;
-		for (let i = 0; i < reducedData.length; i++) {
-			if (reducedData[i] === undefined) {
-				sizeObjectMinusArray -= 2;
-			} else {
-				sizeObjectMinusArray += `${i}`.length + 3;
-			}
-		}
-		if (arrayLengthWhenUsed !== undefined) {
-			sizeObjectMinusArray +=
-				`${arrayLengthWhenUsed}`.length +
-				8 -
-				(arrayLengthWhenUsed - reducedData.length) * 2;
-		}
-		if (sizeObjectMinusArray < 0)
-			return Object.assign(
-				arrayLengthWhenUsed === undefined
-					? {}
-					: { length: arrayLengthWhenUsed },
-				reducedData
-			);
-		const generatedLength =
-			arrayLengthWhenUsed !== undefined
-				? Math.max(arrayLengthWhenUsed, reducedData.length)
-				: reducedData.length;
-		for (let i = 0; i < generatedLength; i++) {
-			if (reducedData[i] === undefined) {
-				reducedData[i] = 0;
-			}
-		}
+	get type() {
+		return "new URL()";
 	}
-	return reducedData;
-};
 
-const TYPES = new Set(["javascript"]);
+	get category() {
+		return "url";
+	}
 
-class JsonGenerator extends Generator {
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
-	getTypes(module) {
-		return TYPES;
+	getCondition(moduleGraph) {
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {string} context context directory
+	 * @returns {Module} a module
 	 */
-	getSize(module, type) {
-		let data =
-			module.buildInfo &&
-			module.buildInfo.jsonData &&
-			module.buildInfo.jsonData.get();
-		if (!data) return 0;
-		return stringifySafe(data).length + 10;
+	createIgnoredModule(context) {
+		const RawDataUrlModule = getRawDataUrlModule();
+		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
 	}
 
-	/**
-	 * @param {NormalModule} module module for which the bailout reason should be determined
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(module, context) {
-		return undefined;
+	serialize(context) {
+		const { write } = context;
+		write(this.outerRange);
+		write(this.relative);
+		write(this.usedByExports);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.outerRange = read();
+		this.relative = read();
+		this.usedByExports = read();
+		super.deserialize(context);
 	}
+}
 
+URLDependency.Template = class URLDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	generate(
-		module,
-		{
+	apply(dependency, source, templateContext) {
+		const {
+			chunkGraph,
 			moduleGraph,
-			runtimeTemplate,
 			runtimeRequirements,
-			runtime,
-			concatenationScope
-		}
-	) {
-		const data =
-			module.buildInfo &&
-			module.buildInfo.jsonData &&
-			module.buildInfo.jsonData.get();
-		if (data === undefined) {
-			return new RawSource(
-				runtimeTemplate.missingModuleStatement({
-					request: module.rawRequest
-				})
+			runtimeTemplate,
+			runtime
+		} = templateContext;
+		const dep = /** @type {URLDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				"/* unused asset import */ undefined"
 			);
+			return;
 		}
-		const exportsInfo = moduleGraph.getExportsInfo(module);
-		let finalJson =
-			typeof data === "object" &&
-			data &&
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused
-				? createObjectForExportsInfo(data, exportsInfo, runtime)
-				: data;
-		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
-		const jsonStr = stringifySafe(finalJson);
-		const jsonExpr =
-			jsonStr.length > 20 && typeof finalJson === "object"
-				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
-				: jsonStr;
-		let content;
-		if (concatenationScope) {
-			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
-				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-			} = ${jsonExpr};`;
-			concatenationScope.registerNamespaceExport(
-				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+
+		runtimeRequirements.add(RuntimeGlobals.require);
+
+		if (dep.relative) {
+			runtimeRequirements.add(RuntimeGlobals.relativeUrl);
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				`/* asset import */ new ${
+					RuntimeGlobals.relativeUrl
+				}(${runtimeTemplate.moduleRaw({
+					chunkGraph,
+					module: moduleGraph.getModule(dep),
+					request: dep.request,
+					runtimeRequirements,
+					weak: false
+				})})`
 			);
 		} else {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			content = `${module.moduleArgument}.exports = ${jsonExpr};`;
+			runtimeRequirements.add(RuntimeGlobals.baseURI);
+
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				`/* asset import */ ${runtimeTemplate.moduleRaw({
+					chunkGraph,
+					module: moduleGraph.getModule(dep),
+					request: dep.request,
+					runtimeRequirements,
+					weak: false
+				})}, ${RuntimeGlobals.baseURI}`
+			);
 		}
-		return new RawSource(content);
 	}
-}
+};
 
-module.exports = JsonGenerator;
+makeSerializable(URLDependency, "webpack/lib/dependencies/URLDependency");
+
+module.exports = URLDependency;
 
 
 /***/ }),
 
-/***/ 86770:
+/***/ 14412:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const createSchemaValidation = __webpack_require__(32540);
-const JsonGenerator = __webpack_require__(70393);
-const JsonParser = __webpack_require__(41090);
+const { approve } = __webpack_require__(93998);
+const InnerGraph = __webpack_require__(38988);
+const URLDependency = __webpack_require__(58612);
 
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
-const validate = createSchemaValidation(
-	__webpack_require__(54094),
-	() => __webpack_require__(50166),
-	{
-		name: "Json Modules Plugin",
-		baseDataPath: "parser"
-	}
-);
-
-class JsonModulesPlugin {
+class URLPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Compiler} compiler compiler
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JsonModulesPlugin",
+			"URLPlugin",
 			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.createParser
-					.for("json")
-					.tap("JsonModulesPlugin", parserOptions => {
-						validate(parserOptions);
+				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
+				compilation.dependencyTemplates.set(
+					URLDependency,
+					new URLDependency.Template()
+				);
 
-						return new JsonParser(parserOptions);
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("json")
-					.tap("JsonModulesPlugin", () => {
-						return new JsonGenerator();
-					});
-			}
-		);
-	}
-}
+				/**
+				 * @param {JavascriptParser} parser parser
+				 * @param {object} parserOptions options
+				 */
+				const parserCallback = (parser, parserOptions) => {
+					if (parserOptions.url === false) return;
+					const relative = parserOptions.url === "relative";
 
-module.exports = JsonModulesPlugin;
+					/**
+					 * @param {NewExpressionNode} expr expression
+					 * @returns {undefined | string} request
+					 */
+					const getUrlRequest = expr => {
+						if (expr.arguments.length !== 2) return;
 
+						const [arg1, arg2] = expr.arguments;
 
-/***/ }),
+						if (
+							arg2.type !== "MemberExpression" ||
+							arg1.type === "SpreadElement"
+						)
+							return;
 
-/***/ 41090:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+						const chain = parser.extractMemberExpressionChain(arg2);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+						if (
+							chain.members.length !== 1 ||
+							chain.object.type !== "MetaProperty" ||
+							chain.object.meta.name !== "import" ||
+							chain.object.property.name !== "meta" ||
+							chain.members[0] !== "url"
+						)
+							return;
 
+						const request = parser.evaluateExpression(arg1).asString();
 
+						return request;
+					};
 
-const parseJson = __webpack_require__(15235);
-const Parser = __webpack_require__(11715);
-const JsonExportsDependency = __webpack_require__(750);
-const JsonData = __webpack_require__(90490);
+					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
 
-/** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+						const request = getUrlRequest(expr);
 
-class JsonParser extends Parser {
-	/**
-	 * @param {JsonModulesPluginParserOptions} options parser options
-	 */
-	constructor(options) {
-		super();
-		this.options = options || {};
-	}
+						if (!request) return;
 
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
-		}
+						const [arg1, arg2] = expr.arguments;
+						const dep = new URLDependency(
+							request,
+							[arg1.range[0], arg2.range[1]],
+							expr.range,
+							relative
+						);
+						dep.loc = expr.loc;
+						parser.state.current.addDependency(dep);
+						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+						return true;
+					});
+					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+						const { callee } = expr;
+						if (callee.type !== "Identifier") return;
+						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+						if (!calleeInfo || calleeInfo.name !== "URL") return;
 
-		/** @type {JsonModulesPluginParserOptions["parse"]} */
-		const parseFn =
-			typeof this.options.parse === "function" ? this.options.parse : parseJson;
+						const request = getUrlRequest(expr);
 
-		const data =
-			typeof source === "object"
-				? source
-				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
+						if (request) return true;
+					});
+				};
 
-		state.module.buildInfo.jsonData = new JsonData(data);
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject =
-			typeof data === "object" ? "redirect-warn" : false;
-		state.module.addDependency(
-			new JsonExportsDependency(JsonExportsDependency.getExportsFromData(data))
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("URLPlugin", parserCallback);
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("URLPlugin", parserCallback);
+			}
 		);
-		return state;
 	}
 }
 
-module.exports = JsonParser;
+module.exports = URLPlugin;
 
 
 /***/ }),
 
-/***/ 26030:
+/***/ 51669:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -95513,301 +91253,73 @@ module.exports = JsonParser;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-const COMMON_LIBRARY_NAME_MESSAGE =
-	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-/**
- * @template T
- * @typedef {Object} LibraryContext
- * @property {Compilation} compilation
- * @property {ChunkGraph} chunkGraph
- * @property {T} options
- */
+class UnsupportedDependency extends NullDependency {
+	constructor(request, range) {
+		super();
 
-/**
- * @template T
- */
-class AbstractLibraryPlugin {
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.pluginName name of the plugin
-	 * @param {LibraryType} options.type used library type
-	 */
-	constructor({ pluginName, type }) {
-		this._pluginName = pluginName;
-		this._type = type;
-		this._parseCache = new WeakMap();
+		this.request = request;
+		this.range = range;
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { _pluginName } = this;
-		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
-			compilation.hooks.finishModules.tap(
-				{ name: _pluginName, stage: 10 },
-				() => {
-					for (const [
-						name,
-						{
-							dependencies: deps,
-							options: { library }
-						}
-					] of compilation.entries) {
-						const options = this._parseOptionsCached(
-							library !== undefined
-								? library
-								: compilation.outputOptions.library
-						);
-						if (options !== false) {
-							const dep = deps[deps.length - 1];
-							if (dep) {
-								const module = compilation.moduleGraph.getModule(dep);
-								if (module) {
-									this.finishEntryModule(module, name, {
-										options,
-										compilation,
-										chunkGraph: compilation.chunkGraph
-									});
-								}
-							}
-						}
-					}
-				}
-			);
-
-			const getOptionsForChunk = chunk => {
-				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
-					return false;
-				const options = chunk.getEntryOptions();
-				const library = options && options.library;
-				return this._parseOptionsCached(
-					library !== undefined ? library : compilation.outputOptions.library
-				);
-			};
-
-			if (
-				this.render !== AbstractLibraryPlugin.prototype.render ||
-				this.runtimeRequirements !==
-					AbstractLibraryPlugin.prototype.runtimeRequirements
-			) {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					_pluginName,
-					(chunk, set, { chunkGraph }) => {
-						const options = getOptionsForChunk(chunk);
-						if (options !== false) {
-							this.runtimeRequirements(chunk, set, {
-								options,
-								compilation,
-								chunkGraph
-							});
-						}
-					}
-				);
-			}
-
-			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-
-			if (this.render !== AbstractLibraryPlugin.prototype.render) {
-				hooks.render.tap(_pluginName, (source, renderContext) => {
-					const options = getOptionsForChunk(renderContext.chunk);
-					if (options === false) return source;
-					return this.render(source, renderContext, {
-						options,
-						compilation,
-						chunkGraph: compilation.chunkGraph
-					});
-				});
-			}
-
-			if (
-				this.embedInRuntimeBailout !==
-				AbstractLibraryPlugin.prototype.embedInRuntimeBailout
-			) {
-				hooks.embedInRuntimeBailout.tap(
-					_pluginName,
-					(module, renderContext) => {
-						const options = getOptionsForChunk(renderContext.chunk);
-						if (options === false) return;
-						return this.embedInRuntimeBailout(module, renderContext, {
-							options,
-							compilation,
-							chunkGraph: compilation.chunkGraph
-						});
-					}
-				);
-			}
-
-			if (
-				this.strictRuntimeBailout !==
-				AbstractLibraryPlugin.prototype.strictRuntimeBailout
-			) {
-				hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
-					const options = getOptionsForChunk(renderContext.chunk);
-					if (options === false) return;
-					return this.strictRuntimeBailout(renderContext, {
-						options,
-						compilation,
-						chunkGraph: compilation.chunkGraph
-					});
-				});
-			}
-
-			if (
-				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
-			) {
-				hooks.renderStartup.tap(
-					_pluginName,
-					(source, module, renderContext) => {
-						const options = getOptionsForChunk(renderContext.chunk);
-						if (options === false) return source;
-						return this.renderStartup(source, module, renderContext, {
-							options,
-							compilation,
-							chunkGraph: compilation.chunkGraph
-						});
-					}
-				);
-			}
+	serialize(context) {
+		const { write } = context;
 
-			hooks.chunkHash.tap(_pluginName, (chunk, hash, context) => {
-				const options = getOptionsForChunk(chunk);
-				if (options === false) return;
-				this.chunkHash(chunk, hash, context, {
-					options,
-					compilation,
-					chunkGraph: compilation.chunkGraph
-				});
-			});
-		});
-	}
+		write(this.request);
+		write(this.range);
 
-	/**
-	 * @param {LibraryOptions=} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	_parseOptionsCached(library) {
-		if (!library) return false;
-		if (library.type !== this._type) return false;
-		const cacheEntry = this._parseCache.get(library);
-		if (cacheEntry !== undefined) return cacheEntry;
-		const result = this.parseOptions(library);
-		this._parseCache.set(library, result);
-		return result;
+		super.serialize(context);
 	}
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+	deserialize(context) {
+		const { read } = context;
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {string} entryName the name of the entrypoint
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	finishEntryModule(module, entryName, libraryContext) {}
+		this.request = read();
+		this.range = read();
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	embedInRuntimeBailout(module, renderContext, libraryContext) {
-		return undefined;
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	strictRuntimeBailout(renderContext, libraryContext) {
-		return undefined;
-	}
+makeSerializable(
+	UnsupportedDependency,
+	"webpack/lib/dependencies/UnsupportedDependency"
+);
 
+UnsupportedDependency.Template = class UnsupportedDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
-	 * @param {LibraryContext<T>} libraryContext context
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	runtimeRequirements(chunk, set, libraryContext) {
-		if (this.render !== AbstractLibraryPlugin.prototype.render)
-			set.add(RuntimeGlobals.returnExportsFromRuntime);
-	}
-
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(source, renderContext, libraryContext) {
-		return source;
-	}
-
-	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	renderStartup(source, module, renderContext, libraryContext) {
-		return source;
-	}
+	apply(dependency, source, { runtimeTemplate }) {
+		const dep = /** @type {UnsupportedDependency} */ (dependency);
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	chunkHash(chunk, hash, chunkHashContext, libraryContext) {
-		const options = this._parseOptionsCached(
-			libraryContext.compilation.outputOptions.library
+		source.replace(
+			dep.range[0],
+			dep.range[1],
+			runtimeTemplate.missingModule({
+				request: dep.request
+			})
 		);
-		hash.update(this._pluginName);
-		hash.update(JSON.stringify(options));
 	}
-}
+};
 
-AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
-module.exports = AbstractLibraryPlugin;
+module.exports = UnsupportedDependency;
 
 
 /***/ }),
 
-/***/ 67416:
+/***/ 52204:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -95818,166 +91330,83 @@ module.exports = AbstractLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const ExternalModule = __webpack_require__(73071);
-const Template = __webpack_require__(1626);
-const AbstractLibraryPlugin = __webpack_require__(26030);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} AmdLibraryPluginOptions
- * @property {LibraryType} type
- * @property {boolean=} requireAsWrapper
- */
-
-/**
- * @typedef {Object} AmdLibraryPluginParsed
- * @property {string} name
- */
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-/**
- * @typedef {AmdLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<AmdLibraryPluginParsed>}
- */
-class AmdLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {AmdLibraryPluginOptions} options the plugin options
-	 */
-	constructor(options) {
-		super({
-			pluginName: "AmdLibraryPlugin",
-			type: options.type
-		});
-		this.requireAsWrapper = options.requireAsWrapper;
-	}
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (this.requireAsWrapper) {
-			if (name) {
-				throw new Error(
-					`AMD library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		} else {
-			if (name && typeof name !== "string") {
-				throw new Error(
-					`AMD library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		}
-		return {
-			name: /** @type {string=} */ (name)
-		};
+class WebAssemblyExportImportedDependency extends ModuleDependency {
+	constructor(exportName, request, name, valueType) {
+		super(request);
+		/** @type {string} */
+		this.exportName = exportName;
+		/** @type {string} */
+		this.name = name;
+		/** @type {string} */
+		this.valueType = valueType;
 	}
 
 	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(
-		source,
-		{ chunkGraph, chunk, runtimeTemplate },
-		{ options, compilation }
-	) {
-		const modern = runtimeTemplate.supportsArrowFunction();
-		const modules = chunkGraph
-			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule);
-		const externals = /** @type {ExternalModule[]} */ (modules);
-		const externalsDepsArray = JSON.stringify(
-			externals.map(m =>
-				typeof m.request === "object" && !Array.isArray(m.request)
-					? m.request.amd
-					: m.request
-			)
-		);
-		const externalsArguments = externals
-			.map(
-				m =>
-					`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-						`${chunkGraph.getModuleId(m)}`
-					)}__`
-			)
-			.join(", ");
-
-		const iife = runtimeTemplate.isIIFE();
-		const fnStart =
-			(modern
-				? `(${externalsArguments}) => {`
-				: `function(${externalsArguments}) {`) +
-			(iife || !chunk.hasRuntime() ? " return " : "\n");
-		const fnEnd = iife ? ";\n}" : "\n}";
-
-		if (this.requireAsWrapper) {
-			return new ConcatSource(
-				`require(${externalsDepsArray}, ${fnStart}`,
-				source,
-				`${fnEnd});`
-			);
-		} else if (options.name) {
-			const name = compilation.getPath(options.name, {
-				chunk
-			});
-
-			return new ConcatSource(
-				`define(${JSON.stringify(name)}, ${externalsDepsArray}, ${fnStart}`,
-				source,
-				`${fnEnd});`
-			);
-		} else if (externalsArguments) {
-			return new ConcatSource(
-				`define(${externalsDepsArray}, ${fnStart}`,
-				source,
-				`${fnEnd});`
-			);
-		} else {
-			return new ConcatSource(`define(${fnStart}`, source, `${fnEnd});`);
-		}
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("AmdLibraryPlugin");
-		if (this.requireAsWrapper) {
-			hash.update("requireAsWrapper");
-		} else if (options.name) {
-			hash.update("named");
-			const name = compilation.getPath(options.name, {
-				chunk
-			});
-			hash.update(name);
-		}
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
+
+	get type() {
+		return "wasm export import";
+	}
+
+	get category() {
+		return "wasm";
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.exportName);
+		write(this.name);
+		write(this.valueType);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.exportName = read();
+		this.name = read();
+		this.valueType = read();
+
+		super.deserialize(context);
 	}
 }
 
-module.exports = AmdLibraryPlugin;
+makeSerializable(
+	WebAssemblyExportImportedDependency,
+	"webpack/lib/dependencies/WebAssemblyExportImportedDependency"
+);
+
+module.exports = WebAssemblyExportImportedDependency;
 
 
 /***/ }),
 
-/***/ 40080:
+/***/ 5239:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -95988,373 +91417,289 @@ module.exports = AmdLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Template = __webpack_require__(1626);
-const propertyAccess = __webpack_require__(54190);
-const { getEntryRuntime } = __webpack_require__(17156);
-const AbstractLibraryPlugin = __webpack_require__(26030);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-const KEYWORD_REGEX =
-	/^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
-const IDENTIFIER_REGEX =
-	/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
-
-/**
- * Validates the library name by checking for keywords and valid characters
- * @param {string} name name to be validated
- * @returns {boolean} true, when valid
- */
-const isNameValid = name => {
-	return !KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
-};
-
-/**
- * @param {string[]} accessor variable plus properties
- * @param {number} existingLength items of accessor that are existing already
- * @param {boolean=} initLast if the last property should also be initialized to an object
- * @returns {string} code to access the accessor while initializing
- */
-const accessWithInit = (accessor, existingLength, initLast = false) => {
-	// This generates for [a, b, c, d]:
-	// (((a = typeof a === "undefined" ? {} : a).b = a.b || {}).c = a.b.c || {}).d
-	const base = accessor[0];
-	if (accessor.length === 1 && !initLast) return base;
-	let current =
-		existingLength > 0
-			? base
-			: `(${base} = typeof ${base} === "undefined" ? {} : ${base})`;
-
-	// i is the current position in accessor that has been printed
-	let i = 1;
+const makeSerializable = __webpack_require__(33032);
+const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
+const ModuleDependency = __webpack_require__(80321);
 
-	// all properties printed so far (excluding base)
-	let propsSoFar;
+/** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-	// if there is existingLength, print all properties until this position as property access
-	if (existingLength > i) {
-		propsSoFar = accessor.slice(1, existingLength);
-		i = existingLength;
-		current += propertyAccess(propsSoFar);
-	} else {
-		propsSoFar = [];
+class WebAssemblyImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {string} name the imported name
+	 * @param {ModuleImportDescription} description the WASM ast node
+	 * @param {false | string} onlyDirectImport if only direct imports are allowed
+	 */
+	constructor(request, name, description, onlyDirectImport) {
+		super(request);
+		/** @type {string} */
+		this.name = name;
+		/** @type {ModuleImportDescription} */
+		this.description = description;
+		/** @type {false | string} */
+		this.onlyDirectImport = onlyDirectImport;
 	}
 
-	// all remaining properties (except the last one when initLast is not set)
-	// should be printed as initializer
-	const initUntil = initLast ? accessor.length : accessor.length - 1;
-	for (; i < initUntil; i++) {
-		const prop = accessor[i];
-		propsSoFar.push(prop);
-		current = `(${current}${propertyAccess([prop])} = ${base}${propertyAccess(
-			propsSoFar
-		)} || {})`;
+	get type() {
+		return "wasm import";
 	}
 
-	// print the last property as property access if not yet printed
-	if (i < accessor.length)
-		current = `${current}${propertyAccess([accessor[accessor.length - 1]])}`;
-
-	return current;
-};
-
-/**
- * @typedef {Object} AssignLibraryPluginOptions
- * @property {LibraryType} type
- * @property {string[] | "global"} prefix name prefix
- * @property {string | false} declare declare name as variable
- * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
- * @property {"copy"|"assign"=} named behavior for named library name
- */
-
-/**
- * @typedef {Object} AssignLibraryPluginParsed
- * @property {string | string[]} name
- * @property {string | string[] | undefined} export
- */
-
-/**
- * @typedef {AssignLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
- */
-class AssignLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {AssignLibraryPluginOptions} options the plugin options
-	 */
-	constructor(options) {
-		super({
-			pluginName: "AssignLibraryPlugin",
-			type: options.type
-		});
-		this.prefix = options.prefix;
-		this.declare = options.declare;
-		this.unnamed = options.unnamed;
-		this.named = options.named || "assign";
+	get category() {
+		return "wasm";
 	}
 
 	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (this.unnamed === "error") {
-			if (typeof name !== "string" && !Array.isArray(name)) {
-				throw new Error(
-					`Library name must be a string or string array. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		} else {
-			if (name && typeof name !== "string" && !Array.isArray(name)) {
-				throw new Error(
-					`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		}
-		return {
-			name: /** @type {string|string[]=} */ (name),
-			export: library.export
-		};
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
 	}
 
 	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {string} entryName the name of the entrypoint
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
 	 */
-	finishEntryModule(
-		module,
-		entryName,
-		{ options, compilation, compilation: { moduleGraph } }
-	) {
-		const runtime = getEntryRuntime(compilation, entryName);
-		if (options.export) {
-			const exportsInfo = moduleGraph.getExportInfo(
-				module,
-				Array.isArray(options.export) ? options.export[0] : options.export
-			);
-			exportsInfo.setUsed(UsageState.Used, runtime);
-			exportsInfo.canMangleUse = false;
-		} else {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			exportsInfo.setUsedInUnknownWay(runtime);
+	getErrors(moduleGraph) {
+		const module = moduleGraph.getModule(this);
+
+		if (
+			this.onlyDirectImport &&
+			module &&
+			!module.type.startsWith("webassembly")
+		) {
+			return [
+				new UnsupportedWebAssemblyFeatureError(
+					`Import "${this.name}" from "${this.request}" with ${this.onlyDirectImport} can only be used for direct wasm to wasm dependencies`
+				)
+			];
 		}
-		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
-	_getPrefix(compilation) {
-		return this.prefix === "global"
-			? [compilation.runtimeTemplate.globalObject]
-			: this.prefix;
+	serialize(context) {
+		const { write } = context;
+
+		write(this.name);
+		write(this.description);
+		write(this.onlyDirectImport);
+
+		super.serialize(context);
 	}
 
-	_getResolvedFullName(options, chunk, compilation) {
-		const prefix = this._getPrefix(compilation);
-		const fullName = options.name ? prefix.concat(options.name) : prefix;
-		return fullName.map(n =>
-			compilation.getPath(n, {
-				chunk
-			})
-		);
+	deserialize(context) {
+		const { read } = context;
+
+		this.name = read();
+		this.description = read();
+		this.onlyDirectImport = read();
+
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(source, { chunk }, { options, compilation }) {
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		if (this.declare) {
-			const base = fullNameResolved[0];
-			if (!isNameValid(base)) {
-				throw new Error(
-					`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
-						base
-					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${
-						AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE
-					}`
-				);
-			}
-			source = new ConcatSource(`${this.declare} ${base};\n`, source);
-		}
-		return source;
+makeSerializable(
+	WebAssemblyImportDependency,
+	"webpack/lib/dependencies/WebAssemblyImportDependency"
+);
+
+module.exports = WebAssemblyImportDependency;
+
+
+/***/ }),
+
+/***/ 26505:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const Template = __webpack_require__(39722);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebpackIsIncludedDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+
+		this.weak = true;
+		this.range = range;
 	}
 
 	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
-		const topLevelDeclarations =
-			module.buildInfo && module.buildInfo.topLevelDeclarations;
-		if (!topLevelDeclarations)
-			return "it doesn't tell about top level declarations.";
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		const base = fullNameResolved[0];
-		if (topLevelDeclarations.has(base))
-			return `it declares '${base}' on top-level, which conflicts with the current library output.`;
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
 
-	/**
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	strictRuntimeBailout({ chunk }, { options, compilation }) {
-		if (
-			this.declare ||
-			this.prefix === "global" ||
-			this.prefix.length > 0 ||
-			!options.name
-		) {
-			return;
-		}
-		return "a global variable is assign and maybe created";
+	get type() {
+		return "__webpack_is_included__";
 	}
+}
+
+makeSerializable(
+	WebpackIsIncludedDependency,
+	"webpack/lib/dependencies/WebpackIsIncludedDependency"
+);
 
+WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	renderStartup(
-		source,
-		module,
-		{ moduleGraph, chunk },
-		{ options, compilation }
-	) {
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		const staticExports = this.unnamed === "static";
-		const exportAccess = options.export
-			? propertyAccess(
-					Array.isArray(options.export) ? options.export : [options.export]
+	apply(dependency, source, { runtimeTemplate, chunkGraph, moduleGraph }) {
+		const dep = /** @type {WebpackIsIncludedDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		const included = connection
+			? chunkGraph.getNumberOfModuleChunks(connection.module) > 0
+			: false;
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
 			  )
 			: "";
-		const result = new ConcatSource(source);
-		if (staticExports) {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const exportTarget = accessWithInit(
-				fullNameResolved,
-				this._getPrefix(compilation).length,
-				true
-			);
-			for (const exportInfo of exportsInfo.orderedExports) {
-				if (!exportInfo.provided) continue;
-				const nameAccess = propertyAccess([exportInfo.name]);
-				result.add(
-					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
-				);
-			}
-			result.add(
-				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
-			);
-		} else if (options.name ? this.named === "copy" : this.unnamed === "copy") {
-			result.add(
-				`var __webpack_export_target__ = ${accessWithInit(
-					fullNameResolved,
-					this._getPrefix(compilation).length,
-					true
-				)};\n`
-			);
-			let exports = "__webpack_exports__";
-			if (exportAccess) {
-				result.add(
-					`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
-				);
-				exports = "__webpack_exports_export__";
-			}
-			result.add(
-				`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`
-			);
-			result.add(
-				`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`
-			);
-		} else {
-			result.add(
-				`${accessWithInit(
-					fullNameResolved,
-					this._getPrefix(compilation).length,
-					false
-				)} = __webpack_exports__${exportAccess};\n`
-			);
-		}
-		return result;
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${comment}${JSON.stringify(included)}`
+		);
+	}
+};
+
+module.exports = WebpackIsIncludedDependency;
+
+
+/***/ }),
+
+/***/ 1466:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WorkerDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	runtimeRequirements(chunk, set, libraryContext) {
-		// we don't need to return exports from runtime
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "new Worker()";
+	}
+
+	get category() {
+		return "worker";
 	}
+}
 
+WorkerDependency.Template = class WorkerDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("AssignLibraryPlugin");
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
+	apply(dependency, source, templateContext) {
+		const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+		const dep = /** @type {WorkerDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dependency)
+		);
+		const entrypoint = /** @type {Entrypoint} */ (
+			chunkGraph.getBlockChunkGroup(block)
+		);
+		const chunk = entrypoint.getEntrypointChunk();
+
+		runtimeRequirements.add(RuntimeGlobals.publicPath);
+		runtimeRequirements.add(RuntimeGlobals.baseURI);
+		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`/* worker import */ ${RuntimeGlobals.publicPath} + ${
+				RuntimeGlobals.getChunkScriptFilename
+			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
 		);
-		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
-			hash.update("copy");
-		}
-		if (this.declare) {
-			hash.update(this.declare);
-		}
-		hash.update(fullNameResolved.join("."));
-		if (options.export) {
-			hash.update(`${options.export}`);
-		}
 	}
-}
+};
 
-module.exports = AssignLibraryPlugin;
+makeSerializable(WorkerDependency, "webpack/lib/dependencies/WorkerDependency");
+
+module.exports = WorkerDependency;
 
 
 /***/ }),
 
-/***/ 91452:
+/***/ 82509:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -96365,252 +91710,483 @@ module.exports = AssignLibraryPlugin;
 
 
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Compiler")} Compiler */
+const { pathToFileURL } = __webpack_require__(57310);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const CommentCompilationWarning = __webpack_require__(98427);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const { equals } = __webpack_require__(84953);
+const createHash = __webpack_require__(49835);
+const { contextify } = __webpack_require__(82186);
+const EnableWasmLoadingPlugin = __webpack_require__(78613);
+const ConstDependency = __webpack_require__(76911);
+const CreateScriptUrlDependency = __webpack_require__(79062);
+const {
+	harmonySpecifierTag
+} = __webpack_require__(20862);
+const WorkerDependency = __webpack_require__(1466);
 
-/** @type {WeakMap<Compiler, Set<LibraryType>>} */
-const enabledTypes = new WeakMap();
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
-const getEnabledTypes = compiler => {
-	let set = enabledTypes.get(compiler);
-	if (set === undefined) {
-		set = new Set();
-		enabledTypes.set(compiler, set);
-	}
-	return set;
+const getUrl = module => {
+	return pathToFileURL(module.resource).toString();
 };
 
-class EnableLibraryPlugin {
+const DEFAULT_SYNTAX = [
+	"Worker",
+	"SharedWorker",
+	"navigator.serviceWorker.register()",
+	"Worker from worker_threads"
+];
+
+/** @type {WeakMap<ParserState, number>} */
+const workerIndexMap = new WeakMap();
+
+class WorkerPlugin {
+	constructor(chunkLoading, wasmLoading, module) {
+		this._chunkLoading = chunkLoading;
+		this._wasmLoading = wasmLoading;
+		this._module = module;
+	}
 	/**
-	 * @param {LibraryType} type library type that should be available
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(type) {
-		this.type = type;
+	apply(compiler) {
+		if (this._chunkLoading) {
+			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
+		}
+		if (this._wasmLoading) {
+			new EnableWasmLoadingPlugin(this._wasmLoading).apply(compiler);
+		}
+		const cachedContextify = contextify.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
+		compiler.hooks.thisCompilation.tap(
+			"WorkerPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WorkerDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					WorkerDependency,
+					new WorkerDependency.Template()
+				);
+				compilation.dependencyTemplates.set(
+					CreateScriptUrlDependency,
+					new CreateScriptUrlDependency.Template()
+				);
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {Expression} expr expression
+				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
+				 */
+				const parseModuleUrl = (parser, expr) => {
+					if (
+						expr.type !== "NewExpression" ||
+						expr.callee.type === "Super" ||
+						expr.arguments.length !== 2
+					)
+						return;
+					const [arg1, arg2] = expr.arguments;
+					if (arg1.type === "SpreadElement") return;
+					if (arg2.type === "SpreadElement") return;
+					const callee = parser.evaluateExpression(expr.callee);
+					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
+					const arg2Value = parser.evaluateExpression(arg2);
+					if (
+						!arg2Value.isString() ||
+						!arg2Value.string.startsWith("file://") ||
+						arg2Value.string !== getUrl(parser.state.module)
+					) {
+						return;
+					}
+					const arg1Value = parser.evaluateExpression(arg1);
+					return [arg1Value, [arg1.range[0], arg2.range[1]]];
+				};
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {ObjectExpression} expr expression
+				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
+				 */
+				const parseObjectExpression = (parser, expr) => {
+					/** @type {Record<string, any>} */
+					const values = {};
+					/** @type {Record<string, Expression | Pattern>} */
+					const expressions = {};
+					/** @type {(Property | SpreadElement)[]} */
+					const otherElements = [];
+					let spread = false;
+					for (const prop of expr.properties) {
+						if (prop.type === "SpreadElement") {
+							spread = true;
+						} else if (
+							prop.type === "Property" &&
+							!prop.method &&
+							!prop.computed &&
+							prop.key.type === "Identifier"
+						) {
+							expressions[prop.key.name] = prop.value;
+							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
+								const value = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (value.isCompileTimeValue())
+									values[prop.key.name] = value.asCompileTimeValue();
+							}
+						} else {
+							otherElements.push(prop);
+						}
+					}
+					const insertType = expr.properties.length > 0 ? "comma" : "single";
+					const insertLocation =
+						expr.properties[expr.properties.length - 1].range[1];
+					return {
+						expressions,
+						otherElements,
+						values,
+						spread,
+						insertType,
+						insertLocation
+					};
+				};
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {object} parserOptions options
+				 */
+				const parserPlugin = (parser, parserOptions) => {
+					if (parserOptions.worker === false) return;
+					const options = !Array.isArray(parserOptions.worker)
+						? ["..."]
+						: parserOptions.worker;
+					const handleNewWorker = expr => {
+						if (expr.arguments.length === 0 || expr.arguments.length > 2)
+							return;
+						const [arg1, arg2] = expr.arguments;
+						if (arg1.type === "SpreadElement") return;
+						if (arg2 && arg2.type === "SpreadElement") return;
+						const parsedUrl = parseModuleUrl(parser, arg1);
+						if (!parsedUrl) return;
+						const [url, range] = parsedUrl;
+						if (!url.isString()) return;
+						const {
+							expressions,
+							otherElements,
+							values: options,
+							spread: hasSpreadInOptions,
+							insertType,
+							insertLocation
+						} = arg2 && arg2.type === "ObjectExpression"
+							? parseObjectExpression(parser, arg2)
+							: {
+									expressions: {},
+									otherElements: [],
+									values: {},
+									spread: false,
+									insertType: arg2 ? "spread" : "argument",
+									insertLocation: arg2 ? arg2.range : arg1.range[1]
+							  };
+						const { options: importOptions, errors: commentErrors } =
+							parser.parseCommentOptions(expr.range);
+
+						if (commentErrors) {
+							for (const e of commentErrors) {
+								const { comment } = e;
+								parser.state.module.addWarning(
+									new CommentCompilationWarning(
+										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+										comment.loc
+									)
+								);
+							}
+						}
+
+						/** @type {EntryOptions} */
+						let entryOptions = {};
+
+						if (importOptions) {
+							if (importOptions.webpackIgnore !== undefined) {
+								if (typeof importOptions.webpackIgnore !== "boolean") {
+									parser.state.module.addWarning(
+										new UnsupportedFeatureWarning(
+											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+											expr.loc
+										)
+									);
+								} else {
+									if (importOptions.webpackIgnore) {
+										return false;
+									}
+								}
+							}
+							if (importOptions.webpackEntryOptions !== undefined) {
+								if (
+									typeof importOptions.webpackEntryOptions !== "object" ||
+									importOptions.webpackEntryOptions === null
+								) {
+									parser.state.module.addWarning(
+										new UnsupportedFeatureWarning(
+											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
+											expr.loc
+										)
+									);
+								} else {
+									Object.assign(
+										entryOptions,
+										importOptions.webpackEntryOptions
+									);
+								}
+							}
+							if (importOptions.webpackChunkName !== undefined) {
+								if (typeof importOptions.webpackChunkName !== "string") {
+									parser.state.module.addWarning(
+										new UnsupportedFeatureWarning(
+											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
+											expr.loc
+										)
+									);
+								} else {
+									entryOptions.name = importOptions.webpackChunkName;
+								}
+							}
+						}
+
+						if (
+							!Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
+							options &&
+							typeof options.name === "string"
+						) {
+							entryOptions.name = options.name;
+						}
+
+						if (entryOptions.runtime === undefined) {
+							let i = workerIndexMap.get(parser.state) || 0;
+							workerIndexMap.set(parser.state, i + 1);
+							let name = `${cachedContextify(
+								parser.state.module.identifier()
+							)}|${i}`;
+							const hash = createHash(compilation.outputOptions.hashFunction);
+							hash.update(name);
+							const digest = /** @type {string} */ (
+								hash.digest(compilation.outputOptions.hashDigest)
+							);
+							entryOptions.runtime = digest.slice(
+								0,
+								compilation.outputOptions.hashDigestLength
+							);
+						}
+
+						const block = new AsyncDependenciesBlock({
+							name: entryOptions.name,
+							entryOptions: {
+								chunkLoading: this._chunkLoading,
+								wasmLoading: this._wasmLoading,
+								...entryOptions
+							}
+						});
+						block.loc = expr.loc;
+						const dep = new WorkerDependency(url.string, range);
+						dep.loc = expr.loc;
+						block.addDependency(dep);
+						parser.state.module.addBlock(block);
+
+						if (compilation.outputOptions.trustedTypes) {
+							const dep = new CreateScriptUrlDependency(
+								expr.arguments[0].range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+						}
+
+						if (expressions.type) {
+							const expr = expressions.type;
+							if (options.type !== false) {
+								const dep = new ConstDependency(
+									this._module ? '"module"' : "undefined",
+									expr.range
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								expressions.type = undefined;
+							}
+						} else if (insertType === "comma") {
+							if (this._module || hasSpreadInOptions) {
+								const dep = new ConstDependency(
+									`, type: ${this._module ? '"module"' : "undefined"}`,
+									insertLocation
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
+						} else if (insertType === "spread") {
+							const dep1 = new ConstDependency(
+								"Object.assign({}, ",
+								insertLocation[0]
+							);
+							const dep2 = new ConstDependency(
+								`, { type: ${this._module ? '"module"' : "undefined"} })`,
+								insertLocation[1]
+							);
+							dep1.loc = expr.loc;
+							dep2.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep1);
+							parser.state.module.addPresentationalDependency(dep2);
+						} else if (insertType === "argument") {
+							if (this._module) {
+								const dep = new ConstDependency(
+									', { type: "module" }',
+									insertLocation
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
+						}
+
+						parser.walkExpression(expr.callee);
+						for (const key of Object.keys(expressions)) {
+							if (expressions[key]) parser.walkExpression(expressions[key]);
+						}
+						for (const prop of otherElements) {
+							parser.walkProperty(prop);
+						}
+						if (insertType === "spread") {
+							parser.walkExpression(arg2);
+						}
+
+						return true;
+					};
+					const processItem = item => {
+						if (item.endsWith("()")) {
+							parser.hooks.call
+								.for(item.slice(0, -2))
+								.tap("WorkerPlugin", handleNewWorker);
+						} else {
+							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
+							if (match) {
+								const ids = match[1].split(".");
+								const call = match[2];
+								const source = match[3];
+								(call ? parser.hooks.call : parser.hooks.new)
+									.for(harmonySpecifierTag)
+									.tap("WorkerPlugin", expr => {
+										const settings = /** @type {HarmonySettings} */ (
+											parser.currentTagData
+										);
+										if (
+											!settings ||
+											settings.source !== source ||
+											!equals(settings.ids, ids)
+										) {
+											return;
+										}
+										return handleNewWorker(expr);
+									});
+							} else {
+								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
+							}
+						}
+					};
+					for (const item of options) {
+						if (item === "...") {
+							DEFAULT_SYNTAX.forEach(processItem);
+						} else processItem(item);
+					}
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("WorkerPlugin", parserPlugin);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("WorkerPlugin", parserPlugin);
+			}
+		);
 	}
+}
+module.exports = WorkerPlugin;
 
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {LibraryType} type type of library
-	 * @returns {void}
-	 */
-	static setEnabled(compiler, type) {
-		getEnabledTypes(compiler).add(type);
-	}
 
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {LibraryType} type type of library
-	 * @returns {void}
-	 */
-	static checkEnabled(compiler, type) {
-		if (!getEnabledTypes(compiler).has(type)) {
-			throw new Error(
-				`Library type "${type}" is not enabled. ` +
-					"EnableLibraryPlugin need to be used to enable this type of library. " +
-					'This usually happens through the "output.enabledLibraryTypes" option. ' +
-					'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
-					"These types are enabled: " +
-					Array.from(getEnabledTypes(compiler)).join(", ")
-			);
-		}
-	}
+/***/ }),
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { type } = this;
+/***/ 50396:
+/***/ (function(module) {
 
-		// Only enable once
-		const enabled = getEnabledTypes(compiler);
-		if (enabled.has(type)) return;
-		enabled.add(type);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (typeof type === "string") {
-			const enableExportProperty = () => {
-				const ExportPropertyTemplatePlugin = __webpack_require__(5487);
-				new ExportPropertyTemplatePlugin({
-					type,
-					nsObjectUsed: type !== "module"
-				}).apply(compiler);
-			};
-			switch (type) {
-				case "var": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: [],
-						declare: "var",
-						unnamed: "error"
-					}).apply(compiler);
-					break;
-				}
-				case "assign-properties": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: [],
-						declare: false,
-						unnamed: "error",
-						named: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "assign": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: [],
-						declare: false,
-						unnamed: "error"
-					}).apply(compiler);
-					break;
-				}
-				case "this": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["this"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "window": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["window"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "self": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["self"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "global": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: "global",
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "commonjs": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["exports"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "commonjs-static": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["exports"],
-						declare: false,
-						unnamed: "static"
-					}).apply(compiler);
-					break;
-				}
-				case "commonjs2":
-				case "commonjs-module": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["module", "exports"],
-						declare: false,
-						unnamed: "assign"
-					}).apply(compiler);
-					break;
-				}
-				case "amd":
-				case "amd-require": {
-					enableExportProperty();
-					const AmdLibraryPlugin = __webpack_require__(67416);
-					new AmdLibraryPlugin({
-						type,
-						requireAsWrapper: type === "amd-require"
-					}).apply(compiler);
-					break;
-				}
-				case "umd":
-				case "umd2": {
-					enableExportProperty();
-					const UmdLibraryPlugin = __webpack_require__(54442);
-					new UmdLibraryPlugin({
-						type,
-						optionalAmdExternalAsGlobal: type === "umd2"
-					}).apply(compiler);
-					break;
-				}
-				case "system": {
-					enableExportProperty();
-					const SystemLibraryPlugin = __webpack_require__(11707);
-					new SystemLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
-				case "jsonp": {
-					enableExportProperty();
-					const JsonpLibraryPlugin = __webpack_require__(84415);
-					new JsonpLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
-				case "module": {
-					enableExportProperty();
-					const ModuleLibraryPlugin = __webpack_require__(59780);
-					new ModuleLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
-				default:
-					throw new Error(`Unsupported library type ${type}.
-Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);
-			}
-		} else {
-			// TODO support plugin instances here
-			// apply them to the compiler
-		}
+
+
+module.exports = expr => {
+	// <FunctionExpression>
+	if (
+		expr.type === "FunctionExpression" ||
+		expr.type === "ArrowFunctionExpression"
+	) {
+		return {
+			fn: expr,
+			expressions: [],
+			needThis: false
+		};
 	}
-}
 
-module.exports = EnableLibraryPlugin;
+	// <FunctionExpression>.bind(<Expression>)
+	if (
+		expr.type === "CallExpression" &&
+		expr.callee.type === "MemberExpression" &&
+		expr.callee.object.type === "FunctionExpression" &&
+		expr.callee.property.type === "Identifier" &&
+		expr.callee.property.name === "bind" &&
+		expr.arguments.length === 1
+	) {
+		return {
+			fn: expr.callee.object,
+			expressions: [expr.arguments[0]],
+			needThis: undefined
+		};
+	}
+	// (function(_this) {return <FunctionExpression>})(this) (Coffeescript)
+	if (
+		expr.type === "CallExpression" &&
+		expr.callee.type === "FunctionExpression" &&
+		expr.callee.body.type === "BlockStatement" &&
+		expr.arguments.length === 1 &&
+		expr.arguments[0].type === "ThisExpression" &&
+		expr.callee.body.body &&
+		expr.callee.body.body.length === 1 &&
+		expr.callee.body.body[0].type === "ReturnStatement" &&
+		expr.callee.body.body[0].argument &&
+		expr.callee.body.body[0].argument.type === "FunctionExpression"
+	) {
+		return {
+			fn: expr.callee.body.body[0].argument,
+			expressions: [],
+			needThis: true
+		};
+	}
+};
 
 
 /***/ }),
 
-/***/ 5487:
+/***/ 55207:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -96621,117 +92197,69 @@ module.exports = EnableLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
 const { UsageState } = __webpack_require__(63686);
-const propertyAccess = __webpack_require__(54190);
-const { getEntryRuntime } = __webpack_require__(17156);
-const AbstractLibraryPlugin = __webpack_require__(26030);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-/**
- * @typedef {Object} ExportPropertyLibraryPluginParsed
- * @property {string | string[]} export
- */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} ExportPropertyLibraryPluginOptions
- * @property {LibraryType} type
- * @property {boolean} nsObjectUsed the namespace object is used
- */
-/**
- * @typedef {ExportPropertyLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<ExportPropertyLibraryPluginParsed>}
+ * @param {RuntimeSpec} runtime the runtime
+ * @param {string[][]} referencedExports list of referenced exports, will be added to
+ * @param {string[]} prefix export prefix
+ * @param {ExportInfo=} exportInfo the export info
+ * @param {boolean} defaultPointsToSelf when true, using default will reference itself
+ * @param {Set<ExportInfo>} alreadyVisited already visited export info (to handle circular reexports)
  */
-class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {ExportPropertyLibraryPluginOptions} options options
-	 */
-	constructor({ type, nsObjectUsed }) {
-		super({
-			pluginName: "ExportPropertyLibraryPlugin",
-			type
-		});
-		this.nsObjectUsed = nsObjectUsed;
+const processExportInfo = (
+	runtime,
+	referencedExports,
+	prefix,
+	exportInfo,
+	defaultPointsToSelf = false,
+	alreadyVisited = new Set()
+) => {
+	if (!exportInfo) {
+		referencedExports.push(prefix);
+		return;
 	}
-
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		return {
-			export: library.export
-		};
+	const used = exportInfo.getUsed(runtime);
+	if (used === UsageState.Unused) return;
+	if (alreadyVisited.has(exportInfo)) {
+		referencedExports.push(prefix);
+		return;
 	}
-
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {string} entryName the name of the entrypoint
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	finishEntryModule(
-		module,
-		entryName,
-		{ options, compilation, compilation: { moduleGraph } }
+	alreadyVisited.add(exportInfo);
+	if (
+		used !== UsageState.OnlyPropertiesUsed ||
+		!exportInfo.exportsInfo ||
+		exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !==
+			UsageState.Unused
 	) {
-		const runtime = getEntryRuntime(compilation, entryName);
-		if (options.export) {
-			const exportsInfo = moduleGraph.getExportInfo(
-				module,
-				Array.isArray(options.export) ? options.export[0] : options.export
-			);
-			exportsInfo.setUsed(UsageState.Used, runtime);
-			exportsInfo.canMangleUse = false;
-		} else {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			if (this.nsObjectUsed) {
-				exportsInfo.setUsedInUnknownWay(runtime);
-			} else {
-				exportsInfo.setAllKnownExportsUsed(runtime);
-			}
-		}
-		moduleGraph.addExtraReason(module, "used as library export");
+		alreadyVisited.delete(exportInfo);
+		referencedExports.push(prefix);
+		return;
 	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	runtimeRequirements(chunk, set, libraryContext) {}
-
-	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	renderStartup(source, module, renderContext, { options }) {
-		if (!options.export) return source;
-		const postfix = `__webpack_exports__ = __webpack_exports__${propertyAccess(
-			Array.isArray(options.export) ? options.export : [options.export]
-		)};\n`;
-		return new ConcatSource(source, postfix);
+	const exportsInfo = exportInfo.exportsInfo;
+	for (const exportInfo of exportsInfo.orderedExports) {
+		processExportInfo(
+			runtime,
+			referencedExports,
+			defaultPointsToSelf && exportInfo.name === "default"
+				? prefix
+				: prefix.concat(exportInfo.name),
+			exportInfo,
+			false,
+			alreadyVisited
+		);
 	}
-}
-
-module.exports = ExportPropertyLibraryPlugin;
+	alreadyVisited.delete(exportInfo);
+};
+module.exports = processExportInfo;
 
 
 /***/ }),
 
-/***/ 84415:
+/***/ 32277:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -96742,92 +92270,72 @@ module.exports = ExportPropertyLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const ExternalsPlugin = __webpack_require__(6652);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} JsonpLibraryPluginOptions
- * @property {LibraryType} type
- */
-
-/**
- * @typedef {Object} JsonpLibraryPluginParsed
- * @property {string} name
- */
-
-/**
- * @typedef {JsonpLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<JsonpLibraryPluginParsed>}
- */
-class JsonpLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {JsonpLibraryPluginOptions} options the plugin options
-	 */
-	constructor(options) {
-		super({
-			pluginName: "JsonpLibraryPlugin",
-			type: options.type
-		});
-	}
-
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (typeof name !== "string") {
-			throw new Error(
-				`Jsonp library name must be a simple string. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-			);
-		}
-		return {
-			name: /** @type {string} */ (name)
-		};
-	}
 
+class ElectronTargetPlugin {
 	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
+	 * @param {"main" | "preload" | "renderer"=} context in main, preload or renderer context?
 	 */
-	render(source, { chunk }, { options, compilation }) {
-		const name = compilation.getPath(options.name, {
-			chunk
-		});
-		return new ConcatSource(`${name}(`, source, ")");
+	constructor(context) {
+		this._context = context;
 	}
-
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("JsonpLibraryPlugin");
-		hash.update(compilation.getPath(options.name, { chunk }));
+	apply(compiler) {
+		new ExternalsPlugin("node-commonjs", [
+			"clipboard",
+			"crash-reporter",
+			"electron",
+			"ipc",
+			"native-image",
+			"original-fs",
+			"screen",
+			"shell"
+		]).apply(compiler);
+		switch (this._context) {
+			case "main":
+				new ExternalsPlugin("node-commonjs", [
+					"app",
+					"auto-updater",
+					"browser-window",
+					"content-tracing",
+					"dialog",
+					"global-shortcut",
+					"ipc-main",
+					"menu",
+					"menu-item",
+					"power-monitor",
+					"power-save-blocker",
+					"protocol",
+					"session",
+					"tray",
+					"web-contents"
+				]).apply(compiler);
+				break;
+			case "preload":
+			case "renderer":
+				new ExternalsPlugin("node-commonjs", [
+					"desktop-capturer",
+					"ipc-renderer",
+					"remote",
+					"web-frame"
+				]).apply(compiler);
+				break;
+		}
 	}
 }
 
-module.exports = JsonpLibraryPlugin;
+module.exports = ElectronTargetPlugin;
 
 
 /***/ }),
 
-/***/ 59780:
+/***/ 22273:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -96838,349 +92346,278 @@ module.exports = JsonpLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const Template = __webpack_require__(1626);
-const propertyAccess = __webpack_require__(54190);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} ModuleLibraryPluginOptions
- * @property {LibraryType} type
- */
 
-/**
- * @typedef {Object} ModuleLibraryPluginParsed
- * @property {string} name
- */
-
-/**
- * @typedef {ModuleLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
- */
-class ModuleLibraryPlugin extends AbstractLibraryPlugin {
+class BuildCycleError extends WebpackError {
 	/**
-	 * @param {ModuleLibraryPluginOptions} options the plugin options
+	 * Creates an instance of ModuleDependencyError.
+	 * @param {Module} module the module starting the cycle
 	 */
-	constructor(options) {
-		super({
-			pluginName: "ModuleLibraryPlugin",
-			type: options.type
-		});
+	constructor(module) {
+		super(
+			"There is a circular build dependency, which makes it impossible to create this module"
+		);
+
+		this.name = "BuildCycleError";
+		this.module = module;
+	}
+}
+
+module.exports = BuildCycleError;
+
+
+/***/ }),
+
+/***/ 5294:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeModule = __webpack_require__(16963);
+
+class ExportWebpackRequireRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("export webpack runtime", RuntimeModule.STAGE_ATTACH);
 	}
 
 	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (name) {
-			throw new Error(
-				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-			);
-		}
-		return {
-			name: /** @type {string} */ (name)
-		};
+	shouldIsolate() {
+		return false;
 	}
 
 	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
+	 * @returns {string} runtime code
 	 */
-	renderStartup(
-		source,
-		module,
-		{ moduleGraph, chunk },
-		{ options, compilation }
-	) {
-		const result = new ConcatSource(source);
-		const exportsInfo = moduleGraph.getExportsInfo(module);
-		const exports = [];
-		const isAsync = moduleGraph.isAsync(module);
-		if (isAsync) {
-			result.add(`__webpack_exports__ = await __webpack_exports__;\n`);
-		}
-		for (const exportInfo of exportsInfo.orderedExports) {
-			if (!exportInfo.provided) continue;
-			const varName = `__webpack_exports__${Template.toIdentifier(
-				exportInfo.name
-			)}`;
-			result.add(
-				`var ${varName} = __webpack_exports__${propertyAccess([
-					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
-				])};\n`
-			);
-			exports.push(`${varName} as ${exportInfo.name}`);
-		}
-		if (exports.length > 0) {
-			result.add(`export { ${exports.join(", ")} };\n`);
-		}
-		return result;
+	generate() {
+		return "export default __webpack_require__;";
 	}
 }
 
-module.exports = ModuleLibraryPlugin;
+module.exports = ExportWebpackRequireRuntimeModule;
 
 
 /***/ }),
 
-/***/ 11707:
+/***/ 68927:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Joel Denning @joeldenning
+	Author Tobias Koppers @sokra
 */
 
 
 
 const { ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const ExternalModule = __webpack_require__(73071);
-const Template = __webpack_require__(1626);
-const propertyAccess = __webpack_require__(54190);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const { RuntimeGlobals } = __webpack_require__(91919);
+const HotUpdateChunk = __webpack_require__(9597);
+const Template = __webpack_require__(39722);
+const { getAllChunks } = __webpack_require__(91145);
+const {
+	getCompilationHooks,
+	getChunkFilenameTemplate
+} = __webpack_require__(89464);
+const { updateHashForEntryStartup } = __webpack_require__(98124);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} SystemLibraryPluginOptions
- * @property {LibraryType} type
- */
-
-/**
- * @typedef {Object} SystemLibraryPluginParsed
- * @property {string} name
- */
-
-/**
- * @typedef {SystemLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<SystemLibraryPluginParsed>}
- */
-class SystemLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {SystemLibraryPluginOptions} options the plugin options
-	 */
-	constructor(options) {
-		super({
-			pluginName: "SystemLibraryPlugin",
-			type: options.type
-		});
-	}
-
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (name && typeof name !== "string") {
-			throw new Error(
-				`System.js library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-			);
-		}
-		return {
-			name: /** @type {string=} */ (name)
-		};
-	}
 
+class ModuleChunkFormatPlugin {
 	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
-		const modules = chunkGraph
-			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule && m.externalType === "system");
-		const externals = /** @type {ExternalModule[]} */ (modules);
-
-		// The name this bundle should be registered as with System
-		const name = options.name
-			? `${JSON.stringify(compilation.getPath(options.name, { chunk }))}, `
-			: "";
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ModuleChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ModuleChunkFormatPlugin",
+					(chunk, set) => {
+						if (chunk.hasRuntime()) return;
+						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.require);
+							set.add(RuntimeGlobals.startupEntrypoint);
+							set.add(RuntimeGlobals.externalInstallChunk);
+						}
+					}
+				);
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"ModuleChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
+						const source = new ConcatSource();
+						if (hotUpdateChunk) {
+							throw new Error(
+								"HMR is not implemented for module chunk format yet"
+							);
+						} else {
+							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
+							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
+							source.add(`export const modules = `);
+							source.add(modules);
+							source.add(`;\n`);
+							const runtimeModules =
+								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+							if (runtimeModules.length > 0) {
+								source.add("export const runtime =\n");
+								source.add(
+									Template.renderChunkRuntimeModules(
+										runtimeModules,
+										renderContext
+									)
+								);
+							}
+							const entries = Array.from(
+								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+							);
+							if (entries.length > 0) {
+								const runtimeChunk = entries[0][1].getRuntimeChunk();
+								const currentOutputName = compilation
+									.getPath(
+										getChunkFilenameTemplate(chunk, compilation.outputOptions),
+										{
+											chunk,
+											contentHashType: "javascript"
+										}
+									)
+									.split("/");
 
-		// The array of dependencies that are external to webpack and will be provided by System
-		const systemDependencies = JSON.stringify(
-			externals.map(m =>
-				typeof m.request === "object" && !Array.isArray(m.request)
-					? m.request.amd
-					: m.request
-			)
-		);
+								// remove filename, we only need the directory
+								currentOutputName.pop();
 
-		// The name of the variable provided by System for exporting
-		const dynamicExport = "__WEBPACK_DYNAMIC_EXPORT__";
+								const getRelativePath = chunk => {
+									const baseOutputName = currentOutputName.slice();
+									const chunkOutputName = compilation
+										.getPath(
+											getChunkFilenameTemplate(
+												chunk,
+												compilation.outputOptions
+											),
+											{
+												chunk: chunk,
+												contentHashType: "javascript"
+											}
+										)
+										.split("/");
 
-		// An array of the internal variable names for the webpack externals
-		const externalWebpackNames = externals.map(
-			m =>
-				`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-					`${chunkGraph.getModuleId(m)}`
-				)}__`
-		);
+									// remove common parts
+									while (
+										baseOutputName.length > 0 &&
+										chunkOutputName.length > 0 &&
+										baseOutputName[0] === chunkOutputName[0]
+									) {
+										baseOutputName.shift();
+										chunkOutputName.shift();
+									}
+									// create final path
+									return (
+										(baseOutputName.length > 0
+											? "../".repeat(baseOutputName.length)
+											: "./") + chunkOutputName.join("/")
+									);
+								};
 
-		// Declaring variables for the internal variable names for the webpack externals
-		const externalVarDeclarations = externalWebpackNames
-			.map(name => `var ${name} = {};`)
-			.join("\n");
+								const entrySource = new ConcatSource();
+								entrySource.add(source);
+								entrySource.add(";\n\n// load runtime\n");
+								entrySource.add(
+									`import __webpack_require__ from ${JSON.stringify(
+										getRelativePath(runtimeChunk)
+									)};\n`
+								);
 
-		// Define __esModule flag on all internal variables and helpers
-		const externalVarInitialization = [];
+								const startupSource = new ConcatSource();
+								startupSource.add(
+									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+										`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+										"moduleId"
+									)}\n`
+								);
 
-		// The system.register format requires an array of setter functions for externals.
-		const setters =
-			externalWebpackNames.length === 0
-				? ""
-				: Template.asString([
-						"setters: [",
-						Template.indent(
-							externals
-								.map((module, i) => {
-									const external = externalWebpackNames[i];
-									const exportsInfo = moduleGraph.getExportsInfo(module);
-									const otherUnused =
-										exportsInfo.otherExportsInfo.getUsed(chunk.runtime) ===
-										UsageState.Unused;
-									const instructions = [];
-									const handledNames = [];
-									for (const exportInfo of exportsInfo.orderedExports) {
-										const used = exportInfo.getUsedName(
-											undefined,
-											chunk.runtime
+								const loadedChunks = new Set();
+								let index = 0;
+								for (let i = 0; i < entries.length; i++) {
+									const [module, entrypoint] = entries[i];
+									const final = i + 1 === entries.length;
+									const moduleId = chunkGraph.getModuleId(module);
+									const chunks = getAllChunks(
+										entrypoint,
+										runtimeChunk,
+										undefined
+									);
+									for (const chunk of chunks) {
+										if (loadedChunks.has(chunk)) continue;
+										loadedChunks.add(chunk);
+										startupSource.add(
+											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
+												getRelativePath(chunk)
+											)};\n`
 										);
-										if (used) {
-											if (otherUnused || used !== exportInfo.name) {
-												instructions.push(
-													`${external}${propertyAccess([
-														used
-													])} = module${propertyAccess([exportInfo.name])};`
-												);
-												handledNames.push(exportInfo.name);
-											}
-										} else {
-											handledNames.push(exportInfo.name);
-										}
-									}
-									if (!otherUnused) {
-										if (
-											!Array.isArray(module.request) ||
-											module.request.length === 1
-										) {
-											externalVarInitialization.push(
-												`Object.defineProperty(${external}, "__esModule", { value: true });`
-											);
-										}
-										if (handledNames.length > 0) {
-											const name = `${external}handledNames`;
-											externalVarInitialization.push(
-												`var ${name} = ${JSON.stringify(handledNames)};`
-											);
-											instructions.push(
-												Template.asString([
-													"Object.keys(module).forEach(function(key) {",
-													Template.indent([
-														`if(${name}.indexOf(key) >= 0)`,
-														Template.indent(`${external}[key] = module[key];`)
-													]),
-													"});"
-												])
-											);
-										} else {
-											instructions.push(
-												Template.asString([
-													"Object.keys(module).forEach(function(key) {",
-													Template.indent([`${external}[key] = module[key];`]),
-													"});"
-												])
-											);
-										}
+										startupSource.add(
+											`${RuntimeGlobals.externalInstallChunk}(__webpack_chunk_${index}__);\n`
+										);
+										index++;
 									}
-									if (instructions.length === 0) return "function() {}";
-									return Template.asString([
-										"function(module) {",
-										Template.indent(instructions),
-										"}"
-									]);
-								})
-								.join(",\n")
-						),
-						"],"
-				  ]);
+									startupSource.add(
+										`${
+											final ? "var __webpack_exports__ = " : ""
+										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
+									);
+								}
 
-		return new ConcatSource(
-			Template.asString([
-				`System.register(${name}${systemDependencies}, function(${dynamicExport}, __system_context__) {`,
-				Template.indent([
-					externalVarDeclarations,
-					Template.asString(externalVarInitialization),
-					"return {",
-					Template.indent([
-						setters,
-						"execute: function() {",
-						Template.indent(`${dynamicExport}(`)
-					])
-				]),
-				""
-			]),
-			source,
-			Template.asString([
-				"",
-				Template.indent([
-					Template.indent([Template.indent([");"]), "}"]),
-					"};"
-				]),
-				"})"
-			])
+								entrySource.add(
+									hooks.renderStartup.call(
+										startupSource,
+										entries[entries.length - 1][0],
+										{
+											...renderContext,
+											inlined: false
+										}
+									)
+								);
+								return entrySource;
+							}
+						}
+						return source;
+					}
+				);
+				hooks.chunkHash.tap(
+					"ModuleChunkFormatPlugin",
+					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update("ModuleChunkFormatPlugin");
+						hash.update("1");
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
+			}
 		);
 	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("SystemLibraryPlugin");
-		if (options.name) {
-			hash.update(compilation.getPath(options.name, { chunk }));
-		}
-	}
 }
 
-module.exports = SystemLibraryPlugin;
+module.exports = ModuleChunkFormatPlugin;
 
 
 /***/ }),
 
-/***/ 54442:
+/***/ 89831:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -97191,329 +92628,441 @@ module.exports = SystemLibraryPlugin;
 
 
 
-const { ConcatSource, OriginalSource } = __webpack_require__(51255);
-const ExternalModule = __webpack_require__(73071);
-const Template = __webpack_require__(1626);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const RuntimeGlobals = __webpack_require__(16475);
+const ExportWebpackRequireRuntimeModule = __webpack_require__(5294);
+const ModuleChunkLoadingRuntimeModule = __webpack_require__(64747);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdCommentObject} LibraryCustomUmdCommentObject */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdObject} LibraryCustomUmdObject */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-/**
- * @param {string[]} accessor the accessor to convert to path
- * @returns {string} the path
- */
-const accessorToObjectAccess = accessor => {
-	return accessor.map(a => `[${JSON.stringify(a)}]`).join("");
-};
+class ModuleChunkLoadingPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ModuleChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						(options && options.chunkLoading) || globalChunkLoading;
+					return chunkLoading === "import";
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
+						chunk,
+						new ModuleChunkLoadingRuntimeModule(set)
+					);
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						compilation.addRuntimeModule(
+							chunk,
+							new ExportWebpackRequireRuntimeModule()
+						);
+					});
 
-/**
- * @param {string|undefined} base the path prefix
- * @param {string|string[]} accessor the accessor
- * @param {string=} joinWith the element separator
- * @returns {string} the path
- */
-const accessorAccess = (base, accessor, joinWith = ", ") => {
-	const accessors = Array.isArray(accessor) ? accessor : [accessor];
-	return accessors
-		.map((_, idx) => {
-			const a = base
-				? base + accessorToObjectAccess(accessors.slice(0, idx + 1))
-				: accessors[0] + accessorToObjectAccess(accessors.slice(1, idx + 1));
-			if (idx === accessors.length - 1) return a;
-			if (idx === 0 && base === undefined)
-				return `${a} = typeof ${a} === "object" ? ${a} : {}`;
-			return `${a} = ${a} || {}`;
-		})
-		.join(joinWith);
-};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+			}
+		);
+	}
+}
 
-/** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
+module.exports = ModuleChunkLoadingPlugin;
 
-/**
- * @typedef {Object} UmdLibraryPluginOptions
- * @property {LibraryType} type
- * @property {boolean=} optionalAmdExternalAsGlobal
- */
 
-/**
- * @typedef {Object} UmdLibraryPluginParsed
- * @property {string | string[]} name
- * @property {LibraryCustomUmdObject} names
- * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
- * @property {boolean} namedDefine
- */
+/***/ }),
+
+/***/ 64747:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const { SyncWaterfallHook } = __webpack_require__(41242);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const {
+	getChunkFilenameTemplate,
+	chunkHasJs
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
+
+/** @typedef {import("../Chunk")} Chunk */
 
 /**
- * @typedef {UmdLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<UmdLibraryPluginParsed>}
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
  */
-class UmdLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {UmdLibraryPluginOptions} options the plugin option
-	 */
-	constructor(options) {
-		super({
-			pluginName: "UmdLibraryPlugin",
-			type: options.type
-		});
 
-		this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal;
-	}
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
 
+class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
 	 */
-	parseOptions(library) {
-		/** @type {LibraryName} */
-		let name;
-		/** @type {LibraryCustomUmdObject} */
-		let names;
-		if (typeof library.name === "object" && !Array.isArray(library.name)) {
-			name = library.name.root || library.name.amd || library.name.commonjs;
-			names = library.name;
-		} else {
-			name = library.name;
-			const singleName = Array.isArray(name) ? name[0] : name;
-			names = {
-				commonjs: singleName,
-				root: library.name,
-				amd: singleName
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
 			};
+			compilationHooksMap.set(compilation, hooks);
 		}
-		return {
-			name,
-			names,
-			auxiliaryComment: library.auxiliaryComment,
-			namedDefine: library.umdNamedDefine
-		};
+		return hooks;
+	}
+
+	constructor(runtimeRequirements) {
+		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
+	 * @returns {string} runtime code
 	 */
-	render(
-		source,
-		{ chunkGraph, runtimeTemplate, chunk, moduleGraph },
-		{ options, compilation }
-	) {
-		const modules = chunkGraph
-			.getChunkModules(chunk)
-			.filter(
-				m =>
-					m instanceof ExternalModule &&
-					(m.externalType === "umd" || m.externalType === "umd2")
-			);
-		let externals = /** @type {ExternalModule[]} */ (modules);
-		/** @type {ExternalModule[]} */
-		const optionalExternals = [];
-		/** @type {ExternalModule[]} */
-		let requiredExternals = [];
-		if (this.optionalAmdExternalAsGlobal) {
-			for (const m of externals) {
-				if (m.isOptional(moduleGraph)) {
-					optionalExternals.push(m);
-				} else {
-					requiredExternals.push(m);
-				}
+	generate() {
+		const { compilation, chunk } = this;
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			outputOptions: { importFunctionName, importMetaName }
+		} = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this._runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
+		const withLoading = this._runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withOnChunkLoad = this._runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withHmr = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
 			}
-			externals = requiredExternals.concat(optionalExternals);
-		} else {
-			requiredExternals = externals;
-		}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			true
+		);
 
-		const replaceKeys = str => {
-			return compilation.getPath(str, {
-				chunk
-			});
-		};
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_module`
+			: undefined;
 
-		const externalsDepsArray = modules => {
-			return `[${replaceKeys(
-				modules
-					.map(m =>
-						JSON.stringify(
-							typeof m.request === "object" ? m.request.amd : m.request
-						)
-					)
-					.join(", ")
-			)}]`;
-		};
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
+							rootOutputDir
+						)}, ${importMetaName}.url);`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
+						runtimeTemplate.destructureObject(
+							["ids", "modules", "runtime"],
+							"data"
+						),
+						'// add "modules" to the modules object,',
+						'// then flag all "ids" as loaded and fire callback',
+						"var moduleId, chunkId, i = 0;",
+						"for(moduleId in modules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
+							Template.indent(
+								`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
+							),
+							"}"
+						]),
+						"}",
+						"if(runtime) runtime(__webpack_require__);",
+						"for(;i < ids.length; i++) {",
+						Template.indent([
+							"chunkId = ids[i];",
+							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+							Template.indent("installedChunks[chunkId][0]();"),
+							"}",
+							"installedChunks[ids[i]] = 0;"
+						]),
+						"}",
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])}`
+				: "// no install chunk",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.j = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? Template.indent([
+										"// import() chunk loading for javascript",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[1]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasJsMatcher === true
+													? "if(true) { // all chunks have JS"
+													: `if(${hasJsMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = ${importFunctionName}(${JSON.stringify(
+														rootOutputDir
+													)} + ${
+														RuntimeGlobals.getChunkScriptFilename
+													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
+														"e",
+														[
+															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+															"throw e;"
+														]
+													)});`,
+													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve]`,
+														"resolve"
+													)})])`,
+													`promises.push(installedChunkData[1] = promise);`
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ])
+								: Template.indent(["installedChunks[chunkId] = 0;"])
+						)};`
+				  ])
+				: "// no chunk on demand loading",
+			"",
+			withExternalInstallChunk
+				? Template.asString([
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.j = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded"
+		]);
+	}
+}
+
+module.exports = ModuleChunkLoadingRuntimeModule;
+
+
+/***/ }),
+
+/***/ 16734:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
+
+/**
+ * @param {SourcePosition} pos position
+ * @returns {string} formatted position
+ */
+const formatPosition = pos => {
+	if (pos && typeof pos === "object") {
+		if ("line" in pos && "column" in pos) {
+			return `${pos.line}:${pos.column}`;
+		} else if ("line" in pos) {
+			return `${pos.line}:?`;
+		}
+	}
+	return "";
+};
+
+/**
+ * @param {DependencyLocation} loc location
+ * @returns {string} formatted location
+ */
+const formatLocation = loc => {
+	if (loc && typeof loc === "object") {
+		if ("start" in loc && loc.start && "end" in loc && loc.end) {
+			if (
+				typeof loc.start === "object" &&
+				typeof loc.start.line === "number" &&
+				typeof loc.end === "object" &&
+				typeof loc.end.line === "number" &&
+				typeof loc.end.column === "number" &&
+				loc.start.line === loc.end.line
+			) {
+				return `${formatPosition(loc.start)}-${loc.end.column}`;
+			} else if (
+				typeof loc.start === "object" &&
+				typeof loc.start.line === "number" &&
+				typeof loc.start.column !== "number" &&
+				typeof loc.end === "object" &&
+				typeof loc.end.line === "number" &&
+				typeof loc.end.column !== "number"
+			) {
+				return `${loc.start.line}-${loc.end.line}`;
+			} else {
+				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+			}
+		}
+		if ("start" in loc && loc.start) {
+			return formatPosition(loc.start);
+		}
+		if ("name" in loc && "index" in loc) {
+			return `${loc.name}[${loc.index}]`;
+		}
+		if ("name" in loc) {
+			return loc.name;
+		}
+	}
+	return "";
+};
 
-		const externalsRootArray = modules => {
-			return replaceKeys(
-				modules
-					.map(m => {
-						let request = m.request;
-						if (typeof request === "object") request = request.root;
-						return `root${accessorToObjectAccess([].concat(request))}`;
-					})
-					.join(", ")
-			);
-		};
+module.exports = formatLocation;
 
-		const externalsRequireArray = type => {
-			return replaceKeys(
-				externals
-					.map(m => {
-						let expr;
-						let request = m.request;
-						if (typeof request === "object") {
-							request = request[type];
-						}
-						if (request === undefined) {
-							throw new Error(
-								"Missing external configuration for type:" + type
-							);
-						}
-						if (Array.isArray(request)) {
-							expr = `require(${JSON.stringify(
-								request[0]
-							)})${accessorToObjectAccess(request.slice(1))}`;
-						} else {
-							expr = `require(${JSON.stringify(request)})`;
-						}
-						if (m.isOptional(moduleGraph)) {
-							expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
-						}
-						return expr;
-					})
-					.join(", ")
-			);
-		};
 
-		const externalsArguments = modules => {
-			return modules
-				.map(
-					m =>
-						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-							`${chunkGraph.getModuleId(m)}`
-						)}__`
-				)
-				.join(", ");
-		};
+/***/ }),
 
-		const libraryName = library => {
-			return JSON.stringify(replaceKeys([].concat(library).pop()));
-		};
+/***/ 27899:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		let amdFactory;
-		if (optionalExternals.length > 0) {
-			const wrapperArguments = externalsArguments(requiredExternals);
-			const factoryArguments =
-				requiredExternals.length > 0
-					? externalsArguments(requiredExternals) +
-					  ", " +
-					  externalsRootArray(optionalExternals)
-					: externalsRootArray(optionalExternals);
-			amdFactory =
-				`function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` +
-				`			return factory(${factoryArguments});\n` +
-				"		}";
-		} else {
-			amdFactory = "factory";
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const { auxiliaryComment, namedDefine, names } = options;
 
-		const getAuxiliaryComment = type => {
-			if (auxiliaryComment) {
-				if (typeof auxiliaryComment === "string")
-					return "\t//" + auxiliaryComment + "\n";
-				if (auxiliaryComment[type])
-					return "\t//" + auxiliaryComment[type] + "\n";
-			}
-			return "";
-		};
 
-		return new ConcatSource(
-			new OriginalSource(
-				"(function webpackUniversalModuleDefinition(root, factory) {\n" +
-					getAuxiliaryComment("commonjs2") +
-					"	if(typeof exports === 'object' && typeof module === 'object')\n" +
-					"		module.exports = factory(" +
-					externalsRequireArray("commonjs2") +
-					");\n" +
-					getAuxiliaryComment("amd") +
-					"	else if(typeof define === 'function' && define.amd)\n" +
-					(requiredExternals.length > 0
-						? names.amd && namedDefine === true
-							? "		define(" +
-							  libraryName(names.amd) +
-							  ", " +
-							  externalsDepsArray(requiredExternals) +
-							  ", " +
-							  amdFactory +
-							  ");\n"
-							: "		define(" +
-							  externalsDepsArray(requiredExternals) +
-							  ", " +
-							  amdFactory +
-							  ");\n"
-						: names.amd && namedDefine === true
-						? "		define(" +
-						  libraryName(names.amd) +
-						  ", [], " +
-						  amdFactory +
-						  ");\n"
-						: "		define([], " + amdFactory + ");\n") +
-					(names.root || names.commonjs
-						? getAuxiliaryComment("commonjs") +
-						  "	else if(typeof exports === 'object')\n" +
-						  "		exports[" +
-						  libraryName(names.commonjs || names.root) +
-						  "] = factory(" +
-						  externalsRequireArray("commonjs") +
-						  ");\n" +
-						  getAuxiliaryComment("root") +
-						  "	else\n" +
-						  "		" +
-						  replaceKeys(
-								accessorAccess("root", names.root || names.commonjs)
-						  ) +
-						  " = factory(" +
-						  externalsRootArray(externals) +
-						  ");\n"
-						: "	else {\n" +
-						  (externals.length > 0
-								? "		var a = typeof exports === 'object' ? factory(" +
-								  externalsRequireArray("commonjs") +
-								  ") : factory(" +
-								  externalsRootArray(externals) +
-								  ");\n"
-								: "		var a = factory();\n") +
-						  "		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" +
-						  "	}\n") +
-					`})(${
-						runtimeTemplate.outputOptions.globalObject
-					}, function(${externalsArguments(externals)}) {\nreturn `,
-				"webpack/universalModuleDefinition"
-			),
-			source,
-			";\n})"
-		);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+class HotModuleReplacementRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("hot module replacement", RuntimeModule.STAGE_BASIC);
+	}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return Template.getFunctionContent(
+			require('./HotModuleReplacement.runtime.js')
+		)
+			.replace(/\$getFullHash\$/g, RuntimeGlobals.getFullHash)
+			.replace(
+				/\$interceptModuleExecution\$/g,
+				RuntimeGlobals.interceptModuleExecution
+			)
+			.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+			.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+			.replace(/\$hmrDownloadManifest\$/g, RuntimeGlobals.hmrDownloadManifest)
+			.replace(
+				/\$hmrInvalidateModuleHandlers\$/g,
+				RuntimeGlobals.hmrInvalidateModuleHandlers
+			)
+			.replace(
+				/\$hmrDownloadUpdateHandlers\$/g,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			);
 	}
 }
 
-module.exports = UmdLibraryPlugin;
+module.exports = HotModuleReplacementRuntimeModule;
 
 
 /***/ }),
 
-/***/ 32597:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 79040:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -97523,167 +93072,422 @@ module.exports = UmdLibraryPlugin;
 
 
 
-const LogType = Object.freeze({
-	error: /** @type {"error"} */ ("error"), // message, c style arguments
-	warn: /** @type {"warn"} */ ("warn"), // message, c style arguments
-	info: /** @type {"info"} */ ("info"), // message, c style arguments
-	log: /** @type {"log"} */ ("log"), // message, c style arguments
-	debug: /** @type {"debug"} */ ("debug"), // message, c style arguments
-
-	trace: /** @type {"trace"} */ ("trace"), // no arguments
-
-	group: /** @type {"group"} */ ("group"), // [label]
-	groupCollapsed: /** @type {"groupCollapsed"} */ ("groupCollapsed"), // [label]
-	groupEnd: /** @type {"groupEnd"} */ ("groupEnd"), // [label]
-
-	profile: /** @type {"profile"} */ ("profile"), // [profileName]
-	profileEnd: /** @type {"profileEnd"} */ ("profileEnd"), // [profileName]
+const { RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Dependency = __webpack_require__(54912);
+const Module = __webpack_require__(73208);
+const ModuleFactory = __webpack_require__(51010);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const CommonJsRequireDependency = __webpack_require__(21264);
+const { registerNotSerializable } = __webpack_require__(8282);
 
-	time: /** @type {"time"} */ ("time"), // name, time as [seconds, nanoseconds]
+/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-	clear: /** @type {"clear"} */ ("clear"), // no arguments
-	status: /** @type {"status"} */ ("status") // message, arguments
-});
+/**
+ * @typedef {Object} BackendApi
+ * @property {function(Error=): void} dispose
+ * @property {function(Module): { client: string, data: string, active: boolean }} module
+ */
 
-exports.LogType = LogType;
+const HMR_DEPENDENCY_TYPES = new Set([
+	"import.meta.webpackHot.accept",
+	"import.meta.webpackHot.decline",
+	"module.hot.accept",
+	"module.hot.decline"
+]);
 
-/** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
+/**
+ * @param {undefined|string|RegExp|Function} test test option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkTest = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module);
+	}
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name && name.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name && test.test(name);
+	}
+	return false;
+};
 
-const LOG_SYMBOL = Symbol("webpack logger raw log method");
-const TIMERS_SYMBOL = Symbol("webpack logger times");
-const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
+const TYPES = new Set(["javascript"]);
 
-class WebpackLogger {
-	/**
-	 * @param {function(LogTypeEnum, any[]=): void} log log function
-	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
-	 */
-	constructor(log, getChildLogger) {
-		this[LOG_SYMBOL] = log;
-		this.getChildLogger = getChildLogger;
+class LazyCompilationDependency extends Dependency {
+	constructor(proxyModule) {
+		super();
+		this.proxyModule = proxyModule;
 	}
 
-	error(...args) {
-		this[LOG_SYMBOL](LogType.error, args);
+	get category() {
+		return "esm";
 	}
 
-	warn(...args) {
-		this[LOG_SYMBOL](LogType.warn, args);
+	get type() {
+		return "lazy import()";
 	}
 
-	info(...args) {
-		this[LOG_SYMBOL](LogType.info, args);
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return this.proxyModule.originalModule.identifier();
 	}
+}
 
-	log(...args) {
-		this[LOG_SYMBOL](LogType.log, args);
-	}
+registerNotSerializable(LazyCompilationDependency);
 
-	debug(...args) {
-		this[LOG_SYMBOL](LogType.debug, args);
+class LazyCompilationProxyModule extends Module {
+	constructor(context, originalModule, request, client, data, active) {
+		super("lazy-compilation-proxy", context, originalModule.layer);
+		this.originalModule = originalModule;
+		this.request = request;
+		this.client = client;
+		this.data = data;
+		this.active = active;
 	}
 
-	assert(assertion, ...args) {
-		if (!assertion) {
-			this[LOG_SYMBOL](LogType.error, args);
-		}
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
 	}
 
-	trace() {
-		this[LOG_SYMBOL](LogType.trace, ["Trace"]);
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
+			requestShortener
+		)}`;
 	}
 
-	clear() {
-		this[LOG_SYMBOL](LogType.clear);
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {LazyCompilationProxyModule} */ (module);
+		this.originalModule = m.originalModule;
+		this.request = m.request;
+		this.client = m.client;
+		this.data = m.data;
+		this.active = m.active;
 	}
 
-	status(...args) {
-		this[LOG_SYMBOL](LogType.status, args);
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
 	}
 
-	group(...args) {
-		this[LOG_SYMBOL](LogType.group, args);
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo || this.buildInfo.active !== this.active);
 	}
 
-	groupCollapsed(...args) {
-		this[LOG_SYMBOL](LogType.groupCollapsed, args);
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildInfo = {
+			active: this.active
+		};
+		/** @type {BuildMeta} */
+		this.buildMeta = {};
+		this.clearDependenciesAndBlocks();
+		const dep = new CommonJsRequireDependency(this.client);
+		this.addDependency(dep);
+		if (this.active) {
+			const dep = new LazyCompilationDependency(this);
+			const block = new AsyncDependenciesBlock({});
+			block.addDependency(dep);
+			this.addBlock(block);
+		}
+		callback();
 	}
 
-	groupEnd(...args) {
-		this[LOG_SYMBOL](LogType.groupEnd, args);
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
 
-	profile(label) {
-		this[LOG_SYMBOL](LogType.profile, [label]);
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 200;
 	}
 
-	profileEnd(label) {
-		this[LOG_SYMBOL](LogType.profileEnd, [label]);
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
+		const sources = new Map();
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		const clientDep = /** @type {CommonJsRequireDependency} */ (
+			this.dependencies[0]
+		);
+		const clientModule = moduleGraph.getModule(clientDep);
+		const block = this.blocks[0];
+		const client = Template.asString([
+			`var client = ${runtimeTemplate.moduleExports({
+				module: clientModule,
+				chunkGraph,
+				request: clientDep.userRequest,
+				runtimeRequirements
+			})}`,
+			`var data = ${JSON.stringify(this.data)};`
+		]);
+		const keepActive = Template.asString([
+			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
+				!!block
+			)}, module: module, onError: onError });`
+		]);
+		let source;
+		if (block) {
+			const dep = block.dependencies[0];
+			const module = moduleGraph.getModule(dep);
+			source = Template.asString([
+				client,
+				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
+					chunkGraph,
+					block,
+					module,
+					request: this.request,
+					strict: false, // TODO this should be inherited from the original module
+					message: "import()",
+					runtimeRequirements
+				})};`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					`module.hot.accept(${JSON.stringify(
+						chunkGraph.getModuleId(module)
+					)}, function() { module.hot.invalidate(); });`,
+					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
+				]),
+				"}",
+				"function onError() { /* ignore */ }",
+				keepActive
+			]);
+		} else {
+			source = Template.asString([
+				client,
+				"var resolveSelf, onError;",
+				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
+					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
+				]),
+				"}",
+				keepActive
+			]);
+		}
+		sources.set("javascript", new RawSource(source));
+		return {
+			sources,
+			runtimeRequirements
+		};
 	}
 
-	time(label) {
-		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
-		this[TIMERS_SYMBOL].set(label, process.hrtime());
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.active ? "active" : "");
+		hash.update(JSON.stringify(this.data));
 	}
+}
 
-	timeLog(label) {
-		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
-		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
-		}
-		const time = process.hrtime(prev);
-		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+registerNotSerializable(LazyCompilationProxyModule);
+
+class LazyCompilationDependencyFactory extends ModuleFactory {
+	constructor(factory) {
+		super();
+		this._factory = factory;
 	}
 
-	timeEnd(label) {
-		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
-		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
-		}
-		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
-		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dependency = /** @type {LazyCompilationDependency} */ (
+			data.dependencies[0]
+		);
+		callback(null, {
+			module: dependency.proxyModule.originalModule
+		});
 	}
+}
 
-	timeAggregate(label) {
-		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
-		if (!prev) {
-			throw new Error(
-				`No such label '${label}' for WebpackLogger.timeAggregate()`
-			);
-		}
-		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
-		this[TIMERS_AGGREGATES_SYMBOL] =
-			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
-		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
-		if (current !== undefined) {
-			if (time[1] + current[1] > 1e9) {
-				time[0] += current[0] + 1;
-				time[1] = time[1] - 1e9 + current[1];
-			} else {
-				time[0] += current[0];
-				time[1] += current[1];
-			}
-		}
-		this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
+class LazyCompilationPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
+	 * @param {boolean} options.entries true, when entries are lazy compiled
+	 * @param {boolean} options.imports true, when import() modules are lazy compiled
+	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
+	 */
+	constructor({ backend, entries, imports, test }) {
+		this.backend = backend;
+		this.entries = entries;
+		this.imports = imports;
+		this.test = test;
 	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		let backend;
+		compiler.hooks.beforeCompile.tapAsync(
+			"LazyCompilationPlugin",
+			(params, callback) => {
+				if (backend !== undefined) return callback();
+				const promise = this.backend(compiler, (err, result) => {
+					if (err) return callback(err);
+					backend = result;
+					callback();
+				});
+				if (promise && promise.then) {
+					promise.then(b => {
+						backend = b;
+						callback();
+					}, callback);
+				}
+			}
+		);
+		compiler.hooks.thisCompilation.tap(
+			"LazyCompilationPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.module.tap(
+					"LazyCompilationPlugin",
+					(originalModule, createData, resolveData) => {
+						if (
+							resolveData.dependencies.every(dep =>
+								HMR_DEPENDENCY_TYPES.has(dep.type)
+							)
+						) {
+							// for HMR only resolving, try to determine if the HMR accept/decline refers to
+							// an import() or not
+							const hmrDep = resolveData.dependencies[0];
+							const originModule =
+								compilation.moduleGraph.getParentModule(hmrDep);
+							const isReferringToDynamicImport = originModule.blocks.some(
+								block =>
+									block.dependencies.some(
+										dep =>
+											dep.type === "import()" &&
+											/** @type {HarmonyImportDependency} */ (dep).request ===
+												hmrDep.request
+									)
+							);
+							if (!isReferringToDynamicImport) return;
+						} else if (
+							!resolveData.dependencies.every(
+								dep =>
+									HMR_DEPENDENCY_TYPES.has(dep.type) ||
+									(this.imports &&
+										(dep.type === "import()" ||
+											dep.type === "import() context element")) ||
+									(this.entries && dep.type === "entry")
+							)
+						)
+							return;
+						if (
+							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
+								resolveData.request
+							) ||
+							!checkTest(this.test, originalModule)
+						)
+							return;
+						const moduleInfo = backend.module(originalModule);
+						if (!moduleInfo) return;
+						const { client, data, active } = moduleInfo;
 
-	timeAggregateEnd(label) {
-		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
-		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
-		if (time === undefined) return;
-		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
-		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+						return new LazyCompilationProxyModule(
+							compiler.context,
+							originalModule,
+							resolveData.request,
+							client,
+							data,
+							active
+						);
+					}
+				);
+				compilation.dependencyFactories.set(
+					LazyCompilationDependency,
+					new LazyCompilationDependencyFactory()
+				);
+			}
+		);
+		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
+			backend.dispose(callback);
+		});
 	}
 }
 
-exports.Logger = WebpackLogger;
+module.exports = LazyCompilationPlugin;
 
 
 /***/ }),
 
-/***/ 54963:
+/***/ 17781:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -97694,322 +93498,147 @@ exports.Logger = WebpackLogger;
 
 
 
-const { LogType } = __webpack_require__(32597);
-
-/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
-/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
-/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
-
-/** @typedef {function(string): boolean} FilterFunction */
+/** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
 /**
- * @typedef {Object} LoggerConsole
- * @property {function(): void} clear
- * @property {function(): void} trace
- * @property {(...args: any[]) => void} info
- * @property {(...args: any[]) => void} log
- * @property {(...args: any[]) => void} warn
- * @property {(...args: any[]) => void} error
- * @property {(...args: any[]) => void=} debug
- * @property {(...args: any[]) => void=} group
- * @property {(...args: any[]) => void=} groupCollapsed
- * @property {(...args: any[]) => void=} groupEnd
- * @property {(...args: any[]) => void=} status
- * @property {(...args: any[]) => void=} profile
- * @property {(...args: any[]) => void=} profileEnd
- * @property {(...args: any[]) => void=} logTime
+ * @callback BackendHandler
+ * @param {Compiler} compiler compiler
+ * @param {function((Error | null)=, any=): void} callback callback
+ * @returns {void}
  */
 
 /**
- * @typedef {Object} LoggerOptions
- * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
- * @property {FilterTypes|boolean} debug filter for debug logging
- * @property {LoggerConsole} console the console to log to
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
  */
+module.exports = options => (compiler, callback) => {
+	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+	const activeModules = new Map();
+	const prefix = "/lazy-compilation-using-";
 
-/**
- * @param {FilterItemTypes} item an input item
- * @returns {FilterFunction} filter function
- */
-const filterToFunction = item => {
-	if (typeof item === "string") {
-		const regExp = new RegExp(
-			`[\\\\/]${item.replace(
-				// eslint-disable-next-line no-useless-escape
-				/[-[\]{}()*+?.\\^$|]/g,
-				"\\$&"
-			)}([\\\\/]|$|!|\\?)`
-		);
-		return ident => regExp.test(ident);
-	}
-	if (item && typeof item === "object" && typeof item.test === "function") {
-		return ident => item.test(ident);
-	}
-	if (typeof item === "function") {
-		return item;
-	}
-	if (typeof item === "boolean") {
-		return () => item;
-	}
-};
+	const isHttps =
+		options.protocol === "https" ||
+		(typeof options.server === "object" &&
+			("key" in options.server || "pfx" in options.server));
 
-/**
- * @enum {number}
- */
-const LogLevel = {
-	none: 6,
-	false: 6,
-	error: 5,
-	warn: 4,
-	info: 3,
-	log: 2,
-	true: 2,
-	verbose: 1
-};
+	const createServer =
+		typeof options.server === "function"
+			? options.server
+			: (() => {
+					const http = isHttps ? __webpack_require__(95687) : __webpack_require__(13685);
+					return http.createServer.bind(http, options.server);
+			  })();
+	const listen =
+		typeof options.listen === "function"
+			? options.listen
+			: server => {
+					let listen = options.listen;
+					if (typeof listen === "object" && !("port" in listen))
+						listen = { ...listen, port: undefined };
+					server.listen(listen);
+			  };
 
-/**
- * @param {LoggerOptions} options options object
- * @returns {function(string, LogTypeEnum, any[]): void} logging function
- */
-module.exports = ({ level = "info", debug = false, console }) => {
-	const debugFilters =
-		typeof debug === "boolean"
-			? [() => debug]
-			: /** @type {FilterItemTypes[]} */ ([])
-					.concat(debug)
-					.map(filterToFunction);
-	/** @type {number} */
-	const loglevel = LogLevel[`${level}`] || 0;
+	const protocol = options.protocol || (isHttps ? "https" : "http");
 
-	/**
-	 * @param {string} name name of the logger
-	 * @param {LogTypeEnum} type type of the log entry
-	 * @param {any[]} args arguments of the log entry
-	 * @returns {void}
-	 */
-	const logger = (name, type, args) => {
-		const labeledArgs = () => {
-			if (Array.isArray(args)) {
-				if (args.length > 0 && typeof args[0] === "string") {
-					return [`[${name}] ${args[0]}`, ...args.slice(1)];
-				} else {
-					return [`[${name}]`, ...args];
-				}
-			} else {
-				return [];
-			}
-		};
-		const debug = debugFilters.some(f => f(name));
-		switch (type) {
-			case LogType.debug:
-				if (!debug) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.debug === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.debug(...labeledArgs());
-				} else {
-					console.log(...labeledArgs());
-				}
-				break;
-			case LogType.log:
-				if (!debug && loglevel > LogLevel.log) return;
-				console.log(...labeledArgs());
-				break;
-			case LogType.info:
-				if (!debug && loglevel > LogLevel.info) return;
-				console.info(...labeledArgs());
-				break;
-			case LogType.warn:
-				if (!debug && loglevel > LogLevel.warn) return;
-				console.warn(...labeledArgs());
-				break;
-			case LogType.error:
-				if (!debug && loglevel > LogLevel.error) return;
-				console.error(...labeledArgs());
-				break;
-			case LogType.trace:
-				if (!debug) return;
-				console.trace();
-				break;
-			case LogType.groupCollapsed:
-				if (!debug && loglevel > LogLevel.log) return;
-				if (!debug && loglevel > LogLevel.verbose) {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					if (typeof console.groupCollapsed === "function") {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						console.groupCollapsed(...labeledArgs());
-					} else {
-						console.log(...labeledArgs());
+	const requestListener = (req, res) => {
+		const keys = req.url.slice(prefix.length).split("@");
+		req.socket.on("close", () => {
+			setTimeout(() => {
+				for (const key of keys) {
+					const oldValue = activeModules.get(key) || 0;
+					activeModules.set(key, oldValue - 1);
+					if (oldValue === 1) {
+						logger.log(
+							`${key} is no longer in use. Next compilation will skip this module.`
+						);
 					}
-					break;
-				}
-			// falls through
-			case LogType.group:
-				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.group === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.group(...labeledArgs());
-				} else {
-					console.log(...labeledArgs());
-				}
-				break;
-			case LogType.groupEnd:
-				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.groupEnd === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.groupEnd();
-				}
-				break;
-			case LogType.time: {
-				if (!debug && loglevel > LogLevel.log) return;
-				const ms = args[1] * 1000 + args[2] / 1000000;
-				const msg = `[${name}] ${args[0]}: ${ms} ms`;
-				if (typeof console.logTime === "function") {
-					console.logTime(msg);
-				} else {
-					console.log(msg);
 				}
-				break;
+			}, 120000);
+		});
+		req.socket.setNoDelay(true);
+		res.writeHead(200, {
+			"content-type": "text/event-stream",
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "*",
+			"Access-Control-Allow-Headers": "*"
+		});
+		res.write("\n");
+		let moduleActivated = false;
+		for (const key of keys) {
+			const oldValue = activeModules.get(key) || 0;
+			activeModules.set(key, oldValue + 1);
+			if (oldValue === 0) {
+				logger.log(`${key} is now in use and will be compiled.`);
+				moduleActivated = true;
 			}
-			case LogType.profile:
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.profile === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.profile(...labeledArgs());
-				}
-				break;
-			case LogType.profileEnd:
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.profileEnd === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.profileEnd(...labeledArgs());
-				}
-				break;
-			case LogType.clear:
-				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.clear === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.clear();
-				}
-				break;
-			case LogType.status:
-				if (!debug && loglevel > LogLevel.info) return;
-				if (typeof console.status === "function") {
-					if (args.length === 0) {
-						console.status();
-					} else {
-						console.status(...labeledArgs());
-					}
-				} else {
-					if (args.length !== 0) {
-						console.info(...labeledArgs());
-					}
-				}
-				break;
-			default:
-				throw new Error(`Unexpected LogType ${type}`);
 		}
+		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	};
-	return logger;
-};
-
-
-/***/ }),
-
-/***/ 62090:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const arraySum = array => {
-	let sum = 0;
-	for (const item of array) sum += item;
-	return sum;
-};
-
-/**
- * @param {any[]} args items to be truncated
- * @param {number} maxLength maximum length of args including spaces between
- * @returns {string[]} truncated args
- */
-const truncateArgs = (args, maxLength) => {
-	const lengths = args.map(a => `${a}`.length);
-	const availableLength = maxLength - lengths.length + 1;
-
-	if (availableLength > 0 && args.length === 1) {
-		if (availableLength >= args[0].length) {
-			return args;
-		} else if (availableLength > 3) {
-			return ["..." + args[0].slice(-availableLength + 3)];
-		} else {
-			return [args[0].slice(-availableLength)];
-		}
-	}
-
-	// Check if there is space for at least 4 chars per arg
-	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
-		// remove args
-		if (args.length > 1)
-			return truncateArgs(args.slice(0, args.length - 1), maxLength);
-		return [];
-	}
-
-	let currentLength = arraySum(lengths);
 
-	// Check if all fits into maxLength
-	if (currentLength <= availableLength) return args;
+	const server = /** @type {import("net").Server} */ (createServer());
+	server.on("request", requestListener);
 
-	// Try to remove chars from the longest items until it fits
-	while (currentLength > availableLength) {
-		const maxLength = Math.max(...lengths);
-		const shorterItems = lengths.filter(l => l !== maxLength);
-		const nextToMaxLength =
-			shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
-		const maxReduce = maxLength - nextToMaxLength;
-		let maxItems = lengths.length - shorterItems.length;
-		let overrun = currentLength - availableLength;
-		for (let i = 0; i < lengths.length; i++) {
-			if (lengths[i] === maxLength) {
-				const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
-				lengths[i] -= reduce;
-				currentLength -= reduce;
-				overrun -= reduce;
-				maxItems--;
+	let isClosing = false;
+	/** @type {Set<import("net").Socket>} */
+	const sockets = new Set();
+	server.on("connection", socket => {
+		sockets.add(socket);
+		socket.on("close", () => {
+			sockets.delete(socket);
+		});
+		if (isClosing) socket.destroy();
+	});
+	server.on("clientError", e => {
+		if (e.message !== "Server is disposing") logger.warn(e);
+	});
+	server.on("listening", err => {
+		if (err) return callback(err);
+		const addr = server.address();
+		if (typeof addr === "string") throw new Error("addr must not be a string");
+		const urlBase =
+			addr.address === "::" || addr.address === "0.0.0.0"
+				? `${protocol}://localhost:${addr.port}`
+				: addr.family === "IPv6"
+				? `${protocol}://[${addr.address}]:${addr.port}`
+				: `${protocol}://${addr.address}:${addr.port}`;
+		logger.log(
+			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+		);
+		callback(null, {
+			dispose(callback) {
+				isClosing = true;
+				// Removing the listener is a workaround for a memory leak in node.js
+				server.off("request", requestListener);
+				server.close(err => {
+					callback(err);
+				});
+				for (const socket of sockets) {
+					socket.destroy(new Error("Server is disposing"));
+				}
+			},
+			module(originalModule) {
+				const key = `${encodeURIComponent(
+					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
+				const active = activeModules.get(key) > 0;
+				return {
+					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+					data: key,
+					active
+				};
 			}
-		}
-	}
-
-	// Return args reduced to length in lengths
-	return args.map((a, i) => {
-		const str = `${a}`;
-		const length = lengths[i];
-		if (str.length === length) {
-			return str;
-		} else if (length > 5) {
-			return "..." + str.slice(-length + 3);
-		} else if (length > 0) {
-			return str.slice(-length);
-		} else {
-			return "";
-		}
+		});
 	});
+	listen(server);
 };
 
-module.exports = truncateArgs;
-
 
 /***/ }),
 
-/***/ 1313:
+/***/ 64618:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -98020,15 +93649,17 @@ module.exports = truncateArgs;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const StartupChunkDependenciesPlugin = __webpack_require__(22339);
+const { find } = __webpack_require__(93347);
+const {
+	compareModulesByPreOrderIndexOrIdentifier,
+	compareModulesByPostOrderIndexOrIdentifier
+} = __webpack_require__(29579);
 
 /** @typedef {import("../Compiler")} Compiler */
 
-class CommonJsChunkLoadingPlugin {
+class ChunkModuleIdRangePlugin {
 	constructor(options) {
-		options = options || {};
-		this._asyncChunkLoading = options.asyncChunkLoading;
+		this.options = options;
 	}
 
 	/**
@@ -98037,118 +93668,88 @@ class CommonJsChunkLoadingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const ChunkLoadingRuntimeModule = this._asyncChunkLoading
-			? __webpack_require__(73369)
-			: __webpack_require__(94172);
-		const chunkLoadingValue = this._asyncChunkLoading
-			? "async-node"
-			: "require";
-		new StartupChunkDependenciesPlugin({
-			chunkLoading: chunkLoadingValue,
-			asyncChunkLoading: this._asyncChunkLoading
-		}).apply(compiler);
-		compiler.hooks.thisCompilation.tap(
-			"CommonJsChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === chunkLoadingValue;
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new ChunkLoadingRuntimeModule(set)
+		const options = this.options;
+		compiler.hooks.compilation.tap("ChunkModuleIdRangePlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			compilation.hooks.moduleIds.tap("ChunkModuleIdRangePlugin", modules => {
+				const chunkGraph = compilation.chunkGraph;
+				const chunk = find(
+					compilation.chunks,
+					chunk => chunk.name === options.name
+				);
+				if (!chunk) {
+					throw new Error(
+						`ChunkModuleIdRangePlugin: Chunk with name '${options.name}"' was not found`
 					);
-				};
+				}
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("CommonJsChunkLoadingPlugin", handler);
+				let chunkModules;
+				if (options.order) {
+					let cmpFn;
+					switch (options.order) {
+						case "index":
+						case "preOrderIndex":
+							cmpFn = compareModulesByPreOrderIndexOrIdentifier(moduleGraph);
+							break;
+						case "index2":
+						case "postOrderIndex":
+							cmpFn = compareModulesByPostOrderIndexOrIdentifier(moduleGraph);
+							break;
+						default:
+							throw new Error(
+								"ChunkModuleIdRangePlugin: unexpected value of order"
+							);
+					}
+					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
+				} else {
+					chunkModules = Array.from(modules)
+						.filter(m => {
+							return chunkGraph.isModuleInChunk(m, chunk);
+						})
+						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
+				}
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
-			}
-		);
+				let currentId = options.start || 0;
+				for (let i = 0; i < chunkModules.length; i++) {
+					const m = chunkModules[i];
+					if (m.needId && chunkGraph.getModuleId(m) === null) {
+						chunkGraph.setModuleId(m, currentId++);
+					}
+					if (options.end && currentId > options.end) break;
+				}
+			});
+		});
 	}
 }
-
-module.exports = CommonJsChunkLoadingPlugin;
+module.exports = ChunkModuleIdRangePlugin;
 
 
 /***/ }),
 
-/***/ 7553:
+/***/ 8747:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const CachedInputFileSystem = __webpack_require__(52788);
-const fs = __webpack_require__(90552);
-const createConsoleLogger = __webpack_require__(54963);
-const NodeWatchFileSystem = __webpack_require__(98810);
-const nodeConsole = __webpack_require__(91786);
+const { compareChunksNatural } = __webpack_require__(29579);
+const {
+	getFullChunkName,
+	getUsedChunkIds,
+	assignDeterministicIds
+} = __webpack_require__(63290);
 
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-class NodeEnvironmentPlugin {
-	/**
-	 * @param {Object} options options
-	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
-	 */
+class DeterministicChunkIdsPlugin {
 	constructor(options) {
-		this.options = options;
+		this.options = options || {};
 	}
 
 	/**
@@ -98157,155 +93758,154 @@ class NodeEnvironmentPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { infrastructureLogging } = this.options;
-		compiler.infrastructureLogger = createConsoleLogger({
-			level: infrastructureLogging.level || "info",
-			debug: infrastructureLogging.debug || false,
-			console:
-				infrastructureLogging.console ||
-				nodeConsole({
-					colors: infrastructureLogging.colors,
-					appendOnly: infrastructureLogging.appendOnly,
-					stream: infrastructureLogging.stream
-				})
-		});
-		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
-		const inputFileSystem = compiler.inputFileSystem;
-		compiler.outputFileSystem = fs;
-		compiler.intermediateFileSystem = fs;
-		compiler.watchFileSystem = new NodeWatchFileSystem(
-			compiler.inputFileSystem
-		);
-		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
-			if (compiler.inputFileSystem === inputFileSystem) {
-				compiler.fsStartTime = Date.now();
-				inputFileSystem.purge();
-			}
-		});
-	}
-}
-
-module.exports = NodeEnvironmentPlugin;
-
-
-/***/ }),
-
-/***/ 7103:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+		compiler.hooks.compilation.tap(
+			"DeterministicChunkIdsPlugin",
+			compilation => {
+				compilation.hooks.chunkIds.tap(
+					"DeterministicChunkIdsPlugin",
+					chunks => {
+						const chunkGraph = compilation.chunkGraph;
+						const context = this.options.context
+							? this.options.context
+							: compiler.context;
+						const maxLength = this.options.maxLength || 3;
 
-/** @typedef {import("../Compiler")} Compiler */
+						const compareNatural = compareChunksNatural(chunkGraph);
 
-class NodeSourcePlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {}
+						const usedIds = getUsedChunkIds(compilation);
+						assignDeterministicIds(
+							Array.from(chunks).filter(chunk => {
+								return chunk.id === null;
+							}),
+							chunk =>
+								getFullChunkName(chunk, chunkGraph, context, compiler.root),
+							compareNatural,
+							(chunk, id) => {
+								const size = usedIds.size;
+								usedIds.add(`${id}`);
+								if (size === usedIds.size) return false;
+								chunk.id = id;
+								chunk.ids = [id];
+								return true;
+							},
+							[Math.pow(10, maxLength)],
+							10,
+							usedIds.size
+						);
+					}
+				);
+			}
+		);
+	}
 }
 
-module.exports = NodeSourcePlugin;
+module.exports = DeterministicChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 17916:
+/***/ 76692:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const ExternalsPlugin = __webpack_require__(6652);
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName,
+	assignDeterministicIds
+} = __webpack_require__(63290);
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-const builtins = [
-	"assert",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"dns/promises",
-	"domain",
-	"events",
-	"fs",
-	"fs/promises",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"module",
-	"net",
-	"os",
-	"path",
-	"path/posix",
-	"path/win32",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"repl",
-	"stream",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"sys",
-	"timers",
-	"timers/promises",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib",
-	/^node:/,
-
-	// cspell:word pnpapi
-	// Yarn PnP adds pnpapi as "builtin"
-	"pnpapi"
-];
+class DeterministicModuleIdsPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string=} options.context context relative to which module identifiers are computed
+	 * @param {function(Module): boolean=} options.test selector function for modules
+	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
+	 * @param {number=} options.salt hash salt for ids
+	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
+	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
+	 */
+	constructor(options = {}) {
+		this.options = options;
+	}
 
-class NodeTargetPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
+		compiler.hooks.compilation.tap(
+			"DeterministicModuleIdsPlugin",
+			compilation => {
+				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
+					const chunkGraph = compilation.chunkGraph;
+					const context = this.options.context
+						? this.options.context
+						: compiler.context;
+					const maxLength = this.options.maxLength || 3;
+					const failOnConflict = this.options.failOnConflict || false;
+					const fixedLength = this.options.fixedLength || false;
+					const salt = this.options.salt || 0;
+					let conflicts = 0;
+
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this.options.test
+					);
+					assignDeterministicIds(
+						modules,
+						module => getFullModuleName(module, context, compiler.root),
+						failOnConflict
+							? () => 0
+							: compareModulesByPreOrderIndexOrIdentifier(
+									compilation.moduleGraph
+							  ),
+						(module, id) => {
+							const size = usedIds.size;
+							usedIds.add(`${id}`);
+							if (size === usedIds.size) {
+								conflicts++;
+								return false;
+							}
+							chunkGraph.setModuleId(module, id);
+							return true;
+						},
+						[Math.pow(10, maxLength)],
+						fixedLength ? 0 : 10,
+						usedIds.size,
+						salt
+					);
+					if (failOnConflict && conflicts)
+						throw new Error(
+							`Assigning deterministic module ids has lead to ${conflicts} conflict${
+								conflicts > 1 ? "s" : ""
+							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
+						);
+				});
+			}
+		);
 	}
 }
 
-module.exports = NodeTargetPlugin;
+module.exports = DeterministicModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 61052:
+/***/ 21825:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -98316,38 +93916,82 @@ module.exports = NodeTargetPlugin;
 
 
 
-const CommonJsChunkFormatPlugin = __webpack_require__(84508);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName
+} = __webpack_require__(63290);
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
 
-class NodeTemplatePlugin {
-	constructor(options) {
-		this._options = options || {};
+const validate = createSchemaValidation(
+	__webpack_require__(52210),
+	() => __webpack_require__(59106),
+	{
+		name: "Hashed Module Ids Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class HashedModuleIdsPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {HashedModuleIdsPluginOptions=} options options object
 	 */
+	constructor(options = {}) {
+		validate(options);
+
+		/** @type {HashedModuleIdsPluginOptions} */
+		this.options = {
+			context: null,
+			hashFunction: "md4",
+			hashDigest: "base64",
+			hashDigestLength: 4,
+			...options
+		};
+	}
+
 	apply(compiler) {
-		const chunkLoading = this._options.asyncChunkLoading
-			? "async-node"
-			: "require";
-		compiler.options.output.chunkLoading = chunkLoading;
-		new CommonJsChunkFormatPlugin().apply(compiler);
-		new EnableChunkLoadingPlugin(chunkLoading).apply(compiler);
+		const options = this.options;
+		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
+			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
+
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const modulesInNaturalOrder = modules.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				for (const module of modulesInNaturalOrder) {
+					const ident = getFullModuleName(module, context, compiler.root);
+					const hash = createHash(options.hashFunction);
+					hash.update(ident || "");
+					const hashId = /** @type {string} */ (
+						hash.digest(options.hashDigest)
+					);
+					let len = options.hashDigestLength;
+					while (usedIds.has(hashId.substr(0, len))) len++;
+					const moduleId = hashId.substr(0, len);
+					chunkGraph.setModuleId(module, moduleId);
+					usedIds.add(moduleId);
+				}
+			});
+		});
 	}
 }
 
-module.exports = NodeTemplatePlugin;
+module.exports = HashedModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 98810:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 63290:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -98357,482 +94001,481 @@ module.exports = NodeTemplatePlugin;
 
 
 
-const util = __webpack_require__(73837);
-const Watchpack = __webpack_require__(36871);
+const createHash = __webpack_require__(49835);
+const { makePathsRelative } = __webpack_require__(82186);
+const numberHash = __webpack_require__(70002);
 
-/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
-/** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
-/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
-/** @typedef {import("../util/fs").Watcher} Watcher */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {typeof import("../util/Hash")} Hash */
 
-class NodeWatchFileSystem {
-	constructor(inputFileSystem) {
-		this.inputFileSystem = inputFileSystem;
-		this.watcherOptions = {
-			aggregateTimeout: 0
-		};
-		this.watcher = new Watchpack(this.watcherOptions);
+/**
+ * @param {string} str string to hash
+ * @param {number} len max length of the hash
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const getHash = (str, len, hashFunction) => {
+	const hash = createHash(hashFunction);
+	hash.update(str);
+	const digest = /** @type {string} */ (hash.digest("hex"));
+	return digest.substr(0, len);
+};
+
+/**
+ * @param {string} str the string
+ * @returns {string} string prefixed by an underscore if it is a number
+ */
+const avoidNumber = str => {
+	// max length of a number is 21 chars, bigger numbers a written as "...e+xx"
+	if (str.length > 21) return str;
+	const firstChar = str.charCodeAt(0);
+	// skip everything that doesn't look like a number
+	// charCodes: "-": 45, "1": 49, "9": 57
+	if (firstChar < 49) {
+		if (firstChar !== 45) return str;
+	} else if (firstChar > 57) {
+		return str;
 	}
+	if (str === +str + "") {
+		return `_${str}`;
+	}
+	return str;
+};
 
-	/**
-	 * @param {Iterable<string>} files watched files
-	 * @param {Iterable<string>} directories watched directories
-	 * @param {Iterable<string>} missing watched exitance entries
-	 * @param {number} startTime timestamp of start time
-	 * @param {WatchOptions} options options object
-	 * @param {function(Error=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
-	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
-	 * @returns {Watcher} a watcher
-	 */
-	watch(
-		files,
-		directories,
-		missing,
-		startTime,
-		options,
-		callback,
-		callbackUndelayed
-	) {
-		if (!files || typeof files[Symbol.iterator] !== "function") {
-			throw new Error("Invalid arguments: 'files'");
-		}
-		if (!directories || typeof directories[Symbol.iterator] !== "function") {
-			throw new Error("Invalid arguments: 'directories'");
-		}
-		if (!missing || typeof missing[Symbol.iterator] !== "function") {
-			throw new Error("Invalid arguments: 'missing'");
-		}
-		if (typeof callback !== "function") {
-			throw new Error("Invalid arguments: 'callback'");
-		}
-		if (typeof startTime !== "number" && startTime) {
-			throw new Error("Invalid arguments: 'startTime'");
-		}
-		if (typeof options !== "object") {
-			throw new Error("Invalid arguments: 'options'");
-		}
-		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
-			throw new Error("Invalid arguments: 'callbackUndelayed'");
-		}
-		const oldWatcher = this.watcher;
-		this.watcher = new Watchpack(options);
+/**
+ * @param {string} request the request
+ * @returns {string} id representation
+ */
+const requestToId = request => {
+	return request
+		.replace(/^(\.\.?\/)+/, "")
+		.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+};
+exports.requestToId = requestToId;
 
-		if (callbackUndelayed) {
-			this.watcher.once("change", callbackUndelayed);
+/**
+ * @param {string} string the string
+ * @param {string} delimiter separator for string and hash
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} string with limited max length to 100 chars
+ */
+const shortenLongString = (string, delimiter, hashFunction) => {
+	if (string.length < 100) return string;
+	return (
+		string.slice(0, 100 - 6 - delimiter.length) +
+		delimiter +
+		getHash(string, 6, hashFunction)
+	);
+};
+
+/**
+ * @param {Module} module the module
+ * @param {string} context context directory
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} short module name
+ */
+const getShortModuleName = (module, context, associatedObjectForCache) => {
+	const libIdent = module.libIdent({ context, associatedObjectForCache });
+	if (libIdent) return avoidNumber(libIdent);
+	const nameForCondition = module.nameForCondition();
+	if (nameForCondition)
+		return avoidNumber(
+			makePathsRelative(context, nameForCondition, associatedObjectForCache)
+		);
+	return "";
+};
+exports.getShortModuleName = getShortModuleName;
+
+/**
+ * @param {string} shortName the short name
+ * @param {Module} module the module
+ * @param {string} context context directory
+ * @param {string | Hash} hashFunction hash function to use
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} long module name
+ */
+const getLongModuleName = (
+	shortName,
+	module,
+	context,
+	hashFunction,
+	associatedObjectForCache
+) => {
+	const fullName = getFullModuleName(module, context, associatedObjectForCache);
+	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
+};
+exports.getLongModuleName = getLongModuleName;
+
+/**
+ * @param {Module} module the module
+ * @param {string} context context directory
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} full module name
+ */
+const getFullModuleName = (module, context, associatedObjectForCache) => {
+	return makePathsRelative(
+		context,
+		module.identifier(),
+		associatedObjectForCache
+	);
+};
+exports.getFullModuleName = getFullModuleName;
+
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {string} context context directory
+ * @param {string} delimiter delimiter for names
+ * @param {string | Hash} hashFunction hash function to use
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} short chunk name
+ */
+const getShortChunkName = (
+	chunk,
+	chunkGraph,
+	context,
+	delimiter,
+	hashFunction,
+	associatedObjectForCache
+) => {
+	const modules = chunkGraph.getChunkRootModules(chunk);
+	const shortModuleNames = modules.map(m =>
+		requestToId(getShortModuleName(m, context, associatedObjectForCache))
+	);
+	chunk.idNameHints.sort();
+	const chunkName = Array.from(chunk.idNameHints)
+		.concat(shortModuleNames)
+		.filter(Boolean)
+		.join(delimiter);
+	return shortenLongString(chunkName, delimiter, hashFunction);
+};
+exports.getShortChunkName = getShortChunkName;
+
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {string} context context directory
+ * @param {string} delimiter delimiter for names
+ * @param {string | Hash} hashFunction hash function to use
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} short chunk name
+ */
+const getLongChunkName = (
+	chunk,
+	chunkGraph,
+	context,
+	delimiter,
+	hashFunction,
+	associatedObjectForCache
+) => {
+	const modules = chunkGraph.getChunkRootModules(chunk);
+	const shortModuleNames = modules.map(m =>
+		requestToId(getShortModuleName(m, context, associatedObjectForCache))
+	);
+	const longModuleNames = modules.map(m =>
+		requestToId(
+			getLongModuleName("", m, context, hashFunction, associatedObjectForCache)
+		)
+	);
+	chunk.idNameHints.sort();
+	const chunkName = Array.from(chunk.idNameHints)
+		.concat(shortModuleNames, longModuleNames)
+		.filter(Boolean)
+		.join(delimiter);
+	return shortenLongString(chunkName, delimiter, hashFunction);
+};
+exports.getLongChunkName = getLongChunkName;
+
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {string} context context directory
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} full chunk name
+ */
+const getFullChunkName = (
+	chunk,
+	chunkGraph,
+	context,
+	associatedObjectForCache
+) => {
+	if (chunk.name) return chunk.name;
+	const modules = chunkGraph.getChunkRootModules(chunk);
+	const fullModuleNames = modules.map(m =>
+		makePathsRelative(context, m.identifier(), associatedObjectForCache)
+	);
+	return fullModuleNames.join();
+};
+exports.getFullChunkName = getFullChunkName;
+
+/**
+ * @template K
+ * @template V
+ * @param {Map<K, V[]>} map a map from key to values
+ * @param {K} key key
+ * @param {V} value value
+ * @returns {void}
+ */
+const addToMapOfItems = (map, key, value) => {
+	let array = map.get(key);
+	if (array === undefined) {
+		array = [];
+		map.set(key, array);
+	}
+	array.push(value);
+};
+
+/**
+ * @param {Compilation} compilation the compilation
+ * @param {function(Module): boolean=} filter filter modules
+ * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
+ */
+const getUsedModuleIdsAndModules = (compilation, filter) => {
+	const chunkGraph = compilation.chunkGraph;
+
+	const modules = [];
+
+	/** @type {Set<string>} */
+	const usedIds = new Set();
+	if (compilation.usedModuleIds) {
+		for (const id of compilation.usedModuleIds) {
+			usedIds.add(id + "");
 		}
+	}
 
-		const fetchTimeInfo = () => {
-			const fileTimeInfoEntries = new Map();
-			const contextTimeInfoEntries = new Map();
-			if (this.watcher) {
-				this.watcher.collectTimeInfoEntries(
-					fileTimeInfoEntries,
-					contextTimeInfoEntries
-				);
+	for (const module of compilation.modules) {
+		if (!module.needId) continue;
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId !== null) {
+			usedIds.add(moduleId + "");
+		} else {
+			if (
+				(!filter || filter(module)) &&
+				chunkGraph.getNumberOfModuleChunks(module) !== 0
+			) {
+				modules.push(module);
 			}
-			return { fileTimeInfoEntries, contextTimeInfoEntries };
-		};
-		this.watcher.once("aggregated", (changes, removals) => {
-			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
-			this.watcher.pause();
+		}
+	}
 
-			if (this.inputFileSystem && this.inputFileSystem.purge) {
-				const fs = this.inputFileSystem;
-				for (const item of changes) {
-					fs.purge(item);
-				}
-				for (const item of removals) {
-					fs.purge(item);
-				}
-			}
-			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
-			callback(
-				null,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changes,
-				removals
-			);
-		});
+	return [usedIds, modules];
+};
+exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
 
-		this.watcher.watch({ files, directories, missing, startTime });
+/**
+ * @param {Compilation} compilation the compilation
+ * @returns {Set<string>} used chunk ids as strings
+ */
+const getUsedChunkIds = compilation => {
+	/** @type {Set<string>} */
+	const usedIds = new Set();
+	if (compilation.usedChunkIds) {
+		for (const id of compilation.usedChunkIds) {
+			usedIds.add(id + "");
+		}
+	}
 
-		if (oldWatcher) {
-			oldWatcher.close();
+	for (const chunk of compilation.chunks) {
+		const chunkId = chunk.id;
+		if (chunkId !== null) {
+			usedIds.add(chunkId + "");
 		}
-		return {
-			close: () => {
-				if (this.watcher) {
-					this.watcher.close();
-					this.watcher = null;
-				}
-			},
-			pause: () => {
-				if (this.watcher) {
-					this.watcher.pause();
-				}
-			},
-			getAggregatedRemovals: util.deprecate(
-				() => {
-					const items = this.watcher && this.watcher.aggregatedRemovals;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
-						for (const item of items) {
-							fs.purge(item);
-						}
-					}
-					return items;
-				},
-				"Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
-			),
-			getAggregatedChanges: util.deprecate(
-				() => {
-					const items = this.watcher && this.watcher.aggregatedChanges;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
-						for (const item of items) {
-							fs.purge(item);
-						}
-					}
-					return items;
-				},
-				"Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
-			),
-			getFileTimeInfoEntries: util.deprecate(
-				() => {
-					return fetchTimeInfo().fileTimeInfoEntries;
-				},
-				"Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
-			),
-			getContextTimeInfoEntries: util.deprecate(
-				() => {
-					return fetchTimeInfo().contextTimeInfoEntries;
-				},
-				"Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"
-			),
-			getInfo: () => {
-				const removals = this.watcher && this.watcher.aggregatedRemovals;
-				const changes = this.watcher && this.watcher.aggregatedChanges;
-				if (this.inputFileSystem && this.inputFileSystem.purge) {
-					const fs = this.inputFileSystem;
-					if (removals) {
-						for (const item of removals) {
-							fs.purge(item);
-						}
-					}
-					if (changes) {
-						for (const item of changes) {
-							fs.purge(item);
-						}
-					}
-				}
-				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
-				return {
-					changes,
-					removals,
-					fileTimeInfoEntries,
-					contextTimeInfoEntries
-				};
-			}
-		};
 	}
-}
 
-module.exports = NodeWatchFileSystem;
+	return usedIds;
+};
+exports.getUsedChunkIds = getUsedChunkIds;
 
+/**
+ * @template T
+ * @param {Iterable<T>} items list of items to be named
+ * @param {function(T): string} getShortName get a short name for an item
+ * @param {function(T, string): string} getLongName get a long name for an item
+ * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {Set<string>} usedIds already used ids, will not be assigned
+ * @param {function(T, string): void} assignName assign a name to an item
+ * @returns {T[]} list of items without a name
+ */
+const assignNames = (
+	items,
+	getShortName,
+	getLongName,
+	comparator,
+	usedIds,
+	assignName
+) => {
+	/** @type {Map<string, T[]>} */
+	const nameToItems = new Map();
 
-/***/ }),
+	for (const item of items) {
+		const name = getShortName(item);
+		addToMapOfItems(nameToItems, name, item);
+	}
 
-/***/ 73369:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/** @type {Map<string, T[]>} */
+	const nameToItems2 = new Map();
+
+	for (const [name, items] of nameToItems) {
+		if (items.length > 1 || !name) {
+			for (const item of items) {
+				const longName = getLongName(item, name);
+				addToMapOfItems(nameToItems2, longName, item);
+			}
+		} else {
+			addToMapOfItems(nameToItems2, name, items[0]);
+		}
+	}
+
+	/** @type {T[]} */
+	const unnamedItems = [];
+
+	for (const [name, items] of nameToItems2) {
+		if (!name) {
+			for (const item of items) {
+				unnamedItems.push(item);
+			}
+		} else if (items.length === 1 && !usedIds.has(name)) {
+			assignName(items[0], name);
+			usedIds.add(name);
+		} else {
+			items.sort(comparator);
+			let i = 0;
+			for (const item of items) {
+				while (nameToItems2.has(name + i) && usedIds.has(name + i)) i++;
+				assignName(item, name + i);
+				usedIds.add(name + i);
+				i++;
+			}
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	unnamedItems.sort(comparator);
+	return unnamedItems;
+};
+exports.assignNames = assignNames;
 
+/**
+ * @template T
+ * @param {T[]} items list of items to be named
+ * @param {function(T): string} getName get a name for an item
+ * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {function(T, number): boolean} assignId assign an id to an item
+ * @param {number[]} ranges usable ranges for ids
+ * @param {number} expandFactor factor to create more ranges
+ * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
+ * @param {number} salt salting number to initialize hashing
+ * @returns {void}
+ */
+const assignDeterministicIds = (
+	items,
+	getName,
+	comparator,
+	assignId,
+	ranges = [10],
+	expandFactor = 10,
+	extraSpace = 0,
+	salt = 0
+) => {
+	items.sort(comparator);
 
+	// max 5% fill rate
+	const optimalRange = Math.min(
+		Math.ceil(items.length * 20) + extraSpace,
+		Number.MAX_SAFE_INTEGER
+	);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
+	let i = 0;
+	let range = ranges[i];
+	while (range < optimalRange) {
+		i++;
+		if (i < ranges.length) {
+			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
+		} else if (expandFactor) {
+			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+		} else {
+			break;
+		}
+	}
 
-class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.runtimeRequirements = runtimeRequirements;
+	for (const item of items) {
+		const ident = getName(item);
+		let id;
+		let i = salt;
+		do {
+			id = numberHash(ident + i++, range);
+		} while (!assignId(item, id));
 	}
+};
+exports.assignDeterministicIds = assignDeterministicIds;
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withExternalInstallChunk = this.runtimeRequirements.has(
-			RuntimeGlobals.externalInstallChunk
-		);
-		const withOnChunkLoad = this.runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withLoading = this.runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withHmr = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+/**
+ * @param {Set<string>} usedIds used ids
+ * @param {Iterable<Module>} modules the modules
+ * @param {Compilation} compilation the compilation
+ * @returns {void}
+ */
+const assignAscendingModuleIds = (usedIds, modules, compilation) => {
+	const chunkGraph = compilation.chunkGraph;
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
+	let nextId = 0;
+	let assignId;
+	if (usedIds.size > 0) {
+		assignId = module => {
+			if (chunkGraph.getModuleId(module) === null) {
+				while (usedIds.has(nextId + "")) nextId++;
+				chunkGraph.setModuleId(module, nextId++);
 			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			false
-		);
+		};
+	} else {
+		assignId = module => {
+			if (chunkGraph.getModuleId(module) === null) {
+				chunkGraph.setModuleId(module, nextId++);
+			}
+		};
+	}
+	for (const module of modules) {
+		assignId(module);
+	}
+};
+exports.assignAscendingModuleIds = assignAscendingModuleIds;
 
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
-			: undefined;
+/**
+ * @param {Iterable<Chunk>} chunks the chunks
+ * @param {Compilation} compilation the compilation
+ * @returns {void}
+ */
+const assignAscendingChunkIds = (chunks, compilation) => {
+	const usedIds = getUsedChunkIds(compilation);
 
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
-							rootOutputDir
-								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
-								: "__filename"
-						});`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded chunks",
-			'// "0" means "already loaded", Promise means loading',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.readFileVm = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId] === 0",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded",
-			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
-						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
-						"for(var moduleId in moreModules) {",
-						Template.indent([
-							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-							Template.indent([
-								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-							]),
-							"}"
-						]),
-						"}",
-						`if(runtime) runtime(__webpack_require__);`,
-						"for(var i = 0; i < chunkIds.length; i++) {",
-						Template.indent([
-							"if(installedChunks[chunkIds[i]]) {",
-							Template.indent(["installedChunks[chunkIds[i]][0]();"]),
-							"}",
-							"installedChunks[chunkIds[i]] = 0;"
-						]),
-						"}",
-						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
-				  ])};`
-				: "// no chunk install function needed",
-			"",
-			withLoading
-				? Template.asString([
-						"// ReadFile + VM.run chunk loading for javascript",
-						`${fn}.readFileVm = function(chunkId, promises) {`,
-						hasJsMatcher !== false
-							? Template.indent([
-									"",
-									"var installedChunkData = installedChunks[chunkId];",
-									'if(installedChunkData !== 0) { // 0 means "already installed".',
-									Template.indent([
-										'// array of [resolve, reject, promise] means "currently loading"',
-										"if(installedChunkData) {",
-										Template.indent(["promises.push(installedChunkData[2]);"]),
-										"} else {",
-										Template.indent([
-											hasJsMatcher === true
-												? "if(true) { // all chunks have JS"
-												: `if(${hasJsMatcher("chunkId")}) {`,
-											Template.indent([
-												"// load the chunk and return promise to it",
-												"var promise = new Promise(function(resolve, reject) {",
-												Template.indent([
-													"installedChunkData = installedChunks[chunkId] = [resolve, reject];",
-													`var filename = require('path').join(__dirname, ${JSON.stringify(
-														rootOutputDir
-													)} + ${
-														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId));`,
-													"require('fs').readFile(filename, 'utf-8', function(err, content) {",
-													Template.indent([
-														"if(err) return reject(err);",
-														"var chunk = {};",
-														"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
-															"(chunk, require, require('path').dirname(filename), filename);",
-														"installChunk(chunk);"
-													]),
-													"});"
-												]),
-												"});",
-												"promises.push(installedChunkData[2] = promise);"
-											]),
-											"} else installedChunks[chunkId] = 0;"
-										]),
-										"}"
-									]),
-									"}"
-							  ])
-							: Template.indent(["installedChunks[chunkId] = 0;"]),
-						"};"
-				  ])
-				: "// no chunk loading",
-			"",
-			withExternalInstallChunk
-				? Template.asString([
-						"module.exports = __webpack_require__;",
-						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
-				  ])
-				: "// no external install chunk",
-			"",
-			withHmr
-				? Template.asString([
-						"function loadUpdateChunk(chunkId, updatedModulesList) {",
-						Template.indent([
-							"return new Promise(function(resolve, reject) {",
-							Template.indent([
-								`var filename = require('path').join(__dirname, ${JSON.stringify(
-									rootOutputDir
-								)} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId));`,
-								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
-								Template.indent([
-									"if(err) return reject(err);",
-									"var update = {};",
-									"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
-										"(update, require, require('path').dirname(filename), filename);",
-									"var updatedModules = update.modules;",
-									"var runtime = update.runtime;",
-									"for(var moduleId in updatedModules) {",
-									Template.indent([
-										`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
-										Template.indent([
-											`currentUpdate[moduleId] = updatedModules[moduleId];`,
-											"if(updatedModulesList) updatedModulesList.push(moduleId);"
-										]),
-										"}"
-									]),
-									"}",
-									"if(runtime) currentUpdateRuntime.push(runtime);",
-									"resolve();"
-								]),
-								"});"
-							]),
-							"});"
-						]),
-						"}",
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "readFileVm")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
-						Template.indent([
-							"return new Promise(function(resolve, reject) {",
-							Template.indent([
-								`var filename = require('path').join(__dirname, ${JSON.stringify(
-									rootOutputDir
-								)} + ${RuntimeGlobals.getUpdateManifestFilename}());`,
-								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
-								Template.indent([
-									"if(err) {",
-									Template.indent([
-										'if(err.code === "ENOENT") return resolve();',
-										"return reject(err);"
-									]),
-									"}",
-									"try { resolve(JSON.parse(content)); }",
-									"catch(e) { reject(e); }"
-								]),
-								"});"
-							]),
-							"});"
-						]),
-						"}"
-				  ])
-				: "// no HMR manifest"
-		]);
+	let nextId = 0;
+	if (usedIds.size > 0) {
+		for (const chunk of chunks) {
+			if (chunk.id === null) {
+				while (usedIds.has(nextId + "")) nextId++;
+				chunk.id = nextId;
+				chunk.ids = [nextId];
+				nextId++;
+			}
+		}
+	} else {
+		for (const chunk of chunks) {
+			if (chunk.id === null) {
+				chunk.id = nextId;
+				chunk.ids = [nextId];
+				nextId++;
+			}
+		}
 	}
-}
-
-module.exports = ReadFileChunkLoadingRuntimeModule;
+};
+exports.assignAscendingChunkIds = assignAscendingChunkIds;
 
 
 /***/ }),
 
-/***/ 73163:
+/***/ 6454:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -98843,111 +94486,85 @@ module.exports = ReadFileChunkLoadingRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
+const { compareChunksNatural } = __webpack_require__(29579);
+const {
+	getShortChunkName,
+	getLongChunkName,
+	assignNames,
+	getUsedChunkIds,
+	assignAscendingChunkIds
+} = __webpack_require__(63290);
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-class ReadFileCompileAsyncWasmPlugin {
-	constructor({ type = "async-node", import: useImport = false } = {}) {
-		this._type = type;
-		this._import = useImport;
+class NamedChunkIdsPlugin {
+	constructor(options) {
+		this.delimiter = (options && options.delimiter) || "-";
+		this.context = options && options.context;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ReadFileCompileAsyncWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === this._type;
-				};
-				const generateLoadBinaryCode = this._import
-					? path =>
-							Template.asString([
-								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
-								Template.indent([
-									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
-									Template.indent([
-										"if (err) return reject(err);",
-										"",
-										"// Fake fetch response",
-										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
-										"});"
-									]),
-									"});"
-								]),
-								"}))"
-							])
-					: path =>
-							Template.asString([
-								"new Promise(function (resolve, reject) {",
-								Template.indent([
-									"try {",
-									Template.indent([
-										"var { readFile } = require('fs');",
-										"var { join } = require('path');",
-										"",
-										`readFile(join(__dirname, ${path}), function(err, buffer){`,
-										Template.indent([
-											"if (err) return reject(err);",
-											"",
-											"// Fake fetch response",
-											"resolve({",
-											Template.indent(["arrayBuffer() { return buffer; }"]),
-											"});"
-										]),
-										"});"
-									]),
-									"} catch (err) { reject(err); }"
-								]),
-								"})"
-							]);
+		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
+			const { hashFunction } = compilation.outputOptions;
+			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.context ? this.context : compiler.context;
+				const delimiter = this.delimiter;
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.instantiateWasm)
-					.tap("ReadFileCompileAsyncWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/async"
-							)
-						) {
-							return;
+				const unnamedChunks = assignNames(
+					Array.from(chunks).filter(chunk => {
+						if (chunk.name) {
+							chunk.id = chunk.name;
+							chunk.ids = [chunk.name];
 						}
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
+						return chunk.id === null;
+					}),
+					chunk =>
+						getShortChunkName(
 							chunk,
-							new AsyncWasmLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: false
-							})
-						);
-					});
-			}
-		);
+							chunkGraph,
+							context,
+							delimiter,
+							hashFunction,
+							compiler.root
+						),
+					chunk =>
+						getLongChunkName(
+							chunk,
+							chunkGraph,
+							context,
+							delimiter,
+							hashFunction,
+							compiler.root
+						),
+					compareChunksNatural(chunkGraph),
+					getUsedChunkIds(compilation),
+					(chunk, name) => {
+						chunk.id = name;
+						chunk.ids = [name];
+					}
+				);
+				if (unnamedChunks.length > 0) {
+					assignAscendingChunkIds(unnamedChunks, compilation);
+				}
+			});
+		});
 	}
 }
 
-module.exports = ReadFileCompileAsyncWasmPlugin;
+module.exports = NamedChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 98939:
+/***/ 24339:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -98958,15 +94575,19 @@ module.exports = ReadFileCompileAsyncWasmPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const {
+	getShortModuleName,
+	getLongModuleName,
+	assignNames,
+	getUsedModuleIdsAndModules,
+	assignAscendingModuleIds
+} = __webpack_require__(63290);
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-// TODO webpack 6 remove
-
-class ReadFileCompileWasmPlugin {
+class NamedModuleIdsPlugin {
 	constructor(options) {
 		this.options = options || {};
 	}
@@ -98977,460 +94598,127 @@ class ReadFileCompileWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ReadFileCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "async-node";
-				};
-				const generateLoadBinaryCode = path =>
-					Template.asString([
-						"new Promise(function (resolve, reject) {",
-						Template.indent([
-							"var { readFile } = require('fs');",
-							"var { join } = require('path');",
-							"",
-							"try {",
-							Template.indent([
-								`readFile(join(__dirname, ${path}), function(err, buffer){`,
-								Template.indent([
-									"if (err) return reject(err);",
-									"",
-									"// Fake fetch response",
-									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
-									"});"
-								]),
-								"});"
-							]),
-							"} catch (err) { reject(err); }"
-						]),
-						"})"
-					]);
+		const { root } = compiler;
+		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
+			const { hashFunction } = compilation.outputOptions;
+			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ReadFileCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						compilation.addRuntimeModule(
-							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: false,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const unnamedModules = assignNames(
+					modules,
+					m => getShortModuleName(m, context, root),
+					(m, shortName) =>
+						getLongModuleName(shortName, m, context, hashFunction, root),
+					compareModulesByIdentifier,
+					usedIds,
+					(m, name) => chunkGraph.setModuleId(m, name)
+				);
+				if (unnamedModules.length > 0) {
+					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
+				}
+			});
+		});
 	}
 }
 
-module.exports = ReadFileCompileWasmPlugin;
+module.exports = NamedModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 94172:
+/***/ 86221:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
+const { compareChunksNatural } = __webpack_require__(29579);
+const { assignAscendingChunkIds } = __webpack_require__(63290);
 
-class RequireChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("require chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.runtimeRequirements = runtimeRequirements;
-	}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
+class NaturalChunkIdsPlugin {
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withExternalInstallChunk = this.runtimeRequirements.has(
-			RuntimeGlobals.externalInstallChunk
-		);
-		const withOnChunkLoad = this.runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withLoading = this.runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withHmr = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
-
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			true
-		);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_require`
-			: undefined;
-
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
-							rootOutputDir !== "./"
-								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
-								: "__filename"
-						});`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded chunks",
-			'// "1" means "loaded", otherwise not loaded yet',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.require = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId]",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded",
-			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
-						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
-						"for(var moduleId in moreModules) {",
-						Template.indent([
-							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-							Template.indent([
-								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-							]),
-							"}"
-						]),
-						"}",
-						`if(runtime) runtime(__webpack_require__);`,
-						"for(var i = 0; i < chunkIds.length; i++)",
-						Template.indent("installedChunks[chunkIds[i]] = 1;"),
-						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
-				  ])};`
-				: "// no chunk install function needed",
-			"",
-			withLoading
-				? Template.asString([
-						"// require() chunk loading for javascript",
-						`${fn}.require = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? [
-										'// "1" is the signal for "already loaded"',
-										"if(!installedChunks[chunkId]) {",
-										Template.indent([
-											hasJsMatcher === true
-												? "if(true) { // all chunks have JS"
-												: `if(${hasJsMatcher("chunkId")}) {`,
-											Template.indent([
-												`installChunk(require(${JSON.stringify(
-													rootOutputDir
-												)} + ${
-													RuntimeGlobals.getChunkScriptFilename
-												}(chunkId)));`
-											]),
-											"} else installedChunks[chunkId] = 1;",
-											""
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 1;"
-						)};`
-				  ])
-				: "// no chunk loading",
-			"",
-			withExternalInstallChunk
-				? Template.asString([
-						"module.exports = __webpack_require__;",
-						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
-				  ])
-				: "// no external install chunk",
-			"",
-			withHmr
-				? Template.asString([
-						"function loadUpdateChunk(chunkId, updatedModulesList) {",
-						Template.indent([
-							`var update = require(${JSON.stringify(rootOutputDir)} + ${
-								RuntimeGlobals.getChunkUpdateScriptFilename
-							}(chunkId));`,
-							"var updatedModules = update.modules;",
-							"var runtime = update.runtime;",
-							"for(var moduleId in updatedModules) {",
-							Template.indent([
-								`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
-								Template.indent([
-									`currentUpdate[moduleId] = updatedModules[moduleId];`,
-									"if(updatedModulesList) updatedModulesList.push(moduleId);"
-								]),
-								"}"
-							]),
-							"}",
-							"if(runtime) currentUpdateRuntime.push(runtime);"
-						]),
-						"}",
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "require")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
-						Template.indent([
-							"return Promise.resolve().then(function() {",
-							Template.indent([
-								`return require(${JSON.stringify(rootOutputDir)} + ${
-									RuntimeGlobals.getUpdateManifestFilename
-								}());`
-							]),
-							"})['catch'](function(err) { if(err.code !== 'MODULE_NOT_FOUND') throw err; });"
-						]),
-						"}"
-				  ])
-				: "// no HMR manifest"
-		]);
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NaturalChunkIdsPlugin", compilation => {
+			compilation.hooks.chunkIds.tap("NaturalChunkIdsPlugin", chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				const compareNatural = compareChunksNatural(chunkGraph);
+				const chunksInNaturalOrder = Array.from(chunks).sort(compareNatural);
+				assignAscendingChunkIds(chunksInNaturalOrder, compilation);
+			});
+		});
 	}
 }
 
-module.exports = RequireChunkLoadingRuntimeModule;
+module.exports = NaturalChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 91786:
+/***/ 83366:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const util = __webpack_require__(73837);
-const truncateArgs = __webpack_require__(62090);
-
-module.exports = ({ colors, appendOnly, stream }) => {
-	let currentStatusMessage = undefined;
-	let hasStatusMessage = false;
-	let currentIndent = "";
-	let currentCollapsed = 0;
-
-	const indent = (str, prefix, colorPrefix, colorSuffix) => {
-		if (str === "") return str;
-		prefix = currentIndent + prefix;
-		if (colors) {
-			return (
-				prefix +
-				colorPrefix +
-				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
-				colorSuffix
-			);
-		} else {
-			return prefix + str.replace(/\n/g, "\n" + prefix);
-		}
-	};
-
-	const clearStatusMessage = () => {
-		if (hasStatusMessage) {
-			stream.write("\x1b[2K\r");
-			hasStatusMessage = false;
-		}
-	};
-
-	const writeStatusMessage = () => {
-		if (!currentStatusMessage) return;
-		const l = stream.columns;
-		const args = l
-			? truncateArgs(currentStatusMessage, l - 1)
-			: currentStatusMessage;
-		const str = args.join(" ");
-		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
-		stream.write(`\x1b[2K\r${coloredStr}`);
-		hasStatusMessage = true;
-	};
-
-	const writeColored = (prefix, colorPrefix, colorSuffix) => {
-		return (...args) => {
-			if (currentCollapsed > 0) return;
-			clearStatusMessage();
-			const str = indent(
-				util.format(...args),
-				prefix,
-				colorPrefix,
-				colorSuffix
-			);
-			stream.write(str + "\n");
-			writeStatusMessage();
-		};
-	};
-
-	const writeGroupMessage = writeColored(
-		"<-> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
-	);
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = __webpack_require__(63290);
 
-	const writeGroupCollapsedMessage = writeColored(
-		"<+> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
-	);
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-	return {
-		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
-		debug: writeColored("    ", "", ""),
-		trace: writeColored("    ", "", ""),
-		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
-		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
-		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
-		logTime: writeColored(
-			"<t> ",
-			"\u001b[1m\u001b[35m",
-			"\u001b[39m\u001b[22m"
-		),
-		group: (...args) => {
-			writeGroupMessage(...args);
-			if (currentCollapsed > 0) {
-				currentCollapsed++;
-			} else {
-				currentIndent += "  ";
-			}
-		},
-		groupCollapsed: (...args) => {
-			writeGroupCollapsedMessage(...args);
-			currentCollapsed++;
-		},
-		groupEnd: () => {
-			if (currentCollapsed > 0) currentCollapsed--;
-			else if (currentIndent.length >= 2)
-				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
-		},
-		// eslint-disable-next-line node/no-unsupported-features/node-builtins
-		profile: console.profile && (name => console.profile(name)),
-		// eslint-disable-next-line node/no-unsupported-features/node-builtins
-		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
-		clear:
-			!appendOnly &&
-			// eslint-disable-next-line node/no-unsupported-features/node-builtins
-			console.clear &&
-			(() => {
-				clearStatusMessage();
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				console.clear();
-				writeStatusMessage();
-			}),
-		status: appendOnly
-			? writeColored("<s> ", "", "")
-			: (name, ...args) => {
-					args = args.filter(Boolean);
-					if (name === undefined && args.length === 0) {
-						clearStatusMessage();
-						currentStatusMessage = undefined;
-					} else if (
-						typeof name === "string" &&
-						name.startsWith("[webpack.Progress] ")
-					) {
-						currentStatusMessage = [name.slice(19), ...args];
-						writeStatusMessage();
-					} else if (name === "[webpack.Progress]") {
-						currentStatusMessage = [...args];
-						writeStatusMessage();
-					} else {
-						currentStatusMessage = [name, ...args];
-						writeStatusMessage();
-					}
-			  }
-	};
-};
+class NaturalModuleIdsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
+			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
+				const [usedIds, modulesInNaturalOrder] =
+					getUsedModuleIdsAndModules(compilation);
+				modulesInNaturalOrder.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
+			});
+		});
+	}
+}
+
+module.exports = NaturalModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 64395:
+/***/ 51020:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -99441,22 +94729,31 @@ module.exports = ({ colors, appendOnly, stream }) => {
 
 
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
+const { compareChunksNatural } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const { assignAscendingChunkIds } = __webpack_require__(63290);
 
+/** @typedef {import("../../declarations/plugins/ids/OccurrenceChunkIdsPlugin").OccurrenceChunkIdsPluginOptions} OccurrenceChunkIdsPluginOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-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 || {};
+const validate = createSchemaValidation(
+	__webpack_require__(24344),
+	() => __webpack_require__(53576),
+	{
+		name: "Occurrence Order Chunk Ids Plugin",
+		baseDataPath: "options"
+	}
+);
+
+class OccurrenceChunkIdsPlugin {
+	/**
+	 * @param {OccurrenceChunkIdsPluginOptions=} options options object
+	 */
+	constructor(options = {}) {
+		validate(options);
+		this.options = options;
 	}
 
 	/**
@@ -99465,72 +94762,51 @@ class AggressiveMergingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const options = this.options;
-		const minSizeReduce = options.minSizeReduce || 1.5;
-
-		compiler.hooks.thisCompilation.tap(
-			"AggressiveMergingPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "AggressiveMergingPlugin",
-						stage: STAGE_ADVANCED
-					},
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
-						let combinations = [];
-						for (const a of chunks) {
-							if (a.canBeInitial()) continue;
-							for (const b of chunks) {
-								if (b.canBeInitial()) continue;
-								if (b === a) break;
-								if (!chunkGraph.canChunksBeIntegrated(a, b)) {
-									continue;
-								}
-								const aSize = chunkGraph.getChunkSize(b, {
-									chunkOverhead: 0
-								});
-								const bSize = chunkGraph.getChunkSize(a, {
-									chunkOverhead: 0
-								});
-								const abSize = chunkGraph.getIntegratedChunksSize(b, a, {
-									chunkOverhead: 0
-								});
-								const improvement = (aSize + bSize) / abSize;
-								combinations.push({
-									a,
-									b,
-									improvement
-								});
-							}
-						}
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap("OccurrenceChunkIdsPlugin", compilation => {
+			compilation.hooks.chunkIds.tap("OccurrenceChunkIdsPlugin", chunks => {
+				const chunkGraph = compilation.chunkGraph;
 
-						combinations.sort((a, b) => {
-							return b.improvement - a.improvement;
-						});
+				/** @type {Map<Chunk, number>} */
+				const occursInInitialChunksMap = new Map();
 
-						const pair = combinations[0];
+				const compareNatural = compareChunksNatural(chunkGraph);
 
-						if (!pair) return;
-						if (pair.improvement < minSizeReduce) return;
+				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);
+				}
 
-						chunkGraph.integrateChunks(pair.b, pair.a);
-						compilation.chunks.delete(pair.a);
-						return true;
+				const chunksInOccurrenceOrder = Array.from(chunks).sort((a, b) => {
+					if (prioritiseInitial) {
+						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;
+					return compareNatural(a, b);
+				});
+				assignAscendingChunkIds(chunksInOccurrenceOrder, compilation);
+			});
+		});
 	}
 }
 
-module.exports = AggressiveMergingPlugin;
+module.exports = OccurrenceChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 15543:
+/***/ 35371:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -99541,80 +94817,36 @@ module.exports = AggressiveMergingPlugin;
 
 
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const { intersect } = __webpack_require__(93347);
 const {
-	compareModulesByIdentifier,
-	compareChunks
+	compareModulesByPreOrderIndexOrIdentifier
 } = __webpack_require__(29579);
 const createSchemaValidation = __webpack_require__(32540);
-const identifierUtils = __webpack_require__(82186);
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = __webpack_require__(63290);
 
-/** @typedef {import("../../declarations/plugins/optimize/AggressiveSplittingPlugin").AggressiveSplittingPluginOptions} AggressiveSplittingPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 
 const validate = createSchemaValidation(
-	__webpack_require__(32697),
-	() =>
-		__webpack_require__(47995),
+	__webpack_require__(14916),
+	() => __webpack_require__(19330),
 	{
-		name: "Aggressive Splitting Plugin",
+		name: "Occurrence Order Module Ids Plugin",
 		baseDataPath: "options"
 	}
 );
 
-const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
-	return module => {
-		chunkGraph.disconnectChunkAndModule(oldChunk, module);
-		chunkGraph.connectChunkAndModule(newChunk, module);
-	};
-};
-
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Chunk} chunk the chunk
- * @returns {function(Module): boolean} filter for entry module
- */
-const isNotAEntryModule = (chunkGraph, chunk) => {
-	return module => {
-		return !chunkGraph.isEntryModuleInChunk(module, chunk);
-	};
-};
-
-/** @type {WeakSet<Chunk>} */
-const recordedChunks = new WeakSet();
-
-class AggressiveSplittingPlugin {
+class OccurrenceModuleIdsPlugin {
 	/**
-	 * @param {AggressiveSplittingPluginOptions=} options options object
+	 * @param {OccurrenceModuleIdsPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
 		validate(options);
-
 		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;
-		}
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk to test
-	 * @returns {boolean} true if the chunk was recorded
-	 */
-	static wasChunkRecorded(chunk) {
-		return recordedChunks.has(chunk);
 	}
 
 	/**
@@ -99623,251 +94855,125 @@ class AggressiveSplittingPlugin {
 	 * @returns {void}
 	 */
 	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.optimizeChunks.tap(
-					{
-						name: "AggressiveSplittingPlugin",
-						stage: STAGE_ADVANCED
-					},
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						// Precompute stuff
-						const nameToModuleMap = new Map();
-						const moduleToNameMap = new Map();
-						const makePathsRelative =
-							identifierUtils.makePathsRelative.bindContextCache(
-								compiler.context,
-								compiler.root
-							);
-						for (const m of compilation.modules) {
-							const name = makePathsRelative(m.identifier());
-							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)
-							let size = 0;
-							for (const m of selectedModules) size += m.size();
-							if (size !== splitData.size) return false;
-
-							// get chunks with all modules
-							const selectedChunks = intersect(
-								selectedModules.map(
-									m => new Set(chunkGraph.getModuleChunksIterable(m))
-								)
-							);
-
-							// No relevant chunks found
-							if (selectedChunks.size === 0) return false;
-
-							// The found chunk is already the split or similar
-							if (
-								selectedChunks.size === 1 &&
-								chunkGraph.getNumberOfChunkModules(
-									Array.from(selectedChunks)[0]
-								) === selectedModules.length
-							) {
-								const chunk = Array.from(selectedChunks)[0];
-								if (fromAggressiveSplittingSet.has(chunk)) return false;
-								fromAggressiveSplittingSet.add(chunk);
-								chunkSplitDataMap.set(chunk, splitData);
-								return true;
-							}
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
 
-							// split the chunk into two parts
-							const newChunk = compilation.addChunk();
-							newChunk.chunkReason = "aggressive splitted";
-							for (const chunk of selectedChunks) {
-								selectedModules.forEach(
-									moveModuleBetween(chunkGraph, chunk, newChunk)
-								);
-								chunk.split(newChunk);
-								chunk.name = null;
-							}
-							fromAggressiveSplittingSet.add(newChunk);
-							chunkSplitDataMap.set(newChunk, splitData);
+			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
+				const chunkGraph = compilation.chunkGraph;
 
-							if (splitData.id !== null && splitData.id !== undefined) {
-								newChunk.id = splitData.id;
-								newChunk.ids = [splitData.id];
-							}
-							return true;
-						};
+				const [usedIds, modulesInOccurrenceOrder] =
+					getUsedModuleIdsAndModules(compilation);
 
-						// 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;
-						}
+				const occursInInitialChunksMap = new Map();
+				const occursInAllChunksMap = new Map();
 
-						// for any chunk which isn't splitted yet, split it and create a new entry
-						// start with the biggest chunk
-						const cmpFn = compareChunks(chunkGraph);
-						const sortedChunks = Array.from(chunks).sort((a, b) => {
-							const diff1 =
-								chunkGraph.getChunkModulesSize(b) -
-								chunkGraph.getChunkModulesSize(a);
-							if (diff1) return diff1;
-							const diff2 =
-								chunkGraph.getNumberOfChunkModules(a) -
-								chunkGraph.getNumberOfChunkModules(b);
-							if (diff2) return diff2;
-							return cmpFn(a, b);
-						});
-						for (const chunk of sortedChunks) {
-							if (fromAggressiveSplittingSet.has(chunk)) continue;
-							const size = chunkGraph.getChunkModulesSize(chunk);
-							if (
-								size > maxSize &&
-								chunkGraph.getNumberOfChunkModules(chunk) > 1
-							) {
-								const modules = chunkGraph
-									.getOrderedChunkModules(chunk, compareModulesByIdentifier)
-									.filter(isNotAEntryModule(chunkGraph, chunk));
-								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
-								};
+				const initialChunkChunkMap = new Map();
+				const entryCountMap = new Map();
+				for (const m of modulesInOccurrenceOrder) {
+					let initial = 0;
+					let entry = 0;
+					for (const c of chunkGraph.getModuleChunksIterable(m)) {
+						if (c.canBeInitial()) initial++;
+						if (chunkGraph.isEntryModuleInChunk(m, c)) entry++;
+					}
+					initialChunkChunkMap.set(m, initial);
+					entryCountMap.set(m, entry);
+				}
 
-								if (applySplit(splitData)) {
-									newSplits = (newSplits || []).concat(splitData);
-									changed = true;
-								}
-							}
-						}
-						if (changed) return true;
+				/**
+				 * @param {Module} module module
+				 * @returns {number} count of occurs
+				 */
+				const countOccursInEntry = module => {
+					let sum = 0;
+					for (const [
+						originModule,
+						connections
+					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+						if (!originModule) continue;
+						if (!connections.some(c => c.isTargetActive(undefined))) continue;
+						sum += initialChunkChunkMap.get(originModule);
 					}
-				);
-				compilation.hooks.recordHash.tap(
-					"AggressiveSplittingPlugin",
-					records => {
-						// 4. save made splittings to records
-						const allSplits = new Set();
-						const invalidSplits = new Set();
+					return sum;
+				};
 
-						// 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);
-								}
-							}
+				/**
+				 * @param {Module} module module
+				 * @returns {number} count of occurs
+				 */
+				const countOccurs = module => {
+					let sum = 0;
+					for (const [
+						originModule,
+						connections
+					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+						if (!originModule) continue;
+						const chunkModules =
+							chunkGraph.getNumberOfModuleChunks(originModule);
+						for (const c of connections) {
+							if (!c.isTargetActive(undefined)) continue;
+							if (!c.dependency) continue;
+							const factor = c.dependency.getNumberOfIdOccurrences();
+							if (factor === 0) continue;
+							sum += factor * chunkModules;
 						}
+					}
+					return sum;
+				};
 
-						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
-									recordedChunks.add(chunk);
-								}
-							}
-
-							// Also add all unused historical 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);
-								}
-							}
+				if (prioritiseInitial) {
+					for (const m of modulesInOccurrenceOrder) {
+						const result =
+							countOccursInEntry(m) +
+							initialChunkChunkMap.get(m) +
+							entryCountMap.get(m);
+						occursInInitialChunksMap.set(m, result);
+					}
+				}
 
-							// record all splits
-							records.aggressiveSplits = Array.from(allSplits);
+				for (const m of modulesInOccurrenceOrder) {
+					const result =
+						countOccurs(m) +
+						chunkGraph.getNumberOfModuleChunks(m) +
+						entryCountMap.get(m);
+					occursInAllChunksMap.set(m, result);
+				}
 
-							needAdditionalSeal = false;
-						}
-					}
+				const naturalCompare = compareModulesByPreOrderIndexOrIdentifier(
+					compilation.moduleGraph
 				);
-				compilation.hooks.needAdditionalSeal.tap(
-					"AggressiveSplittingPlugin",
-					() => {
-						if (needAdditionalSeal) {
-							needAdditionalSeal = false;
-							return true;
-						}
+
+				modulesInOccurrenceOrder.sort((a, b) => {
+					if (prioritiseInitial) {
+						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;
+					return naturalCompare(a, b);
+				});
+
+				assignAscendingModuleIds(
+					usedIds,
+					modulesInOccurrenceOrder,
+					compilation
 				);
-			}
-		);
+			});
+		});
 	}
 }
-module.exports = AggressiveSplittingPlugin;
+
+module.exports = OccurrenceModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 97198:
+/***/ 8635:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -99878,1877 +94984,1723 @@ module.exports = AggressiveSplittingPlugin;
 
 
 
-const eslintScope = __webpack_require__(36007);
-const Referencer = __webpack_require__(44585);
-const {
-	CachedSource,
-	ConcatSource,
-	ReplaceSource
-} = __webpack_require__(51255);
-const ConcatenationScope = __webpack_require__(98229);
-const { UsageState } = __webpack_require__(63686);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HarmonyImportDependency = __webpack_require__(57154);
-const JavascriptParser = __webpack_require__(29050);
-const { equals } = __webpack_require__(84953);
-const LazySet = __webpack_require__(38938);
-const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const { makePathsRelative } = __webpack_require__(82186);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const {
-	filterRuntime,
-	intersectRuntime,
-	mergeRuntimeCondition,
-	mergeRuntimeConditionNonFalse,
-	runtimeConditionToString,
-	subtractRuntimeCondition
-} = __webpack_require__(17156);
+const { WebpackError } = __webpack_require__(91919);
+const { getUsedModuleIdsAndModules } = __webpack_require__(63290);
 
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {typeof import("../util/Hash")} HashConstructor */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-// fix eslint-scope to support class properties correctly
-// cspell:word Referencer
-const ReferencerClass = Referencer;
-if (!ReferencerClass.prototype.PropertyDefinition) {
-	ReferencerClass.prototype.PropertyDefinition =
-		ReferencerClass.prototype.Property;
+const plugin = "SyncModuleIdsPlugin";
+
+class SyncModuleIdsPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.path path to file
+	 * @param {string=} options.context context for module names
+	 * @param {function(Module): boolean} options.test selector for modules
+	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 */
+	constructor({ path, context, test, mode }) {
+		this._path = path;
+		this._context = context;
+		this._test = test || (() => true);
+		const readAndWrite = !mode || mode === "merge" || mode === "update";
+		this._read = readAndWrite || mode === "read";
+		this._write = readAndWrite || mode === "create";
+		this._prune = mode === "update";
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Map<string, string | number>} */
+		let data;
+		let dataChanged = false;
+		if (this._read) {
+			compiler.hooks.readRecords.tapAsync(plugin, callback => {
+				const fs = compiler.intermediateFileSystem;
+				fs.readFile(this._path, (err, buffer) => {
+					if (err) {
+						if (err.code !== "ENOENT") {
+							return callback(err);
+						}
+						return callback();
+					}
+					const json = JSON.parse(buffer.toString());
+					data = new Map();
+					for (const key of Object.keys(json)) {
+						data.set(key, json[key]);
+					}
+					dataChanged = false;
+					return callback();
+				});
+			});
+		}
+		if (this._write) {
+			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
+				if (!data || !dataChanged) return callback();
+				const json = {};
+				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
+				for (const [key, value] of sorted) {
+					json[key] = value;
+				}
+				const fs = compiler.intermediateFileSystem;
+				fs.writeFile(this._path, JSON.stringify(json), callback);
+			});
+		}
+		compiler.hooks.thisCompilation.tap(plugin, compilation => {
+			const associatedObjectForCache = compiler.root;
+			const context = this._context || compiler.context;
+			if (this._read) {
+				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
+					if (!data) return;
+					const { chunkGraph } = compilation;
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this._test
+					);
+					for (const module of modules) {
+						const name = module.libIdent({
+							context,
+							associatedObjectForCache
+						});
+						if (!name) continue;
+						const id = data.get(name);
+						const idAsString = `${id}`;
+						if (usedIds.has(idAsString)) {
+							const err = new WebpackError(
+								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
+							);
+							err.module = module;
+							compilation.errors.push(err);
+						}
+						chunkGraph.setModuleId(module, id);
+						usedIds.add(idAsString);
+					}
+				});
+			}
+			if (this._write) {
+				compilation.hooks.recordModules.tap(plugin, modules => {
+					const { chunkGraph } = compilation;
+					let oldData = data;
+					if (!oldData) {
+						oldData = data = new Map();
+					} else if (this._prune) {
+						data = new Map();
+					}
+					for (const module of modules) {
+						if (this._test(module)) {
+							const name = module.libIdent({
+								context,
+								associatedObjectForCache
+							});
+							if (!name) continue;
+							const id = chunkGraph.getModuleId(module);
+							if (id === null) continue;
+							const oldId = oldData.get(name);
+							if (oldId !== id) {
+								dataChanged = true;
+							} else if (data === oldData) {
+								continue;
+							}
+							data.set(name, id);
+						}
+					}
+					if (data.size !== oldData.size) dataChanged = true;
+				});
+			}
+		});
+	}
 }
 
-/**
- * @typedef {Object} ReexportInfo
- * @property {Module} module
- * @property {string[]} export
- */
+module.exports = SyncModuleIdsPlugin;
 
-/** @typedef {RawBinding | SymbolBinding} Binding */
 
-/**
- * @typedef {Object} RawBinding
- * @property {ModuleInfo} info
- * @property {string} rawName
- * @property {string=} comment
- * @property {string[]} ids
- * @property {string[]} exportName
- */
+/***/ }),
 
-/**
- * @typedef {Object} SymbolBinding
- * @property {ConcatenatedModuleInfo} info
- * @property {string} name
- * @property {string=} comment
- * @property {string[]} ids
- * @property {string[]} exportName
- */
+/***/ 91919:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo } ModuleInfo */
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @typedef {Object} ConcatenatedModuleInfo
- * @property {"concatenated"} type
- * @property {Module} module
- * @property {number} index
- * @property {Object} ast
- * @property {Source} internalSource
- * @property {ReplaceSource} source
- * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {Iterable<string>} runtimeRequirements
- * @property {Scope} globalScope
- * @property {Scope} moduleScope
- * @property {Map<string, string>} internalNames
- * @property {Map<string, string>} exportMap
- * @property {Map<string, string>} rawExportMap
- * @property {string=} namespaceExportSymbol
- * @property {string} namespaceObjectName
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
- */
+
+
+const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
+/** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
+/** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetCondition} RuleSetCondition */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./Compilation").Asset} Asset */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./Parser").ParserState} ParserState */
+/** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
+/** @typedef {import("./ResolverFactory").Resolver} Resolver */
+/** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLogging} StatsLogging */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLoggingEntry} StatsLoggingEntry */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
 
 /**
- * @typedef {Object} ExternalModuleInfo
- * @property {"external"} type
- * @property {Module} module
- * @property {RuntimeSpec | boolean} runtimeCondition
- * @property {number} index
- * @property {string} name
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
+ * @template {Function} T
+ * @param {function(): T} factory factory function
+ * @returns {T} function
  */
+const lazyFunction = factory => {
+	const fac = memoize(factory);
+	const f = /** @type {any} */ (
+		(...args) => {
+			return fac()(...args);
+		}
+	);
+	return /** @type {T} */ (f);
+};
 
 /**
- * @typedef {Object} ReferenceToModuleInfo
- * @property {"reference"} type
- * @property {RuntimeSpec | boolean} runtimeCondition
- * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
  */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	for (const name of Object.keys(descriptors)) {
+		const descriptor = descriptors[name];
+		if (descriptor.get) {
+			const fn = descriptor.get;
+			Object.defineProperty(obj, name, {
+				configurable: false,
+				enumerable: true,
+				get: memoize(fn)
+			});
+		} else if (typeof descriptor.value === "object") {
+			Object.defineProperty(obj, name, {
+				configurable: false,
+				enumerable: true,
+				writable: false,
+				value: mergeExports({}, descriptor.value)
+			});
+		} else {
+			throw new Error(
+				"Exposed values must be either a getter or an nested object"
+			);
+		}
+	}
+	return /** @type {A & B} */ (Object.freeze(obj));
+};
 
-const RESERVED_NAMES = new Set(
-	[
-		// internal names (should always be renamed)
-		ConcatenationScope.DEFAULT_EXPORT,
-		ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
-
-		// keywords
-		"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",
-
-		// commonjs/amd
-		"module,__dirname,__filename,exports,require,define",
-
-		// js globals
-		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
-		"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
-
-		// browser globals
-		"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",
+const fn = lazyFunction(() => __webpack_require__(36243));
+module.exports = mergeExports(fn, {
+	get webpack() {
+		return __webpack_require__(36243);
+	},
+	get validate() {
+		const webpackOptionsSchemaCheck = __webpack_require__(10382);
+		const getRealValidate = memoize(() => {
+			const validateSchema = __webpack_require__(12047);
+			const webpackOptionsSchema = __webpack_require__(73342);
+			return options => validateSchema(webpackOptionsSchema, options);
+		});
+		return options => {
+			if (!webpackOptionsSchemaCheck(options)) getRealValidate()(options);
+		};
+	},
+	get validateSchema() {
+		const validateSchema = __webpack_require__(12047);
+		return validateSchema;
+	},
+	get version() {
+		return /** @type {string} */ ((__webpack_require__(32702)/* .version */ .i8));
+	},
 
-		// window events
-		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
-	]
-		.join(",")
-		.split(",")
-);
+	get cli() {
+		return __webpack_require__(13462);
+	},
+	get AutomaticPrefetchPlugin() {
+		return __webpack_require__(17714);
+	},
+	get AsyncDependenciesBlock() {
+		return __webpack_require__(47736);
+	},
+	get BannerPlugin() {
+		return __webpack_require__(21242);
+	},
+	get Cache() {
+		return __webpack_require__(7592);
+	},
+	get Chunk() {
+		return __webpack_require__(39385);
+	},
+	get ChunkGraph() {
+		return __webpack_require__(64971);
+	},
+	get CleanPlugin() {
+		return __webpack_require__(31085);
+	},
+	get Compilation() {
+		return __webpack_require__(85720);
+	},
+	get Compiler() {
+		return __webpack_require__(70845);
+	},
+	get ConcatenationScope() {
+		return __webpack_require__(98229);
+	},
+	get ContextExclusionPlugin() {
+		return __webpack_require__(21411);
+	},
+	get ContextReplacementPlugin() {
+		return __webpack_require__(12206);
+	},
+	get DefinePlugin() {
+		return __webpack_require__(79065);
+	},
+	get DelegatedPlugin() {
+		return __webpack_require__(80632);
+	},
+	get Dependency() {
+		return __webpack_require__(54912);
+	},
+	get DllPlugin() {
+		return __webpack_require__(40038);
+	},
+	get DllReferencePlugin() {
+		return __webpack_require__(90999);
+	},
+	get DynamicEntryPlugin() {
+		return __webpack_require__(96475);
+	},
+	get EntryOptionPlugin() {
+		return __webpack_require__(9909);
+	},
+	get EntryPlugin() {
+		return __webpack_require__(96953);
+	},
+	get EnvironmentPlugin() {
+		return __webpack_require__(22070);
+	},
+	get EvalDevToolModulePlugin() {
+		return __webpack_require__(65218);
+	},
+	get EvalSourceMapDevToolPlugin() {
+		return __webpack_require__(14790);
+	},
+	get ExternalModule() {
+		return __webpack_require__(73071);
+	},
+	get ExternalsPlugin() {
+		return __webpack_require__(6652);
+	},
+	get Generator() {
+		return __webpack_require__(93401);
+	},
+	get HotUpdateChunk() {
+		return __webpack_require__(9597);
+	},
+	get HotModuleReplacementPlugin() {
+		return __webpack_require__(6404);
+	},
+	get IgnorePlugin() {
+		return __webpack_require__(84808);
+	},
+	get JavascriptModulesPlugin() {
+		return util.deprecate(
+			() => __webpack_require__(89464),
+			"webpack.JavascriptModulesPlugin has moved to webpack.javascript.JavascriptModulesPlugin",
+			"DEP_WEBPACK_JAVASCRIPT_MODULES_PLUGIN"
+		)();
+	},
+	get LibManifestPlugin() {
+		return __webpack_require__(93837);
+	},
+	get LibraryTemplatePlugin() {
+		return util.deprecate(
+			() => __webpack_require__(14157),
+			"webpack.LibraryTemplatePlugin is deprecated and has been replaced by compilation.outputOptions.library or compilation.addEntry + passing a library option",
+			"DEP_WEBPACK_LIBRARY_TEMPLATE_PLUGIN"
+		)();
+	},
+	get LoaderOptionsPlugin() {
+		return __webpack_require__(22078);
+	},
+	get LoaderTargetPlugin() {
+		return __webpack_require__(86738);
+	},
+	get Module() {
+		return __webpack_require__(73208);
+	},
+	get ModuleFilenameHelpers() {
+		return __webpack_require__(88821);
+	},
+	get ModuleGraph() {
+		return __webpack_require__(99988);
+	},
+	get ModuleGraphConnection() {
+		return __webpack_require__(40639);
+	},
+	get NoEmitOnErrorsPlugin() {
+		return __webpack_require__(50169);
+	},
+	get NormalModule() {
+		return __webpack_require__(39);
+	},
+	get NormalModuleReplacementPlugin() {
+		return __webpack_require__(30633);
+	},
+	get MultiCompiler() {
+		return __webpack_require__(33370);
+	},
+	get Parser() {
+		return __webpack_require__(11715);
+	},
+	get PrefetchPlugin() {
+		return __webpack_require__(73850);
+	},
+	get ProgressPlugin() {
+		return __webpack_require__(13216);
+	},
+	get ProvidePlugin() {
+		return __webpack_require__(38309);
+	},
+	get RuntimeGlobals() {
+		return __webpack_require__(16475);
+	},
+	get RuntimeModule() {
+		return __webpack_require__(16963);
+	},
+	get SingleEntryPlugin() {
+		return util.deprecate(
+			() => __webpack_require__(96953),
+			"SingleEntryPlugin was renamed to EntryPlugin",
+			"DEP_WEBPACK_SINGLE_ENTRY_PLUGIN"
+		)();
+	},
+	get SourceMapDevToolPlugin() {
+		return __webpack_require__(63872);
+	},
+	get Stats() {
+		return __webpack_require__(31743);
+	},
+	get Template() {
+		return __webpack_require__(39722);
+	},
+	get UsageState() {
+		return (__webpack_require__(63686).UsageState);
+	},
+	get WatchIgnorePlugin() {
+		return __webpack_require__(65193);
+	},
+	get WebpackError() {
+		return __webpack_require__(53799);
+	},
+	get WebpackOptionsApply() {
+		return __webpack_require__(88422);
+	},
+	get WebpackOptionsDefaulter() {
+		return util.deprecate(
+			() => __webpack_require__(14452),
+			"webpack.WebpackOptionsDefaulter is deprecated and has been replaced by webpack.config.getNormalizedWebpackOptions and webpack.config.applyWebpackOptionsDefaults",
+			"DEP_WEBPACK_OPTIONS_DEFAULTER"
+		)();
+	},
+	// TODO webpack 6 deprecate
+	get WebpackOptionsValidationError() {
+		return (__webpack_require__(38476).ValidationError);
+	},
+	get ValidationError() {
+		return (__webpack_require__(38476).ValidationError);
+	},
 
-const bySourceOrder = (a, b) => {
-	const aOrder = a.sourceOrder;
-	const bOrder = b.sourceOrder;
-	if (isNaN(aOrder)) {
-		if (!isNaN(bOrder)) {
-			return 1;
-		}
-	} else {
-		if (isNaN(bOrder)) {
-			return -1;
+	cache: {
+		get MemoryCachePlugin() {
+			return __webpack_require__(52539);
 		}
-		if (aOrder !== bOrder) {
-			return aOrder < bOrder ? -1 : 1;
+	},
+
+	config: {
+		get getNormalizedWebpackOptions() {
+			return (__webpack_require__(26693).getNormalizedWebpackOptions);
+		},
+		get applyWebpackOptionsDefaults() {
+			return (__webpack_require__(92988).applyWebpackOptionsDefaults);
 		}
-	}
-	return 0;
-};
+	},
 
-const joinIterableWithComma = iterable => {
-	// This is more performant than Array.from().join(", ")
-	// as it doesn't create an array
-	let str = "";
-	let first = true;
-	for (const item of iterable) {
-		if (first) {
-			first = false;
-		} else {
-			str += ", ";
+	dependencies: {
+		get ModuleDependency() {
+			return __webpack_require__(80321);
+		},
+		get ConstDependency() {
+			return __webpack_require__(76911);
+		},
+		get NullDependency() {
+			return __webpack_require__(31830);
 		}
-		str += item;
-	}
-	return str;
-};
+	},
 
-/**
- * @typedef {Object} ConcatenationEntry
- * @property {"concatenated" | "external"} type
- * @property {Module} module
- * @property {RuntimeSpec | boolean} runtimeCondition
- */
+	ids: {
+		get ChunkModuleIdRangePlugin() {
+			return __webpack_require__(64618);
+		},
+		get NaturalModuleIdsPlugin() {
+			return __webpack_require__(83366);
+		},
+		get OccurrenceModuleIdsPlugin() {
+			return __webpack_require__(35371);
+		},
+		get NamedModuleIdsPlugin() {
+			return __webpack_require__(24339);
+		},
+		get DeterministicChunkIdsPlugin() {
+			return __webpack_require__(8747);
+		},
+		get DeterministicModuleIdsPlugin() {
+			return __webpack_require__(76692);
+		},
+		get NamedChunkIdsPlugin() {
+			return __webpack_require__(6454);
+		},
+		get OccurrenceChunkIdsPlugin() {
+			return __webpack_require__(51020);
+		},
+		get HashedModuleIdsPlugin() {
+			return __webpack_require__(21825);
+		}
+	},
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {ModuleInfo} info module info
- * @param {string[]} exportName exportName
- * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
- * @param {RuntimeSpec} runtime for which runtime
- * @param {RequestShortener} requestShortener the request shortener
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
- * @param {boolean} asCall asCall
- * @param {boolean} strictHarmonyModule strictHarmonyModule
- * @param {boolean | undefined} asiSafe asiSafe
- * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
- * @returns {Binding} the final variable
- */
-const getFinalBinding = (
-	moduleGraph,
-	info,
-	exportName,
-	moduleToInfoMap,
-	runtime,
-	requestShortener,
-	runtimeTemplate,
-	neededNamespaceObjects,
-	asCall,
-	strictHarmonyModule,
-	asiSafe,
-	alreadyVisited = new Set()
-) => {
-	const exportsType = info.module.getExportsType(
-		moduleGraph,
-		strictHarmonyModule
-	);
-	if (exportName.length === 0) {
-		switch (exportsType) {
-			case "default-only":
-				info.interopNamespaceObject2Used = true;
-				return {
-					info,
-					rawName: info.interopNamespaceObject2Name,
-					ids: exportName,
-					exportName
-				};
-			case "default-with-named":
-				info.interopNamespaceObjectUsed = true;
-				return {
-					info,
-					rawName: info.interopNamespaceObjectName,
-					ids: exportName,
-					exportName
-				};
-			case "namespace":
-			case "dynamic":
-				break;
-			default:
-				throw new Error(`Unexpected exportsType ${exportsType}`);
+	javascript: {
+		get EnableChunkLoadingPlugin() {
+			return __webpack_require__(61291);
+		},
+		get JavascriptModulesPlugin() {
+			return __webpack_require__(89464);
+		},
+		get JavascriptParser() {
+			return __webpack_require__(29050);
 		}
-	} else {
-		switch (exportsType) {
-			case "namespace":
-				break;
-			case "default-with-named":
-				switch (exportName[0]) {
-					case "default":
-						exportName = exportName.slice(1);
-						break;
-					case "__esModule":
-						return {
-							info,
-							rawName: "/* __esModule */true",
-							ids: exportName.slice(1),
-							exportName
-						};
-				}
-				break;
-			case "default-only": {
-				const exportId = exportName[0];
-				if (exportId === "__esModule") {
-					return {
-						info,
-						rawName: "/* __esModule */true",
-						ids: exportName.slice(1),
-						exportName
-					};
-				}
-				exportName = exportName.slice(1);
-				if (exportId !== "default") {
-					return {
-						info,
-						rawName:
-							"/* non-default import from default-exporting module */undefined",
-						ids: exportName,
-						exportName
-					};
-				}
-				break;
-			}
-			case "dynamic":
-				switch (exportName[0]) {
-					case "default": {
-						exportName = exportName.slice(1);
-						info.interopDefaultAccessUsed = true;
-						const defaultExport = asCall
-							? `${info.interopDefaultAccessName}()`
-							: asiSafe
-							? `(${info.interopDefaultAccessName}())`
-							: asiSafe === false
-							? `;(${info.interopDefaultAccessName}())`
-							: `${info.interopDefaultAccessName}.a`;
-						return {
-							info,
-							rawName: defaultExport,
-							ids: exportName,
-							exportName
-						};
-					}
-					case "__esModule":
-						return {
-							info,
-							rawName: "/* __esModule */true",
-							ids: exportName.slice(1),
-							exportName
-						};
-				}
-				break;
-			default:
-				throw new Error(`Unexpected exportsType ${exportsType}`);
+	},
+
+	optimize: {
+		get AggressiveMergingPlugin() {
+			return __webpack_require__(64395);
+		},
+		get AggressiveSplittingPlugin() {
+			return util.deprecate(
+				() => __webpack_require__(15543),
+				"AggressiveSplittingPlugin is deprecated in favor of SplitChunksPlugin",
+				"DEP_WEBPACK_AGGRESSIVE_SPLITTING_PLUGIN"
+			)();
+		},
+		get InnerGraph() {
+			return __webpack_require__(38988);
+		},
+		get LimitChunkCountPlugin() {
+			return __webpack_require__(83608);
+		},
+		get MinChunkSizePlugin() {
+			return __webpack_require__(53912);
+		},
+		get ModuleConcatenationPlugin() {
+			return __webpack_require__(74844);
+		},
+		get RealContentHashPlugin() {
+			return __webpack_require__(46043);
+		},
+		get RuntimeChunkPlugin() {
+			return __webpack_require__(2837);
+		},
+		get SideEffectsFlagPlugin() {
+			return __webpack_require__(84800);
+		},
+		get SplitChunksPlugin() {
+			return __webpack_require__(21478);
 		}
-	}
-	if (exportName.length === 0) {
-		switch (info.type) {
-			case "concatenated":
-				neededNamespaceObjects.add(info);
-				return {
-					info,
-					rawName: info.namespaceObjectName,
-					ids: exportName,
-					exportName
-				};
-			case "external":
-				return { info, rawName: info.name, ids: exportName, exportName };
+	},
+
+	runtime: {
+		get GetChunkFilenameRuntimeModule() {
+			return __webpack_require__(34277);
+		},
+		get LoadScriptRuntimeModule() {
+			return __webpack_require__(19942);
 		}
-	}
-	const exportsInfo = moduleGraph.getExportsInfo(info.module);
-	const exportInfo = exportsInfo.getExportInfo(exportName[0]);
-	if (alreadyVisited.has(exportInfo)) {
-		return {
-			info,
-			rawName: "/* circular reexport */ Object(function x() { x() }())",
-			ids: [],
-			exportName
-		};
-	}
-	alreadyVisited.add(exportInfo);
-	switch (info.type) {
-		case "concatenated": {
-			const exportId = exportName[0];
-			if (exportInfo.provided === false) {
-				// It's not provided, but it could be on the prototype
-				neededNamespaceObjects.add(info);
-				return {
-					info,
-					rawName: info.namespaceObjectName,
-					ids: exportName,
-					exportName
-				};
-			}
-			const directExport = info.exportMap && info.exportMap.get(exportId);
-			if (directExport) {
-				const usedName = /** @type {string[]} */ (
-					exportsInfo.getUsedName(exportName, runtime)
-				);
-				if (!usedName) {
-					return {
-						info,
-						rawName: "/* unused export */ undefined",
-						ids: exportName.slice(1),
-						exportName
-					};
-				}
-				return {
-					info,
-					name: directExport,
-					ids: usedName.slice(1),
-					exportName
-				};
-			}
-			const rawExport = info.rawExportMap && info.rawExportMap.get(exportId);
-			if (rawExport) {
-				return {
-					info,
-					rawName: rawExport,
-					ids: exportName.slice(1),
-					exportName
-				};
-			}
-			const reexport = exportInfo.findTarget(moduleGraph, module =>
-				moduleToInfoMap.has(module)
-			);
-			if (reexport === false) {
-				throw new Error(
-					`Target module of reexport from '${info.module.readableIdentifier(
-						requestShortener
-					)}' is not part of the concatenation (export '${exportId}')\nModules in the concatenation:\n${Array.from(
-						moduleToInfoMap,
-						([m, info]) =>
-							` * ${info.type} ${m.readableIdentifier(requestShortener)}`
-					).join("\n")}`
-				);
-			}
-			if (reexport) {
-				const refInfo = moduleToInfoMap.get(reexport.module);
-				return getFinalBinding(
-					moduleGraph,
-					refInfo,
-					reexport.export
-						? [...reexport.export, ...exportName.slice(1)]
-						: exportName.slice(1),
-					moduleToInfoMap,
-					runtime,
-					requestShortener,
-					runtimeTemplate,
-					neededNamespaceObjects,
-					asCall,
-					info.module.buildMeta.strictHarmonyModule,
-					asiSafe,
-					alreadyVisited
-				);
-			}
-			if (info.namespaceExportSymbol) {
-				const usedName = /** @type {string[]} */ (
-					exportsInfo.getUsedName(exportName, runtime)
-				);
-				return {
-					info,
-					rawName: info.namespaceObjectName,
-					ids: usedName,
-					exportName
-				};
-			}
-			throw new Error(
-				`Cannot get final name for export '${exportName.join(
-					"."
-				)}' of ${info.module.readableIdentifier(requestShortener)}`
-			);
+	},
+
+	prefetch: {
+		get ChunkPrefetchPreloadPlugin() {
+			return __webpack_require__(33895);
 		}
+	},
 
-		case "external": {
-			const used = /** @type {string[]} */ (
-				exportsInfo.getUsedName(exportName, runtime)
-			);
-			if (!used) {
-				return {
-					info,
-					rawName: "/* unused export */ undefined",
-					ids: exportName.slice(1),
-					exportName
-				};
-			}
-			const comment = equals(used, exportName)
-				? ""
-				: Template.toNormalComment(`${exportName.join(".")}`);
-			return { info, rawName: info.name + comment, ids: used, exportName };
+	web: {
+		get FetchCompileAsyncWasmPlugin() {
+			return __webpack_require__(8437);
+		},
+		get FetchCompileWasmPlugin() {
+			return __webpack_require__(35537);
+		},
+		get JsonpChunkLoadingRuntimeModule() {
+			return __webpack_require__(84154);
+		},
+		get JsonpTemplatePlugin() {
+			return __webpack_require__(4607);
+		}
+	},
+
+	webworker: {
+		get WebWorkerTemplatePlugin() {
+			return __webpack_require__(68693);
 		}
-	}
-};
+	},
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {ModuleInfo} info module info
- * @param {string[]} exportName exportName
- * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
- * @param {RuntimeSpec} runtime for which runtime
- * @param {RequestShortener} requestShortener the request shortener
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
- * @param {boolean} asCall asCall
- * @param {boolean} callContext callContext
- * @param {boolean} strictHarmonyModule strictHarmonyModule
- * @param {boolean | undefined} asiSafe asiSafe
- * @returns {string} the final name
- */
-const getFinalName = (
-	moduleGraph,
-	info,
-	exportName,
-	moduleToInfoMap,
-	runtime,
-	requestShortener,
-	runtimeTemplate,
-	neededNamespaceObjects,
-	asCall,
-	callContext,
-	strictHarmonyModule,
-	asiSafe
-) => {
-	const binding = getFinalBinding(
-		moduleGraph,
-		info,
-		exportName,
-		moduleToInfoMap,
-		runtime,
-		requestShortener,
-		runtimeTemplate,
-		neededNamespaceObjects,
-		asCall,
-		strictHarmonyModule,
-		asiSafe
-	);
-	{
-		const { ids, comment } = binding;
-		let reference;
-		let isPropertyAccess;
-		if ("rawName" in binding) {
-			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
-			isPropertyAccess = ids.length > 0;
-		} else {
-			const { info, name: exportId } = binding;
-			const name = info.internalNames.get(exportId);
-			if (!name) {
-				throw new Error(
-					`The export "${exportId}" in "${info.module.readableIdentifier(
-						requestShortener
-					)}" has no internal name (existing names: ${
-						Array.from(
-							info.internalNames,
-							([name, symbol]) => `${name}: ${symbol}`
-						).join(", ") || "none"
-					})`
-				);
-			}
-			reference = `${name}${comment || ""}${propertyAccess(ids)}`;
-			isPropertyAccess = ids.length > 1;
+	node: {
+		get NodeEnvironmentPlugin() {
+			return __webpack_require__(7553);
+		},
+		get NodeSourcePlugin() {
+			return __webpack_require__(7103);
+		},
+		get NodeTargetPlugin() {
+			return __webpack_require__(17916);
+		},
+		get NodeTemplatePlugin() {
+			return __webpack_require__(61052);
+		},
+		get ReadFileCompileWasmPlugin() {
+			return __webpack_require__(98939);
 		}
-		if (isPropertyAccess && asCall && callContext === false) {
-			return asiSafe
-				? `(0,${reference})`
-				: asiSafe === false
-				? `;(0,${reference})`
-				: `/*#__PURE__*/Object(${reference})`;
+	},
+
+	electron: {
+		get ElectronTargetPlugin() {
+			return __webpack_require__(32277);
 		}
-		return reference;
-	}
-};
+	},
 
-const addScopeSymbols = (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);
+	wasm: {
+		get AsyncWebAssemblyModulesPlugin() {
+			return __webpack_require__(7538);
 		}
-		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;
-			}
+	library: {
+		get AbstractLibraryPlugin() {
+			return __webpack_require__(26030);
+		},
+		get EnableLibraryPlugin() {
+			return __webpack_require__(91452);
 		}
-	}
-	return set;
-};
+	},
 
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
+	container: {
+		get ContainerPlugin() {
+			return __webpack_require__(9244);
+		},
+		get ContainerReferencePlugin() {
+			return __webpack_require__(95757);
+		},
+		get ModuleFederationPlugin() {
+			return __webpack_require__(30569);
+		},
+		get scope() {
+			return (__webpack_require__(3083).scope);
+		}
+	},
 
-	const nr = node.range;
+	sharing: {
+		get ConsumeSharedPlugin() {
+			return __webpack_require__(15046);
+		},
+		get ProvideSharedPlugin() {
+			return __webpack_require__(31225);
+		},
+		get SharePlugin() {
+			return __webpack_require__(26335);
+		},
+		get scope() {
+			return (__webpack_require__(3083).scope);
+		}
+	},
 
-	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;
-				}
-			}
+	debug: {
+		get ProfilingPlugin() {
+			return __webpack_require__(2757);
 		}
-		return undefined;
-	};
+	},
 
-	if (Array.isArray(ast)) {
-		for (let i = 0; i < ast.length; i++) {
-			const enterResult = enterNode(ast[i]);
-			if (enterResult !== undefined) return enterResult;
+	util: {
+		get createHash() {
+			return __webpack_require__(49835);
+		},
+		get comparators() {
+			return __webpack_require__(29579);
+		},
+		get runtime() {
+			return __webpack_require__(17156);
+		},
+		get serialization() {
+			return __webpack_require__(8282);
+		},
+		get cleverMerge() {
+			return (__webpack_require__(60839).cachedCleverMerge);
+		},
+		get LazySet() {
+			return __webpack_require__(38938);
 		}
-	} else if (ast && typeof ast === "object") {
-		const keys = Object.keys(ast);
-		for (let 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;
+	},
+
+	get sources() {
+		return __webpack_require__(51255);
+	},
+
+	experiments: {
+		schemes: {
+			get HttpUriPlugin() {
+				return __webpack_require__(42110);
+			}
+		},
+		ids: {
+			get SyncModuleIdsPlugin() {
+				return __webpack_require__(8635);
 			}
 		}
 	}
-};
+});
 
-const TYPES = new Set(["javascript"]);
 
-class ConcatenatedModule extends Module {
+/***/ }),
+
+/***/ 18535:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { ConcatSource, PrefixSource, RawSource } = __webpack_require__(51255);
+const { RuntimeGlobals } = __webpack_require__(91919);
+const HotUpdateChunk = __webpack_require__(9597);
+const Template = __webpack_require__(39722);
+const { getCompilationHooks } = __webpack_require__(89464);
+const {
+	generateEntryStartup,
+	updateHashForEntryStartup
+} = __webpack_require__(98124);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ArrayPushCallbackChunkFormatPlugin {
 	/**
-	 * @param {Module} rootModule the root module of the concatenation
-	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @param {string | HashConstructor=} hashFunction hash function to use
-	 * @returns {ConcatenatedModule} the module
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static create(
-		rootModule,
-		modules,
-		runtime,
-		associatedObjectForCache,
-		hashFunction = "md4"
-	) {
-		const identifier = ConcatenatedModule._createIdentifier(
-			rootModule,
-			modules,
-			associatedObjectForCache,
-			hashFunction
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ArrayPushCallbackChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ArrayPushCallbackChunkFormatPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (chunk.hasRuntime()) return;
+						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.require);
+						}
+						set.add(RuntimeGlobals.chunkCallback);
+					}
+				);
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"ArrayPushCallbackChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
+						const globalObject = runtimeTemplate.globalObject;
+						const source = new ConcatSource();
+						const runtimeModules =
+							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+						if (hotUpdateChunk) {
+							const hotUpdateGlobal =
+								runtimeTemplate.outputOptions.hotUpdateGlobal;
+							source.add(
+								`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`
+							);
+							source.add(`${JSON.stringify(chunk.id)},`);
+							source.add(modules);
+							if (runtimeModules.length > 0) {
+								source.add(",\n");
+								const runtimePart = Template.renderChunkRuntimeModules(
+									runtimeModules,
+									renderContext
+								);
+								source.add(runtimePart);
+							}
+							source.add(")");
+						} else {
+							const chunkLoadingGlobal =
+								runtimeTemplate.outputOptions.chunkLoadingGlobal;
+							source.add(
+								`(${globalObject}[${JSON.stringify(
+									chunkLoadingGlobal
+								)}] = ${globalObject}[${JSON.stringify(
+									chunkLoadingGlobal
+								)}] || []).push([`
+							);
+							source.add(`${JSON.stringify(chunk.ids)},`);
+							source.add(modules);
+							const entries = Array.from(
+								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+							);
+							if (runtimeModules.length > 0 || entries.length > 0) {
+								const runtime = new ConcatSource(
+									(runtimeTemplate.supportsArrowFunction()
+										? "__webpack_require__ =>"
+										: "function(__webpack_require__)") +
+										" { // webpackRuntimeModules\n"
+								);
+								if (runtimeModules.length > 0) {
+									runtime.add(
+										Template.renderRuntimeModules(runtimeModules, {
+											...renderContext,
+											codeGenerationResults: compilation.codeGenerationResults
+										})
+									);
+								}
+								if (entries.length > 0) {
+									const startupSource = new RawSource(
+										generateEntryStartup(
+											chunkGraph,
+											runtimeTemplate,
+											entries,
+											chunk,
+											true
+										)
+									);
+									runtime.add(
+										hooks.renderStartup.call(
+											startupSource,
+											entries[entries.length - 1][0],
+											{
+												...renderContext,
+												inlined: false
+											}
+										)
+									);
+									if (
+										chunkGraph
+											.getChunkRuntimeRequirements(chunk)
+											.has(RuntimeGlobals.returnExportsFromRuntime)
+									) {
+										runtime.add("return __webpack_exports__;\n");
+									}
+								}
+								runtime.add("}\n");
+								source.add(",\n");
+								source.add(new PrefixSource("/******/ ", runtime));
+							}
+							source.add("])");
+						}
+						return source;
+					}
+				);
+				hooks.chunkHash.tap(
+					"ArrayPushCallbackChunkFormatPlugin",
+					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update(
+							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
+						);
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
+			}
 		);
-		return new ConcatenatedModule({
-			identifier,
-			rootModule,
-			modules,
-			runtime
-		});
+	}
+}
+
+module.exports = ArrayPushCallbackChunkFormatPlugin;
+
+
+/***/ }),
+
+/***/ 950:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
+
+const TypeUnknown = 0;
+const TypeUndefined = 1;
+const TypeNull = 2;
+const TypeString = 3;
+const TypeNumber = 4;
+const TypeBoolean = 5;
+const TypeRegExp = 6;
+const TypeConditional = 7;
+const TypeArray = 8;
+const TypeConstArray = 9;
+const TypeIdentifier = 10;
+const TypeWrapped = 11;
+const TypeTemplateString = 12;
+const TypeBigInt = 13;
+
+class BasicEvaluatedExpression {
+	constructor() {
+		this.type = TypeUnknown;
+		/** @type {[number, number]} */
+		this.range = undefined;
+		/** @type {boolean} */
+		this.falsy = false;
+		/** @type {boolean} */
+		this.truthy = false;
+		/** @type {boolean | undefined} */
+		this.nullish = undefined;
+		/** @type {boolean} */
+		this.sideEffects = true;
+		/** @type {boolean | undefined} */
+		this.bool = undefined;
+		/** @type {number | undefined} */
+		this.number = undefined;
+		/** @type {bigint | undefined} */
+		this.bigint = undefined;
+		/** @type {RegExp | undefined} */
+		this.regExp = undefined;
+		/** @type {string | undefined} */
+		this.string = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.quasis = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.parts = undefined;
+		/** @type {any[] | undefined} */
+		this.array = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.items = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.options = undefined;
+		/** @type {BasicEvaluatedExpression | undefined} */
+		this.prefix = undefined;
+		/** @type {BasicEvaluatedExpression | undefined} */
+		this.postfix = undefined;
+		this.wrappedInnerExpressions = undefined;
+		/** @type {string | undefined} */
+		this.identifier = undefined;
+		/** @type {VariableInfoInterface} */
+		this.rootInfo = undefined;
+		/** @type {() => string[]} */
+		this.getMembers = undefined;
+		/** @type {EsTreeNode} */
+		this.expression = undefined;
+	}
+
+	isUnknown() {
+		return this.type === TypeUnknown;
+	}
+
+	isNull() {
+		return this.type === TypeNull;
+	}
+
+	isUndefined() {
+		return this.type === TypeUndefined;
+	}
+
+	isString() {
+		return this.type === TypeString;
 	}
 
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.identifier the identifier of the module
-	 * @param {Module=} options.rootModule the root module of the concatenation
-	 * @param {RuntimeSpec} options.runtime the selected runtime
-	 * @param {Set<Module>=} options.modules all concatenated modules
-	 */
-	constructor({ identifier, rootModule, modules, runtime }) {
-		super("javascript/esm", null, rootModule && rootModule.layer);
+	isNumber() {
+		return this.type === TypeNumber;
+	}
 
-		// Info from Factory
-		/** @type {string} */
-		this._identifier = identifier;
-		/** @type {Module} */
-		this.rootModule = rootModule;
-		/** @type {Set<Module>} */
-		this._modules = modules;
-		this._runtime = runtime;
-		this.factoryMeta = rootModule && rootModule.factoryMeta;
+	isBigInt() {
+		return this.type === TypeBigInt;
 	}
 
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		throw new Error("Must not be called");
+	isBoolean() {
+		return this.type === TypeBoolean;
 	}
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
+	isRegExp() {
+		return this.type === TypeRegExp;
 	}
 
-	get modules() {
-		return Array.from(this._modules);
+	isConditional() {
+		return this.type === TypeConditional;
 	}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return this._identifier;
+	isArray() {
+		return this.type === TypeArray;
 	}
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return (
-			this.rootModule.readableIdentifier(requestShortener) +
-			` + ${this._modules.size - 1} modules`
-		);
+	isConstArray() {
+		return this.type === TypeConstArray;
+	}
+
+	isIdentifier() {
+		return this.type === TypeIdentifier;
+	}
+
+	isWrapped() {
+		return this.type === TypeWrapped;
+	}
+
+	isTemplateString() {
+		return this.type === TypeTemplateString;
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * Is expression a primitive or an object type value?
+	 * @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
 	 */
-	libIdent(options) {
-		return this.rootModule.libIdent(options);
+	isPrimitiveType() {
+		switch (this.type) {
+			case TypeUndefined:
+			case TypeNull:
+			case TypeString:
+			case TypeNumber:
+			case TypeBoolean:
+			case TypeBigInt:
+			case TypeWrapped:
+			case TypeTemplateString:
+				return true;
+			case TypeRegExp:
+			case TypeArray:
+			case TypeConstArray:
+				return false;
+			default:
+				return undefined;
+		}
 	}
 
 	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 * Is expression a runtime or compile-time value?
+	 * @returns {boolean} true: compile time value, false: runtime value
 	 */
-	nameForCondition() {
-		return this.rootModule.nameForCondition();
+	isCompileTimeValue() {
+		switch (this.type) {
+			case TypeUndefined:
+			case TypeNull:
+			case TypeString:
+			case TypeNumber:
+			case TypeBoolean:
+			case TypeRegExp:
+			case TypeConstArray:
+			case TypeBigInt:
+				return true;
+			default:
+				return false;
+		}
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 * Gets the compile-time value of the expression
+	 * @returns {any} the javascript value
 	 */
-	getSideEffectsConnectionState(moduleGraph) {
-		return this.rootModule.getSideEffectsConnectionState(moduleGraph);
+	asCompileTimeValue() {
+		switch (this.type) {
+			case TypeUndefined:
+				return undefined;
+			case TypeNull:
+				return null;
+			case TypeString:
+				return this.string;
+			case TypeNumber:
+				return this.number;
+			case TypeBoolean:
+				return this.bool;
+			case TypeRegExp:
+				return this.regExp;
+			case TypeConstArray:
+				return this.array;
+			case TypeBigInt:
+				return this.bigint;
+			default:
+				throw new Error(
+					"asCompileTimeValue must only be called for compile-time values"
+				);
+		}
+	}
+
+	isTruthy() {
+		return this.truthy;
+	}
+
+	isFalsy() {
+		return this.falsy;
+	}
+
+	isNullish() {
+		return this.nullish;
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * Can this expression have side effects?
+	 * @returns {boolean} false: never has side effects
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		const { rootModule } = this;
-		this.buildInfo = {
-			strict: true,
-			cacheable: true,
-			moduleArgument: rootModule.buildInfo.moduleArgument,
-			exportsArgument: rootModule.buildInfo.exportsArgument,
-			fileDependencies: new LazySet(),
-			contextDependencies: new LazySet(),
-			missingDependencies: new LazySet(),
-			topLevelDeclarations: new Set(),
-			assets: undefined
-		};
-		this.buildMeta = rootModule.buildMeta;
-		this.clearDependenciesAndBlocks();
-		this.clearWarningsAndErrors();
+	couldHaveSideEffects() {
+		return this.sideEffects;
+	}
 
-		for (const m of this._modules) {
-			// populate cacheable
-			if (!m.buildInfo.cacheable) {
-				this.buildInfo.cacheable = false;
-			}
+	asBool() {
+		if (this.truthy) return true;
+		if (this.falsy || this.nullish) return false;
+		if (this.isBoolean()) return this.bool;
+		if (this.isNull()) return false;
+		if (this.isUndefined()) return false;
+		if (this.isString()) return this.string !== "";
+		if (this.isNumber()) return this.number !== 0;
+		if (this.isBigInt()) return this.bigint !== BigInt(0);
+		if (this.isRegExp()) return true;
+		if (this.isArray()) return true;
+		if (this.isConstArray()) return true;
+		if (this.isWrapped()) {
+			return (this.prefix && this.prefix.asBool()) ||
+				(this.postfix && this.postfix.asBool())
+				? true
+				: undefined;
+		}
+		if (this.isTemplateString()) {
+			const str = this.asString();
+			if (typeof str === "string") return str !== "";
+		}
+		return undefined;
+	}
 
-			// populate dependencies
-			for (const d of m.dependencies.filter(
-				dep =>
-					!(dep instanceof HarmonyImportDependency) ||
-					!this._modules.has(compilation.moduleGraph.getModule(dep))
-			)) {
-				this.dependencies.push(d);
-			}
-			// populate blocks
-			for (const d of m.blocks) {
-				this.blocks.push(d);
-			}
+	asNullish() {
+		const nullish = this.isNullish();
 
-			// populate warnings
-			const warnings = m.getWarnings();
-			if (warnings !== undefined) {
-				for (const warning of warnings) {
-					this.addWarning(warning);
-				}
-			}
+		if (nullish === true || this.isNull() || this.isUndefined()) return true;
 
-			// populate errors
-			const errors = m.getErrors();
-			if (errors !== undefined) {
-				for (const error of errors) {
-					this.addError(error);
-				}
-			}
+		if (nullish === false) return false;
+		if (this.isTruthy()) return false;
+		if (this.isBoolean()) return false;
+		if (this.isString()) return false;
+		if (this.isNumber()) return false;
+		if (this.isBigInt()) return false;
+		if (this.isRegExp()) return false;
+		if (this.isArray()) return false;
+		if (this.isConstArray()) return false;
+		if (this.isTemplateString()) return false;
+		if (this.isRegExp()) return false;
 
-			// populate topLevelDeclarations
-			if (m.buildInfo.topLevelDeclarations) {
-				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
-				if (topLevelDeclarations !== undefined) {
-					for (const decl of m.buildInfo.topLevelDeclarations) {
-						// reserved names will always be renamed
-						if (RESERVED_NAMES.has(decl)) continue;
-						// TODO actually this is incorrect since with renaming there could be more
-						// We should do the renaming during build
-						topLevelDeclarations.add(decl);
-					}
-				}
-			} else {
-				this.buildInfo.topLevelDeclarations = undefined;
-			}
+		return undefined;
+	}
 
-			// populate assets
-			if (m.buildInfo.assets) {
-				if (this.buildInfo.assets === undefined) {
-					this.buildInfo.assets = Object.create(null);
-				}
-				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
+	asString() {
+		if (this.isBoolean()) return `${this.bool}`;
+		if (this.isNull()) return "null";
+		if (this.isUndefined()) return "undefined";
+		if (this.isString()) return this.string;
+		if (this.isNumber()) return `${this.number}`;
+		if (this.isBigInt()) return `${this.bigint}`;
+		if (this.isRegExp()) return `${this.regExp}`;
+		if (this.isArray()) {
+			let array = [];
+			for (const item of this.items) {
+				const itemStr = item.asString();
+				if (itemStr === undefined) return undefined;
+				array.push(itemStr);
 			}
-			if (m.buildInfo.assetsInfo) {
-				if (this.buildInfo.assetsInfo === undefined) {
-					this.buildInfo.assetsInfo = new Map();
-				}
-				for (const [key, value] of m.buildInfo.assetsInfo) {
-					this.buildInfo.assetsInfo.set(key, value);
-				}
+			return `${array}`;
+		}
+		if (this.isConstArray()) return `${this.array}`;
+		if (this.isTemplateString()) {
+			let str = "";
+			for (const part of this.parts) {
+				const partStr = part.asString();
+				if (partStr === undefined) return undefined;
+				str += partStr;
 			}
+			return str;
 		}
-		callback();
+		return undefined;
 	}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		// Guess size from embedded modules
-		let size = 0;
-		for (const module of this._modules) {
-			size += module.size(type);
-		}
-		return size;
+	setString(string) {
+		this.type = TypeString;
+		this.string = string;
+		this.sideEffects = false;
+		return this;
 	}
 
-	/**
-	 * @private
-	 * @param {Module} rootModule the root of the concatenation
-	 * @param {Set<Module>} modulesSet a set of modules which should be concatenated
-	 * @param {RuntimeSpec} runtime for this runtime
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConcatenationEntry[]} concatenation list
-	 */
-	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
-		/** @type {ConcatenationEntry[]} */
-		const list = [];
-		/** @type {Map<Module, RuntimeSpec | true>} */
-		const existingEntries = new Map();
+	setUndefined() {
+		this.type = TypeUndefined;
+		this.sideEffects = false;
+		return this;
+	}
 
-		/**
-		 * @param {Module} module a module
-		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
-		 */
-		const getConcatenatedImports = module => {
-			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
-			if (module === rootModule) {
-				for (const c of moduleGraph.getOutgoingConnections(this))
-					connections.push(c);
-			}
-			const references = connections
-				.filter(connection => {
-					if (!(connection.dependency instanceof HarmonyImportDependency))
-						return false;
-					return (
-						connection &&
-						connection.resolvedOriginModule === module &&
-						connection.module &&
-						connection.isTargetActive(runtime)
-					);
-				})
-				.map(connection => ({
-					connection,
-					sourceOrder: /** @type {HarmonyImportDependency} */ (
-						connection.dependency
-					).sourceOrder
-				}));
-			references.sort(
-				concatComparators(bySourceOrder, keepOriginalOrder(references))
-			);
-			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
-			const referencesMap = new Map();
-			for (const { connection } of references) {
-				const runtimeCondition = filterRuntime(runtime, r =>
-					connection.isTargetActive(r)
-				);
-				if (runtimeCondition === false) continue;
-				const module = connection.module;
-				const entry = referencesMap.get(module);
-				if (entry === undefined) {
-					referencesMap.set(module, { connection, runtimeCondition });
-					continue;
-				}
-				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
-					entry.runtimeCondition,
-					runtimeCondition,
-					runtime
-				);
-			}
-			return referencesMap.values();
-		};
+	setNull() {
+		this.type = TypeNull;
+		this.sideEffects = false;
+		return this;
+	}
 
-		/**
-		 * @param {ModuleGraphConnection} connection graph connection
-		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
-		 * @returns {void}
-		 */
-		const enterModule = (connection, runtimeCondition) => {
-			const module = connection.module;
-			if (!module) return;
-			const existingEntry = existingEntries.get(module);
-			if (existingEntry === true) {
-				return;
-			}
-			if (modulesSet.has(module)) {
-				existingEntries.set(module, true);
-				if (runtimeCondition !== true) {
-					throw new Error(
-						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
-							runtimeCondition
-						)}). This should not happen.`
-					);
-				}
-				const imports = getConcatenatedImports(module);
-				for (const { connection, runtimeCondition } of imports)
-					enterModule(connection, runtimeCondition);
-				list.push({
-					type: "concatenated",
-					module: connection.module,
-					runtimeCondition
-				});
-			} else {
-				if (existingEntry !== undefined) {
-					const reducedRuntimeCondition = subtractRuntimeCondition(
-						runtimeCondition,
-						existingEntry,
-						runtime
-					);
-					if (reducedRuntimeCondition === false) return;
-					runtimeCondition = reducedRuntimeCondition;
-					existingEntries.set(
-						connection.module,
-						mergeRuntimeConditionNonFalse(
-							existingEntry,
-							runtimeCondition,
-							runtime
-						)
-					);
-				} else {
-					existingEntries.set(connection.module, runtimeCondition);
-				}
-				if (list.length > 0) {
-					const lastItem = list[list.length - 1];
-					if (
-						lastItem.type === "external" &&
-						lastItem.module === connection.module
-					) {
-						lastItem.runtimeCondition = mergeRuntimeCondition(
-							lastItem.runtimeCondition,
-							runtimeCondition,
-							runtime
-						);
-						return;
-					}
-				}
-				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 connection.module;
-					},
-					runtimeCondition
-				});
-			}
-		};
+	setNumber(number) {
+		this.type = TypeNumber;
+		this.number = number;
+		this.sideEffects = false;
+		return this;
+	}
 
-		existingEntries.set(rootModule, true);
-		const imports = getConcatenatedImports(rootModule);
-		for (const { connection, runtimeCondition } of imports)
-			enterModule(connection, runtimeCondition);
-		list.push({
-			type: "concatenated",
-			module: rootModule,
-			runtimeCondition: true
-		});
+	setBigInt(bigint) {
+		this.type = TypeBigInt;
+		this.bigint = bigint;
+		this.sideEffects = false;
+		return this;
+	}
 
-		return list;
+	setBoolean(bool) {
+		this.type = TypeBoolean;
+		this.bool = bool;
+		this.sideEffects = false;
+		return this;
+	}
+
+	setRegExp(regExp) {
+		this.type = TypeRegExp;
+		this.regExp = regExp;
+		this.sideEffects = false;
+		return this;
 	}
 
-	/**
-	 * @param {Module} rootModule the root module of the concatenation
-	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @param {string | HashConstructor=} hashFunction hash function to use
-	 * @returns {string} the identifier
-	 */
-	static _createIdentifier(
-		rootModule,
-		modules,
-		associatedObjectForCache,
-		hashFunction = "md4"
-	) {
-		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			rootModule.context,
-			associatedObjectForCache
-		);
-		let identifiers = [];
-		for (const module of modules) {
-			identifiers.push(cachedMakePathsRelative(module.identifier()));
-		}
-		identifiers.sort();
-		const hash = createHash(hashFunction);
-		hash.update(identifiers.join(" "));
-		return rootModule.identifier() + "|" + hash.digest("hex");
+	setIdentifier(identifier, rootInfo, getMembers) {
+		this.type = TypeIdentifier;
+		this.identifier = identifier;
+		this.rootInfo = rootInfo;
+		this.getMembers = getMembers;
+		this.sideEffects = true;
+		return this;
 	}
 
-	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
-	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {
-		for (const module of this._modules) {
-			module.addCacheDependencies(
-				fileDependencies,
-				contextDependencies,
-				missingDependencies,
-				buildDependencies
-			);
-		}
+	setWrapped(prefix, postfix, innerExpressions) {
+		this.type = TypeWrapped;
+		this.prefix = prefix;
+		this.postfix = postfix;
+		this.wrappedInnerExpressions = innerExpressions;
+		this.sideEffects = true;
+		return this;
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({
-		dependencyTemplates,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime: generationRuntime,
-		codeGenerationResults
-	}) {
-		/** @type {Set<string>} */
-		const runtimeRequirements = new Set();
-		const runtime = intersectRuntime(generationRuntime, this._runtime);
+	setOptions(options) {
+		this.type = TypeConditional;
+		this.options = options;
+		this.sideEffects = true;
+		return this;
+	}
 
-		const requestShortener = runtimeTemplate.requestShortener;
-		// Meta info for each module
-		const [modulesWithInfo, moduleToInfoMap] = this._getModulesWithInfo(
-			moduleGraph,
-			runtime
-		);
+	addOptions(options) {
+		if (!this.options) {
+			this.type = TypeConditional;
+			this.options = [];
+			this.sideEffects = true;
+		}
+		for (const item of options) {
+			this.options.push(item);
+		}
+		return this;
+	}
 
-		// Set with modules that need a generated namespace object
-		/** @type {Set<ConcatenatedModuleInfo>} */
-		const neededNamespaceObjects = new Set();
+	setItems(items) {
+		this.type = TypeArray;
+		this.items = items;
+		this.sideEffects = items.some(i => i.couldHaveSideEffects());
+		return this;
+	}
 
-		// Generate source code and analyse scopes
-		// Prepare a ReplaceSource for the final source
-		for (const info of moduleToInfoMap.values()) {
-			this._analyseModule(
-				moduleToInfoMap,
-				info,
-				dependencyTemplates,
-				runtimeTemplate,
-				moduleGraph,
-				chunkGraph,
-				runtime,
-				codeGenerationResults
-			);
-		}
+	setArray(array) {
+		this.type = TypeConstArray;
+		this.array = array;
+		this.sideEffects = false;
+		return this;
+	}
 
-		// List of all used names to avoid conflicts
-		const allUsedNames = new Set(RESERVED_NAMES);
+	setTemplateString(quasis, parts, kind) {
+		this.type = TypeTemplateString;
+		this.quasis = quasis;
+		this.parts = parts;
+		this.templateStringKind = kind;
+		this.sideEffects = parts.some(p => p.sideEffects);
+		return this;
+	}
 
-		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
-		const usedNamesInScopeInfo = new Map();
-		/**
-		 * @param {string} module module identifier
-		 * @param {string} id export id
-		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
-		 */
-		const getUsedNamesInScopeInfo = (module, id) => {
-			const key = `${module}-${id}`;
-			let info = usedNamesInScopeInfo.get(key);
-			if (info === undefined) {
-				info = {
-					usedNames: new Set(),
-					alreadyCheckedScopes: new Set()
-				};
-				usedNamesInScopeInfo.set(key, info);
-			}
-			return info;
-		};
+	setTruthy() {
+		this.falsy = false;
+		this.truthy = true;
+		this.nullish = false;
+		return this;
+	}
 
-		// Set of already checked scopes
-		const ignoredScopes = new Set();
+	setFalsy() {
+		this.falsy = true;
+		this.truthy = false;
+		return this;
+	}
 
-		// get all global names
-		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
-				// ignore symbols from moduleScope
-				if (info.moduleScope) {
-					ignoredScopes.add(info.moduleScope);
-				}
+	setNullish(value) {
+		this.nullish = value;
 
-				// The super class expression in class scopes behaves weird
-				// We get ranges of all super class expressions to make
-				// renaming to work correctly
-				const superClassCache = new WeakMap();
-				const getSuperClassExpressions = scope => {
-					const cacheEntry = superClassCache.get(scope);
-					if (cacheEntry !== undefined) return cacheEntry;
-					const superClassExpressions = [];
-					for (const childScope of scope.childScopes) {
-						if (childScope.type !== "class") continue;
-						const block = childScope.block;
-						if (
-							(block.type === "ClassDeclaration" ||
-								block.type === "ClassExpression") &&
-							block.superClass
-						) {
-							superClassExpressions.push({
-								range: block.superClass.range,
-								variables: childScope.variables
-							});
-						}
-					}
-					superClassCache.set(scope, superClassExpressions);
-					return superClassExpressions;
-				};
+		if (value) return this.setFalsy();
 
-				// add global symbols
-				if (info.globalScope) {
-					for (const reference of info.globalScope.through) {
-						const name = reference.identifier.name;
-						if (ConcatenationScope.isModuleReference(name)) {
-							const match = ConcatenationScope.matchModuleReference(name);
-							if (!match) continue;
-							const referencedInfo = modulesWithInfo[match.index];
-							if (referencedInfo.type === "reference")
-								throw new Error("Module reference can't point to a reference");
-							const binding = getFinalBinding(
-								moduleGraph,
-								referencedInfo,
-								match.ids,
-								moduleToInfoMap,
-								runtime,
-								requestShortener,
-								runtimeTemplate,
-								neededNamespaceObjects,
-								false,
-								info.module.buildMeta.strictHarmonyModule,
-								true
-							);
-							if (!binding.ids) continue;
-							const { usedNames, alreadyCheckedScopes } =
-								getUsedNamesInScopeInfo(
-									binding.info.module.identifier(),
-									"name" in binding ? binding.name : ""
-								);
-							for (const expr of getSuperClassExpressions(reference.from)) {
-								if (
-									expr.range[0] <= reference.identifier.range[0] &&
-									expr.range[1] >= reference.identifier.range[1]
-								) {
-									for (const variable of expr.variables) {
-										usedNames.add(variable.name);
-									}
-								}
-							}
-							addScopeSymbols(
-								reference.from,
-								usedNames,
-								alreadyCheckedScopes,
-								ignoredScopes
-							);
-						} else {
-							allUsedNames.add(name);
-						}
-					}
-				}
-			}
-		}
+		return this;
+	}
 
-		// generate names for symbols
-		for (const info of moduleToInfoMap.values()) {
-			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
-				info.module.identifier(),
-				""
-			);
-			switch (info.type) {
-				case "concatenated": {
-					for (const variable of info.moduleScope.variables) {
-						const name = variable.name;
-						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
-							info.module.identifier(),
-							name
-						);
-						if (allUsedNames.has(name) || usedNames.has(name)) {
-							const references = getAllReferences(variable);
-							for (const ref of references) {
-								addScopeSymbols(
-									ref.from,
-									usedNames,
-									alreadyCheckedScopes,
-									ignoredScopes
-								);
-							}
-							const newName = this.findNewName(
-								name,
-								allUsedNames,
-								usedNames,
-								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) {
-									const maybeProperty =
-										path[1].type === "AssignmentPattern" &&
-										path[1].left === path[0]
-											? path[2]
-											: path[1];
-									if (
-										maybeProperty.type === "Property" &&
-										maybeProperty.shorthand
-									) {
-										source.insert(r[1], `: ${newName}`);
-										continue;
-									}
-								}
-								source.replace(r[0], r[1] - 1, newName);
-							}
-						} else {
-							allUsedNames.add(name);
-							info.internalNames.set(name, name);
-						}
-					}
-					let namespaceObjectName;
-					if (info.namespaceExportSymbol) {
-						namespaceObjectName = info.internalNames.get(
-							info.namespaceExportSymbol
-						);
-					} else {
-						namespaceObjectName = this.findNewName(
-							"namespaceObject",
-							allUsedNames,
-							namespaceObjectUsedNames,
-							info.module.readableIdentifier(requestShortener)
-						);
-						allUsedNames.add(namespaceObjectName);
-					}
-					info.namespaceObjectName = namespaceObjectName;
-					break;
-				}
-				case "external": {
-					const externalName = this.findNewName(
-						"",
-						allUsedNames,
-						namespaceObjectUsedNames,
-						info.module.readableIdentifier(requestShortener)
-					);
-					allUsedNames.add(externalName);
-					info.name = externalName;
-					break;
-				}
-			}
-			if (info.module.buildMeta.exportsType !== "namespace") {
-				const externalNameInterop = this.findNewName(
-					"namespaceObject",
-					allUsedNames,
-					namespaceObjectUsedNames,
-					info.module.readableIdentifier(requestShortener)
-				);
-				allUsedNames.add(externalNameInterop);
-				info.interopNamespaceObjectName = externalNameInterop;
-			}
-			if (
-				info.module.buildMeta.exportsType === "default" &&
-				info.module.buildMeta.defaultObject !== "redirect"
-			) {
-				const externalNameInterop = this.findNewName(
-					"namespaceObject2",
-					allUsedNames,
-					namespaceObjectUsedNames,
-					info.module.readableIdentifier(requestShortener)
-				);
-				allUsedNames.add(externalNameInterop);
-				info.interopNamespaceObject2Name = externalNameInterop;
-			}
-			if (
-				info.module.buildMeta.exportsType === "dynamic" ||
-				!info.module.buildMeta.exportsType
-			) {
-				const externalNameInterop = this.findNewName(
-					"default",
-					allUsedNames,
-					namespaceObjectUsedNames,
-					info.module.readableIdentifier(requestShortener)
-				);
-				allUsedNames.add(externalNameInterop);
-				info.interopDefaultAccessName = externalNameInterop;
-			}
-		}
+	setRange(range) {
+		this.range = range;
+		return this;
+	}
 
-		// Find and replace references to modules
-		for (const info of moduleToInfoMap.values()) {
-			if (info.type === "concatenated") {
-				for (const reference of info.globalScope.through) {
-					const name = reference.identifier.name;
-					const match = ConcatenationScope.matchModuleReference(name);
-					if (match) {
-						const referencedInfo = modulesWithInfo[match.index];
-						if (referencedInfo.type === "reference")
-							throw new Error("Module reference can't point to a reference");
-						const finalName = getFinalName(
-							moduleGraph,
-							referencedInfo,
-							match.ids,
-							moduleToInfoMap,
-							runtime,
-							requestShortener,
-							runtimeTemplate,
-							neededNamespaceObjects,
-							match.call,
-							!match.directImport,
-							info.module.buildMeta.strictHarmonyModule,
-							match.asiSafe
-						);
-						const r = reference.identifier.range;
-						const source = info.source;
-						// range is extended by 2 chars to cover the appended "._"
-						source.replace(r[0], r[1] + 1, finalName);
-					}
-				}
-			}
-		}
+	setSideEffects(sideEffects = true) {
+		this.sideEffects = sideEffects;
+		return this;
+	}
 
-		// Map with all root exposed used exports
-		/** @type {Map<string, function(RequestShortener): string>} */
-		const exportsMap = new Map();
+	setExpression(expression) {
+		this.expression = expression;
+		return this;
+	}
+}
 
-		// Set with all root exposed unused exports
-		/** @type {Set<string>} */
-		const unusedExports = new Set();
+/**
+ * @param {string} flags regexp flags
+ * @returns {boolean} is valid flags
+ */
+BasicEvaluatedExpression.isValidRegExpFlags = flags => {
+	const len = flags.length;
 
-		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
-			moduleToInfoMap.get(this.rootModule)
-		);
-		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
-		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
-		for (const exportInfo of exportsInfo.orderedExports) {
-			const name = exportInfo.name;
-			if (exportInfo.provided === false) continue;
-			const used = exportInfo.getUsedName(undefined, runtime);
-			if (!used) {
-				unusedExports.add(name);
-				continue;
-			}
-			exportsMap.set(used, requestShortener => {
-				try {
-					const finalName = getFinalName(
-						moduleGraph,
-						rootInfo,
-						[name],
-						moduleToInfoMap,
-						runtime,
-						requestShortener,
-						runtimeTemplate,
-						neededNamespaceObjects,
-						false,
-						false,
-						strictHarmonyModule,
-						true
-					);
-					return `/* ${
-						exportInfo.isReexport() ? "reexport" : "binding"
-					} */ ${finalName}`;
-				} catch (e) {
-					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
-					throw e;
-				}
-			});
-		}
+	if (len === 0) return true;
+	if (len > 4) return false;
 
-		const result = new ConcatSource();
+	// cspell:word gimy
+	let remaining = 0b0000; // bit per RegExp flag: gimy
 
-		// add harmony compatibility flag (must be first because of possible circular dependencies)
-		if (
-			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
-			UsageState.Unused
-		) {
-			result.add(`// ESM COMPAT FLAG\n`);
-			result.add(
-				runtimeTemplate.defineEsModuleFlagStatement({
-					exportsArgument: this.exportsArgument,
-					runtimeRequirements
-				})
-			);
+	for (let i = 0; i < len; i++)
+		switch (flags.charCodeAt(i)) {
+			case 103 /* g */:
+				if (remaining & 0b1000) return false;
+				remaining |= 0b1000;
+				break;
+			case 105 /* i */:
+				if (remaining & 0b0100) return false;
+				remaining |= 0b0100;
+				break;
+			case 109 /* m */:
+				if (remaining & 0b0010) return false;
+				remaining |= 0b0010;
+				break;
+			case 121 /* y */:
+				if (remaining & 0b0001) return false;
+				remaining |= 0b0001;
+				break;
+			default:
+				return false;
 		}
 
-		// define exports
-		if (exportsMap.size > 0) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-			const definitions = [];
-			for (const [key, value] of exportsMap) {
-				definitions.push(
-					`\n  ${JSON.stringify(key)}: ${runtimeTemplate.returningFunction(
-						value(requestShortener)
-					)}`
-				);
-			}
-			result.add(`\n// EXPORTS\n`);
-			result.add(
-				`${RuntimeGlobals.definePropertyGetters}(${
-					this.exportsArgument
-				}, {${definitions.join(",")}\n});\n`
-			);
-		}
+	return true;
+};
 
-		// list unused exports
-		if (unusedExports.size > 0) {
-			result.add(
-				`\n// UNUSED EXPORTS: ${joinIterableWithComma(unusedExports)}\n`
-			);
-		}
+module.exports = BasicEvaluatedExpression;
 
-		// generate namespace objects
-		const namespaceObjectSources = new Map();
-		for (const info of neededNamespaceObjects) {
-			if (info.namespaceExportSymbol) continue;
-			const nsObj = [];
-			const exportsInfo = moduleGraph.getExportsInfo(info.module);
-			for (const exportInfo of exportsInfo.orderedExports) {
-				if (exportInfo.provided === false) continue;
-				const usedName = exportInfo.getUsedName(undefined, runtime);
-				if (usedName) {
-					const finalName = getFinalName(
-						moduleGraph,
-						info,
-						[exportInfo.name],
-						moduleToInfoMap,
-						runtime,
-						requestShortener,
-						runtimeTemplate,
-						neededNamespaceObjects,
-						false,
-						undefined,
-						info.module.buildMeta.strictHarmonyModule,
-						true
-					);
-					nsObj.push(
-						`\n  ${JSON.stringify(
-							usedName
-						)}: ${runtimeTemplate.returningFunction(finalName)}`
-					);
-				}
-			}
-			const name = info.namespaceObjectName;
-			const defineGetters =
-				nsObj.length > 0
-					? `${RuntimeGlobals.definePropertyGetters}(${name}, {${nsObj.join(
-							","
-					  )}\n});\n`
-					: "";
-			if (nsObj.length > 0)
-				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-			namespaceObjectSources.set(
-				info,
-				`
-// NAMESPACE OBJECT: ${info.module.readableIdentifier(requestShortener)}
-var ${name} = {};
-${RuntimeGlobals.makeNamespaceObject}(${name});
-${defineGetters}`
-			);
-			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
-		}
 
-		// define required namespace objects (must be before evaluation modules)
-		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
-				const source = namespaceObjectSources.get(info);
-				if (!source) continue;
-				result.add(source);
-			}
-		}
+/***/ }),
 
-		const chunkInitFragments = [];
+/***/ 91145:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-		// evaluate modules in order
-		for (const rawInfo of modulesWithInfo) {
-			let name;
-			let isConditional = false;
-			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
-			switch (info.type) {
-				case "concatenated": {
-					result.add(
-						`\n;// CONCATENATED MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					result.add(info.source);
-					if (info.chunkInitFragments) {
-						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
-					}
-					if (info.runtimeRequirements) {
-						for (const r of info.runtimeRequirements) {
-							runtimeRequirements.add(r);
-						}
-					}
-					name = info.namespaceObjectName;
-					break;
-				}
-				case "external": {
-					result.add(
-						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					runtimeRequirements.add(RuntimeGlobals.require);
-					const { runtimeCondition } =
-						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
-					const condition = runtimeTemplate.runtimeConditionExpression({
-						chunkGraph,
-						runtimeCondition,
-						runtime,
-						runtimeRequirements
-					});
-					if (condition !== "true") {
-						isConditional = true;
-						result.add(`if (${condition}) {\n`);
-					}
-					result.add(
-						`var ${info.name} = __webpack_require__(${JSON.stringify(
-							chunkGraph.getModuleId(info.module)
-						)});`
-					);
-					name = info.name;
-					break;
-				}
-				default:
-					// @ts-expect-error never is expected here
-					throw new Error(`Unsupported concatenation entry type ${info.type}`);
-			}
-			if (info.interopNamespaceObjectUsed) {
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				result.add(
-					`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
-				);
-			}
-			if (info.interopNamespaceObject2Used) {
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				result.add(
-					`\nvar ${info.interopNamespaceObject2Name} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
-				);
-			}
-			if (info.interopDefaultAccessUsed) {
-				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
-				result.add(
-					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
-				);
-			}
-			if (isConditional) {
-				result.add("\n}");
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const data = new Map();
-		if (chunkInitFragments.length > 0)
-			data.set("chunkInitFragments", chunkInitFragments);
 
-		/** @type {CodeGenerationResult} */
-		const resultEntry = {
-			sources: new Map([["javascript", new CachedSource(result)]]),
-			data,
-			runtimeRequirements
-		};
 
-		return resultEntry;
-	}
+const Entrypoint = __webpack_require__(13795);
 
-	/**
-	 * @param {Map<Module, ModuleInfo>} modulesMap modulesMap
-	 * @param {ModuleInfo} info info
-	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
-	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
-	 * @param {ModuleGraph} moduleGraph moduleGraph
-	 * @param {ChunkGraph} chunkGraph chunkGraph
-	 * @param {RuntimeSpec} runtime runtime
-	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
-	 */
-	_analyseModule(
-		modulesMap,
-		info,
-		dependencyTemplates,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime,
-		codeGenerationResults
-	) {
-		if (info.type === "concatenated") {
-			const m = info.module;
-			try {
-				// Create a concatenation scope to track and capture information
-				const concatenationScope = new ConcatenationScope(modulesMap, info);
+/** @typedef {import("../Chunk")} Chunk */
 
-				// TODO cache codeGeneration results
-				const codeGenResult = m.codeGeneration({
-					dependencyTemplates,
-					runtimeTemplate,
-					moduleGraph,
-					chunkGraph,
-					runtime,
-					concatenationScope,
-					codeGenerationResults
-				});
-				const source = codeGenResult.sources.get("javascript");
-				const data = codeGenResult.data;
-				const chunkInitFragments = data && data.get("chunkInitFragments");
-				const code = source.source().toString();
-				let ast;
-				try {
-					ast = JavascriptParser._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.runtimeRequirements = codeGenResult.runtimeRequirements;
-				info.ast = ast;
-				info.internalSource = source;
-				info.source = resultSource;
-				info.chunkInitFragments = chunkInitFragments;
-				info.globalScope = globalScope;
-				info.moduleScope = moduleScope;
-			} catch (err) {
-				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
-				throw err;
-			}
+/**
+ * @param {Entrypoint} entrypoint a chunk group
+ * @param {Chunk} excludedChunk1 current chunk which is excluded
+ * @param {Chunk} excludedChunk2 runtime chunk which is excluded
+ * @returns {Set<Chunk>} chunks
+ */
+const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
+	const queue = new Set([entrypoint]);
+	const chunks = new Set();
+	for (const entrypoint of queue) {
+		for (const chunk of entrypoint.chunks) {
+			if (chunk === excludedChunk1) continue;
+			if (chunk === excludedChunk2) continue;
+			chunks.add(chunk);
+		}
+		for (const parent of entrypoint.parentsIterable) {
+			if (parent instanceof Entrypoint) queue.add(parent);
 		}
 	}
+	return chunks;
+};
+exports.getAllChunks = getAllChunks;
+
+
+/***/ }),
+
+/***/ 84508:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
 
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const {
+	getChunkFilenameTemplate,
+	getCompilationHooks
+} = __webpack_require__(89464);
+const {
+	generateEntryStartup,
+	updateHashForEntryStartup
+} = __webpack_require__(98124);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class CommonJsChunkFormatPlugin {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {[ModuleInfoOrReference[], Map<Module, ModuleInfo>]} module info items
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	_getModulesWithInfo(moduleGraph, runtime) {
-		const orderedConcatenationList = this._createConcatenationList(
-			this.rootModule,
-			this._modules,
-			runtime,
-			moduleGraph
-		);
-		/** @type {Map<Module, ModuleInfo>} */
-		const map = new Map();
-		const list = orderedConcatenationList.map((info, index) => {
-			let item = map.get(info.module);
-			if (item === undefined) {
-				switch (info.type) {
-					case "concatenated":
-						item = {
-							type: "concatenated",
-							module: info.module,
-							index,
-							ast: undefined,
-							internalSource: undefined,
-							runtimeRequirements: undefined,
-							source: undefined,
-							globalScope: undefined,
-							moduleScope: undefined,
-							internalNames: new Map(),
-							exportMap: undefined,
-							rawExportMap: undefined,
-							namespaceExportSymbol: undefined,
-							namespaceObjectName: undefined,
-							interopNamespaceObjectUsed: false,
-							interopNamespaceObjectName: undefined,
-							interopNamespaceObject2Used: false,
-							interopNamespaceObject2Name: undefined,
-							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
-						};
-						break;
-					case "external":
-						item = {
-							type: "external",
-							module: info.module,
-							runtimeCondition: info.runtimeCondition,
-							index,
-							name: undefined,
-							interopNamespaceObjectUsed: false,
-							interopNamespaceObjectName: undefined,
-							interopNamespaceObject2Used: false,
-							interopNamespaceObject2Name: undefined,
-							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
-						};
-						break;
-					default:
-						throw new Error(
-							`Unsupported concatenation entry type ${info.type}`
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"CommonJsChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"CommonJsChunkLoadingPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (chunk.hasRuntime()) return;
+						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.require);
+							set.add(RuntimeGlobals.startupEntrypoint);
+							set.add(RuntimeGlobals.externalInstallChunk);
+						}
+					}
+				);
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"CommonJsChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+						const source = new ConcatSource();
+						source.add(`exports.id = ${JSON.stringify(chunk.id)};\n`);
+						source.add(`exports.ids = ${JSON.stringify(chunk.ids)};\n`);
+						source.add(`exports.modules = `);
+						source.add(modules);
+						source.add(";\n");
+						const runtimeModules =
+							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+						if (runtimeModules.length > 0) {
+							source.add("exports.runtime =\n");
+							source.add(
+								Template.renderChunkRuntimeModules(
+									runtimeModules,
+									renderContext
+								)
+							);
+						}
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						if (entries.length > 0) {
+							const runtimeChunk = entries[0][1].getRuntimeChunk();
+							const currentOutputName = compilation
+								.getPath(
+									getChunkFilenameTemplate(chunk, compilation.outputOptions),
+									{
+										chunk,
+										contentHashType: "javascript"
+									}
+								)
+								.split("/");
+							const runtimeOutputName = compilation
+								.getPath(
+									getChunkFilenameTemplate(
+										runtimeChunk,
+										compilation.outputOptions
+									),
+									{
+										chunk: runtimeChunk,
+										contentHashType: "javascript"
+									}
+								)
+								.split("/");
+
+							// remove filename, we only need the directory
+							currentOutputName.pop();
+
+							// remove common parts
+							while (
+								currentOutputName.length > 0 &&
+								runtimeOutputName.length > 0 &&
+								currentOutputName[0] === runtimeOutputName[0]
+							) {
+								currentOutputName.shift();
+								runtimeOutputName.shift();
+							}
+
+							// create final path
+							const runtimePath =
+								(currentOutputName.length > 0
+									? "../".repeat(currentOutputName.length)
+									: "./") + runtimeOutputName.join("/");
+
+							const entrySource = new ConcatSource();
+							entrySource.add(
+								`(${
+									runtimeTemplate.supportsArrowFunction()
+										? "() => "
+										: "function() "
+								}{\n`
+							);
+							entrySource.add("var exports = {};\n");
+							entrySource.add(source);
+							entrySource.add(";\n\n// load runtime\n");
+							entrySource.add(
+								`var __webpack_require__ = require(${JSON.stringify(
+									runtimePath
+								)});\n`
+							);
+							entrySource.add(
+								`${RuntimeGlobals.externalInstallChunk}(exports);\n`
+							);
+							const startupSource = new RawSource(
+								generateEntryStartup(
+									chunkGraph,
+									runtimeTemplate,
+									entries,
+									chunk,
+									false
+								)
+							);
+							entrySource.add(
+								hooks.renderStartup.call(
+									startupSource,
+									entries[entries.length - 1][0],
+									{
+										...renderContext,
+										inlined: false
+									}
+								)
+							);
+							entrySource.add("\n})()");
+							return entrySource;
+						}
+						return source;
+					}
+				);
+				hooks.chunkHash.tap(
+					"CommonJsChunkFormatPlugin",
+					(chunk, hash, { chunkGraph }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update("CommonJsChunkFormatPlugin");
+						hash.update("1");
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 						);
-				}
-				map.set(item.module, item);
-				return item;
-			} else {
-				/** @type {ReferenceToModuleInfo} */
-				const ref = {
-					type: "reference",
-					runtimeCondition: info.runtimeCondition,
-					target: item
-				};
-				return ref;
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
 			}
-		});
-		return [list, map];
+		);
 	}
+}
 
-	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
-		let name = oldName;
+module.exports = CommonJsChunkFormatPlugin;
 
-		if (name === ConcatenationScope.DEFAULT_EXPORT) {
-			name = "";
-		}
-		if (name === ConcatenationScope.NAMESPACE_OBJECT_EXPORT) {
-			name = "namespaceObject";
-		}
 
-		// 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;
-		}
+/***/ 61291:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		let i = 0;
-		let nameWithNumber = Template.toIdentifier(`${name}_${i}`);
-		while (
-			usedNamed1.has(nameWithNumber) ||
-			(usedNamed2 && usedNamed2.has(nameWithNumber))
-		) {
-			i++;
-			nameWithNumber = Template.toIdentifier(`${name}_${i}`);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
+/** @typedef {import("../Compiler")} Compiler */
+
+/** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
+const enabledTypes = new WeakMap();
+
+const getEnabledTypes = compiler => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
+	}
+	return set;
+};
+
+class EnableChunkLoadingPlugin {
+	/**
+	 * @param {ChunkLoadingType} type library type that should be available
+	 */
+	constructor(type) {
+		this.type = type;
+	}
+
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {ChunkLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
+	}
+
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {ChunkLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Chunk loading type "${type}" is not enabled. ` +
+					"EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. " +
+					'This usually happens through the "output.enabledChunkLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". ' +
+					"These types are enabled: " +
+					Array.from(getEnabledTypes(compiler)).join(", ")
+			);
 		}
-		return nameWithNumber;
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		for (const info of this._createConcatenationList(
-			this.rootModule,
-			this._modules,
-			intersectRuntime(runtime, this._runtime),
-			chunkGraph.moduleGraph
-		)) {
-			switch (info.type) {
-				case "concatenated":
-					info.module.updateHash(hash, context);
+	apply(compiler) {
+		const { type } = this;
+
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
+
+		if (typeof type === "string") {
+			switch (type) {
+				case "jsonp": {
+					const JsonpChunkLoadingPlugin = __webpack_require__(83121);
+					new JsonpChunkLoadingPlugin().apply(compiler);
 					break;
-				case "external":
-					hash.update(`${chunkGraph.getModuleId(info.module)}`);
-					// TODO runtimeCondition
+				}
+				case "import-scripts": {
+					const ImportScriptsChunkLoadingPlugin = __webpack_require__(54182);
+					new ImportScriptsChunkLoadingPlugin().apply(compiler);
+					break;
+				}
+				case "require": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
+					new CommonJsChunkLoadingPlugin({
+						asyncChunkLoading: false
+					}).apply(compiler);
+					break;
+				}
+				case "async-node": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
+					new CommonJsChunkLoadingPlugin({
+						asyncChunkLoading: true
+					}).apply(compiler);
+					break;
+				}
+				case "import": {
+					const ModuleChunkLoadingPlugin = __webpack_require__(89831);
+					new ModuleChunkLoadingPlugin().apply(compiler);
 					break;
+				}
+				case "universal":
+					// TODO implement universal chunk loading
+					throw new Error("Universal Chunk Loading is not implemented yet");
+				default:
+					throw new Error(`Unsupported chunk loading type ${type}.
+Plugins which provide custom chunk loading types must call EnableChunkLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
 			}
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
 		}
-		super.updateHash(hash, context);
-	}
-
-	static deserialize(context) {
-		const obj = new ConcatenatedModule({
-			identifier: undefined,
-			rootModule: undefined,
-			modules: undefined,
-			runtime: undefined
-		});
-		obj.deserialize(context);
-		return obj;
 	}
 }
 
-makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
-
-module.exports = ConcatenatedModule;
+module.exports = EnableChunkLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 96260:
+/***/ 77106:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -101759,596 +96711,421 @@ module.exports = ConcatenatedModule;
 
 
 
-const { STAGE_BASIC } = __webpack_require__(80057);
+const util = __webpack_require__(73837);
+const { RawSource, ReplaceSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const HarmonyCompatibilityDependency = __webpack_require__(72906);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
-class EnsureChunkConditionsPlugin {
+// TODO: clean up this file
+// replace with newer constructs
+
+const deprecatedGetInitFragments = util.deprecate(
+	(template, dependency, templateContext) =>
+		template.getInitFragments(dependency, templateContext),
+	"DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)",
+	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
+);
+
+const TYPES = new Set(["javascript"]);
+
+class JavascriptGenerator extends Generator {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EnsureChunkConditionsPlugin",
-			compilation => {
-				const handler = chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					// These sets are hoisted here to save memory
-					// They are cleared at the end of every loop
-					/** @type {Set<Chunk>} */
-					const sourceChunks = new Set();
-					/** @type {Set<ChunkGroup>} */
-					const chunkGroups = new Set();
-					for (const module of compilation.modules) {
-						if (!module.hasChunkCondition()) continue;
-						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-							if (!module.chunkCondition(chunk, compilation)) {
-								sourceChunks.add(chunk);
-								for (const group of chunk.groupsIterable) {
-									chunkGroups.add(group);
-								}
-							}
-						}
-						if (sourceChunks.size === 0) continue;
-						/** @type {Set<Chunk>} */
-						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, compilation)) {
-									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) {
-							chunkGraph.disconnectChunkAndModule(sourceChunk, module);
-						}
-						for (const targetChunk of targetChunks) {
-							chunkGraph.connectChunkAndModule(targetChunk, module);
-						}
-						sourceChunks.clear();
-						chunkGroups.clear();
-					}
-				};
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "EnsureChunkConditionsPlugin",
-						stage: STAGE_BASIC
-					},
-					handler
-				);
-			}
-		);
+	getTypes(module) {
+		return TYPES;
 	}
-}
-module.exports = EnsureChunkConditionsPlugin;
 
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 39;
+		}
+		return originalSource.size();
+	}
 
-/***/ }),
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		// Only harmony modules are valid for optimization
+		if (
+			!module.buildMeta ||
+			module.buildMeta.exportsType !== "namespace" ||
+			module.presentationalDependencies === undefined ||
+			!module.presentationalDependencies.some(
+				d => d instanceof HarmonyCompatibilityDependency
+			)
+		) {
+			return "Module is not an ECMAScript module";
+		}
 
-/***/ 50089:
-/***/ (function(module) {
+		// 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.buildInfo && module.buildInfo.moduleConcatenationBailout) {
+			return `Module uses ${module.buildInfo.moduleConcatenationBailout}`;
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return new RawSource("throw new Error('No source available');");
+		}
 
+		const source = new ReplaceSource(originalSource);
+		const initFragments = [];
 
+		this.sourceModule(module, initFragments, source, generateContext);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+		return InitFragment.addToSource(source, initFragments, generateContext);
+	}
 
-class FlagIncludedChunksPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Module} module the module to generate
+	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {GenerateContext} generateContext the generateContext
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
-			compilation.hooks.optimizeChunkIds.tap(
-				"FlagIncludedChunksPlugin",
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-
-					// 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)
-					/** @type {WeakMap<Module, number>} */
-					const moduleBits = new WeakMap();
-					const modulesCount = compilation.modules.size;
-
-					// 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
-					);
+	sourceModule(module, initFragments, source, generateContext) {
+		for (const dependency of module.dependencies) {
+			this.sourceDependency(
+				module,
+				dependency,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
 
-					// 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++;
-					}
+		if (module.presentationalDependencies !== undefined) {
+			for (const dependency of module.presentationalDependencies) {
+				this.sourceDependency(
+					module,
+					dependency,
+					initFragments,
+					source,
+					generateContext
+				);
+			}
+		}
 
-					// iterate all chunks to generate bitmaps
-					/** @type {WeakMap<Chunk, number>} */
-					const chunkModulesHash = new WeakMap();
-					for (const chunk of chunks) {
-						let hash = 0;
-						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-							hash |= moduleBits.get(module);
-						}
-						chunkModulesHash.set(chunk, hash);
-					}
+		for (const childBlock of module.blocks) {
+			this.sourceBlock(
+				module,
+				childBlock,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
+	}
 
-					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
-						const chunkAModulesCount =
-							chunkGraph.getNumberOfChunkModules(chunkA);
-						if (chunkAModulesCount === 0) continue;
-						let bestModule = undefined;
-						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
-							if (
-								bestModule === undefined ||
-								chunkGraph.getNumberOfModuleChunks(bestModule) >
-									chunkGraph.getNumberOfModuleChunks(module)
-							)
-								bestModule = module;
-						}
-						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
-							bestModule
-						)) {
-							// as we iterate the same iterables twice
-							// skip if we find ourselves
-							if (chunkA === chunkB) continue;
+	/**
+	 * @param {Module} module the module to generate
+	 * @param {DependenciesBlock} block the dependencies block which will be processed
+	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {GenerateContext} generateContext the generateContext
+	 * @returns {void}
+	 */
+	sourceBlock(module, block, initFragments, source, generateContext) {
+		for (const dependency of block.dependencies) {
+			this.sourceDependency(
+				module,
+				dependency,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
 
-							const chunkBModulesCount =
-								chunkGraph.getNumberOfChunkModules(chunkB);
+		for (const childBlock of block.blocks) {
+			this.sourceBlock(
+				module,
+				childBlock,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
+	}
 
-							// ids for empty chunks are not included
-							if (chunkBModulesCount === 0) continue;
+	/**
+	 * @param {Module} module the current module
+	 * @param {Dependency} dependency the dependency to generate
+	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {GenerateContext} generateContext the render context
+	 * @returns {void}
+	 */
+	sourceDependency(module, dependency, initFragments, source, generateContext) {
+		const constructor = /** @type {new (...args: any[]) => Dependency} */ (
+			dependency.constructor
+		);
+		const template = generateContext.dependencyTemplates.get(constructor);
+		if (!template) {
+			throw new Error(
+				"No template for dependency: " + dependency.constructor.name
+			);
+		}
 
-							// 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;
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
+			initFragments
+		};
 
-							// is chunkA in chunkB?
+		template.apply(dependency, source, templateContext);
 
-							// we do a cheap check for the hash value
-							const chunkBHash = chunkModulesHash.get(chunkB);
-							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
+		// TODO remove in webpack 6
+		if ("getInitFragments" in template) {
+			const fragments = deprecatedGetInitFragments(
+				template,
+				dependency,
+				templateContext
+			);
 
-							// compare all modules
-							for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
-								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
-							}
-							chunkB.ids.push(chunkA.id);
-						}
-					}
+			if (fragments) {
+				for (const fragment of fragments) {
+					initFragments.push(fragment);
 				}
-			);
-		});
+			}
+		}
 	}
 }
-module.exports = FlagIncludedChunksPlugin;
+
+module.exports = JavascriptGenerator;
 
 
 /***/ }),
 
-/***/ 38988:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 89464:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { UsageState } = __webpack_require__(63686);
+const { SyncWaterfallHook, SyncHook, SyncBailHook } = __webpack_require__(41242);
+const vm = __webpack_require__(26144);
+const {
+	ConcatSource,
+	OriginalSource,
+	PrefixSource,
+	RawSource,
+	CachedSource
+} = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const { tryRunOrWebpackError } = __webpack_require__(11351);
+const HotUpdateChunk = __webpack_require__(9597);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const { last, someInIterable } = __webpack_require__(39104);
+const StringXor = __webpack_require__(40293);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const { intersectRuntime } = __webpack_require__(17156);
+const JavascriptGenerator = __webpack_require__(77106);
+const JavascriptParser = __webpack_require__(29050);
 
-/** @typedef {import("estree").Node} AnyNode */
-/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
-/** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
-
-/**
- * @typedef {Object} StateObject
- * @property {InnerGraph} innerGraph
- * @property {TopLevelSymbol=} currentTopLevelSymbol
- * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
- */
-
-/** @typedef {false|StateObject} State */
-
-/** @type {WeakMap<ParserState, State>} */
-const parserStateMap = new WeakMap();
-const topLevelSymbolTag = Symbol("top level symbol");
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {State} state
- */
-function getState(parserState) {
-	return parserStateMap.get(parserState);
-}
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.bailout = parserState => {
-	parserStateMap.set(parserState, false);
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.enable = parserState => {
-	const state = parserStateMap.get(parserState);
-	if (state === false) {
-		return;
-	}
-	parserStateMap.set(parserState, {
-		innerGraph: new Map(),
-		currentTopLevelSymbol: undefined,
-		usageCallbackMap: new Map()
-	});
-};
-
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-exports.isEnabled = parserState => {
-	const state = parserStateMap.get(parserState);
-	return !!state;
-};
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
 
 /**
- * @param {ParserState} state parser state
- * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
- * @param {string | TopLevelSymbol | true} usage usage data
- * @returns {void}
+ * @param {Chunk} chunk a chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true, when a JS file is needed for this chunk
  */
-exports.addUsage = (state, symbol, usage) => {
-	const innerGraphState = getState(state);
-
-	if (innerGraphState) {
-		const { innerGraph } = innerGraphState;
-		const info = innerGraph.get(symbol);
-		if (usage === true) {
-			innerGraph.set(symbol, true);
-		} else if (info === undefined) {
-			innerGraph.set(symbol, new Set([usage]));
-		} else if (info !== true) {
-			info.add(usage);
-		}
-	}
-};
+const chunkHasJs = (chunk, chunkGraph) => {
+	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
 
-/**
- * @param {JavascriptParser} parser the parser
- * @param {string} name name of variable
- * @param {string | TopLevelSymbol | true} usage usage data
- * @returns {void}
- */
-exports.addVariableUsage = (parser, name, usage) => {
-	const symbol =
-		/** @type {TopLevelSymbol} */ (
-			parser.getTagData(name, topLevelSymbolTag)
-		) || exports.tagTopLevelSymbol(parser, name);
-	if (symbol) {
-		exports.addUsage(parser.state, symbol, usage);
-	}
+	return chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+		? true
+		: false;
 };
 
-/**
- * @param {ParserState} state parser state
- * @returns {void}
- */
-exports.inferDependencyUsage = state => {
-	const innerGraphState = getState(state);
-
-	if (!innerGraphState) {
-		return;
-	}
-
-	const { innerGraph, usageCallbackMap } = innerGraphState;
-	const processed = new Map();
-	// flatten graph to terminal nodes (string, undefined or true)
-	const nonTerminal = new Set(innerGraph.keys());
-	while (nonTerminal.size > 0) {
-		for (const key of nonTerminal) {
-			/** @type {Set<string|TopLevelSymbol> | true} */
-			let newSet = new Set();
-			let isTerminal = true;
-			const value = innerGraph.get(key);
-			let alreadyProcessed = processed.get(key);
-			if (alreadyProcessed === undefined) {
-				alreadyProcessed = new Set();
-				processed.set(key, alreadyProcessed);
-			}
-			if (value !== true && value !== undefined) {
-				for (const item of value) {
-					alreadyProcessed.add(item);
-				}
-				for (const item of value) {
-					if (typeof item === "string") {
-						newSet.add(item);
-					} else {
-						const itemValue = innerGraph.get(item);
-						if (itemValue === true) {
-							newSet = true;
-							break;
-						}
-						if (itemValue !== undefined) {
-							for (const i of itemValue) {
-								if (i === key) continue;
-								if (alreadyProcessed.has(i)) continue;
-								newSet.add(i);
-								if (typeof i !== "string") {
-									isTerminal = false;
-								}
-							}
-						}
-					}
-				}
-				if (newSet === true) {
-					innerGraph.set(key, true);
-				} else if (newSet.size === 0) {
-					innerGraph.set(key, undefined);
-				} else {
-					innerGraph.set(key, newSet);
-				}
-			}
-			if (isTerminal) {
-				nonTerminal.delete(key);
-
-				// For the global key, merge with all other keys
-				if (key === null) {
-					const globalValue = innerGraph.get(null);
-					if (globalValue) {
-						for (const [key, value] of innerGraph) {
-							if (key !== null && value !== true) {
-								if (globalValue === true) {
-									innerGraph.set(key, true);
-								} else {
-									const newSet = new Set(value);
-									for (const item of globalValue) {
-										newSet.add(item);
-									}
-									innerGraph.set(key, newSet);
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-
-	/** @type {Map<Dependency, true | Set<string>>} */
-	for (const [symbol, callbacks] of usageCallbackMap) {
-		const usage = /** @type {true | Set<string> | undefined} */ (
-			innerGraph.get(symbol)
-		);
-		for (const callback of callbacks) {
-			callback(usage === undefined ? false : usage);
-		}
-	}
+const printGeneratedCodeForStack = (module, code) => {
+	const lines = code.split("\n");
+	const n = `${lines.length}`.length;
+	return `\n\nGenerated code for ${module.identifier()}\n${lines
+		.map((line, i, lines) => {
+			const iStr = `${i + 1}`;
+			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
+		})
+		.join("\n")}`;
 };
 
 /**
- * @param {ParserState} state parser state
- * @param {UsageCallback} onUsageCallback on usage callback
+ * @typedef {Object} RenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {boolean} strictMode rendering in strict context
  */
-exports.onUsage = (state, onUsageCallback) => {
-	const innerGraphState = getState(state);
-
-	if (innerGraphState) {
-		const { usageCallbackMap, currentTopLevelSymbol } = innerGraphState;
-		if (currentTopLevelSymbol) {
-			let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
-
-			if (callbacks === undefined) {
-				callbacks = new Set();
-				usageCallbackMap.set(currentTopLevelSymbol, callbacks);
-			}
-
-			callbacks.add(onUsageCallback);
-		} else {
-			onUsageCallback(true);
-		}
-	} else {
-		onUsageCallback(undefined);
-	}
-};
 
 /**
- * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
+ * @typedef {Object} MainRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {string} hash hash to be used for render call
+ * @property {boolean} strictMode rendering in strict context
  */
-exports.setTopLevelSymbol = (state, symbol) => {
-	const innerGraphState = getState(state);
-
-	if (innerGraphState) {
-		innerGraphState.currentTopLevelSymbol = symbol;
-	}
-};
 
 /**
- * @param {ParserState} state parser state
- * @returns {TopLevelSymbol|void} usage data
+ * @typedef {Object} ChunkRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
+ * @property {boolean} strictMode rendering in strict context
  */
-exports.getTopLevelSymbol = state => {
-	const innerGraphState = getState(state);
-
-	if (innerGraphState) {
-		return innerGraphState.currentTopLevelSymbol;
-	}
-};
 
 /**
- * @param {JavascriptParser} parser parser
- * @param {string} name name of variable
- * @returns {TopLevelSymbol} symbol
+ * @typedef {Object} RenderBootstrapContext
+ * @property {Chunk} chunk the chunk
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {string} hash hash to be used for render call
  */
-exports.tagTopLevelSymbol = (parser, name) => {
-	const innerGraphState = getState(parser.state);
-	if (!innerGraphState) return;
-
-	parser.defineVariable(name);
-
-	const existingTag = /** @type {TopLevelSymbol} */ (
-		parser.getTagData(name, topLevelSymbolTag)
-	);
-	if (existingTag) {
-		return existingTag;
-	}
 
-	const fn = new TopLevelSymbol(name);
-	parser.tagVariable(name, topLevelSymbolTag, fn);
-	return fn;
-};
+/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
 
 /**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @param {RuntimeSpec} runtime runtime
- * @returns {boolean} false, when unused. Otherwise true
+ * @typedef {Object} CompilationHooks
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} render
+ * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
+ * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
+ * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
+ * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
+ * @property {SyncBailHook<[RenderContext], string>} strictRuntimeBailout
+ * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
+ * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
  */
-exports.isDependencyUsedByExports = (
-	dependency,
-	usedByExports,
-	moduleGraph,
-	runtime
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		let used = false;
-		for (const exportName of usedByExports) {
-			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-				used = true;
-		}
-		if (!used) return false;
-	}
-	return true;
-};
 
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
- */
-exports.getDependencyUsedByExportsCondition = (
-	dependency,
-	usedByExports,
-	moduleGraph
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		return (connections, runtime) => {
-			for (const exportName of usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-					return true;
-			}
-			return false;
-		};
-	}
-	return null;
-};
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-class TopLevelSymbol {
+class JavascriptModulesPlugin {
 	/**
-	 * @param {string} name name of the variable
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
 	 */
-	constructor(name) {
-		this.name = name;
-	}
-}
-
-exports.TopLevelSymbol = TopLevelSymbol;
-exports.topLevelSymbolTag = topLevelSymbolTag;
-
-
-/***/ }),
-
-/***/ 28758:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const PureExpressionDependency = __webpack_require__(55799);
-const InnerGraph = __webpack_require__(38988);
-
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
-/** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				renderModuleContent: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				]),
+				renderModuleContainer: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				]),
+				renderModulePackage: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				]),
+				render: new SyncWaterfallHook(["source", "renderContext"]),
+				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
+				renderStartup: new SyncWaterfallHook([
+					"source",
+					"module",
+					"startupRenderContext"
+				]),
+				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
+				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
+				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
+				inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+				embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+				strictRuntimeBailout: new SyncBailHook(["renderContext"]),
+				chunkHash: new SyncHook(["chunk", "hash", "context"]),
+				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
 
-const { topLevelSymbolTag } = InnerGraph;
+	constructor(options = {}) {
+		this.options = options;
+		/** @type {WeakMap<Source, TODO>} */
+		this._moduleFactoryCache = new WeakMap();
+	}
 
-class InnerGraphPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -102356,612 +97133,1160 @@ class InnerGraphPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"InnerGraphPlugin",
+			"JavascriptModulesPlugin",
 			(compilation, { normalModuleFactory }) => {
-				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
-
-				compilation.dependencyTemplates.set(
-					PureExpressionDependency,
-					new PureExpressionDependency.Template()
-				);
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
-				 * @returns {void}
-				 */
-				const handler = (parser, parserOptions) => {
-					const onUsageSuper = sup => {
-						InnerGraph.onUsage(parser.state, usedByExports => {
-							switch (usedByExports) {
-								case undefined:
-								case true:
-									return;
-								default: {
-									const dep = new PureExpressionDependency(sup.range);
-									dep.loc = sup.loc;
-									dep.usedByExports = usedByExports;
-									parser.state.module.addDependency(dep);
-									break;
-								}
-							}
-						});
-					};
-
-					parser.hooks.program.tap("InnerGraphPlugin", () => {
-						InnerGraph.enable(parser.state);
+				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+				normalModuleFactory.hooks.createParser
+					.for("javascript/auto")
+					.tap("JavascriptModulesPlugin", options => {
+						return new JavascriptParser("auto");
 					});
-
-					parser.hooks.finish.tap("InnerGraphPlugin", () => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						logger.time("infer dependency usage");
-						InnerGraph.inferDependencyUsage(parser.state);
-						logger.timeAggregate("infer dependency usage");
+				normalModuleFactory.hooks.createParser
+					.for("javascript/dynamic")
+					.tap("JavascriptModulesPlugin", options => {
+						return new JavascriptParser("script");
 					});
-
-					// During prewalking the following datastructures are filled with
-					// nodes that have a TopLevelSymbol assigned and
-					// variables are tagged with the assigned TopLevelSymbol
-
-					// We differ 3 types of nodes:
-					// 1. full statements (export default, function declaration)
-					// 2. classes (class declaration, class expression)
-					// 3. variable declarators (const x = ...)
-
-					/** @type {WeakMap<Node, TopLevelSymbol>} */
-					const statementWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakMap<Node, Node>} */
-					const statementPurePart = new WeakMap();
-
-					/** @type {WeakMap<ClassExpressionNode | ClassDeclarationNode, TopLevelSymbol>} */
-					const classWithTopLevelSymbol = new WeakMap();
-
-					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
-					const declWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakSet<VariableDeclaratorNode>} */
-					const pureDeclarators = new WeakSet();
-
-					// The following hooks are used during prewalking:
-
-					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "FunctionDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								statementWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
-						}
+				normalModuleFactory.hooks.createParser
+					.for("javascript/esm")
+					.tap("JavascriptModulesPlugin", options => {
+						return new JavascriptParser("module");
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/auto")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/dynamic")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/esm")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
 					});
+				compilation.hooks.renderManifest.tap(
+					"JavascriptModulesPlugin",
+					(result, options) => {
+						const {
+							hash,
+							chunk,
+							chunkGraph,
+							moduleGraph,
+							runtimeTemplate,
+							dependencyTemplates,
+							outputOptions,
+							codeGenerationResults
+						} = options;
 
-					parser.hooks.blockPreStatement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
 
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "ClassDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								classWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
-							if (statement.type === "ExportDefaultDeclaration") {
-								const name = "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								const decl = statement.declaration;
-								if (
-									decl.type === "ClassExpression" ||
-									decl.type === "ClassDeclaration"
-								) {
-									classWithTopLevelSymbol.set(decl, fn);
-								} else if (parser.isPure(decl, statement.range[0])) {
-									statementWithTopLevelSymbol.set(statement, fn);
-									if (
-										!decl.type.endsWith("FunctionExpression") &&
-										!decl.type.endsWith("Declaration") &&
-										decl.type !== "Literal"
-									) {
-										statementPurePart.set(statement, decl);
-									}
-								}
+						let render;
+						const filenameTemplate =
+							JavascriptModulesPlugin.getChunkFilenameTemplate(
+								chunk,
+								outputOptions
+							);
+						if (hotUpdateChunk) {
+							render = () =>
+								this.renderChunk(
+									{
+										chunk,
+										dependencyTemplates,
+										runtimeTemplate,
+										moduleGraph,
+										chunkGraph,
+										codeGenerationResults,
+										strictMode: runtimeTemplate.isModule()
+									},
+									hooks
+								);
+						} else if (chunk.hasRuntime()) {
+							render = () =>
+								this.renderMain(
+									{
+										hash,
+										chunk,
+										dependencyTemplates,
+										runtimeTemplate,
+										moduleGraph,
+										chunkGraph,
+										codeGenerationResults,
+										strictMode: runtimeTemplate.isModule()
+									},
+									hooks,
+									compilation
+								);
+						} else {
+							if (!chunkHasJs(chunk, chunkGraph)) {
+								return result;
 							}
-						}
-					});
 
-					parser.hooks.preDeclarator.tap(
-						"InnerGraphPlugin",
-						(decl, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (
-								parser.scope.topLevelScope === true &&
-								decl.init &&
-								decl.id.type === "Identifier"
-							) {
-								const name = decl.id.name;
-								if (decl.init.type === "ClassExpression") {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									classWithTopLevelSymbol.set(decl.init, fn);
-								} else if (parser.isPure(decl.init, decl.id.range[1])) {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									declWithTopLevelSymbol.set(decl, fn);
-									if (
-										!decl.init.type.endsWith("FunctionExpression") &&
-										decl.init.type !== "Literal"
-									) {
-										pureDeclarators.add(decl);
-									}
-									return true;
-								}
-							}
+							render = () =>
+								this.renderChunk(
+									{
+										chunk,
+										dependencyTemplates,
+										runtimeTemplate,
+										moduleGraph,
+										chunkGraph,
+										codeGenerationResults,
+										strictMode: runtimeTemplate.isModule()
+									},
+									hooks
+								);
 						}
-					);
-
-					// During real walking we set the TopLevelSymbol state to the assigned
-					// TopLevelSymbol by using the fill datastructures.
-
-					// In addition to tracking TopLevelSymbols, we sometimes need to
-					// add a PureExpressionDependency. This is needed to skip execution
-					// of pure expressions, even when they are not dropped due to
-					// minimizing. Otherwise symbols used there might not exist anymore
-					// as they are removed as unused by this optimization
-
-					// When we find a reference to a TopLevelSymbol, we register a
-					// TopLevelSymbol dependency from TopLevelSymbol in state to the
-					// referenced TopLevelSymbol. This way we get a graph of all
-					// TopLevelSymbols.
-
-					// The following hooks are called during walking:
 
-					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						if (parser.scope.topLevelScope === true) {
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+						result.push({
+							render,
+							filenameTemplate,
+							pathOptions: {
+								hash,
+								runtime: chunk.runtime,
+								chunk,
+								contentHashType: "javascript"
+							},
+							info: {
+								javascriptModule: compilation.runtimeTemplate.isModule()
+							},
+							identifier: hotUpdateChunk
+								? `hotupdatechunk${chunk.id}`
+								: `chunk${chunk.id}`,
+							hash: chunk.contentHash.javascript
+						});
 
-							const fn = statementWithTopLevelSymbol.get(statement);
-							if (fn) {
-								InnerGraph.setTopLevelSymbol(parser.state, fn);
-								const purePart = statementPurePart.get(statement);
-								if (purePart) {
-									InnerGraph.onUsage(parser.state, usedByExports => {
-										switch (usedByExports) {
-											case undefined:
-											case true:
-												return;
-											default: {
-												const dep = new PureExpressionDependency(
-													purePart.range
-												);
-												dep.loc = statement.loc;
-												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
-												break;
-											}
-										}
-									});
-								}
-							}
+						return result;
+					}
+				);
+				compilation.hooks.chunkHash.tap(
+					"JavascriptModulesPlugin",
+					(chunk, hash, context) => {
+						hooks.chunkHash.call(chunk, hash, context);
+						if (chunk.hasRuntime()) {
+							this.updateHashWithBootstrap(
+								hash,
+								{
+									hash: "0000",
+									chunk,
+									chunkGraph: context.chunkGraph,
+									moduleGraph: context.moduleGraph,
+									runtimeTemplate: context.runtimeTemplate
+								},
+								hooks
+							);
 						}
-					});
-
-					parser.hooks.classExtendsExpression.tap(
-						"InnerGraphPlugin",
-						(expr, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(statement);
-								if (
-									fn &&
-									parser.isPure(
-										expr,
-										statement.id ? statement.id.range[1] : statement.range[0]
-									)
-								) {
-									InnerGraph.setTopLevelSymbol(parser.state, fn);
-									onUsageSuper(expr);
-								}
-							}
+					}
+				);
+				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+					const {
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						outputOptions: {
+							hashSalt,
+							hashDigest,
+							hashDigestLength,
+							hashFunction
 						}
+					} = compilation;
+					const hash = createHash(hashFunction);
+					if (hashSalt) hash.update(hashSalt);
+					if (chunk.hasRuntime()) {
+						this.updateHashWithBootstrap(
+							hash,
+							{
+								hash: "0000",
+								chunk,
+								chunkGraph: compilation.chunkGraph,
+								moduleGraph: compilation.moduleGraph,
+								runtimeTemplate: compilation.runtimeTemplate
+							},
+							hooks
+						);
+					} else {
+						hash.update(`${chunk.id} `);
+						hash.update(chunk.ids ? chunk.ids.join(",") : "");
+					}
+					hooks.chunkHash.call(chunk, hash, {
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate
+					});
+					const modules = chunkGraph.getChunkModulesIterableBySourceType(
+						chunk,
+						"javascript"
 					);
-
-					parser.hooks.classBodyElement.tap(
-						"InnerGraphPlugin",
-						(element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(classDefinition);
-								if (fn) {
-									InnerGraph.setTopLevelSymbol(parser.state, undefined);
-								}
-							}
+					if (modules) {
+						const xor = new StringXor();
+						for (const m of modules) {
+							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
 						}
+						xor.updateHash(hash);
+					}
+					const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(
+						chunk,
+						"runtime"
 					);
+					if (runtimeModules) {
+						const xor = new StringXor();
+						for (const m of runtimeModules) {
+							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+						}
+						xor.updateHash(hash);
+					}
+					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
+				});
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"JavascriptModulesPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (
+							!set.has(RuntimeGlobals.startupNoDefault) &&
+							chunkGraph.hasChunkEntryDependentChunks(chunk)
+						) {
+							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.require);
+						}
+					}
+				);
+				compilation.hooks.executeModule.tap(
+					"JavascriptModulesPlugin",
+					(options, context) => {
+						const source =
+							options.codeGenerationResult.sources.get("javascript");
+						if (source === undefined) return;
+						const { module, moduleObject } = options;
+						const code = source.source();
 
-					parser.hooks.classBodyValue.tap(
-						"InnerGraphPlugin",
-						(expression, element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(classDefinition);
-								if (fn) {
-									if (
-										!element.static ||
-										parser.isPure(
-											expression,
-											element.key ? element.key.range[1] : element.range[0]
-										)
-									) {
-										InnerGraph.setTopLevelSymbol(parser.state, fn);
-										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, usedByExports => {
-												switch (usedByExports) {
-													case undefined:
-													case true:
-														return;
-													default: {
-														const dep = new PureExpressionDependency(
-															expression.range
-														);
-														dep.loc = expression.loc;
-														dep.usedByExports = usedByExports;
-														parser.state.module.addDependency(dep);
-														break;
-													}
-												}
-											});
-										}
-									} else {
-										InnerGraph.setTopLevelSymbol(parser.state, undefined);
-									}
-								}
+						const fn = vm.runInThisContext(
+							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
+							{
+								filename: module.identifier(),
+								lineOffset: -1
 							}
+						);
+						try {
+							fn.call(
+								moduleObject.exports,
+								moduleObject,
+								moduleObject.exports,
+								context.__webpack_require__
+							);
+						} catch (e) {
+							e.stack += printGeneratedCodeForStack(options.module, code);
+							throw e;
 						}
-					);
-
-					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						const fn = declWithTopLevelSymbol.get(decl);
+					}
+				);
+				compilation.hooks.executeModule.tap(
+					"JavascriptModulesPlugin",
+					(options, context) => {
+						const source = options.codeGenerationResult.sources.get("runtime");
+						if (source === undefined) return;
+						let code = source.source();
+						if (typeof code !== "string") code = code.toString();
 
-						if (fn) {
-							InnerGraph.setTopLevelSymbol(parser.state, fn);
-							if (pureDeclarators.has(decl)) {
-								if (decl.init.type === "ClassExpression") {
-									if (decl.init.superClass) {
-										onUsageSuper(decl.init.superClass);
-									}
-								} else {
-									InnerGraph.onUsage(parser.state, usedByExports => {
-										switch (usedByExports) {
-											case undefined:
-											case true:
-												return;
-											default: {
-												const dep = new PureExpressionDependency(
-													decl.init.range
-												);
-												dep.loc = decl.loc;
-												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
-												break;
-											}
-										}
-									});
-								}
+						const fn = vm.runInThisContext(
+							`(function(__webpack_require__) {\n${code}\n/**/})`,
+							{
+								filename: options.module.identifier(),
+								lineOffset: -1
 							}
-							parser.walkExpression(decl.init);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
-							return true;
+						);
+						try {
+							fn.call(null, context.__webpack_require__);
+						} catch (e) {
+							e.stack += printGeneratedCodeForStack(options.module, code);
+							throw e;
 						}
-					});
+					}
+				);
+			}
+		);
+	}
 
-					parser.hooks.expression
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", () => {
-							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
-								parser.currentTagData
-							);
-							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
-								parser.state
-							);
-							InnerGraph.addUsage(
-								parser.state,
-								topLevelSymbol,
-								currentTopLevelSymbol || true
-							);
-						});
-					parser.hooks.assign
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", expr => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (expr.operator === "=") return true;
-						});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("InnerGraphPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("InnerGraphPlugin", handler);
+	static getChunkFilenameTemplate(chunk, outputOptions) {
+		if (chunk.filenameTemplate) {
+			return chunk.filenameTemplate;
+		} else if (chunk instanceof HotUpdateChunk) {
+			return outputOptions.hotUpdateChunkFilename;
+		} else if (chunk.canBeInitial()) {
+			return outputOptions.filename;
+		} else {
+			return outputOptions.chunkFilename;
+		}
+	}
 
-				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
-					logger.timeAggregateEnd("infer dependency usage");
-				});
+	/**
+	 * @param {Module} module the rendered module
+	 * @param {ChunkRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @param {boolean} factory true: renders as factory method, false: pure module content
+	 * @returns {Source} the newly generated source from rendering
+	 */
+	renderModule(module, renderContext, hooks, factory) {
+		const {
+			chunk,
+			chunkGraph,
+			runtimeTemplate,
+			codeGenerationResults,
+			strictMode
+		} = renderContext;
+		try {
+			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+			const moduleSource = codeGenResult.sources.get("javascript");
+			if (!moduleSource) return null;
+			if (codeGenResult.data !== undefined) {
+				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
+				if (chunkInitFragments) {
+					for (const i of chunkInitFragments)
+						renderContext.chunkInitFragments.push(i);
+				}
+			}
+			const moduleSourcePostContent = tryRunOrWebpackError(
+				() =>
+					hooks.renderModuleContent.call(moduleSource, module, renderContext),
+				"JavascriptModulesPlugin.getCompilationHooks().renderModuleContent"
+			);
+			let moduleSourcePostContainer;
+			if (factory) {
+				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+					module,
+					chunk.runtime
+				);
+				const needModule = runtimeRequirements.has(RuntimeGlobals.module);
+				const needExports = runtimeRequirements.has(RuntimeGlobals.exports);
+				const needRequire =
+					runtimeRequirements.has(RuntimeGlobals.require) ||
+					runtimeRequirements.has(RuntimeGlobals.requireScope);
+				const needThisAsExports = runtimeRequirements.has(
+					RuntimeGlobals.thisAsExports
+				);
+				const needStrict = module.buildInfo.strict && !strictMode;
+				const cacheEntry = this._moduleFactoryCache.get(
+					moduleSourcePostContent
+				);
+				let source;
+				if (
+					cacheEntry &&
+					cacheEntry.needModule === needModule &&
+					cacheEntry.needExports === needExports &&
+					cacheEntry.needRequire === needRequire &&
+					cacheEntry.needThisAsExports === needThisAsExports &&
+					cacheEntry.needStrict === needStrict
+				) {
+					source = cacheEntry.source;
+				} else {
+					const factorySource = new ConcatSource();
+					const args = [];
+					if (needExports || needRequire || needModule)
+						args.push(
+							needModule
+								? module.moduleArgument
+								: "__unused_webpack_" + module.moduleArgument
+						);
+					if (needExports || needRequire)
+						args.push(
+							needExports
+								? module.exportsArgument
+								: "__unused_webpack_" + module.exportsArgument
+						);
+					if (needRequire) args.push("__webpack_require__");
+					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
+						factorySource.add("/***/ ((" + args.join(", ") + ") => {\n\n");
+					} else {
+						factorySource.add("/***/ (function(" + args.join(", ") + ") {\n\n");
+					}
+					if (needStrict) {
+						factorySource.add('"use strict";\n');
+					}
+					factorySource.add(moduleSourcePostContent);
+					factorySource.add("\n\n/***/ })");
+					source = new CachedSource(factorySource);
+					this._moduleFactoryCache.set(moduleSourcePostContent, {
+						source,
+						needModule,
+						needExports,
+						needRequire,
+						needThisAsExports,
+						needStrict
+					});
+				}
+				moduleSourcePostContainer = tryRunOrWebpackError(
+					() => hooks.renderModuleContainer.call(source, module, renderContext),
+					"JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer"
+				);
+			} else {
+				moduleSourcePostContainer = moduleSourcePostContent;
 			}
+			return tryRunOrWebpackError(
+				() =>
+					hooks.renderModulePackage.call(
+						moduleSourcePostContainer,
+						module,
+						renderContext
+					),
+				"JavascriptModulesPlugin.getCompilationHooks().renderModulePackage"
+			);
+		} catch (e) {
+			e.module = module;
+			throw e;
+		}
+	}
+
+	/**
+	 * @param {RenderContext} renderContext the render context
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Source} the rendered source
+	 */
+	renderChunk(renderContext, hooks) {
+		const { chunk, chunkGraph } = renderContext;
+		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+			chunk,
+			"javascript",
+			compareModulesByIdentifier
+		);
+		const allModules = modules ? Array.from(modules) : [];
+		let strictHeader;
+		let allStrict = renderContext.strictMode;
+		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+			strictHeader = strictBailout
+				? `// runtime can't be in strict mode because ${strictBailout}.\n`
+				: '"use strict";\n';
+			if (!strictBailout) allStrict = true;
+		}
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: [],
+			strictMode: allStrict
+		};
+		const moduleSources =
+			Template.renderChunkModules(chunkRenderContext, allModules, module =>
+				this.renderModule(module, chunkRenderContext, hooks, true)
+			) || new RawSource("{}");
+		let source = tryRunOrWebpackError(
+			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderChunk"
+		);
+		source = tryRunOrWebpackError(
+			() => hooks.renderContent.call(source, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		source = InitFragment.addToSource(
+			source,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
+		source = tryRunOrWebpackError(
+			() => hooks.render.call(source, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().render"
 		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
+			);
+		}
+		chunk.rendered = true;
+		return strictHeader
+			? new ConcatSource(strictHeader, source, ";")
+			: renderContext.runtimeTemplate.isModule()
+			? source
+			: new ConcatSource(source, ";");
 	}
-}
 
-module.exports = InnerGraphPlugin;
+	/**
+	 * @param {MainRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Source} the newly generated source from rendering
+	 */
+	renderMain(renderContext, hooks, compilation) {
+		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+		const iife = runtimeTemplate.isIIFE();
 
-/***/ }),
+		const bootstrap = this.renderBootstrap(renderContext, hooks);
+		const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
 
-/***/ 83608:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const allModules = Array.from(
+			chunkGraph.getOrderedChunkModulesIterableBySourceType(
+				chunk,
+				"javascript",
+				compareModulesByIdentifier
+			) || []
+		);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
+		let inlinedModules;
+		if (bootstrap.allowInlineStartup && hasEntryModules) {
+			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
+		}
 
+		let source = new ConcatSource();
+		let prefix;
+		if (iife) {
+			if (runtimeTemplate.supportsArrowFunction()) {
+				source.add("/******/ (() => { // webpackBootstrap\n");
+			} else {
+				source.add("/******/ (function() { // webpackBootstrap\n");
+			}
+			prefix = "/******/ \t";
+		} else {
+			prefix = "/******/ ";
+		}
+		let allStrict = renderContext.strictMode;
+		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+			if (strictBailout) {
+				source.add(
+					prefix +
+						`// runtime can't be in strict mode because ${strictBailout}.\n`
+				);
+			} else {
+				allStrict = true;
+				source.add(prefix + '"use strict";\n');
+			}
+		}
 
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: [],
+			strictMode: allStrict
+		};
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const LazyBucketSortedSet = __webpack_require__(48424);
-const { compareChunks } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
+		const chunkModules = Template.renderChunkModules(
+			chunkRenderContext,
+			inlinedModules
+				? allModules.filter(m => !inlinedModules.has(m))
+				: allModules,
+			module => this.renderModule(module, chunkRenderContext, hooks, true),
+			prefix
+		);
+		if (
+			chunkModules ||
+			runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
+			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
+			runtimeRequirements.has(RuntimeGlobals.require)
+		) {
+			source.add(prefix + "var __webpack_modules__ = (");
+			source.add(chunkModules || "{}");
+			source.add(");\n");
+			source.add(
+				"/************************************************************************/\n"
+			);
+		}
 
-/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+		if (bootstrap.header.length > 0) {
+			const header = Template.asString(bootstrap.header) + "\n";
+			source.add(
+				new PrefixSource(
+					prefix,
+					useSourceMap
+						? new OriginalSource(header, "webpack/bootstrap")
+						: new RawSource(header)
+				)
+			);
+			source.add(
+				"/************************************************************************/\n"
+			);
+		}
 
-const validate = createSchemaValidation(
-	__webpack_require__(36557),
-	() => __webpack_require__(30837),
-	{
-		name: "Limit Chunk Count Plugin",
-		baseDataPath: "options"
-	}
-);
+		const runtimeModules =
+			renderContext.chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 
-/**
- * @typedef {Object} ChunkCombination
- * @property {boolean} deleted this is set to true when combination was removed
- * @property {number} sizeDiff
- * @property {number} integratedSize
- * @property {Chunk} a
- * @property {Chunk} b
- * @property {number} aIdx
- * @property {number} bIdx
- * @property {number} aSize
- * @property {number} bSize
- */
+		if (runtimeModules.length > 0) {
+			source.add(
+				new PrefixSource(
+					prefix,
+					Template.renderRuntimeModules(runtimeModules, chunkRenderContext)
+				)
+			);
+			source.add(
+				"/************************************************************************/\n"
+			);
+			// runtimeRuntimeModules calls codeGeneration
+			for (const module of runtimeModules) {
+				compilation.codeGeneratedModules.add(module);
+			}
+		}
+		if (inlinedModules) {
+			if (bootstrap.beforeStartup.length > 0) {
+				const beforeStartup = Template.asString(bootstrap.beforeStartup) + "\n";
+				source.add(
+					new PrefixSource(
+						prefix,
+						useSourceMap
+							? new OriginalSource(beforeStartup, "webpack/before-startup")
+							: new RawSource(beforeStartup)
+					)
+				);
+			}
+			const lastInlinedModule = last(inlinedModules);
+			const startupSource = new ConcatSource();
+			startupSource.add(`var __webpack_exports__ = {};\n`);
+			for (const m of inlinedModules) {
+				const renderedModule = this.renderModule(
+					m,
+					chunkRenderContext,
+					hooks,
+					false
+				);
+				if (renderedModule) {
+					const innerStrict = !allStrict && m.buildInfo.strict;
+					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+						m,
+						chunk.runtime
+					);
+					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
+					const webpackExports =
+						exports && m.exportsArgument === "__webpack_exports__";
+					let iife = innerStrict
+						? "it need to be in strict mode."
+						: inlinedModules.size > 1
+						? // TODO check globals and top-level declarations of other entries and chunk modules
+						  // to make a better decision
+						  "it need to be isolated against other entry modules."
+						: chunkModules
+						? "it need to be isolated against other modules in the chunk."
+						: exports && !webpackExports
+						? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+						: hooks.embedInRuntimeBailout.call(m, renderContext);
+					let footer;
+					if (iife !== undefined) {
+						startupSource.add(
+							`// This entry need to be wrapped in an IIFE because ${iife}\n`
+						);
+						const arrow = runtimeTemplate.supportsArrowFunction();
+						if (arrow) {
+							startupSource.add("(() => {\n");
+							footer = "\n})();\n\n";
+						} else {
+							startupSource.add("!function() {\n");
+							footer = "\n}();\n";
+						}
+						if (innerStrict) startupSource.add('"use strict";\n');
+					} else {
+						footer = "\n";
+					}
+					if (exports) {
+						if (m !== lastInlinedModule)
+							startupSource.add(`var ${m.exportsArgument} = {};\n`);
+						else if (m.exportsArgument !== "__webpack_exports__")
+							startupSource.add(
+								`var ${m.exportsArgument} = __webpack_exports__;\n`
+							);
+					}
+					startupSource.add(renderedModule);
+					startupSource.add(footer);
+				}
+			}
+			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+				startupSource.add(
+					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
+				);
+			}
+			source.add(
+				hooks.renderStartup.call(startupSource, lastInlinedModule, {
+					...renderContext,
+					inlined: true
+				})
+			);
+			if (bootstrap.afterStartup.length > 0) {
+				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
+				source.add(
+					new PrefixSource(
+						prefix,
+						useSourceMap
+							? new OriginalSource(afterStartup, "webpack/after-startup")
+							: new RawSource(afterStartup)
+					)
+				);
+			}
+		} else {
+			const lastEntryModule = last(
+				chunkGraph.getChunkEntryModulesIterable(chunk)
+			);
+			const toSource = useSourceMap
+				? (content, name) =>
+						new OriginalSource(Template.asString(content), name)
+				: content => new RawSource(Template.asString(content));
+			source.add(
+				new PrefixSource(
+					prefix,
+					new ConcatSource(
+						toSource(bootstrap.beforeStartup, "webpack/before-startup"),
+						"\n",
+						hooks.renderStartup.call(
+							toSource(bootstrap.startup.concat(""), "webpack/startup"),
+							lastEntryModule,
+							{
+								...renderContext,
+								inlined: false
+							}
+						),
+						toSource(bootstrap.afterStartup, "webpack/after-startup"),
+						"\n"
+					)
+				)
+			);
+		}
+		if (
+			hasEntryModules &&
+			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
+		) {
+			source.add(`${prefix}return __webpack_exports__;\n`);
+		}
+		if (iife) {
+			source.add("/******/ })()\n");
+		}
 
-const addToSetMap = (map, key, value) => {
-	const set = map.get(key);
-	if (set === undefined) {
-		map.set(key, new Set([value]));
-	} else {
-		set.add(value);
+		/** @type {Source} */
+		let finalSource = tryRunOrWebpackError(
+			() => hooks.renderMain.call(source, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderMain"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something"
+			);
+		}
+		finalSource = tryRunOrWebpackError(
+			() => hooks.renderContent.call(finalSource, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		finalSource = InitFragment.addToSource(
+			finalSource,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
+		finalSource = tryRunOrWebpackError(
+			() => hooks.render.call(finalSource, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().render"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
+			);
+		}
+		chunk.rendered = true;
+		return iife ? new ConcatSource(finalSource, ";") : finalSource;
 	}
-};
 
-class LimitChunkCountPlugin {
 	/**
-	 * @param {LimitChunkCountPluginOptions=} options options object
+	 * @param {Hash} hash the hash to be updated
+	 * @param {RenderBootstrapContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
 	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
+	updateHashWithBootstrap(hash, renderContext, hooks) {
+		const bootstrap = this.renderBootstrap(renderContext, hooks);
+		for (const key of Object.keys(bootstrap)) {
+			hash.update(key);
+			if (Array.isArray(bootstrap[key])) {
+				for (const line of bootstrap[key]) {
+					hash.update(line);
+				}
+			} else {
+				hash.update(JSON.stringify(bootstrap[key]));
+			}
+		}
 	}
 
 	/**
-	 * @param {Compiler} compiler the webpack compiler
-	 * @returns {void}
+	 * @param {RenderBootstrapContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "LimitChunkCountPlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					const maxChunks = options.maxChunks;
-					if (!maxChunks) return;
-					if (maxChunks < 1) return;
-					if (compilation.chunks.size <= maxChunks) return;
-
-					let remainingChunksToMerge = compilation.chunks.size - maxChunks;
-
-					// order chunks in a deterministic way
-					const compareChunksWithGraph = compareChunks(chunkGraph);
-					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
-
-					// create a lazy sorted data structure to keep all combinations
-					// this is large. Size = chunks * (chunks - 1) / 2
-					// It uses a multi layer bucket sort plus normal sort in the last layer
-					// It's also lazy so only accessed buckets are sorted
-					const combinations = new LazyBucketSortedSet(
-						// Layer 1: ordered by largest size benefit
-						c => c.sizeDiff,
-						(a, b) => b - a,
-						// Layer 2: ordered by smallest combined size
-						c => c.integratedSize,
-						(a, b) => a - b,
-						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
-						c => c.bIdx - c.aIdx,
-						(a, b) => a - b,
-						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
-						(a, b) => a.bIdx - b.bIdx
-					);
-
-					// we keep a mapping from chunk to all combinations
-					// but this mapping is not kept up-to-date with deletions
-					// so `deleted` flag need to be considered when iterating this
-					/** @type {Map<Chunk, Set<ChunkCombination>>} */
-					const combinationsByChunk = new Map();
-
-					orderedChunks.forEach((b, bIdx) => {
-						// create combination pairs with size and integrated size
-						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
-							const a = orderedChunks[aIdx];
-							// filter pairs that can not be integrated!
-							if (!chunkGraph.canChunksBeIntegrated(a, b)) continue;
+	renderBootstrap(renderContext, hooks) {
+		const { chunkGraph, moduleGraph, chunk, runtimeTemplate } = renderContext;
 
-							const integratedSize = chunkGraph.getIntegratedChunksSize(
-								a,
-								b,
-								options
-							);
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
-							const aSize = chunkGraph.getChunkSize(a, options);
-							const bSize = chunkGraph.getChunkSize(b, options);
-							const c = {
-								deleted: false,
-								sizeDiff: aSize + bSize - integratedSize,
-								integratedSize,
-								a,
-								b,
-								aIdx,
-								bIdx,
-								aSize,
-								bSize
-							};
-							combinations.add(c);
-							addToSetMap(combinationsByChunk, a, c);
-							addToSetMap(combinationsByChunk, b, c);
-						}
-						return combinations;
-					});
+		const requireFunction = runtimeRequirements.has(RuntimeGlobals.require);
+		const moduleCache = runtimeRequirements.has(RuntimeGlobals.moduleCache);
+		const moduleFactories = runtimeRequirements.has(
+			RuntimeGlobals.moduleFactories
+		);
+		const moduleUsed = runtimeRequirements.has(RuntimeGlobals.module);
+		const requireScopeUsed = runtimeRequirements.has(
+			RuntimeGlobals.requireScope
+		);
+		const interceptModuleExecution = runtimeRequirements.has(
+			RuntimeGlobals.interceptModuleExecution
+		);
 
-					// list of modified chunks during this run
-					// combinations affected by this change are skipped to allow
-					// further optimizations
-					/** @type {Set<Chunk>} */
-					const modifiedChunks = new Set();
+		const useRequire =
+			requireFunction || interceptModuleExecution || moduleUsed;
 
-					let changed = false;
-					// eslint-disable-next-line no-constant-condition
-					loop: while (true) {
-						const combination = combinations.popFirst();
-						if (combination === undefined) break;
+		const result = {
+			header: [],
+			beforeStartup: [],
+			startup: [],
+			afterStartup: [],
+			allowInlineStartup: true
+		};
 
-						combination.deleted = true;
-						const { a, b, integratedSize } = combination;
+		let { header: buf, startup, beforeStartup, afterStartup } = result;
 
-						// skip over pair when
-						// one of the already merged chunks is a parent of one of the chunks
-						if (modifiedChunks.size > 0) {
-							const queue = new Set(a.groupsIterable);
-							for (const group of b.groupsIterable) {
-								queue.add(group);
-							}
-							for (const group of queue) {
-								for (const mChunk of modifiedChunks) {
-									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
-										// This is a potential pair which needs recalculation
-										// We can't do that now, but it merge before following pairs
-										// so we leave space for it, and consider chunks as modified
-										// just for the worse case
-										remainingChunksToMerge--;
-										if (remainingChunksToMerge <= 0) break loop;
-										modifiedChunks.add(a);
-										modifiedChunks.add(b);
-										continue loop;
-									}
-								}
-								for (const parent of group.parentsIterable) {
-									queue.add(parent);
-								}
-							}
-						}
+		if (result.allowInlineStartup && moduleFactories) {
+			startup.push(
+				"// module factories are used so entry inlining is disabled"
+			);
+			result.allowInlineStartup = false;
+		}
+		if (result.allowInlineStartup && moduleCache) {
+			startup.push("// module cache are used so entry inlining is disabled");
+			result.allowInlineStartup = false;
+		}
+		if (result.allowInlineStartup && interceptModuleExecution) {
+			startup.push(
+				"// module execution is intercepted so entry inlining is disabled"
+			);
+			result.allowInlineStartup = false;
+		}
 
-						// merge the chunks
-						if (chunkGraph.canChunksBeIntegrated(a, b)) {
-							chunkGraph.integrateChunks(a, b);
-							compilation.chunks.delete(b);
+		if (useRequire || moduleCache) {
+			buf.push("// The module cache");
+			buf.push("var __webpack_module_cache__ = {};");
+			buf.push("");
+		}
 
-							// flag chunk a as modified as further optimization are possible for all children here
-							modifiedChunks.add(a);
+		if (useRequire) {
+			buf.push("// The require function");
+			buf.push(`function __webpack_require__(moduleId) {`);
+			buf.push(Template.indent(this.renderRequire(renderContext, hooks)));
+			buf.push("}");
+			buf.push("");
+		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
+			buf.push("// The require scope");
+			buf.push("var __webpack_require__ = {};");
+			buf.push("");
+		}
 
-							changed = true;
-							remainingChunksToMerge--;
-							if (remainingChunksToMerge <= 0) break;
+		if (
+			moduleFactories ||
+			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)
+		) {
+			buf.push("// expose the modules object (__webpack_modules__)");
+			buf.push(`${RuntimeGlobals.moduleFactories} = __webpack_modules__;`);
+			buf.push("");
+		}
 
-							// Update all affected combinations
-							// delete all combination with the removed chunk
-							// we will use combinations with the kept chunk instead
-							for (const combination of combinationsByChunk.get(a)) {
-								if (combination.deleted) continue;
-								combination.deleted = true;
-								combinations.delete(combination);
-							}
+		if (moduleCache) {
+			buf.push("// expose the module cache");
+			buf.push(`${RuntimeGlobals.moduleCache} = __webpack_module_cache__;`);
+			buf.push("");
+		}
 
-							// Update combinations with the kept chunk with new sizes
-							for (const combination of combinationsByChunk.get(b)) {
-								if (combination.deleted) continue;
-								if (combination.a === b) {
-									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
-										combination.deleted = true;
-										combinations.delete(combination);
-										continue;
-									}
-									// Update size
-									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
-										a,
-										combination.b,
-										options
-									);
-									const finishUpdate = combinations.startUpdate(combination);
-									combination.a = a;
-									combination.integratedSize = newIntegratedSize;
-									combination.aSize = integratedSize;
-									combination.sizeDiff =
-										combination.bSize + integratedSize - newIntegratedSize;
-									finishUpdate();
-								} else if (combination.b === b) {
-									if (!chunkGraph.canChunksBeIntegrated(combination.a, a)) {
-										combination.deleted = true;
-										combinations.delete(combination);
-										continue;
-									}
-									// Update size
-									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
-										combination.a,
-										a,
-										options
-									);
+		if (interceptModuleExecution) {
+			buf.push("// expose the module execution interceptor");
+			buf.push(`${RuntimeGlobals.interceptModuleExecution} = [];`);
+			buf.push("");
+		}
 
-									const finishUpdate = combinations.startUpdate(combination);
-									combination.b = a;
-									combination.integratedSize = newIntegratedSize;
-									combination.bSize = integratedSize;
-									combination.sizeDiff =
-										integratedSize + combination.aSize - newIntegratedSize;
-									finishUpdate();
-								}
-							}
-							combinationsByChunk.set(a, combinationsByChunk.get(b));
-							combinationsByChunk.delete(b);
+		if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
+			if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+				/** @type {string[]} */
+				const buf2 = [];
+				const runtimeRequirements =
+					chunkGraph.getTreeRuntimeRequirements(chunk);
+				buf2.push("// Load entry module and return exports");
+				let i = chunkGraph.getNumberOfEntryModules(chunk);
+				for (const [
+					entryModule,
+					entrypoint
+				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+					const chunks = entrypoint.chunks.filter(c => c !== chunk);
+					if (result.allowInlineStartup && chunks.length > 0) {
+						buf2.push(
+							"// This entry module depends on other loaded chunks and execution need to be delayed"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (
+						result.allowInlineStartup &&
+						someInIterable(
+							moduleGraph.getIncomingConnectionsByOriginModule(entryModule),
+							([originModule, connections]) =>
+								originModule &&
+								connections.some(c => c.isTargetActive(chunk.runtime)) &&
+								someInIterable(
+									chunkGraph.getModuleRuntimes(originModule),
+									runtime =>
+										intersectRuntime(runtime, chunk.runtime) !== undefined
+								)
+						)
+					) {
+						buf2.push(
+							"// This entry module is referenced by other modules so it can't be inlined"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (
+						result.allowInlineStartup &&
+						(!entryModule.buildInfo ||
+							!entryModule.buildInfo.topLevelDeclarations)
+					) {
+						buf2.push(
+							"// This entry module doesn't tell about it's top-level declarations so it can't be inlined"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (result.allowInlineStartup) {
+						const bailout = hooks.inlineInRuntimeBailout.call(
+							entryModule,
+							renderContext
+						);
+						if (bailout !== undefined) {
+							buf2.push(
+								`// This entry module can't be inlined because ${bailout}`
+							);
+							result.allowInlineStartup = false;
 						}
 					}
-					if (changed) return true;
+					i--;
+					const moduleId = chunkGraph.getModuleId(entryModule);
+					const entryRuntimeRequirements =
+						chunkGraph.getModuleRuntimeRequirements(entryModule, chunk.runtime);
+					let moduleIdExpr = JSON.stringify(moduleId);
+					if (runtimeRequirements.has(RuntimeGlobals.entryModuleId)) {
+						moduleIdExpr = `${RuntimeGlobals.entryModuleId} = ${moduleIdExpr}`;
+					}
+					if (
+						result.allowInlineStartup &&
+						entryRuntimeRequirements.has(RuntimeGlobals.module)
+					) {
+						result.allowInlineStartup = false;
+						buf2.push(
+							"// This entry module used 'module' so it can't be inlined"
+						);
+					}
+					if (chunks.length > 0) {
+						buf2.push(
+							`${i === 0 ? "var __webpack_exports__ = " : ""}${
+								RuntimeGlobals.onChunksLoaded
+							}(undefined, ${JSON.stringify(
+								chunks.map(c => c.id)
+							)}, ${runtimeTemplate.returningFunction(
+								`__webpack_require__(${moduleIdExpr})`
+							)})`
+						);
+					} else if (useRequire) {
+						buf2.push(
+							`${
+								i === 0 ? "var __webpack_exports__ = " : ""
+							}__webpack_require__(${moduleIdExpr});`
+						);
+					} else {
+						if (i === 0) buf2.push("var __webpack_exports__ = {};");
+						if (requireScopeUsed) {
+							buf2.push(
+								`__webpack_modules__[${moduleIdExpr}](0, ${
+									i === 0 ? "__webpack_exports__" : "{}"
+								}, __webpack_require__);`
+							);
+						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
+							buf2.push(
+								`__webpack_modules__[${moduleIdExpr}](0, ${
+									i === 0 ? "__webpack_exports__" : "{}"
+								});`
+							);
+						} else {
+							buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+						}
+					}
+				}
+				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+					buf2.push(
+						`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);`
+					);
+				}
+				if (
+					runtimeRequirements.has(RuntimeGlobals.startup) ||
+					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
+						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))
+				) {
+					result.allowInlineStartup = false;
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
+							...buf2,
+							"return __webpack_exports__;"
+						])};`
+					);
+					buf.push("");
+					startup.push("// run startup");
+					startup.push(
+						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
+					);
+				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+					);
+					beforeStartup.push("// run runtime startup");
+					beforeStartup.push(`${RuntimeGlobals.startup}();`);
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+					);
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+					afterStartup.push("// run runtime startup");
+					afterStartup.push(`${RuntimeGlobals.startup}();`);
+				} else {
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
 				}
+			} else if (
+				runtimeRequirements.has(RuntimeGlobals.startup) ||
+				runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+				runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+			) {
+				buf.push(
+					"// the startup function",
+					"// It's empty as no entry modules are in this chunk",
+					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`,
+					""
+				);
+			}
+		} else if (
+			runtimeRequirements.has(RuntimeGlobals.startup) ||
+			runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+			runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+		) {
+			result.allowInlineStartup = false;
+			buf.push(
+				"// the startup function",
+				"// It's empty as some runtime module handles the default behavior",
+				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
 			);
-		});
+			startup.push("// run startup");
+			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
+		}
+		return result;
+	}
+
+	/**
+	 * @param {RenderBootstrapContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {string} the generated source of the require function
+	 */
+	renderRequire(renderContext, hooks) {
+		const {
+			chunk,
+			chunkGraph,
+			runtimeTemplate: { outputOptions }
+		} = renderContext;
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+		const moduleExecution = runtimeRequirements.has(
+			RuntimeGlobals.interceptModuleExecution
+		)
+			? Template.asString([
+					"var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };",
+					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
+					"module = execOptions.module;",
+					"execOptions.factory.call(module.exports, module, module.exports, execOptions.require);"
+			  ])
+			: runtimeRequirements.has(RuntimeGlobals.thisAsExports)
+			? Template.asString([
+					"__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);"
+			  ])
+			: Template.asString([
+					"__webpack_modules__[moduleId](module, module.exports, __webpack_require__);"
+			  ]);
+		const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
+		const needModuleLoaded = runtimeRequirements.has(
+			RuntimeGlobals.moduleLoaded
+		);
+		const content = Template.asString([
+			"// Check if module is in cache",
+			"var cachedModule = __webpack_module_cache__[moduleId];",
+			"if (cachedModule !== undefined) {",
+			outputOptions.strictModuleErrorHandling
+				? Template.indent([
+						"if (cachedModule.error !== undefined) throw cachedModule.error;",
+						"return cachedModule.exports;"
+				  ])
+				: Template.indent("return cachedModule.exports;"),
+			"}",
+			"// Create a new module (and put it into the cache)",
+			"var module = __webpack_module_cache__[moduleId] = {",
+			Template.indent([
+				needModuleId ? "id: moduleId," : "// no module.id needed",
+				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
+				"exports: {}"
+			]),
+			"};",
+			"",
+			outputOptions.strictModuleExceptionHandling
+				? Template.asString([
+						"// Execute the module function",
+						"var threw = true;",
+						"try {",
+						Template.indent([moduleExecution, "threw = false;"]),
+						"} finally {",
+						Template.indent([
+							"if(threw) delete __webpack_module_cache__[moduleId];"
+						]),
+						"}"
+				  ])
+				: outputOptions.strictModuleErrorHandling
+				? Template.asString([
+						"// Execute the module function",
+						"try {",
+						Template.indent(moduleExecution),
+						"} catch(e) {",
+						Template.indent(["module.error = e;", "throw e;"]),
+						"}"
+				  ])
+				: Template.asString([
+						"// Execute the module function",
+						moduleExecution
+				  ]),
+			needModuleLoaded
+				? Template.asString([
+						"",
+						"// Flag the module as loaded",
+						"module.loaded = true;",
+						""
+				  ])
+				: "",
+			"// Return the exports of the module",
+			"return module.exports;"
+		]);
+		return tryRunOrWebpackError(
+			() => hooks.renderRequire.call(content, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderRequire"
+		);
 	}
 }
-module.exports = LimitChunkCountPlugin;
+
+module.exports = JavascriptModulesPlugin;
+module.exports.chunkHasJs = chunkHasJs;
 
 
 /***/ }),
 
-/***/ 27868:
+/***/ 29050:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -102972,4411 +98297,5257 @@ module.exports = LimitChunkCountPlugin;
 
 
 
-const { UsageState } = __webpack_require__(63686);
-const {
-	numberToIdentifier,
-	NUMBER_OF_IDENTIFIER_START_CHARS,
-	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
-} = __webpack_require__(1626);
-const { assignDeterministicIds } = __webpack_require__(63290);
-const { compareSelect, compareStringsNumeric } = __webpack_require__(29579);
+const { Parser: AcornParser } = __webpack_require__(31988);
+const { importAssertions } = __webpack_require__(72617);
+const { SyncBailHook, HookMap } = __webpack_require__(41242);
+const vm = __webpack_require__(26144);
+const Parser = __webpack_require__(11715);
+const StackedMap = __webpack_require__(58845);
+const binarySearchBounds = __webpack_require__(92229);
+const memoize = __webpack_require__(78676);
+const BasicEvaluatedExpression = __webpack_require__(950);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("acorn").Options} AcornOptions */
+/** @typedef {import("estree").ArrayExpression} ArrayExpressionNode */
+/** @typedef {import("estree").BinaryExpression} BinaryExpressionNode */
+/** @typedef {import("estree").BlockStatement} BlockStatementNode */
+/** @typedef {import("estree").SequenceExpression} SequenceExpressionNode */
+/** @typedef {import("estree").CallExpression} CallExpressionNode */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
+/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
+/** @typedef {import("estree").Comment} CommentNode */
+/** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
+/** @typedef {import("estree").Declaration} DeclarationNode */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Identifier} IdentifierNode */
+/** @typedef {import("estree").IfStatement} IfStatementNode */
+/** @typedef {import("estree").LabeledStatement} LabeledStatementNode */
+/** @typedef {import("estree").Literal} LiteralNode */
+/** @typedef {import("estree").LogicalExpression} LogicalExpressionNode */
+/** @typedef {import("estree").ChainExpression} ChainExpressionNode */
+/** @typedef {import("estree").MemberExpression} MemberExpressionNode */
+/** @typedef {import("estree").MetaProperty} MetaPropertyNode */
+/** @typedef {import("estree").MethodDefinition} MethodDefinitionNode */
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclarationNode */
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("estree").Program} ProgramNode */
+/** @typedef {import("estree").Statement} StatementNode */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
+/** @typedef {import("estree").Super} SuperNode */
+/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
+/** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
+/** @typedef {import("estree").ThisExpression} ThisExpressionNode */
+/** @typedef {import("estree").UnaryExpression} UnaryExpressionNode */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[] }} GetInfoResult */
+
+const EMPTY_ARRAY = [];
+const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
+const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
+const ALLOWED_MEMBER_TYPES_ALL = 0b11;
+
+// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
+
+const parser = AcornParser.extend(importAssertions);
+
+class VariableInfo {
+	/**
+	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
+	 * @param {string | true} freeName which free name the variable aliases, or true when none
+	 * @param {TagInfo | undefined} tagInfo info about tags
+	 */
+	constructor(declaredScope, freeName, tagInfo) {
+		this.declaredScope = declaredScope;
+		this.freeName = freeName;
+		this.tagInfo = tagInfo;
+	}
+}
+
+/** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
+/** @typedef {LiteralNode | string | null | undefined} ImportSource */
+/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
 
 /**
- * @param {ExportsInfo} exportsInfo exports info
- * @returns {boolean} mangle is possible
+ * @typedef {Object} TagInfo
+ * @property {any} tag
+ * @property {any} data
+ * @property {TagInfo | undefined} next
  */
-const canMangle = exportsInfo => {
-	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused)
-		return false;
-	let hasSomethingToMangle = false;
-	for (const exportInfo of exportsInfo.exports) {
-		if (exportInfo.canMangle === true) {
-			hasSomethingToMangle = true;
-		}
-	}
-	return hasSomethingToMangle;
-};
 
-// Sort by name
-const comparator = compareSelect(e => e.name, compareStringsNumeric);
 /**
- * @param {boolean} deterministic use deterministic names
- * @param {ExportsInfo} exportsInfo exports info
- * @param {boolean} isNamespace is namespace object
- * @returns {void}
+ * @typedef {Object} ScopeInfo
+ * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
+ * @property {boolean | "arrow"} topLevelScope
+ * @property {boolean} inShorthand
+ * @property {boolean} isStrict
+ * @property {boolean} isAsmJs
+ * @property {boolean} inTry
  */
-const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
-	if (!canMangle(exportsInfo)) return;
-	const usedNames = new Set();
-	/** @type {ExportInfo[]} */
-	const mangleableExports = [];
 
-	// Avoid to renamed exports that are not provided when
-	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
-	// 2. there are other provided exports and deterministic mode is chosen:
-	//    non-provided exports would break the determinism
-	let avoidMangleNonProvided = !isNamespace;
-	if (!avoidMangleNonProvided && deterministic) {
-		for (const exportInfo of exportsInfo.ownedExports) {
-			if (exportInfo.provided !== false) {
-				avoidMangleNonProvided = true;
-				break;
-			}
-		}
-	}
-	for (const exportInfo of exportsInfo.ownedExports) {
-		const name = exportInfo.name;
-		if (!exportInfo.hasUsedName()) {
-			if (
-				// Can the export be mangled?
-				exportInfo.canMangle !== true ||
-				// Never rename 1 char exports
-				(name.length === 1 && /^[a-zA-Z0-9_$]/.test(name)) ||
-				// Don't rename 2 char exports in deterministic mode
-				(deterministic &&
-					name.length === 2 &&
-					/^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
-				// Don't rename exports that are not provided
-				(avoidMangleNonProvided && exportInfo.provided !== true)
-			) {
-				exportInfo.setUsedName(name);
-				usedNames.add(name);
-			} else {
-				mangleableExports.push(exportInfo);
-			}
-		}
-		if (exportInfo.exportsInfoOwned) {
-			const used = exportInfo.getUsed(undefined);
-			if (
-				used === UsageState.OnlyPropertiesUsed ||
-				used === UsageState.Unused
-			) {
-				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
-			}
-		}
-	}
-	if (deterministic) {
-		assignDeterministicIds(
-			mangleableExports,
-			e => e.name,
-			comparator,
-			(e, id) => {
-				const name = numberToIdentifier(id);
-				const size = usedNames.size;
-				usedNames.add(name);
-				if (size === usedNames.size) return false;
-				e.setUsedName(name);
-				return true;
-			},
-			[
-				NUMBER_OF_IDENTIFIER_START_CHARS,
-				NUMBER_OF_IDENTIFIER_START_CHARS *
-					NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
-			],
-			NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
-			usedNames.size
-		);
-	} else {
-		const usedExports = [];
-		const unusedExports = [];
-		for (const exportInfo of mangleableExports) {
-			if (exportInfo.getUsed(undefined) === UsageState.Unused) {
-				unusedExports.push(exportInfo);
-			} else {
-				usedExports.push(exportInfo);
-			}
-		}
-		usedExports.sort(comparator);
-		unusedExports.sort(comparator);
-		let i = 0;
-		for (const list of [usedExports, unusedExports]) {
-			for (const exportInfo of list) {
-				let name;
-				do {
-					name = numberToIdentifier(i++);
-				} while (usedNames.has(name));
-				exportInfo.setUsedName(name);
-			}
-		}
+const joinRanges = (startRange, endRange) => {
+	if (!endRange) return startRange;
+	if (!startRange) return endRange;
+	return [startRange[0], endRange[1]];
+};
+
+const objectAndMembersToName = (object, membersReversed) => {
+	let name = object;
+	for (let i = membersReversed.length - 1; i >= 0; i--) {
+		name = name + "." + membersReversed[i];
 	}
+	return name;
 };
 
-class MangleExportsPlugin {
-	/**
-	 * @param {boolean} deterministic use deterministic names
-	 */
-	constructor(deterministic) {
-		this._deterministic = deterministic;
+const getRootName = expression => {
+	switch (expression.type) {
+		case "Identifier":
+			return expression.name;
+		case "ThisExpression":
+			return "this";
+		case "MetaProperty":
+			return `${expression.meta.name}.${expression.property.name}`;
+		default:
+			return undefined;
 	}
+};
+
+/** @type {AcornOptions} */
+const defaultParserOptions = {
+	ranges: true,
+	locations: true,
+	ecmaVersion: "latest",
+	sourceType: "module",
+	// https://github.com/tc39/proposal-hashbang
+	allowHashBang: true,
+	onComment: null
+};
+
+// regexp to match at least one "magic comment"
+const webpackCommentRegExp = new RegExp(/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/);
+
+const EMPTY_COMMENT_OPTIONS = {
+	options: null,
+	errors: null
+};
+
+class JavascriptParser extends Parser {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {"module" | "script" | "auto"} sourceType default source type
 	 */
-	apply(compiler) {
-		const { _deterministic: deterministic } = this;
-		compiler.hooks.compilation.tap("MangleExportsPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.optimizeCodeGeneration.tap(
-				"MangleExportsPlugin",
-				modules => {
-					if (compilation.moduleMemCaches) {
-						throw new Error(
-							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
-						);
-					}
-					for (const module of modules) {
-						const isNamespace =
-							module.buildMeta && module.buildMeta.exportsType === "namespace";
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
-					}
-				}
-			);
+	constructor(sourceType = "auto") {
+		super();
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[UnaryExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode | MetaPropertyNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateDefinedIdentifier: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateCallExpressionMember: new HookMap(
+				() => new SyncBailHook(["expression", "param"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
+			isPure: new HookMap(
+				() => new SyncBailHook(["expression", "commentsStartPosition"])
+			),
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			preStatement: new SyncBailHook(["statement"]),
+
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			blockPreStatement: new SyncBailHook(["declaration"]),
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			statement: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
+			statementIf: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classExtendsExpression: new SyncBailHook([
+				"expression",
+				"classDefinition"
+			]),
+			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
+			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyValue: new SyncBailHook([
+				"expression",
+				"element",
+				"classDefinition"
+			]),
+			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
+			label: new HookMap(() => new SyncBailHook(["statement"])),
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
+			import: new SyncBailHook(["statement", "source"]),
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
+			importSpecifier: new SyncBailHook([
+				"statement",
+				"source",
+				"exportName",
+				"identifierName"
+			]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
+			export: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
+			exportImport: new SyncBailHook(["statement", "source"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
+			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
+			exportExpression: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
+			exportSpecifier: new SyncBailHook([
+				"statement",
+				"identifierName",
+				"exportName",
+				"index"
+			]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
+			exportImportSpecifier: new SyncBailHook([
+				"statement",
+				"source",
+				"identifierName",
+				"exportName",
+				"index"
+			]),
+			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			preDeclarator: new SyncBailHook(["declarator", "statement"]),
+			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			declarator: new SyncBailHook(["declarator", "statement"]),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
+			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
+			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression], boolean | void>>} */
+			assign: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression, string[]], boolean | void>>} */
+			assignMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			typeof: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			importCall: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			topLevelAwait: new SyncBailHook(["expression"]),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			call: new HookMap(() => new SyncBailHook(["expression"])),
+			/** Something like "a.b()" */
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode, string[]], boolean | void>>} */
+			callMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** Something like "a.b().c.d" */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			memberChainOfCallMemberChain: new HookMap(
+				() =>
+					new SyncBailHook([
+						"expression",
+						"calleeMembers",
+						"callExpression",
+						"members"
+					])
+			),
+			/** Something like "a.b().c.d()"" */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			callMemberChainOfCallMemberChain: new HookMap(
+				() =>
+					new SyncBailHook([
+						"expression",
+						"calleeMembers",
+						"innerCallExpression",
+						"members"
+					])
+			),
+			/** @type {SyncBailHook<[ChainExpressionNode], boolean | void>} */
+			optionalChaining: new SyncBailHook(["optionalChaining"]),
+			/** @type {HookMap<SyncBailHook<[NewExpressionNode], boolean | void>>} */
+			new: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			expression: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			expressionMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			unhandledExpressionMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			expressionConditionalOperator: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			expressionLogicalOperator: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			program: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			finish: new SyncBailHook(["ast", "comments"])
 		});
+		this.sourceType = sourceType;
+		/** @type {ScopeInfo} */
+		this.scope = undefined;
+		/** @type {ParserState} */
+		this.state = undefined;
+		this.comments = undefined;
+		this.semicolons = undefined;
+		/** @type {(StatementNode|ExpressionNode)[]} */
+		this.statementPath = undefined;
+		this.prevStatement = undefined;
+		this.currentTagData = undefined;
+		this._initializeEvaluating();
 	}
-}
 
-module.exports = MangleExportsPlugin;
+	_initializeEvaluating() {
+		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
+			const expr = /** @type {LiteralNode} */ (_expr);
 
+			switch (typeof expr.value) {
+				case "number":
+					return new BasicEvaluatedExpression()
+						.setNumber(expr.value)
+						.setRange(expr.range);
+				case "bigint":
+					return new BasicEvaluatedExpression()
+						.setBigInt(expr.value)
+						.setRange(expr.range);
+				case "string":
+					return new BasicEvaluatedExpression()
+						.setString(expr.value)
+						.setRange(expr.range);
+				case "boolean":
+					return new BasicEvaluatedExpression()
+						.setBoolean(expr.value)
+						.setRange(expr.range);
+			}
+			if (expr.value === null) {
+				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
+			}
+			if (expr.value instanceof RegExp) {
+				return new BasicEvaluatedExpression()
+					.setRegExp(expr.value)
+					.setRange(expr.range);
+			}
+		});
+		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const callee = expr.callee;
+			if (
+				callee.type !== "Identifier" ||
+				callee.name !== "RegExp" ||
+				expr.arguments.length > 2 ||
+				this.getVariableInfo("RegExp") !== "RegExp"
+			)
+				return;
 
-/***/ }),
+			let regExp, flags;
+			const arg1 = expr.arguments[0];
 
-/***/ 85067:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			if (arg1) {
+				if (arg1.type === "SpreadElement") return;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				const evaluatedRegExp = this.evaluateExpression(arg1);
 
+				if (!evaluatedRegExp) return;
 
+				regExp = evaluatedRegExp.asString();
 
-const { STAGE_BASIC } = __webpack_require__(80057);
-const { runtimeEqual } = __webpack_require__(17156);
+				if (!regExp) return;
+			} else {
+				return new BasicEvaluatedExpression()
+					.setRegExp(new RegExp(""))
+					.setRange(expr.range);
+			}
 
-/** @typedef {import("../Compiler")} Compiler */
+			const arg2 = expr.arguments[1];
 
-class MergeDuplicateChunksPlugin {
-	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"MergeDuplicateChunksPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "MergeDuplicateChunksPlugin",
-						stage: STAGE_BASIC
-					},
-					chunks => {
-						const { chunkGraph, moduleGraph } = compilation;
+			if (arg2) {
+				if (arg2.type === "SpreadElement") return;
 
-						// remember already tested chunks for performance
-						const notDuplicates = new Set();
+				const evaluatedFlags = this.evaluateExpression(arg2);
 
-						// for each chunk
-						for (const chunk of chunks) {
-							// track a Set of all chunk that could be duplicates
-							let possibleDuplicates;
-							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								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 chunkGraph.getModuleChunksIterable(
-										module
-									)) {
-										if (
-											dup !== chunk &&
-											chunkGraph.getNumberOfChunkModules(chunk) ===
-												chunkGraph.getNumberOfChunkModules(dup) &&
-											!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 (!chunkGraph.isModuleInChunk(module, dup)) {
-											possibleDuplicates.delete(dup);
-										}
-									}
-									// when all chunks has been removed we can break here
-									if (possibleDuplicates.size === 0) break;
-								}
-							}
+				if (!evaluatedFlags) return;
 
-							// when we found duplicates
-							if (
-								possibleDuplicates !== undefined &&
-								possibleDuplicates.size > 0
-							) {
-								outer: for (const otherChunk of possibleDuplicates) {
-									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
-									if (chunkGraph.getNumberOfEntryModules(chunk) > 0) continue;
-									if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0)
-										continue;
-									if (!runtimeEqual(chunk.runtime, otherChunk.runtime)) {
-										for (const module of chunkGraph.getChunkModulesIterable(
-											chunk
-										)) {
-											const exportsInfo = moduleGraph.getExportsInfo(module);
-											if (
-												!exportsInfo.isEquallyUsed(
-													chunk.runtime,
-													otherChunk.runtime
-												)
-											) {
-												continue outer;
-											}
-										}
-									}
-									// merge them
-									if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
-										chunkGraph.integrateChunks(chunk, otherChunk);
-										compilation.chunks.delete(otherChunk);
-									}
-								}
-							}
+				if (!evaluatedFlags.isUndefined()) {
+					flags = evaluatedFlags.asString();
 
-							// don't check already processed chunks twice
-							notDuplicates.add(chunk);
-						}
-					}
-				);
+					if (
+						flags === undefined ||
+						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
+					)
+						return;
+				}
 			}
-		);
-	}
-}
-module.exports = MergeDuplicateChunksPlugin;
 
+			return new BasicEvaluatedExpression()
+				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
+				.setRange(expr.range);
+		});
+		this.hooks.evaluate
+			.for("LogicalExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {LogicalExpressionNode} */ (_expr);
 
-/***/ }),
+				const left = this.evaluateExpression(expr.left);
+				if (!left) return;
+				let returnRight = false;
+				/** @type {boolean|undefined} */
+				let allowedRight;
+				if (expr.operator === "&&") {
+					const leftAsBool = left.asBool();
+					if (leftAsBool === false) return left.setRange(expr.range);
+					returnRight = leftAsBool === true;
+					allowedRight = false;
+				} else if (expr.operator === "||") {
+					const leftAsBool = left.asBool();
+					if (leftAsBool === true) return left.setRange(expr.range);
+					returnRight = leftAsBool === false;
+					allowedRight = true;
+				} else if (expr.operator === "??") {
+					const leftAsNullish = left.asNullish();
+					if (leftAsNullish === false) return left.setRange(expr.range);
+					if (leftAsNullish !== true) return;
+					returnRight = true;
+				} else return;
+				const right = this.evaluateExpression(expr.right);
+				if (!right) return;
+				if (returnRight) {
+					if (left.couldHaveSideEffects()) right.setSideEffects();
+					return right.setRange(expr.range);
+				}
 
-/***/ 53912:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				const asBool = right.asBool();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				if (allowedRight === true && asBool === true) {
+					return new BasicEvaluatedExpression()
+						.setRange(expr.range)
+						.setTruthy();
+				} else if (allowedRight === false && asBool === false) {
+					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
+				}
+			});
 
+		const valueAsExpression = (value, expr, sideEffects) => {
+			switch (typeof value) {
+				case "boolean":
+					return new BasicEvaluatedExpression()
+						.setBoolean(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "number":
+					return new BasicEvaluatedExpression()
+						.setNumber(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "bigint":
+					return new BasicEvaluatedExpression()
+						.setBigInt(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "string":
+					return new BasicEvaluatedExpression()
+						.setString(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+			}
+		};
 
+		this.hooks.evaluate
+			.for("BinaryExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {BinaryExpressionNode} */ (_expr);
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const createSchemaValidation = __webpack_require__(32540);
+				const handleConstOperation = fn => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left || !left.isCompileTimeValue()) return;
 
-/** @typedef {import("../../declarations/plugins/optimize/MinChunkSizePlugin").MinChunkSizePluginOptions} MinChunkSizePluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+					const right = this.evaluateExpression(expr.right);
+					if (!right || !right.isCompileTimeValue()) return;
 
-const validate = createSchemaValidation(
-	__webpack_require__(60135),
-	() => __webpack_require__(53850),
-	{
-		name: "Min Chunk Size Plugin",
-		baseDataPath: "options"
-	}
-);
+					const result = fn(
+						left.asCompileTimeValue(),
+						right.asCompileTimeValue()
+					);
+					return valueAsExpression(
+						result,
+						expr,
+						left.couldHaveSideEffects() || right.couldHaveSideEffects()
+					);
+				};
 
-class MinChunkSizePlugin {
-	/**
-	 * @param {MinChunkSizePluginOptions} options options object
-	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
-	}
+				const isAlwaysDifferent = (a, b) =>
+					(a === true && b === false) || (a === false && b === true);
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const options = this.options;
-		const minChunkSize = options.minChunkSize;
-		compiler.hooks.compilation.tap("MinChunkSizePlugin", compilation => {
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "MinChunkSizePlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					const equalOptions = {
-						chunkOverhead: 1,
-						entryChunkMultiplicator: 1
+				const handleTemplateStringCompare = (left, right, res, eql) => {
+					const getPrefix = parts => {
+						let value = "";
+						for (const p of parts) {
+							const v = p.asString();
+							if (v !== undefined) value += v;
+							else break;
+						}
+						return value;
 					};
-
-					const chunkSizesMap = new Map();
-					/** @type {[Chunk, Chunk][]} */
-					const combinations = [];
-					/** @type {Chunk[]} */
-					const smallChunks = [];
-					const visitedChunks = [];
-					for (const a of chunks) {
-						// check if one of the chunks sizes is smaller than the minChunkSize
-						// and filter pairs that can NOT be integrated!
-						if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
-							smallChunks.push(a);
-							for (const b of visitedChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
-									combinations.push([b, a]);
-							}
-						} else {
-							for (const b of smallChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
-									combinations.push([b, a]);
-							}
+					const getSuffix = parts => {
+						let value = "";
+						for (let i = parts.length - 1; i >= 0; i--) {
+							const v = parts[i].asString();
+							if (v !== undefined) value = v + value;
+							else break;
 						}
-						chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
-						visitedChunks.push(a);
-					}
-
-					const sortedSizeFilteredExtendedPairCombinations = combinations
-						.map(pair => {
-							// extend combination pairs with size and integrated size
-							const a = chunkSizesMap.get(pair[0]);
-							const b = chunkSizesMap.get(pair[1]);
-							const ab = chunkGraph.getIntegratedChunksSize(
-								pair[0],
-								pair[1],
-								options
+						return value;
+					};
+					const leftPrefix = getPrefix(left.parts);
+					const rightPrefix = getPrefix(right.parts);
+					const leftSuffix = getSuffix(left.parts);
+					const rightSuffix = getSuffix(right.parts);
+					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
+					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
+					if (
+						leftPrefix.slice(0, lenPrefix) !==
+							rightPrefix.slice(0, lenPrefix) ||
+						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
+					) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
 							);
-							/** @type {[number, number, Chunk, Chunk]} */
-							const extendedPair = [a + b - ab, ab, pair[0], pair[1]];
-							return extendedPair;
-						})
-						.sort((a, b) => {
-							// sadly javascript does an in place 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];
-
-					chunkGraph.integrateChunks(pair[2], pair[3]);
-					compilation.chunks.delete(pair[3]);
-					return true;
-				}
-			);
-		});
-	}
-}
-module.exports = MinChunkSizePlugin;
-
-
-/***/ }),
-
-/***/ 85305:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const SizeFormatHelpers = __webpack_require__(71070);
-const WebpackError = __webpack_require__(53799);
-
-class MinMaxSizeWarning extends WebpackError {
-	constructor(keys, minSize, maxSize) {
-		let keysMessage = "Fallback cache group";
-		if (keys) {
-			keysMessage =
-				keys.length > 1
-					? `Cache groups ${keys.sort().join(", ")}`
-					: `Cache group ${keys[0]}`;
-		}
-		super(
-			`SplitChunksPlugin\n` +
-				`${keysMessage}\n` +
-				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
-				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
-				"This seem to be a invalid optimization.splitChunks configuration."
-		);
-	}
-}
+					}
+				};
 
-module.exports = MinMaxSizeWarning;
+				const handleStrictEqualityComparison = eql => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					res.setRange(expr.range);
 
+					const leftConst = left.isCompileTimeValue();
+					const rightConst = right.isCompileTimeValue();
 
-/***/ }),
+					if (leftConst && rightConst) {
+						return res
+							.setBoolean(
+								eql ===
+									(left.asCompileTimeValue() === right.asCompileTimeValue())
+							)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
 
-/***/ 74844:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					if (left.isArray() && right.isArray()) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+					if (left.isTemplateString() && right.isTemplateString()) {
+						return handleTemplateStringCompare(left, right, res, eql);
+					}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					const leftPrimitive = left.isPrimitiveType();
+					const rightPrimitive = right.isPrimitiveType();
 
+					if (
+						// Primitive !== Object or
+						// compile-time object types are never equal to something at runtime
+						(leftPrimitive === false &&
+							(leftConst || rightPrimitive === true)) ||
+						(rightPrimitive === false &&
+							(rightConst || leftPrimitive === true)) ||
+						// Different nullish or boolish status also means not equal
+						isAlwaysDifferent(left.asBool(), right.asBool()) ||
+						isAlwaysDifferent(left.asNullish(), right.asNullish())
+					) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+				};
 
+				const handleAbstractEqualityComparison = eql => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					res.setRange(expr.range);
 
-const asyncLib = __webpack_require__(78175);
-const ChunkGraph = __webpack_require__(64971);
-const ModuleGraph = __webpack_require__(99988);
-const { STAGE_DEFAULT } = __webpack_require__(80057);
-const HarmonyImportDependency = __webpack_require__(57154);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const {
-	intersectRuntime,
-	mergeRuntimeOwned,
-	filterRuntime,
-	runtimeToString,
-	mergeRuntime
-} = __webpack_require__(17156);
-const ConcatenatedModule = __webpack_require__(97198);
+					const leftConst = left.isCompileTimeValue();
+					const rightConst = right.isCompileTimeValue();
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+					if (leftConst && rightConst) {
+						return res
+							.setBoolean(
+								eql ===
+									// eslint-disable-next-line eqeqeq
+									(left.asCompileTimeValue() == right.asCompileTimeValue())
+							)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
 
-/**
- * @typedef {Object} Statistics
- * @property {number} cached
- * @property {number} alreadyInConfig
- * @property {number} invalidModule
- * @property {number} incorrectChunks
- * @property {number} incorrectDependency
- * @property {number} incorrectModuleDependency
- * @property {number} incorrectChunksOfImporter
- * @property {number} incorrectRuntimeCondition
- * @property {number} importerFailed
- * @property {number} added
- */
+					if (left.isArray() && right.isArray()) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+					if (left.isTemplateString() && right.isTemplateString()) {
+						return handleTemplateStringCompare(left, right, res, eql);
+					}
+				};
 
-const formatBailoutReason = msg => {
-	return "ModuleConcatenation bailout: " + msg;
-};
+				if (expr.operator === "+") {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					if (left.isString()) {
+						if (right.isString()) {
+							res.setString(left.string + right.string);
+						} else if (right.isNumber()) {
+							res.setString(left.string + right.number);
+						} else if (
+							right.isWrapped() &&
+							right.prefix &&
+							right.prefix.isString()
+						) {
+							// "left" + ("prefix" + inner + "postfix")
+							// => ("leftPrefix" + inner + "postfix")
+							res.setWrapped(
+								new BasicEvaluatedExpression()
+									.setString(left.string + right.prefix.string)
+									.setRange(joinRanges(left.range, right.prefix.range)),
+								right.postfix,
+								right.wrappedInnerExpressions
+							);
+						} else if (right.isWrapped()) {
+							// "left" + ([null] + inner + "postfix")
+							// => ("left" + inner + "postfix")
+							res.setWrapped(
+								left,
+								right.postfix,
+								right.wrappedInnerExpressions
+							);
+						} else {
+							// "left" + expr
+							// => ("left" + expr + "")
+							res.setWrapped(left, null, [right]);
+						}
+					} else if (left.isNumber()) {
+						if (right.isString()) {
+							res.setString(left.number + right.string);
+						} else if (right.isNumber()) {
+							res.setNumber(left.number + right.number);
+						} else {
+							return;
+						}
+					} else if (left.isBigInt()) {
+						if (right.isBigInt()) {
+							res.setBigInt(left.bigint + right.bigint);
+						}
+					} else if (left.isWrapped()) {
+						if (left.postfix && left.postfix.isString() && right.isString()) {
+							// ("prefix" + inner + "postfix") + "right"
+							// => ("prefix" + inner + "postfixRight")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(left.postfix.string + right.string)
+									.setRange(joinRanges(left.postfix.range, right.range)),
+								left.wrappedInnerExpressions
+							);
+						} else if (
+							left.postfix &&
+							left.postfix.isString() &&
+							right.isNumber()
+						) {
+							// ("prefix" + inner + "postfix") + 123
+							// => ("prefix" + inner + "postfix123")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(left.postfix.string + right.number)
+									.setRange(joinRanges(left.postfix.range, right.range)),
+								left.wrappedInnerExpressions
+							);
+						} else if (right.isString()) {
+							// ("prefix" + inner + [null]) + "right"
+							// => ("prefix" + inner + "right")
+							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
+						} else if (right.isNumber()) {
+							// ("prefix" + inner + [null]) + 123
+							// => ("prefix" + inner + "123")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(right.number + "")
+									.setRange(right.range),
+								left.wrappedInnerExpressions
+							);
+						} else if (right.isWrapped()) {
+							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
+							res.setWrapped(
+								left.prefix,
+								right.postfix,
+								left.wrappedInnerExpressions &&
+									right.wrappedInnerExpressions &&
+									left.wrappedInnerExpressions
+										.concat(left.postfix ? [left.postfix] : [])
+										.concat(right.prefix ? [right.prefix] : [])
+										.concat(right.wrappedInnerExpressions)
+							);
+						} else {
+							// ("prefix" + inner + postfix) + expr
+							// => ("prefix" + inner + postfix + expr + [null])
+							res.setWrapped(
+								left.prefix,
+								null,
+								left.wrappedInnerExpressions &&
+									left.wrappedInnerExpressions.concat(
+										left.postfix ? [left.postfix, right] : [right]
+									)
+							);
+						}
+					} else {
+						if (right.isString()) {
+							// left + "right"
+							// => ([null] + left + "right")
+							res.setWrapped(null, right, [left]);
+						} else if (right.isWrapped()) {
+							// left + (prefix + inner + "postfix")
+							// => ([null] + left + prefix + inner + "postfix")
+							res.setWrapped(
+								null,
+								right.postfix,
+								right.wrappedInnerExpressions &&
+									(right.prefix ? [left, right.prefix] : [left]).concat(
+										right.wrappedInnerExpressions
+									)
+							);
+						} else {
+							return;
+						}
+					}
+					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
+						res.setSideEffects();
+					res.setRange(expr.range);
+					return res;
+				} else if (expr.operator === "-") {
+					return handleConstOperation((l, r) => l - r);
+				} else if (expr.operator === "*") {
+					return handleConstOperation((l, r) => l * r);
+				} else if (expr.operator === "/") {
+					return handleConstOperation((l, r) => l / r);
+				} else if (expr.operator === "**") {
+					return handleConstOperation((l, r) => l ** r);
+				} else if (expr.operator === "===") {
+					return handleStrictEqualityComparison(true);
+				} else if (expr.operator === "==") {
+					return handleAbstractEqualityComparison(true);
+				} else if (expr.operator === "!==") {
+					return handleStrictEqualityComparison(false);
+				} else if (expr.operator === "!=") {
+					return handleAbstractEqualityComparison(false);
+				} else if (expr.operator === "&") {
+					return handleConstOperation((l, r) => l & r);
+				} else if (expr.operator === "|") {
+					return handleConstOperation((l, r) => l | r);
+				} else if (expr.operator === "^") {
+					return handleConstOperation((l, r) => l ^ r);
+				} else if (expr.operator === ">>>") {
+					return handleConstOperation((l, r) => l >>> r);
+				} else if (expr.operator === ">>") {
+					return handleConstOperation((l, r) => l >> r);
+				} else if (expr.operator === "<<") {
+					return handleConstOperation((l, r) => l << r);
+				} else if (expr.operator === "<") {
+					return handleConstOperation((l, r) => l < r);
+				} else if (expr.operator === ">") {
+					return handleConstOperation((l, r) => l > r);
+				} else if (expr.operator === "<=") {
+					return handleConstOperation((l, r) => l <= r);
+				} else if (expr.operator === ">=") {
+					return handleConstOperation((l, r) => l >= r);
+				}
+			});
+		this.hooks.evaluate
+			.for("UnaryExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {UnaryExpressionNode} */ (_expr);
 
-class ModuleConcatenationPlugin {
-	constructor(options) {
-		if (typeof options !== "object") options = {};
-		this.options = options;
-	}
+				const handleConstOperation = fn => {
+					const argument = this.evaluateExpression(expr.argument);
+					if (!argument || !argument.isCompileTimeValue()) return;
+					const result = fn(argument.asCompileTimeValue());
+					return valueAsExpression(
+						result,
+						expr,
+						argument.couldHaveSideEffects()
+					);
+				};
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { _backCompat: backCompat } = compiler;
-		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			const bailoutReasonMap = new Map();
+				if (expr.operator === "typeof") {
+					switch (expr.argument.type) {
+						case "Identifier": {
+							const res = this.callHooksForName(
+								this.hooks.evaluateTypeof,
+								expr.argument.name,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "MetaProperty": {
+							const res = this.callHooksForName(
+								this.hooks.evaluateTypeof,
+								getRootName(expr.argument),
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "MemberExpression": {
+							const res = this.callHooksForExpression(
+								this.hooks.evaluateTypeof,
+								expr.argument,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "ChainExpression": {
+							const res = this.callHooksForExpression(
+								this.hooks.evaluateTypeof,
+								expr.argument.expression,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "FunctionExpression": {
+							return new BasicEvaluatedExpression()
+								.setString("function")
+								.setRange(expr.range);
+						}
+					}
+					const arg = this.evaluateExpression(expr.argument);
+					if (arg.isUnknown()) return;
+					if (arg.isString()) {
+						return new BasicEvaluatedExpression()
+							.setString("string")
+							.setRange(expr.range);
+					}
+					if (arg.isWrapped()) {
+						return new BasicEvaluatedExpression()
+							.setString("string")
+							.setSideEffects()
+							.setRange(expr.range);
+					}
+					if (arg.isUndefined()) {
+						return new BasicEvaluatedExpression()
+							.setString("undefined")
+							.setRange(expr.range);
+					}
+					if (arg.isNumber()) {
+						return new BasicEvaluatedExpression()
+							.setString("number")
+							.setRange(expr.range);
+					}
+					if (arg.isBigInt()) {
+						return new BasicEvaluatedExpression()
+							.setString("bigint")
+							.setRange(expr.range);
+					}
+					if (arg.isBoolean()) {
+						return new BasicEvaluatedExpression()
+							.setString("boolean")
+							.setRange(expr.range);
+					}
+					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
+						return new BasicEvaluatedExpression()
+							.setString("object")
+							.setRange(expr.range);
+					}
+					if (arg.isArray()) {
+						return new BasicEvaluatedExpression()
+							.setString("object")
+							.setSideEffects(arg.couldHaveSideEffects())
+							.setRange(expr.range);
+					}
+				} else if (expr.operator === "!") {
+					const argument = this.evaluateExpression(expr.argument);
+					if (!argument) return;
+					const bool = argument.asBool();
+					if (typeof bool !== "boolean") return;
+					return new BasicEvaluatedExpression()
+						.setBoolean(!bool)
+						.setSideEffects(argument.couldHaveSideEffects())
+						.setRange(expr.range);
+				} else if (expr.operator === "~") {
+					return handleConstOperation(v => ~v);
+				} else if (expr.operator === "+") {
+					return handleConstOperation(v => +v);
+				} else if (expr.operator === "-") {
+					return handleConstOperation(v => -v);
+				}
+			});
+		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
+			return new BasicEvaluatedExpression()
+				.setString("undefined")
+				.setRange(expr.range);
+		});
+		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
+				return new BasicEvaluatedExpression()
+					.setUndefined()
+					.setRange(expr.range);
+			}
+		});
+		/**
+		 * @param {string} exprType expression type name
+		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
+		 * @returns {void}
+		 */
+		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
+			/** @type {ExpressionNode | undefined} */
+			let cachedExpression = undefined;
+			/** @type {GetInfoResult | undefined} */
+			let cachedInfo = undefined;
+			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
+				const expression = /** @type {MemberExpressionNode} */ (expr);
 
-			const setBailoutReason = (module, reason) => {
-				setInnerBailoutReason(module, reason);
-				moduleGraph
-					.getOptimizationBailout(module)
-					.push(
-						typeof reason === "function"
-							? rs => formatBailoutReason(reason(rs))
-							: formatBailoutReason(reason)
+				const info = getInfo(expr);
+				if (info !== undefined) {
+					return this.callHooksForInfoWithFallback(
+						this.hooks.evaluateIdentifier,
+						info.name,
+						name => {
+							cachedExpression = expression;
+							cachedInfo = info;
+						},
+						name => {
+							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
+							if (hook !== undefined) {
+								return hook.call(expression);
+							}
+						},
+						expression
 					);
-			};
+				}
+			});
+			this.hooks.evaluate
+				.for(exprType)
+				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
+					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
+					if (info !== undefined) {
+						return new BasicEvaluatedExpression()
+							.setIdentifier(info.name, info.rootInfo, info.getMembers)
+							.setRange(expr.range);
+					}
+				});
+			this.hooks.finish.tap("JavascriptParser", () => {
+				// Cleanup for GC
+				cachedExpression = cachedInfo = undefined;
+			});
+		};
+		tapEvaluateWithVariableInfo("Identifier", expr => {
+			const info = this.getVariableInfo(
+				/** @type {IdentifierNode} */ (expr).name
+			);
+			if (
+				typeof info === "string" ||
+				(info instanceof VariableInfo && typeof info.freeName === "string")
+			) {
+				return { name: info, rootInfo: info, getMembers: () => [] };
+			}
+		});
+		tapEvaluateWithVariableInfo("ThisExpression", expr => {
+			const info = this.getVariableInfo("this");
+			if (
+				typeof info === "string" ||
+				(info instanceof VariableInfo && typeof info.freeName === "string")
+			) {
+				return { name: info, rootInfo: info, getMembers: () => [] };
+			}
+		});
+		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
+			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
+
+			return this.callHooksForName(
+				this.hooks.evaluateIdentifier,
+				getRootName(expr),
+				metaProperty
+			);
+		});
+		tapEvaluateWithVariableInfo("MemberExpression", expr =>
+			this.getMemberExpressionInfo(
+				/** @type {MemberExpressionNode} */ (expr),
+				ALLOWED_MEMBER_TYPES_EXPRESSION
+			)
+		);
 
-			const setInnerBailoutReason = (module, reason) => {
-				bailoutReasonMap.set(module, reason);
-			};
+		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
+			const expr = /** @type {CallExpressionNode} */ (_expr);
+			if (
+				expr.callee.type !== "MemberExpression" ||
+				expr.callee.property.type !==
+					(expr.callee.computed ? "Literal" : "Identifier")
+			) {
+				return;
+			}
 
-			const getInnerBailoutReason = (module, requestShortener) => {
-				const reason = bailoutReasonMap.get(module);
-				if (typeof reason === "function") return reason(requestShortener);
-				return reason;
-			};
+			// type Super also possible here
+			const param = this.evaluateExpression(
+				/** @type {ExpressionNode} */ (expr.callee.object)
+			);
+			if (!param) return;
+			const property =
+				expr.callee.property.type === "Literal"
+					? `${expr.callee.property.value}`
+					: expr.callee.property.name;
+			const hook = this.hooks.evaluateCallExpressionMember.get(property);
+			if (hook !== undefined) {
+				return hook.call(expr, param);
+			}
+		});
+		this.hooks.evaluateCallExpressionMember
+			.for("indexOf")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length === 0) return;
+				const [arg1, arg2] = expr.arguments;
+				if (arg1.type === "SpreadElement") return;
+				const arg1Eval = this.evaluateExpression(arg1);
+				if (!arg1Eval.isString()) return;
+				const arg1Value = arg1Eval.string;
 
-			const formatBailoutWarning = (module, problem) => requestShortener => {
-				if (typeof problem === "function") {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)}: ${problem(requestShortener)}`
-					);
-				}
-				const reason = getInnerBailoutReason(module, requestShortener);
-				const reasonWithPrefix = reason ? `: ${reason}` : "";
-				if (module === problem) {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)}${reasonWithPrefix}`
-					);
+				let result;
+				if (arg2) {
+					if (arg2.type === "SpreadElement") return;
+					const arg2Eval = this.evaluateExpression(arg2);
+					if (!arg2Eval.isNumber()) return;
+					result = param.string.indexOf(arg1Value, arg2Eval.number);
 				} else {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)} because of ${problem.readableIdentifier(
-							requestShortener
-						)}${reasonWithPrefix}`
-					);
+					result = param.string.indexOf(arg1Value);
 				}
-			};
-
-			compilation.hooks.optimizeChunkModules.tapAsync(
-				{
-					name: "ModuleConcatenationPlugin",
-					stage: STAGE_DEFAULT
-				},
-				(allChunks, modules, callback) => {
-					const logger = compilation.getLogger(
-						"webpack.ModuleConcatenationPlugin"
-					);
-					const { chunkGraph, moduleGraph } = compilation;
-					const relevantModules = [];
-					const possibleInners = new Set();
-					const context = {
-						chunkGraph,
-						moduleGraph
-					};
-					logger.time("select relevant modules");
-					for (const module of modules) {
-						let canBeRoot = true;
-						let canBeInner = true;
-
-						const bailoutReason = module.getConcatenationBailoutReason(context);
-						if (bailoutReason) {
-							setBailoutReason(module, bailoutReason);
-							continue;
-						}
-
-						// Must not be an async module
-						if (moduleGraph.isAsync(module)) {
-							setBailoutReason(module, `Module is async`);
-							continue;
+				return new BasicEvaluatedExpression()
+					.setNumber(result)
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		this.hooks.evaluateCallExpressionMember
+			.for("replace")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length !== 2) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				if (expr.arguments[1].type === "SpreadElement") return;
+				let arg1 = this.evaluateExpression(expr.arguments[0]);
+				let arg2 = this.evaluateExpression(expr.arguments[1]);
+				if (!arg1.isString() && !arg1.isRegExp()) return;
+				const arg1Value = arg1.regExp || arg1.string;
+				if (!arg2.isString()) return;
+				const arg2Value = arg2.string;
+				return new BasicEvaluatedExpression()
+					.setString(param.string.replace(arg1Value, arg2Value))
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		["substr", "substring", "slice"].forEach(fn => {
+			this.hooks.evaluateCallExpressionMember
+				.for(fn)
+				.tap("JavascriptParser", (expr, param) => {
+					if (!param.isString()) return;
+					let arg1;
+					let result,
+						str = param.string;
+					switch (expr.arguments.length) {
+						case 1:
+							if (expr.arguments[0].type === "SpreadElement") return;
+							arg1 = this.evaluateExpression(expr.arguments[0]);
+							if (!arg1.isNumber()) return;
+							result = str[fn](arg1.number);
+							break;
+						case 2: {
+							if (expr.arguments[0].type === "SpreadElement") return;
+							if (expr.arguments[1].type === "SpreadElement") return;
+							arg1 = this.evaluateExpression(expr.arguments[0]);
+							const arg2 = this.evaluateExpression(expr.arguments[1]);
+							if (!arg1.isNumber()) return;
+							if (!arg2.isNumber()) return;
+							result = str[fn](arg1.number, arg2.number);
+							break;
 						}
+						default:
+							return;
+					}
+					return new BasicEvaluatedExpression()
+						.setString(result)
+						.setSideEffects(param.couldHaveSideEffects())
+						.setRange(expr.range);
+				});
+		});
 
-						// Must be in strict mode
-						if (!module.buildInfo.strict) {
-							setBailoutReason(module, `Module is not in strict mode`);
-							continue;
-						}
+		/**
+		 * @param {"cooked" | "raw"} kind kind of values to get
+		 * @param {TemplateLiteralNode} templateLiteralExpr TemplateLiteral expr
+		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
+		 */
+		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
+			/** @type {BasicEvaluatedExpression[]} */
+			const quasis = [];
+			/** @type {BasicEvaluatedExpression[]} */
+			const parts = [];
 
-						// Module must be in any chunk (we don't want to do useless work)
-						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
-							setBailoutReason(module, "Module is not in any chunk");
-							continue;
-						}
+			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
+				const quasiExpr = templateLiteralExpr.quasis[i];
+				const quasi = quasiExpr.value[kind];
 
-						// Exports must be known (and not dynamic)
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						const relevantExports = exportsInfo.getRelevantExports(undefined);
-						const unknownReexports = relevantExports.filter(exportInfo => {
-							return (
-								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
-							);
-						});
-						if (unknownReexports.length > 0) {
-							setBailoutReason(
-								module,
-								`Reexports in this module do not have a static target (${Array.from(
-									unknownReexports,
-									exportInfo =>
-										`${
-											exportInfo.name || "other exports"
-										}: ${exportInfo.getUsedInfo()}`
-								).join(", ")})`
-							);
-							continue;
-						}
+				if (i > 0) {
+					const prevExpr = parts[parts.length - 1];
+					const expr = this.evaluateExpression(
+						templateLiteralExpr.expressions[i - 1]
+					);
+					const exprAsString = expr.asString();
+					if (
+						typeof exprAsString === "string" &&
+						!expr.couldHaveSideEffects()
+					) {
+						// We can merge quasi + expr + quasi when expr
+						// is a const string
 
-						// Root modules must have a static list of exports
-						const unknownProvidedExports = relevantExports.filter(
-							exportInfo => {
-								return exportInfo.provided !== true;
-							}
-						);
-						if (unknownProvidedExports.length > 0) {
-							setBailoutReason(
-								module,
-								`List of module exports is dynamic (${Array.from(
-									unknownProvidedExports,
-									exportInfo =>
-										`${
-											exportInfo.name || "other exports"
-										}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
-								).join(", ")})`
-							);
-							canBeRoot = false;
-						}
+						prevExpr.setString(prevExpr.string + exprAsString + quasi);
+						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						// We unset the expression as it doesn't match to a single expression
+						prevExpr.setExpression(undefined);
+						continue;
+					}
+					parts.push(expr);
+				}
 
-						// Module must not be an entry point
-						if (chunkGraph.isEntryModule(module)) {
-							setInnerBailoutReason(module, "Module is an entry point");
-							canBeInner = false;
-						}
+				const part = new BasicEvaluatedExpression()
+					.setString(quasi)
+					.setRange(quasiExpr.range)
+					.setExpression(quasiExpr);
+				quasis.push(part);
+				parts.push(part);
+			}
+			return {
+				quasis,
+				parts
+			};
+		};
 
-						if (canBeRoot) relevantModules.push(module);
-						if (canBeInner) possibleInners.add(module);
-					}
-					logger.timeEnd("select relevant modules");
-					logger.debug(
-						`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
-					);
-					// sort by depth
-					// modules with lower depth are more likely suited as roots
-					// this improves performance, because modules already selected as inner are skipped
-					logger.time("sort relevant modules");
-					relevantModules.sort((a, b) => {
-						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
-					});
-					logger.timeEnd("sort relevant modules");
+		this.hooks.evaluate
+			.for("TemplateLiteral")
+			.tap("JavascriptParser", _node => {
+				const node = /** @type {TemplateLiteralNode} */ (_node);
 
-					/** @type {Statistics} */
-					const stats = {
-						cached: 0,
-						alreadyInConfig: 0,
-						invalidModule: 0,
-						incorrectChunks: 0,
-						incorrectDependency: 0,
-						incorrectModuleDependency: 0,
-						incorrectChunksOfImporter: 0,
-						incorrectRuntimeCondition: 0,
-						importerFailed: 0,
-						added: 0
-					};
-					let statsCandidates = 0;
-					let statsSizeSum = 0;
-					let statsEmptyConfigurations = 0;
+				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
+				if (parts.length === 1) {
+					return parts[0].setRange(node.range);
+				}
+				return new BasicEvaluatedExpression()
+					.setTemplateString(quasis, parts, "cooked")
+					.setRange(node.range);
+			});
+		this.hooks.evaluate
+			.for("TaggedTemplateExpression")
+			.tap("JavascriptParser", _node => {
+				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
+				const tag = this.evaluateExpression(node.tag);
 
-					logger.time("find modules to concatenate");
-					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
-						// TODO reconsider that when it's only used in a different runtime
-						if (usedAsInner.has(currentRoot)) continue;
+				if (tag.isIdentifier() && tag.identifier === "String.raw") {
+					const { quasis, parts } = getSimplifiedTemplateResult(
+						"raw",
+						node.quasi
+					);
+					return new BasicEvaluatedExpression()
+						.setTemplateString(quasis, parts, "raw")
+						.setRange(node.range);
+				}
+			});
 
-						let chunkRuntime = undefined;
-						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
-							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
-						}
-						const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
-						const filteredRuntime = filterRuntime(chunkRuntime, r =>
-							exportsInfo.isModuleUsed(r)
-						);
-						const activeRuntime =
-							filteredRuntime === true
-								? chunkRuntime
-								: filteredRuntime === false
-								? undefined
-								: filteredRuntime;
+		this.hooks.evaluateCallExpressionMember
+			.for("concat")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString() && !param.isWrapped()) return;
 
-						// create a configuration with the root
-						const currentConfiguration = new ConcatConfiguration(
-							currentRoot,
-							activeRuntime
-						);
+				let stringSuffix = null;
+				let hasUnknownParams = false;
+				const innerExpressions = [];
+				for (let i = expr.arguments.length - 1; i >= 0; i--) {
+					const arg = expr.arguments[i];
+					if (arg.type === "SpreadElement") return;
+					const argExpr = this.evaluateExpression(arg);
+					if (
+						hasUnknownParams ||
+						(!argExpr.isString() && !argExpr.isNumber())
+					) {
+						hasUnknownParams = true;
+						innerExpressions.push(argExpr);
+						continue;
+					}
 
-						// cache failures to add modules
-						const failureCache = new Map();
+					const value = argExpr.isString()
+						? argExpr.string
+						: "" + argExpr.number;
 
-						// potential optional import candidates
-						/** @type {Set<Module>} */
-						const candidates = new Set();
+					const newString = value + (stringSuffix ? stringSuffix.string : "");
+					const newRange = [
+						argExpr.range[0],
+						(stringSuffix || argExpr).range[1]
+					];
+					stringSuffix = new BasicEvaluatedExpression()
+						.setString(newString)
+						.setSideEffects(
+							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+								argExpr.couldHaveSideEffects()
+						)
+						.setRange(newRange);
+				}
 
-						// try to add all imports
-						for (const imp of this._getImports(
-							compilation,
-							currentRoot,
-							activeRuntime
-						)) {
-							candidates.add(imp);
-						}
+				if (hasUnknownParams) {
+					const prefix = param.isString() ? param : param.prefix;
+					const inner =
+						param.isWrapped() && param.wrappedInnerExpressions
+							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+							: innerExpressions.reverse();
+					return new BasicEvaluatedExpression()
+						.setWrapped(prefix, stringSuffix, inner)
+						.setRange(expr.range);
+				} else if (param.isWrapped()) {
+					const postfix = stringSuffix || param.postfix;
+					const inner = param.wrappedInnerExpressions
+						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+						: innerExpressions.reverse();
+					return new BasicEvaluatedExpression()
+						.setWrapped(param.prefix, postfix, inner)
+						.setRange(expr.range);
+				} else {
+					const newString =
+						param.string + (stringSuffix ? stringSuffix.string : "");
+					return new BasicEvaluatedExpression()
+						.setString(newString)
+						.setSideEffects(
+							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+								param.couldHaveSideEffects()
+						)
+						.setRange(expr.range);
+				}
+			});
+		this.hooks.evaluateCallExpressionMember
+			.for("split")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length !== 1) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				let result;
+				const arg = this.evaluateExpression(expr.arguments[0]);
+				if (arg.isString()) {
+					result = param.string.split(arg.string);
+				} else if (arg.isRegExp()) {
+					result = param.string.split(arg.regExp);
+				} else {
+					return;
+				}
+				return new BasicEvaluatedExpression()
+					.setArray(result)
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		this.hooks.evaluate
+			.for("ConditionalExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ConditionalExpressionNode} */ (_expr);
 
-						for (const imp of candidates) {
-							const impCandidates = new Set();
-							const problem = this._tryToAdd(
-								compilation,
-								currentConfiguration,
-								imp,
-								chunkRuntime,
-								activeRuntime,
-								possibleInners,
-								impCandidates,
-								failureCache,
-								chunkGraph,
-								true,
-								stats
-							);
-							if (problem) {
-								failureCache.set(imp, problem);
-								currentConfiguration.addWarning(imp, problem);
-							} else {
-								for (const c of impCandidates) {
-									candidates.add(c);
-								}
-							}
-						}
-						statsCandidates += candidates.size;
-						if (!currentConfiguration.isEmpty()) {
-							const modules = currentConfiguration.getModules();
-							statsSizeSum += modules.size;
-							concatConfigurations.push(currentConfiguration);
-							for (const module of modules) {
-								if (module !== currentConfiguration.rootModule) {
-									usedAsInner.add(module);
-								}
-							}
-						} else {
-							statsEmptyConfigurations++;
-							const optimizationBailouts =
-								moduleGraph.getOptimizationBailout(currentRoot);
-							for (const warning of currentConfiguration.getWarningsSorted()) {
-								optimizationBailouts.push(
-									formatBailoutWarning(warning[0], warning[1])
-								);
-							}
-						}
+				const condition = this.evaluateExpression(expr.test);
+				const conditionValue = condition.asBool();
+				let res;
+				if (conditionValue === undefined) {
+					const consequent = this.evaluateExpression(expr.consequent);
+					const alternate = this.evaluateExpression(expr.alternate);
+					if (!consequent || !alternate) return;
+					res = new BasicEvaluatedExpression();
+					if (consequent.isConditional()) {
+						res.setOptions(consequent.options);
+					} else {
+						res.setOptions([consequent]);
 					}
-					logger.timeEnd("find modules to concatenate");
-					logger.debug(
-						`${
-							concatConfigurations.length
-						} successful concat configurations (avg size: ${
-							statsSizeSum / concatConfigurations.length
-						}), ${statsEmptyConfigurations} bailed out completely`
-					);
-					logger.debug(
-						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
+					if (alternate.isConditional()) {
+						res.addOptions(alternate.options);
+					} else {
+						res.addOptions([alternate]);
+					}
+				} else {
+					res = this.evaluateExpression(
+						conditionValue ? expr.consequent : expr.alternate
 					);
-					// HACK: Sort configurations by length and start with the longest one
-					// to get the biggest 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)
-					logger.time(`sort concat configurations`);
-					concatConfigurations.sort((a, b) => {
-						return b.modules.size - a.modules.size;
-					});
-					logger.timeEnd(`sort concat configurations`);
-					const usedModules = new Set();
-
-					logger.time("create concatenated modules");
-					asyncLib.each(
-						concatConfigurations,
-						(concatConfiguration, callback) => {
-							const rootModule = concatConfiguration.rootModule;
+					if (condition.couldHaveSideEffects()) res.setSideEffects();
+				}
+				res.setRange(expr.range);
+				return res;
+			});
+		this.hooks.evaluate
+			.for("ArrayExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ArrayExpressionNode} */ (_expr);
 
-							// Avoid overlapping configurations
-							// TODO: remove this when todo above is fixed
-							if (usedModules.has(rootModule)) return callback();
-							const modules = concatConfiguration.getModules();
-							for (const m of modules) {
-								usedModules.add(m);
-							}
+				const items = expr.elements.map(element => {
+					return (
+						element !== null &&
+						element.type !== "SpreadElement" &&
+						this.evaluateExpression(element)
+					);
+				});
+				if (!items.every(Boolean)) return;
+				return new BasicEvaluatedExpression()
+					.setItems(items)
+					.setRange(expr.range);
+			});
+		this.hooks.evaluate
+			.for("ChainExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ChainExpressionNode} */ (_expr);
+				/** @type {ExpressionNode[]} */
+				const optionalExpressionsStack = [];
+				/** @type {ExpressionNode|SuperNode} */
+				let next = expr.expression;
 
-							// Create a new ConcatenatedModule
-							let newModule = ConcatenatedModule.create(
-								rootModule,
-								modules,
-								concatConfiguration.runtime,
-								compiler.root,
-								compilation.outputOptions.hashFunction
+				while (
+					next.type === "MemberExpression" ||
+					next.type === "CallExpression"
+				) {
+					if (next.type === "MemberExpression") {
+						if (next.optional) {
+							// SuperNode can not be optional
+							optionalExpressionsStack.push(
+								/** @type {ExpressionNode} */ (next.object)
 							);
+						}
+						next = next.object;
+					} else {
+						if (next.optional) {
+							// SuperNode can not be optional
+							optionalExpressionsStack.push(
+								/** @type {ExpressionNode} */ (next.callee)
+							);
+						}
+						next = next.callee;
+					}
+				}
 
-							const build = () => {
-								newModule.build(
-									compiler.options,
-									compilation,
-									null,
-									null,
-									err => {
-										if (err) {
-											if (!err.module) {
-												err.module = newModule;
-											}
-											return callback(err);
-										}
-										integrate();
-									}
-								);
-							};
-
-							const integrate = () => {
-								if (backCompat) {
-									ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
-									ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
-								}
-
-								for (const warning of concatConfiguration.getWarningsSorted()) {
-									moduleGraph
-										.getOptimizationBailout(newModule)
-										.push(formatBailoutWarning(warning[0], warning[1]));
-								}
-								moduleGraph.cloneModuleAttributes(rootModule, newModule);
-								for (const m of modules) {
-									// add to builtModules when one of the included modules was built
-									if (compilation.builtModules.has(m)) {
-										compilation.builtModules.add(newModule);
-									}
-									if (m !== rootModule) {
-										// attach external references to the concatenated module too
-										moduleGraph.copyOutgoingModuleConnections(
-											m,
-											newModule,
-											c => {
-												return (
-													c.originModule === m &&
-													!(
-														c.dependency instanceof HarmonyImportDependency &&
-														modules.has(c.module)
-													)
-												);
-											}
-										);
-										// remove module from chunk
-										for (const chunk of chunkGraph.getModuleChunksIterable(
-											rootModule
-										)) {
-											chunkGraph.disconnectChunkAndModule(chunk, m);
-										}
-									}
-								}
-								compilation.modules.delete(rootModule);
-								ChunkGraph.clearChunkGraphForModule(rootModule);
-								ModuleGraph.clearModuleGraphForModule(rootModule);
-
-								// remove module from chunk
-								chunkGraph.replaceModule(rootModule, newModule);
-								// replace module references with the concatenated module
-								moduleGraph.moveModuleConnections(rootModule, newModule, c => {
-									const otherModule =
-										c.module === rootModule ? c.originModule : c.module;
-									const innerConnection =
-										c.dependency instanceof HarmonyImportDependency &&
-										modules.has(otherModule);
-									return !innerConnection;
-								});
-								// add concatenated module to the compilation
-								compilation.modules.add(newModule);
-
-								callback();
-							};
+				while (optionalExpressionsStack.length > 0) {
+					const expression = optionalExpressionsStack.pop();
+					const evaluated = this.evaluateExpression(expression);
 
-							build();
-						},
-						err => {
-							logger.timeEnd("create concatenated modules");
-							process.nextTick(callback.bind(null, err));
-						}
-					);
+					if (evaluated && evaluated.asNullish()) {
+						return evaluated.setRange(_expr.range);
+					}
 				}
-			);
-		});
+				return this.evaluateExpression(expr.expression);
+			});
+	}
+
+	getRenameIdentifier(expr) {
+		const result = this.evaluateExpression(expr);
+		if (result && result.isIdentifier()) {
+			return result.identifier;
+		}
 	}
 
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {Module} module the module to be added
-	 * @param {RuntimeSpec} runtime the runtime scope
-	 * @returns {Set<Module>} the imported modules
+	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * @returns {void}
 	 */
-	_getImports(compilation, module, runtime) {
-		const moduleGraph = compilation.moduleGraph;
-		const set = new Set();
-		for (const dep of module.dependencies) {
-			// Get reference info only for harmony Dependencies
-			if (!(dep instanceof HarmonyImportDependency)) continue;
-
-			const connection = moduleGraph.getConnection(dep);
-			// Reference is valid and has a module
-			if (
-				!connection ||
-				!connection.module ||
-				!connection.isTargetActive(runtime)
-			) {
-				continue;
+	walkClass(classy) {
+		if (classy.superClass) {
+			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
+				this.walkExpression(classy.superClass);
+			}
+		}
+		if (classy.body && classy.body.type === "ClassBody") {
+			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
+				if (!this.hooks.classBodyElement.call(classElement, classy)) {
+					if (classElement.computed && classElement.key) {
+						this.walkExpression(classElement.key);
+					}
+					if (classElement.value) {
+						if (
+							!this.hooks.classBodyValue.call(
+								classElement.value,
+								classElement,
+								classy
+							)
+						) {
+							const wasTopLevel = this.scope.topLevelScope;
+							this.scope.topLevelScope = false;
+							this.walkExpression(classElement.value);
+							this.scope.topLevelScope = wasTopLevel;
+						}
+					}
+				}
 			}
+		}
+	}
 
-			const importedNames = compilation.getDependencyReferencedExports(
-				dep,
-				undefined
-			);
+	// Pre walking iterates the scope for variable declarations
+	preWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.preWalkStatement(statement);
+		}
+	}
 
-			if (
-				importedNames.every(i =>
-					Array.isArray(i) ? i.length > 0 : i.name.length > 0
-				) ||
-				Array.isArray(moduleGraph.getProvidedExports(module))
-			) {
-				set.add(connection.module);
-			}
+	// Block pre walking iterates the scope for block variable declarations
+	blockPreWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.blockPreWalkStatement(statement);
 		}
-		return set;
 	}
 
-	/**
-	 * @param {Compilation} compilation webpack compilation
-	 * @param {ConcatConfiguration} config concat configuration (will be modified when added)
-	 * @param {Module} module the module to be added
-	 * @param {RuntimeSpec} runtime the runtime scope of the generated code
-	 * @param {RuntimeSpec} activeRuntime the runtime scope of the root module
-	 * @param {Set<Module>} possibleModules modules that are candidates
-	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
-	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
-	 * @param {Statistics} statistics gathering metrics
-	 * @returns {Module | function(RequestShortener): string} the problematic module
-	 */
-	_tryToAdd(
-		compilation,
-		config,
-		module,
-		runtime,
-		activeRuntime,
-		possibleModules,
-		candidates,
-		failureCache,
-		chunkGraph,
-		avoidMutateOnFailure,
-		statistics
-	) {
-		const cacheEntry = failureCache.get(module);
-		if (cacheEntry) {
-			statistics.cached++;
-			return cacheEntry;
+	// Walking iterates the statements and expressions and processes them
+	walkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.walkStatement(statement);
 		}
+	}
 
-		// Already added?
-		if (config.has(module)) {
-			statistics.alreadyInConfig++;
-			return null;
+	preWalkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.preStatement.call(statement)) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "BlockStatement":
+				this.preWalkBlockStatement(statement);
+				break;
+			case "DoWhileStatement":
+				this.preWalkDoWhileStatement(statement);
+				break;
+			case "ForInStatement":
+				this.preWalkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.preWalkForOfStatement(statement);
+				break;
+			case "ForStatement":
+				this.preWalkForStatement(statement);
+				break;
+			case "FunctionDeclaration":
+				this.preWalkFunctionDeclaration(statement);
+				break;
+			case "IfStatement":
+				this.preWalkIfStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.preWalkLabeledStatement(statement);
+				break;
+			case "SwitchStatement":
+				this.preWalkSwitchStatement(statement);
+				break;
+			case "TryStatement":
+				this.preWalkTryStatement(statement);
+				break;
+			case "VariableDeclaration":
+				this.preWalkVariableDeclaration(statement);
+				break;
+			case "WhileStatement":
+				this.preWalkWhileStatement(statement);
+				break;
+			case "WithStatement":
+				this.preWalkWithStatement(statement);
+				break;
 		}
+		this.prevStatement = this.statementPath.pop();
+	}
 
-		// Not possible to add?
-		if (!possibleModules.has(module)) {
-			statistics.invalidModule++;
-			failureCache.set(module, module); // cache failures for performance
-			return module;
+	blockPreWalkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.blockPreStatement.call(statement)) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "ImportDeclaration":
+				this.blockPreWalkImportDeclaration(statement);
+				break;
+			case "ExportAllDeclaration":
+				this.blockPreWalkExportAllDeclaration(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.blockPreWalkExportDefaultDeclaration(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.blockPreWalkExportNamedDeclaration(statement);
+				break;
+			case "VariableDeclaration":
+				this.blockPreWalkVariableDeclaration(statement);
+				break;
+			case "ClassDeclaration":
+				this.blockPreWalkClassDeclaration(statement);
+				break;
 		}
+		this.prevStatement = this.statementPath.pop();
+	}
 
-		// Module must be in the correct chunks
-		const missingChunks = Array.from(
-			chunkGraph.getModuleChunksIterable(config.rootModule)
-		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
-		if (missingChunks.length > 0) {
-			const problem = requestShortener => {
-				const missingChunksList = Array.from(
-					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
-				).sort();
-				const chunks = Array.from(
-					new Set(
-						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
-							chunk => chunk.name || "unnamed chunk(s)"
-						)
-					)
-				).sort();
-				return `Module ${module.readableIdentifier(
-					requestShortener
-				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
-					", "
-				)}, module is in chunk(s) ${chunks.join(", ")})`;
-			};
-			statistics.incorrectChunks++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
+	walkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.statement.call(statement) !== undefined) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "BlockStatement":
+				this.walkBlockStatement(statement);
+				break;
+			case "ClassDeclaration":
+				this.walkClassDeclaration(statement);
+				break;
+			case "DoWhileStatement":
+				this.walkDoWhileStatement(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.walkExportDefaultDeclaration(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.walkExportNamedDeclaration(statement);
+				break;
+			case "ExpressionStatement":
+				this.walkExpressionStatement(statement);
+				break;
+			case "ForInStatement":
+				this.walkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.walkForOfStatement(statement);
+				break;
+			case "ForStatement":
+				this.walkForStatement(statement);
+				break;
+			case "FunctionDeclaration":
+				this.walkFunctionDeclaration(statement);
+				break;
+			case "IfStatement":
+				this.walkIfStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.walkLabeledStatement(statement);
+				break;
+			case "ReturnStatement":
+				this.walkReturnStatement(statement);
+				break;
+			case "SwitchStatement":
+				this.walkSwitchStatement(statement);
+				break;
+			case "ThrowStatement":
+				this.walkThrowStatement(statement);
+				break;
+			case "TryStatement":
+				this.walkTryStatement(statement);
+				break;
+			case "VariableDeclaration":
+				this.walkVariableDeclaration(statement);
+				break;
+			case "WhileStatement":
+				this.walkWhileStatement(statement);
+				break;
+			case "WithStatement":
+				this.walkWithStatement(statement);
+				break;
 		}
+		this.prevStatement = this.statementPath.pop();
+	}
+
+	/**
+	 * Walks a statements that is nested within a parent statement
+	 * and can potentially be a non-block statement.
+	 * This enforces the nested statement to never be in ASI position.
+	 * @param {StatementNode} statement the nested statement
+	 * @returns {void}
+	 */
+	walkNestedStatement(statement) {
+		this.prevStatement = undefined;
+		this.walkStatement(statement);
+	}
+
+	// Real Statements
+	preWalkBlockStatement(statement) {
+		this.preWalkStatements(statement.body);
+	}
+
+	walkBlockStatement(statement) {
+		this.inBlockScope(() => {
+			const body = statement.body;
+			const prev = this.prevStatement;
+			this.blockPreWalkStatements(body);
+			this.prevStatement = prev;
+			this.walkStatements(body);
+		});
+	}
 
-		const moduleGraph = compilation.moduleGraph;
+	walkExpressionStatement(statement) {
+		this.walkExpression(statement.expression);
+	}
 
-		const incomingConnections =
-			moduleGraph.getIncomingConnectionsByOriginModule(module);
+	preWalkIfStatement(statement) {
+		this.preWalkStatement(statement.consequent);
+		if (statement.alternate) {
+			this.preWalkStatement(statement.alternate);
+		}
+	}
 
-		const incomingConnectionsFromNonModules =
-			incomingConnections.get(null) || incomingConnections.get(undefined);
-		if (incomingConnectionsFromNonModules) {
-			const activeNonModulesConnections =
-				incomingConnectionsFromNonModules.filter(connection => {
-					// We are not interested in inactive connections
-					// or connections without dependency
-					return connection.isActive(runtime) || connection.dependency;
-				});
-			if (activeNonModulesConnections.length > 0) {
-				const problem = requestShortener => {
-					const importingExplanations = new Set(
-						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
-					);
-					const explanations = Array.from(importingExplanations).sort();
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is referenced ${
-						explanations.length > 0
-							? `by: ${explanations.join(", ")}`
-							: "in an unsupported way"
-					}`;
-				};
-				statistics.incorrectDependency++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+	walkIfStatement(statement) {
+		const result = this.hooks.statementIf.call(statement);
+		if (result === undefined) {
+			this.walkExpression(statement.test);
+			this.walkNestedStatement(statement.consequent);
+			if (statement.alternate) {
+				this.walkNestedStatement(statement.alternate);
+			}
+		} else {
+			if (result) {
+				this.walkNestedStatement(statement.consequent);
+			} else if (statement.alternate) {
+				this.walkNestedStatement(statement.alternate);
 			}
 		}
+	}
 
-		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
-		const incomingConnectionsFromModules = new Map();
-		for (const [originModule, connections] of incomingConnections) {
-			if (originModule) {
-				// Ignore connection from orphan modules
-				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
+	preWalkLabeledStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
 
-				// We don't care for connections from other runtimes
-				let originRuntime = undefined;
-				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
-					originRuntime = mergeRuntimeOwned(originRuntime, r);
-				}
+	walkLabeledStatement(statement) {
+		const hook = this.hooks.label.get(statement.label.name);
+		if (hook !== undefined) {
+			const result = hook.call(statement);
+			if (result === true) return;
+		}
+		this.walkNestedStatement(statement.body);
+	}
 
-				if (!intersectRuntime(runtime, originRuntime)) continue;
+	preWalkWithStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
 
-				// We are not interested in inactive connections
-				const activeConnections = connections.filter(connection =>
-					connection.isActive(runtime)
-				);
-				if (activeConnections.length > 0)
-					incomingConnectionsFromModules.set(originModule, activeConnections);
-			}
-		}
+	walkWithStatement(statement) {
+		this.walkExpression(statement.object);
+		this.walkNestedStatement(statement.body);
+	}
 
-		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
+	preWalkSwitchStatement(statement) {
+		this.preWalkSwitchCases(statement.cases);
+	}
 
-		// Module must be in the same chunks like the referencing module
-		const otherChunkModules = incomingModules.filter(originModule => {
-			for (const chunk of chunkGraph.getModuleChunksIterable(
-				config.rootModule
-			)) {
-				if (!chunkGraph.isModuleInChunk(originModule, chunk)) {
-					return true;
-				}
-			}
-			return false;
-		});
-		if (otherChunkModules.length > 0) {
-			const problem = requestShortener => {
-				const names = otherChunkModules
-					.map(m => m.readableIdentifier(requestShortener))
-					.sort();
-				return `Module ${module.readableIdentifier(
-					requestShortener
-				)} is referenced from different chunks by these modules: ${names.join(
-					", "
-				)}`;
-			};
-			statistics.incorrectChunksOfImporter++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
-		}
+	walkSwitchStatement(statement) {
+		this.walkExpression(statement.discriminant);
+		this.walkSwitchCases(statement.cases);
+	}
 
-		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
-		const nonHarmonyConnections = new Map();
-		for (const [originModule, connections] of incomingConnectionsFromModules) {
-			const selected = connections.filter(
-				connection =>
-					!connection.dependency ||
-					!(connection.dependency instanceof HarmonyImportDependency)
-			);
-			if (selected.length > 0)
-				nonHarmonyConnections.set(originModule, connections);
-		}
-		if (nonHarmonyConnections.size > 0) {
-			const problem = requestShortener => {
-				const names = Array.from(nonHarmonyConnections)
-					.map(([originModule, connections]) => {
-						return `${originModule.readableIdentifier(
-							requestShortener
-						)} (referenced with ${Array.from(
-							new Set(
-								connections
-									.map(c => c.dependency && c.dependency.type)
-									.filter(Boolean)
-							)
-						)
-							.sort()
-							.join(", ")})`;
-					})
-					.sort();
-				return `Module ${module.readableIdentifier(
-					requestShortener
-				)} is referenced from these modules with unsupported syntax: ${names.join(
-					", "
-				)}`;
-			};
-			statistics.incorrectModuleDependency++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
-		}
+	walkTerminatingStatement(statement) {
+		if (statement.argument) this.walkExpression(statement.argument);
+	}
 
-		if (runtime !== undefined && typeof runtime !== "string") {
-			// Module must be consistently referenced in the same runtimes
-			/** @type {{ originModule: Module, runtimeCondition: RuntimeSpec }[]} */
-			const otherRuntimeConnections = [];
-			outer: for (const [
-				originModule,
-				connections
-			] of incomingConnectionsFromModules) {
-				/** @type {false | RuntimeSpec} */
-				let currentRuntimeCondition = false;
-				for (const connection of connections) {
-					const runtimeCondition = filterRuntime(runtime, runtime => {
-						return connection.isTargetActive(runtime);
-					});
-					if (runtimeCondition === false) continue;
-					if (runtimeCondition === true) continue outer;
-					if (currentRuntimeCondition !== false) {
-						currentRuntimeCondition = mergeRuntime(
-							currentRuntimeCondition,
-							runtimeCondition
-						);
-					} else {
-						currentRuntimeCondition = runtimeCondition;
-					}
-				}
-				if (currentRuntimeCondition !== false) {
-					otherRuntimeConnections.push({
-						originModule,
-						runtimeCondition: currentRuntimeCondition
-					});
-				}
-			}
-			if (otherRuntimeConnections.length > 0) {
-				const problem = requestShortener => {
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is runtime-dependent referenced by these modules: ${Array.from(
-						otherRuntimeConnections,
-						({ originModule, runtimeCondition }) =>
-							`${originModule.readableIdentifier(
-								requestShortener
-							)} (expected runtime ${runtimeToString(
-								runtime
-							)}, module is only referenced in ${runtimeToString(
-								/** @type {RuntimeSpec} */ (runtimeCondition)
-							)})`
-					).join(", ")}`;
-				};
-				statistics.incorrectRuntimeCondition++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
-			}
-		}
+	walkReturnStatement(statement) {
+		this.walkTerminatingStatement(statement);
+	}
 
-		let backup;
-		if (avoidMutateOnFailure) {
-			backup = config.snapshot();
+	walkThrowStatement(statement) {
+		this.walkTerminatingStatement(statement);
+	}
+
+	preWalkTryStatement(statement) {
+		this.preWalkStatement(statement.block);
+		if (statement.handler) this.preWalkCatchClause(statement.handler);
+		if (statement.finializer) this.preWalkStatement(statement.finializer);
+	}
+
+	walkTryStatement(statement) {
+		if (this.scope.inTry) {
+			this.walkStatement(statement.block);
+		} else {
+			this.scope.inTry = true;
+			this.walkStatement(statement.block);
+			this.scope.inTry = false;
 		}
+		if (statement.handler) this.walkCatchClause(statement.handler);
+		if (statement.finalizer) this.walkStatement(statement.finalizer);
+	}
 
-		// Add the module
-		config.add(module);
+	preWalkWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
 
-		incomingModules.sort(compareModulesByIdentifier);
+	walkWhileStatement(statement) {
+		this.walkExpression(statement.test);
+		this.walkNestedStatement(statement.body);
+	}
 
-		// Every module which depends on the added module must be in the configuration too.
-		for (const originModule of incomingModules) {
-			const problem = this._tryToAdd(
-				compilation,
-				config,
-				originModule,
-				runtime,
-				activeRuntime,
-				possibleModules,
-				candidates,
-				failureCache,
-				chunkGraph,
-				false,
-				statistics
-			);
-			if (problem) {
-				if (backup !== undefined) config.rollback(backup);
-				statistics.importerFailed++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
+	preWalkDoWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	walkDoWhileStatement(statement) {
+		this.walkNestedStatement(statement.body);
+		this.walkExpression(statement.test);
+	}
+
+	preWalkForStatement(statement) {
+		if (statement.init) {
+			if (statement.init.type === "VariableDeclaration") {
+				this.preWalkStatement(statement.init);
 			}
 		}
+		this.preWalkStatement(statement.body);
+	}
 
-		// Add imports to possible candidates list
-		for (const imp of this._getImports(compilation, module, runtime)) {
-			candidates.add(imp);
-		}
-		statistics.added++;
-		return null;
+	walkForStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.init) {
+				if (statement.init.type === "VariableDeclaration") {
+					this.blockPreWalkVariableDeclaration(statement.init);
+					this.prevStatement = undefined;
+					this.walkStatement(statement.init);
+				} else {
+					this.walkExpression(statement.init);
+				}
+			}
+			if (statement.test) {
+				this.walkExpression(statement.test);
+			}
+			if (statement.update) {
+				this.walkExpression(statement.update);
+			}
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
 	}
-}
 
-class ConcatConfiguration {
-	/**
-	 * @param {Module} rootModule the root module
-	 * @param {RuntimeSpec} runtime the runtime
-	 */
-	constructor(rootModule, runtime) {
-		this.rootModule = rootModule;
-		this.runtime = runtime;
-		/** @type {Set<Module>} */
-		this.modules = new Set();
-		this.modules.add(rootModule);
-		/** @type {Map<Module, Module | function(RequestShortener): string>} */
-		this.warnings = new Map();
+	preWalkForInStatement(statement) {
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkVariableDeclaration(statement.left);
+		}
+		this.preWalkStatement(statement.body);
 	}
 
-	add(module) {
-		this.modules.add(module);
+	walkForInStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.left.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.left);
+				this.walkVariableDeclaration(statement.left);
+			} else {
+				this.walkPattern(statement.left);
+			}
+			this.walkExpression(statement.right);
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
 	}
 
-	has(module) {
-		return this.modules.has(module);
+	preWalkForOfStatement(statement) {
+		if (statement.await && this.scope.topLevelScope === true) {
+			this.hooks.topLevelAwait.call(statement);
+		}
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkVariableDeclaration(statement.left);
+		}
+		this.preWalkStatement(statement.body);
 	}
 
-	isEmpty() {
-		return this.modules.size === 1;
+	walkForOfStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.left.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.left);
+				this.walkVariableDeclaration(statement.left);
+			} else {
+				this.walkPattern(statement.left);
+			}
+			this.walkExpression(statement.right);
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
 	}
 
-	addWarning(module, problem) {
-		this.warnings.set(module, problem);
+	// Declarations
+	preWalkFunctionDeclaration(statement) {
+		if (statement.id) {
+			this.defineVariable(statement.id.name);
+		}
 	}
 
-	getWarningsSorted() {
-		return new Map(
-			Array.from(this.warnings).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;
-			})
-		);
+	walkFunctionDeclaration(statement) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = false;
+		this.inFunctionScope(true, statement.params, () => {
+			for (const param of statement.params) {
+				this.walkPattern(param);
+			}
+			if (statement.body.type === "BlockStatement") {
+				this.detectMode(statement.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(statement.body);
+				this.prevStatement = prev;
+				this.walkStatement(statement.body);
+			} else {
+				this.walkExpression(statement.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
 	}
 
-	/**
-	 * @returns {Set<Module>} modules as set
-	 */
-	getModules() {
-		return this.modules;
+	blockPreWalkImportDeclaration(statement) {
+		const source = statement.source.value;
+		this.hooks.import.call(statement, source);
+		for (const specifier of statement.specifiers) {
+			const name = specifier.local.name;
+			switch (specifier.type) {
+				case "ImportDefaultSpecifier":
+					if (
+						!this.hooks.importSpecifier.call(statement, source, "default", name)
+					) {
+						this.defineVariable(name);
+					}
+					break;
+				case "ImportSpecifier":
+					if (
+						!this.hooks.importSpecifier.call(
+							statement,
+							source,
+							specifier.imported.name,
+							name
+						)
+					) {
+						this.defineVariable(name);
+					}
+					break;
+				case "ImportNamespaceSpecifier":
+					if (!this.hooks.importSpecifier.call(statement, source, null, name)) {
+						this.defineVariable(name);
+					}
+					break;
+				default:
+					this.defineVariable(name);
+			}
+		}
 	}
 
-	snapshot() {
-		return this.modules.size;
+	enterDeclaration(declaration, onIdent) {
+		switch (declaration.type) {
+			case "VariableDeclaration":
+				for (const declarator of declaration.declarations) {
+					switch (declarator.type) {
+						case "VariableDeclarator": {
+							this.enterPattern(declarator.id, onIdent);
+							break;
+						}
+					}
+				}
+				break;
+			case "FunctionDeclaration":
+				this.enterPattern(declaration.id, onIdent);
+				break;
+			case "ClassDeclaration":
+				this.enterPattern(declaration.id, onIdent);
+				break;
+		}
 	}
 
-	rollback(snapshot) {
-		const modules = this.modules;
-		for (const m of modules) {
-			if (snapshot === 0) {
-				modules.delete(m);
-			} else {
-				snapshot--;
+	blockPreWalkExportNamedDeclaration(statement) {
+		let source;
+		if (statement.source) {
+			source = statement.source.value;
+			this.hooks.exportImport.call(statement, source);
+		} else {
+			this.hooks.export.call(statement);
+		}
+		if (statement.declaration) {
+			if (
+				!this.hooks.exportDeclaration.call(statement, statement.declaration)
+			) {
+				const prev = this.prevStatement;
+				this.preWalkStatement(statement.declaration);
+				this.prevStatement = prev;
+				this.blockPreWalkStatement(statement.declaration);
+				let index = 0;
+				this.enterDeclaration(statement.declaration, def => {
+					this.hooks.exportSpecifier.call(statement, def, def, index++);
+				});
+			}
+		}
+		if (statement.specifiers) {
+			for (
+				let specifierIndex = 0;
+				specifierIndex < statement.specifiers.length;
+				specifierIndex++
+			) {
+				const specifier = statement.specifiers[specifierIndex];
+				switch (specifier.type) {
+					case "ExportSpecifier": {
+						const name = specifier.exported.name;
+						if (source) {
+							this.hooks.exportImportSpecifier.call(
+								statement,
+								source,
+								specifier.local.name,
+								name,
+								specifierIndex
+							);
+						} else {
+							this.hooks.exportSpecifier.call(
+								statement,
+								specifier.local.name,
+								name,
+								specifierIndex
+							);
+						}
+						break;
+					}
+				}
 			}
 		}
 	}
-}
-
-module.exports = ModuleConcatenationPlugin;
-
-
-/***/ }),
-
-/***/ 46043:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { SyncBailHook } = __webpack_require__(6967);
-const { RawSource, CachedSource, CompatSource } = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const WebpackError = __webpack_require__(53799);
-const { compareSelect, compareStrings } = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compiler")} Compiler */
-
-const EMPTY_SET = new Set();
-
-const addToList = (itemOrItems, list) => {
-	if (Array.isArray(itemOrItems)) {
-		for (const item of itemOrItems) {
-			list.add(item);
+	walkExportNamedDeclaration(statement) {
+		if (statement.declaration) {
+			this.walkStatement(statement.declaration);
 		}
-	} else if (itemOrItems) {
-		list.add(itemOrItems);
 	}
-};
 
-/**
- * @template T
- * @param {T[]} input list
- * @param {function(T): Buffer} fn map function
- * @returns {Buffer[]} buffers without duplicates
- */
-const mapAndDeduplicateBuffers = (input, fn) => {
-	// Buffer.equals compares size first so this should be efficient enough
-	// If it becomes a performance problem we can use a map and group by size
-	// instead of looping over all assets.
-	const result = [];
-	outer: for (const value of input) {
-		const buf = fn(value);
-		for (const other of result) {
-			if (buf.equals(other)) continue outer;
+	blockPreWalkExportDefaultDeclaration(statement) {
+		const prev = this.prevStatement;
+		this.preWalkStatement(statement.declaration);
+		this.prevStatement = prev;
+		this.blockPreWalkStatement(statement.declaration);
+		if (
+			statement.declaration.id &&
+			statement.declaration.type !== "FunctionExpression" &&
+			statement.declaration.type !== "ClassExpression"
+		) {
+			this.hooks.exportSpecifier.call(
+				statement,
+				statement.declaration.id.name,
+				"default",
+				undefined
+			);
 		}
-		result.push(buf);
 	}
-	return result;
-};
-
-/**
- * Escapes regular expression metacharacters
- * @param {string} str String to quote
- * @returns {string} Escaped string
- */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
-
-const cachedSourceMap = new WeakMap();
 
-const toCachedSource = source => {
-	if (source instanceof CachedSource) {
-		return source;
+	walkExportDefaultDeclaration(statement) {
+		this.hooks.export.call(statement);
+		if (
+			statement.declaration.id &&
+			statement.declaration.type !== "FunctionExpression" &&
+			statement.declaration.type !== "ClassExpression"
+		) {
+			if (
+				!this.hooks.exportDeclaration.call(statement, statement.declaration)
+			) {
+				this.walkStatement(statement.declaration);
+			}
+		} else {
+			// Acorn parses `export default function() {}` as `FunctionDeclaration` and
+			// `export default class {}` as `ClassDeclaration`, both with `id = null`.
+			// These nodes must be treated as expressions.
+			if (
+				statement.declaration.type === "FunctionDeclaration" ||
+				statement.declaration.type === "ClassDeclaration"
+			) {
+				this.walkStatement(statement.declaration);
+			} else {
+				this.walkExpression(statement.declaration);
+			}
+			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
+				this.hooks.exportSpecifier.call(
+					statement,
+					statement.declaration,
+					"default",
+					undefined
+				);
+			}
+		}
 	}
-	const entry = cachedSourceMap.get(source);
-	if (entry !== undefined) return entry;
-	const newSource = new CachedSource(CompatSource.from(source));
-	cachedSourceMap.set(source, newSource);
-	return newSource;
-};
-
-/**
- * @typedef {Object} AssetInfoForRealContentHash
- * @property {string} name
- * @property {AssetInfo} info
- * @property {Source} source
- * @property {RawSource | undefined} newSource
- * @property {RawSource | undefined} newSourceWithoutOwn
- * @property {string} content
- * @property {Set<string>} ownHashes
- * @property {Promise} contentComputePromise
- * @property {Promise} contentComputeWithoutOwnPromise
- * @property {Set<string>} referencedHashes
- * @property {Set<string>} hashes
- */
-
-/**
- * @typedef {Object} CompilationHooks
- * @property {SyncBailHook<[Buffer[], string], string>} updateHash
- */
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+	blockPreWalkExportAllDeclaration(statement) {
+		const source = statement.source.value;
+		const name = statement.exported ? statement.exported.name : null;
+		this.hooks.exportImport.call(statement, source);
+		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
+	}
 
-class RealContentHashPlugin {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				updateHash: new SyncBailHook(["content", "oldHash"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
+	preWalkVariableDeclaration(statement) {
+		if (statement.kind !== "var") return;
+		this._preWalkVariableDeclaration(statement, this.hooks.varDeclarationVar);
 	}
 
-	constructor({ hashFunction, hashDigest }) {
-		this._hashFunction = hashFunction;
-		this._hashDigest = hashDigest;
+	blockPreWalkVariableDeclaration(statement) {
+		if (statement.kind === "var") return;
+		const hookMap =
+			statement.kind === "const"
+				? this.hooks.varDeclarationConst
+				: this.hooks.varDeclarationLet;
+		this._preWalkVariableDeclaration(statement, hookMap);
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
-			const cacheAnalyse = compilation.getCache(
-				"RealContentHashPlugin|analyse"
-			);
-			const cacheGenerate = compilation.getCache(
-				"RealContentHashPlugin|generate"
-			);
-			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
-			compilation.hooks.processAssets.tapPromise(
-				{
-					name: "RealContentHashPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
-				},
-				async () => {
-					const assets = compilation.getAssets();
-					/** @type {AssetInfoForRealContentHash[]} */
-					const assetsWithInfo = [];
-					const hashToAssets = new Map();
-					for (const { source, info, name } of assets) {
-						const cachedSource = toCachedSource(source);
-						const content = cachedSource.source();
-						/** @type {Set<string>} */
-						const hashes = new Set();
-						addToList(info.contenthash, hashes);
-						const data = {
-							name,
-							info,
-							source: cachedSource,
-							/** @type {RawSource | undefined} */
-							newSource: undefined,
-							/** @type {RawSource | undefined} */
-							newSourceWithoutOwn: undefined,
-							content,
-							/** @type {Set<string>} */
-							ownHashes: undefined,
-							contentComputePromise: undefined,
-							contentComputeWithoutOwnPromise: undefined,
-							/** @type {Set<string>} */
-							referencedHashes: undefined,
-							hashes
-						};
-						assetsWithInfo.push(data);
-						for (const hash of hashes) {
-							const list = hashToAssets.get(hash);
-							if (list === undefined) {
-								hashToAssets.set(hash, [data]);
-							} else {
-								list.push(data);
-							}
-						}
-					}
-					if (hashToAssets.size === 0) return;
-					const hashRegExp = new RegExp(
-						Array.from(hashToAssets.keys(), quoteMeta).join("|"),
-						"g"
-					);
-					await Promise.all(
-						assetsWithInfo.map(async asset => {
-							const { name, source, content, hashes } = asset;
-							if (Buffer.isBuffer(content)) {
-								asset.referencedHashes = EMPTY_SET;
-								asset.ownHashes = EMPTY_SET;
-								return;
-							}
-							const etag = cacheAnalyse.mergeEtags(
-								cacheAnalyse.getLazyHashedEtag(source),
-								Array.from(hashes).join("|")
-							);
-							[asset.referencedHashes, asset.ownHashes] =
-								await cacheAnalyse.providePromise(name, etag, () => {
-									const referencedHashes = new Set();
-									let ownHashes = new Set();
-									const inContent = content.match(hashRegExp);
-									if (inContent) {
-										for (const hash of inContent) {
-											if (hashes.has(hash)) {
-												ownHashes.add(hash);
-												continue;
-											}
-											referencedHashes.add(hash);
-										}
-									}
-									return [referencedHashes, ownHashes];
-								});
-						})
-					);
-					const getDependencies = hash => {
-						const assets = hashToAssets.get(hash);
-						if (!assets) {
-							const referencingAssets = assetsWithInfo.filter(asset =>
-								asset.referencedHashes.has(hash)
-							);
-							const err = new WebpackError(`RealContentHashPlugin
-Some kind of unexpected caching problem occurred.
-An asset was cached with a reference to another asset (${hash}) that's not in the compilation anymore.
-Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
-Referenced by:
-${referencingAssets
-	.map(a => {
-		const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(
-			a.content
-		);
-		return ` - ${a.name}: ...${match ? match[0] : "???"}...`;
-	})
-	.join("\n")}`);
-							compilation.errors.push(err);
-							return undefined;
-						}
-						const hashes = new Set();
-						for (const { referencedHashes, ownHashes } of assets) {
-							if (!ownHashes.has(hash)) {
-								for (const hash of ownHashes) {
-									hashes.add(hash);
-								}
-							}
-							for (const hash of referencedHashes) {
-								hashes.add(hash);
-							}
-						}
-						return hashes;
-					};
-					const hashInfo = hash => {
-						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(assets, a => a.name)})`;
-					};
-					const hashesInOrder = new Set();
-					for (const hash of hashToAssets.keys()) {
-						const add = (hash, stack) => {
-							const deps = getDependencies(hash);
-							if (!deps) return;
-							stack.add(hash);
-							for (const dep of deps) {
-								if (hashesInOrder.has(dep)) continue;
-								if (stack.has(dep)) {
-									throw new Error(
-										`Circular hash dependency ${Array.from(
-											stack,
-											hashInfo
-										).join(" -> ")} -> ${hashInfo(dep)}`
-									);
+	_preWalkVariableDeclaration(statement, hookMap) {
+		for (const declarator of statement.declarations) {
+			switch (declarator.type) {
+				case "VariableDeclarator": {
+					if (!this.hooks.preDeclarator.call(declarator, statement)) {
+						this.enterPattern(declarator.id, (name, decl) => {
+							let hook = hookMap.get(name);
+							if (hook === undefined || !hook.call(decl)) {
+								hook = this.hooks.varDeclaration.get(name);
+								if (hook === undefined || !hook.call(decl)) {
+									this.defineVariable(name);
 								}
-								add(dep, stack);
-							}
-							hashesInOrder.add(hash);
-							stack.delete(hash);
-						};
-						if (hashesInOrder.has(hash)) continue;
-						add(hash, new Set());
-					}
-					const hashToNewHash = new Map();
-					const getEtag = asset =>
-						cacheGenerate.mergeEtags(
-							cacheGenerate.getLazyHashedEtag(asset.source),
-							Array.from(asset.referencedHashes, hash =>
-								hashToNewHash.get(hash)
-							).join("|")
-						);
-					const computeNewContent = asset => {
-						if (asset.contentComputePromise) return asset.contentComputePromise;
-						return (asset.contentComputePromise = (async () => {
-							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
-							) {
-								const identifier = asset.name;
-								const etag = getEtag(asset);
-								asset.newSource = await cacheGenerate.providePromise(
-									identifier,
-									etag,
-									() => {
-										const newContent = asset.content.replace(hashRegExp, hash =>
-											hashToNewHash.get(hash)
-										);
-										return new RawSource(newContent);
-									}
-								);
-							}
-						})());
-					};
-					const computeNewContentWithoutOwn = asset => {
-						if (asset.contentComputeWithoutOwnPromise)
-							return asset.contentComputeWithoutOwnPromise;
-						return (asset.contentComputeWithoutOwnPromise = (async () => {
-							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
-							) {
-								const identifier = asset.name + "|without-own";
-								const etag = getEtag(asset);
-								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
-									identifier,
-									etag,
-									() => {
-										const newContent = asset.content.replace(
-											hashRegExp,
-											hash => {
-												if (asset.ownHashes.has(hash)) {
-													return "";
-												}
-												return hashToNewHash.get(hash);
-											}
-										);
-										return new RawSource(newContent);
-									}
-								);
-							}
-						})());
-					};
-					const comparator = compareSelect(a => a.name, compareStrings);
-					for (const oldHash of hashesInOrder) {
-						const assets = hashToAssets.get(oldHash);
-						assets.sort(comparator);
-						const hash = createHash(this._hashFunction);
-						await Promise.all(
-							assets.map(asset =>
-								asset.ownHashes.has(oldHash)
-									? computeNewContentWithoutOwn(asset)
-									: computeNewContent(asset)
-							)
-						);
-						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
-							if (asset.ownHashes.has(oldHash)) {
-								return asset.newSourceWithoutOwn
-									? asset.newSourceWithoutOwn.buffer()
-									: asset.source.buffer();
-							} else {
-								return asset.newSource
-									? asset.newSource.buffer()
-									: asset.source.buffer();
 							}
 						});
-						let newHash = hooks.updateHash.call(assetsContent, oldHash);
-						if (!newHash) {
-							for (const content of assetsContent) {
-								hash.update(content);
+					}
+					break;
+				}
+			}
+		}
+	}
+
+	walkVariableDeclaration(statement) {
+		for (const declarator of statement.declarations) {
+			switch (declarator.type) {
+				case "VariableDeclarator": {
+					const renameIdentifier =
+						declarator.init && this.getRenameIdentifier(declarator.init);
+					if (renameIdentifier && declarator.id.type === "Identifier") {
+						const hook = this.hooks.canRename.get(renameIdentifier);
+						if (hook !== undefined && hook.call(declarator.init)) {
+							// renaming with "var a = b;"
+							const hook = this.hooks.rename.get(renameIdentifier);
+							if (hook === undefined || !hook.call(declarator.init)) {
+								this.setVariable(declarator.id.name, renameIdentifier);
 							}
-							const digest = hash.digest(this._hashDigest);
-							newHash = /** @type {string} */ (digest.slice(0, oldHash.length));
+							break;
 						}
-						hashToNewHash.set(oldHash, newHash);
 					}
-					await Promise.all(
-						assetsWithInfo.map(async asset => {
-							await computeNewContent(asset);
-							const newName = asset.name.replace(hashRegExp, hash =>
-								hashToNewHash.get(hash)
-							);
+					if (!this.hooks.declarator.call(declarator, statement)) {
+						this.walkPattern(declarator.id);
+						if (declarator.init) this.walkExpression(declarator.init);
+					}
+					break;
+				}
+			}
+		}
+	}
 
-							const infoUpdate = {};
-							const hash = asset.info.contenthash;
-							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(hash => hashToNewHash.get(hash))
-								: hashToNewHash.get(hash);
+	blockPreWalkClassDeclaration(statement) {
+		if (statement.id) {
+			this.defineVariable(statement.id.name);
+		}
+	}
 
-							if (asset.newSource !== undefined) {
-								compilation.updateAsset(
-									asset.name,
-									asset.newSource,
-									infoUpdate
-								);
-							} else {
-								compilation.updateAsset(asset.name, asset.source, infoUpdate);
-							}
+	walkClassDeclaration(statement) {
+		this.walkClass(statement);
+	}
 
-							if (asset.name !== newName) {
-								compilation.renameAsset(asset.name, newName);
-							}
-						})
-					);
+	preWalkSwitchCases(switchCases) {
+		for (let index = 0, len = switchCases.length; index < len; index++) {
+			const switchCase = switchCases[index];
+			this.preWalkStatements(switchCase.consequent);
+		}
+	}
+
+	walkSwitchCases(switchCases) {
+		this.inBlockScope(() => {
+			const len = switchCases.length;
+
+			// we need to pre walk all statements first since we can have invalid code
+			// import A from "module";
+			// switch(1) {
+			//    case 1:
+			//      console.log(A); // should fail at runtime
+			//    case 2:
+			//      const A = 1;
+			// }
+			for (let index = 0; index < len; index++) {
+				const switchCase = switchCases[index];
+
+				if (switchCase.consequent.length > 0) {
+					const prev = this.prevStatement;
+					this.blockPreWalkStatements(switchCase.consequent);
+					this.prevStatement = prev;
 				}
-			);
+			}
+
+			for (let index = 0; index < len; index++) {
+				const switchCase = switchCases[index];
+
+				if (switchCase.test) {
+					this.walkExpression(switchCase.test);
+				}
+				if (switchCase.consequent.length > 0) {
+					this.walkStatements(switchCase.consequent);
+				}
+			}
 		});
 	}
-}
-
-module.exports = RealContentHashPlugin;
 
+	preWalkCatchClause(catchClause) {
+		this.preWalkStatement(catchClause.body);
+	}
 
-/***/ }),
+	walkCatchClause(catchClause) {
+		this.inBlockScope(() => {
+			// Error binding is optional in catch clause since ECMAScript 2019
+			if (catchClause.param !== null) {
+				this.enterPattern(catchClause.param, ident => {
+					this.defineVariable(ident);
+				});
+				this.walkPattern(catchClause.param);
+			}
+			const prev = this.prevStatement;
+			this.blockPreWalkStatement(catchClause.body);
+			this.prevStatement = prev;
+			this.walkStatement(catchClause.body);
+		});
+	}
 
-/***/ 84760:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	walkPattern(pattern) {
+		switch (pattern.type) {
+			case "ArrayPattern":
+				this.walkArrayPattern(pattern);
+				break;
+			case "AssignmentPattern":
+				this.walkAssignmentPattern(pattern);
+				break;
+			case "MemberExpression":
+				this.walkMemberExpression(pattern);
+				break;
+			case "ObjectPattern":
+				this.walkObjectPattern(pattern);
+				break;
+			case "RestElement":
+				this.walkRestElement(pattern);
+				break;
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	walkAssignmentPattern(pattern) {
+		this.walkExpression(pattern.right);
+		this.walkPattern(pattern.left);
+	}
 
+	walkObjectPattern(pattern) {
+		for (let i = 0, len = pattern.properties.length; i < len; i++) {
+			const prop = pattern.properties[i];
+			if (prop) {
+				if (prop.computed) this.walkExpression(prop.key);
+				if (prop.value) this.walkPattern(prop.value);
+			}
+		}
+	}
 
+	walkArrayPattern(pattern) {
+		for (let i = 0, len = pattern.elements.length; i < len; i++) {
+			const element = pattern.elements[i];
+			if (element) this.walkPattern(element);
+		}
+	}
 
-const { STAGE_BASIC, STAGE_ADVANCED } = __webpack_require__(80057);
+	walkRestElement(pattern) {
+		this.walkPattern(pattern.argument);
+	}
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+	walkExpressions(expressions) {
+		for (const expression of expressions) {
+			if (expression) {
+				this.walkExpression(expression);
+			}
+		}
+	}
 
-class RemoveEmptyChunksPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
-			/**
-			 * @param {Iterable<Chunk>} chunks the chunks array
-			 * @returns {void}
-			 */
-			const handler = chunks => {
-				const chunkGraph = compilation.chunkGraph;
-				for (const chunk of chunks) {
-					if (
-						chunkGraph.getNumberOfChunkModules(chunk) === 0 &&
-						!chunk.hasRuntime() &&
-						chunkGraph.getNumberOfEntryModules(chunk) === 0
-					) {
-						compilation.chunkGraph.disconnectChunk(chunk);
-						compilation.chunks.delete(chunk);
-					}
-				}
-			};
+	walkExpression(expression) {
+		switch (expression.type) {
+			case "ArrayExpression":
+				this.walkArrayExpression(expression);
+				break;
+			case "ArrowFunctionExpression":
+				this.walkArrowFunctionExpression(expression);
+				break;
+			case "AssignmentExpression":
+				this.walkAssignmentExpression(expression);
+				break;
+			case "AwaitExpression":
+				this.walkAwaitExpression(expression);
+				break;
+			case "BinaryExpression":
+				this.walkBinaryExpression(expression);
+				break;
+			case "CallExpression":
+				this.walkCallExpression(expression);
+				break;
+			case "ChainExpression":
+				this.walkChainExpression(expression);
+				break;
+			case "ClassExpression":
+				this.walkClassExpression(expression);
+				break;
+			case "ConditionalExpression":
+				this.walkConditionalExpression(expression);
+				break;
+			case "FunctionExpression":
+				this.walkFunctionExpression(expression);
+				break;
+			case "Identifier":
+				this.walkIdentifier(expression);
+				break;
+			case "ImportExpression":
+				this.walkImportExpression(expression);
+				break;
+			case "LogicalExpression":
+				this.walkLogicalExpression(expression);
+				break;
+			case "MetaProperty":
+				this.walkMetaProperty(expression);
+				break;
+			case "MemberExpression":
+				this.walkMemberExpression(expression);
+				break;
+			case "NewExpression":
+				this.walkNewExpression(expression);
+				break;
+			case "ObjectExpression":
+				this.walkObjectExpression(expression);
+				break;
+			case "SequenceExpression":
+				this.walkSequenceExpression(expression);
+				break;
+			case "SpreadElement":
+				this.walkSpreadElement(expression);
+				break;
+			case "TaggedTemplateExpression":
+				this.walkTaggedTemplateExpression(expression);
+				break;
+			case "TemplateLiteral":
+				this.walkTemplateLiteral(expression);
+				break;
+			case "ThisExpression":
+				this.walkThisExpression(expression);
+				break;
+			case "UnaryExpression":
+				this.walkUnaryExpression(expression);
+				break;
+			case "UpdateExpression":
+				this.walkUpdateExpression(expression);
+				break;
+			case "YieldExpression":
+				this.walkYieldExpression(expression);
+				break;
+		}
+	}
 
-			// TODO do it once
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "RemoveEmptyChunksPlugin",
-					stage: STAGE_BASIC
-				},
-				handler
-			);
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "RemoveEmptyChunksPlugin",
-					stage: STAGE_ADVANCED
-				},
-				handler
-			);
-		});
+	walkAwaitExpression(expression) {
+		if (this.scope.topLevelScope === true)
+			this.hooks.topLevelAwait.call(expression);
+		this.walkExpression(expression.argument);
 	}
-}
-module.exports = RemoveEmptyChunksPlugin;
 
+	walkArrayExpression(expression) {
+		if (expression.elements) {
+			this.walkExpressions(expression.elements);
+		}
+	}
 
-/***/ }),
+	walkSpreadElement(expression) {
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
+	}
 
-/***/ 7081:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	walkObjectExpression(expression) {
+		for (
+			let propIndex = 0, len = expression.properties.length;
+			propIndex < len;
+			propIndex++
+		) {
+			const prop = expression.properties[propIndex];
+			this.walkProperty(prop);
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	walkProperty(prop) {
+		if (prop.type === "SpreadElement") {
+			this.walkExpression(prop.argument);
+			return;
+		}
+		if (prop.computed) {
+			this.walkExpression(prop.key);
+		}
+		if (prop.shorthand && prop.value && prop.value.type === "Identifier") {
+			this.scope.inShorthand = prop.value.name;
+			this.walkIdentifier(prop.value);
+			this.scope.inShorthand = false;
+		} else {
+			this.walkExpression(prop.value);
+		}
+	}
 
+	walkFunctionExpression(expression) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = false;
+		const scopeParams = expression.params;
 
+		// Add function name in scope for recursive calls
+		if (expression.id) {
+			scopeParams.push(expression.id.name);
+		}
 
-const { STAGE_BASIC } = __webpack_require__(80057);
-const Queue = __webpack_require__(65930);
-const { intersect } = __webpack_require__(93347);
+		this.inFunctionScope(true, scopeParams, () => {
+			for (const param of expression.params) {
+				this.walkPattern(param);
+			}
+			if (expression.body.type === "BlockStatement") {
+				this.detectMode(expression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(expression.body);
+				this.prevStatement = prev;
+				this.walkStatement(expression.body);
+			} else {
+				this.walkExpression(expression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	walkArrowFunctionExpression(expression) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
+		this.inFunctionScope(false, expression.params, () => {
+			for (const param of expression.params) {
+				this.walkPattern(param);
+			}
+			if (expression.body.type === "BlockStatement") {
+				this.detectMode(expression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(expression.body);
+				this.prevStatement = prev;
+				this.walkStatement(expression.body);
+			} else {
+				this.walkExpression(expression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
 
-class RemoveParentModulesPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
+	 * @param {SequenceExpressionNode} expression the sequence
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
-			const handler = (chunks, chunkGroups) => {
-				const chunkGraph = compilation.chunkGraph;
-				const queue = new Queue();
-				const availableModulesMap = new WeakMap();
+	walkSequenceExpression(expression) {
+		if (!expression.expressions) return;
+		// We treat sequence expressions like statements when they are one statement level
+		// This has some benefits for optimizations that only work on statement level
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		if (
+			currentStatement === expression ||
+			(currentStatement.type === "ExpressionStatement" &&
+				currentStatement.expression === expression)
+		) {
+			const old = this.statementPath.pop();
+			for (const expr of expression.expressions) {
+				this.statementPath.push(expr);
+				this.walkExpression(expr);
+				this.statementPath.pop();
+			}
+			this.statementPath.push(old);
+		} else {
+			this.walkExpressions(expression.expressions);
+		}
+	}
 
-				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);
-					}
-				}
-				for (const chunkGroup of compilation.asyncEntrypoints) {
-					// initialize available modules for chunks without parents
-					availableModulesMap.set(chunkGroup, new Set());
-					for (const child of chunkGroup.childrenIterable) {
-						queue.enqueue(child);
-					}
-				}
+	walkUpdateExpression(expression) {
+		this.walkExpression(expression.argument);
+	}
 
-				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 chunkGraph.getChunkModulesIterable(chunk)) {
-										availableModules.add(m);
-									}
-								}
-								availableModulesMap.set(chunkGroup, availableModules);
-								changed = true;
-							} else {
-								for (const m of availableModules) {
-									if (
-										!chunkGraph.isModuleInChunkGroup(m, parent) &&
-										!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);
-						}
+	walkUnaryExpression(expression) {
+		if (expression.operator === "typeof") {
+			const result = this.callHooksForExpression(
+				this.hooks.typeof,
+				expression.argument,
+				expression
+			);
+			if (result === true) return;
+			if (expression.argument.type === "ChainExpression") {
+				const result = this.callHooksForExpression(
+					this.hooks.typeof,
+					expression.argument.expression,
+					expression
+				);
+				if (result === true) return;
+			}
+		}
+		this.walkExpression(expression.argument);
+	}
+
+	walkLeftRightExpression(expression) {
+		this.walkExpression(expression.left);
+		this.walkExpression(expression.right);
+	}
+
+	walkBinaryExpression(expression) {
+		this.walkLeftRightExpression(expression);
+	}
+
+	walkLogicalExpression(expression) {
+		const result = this.hooks.expressionLogicalOperator.call(expression);
+		if (result === undefined) {
+			this.walkLeftRightExpression(expression);
+		} else {
+			if (result) {
+				this.walkExpression(expression.right);
+			}
+		}
+	}
+
+	walkAssignmentExpression(expression) {
+		if (expression.left.type === "Identifier") {
+			const renameIdentifier = this.getRenameIdentifier(expression.right);
+			if (renameIdentifier) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.canRename,
+						renameIdentifier,
+						expression.right
+					)
+				) {
+					// renaming "a = b;"
+					if (
+						!this.callHooksForInfo(
+							this.hooks.rename,
+							renameIdentifier,
+							expression.right
+						)
+					) {
+						this.setVariable(
+							expression.left.name,
+							this.getVariableInfo(renameIdentifier)
+						);
 					}
+					return;
 				}
-
-				// 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 = chunkGraph.getNumberOfChunkModules(chunk);
-					const toRemove = new Set();
-					if (numberOfModules < availableModules.size) {
-						for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-							if (availableModules.has(m)) {
-								toRemove.add(m);
-							}
-						}
-					} else {
-						for (const m of availableModules) {
-							if (chunkGraph.isModuleInChunk(m, chunk)) {
-								toRemove.add(m);
-							}
-						}
-					}
-					for (const module of toRemove) {
-						chunkGraph.disconnectChunkAndModule(chunk, module);
-					}
+			}
+			this.walkExpression(expression.right);
+			this.enterPattern(expression.left, (name, decl) => {
+				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+					this.walkExpression(expression.left);
 				}
-			};
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "RemoveParentModulesPlugin",
-					stage: STAGE_BASIC
-				},
-				handler
+			});
+			return;
+		}
+		if (expression.left.type.endsWith("Pattern")) {
+			this.walkExpression(expression.right);
+			this.enterPattern(expression.left, (name, decl) => {
+				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+					this.defineVariable(name);
+				}
+			});
+			this.walkPattern(expression.left);
+		} else if (expression.left.type === "MemberExpression") {
+			const exprName = this.getMemberExpressionInfo(
+				expression.left,
+				ALLOWED_MEMBER_TYPES_EXPRESSION
 			);
-		});
+			if (exprName) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.assignMemberChain,
+						exprName.rootInfo,
+						expression,
+						exprName.getMembers()
+					)
+				) {
+					return;
+				}
+			}
+			this.walkExpression(expression.right);
+			this.walkExpression(expression.left);
+		} else {
+			this.walkExpression(expression.right);
+			this.walkExpression(expression.left);
+		}
 	}
-}
-module.exports = RemoveParentModulesPlugin;
 
+	walkConditionalExpression(expression) {
+		const result = this.hooks.expressionConditionalOperator.call(expression);
+		if (result === undefined) {
+			this.walkExpression(expression.test);
+			this.walkExpression(expression.consequent);
+			if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
+		} else {
+			if (result) {
+				this.walkExpression(expression.consequent);
+			} else if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
+		}
+	}
 
-/***/ }),
-
-/***/ 2837:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	walkNewExpression(expression) {
+		const result = this.callHooksForExpression(
+			this.hooks.new,
+			expression.callee,
+			expression
+		);
+		if (result === true) return;
+		this.walkExpression(expression.callee);
+		if (expression.arguments) {
+			this.walkExpressions(expression.arguments);
+		}
+	}
 
+	walkYieldExpression(expression) {
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
+	}
 
+	walkTemplateLiteral(expression) {
+		if (expression.expressions) {
+			this.walkExpressions(expression.expressions);
+		}
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	walkTaggedTemplateExpression(expression) {
+		if (expression.tag) {
+			this.walkExpression(expression.tag);
+		}
+		if (expression.quasi && expression.quasi.expressions) {
+			this.walkExpressions(expression.quasi.expressions);
+		}
+	}
 
-class RuntimeChunkPlugin {
-	constructor(options) {
-		this.options = {
-			name: entrypoint => `runtime~${entrypoint.name}`,
-			...options
-		};
+	walkClassExpression(expression) {
+		this.walkClass(expression);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {ChainExpressionNode} expression expression
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
-			compilation.hooks.addEntry.tap(
-				"RuntimeChunkPlugin",
-				(_, { name: entryName }) => {
-					if (entryName === undefined) return;
-					const data = compilation.entries.get(entryName);
-					if (data.options.runtime === undefined && !data.options.dependOn) {
-						// Determine runtime chunk name
-						let name = this.options.name;
-						if (typeof name === "function") {
-							name = name({ name: entryName });
-						}
-						data.options.runtime = name;
+	walkChainExpression(expression) {
+		const result = this.hooks.optionalChaining.call(expression);
+
+		if (result === undefined) {
+			if (expression.expression.type === "CallExpression") {
+				this.walkCallExpression(expression.expression);
+			} else {
+				this.walkMemberExpression(expression.expression);
+			}
+		}
+	}
+
+	_walkIIFE(functionExpression, options, currentThis) {
+		const getVarInfo = argOrThis => {
+			const renameIdentifier = this.getRenameIdentifier(argOrThis);
+			if (renameIdentifier) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.canRename,
+						renameIdentifier,
+						argOrThis
+					)
+				) {
+					if (
+						!this.callHooksForInfo(
+							this.hooks.rename,
+							renameIdentifier,
+							argOrThis
+						)
+					) {
+						return this.getVariableInfo(renameIdentifier);
 					}
 				}
-			);
+			}
+			this.walkExpression(argOrThis);
+		};
+		const { params, type } = functionExpression;
+		const arrow = type === "ArrowFunctionExpression";
+		const renameThis = currentThis ? getVarInfo(currentThis) : null;
+		const varInfoForArgs = options.map(getVarInfo);
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = wasTopLevel && arrow ? "arrow" : false;
+		const scopeParams = params.filter(
+			(identifier, idx) => !varInfoForArgs[idx]
+		);
+
+		// Add function name in scope for recursive calls
+		if (functionExpression.id) {
+			scopeParams.push(functionExpression.id.name);
+		}
+
+		this.inFunctionScope(true, scopeParams, () => {
+			if (renameThis && !arrow) {
+				this.setVariable("this", renameThis);
+			}
+			for (let i = 0; i < varInfoForArgs.length; i++) {
+				const varInfo = varInfoForArgs[i];
+				if (!varInfo) continue;
+				if (!params[i] || params[i].type !== "Identifier") continue;
+				this.setVariable(params[i].name, varInfo);
+			}
+			if (functionExpression.body.type === "BlockStatement") {
+				this.detectMode(functionExpression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(functionExpression.body);
+				this.prevStatement = prev;
+				this.walkStatement(functionExpression.body);
+			} else {
+				this.walkExpression(functionExpression.body);
+			}
 		});
+		this.scope.topLevelScope = wasTopLevel;
 	}
-}
-
-module.exports = RuntimeChunkPlugin;
 
+	walkImportExpression(expression) {
+		let result = this.hooks.importCall.call(expression);
+		if (result === true) return;
 
-/***/ }),
+		this.walkExpression(expression.source);
+	}
 
-/***/ 84800:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	walkCallExpression(expression) {
+		const isSimpleFunction = fn => {
+			return fn.params.every(p => p.type === "Identifier");
+		};
+		if (
+			expression.callee.type === "MemberExpression" &&
+			expression.callee.object.type.endsWith("FunctionExpression") &&
+			!expression.callee.computed &&
+			(expression.callee.property.name === "call" ||
+				expression.callee.property.name === "bind") &&
+			expression.arguments.length > 0 &&
+			isSimpleFunction(expression.callee.object)
+		) {
+			// (function(…) { }.call/bind(?, …))
+			this._walkIIFE(
+				expression.callee.object,
+				expression.arguments.slice(1),
+				expression.arguments[0]
+			);
+		} else if (
+			expression.callee.type.endsWith("FunctionExpression") &&
+			isSimpleFunction(expression.callee)
+		) {
+			// (function(…) { }(…))
+			this._walkIIFE(expression.callee, expression.arguments, null);
+		} else {
+			if (expression.callee.type === "MemberExpression") {
+				const exprInfo = this.getMemberExpressionInfo(
+					expression.callee,
+					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
+				);
+				if (exprInfo && exprInfo.type === "call") {
+					const result = this.callHooksForInfo(
+						this.hooks.callMemberChainOfCallMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						exprInfo.getCalleeMembers(),
+						exprInfo.call,
+						exprInfo.getMembers()
+					);
+					if (result === true) return;
+				}
+			}
+			const callee = this.evaluateExpression(expression.callee);
+			if (callee.isIdentifier()) {
+				const result1 = this.callHooksForInfo(
+					this.hooks.callMemberChain,
+					callee.rootInfo,
+					expression,
+					callee.getMembers()
+				);
+				if (result1 === true) return;
+				const result2 = this.callHooksForInfo(
+					this.hooks.call,
+					callee.identifier,
+					expression
+				);
+				if (result2 === true) return;
+			}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			if (expression.callee) {
+				if (expression.callee.type === "MemberExpression") {
+					// because of call context we need to walk the call context as expression
+					this.walkExpression(expression.callee.object);
+					if (expression.callee.computed === true)
+						this.walkExpression(expression.callee.property);
+				} else {
+					this.walkExpression(expression.callee);
+				}
+			}
+			if (expression.arguments) this.walkExpressions(expression.arguments);
+		}
+	}
 
+	walkMemberExpression(expression) {
+		const exprInfo = this.getMemberExpressionInfo(
+			expression,
+			ALLOWED_MEMBER_TYPES_ALL
+		);
+		if (exprInfo) {
+			switch (exprInfo.type) {
+				case "expression": {
+					const result1 = this.callHooksForInfo(
+						this.hooks.expression,
+						exprInfo.name,
+						expression
+					);
+					if (result1 === true) return;
+					const members = exprInfo.getMembers();
+					const result2 = this.callHooksForInfo(
+						this.hooks.expressionMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						members
+					);
+					if (result2 === true) return;
+					this.walkMemberExpressionWithExpressionName(
+						expression,
+						exprInfo.name,
+						exprInfo.rootInfo,
+						members.slice(),
+						() =>
+							this.callHooksForInfo(
+								this.hooks.unhandledExpressionMemberChain,
+								exprInfo.rootInfo,
+								expression,
+								members
+							)
+					);
+					return;
+				}
+				case "call": {
+					const result = this.callHooksForInfo(
+						this.hooks.memberChainOfCallMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						exprInfo.getCalleeMembers(),
+						exprInfo.call,
+						exprInfo.getMembers()
+					);
+					if (result === true) return;
+					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
+					// and call computed property are literals anyway
+					this.walkExpression(exprInfo.call);
+					return;
+				}
+			}
+		}
+		this.walkExpression(expression.object);
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
 
+	walkMemberExpressionWithExpressionName(
+		expression,
+		name,
+		rootInfo,
+		members,
+		onUnhandled
+	) {
+		if (expression.object.type === "MemberExpression") {
+			// optimize the case where expression.object is a MemberExpression too.
+			// we can keep info here when calling walkMemberExpression directly
+			const property =
+				expression.property.name || `${expression.property.value}`;
+			name = name.slice(0, -property.length - 1);
+			members.pop();
+			const result = this.callHooksForInfo(
+				this.hooks.expression,
+				name,
+				expression.object
+			);
+			if (result === true) return;
+			this.walkMemberExpressionWithExpressionName(
+				expression.object,
+				name,
+				rootInfo,
+				members,
+				onUnhandled
+			);
+		} else if (!onUnhandled || !onUnhandled()) {
+			this.walkExpression(expression.object);
+		}
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
 
-const glob2regexp = __webpack_require__(86140);
-const { STAGE_DEFAULT } = __webpack_require__(80057);
-const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
-const HarmonyImportSpecifierDependency = __webpack_require__(14077);
-const formatLocation = __webpack_require__(16734);
+	walkThisExpression(expression) {
+		this.callHooksForName(this.hooks.expression, "this", expression);
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+	walkIdentifier(expression) {
+		this.callHooksForName(this.hooks.expression, expression.name, expression);
+	}
 
-/**
- * @typedef {Object} ExportInModule
- * @property {Module} module the module
- * @property {string} exportName the name of the export
- * @property {boolean} checked if the export is conditional
- */
+	/**
+	 * @param {MetaPropertyNode} metaProperty meta property
+	 */
+	walkMetaProperty(metaProperty) {
+		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
+	}
 
-/**
- * @typedef {Object} ReexportInfo
- * @property {Map<string, ExportInModule[]>} static
- * @property {Map<Module, Set<string>>} dynamic
- */
+	callHooksForExpression(hookMap, expr, ...args) {
+		return this.callHooksForExpressionWithFallback(
+			hookMap,
+			expr,
+			undefined,
+			undefined,
+			...args
+		);
+	}
 
-/** @type {WeakMap<any, Map<string, RegExp>>} */
-const globToRegexpCache = new WeakMap();
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {MemberExpressionNode} expr expression info
+	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
+	 * @param {function(string): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForExpressionWithFallback(
+		hookMap,
+		expr,
+		fallback,
+		defined,
+		...args
+	) {
+		const exprName = this.getMemberExpressionInfo(
+			expr,
+			ALLOWED_MEMBER_TYPES_EXPRESSION
+		);
+		if (exprName !== undefined) {
+			const members = exprName.getMembers();
+			return this.callHooksForInfoWithFallback(
+				hookMap,
+				members.length === 0 ? exprName.rootInfo : exprName.name,
+				fallback &&
+					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
+				defined && (() => defined(exprName.name)),
+				...args
+			);
+		}
+	}
 
-/**
- * @param {string} glob the pattern
- * @param {Map<string, RegExp>} cache the glob to RegExp cache
- * @returns {RegExp} a regular expression
- */
-const globToRegexp = (glob, cache) => {
-	const cacheEntry = cache.get(glob);
-	if (cacheEntry !== undefined) return cacheEntry;
-	if (!glob.includes("/")) {
-		glob = `**/${glob}`;
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {string} name key in map
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForName(hookMap, name, ...args) {
+		return this.callHooksForNameWithFallback(
+			hookMap,
+			name,
+			undefined,
+			undefined,
+			...args
+		);
 	}
-	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
-	const regexpSource = baseRegexp.source;
-	const regexp = new RegExp("^(\\./)?" + regexpSource.slice(1));
-	cache.set(glob, regexp);
-	return regexp;
-};
 
-class SideEffectsFlagPlugin {
 	/**
-	 * @param {boolean} analyseSource analyse source code for side effects
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param  {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
 	 */
-	constructor(analyseSource = true) {
-		this._analyseSource = analyseSource;
+	callHooksForInfo(hookMap, info, ...args) {
+		return this.callHooksForInfoWithFallback(
+			hookMap,
+			info,
+			undefined,
+			undefined,
+			...args
+		);
 	}
+
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param {function(string): any} fallback callback when variable in not handled by hooks
+	 * @param {function(): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
 	 */
-	apply(compiler) {
-		let cache = globToRegexpCache.get(compiler.root);
-		if (cache === undefined) {
-			cache = new Map();
-			globToRegexpCache.set(compiler.root, cache);
-		}
-		compiler.hooks.compilation.tap(
-			"SideEffectsFlagPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const moduleGraph = compilation.moduleGraph;
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						const resolveData = data.resourceResolveData;
-						if (
-							resolveData &&
-							resolveData.descriptionFileData &&
-							resolveData.relativePath
-						) {
-							const sideEffects = resolveData.descriptionFileData.sideEffects;
-							if (sideEffects !== undefined) {
-								if (module.factoryMeta === undefined) {
-									module.factoryMeta = {};
-								}
-								const hasSideEffects =
-									SideEffectsFlagPlugin.moduleHasSideEffects(
-										resolveData.relativePath,
-										sideEffects,
-										cache
-									);
-								module.factoryMeta.sideEffectFree = !hasSideEffects;
-							}
-						}
-
-						return module;
-					}
-				);
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						if (typeof data.settings.sideEffects === "boolean") {
-							if (module.factoryMeta === undefined) {
-								module.factoryMeta = {};
-							}
-							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
-						}
-						return module;
-					}
-				);
-				if (this._analyseSource) {
-					/**
-					 * @param {JavascriptParser} parser the parser
-					 * @returns {void}
-					 */
-					const parserHandler = parser => {
-						let sideEffectsStatement;
-						parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
-							sideEffectsStatement = undefined;
-						});
-						parser.hooks.statement.tap(
-							{ name: "SideEffectsFlagPlugin", stage: -100 },
-							statement => {
-								if (sideEffectsStatement) return;
-								if (parser.scope.topLevelScope !== true) return;
-								switch (statement.type) {
-									case "ExpressionStatement":
-										if (
-											!parser.isPure(statement.expression, statement.range[0])
-										) {
-											sideEffectsStatement = statement;
-										}
-										break;
-									case "IfStatement":
-									case "WhileStatement":
-									case "DoWhileStatement":
-										if (!parser.isPure(statement.test, statement.range[0])) {
-											sideEffectsStatement = statement;
-										}
-										// statement hook will be called for child statements too
-										break;
-									case "ForStatement":
-										if (
-											!parser.isPure(statement.init, statement.range[0]) ||
-											!parser.isPure(
-												statement.test,
-												statement.init
-													? statement.init.range[1]
-													: statement.range[0]
-											) ||
-											!parser.isPure(
-												statement.update,
-												statement.test
-													? statement.test.range[1]
-													: statement.init
-													? statement.init.range[1]
-													: statement.range[0]
-											)
-										) {
-											sideEffectsStatement = statement;
-										}
-										// statement hook will be called for child statements too
-										break;
-									case "SwitchStatement":
-										if (
-											!parser.isPure(statement.discriminant, statement.range[0])
-										) {
-											sideEffectsStatement = statement;
-										}
-										// statement hook will be called for child statements too
-										break;
-									case "VariableDeclaration":
-									case "ClassDeclaration":
-									case "FunctionDeclaration":
-										if (!parser.isPure(statement, statement.range[0])) {
-											sideEffectsStatement = statement;
-										}
-										break;
-									case "ExportNamedDeclaration":
-									case "ExportDefaultDeclaration":
-										if (
-											!parser.isPure(statement.declaration, statement.range[0])
-										) {
-											sideEffectsStatement = statement;
-										}
-										break;
-									case "LabeledStatement":
-									case "BlockStatement":
-										// statement hook will be called for child statements too
-										break;
-									case "EmptyStatement":
-										break;
-									case "ExportAllDeclaration":
-									case "ImportDeclaration":
-										// imports will be handled by the dependencies
-										break;
-									default:
-										sideEffectsStatement = statement;
-										break;
-								}
-							}
-						);
-						parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
-							if (sideEffectsStatement === undefined) {
-								parser.state.module.buildMeta.sideEffectFree = true;
-							} else {
-								const { loc, type } = sideEffectsStatement;
-								moduleGraph
-									.getOptimizationBailout(parser.state.module)
-									.push(
-										() =>
-											`Statement (${type}) with side effects in source code at ${formatLocation(
-												loc
-											)}`
-									);
-							}
-						});
-					};
-					for (const key of [
-						"javascript/auto",
-						"javascript/esm",
-						"javascript/dynamic"
-					]) {
-						normalModuleFactory.hooks.parser
-							.for(key)
-							.tap("SideEffectsFlagPlugin", parserHandler);
-					}
+	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
+		let name;
+		if (typeof info === "string") {
+			name = info;
+		} else {
+			if (!(info instanceof VariableInfo)) {
+				if (defined !== undefined) {
+					return defined();
 				}
-				compilation.hooks.optimizeDependencies.tap(
-					{
-						name: "SideEffectsFlagPlugin",
-						stage: STAGE_DEFAULT
-					},
-					modules => {
-						const logger = compilation.getLogger(
-							"webpack.SideEffectsFlagPlugin"
-						);
-
-						logger.time("update dependencies");
-						for (const module of modules) {
-							if (module.getSideEffectsConnectionState(moduleGraph) === false) {
-								const exportsInfo = moduleGraph.getExportsInfo(module);
-								for (const connection of moduleGraph.getIncomingConnections(
-									module
-								)) {
-									const dep = connection.dependency;
-									let isReexport;
-									if (
-										(isReexport =
-											dep instanceof
-											HarmonyExportImportedSpecifierDependency) ||
-										(dep instanceof HarmonyImportSpecifierDependency &&
-											!dep.namespaceObjectAsContext)
-									) {
-										// TODO improve for export *
-										if (isReexport && dep.name) {
-											const exportInfo = moduleGraph.getExportInfo(
-												connection.originModule,
-												dep.name
-											);
-											exportInfo.moveTarget(
-												moduleGraph,
-												({ module }) =>
-													module.getSideEffectsConnectionState(moduleGraph) ===
-													false,
-												({ module: newModule, export: exportName }) => {
-													moduleGraph.updateModule(dep, newModule);
-													moduleGraph.addExplanation(
-														dep,
-														"(skipped side-effect-free modules)"
-													);
-													const ids = dep.getIds(moduleGraph);
-													dep.setIds(
-														moduleGraph,
-														exportName
-															? [...exportName, ...ids.slice(1)]
-															: ids.slice(1)
-													);
-													return moduleGraph.getConnection(dep);
-												}
-											);
-											continue;
-										}
-										// TODO improve for nested imports
-										const ids = dep.getIds(moduleGraph);
-										if (ids.length > 0) {
-											const exportInfo = exportsInfo.getExportInfo(ids[0]);
-											const target = exportInfo.getTarget(
-												moduleGraph,
-												({ module }) =>
-													module.getSideEffectsConnectionState(moduleGraph) ===
-													false
-											);
-											if (!target) continue;
-
-											moduleGraph.updateModule(dep, target.module);
-											moduleGraph.addExplanation(
-												dep,
-												"(skipped side-effect-free modules)"
-											);
-											dep.setIds(
-												moduleGraph,
-												target.export
-													? [...target.export, ...ids.slice(1)]
-													: ids.slice(1)
-											);
-										}
-									}
-								}
-							}
-						}
-						logger.timeEnd("update dependencies");
-					}
-				);
+				return;
 			}
-		);
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				const hook = hookMap.get(tagInfo.tag);
+				if (hook !== undefined) {
+					this.currentTagData = tagInfo.data;
+					const result = hook.call(...args);
+					this.currentTagData = undefined;
+					if (result !== undefined) return result;
+				}
+				tagInfo = tagInfo.next;
+			}
+			if (info.freeName === true) {
+				if (defined !== undefined) {
+					return defined();
+				}
+				return;
+			}
+			name = info.freeName;
+		}
+		const hook = hookMap.get(name);
+		if (hook !== undefined) {
+			const result = hook.call(...args);
+			if (result !== undefined) return result;
+		}
+		if (fallback !== undefined) {
+			return fallback(name);
+		}
 	}
 
-	static moduleHasSideEffects(moduleName, flagValue, cache) {
-		switch (typeof flagValue) {
-			case "undefined":
-				return true;
-			case "boolean":
-				return flagValue;
-			case "string":
-				return globToRegexp(flagValue, cache).test(moduleName);
-			case "object":
-				return flagValue.some(glob =>
-					SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob, cache)
-				);
-		}
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {string} name key in map
+	 * @param {function(string): any} fallback callback when variable in not handled by hooks
+	 * @param {function(): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
+		return this.callHooksForInfoWithFallback(
+			hookMap,
+			this.getVariableInfo(name),
+			fallback,
+			defined,
+			...args
+		);
 	}
-}
-module.exports = SideEffectsFlagPlugin;
 
+	/**
+	 * @deprecated
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
+	inScope(params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
 
-/***/ }),
+		this.undefineVariable("this");
 
-/***/ 21478:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		fn();
 
+		this.scope = oldScope;
+	}
 
+	inFunctionScope(hasThis, params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
 
-const Chunk = __webpack_require__(39385);
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const WebpackError = __webpack_require__(53799);
-const { requestToId } = __webpack_require__(63290);
-const { isSubset } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-const {
-	compareModulesByIdentifier,
-	compareIterables
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const deterministicGrouping = __webpack_require__(59836);
-const { makePathsRelative } = __webpack_require__(82186);
-const memoize = __webpack_require__(78676);
-const MinMaxSizeWarning = __webpack_require__(85305);
+		if (hasThis) {
+			this.undefineVariable("this");
+		}
 
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
-/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
-/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
 
-/** @typedef {Record<string, number>} SplitChunksSizes */
+		fn();
 
-/**
- * @callback ChunkFilterFunction
- * @param {Chunk} chunk
- * @returns {boolean}
- */
+		this.scope = oldScope;
+	}
 
-/**
- * @callback CombineSizeFunction
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
+	inBlockScope(fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: oldScope.inTry,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
 
-/**
- * @typedef {Object} CacheGroupSource
- * @property {string=} key
- * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
- * @property {boolean=} enforce
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} minSizeReduction
- * @property {SplitChunksSizes} minRemainingSize
- * @property {SplitChunksSizes} enforceSizeThreshold
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
- * @property {string=} idHint
- * @property {string} automaticNameDelimiter
- * @property {boolean=} reuseExistingChunk
- * @property {boolean=} usedExports
- */
+		fn();
 
-/**
- * @typedef {Object} CacheGroup
- * @property {string} key
- * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} minSizeReduction
- * @property {SplitChunksSizes} minRemainingSize
- * @property {SplitChunksSizes} enforceSizeThreshold
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
- * @property {string=} idHint
- * @property {string} automaticNameDelimiter
- * @property {boolean} reuseExistingChunk
- * @property {boolean} usedExports
- * @property {boolean} _validateSize
- * @property {boolean} _validateRemainingSize
- * @property {SplitChunksSizes} _minSizeForMaxSize
- * @property {boolean} _conditionalEnforce
- */
+		this.scope = oldScope;
+	}
 
-/**
- * @typedef {Object} FallbackCacheGroup
- * @property {ChunkFilterFunction} chunksFilter
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {SplitChunksSizes} maxInitialSize
- * @property {string} automaticNameDelimiter
- */
+	detectMode(statements) {
+		const isLiteral =
+			statements.length >= 1 &&
+			statements[0].type === "ExpressionStatement" &&
+			statements[0].expression.type === "Literal";
+		if (isLiteral && statements[0].expression.value === "use strict") {
+			this.scope.isStrict = true;
+		}
+		if (isLiteral && statements[0].expression.value === "use asm") {
+			this.scope.isAsmJs = true;
+		}
+	}
 
-/**
- * @typedef {Object} CacheGroupsContext
- * @property {ModuleGraph} moduleGraph
- * @property {ChunkGraph} chunkGraph
- */
+	enterPatterns(patterns, onIdent) {
+		for (const pattern of patterns) {
+			if (typeof pattern !== "string") {
+				this.enterPattern(pattern, onIdent);
+			} else if (pattern) {
+				onIdent(pattern);
+			}
+		}
+	}
 
-/**
- * @callback GetCacheGroups
- * @param {Module} module
- * @param {CacheGroupsContext} context
- * @returns {CacheGroupSource[]}
- */
+	enterPattern(pattern, onIdent) {
+		if (!pattern) return;
+		switch (pattern.type) {
+			case "ArrayPattern":
+				this.enterArrayPattern(pattern, onIdent);
+				break;
+			case "AssignmentPattern":
+				this.enterAssignmentPattern(pattern, onIdent);
+				break;
+			case "Identifier":
+				this.enterIdentifier(pattern, onIdent);
+				break;
+			case "ObjectPattern":
+				this.enterObjectPattern(pattern, onIdent);
+				break;
+			case "RestElement":
+				this.enterRestElement(pattern, onIdent);
+				break;
+			case "Property":
+				if (pattern.shorthand && pattern.value.type === "Identifier") {
+					this.scope.inShorthand = pattern.value.name;
+					this.enterIdentifier(pattern.value, onIdent);
+					this.scope.inShorthand = false;
+				} else {
+					this.enterPattern(pattern.value, onIdent);
+				}
+				break;
+		}
+	}
 
-/**
- * @callback GetName
- * @param {Module=} module
- * @param {Chunk[]=} chunks
- * @param {string=} key
- * @returns {string=}
- */
+	enterIdentifier(pattern, onIdent) {
+		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
+			onIdent(pattern.name, pattern);
+		}
+	}
 
-/**
- * @typedef {Object} SplitChunksOptions
- * @property {ChunkFilterFunction} chunksFilter
- * @property {string[]} defaultSizeTypes
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} minSizeReduction
- * @property {SplitChunksSizes} minRemainingSize
- * @property {SplitChunksSizes} enforceSizeThreshold
- * @property {SplitChunksSizes} maxInitialSize
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {number} minChunks
- * @property {number} maxAsyncRequests
- * @property {number} maxInitialRequests
- * @property {boolean} hidePathInfo
- * @property {string | function(PathData, AssetInfo=): string} filename
- * @property {string} automaticNameDelimiter
- * @property {GetCacheGroups} getCacheGroups
- * @property {GetName} getName
- * @property {boolean} usedExports
- * @property {FallbackCacheGroup} fallbackCacheGroup
- */
+	enterObjectPattern(pattern, onIdent) {
+		for (
+			let propIndex = 0, len = pattern.properties.length;
+			propIndex < len;
+			propIndex++
+		) {
+			const prop = pattern.properties[propIndex];
+			this.enterPattern(prop, onIdent);
+		}
+	}
 
-/**
- * @typedef {Object} ChunksInfoItem
- * @property {SortableSet<Module>} modules
- * @property {CacheGroup} cacheGroup
- * @property {number} cacheGroupIndex
- * @property {string} name
- * @property {Record<string, number>} sizes
- * @property {Set<Chunk>} chunks
- * @property {Set<Chunk>} reuseableChunks
- * @property {Set<bigint | Chunk>} chunksKeys
- */
+	enterArrayPattern(pattern, onIdent) {
+		for (
+			let elementIndex = 0, len = pattern.elements.length;
+			elementIndex < len;
+			elementIndex++
+		) {
+			const element = pattern.elements[elementIndex];
+			this.enterPattern(element, onIdent);
+		}
+	}
 
-const defaultGetName = /** @type {GetName} */ (() => {});
+	enterRestElement(pattern, onIdent) {
+		this.enterPattern(pattern.argument, onIdent);
+	}
 
-const deterministicGroupingForModules =
-	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
-		deterministicGrouping
-	);
+	enterAssignmentPattern(pattern, onIdent) {
+		this.enterPattern(pattern.left, onIdent);
+	}
 
-/** @type {WeakMap<Module, string>} */
-const getKeyCache = new WeakMap();
+	/**
+	 * @param {ExpressionNode} expression expression node
+	 * @returns {BasicEvaluatedExpression | undefined} evaluation result
+	 */
+	evaluateExpression(expression) {
+		try {
+			const hook = this.hooks.evaluate.get(expression.type);
+			if (hook !== undefined) {
+				const result = hook.call(expression);
+				if (result !== undefined) {
+					if (result) {
+						result.setExpression(expression);
+					}
+					return result;
+				}
+			}
+		} catch (e) {
+			console.warn(e);
+			// ignore error
+		}
+		return new BasicEvaluatedExpression()
+			.setRange(expression.range)
+			.setExpression(expression);
+	}
 
-/**
- * @param {string} name a filename to hash
- * @param {OutputOptions} outputOptions hash function used
- * @returns {string} hashed filename
- */
-const hashFilename = (name, outputOptions) => {
-	const digest = /** @type {string} */ (
-		createHash(outputOptions.hashFunction)
-			.update(name)
-			.digest(outputOptions.hashDigest)
-	);
-	return digest.slice(0, 8);
-};
+	parseString(expression) {
+		switch (expression.type) {
+			case "BinaryExpression":
+				if (expression.operator === "+") {
+					return (
+						this.parseString(expression.left) +
+						this.parseString(expression.right)
+					);
+				}
+				break;
+			case "Literal":
+				return expression.value + "";
+		}
+		throw new Error(
+			expression.type + " is not supported as parameter for require"
+		);
+	}
 
-/**
- * @param {Chunk} chunk the chunk
- * @returns {number} the number of requests
- */
-const getRequests = chunk => {
-	let requests = 0;
-	for (const chunkGroup of chunk.groupsIterable) {
-		requests = Math.max(requests, chunkGroup.chunks.length);
+	parseCalculatedString(expression) {
+		switch (expression.type) {
+			case "BinaryExpression":
+				if (expression.operator === "+") {
+					const left = this.parseCalculatedString(expression.left);
+					const right = this.parseCalculatedString(expression.right);
+					if (left.code) {
+						return {
+							range: left.range,
+							value: left.value,
+							code: true,
+							conditional: false
+						};
+					} else if (right.code) {
+						return {
+							range: [
+								left.range[0],
+								right.range ? right.range[1] : left.range[1]
+							],
+							value: left.value + right.value,
+							code: true,
+							conditional: false
+						};
+					} else {
+						return {
+							range: [left.range[0], right.range[1]],
+							value: left.value + right.value,
+							code: false,
+							conditional: false
+						};
+					}
+				}
+				break;
+			case "ConditionalExpression": {
+				const consequent = this.parseCalculatedString(expression.consequent);
+				const alternate = this.parseCalculatedString(expression.alternate);
+				const items = [];
+				if (consequent.conditional) {
+					items.push(...consequent.conditional);
+				} else if (!consequent.code) {
+					items.push(consequent);
+				} else {
+					break;
+				}
+				if (alternate.conditional) {
+					items.push(...alternate.conditional);
+				} else if (!alternate.code) {
+					items.push(alternate);
+				} else {
+					break;
+				}
+				return {
+					range: undefined,
+					value: "",
+					code: true,
+					conditional: items
+				};
+			}
+			case "Literal":
+				return {
+					range: expression.range,
+					value: expression.value + "",
+					code: false,
+					conditional: false
+				};
+		}
+		return {
+			range: undefined,
+			value: "",
+			code: true,
+			conditional: false
+		};
 	}
-	return requests;
-};
 
-const mapObject = (obj, fn) => {
-	const newObj = Object.create(null);
-	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], key);
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		let ast;
+		let comments;
+		const semicolons = new Set();
+		if (source === null) {
+			throw new Error("source must not be null");
+		}
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		}
+		if (typeof source === "object") {
+			ast = /** @type {ProgramNode} */ (source);
+			comments = source.comments;
+		} else {
+			comments = [];
+			ast = JavascriptParser._parse(source, {
+				sourceType: this.sourceType,
+				onComment: comments,
+				onInsertedSemicolon: pos => semicolons.add(pos)
+			});
+		}
+
+		const oldScope = this.scope;
+		const oldState = this.state;
+		const oldComments = this.comments;
+		const oldSemicolons = this.semicolons;
+		const oldStatementPath = this.statementPath;
+		const oldPrevStatement = this.prevStatement;
+		this.scope = {
+			topLevelScope: true,
+			inTry: false,
+			inShorthand: false,
+			isStrict: false,
+			isAsmJs: false,
+			definitions: new StackedMap()
+		};
+		/** @type {ParserState} */
+		this.state = state;
+		this.comments = comments;
+		this.semicolons = semicolons;
+		this.statementPath = [];
+		this.prevStatement = undefined;
+		if (this.hooks.program.call(ast, comments) === undefined) {
+			this.detectMode(ast.body);
+			this.preWalkStatements(ast.body);
+			this.prevStatement = undefined;
+			this.blockPreWalkStatements(ast.body);
+			this.prevStatement = undefined;
+			this.walkStatements(ast.body);
+		}
+		this.hooks.finish.call(ast, comments);
+		this.scope = oldScope;
+		/** @type {ParserState} */
+		this.state = oldState;
+		this.comments = oldComments;
+		this.semicolons = oldSemicolons;
+		this.statementPath = oldStatementPath;
+		this.prevStatement = oldPrevStatement;
+		return state;
 	}
-	return newObj;
-};
 
-/**
- * @template T
- * @param {Set<T>} a set
- * @param {Set<T>} b other set
- * @returns {boolean} true if at least one item of a is in b
- */
-const isOverlap = (a, b) => {
-	for (const item of a) {
-		if (b.has(item)) return true;
+	evaluate(source) {
+		const ast = JavascriptParser._parse("(" + source + ")", {
+			sourceType: this.sourceType,
+			locations: false
+		});
+		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
+			throw new Error("evaluate: Source is not a expression");
+		}
+		return this.evaluateExpression(ast.body[0].expression);
 	}
-	return false;
-};
 
-const compareModuleIterables = compareIterables(compareModulesByIdentifier);
+	/**
+	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
+	 * @param {number} commentsStartPos source position from which annotation comments are checked
+	 * @returns {boolean} true, when the expression is pure
+	 */
+	isPure(expr, commentsStartPos) {
+		if (!expr) return true;
+		const result = this.hooks.isPure
+			.for(expr.type)
+			.call(expr, commentsStartPos);
+		if (typeof result === "boolean") return result;
+		switch (expr.type) {
+			case "ClassDeclaration":
+			case "ClassExpression": {
+				if (expr.body.type !== "ClassBody") return false;
+				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
+					return false;
+				}
+				const items =
+					/** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (
+						expr.body.body
+					);
+				return items.every(
+					item =>
+						(!item.computed ||
+							!item.key ||
+							this.isPure(item.key, item.range[0])) &&
+						(!item.static ||
+							!item.value ||
+							this.isPure(
+								item.value,
+								item.key ? item.key.range[1] : item.range[0]
+							))
+				);
+			}
 
-/**
- * @param {ChunksInfoItem} a item
- * @param {ChunksInfoItem} b item
- * @returns {number} compare result
- */
-const compareEntries = (a, b) => {
-	// 1. by priority
-	const diffPriority = a.cacheGroup.priority - b.cacheGroup.priority;
-	if (diffPriority) return diffPriority;
-	// 2. by number of chunks
-	const diffCount = a.chunks.size - b.chunks.size;
-	if (diffCount) return diffCount;
-	// 3. by size reduction
-	const aSizeReduce = totalSize(a.sizes) * (a.chunks.size - 1);
-	const bSizeReduce = totalSize(b.sizes) * (b.chunks.size - 1);
-	const diffSizeReduce = aSizeReduce - bSizeReduce;
-	if (diffSizeReduce) return diffSizeReduce;
-	// 4. by cache group index
-	const indexDiff = b.cacheGroupIndex - a.cacheGroupIndex;
-	if (indexDiff) return indexDiff;
-	// 5. by number of modules (to be able to compare by identifier)
-	const modulesA = a.modules;
-	const modulesB = b.modules;
-	const diff = modulesA.size - modulesB.size;
-	if (diff) return diff;
-	// 6. by module identifiers
-	modulesA.sort();
-	modulesB.sort();
-	return compareModuleIterables(modulesA, modulesB);
-};
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+			case "Literal":
+			case "PrivateIdentifier":
+				return true;
 
-const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
-const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
-const ALL_CHUNK_FILTER = chunk => true;
+			case "VariableDeclaration":
+				return expr.declarations.every(decl =>
+					this.isPure(decl.init, decl.range[0])
+				);
 
-/**
- * @param {OptimizationSplitChunksSizes} value the sizes
- * @param {string[]} defaultSizeTypes the default size types
- * @returns {SplitChunksSizes} normalized representation
- */
-const normalizeSizes = (value, defaultSizeTypes) => {
-	if (typeof value === "number") {
-		/** @type {Record<string, number>} */
-		const o = {};
-		for (const sizeType of defaultSizeTypes) o[sizeType] = value;
-		return o;
-	} else if (typeof value === "object" && value !== null) {
-		return { ...value };
-	} else {
-		return {};
+			case "ConditionalExpression":
+				return (
+					this.isPure(expr.test, commentsStartPos) &&
+					this.isPure(expr.consequent, expr.test.range[1]) &&
+					this.isPure(expr.alternate, expr.consequent.range[1])
+				);
+
+			case "SequenceExpression":
+				return expr.expressions.every(expr => {
+					const pureFlag = this.isPure(expr, commentsStartPos);
+					commentsStartPos = expr.range[1];
+					return pureFlag;
+				});
+
+			case "CallExpression": {
+				const pureFlag =
+					expr.range[0] - commentsStartPos > 12 &&
+					this.getComments([commentsStartPos, expr.range[0]]).some(
+						comment =>
+							comment.type === "Block" &&
+							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = expr.callee.range[1];
+				return expr.arguments.every(arg => {
+					if (arg.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(arg, commentsStartPos);
+					commentsStartPos = arg.range[1];
+					return pureFlag;
+				});
+			}
+		}
+		const evaluated = this.evaluateExpression(expr);
+		return !evaluated.couldHaveSideEffects();
+	}
+
+	getComments(range) {
+		const [rangeStart, rangeEnd] = range;
+		const compare = (comment, needle) => comment.range[0] - needle;
+		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
+		let commentsInRange = [];
+		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
+			commentsInRange.push(this.comments[idx]);
+			idx++;
+		}
+
+		return commentsInRange;
 	}
-};
 
-/**
- * @param {...SplitChunksSizes} sizes the sizes
- * @returns {SplitChunksSizes} the merged sizes
- */
-const mergeSizes = (...sizes) => {
-	/** @type {SplitChunksSizes} */
-	let merged = {};
-	for (let i = sizes.length - 1; i >= 0; i--) {
-		merged = Object.assign(merged, sizes[i]);
+	/**
+	 * @param {number} pos source code position
+	 * @returns {boolean} true when a semicolon has been inserted before this position, false if not
+	 */
+	isAsiPosition(pos) {
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		if (currentStatement === undefined) throw new Error("Not in statement");
+		return (
+			// Either asking directly for the end position of the current statement
+			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
+			// Or asking for the start position of the current statement,
+			// here we have to check multiple things
+			(currentStatement.range[0] === pos &&
+				// is there a previous statement which might be relevant?
+				this.prevStatement !== undefined &&
+				// is the end position of the previous statement an ASI position?
+				this.semicolons.has(this.prevStatement.range[1]))
+		);
 	}
-	return merged;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @returns {boolean} true, if there are sizes > 0
- */
-const hasNonZeroSizes = sizes => {
-	for (const key of Object.keys(sizes)) {
-		if (sizes[key] > 0) return true;
+	/**
+	 * @param {number} pos source code position
+	 * @returns {void}
+	 */
+	unsetAsiPosition(pos) {
+		this.semicolons.delete(pos);
 	}
-	return false;
-};
 
-/**
- * @param {SplitChunksSizes} a first sizes
- * @param {SplitChunksSizes} b second sizes
- * @param {CombineSizeFunction} combine a function to combine sizes
- * @returns {SplitChunksSizes} the combine sizes
- */
-const combineSizes = (a, b, combine) => {
-	const aKeys = new Set(Object.keys(a));
-	const bKeys = new Set(Object.keys(b));
-	/** @type {SplitChunksSizes} */
-	const result = {};
-	for (const key of aKeys) {
-		if (bKeys.has(key)) {
-			result[key] = combine(a[key], b[key]);
-		} else {
-			result[key] = a[key];
+	isStatementLevelExpression(expr) {
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		return (
+			expr === currentStatement ||
+			(currentStatement.type === "ExpressionStatement" &&
+				currentStatement.expression === expr)
+		);
+	}
+
+	getTagData(name, tag) {
+		const info = this.scope.definitions.get(name);
+		if (info instanceof VariableInfo) {
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				if (tagInfo.tag === tag) return tagInfo.data;
+				tagInfo = tagInfo.next;
+			}
 		}
 	}
-	for (const key of bKeys) {
-		if (!aKeys.has(key)) {
-			result[key] = b[key];
+
+	tagVariable(name, tag, data) {
+		const oldInfo = this.scope.definitions.get(name);
+		/** @type {VariableInfo} */
+		let newInfo;
+		if (oldInfo === undefined) {
+			newInfo = new VariableInfo(this.scope, name, {
+				tag,
+				data,
+				next: undefined
+			});
+		} else if (oldInfo instanceof VariableInfo) {
+			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
+				tag,
+				data,
+				next: oldInfo.tagInfo
+			});
+		} else {
+			newInfo = new VariableInfo(oldInfo, true, {
+				tag,
+				data,
+				next: undefined
+			});
 		}
+		this.scope.definitions.set(name, newInfo);
 	}
-	return result;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @param {SplitChunksSizes} minSize the min sizes
- * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
- */
-const checkMinSize = (sizes, minSize) => {
-	for (const key of Object.keys(minSize)) {
-		const size = sizes[key];
-		if (size === undefined || size === 0) continue;
-		if (size < minSize[key]) return false;
+	defineVariable(name) {
+		const oldInfo = this.scope.definitions.get(name);
+		// Don't redefine variable in same scope to keep existing tags
+		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
+			return;
+		this.scope.definitions.set(name, this.scope);
 	}
-	return true;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @param {SplitChunksSizes} minSizeReduction the min sizes
- * @param {number} chunkCount number of chunks
- * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
- */
-const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
-	for (const key of Object.keys(minSizeReduction)) {
-		const size = sizes[key];
-		if (size === undefined || size === 0) continue;
-		if (size * chunkCount < minSizeReduction[key]) return false;
+	undefineVariable(name) {
+		this.scope.definitions.delete(name);
 	}
-	return true;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @param {SplitChunksSizes} minSize the min sizes
- * @returns {undefined | string[]} list of size types that are below min size
- */
-const getViolatingMinSizes = (sizes, minSize) => {
-	let list;
-	for (const key of Object.keys(minSize)) {
-		const size = sizes[key];
-		if (size === undefined || size === 0) continue;
-		if (size < minSize[key]) {
-			if (list === undefined) list = [key];
-			else list.push(key);
+	isVariableDefined(name) {
+		const info = this.scope.definitions.get(name);
+		if (info === undefined) return false;
+		if (info instanceof VariableInfo) {
+			return info.freeName === true;
 		}
+		return true;
 	}
-	return list;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @returns {number} the total size
- */
-const totalSize = sizes => {
-	let size = 0;
-	for (const key of Object.keys(sizes)) {
-		size += sizes[key];
+	/**
+	 * @param {string} name variable name
+	 * @returns {ExportedVariableInfo} info for this variable
+	 */
+	getVariableInfo(name) {
+		const value = this.scope.definitions.get(name);
+		if (value === undefined) {
+			return name;
+		} else {
+			return value;
+		}
 	}
-	return size;
-};
 
-/**
- * @param {false|string|Function} name the chunk name
- * @returns {GetName} a function to get the name of the chunk
- */
-const normalizeName = name => {
-	if (typeof name === "string") {
-		return () => name;
-	}
-	if (typeof name === "function") {
-		return /** @type {GetName} */ (name);
+	/**
+	 * @param {string} name variable name
+	 * @param {ExportedVariableInfo} variableInfo new info for this variable
+	 * @returns {void}
+	 */
+	setVariable(name, variableInfo) {
+		if (typeof variableInfo === "string") {
+			if (variableInfo === name) {
+				this.scope.definitions.delete(name);
+			} else {
+				this.scope.definitions.set(
+					name,
+					new VariableInfo(this.scope, variableInfo, undefined)
+				);
+			}
+		} else {
+			this.scope.definitions.set(name, variableInfo);
+		}
 	}
-};
 
-/**
- * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
- * @returns {ChunkFilterFunction} the chunk filter function
- */
-const normalizeChunksFilter = chunks => {
-	if (chunks === "initial") {
-		return INITIAL_CHUNK_FILTER;
+	parseCommentOptions(range) {
+		const comments = this.getComments(range);
+		if (comments.length === 0) {
+			return EMPTY_COMMENT_OPTIONS;
+		}
+		let options = {};
+		let errors = [];
+		for (const comment of comments) {
+			const { value } = comment;
+			if (value && webpackCommentRegExp.test(value)) {
+				// try compile only if webpack options comment is present
+				try {
+					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
+					Object.assign(options, val);
+				} catch (e) {
+					e.comment = comment;
+					errors.push(e);
+				}
+			}
+		}
+		return { options, errors };
 	}
-	if (chunks === "async") {
-		return ASYNC_CHUNK_FILTER;
+
+	/**
+	 * @param {MemberExpressionNode} expression a member expression
+	 * @returns {{ members: string[], object: ExpressionNode | SuperNode }} member names (reverse order) and remaining object
+	 */
+	extractMemberExpressionChain(expression) {
+		/** @type {AnyNode} */
+		let expr = expression;
+		const members = [];
+		while (expr.type === "MemberExpression") {
+			if (expr.computed) {
+				if (expr.property.type !== "Literal") break;
+				members.push(`${expr.property.value}`);
+			} else {
+				if (expr.property.type !== "Identifier") break;
+				members.push(expr.property.name);
+			}
+			expr = expr.object;
+		}
+		return {
+			members,
+			object: expr
+		};
 	}
-	if (chunks === "all") {
-		return ALL_CHUNK_FILTER;
+
+	/**
+	 * @param {string} varName variable name
+	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 */
+	getFreeInfoFromVariable(varName) {
+		const info = this.getVariableInfo(varName);
+		let name;
+		if (info instanceof VariableInfo) {
+			name = info.freeName;
+			if (typeof name !== "string") return undefined;
+		} else if (typeof info !== "string") {
+			return undefined;
+		} else {
+			name = info;
+		}
+		return { info, name };
 	}
-	if (typeof chunks === "function") {
-		return chunks;
+
+	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[]}} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[]}} ExpressionExpressionInfo */
+
+	/**
+	 * @param {MemberExpressionNode} expression a member expression
+	 * @param {number} allowedTypes which types should be returned, presented in bit mask
+	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 */
+	getMemberExpressionInfo(expression, allowedTypes) {
+		const { object, members } = this.extractMemberExpressionChain(expression);
+		switch (object.type) {
+			case "CallExpression": {
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
+					return undefined;
+				let callee = object.callee;
+				let rootMembers = EMPTY_ARRAY;
+				if (callee.type === "MemberExpression") {
+					({ object: callee, members: rootMembers } =
+						this.extractMemberExpressionChain(callee));
+				}
+				const rootName = getRootName(callee);
+				if (!rootName) return undefined;
+				const result = this.getFreeInfoFromVariable(rootName);
+				if (!result) return undefined;
+				const { info: rootInfo, name: resolvedRoot } = result;
+				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
+				return {
+					type: "call",
+					call: object,
+					calleeName,
+					rootInfo,
+					getCalleeMembers: memoize(() => rootMembers.reverse()),
+					name: objectAndMembersToName(`${calleeName}()`, members),
+					getMembers: memoize(() => members.reverse())
+				};
+			}
+			case "Identifier":
+			case "MetaProperty":
+			case "ThisExpression": {
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
+					return undefined;
+				const rootName = getRootName(object);
+				if (!rootName) return undefined;
+
+				const result = this.getFreeInfoFromVariable(rootName);
+				if (!result) return undefined;
+				const { info: rootInfo, name: resolvedRoot } = result;
+				return {
+					type: "expression",
+					name: objectAndMembersToName(resolvedRoot, members),
+					rootInfo,
+					getMembers: memoize(() => members.reverse())
+				};
+			}
+		}
 	}
-};
 
-/**
- * @param {GetCacheGroups | Record<string, false|string|RegExp|OptimizationSplitChunksGetCacheGroups|OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
- * @param {string[]} defaultSizeTypes the default size types
- * @returns {GetCacheGroups} a function to get the cache groups
- */
-const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
-	if (typeof cacheGroups === "function") {
-		return cacheGroups;
+	/**
+	 * @param {MemberExpressionNode} expression an expression
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 */
+	getNameForExpression(expression) {
+		return this.getMemberExpressionInfo(
+			expression,
+			ALLOWED_MEMBER_TYPES_EXPRESSION
+		);
 	}
-	if (typeof cacheGroups === "object" && cacheGroups !== null) {
-		/** @type {(function(Module, CacheGroupsContext, CacheGroupSource[]): void)[]} */
-		const handlers = [];
-		for (const key of Object.keys(cacheGroups)) {
-			const option = cacheGroups[key];
-			if (option === false) {
-				continue;
+
+	/**
+	 * @param {string} code source code
+	 * @param {ParseOptions} options parsing options
+	 * @returns {ProgramNode} parsed ast
+	 */
+	static _parse(code, options) {
+		const type = options ? options.sourceType : "module";
+		/** @type {AcornOptions} */
+		const parserOptions = {
+			...defaultParserOptions,
+			allowReturnOutsideFunction: type === "script",
+			...options,
+			sourceType: type === "auto" ? "module" : type
+		};
+
+		/** @type {AnyNode} */
+		let ast;
+		let error;
+		let threw = false;
+		try {
+			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+		} catch (e) {
+			error = e;
+			threw = true;
+		}
+
+		if (threw && type === "auto") {
+			parserOptions.sourceType = "script";
+			if (!("allowReturnOutsideFunction" in options)) {
+				parserOptions.allowReturnOutsideFunction = true;
 			}
-			if (typeof option === "string" || option instanceof RegExp) {
-				const source = createCacheGroupSource({}, key, defaultSizeTypes);
-				handlers.push((module, context, results) => {
-					if (checkTest(option, module, context)) {
-						results.push(source);
-					}
-				});
-			} else if (typeof option === "function") {
-				const cache = new WeakMap();
-				handlers.push((module, context, results) => {
-					const result = option(module);
-					if (result) {
-						const groups = Array.isArray(result) ? result : [result];
-						for (const group of groups) {
-							const cachedSource = cache.get(group);
-							if (cachedSource !== undefined) {
-								results.push(cachedSource);
-							} else {
-								const source = createCacheGroupSource(
-									group,
-									key,
-									defaultSizeTypes
-								);
-								cache.set(group, source);
-								results.push(source);
-							}
-						}
-					}
-				});
-			} else {
-				const source = createCacheGroupSource(option, key, defaultSizeTypes);
-				handlers.push((module, context, results) => {
-					if (
-						checkTest(option.test, module, context) &&
-						checkModuleType(option.type, module) &&
-						checkModuleLayer(option.layer, module)
-					) {
-						results.push(source);
-					}
-				});
+			if (Array.isArray(parserOptions.onComment)) {
+				parserOptions.onComment.length = 0;
 			}
-		}
-		/**
-		 * @param {Module} module the current module
-		 * @param {CacheGroupsContext} context the current context
-		 * @returns {CacheGroupSource[]} the matching cache groups
-		 */
-		const fn = (module, context) => {
-			/** @type {CacheGroupSource[]} */
-			let results = [];
-			for (const fn of handlers) {
-				fn(module, context, results);
+			try {
+				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+				threw = false;
+			} catch (e) {
+				// we use the error from first parse try
+				// so nothing to do here
 			}
-			return results;
-		};
-		return fn;
+		}
+
+		if (threw) {
+			throw error;
+		}
+
+		return /** @type {ProgramNode} */ (ast);
 	}
-	return () => null;
+}
+
+module.exports = JavascriptParser;
+module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
+module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_EXPRESSION;
+module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
+
+
+/***/ }),
+
+/***/ 93998:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const ConstDependency = __webpack_require__(76911);
+const BasicEvaluatedExpression = __webpack_require__(950);
+
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("./JavascriptParser")} JavascriptParser */
+
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} value the const value
+ * @param {string[]=} runtimeRequirements runtime requirements
+ * @returns {function(ExpressionNode): true} plugin function
+ */
+exports.toConstantDependency = (parser, value, runtimeRequirements) => {
+	return function constDependency(expr) {
+		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
+		dep.loc = expr.loc;
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	};
 };
 
 /**
- * @param {undefined|boolean|string|RegExp|Function} test test option
- * @param {Module} module the module
- * @param {CacheGroupsContext} context context object
- * @returns {boolean} true, if the module should be selected
+ * @param {string} value the string value
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
  */
-const checkTest = (test, module, context) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module, context);
-	}
-	if (typeof test === "boolean") return test;
-	if (typeof test === "string") {
-		const name = module.nameForCondition();
-		return name && name.startsWith(test);
-	}
-	if (test instanceof RegExp) {
-		const name = module.nameForCondition();
-		return name && test.test(name);
-	}
-	return false;
+exports.evaluateToString = value => {
+	return function stringExpression(expr) {
+		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+	};
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
- * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @param {number} value the number value
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
  */
-const checkModuleType = (test, module) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module.type);
-	}
-	if (typeof test === "string") {
-		const type = module.type;
-		return test === type;
-	}
-	if (test instanceof RegExp) {
-		const type = module.type;
-		return test.test(type);
-	}
-	return false;
+exports.evaluateToNumber = value => {
+	return function stringExpression(expr) {
+		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
+	};
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
- * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @param {boolean} value the boolean value
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
  */
-const checkModuleLayer = (test, module) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module.layer);
-	}
-	if (typeof test === "string") {
-		const layer = module.layer;
-		return test === "" ? !layer : layer && layer.startsWith(test);
-	}
-	if (test instanceof RegExp) {
-		const layer = module.layer;
-		return test.test(layer);
-	}
-	return false;
+exports.evaluateToBoolean = value => {
+	return function booleanExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setBoolean(value)
+			.setRange(expr.range);
+	};
 };
 
 /**
- * @param {OptimizationSplitChunksCacheGroup} options the group options
- * @param {string} key key of cache group
- * @param {string[]} defaultSizeTypes the default size types
- * @returns {CacheGroupSource} the normalized cached group
+ * @param {string} identifier identifier
+ * @param {string} rootInfo rootInfo
+ * @param {function(): string[]} getMembers getMembers
+ * @param {boolean|null=} truthy is truthy, null if nullish
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
  */
-const createCacheGroupSource = (options, key, defaultSizeTypes) => {
-	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
-	const minSizeReduction = normalizeSizes(
-		options.minSizeReduction,
-		defaultSizeTypes
-	);
-	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
-	return {
-		key,
-		priority: options.priority,
-		getName: normalizeName(options.name),
-		chunksFilter: normalizeChunksFilter(options.chunks),
-		enforce: options.enforce,
-		minSize,
-		minSizeReduction,
-		minRemainingSize: mergeSizes(
-			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
-			minSize
-		),
-		enforceSizeThreshold: normalizeSizes(
-			options.enforceSizeThreshold,
-			defaultSizeTypes
-		),
-		maxAsyncSize: mergeSizes(
-			normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
-			maxSize
-		),
-		maxInitialSize: mergeSizes(
-			normalizeSizes(options.maxInitialSize, defaultSizeTypes),
-			maxSize
-		),
-		minChunks: options.minChunks,
-		maxAsyncRequests: options.maxAsyncRequests,
-		maxInitialRequests: options.maxInitialRequests,
-		filename: options.filename,
-		idHint: options.idHint,
-		automaticNameDelimiter: options.automaticNameDelimiter,
-		reuseExistingChunk: options.reuseExistingChunk,
-		usedExports: options.usedExports
+exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
+	return function identifierExpression(expr) {
+		let evaluatedExpression = new BasicEvaluatedExpression()
+			.setIdentifier(identifier, rootInfo, getMembers)
+			.setSideEffects(false)
+			.setRange(expr.range);
+		switch (truthy) {
+			case true:
+				evaluatedExpression.setTruthy();
+				break;
+			case null:
+				evaluatedExpression.setNullish(true);
+				break;
+			case false:
+				evaluatedExpression.setFalsy();
+				break;
+		}
+
+		return evaluatedExpression;
 	};
 };
 
-module.exports = class SplitChunksPlugin {
-	/**
-	 * @param {OptimizationSplitChunksOptions=} options plugin options
-	 */
-	constructor(options = {}) {
-		const defaultSizeTypes = options.defaultSizeTypes || [
-			"javascript",
-			"unknown"
-		];
-		const fallbackCacheGroup = options.fallbackCacheGroup || {};
-		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
-		const minSizeReduction = normalizeSizes(
-			options.minSizeReduction,
-			defaultSizeTypes
+exports.expressionIsUnsupported = (parser, message) => {
+	return function unsupportedExpression(expr) {
+		const dep = new ConstDependency("(void 0)", expr.range, null);
+		dep.loc = expr.loc;
+		parser.state.module.addPresentationalDependency(dep);
+		if (!parser.state.module) return;
+		parser.state.module.addWarning(
+			new UnsupportedFeatureWarning(message, expr.loc)
 		);
-		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
+		return true;
+	};
+};
 
-		/** @type {SplitChunksOptions} */
-		this.options = {
-			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
-			defaultSizeTypes,
-			minSize,
-			minSizeReduction,
-			minRemainingSize: mergeSizes(
-				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
-				minSize
-			),
-			enforceSizeThreshold: normalizeSizes(
-				options.enforceSizeThreshold,
-				defaultSizeTypes
-			),
-			maxAsyncSize: mergeSizes(
-				normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
-				maxSize
-			),
-			maxInitialSize: mergeSizes(
-				normalizeSizes(options.maxInitialSize, defaultSizeTypes),
-				maxSize
-			),
-			minChunks: options.minChunks || 1,
-			maxAsyncRequests: options.maxAsyncRequests || 1,
-			maxInitialRequests: options.maxInitialRequests || 1,
-			hidePathInfo: options.hidePathInfo || false,
-			filename: options.filename || undefined,
-			getCacheGroups: normalizeCacheGroups(
-				options.cacheGroups,
-				defaultSizeTypes
-			),
-			getName: options.name ? normalizeName(options.name) : defaultGetName,
-			automaticNameDelimiter: options.automaticNameDelimiter,
-			usedExports: options.usedExports,
-			fallbackCacheGroup: {
-				chunksFilter: normalizeChunksFilter(
-					fallbackCacheGroup.chunks || options.chunks || "all"
-				),
-				minSize: mergeSizes(
-					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
-					minSize
-				),
-				maxAsyncSize: mergeSizes(
-					normalizeSizes(fallbackCacheGroup.maxAsyncSize, defaultSizeTypes),
-					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
-					normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
-					normalizeSizes(options.maxSize, defaultSizeTypes)
-				),
-				maxInitialSize: mergeSizes(
-					normalizeSizes(fallbackCacheGroup.maxInitialSize, defaultSizeTypes),
-					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
-					normalizeSizes(options.maxInitialSize, defaultSizeTypes),
-					normalizeSizes(options.maxSize, defaultSizeTypes)
-				),
-				automaticNameDelimiter:
-					fallbackCacheGroup.automaticNameDelimiter ||
-					options.automaticNameDelimiter ||
-					"~"
+exports.skipTraversal = () => true;
+
+exports.approve = () => true;
+
+
+/***/ }),
+
+/***/ 98124:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const { isSubset } = __webpack_require__(93347);
+const { getAllChunks } = __webpack_require__(91145);
+
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {(string|number)[]} EntryItem */
+
+const EXPORT_PREFIX = "var __webpack_exports__ = ";
+
+/**
+ * @param {ChunkGraph} chunkGraph chunkGraph
+ * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+ * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
+ * @param {Chunk} chunk chunk
+ * @param {boolean} passive true: passive startup with on chunks loaded
+ * @returns {string} runtime code
+ */
+exports.generateEntryStartup = (
+	chunkGraph,
+	runtimeTemplate,
+	entries,
+	chunk,
+	passive
+) => {
+	/** @type {string[]} */
+	const runtime = [
+		`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+			`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+			"moduleId"
+		)}`
+	];
+
+	const runModule = id => {
+		return `__webpack_exec__(${JSON.stringify(id)})`;
+	};
+	const outputCombination = (chunks, moduleIds, final) => {
+		if (chunks.size === 0) {
+			runtime.push(
+				`${final ? EXPORT_PREFIX : ""}(${moduleIds.map(runModule).join(", ")});`
+			);
+		} else {
+			const fn = runtimeTemplate.returningFunction(
+				moduleIds.map(runModule).join(", ")
+			);
+			runtime.push(
+				`${final && !passive ? EXPORT_PREFIX : ""}${
+					passive
+						? RuntimeGlobals.onChunksLoaded
+						: RuntimeGlobals.startupEntrypoint
+				}(0, ${JSON.stringify(Array.from(chunks, c => c.id))}, ${fn});`
+			);
+			if (final && passive) {
+				runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);
 			}
-		};
+		}
+	};
 
-		/** @type {WeakMap<CacheGroupSource, CacheGroup>} */
-		this._cacheGroupCache = new WeakMap();
+	let currentChunks = undefined;
+	let currentModuleIds = undefined;
+
+	for (const [module, entrypoint] of entries) {
+		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const moduleId = chunkGraph.getModuleId(module);
+		const chunks = getAllChunks(entrypoint, chunk, runtimeChunk);
+		if (
+			currentChunks &&
+			currentChunks.size === chunks.size &&
+			isSubset(currentChunks, chunks)
+		) {
+			currentModuleIds.push(moduleId);
+		} else {
+			if (currentChunks) {
+				outputCombination(currentChunks, currentModuleIds);
+			}
+			currentChunks = chunks;
+			currentModuleIds = [moduleId];
+		}
 	}
 
-	/**
-	 * @param {CacheGroupSource} cacheGroupSource source
-	 * @returns {CacheGroup} the cache group (cached)
-	 */
-	_getCacheGroup(cacheGroupSource) {
-		const cacheEntry = this._cacheGroupCache.get(cacheGroupSource);
-		if (cacheEntry !== undefined) return cacheEntry;
-		const minSize = mergeSizes(
-			cacheGroupSource.minSize,
-			cacheGroupSource.enforce ? undefined : this.options.minSize
-		);
-		const minSizeReduction = mergeSizes(
-			cacheGroupSource.minSizeReduction,
-			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
-		);
-		const minRemainingSize = mergeSizes(
-			cacheGroupSource.minRemainingSize,
-			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
-		);
-		const enforceSizeThreshold = mergeSizes(
-			cacheGroupSource.enforceSizeThreshold,
-			cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold
-		);
-		const cacheGroup = {
-			key: cacheGroupSource.key,
-			priority: cacheGroupSource.priority || 0,
-			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
-			minSize,
-			minSizeReduction,
-			minRemainingSize,
-			enforceSizeThreshold,
-			maxAsyncSize: mergeSizes(
-				cacheGroupSource.maxAsyncSize,
-				cacheGroupSource.enforce ? undefined : this.options.maxAsyncSize
-			),
-			maxInitialSize: mergeSizes(
-				cacheGroupSource.maxInitialSize,
-				cacheGroupSource.enforce ? undefined : this.options.maxInitialSize
-			),
-			minChunks:
-				cacheGroupSource.minChunks !== undefined
-					? cacheGroupSource.minChunks
-					: cacheGroupSource.enforce
-					? 1
-					: this.options.minChunks,
-			maxAsyncRequests:
-				cacheGroupSource.maxAsyncRequests !== undefined
-					? cacheGroupSource.maxAsyncRequests
-					: cacheGroupSource.enforce
-					? Infinity
-					: this.options.maxAsyncRequests,
-			maxInitialRequests:
-				cacheGroupSource.maxInitialRequests !== undefined
-					? cacheGroupSource.maxInitialRequests
-					: cacheGroupSource.enforce
-					? Infinity
-					: this.options.maxInitialRequests,
-			getName:
-				cacheGroupSource.getName !== undefined
-					? cacheGroupSource.getName
-					: this.options.getName,
-			usedExports:
-				cacheGroupSource.usedExports !== undefined
-					? cacheGroupSource.usedExports
-					: this.options.usedExports,
-			filename:
-				cacheGroupSource.filename !== undefined
-					? cacheGroupSource.filename
-					: this.options.filename,
-			automaticNameDelimiter:
-				cacheGroupSource.automaticNameDelimiter !== undefined
-					? cacheGroupSource.automaticNameDelimiter
-					: this.options.automaticNameDelimiter,
-			idHint:
-				cacheGroupSource.idHint !== undefined
-					? cacheGroupSource.idHint
-					: cacheGroupSource.key,
-			reuseExistingChunk: cacheGroupSource.reuseExistingChunk || false,
-			_validateSize: hasNonZeroSizes(minSize),
-			_validateRemainingSize: hasNonZeroSizes(minRemainingSize),
-			_minSizeForMaxSize: mergeSizes(
-				cacheGroupSource.minSize,
-				this.options.minSize
-			),
-			_conditionalEnforce: hasNonZeroSizes(enforceSizeThreshold)
-		};
-		this._cacheGroupCache.set(cacheGroupSource, cacheGroup);
-		return cacheGroup;
+	// output current modules with export prefix
+	if (currentChunks) {
+		outputCombination(currentChunks, currentModuleIds, true);
 	}
+	runtime.push("");
+	return Template.asString(runtime);
+};
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			compiler.context,
-			compiler.root
-		);
-		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
-			const logger = compilation.getLogger("webpack.SplitChunksPlugin");
-			let alreadyOptimized = false;
-			compilation.hooks.unseal.tap("SplitChunksPlugin", () => {
-				alreadyOptimized = false;
-			});
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "SplitChunksPlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					if (alreadyOptimized) return;
-					alreadyOptimized = true;
-					logger.time("prepare");
-					const chunkGraph = compilation.chunkGraph;
-					const moduleGraph = compilation.moduleGraph;
-					// Give each selected chunk an index (to create strings from chunks)
-					/** @type {Map<Chunk, bigint>} */
-					const chunkIndexMap = new Map();
-					const ZERO = BigInt("0");
-					const ONE = BigInt("1");
-					const START = ONE << BigInt("31");
-					let index = START;
-					for (const chunk of chunks) {
-						chunkIndexMap.set(
-							chunk,
-							index | BigInt((Math.random() * 0x7fffffff) | 0)
-						);
-						index = index << ONE;
-					}
-					/**
-					 * @param {Iterable<Chunk>} chunks list of chunks
-					 * @returns {bigint | Chunk} key of the chunks
-					 */
-					const getKey = chunks => {
-						const iterator = chunks[Symbol.iterator]();
-						let result = iterator.next();
-						if (result.done) return ZERO;
-						const first = result.value;
-						result = iterator.next();
-						if (result.done) return first;
-						let key =
-							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
-						while (!(result = iterator.next()).done) {
-							const raw = chunkIndexMap.get(result.value);
-							key = key ^ raw;
-						}
-						return key;
-					};
-					const keyToString = key => {
-						if (typeof key === "bigint") return key.toString(16);
-						return chunkIndexMap.get(key).toString(16);
-					};
+/**
+ * @param {Hash} hash the hash to update
+ * @param {ChunkGraph} chunkGraph chunkGraph
+ * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
+ * @param {Chunk} chunk chunk
+ * @returns {void}
+ */
+exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
+	for (const [module, entrypoint] of entries) {
+		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const moduleId = chunkGraph.getModuleId(module);
+		hash.update(`${moduleId}`);
+		for (const c of getAllChunks(entrypoint, chunk, runtimeChunk))
+			hash.update(`${c.id}`);
+	}
+};
+
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
+ * @returns {Set<number | string>} initially fulfilled chunk ids
+ */
+exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
+	const initialChunkIds = new Set(chunk.ids);
+	for (const c of chunk.getAllInitialChunks()) {
+		if (c === chunk || filterFn(c, chunkGraph)) continue;
+		for (const id of c.ids) initialChunkIds.add(id);
+	}
+	return initialChunkIds;
+};
 
-					const getChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
-						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
-						const singleChunkSets = new Set();
-						for (const module of compilation.modules) {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							if (typeof chunksKey === "bigint") {
-								if (!chunkSetsInGraph.has(chunksKey)) {
-									chunkSetsInGraph.set(chunksKey, new Set(chunks));
-								}
-							} else {
-								singleChunkSets.add(chunksKey);
-							}
-						}
-						return { chunkSetsInGraph, singleChunkSets };
-					});
 
-					/**
-					 * @param {Module} module the module
-					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
-					 */
-					const groupChunksByExports = module => {
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						const groupedByUsedExports = new Map();
-						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-							const key = exportsInfo.getUsageKey(chunk.runtime);
-							const list = groupedByUsedExports.get(key);
-							if (list !== undefined) {
-								list.push(chunk);
-							} else {
-								groupedByUsedExports.set(key, [chunk]);
-							}
-						}
-						return groupedByUsedExports.values();
-					};
+/***/ }),
 
-					/** @type {Map<Module, Iterable<Chunk[]>>} */
-					const groupedByExportsMap = new Map();
+/***/ 90490:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					const getExportsChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
-						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
-						const singleChunkSets = new Set();
-						for (const module of compilation.modules) {
-							const groupedChunks = Array.from(groupChunksByExports(module));
-							groupedByExportsMap.set(module, groupedChunks);
-							for (const chunks of groupedChunks) {
-								if (chunks.length === 1) {
-									singleChunkSets.add(chunks[0]);
-								} else {
-									const chunksKey = /** @type {bigint} */ (getKey(chunks));
-									if (!chunkSetsInGraph.has(chunksKey)) {
-										chunkSetsInGraph.set(chunksKey, new Set(chunks));
-									}
-								}
-							}
-						}
-						return { chunkSetsInGraph, singleChunkSets };
-					});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					// group these set of chunks by count
-					// to allow to check less sets via isSubset
-					// (only smaller sets can be subset)
-					const groupChunkSetsByCount = chunkSets => {
-						/** @type {Map<number, Array<Set<Chunk>>>} */
-						const chunkSetsByCount = new Map();
-						for (const chunksSet of chunkSets) {
-							const count = chunksSet.size;
-							let array = chunkSetsByCount.get(count);
-							if (array === undefined) {
-								array = [];
-								chunkSetsByCount.set(count, array);
-							}
-							array.push(chunksSet);
-						}
-						return chunkSetsByCount;
-					};
-					const getChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getChunkSetsInGraph().chunkSetsInGraph.values()
-						)
-					);
-					const getExportsChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
-						)
-					);
 
-					// Create a list of possible combinations
-					const createGetCombinations = (
-						chunkSets,
-						singleChunkSets,
-						chunkSetsByCount
-					) => {
-						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
-						const combinationsCache = new Map();
 
-						return key => {
-							const cacheEntry = combinationsCache.get(key);
-							if (cacheEntry !== undefined) return cacheEntry;
-							if (key instanceof Chunk) {
-								const result = [key];
-								combinationsCache.set(key, result);
-								return result;
-							}
-							const chunksSet = chunkSets.get(key);
-							/** @type {(Set<Chunk> | Chunk)[]} */
-							const array = [chunksSet];
-							for (const [count, setArray] of chunkSetsByCount) {
-								// "equal" is not needed because they would have been merge in the first step
-								if (count < chunksSet.size) {
-									for (const set of setArray) {
-										if (isSubset(chunksSet, set)) {
-											array.push(set);
-										}
-									}
-								}
-							}
-							for (const chunk of singleChunkSets) {
-								if (chunksSet.has(chunk)) {
-									array.push(chunk);
-								}
-							}
-							combinationsCache.set(key, array);
-							return array;
-						};
-					};
+const { register } = __webpack_require__(8282);
 
-					const getCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
-						return createGetCombinations(
-							chunkSetsInGraph,
-							singleChunkSets,
-							getChunkSetsByCount()
-						);
-					});
-					const getCombinations = key => getCombinationsFactory()(key);
+class JsonData {
+	constructor(data) {
+		this._buffer = undefined;
+		this._data = undefined;
+		if (Buffer.isBuffer(data)) {
+			this._buffer = data;
+		} else {
+			this._data = data;
+		}
+	}
 
-					const getExportsCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } =
-							getExportsChunkSetsInGraph();
-						return createGetCombinations(
-							chunkSetsInGraph,
-							singleChunkSets,
-							getExportsChunkSetsByCount()
-						);
-					});
-					const getExportsCombinations = key =>
-						getExportsCombinationsFactory()(key);
+	get() {
+		if (this._data === undefined && this._buffer !== undefined) {
+			this._data = JSON.parse(this._buffer.toString());
+		}
+		return this._data;
+	}
+}
 
-					/**
-					 * @typedef {Object} SelectedChunksResult
-					 * @property {Chunk[]} chunks the list of chunks
-					 * @property {bigint | Chunk} key a key of the list
-					 */
+register(JsonData, "webpack/lib/json/JsonData", null, {
+	serialize(obj, { write }) {
+		if (obj._buffer === undefined && obj._data !== undefined) {
+			obj._buffer = Buffer.from(JSON.stringify(obj._data));
+		}
+		write(obj._buffer);
+	},
+	deserialize({ read }) {
+		return new JsonData(read());
+	}
+});
 
-					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
-					const selectedChunksCacheByChunksSet = new WeakMap();
+module.exports = JsonData;
 
-					/**
-					 * get list and key by applying the filter function to the list
-					 * It is cached for performance reasons
-					 * @param {Set<Chunk> | Chunk} chunks list of chunks
-					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
-					 * @returns {SelectedChunksResult} list and key
-					 */
-					const getSelectedChunks = (chunks, chunkFilter) => {
-						let entry = selectedChunksCacheByChunksSet.get(chunks);
-						if (entry === undefined) {
-							entry = new WeakMap();
-							selectedChunksCacheByChunksSet.set(chunks, entry);
-						}
-						/** @type {SelectedChunksResult} */
-						let entry2 = entry.get(chunkFilter);
-						if (entry2 === undefined) {
-							/** @type {Chunk[]} */
-							const selectedChunks = [];
-							if (chunks instanceof Chunk) {
-								if (chunkFilter(chunks)) selectedChunks.push(chunks);
-							} else {
-								for (const chunk of chunks) {
-									if (chunkFilter(chunk)) selectedChunks.push(chunk);
-								}
-							}
-							entry2 = {
-								chunks: selectedChunks,
-								key: getKey(selectedChunks)
-							};
-							entry.set(chunkFilter, entry2);
-						}
-						return entry2;
-					};
 
-					/** @type {Map<string, boolean>} */
-					const alreadyValidatedParents = new Map();
-					/** @type {Set<string>} */
-					const alreadyReportedErrors = new Set();
+/***/ }),
 
-					// Map a list of chunks to a list of modules
-					// For the key the chunk "index" is used, the value is a SortableSet of modules
-					/** @type {Map<string, ChunksInfoItem>} */
-					const chunksInfoMap = new Map();
+/***/ 70393:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					/**
-					 * @param {CacheGroup} cacheGroup the current cache group
-					 * @param {number} cacheGroupIndex the index of the cache group of ordering
-					 * @param {Chunk[]} selectedChunks chunks selected for this module
-					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
-					 * @param {Module} module the current module
-					 * @returns {void}
-					 */
-					const addModuleToChunksInfoMap = (
-						cacheGroup,
-						cacheGroupIndex,
-						selectedChunks,
-						selectedChunksKey,
-						module
-					) => {
-						// Break if minimum number of chunks is not reached
-						if (selectedChunks.length < cacheGroup.minChunks) return;
-						// Determine name for split chunk
-						const name = cacheGroup.getName(
-							module,
-							selectedChunks,
-							cacheGroup.key
-						);
-						// Check if the name is ok
-						const existingChunk = compilation.namedChunks.get(name);
-						if (existingChunk) {
-							const parentValidationKey = `${name}|${
-								typeof selectedChunksKey === "bigint"
-									? selectedChunksKey
-									: selectedChunksKey.debugId
-							}`;
-							const valid = alreadyValidatedParents.get(parentValidationKey);
-							if (valid === false) return;
-							if (valid === undefined) {
-								// Module can only be moved into the existing chunk if the existing chunk
-								// is a parent of all selected chunks
-								let isInAllParents = true;
-								/** @type {Set<ChunkGroup>} */
-								const queue = new Set();
-								for (const chunk of selectedChunks) {
-									for (const group of chunk.groupsIterable) {
-										queue.add(group);
-									}
-								}
-								for (const group of queue) {
-									if (existingChunk.isInGroup(group)) continue;
-									let hasParent = false;
-									for (const parent of group.parentsIterable) {
-										hasParent = true;
-										queue.add(parent);
-									}
-									if (!hasParent) {
-										isInAllParents = false;
-									}
-								}
-								const valid = isInAllParents;
-								alreadyValidatedParents.set(parentValidationKey, valid);
-								if (!valid) {
-									if (!alreadyReportedErrors.has(name)) {
-										alreadyReportedErrors.add(name);
-										compilation.errors.push(
-											new WebpackError(
-												"SplitChunksPlugin\n" +
-													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
-													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
-													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +
-													'HINT: You can omit "name" to automatically create a name.\n' +
-													"BREAKING CHANGE: webpack < 5 used to allow to use an entrypoint as splitChunk. " +
-													"This is no longer allowed when the entrypoint is not a parent of the selected modules.\n" +
-													"Remove this entrypoint and add modules to cache group's 'test' instead. " +
-													"If you need modules to be evaluated on startup, add them to the existing entrypoints (make them arrays). " +
-													"See migration guide of more info."
-											)
-										);
-									}
-									return;
-								}
-							}
-						}
-						// Create key for maps
-						// When it has a name we use the name as key
-						// Otherwise we create the key from chunks and cache group key
-						// This automatically merges equal names
-						const key =
-							cacheGroup.key +
-							(name
-								? ` name:${name}`
-								: ` chunks:${keyToString(selectedChunksKey)}`);
-						// Add module to maps
-						let info = chunksInfoMap.get(key);
-						if (info === undefined) {
-							chunksInfoMap.set(
-								key,
-								(info = {
-									modules: new SortableSet(
-										undefined,
-										compareModulesByIdentifier
-									),
-									cacheGroup,
-									cacheGroupIndex,
-									name,
-									sizes: {},
-									chunks: new Set(),
-									reuseableChunks: new Set(),
-									chunksKeys: new Set()
-								})
-							);
-						}
-						const oldSize = info.modules.size;
-						info.modules.add(module);
-						if (info.modules.size !== oldSize) {
-							for (const type of module.getSourceTypes()) {
-								info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
-							}
-						}
-						const oldChunksKeysSize = info.chunksKeys.size;
-						info.chunksKeys.add(selectedChunksKey);
-						if (oldChunksKeysSize !== info.chunksKeys.size) {
-							for (const chunk of selectedChunks) {
-								info.chunks.add(chunk);
-							}
-						}
-					};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { RawSource } = __webpack_require__(51255);
+const ConcatenationScope = __webpack_require__(98229);
+const { UsageState } = __webpack_require__(63686);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+const stringifySafe = data => {
+	const stringified = JSON.stringify(data);
+	if (!stringified) {
+		return undefined; // Invalid JSON
+	}
+
+	return stringified.replace(/\u2028|\u2029/g, str =>
+		str === "\u2029" ? "\\u2029" : "\\u2028"
+	); // invalid in JavaScript but valid JSON
+};
+
+/**
+ * @param {Object} data data (always an object or array)
+ * @param {ExportsInfo} exportsInfo exports info
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {Object} reduced data
+ */
+const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
+		return data;
+	const isArray = Array.isArray(data);
+	const reducedData = isArray ? [] : {};
+	for (const key of Object.keys(data)) {
+		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
+		const used = exportInfo.getUsed(runtime);
+		if (used === UsageState.Unused) continue;
+
+		let value;
+		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
+			value = createObjectForExportsInfo(
+				data[key],
+				exportInfo.exportsInfo,
+				runtime
+			);
+		} else {
+			value = data[key];
+		}
+		const name = exportInfo.getUsedName(key, runtime);
+		reducedData[name] = value;
+	}
+	if (isArray) {
+		let arrayLengthWhenUsed =
+			exportsInfo.getReadOnlyExportInfo("length").getUsed(runtime) !==
+			UsageState.Unused
+				? data.length
+				: undefined;
+
+		let sizeObjectMinusArray = 0;
+		for (let i = 0; i < reducedData.length; i++) {
+			if (reducedData[i] === undefined) {
+				sizeObjectMinusArray -= 2;
+			} else {
+				sizeObjectMinusArray += `${i}`.length + 3;
+			}
+		}
+		if (arrayLengthWhenUsed !== undefined) {
+			sizeObjectMinusArray +=
+				`${arrayLengthWhenUsed}`.length +
+				8 -
+				(arrayLengthWhenUsed - reducedData.length) * 2;
+		}
+		if (sizeObjectMinusArray < 0)
+			return Object.assign(
+				arrayLengthWhenUsed === undefined
+					? {}
+					: { length: arrayLengthWhenUsed },
+				reducedData
+			);
+		const generatedLength =
+			arrayLengthWhenUsed !== undefined
+				? Math.max(arrayLengthWhenUsed, reducedData.length)
+				: reducedData.length;
+		for (let i = 0; i < generatedLength; i++) {
+			if (reducedData[i] === undefined) {
+				reducedData[i] = 0;
+			}
+		}
+	}
+	return reducedData;
+};
+
+const TYPES = new Set(["javascript"]);
+
+class JsonGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		let data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
+		if (!data) return 0;
+		return stringifySafe(data).length + 10;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(
+		module,
+		{
+			moduleGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
+		}
+	) {
+		const data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
+		if (data === undefined) {
+			return new RawSource(
+				runtimeTemplate.missingModuleStatement({
+					request: module.rawRequest
+				})
+			);
+		}
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		let finalJson =
+			typeof data === "object" &&
+			data &&
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused
+				? createObjectForExportsInfo(data, exportsInfo, runtime)
+				: data;
+		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
+		const jsonStr = stringifySafe(finalJson);
+		const jsonExpr =
+			jsonStr.length > 20 && typeof finalJson === "object"
+				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
+				: jsonStr;
+		let content;
+		if (concatenationScope) {
+			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			} = ${jsonExpr};`;
+			concatenationScope.registerNamespaceExport(
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			);
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			content = `${module.moduleArgument}.exports = ${jsonExpr};`;
+		}
+		return new RawSource(content);
+	}
+}
 
-					const context = {
-						moduleGraph,
-						chunkGraph
-					};
+module.exports = JsonGenerator;
 
-					logger.timeEnd("prepare");
 
-					logger.time("modules");
+/***/ }),
 
-					// Walk through all modules
-					for (const module of compilation.modules) {
-						// Get cache group
-						let cacheGroups = this.options.getCacheGroups(module, context);
-						if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
-							continue;
-						}
+/***/ 86770:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						// Prepare some values (usedExports = false)
-						const getCombs = memoize(() => {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							return getCombinations(chunksKey);
-						});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						// Prepare some values (usedExports = true)
-						const getCombsByUsedExports = memoize(() => {
-							// fill the groupedByExportsMap
-							getExportsChunkSetsInGraph();
-							/** @type {Set<Set<Chunk> | Chunk>} */
-							const set = new Set();
-							const groupedByUsedExports = groupedByExportsMap.get(module);
-							for (const chunks of groupedByUsedExports) {
-								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey))
-									set.add(comb);
-							}
-							return set;
-						});
 
-						let cacheGroupIndex = 0;
-						for (const cacheGroupSource of cacheGroups) {
-							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-							const combs = cacheGroup.usedExports
-								? getCombsByUsedExports()
-								: getCombs();
-							// For all combination of chunk selection
-							for (const chunkCombination of combs) {
-								// Break if minimum number of chunks is not reached
-								const count =
-									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
-								if (count < cacheGroup.minChunks) continue;
-								// Select chunks by configuration
-								const { chunks: selectedChunks, key: selectedChunksKey } =
-									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
+const createSchemaValidation = __webpack_require__(32540);
+const JsonGenerator = __webpack_require__(70393);
+const JsonParser = __webpack_require__(41090);
 
-								addModuleToChunksInfoMap(
-									cacheGroup,
-									cacheGroupIndex,
-									selectedChunks,
-									selectedChunksKey,
-									module
-								);
-							}
-							cacheGroupIndex++;
-						}
-					}
+/** @typedef {import("../Compiler")} Compiler */
 
-					logger.timeEnd("modules");
+const validate = createSchemaValidation(
+	__webpack_require__(54094),
+	() => __webpack_require__(50166),
+	{
+		name: "Json Modules Plugin",
+		baseDataPath: "parser"
+	}
+);
 
-					logger.time("queue");
+class JsonModulesPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"JsonModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("json")
+					.tap("JsonModulesPlugin", parserOptions => {
+						validate(parserOptions);
 
-					/**
-					 * @param {ChunksInfoItem} info entry
-					 * @param {string[]} sourceTypes source types to be removed
-					 */
-					const removeModulesWithSourceType = (info, sourceTypes) => {
-						for (const module of info.modules) {
-							const types = module.getSourceTypes();
-							if (sourceTypes.some(type => types.has(type))) {
-								info.modules.delete(module);
-								for (const type of types) {
-									info.sizes[type] -= module.size(type);
-								}
-							}
-						}
-					};
+						return new JsonParser(parserOptions);
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("json")
+					.tap("JsonModulesPlugin", () => {
+						return new JsonGenerator();
+					});
+			}
+		);
+	}
+}
 
-					/**
-					 * @param {ChunksInfoItem} info entry
-					 * @returns {boolean} true, if entry become empty
-					 */
-					const removeMinSizeViolatingModules = info => {
-						if (!info.cacheGroup._validateSize) return false;
-						const violatingSizes = getViolatingMinSizes(
-							info.sizes,
-							info.cacheGroup.minSize
-						);
-						if (violatingSizes === undefined) return false;
-						removeModulesWithSourceType(info, violatingSizes);
-						return info.modules.size === 0;
-					};
+module.exports = JsonModulesPlugin;
 
-					// Filter items were size < minSize
-					for (const [key, info] of chunksInfoMap) {
-						if (removeMinSizeViolatingModules(info)) {
-							chunksInfoMap.delete(key);
-						} else if (
-							!checkMinSizeReduction(
-								info.sizes,
-								info.cacheGroup.minSizeReduction,
-								info.chunks.size
-							)
-						) {
-							chunksInfoMap.delete(key);
-						}
-					}
 
-					/**
-					 * @typedef {Object} MaxSizeQueueItem
-					 * @property {SplitChunksSizes} minSize
-					 * @property {SplitChunksSizes} maxAsyncSize
-					 * @property {SplitChunksSizes} maxInitialSize
-					 * @property {string} automaticNameDelimiter
-					 * @property {string[]} keys
-					 */
+/***/ }),
 
-					/** @type {Map<Chunk, MaxSizeQueueItem>} */
-					const maxSizeQueueMap = new Map();
+/***/ 41090:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					while (chunksInfoMap.size > 0) {
-						// Find best matching entry
-						let bestEntryKey;
-						let bestEntry;
-						for (const pair of chunksInfoMap) {
-							const key = pair[0];
-							const info = pair[1];
-							if (
-								bestEntry === undefined ||
-								compareEntries(bestEntry, info) < 0
-							) {
-								bestEntry = info;
-								bestEntryKey = key;
-							}
-						}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						const item = bestEntry;
-						chunksInfoMap.delete(bestEntryKey);
 
-						let chunkName = item.name;
-						// Variable for the new chunk (lazy created)
-						/** @type {Chunk} */
-						let newChunk;
-						// When no chunk name, check if we can reuse a chunk instead of creating a new one
-						let isExistingChunk = false;
-						let isReusedWithAllModules = false;
-						if (chunkName) {
-							const chunkByName = compilation.namedChunks.get(chunkName);
-							if (chunkByName !== undefined) {
-								newChunk = chunkByName;
-								const oldSize = item.chunks.size;
-								item.chunks.delete(newChunk);
-								isExistingChunk = item.chunks.size !== oldSize;
-							}
-						} else if (item.cacheGroup.reuseExistingChunk) {
-							outer: for (const chunk of item.chunks) {
-								if (
-									chunkGraph.getNumberOfChunkModules(chunk) !==
-									item.modules.size
-								) {
-									continue;
-								}
-								if (
-									item.chunks.size > 1 &&
-									chunkGraph.getNumberOfEntryModules(chunk) > 0
-								) {
-									continue;
-								}
-								for (const module of item.modules) {
-									if (!chunkGraph.isModuleInChunk(module, chunk)) {
-										continue outer;
-									}
-								}
-								if (!newChunk || !newChunk.name) {
-									newChunk = chunk;
-								} else if (
-									chunk.name &&
-									chunk.name.length < newChunk.name.length
-								) {
-									newChunk = chunk;
-								} else if (
-									chunk.name &&
-									chunk.name.length === newChunk.name.length &&
-									chunk.name < newChunk.name
-								) {
-									newChunk = chunk;
-								}
-							}
-							if (newChunk) {
-								item.chunks.delete(newChunk);
-								chunkName = undefined;
-								isExistingChunk = true;
-								isReusedWithAllModules = true;
-							}
-						}
 
-						const enforced =
-							item.cacheGroup._conditionalEnforce &&
-							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
+const parseJson = __webpack_require__(15235);
+const Parser = __webpack_require__(11715);
+const JsonExportsDependency = __webpack_require__(750);
+const JsonData = __webpack_require__(90490);
 
-						const usedChunks = new Set(item.chunks);
+/** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-						// Check if maxRequests condition can be fulfilled
-						if (
-							!enforced &&
-							(Number.isFinite(item.cacheGroup.maxInitialRequests) ||
-								Number.isFinite(item.cacheGroup.maxAsyncRequests))
-						) {
-							for (const chunk of usedChunks) {
-								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-									? Math.min(
-											item.cacheGroup.maxInitialRequests,
-											item.cacheGroup.maxAsyncRequests
-									  )
-									: item.cacheGroup.maxAsyncRequests;
-								if (
-									isFinite(maxRequests) &&
-									getRequests(chunk) >= maxRequests
-								) {
-									usedChunks.delete(chunk);
-								}
-							}
-						}
+class JsonParser extends Parser {
+	/**
+	 * @param {JsonModulesPluginParserOptions} options parser options
+	 */
+	constructor(options) {
+		super();
+		this.options = options || {};
+	}
 
-						outer: for (const chunk of usedChunks) {
-							for (const module of item.modules) {
-								if (chunkGraph.isModuleInChunk(module, chunk)) continue outer;
-							}
-							usedChunks.delete(chunk);
-						}
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		}
 
-						// Were some (invalid) chunks removed from usedChunks?
-						// => readd all modules to the queue, as things could have been changed
-						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk) usedChunks.add(newChunk);
-							if (usedChunks.size >= item.cacheGroup.minChunks) {
-								const chunksArr = Array.from(usedChunks);
-								for (const module of item.modules) {
-									addModuleToChunksInfoMap(
-										item.cacheGroup,
-										item.cacheGroupIndex,
-										chunksArr,
-										getKey(usedChunks),
-										module
-									);
-								}
-							}
-							continue;
-						}
+		/** @type {JsonModulesPluginParserOptions["parse"]} */
+		const parseFn =
+			typeof this.options.parse === "function" ? this.options.parse : parseJson;
 
-						// Validate minRemainingSize constraint when a single chunk is left over
-						if (
-							!enforced &&
-							item.cacheGroup._validateRemainingSize &&
-							usedChunks.size === 1
-						) {
-							const [chunk] = usedChunks;
-							let chunkSizes = Object.create(null);
-							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								if (!item.modules.has(module)) {
-									for (const type of module.getSourceTypes()) {
-										chunkSizes[type] =
-											(chunkSizes[type] || 0) + module.size(type);
-									}
-								}
-							}
-							const violatingSizes = getViolatingMinSizes(
-								chunkSizes,
-								item.cacheGroup.minRemainingSize
-							);
-							if (violatingSizes !== undefined) {
-								const oldModulesSize = item.modules.size;
-								removeModulesWithSourceType(item, violatingSizes);
-								if (
-									item.modules.size > 0 &&
-									item.modules.size !== oldModulesSize
-								) {
-									// queue this item again to be processed again
-									// without violating modules
-									chunksInfoMap.set(bestEntryKey, item);
-								}
-								continue;
-							}
-						}
+		const data =
+			typeof source === "object"
+				? source
+				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
 
-						// Create the new chunk if not reusing one
-						if (newChunk === undefined) {
-							newChunk = compilation.addChunk(chunkName);
-						}
-						// Walk through all chunks
-						for (const chunk of usedChunks) {
-							// Add graph connections for splitted chunk
-							chunk.split(newChunk);
-						}
+		state.module.buildInfo.jsonData = new JsonData(data);
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "default";
+		state.module.buildMeta.defaultObject =
+			typeof data === "object" ? "redirect-warn" : false;
+		state.module.addDependency(
+			new JsonExportsDependency(JsonExportsDependency.getExportsFromData(data))
+		);
+		return state;
+	}
+}
 
-						// Add a note to the chunk
-						newChunk.chunkReason =
-							(newChunk.chunkReason ? newChunk.chunkReason + ", " : "") +
-							(isReusedWithAllModules
-								? "reused as split chunk"
-								: "split chunk");
-						if (item.cacheGroup.key) {
-							newChunk.chunkReason += ` (cache group: ${item.cacheGroup.key})`;
-						}
-						if (chunkName) {
-							newChunk.chunkReason += ` (name: ${chunkName})`;
-						}
-						if (item.cacheGroup.filename) {
-							newChunk.filenameTemplate = item.cacheGroup.filename;
-						}
-						if (item.cacheGroup.idHint) {
-							newChunk.idNameHints.add(item.cacheGroup.idHint);
-						}
-						if (!isReusedWithAllModules) {
-							// Add all modules to the new chunk
-							for (const module of item.modules) {
-								if (!module.chunkCondition(newChunk, compilation)) continue;
-								// Add module to new chunk
-								chunkGraph.connectChunkAndModule(newChunk, module);
-								// Remove module from used chunks
-								for (const chunk of usedChunks) {
-									chunkGraph.disconnectChunkAndModule(chunk, module);
-								}
-							}
-						} else {
-							// Remove all modules from used chunks
-							for (const module of item.modules) {
-								for (const chunk of usedChunks) {
-									chunkGraph.disconnectChunkAndModule(chunk, module);
+module.exports = JsonParser;
+
+
+/***/ }),
+
+/***/ 26030:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+
+const COMMON_LIBRARY_NAME_MESSAGE =
+	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
+
+/**
+ * @template T
+ * @typedef {Object} LibraryContext
+ * @property {Compilation} compilation
+ * @property {ChunkGraph} chunkGraph
+ * @property {T} options
+ */
+
+/**
+ * @template T
+ */
+class AbstractLibraryPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.pluginName name of the plugin
+	 * @param {LibraryType} options.type used library type
+	 */
+	constructor({ pluginName, type }) {
+		this._pluginName = pluginName;
+		this._type = type;
+		this._parseCache = new WeakMap();
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _pluginName } = this;
+		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
+			compilation.hooks.finishModules.tap(
+				{ name: _pluginName, stage: 10 },
+				() => {
+					for (const [
+						name,
+						{
+							dependencies: deps,
+							options: { library }
+						}
+					] of compilation.entries) {
+						const options = this._parseOptionsCached(
+							library !== undefined
+								? library
+								: compilation.outputOptions.library
+						);
+						if (options !== false) {
+							const dep = deps[deps.length - 1];
+							if (dep) {
+								const module = compilation.moduleGraph.getModule(dep);
+								if (module) {
+									this.finishEntryModule(module, name, {
+										options,
+										compilation,
+										chunkGraph: compilation.chunkGraph
+									});
 								}
 							}
 						}
+					}
+				}
+			);
 
-						if (
-							Object.keys(item.cacheGroup.maxAsyncSize).length > 0 ||
-							Object.keys(item.cacheGroup.maxInitialSize).length > 0
-						) {
-							const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
-							maxSizeQueueMap.set(newChunk, {
-								minSize: oldMaxSizeSettings
-									? combineSizes(
-											oldMaxSizeSettings.minSize,
-											item.cacheGroup._minSizeForMaxSize,
-											Math.max
-									  )
-									: item.cacheGroup.minSize,
-								maxAsyncSize: oldMaxSizeSettings
-									? combineSizes(
-											oldMaxSizeSettings.maxAsyncSize,
-											item.cacheGroup.maxAsyncSize,
-											Math.min
-									  )
-									: item.cacheGroup.maxAsyncSize,
-								maxInitialSize: oldMaxSizeSettings
-									? combineSizes(
-											oldMaxSizeSettings.maxInitialSize,
-											item.cacheGroup.maxInitialSize,
-											Math.min
-									  )
-									: item.cacheGroup.maxInitialSize,
-								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
-								keys: oldMaxSizeSettings
-									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
-									: [item.cacheGroup.key]
-							});
-						}
+			const getOptionsForChunk = chunk => {
+				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
+					return false;
+				const options = chunk.getEntryOptions();
+				const library = options && options.library;
+				return this._parseOptionsCached(
+					library !== undefined ? library : compilation.outputOptions.library
+				);
+			};
 
-						// remove all modules from other entries and update size
-						for (const [key, info] of chunksInfoMap) {
-							if (isOverlap(info.chunks, usedChunks)) {
-								// update modules and total size
-								// may remove it from the map when < minSize
-								let updated = false;
-								for (const module of item.modules) {
-									if (info.modules.has(module)) {
-										// remove module
-										info.modules.delete(module);
-										// update size
-										for (const key of module.getSourceTypes()) {
-											info.sizes[key] -= module.size(key);
-										}
-										updated = true;
-									}
-								}
-								if (updated) {
-									if (info.modules.size === 0) {
-										chunksInfoMap.delete(key);
-										continue;
-									}
-									if (
-										removeMinSizeViolatingModules(info) ||
-										!checkMinSizeReduction(
-											info.sizes,
-											info.cacheGroup.minSizeReduction,
-											info.chunks.size
-										)
-									) {
-										chunksInfoMap.delete(key);
-										continue;
-									}
-								}
-							}
+			if (
+				this.render !== AbstractLibraryPlugin.prototype.render ||
+				this.runtimeRequirements !==
+					AbstractLibraryPlugin.prototype.runtimeRequirements
+			) {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					_pluginName,
+					(chunk, set, { chunkGraph }) => {
+						const options = getOptionsForChunk(chunk);
+						if (options !== false) {
+							this.runtimeRequirements(chunk, set, {
+								options,
+								compilation,
+								chunkGraph
+							});
 						}
 					}
+				);
+			}
 
-					logger.timeEnd("queue");
+			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
 
-					logger.time("maxSize");
+			if (this.render !== AbstractLibraryPlugin.prototype.render) {
+				hooks.render.tap(_pluginName, (source, renderContext) => {
+					const options = getOptionsForChunk(renderContext.chunk);
+					if (options === false) return source;
+					return this.render(source, renderContext, {
+						options,
+						compilation,
+						chunkGraph: compilation.chunkGraph
+					});
+				});
+			}
 
-					/** @type {Set<string>} */
-					const incorrectMinMaxSizeSet = new Set();
+			if (
+				this.embedInRuntimeBailout !==
+				AbstractLibraryPlugin.prototype.embedInRuntimeBailout
+			) {
+				hooks.embedInRuntimeBailout.tap(
+					_pluginName,
+					(module, renderContext) => {
+						const options = getOptionsForChunk(renderContext.chunk);
+						if (options === false) return;
+						return this.embedInRuntimeBailout(module, renderContext, {
+							options,
+							compilation,
+							chunkGraph: compilation.chunkGraph
+						});
+					}
+				);
+			}
 
-					const { outputOptions } = compilation;
+			if (
+				this.strictRuntimeBailout !==
+				AbstractLibraryPlugin.prototype.strictRuntimeBailout
+			) {
+				hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
+					const options = getOptionsForChunk(renderContext.chunk);
+					if (options === false) return;
+					return this.strictRuntimeBailout(renderContext, {
+						options,
+						compilation,
+						chunkGraph: compilation.chunkGraph
+					});
+				});
+			}
 
-					// Make sure that maxSize is fulfilled
-					const { fallbackCacheGroup } = this.options;
-					for (const chunk of Array.from(compilation.chunks)) {
-						const chunkConfig = maxSizeQueueMap.get(chunk);
-						const {
-							minSize,
-							maxAsyncSize,
-							maxInitialSize,
-							automaticNameDelimiter
-						} = chunkConfig || fallbackCacheGroup;
-						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
-							continue;
-						/** @type {SplitChunksSizes} */
-						let maxSize;
-						if (chunk.isOnlyInitial()) {
-							maxSize = maxInitialSize;
-						} else if (chunk.canBeInitial()) {
-							maxSize = combineSizes(maxAsyncSize, maxInitialSize, Math.min);
-						} else {
-							maxSize = maxAsyncSize;
-						}
-						if (Object.keys(maxSize).length === 0) {
-							continue;
-						}
-						for (const key of Object.keys(maxSize)) {
-							const maxSizeValue = maxSize[key];
-							const minSizeValue = minSize[key];
-							if (
-								typeof minSizeValue === "number" &&
-								minSizeValue > maxSizeValue
-							) {
-								const keys = chunkConfig && chunkConfig.keys;
-								const warningKey = `${
-									keys && keys.join()
-								} ${minSizeValue} ${maxSizeValue}`;
-								if (!incorrectMinMaxSizeSet.has(warningKey)) {
-									incorrectMinMaxSizeSet.add(warningKey);
-									compilation.warnings.push(
-										new MinMaxSizeWarning(keys, minSizeValue, maxSizeValue)
-									);
-								}
-							}
-						}
-						const results = deterministicGroupingForModules({
-							minSize,
-							maxSize: mapObject(maxSize, (value, key) => {
-								const minSizeValue = minSize[key];
-								return typeof minSizeValue === "number"
-									? Math.max(value, minSizeValue)
-									: value;
-							}),
-							items: chunkGraph.getChunkModulesIterable(chunk),
-							getKey(module) {
-								const cache = getKeyCache.get(module);
-								if (cache !== undefined) return cache;
-								const ident = cachedMakePathsRelative(module.identifier());
-								const nameForCondition =
-									module.nameForCondition && module.nameForCondition();
-								const name = nameForCondition
-									? cachedMakePathsRelative(nameForCondition)
-									: ident.replace(/^.*!|\?[^?!]*$/g, "");
-								const fullKey =
-									name +
-									automaticNameDelimiter +
-									hashFilename(ident, outputOptions);
-								const key = requestToId(fullKey);
-								getKeyCache.set(module, key);
-								return key;
-							},
-							getSize(module) {
-								const size = Object.create(null);
-								for (const key of module.getSourceTypes()) {
-									size[key] = module.size(key);
-								}
-								return size;
-							}
+			if (
+				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
+			) {
+				hooks.renderStartup.tap(
+					_pluginName,
+					(source, module, renderContext) => {
+						const options = getOptionsForChunk(renderContext.chunk);
+						if (options === false) return source;
+						return this.renderStartup(source, module, renderContext, {
+							options,
+							compilation,
+							chunkGraph: compilation.chunkGraph
 						});
-						if (results.length <= 1) {
-							continue;
-						}
-						for (let i = 0; i < results.length; i++) {
-							const group = results[i];
-							const key = this.options.hidePathInfo
-								? hashFilename(group.key, outputOptions)
-								: group.key;
-							let name = chunk.name
-								? chunk.name + automaticNameDelimiter + key
-								: null;
-							if (name && name.length > 100) {
-								name =
-									name.slice(0, 100) +
-									automaticNameDelimiter +
-									hashFilename(name, outputOptions);
-							}
-							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(name);
-								chunk.split(newPart);
-								newPart.chunkReason = chunk.chunkReason;
-								// Add all modules to the new chunk
-								for (const module of group.items) {
-									if (!module.chunkCondition(newPart, compilation)) {
-										continue;
-									}
-									// Add module to new chunk
-									chunkGraph.connectChunkAndModule(newPart, module);
-									// Remove module from used chunks
-									chunkGraph.disconnectChunkAndModule(chunk, module);
-								}
-							} else {
-								// change the chunk to be a part
-								chunk.name = name;
-							}
-						}
 					}
-					logger.timeEnd("maxSize");
-				}
-			);
+				);
+			}
+
+			hooks.chunkHash.tap(_pluginName, (chunk, hash, context) => {
+				const options = getOptionsForChunk(chunk);
+				if (options === false) return;
+				this.chunkHash(chunk, hash, context, {
+					options,
+					compilation,
+					chunkGraph: compilation.chunkGraph
+				});
+			});
 		});
 	}
-};
+
+	/**
+	 * @param {LibraryOptions=} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	_parseOptionsCached(library) {
+		if (!library) return false;
+		if (library.type !== this._type) return false;
+		const cacheEntry = this._parseCache.get(library);
+		if (cacheEntry !== undefined) return cacheEntry;
+		const result = this.parseOptions(library);
+		this._parseCache.set(library, result);
+		return result;
+	}
+
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	finishEntryModule(module, entryName, libraryContext) {}
+
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	embedInRuntimeBailout(module, renderContext, libraryContext) {
+		return undefined;
+	}
+
+	/**
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	strictRuntimeBailout(renderContext, libraryContext) {
+		return undefined;
+	}
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	runtimeRequirements(chunk, set, libraryContext) {
+		if (this.render !== AbstractLibraryPlugin.prototype.render)
+			set.add(RuntimeGlobals.returnExportsFromRuntime);
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, renderContext, libraryContext) {
+		return source;
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(source, module, renderContext, libraryContext) {
+		return source;
+	}
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	chunkHash(chunk, hash, chunkHashContext, libraryContext) {
+		const options = this._parseOptionsCached(
+			libraryContext.compilation.outputOptions.library
+		);
+		hash.update(this._pluginName);
+		hash.update(JSON.stringify(options));
+	}
+}
+
+AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
+module.exports = AbstractLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 52149:
+/***/ 67416:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { formatSize } = __webpack_require__(71070);
-const WebpackError = __webpack_require__(53799);
+const { ConcatSource } = __webpack_require__(51255);
+const ExternalModule = __webpack_require__(73071);
+const Template = __webpack_require__(39722);
+const AbstractLibraryPlugin = __webpack_require__(26030);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @typedef {Object} AmdLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {boolean=} requireAsWrapper
+ */
+
+/**
+ * @typedef {Object} AmdLibraryPluginParsed
+ * @property {string} name
+ */
+
+/**
+ * @typedef {AmdLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<AmdLibraryPluginParsed>}
+ */
+class AmdLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {AmdLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "AmdLibraryPlugin",
+			type: options.type
+		});
+		this.requireAsWrapper = options.requireAsWrapper;
+	}
+
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (this.requireAsWrapper) {
+			if (name) {
+				throw new Error(
+					`AMD library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
+		} else {
+			if (name && typeof name !== "string") {
+				throw new Error(
+					`AMD library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
+		}
+		return {
+			name: /** @type {string=} */ (name)
+		};
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(
+		source,
+		{ chunkGraph, chunk, runtimeTemplate },
+		{ options, compilation }
+	) {
+		const modern = runtimeTemplate.supportsArrowFunction();
+		const modules = chunkGraph
+			.getChunkModules(chunk)
+			.filter(m => m instanceof ExternalModule);
+		const externals = /** @type {ExternalModule[]} */ (modules);
+		const externalsDepsArray = JSON.stringify(
+			externals.map(m =>
+				typeof m.request === "object" && !Array.isArray(m.request)
+					? m.request.amd
+					: m.request
+			)
+		);
+		const externalsArguments = externals
+			.map(
+				m =>
+					`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+						`${chunkGraph.getModuleId(m)}`
+					)}__`
+			)
+			.join(", ");
+
+		const iife = runtimeTemplate.isIIFE();
+		const fnStart =
+			(modern
+				? `(${externalsArguments}) => {`
+				: `function(${externalsArguments}) {`) +
+			(iife || !chunk.hasRuntime() ? " return " : "\n");
+		const fnEnd = iife ? ";\n}" : "\n}";
+
+		if (this.requireAsWrapper) {
+			return new ConcatSource(
+				`require(${externalsDepsArray}, ${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
+		} else if (options.name) {
+			const name = compilation.getPath(options.name, {
+				chunk
+			});
 
-/** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
+			return new ConcatSource(
+				`define(${JSON.stringify(name)}, ${externalsDepsArray}, ${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
+		} else if (externalsArguments) {
+			return new ConcatSource(
+				`define(${externalsDepsArray}, ${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
+		} else {
+			return new ConcatSource(`define(${fnStart}`, source, `${fnEnd});`);
+		}
+	}
 
-module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
 	/**
-	 * @param {AssetDetails[]} assetsOverSizeLimit the assets
-	 * @param {number} assetLimit the size limit
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
 	 */
-	constructor(assetsOverSizeLimit, assetLimit) {
-		const assetLists = assetsOverSizeLimit
-			.map(asset => `\n  ${asset.name} (${formatSize(asset.size)})`)
-			.join("");
-
-		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(
-			assetLimit
-		)}).
-This can impact web performance.
-Assets: ${assetLists}`);
-
-		this.name = "AssetsOverSizeLimitWarning";
-		this.assets = assetsOverSizeLimit;
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("AmdLibraryPlugin");
+		if (this.requireAsWrapper) {
+			hash.update("requireAsWrapper");
+		} else if (options.name) {
+			hash.update("named");
+			const name = compilation.getPath(options.name, {
+				chunk
+			});
+			hash.update(name);
+		}
 	}
-};
+}
+
+module.exports = AmdLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 84229:
+/***/ 40080:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { formatSize } = __webpack_require__(71070);
-const WebpackError = __webpack_require__(53799);
+const { ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Template = __webpack_require__(39722);
+const propertyAccess = __webpack_require__(54190);
+const { getEntryRuntime } = __webpack_require__(17156);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-/** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
-	/**
-	 * @param {EntrypointDetails[]} entrypoints the entrypoints
-	 * @param {number} entrypointLimit the size limit
-	 */
-	constructor(entrypoints, entrypointLimit) {
-		const entrypointList = entrypoints
-			.map(
-				entrypoint =>
-					`\n  ${entrypoint.name} (${formatSize(
-						entrypoint.size
-					)})\n${entrypoint.files.map(asset => `      ${asset}`).join("\n")}`
-			)
-			.join("");
-		super(`entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${formatSize(
-			entrypointLimit
-		)}). This can impact web performance.
-Entrypoints:${entrypointList}\n`);
+const KEYWORD_REGEX =
+	/^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
+const IDENTIFIER_REGEX =
+	/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
 
-		this.name = "EntrypointsOverSizeLimitWarning";
-		this.entrypoints = entrypoints;
-	}
+/**
+ * Validates the library name by checking for keywords and valid characters
+ * @param {string} name name to be validated
+ * @returns {boolean} true, when valid
+ */
+const isNameValid = name => {
+	return !KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
 };
 
+/**
+ * @param {string[]} accessor variable plus properties
+ * @param {number} existingLength items of accessor that are existing already
+ * @param {boolean=} initLast if the last property should also be initialized to an object
+ * @returns {string} code to access the accessor while initializing
+ */
+const accessWithInit = (accessor, existingLength, initLast = false) => {
+	// This generates for [a, b, c, d]:
+	// (((a = typeof a === "undefined" ? {} : a).b = a.b || {}).c = a.b.c || {}).d
+	const base = accessor[0];
+	if (accessor.length === 1 && !initLast) return base;
+	let current =
+		existingLength > 0
+			? base
+			: `(${base} = typeof ${base} === "undefined" ? {} : ${base})`;
 
-/***/ }),
-
-/***/ 17791:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
+	// i is the current position in accessor that has been printed
+	let i = 1;
 
-module.exports = class NoAsyncChunksWarning extends WebpackError {
-	constructor() {
-		super(
-			"webpack performance recommendations: \n" +
-				"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
-				"For more info visit https://webpack.js.org/guides/code-splitting/"
-		);
+	// all properties printed so far (excluding base)
+	let propsSoFar;
 
-		this.name = "NoAsyncChunksWarning";
+	// if there is existingLength, print all properties until this position as property access
+	if (existingLength > i) {
+		propsSoFar = accessor.slice(1, existingLength);
+		i = existingLength;
+		current += propertyAccess(propsSoFar);
+	} else {
+		propsSoFar = [];
 	}
-};
-
-
-/***/ }),
-
-/***/ 32557:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-
 
+	// all remaining properties (except the last one when initLast is not set)
+	// should be printed as initializer
+	const initUntil = initLast ? accessor.length : accessor.length - 1;
+	for (; i < initUntil; i++) {
+		const prop = accessor[i];
+		propsSoFar.push(prop);
+		current = `(${current}${propertyAccess([prop])} = ${base}${propertyAccess(
+			propsSoFar
+		)} || {})`;
+	}
 
-const { find } = __webpack_require__(93347);
-const AssetsOverSizeLimitWarning = __webpack_require__(52149);
-const EntrypointsOverSizeLimitWarning = __webpack_require__(84229);
-const NoAsyncChunksWarning = __webpack_require__(17791);
+	// print the last property as property access if not yet printed
+	if (i < accessor.length)
+		current = `${current}${propertyAccess([accessor[accessor.length - 1]])}`;
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../WebpackError")} WebpackError */
+	return current;
+};
 
 /**
- * @typedef {Object} AssetDetails
- * @property {string} name
- * @property {number} size
+ * @typedef {Object} AssignLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {string[] | "global"} prefix name prefix
+ * @property {string | false} declare declare name as variable
+ * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
+ * @property {"copy"|"assign"=} named behavior for named library name
  */
 
 /**
- * @typedef {Object} EntrypointDetails
- * @property {string} name
- * @property {number} size
- * @property {string[]} files
+ * @typedef {Object} AssignLibraryPluginParsed
+ * @property {string | string[]} name
+ * @property {string | string[] | undefined} export
  */
 
-const isOverSizeLimitSet = new WeakSet();
-
-const excludeSourceMap = (name, source, info) => !info.development;
-
-module.exports = class SizeLimitsPlugin {
+/**
+ * @typedef {AssignLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
+ */
+class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	/**
-	 * @param {PerformanceOptions} options the plugin options
+	 * @param {AssignLibraryPluginOptions} options the plugin options
 	 */
 	constructor(options) {
-		this.hints = options.hints;
-		this.maxAssetSize = options.maxAssetSize;
-		this.maxEntrypointSize = options.maxEntrypointSize;
-		this.assetFilter = options.assetFilter;
+		super({
+			pluginName: "AssignLibraryPlugin",
+			type: options.type
+		});
+		this.prefix = options.prefix;
+		this.declare = options.declare;
+		this.unnamed = options.unnamed;
+		this.named = options.named || "assign";
 	}
 
 	/**
-	 * @param {ChunkGroup | Source} thing the resource to test
-	 * @returns {boolean} true if over the limit
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
 	 */
-	static isOverSizeLimit(thing) {
-		return isOverSizeLimitSet.has(thing);
+	parseOptions(library) {
+		const { name } = library;
+		if (this.unnamed === "error") {
+			if (typeof name !== "string" && !Array.isArray(name)) {
+				throw new Error(
+					`Library name must be a string or string array. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
+		} else {
+			if (name && typeof name !== "string" && !Array.isArray(name)) {
+				throw new Error(
+					`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
+		}
+		return {
+			name: /** @type {string|string[]=} */ (name),
+			export: library.export
+		};
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const entrypointSizeLimit = this.maxEntrypointSize;
-		const assetSizeLimit = this.maxAssetSize;
-		const hints = this.hints;
-		const assetFilter = this.assetFilter || excludeSourceMap;
-
-		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
-			/** @type {WebpackError[]} */
-			const warnings = [];
-
-			/**
-			 * @param {Entrypoint} entrypoint an entrypoint
-			 * @returns {number} the size of the entrypoint
-			 */
-			const getEntrypointSize = entrypoint => {
-				let size = 0;
-				for (const file of entrypoint.getFiles()) {
-					const asset = compilation.getAsset(file);
-					if (
-						asset &&
-						assetFilter(asset.name, asset.source, asset.info) &&
-						asset.source
-					) {
-						size += asset.info.size || asset.source.size();
-					}
-				}
-				return size;
-			};
-
-			/** @type {AssetDetails[]} */
-			const assetsOverSizeLimit = [];
-			for (const { name, source, info } of compilation.getAssets()) {
-				if (!assetFilter(name, source, info) || !source) {
-					continue;
-				}
-
-				const size = info.size || source.size();
-				if (size > assetSizeLimit) {
-					assetsOverSizeLimit.push({
-						name,
-						size
-					});
-					isOverSizeLimitSet.add(source);
-				}
-			}
+	finishEntryModule(
+		module,
+		entryName,
+		{ options, compilation, compilation: { moduleGraph } }
+	) {
+		const runtime = getEntryRuntime(compilation, entryName);
+		if (options.export) {
+			const exportsInfo = moduleGraph.getExportInfo(
+				module,
+				Array.isArray(options.export) ? options.export[0] : options.export
+			);
+			exportsInfo.setUsed(UsageState.Used, runtime);
+			exportsInfo.canMangleUse = false;
+		} else {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			exportsInfo.setUsedInUnknownWay(runtime);
+		}
+		moduleGraph.addExtraReason(module, "used as library export");
+	}
 
-			const fileFilter = name => {
-				const asset = compilation.getAsset(name);
-				return asset && assetFilter(asset.name, asset.source, asset.info);
-			};
+	_getPrefix(compilation) {
+		return this.prefix === "global"
+			? [compilation.runtimeTemplate.globalObject]
+			: this.prefix;
+	}
 
-			/** @type {EntrypointDetails[]} */
-			const entrypointsOverLimit = [];
-			for (const [name, entry] of compilation.entrypoints) {
-				const size = getEntrypointSize(entry);
+	_getResolvedFullName(options, chunk, compilation) {
+		const prefix = this._getPrefix(compilation);
+		const fullName = options.name ? prefix.concat(options.name) : prefix;
+		return fullName.map(n =>
+			compilation.getPath(n, {
+				chunk
+			})
+		);
+	}
 
-				if (size > entrypointSizeLimit) {
-					entrypointsOverLimit.push({
-						name: name,
-						size: size,
-						files: entry.getFiles().filter(fileFilter)
-					});
-					isOverSizeLimitSet.add(entry);
-				}
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, { chunk }, { options, compilation }) {
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		if (this.declare) {
+			const base = fullNameResolved[0];
+			if (!isNameValid(base)) {
+				throw new Error(
+					`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
+						base
+					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${
+						AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE
+					}`
+				);
 			}
+			source = new ConcatSource(`${this.declare} ${base};\n`, source);
+		}
+		return source;
+	}
 
-			if (hints) {
-				// 1. Individual Chunk: Size < 250kb
-				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
-				// 3. No Async Chunks
-				// if !1, then 2, if !2 return
-				if (assetsOverSizeLimit.length > 0) {
-					warnings.push(
-						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
-					);
-				}
-				if (entrypointsOverLimit.length > 0) {
-					warnings.push(
-						new EntrypointsOverSizeLimitWarning(
-							entrypointsOverLimit,
-							entrypointSizeLimit
-						)
-					);
-				}
-
-				if (warnings.length > 0) {
-					const someAsyncChunk = find(
-						compilation.chunks,
-						chunk => !chunk.canBeInitial()
-					);
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
+		const topLevelDeclarations =
+			module.buildInfo && module.buildInfo.topLevelDeclarations;
+		if (!topLevelDeclarations)
+			return "it doesn't tell about top level declarations.";
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		const base = fullNameResolved[0];
+		if (topLevelDeclarations.has(base))
+			return `it declares '${base}' on top-level, which conflicts with the current library output.`;
+	}
 
-					if (!someAsyncChunk) {
-						warnings.push(new NoAsyncChunksWarning());
-					}
+	/**
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	strictRuntimeBailout({ chunk }, { options, compilation }) {
+		if (
+			this.declare ||
+			this.prefix === "global" ||
+			this.prefix.length > 0 ||
+			!options.name
+		) {
+			return;
+		}
+		return "a global variable is assign and maybe created";
+	}
 
-					if (hints === "error") {
-						compilation.errors.push(...warnings);
-					} else {
-						compilation.warnings.push(...warnings);
-					}
-				}
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		const staticExports = this.unnamed === "static";
+		const exportAccess = options.export
+			? propertyAccess(
+					Array.isArray(options.export) ? options.export : [options.export]
+			  )
+			: "";
+		const result = new ConcatSource(source);
+		if (staticExports) {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportTarget = accessWithInit(
+				fullNameResolved,
+				this._getPrefix(compilation).length,
+				true
+			);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (!exportInfo.provided) continue;
+				const nameAccess = propertyAccess([exportInfo.name]);
+				result.add(
+					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
+				);
 			}
-		});
+			result.add(
+				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
+			);
+		} else if (options.name ? this.named === "copy" : this.unnamed === "copy") {
+			result.add(
+				`var __webpack_export_target__ = ${accessWithInit(
+					fullNameResolved,
+					this._getPrefix(compilation).length,
+					true
+				)};\n`
+			);
+			let exports = "__webpack_exports__";
+			if (exportAccess) {
+				result.add(
+					`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
+				);
+				exports = "__webpack_exports_export__";
+			}
+			result.add(
+				`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`
+			);
+			result.add(
+				`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`
+			);
+		} else {
+			result.add(
+				`${accessWithInit(
+					fullNameResolved,
+					this._getPrefix(compilation).length,
+					false
+				)} = __webpack_exports__${exportAccess};\n`
+			);
+		}
+		return result;
 	}
-};
-
-
-/***/ }),
-
-/***/ 95175:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
 
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {string} childType TODO
-	 * @param {string} runtimeFunction TODO
-	 * @param {string} runtimeHandlers TODO
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
 	 */
-	constructor(childType, runtimeFunction, runtimeHandlers) {
-		super(`chunk ${childType} function`);
-		this.childType = childType;
-		this.runtimeFunction = runtimeFunction;
-		this.runtimeHandlers = runtimeHandlers;
+	runtimeRequirements(chunk, set, libraryContext) {
+		// we don't need to return exports from runtime
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
 	 */
-	generate() {
-		const { runtimeFunction, runtimeHandlers } = this;
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${runtimeHandlers} = {};`,
-			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
-				// map is shorter than forEach
-				`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
-					"key",
-					`${runtimeHandlers}[key](chunkId);`
-				)});`
-			])}`
-		]);
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("AssignLibraryPlugin");
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
+			hash.update("copy");
+		}
+		if (this.declare) {
+			hash.update(this.declare);
+		}
+		hash.update(fullNameResolved.join("."));
+		if (options.export) {
+			hash.update(`${options.export}`);
+		}
 	}
 }
 
-module.exports = ChunkPrefetchFunctionRuntimeModule;
+module.exports = AssignLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 33895:
+/***/ 91452:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -107387,424 +103558,373 @@ module.exports = ChunkPrefetchFunctionRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const ChunkPrefetchFunctionRuntimeModule = __webpack_require__(95175);
-const ChunkPrefetchStartupRuntimeModule = __webpack_require__(15294);
-const ChunkPrefetchTriggerRuntimeModule = __webpack_require__(98441);
-const ChunkPreloadTriggerRuntimeModule = __webpack_require__(56236);
-
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Compiler")} Compiler */
 
-class ChunkPrefetchPreloadPlugin {
-	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ChunkPrefetchPreloadPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
-						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
-							chunkGraph,
-							"prefetchOrder"
-						);
-						if (startupChildChunks) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							set.add(RuntimeGlobals.onChunksLoaded);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
-							);
-						}
-					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph, false);
+/** @type {WeakMap<Compiler, Set<LibraryType>>} */
+const enabledTypes = new WeakMap();
 
-						if (chunkMap.prefetch) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
-							);
-						}
-						if (chunkMap.preload) {
-							set.add(RuntimeGlobals.preloadChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.prefetchChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"prefetch",
-								RuntimeGlobals.prefetchChunk,
-								RuntimeGlobals.prefetchChunkHandlers
-							)
-						);
-						set.add(RuntimeGlobals.prefetchChunkHandlers);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.preloadChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"preload",
-								RuntimeGlobals.preloadChunk,
-								RuntimeGlobals.preloadChunkHandlers
-							)
-						);
-						set.add(RuntimeGlobals.preloadChunkHandlers);
-					});
-			}
-		);
+const getEnabledTypes = compiler => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
 	}
-}
-
-module.exports = ChunkPrefetchPreloadPlugin;
-
-
-/***/ }),
-
-/***/ 15294:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+	return set;
+};
 
-class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
+class EnableLibraryPlugin {
 	/**
-	 * @param {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} startupChunks chunk ids to trigger when chunks are loaded
+	 * @param {LibraryType} type library type that should be available
 	 */
-	constructor(startupChunks) {
-		super("startup prefetch", RuntimeModule.STAGE_TRIGGER);
-		this.startupChunks = startupChunks;
+	constructor(type) {
+		this.type = type;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {LibraryType} type type of library
+	 * @returns {void}
 	 */
-	generate() {
-		const { startupChunks, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString(
-			startupChunks.map(
-				({ onChunks, chunks }) =>
-					`${RuntimeGlobals.onChunksLoaded}(0, ${JSON.stringify(
-						// This need to include itself to delay execution after this chunk has been fully loaded
-						onChunks.filter(c => c === chunk).map(c => c.id)
-					)}, ${runtimeTemplate.basicFunction(
-						"",
-						chunks.size < 3
-							? Array.from(
-									chunks,
-									c =>
-										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
-							  )
-							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
-									RuntimeGlobals.prefetchChunk
-							  });`
-					)}, 5);`
-			)
-		);
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
 	}
-}
-
-module.exports = ChunkPrefetchStartupRuntimeModule;
-
-
-/***/ }),
-
-/***/ 98441:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
 
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {LibraryType} type type of library
+	 * @returns {void}
 	 */
-	constructor(chunkMap) {
-		super(`chunk prefetch trigger`, RuntimeModule.STAGE_TRIGGER);
-		this.chunkMap = chunkMap;
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Library type "${type}" is not enabled. ` +
+					"EnableLibraryPlugin need to be used to enable this type of library. " +
+					'This usually happens through the "output.enabledLibraryTypes" option. ' +
+					'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
+					"These types are enabled: " +
+					Array.from(getEnabledTypes(compiler)).join(", ")
+			);
+		}
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
-		const body = [
-			"var chunks = chunkToChildrenMap[chunkId];",
-			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`
-		];
-		return Template.asString([
-			Template.asString([
-				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
-				`${
-					RuntimeGlobals.ensureChunkHandlers
-				}.prefetch = ${runtimeTemplate.expressionFunction(
-					`Promise.all(promises).then(${runtimeTemplate.basicFunction(
-						"",
-						body
-					)})`,
-					"chunkId, promises"
-				)};`
-			])
-		]);
+	apply(compiler) {
+		const { type } = this;
+
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
+
+		if (typeof type === "string") {
+			const enableExportProperty = () => {
+				const ExportPropertyTemplatePlugin = __webpack_require__(5487);
+				new ExportPropertyTemplatePlugin({
+					type,
+					nsObjectUsed: type !== "module"
+				}).apply(compiler);
+			};
+			switch (type) {
+				case "var": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: "var",
+						unnamed: "error"
+					}).apply(compiler);
+					break;
+				}
+				case "assign-properties": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: false,
+						unnamed: "error",
+						named: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "assign": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: false,
+						unnamed: "error"
+					}).apply(compiler);
+					break;
+				}
+				case "this": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["this"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "window": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["window"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "self": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["self"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "global": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: "global",
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "commonjs": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["exports"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "commonjs-static": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["exports"],
+						declare: false,
+						unnamed: "static"
+					}).apply(compiler);
+					break;
+				}
+				case "commonjs2":
+				case "commonjs-module": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["module", "exports"],
+						declare: false,
+						unnamed: "assign"
+					}).apply(compiler);
+					break;
+				}
+				case "amd":
+				case "amd-require": {
+					enableExportProperty();
+					const AmdLibraryPlugin = __webpack_require__(67416);
+					new AmdLibraryPlugin({
+						type,
+						requireAsWrapper: type === "amd-require"
+					}).apply(compiler);
+					break;
+				}
+				case "umd":
+				case "umd2": {
+					enableExportProperty();
+					const UmdLibraryPlugin = __webpack_require__(54442);
+					new UmdLibraryPlugin({
+						type,
+						optionalAmdExternalAsGlobal: type === "umd2"
+					}).apply(compiler);
+					break;
+				}
+				case "system": {
+					enableExportProperty();
+					const SystemLibraryPlugin = __webpack_require__(11707);
+					new SystemLibraryPlugin({
+						type
+					}).apply(compiler);
+					break;
+				}
+				case "jsonp": {
+					enableExportProperty();
+					const JsonpLibraryPlugin = __webpack_require__(84415);
+					new JsonpLibraryPlugin({
+						type
+					}).apply(compiler);
+					break;
+				}
+				case "module": {
+					enableExportProperty();
+					const ModuleLibraryPlugin = __webpack_require__(59780);
+					new ModuleLibraryPlugin({
+						type
+					}).apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(`Unsupported library type ${type}.
+Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);
+			}
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
+		}
 	}
 }
 
-module.exports = ChunkPrefetchTriggerRuntimeModule;
+module.exports = EnableLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 56236:
+/***/ 5487:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const { ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const propertyAccess = __webpack_require__(54190);
+const { getEntryRuntime } = __webpack_require__(17156);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
+/**
+ * @typedef {Object} ExportPropertyLibraryPluginParsed
+ * @property {string | string[]} export
+ */
+
+/**
+ * @typedef {Object} ExportPropertyLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {boolean} nsObjectUsed the namespace object is used
+ */
+/**
+ * @typedef {ExportPropertyLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<ExportPropertyLibraryPluginParsed>}
+ */
+class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
+	 * @param {ExportPropertyLibraryPluginOptions} options options
 	 */
-	constructor(chunkMap) {
-		super(`chunk preload trigger`, RuntimeModule.STAGE_TRIGGER);
-		this.chunkMap = chunkMap;
+	constructor({ type, nsObjectUsed }) {
+		super({
+			pluginName: "ExportPropertyLibraryPlugin",
+			type
+		});
+		this.nsObjectUsed = nsObjectUsed;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
 	 */
-	generate() {
-		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
-		const body = [
-			"var chunks = chunkToChildrenMap[chunkId];",
-			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`
-		];
-		return Template.asString([
-			Template.asString([
-				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
-				`${
-					RuntimeGlobals.ensureChunkHandlers
-				}.preload = ${runtimeTemplate.basicFunction("chunkId", body)};`
-			])
-		]);
-	}
-}
-
-module.exports = ChunkPreloadTriggerRuntimeModule;
-
-
-/***/ }),
-
-/***/ 30318:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-
-class BasicEffectRulePlugin {
-	constructor(ruleProperty, effectType) {
-		this.ruleProperty = ruleProperty;
-		this.effectType = effectType || ruleProperty;
+	parseOptions(library) {
+		return {
+			export: library.export
+		};
 	}
 
 	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
-	apply(ruleSetCompiler) {
-		ruleSetCompiler.hooks.rule.tap(
-			"BasicEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
-				if (unhandledProperties.has(this.ruleProperty)) {
-					unhandledProperties.delete(this.ruleProperty);
-
-					const value = rule[this.ruleProperty];
-
-					result.effects.push({
-						type: this.effectType,
-						value
-					});
-				}
+	finishEntryModule(
+		module,
+		entryName,
+		{ options, compilation, compilation: { moduleGraph } }
+	) {
+		const runtime = getEntryRuntime(compilation, entryName);
+		if (options.export) {
+			const exportsInfo = moduleGraph.getExportInfo(
+				module,
+				Array.isArray(options.export) ? options.export[0] : options.export
+			);
+			exportsInfo.setUsed(UsageState.Used, runtime);
+			exportsInfo.canMangleUse = false;
+		} else {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			if (this.nsObjectUsed) {
+				exportsInfo.setUsedInUnknownWay(runtime);
+			} else {
+				exportsInfo.setAllKnownExportsUsed(runtime);
 			}
-		);
-	}
-}
-
-module.exports = BasicEffectRulePlugin;
-
-
-/***/ }),
-
-/***/ 94215:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
-
-class BasicMatcherRulePlugin {
-	constructor(ruleProperty, dataProperty, invert) {
-		this.ruleProperty = ruleProperty;
-		this.dataProperty = dataProperty || ruleProperty;
-		this.invert = invert || false;
+		}
+		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
 	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
-	apply(ruleSetCompiler) {
-		ruleSetCompiler.hooks.rule.tap(
-			"BasicMatcherRulePlugin",
-			(path, rule, unhandledProperties, result) => {
-				if (unhandledProperties.has(this.ruleProperty)) {
-					unhandledProperties.delete(this.ruleProperty);
-					const value = rule[this.ruleProperty];
-					const condition = ruleSetCompiler.compileCondition(
-						`${path}.${this.ruleProperty}`,
-						value
-					);
-					const fn = condition.fn;
-					result.conditions.push({
-						property: this.dataProperty,
-						matchWhenEmpty: this.invert
-							? !condition.matchWhenEmpty
-							: condition.matchWhenEmpty,
-						fn: this.invert ? v => !fn(v) : fn
-					});
-				}
-			}
-		);
-	}
-}
-
-module.exports = BasicMatcherRulePlugin;
-
-
-/***/ }),
-
-/***/ 72021:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
-
-class ObjectMatcherRulePlugin {
-	constructor(ruleProperty, dataProperty) {
-		this.ruleProperty = ruleProperty;
-		this.dataProperty = dataProperty || ruleProperty;
-	}
+	runtimeRequirements(chunk, set, libraryContext) {}
 
 	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
-	 * @returns {void}
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
 	 */
-	apply(ruleSetCompiler) {
-		const { ruleProperty, dataProperty } = this;
-		ruleSetCompiler.hooks.rule.tap(
-			"ObjectMatcherRulePlugin",
-			(path, rule, unhandledProperties, result) => {
-				if (unhandledProperties.has(ruleProperty)) {
-					unhandledProperties.delete(ruleProperty);
-					const value = rule[ruleProperty];
-					for (const property of Object.keys(value)) {
-						const nestedDataProperties = property.split(".");
-						const condition = ruleSetCompiler.compileCondition(
-							`${path}.${ruleProperty}.${property}`,
-							value[property]
-						);
-						result.conditions.push({
-							property: [dataProperty, ...nestedDataProperties],
-							matchWhenEmpty: condition.matchWhenEmpty,
-							fn: condition.fn
-						});
-					}
-				}
-			}
-		);
+	renderStartup(source, module, renderContext, { options }) {
+		if (!options.export) return source;
+		const postfix = `__webpack_exports__ = __webpack_exports__${propertyAccess(
+			Array.isArray(options.export) ? options.export : [options.export]
+		)};\n`;
+		return new ConcatSource(source, postfix);
 	}
 }
 
-module.exports = ObjectMatcherRulePlugin;
+module.exports = ExportPropertyLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 83349:
+/***/ 84415:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -107815,383 +103935,92 @@ module.exports = ObjectMatcherRulePlugin;
 
 
 
-const { SyncHook } = __webpack_require__(6967);
-
-/**
- * @typedef {Object} RuleCondition
- * @property {string | string[]} property
- * @property {boolean} matchWhenEmpty
- * @property {function(string): boolean} fn
- */
-
-/**
- * @typedef {Object} Condition
- * @property {boolean} matchWhenEmpty
- * @property {function(string): boolean} fn
- */
-
-/**
- * @typedef {Object} CompiledRule
- * @property {RuleCondition[]} conditions
- * @property {(Effect|function(object): Effect[])[]} effects
- * @property {CompiledRule[]=} rules
- * @property {CompiledRule[]=} oneOf
- */
+const { ConcatSource } = __webpack_require__(51255);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-/**
- * @typedef {Object} Effect
- * @property {string} type
- * @property {any} value
- */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @typedef {Object} RuleSet
- * @property {Map<string, any>} references map of references in the rule set (may grow over time)
- * @property {function(object): Effect[]} exec execute the rule set
+ * @typedef {Object} JsonpLibraryPluginOptions
+ * @property {LibraryType} type
  */
 
-class RuleSetCompiler {
-	constructor(plugins) {
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, object, Set<string>, CompiledRule, Map<string, any>]>} */
-			rule: new SyncHook([
-				"path",
-				"rule",
-				"unhandledProperties",
-				"compiledRule",
-				"references"
-			])
-		});
-		if (plugins) {
-			for (const plugin of plugins) {
-				plugin.apply(this);
-			}
-		}
-	}
-
-	/**
-	 * @param {object[]} ruleSet raw user provided rules
-	 * @returns {RuleSet} compiled RuleSet
-	 */
-	compile(ruleSet) {
-		const refs = new Map();
-		const rules = this.compileRules("ruleSet", ruleSet, refs);
-
-		/**
-		 * @param {object} data data passed in
-		 * @param {CompiledRule} rule the compiled rule
-		 * @param {Effect[]} effects an array where effects are pushed to
-		 * @returns {boolean} true, if the rule has matched
-		 */
-		const execRule = (data, rule, effects) => {
-			for (const condition of rule.conditions) {
-				const p = condition.property;
-				if (Array.isArray(p)) {
-					let current = data;
-					for (const subProperty of p) {
-						if (
-							current &&
-							typeof current === "object" &&
-							Object.prototype.hasOwnProperty.call(current, subProperty)
-						) {
-							current = current[subProperty];
-						} else {
-							current = undefined;
-							break;
-						}
-					}
-					if (current !== undefined) {
-						if (!condition.fn(current)) return false;
-						continue;
-					}
-				} else if (p in data) {
-					const value = data[p];
-					if (value !== undefined) {
-						if (!condition.fn(value)) return false;
-						continue;
-					}
-				}
-				if (!condition.matchWhenEmpty) {
-					return false;
-				}
-			}
-			for (const effect of rule.effects) {
-				if (typeof effect === "function") {
-					const returnedEffects = effect(data);
-					for (const effect of returnedEffects) {
-						effects.push(effect);
-					}
-				} else {
-					effects.push(effect);
-				}
-			}
-			if (rule.rules) {
-				for (const childRule of rule.rules) {
-					execRule(data, childRule, effects);
-				}
-			}
-			if (rule.oneOf) {
-				for (const childRule of rule.oneOf) {
-					if (execRule(data, childRule, effects)) {
-						break;
-					}
-				}
-			}
-			return true;
-		};
-
-		return {
-			references: refs,
-			exec: data => {
-				/** @type {Effect[]} */
-				const effects = [];
-				for (const rule of rules) {
-					execRule(data, rule, effects);
-				}
-				return effects;
-			}
-		};
-	}
-
-	/**
-	 * @param {string} path current path
-	 * @param {object[]} rules the raw rules provided by user
-	 * @param {Map<string, any>} refs references
-	 * @returns {CompiledRule[]} rules
-	 */
-	compileRules(path, rules, refs) {
-		return rules.map((rule, i) =>
-			this.compileRule(`${path}[${i}]`, rule, refs)
-		);
-	}
-
-	/**
-	 * @param {string} path current path
-	 * @param {object} rule the raw rule provided by user
-	 * @param {Map<string, any>} refs references
-	 * @returns {CompiledRule} normalized and compiled rule for processing
-	 */
-	compileRule(path, rule, refs) {
-		const unhandledProperties = new Set(
-			Object.keys(rule).filter(key => rule[key] !== undefined)
-		);
-
-		/** @type {CompiledRule} */
-		const compiledRule = {
-			conditions: [],
-			effects: [],
-			rules: undefined,
-			oneOf: undefined
-		};
-
-		this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs);
-
-		if (unhandledProperties.has("rules")) {
-			unhandledProperties.delete("rules");
-			const rules = rule.rules;
-			if (!Array.isArray(rules))
-				throw this.error(path, rules, "Rule.rules must be an array of rules");
-			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
-		}
-
-		if (unhandledProperties.has("oneOf")) {
-			unhandledProperties.delete("oneOf");
-			const oneOf = rule.oneOf;
-			if (!Array.isArray(oneOf))
-				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
-			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
-		}
-
-		if (unhandledProperties.size > 0) {
-			throw this.error(
-				path,
-				rule,
-				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
-			);
-		}
-
-		return compiledRule;
-	}
-
-	/**
-	 * @param {string} path current path
-	 * @param {any} condition user provided condition value
-	 * @returns {Condition} compiled condition
-	 */
-	compileCondition(path, condition) {
-		if (condition === "") {
-			return {
-				matchWhenEmpty: true,
-				fn: str => str === ""
-			};
-		}
-		if (!condition) {
-			throw this.error(
-				path,
-				condition,
-				"Expected condition but got falsy value"
-			);
-		}
-		if (typeof condition === "string") {
-			return {
-				matchWhenEmpty: condition.length === 0,
-				fn: str => typeof str === "string" && str.startsWith(condition)
-			};
-		}
-		if (typeof condition === "function") {
-			try {
-				return {
-					matchWhenEmpty: condition(""),
-					fn: condition
-				};
-			} catch (err) {
-				throw this.error(
-					path,
-					condition,
-					"Evaluation of condition function threw error"
-				);
-			}
-		}
-		if (condition instanceof RegExp) {
-			return {
-				matchWhenEmpty: condition.test(""),
-				fn: v => typeof v === "string" && condition.test(v)
-			};
-		}
-		if (Array.isArray(condition)) {
-			const items = condition.map((c, i) =>
-				this.compileCondition(`${path}[${i}]`, c)
-			);
-			return this.combineConditionsOr(items);
-		}
-
-		if (typeof condition !== "object") {
-			throw this.error(
-				path,
-				condition,
-				`Unexpected ${typeof condition} when condition was expected`
-			);
-		}
+/**
+ * @typedef {Object} JsonpLibraryPluginParsed
+ * @property {string} name
+ */
 
-		const conditions = [];
-		for (const key of Object.keys(condition)) {
-			const value = condition[key];
-			switch (key) {
-				case "or":
-					if (value) {
-						if (!Array.isArray(value)) {
-							throw this.error(
-								`${path}.or`,
-								condition.and,
-								"Expected array of conditions"
-							);
-						}
-						conditions.push(this.compileCondition(`${path}.or`, value));
-					}
-					break;
-				case "and":
-					if (value) {
-						if (!Array.isArray(value)) {
-							throw this.error(
-								`${path}.and`,
-								condition.and,
-								"Expected array of conditions"
-							);
-						}
-						let i = 0;
-						for (const item of value) {
-							conditions.push(this.compileCondition(`${path}.and[${i}]`, item));
-							i++;
-						}
-					}
-					break;
-				case "not":
-					if (value) {
-						const matcher = this.compileCondition(`${path}.not`, value);
-						const fn = matcher.fn;
-						conditions.push({
-							matchWhenEmpty: !matcher.matchWhenEmpty,
-							fn: v => !fn(v)
-						});
-					}
-					break;
-				default:
-					throw this.error(
-						`${path}.${key}`,
-						condition[key],
-						`Unexpected property ${key} in condition`
-					);
-			}
-		}
-		if (conditions.length === 0) {
-			throw this.error(
-				path,
-				condition,
-				"Expected condition, but got empty thing"
-			);
-		}
-		return this.combineConditionsAnd(conditions);
+/**
+ * @typedef {JsonpLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<JsonpLibraryPluginParsed>}
+ */
+class JsonpLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {JsonpLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "JsonpLibraryPlugin",
+			type: options.type
+		});
 	}
 
 	/**
-	 * @param {Condition[]} conditions some conditions
-	 * @returns {Condition} merged condition
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
 	 */
-	combineConditionsOr(conditions) {
-		if (conditions.length === 0) {
-			return {
-				matchWhenEmpty: false,
-				fn: () => false
-			};
-		} else if (conditions.length === 1) {
-			return conditions[0];
-		} else {
-			return {
-				matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
-				fn: v => conditions.some(c => c.fn(v))
-			};
+	parseOptions(library) {
+		const { name } = library;
+		if (typeof name !== "string") {
+			throw new Error(
+				`Jsonp library name must be a simple string. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
 		}
+		return {
+			name: /** @type {string} */ (name)
+		};
 	}
 
 	/**
-	 * @param {Condition[]} conditions some conditions
-	 * @returns {Condition} merged condition
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
 	 */
-	combineConditionsAnd(conditions) {
-		if (conditions.length === 0) {
-			return {
-				matchWhenEmpty: false,
-				fn: () => false
-			};
-		} else if (conditions.length === 1) {
-			return conditions[0];
-		} else {
-			return {
-				matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
-				fn: v => conditions.every(c => c.fn(v))
-			};
-		}
+	render(source, { chunk }, { options, compilation }) {
+		const name = compilation.getPath(options.name, {
+			chunk
+		});
+		return new ConcatSource(`${name}(`, source, ")");
 	}
 
 	/**
-	 * @param {string} path current path
-	 * @param {any} value value at the error location
-	 * @param {string} message message explaining the problem
-	 * @returns {Error} an error object
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
 	 */
-	error(path, value, message) {
-		return new Error(
-			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
-		);
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("JsonpLibraryPlugin");
+		hash.update(compilation.getPath(options.name, { chunk }));
 	}
 }
 
-module.exports = RuleSetCompiler;
+module.exports = JsonpLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 84977:
+/***/ 59780:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -108202,1203 +104031,1717 @@ module.exports = RuleSetCompiler;
 
 
 
-const util = __webpack_require__(73837);
+const { ConcatSource } = __webpack_require__(51255);
+const Template = __webpack_require__(39722);
+const propertyAccess = __webpack_require__(54190);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").Effect} Effect */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-class UseEffectRulePlugin {
+/**
+ * @typedef {Object} ModuleLibraryPluginOptions
+ * @property {LibraryType} type
+ */
+
+/**
+ * @typedef {Object} ModuleLibraryPluginParsed
+ * @property {string} name
+ */
+
+/**
+ * @typedef {ModuleLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
+ */
+class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
-	 * @returns {void}
+	 * @param {ModuleLibraryPluginOptions} options the plugin options
 	 */
-	apply(ruleSetCompiler) {
-		ruleSetCompiler.hooks.rule.tap(
-			"UseEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
-				const conflictWith = (property, correctProperty) => {
-					if (unhandledProperties.has(property)) {
-						throw ruleSetCompiler.error(
-							`${path}.${property}`,
-							rule[property],
-							`A Rule must not have a '${property}' property when it has a '${correctProperty}' property`
-						);
-					}
-				};
+	constructor(options) {
+		super({
+			pluginName: "ModuleLibraryPlugin",
+			type: options.type
+		});
+	}
 
-				if (unhandledProperties.has("use")) {
-					unhandledProperties.delete("use");
-					unhandledProperties.delete("enforce");
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (name) {
+			throw new Error(
+				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
+		}
+		return {
+			name: /** @type {string} */ (name)
+		};
+	}
 
-					conflictWith("loader", "use");
-					conflictWith("options", "use");
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
+		const result = new ConcatSource(source);
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		const exports = [];
+		const isAsync = moduleGraph.isAsync(module);
+		if (isAsync) {
+			result.add(`__webpack_exports__ = await __webpack_exports__;\n`);
+		}
+		for (const exportInfo of exportsInfo.orderedExports) {
+			if (!exportInfo.provided) continue;
+			const varName = `__webpack_exports__${Template.toIdentifier(
+				exportInfo.name
+			)}`;
+			result.add(
+				`var ${varName} = __webpack_exports__${propertyAccess([
+					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
+				])};\n`
+			);
+			exports.push(`${varName} as ${exportInfo.name}`);
+		}
+		if (exports.length > 0) {
+			result.add(`export { ${exports.join(", ")} };\n`);
+		}
+		return result;
+	}
+}
 
-					const use = rule.use;
-					const enforce = rule.enforce;
+module.exports = ModuleLibraryPlugin;
 
-					const type = enforce ? `use-${enforce}` : "use";
 
-					/**
-					 *
-					 * @param {string} path options path
-					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
-					 * @returns {Effect|function(any): Effect[]} effect
-					 */
-					const useToEffect = (path, defaultIdent, item) => {
-						if (typeof item === "function") {
-							return data => useToEffectsWithoutIdent(path, item(data));
-						} else {
-							return useToEffectRaw(path, defaultIdent, item);
-						}
-					};
+/***/ }),
 
-					/**
-					 *
-					 * @param {string} path options path
-					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
-					 * @returns {Effect} effect
-					 */
-					const useToEffectRaw = (path, defaultIdent, item) => {
-						if (typeof item === "string") {
-							return {
-								type,
-								value: {
-									loader: item,
-									options: undefined,
-									ident: undefined
-								}
-							};
-						} else {
-							const loader = item.loader;
-							const options = item.options;
-							let ident = item.ident;
-							if (options && typeof options === "object") {
-								if (!ident) ident = defaultIdent;
-								references.set(ident, options);
-							}
-							if (typeof options === "string") {
-								util.deprecate(
-									() => {},
-									`Using a string as loader options is deprecated (${path}.options)`,
-									"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
-								)();
-							}
-							return {
-								type: enforce ? `use-${enforce}` : "use",
-								value: {
-									loader,
-									options,
-									ident
-								}
-							};
-						}
-					};
+/***/ 11707:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					/**
-					 * @param {string} path options path
-					 * @param {any} items user provided use value
-					 * @returns {Effect[]} effects
-					 */
-					const useToEffectsWithoutIdent = (path, items) => {
-						if (Array.isArray(items)) {
-							return items.map((item, idx) =>
-								useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
-							);
-						}
-						return [useToEffectRaw(path, "[[missing ident]]", items)];
-					};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Joel Denning @joeldenning
+*/
 
-					/**
-					 * @param {string} path current path
-					 * @param {any} items user provided use value
-					 * @returns {(Effect|function(any): Effect[])[]} effects
-					 */
-					const useToEffects = (path, items) => {
-						if (Array.isArray(items)) {
-							return items.map((item, idx) => {
-								const subPath = `${path}[${idx}]`;
-								return useToEffect(subPath, subPath, item);
-							});
-						}
-						return [useToEffect(path, path, items)];
-					};
 
-					if (typeof use === "function") {
-						result.effects.push(data =>
-							useToEffectsWithoutIdent(`${path}.use`, use(data))
-						);
-					} else {
-						for (const effect of useToEffects(`${path}.use`, use)) {
-							result.effects.push(effect);
-						}
-					}
-				}
 
-				if (unhandledProperties.has("loader")) {
-					unhandledProperties.delete("loader");
-					unhandledProperties.delete("options");
-					unhandledProperties.delete("enforce");
+const { ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const ExternalModule = __webpack_require__(73071);
+const Template = __webpack_require__(39722);
+const propertyAccess = __webpack_require__(54190);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-					const loader = rule.loader;
-					const options = rule.options;
-					const enforce = rule.enforce;
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-					if (loader.includes("!")) {
-						throw ruleSetCompiler.error(
-							`${path}.loader`,
-							loader,
-							"Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays"
-						);
-					}
+/**
+ * @typedef {Object} SystemLibraryPluginOptions
+ * @property {LibraryType} type
+ */
 
-					if (loader.includes("?")) {
-						throw ruleSetCompiler.error(
-							`${path}.loader`,
-							loader,
-							"Query arguments on 'loader' has been removed in favor of the 'options' property"
-						);
-					}
+/**
+ * @typedef {Object} SystemLibraryPluginParsed
+ * @property {string} name
+ */
 
-					if (typeof options === "string") {
-						util.deprecate(
-							() => {},
-							`Using a string as loader options is deprecated (${path}.options)`,
-							"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
-						)();
-					}
+/**
+ * @typedef {SystemLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<SystemLibraryPluginParsed>}
+ */
+class SystemLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {SystemLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "SystemLibraryPlugin",
+			type: options.type
+		});
+	}
+
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (name && typeof name !== "string") {
+			throw new Error(
+				`System.js library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
+		}
+		return {
+			name: /** @type {string=} */ (name)
+		};
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
+		const modules = chunkGraph
+			.getChunkModules(chunk)
+			.filter(m => m instanceof ExternalModule && m.externalType === "system");
+		const externals = /** @type {ExternalModule[]} */ (modules);
+
+		// The name this bundle should be registered as with System
+		const name = options.name
+			? `${JSON.stringify(compilation.getPath(options.name, { chunk }))}, `
+			: "";
+
+		// The array of dependencies that are external to webpack and will be provided by System
+		const systemDependencies = JSON.stringify(
+			externals.map(m =>
+				typeof m.request === "object" && !Array.isArray(m.request)
+					? m.request.amd
+					: m.request
+			)
+		);
+
+		// The name of the variable provided by System for exporting
+		const dynamicExport = "__WEBPACK_DYNAMIC_EXPORT__";
+
+		// An array of the internal variable names for the webpack externals
+		const externalWebpackNames = externals.map(
+			m =>
+				`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+					`${chunkGraph.getModuleId(m)}`
+				)}__`
+		);
+
+		// Declaring variables for the internal variable names for the webpack externals
+		const externalVarDeclarations = externalWebpackNames
+			.map(name => `var ${name} = {};`)
+			.join("\n");
+
+		// Define __esModule flag on all internal variables and helpers
+		const externalVarInitialization = [];
+
+		// The system.register format requires an array of setter functions for externals.
+		const setters =
+			externalWebpackNames.length === 0
+				? ""
+				: Template.asString([
+						"setters: [",
+						Template.indent(
+							externals
+								.map((module, i) => {
+									const external = externalWebpackNames[i];
+									const exportsInfo = moduleGraph.getExportsInfo(module);
+									const otherUnused =
+										exportsInfo.otherExportsInfo.getUsed(chunk.runtime) ===
+										UsageState.Unused;
+									const instructions = [];
+									const handledNames = [];
+									for (const exportInfo of exportsInfo.orderedExports) {
+										const used = exportInfo.getUsedName(
+											undefined,
+											chunk.runtime
+										);
+										if (used) {
+											if (otherUnused || used !== exportInfo.name) {
+												instructions.push(
+													`${external}${propertyAccess([
+														used
+													])} = module${propertyAccess([exportInfo.name])};`
+												);
+												handledNames.push(exportInfo.name);
+											}
+										} else {
+											handledNames.push(exportInfo.name);
+										}
+									}
+									if (!otherUnused) {
+										if (
+											!Array.isArray(module.request) ||
+											module.request.length === 1
+										) {
+											externalVarInitialization.push(
+												`Object.defineProperty(${external}, "__esModule", { value: true });`
+											);
+										}
+										if (handledNames.length > 0) {
+											const name = `${external}handledNames`;
+											externalVarInitialization.push(
+												`var ${name} = ${JSON.stringify(handledNames)};`
+											);
+											instructions.push(
+												Template.asString([
+													"Object.keys(module).forEach(function(key) {",
+													Template.indent([
+														`if(${name}.indexOf(key) >= 0)`,
+														Template.indent(`${external}[key] = module[key];`)
+													]),
+													"});"
+												])
+											);
+										} else {
+											instructions.push(
+												Template.asString([
+													"Object.keys(module).forEach(function(key) {",
+													Template.indent([`${external}[key] = module[key];`]),
+													"});"
+												])
+											);
+										}
+									}
+									if (instructions.length === 0) return "function() {}";
+									return Template.asString([
+										"function(module) {",
+										Template.indent(instructions),
+										"}"
+									]);
+								})
+								.join(",\n")
+						),
+						"],"
+				  ]);
 
-					const ident =
-						options && typeof options === "object" ? path : undefined;
-					references.set(ident, options);
-					result.effects.push({
-						type: enforce ? `use-${enforce}` : "use",
-						value: {
-							loader,
-							options,
-							ident
-						}
-					});
-				}
-			}
+		return new ConcatSource(
+			Template.asString([
+				`System.register(${name}${systemDependencies}, function(${dynamicExport}, __system_context__) {`,
+				Template.indent([
+					externalVarDeclarations,
+					Template.asString(externalVarInitialization),
+					"return {",
+					Template.indent([
+						setters,
+						"execute: function() {",
+						Template.indent(`${dynamicExport}(`)
+					])
+				]),
+				""
+			]),
+			source,
+			Template.asString([
+				"",
+				Template.indent([
+					Template.indent([Template.indent([");"]), "}"]),
+					"};"
+				]),
+				"})"
+			])
 		);
 	}
 
-	useItemToEffects(path, item) {}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("SystemLibraryPlugin");
+		if (options.name) {
+			hash.update(compilation.getPath(options.name, { chunk }));
+		}
+	}
 }
 
-module.exports = UseEffectRulePlugin;
+module.exports = SystemLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 63672:
+/***/ 54442:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+const { ConcatSource, OriginalSource } = __webpack_require__(51255);
+const ExternalModule = __webpack_require__(73071);
+const Template = __webpack_require__(39722);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-class AsyncModuleRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("async module");
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdCommentObject} LibraryCustomUmdCommentObject */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdObject} LibraryCustomUmdObject */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @param {string[]} accessor the accessor to convert to path
+ * @returns {string} the path
+ */
+const accessorToObjectAccess = accessor => {
+	return accessor.map(a => `[${JSON.stringify(a)}]`).join("");
+};
+
+/**
+ * @param {string|undefined} base the path prefix
+ * @param {string|string[]} accessor the accessor
+ * @param {string=} joinWith the element separator
+ * @returns {string} the path
+ */
+const accessorAccess = (base, accessor, joinWith = ", ") => {
+	const accessors = Array.isArray(accessor) ? accessor : [accessor];
+	return accessors
+		.map((_, idx) => {
+			const a = base
+				? base + accessorToObjectAccess(accessors.slice(0, idx + 1))
+				: accessors[0] + accessorToObjectAccess(accessors.slice(1, idx + 1));
+			if (idx === accessors.length - 1) return a;
+			if (idx === 0 && base === undefined)
+				return `${a} = typeof ${a} === "object" ? ${a} : {}`;
+			return `${a} = ${a} || {}`;
+		})
+		.join(joinWith);
+};
+
+/** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
+
+/**
+ * @typedef {Object} UmdLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {boolean=} optionalAmdExternalAsGlobal
+ */
+
+/**
+ * @typedef {Object} UmdLibraryPluginParsed
+ * @property {string | string[]} name
+ * @property {LibraryCustomUmdObject} names
+ * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
+ * @property {boolean} namedDefine
+ */
+
+/**
+ * @typedef {UmdLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<UmdLibraryPluginParsed>}
+ */
+class UmdLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {UmdLibraryPluginOptions} options the plugin option
+	 */
+	constructor(options) {
+		super({
+			pluginName: "UmdLibraryPlugin",
+			type: options.type
+		});
+
+		this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.asyncModule;
-		return Template.asString([
-			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
-			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
-			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
-			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
-				"if(queue) {",
-				Template.indent([
-					`queue.forEach(${runtimeTemplate.expressionFunction(
-						"fn.r--",
-						"fn"
-					)});`,
-					`queue.forEach(${runtimeTemplate.expressionFunction(
-						"fn.r-- ? fn.r++ : fn()",
-						"fn"
-					)});`
-				]),
-				"}"
-			])}`,
-			`var completeFunction = ${runtimeTemplate.expressionFunction(
-				"!--fn.r && fn()",
-				"fn"
-			)};`,
-			`var queueFunction = ${runtimeTemplate.expressionFunction(
-				"queue ? queue.push(fn) : completeFunction(fn)",
-				"queue, fn"
-			)};`,
-			`var wrapDeps = ${runtimeTemplate.returningFunction(
-				`deps.map(${runtimeTemplate.basicFunction("dep", [
-					'if(dep !== null && typeof dep === "object") {',
-					Template.indent([
-						"if(dep[webpackThen]) return dep;",
-						"if(dep.then) {",
-						Template.indent([
-							"var queue = [];",
-							`dep.then(${runtimeTemplate.basicFunction("r", [
-								"obj[webpackExports] = r;",
-								"completeQueue(queue);",
-								"queue = 0;"
-							])}, ${runtimeTemplate.basicFunction("e", [
-								"obj[webpackError] = e;",
-								"completeQueue(queue);",
-								"queue = 0;"
-							])});`,
-							"var obj = {};",
-							`obj[webpackThen] = ${runtimeTemplate.expressionFunction(
-								"queueFunction(queue, fn), dep['catch'](reject)",
-								"fn, reject"
-							)};`,
-							"return obj;"
-						]),
-						"}"
-					]),
-					"}",
-					"var ret = {};",
-					`ret[webpackThen] = ${runtimeTemplate.expressionFunction(
-						"completeFunction(fn)",
-						"fn"
-					)};`,
-					"ret[webpackExports] = dep;",
-					"return ret;"
-				])})`,
-				"deps"
-			)};`,
-			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
-				"var queue = hasAwait && [];",
-				"var exports = module.exports;",
-				"var currentDeps;",
-				"var outerResolve;",
-				"var reject;",
-				"var isEvaluating = true;",
-				"var nested = false;",
-				`var whenAll = ${runtimeTemplate.basicFunction(
-					"deps, onResolve, onReject",
-					[
-						"if (nested) return;",
-						"nested = true;",
-						"onResolve.r += deps.length;",
-						`deps.map(${runtimeTemplate.expressionFunction(
-							"dep[webpackThen](onResolve, onReject)",
-							"dep, i"
-						)});`,
-						"nested = false;"
-					]
-				)};`,
-				`var promise = new Promise(${runtimeTemplate.basicFunction(
-					"resolve, rej",
-					[
-						"reject = rej;",
-						`outerResolve = ${runtimeTemplate.expressionFunction(
-							"resolve(exports), completeQueue(queue), queue = 0"
-						)};`
-					]
-				)});`,
-				"promise[webpackExports] = exports;",
-				`promise[webpackThen] = ${runtimeTemplate.basicFunction(
-					"fn, rejectFn",
-					[
-						"if (isEvaluating) { return completeFunction(fn); }",
-						"if (currentDeps) whenAll(currentDeps, fn, rejectFn);",
-						"queueFunction(queue, fn);",
-						"promise['catch'](rejectFn);"
-					]
-				)};`,
-				"module.exports = promise;",
-				`body(${runtimeTemplate.basicFunction("deps", [
-					"currentDeps = wrapDeps(deps);",
-					"var fn;",
-					`var getResult = ${runtimeTemplate.returningFunction(
-						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
-							"if(d[webpackError]) throw d[webpackError];",
-							"return d[webpackExports];"
-						])})`
-					)}`,
-					`var promise = new Promise(${runtimeTemplate.basicFunction(
-						"resolve, reject",
-						[
-							`fn = ${runtimeTemplate.expressionFunction(
-								"resolve(getResult)"
-							)};`,
-							"fn.r = 0;",
-							"whenAll(currentDeps, fn, reject);"
-						]
-					)});`,
-					"return fn.r ? promise : getResult();"
-				])}, ${runtimeTemplate.expressionFunction(
-					"err && reject(promise[webpackError] = err), outerResolve()",
-					"err"
-				)});`,
-				"isEvaluating = false;"
-			])};`
-		]);
+	parseOptions(library) {
+		/** @type {LibraryName} */
+		let name;
+		/** @type {LibraryCustomUmdObject} */
+		let names;
+		if (typeof library.name === "object" && !Array.isArray(library.name)) {
+			name = library.name.root || library.name.amd || library.name.commonjs;
+			names = library.name;
+		} else {
+			name = library.name;
+			const singleName = Array.isArray(name) ? name[0] : name;
+			names = {
+				commonjs: singleName,
+				root: library.name,
+				amd: singleName
+			};
+		}
+		return {
+			name,
+			names,
+			auxiliaryComment: library.auxiliaryComment,
+			namedDefine: library.umdNamedDefine
+		};
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(
+		source,
+		{ chunkGraph, runtimeTemplate, chunk, moduleGraph },
+		{ options, compilation }
+	) {
+		const modules = chunkGraph
+			.getChunkModules(chunk)
+			.filter(
+				m =>
+					m instanceof ExternalModule &&
+					(m.externalType === "umd" || m.externalType === "umd2")
+			);
+		let externals = /** @type {ExternalModule[]} */ (modules);
+		/** @type {ExternalModule[]} */
+		const optionalExternals = [];
+		/** @type {ExternalModule[]} */
+		let requiredExternals = [];
+		if (this.optionalAmdExternalAsGlobal) {
+			for (const m of externals) {
+				if (m.isOptional(moduleGraph)) {
+					optionalExternals.push(m);
+				} else {
+					requiredExternals.push(m);
+				}
+			}
+			externals = requiredExternals.concat(optionalExternals);
+		} else {
+			requiredExternals = externals;
+		}
+
+		const replaceKeys = str => {
+			return compilation.getPath(str, {
+				chunk
+			});
+		};
+
+		const externalsDepsArray = modules => {
+			return `[${replaceKeys(
+				modules
+					.map(m =>
+						JSON.stringify(
+							typeof m.request === "object" ? m.request.amd : m.request
+						)
+					)
+					.join(", ")
+			)}]`;
+		};
+
+		const externalsRootArray = modules => {
+			return replaceKeys(
+				modules
+					.map(m => {
+						let request = m.request;
+						if (typeof request === "object") request = request.root;
+						return `root${accessorToObjectAccess([].concat(request))}`;
+					})
+					.join(", ")
+			);
+		};
+
+		const externalsRequireArray = type => {
+			return replaceKeys(
+				externals
+					.map(m => {
+						let expr;
+						let request = m.request;
+						if (typeof request === "object") {
+							request = request[type];
+						}
+						if (request === undefined) {
+							throw new Error(
+								"Missing external configuration for type:" + type
+							);
+						}
+						if (Array.isArray(request)) {
+							expr = `require(${JSON.stringify(
+								request[0]
+							)})${accessorToObjectAccess(request.slice(1))}`;
+						} else {
+							expr = `require(${JSON.stringify(request)})`;
+						}
+						if (m.isOptional(moduleGraph)) {
+							expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
+						}
+						return expr;
+					})
+					.join(", ")
+			);
+		};
+
+		const externalsArguments = modules => {
+			return modules
+				.map(
+					m =>
+						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+							`${chunkGraph.getModuleId(m)}`
+						)}__`
+				)
+				.join(", ");
+		};
+
+		const libraryName = library => {
+			return JSON.stringify(replaceKeys([].concat(library).pop()));
+		};
+
+		let amdFactory;
+		if (optionalExternals.length > 0) {
+			const wrapperArguments = externalsArguments(requiredExternals);
+			const factoryArguments =
+				requiredExternals.length > 0
+					? externalsArguments(requiredExternals) +
+					  ", " +
+					  externalsRootArray(optionalExternals)
+					: externalsRootArray(optionalExternals);
+			amdFactory =
+				`function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` +
+				`			return factory(${factoryArguments});\n` +
+				"		}";
+		} else {
+			amdFactory = "factory";
+		}
+
+		const { auxiliaryComment, namedDefine, names } = options;
+
+		const getAuxiliaryComment = type => {
+			if (auxiliaryComment) {
+				if (typeof auxiliaryComment === "string")
+					return "\t//" + auxiliaryComment + "\n";
+				if (auxiliaryComment[type])
+					return "\t//" + auxiliaryComment[type] + "\n";
+			}
+			return "";
+		};
+
+		return new ConcatSource(
+			new OriginalSource(
+				"(function webpackUniversalModuleDefinition(root, factory) {\n" +
+					getAuxiliaryComment("commonjs2") +
+					"	if(typeof exports === 'object' && typeof module === 'object')\n" +
+					"		module.exports = factory(" +
+					externalsRequireArray("commonjs2") +
+					");\n" +
+					getAuxiliaryComment("amd") +
+					"	else if(typeof define === 'function' && define.amd)\n" +
+					(requiredExternals.length > 0
+						? names.amd && namedDefine === true
+							? "		define(" +
+							  libraryName(names.amd) +
+							  ", " +
+							  externalsDepsArray(requiredExternals) +
+							  ", " +
+							  amdFactory +
+							  ");\n"
+							: "		define(" +
+							  externalsDepsArray(requiredExternals) +
+							  ", " +
+							  amdFactory +
+							  ");\n"
+						: names.amd && namedDefine === true
+						? "		define(" +
+						  libraryName(names.amd) +
+						  ", [], " +
+						  amdFactory +
+						  ");\n"
+						: "		define([], " + amdFactory + ");\n") +
+					(names.root || names.commonjs
+						? getAuxiliaryComment("commonjs") +
+						  "	else if(typeof exports === 'object')\n" +
+						  "		exports[" +
+						  libraryName(names.commonjs || names.root) +
+						  "] = factory(" +
+						  externalsRequireArray("commonjs") +
+						  ");\n" +
+						  getAuxiliaryComment("root") +
+						  "	else\n" +
+						  "		" +
+						  replaceKeys(
+								accessorAccess("root", names.root || names.commonjs)
+						  ) +
+						  " = factory(" +
+						  externalsRootArray(externals) +
+						  ");\n"
+						: "	else {\n" +
+						  (externals.length > 0
+								? "		var a = typeof exports === 'object' ? factory(" +
+								  externalsRequireArray("commonjs") +
+								  ") : factory(" +
+								  externalsRootArray(externals) +
+								  ");\n"
+								: "		var a = factory();\n") +
+						  "		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" +
+						  "	}\n") +
+					`})(${
+						runtimeTemplate.outputOptions.globalObject
+					}, function(${externalsArguments(externals)}) {\nreturn `,
+				"webpack/universalModuleDefinition"
+			),
+			source,
+			";\n})"
+		);
 	}
 }
 
-module.exports = AsyncModuleRuntimeModule;
+module.exports = UmdLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 66532:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 32597:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const { getUndoPath } = __webpack_require__(82186);
+const LogType = Object.freeze({
+	error: /** @type {"error"} */ ("error"), // message, c style arguments
+	warn: /** @type {"warn"} */ ("warn"), // message, c style arguments
+	info: /** @type {"info"} */ ("info"), // message, c style arguments
+	log: /** @type {"log"} */ ("log"), // message, c style arguments
+	debug: /** @type {"debug"} */ ("debug"), // message, c style arguments
 
-class AutoPublicPathRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("publicPath", RuntimeModule.STAGE_BASIC);
-	}
+	trace: /** @type {"trace"} */ ("trace"), // no arguments
+
+	group: /** @type {"group"} */ ("group"), // [label]
+	groupCollapsed: /** @type {"groupCollapsed"} */ ("groupCollapsed"), // [label]
+	groupEnd: /** @type {"groupEnd"} */ ("groupEnd"), // [label]
+
+	profile: /** @type {"profile"} */ ("profile"), // [profileName]
+	profileEnd: /** @type {"profileEnd"} */ ("profileEnd"), // [profileName]
+
+	time: /** @type {"time"} */ ("time"), // name, time as [seconds, nanoseconds]
+
+	clear: /** @type {"clear"} */ ("clear"), // no arguments
+	status: /** @type {"status"} */ ("status") // message, arguments
+});
+
+exports.LogType = LogType;
+
+/** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
+
+const LOG_SYMBOL = Symbol("webpack logger raw log method");
+const TIMERS_SYMBOL = Symbol("webpack logger times");
+const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
+class WebpackLogger {
 	/**
-	 * @returns {string} runtime code
+	 * @param {function(LogTypeEnum, any[]=): void} log log function
+	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
 	 */
-	generate() {
-		const { compilation } = this;
-		const { scriptType, importMetaName, path } = compilation.outputOptions;
-		const chunkName = compilation.getPath(
-			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				this.chunk,
-				compilation.outputOptions
-			),
-			{
-				chunk: this.chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const undoPath = getUndoPath(chunkName, path, false);
+	constructor(log, getChildLogger) {
+		this[LOG_SYMBOL] = log;
+		this.getChildLogger = getChildLogger;
+	}
 
-		return Template.asString([
-			"var scriptUrl;",
-			scriptType === "module"
-				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
-				: Template.asString([
-						`if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
-						`var document = ${RuntimeGlobals.global}.document;`,
-						"if (!scriptUrl && document) {",
-						Template.indent([
-							`if (document.currentScript)`,
-							Template.indent(`scriptUrl = document.currentScript.src`),
-							"if (!scriptUrl) {",
-							Template.indent([
-								'var scripts = document.getElementsByTagName("script");',
-								"if(scripts.length) scriptUrl = scripts[scripts.length - 1].src"
-							]),
-							"}"
-						]),
-						"}"
-				  ]),
-			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
-			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
-			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
-			'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
-			!undoPath
-				? `${RuntimeGlobals.publicPath} = scriptUrl;`
-				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(
-						undoPath
-				  )};`
-		]);
+	error(...args) {
+		this[LOG_SYMBOL](LogType.error, args);
 	}
-}
 
-module.exports = AutoPublicPathRuntimeModule;
+	warn(...args) {
+		this[LOG_SYMBOL](LogType.warn, args);
+	}
 
+	info(...args) {
+		this[LOG_SYMBOL](LogType.info, args);
+	}
 
-/***/ }),
+	log(...args) {
+		this[LOG_SYMBOL](LogType.log, args);
+	}
 
-/***/ 84519:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	debug(...args) {
+		this[LOG_SYMBOL](LogType.debug, args);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	assert(assertion, ...args) {
+		if (!assertion) {
+			this[LOG_SYMBOL](LogType.error, args);
+		}
+	}
 
+	trace() {
+		this[LOG_SYMBOL](LogType.trace, ["Trace"]);
+	}
 
+	clear() {
+		this[LOG_SYMBOL](LogType.clear);
+	}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
+	status(...args) {
+		this[LOG_SYMBOL](LogType.status, args);
+	}
 
-class ChunkNameRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} chunkName the chunk's name
-	 */
-	constructor(chunkName) {
-		super("chunkName");
-		this.chunkName = chunkName;
+	group(...args) {
+		this[LOG_SYMBOL](LogType.group, args);
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;
+	groupCollapsed(...args) {
+		this[LOG_SYMBOL](LogType.groupCollapsed, args);
+	}
+
+	groupEnd(...args) {
+		this[LOG_SYMBOL](LogType.groupEnd, args);
+	}
+
+	profile(label) {
+		this[LOG_SYMBOL](LogType.profile, [label]);
+	}
+
+	profileEnd(label) {
+		this[LOG_SYMBOL](LogType.profileEnd, [label]);
+	}
+
+	time(label) {
+		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
+		this[TIMERS_SYMBOL].set(label, process.hrtime());
+	}
+
+	timeLog(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+		}
+		const time = process.hrtime(prev);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
+
+	timeEnd(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+		}
+		const time = process.hrtime(prev);
+		this[TIMERS_SYMBOL].delete(label);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
+
+	timeAggregate(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(
+				`No such label '${label}' for WebpackLogger.timeAggregate()`
+			);
+		}
+		const time = process.hrtime(prev);
+		this[TIMERS_SYMBOL].delete(label);
+		this[TIMERS_AGGREGATES_SYMBOL] =
+			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
+		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+		if (current !== undefined) {
+			if (time[1] + current[1] > 1e9) {
+				time[0] += current[0] + 1;
+				time[1] = time[1] - 1e9 + current[1];
+			} else {
+				time[0] += current[0];
+				time[1] += current[1];
+			}
+		}
+		this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
+	}
+
+	timeAggregateEnd(label) {
+		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
+		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+		if (time === undefined) return;
+		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 }
 
-module.exports = ChunkNameRuntimeModule;
+exports.Logger = WebpackLogger;
 
 
 /***/ }),
 
-/***/ 44793:
+/***/ 54963:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+const { LogType } = __webpack_require__(32597);
 
-class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("compat get default export");
+/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
+/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
+/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
+
+/** @typedef {function(string): boolean} FilterFunction */
+
+/**
+ * @typedef {Object} LoggerConsole
+ * @property {function(): void} clear
+ * @property {function(): void} trace
+ * @property {(...args: any[]) => void} info
+ * @property {(...args: any[]) => void} log
+ * @property {(...args: any[]) => void} warn
+ * @property {(...args: any[]) => void} error
+ * @property {(...args: any[]) => void=} debug
+ * @property {(...args: any[]) => void=} group
+ * @property {(...args: any[]) => void=} groupCollapsed
+ * @property {(...args: any[]) => void=} groupEnd
+ * @property {(...args: any[]) => void=} status
+ * @property {(...args: any[]) => void=} profile
+ * @property {(...args: any[]) => void=} profileEnd
+ * @property {(...args: any[]) => void=} logTime
+ */
+
+/**
+ * @typedef {Object} LoggerOptions
+ * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
+ * @property {FilterTypes|boolean} debug filter for debug logging
+ * @property {LoggerConsole} console the console to log to
+ */
+
+/**
+ * @param {FilterItemTypes} item an input item
+ * @returns {FilterFunction} filter function
+ */
+const filterToFunction = item => {
+	if (typeof item === "string") {
+		const regExp = new RegExp(
+			`[\\\\/]${item.replace(
+				// eslint-disable-next-line no-useless-escape
+				/[-[\]{}()*+?.\\^$|]/g,
+				"\\$&"
+			)}([\\\\/]|$|!|\\?)`
+		);
+		return ident => regExp.test(ident);
+	}
+	if (item && typeof item === "object" && typeof item.test === "function") {
+		return ident => item.test(ident);
+	}
+	if (typeof item === "function") {
+		return item;
+	}
+	if (typeof item === "boolean") {
+		return () => item;
 	}
+};
+
+/**
+ * @enum {number}
+ */
+const LogLevel = {
+	none: 6,
+	false: 6,
+	error: 5,
+	warn: 4,
+	info: 3,
+	log: 2,
+	true: 2,
+	verbose: 1
+};
+
+/**
+ * @param {LoggerOptions} options options object
+ * @returns {function(string, LogTypeEnum, any[]): void} logging function
+ */
+module.exports = ({ level = "info", debug = false, console }) => {
+	const debugFilters =
+		typeof debug === "boolean"
+			? [() => debug]
+			: /** @type {FilterItemTypes[]} */ ([])
+					.concat(debug)
+					.map(filterToFunction);
+	/** @type {number} */
+	const loglevel = LogLevel[`${level}`] || 0;
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {string} name name of the logger
+	 * @param {LogTypeEnum} type type of the log entry
+	 * @param {any[]} args arguments of the log entry
+	 * @returns {void}
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.compatGetDefaultExport;
-		return Template.asString([
-			"// getDefaultExport function for compatibility with non-harmony modules",
-			`${fn} = ${runtimeTemplate.basicFunction("module", [
-				"var getter = module && module.__esModule ?",
-				Template.indent([
-					`${runtimeTemplate.returningFunction("module['default']")} :`,
-					`${runtimeTemplate.returningFunction("module")};`
-				]),
-				`${RuntimeGlobals.definePropertyGetters}(getter, { a: getter });`,
-				"return getter;"
-			])};`
-		]);
-	}
-}
-
-module.exports = CompatGetDefaultExportRuntimeModule;
+	const logger = (name, type, args) => {
+		const labeledArgs = () => {
+			if (Array.isArray(args)) {
+				if (args.length > 0 && typeof args[0] === "string") {
+					return [`[${name}] ${args[0]}`, ...args.slice(1)];
+				} else {
+					return [`[${name}]`, ...args];
+				}
+			} else {
+				return [];
+			}
+		};
+		const debug = debugFilters.some(f => f(name));
+		switch (type) {
+			case LogType.debug:
+				if (!debug) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.debug === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.debug(...labeledArgs());
+				} else {
+					console.log(...labeledArgs());
+				}
+				break;
+			case LogType.log:
+				if (!debug && loglevel > LogLevel.log) return;
+				console.log(...labeledArgs());
+				break;
+			case LogType.info:
+				if (!debug && loglevel > LogLevel.info) return;
+				console.info(...labeledArgs());
+				break;
+			case LogType.warn:
+				if (!debug && loglevel > LogLevel.warn) return;
+				console.warn(...labeledArgs());
+				break;
+			case LogType.error:
+				if (!debug && loglevel > LogLevel.error) return;
+				console.error(...labeledArgs());
+				break;
+			case LogType.trace:
+				if (!debug) return;
+				console.trace();
+				break;
+			case LogType.groupCollapsed:
+				if (!debug && loglevel > LogLevel.log) return;
+				if (!debug && loglevel > LogLevel.verbose) {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					if (typeof console.groupCollapsed === "function") {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						console.groupCollapsed(...labeledArgs());
+					} else {
+						console.log(...labeledArgs());
+					}
+					break;
+				}
+			// falls through
+			case LogType.group:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.group === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.group(...labeledArgs());
+				} else {
+					console.log(...labeledArgs());
+				}
+				break;
+			case LogType.groupEnd:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.groupEnd === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.groupEnd();
+				}
+				break;
+			case LogType.time: {
+				if (!debug && loglevel > LogLevel.log) return;
+				const ms = args[1] * 1000 + args[2] / 1000000;
+				const msg = `[${name}] ${args[0]}: ${ms} ms`;
+				if (typeof console.logTime === "function") {
+					console.logTime(msg);
+				} else {
+					console.log(msg);
+				}
+				break;
+			}
+			case LogType.profile:
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.profile === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.profile(...labeledArgs());
+				}
+				break;
+			case LogType.profileEnd:
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.profileEnd === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.profileEnd(...labeledArgs());
+				}
+				break;
+			case LogType.clear:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.clear === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.clear();
+				}
+				break;
+			case LogType.status:
+				if (!debug && loglevel > LogLevel.info) return;
+				if (typeof console.status === "function") {
+					if (args.length === 0) {
+						console.status();
+					} else {
+						console.status(...labeledArgs());
+					}
+				} else {
+					if (args.length !== 0) {
+						console.info(...labeledArgs());
+					}
+				}
+				break;
+			default:
+				throw new Error(`Unexpected LogType ${type}`);
+		}
+	};
+	return logger;
+};
 
 
 /***/ }),
 
-/***/ 88234:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 62090:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-/** @typedef {import("../MainTemplate")} MainTemplate */
+const arraySum = array => {
+	let sum = 0;
+	for (const item of array) sum += item;
+	return sum;
+};
 
-class CompatRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("compat", RuntimeModule.STAGE_ATTACH);
-		this.fullHash = true;
-	}
+/**
+ * @param {any[]} args items to be truncated
+ * @param {number} maxLength maximum length of args including spaces between
+ * @returns {string[]} truncated args
+ */
+const truncateArgs = (args, maxLength) => {
+	const lengths = args.map(a => `${a}`.length);
+	const availableLength = maxLength - lengths.length + 1;
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, chunk, compilation } = this;
-		const {
-			runtimeTemplate,
-			mainTemplate,
-			moduleTemplates,
-			dependencyTemplates
-		} = compilation;
-		const bootstrap = mainTemplate.hooks.bootstrap.call(
-			"",
-			chunk,
-			compilation.hash || "XXXX",
-			moduleTemplates.javascript,
-			dependencyTemplates
-		);
-		const localVars = mainTemplate.hooks.localVars.call(
-			"",
-			chunk,
-			compilation.hash || "XXXX"
-		);
-		const requireExtensions = mainTemplate.hooks.requireExtensions.call(
-			"",
-			chunk,
-			compilation.hash || "XXXX"
-		);
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
-		let requireEnsure = "";
-		if (runtimeRequirements.has(RuntimeGlobals.ensureChunk)) {
-			const requireEnsureHandler = mainTemplate.hooks.requireEnsure.call(
-				"",
-				chunk,
-				compilation.hash || "XXXX",
-				"chunkId"
-			);
-			if (requireEnsureHandler) {
-				requireEnsure = `${
-					RuntimeGlobals.ensureChunkHandlers
-				}.compat = ${runtimeTemplate.basicFunction(
-					"chunkId, promises",
-					requireEnsureHandler
-				)};`;
-			}
+	if (availableLength > 0 && args.length === 1) {
+		if (availableLength >= args[0].length) {
+			return args;
+		} else if (availableLength > 3) {
+			return ["..." + args[0].slice(-availableLength + 3)];
+		} else {
+			return [args[0].slice(-availableLength)];
 		}
-		return [bootstrap, localVars, requireEnsure, requireExtensions]
-			.filter(Boolean)
-			.join("\n");
 	}
 
-	/**
-	 * @returns {boolean} true, if the runtime module should get it's own scope
-	 */
-	shouldIsolate() {
-		// We avoid isolating this to have better backward-compat
-		return false;
+	// Check if there is space for at least 4 chars per arg
+	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
+		// remove args
+		if (args.length > 1)
+			return truncateArgs(args.slice(0, args.length - 1), maxLength);
+		return [];
 	}
-}
-
-module.exports = CompatRuntimeModule;
-
-
-/***/ }),
-
-/***/ 94669:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
 
+	let currentLength = arraySum(lengths);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+	// Check if all fits into maxLength
+	if (currentLength <= availableLength) return args;
 
-class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("create fake namespace object");
+	// Try to remove chars from the longest items until it fits
+	while (currentLength > availableLength) {
+		const maxLength = Math.max(...lengths);
+		const shorterItems = lengths.filter(l => l !== maxLength);
+		const nextToMaxLength =
+			shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
+		const maxReduce = maxLength - nextToMaxLength;
+		let maxItems = lengths.length - shorterItems.length;
+		let overrun = currentLength - availableLength;
+		for (let i = 0; i < lengths.length; i++) {
+			if (lengths[i] === maxLength) {
+				const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
+				lengths[i] -= reduce;
+				currentLength -= reduce;
+				overrun -= reduce;
+				maxItems--;
+			}
+		}
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.createFakeNamespaceObject;
-		return Template.asString([
-			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
-				"Object.getPrototypeOf(obj)",
-				"obj"
-			)} : ${runtimeTemplate.returningFunction("obj.__proto__", "obj")};`,
-			"var leafPrototypes;",
-			"// create a fake namespace object",
-			"// mode & 1: value is a module id, require it",
-			"// mode & 2: merge all properties of value into the ns",
-			"// mode & 4: return value when already ns object",
-			"// mode & 16: return value when it's Promise-like",
-			"// mode & 8|1: behave like require",
-			// Note: must be a function (not arrow), because this is used in body!
-			`${fn} = function(value, mode) {`,
-			Template.indent([
-				`if(mode & 1) value = this(value);`,
-				`if(mode & 8) return value;`,
-				"if(typeof value === 'object' && value) {",
-				Template.indent([
-					"if((mode & 4) && value.__esModule) return value;",
-					"if((mode & 16) && typeof value.then === 'function') return value;"
-				]),
-				"}",
-				"var ns = Object.create(null);",
-				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
-				"var def = {};",
-				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
-				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
-				Template.indent([
-					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
-						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,
-						"key"
-					)});`
-				]),
-				"}",
-				`def['default'] = ${runtimeTemplate.returningFunction("value", "")};`,
-				`${RuntimeGlobals.definePropertyGetters}(ns, def);`,
-				"return ns;"
-			]),
-			"};"
-		]);
-	}
-}
+	// Return args reduced to length in lengths
+	return args.map((a, i) => {
+		const str = `${a}`;
+		const length = lengths[i];
+		if (str.length === length) {
+			return str;
+		} else if (length > 5) {
+			return "..." + str.slice(-length + 3);
+		} else if (length > 0) {
+			return str.slice(-length);
+		} else {
+			return "";
+		}
+	});
+};
 
-module.exports = CreateFakeNamespaceObjectRuntimeModule;
+module.exports = truncateArgs;
 
 
 /***/ }),
 
-/***/ 2759:
+/***/ 1313:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
 const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+const StartupChunkDependenciesPlugin = __webpack_require__(22339);
 
-class CreateScriptRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("trusted types script");
+/** @typedef {import("../Compiler")} Compiler */
+
+class CommonJsChunkLoadingPlugin {
+	constructor(options) {
+		options = options || {};
+		this._asyncChunkLoading = options.asyncChunkLoading;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const { trustedTypes } = outputOptions;
-		const fn = RuntimeGlobals.createScript;
+	apply(compiler) {
+		const ChunkLoadingRuntimeModule = this._asyncChunkLoading
+			? __webpack_require__(73369)
+			: __webpack_require__(94172);
+		const chunkLoadingValue = this._asyncChunkLoading
+			? "async-node"
+			: "require";
+		new StartupChunkDependenciesPlugin({
+			chunkLoading: chunkLoadingValue,
+			asyncChunkLoading: this._asyncChunkLoading
+		}).apply(compiler);
+		compiler.hooks.thisCompilation.tap(
+			"CommonJsChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === chunkLoadingValue;
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkLoadingRuntimeModule(set)
+					);
+				};
 
-		return Template.asString(
-			`${fn} = ${runtimeTemplate.returningFunction(
-				trustedTypes
-					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)`
-					: "script",
-				"script"
-			)};`
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.hmrModuleData);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getUpdateManifestFilename);
+					});
+			}
 		);
 	}
 }
 
-module.exports = CreateScriptRuntimeModule;
+module.exports = CommonJsChunkLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 21213:
+/***/ 7553:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+const CachedInputFileSystem = __webpack_require__(89429);
+const fs = __webpack_require__(90552);
+const createConsoleLogger = __webpack_require__(54963);
+const NodeWatchFileSystem = __webpack_require__(98810);
+const nodeConsole = __webpack_require__(91786);
 
-class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("trusted types script url");
-	}
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
+/** @typedef {import("../Compiler")} Compiler */
 
+class NodeEnvironmentPlugin {
 	/**
-	 * @returns {string} runtime code
+	 * @param {Object} options options
+	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const { trustedTypes } = outputOptions;
-		const fn = RuntimeGlobals.createScriptUrl;
+	constructor(options) {
+		this.options = options;
+	}
 
-		return Template.asString(
-			`${fn} = ${runtimeTemplate.returningFunction(
-				trustedTypes
-					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScriptURL(url)`
-					: "url",
-				"url"
-			)};`
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { infrastructureLogging } = this.options;
+		compiler.infrastructureLogger = createConsoleLogger({
+			level: infrastructureLogging.level || "info",
+			debug: infrastructureLogging.debug || false,
+			console:
+				infrastructureLogging.console ||
+				nodeConsole({
+					colors: infrastructureLogging.colors,
+					appendOnly: infrastructureLogging.appendOnly,
+					stream: infrastructureLogging.stream
+				})
+		});
+		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
+		const inputFileSystem = compiler.inputFileSystem;
+		compiler.outputFileSystem = fs;
+		compiler.intermediateFileSystem = fs;
+		compiler.watchFileSystem = new NodeWatchFileSystem(
+			compiler.inputFileSystem
 		);
+		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
+			if (compiler.inputFileSystem === inputFileSystem) {
+				compiler.fsStartTime = Date.now();
+				inputFileSystem.purge();
+			}
+		});
 	}
 }
 
-module.exports = CreateScriptUrlRuntimeModule;
+module.exports = NodeEnvironmentPlugin;
 
 
 /***/ }),
 
-/***/ 75481:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 7103:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("define property getters");
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
+class NodeSourcePlugin {
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.definePropertyGetters;
-		return Template.asString([
-			"// define getter functions for harmony exports",
-			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
-				`for(var key in definition) {`,
-				Template.indent([
-					`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
-					Template.indent([
-						"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
-					]),
-					"}"
-				]),
-				"}"
-			])};`
-		]);
-	}
+	apply(compiler) {}
 }
 
-module.exports = DefinePropertyGettersRuntimeModule;
+module.exports = NodeSourcePlugin;
 
 
 /***/ }),
 
-/***/ 71519:
+/***/ 17916:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const ExternalsPlugin = __webpack_require__(6652);
 
-class EnsureChunkRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("ensure chunk");
-		this.runtimeRequirements = runtimeRequirements;
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		// Check if there are non initial chunks which need to be imported using require-ensure
-		if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
-			const handlers = RuntimeGlobals.ensureChunkHandlers;
-			return Template.asString([
-				`${handlers} = {};`,
-				"// This file contains only the entry chunk.",
-				"// The chunk loading function for additional chunks",
-				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
-					"chunkId",
-					[
-						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
-							"promises, key",
-							[`${handlers}[key](chunkId, promises);`, "return promises;"]
-						)}, []));`
-					]
-				)};`
-			]);
-		} else {
-			// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
-			// function. This can happen with multiple entrypoints.
-			return Template.asString([
-				"// The chunk loading function for additional chunks",
-				"// Since all referenced chunks are already included",
-				"// in this file, this function is empty here.",
-				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
-					"Promise.resolve()"
-				)};`
-			]);
-		}
+const builtins = [
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"dns/promises",
+	"domain",
+	"events",
+	"fs",
+	"fs/promises",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"path/posix",
+	"path/win32",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"sys",
+	"timers",
+	"timers/promises",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib",
+	/^node:/,
+
+	// cspell:word pnpapi
+	// Yarn PnP adds pnpapi as "builtin"
+	"pnpapi"
+];
+
+class NodeTargetPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
 	}
 }
 
-module.exports = EnsureChunkRuntimeModule;
+module.exports = NodeTargetPlugin;
 
 
 /***/ }),
 
-/***/ 34277:
+/***/ 61052:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const { first } = __webpack_require__(93347);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
+const CommonJsChunkFormatPlugin = __webpack_require__(84508);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
 
-/** @typedef {function(PathData, AssetInfo=): string} FilenameFunction */
+/** @typedef {import("../Compiler")} Compiler */
 
-class GetChunkFilenameRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} contentType the contentType to use the content hash for
-	 * @param {string} name kind of filename
-	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
-	 * @param {boolean} allChunks when false, only async chunks are included
-	 */
-	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
-		super(`get ${name} chunk filename`);
-		this.contentType = contentType;
-		this.global = global;
-		this.getFilenameForChunk = getFilenameForChunk;
-		this.allChunks = allChunks;
-		this.dependentHash = true;
+class NodeTemplatePlugin {
+	constructor(options) {
+		this._options = options || {};
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const {
-			global,
-			chunk,
-			chunkGraph,
-			contentType,
-			getFilenameForChunk,
-			allChunks,
-			compilation
-		} = this;
-		const { runtimeTemplate } = compilation;
-
-		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
-		const chunkFilenames = new Map();
-		let maxChunks = 0;
-		/** @type {string} */
-		let dynamicFilename;
-
-		/**
-		 * @param {Chunk} c the chunk
-		 * @returns {void}
-		 */
-		const addChunk = c => {
-			const chunkFilename = getFilenameForChunk(c);
-			if (chunkFilename) {
-				let set = chunkFilenames.get(chunkFilename);
-				if (set === undefined) {
-					chunkFilenames.set(chunkFilename, (set = new Set()));
-				}
-				set.add(c);
-				if (typeof chunkFilename === "string") {
-					if (set.size < maxChunks) return;
-					if (set.size === maxChunks) {
-						if (chunkFilename.length < dynamicFilename.length) return;
-						if (chunkFilename.length === dynamicFilename.length) {
-							if (chunkFilename < dynamicFilename) return;
-						}
-					}
-					maxChunks = set.size;
-					dynamicFilename = chunkFilename;
-				}
-			}
-		};
-
-		/** @type {string[]} */
-		const includedChunksMessages = [];
-		if (allChunks) {
-			includedChunksMessages.push("all chunks");
-			for (const c of chunk.getAllReferencedChunks()) {
-				addChunk(c);
-			}
-		} else {
-			includedChunksMessages.push("async chunks");
-			for (const c of chunk.getAllAsyncChunks()) {
-				addChunk(c);
-			}
-			const includeEntries = chunkGraph
-				.getTreeRuntimeRequirements(chunk)
-				.has(RuntimeGlobals.ensureChunkIncludeEntries);
-			if (includeEntries) {
-				includedChunksMessages.push("sibling chunks for the entrypoint");
-				for (const c of chunkGraph.getChunkEntryDependentChunksIterable(
-					chunk
-				)) {
-					addChunk(c);
-				}
-			}
-		}
-		for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {
-			addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
-		}
-
-		/** @type {Map<string, Set<string | number>>} */
-		const staticUrls = new Map();
-		/** @type {Set<Chunk>} */
-		const dynamicUrlChunks = new Set();
-
-		/**
-		 * @param {Chunk} c the chunk
-		 * @param {string | FilenameFunction} chunkFilename the filename template for the chunk
-		 * @returns {void}
-		 */
-		const addStaticUrl = (c, chunkFilename) => {
-			/**
-			 * @param {string | number} value a value
-			 * @returns {string} string to put in quotes
-			 */
-			const unquotedStringify = value => {
-				const str = `${value}`;
-				if (str.length >= 5 && str === `${c.id}`) {
-					// This is shorter and generates the same result
-					return '" + chunkId + "';
-				}
-				const s = JSON.stringify(str);
-				return s.slice(1, s.length - 1);
-			};
-			const unquotedStringifyWithLength = value => length =>
-				unquotedStringify(`${value}`.slice(0, length));
-			const chunkFilenameValue =
-				typeof chunkFilename === "function"
-					? JSON.stringify(
-							chunkFilename({
-								chunk: c,
-								contentHashType: contentType
-							})
-					  )
-					: JSON.stringify(chunkFilename);
-			const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				chunk: {
-					id: unquotedStringify(c.id),
-					hash: unquotedStringify(c.renderedHash),
-					hashWithLength: unquotedStringifyWithLength(c.renderedHash),
-					name: unquotedStringify(c.name || c.id),
-					contentHash: {
-						[contentType]: unquotedStringify(c.contentHash[contentType])
-					},
-					contentHashWithLength: {
-						[contentType]: unquotedStringifyWithLength(
-							c.contentHash[contentType]
-						)
-					}
-				},
-				contentHashType: contentType
-			});
-			let set = staticUrls.get(staticChunkFilename);
-			if (set === undefined) {
-				staticUrls.set(staticChunkFilename, (set = new Set()));
-			}
-			set.add(c.id);
-		};
-
-		for (const [filename, chunks] of chunkFilenames) {
-			if (filename !== dynamicFilename) {
-				for (const c of chunks) addStaticUrl(c, filename);
-			} else {
-				for (const c of chunks) dynamicUrlChunks.add(c);
-			}
-		}
-
-		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {string} code with static mapping of results of fn
-		 */
-		const createMap = fn => {
-			const obj = {};
-			let useId = false;
-			let lastKey;
-			let entries = 0;
-			for (const c of dynamicUrlChunks) {
-				const value = fn(c);
-				if (value === c.id) {
-					useId = true;
-				} else {
-					obj[c.id] = value;
-					lastKey = c.id;
-					entries++;
-				}
-			}
-			if (entries === 0) return "chunkId";
-			if (entries === 1) {
-				return useId
-					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
-							obj[lastKey]
-					  )} : chunkId)`
-					: JSON.stringify(obj[lastKey]);
-			}
-			return useId
-				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
-				: `${JSON.stringify(obj)}[chunkId]`;
-		};
-
-		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {string} code with static mapping of results of fn for including in quoted string
-		 */
-		const mapExpr = fn => {
-			return `" + ${createMap(fn)} + "`;
-		};
-
-		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
-		 */
-		const mapExprWithLength = fn => length => {
-			return `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
-		};
-
-		const url =
-			dynamicFilename &&
-			compilation.getPath(JSON.stringify(dynamicFilename), {
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				chunk: {
-					id: `" + chunkId + "`,
-					hash: mapExpr(c => c.renderedHash),
-					hashWithLength: mapExprWithLength(c => c.renderedHash),
-					name: mapExpr(c => c.name || c.id),
-					contentHash: {
-						[contentType]: mapExpr(c => c.contentHash[contentType])
-					},
-					contentHashWithLength: {
-						[contentType]: mapExprWithLength(c => c.contentHash[contentType])
-					}
-				},
-				contentHashType: contentType
-			});
-
-		return Template.asString([
-			`// This function allow to reference ${includedChunksMessages.join(
-				" and "
-			)}`,
-			`${global} = ${runtimeTemplate.basicFunction(
-				"chunkId",
-
-				staticUrls.size > 0
-					? [
-							"// return url for filenames not based on template",
-							// it minimizes to `x===1?"...":x===2?"...":"..."`
-							Template.asString(
-								Array.from(staticUrls, ([url, ids]) => {
-									const condition =
-										ids.size === 1
-											? `chunkId === ${JSON.stringify(first(ids))}`
-											: `{${Array.from(
-													ids,
-													id => `${JSON.stringify(id)}:1`
-											  ).join(",")}}[chunkId]`;
-									return `if (${condition}) return ${url};`;
-								})
-							),
-							"// return url for filenames based on template",
-							`return ${url};`
-					  ]
-					: ["// return url for filenames based on template", `return ${url};`]
-			)};`
-		]);
+	apply(compiler) {
+		const chunkLoading = this._options.asyncChunkLoading
+			? "async-node"
+			: "require";
+		compiler.options.output.chunkLoading = chunkLoading;
+		new CommonJsChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin(chunkLoading).apply(compiler);
 	}
 }
 
-module.exports = GetChunkFilenameRuntimeModule;
+module.exports = NodeTemplatePlugin;
 
 
 /***/ }),
 
-/***/ 88732:
+/***/ 98810:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
+const util = __webpack_require__(73837);
+const Watchpack = __webpack_require__(36871);
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
+/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
+/** @typedef {import("../util/fs").Watcher} Watcher */
 
-class GetFullHashRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("getFullHash");
-		this.fullHash = true;
+class NodeWatchFileSystem {
+	constructor(inputFileSystem) {
+		this.inputFileSystem = inputFileSystem;
+		this.watcherOptions = {
+			aggregateTimeout: 0
+		};
+		this.watcher = new Watchpack(this.watcherOptions);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {Iterable<string>} files watched files
+	 * @param {Iterable<string>} directories watched directories
+	 * @param {Iterable<string>} missing watched exitance entries
+	 * @param {number} startTime timestamp of start time
+	 * @param {WatchOptions} options options object
+	 * @param {function(Error=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
+	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
+	 * @returns {Watcher} a watcher
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(
-			JSON.stringify(this.compilation.hash || "XXXX")
-		)}`;
+	watch(
+		files,
+		directories,
+		missing,
+		startTime,
+		options,
+		callback,
+		callbackUndelayed
+	) {
+		if (!files || typeof files[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'files'");
+		}
+		if (!directories || typeof directories[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'directories'");
+		}
+		if (!missing || typeof missing[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'missing'");
+		}
+		if (typeof callback !== "function") {
+			throw new Error("Invalid arguments: 'callback'");
+		}
+		if (typeof startTime !== "number" && startTime) {
+			throw new Error("Invalid arguments: 'startTime'");
+		}
+		if (typeof options !== "object") {
+			throw new Error("Invalid arguments: 'options'");
+		}
+		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
+			throw new Error("Invalid arguments: 'callbackUndelayed'");
+		}
+		const oldWatcher = this.watcher;
+		this.watcher = new Watchpack(options);
+
+		if (callbackUndelayed) {
+			this.watcher.once("change", callbackUndelayed);
+		}
+
+		const fetchTimeInfo = () => {
+			const fileTimeInfoEntries = new Map();
+			const contextTimeInfoEntries = new Map();
+			if (this.watcher) {
+				this.watcher.collectTimeInfoEntries(
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				);
+			}
+			return { fileTimeInfoEntries, contextTimeInfoEntries };
+		};
+		this.watcher.once("aggregated", (changes, removals) => {
+			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
+			this.watcher.pause();
+
+			if (this.inputFileSystem && this.inputFileSystem.purge) {
+				const fs = this.inputFileSystem;
+				for (const item of changes) {
+					fs.purge(item);
+				}
+				for (const item of removals) {
+					fs.purge(item);
+				}
+			}
+			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+			callback(
+				null,
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changes,
+				removals
+			);
+		});
+
+		this.watcher.watch({ files, directories, missing, startTime });
+
+		if (oldWatcher) {
+			oldWatcher.close();
+		}
+		return {
+			close: () => {
+				if (this.watcher) {
+					this.watcher.close();
+					this.watcher = null;
+				}
+			},
+			pause: () => {
+				if (this.watcher) {
+					this.watcher.pause();
+				}
+			},
+			getAggregatedRemovals: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedRemovals;
+					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+						const fs = this.inputFileSystem;
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
+			),
+			getAggregatedChanges: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedChanges;
+					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+						const fs = this.inputFileSystem;
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
+			),
+			getFileTimeInfoEntries: util.deprecate(
+				() => {
+					return fetchTimeInfo().fileTimeInfoEntries;
+				},
+				"Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
+			),
+			getContextTimeInfoEntries: util.deprecate(
+				() => {
+					return fetchTimeInfo().contextTimeInfoEntries;
+				},
+				"Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"
+			),
+			getInfo: () => {
+				const removals = this.watcher && this.watcher.aggregatedRemovals;
+				const changes = this.watcher && this.watcher.aggregatedChanges;
+				if (this.inputFileSystem && this.inputFileSystem.purge) {
+					const fs = this.inputFileSystem;
+					if (removals) {
+						for (const item of removals) {
+							fs.purge(item);
+						}
+					}
+					if (changes) {
+						for (const item of changes) {
+							fs.purge(item);
+						}
+					}
+				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				return {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				};
+			}
+		};
 	}
 }
 
-module.exports = GetFullHashRuntimeModule;
+module.exports = NodeWatchFileSystem;
 
 
 /***/ }),
 
-/***/ 10029:
+/***/ 73369:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -109410,5011 +105753,6411 @@ module.exports = GetFullHashRuntimeModule;
 
 const RuntimeGlobals = __webpack_require__(16475);
 const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-
-/** @typedef {import("../Compilation")} Compilation */
+const Template = __webpack_require__(39722);
+const {
+	chunkHasJs,
+	getChunkFilenameTemplate
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
 
-class GetMainFilenameRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} name readable name
-	 * @param {string} global global object binding
-	 * @param {string} filename main file name
-	 */
-	constructor(name, global, filename) {
-		super(`get ${name} filename`);
-		this.global = global;
-		this.filename = filename;
+class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
 	 * @returns {string} runtime code
 	 */
 	generate() {
-		const { global, filename, compilation, chunk } = this;
-		const { runtimeTemplate } = compilation;
-		const url = compilation.getPath(JSON.stringify(filename), {
-			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-			hashWithLength: length =>
-				`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-			chunk,
-			runtime: chunk.runtime
-		});
+		const { chunkGraph, chunk } = this;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this.runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
+		const withOnChunkLoad = this.runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			false
+		);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
+			: undefined;
+
 		return Template.asString([
-			`${global} = ${runtimeTemplate.returningFunction(url)};`
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
+							rootOutputDir
+								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
+								: "__filename"
+						});`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "0" means "already loaded", Promise means loading',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.readFileVm = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded",
+			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
+						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
+						"for(var moduleId in moreModules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+							Template.indent([
+								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+							]),
+							"}"
+						]),
+						"}",
+						`if(runtime) runtime(__webpack_require__);`,
+						"for(var i = 0; i < chunkIds.length; i++) {",
+						Template.indent([
+							"if(installedChunks[chunkIds[i]]) {",
+							Template.indent(["installedChunks[chunkIds[i]][0]();"]),
+							"}",
+							"installedChunks[chunkIds[i]] = 0;"
+						]),
+						"}",
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])};`
+				: "// no chunk install function needed",
+			"",
+			withLoading
+				? Template.asString([
+						"// ReadFile + VM.run chunk loading for javascript",
+						`${fn}.readFileVm = function(chunkId, promises) {`,
+						hasJsMatcher !== false
+							? Template.indent([
+									"",
+									"var installedChunkData = installedChunks[chunkId];",
+									'if(installedChunkData !== 0) { // 0 means "already installed".',
+									Template.indent([
+										'// array of [resolve, reject, promise] means "currently loading"',
+										"if(installedChunkData) {",
+										Template.indent(["promises.push(installedChunkData[2]);"]),
+										"} else {",
+										Template.indent([
+											hasJsMatcher === true
+												? "if(true) { // all chunks have JS"
+												: `if(${hasJsMatcher("chunkId")}) {`,
+											Template.indent([
+												"// load the chunk and return promise to it",
+												"var promise = new Promise(function(resolve, reject) {",
+												Template.indent([
+													"installedChunkData = installedChunks[chunkId] = [resolve, reject];",
+													`var filename = require('path').join(__dirname, ${JSON.stringify(
+														rootOutputDir
+													)} + ${
+														RuntimeGlobals.getChunkScriptFilename
+													}(chunkId));`,
+													"require('fs').readFile(filename, 'utf-8', function(err, content) {",
+													Template.indent([
+														"if(err) return reject(err);",
+														"var chunk = {};",
+														"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+															"(chunk, require, require('path').dirname(filename), filename);",
+														"installChunk(chunk);"
+													]),
+													"});"
+												]),
+												"});",
+												"promises.push(installedChunkData[2] = promise);"
+											]),
+											"} else installedChunks[chunkId] = 0;"
+										]),
+										"}"
+									]),
+									"}"
+							  ])
+							: Template.indent(["installedChunks[chunkId] = 0;"]),
+						"};"
+				  ])
+				: "// no chunk loading",
+			"",
+			withExternalInstallChunk
+				? Template.asString([
+						"module.exports = __webpack_require__;",
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							"return new Promise(function(resolve, reject) {",
+							Template.indent([
+								`var filename = require('path').join(__dirname, ${JSON.stringify(
+									rootOutputDir
+								)} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId));`,
+								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
+								Template.indent([
+									"if(err) return reject(err);",
+									"var update = {};",
+									"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+										"(update, require, require('path').dirname(filename), filename);",
+									"var updatedModules = update.modules;",
+									"var runtime = update.runtime;",
+									"for(var moduleId in updatedModules) {",
+									Template.indent([
+										`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
+										Template.indent([
+											`currentUpdate[moduleId] = updatedModules[moduleId];`,
+											"if(updatedModulesList) updatedModulesList.push(moduleId);"
+										]),
+										"}"
+									]),
+									"}",
+									"if(runtime) currentUpdateRuntime.push(runtime);",
+									"resolve();"
+								]),
+								"});"
+							]),
+							"});"
+						]),
+						"}",
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "readFileVm")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
+						Template.indent([
+							"return new Promise(function(resolve, reject) {",
+							Template.indent([
+								`var filename = require('path').join(__dirname, ${JSON.stringify(
+									rootOutputDir
+								)} + ${RuntimeGlobals.getUpdateManifestFilename}());`,
+								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
+								Template.indent([
+									"if(err) {",
+									Template.indent([
+										'if(err.code === "ENOENT") return resolve();',
+										"return reject(err);"
+									]),
+									"}",
+									"try { resolve(JSON.parse(content)); }",
+									"catch(e) { reject(e); }"
+								]),
+								"});"
+							]),
+							"});"
+						]),
+						"}"
+				  ])
+				: "// no HMR manifest"
 		]);
 	}
 }
 
-module.exports = GetMainFilenameRuntimeModule;
+module.exports = ReadFileChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 38713:
+/***/ 73163:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
 const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+const Template = __webpack_require__(39722);
+const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
 
-class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
-	/**
-	 * @param {Set<string>} runtimeRequirements runtime requirements
-	 */
-	constructor(runtimeRequirements) {
-		super("trusted types policy");
-		this.runtimeRequirements = runtimeRequirements;
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
+class ReadFileCompileAsyncWasmPlugin {
+	constructor({ type = "async-node", import: useImport = false } = {}) {
+		this._type = type;
+		this._import = useImport;
+	}
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const { trustedTypes } = outputOptions;
-		const fn = RuntimeGlobals.getTrustedTypesPolicy;
-
-		return Template.asString([
-			"var policy;",
-			`${fn} = ${runtimeTemplate.basicFunction("", [
-				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
-				"if (policy === undefined) {",
-				Template.indent([
-					"policy = {",
-					Template.indent(
-						[
-							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
-								? [
-										`createScript: ${runtimeTemplate.returningFunction(
-											"script",
-											"script"
-										)}`
-								  ]
-								: []),
-							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
-								? [
-										`createScriptURL: ${runtimeTemplate.returningFunction(
-											"url",
-											"url"
-										)}`
-								  ]
-								: [])
-						].join(",\n")
-					),
-					"};",
-					...(trustedTypes
-						? [
-								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ReadFileCompileAsyncWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === this._type;
+				};
+				const generateLoadBinaryCode = this._import
+					? path =>
+							Template.asString([
+								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 								Template.indent([
-									`policy = trustedTypes.createPolicy(${JSON.stringify(
-										trustedTypes.policyName
-									)}, policy);`
+									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
+									Template.indent([
+										"if (err) return reject(err);",
+										"",
+										"// Fake fetch response",
+										"resolve({",
+										Template.indent(["arrayBuffer() { return buffer; }"]),
+										"});"
+									]),
+									"});"
 								]),
-								"}"
-						  ]
-						: [])
-				]),
-				"}",
-				"return policy;"
-			])};`
-		]);
+								"}))"
+							])
+					: path =>
+							Template.asString([
+								"new Promise(function (resolve, reject) {",
+								Template.indent([
+									"try {",
+									Template.indent([
+										"var { readFile } = require('fs');",
+										"var { join } = require('path');",
+										"",
+										`readFile(join(__dirname, ${path}), function(err, buffer){`,
+										Template.indent([
+											"if (err) return reject(err);",
+											"",
+											"// Fake fetch response",
+											"resolve({",
+											Template.indent(["arrayBuffer() { return buffer; }"]),
+											"});"
+										]),
+										"});"
+									]),
+									"} catch (err) { reject(err); }"
+								]),
+								"})"
+							]);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.instantiateWasm)
+					.tap("ReadFileCompileAsyncWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/async"
+							)
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.publicPath);
+						compilation.addRuntimeModule(
+							chunk,
+							new AsyncWasmLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: false
+							})
+						);
+					});
+			}
+		);
 	}
 }
 
-module.exports = GetTrustedTypesPolicyRuntimeModule;
+module.exports = ReadFileCompileAsyncWasmPlugin;
 
 
 /***/ }),
 
-/***/ 23255:
+/***/ 98939:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
 const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const Template = __webpack_require__(39722);
+const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
 
-class GlobalRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("global");
+/** @typedef {import("../Compiler")} Compiler */
+
+// TODO webpack 6 remove
+
+class ReadFileCompileWasmPlugin {
+	constructor(options) {
+		this.options = options || {};
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.global} = (function() {`,
-			Template.indent([
-				"if (typeof globalThis === 'object') return globalThis;",
-				"try {",
-				Template.indent(
-					// This works in non-strict mode
-					// or
-					// This works if eval is allowed (see CSP)
-					"return this || new Function('return this')();"
-				),
-				"} catch (e) {",
-				Template.indent(
-					// This works if the window reference is available
-					"if (typeof window === 'object') return window;"
-				),
-				"}"
-				// It can still be `undefined`, but nothing to do about it...
-				// We return `undefined`, instead of nothing here, so it's
-				// easier to handle this case:
-				//   if (!global) { … }
-			]),
-			"})();"
-		]);
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ReadFileCompileWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === "async-node";
+				};
+				const generateLoadBinaryCode = path =>
+					Template.asString([
+						"new Promise(function (resolve, reject) {",
+						Template.indent([
+							"var { readFile } = require('fs');",
+							"var { join } = require('path');",
+							"",
+							"try {",
+							Template.indent([
+								`readFile(join(__dirname, ${path}), function(err, buffer){`,
+								Template.indent([
+									"if (err) return reject(err);",
+									"",
+									"// Fake fetch response",
+									"resolve({",
+									Template.indent(["arrayBuffer() { return buffer; }"]),
+									"});"
+								]),
+								"});"
+							]),
+							"} catch (err) { reject(err); }"
+						]),
+						"})"
+					]);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ReadFileCompileWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/sync"
+							)
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.moduleCache);
+						compilation.addRuntimeModule(
+							chunk,
+							new WasmChunkLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: false,
+								mangleImports: this.options.mangleImports,
+								runtimeRequirements: set
+							})
+						);
+					});
+			}
+		);
 	}
 }
 
-module.exports = GlobalRuntimeModule;
+module.exports = ReadFileCompileWasmPlugin;
 
 
 /***/ }),
 
-/***/ 8011:
+/***/ 94172:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
 */
 
 
 
 const RuntimeGlobals = __webpack_require__(16475);
 const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const Template = __webpack_require__(39722);
+const {
+	chunkHasJs,
+	getChunkFilenameTemplate
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
 
-class HasOwnPropertyRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("hasOwnProperty shorthand");
+class RequireChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("require chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
 	 * @returns {string} runtime code
 	 */
 	generate() {
+		const { chunkGraph, chunk } = this;
 		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this.runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
+		const withOnChunkLoad = this.runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		return Template.asString([
-			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(
-				"Object.prototype.hasOwnProperty.call(obj, prop)",
-				"obj, prop"
-			)}`
-		]);
-	}
-}
-
-module.exports = HasOwnPropertyRuntimeModule;
-
-
-/***/ }),
-
-/***/ 82444:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			true
+		);
 
-const RuntimeModule = __webpack_require__(16963);
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_require`
+			: undefined;
 
-class HelperRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} name a readable name
-	 */
-	constructor(name) {
-		super(name);
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
+							rootOutputDir !== "./"
+								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
+								: "__filename"
+						});`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "1" means "loaded", otherwise not loaded yet',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.require = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId]",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded",
+			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
+						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
+						"for(var moduleId in moreModules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+							Template.indent([
+								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+							]),
+							"}"
+						]),
+						"}",
+						`if(runtime) runtime(__webpack_require__);`,
+						"for(var i = 0; i < chunkIds.length; i++)",
+						Template.indent("installedChunks[chunkIds[i]] = 1;"),
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])};`
+				: "// no chunk install function needed",
+			"",
+			withLoading
+				? Template.asString([
+						"// require() chunk loading for javascript",
+						`${fn}.require = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? [
+										'// "1" is the signal for "already loaded"',
+										"if(!installedChunks[chunkId]) {",
+										Template.indent([
+											hasJsMatcher === true
+												? "if(true) { // all chunks have JS"
+												: `if(${hasJsMatcher("chunkId")}) {`,
+											Template.indent([
+												`installChunk(require(${JSON.stringify(
+													rootOutputDir
+												)} + ${
+													RuntimeGlobals.getChunkScriptFilename
+												}(chunkId)));`
+											]),
+											"} else installedChunks[chunkId] = 1;",
+											""
+										]),
+										"}"
+								  ]
+								: "installedChunks[chunkId] = 1;"
+						)};`
+				  ])
+				: "// no chunk loading",
+			"",
+			withExternalInstallChunk
+				? Template.asString([
+						"module.exports = __webpack_require__;",
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							`var update = require(${JSON.stringify(rootOutputDir)} + ${
+								RuntimeGlobals.getChunkUpdateScriptFilename
+							}(chunkId));`,
+							"var updatedModules = update.modules;",
+							"var runtime = update.runtime;",
+							"for(var moduleId in updatedModules) {",
+							Template.indent([
+								`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
+								Template.indent([
+									`currentUpdate[moduleId] = updatedModules[moduleId];`,
+									"if(updatedModulesList) updatedModulesList.push(moduleId);"
+								]),
+								"}"
+							]),
+							"}",
+							"if(runtime) currentUpdateRuntime.push(runtime);"
+						]),
+						"}",
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "require")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
+						Template.indent([
+							"return Promise.resolve().then(function() {",
+							Template.indent([
+								`return require(${JSON.stringify(rootOutputDir)} + ${
+									RuntimeGlobals.getUpdateManifestFilename
+								}());`
+							]),
+							"})['catch'](function(err) { if(err.code !== 'MODULE_NOT_FOUND') throw err; });"
+						]),
+						"}"
+				  ])
+				: "// no HMR manifest"
+		]);
 	}
 }
 
-module.exports = HelperRuntimeModule;
+module.exports = RequireChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 19942:
+/***/ 91786:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(6967);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-
-/**
- * @typedef {Object} LoadScriptCompilationHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} createScript
- */
+const util = __webpack_require__(73837);
+const truncateArgs = __webpack_require__(62090);
 
-/** @type {WeakMap<Compilation, LoadScriptCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+module.exports = ({ colors, appendOnly, stream }) => {
+	let currentStatusMessage = undefined;
+	let hasStatusMessage = false;
+	let currentIndent = "";
+	let currentCollapsed = 0;
 
-class LoadScriptRuntimeModule extends HelperRuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {LoadScriptCompilationHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
+	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+		if (str === "") return str;
+		prefix = currentIndent + prefix;
+		if (colors) {
+			return (
+				prefix +
+				colorPrefix +
+				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+				colorSuffix
 			);
+		} else {
+			return prefix + str.replace(/\n/g, "\n" + prefix);
 		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				createScript: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
+	};
 
-	/**
-	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
-	 */
-	constructor(withCreateScriptUrl) {
-		super("load script");
-		this._withCreateScriptUrl = withCreateScriptUrl;
-	}
+	const clearStatusMessage = () => {
+		if (hasStatusMessage) {
+			stream.write("\x1b[2K\r");
+			hasStatusMessage = false;
+		}
+	};
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const {
-			scriptType,
-			chunkLoadTimeout: loadTimeout,
-			crossOriginLoading,
-			uniqueName,
-			charset
-		} = outputOptions;
-		const fn = RuntimeGlobals.loadScript;
+	const writeStatusMessage = () => {
+		if (!currentStatusMessage) return;
+		const l = stream.columns;
+		const args = l
+			? truncateArgs(currentStatusMessage, l - 1)
+			: currentStatusMessage;
+		const str = args.join(" ");
+		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
+		stream.write(`\x1b[2K\r${coloredStr}`);
+		hasStatusMessage = true;
+	};
 
-		const { createScript } =
-			LoadScriptRuntimeModule.getCompilationHooks(compilation);
+	const writeColored = (prefix, colorPrefix, colorSuffix) => {
+		return (...args) => {
+			if (currentCollapsed > 0) return;
+			clearStatusMessage();
+			const str = indent(
+				util.format(...args),
+				prefix,
+				colorPrefix,
+				colorSuffix
+			);
+			stream.write(str + "\n");
+			writeStatusMessage();
+		};
+	};
 
-		const code = Template.asString([
-			"script = document.createElement('script');",
-			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
-			charset ? "script.charset = 'utf-8';" : "",
-			`script.timeout = ${loadTimeout / 1000};`,
-			`if (${RuntimeGlobals.scriptNonce}) {`,
-			Template.indent(
-				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
-			),
-			"}",
-			uniqueName
-				? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);'
-				: "",
-			`script.src = ${
-				this._withCreateScriptUrl
-					? `${RuntimeGlobals.createScriptUrl}(url)`
-					: "url"
-			};`,
-			crossOriginLoading
-				? Template.asString([
-						"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
-						Template.indent(
-							`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
-						),
-						"}"
-				  ])
-				: ""
-		]);
+	const writeGroupMessage = writeColored(
+		"<-> ",
+		"\u001b[1m\u001b[36m",
+		"\u001b[39m\u001b[22m"
+	);
 
-		return Template.asString([
-			"var inProgress = {};",
-			uniqueName
-				? `var dataWebpackPrefix = ${JSON.stringify(uniqueName + ":")};`
-				: "// data-webpack is not used as build has no uniqueName",
-			"// loadScript function to load a script via script tag",
-			`${fn} = ${runtimeTemplate.basicFunction("url, done, key, chunkId", [
-				"if(inProgress[url]) { inProgress[url].push(done); return; }",
-				"var script, needAttach;",
-				"if(key !== undefined) {",
-				Template.indent([
-					'var scripts = document.getElementsByTagName("script");',
-					"for(var i = 0; i < scripts.length; i++) {",
-					Template.indent([
-						"var s = scripts[i];",
-						`if(s.getAttribute("src") == url${
-							uniqueName
-								? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
-								: ""
-						}) { script = s; break; }`
-					]),
-					"}"
-				]),
-				"}",
-				"if(!script) {",
-				Template.indent([
-					"needAttach = true;",
-					createScript.call(code, this.chunk)
-				]),
-				"}",
-				"inProgress[url] = [done];",
-				"var onScriptComplete = " +
-					runtimeTemplate.basicFunction(
-						"prev, event",
-						Template.asString([
-							"// avoid mem leaks in IE.",
-							"script.onerror = script.onload = null;",
-							"clearTimeout(timeout);",
-							"var doneFns = inProgress[url];",
-							"delete inProgress[url];",
-							"script.parentNode && script.parentNode.removeChild(script);",
-							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
-								"fn(event)",
-								"fn"
-							)});`,
-							"if(prev) return prev(event);"
-						])
-					),
-				";",
-				`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
-				"script.onerror = onScriptComplete.bind(null, script.onerror);",
-				"script.onload = onScriptComplete.bind(null, script.onload);",
-				"needAttach && document.head.appendChild(script);"
-			])};`
-		]);
-	}
-}
+	const writeGroupCollapsedMessage = writeColored(
+		"<+> ",
+		"\u001b[1m\u001b[36m",
+		"\u001b[39m\u001b[22m"
+	);
 
-module.exports = LoadScriptRuntimeModule;
+	return {
+		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
+		debug: writeColored("    ", "", ""),
+		trace: writeColored("    ", "", ""),
+		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
+		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
+		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
+		logTime: writeColored(
+			"<t> ",
+			"\u001b[1m\u001b[35m",
+			"\u001b[39m\u001b[22m"
+		),
+		group: (...args) => {
+			writeGroupMessage(...args);
+			if (currentCollapsed > 0) {
+				currentCollapsed++;
+			} else {
+				currentIndent += "  ";
+			}
+		},
+		groupCollapsed: (...args) => {
+			writeGroupCollapsedMessage(...args);
+			currentCollapsed++;
+		},
+		groupEnd: () => {
+			if (currentCollapsed > 0) currentCollapsed--;
+			else if (currentIndent.length >= 2)
+				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+		},
+		// eslint-disable-next-line node/no-unsupported-features/node-builtins
+		profile: console.profile && (name => console.profile(name)),
+		// eslint-disable-next-line node/no-unsupported-features/node-builtins
+		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
+		clear:
+			!appendOnly &&
+			// eslint-disable-next-line node/no-unsupported-features/node-builtins
+			console.clear &&
+			(() => {
+				clearStatusMessage();
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				console.clear();
+				writeStatusMessage();
+			}),
+		status: appendOnly
+			? writeColored("<s> ", "", "")
+			: (name, ...args) => {
+					args = args.filter(Boolean);
+					if (name === undefined && args.length === 0) {
+						clearStatusMessage();
+						currentStatusMessage = undefined;
+					} else if (
+						typeof name === "string" &&
+						name.startsWith("[webpack.Progress] ")
+					) {
+						currentStatusMessage = [name.slice(19), ...args];
+						writeStatusMessage();
+					} else if (name === "[webpack.Progress]") {
+						currentStatusMessage = [...args];
+						writeStatusMessage();
+					} else {
+						currentStatusMessage = [name, ...args];
+						writeStatusMessage();
+					}
+			  }
+	};
+};
 
 
 /***/ }),
 
-/***/ 65714:
+/***/ 64395:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+const { STAGE_ADVANCED } = __webpack_require__(80057);
 
-class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("make namespace object");
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+
+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 || {};
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.makeNamespaceObject;
-		return Template.asString([
-			"// define __esModule on exports",
-			`${fn} = ${runtimeTemplate.basicFunction("exports", [
-				"if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {",
-				Template.indent([
-					"Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });"
-				]),
-				"}",
-				"Object.defineProperty(exports, '__esModule', { value: true });"
-			])};`
-		]);
+	apply(compiler) {
+		const options = this.options;
+		const minSizeReduce = options.minSizeReduce || 1.5;
+
+		compiler.hooks.thisCompilation.tap(
+			"AggressiveMergingPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "AggressiveMergingPlugin",
+						stage: STAGE_ADVANCED
+					},
+					chunks => {
+						const chunkGraph = compilation.chunkGraph;
+						/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
+						let combinations = [];
+						for (const a of chunks) {
+							if (a.canBeInitial()) continue;
+							for (const b of chunks) {
+								if (b.canBeInitial()) continue;
+								if (b === a) break;
+								if (!chunkGraph.canChunksBeIntegrated(a, b)) {
+									continue;
+								}
+								const aSize = chunkGraph.getChunkSize(b, {
+									chunkOverhead: 0
+								});
+								const bSize = chunkGraph.getChunkSize(a, {
+									chunkOverhead: 0
+								});
+								const abSize = chunkGraph.getIntegratedChunksSize(b, a, {
+									chunkOverhead: 0
+								});
+								const improvement = (aSize + bSize) / abSize;
+								combinations.push({
+									a,
+									b,
+									improvement
+								});
+							}
+						}
+
+						combinations.sort((a, b) => {
+							return b.improvement - a.improvement;
+						});
+
+						const pair = combinations[0];
+
+						if (!pair) return;
+						if (pair.improvement < minSizeReduce) return;
+
+						chunkGraph.integrateChunks(pair.b, pair.a);
+						compilation.chunks.delete(pair.a);
+						return true;
+					}
+				);
+			}
+		);
 	}
 }
 
-module.exports = MakeNamespaceObjectRuntimeModule;
+module.exports = AggressiveMergingPlugin;
 
 
 /***/ }),
 
-/***/ 44518:
+/***/ 15543:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const { intersect } = __webpack_require__(93347);
+const {
+	compareModulesByIdentifier,
+	compareChunks
+} = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const identifierUtils = __webpack_require__(82186);
 
-class OnChunksLoadedRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("chunk loaded");
+/** @typedef {import("../../declarations/plugins/optimize/AggressiveSplittingPlugin").AggressiveSplittingPluginOptions} AggressiveSplittingPluginOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const validate = createSchemaValidation(
+	__webpack_require__(32697),
+	() =>
+		__webpack_require__(47995),
+	{
+		name: "Aggressive Splitting Plugin",
+		baseDataPath: "options"
 	}
+);
+
+const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
+	return module => {
+		chunkGraph.disconnectChunkAndModule(oldChunk, module);
+		chunkGraph.connectChunkAndModule(newChunk, module);
+	};
+};
+
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} chunk the chunk
+ * @returns {function(Module): boolean} filter for entry module
+ */
+const isNotAEntryModule = (chunkGraph, chunk) => {
+	return module => {
+		return !chunkGraph.isEntryModuleInChunk(module, chunk);
+	};
+};
+
+/** @type {WeakSet<Chunk>} */
+const recordedChunks = new WeakSet();
 
+class AggressiveSplittingPlugin {
 	/**
-	 * @returns {string} runtime code
+	 * @param {AggressiveSplittingPluginOptions=} options options object
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate } = compilation;
-		return Template.asString([
-			"var deferred = [];",
-			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
-				"result, chunkIds, fn, priority",
-				[
-					"if(chunkIds) {",
-					Template.indent([
-						"priority = priority || 0;",
-						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
-						"deferred[i] = [chunkIds, fn, priority];",
-						"return;"
-					]),
-					"}",
-					"var notFulfilled = Infinity;",
-					"for (var i = 0; i < deferred.length; i++) {",
-					Template.indent([
-						runtimeTemplate.destructureArray(
-							["chunkIds", "fn", "priority"],
-							"deferred[i]"
-						),
-						"var fulfilled = true;",
-						"for (var j = 0; j < chunkIds.length; j++) {",
-						Template.indent([
-							`if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${
-								RuntimeGlobals.onChunksLoaded
-							}).every(${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
-								"key"
-							)})) {`,
-							Template.indent(["chunkIds.splice(j--, 1);"]),
-							"} else {",
-							Template.indent([
-								"fulfilled = false;",
-								"if(priority < notFulfilled) notFulfilled = priority;"
-							]),
-							"}"
-						]),
-						"}",
-						"if(fulfilled) {",
-						Template.indent([
-							"deferred.splice(i--, 1)",
-							"var r = fn();",
-							"if (r !== undefined) result = r;"
-						]),
-						"}"
-					]),
-					"}",
-					"return result;"
-				]
-			)};`
-		]);
-	}
-}
+	constructor(options = {}) {
+		validate(options);
 
-module.exports = OnChunksLoadedRuntimeModule;
+		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;
+		}
+	}
 
+	/**
+	 * @param {Chunk} chunk the chunk to test
+	 * @returns {boolean} true if the chunk was recorded
+	 */
+	static wasChunkRecorded(chunk) {
+		return recordedChunks.has(chunk);
+	}
 
-/***/ }),
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	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.optimizeChunks.tap(
+					{
+						name: "AggressiveSplittingPlugin",
+						stage: STAGE_ADVANCED
+					},
+					chunks => {
+						const chunkGraph = compilation.chunkGraph;
+						// Precompute stuff
+						const nameToModuleMap = new Map();
+						const moduleToNameMap = new Map();
+						const makePathsRelative =
+							identifierUtils.makePathsRelative.bindContextCache(
+								compiler.context,
+								compiler.root
+							);
+						for (const m of compilation.modules) {
+							const name = makePathsRelative(m.identifier());
+							nameToModuleMap.set(name, m);
+							moduleToNameMap.set(m, name);
+						}
 
-/***/ 56030:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+						// Check used chunk ids
+						const usedIds = new Set();
+						for (const chunk of chunks) {
+							usedIds.add(chunk.id);
+						}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+						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;
+							}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
+							// Get module objects from names
+							const selectedModules = splitData.modules.map(name =>
+								nameToModuleMap.get(name)
+							);
 
-class PublicPathRuntimeModule extends RuntimeModule {
-	constructor(publicPath) {
-		super("publicPath", RuntimeModule.STAGE_BASIC);
-		this.publicPath = publicPath;
-	}
+							// Does the modules exist at all?
+							if (!selectedModules.every(Boolean)) return false;
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, publicPath } = this;
+							// Check if size matches (faster than waiting for hash)
+							let size = 0;
+							for (const m of selectedModules) size += m.size();
+							if (size !== splitData.size) return false;
 
-		return `${RuntimeGlobals.publicPath} = ${JSON.stringify(
-			compilation.getPath(publicPath || "", {
-				hash: compilation.hash || "XXXX"
-			})
-		)};`;
-	}
-}
+							// get chunks with all modules
+							const selectedChunks = intersect(
+								selectedModules.map(
+									m => new Set(chunkGraph.getModuleChunksIterable(m))
+								)
+							);
 
-module.exports = PublicPathRuntimeModule;
+							// No relevant chunks found
+							if (selectedChunks.size === 0) return false;
 
+							// The found chunk is already the split or similar
+							if (
+								selectedChunks.size === 1 &&
+								chunkGraph.getNumberOfChunkModules(
+									Array.from(selectedChunks)[0]
+								) === 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(chunkGraph, chunk, newChunk)
+								);
+								chunk.split(newChunk);
+								chunk.name = null;
+							}
+							fromAggressiveSplittingSet.add(newChunk);
+							chunkSplitDataMap.set(newChunk, splitData);
 
-/***/ 4537:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+							if (splitData.id !== null && splitData.id !== undefined) {
+								newChunk.id = splitData.id;
+								newChunk.ids = [splitData.id];
+							}
+							return true;
+						};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+						// 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 cmpFn = compareChunks(chunkGraph);
+						const sortedChunks = Array.from(chunks).sort((a, b) => {
+							const diff1 =
+								chunkGraph.getChunkModulesSize(b) -
+								chunkGraph.getChunkModulesSize(a);
+							if (diff1) return diff1;
+							const diff2 =
+								chunkGraph.getNumberOfChunkModules(a) -
+								chunkGraph.getNumberOfChunkModules(b);
+							if (diff2) return diff2;
+							return cmpFn(a, b);
+						});
+						for (const chunk of sortedChunks) {
+							if (fromAggressiveSplittingSet.has(chunk)) continue;
+							const size = chunkGraph.getChunkModulesSize(chunk);
+							if (
+								size > maxSize &&
+								chunkGraph.getNumberOfChunkModules(chunk) > 1
+							) {
+								const modules = chunkGraph
+									.getOrderedChunkModules(chunk, compareModulesByIdentifier)
+									.filter(isNotAEntryModule(chunkGraph, chunk));
+								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();
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const HelperRuntimeModule = __webpack_require__(82444);
+						// 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);
+								}
+							}
+						}
 
-class RelativeUrlRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("relative url");
-	}
+						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
+									recordedChunks.add(chunk);
+								}
+							}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
-			Template.indent([
-				'var realUrl = new URL(url, "x:/");',
-				"var values = {};",
-				"for (var key in realUrl) values[key] = realUrl[key];",
-				"values.href = url;",
-				'values.pathname = url.replace(/[?#].*/, "");',
-				'values.origin = values.protocol = "";',
-				`values.toString = values.toJSON = ${runtimeTemplate.returningFunction(
-					"url"
-				)};`,
-				"for (var key in values) Object.defineProperty(this, key, { enumerable: true, configurable: true, value: values[key] });"
-			]),
-			"};",
-			`${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`
-		]);
+							// Also add all unused historical 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 = RelativeUrlRuntimeModule;
+module.exports = AggressiveSplittingPlugin;
 
 
 /***/ }),
 
-/***/ 97115:
+/***/ 97198:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
+const eslintScope = __webpack_require__(36007);
+const Referencer = __webpack_require__(44585);
+const {
+	CachedSource,
+	ConcatSource,
+	ReplaceSource
+} = __webpack_require__(51255);
+const ConcatenationScope = __webpack_require__(98229);
+const { UsageState } = __webpack_require__(63686);
+const Module = __webpack_require__(73208);
 const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const HarmonyImportDependency = __webpack_require__(57154);
+const JavascriptParser = __webpack_require__(29050);
+const { equals } = __webpack_require__(84953);
+const LazySet = __webpack_require__(38938);
+const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const { makePathsRelative } = __webpack_require__(82186);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const {
+	filterRuntime,
+	intersectRuntime,
+	mergeRuntimeCondition,
+	mergeRuntimeConditionNonFalse,
+	runtimeConditionToString,
+	subtractRuntimeCondition
+} = __webpack_require__(17156);
 
-class RuntimeIdRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("runtimeId");
-	}
+/** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, chunk } = this;
-		const runtime = chunk.runtime;
-		if (typeof runtime !== "string")
-			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
-		const id = chunkGraph.getRuntimeId(runtime);
-		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
-	}
+// fix eslint-scope to support class properties correctly
+// cspell:word Referencer
+const ReferencerClass = Referencer;
+if (!ReferencerClass.prototype.PropertyDefinition) {
+	ReferencerClass.prototype.PropertyDefinition =
+		ReferencerClass.prototype.Property;
 }
 
-module.exports = RuntimeIdRuntimeModule;
+/**
+ * @typedef {Object} ReexportInfo
+ * @property {Module} module
+ * @property {string[]} export
+ */
 
+/** @typedef {RawBinding | SymbolBinding} Binding */
 
-/***/ }),
+/**
+ * @typedef {Object} RawBinding
+ * @property {ModuleInfo} info
+ * @property {string} rawName
+ * @property {string=} comment
+ * @property {string[]} ids
+ * @property {string[]} exportName
+ */
 
-/***/ 22339:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @typedef {Object} SymbolBinding
+ * @property {ConcatenatedModuleInfo} info
+ * @property {string} name
+ * @property {string=} comment
+ * @property {string[]} ids
+ * @property {string[]} exportName
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo } ModuleInfo */
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
 
+/**
+ * @typedef {Object} ConcatenatedModuleInfo
+ * @property {"concatenated"} type
+ * @property {Module} module
+ * @property {number} index
+ * @property {Object} ast
+ * @property {Source} internalSource
+ * @property {ReplaceSource} source
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {Iterable<string>} runtimeRequirements
+ * @property {Scope} globalScope
+ * @property {Scope} moduleScope
+ * @property {Map<string, string>} internalNames
+ * @property {Map<string, string>} exportMap
+ * @property {Map<string, string>} rawExportMap
+ * @property {string=} namespaceExportSymbol
+ * @property {string} namespaceObjectName
+ * @property {boolean} interopNamespaceObjectUsed
+ * @property {string} interopNamespaceObjectName
+ * @property {boolean} interopNamespaceObject2Used
+ * @property {string} interopNamespaceObject2Name
+ * @property {boolean} interopDefaultAccessUsed
+ * @property {string} interopDefaultAccessName
+ */
 
+/**
+ * @typedef {Object} ExternalModuleInfo
+ * @property {"external"} type
+ * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {number} index
+ * @property {string} name
+ * @property {boolean} interopNamespaceObjectUsed
+ * @property {string} interopNamespaceObjectName
+ * @property {boolean} interopNamespaceObject2Used
+ * @property {string} interopNamespaceObject2Name
+ * @property {boolean} interopDefaultAccessUsed
+ * @property {string} interopDefaultAccessName
+ */
 
-const RuntimeGlobals = __webpack_require__(16475);
-const StartupChunkDependenciesRuntimeModule = __webpack_require__(38157);
-const StartupEntrypointRuntimeModule = __webpack_require__(97672);
+/**
+ * @typedef {Object} ReferenceToModuleInfo
+ * @property {"reference"} type
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
+ */
 
-/** @typedef {import("../Compiler")} Compiler */
+const RESERVED_NAMES = new Set(
+	[
+		// internal names (should always be renamed)
+		ConcatenationScope.DEFAULT_EXPORT,
+		ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
 
-class StartupChunkDependenciesPlugin {
-	constructor(options) {
-		this.chunkLoading = options.chunkLoading;
-		this.asyncChunkLoading =
-			typeof options.asyncChunkLoading === "boolean"
-				? options.asyncChunkLoading
-				: true;
+		// keywords
+		"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",
+
+		// commonjs/amd
+		"module,__dirname,__filename,exports,require,define",
+
+		// js globals
+		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
+		"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
+
+		// browser globals
+		"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",
+
+		// window events
+		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
+	]
+		.join(",")
+		.split(",")
+);
+
+const bySourceOrder = (a, b) => {
+	const aOrder = a.sourceOrder;
+	const bOrder = b.sourceOrder;
+	if (isNaN(aOrder)) {
+		if (!isNaN(bOrder)) {
+			return 1;
+		}
+	} else {
+		if (isNaN(bOrder)) {
+			return -1;
+		}
+		if (aOrder !== bOrder) {
+			return aOrder < bOrder ? -1 : 1;
+		}
 	}
+	return 0;
+};
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"StartupChunkDependenciesPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === this.chunkLoading;
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
+	}
+	return str;
+};
+
+/**
+ * @typedef {Object} ConcatenationEntry
+ * @property {"concatenated" | "external"} type
+ * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ */
+
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ModuleInfo} info module info
+ * @param {string[]} exportName exportName
+ * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
+ * @param {RuntimeSpec} runtime for which runtime
+ * @param {RequestShortener} requestShortener the request shortener
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
+ * @param {boolean} asCall asCall
+ * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
+ * @returns {Binding} the final variable
+ */
+const getFinalBinding = (
+	moduleGraph,
+	info,
+	exportName,
+	moduleToInfoMap,
+	runtime,
+	requestShortener,
+	runtimeTemplate,
+	neededNamespaceObjects,
+	asCall,
+	strictHarmonyModule,
+	asiSafe,
+	alreadyVisited = new Set()
+) => {
+	const exportsType = info.module.getExportsType(
+		moduleGraph,
+		strictHarmonyModule
+	);
+	if (exportName.length === 0) {
+		switch (exportsType) {
+			case "default-only":
+				info.interopNamespaceObject2Used = true;
+				return {
+					info,
+					rawName: info.interopNamespaceObject2Name,
+					ids: exportName,
+					exportName
 				};
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"StartupChunkDependenciesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
-							set.add(RuntimeGlobals.startup);
-							set.add(RuntimeGlobals.ensureChunk);
-							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-							compilation.addRuntimeModule(
-								chunk,
-								new StartupChunkDependenciesRuntimeModule(
-									this.asyncChunkLoading
-								)
-							);
-						}
+			case "default-with-named":
+				info.interopNamespaceObjectUsed = true;
+				return {
+					info,
+					rawName: info.interopNamespaceObjectName,
+					ids: exportName,
+					exportName
+				};
+			case "namespace":
+			case "dynamic":
+				break;
+			default:
+				throw new Error(`Unexpected exportsType ${exportsType}`);
+		}
+	} else {
+		switch (exportsType) {
+			case "namespace":
+				break;
+			case "default-with-named":
+				switch (exportName[0]) {
+					case "default":
+						exportName = exportName.slice(1);
+						break;
+					case "__esModule":
+						return {
+							info,
+							rawName: "/* __esModule */true",
+							ids: exportName.slice(1),
+							exportName
+						};
+				}
+				break;
+			case "default-only": {
+				const exportId = exportName[0];
+				if (exportId === "__esModule") {
+					return {
+						info,
+						rawName: "/* __esModule */true",
+						ids: exportName.slice(1),
+						exportName
+					};
+				}
+				exportName = exportName.slice(1);
+				if (exportId !== "default") {
+					return {
+						info,
+						rawName:
+							"/* non-default import from default-exporting module */undefined",
+						ids: exportName,
+						exportName
+					};
+				}
+				break;
+			}
+			case "dynamic":
+				switch (exportName[0]) {
+					case "default": {
+						exportName = exportName.slice(1);
+						info.interopDefaultAccessUsed = true;
+						const defaultExport = asCall
+							? `${info.interopDefaultAccessName}()`
+							: asiSafe
+							? `(${info.interopDefaultAccessName}())`
+							: asiSafe === false
+							? `;(${info.interopDefaultAccessName}())`
+							: `${info.interopDefaultAccessName}.a`;
+						return {
+							info,
+							rawName: defaultExport,
+							ids: exportName,
+							exportName
+						};
 					}
+					case "__esModule":
+						return {
+							info,
+							rawName: "/* __esModule */true",
+							ids: exportName.slice(1),
+							exportName
+						};
+				}
+				break;
+			default:
+				throw new Error(`Unexpected exportsType ${exportsType}`);
+		}
+	}
+	if (exportName.length === 0) {
+		switch (info.type) {
+			case "concatenated":
+				neededNamespaceObjects.add(info);
+				return {
+					info,
+					rawName: info.namespaceObjectName,
+					ids: exportName,
+					exportName
+				};
+			case "external":
+				return { info, rawName: info.name, ids: exportName, exportName };
+		}
+	}
+	const exportsInfo = moduleGraph.getExportsInfo(info.module);
+	const exportInfo = exportsInfo.getExportInfo(exportName[0]);
+	if (alreadyVisited.has(exportInfo)) {
+		return {
+			info,
+			rawName: "/* circular reexport */ Object(function x() { x() }())",
+			ids: [],
+			exportName
+		};
+	}
+	alreadyVisited.add(exportInfo);
+	switch (info.type) {
+		case "concatenated": {
+			const exportId = exportName[0];
+			if (exportInfo.provided === false) {
+				// It's not provided, but it could be on the prototype
+				neededNamespaceObjects.add(info);
+				return {
+					info,
+					rawName: info.namespaceObjectName,
+					ids: exportName,
+					exportName
+				};
+			}
+			const directExport = info.exportMap && info.exportMap.get(exportId);
+			if (directExport) {
+				const usedName = /** @type {string[]} */ (
+					exportsInfo.getUsedName(exportName, runtime)
+				);
+				if (!usedName) {
+					return {
+						info,
+						rawName: "/* unused export */ undefined",
+						ids: exportName.slice(1),
+						exportName
+					};
+				}
+				return {
+					info,
+					name: directExport,
+					ids: usedName.slice(1),
+					exportName
+				};
+			}
+			const rawExport = info.rawExportMap && info.rawExportMap.get(exportId);
+			if (rawExport) {
+				return {
+					info,
+					rawName: rawExport,
+					ids: exportName.slice(1),
+					exportName
+				};
+			}
+			const reexport = exportInfo.findTarget(moduleGraph, module =>
+				moduleToInfoMap.has(module)
+			);
+			if (reexport === false) {
+				throw new Error(
+					`Target module of reexport from '${info.module.readableIdentifier(
+						requestShortener
+					)}' is not part of the concatenation (export '${exportId}')\nModules in the concatenation:\n${Array.from(
+						moduleToInfoMap,
+						([m, info]) =>
+							` * ${info.type} ${m.readableIdentifier(requestShortener)}`
+					).join("\n")}`
+				);
+			}
+			if (reexport) {
+				const refInfo = moduleToInfoMap.get(reexport.module);
+				return getFinalBinding(
+					moduleGraph,
+					refInfo,
+					reexport.export
+						? [...reexport.export, ...exportName.slice(1)]
+						: exportName.slice(1),
+					moduleToInfoMap,
+					runtime,
+					requestShortener,
+					runtimeTemplate,
+					neededNamespaceObjects,
+					asCall,
+					info.module.buildMeta.strictHarmonyModule,
+					asiSafe,
+					alreadyVisited
 				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.startupEntrypoint)
-					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.require);
-						set.add(RuntimeGlobals.ensureChunk);
-						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-						compilation.addRuntimeModule(
-							chunk,
-							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
-						);
-					});
 			}
-		);
-	}
-}
-
-module.exports = StartupChunkDependenciesPlugin;
-
-
-/***/ }),
-
-/***/ 38157:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-
-class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
-	constructor(asyncChunkLoading) {
-		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
-		this.asyncChunkLoading = asyncChunkLoading;
-	}
+			if (info.namespaceExportSymbol) {
+				const usedName = /** @type {string[]} */ (
+					exportsInfo.getUsedName(exportName, runtime)
+				);
+				return {
+					info,
+					rawName: info.namespaceObjectName,
+					ids: usedName,
+					exportName
+				};
+			}
+			throw new Error(
+				`Cannot get final name for export '${exportName.join(
+					"."
+				)}' of ${info.module.readableIdentifier(requestShortener)}`
+			);
+		}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, chunk, compilation } = this;
-		const { runtimeTemplate } = compilation;
-		const chunkIds = Array.from(
-			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-		).map(chunk => {
-			return chunk.id;
-		});
-		return Template.asString([
-			`var next = ${RuntimeGlobals.startup};`,
-			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
-				"",
-				!this.asyncChunkLoading
-					? chunkIds
-							.map(
-								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
-							)
-							.concat("return next();")
-					: chunkIds.length === 1
-					? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
-							chunkIds[0]
-					  )}).then(next);`
-					: chunkIds.length > 2
-					? [
-							// using map is shorter for 3 or more chunks
-							`return Promise.all(${JSON.stringify(chunkIds)}.map(${
-								RuntimeGlobals.ensureChunk
-							}, __webpack_require__)).then(next);`
-					  ]
-					: [
-							// calling ensureChunk directly is shorter for 0 - 2 chunks
-							"return Promise.all([",
-							Template.indent(
-								chunkIds
-									.map(
-										id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)})`
-									)
-									.join(",\n")
-							),
-							"]).then(next);"
-					  ]
-			)};`
-		]);
+		case "external": {
+			const used = /** @type {string[]} */ (
+				exportsInfo.getUsedName(exportName, runtime)
+			);
+			if (!used) {
+				return {
+					info,
+					rawName: "/* unused export */ undefined",
+					ids: exportName.slice(1),
+					exportName
+				};
+			}
+			const comment = equals(used, exportName)
+				? ""
+				: Template.toNormalComment(`${exportName.join(".")}`);
+			return { info, rawName: info.name + comment, ids: used, exportName };
+		}
 	}
-}
-
-module.exports = StartupChunkDependenciesRuntimeModule;
-
-
-/***/ }),
-
-/***/ 97672:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-/** @typedef {import("../MainTemplate")} MainTemplate */
+};
 
-class StartupEntrypointRuntimeModule extends RuntimeModule {
-	constructor(asyncChunkLoading) {
-		super("startup entrypoint");
-		this.asyncChunkLoading = asyncChunkLoading;
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ModuleInfo} info module info
+ * @param {string[]} exportName exportName
+ * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
+ * @param {RuntimeSpec} runtime for which runtime
+ * @param {RequestShortener} requestShortener the request shortener
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
+ * @param {boolean} asCall asCall
+ * @param {boolean} callContext callContext
+ * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @returns {string} the final name
+ */
+const getFinalName = (
+	moduleGraph,
+	info,
+	exportName,
+	moduleToInfoMap,
+	runtime,
+	requestShortener,
+	runtimeTemplate,
+	neededNamespaceObjects,
+	asCall,
+	callContext,
+	strictHarmonyModule,
+	asiSafe
+) => {
+	const binding = getFinalBinding(
+		moduleGraph,
+		info,
+		exportName,
+		moduleToInfoMap,
+		runtime,
+		requestShortener,
+		runtimeTemplate,
+		neededNamespaceObjects,
+		asCall,
+		strictHarmonyModule,
+		asiSafe
+	);
+	{
+		const { ids, comment } = binding;
+		let reference;
+		let isPropertyAccess;
+		if ("rawName" in binding) {
+			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
+			isPropertyAccess = ids.length > 0;
+		} else {
+			const { info, name: exportId } = binding;
+			const name = info.internalNames.get(exportId);
+			if (!name) {
+				throw new Error(
+					`The export "${exportId}" in "${info.module.readableIdentifier(
+						requestShortener
+					)}" has no internal name (existing names: ${
+						Array.from(
+							info.internalNames,
+							([name, symbol]) => `${name}: ${symbol}`
+						).join(", ") || "none"
+					})`
+				);
+			}
+			reference = `${name}${comment || ""}${propertyAccess(ids)}`;
+			isPropertyAccess = ids.length > 1;
+		}
+		if (isPropertyAccess && asCall && callContext === false) {
+			return asiSafe
+				? `(0,${reference})`
+				: asiSafe === false
+				? `;(0,${reference})`
+				: `/*#__PURE__*/Object(${reference})`;
+		}
+		return reference;
 	}
+};
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate } = compilation;
-		return `${
-			RuntimeGlobals.startupEntrypoint
-		} = ${runtimeTemplate.basicFunction("result, chunkIds, fn", [
-			"// arguments: chunkIds, moduleId are deprecated",
-			"var moduleId = chunkIds;",
-			`if(!fn) chunkIds = result, fn = ${runtimeTemplate.returningFunction(
-				`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`
-			)};`,
-			...(this.asyncChunkLoading
-				? [
-						`return Promise.all(chunkIds.map(${
-							RuntimeGlobals.ensureChunk
-						}, __webpack_require__)).then(${runtimeTemplate.basicFunction("", [
-							"var r = fn();",
-							"return r === undefined ? result : r;"
-						])})`
-				  ]
-				: [
-						`chunkIds.map(${RuntimeGlobals.ensureChunk}, __webpack_require__)`,
-						"var r = fn();",
-						"return r === undefined ? result : r;"
-				  ])
-		])}`;
+const addScopeSymbols = (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;
 	}
-}
-
-module.exports = StartupEntrypointRuntimeModule;
-
-
-/***/ }),
-
-/***/ 80655:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-/** @typedef {import("../Compilation")} Compilation */
+};
 
-class SystemContextRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("__system_context__");
+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;
+};
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return `${RuntimeGlobals.systemContext} = __system_context__;`;
+const getPathInAst = (ast, node) => {
+	if (ast === node) {
+		return [];
 	}
-}
-
-module.exports = SystemContextRuntimeModule;
-
-
-/***/ }),
-
-/***/ 64820:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	const nr = node.range;
 
-const NormalModule = __webpack_require__(39);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
-// http://www.ietf.org/rfc/rfc2397.txt
-const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
-
-const decodeDataURI = uri => {
-	const match = URIRegEx.exec(uri);
-	if (!match) return null;
-
-	const isBase64 = match[3];
-	const body = match[4];
-	return isBase64
-		? Buffer.from(body, "base64")
-		: Buffer.from(decodeURIComponent(body), "ascii");
-};
+	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;
+	};
 
-class DataUriPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DataUriPlugin",
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.resolveForScheme
-					.for("data")
-					.tap("DataUriPlugin", resourceData => {
-						const match = URIRegEx.exec(resourceData.resource);
-						if (match) {
-							resourceData.data.mimetype = match[1] || "";
-							resourceData.data.parameters = match[2] || "";
-							resourceData.data.encoding = match[3] || false;
-							resourceData.data.encodedContent = match[4] || "";
-						}
-					});
-				NormalModule.getCompilationHooks(compilation)
-					.readResourceForScheme.for("data")
-					.tap("DataUriPlugin", resource => decodeDataURI(resource));
+	if (Array.isArray(ast)) {
+		for (let 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 (let 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;
 			}
-		);
+		}
 	}
-}
-
-module.exports = DataUriPlugin;
-
-
-/***/ }),
-
-/***/ 57637:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { URL, fileURLToPath } = __webpack_require__(57310);
-const { NormalModule } = __webpack_require__(91919);
+};
 
-/** @typedef {import("../Compiler")} Compiler */
+const TYPES = new Set(["javascript"]);
 
-class FileUriPlugin {
+class ConcatenatedModule extends Module {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Module} rootModule the root module of the concatenation
+	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @returns {ConcatenatedModule} the module
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FileUriPlugin",
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.resolveForScheme
-					.for("file")
-					.tap("FileUriPlugin", resourceData => {
-						const url = new URL(resourceData.resource);
-						const path = fileURLToPath(url);
-						const query = url.search;
-						const fragment = url.hash;
-						resourceData.path = path;
-						resourceData.query = query;
-						resourceData.fragment = fragment;
-						resourceData.resource = path + query + fragment;
-						return true;
-					});
-				const hooks = NormalModule.getCompilationHooks(compilation);
-				hooks.readResource
-					.for(undefined)
-					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
-						const { resourcePath } = loaderContext;
-						loaderContext.addDependency(resourcePath);
-						loaderContext.fs.readFile(resourcePath, callback);
-					});
-			}
+	static create(
+		rootModule,
+		modules,
+		runtime,
+		associatedObjectForCache,
+		hashFunction = "md4"
+	) {
+		const identifier = ConcatenatedModule._createIdentifier(
+			rootModule,
+			modules,
+			associatedObjectForCache,
+			hashFunction
 		);
-	}
-}
-
-module.exports = FileUriPlugin;
-
-
-/***/ }),
-
-/***/ 42110:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { extname, basename } = __webpack_require__(71017);
-const { URL } = __webpack_require__(57310);
-const { createGunzip, createBrotliDecompress, createInflate } = __webpack_require__(59796);
-const NormalModule = __webpack_require__(39);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const { mkdirp, dirname, join } = __webpack_require__(17139);
-const memoize = __webpack_require__(78676);
+		return new ConcatenatedModule({
+			identifier,
+			rootModule,
+			modules,
+			runtime
+		});
+	}
 
-/** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.identifier the identifier of the module
+	 * @param {Module=} options.rootModule the root module of the concatenation
+	 * @param {RuntimeSpec} options.runtime the selected runtime
+	 * @param {Set<Module>=} options.modules all concatenated modules
+	 */
+	constructor({ identifier, rootModule, modules, runtime }) {
+		super("javascript/esm", null, rootModule && rootModule.layer);
 
-const getHttp = memoize(() => __webpack_require__(13685));
-const getHttps = memoize(() => __webpack_require__(95687));
+		// Info from Factory
+		/** @type {string} */
+		this._identifier = identifier;
+		/** @type {Module} */
+		this.rootModule = rootModule;
+		/** @type {Set<Module>} */
+		this._modules = modules;
+		this._runtime = runtime;
+		this.factoryMeta = rootModule && rootModule.factoryMeta;
+	}
 
-/** @type {(() => void)[] | undefined} */
-let inProgressWrite = undefined;
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		throw new Error("Must not be called");
+	}
 
-const validate = createSchemaValidation(
-	__webpack_require__(67263),
-	() => __webpack_require__(27256),
-	{
-		name: "Http Uri Plugin",
-		baseDataPath: "options"
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
-);
 
-const toSafePath = str =>
-	str
-		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
-		.replace(/[^a-zA-Z0-9._-]+/g, "_");
+	get modules() {
+		return Array.from(this._modules);
+	}
 
-const computeIntegrity = content => {
-	const hash = createHash("sha512");
-	hash.update(content);
-	const integrity = "sha512-" + hash.digest("base64");
-	return integrity;
-};
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this._identifier;
+	}
 
-const verifyIntegrity = (content, integrity) => {
-	if (integrity === "ignore") return true;
-	return computeIntegrity(content) === integrity;
-};
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return (
+			this.rootModule.readableIdentifier(requestShortener) +
+			` + ${this._modules.size - 1} modules`
+		);
+	}
 
-/**
- * @param {string} str input
- * @returns {Record<string, string>} parsed
- */
-const parseKeyValuePairs = str => {
-	/** @type {Record<string, string>} */
-	const result = {};
-	for (const item of str.split(",")) {
-		const i = item.indexOf("=");
-		if (i >= 0) {
-			const key = item.slice(0, i).trim();
-			const value = item.slice(i + 1).trim();
-			result[key] = value;
-		} else {
-			const key = item.trim();
-			if (!key) continue;
-			result[key] = key;
-		}
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return this.rootModule.libIdent(options);
 	}
-	return result;
-};
 
-const parseCacheControl = (cacheControl, requestTime) => {
-	// When false resource is not stored in cache
-	let storeCache = true;
-	// When false resource is not stored in lockfile cache
-	let storeLock = true;
-	// Resource is only revalidated, after that timestamp and when upgrade is chosen
-	let validUntil = 0;
-	if (cacheControl) {
-		const parsed = parseKeyValuePairs(cacheControl);
-		if (parsed["no-cache"]) storeCache = storeLock = false;
-		if (parsed["max-age"] && !isNaN(+parsed["max-age"])) {
-			validUntil = requestTime + +parsed["max-age"] * 1000;
-		}
-		if (parsed["must-revalidate"]) validUntil = 0;
+	/**
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 */
+	nameForCondition() {
+		return this.rootModule.nameForCondition();
 	}
-	return {
-		storeLock,
-		storeCache,
-		validUntil
-	};
-};
 
-/**
- * @typedef {Object} LockfileEntry
- * @property {string} resolved
- * @property {string} integrity
- * @property {string} contentType
- */
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		return this.rootModule.getSideEffectsConnectionState(moduleGraph);
+	}
 
-const areLockfileEntriesEqual = (a, b) => {
-	return (
-		a.resolved === b.resolved &&
-		a.integrity === b.integrity &&
-		a.contentType === b.contentType
-	);
-};
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		const { rootModule } = this;
+		this.buildInfo = {
+			strict: true,
+			cacheable: true,
+			moduleArgument: rootModule.buildInfo.moduleArgument,
+			exportsArgument: rootModule.buildInfo.exportsArgument,
+			fileDependencies: new LazySet(),
+			contextDependencies: new LazySet(),
+			missingDependencies: new LazySet(),
+			topLevelDeclarations: new Set(),
+			assets: undefined
+		};
+		this.buildMeta = rootModule.buildMeta;
+		this.clearDependenciesAndBlocks();
+		this.clearWarningsAndErrors();
 
-const entryToString = entry => {
-	return `resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
-};
+		for (const m of this._modules) {
+			// populate cacheable
+			if (!m.buildInfo.cacheable) {
+				this.buildInfo.cacheable = false;
+			}
 
-class Lockfile {
-	constructor() {
-		this.version = 1;
-		/** @type {Map<string, LockfileEntry | "ignore" | "no-cache">} */
-		this.entries = new Map();
-	}
+			// populate dependencies
+			for (const d of m.dependencies.filter(
+				dep =>
+					!(dep instanceof HarmonyImportDependency) ||
+					!this._modules.has(compilation.moduleGraph.getModule(dep))
+			)) {
+				this.dependencies.push(d);
+			}
+			// populate blocks
+			for (const d of m.blocks) {
+				this.blocks.push(d);
+			}
 
-	static parse(content) {
-		// TODO handle merge conflicts
-		const data = JSON.parse(content);
-		if (data.version !== 1)
-			throw new Error(`Unsupported lockfile version ${data.version}`);
-		const lockfile = new Lockfile();
-		for (const key of Object.keys(data)) {
-			if (key === "version") continue;
-			const entry = data[key];
-			lockfile.entries.set(
-				key,
-				typeof entry === "string"
-					? entry
-					: {
-							resolved: key,
-							...entry
-					  }
-			);
-		}
-		return lockfile;
-	}
+			// populate warnings
+			const warnings = m.getWarnings();
+			if (warnings !== undefined) {
+				for (const warning of warnings) {
+					this.addWarning(warning);
+				}
+			}
 
-	toString() {
-		let str = "{\n";
-		const entries = Array.from(this.entries).sort(([a], [b]) =>
-			a < b ? -1 : 1
-		);
-		for (const [key, entry] of entries) {
-			if (typeof entry === "string") {
-				str += `  ${JSON.stringify(key)}: ${JSON.stringify(entry)},\n`;
+			// populate errors
+			const errors = m.getErrors();
+			if (errors !== undefined) {
+				for (const error of errors) {
+					this.addError(error);
+				}
+			}
+
+			// populate topLevelDeclarations
+			if (m.buildInfo.topLevelDeclarations) {
+				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
+				if (topLevelDeclarations !== undefined) {
+					for (const decl of m.buildInfo.topLevelDeclarations) {
+						// reserved names will always be renamed
+						if (RESERVED_NAMES.has(decl)) continue;
+						// TODO actually this is incorrect since with renaming there could be more
+						// We should do the renaming during build
+						topLevelDeclarations.add(decl);
+					}
+				}
 			} else {
-				str += `  ${JSON.stringify(key)}: { `;
-				if (entry.resolved !== key)
-					str += `"resolved": ${JSON.stringify(entry.resolved)}, `;
-				str += `"integrity": ${JSON.stringify(
-					entry.integrity
-				)}, "contentType": ${JSON.stringify(entry.contentType)} },\n`;
+				this.buildInfo.topLevelDeclarations = undefined;
+			}
+
+			// populate assets
+			if (m.buildInfo.assets) {
+				if (this.buildInfo.assets === undefined) {
+					this.buildInfo.assets = Object.create(null);
+				}
+				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
+			}
+			if (m.buildInfo.assetsInfo) {
+				if (this.buildInfo.assetsInfo === undefined) {
+					this.buildInfo.assetsInfo = new Map();
+				}
+				for (const [key, value] of m.buildInfo.assetsInfo) {
+					this.buildInfo.assetsInfo.set(key, value);
+				}
 			}
 		}
-		str += `  "version": ${this.version}\n}\n`;
-		return str;
+		callback();
 	}
-}
 
-/**
- * @template R
- * @param {function(function(Error=, R=): void): void} fn function
- * @returns {function(function((Error | null)=, R=): void): void} cached function
- */
-const cachedWithoutKey = fn => {
-	let inFlight = false;
-	/** @type {Error | undefined} */
-	let cachedError = undefined;
-	/** @type {R | undefined} */
-	let cachedResult = undefined;
-	/** @type {(function(Error=, R=): void)[] | undefined} */
-	let cachedCallbacks = undefined;
-	return callback => {
-		if (inFlight) {
-			if (cachedResult !== undefined) return callback(null, cachedResult);
-			if (cachedError !== undefined) return callback(cachedError);
-			if (cachedCallbacks === undefined) cachedCallbacks = [callback];
-			else cachedCallbacks.push(callback);
-			return;
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		// Guess size from embedded modules
+		let size = 0;
+		for (const module of this._modules) {
+			size += module.size(type);
 		}
-		inFlight = true;
-		fn((err, result) => {
-			if (err) cachedError = err;
-			else cachedResult = result;
-			const callbacks = cachedCallbacks;
-			cachedCallbacks = undefined;
-			callback(err, result);
-			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
-		});
-	};
-};
+		return size;
+	}
 
-/**
- * @template T
- * @template R
- * @param {function(T, function(Error=, R=): void): void} fn function
- * @param {function(T, function(Error=, R=): void): void=} forceFn function for the second try
- * @returns {(function(T, function((Error | null)=, R=): void): void) & { force: function(T, function((Error | null)=, R=): void): void }} cached function
- */
-const cachedWithKey = (fn, forceFn = fn) => {
-	/** @typedef {{ result?: R, error?: Error, callbacks?: (function((Error | null)=, R=): void)[], force?: true }} CacheEntry */
-	/** @type {Map<T, CacheEntry>} */
-	const cache = new Map();
-	const resultFn = (arg, callback) => {
-		const cacheEntry = cache.get(arg);
-		if (cacheEntry !== undefined) {
-			if (cacheEntry.result !== undefined)
-				return callback(null, cacheEntry.result);
-			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
-			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
-			else cacheEntry.callbacks.push(callback);
-			return;
-		}
-		/** @type {CacheEntry} */
-		const newCacheEntry = {
-			result: undefined,
-			error: undefined,
-			callbacks: undefined
+	/**
+	 * @private
+	 * @param {Module} rootModule the root of the concatenation
+	 * @param {Set<Module>} modulesSet a set of modules which should be concatenated
+	 * @param {RuntimeSpec} runtime for this runtime
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConcatenationEntry[]} concatenation list
+	 */
+	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
+		/** @type {ConcatenationEntry[]} */
+		const list = [];
+		/** @type {Map<Module, RuntimeSpec | true>} */
+		const existingEntries = new Map();
+
+		/**
+		 * @param {Module} module a module
+		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
+		 */
+		const getConcatenatedImports = module => {
+			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
+			if (module === rootModule) {
+				for (const c of moduleGraph.getOutgoingConnections(this))
+					connections.push(c);
+			}
+			const references = connections
+				.filter(connection => {
+					if (!(connection.dependency instanceof HarmonyImportDependency))
+						return false;
+					return (
+						connection &&
+						connection.resolvedOriginModule === module &&
+						connection.module &&
+						connection.isTargetActive(runtime)
+					);
+				})
+				.map(connection => ({
+					connection,
+					sourceOrder: /** @type {HarmonyImportDependency} */ (
+						connection.dependency
+					).sourceOrder
+				}));
+			references.sort(
+				concatComparators(bySourceOrder, keepOriginalOrder(references))
+			);
+			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
+			const referencesMap = new Map();
+			for (const { connection } of references) {
+				const runtimeCondition = filterRuntime(runtime, r =>
+					connection.isTargetActive(r)
+				);
+				if (runtimeCondition === false) continue;
+				const module = connection.module;
+				const entry = referencesMap.get(module);
+				if (entry === undefined) {
+					referencesMap.set(module, { connection, runtimeCondition });
+					continue;
+				}
+				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
+					entry.runtimeCondition,
+					runtimeCondition,
+					runtime
+				);
+			}
+			return referencesMap.values();
 		};
-		cache.set(arg, newCacheEntry);
-		fn(arg, (err, result) => {
-			if (err) newCacheEntry.error = err;
-			else newCacheEntry.result = result;
-			const callbacks = newCacheEntry.callbacks;
-			newCacheEntry.callbacks = undefined;
-			callback(err, result);
-			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
-		});
-	};
-	resultFn.force = (arg, callback) => {
-		const cacheEntry = cache.get(arg);
-		if (cacheEntry !== undefined && cacheEntry.force) {
-			if (cacheEntry.result !== undefined)
-				return callback(null, cacheEntry.result);
-			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
-			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
-			else cacheEntry.callbacks.push(callback);
-			return;
-		}
-		/** @type {CacheEntry} */
-		const newCacheEntry = {
-			result: undefined,
-			error: undefined,
-			callbacks: undefined,
-			force: true
+
+		/**
+		 * @param {ModuleGraphConnection} connection graph connection
+		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
+		 * @returns {void}
+		 */
+		const enterModule = (connection, runtimeCondition) => {
+			const module = connection.module;
+			if (!module) return;
+			const existingEntry = existingEntries.get(module);
+			if (existingEntry === true) {
+				return;
+			}
+			if (modulesSet.has(module)) {
+				existingEntries.set(module, true);
+				if (runtimeCondition !== true) {
+					throw new Error(
+						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
+							runtimeCondition
+						)}). This should not happen.`
+					);
+				}
+				const imports = getConcatenatedImports(module);
+				for (const { connection, runtimeCondition } of imports)
+					enterModule(connection, runtimeCondition);
+				list.push({
+					type: "concatenated",
+					module: connection.module,
+					runtimeCondition
+				});
+			} else {
+				if (existingEntry !== undefined) {
+					const reducedRuntimeCondition = subtractRuntimeCondition(
+						runtimeCondition,
+						existingEntry,
+						runtime
+					);
+					if (reducedRuntimeCondition === false) return;
+					runtimeCondition = reducedRuntimeCondition;
+					existingEntries.set(
+						connection.module,
+						mergeRuntimeConditionNonFalse(
+							existingEntry,
+							runtimeCondition,
+							runtime
+						)
+					);
+				} else {
+					existingEntries.set(connection.module, runtimeCondition);
+				}
+				if (list.length > 0) {
+					const lastItem = list[list.length - 1];
+					if (
+						lastItem.type === "external" &&
+						lastItem.module === connection.module
+					) {
+						lastItem.runtimeCondition = mergeRuntimeCondition(
+							lastItem.runtimeCondition,
+							runtimeCondition,
+							runtime
+						);
+						return;
+					}
+				}
+				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 connection.module;
+					},
+					runtimeCondition
+				});
+			}
 		};
-		cache.set(arg, newCacheEntry);
-		forceFn(arg, (err, result) => {
-			if (err) newCacheEntry.error = err;
-			else newCacheEntry.result = result;
-			const callbacks = newCacheEntry.callbacks;
-			newCacheEntry.callbacks = undefined;
-			callback(err, result);
-			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+
+		existingEntries.set(rootModule, true);
+		const imports = getConcatenatedImports(rootModule);
+		for (const { connection, runtimeCondition } of imports)
+			enterModule(connection, runtimeCondition);
+		list.push({
+			type: "concatenated",
+			module: rootModule,
+			runtimeCondition: true
 		});
-	};
-	return resultFn;
-};
 
-class HttpUriPlugin {
+		return list;
+	}
+
 	/**
-	 * @param {HttpUriPluginOptions} options options
+	 * @param {Module} rootModule the root module of the concatenation
+	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @returns {string} the identifier
 	 */
-	constructor(options) {
-		validate(options);
-		this._lockfileLocation = options.lockfileLocation;
-		this._cacheLocation = options.cacheLocation;
-		this._upgrade = options.upgrade;
-		this._frozen = options.frozen;
-		this._allowedUris = options.allowedUris;
+	static _createIdentifier(
+		rootModule,
+		modules,
+		associatedObjectForCache,
+		hashFunction = "md4"
+	) {
+		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
+			rootModule.context,
+			associatedObjectForCache
+		);
+		let identifiers = [];
+		for (const module of modules) {
+			identifiers.push(cachedMakePathsRelative(module.identifier()));
+		}
+		identifiers.sort();
+		const hash = createHash(hashFunction);
+		hash.update(identifiers.join(" "));
+		return rootModule.identifier() + "|" + hash.digest("hex");
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
 	 */
-	apply(compiler) {
-		const schemes = [
-			{
-				scheme: "http",
-				fetch: (url, options, callback) => getHttp().get(url, options, callback)
-			},
-			{
-				scheme: "https",
-				fetch: (url, options, callback) =>
-					getHttps().get(url, options, callback)
-			}
-		];
-		let lockfileCache;
-		compiler.hooks.compilation.tap(
-			"HttpUriPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const intermediateFs = compiler.intermediateFileSystem;
-				const fs = compilation.inputFileSystem;
-				const cache = compilation.getCache("webpack.HttpUriPlugin");
-				const logger = compilation.getLogger("webpack.HttpUriPlugin");
-				const lockfileLocation =
-					this._lockfileLocation ||
-					join(
-						intermediateFs,
-						compiler.context,
-						compiler.name
-							? `${toSafePath(compiler.name)}.webpack.lock`
-							: "webpack.lock"
-					);
-				const cacheLocation =
-					this._cacheLocation !== undefined
-						? this._cacheLocation
-						: lockfileLocation + ".data";
-				const upgrade = this._upgrade || false;
-				const frozen = this._frozen || false;
-				const hashFunction = "sha512";
-				const hashDigest = "hex";
-				const hashDigestLength = 20;
-				const allowedUris = this._allowedUris;
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {
+		for (const module of this._modules) {
+			module.addCacheDependencies(
+				fileDependencies,
+				contextDependencies,
+				missingDependencies,
+				buildDependencies
+			);
+		}
+	}
 
-				let warnedAboutEol = false;
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({
+		dependencyTemplates,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime: generationRuntime,
+		codeGenerationResults
+	}) {
+		/** @type {Set<string>} */
+		const runtimeRequirements = new Set();
+		const runtime = intersectRuntime(generationRuntime, this._runtime);
 
-				const cacheKeyCache = new Map();
-				/**
-				 * @param {string} url the url
-				 * @returns {string} the key
-				 */
-				const getCacheKey = url => {
-					const cachedResult = cacheKeyCache.get(url);
-					if (cachedResult !== undefined) return cachedResult;
-					const result = _getCacheKey(url);
-					cacheKeyCache.set(url, result);
-					return result;
-				};
+		const requestShortener = runtimeTemplate.requestShortener;
+		// Meta info for each module
+		const [modulesWithInfo, moduleToInfoMap] = this._getModulesWithInfo(
+			moduleGraph,
+			runtime
+		);
 
-				/**
-				 * @param {string} url the url
-				 * @returns {string} the key
-				 */
-				const _getCacheKey = url => {
-					const parsedUrl = new URL(url);
-					const folder = toSafePath(parsedUrl.origin);
-					const name = toSafePath(parsedUrl.pathname);
-					const query = toSafePath(parsedUrl.search);
-					let ext = extname(name);
-					if (ext.length > 20) ext = "";
-					const basename = ext ? name.slice(0, -ext.length) : name;
-					const hash = createHash(hashFunction);
-					hash.update(url);
-					const digest = hash.digest(hashDigest).slice(0, hashDigestLength);
-					return `${folder.slice(-50)}/${`${basename}${
-						query ? `_${query}` : ""
-					}`.slice(0, 150)}_${digest}${ext}`;
-				};
+		// Set with modules that need a generated namespace object
+		/** @type {Set<ConcatenatedModuleInfo>} */
+		const neededNamespaceObjects = new Set();
 
-				const getLockfile = cachedWithoutKey(
-					/**
-					 * @param {function((Error | null)=, Lockfile=): void} callback callback
-					 * @returns {void}
-					 */
-					callback => {
-						const readLockfile = () => {
-							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
-								if (err && err.code !== "ENOENT") {
-									compilation.missingDependencies.add(lockfileLocation);
-									return callback(err);
-								}
-								compilation.fileDependencies.add(lockfileLocation);
-								compilation.fileSystemInfo.createSnapshot(
-									compiler.fsStartTime,
-									buffer ? [lockfileLocation] : [],
-									[],
-									buffer ? [] : [lockfileLocation],
-									{ timestamp: true },
-									(err, snapshot) => {
-										if (err) return callback(err);
-										const lockfile = buffer
-											? Lockfile.parse(buffer.toString("utf-8"))
-											: new Lockfile();
-										lockfileCache = {
-											lockfile,
-											snapshot
-										};
-										callback(null, lockfile);
-									}
-								);
-							});
-						};
-						if (lockfileCache) {
-							compilation.fileSystemInfo.checkSnapshotValid(
-								lockfileCache.snapshot,
-								(err, valid) => {
-									if (err) return callback(err);
-									if (!valid) return readLockfile();
-									callback(null, lockfileCache.lockfile);
-								}
-							);
-						} else {
-							readLockfile();
-						}
-					}
-				);
+		// Generate source code and analyse scopes
+		// Prepare a ReplaceSource for the final source
+		for (const info of moduleToInfoMap.values()) {
+			this._analyseModule(
+				moduleToInfoMap,
+				info,
+				dependencyTemplates,
+				runtimeTemplate,
+				moduleGraph,
+				chunkGraph,
+				runtime,
+				codeGenerationResults
+			);
+		}
 
-				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
-				let lockfileUpdates = undefined;
-				const storeLockEntry = (lockfile, url, entry) => {
-					const oldEntry = lockfile.entries.get(url);
-					if (lockfileUpdates === undefined) lockfileUpdates = new Map();
-					lockfileUpdates.set(url, entry);
-					lockfile.entries.set(url, entry);
-					if (!oldEntry) {
-						logger.log(`${url} added to lockfile`);
-					} else if (typeof oldEntry === "string") {
-						if (typeof entry === "string") {
-							logger.log(`${url} updated in lockfile: ${oldEntry} -> ${entry}`);
-						} else {
-							logger.log(
-								`${url} updated in lockfile: ${oldEntry} -> ${entry.resolved}`
-							);
-						}
-					} else if (typeof entry === "string") {
-						logger.log(
-							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry}`
-						);
-					} else if (oldEntry.resolved !== entry.resolved) {
-						logger.log(
-							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry.resolved}`
-						);
-					} else if (oldEntry.integrity !== entry.integrity) {
-						logger.log(`${url} updated in lockfile: content changed`);
-					} else if (oldEntry.contentType !== entry.contentType) {
-						logger.log(
-							`${url} updated in lockfile: ${oldEntry.contentType} -> ${entry.contentType}`
-						);
-					} else {
-						logger.log(`${url} updated in lockfile`);
-					}
+		// List of all used names to avoid conflicts
+		const allUsedNames = new Set(RESERVED_NAMES);
+
+		// List of additional names in scope for module references
+		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
+		const usedNamesInScopeInfo = new Map();
+		/**
+		 * @param {string} module module identifier
+		 * @param {string} id export id
+		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
+		 */
+		const getUsedNamesInScopeInfo = (module, id) => {
+			const key = `${module}-${id}`;
+			let info = usedNamesInScopeInfo.get(key);
+			if (info === undefined) {
+				info = {
+					usedNames: new Set(),
+					alreadyCheckedScopes: new Set()
 				};
+				usedNamesInScopeInfo.set(key, info);
+			}
+			return info;
+		};
 
-				const storeResult = (lockfile, url, result, callback) => {
-					if (result.storeLock) {
-						storeLockEntry(lockfile, url, result.entry);
-						if (!cacheLocation || !result.content)
-							return callback(null, result);
-						const key = getCacheKey(result.entry.resolved);
-						const filePath = join(intermediateFs, cacheLocation, key);
-						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
-							if (err) return callback(err);
-							intermediateFs.writeFile(filePath, result.content, err => {
-								if (err) return callback(err);
-								callback(null, result);
+		// Set of already checked scopes
+		const ignoredScopes = new Set();
+
+		// get all global names
+		for (const info of modulesWithInfo) {
+			if (info.type === "concatenated") {
+				// ignore symbols from moduleScope
+				if (info.moduleScope) {
+					ignoredScopes.add(info.moduleScope);
+				}
+
+				// The super class expression in class scopes behaves weird
+				// We get ranges of all super class expressions to make
+				// renaming to work correctly
+				const superClassCache = new WeakMap();
+				const getSuperClassExpressions = scope => {
+					const cacheEntry = superClassCache.get(scope);
+					if (cacheEntry !== undefined) return cacheEntry;
+					const superClassExpressions = [];
+					for (const childScope of scope.childScopes) {
+						if (childScope.type !== "class") continue;
+						const block = childScope.block;
+						if (
+							(block.type === "ClassDeclaration" ||
+								block.type === "ClassExpression") &&
+							block.superClass
+						) {
+							superClassExpressions.push({
+								range: block.superClass.range,
+								variables: childScope.variables
 							});
-						});
-					} else {
-						storeLockEntry(lockfile, url, "no-cache");
-						callback(null, result);
+						}
 					}
+					superClassCache.set(scope, superClassExpressions);
+					return superClassExpressions;
 				};
 
-				for (const { scheme, fetch } of schemes) {
-					/**
-					 *
-					 * @param {string} url URL
-					 * @param {string} integrity integrity
-					 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
-					 */
-					const resolveContent = (url, integrity, callback) => {
-						const handleResult = (err, result) => {
-							if (err) return callback(err);
-							if ("location" in result) {
-								return resolveContent(
-									result.location,
-									integrity,
-									(err, innerResult) => {
-										if (err) return callback(err);
-										callback(null, {
-											entry: innerResult.entry,
-											content: innerResult.content,
-											storeLock: innerResult.storeLock && result.storeLock
-										});
-									}
-								);
-							} else {
-								if (
-									!result.fresh &&
-									integrity &&
-									result.entry.integrity !== integrity &&
-									!verifyIntegrity(result.content, integrity)
-								) {
-									return fetchContent.force(url, handleResult);
-								}
-								return callback(null, {
-									entry: result.entry,
-									content: result.content,
-									storeLock: result.storeLock
-								});
-							}
-						};
-						fetchContent(url, handleResult);
-					};
-
-					/** @typedef {{ storeCache: boolean, storeLock: boolean, validUntil: number, etag: string | undefined, fresh: boolean }} FetchResultMeta */
-					/** @typedef {FetchResultMeta & { location: string }} RedirectFetchResult */
-					/** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
-					/** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
-
-					/**
-					 * @param {string} url URL
-					 * @param {FetchResult} cachedResult result from cache
-					 * @param {function((Error | null)=, FetchResult=): void} callback callback
-					 * @returns {void}
-					 */
-					const fetchContentRaw = (url, cachedResult, callback) => {
-						const requestTime = Date.now();
-						fetch(
-							new URL(url),
-							{
-								headers: {
-									"accept-encoding": "gzip, deflate, br",
-									"user-agent": "webpack",
-									"if-none-match": cachedResult
-										? cachedResult.etag || null
-										: null
-								}
-							},
-							res => {
-								const etag = res.headers["etag"];
-								const location = res.headers["location"];
-								const cacheControl = res.headers["cache-control"];
-								const { storeLock, storeCache, validUntil } = parseCacheControl(
-									cacheControl,
-									requestTime
+				// add global symbols
+				if (info.globalScope) {
+					for (const reference of info.globalScope.through) {
+						const name = reference.identifier.name;
+						if (ConcatenationScope.isModuleReference(name)) {
+							const match = ConcatenationScope.matchModuleReference(name);
+							if (!match) continue;
+							const referencedInfo = modulesWithInfo[match.index];
+							if (referencedInfo.type === "reference")
+								throw new Error("Module reference can't point to a reference");
+							const binding = getFinalBinding(
+								moduleGraph,
+								referencedInfo,
+								match.ids,
+								moduleToInfoMap,
+								runtime,
+								requestShortener,
+								runtimeTemplate,
+								neededNamespaceObjects,
+								false,
+								info.module.buildMeta.strictHarmonyModule,
+								true
+							);
+							if (!binding.ids) continue;
+							const { usedNames, alreadyCheckedScopes } =
+								getUsedNamesInScopeInfo(
+									binding.info.module.identifier(),
+									"name" in binding ? binding.name : ""
 								);
-								/**
-								 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
-								 * @returns {void}
-								 */
-								const finishWith = partialResult => {
-									if ("location" in partialResult) {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
-										);
-									} else {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] ${Math.ceil(
-												partialResult.content.length / 1024
-											)} kB${!storeLock ? " no-cache" : ""}`
-										);
-									}
-									const result = {
-										...partialResult,
-										fresh: true,
-										storeLock,
-										storeCache,
-										validUntil,
-										etag
-									};
-									if (!storeCache) {
-										logger.log(
-											`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
-										);
-										return callback(null, result);
-									}
-									cache.store(
-										url,
-										null,
-										{
-											...result,
-											fresh: false
-										},
-										err => {
-											if (err) {
-												logger.warn(
-													`${url} can't be stored in cache: ${err.message}`
-												);
-												logger.debug(err.stack);
-											}
-											callback(null, result);
-										}
-									);
-								};
-								if (res.statusCode === 304) {
-									if (
-										cachedResult.validUntil < validUntil ||
-										cachedResult.storeLock !== storeLock ||
-										cachedResult.storeCache !== storeCache ||
-										cachedResult.etag !== etag
-									) {
-										return finishWith(cachedResult);
-									} else {
-										logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-										return callback(null, {
-											...cachedResult,
-											fresh: true
-										});
-									}
-								}
+							for (const expr of getSuperClassExpressions(reference.from)) {
 								if (
-									location &&
-									res.statusCode >= 301 &&
-									res.statusCode <= 308
+									expr.range[0] <= reference.identifier.range[0] &&
+									expr.range[1] >= reference.identifier.range[1]
 								) {
-									return finishWith({
-										location: new URL(location, url).href
-									});
-								}
-								const contentType = res.headers["content-type"] || "";
-								const bufferArr = [];
-
-								const contentEncoding = res.headers["content-encoding"];
-								let stream = res;
-								if (contentEncoding === "gzip") {
-									stream = stream.pipe(createGunzip());
-								} else if (contentEncoding === "br") {
-									stream = stream.pipe(createBrotliDecompress());
-								} else if (contentEncoding === "deflate") {
-									stream = stream.pipe(createInflate());
-								}
-
-								stream.on("data", chunk => {
-									bufferArr.push(chunk);
-								});
-
-								stream.on("end", () => {
-									if (!res.complete) {
-										logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
-										return callback(new Error(`${url} request was terminated`));
-									}
-
-									const content = Buffer.concat(bufferArr);
-
-									if (res.statusCode !== 200) {
-										logger.log(`GET ${url} [${res.statusCode}]`);
-										return callback(
-											new Error(
-												`${url} request status code = ${
-													res.statusCode
-												}\n${content.toString("utf-8")}`
-											)
-										);
+									for (const variable of expr.variables) {
+										usedNames.add(variable.name);
 									}
-
-									const integrity = computeIntegrity(content);
-									const entry = { resolved: url, integrity, contentType };
-
-									finishWith({
-										entry,
-										content
-									});
-								});
-							}
-						).on("error", err => {
-							logger.log(`GET ${url} (error)`);
-							err.message += `\nwhile fetching ${url}`;
-							callback(err);
-						});
-					};
-
-					const fetchContent = cachedWithKey(
-						/**
-						 * @param {string} url URL
-						 * @param {function((Error | null)=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
-						 * @returns {void}
-						 */ (url, callback) => {
-							cache.get(url, null, (err, cachedResult) => {
-								if (err) return callback(err);
-								if (cachedResult) {
-									const isValid = cachedResult.validUntil >= Date.now();
-									if (isValid) return callback(null, cachedResult);
 								}
-								fetchContentRaw(url, cachedResult, callback);
-							});
-						},
-						(url, callback) => fetchContentRaw(url, undefined, callback)
-					);
-
-					const isAllowed = uri => {
-						for (const allowed of allowedUris) {
-							if (typeof allowed === "string") {
-								if (uri.startsWith(allowed)) return true;
-							} else if (typeof allowed === "function") {
-								if (allowed(uri)) return true;
-							} else {
-								if (allowed.test(uri)) return true;
 							}
+							addScopeSymbols(
+								reference.from,
+								usedNames,
+								alreadyCheckedScopes,
+								ignoredScopes
+							);
+						} else {
+							allUsedNames.add(name);
 						}
-						return false;
-					};
+					}
+				}
+			}
+		}
 
-					const getInfo = cachedWithKey(
-						/**
-						 * @param {string} url the url
-						 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
-						 * @returns {void}
-						 */
-						(url, callback) => {
-							if (!isAllowed(url)) {
-								return callback(
-									new Error(
-										`${url} doesn't match the allowedUris policy. These URIs are allowed:\n${allowedUris
-											.map(uri => ` - ${uri}`)
-											.join("\n")}`
-									)
+		// generate names for symbols
+		for (const info of moduleToInfoMap.values()) {
+			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
+				info.module.identifier(),
+				""
+			);
+			switch (info.type) {
+				case "concatenated": {
+					for (const variable of info.moduleScope.variables) {
+						const name = variable.name;
+						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+							info.module.identifier(),
+							name
+						);
+						if (allUsedNames.has(name) || usedNames.has(name)) {
+							const references = getAllReferences(variable);
+							for (const ref of references) {
+								addScopeSymbols(
+									ref.from,
+									usedNames,
+									alreadyCheckedScopes,
+									ignoredScopes
 								);
 							}
-							getLockfile((err, lockfile) => {
-								if (err) return callback(err);
-								const entryOrString = lockfile.entries.get(url);
-								if (!entryOrString) {
-									if (frozen) {
-										return callback(
-											new Error(
-												`${url} has no lockfile entry and lockfile is frozen`
-											)
-										);
+							const newName = this.findNewName(
+								name,
+								allUsedNames,
+								usedNames,
+								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) {
+									const maybeProperty =
+										path[1].type === "AssignmentPattern" &&
+										path[1].left === path[0]
+											? path[2]
+											: path[1];
+									if (
+										maybeProperty.type === "Property" &&
+										maybeProperty.shorthand
+									) {
+										source.insert(r[1], `: ${newName}`);
+										continue;
 									}
-									resolveContent(url, null, (err, result) => {
-										if (err) return callback(err);
-										storeResult(lockfile, url, result, callback);
-									});
-									return;
-								}
-								if (typeof entryOrString === "string") {
-									const entryTag = entryOrString;
-									resolveContent(url, null, (err, result) => {
-										if (err) return callback(err);
-										if (!result.storeLock || entryTag === "ignore")
-											return callback(null, result);
-										if (frozen) {
-											return callback(
-												new Error(
-													`${url} used to have ${entryTag} lockfile entry and has content now, but lockfile is frozen`
-												)
-											);
-										}
-										if (!upgrade) {
-											return callback(
-												new Error(
-													`${url} used to have ${entryTag} lockfile entry and has content now.
-This should be reflected in the lockfile, so this lockfile entry must be upgraded, but upgrading is not enabled.
-Remove this line from the lockfile to force upgrading.`
-												)
-											);
-										}
-										storeResult(lockfile, url, result, callback);
-									});
-									return;
-								}
-								let entry = entryOrString;
-								const doFetch = lockedContent => {
-									resolveContent(url, entry.integrity, (err, result) => {
-										if (err) {
-											if (lockedContent) {
-												logger.warn(
-													`Upgrade request to ${url} failed: ${err.message}`
-												);
-												logger.debug(err.stack);
-												return callback(null, {
-													entry,
-													content: lockedContent
-												});
-											}
-											return callback(err);
-										}
-										if (!result.storeLock) {
-											// When the lockfile entry should be no-cache
-											// we need to update the lockfile
-											if (frozen) {
-												return callback(
-													new Error(
-														`${url} has a lockfile entry and is no-cache now, but lockfile is frozen\nLockfile: ${entryToString(
-															entry
-														)}`
-													)
-												);
-											}
-											storeResult(lockfile, url, result, callback);
-											return;
-										}
-										if (!areLockfileEntriesEqual(result.entry, entry)) {
-											// When the lockfile entry is outdated
-											// we need to update the lockfile
-											if (frozen) {
-												return callback(
-													new Error(
-														`${url} has an outdated lockfile entry, but lockfile is frozen\nLockfile: ${entryToString(
-															entry
-														)}\nExpected: ${entryToString(result.entry)}`
-													)
-												);
-											}
-											storeResult(lockfile, url, result, callback);
-											return;
-										}
-										if (!lockedContent && cacheLocation) {
-											// When the lockfile cache content is missing
-											// we need to update the lockfile
-											if (frozen) {
-												return callback(
-													new Error(
-														`${url} is missing content in the lockfile cache, but lockfile is frozen\nLockfile: ${entryToString(
-															entry
-														)}`
-													)
-												);
-											}
-											storeResult(lockfile, url, result, callback);
-											return;
-										}
-										return callback(null, result);
-									});
-								};
-								if (cacheLocation) {
-									// When there is a lockfile cache
-									// we read the content from there
-									const key = getCacheKey(entry.resolved);
-									const filePath = join(intermediateFs, cacheLocation, key);
-									fs.readFile(filePath, (err, result) => {
-										const content = /** @type {Buffer} */ (result);
-										if (err) {
-											if (err.code === "ENOENT") return doFetch();
-											return callback(err);
-										}
-										const continueWithCachedContent = result => {
-											if (!upgrade) {
-												// When not in upgrade mode, we accept the result from the lockfile cache
-												return callback(null, { entry, content });
-											}
-											return doFetch(content);
-										};
-										if (!verifyIntegrity(content, entry.integrity)) {
-											let contentWithChangedEol;
-											let isEolChanged = false;
-											try {
-												contentWithChangedEol = Buffer.from(
-													content.toString("utf-8").replace(/\r\n/g, "\n")
-												);
-												isEolChanged = verifyIntegrity(
-													contentWithChangedEol,
-													entry.integrity
-												);
-											} catch (e) {
-												// ignore
-											}
-											if (isEolChanged) {
-												if (!warnedAboutEol) {
-													const explainer = `Incorrect end of line sequence was detected in the lockfile cache.
-The lockfile cache is protected by integrity checks, so any external modification will lead to a corrupted lockfile cache.
-When using git make sure to configure .gitattributes correctly for the lockfile cache:
-  **/*webpack.lock.data/** -text
-This will avoid that the end of line sequence is changed by git on Windows.`;
-													if (frozen) {
-														logger.error(explainer);
-													} else {
-														logger.warn(explainer);
-														logger.info(
-															"Lockfile cache will be automatically fixed now, but when lockfile is frozen this would result in an error."
-														);
-													}
-													warnedAboutEol = true;
-												}
-												if (!frozen) {
-													// "fix" the end of line sequence of the lockfile content
-													logger.log(
-														`${filePath} fixed end of line sequence (\\r\\n instead of \\n).`
-													);
-													intermediateFs.writeFile(
-														filePath,
-														contentWithChangedEol,
-														err => {
-															if (err) return callback(err);
-															continueWithCachedContent(contentWithChangedEol);
-														}
-													);
-													return;
-												}
-											}
-											if (frozen) {
-												return callback(
-													new Error(
-														`${
-															entry.resolved
-														} integrity mismatch, expected content with integrity ${
-															entry.integrity
-														} but got ${computeIntegrity(content)}.
-Lockfile corrupted (${
-															isEolChanged
-																? "end of line sequence was unexpectedly changed"
-																: "incorrectly merged? changed by other tools?"
-														}).
-Run build with un-frozen lockfile to automatically fix lockfile.`
-													)
-												);
-											} else {
-												// "fix" the lockfile entry to the correct integrity
-												// the content has priority over the integrity value
-												entry = {
-													...entry,
-													integrity: computeIntegrity(content)
-												};
-												storeLockEntry(lockfile, url, entry);
-											}
-										}
-										continueWithCachedContent(result);
-									});
-								} else {
-									doFetch();
 								}
-							});
+								source.replace(r[0], r[1] - 1, newName);
+							}
+						} else {
+							allUsedNames.add(name);
+							info.internalNames.set(name, name);
 						}
+					}
+					let namespaceObjectName;
+					if (info.namespaceExportSymbol) {
+						namespaceObjectName = info.internalNames.get(
+							info.namespaceExportSymbol
+						);
+					} else {
+						namespaceObjectName = this.findNewName(
+							"namespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(namespaceObjectName);
+					}
+					info.namespaceObjectName = namespaceObjectName;
+					break;
+				}
+				case "external": {
+					const externalName = this.findNewName(
+						"",
+						allUsedNames,
+						namespaceObjectUsedNames,
+						info.module.readableIdentifier(requestShortener)
+					);
+					allUsedNames.add(externalName);
+					info.name = externalName;
+					break;
+				}
+			}
+			if (info.module.buildMeta.exportsType !== "namespace") {
+				const externalNameInterop = this.findNewName(
+					"namespaceObject",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopNamespaceObjectName = externalNameInterop;
+			}
+			if (
+				info.module.buildMeta.exportsType === "default" &&
+				info.module.buildMeta.defaultObject !== "redirect"
+			) {
+				const externalNameInterop = this.findNewName(
+					"namespaceObject2",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopNamespaceObject2Name = externalNameInterop;
+			}
+			if (
+				info.module.buildMeta.exportsType === "dynamic" ||
+				!info.module.buildMeta.exportsType
+			) {
+				const externalNameInterop = this.findNewName(
+					"default",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopDefaultAccessName = externalNameInterop;
+			}
+		}
+
+		// Find and replace references to modules
+		for (const info of moduleToInfoMap.values()) {
+			if (info.type === "concatenated") {
+				for (const reference of info.globalScope.through) {
+					const name = reference.identifier.name;
+					const match = ConcatenationScope.matchModuleReference(name);
+					if (match) {
+						const referencedInfo = modulesWithInfo[match.index];
+						if (referencedInfo.type === "reference")
+							throw new Error("Module reference can't point to a reference");
+						const finalName = getFinalName(
+							moduleGraph,
+							referencedInfo,
+							match.ids,
+							moduleToInfoMap,
+							runtime,
+							requestShortener,
+							runtimeTemplate,
+							neededNamespaceObjects,
+							match.call,
+							!match.directImport,
+							info.module.buildMeta.strictHarmonyModule,
+							match.asiSafe
+						);
+						const r = reference.identifier.range;
+						const source = info.source;
+						// range is extended by 2 chars to cover the appended "._"
+						source.replace(r[0], r[1] + 1, finalName);
+					}
+				}
+			}
+		}
+
+		// Map with all root exposed used exports
+		/** @type {Map<string, function(RequestShortener): string>} */
+		const exportsMap = new Map();
+
+		// Set with all root exposed unused exports
+		/** @type {Set<string>} */
+		const unusedExports = new Set();
+
+		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
+			moduleToInfoMap.get(this.rootModule)
+		);
+		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
+		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const name = exportInfo.name;
+			if (exportInfo.provided === false) continue;
+			const used = exportInfo.getUsedName(undefined, runtime);
+			if (!used) {
+				unusedExports.add(name);
+				continue;
+			}
+			exportsMap.set(used, requestShortener => {
+				try {
+					const finalName = getFinalName(
+						moduleGraph,
+						rootInfo,
+						[name],
+						moduleToInfoMap,
+						runtime,
+						requestShortener,
+						runtimeTemplate,
+						neededNamespaceObjects,
+						false,
+						false,
+						strictHarmonyModule,
+						true
 					);
+					return `/* ${
+						exportInfo.isReexport() ? "reexport" : "binding"
+					} */ ${finalName}`;
+				} catch (e) {
+					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
+					throw e;
+				}
+			});
+		}
 
-					const respondWithUrlModule = (url, resourceData, callback) => {
-						getInfo(url.href, (err, result) => {
-							if (err) return callback(err);
-							resourceData.resource = url.href;
-							resourceData.path = url.origin + url.pathname;
-							resourceData.query = url.search;
-							resourceData.fragment = url.hash;
-							resourceData.context = new URL(
-								".",
-								result.entry.resolved
-							).href.slice(0, -1);
-							resourceData.data.mimetype = result.entry.contentType;
-							callback(null, true);
-						});
-					};
-					normalModuleFactory.hooks.resolveForScheme
-						.for(scheme)
-						.tapAsync(
-							"HttpUriPlugin",
-							(resourceData, resolveData, callback) => {
-								respondWithUrlModule(
-									new URL(resourceData.resource),
-									resourceData,
-									callback
-								);
-							}
-						);
-					normalModuleFactory.hooks.resolveInScheme
-						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
-							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
-							if (
-								data.dependencyType !== "url" &&
-								!/^\.{0,2}\//.test(resourceData.resource)
-							) {
-								return callback();
-							}
-							respondWithUrlModule(
-								new URL(resourceData.resource, data.context + "/"),
-								resourceData,
-								callback
-							);
-						});
-					const hooks = NormalModule.getCompilationHooks(compilation);
-					hooks.readResourceForScheme
-						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resource, module, callback) => {
-							return getInfo(resource, (err, result) => {
-								if (err) return callback(err);
-								module.buildInfo.resourceIntegrity = result.entry.integrity;
-								callback(null, result.content);
-							});
-						});
-					hooks.needBuild.tapAsync(
-						"HttpUriPlugin",
-						(module, context, callback) => {
-							if (
-								module.resource &&
-								module.resource.startsWith(`${scheme}://`)
-							) {
-								getInfo(module.resource, (err, result) => {
-									if (err) return callback(err);
-									if (
-										result.entry.integrity !==
-										module.buildInfo.resourceIntegrity
-									) {
-										return callback(null, true);
-									}
-									callback();
-								});
-							} else {
-								return callback();
-							}
-						}
+		const result = new ConcatSource();
+
+		// add harmony compatibility flag (must be first because of possible circular dependencies)
+		if (
+			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
+			UsageState.Unused
+		) {
+			result.add(`// ESM COMPAT FLAG\n`);
+			result.add(
+				runtimeTemplate.defineEsModuleFlagStatement({
+					exportsArgument: this.exportsArgument,
+					runtimeRequirements
+				})
+			);
+		}
+
+		// define exports
+		if (exportsMap.size > 0) {
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			const definitions = [];
+			for (const [key, value] of exportsMap) {
+				definitions.push(
+					`\n  ${JSON.stringify(key)}: ${runtimeTemplate.returningFunction(
+						value(requestShortener)
+					)}`
+				);
+			}
+			result.add(`\n// EXPORTS\n`);
+			result.add(
+				`${RuntimeGlobals.definePropertyGetters}(${
+					this.exportsArgument
+				}, {${definitions.join(",")}\n});\n`
+			);
+		}
+
+		// list unused exports
+		if (unusedExports.size > 0) {
+			result.add(
+				`\n// UNUSED EXPORTS: ${joinIterableWithComma(unusedExports)}\n`
+			);
+		}
+
+		// generate namespace objects
+		const namespaceObjectSources = new Map();
+		for (const info of neededNamespaceObjects) {
+			if (info.namespaceExportSymbol) continue;
+			const nsObj = [];
+			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (exportInfo.provided === false) continue;
+				const usedName = exportInfo.getUsedName(undefined, runtime);
+				if (usedName) {
+					const finalName = getFinalName(
+						moduleGraph,
+						info,
+						[exportInfo.name],
+						moduleToInfoMap,
+						runtime,
+						requestShortener,
+						runtimeTemplate,
+						neededNamespaceObjects,
+						false,
+						undefined,
+						info.module.buildMeta.strictHarmonyModule,
+						true
+					);
+					nsObj.push(
+						`\n  ${JSON.stringify(
+							usedName
+						)}: ${runtimeTemplate.returningFunction(finalName)}`
 					);
 				}
-				compilation.hooks.finishModules.tapAsync(
-					"HttpUriPlugin",
-					(modules, callback) => {
-						if (!lockfileUpdates) return callback();
-						const ext = extname(lockfileLocation);
-						const tempFile = join(
-							intermediateFs,
-							dirname(intermediateFs, lockfileLocation),
-							`.${basename(lockfileLocation, ext)}.${
-								(Math.random() * 10000) | 0
-							}${ext}`
-						);
+			}
+			const name = info.namespaceObjectName;
+			const defineGetters =
+				nsObj.length > 0
+					? `${RuntimeGlobals.definePropertyGetters}(${name}, {${nsObj.join(
+							","
+					  )}\n});\n`
+					: "";
+			if (nsObj.length > 0)
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			namespaceObjectSources.set(
+				info,
+				`
+// NAMESPACE OBJECT: ${info.module.readableIdentifier(requestShortener)}
+var ${name} = {};
+${RuntimeGlobals.makeNamespaceObject}(${name});
+${defineGetters}`
+			);
+			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		}
 
-						const writeDone = () => {
-							const nextOperation = inProgressWrite.shift();
-							if (nextOperation) {
-								nextOperation();
-							} else {
-								inProgressWrite = undefined;
-							}
-						};
-						const runWrite = () => {
-							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
-								if (err && err.code !== "ENOENT") {
-									writeDone();
-									return callback(err);
-								}
-								const lockfile = buffer
-									? Lockfile.parse(buffer.toString("utf-8"))
-									: new Lockfile();
-								for (const [key, value] of lockfileUpdates) {
-									lockfile.entries.set(key, value);
-								}
-								intermediateFs.writeFile(tempFile, lockfile.toString(), err => {
-									if (err) {
-										writeDone();
-										return intermediateFs.unlink(tempFile, () => callback(err));
-									}
-									intermediateFs.rename(tempFile, lockfileLocation, err => {
-										if (err) {
-											writeDone();
-											return intermediateFs.unlink(tempFile, () =>
-												callback(err)
-											);
-										}
-										writeDone();
-										callback();
-									});
-								});
-							});
-						};
-						if (inProgressWrite) {
-							inProgressWrite.push(runWrite);
-						} else {
-							inProgressWrite = [];
-							runWrite();
+		// define required namespace objects (must be before evaluation modules)
+		for (const info of modulesWithInfo) {
+			if (info.type === "concatenated") {
+				const source = namespaceObjectSources.get(info);
+				if (!source) continue;
+				result.add(source);
+			}
+		}
+
+		const chunkInitFragments = [];
+
+		// evaluate modules in order
+		for (const rawInfo of modulesWithInfo) {
+			let name;
+			let isConditional = false;
+			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
+			switch (info.type) {
+				case "concatenated": {
+					result.add(
+						`\n;// CONCATENATED MODULE: ${info.module.readableIdentifier(
+							requestShortener
+						)}\n`
+					);
+					result.add(info.source);
+					if (info.chunkInitFragments) {
+						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
+					}
+					if (info.runtimeRequirements) {
+						for (const r of info.runtimeRequirements) {
+							runtimeRequirements.add(r);
 						}
 					}
+					name = info.namespaceObjectName;
+					break;
+				}
+				case "external": {
+					result.add(
+						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
+							requestShortener
+						)}\n`
+					);
+					runtimeRequirements.add(RuntimeGlobals.require);
+					const { runtimeCondition } =
+						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
+					const condition = runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition,
+						runtime,
+						runtimeRequirements
+					});
+					if (condition !== "true") {
+						isConditional = true;
+						result.add(`if (${condition}) {\n`);
+					}
+					result.add(
+						`var ${info.name} = __webpack_require__(${JSON.stringify(
+							chunkGraph.getModuleId(info.module)
+						)});`
+					);
+					name = info.name;
+					break;
+				}
+				default:
+					// @ts-expect-error never is expected here
+					throw new Error(`Unsupported concatenation entry type ${info.type}`);
+			}
+			if (info.interopNamespaceObjectUsed) {
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				result.add(
+					`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
 				);
 			}
-		);
+			if (info.interopNamespaceObject2Used) {
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				result.add(
+					`\nvar ${info.interopNamespaceObject2Name} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
+				);
+			}
+			if (info.interopDefaultAccessUsed) {
+				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+				result.add(
+					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
+				);
+			}
+			if (isConditional) {
+				result.add("\n}");
+			}
+		}
+
+		const data = new Map();
+		if (chunkInitFragments.length > 0)
+			data.set("chunkInitFragments", chunkInitFragments);
+
+		/** @type {CodeGenerationResult} */
+		const resultEntry = {
+			sources: new Map([["javascript", new CachedSource(result)]]),
+			data,
+			runtimeRequirements
+		};
+
+		return resultEntry;
 	}
-}
 
-module.exports = HttpUriPlugin;
+	/**
+	 * @param {Map<Module, ModuleInfo>} modulesMap modulesMap
+	 * @param {ModuleInfo} info info
+	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+	 * @param {ModuleGraph} moduleGraph moduleGraph
+	 * @param {ChunkGraph} chunkGraph chunkGraph
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
+	 */
+	_analyseModule(
+		modulesMap,
+		info,
+		dependencyTemplates,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime,
+		codeGenerationResults
+	) {
+		if (info.type === "concatenated") {
+			const m = info.module;
+			try {
+				// Create a concatenation scope to track and capture information
+				const concatenationScope = new ConcatenationScope(modulesMap, info);
 
+				// TODO cache codeGeneration results
+				const codeGenResult = m.codeGeneration({
+					dependencyTemplates,
+					runtimeTemplate,
+					moduleGraph,
+					chunkGraph,
+					runtime,
+					concatenationScope,
+					codeGenerationResults
+				});
+				const source = codeGenResult.sources.get("javascript");
+				const data = codeGenResult.data;
+				const chunkInitFragments = data && data.get("chunkInitFragments");
+				const code = source.source().toString();
+				let ast;
+				try {
+					ast = JavascriptParser._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.runtimeRequirements = codeGenResult.runtimeRequirements;
+				info.ast = ast;
+				info.internalSource = source;
+				info.source = resultSource;
+				info.chunkInitFragments = chunkInitFragments;
+				info.globalScope = globalScope;
+				info.moduleScope = moduleScope;
+			} catch (err) {
+				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
+				throw err;
+			}
+		}
+	}
 
-/***/ }),
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {[ModuleInfoOrReference[], Map<Module, ModuleInfo>]} module info items
+	 */
+	_getModulesWithInfo(moduleGraph, runtime) {
+		const orderedConcatenationList = this._createConcatenationList(
+			this.rootModule,
+			this._modules,
+			runtime,
+			moduleGraph
+		);
+		/** @type {Map<Module, ModuleInfo>} */
+		const map = new Map();
+		const list = orderedConcatenationList.map((info, index) => {
+			let item = map.get(info.module);
+			if (item === undefined) {
+				switch (info.type) {
+					case "concatenated":
+						item = {
+							type: "concatenated",
+							module: info.module,
+							index,
+							ast: undefined,
+							internalSource: undefined,
+							runtimeRequirements: undefined,
+							source: undefined,
+							globalScope: undefined,
+							moduleScope: undefined,
+							internalNames: new Map(),
+							exportMap: undefined,
+							rawExportMap: undefined,
+							namespaceExportSymbol: undefined,
+							namespaceObjectName: undefined,
+							interopNamespaceObjectUsed: false,
+							interopNamespaceObjectName: undefined,
+							interopNamespaceObject2Used: false,
+							interopNamespaceObject2Name: undefined,
+							interopDefaultAccessUsed: false,
+							interopDefaultAccessName: undefined
+						};
+						break;
+					case "external":
+						item = {
+							type: "external",
+							module: info.module,
+							runtimeCondition: info.runtimeCondition,
+							index,
+							name: undefined,
+							interopNamespaceObjectUsed: false,
+							interopNamespaceObjectName: undefined,
+							interopNamespaceObject2Used: false,
+							interopNamespaceObject2Name: undefined,
+							interopDefaultAccessUsed: false,
+							interopDefaultAccessName: undefined
+						};
+						break;
+					default:
+						throw new Error(
+							`Unsupported concatenation entry type ${info.type}`
+						);
+				}
+				map.set(item.module, item);
+				return item;
+			} else {
+				/** @type {ReferenceToModuleInfo} */
+				const ref = {
+					type: "reference",
+					runtimeCondition: info.runtimeCondition,
+					target: item
+				};
+				return ref;
+			}
+		});
+		return [list, map];
+	}
 
-/***/ 41721:
-/***/ (function(module) {
+	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
+		let name = oldName;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+		if (name === ConcatenationScope.DEFAULT_EXPORT) {
+			name = "";
+		}
+		if (name === ConcatenationScope.NAMESPACE_OBJECT_EXPORT) {
+			name = "namespaceObject";
+		}
 
+		// 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;
+		}
 
-class ArraySerializer {
-	serialize(array, { write }) {
-		write(array.length);
-		for (const item of array) write(item);
+		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;
 	}
-	deserialize({ read }) {
-		const length = read();
-		const array = [];
-		for (let i = 0; i < length; i++) {
-			array.push(read());
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		for (const info of this._createConcatenationList(
+			this.rootModule,
+			this._modules,
+			intersectRuntime(runtime, this._runtime),
+			chunkGraph.moduleGraph
+		)) {
+			switch (info.type) {
+				case "concatenated":
+					info.module.updateHash(hash, context);
+					break;
+				case "external":
+					hash.update(`${chunkGraph.getModuleId(info.module)}`);
+					// TODO runtimeCondition
+					break;
+			}
 		}
-		return array;
+		super.updateHash(hash, context);
+	}
+
+	static deserialize(context) {
+		const obj = new ConcatenatedModule({
+			identifier: undefined,
+			rootModule: undefined,
+			modules: undefined,
+			runtime: undefined
+		});
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-module.exports = ArraySerializer;
+makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
+
+module.exports = ConcatenatedModule;
 
 
 /***/ }),
 
-/***/ 97059:
+/***/ 96260:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const memoize = __webpack_require__(78676);
-const SerializerMiddleware = __webpack_require__(83137);
-
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
-
-/*
-Format:
-
-File -> Section*
-
-Section -> NullsSection |
-					 BooleansSection |
-					 F64NumbersSection |
-					 I32NumbersSection |
-					 I8NumbersSection |
-					 ShortStringSection |
-					 StringSection |
-					 BufferSection |
-					 NopSection
-
-
-
-NullsSection ->
-	NullHeaderByte | Null2HeaderByte | Null3HeaderByte |
-	Nulls8HeaderByte 0xnn (n:count - 4) |
-	Nulls32HeaderByte n:ui32 (n:count - 260) |
-BooleansSection -> TrueHeaderByte | FalseHeaderByte | BooleansSectionHeaderByte BooleansCountAndBitsByte
-F64NumbersSection -> F64NumbersSectionHeaderByte f64*
-I32NumbersSection -> I32NumbersSectionHeaderByte i32*
-I8NumbersSection -> I8NumbersSectionHeaderByte i8*
-ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
-StringSection -> StringSectionHeaderByte i32:length utf8-byte*
-BufferSection -> BufferSectionHeaderByte i32:length byte*
-NopSection --> NopSectionHeaderByte
-
-ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
-
-F64NumbersSectionHeaderByte -> 0b001n_nnnn (n:count - 1)
-I32NumbersSectionHeaderByte -> 0b010n_nnnn (n:count - 1)
-I8NumbersSectionHeaderByte -> 0b011n_nnnn (n:count - 1)
-
-NullsSectionHeaderByte -> 0b0001_nnnn (n:count - 1)
-BooleansCountAndBitsByte ->
-	0b0000_1xxx (count = 3) |
-	0b0001_xxxx (count = 4) |
-	0b001x_xxxx (count = 5) |
-	0b01xx_xxxx (count = 6) |
-	0b1nnn_nnnn (n:count - 7, 7 <= count <= 133)
-	0xff n:ui32 (n:count, 134 <= count < 2^32)
-
-StringSectionHeaderByte -> 0b0000_1110
-BufferSectionHeaderByte -> 0b0000_1111
-NopSectionHeaderByte -> 0b0000_1011
-FalseHeaderByte -> 0b0000_1100
-TrueHeaderByte -> 0b0000_1101
-
-RawNumber -> n (n <= 10)
-
-*/
-
-const LAZY_HEADER = 0x0b;
-const TRUE_HEADER = 0x0c;
-const FALSE_HEADER = 0x0d;
-const BOOLEANS_HEADER = 0x0e;
-const NULL_HEADER = 0x10;
-const NULL2_HEADER = 0x11;
-const NULL3_HEADER = 0x12;
-const NULLS8_HEADER = 0x13;
-const NULLS32_HEADER = 0x14;
-const NULL_AND_I8_HEADER = 0x15;
-const NULL_AND_I32_HEADER = 0x16;
-const NULL_AND_TRUE_HEADER = 0x17;
-const NULL_AND_FALSE_HEADER = 0x18;
-const STRING_HEADER = 0x1e;
-const BUFFER_HEADER = 0x1f;
-const I8_HEADER = 0x60;
-const I32_HEADER = 0x40;
-const F64_HEADER = 0x20;
-const SHORT_STRING_HEADER = 0x80;
-
-/** Uplift high-order bits */
-const NUMBERS_HEADER_MASK = 0xe0;
-const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
-const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
-
-const HEADER_SIZE = 1;
-const I8_SIZE = 1;
-const I32_SIZE = 4;
-const F64_SIZE = 8;
-
-const MEASURE_START_OPERATION = Symbol("MEASURE_START_OPERATION");
-const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
-
-/** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
-/** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
-
-const identifyNumber = n => {
-	if (n === (n | 0)) {
-		if (n <= 127 && n >= -128) return 0;
-		if (n <= 2147483647 && n >= -2147483648) return 1;
-	}
-	return 2;
-};
-
-/**
- * @typedef {PrimitiveSerializableType[]} DeserializedType
- * @typedef {BufferSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class BinaryMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		return this._serialize(data, context);
-	}
+const { STAGE_BASIC } = __webpack_require__(80057);
 
-	_serializeLazy(fn, context) {
-		return SerializerMiddleware.serializeLazy(fn, data =>
-			this._serialize(data, context)
-		);
-	}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compiler")} Compiler */
 
+class EnsureChunkConditionsPlugin {
 	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
-	 * @returns {SerializedType} serialized data
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	_serialize(
-		data,
-		context,
-		allocationScope = {
-			allocationSize: 1024,
-			increaseCounter: 0,
-			leftOverBuffer: null
-		}
-	) {
-		/** @type {Buffer} */
-		let leftOverBuffer = null;
-		/** @type {BufferSerializableType[]} */
-		let buffers = [];
-		/** @type {Buffer} */
-		let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
-		allocationScope.leftOverBuffer = null;
-		let currentPosition = 0;
-		if (currentBuffer === null) {
-			currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
-		}
-		const allocate = bytesNeeded => {
-			if (currentBuffer !== null) {
-				if (currentBuffer.length - currentPosition >= bytesNeeded) return;
-				flush();
-			}
-			if (leftOverBuffer && leftOverBuffer.length >= bytesNeeded) {
-				currentBuffer = leftOverBuffer;
-				leftOverBuffer = null;
-			} else {
-				currentBuffer = Buffer.allocUnsafe(
-					Math.max(bytesNeeded, allocationScope.allocationSize)
-				);
-				if (
-					!(allocationScope.increaseCounter =
-						(allocationScope.increaseCounter + 1) % 4) &&
-					allocationScope.allocationSize < 16777216
-				) {
-					allocationScope.allocationSize = allocationScope.allocationSize << 1;
-				}
-			}
-		};
-		const flush = () => {
-			if (currentBuffer !== null) {
-				if (currentPosition > 0) {
-					buffers.push(
-						Buffer.from(
-							currentBuffer.buffer,
-							currentBuffer.byteOffset,
-							currentPosition
-						)
-					);
-				}
-				if (
-					!leftOverBuffer ||
-					leftOverBuffer.length < currentBuffer.length - currentPosition
-				) {
-					leftOverBuffer = Buffer.from(
-						currentBuffer.buffer,
-						currentBuffer.byteOffset + currentPosition,
-						currentBuffer.byteLength - currentPosition
-					);
-				}
-
-				currentBuffer = null;
-				currentPosition = 0;
-			}
-		};
-		const writeU8 = byte => {
-			currentBuffer.writeUInt8(byte, currentPosition++);
-		};
-		const writeU32 = ui32 => {
-			currentBuffer.writeUInt32LE(ui32, currentPosition);
-			currentPosition += 4;
-		};
-		const measureStack = [];
-		const measureStart = () => {
-			measureStack.push(buffers.length, currentPosition);
-		};
-		const measureEnd = () => {
-			const oldPos = measureStack.pop();
-			const buffersIndex = measureStack.pop();
-			let size = currentPosition - oldPos;
-			for (let i = buffersIndex; i < buffers.length; i++) {
-				size += buffers[i].length;
-			}
-			return size;
-		};
-		for (let i = 0; i < data.length; i++) {
-			const thing = data[i];
-			switch (typeof thing) {
-				case "function": {
-					if (!SerializerMiddleware.isLazy(thing))
-						throw new Error("Unexpected function " + thing);
-					/** @type {SerializedType | (() => SerializedType)} */
-					let serializedData =
-						SerializerMiddleware.getLazySerializedValue(thing);
-					if (serializedData === undefined) {
-						if (SerializerMiddleware.isLazy(thing, this)) {
-							flush();
-							allocationScope.leftOverBuffer = leftOverBuffer;
-							const result =
-								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
-									thing()
-								);
-							const data = this._serialize(result, context, allocationScope);
-							leftOverBuffer = allocationScope.leftOverBuffer;
-							allocationScope.leftOverBuffer = null;
-							SerializerMiddleware.setLazySerializedValue(thing, data);
-							serializedData = data;
-						} else {
-							serializedData = this._serializeLazy(thing, context);
-							flush();
-							buffers.push(serializedData);
-							break;
-						}
-					} else {
-						if (typeof serializedData === "function") {
-							flush();
-							buffers.push(serializedData);
-							break;
-						}
-					}
-					const lengths = [];
-					for (const item of serializedData) {
-						let last;
-						if (typeof item === "function") {
-							lengths.push(0);
-						} else if (item.length === 0) {
-							// ignore
-						} else if (
-							lengths.length > 0 &&
-							(last = lengths[lengths.length - 1]) !== 0
-						) {
-							const remaining = 0xffffffff - last;
-							if (remaining >= item.length) {
-								lengths[lengths.length - 1] += item.length;
-							} else {
-								lengths.push(item.length - remaining);
-								lengths[lengths.length - 2] = 0xffffffff;
-							}
-						} else {
-							lengths.push(item.length);
-						}
-					}
-					allocate(5 + lengths.length * 4);
-					writeU8(LAZY_HEADER);
-					writeU32(lengths.length);
-					for (const l of lengths) {
-						writeU32(l);
-					}
-					flush();
-					for (const item of serializedData) {
-						buffers.push(item);
-					}
-					break;
-				}
-				case "string": {
-					const len = Buffer.byteLength(thing);
-					if (len >= 128 || len !== thing.length) {
-						allocate(len + HEADER_SIZE + I32_SIZE);
-						writeU8(STRING_HEADER);
-						writeU32(len);
-						currentBuffer.write(thing, currentPosition);
-						currentPosition += len;
-					} else if (len >= 70) {
-						allocate(len + HEADER_SIZE);
-						writeU8(SHORT_STRING_HEADER | len);
-
-						currentBuffer.write(thing, currentPosition, "latin1");
-						currentPosition += len;
-					} else {
-						allocate(len + HEADER_SIZE);
-						writeU8(SHORT_STRING_HEADER | len);
-
-						for (let i = 0; i < len; i++) {
-							currentBuffer[currentPosition++] = thing.charCodeAt(i);
-						}
-					}
-					break;
-				}
-				case "number": {
-					const type = identifyNumber(thing);
-					if (type === 0 && thing >= 0 && thing <= 10) {
-						// shortcut for very small numbers
-						allocate(I8_SIZE);
-						writeU8(thing);
-						break;
-					}
-					/**
-					 * amount of numbers to write
-					 * @type {number}
-					 */
-					let n = 1;
-					for (; n < 32 && i + n < data.length; n++) {
-						const item = data[i + n];
-						if (typeof item !== "number") break;
-						if (identifyNumber(item) !== type) break;
-					}
-					switch (type) {
-						case 0:
-							allocate(HEADER_SIZE + I8_SIZE * n);
-							writeU8(I8_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt8(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += I8_SIZE;
-								n--;
-								i++;
-							}
-							break;
-						case 1:
-							allocate(HEADER_SIZE + I32_SIZE * n);
-							writeU8(I32_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt32LE(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += I32_SIZE;
-								n--;
-								i++;
-							}
-							break;
-						case 2:
-							allocate(HEADER_SIZE + F64_SIZE * n);
-							writeU8(F64_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeDoubleLE(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += F64_SIZE;
-								n--;
-								i++;
-							}
-							break;
-					}
-
-					i--;
-					break;
-				}
-				case "boolean": {
-					let lastByte = thing === true ? 1 : 0;
-					const bytes = [];
-					let count = 1;
-					let n;
-					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
-						const item = data[i + n];
-						if (typeof item !== "boolean") break;
-						const pos = count & 0x7;
-						if (pos === 0) {
-							bytes.push(lastByte);
-							lastByte = item === true ? 1 : 0;
-						} else if (item === true) {
-							lastByte |= 1 << pos;
-						}
-						count++;
-					}
-					i += count - 1;
-					if (count === 1) {
-						allocate(HEADER_SIZE);
-						writeU8(lastByte === 1 ? TRUE_HEADER : FALSE_HEADER);
-					} else if (count === 2) {
-						allocate(HEADER_SIZE * 2);
-						writeU8(lastByte & 1 ? TRUE_HEADER : FALSE_HEADER);
-						writeU8(lastByte & 2 ? TRUE_HEADER : FALSE_HEADER);
-					} else if (count <= 6) {
-						allocate(HEADER_SIZE + I8_SIZE);
-						writeU8(BOOLEANS_HEADER);
-						writeU8((1 << count) | lastByte);
-					} else if (count <= 133) {
-						allocate(HEADER_SIZE + I8_SIZE + I8_SIZE * bytes.length + I8_SIZE);
-						writeU8(BOOLEANS_HEADER);
-						writeU8(0x80 | (count - 7));
-						for (const byte of bytes) writeU8(byte);
-						writeU8(lastByte);
-					} else {
-						allocate(
-							HEADER_SIZE +
-								I8_SIZE +
-								I32_SIZE +
-								I8_SIZE * bytes.length +
-								I8_SIZE
-						);
-						writeU8(BOOLEANS_HEADER);
-						writeU8(0xff);
-						writeU32(count);
-						for (const byte of bytes) writeU8(byte);
-						writeU8(lastByte);
-					}
-					break;
-				}
-				case "object": {
-					if (thing === null) {
-						let n;
-						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
-							const item = data[i + n];
-							if (item !== null) break;
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"EnsureChunkConditionsPlugin",
+			compilation => {
+				const handler = chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					// These sets are hoisted here to save memory
+					// They are cleared at the end of every loop
+					/** @type {Set<Chunk>} */
+					const sourceChunks = new Set();
+					/** @type {Set<ChunkGroup>} */
+					const chunkGroups = new Set();
+					for (const module of compilation.modules) {
+						if (!module.hasChunkCondition()) continue;
+						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+							if (!module.chunkCondition(chunk, compilation)) {
+								sourceChunks.add(chunk);
+								for (const group of chunk.groupsIterable) {
+									chunkGroups.add(group);
+								}
+							}
 						}
-						i += n - 1;
-						if (n === 1) {
-							if (i + 1 < data.length) {
-								const next = data[i + 1];
-								if (next === true) {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_AND_TRUE_HEADER);
-									i++;
-								} else if (next === false) {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_AND_FALSE_HEADER);
-									i++;
-								} else if (typeof next === "number") {
-									const type = identifyNumber(next);
-									if (type === 0) {
-										allocate(HEADER_SIZE + I8_SIZE);
-										writeU8(NULL_AND_I8_HEADER);
-										currentBuffer.writeInt8(next, currentPosition);
-										currentPosition += I8_SIZE;
-										i++;
-									} else if (type === 1) {
-										allocate(HEADER_SIZE + I32_SIZE);
-										writeU8(NULL_AND_I32_HEADER);
-										currentBuffer.writeInt32LE(next, currentPosition);
-										currentPosition += I32_SIZE;
-										i++;
-									} else {
-										allocate(HEADER_SIZE);
-										writeU8(NULL_HEADER);
-									}
-								} else {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_HEADER);
+						if (sourceChunks.size === 0) continue;
+						/** @type {Set<Chunk>} */
+						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, compilation)) {
+									targetChunks.add(chunk);
+									continue chunkGroupLoop;
 								}
-							} else {
-								allocate(HEADER_SIZE);
-								writeU8(NULL_HEADER);
 							}
-						} else if (n === 2) {
-							allocate(HEADER_SIZE);
-							writeU8(NULL2_HEADER);
-						} else if (n === 3) {
-							allocate(HEADER_SIZE);
-							writeU8(NULL3_HEADER);
-						} else if (n < 260) {
-							allocate(HEADER_SIZE + I8_SIZE);
-							writeU8(NULLS8_HEADER);
-							writeU8(n - 4);
-						} else {
-							allocate(HEADER_SIZE + I32_SIZE);
-							writeU8(NULLS32_HEADER);
-							writeU32(n - 260);
+							// 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);
+							}
 						}
-					} else if (Buffer.isBuffer(thing)) {
-						if (thing.length < 8192) {
-							allocate(HEADER_SIZE + I32_SIZE + thing.length);
-							writeU8(BUFFER_HEADER);
-							writeU32(thing.length);
-							thing.copy(currentBuffer, currentPosition);
-							currentPosition += thing.length;
-						} else {
-							allocate(HEADER_SIZE + I32_SIZE);
-							writeU8(BUFFER_HEADER);
-							writeU32(thing.length);
-							flush();
-							buffers.push(thing);
+						for (const sourceChunk of sourceChunks) {
+							chunkGraph.disconnectChunkAndModule(sourceChunk, module);
 						}
+						for (const targetChunk of targetChunks) {
+							chunkGraph.connectChunkAndModule(targetChunk, module);
+						}
+						sourceChunks.clear();
+						chunkGroups.clear();
 					}
-					break;
-				}
-				case "symbol": {
-					if (thing === MEASURE_START_OPERATION) {
-						measureStart();
-					} else if (thing === MEASURE_END_OPERATION) {
-						const size = measureEnd();
-						allocate(HEADER_SIZE + I32_SIZE);
-						writeU8(I32_HEADER);
-						currentBuffer.writeInt32LE(size, currentPosition);
-						currentPosition += I32_SIZE;
-					}
-					break;
-				}
+				};
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "EnsureChunkConditionsPlugin",
+						stage: STAGE_BASIC
+					},
+					handler
+				);
 			}
-		}
-		flush();
+		);
+	}
+}
+module.exports = EnsureChunkConditionsPlugin;
 
-		allocationScope.leftOverBuffer = leftOverBuffer;
 
-		// avoid leaking memory
-		currentBuffer = null;
-		leftOverBuffer = null;
-		allocationScope = undefined;
-		const _buffers = buffers;
-		buffers = undefined;
-		return _buffers;
-	}
+/***/ }),
+
+/***/ 50089:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
+class FlagIncludedChunksPlugin {
 	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	deserialize(data, context) {
-		return this._deserialize(data, context);
+	apply(compiler) {
+		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
+			compilation.hooks.optimizeChunkIds.tap(
+				"FlagIncludedChunksPlugin",
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
+
+					// 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)
+					/** @type {WeakMap<Module, number>} */
+					const moduleBits = new WeakMap();
+					const modulesCount = compilation.modules.size;
+
+					// 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++;
+					}
+
+					// iterate all chunks to generate bitmaps
+					/** @type {WeakMap<Chunk, number>} */
+					const chunkModulesHash = new WeakMap();
+					for (const chunk of chunks) {
+						let hash = 0;
+						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+							hash |= moduleBits.get(module);
+						}
+						chunkModulesHash.set(chunk, hash);
+					}
+
+					for (const chunkA of chunks) {
+						const chunkAHash = chunkModulesHash.get(chunkA);
+						const chunkAModulesCount =
+							chunkGraph.getNumberOfChunkModules(chunkA);
+						if (chunkAModulesCount === 0) continue;
+						let bestModule = undefined;
+						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
+							if (
+								bestModule === undefined ||
+								chunkGraph.getNumberOfModuleChunks(bestModule) >
+									chunkGraph.getNumberOfModuleChunks(module)
+							)
+								bestModule = module;
+						}
+						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
+							bestModule
+						)) {
+							// as we iterate the same iterables twice
+							// skip if we find ourselves
+							if (chunkA === chunkB) continue;
+
+							const chunkBModulesCount =
+								chunkGraph.getNumberOfChunkModules(chunkB);
+
+							// 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 chunkGraph.getChunkModulesIterable(chunkA)) {
+								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
+							}
+							chunkB.ids.push(chunkA.id);
+						}
+					}
+				}
+			);
+		});
 	}
+}
+module.exports = FlagIncludedChunksPlugin;
 
-	_createLazyDeserialized(content, context) {
-		return SerializerMiddleware.createLazy(
-			memoize(() => this._deserialize(content, context)),
-			this,
-			undefined,
-			content
-		);
+
+/***/ }),
+
+/***/ 38988:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+
+
+const { UsageState } = __webpack_require__(63686);
+
+/** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
+
+/**
+ * @typedef {Object} StateObject
+ * @property {InnerGraph} innerGraph
+ * @property {TopLevelSymbol=} currentTopLevelSymbol
+ * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
+ */
+
+/** @typedef {false|StateObject} State */
+
+/** @type {WeakMap<ParserState, State>} */
+const parserStateMap = new WeakMap();
+const topLevelSymbolTag = Symbol("top level symbol");
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {State} state
+ */
+function getState(parserState) {
+	return parserStateMap.get(parserState);
+}
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.bailout = parserState => {
+	parserStateMap.set(parserState, false);
+};
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.enable = parserState => {
+	const state = parserStateMap.get(parserState);
+	if (state === false) {
+		return;
 	}
+	parserStateMap.set(parserState, {
+		innerGraph: new Map(),
+		currentTopLevelSymbol: undefined,
+		usageCallbackMap: new Map()
+	});
+};
 
-	_deserializeLazy(fn, context) {
-		return SerializerMiddleware.deserializeLazy(fn, data =>
-			this._deserialize(data, context)
-		);
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+exports.isEnabled = parserState => {
+	const state = parserStateMap.get(parserState);
+	return !!state;
+};
+
+/**
+ * @param {ParserState} state parser state
+ * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
+ * @param {string | TopLevelSymbol | true} usage usage data
+ * @returns {void}
+ */
+exports.addUsage = (state, symbol, usage) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		const { innerGraph } = innerGraphState;
+		const info = innerGraph.get(symbol);
+		if (usage === true) {
+			innerGraph.set(symbol, true);
+		} else if (info === undefined) {
+			innerGraph.set(symbol, new Set([usage]));
+		} else if (info !== true) {
+			info.add(usage);
+		}
 	}
+};
 
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType} deserialized data
-	 */
-	_deserialize(data, context) {
-		let currentDataItem = 0;
-		let currentBuffer = data[0];
-		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
-		let currentPosition = 0;
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} name name of variable
+ * @param {string | TopLevelSymbol | true} usage usage data
+ * @returns {void}
+ */
+exports.addVariableUsage = (parser, name, usage) => {
+	const symbol =
+		/** @type {TopLevelSymbol} */ (
+			parser.getTagData(name, topLevelSymbolTag)
+		) || exports.tagTopLevelSymbol(parser, name);
+	if (symbol) {
+		exports.addUsage(parser.state, symbol, usage);
+	}
+};
 
-		const retainedBuffer = context.retainedBuffer || (x => x);
+/**
+ * @param {ParserState} state parser state
+ * @returns {void}
+ */
+exports.inferDependencyUsage = state => {
+	const innerGraphState = getState(state);
 
-		const checkOverflow = () => {
-			if (currentPosition >= currentBuffer.length) {
-				currentPosition = 0;
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			}
-		};
-		const isInCurrentBuffer = n => {
-			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
-		};
-		const ensureBuffer = () => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
-		};
-		/**
-		 * Reads n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const read = n => {
-			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
-			if (rem < n) {
-				const buffers = [read(rem)];
-				n -= rem;
-				ensureBuffer();
-				while (currentBuffer.length < n) {
-					const b = /** @type {Buffer} */ (currentBuffer);
-					buffers.push(b);
-					n -= b.length;
-					currentDataItem++;
-					currentBuffer =
-						currentDataItem < data.length ? data[currentDataItem] : null;
-					currentIsBuffer = Buffer.isBuffer(currentBuffer);
-					ensureBuffer();
-				}
-				buffers.push(read(n));
-				return Buffer.concat(buffers);
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		/**
-		 * Reads up to n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const readUpTo = n => {
-			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
-			if (rem < n) {
-				n = rem;
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		const readU8 = () => {
-			ensureBuffer();
-			/**
-			 * There is no need to check remaining buffer size here
-			 * since {@link checkOverflow} guarantees at least one byte remaining
-			 */
-			const byte = /** @type {Buffer} */ (currentBuffer).readUInt8(
-				currentPosition
-			);
-			currentPosition += I8_SIZE;
-			checkOverflow();
-			return byte;
-		};
-		const readU32 = () => {
-			return read(I32_SIZE).readUInt32LE(0);
-		};
-		const readBits = (data, n) => {
-			let mask = 1;
-			while (n !== 0) {
-				result.push((data & mask) !== 0);
-				mask = mask << 1;
-				n--;
+	if (!innerGraphState) {
+		return;
+	}
+
+	const { innerGraph, usageCallbackMap } = innerGraphState;
+	const processed = new Map();
+	// flatten graph to terminal nodes (string, undefined or true)
+	const nonTerminal = new Set(innerGraph.keys());
+	while (nonTerminal.size > 0) {
+		for (const key of nonTerminal) {
+			/** @type {Set<string|TopLevelSymbol> | true} */
+			let newSet = new Set();
+			let isTerminal = true;
+			const value = innerGraph.get(key);
+			let alreadyProcessed = processed.get(key);
+			if (alreadyProcessed === undefined) {
+				alreadyProcessed = new Set();
+				processed.set(key, alreadyProcessed);
 			}
-		};
-		const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
-			switch (header) {
-				case LAZY_HEADER:
-					return () => {
-						const count = readU32();
-						const lengths = Array.from({ length: count }).map(() => readU32());
-						const content = [];
-						for (let l of lengths) {
-							if (l === 0) {
-								if (typeof currentBuffer !== "function") {
-									throw new Error("Unexpected non-lazy element in stream");
-								}
-								content.push(currentBuffer);
-								currentDataItem++;
-								currentBuffer =
-									currentDataItem < data.length ? data[currentDataItem] : null;
-								currentIsBuffer = Buffer.isBuffer(currentBuffer);
-							} else {
-								do {
-									const buf = readUpTo(l);
-									l -= buf.length;
-									content.push(retainedBuffer(buf));
-								} while (l > 0);
-							}
-						}
-						result.push(this._createLazyDeserialized(content, context));
-					};
-				case BUFFER_HEADER:
-					return () => {
-						const len = readU32();
-						result.push(retainedBuffer(read(len)));
-					};
-				case TRUE_HEADER:
-					return () => result.push(true);
-				case FALSE_HEADER:
-					return () => result.push(false);
-				case NULL3_HEADER:
-					return () => result.push(null, null, null);
-				case NULL2_HEADER:
-					return () => result.push(null, null);
-				case NULL_HEADER:
-					return () => result.push(null);
-				case NULL_AND_TRUE_HEADER:
-					return () => result.push(null, true);
-				case NULL_AND_FALSE_HEADER:
-					return () => result.push(null, false);
-				case NULL_AND_I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								null,
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition += I8_SIZE;
-							checkOverflow();
-						} else {
-							result.push(null, read(I8_SIZE).readInt8(0));
-						}
-					};
-				case NULL_AND_I32_HEADER:
-					return () => {
-						result.push(null);
-						if (isInCurrentBuffer(I32_SIZE)) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt32LE(
-									currentPosition
-								)
-							);
-							currentPosition += I32_SIZE;
-							checkOverflow();
-						} else {
-							result.push(read(I32_SIZE).readInt32LE(0));
-						}
-					};
-				case NULLS8_HEADER:
-					return () => {
-						const len = readU8() + 4;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case NULLS32_HEADER:
-					return () => {
-						const len = readU32() + 260;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case BOOLEANS_HEADER:
-					return () => {
-						const innerHeader = readU8();
-						if ((innerHeader & 0xf0) === 0) {
-							readBits(innerHeader, 3);
-						} else if ((innerHeader & 0xe0) === 0) {
-							readBits(innerHeader, 4);
-						} else if ((innerHeader & 0xc0) === 0) {
-							readBits(innerHeader, 5);
-						} else if ((innerHeader & 0x80) === 0) {
-							readBits(innerHeader, 6);
-						} else if (innerHeader !== 0xff) {
-							let count = (innerHeader & 0x7f) + 7;
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						} else {
-							let count = readU32();
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						}
-					};
-				case STRING_HEADER:
-					return () => {
-						const len = readU32();
-						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							result.push(
-								currentBuffer.toString(
-									undefined,
-									currentPosition,
-									currentPosition + len
-								)
-							);
-							currentPosition += len;
-							checkOverflow();
-						} else {
-							result.push(read(len).toString());
-						}
-					};
-				case SHORT_STRING_HEADER:
-					return () => result.push("");
-				case SHORT_STRING_HEADER | 1:
-					return () => {
-						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
-							result.push(
-								currentBuffer.toString(
-									"latin1",
-									currentPosition,
-									currentPosition + 1
-								)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).toString("latin1"));
-						}
-					};
-				case I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).readInt8(0));
+			if (value !== true && value !== undefined) {
+				for (const item of value) {
+					alreadyProcessed.add(item);
+				}
+				for (const item of value) {
+					if (typeof item === "string") {
+						newSet.add(item);
+					} else {
+						const itemValue = innerGraph.get(item);
+						if (itemValue === true) {
+							newSet = true;
+							break;
 						}
-					};
-				default:
-					if (header <= 10) {
-						return () => result.push(header);
-					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
-						const len = header & SHORT_STRING_LENGTH_MASK;
-						return () => {
-							if (
-								isInCurrentBuffer(len) &&
-								currentPosition + len < 0x7fffffff
-							) {
-								result.push(
-									currentBuffer.toString(
-										"latin1",
-										currentPosition,
-										currentPosition + len
-									)
-								);
-								currentPosition += len;
-								checkOverflow();
-							} else {
-								result.push(read(len).toString("latin1"));
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = F64_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readDoubleLE(
-											currentPosition
-										)
-									);
-									currentPosition += F64_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readDoubleLE(i * F64_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I32_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt32LE(
-											currentPosition
-										)
-									);
-									currentPosition += I32_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt32LE(i * I32_SIZE));
+						if (itemValue !== undefined) {
+							for (const i of itemValue) {
+								if (i === key) continue;
+								if (alreadyProcessed.has(i)) continue;
+								newSet.add(i);
+								if (typeof i !== "string") {
+									isTerminal = false;
 								}
 							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I8_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt8(
-											currentPosition
-										)
-									);
-									currentPosition += I8_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt8(i * I8_SIZE));
+						}
+					}
+				}
+				if (newSet === true) {
+					innerGraph.set(key, true);
+				} else if (newSet.size === 0) {
+					innerGraph.set(key, undefined);
+				} else {
+					innerGraph.set(key, newSet);
+				}
+			}
+			if (isTerminal) {
+				nonTerminal.delete(key);
+
+				// For the global key, merge with all other keys
+				if (key === null) {
+					const globalValue = innerGraph.get(null);
+					if (globalValue) {
+						for (const [key, value] of innerGraph) {
+							if (key !== null && value !== true) {
+								if (globalValue === true) {
+									innerGraph.set(key, true);
+								} else {
+									const newSet = new Set(value);
+									for (const item of globalValue) {
+										newSet.add(item);
+									}
+									innerGraph.set(key, newSet);
 								}
 							}
-						};
-					} else {
-						return () => {
-							throw new Error(
-								`Unexpected header byte 0x${header.toString(16)}`
-							);
-						};
+						}
 					}
+				}
 			}
-		});
+		}
+	}
 
-		/** @type {DeserializedType} */
-		let result = [];
-		while (currentBuffer !== null) {
-			if (typeof currentBuffer === "function") {
-				result.push(this._deserializeLazy(currentBuffer, context));
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			} else {
-				const header = readU8();
-				dispatchTable[header]();
-			}
+	/** @type {Map<Dependency, true | Set<string>>} */
+	for (const [symbol, callbacks] of usageCallbackMap) {
+		const usage = /** @type {true | Set<string> | undefined} */ (
+			innerGraph.get(symbol)
+		);
+		for (const callback of callbacks) {
+			callback(usage === undefined ? false : usage);
 		}
+	}
+};
 
-		// avoid leaking memory in context
-		let _result = result;
-		result = undefined;
-		return _result;
+/**
+ * @param {ParserState} state parser state
+ * @param {UsageCallback} onUsageCallback on usage callback
+ */
+exports.onUsage = (state, onUsageCallback) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		const { usageCallbackMap, currentTopLevelSymbol } = innerGraphState;
+		if (currentTopLevelSymbol) {
+			let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
+
+			if (callbacks === undefined) {
+				callbacks = new Set();
+				usageCallbackMap.set(currentTopLevelSymbol, callbacks);
+			}
+
+			callbacks.add(onUsageCallback);
+		} else {
+			onUsageCallback(true);
+		}
+	} else {
+		onUsageCallback(undefined);
 	}
-}
+};
 
-module.exports = BinaryMiddleware;
+/**
+ * @param {ParserState} state parser state
+ * @param {TopLevelSymbol} symbol the symbol
+ */
+exports.setTopLevelSymbol = (state, symbol) => {
+	const innerGraphState = getState(state);
 
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
-module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+	if (innerGraphState) {
+		innerGraphState.currentTopLevelSymbol = symbol;
+	}
+};
 
+/**
+ * @param {ParserState} state parser state
+ * @returns {TopLevelSymbol|void} usage data
+ */
+exports.getTopLevelSymbol = state => {
+	const innerGraphState = getState(state);
 
-/***/ }),
+	if (innerGraphState) {
+		return innerGraphState.currentTopLevelSymbol;
+	}
+};
 
-/***/ 93475:
-/***/ (function(module) {
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {string} name name of variable
+ * @returns {TopLevelSymbol} symbol
+ */
+exports.tagTopLevelSymbol = (parser, name) => {
+	const innerGraphState = getState(parser.state);
+	if (!innerGraphState) return;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	parser.defineVariable(name);
 
+	const existingTag = /** @type {TopLevelSymbol} */ (
+		parser.getTagData(name, topLevelSymbolTag)
+	);
+	if (existingTag) {
+		return existingTag;
+	}
 
+	const fn = new TopLevelSymbol(name);
+	parser.tagVariable(name, topLevelSymbolTag, fn);
+	return fn;
+};
 
-class DateObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.getTime());
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} false, when unused. Otherwise true
+ */
+exports.isDependencyUsedByExports = (
+	dependency,
+	usedByExports,
+	moduleGraph,
+	runtime
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		let used = false;
+		for (const exportName of usedByExports) {
+			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+				used = true;
+		}
+		if (!used) return false;
 	}
-	deserialize({ read }) {
-		return new Date(read());
+	return true;
+};
+
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+ */
+exports.getDependencyUsedByExportsCondition = (
+	dependency,
+	usedByExports,
+	moduleGraph
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		return (connections, runtime) => {
+			for (const exportName of usedByExports) {
+				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+					return true;
+			}
+			return false;
+		};
+	}
+	return null;
+};
+
+class TopLevelSymbol {
+	/**
+	 * @param {string} name name of the variable
+	 */
+	constructor(name) {
+		this.name = name;
 	}
 }
 
-module.exports = DateObjectSerializer;
+exports.TopLevelSymbol = TopLevelSymbol;
+exports.topLevelSymbolTag = topLevelSymbolTag;
 
 
 /***/ }),
 
-/***/ 79479:
-/***/ (function(module) {
+/***/ 28758:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-class ErrorObjectSerializer {
-	constructor(Type) {
-		this.Type = Type;
-	}
-
-	serialize(obj, { write }) {
-		write(obj.message);
-		write(obj.stack);
-	}
-
-	deserialize({ read }) {
-		const err = new this.Type();
+const PureExpressionDependency = __webpack_require__(55799);
+const InnerGraph = __webpack_require__(38988);
 
-		err.message = read();
-		err.stack = read();
+/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
+/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
+/** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
-		return err;
-	}
-}
+const { topLevelSymbolTag } = InnerGraph;
 
-module.exports = ErrorObjectSerializer;
+class InnerGraphPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"InnerGraphPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
 
+				compilation.dependencyTemplates.set(
+					PureExpressionDependency,
+					new PureExpressionDependency.Template()
+				);
 
-/***/ }),
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {Object} parserOptions options
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					const onUsageSuper = sup => {
+						InnerGraph.onUsage(parser.state, usedByExports => {
+							switch (usedByExports) {
+								case undefined:
+								case true:
+									return;
+								default: {
+									const dep = new PureExpressionDependency(sup.range);
+									dep.loc = sup.loc;
+									dep.usedByExports = usedByExports;
+									parser.state.module.addDependency(dep);
+									break;
+								}
+							}
+						});
+					};
 
-/***/ 65321:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					parser.hooks.program.tap("InnerGraphPlugin", () => {
+						InnerGraph.enable(parser.state);
+					});
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+					parser.hooks.finish.tap("InnerGraphPlugin", () => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
 
+						logger.time("infer dependency usage");
+						InnerGraph.inferDependencyUsage(parser.state);
+						logger.timeAggregate("infer dependency usage");
+					});
 
+					// During prewalking the following datastructures are filled with
+					// nodes that have a TopLevelSymbol assigned and
+					// variables are tagged with the assigned TopLevelSymbol
 
-const { constants } = __webpack_require__(14300);
-const { pipeline } = __webpack_require__(12781);
-const {
-	createBrotliCompress,
-	createBrotliDecompress,
-	createGzip,
-	createGunzip,
-	constants: zConstants
-} = __webpack_require__(59796);
-const createHash = __webpack_require__(49835);
-const { dirname, join, mkdirp } = __webpack_require__(17139);
-const memoize = __webpack_require__(78676);
-const SerializerMiddleware = __webpack_require__(83137);
+					// We differ 3 types of nodes:
+					// 1. full statements (export default, function declaration)
+					// 2. classes (class declaration, class expression)
+					// 3. variable declarators (const x = ...)
 
-/** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+					/** @type {WeakMap<Node, TopLevelSymbol>} */
+					const statementWithTopLevelSymbol = new WeakMap();
+					/** @type {WeakMap<Node, Node>} */
+					const statementPurePart = new WeakMap();
 
-/*
-Format:
+					/** @type {WeakMap<ClassExpressionNode | ClassDeclarationNode, TopLevelSymbol>} */
+					const classWithTopLevelSymbol = new WeakMap();
 
-File -> Header Section*
+					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
+					const declWithTopLevelSymbol = new WeakMap();
+					/** @type {WeakSet<VariableDeclaratorNode>} */
+					const pureDeclarators = new WeakSet();
 
-Version -> u32
-AmountOfSections -> u32
-SectionSize -> i32 (if less than zero represents lazy value)
+					// The following hooks are used during prewalking:
 
-Header -> Version AmountOfSections SectionSize*
+					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
 
-Buffer -> n bytes
-Section -> Buffer
+						if (parser.scope.topLevelScope === true) {
+							if (statement.type === "FunctionDeclaration") {
+								const name = statement.id ? statement.id.name : "*default*";
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								statementWithTopLevelSymbol.set(statement, fn);
+								return true;
+							}
+						}
+					});
 
-*/
+					parser.hooks.blockPreStatement.tap("InnerGraphPlugin", statement => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
 
-// "wpc" + 1 in little-endian
-const VERSION = 0x01637077;
+						if (parser.scope.topLevelScope === true) {
+							if (statement.type === "ClassDeclaration") {
+								const name = statement.id ? statement.id.name : "*default*";
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								classWithTopLevelSymbol.set(statement, fn);
+								return true;
+							}
+							if (statement.type === "ExportDefaultDeclaration") {
+								const name = "*default*";
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								const decl = statement.declaration;
+								if (
+									decl.type === "ClassExpression" ||
+									decl.type === "ClassDeclaration"
+								) {
+									classWithTopLevelSymbol.set(decl, fn);
+								} else if (parser.isPure(decl, statement.range[0])) {
+									statementWithTopLevelSymbol.set(statement, fn);
+									if (
+										!decl.type.endsWith("FunctionExpression") &&
+										!decl.type.endsWith("Declaration") &&
+										decl.type !== "Literal"
+									) {
+										statementPurePart.set(statement, decl);
+									}
+								}
+							}
+						}
+					});
 
-/**
- * @param {Buffer[]} buffers buffers
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const hashForName = (buffers, hashFunction) => {
-	const hash = createHash(hashFunction);
-	for (const buf of buffers) hash.update(buf);
-	return /** @type {string} */ (hash.digest("hex"));
-};
+					parser.hooks.preDeclarator.tap(
+						"InnerGraphPlugin",
+						(decl, statement) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (
+								parser.scope.topLevelScope === true &&
+								decl.init &&
+								decl.id.type === "Identifier"
+							) {
+								const name = decl.id.name;
+								if (decl.init.type === "ClassExpression") {
+									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+									classWithTopLevelSymbol.set(decl.init, fn);
+								} else if (parser.isPure(decl.init, decl.id.range[1])) {
+									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+									declWithTopLevelSymbol.set(decl, fn);
+									if (
+										!decl.init.type.endsWith("FunctionExpression") &&
+										decl.init.type !== "Literal"
+									) {
+										pureDeclarators.add(decl);
+									}
+									return true;
+								}
+							}
+						}
+					);
 
-const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
-const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
+					// During real walking we set the TopLevelSymbol state to the assigned
+					// TopLevelSymbol by using the fill datastructures.
 
-const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
-	? (buf, value, offset) => {
-			buf.writeBigUInt64LE(BigInt(value), offset);
-	  }
-	: (buf, value, offset) => {
-			const low = value % 0x100000000;
-			const high = (value - low) / 0x100000000;
-			buf.writeUInt32LE(low, offset);
-			buf.writeUInt32LE(high, offset + 4);
-	  };
+					// In addition to tracking TopLevelSymbols, we sometimes need to
+					// add a PureExpressionDependency. This is needed to skip execution
+					// of pure expressions, even when they are not dropped due to
+					// minimizing. Otherwise symbols used there might not exist anymore
+					// as they are removed as unused by this optimization
 
-const readUInt64LE = Buffer.prototype.readBigUInt64LE
-	? (buf, offset) => {
-			return Number(buf.readBigUInt64LE(offset));
-	  }
-	: (buf, offset) => {
-			const low = buf.readUInt32LE(offset);
-			const high = buf.readUInt32LE(offset + 4);
-			return high * 0x100000000 + low;
-	  };
+					// When we find a reference to a TopLevelSymbol, we register a
+					// TopLevelSymbol dependency from TopLevelSymbol in state to the
+					// referenced TopLevelSymbol. This way we get a graph of all
+					// TopLevelSymbols.
 
-/**
- * @typedef {Object} SerializeResult
- * @property {string | false} name
- * @property {number} size
- * @property {Promise=} backgroundJob
- */
+					// The following hooks are called during walking:
 
-/**
- * @param {FileMiddleware} middleware this
- * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
- * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
- * @param {string | Hash} hashFunction hash function to use
- * @returns {Promise<SerializeResult>} resulting file pointer and promise
- */
-const serialize = async (
-	middleware,
-	data,
-	name,
-	writeFile,
-	hashFunction = "md4"
-) => {
-	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
-	const processedData = [];
-	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
-	const resultToLazy = new WeakMap();
-	/** @type {Buffer[]} */
-	let lastBuffers = undefined;
-	for (const item of await data) {
-		if (typeof item === "function") {
-			if (!SerializerMiddleware.isLazy(item))
-				throw new Error("Unexpected function");
-			if (!SerializerMiddleware.isLazy(item, middleware)) {
-				throw new Error(
-					"Unexpected lazy value with non-this target (can't pass through lazy values)"
-				);
-			}
-			lastBuffers = undefined;
-			const serializedInfo = SerializerMiddleware.getLazySerializedValue(item);
-			if (serializedInfo) {
-				if (typeof serializedInfo === "function") {
-					throw new Error(
-						"Unexpected lazy value with non-this target (can't pass through lazy values)"
-					);
-				} else {
-					processedData.push(serializedInfo);
-				}
-			} else {
-				const content = item();
-				if (content) {
-					const options = SerializerMiddleware.getLazyOptions(item);
-					processedData.push(
-						serialize(
-							middleware,
-							content,
-							(options && options.name) || true,
-							writeFile,
-							hashFunction
-						).then(result => {
-							/** @type {any} */ (item).options.size = result.size;
-							resultToLazy.set(result, item);
-							return result;
-						})
-					);
-				} else {
-					throw new Error(
-						"Unexpected falsy value returned by lazy value function"
-					);
-				}
-			}
-		} else if (item) {
-			if (lastBuffers) {
-				lastBuffers.push(item);
-			} else {
-				lastBuffers = [item];
-				processedData.push(lastBuffers);
-			}
-		} else {
-			throw new Error("Unexpected falsy value in items array");
-		}
-	}
-	/** @type {Promise<any>[]} */
-	const backgroundJobs = [];
-	const resolvedData = (
-		await Promise.all(
-			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (
-				processedData
-			)
-		)
-	).map(item => {
-		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
+					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (parser.scope.topLevelScope === true) {
+							InnerGraph.setTopLevelSymbol(parser.state, undefined);
 
-		backgroundJobs.push(item.backgroundJob);
-		// create pointer buffer from size and name
-		const name = /** @type {string} */ (item.name);
-		const nameBuffer = Buffer.from(name);
-		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
-		writeUInt64LE(buf, item.size, 0);
-		nameBuffer.copy(buf, 8, 0);
-		const lazy = resultToLazy.get(item);
-		SerializerMiddleware.setLazySerializedValue(lazy, buf);
-		return buf;
-	});
-	const lengths = [];
-	for (const item of resolvedData) {
-		if (Array.isArray(item)) {
-			let l = 0;
-			for (const b of item) l += b.length;
-			while (l > 0x7fffffff) {
-				lengths.push(0x7fffffff);
-				l -= 0x7fffffff;
-			}
-			lengths.push(l);
-		} else if (item) {
-			lengths.push(-item.length);
-		} else {
-			throw new Error("Unexpected falsy value in resolved data " + item);
-		}
-	}
-	const header = Buffer.allocUnsafe(8 + lengths.length * 4);
-	header.writeUInt32LE(VERSION, 0);
-	header.writeUInt32LE(lengths.length, 4);
-	for (let i = 0; i < lengths.length; i++) {
-		header.writeInt32LE(lengths[i], 8 + i * 4);
-	}
-	const buf = [header];
-	for (const item of resolvedData) {
-		if (Array.isArray(item)) {
-			for (const b of item) buf.push(b);
-		} else if (item) {
-			buf.push(item);
-		}
-	}
-	if (name === true) {
-		name = hashForName(buf, hashFunction);
-	}
-	backgroundJobs.push(writeFile(name, buf));
-	let size = 0;
-	for (const b of buf) size += b.length;
-	return {
-		size,
-		name,
-		backgroundJob:
-			backgroundJobs.length === 1
-				? backgroundJobs[0]
-				: Promise.all(backgroundJobs)
-	};
-};
+							const fn = statementWithTopLevelSymbol.get(statement);
+							if (fn) {
+								InnerGraph.setTopLevelSymbol(parser.state, fn);
+								const purePart = statementPurePart.get(statement);
+								if (purePart) {
+									InnerGraph.onUsage(parser.state, usedByExports => {
+										switch (usedByExports) {
+											case undefined:
+											case true:
+												return;
+											default: {
+												const dep = new PureExpressionDependency(
+													purePart.range
+												);
+												dep.loc = statement.loc;
+												dep.usedByExports = usedByExports;
+												parser.state.module.addDependency(dep);
+												break;
+											}
+										}
+									});
+								}
+							}
+						}
+					});
 
-/**
- * @param {FileMiddleware} middleware this
- * @param {string | false} name filename
- * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
- * @returns {Promise<BufferSerializableType[]>} deserialized data
- */
-const deserialize = async (middleware, name, readFile) => {
-	const contents = await readFile(name);
-	if (contents.length === 0) throw new Error("Empty file " + name);
-	let contentsIndex = 0;
-	let contentItem = contents[0];
-	let contentItemLength = contentItem.length;
-	let contentPosition = 0;
-	if (contentItemLength === 0) throw new Error("Empty file " + name);
-	const nextContent = () => {
-		contentsIndex++;
-		contentItem = contents[contentsIndex];
-		contentItemLength = contentItem.length;
-		contentPosition = 0;
-	};
-	const ensureData = n => {
-		if (contentPosition === contentItemLength) {
-			nextContent();
-		}
-		while (contentItemLength - contentPosition < n) {
-			const remaining = contentItem.slice(contentPosition);
-			let lengthFromNext = n - remaining.length;
-			const buffers = [remaining];
-			for (let i = contentsIndex + 1; i < contents.length; i++) {
-				const l = contents[i].length;
-				if (l > lengthFromNext) {
-					buffers.push(contents[i].slice(0, lengthFromNext));
-					contents[i] = contents[i].slice(lengthFromNext);
-					lengthFromNext = 0;
-					break;
-				} else {
-					buffers.push(contents[i]);
-					contentsIndex = i;
-					lengthFromNext -= l;
-				}
-			}
-			if (lengthFromNext > 0) throw new Error("Unexpected end of data");
-			contentItem = Buffer.concat(buffers, n);
-			contentItemLength = n;
-			contentPosition = 0;
-		}
-	};
-	const readUInt32LE = () => {
-		ensureData(4);
-		const value = contentItem.readUInt32LE(contentPosition);
-		contentPosition += 4;
-		return value;
-	};
-	const readInt32LE = () => {
-		ensureData(4);
-		const value = contentItem.readInt32LE(contentPosition);
-		contentPosition += 4;
-		return value;
-	};
-	const readSlice = l => {
-		ensureData(l);
-		if (contentPosition === 0 && contentItemLength === l) {
-			const result = contentItem;
-			if (contentsIndex + 1 < contents.length) {
-				nextContent();
-			} else {
-				contentPosition = l;
-			}
-			return result;
-		}
-		const result = contentItem.slice(contentPosition, contentPosition + l);
-		contentPosition += l;
-		// we clone the buffer here to allow the original content to be garbage collected
-		return l * 2 < contentItem.buffer.byteLength ? Buffer.from(result) : result;
-	};
-	const version = readUInt32LE();
-	if (version !== VERSION) {
-		throw new Error("Invalid file version");
-	}
-	const sectionCount = readUInt32LE();
-	const lengths = [];
-	let lastLengthPositive = false;
-	for (let i = 0; i < sectionCount; i++) {
-		const value = readInt32LE();
-		const valuePositive = value >= 0;
-		if (lastLengthPositive && valuePositive) {
-			lengths[lengths.length - 1] += value;
-		} else {
-			lengths.push(value);
-			lastLengthPositive = valuePositive;
-		}
-	}
-	const result = [];
-	for (let length of lengths) {
-		if (length < 0) {
-			const slice = readSlice(-length);
-			const size = Number(readUInt64LE(slice, 0));
-			const nameBuffer = slice.slice(8);
-			const name = nameBuffer.toString();
-			result.push(
-				SerializerMiddleware.createLazy(
-					memoize(() => deserialize(middleware, name, readFile)),
-					middleware,
-					{
-						name,
-						size
-					},
-					slice
-				)
-			);
-		} else {
-			if (contentPosition === contentItemLength) {
-				nextContent();
-			} else if (contentPosition !== 0) {
-				if (length <= contentItemLength - contentPosition) {
-					result.push(
-						Buffer.from(
-							contentItem.buffer,
-							contentItem.byteOffset + contentPosition,
-							length
-						)
-					);
-					contentPosition += length;
-					length = 0;
-				} else {
-					const l = contentItemLength - contentPosition;
-					result.push(
-						Buffer.from(
-							contentItem.buffer,
-							contentItem.byteOffset + contentPosition,
-							l
-						)
+					parser.hooks.classExtendsExpression.tap(
+						"InnerGraphPlugin",
+						(expr, statement) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(statement);
+								if (
+									fn &&
+									parser.isPure(
+										expr,
+										statement.id ? statement.id.range[1] : statement.range[0]
+									)
+								) {
+									InnerGraph.setTopLevelSymbol(parser.state, fn);
+									onUsageSuper(expr);
+								}
+							}
+						}
 					);
-					length -= l;
-					contentPosition = contentItemLength;
-				}
-			} else {
-				if (length >= contentItemLength) {
-					result.push(contentItem);
-					length -= contentItemLength;
-					contentPosition = contentItemLength;
-				} else {
-					result.push(
-						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+
+					parser.hooks.classBodyElement.tap(
+						"InnerGraphPlugin",
+						(element, classDefinition) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(classDefinition);
+								if (fn) {
+									InnerGraph.setTopLevelSymbol(parser.state, undefined);
+								}
+							}
+						}
 					);
-					contentPosition += length;
-					length = 0;
-				}
-			}
-			while (length > 0) {
-				nextContent();
-				if (length >= contentItemLength) {
-					result.push(contentItem);
-					length -= contentItemLength;
-					contentPosition = contentItemLength;
-				} else {
-					result.push(
-						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+
+					parser.hooks.classBodyValue.tap(
+						"InnerGraphPlugin",
+						(expression, element, classDefinition) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(classDefinition);
+								if (fn) {
+									if (
+										!element.static ||
+										parser.isPure(
+											expression,
+											element.key ? element.key.range[1] : element.range[0]
+										)
+									) {
+										InnerGraph.setTopLevelSymbol(parser.state, fn);
+										if (element.type !== "MethodDefinition" && element.static) {
+											InnerGraph.onUsage(parser.state, usedByExports => {
+												switch (usedByExports) {
+													case undefined:
+													case true:
+														return;
+													default: {
+														const dep = new PureExpressionDependency(
+															expression.range
+														);
+														dep.loc = expression.loc;
+														dep.usedByExports = usedByExports;
+														parser.state.module.addDependency(dep);
+														break;
+													}
+												}
+											});
+										}
+									} else {
+										InnerGraph.setTopLevelSymbol(parser.state, undefined);
+									}
+								}
+							}
+						}
 					);
-					contentPosition += length;
-					length = 0;
-				}
+
+					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+						const fn = declWithTopLevelSymbol.get(decl);
+
+						if (fn) {
+							InnerGraph.setTopLevelSymbol(parser.state, fn);
+							if (pureDeclarators.has(decl)) {
+								if (decl.init.type === "ClassExpression") {
+									if (decl.init.superClass) {
+										onUsageSuper(decl.init.superClass);
+									}
+								} else {
+									InnerGraph.onUsage(parser.state, usedByExports => {
+										switch (usedByExports) {
+											case undefined:
+											case true:
+												return;
+											default: {
+												const dep = new PureExpressionDependency(
+													decl.init.range
+												);
+												dep.loc = decl.loc;
+												dep.usedByExports = usedByExports;
+												parser.state.module.addDependency(dep);
+												break;
+											}
+										}
+									});
+								}
+							}
+							parser.walkExpression(decl.init);
+							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							return true;
+						}
+					});
+
+					parser.hooks.expression
+						.for(topLevelSymbolTag)
+						.tap("InnerGraphPlugin", () => {
+							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
+								parser.currentTagData
+							);
+							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
+								parser.state
+							);
+							InnerGraph.addUsage(
+								parser.state,
+								topLevelSymbol,
+								currentTopLevelSymbol || true
+							);
+						});
+					parser.hooks.assign
+						.for(topLevelSymbolTag)
+						.tap("InnerGraphPlugin", expr => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (expr.operator === "=") return true;
+						});
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("InnerGraphPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("InnerGraphPlugin", handler);
+
+				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
+					logger.timeAggregateEnd("infer dependency usage");
+				});
 			}
-		}
+		);
 	}
-	return result;
-};
+}
+
+module.exports = InnerGraphPlugin;
+
+
+/***/ }),
+
+/***/ 83608:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const LazyBucketSortedSet = __webpack_require__(48424);
+const { compareChunks } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+
+/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+
+const validate = createSchemaValidation(
+	__webpack_require__(36557),
+	() => __webpack_require__(30837),
+	{
+		name: "Limit Chunk Count Plugin",
+		baseDataPath: "options"
+	}
+);
 
 /**
- * @typedef {BufferSerializableType[]} DeserializedType
- * @typedef {true} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @typedef {Object} ChunkCombination
+ * @property {boolean} deleted this is set to true when combination was removed
+ * @property {number} sizeDiff
+ * @property {number} integratedSize
+ * @property {Chunk} a
+ * @property {Chunk} b
+ * @property {number} aIdx
+ * @property {number} bIdx
+ * @property {number} aSize
+ * @property {number} bSize
  */
-class FileMiddleware extends SerializerMiddleware {
+
+const addToSetMap = (map, key, value) => {
+	const set = map.get(key);
+	if (set === undefined) {
+		map.set(key, new Set([value]));
+	} else {
+		set.add(value);
+	}
+};
+
+class LimitChunkCountPlugin {
 	/**
-	 * @param {IntermediateFileSystem} fs filesystem
-	 * @param {string | Hash} hashFunction hash function to use
+	 * @param {LimitChunkCountPluginOptions=} options options object
 	 */
-	constructor(fs, hashFunction = "md4") {
-		super();
-		this.fs = fs;
-		this._hashFunction = hashFunction;
+	constructor(options) {
+		validate(options);
+		this.options = options;
 	}
+
 	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {Compiler} compiler the webpack compiler
+	 * @returns {void}
 	 */
-	serialize(data, context) {
-		const { filename, extension = "" } = context;
-		return new Promise((resolve, reject) => {
-			mkdirp(this.fs, dirname(this.fs, filename), err => {
-				if (err) return reject(err);
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "LimitChunkCountPlugin",
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					const maxChunks = options.maxChunks;
+					if (!maxChunks) return;
+					if (maxChunks < 1) return;
+					if (compilation.chunks.size <= maxChunks) return;
 
-				// It's important that we don't touch existing files during serialization
-				// because serialize may read existing files (when deserializing)
-				const allWrittenFiles = new Set();
-				const writeFile = async (name, content) => {
-					const file = name
-						? join(this.fs, filename, `../${name}${extension}`)
-						: filename;
-					await new Promise((resolve, reject) => {
-						let stream = this.fs.createWriteStream(file + "_");
-						let compression;
-						if (file.endsWith(".gz")) {
-							compression = createGzip({
-								chunkSize: COMPRESSION_CHUNK_SIZE,
-								level: zConstants.Z_BEST_SPEED
-							});
-						} else if (file.endsWith(".br")) {
-							compression = createBrotliCompress({
-								chunkSize: COMPRESSION_CHUNK_SIZE,
-								params: {
-									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
-									[zConstants.BROTLI_PARAM_QUALITY]: 2,
-									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
-									[zConstants.BROTLI_PARAM_SIZE_HINT]: content.reduce(
-										(size, b) => size + b.length,
-										0
-									)
-								}
-							});
-						}
-						if (compression) {
-							pipeline(compression, stream, reject);
-							stream = compression;
-							stream.on("finish", () => resolve());
-						} else {
-							stream.on("error", err => reject(err));
-							stream.on("finish", () => resolve());
-						}
-						for (const b of content) stream.write(b);
-						stream.end();
-					});
-					if (name) allWrittenFiles.add(file);
-				};
+					let remainingChunksToMerge = compilation.chunks.size - maxChunks;
 
-				resolve(
-					serialize(this, data, false, writeFile, this._hashFunction).then(
-						async ({ backgroundJob }) => {
-							await backgroundJob;
+					// order chunks in a deterministic way
+					const compareChunksWithGraph = compareChunks(chunkGraph);
+					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
 
-							// Rename the index file to disallow access during inconsistent file state
-							await new Promise(resolve =>
-								this.fs.rename(filename, filename + ".old", err => {
-									resolve();
-								})
-							);
+					// create a lazy sorted data structure to keep all combinations
+					// this is large. Size = chunks * (chunks - 1) / 2
+					// It uses a multi layer bucket sort plus normal sort in the last layer
+					// It's also lazy so only accessed buckets are sorted
+					const combinations = new LazyBucketSortedSet(
+						// Layer 1: ordered by largest size benefit
+						c => c.sizeDiff,
+						(a, b) => b - a,
+						// Layer 2: ordered by smallest combined size
+						c => c.integratedSize,
+						(a, b) => a - b,
+						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
+						c => c.bIdx - c.aIdx,
+						(a, b) => a - b,
+						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
+						(a, b) => a.bIdx - b.bIdx
+					);
 
-							// update all written files
-							await Promise.all(
-								Array.from(
-									allWrittenFiles,
-									file =>
-										new Promise((resolve, reject) => {
-											this.fs.rename(file + "_", file, err => {
-												if (err) return reject(err);
-												resolve();
-											});
-										})
-								)
-							);
+					// we keep a mapping from chunk to all combinations
+					// but this mapping is not kept up-to-date with deletions
+					// so `deleted` flag need to be considered when iterating this
+					/** @type {Map<Chunk, Set<ChunkCombination>>} */
+					const combinationsByChunk = new Map();
 
-							// As final step automatically update the index file to have a consistent pack again
-							await new Promise(resolve => {
-								this.fs.rename(filename + "_", filename, err => {
-									if (err) return reject(err);
-									resolve();
-								});
-							});
-							return /** @type {true} */ (true);
-						}
-					)
-				);
-			});
-		});
-	}
+					orderedChunks.forEach((b, bIdx) => {
+						// create combination pairs with size and integrated size
+						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
+							const a = orderedChunks[aIdx];
+							// filter pairs that can not be integrated!
+							if (!chunkGraph.canChunksBeIntegrated(a, b)) continue;
 
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		const { filename, extension = "" } = context;
-		const readFile = name =>
-			new Promise((resolve, reject) => {
-				const file = name
-					? join(this.fs, filename, `../${name}${extension}`)
-					: filename;
-				this.fs.stat(file, (err, stats) => {
-					if (err) {
-						reject(err);
-						return;
-					}
-					let remaining = /** @type {number} */ (stats.size);
-					let currentBuffer;
-					let currentBufferUsed;
-					const buf = [];
-					let decompression;
-					if (file.endsWith(".gz")) {
-						decompression = createGunzip({
-							chunkSize: DECOMPRESSION_CHUNK_SIZE
-						});
-					} else if (file.endsWith(".br")) {
-						decompression = createBrotliDecompress({
-							chunkSize: DECOMPRESSION_CHUNK_SIZE
-						});
-					}
-					if (decompression) {
-						let newResolve, newReject;
-						resolve(
-							Promise.all([
-								new Promise((rs, rj) => {
-									newResolve = rs;
-									newReject = rj;
-								}),
-								new Promise((resolve, reject) => {
-									decompression.on("data", chunk => buf.push(chunk));
-									decompression.on("end", () => resolve());
-									decompression.on("error", err => reject(err));
-								})
-							]).then(() => buf)
-						);
-						resolve = newResolve;
-						reject = newReject;
-					}
-					this.fs.open(file, "r", (err, fd) => {
-						if (err) {
-							reject(err);
-							return;
-						}
-						const read = () => {
-							if (currentBuffer === undefined) {
-								currentBuffer = Buffer.allocUnsafeSlow(
-									Math.min(
-										constants.MAX_LENGTH,
-										remaining,
-										decompression ? DECOMPRESSION_CHUNK_SIZE : Infinity
-									)
-								);
-								currentBufferUsed = 0;
-							}
-							let readBuffer = currentBuffer;
-							let readOffset = currentBufferUsed;
-							let readLength = currentBuffer.length - currentBufferUsed;
-							// values passed to fs.read must be valid int32 values
-							if (readOffset > 0x7fffffff) {
-								readBuffer = currentBuffer.slice(readOffset);
-								readOffset = 0;
-							}
-							if (readLength > 0x7fffffff) {
-								readLength = 0x7fffffff;
-							}
-							this.fs.read(
-								fd,
-								readBuffer,
-								readOffset,
-								readLength,
-								null,
-								(err, bytesRead) => {
-									if (err) {
-										this.fs.close(fd, () => {
-											reject(err);
-										});
-										return;
-									}
-									currentBufferUsed += bytesRead;
-									remaining -= bytesRead;
-									if (currentBufferUsed === currentBuffer.length) {
-										if (decompression) {
-											decompression.write(currentBuffer);
-										} else {
-											buf.push(currentBuffer);
-										}
-										currentBuffer = undefined;
-										if (remaining === 0) {
-											if (decompression) {
-												decompression.end();
-											}
-											this.fs.close(fd, err => {
-												if (err) {
-													reject(err);
-													return;
-												}
-												resolve(buf);
-											});
-											return;
-										}
-									}
-									read();
-								}
+							const integratedSize = chunkGraph.getIntegratedChunksSize(
+								a,
+								b,
+								options
 							);
-						};
-						read();
+
+							const aSize = chunkGraph.getChunkSize(a, options);
+							const bSize = chunkGraph.getChunkSize(b, options);
+							const c = {
+								deleted: false,
+								sizeDiff: aSize + bSize - integratedSize,
+								integratedSize,
+								a,
+								b,
+								aIdx,
+								bIdx,
+								aSize,
+								bSize
+							};
+							combinations.add(c);
+							addToSetMap(combinationsByChunk, a, c);
+							addToSetMap(combinationsByChunk, b, c);
+						}
+						return combinations;
 					});
-				});
-			});
-		return deserialize(this, false, readFile);
-	}
-}
 
-module.exports = FileMiddleware;
+					// list of modified chunks during this run
+					// combinations affected by this change are skipped to allow
+					// further optimizations
+					/** @type {Set<Chunk>} */
+					const modifiedChunks = new Set();
 
+					let changed = false;
+					// eslint-disable-next-line no-constant-condition
+					loop: while (true) {
+						const combination = combinations.popFirst();
+						if (combination === undefined) break;
 
-/***/ }),
+						combination.deleted = true;
+						const { a, b, integratedSize } = combination;
 
-/***/ 86791:
-/***/ (function(module) {
+						// skip over pair when
+						// one of the already merged chunks is a parent of one of the chunks
+						if (modifiedChunks.size > 0) {
+							const queue = new Set(a.groupsIterable);
+							for (const group of b.groupsIterable) {
+								queue.add(group);
+							}
+							for (const group of queue) {
+								for (const mChunk of modifiedChunks) {
+									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
+										// This is a potential pair which needs recalculation
+										// We can't do that now, but it merge before following pairs
+										// so we leave space for it, and consider chunks as modified
+										// just for the worse case
+										remainingChunksToMerge--;
+										if (remainingChunksToMerge <= 0) break loop;
+										modifiedChunks.add(a);
+										modifiedChunks.add(b);
+										continue loop;
+									}
+								}
+								for (const parent of group.parentsIterable) {
+									queue.add(parent);
+								}
+							}
+						}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+						// merge the chunks
+						if (chunkGraph.canChunksBeIntegrated(a, b)) {
+							chunkGraph.integrateChunks(a, b);
+							compilation.chunks.delete(b);
 
+							// flag chunk a as modified as further optimization are possible for all children here
+							modifiedChunks.add(a);
 
+							changed = true;
+							remainingChunksToMerge--;
+							if (remainingChunksToMerge <= 0) break;
 
-class MapObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.size);
-		for (const key of obj.keys()) {
-			write(key);
-		}
-		for (const value of obj.values()) {
-			write(value);
-		}
-	}
-	deserialize({ read }) {
-		let size = read();
-		const map = new Map();
-		const keys = [];
-		for (let i = 0; i < size; i++) {
-			keys.push(read());
-		}
-		for (let i = 0; i < size; i++) {
-			map.set(keys[i], read());
-		}
-		return map;
+							// Update all affected combinations
+							// delete all combination with the removed chunk
+							// we will use combinations with the kept chunk instead
+							for (const combination of combinationsByChunk.get(a)) {
+								if (combination.deleted) continue;
+								combination.deleted = true;
+								combinations.delete(combination);
+							}
+
+							// Update combinations with the kept chunk with new sizes
+							for (const combination of combinationsByChunk.get(b)) {
+								if (combination.deleted) continue;
+								if (combination.a === b) {
+									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
+										combination.deleted = true;
+										combinations.delete(combination);
+										continue;
+									}
+									// Update size
+									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
+										a,
+										combination.b,
+										options
+									);
+									const finishUpdate = combinations.startUpdate(combination);
+									combination.a = a;
+									combination.integratedSize = newIntegratedSize;
+									combination.aSize = integratedSize;
+									combination.sizeDiff =
+										combination.bSize + integratedSize - newIntegratedSize;
+									finishUpdate();
+								} else if (combination.b === b) {
+									if (!chunkGraph.canChunksBeIntegrated(combination.a, a)) {
+										combination.deleted = true;
+										combinations.delete(combination);
+										continue;
+									}
+									// Update size
+									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
+										combination.a,
+										a,
+										options
+									);
+
+									const finishUpdate = combinations.startUpdate(combination);
+									combination.b = a;
+									combination.integratedSize = newIntegratedSize;
+									combination.bSize = integratedSize;
+									combination.sizeDiff =
+										integratedSize + combination.aSize - newIntegratedSize;
+									finishUpdate();
+								}
+							}
+							combinationsByChunk.set(a, combinationsByChunk.get(b));
+							combinationsByChunk.delete(b);
+						}
+					}
+					if (changed) return true;
+				}
+			);
+		});
 	}
 }
-
-module.exports = MapObjectSerializer;
+module.exports = LimitChunkCountPlugin;
 
 
 /***/ }),
 
-/***/ 21048:
-/***/ (function(module) {
+/***/ 27868:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-class NullPrototypeObjectSerializer {
-	serialize(obj, { write }) {
-		const keys = Object.keys(obj);
-		for (const key of keys) {
-			write(key);
+const { UsageState } = __webpack_require__(63686);
+const {
+	numberToIdentifier,
+	NUMBER_OF_IDENTIFIER_START_CHARS,
+	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+} = __webpack_require__(39722);
+const { assignDeterministicIds } = __webpack_require__(63290);
+const { compareSelect, compareStringsNumeric } = __webpack_require__(29579);
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+
+/**
+ * @param {ExportsInfo} exportsInfo exports info
+ * @returns {boolean} mangle is possible
+ */
+const canMangle = exportsInfo => {
+	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused)
+		return false;
+	let hasSomethingToMangle = false;
+	for (const exportInfo of exportsInfo.exports) {
+		if (exportInfo.canMangle === true) {
+			hasSomethingToMangle = true;
 		}
-		write(null);
-		for (const key of keys) {
-			write(obj[key]);
+	}
+	return hasSomethingToMangle;
+};
+
+// Sort by name
+const comparator = compareSelect(e => e.name, compareStringsNumeric);
+/**
+ * @param {boolean} deterministic use deterministic names
+ * @param {ExportsInfo} exportsInfo exports info
+ * @param {boolean} isNamespace is namespace object
+ * @returns {void}
+ */
+const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
+	if (!canMangle(exportsInfo)) return;
+	const usedNames = new Set();
+	/** @type {ExportInfo[]} */
+	const mangleableExports = [];
+
+	// Avoid to renamed exports that are not provided when
+	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
+	// 2. there are other provided exports and deterministic mode is chosen:
+	//    non-provided exports would break the determinism
+	let avoidMangleNonProvided = !isNamespace;
+	if (!avoidMangleNonProvided && deterministic) {
+		for (const exportInfo of exportsInfo.ownedExports) {
+			if (exportInfo.provided !== false) {
+				avoidMangleNonProvided = true;
+				break;
+			}
 		}
 	}
-	deserialize({ read }) {
-		const obj = Object.create(null);
-		const keys = [];
-		let key = read();
-		while (key !== null) {
-			keys.push(key);
-			key = read();
+	for (const exportInfo of exportsInfo.ownedExports) {
+		const name = exportInfo.name;
+		if (!exportInfo.hasUsedName()) {
+			if (
+				// Can the export be mangled?
+				exportInfo.canMangle !== true ||
+				// Never rename 1 char exports
+				(name.length === 1 && /^[a-zA-Z0-9_$]/.test(name)) ||
+				// Don't rename 2 char exports in deterministic mode
+				(deterministic &&
+					name.length === 2 &&
+					/^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
+				// Don't rename exports that are not provided
+				(avoidMangleNonProvided && exportInfo.provided !== true)
+			) {
+				exportInfo.setUsedName(name);
+				usedNames.add(name);
+			} else {
+				mangleableExports.push(exportInfo);
+			}
 		}
-		for (const key of keys) {
-			obj[key] = read();
+		if (exportInfo.exportsInfoOwned) {
+			const used = exportInfo.getUsed(undefined);
+			if (
+				used === UsageState.OnlyPropertiesUsed ||
+				used === UsageState.Unused
+			) {
+				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
+			}
 		}
-		return obj;
+	}
+	if (deterministic) {
+		assignDeterministicIds(
+			mangleableExports,
+			e => e.name,
+			comparator,
+			(e, id) => {
+				const name = numberToIdentifier(id);
+				const size = usedNames.size;
+				usedNames.add(name);
+				if (size === usedNames.size) return false;
+				e.setUsedName(name);
+				return true;
+			},
+			[
+				NUMBER_OF_IDENTIFIER_START_CHARS,
+				NUMBER_OF_IDENTIFIER_START_CHARS *
+					NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+			],
+			NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
+			usedNames.size
+		);
+	} else {
+		const usedExports = [];
+		const unusedExports = [];
+		for (const exportInfo of mangleableExports) {
+			if (exportInfo.getUsed(undefined) === UsageState.Unused) {
+				unusedExports.push(exportInfo);
+			} else {
+				usedExports.push(exportInfo);
+			}
+		}
+		usedExports.sort(comparator);
+		unusedExports.sort(comparator);
+		let i = 0;
+		for (const list of [usedExports, unusedExports]) {
+			for (const exportInfo of list) {
+				let name;
+				do {
+					name = numberToIdentifier(i++);
+				} while (usedNames.has(name));
+				exportInfo.setUsedName(name);
+			}
+		}
+	}
+};
+
+class MangleExportsPlugin {
+	/**
+	 * @param {boolean} deterministic use deterministic names
+	 */
+	constructor(deterministic) {
+		this._deterministic = deterministic;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _deterministic: deterministic } = this;
+		compiler.hooks.compilation.tap("MangleExportsPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			compilation.hooks.optimizeCodeGeneration.tap(
+				"MangleExportsPlugin",
+				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
+						);
+					}
+					for (const module of modules) {
+						const isNamespace =
+							module.buildMeta && module.buildMeta.exportsType === "namespace";
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
+					}
+				}
+			);
+		});
 	}
 }
 
-module.exports = NullPrototypeObjectSerializer;
+module.exports = MangleExportsPlugin;
 
 
 /***/ }),
 
-/***/ 34795:
-/***/ (function(module, exports, __webpack_require__) {
+/***/ 85067:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const createHash = __webpack_require__(49835);
-const ArraySerializer = __webpack_require__(41721);
-const DateObjectSerializer = __webpack_require__(93475);
-const ErrorObjectSerializer = __webpack_require__(79479);
-const MapObjectSerializer = __webpack_require__(86791);
-const NullPrototypeObjectSerializer = __webpack_require__(21048);
-const PlainObjectSerializer = __webpack_require__(33040);
-const RegExpObjectSerializer = __webpack_require__(57328);
-const SerializerMiddleware = __webpack_require__(83137);
-const SetObjectSerializer = __webpack_require__(79240);
-
-/** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
-
-/** @typedef {new (...params: any[]) => any} Constructor */
-
-/*
-
-Format:
-
-File -> Section*
-Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
-
-ObjectSection -> ESCAPE (
-	number:relativeOffset (number > 0) |
-	string:request (string|null):export
-) Section:value* ESCAPE ESCAPE_END_OBJECT
-ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
-EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
-EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
-OtherSection -> any (except ESCAPE)
-
-Why using null as escape value?
-Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
-Technically any value can be used.
-
-*/
-
-/**
- * @typedef {Object} ObjectSerializerContext
- * @property {function(any): void} write
- */
-
-/**
- * @typedef {Object} ObjectDeserializerContext
- * @property {function(): any} read
- */
+const { STAGE_BASIC } = __webpack_require__(80057);
+const { runtimeEqual } = __webpack_require__(17156);
 
-/**
- * @typedef {Object} ObjectSerializer
- * @property {function(any, ObjectSerializerContext): void} serialize
- * @property {function(ObjectDeserializerContext): any} deserialize
- */
+/** @typedef {import("../Compiler")} Compiler */
 
-const setSetSize = (set, size) => {
-	let i = 0;
-	for (const item of set) {
-		if (i++ >= size) {
-			set.delete(item);
-		}
-	}
-};
+class MergeDuplicateChunksPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"MergeDuplicateChunksPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "MergeDuplicateChunksPlugin",
+						stage: STAGE_BASIC
+					},
+					chunks => {
+						const { chunkGraph, moduleGraph } = compilation;
 
-const setMapSize = (map, size) => {
-	let i = 0;
-	for (const item of map.keys()) {
-		if (i++ >= size) {
-			map.delete(item);
-		}
-	}
-};
+						// remember already tested chunks for performance
+						const notDuplicates = new Set();
 
-/**
- * @param {Buffer} buffer buffer
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const toHash = (buffer, hashFunction) => {
-	const hash = createHash(hashFunction);
-	hash.update(buffer);
-	return /** @type {string} */ (hash.digest("latin1"));
-};
+						// for each chunk
+						for (const chunk of chunks) {
+							// track a Set of all chunk that could be duplicates
+							let possibleDuplicates;
+							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+								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 chunkGraph.getModuleChunksIterable(
+										module
+									)) {
+										if (
+											dup !== chunk &&
+											chunkGraph.getNumberOfChunkModules(chunk) ===
+												chunkGraph.getNumberOfChunkModules(dup) &&
+											!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 (!chunkGraph.isModuleInChunk(module, dup)) {
+											possibleDuplicates.delete(dup);
+										}
+									}
+									// when all chunks has been removed we can break here
+									if (possibleDuplicates.size === 0) break;
+								}
+							}
 
-const ESCAPE = null;
-const ESCAPE_ESCAPE_VALUE = null;
-const ESCAPE_END_OBJECT = true;
-const ESCAPE_UNDEFINED = false;
+							// when we found duplicates
+							if (
+								possibleDuplicates !== undefined &&
+								possibleDuplicates.size > 0
+							) {
+								outer: for (const otherChunk of possibleDuplicates) {
+									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
+									if (chunkGraph.getNumberOfEntryModules(chunk) > 0) continue;
+									if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0)
+										continue;
+									if (!runtimeEqual(chunk.runtime, otherChunk.runtime)) {
+										for (const module of chunkGraph.getChunkModulesIterable(
+											chunk
+										)) {
+											const exportsInfo = moduleGraph.getExportsInfo(module);
+											if (
+												!exportsInfo.isEquallyUsed(
+													chunk.runtime,
+													otherChunk.runtime
+												)
+											) {
+												continue outer;
+											}
+										}
+									}
+									// merge them
+									if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
+										chunkGraph.integrateChunks(chunk, otherChunk);
+										compilation.chunks.delete(otherChunk);
+									}
+								}
+							}
 
-const CURRENT_VERSION = 2;
+							// don't check already processed chunks twice
+							notDuplicates.add(chunk);
+						}
+					}
+				);
+			}
+		);
+	}
+}
+module.exports = MergeDuplicateChunksPlugin;
 
-const serializers = new Map();
-const serializerInversed = new Map();
 
-const loadedRequests = new Set();
+/***/ }),
 
-const NOT_SERIALIZABLE = {};
+/***/ 53912:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const jsTypes = new Map();
-jsTypes.set(Object, new PlainObjectSerializer());
-jsTypes.set(Array, new ArraySerializer());
-jsTypes.set(null, new NullPrototypeObjectSerializer());
-jsTypes.set(Map, new MapObjectSerializer());
-jsTypes.set(Set, new SetObjectSerializer());
-jsTypes.set(Date, new DateObjectSerializer());
-jsTypes.set(RegExp, new RegExpObjectSerializer());
-jsTypes.set(Error, new ErrorObjectSerializer(Error));
-jsTypes.set(EvalError, new ErrorObjectSerializer(EvalError));
-jsTypes.set(RangeError, new ErrorObjectSerializer(RangeError));
-jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
-jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
-jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
-// real Object and Array types to. These types may occur in the wild too, e. g. when
-// using Structured Clone in postMessage.
-if (exports.constructor !== Object) {
-	const Obj = /** @type {typeof Object} */ (exports.constructor);
-	const Fn = /** @type {typeof Function} */ (Obj.constructor);
-	for (const [type, config] of Array.from(jsTypes)) {
-		if (type) {
-			const Type = new Fn(`return ${type.name};`)();
-			jsTypes.set(Type, config);
-		}
-	}
-}
 
-{
-	let i = 1;
-	for (const [type, serializer] of jsTypes) {
-		serializers.set(type, {
-			request: "",
-			name: i++,
-			serializer
-		});
-	}
-}
 
-for (const { request, name, serializer } of serializers.values()) {
-	serializerInversed.set(`${request}/${name}`, serializer);
-}
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const createSchemaValidation = __webpack_require__(32540);
 
-/** @type {Map<RegExp, (request: string) => boolean>} */
-const loaders = new Map();
+/** @typedef {import("../../declarations/plugins/optimize/MinChunkSizePlugin").MinChunkSizePluginOptions} MinChunkSizePluginOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
 
-/**
- * @typedef {ComplexSerializableType[]} DeserializedType
- * @typedef {PrimitiveSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class ObjectMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {function(any): void} extendContext context extensions
-	 * @param {string | Hash} hashFunction hash function to use
-	 */
-	constructor(extendContext, hashFunction = "md4") {
-		super();
-		this.extendContext = extendContext;
-		this._hashFunction = hashFunction;
+const validate = createSchemaValidation(
+	__webpack_require__(60135),
+	() => __webpack_require__(53850),
+	{
+		name: "Min Chunk Size Plugin",
+		baseDataPath: "options"
 	}
+);
+
+class MinChunkSizePlugin {
 	/**
-	 * @param {RegExp} regExp RegExp for which the request is tested
-	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
-	 * @returns {void}
+	 * @param {MinChunkSizePluginOptions} options options object
 	 */
-	static registerLoader(regExp, loader) {
-		loaders.set(regExp, loader);
+	constructor(options) {
+		validate(options);
+		this.options = options;
 	}
 
 	/**
-	 * @param {Constructor} Constructor the constructor
-	 * @param {string} request the request which will be required when deserializing
-	 * @param {string} name the name to make multiple serializer unique when sharing a request
-	 * @param {ObjectSerializer} serializer the serializer
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	static register(Constructor, request, name, serializer) {
-		const key = request + "/" + name;
+	apply(compiler) {
+		const options = this.options;
+		const minChunkSize = options.minChunkSize;
+		compiler.hooks.compilation.tap("MinChunkSizePlugin", compilation => {
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "MinChunkSizePlugin",
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					const equalOptions = {
+						chunkOverhead: 1,
+						entryChunkMultiplicator: 1
+					};
 
-		if (serializers.has(Constructor)) {
-			throw new Error(
-				`ObjectMiddleware.register: serializer for ${Constructor.name} is already registered`
-			);
-		}
+					const chunkSizesMap = new Map();
+					/** @type {[Chunk, Chunk][]} */
+					const combinations = [];
+					/** @type {Chunk[]} */
+					const smallChunks = [];
+					const visitedChunks = [];
+					for (const a of chunks) {
+						// check if one of the chunks sizes is smaller than the minChunkSize
+						// and filter pairs that can NOT be integrated!
+						if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
+							smallChunks.push(a);
+							for (const b of visitedChunks) {
+								if (chunkGraph.canChunksBeIntegrated(b, a))
+									combinations.push([b, a]);
+							}
+						} else {
+							for (const b of smallChunks) {
+								if (chunkGraph.canChunksBeIntegrated(b, a))
+									combinations.push([b, a]);
+							}
+						}
+						chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
+						visitedChunks.push(a);
+					}
 
-		if (serializerInversed.has(key)) {
-			throw new Error(
-				`ObjectMiddleware.register: serializer for ${key} is already registered`
-			);
-		}
+					const sortedSizeFilteredExtendedPairCombinations = combinations
+						.map(pair => {
+							// extend combination pairs with size and integrated size
+							const a = chunkSizesMap.get(pair[0]);
+							const b = chunkSizesMap.get(pair[1]);
+							const ab = chunkGraph.getIntegratedChunksSize(
+								pair[0],
+								pair[1],
+								options
+							);
+							/** @type {[number, number, Chunk, Chunk]} */
+							const extendedPair = [a + b - ab, ab, pair[0], pair[1]];
+							return extendedPair;
+						})
+						.sort((a, b) => {
+							// sadly javascript does an in place sort here
+							// sort by size
+							const diff = b[0] - a[0];
+							if (diff !== 0) return diff;
+							return a[1] - b[1];
+						});
 
-		serializers.set(Constructor, {
-			request,
-			name,
-			serializer
-		});
+					if (sortedSizeFilteredExtendedPairCombinations.length === 0) return;
 
-		serializerInversed.set(key, serializer);
-	}
+					const pair = sortedSizeFilteredExtendedPairCombinations[0];
 
-	/**
-	 * @param {Constructor} Constructor the constructor
-	 * @returns {void}
-	 */
-	static registerNotSerializable(Constructor) {
-		if (serializers.has(Constructor)) {
-			throw new Error(
-				`ObjectMiddleware.registerNotSerializable: serializer for ${Constructor.name} is already registered`
+					chunkGraph.integrateChunks(pair[2], pair[3]);
+					compilation.chunks.delete(pair[3]);
+					return true;
+				}
 			);
-		}
-
-		serializers.set(Constructor, NOT_SERIALIZABLE);
+		});
 	}
+}
+module.exports = MinChunkSizePlugin;
 
-	static getSerializerFor(object) {
-		const proto = Object.getPrototypeOf(object);
-		let c;
-		if (proto === null) {
-			// Object created with Object.create(null)
-			c = null;
-		} else {
-			c = proto.constructor;
-			if (!c) {
-				throw new Error(
-					"Serialization of objects with prototype without valid constructor property not possible"
-				);
-			}
-		}
-		const config = serializers.get(c);
 
-		if (!config) throw new Error(`No serializer registered for ${c.name}`);
-		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
+/***/ }),
 
-		return config;
-	}
+/***/ 85305:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	static getDeserializerFor(request, name) {
-		const key = request + "/" + name;
-		const serializer = serializerInversed.get(key);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (serializer === undefined) {
-			throw new Error(`No deserializer registered for ${key}`);
-		}
 
-		return serializer;
-	}
 
-	static _getDeserializerForWithoutError(request, name) {
-		const key = request + "/" + name;
-		const serializer = serializerInversed.get(key);
-		return serializer;
+const SizeFormatHelpers = __webpack_require__(71070);
+const WebpackError = __webpack_require__(53799);
+
+class MinMaxSizeWarning extends WebpackError {
+	constructor(keys, minSize, maxSize) {
+		let keysMessage = "Fallback cache group";
+		if (keys) {
+			keysMessage =
+				keys.length > 1
+					? `Cache groups ${keys.sort().join(", ")}`
+					: `Cache group ${keys[0]}`;
+		}
+		super(
+			`SplitChunksPlugin\n` +
+				`${keysMessage}\n` +
+				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
+				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
+				"This seem to be a invalid optimization.splitChunks configuration."
+		);
 	}
+}
 
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		/** @type {any[]} */
-		let result = [CURRENT_VERSION];
-		let currentPos = 0;
-		let referenceable = new Map();
-		const addReferenceable = item => {
-			referenceable.set(item, currentPos++);
-		};
-		let bufferDedupeMap = new Map();
-		const dedupeBuffer = buf => {
-			const len = buf.length;
-			const entry = bufferDedupeMap.get(len);
-			if (entry === undefined) {
-				bufferDedupeMap.set(len, buf);
-				return buf;
-			}
-			if (Buffer.isBuffer(entry)) {
-				if (len < 32) {
-					if (buf.equals(entry)) {
-						return entry;
-					}
-					bufferDedupeMap.set(len, [entry, buf]);
-					return buf;
-				} else {
-					const hash = toHash(entry, this._hashFunction);
-					const newMap = new Map();
-					newMap.set(hash, entry);
-					bufferDedupeMap.set(len, newMap);
-					const hashBuf = toHash(buf, this._hashFunction);
-					if (hash === hashBuf) {
-						return entry;
-					}
-					return buf;
-				}
-			} else if (Array.isArray(entry)) {
-				if (entry.length < 16) {
-					for (const item of entry) {
-						if (buf.equals(item)) {
-							return item;
-						}
-					}
-					entry.push(buf);
-					return buf;
-				} else {
-					const newMap = new Map();
-					const hash = toHash(buf, this._hashFunction);
-					let found;
-					for (const item of entry) {
-						const itemHash = toHash(item, this._hashFunction);
-						newMap.set(itemHash, item);
-						if (found === undefined && itemHash === hash) found = item;
-					}
-					bufferDedupeMap.set(len, newMap);
-					if (found === undefined) {
-						newMap.set(hash, buf);
-						return buf;
-					} else {
-						return found;
-					}
-				}
-			} else {
-				const hash = toHash(buf, this._hashFunction);
-				const item = entry.get(hash);
-				if (item !== undefined) {
-					return item;
-				}
-				entry.set(hash, buf);
-				return buf;
-			}
-		};
-		let currentPosTypeLookup = 0;
-		let objectTypeLookup = new Map();
-		const cycleStack = new Set();
-		const stackToString = item => {
-			const arr = Array.from(cycleStack);
-			arr.push(item);
-			return arr
-				.map(item => {
-					if (typeof item === "string") {
-						if (item.length > 100) {
-							return `String ${JSON.stringify(item.slice(0, 100)).slice(
-								0,
-								-1
-							)}..."`;
-						}
-						return `String ${JSON.stringify(item)}`;
-					}
-					try {
-						const { request, name } = ObjectMiddleware.getSerializerFor(item);
-						if (request) {
-							return `${request}${name ? `.${name}` : ""}`;
-						}
-					} catch (e) {
-						// ignore -> fallback
-					}
-					if (typeof item === "object" && item !== null) {
-						if (item.constructor) {
-							if (item.constructor === Object)
-								return `Object { ${Object.keys(item).join(", ")} }`;
-							if (item.constructor === Map) return `Map { ${item.size} items }`;
-							if (item.constructor === Array)
-								return `Array { ${item.length} items }`;
-							if (item.constructor === Set) return `Set { ${item.size} items }`;
-							if (item.constructor === RegExp) return item.toString();
-							return `${item.constructor.name}`;
-						}
-						return `Object [null prototype] { ${Object.keys(item).join(
-							", "
-						)} }`;
-					}
-					try {
-						return `${item}`;
-					} catch (e) {
-						return `(${e.message})`;
-					}
-				})
-				.join(" -> ");
-		};
-		let hasDebugInfoAttached;
-		let ctx = {
-			write(value, key) {
-				try {
-					process(value);
-				} catch (e) {
-					if (e !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined)
-							hasDebugInfoAttached = new WeakSet();
-						if (!hasDebugInfoAttached.has(e)) {
-							e.message += `\nwhile serializing ${stackToString(value)}`;
-							hasDebugInfoAttached.add(e);
-						}
-					}
-					throw e;
-				}
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			snapshot() {
-				return {
-					length: result.length,
-					cycleStackSize: cycleStack.size,
-					referenceableSize: referenceable.size,
-					currentPos,
-					objectTypeLookupSize: objectTypeLookup.size,
-					currentPosTypeLookup
-				};
-			},
-			rollback(snapshot) {
-				result.length = snapshot.length;
-				setSetSize(cycleStack, snapshot.cycleStackSize);
-				setMapSize(referenceable, snapshot.referenceableSize);
-				currentPos = snapshot.currentPos;
-				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
-				currentPosTypeLookup = snapshot.currentPosTypeLookup;
-			},
-			...context
-		};
-		this.extendContext(ctx);
-		const process = item => {
-			if (Buffer.isBuffer(item)) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
-					return;
-				}
-				const alreadyUsedBuffer = dedupeBuffer(item);
-				if (alreadyUsedBuffer !== item) {
-					const ref = referenceable.get(alreadyUsedBuffer);
-					if (ref !== undefined) {
-						referenceable.set(item, ref);
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-					item = alreadyUsedBuffer;
-				}
-				addReferenceable(item);
+module.exports = MinMaxSizeWarning;
 
-				result.push(item);
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-			} else if (
-				typeof item === "object"
-				// We don't have to check for null as ESCAPE is null and this has been checked before
-			) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
-					return;
-				}
 
-				if (cycleStack.has(item)) {
-					throw new Error(
-						`This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize.`
-					);
-				}
+/***/ }),
 
-				const { request, name, serializer } =
-					ObjectMiddleware.getSerializerFor(item);
-				const key = `${request}/${name}`;
-				const lastIndex = objectTypeLookup.get(key);
+/***/ 74844:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const asyncLib = __webpack_require__(78175);
+const ChunkGraph = __webpack_require__(64971);
+const ModuleGraph = __webpack_require__(99988);
+const { STAGE_DEFAULT } = __webpack_require__(80057);
+const HarmonyImportDependency = __webpack_require__(57154);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const {
+	intersectRuntime,
+	mergeRuntimeOwned,
+	filterRuntime,
+	runtimeToString,
+	mergeRuntime
+} = __webpack_require__(17156);
+const ConcatenatedModule = __webpack_require__(97198);
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @typedef {Object} Statistics
+ * @property {number} cached
+ * @property {number} alreadyInConfig
+ * @property {number} invalidModule
+ * @property {number} incorrectChunks
+ * @property {number} incorrectDependency
+ * @property {number} incorrectModuleDependency
+ * @property {number} incorrectChunksOfImporter
+ * @property {number} incorrectRuntimeCondition
+ * @property {number} importerFailed
+ * @property {number} added
+ */
 
-				if (lastIndex === undefined) {
-					objectTypeLookup.set(key, currentPosTypeLookup++);
+const formatBailoutReason = msg => {
+	return "ModuleConcatenation bailout: " + msg;
+};
 
-					result.push(ESCAPE, request, name);
-				} else {
-					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
-				}
+class ModuleConcatenationPlugin {
+	constructor(options) {
+		if (typeof options !== "object") options = {};
+		this.options = options;
+	}
 
-				cycleStack.add(item);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _backCompat: backCompat } = compiler;
+		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			const bailoutReasonMap = new Map();
 
-				try {
-					serializer.serialize(item, ctx);
-				} finally {
-					cycleStack.delete(item);
-				}
+			const setBailoutReason = (module, reason) => {
+				setInnerBailoutReason(module, reason);
+				moduleGraph
+					.getOptimizationBailout(module)
+					.push(
+						typeof reason === "function"
+							? rs => formatBailoutReason(reason(rs))
+							: formatBailoutReason(reason)
+					);
+			};
 
-				result.push(ESCAPE, ESCAPE_END_OBJECT);
+			const setInnerBailoutReason = (module, reason) => {
+				bailoutReasonMap.set(module, reason);
+			};
 
-				addReferenceable(item);
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-					addReferenceable(item);
-				}
+			const getInnerBailoutReason = (module, requestShortener) => {
+				const reason = bailoutReasonMap.get(module);
+				if (typeof reason === "function") return reason(requestShortener);
+				return reason;
+			};
 
-				if (item.length > 102400 && context.logger) {
-					context.logger.warn(
-						`Serializing big strings (${Math.round(
-							item.length / 1024
-						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
+			const formatBailoutWarning = (module, problem) => requestShortener => {
+				if (typeof problem === "function") {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)}: ${problem(requestShortener)}`
 					);
 				}
-
-				result.push(item);
-			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item))
-					throw new Error("Unexpected function " + item);
-				/** @type {SerializedType} */
-				const serializedData =
-					SerializerMiddleware.getLazySerializedValue(item);
-				if (serializedData !== undefined) {
-					if (typeof serializedData === "function") {
-						result.push(serializedData);
-					} else {
-						throw new Error("Not implemented");
-					}
-				} else if (SerializerMiddleware.isLazy(item, this)) {
-					throw new Error("Not implemented");
+				const reason = getInnerBailoutReason(module, requestShortener);
+				const reasonWithPrefix = reason ? `: ${reason}` : "";
+				if (module === problem) {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)}${reasonWithPrefix}`
+					);
 				} else {
-					const data = SerializerMiddleware.serializeLazy(item, data =>
-						this.serialize([data], context)
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)} because of ${problem.readableIdentifier(
+							requestShortener
+						)}${reasonWithPrefix}`
 					);
-					SerializerMiddleware.setLazySerializedValue(item, data);
-					result.push(data);
 				}
-			} else if (item === undefined) {
-				result.push(ESCAPE, ESCAPE_UNDEFINED);
-			} else {
-				result.push(item);
-			}
-		};
+			};
 
-		try {
-			for (const item of data) {
-				process(item);
-			}
-			return result;
-		} catch (e) {
-			if (e === NOT_SERIALIZABLE) return null;
+			compilation.hooks.optimizeChunkModules.tapAsync(
+				{
+					name: "ModuleConcatenationPlugin",
+					stage: STAGE_DEFAULT
+				},
+				(allChunks, modules, callback) => {
+					const logger = compilation.getLogger(
+						"webpack.ModuleConcatenationPlugin"
+					);
+					const { chunkGraph, moduleGraph } = compilation;
+					const relevantModules = [];
+					const possibleInners = new Set();
+					const context = {
+						chunkGraph,
+						moduleGraph
+					};
+					logger.time("select relevant modules");
+					for (const module of modules) {
+						let canBeRoot = true;
+						let canBeInner = true;
 
-			throw e;
-		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.write" method so it will reference
-			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
-			data =
-				result =
-				referenceable =
-				bufferDedupeMap =
-				objectTypeLookup =
-				ctx =
-					undefined;
-		}
-	}
+						const bailoutReason = module.getConcatenationBailoutReason(context);
+						if (bailoutReason) {
+							setBailoutReason(module, bailoutReason);
+							continue;
+						}
 
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		let currentDataPos = 0;
-		const read = () => {
-			if (currentDataPos >= data.length)
-				throw new Error("Unexpected end of stream");
+						// Must not be an async module
+						if (moduleGraph.isAsync(module)) {
+							setBailoutReason(module, `Module is async`);
+							continue;
+						}
 
-			return data[currentDataPos++];
-		};
+						// Must be in strict mode
+						if (!module.buildInfo.strict) {
+							setBailoutReason(module, `Module is not in strict mode`);
+							continue;
+						}
 
-		if (read() !== CURRENT_VERSION)
-			throw new Error("Version mismatch, serializer changed");
+						// Module must be in any chunk (we don't want to do useless work)
+						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
+							setBailoutReason(module, "Module is not in any chunk");
+							continue;
+						}
 
-		let currentPos = 0;
-		let referenceable = [];
-		const addReferenceable = item => {
-			referenceable.push(item);
-			currentPos++;
-		};
-		let currentPosTypeLookup = 0;
-		let objectTypeLookup = [];
-		let result = [];
-		let ctx = {
-			read() {
-				return decodeValue();
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			...context
-		};
-		this.extendContext(ctx);
-		const decodeValue = () => {
-			const item = read();
+						// Exports must be known (and not dynamic)
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						const relevantExports = exportsInfo.getRelevantExports(undefined);
+						const unknownReexports = relevantExports.filter(exportInfo => {
+							return (
+								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
+							);
+						});
+						if (unknownReexports.length > 0) {
+							setBailoutReason(
+								module,
+								`Reexports in this module do not have a static target (${Array.from(
+									unknownReexports,
+									exportInfo =>
+										`${
+											exportInfo.name || "other exports"
+										}: ${exportInfo.getUsedInfo()}`
+								).join(", ")})`
+							);
+							continue;
+						}
 
-			if (item === ESCAPE) {
-				const nextItem = read();
+						// Root modules must have a static list of exports
+						const unknownProvidedExports = relevantExports.filter(
+							exportInfo => {
+								return exportInfo.provided !== true;
+							}
+						);
+						if (unknownProvidedExports.length > 0) {
+							setBailoutReason(
+								module,
+								`List of module exports is dynamic (${Array.from(
+									unknownProvidedExports,
+									exportInfo =>
+										`${
+											exportInfo.name || "other exports"
+										}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
+								).join(", ")})`
+							);
+							canBeRoot = false;
+						}
 
-				if (nextItem === ESCAPE_ESCAPE_VALUE) {
-					return ESCAPE;
-				} else if (nextItem === ESCAPE_UNDEFINED) {
-					return undefined;
-				} else if (nextItem === ESCAPE_END_OBJECT) {
-					throw new Error(
-						`Unexpected end of object at position ${currentDataPos - 1}`
+						// Module must not be an entry point
+						if (chunkGraph.isEntryModule(module)) {
+							setInnerBailoutReason(module, "Module is an entry point");
+							canBeInner = false;
+						}
+
+						if (canBeRoot) relevantModules.push(module);
+						if (canBeInner) possibleInners.add(module);
+					}
+					logger.timeEnd("select relevant modules");
+					logger.debug(
+						`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
 					);
-				} else {
-					const request = nextItem;
-					let serializer;
+					// sort by depth
+					// modules with lower depth are more likely suited as roots
+					// this improves performance, because modules already selected as inner are skipped
+					logger.time("sort relevant modules");
+					relevantModules.sort((a, b) => {
+						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
+					});
+					logger.timeEnd("sort relevant modules");
 
-					if (typeof request === "number") {
-						if (request < 0) {
-							// relative reference
-							return referenceable[currentPos + request];
-						}
-						serializer = objectTypeLookup[currentPosTypeLookup - request];
-					} else {
-						if (typeof request !== "string") {
-							throw new Error(
-								`Unexpected type (${typeof request}) of request ` +
-									`at position ${currentDataPos - 1}`
-							);
+					/** @type {Statistics} */
+					const stats = {
+						cached: 0,
+						alreadyInConfig: 0,
+						invalidModule: 0,
+						incorrectChunks: 0,
+						incorrectDependency: 0,
+						incorrectModuleDependency: 0,
+						incorrectChunksOfImporter: 0,
+						incorrectRuntimeCondition: 0,
+						importerFailed: 0,
+						added: 0
+					};
+					let statsCandidates = 0;
+					let statsSizeSum = 0;
+					let statsEmptyConfigurations = 0;
+
+					logger.time("find modules to concatenate");
+					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
+						// TODO reconsider that when it's only used in a different runtime
+						if (usedAsInner.has(currentRoot)) continue;
+
+						let chunkRuntime = undefined;
+						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
+							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
 						}
-						const name = read();
+						const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
+						const filteredRuntime = filterRuntime(chunkRuntime, r =>
+							exportsInfo.isModuleUsed(r)
+						);
+						const activeRuntime =
+							filteredRuntime === true
+								? chunkRuntime
+								: filteredRuntime === false
+								? undefined
+								: filteredRuntime;
 
-						serializer = ObjectMiddleware._getDeserializerForWithoutError(
-							request,
-							name
+						// create a configuration with the root
+						const currentConfiguration = new ConcatConfiguration(
+							currentRoot,
+							activeRuntime
 						);
 
-						if (serializer === undefined) {
-							if (request && !loadedRequests.has(request)) {
-								let loaded = false;
-								for (const [regExp, loader] of loaders) {
-									if (regExp.test(request)) {
-										if (loader(request)) {
-											loaded = true;
-											break;
-										}
-									}
+						// cache failures to add modules
+						const failureCache = new Map();
+
+						// potential optional import candidates
+						/** @type {Set<Module>} */
+						const candidates = new Set();
+
+						// try to add all imports
+						for (const imp of this._getImports(
+							compilation,
+							currentRoot,
+							activeRuntime
+						)) {
+							candidates.add(imp);
+						}
+
+						for (const imp of candidates) {
+							const impCandidates = new Set();
+							const problem = this._tryToAdd(
+								compilation,
+								currentConfiguration,
+								imp,
+								chunkRuntime,
+								activeRuntime,
+								possibleInners,
+								impCandidates,
+								failureCache,
+								chunkGraph,
+								true,
+								stats
+							);
+							if (problem) {
+								failureCache.set(imp, problem);
+								currentConfiguration.addWarning(imp, problem);
+							} else {
+								for (const c of impCandidates) {
+									candidates.add(c);
 								}
-								if (!loaded) {
-									require(request);
+							}
+						}
+						statsCandidates += candidates.size;
+						if (!currentConfiguration.isEmpty()) {
+							const modules = currentConfiguration.getModules();
+							statsSizeSum += modules.size;
+							concatConfigurations.push(currentConfiguration);
+							for (const module of modules) {
+								if (module !== currentConfiguration.rootModule) {
+									usedAsInner.add(module);
 								}
+							}
+						} else {
+							statsEmptyConfigurations++;
+							const optimizationBailouts =
+								moduleGraph.getOptimizationBailout(currentRoot);
+							for (const warning of currentConfiguration.getWarningsSorted()) {
+								optimizationBailouts.push(
+									formatBailoutWarning(warning[0], warning[1])
+								);
+							}
+						}
+					}
+					logger.timeEnd("find modules to concatenate");
+					logger.debug(
+						`${
+							concatConfigurations.length
+						} successful concat configurations (avg size: ${
+							statsSizeSum / concatConfigurations.length
+						}), ${statsEmptyConfigurations} bailed out completely`
+					);
+					logger.debug(
+						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
+					);
+					// HACK: Sort configurations by length and start with the longest one
+					// to get the biggest 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)
+					logger.time(`sort concat configurations`);
+					concatConfigurations.sort((a, b) => {
+						return b.modules.size - a.modules.size;
+					});
+					logger.timeEnd(`sort concat configurations`);
+					const usedModules = new Set();
 
-								loadedRequests.add(request);
+					logger.time("create concatenated modules");
+					asyncLib.each(
+						concatConfigurations,
+						(concatConfiguration, callback) => {
+							const rootModule = concatConfiguration.rootModule;
+
+							// Avoid overlapping configurations
+							// TODO: remove this when todo above is fixed
+							if (usedModules.has(rootModule)) return callback();
+							const modules = concatConfiguration.getModules();
+							for (const m of modules) {
+								usedModules.add(m);
 							}
 
-							serializer = ObjectMiddleware.getDeserializerFor(request, name);
-						}
+							// Create a new ConcatenatedModule
+							let newModule = ConcatenatedModule.create(
+								rootModule,
+								modules,
+								concatConfiguration.runtime,
+								compiler.root,
+								compilation.outputOptions.hashFunction
+							);
 
-						objectTypeLookup.push(serializer);
-						currentPosTypeLookup++;
-					}
-					try {
-						const item = serializer.deserialize(ctx);
-						const end1 = read();
+							const build = () => {
+								newModule.build(
+									compiler.options,
+									compilation,
+									null,
+									null,
+									err => {
+										if (err) {
+											if (!err.module) {
+												err.module = newModule;
+											}
+											return callback(err);
+										}
+										integrate();
+									}
+								);
+							};
 
-						if (end1 !== ESCAPE) {
-							throw new Error("Expected end of object");
-						}
+							const integrate = () => {
+								if (backCompat) {
+									ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
+									ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
+								}
 
-						const end2 = read();
+								for (const warning of concatConfiguration.getWarningsSorted()) {
+									moduleGraph
+										.getOptimizationBailout(newModule)
+										.push(formatBailoutWarning(warning[0], warning[1]));
+								}
+								moduleGraph.cloneModuleAttributes(rootModule, newModule);
+								for (const m of modules) {
+									// add to builtModules when one of the included modules was built
+									if (compilation.builtModules.has(m)) {
+										compilation.builtModules.add(newModule);
+									}
+									if (m !== rootModule) {
+										// attach external references to the concatenated module too
+										moduleGraph.copyOutgoingModuleConnections(
+											m,
+											newModule,
+											c => {
+												return (
+													c.originModule === m &&
+													!(
+														c.dependency instanceof HarmonyImportDependency &&
+														modules.has(c.module)
+													)
+												);
+											}
+										);
+										// remove module from chunk
+										for (const chunk of chunkGraph.getModuleChunksIterable(
+											rootModule
+										)) {
+											chunkGraph.disconnectChunkAndModule(chunk, m);
+										}
+									}
+								}
+								compilation.modules.delete(rootModule);
+								ChunkGraph.clearChunkGraphForModule(rootModule);
+								ModuleGraph.clearModuleGraphForModule(rootModule);
 
-						if (end2 !== ESCAPE_END_OBJECT) {
-							throw new Error("Expected end of object");
-						}
+								// remove module from chunk
+								chunkGraph.replaceModule(rootModule, newModule);
+								// replace module references with the concatenated module
+								moduleGraph.moveModuleConnections(rootModule, newModule, c => {
+									const otherModule =
+										c.module === rootModule ? c.originModule : c.module;
+									const innerConnection =
+										c.dependency instanceof HarmonyImportDependency &&
+										modules.has(otherModule);
+									return !innerConnection;
+								});
+								// add concatenated module to the compilation
+								compilation.modules.add(newModule);
 
-						addReferenceable(item);
+								callback();
+							};
 
-						return item;
-					} catch (err) {
-						// As this is only for error handling, we omit creating a Map for
-						// faster access to this information, as this would affect performance
-						// in the good case
-						let serializerEntry;
-						for (const entry of serializers) {
-							if (entry[1].serializer === serializer) {
-								serializerEntry = entry;
-								break;
-							}
+							build();
+						},
+						err => {
+							logger.timeEnd("create concatenated modules");
+							process.nextTick(callback.bind(null, err));
 						}
-						const name = !serializerEntry
-							? "unknown"
-							: !serializerEntry[1].request
-							? serializerEntry[0].name
-							: serializerEntry[1].name
-							? `${serializerEntry[1].request} ${serializerEntry[1].name}`
-							: serializerEntry[1].request;
-						err.message += `\n(during deserialization of ${name})`;
-						throw err;
-					}
-				}
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					addReferenceable(item);
+					);
 				}
+			);
+		});
+	}
 
-				return item;
-			} else if (Buffer.isBuffer(item)) {
-				addReferenceable(item);
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @param {Module} module the module to be added
+	 * @param {RuntimeSpec} runtime the runtime scope
+	 * @returns {Set<Module>} the imported modules
+	 */
+	_getImports(compilation, module, runtime) {
+		const moduleGraph = compilation.moduleGraph;
+		const set = new Set();
+		for (const dep of module.dependencies) {
+			// Get reference info only for harmony Dependencies
+			if (!(dep instanceof HarmonyImportDependency)) continue;
 
-				return item;
-			} else if (typeof item === "function") {
-				return SerializerMiddleware.deserializeLazy(
-					item,
-					data => this.deserialize(data, context)[0]
-				);
-			} else {
-				return item;
+			const connection = moduleGraph.getConnection(dep);
+			// Reference is valid and has a module
+			if (
+				!connection ||
+				!connection.module ||
+				!connection.isTargetActive(runtime)
+			) {
+				continue;
 			}
-		};
 
-		try {
-			while (currentDataPos < data.length) {
-				result.push(decodeValue());
+			const importedNames = compilation.getDependencyReferencedExports(
+				dep,
+				undefined
+			);
+
+			if (
+				importedNames.every(i =>
+					Array.isArray(i) ? i.length > 0 : i.name.length > 0
+				) ||
+				Array.isArray(moduleGraph.getProvidedExports(module))
+			) {
+				set.add(connection.module);
 			}
-			return result;
-		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.read" method so it will reference
-			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
-			result = referenceable = data = objectTypeLookup = ctx = undefined;
 		}
+		return set;
 	}
-}
 
-module.exports = ObjectMiddleware;
-module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
-
-
-/***/ }),
+	/**
+	 * @param {Compilation} compilation webpack compilation
+	 * @param {ConcatConfiguration} config concat configuration (will be modified when added)
+	 * @param {Module} module the module to be added
+	 * @param {RuntimeSpec} runtime the runtime scope of the generated code
+	 * @param {RuntimeSpec} activeRuntime the runtime scope of the root module
+	 * @param {Set<Module>} possibleModules modules that are candidates
+	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
+	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
+	 * @param {Statistics} statistics gathering metrics
+	 * @returns {Module | function(RequestShortener): string} the problematic module
+	 */
+	_tryToAdd(
+		compilation,
+		config,
+		module,
+		runtime,
+		activeRuntime,
+		possibleModules,
+		candidates,
+		failureCache,
+		chunkGraph,
+		avoidMutateOnFailure,
+		statistics
+	) {
+		const cacheEntry = failureCache.get(module);
+		if (cacheEntry) {
+			statistics.cached++;
+			return cacheEntry;
+		}
 
-/***/ 33040:
-/***/ (function(module) {
+		// Already added?
+		if (config.has(module)) {
+			statistics.alreadyInConfig++;
+			return null;
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+		// Not possible to add?
+		if (!possibleModules.has(module)) {
+			statistics.invalidModule++;
+			failureCache.set(module, module); // cache failures for performance
+			return module;
+		}
 
+		// Module must be in the correct chunks
+		const missingChunks = Array.from(
+			chunkGraph.getModuleChunksIterable(config.rootModule)
+		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
+		if (missingChunks.length > 0) {
+			const problem = requestShortener => {
+				const missingChunksList = Array.from(
+					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
+				).sort();
+				const chunks = Array.from(
+					new Set(
+						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
+							chunk => chunk.name || "unnamed chunk(s)"
+						)
+					)
+				).sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
+					", "
+				)}, module is in chunk(s) ${chunks.join(", ")})`;
+			};
+			statistics.incorrectChunks++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
+		}
 
+		const moduleGraph = compilation.moduleGraph;
 
-const cache = new WeakMap();
+		const incomingConnections =
+			moduleGraph.getIncomingConnectionsByOriginModule(module);
 
-class ObjectStructure {
-	constructor() {
-		this.keys = undefined;
-		this.children = undefined;
-	}
+		const incomingConnectionsFromNonModules =
+			incomingConnections.get(null) || incomingConnections.get(undefined);
+		if (incomingConnectionsFromNonModules) {
+			const activeNonModulesConnections =
+				incomingConnectionsFromNonModules.filter(connection => {
+					// We are not interested in inactive connections
+					// or connections without dependency
+					return connection.isActive(runtime) || connection.dependency;
+				});
+			if (activeNonModulesConnections.length > 0) {
+				const problem = requestShortener => {
+					const importingExplanations = new Set(
+						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
+					);
+					const explanations = Array.from(importingExplanations).sort();
+					return `Module ${module.readableIdentifier(
+						requestShortener
+					)} is referenced ${
+						explanations.length > 0
+							? `by: ${explanations.join(", ")}`
+							: "in an unsupported way"
+					}`;
+				};
+				statistics.incorrectDependency++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
+		}
 
-	getKeys(keys) {
-		if (this.keys === undefined) this.keys = keys;
-		return this.keys;
-	}
+		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
+		const incomingConnectionsFromModules = new Map();
+		for (const [originModule, connections] of incomingConnections) {
+			if (originModule) {
+				// Ignore connection from orphan modules
+				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
 
-	key(key) {
-		if (this.children === undefined) this.children = new Map();
-		const child = this.children.get(key);
-		if (child !== undefined) return child;
-		const newChild = new ObjectStructure();
-		this.children.set(key, newChild);
-		return newChild;
-	}
-}
+				// We don't care for connections from other runtimes
+				let originRuntime = undefined;
+				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
+					originRuntime = mergeRuntimeOwned(originRuntime, r);
+				}
 
-const getCachedKeys = (keys, cacheAssoc) => {
-	let root = cache.get(cacheAssoc);
-	if (root === undefined) {
-		root = new ObjectStructure();
-		cache.set(cacheAssoc, root);
-	}
-	let current = root;
-	for (const key of keys) {
-		current = current.key(key);
-	}
-	return current.getKeys(keys);
-};
+				if (!intersectRuntime(runtime, originRuntime)) continue;
 
-class PlainObjectSerializer {
-	serialize(obj, { write }) {
-		const keys = Object.keys(obj);
-		if (keys.length > 128) {
-			// Objects with so many keys are unlikely to share structure
-			// with other objects
-			write(keys);
-			for (const key of keys) {
-				write(obj[key]);
-			}
-		} else if (keys.length > 1) {
-			write(getCachedKeys(keys, write));
-			for (const key of keys) {
-				write(obj[key]);
+				// We are not interested in inactive connections
+				const activeConnections = connections.filter(connection =>
+					connection.isActive(runtime)
+				);
+				if (activeConnections.length > 0)
+					incomingConnectionsFromModules.set(originModule, activeConnections);
 			}
-		} else if (keys.length === 1) {
-			const key = keys[0];
-			write(key);
-			write(obj[key]);
-		} else {
-			write(null);
 		}
-	}
-	deserialize({ read }) {
-		const keys = read();
-		const obj = {};
-		if (Array.isArray(keys)) {
-			for (const key of keys) {
-				obj[key] = read();
+
+		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
+
+		// Module must be in the same chunks like the referencing module
+		const otherChunkModules = incomingModules.filter(originModule => {
+			for (const chunk of chunkGraph.getModuleChunksIterable(
+				config.rootModule
+			)) {
+				if (!chunkGraph.isModuleInChunk(originModule, chunk)) {
+					return true;
+				}
 			}
-		} else if (keys !== null) {
-			obj[keys] = read();
+			return false;
+		});
+		if (otherChunkModules.length > 0) {
+			const problem = requestShortener => {
+				const names = otherChunkModules
+					.map(m => m.readableIdentifier(requestShortener))
+					.sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is referenced from different chunks by these modules: ${names.join(
+					", "
+				)}`;
+			};
+			statistics.incorrectChunksOfImporter++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
 		}
-		return obj;
-	}
-}
-
-module.exports = PlainObjectSerializer;
 
+		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
+		const nonHarmonyConnections = new Map();
+		for (const [originModule, connections] of incomingConnectionsFromModules) {
+			const selected = connections.filter(
+				connection =>
+					!connection.dependency ||
+					!(connection.dependency instanceof HarmonyImportDependency)
+			);
+			if (selected.length > 0)
+				nonHarmonyConnections.set(originModule, connections);
+		}
+		if (nonHarmonyConnections.size > 0) {
+			const problem = requestShortener => {
+				const names = Array.from(nonHarmonyConnections)
+					.map(([originModule, connections]) => {
+						return `${originModule.readableIdentifier(
+							requestShortener
+						)} (referenced with ${Array.from(
+							new Set(
+								connections
+									.map(c => c.dependency && c.dependency.type)
+									.filter(Boolean)
+							)
+						)
+							.sort()
+							.join(", ")})`;
+					})
+					.sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is referenced from these modules with unsupported syntax: ${names.join(
+					", "
+				)}`;
+			};
+			statistics.incorrectModuleDependency++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
+		}
 
-/***/ }),
+		if (runtime !== undefined && typeof runtime !== "string") {
+			// Module must be consistently referenced in the same runtimes
+			/** @type {{ originModule: Module, runtimeCondition: RuntimeSpec }[]} */
+			const otherRuntimeConnections = [];
+			outer: for (const [
+				originModule,
+				connections
+			] of incomingConnectionsFromModules) {
+				/** @type {false | RuntimeSpec} */
+				let currentRuntimeCondition = false;
+				for (const connection of connections) {
+					const runtimeCondition = filterRuntime(runtime, runtime => {
+						return connection.isTargetActive(runtime);
+					});
+					if (runtimeCondition === false) continue;
+					if (runtimeCondition === true) continue outer;
+					if (currentRuntimeCondition !== false) {
+						currentRuntimeCondition = mergeRuntime(
+							currentRuntimeCondition,
+							runtimeCondition
+						);
+					} else {
+						currentRuntimeCondition = runtimeCondition;
+					}
+				}
+				if (currentRuntimeCondition !== false) {
+					otherRuntimeConnections.push({
+						originModule,
+						runtimeCondition: currentRuntimeCondition
+					});
+				}
+			}
+			if (otherRuntimeConnections.length > 0) {
+				const problem = requestShortener => {
+					return `Module ${module.readableIdentifier(
+						requestShortener
+					)} is runtime-dependent referenced by these modules: ${Array.from(
+						otherRuntimeConnections,
+						({ originModule, runtimeCondition }) =>
+							`${originModule.readableIdentifier(
+								requestShortener
+							)} (expected runtime ${runtimeToString(
+								runtime
+							)}, module is only referenced in ${runtimeToString(
+								/** @type {RuntimeSpec} */ (runtimeCondition)
+							)})`
+					).join(", ")}`;
+				};
+				statistics.incorrectRuntimeCondition++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
+		}
 
-/***/ 57328:
-/***/ (function(module) {
+		let backup;
+		if (avoidMutateOnFailure) {
+			backup = config.snapshot();
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+		// Add the module
+		config.add(module);
 
+		incomingModules.sort(compareModulesByIdentifier);
 
+		// Every module which depends on the added module must be in the configuration too.
+		for (const originModule of incomingModules) {
+			const problem = this._tryToAdd(
+				compilation,
+				config,
+				originModule,
+				runtime,
+				activeRuntime,
+				possibleModules,
+				candidates,
+				failureCache,
+				chunkGraph,
+				false,
+				statistics
+			);
+			if (problem) {
+				if (backup !== undefined) config.rollback(backup);
+				statistics.importerFailed++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
+		}
 
-class RegExpObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.source);
-		write(obj.flags);
-	}
-	deserialize({ read }) {
-		return new RegExp(read(), read());
+		// Add imports to possible candidates list
+		for (const imp of this._getImports(compilation, module, runtime)) {
+			candidates.add(imp);
+		}
+		statistics.added++;
+		return null;
 	}
 }
 
-module.exports = RegExpObjectSerializer;
-
-
-/***/ }),
+class ConcatConfiguration {
+	/**
+	 * @param {Module} rootModule the root module
+	 * @param {RuntimeSpec} runtime the runtime
+	 */
+	constructor(rootModule, runtime) {
+		this.rootModule = rootModule;
+		this.runtime = runtime;
+		/** @type {Set<Module>} */
+		this.modules = new Set();
+		this.modules.add(rootModule);
+		/** @type {Map<Module, Module | function(RequestShortener): string>} */
+		this.warnings = new Map();
+	}
 
-/***/ 53080:
-/***/ (function(module) {
+	add(module) {
+		this.modules.add(module);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	has(module) {
+		return this.modules.has(module);
+	}
 
+	isEmpty() {
+		return this.modules.size === 1;
+	}
 
+	addWarning(module, problem) {
+		this.warnings.set(module, problem);
+	}
 
-class Serializer {
-	constructor(middlewares, context) {
-		this.serializeMiddlewares = middlewares.slice();
-		this.deserializeMiddlewares = middlewares.slice().reverse();
-		this.context = context;
+	getWarningsSorted() {
+		return new Map(
+			Array.from(this.warnings).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;
+			})
+		);
 	}
 
-	serialize(obj, context) {
-		const ctx = { ...context, ...this.context };
-		let current = obj;
-		for (const middleware of this.serializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => data && middleware.serialize(data, ctx));
-			} else if (current) {
-				try {
-					current = middleware.serialize(current, ctx);
-				} catch (err) {
-					current = Promise.reject(err);
-				}
-			} else break;
-		}
-		return current;
+	/**
+	 * @returns {Set<Module>} modules as set
+	 */
+	getModules() {
+		return this.modules;
 	}
 
-	deserialize(value, context) {
-		const ctx = { ...context, ...this.context };
-		/** @type {any} */
-		let current = value;
-		for (const middleware of this.deserializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => middleware.deserialize(data, ctx));
+	snapshot() {
+		return this.modules.size;
+	}
+
+	rollback(snapshot) {
+		const modules = this.modules;
+		for (const m of modules) {
+			if (snapshot === 0) {
+				modules.delete(m);
 			} else {
-				current = middleware.deserialize(current, ctx);
+				snapshot--;
 			}
 		}
-		return current;
 	}
 }
 
-module.exports = Serializer;
+module.exports = ModuleConcatenationPlugin;
 
 
 /***/ }),
 
-/***/ 83137:
+/***/ 46043:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const memoize = __webpack_require__(78676);
+const { SyncBailHook } = __webpack_require__(41242);
+const { RawSource, CachedSource, CompatSource } = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const WebpackError = __webpack_require__(53799);
+const { compareSelect, compareStrings } = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
 
-const LAZY_TARGET = Symbol("lazy serialization target");
-const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compiler")} Compiler */
+
+const EMPTY_SET = new Set();
+
+const addToList = (itemOrItems, list) => {
+	if (Array.isArray(itemOrItems)) {
+		for (const item of itemOrItems) {
+			list.add(item);
+		}
+	} else if (itemOrItems) {
+		list.add(itemOrItems);
+	}
+};
 
 /**
- * @template DeserializedType
- * @template SerializedType
+ * @template T
+ * @param {T[]} input list
+ * @param {function(T): Buffer} fn map function
+ * @returns {Buffer[]} buffers without duplicates
  */
-class SerializerMiddleware {
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+const mapAndDeduplicateBuffers = (input, fn) => {
+	// Buffer.equals compares size first so this should be efficient enough
+	// If it becomes a performance problem we can use a map and group by size
+	// instead of looping over all assets.
+	const result = [];
+	outer: for (const value of input) {
+		const buf = fn(value);
+		for (const other of result) {
+			if (buf.equals(other)) continue outer;
+		}
+		result.push(buf);
 	}
+	return result;
+};
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+/**
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
+ */
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+};
+
+const cachedSourceMap = new WeakMap();
+
+const toCachedSource = source => {
+	if (source instanceof CachedSource) {
+		return source;
 	}
+	const entry = cachedSourceMap.get(source);
+	if (entry !== undefined) return entry;
+	const newSource = new CachedSource(CompatSource.from(source));
+	cachedSourceMap.set(source, newSource);
+	return newSource;
+};
+
+/**
+ * @typedef {Object} AssetInfoForRealContentHash
+ * @property {string} name
+ * @property {AssetInfo} info
+ * @property {Source} source
+ * @property {RawSource | undefined} newSource
+ * @property {RawSource | undefined} newSourceWithoutOwn
+ * @property {string} content
+ * @property {Set<string>} ownHashes
+ * @property {Promise} contentComputePromise
+ * @property {Promise} contentComputeWithoutOwnPromise
+ * @property {Set<string>} referencedHashes
+ * @property {Set<string>} hashes
+ */
+
+/**
+ * @typedef {Object} CompilationHooks
+ * @property {SyncBailHook<[Buffer[], string], string>} updateHash
+ */
+
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
+class RealContentHashPlugin {
 	/**
-	 * @param {any | function(): Promise<any> | any} value contained value or function to value
-	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {object=} options lazy options
-	 * @param {any=} serializedValue serialized value
-	 * @returns {function(): Promise<any> | any} lazy function
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
 	 */
-	static createLazy(value, target, options = {}, serializedValue) {
-		if (SerializerMiddleware.isLazy(value, target)) return value;
-		const fn = typeof value === "function" ? value : () => value;
-		fn[LAZY_TARGET] = target;
-		/** @type {any} */ (fn).options = options;
-		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
-		return fn;
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				updateHash: new SyncBailHook(["content", "oldHash"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	constructor({ hashFunction, hashDigest }) {
+		this._hashFunction = hashFunction;
+		this._hashDigest = hashDigest;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {SerializerMiddleware<any, any>=} target target middleware
-	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static isLazy(fn, target) {
-		if (typeof fn !== "function") return false;
-		const t = fn[LAZY_TARGET];
-		return target ? t === target : !!t;
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
+			const cacheAnalyse = compilation.getCache(
+				"RealContentHashPlugin|analyse"
+			);
+			const cacheGenerate = compilation.getCache(
+				"RealContentHashPlugin|generate"
+			);
+			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
+			compilation.hooks.processAssets.tapPromise(
+				{
+					name: "RealContentHashPlugin",
+					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
+				},
+				async () => {
+					const assets = compilation.getAssets();
+					/** @type {AssetInfoForRealContentHash[]} */
+					const assetsWithInfo = [];
+					const hashToAssets = new Map();
+					for (const { source, info, name } of assets) {
+						const cachedSource = toCachedSource(source);
+						const content = cachedSource.source();
+						/** @type {Set<string>} */
+						const hashes = new Set();
+						addToList(info.contenthash, hashes);
+						const data = {
+							name,
+							info,
+							source: cachedSource,
+							/** @type {RawSource | undefined} */
+							newSource: undefined,
+							/** @type {RawSource | undefined} */
+							newSourceWithoutOwn: undefined,
+							content,
+							/** @type {Set<string>} */
+							ownHashes: undefined,
+							contentComputePromise: undefined,
+							contentComputeWithoutOwnPromise: undefined,
+							/** @type {Set<string>} */
+							referencedHashes: undefined,
+							hashes
+						};
+						assetsWithInfo.push(data);
+						for (const hash of hashes) {
+							const list = hashToAssets.get(hash);
+							if (list === undefined) {
+								hashToAssets.set(hash, [data]);
+							} else {
+								list.push(data);
+							}
+						}
+					}
+					if (hashToAssets.size === 0) return;
+					const hashRegExp = new RegExp(
+						Array.from(hashToAssets.keys(), quoteMeta).join("|"),
+						"g"
+					);
+					await Promise.all(
+						assetsWithInfo.map(async asset => {
+							const { name, source, content, hashes } = asset;
+							if (Buffer.isBuffer(content)) {
+								asset.referencedHashes = EMPTY_SET;
+								asset.ownHashes = EMPTY_SET;
+								return;
+							}
+							const etag = cacheAnalyse.mergeEtags(
+								cacheAnalyse.getLazyHashedEtag(source),
+								Array.from(hashes).join("|")
+							);
+							[asset.referencedHashes, asset.ownHashes] =
+								await cacheAnalyse.providePromise(name, etag, () => {
+									const referencedHashes = new Set();
+									let ownHashes = new Set();
+									const inContent = content.match(hashRegExp);
+									if (inContent) {
+										for (const hash of inContent) {
+											if (hashes.has(hash)) {
+												ownHashes.add(hash);
+												continue;
+											}
+											referencedHashes.add(hash);
+										}
+									}
+									return [referencedHashes, ownHashes];
+								});
+						})
+					);
+					const getDependencies = hash => {
+						const assets = hashToAssets.get(hash);
+						if (!assets) {
+							const referencingAssets = assetsWithInfo.filter(asset =>
+								asset.referencedHashes.has(hash)
+							);
+							const err = new WebpackError(`RealContentHashPlugin
+Some kind of unexpected caching problem occurred.
+An asset was cached with a reference to another asset (${hash}) that's not in the compilation anymore.
+Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
+Referenced by:
+${referencingAssets
+	.map(a => {
+		const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(
+			a.content
+		);
+		return ` - ${a.name}: ...${match ? match[0] : "???"}...`;
+	})
+	.join("\n")}`);
+							compilation.errors.push(err);
+							return undefined;
+						}
+						const hashes = new Set();
+						for (const { referencedHashes, ownHashes } of assets) {
+							if (!ownHashes.has(hash)) {
+								for (const hash of ownHashes) {
+									hashes.add(hash);
+								}
+							}
+							for (const hash of referencedHashes) {
+								hashes.add(hash);
+							}
+						}
+						return hashes;
+					};
+					const hashInfo = hash => {
+						const assets = hashToAssets.get(hash);
+						return `${hash} (${Array.from(assets, a => a.name)})`;
+					};
+					const hashesInOrder = new Set();
+					for (const hash of hashToAssets.keys()) {
+						const add = (hash, stack) => {
+							const deps = getDependencies(hash);
+							if (!deps) return;
+							stack.add(hash);
+							for (const dep of deps) {
+								if (hashesInOrder.has(dep)) continue;
+								if (stack.has(dep)) {
+									throw new Error(
+										`Circular hash dependency ${Array.from(
+											stack,
+											hashInfo
+										).join(" -> ")} -> ${hashInfo(dep)}`
+									);
+								}
+								add(dep, stack);
+							}
+							hashesInOrder.add(hash);
+							stack.delete(hash);
+						};
+						if (hashesInOrder.has(hash)) continue;
+						add(hash, new Set());
+					}
+					const hashToNewHash = new Map();
+					const getEtag = asset =>
+						cacheGenerate.mergeEtags(
+							cacheGenerate.getLazyHashedEtag(asset.source),
+							Array.from(asset.referencedHashes, hash =>
+								hashToNewHash.get(hash)
+							).join("|")
+						);
+					const computeNewContent = asset => {
+						if (asset.contentComputePromise) return asset.contentComputePromise;
+						return (asset.contentComputePromise = (async () => {
+							if (
+								asset.ownHashes.size > 0 ||
+								Array.from(asset.referencedHashes).some(
+									hash => hashToNewHash.get(hash) !== hash
+								)
+							) {
+								const identifier = asset.name;
+								const etag = getEtag(asset);
+								asset.newSource = await cacheGenerate.providePromise(
+									identifier,
+									etag,
+									() => {
+										const newContent = asset.content.replace(hashRegExp, hash =>
+											hashToNewHash.get(hash)
+										);
+										return new RawSource(newContent);
+									}
+								);
+							}
+						})());
+					};
+					const computeNewContentWithoutOwn = asset => {
+						if (asset.contentComputeWithoutOwnPromise)
+							return asset.contentComputeWithoutOwnPromise;
+						return (asset.contentComputeWithoutOwnPromise = (async () => {
+							if (
+								asset.ownHashes.size > 0 ||
+								Array.from(asset.referencedHashes).some(
+									hash => hashToNewHash.get(hash) !== hash
+								)
+							) {
+								const identifier = asset.name + "|without-own";
+								const etag = getEtag(asset);
+								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
+									identifier,
+									etag,
+									() => {
+										const newContent = asset.content.replace(
+											hashRegExp,
+											hash => {
+												if (asset.ownHashes.has(hash)) {
+													return "";
+												}
+												return hashToNewHash.get(hash);
+											}
+										);
+										return new RawSource(newContent);
+									}
+								);
+							}
+						})());
+					};
+					const comparator = compareSelect(a => a.name, compareStrings);
+					for (const oldHash of hashesInOrder) {
+						const assets = hashToAssets.get(oldHash);
+						assets.sort(comparator);
+						const hash = createHash(this._hashFunction);
+						await Promise.all(
+							assets.map(asset =>
+								asset.ownHashes.has(oldHash)
+									? computeNewContentWithoutOwn(asset)
+									: computeNewContent(asset)
+							)
+						);
+						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
+							if (asset.ownHashes.has(oldHash)) {
+								return asset.newSourceWithoutOwn
+									? asset.newSourceWithoutOwn.buffer()
+									: asset.source.buffer();
+							} else {
+								return asset.newSource
+									? asset.newSource.buffer()
+									: asset.source.buffer();
+							}
+						});
+						let newHash = hooks.updateHash.call(assetsContent, oldHash);
+						if (!newHash) {
+							for (const content of assetsContent) {
+								hash.update(content);
+							}
+							const digest = hash.digest(this._hashDigest);
+							newHash = /** @type {string} */ (digest.slice(0, oldHash.length));
+						}
+						hashToNewHash.set(oldHash, newHash);
+					}
+					await Promise.all(
+						assetsWithInfo.map(async asset => {
+							await computeNewContent(asset);
+							const newName = asset.name.replace(hashRegExp, hash =>
+								hashToNewHash.get(hash)
+							);
+
+							const infoUpdate = {};
+							const hash = asset.info.contenthash;
+							infoUpdate.contenthash = Array.isArray(hash)
+								? hash.map(hash => hashToNewHash.get(hash))
+								: hashToNewHash.get(hash);
+
+							if (asset.newSource !== undefined) {
+								compilation.updateAsset(
+									asset.name,
+									asset.newSource,
+									infoUpdate
+								);
+							} else {
+								compilation.updateAsset(asset.name, asset.source, infoUpdate);
+							}
+
+							if (asset.name !== newName) {
+								compilation.renameAsset(asset.name, newName);
+							}
+						})
+					);
+				}
+			);
+		});
 	}
+}
+
+module.exports = RealContentHashPlugin;
+
+
+/***/ }),
+
+/***/ 84760:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {object} options
-	 */
-	static getLazyOptions(fn) {
-		if (typeof fn !== "function") return undefined;
-		return /** @type {any} */ (fn).options;
-	}
 
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {any} serialized value
-	 */
-	static getLazySerializedValue(fn) {
-		if (typeof fn !== "function") return undefined;
-		return fn[LAZY_SERIALIZED_VALUE];
-	}
 
-	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {any} value serialized value
-	 * @returns {void}
-	 */
-	static setLazySerializedValue(fn, value) {
-		fn[LAZY_SERIALIZED_VALUE] = value;
-	}
+const { STAGE_BASIC, STAGE_ADVANCED } = __webpack_require__(80057);
 
-	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} serialize serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
-	 */
-	static serializeLazy(lazy, serialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => data && serialize(data));
-			}
-			return serialize(r);
-		});
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
-		lazy[LAZY_SERIALIZED_VALUE] = fn;
-		return fn;
-	}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
 
+class RemoveEmptyChunksPlugin {
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} deserialize deserialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static deserializeLazy(lazy, deserialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => deserialize(data));
-			}
-			return deserialize(r);
-		});
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
-		fn[LAZY_SERIALIZED_VALUE] = lazy;
-		return fn;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks array
+			 * @returns {void}
+			 */
+			const handler = chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				for (const chunk of chunks) {
+					if (
+						chunkGraph.getNumberOfChunkModules(chunk) === 0 &&
+						!chunk.hasRuntime() &&
+						chunkGraph.getNumberOfEntryModules(chunk) === 0
+					) {
+						compilation.chunkGraph.disconnectChunk(chunk);
+						compilation.chunks.delete(chunk);
+					}
+				}
+			};
 
-	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @returns {function(): Promise<any> | any} new lazy
-	 */
-	static unMemoizeLazy(lazy) {
-		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
-		const fn = () => {
-			throw new Error(
-				"A lazy value that has been unmemorized can't be called again"
+			// TODO do it once
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "RemoveEmptyChunksPlugin",
+					stage: STAGE_BASIC
+				},
+				handler
 			);
-		};
-		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
-			lazy[LAZY_SERIALIZED_VALUE]
-		);
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		fn.options = /** @type {any} */ (lazy).options;
-		return fn;
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "RemoveEmptyChunksPlugin",
+					stage: STAGE_ADVANCED
+				},
+				handler
+			);
+		});
 	}
 }
-
-module.exports = SerializerMiddleware;
+module.exports = RemoveEmptyChunksPlugin;
 
 
 /***/ }),
 
-/***/ 79240:
-/***/ (function(module) {
+/***/ 7081:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-class SetObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.size);
-		for (const value of obj) {
-			write(value);
-		}
-	}
-	deserialize({ read }) {
-		let size = read();
-		const set = new Set();
-		for (let i = 0; i < size; i++) {
-			set.add(read());
-		}
-		return set;
+const { STAGE_BASIC } = __webpack_require__(80057);
+const Queue = __webpack_require__(65930);
+const { intersect } = __webpack_require__(93347);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class RemoveParentModulesPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			const handler = (chunks, chunkGroups) => {
+				const chunkGraph = compilation.chunkGraph;
+				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);
+					}
+				}
+				for (const chunkGroup of compilation.asyncEntrypoints) {
+					// 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 chunkGraph.getChunkModulesIterable(chunk)) {
+										availableModules.add(m);
+									}
+								}
+								availableModulesMap.set(chunkGroup, availableModules);
+								changed = true;
+							} else {
+								for (const m of availableModules) {
+									if (
+										!chunkGraph.isModuleInChunkGroup(m, parent) &&
+										!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 = chunkGraph.getNumberOfChunkModules(chunk);
+					const toRemove = new Set();
+					if (numberOfModules < availableModules.size) {
+						for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+							if (availableModules.has(m)) {
+								toRemove.add(m);
+							}
+						}
+					} else {
+						for (const m of availableModules) {
+							if (chunkGraph.isModuleInChunk(m, chunk)) {
+								toRemove.add(m);
+							}
+						}
+					}
+					for (const module of toRemove) {
+						chunkGraph.disconnectChunkAndModule(chunk, module);
+					}
+				}
+			};
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "RemoveParentModulesPlugin",
+					stage: STAGE_BASIC
+				},
+				handler
+			);
+		});
 	}
 }
-
-module.exports = SetObjectSerializer;
+module.exports = RemoveParentModulesPlugin;
 
 
 /***/ }),
 
-/***/ 65112:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 2837:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const SerializerMiddleware = __webpack_require__(83137);
+/** @typedef {import("../Compiler")} Compiler */
 
-/**
- * @typedef {any} DeserializedType
- * @typedef {any[]} SerializedType
- * @extends {SerializerMiddleware<any, any[]>}
- */
-class SingleItemMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		return [data];
+class RuntimeChunkPlugin {
+	constructor(options) {
+		this.options = {
+			name: entrypoint => `runtime~${entrypoint.name}`,
+			...options
+		};
 	}
 
 	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	deserialize(data, context) {
-		return data[0];
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
+			compilation.hooks.addEntry.tap(
+				"RuntimeChunkPlugin",
+				(_, { name: entryName }) => {
+					if (entryName === undefined) return;
+					const data = compilation.entries.get(entryName);
+					if (data.options.runtime === undefined && !data.options.dependOn) {
+						// Determine runtime chunk name
+						let name = this.options.name;
+						if (typeof name === "function") {
+							name = name({ name: entryName });
+						}
+						data.options.runtime = name;
+					}
+				}
+			);
+		});
 	}
 }
 
-module.exports = SingleItemMiddleware;
+module.exports = RuntimeChunkPlugin;
 
 
 /***/ }),
 
-/***/ 58831:
+/***/ 84800:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -114425,34 +112168,341 @@ module.exports = SingleItemMiddleware;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
+const glob2regexp = __webpack_require__(86140);
+const { STAGE_DEFAULT } = __webpack_require__(80057);
+const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
+const HarmonyImportSpecifierDependency = __webpack_require__(14077);
+const formatLocation = __webpack_require__(16734);
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
+/**
+ * @typedef {Object} ExportInModule
+ * @property {Module} module the module
+ * @property {string} exportName the name of the export
+ * @property {boolean} checked if the export is conditional
+ */
+
+/**
+ * @typedef {Object} ReexportInfo
+ * @property {Map<string, ExportInModule[]>} static
+ * @property {Map<Module, Set<string>>} dynamic
+ */
+
+/** @type {WeakMap<any, Map<string, RegExp>>} */
+const globToRegexpCache = new WeakMap();
+
+/**
+ * @param {string} glob the pattern
+ * @param {Map<string, RegExp>} cache the glob to RegExp cache
+ * @returns {RegExp} a regular expression
+ */
+const globToRegexp = (glob, cache) => {
+	const cacheEntry = cache.get(glob);
+	if (cacheEntry !== undefined) return cacheEntry;
+	if (!glob.includes("/")) {
+		glob = `**/${glob}`;
+	}
+	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
+	const regexpSource = baseRegexp.source;
+	const regexp = new RegExp("^(\\./)?" + regexpSource.slice(1));
+	cache.set(glob, regexp);
+	return regexp;
+};
+
+class SideEffectsFlagPlugin {
+	/**
+	 * @param {boolean} analyseSource analyse source code for side effects
+	 */
+	constructor(analyseSource = true) {
+		this._analyseSource = analyseSource;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		let cache = globToRegexpCache.get(compiler.root);
+		if (cache === undefined) {
+			cache = new Map();
+			globToRegexpCache.set(compiler.root, cache);
+		}
+		compiler.hooks.compilation.tap(
+			"SideEffectsFlagPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const moduleGraph = compilation.moduleGraph;
+				normalModuleFactory.hooks.module.tap(
+					"SideEffectsFlagPlugin",
+					(module, data) => {
+						const resolveData = data.resourceResolveData;
+						if (
+							resolveData &&
+							resolveData.descriptionFileData &&
+							resolveData.relativePath
+						) {
+							const sideEffects = resolveData.descriptionFileData.sideEffects;
+							if (sideEffects !== undefined) {
+								if (module.factoryMeta === undefined) {
+									module.factoryMeta = {};
+								}
+								const hasSideEffects =
+									SideEffectsFlagPlugin.moduleHasSideEffects(
+										resolveData.relativePath,
+										sideEffects,
+										cache
+									);
+								module.factoryMeta.sideEffectFree = !hasSideEffects;
+							}
+						}
+
+						return module;
+					}
+				);
+				normalModuleFactory.hooks.module.tap(
+					"SideEffectsFlagPlugin",
+					(module, data) => {
+						if (typeof data.settings.sideEffects === "boolean") {
+							if (module.factoryMeta === undefined) {
+								module.factoryMeta = {};
+							}
+							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+						}
+						return module;
+					}
+				);
+				if (this._analyseSource) {
+					/**
+					 * @param {JavascriptParser} parser the parser
+					 * @returns {void}
+					 */
+					const parserHandler = parser => {
+						let sideEffectsStatement;
+						parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
+							sideEffectsStatement = undefined;
+						});
+						parser.hooks.statement.tap(
+							{ name: "SideEffectsFlagPlugin", stage: -100 },
+							statement => {
+								if (sideEffectsStatement) return;
+								if (parser.scope.topLevelScope !== true) return;
+								switch (statement.type) {
+									case "ExpressionStatement":
+										if (
+											!parser.isPure(statement.expression, statement.range[0])
+										) {
+											sideEffectsStatement = statement;
+										}
+										break;
+									case "IfStatement":
+									case "WhileStatement":
+									case "DoWhileStatement":
+										if (!parser.isPure(statement.test, statement.range[0])) {
+											sideEffectsStatement = statement;
+										}
+										// statement hook will be called for child statements too
+										break;
+									case "ForStatement":
+										if (
+											!parser.isPure(statement.init, statement.range[0]) ||
+											!parser.isPure(
+												statement.test,
+												statement.init
+													? statement.init.range[1]
+													: statement.range[0]
+											) ||
+											!parser.isPure(
+												statement.update,
+												statement.test
+													? statement.test.range[1]
+													: statement.init
+													? statement.init.range[1]
+													: statement.range[0]
+											)
+										) {
+											sideEffectsStatement = statement;
+										}
+										// statement hook will be called for child statements too
+										break;
+									case "SwitchStatement":
+										if (
+											!parser.isPure(statement.discriminant, statement.range[0])
+										) {
+											sideEffectsStatement = statement;
+										}
+										// statement hook will be called for child statements too
+										break;
+									case "VariableDeclaration":
+									case "ClassDeclaration":
+									case "FunctionDeclaration":
+										if (!parser.isPure(statement, statement.range[0])) {
+											sideEffectsStatement = statement;
+										}
+										break;
+									case "ExportNamedDeclaration":
+									case "ExportDefaultDeclaration":
+										if (
+											!parser.isPure(statement.declaration, statement.range[0])
+										) {
+											sideEffectsStatement = statement;
+										}
+										break;
+									case "LabeledStatement":
+									case "BlockStatement":
+										// statement hook will be called for child statements too
+										break;
+									case "EmptyStatement":
+										break;
+									case "ExportAllDeclaration":
+									case "ImportDeclaration":
+										// imports will be handled by the dependencies
+										break;
+									default:
+										sideEffectsStatement = statement;
+										break;
+								}
+							}
+						);
+						parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
+							if (sideEffectsStatement === undefined) {
+								parser.state.module.buildMeta.sideEffectFree = true;
+							} else {
+								const { loc, type } = sideEffectsStatement;
+								moduleGraph
+									.getOptimizationBailout(parser.state.module)
+									.push(
+										() =>
+											`Statement (${type}) with side effects in source code at ${formatLocation(
+												loc
+											)}`
+									);
+							}
+						});
+					};
+					for (const key of [
+						"javascript/auto",
+						"javascript/esm",
+						"javascript/dynamic"
+					]) {
+						normalModuleFactory.hooks.parser
+							.for(key)
+							.tap("SideEffectsFlagPlugin", parserHandler);
+					}
+				}
+				compilation.hooks.optimizeDependencies.tap(
+					{
+						name: "SideEffectsFlagPlugin",
+						stage: STAGE_DEFAULT
+					},
+					modules => {
+						const logger = compilation.getLogger(
+							"webpack.SideEffectsFlagPlugin"
+						);
 
-class ConsumeSharedFallbackDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
+						logger.time("update dependencies");
+						for (const module of modules) {
+							if (module.getSideEffectsConnectionState(moduleGraph) === false) {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								for (const connection of moduleGraph.getIncomingConnections(
+									module
+								)) {
+									const dep = connection.dependency;
+									let isReexport;
+									if (
+										(isReexport =
+											dep instanceof
+											HarmonyExportImportedSpecifierDependency) ||
+										(dep instanceof HarmonyImportSpecifierDependency &&
+											!dep.namespaceObjectAsContext)
+									) {
+										// TODO improve for export *
+										if (isReexport && dep.name) {
+											const exportInfo = moduleGraph.getExportInfo(
+												connection.originModule,
+												dep.name
+											);
+											exportInfo.moveTarget(
+												moduleGraph,
+												({ module }) =>
+													module.getSideEffectsConnectionState(moduleGraph) ===
+													false,
+												({ module: newModule, export: exportName }) => {
+													moduleGraph.updateModule(dep, newModule);
+													moduleGraph.addExplanation(
+														dep,
+														"(skipped side-effect-free modules)"
+													);
+													const ids = dep.getIds(moduleGraph);
+													dep.setIds(
+														moduleGraph,
+														exportName
+															? [...exportName, ...ids.slice(1)]
+															: ids.slice(1)
+													);
+													return moduleGraph.getConnection(dep);
+												}
+											);
+											continue;
+										}
+										// TODO improve for nested imports
+										const ids = dep.getIds(moduleGraph);
+										if (ids.length > 0) {
+											const exportInfo = exportsInfo.getExportInfo(ids[0]);
+											const target = exportInfo.getTarget(
+												moduleGraph,
+												({ module }) =>
+													module.getSideEffectsConnectionState(moduleGraph) ===
+													false
+											);
+											if (!target) continue;
 
-	get type() {
-		return "consume shared fallback";
+											moduleGraph.updateModule(dep, target.module);
+											moduleGraph.addExplanation(
+												dep,
+												"(skipped side-effect-free modules)"
+											);
+											dep.setIds(
+												moduleGraph,
+												target.export
+													? [...target.export, ...ids.slice(1)]
+													: ids.slice(1)
+											);
+										}
+									}
+								}
+							}
+						}
+						logger.timeEnd("update dependencies");
+					}
+				);
+			}
+		);
 	}
 
-	get category() {
-		return "esm";
+	static moduleHasSideEffects(moduleName, flagValue, cache) {
+		switch (typeof flagValue) {
+			case "undefined":
+				return true;
+			case "boolean":
+				return flagValue;
+			case "string":
+				return globToRegexp(flagValue, cache).test(moduleName);
+			case "object":
+				return flagValue.some(glob =>
+					SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob, cache)
+				);
+		}
 	}
 }
-
-makeSerializable(
-	ConsumeSharedFallbackDependency,
-	"webpack/lib/sharing/ConsumeSharedFallbackDependency"
-);
-
-module.exports = ConsumeSharedFallbackDependency;
+module.exports = SideEffectsFlagPlugin;
 
 
 /***/ }),
 
-/***/ 62286:
+/***/ 21478:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -114463,4395 +112513,2878 @@ module.exports = ConsumeSharedFallbackDependency;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const { rangeToString, stringifyHoley } = __webpack_require__(19702);
-const ConsumeSharedFallbackDependency = __webpack_require__(58831);
+const Chunk = __webpack_require__(39385);
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const WebpackError = __webpack_require__(53799);
+const { requestToId } = __webpack_require__(63290);
+const { isSubset } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
+const {
+	compareModulesByIdentifier,
+	compareIterables
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const deterministicGrouping = __webpack_require__(59836);
+const { makePathsRelative } = __webpack_require__(82186);
+const memoize = __webpack_require__(78676);
+const MinMaxSizeWarning = __webpack_require__(85305);
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
+/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").PathData} PathData */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
+/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
+
+/** @typedef {Record<string, number>} SplitChunksSizes */
 
 /**
- * @typedef {Object} ConsumeOptions
- * @property {string=} import fallback request
- * @property {string=} importResolved resolved fallback request
- * @property {string} shareKey global share key
- * @property {string} shareScope share scope
- * @property {SemVerRange | false | undefined} requiredVersion version requirement
- * @property {string} packageName package name to determine required version automatically
- * @property {boolean} strictVersion don't use shared version even if version isn't valid
- * @property {boolean} singleton use single global version
- * @property {boolean} eager include the fallback module in a sync way
+ * @callback ChunkFilterFunction
+ * @param {Chunk} chunk
+ * @returns {boolean}
  */
 
-const TYPES = new Set(["consume-shared"]);
-
-class ConsumeSharedModule extends Module {
-	/**
-	 * @param {string} context context
-	 * @param {ConsumeOptions} options consume options
-	 */
-	constructor(context, options) {
-		super("consume-shared-module", context);
-		this.options = options;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		const {
-			shareKey,
-			shareScope,
-			importResolved,
-			requiredVersion,
-			strictVersion,
-			singleton,
-			eager
-		} = this.options;
-		return `consume-shared-module|${shareScope}|${shareKey}|${
-			requiredVersion && rangeToString(requiredVersion)
-		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
-	}
-
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		const {
-			shareKey,
-			shareScope,
-			importResolved,
-			requiredVersion,
-			strictVersion,
-			singleton,
-			eager
-		} = this.options;
-		return `consume shared module (${shareScope}) ${shareKey}@${
-			requiredVersion ? rangeToString(requiredVersion) : "*"
-		}${strictVersion ? " (strict)" : ""}${singleton ? " (singleton)" : ""}${
-			importResolved
-				? ` (fallback: ${requestShortener.shorten(importResolved)})`
-				: ""
-		}${eager ? " (eager)" : ""}`;
-	}
+/**
+ * @callback CombineSizeFunction
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		const { shareKey, shareScope, import: request } = this.options;
-		return `${
-			this.layer ? `(${this.layer})/` : ""
-		}webpack/sharing/consume/${shareScope}/${shareKey}${
-			request ? `/${request}` : ""
-		}`;
-	}
+/**
+ * @typedef {Object} CacheGroupSource
+ * @property {string=} key
+ * @property {number=} priority
+ * @property {GetName=} getName
+ * @property {ChunkFilterFunction=} chunksFilter
+ * @property {boolean=} enforce
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
+ * @property {SplitChunksSizes} minRemainingSize
+ * @property {SplitChunksSizes} enforceSizeThreshold
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {number=} minChunks
+ * @property {number=} maxAsyncRequests
+ * @property {number=} maxInitialRequests
+ * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {string=} idHint
+ * @property {string} automaticNameDelimiter
+ * @property {boolean=} reuseExistingChunk
+ * @property {boolean=} usedExports
+ */
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
-	}
+/**
+ * @typedef {Object} CacheGroup
+ * @property {string} key
+ * @property {number=} priority
+ * @property {GetName=} getName
+ * @property {ChunkFilterFunction=} chunksFilter
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
+ * @property {SplitChunksSizes} minRemainingSize
+ * @property {SplitChunksSizes} enforceSizeThreshold
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {number=} minChunks
+ * @property {number=} maxAsyncRequests
+ * @property {number=} maxInitialRequests
+ * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {string=} idHint
+ * @property {string} automaticNameDelimiter
+ * @property {boolean} reuseExistingChunk
+ * @property {boolean} usedExports
+ * @property {boolean} _validateSize
+ * @property {boolean} _validateRemainingSize
+ * @property {SplitChunksSizes} _minSizeForMaxSize
+ * @property {boolean} _conditionalEnforce
+ */
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {};
-		if (this.options.import) {
-			const dep = new ConsumeSharedFallbackDependency(this.options.import);
-			if (this.options.eager) {
-				this.addDependency(dep);
-			} else {
-				const block = new AsyncDependenciesBlock({});
-				block.addDependency(dep);
-				this.addBlock(block);
-			}
-		}
-		callback();
-	}
+/**
+ * @typedef {Object} FallbackCacheGroup
+ * @property {ChunkFilterFunction} chunksFilter
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {string} automaticNameDelimiter
+ */
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+/**
+ * @typedef {Object} CacheGroupsContext
+ * @property {ModuleGraph} moduleGraph
+ * @property {ChunkGraph} chunkGraph
+ */
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 42;
-	}
+/**
+ * @callback GetCacheGroups
+ * @param {Module} module
+ * @param {CacheGroupsContext} context
+ * @returns {CacheGroupSource[]}
+ */
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(JSON.stringify(this.options));
-		super.updateHash(hash, context);
-	}
+/**
+ * @callback GetName
+ * @param {Module=} module
+ * @param {Chunk[]=} chunks
+ * @param {string=} key
+ * @returns {string=}
+ */
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ chunkGraph, moduleGraph, runtimeTemplate }) {
-		const runtimeRequirements = new Set([RuntimeGlobals.shareScopeMap]);
-		const {
-			shareScope,
-			shareKey,
-			strictVersion,
-			requiredVersion,
-			import: request,
-			singleton,
-			eager
-		} = this.options;
-		let fallbackCode;
-		if (request) {
-			if (eager) {
-				const dep = this.dependencies[0];
-				fallbackCode = runtimeTemplate.syncModuleFactory({
-					dependency: dep,
-					chunkGraph,
-					runtimeRequirements,
-					request: this.options.import
-				});
-			} else {
-				const block = this.blocks[0];
-				fallbackCode = runtimeTemplate.asyncModuleFactory({
-					block,
-					chunkGraph,
-					runtimeRequirements,
-					request: this.options.import
-				});
-			}
-		}
-		let fn = "load";
-		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
-		if (requiredVersion) {
-			if (strictVersion) {
-				fn += "Strict";
-			}
-			if (singleton) {
-				fn += "Singleton";
-			}
-			args.push(stringifyHoley(requiredVersion));
-			fn += "VersionCheck";
-		} else {
-			if (singleton) {
-				fn += "Singleton";
-			}
-		}
-		if (fallbackCode) {
-			fn += "Fallback";
-			args.push(fallbackCode);
-		}
-		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
-		const sources = new Map();
-		sources.set("consume-shared", new RawSource(code));
-		return {
-			runtimeRequirements,
-			sources
-		};
-	}
+/**
+ * @typedef {Object} SplitChunksOptions
+ * @property {ChunkFilterFunction} chunksFilter
+ * @property {string[]} defaultSizeTypes
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
+ * @property {SplitChunksSizes} minRemainingSize
+ * @property {SplitChunksSizes} enforceSizeThreshold
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {number} minChunks
+ * @property {number} maxAsyncRequests
+ * @property {number} maxInitialRequests
+ * @property {boolean} hidePathInfo
+ * @property {string | function(PathData, AssetInfo=): string} filename
+ * @property {string} automaticNameDelimiter
+ * @property {GetCacheGroups} getCacheGroups
+ * @property {GetName} getName
+ * @property {boolean} usedExports
+ * @property {FallbackCacheGroup} fallbackCacheGroup
+ */
 
-	serialize(context) {
-		const { write } = context;
-		write(this.options);
-		super.serialize(context);
-	}
+/**
+ * @typedef {Object} ChunksInfoItem
+ * @property {SortableSet<Module>} modules
+ * @property {CacheGroup} cacheGroup
+ * @property {number} cacheGroupIndex
+ * @property {string} name
+ * @property {Record<string, number>} sizes
+ * @property {Set<Chunk>} chunks
+ * @property {Set<Chunk>} reuseableChunks
+ * @property {Set<bigint | Chunk>} chunksKeys
+ */
 
-	deserialize(context) {
-		const { read } = context;
-		this.options = read();
-		super.deserialize(context);
-	}
-}
+const defaultGetName = /** @type {GetName} */ (() => {});
 
-makeSerializable(
-	ConsumeSharedModule,
-	"webpack/lib/sharing/ConsumeSharedModule"
-);
+const deterministicGroupingForModules =
+	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
+		deterministicGrouping
+	);
 
-module.exports = ConsumeSharedModule;
+/** @type {WeakMap<Module, string>} */
+const getKeyCache = new WeakMap();
 
+/**
+ * @param {string} name a filename to hash
+ * @param {OutputOptions} outputOptions hash function used
+ * @returns {string} hashed filename
+ */
+const hashFilename = (name, outputOptions) => {
+	const digest = /** @type {string} */ (
+		createHash(outputOptions.hashFunction)
+			.update(name)
+			.digest(outputOptions.hashDigest)
+	);
+	return digest.slice(0, 8);
+};
 
-/***/ }),
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {number} the number of requests
+ */
+const getRequests = chunk => {
+	let requests = 0;
+	for (const chunkGroup of chunk.groupsIterable) {
+		requests = Math.max(requests, chunkGroup.chunks.length);
+	}
+	return requests;
+};
 
-/***/ 15046:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const mapObject = (obj, fn) => {
+	const newObj = Object.create(null);
+	for (const key of Object.keys(obj)) {
+		newObj[key] = fn(obj[key], key);
+	}
+	return newObj;
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @template T
+ * @param {Set<T>} a set
+ * @param {Set<T>} b other set
+ * @returns {boolean} true if at least one item of a is in b
+ */
+const isOverlap = (a, b) => {
+	for (const item of a) {
+		if (b.has(item)) return true;
+	}
+	return false;
+};
 
+const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
+/**
+ * @param {ChunksInfoItem} a item
+ * @param {ChunksInfoItem} b item
+ * @returns {number} compare result
+ */
+const compareEntries = (a, b) => {
+	// 1. by priority
+	const diffPriority = a.cacheGroup.priority - b.cacheGroup.priority;
+	if (diffPriority) return diffPriority;
+	// 2. by number of chunks
+	const diffCount = a.chunks.size - b.chunks.size;
+	if (diffCount) return diffCount;
+	// 3. by size reduction
+	const aSizeReduce = totalSize(a.sizes) * (a.chunks.size - 1);
+	const bSizeReduce = totalSize(b.sizes) * (b.chunks.size - 1);
+	const diffSizeReduce = aSizeReduce - bSizeReduce;
+	if (diffSizeReduce) return diffSizeReduce;
+	// 4. by cache group index
+	const indexDiff = b.cacheGroupIndex - a.cacheGroupIndex;
+	if (indexDiff) return indexDiff;
+	// 5. by number of modules (to be able to compare by identifier)
+	const modulesA = a.modules;
+	const modulesB = b.modules;
+	const diff = modulesA.size - modulesB.size;
+	if (diff) return diff;
+	// 6. by module identifiers
+	modulesA.sort();
+	modulesB.sort();
+	return compareModuleIterables(modulesA, modulesB);
+};
 
-const ModuleNotFoundError = __webpack_require__(32882);
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const { parseOptions } = __webpack_require__(3083);
-const LazySet = __webpack_require__(38938);
-const createSchemaValidation = __webpack_require__(32540);
-const { parseRange } = __webpack_require__(19702);
-const ConsumeSharedFallbackDependency = __webpack_require__(58831);
-const ConsumeSharedModule = __webpack_require__(62286);
-const ConsumeSharedRuntimeModule = __webpack_require__(10394);
-const ProvideForSharedDependency = __webpack_require__(40017);
-const { resolveMatchedConfigs } = __webpack_require__(3591);
-const {
-	isRequiredVersion,
-	getDescriptionFile,
-	getRequiredVersionFromDescriptionFile
-} = __webpack_require__(84379);
+const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+const ALL_CHUNK_FILTER = chunk => true;
 
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
-/** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
+/**
+ * @param {OptimizationSplitChunksSizes} value the sizes
+ * @param {string[]} defaultSizeTypes the default size types
+ * @returns {SplitChunksSizes} normalized representation
+ */
+const normalizeSizes = (value, defaultSizeTypes) => {
+	if (typeof value === "number") {
+		/** @type {Record<string, number>} */
+		const o = {};
+		for (const sizeType of defaultSizeTypes) o[sizeType] = value;
+		return o;
+	} else if (typeof value === "object" && value !== null) {
+		return { ...value };
+	} else {
+		return {};
+	}
+};
 
-const validate = createSchemaValidation(
-	__webpack_require__(6464),
-	() => __webpack_require__(16116),
-	{
-		name: "Consume Shared Plugin",
-		baseDataPath: "options"
+/**
+ * @param {...SplitChunksSizes} sizes the sizes
+ * @returns {SplitChunksSizes} the merged sizes
+ */
+const mergeSizes = (...sizes) => {
+	/** @type {SplitChunksSizes} */
+	let merged = {};
+	for (let i = sizes.length - 1; i >= 0; i--) {
+		merged = Object.assign(merged, sizes[i]);
 	}
-);
+	return merged;
+};
 
-/** @type {ResolveOptionsWithDependencyType} */
-const RESOLVE_OPTIONS = { dependencyType: "esm" };
-const PLUGIN_NAME = "ConsumeSharedPlugin";
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @returns {boolean} true, if there are sizes > 0
+ */
+const hasNonZeroSizes = sizes => {
+	for (const key of Object.keys(sizes)) {
+		if (sizes[key] > 0) return true;
+	}
+	return false;
+};
 
-class ConsumeSharedPlugin {
-	/**
-	 * @param {ConsumeSharedPluginOptions} options options
-	 */
-	constructor(options) {
-		if (typeof options !== "string") {
-			validate(options);
+/**
+ * @param {SplitChunksSizes} a first sizes
+ * @param {SplitChunksSizes} b second sizes
+ * @param {CombineSizeFunction} combine a function to combine sizes
+ * @returns {SplitChunksSizes} the combine sizes
+ */
+const combineSizes = (a, b, combine) => {
+	const aKeys = new Set(Object.keys(a));
+	const bKeys = new Set(Object.keys(b));
+	/** @type {SplitChunksSizes} */
+	const result = {};
+	for (const key of aKeys) {
+		if (bKeys.has(key)) {
+			result[key] = combine(a[key], b[key]);
+		} else {
+			result[key] = a[key];
+		}
+	}
+	for (const key of bKeys) {
+		if (!aKeys.has(key)) {
+			result[key] = b[key];
 		}
+	}
+	return result;
+};
 
-		/** @type {[string, ConsumeOptions][]} */
-		this._consumes = parseOptions(
-			options.consumes,
-			(item, key) => {
-				if (Array.isArray(item)) throw new Error("Unexpected array in options");
-				/** @type {ConsumeOptions} */
-				let result =
-					item === key || !isRequiredVersion(item)
-						? // item is a request/key
-						  {
-								import: key,
-								shareScope: options.shareScope || "default",
-								shareKey: key,
-								requiredVersion: undefined,
-								packageName: undefined,
-								strictVersion: false,
-								singleton: false,
-								eager: false
-						  }
-						: // key is a request/key
-						  // item is a version
-						  {
-								import: key,
-								shareScope: options.shareScope || "default",
-								shareKey: key,
-								requiredVersion: parseRange(item),
-								strictVersion: true,
-								packageName: undefined,
-								singleton: false,
-								eager: false
-						  };
-				return result;
-			},
-			(item, key) => ({
-				import: item.import === false ? undefined : item.import || key,
-				shareScope: item.shareScope || options.shareScope || "default",
-				shareKey: item.shareKey || key,
-				requiredVersion:
-					typeof item.requiredVersion === "string"
-						? parseRange(item.requiredVersion)
-						: item.requiredVersion,
-				strictVersion:
-					typeof item.strictVersion === "boolean"
-						? item.strictVersion
-						: item.import !== false && !item.singleton,
-				packageName: item.packageName,
-				singleton: !!item.singleton,
-				eager: !!item.eager
-			})
-		);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSize the min sizes
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
+ */
+const checkMinSize = (sizes, minSize) => {
+	for (const key of Object.keys(minSize)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size < minSize[key]) return false;
 	}
+	return true;
+};
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ConsumeSharedFallbackDependency,
-					normalModuleFactory
-				);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSizeReduction the min sizes
+ * @param {number} chunkCount number of chunks
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
+ */
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+	for (const key of Object.keys(minSizeReduction)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size * chunkCount < minSizeReduction[key]) return false;
+	}
+	return true;
+};
 
-				let unresolvedConsumes, resolvedConsumes, prefixedConsumes;
-				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
-					({ resolved, unresolved, prefixed }) => {
-						resolvedConsumes = resolved;
-						unresolvedConsumes = unresolved;
-						prefixedConsumes = prefixed;
-					}
-				);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSize the min sizes
+ * @returns {undefined | string[]} list of size types that are below min size
+ */
+const getViolatingMinSizes = (sizes, minSize) => {
+	let list;
+	for (const key of Object.keys(minSize)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size < minSize[key]) {
+			if (list === undefined) list = [key];
+			else list.push(key);
+		}
+	}
+	return list;
+};
 
-				const resolver = compilation.resolverFactory.get(
-					"normal",
-					RESOLVE_OPTIONS
-				);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @returns {number} the total size
+ */
+const totalSize = sizes => {
+	let size = 0;
+	for (const key of Object.keys(sizes)) {
+		size += sizes[key];
+	}
+	return size;
+};
 
-				/**
-				 * @param {string} context issuer directory
-				 * @param {string} request request
-				 * @param {ConsumeOptions} config options
-				 * @returns {Promise<ConsumeSharedModule>} create module
-				 */
-				const createConsumeSharedModule = (context, request, config) => {
-					const requiredVersionWarning = details => {
-						const error = new WebpackError(
-							`No required version specified and unable to automatically determine one. ${details}`
-						);
-						error.file = `shared module ${request}`;
-						compilation.warnings.push(error);
-					};
-					const directFallback =
-						config.import &&
-						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
-					return Promise.all([
-						new Promise(resolve => {
-							if (!config.import) return resolve();
-							const resolveContext = {
-								/** @type {LazySet<string>} */
-								fileDependencies: new LazySet(),
-								/** @type {LazySet<string>} */
-								contextDependencies: new LazySet(),
-								/** @type {LazySet<string>} */
-								missingDependencies: new LazySet()
-							};
-							resolver.resolve(
-								{},
-								directFallback ? compiler.context : context,
-								config.import,
-								resolveContext,
-								(err, result) => {
-									compilation.contextDependencies.addAll(
-										resolveContext.contextDependencies
-									);
-									compilation.fileDependencies.addAll(
-										resolveContext.fileDependencies
-									);
-									compilation.missingDependencies.addAll(
-										resolveContext.missingDependencies
-									);
-									if (err) {
-										compilation.errors.push(
-											new ModuleNotFoundError(null, err, {
-												name: `resolving fallback for shared module ${request}`
-											})
-										);
-										return resolve();
-									}
-									resolve(result);
-								}
-							);
-						}),
-						new Promise(resolve => {
-							if (config.requiredVersion !== undefined)
-								return resolve(config.requiredVersion);
-							let packageName = config.packageName;
-							if (packageName === undefined) {
-								if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
-									// For relative or absolute requests we don't automatically use a packageName.
-									// If wished one can specify one with the packageName option.
-									return resolve();
-								}
-								const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
-								if (!match) {
-									requiredVersionWarning(
-										"Unable to extract the package name from request."
-									);
-									return resolve();
-								}
-								packageName = match[0];
-							}
+/**
+ * @param {false|string|Function} name the chunk name
+ * @returns {GetName} a function to get the name of the chunk
+ */
+const normalizeName = name => {
+	if (typeof name === "string") {
+		return () => name;
+	}
+	if (typeof name === "function") {
+		return /** @type {GetName} */ (name);
+	}
+};
 
-							getDescriptionFile(
-								compilation.inputFileSystem,
-								context,
-								["package.json"],
-								(err, result) => {
-									if (err) {
-										requiredVersionWarning(
-											`Unable to read description file: ${err}`
-										);
-										return resolve();
-									}
-									const { data, path: descriptionPath } = result;
-									if (!data) {
-										requiredVersionWarning(
-											`Unable to find description file in ${context}.`
-										);
-										return resolve();
-									}
-									const requiredVersion = getRequiredVersionFromDescriptionFile(
-										data,
-										packageName
-									);
-									if (typeof requiredVersion !== "string") {
-										requiredVersionWarning(
-											`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
-										);
-										return resolve();
-									}
-									resolve(parseRange(requiredVersion));
-								}
-							);
-						})
-					]).then(([importResolved, requiredVersion]) => {
-						return new ConsumeSharedModule(
-							directFallback ? compiler.context : context,
-							{
-								...config,
-								importResolved,
-								import: importResolved ? config.import : undefined,
-								requiredVersion
-							}
-						);
-					});
-				};
+/**
+ * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
+ * @returns {ChunkFilterFunction} the chunk filter function
+ */
+const normalizeChunksFilter = chunks => {
+	if (chunks === "initial") {
+		return INITIAL_CHUNK_FILTER;
+	}
+	if (chunks === "async") {
+		return ASYNC_CHUNK_FILTER;
+	}
+	if (chunks === "all") {
+		return ALL_CHUNK_FILTER;
+	}
+	if (typeof chunks === "function") {
+		return chunks;
+	}
+};
 
-				normalModuleFactory.hooks.factorize.tapPromise(
-					PLUGIN_NAME,
-					({ context, request, dependencies }) =>
-						// wait for resolving to be complete
-						promise.then(() => {
-							if (
-								dependencies[0] instanceof ConsumeSharedFallbackDependency ||
-								dependencies[0] instanceof ProvideForSharedDependency
-							) {
-								return;
-							}
-							const match = unresolvedConsumes.get(request);
-							if (match !== undefined) {
-								return createConsumeSharedModule(context, request, match);
-							}
-							for (const [prefix, options] of prefixedConsumes) {
-								if (request.startsWith(prefix)) {
-									const remainder = request.slice(prefix.length);
-									return createConsumeSharedModule(context, request, {
-										...options,
-										import: options.import
-											? options.import + remainder
-											: undefined,
-										shareKey: options.shareKey + remainder
-									});
-								}
+/**
+ * @param {GetCacheGroups | Record<string, false|string|RegExp|OptimizationSplitChunksGetCacheGroups|OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
+ * @param {string[]} defaultSizeTypes the default size types
+ * @returns {GetCacheGroups} a function to get the cache groups
+ */
+const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
+	if (typeof cacheGroups === "function") {
+		return cacheGroups;
+	}
+	if (typeof cacheGroups === "object" && cacheGroups !== null) {
+		/** @type {(function(Module, CacheGroupsContext, CacheGroupSource[]): void)[]} */
+		const handlers = [];
+		for (const key of Object.keys(cacheGroups)) {
+			const option = cacheGroups[key];
+			if (option === false) {
+				continue;
+			}
+			if (typeof option === "string" || option instanceof RegExp) {
+				const source = createCacheGroupSource({}, key, defaultSizeTypes);
+				handlers.push((module, context, results) => {
+					if (checkTest(option, module, context)) {
+						results.push(source);
+					}
+				});
+			} else if (typeof option === "function") {
+				const cache = new WeakMap();
+				handlers.push((module, context, results) => {
+					const result = option(module);
+					if (result) {
+						const groups = Array.isArray(result) ? result : [result];
+						for (const group of groups) {
+							const cachedSource = cache.get(group);
+							if (cachedSource !== undefined) {
+								results.push(cachedSource);
+							} else {
+								const source = createCacheGroupSource(
+									group,
+									key,
+									defaultSizeTypes
+								);
+								cache.set(group, source);
+								results.push(source);
 							}
-						})
-				);
-				normalModuleFactory.hooks.createModule.tapPromise(
-					PLUGIN_NAME,
-					({ resource }, { context, dependencies }) => {
-						if (
-							dependencies[0] instanceof ConsumeSharedFallbackDependency ||
-							dependencies[0] instanceof ProvideForSharedDependency
-						) {
-							return Promise.resolve();
-						}
-						const options = resolvedConsumes.get(resource);
-						if (options !== undefined) {
-							return createConsumeSharedModule(context, resource, options);
 						}
-						return Promise.resolve();
 					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					PLUGIN_NAME,
-					(chunk, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-						set.add(RuntimeGlobals.shareScopeMap);
-						set.add(RuntimeGlobals.initializeSharing);
-						set.add(RuntimeGlobals.hasOwnProperty);
-						compilation.addRuntimeModule(
-							chunk,
-							new ConsumeSharedRuntimeModule(set)
-						);
+				});
+			} else {
+				const source = createCacheGroupSource(option, key, defaultSizeTypes);
+				handlers.push((module, context, results) => {
+					if (
+						checkTest(option.test, module, context) &&
+						checkModuleType(option.type, module) &&
+						checkModuleLayer(option.layer, module)
+					) {
+						results.push(source);
 					}
-				);
+				});
 			}
-		);
-	}
-}
-
-module.exports = ConsumeSharedPlugin;
-
-
-/***/ }),
-
-/***/ 10394:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const {
-	parseVersionRuntimeCode,
-	versionLtRuntimeCode,
-	rangeToStringRuntimeCode,
-	satisfyRuntimeCode
-} = __webpack_require__(19702);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
-
-class ConsumeSharedRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("consumes", RuntimeModule.STAGE_ATTACH);
-		this._runtimeRequirements = runtimeRequirements;
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, chunkGraph } = this;
-		const { runtimeTemplate, codeGenerationResults } = compilation;
-		const chunkToModuleMapping = {};
-		/** @type {Map<string | number, Source>} */
-		const moduleIdToSourceMapping = new Map();
-		const initialConsumes = [];
+		}
 		/**
-		 *
-		 * @param {Iterable<Module>} modules modules
-		 * @param {Chunk} chunk the chunk
-		 * @param {(string | number)[]} list list of ids
+		 * @param {Module} module the current module
+		 * @param {CacheGroupsContext} context the current context
+		 * @returns {CacheGroupSource[]} the matching cache groups
 		 */
-		const addModules = (modules, chunk, list) => {
-			for (const m of modules) {
-				const module = /** @type {ConsumeSharedModule} */ (m);
-				const id = chunkGraph.getModuleId(module);
-				list.push(id);
-				moduleIdToSourceMapping.set(
-					id,
-					codeGenerationResults.getSource(
-						module,
-						chunk.runtime,
-						"consume-shared"
-					)
-				);
+		const fn = (module, context) => {
+			/** @type {CacheGroupSource[]} */
+			let results = [];
+			for (const fn of handlers) {
+				fn(module, context, results);
 			}
+			return results;
 		};
-		for (const chunk of this.chunk.getAllAsyncChunks()) {
-			const modules = chunkGraph.getChunkModulesIterableBySourceType(
-				chunk,
-				"consume-shared"
-			);
-			if (!modules) continue;
-			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
-		}
-		for (const chunk of this.chunk.getAllInitialChunks()) {
-			const modules = chunkGraph.getChunkModulesIterableBySourceType(
-				chunk,
-				"consume-shared"
-			);
-			if (!modules) continue;
-			addModules(modules, chunk, initialConsumes);
-		}
-		if (moduleIdToSourceMapping.size === 0) return null;
-		return Template.asString([
-			parseVersionRuntimeCode(runtimeTemplate),
-			versionLtRuntimeCode(runtimeTemplate),
-			rangeToStringRuntimeCode(runtimeTemplate),
-			satisfyRuntimeCode(runtimeTemplate),
-			`var ensureExistence = ${runtimeTemplate.basicFunction("scopeName, key", [
-				`var scope = ${RuntimeGlobals.shareScopeMap}[scopeName];`,
-				`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) throw new Error("Shared module " + key + " doesn't exist in shared scope " + scopeName);`,
-				"return scope;"
-			])};`,
-			`var findVersion = ${runtimeTemplate.basicFunction("scope, key", [
-				"var versions = scope[key];",
-				`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-					"a, b",
-					["return !a || versionLt(a, b) ? b : a;"]
-				)}, 0);`,
-				"return key && versions[key]"
-			])};`,
-			`var findSingletonVersionKey = ${runtimeTemplate.basicFunction(
-				"scope, key",
-				[
-					"var versions = scope[key];",
-					`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-						"a, b",
-						["return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;"]
-					)}, 0);`
-				]
-			)};`,
-			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
-				"scope, key, version, requiredVersion",
-				[
-					`return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
-				]
-			)};`,
-			`var getSingleton = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var getSingletonVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));',
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var getStrictSingletonVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						"throw new Error(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));",
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var findValidVersion = ${runtimeTemplate.basicFunction(
-				"scope, key, requiredVersion",
-				[
-					"var versions = scope[key];",
-					`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-						"a, b",
-						[
-							"if (!satisfy(requiredVersion, b)) return a;",
-							"return !a || versionLt(a, b) ? b : a;"
-						]
-					)}, 0);`,
-					"return key && versions[key]"
-				]
-			)};`,
-			`var getInvalidVersionMessage = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var versions = scope[key];",
-					'return "No satisfying version (" + rangeToString(requiredVersion) + ") of shared module " + key + " found in shared scope " + scopeName + ".\\n" +',
-					`\t"Available versions: " + Object.keys(versions).map(${runtimeTemplate.basicFunction(
-						"key",
-						['return key + " from " + versions[key].from;']
-					)}).join(", ");`
-				]
-			)};`,
-			`var getValidVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var entry = findValidVersion(scope, key, requiredVersion);",
-					"if(entry) return get(entry);",
-					"throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
-				]
-			)};`,
-			`var warnInvalidVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					'typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));'
-				]
-			)};`,
-			`var get = ${runtimeTemplate.basicFunction("entry", [
-				"entry.loaded = 1;",
-				"return entry.get()"
-			])};`,
-			`var init = ${runtimeTemplate.returningFunction(
-				Template.asString([
-					"function(scopeName, a, b, c) {",
-					Template.indent([
-						`var promise = ${RuntimeGlobals.initializeSharing}(scopeName);`,
-						`if (promise && promise.then) return promise.then(fn.bind(fn, scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c));`,
-						`return fn(scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c);`
-					]),
-					"}"
-				]),
-				"fn"
-			)};`,
-			"",
-			`var load = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key",
-				[
-					"ensureExistence(scopeName, key);",
-					"return get(findVersion(scope, key));"
-				]
-			)});`,
-			`var loadFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, fallback",
-				[
-					`return scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) ? get(findVersion(scope, key)) : fallback();`
-				]
-			)});`,
-			`var loadVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
-				]
-			)});`,
-			`var loadSingleton = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getSingleton(scope, scopeName, key);"
-				]
-			)});`,
-			`var loadSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getValidVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getStrictSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
-				]
-			)});`,
-			`var loadSingletonFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getSingleton(scope, scopeName, key);"
-				]
-			)});`,
-			`var loadSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`var entry = scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) && findValidVersion(scope, key, version);`,
-					`return entry ? get(entry) : fallback();`
-				]
-			)});`,
-			`var loadStrictSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getStrictSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			"var installedModules = {};",
-			"var moduleToHandlerMapping = {",
-			Template.indent(
-				Array.from(
-					moduleIdToSourceMapping,
-					([key, source]) => `${JSON.stringify(key)}: ${source.source()}`
-				).join(",\n")
-			),
-			"};",
-
-			initialConsumes.length > 0
-				? Template.asString([
-						`var initialConsumes = ${JSON.stringify(initialConsumes)};`,
-						`initialConsumes.forEach(${runtimeTemplate.basicFunction("id", [
-							`${
-								RuntimeGlobals.moduleFactories
-							}[id] = ${runtimeTemplate.basicFunction("module", [
-								"// Handle case when module is used sync",
-								"installedModules[id] = 0;",
-								`delete ${RuntimeGlobals.moduleCache}[id];`,
-								"var factory = moduleToHandlerMapping[id]();",
-								'if(typeof factory !== "function") throw new Error("Shared module is not available for eager consumption: " + id);',
-								`module.exports = factory();`
-							])}`
-						])});`
-				  ])
-				: "// no consumes in initial chunks",
-			this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
-				? Template.asString([
-						`var chunkMapping = ${JSON.stringify(
-							chunkToModuleMapping,
-							null,
-							"\t"
-						)};`,
-						`${
-							RuntimeGlobals.ensureChunkHandlers
-						}.consumes = ${runtimeTemplate.basicFunction("chunkId, promises", [
-							`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
-							Template.indent([
-								`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction(
-									"id",
-									[
-										`if(${RuntimeGlobals.hasOwnProperty}(installedModules, id)) return promises.push(installedModules[id]);`,
-										`var onFactory = ${runtimeTemplate.basicFunction(
-											"factory",
-											[
-												"installedModules[id] = 0;",
-												`${
-													RuntimeGlobals.moduleFactories
-												}[id] = ${runtimeTemplate.basicFunction("module", [
-													`delete ${RuntimeGlobals.moduleCache}[id];`,
-													"module.exports = factory();"
-												])}`
-											]
-										)};`,
-										`var onError = ${runtimeTemplate.basicFunction("error", [
-											"delete installedModules[id];",
-											`${
-												RuntimeGlobals.moduleFactories
-											}[id] = ${runtimeTemplate.basicFunction("module", [
-												`delete ${RuntimeGlobals.moduleCache}[id];`,
-												"throw error;"
-											])}`
-										])};`,
-										"try {",
-										Template.indent([
-											"var promise = moduleToHandlerMapping[id]();",
-											"if(promise.then) {",
-											Template.indent(
-												"promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));"
-											),
-											"} else onFactory(promise);"
-										]),
-										"} catch(e) { onError(e); }"
-									]
-								)});`
-							]),
-							"}"
-						])}`
-				  ])
-				: "// no chunk loading of consumes"
-		]);
+		return fn;
 	}
-}
-
-module.exports = ConsumeSharedRuntimeModule;
-
-
-/***/ }),
-
-/***/ 40017:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+	return () => null;
+};
 
+/**
+ * @param {undefined|boolean|string|RegExp|Function} test test option
+ * @param {Module} module the module
+ * @param {CacheGroupsContext} context context object
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkTest = (test, module, context) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module, context);
+	}
+	if (typeof test === "boolean") return test;
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name && name.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name && test.test(name);
+	}
+	return false;
+};
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
+/**
+ * @param {undefined|string|RegExp|Function} test type option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkModuleType = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module.type);
+	}
+	if (typeof test === "string") {
+		const type = module.type;
+		return test === type;
+	}
+	if (test instanceof RegExp) {
+		const type = module.type;
+		return test.test(type);
+	}
+	return false;
+};
 
-class ProvideForSharedDependency extends ModuleDependency {
-	/**
-	 *
-	 * @param {string} request request string
-	 */
-	constructor(request) {
-		super(request);
+/**
+ * @param {undefined|string|RegExp|Function} test type option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkModuleLayer = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module.layer);
 	}
-
-	get type() {
-		return "provide module for shared";
+	if (typeof test === "string") {
+		const layer = module.layer;
+		return test === "" ? !layer : layer && layer.startsWith(test);
 	}
-
-	get category() {
-		return "esm";
+	if (test instanceof RegExp) {
+		const layer = module.layer;
+		return test.test(layer);
 	}
-}
-
-makeSerializable(
-	ProvideForSharedDependency,
-	"webpack/lib/sharing/ProvideForSharedDependency"
-);
-
-module.exports = ProvideForSharedDependency;
-
-
-/***/ }),
-
-/***/ 1798:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+	return false;
+};
 
+/**
+ * @param {OptimizationSplitChunksCacheGroup} options the group options
+ * @param {string} key key of cache group
+ * @param {string[]} defaultSizeTypes the default size types
+ * @returns {CacheGroupSource} the normalized cached group
+ */
+const createCacheGroupSource = (options, key, defaultSizeTypes) => {
+	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+	const minSizeReduction = normalizeSizes(
+		options.minSizeReduction,
+		defaultSizeTypes
+	);
+	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
+	return {
+		key,
+		priority: options.priority,
+		getName: normalizeName(options.name),
+		chunksFilter: normalizeChunksFilter(options.chunks),
+		enforce: options.enforce,
+		minSize,
+		minSizeReduction,
+		minRemainingSize: mergeSizes(
+			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
+			minSize
+		),
+		enforceSizeThreshold: normalizeSizes(
+			options.enforceSizeThreshold,
+			defaultSizeTypes
+		),
+		maxAsyncSize: mergeSizes(
+			normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
+			maxSize
+		),
+		maxInitialSize: mergeSizes(
+			normalizeSizes(options.maxInitialSize, defaultSizeTypes),
+			maxSize
+		),
+		minChunks: options.minChunks,
+		maxAsyncRequests: options.maxAsyncRequests,
+		maxInitialRequests: options.maxInitialRequests,
+		filename: options.filename,
+		idHint: options.idHint,
+		automaticNameDelimiter: options.automaticNameDelimiter,
+		reuseExistingChunk: options.reuseExistingChunk,
+		usedExports: options.usedExports
+	};
+};
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
+module.exports = class SplitChunksPlugin {
+	/**
+	 * @param {OptimizationSplitChunksOptions=} options plugin options
+	 */
+	constructor(options = {}) {
+		const defaultSizeTypes = options.defaultSizeTypes || [
+			"javascript",
+			"unknown"
+		];
+		const fallbackCacheGroup = options.fallbackCacheGroup || {};
+		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+		const minSizeReduction = normalizeSizes(
+			options.minSizeReduction,
+			defaultSizeTypes
+		);
+		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 
-class ProvideSharedDependency extends Dependency {
-	constructor(shareScope, name, version, request, eager) {
-		super();
-		this.shareScope = shareScope;
-		this.name = name;
-		this.version = version;
-		this.request = request;
-		this.eager = eager;
-	}
+		/** @type {SplitChunksOptions} */
+		this.options = {
+			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
+			defaultSizeTypes,
+			minSize,
+			minSizeReduction,
+			minRemainingSize: mergeSizes(
+				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
+				minSize
+			),
+			enforceSizeThreshold: normalizeSizes(
+				options.enforceSizeThreshold,
+				defaultSizeTypes
+			),
+			maxAsyncSize: mergeSizes(
+				normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
+				maxSize
+			),
+			maxInitialSize: mergeSizes(
+				normalizeSizes(options.maxInitialSize, defaultSizeTypes),
+				maxSize
+			),
+			minChunks: options.minChunks || 1,
+			maxAsyncRequests: options.maxAsyncRequests || 1,
+			maxInitialRequests: options.maxInitialRequests || 1,
+			hidePathInfo: options.hidePathInfo || false,
+			filename: options.filename || undefined,
+			getCacheGroups: normalizeCacheGroups(
+				options.cacheGroups,
+				defaultSizeTypes
+			),
+			getName: options.name ? normalizeName(options.name) : defaultGetName,
+			automaticNameDelimiter: options.automaticNameDelimiter,
+			usedExports: options.usedExports,
+			fallbackCacheGroup: {
+				chunksFilter: normalizeChunksFilter(
+					fallbackCacheGroup.chunks || options.chunks || "all"
+				),
+				minSize: mergeSizes(
+					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
+					minSize
+				),
+				maxAsyncSize: mergeSizes(
+					normalizeSizes(fallbackCacheGroup.maxAsyncSize, defaultSizeTypes),
+					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
+					normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
+					normalizeSizes(options.maxSize, defaultSizeTypes)
+				),
+				maxInitialSize: mergeSizes(
+					normalizeSizes(fallbackCacheGroup.maxInitialSize, defaultSizeTypes),
+					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
+					normalizeSizes(options.maxInitialSize, defaultSizeTypes),
+					normalizeSizes(options.maxSize, defaultSizeTypes)
+				),
+				automaticNameDelimiter:
+					fallbackCacheGroup.automaticNameDelimiter ||
+					options.automaticNameDelimiter ||
+					"~"
+			}
+		};
 
-	get type() {
-		return "provide shared module";
+		/** @type {WeakMap<CacheGroupSource, CacheGroup>} */
+		this._cacheGroupCache = new WeakMap();
 	}
 
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * @param {CacheGroupSource} cacheGroupSource source
+	 * @returns {CacheGroup} the cache group (cached)
 	 */
-	getResourceIdentifier() {
-		return `provide module (${this.shareScope}) ${this.request} as ${
-			this.name
-		} @ ${this.version}${this.eager ? " (eager)" : ""}`;
-	}
-
-	serialize(context) {
-		context.write(this.shareScope);
-		context.write(this.name);
-		context.write(this.request);
-		context.write(this.version);
-		context.write(this.eager);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new ProvideSharedDependency(
-			read(),
-			read(),
-			read(),
-			read(),
-			read()
+	_getCacheGroup(cacheGroupSource) {
+		const cacheEntry = this._cacheGroupCache.get(cacheGroupSource);
+		if (cacheEntry !== undefined) return cacheEntry;
+		const minSize = mergeSizes(
+			cacheGroupSource.minSize,
+			cacheGroupSource.enforce ? undefined : this.options.minSize
 		);
-		this.shareScope = context.read();
-		obj.deserialize(context);
-		return obj;
+		const minSizeReduction = mergeSizes(
+			cacheGroupSource.minSizeReduction,
+			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
+		);
+		const minRemainingSize = mergeSizes(
+			cacheGroupSource.minRemainingSize,
+			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
+		);
+		const enforceSizeThreshold = mergeSizes(
+			cacheGroupSource.enforceSizeThreshold,
+			cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold
+		);
+		const cacheGroup = {
+			key: cacheGroupSource.key,
+			priority: cacheGroupSource.priority || 0,
+			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
+			minSize,
+			minSizeReduction,
+			minRemainingSize,
+			enforceSizeThreshold,
+			maxAsyncSize: mergeSizes(
+				cacheGroupSource.maxAsyncSize,
+				cacheGroupSource.enforce ? undefined : this.options.maxAsyncSize
+			),
+			maxInitialSize: mergeSizes(
+				cacheGroupSource.maxInitialSize,
+				cacheGroupSource.enforce ? undefined : this.options.maxInitialSize
+			),
+			minChunks:
+				cacheGroupSource.minChunks !== undefined
+					? cacheGroupSource.minChunks
+					: cacheGroupSource.enforce
+					? 1
+					: this.options.minChunks,
+			maxAsyncRequests:
+				cacheGroupSource.maxAsyncRequests !== undefined
+					? cacheGroupSource.maxAsyncRequests
+					: cacheGroupSource.enforce
+					? Infinity
+					: this.options.maxAsyncRequests,
+			maxInitialRequests:
+				cacheGroupSource.maxInitialRequests !== undefined
+					? cacheGroupSource.maxInitialRequests
+					: cacheGroupSource.enforce
+					? Infinity
+					: this.options.maxInitialRequests,
+			getName:
+				cacheGroupSource.getName !== undefined
+					? cacheGroupSource.getName
+					: this.options.getName,
+			usedExports:
+				cacheGroupSource.usedExports !== undefined
+					? cacheGroupSource.usedExports
+					: this.options.usedExports,
+			filename:
+				cacheGroupSource.filename !== undefined
+					? cacheGroupSource.filename
+					: this.options.filename,
+			automaticNameDelimiter:
+				cacheGroupSource.automaticNameDelimiter !== undefined
+					? cacheGroupSource.automaticNameDelimiter
+					: this.options.automaticNameDelimiter,
+			idHint:
+				cacheGroupSource.idHint !== undefined
+					? cacheGroupSource.idHint
+					: cacheGroupSource.key,
+			reuseExistingChunk: cacheGroupSource.reuseExistingChunk || false,
+			_validateSize: hasNonZeroSizes(minSize),
+			_validateRemainingSize: hasNonZeroSizes(minRemainingSize),
+			_minSizeForMaxSize: mergeSizes(
+				cacheGroupSource.minSize,
+				this.options.minSize
+			),
+			_conditionalEnforce: hasNonZeroSizes(enforceSizeThreshold)
+		};
+		this._cacheGroupCache.set(cacheGroupSource, cacheGroup);
+		return cacheGroup;
 	}
-}
-
-makeSerializable(
-	ProvideSharedDependency,
-	"webpack/lib/sharing/ProvideSharedDependency"
-);
 
-module.exports = ProvideSharedDependency;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
+		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
+			const logger = compilation.getLogger("webpack.SplitChunksPlugin");
+			let alreadyOptimized = false;
+			compilation.hooks.unseal.tap("SplitChunksPlugin", () => {
+				alreadyOptimized = false;
+			});
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "SplitChunksPlugin",
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					if (alreadyOptimized) return;
+					alreadyOptimized = true;
+					logger.time("prepare");
+					const chunkGraph = compilation.chunkGraph;
+					const moduleGraph = compilation.moduleGraph;
+					// Give each selected chunk an index (to create strings from chunks)
+					/** @type {Map<Chunk, bigint>} */
+					const chunkIndexMap = new Map();
+					const ZERO = BigInt("0");
+					const ONE = BigInt("1");
+					const START = ONE << BigInt("31");
+					let index = START;
+					for (const chunk of chunks) {
+						chunkIndexMap.set(
+							chunk,
+							index | BigInt((Math.random() * 0x7fffffff) | 0)
+						);
+						index = index << ONE;
+					}
+					/**
+					 * @param {Iterable<Chunk>} chunks list of chunks
+					 * @returns {bigint | Chunk} key of the chunks
+					 */
+					const getKey = chunks => {
+						const iterator = chunks[Symbol.iterator]();
+						let result = iterator.next();
+						if (result.done) return ZERO;
+						const first = result.value;
+						result = iterator.next();
+						if (result.done) return first;
+						let key =
+							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
+						while (!(result = iterator.next()).done) {
+							const raw = chunkIndexMap.get(result.value);
+							key = key ^ raw;
+						}
+						return key;
+					};
+					const keyToString = key => {
+						if (typeof key === "bigint") return key.toString(16);
+						return chunkIndexMap.get(key).toString(16);
+					};
 
+					const getChunkSetsInGraph = memoize(() => {
+						/** @type {Map<bigint, Set<Chunk>>} */
+						const chunkSetsInGraph = new Map();
+						/** @type {Set<Chunk>} */
+						const singleChunkSets = new Set();
+						for (const module of compilation.modules) {
+							const chunks = chunkGraph.getModuleChunksIterable(module);
+							const chunksKey = getKey(chunks);
+							if (typeof chunksKey === "bigint") {
+								if (!chunkSetsInGraph.has(chunksKey)) {
+									chunkSetsInGraph.set(chunksKey, new Set(chunks));
+								}
+							} else {
+								singleChunkSets.add(chunksKey);
+							}
+						}
+						return { chunkSetsInGraph, singleChunkSets };
+					});
 
-/***/ }),
+					/**
+					 * @param {Module} module the module
+					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
+					 */
+					const groupChunksByExports = module => {
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						const groupedByUsedExports = new Map();
+						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+							const key = exportsInfo.getUsageKey(chunk.runtime);
+							const list = groupedByUsedExports.get(key);
+							if (list !== undefined) {
+								list.push(chunk);
+							} else {
+								groupedByUsedExports.set(key, [chunk]);
+							}
+						}
+						return groupedByUsedExports.values();
+					};
 
-/***/ 50821:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					/** @type {Map<Module, Iterable<Chunk[]>>} */
+					const groupedByExportsMap = new Map();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
-*/
+					const getExportsChunkSetsInGraph = memoize(() => {
+						/** @type {Map<bigint, Set<Chunk>>} */
+						const chunkSetsInGraph = new Map();
+						/** @type {Set<Chunk>} */
+						const singleChunkSets = new Set();
+						for (const module of compilation.modules) {
+							const groupedChunks = Array.from(groupChunksByExports(module));
+							groupedByExportsMap.set(module, groupedChunks);
+							for (const chunks of groupedChunks) {
+								if (chunks.length === 1) {
+									singleChunkSets.add(chunks[0]);
+								} else {
+									const chunksKey = /** @type {bigint} */ (getKey(chunks));
+									if (!chunkSetsInGraph.has(chunksKey)) {
+										chunkSetsInGraph.set(chunksKey, new Set(chunks));
+									}
+								}
+							}
+						}
+						return { chunkSetsInGraph, singleChunkSets };
+					});
 
+					// group these set of chunks by count
+					// to allow to check less sets via isSubset
+					// (only smaller sets can be subset)
+					const groupChunkSetsByCount = chunkSets => {
+						/** @type {Map<number, Array<Set<Chunk>>>} */
+						const chunkSetsByCount = new Map();
+						for (const chunksSet of chunkSets) {
+							const count = chunksSet.size;
+							let array = chunkSetsByCount.get(count);
+							if (array === undefined) {
+								array = [];
+								chunkSetsByCount.set(count, array);
+							}
+							array.push(chunksSet);
+						}
+						return chunkSetsByCount;
+					};
+					const getChunkSetsByCount = memoize(() =>
+						groupChunkSetsByCount(
+							getChunkSetsInGraph().chunkSetsInGraph.values()
+						)
+					);
+					const getExportsChunkSetsByCount = memoize(() =>
+						groupChunkSetsByCount(
+							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
+						)
+					);
 
+					// Create a list of possible combinations
+					const createGetCombinations = (
+						chunkSets,
+						singleChunkSets,
+						chunkSetsByCount
+					) => {
+						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
+						const combinationsCache = new Map();
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const ProvideForSharedDependency = __webpack_require__(40017);
+						return key => {
+							const cacheEntry = combinationsCache.get(key);
+							if (cacheEntry !== undefined) return cacheEntry;
+							if (key instanceof Chunk) {
+								const result = [key];
+								combinationsCache.set(key, result);
+								return result;
+							}
+							const chunksSet = chunkSets.get(key);
+							/** @type {(Set<Chunk> | Chunk)[]} */
+							const array = [chunksSet];
+							for (const [count, setArray] of chunkSetsByCount) {
+								// "equal" is not needed because they would have been merge in the first step
+								if (count < chunksSet.size) {
+									for (const set of setArray) {
+										if (isSubset(chunksSet, set)) {
+											array.push(set);
+										}
+									}
+								}
+							}
+							for (const chunk of singleChunkSets) {
+								if (chunksSet.has(chunk)) {
+									array.push(chunk);
+								}
+							}
+							combinationsCache.set(key, array);
+							return array;
+						};
+					};
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+					const getCombinationsFactory = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
+						return createGetCombinations(
+							chunkSetsInGraph,
+							singleChunkSets,
+							getChunkSetsByCount()
+						);
+					});
+					const getCombinations = key => getCombinationsFactory()(key);
 
-const TYPES = new Set(["share-init"]);
+					const getExportsCombinationsFactory = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets } =
+							getExportsChunkSetsInGraph();
+						return createGetCombinations(
+							chunkSetsInGraph,
+							singleChunkSets,
+							getExportsChunkSetsByCount()
+						);
+					});
+					const getExportsCombinations = key =>
+						getExportsCombinationsFactory()(key);
 
-class ProvideSharedModule extends Module {
-	/**
-	 * @param {string} shareScope shared scope name
-	 * @param {string} name shared key
-	 * @param {string | false} version version
-	 * @param {string} request request to the provided module
-	 * @param {boolean} eager include the module in sync way
-	 */
-	constructor(shareScope, name, version, request, eager) {
-		super("provide-module");
-		this._shareScope = shareScope;
-		this._name = name;
-		this._version = version;
-		this._request = request;
-		this._eager = eager;
-	}
+					/**
+					 * @typedef {Object} SelectedChunksResult
+					 * @property {Chunk[]} chunks the list of chunks
+					 * @property {bigint | Chunk} key a key of the list
+					 */
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `provide module (${this._shareScope}) ${this._name}@${this._version} = ${this._request}`;
-	}
+					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
+					const selectedChunksCacheByChunksSet = new WeakMap();
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `provide shared module (${this._shareScope}) ${this._name}@${
-			this._version
-		} = ${requestShortener.shorten(this._request)}`;
-	}
+					/**
+					 * get list and key by applying the filter function to the list
+					 * It is cached for performance reasons
+					 * @param {Set<Chunk> | Chunk} chunks list of chunks
+					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
+					 * @returns {SelectedChunksResult} list and key
+					 */
+					const getSelectedChunks = (chunks, chunkFilter) => {
+						let entry = selectedChunksCacheByChunksSet.get(chunks);
+						if (entry === undefined) {
+							entry = new WeakMap();
+							selectedChunksCacheByChunksSet.set(chunks, entry);
+						}
+						/** @type {SelectedChunksResult} */
+						let entry2 = entry.get(chunkFilter);
+						if (entry2 === undefined) {
+							/** @type {Chunk[]} */
+							const selectedChunks = [];
+							if (chunks instanceof Chunk) {
+								if (chunkFilter(chunks)) selectedChunks.push(chunks);
+							} else {
+								for (const chunk of chunks) {
+									if (chunkFilter(chunk)) selectedChunks.push(chunk);
+								}
+							}
+							entry2 = {
+								chunks: selectedChunks,
+								key: getKey(selectedChunks)
+							};
+							entry.set(chunkFilter, entry2);
+						}
+						return entry2;
+					};
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
-			this._shareScope
-		}/${this._name}`;
-	}
+					/** @type {Map<string, boolean>} */
+					const alreadyValidatedParents = new Map();
+					/** @type {Set<string>} */
+					const alreadyReportedErrors = new Set();
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
-	}
+					// Map a list of chunks to a list of modules
+					// For the key the chunk "index" is used, the value is a SortableSet of modules
+					/** @type {Map<string, ChunksInfoItem>} */
+					const chunksInfoMap = new Map();
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true
-		};
+					/**
+					 * @param {CacheGroup} cacheGroup the current cache group
+					 * @param {number} cacheGroupIndex the index of the cache group of ordering
+					 * @param {Chunk[]} selectedChunks chunks selected for this module
+					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
+					 * @param {Module} module the current module
+					 * @returns {void}
+					 */
+					const addModuleToChunksInfoMap = (
+						cacheGroup,
+						cacheGroupIndex,
+						selectedChunks,
+						selectedChunksKey,
+						module
+					) => {
+						// Break if minimum number of chunks is not reached
+						if (selectedChunks.length < cacheGroup.minChunks) return;
+						// Determine name for split chunk
+						const name = cacheGroup.getName(
+							module,
+							selectedChunks,
+							cacheGroup.key
+						);
+						// Check if the name is ok
+						const existingChunk = compilation.namedChunks.get(name);
+						if (existingChunk) {
+							const parentValidationKey = `${name}|${
+								typeof selectedChunksKey === "bigint"
+									? selectedChunksKey
+									: selectedChunksKey.debugId
+							}`;
+							const valid = alreadyValidatedParents.get(parentValidationKey);
+							if (valid === false) return;
+							if (valid === undefined) {
+								// Module can only be moved into the existing chunk if the existing chunk
+								// is a parent of all selected chunks
+								let isInAllParents = true;
+								/** @type {Set<ChunkGroup>} */
+								const queue = new Set();
+								for (const chunk of selectedChunks) {
+									for (const group of chunk.groupsIterable) {
+										queue.add(group);
+									}
+								}
+								for (const group of queue) {
+									if (existingChunk.isInGroup(group)) continue;
+									let hasParent = false;
+									for (const parent of group.parentsIterable) {
+										hasParent = true;
+										queue.add(parent);
+									}
+									if (!hasParent) {
+										isInAllParents = false;
+									}
+								}
+								const valid = isInAllParents;
+								alreadyValidatedParents.set(parentValidationKey, valid);
+								if (!valid) {
+									if (!alreadyReportedErrors.has(name)) {
+										alreadyReportedErrors.add(name);
+										compilation.errors.push(
+											new WebpackError(
+												"SplitChunksPlugin\n" +
+													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
+													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
+													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +
+													'HINT: You can omit "name" to automatically create a name.\n' +
+													"BREAKING CHANGE: webpack < 5 used to allow to use an entrypoint as splitChunk. " +
+													"This is no longer allowed when the entrypoint is not a parent of the selected modules.\n" +
+													"Remove this entrypoint and add modules to cache group's 'test' instead. " +
+													"If you need modules to be evaluated on startup, add them to the existing entrypoints (make them arrays). " +
+													"See migration guide of more info."
+											)
+										);
+									}
+									return;
+								}
+							}
+						}
+						// Create key for maps
+						// When it has a name we use the name as key
+						// Otherwise we create the key from chunks and cache group key
+						// This automatically merges equal names
+						const key =
+							cacheGroup.key +
+							(name
+								? ` name:${name}`
+								: ` chunks:${keyToString(selectedChunksKey)}`);
+						// Add module to maps
+						let info = chunksInfoMap.get(key);
+						if (info === undefined) {
+							chunksInfoMap.set(
+								key,
+								(info = {
+									modules: new SortableSet(
+										undefined,
+										compareModulesByIdentifier
+									),
+									cacheGroup,
+									cacheGroupIndex,
+									name,
+									sizes: {},
+									chunks: new Set(),
+									reuseableChunks: new Set(),
+									chunksKeys: new Set()
+								})
+							);
+						}
+						const oldSize = info.modules.size;
+						info.modules.add(module);
+						if (info.modules.size !== oldSize) {
+							for (const type of module.getSourceTypes()) {
+								info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
+							}
+						}
+						const oldChunksKeysSize = info.chunksKeys.size;
+						info.chunksKeys.add(selectedChunksKey);
+						if (oldChunksKeysSize !== info.chunksKeys.size) {
+							for (const chunk of selectedChunks) {
+								info.chunks.add(chunk);
+							}
+						}
+					};
 
-		this.clearDependenciesAndBlocks();
-		const dep = new ProvideForSharedDependency(this._request);
-		if (this._eager) {
-			this.addDependency(dep);
-		} else {
-			const block = new AsyncDependenciesBlock({});
-			block.addDependency(dep);
-			this.addBlock(block);
-		}
+					const context = {
+						moduleGraph,
+						chunkGraph
+					};
 
-		callback();
-	}
+					logger.timeEnd("prepare");
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 42;
-	}
+					logger.time("modules");
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+					// Walk through all modules
+					for (const module of compilation.modules) {
+						// Get cache group
+						let cacheGroups = this.options.getCacheGroups(module, context);
+						if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
+							continue;
+						}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const runtimeRequirements = new Set([RuntimeGlobals.initializeSharing]);
-		const code = `register(${JSON.stringify(this._name)}, ${JSON.stringify(
-			this._version || "0"
-		)}, ${
-			this._eager
-				? runtimeTemplate.syncModuleFactory({
-						dependency: this.dependencies[0],
-						chunkGraph,
-						request: this._request,
-						runtimeRequirements
-				  })
-				: runtimeTemplate.asyncModuleFactory({
-						block: this.blocks[0],
-						chunkGraph,
-						request: this._request,
-						runtimeRequirements
-				  })
-		}${this._eager ? ", 1" : ""});`;
-		const sources = new Map();
-		const data = new Map();
-		data.set("share-init", [
-			{
-				shareScope: this._shareScope,
-				initStage: 10,
-				init: code
-			}
-		]);
-		return { sources, data, runtimeRequirements };
-	}
+						// Prepare some values (usedExports = false)
+						const getCombs = memoize(() => {
+							const chunks = chunkGraph.getModuleChunksIterable(module);
+							const chunksKey = getKey(chunks);
+							return getCombinations(chunksKey);
+						});
 
-	serialize(context) {
-		const { write } = context;
-		write(this._shareScope);
-		write(this._name);
-		write(this._version);
-		write(this._request);
-		write(this._eager);
-		super.serialize(context);
-	}
+						// Prepare some values (usedExports = true)
+						const getCombsByUsedExports = memoize(() => {
+							// fill the groupedByExportsMap
+							getExportsChunkSetsInGraph();
+							/** @type {Set<Set<Chunk> | Chunk>} */
+							const set = new Set();
+							const groupedByUsedExports = groupedByExportsMap.get(module);
+							for (const chunks of groupedByUsedExports) {
+								const chunksKey = getKey(chunks);
+								for (const comb of getExportsCombinations(chunksKey))
+									set.add(comb);
+							}
+							return set;
+						});
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new ProvideSharedModule(read(), read(), read(), read(), read());
-		obj.deserialize(context);
-		return obj;
-	}
-}
+						let cacheGroupIndex = 0;
+						for (const cacheGroupSource of cacheGroups) {
+							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-makeSerializable(
-	ProvideSharedModule,
-	"webpack/lib/sharing/ProvideSharedModule"
-);
+							const combs = cacheGroup.usedExports
+								? getCombsByUsedExports()
+								: getCombs();
+							// For all combination of chunk selection
+							for (const chunkCombination of combs) {
+								// Break if minimum number of chunks is not reached
+								const count =
+									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
+								if (count < cacheGroup.minChunks) continue;
+								// Select chunks by configuration
+								const { chunks: selectedChunks, key: selectedChunksKey } =
+									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
 
-module.exports = ProvideSharedModule;
+								addModuleToChunksInfoMap(
+									cacheGroup,
+									cacheGroupIndex,
+									selectedChunks,
+									selectedChunksKey,
+									module
+								);
+							}
+							cacheGroupIndex++;
+						}
+					}
 
+					logger.timeEnd("modules");
 
-/***/ }),
+					logger.time("queue");
 
-/***/ 39344:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					/**
+					 * @param {ChunksInfoItem} info entry
+					 * @param {string[]} sourceTypes source types to be removed
+					 */
+					const removeModulesWithSourceType = (info, sourceTypes) => {
+						for (const module of info.modules) {
+							const types = module.getSourceTypes();
+							if (sourceTypes.some(type => types.has(type))) {
+								info.modules.delete(module);
+								for (const type of types) {
+									info.sizes[type] -= module.size(type);
+								}
+							}
+						}
+					};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
-*/
+					/**
+					 * @param {ChunksInfoItem} info entry
+					 * @returns {boolean} true, if entry become empty
+					 */
+					const removeMinSizeViolatingModules = info => {
+						if (!info.cacheGroup._validateSize) return false;
+						const violatingSizes = getViolatingMinSizes(
+							info.sizes,
+							info.cacheGroup.minSize
+						);
+						if (violatingSizes === undefined) return false;
+						removeModulesWithSourceType(info, violatingSizes);
+						return info.modules.size === 0;
+					};
 
+					// Filter items were size < minSize
+					for (const [key, info] of chunksInfoMap) {
+						if (removeMinSizeViolatingModules(info)) {
+							chunksInfoMap.delete(key);
+						} else if (
+							!checkMinSizeReduction(
+								info.sizes,
+								info.cacheGroup.minSizeReduction,
+								info.chunks.size
+							)
+						) {
+							chunksInfoMap.delete(key);
+						}
+					}
 
+					/**
+					 * @typedef {Object} MaxSizeQueueItem
+					 * @property {SplitChunksSizes} minSize
+					 * @property {SplitChunksSizes} maxAsyncSize
+					 * @property {SplitChunksSizes} maxInitialSize
+					 * @property {string} automaticNameDelimiter
+					 * @property {string[]} keys
+					 */
 
-const ModuleFactory = __webpack_require__(51010);
-const ProvideSharedModule = __webpack_require__(50821);
+					/** @type {Map<Chunk, MaxSizeQueueItem>} */
+					const maxSizeQueueMap = new Map();
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
+					while (chunksInfoMap.size > 0) {
+						// Find best matching entry
+						let bestEntryKey;
+						let bestEntry;
+						for (const pair of chunksInfoMap) {
+							const key = pair[0];
+							const info = pair[1];
+							if (
+								bestEntry === undefined ||
+								compareEntries(bestEntry, info) < 0
+							) {
+								bestEntry = info;
+								bestEntryKey = key;
+							}
+						}
 
-class ProvideSharedModuleFactory extends ModuleFactory {
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		const dep = /** @type {ProvideSharedDependency} */ (data.dependencies[0]);
-		callback(null, {
-			module: new ProvideSharedModule(
-				dep.shareScope,
-				dep.name,
-				dep.version,
-				dep.request,
-				dep.eager
-			)
-		});
-	}
-}
+						const item = bestEntry;
+						chunksInfoMap.delete(bestEntryKey);
 
-module.exports = ProvideSharedModuleFactory;
+						let chunkName = item.name;
+						// Variable for the new chunk (lazy created)
+						/** @type {Chunk} */
+						let newChunk;
+						// When no chunk name, check if we can reuse a chunk instead of creating a new one
+						let isExistingChunk = false;
+						let isReusedWithAllModules = false;
+						if (chunkName) {
+							const chunkByName = compilation.namedChunks.get(chunkName);
+							if (chunkByName !== undefined) {
+								newChunk = chunkByName;
+								const oldSize = item.chunks.size;
+								item.chunks.delete(newChunk);
+								isExistingChunk = item.chunks.size !== oldSize;
+							}
+						} else if (item.cacheGroup.reuseExistingChunk) {
+							outer: for (const chunk of item.chunks) {
+								if (
+									chunkGraph.getNumberOfChunkModules(chunk) !==
+									item.modules.size
+								) {
+									continue;
+								}
+								if (
+									item.chunks.size > 1 &&
+									chunkGraph.getNumberOfEntryModules(chunk) > 0
+								) {
+									continue;
+								}
+								for (const module of item.modules) {
+									if (!chunkGraph.isModuleInChunk(module, chunk)) {
+										continue outer;
+									}
+								}
+								if (!newChunk || !newChunk.name) {
+									newChunk = chunk;
+								} else if (
+									chunk.name &&
+									chunk.name.length < newChunk.name.length
+								) {
+									newChunk = chunk;
+								} else if (
+									chunk.name &&
+									chunk.name.length === newChunk.name.length &&
+									chunk.name < newChunk.name
+								) {
+									newChunk = chunk;
+								}
+							}
+							if (newChunk) {
+								item.chunks.delete(newChunk);
+								chunkName = undefined;
+								isExistingChunk = true;
+								isReusedWithAllModules = true;
+							}
+						}
 
+						const enforced =
+							item.cacheGroup._conditionalEnforce &&
+							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
 
-/***/ }),
+						const usedChunks = new Set(item.chunks);
 
-/***/ 31225:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+						// Check if maxRequests condition can be fulfilled
+						if (
+							!enforced &&
+							(Number.isFinite(item.cacheGroup.maxInitialRequests) ||
+								Number.isFinite(item.cacheGroup.maxAsyncRequests))
+						) {
+							for (const chunk of usedChunks) {
+								// respect max requests
+								const maxRequests = chunk.isOnlyInitial()
+									? item.cacheGroup.maxInitialRequests
+									: chunk.canBeInitial()
+									? Math.min(
+											item.cacheGroup.maxInitialRequests,
+											item.cacheGroup.maxAsyncRequests
+									  )
+									: item.cacheGroup.maxAsyncRequests;
+								if (
+									isFinite(maxRequests) &&
+									getRequests(chunk) >= maxRequests
+								) {
+									usedChunks.delete(chunk);
+								}
+							}
+						}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
-*/
+						outer: for (const chunk of usedChunks) {
+							for (const module of item.modules) {
+								if (chunkGraph.isModuleInChunk(module, chunk)) continue outer;
+							}
+							usedChunks.delete(chunk);
+						}
 
+						// Were some (invalid) chunks removed from usedChunks?
+						// => readd all modules to the queue, as things could have been changed
+						if (usedChunks.size < item.chunks.size) {
+							if (isExistingChunk) usedChunks.add(newChunk);
+							if (usedChunks.size >= item.cacheGroup.minChunks) {
+								const chunksArr = Array.from(usedChunks);
+								for (const module of item.modules) {
+									addModuleToChunksInfoMap(
+										item.cacheGroup,
+										item.cacheGroupIndex,
+										chunksArr,
+										getKey(usedChunks),
+										module
+									);
+								}
+							}
+							continue;
+						}
 
+						// Validate minRemainingSize constraint when a single chunk is left over
+						if (
+							!enforced &&
+							item.cacheGroup._validateRemainingSize &&
+							usedChunks.size === 1
+						) {
+							const [chunk] = usedChunks;
+							let chunkSizes = Object.create(null);
+							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+								if (!item.modules.has(module)) {
+									for (const type of module.getSourceTypes()) {
+										chunkSizes[type] =
+											(chunkSizes[type] || 0) + module.size(type);
+									}
+								}
+							}
+							const violatingSizes = getViolatingMinSizes(
+								chunkSizes,
+								item.cacheGroup.minRemainingSize
+							);
+							if (violatingSizes !== undefined) {
+								const oldModulesSize = item.modules.size;
+								removeModulesWithSourceType(item, violatingSizes);
+								if (
+									item.modules.size > 0 &&
+									item.modules.size !== oldModulesSize
+								) {
+									// queue this item again to be processed again
+									// without violating modules
+									chunksInfoMap.set(bestEntryKey, item);
+								}
+								continue;
+							}
+						}
 
-const WebpackError = __webpack_require__(53799);
-const { parseOptions } = __webpack_require__(3083);
-const createSchemaValidation = __webpack_require__(32540);
-const ProvideForSharedDependency = __webpack_require__(40017);
-const ProvideSharedDependency = __webpack_require__(1798);
-const ProvideSharedModuleFactory = __webpack_require__(39344);
+						// Create the new chunk if not reusing one
+						if (newChunk === undefined) {
+							newChunk = compilation.addChunk(chunkName);
+						}
+						// Walk through all chunks
+						for (const chunk of usedChunks) {
+							// Add graph connections for splitted chunk
+							chunk.split(newChunk);
+						}
 
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
+						// Add a note to the chunk
+						newChunk.chunkReason =
+							(newChunk.chunkReason ? newChunk.chunkReason + ", " : "") +
+							(isReusedWithAllModules
+								? "reused as split chunk"
+								: "split chunk");
+						if (item.cacheGroup.key) {
+							newChunk.chunkReason += ` (cache group: ${item.cacheGroup.key})`;
+						}
+						if (chunkName) {
+							newChunk.chunkReason += ` (name: ${chunkName})`;
+						}
+						if (item.cacheGroup.filename) {
+							newChunk.filenameTemplate = item.cacheGroup.filename;
+						}
+						if (item.cacheGroup.idHint) {
+							newChunk.idNameHints.add(item.cacheGroup.idHint);
+						}
+						if (!isReusedWithAllModules) {
+							// Add all modules to the new chunk
+							for (const module of item.modules) {
+								if (!module.chunkCondition(newChunk, compilation)) continue;
+								// Add module to new chunk
+								chunkGraph.connectChunkAndModule(newChunk, module);
+								// Remove module from used chunks
+								for (const chunk of usedChunks) {
+									chunkGraph.disconnectChunkAndModule(chunk, module);
+								}
+							}
+						} else {
+							// Remove all modules from used chunks
+							for (const module of item.modules) {
+								for (const chunk of usedChunks) {
+									chunkGraph.disconnectChunkAndModule(chunk, module);
+								}
+							}
+						}
 
-const validate = createSchemaValidation(
-	__webpack_require__(91924),
-	() => __webpack_require__(438),
-	{
-		name: "Provide Shared Plugin",
-		baseDataPath: "options"
-	}
-);
+						if (
+							Object.keys(item.cacheGroup.maxAsyncSize).length > 0 ||
+							Object.keys(item.cacheGroup.maxInitialSize).length > 0
+						) {
+							const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
+							maxSizeQueueMap.set(newChunk, {
+								minSize: oldMaxSizeSettings
+									? combineSizes(
+											oldMaxSizeSettings.minSize,
+											item.cacheGroup._minSizeForMaxSize,
+											Math.max
+									  )
+									: item.cacheGroup.minSize,
+								maxAsyncSize: oldMaxSizeSettings
+									? combineSizes(
+											oldMaxSizeSettings.maxAsyncSize,
+											item.cacheGroup.maxAsyncSize,
+											Math.min
+									  )
+									: item.cacheGroup.maxAsyncSize,
+								maxInitialSize: oldMaxSizeSettings
+									? combineSizes(
+											oldMaxSizeSettings.maxInitialSize,
+											item.cacheGroup.maxInitialSize,
+											Math.min
+									  )
+									: item.cacheGroup.maxInitialSize,
+								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
+								keys: oldMaxSizeSettings
+									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+									: [item.cacheGroup.key]
+							});
+						}
 
-/**
- * @typedef {Object} ProvideOptions
- * @property {string} shareKey
- * @property {string} shareScope
- * @property {string | undefined | false} version
- * @property {boolean} eager
- */
+						// remove all modules from other entries and update size
+						for (const [key, info] of chunksInfoMap) {
+							if (isOverlap(info.chunks, usedChunks)) {
+								// update modules and total size
+								// may remove it from the map when < minSize
+								let updated = false;
+								for (const module of item.modules) {
+									if (info.modules.has(module)) {
+										// remove module
+										info.modules.delete(module);
+										// update size
+										for (const key of module.getSourceTypes()) {
+											info.sizes[key] -= module.size(key);
+										}
+										updated = true;
+									}
+								}
+								if (updated) {
+									if (info.modules.size === 0) {
+										chunksInfoMap.delete(key);
+										continue;
+									}
+									if (
+										removeMinSizeViolatingModules(info) ||
+										!checkMinSizeReduction(
+											info.sizes,
+											info.cacheGroup.minSizeReduction,
+											info.chunks.size
+										)
+									) {
+										chunksInfoMap.delete(key);
+										continue;
+									}
+								}
+							}
+						}
+					}
 
-/** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
+					logger.timeEnd("queue");
 
-class ProvideSharedPlugin {
-	/**
-	 * @param {ProvideSharedPluginOptions} options options
-	 */
-	constructor(options) {
-		validate(options);
+					logger.time("maxSize");
 
-		/** @type {[string, ProvideOptions][]} */
-		this._provides = parseOptions(
-			options.provides,
-			item => {
-				if (Array.isArray(item))
-					throw new Error("Unexpected array of provides");
-				/** @type {ProvideOptions} */
-				const result = {
-					shareKey: item,
-					version: undefined,
-					shareScope: options.shareScope || "default",
-					eager: false
-				};
-				return result;
-			},
-			item => ({
-				shareKey: item.shareKey,
-				version: item.version,
-				shareScope: item.shareScope || options.shareScope || "default",
-				eager: !!item.eager
-			})
-		);
-		this._provides.sort(([a], [b]) => {
-			if (a < b) return -1;
-			if (b < a) return 1;
-			return 0;
-		});
-	}
+					/** @type {Set<string>} */
+					const incorrectMinMaxSizeSet = new Set();
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		/** @type {WeakMap<Compilation, ResolvedProvideMap>} */
-		const compilationData = new WeakMap();
+					const { outputOptions } = compilation;
 
-		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				/** @type {ResolvedProvideMap} */
-				const resolvedProvideMap = new Map();
-				/** @type {Map<string, ProvideOptions>} */
-				const matchProvides = new Map();
-				/** @type {Map<string, ProvideOptions>} */
-				const prefixMatchProvides = new Map();
-				for (const [request, config] of this._provides) {
-					if (/^(\/|[A-Za-z]:\\|\\\\|\.\.?(\/|$))/.test(request)) {
-						// relative request
-						resolvedProvideMap.set(request, {
-							config,
-							version: config.version
-						});
-					} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
-						// absolute path
-						resolvedProvideMap.set(request, {
-							config,
-							version: config.version
-						});
-					} else if (request.endsWith("/")) {
-						// module request prefix
-						prefixMatchProvides.set(request, config);
-					} else {
-						// module request
-						matchProvides.set(request, config);
-					}
-				}
-				compilationData.set(compilation, resolvedProvideMap);
-				const provideSharedModule = (
-					key,
-					config,
-					resource,
-					resourceResolveData
-				) => {
-					let version = config.version;
-					if (version === undefined) {
-						let details = "";
-						if (!resourceResolveData) {
-							details = `No resolve data provided from resolver.`;
+					// Make sure that maxSize is fulfilled
+					const { fallbackCacheGroup } = this.options;
+					for (const chunk of Array.from(compilation.chunks)) {
+						const chunkConfig = maxSizeQueueMap.get(chunk);
+						const {
+							minSize,
+							maxAsyncSize,
+							maxInitialSize,
+							automaticNameDelimiter
+						} = chunkConfig || fallbackCacheGroup;
+						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+							continue;
+						/** @type {SplitChunksSizes} */
+						let maxSize;
+						if (chunk.isOnlyInitial()) {
+							maxSize = maxInitialSize;
+						} else if (chunk.canBeInitial()) {
+							maxSize = combineSizes(maxAsyncSize, maxInitialSize, Math.min);
 						} else {
-							const descriptionFileData =
-								resourceResolveData.descriptionFileData;
-							if (!descriptionFileData) {
-								details =
-									"No description file (usually package.json) found. Add description file with name and version, or manually specify version in shared config.";
-							} else if (!descriptionFileData.version) {
-								details =
-									"No version in description file (usually package.json). Add version to description file, or manually specify version in shared config.";
-							} else {
-								version = descriptionFileData.version;
-							}
+							maxSize = maxAsyncSize;
 						}
-						if (!version) {
-							const error = new WebpackError(
-								`No version specified and unable to automatically determine one. ${details}`
-							);
-							error.file = `shared module ${key} -> ${resource}`;
-							compilation.warnings.push(error);
+						if (Object.keys(maxSize).length === 0) {
+							continue;
 						}
-					}
-					resolvedProvideMap.set(resource, {
-						config,
-						version
-					});
-				};
-				normalModuleFactory.hooks.module.tap(
-					"ProvideSharedPlugin",
-					(module, { resource, resourceResolveData }, resolveData) => {
-						if (resolvedProvideMap.has(resource)) {
-							return module;
+						for (const key of Object.keys(maxSize)) {
+							const maxSizeValue = maxSize[key];
+							const minSizeValue = minSize[key];
+							if (
+								typeof minSizeValue === "number" &&
+								minSizeValue > maxSizeValue
+							) {
+								const keys = chunkConfig && chunkConfig.keys;
+								const warningKey = `${
+									keys && keys.join()
+								} ${minSizeValue} ${maxSizeValue}`;
+								if (!incorrectMinMaxSizeSet.has(warningKey)) {
+									incorrectMinMaxSizeSet.add(warningKey);
+									compilation.warnings.push(
+										new MinMaxSizeWarning(keys, minSizeValue, maxSizeValue)
+									);
+								}
+							}
 						}
-						const { request } = resolveData;
-						{
-							const config = matchProvides.get(request);
-							if (config !== undefined) {
-								provideSharedModule(
-									request,
-									config,
-									resource,
-									resourceResolveData
-								);
-								resolveData.cacheable = false;
+						const results = deterministicGroupingForModules({
+							minSize,
+							maxSize: mapObject(maxSize, (value, key) => {
+								const minSizeValue = minSize[key];
+								return typeof minSizeValue === "number"
+									? Math.max(value, minSizeValue)
+									: value;
+							}),
+							items: chunkGraph.getChunkModulesIterable(chunk),
+							getKey(module) {
+								const cache = getKeyCache.get(module);
+								if (cache !== undefined) return cache;
+								const ident = cachedMakePathsRelative(module.identifier());
+								const nameForCondition =
+									module.nameForCondition && module.nameForCondition();
+								const name = nameForCondition
+									? cachedMakePathsRelative(nameForCondition)
+									: ident.replace(/^.*!|\?[^?!]*$/g, "");
+								const fullKey =
+									name +
+									automaticNameDelimiter +
+									hashFilename(ident, outputOptions);
+								const key = requestToId(fullKey);
+								getKeyCache.set(module, key);
+								return key;
+							},
+							getSize(module) {
+								const size = Object.create(null);
+								for (const key of module.getSourceTypes()) {
+									size[key] = module.size(key);
+								}
+								return size;
 							}
+						});
+						if (results.length <= 1) {
+							continue;
 						}
-						for (const [prefix, config] of prefixMatchProvides) {
-							if (request.startsWith(prefix)) {
-								const remainder = request.slice(prefix.length);
-								provideSharedModule(
-									resource,
-									{
-										...config,
-										shareKey: config.shareKey + remainder
-									},
-									resource,
-									resourceResolveData
-								);
-								resolveData.cacheable = false;
+						for (let i = 0; i < results.length; i++) {
+							const group = results[i];
+							const key = this.options.hidePathInfo
+								? hashFilename(group.key, outputOptions)
+								: group.key;
+							let name = chunk.name
+								? chunk.name + automaticNameDelimiter + key
+								: null;
+							if (name && name.length > 100) {
+								name =
+									name.slice(0, 100) +
+									automaticNameDelimiter +
+									hashFilename(name, outputOptions);
+							}
+							if (i !== results.length - 1) {
+								const newPart = compilation.addChunk(name);
+								chunk.split(newPart);
+								newPart.chunkReason = chunk.chunkReason;
+								// Add all modules to the new chunk
+								for (const module of group.items) {
+									if (!module.chunkCondition(newPart, compilation)) {
+										continue;
+									}
+									// Add module to new chunk
+									chunkGraph.connectChunkAndModule(newPart, module);
+									// Remove module from used chunks
+									chunkGraph.disconnectChunkAndModule(chunk, module);
+								}
+							} else {
+								// change the chunk to be a part
+								chunk.name = name;
 							}
 						}
-						return module;
 					}
-				);
-			}
-		);
-		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
-			const resolvedProvideMap = compilationData.get(compilation);
-			if (!resolvedProvideMap) return Promise.resolve();
-			return Promise.all(
-				Array.from(
-					resolvedProvideMap,
-					([resource, { config, version }]) =>
-						new Promise((resolve, reject) => {
-							compilation.addInclude(
-								compiler.context,
-								new ProvideSharedDependency(
-									config.shareScope,
-									config.shareKey,
-									version || false,
-									resource,
-									config.eager
-								),
-								{
-									name: undefined
-								},
-								err => {
-									if (err) return reject(err);
-									resolve();
-								}
-							);
-						})
-				)
-			).then(() => {});
+					logger.timeEnd("maxSize");
+				}
+			);
 		});
-
-		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ProvideForSharedDependency,
-					normalModuleFactory
-				);
-
-				compilation.dependencyFactories.set(
-					ProvideSharedDependency,
-					new ProvideSharedModuleFactory()
-				);
-			}
-		);
 	}
-}
-
-module.exports = ProvideSharedPlugin;
+};
 
 
 /***/ }),
 
-/***/ 26335:
+/***/ 52149:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const { parseOptions } = __webpack_require__(3083);
-const ConsumeSharedPlugin = __webpack_require__(15046);
-const ProvideSharedPlugin = __webpack_require__(31225);
-const { isRequiredVersion } = __webpack_require__(84379);
+const { formatSize } = __webpack_require__(71070);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvidesConfig} ProvidesConfig */
-/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharePluginOptions} SharePluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharedConfig} SharedConfig */
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
 
-class SharePlugin {
+module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
 	/**
-	 * @param {SharePluginOptions} options options
+	 * @param {AssetDetails[]} assetsOverSizeLimit the assets
+	 * @param {number} assetLimit the size limit
 	 */
-	constructor(options) {
-		/** @type {[string, SharedConfig][]} */
-		const sharedOptions = parseOptions(
-			options.shared,
-			(item, key) => {
-				if (typeof item !== "string")
-					throw new Error("Unexpected array in shared");
-				/** @type {SharedConfig} */
-				const config =
-					item === key || !isRequiredVersion(item)
-						? {
-								import: item
-						  }
-						: {
-								import: key,
-								requiredVersion: item
-						  };
-				return config;
-			},
-			item => item
-		);
-		/** @type {Record<string, ConsumesConfig>[]} */
-		const consumes = sharedOptions.map(([key, options]) => ({
-			[key]: {
-				import: options.import,
-				shareKey: options.shareKey || key,
-				shareScope: options.shareScope,
-				requiredVersion: options.requiredVersion,
-				strictVersion: options.strictVersion,
-				singleton: options.singleton,
-				packageName: options.packageName,
-				eager: options.eager
-			}
-		}));
-		/** @type {Record<string, ProvidesConfig>[]} */
-		const provides = sharedOptions
-			.filter(([, options]) => options.import !== false)
-			.map(([key, options]) => ({
-				[options.import || key]: {
-					shareKey: options.shareKey || key,
-					shareScope: options.shareScope,
-					version: options.version,
-					eager: options.eager
-				}
-			}));
-		this._shareScope = options.shareScope;
-		this._consumes = consumes;
-		this._provides = provides;
-	}
+	constructor(assetsOverSizeLimit, assetLimit) {
+		const assetLists = assetsOverSizeLimit
+			.map(asset => `\n  ${asset.name} (${formatSize(asset.size)})`)
+			.join("");
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		new ConsumeSharedPlugin({
-			shareScope: this._shareScope,
-			consumes: this._consumes
-		}).apply(compiler);
-		new ProvideSharedPlugin({
-			shareScope: this._shareScope,
-			provides: this._provides
-		}).apply(compiler);
-	}
-}
+		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(
+			assetLimit
+		)}).
+This can impact web performance.
+Assets: ${assetLists}`);
 
-module.exports = SharePlugin;
+		this.name = "AssetsOverSizeLimitWarning";
+		this.assets = assetsOverSizeLimit;
+	}
+};
 
 
 /***/ }),
 
-/***/ 96066:
+/***/ 84229:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const {
-	compareModulesByIdentifier,
-	compareStrings
-} = __webpack_require__(29579);
+const { formatSize } = __webpack_require__(71070);
+const WebpackError = __webpack_require__(53799);
 
-class ShareRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("sharing");
-	}
+/** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
 
+module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
 	/**
-	 * @returns {string} runtime code
+	 * @param {EntrypointDetails[]} entrypoints the entrypoints
+	 * @param {number} entrypointLimit the size limit
 	 */
-	generate() {
-		const { compilation, chunkGraph } = this;
-		const {
-			runtimeTemplate,
-			codeGenerationResults,
-			outputOptions: { uniqueName }
-		} = compilation;
-		/** @type {Map<string, Map<number, Set<string>>>} */
-		const initCodePerScope = new Map();
-		for (const chunk of this.chunk.getAllReferencedChunks()) {
-			const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
-				chunk,
-				"share-init",
-				compareModulesByIdentifier
-			);
-			if (!modules) continue;
-			for (const m of modules) {
-				const data = codeGenerationResults.getData(
-					m,
-					chunk.runtime,
-					"share-init"
-				);
-				if (!data) continue;
-				for (const item of data) {
-					const { shareScope, initStage, init } = item;
-					let stages = initCodePerScope.get(shareScope);
-					if (stages === undefined) {
-						initCodePerScope.set(shareScope, (stages = new Map()));
-					}
-					let list = stages.get(initStage || 0);
-					if (list === undefined) {
-						stages.set(initStage || 0, (list = new Set()));
-					}
-					list.add(init);
-				}
-			}
-		}
-		return Template.asString([
-			`${RuntimeGlobals.shareScopeMap} = {};`,
-			"var initPromises = {};",
-			"var initTokens = {};",
-			`${RuntimeGlobals.initializeSharing} = ${runtimeTemplate.basicFunction(
-				"name, initScope",
-				[
-					"if(!initScope) initScope = [];",
-					"// handling circular init calls",
-					"var initToken = initTokens[name];",
-					"if(!initToken) initToken = initTokens[name] = {};",
-					"if(initScope.indexOf(initToken) >= 0) return;",
-					"initScope.push(initToken);",
-					"// only runs once",
-					"if(initPromises[name]) return initPromises[name];",
-					"// creates a new share scope if needed",
-					`if(!${RuntimeGlobals.hasOwnProperty}(${RuntimeGlobals.shareScopeMap}, name)) ${RuntimeGlobals.shareScopeMap}[name] = {};`,
-					"// runs all init snippets from all modules reachable",
-					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
-					`var warn = ${runtimeTemplate.returningFunction(
-						'typeof console !== "undefined" && console.warn && console.warn(msg)',
-						"msg"
-					)};`,
-					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
-					`var register = ${runtimeTemplate.basicFunction(
-						"name, version, factory, eager",
-						[
-							"var versions = scope[name] = scope[name] || {};",
-							"var activeVersion = versions[version];",
-							"if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };"
-						]
-					)};`,
-					`var initExternal = ${runtimeTemplate.basicFunction("id", [
-						`var handleError = ${runtimeTemplate.expressionFunction(
-							'warn("Initialization of sharing external failed: " + err)',
-							"err"
-						)};`,
-						"try {",
-						Template.indent([
-							"var module = __webpack_require__(id);",
-							"if(!module) return;",
-							`var initFn = ${runtimeTemplate.returningFunction(
-								`module && module.init && module.init(${RuntimeGlobals.shareScopeMap}[name], initScope)`,
-								"module"
-							)}`,
-							"if(module.then) return promises.push(module.then(initFn, handleError));",
-							"var initResult = initFn(module);",
-							"if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));"
-						]),
-						"} catch(err) { handleError(err); }"
-					])}`,
-					"var promises = [];",
-					"switch(name) {",
-					...Array.from(initCodePerScope)
-						.sort(([a], [b]) => compareStrings(a, b))
-						.map(([name, stages]) =>
-							Template.indent([
-								`case ${JSON.stringify(name)}: {`,
-								Template.indent(
-									Array.from(stages)
-										.sort(([a], [b]) => a - b)
-										.map(([, initCode]) =>
-											Template.asString(Array.from(initCode))
-										)
-								),
-								"}",
-								"break;"
-							])
-						),
-					"}",
-					"if(!promises.length) return initPromises[name] = 1;",
-					`return initPromises[name] = Promise.all(promises).then(${runtimeTemplate.returningFunction(
-						"initPromises[name] = 1"
-					)});`
-				]
-			)};`
-		]);
-	}
-}
-
-module.exports = ShareRuntimeModule;
-
-
-/***/ }),
-
-/***/ 3591:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ModuleNotFoundError = __webpack_require__(32882);
-const LazySet = __webpack_require__(38938);
-
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
-
-/**
- * @template T
- * @typedef {Object} MatchedConfigs
- * @property {Map<string, T>} resolved
- * @property {Map<string, T>} unresolved
- * @property {Map<string, T>} prefixed
- */
-
-/** @type {ResolveOptionsWithDependencyType} */
-const RESOLVE_OPTIONS = { dependencyType: "esm" };
-
-/**
- * @template T
- * @param {Compilation} compilation the compilation
- * @param {[string, T][]} configs to be processed configs
- * @returns {Promise<MatchedConfigs<T>>} resolved matchers
- */
-exports.resolveMatchedConfigs = (compilation, configs) => {
-	/** @type {Map<string, T>} */
-	const resolved = new Map();
-	/** @type {Map<string, T>} */
-	const unresolved = new Map();
-	/** @type {Map<string, T>} */
-	const prefixed = new Map();
-	const resolveContext = {
-		/** @type {LazySet<string>} */
-		fileDependencies: new LazySet(),
-		/** @type {LazySet<string>} */
-		contextDependencies: new LazySet(),
-		/** @type {LazySet<string>} */
-		missingDependencies: new LazySet()
-	};
-	const resolver = compilation.resolverFactory.get("normal", RESOLVE_OPTIONS);
-	const context = compilation.compiler.context;
-
-	return Promise.all(
-		configs.map(([request, config]) => {
-			if (/^\.\.?(\/|$)/.test(request)) {
-				// relative request
-				return new Promise(resolve => {
-					resolver.resolve(
-						{},
-						context,
-						request,
-						resolveContext,
-						(err, result) => {
-							if (err || result === false) {
-								err = err || new Error(`Can't resolve ${request}`);
-								compilation.errors.push(
-									new ModuleNotFoundError(null, err, {
-										name: `shared module ${request}`
-									})
-								);
-								return resolve();
-							}
-							resolved.set(result, config);
-							resolve();
-						}
-					);
-				});
-			} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
-				// absolute path
-				resolved.set(request, config);
-			} else if (request.endsWith("/")) {
-				// module request prefix
-				prefixed.set(request, config);
-			} else {
-				// module request
-				unresolved.set(request, config);
-			}
-		})
-	).then(() => {
-		compilation.contextDependencies.addAll(resolveContext.contextDependencies);
-		compilation.fileDependencies.addAll(resolveContext.fileDependencies);
-		compilation.missingDependencies.addAll(resolveContext.missingDependencies);
-		return { resolved, unresolved, prefixed };
-	});
-};
-
-
-/***/ }),
-
-/***/ 84379:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { join, dirname, readJson } = __webpack_require__(17139);
-
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-
-/**
- * @param {string} str maybe required version
- * @returns {boolean} true, if it looks like a version
- */
-exports.isRequiredVersion = str => {
-	return /^([\d^=v<>~]|[*xX]$)/.test(str);
-};
-
-/**
- *
- * @param {InputFileSystem} fs file system
- * @param {string} directory directory to start looking into
- * @param {string[]} descriptionFiles possible description filenames
- * @param {function((Error | null)=, {data: object, path: string}=): void} callback callback
- */
-const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
-	let i = 0;
-	const tryLoadCurrent = () => {
-		if (i >= descriptionFiles.length) {
-			const parentDirectory = dirname(fs, directory);
-			if (!parentDirectory || parentDirectory === directory) return callback();
-			return getDescriptionFile(
-				fs,
-				parentDirectory,
-				descriptionFiles,
-				callback
-			);
-		}
-		const filePath = join(fs, directory, descriptionFiles[i]);
-		readJson(fs, filePath, (err, data) => {
-			if (err) {
-				if ("code" in err && err.code === "ENOENT") {
-					i++;
-					return tryLoadCurrent();
-				}
-				return callback(err);
-			}
-			if (!data || typeof data !== "object" || Array.isArray(data)) {
-				return callback(
-					new Error(`Description file ${filePath} is not an object`)
-				);
-			}
-			callback(null, { data, path: filePath });
-		});
-	};
-	tryLoadCurrent();
-};
-exports.getDescriptionFile = getDescriptionFile;
+	constructor(entrypoints, entrypointLimit) {
+		const entrypointList = entrypoints
+			.map(
+				entrypoint =>
+					`\n  ${entrypoint.name} (${formatSize(
+						entrypoint.size
+					)})\n${entrypoint.files.map(asset => `      ${asset}`).join("\n")}`
+			)
+			.join("");
+		super(`entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${formatSize(
+			entrypointLimit
+		)}). This can impact web performance.
+Entrypoints:${entrypointList}\n`);
 
-exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
-	if (
-		data.optionalDependencies &&
-		typeof data.optionalDependencies === "object" &&
-		packageName in data.optionalDependencies
-	) {
-		return data.optionalDependencies[packageName];
-	}
-	if (
-		data.dependencies &&
-		typeof data.dependencies === "object" &&
-		packageName in data.dependencies
-	) {
-		return data.dependencies[packageName];
-	}
-	if (
-		data.peerDependencies &&
-		typeof data.peerDependencies === "object" &&
-		packageName in data.peerDependencies
-	) {
-		return data.peerDependencies[packageName];
-	}
-	if (
-		data.devDependencies &&
-		typeof data.devDependencies === "object" &&
-		packageName in data.devDependencies
-	) {
-		return data.devDependencies[packageName];
+		this.name = "EntrypointsOverSizeLimitWarning";
+		this.entrypoints = entrypoints;
 	}
 };
 
 
 /***/ }),
 
-/***/ 71760:
+/***/ 17791:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const util = __webpack_require__(73837);
-const ModuleDependency = __webpack_require__(80321);
-const formatLocation = __webpack_require__(16734);
-const { LogType } = __webpack_require__(32597);
-const AggressiveSplittingPlugin = __webpack_require__(15543);
-const SizeLimitsPlugin = __webpack_require__(32557);
-const { countIterable } = __webpack_require__(39104);
-const {
-	compareLocations,
-	compareChunksById,
-	compareNumbers,
-	compareIds,
-	concatComparators,
-	compareSelect,
-	compareModulesByIdentifier
-} = __webpack_require__(29579);
-const { makePathsRelative, parseResource } = __webpack_require__(82186);
+const WebpackError = __webpack_require__(53799);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").Asset} Asset */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleProfile")} ModuleProfile */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @template T @typedef {import("../util/comparators").Comparator<T>} Comparator<T> */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
-/** @typedef {import("./StatsFactory")} StatsFactory */
-/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
+module.exports = class NoAsyncChunksWarning extends WebpackError {
+	constructor() {
+		super(
+			"webpack performance recommendations: \n" +
+				"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
+				"For more info visit https://webpack.js.org/guides/code-splitting/"
+		);
 
-/** @typedef {KnownStatsCompilation & Record<string, any>} StatsCompilation */
-/**
- * @typedef {Object} KnownStatsCompilation
- * @property {any=} env
- * @property {string=} name
- * @property {string=} hash
- * @property {string=} version
- * @property {number=} time
- * @property {number=} builtAt
- * @property {boolean=} needAdditionalPass
- * @property {string=} publicPath
- * @property {string=} outputPath
- * @property {Record<string, string[]>=} assetsByChunkName
- * @property {StatsAsset[]=} assets
- * @property {number=} filteredAssets
- * @property {StatsChunk[]=} chunks
- * @property {StatsModule[]=} modules
- * @property {number=} filteredModules
- * @property {Record<string, StatsChunkGroup>=} entrypoints
- * @property {Record<string, StatsChunkGroup>=} namedChunkGroups
- * @property {StatsError[]=} errors
- * @property {number=} errorsCount
- * @property {StatsError[]=} warnings
- * @property {number=} warningsCount
- * @property {StatsCompilation[]=} children
- * @property {Record<string, StatsLogging>=} logging
- */
+		this.name = "NoAsyncChunksWarning";
+	}
+};
 
-/** @typedef {KnownStatsLogging & Record<string, any>} StatsLogging */
-/**
- * @typedef {Object} KnownStatsLogging
- * @property {StatsLoggingEntry[]} entries
- * @property {number} filteredEntries
- * @property {boolean} debug
- */
 
-/** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
-/**
- * @typedef {Object} KnownStatsLoggingEntry
- * @property {string} type
- * @property {string} message
- * @property {string[]=} trace
- * @property {StatsLoggingEntry[]=} children
- * @property {any[]=} args
- * @property {number=} time
- */
+/***/ }),
 
-/** @typedef {KnownStatsAsset & Record<string, any>} StatsAsset */
-/**
- * @typedef {Object} KnownStatsAsset
- * @property {string} type
- * @property {string} name
- * @property {AssetInfo} info
- * @property {number} size
- * @property {boolean} emitted
- * @property {boolean} comparedForEmit
- * @property {boolean} cached
- * @property {StatsAsset[]=} related
- * @property {(string|number)[]=} chunkNames
- * @property {(string|number)[]=} chunkIdHints
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} auxiliaryChunkNames
- * @property {(string|number)[]=} auxiliaryChunks
- * @property {(string|number)[]=} auxiliaryChunkIdHints
- * @property {number=} filteredRelated
- * @property {boolean=} isOverSizeLimit
- */
+/***/ 32557:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
-/**
- * @typedef {Object} KnownStatsChunkGroup
- * @property {string=} name
- * @property {(string|number)[]=} chunks
- * @property {({ name: string, size?: number })[]=} assets
- * @property {number=} filteredAssets
- * @property {number=} assetsSize
- * @property {({ name: string, size?: number })[]=} auxiliaryAssets
- * @property {number=} filteredAuxiliaryAssets
- * @property {number=} auxiliaryAssetsSize
- * @property {{ [x: string]: StatsChunkGroup[] }=} children
- * @property {{ [x: string]: string[] }=} childAssets
- * @property {boolean=} isOverSizeLimit
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
 
-/** @typedef {KnownStatsModule & Record<string, any>} StatsModule */
-/**
- * @typedef {Object} KnownStatsModule
- * @property {string=} type
- * @property {string=} moduleType
- * @property {string=} layer
- * @property {string=} identifier
- * @property {string=} name
- * @property {string=} nameForCondition
- * @property {number=} index
- * @property {number=} preOrderIndex
- * @property {number=} index2
- * @property {number=} postOrderIndex
- * @property {number=} size
- * @property {{[x: string]: number}=} sizes
- * @property {boolean=} cacheable
- * @property {boolean=} built
- * @property {boolean=} codeGenerated
- * @property {boolean=} buildTimeExecuted
- * @property {boolean=} cached
- * @property {boolean=} optional
- * @property {boolean=} orphan
- * @property {string|number=} id
- * @property {string|number=} issuerId
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} assets
- * @property {boolean=} dependent
- * @property {string=} issuer
- * @property {string=} issuerName
- * @property {StatsModuleIssuer[]=} issuerPath
- * @property {boolean=} failed
- * @property {number=} errors
- * @property {number=} warnings
- * @property {StatsProfile=} profile
- * @property {StatsModuleReason[]=} reasons
- * @property {(boolean | string[])=} usedExports
- * @property {string[]=} providedExports
- * @property {string[]=} optimizationBailout
- * @property {number=} depth
- * @property {StatsModule[]=} modules
- * @property {number=} filteredModules
- * @property {ReturnType<Source["source"]>=} source
- */
 
-/** @typedef {KnownStatsProfile & Record<string, any>} StatsProfile */
-/**
- * @typedef {Object} KnownStatsProfile
- * @property {number} total
- * @property {number} resolving
- * @property {number} restoring
- * @property {number} building
- * @property {number} integration
- * @property {number} storing
- * @property {number} additionalResolving
- * @property {number} additionalIntegration
- * @property {number} factory
- * @property {number} dependencies
- */
 
-/** @typedef {KnownStatsModuleIssuer & Record<string, any>} StatsModuleIssuer */
-/**
- * @typedef {Object} KnownStatsModuleIssuer
- * @property {string=} identifier
- * @property {string=} name
- * @property {(string|number)=} id
- * @property {StatsProfile=} profile
- */
+const { find } = __webpack_require__(93347);
+const AssetsOverSizeLimitWarning = __webpack_require__(52149);
+const EntrypointsOverSizeLimitWarning = __webpack_require__(84229);
+const NoAsyncChunksWarning = __webpack_require__(17791);
 
-/** @typedef {KnownStatsModuleReason & Record<string, any>} StatsModuleReason */
-/**
- * @typedef {Object} KnownStatsModuleReason
- * @property {string=} moduleIdentifier
- * @property {string=} module
- * @property {string=} moduleName
- * @property {string=} resolvedModuleIdentifier
- * @property {string=} resolvedModule
- * @property {string=} type
- * @property {boolean} active
- * @property {string=} explanation
- * @property {string=} userRequest
- * @property {string=} loc
- * @property {(string|number)=} moduleId
- * @property {(string|number)=} resolvedModuleId
- */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
 
-/** @typedef {KnownStatsChunk & Record<string, any>} StatsChunk */
 /**
- * @typedef {Object} KnownStatsChunk
- * @property {boolean} rendered
- * @property {boolean} initial
- * @property {boolean} entry
- * @property {boolean} recorded
- * @property {string=} reason
+ * @typedef {Object} AssetDetails
+ * @property {string} name
  * @property {number} size
- * @property {Record<string, number>=} sizes
- * @property {string[]=} names
- * @property {string[]=} idHints
- * @property {string[]=} runtime
- * @property {string[]=} files
- * @property {string[]=} auxiliaryFiles
- * @property {string} hash
- * @property {Record<string, (string|number)[]>=} childrenByOrder
- * @property {(string|number)=} id
- * @property {(string|number)[]=} siblings
- * @property {(string|number)[]=} parents
- * @property {(string|number)[]=} children
- * @property {StatsModule[]=} modules
- * @property {number=} filteredModules
- * @property {StatsChunkOrigin[]=} origins
  */
 
-/** @typedef {KnownStatsChunkOrigin & Record<string, any>} StatsChunkOrigin */
-/**
- * @typedef {Object} KnownStatsChunkOrigin
- * @property {string=} module
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {string=} loc
- * @property {string=} request
- * @property {(string|number)=} moduleId
- */
-
-/** @typedef {KnownStatsModuleTraceItem & Record<string, any>} StatsModuleTraceItem */
-/**
- * @typedef {Object} KnownStatsModuleTraceItem
- * @property {string=} originIdentifier
- * @property {string=} originName
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {StatsModuleTraceDependency[]=} dependencies
- * @property {(string|number)=} originId
- * @property {(string|number)=} moduleId
- */
-
-/** @typedef {KnownStatsModuleTraceDependency & Record<string, any>} StatsModuleTraceDependency */
-/**
- * @typedef {Object} KnownStatsModuleTraceDependency
- * @property {string=} loc
- */
-
-/** @typedef {KnownStatsError & Record<string, any>} StatsError */
-/**
- * @typedef {Object} KnownStatsError
- * @property {string} message
- * @property {string=} chunkName
- * @property {boolean=} chunkEntry
- * @property {boolean=} chunkInitial
- * @property {string=} file
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {string=} loc
- * @property {string|number=} chunkId
- * @property {string|number=} moduleId
- * @property {StatsModuleTraceItem[]=} moduleTrace
- * @property {any=} details
- * @property {string=} stack
- */
-
-/** @typedef {Asset & { type: string, related: PreprocessedAsset[] }} PreprocessedAsset */
-
-/**
- * @template T
- * @template O
- * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
- */
-
-/**
- * @typedef {Object} SimpleExtractors
- * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
- * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
- * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
- * @property {ExtractorsByOption<{ name: string, chunkGroup: ChunkGroup }, StatsChunkGroup>} chunkGroup
- * @property {ExtractorsByOption<Module, StatsModule>} module
- * @property {ExtractorsByOption<Module, StatsModule>} module$visible
- * @property {ExtractorsByOption<Module, StatsModuleIssuer>} moduleIssuer
- * @property {ExtractorsByOption<ModuleProfile, StatsProfile>} profile
- * @property {ExtractorsByOption<ModuleGraphConnection, StatsModuleReason>} moduleReason
- * @property {ExtractorsByOption<Chunk, StatsChunk>} chunk
- * @property {ExtractorsByOption<OriginRecord, StatsChunkOrigin>} chunkOrigin
- * @property {ExtractorsByOption<WebpackError, StatsError>} error
- * @property {ExtractorsByOption<WebpackError, StatsError>} warning
- * @property {ExtractorsByOption<{ origin: Module, module: Module }, StatsModuleTraceItem>} moduleTraceItem
- * @property {ExtractorsByOption<Dependency, StatsModuleTraceDependency>} moduleTraceDependency
- */
-
-/**
- * @template T
- * @template I
- * @param {Iterable<T>} items items to select from
- * @param {function(T): Iterable<I>} selector selector function to select values from item
- * @returns {I[]} array of values
- */
-const uniqueArray = (items, selector) => {
-	/** @type {Set<I>} */
-	const set = new Set();
-	for (const item of items) {
-		for (const i of selector(item)) {
-			set.add(i);
-		}
-	}
-	return Array.from(set);
-};
-
-/**
- * @template T
- * @template I
- * @param {Iterable<T>} items items to select from
- * @param {function(T): Iterable<I>} selector selector function to select values from item
- * @param {Comparator<I>} comparator comparator function
- * @returns {I[]} array of values
- */
-const uniqueOrderedArray = (items, selector, comparator) => {
-	return uniqueArray(items, selector).sort(comparator);
-};
-
-/** @template T @template R @typedef {{ [P in keyof T]: R }} MappedValues<T, R> */
-
-/**
- * @template T
- * @template R
- * @param {T} obj object to be mapped
- * @param {function(T[keyof T], keyof T): R} fn mapping function
- * @returns {MappedValues<T, R>} mapped object
- */
-const mapObject = (obj, fn) => {
-	const newObj = Object.create(null);
-	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], /** @type {keyof T} */ (key));
-	}
-	return newObj;
-};
-
-/**
- * @param {Compilation} compilation the compilation
- * @param {function(Compilation, string): any[]} getItems get items
- * @returns {number} total number
- */
-const countWithChildren = (compilation, getItems) => {
-	let count = getItems(compilation, "").length;
-	for (const child of compilation.children) {
-		count += countWithChildren(child, (c, type) =>
-			getItems(c, `.children[].compilation${type}`)
-		);
-	}
-	return count;
-};
-
-/** @type {ExtractorsByOption<WebpackError | string, StatsError>} */
-const EXTRACT_ERROR = {
-	_: (object, error, context, { requestShortener }) => {
-		// TODO webpack 6 disallow strings in the errors/warnings list
-		if (typeof error === "string") {
-			object.message = error;
-		} else {
-			if (error.chunk) {
-				object.chunkName = error.chunk.name;
-				object.chunkEntry = error.chunk.hasRuntime();
-				object.chunkInitial = error.chunk.canBeInitial();
-			}
-			if (error.file) {
-				object.file = error.file;
-			}
-			if (error.module) {
-				object.moduleIdentifier = error.module.identifier();
-				object.moduleName = error.module.readableIdentifier(requestShortener);
-			}
-			if (error.loc) {
-				object.loc = formatLocation(error.loc);
-			}
-			object.message = error.message;
-		}
-	},
-	ids: (object, error, { compilation: { chunkGraph } }) => {
-		if (typeof error !== "string") {
-			if (error.chunk) {
-				object.chunkId = error.chunk.id;
-			}
-			if (error.module) {
-				object.moduleId = chunkGraph.getModuleId(error.module);
-			}
-		}
-	},
-	moduleTrace: (object, error, context, options, factory) => {
-		if (typeof error !== "string" && error.module) {
-			const {
-				type,
-				compilation: { moduleGraph }
-			} = context;
-			/** @type {Set<Module>} */
-			const visitedModules = new Set();
-			const moduleTrace = [];
-			let current = error.module;
-			while (current) {
-				if (visitedModules.has(current)) break; // circular (technically impossible, but how knows)
-				visitedModules.add(current);
-				const origin = moduleGraph.getIssuer(current);
-				if (!origin) break;
-				moduleTrace.push({ origin, module: current });
-				current = origin;
-			}
-			object.moduleTrace = factory.create(
-				`${type}.moduleTrace`,
-				moduleTrace,
-				context
-			);
-		}
-	},
-	errorDetails: (
-		object,
-		error,
-		{ type, compilation, cachedGetErrors, cachedGetWarnings },
-		{ errorDetails }
-	) => {
-		if (
-			typeof error !== "string" &&
-			(errorDetails === true ||
-				(type.endsWith(".error") && cachedGetErrors(compilation).length < 3))
-		) {
-			object.details = error.details;
-		}
-	},
-	errorStack: (object, error) => {
-		if (typeof error !== "string") {
-			object.stack = error.stack;
-		}
-	}
-};
-
-/** @type {SimpleExtractors} */
-const SIMPLE_EXTRACTORS = {
-	compilation: {
-		_: (object, compilation, context, options) => {
-			if (!context.makePathsRelative) {
-				context.makePathsRelative = makePathsRelative.bindContextCache(
-					compilation.compiler.context,
-					compilation.compiler.root
-				);
-			}
-			if (!context.cachedGetErrors) {
-				const map = new WeakMap();
-				context.cachedGetErrors = compilation => {
-					return (
-						map.get(compilation) ||
-						(errors => (map.set(compilation, errors), errors))(
-							compilation.getErrors()
-						)
-					);
-				};
-			}
-			if (!context.cachedGetWarnings) {
-				const map = new WeakMap();
-				context.cachedGetWarnings = compilation => {
-					return (
-						map.get(compilation) ||
-						(warnings => (map.set(compilation, warnings), warnings))(
-							compilation.getWarnings()
-						)
-					);
-				};
-			}
-			if (compilation.name) {
-				object.name = compilation.name;
-			}
-			if (compilation.needAdditionalPass) {
-				object.needAdditionalPass = true;
-			}
-
-			const { logging, loggingDebug, loggingTrace } = options;
-			if (logging || (loggingDebug && loggingDebug.length > 0)) {
-				const util = __webpack_require__(73837);
-				object.logging = {};
-				let acceptedTypes;
-				let collapsedGroups = false;
-				switch (logging) {
-					default:
-						acceptedTypes = new Set();
-						break;
-					case "error":
-						acceptedTypes = new Set([LogType.error]);
-						break;
-					case "warn":
-						acceptedTypes = new Set([LogType.error, LogType.warn]);
-						break;
-					case "info":
-						acceptedTypes = new Set([
-							LogType.error,
-							LogType.warn,
-							LogType.info
-						]);
-						break;
-					case "log":
-						acceptedTypes = new Set([
-							LogType.error,
-							LogType.warn,
-							LogType.info,
-							LogType.log,
-							LogType.group,
-							LogType.groupEnd,
-							LogType.groupCollapsed,
-							LogType.clear
-						]);
-						break;
-					case "verbose":
-						acceptedTypes = new Set([
-							LogType.error,
-							LogType.warn,
-							LogType.info,
-							LogType.log,
-							LogType.group,
-							LogType.groupEnd,
-							LogType.groupCollapsed,
-							LogType.profile,
-							LogType.profileEnd,
-							LogType.time,
-							LogType.status,
-							LogType.clear
-						]);
-						collapsedGroups = true;
-						break;
-				}
-				const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-					options.context,
-					compilation.compiler.root
-				);
-				let depthInCollapsedGroup = 0;
-				for (const [origin, logEntries] of compilation.logging) {
-					const debugMode = loggingDebug.some(fn => fn(origin));
-					if (logging === false && !debugMode) continue;
-					/** @type {KnownStatsLoggingEntry[]} */
-					const groupStack = [];
-					/** @type {KnownStatsLoggingEntry[]} */
-					const rootList = [];
-					let currentList = rootList;
-					let processedLogEntries = 0;
-					for (const entry of logEntries) {
-						let type = entry.type;
-						if (!debugMode && !acceptedTypes.has(type)) continue;
+/**
+ * @typedef {Object} EntrypointDetails
+ * @property {string} name
+ * @property {number} size
+ * @property {string[]} files
+ */
 
-						// Expand groups in verbose and debug modes
-						if (
-							type === LogType.groupCollapsed &&
-							(debugMode || collapsedGroups)
-						)
-							type = LogType.group;
+const isOverSizeLimitSet = new WeakSet();
 
-						if (depthInCollapsedGroup === 0) {
-							processedLogEntries++;
-						}
+const excludeSourceMap = (name, source, info) => !info.development;
 
-						if (type === LogType.groupEnd) {
-							groupStack.pop();
-							if (groupStack.length > 0) {
-								currentList = groupStack[groupStack.length - 1].children;
-							} else {
-								currentList = rootList;
-							}
-							if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
-							continue;
-						}
-						let message = undefined;
-						if (entry.type === LogType.time) {
-							message = `${entry.args[0]}: ${
-								entry.args[1] * 1000 + entry.args[2] / 1000000
-							} ms`;
-						} else if (entry.args && entry.args.length > 0) {
-							message = util.format(entry.args[0], ...entry.args.slice(1));
-						}
-						/** @type {KnownStatsLoggingEntry} */
-						const newEntry = {
-							...entry,
-							type,
-							message,
-							trace: loggingTrace ? entry.trace : undefined,
-							children:
-								type === LogType.group || type === LogType.groupCollapsed
-									? []
-									: undefined
-						};
-						currentList.push(newEntry);
-						if (newEntry.children) {
-							groupStack.push(newEntry);
-							currentList = newEntry.children;
-							if (depthInCollapsedGroup > 0) {
-								depthInCollapsedGroup++;
-							} else if (type === LogType.groupCollapsed) {
-								depthInCollapsedGroup = 1;
-							}
-						}
-					}
-					let name = cachedMakePathsRelative(origin).replace(/\|/g, " ");
-					if (name in object.logging) {
-						let i = 1;
-						while (`${name}#${i}` in object.logging) {
-							i++;
-						}
-						name = `${name}#${i}`;
-					}
-					object.logging[name] = {
-						entries: rootList,
-						filteredEntries: logEntries.length - processedLogEntries,
-						debug: debugMode
-					};
-				}
-			}
-		},
-		hash: (object, compilation) => {
-			object.hash = compilation.hash;
-		},
-		version: object => {
-			object.version = (__webpack_require__(32702)/* .version */ .i8);
-		},
-		env: (object, compilation, context, { _env }) => {
-			object.env = _env;
-		},
-		timings: (object, compilation) => {
-			object.time = compilation.endTime - compilation.startTime;
-		},
-		builtAt: (object, compilation) => {
-			object.builtAt = compilation.endTime;
-		},
-		publicPath: (object, compilation) => {
-			object.publicPath = compilation.getPath(
-				compilation.outputOptions.publicPath
-			);
-		},
-		outputPath: (object, compilation) => {
-			object.outputPath = compilation.outputOptions.path;
-		},
-		assets: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			/** @type {Map<string, Chunk[]>} */
-			const compilationFileToChunks = new Map();
-			/** @type {Map<string, Chunk[]>} */
-			const compilationAuxiliaryFileToChunks = new Map();
-			for (const chunk of compilation.chunks) {
-				for (const file of chunk.files) {
-					let array = compilationFileToChunks.get(file);
-					if (array === undefined) {
-						array = [];
-						compilationFileToChunks.set(file, array);
-					}
-					array.push(chunk);
-				}
-				for (const file of chunk.auxiliaryFiles) {
-					let array = compilationAuxiliaryFileToChunks.get(file);
-					if (array === undefined) {
-						array = [];
-						compilationAuxiliaryFileToChunks.set(file, array);
-					}
-					array.push(chunk);
-				}
-			}
-			/** @type {Map<string, PreprocessedAsset>} */
-			const assetMap = new Map();
-			/** @type {Set<PreprocessedAsset>} */
-			const assets = new Set();
-			for (const asset of compilation.getAssets()) {
-				/** @type {PreprocessedAsset} */
-				const item = {
-					...asset,
-					type: "asset",
-					related: undefined
-				};
-				assets.add(item);
-				assetMap.set(asset.name, item);
-			}
-			for (const item of assetMap.values()) {
-				const related = item.info.related;
-				if (!related) continue;
-				for (const type of Object.keys(related)) {
-					const relatedEntry = related[type];
-					const deps = Array.isArray(relatedEntry)
-						? relatedEntry
-						: [relatedEntry];
-					for (const dep of deps) {
-						const depItem = assetMap.get(dep);
-						if (!depItem) continue;
-						assets.delete(depItem);
-						depItem.type = type;
-						item.related = item.related || [];
-						item.related.push(depItem);
-					}
-				}
-			}
+module.exports = class SizeLimitsPlugin {
+	/**
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		this.hints = options.hints;
+		this.maxAssetSize = options.maxAssetSize;
+		this.maxEntrypointSize = options.maxEntrypointSize;
+		this.assetFilter = options.assetFilter;
+	}
 
-			object.assetsByChunkName = {};
-			for (const [file, chunks] of compilationFileToChunks) {
-				for (const chunk of chunks) {
-					const name = chunk.name;
-					if (!name) continue;
-					if (
-						!Object.prototype.hasOwnProperty.call(
-							object.assetsByChunkName,
-							name
-						)
-					) {
-						object.assetsByChunkName[name] = [];
-					}
-					object.assetsByChunkName[name].push(file);
-				}
-			}
+	/**
+	 * @param {ChunkGroup | Source} thing the resource to test
+	 * @returns {boolean} true if over the limit
+	 */
+	static isOverSizeLimit(thing) {
+		return isOverSizeLimitSet.has(thing);
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const entrypointSizeLimit = this.maxEntrypointSize;
+		const assetSizeLimit = this.maxAssetSize;
+		const hints = this.hints;
+		const assetFilter = this.assetFilter || excludeSourceMap;
+
+		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
+			/** @type {WebpackError[]} */
+			const warnings = [];
 
-			const groupedAssets = factory.create(
-				`${type}.assets`,
-				Array.from(assets),
-				{
-					...context,
-					compilationFileToChunks,
-					compilationAuxiliaryFileToChunks
-				}
-			);
-			const limited = spaceLimited(groupedAssets, options.assetsSpace);
-			object.assets = limited.children;
-			object.filteredAssets = limited.filteredChildren;
-		},
-		chunks: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			object.chunks = factory.create(
-				`${type}.chunks`,
-				Array.from(compilation.chunks),
-				context
-			);
-		},
-		modules: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			const array = Array.from(compilation.modules);
-			const groupedModules = factory.create(`${type}.modules`, array, context);
-			const limited = spaceLimited(groupedModules, options.modulesSpace);
-			object.modules = limited.children;
-			object.filteredModules = limited.filteredChildren;
-		},
-		entrypoints: (
-			object,
-			compilation,
-			context,
-			{ entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren },
-			factory
-		) => {
-			const { type } = context;
-			const array = Array.from(compilation.entrypoints, ([key, value]) => ({
-				name: key,
-				chunkGroup: value
-			}));
-			if (entrypoints === "auto" && !chunkGroups) {
-				if (array.length > 5) return;
-				if (
-					!chunkGroupChildren &&
-					array.every(({ chunkGroup }) => {
-						if (chunkGroup.chunks.length !== 1) return false;
-						const chunk = chunkGroup.chunks[0];
-						return (
-							chunk.files.size === 1 &&
-							(!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0)
-						);
-					})
-				) {
-					return;
-				}
-			}
-			object.entrypoints = factory.create(
-				`${type}.entrypoints`,
-				array,
-				context
-			);
-		},
-		chunkGroups: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			const array = Array.from(
-				compilation.namedChunkGroups,
-				([key, value]) => ({
-					name: key,
-					chunkGroup: value
-				})
-			);
-			object.namedChunkGroups = factory.create(
-				`${type}.namedChunkGroups`,
-				array,
-				context
-			);
-		},
-		errors: (object, compilation, context, options, factory) => {
-			const { type, cachedGetErrors } = context;
-			object.errors = factory.create(
-				`${type}.errors`,
-				cachedGetErrors(compilation),
-				context
-			);
-		},
-		errorsCount: (object, compilation, { cachedGetErrors }) => {
-			object.errorsCount = countWithChildren(compilation, c =>
-				cachedGetErrors(c)
-			);
-		},
-		warnings: (object, compilation, context, options, factory) => {
-			const { type, cachedGetWarnings } = context;
-			object.warnings = factory.create(
-				`${type}.warnings`,
-				cachedGetWarnings(compilation),
-				context
-			);
-		},
-		warningsCount: (
-			object,
-			compilation,
-			context,
-			{ warningsFilter },
-			factory
-		) => {
-			const { type, cachedGetWarnings } = context;
-			object.warningsCount = countWithChildren(compilation, (c, childType) => {
-				if (!warningsFilter && warningsFilter.length === 0)
-					return cachedGetWarnings(c);
-				return factory
-					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
-					.filter(warning => {
-						const warningString = Object.keys(warning)
-							.map(key => `${warning[key]}`)
-							.join("\n");
-						return !warningsFilter.some(filter =>
-							filter(warning, warningString)
-						);
-					});
-			});
-		},
-		errorDetails: (
-			object,
-			compilation,
-			{ cachedGetErrors, cachedGetWarnings },
-			{ errorDetails, errors, warnings }
-		) => {
-			if (errorDetails === "auto") {
-				if (warnings) {
-					const warnings = cachedGetWarnings(compilation);
-					object.filteredWarningDetailsCount = warnings
-						.map(e => typeof e !== "string" && e.details)
-						.filter(Boolean).length;
-				}
-				if (errors) {
-					const errors = cachedGetErrors(compilation);
-					if (errors.length >= 3) {
-						object.filteredErrorDetailsCount = errors
-							.map(e => typeof e !== "string" && e.details)
-							.filter(Boolean).length;
-					}
-				}
-			}
-		},
-		children: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			object.children = factory.create(
-				`${type}.children`,
-				compilation.children,
-				context
-			);
-		}
-	},
-	asset: {
-		_: (object, asset, context, options, factory) => {
-			const { compilation } = context;
-			object.type = asset.type;
-			object.name = asset.name;
-			object.size = asset.source.size();
-			object.emitted = compilation.emittedAssets.has(asset.name);
-			object.comparedForEmit = compilation.comparedForEmitAssets.has(
-				asset.name
-			);
-			const cached = !object.emitted && !object.comparedForEmit;
-			object.cached = cached;
-			object.info = asset.info;
-			if (!cached || options.cachedAssets) {
-				Object.assign(
-					object,
-					factory.create(`${context.type}$visible`, asset, context)
-				);
-			}
-		}
-	},
-	asset$visible: {
-		_: (
-			object,
-			asset,
-			{ compilation, compilationFileToChunks, compilationAuxiliaryFileToChunks }
-		) => {
-			const chunks = compilationFileToChunks.get(asset.name) || [];
-			const auxiliaryChunks =
-				compilationAuxiliaryFileToChunks.get(asset.name) || [];
-			object.chunkNames = uniqueOrderedArray(
-				chunks,
-				c => (c.name ? [c.name] : []),
-				compareIds
-			);
-			object.chunkIdHints = uniqueOrderedArray(
-				chunks,
-				c => Array.from(c.idNameHints),
-				compareIds
-			);
-			object.auxiliaryChunkNames = uniqueOrderedArray(
-				auxiliaryChunks,
-				c => (c.name ? [c.name] : []),
-				compareIds
-			);
-			object.auxiliaryChunkIdHints = uniqueOrderedArray(
-				auxiliaryChunks,
-				c => Array.from(c.idNameHints),
-				compareIds
-			);
-			object.filteredRelated = asset.related ? asset.related.length : undefined;
-		},
-		relatedAssets: (object, asset, context, options, factory) => {
-			const { type } = context;
-			object.related = factory.create(
-				`${type.slice(0, -8)}.related`,
-				asset.related,
-				context
-			);
-			object.filteredRelated = asset.related
-				? asset.related.length - object.related.length
-				: undefined;
-		},
-		ids: (
-			object,
-			asset,
-			{ compilationFileToChunks, compilationAuxiliaryFileToChunks }
-		) => {
-			const chunks = compilationFileToChunks.get(asset.name) || [];
-			const auxiliaryChunks =
-				compilationAuxiliaryFileToChunks.get(asset.name) || [];
-			object.chunks = uniqueOrderedArray(chunks, c => c.ids, compareIds);
-			object.auxiliaryChunks = uniqueOrderedArray(
-				auxiliaryChunks,
-				c => c.ids,
-				compareIds
-			);
-		},
-		performance: (object, asset) => {
-			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(asset.source);
-		}
-	},
-	chunkGroup: {
-		_: (
-			object,
-			{ name, chunkGroup },
-			{ compilation, compilation: { moduleGraph, chunkGraph } },
-			{ ids, chunkGroupAuxiliary, chunkGroupChildren, chunkGroupMaxAssets }
-		) => {
-			const children =
-				chunkGroupChildren &&
-				chunkGroup.getChildrenByOrders(moduleGraph, chunkGraph);
 			/**
-			 * @param {string} name Name
-			 * @returns {{ name: string, size: number }} Asset object
+			 * @param {Entrypoint} entrypoint an entrypoint
+			 * @returns {number} the size of the entrypoint
 			 */
-			const toAsset = name => {
-				const asset = compilation.getAsset(name);
-				return {
-					name,
-					size: asset ? asset.info.size : -1
-				};
+			const getEntrypointSize = entrypoint => {
+				let size = 0;
+				for (const file of entrypoint.getFiles()) {
+					const asset = compilation.getAsset(file);
+					if (
+						asset &&
+						assetFilter(asset.name, asset.source, asset.info) &&
+						asset.source
+					) {
+						size += asset.info.size || asset.source.size();
+					}
+				}
+				return size;
 			};
-			/** @type {(total: number, asset: { size: number }) => number} */
-			const sizeReducer = (total, { size }) => total + size;
-			const assets = uniqueArray(chunkGroup.chunks, c => c.files).map(toAsset);
-			const auxiliaryAssets = uniqueOrderedArray(
-				chunkGroup.chunks,
-				c => c.auxiliaryFiles,
-				compareIds
-			).map(toAsset);
-			const assetsSize = assets.reduce(sizeReducer, 0);
-			const auxiliaryAssetsSize = auxiliaryAssets.reduce(sizeReducer, 0);
-			/** @type {KnownStatsChunkGroup} */
-			const statsChunkGroup = {
-				name,
-				chunks: ids ? chunkGroup.chunks.map(c => c.id) : undefined,
-				assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
-				filteredAssets:
-					assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
-				assetsSize,
-				auxiliaryAssets:
-					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
-						? auxiliaryAssets
-						: undefined,
-				filteredAuxiliaryAssets:
-					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
-						? 0
-						: auxiliaryAssets.length,
-				auxiliaryAssetsSize,
-				children: children
-					? mapObject(children, groups =>
-							groups.map(group => {
-								const assets = uniqueArray(group.chunks, c => c.files).map(
-									toAsset
-								);
-								const auxiliaryAssets = uniqueOrderedArray(
-									group.chunks,
-									c => c.auxiliaryFiles,
-									compareIds
-								).map(toAsset);
 
-								/** @type {KnownStatsChunkGroup} */
-								const childStatsChunkGroup = {
-									name: group.name,
-									chunks: ids ? group.chunks.map(c => c.id) : undefined,
-									assets:
-										assets.length <= chunkGroupMaxAssets ? assets : undefined,
-									filteredAssets:
-										assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
-									auxiliaryAssets:
-										chunkGroupAuxiliary &&
-										auxiliaryAssets.length <= chunkGroupMaxAssets
-											? auxiliaryAssets
-											: undefined,
-									filteredAuxiliaryAssets:
-										chunkGroupAuxiliary &&
-										auxiliaryAssets.length <= chunkGroupMaxAssets
-											? 0
-											: auxiliaryAssets.length
-								};
+			/** @type {AssetDetails[]} */
+			const assetsOverSizeLimit = [];
+			for (const { name, source, info } of compilation.getAssets()) {
+				if (!assetFilter(name, source, info) || !source) {
+					continue;
+				}
 
-								return childStatsChunkGroup;
-							})
-					  )
-					: undefined,
-				childAssets: children
-					? mapObject(children, groups => {
-							/** @type {Set<string>} */
-							const set = new Set();
-							for (const group of groups) {
-								for (const chunk of group.chunks) {
-									for (const asset of chunk.files) {
-										set.add(asset);
-									}
-								}
-							}
-							return Array.from(set);
-					  })
-					: undefined
-			};
-			Object.assign(object, statsChunkGroup);
-		},
-		performance: (object, { chunkGroup }) => {
-			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(chunkGroup);
-		}
-	},
-	module: {
-		_: (object, module, context, options, factory) => {
-			const { compilation, type } = context;
-			const built = compilation.builtModules.has(module);
-			const codeGenerated = compilation.codeGeneratedModules.has(module);
-			const buildTimeExecuted =
-				compilation.buildTimeExecutedModules.has(module);
-			/** @type {{[x: string]: number}} */
-			const sizes = {};
-			for (const sourceType of module.getSourceTypes()) {
-				sizes[sourceType] = module.size(sourceType);
+				const size = info.size || source.size();
+				if (size > assetSizeLimit) {
+					assetsOverSizeLimit.push({
+						name,
+						size
+					});
+					isOverSizeLimitSet.add(source);
+				}
 			}
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				type: "module",
-				moduleType: module.type,
-				layer: module.layer,
-				size: module.size(),
-				sizes,
-				built,
-				codeGenerated,
-				buildTimeExecuted,
-				cached: !built && !codeGenerated
-			};
-			Object.assign(object, statsModule);
 
-			if (built || codeGenerated || options.cachedModules) {
-				Object.assign(
-					object,
-					factory.create(`${type}$visible`, module, context)
-				);
-			}
-		}
-	},
-	module$visible: {
-		_: (object, module, context, { requestShortener }, factory) => {
-			const { compilation, type, rootModules } = context;
-			const { moduleGraph } = compilation;
-			/** @type {Module[]} */
-			const path = [];
-			const issuer = moduleGraph.getIssuer(module);
-			let current = issuer;
-			while (current) {
-				path.push(current);
-				current = moduleGraph.getIssuer(current);
-			}
-			path.reverse();
-			const profile = moduleGraph.getProfile(module);
-			const errors = module.getErrors();
-			const errorsCount = errors !== undefined ? countIterable(errors) : 0;
-			const warnings = module.getWarnings();
-			const warningsCount =
-				warnings !== undefined ? countIterable(warnings) : 0;
-			/** @type {{[x: string]: number}} */
-			const sizes = {};
-			for (const sourceType of module.getSourceTypes()) {
-				sizes[sourceType] = module.size(sourceType);
-			}
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener),
-				nameForCondition: module.nameForCondition(),
-				index: moduleGraph.getPreOrderIndex(module),
-				preOrderIndex: moduleGraph.getPreOrderIndex(module),
-				index2: moduleGraph.getPostOrderIndex(module),
-				postOrderIndex: moduleGraph.getPostOrderIndex(module),
-				cacheable: module.buildInfo.cacheable,
-				optional: module.isOptional(moduleGraph),
-				orphan:
-					!type.endsWith("module.modules[].module$visible") &&
-					compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
-				dependent: rootModules ? !rootModules.has(module) : undefined,
-				issuer: issuer && issuer.identifier(),
-				issuerName: issuer && issuer.readableIdentifier(requestShortener),
-				issuerPath:
-					issuer &&
-					factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
-				failed: errorsCount > 0,
-				errors: errorsCount,
-				warnings: warningsCount
-			};
-			Object.assign(object, statsModule);
-			if (profile) {
-				object.profile = factory.create(
-					`${type.slice(0, -8)}.profile`,
-					profile,
-					context
-				);
-			}
-		},
-		ids: (object, module, { compilation: { chunkGraph, moduleGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
-			const issuer = moduleGraph.getIssuer(module);
-			object.issuerId = issuer && chunkGraph.getModuleId(issuer);
-			object.chunks = Array.from(
-				chunkGraph.getOrderedModuleChunksIterable(module, compareChunksById),
-				chunk => chunk.id
-			);
-		},
-		moduleAssets: (object, module) => {
-			object.assets = module.buildInfo.assets
-				? Object.keys(module.buildInfo.assets)
-				: [];
-		},
-		reasons: (object, module, context, options, factory) => {
-			const {
-				type,
-				compilation: { moduleGraph }
-			} = context;
-			const groupsReasons = factory.create(
-				`${type.slice(0, -8)}.reasons`,
-				Array.from(moduleGraph.getIncomingConnections(module)),
-				context
-			);
-			const limited = spaceLimited(groupsReasons, options.reasonsSpace);
-			object.reasons = limited.children;
-			object.filteredReasons = limited.filteredChildren;
-		},
-		usedExports: (
-			object,
-			module,
-			{ runtime, compilation: { moduleGraph } }
-		) => {
-			const usedExports = moduleGraph.getUsedExports(module, runtime);
-			if (usedExports === null) {
-				object.usedExports = null;
-			} else if (typeof usedExports === "boolean") {
-				object.usedExports = usedExports;
-			} else {
-				object.usedExports = Array.from(usedExports);
-			}
-		},
-		providedExports: (object, module, { compilation: { moduleGraph } }) => {
-			const providedExports = moduleGraph.getProvidedExports(module);
-			object.providedExports = Array.isArray(providedExports)
-				? providedExports
-				: null;
-		},
-		optimizationBailout: (
-			object,
-			module,
-			{ compilation: { moduleGraph } },
-			{ requestShortener }
-		) => {
-			object.optimizationBailout = moduleGraph
-				.getOptimizationBailout(module)
-				.map(item => {
-					if (typeof item === "function") return item(requestShortener);
-					return item;
-				});
-		},
-		depth: (object, module, { compilation: { moduleGraph } }) => {
-			object.depth = moduleGraph.getDepth(module);
-		},
-		nestedModules: (object, module, context, options, factory) => {
-			const { type } = context;
-			const innerModules = /** @type {Module & { modules?: Module[] }} */ (
-				module
-			).modules;
-			if (Array.isArray(innerModules)) {
-				const groupedModules = factory.create(
-					`${type.slice(0, -8)}.modules`,
-					innerModules,
-					context
-				);
-				const limited = spaceLimited(
-					groupedModules,
-					options.nestedModulesSpace
-				);
-				object.modules = limited.children;
-				object.filteredModules = limited.filteredChildren;
-			}
-		},
-		source: (object, module) => {
-			const originalSource = module.originalSource();
-			if (originalSource) {
-				object.source = originalSource.source();
-			}
-		}
-	},
-	profile: {
-		_: (object, profile) => {
-			/** @type {KnownStatsProfile} */
-			const statsProfile = {
-				total:
-					profile.factory +
-					profile.restoring +
-					profile.integration +
-					profile.building +
-					profile.storing,
-				resolving: profile.factory,
-				restoring: profile.restoring,
-				building: profile.building,
-				integration: profile.integration,
-				storing: profile.storing,
-				additionalResolving: profile.additionalFactories,
-				additionalIntegration: profile.additionalIntegration,
-				// TODO remove this in webpack 6
-				factory: profile.factory,
-				// TODO remove this in webpack 6
-				dependencies: profile.additionalFactories
-			};
-			Object.assign(object, statsProfile);
-		}
-	},
-	moduleIssuer: {
-		_: (object, module, context, { requestShortener }, factory) => {
-			const { compilation, type } = context;
-			const { moduleGraph } = compilation;
-			const profile = moduleGraph.getProfile(module);
-			/** @type {KnownStatsModuleIssuer} */
-			const statsModuleIssuer = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener)
-			};
-			Object.assign(object, statsModuleIssuer);
-			if (profile) {
-				object.profile = factory.create(`${type}.profile`, profile, context);
-			}
-		},
-		ids: (object, module, { compilation: { chunkGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
-		}
-	},
-	moduleReason: {
-		_: (object, reason, { runtime }, { requestShortener }) => {
-			const dep = reason.dependency;
-			const moduleDep =
-				dep && dep instanceof ModuleDependency ? dep : undefined;
-			/** @type {KnownStatsModuleReason} */
-			const statsModuleReason = {
-				moduleIdentifier: reason.originModule
-					? reason.originModule.identifier()
-					: null,
-				module: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				moduleName: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				resolvedModuleIdentifier: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.identifier()
-					: null,
-				resolvedModule: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.readableIdentifier(requestShortener)
-					: null,
-				type: reason.dependency ? reason.dependency.type : null,
-				active: reason.isActive(runtime),
-				explanation: reason.explanation,
-				userRequest: (moduleDep && moduleDep.userRequest) || null
+			const fileFilter = name => {
+				const asset = compilation.getAsset(name);
+				return asset && assetFilter(asset.name, asset.source, asset.info);
 			};
-			Object.assign(object, statsModuleReason);
-			if (reason.dependency) {
-				const locInfo = formatLocation(reason.dependency.loc);
-				if (locInfo) {
-					object.loc = locInfo;
+
+			/** @type {EntrypointDetails[]} */
+			const entrypointsOverLimit = [];
+			for (const [name, entry] of compilation.entrypoints) {
+				const size = getEntrypointSize(entry);
+
+				if (size > entrypointSizeLimit) {
+					entrypointsOverLimit.push({
+						name: name,
+						size: size,
+						files: entry.getFiles().filter(fileFilter)
+					});
+					isOverSizeLimitSet.add(entry);
 				}
 			}
-		},
-		ids: (object, reason, { compilation: { chunkGraph } }) => {
-			object.moduleId = reason.originModule
-				? chunkGraph.getModuleId(reason.originModule)
-				: null;
-			object.resolvedModuleId = reason.resolvedOriginModule
-				? chunkGraph.getModuleId(reason.resolvedOriginModule)
-				: null;
-		}
-	},
-	chunk: {
-		_: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
-			const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
 
-			/** @type {KnownStatsChunk} */
-			const statsChunk = {
-				rendered: chunk.rendered,
-				initial: chunk.canBeInitial(),
-				entry: chunk.hasRuntime(),
-				recorded: AggressiveSplittingPlugin.wasChunkRecorded(chunk),
-				reason: chunk.chunkReason,
-				size: chunkGraph.getChunkModulesSize(chunk),
-				sizes: chunkGraph.getChunkModulesSizes(chunk),
-				names: chunk.name ? [chunk.name] : [],
-				idHints: Array.from(chunk.idNameHints),
-				runtime:
-					chunk.runtime === undefined
-						? undefined
-						: typeof chunk.runtime === "string"
-						? [makePathsRelative(chunk.runtime)]
-						: Array.from(chunk.runtime.sort(), makePathsRelative),
-				files: Array.from(chunk.files),
-				auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(compareIds),
-				hash: chunk.renderedHash,
-				childrenByOrder: childIdByOrder
-			};
-			Object.assign(object, statsChunk);
-		},
-		ids: (object, chunk) => {
-			object.id = chunk.id;
-		},
-		chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
-			/** @type {Set<string|number>} */
-			const parents = new Set();
-			/** @type {Set<string|number>} */
-			const children = new Set();
-			/** @type {Set<string|number>} */
-			const siblings = new Set();
+			if (hints) {
+				// 1. Individual Chunk: Size < 250kb
+				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
+				// 3. No Async Chunks
+				// if !1, then 2, if !2 return
+				if (assetsOverSizeLimit.length > 0) {
+					warnings.push(
+						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
+					);
+				}
+				if (entrypointsOverLimit.length > 0) {
+					warnings.push(
+						new EntrypointsOverSizeLimitWarning(
+							entrypointsOverLimit,
+							entrypointSizeLimit
+						)
+					);
+				}
 
-			for (const chunkGroup of chunk.groupsIterable) {
-				for (const parentGroup of chunkGroup.parentsIterable) {
-					for (const chunk of parentGroup.chunks) {
-						parents.add(chunk.id);
+				if (warnings.length > 0) {
+					const someAsyncChunk = find(
+						compilation.chunks,
+						chunk => !chunk.canBeInitial()
+					);
+
+					if (!someAsyncChunk) {
+						warnings.push(new NoAsyncChunksWarning());
 					}
-				}
-				for (const childGroup of chunkGroup.childrenIterable) {
-					for (const chunk of childGroup.chunks) {
-						children.add(chunk.id);
+
+					if (hints === "error") {
+						compilation.errors.push(...warnings);
+					} else {
+						compilation.warnings.push(...warnings);
 					}
 				}
-				for (const sibling of chunkGroup.chunks) {
-					if (sibling !== chunk) siblings.add(sibling.id);
-				}
-			}
-			object.siblings = Array.from(siblings).sort(compareIds);
-			object.parents = Array.from(parents).sort(compareIds);
-			object.children = Array.from(children).sort(compareIds);
-		},
-		chunkModules: (object, chunk, context, options, factory) => {
-			const {
-				type,
-				compilation: { chunkGraph }
-			} = context;
-			const array = chunkGraph.getChunkModules(chunk);
-			const groupedModules = factory.create(`${type}.modules`, array, {
-				...context,
-				runtime: chunk.runtime,
-				rootModules: new Set(chunkGraph.getChunkRootModules(chunk))
-			});
-			const limited = spaceLimited(groupedModules, options.chunkModulesSpace);
-			object.modules = limited.children;
-			object.filteredModules = limited.filteredChildren;
-		},
-		chunkOrigins: (object, chunk, context, options, factory) => {
-			const {
-				type,
-				compilation: { chunkGraph }
-			} = context;
-			/** @type {Set<string>} */
-			const originsKeySet = new Set();
-			const origins = [];
-			for (const g of chunk.groupsIterable) {
-				origins.push(...g.origins);
 			}
-			const array = origins.filter(origin => {
-				const key = [
-					origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
-					formatLocation(origin.loc),
-					origin.request
-				].join();
-				if (originsKeySet.has(key)) return false;
-				originsKeySet.add(key);
-				return true;
-			});
-			object.origins = factory.create(`${type}.origins`, array, context);
-		}
-	},
-	chunkOrigin: {
-		_: (object, origin, context, { requestShortener }) => {
-			/** @type {KnownStatsChunkOrigin} */
-			const statsChunkOrigin = {
-				module: origin.module ? origin.module.identifier() : "",
-				moduleIdentifier: origin.module ? origin.module.identifier() : "",
-				moduleName: origin.module
-					? origin.module.readableIdentifier(requestShortener)
-					: "",
-				loc: formatLocation(origin.loc),
-				request: origin.request
-			};
-			Object.assign(object, statsChunkOrigin);
-		},
-		ids: (object, origin, { compilation: { chunkGraph } }) => {
-			object.moduleId = origin.module
-				? chunkGraph.getModuleId(origin.module)
-				: undefined;
-		}
-	},
-	error: EXTRACT_ERROR,
-	warning: EXTRACT_ERROR,
-	moduleTraceItem: {
-		_: (object, { origin, module }, context, { requestShortener }, factory) => {
-			const {
-				type,
-				compilation: { moduleGraph }
-			} = context;
-			object.originIdentifier = origin.identifier();
-			object.originName = origin.readableIdentifier(requestShortener);
-			object.moduleIdentifier = module.identifier();
-			object.moduleName = module.readableIdentifier(requestShortener);
-			const dependencies = Array.from(
-				moduleGraph.getIncomingConnections(module)
-			)
-				.filter(c => c.resolvedOriginModule === origin && c.dependency)
-				.map(c => c.dependency);
-			object.dependencies = factory.create(
-				`${type}.dependencies`,
-				Array.from(new Set(dependencies)),
-				context
-			);
-		},
-		ids: (object, { origin, module }, { compilation: { chunkGraph } }) => {
-			object.originId = chunkGraph.getModuleId(origin);
-			object.moduleId = chunkGraph.getModuleId(module);
-		}
-	},
-	moduleTraceDependency: {
-		_: (object, dependency) => {
-			object.loc = formatLocation(dependency.loc);
-		}
+		});
 	}
 };
 
-/** @type {Record<string, Record<string, (thing: any, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
-const FILTER = {
-	"module.reasons": {
-		"!orphanModules": (reason, { compilation: { chunkGraph } }) => {
-			if (
-				reason.originModule &&
-				chunkGraph.getNumberOfModuleChunks(reason.originModule) === 0
-			) {
-				return false;
+
+/***/ }),
+
+/***/ 95175:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} childType TODO
+	 * @param {string} runtimeFunction TODO
+	 * @param {string} runtimeHandlers TODO
+	 */
+	constructor(childType, runtimeFunction, runtimeHandlers) {
+		super(`chunk ${childType} function`);
+		this.childType = childType;
+		this.runtimeFunction = runtimeFunction;
+		this.runtimeHandlers = runtimeHandlers;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeFunction, runtimeHandlers } = this;
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${runtimeHandlers} = {};`,
+			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
+				// map is shorter than forEach
+				`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
+					"key",
+					`${runtimeHandlers}[key](chunkId);`
+				)});`
+			])}`
+		]);
+	}
+}
+
+module.exports = ChunkPrefetchFunctionRuntimeModule;
+
+
+/***/ }),
+
+/***/ 33895:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const ChunkPrefetchFunctionRuntimeModule = __webpack_require__(95175);
+const ChunkPrefetchStartupRuntimeModule = __webpack_require__(15294);
+const ChunkPrefetchTriggerRuntimeModule = __webpack_require__(98441);
+const ChunkPreloadTriggerRuntimeModule = __webpack_require__(56236);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ChunkPrefetchPreloadPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ChunkPrefetchPreloadPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ChunkPrefetchPreloadPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
+						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
+							chunkGraph,
+							"prefetchOrder"
+						);
+						if (startupChildChunks) {
+							set.add(RuntimeGlobals.prefetchChunk);
+							set.add(RuntimeGlobals.onChunksLoaded);
+							compilation.addRuntimeModule(
+								chunk,
+								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
+							);
+						}
+					}
+				);
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"ChunkPrefetchPreloadPlugin",
+					(chunk, set, { chunkGraph }) => {
+						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph, false);
+
+						if (chunkMap.prefetch) {
+							set.add(RuntimeGlobals.prefetchChunk);
+							compilation.addRuntimeModule(
+								chunk,
+								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
+							);
+						}
+						if (chunkMap.preload) {
+							set.add(RuntimeGlobals.preloadChunk);
+							compilation.addRuntimeModule(
+								chunk,
+								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
+							);
+						}
+					}
+				);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.prefetchChunk)
+					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchFunctionRuntimeModule(
+								"prefetch",
+								RuntimeGlobals.prefetchChunk,
+								RuntimeGlobals.prefetchChunkHandlers
+							)
+						);
+						set.add(RuntimeGlobals.prefetchChunkHandlers);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.preloadChunk)
+					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchFunctionRuntimeModule(
+								"preload",
+								RuntimeGlobals.preloadChunk,
+								RuntimeGlobals.preloadChunkHandlers
+							)
+						);
+						set.add(RuntimeGlobals.preloadChunkHandlers);
+					});
 			}
-		}
+		);
 	}
-};
+}
 
-/** @type {Record<string, Record<string, (thing: Object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
-const FILTER_RESULTS = {
-	"compilation.warnings": {
-		warningsFilter: util.deprecate(
-			(warning, context, { warningsFilter }) => {
-				const warningString = Object.keys(warning)
-					.map(key => `${warning[key]}`)
-					.join("\n");
-				return !warningsFilter.some(filter => filter(warning, warningString));
-			},
-			"config.stats.warningsFilter is deprecated in favor of config.ignoreWarnings",
-			"DEP_WEBPACK_STATS_WARNINGS_FILTER"
-		)
+module.exports = ChunkPrefetchPreloadPlugin;
+
+
+/***/ }),
+
+/***/ 15294:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} startupChunks chunk ids to trigger when chunks are loaded
+	 */
+	constructor(startupChunks) {
+		super("startup prefetch", RuntimeModule.STAGE_TRIGGER);
+		this.startupChunks = startupChunks;
 	}
-};
 
-/** @type {Record<string, (comparators: Function[], context: StatsFactoryContext) => void>} */
-const MODULES_SORTER = {
-	_: (comparators, { compilation: { moduleGraph } }) => {
-		comparators.push(
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {number} depth
-				 */
-				m => moduleGraph.getDepth(m),
-				compareNumbers
-			),
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {number} index
-				 */
-				m => moduleGraph.getPreOrderIndex(m),
-				compareNumbers
-			),
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {string} identifier
-				 */
-				m => m.identifier(),
-				compareIds
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { startupChunks, chunk } = this;
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString(
+			startupChunks.map(
+				({ onChunks, chunks }) =>
+					`${RuntimeGlobals.onChunksLoaded}(0, ${JSON.stringify(
+						// This need to include itself to delay execution after this chunk has been fully loaded
+						onChunks.filter(c => c === chunk).map(c => c.id)
+					)}, ${runtimeTemplate.basicFunction(
+						"",
+						chunks.size < 3
+							? Array.from(
+									chunks,
+									c =>
+										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
+							  )
+							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
+									RuntimeGlobals.prefetchChunk
+							  });`
+					)}, 5);`
 			)
 		);
 	}
-};
+}
 
-/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext) => void>>} */
-const SORTERS = {
-	"compilation.chunks": {
-		_: comparators => {
-			comparators.push(compareSelect(c => c.id, compareIds));
-		}
-	},
-	"compilation.modules": MODULES_SORTER,
-	"chunk.rootModules": MODULES_SORTER,
-	"chunk.modules": MODULES_SORTER,
-	"module.modules": MODULES_SORTER,
-	"module.reasons": {
-		_: (comparators, { compilation: { chunkGraph } }) => {
-			comparators.push(
-				compareSelect(x => x.originModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect(x => x.resolvedOriginModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect(
-					x => x.dependency,
-					concatComparators(
-						compareSelect(
-							/**
-							 * @param {Dependency} x dependency
-							 * @returns {DependencyLocation} location
-							 */
-							x => x.loc,
-							compareLocations
-						),
-						compareSelect(x => x.type, compareIds)
-					)
-				)
-			);
-		}
-	},
-	"chunk.origins": {
-		_: (comparators, { compilation: { chunkGraph } }) => {
-			comparators.push(
-				compareSelect(
-					origin =>
-						origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
-					compareIds
-				),
-				compareSelect(origin => formatLocation(origin.loc), compareIds),
-				compareSelect(origin => origin.request, compareIds)
-			);
-		}
+module.exports = ChunkPrefetchStartupRuntimeModule;
+
+
+/***/ }),
+
+/***/ 98441:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
+	 */
+	constructor(chunkMap) {
+		super(`chunk prefetch trigger`, RuntimeModule.STAGE_TRIGGER);
+		this.chunkMap = chunkMap;
 	}
-};
 
-const getItemSize = item => {
-	// Each item takes 1 line
-	// + the size of the children
-	// + 1 extra line when it has children and filteredChildren
-	return !item.children
-		? 1
-		: item.filteredChildren
-		? 2 + getTotalSize(item.children)
-		: 1 + getTotalSize(item.children);
-};
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkMap } = this;
+		const { runtimeTemplate } = this.compilation;
+		const body = [
+			"var chunks = chunkToChildrenMap[chunkId];",
+			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`
+		];
+		return Template.asString([
+			Template.asString([
+				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
+				`${
+					RuntimeGlobals.ensureChunkHandlers
+				}.prefetch = ${runtimeTemplate.expressionFunction(
+					`Promise.all(promises).then(${runtimeTemplate.basicFunction(
+						"",
+						body
+					)})`,
+					"chunkId, promises"
+				)};`
+			])
+		]);
+	}
+}
 
-const getTotalSize = children => {
-	let size = 0;
-	for (const child of children) {
-		size += getItemSize(child);
+module.exports = ChunkPrefetchTriggerRuntimeModule;
+
+
+/***/ }),
+
+/***/ 56236:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
+	 */
+	constructor(chunkMap) {
+		super(`chunk preload trigger`, RuntimeModule.STAGE_TRIGGER);
+		this.chunkMap = chunkMap;
 	}
-	return size;
-};
 
-const getTotalItems = children => {
-	let count = 0;
-	for (const child of children) {
-		if (!child.children && !child.filteredChildren) {
-			count++;
-		} else {
-			if (child.children) count += getTotalItems(child.children);
-			if (child.filteredChildren) count += child.filteredChildren;
-		}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkMap } = this;
+		const { runtimeTemplate } = this.compilation;
+		const body = [
+			"var chunks = chunkToChildrenMap[chunkId];",
+			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`
+		];
+		return Template.asString([
+			Template.asString([
+				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
+				`${
+					RuntimeGlobals.ensureChunkHandlers
+				}.preload = ${runtimeTemplate.basicFunction("chunkId", body)};`
+			])
+		]);
 	}
-	return count;
-};
+}
+
+module.exports = ChunkPreloadTriggerRuntimeModule;
+
+
+/***/ }),
+
+/***/ 30318:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
 
-const collapse = children => {
-	// After collapse each child must take exactly one line
-	const newChildren = [];
-	for (const child of children) {
-		if (child.children) {
-			let filteredChildren = child.filteredChildren || 0;
-			filteredChildren += getTotalItems(child.children);
-			newChildren.push({
-				...child,
-				children: undefined,
-				filteredChildren
-			});
-		} else {
-			newChildren.push(child);
-		}
-	}
-	return newChildren;
-};
 
-const spaceLimited = (
-	itemsAndGroups,
-	max,
-	filteredChildrenLineReserved = false
-) => {
-	if (max < 1) {
-		return {
-			children: undefined,
-			filteredChildren: getTotalItems(itemsAndGroups)
-		};
-	}
-	/** @type {any[] | undefined} */
-	let children = undefined;
-	/** @type {number | undefined} */
-	let filteredChildren = undefined;
-	// This are the groups, which take 1+ lines each
-	const groups = [];
-	// The sizes of the groups are stored in groupSizes
-	const groupSizes = [];
-	// This are the items, which take 1 line each
-	const items = [];
-	// The total of group sizes
-	let groupsSize = 0;
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
-	for (const itemOrGroup of itemsAndGroups) {
-		// is item
-		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
-			items.push(itemOrGroup);
-		} else {
-			groups.push(itemOrGroup);
-			const size = getItemSize(itemOrGroup);
-			groupSizes.push(size);
-			groupsSize += size;
-		}
+class BasicEffectRulePlugin {
+	constructor(ruleProperty, effectType) {
+		this.ruleProperty = ruleProperty;
+		this.effectType = effectType || ruleProperty;
 	}
 
-	if (groupsSize + items.length <= max) {
-		// The total size in the current state fits into the max
-		// keep all
-		children = groups.length > 0 ? groups.concat(items) : items;
-	} else if (groups.length === 0) {
-		// slice items to max
-		// inner space marks that lines for filteredChildren already reserved
-		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
-		filteredChildren = items.length - limit;
-		items.length = limit;
-		children = items;
-	} else {
-		// limit is the size when all groups are collapsed
-		const limit =
-			groups.length +
-			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
-		if (limit < max) {
-			// calculate how much we are over the size limit
-			// this allows to approach the limit faster
-			let oversize;
-			// If each group would take 1 line the total would be below the maximum
-			// collapse some groups, keep items
-			while (
-				(oversize =
-					groupsSize +
-					items.length +
-					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
-					max) > 0
-			) {
-				// Find the maximum group and process only this one
-				const maxGroupSize = Math.max(...groupSizes);
-				if (maxGroupSize < items.length) {
-					filteredChildren = items.length;
-					items.length = 0;
-					continue;
-				}
-				for (let i = 0; i < groups.length; i++) {
-					if (groupSizes[i] === maxGroupSize) {
-						const group = groups[i];
-						// run this algorithm recursively and limit the size of the children to
-						// current size - oversize / number of groups
-						// So it should always end up being smaller
-						const headerSize = group.filteredChildren ? 2 : 1;
-						const limited = spaceLimited(
-							group.children,
-							maxGroupSize -
-								// we should use ceil to always feet in max
-								Math.ceil(oversize / groups.length) -
-								// we substitute size of group head
-								headerSize,
-							headerSize === 2
-						);
-						groups[i] = {
-							...group,
-							children: limited.children,
-							filteredChildren: limited.filteredChildren
-								? (group.filteredChildren || 0) + limited.filteredChildren
-								: group.filteredChildren
-						};
-						const newSize = getItemSize(groups[i]);
-						groupsSize -= maxGroupSize - newSize;
-						groupSizes[i] = newSize;
-						break;
-					}
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"BasicEffectRulePlugin",
+			(path, rule, unhandledProperties, result, references) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+
+					const value = rule[this.ruleProperty];
+
+					result.effects.push({
+						type: this.effectType,
+						value
+					});
 				}
 			}
-			children = groups.concat(items);
-		} else if (limit === max) {
-			// If we have only enough space to show one line per group and one line for the filtered items
-			// collapse all groups and items
-			children = collapse(groups);
-			filteredChildren = items.length;
-		} else {
-			// If we have no space
-			// collapse complete group
-			filteredChildren = getTotalItems(itemsAndGroups);
-		}
+		);
 	}
+}
 
-	return {
-		children,
-		filteredChildren
-	};
-};
+module.exports = BasicEffectRulePlugin;
 
-const assetGroup = (children, assets) => {
-	let size = 0;
-	for (const asset of children) {
-		size += asset.size;
-	}
-	return {
-		size
-	};
-};
 
-const moduleGroup = (children, modules) => {
-	let size = 0;
-	const sizes = {};
-	for (const module of children) {
-		size += module.size;
-		for (const key of Object.keys(module.sizes)) {
-			sizes[key] = (sizes[key] || 0) + module.sizes[key];
-		}
-	}
-	return {
-		size,
-		sizes
-	};
-};
+/***/ }),
 
-const reasonGroup = (children, reasons) => {
-	let active = false;
-	for (const reason of children) {
-		active = active || reason.active;
-	}
-	return {
-		active
-	};
-};
+/***/ 94215:
+/***/ (function(module) {
 
-const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
-const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
-const ASSETS_GROUPERS = {
-	_: (groupConfigs, context, options) => {
-		const groupByFlag = (name, exclude) => {
-			groupConfigs.push({
-				getKeys: asset => {
-					return asset[name] ? ["1"] : undefined;
-				},
-				getOptions: () => {
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, assets) => {
-					return exclude
-						? {
-								type: "assets by status",
-								[name]: !!key,
-								filteredChildren: assets.length,
-								...assetGroup(children, assets)
-						  }
-						: {
-								type: "assets by status",
-								[name]: !!key,
-								children,
-								...assetGroup(children, assets)
-						  };
-				}
-			});
-		};
-		const {
-			groupAssetsByEmitStatus,
-			groupAssetsByPath,
-			groupAssetsByExtension
-		} = options;
-		if (groupAssetsByEmitStatus) {
-			groupByFlag("emitted");
-			groupByFlag("comparedForEmit");
-			groupByFlag("isOverSizeLimit");
-		}
-		if (groupAssetsByEmitStatus || !options.cachedAssets) {
-			groupByFlag("cached", !options.cachedAssets);
-		}
-		if (groupAssetsByPath || groupAssetsByExtension) {
-			groupConfigs.push({
-				getKeys: asset => {
-					const extensionMatch =
-						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
-					const extension = extensionMatch ? extensionMatch[1] : "";
-					const pathMatch =
-						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
-					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
-					const keys = [];
-					if (groupAssetsByPath) {
-						keys.push(".");
-						if (extension)
-							keys.push(
-								path.length
-									? `${path.join("/")}/*${extension}`
-									: `*${extension}`
-							);
-						while (path.length > 0) {
-							keys.push(path.join("/") + "/");
-							path.pop();
-						}
-					} else {
-						if (extension) keys.push(`*${extension}`);
-					}
-					return keys;
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: groupAssetsByPath ? "assets by path" : "assets by extension",
-						name: key,
-						children,
-						...assetGroup(children, assets)
-					};
-				}
-			});
-		}
-	},
-	groupAssetsByInfo: (groupConfigs, context, options) => {
-		const groupByAssetInfoFlag = name => {
-			groupConfigs.push({
-				getKeys: asset => {
-					return asset.info && asset.info[name] ? ["1"] : undefined;
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: "assets by info",
-						info: {
-							[name]: !!key
-						},
-						children,
-						...assetGroup(children, assets)
-					};
-				}
-			});
-		};
-		groupByAssetInfoFlag("immutable");
-		groupByAssetInfoFlag("development");
-		groupByAssetInfoFlag("hotModuleReplacement");
-	},
-	groupAssetsByChunk: (groupConfigs, context, options) => {
-		const groupByNames = name => {
-			groupConfigs.push({
-				getKeys: asset => {
-					return asset[name];
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: "assets by chunk",
-						[name]: [key],
-						children,
-						...assetGroup(children, assets)
-					};
-				}
-			});
-		};
-		groupByNames("chunkNames");
-		groupByNames("auxiliaryChunkNames");
-		groupByNames("chunkIdHints");
-		groupByNames("auxiliaryChunkIdHints");
-	},
-	excludeAssets: (groupConfigs, context, { excludeAssets }) => {
-		groupConfigs.push({
-			getKeys: asset => {
-				const ident = asset.name;
-				const excluded = excludeAssets.some(fn => fn(ident, asset));
-				if (excluded) return ["excluded"];
-			},
-			getOptions: () => ({
-				groupChildren: false,
-				force: true
-			}),
-			createGroup: (key, children, assets) => ({
-				type: "hidden assets",
-				filteredChildren: assets.length,
-				...assetGroup(children, assets)
-			})
-		});
-	}
-};
 
-/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
-const MODULES_GROUPERS = type => ({
-	_: (groupConfigs, context, options) => {
-		const groupByFlag = (name, type, exclude) => {
-			groupConfigs.push({
-				getKeys: module => {
-					return module[name] ? ["1"] : undefined;
-				},
-				getOptions: () => {
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, modules) => {
-					return {
-						type,
-						[name]: !!key,
-						...(exclude ? { filteredChildren: modules.length } : { children }),
-						...moduleGroup(children, modules)
-					};
-				}
-			});
-		};
-		const {
-			groupModulesByCacheStatus,
-			groupModulesByLayer,
-			groupModulesByAttributes,
-			groupModulesByType,
-			groupModulesByPath,
-			groupModulesByExtension
-		} = options;
-		if (groupModulesByAttributes) {
-			groupByFlag("errors", "modules with errors");
-			groupByFlag("warnings", "modules with warnings");
-			groupByFlag("assets", "modules with assets");
-			groupByFlag("optional", "optional modules");
-		}
-		if (groupModulesByCacheStatus) {
-			groupByFlag("cacheable", "cacheable modules");
-			groupByFlag("built", "built modules");
-			groupByFlag("codeGenerated", "code generated modules");
-		}
-		if (groupModulesByCacheStatus || !options.cachedModules) {
-			groupByFlag("cached", "cached modules", !options.cachedModules);
-		}
-		if (groupModulesByAttributes || !options.orphanModules) {
-			groupByFlag("orphan", "orphan modules", !options.orphanModules);
-		}
-		if (groupModulesByAttributes || !options.dependentModules) {
-			groupByFlag("dependent", "dependent modules", !options.dependentModules);
-		}
-		if (groupModulesByType || !options.runtimeModules) {
-			groupConfigs.push({
-				getKeys: module => {
-					if (!module.moduleType) return;
-					if (groupModulesByType) {
-						return [module.moduleType.split("/", 1)[0]];
-					} else if (module.moduleType === "runtime") {
-						return ["runtime"];
-					}
-				},
-				getOptions: key => {
-					const exclude = key === "runtime" && !options.runtimeModules;
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, modules) => {
-					const exclude = key === "runtime" && !options.runtimeModules;
-					return {
-						type: `${key} modules`,
-						moduleType: key,
-						...(exclude ? { filteredChildren: modules.length } : { children }),
-						...moduleGroup(children, modules)
-					};
-				}
-			});
-		}
-		if (groupModulesByLayer) {
-			groupConfigs.push({
-				getKeys: module => {
-					return [module.layer];
-				},
-				createGroup: (key, children, modules) => {
-					return {
-						type: "modules by layer",
-						layer: key,
-						children,
-						...moduleGroup(children, modules)
-					};
-				}
-			});
-		}
-		if (groupModulesByPath || groupModulesByExtension) {
-			groupConfigs.push({
-				getKeys: module => {
-					if (!module.name) return;
-					const resource = parseResource(module.name.split("!").pop()).path;
-					const dataUrl = /^data:[^,;]+/.exec(resource);
-					if (dataUrl) return [dataUrl[0]];
-					const extensionMatch =
-						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
-					const extension = extensionMatch ? extensionMatch[1] : "";
-					const pathMatch =
-						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
-					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
-					const keys = [];
-					if (groupModulesByPath) {
-						if (extension)
-							keys.push(
-								path.length
-									? `${path.join("/")}/*${extension}`
-									: `*${extension}`
-							);
-						while (path.length > 0) {
-							keys.push(path.join("/") + "/");
-							path.pop();
-						}
-					} else {
-						if (extension) keys.push(`*${extension}`);
-					}
-					return keys;
-				},
-				createGroup: (key, children, modules) => {
-					const isDataUrl = key.startsWith("data:");
-					return {
-						type: isDataUrl
-							? "modules by mime type"
-							: groupModulesByPath
-							? "modules by path"
-							: "modules by extension",
-						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
-						children,
-						...moduleGroup(children, modules)
-					};
-				}
-			});
-		}
-	},
-	excludeModules: (groupConfigs, context, { excludeModules }) => {
-		groupConfigs.push({
-			getKeys: module => {
-				const name = module.name;
-				if (name) {
-					const excluded = excludeModules.some(fn => fn(name, module, type));
-					if (excluded) return ["1"];
-				}
-			},
-			getOptions: () => ({
-				groupChildren: false,
-				force: true
-			}),
-			createGroup: (key, children, modules) => ({
-				type: "hidden modules",
-				filteredChildren: children.length,
-				...moduleGroup(children, modules)
-			})
-		});
+
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+
+class BasicMatcherRulePlugin {
+	constructor(ruleProperty, dataProperty, invert) {
+		this.ruleProperty = ruleProperty;
+		this.dataProperty = dataProperty || ruleProperty;
+		this.invert = invert || false;
 	}
-});
 
-/** @type {Record<string, Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
-const RESULT_GROUPERS = {
-	"compilation.assets": ASSETS_GROUPERS,
-	"asset.related": ASSETS_GROUPERS,
-	"compilation.modules": MODULES_GROUPERS("module"),
-	"chunk.modules": MODULES_GROUPERS("chunk"),
-	"chunk.rootModules": MODULES_GROUPERS("root-of-chunk"),
-	"module.modules": MODULES_GROUPERS("nested"),
-	"module.reasons": {
-		groupReasonsByOrigin: groupConfigs => {
-			groupConfigs.push({
-				getKeys: reason => {
-					return [reason.module];
-				},
-				createGroup: (key, children, reasons) => {
-					return {
-						type: "from origin",
-						module: key,
-						children,
-						...reasonGroup(children, reasons)
-					};
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"BasicMatcherRulePlugin",
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+					const value = rule[this.ruleProperty];
+					const condition = ruleSetCompiler.compileCondition(
+						`${path}.${this.ruleProperty}`,
+						value
+					);
+					const fn = condition.fn;
+					result.conditions.push({
+						property: this.dataProperty,
+						matchWhenEmpty: this.invert
+							? !condition.matchWhenEmpty
+							: condition.matchWhenEmpty,
+						fn: this.invert ? v => !fn(v) : fn
+					});
 				}
-			});
-		}
+			}
+		);
 	}
-};
+}
 
-// remove a prefixed "!" that can be specified to reverse sort order
-const normalizeFieldKey = field => {
-	if (field[0] === "!") {
-		return field.substr(1);
+module.exports = BasicMatcherRulePlugin;
+
+
+/***/ }),
+
+/***/ 72021:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+
+class ObjectMatcherRulePlugin {
+	constructor(ruleProperty, dataProperty) {
+		this.ruleProperty = ruleProperty;
+		this.dataProperty = dataProperty || ruleProperty;
 	}
-	return field;
-};
 
-// if a field is prefixed by a "!" reverse sort order
-const sortOrderRegular = field => {
-	if (field[0] === "!") {
-		return false;
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		const { ruleProperty, dataProperty } = this;
+		ruleSetCompiler.hooks.rule.tap(
+			"ObjectMatcherRulePlugin",
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(ruleProperty)) {
+					unhandledProperties.delete(ruleProperty);
+					const value = rule[ruleProperty];
+					for (const property of Object.keys(value)) {
+						const nestedDataProperties = property.split(".");
+						const condition = ruleSetCompiler.compileCondition(
+							`${path}.${ruleProperty}.${property}`,
+							value[property]
+						);
+						result.conditions.push({
+							property: [dataProperty, ...nestedDataProperties],
+							matchWhenEmpty: condition.matchWhenEmpty,
+							fn: condition.fn
+						});
+					}
+				}
+			}
+		);
 	}
-	return true;
-};
+}
+
+module.exports = ObjectMatcherRulePlugin;
+
+
+/***/ }),
+
+/***/ 83349:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { SyncHook } = __webpack_require__(41242);
 
 /**
- * @param {string} field field name
- * @returns {function(Object, Object): number} comparators
+ * @typedef {Object} RuleCondition
+ * @property {string | string[]} property
+ * @property {boolean} matchWhenEmpty
+ * @property {function(string): boolean} fn
  */
-const sortByField = field => {
-	if (!field) {
+
+/**
+ * @typedef {Object} Condition
+ * @property {boolean} matchWhenEmpty
+ * @property {function(string): boolean} fn
+ */
+
+/**
+ * @typedef {Object} CompiledRule
+ * @property {RuleCondition[]} conditions
+ * @property {(Effect|function(object): Effect[])[]} effects
+ * @property {CompiledRule[]=} rules
+ * @property {CompiledRule[]=} oneOf
+ */
+
+/**
+ * @typedef {Object} Effect
+ * @property {string} type
+ * @property {any} value
+ */
+
+/**
+ * @typedef {Object} RuleSet
+ * @property {Map<string, any>} references map of references in the rule set (may grow over time)
+ * @property {function(object): Effect[]} exec execute the rule set
+ */
+
+class RuleSetCompiler {
+	constructor(plugins) {
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[string, object, Set<string>, CompiledRule, Map<string, any>]>} */
+			rule: new SyncHook([
+				"path",
+				"rule",
+				"unhandledProperties",
+				"compiledRule",
+				"references"
+			])
+		});
+		if (plugins) {
+			for (const plugin of plugins) {
+				plugin.apply(this);
+			}
+		}
+	}
+
+	/**
+	 * @param {object[]} ruleSet raw user provided rules
+	 * @returns {RuleSet} compiled RuleSet
+	 */
+	compile(ruleSet) {
+		const refs = new Map();
+		const rules = this.compileRules("ruleSet", ruleSet, refs);
+
 		/**
-		 * @param {any} a first
-		 * @param {any} b second
-		 * @returns {-1|0|1} zero
+		 * @param {object} data data passed in
+		 * @param {CompiledRule} rule the compiled rule
+		 * @param {Effect[]} effects an array where effects are pushed to
+		 * @returns {boolean} true, if the rule has matched
 		 */
-		const noSort = (a, b) => 0;
-		return noSort;
+		const execRule = (data, rule, effects) => {
+			for (const condition of rule.conditions) {
+				const p = condition.property;
+				if (Array.isArray(p)) {
+					let current = data;
+					for (const subProperty of p) {
+						if (
+							current &&
+							typeof current === "object" &&
+							Object.prototype.hasOwnProperty.call(current, subProperty)
+						) {
+							current = current[subProperty];
+						} else {
+							current = undefined;
+							break;
+						}
+					}
+					if (current !== undefined) {
+						if (!condition.fn(current)) return false;
+						continue;
+					}
+				} else if (p in data) {
+					const value = data[p];
+					if (value !== undefined) {
+						if (!condition.fn(value)) return false;
+						continue;
+					}
+				}
+				if (!condition.matchWhenEmpty) {
+					return false;
+				}
+			}
+			for (const effect of rule.effects) {
+				if (typeof effect === "function") {
+					const returnedEffects = effect(data);
+					for (const effect of returnedEffects) {
+						effects.push(effect);
+					}
+				} else {
+					effects.push(effect);
+				}
+			}
+			if (rule.rules) {
+				for (const childRule of rule.rules) {
+					execRule(data, childRule, effects);
+				}
+			}
+			if (rule.oneOf) {
+				for (const childRule of rule.oneOf) {
+					if (execRule(data, childRule, effects)) {
+						break;
+					}
+				}
+			}
+			return true;
+		};
+
+		return {
+			references: refs,
+			exec: data => {
+				/** @type {Effect[]} */
+				const effects = [];
+				for (const rule of rules) {
+					execRule(data, rule, effects);
+				}
+				return effects;
+			}
+		};
 	}
 
-	const fieldKey = normalizeFieldKey(field);
+	/**
+	 * @param {string} path current path
+	 * @param {object[]} rules the raw rules provided by user
+	 * @param {Map<string, any>} refs references
+	 * @returns {CompiledRule[]} rules
+	 */
+	compileRules(path, rules, refs) {
+		return rules.map((rule, i) =>
+			this.compileRule(`${path}[${i}]`, rule, refs)
+		);
+	}
 
-	let sortFn = compareSelect(m => m[fieldKey], compareIds);
+	/**
+	 * @param {string} path current path
+	 * @param {object} rule the raw rule provided by user
+	 * @param {Map<string, any>} refs references
+	 * @returns {CompiledRule} normalized and compiled rule for processing
+	 */
+	compileRule(path, rule, refs) {
+		const unhandledProperties = new Set(
+			Object.keys(rule).filter(key => rule[key] !== undefined)
+		);
 
-	// if a field is prefixed with a "!" the sort is reversed!
-	const sortIsRegular = sortOrderRegular(field);
+		/** @type {CompiledRule} */
+		const compiledRule = {
+			conditions: [],
+			effects: [],
+			rules: undefined,
+			oneOf: undefined
+		};
 
-	if (!sortIsRegular) {
-		const oldSortFn = sortFn;
-		sortFn = (a, b) => oldSortFn(b, a);
-	}
+		this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs);
 
-	return sortFn;
-};
+		if (unhandledProperties.has("rules")) {
+			unhandledProperties.delete("rules");
+			const rules = rule.rules;
+			if (!Array.isArray(rules))
+				throw this.error(path, rules, "Rule.rules must be an array of rules");
+			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
+		}
 
-const ASSET_SORTERS = {
-	/** @type {(comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void} */
-	assetsSort: (comparators, context, { assetsSort }) => {
-		comparators.push(sortByField(assetsSort));
-	},
-	_: comparators => {
-		comparators.push(compareSelect(a => a.name, compareIds));
+		if (unhandledProperties.has("oneOf")) {
+			unhandledProperties.delete("oneOf");
+			const oneOf = rule.oneOf;
+			if (!Array.isArray(oneOf))
+				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
+			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
+		}
+
+		if (unhandledProperties.size > 0) {
+			throw this.error(
+				path,
+				rule,
+				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
+			);
+		}
+
+		return compiledRule;
 	}
-};
 
-/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
-const RESULT_SORTERS = {
-	"compilation.chunks": {
-		chunksSort: (comparators, context, { chunksSort }) => {
-			comparators.push(sortByField(chunksSort));
+	/**
+	 * @param {string} path current path
+	 * @param {any} condition user provided condition value
+	 * @returns {Condition} compiled condition
+	 */
+	compileCondition(path, condition) {
+		if (condition === "") {
+			return {
+				matchWhenEmpty: true,
+				fn: str => str === ""
+			};
 		}
-	},
-	"compilation.modules": {
-		modulesSort: (comparators, context, { modulesSort }) => {
-			comparators.push(sortByField(modulesSort));
+		if (!condition) {
+			throw this.error(
+				path,
+				condition,
+				"Expected condition but got falsy value"
+			);
 		}
-	},
-	"chunk.modules": {
-		chunkModulesSort: (comparators, context, { chunkModulesSort }) => {
-			comparators.push(sortByField(chunkModulesSort));
+		if (typeof condition === "string") {
+			return {
+				matchWhenEmpty: condition.length === 0,
+				fn: str => typeof str === "string" && str.startsWith(condition)
+			};
 		}
-	},
-	"module.modules": {
-		nestedModulesSort: (comparators, context, { nestedModulesSort }) => {
-			comparators.push(sortByField(nestedModulesSort));
+		if (typeof condition === "function") {
+			try {
+				return {
+					matchWhenEmpty: condition(""),
+					fn: condition
+				};
+			} catch (err) {
+				throw this.error(
+					path,
+					condition,
+					"Evaluation of condition function threw error"
+				);
+			}
+		}
+		if (condition instanceof RegExp) {
+			return {
+				matchWhenEmpty: condition.test(""),
+				fn: v => typeof v === "string" && condition.test(v)
+			};
+		}
+		if (Array.isArray(condition)) {
+			const items = condition.map((c, i) =>
+				this.compileCondition(`${path}[${i}]`, c)
+			);
+			return this.combineConditionsOr(items);
 		}
-	},
-	"compilation.assets": ASSET_SORTERS,
-	"asset.related": ASSET_SORTERS
-};
 
-/**
- * @param {Record<string, Record<string, Function>>} config the config see above
- * @param {NormalizedStatsOptions} options stats options
- * @param {function(string, Function): void} fn handler function called for every active line in config
- * @returns {void}
- */
-const iterateConfig = (config, options, fn) => {
-	for (const hookFor of Object.keys(config)) {
-		const subConfig = config[hookFor];
-		for (const option of Object.keys(subConfig)) {
-			if (option !== "_") {
-				if (option.startsWith("!")) {
-					if (options[option.slice(1)]) continue;
-				} else {
-					const value = options[option];
-					if (
-						value === false ||
-						value === undefined ||
-						(Array.isArray(value) && value.length === 0)
-					)
-						continue;
-				}
+		if (typeof condition !== "object") {
+			throw this.error(
+				path,
+				condition,
+				`Unexpected ${typeof condition} when condition was expected`
+			);
+		}
+
+		const conditions = [];
+		for (const key of Object.keys(condition)) {
+			const value = condition[key];
+			switch (key) {
+				case "or":
+					if (value) {
+						if (!Array.isArray(value)) {
+							throw this.error(
+								`${path}.or`,
+								condition.and,
+								"Expected array of conditions"
+							);
+						}
+						conditions.push(this.compileCondition(`${path}.or`, value));
+					}
+					break;
+				case "and":
+					if (value) {
+						if (!Array.isArray(value)) {
+							throw this.error(
+								`${path}.and`,
+								condition.and,
+								"Expected array of conditions"
+							);
+						}
+						let i = 0;
+						for (const item of value) {
+							conditions.push(this.compileCondition(`${path}.and[${i}]`, item));
+							i++;
+						}
+					}
+					break;
+				case "not":
+					if (value) {
+						const matcher = this.compileCondition(`${path}.not`, value);
+						const fn = matcher.fn;
+						conditions.push({
+							matchWhenEmpty: !matcher.matchWhenEmpty,
+							fn: v => !fn(v)
+						});
+					}
+					break;
+				default:
+					throw this.error(
+						`${path}.${key}`,
+						condition[key],
+						`Unexpected property ${key} in condition`
+					);
 			}
-			fn(hookFor, subConfig[option]);
+		}
+		if (conditions.length === 0) {
+			throw this.error(
+				path,
+				condition,
+				"Expected condition, but got empty thing"
+			);
+		}
+		return this.combineConditionsAnd(conditions);
+	}
+
+	/**
+	 * @param {Condition[]} conditions some conditions
+	 * @returns {Condition} merged condition
+	 */
+	combineConditionsOr(conditions) {
+		if (conditions.length === 0) {
+			return {
+				matchWhenEmpty: false,
+				fn: () => false
+			};
+		} else if (conditions.length === 1) {
+			return conditions[0];
+		} else {
+			return {
+				matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
+				fn: v => conditions.some(c => c.fn(v))
+			};
 		}
 	}
-};
-
-/** @type {Record<string, string>} */
-const ITEM_NAMES = {
-	"compilation.children[]": "compilation",
-	"compilation.modules[]": "module",
-	"compilation.entrypoints[]": "chunkGroup",
-	"compilation.namedChunkGroups[]": "chunkGroup",
-	"compilation.errors[]": "error",
-	"compilation.warnings[]": "warning",
-	"chunk.modules[]": "module",
-	"chunk.rootModules[]": "module",
-	"chunk.origins[]": "chunkOrigin",
-	"compilation.chunks[]": "chunk",
-	"compilation.assets[]": "asset",
-	"asset.related[]": "asset",
-	"module.issuerPath[]": "moduleIssuer",
-	"module.reasons[]": "moduleReason",
-	"module.modules[]": "module",
-	"module.children[]": "module",
-	"moduleTrace[]": "moduleTraceItem",
-	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
-};
 
-/**
- * @param {Object[]} items items to be merged
- * @returns {Object} an object
- */
-const mergeToObject = items => {
-	const obj = Object.create(null);
-	for (const item of items) {
-		obj[item.name] = item;
+	/**
+	 * @param {Condition[]} conditions some conditions
+	 * @returns {Condition} merged condition
+	 */
+	combineConditionsAnd(conditions) {
+		if (conditions.length === 0) {
+			return {
+				matchWhenEmpty: false,
+				fn: () => false
+			};
+		} else if (conditions.length === 1) {
+			return conditions[0];
+		} else {
+			return {
+				matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
+				fn: v => conditions.every(c => c.fn(v))
+			};
+		}
 	}
-	return obj;
-};
-
-/** @type {Record<string, (items: Object[]) => any>} */
-const MERGER = {
-	"compilation.entrypoints": mergeToObject,
-	"compilation.namedChunkGroups": mergeToObject
-};
 
-class DefaultStatsFactoryPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string} path current path
+	 * @param {any} value value at the error location
+	 * @param {string} message message explaining the problem
+	 * @returns {Error} an error object
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
-			compilation.hooks.statsFactory.tap(
-				"DefaultStatsFactoryPlugin",
-				(stats, options, context) => {
-					iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
-						stats.hooks.extract
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (obj, data, ctx) =>
-								fn(obj, data, ctx, options, stats)
-							);
-					});
-					iterateConfig(FILTER, options, (hookFor, fn) => {
-						stats.hooks.filter
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
-								fn(item, ctx, options, idx, i)
-							);
-					});
-					iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
-						stats.hooks.filterResults
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
-								fn(item, ctx, options, idx, i)
-							);
-					});
-					iterateConfig(SORTERS, options, (hookFor, fn) => {
-						stats.hooks.sort
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
-								fn(comparators, ctx, options)
-							);
-					});
-					iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
-						stats.hooks.sortResults
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
-								fn(comparators, ctx, options)
-							);
-					});
-					iterateConfig(RESULT_GROUPERS, options, (hookFor, fn) => {
-						stats.hooks.groupResults
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (groupConfigs, ctx) =>
-								fn(groupConfigs, ctx, options)
-							);
-					});
-					for (const key of Object.keys(ITEM_NAMES)) {
-						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap("DefaultStatsFactoryPlugin", () => itemName);
-					}
-					for (const key of Object.keys(MERGER)) {
-						const merger = MERGER[key];
-						stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
-					}
-					if (options.children) {
-						if (Array.isArray(options.children)) {
-							stats.hooks.getItemFactory
-								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", (comp, { _index: idx }) => {
-									if (idx < options.children.length) {
-										return compilation.createStatsFactory(
-											compilation.createStatsOptions(
-												options.children[idx],
-												context
-											)
-										);
-									}
-								});
-						} else if (options.children !== true) {
-							const childFactory = compilation.createStatsFactory(
-								compilation.createStatsOptions(options.children, context)
-							);
-							stats.hooks.getItemFactory
-								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", () => {
-									return childFactory;
-								});
-						}
-					}
-				}
-			);
-		});
+	error(path, value, message) {
+		return new Error(
+			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
+		);
 	}
 }
-module.exports = DefaultStatsFactoryPlugin;
+
+module.exports = RuleSetCompiler;
 
 
 /***/ }),
 
-/***/ 55442:
+/***/ 84977:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -118862,3168 +115395,1959 @@ module.exports = DefaultStatsFactoryPlugin;
 
 
 
-const RequestShortener = __webpack_require__(73406);
+const util = __webpack_require__(73837);
 
-/** @typedef {import("../../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").Effect} Effect */
 
-const applyDefaults = (options, defaults) => {
-	for (const key of Object.keys(defaults)) {
-		if (typeof options[key] === "undefined") {
-			options[key] = defaults[key];
-		}
-	}
-};
+class UseEffectRulePlugin {
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"UseEffectRulePlugin",
+			(path, rule, unhandledProperties, result, references) => {
+				const conflictWith = (property, correctProperty) => {
+					if (unhandledProperties.has(property)) {
+						throw ruleSetCompiler.error(
+							`${path}.${property}`,
+							rule[property],
+							`A Rule must not have a '${property}' property when it has a '${correctProperty}' property`
+						);
+					}
+				};
 
-const NAMED_PRESETS = {
-	verbose: {
-		hash: true,
-		builtAt: true,
-		relatedAssets: true,
-		entrypoints: true,
-		chunkGroups: true,
-		ids: true,
-		modules: false,
-		chunks: true,
-		chunkRelations: true,
-		chunkModules: true,
-		dependentModules: true,
-		chunkOrigins: true,
-		depth: true,
-		env: true,
-		reasons: true,
-		usedExports: true,
-		providedExports: true,
-		optimizationBailout: true,
-		errorDetails: true,
-		errorStack: true,
-		publicPath: true,
-		logging: "verbose",
-		orphanModules: true,
-		runtimeModules: true,
-		exclude: false,
-		modulesSpace: Infinity,
-		chunkModulesSpace: Infinity,
-		assetsSpace: Infinity,
-		reasonsSpace: Infinity,
-		children: true
-	},
-	detailed: {
-		hash: true,
-		builtAt: true,
-		relatedAssets: true,
-		entrypoints: true,
-		chunkGroups: true,
-		ids: true,
-		chunks: true,
-		chunkRelations: true,
-		chunkModules: false,
-		chunkOrigins: true,
-		depth: true,
-		usedExports: true,
-		providedExports: true,
-		optimizationBailout: true,
-		errorDetails: true,
-		publicPath: true,
-		logging: true,
-		runtimeModules: true,
-		exclude: false,
-		modulesSpace: 1000,
-		assetsSpace: 1000,
-		reasonsSpace: 1000
-	},
-	minimal: {
-		all: false,
-		version: true,
-		timings: true,
-		modules: true,
-		modulesSpace: 0,
-		assets: true,
-		assetsSpace: 0,
-		errors: true,
-		errorsCount: true,
-		warnings: true,
-		warningsCount: true,
-		logging: "warn"
-	},
-	"errors-only": {
-		all: false,
-		errors: true,
-		errorsCount: true,
-		moduleTrace: true,
-		logging: "error"
-	},
-	"errors-warnings": {
-		all: false,
-		errors: true,
-		errorsCount: true,
-		warnings: true,
-		warningsCount: true,
-		logging: "warn"
-	},
-	summary: {
-		all: false,
-		version: true,
-		errorsCount: true,
-		warningsCount: true
-	},
-	none: {
-		all: false
-	}
-};
+				if (unhandledProperties.has("use")) {
+					unhandledProperties.delete("use");
+					unhandledProperties.delete("enforce");
 
-const NORMAL_ON = ({ all }) => all !== false;
-const NORMAL_OFF = ({ all }) => all === true;
-const ON_FOR_TO_STRING = ({ all }, { forToString }) =>
-	forToString ? all !== false : all === true;
-const OFF_FOR_TO_STRING = ({ all }, { forToString }) =>
-	forToString ? all === true : all !== false;
-const AUTO_FOR_TO_STRING = ({ all }, { forToString }) => {
-	if (all === false) return false;
-	if (all === true) return true;
-	if (forToString) return "auto";
-	return true;
-};
+					conflictWith("loader", "use");
+					conflictWith("options", "use");
 
-/** @type {Record<string, (options: StatsOptions, context: CreateStatsOptionsContext, compilation: Compilation) => any>} */
-const DEFAULTS = {
-	context: (options, context, compilation) => compilation.compiler.context,
-	requestShortener: (options, context, compilation) =>
-		compilation.compiler.context === options.context
-			? compilation.requestShortener
-			: new RequestShortener(options.context, compilation.compiler.root),
-	performance: NORMAL_ON,
-	hash: OFF_FOR_TO_STRING,
-	env: NORMAL_OFF,
-	version: NORMAL_ON,
-	timings: NORMAL_ON,
-	builtAt: OFF_FOR_TO_STRING,
-	assets: NORMAL_ON,
-	entrypoints: AUTO_FOR_TO_STRING,
-	chunkGroups: OFF_FOR_TO_STRING,
-	chunkGroupAuxiliary: OFF_FOR_TO_STRING,
-	chunkGroupChildren: OFF_FOR_TO_STRING,
-	chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
-	chunks: OFF_FOR_TO_STRING,
-	chunkRelations: OFF_FOR_TO_STRING,
-	chunkModules: ({ all, modules }) => {
-		if (all === false) return false;
-		if (all === true) return true;
-		if (modules) return false;
-		return true;
-	},
-	dependentModules: OFF_FOR_TO_STRING,
-	chunkOrigins: OFF_FOR_TO_STRING,
-	ids: OFF_FOR_TO_STRING,
-	modules: ({ all, chunks, chunkModules }, { forToString }) => {
-		if (all === false) return false;
-		if (all === true) return true;
-		if (forToString && chunks && chunkModules) return false;
-		return true;
-	},
-	nestedModules: OFF_FOR_TO_STRING,
-	groupModulesByType: ON_FOR_TO_STRING,
-	groupModulesByCacheStatus: ON_FOR_TO_STRING,
-	groupModulesByLayer: ON_FOR_TO_STRING,
-	groupModulesByAttributes: ON_FOR_TO_STRING,
-	groupModulesByPath: ON_FOR_TO_STRING,
-	groupModulesByExtension: ON_FOR_TO_STRING,
-	modulesSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-	chunkModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
-	nestedModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
-	relatedAssets: OFF_FOR_TO_STRING,
-	groupAssetsByEmitStatus: ON_FOR_TO_STRING,
-	groupAssetsByInfo: ON_FOR_TO_STRING,
-	groupAssetsByPath: ON_FOR_TO_STRING,
-	groupAssetsByExtension: ON_FOR_TO_STRING,
-	groupAssetsByChunk: ON_FOR_TO_STRING,
-	assetsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-	orphanModules: OFF_FOR_TO_STRING,
-	runtimeModules: ({ all, runtime }, { forToString }) =>
-		runtime !== undefined
-			? runtime
-			: forToString
-			? all === true
-			: all !== false,
-	cachedModules: ({ all, cached }, { forToString }) =>
-		cached !== undefined ? cached : forToString ? all === true : all !== false,
-	moduleAssets: OFF_FOR_TO_STRING,
-	depth: OFF_FOR_TO_STRING,
-	cachedAssets: OFF_FOR_TO_STRING,
-	reasons: OFF_FOR_TO_STRING,
-	reasonsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-	groupReasonsByOrigin: ON_FOR_TO_STRING,
-	usedExports: OFF_FOR_TO_STRING,
-	providedExports: OFF_FOR_TO_STRING,
-	optimizationBailout: OFF_FOR_TO_STRING,
-	children: OFF_FOR_TO_STRING,
-	source: NORMAL_OFF,
-	moduleTrace: NORMAL_ON,
-	errors: NORMAL_ON,
-	errorsCount: NORMAL_ON,
-	errorDetails: AUTO_FOR_TO_STRING,
-	errorStack: OFF_FOR_TO_STRING,
-	warnings: NORMAL_ON,
-	warningsCount: NORMAL_ON,
-	publicPath: OFF_FOR_TO_STRING,
-	logging: ({ all }, { forToString }) =>
-		forToString && all !== false ? "info" : false,
-	loggingDebug: () => [],
-	loggingTrace: OFF_FOR_TO_STRING,
-	excludeModules: () => [],
-	excludeAssets: () => [],
-	modulesSort: () => "depth",
-	chunkModulesSort: () => "name",
-	nestedModulesSort: () => false,
-	chunksSort: () => false,
-	assetsSort: () => "!size",
-	outputPath: OFF_FOR_TO_STRING,
-	colors: () => false
-};
+					const use = rule.use;
+					const enforce = rule.enforce;
 
-const normalizeFilter = item => {
-	if (typeof item === "string") {
-		const regExp = new RegExp(
-			`[\\\\/]${item.replace(
-				// eslint-disable-next-line no-useless-escape
-				/[-[\]{}()*+?.\\^$|]/g,
-				"\\$&"
-			)}([\\\\/]|$|!|\\?)`
-		);
-		return ident => regExp.test(ident);
-	}
-	if (item && typeof item === "object" && typeof item.test === "function") {
-		return ident => item.test(ident);
-	}
-	if (typeof item === "function") {
-		return item;
-	}
-	if (typeof item === "boolean") {
-		return () => item;
-	}
-};
+					const type = enforce ? `use-${enforce}` : "use";
+
+					/**
+					 *
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {object} item user provided use value
+					 * @returns {Effect|function(any): Effect[]} effect
+					 */
+					const useToEffect = (path, defaultIdent, item) => {
+						if (typeof item === "function") {
+							return data => useToEffectsWithoutIdent(path, item(data));
+						} else {
+							return useToEffectRaw(path, defaultIdent, item);
+						}
+					};
+
+					/**
+					 *
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {object} item user provided use value
+					 * @returns {Effect} effect
+					 */
+					const useToEffectRaw = (path, defaultIdent, item) => {
+						if (typeof item === "string") {
+							return {
+								type,
+								value: {
+									loader: item,
+									options: undefined,
+									ident: undefined
+								}
+							};
+						} else {
+							const loader = item.loader;
+							const options = item.options;
+							let ident = item.ident;
+							if (options && typeof options === "object") {
+								if (!ident) ident = defaultIdent;
+								references.set(ident, options);
+							}
+							if (typeof options === "string") {
+								util.deprecate(
+									() => {},
+									`Using a string as loader options is deprecated (${path}.options)`,
+									"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+								)();
+							}
+							return {
+								type: enforce ? `use-${enforce}` : "use",
+								value: {
+									loader,
+									options,
+									ident
+								}
+							};
+						}
+					};
+
+					/**
+					 * @param {string} path options path
+					 * @param {any} items user provided use value
+					 * @returns {Effect[]} effects
+					 */
+					const useToEffectsWithoutIdent = (path, items) => {
+						if (Array.isArray(items)) {
+							return items.map((item, idx) =>
+								useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
+							);
+						}
+						return [useToEffectRaw(path, "[[missing ident]]", items)];
+					};
+
+					/**
+					 * @param {string} path current path
+					 * @param {any} items user provided use value
+					 * @returns {(Effect|function(any): Effect[])[]} effects
+					 */
+					const useToEffects = (path, items) => {
+						if (Array.isArray(items)) {
+							return items.map((item, idx) => {
+								const subPath = `${path}[${idx}]`;
+								return useToEffect(subPath, subPath, item);
+							});
+						}
+						return [useToEffect(path, path, items)];
+					};
 
-const NORMALIZER = {
-	excludeModules: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
-		}
-		return value.map(normalizeFilter);
-	},
-	excludeAssets: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
-		}
-		return value.map(normalizeFilter);
-	},
-	warningsFilter: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
-		}
-		return value.map(filter => {
-			if (typeof filter === "string") {
-				return (warning, warningString) => warningString.includes(filter);
-			}
-			if (filter instanceof RegExp) {
-				return (warning, warningString) => filter.test(warningString);
-			}
-			if (typeof filter === "function") {
-				return filter;
-			}
-			throw new Error(
-				`Can only filter warnings with Strings or RegExps. (Given: ${filter})`
-			);
-		});
-	},
-	logging: value => {
-		if (value === true) value = "log";
-		return value;
-	},
-	loggingDebug: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
-		}
-		return value.map(normalizeFilter);
-	}
-};
+					if (typeof use === "function") {
+						result.effects.push(data =>
+							useToEffectsWithoutIdent(`${path}.use`, use(data))
+						);
+					} else {
+						for (const effect of useToEffects(`${path}.use`, use)) {
+							result.effects.push(effect);
+						}
+					}
+				}
 
-class DefaultStatsPresetPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsPresetPlugin", compilation => {
-			for (const key of Object.keys(NAMED_PRESETS)) {
-				const defaults = NAMED_PRESETS[key];
-				compilation.hooks.statsPreset
-					.for(key)
-					.tap("DefaultStatsPresetPlugin", (options, context) => {
-						applyDefaults(options, defaults);
-					});
-			}
-			compilation.hooks.statsNormalize.tap(
-				"DefaultStatsPresetPlugin",
-				(options, context) => {
-					for (const key of Object.keys(DEFAULTS)) {
-						if (options[key] === undefined)
-							options[key] = DEFAULTS[key](options, context, compilation);
+				if (unhandledProperties.has("loader")) {
+					unhandledProperties.delete("loader");
+					unhandledProperties.delete("options");
+					unhandledProperties.delete("enforce");
+
+					const loader = rule.loader;
+					const options = rule.options;
+					const enforce = rule.enforce;
+
+					if (loader.includes("!")) {
+						throw ruleSetCompiler.error(
+							`${path}.loader`,
+							loader,
+							"Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays"
+						);
 					}
-					for (const key of Object.keys(NORMALIZER)) {
-						options[key] = NORMALIZER[key](options[key]);
+
+					if (loader.includes("?")) {
+						throw ruleSetCompiler.error(
+							`${path}.loader`,
+							loader,
+							"Query arguments on 'loader' has been removed in favor of the 'options' property"
+						);
+					}
+
+					if (typeof options === "string") {
+						util.deprecate(
+							() => {},
+							`Using a string as loader options is deprecated (${path}.options)`,
+							"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+						)();
 					}
+
+					const ident =
+						options && typeof options === "object" ? path : undefined;
+					references.set(ident, options);
+					result.effects.push({
+						type: enforce ? `use-${enforce}` : "use",
+						value: {
+							loader,
+							options,
+							ident
+						}
+					});
 				}
-			);
-		});
+			}
+		);
 	}
+
+	useItemToEffects(path, item) {}
 }
-module.exports = DefaultStatsPresetPlugin;
+
+module.exports = UseEffectRulePlugin;
 
 
 /***/ }),
 
-/***/ 58692:
+/***/ 63672:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("./StatsPrinter")} StatsPrinter */
-/** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
-
-const DATA_URI_CONTENT_LENGTH = 16;
-
-const plural = (n, singular, plural) => (n === 1 ? singular : plural);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-/**
- * @param {Record<string, number>} sizes sizes by source type
- * @param {Object} options options
- * @param {(number) => string=} options.formatSize size formatter
- * @returns {string} text
- */
-const printSizes = (sizes, { formatSize = n => `${n}` }) => {
-	const keys = Object.keys(sizes);
-	if (keys.length > 1) {
-		return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
-	} else if (keys.length === 1) {
-		return formatSize(sizes[keys[0]]);
+class AsyncModuleRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("async module");
 	}
-};
-
-const getResourceName = resource => {
-	const dataUrl = /^data:[^,]+,/.exec(resource);
-	if (!dataUrl) return resource;
-
-	const len = dataUrl[0].length + DATA_URI_CONTENT_LENGTH;
-	if (resource.length < len) return resource;
-	return `${resource.slice(
-		0,
-		Math.min(resource.length - /* '..'.length */ 2, len)
-	)}..`;
-};
-
-const getModuleName = name => {
-	const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
-	return [prefix, getResourceName(resource)];
-};
-
-const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
-
-/**
- * @param {number} n a number
- * @returns {string} number as two digit string, leading 0
- */
-const twoDigit = n => (n >= 10 ? `${n}` : `0${n}`);
-
-const isValidId = id => {
-	return typeof id === "number" || id;
-};
-
-const moreCount = (list, count) => {
-	return list && list.length > 0 ? `+ ${count}` : `${count}`;
-};
-
-/** @type {Record<string, (thing: any, context: StatsPrinterContext, printer: StatsPrinter) => string | void>} */
-const SIMPLE_PRINTERS = {
-	"compilation.summary!": (
-		_,
-		{
-			type,
-			bold,
-			green,
-			red,
-			yellow,
-			formatDateTime,
-			formatTime,
-			compilation: {
-				name,
-				hash,
-				version,
-				time,
-				builtAt,
-				errorsCount,
-				warningsCount
-			}
-		}
-	) => {
-		const root = type === "compilation.summary!";
-		const warningsMessage =
-			warningsCount > 0
-				? yellow(
-						`${warningsCount} ${plural(warningsCount, "warning", "warnings")}`
-				  )
-				: "";
-		const errorsMessage =
-			errorsCount > 0
-				? red(`${errorsCount} ${plural(errorsCount, "error", "errors")}`)
-				: "";
-		const timeMessage = root && time ? ` in ${formatTime(time)}` : "";
-		const hashMessage = hash ? ` (${hash})` : "";
-		const builtAtMessage =
-			root && builtAt ? `${formatDateTime(builtAt)}: ` : "";
-		const versionMessage = root && version ? `webpack ${version}` : "";
-		const nameMessage =
-			root && name
-				? bold(name)
-				: name
-				? `Child ${bold(name)}`
-				: root
-				? ""
-				: "Child";
-		const subjectMessage =
-			nameMessage && versionMessage
-				? `${nameMessage} (${versionMessage})`
-				: versionMessage || nameMessage || "webpack";
-		let statusMessage;
-		if (errorsMessage && warningsMessage) {
-			statusMessage = `compiled with ${errorsMessage} and ${warningsMessage}`;
-		} else if (errorsMessage) {
-			statusMessage = `compiled with ${errorsMessage}`;
-		} else if (warningsMessage) {
-			statusMessage = `compiled with ${warningsMessage}`;
-		} else if (errorsCount === 0 && warningsCount === 0) {
-			statusMessage = `compiled ${green("successfully")}`;
-		} else {
-			statusMessage = `compiled`;
-		}
-		if (
-			builtAtMessage ||
-			versionMessage ||
-			errorsMessage ||
-			warningsMessage ||
-			(errorsCount === 0 && warningsCount === 0) ||
-			timeMessage ||
-			hashMessage
-		)
-			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
-	},
-	"compilation.filteredWarningDetailsCount": count =>
-		count
-			? `${count} ${plural(
-					count,
-					"warning has",
-					"warnings have"
-			  )} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
-			: undefined,
-	"compilation.filteredErrorDetailsCount": (count, { yellow }) =>
-		count
-			? yellow(
-					`${count} ${plural(
-						count,
-						"error has",
-						"errors have"
-					)} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
-			  )
-			: undefined,
-	"compilation.env": (env, { bold }) =>
-		env
-			? `Environment (--env): ${bold(JSON.stringify(env, null, 2))}`
-			: undefined,
-	"compilation.publicPath": (publicPath, { bold }) =>
-		`PublicPath: ${bold(publicPath || "(none)")}`,
-	"compilation.entrypoints": (entrypoints, context, printer) =>
-		Array.isArray(entrypoints)
-			? undefined
-			: printer.print(context.type, Object.values(entrypoints), {
-					...context,
-					chunkGroupKind: "Entrypoint"
-			  }),
-	"compilation.namedChunkGroups": (namedChunkGroups, context, printer) => {
-		if (!Array.isArray(namedChunkGroups)) {
-			const {
-				compilation: { entrypoints }
-			} = context;
-			let chunkGroups = Object.values(namedChunkGroups);
-			if (entrypoints) {
-				chunkGroups = chunkGroups.filter(
-					group =>
-						!Object.prototype.hasOwnProperty.call(entrypoints, group.name)
-				);
-			}
-			return printer.print(context.type, chunkGroups, {
-				...context,
-				chunkGroupKind: "Chunk Group"
-			});
-		}
-	},
-	"compilation.assetsByChunkName": () => "",
 
-	"compilation.filteredModules": (
-		filteredModules,
-		{ compilation: { modules } }
-	) =>
-		filteredModules > 0
-			? `${moreCount(modules, filteredModules)} ${plural(
-					filteredModules,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"compilation.filteredAssets": (filteredAssets, { compilation: { assets } }) =>
-		filteredAssets > 0
-			? `${moreCount(assets, filteredAssets)} ${plural(
-					filteredAssets,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
-	"compilation.logging": (logging, context, printer) =>
-		Array.isArray(logging)
-			? undefined
-			: printer.print(
-					context.type,
-					Object.entries(logging).map(([name, value]) => ({ ...value, name })),
-					context
-			  ),
-	"compilation.warningsInChildren!": (_, { yellow, compilation }) => {
-		if (
-			!compilation.children &&
-			compilation.warningsCount > 0 &&
-			compilation.warnings
-		) {
-			const childWarnings =
-				compilation.warningsCount - compilation.warnings.length;
-			if (childWarnings > 0) {
-				return yellow(
-					`${childWarnings} ${plural(
-						childWarnings,
-						"WARNING",
-						"WARNINGS"
-					)} in child compilations${
-						compilation.children
-							? ""
-							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
-					}`
-				);
-			}
-		}
-	},
-	"compilation.errorsInChildren!": (_, { red, compilation }) => {
-		if (
-			!compilation.children &&
-			compilation.errorsCount > 0 &&
-			compilation.errors
-		) {
-			const childErrors = compilation.errorsCount - compilation.errors.length;
-			if (childErrors > 0) {
-				return red(
-					`${childErrors} ${plural(
-						childErrors,
-						"ERROR",
-						"ERRORS"
-					)} in child compilations${
-						compilation.children
-							? ""
-							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
-					}`
-				);
-			}
-		}
-	},
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.asyncModule;
+		return Template.asString([
+			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
+			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
+			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
+				"if(queue) {",
+				Template.indent([
+					`queue.forEach(${runtimeTemplate.expressionFunction(
+						"fn.r--",
+						"fn"
+					)});`,
+					`queue.forEach(${runtimeTemplate.expressionFunction(
+						"fn.r-- ? fn.r++ : fn()",
+						"fn"
+					)});`
+				]),
+				"}"
+			])}`,
+			`var completeFunction = ${runtimeTemplate.expressionFunction(
+				"!--fn.r && fn()",
+				"fn"
+			)};`,
+			`var queueFunction = ${runtimeTemplate.expressionFunction(
+				"queue ? queue.push(fn) : completeFunction(fn)",
+				"queue, fn"
+			)};`,
+			`var wrapDeps = ${runtimeTemplate.returningFunction(
+				`deps.map(${runtimeTemplate.basicFunction("dep", [
+					'if(dep !== null && typeof dep === "object") {',
+					Template.indent([
+						"if(dep[webpackThen]) return dep;",
+						"if(dep.then) {",
+						Template.indent([
+							"var queue = [];",
+							`dep.then(${runtimeTemplate.basicFunction("r", [
+								"obj[webpackExports] = r;",
+								"completeQueue(queue);",
+								"queue = 0;"
+							])}, ${runtimeTemplate.basicFunction("e", [
+								"obj[webpackError] = e;",
+								"completeQueue(queue);",
+								"queue = 0;"
+							])});`,
+							"var obj = {};",
+							`obj[webpackThen] = ${runtimeTemplate.expressionFunction(
+								"queueFunction(queue, fn), dep['catch'](reject)",
+								"fn, reject"
+							)};`,
+							"return obj;"
+						]),
+						"}"
+					]),
+					"}",
+					"var ret = {};",
+					`ret[webpackThen] = ${runtimeTemplate.expressionFunction(
+						"completeFunction(fn)",
+						"fn"
+					)};`,
+					"ret[webpackExports] = dep;",
+					"return ret;"
+				])})`,
+				"deps"
+			)};`,
+			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
+				"var queue = hasAwait && [];",
+				"var exports = module.exports;",
+				"var currentDeps;",
+				"var outerResolve;",
+				"var reject;",
+				"var isEvaluating = true;",
+				"var nested = false;",
+				`var whenAll = ${runtimeTemplate.basicFunction(
+					"deps, onResolve, onReject",
+					[
+						"if (nested) return;",
+						"nested = true;",
+						"onResolve.r += deps.length;",
+						`deps.map(${runtimeTemplate.expressionFunction(
+							"dep[webpackThen](onResolve, onReject)",
+							"dep, i"
+						)});`,
+						"nested = false;"
+					]
+				)};`,
+				`var promise = new Promise(${runtimeTemplate.basicFunction(
+					"resolve, rej",
+					[
+						"reject = rej;",
+						`outerResolve = ${runtimeTemplate.expressionFunction(
+							"resolve(exports), completeQueue(queue), queue = 0"
+						)};`
+					]
+				)});`,
+				"promise[webpackExports] = exports;",
+				`promise[webpackThen] = ${runtimeTemplate.basicFunction(
+					"fn, rejectFn",
+					[
+						"if (isEvaluating) { return completeFunction(fn); }",
+						"if (currentDeps) whenAll(currentDeps, fn, rejectFn);",
+						"queueFunction(queue, fn);",
+						"promise['catch'](rejectFn);"
+					]
+				)};`,
+				"module.exports = promise;",
+				`body(${runtimeTemplate.basicFunction("deps", [
+					"currentDeps = wrapDeps(deps);",
+					"var fn;",
+					`var getResult = ${runtimeTemplate.returningFunction(
+						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							"if(d[webpackError]) throw d[webpackError];",
+							"return d[webpackExports];"
+						])})`
+					)}`,
+					`var promise = new Promise(${runtimeTemplate.basicFunction(
+						"resolve, reject",
+						[
+							`fn = ${runtimeTemplate.expressionFunction(
+								"resolve(getResult)"
+							)};`,
+							"fn.r = 0;",
+							"whenAll(currentDeps, fn, reject);"
+						]
+					)});`,
+					"return fn.r ? promise : getResult();"
+				])}, ${runtimeTemplate.expressionFunction(
+					"err && reject(promise[webpackError] = err), outerResolve()",
+					"err"
+				)});`,
+				"isEvaluating = false;"
+			])};`
+		]);
+	}
+}
 
-	"asset.type": type => type,
-	"asset.name": (name, { formatFilename, asset: { isOverSizeLimit } }) =>
-		formatFilename(name, isOverSizeLimit),
-	"asset.size": (
-		size,
-		{ asset: { isOverSizeLimit }, yellow, green, formatSize }
-	) => (isOverSizeLimit ? yellow(formatSize(size)) : formatSize(size)),
-	"asset.emitted": (emitted, { green, formatFlag }) =>
-		emitted ? green(formatFlag("emitted")) : undefined,
-	"asset.comparedForEmit": (comparedForEmit, { yellow, formatFlag }) =>
-		comparedForEmit ? yellow(formatFlag("compared for emit")) : undefined,
-	"asset.cached": (cached, { green, formatFlag }) =>
-		cached ? green(formatFlag("cached")) : undefined,
-	"asset.isOverSizeLimit": (isOverSizeLimit, { yellow, formatFlag }) =>
-		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
+module.exports = AsyncModuleRuntimeModule;
 
-	"asset.info.immutable": (immutable, { green, formatFlag }) =>
-		immutable ? green(formatFlag("immutable")) : undefined,
-	"asset.info.javascriptModule": (javascriptModule, { formatFlag }) =>
-		javascriptModule ? formatFlag("javascript module") : undefined,
-	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
-		sourceFilename
-			? formatFlag(
-					sourceFilename === true
-						? "from source file"
-						: `from: ${sourceFilename}`
-			  )
-			: undefined,
-	"asset.info.development": (development, { green, formatFlag }) =>
-		development ? green(formatFlag("dev")) : undefined,
-	"asset.info.hotModuleReplacement": (
-		hotModuleReplacement,
-		{ green, formatFlag }
-	) => (hotModuleReplacement ? green(formatFlag("hmr")) : undefined),
-	"asset.separator!": () => "\n",
-	"asset.filteredRelated": (filteredRelated, { asset: { related } }) =>
-		filteredRelated > 0
-			? `${moreCount(related, filteredRelated)} related ${plural(
-					filteredRelated,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
-	"asset.filteredChildren": (filteredChildren, { asset: { children } }) =>
-		filteredChildren > 0
-			? `${moreCount(children, filteredChildren)} ${plural(
-					filteredChildren,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
 
-	assetChunk: (id, { formatChunkId }) => formatChunkId(id),
+/***/ }),
 
-	assetChunkName: name => name,
-	assetChunkIdHint: name => name,
+/***/ 66532:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	"module.type": type => (type !== "module" ? type : undefined),
-	"module.id": (id, { formatModuleId }) =>
-		isValidId(id) ? formatModuleId(id) : undefined,
-	"module.name": (name, { bold }) => {
-		const [prefix, resource] = getModuleName(name);
-		return `${prefix || ""}${bold(resource || "")}`;
-	},
-	"module.identifier": identifier => undefined,
-	"module.layer": (layer, { formatLayer }) =>
-		layer ? formatLayer(layer) : undefined,
-	"module.sizes": printSizes,
-	"module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
-	"module.depth": (depth, { formatFlag }) =>
-		depth !== null ? formatFlag(`depth ${depth}`) : undefined,
-	"module.cacheable": (cacheable, { formatFlag, red }) =>
-		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
-	"module.orphan": (orphan, { formatFlag, yellow }) =>
-		orphan ? yellow(formatFlag("orphan")) : undefined,
-	"module.runtime": (runtime, { formatFlag, yellow }) =>
-		runtime ? yellow(formatFlag("runtime")) : undefined,
-	"module.optional": (optional, { formatFlag, yellow }) =>
-		optional ? yellow(formatFlag("optional")) : undefined,
-	"module.dependent": (dependent, { formatFlag, cyan }) =>
-		dependent ? cyan(formatFlag("dependent")) : undefined,
-	"module.built": (built, { formatFlag, yellow }) =>
-		built ? yellow(formatFlag("built")) : undefined,
-	"module.codeGenerated": (codeGenerated, { formatFlag, yellow }) =>
-		codeGenerated ? yellow(formatFlag("code generated")) : undefined,
-	"module.buildTimeExecuted": (buildTimeExecuted, { formatFlag, green }) =>
-		buildTimeExecuted ? green(formatFlag("build time executed")) : undefined,
-	"module.cached": (cached, { formatFlag, green }) =>
-		cached ? green(formatFlag("cached")) : undefined,
-	"module.assets": (assets, { formatFlag, magenta }) =>
-		assets && assets.length
-			? magenta(
-					formatFlag(
-						`${assets.length} ${plural(assets.length, "asset", "assets")}`
-					)
-			  )
-			: undefined,
-	"module.warnings": (warnings, { formatFlag, yellow }) =>
-		warnings === true
-			? yellow(formatFlag("warnings"))
-			: warnings
-			? yellow(
-					formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`)
-			  )
-			: undefined,
-	"module.errors": (errors, { formatFlag, red }) =>
-		errors === true
-			? red(formatFlag("errors"))
-			: errors
-			? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
-			: undefined,
-	"module.providedExports": (providedExports, { formatFlag, cyan }) => {
-		if (Array.isArray(providedExports)) {
-			if (providedExports.length === 0) return cyan(formatFlag("no exports"));
-			return cyan(formatFlag(`exports: ${providedExports.join(", ")}`));
-		}
-	},
-	"module.usedExports": (usedExports, { formatFlag, cyan, module }) => {
-		if (usedExports !== true) {
-			if (usedExports === null) return cyan(formatFlag("used exports unknown"));
-			if (usedExports === false) return cyan(formatFlag("module unused"));
-			if (Array.isArray(usedExports)) {
-				if (usedExports.length === 0)
-					return cyan(formatFlag("no exports used"));
-				const providedExportsCount = Array.isArray(module.providedExports)
-					? module.providedExports.length
-					: null;
-				if (
-					providedExportsCount !== null &&
-					providedExportsCount === usedExports.length
-				) {
-					return cyan(formatFlag("all exports used"));
-				} else {
-					return cyan(
-						formatFlag(`only some exports used: ${usedExports.join(", ")}`)
-					);
-				}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const { getUndoPath } = __webpack_require__(82186);
+
+class AutoPublicPathRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("publicPath", RuntimeModule.STAGE_BASIC);
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { scriptType, importMetaName, path } = compilation.outputOptions;
+		const chunkName = compilation.getPath(
+			JavascriptModulesPlugin.getChunkFilenameTemplate(
+				this.chunk,
+				compilation.outputOptions
+			),
+			{
+				chunk: this.chunk,
+				contentHashType: "javascript"
 			}
-		}
-	},
-	"module.optimizationBailout[]": (optimizationBailout, { yellow }) =>
-		yellow(optimizationBailout),
-	"module.issuerPath": (issuerPath, { module }) =>
-		module.profile ? undefined : "",
-	"module.profile": profile => undefined,
-	"module.filteredModules": (filteredModules, { module: { modules } }) =>
-		filteredModules > 0
-			? `${moreCount(modules, filteredModules)} nested ${plural(
-					filteredModules,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"module.filteredReasons": (filteredReasons, { module: { reasons } }) =>
-		filteredReasons > 0
-			? `${moreCount(reasons, filteredReasons)} ${plural(
-					filteredReasons,
-					"reason",
-					"reasons"
-			  )}`
-			: undefined,
-	"module.filteredChildren": (filteredChildren, { module: { children } }) =>
-		filteredChildren > 0
-			? `${moreCount(children, filteredChildren)} ${plural(
-					filteredChildren,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"module.separator!": () => "\n",
+		);
+		const undoPath = getUndoPath(chunkName, path, false);
 
-	"moduleIssuer.id": (id, { formatModuleId }) => formatModuleId(id),
-	"moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value),
+		return Template.asString([
+			"var scriptUrl;",
+			scriptType === "module"
+				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
+				: Template.asString([
+						`if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
+						`var document = ${RuntimeGlobals.global}.document;`,
+						"if (!scriptUrl && document) {",
+						Template.indent([
+							`if (document.currentScript)`,
+							Template.indent(`scriptUrl = document.currentScript.src`),
+							"if (!scriptUrl) {",
+							Template.indent([
+								'var scripts = document.getElementsByTagName("script");',
+								"if(scripts.length) scriptUrl = scripts[scripts.length - 1].src"
+							]),
+							"}"
+						]),
+						"}"
+				  ]),
+			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
+			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
+			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
+			'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+			!undoPath
+				? `${RuntimeGlobals.publicPath} = scriptUrl;`
+				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(
+						undoPath
+				  )};`
+		]);
+	}
+}
 
-	"moduleReason.type": type => type,
-	"moduleReason.userRequest": (userRequest, { cyan }) =>
-		cyan(getResourceName(userRequest)),
-	"moduleReason.moduleId": (moduleId, { formatModuleId }) =>
-		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
-	"moduleReason.module": (module, { magenta }) => magenta(module),
-	"moduleReason.loc": loc => loc,
-	"moduleReason.explanation": (explanation, { cyan }) => cyan(explanation),
-	"moduleReason.active": (active, { formatFlag }) =>
-		active ? undefined : formatFlag("inactive"),
-	"moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
-	"moduleReason.filteredChildren": (
-		filteredChildren,
-		{ moduleReason: { children } }
-	) =>
-		filteredChildren > 0
-			? `${moreCount(children, filteredChildren)} ${plural(
-					filteredChildren,
-					"reason",
-					"reasons"
-			  )}`
-			: undefined,
+module.exports = AutoPublicPathRuntimeModule;
 
-	"module.profile.total": (value, { formatTime }) => formatTime(value),
-	"module.profile.resolving": (value, { formatTime }) =>
-		`resolving: ${formatTime(value)}`,
-	"module.profile.restoring": (value, { formatTime }) =>
-		`restoring: ${formatTime(value)}`,
-	"module.profile.integration": (value, { formatTime }) =>
-		`integration: ${formatTime(value)}`,
-	"module.profile.building": (value, { formatTime }) =>
-		`building: ${formatTime(value)}`,
-	"module.profile.storing": (value, { formatTime }) =>
-		`storing: ${formatTime(value)}`,
-	"module.profile.additionalResolving": (value, { formatTime }) =>
-		value ? `additional resolving: ${formatTime(value)}` : undefined,
-	"module.profile.additionalIntegration": (value, { formatTime }) =>
-		value ? `additional integration: ${formatTime(value)}` : undefined,
 
-	"chunkGroup.kind!": (_, { chunkGroupKind }) => chunkGroupKind,
-	"chunkGroup.separator!": () => "\n",
-	"chunkGroup.name": (name, { bold }) => bold(name),
-	"chunkGroup.isOverSizeLimit": (isOverSizeLimit, { formatFlag, yellow }) =>
-		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
-	"chunkGroup.assetsSize": (size, { formatSize }) =>
-		size ? formatSize(size) : undefined,
-	"chunkGroup.auxiliaryAssetsSize": (size, { formatSize }) =>
-		size ? `(${formatSize(size)})` : undefined,
-	"chunkGroup.filteredAssets": (n, { chunkGroup: { assets } }) =>
-		n > 0
-			? `${moreCount(assets, n)} ${plural(n, "asset", "assets")}`
-			: undefined,
-	"chunkGroup.filteredAuxiliaryAssets": (
-		n,
-		{ chunkGroup: { auxiliaryAssets } }
-	) =>
-		n > 0
-			? `${moreCount(auxiliaryAssets, n)} auxiliary ${plural(
-					n,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
-	"chunkGroup.is!": () => "=",
-	"chunkGroupAsset.name": (asset, { green }) => green(asset),
-	"chunkGroupAsset.size": (size, { formatSize, chunkGroup }) =>
-		chunkGroup.assets.length > 1 ||
-		(chunkGroup.auxiliaryAssets && chunkGroup.auxiliaryAssets.length > 0)
-			? formatSize(size)
-			: undefined,
-	"chunkGroup.children": (children, context, printer) =>
-		Array.isArray(children)
-			? undefined
-			: printer.print(
-					context.type,
-					Object.keys(children).map(key => ({
-						type: key,
-						children: children[key]
-					})),
-					context
-			  ),
-	"chunkGroupChildGroup.type": type => `${type}:`,
-	"chunkGroupChild.assets[]": (file, { formatFilename }) =>
-		formatFilename(file),
-	"chunkGroupChild.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
-	"chunkGroupChild.name": name => (name ? `(name: ${name})` : undefined),
+/***/ }),
 
-	"chunk.id": (id, { formatChunkId }) => formatChunkId(id),
-	"chunk.files[]": (file, { formatFilename }) => formatFilename(file),
-	"chunk.names[]": name => name,
-	"chunk.idHints[]": name => name,
-	"chunk.runtime[]": name => name,
-	"chunk.sizes": (sizes, context) => printSizes(sizes, context),
-	"chunk.parents[]": (parents, context) =>
-		context.formatChunkId(parents, "parent"),
-	"chunk.siblings[]": (siblings, context) =>
-		context.formatChunkId(siblings, "sibling"),
-	"chunk.children[]": (children, context) =>
-		context.formatChunkId(children, "child"),
-	"chunk.childrenByOrder": (childrenByOrder, context, printer) =>
-		Array.isArray(childrenByOrder)
-			? undefined
-			: printer.print(
-					context.type,
-					Object.keys(childrenByOrder).map(key => ({
-						type: key,
-						children: childrenByOrder[key]
-					})),
-					context
-			  ),
-	"chunk.childrenByOrder[].type": type => `${type}:`,
-	"chunk.childrenByOrder[].children[]": (id, { formatChunkId }) =>
-		isValidId(id) ? formatChunkId(id) : undefined,
-	"chunk.entry": (entry, { formatFlag, yellow }) =>
-		entry ? yellow(formatFlag("entry")) : undefined,
-	"chunk.initial": (initial, { formatFlag, yellow }) =>
-		initial ? yellow(formatFlag("initial")) : undefined,
-	"chunk.rendered": (rendered, { formatFlag, green }) =>
-		rendered ? green(formatFlag("rendered")) : undefined,
-	"chunk.recorded": (recorded, { formatFlag, green }) =>
-		recorded ? green(formatFlag("recorded")) : undefined,
-	"chunk.reason": (reason, { yellow }) => (reason ? yellow(reason) : undefined),
-	"chunk.filteredModules": (filteredModules, { chunk: { modules } }) =>
-		filteredModules > 0
-			? `${moreCount(modules, filteredModules)} chunk ${plural(
-					filteredModules,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"chunk.separator!": () => "\n",
+/***/ 84519:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	"chunkOrigin.request": request => request,
-	"chunkOrigin.moduleId": (moduleId, { formatModuleId }) =>
-		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
-	"chunkOrigin.moduleName": (moduleName, { bold }) => bold(moduleName),
-	"chunkOrigin.loc": loc => loc,
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-	"error.compilerPath": (compilerPath, { bold }) =>
-		compilerPath ? bold(`(${compilerPath})`) : undefined,
-	"error.chunkId": (chunkId, { formatChunkId }) =>
-		isValidId(chunkId) ? formatChunkId(chunkId) : undefined,
-	"error.chunkEntry": (chunkEntry, { formatFlag }) =>
-		chunkEntry ? formatFlag("entry") : undefined,
-	"error.chunkInitial": (chunkInitial, { formatFlag }) =>
-		chunkInitial ? formatFlag("initial") : undefined,
-	"error.file": (file, { bold }) => bold(file),
-	"error.moduleName": (moduleName, { bold }) => {
-		return moduleName.includes("!")
-			? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})`
-			: `${bold(moduleName)}`;
-	},
-	"error.loc": (loc, { green }) => green(loc),
-	"error.message": (message, { bold, formatError }) =>
-		message.includes("\u001b[") ? message : bold(formatError(message)),
-	"error.details": (details, { formatError }) => formatError(details),
-	"error.stack": stack => stack,
-	"error.moduleTrace": moduleTrace => undefined,
-	"error.separator!": () => "\n",
 
-	"loggingEntry(error).loggingEntry.message": (message, { red }) =>
-		mapLines(message, x => `<e> ${red(x)}`),
-	"loggingEntry(warn).loggingEntry.message": (message, { yellow }) =>
-		mapLines(message, x => `<w> ${yellow(x)}`),
-	"loggingEntry(info).loggingEntry.message": (message, { green }) =>
-		mapLines(message, x => `<i> ${green(x)}`),
-	"loggingEntry(log).loggingEntry.message": (message, { bold }) =>
-		mapLines(message, x => `    ${bold(x)}`),
-	"loggingEntry(debug).loggingEntry.message": message =>
-		mapLines(message, x => `    ${x}`),
-	"loggingEntry(trace).loggingEntry.message": message =>
-		mapLines(message, x => `    ${x}`),
-	"loggingEntry(status).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<s> ${magenta(x)}`),
-	"loggingEntry(profile).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<p> ${magenta(x)}`),
-	"loggingEntry(profileEnd).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `</p> ${magenta(x)}`),
-	"loggingEntry(time).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<t> ${magenta(x)}`),
-	"loggingEntry(group).loggingEntry.message": (message, { cyan }) =>
-		mapLines(message, x => `<-> ${cyan(x)}`),
-	"loggingEntry(groupCollapsed).loggingEntry.message": (message, { cyan }) =>
-		mapLines(message, x => `<+> ${cyan(x)}`),
-	"loggingEntry(clear).loggingEntry": () => "    -------",
-	"loggingEntry(groupCollapsed).loggingEntry.children": () => "",
-	"loggingEntry.trace[]": trace =>
-		trace ? mapLines(trace, x => `| ${x}`) : undefined,
 
-	"moduleTraceItem.originName": originName => originName,
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-	loggingGroup: loggingGroup =>
-		loggingGroup.entries.length === 0 ? "" : undefined,
-	"loggingGroup.debug": (flag, { red }) => (flag ? red("DEBUG") : undefined),
-	"loggingGroup.name": (name, { bold }) => bold(`LOG from ${name}`),
-	"loggingGroup.separator!": () => "\n",
-	"loggingGroup.filteredEntries": filteredEntries =>
-		filteredEntries > 0 ? `+ ${filteredEntries} hidden lines` : undefined,
+class ChunkNameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} chunkName the chunk's name
+	 */
+	constructor(chunkName) {
+		super("chunkName");
+		this.chunkName = chunkName;
+	}
 
-	"moduleTraceDependency.loc": loc => loc
-};
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;
+	}
+}
 
-/** @type {Record<string, string | Function>} */
-const ITEM_NAMES = {
-	"compilation.assets[]": "asset",
-	"compilation.modules[]": "module",
-	"compilation.chunks[]": "chunk",
-	"compilation.entrypoints[]": "chunkGroup",
-	"compilation.namedChunkGroups[]": "chunkGroup",
-	"compilation.errors[]": "error",
-	"compilation.warnings[]": "error",
-	"compilation.logging[]": "loggingGroup",
-	"compilation.children[]": "compilation",
-	"asset.related[]": "asset",
-	"asset.children[]": "asset",
-	"asset.chunks[]": "assetChunk",
-	"asset.auxiliaryChunks[]": "assetChunk",
-	"asset.chunkNames[]": "assetChunkName",
-	"asset.chunkIdHints[]": "assetChunkIdHint",
-	"asset.auxiliaryChunkNames[]": "assetChunkName",
-	"asset.auxiliaryChunkIdHints[]": "assetChunkIdHint",
-	"chunkGroup.assets[]": "chunkGroupAsset",
-	"chunkGroup.auxiliaryAssets[]": "chunkGroupAsset",
-	"chunkGroupChild.assets[]": "chunkGroupAsset",
-	"chunkGroupChild.auxiliaryAssets[]": "chunkGroupAsset",
-	"chunkGroup.children[]": "chunkGroupChildGroup",
-	"chunkGroupChildGroup.children[]": "chunkGroupChild",
-	"module.modules[]": "module",
-	"module.children[]": "module",
-	"module.reasons[]": "moduleReason",
-	"moduleReason.children[]": "moduleReason",
-	"module.issuerPath[]": "moduleIssuer",
-	"chunk.origins[]": "chunkOrigin",
-	"chunk.modules[]": "module",
-	"loggingGroup.entries[]": logEntry =>
-		`loggingEntry(${logEntry.type}).loggingEntry`,
-	"loggingEntry.children[]": logEntry =>
-		`loggingEntry(${logEntry.type}).loggingEntry`,
-	"error.moduleTrace[]": "moduleTraceItem",
-	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
-};
+module.exports = ChunkNameRuntimeModule;
+
+
+/***/ }),
+
+/***/ 44793:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const ERROR_PREFERRED_ORDER = [
-	"compilerPath",
-	"chunkId",
-	"chunkEntry",
-	"chunkInitial",
-	"file",
-	"separator!",
-	"moduleName",
-	"loc",
-	"separator!",
-	"message",
-	"separator!",
-	"details",
-	"separator!",
-	"stack",
-	"separator!",
-	"missing",
-	"separator!",
-	"moduleTrace"
-];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-/** @type {Record<string, string[]>} */
-const PREFERRED_ORDERS = {
-	compilation: [
-		"name",
-		"hash",
-		"version",
-		"time",
-		"builtAt",
-		"env",
-		"publicPath",
-		"assets",
-		"filteredAssets",
-		"entrypoints",
-		"namedChunkGroups",
-		"chunks",
-		"modules",
-		"filteredModules",
-		"children",
-		"logging",
-		"warnings",
-		"warningsInChildren!",
-		"filteredWarningDetailsCount",
-		"errors",
-		"errorsInChildren!",
-		"filteredErrorDetailsCount",
-		"summary!",
-		"needAdditionalPass"
-	],
-	asset: [
-		"type",
-		"name",
-		"size",
-		"chunks",
-		"auxiliaryChunks",
-		"emitted",
-		"comparedForEmit",
-		"cached",
-		"info",
-		"isOverSizeLimit",
-		"chunkNames",
-		"auxiliaryChunkNames",
-		"chunkIdHints",
-		"auxiliaryChunkIdHints",
-		"related",
-		"filteredRelated",
-		"children",
-		"filteredChildren"
-	],
-	"asset.info": [
-		"immutable",
-		"sourceFilename",
-		"javascriptModule",
-		"development",
-		"hotModuleReplacement"
-	],
-	chunkGroup: [
-		"kind!",
-		"name",
-		"isOverSizeLimit",
-		"assetsSize",
-		"auxiliaryAssetsSize",
-		"is!",
-		"assets",
-		"filteredAssets",
-		"auxiliaryAssets",
-		"filteredAuxiliaryAssets",
-		"separator!",
-		"children"
-	],
-	chunkGroupAsset: ["name", "size"],
-	chunkGroupChildGroup: ["type", "children"],
-	chunkGroupChild: ["assets", "chunks", "name"],
-	module: [
-		"type",
-		"name",
-		"identifier",
-		"id",
-		"layer",
-		"sizes",
-		"chunks",
-		"depth",
-		"cacheable",
-		"orphan",
-		"runtime",
-		"optional",
-		"dependent",
-		"built",
-		"codeGenerated",
-		"cached",
-		"assets",
-		"failed",
-		"warnings",
-		"errors",
-		"children",
-		"filteredChildren",
-		"providedExports",
-		"usedExports",
-		"optimizationBailout",
-		"reasons",
-		"filteredReasons",
-		"issuerPath",
-		"profile",
-		"modules",
-		"filteredModules"
-	],
-	moduleReason: [
-		"active",
-		"type",
-		"userRequest",
-		"moduleId",
-		"module",
-		"resolvedModule",
-		"loc",
-		"explanation",
-		"children",
-		"filteredChildren"
-	],
-	"module.profile": [
-		"total",
-		"separator!",
-		"resolving",
-		"restoring",
-		"integration",
-		"building",
-		"storing",
-		"additionalResolving",
-		"additionalIntegration"
-	],
-	chunk: [
-		"id",
-		"runtime",
-		"files",
-		"names",
-		"idHints",
-		"sizes",
-		"parents",
-		"siblings",
-		"children",
-		"childrenByOrder",
-		"entry",
-		"initial",
-		"rendered",
-		"recorded",
-		"reason",
-		"separator!",
-		"origins",
-		"separator!",
-		"modules",
-		"separator!",
-		"filteredModules"
-	],
-	chunkOrigin: ["request", "moduleId", "moduleName", "loc"],
-	error: ERROR_PREFERRED_ORDER,
-	warning: ERROR_PREFERRED_ORDER,
-	"chunk.childrenByOrder[]": ["type", "children"],
-	loggingGroup: [
-		"debug",
-		"name",
-		"separator!",
-		"entries",
-		"separator!",
-		"filteredEntries"
-	],
-	loggingEntry: ["message", "trace", "children"]
-};
 
-const itemsJoinOneLine = items => items.filter(Boolean).join(" ");
-const itemsJoinOneLineBrackets = items =>
-	items.length > 0 ? `(${items.filter(Boolean).join(" ")})` : undefined;
-const itemsJoinMoreSpacing = items => items.filter(Boolean).join("\n\n");
-const itemsJoinComma = items => items.filter(Boolean).join(", ");
-const itemsJoinCommaBrackets = items =>
-	items.length > 0 ? `(${items.filter(Boolean).join(", ")})` : undefined;
-const itemsJoinCommaBracketsWithName = name => items =>
-	items.length > 0
-		? `(${name}: ${items.filter(Boolean).join(", ")})`
-		: undefined;
 
-/** @type {Record<string, (items: string[]) => string>} */
-const SIMPLE_ITEMS_JOINER = {
-	"chunk.parents": itemsJoinOneLine,
-	"chunk.siblings": itemsJoinOneLine,
-	"chunk.children": itemsJoinOneLine,
-	"chunk.names": itemsJoinCommaBrackets,
-	"chunk.idHints": itemsJoinCommaBracketsWithName("id hint"),
-	"chunk.runtime": itemsJoinCommaBracketsWithName("runtime"),
-	"chunk.files": itemsJoinComma,
-	"chunk.childrenByOrder": itemsJoinOneLine,
-	"chunk.childrenByOrder[].children": itemsJoinOneLine,
-	"chunkGroup.assets": itemsJoinOneLine,
-	"chunkGroup.auxiliaryAssets": itemsJoinOneLineBrackets,
-	"chunkGroupChildGroup.children": itemsJoinComma,
-	"chunkGroupChild.assets": itemsJoinOneLine,
-	"chunkGroupChild.auxiliaryAssets": itemsJoinOneLineBrackets,
-	"asset.chunks": itemsJoinComma,
-	"asset.auxiliaryChunks": itemsJoinCommaBrackets,
-	"asset.chunkNames": itemsJoinCommaBracketsWithName("name"),
-	"asset.auxiliaryChunkNames": itemsJoinCommaBracketsWithName("auxiliary name"),
-	"asset.chunkIdHints": itemsJoinCommaBracketsWithName("id hint"),
-	"asset.auxiliaryChunkIdHints":
-		itemsJoinCommaBracketsWithName("auxiliary id hint"),
-	"module.chunks": itemsJoinOneLine,
-	"module.issuerPath": items =>
-		items
-			.filter(Boolean)
-			.map(item => `${item} ->`)
-			.join(" "),
-	"compilation.errors": itemsJoinMoreSpacing,
-	"compilation.warnings": itemsJoinMoreSpacing,
-	"compilation.logging": itemsJoinMoreSpacing,
-	"compilation.children": items => indent(itemsJoinMoreSpacing(items), "  "),
-	"moduleTraceItem.dependencies": itemsJoinOneLine,
-	"loggingEntry.children": items =>
-		indent(items.filter(Boolean).join("\n"), "  ", false)
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-const joinOneLine = items =>
-	items
-		.map(item => item.content)
-		.filter(Boolean)
-		.join(" ");
+class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("compat get default export");
+	}
 
-const joinInBrackets = items => {
-	const res = [];
-	let mode = 0;
-	for (const item of items) {
-		if (item.element === "separator!") {
-			switch (mode) {
-				case 0:
-				case 1:
-					mode += 2;
-					break;
-				case 4:
-					res.push(")");
-					mode = 3;
-					break;
-			}
-		}
-		if (!item.content) continue;
-		switch (mode) {
-			case 0:
-				mode = 1;
-				break;
-			case 1:
-				res.push(" ");
-				break;
-			case 2:
-				res.push("(");
-				mode = 4;
-				break;
-			case 3:
-				res.push(" (");
-				mode = 4;
-				break;
-			case 4:
-				res.push(", ");
-				break;
-		}
-		res.push(item.content);
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.compatGetDefaultExport;
+		return Template.asString([
+			"// getDefaultExport function for compatibility with non-harmony modules",
+			`${fn} = ${runtimeTemplate.basicFunction("module", [
+				"var getter = module && module.__esModule ?",
+				Template.indent([
+					`${runtimeTemplate.returningFunction("module['default']")} :`,
+					`${runtimeTemplate.returningFunction("module")};`
+				]),
+				`${RuntimeGlobals.definePropertyGetters}(getter, { a: getter });`,
+				"return getter;"
+			])};`
+		]);
 	}
-	if (mode === 4) res.push(")");
-	return res.join("");
-};
+}
 
-const indent = (str, prefix, noPrefixInFirstLine) => {
-	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
-	if (noPrefixInFirstLine) return rem;
-	const ind = str[0] === "\n" ? "" : prefix;
-	return ind + rem;
-};
+module.exports = CompatGetDefaultExportRuntimeModule;
 
-const joinExplicitNewLine = (items, indenter) => {
-	let firstInLine = true;
-	let first = true;
-	return items
-		.map(item => {
-			if (!item || !item.content) return;
-			let content = indent(item.content, first ? "" : indenter, !firstInLine);
-			if (firstInLine) {
-				content = content.replace(/^\n+/, "");
-			}
-			if (!content) return;
-			first = false;
-			const noJoiner = firstInLine || content.startsWith("\n");
-			firstInLine = content.endsWith("\n");
-			return noJoiner ? content : " " + content;
-		})
-		.filter(Boolean)
-		.join("")
-		.trim();
-};
 
-const joinError =
-	error =>
-	(items, { red, yellow }) =>
-		`${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(
-			items,
-			""
-		)}`;
+/***/ }),
 
-/** @type {Record<string, (items: ({ element: string, content: string })[], context: StatsPrinterContext) => string>} */
-const SIMPLE_ELEMENT_JOINERS = {
-	compilation: items => {
-		const result = [];
-		let lastNeedMore = false;
-		for (const item of items) {
-			if (!item.content) continue;
-			const needMoreSpace =
-				item.element === "warnings" ||
-				item.element === "filteredWarningDetailsCount" ||
-				item.element === "errors" ||
-				item.element === "filteredErrorDetailsCount" ||
-				item.element === "logging";
-			if (result.length !== 0) {
-				result.push(needMoreSpace || lastNeedMore ? "\n\n" : "\n");
-			}
-			result.push(item.content);
-			lastNeedMore = needMoreSpace;
-		}
-		if (lastNeedMore) result.push("\n");
-		return result.join("");
-	},
-	asset: items =>
-		joinExplicitNewLine(
-			items.map(item => {
-				if (
-					(item.element === "related" || item.element === "children") &&
-					item.content
-				) {
-					return {
-						...item,
-						content: `\n${item.content}\n`
-					};
-				}
-				return item;
-			}),
-			"  "
-		),
-	"asset.info": joinOneLine,
-	module: (items, { module }) => {
-		let hasName = false;
-		return joinExplicitNewLine(
-			items.map(item => {
-				switch (item.element) {
-					case "id":
-						if (module.id === module.name) {
-							if (hasName) return false;
-							if (item.content) hasName = true;
-						}
-						break;
-					case "name":
-						if (hasName) return false;
-						if (item.content) hasName = true;
-						break;
-					case "providedExports":
-					case "usedExports":
-					case "optimizationBailout":
-					case "reasons":
-					case "issuerPath":
-					case "profile":
-					case "children":
-					case "modules":
-						if (item.content) {
-							return {
-								...item,
-								content: `\n${item.content}\n`
-							};
-						}
-						break;
-				}
-				return item;
-			}),
-			"  "
-		);
-	},
-	chunk: items => {
-		let hasEntry = false;
-		return (
-			"chunk " +
-			joinExplicitNewLine(
-				items.filter(item => {
-					switch (item.element) {
-						case "entry":
-							if (item.content) hasEntry = true;
-							break;
-						case "initial":
-							if (hasEntry) return false;
-							break;
-					}
-					return true;
-				}),
-				"  "
-			)
-		);
-	},
-	"chunk.childrenByOrder[]": items => `(${joinOneLine(items)})`,
-	chunkGroup: items => joinExplicitNewLine(items, "  "),
-	chunkGroupAsset: joinOneLine,
-	chunkGroupChildGroup: joinOneLine,
-	chunkGroupChild: joinOneLine,
-	// moduleReason: (items, { moduleReason }) => {
-	// 	let hasName = false;
-	// 	return joinOneLine(
-	// 		items.filter(item => {
-	// 			switch (item.element) {
-	// 				case "moduleId":
-	// 					if (moduleReason.moduleId === moduleReason.module && item.content)
-	// 						hasName = true;
-	// 					break;
-	// 				case "module":
-	// 					if (hasName) return false;
-	// 					break;
-	// 				case "resolvedModule":
-	// 					return (
-	// 						moduleReason.module !== moduleReason.resolvedModule &&
-	// 						item.content
-	// 					);
-	// 			}
-	// 			return true;
-	// 		})
-	// 	);
-	// },
-	moduleReason: (items, { moduleReason }) => {
-		let hasName = false;
-		return joinExplicitNewLine(
-			items.map(item => {
-				switch (item.element) {
-					case "moduleId":
-						if (moduleReason.moduleId === moduleReason.module && item.content)
-							hasName = true;
-						break;
-					case "module":
-						if (hasName) return false;
-						break;
-					case "resolvedModule":
-						if (moduleReason.module === moduleReason.resolvedModule)
-							return false;
-						break;
-					case "children":
-						if (item.content) {
-							return {
-								...item,
-								content: `\n${item.content}\n`
-							};
-						}
-						break;
-				}
-				return item;
-			}),
-			"  "
-		);
-	},
-	"module.profile": joinInBrackets,
-	moduleIssuer: joinOneLine,
-	chunkOrigin: items => "> " + joinOneLine(items),
-	"errors[].error": joinError(true),
-	"warnings[].error": joinError(false),
-	loggingGroup: items => joinExplicitNewLine(items, "").trimRight(),
-	moduleTraceItem: items => " @ " + joinOneLine(items),
-	moduleTraceDependency: joinOneLine
-};
+/***/ 88234:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-const AVAILABLE_COLORS = {
-	bold: "\u001b[1m",
-	yellow: "\u001b[1m\u001b[33m",
-	red: "\u001b[1m\u001b[31m",
-	green: "\u001b[1m\u001b[32m",
-	cyan: "\u001b[1m\u001b[36m",
-	magenta: "\u001b[1m\u001b[35m"
-};
 
-const AVAILABLE_FORMATS = {
-	formatChunkId: (id, { yellow }, direction) => {
-		switch (direction) {
-			case "parent":
-				return `<{${yellow(id)}}>`;
-			case "sibling":
-				return `={${yellow(id)}}=`;
-			case "child":
-				return `>{${yellow(id)}}<`;
-			default:
-				return `{${yellow(id)}}`;
-		}
-	},
-	formatModuleId: id => `[${id}]`,
-	formatFilename: (filename, { green, yellow }, oversize) =>
-		(oversize ? yellow : green)(filename),
-	formatFlag: flag => `[${flag}]`,
-	formatLayer: layer => `(in ${layer})`,
-	formatSize: (__webpack_require__(71070).formatSize),
-	formatDateTime: (dateTime, { bold }) => {
-		const d = new Date(dateTime);
-		const x = twoDigit;
-		const date = `${d.getFullYear()}-${x(d.getMonth() + 1)}-${x(d.getDate())}`;
-		const time = `${x(d.getHours())}:${x(d.getMinutes())}:${x(d.getSeconds())}`;
-		return `${date} ${bold(time)}`;
-	},
-	formatTime: (
-		time,
-		{ timeReference, bold, green, yellow, red },
-		boldQuantity
-	) => {
-		const unit = " ms";
-		if (timeReference && time !== timeReference) {
-			const times = [
-				timeReference / 2,
-				timeReference / 4,
-				timeReference / 8,
-				timeReference / 16
-			];
-			if (time < times[3]) return `${time}${unit}`;
-			else if (time < times[2]) return bold(`${time}${unit}`);
-			else if (time < times[1]) return green(`${time}${unit}`);
-			else if (time < times[0]) return yellow(`${time}${unit}`);
-			else return red(`${time}${unit}`);
-		} else {
-			return `${boldQuantity ? bold(time) : time}${unit}`;
-		}
-	},
-	formatError: (message, { green, yellow, red }) => {
-		if (message.includes("\u001b[")) return message;
-		const highlights = [
-			{ regExp: /(Did you mean .+)/g, format: green },
-			{
-				regExp: /(Set 'mode' option to 'development' or 'production')/g,
-				format: green
-			},
-			{ regExp: /(\(module has no exports\))/g, format: red },
-			{ regExp: /\(possible exports: (.+)\)/g, format: green },
-			{ regExp: /(?:^|\n)(.* doesn't exist)/g, format: red },
-			{ regExp: /('\w+' option has not been set)/g, format: red },
-			{
-				regExp: /(Emitted value instead of an instance of Error)/g,
-				format: yellow
-			},
-			{ regExp: /(Used? .+ instead)/gi, format: yellow },
-			{ regExp: /\b(deprecated|must|required)\b/g, format: yellow },
-			{
-				regExp: /\b(BREAKING CHANGE)\b/gi,
-				format: red
-			},
-			{
-				regExp:
-					/\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
-				format: red
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+/** @typedef {import("../MainTemplate")} MainTemplate */
+
+class CompatRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("compat", RuntimeModule.STAGE_ATTACH);
+		this.fullHash = true;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, chunk, compilation } = this;
+		const {
+			runtimeTemplate,
+			mainTemplate,
+			moduleTemplates,
+			dependencyTemplates
+		} = compilation;
+		const bootstrap = mainTemplate.hooks.bootstrap.call(
+			"",
+			chunk,
+			compilation.hash || "XXXX",
+			moduleTemplates.javascript,
+			dependencyTemplates
+		);
+		const localVars = mainTemplate.hooks.localVars.call(
+			"",
+			chunk,
+			compilation.hash || "XXXX"
+		);
+		const requireExtensions = mainTemplate.hooks.requireExtensions.call(
+			"",
+			chunk,
+			compilation.hash || "XXXX"
+		);
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+		let requireEnsure = "";
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunk)) {
+			const requireEnsureHandler = mainTemplate.hooks.requireEnsure.call(
+				"",
+				chunk,
+				compilation.hash || "XXXX",
+				"chunkId"
+			);
+			if (requireEnsureHandler) {
+				requireEnsure = `${
+					RuntimeGlobals.ensureChunkHandlers
+				}.compat = ${runtimeTemplate.basicFunction(
+					"chunkId, promises",
+					requireEnsureHandler
+				)};`;
 			}
-		];
-		for (const { regExp, format } of highlights) {
-			message = message.replace(regExp, (match, content) => {
-				return match.replace(content, format(content));
-			});
 		}
-		return message;
+		return [bootstrap, localVars, requireEnsure, requireExtensions]
+			.filter(Boolean)
+			.join("\n");
 	}
-};
 
-const RESULT_MODIFIER = {
-	"module.modules": result => {
-		return indent(result, "| ");
+	/**
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		// We avoid isolating this to have better backward-compat
+		return false;
 	}
-};
+}
 
-const createOrder = (array, preferredOrder) => {
-	const originalArray = array.slice();
-	const set = new Set(array);
-	const usedSet = new Set();
-	array.length = 0;
-	for (const element of preferredOrder) {
-		if (element.endsWith("!") || set.has(element)) {
-			array.push(element);
-			usedSet.add(element);
-		}
+module.exports = CompatRuntimeModule;
+
+
+/***/ }),
+
+/***/ 94669:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("create fake namespace object");
 	}
-	for (const element of originalArray) {
-		if (!usedSet.has(element)) {
-			array.push(element);
-		}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.createFakeNamespaceObject;
+		return Template.asString([
+			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
+				"Object.getPrototypeOf(obj)",
+				"obj"
+			)} : ${runtimeTemplate.returningFunction("obj.__proto__", "obj")};`,
+			"var leafPrototypes;",
+			"// create a fake namespace object",
+			"// mode & 1: value is a module id, require it",
+			"// mode & 2: merge all properties of value into the ns",
+			"// mode & 4: return value when already ns object",
+			"// mode & 16: return value when it's Promise-like",
+			"// mode & 8|1: behave like require",
+			// Note: must be a function (not arrow), because this is used in body!
+			`${fn} = function(value, mode) {`,
+			Template.indent([
+				`if(mode & 1) value = this(value);`,
+				`if(mode & 8) return value;`,
+				"if(typeof value === 'object' && value) {",
+				Template.indent([
+					"if((mode & 4) && value.__esModule) return value;",
+					"if((mode & 16) && typeof value.then === 'function') return value;"
+				]),
+				"}",
+				"var ns = Object.create(null);",
+				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
+				"var def = {};",
+				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
+				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
+				Template.indent([
+					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
+						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,
+						"key"
+					)});`
+				]),
+				"}",
+				`def['default'] = ${runtimeTemplate.returningFunction("value", "")};`,
+				`${RuntimeGlobals.definePropertyGetters}(ns, def);`,
+				"return ns;"
+			]),
+			"};"
+		]);
+	}
+}
+
+module.exports = CreateFakeNamespaceObjectRuntimeModule;
+
+
+/***/ }),
+
+/***/ 2759:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+class CreateScriptRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("trusted types script");
 	}
-	return array;
-};
 
-class DefaultStatsPrinterPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsPrinterPlugin", compilation => {
-			compilation.hooks.statsPrinter.tap(
-				"DefaultStatsPrinterPlugin",
-				(stats, options, context) => {
-					// Put colors into context
-					stats.hooks.print
-						.for("compilation")
-						.tap("DefaultStatsPrinterPlugin", (compilation, context) => {
-							for (const color of Object.keys(AVAILABLE_COLORS)) {
-								let start;
-								if (options.colors) {
-									if (
-										typeof options.colors === "object" &&
-										typeof options.colors[color] === "string"
-									) {
-										start = options.colors[color];
-									} else {
-										start = AVAILABLE_COLORS[color];
-									}
-								}
-								if (start) {
-									context[color] = str =>
-										`${start}${
-											typeof str === "string"
-												? str.replace(
-														/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
-														`$1${start}`
-												  )
-												: str
-										}\u001b[39m\u001b[22m`;
-								} else {
-									context[color] = str => str;
-								}
-							}
-							for (const format of Object.keys(AVAILABLE_FORMATS)) {
-								context[format] = (content, ...args) =>
-									AVAILABLE_FORMATS[format](content, context, ...args);
-							}
-							context.timeReference = compilation.time;
-						});
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.createScript;
 
-					for (const key of Object.keys(SIMPLE_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								SIMPLE_PRINTERS[key](obj, ctx, stats)
-							);
-					}
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)`
+					: "script",
+				"script"
+			)};`
+		);
+	}
+}
 
-					for (const key of Object.keys(PREFERRED_ORDERS)) {
-						const preferredOrder = PREFERRED_ORDERS[key];
-						stats.hooks.sortElements
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (elements, context) => {
-								createOrder(elements, preferredOrder);
-							});
-					}
+module.exports = CreateScriptRuntimeModule;
 
-					for (const key of Object.keys(ITEM_NAMES)) {
-						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap(
-								"DefaultStatsPrinterPlugin",
-								typeof itemName === "string" ? () => itemName : itemName
-							);
-					}
 
-					for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
-						const joiner = SIMPLE_ITEMS_JOINER[key];
-						stats.hooks.printItems
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", joiner);
-					}
+/***/ }),
 
-					for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
-						const joiner = SIMPLE_ELEMENT_JOINERS[key];
-						stats.hooks.printElements
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", joiner);
-					}
+/***/ 21213:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					for (const key of Object.keys(RESULT_MODIFIER)) {
-						const modifier = RESULT_MODIFIER[key];
-						stats.hooks.result
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", modifier);
-					}
-				}
-			);
-		});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("trusted types script url");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.createScriptUrl;
+
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScriptURL(url)`
+					: "url",
+				"url"
+			)};`
+		);
+	}
+}
+
+module.exports = CreateScriptUrlRuntimeModule;
+
+
+/***/ }),
+
+/***/ 75481:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("define property getters");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.definePropertyGetters;
+		return Template.asString([
+			"// define getter functions for harmony exports",
+			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
+				`for(var key in definition) {`,
+				Template.indent([
+					`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+					Template.indent([
+						"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
+					]),
+					"}"
+				]),
+				"}"
+			])};`
+		]);
+	}
+}
+
+module.exports = DefinePropertyGettersRuntimeModule;
+
+
+/***/ }),
+
+/***/ 71519:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+class EnsureChunkRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("ensure chunk");
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		// Check if there are non initial chunks which need to be imported using require-ensure
+		if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			const handlers = RuntimeGlobals.ensureChunkHandlers;
+			return Template.asString([
+				`${handlers} = {};`,
+				"// This file contains only the entry chunk.",
+				"// The chunk loading function for additional chunks",
+				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
+					"chunkId",
+					[
+						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
+							"promises, key",
+							[`${handlers}[key](chunkId, promises);`, "return promises;"]
+						)}, []));`
+					]
+				)};`
+			]);
+		} else {
+			// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
+			// function. This can happen with multiple entrypoints.
+			return Template.asString([
+				"// The chunk loading function for additional chunks",
+				"// Since all referenced chunks are already included",
+				"// in this file, this function is empty here.",
+				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
+					"Promise.resolve()"
+				)};`
+			]);
+		}
 	}
 }
-module.exports = DefaultStatsPrinterPlugin;
+
+module.exports = EnsureChunkRuntimeModule;
 
 
 /***/ }),
 
-/***/ 92629:
+/***/ 34277:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { HookMap, SyncBailHook, SyncWaterfallHook } = __webpack_require__(6967);
-const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
-const smartGrouping = __webpack_require__(15652);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const { first } = __webpack_require__(93347);
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
-
-/**
- * @typedef {Object} KnownStatsFactoryContext
- * @property {string} type
- * @property {function(string): string=} makePathsRelative
- * @property {Compilation=} compilation
- * @property {Set<Module>=} rootModules
- * @property {Map<string,Chunk[]>=} compilationFileToChunks
- * @property {Map<string,Chunk[]>=} compilationAuxiliaryFileToChunks
- * @property {RuntimeSpec=} runtime
- * @property {function(Compilation): WebpackError[]=} cachedGetErrors
- * @property {function(Compilation): WebpackError[]=} cachedGetWarnings
- */
-
-/** @typedef {KnownStatsFactoryContext & Record<string, any>} StatsFactoryContext */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").PathData} PathData */
 
-class StatsFactory {
-	constructor() {
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[Object, any, StatsFactoryContext]>>} */
-			extract: new HookMap(
-				() => new SyncBailHook(["object", "data", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
-			filter: new HookMap(
-				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
-			),
-			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
-			sort: new HookMap(() => new SyncBailHook(["comparators", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
-			filterSorted: new HookMap(
-				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
-			),
-			/** @type {HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext]>>} */
-			groupResults: new HookMap(
-				() => new SyncBailHook(["groupConfigs", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
-			sortResults: new HookMap(
-				() => new SyncBailHook(["comparators", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
-			filterResults: new HookMap(
-				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
-			),
-			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
-			merge: new HookMap(() => new SyncBailHook(["items", "context"])),
-			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
-			result: new HookMap(() => new SyncWaterfallHook(["result", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
-			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
-			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
-		});
-		const hooks = this.hooks;
-		this._caches =
-			/** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
-		for (const key of Object.keys(hooks)) {
-			this._caches[key] = new Map();
-		}
-		this._inCreate = false;
-	}
+/** @typedef {function(PathData, AssetInfo=): string} FilenameFunction */
 
-	_getAllLevelHooks(hookMap, cache, type) {
-		const cacheEntry = cache.get(type);
-		if (cacheEntry !== undefined) {
-			return cacheEntry;
-		}
-		const hooks = [];
-		const typeParts = type.split(".");
-		for (let i = 0; i < typeParts.length; i++) {
-			const hook = hookMap.get(typeParts.slice(i).join("."));
-			if (hook) {
-				hooks.push(hook);
-			}
-		}
-		cache.set(type, hooks);
-		return hooks;
+class GetChunkFilenameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} contentType the contentType to use the content hash for
+	 * @param {string} name kind of filename
+	 * @param {string} global function name to be assigned
+	 * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
+	 * @param {boolean} allChunks when false, only async chunks are included
+	 */
+	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
+		super(`get ${name} chunk filename`);
+		this.contentType = contentType;
+		this.global = global;
+		this.getFilenameForChunk = getFilenameForChunk;
+		this.allChunks = allChunks;
+		this.dependentHash = true;
 	}
 
-	_forEachLevel(hookMap, cache, type, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-			const result = fn(hook);
-			if (result !== undefined) return result;
-		}
-	}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const {
+			global,
+			chunk,
+			chunkGraph,
+			contentType,
+			getFilenameForChunk,
+			allChunks,
+			compilation
+		} = this;
+		const { runtimeTemplate } = compilation;
 
-	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-			data = fn(hook, data);
-		}
-		return data;
-	}
+		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
+		const chunkFilenames = new Map();
+		let maxChunks = 0;
+		/** @type {string} */
+		let dynamicFilename;
 
-	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
-		const hooks = this._getAllLevelHooks(hookMap, cache, type);
-		if (hooks.length === 0) return forceClone ? items.slice() : items;
-		let i = 0;
-		return items.filter((item, idx) => {
-			for (const hook of hooks) {
-				const r = fn(hook, item, idx, i);
-				if (r !== undefined) {
-					if (r) i++;
-					return r;
+		/**
+		 * @param {Chunk} c the chunk
+		 * @returns {void}
+		 */
+		const addChunk = c => {
+			const chunkFilename = getFilenameForChunk(c);
+			if (chunkFilename) {
+				let set = chunkFilenames.get(chunkFilename);
+				if (set === undefined) {
+					chunkFilenames.set(chunkFilename, (set = new Set()));
+				}
+				set.add(c);
+				if (typeof chunkFilename === "string") {
+					if (set.size < maxChunks) return;
+					if (set.size === maxChunks) {
+						if (chunkFilename.length < dynamicFilename.length) return;
+						if (chunkFilename.length === dynamicFilename.length) {
+							if (chunkFilename < dynamicFilename) return;
+						}
+					}
+					maxChunks = set.size;
+					dynamicFilename = chunkFilename;
 				}
 			}
-			i++;
-			return true;
-		});
-	}
+		};
 
-	/**
-	 * @param {string} type type
-	 * @param {any} data factory data
-	 * @param {Omit<StatsFactoryContext, "type">} baseContext context used as base
-	 * @returns {any} created object
-	 */
-	create(type, data, baseContext) {
-		if (this._inCreate) {
-			return this._create(type, data, baseContext);
+		/** @type {string[]} */
+		const includedChunksMessages = [];
+		if (allChunks) {
+			includedChunksMessages.push("all chunks");
+			for (const c of chunk.getAllReferencedChunks()) {
+				addChunk(c);
+			}
 		} else {
-			try {
-				this._inCreate = true;
-				return this._create(type, data, baseContext);
-			} finally {
-				for (const key of Object.keys(this._caches)) this._caches[key].clear();
-				this._inCreate = false;
+			includedChunksMessages.push("async chunks");
+			for (const c of chunk.getAllAsyncChunks()) {
+				addChunk(c);
 			}
-		}
-	}
-
-	_create(type, data, baseContext) {
-		const context = {
-			...baseContext,
-			type,
-			[type]: data
-		};
-		if (Array.isArray(data)) {
-			// run filter on unsorted items
-			const items = this._forEachLevelFilter(
-				this.hooks.filter,
-				this._caches.filter,
-				type,
-				data,
-				(h, r, idx, i) => h.call(r, context, idx, i),
-				true
-			);
-
-			// sort items
-			const comparators = [];
-			this._forEachLevel(this.hooks.sort, this._caches.sort, type, h =>
-				h.call(comparators, context)
-			);
-			if (comparators.length > 0) {
-				items.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators, keepOriginalOrder(items))
-				);
+			const includeEntries = chunkGraph
+				.getTreeRuntimeRequirements(chunk)
+				.has(RuntimeGlobals.ensureChunkIncludeEntries);
+			if (includeEntries) {
+				includedChunksMessages.push("sibling chunks for the entrypoint");
+				for (const c of chunkGraph.getChunkEntryDependentChunksIterable(
+					chunk
+				)) {
+					addChunk(c);
+				}
 			}
+		}
+		for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {
+			addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
+		}
 
-			// run filter on sorted items
-			const items2 = this._forEachLevelFilter(
-				this.hooks.filterSorted,
-				this._caches.filterSorted,
-				type,
-				items,
-				(h, r, idx, i) => h.call(r, context, idx, i),
-				false
-			);
-
-			// for each item
-			let resultItems = items2.map((item, i) => {
-				const itemContext = {
-					...context,
-					_index: i
-				};
-
-				// run getItemName
-				const itemName = this._forEachLevel(
-					this.hooks.getItemName,
-					this._caches.getItemName,
-					`${type}[]`,
-					h => h.call(item, itemContext)
-				);
-				if (itemName) itemContext[itemName] = item;
-				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
-
-				// run getItemFactory
-				const itemFactory =
-					this._forEachLevel(
-						this.hooks.getItemFactory,
-						this._caches.getItemFactory,
-						innerType,
-						h => h.call(item, itemContext)
-					) || this;
+		/** @type {Map<string, Set<string | number>>} */
+		const staticUrls = new Map();
+		/** @type {Set<Chunk>} */
+		const dynamicUrlChunks = new Set();
 
-				// run item factory
-				return itemFactory.create(innerType, item, itemContext);
+		/**
+		 * @param {Chunk} c the chunk
+		 * @param {string | FilenameFunction} chunkFilename the filename template for the chunk
+		 * @returns {void}
+		 */
+		const addStaticUrl = (c, chunkFilename) => {
+			/**
+			 * @param {string | number} value a value
+			 * @returns {string} string to put in quotes
+			 */
+			const unquotedStringify = value => {
+				const str = `${value}`;
+				if (str.length >= 5 && str === `${c.id}`) {
+					// This is shorter and generates the same result
+					return '" + chunkId + "';
+				}
+				const s = JSON.stringify(str);
+				return s.slice(1, s.length - 1);
+			};
+			const unquotedStringifyWithLength = value => length =>
+				unquotedStringify(`${value}`.slice(0, length));
+			const chunkFilenameValue =
+				typeof chunkFilename === "function"
+					? JSON.stringify(
+							chunkFilename({
+								chunk: c,
+								contentHashType: contentType
+							})
+					  )
+					: JSON.stringify(chunkFilename);
+			const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				chunk: {
+					id: unquotedStringify(c.id),
+					hash: unquotedStringify(c.renderedHash),
+					hashWithLength: unquotedStringifyWithLength(c.renderedHash),
+					name: unquotedStringify(c.name || c.id),
+					contentHash: {
+						[contentType]: unquotedStringify(c.contentHash[contentType])
+					},
+					contentHashWithLength: {
+						[contentType]: unquotedStringifyWithLength(
+							c.contentHash[contentType]
+						)
+					}
+				},
+				contentHashType: contentType
 			});
+			let set = staticUrls.get(staticChunkFilename);
+			if (set === undefined) {
+				staticUrls.set(staticChunkFilename, (set = new Set()));
+			}
+			set.add(c.id);
+		};
 
-			// sort result items
-			const comparators2 = [];
-			this._forEachLevel(
-				this.hooks.sortResults,
-				this._caches.sortResults,
-				type,
-				h => h.call(comparators2, context)
-			);
-			if (comparators2.length > 0) {
-				resultItems.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators2, keepOriginalOrder(resultItems))
-				);
+		for (const [filename, chunks] of chunkFilenames) {
+			if (filename !== dynamicFilename) {
+				for (const c of chunks) addStaticUrl(c, filename);
+			} else {
+				for (const c of chunks) dynamicUrlChunks.add(c);
 			}
+		}
 
-			// group result items
-			const groupConfigs = [];
-			this._forEachLevel(
-				this.hooks.groupResults,
-				this._caches.groupResults,
-				type,
-				h => h.call(groupConfigs, context)
-			);
-			if (groupConfigs.length > 0) {
-				resultItems = smartGrouping(resultItems, groupConfigs);
+		/**
+		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @returns {string} code with static mapping of results of fn
+		 */
+		const createMap = fn => {
+			const obj = {};
+			let useId = false;
+			let lastKey;
+			let entries = 0;
+			for (const c of dynamicUrlChunks) {
+				const value = fn(c);
+				if (value === c.id) {
+					useId = true;
+				} else {
+					obj[c.id] = value;
+					lastKey = c.id;
+					entries++;
+				}
+			}
+			if (entries === 0) return "chunkId";
+			if (entries === 1) {
+				return useId
+					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
+							obj[lastKey]
+					  )} : chunkId)`
+					: JSON.stringify(obj[lastKey]);
 			}
+			return useId
+				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
+				: `${JSON.stringify(obj)}[chunkId]`;
+		};
 
-			// run filter on sorted result items
-			const finalResultItems = this._forEachLevelFilter(
-				this.hooks.filterResults,
-				this._caches.filterResults,
-				type,
-				resultItems,
-				(h, r, idx, i) => h.call(r, context, idx, i),
-				false
-			);
+		/**
+		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @returns {string} code with static mapping of results of fn for including in quoted string
+		 */
+		const mapExpr = fn => {
+			return `" + ${createMap(fn)} + "`;
+		};
 
-			// run merge on mapped items
-			let result = this._forEachLevel(
-				this.hooks.merge,
-				this._caches.merge,
-				type,
-				h => h.call(finalResultItems, context)
-			);
-			if (result === undefined) result = finalResultItems;
+		/**
+		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
+		 */
+		const mapExprWithLength = fn => length => {
+			return `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
+		};
 
-			// run result on merged items
-			return this._forEachLevelWaterfall(
-				this.hooks.result,
-				this._caches.result,
-				type,
-				result,
-				(h, r) => h.call(r, context)
-			);
-		} else {
-			const object = {};
+		const url =
+			dynamicFilename &&
+			compilation.getPath(JSON.stringify(dynamicFilename), {
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				chunk: {
+					id: `" + chunkId + "`,
+					hash: mapExpr(c => c.renderedHash),
+					hashWithLength: mapExprWithLength(c => c.renderedHash),
+					name: mapExpr(c => c.name || c.id),
+					contentHash: {
+						[contentType]: mapExpr(c => c.contentHash[contentType])
+					},
+					contentHashWithLength: {
+						[contentType]: mapExprWithLength(c => c.contentHash[contentType])
+					}
+				},
+				contentHashType: contentType
+			});
 
-			// run extract on value
-			this._forEachLevel(this.hooks.extract, this._caches.extract, type, h =>
-				h.call(object, data, context)
-			);
+		return Template.asString([
+			`// This function allow to reference ${includedChunksMessages.join(
+				" and "
+			)}`,
+			`${global} = ${runtimeTemplate.basicFunction(
+				"chunkId",
 
-			// run result on extracted object
-			return this._forEachLevelWaterfall(
-				this.hooks.result,
-				this._caches.result,
-				type,
-				object,
-				(h, r) => h.call(r, context)
-			);
-		}
+				staticUrls.size > 0
+					? [
+							"// return url for filenames not based on template",
+							// it minimizes to `x===1?"...":x===2?"...":"..."`
+							Template.asString(
+								Array.from(staticUrls, ([url, ids]) => {
+									const condition =
+										ids.size === 1
+											? `chunkId === ${JSON.stringify(first(ids))}`
+											: `{${Array.from(
+													ids,
+													id => `${JSON.stringify(id)}:1`
+											  ).join(",")}}[chunkId]`;
+									return `if (${condition}) return ${url};`;
+								})
+							),
+							"// return url for filenames based on template",
+							`return ${url};`
+					  ]
+					: ["// return url for filenames based on template", `return ${url};`]
+			)};`
+		]);
 	}
 }
-module.exports = StatsFactory;
+
+module.exports = GetChunkFilenameRuntimeModule;
 
 
 /***/ }),
 
-/***/ 30198:
+/***/ 88732:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { HookMap, SyncWaterfallHook, SyncBailHook } = __webpack_require__(6967);
-
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
-/** @typedef {import("tapable").Hook} Hook */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
-
-/**
- * @typedef {Object} PrintedElement
- * @property {string} element
- * @property {string} content
- */
-
-/**
- * @typedef {Object} KnownStatsPrinterContext
- * @property {string=} type
- * @property {StatsCompilation=} compilation
- * @property {StatsChunkGroup=} chunkGroup
- * @property {StatsAsset=} asset
- * @property {StatsModule=} module
- * @property {StatsChunk=} chunk
- * @property {StatsModuleReason=} moduleReason
- * @property {(str: string) => string=} bold
- * @property {(str: string) => string=} yellow
- * @property {(str: string) => string=} red
- * @property {(str: string) => string=} green
- * @property {(str: string) => string=} magenta
- * @property {(str: string) => string=} cyan
- * @property {(file: string, oversize?: boolean) => string=} formatFilename
- * @property {(id: string) => string=} formatModuleId
- * @property {(id: string, direction?: "parent"|"child"|"sibling") => string=} formatChunkId
- * @property {(size: number) => string=} formatSize
- * @property {(dateTime: number) => string=} formatDateTime
- * @property {(flag: string) => string=} formatFlag
- * @property {(time: number, boldQuantity?: boolean) => string=} formatTime
- * @property {string=} chunkGroupKind
- */
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-/** @typedef {KnownStatsPrinterContext & Record<string, any>} StatsPrinterContext */
+/** @typedef {import("../Compilation")} Compilation */
 
-class StatsPrinter {
+class GetFullHashRuntimeModule extends RuntimeModule {
 	constructor() {
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], true>>} */
-			sortElements: new HookMap(
-				() => new SyncBailHook(["elements", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string>>} */
-			printElements: new HookMap(
-				() => new SyncBailHook(["printedElements", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>} */
-			sortItems: new HookMap(() => new SyncBailHook(["items", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsPrinterContext], string>>} */
-			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
-			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>} */
-			printItems: new HookMap(
-				() => new SyncBailHook(["printedItems", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>} */
-			print: new HookMap(() => new SyncBailHook(["object", "context"])),
-			/** @type {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} */
-			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
-		});
-		/** @type {Map<HookMap<Hook>, Map<string, Hook[]>>} */
-		this._levelHookCache = new Map();
-		this._inPrint = false;
+		super("getFullHash");
+		this.fullHash = true;
 	}
 
 	/**
-	 * get all level hooks
-	 * @private
-	 * @template {Hook} T
-	 * @param {HookMap<T>} hookMap HookMap
-	 * @param {string} type type
-	 * @returns {T[]} hooks
+	 * @returns {string} runtime code
 	 */
-	_getAllLevelHooks(hookMap, type) {
-		let cache = /** @type {Map<string, T[]>} */ (
-			this._levelHookCache.get(hookMap)
-		);
-		if (cache === undefined) {
-			cache = new Map();
-			this._levelHookCache.set(hookMap, cache);
-		}
-		const cacheEntry = cache.get(type);
-		if (cacheEntry !== undefined) {
-			return cacheEntry;
-		}
-		/** @type {T[]} */
-		const hooks = [];
-		const typeParts = type.split(".");
-		for (let i = 0; i < typeParts.length; i++) {
-			const hook = hookMap.get(typeParts.slice(i).join("."));
-			if (hook) {
-				hooks.push(hook);
-			}
-		}
-		cache.set(type, hooks);
-		return hooks;
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(
+			JSON.stringify(this.compilation.hash || "XXXX")
+		)}`;
 	}
+}
 
-	/**
-	 * Run `fn` for each level
-	 * @private
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap HookMap
-	 * @param {string} type type
-	 * @param {(hook: SyncBailHook<T, R>) => R} fn function
-	 * @returns {R} result of `fn`
-	 */
-	_forEachLevel(hookMap, type, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, type)) {
-			const result = fn(hook);
-			if (result !== undefined) return result;
-		}
-	}
+module.exports = GetFullHashRuntimeModule;
 
-	/**
-	 * Run `fn` for each level
-	 * @private
-	 * @template T
-	 * @param {HookMap<SyncWaterfallHook<T>>} hookMap HookMap
-	 * @param {string} type type
-	 * @param {AsArray<T>[0]} data data
-	 * @param {(hook: SyncWaterfallHook<T>, data: AsArray<T>[0]) => AsArray<T>[0]} fn function
-	 * @returns {AsArray<T>[0]} result of `fn`
-	 */
-	_forEachLevelWaterfall(hookMap, type, data, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, type)) {
-			data = fn(hook, data);
-		}
-		return data;
-	}
 
+/***/ }),
+
+/***/ 10029:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class GetMainFilenameRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {string} type The type
-	 * @param {Object} object Object to print
-	 * @param {Object=} baseContext The base context
-	 * @returns {string} printed result
+	 * @param {string} name readable name
+	 * @param {string} global global object binding
+	 * @param {string} filename main file name
 	 */
-	print(type, object, baseContext) {
-		if (this._inPrint) {
-			return this._print(type, object, baseContext);
-		} else {
-			try {
-				this._inPrint = true;
-				return this._print(type, object, baseContext);
-			} finally {
-				this._levelHookCache.clear();
-				this._inPrint = false;
-			}
-		}
+	constructor(name, global, filename) {
+		super(`get ${name} filename`);
+		this.global = global;
+		this.filename = filename;
 	}
 
 	/**
-	 * @private
-	 * @param {string} type type
-	 * @param {Object} object object
-	 * @param {Object=} baseContext context
-	 * @returns {string} printed result
+	 * @returns {string} runtime code
 	 */
-	_print(type, object, baseContext) {
-		const context = {
-			...baseContext,
-			type,
-			[type]: object
-		};
-
-		let printResult = this._forEachLevel(this.hooks.print, type, hook =>
-			hook.call(object, context)
-		);
-		if (printResult === undefined) {
-			if (Array.isArray(object)) {
-				const sortedItems = object.slice();
-				this._forEachLevel(this.hooks.sortItems, type, h =>
-					h.call(sortedItems, context)
-				);
-				const printedItems = sortedItems.map((item, i) => {
-					const itemContext = {
-						...context,
-						_index: i
-					};
-					const itemName = this._forEachLevel(
-						this.hooks.getItemName,
-						`${type}[]`,
-						h => h.call(item, itemContext)
-					);
-					if (itemName) itemContext[itemName] = item;
-					return this.print(
-						itemName ? `${type}[].${itemName}` : `${type}[]`,
-						item,
-						itemContext
-					);
-				});
-				printResult = this._forEachLevel(this.hooks.printItems, type, h =>
-					h.call(printedItems, context)
-				);
-				if (printResult === undefined) {
-					const result = printedItems.filter(Boolean);
-					if (result.length > 0) printResult = result.join("\n");
-				}
-			} else if (object !== null && typeof object === "object") {
-				const elements = Object.keys(object).filter(
-					key => object[key] !== undefined
-				);
-				this._forEachLevel(this.hooks.sortElements, type, h =>
-					h.call(elements, context)
-				);
-				const printedElements = elements.map(element => {
-					const content = this.print(`${type}.${element}`, object[element], {
-						...context,
-						_parent: object,
-						_element: element,
-						[element]: object[element]
-					});
-					return { element, content };
-				});
-				printResult = this._forEachLevel(this.hooks.printElements, type, h =>
-					h.call(printedElements, context)
-				);
-				if (printResult === undefined) {
-					const result = printedElements.map(e => e.content).filter(Boolean);
-					if (result.length > 0) printResult = result.join("\n");
-				}
-			}
-		}
-
-		return this._forEachLevelWaterfall(
-			this.hooks.result,
-			type,
-			printResult,
-			(h, r) => h.call(r, context)
-		);
+	generate() {
+		const { global, filename, compilation, chunk } = this;
+		const { runtimeTemplate } = compilation;
+		const url = compilation.getPath(JSON.stringify(filename), {
+			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+			hashWithLength: length =>
+				`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+			chunk,
+			runtime: chunk.runtime
+		});
+		return Template.asString([
+			`${global} = ${runtimeTemplate.returningFunction(url)};`
+		]);
 	}
 }
-module.exports = StatsPrinter;
+
+module.exports = GetMainFilenameRuntimeModule;
 
 
 /***/ }),
 
-/***/ 84953:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 38713:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-/**
- * Compare two arrays or strings by performing strict equality check for each value.
- * @template T [T=any]
- * @param {ArrayLike<T>} a Array of values to be compared
- * @param {ArrayLike<T>} b Array of values to be compared
- * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
- */
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-exports.equals = (a, b) => {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		if (a[i] !== b[i]) return false;
+class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
+		super("trusted types policy");
+		this.runtimeRequirements = runtimeRequirements;
 	}
-	return true;
-};
 
-/**
- * Partition an array by calling a predicate function on each value.
- * @template T [T=any]
- * @param {Array<T>} arr Array of values to be partitioned
- * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
- * @returns {[Array<T>, Array<T>]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
- */
-exports.groupBy = (arr = [], fn) => {
-	return arr.reduce(
-		/**
-		 * @param {[Array<T>, Array<T>]} groups An accumulator storing already partitioned values returned from previous call.
-		 * @param {T} value The value of the current element
-		 * @returns {[Array<T>, Array<T>]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
-		 */
-		(groups, value) => {
-			groups[fn(value) ? 0 : 1].push(value);
-			return groups;
-		},
-		[[], []]
-	);
-};
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.getTrustedTypesPolicy;
+
+		return Template.asString([
+			"var policy;",
+			`${fn} = ${runtimeTemplate.basicFunction("", [
+				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
+				"if (policy === undefined) {",
+				Template.indent([
+					"policy = {",
+					Template.indent(
+						[
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
+								? [
+										`createScript: ${runtimeTemplate.returningFunction(
+											"script",
+											"script"
+										)}`
+								  ]
+								: []),
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
+								? [
+										`createScriptURL: ${runtimeTemplate.returningFunction(
+											"url",
+											"url"
+										)}`
+								  ]
+								: [])
+						].join(",\n")
+					),
+					"};",
+					...(trustedTypes
+						? [
+								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+								Template.indent([
+									`policy = trustedTypes.createPolicy(${JSON.stringify(
+										trustedTypes.policyName
+									)}, policy);`
+								]),
+								"}"
+						  ]
+						: [])
+				]),
+				"}",
+				"return policy;"
+			])};`
+		]);
+	}
+}
+
+module.exports = GetTrustedTypesPolicyRuntimeModule;
 
 
 /***/ }),
 
-/***/ 41792:
-/***/ (function(module) {
+/***/ 23255:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-/**
- * @template T
- */
-class ArrayQueue {
-	/**
-	 * @param {Iterable<T>=} items The initial elements.
-	 */
-	constructor(items) {
-		/** @private @type {T[]} */
-		this._list = items ? Array.from(items) : [];
-		/** @private @type {T[]} */
-		this._listReversed = [];
-	}
-
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this._list.length + this._listReversed.length;
-	}
-
-	/**
-	 * Empties the queue.
-	 */
-	clear() {
-		this._list.length = 0;
-		this._listReversed.length = 0;
-	}
-
-	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
-	 */
-	enqueue(item) {
-		this._list.push(item);
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
-	 */
-	dequeue() {
-		if (this._listReversed.length === 0) {
-			if (this._list.length === 0) return undefined;
-			if (this._list.length === 1) return this._list.pop();
-			if (this._list.length < 16) return this._list.shift();
-			const temp = this._listReversed;
-			this._listReversed = this._list;
-			this._listReversed.reverse();
-			this._list = temp;
-		}
-		return this._listReversed.pop();
+class GlobalRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("global");
 	}
 
 	/**
-	 * Finds and removes an item
-	 * @param {T} item the item
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	delete(item) {
-		const i = this._list.indexOf(item);
-		if (i >= 0) {
-			this._list.splice(i, 1);
-		} else {
-			const i = this._listReversed.indexOf(item);
-			if (i >= 0) this._listReversed.splice(i, 1);
-		}
-	}
-
-	[Symbol.iterator]() {
-		let i = -1;
-		let reversed = false;
-		return {
-			next: () => {
-				if (!reversed) {
-					i++;
-					if (i < this._list.length) {
-						return {
-							done: false,
-							value: this._list[i]
-						};
-					}
-					reversed = true;
-					i = this._listReversed.length;
-				}
-				i--;
-				if (i < 0) {
-					return {
-						done: true,
-						value: undefined
-					};
-				}
-				return {
-					done: false,
-					value: this._listReversed[i]
-				};
-			}
-		};
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.global} = (function() {`,
+			Template.indent([
+				"if (typeof globalThis === 'object') return globalThis;",
+				"try {",
+				Template.indent(
+					// This works in non-strict mode
+					// or
+					// This works if eval is allowed (see CSP)
+					"return this || new Function('return this')();"
+				),
+				"} catch (e) {",
+				Template.indent(
+					// This works if the window reference is available
+					"if (typeof window === 'object') return window;"
+				),
+				"}"
+				// It can still be `undefined`, but nothing to do about it...
+				// We return `undefined`, instead of nothing here, so it's
+				// easier to handle this case:
+				//   if (!global) { … }
+			]),
+			"})();"
+		]);
 	}
 }
 
-module.exports = ArrayQueue;
+module.exports = GlobalRuntimeModule;
 
 
 /***/ }),
 
-/***/ 12260:
+/***/ 8011:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const { SyncHook, AsyncSeriesHook } = __webpack_require__(6967);
-const { makeWebpackError } = __webpack_require__(11351);
-const WebpackError = __webpack_require__(53799);
-const ArrayQueue = __webpack_require__(41792);
-
-const QUEUED_STATE = 0;
-const PROCESSING_STATE = 1;
-const DONE_STATE = 2;
-
-let inHandleResult = 0;
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-/**
- * @template T
- * @callback Callback
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- */
+class HasOwnPropertyRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("hasOwnProperty shorthand");
+	}
 
-/**
- * @template T
- * @template K
- * @template R
- */
-class AsyncQueueEntry {
 	/**
-	 * @param {T} item the item
-	 * @param {Callback<R>} callback the callback
+	 * @returns {string} runtime code
 	 */
-	constructor(item, callback) {
-		this.item = item;
-		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
-		this.state = QUEUED_STATE;
-		this.callback = callback;
-		/** @type {Callback<R>[] | undefined} */
-		this.callbacks = undefined;
-		this.result = undefined;
-		/** @type {WebpackError | undefined} */
-		this.error = undefined;
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+
+		return Template.asString([
+			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(
+				"Object.prototype.hasOwnProperty.call(obj, prop)",
+				"obj, prop"
+			)}`
+		]);
 	}
 }
 
-/**
- * @template T
- * @template K
- * @template R
- */
-class AsyncQueue {
-	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.name name of the queue
-	 * @param {number=} options.parallelism how many items should be processed at once
-	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
-	 * @param {function(T): K=} options.getKey extract key from item
-	 * @param {function(T, Callback<R>): void} options.processor async function to process items
-	 */
-	constructor({ name, parallelism, parent, processor, getKey }) {
-		this._name = name;
-		this._parallelism = parallelism || 1;
-		this._processor = processor;
-		this._getKey =
-			getKey || /** @type {(T) => K} */ (item => /** @type {any} */ (item));
-		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
-		this._entries = new Map();
-		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
-		this._queued = new ArrayQueue();
-		/** @type {AsyncQueue<any, any, any>[]} */
-		this._children = undefined;
-		this._activeTasks = 0;
-		this._willEnsureProcessing = false;
-		this._needProcessing = false;
-		this._stopped = false;
-		this._root = parent ? parent._root : this;
-		if (parent) {
-			if (this._root._children === undefined) {
-				this._root._children = [this];
-			} else {
-				this._root._children.push(this);
-			}
-		}
+module.exports = HasOwnPropertyRuntimeModule;
 
-		this.hooks = {
-			/** @type {AsyncSeriesHook<[T]>} */
-			beforeAdd: new AsyncSeriesHook(["item"]),
-			/** @type {SyncHook<[T]>} */
-			added: new SyncHook(["item"]),
-			/** @type {AsyncSeriesHook<[T]>} */
-			beforeStart: new AsyncSeriesHook(["item"]),
-			/** @type {SyncHook<[T]>} */
-			started: new SyncHook(["item"]),
-			/** @type {SyncHook<[T, Error, R]>} */
-			result: new SyncHook(["item", "error", "result"])
-		};
 
-		this._ensureProcessing = this._ensureProcessing.bind(this);
-	}
+/***/ }),
 
-	/**
-	 * @param {T} item an item
-	 * @param {Callback<R>} callback callback function
-	 * @returns {void}
-	 */
-	add(item, callback) {
-		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
-		this.hooks.beforeAdd.callAsync(item, err => {
-			if (err) {
-				callback(
-					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeAdd`)
-				);
-				return;
-			}
-			const key = this._getKey(item);
-			const entry = this._entries.get(key);
-			if (entry !== undefined) {
-				if (entry.state === DONE_STATE) {
-					if (inHandleResult++ > 3) {
-						process.nextTick(() => callback(entry.error, entry.result));
-					} else {
-						callback(entry.error, entry.result);
-					}
-					inHandleResult--;
-				} else if (entry.callbacks === undefined) {
-					entry.callbacks = [callback];
-				} else {
-					entry.callbacks.push(callback);
-				}
-				return;
-			}
-			const newEntry = new AsyncQueueEntry(item, callback);
-			if (this._stopped) {
-				this.hooks.added.call(item);
-				this._root._activeTasks++;
-				process.nextTick(() =>
-					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
-				);
-			} else {
-				this._entries.set(key, newEntry);
-				this._queued.enqueue(newEntry);
-				const root = this._root;
-				root._needProcessing = true;
-				if (root._willEnsureProcessing === false) {
-					root._willEnsureProcessing = true;
-					setImmediate(root._ensureProcessing);
-				}
-				this.hooks.added.call(item);
-			}
-		});
-	}
+/***/ 82444:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {T} item an item
-	 * @returns {void}
-	 */
-	invalidate(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		this._entries.delete(key);
-		if (entry.state === QUEUED_STATE) {
-			this._queued.delete(entry);
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-	/**
-	 * Waits for an already started item
-	 * @param {T} item an item
-	 * @param {Callback<R>} callback callback function
-	 * @returns {void}
-	 */
-	waitFor(item, callback) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		if (entry === undefined) {
-			return callback(
-				new WebpackError(
-					"waitFor can only be called for an already started item"
-				)
-			);
-		}
-		if (entry.state === DONE_STATE) {
-			process.nextTick(() => callback(entry.error, entry.result));
-		} else if (entry.callbacks === undefined) {
-			entry.callbacks = [callback];
-		} else {
-			entry.callbacks.push(callback);
-		}
-	}
 
-	/**
-	 * @returns {void}
-	 */
-	stop() {
-		this._stopped = true;
-		const queue = this._queued;
-		this._queued = new ArrayQueue();
-		const root = this._root;
-		for (const entry of queue) {
-			this._entries.delete(this._getKey(entry.item));
-			root._activeTasks++;
-			this._handleResult(entry, new WebpackError("Queue was stopped"));
-		}
-	}
 
-	/**
-	 * @returns {void}
-	 */
-	increaseParallelism() {
-		const root = this._root;
-		root._parallelism++;
-		/* istanbul ignore next */
-		if (root._willEnsureProcessing === false && root._needProcessing) {
-			root._willEnsureProcessing = true;
-			setImmediate(root._ensureProcessing);
-		}
-	}
+const RuntimeModule = __webpack_require__(16963);
 
+class HelperRuntimeModule extends RuntimeModule {
 	/**
-	 * @returns {void}
+	 * @param {string} name a readable name
 	 */
-	decreaseParallelism() {
-		const root = this._root;
-		root._parallelism--;
+	constructor(name) {
+		super(name);
 	}
+}
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, if the item is currently being processed
-	 */
-	isProcessing(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		return entry !== undefined && entry.state === PROCESSING_STATE;
-	}
+module.exports = HelperRuntimeModule;
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, if the item is currently queued
-	 */
-	isQueued(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		return entry !== undefined && entry.state === QUEUED_STATE;
-	}
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, if the item is currently queued
-	 */
-	isDone(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		return entry !== undefined && entry.state === DONE_STATE;
-	}
+/***/ }),
+
+/***/ 19942:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const { SyncWaterfallHook } = __webpack_require__(41242);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {Object} LoadScriptCompilationHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} createScript
+ */
+
+/** @type {WeakMap<Compilation, LoadScriptCompilationHooks>} */
+const compilationHooksMap = new WeakMap();
+
+class LoadScriptRuntimeModule extends HelperRuntimeModule {
 	/**
-	 * @returns {void}
+	 * @param {Compilation} compilation the compilation
+	 * @returns {LoadScriptCompilationHooks} hooks
 	 */
-	_ensureProcessing() {
-		while (this._activeTasks < this._parallelism) {
-			const entry = this._queued.dequeue();
-			if (entry === undefined) break;
-			this._activeTasks++;
-			entry.state = PROCESSING_STATE;
-			this._startProcessing(entry);
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
 		}
-		this._willEnsureProcessing = false;
-		if (this._queued.length > 0) return;
-		if (this._children !== undefined) {
-			for (const child of this._children) {
-				while (this._activeTasks < this._parallelism) {
-					const entry = child._queued.dequeue();
-					if (entry === undefined) break;
-					this._activeTasks++;
-					entry.state = PROCESSING_STATE;
-					child._startProcessing(entry);
-				}
-				if (child._queued.length > 0) return;
-			}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				createScript: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
 		}
-		if (!this._willEnsureProcessing) this._needProcessing = false;
+		return hooks;
 	}
 
 	/**
-	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
-	 * @returns {void}
+	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
 	 */
-	_startProcessing(entry) {
-		this.hooks.beforeStart.callAsync(entry.item, err => {
-			if (err) {
-				this._handleResult(
-					entry,
-					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeStart`)
-				);
-				return;
-			}
-			let inCallback = false;
-			try {
-				this._processor(entry.item, (e, r) => {
-					inCallback = true;
-					this._handleResult(entry, e, r);
-				});
-			} catch (err) {
-				if (inCallback) throw err;
-				this._handleResult(entry, err, null);
-			}
-			this.hooks.started.call(entry.item);
-		});
+	constructor(withCreateScriptUrl) {
+		super("load script");
+		this._withCreateScriptUrl = withCreateScriptUrl;
 	}
 
 	/**
-	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
-	 * @param {WebpackError=} err error, if any
-	 * @param {R=} result result, if any
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	_handleResult(entry, err, result) {
-		this.hooks.result.callAsync(entry.item, err, result, hookError => {
-			const error = hookError
-				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
-				: err;
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const {
+			scriptType,
+			chunkLoadTimeout: loadTimeout,
+			crossOriginLoading,
+			uniqueName,
+			charset
+		} = outputOptions;
+		const fn = RuntimeGlobals.loadScript;
 
-			const callback = entry.callback;
-			const callbacks = entry.callbacks;
-			entry.state = DONE_STATE;
-			entry.callback = undefined;
-			entry.callbacks = undefined;
-			entry.result = result;
-			entry.error = error;
+		const { createScript } =
+			LoadScriptRuntimeModule.getCompilationHooks(compilation);
 
-			const root = this._root;
-			root._activeTasks--;
-			if (root._willEnsureProcessing === false && root._needProcessing) {
-				root._willEnsureProcessing = true;
-				setImmediate(root._ensureProcessing);
-			}
+		const code = Template.asString([
+			"script = document.createElement('script');",
+			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
+			charset ? "script.charset = 'utf-8';" : "",
+			`script.timeout = ${loadTimeout / 1000};`,
+			`if (${RuntimeGlobals.scriptNonce}) {`,
+			Template.indent(
+				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+			),
+			"}",
+			uniqueName
+				? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);'
+				: "",
+			`script.src = ${
+				this._withCreateScriptUrl
+					? `${RuntimeGlobals.createScriptUrl}(url)`
+					: "url"
+			};`,
+			crossOriginLoading
+				? Template.asString([
+						"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
+						Template.indent(
+							`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+						),
+						"}"
+				  ])
+				: ""
+		]);
 
-			if (inHandleResult++ > 3) {
-				process.nextTick(() => {
-					callback(error, result);
-					if (callbacks !== undefined) {
-						for (const callback of callbacks) {
-							callback(error, result);
-						}
-					}
-				});
-			} else {
-				callback(error, result);
-				if (callbacks !== undefined) {
-					for (const callback of callbacks) {
-						callback(error, result);
-					}
-				}
-			}
-			inHandleResult--;
-		});
+		return Template.asString([
+			"var inProgress = {};",
+			uniqueName
+				? `var dataWebpackPrefix = ${JSON.stringify(uniqueName + ":")};`
+				: "// data-webpack is not used as build has no uniqueName",
+			"// loadScript function to load a script via script tag",
+			`${fn} = ${runtimeTemplate.basicFunction("url, done, key, chunkId", [
+				"if(inProgress[url]) { inProgress[url].push(done); return; }",
+				"var script, needAttach;",
+				"if(key !== undefined) {",
+				Template.indent([
+					'var scripts = document.getElementsByTagName("script");',
+					"for(var i = 0; i < scripts.length; i++) {",
+					Template.indent([
+						"var s = scripts[i];",
+						`if(s.getAttribute("src") == url${
+							uniqueName
+								? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
+								: ""
+						}) { script = s; break; }`
+					]),
+					"}"
+				]),
+				"}",
+				"if(!script) {",
+				Template.indent([
+					"needAttach = true;",
+					createScript.call(code, this.chunk)
+				]),
+				"}",
+				"inProgress[url] = [done];",
+				"var onScriptComplete = " +
+					runtimeTemplate.basicFunction(
+						"prev, event",
+						Template.asString([
+							"// avoid mem leaks in IE.",
+							"script.onerror = script.onload = null;",
+							"clearTimeout(timeout);",
+							"var doneFns = inProgress[url];",
+							"delete inProgress[url];",
+							"script.parentNode && script.parentNode.removeChild(script);",
+							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
+								"fn(event)",
+								"fn"
+							)});`,
+							"if(prev) return prev(event);"
+						])
+					),
+				";",
+				`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
+				"script.onerror = onScriptComplete.bind(null, script.onerror);",
+				"script.onload = onScriptComplete.bind(null, script.onload);",
+				"needAttach && document.head.appendChild(script);"
+			])};`
+		]);
+	}
+}
+
+module.exports = LoadScriptRuntimeModule;
+
+
+/***/ }),
+
+/***/ 65714:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("make namespace object");
 	}
 
-	clear() {
-		this._entries.clear();
-		this._queued.clear();
-		this._activeTasks = 0;
-		this._willEnsureProcessing = false;
-		this._needProcessing = false;
-		this._stopped = false;
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.makeNamespaceObject;
+		return Template.asString([
+			"// define __esModule on exports",
+			`${fn} = ${runtimeTemplate.basicFunction("exports", [
+				"if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {",
+				Template.indent([
+					"Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });"
+				]),
+				"}",
+				"Object.defineProperty(exports, '__esModule', { value: true });"
+			])};`
+		]);
 	}
 }
 
-module.exports = AsyncQueue;
+module.exports = MakeNamespaceObjectRuntimeModule;
 
 
 /***/ }),
 
-/***/ 36692:
+/***/ 44518:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-class Hash {
-	/* istanbul ignore next */
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @abstract
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+
+class OnChunksLoadedRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("chunk loaded");
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @abstract
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
+	 * @returns {string} runtime code
 	 */
-	digest(encoding) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate } = compilation;
+		return Template.asString([
+			"var deferred = [];",
+			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
+				"result, chunkIds, fn, priority",
+				[
+					"if(chunkIds) {",
+					Template.indent([
+						"priority = priority || 0;",
+						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
+						"deferred[i] = [chunkIds, fn, priority];",
+						"return;"
+					]),
+					"}",
+					"var notFulfilled = Infinity;",
+					"for (var i = 0; i < deferred.length; i++) {",
+					Template.indent([
+						runtimeTemplate.destructureArray(
+							["chunkIds", "fn", "priority"],
+							"deferred[i]"
+						),
+						"var fulfilled = true;",
+						"for (var j = 0; j < chunkIds.length; j++) {",
+						Template.indent([
+							`if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${
+								RuntimeGlobals.onChunksLoaded
+							}).every(${runtimeTemplate.returningFunction(
+								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
+								"key"
+							)})) {`,
+							Template.indent(["chunkIds.splice(j--, 1);"]),
+							"} else {",
+							Template.indent([
+								"fulfilled = false;",
+								"if(priority < notFulfilled) notFulfilled = priority;"
+							]),
+							"}"
+						]),
+						"}",
+						"if(fulfilled) {",
+						Template.indent([
+							"deferred.splice(i--, 1)",
+							"var r = fn();",
+							"if (r !== undefined) result = r;"
+						]),
+						"}"
+					]),
+					"}",
+					"return result;"
+				]
+			)};`
+		]);
 	}
 }
 
-module.exports = Hash;
+module.exports = OnChunksLoadedRuntimeModule;
 
 
 /***/ }),
 
-/***/ 39104:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 56030:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-/**
- * @template T
- * @param {Iterable<T>} set a set
- * @returns {T | undefined} last item
- */
-const last = set => {
-	let last;
-	for (const item of set) last = item;
-	return last;
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-/**
- * @template T
- * @param {Iterable<T>} iterable iterable
- * @param {function(T): boolean} filter predicate
- * @returns {boolean} true, if some items match the filter predicate
- */
-const someInIterable = (iterable, filter) => {
-	for (const item of iterable) {
-		if (filter(item)) return true;
+class PublicPathRuntimeModule extends RuntimeModule {
+	constructor(publicPath) {
+		super("publicPath", RuntimeModule.STAGE_BASIC);
+		this.publicPath = publicPath;
 	}
-	return false;
-};
 
-/**
- * @template T
- * @param {Iterable<T>} iterable an iterable
- * @returns {number} count of items
- */
-const countIterable = iterable => {
-	let i = 0;
-	// eslint-disable-next-line no-unused-vars
-	for (const _ of iterable) i++;
-	return i;
-};
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, publicPath } = this;
 
-exports.last = last;
-exports.someInIterable = someInIterable;
-exports.countIterable = countIterable;
+		return `${RuntimeGlobals.publicPath} = ${JSON.stringify(
+			compilation.getPath(publicPath || "", {
+				hash: compilation.hash || "XXXX"
+			})
+		)};`;
+	}
+}
+
+module.exports = PublicPathRuntimeModule;
 
 
 /***/ }),
 
-/***/ 48424:
+/***/ 4537:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { first } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-/**
- * Multi layer bucket sorted set:
- * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
- * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET),
- * Supports popping the first items according to defined order,
- * Supports iterating all items without order,
- * Supports updating an item in an efficient way,
- * Supports size property, which is the number of items,
- * Items are lazy partially sorted when needed
- * @template T
- * @template K
- */
-class LazyBucketSortedSet {
-	/**
-	 * @param {function(T): K} getKey function to get key from item
-	 * @param {function(K, K): number} comparator comparator to sort keys
-	 * @param  {...((function(T): any) | (function(any, any): number))} args more pairs of getKey and comparator plus optional final comparator for the last layer
-	 */
-	constructor(getKey, comparator, ...args) {
-		this._getKey = getKey;
-		this._innerArgs = args;
-		this._leaf = args.length <= 1;
-		this._keys = new SortableSet(undefined, comparator);
-		/** @type {Map<K, LazyBucketSortedSet<T, any> | SortableSet<T>>} */
-		this._map = new Map();
-		this._unsortedItems = new Set();
-		this.size = 0;
+class RelativeUrlRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("relative url");
 	}
 
 	/**
-	 * @param {T} item an item
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	add(item) {
-		this.size++;
-		this._unsortedItems.add(item);
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
+			Template.indent([
+				'var realUrl = new URL(url, "x:/");',
+				"var values = {};",
+				"for (var key in realUrl) values[key] = realUrl[key];",
+				"values.href = url;",
+				'values.pathname = url.replace(/[?#].*/, "");',
+				'values.origin = values.protocol = "";',
+				`values.toString = values.toJSON = ${runtimeTemplate.returningFunction(
+					"url"
+				)};`,
+				"for (var key in values) Object.defineProperty(this, key, { enumerable: true, configurable: true, value: values[key] });"
+			]),
+			"};",
+			`${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`
+		]);
 	}
+}
 
-	/**
-	 * @param {K} key key of item
-	 * @param {T} item the item
-	 * @returns {void}
-	 */
-	_addInternal(key, item) {
-		let entry = this._map.get(key);
-		if (entry === undefined) {
-			entry = this._leaf
-				? new SortableSet(undefined, this._innerArgs[0])
-				: new /** @type {any} */ (LazyBucketSortedSet)(...this._innerArgs);
-			this._keys.add(key);
-			this._map.set(key, entry);
-		}
-		entry.add(item);
-	}
+module.exports = RelativeUrlRuntimeModule;
 
-	/**
-	 * @param {T} item an item
-	 * @returns {void}
-	 */
-	delete(item) {
-		this.size--;
-		if (this._unsortedItems.has(item)) {
-			this._unsortedItems.delete(item);
-			return;
-		}
-		const key = this._getKey(item);
-		const entry = this._map.get(key);
-		entry.delete(item);
-		if (entry.size === 0) {
-			this._deleteKey(key);
-		}
-	}
 
-	/**
-	 * @param {K} key key to be removed
-	 * @returns {void}
-	 */
-	_deleteKey(key) {
-		this._keys.delete(key);
-		this._map.delete(key);
-	}
+/***/ }),
 
-	/**
-	 * @returns {T | undefined} an item
-	 */
-	popFirst() {
-		if (this.size === 0) return undefined;
-		this.size--;
-		if (this._unsortedItems.size > 0) {
-			for (const item of this._unsortedItems) {
-				const key = this._getKey(item);
-				this._addInternal(key, item);
-			}
-			this._unsortedItems.clear();
-		}
-		this._keys.sort();
-		const key = first(this._keys);
-		const entry = this._map.get(key);
-		if (this._leaf) {
-			const leafEntry = /** @type {SortableSet<T>} */ (entry);
-			leafEntry.sort();
-			const item = first(leafEntry);
-			leafEntry.delete(item);
-			if (leafEntry.size === 0) {
-				this._deleteKey(key);
-			}
-			return item;
-		} else {
-			const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
-			const item = nodeEntry.popFirst();
-			if (nodeEntry.size === 0) {
-				this._deleteKey(key);
-			}
-			return item;
-		}
+/***/ 97115:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+class RuntimeIdRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("runtimeId");
 	}
 
 	/**
-	 * @param {T} item to be updated item
-	 * @returns {function(true=): void} finish update
+	 * @returns {string} runtime code
 	 */
-	startUpdate(item) {
-		if (this._unsortedItems.has(item)) {
-			return remove => {
-				if (remove) {
-					this._unsortedItems.delete(item);
-					this.size--;
-					return;
-				}
-			};
-		}
-		const key = this._getKey(item);
-		if (this._leaf) {
-			const oldEntry = /** @type {SortableSet<T>} */ (this._map.get(key));
-			return remove => {
-				if (remove) {
-					this.size--;
-					oldEntry.delete(item);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					return;
-				}
-				const newKey = this._getKey(item);
-				if (key === newKey) {
-					// This flags the sortable set as unordered
-					oldEntry.add(item);
-				} else {
-					oldEntry.delete(item);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					this._addInternal(newKey, item);
-				}
-			};
-		} else {
-			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
-				this._map.get(key)
-			);
-			const finishUpdate = oldEntry.startUpdate(item);
-			return remove => {
-				if (remove) {
-					this.size--;
-					finishUpdate(true);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					return;
-				}
-				const newKey = this._getKey(item);
-				if (key === newKey) {
-					finishUpdate();
-				} else {
-					finishUpdate(true);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					this._addInternal(newKey, item);
-				}
-			};
-		}
+	generate() {
+		const { chunkGraph, chunk } = this;
+		const runtime = chunk.runtime;
+		if (typeof runtime !== "string")
+			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
+		const id = chunkGraph.getRuntimeId(runtime);
+		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
 	}
+}
 
-	/**
-	 * @param {Iterator<T>[]} iterators list of iterators to append to
-	 * @returns {void}
-	 */
-	_appendIterators(iterators) {
-		if (this._unsortedItems.size > 0)
-			iterators.push(this._unsortedItems[Symbol.iterator]());
-		for (const key of this._keys) {
-			const entry = this._map.get(key);
-			if (this._leaf) {
-				const leafEntry = /** @type {SortableSet<T>} */ (entry);
-				const iterator = leafEntry[Symbol.iterator]();
-				iterators.push(iterator);
-			} else {
-				const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
-				nodeEntry._appendIterators(iterators);
-			}
-		}
+module.exports = RuntimeIdRuntimeModule;
+
+
+/***/ }),
+
+/***/ 22339:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const StartupChunkDependenciesRuntimeModule = __webpack_require__(38157);
+const StartupEntrypointRuntimeModule = __webpack_require__(97672);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class StartupChunkDependenciesPlugin {
+	constructor(options) {
+		this.chunkLoading = options.chunkLoading;
+		this.asyncChunkLoading =
+			typeof options.asyncChunkLoading === "boolean"
+				? options.asyncChunkLoading
+				: true;
 	}
 
 	/**
-	 * @returns {Iterator<T>} the iterator
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	[Symbol.iterator]() {
-		const iterators = [];
-		this._appendIterators(iterators);
-		iterators.reverse();
-		let currentIterator = iterators.pop();
-		return {
-			next: () => {
-				const res = currentIterator.next();
-				if (res.done) {
-					if (iterators.length === 0) return res;
-					currentIterator = iterators.pop();
-					return currentIterator.next();
-				}
-				return res;
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"StartupChunkDependenciesPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === this.chunkLoading;
+				};
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"StartupChunkDependenciesPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (!isEnabledForChunk(chunk)) return;
+						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+							set.add(RuntimeGlobals.startup);
+							set.add(RuntimeGlobals.ensureChunk);
+							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+							compilation.addRuntimeModule(
+								chunk,
+								new StartupChunkDependenciesRuntimeModule(
+									this.asyncChunkLoading
+								)
+							);
+						}
+					}
+				);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.startupEntrypoint)
+					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.require);
+						set.add(RuntimeGlobals.ensureChunk);
+						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+						compilation.addRuntimeModule(
+							chunk,
+							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+						);
+					});
 			}
-		};
+		);
 	}
 }
 
-module.exports = LazyBucketSortedSet;
+module.exports = StartupChunkDependenciesPlugin;
 
 
 /***/ }),
 
-/***/ 38938:
+/***/ 38157:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -122034,213 +117358,163 @@ module.exports = LazyBucketSortedSet;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-
-/**
- * @template T
- * @param {Set<T>} targetSet set where items should be added
- * @param {Set<Iterable<T>>} toMerge iterables to be merged
- * @returns {void}
- */
-const merge = (targetSet, toMerge) => {
-	for (const set of toMerge) {
-		for (const item of set) {
-			targetSet.add(item);
-		}
-	}
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-/**
- * @template T
- * @param {Set<Iterable<T>>} targetSet set where iterables should be added
- * @param {Array<LazySet<T>>} toDeepMerge lazy sets to be flattened
- * @returns {void}
- */
-const flatten = (targetSet, toDeepMerge) => {
-	for (const set of toDeepMerge) {
-		if (set._set.size > 0) targetSet.add(set._set);
-		if (set._needMerge) {
-			for (const mergedSet of set._toMerge) {
-				targetSet.add(mergedSet);
-			}
-			flatten(targetSet, set._toDeepMerge);
-		}
+class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
+	constructor(asyncChunkLoading) {
+		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
+		this.asyncChunkLoading = asyncChunkLoading;
 	}
-};
 
-/**
- * Like Set but with an addAll method to eventually add items from another iterable.
- * Access methods make sure that all delayed operations are executed.
- * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
- * @template T
- */
-class LazySet {
 	/**
-	 * @param {Iterable<T>=} iterable init iterable
+	 * @returns {string} runtime code
 	 */
-	constructor(iterable) {
-		/** @type {Set<T>} */
-		this._set = new Set(iterable);
-		/** @type {Set<Iterable<T>>} */
-		this._toMerge = new Set();
-		/** @type {Array<LazySet<T>>} */
-		this._toDeepMerge = [];
-		this._needMerge = false;
-		this._deopt = false;
+	generate() {
+		const { chunkGraph, chunk, compilation } = this;
+		const { runtimeTemplate } = compilation;
+		const chunkIds = Array.from(
+			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
+		).map(chunk => {
+			return chunk.id;
+		});
+		return Template.asString([
+			`var next = ${RuntimeGlobals.startup};`,
+			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
+				"",
+				!this.asyncChunkLoading
+					? chunkIds
+							.map(
+								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
+							)
+							.concat("return next();")
+					: chunkIds.length === 1
+					? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
+							chunkIds[0]
+					  )}).then(next);`
+					: chunkIds.length > 2
+					? [
+							// using map is shorter for 3 or more chunks
+							`return Promise.all(${JSON.stringify(chunkIds)}.map(${
+								RuntimeGlobals.ensureChunk
+							}, __webpack_require__)).then(next);`
+					  ]
+					: [
+							// calling ensureChunk directly is shorter for 0 - 2 chunks
+							"return Promise.all([",
+							Template.indent(
+								chunkIds
+									.map(
+										id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)})`
+									)
+									.join(",\n")
+							),
+							"]).then(next);"
+					  ]
+			)};`
+		]);
 	}
+}
 
-	_flatten() {
-		flatten(this._toMerge, this._toDeepMerge);
-		this._toDeepMerge.length = 0;
-	}
+module.exports = StartupChunkDependenciesRuntimeModule;
 
-	_merge() {
-		this._flatten();
-		merge(this._set, this._toMerge);
-		this._toMerge.clear();
-		this._needMerge = false;
-	}
 
-	_isEmpty() {
-		return (
-			this._set.size === 0 &&
-			this._toMerge.size === 0 &&
-			this._toDeepMerge.length === 0
-		);
-	}
+/***/ }),
 
-	get size() {
-		if (this._needMerge) this._merge();
-		return this._set.size;
-	}
+/***/ 97672:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {T} item an item
-	 * @returns {this} itself
-	 */
-	add(item) {
-		this._set.add(item);
-		return this;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-	/**
-	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
-	 * @returns {this} itself
-	 */
-	addAll(iterable) {
-		if (this._deopt) {
-			const _set = this._set;
-			for (const item of iterable) {
-				_set.add(item);
-			}
-		} else {
-			if (iterable instanceof LazySet) {
-				if (iterable._isEmpty()) return this;
-				this._toDeepMerge.push(iterable);
-				this._needMerge = true;
-				if (this._toDeepMerge.length > 100000) {
-					this._flatten();
-				}
-			} else {
-				this._toMerge.add(iterable);
-				this._needMerge = true;
-			}
-			if (this._toMerge.size > 100000) this._merge();
-		}
-		return this;
-	}
 
-	clear() {
-		this._set.clear();
-		this._toMerge.clear();
-		this._toDeepMerge.length = 0;
-		this._needMerge = false;
-		this._deopt = false;
-	}
 
-	/**
-	 * @param {T} value an item
-	 * @returns {boolean} true, if the value was in the Set before
-	 */
-	delete(value) {
-		if (this._needMerge) this._merge();
-		return this._set.delete(value);
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-	entries() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set.entries();
-	}
+/** @typedef {import("../MainTemplate")} MainTemplate */
 
-	/**
-	 * @param {function(T, T, Set<T>): void} callbackFn function called for each entry
-	 * @param {any} thisArg this argument for the callbackFn
-	 * @returns {void}
-	 */
-	forEach(callbackFn, thisArg) {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		this._set.forEach(callbackFn, thisArg);
+class StartupEntrypointRuntimeModule extends RuntimeModule {
+	constructor(asyncChunkLoading) {
+		super("startup entrypoint");
+		this.asyncChunkLoading = asyncChunkLoading;
 	}
 
 	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, when the item is in the Set
+	 * @returns {string} runtime code
 	 */
-	has(item) {
-		if (this._needMerge) this._merge();
-		return this._set.has(item);
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate } = compilation;
+		return `${
+			RuntimeGlobals.startupEntrypoint
+		} = ${runtimeTemplate.basicFunction("result, chunkIds, fn", [
+			"// arguments: chunkIds, moduleId are deprecated",
+			"var moduleId = chunkIds;",
+			`if(!fn) chunkIds = result, fn = ${runtimeTemplate.returningFunction(
+				`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`
+			)};`,
+			...(this.asyncChunkLoading
+				? [
+						`return Promise.all(chunkIds.map(${
+							RuntimeGlobals.ensureChunk
+						}, __webpack_require__)).then(${runtimeTemplate.basicFunction("", [
+							"var r = fn();",
+							"return r === undefined ? result : r;"
+						])})`
+				  ]
+				: [
+						`chunkIds.map(${RuntimeGlobals.ensureChunk}, __webpack_require__)`,
+						"var r = fn();",
+						"return r === undefined ? result : r;"
+				  ])
+		])}`;
 	}
+}
 
-	keys() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set.keys();
-	}
+module.exports = StartupEntrypointRuntimeModule;
 
-	values() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set.values();
-	}
 
-	[Symbol.iterator]() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set[Symbol.iterator]();
-	}
+/***/ }),
 
-	/* istanbul ignore next */
-	get [Symbol.toStringTag]() {
-		return "LazySet";
-	}
+/***/ 80655:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	serialize({ write }) {
-		if (this._needMerge) this._merge();
-		write(this._set.size);
-		for (const item of this._set) write(item);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class SystemContextRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("__system_context__");
 	}
 
-	static deserialize({ read }) {
-		const count = read();
-		const items = [];
-		for (let i = 0; i < count; i++) {
-			items.push(read());
-		}
-		return new LazySet(items);
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return `${RuntimeGlobals.systemContext} = __system_context__;`;
 	}
 }
 
-makeSerializable(LazySet, "webpack/lib/util/LazySet");
-
-module.exports = LazySet;
+module.exports = SystemContextRuntimeModule;
 
 
 /***/ }),
 
-/***/ 82482:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 64820:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -122250,26 +117524,60 @@ module.exports = LazySet;
 
 
 
-/**
- * @template K
- * @template V
- * @param {Map<K, V>} map a map
- * @param {K} key the key
- * @param {function(): V} computer compute value
- * @returns {V} value
- */
-exports.provide = (map, key, computer) => {
-	const value = map.get(key);
-	if (value !== undefined) return value;
-	const newValue = computer();
-	map.set(key, newValue);
-	return newValue;
+const NormalModule = __webpack_require__(39);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
+// http://www.ietf.org/rfc/rfc2397.txt
+const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
+
+const decodeDataURI = uri => {
+	const match = URIRegEx.exec(uri);
+	if (!match) return null;
+
+	const isBase64 = match[3];
+	const body = match[4];
+	return isBase64
+		? Buffer.from(body, "base64")
+		: Buffer.from(decodeURIComponent(body), "ascii");
 };
 
+class DataUriPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DataUriPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.resolveForScheme
+					.for("data")
+					.tap("DataUriPlugin", resourceData => {
+						const match = URIRegEx.exec(resourceData.resource);
+						if (match) {
+							resourceData.data.mimetype = match[1] || "";
+							resourceData.data.parameters = match[2] || "";
+							resourceData.data.encoding = match[3] || false;
+							resourceData.data.encodedContent = match[4] || "";
+						}
+					});
+				NormalModule.getCompilationHooks(compilation)
+					.readResourceForScheme.for("data")
+					.tap("DataUriPlugin", resource => decodeDataURI(resource));
+			}
+		);
+	}
+}
+
+module.exports = DataUriPlugin;
+
 
 /***/ }),
 
-/***/ 50780:
+/***/ 57637:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -122280,64 +117588,54 @@ exports.provide = (map, key, computer) => {
 
 
 
-const binarySearchBounds = __webpack_require__(92229);
-
-class ParallelismFactorCalculator {
-	constructor() {
-		this._rangePoints = [];
-		this._rangeCallbacks = [];
-	}
+const { URL, fileURLToPath } = __webpack_require__(57310);
+const { NormalModule } = __webpack_require__(91919);
 
-	range(start, end, callback) {
-		if (start === end) return callback(1);
-		this._rangePoints.push(start);
-		this._rangePoints.push(end);
-		this._rangeCallbacks.push(callback);
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
-	calculate() {
-		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
-			a < b ? -1 : 1
+class FileUriPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FileUriPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.resolveForScheme
+					.for("file")
+					.tap("FileUriPlugin", resourceData => {
+						const url = new URL(resourceData.resource);
+						const path = fileURLToPath(url);
+						const query = url.search;
+						const fragment = url.hash;
+						resourceData.path = path;
+						resourceData.query = query;
+						resourceData.fragment = fragment;
+						resourceData.resource = path + query + fragment;
+						return true;
+					});
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(undefined)
+					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						loaderContext.addDependency(resourcePath);
+						loaderContext.fs.readFile(resourcePath, callback);
+					});
+			}
 		);
-		const parallelism = segments.map(() => 0);
-		const rangeStartIndices = [];
-		for (let i = 0; i < this._rangePoints.length; i += 2) {
-			const start = this._rangePoints[i];
-			const end = this._rangePoints[i + 1];
-			let idx = binarySearchBounds.eq(segments, start);
-			rangeStartIndices.push(idx);
-			do {
-				parallelism[idx]++;
-				idx++;
-			} while (segments[idx] < end);
-		}
-		for (let i = 0; i < this._rangeCallbacks.length; i++) {
-			const start = this._rangePoints[i * 2];
-			const end = this._rangePoints[i * 2 + 1];
-			let idx = rangeStartIndices[i];
-			let sum = 0;
-			let totalDuration = 0;
-			let current = start;
-			do {
-				const p = parallelism[idx];
-				idx++;
-				const duration = segments[idx] - current;
-				totalDuration += duration;
-				current = segments[idx];
-				sum += p * duration;
-			} while (current < end);
-			this._rangeCallbacks[i](sum / totalDuration);
-		}
 	}
 }
 
-module.exports = ParallelismFactorCalculator;
+module.exports = FileUriPlugin;
 
 
 /***/ }),
 
-/***/ 65930:
-/***/ (function(module) {
+/***/ 42110:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -122347,3562 +117645,4267 @@ module.exports = ParallelismFactorCalculator;
 
 
 
-/**
- * @template T
- */
-class Queue {
-	/**
-	 * @param {Iterable<T>=} items The initial elements.
-	 */
-	constructor(items) {
-		/** @private @type {Set<T>} */
-		this._set = new Set(items);
-		/** @private @type {Iterator<T>} */
-		this._iterator = this._set[Symbol.iterator]();
-	}
-
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this._set.size;
-	}
-
-	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
-	 */
-	enqueue(item) {
-		this._set.add(item);
-	}
-
-	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
-	 */
-	dequeue() {
-		const result = this._iterator.next();
-		if (result.done) return undefined;
-		this._set.delete(result.value);
-		return result.value;
-	}
-}
+const { extname, basename } = __webpack_require__(71017);
+const { URL } = __webpack_require__(57310);
+const { createGunzip, createBrotliDecompress, createInflate } = __webpack_require__(59796);
+const NormalModule = __webpack_require__(39);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const { mkdirp, dirname, join } = __webpack_require__(17139);
+const memoize = __webpack_require__(78676);
 
-module.exports = Queue;
+/** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
+const getHttp = memoize(() => __webpack_require__(13685));
+const getHttps = memoize(() => __webpack_require__(95687));
 
-/***/ }),
+/** @type {(() => void)[] | undefined} */
+let inProgressWrite = undefined;
 
-/***/ 93347:
-/***/ (function(__unused_webpack_module, exports) {
+const validate = createSchemaValidation(
+	__webpack_require__(67263),
+	() => __webpack_require__(27256),
+	{
+		name: "Http Uri Plugin",
+		baseDataPath: "options"
+	}
+);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const toSafePath = str =>
+	str
+		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
+		.replace(/[^a-zA-Z0-9._-]+/g, "_");
 
+const computeIntegrity = content => {
+	const hash = createHash("sha512");
+	hash.update(content);
+	const integrity = "sha512-" + hash.digest("base64");
+	return integrity;
+};
 
+const verifyIntegrity = (content, integrity) => {
+	if (integrity === "ignore") return true;
+	return computeIntegrity(content) === integrity;
+};
 
 /**
- * intersect creates Set containing the intersection of elements between all sets
- * @template T
- * @param {Set<T>[]} sets an array of sets being checked for shared elements
- * @returns {Set<T>} returns a new Set containing the intersecting items
+ * @param {string} str input
+ * @returns {Record<string, string>} parsed
  */
-const intersect = sets => {
-	if (sets.length === 0) return new Set();
-	if (sets.length === 1) return new Set(sets[0]);
-	let minSize = Infinity;
-	let minIndex = -1;
-	for (let i = 0; i < sets.length; i++) {
-		const size = sets[i].size;
-		if (size < minSize) {
-			minIndex = i;
-			minSize = size;
+const parseKeyValuePairs = str => {
+	/** @type {Record<string, string>} */
+	const result = {};
+	for (const item of str.split(",")) {
+		const i = item.indexOf("=");
+		if (i >= 0) {
+			const key = item.slice(0, i).trim();
+			const value = item.slice(i + 1).trim();
+			result[key] = value;
+		} else {
+			const key = item.trim();
+			if (!key) continue;
+			result[key] = key;
 		}
 	}
-	const current = new Set(sets[minIndex]);
-	for (let i = 0; i < sets.length; i++) {
-		if (i === minIndex) continue;
-		const set = sets[i];
-		for (const item of current) {
-			if (!set.has(item)) {
-				current.delete(item);
-			}
+	return result;
+};
+
+const parseCacheControl = (cacheControl, requestTime) => {
+	// When false resource is not stored in cache
+	let storeCache = true;
+	// When false resource is not stored in lockfile cache
+	let storeLock = true;
+	// Resource is only revalidated, after that timestamp and when upgrade is chosen
+	let validUntil = 0;
+	if (cacheControl) {
+		const parsed = parseKeyValuePairs(cacheControl);
+		if (parsed["no-cache"]) storeCache = storeLock = false;
+		if (parsed["max-age"] && !isNaN(+parsed["max-age"])) {
+			validUntil = requestTime + +parsed["max-age"] * 1000;
 		}
+		if (parsed["must-revalidate"]) validUntil = 0;
 	}
-	return current;
+	return {
+		storeLock,
+		storeCache,
+		validUntil
+	};
 };
 
 /**
- * Checks if a set is the subset of another set
- * @template T
- * @param {Set<T>} bigSet a Set which contains the original elements to compare against
- * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
- * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ * @typedef {Object} LockfileEntry
+ * @property {string} resolved
+ * @property {string} integrity
+ * @property {string} contentType
  */
-const isSubset = (bigSet, smallSet) => {
-	if (bigSet.size < smallSet.size) return false;
-	for (const item of smallSet) {
-		if (!bigSet.has(item)) return false;
-	}
-	return true;
+
+const areLockfileEntriesEqual = (a, b) => {
+	return (
+		a.resolved === b.resolved &&
+		a.integrity === b.integrity &&
+		a.contentType === b.contentType
+	);
 };
 
-/**
- * @template T
- * @param {Set<T>} set a set
- * @param {function(T): boolean} fn selector function
- * @returns {T | undefined} found item
- */
-const find = (set, fn) => {
-	for (const item of set) {
-		if (fn(item)) return item;
-	}
+const entryToString = entry => {
+	return `resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
 };
 
+class Lockfile {
+	constructor() {
+		this.version = 1;
+		/** @type {Map<string, LockfileEntry | "ignore" | "no-cache">} */
+		this.entries = new Map();
+	}
+
+	static parse(content) {
+		// TODO handle merge conflicts
+		const data = JSON.parse(content);
+		if (data.version !== 1)
+			throw new Error(`Unsupported lockfile version ${data.version}`);
+		const lockfile = new Lockfile();
+		for (const key of Object.keys(data)) {
+			if (key === "version") continue;
+			const entry = data[key];
+			lockfile.entries.set(
+				key,
+				typeof entry === "string"
+					? entry
+					: {
+							resolved: key,
+							...entry
+					  }
+			);
+		}
+		return lockfile;
+	}
+
+	toString() {
+		let str = "{\n";
+		const entries = Array.from(this.entries).sort(([a], [b]) =>
+			a < b ? -1 : 1
+		);
+		for (const [key, entry] of entries) {
+			if (typeof entry === "string") {
+				str += `  ${JSON.stringify(key)}: ${JSON.stringify(entry)},\n`;
+			} else {
+				str += `  ${JSON.stringify(key)}: { `;
+				if (entry.resolved !== key)
+					str += `"resolved": ${JSON.stringify(entry.resolved)}, `;
+				str += `"integrity": ${JSON.stringify(
+					entry.integrity
+				)}, "contentType": ${JSON.stringify(entry.contentType)} },\n`;
+			}
+		}
+		str += `  "version": ${this.version}\n}\n`;
+		return str;
+	}
+}
+
 /**
- * @template T
- * @param {Set<T>} set a set
- * @returns {T | undefined} first item
+ * @template R
+ * @param {function(function(Error=, R=): void): void} fn function
+ * @returns {function(function((Error | null)=, R=): void): void} cached function
  */
-const first = set => {
-	const entry = set.values().next();
-	return entry.done ? undefined : entry.value;
+const cachedWithoutKey = fn => {
+	let inFlight = false;
+	/** @type {Error | undefined} */
+	let cachedError = undefined;
+	/** @type {R | undefined} */
+	let cachedResult = undefined;
+	/** @type {(function(Error=, R=): void)[] | undefined} */
+	let cachedCallbacks = undefined;
+	return callback => {
+		if (inFlight) {
+			if (cachedResult !== undefined) return callback(null, cachedResult);
+			if (cachedError !== undefined) return callback(cachedError);
+			if (cachedCallbacks === undefined) cachedCallbacks = [callback];
+			else cachedCallbacks.push(callback);
+			return;
+		}
+		inFlight = true;
+		fn((err, result) => {
+			if (err) cachedError = err;
+			else cachedResult = result;
+			const callbacks = cachedCallbacks;
+			cachedCallbacks = undefined;
+			callback(err, result);
+			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+		});
+	};
 };
 
 /**
  * @template T
- * @param {Set<T>} a first
- * @param {Set<T>} b second
- * @returns {Set<T>} combined set, may be identical to a or b
+ * @template R
+ * @param {function(T, function(Error=, R=): void): void} fn function
+ * @param {function(T, function(Error=, R=): void): void=} forceFn function for the second try
+ * @returns {(function(T, function((Error | null)=, R=): void): void) & { force: function(T, function((Error | null)=, R=): void): void }} cached function
  */
-const combine = (a, b) => {
-	if (b.size === 0) return a;
-	if (a.size === 0) return b;
-	const set = new Set(a);
-	for (const item of b) set.add(item);
-	return set;
+const cachedWithKey = (fn, forceFn = fn) => {
+	/** @typedef {{ result?: R, error?: Error, callbacks?: (function((Error | null)=, R=): void)[], force?: true }} CacheEntry */
+	/** @type {Map<T, CacheEntry>} */
+	const cache = new Map();
+	const resultFn = (arg, callback) => {
+		const cacheEntry = cache.get(arg);
+		if (cacheEntry !== undefined) {
+			if (cacheEntry.result !== undefined)
+				return callback(null, cacheEntry.result);
+			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
+			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
+			else cacheEntry.callbacks.push(callback);
+			return;
+		}
+		/** @type {CacheEntry} */
+		const newCacheEntry = {
+			result: undefined,
+			error: undefined,
+			callbacks: undefined
+		};
+		cache.set(arg, newCacheEntry);
+		fn(arg, (err, result) => {
+			if (err) newCacheEntry.error = err;
+			else newCacheEntry.result = result;
+			const callbacks = newCacheEntry.callbacks;
+			newCacheEntry.callbacks = undefined;
+			callback(err, result);
+			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+		});
+	};
+	resultFn.force = (arg, callback) => {
+		const cacheEntry = cache.get(arg);
+		if (cacheEntry !== undefined && cacheEntry.force) {
+			if (cacheEntry.result !== undefined)
+				return callback(null, cacheEntry.result);
+			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
+			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
+			else cacheEntry.callbacks.push(callback);
+			return;
+		}
+		/** @type {CacheEntry} */
+		const newCacheEntry = {
+			result: undefined,
+			error: undefined,
+			callbacks: undefined,
+			force: true
+		};
+		cache.set(arg, newCacheEntry);
+		forceFn(arg, (err, result) => {
+			if (err) newCacheEntry.error = err;
+			else newCacheEntry.result = result;
+			const callbacks = newCacheEntry.callbacks;
+			newCacheEntry.callbacks = undefined;
+			callback(err, result);
+			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+		});
+	};
+	return resultFn;
 };
 
-exports.intersect = intersect;
-exports.isSubset = isSubset;
-exports.find = find;
-exports.first = first;
-exports.combine = combine;
+class HttpUriPlugin {
+	/**
+	 * @param {HttpUriPluginOptions} options options
+	 */
+	constructor(options) {
+		validate(options);
+		this._lockfileLocation = options.lockfileLocation;
+		this._cacheLocation = options.cacheLocation;
+		this._upgrade = options.upgrade;
+		this._frozen = options.frozen;
+		this._allowedUris = options.allowedUris;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const schemes = [
+			{
+				scheme: "http",
+				fetch: (url, options, callback) => getHttp().get(url, options, callback)
+			},
+			{
+				scheme: "https",
+				fetch: (url, options, callback) =>
+					getHttps().get(url, options, callback)
+			}
+		];
+		let lockfileCache;
+		compiler.hooks.compilation.tap(
+			"HttpUriPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const intermediateFs = compiler.intermediateFileSystem;
+				const fs = compilation.inputFileSystem;
+				const cache = compilation.getCache("webpack.HttpUriPlugin");
+				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				const lockfileLocation =
+					this._lockfileLocation ||
+					join(
+						intermediateFs,
+						compiler.context,
+						compiler.name
+							? `${toSafePath(compiler.name)}.webpack.lock`
+							: "webpack.lock"
+					);
+				const cacheLocation =
+					this._cacheLocation !== undefined
+						? this._cacheLocation
+						: lockfileLocation + ".data";
+				const upgrade = this._upgrade || false;
+				const frozen = this._frozen || false;
+				const hashFunction = "sha512";
+				const hashDigest = "hex";
+				const hashDigestLength = 20;
+				const allowedUris = this._allowedUris;
 
+				let warnedAboutEol = false;
 
-/***/ }),
+				const cacheKeyCache = new Map();
+				/**
+				 * @param {string} url the url
+				 * @returns {string} the key
+				 */
+				const getCacheKey = url => {
+					const cachedResult = cacheKeyCache.get(url);
+					if (cachedResult !== undefined) return cachedResult;
+					const result = _getCacheKey(url);
+					cacheKeyCache.set(url, result);
+					return result;
+				};
 
-/***/ 13098:
-/***/ (function(module) {
+				/**
+				 * @param {string} url the url
+				 * @returns {string} the key
+				 */
+				const _getCacheKey = url => {
+					const parsedUrl = new URL(url);
+					const folder = toSafePath(parsedUrl.origin);
+					const name = toSafePath(parsedUrl.pathname);
+					const query = toSafePath(parsedUrl.search);
+					let ext = extname(name);
+					if (ext.length > 20) ext = "";
+					const basename = ext ? name.slice(0, -ext.length) : name;
+					const hash = createHash(hashFunction);
+					hash.update(url);
+					const digest = hash.digest(hashDigest).slice(0, hashDigestLength);
+					return `${folder.slice(-50)}/${`${basename}${
+						query ? `_${query}` : ""
+					}`.slice(0, 150)}_${digest}${ext}`;
+				};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				const getLockfile = cachedWithoutKey(
+					/**
+					 * @param {function((Error | null)=, Lockfile=): void} callback callback
+					 * @returns {void}
+					 */
+					callback => {
+						const readLockfile = () => {
+							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
+								if (err && err.code !== "ENOENT") {
+									compilation.missingDependencies.add(lockfileLocation);
+									return callback(err);
+								}
+								compilation.fileDependencies.add(lockfileLocation);
+								compilation.fileSystemInfo.createSnapshot(
+									compiler.fsStartTime,
+									buffer ? [lockfileLocation] : [],
+									[],
+									buffer ? [] : [lockfileLocation],
+									{ timestamp: true },
+									(err, snapshot) => {
+										if (err) return callback(err);
+										const lockfile = buffer
+											? Lockfile.parse(buffer.toString("utf-8"))
+											: new Lockfile();
+										lockfileCache = {
+											lockfile,
+											snapshot
+										};
+										callback(null, lockfile);
+									}
+								);
+							});
+						};
+						if (lockfileCache) {
+							compilation.fileSystemInfo.checkSnapshotValid(
+								lockfileCache.snapshot,
+								(err, valid) => {
+									if (err) return callback(err);
+									if (!valid) return readLockfile();
+									callback(null, lockfileCache.lockfile);
+								}
+							);
+						} else {
+							readLockfile();
+						}
+					}
+				);
+
+				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
+				let lockfileUpdates = undefined;
+				const storeLockEntry = (lockfile, url, entry) => {
+					const oldEntry = lockfile.entries.get(url);
+					if (lockfileUpdates === undefined) lockfileUpdates = new Map();
+					lockfileUpdates.set(url, entry);
+					lockfile.entries.set(url, entry);
+					if (!oldEntry) {
+						logger.log(`${url} added to lockfile`);
+					} else if (typeof oldEntry === "string") {
+						if (typeof entry === "string") {
+							logger.log(`${url} updated in lockfile: ${oldEntry} -> ${entry}`);
+						} else {
+							logger.log(
+								`${url} updated in lockfile: ${oldEntry} -> ${entry.resolved}`
+							);
+						}
+					} else if (typeof entry === "string") {
+						logger.log(
+							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry}`
+						);
+					} else if (oldEntry.resolved !== entry.resolved) {
+						logger.log(
+							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry.resolved}`
+						);
+					} else if (oldEntry.integrity !== entry.integrity) {
+						logger.log(`${url} updated in lockfile: content changed`);
+					} else if (oldEntry.contentType !== entry.contentType) {
+						logger.log(
+							`${url} updated in lockfile: ${oldEntry.contentType} -> ${entry.contentType}`
+						);
+					} else {
+						logger.log(`${url} updated in lockfile`);
+					}
+				};
+
+				const storeResult = (lockfile, url, result, callback) => {
+					if (result.storeLock) {
+						storeLockEntry(lockfile, url, result.entry);
+						if (!cacheLocation || !result.content)
+							return callback(null, result);
+						const key = getCacheKey(result.entry.resolved);
+						const filePath = join(intermediateFs, cacheLocation, key);
+						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
+							if (err) return callback(err);
+							intermediateFs.writeFile(filePath, result.content, err => {
+								if (err) return callback(err);
+								callback(null, result);
+							});
+						});
+					} else {
+						storeLockEntry(lockfile, url, "no-cache");
+						callback(null, result);
+					}
+				};
 
+				for (const { scheme, fetch } of schemes) {
+					/**
+					 *
+					 * @param {string} url URL
+					 * @param {string} integrity integrity
+					 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
+					 */
+					const resolveContent = (url, integrity, callback) => {
+						const handleResult = (err, result) => {
+							if (err) return callback(err);
+							if ("location" in result) {
+								return resolveContent(
+									result.location,
+									integrity,
+									(err, innerResult) => {
+										if (err) return callback(err);
+										callback(null, {
+											entry: innerResult.entry,
+											content: innerResult.content,
+											storeLock: innerResult.storeLock && result.storeLock
+										});
+									}
+								);
+							} else {
+								if (
+									!result.fresh &&
+									integrity &&
+									result.entry.integrity !== integrity &&
+									!verifyIntegrity(result.content, integrity)
+								) {
+									return fetchContent.force(url, handleResult);
+								}
+								return callback(null, {
+									entry: result.entry,
+									content: result.content,
+									storeLock: result.storeLock
+								});
+							}
+						};
+						fetchContent(url, handleResult);
+					};
 
+					/** @typedef {{ storeCache: boolean, storeLock: boolean, validUntil: number, etag: string | undefined, fresh: boolean }} FetchResultMeta */
+					/** @typedef {FetchResultMeta & { location: string }} RedirectFetchResult */
+					/** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
+					/** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
 
-const NONE = Symbol("not sorted");
+					/**
+					 * @param {string} url URL
+					 * @param {FetchResult} cachedResult result from cache
+					 * @param {function((Error | null)=, FetchResult=): void} callback callback
+					 * @returns {void}
+					 */
+					const fetchContentRaw = (url, cachedResult, callback) => {
+						const requestTime = Date.now();
+						fetch(
+							new URL(url),
+							{
+								headers: {
+									"accept-encoding": "gzip, deflate, br",
+									"user-agent": "webpack",
+									"if-none-match": cachedResult
+										? cachedResult.etag || null
+										: null
+								}
+							},
+							res => {
+								const etag = res.headers["etag"];
+								const location = res.headers["location"];
+								const cacheControl = res.headers["cache-control"];
+								const { storeLock, storeCache, validUntil } = parseCacheControl(
+									cacheControl,
+									requestTime
+								);
+								/**
+								 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
+								 * @returns {void}
+								 */
+								const finishWith = partialResult => {
+									if ("location" in partialResult) {
+										logger.debug(
+											`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
+										);
+									} else {
+										logger.debug(
+											`GET ${url} [${res.statusCode}] ${Math.ceil(
+												partialResult.content.length / 1024
+											)} kB${!storeLock ? " no-cache" : ""}`
+										);
+									}
+									const result = {
+										...partialResult,
+										fresh: true,
+										storeLock,
+										storeCache,
+										validUntil,
+										etag
+									};
+									if (!storeCache) {
+										logger.log(
+											`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
+										);
+										return callback(null, result);
+									}
+									cache.store(
+										url,
+										null,
+										{
+											...result,
+											fresh: false
+										},
+										err => {
+											if (err) {
+												logger.warn(
+													`${url} can't be stored in cache: ${err.message}`
+												);
+												logger.debug(err.stack);
+											}
+											callback(null, result);
+										}
+									);
+								};
+								if (res.statusCode === 304) {
+									if (
+										cachedResult.validUntil < validUntil ||
+										cachedResult.storeLock !== storeLock ||
+										cachedResult.storeCache !== storeCache ||
+										cachedResult.etag !== etag
+									) {
+										return finishWith(cachedResult);
+									} else {
+										logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+										return callback(null, {
+											...cachedResult,
+											fresh: true
+										});
+									}
+								}
+								if (
+									location &&
+									res.statusCode >= 301 &&
+									res.statusCode <= 308
+								) {
+									return finishWith({
+										location: new URL(location, url).href
+									});
+								}
+								const contentType = res.headers["content-type"] || "";
+								const bufferArr = [];
 
-/**
- * A subset of Set that offers sorting functionality
- * @template T item type in set
- * @extends {Set<T>}
- */
-class SortableSet extends Set {
-	/**
-	 * Create a new sortable set
-	 * @param {Iterable<T>=} initialIterable The initial iterable value
-	 * @typedef {function(T, T): number} SortFunction
-	 * @param {SortFunction=} defaultSort Default sorting function
-	 */
-	constructor(initialIterable, defaultSort) {
-		super(initialIterable);
-		/** @private @type {undefined | function(T, T): number}} */
-		this._sortFn = defaultSort;
-		/** @private @type {typeof NONE | undefined | function(T, T): number}} */
-		this._lastActiveSortFn = NONE;
-		/** @private @type {Map<Function, any> | undefined} */
-		this._cache = undefined;
-		/** @private @type {Map<Function, any> | undefined} */
-		this._cacheOrderIndependent = undefined;
-	}
+								const contentEncoding = res.headers["content-encoding"];
+								let stream = res;
+								if (contentEncoding === "gzip") {
+									stream = stream.pipe(createGunzip());
+								} else if (contentEncoding === "br") {
+									stream = stream.pipe(createBrotliDecompress());
+								} else if (contentEncoding === "deflate") {
+									stream = stream.pipe(createInflate());
+								}
 
-	/**
-	 * @param {T} value value to add to set
-	 * @returns {this} returns itself
-	 */
-	add(value) {
-		this._lastActiveSortFn = NONE;
-		this._invalidateCache();
-		this._invalidateOrderedCache();
-		super.add(value);
-		return this;
-	}
+								stream.on("data", chunk => {
+									bufferArr.push(chunk);
+								});
 
-	/**
-	 * @param {T} value value to delete
-	 * @returns {boolean} true if value existed in set, false otherwise
-	 */
-	delete(value) {
-		this._invalidateCache();
-		this._invalidateOrderedCache();
-		return super.delete(value);
-	}
+								stream.on("end", () => {
+									if (!res.complete) {
+										logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
+										return callback(new Error(`${url} request was terminated`));
+									}
 
-	/**
-	 * @returns {void}
-	 */
-	clear() {
-		this._invalidateCache();
-		this._invalidateOrderedCache();
-		return super.clear();
-	}
+									const content = Buffer.concat(bufferArr);
 
-	/**
-	 * Sort with a comparer function
-	 * @param {SortFunction} sortFn Sorting comparer function
-	 * @returns {void}
-	 */
-	sortWith(sortFn) {
-		if (this.size <= 1 || sortFn === this._lastActiveSortFn) {
-			// already sorted - nothing to do
-			return;
-		}
+									if (res.statusCode !== 200) {
+										logger.log(`GET ${url} [${res.statusCode}]`);
+										return callback(
+											new Error(
+												`${url} request status code = ${
+													res.statusCode
+												}\n${content.toString("utf-8")}`
+											)
+										);
+									}
 
-		const sortedArray = Array.from(this).sort(sortFn);
-		super.clear();
-		for (let i = 0; i < sortedArray.length; i += 1) {
-			super.add(sortedArray[i]);
-		}
-		this._lastActiveSortFn = sortFn;
-		this._invalidateCache();
-	}
+									const integrity = computeIntegrity(content);
+									const entry = { resolved: url, integrity, contentType };
 
-	sort() {
-		this.sortWith(this._sortFn);
-		return this;
-	}
+									finishWith({
+										entry,
+										content
+									});
+								});
+							}
+						).on("error", err => {
+							logger.log(`GET ${url} (error)`);
+							err.message += `\nwhile fetching ${url}`;
+							callback(err);
+						});
+					};
 
-	/**
-	 * Get data from cache
-	 * @template R
-	 * @param {function(SortableSet<T>): R} fn function to calculate value
-	 * @returns {R} returns result of fn(this), cached until set changes
-	 */
-	getFromCache(fn) {
-		if (this._cache === undefined) {
-			this._cache = new Map();
-		} else {
-			const result = this._cache.get(fn);
-			const data = /** @type {R} */ (result);
-			if (data !== undefined) {
-				return data;
-			}
-		}
-		const newData = fn(this);
-		this._cache.set(fn, newData);
-		return newData;
-	}
+					const fetchContent = cachedWithKey(
+						/**
+						 * @param {string} url URL
+						 * @param {function((Error | null)=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
+						 * @returns {void}
+						 */ (url, callback) => {
+							cache.get(url, null, (err, cachedResult) => {
+								if (err) return callback(err);
+								if (cachedResult) {
+									const isValid = cachedResult.validUntil >= Date.now();
+									if (isValid) return callback(null, cachedResult);
+								}
+								fetchContentRaw(url, cachedResult, callback);
+							});
+						},
+						(url, callback) => fetchContentRaw(url, undefined, callback)
+					);
 
-	/**
-	 * Get data from cache (ignoring sorting)
-	 * @template R
-	 * @param {function(SortableSet<T>): R} fn function to calculate value
-	 * @returns {R} returns result of fn(this), cached until set changes
-	 */
-	getFromUnorderedCache(fn) {
-		if (this._cacheOrderIndependent === undefined) {
-			this._cacheOrderIndependent = new Map();
-		} else {
-			const result = this._cacheOrderIndependent.get(fn);
-			const data = /** @type {R} */ (result);
-			if (data !== undefined) {
-				return data;
-			}
-		}
-		const newData = fn(this);
-		this._cacheOrderIndependent.set(fn, newData);
-		return newData;
-	}
+					const isAllowed = uri => {
+						for (const allowed of allowedUris) {
+							if (typeof allowed === "string") {
+								if (uri.startsWith(allowed)) return true;
+							} else if (typeof allowed === "function") {
+								if (allowed(uri)) return true;
+							} else {
+								if (allowed.test(uri)) return true;
+							}
+						}
+						return false;
+					};
 
-	/**
-	 * @private
-	 * @returns {void}
-	 */
-	_invalidateCache() {
-		if (this._cache !== undefined) {
-			this._cache.clear();
-		}
-	}
+					const getInfo = cachedWithKey(
+						/**
+						 * @param {string} url the url
+						 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
+						 * @returns {void}
+						 */
+						(url, callback) => {
+							if (!isAllowed(url)) {
+								return callback(
+									new Error(
+										`${url} doesn't match the allowedUris policy. These URIs are allowed:\n${allowedUris
+											.map(uri => ` - ${uri}`)
+											.join("\n")}`
+									)
+								);
+							}
+							getLockfile((err, lockfile) => {
+								if (err) return callback(err);
+								const entryOrString = lockfile.entries.get(url);
+								if (!entryOrString) {
+									if (frozen) {
+										return callback(
+											new Error(
+												`${url} has no lockfile entry and lockfile is frozen`
+											)
+										);
+									}
+									resolveContent(url, null, (err, result) => {
+										if (err) return callback(err);
+										storeResult(lockfile, url, result, callback);
+									});
+									return;
+								}
+								if (typeof entryOrString === "string") {
+									const entryTag = entryOrString;
+									resolveContent(url, null, (err, result) => {
+										if (err) return callback(err);
+										if (!result.storeLock || entryTag === "ignore")
+											return callback(null, result);
+										if (frozen) {
+											return callback(
+												new Error(
+													`${url} used to have ${entryTag} lockfile entry and has content now, but lockfile is frozen`
+												)
+											);
+										}
+										if (!upgrade) {
+											return callback(
+												new Error(
+													`${url} used to have ${entryTag} lockfile entry and has content now.
+This should be reflected in the lockfile, so this lockfile entry must be upgraded, but upgrading is not enabled.
+Remove this line from the lockfile to force upgrading.`
+												)
+											);
+										}
+										storeResult(lockfile, url, result, callback);
+									});
+									return;
+								}
+								let entry = entryOrString;
+								const doFetch = lockedContent => {
+									resolveContent(url, entry.integrity, (err, result) => {
+										if (err) {
+											if (lockedContent) {
+												logger.warn(
+													`Upgrade request to ${url} failed: ${err.message}`
+												);
+												logger.debug(err.stack);
+												return callback(null, {
+													entry,
+													content: lockedContent
+												});
+											}
+											return callback(err);
+										}
+										if (!result.storeLock) {
+											// When the lockfile entry should be no-cache
+											// we need to update the lockfile
+											if (frozen) {
+												return callback(
+													new Error(
+														`${url} has a lockfile entry and is no-cache now, but lockfile is frozen\nLockfile: ${entryToString(
+															entry
+														)}`
+													)
+												);
+											}
+											storeResult(lockfile, url, result, callback);
+											return;
+										}
+										if (!areLockfileEntriesEqual(result.entry, entry)) {
+											// When the lockfile entry is outdated
+											// we need to update the lockfile
+											if (frozen) {
+												return callback(
+													new Error(
+														`${url} has an outdated lockfile entry, but lockfile is frozen\nLockfile: ${entryToString(
+															entry
+														)}\nExpected: ${entryToString(result.entry)}`
+													)
+												);
+											}
+											storeResult(lockfile, url, result, callback);
+											return;
+										}
+										if (!lockedContent && cacheLocation) {
+											// When the lockfile cache content is missing
+											// we need to update the lockfile
+											if (frozen) {
+												return callback(
+													new Error(
+														`${url} is missing content in the lockfile cache, but lockfile is frozen\nLockfile: ${entryToString(
+															entry
+														)}`
+													)
+												);
+											}
+											storeResult(lockfile, url, result, callback);
+											return;
+										}
+										return callback(null, result);
+									});
+								};
+								if (cacheLocation) {
+									// When there is a lockfile cache
+									// we read the content from there
+									const key = getCacheKey(entry.resolved);
+									const filePath = join(intermediateFs, cacheLocation, key);
+									fs.readFile(filePath, (err, result) => {
+										const content = /** @type {Buffer} */ (result);
+										if (err) {
+											if (err.code === "ENOENT") return doFetch();
+											return callback(err);
+										}
+										const continueWithCachedContent = result => {
+											if (!upgrade) {
+												// When not in upgrade mode, we accept the result from the lockfile cache
+												return callback(null, { entry, content });
+											}
+											return doFetch(content);
+										};
+										if (!verifyIntegrity(content, entry.integrity)) {
+											let contentWithChangedEol;
+											let isEolChanged = false;
+											try {
+												contentWithChangedEol = Buffer.from(
+													content.toString("utf-8").replace(/\r\n/g, "\n")
+												);
+												isEolChanged = verifyIntegrity(
+													contentWithChangedEol,
+													entry.integrity
+												);
+											} catch (e) {
+												// ignore
+											}
+											if (isEolChanged) {
+												if (!warnedAboutEol) {
+													const explainer = `Incorrect end of line sequence was detected in the lockfile cache.
+The lockfile cache is protected by integrity checks, so any external modification will lead to a corrupted lockfile cache.
+When using git make sure to configure .gitattributes correctly for the lockfile cache:
+  **/*webpack.lock.data/** -text
+This will avoid that the end of line sequence is changed by git on Windows.`;
+													if (frozen) {
+														logger.error(explainer);
+													} else {
+														logger.warn(explainer);
+														logger.info(
+															"Lockfile cache will be automatically fixed now, but when lockfile is frozen this would result in an error."
+														);
+													}
+													warnedAboutEol = true;
+												}
+												if (!frozen) {
+													// "fix" the end of line sequence of the lockfile content
+													logger.log(
+														`${filePath} fixed end of line sequence (\\r\\n instead of \\n).`
+													);
+													intermediateFs.writeFile(
+														filePath,
+														contentWithChangedEol,
+														err => {
+															if (err) return callback(err);
+															continueWithCachedContent(contentWithChangedEol);
+														}
+													);
+													return;
+												}
+											}
+											if (frozen) {
+												return callback(
+													new Error(
+														`${
+															entry.resolved
+														} integrity mismatch, expected content with integrity ${
+															entry.integrity
+														} but got ${computeIntegrity(content)}.
+Lockfile corrupted (${
+															isEolChanged
+																? "end of line sequence was unexpectedly changed"
+																: "incorrectly merged? changed by other tools?"
+														}).
+Run build with un-frozen lockfile to automatically fix lockfile.`
+													)
+												);
+											} else {
+												// "fix" the lockfile entry to the correct integrity
+												// the content has priority over the integrity value
+												entry = {
+													...entry,
+													integrity: computeIntegrity(content)
+												};
+												storeLockEntry(lockfile, url, entry);
+											}
+										}
+										continueWithCachedContent(result);
+									});
+								} else {
+									doFetch();
+								}
+							});
+						}
+					);
 
-	/**
-	 * @private
-	 * @returns {void}
-	 */
-	_invalidateOrderedCache() {
-		if (this._cacheOrderIndependent !== undefined) {
-			this._cacheOrderIndependent.clear();
-		}
-	}
+					const respondWithUrlModule = (url, resourceData, callback) => {
+						getInfo(url.href, (err, result) => {
+							if (err) return callback(err);
+							resourceData.resource = url.href;
+							resourceData.path = url.origin + url.pathname;
+							resourceData.query = url.search;
+							resourceData.fragment = url.hash;
+							resourceData.context = new URL(
+								".",
+								result.entry.resolved
+							).href.slice(0, -1);
+							resourceData.data.mimetype = result.entry.contentType;
+							callback(null, true);
+						});
+					};
+					normalModuleFactory.hooks.resolveForScheme
+						.for(scheme)
+						.tapAsync(
+							"HttpUriPlugin",
+							(resourceData, resolveData, callback) => {
+								respondWithUrlModule(
+									new URL(resourceData.resource),
+									resourceData,
+									callback
+								);
+							}
+						);
+					normalModuleFactory.hooks.resolveInScheme
+						.for(scheme)
+						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
+							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
+							if (
+								data.dependencyType !== "url" &&
+								!/^\.{0,2}\//.test(resourceData.resource)
+							) {
+								return callback();
+							}
+							respondWithUrlModule(
+								new URL(resourceData.resource, data.context + "/"),
+								resourceData,
+								callback
+							);
+						});
+					const hooks = NormalModule.getCompilationHooks(compilation);
+					hooks.readResourceForScheme
+						.for(scheme)
+						.tapAsync("HttpUriPlugin", (resource, module, callback) => {
+							return getInfo(resource, (err, result) => {
+								if (err) return callback(err);
+								module.buildInfo.resourceIntegrity = result.entry.integrity;
+								callback(null, result.content);
+							});
+						});
+					hooks.needBuild.tapAsync(
+						"HttpUriPlugin",
+						(module, context, callback) => {
+							if (
+								module.resource &&
+								module.resource.startsWith(`${scheme}://`)
+							) {
+								getInfo(module.resource, (err, result) => {
+									if (err) return callback(err);
+									if (
+										result.entry.integrity !==
+										module.buildInfo.resourceIntegrity
+									) {
+										return callback(null, true);
+									}
+									callback();
+								});
+							} else {
+								return callback();
+							}
+						}
+					);
+				}
+				compilation.hooks.finishModules.tapAsync(
+					"HttpUriPlugin",
+					(modules, callback) => {
+						if (!lockfileUpdates) return callback();
+						const ext = extname(lockfileLocation);
+						const tempFile = join(
+							intermediateFs,
+							dirname(intermediateFs, lockfileLocation),
+							`.${basename(lockfileLocation, ext)}.${
+								(Math.random() * 10000) | 0
+							}${ext}`
+						);
 
-	/**
-	 * @returns {T[]} the raw array
-	 */
-	toJSON() {
-		return Array.from(this);
+						const writeDone = () => {
+							const nextOperation = inProgressWrite.shift();
+							if (nextOperation) {
+								nextOperation();
+							} else {
+								inProgressWrite = undefined;
+							}
+						};
+						const runWrite = () => {
+							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
+								if (err && err.code !== "ENOENT") {
+									writeDone();
+									return callback(err);
+								}
+								const lockfile = buffer
+									? Lockfile.parse(buffer.toString("utf-8"))
+									: new Lockfile();
+								for (const [key, value] of lockfileUpdates) {
+									lockfile.entries.set(key, value);
+								}
+								intermediateFs.writeFile(tempFile, lockfile.toString(), err => {
+									if (err) {
+										writeDone();
+										return intermediateFs.unlink(tempFile, () => callback(err));
+									}
+									intermediateFs.rename(tempFile, lockfileLocation, err => {
+										if (err) {
+											writeDone();
+											return intermediateFs.unlink(tempFile, () =>
+												callback(err)
+											);
+										}
+										writeDone();
+										callback();
+									});
+								});
+							});
+						};
+						if (inProgressWrite) {
+							inProgressWrite.push(runWrite);
+						} else {
+							inProgressWrite = [];
+							runWrite();
+						}
+					}
+				);
+			}
+		);
 	}
 }
 
-module.exports = SortableSet;
+module.exports = HttpUriPlugin;
 
 
 /***/ }),
 
-/***/ 64985:
+/***/ 41721:
 /***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-/**
- * @template K
- * @template V
- */
-class StackedCacheMap {
-	constructor() {
-		/** @type {Map<K, V>} */
-		this.map = new Map();
-		/** @type {ReadonlyMap<K, V>[]} */
-		this.stack = [];
-	}
-
-	/**
-	 * @param {ReadonlyMap<K, V>} map map to add
-	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
-	 */
-	addAll(map, immutable) {
-		if (immutable) {
-			this.stack.push(map);
-
-			// largest map should go first
-			for (let i = this.stack.length - 1; i > 0; i--) {
-				const beforeLast = this.stack[i - 1];
-				if (beforeLast.size >= map.size) break;
-				this.stack[i] = beforeLast;
-				this.stack[i - 1] = map;
-			}
-		} else {
-			for (const [key, value] of map) {
-				this.map.set(key, value);
-			}
-		}
-	}
-
-	/**
-	 * @param {K} item the key of the element to add
-	 * @param {V} value the value of the element to add
-	 * @returns {void}
-	 */
-	set(item, value) {
-		this.map.set(item, value);
-	}
-
-	/**
-	 * @param {K} item the item to delete
-	 * @returns {void}
-	 */
-	delete(item) {
-		throw new Error("Items can't be deleted from a StackedCacheMap");
-	}
-
-	/**
-	 * @param {K} item the item to test
-	 * @returns {boolean} true if the item exists in this set
-	 */
-	has(item) {
-		throw new Error(
-			"Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined"
-		);
-	}
-
-	/**
-	 * @param {K} item the key of the element to return
-	 * @returns {V} the value of the element
-	 */
-	get(item) {
-		for (const map of this.stack) {
-			const value = map.get(item);
-			if (value !== undefined) return value;
-		}
-		return this.map.get(item);
-	}
-
-	clear() {
-		this.stack.length = 0;
-		this.map.clear();
+class ArraySerializer {
+	serialize(array, { write }) {
+		write(array.length);
+		for (const item of array) write(item);
 	}
-
-	get size() {
-		let size = this.map.size;
-		for (const map of this.stack) {
-			size += map.size;
+	deserialize({ read }) {
+		const length = read();
+		const array = [];
+		for (let i = 0; i < length; i++) {
+			array.push(read());
 		}
-		return size;
-	}
-
-	[Symbol.iterator]() {
-		const iterators = this.stack.map(map => map[Symbol.iterator]());
-		let current = this.map[Symbol.iterator]();
-		return {
-			next() {
-				let result = current.next();
-				while (result.done && iterators.length > 0) {
-					current = iterators.pop();
-					result = current.next();
-				}
-				return result;
-			}
-		};
+		return array;
 	}
 }
 
-module.exports = StackedCacheMap;
+module.exports = ArraySerializer;
 
 
 /***/ }),
 
-/***/ 58845:
-/***/ (function(module) {
+/***/ 97059:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const TOMBSTONE = Symbol("tombstone");
-const UNDEFINED_MARKER = Symbol("undefined");
-
-/**
- * @template T
- * @typedef {T | undefined} Cell<T>
- */
-
-/**
- * @template T
- * @typedef {T | typeof TOMBSTONE | typeof UNDEFINED_MARKER} InternalCell<T>
- */
-
-/**
- * @template K
- * @template V
- * @param {[K, InternalCell<V>]} pair the internal cell
- * @returns {[K, Cell<V>]} its “safe” representation
- */
-const extractPair = pair => {
-	const key = pair[0];
-	const val = pair[1];
-	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
-		return [key, undefined];
-	} else {
-		return /** @type {[K, Cell<V>]} */ (pair);
-	}
-};
-
-/**
- * @template K
- * @template V
- */
-class StackedMap {
-	/**
-	 * @param {Map<K, InternalCell<V>>[]=} parentStack an optional parent
-	 */
-	constructor(parentStack) {
-		/** @type {Map<K, InternalCell<V>>} */
-		this.map = new Map();
-		/** @type {Map<K, InternalCell<V>>[]} */
-		this.stack = parentStack === undefined ? [] : parentStack.slice();
-		this.stack.push(this.map);
-	}
-
-	/**
-	 * @param {K} item the key of the element to add
-	 * @param {V} value the value of the element to add
-	 * @returns {void}
-	 */
-	set(item, value) {
-		this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
-	}
-
-	/**
-	 * @param {K} item the item to delete
-	 * @returns {void}
-	 */
-	delete(item) {
-		if (this.stack.length > 1) {
-			this.map.set(item, TOMBSTONE);
-		} else {
-			this.map.delete(item);
-		}
-	}
-
-	/**
-	 * @param {K} item the item to test
-	 * @returns {boolean} true if the item exists in this set
-	 */
-	has(item) {
-		const topValue = this.map.get(item);
-		if (topValue !== undefined) {
-			return topValue !== TOMBSTONE;
-		}
-		if (this.stack.length > 1) {
-			for (let i = this.stack.length - 2; i >= 0; i--) {
-				const value = this.stack[i].get(item);
-				if (value !== undefined) {
-					this.map.set(item, value);
-					return value !== TOMBSTONE;
-				}
-			}
-			this.map.set(item, TOMBSTONE);
-		}
-		return false;
-	}
-
-	/**
-	 * @param {K} item the key of the element to return
-	 * @returns {Cell<V>} the value of the element
-	 */
-	get(item) {
-		const topValue = this.map.get(item);
-		if (topValue !== undefined) {
-			return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
-				? undefined
-				: topValue;
-		}
-		if (this.stack.length > 1) {
-			for (let i = this.stack.length - 2; i >= 0; i--) {
-				const value = this.stack[i].get(item);
-				if (value !== undefined) {
-					this.map.set(item, value);
-					return value === TOMBSTONE || value === UNDEFINED_MARKER
-						? undefined
-						: value;
-				}
-			}
-			this.map.set(item, TOMBSTONE);
-		}
-		return undefined;
-	}
-
-	_compress() {
-		if (this.stack.length === 1) return;
-		this.map = new Map();
-		for (const data of this.stack) {
-			for (const pair of data) {
-				if (pair[1] === TOMBSTONE) {
-					this.map.delete(pair[0]);
-				} else {
-					this.map.set(pair[0], pair[1]);
-				}
-			}
-		}
-		this.stack = [this.map];
-	}
-
-	asArray() {
-		this._compress();
-		return Array.from(this.map.keys());
-	}
-
-	asSet() {
-		this._compress();
-		return new Set(this.map.keys());
-	}
-
-	asPairArray() {
-		this._compress();
-		return Array.from(this.map.entries(), extractPair);
-	}
-
-	asMap() {
-		return new Map(this.asPairArray());
-	}
-
-	get size() {
-		this._compress();
-		return this.map.size;
-	}
-
-	createChild() {
-		return new StackedMap(this.stack);
-	}
-}
-
-module.exports = StackedMap;
-
-
-/***/ }),
+const memoize = __webpack_require__(78676);
+const SerializerMiddleware = __webpack_require__(83137);
 
-/***/ 40293:
-/***/ (function(module) {
+/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-"use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+Format:
 
+File -> Section*
 
+Section -> NullsSection |
+					 BooleansSection |
+					 F64NumbersSection |
+					 I32NumbersSection |
+					 I8NumbersSection |
+					 ShortStringSection |
+					 StringSection |
+					 BufferSection |
+					 NopSection
 
-class StringXor {
-	constructor() {
-		this._value = undefined;
-	}
 
-	/**
-	 * @param {string} str string
-	 * @returns {void}
-	 */
-	add(str) {
-		const len = str.length;
-		const value = this._value;
-		if (value === undefined) {
-			const newValue = (this._value = Buffer.allocUnsafe(len));
-			for (let i = 0; i < len; i++) {
-				newValue[i] = str.charCodeAt(i);
-			}
-			return;
-		}
-		const valueLen = value.length;
-		if (valueLen < len) {
-			const newValue = (this._value = Buffer.allocUnsafe(len));
-			let i;
-			for (i = 0; i < valueLen; i++) {
-				newValue[i] = value[i] ^ str.charCodeAt(i);
-			}
-			for (; i < len; i++) {
-				newValue[i] = str.charCodeAt(i);
-			}
-		} else {
-			for (let i = 0; i < len; i++) {
-				value[i] = value[i] ^ str.charCodeAt(i);
-			}
-		}
-	}
 
-	toString() {
-		const value = this._value;
-		return value === undefined ? "" : value.toString("latin1");
-	}
+NullsSection ->
+	NullHeaderByte | Null2HeaderByte | Null3HeaderByte |
+	Nulls8HeaderByte 0xnn (n:count - 4) |
+	Nulls32HeaderByte n:ui32 (n:count - 260) |
+BooleansSection -> TrueHeaderByte | FalseHeaderByte | BooleansSectionHeaderByte BooleansCountAndBitsByte
+F64NumbersSection -> F64NumbersSectionHeaderByte f64*
+I32NumbersSection -> I32NumbersSectionHeaderByte i32*
+I8NumbersSection -> I8NumbersSectionHeaderByte i8*
+ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
+StringSection -> StringSectionHeaderByte i32:length utf8-byte*
+BufferSection -> BufferSectionHeaderByte i32:length byte*
+NopSection --> NopSectionHeaderByte
 
-	updateHash(hash) {
-		const value = this._value;
-		if (value !== undefined) hash.update(value);
-	}
-}
+ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
 
-module.exports = StringXor;
+F64NumbersSectionHeaderByte -> 0b001n_nnnn (n:count - 1)
+I32NumbersSectionHeaderByte -> 0b010n_nnnn (n:count - 1)
+I8NumbersSectionHeaderByte -> 0b011n_nnnn (n:count - 1)
 
+NullsSectionHeaderByte -> 0b0001_nnnn (n:count - 1)
+BooleansCountAndBitsByte ->
+	0b0000_1xxx (count = 3) |
+	0b0001_xxxx (count = 4) |
+	0b001x_xxxx (count = 5) |
+	0b01xx_xxxx (count = 6) |
+	0b1nnn_nnnn (n:count - 7, 7 <= count <= 133)
+	0xff n:ui32 (n:count, 134 <= count < 2^32)
 
-/***/ }),
+StringSectionHeaderByte -> 0b0000_1110
+BufferSectionHeaderByte -> 0b0000_1111
+NopSectionHeaderByte -> 0b0000_1011
+FalseHeaderByte -> 0b0000_1100
+TrueHeaderByte -> 0b0000_1101
 
-/***/ 38415:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+RawNumber -> n (n <= 10)
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
+const LAZY_HEADER = 0x0b;
+const TRUE_HEADER = 0x0c;
+const FALSE_HEADER = 0x0d;
+const BOOLEANS_HEADER = 0x0e;
+const NULL_HEADER = 0x10;
+const NULL2_HEADER = 0x11;
+const NULL3_HEADER = 0x12;
+const NULLS8_HEADER = 0x13;
+const NULLS32_HEADER = 0x14;
+const NULL_AND_I8_HEADER = 0x15;
+const NULL_AND_I32_HEADER = 0x16;
+const NULL_AND_TRUE_HEADER = 0x17;
+const NULL_AND_FALSE_HEADER = 0x18;
+const STRING_HEADER = 0x1e;
+const BUFFER_HEADER = 0x1f;
+const I8_HEADER = 0x60;
+const I32_HEADER = 0x40;
+const F64_HEADER = 0x20;
+const SHORT_STRING_HEADER = 0x80;
+
+/** Uplift high-order bits */
+const NUMBERS_HEADER_MASK = 0xe0;
+const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
+const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
+
+const HEADER_SIZE = 1;
+const I8_SIZE = 1;
+const I32_SIZE = 4;
+const F64_SIZE = 8;
+
+const MEASURE_START_OPERATION = Symbol("MEASURE_START_OPERATION");
+const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
 
+/** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
+/** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
 
-const TupleSet = __webpack_require__(76455);
+const identifyNumber = n => {
+	if (n === (n | 0)) {
+		if (n <= 127 && n >= -128) return 0;
+		if (n <= 2147483647 && n >= -2147483648) return 1;
+	}
+	return 2;
+};
 
 /**
- * @template {any[]} T
+ * @typedef {PrimitiveSerializableType[]} DeserializedType
+ * @typedef {BufferSerializableType[]} SerializedType
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
-class TupleQueue {
+class BinaryMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {Iterable<T>=} items The initial elements.
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
 	 */
-	constructor(items) {
-		/** @private @type {TupleSet<T>} */
-		this._set = new TupleSet(items);
-		/** @private @type {Iterator<T>} */
-		this._iterator = this._set[Symbol.iterator]();
+	serialize(data, context) {
+		return this._serialize(data, context);
 	}
 
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this._set.size;
+	_serializeLazy(fn, context) {
+		return SerializerMiddleware.serializeLazy(fn, data =>
+			this._serialize(data, context)
+		);
 	}
 
 	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
+	 * @returns {SerializedType} serialized data
 	 */
-	enqueue(...item) {
-		this._set.add(...item);
-	}
+	_serialize(
+		data,
+		context,
+		allocationScope = {
+			allocationSize: 1024,
+			increaseCounter: 0,
+			leftOverBuffer: null
+		}
+	) {
+		/** @type {Buffer} */
+		let leftOverBuffer = null;
+		/** @type {BufferSerializableType[]} */
+		let buffers = [];
+		/** @type {Buffer} */
+		let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
+		allocationScope.leftOverBuffer = null;
+		let currentPosition = 0;
+		if (currentBuffer === null) {
+			currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
+		}
+		const allocate = bytesNeeded => {
+			if (currentBuffer !== null) {
+				if (currentBuffer.length - currentPosition >= bytesNeeded) return;
+				flush();
+			}
+			if (leftOverBuffer && leftOverBuffer.length >= bytesNeeded) {
+				currentBuffer = leftOverBuffer;
+				leftOverBuffer = null;
+			} else {
+				currentBuffer = Buffer.allocUnsafe(
+					Math.max(bytesNeeded, allocationScope.allocationSize)
+				);
+				if (
+					!(allocationScope.increaseCounter =
+						(allocationScope.increaseCounter + 1) % 4) &&
+					allocationScope.allocationSize < 16777216
+				) {
+					allocationScope.allocationSize = allocationScope.allocationSize << 1;
+				}
+			}
+		};
+		const flush = () => {
+			if (currentBuffer !== null) {
+				if (currentPosition > 0) {
+					buffers.push(
+						Buffer.from(
+							currentBuffer.buffer,
+							currentBuffer.byteOffset,
+							currentPosition
+						)
+					);
+				}
+				if (
+					!leftOverBuffer ||
+					leftOverBuffer.length < currentBuffer.length - currentPosition
+				) {
+					leftOverBuffer = Buffer.from(
+						currentBuffer.buffer,
+						currentBuffer.byteOffset + currentPosition,
+						currentBuffer.byteLength - currentPosition
+					);
+				}
 
-	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
-	 */
-	dequeue() {
-		const result = this._iterator.next();
-		if (result.done) {
-			if (this._set.size > 0) {
-				this._iterator = this._set[Symbol.iterator]();
-				const value = this._iterator.next().value;
-				this._set.delete(...value);
-				return value;
+				currentBuffer = null;
+				currentPosition = 0;
+			}
+		};
+		const writeU8 = byte => {
+			currentBuffer.writeUInt8(byte, currentPosition++);
+		};
+		const writeU32 = ui32 => {
+			currentBuffer.writeUInt32LE(ui32, currentPosition);
+			currentPosition += 4;
+		};
+		const measureStack = [];
+		const measureStart = () => {
+			measureStack.push(buffers.length, currentPosition);
+		};
+		const measureEnd = () => {
+			const oldPos = measureStack.pop();
+			const buffersIndex = measureStack.pop();
+			let size = currentPosition - oldPos;
+			for (let i = buffersIndex; i < buffers.length; i++) {
+				size += buffers[i].length;
+			}
+			return size;
+		};
+		for (let i = 0; i < data.length; i++) {
+			const thing = data[i];
+			switch (typeof thing) {
+				case "function": {
+					if (!SerializerMiddleware.isLazy(thing))
+						throw new Error("Unexpected function " + thing);
+					/** @type {SerializedType | (() => SerializedType)} */
+					let serializedData =
+						SerializerMiddleware.getLazySerializedValue(thing);
+					if (serializedData === undefined) {
+						if (SerializerMiddleware.isLazy(thing, this)) {
+							flush();
+							allocationScope.leftOverBuffer = leftOverBuffer;
+							const result =
+								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
+									thing()
+								);
+							const data = this._serialize(result, context, allocationScope);
+							leftOverBuffer = allocationScope.leftOverBuffer;
+							allocationScope.leftOverBuffer = null;
+							SerializerMiddleware.setLazySerializedValue(thing, data);
+							serializedData = data;
+						} else {
+							serializedData = this._serializeLazy(thing, context);
+							flush();
+							buffers.push(serializedData);
+							break;
+						}
+					} else {
+						if (typeof serializedData === "function") {
+							flush();
+							buffers.push(serializedData);
+							break;
+						}
+					}
+					const lengths = [];
+					for (const item of serializedData) {
+						let last;
+						if (typeof item === "function") {
+							lengths.push(0);
+						} else if (item.length === 0) {
+							// ignore
+						} else if (
+							lengths.length > 0 &&
+							(last = lengths[lengths.length - 1]) !== 0
+						) {
+							const remaining = 0xffffffff - last;
+							if (remaining >= item.length) {
+								lengths[lengths.length - 1] += item.length;
+							} else {
+								lengths.push(item.length - remaining);
+								lengths[lengths.length - 2] = 0xffffffff;
+							}
+						} else {
+							lengths.push(item.length);
+						}
+					}
+					allocate(5 + lengths.length * 4);
+					writeU8(LAZY_HEADER);
+					writeU32(lengths.length);
+					for (const l of lengths) {
+						writeU32(l);
+					}
+					flush();
+					for (const item of serializedData) {
+						buffers.push(item);
+					}
+					break;
+				}
+				case "string": {
+					const len = Buffer.byteLength(thing);
+					if (len >= 128 || len !== thing.length) {
+						allocate(len + HEADER_SIZE + I32_SIZE);
+						writeU8(STRING_HEADER);
+						writeU32(len);
+						currentBuffer.write(thing, currentPosition);
+						currentPosition += len;
+					} else if (len >= 70) {
+						allocate(len + HEADER_SIZE);
+						writeU8(SHORT_STRING_HEADER | len);
+
+						currentBuffer.write(thing, currentPosition, "latin1");
+						currentPosition += len;
+					} else {
+						allocate(len + HEADER_SIZE);
+						writeU8(SHORT_STRING_HEADER | len);
+
+						for (let i = 0; i < len; i++) {
+							currentBuffer[currentPosition++] = thing.charCodeAt(i);
+						}
+					}
+					break;
+				}
+				case "number": {
+					const type = identifyNumber(thing);
+					if (type === 0 && thing >= 0 && thing <= 10) {
+						// shortcut for very small numbers
+						allocate(I8_SIZE);
+						writeU8(thing);
+						break;
+					}
+					/**
+					 * amount of numbers to write
+					 * @type {number}
+					 */
+					let n = 1;
+					for (; n < 32 && i + n < data.length; n++) {
+						const item = data[i + n];
+						if (typeof item !== "number") break;
+						if (identifyNumber(item) !== type) break;
+					}
+					switch (type) {
+						case 0:
+							allocate(HEADER_SIZE + I8_SIZE * n);
+							writeU8(I8_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt8(
+									/** @type {number} */ (data[i]),
+									currentPosition
+								);
+								currentPosition += I8_SIZE;
+								n--;
+								i++;
+							}
+							break;
+						case 1:
+							allocate(HEADER_SIZE + I32_SIZE * n);
+							writeU8(I32_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt32LE(
+									/** @type {number} */ (data[i]),
+									currentPosition
+								);
+								currentPosition += I32_SIZE;
+								n--;
+								i++;
+							}
+							break;
+						case 2:
+							allocate(HEADER_SIZE + F64_SIZE * n);
+							writeU8(F64_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeDoubleLE(
+									/** @type {number} */ (data[i]),
+									currentPosition
+								);
+								currentPosition += F64_SIZE;
+								n--;
+								i++;
+							}
+							break;
+					}
+
+					i--;
+					break;
+				}
+				case "boolean": {
+					let lastByte = thing === true ? 1 : 0;
+					const bytes = [];
+					let count = 1;
+					let n;
+					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
+						const item = data[i + n];
+						if (typeof item !== "boolean") break;
+						const pos = count & 0x7;
+						if (pos === 0) {
+							bytes.push(lastByte);
+							lastByte = item === true ? 1 : 0;
+						} else if (item === true) {
+							lastByte |= 1 << pos;
+						}
+						count++;
+					}
+					i += count - 1;
+					if (count === 1) {
+						allocate(HEADER_SIZE);
+						writeU8(lastByte === 1 ? TRUE_HEADER : FALSE_HEADER);
+					} else if (count === 2) {
+						allocate(HEADER_SIZE * 2);
+						writeU8(lastByte & 1 ? TRUE_HEADER : FALSE_HEADER);
+						writeU8(lastByte & 2 ? TRUE_HEADER : FALSE_HEADER);
+					} else if (count <= 6) {
+						allocate(HEADER_SIZE + I8_SIZE);
+						writeU8(BOOLEANS_HEADER);
+						writeU8((1 << count) | lastByte);
+					} else if (count <= 133) {
+						allocate(HEADER_SIZE + I8_SIZE + I8_SIZE * bytes.length + I8_SIZE);
+						writeU8(BOOLEANS_HEADER);
+						writeU8(0x80 | (count - 7));
+						for (const byte of bytes) writeU8(byte);
+						writeU8(lastByte);
+					} else {
+						allocate(
+							HEADER_SIZE +
+								I8_SIZE +
+								I32_SIZE +
+								I8_SIZE * bytes.length +
+								I8_SIZE
+						);
+						writeU8(BOOLEANS_HEADER);
+						writeU8(0xff);
+						writeU32(count);
+						for (const byte of bytes) writeU8(byte);
+						writeU8(lastByte);
+					}
+					break;
+				}
+				case "object": {
+					if (thing === null) {
+						let n;
+						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
+							const item = data[i + n];
+							if (item !== null) break;
+						}
+						i += n - 1;
+						if (n === 1) {
+							if (i + 1 < data.length) {
+								const next = data[i + 1];
+								if (next === true) {
+									allocate(HEADER_SIZE);
+									writeU8(NULL_AND_TRUE_HEADER);
+									i++;
+								} else if (next === false) {
+									allocate(HEADER_SIZE);
+									writeU8(NULL_AND_FALSE_HEADER);
+									i++;
+								} else if (typeof next === "number") {
+									const type = identifyNumber(next);
+									if (type === 0) {
+										allocate(HEADER_SIZE + I8_SIZE);
+										writeU8(NULL_AND_I8_HEADER);
+										currentBuffer.writeInt8(next, currentPosition);
+										currentPosition += I8_SIZE;
+										i++;
+									} else if (type === 1) {
+										allocate(HEADER_SIZE + I32_SIZE);
+										writeU8(NULL_AND_I32_HEADER);
+										currentBuffer.writeInt32LE(next, currentPosition);
+										currentPosition += I32_SIZE;
+										i++;
+									} else {
+										allocate(HEADER_SIZE);
+										writeU8(NULL_HEADER);
+									}
+								} else {
+									allocate(HEADER_SIZE);
+									writeU8(NULL_HEADER);
+								}
+							} else {
+								allocate(HEADER_SIZE);
+								writeU8(NULL_HEADER);
+							}
+						} else if (n === 2) {
+							allocate(HEADER_SIZE);
+							writeU8(NULL2_HEADER);
+						} else if (n === 3) {
+							allocate(HEADER_SIZE);
+							writeU8(NULL3_HEADER);
+						} else if (n < 260) {
+							allocate(HEADER_SIZE + I8_SIZE);
+							writeU8(NULLS8_HEADER);
+							writeU8(n - 4);
+						} else {
+							allocate(HEADER_SIZE + I32_SIZE);
+							writeU8(NULLS32_HEADER);
+							writeU32(n - 260);
+						}
+					} else if (Buffer.isBuffer(thing)) {
+						if (thing.length < 8192) {
+							allocate(HEADER_SIZE + I32_SIZE + thing.length);
+							writeU8(BUFFER_HEADER);
+							writeU32(thing.length);
+							thing.copy(currentBuffer, currentPosition);
+							currentPosition += thing.length;
+						} else {
+							allocate(HEADER_SIZE + I32_SIZE);
+							writeU8(BUFFER_HEADER);
+							writeU32(thing.length);
+							flush();
+							buffers.push(thing);
+						}
+					}
+					break;
+				}
+				case "symbol": {
+					if (thing === MEASURE_START_OPERATION) {
+						measureStart();
+					} else if (thing === MEASURE_END_OPERATION) {
+						const size = measureEnd();
+						allocate(HEADER_SIZE + I32_SIZE);
+						writeU8(I32_HEADER);
+						currentBuffer.writeInt32LE(size, currentPosition);
+						currentPosition += I32_SIZE;
+					}
+					break;
+				}
 			}
-			return undefined;
 		}
-		this._set.delete(...result.value);
-		return result.value;
-	}
-}
-
-module.exports = TupleQueue;
-
-
-/***/ }),
-
-/***/ 76455:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+		flush();
 
+		allocationScope.leftOverBuffer = leftOverBuffer;
 
-/**
- * @template {any[]} T
- */
-class TupleSet {
-	constructor(init) {
-		this._map = new Map();
-		this.size = 0;
-		if (init) {
-			for (const tuple of init) {
-				this.add(...tuple);
-			}
-		}
+		// avoid leaking memory
+		currentBuffer = null;
+		leftOverBuffer = null;
+		allocationScope = undefined;
+		const _buffers = buffers;
+		buffers = undefined;
+		return _buffers;
 	}
 
 	/**
-	 * @param  {T} args tuple
-	 * @returns {void}
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	add(...args) {
-		let map = this._map;
-		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			const innerMap = map.get(arg);
-			if (innerMap === undefined) {
-				map.set(arg, (map = new Map()));
-			} else {
-				map = innerMap;
-			}
-		}
-
-		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
-		if (set === undefined) {
-			map.set(beforeLast, (set = new Set()));
-		}
-
-		const last = args[args.length - 1];
-		this.size -= set.size;
-		set.add(last);
-		this.size += set.size;
+	deserialize(data, context) {
+		return this._deserialize(data, context);
 	}
 
-	/**
-	 * @param  {T} args tuple
-	 * @returns {boolean} true, if the tuple is in the Set
-	 */
-	has(...args) {
-		let map = this._map;
-		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = map.get(arg);
-			if (map === undefined) {
-				return false;
-			}
-		}
-
-		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
-		if (set === undefined) {
-			return false;
-		}
-
-		const last = args[args.length - 1];
-		return set.has(last);
+	_createLazyDeserialized(content, context) {
+		return SerializerMiddleware.createLazy(
+			memoize(() => this._deserialize(content, context)),
+			this,
+			undefined,
+			content
+		);
 	}
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {void}
-	 */
-	delete(...args) {
-		let map = this._map;
-		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = map.get(arg);
-			if (map === undefined) {
-				return;
-			}
-		}
-
-		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
-		if (set === undefined) {
-			return;
-		}
-
-		const last = args[args.length - 1];
-		this.size -= set.size;
-		set.delete(last);
-		this.size += set.size;
+	_deserializeLazy(fn, context) {
+		return SerializerMiddleware.deserializeLazy(fn, data =>
+			this._deserialize(data, context)
+		);
 	}
 
 	/**
-	 * @returns {Iterator<T>} iterator
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType} deserialized data
 	 */
-	[Symbol.iterator]() {
-		const iteratorStack = [];
-		const tuple = [];
-		let currentSetIterator = undefined;
+	_deserialize(data, context) {
+		let currentDataItem = 0;
+		let currentBuffer = data[0];
+		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
+		let currentPosition = 0;
 
-		const next = it => {
-			const result = it.next();
-			if (result.done) {
-				if (iteratorStack.length === 0) return false;
-				tuple.pop();
-				return next(iteratorStack.pop());
+		const retainedBuffer = context.retainedBuffer || (x => x);
+
+		const checkOverflow = () => {
+			if (currentPosition >= currentBuffer.length) {
+				currentPosition = 0;
+				currentDataItem++;
+				currentBuffer =
+					currentDataItem < data.length ? data[currentDataItem] : null;
+				currentIsBuffer = Buffer.isBuffer(currentBuffer);
 			}
-			const [key, value] = result.value;
-			iteratorStack.push(it);
-			tuple.push(key);
-			if (value instanceof Set) {
-				currentSetIterator = value[Symbol.iterator]();
-				return true;
-			} else {
-				return next(value[Symbol.iterator]());
+		};
+		const isInCurrentBuffer = n => {
+			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
+		};
+		const ensureBuffer = () => {
+			if (!currentIsBuffer) {
+				throw new Error(
+					currentBuffer === null
+						? "Unexpected end of stream"
+						: "Unexpected lazy element in stream"
+				);
 			}
 		};
-
-		next(this._map[Symbol.iterator]());
-
-		return {
-			next() {
-				while (currentSetIterator) {
-					const result = currentSetIterator.next();
-					if (result.done) {
-						tuple.pop();
-						if (!next(iteratorStack.pop())) {
-							currentSetIterator = undefined;
+		/**
+		 * Reads n bytes
+		 * @param {number} n amount of bytes to read
+		 * @returns {Buffer} buffer with bytes
+		 */
+		const read = n => {
+			ensureBuffer();
+			const rem = currentBuffer.length - currentPosition;
+			if (rem < n) {
+				const buffers = [read(rem)];
+				n -= rem;
+				ensureBuffer();
+				while (currentBuffer.length < n) {
+					const b = /** @type {Buffer} */ (currentBuffer);
+					buffers.push(b);
+					n -= b.length;
+					currentDataItem++;
+					currentBuffer =
+						currentDataItem < data.length ? data[currentDataItem] : null;
+					currentIsBuffer = Buffer.isBuffer(currentBuffer);
+					ensureBuffer();
+				}
+				buffers.push(read(n));
+				return Buffer.concat(buffers);
+			}
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
+			currentPosition += n;
+			checkOverflow();
+			return res;
+		};
+		/**
+		 * Reads up to n bytes
+		 * @param {number} n amount of bytes to read
+		 * @returns {Buffer} buffer with bytes
+		 */
+		const readUpTo = n => {
+			ensureBuffer();
+			const rem = currentBuffer.length - currentPosition;
+			if (rem < n) {
+				n = rem;
+			}
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
+			currentPosition += n;
+			checkOverflow();
+			return res;
+		};
+		const readU8 = () => {
+			ensureBuffer();
+			/**
+			 * There is no need to check remaining buffer size here
+			 * since {@link checkOverflow} guarantees at least one byte remaining
+			 */
+			const byte = /** @type {Buffer} */ (currentBuffer).readUInt8(
+				currentPosition
+			);
+			currentPosition += I8_SIZE;
+			checkOverflow();
+			return byte;
+		};
+		const readU32 = () => {
+			return read(I32_SIZE).readUInt32LE(0);
+		};
+		const readBits = (data, n) => {
+			let mask = 1;
+			while (n !== 0) {
+				result.push((data & mask) !== 0);
+				mask = mask << 1;
+				n--;
+			}
+		};
+		const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
+			switch (header) {
+				case LAZY_HEADER:
+					return () => {
+						const count = readU32();
+						const lengths = Array.from({ length: count }).map(() => readU32());
+						const content = [];
+						for (let l of lengths) {
+							if (l === 0) {
+								if (typeof currentBuffer !== "function") {
+									throw new Error("Unexpected non-lazy element in stream");
+								}
+								content.push(currentBuffer);
+								currentDataItem++;
+								currentBuffer =
+									currentDataItem < data.length ? data[currentDataItem] : null;
+								currentIsBuffer = Buffer.isBuffer(currentBuffer);
+							} else {
+								do {
+									const buf = readUpTo(l);
+									l -= buf.length;
+									content.push(retainedBuffer(buf));
+								} while (l > 0);
+							}
+						}
+						result.push(this._createLazyDeserialized(content, context));
+					};
+				case BUFFER_HEADER:
+					return () => {
+						const len = readU32();
+						result.push(retainedBuffer(read(len)));
+					};
+				case TRUE_HEADER:
+					return () => result.push(true);
+				case FALSE_HEADER:
+					return () => result.push(false);
+				case NULL3_HEADER:
+					return () => result.push(null, null, null);
+				case NULL2_HEADER:
+					return () => result.push(null, null);
+				case NULL_HEADER:
+					return () => result.push(null);
+				case NULL_AND_TRUE_HEADER:
+					return () => result.push(null, true);
+				case NULL_AND_FALSE_HEADER:
+					return () => result.push(null, false);
+				case NULL_AND_I8_HEADER:
+					return () => {
+						if (currentIsBuffer) {
+							result.push(
+								null,
+								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
+							);
+							currentPosition += I8_SIZE;
+							checkOverflow();
+						} else {
+							result.push(null, read(I8_SIZE).readInt8(0));
+						}
+					};
+				case NULL_AND_I32_HEADER:
+					return () => {
+						result.push(null);
+						if (isInCurrentBuffer(I32_SIZE)) {
+							result.push(
+								/** @type {Buffer} */ (currentBuffer).readInt32LE(
+									currentPosition
+								)
+							);
+							currentPosition += I32_SIZE;
+							checkOverflow();
+						} else {
+							result.push(read(I32_SIZE).readInt32LE(0));
+						}
+					};
+				case NULLS8_HEADER:
+					return () => {
+						const len = readU8() + 4;
+						for (let i = 0; i < len; i++) {
+							result.push(null);
+						}
+					};
+				case NULLS32_HEADER:
+					return () => {
+						const len = readU32() + 260;
+						for (let i = 0; i < len; i++) {
+							result.push(null);
+						}
+					};
+				case BOOLEANS_HEADER:
+					return () => {
+						const innerHeader = readU8();
+						if ((innerHeader & 0xf0) === 0) {
+							readBits(innerHeader, 3);
+						} else if ((innerHeader & 0xe0) === 0) {
+							readBits(innerHeader, 4);
+						} else if ((innerHeader & 0xc0) === 0) {
+							readBits(innerHeader, 5);
+						} else if ((innerHeader & 0x80) === 0) {
+							readBits(innerHeader, 6);
+						} else if (innerHeader !== 0xff) {
+							let count = (innerHeader & 0x7f) + 7;
+							while (count > 8) {
+								readBits(readU8(), 8);
+								count -= 8;
+							}
+							readBits(readU8(), count);
+						} else {
+							let count = readU32();
+							while (count > 8) {
+								readBits(readU8(), 8);
+								count -= 8;
+							}
+							readBits(readU8(), count);
+						}
+					};
+				case STRING_HEADER:
+					return () => {
+						const len = readU32();
+						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+							result.push(
+								currentBuffer.toString(
+									undefined,
+									currentPosition,
+									currentPosition + len
+								)
+							);
+							currentPosition += len;
+							checkOverflow();
+						} else {
+							result.push(read(len).toString());
+						}
+					};
+				case SHORT_STRING_HEADER:
+					return () => result.push("");
+				case SHORT_STRING_HEADER | 1:
+					return () => {
+						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
+							result.push(
+								currentBuffer.toString(
+									"latin1",
+									currentPosition,
+									currentPosition + 1
+								)
+							);
+							currentPosition++;
+							checkOverflow();
+						} else {
+							result.push(read(1).toString("latin1"));
+						}
+					};
+				case I8_HEADER:
+					return () => {
+						if (currentIsBuffer) {
+							result.push(
+								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
+							);
+							currentPosition++;
+							checkOverflow();
+						} else {
+							result.push(read(1).readInt8(0));
 						}
+					};
+				default:
+					if (header <= 10) {
+						return () => result.push(header);
+					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
+						const len = header & SHORT_STRING_LENGTH_MASK;
+						return () => {
+							if (
+								isInCurrentBuffer(len) &&
+								currentPosition + len < 0x7fffffff
+							) {
+								result.push(
+									currentBuffer.toString(
+										"latin1",
+										currentPosition,
+										currentPosition + len
+									)
+								);
+								currentPosition += len;
+								checkOverflow();
+							} else {
+								result.push(read(len).toString("latin1"));
+							}
+						};
+					} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
+						const len = (header & NUMBERS_COUNT_MASK) + 1;
+						return () => {
+							const need = F64_SIZE * len;
+							if (isInCurrentBuffer(need)) {
+								for (let i = 0; i < len; i++) {
+									result.push(
+										/** @type {Buffer} */ (currentBuffer).readDoubleLE(
+											currentPosition
+										)
+									);
+									currentPosition += F64_SIZE;
+								}
+								checkOverflow();
+							} else {
+								const buf = read(need);
+								for (let i = 0; i < len; i++) {
+									result.push(buf.readDoubleLE(i * F64_SIZE));
+								}
+							}
+						};
+					} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
+						const len = (header & NUMBERS_COUNT_MASK) + 1;
+						return () => {
+							const need = I32_SIZE * len;
+							if (isInCurrentBuffer(need)) {
+								for (let i = 0; i < len; i++) {
+									result.push(
+										/** @type {Buffer} */ (currentBuffer).readInt32LE(
+											currentPosition
+										)
+									);
+									currentPosition += I32_SIZE;
+								}
+								checkOverflow();
+							} else {
+								const buf = read(need);
+								for (let i = 0; i < len; i++) {
+									result.push(buf.readInt32LE(i * I32_SIZE));
+								}
+							}
+						};
+					} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
+						const len = (header & NUMBERS_COUNT_MASK) + 1;
+						return () => {
+							const need = I8_SIZE * len;
+							if (isInCurrentBuffer(need)) {
+								for (let i = 0; i < len; i++) {
+									result.push(
+										/** @type {Buffer} */ (currentBuffer).readInt8(
+											currentPosition
+										)
+									);
+									currentPosition += I8_SIZE;
+								}
+								checkOverflow();
+							} else {
+								const buf = read(need);
+								for (let i = 0; i < len; i++) {
+									result.push(buf.readInt8(i * I8_SIZE));
+								}
+							}
+						};
 					} else {
-						return {
-							done: false,
-							value: /** @type {T} */ (tuple.concat(result.value))
+						return () => {
+							throw new Error(
+								`Unexpected header byte 0x${header.toString(16)}`
+							);
 						};
 					}
-				}
-				return { done: true, value: undefined };
 			}
-		};
+		});
+
+		/** @type {DeserializedType} */
+		let result = [];
+		while (currentBuffer !== null) {
+			if (typeof currentBuffer === "function") {
+				result.push(this._deserializeLazy(currentBuffer, context));
+				currentDataItem++;
+				currentBuffer =
+					currentDataItem < data.length ? data[currentDataItem] : null;
+				currentIsBuffer = Buffer.isBuffer(currentBuffer);
+			} else {
+				const header = readU8();
+				dispatchTable[header]();
+			}
+		}
+
+		// avoid leaking memory in context
+		let _result = result;
+		result = undefined;
+		return _result;
 	}
 }
 
-module.exports = TupleSet;
+module.exports = BinaryMiddleware;
+
+module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
+module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
 
 
 /***/ }),
 
-/***/ 54500:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 93475:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
 */
 
 
 
-/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
-/** @typedef {(error: Error|null, result?: Buffer) => void} ErrorFirstCallback */
+class DateObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.getTime());
+	}
+	deserialize({ read }) {
+		return new Date(read());
+	}
+}
 
-const backSlashCharCode = "\\".charCodeAt(0);
-const slashCharCode = "/".charCodeAt(0);
-const aLowerCaseCharCode = "a".charCodeAt(0);
-const zLowerCaseCharCode = "z".charCodeAt(0);
-const aUpperCaseCharCode = "A".charCodeAt(0);
-const zUpperCaseCharCode = "Z".charCodeAt(0);
-const _0CharCode = "0".charCodeAt(0);
-const _9CharCode = "9".charCodeAt(0);
-const plusCharCode = "+".charCodeAt(0);
-const hyphenCharCode = "-".charCodeAt(0);
-const colonCharCode = ":".charCodeAt(0);
-const hashCharCode = "#".charCodeAt(0);
-const queryCharCode = "?".charCodeAt(0);
-/**
- * Get scheme if specifier is an absolute URL specifier
- * e.g. Absolute specifiers like 'file:///user/webpack/index.js'
- * https://tools.ietf.org/html/rfc3986#section-3.1
- * @param {string} specifier specifier
- * @returns {string|undefined} scheme if absolute URL specifier provided
- */
-function getScheme(specifier) {
-	const start = specifier.charCodeAt(0);
+module.exports = DateObjectSerializer;
 
-	// First char maybe only a letter
-	if (
-		(start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
-		(start < aUpperCaseCharCode || start > zUpperCaseCharCode)
-	) {
-		return undefined;
-	}
 
-	let i = 1;
-	let ch = specifier.charCodeAt(i);
+/***/ }),
 
-	while (
-		(ch >= aLowerCaseCharCode && ch <= zLowerCaseCharCode) ||
-		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
-		(ch >= _0CharCode && ch <= _9CharCode) ||
-		ch === plusCharCode ||
-		ch === hyphenCharCode
-	) {
-		if (++i === specifier.length) return undefined;
-		ch = specifier.charCodeAt(i);
-	}
+/***/ 79479:
+/***/ (function(module) {
 
-	// Scheme must end with colon
-	if (ch !== colonCharCode) return undefined;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-	// Check for Windows absolute path
-	// https://url.spec.whatwg.org/#url-miscellaneous
-	if (i === 1) {
-		const nextChar = i + 1 < specifier.length ? specifier.charCodeAt(i + 1) : 0;
-		if (
-			nextChar === 0 ||
-			nextChar === backSlashCharCode ||
-			nextChar === slashCharCode ||
-			nextChar === hashCharCode ||
-			nextChar === queryCharCode
-		) {
-			return undefined;
-		}
+
+
+class ErrorObjectSerializer {
+	constructor(Type) {
+		this.Type = Type;
 	}
 
-	return specifier.slice(0, i).toLowerCase();
-}
+	serialize(obj, { write }) {
+		write(obj.message);
+		write(obj.stack);
+	}
 
-/**
- * @param {string} specifier specifier
- * @returns {string|null} protocol if absolute URL specifier provided
- */
-function getProtocol(specifier) {
-	const scheme = getScheme(specifier);
-	return scheme === undefined ? undefined : scheme + ":";
+	deserialize({ read }) {
+		const err = new this.Type();
+
+		err.message = read();
+		err.stack = read();
+
+		return err;
+	}
 }
 
-exports.getScheme = getScheme;
-exports.getProtocol = getProtocol;
+module.exports = ErrorObjectSerializer;
 
 
 /***/ }),
 
-/***/ 28745:
-/***/ (function(module) {
+/***/ 65321:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const isWeakKey = thing => typeof thing === "object" && thing !== null;
+const { constants } = __webpack_require__(14300);
+const { pipeline } = __webpack_require__(12781);
+const {
+	createBrotliCompress,
+	createBrotliDecompress,
+	createGzip,
+	createGunzip,
+	constants: zConstants
+} = __webpack_require__(59796);
+const createHash = __webpack_require__(49835);
+const { dirname, join, mkdirp } = __webpack_require__(17139);
+const memoize = __webpack_require__(78676);
+const SerializerMiddleware = __webpack_require__(83137);
+
+/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+
+/*
+Format:
+
+File -> Header Section*
+
+Version -> u32
+AmountOfSections -> u32
+SectionSize -> i32 (if less than zero represents lazy value)
+
+Header -> Version AmountOfSections SectionSize*
+
+Buffer -> n bytes
+Section -> Buffer
+
+*/
+
+// "wpc" + 1 in little-endian
+const VERSION = 0x01637077;
 
 /**
- * @template {any[]} T
- * @template V
+ * @param {Buffer[]} buffers buffers
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
  */
-class WeakTupleMap {
-	constructor() {
-		/** @private */
-		this.f = 0;
-		/** @private @type {any} */
-		this.v = undefined;
-		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
-		this.m = undefined;
-		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
-		this.w = undefined;
-	}
+const hashForName = (buffers, hashFunction) => {
+	const hash = createHash(hashFunction);
+	for (const buf of buffers) hash.update(buf);
+	return /** @type {string} */ (hash.digest("hex"));
+};
 
-	/**
-	 * @param {[...T, V]} args tuple
-	 * @returns {void}
-	 */
-	set(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
-		}
-		node._setValue(args[args.length - 1]);
-	}
+const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
+const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {boolean} true, if the tuple is in the Set
-	 */
-	has(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
-			if (node === undefined) return false;
-		}
-		return node._hasValue();
-	}
+const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
+	? (buf, value, offset) => {
+			buf.writeBigUInt64LE(BigInt(value), offset);
+	  }
+	: (buf, value, offset) => {
+			const low = value % 0x100000000;
+			const high = (value - low) / 0x100000000;
+			buf.writeUInt32LE(low, offset);
+			buf.writeUInt32LE(high, offset + 4);
+	  };
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {V} the value
-	 */
-	get(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
-			if (node === undefined) return undefined;
-		}
-		return node._getValue();
-	}
+const readUInt64LE = Buffer.prototype.readBigUInt64LE
+	? (buf, offset) => {
+			return Number(buf.readBigUInt64LE(offset));
+	  }
+	: (buf, offset) => {
+			const low = buf.readUInt32LE(offset);
+			const high = buf.readUInt32LE(offset + 4);
+			return high * 0x100000000 + low;
+	  };
 
-	/**
-	 * @param {[...T, function(): V]} args tuple
-	 * @returns {V} the value
-	 */
-	provide(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
-		}
-		if (node._hasValue()) return node._getValue();
-		const fn = args[args.length - 1];
-		const newValue = fn(...args.slice(0, -1));
-		node._setValue(newValue);
-		return newValue;
-	}
+/**
+ * @typedef {Object} SerializeResult
+ * @property {string | false} name
+ * @property {number} size
+ * @property {Promise=} backgroundJob
+ */
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {void}
-	 */
-	delete(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
-			if (node === undefined) return;
+/**
+ * @param {FileMiddleware} middleware this
+ * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
+ * @param {string | boolean} name file base name
+ * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {Promise<SerializeResult>} resulting file pointer and promise
+ */
+const serialize = async (
+	middleware,
+	data,
+	name,
+	writeFile,
+	hashFunction = "md4"
+) => {
+	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
+	const processedData = [];
+	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
+	const resultToLazy = new WeakMap();
+	/** @type {Buffer[]} */
+	let lastBuffers = undefined;
+	for (const item of await data) {
+		if (typeof item === "function") {
+			if (!SerializerMiddleware.isLazy(item))
+				throw new Error("Unexpected function");
+			if (!SerializerMiddleware.isLazy(item, middleware)) {
+				throw new Error(
+					"Unexpected lazy value with non-this target (can't pass through lazy values)"
+				);
+			}
+			lastBuffers = undefined;
+			const serializedInfo = SerializerMiddleware.getLazySerializedValue(item);
+			if (serializedInfo) {
+				if (typeof serializedInfo === "function") {
+					throw new Error(
+						"Unexpected lazy value with non-this target (can't pass through lazy values)"
+					);
+				} else {
+					processedData.push(serializedInfo);
+				}
+			} else {
+				const content = item();
+				if (content) {
+					const options = SerializerMiddleware.getLazyOptions(item);
+					processedData.push(
+						serialize(
+							middleware,
+							content,
+							(options && options.name) || true,
+							writeFile,
+							hashFunction
+						).then(result => {
+							/** @type {any} */ (item).options.size = result.size;
+							resultToLazy.set(result, item);
+							return result;
+						})
+					);
+				} else {
+					throw new Error(
+						"Unexpected falsy value returned by lazy value function"
+					);
+				}
+			}
+		} else if (item) {
+			if (lastBuffers) {
+				lastBuffers.push(item);
+			} else {
+				lastBuffers = [item];
+				processedData.push(lastBuffers);
+			}
+		} else {
+			throw new Error("Unexpected falsy value in items array");
 		}
-		node._deleteValue();
 	}
+	/** @type {Promise<any>[]} */
+	const backgroundJobs = [];
+	const resolvedData = (
+		await Promise.all(
+			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (
+				processedData
+			)
+		)
+	).map(item => {
+		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
 
-	/**
-	 * @returns {void}
-	 */
-	clear() {
-		this.f = 0;
-		this.v = undefined;
-		this.w = undefined;
-		this.m = undefined;
+		backgroundJobs.push(item.backgroundJob);
+		// create pointer buffer from size and name
+		const name = /** @type {string} */ (item.name);
+		const nameBuffer = Buffer.from(name);
+		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
+		writeUInt64LE(buf, item.size, 0);
+		nameBuffer.copy(buf, 8, 0);
+		const lazy = resultToLazy.get(item);
+		SerializerMiddleware.setLazySerializedValue(lazy, buf);
+		return buf;
+	});
+	const lengths = [];
+	for (const item of resolvedData) {
+		if (Array.isArray(item)) {
+			let l = 0;
+			for (const b of item) l += b.length;
+			while (l > 0x7fffffff) {
+				lengths.push(0x7fffffff);
+				l -= 0x7fffffff;
+			}
+			lengths.push(l);
+		} else if (item) {
+			lengths.push(-item.length);
+		} else {
+			throw new Error("Unexpected falsy value in resolved data " + item);
+		}
 	}
-
-	_getValue() {
-		return this.v;
+	const header = Buffer.allocUnsafe(8 + lengths.length * 4);
+	header.writeUInt32LE(VERSION, 0);
+	header.writeUInt32LE(lengths.length, 4);
+	for (let i = 0; i < lengths.length; i++) {
+		header.writeInt32LE(lengths[i], 8 + i * 4);
 	}
-
-	_hasValue() {
-		return (this.f & 1) === 1;
+	const buf = [header];
+	for (const item of resolvedData) {
+		if (Array.isArray(item)) {
+			for (const b of item) buf.push(b);
+		} else if (item) {
+			buf.push(item);
+		}
 	}
-
-	_setValue(v) {
-		this.f |= 1;
-		this.v = v;
+	if (name === true) {
+		name = hashForName(buf, hashFunction);
 	}
+	backgroundJobs.push(writeFile(name, buf));
+	let size = 0;
+	for (const b of buf) size += b.length;
+	return {
+		size,
+		name,
+		backgroundJob:
+			backgroundJobs.length === 1
+				? backgroundJobs[0]
+				: Promise.all(backgroundJobs)
+	};
+};
 
-	_deleteValue() {
-		this.f &= 6;
-		this.v = undefined;
+/**
+ * @param {FileMiddleware} middleware this
+ * @param {string | false} name filename
+ * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
+ * @returns {Promise<BufferSerializableType[]>} deserialized data
+ */
+const deserialize = async (middleware, name, readFile) => {
+	const contents = await readFile(name);
+	if (contents.length === 0) throw new Error("Empty file " + name);
+	let contentsIndex = 0;
+	let contentItem = contents[0];
+	let contentItemLength = contentItem.length;
+	let contentPosition = 0;
+	if (contentItemLength === 0) throw new Error("Empty file " + name);
+	const nextContent = () => {
+		contentsIndex++;
+		contentItem = contents[contentsIndex];
+		contentItemLength = contentItem.length;
+		contentPosition = 0;
+	};
+	const ensureData = n => {
+		if (contentPosition === contentItemLength) {
+			nextContent();
+		}
+		while (contentItemLength - contentPosition < n) {
+			const remaining = contentItem.slice(contentPosition);
+			let lengthFromNext = n - remaining.length;
+			const buffers = [remaining];
+			for (let i = contentsIndex + 1; i < contents.length; i++) {
+				const l = contents[i].length;
+				if (l > lengthFromNext) {
+					buffers.push(contents[i].slice(0, lengthFromNext));
+					contents[i] = contents[i].slice(lengthFromNext);
+					lengthFromNext = 0;
+					break;
+				} else {
+					buffers.push(contents[i]);
+					contentsIndex = i;
+					lengthFromNext -= l;
+				}
+			}
+			if (lengthFromNext > 0) throw new Error("Unexpected end of data");
+			contentItem = Buffer.concat(buffers, n);
+			contentItemLength = n;
+			contentPosition = 0;
+		}
+	};
+	const readUInt32LE = () => {
+		ensureData(4);
+		const value = contentItem.readUInt32LE(contentPosition);
+		contentPosition += 4;
+		return value;
+	};
+	const readInt32LE = () => {
+		ensureData(4);
+		const value = contentItem.readInt32LE(contentPosition);
+		contentPosition += 4;
+		return value;
+	};
+	const readSlice = l => {
+		ensureData(l);
+		if (contentPosition === 0 && contentItemLength === l) {
+			const result = contentItem;
+			if (contentsIndex + 1 < contents.length) {
+				nextContent();
+			} else {
+				contentPosition = l;
+			}
+			return result;
+		}
+		const result = contentItem.slice(contentPosition, contentPosition + l);
+		contentPosition += l;
+		// we clone the buffer here to allow the original content to be garbage collected
+		return l * 2 < contentItem.buffer.byteLength ? Buffer.from(result) : result;
+	};
+	const version = readUInt32LE();
+	if (version !== VERSION) {
+		throw new Error("Invalid file version");
 	}
-
-	_peek(thing) {
-		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) return undefined;
-			return this.w.get(thing);
+	const sectionCount = readUInt32LE();
+	const lengths = [];
+	let lastLengthPositive = false;
+	for (let i = 0; i < sectionCount; i++) {
+		const value = readInt32LE();
+		const valuePositive = value >= 0;
+		if (lastLengthPositive && valuePositive) {
+			lengths[lengths.length - 1] += value;
 		} else {
-			if ((this.f & 2) !== 2) return undefined;
-			return this.m.get(thing);
+			lengths.push(value);
+			lastLengthPositive = valuePositive;
 		}
 	}
-
-	_get(thing) {
-		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) {
-				const newMap = new WeakMap();
-				this.f |= 4;
-				const newNode = new WeakTupleMap();
-				(this.w = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry = this.w.get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
-			const newNode = new WeakTupleMap();
-			this.w.set(thing, newNode);
-			return newNode;
+	const result = [];
+	for (let length of lengths) {
+		if (length < 0) {
+			const slice = readSlice(-length);
+			const size = Number(readUInt64LE(slice, 0));
+			const nameBuffer = slice.slice(8);
+			const name = nameBuffer.toString();
+			result.push(
+				SerializerMiddleware.createLazy(
+					memoize(() => deserialize(middleware, name, readFile)),
+					middleware,
+					{
+						name,
+						size
+					},
+					slice
+				)
+			);
 		} else {
-			if ((this.f & 2) !== 2) {
-				const newMap = new Map();
-				this.f |= 2;
-				const newNode = new WeakTupleMap();
-				(this.m = newMap).set(thing, newNode);
-				return newNode;
+			if (contentPosition === contentItemLength) {
+				nextContent();
+			} else if (contentPosition !== 0) {
+				if (length <= contentItemLength - contentPosition) {
+					result.push(
+						Buffer.from(
+							contentItem.buffer,
+							contentItem.byteOffset + contentPosition,
+							length
+						)
+					);
+					contentPosition += length;
+					length = 0;
+				} else {
+					const l = contentItemLength - contentPosition;
+					result.push(
+						Buffer.from(
+							contentItem.buffer,
+							contentItem.byteOffset + contentPosition,
+							l
+						)
+					);
+					length -= l;
+					contentPosition = contentItemLength;
+				}
+			} else {
+				if (length >= contentItemLength) {
+					result.push(contentItem);
+					length -= contentItemLength;
+					contentPosition = contentItemLength;
+				} else {
+					result.push(
+						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+					);
+					contentPosition += length;
+					length = 0;
+				}
 			}
-			const entry = this.m.get(thing);
-			if (entry !== undefined) {
-				return entry;
+			while (length > 0) {
+				nextContent();
+				if (length >= contentItemLength) {
+					result.push(contentItem);
+					length -= contentItemLength;
+					contentPosition = contentItemLength;
+				} else {
+					result.push(
+						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+					);
+					contentPosition += length;
+					length = 0;
+				}
 			}
-			const newNode = new WeakTupleMap();
-			this.m.set(thing, newNode);
-			return newNode;
 		}
 	}
-}
-
-module.exports = WeakTupleMap;
-
-
-/***/ }),
-
-/***/ 92229:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Mikola Lysenko @mikolalysenko
-*/
-
-
-
-/* cspell:disable-next-line */
-// Refactor: Peter Somogyvari @petermetz
-
-const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
-	const code = [
-		"function ",
-		funcName,
-		"(a,l,h,",
-		extraArgs.join(","),
-		"){",
-		earlyOut ? "" : "var i=",
-		reversed ? "l-1" : "h+1",
-		";while(l<=h){var m=(l+h)>>>1,x=a[m]"
-	];
-
-	if (earlyOut) {
-		if (predicate.indexOf("c") < 0) {
-			code.push(";if(x===y){return m}else if(x<=y){");
-		} else {
-			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
-		}
-	} else {
-		code.push(";if(", predicate, "){i=m;");
-	}
-	if (reversed) {
-		code.push("l=m+1}else{h=m-1}");
-	} else {
-		code.push("h=m-1}else{l=m+1}");
-	}
-	code.push("}");
-	if (earlyOut) {
-		code.push("return -1};");
-	} else {
-		code.push("return i};");
-	}
-	return code.join("");
-};
-
-const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
-	const arg1 = compileSearch(
-		"A",
-		"x" + predicate + "y",
-		reversed,
-		["y"],
-		earlyOut
-	);
-
-	const arg2 = compileSearch(
-		"P",
-		"c(x,y)" + predicate + "0",
-		reversed,
-		["y", "c"],
-		earlyOut
-	);
-
-	const fnHeader = "function dispatchBinarySearch";
-
-	const fnBody =
-		"(a,y,c,l,h){\
-if(typeof(c)==='function'){\
-return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
-}else{\
-return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
-}}\
-return dispatchBinarySearch";
-
-	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
-	const fnSource = fnArgList.join("");
-	const result = new Function(fnSource);
-	return result();
-};
-
-module.exports = {
-	ge: compileBoundsSearch(">=", false, "GE"),
-	gt: compileBoundsSearch(">", false, "GT"),
-	lt: compileBoundsSearch("<", true, "LT"),
-	le: compileBoundsSearch("<=", true, "LE"),
-	eq: compileBoundsSearch("-", true, "EQ", true)
+	return result;
 };
 
-
-/***/ }),
-
-/***/ 60839:
-/***/ (function(__unused_webpack_module, exports) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @type {WeakMap<object, WeakMap<object, object>>} */
-const mergeCache = new WeakMap();
-/** @type {WeakMap<object, Map<string, Map<string|number|boolean, object>>>} */
-const setPropertyCache = new WeakMap();
-const DELETE = Symbol("DELETE");
-const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
-
 /**
- * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
- * @template T
- * @template O
- * @example
- * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
- * cachedCleverMerge({a: 1}, {a: 2})
- * {a: 2}
- *  // when same arguments passed, gets the result from WeakMap and returns it.
- * cachedCleverMerge({a: 1}, {a: 2})
- * {a: 2}
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
+ * @typedef {BufferSerializableType[]} DeserializedType
+ * @typedef {true} SerializedType
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
-const cachedCleverMerge = (first, second) => {
-	if (second === undefined) return first;
-	if (first === undefined) return second;
-	if (typeof second !== "object" || second === null) return second;
-	if (typeof first !== "object" || first === null) return first;
-
-	let innerCache = mergeCache.get(first);
-	if (innerCache === undefined) {
-		innerCache = new WeakMap();
-		mergeCache.set(first, innerCache);
+class FileMiddleware extends SerializerMiddleware {
+	/**
+	 * @param {IntermediateFileSystem} fs filesystem
+	 * @param {string | Hash} hashFunction hash function to use
+	 */
+	constructor(fs, hashFunction = "md4") {
+		super();
+		this.fs = fs;
+		this._hashFunction = hashFunction;
 	}
-	const prevMerge = innerCache.get(second);
-	if (prevMerge !== undefined) return prevMerge;
-	const newMerge = _cleverMerge(first, second, true);
-	innerCache.set(second, newMerge);
-	return newMerge;
-};
+	/**
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 */
+	serialize(data, context) {
+		const { filename, extension = "" } = context;
+		return new Promise((resolve, reject) => {
+			mkdirp(this.fs, dirname(this.fs, filename), err => {
+				if (err) return reject(err);
 
-/**
- * @template T
- * @param {Partial<T>} obj object
- * @param {string} property property
- * @param {string|number|boolean} value assignment value
- * @returns {T} new object
- */
-const cachedSetProperty = (obj, property, value) => {
-	let mapByProperty = setPropertyCache.get(obj);
+				// It's important that we don't touch existing files during serialization
+				// because serialize may read existing files (when deserializing)
+				const allWrittenFiles = new Set();
+				const writeFile = async (name, content) => {
+					const file = name
+						? join(this.fs, filename, `../${name}${extension}`)
+						: filename;
+					await new Promise((resolve, reject) => {
+						let stream = this.fs.createWriteStream(file + "_");
+						let compression;
+						if (file.endsWith(".gz")) {
+							compression = createGzip({
+								chunkSize: COMPRESSION_CHUNK_SIZE,
+								level: zConstants.Z_BEST_SPEED
+							});
+						} else if (file.endsWith(".br")) {
+							compression = createBrotliCompress({
+								chunkSize: COMPRESSION_CHUNK_SIZE,
+								params: {
+									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
+									[zConstants.BROTLI_PARAM_QUALITY]: 2,
+									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
+									[zConstants.BROTLI_PARAM_SIZE_HINT]: content.reduce(
+										(size, b) => size + b.length,
+										0
+									)
+								}
+							});
+						}
+						if (compression) {
+							pipeline(compression, stream, reject);
+							stream = compression;
+							stream.on("finish", () => resolve());
+						} else {
+							stream.on("error", err => reject(err));
+							stream.on("finish", () => resolve());
+						}
+						for (const b of content) stream.write(b);
+						stream.end();
+					});
+					if (name) allWrittenFiles.add(file);
+				};
 
-	if (mapByProperty === undefined) {
-		mapByProperty = new Map();
-		setPropertyCache.set(obj, mapByProperty);
-	}
+				resolve(
+					serialize(this, data, false, writeFile, this._hashFunction).then(
+						async ({ backgroundJob }) => {
+							await backgroundJob;
 
-	let mapByValue = mapByProperty.get(property);
+							// Rename the index file to disallow access during inconsistent file state
+							await new Promise(resolve =>
+								this.fs.rename(filename, filename + ".old", err => {
+									resolve();
+								})
+							);
 
-	if (mapByValue === undefined) {
-		mapByValue = new Map();
-		mapByProperty.set(property, mapByValue);
+							// update all written files
+							await Promise.all(
+								Array.from(
+									allWrittenFiles,
+									file =>
+										new Promise((resolve, reject) => {
+											this.fs.rename(file + "_", file, err => {
+												if (err) return reject(err);
+												resolve();
+											});
+										})
+								)
+							);
+
+							// As final step automatically update the index file to have a consistent pack again
+							await new Promise(resolve => {
+								this.fs.rename(filename + "_", filename, err => {
+									if (err) return reject(err);
+									resolve();
+								});
+							});
+							return /** @type {true} */ (true);
+						}
+					)
+				);
+			});
+		});
+	}
+
+	/**
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 */
+	deserialize(data, context) {
+		const { filename, extension = "" } = context;
+		const readFile = name =>
+			new Promise((resolve, reject) => {
+				const file = name
+					? join(this.fs, filename, `../${name}${extension}`)
+					: filename;
+				this.fs.stat(file, (err, stats) => {
+					if (err) {
+						reject(err);
+						return;
+					}
+					let remaining = /** @type {number} */ (stats.size);
+					let currentBuffer;
+					let currentBufferUsed;
+					const buf = [];
+					let decompression;
+					if (file.endsWith(".gz")) {
+						decompression = createGunzip({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
+					} else if (file.endsWith(".br")) {
+						decompression = createBrotliDecompress({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
+					}
+					if (decompression) {
+						let newResolve, newReject;
+						resolve(
+							Promise.all([
+								new Promise((rs, rj) => {
+									newResolve = rs;
+									newReject = rj;
+								}),
+								new Promise((resolve, reject) => {
+									decompression.on("data", chunk => buf.push(chunk));
+									decompression.on("end", () => resolve());
+									decompression.on("error", err => reject(err));
+								})
+							]).then(() => buf)
+						);
+						resolve = newResolve;
+						reject = newReject;
+					}
+					this.fs.open(file, "r", (err, fd) => {
+						if (err) {
+							reject(err);
+							return;
+						}
+						const read = () => {
+							if (currentBuffer === undefined) {
+								currentBuffer = Buffer.allocUnsafeSlow(
+									Math.min(
+										constants.MAX_LENGTH,
+										remaining,
+										decompression ? DECOMPRESSION_CHUNK_SIZE : Infinity
+									)
+								);
+								currentBufferUsed = 0;
+							}
+							let readBuffer = currentBuffer;
+							let readOffset = currentBufferUsed;
+							let readLength = currentBuffer.length - currentBufferUsed;
+							// values passed to fs.read must be valid int32 values
+							if (readOffset > 0x7fffffff) {
+								readBuffer = currentBuffer.slice(readOffset);
+								readOffset = 0;
+							}
+							if (readLength > 0x7fffffff) {
+								readLength = 0x7fffffff;
+							}
+							this.fs.read(
+								fd,
+								readBuffer,
+								readOffset,
+								readLength,
+								null,
+								(err, bytesRead) => {
+									if (err) {
+										this.fs.close(fd, () => {
+											reject(err);
+										});
+										return;
+									}
+									currentBufferUsed += bytesRead;
+									remaining -= bytesRead;
+									if (currentBufferUsed === currentBuffer.length) {
+										if (decompression) {
+											decompression.write(currentBuffer);
+										} else {
+											buf.push(currentBuffer);
+										}
+										currentBuffer = undefined;
+										if (remaining === 0) {
+											if (decompression) {
+												decompression.end();
+											}
+											this.fs.close(fd, err => {
+												if (err) {
+													reject(err);
+													return;
+												}
+												resolve(buf);
+											});
+											return;
+										}
+									}
+									read();
+								}
+							);
+						};
+						read();
+					});
+				});
+			});
+		return deserialize(this, false, readFile);
 	}
+}
 
-	let result = mapByValue.get(value);
-
-	if (result) return result;
+module.exports = FileMiddleware;
 
-	result = {
-		...obj,
-		[property]: value
-	};
-	mapByValue.set(value, result);
 
-	return result;
-};
+/***/ }),
 
-/**
- * @typedef {Object} ObjectParsedPropertyEntry
- * @property {any | undefined} base base value
- * @property {string | undefined} byProperty the name of the selector property
- * @property {Map<string, any>} byValues value depending on selector property, merged with base
- */
+/***/ 86791:
+/***/ (function(module) {
 
-/**
- * @typedef {Object} ParsedObject
- * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
- * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-/** @type {WeakMap<object, ParsedObject>} */
-const parseCache = new WeakMap();
 
-/**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
- */
-const cachedParseObject = obj => {
-	const entry = parseCache.get(obj);
-	if (entry !== undefined) return entry;
-	const result = parseObject(obj);
-	parseCache.set(obj, result);
-	return result;
-};
 
-/**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
- */
-const parseObject = obj => {
-	const info = new Map();
-	let dynamicInfo;
-	const getInfo = p => {
-		const entry = info.get(p);
-		if (entry !== undefined) return entry;
-		const newEntry = {
-			base: undefined,
-			byProperty: undefined,
-			byValues: undefined
-		};
-		info.set(p, newEntry);
-		return newEntry;
-	};
-	for (const key of Object.keys(obj)) {
-		if (key.startsWith("by")) {
-			const byProperty = key;
-			const byObj = obj[byProperty];
-			if (typeof byObj === "object") {
-				for (const byValue of Object.keys(byObj)) {
-					const obj = byObj[byValue];
-					for (const key of Object.keys(obj)) {
-						const entry = getInfo(key);
-						if (entry.byProperty === undefined) {
-							entry.byProperty = byProperty;
-							entry.byValues = new Map();
-						} else if (entry.byProperty !== byProperty) {
-							throw new Error(
-								`${byProperty} and ${entry.byProperty} for a single property is not supported`
-							);
-						}
-						entry.byValues.set(byValue, obj[key]);
-						if (byValue === "default") {
-							for (const otherByValue of Object.keys(byObj)) {
-								if (!entry.byValues.has(otherByValue))
-									entry.byValues.set(otherByValue, undefined);
-							}
-						}
-					}
-				}
-			} else if (typeof byObj === "function") {
-				if (dynamicInfo === undefined) {
-					dynamicInfo = {
-						byProperty: key,
-						fn: byObj
-					};
-				} else {
-					throw new Error(
-						`${key} and ${dynamicInfo.byProperty} when both are functions is not supported`
-					);
-				}
-			} else {
-				const entry = getInfo(key);
-				entry.base = obj[key];
-			}
-		} else {
-			const entry = getInfo(key);
-			entry.base = obj[key];
+class MapObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.size);
+		for (const key of obj.keys()) {
+			write(key);
 		}
-	}
-	return {
-		static: info,
-		dynamic: dynamicInfo
-	};
-};
-
-/**
- * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
- * @returns {object} the object
- */
-const serializeObject = (info, dynamicInfo) => {
-	const obj = {};
-	// Setup byProperty structure
-	for (const entry of info.values()) {
-		if (entry.byProperty !== undefined) {
-			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
-			for (const byValue of entry.byValues.keys()) {
-				byObj[byValue] = byObj[byValue] || {};
-			}
+		for (const value of obj.values()) {
+			write(value);
 		}
 	}
-	for (const [key, entry] of info) {
-		if (entry.base !== undefined) {
-			obj[key] = entry.base;
+	deserialize({ read }) {
+		let size = read();
+		const map = new Map();
+		const keys = [];
+		for (let i = 0; i < size; i++) {
+			keys.push(read());
 		}
-		// Fill byProperty structure
-		if (entry.byProperty !== undefined) {
-			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
-			for (const byValue of Object.keys(byObj)) {
-				const value = getFromByValues(entry.byValues, byValue);
-				if (value !== undefined) byObj[byValue][key] = value;
-			}
+		for (let i = 0; i < size; i++) {
+			map.set(keys[i], read());
 		}
+		return map;
 	}
-	if (dynamicInfo !== undefined) {
-		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
-	}
-	return obj;
-};
-
-const VALUE_TYPE_UNDEFINED = 0;
-const VALUE_TYPE_ATOM = 1;
-const VALUE_TYPE_ARRAY_EXTEND = 2;
-const VALUE_TYPE_OBJECT = 3;
-const VALUE_TYPE_DELETE = 4;
-
-/**
- * @param {any} value a single value
- * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
- */
-const getValueType = value => {
-	if (value === undefined) {
-		return VALUE_TYPE_UNDEFINED;
-	} else if (value === DELETE) {
-		return VALUE_TYPE_DELETE;
-	} else if (Array.isArray(value)) {
-		if (value.lastIndexOf("...") !== -1) return VALUE_TYPE_ARRAY_EXTEND;
-		return VALUE_TYPE_ATOM;
-	} else if (
-		typeof value === "object" &&
-		value !== null &&
-		(!value.constructor || value.constructor === Object)
-	) {
-		return VALUE_TYPE_OBJECT;
-	}
-	return VALUE_TYPE_ATOM;
-};
+}
 
-/**
- * Merges two objects. Objects are deeply clever merged.
- * Arrays might reference the old value with "...".
- * Non-object values take preference over object values.
- * @template T
- * @template O
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
- */
-const cleverMerge = (first, second) => {
-	if (second === undefined) return first;
-	if (first === undefined) return second;
-	if (typeof second !== "object" || second === null) return second;
-	if (typeof first !== "object" || first === null) return first;
+module.exports = MapObjectSerializer;
 
-	return _cleverMerge(first, second, false);
-};
 
-/**
- * Merges two objects. Objects are deeply clever merged.
- * @param {object} first first object
- * @param {object} second second object
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {object} merged object of first and second object
- */
-const _cleverMerge = (first, second, internalCaching = false) => {
-	const firstObject = internalCaching
-		? cachedParseObject(first)
-		: parseObject(first);
-	const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
+/***/ }),
 
-	// If the first argument has a dynamic part we modify the dynamic part to merge the second argument
-	if (firstDynamicInfo !== undefined) {
-		let { byProperty, fn } = firstDynamicInfo;
-		const fnInfo = fn[DYNAMIC_INFO];
-		if (fnInfo) {
-			second = internalCaching
-				? cachedCleverMerge(fnInfo[1], second)
-				: cleverMerge(fnInfo[1], second);
-			fn = fnInfo[0];
-		}
-		const newFn = (...args) => {
-			const fnResult = fn(...args);
-			return internalCaching
-				? cachedCleverMerge(fnResult, second)
-				: cleverMerge(fnResult, second);
-		};
-		newFn[DYNAMIC_INFO] = [fn, second];
-		return serializeObject(firstObject.static, { byProperty, fn: newFn });
-	}
+/***/ 21048:
+/***/ (function(module) {
 
-	// If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
-	const secondObject = internalCaching
-		? cachedParseObject(second)
-		: parseObject(second);
-	const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
-	/** @type {Map<string, ObjectParsedPropertyEntry>} */
-	const resultInfo = new Map();
-	for (const [key, firstEntry] of firstInfo) {
-		const secondEntry = secondInfo.get(key);
-		const entry =
-			secondEntry !== undefined
-				? mergeEntries(firstEntry, secondEntry, internalCaching)
-				: firstEntry;
-		resultInfo.set(key, entry);
-	}
-	for (const [key, secondEntry] of secondInfo) {
-		if (!firstInfo.has(key)) {
-			resultInfo.set(key, secondEntry);
-		}
-	}
-	return serializeObject(resultInfo, secondDynamicInfo);
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-/**
- * @param {ObjectParsedPropertyEntry} firstEntry a
- * @param {ObjectParsedPropertyEntry} secondEntry b
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry} new entry
- */
-const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
-	switch (getValueType(secondEntry.base)) {
-		case VALUE_TYPE_ATOM:
-		case VALUE_TYPE_DELETE:
-			// No need to consider firstEntry at all
-			// second value override everything
-			// = second.base + second.byProperty
-			return secondEntry;
-		case VALUE_TYPE_UNDEFINED:
-			if (!firstEntry.byProperty) {
-				// = first.base + second.byProperty
-				return {
-					base: firstEntry.base,
-					byProperty: secondEntry.byProperty,
-					byValues: secondEntry.byValues
-				};
-			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
-				throw new Error(
-					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
-				);
-			} else {
-				// = first.base + (first.byProperty + second.byProperty)
-				// need to merge first and second byValues
-				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of secondEntry.byValues) {
-					const firstValue = getFromByValues(firstEntry.byValues, key);
-					newByValues.set(
-						key,
-						mergeSingleValue(firstValue, value, internalCaching)
-					);
-				}
-				return {
-					base: firstEntry.base,
-					byProperty: firstEntry.byProperty,
-					byValues: newByValues
-				};
-			}
-		default: {
-			if (!firstEntry.byProperty) {
-				// The simple case
-				// = (first.base + second.base) + second.byProperty
-				return {
-					base: mergeSingleValue(
-						firstEntry.base,
-						secondEntry.base,
-						internalCaching
-					),
-					byProperty: secondEntry.byProperty,
-					byValues: secondEntry.byValues
-				};
-			}
-			let newBase;
-			const intermediateByValues = new Map(firstEntry.byValues);
-			for (const [key, value] of intermediateByValues) {
-				intermediateByValues.set(
-					key,
-					mergeSingleValue(value, secondEntry.base, internalCaching)
-				);
-			}
-			if (
-				Array.from(firstEntry.byValues.values()).every(value => {
-					const type = getValueType(value);
-					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-				})
-			) {
-				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
-				newBase = mergeSingleValue(
-					firstEntry.base,
-					secondEntry.base,
-					internalCaching
-				);
-			} else {
-				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
-				newBase = firstEntry.base;
-				if (!intermediateByValues.has("default"))
-					intermediateByValues.set("default", secondEntry.base);
-			}
-			if (!secondEntry.byProperty) {
-				// = first.base + (first.byProperty + second.base)
-				return {
-					base: newBase,
-					byProperty: firstEntry.byProperty,
-					byValues: intermediateByValues
-				};
-			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
-				throw new Error(
-					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
-				);
-			}
-			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of secondEntry.byValues) {
-				const firstValue = getFromByValues(intermediateByValues, key);
-				newByValues.set(
-					key,
-					mergeSingleValue(firstValue, value, internalCaching)
-				);
-			}
-			return {
-				base: newBase,
-				byProperty: firstEntry.byProperty,
-				byValues: newByValues
-			};
-		}
-	}
-};
 
-/**
- * @param {Map<string, any>} byValues all values
- * @param {string} key value of the selector
- * @returns {any | undefined} value
- */
-const getFromByValues = (byValues, key) => {
-	if (key !== "default" && byValues.has(key)) {
-		return byValues.get(key);
-	}
-	return byValues.get("default");
-};
 
-/**
- * @param {any} a value
- * @param {any} b value
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {any} value
- */
-const mergeSingleValue = (a, b, internalCaching) => {
-	const bType = getValueType(b);
-	const aType = getValueType(a);
-	switch (bType) {
-		case VALUE_TYPE_DELETE:
-		case VALUE_TYPE_ATOM:
-			return b;
-		case VALUE_TYPE_OBJECT: {
-			return aType !== VALUE_TYPE_OBJECT
-				? b
-				: internalCaching
-				? cachedCleverMerge(a, b)
-				: cleverMerge(a, b);
+class NullPrototypeObjectSerializer {
+	serialize(obj, { write }) {
+		const keys = Object.keys(obj);
+		for (const key of keys) {
+			write(key);
 		}
-		case VALUE_TYPE_UNDEFINED:
-			return a;
-		case VALUE_TYPE_ARRAY_EXTEND:
-			switch (
-				aType !== VALUE_TYPE_ATOM
-					? aType
-					: Array.isArray(a)
-					? VALUE_TYPE_ARRAY_EXTEND
-					: VALUE_TYPE_OBJECT
-			) {
-				case VALUE_TYPE_UNDEFINED:
-					return b;
-				case VALUE_TYPE_DELETE:
-					return b.filter(item => item !== "...");
-				case VALUE_TYPE_ARRAY_EXTEND: {
-					const newArray = [];
-					for (const item of b) {
-						if (item === "...") {
-							for (const item of a) {
-								newArray.push(item);
-							}
-						} else {
-							newArray.push(item);
-						}
-					}
-					return newArray;
-				}
-				case VALUE_TYPE_OBJECT:
-					return b.map(item => (item === "..." ? a : item));
-				default:
-					throw new Error("Not implemented");
-			}
-		default:
-			throw new Error("Not implemented");
-	}
-};
-
-/**
- * @template T
- * @param {T} obj the object
- * @returns {T} the object without operations like "..." or DELETE
- */
-const removeOperations = obj => {
-	const newObj = /** @type {T} */ ({});
-	for (const key of Object.keys(obj)) {
-		const value = obj[key];
-		const type = getValueType(value);
-		switch (type) {
-			case VALUE_TYPE_UNDEFINED:
-			case VALUE_TYPE_DELETE:
-				break;
-			case VALUE_TYPE_OBJECT:
-				newObj[key] = removeOperations(value);
-				break;
-			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[key] = value.filter(i => i !== "...");
-				break;
-			default:
-				newObj[key] = value;
-				break;
+		write(null);
+		for (const key of keys) {
+			write(obj[key]);
 		}
 	}
-	return newObj;
-};
-
-/**
- * @template T
- * @template {string} P
- * @param {T} obj the object
- * @param {P} byProperty the by description
- * @param  {...any} values values
- * @returns {Omit<T, P>} object with merged byProperty
- */
-const resolveByProperty = (obj, byProperty, ...values) => {
-	if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
-		return obj;
-	}
-	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
-	const remaining = /** @type {T} */ (_remaining);
-	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
-		_byValue
-	);
-	if (typeof byValue === "object") {
-		const key = values[0];
-		if (key in byValue) {
-			return cachedCleverMerge(remaining, byValue[key]);
-		} else if ("default" in byValue) {
-			return cachedCleverMerge(remaining, byValue.default);
-		} else {
-			return /** @type {T} */ (remaining);
+	deserialize({ read }) {
+		const obj = Object.create(null);
+		const keys = [];
+		let key = read();
+		while (key !== null) {
+			keys.push(key);
+			key = read();
 		}
-	} else if (typeof byValue === "function") {
-		const result = byValue.apply(null, values);
-		return cachedCleverMerge(
-			remaining,
-			resolveByProperty(result, byProperty, ...values)
-		);
+		for (const key of keys) {
+			obj[key] = read();
+		}
+		return obj;
 	}
-};
+}
 
-exports.cachedSetProperty = cachedSetProperty;
-exports.cachedCleverMerge = cachedCleverMerge;
-exports.cleverMerge = cleverMerge;
-exports.resolveByProperty = resolveByProperty;
-exports.removeOperations = removeOperations;
-exports.DELETE = DELETE;
+module.exports = NullPrototypeObjectSerializer;
 
 
 /***/ }),
 
-/***/ 29579:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 34795:
+/***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { compareRuntime } = __webpack_require__(17156);
+const createHash = __webpack_require__(49835);
+const ArraySerializer = __webpack_require__(41721);
+const DateObjectSerializer = __webpack_require__(93475);
+const ErrorObjectSerializer = __webpack_require__(79479);
+const MapObjectSerializer = __webpack_require__(86791);
+const NullPrototypeObjectSerializer = __webpack_require__(21048);
+const PlainObjectSerializer = __webpack_require__(33040);
+const RegExpObjectSerializer = __webpack_require__(57328);
+const SerializerMiddleware = __webpack_require__(83137);
+const SetObjectSerializer = __webpack_require__(79240);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/** @template T @typedef {function(T, T): -1|0|1} Comparator */
-/** @template TArg @template T @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator */
-/** @template TArg @template T @typedef {function(TArg): Comparator<T>} ParameterizedComparator */
+/** @typedef {new (...params: any[]) => any} Constructor */
+
+/*
+
+Format:
+
+File -> Section*
+Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
+
+ObjectSection -> ESCAPE (
+	number:relativeOffset (number > 0) |
+	string:request (string|null):export
+) Section:value* ESCAPE ESCAPE_END_OBJECT
+ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
+EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
+EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
+OtherSection -> any (except ESCAPE)
+
+Why using null as escape value?
+Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
+Technically any value can be used.
+
+*/
 
 /**
- * @template T
- * @param {RawParameterizedComparator<any, T>} fn comparator with argument
- * @returns {ParameterizedComparator<any, T>} comparator
+ * @typedef {Object} ObjectSerializerContext
+ * @property {function(any): void} write
  */
-const createCachedParameterizedComparator = fn => {
-	/** @type {WeakMap<object, Comparator<T>>} */
-	const map = new WeakMap();
-	return arg => {
-		const cachedResult = map.get(arg);
-		if (cachedResult !== undefined) return cachedResult;
-		/**
-		 * @param {T} a first item
-		 * @param {T} b second item
-		 * @returns {-1|0|1} compare result
-		 */
-		const result = fn.bind(null, arg);
-		map.set(arg, result);
-		return result;
-	};
-};
 
 /**
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {-1|0|1} compare result
+ * @typedef {Object} ObjectDeserializerContext
+ * @property {function(): any} read
  */
-exports.compareChunksById = (a, b) => {
-	return compareIds(a.id, b.id);
-};
 
 /**
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
+ * @typedef {Object} ObjectSerializer
+ * @property {function(any, ObjectSerializerContext): void} serialize
+ * @property {function(ObjectDeserializerContext): any} deserialize
  */
-exports.compareModulesByIdentifier = (a, b) => {
-	return compareIds(a.identifier(), b.identifier());
+
+const setSetSize = (set, size) => {
+	let i = 0;
+	for (const item of set) {
+		if (i++ >= size) {
+			set.delete(item);
+		}
+	}
 };
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesById = (chunkGraph, a, b) => {
-	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+const setMapSize = (map, size) => {
+	let i = 0;
+	for (const item of map.keys()) {
+		if (i++ >= size) {
+			map.delete(item);
+		}
+	}
 };
-/** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesById =
-	createCachedParameterizedComparator(compareModulesById);
 
 /**
- * @param {number} a number
- * @param {number} b number
- * @returns {-1|0|1} compare result
+ * @param {Buffer} buffer buffer
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
  */
-const compareNumbers = (a, b) => {
-	if (typeof a !== typeof b) {
-		return typeof a < typeof b ? -1 : 1;
-	}
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
+const toHash = (buffer, hashFunction) => {
+	const hash = createHash(hashFunction);
+	hash.update(buffer);
+	return /** @type {string} */ (hash.digest("latin1"));
 };
-exports.compareNumbers = compareNumbers;
+
+const ESCAPE = null;
+const ESCAPE_ESCAPE_VALUE = null;
+const ESCAPE_END_OBJECT = true;
+const ESCAPE_UNDEFINED = false;
+
+const CURRENT_VERSION = 2;
+
+const serializers = new Map();
+const serializerInversed = new Map();
+
+const loadedRequests = new Set();
+
+const NOT_SERIALIZABLE = {};
+
+const jsTypes = new Map();
+jsTypes.set(Object, new PlainObjectSerializer());
+jsTypes.set(Array, new ArraySerializer());
+jsTypes.set(null, new NullPrototypeObjectSerializer());
+jsTypes.set(Map, new MapObjectSerializer());
+jsTypes.set(Set, new SetObjectSerializer());
+jsTypes.set(Date, new DateObjectSerializer());
+jsTypes.set(RegExp, new RegExpObjectSerializer());
+jsTypes.set(Error, new ErrorObjectSerializer(Error));
+jsTypes.set(EvalError, new ErrorObjectSerializer(EvalError));
+jsTypes.set(RangeError, new ErrorObjectSerializer(RangeError));
+jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
+jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
+jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
+
+// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
+// real Object and Array types to. These types may occur in the wild too, e. g. when
+// using Structured Clone in postMessage.
+if (exports.constructor !== Object) {
+	const Obj = /** @type {typeof Object} */ (exports.constructor);
+	const Fn = /** @type {typeof Function} */ (Obj.constructor);
+	for (const [type, config] of Array.from(jsTypes)) {
+		if (type) {
+			const Type = new Fn(`return ${type.name};`)();
+			jsTypes.set(Type, config);
+		}
+	}
+}
+
+{
+	let i = 1;
+	for (const [type, serializer] of jsTypes) {
+		serializers.set(type, {
+			request: "",
+			name: i++,
+			serializer
+		});
+	}
+}
+
+for (const { request, name, serializer } of serializers.values()) {
+	serializerInversed.set(`${request}/${name}`, serializer);
+}
+
+/** @type {Map<RegExp, (request: string) => boolean>} */
+const loaders = new Map();
 
 /**
- * @param {string} a string
- * @param {string} b string
- * @returns {-1|0|1} compare result
+ * @typedef {ComplexSerializableType[]} DeserializedType
+ * @typedef {PrimitiveSerializableType[]} SerializedType
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
-const compareStringsNumeric = (a, b) => {
-	const partsA = a.split(/(\d+)/);
-	const partsB = b.split(/(\d+)/);
-	const len = Math.min(partsA.length, partsB.length);
-	for (let i = 0; i < len; i++) {
-		const pA = partsA[i];
-		const pB = partsB[i];
-		if (i % 2 === 0) {
-			if (pA.length > pB.length) {
-				if (pA.slice(0, pB.length) > pB) return 1;
-				return -1;
-			} else if (pB.length > pA.length) {
-				if (pB.slice(0, pA.length) > pA) return -1;
-				return 1;
-			} else {
-				if (pA < pB) return -1;
-				if (pA > pB) return 1;
-			}
+class ObjectMiddleware extends SerializerMiddleware {
+	/**
+	 * @param {function(any): void} extendContext context extensions
+	 * @param {string | Hash} hashFunction hash function to use
+	 */
+	constructor(extendContext, hashFunction = "md4") {
+		super();
+		this.extendContext = extendContext;
+		this._hashFunction = hashFunction;
+	}
+	/**
+	 * @param {RegExp} regExp RegExp for which the request is tested
+	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
+	 * @returns {void}
+	 */
+	static registerLoader(regExp, loader) {
+		loaders.set(regExp, loader);
+	}
+
+	/**
+	 * @param {Constructor} Constructor the constructor
+	 * @param {string} request the request which will be required when deserializing
+	 * @param {string} name the name to make multiple serializer unique when sharing a request
+	 * @param {ObjectSerializer} serializer the serializer
+	 * @returns {void}
+	 */
+	static register(Constructor, request, name, serializer) {
+		const key = request + "/" + name;
+
+		if (serializers.has(Constructor)) {
+			throw new Error(
+				`ObjectMiddleware.register: serializer for ${Constructor.name} is already registered`
+			);
+		}
+
+		if (serializerInversed.has(key)) {
+			throw new Error(
+				`ObjectMiddleware.register: serializer for ${key} is already registered`
+			);
+		}
+
+		serializers.set(Constructor, {
+			request,
+			name,
+			serializer
+		});
+
+		serializerInversed.set(key, serializer);
+	}
+
+	/**
+	 * @param {Constructor} Constructor the constructor
+	 * @returns {void}
+	 */
+	static registerNotSerializable(Constructor) {
+		if (serializers.has(Constructor)) {
+			throw new Error(
+				`ObjectMiddleware.registerNotSerializable: serializer for ${Constructor.name} is already registered`
+			);
+		}
+
+		serializers.set(Constructor, NOT_SERIALIZABLE);
+	}
+
+	static getSerializerFor(object) {
+		const proto = Object.getPrototypeOf(object);
+		let c;
+		if (proto === null) {
+			// Object created with Object.create(null)
+			c = null;
 		} else {
-			const nA = +pA;
-			const nB = +pB;
-			if (nA < nB) return -1;
-			if (nA > nB) return 1;
+			c = proto.constructor;
+			if (!c) {
+				throw new Error(
+					"Serialization of objects with prototype without valid constructor property not possible"
+				);
+			}
+		}
+		const config = serializers.get(c);
+
+		if (!config) throw new Error(`No serializer registered for ${c.name}`);
+		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
+
+		return config;
+	}
+
+	static getDeserializerFor(request, name) {
+		const key = request + "/" + name;
+		const serializer = serializerInversed.get(key);
+
+		if (serializer === undefined) {
+			throw new Error(`No deserializer registered for ${key}`);
 		}
+
+		return serializer;
 	}
-	if (partsB.length < partsA.length) return 1;
-	if (partsB.length > partsA.length) return -1;
-	return 0;
-};
-exports.compareStringsNumeric = compareStringsNumeric;
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
-	const cmp = compareNumbers(
-		moduleGraph.getPostOrderIndex(a),
-		moduleGraph.getPostOrderIndex(b)
-	);
-	if (cmp !== 0) return cmp;
-	return compareIds(a.identifier(), b.identifier());
-};
-/** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPostOrderIndexOrIdentifier =
-	createCachedParameterizedComparator(
-		compareModulesByPostOrderIndexOrIdentifier
-	);
+	static _getDeserializerForWithoutError(request, name) {
+		const key = request + "/" + name;
+		const serializer = serializerInversed.get(key);
+		return serializer;
+	}
+
+	/**
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 */
+	serialize(data, context) {
+		/** @type {any[]} */
+		let result = [CURRENT_VERSION];
+		let currentPos = 0;
+		let referenceable = new Map();
+		const addReferenceable = item => {
+			referenceable.set(item, currentPos++);
+		};
+		let bufferDedupeMap = new Map();
+		const dedupeBuffer = buf => {
+			const len = buf.length;
+			const entry = bufferDedupeMap.get(len);
+			if (entry === undefined) {
+				bufferDedupeMap.set(len, buf);
+				return buf;
+			}
+			if (Buffer.isBuffer(entry)) {
+				if (len < 32) {
+					if (buf.equals(entry)) {
+						return entry;
+					}
+					bufferDedupeMap.set(len, [entry, buf]);
+					return buf;
+				} else {
+					const hash = toHash(entry, this._hashFunction);
+					const newMap = new Map();
+					newMap.set(hash, entry);
+					bufferDedupeMap.set(len, newMap);
+					const hashBuf = toHash(buf, this._hashFunction);
+					if (hash === hashBuf) {
+						return entry;
+					}
+					return buf;
+				}
+			} else if (Array.isArray(entry)) {
+				if (entry.length < 16) {
+					for (const item of entry) {
+						if (buf.equals(item)) {
+							return item;
+						}
+					}
+					entry.push(buf);
+					return buf;
+				} else {
+					const newMap = new Map();
+					const hash = toHash(buf, this._hashFunction);
+					let found;
+					for (const item of entry) {
+						const itemHash = toHash(item, this._hashFunction);
+						newMap.set(itemHash, item);
+						if (found === undefined && itemHash === hash) found = item;
+					}
+					bufferDedupeMap.set(len, newMap);
+					if (found === undefined) {
+						newMap.set(hash, buf);
+						return buf;
+					} else {
+						return found;
+					}
+				}
+			} else {
+				const hash = toHash(buf, this._hashFunction);
+				const item = entry.get(hash);
+				if (item !== undefined) {
+					return item;
+				}
+				entry.set(hash, buf);
+				return buf;
+			}
+		};
+		let currentPosTypeLookup = 0;
+		let objectTypeLookup = new Map();
+		const cycleStack = new Set();
+		const stackToString = item => {
+			const arr = Array.from(cycleStack);
+			arr.push(item);
+			return arr
+				.map(item => {
+					if (typeof item === "string") {
+						if (item.length > 100) {
+							return `String ${JSON.stringify(item.slice(0, 100)).slice(
+								0,
+								-1
+							)}..."`;
+						}
+						return `String ${JSON.stringify(item)}`;
+					}
+					try {
+						const { request, name } = ObjectMiddleware.getSerializerFor(item);
+						if (request) {
+							return `${request}${name ? `.${name}` : ""}`;
+						}
+					} catch (e) {
+						// ignore -> fallback
+					}
+					if (typeof item === "object" && item !== null) {
+						if (item.constructor) {
+							if (item.constructor === Object)
+								return `Object { ${Object.keys(item).join(", ")} }`;
+							if (item.constructor === Map) return `Map { ${item.size} items }`;
+							if (item.constructor === Array)
+								return `Array { ${item.length} items }`;
+							if (item.constructor === Set) return `Set { ${item.size} items }`;
+							if (item.constructor === RegExp) return item.toString();
+							return `${item.constructor.name}`;
+						}
+						return `Object [null prototype] { ${Object.keys(item).join(
+							", "
+						)} }`;
+					}
+					try {
+						return `${item}`;
+					} catch (e) {
+						return `(${e.message})`;
+					}
+				})
+				.join(" -> ");
+		};
+		let hasDebugInfoAttached;
+		let ctx = {
+			write(value, key) {
+				try {
+					process(value);
+				} catch (e) {
+					if (e !== NOT_SERIALIZABLE) {
+						if (hasDebugInfoAttached === undefined)
+							hasDebugInfoAttached = new WeakSet();
+						if (!hasDebugInfoAttached.has(e)) {
+							e.message += `\nwhile serializing ${stackToString(value)}`;
+							hasDebugInfoAttached.add(e);
+						}
+					}
+					throw e;
+				}
+			},
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			snapshot() {
+				return {
+					length: result.length,
+					cycleStackSize: cycleStack.size,
+					referenceableSize: referenceable.size,
+					currentPos,
+					objectTypeLookupSize: objectTypeLookup.size,
+					currentPosTypeLookup
+				};
+			},
+			rollback(snapshot) {
+				result.length = snapshot.length;
+				setSetSize(cycleStack, snapshot.cycleStackSize);
+				setMapSize(referenceable, snapshot.referenceableSize);
+				currentPos = snapshot.currentPos;
+				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
+				currentPosTypeLookup = snapshot.currentPosTypeLookup;
+			},
+			...context
+		};
+		this.extendContext(ctx);
+		const process = item => {
+			if (Buffer.isBuffer(item)) {
+				// check if we can emit a reference
+				const ref = referenceable.get(item);
+				if (ref !== undefined) {
+					result.push(ESCAPE, ref - currentPos);
+					return;
+				}
+				const alreadyUsedBuffer = dedupeBuffer(item);
+				if (alreadyUsedBuffer !== item) {
+					const ref = referenceable.get(alreadyUsedBuffer);
+					if (ref !== undefined) {
+						referenceable.set(item, ref);
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
+					item = alreadyUsedBuffer;
+				}
+				addReferenceable(item);
+
+				result.push(item);
+			} else if (item === ESCAPE) {
+				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+			} else if (
+				typeof item === "object"
+				// We don't have to check for null as ESCAPE is null and this has been checked before
+			) {
+				// check if we can emit a reference
+				const ref = referenceable.get(item);
+				if (ref !== undefined) {
+					result.push(ESCAPE, ref - currentPos);
+					return;
+				}
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
-	const cmp = compareNumbers(
-		moduleGraph.getPreOrderIndex(a),
-		moduleGraph.getPreOrderIndex(b)
-	);
-	if (cmp !== 0) return cmp;
-	return compareIds(a.identifier(), b.identifier());
-};
-/** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPreOrderIndexOrIdentifier =
-	createCachedParameterizedComparator(
-		compareModulesByPreOrderIndexOrIdentifier
-	);
+				if (cycleStack.has(item)) {
+					throw new Error(
+						`This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize.`
+					);
+				}
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
-	const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
-	if (cmp !== 0) return cmp;
-	return compareIds(a.identifier(), b.identifier());
-};
-/** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByIdOrIdentifier
-);
+				const { request, name, serializer } =
+					ObjectMiddleware.getSerializerFor(item);
+				const key = `${request}/${name}`;
+				const lastIndex = objectTypeLookup.get(key);
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {-1|0|1} compare result
- */
-const compareChunks = (chunkGraph, a, b) => {
-	return chunkGraph.compareChunks(a, b);
-};
-/** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
-exports.compareChunks = createCachedParameterizedComparator(compareChunks);
+				if (lastIndex === undefined) {
+					objectTypeLookup.set(key, currentPosTypeLookup++);
 
-/**
- * @param {string|number} a first id
- * @param {string|number} b second id
- * @returns {-1|0|1} compare result
- */
-const compareIds = (a, b) => {
-	if (typeof a !== typeof b) {
-		return typeof a < typeof b ? -1 : 1;
-	}
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
-};
+					result.push(ESCAPE, request, name);
+				} else {
+					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
+				}
 
-exports.compareIds = compareIds;
+				cycleStack.add(item);
 
-/**
- * @param {string} a first string
- * @param {string} b second string
- * @returns {-1|0|1} compare result
- */
-const compareStrings = (a, b) => {
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
-};
+				try {
+					serializer.serialize(item, ctx);
+				} finally {
+					cycleStack.delete(item);
+				}
 
-exports.compareStrings = compareStrings;
+				result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-/**
- * @param {ChunkGroup} a first chunk group
- * @param {ChunkGroup} b second chunk group
- * @returns {-1|0|1} compare result
- */
-const compareChunkGroupsByIndex = (a, b) => {
-	return a.index < b.index ? -1 : 1;
-};
+				addReferenceable(item);
+			} else if (typeof item === "string") {
+				if (item.length > 1) {
+					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+					// check if we can emit a reference
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
+					addReferenceable(item);
+				}
 
-exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
+				if (item.length > 102400 && context.logger) {
+					context.logger.warn(
+						`Serializing big strings (${Math.round(
+							item.length / 1024
+						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
+					);
+				}
 
-/**
- * @template K1 {Object}
- * @template K2
- * @template T
- */
-class TwoKeyWeakMap {
-	constructor() {
-		/** @private @type {WeakMap<any, WeakMap<any, T>>} */
-		this._map = new WeakMap();
-	}
+				result.push(item);
+			} else if (typeof item === "function") {
+				if (!SerializerMiddleware.isLazy(item))
+					throw new Error("Unexpected function " + item);
+				/** @type {SerializedType} */
+				const serializedData =
+					SerializerMiddleware.getLazySerializedValue(item);
+				if (serializedData !== undefined) {
+					if (typeof serializedData === "function") {
+						result.push(serializedData);
+					} else {
+						throw new Error("Not implemented");
+					}
+				} else if (SerializerMiddleware.isLazy(item, this)) {
+					throw new Error("Not implemented");
+				} else {
+					const data = SerializerMiddleware.serializeLazy(item, data =>
+						this.serialize([data], context)
+					);
+					SerializerMiddleware.setLazySerializedValue(item, data);
+					result.push(data);
+				}
+			} else if (item === undefined) {
+				result.push(ESCAPE, ESCAPE_UNDEFINED);
+			} else {
+				result.push(item);
+			}
+		};
 
-	/**
-	 * @param {K1} key1 first key
-	 * @param {K2} key2 second key
-	 * @returns {T | undefined} value
-	 */
-	get(key1, key2) {
-		const childMap = this._map.get(key1);
-		if (childMap === undefined) {
-			return undefined;
+		try {
+			for (const item of data) {
+				process(item);
+			}
+			return result;
+		} catch (e) {
+			if (e === NOT_SERIALIZABLE) return null;
+
+			throw e;
+		} finally {
+			// Get rid of these references to avoid leaking memory
+			// This happens because the optimized code v8 generates
+			// is optimized for our "ctx.write" method so it will reference
+			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
+			data =
+				result =
+				referenceable =
+				bufferDedupeMap =
+				objectTypeLookup =
+				ctx =
+					undefined;
 		}
-		return childMap.get(key2);
 	}
 
 	/**
-	 * @param {K1} key1 first key
-	 * @param {K2} key2 second key
-	 * @param {T | undefined} value new value
-	 * @returns {void}
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	set(key1, key2, value) {
-		let childMap = this._map.get(key1);
-		if (childMap === undefined) {
-			childMap = new WeakMap();
-			this._map.set(key1, childMap);
-		}
-		childMap.set(key2, value);
-	}
-}
+	deserialize(data, context) {
+		let currentDataPos = 0;
+		const read = () => {
+			if (currentDataPos >= data.length)
+				throw new Error("Unexpected end of stream");
 
-/** @type {TwoKeyWeakMap<Comparator<any>, Comparator<any>, Comparator<any>>}} */
-const concatComparatorsCache = new TwoKeyWeakMap();
+			return data[currentDataPos++];
+		};
 
-/**
- * @template T
- * @param {Comparator<T>} c1 comparator
- * @param {Comparator<T>} c2 comparator
- * @param {Comparator<T>[]} cRest comparators
- * @returns {Comparator<T>} comparator
- */
-const concatComparators = (c1, c2, ...cRest) => {
-	if (cRest.length > 0) {
-		const [c3, ...cRest2] = cRest;
-		return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
-	}
-	const cacheEntry = /** @type {Comparator<T>} */ (
-		concatComparatorsCache.get(c1, c2)
-	);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {T} a first value
-	 * @param {T} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const res = c1(a, b);
-		if (res !== 0) return res;
-		return c2(a, b);
-	};
-	concatComparatorsCache.set(c1, c2, result);
-	return result;
-};
-exports.concatComparators = concatComparators;
+		if (read() !== CURRENT_VERSION)
+			throw new Error("Version mismatch, serializer changed");
 
-/** @template A, B @typedef {(input: A) => B} Selector */
+		let currentPos = 0;
+		let referenceable = [];
+		const addReferenceable = item => {
+			referenceable.push(item);
+			currentPos++;
+		};
+		let currentPosTypeLookup = 0;
+		let objectTypeLookup = [];
+		let result = [];
+		let ctx = {
+			read() {
+				return decodeValue();
+			},
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			...context
+		};
+		this.extendContext(ctx);
+		const decodeValue = () => {
+			const item = read();
 
-/** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
-const compareSelectCache = new TwoKeyWeakMap();
+			if (item === ESCAPE) {
+				const nextItem = read();
 
-/**
- * @template T
- * @template R
- * @param {Selector<T, R>} getter getter for value
- * @param {Comparator<R>} comparator comparator
- * @returns {Comparator<T>} comparator
- */
-const compareSelect = (getter, comparator) => {
-	const cacheEntry = compareSelectCache.get(getter, comparator);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {T} a first value
-	 * @param {T} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const aValue = getter(a);
-		const bValue = getter(b);
-		if (aValue !== undefined && aValue !== null) {
-			if (bValue !== undefined && bValue !== null) {
-				return comparator(aValue, bValue);
-			}
-			return -1;
-		} else {
-			if (bValue !== undefined && bValue !== null) {
-				return 1;
-			}
-			return 0;
-		}
-	};
-	compareSelectCache.set(getter, comparator, result);
-	return result;
-};
-exports.compareSelect = compareSelect;
+				if (nextItem === ESCAPE_ESCAPE_VALUE) {
+					return ESCAPE;
+				} else if (nextItem === ESCAPE_UNDEFINED) {
+					return undefined;
+				} else if (nextItem === ESCAPE_END_OBJECT) {
+					throw new Error(
+						`Unexpected end of object at position ${currentDataPos - 1}`
+					);
+				} else {
+					const request = nextItem;
+					let serializer;
 
-/** @type {WeakMap<Comparator<any>, Comparator<Iterable<any>>>} */
-const compareIteratorsCache = new WeakMap();
+					if (typeof request === "number") {
+						if (request < 0) {
+							// relative reference
+							return referenceable[currentPos + request];
+						}
+						serializer = objectTypeLookup[currentPosTypeLookup - request];
+					} else {
+						if (typeof request !== "string") {
+							throw new Error(
+								`Unexpected type (${typeof request}) of request ` +
+									`at position ${currentDataPos - 1}`
+							);
+						}
+						const name = read();
 
-/**
- * @template T
- * @param {Comparator<T>} elementComparator comparator for elements
- * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
- */
-const compareIterables = elementComparator => {
-	const cacheEntry = compareIteratorsCache.get(elementComparator);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {Iterable<T>} a first value
-	 * @param {Iterable<T>} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const aI = a[Symbol.iterator]();
-		const bI = b[Symbol.iterator]();
-		// eslint-disable-next-line no-constant-condition
-		while (true) {
-			const aItem = aI.next();
-			const bItem = bI.next();
-			if (aItem.done) {
-				return bItem.done ? 0 : -1;
-			} else if (bItem.done) {
-				return 1;
-			}
-			const res = elementComparator(aItem.value, bItem.value);
-			if (res !== 0) return res;
-		}
-	};
-	compareIteratorsCache.set(elementComparator, result);
-	return result;
-};
-exports.compareIterables = compareIterables;
+						serializer = ObjectMiddleware._getDeserializerForWithoutError(
+							request,
+							name
+						);
 
-// TODO this is no longer needed when minimum node.js version is >= 12
-// since these versions ship with a stable sort function
-/**
- * @template T
- * @param {Iterable<T>} iterable original ordered list
- * @returns {Comparator<T>} comparator
- */
-exports.keepOriginalOrder = iterable => {
-	/** @type {Map<T, number>} */
-	const map = new Map();
-	let i = 0;
-	for (const item of iterable) {
-		map.set(item, i++);
-	}
-	return (a, b) => compareNumbers(map.get(a), map.get(b));
-};
+						if (serializer === undefined) {
+							if (request && !loadedRequests.has(request)) {
+								let loaded = false;
+								for (const [regExp, loader] of loaders) {
+									if (regExp.test(request)) {
+										if (loader(request)) {
+											loaded = true;
+											break;
+										}
+									}
+								}
+								if (!loaded) {
+									require(request);
+								}
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @returns {Comparator<Chunk>} comparator
- */
-exports.compareChunksNatural = chunkGraph => {
-	const cmpFn = exports.compareModulesById(chunkGraph);
-	const cmpIterableFn = compareIterables(cmpFn);
-	return concatComparators(
-		compareSelect(chunk => chunk.name, compareIds),
-		compareSelect(chunk => chunk.runtime, compareRuntime),
-		compareSelect(
-			/**
-			 * @param {Chunk} chunk a chunk
-			 * @returns {Iterable<Module>} modules
-			 */
-			chunk => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn),
-			cmpIterableFn
-		)
-	);
-};
+								loadedRequests.add(request);
+							}
+
+							serializer = ObjectMiddleware.getDeserializerFor(request, name);
+						}
+
+						objectTypeLookup.push(serializer);
+						currentPosTypeLookup++;
+					}
+					try {
+						const item = serializer.deserialize(ctx);
+						const end1 = read();
+
+						if (end1 !== ESCAPE) {
+							throw new Error("Expected end of object");
+						}
+
+						const end2 = read();
+
+						if (end2 !== ESCAPE_END_OBJECT) {
+							throw new Error("Expected end of object");
+						}
+
+						addReferenceable(item);
+
+						return item;
+					} catch (err) {
+						// As this is only for error handling, we omit creating a Map for
+						// faster access to this information, as this would affect performance
+						// in the good case
+						let serializerEntry;
+						for (const entry of serializers) {
+							if (entry[1].serializer === serializer) {
+								serializerEntry = entry;
+								break;
+							}
+						}
+						const name = !serializerEntry
+							? "unknown"
+							: !serializerEntry[1].request
+							? serializerEntry[0].name
+							: serializerEntry[1].name
+							? `${serializerEntry[1].request} ${serializerEntry[1].name}`
+							: serializerEntry[1].request;
+						err.message += `\n(during deserialization of ${name})`;
+						throw err;
+					}
+				}
+			} else if (typeof item === "string") {
+				if (item.length > 1) {
+					addReferenceable(item);
+				}
 
-/**
- * Compare two locations
- * @param {DependencyLocation} a A location node
- * @param {DependencyLocation} b A location node
- * @returns {-1|0|1} sorting comparator value
- */
-exports.compareLocations = (a, b) => {
-	let isObjectA = typeof a === "object" && a !== null;
-	let isObjectB = typeof b === "object" && b !== null;
-	if (!isObjectA || !isObjectB) {
-		if (isObjectA) return 1;
-		if (isObjectB) return -1;
-		return 0;
+				return item;
+			} else if (Buffer.isBuffer(item)) {
+				addReferenceable(item);
+
+				return item;
+			} else if (typeof item === "function") {
+				return SerializerMiddleware.deserializeLazy(
+					item,
+					data => this.deserialize(data, context)[0]
+				);
+			} else {
+				return item;
+			}
+		};
+
+		try {
+			while (currentDataPos < data.length) {
+				result.push(decodeValue());
+			}
+			return result;
+		} finally {
+			// Get rid of these references to avoid leaking memory
+			// This happens because the optimized code v8 generates
+			// is optimized for our "ctx.read" method so it will reference
+			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
+			result = referenceable = data = objectTypeLookup = ctx = undefined;
+		}
 	}
-	if ("start" in a) {
-		if ("start" in b) {
-			const ap = a.start;
-			const bp = b.start;
-			if (ap.line < bp.line) return -1;
-			if (ap.line > bp.line) return 1;
-			if (ap.column < bp.column) return -1;
-			if (ap.column > bp.column) return 1;
-		} else return -1;
-	} else if ("start" in b) return 1;
-	if ("name" in a) {
-		if ("name" in b) {
-			if (a.name < b.name) return -1;
-			if (a.name > b.name) return 1;
-		} else return -1;
-	} else if ("name" in b) return 1;
-	if ("index" in a) {
-		if ("index" in b) {
-			if (a.index < b.index) return -1;
-			if (a.index > b.index) return 1;
-		} else return -1;
-	} else if ("index" in b) return 1;
-	return 0;
-};
+}
+
+module.exports = ObjectMiddleware;
+module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
 
 
 /***/ }),
 
-/***/ 29404:
+/***/ 33040:
 /***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+const cache = new WeakMap();
 
-const toSimpleString = str => {
-	if (`${+str}` === str) {
-		return str;
+class ObjectStructure {
+	constructor() {
+		this.keys = undefined;
+		this.children = undefined;
 	}
-	return JSON.stringify(str);
-};
 
-/**
- * @param {Record<string|number, boolean>} map value map
- * @returns {true|false|function(string): string} true/false, when unconditionally true/false, or a template function to determine the value at runtime
- */
-const compileBooleanMatcher = map => {
-	const positiveItems = Object.keys(map).filter(i => map[i]);
-	const negativeItems = Object.keys(map).filter(i => !map[i]);
-	if (positiveItems.length === 0) return false;
-	if (negativeItems.length === 0) return true;
-	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
-};
+	getKeys(keys) {
+		if (this.keys === undefined) this.keys = keys;
+		return this.keys;
+	}
 
-/**
- * @param {string[]} positiveItems positive items
- * @param {string[]} negativeItems negative items
- * @returns {function(string): string} a template function to determine the value at runtime
- */
-const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
-	if (positiveItems.length === 0) return () => "false";
-	if (negativeItems.length === 0) return () => "true";
-	if (positiveItems.length === 1)
-		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
-	if (negativeItems.length === 1)
-		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
-	const positiveRegexp = itemsToRegexp(positiveItems);
-	const negativeRegexp = itemsToRegexp(negativeItems);
-	if (positiveRegexp.length <= negativeRegexp.length) {
-		return value => `/^${positiveRegexp}$/.test(${value})`;
-	} else {
-		return value => `!/^${negativeRegexp}$/.test(${value})`;
+	key(key) {
+		if (this.children === undefined) this.children = new Map();
+		const child = this.children.get(key);
+		if (child !== undefined) return child;
+		const newChild = new ObjectStructure();
+		this.children.set(key, newChild);
+		return newChild;
 	}
-};
+}
 
-const popCommonItems = (itemsSet, getKey, condition) => {
-	const map = new Map();
-	for (const item of itemsSet) {
-		const key = getKey(item);
-		if (key) {
-			let list = map.get(key);
-			if (list === undefined) {
-				list = [];
-				map.set(key, list);
-			}
-			list.push(item);
-		}
+const getCachedKeys = (keys, cacheAssoc) => {
+	let root = cache.get(cacheAssoc);
+	if (root === undefined) {
+		root = new ObjectStructure();
+		cache.set(cacheAssoc, root);
 	}
-	const result = [];
-	for (const list of map.values()) {
-		if (condition(list)) {
-			for (const item of list) {
-				itemsSet.delete(item);
-			}
-			result.push(list);
-		}
+	let current = root;
+	for (const key of keys) {
+		current = current.key(key);
 	}
-	return result;
+	return current.getKeys(keys);
 };
 
-const getCommonPrefix = items => {
-	let prefix = items[0];
-	for (let i = 1; i < items.length; i++) {
-		const item = items[i];
-		for (let p = 0; p < prefix.length; p++) {
-			if (item[p] !== prefix[p]) {
-				prefix = prefix.slice(0, p);
-				break;
+class PlainObjectSerializer {
+	serialize(obj, { write }) {
+		const keys = Object.keys(obj);
+		if (keys.length > 128) {
+			// Objects with so many keys are unlikely to share structure
+			// with other objects
+			write(keys);
+			for (const key of keys) {
+				write(obj[key]);
 			}
-		}
-	}
-	return prefix;
-};
-
-const getCommonSuffix = items => {
-	let suffix = items[0];
-	for (let i = 1; i < items.length; i++) {
-		const item = items[i];
-		for (let p = item.length - 1, s = suffix.length - 1; s >= 0; p--, s--) {
-			if (item[p] !== suffix[s]) {
-				suffix = suffix.slice(s + 1);
-				break;
+		} else if (keys.length > 1) {
+			write(getCachedKeys(keys, write));
+			for (const key of keys) {
+				write(obj[key]);
 			}
+		} else if (keys.length === 1) {
+			const key = keys[0];
+			write(key);
+			write(obj[key]);
+		} else {
+			write(null);
 		}
 	}
-	return suffix;
-};
-
-const itemsToRegexp = itemsArr => {
-	if (itemsArr.length === 1) {
-		return quoteMeta(itemsArr[0]);
-	}
-	const finishedItems = [];
-
-	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
-	let countOfSingleCharItems = 0;
-	for (const item of itemsArr) {
-		if (item.length === 1) {
-			countOfSingleCharItems++;
-		}
-	}
-	// special case for only single char items
-	if (countOfSingleCharItems === itemsArr.length) {
-		return `[${quoteMeta(itemsArr.sort().join(""))}]`;
-	}
-	const items = new Set(itemsArr.sort());
-	if (countOfSingleCharItems > 2) {
-		let singleCharItems = "";
-		for (const item of items) {
-			if (item.length === 1) {
-				singleCharItems += item;
-				items.delete(item);
+	deserialize({ read }) {
+		const keys = read();
+		const obj = {};
+		if (Array.isArray(keys)) {
+			for (const key of keys) {
+				obj[key] = read();
 			}
+		} else if (keys !== null) {
+			obj[keys] = read();
 		}
-		finishedItems.push(`[${quoteMeta(singleCharItems)}]`);
-	}
-
-	// special case for 2 items with common prefix/suffix
-	if (finishedItems.length === 0 && items.size === 2) {
-		const prefix = getCommonPrefix(itemsArr);
-		const suffix = getCommonSuffix(
-			itemsArr.map(item => item.slice(prefix.length))
-		);
-		if (prefix.length > 0 || suffix.length > 0) {
-			return `${quoteMeta(prefix)}${itemsToRegexp(
-				itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined))
-			)}${quoteMeta(suffix)}`;
-		}
-	}
-
-	// special case for 2 items with common suffix
-	if (finishedItems.length === 0 && items.size === 2) {
-		const it = items[Symbol.iterator]();
-		const a = it.next().value;
-		const b = it.next().value;
-		if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
-			return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(
-				a.slice(-1)
-			)}`;
-		}
-	}
-
-	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
-	const prefixed = popCommonItems(
-		items,
-		item => (item.length >= 1 ? item[0] : false),
-		list => {
-			if (list.length >= 3) return true;
-			if (list.length <= 1) return false;
-			return list[0][1] === list[1][1];
-		}
-	);
-	for (const prefixedItems of prefixed) {
-		const prefix = getCommonPrefix(prefixedItems);
-		finishedItems.push(
-			`${quoteMeta(prefix)}${itemsToRegexp(
-				prefixedItems.map(i => i.slice(prefix.length))
-			)}`
-		);
-	}
-
-	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
-	const suffixed = popCommonItems(
-		items,
-		item => (item.length >= 1 ? item.slice(-1) : false),
-		list => {
-			if (list.length >= 3) return true;
-			if (list.length <= 1) return false;
-			return list[0].slice(-2) === list[1].slice(-2);
-		}
-	);
-	for (const suffixedItems of suffixed) {
-		const suffix = getCommonSuffix(suffixedItems);
-		finishedItems.push(
-			`${itemsToRegexp(
-				suffixedItems.map(i => i.slice(0, -suffix.length))
-			)}${quoteMeta(suffix)}`
-		);
+		return obj;
 	}
+}
 
-	// TODO further optimize regexp, i. e.
-	// use ranges: (1|2|3|4|a) => [1-4a]
-	const conditional = finishedItems.concat(Array.from(items, quoteMeta));
-	if (conditional.length === 1) return conditional[0];
-	return `(${conditional.join("|")})`;
-};
-
-compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
-compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
-module.exports = compileBooleanMatcher;
+module.exports = PlainObjectSerializer;
 
 
 /***/ }),
 
-/***/ 32540:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 57328:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const memoize = __webpack_require__(78676);
-
-const getValidate = memoize(() => (__webpack_require__(38476).validate));
-
-const createSchemaValidation = (check, getSchema, options) => {
-	getSchema = memoize(getSchema);
-	return value => {
-		if (check && !check(value)) {
-			getValidate()(getSchema(), value, options);
-			if (check) {
-				(__webpack_require__(73837).deprecate)(
-					() => {},
-					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
-					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
-				)();
-			}
-		}
-	};
-};
+class RegExpObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.source);
+		write(obj.flags);
+	}
+	deserialize({ read }) {
+		return new RegExp(read(), read());
+	}
+}
 
-module.exports = createSchemaValidation;
+module.exports = RegExpObjectSerializer;
 
 
 /***/ }),
 
-/***/ 49835:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 53080:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const Hash = __webpack_require__(36692);
-
-const BULK_SIZE = 2000;
-
-// We are using an object instead of a Map as this will stay static during the runtime
-// so access to it can be optimized by v8
-const digestCaches = {};
-
-class BulkUpdateDecorator extends Hash {
-	/**
-	 * @param {Hash | function(): Hash} hashOrFactory function to create a hash
-	 * @param {string=} hashKey key for caching
-	 */
-	constructor(hashOrFactory, hashKey) {
-		super();
-		this.hashKey = hashKey;
-		if (typeof hashOrFactory === "function") {
-			this.hashFactory = hashOrFactory;
-			this.hash = undefined;
-		} else {
-			this.hashFactory = undefined;
-			this.hash = hashOrFactory;
-		}
-		this.buffer = "";
-	}
-
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (
-			inputEncoding !== undefined ||
-			typeof data !== "string" ||
-			data.length > BULK_SIZE
-		) {
-			if (this.hash === undefined) this.hash = this.hashFactory();
-			if (this.buffer.length > 0) {
-				this.hash.update(this.buffer);
-				this.buffer = "";
-			}
-			this.hash.update(data, inputEncoding);
-		} else {
-			this.buffer += data;
-			if (this.buffer.length > BULK_SIZE) {
-				if (this.hash === undefined) this.hash = this.hashFactory();
-				this.hash.update(this.buffer);
-				this.buffer = "";
-			}
-		}
-		return this;
-	}
-
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
-	 */
-	digest(encoding) {
-		let digestCache;
-		const buffer = this.buffer;
-		if (this.hash === undefined) {
-			// short data for hash, we can use caching
-			const cacheKey = `${this.hashKey}-${encoding}`;
-			digestCache = digestCaches[cacheKey];
-			if (digestCache === undefined) {
-				digestCache = digestCaches[cacheKey] = new Map();
-			}
-			const cacheEntry = digestCache.get(buffer);
-			if (cacheEntry !== undefined) return cacheEntry;
-			this.hash = this.hashFactory();
-		}
-		if (buffer.length > 0) {
-			this.hash.update(buffer);
-		}
-		const digestResult = this.hash.digest(encoding);
-		const result =
-			typeof digestResult === "string" ? digestResult : digestResult.toString();
-		if (digestCache !== undefined) {
-			digestCache.set(buffer, result);
-		}
-		return result;
-	}
-}
-
-/* istanbul ignore next */
-class DebugHash extends Hash {
-	constructor() {
-		super();
-		this.string = "";
-	}
-
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (typeof data !== "string") data = data.toString("utf-8");
-		if (data.startsWith("debug-digest-")) {
-			data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
-		}
-		this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
-		return this;
-	}
-
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
-	 */
-	digest(encoding) {
-		return "debug-digest-" + Buffer.from(this.string).toString("hex");
+class Serializer {
+	constructor(middlewares, context) {
+		this.serializeMiddlewares = middlewares.slice();
+		this.deserializeMiddlewares = middlewares.slice().reverse();
+		this.context = context;
 	}
-}
-
-let crypto = undefined;
-let createXXHash64 = undefined;
-let createMd4 = undefined;
-let BatchedHash = undefined;
 
-/**
- * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
- * @returns {Hash} the hash
- */
-module.exports = algorithm => {
-	if (typeof algorithm === "function") {
-		return new BulkUpdateDecorator(() => new algorithm());
-	}
-	switch (algorithm) {
-		// TODO add non-cryptographic algorithm here
-		case "debug":
-			return new DebugHash();
-		case "xxhash64":
-			if (createXXHash64 === undefined) {
-				createXXHash64 = __webpack_require__(35028);
-				if (BatchedHash === undefined) {
-					BatchedHash = __webpack_require__(59461);
-				}
-			}
-			return new BatchedHash(createXXHash64());
-		case "md4":
-			if (createMd4 === undefined) {
-				createMd4 = __webpack_require__(86884);
-				if (BatchedHash === undefined) {
-					BatchedHash = __webpack_require__(59461);
+	serialize(obj, context) {
+		const ctx = { ...context, ...this.context };
+		let current = obj;
+		for (const middleware of this.serializeMiddlewares) {
+			if (current && typeof current.then === "function") {
+				current = current.then(data => data && middleware.serialize(data, ctx));
+			} else if (current) {
+				try {
+					current = middleware.serialize(current, ctx);
+				} catch (err) {
+					current = Promise.reject(err);
 				}
+			} else break;
+		}
+		return current;
+	}
+
+	deserialize(value, context) {
+		const ctx = { ...context, ...this.context };
+		/** @type {any} */
+		let current = value;
+		for (const middleware of this.deserializeMiddlewares) {
+			if (current && typeof current.then === "function") {
+				current = current.then(data => middleware.deserialize(data, ctx));
+			} else {
+				current = middleware.deserialize(current, ctx);
 			}
-			return new BatchedHash(createMd4());
-		case "native-md4":
-			if (crypto === undefined) crypto = __webpack_require__(6113);
-			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
-		default:
-			if (crypto === undefined) crypto = __webpack_require__(6113);
-			return new BulkUpdateDecorator(
-				() => crypto.createHash(algorithm),
-				algorithm
-			);
+		}
+		return current;
 	}
-};
+}
+
+module.exports = Serializer;
 
 
 /***/ }),
 
-/***/ 64518:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 83137:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
 
-/** @type {Map<string, Function>} */
-const deprecationCache = new Map();
+const LAZY_TARGET = Symbol("lazy serialization target");
+const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
 /**
- * @typedef {Object} FakeHookMarker
- * @property {true} _fakeHook it's a fake hook
+ * @template DeserializedType
+ * @template SerializedType
  */
+class SerializerMiddleware {
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 */
+	serialize(data, context) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
-/** @template T @typedef {T & FakeHookMarker} FakeHook<T> */
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 */
+	deserialize(data, context) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
-/**
- * @param {string} message deprecation message
- * @param {string} code deprecation code
- * @returns {Function} function to trigger deprecation
- */
-const createDeprecation = (message, code) => {
-	const cached = deprecationCache.get(message);
-	if (cached !== undefined) return cached;
-	const fn = util.deprecate(
-		() => {},
-		message,
-		"DEP_WEBPACK_DEPRECATION_" + code
-	);
-	deprecationCache.set(message, fn);
-	return fn;
-};
+	/**
+	 * @param {any | function(): Promise<any> | any} value contained value or function to value
+	 * @param {SerializerMiddleware<any, any>} target target middleware
+	 * @param {object=} options lazy options
+	 * @param {any=} serializedValue serialized value
+	 * @returns {function(): Promise<any> | any} lazy function
+	 */
+	static createLazy(value, target, options = {}, serializedValue) {
+		if (SerializerMiddleware.isLazy(value, target)) return value;
+		const fn = typeof value === "function" ? value : () => value;
+		fn[LAZY_TARGET] = target;
+		/** @type {any} */ (fn).options = options;
+		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
+		return fn;
+	}
 
-const COPY_METHODS = [
-	"concat",
-	"entry",
-	"filter",
-	"find",
-	"findIndex",
-	"includes",
-	"indexOf",
-	"join",
-	"lastIndexOf",
-	"map",
-	"reduce",
-	"reduceRight",
-	"slice",
-	"some"
-];
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @param {SerializerMiddleware<any, any>=} target target middleware
+	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
+	 */
+	static isLazy(fn, target) {
+		if (typeof fn !== "function") return false;
+		const t = fn[LAZY_TARGET];
+		return target ? t === target : !!t;
+	}
 
-const DISABLED_METHODS = [
-	"copyWithin",
-	"entries",
-	"fill",
-	"keys",
-	"pop",
-	"reverse",
-	"shift",
-	"splice",
-	"sort",
-	"unshift"
-];
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @returns {object} options
+	 */
+	static getLazyOptions(fn) {
+		if (typeof fn !== "function") return undefined;
+		return /** @type {any} */ (fn).options;
+	}
 
-/**
- * @param {any} set new set
- * @param {string} name property name
- * @returns {void}
- */
-exports.arrayToSetDeprecation = (set, name) => {
-	for (const method of COPY_METHODS) {
-		if (set[method]) continue;
-		const d = createDeprecation(
-			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
-			"ARRAY_TO_SET"
-		);
-		/**
-		 * @deprecated
-		 * @this {Set}
-		 * @returns {number} count
-		 */
-		set[method] = function () {
-			d();
-			const array = Array.from(this);
-			return Array.prototype[method].apply(array, arguments);
-		};
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @returns {any} serialized value
+	 */
+	static getLazySerializedValue(fn) {
+		if (typeof fn !== "function") return undefined;
+		return fn[LAZY_SERIALIZED_VALUE];
 	}
-	const dPush = createDeprecation(
-		`${name} was changed from Array to Set (using Array method 'push' is deprecated)`,
-		"ARRAY_TO_SET_PUSH"
-	);
-	const dLength = createDeprecation(
-		`${name} was changed from Array to Set (using Array property 'length' is deprecated)`,
-		"ARRAY_TO_SET_LENGTH"
-	);
-	const dIndexer = createDeprecation(
-		`${name} was changed from Array to Set (indexing Array is deprecated)`,
-		"ARRAY_TO_SET_INDEXER"
-	);
+
 	/**
-	 * @deprecated
-	 * @this {Set}
-	 * @returns {number} count
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @param {any} value serialized value
+	 * @returns {void}
 	 */
-	set.push = function () {
-		dPush();
-		for (const item of Array.from(arguments)) {
-			this.add(item);
-		}
-		return this.size;
-	};
-	for (const method of DISABLED_METHODS) {
-		if (set[method]) continue;
-		set[method] = () => {
-			throw new Error(
-				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
-			);
-		};
+	static setLazySerializedValue(fn, value) {
+		fn[LAZY_SERIALIZED_VALUE] = value;
 	}
-	const createIndexGetter = index => {
-		/**
-		 * @this {Set} a Set
-		 * @returns {any} the value at this location
-		 */
-		const fn = function () {
-			dIndexer();
-			let i = 0;
-			for (const item of this) {
-				if (i++ === index) return item;
-			}
-			return undefined;
-		};
-		return fn;
-	};
-	const defineIndexGetter = index => {
-		Object.defineProperty(set, index, {
-			get: createIndexGetter(index),
-			set(value) {
-				throw new Error(
-					`${name} was changed from Array to Set (indexing Array with write is not possible)`
-				);
+
+	/**
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @param {function(any): Promise<any> | any} serialize serialize function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	static serializeLazy(lazy, serialize) {
+		const fn = memoize(() => {
+			const r = lazy();
+			if (r && typeof r.then === "function") {
+				return r.then(data => data && serialize(data));
 			}
+			return serialize(r);
 		});
-	};
-	defineIndexGetter(0);
-	let indexerDefined = 1;
-	Object.defineProperty(set, "length", {
-		get() {
-			dLength();
-			const length = this.size;
-			for (indexerDefined; indexerDefined < length + 1; indexerDefined++) {
-				defineIndexGetter(indexerDefined);
-			}
-			return length;
-		},
-		set(value) {
-			throw new Error(
-				`${name} was changed from Array to Set (writing to Array property 'length' is not possible)`
-			);
-		}
-	});
-	set[Symbol.isConcatSpreadable] = true;
-};
+		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		lazy[LAZY_SERIALIZED_VALUE] = fn;
+		return fn;
+	}
 
-exports.createArrayToSetDeprecationSet = name => {
-	let initialized = false;
-	class SetDeprecatedArray extends Set {
-		constructor(items) {
-			super(items);
-			if (!initialized) {
-				initialized = true;
-				exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
+	/**
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @param {function(any): Promise<any> | any} deserialize deserialize function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	static deserializeLazy(lazy, deserialize) {
+		const fn = memoize(() => {
+			const r = lazy();
+			if (r && typeof r.then === "function") {
+				return r.then(data => deserialize(data));
 			}
-		}
+			return deserialize(r);
+		});
+		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		fn[LAZY_SERIALIZED_VALUE] = lazy;
+		return fn;
 	}
-	return SetDeprecatedArray;
-};
-
-exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
-	const message = `${name} will be frozen in future, all modifications are deprecated.${
-		note && `\n${note}`
-	}`;
-	return new Proxy(obj, {
-		set: util.deprecate(
-			(target, property, value, receiver) =>
-				Reflect.set(target, property, value, receiver),
-			message,
-			code
-		),
-		defineProperty: util.deprecate(
-			(target, property, descriptor) =>
-				Reflect.defineProperty(target, property, descriptor),
-			message,
-			code
-		),
-		deleteProperty: util.deprecate(
-			(target, property) => Reflect.deleteProperty(target, property),
-			message,
-			code
-		),
-		setPrototypeOf: util.deprecate(
-			(target, proto) => Reflect.setPrototypeOf(target, proto),
-			message,
-			code
-		)
-	});
-};
 
-/**
- * @template T
- * @param {T} obj object
- * @param {string} message deprecation message
- * @param {string} code deprecation code
- * @returns {T} object with property access deprecated
- */
-const deprecateAllProperties = (obj, message, code) => {
-	const newObj = {};
-	const descriptors = Object.getOwnPropertyDescriptors(obj);
-	for (const name of Object.keys(descriptors)) {
-		const descriptor = descriptors[name];
-		if (typeof descriptor.value === "function") {
-			Object.defineProperty(newObj, name, {
-				...descriptor,
-				value: util.deprecate(descriptor.value, message, code)
-			});
-		} else if (descriptor.get || descriptor.set) {
-			Object.defineProperty(newObj, name, {
-				...descriptor,
-				get: descriptor.get && util.deprecate(descriptor.get, message, code),
-				set: descriptor.set && util.deprecate(descriptor.set, message, code)
-			});
-		} else {
-			let value = descriptor.value;
-			Object.defineProperty(newObj, name, {
-				configurable: descriptor.configurable,
-				enumerable: descriptor.enumerable,
-				get: util.deprecate(() => value, message, code),
-				set: descriptor.writable
-					? util.deprecate(v => (value = v), message, code)
-					: undefined
-			});
-		}
+	/**
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	static unMemoizeLazy(lazy) {
+		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
+		const fn = () => {
+			throw new Error(
+				"A lazy value that has been unmemorized can't be called again"
+			);
+		};
+		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
+			lazy[LAZY_SERIALIZED_VALUE]
+		);
+		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+		fn.options = /** @type {any} */ (lazy).options;
+		return fn;
 	}
-	return /** @type {T} */ (newObj);
-};
-exports.deprecateAllProperties = deprecateAllProperties;
+}
 
-/**
- * @template T
- * @param {T} fakeHook fake hook implementation
- * @param {string=} message deprecation message (not deprecated when unset)
- * @param {string=} code deprecation code (not deprecated when unset)
- * @returns {FakeHook<T>} fake hook which redirects
- */
-exports.createFakeHook = (fakeHook, message, code) => {
-	if (message && code) {
-		fakeHook = deprecateAllProperties(fakeHook, message, code);
-	}
-	return Object.freeze(
-		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
-	);
-};
+module.exports = SerializerMiddleware;
 
 
 /***/ }),
 
-/***/ 59836:
+/***/ 79240:
 /***/ (function(module) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-// Simulations show these probabilities for a single change
-// 93.1% that one group is invalidated
-// 4.8% that two groups are invalidated
-// 1.1% that 3 groups are invalidated
-// 0.1% that 4 or more groups are invalidated
-//
-// And these for removing/adding 10 lexically adjacent files
-// 64.5% that one group is invalidated
-// 24.8% that two groups are invalidated
-// 7.8% that 3 groups are invalidated
-// 2.7% that 4 or more groups are invalidated
-//
-// And these for removing/adding 3 random files
-// 0% that one group is invalidated
-// 3.7% that two groups are invalidated
-// 80.8% that 3 groups are invalidated
-// 12.3% that 4 groups are invalidated
-// 3.2% that 5 or more groups are invalidated
-
-/**
- *
- * @param {string} a key
- * @param {string} b key
- * @returns {number} the similarity as number
- */
-const similarity = (a, b) => {
-	const l = Math.min(a.length, b.length);
-	let dist = 0;
-	for (let i = 0; i < l; i++) {
-		const ca = a.charCodeAt(i);
-		const cb = b.charCodeAt(i);
-		dist += Math.max(0, 10 - Math.abs(ca - cb));
-	}
-	return dist;
-};
-
-/**
- * @param {string} a key
- * @param {string} b key
- * @param {Set<string>} usedNames set of already used names
- * @returns {string} the common part and a single char for the difference
- */
-const getName = (a, b, usedNames) => {
-	const l = Math.min(a.length, b.length);
-	let i = 0;
-	while (i < l) {
-		if (a.charCodeAt(i) !== b.charCodeAt(i)) {
-			i++;
-			break;
-		}
-		i++;
-	}
-	while (i < l) {
-		const name = a.slice(0, i);
-		const lowerName = name.toLowerCase();
-		if (!usedNames.has(lowerName)) {
-			usedNames.add(lowerName);
-			return name;
-		}
-		i++;
-	}
-	// names always contain a hash, so this is always unique
-	// we don't need to check usedNames nor add it
-	return a;
-};
-
-/**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
- * @returns {void}
- */
-const addSizeTo = (total, size) => {
-	for (const key of Object.keys(size)) {
-		total[key] = (total[key] || 0) + size[key];
-	}
-};
-
-/**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
- * @returns {void}
- */
-const subtractSizeFrom = (total, size) => {
-	for (const key of Object.keys(size)) {
-		total[key] -= size[key];
-	}
-};
-
-/**
- * @param {Iterable<Node>} nodes some nodes
- * @returns {Record<string, number>} total size
- */
-const sumSize = nodes => {
-	const sum = Object.create(null);
-	for (const node of nodes) {
-		addSizeTo(sum, node.size);
-	}
-	return sum;
-};
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-const isTooBig = (size, maxSize) => {
-	for (const key of Object.keys(size)) {
-		const s = size[key];
-		if (s === 0) continue;
-		const maxSizeValue = maxSize[key];
-		if (typeof maxSizeValue === "number") {
-			if (s > maxSizeValue) return true;
-		}
-	}
-	return false;
-};
 
-const isTooSmall = (size, minSize) => {
-	for (const key of Object.keys(size)) {
-		const s = size[key];
-		if (s === 0) continue;
-		const minSizeValue = minSize[key];
-		if (typeof minSizeValue === "number") {
-			if (s < minSizeValue) return true;
+
+class SetObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.size);
+		for (const value of obj) {
+			write(value);
 		}
 	}
-	return false;
-};
-
-const getTooSmallTypes = (size, minSize) => {
-	const types = new Set();
-	for (const key of Object.keys(size)) {
-		const s = size[key];
-		if (s === 0) continue;
-		const minSizeValue = minSize[key];
-		if (typeof minSizeValue === "number") {
-			if (s < minSizeValue) types.add(key);
+	deserialize({ read }) {
+		let size = read();
+		const set = new Set();
+		for (let i = 0; i < size; i++) {
+			set.add(read());
 		}
+		return set;
 	}
-	return types;
-};
+}
 
-const getNumberOfMatchingSizeTypes = (size, types) => {
-	let i = 0;
-	for (const key of Object.keys(size)) {
-		if (size[key] !== 0 && types.has(key)) i++;
-	}
-	return i;
-};
+module.exports = SetObjectSerializer;
 
-const selectiveSizeSum = (size, types) => {
-	let sum = 0;
-	for (const key of Object.keys(size)) {
-		if (size[key] !== 0 && types.has(key)) sum += size[key];
-	}
-	return sum;
-};
 
-/**
- * @template T
- */
-class Node {
-	/**
-	 * @param {T} item item
-	 * @param {string} key key
-	 * @param {Record<string, number>} size size
-	 */
-	constructor(item, key, size) {
-		this.item = item;
-		this.key = key;
-		this.size = size;
-	}
-}
+/***/ }),
+
+/***/ 65112:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const SerializerMiddleware = __webpack_require__(83137);
 
 /**
- * @template T
+ * @typedef {any} DeserializedType
+ * @typedef {any[]} SerializedType
+ * @extends {SerializerMiddleware<any, any[]>}
  */
-class Group {
+class SingleItemMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
-	 * @param {Record<string, number>=} size size of the group
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
 	 */
-	constructor(nodes, similarities, size) {
-		this.nodes = nodes;
-		this.similarities = similarities;
-		this.size = size || sumSize(nodes);
-		/** @type {string} */
-		this.key = undefined;
+	serialize(data, context) {
+		return [data];
 	}
 
 	/**
-	 * @param {function(Node): boolean} filter filter function
-	 * @returns {Node[]} removed nodes
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	popNodes(filter) {
-		const newNodes = [];
-		const newSimilarities = [];
-		const resultNodes = [];
-		let lastNode;
-		for (let i = 0; i < this.nodes.length; i++) {
-			const node = this.nodes[i];
-			if (filter(node)) {
-				resultNodes.push(node);
-			} else {
-				if (newNodes.length > 0) {
-					newSimilarities.push(
-						lastNode === this.nodes[i - 1]
-							? this.similarities[i - 1]
-							: similarity(lastNode.key, node.key)
-					);
-				}
-				newNodes.push(node);
-				lastNode = node;
-			}
-		}
-		if (resultNodes.length === this.nodes.length) return undefined;
-		this.nodes = newNodes;
-		this.similarities = newSimilarities;
-		this.size = sumSize(newNodes);
-		return resultNodes;
+	deserialize(data, context) {
+		return data[0];
 	}
 }
 
-/**
- * @param {Iterable<Node>} nodes nodes
- * @returns {number[]} similarities
- */
-const getSimilarities = nodes => {
-	// calculate similarities between lexically adjacent nodes
-	/** @type {number[]} */
-	const similarities = [];
-	let last = undefined;
-	for (const node of nodes) {
-		if (last !== undefined) {
-			similarities.push(similarity(last.key, node.key));
-		}
-		last = node;
-	}
-	return similarities;
-};
+module.exports = SingleItemMiddleware;
 
-/**
- * @template T
- * @typedef {Object} GroupedItems<T>
- * @property {string} key
- * @property {T[]} items
- * @property {Record<string, number>} size
- */
 
-/**
- * @template T
- * @typedef {Object} Options
- * @property {Record<string, number>} maxSize maximum size of a group
- * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
- * @property {Iterable<T>} items a list of items
- * @property {function(T): Record<string, number>} getSize function to get size of an item
- * @property {function(T): string} getKey function to get the key of an item
- */
+/***/ }),
 
-/**
- * @template T
- * @param {Options<T>} options options object
- * @returns {GroupedItems<T>[]} grouped items
- */
-module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
-	/** @type {Group<T>[]} */
-	const result = [];
+/***/ 58831:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	const nodes = Array.from(
-		items,
-		item => new Node(item, getKey(item), getSize(item))
-	);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/** @type {Node<T>[]} */
-	const initialNodes = [];
 
-	// lexically ordering of keys
-	nodes.sort((a, b) => {
-		if (a.key < b.key) return -1;
-		if (a.key > b.key) return 1;
-		return 0;
-	});
 
-	// return nodes bigger than maxSize directly as group
-	// But make sure that minSize is not violated
-	for (const node of nodes) {
-		if (isTooBig(node.size, maxSize) && !isTooSmall(node.size, minSize)) {
-			result.push(new Group([node], []));
-		} else {
-			initialNodes.push(node);
-		}
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
+
+class ConsumeSharedFallbackDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
 
-	if (initialNodes.length > 0) {
-		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
+	get type() {
+		return "consume shared fallback";
+	}
 
-		const removeProblematicNodes = (group, consideredSize = group.size) => {
-			const problemTypes = getTooSmallTypes(consideredSize, minSize);
-			if (problemTypes.size > 0) {
-				// We hit an edge case where the working set is already smaller than minSize
-				// We merge problematic nodes with the smallest result node to keep minSize intact
-				const problemNodes = group.popNodes(
-					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
-				);
-				if (problemNodes === undefined) return false;
-				// Only merge it with result nodes that have the problematic size type
-				const possibleResultGroups = result.filter(
-					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
-				);
-				if (possibleResultGroups.length > 0) {
-					const bestGroup = possibleResultGroups.reduce((min, group) => {
-						const minMatches = getNumberOfMatchingSizeTypes(min, problemTypes);
-						const groupMatches = getNumberOfMatchingSizeTypes(
-							group,
-							problemTypes
-						);
-						if (minMatches !== groupMatches)
-							return minMatches < groupMatches ? group : min;
-						if (
-							selectiveSizeSum(min.size, problemTypes) >
-							selectiveSizeSum(group.size, problemTypes)
-						)
-							return group;
-						return min;
-					});
-					for (const node of problemNodes) bestGroup.nodes.push(node);
-					bestGroup.nodes.sort((a, b) => {
-						if (a.key < b.key) return -1;
-						if (a.key > b.key) return 1;
-						return 0;
-					});
-				} else {
-					// There are no other nodes with the same size types
-					// We create a new group and have to accept that it's smaller than minSize
-					result.push(new Group(problemNodes, null));
-				}
-				return true;
-			} else {
-				return false;
-			}
-		};
+	get category() {
+		return "esm";
+	}
+}
 
-		if (initialGroup.nodes.length > 0) {
-			const queue = [initialGroup];
+makeSerializable(
+	ConsumeSharedFallbackDependency,
+	"webpack/lib/sharing/ConsumeSharedFallbackDependency"
+);
 
-			while (queue.length) {
-				const group = queue.pop();
-				// only groups bigger than maxSize need to be splitted
-				if (!isTooBig(group.size, maxSize)) {
-					result.push(group);
-					continue;
-				}
-				// If the group is already too small
-				// we try to work only with the unproblematic nodes
-				if (removeProblematicNodes(group)) {
-					// This changed something, so we try this group again
-					queue.push(group);
-					continue;
-				}
+module.exports = ConsumeSharedFallbackDependency;
 
-				// find unsplittable area from left and right
-				// going minSize from left and right
-				// at least one node need to be included otherwise we get stuck
-				let left = 1;
-				let leftSize = Object.create(null);
-				addSizeTo(leftSize, group.nodes[0].size);
-				while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
-					addSizeTo(leftSize, group.nodes[left].size);
-					left++;
-				}
-				let right = group.nodes.length - 2;
-				let rightSize = Object.create(null);
-				addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
-				while (right >= 0 && isTooSmall(rightSize, minSize)) {
-					addSizeTo(rightSize, group.nodes[right].size);
-					right--;
-				}
 
-				//      left v   v right
-				// [ O O O ] O O O [ O O O ]
-				// ^^^^^^^^^ leftSize
-				//       rightSize ^^^^^^^^^
-				// leftSize > minSize
-				// rightSize > minSize
+/***/ }),
 
-				// Perfect split: [ O O O ] [ O O O ]
-				//                right === left - 1
+/***/ 62286:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				if (left - 1 > right) {
-					// We try to remove some problematic nodes to "fix" that
-					let prevSize;
-					if (right < group.nodes.length - left) {
-						subtractSizeFrom(rightSize, group.nodes[right + 1].size);
-						prevSize = rightSize;
-					} else {
-						subtractSizeFrom(leftSize, group.nodes[left - 1].size);
-						prevSize = leftSize;
-					}
-					if (removeProblematicNodes(group, prevSize)) {
-						// This changed something, so we try this group again
-						queue.push(group);
-						continue;
-					}
-					// can't split group while holding minSize
-					// because minSize is preferred of maxSize we return
-					// the problematic nodes as result here even while it's too big
-					// To avoid this make sure maxSize > minSize * 3
-					result.push(group);
-					continue;
-				}
-				if (left <= right) {
-					// when there is a area between left and right
-					// we look for best split point
-					// we split at the minimum similarity
-					// here key space is separated the most
-					// But we also need to make sure to not create too small groups
-					let best = -1;
-					let bestSimilarity = Infinity;
-					let pos = left;
-					let rightSize = sumSize(group.nodes.slice(pos));
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					//       pos v   v right
-					// [ O O O ] O O O [ O O O ]
-					// ^^^^^^^^^ leftSize
-					// rightSize ^^^^^^^^^^^^^^^
 
-					while (pos <= right + 1) {
-						const similarity = group.similarities[pos - 1];
-						if (
-							similarity < bestSimilarity &&
-							!isTooSmall(leftSize, minSize) &&
-							!isTooSmall(rightSize, minSize)
-						) {
-							best = pos;
-							bestSimilarity = similarity;
-						}
-						addSizeTo(leftSize, group.nodes[pos].size);
-						subtractSizeFrom(rightSize, group.nodes[pos].size);
-						pos++;
-					}
-					if (best < 0) {
-						// This can't happen
-						// but if that assumption is wrong
-						// fallback to a big group
-						result.push(group);
-						continue;
-					}
-					left = best;
-					right = best - 1;
-				}
 
-				// create two new groups for left and right area
-				// and queue them up
-				const rightNodes = [group.nodes[right + 1]];
-				/** @type {number[]} */
-				const rightSimilarities = [];
-				for (let i = right + 2; i < group.nodes.length; i++) {
-					rightSimilarities.push(group.similarities[i - 1]);
-					rightNodes.push(group.nodes[i]);
-				}
-				queue.push(new Group(rightNodes, rightSimilarities));
+const { RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const { rangeToString, stringifyHoley } = __webpack_require__(19702);
+const ConsumeSharedFallbackDependency = __webpack_require__(58831);
 
-				const leftNodes = [group.nodes[0]];
-				/** @type {number[]} */
-				const leftSimilarities = [];
-				for (let i = 1; i < left; i++) {
-					leftSimilarities.push(group.similarities[i - 1]);
-					leftNodes.push(group.nodes[i]);
-				}
-				queue.push(new Group(leftNodes, leftSimilarities));
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+
+/**
+ * @typedef {Object} ConsumeOptions
+ * @property {string=} import fallback request
+ * @property {string=} importResolved resolved fallback request
+ * @property {string} shareKey global share key
+ * @property {string} shareScope share scope
+ * @property {SemVerRange | false | undefined} requiredVersion version requirement
+ * @property {string} packageName package name to determine required version automatically
+ * @property {boolean} strictVersion don't use shared version even if version isn't valid
+ * @property {boolean} singleton use single global version
+ * @property {boolean} eager include the fallback module in a sync way
+ */
+
+const TYPES = new Set(["consume-shared"]);
+
+class ConsumeSharedModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {ConsumeOptions} options consume options
+	 */
+	constructor(context, options) {
+		super("consume-shared-module", context);
+		this.options = options;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		const {
+			shareKey,
+			shareScope,
+			importResolved,
+			requiredVersion,
+			strictVersion,
+			singleton,
+			eager
+		} = this.options;
+		return `consume-shared-module|${shareScope}|${shareKey}|${
+			requiredVersion && rangeToString(requiredVersion)
+		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		const {
+			shareKey,
+			shareScope,
+			importResolved,
+			requiredVersion,
+			strictVersion,
+			singleton,
+			eager
+		} = this.options;
+		return `consume shared module (${shareScope}) ${shareKey}@${
+			requiredVersion ? rangeToString(requiredVersion) : "*"
+		}${strictVersion ? " (strict)" : ""}${singleton ? " (singleton)" : ""}${
+			importResolved
+				? ` (fallback: ${requestShortener.shorten(importResolved)})`
+				: ""
+		}${eager ? " (eager)" : ""}`;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		const { shareKey, shareScope, import: request } = this.options;
+		return `${
+			this.layer ? `(${this.layer})/` : ""
+		}webpack/sharing/consume/${shareScope}/${shareKey}${
+			request ? `/${request}` : ""
+		}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {};
+		if (this.options.import) {
+			const dep = new ConsumeSharedFallbackDependency(this.options.import);
+			if (this.options.eager) {
+				this.addDependency(dep);
+			} else {
+				const block = new AsyncDependenciesBlock({});
+				block.addDependency(dep);
+				this.addBlock(block);
 			}
 		}
+		callback();
 	}
 
-	// lexically ordering
-	result.sort((a, b) => {
-		if (a.nodes[0].key < b.nodes[0].key) return -1;
-		if (a.nodes[0].key > b.nodes[0].key) return 1;
-		return 0;
-	});
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
 
-	// give every group a name
-	const usedNames = new Set();
-	for (let i = 0; i < result.length; i++) {
-		const group = result[i];
-		if (group.nodes.length === 1) {
-			group.key = group.nodes[0].key;
-		} else {
-			const first = group.nodes[0];
-			const last = group.nodes[group.nodes.length - 1];
-			const name = getName(first.key, last.key, usedNames);
-			group.key = name;
-		}
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
 	}
 
-	// return the results
-	return result.map(group => {
-		/** @type {GroupedItems} */
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(JSON.stringify(this.options));
+		super.updateHash(hash, context);
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ chunkGraph, moduleGraph, runtimeTemplate }) {
+		const runtimeRequirements = new Set([RuntimeGlobals.shareScopeMap]);
+		const {
+			shareScope,
+			shareKey,
+			strictVersion,
+			requiredVersion,
+			import: request,
+			singleton,
+			eager
+		} = this.options;
+		let fallbackCode;
+		if (request) {
+			if (eager) {
+				const dep = this.dependencies[0];
+				fallbackCode = runtimeTemplate.syncModuleFactory({
+					dependency: dep,
+					chunkGraph,
+					runtimeRequirements,
+					request: this.options.import
+				});
+			} else {
+				const block = this.blocks[0];
+				fallbackCode = runtimeTemplate.asyncModuleFactory({
+					block,
+					chunkGraph,
+					runtimeRequirements,
+					request: this.options.import
+				});
+			}
+		}
+		let fn = "load";
+		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
+		if (requiredVersion) {
+			if (strictVersion) {
+				fn += "Strict";
+			}
+			if (singleton) {
+				fn += "Singleton";
+			}
+			args.push(stringifyHoley(requiredVersion));
+			fn += "VersionCheck";
+		} else {
+			if (singleton) {
+				fn += "Singleton";
+			}
+		}
+		if (fallbackCode) {
+			fn += "Fallback";
+			args.push(fallbackCode);
+		}
+		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
+		const sources = new Map();
+		sources.set("consume-shared", new RawSource(code));
 		return {
-			key: group.key,
-			items: group.nodes.map(node => node.item),
-			size: group.size
+			runtimeRequirements,
+			sources
 		};
-	});
-};
-
-
-/***/ }),
-
-/***/ 11850:
-/***/ (function(module) {
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sam Chen @chenxsan
-*/
+	serialize(context) {
+		const { write } = context;
+		write(this.options);
+		super.serialize(context);
+	}
 
+	deserialize(context) {
+		const { read } = context;
+		this.options = read();
+		super.deserialize(context);
+	}
+}
 
+makeSerializable(
+	ConsumeSharedModule,
+	"webpack/lib/sharing/ConsumeSharedModule"
+);
 
-/**
- * @param {string} urlAndGlobal the script request
- * @returns {string[]} script url and its global variable
- */
-module.exports = function extractUrlAndGlobal(urlAndGlobal) {
-	const index = urlAndGlobal.indexOf("@");
-	if (index <= 0 || index === urlAndGlobal.length - 1) {
-		throw new Error(`Invalid request "${urlAndGlobal}"`);
-	}
-	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
-};
+module.exports = ConsumeSharedModule;
 
 
 /***/ }),
 
-/***/ 6261:
-/***/ (function(module) {
+/***/ 15046:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -125912,234 +121915,692 @@ module.exports = function extractUrlAndGlobal(urlAndGlobal) {
 
 
 
-const NO_MARKER = 0;
-const IN_PROGRESS_MARKER = 1;
-const DONE_MARKER = 2;
-const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
-const DONE_AND_ROOT_MARKER = 4;
+const ModuleNotFoundError = __webpack_require__(32882);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const { parseOptions } = __webpack_require__(3083);
+const LazySet = __webpack_require__(38938);
+const createSchemaValidation = __webpack_require__(32540);
+const { parseRange } = __webpack_require__(19702);
+const ConsumeSharedFallbackDependency = __webpack_require__(58831);
+const ConsumeSharedModule = __webpack_require__(62286);
+const ConsumeSharedRuntimeModule = __webpack_require__(10394);
+const ProvideForSharedDependency = __webpack_require__(40017);
+const { resolveMatchedConfigs } = __webpack_require__(3591);
+const {
+	isRequiredVersion,
+	getDescriptionFile,
+	getRequiredVersionFromDescriptionFile
+} = __webpack_require__(84379);
 
-/**
- * @template T
- */
-class Node {
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
+/** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
+
+const validate = createSchemaValidation(
+	__webpack_require__(6464),
+	() => __webpack_require__(16116),
+	{
+		name: "Consume Shared Plugin",
+		baseDataPath: "options"
+	}
+);
+
+/** @type {ResolveOptionsWithDependencyType} */
+const RESOLVE_OPTIONS = { dependencyType: "esm" };
+const PLUGIN_NAME = "ConsumeSharedPlugin";
+
+class ConsumeSharedPlugin {
 	/**
-	 * @param {T} item the value of the node
+	 * @param {ConsumeSharedPluginOptions} options options
 	 */
-	constructor(item) {
-		this.item = item;
-		/** @type {Set<Node<T>>} */
-		this.dependencies = new Set();
-		this.marker = NO_MARKER;
-		/** @type {Cycle<T> | undefined} */
-		this.cycle = undefined;
-		this.incoming = 0;
-	}
-}
+	constructor(options) {
+		if (typeof options !== "string") {
+			validate(options);
+		}
 
-/**
- * @template T
- */
-class Cycle {
-	constructor() {
-		/** @type {Set<Node<T>>} */
-		this.nodes = new Set();
+		/** @type {[string, ConsumeOptions][]} */
+		this._consumes = parseOptions(
+			options.consumes,
+			(item, key) => {
+				if (Array.isArray(item)) throw new Error("Unexpected array in options");
+				/** @type {ConsumeOptions} */
+				let result =
+					item === key || !isRequiredVersion(item)
+						? // item is a request/key
+						  {
+								import: key,
+								shareScope: options.shareScope || "default",
+								shareKey: key,
+								requiredVersion: undefined,
+								packageName: undefined,
+								strictVersion: false,
+								singleton: false,
+								eager: false
+						  }
+						: // key is a request/key
+						  // item is a version
+						  {
+								import: key,
+								shareScope: options.shareScope || "default",
+								shareKey: key,
+								requiredVersion: parseRange(item),
+								strictVersion: true,
+								packageName: undefined,
+								singleton: false,
+								eager: false
+						  };
+				return result;
+			},
+			(item, key) => ({
+				import: item.import === false ? undefined : item.import || key,
+				shareScope: item.shareScope || options.shareScope || "default",
+				shareKey: item.shareKey || key,
+				requiredVersion:
+					typeof item.requiredVersion === "string"
+						? parseRange(item.requiredVersion)
+						: item.requiredVersion,
+				strictVersion:
+					typeof item.strictVersion === "boolean"
+						? item.strictVersion
+						: item.import !== false && !item.singleton,
+				packageName: item.packageName,
+				singleton: !!item.singleton,
+				eager: !!item.eager
+			})
+		);
 	}
-}
 
-/**
- * @template T
- * @typedef {Object} StackEntry
- * @property {Node<T>} node
- * @property {Node<T>[]} openEdges
- */
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ConsumeSharedFallbackDependency,
+					normalModuleFactory
+				);
 
-/**
- * @template T
- * @param {Iterable<T>} items list of items
- * @param {function(T): Iterable<T>} getDependencies function to get dependencies of an item (items that are not in list are ignored)
- * @returns {Iterable<T>} graph roots of the items
- */
-module.exports = (items, getDependencies) => {
-	/** @type {Map<T, Node<T>>} */
-	const itemToNode = new Map();
-	for (const item of items) {
-		const node = new Node(item);
-		itemToNode.set(item, node);
+				let unresolvedConsumes, resolvedConsumes, prefixedConsumes;
+				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
+					({ resolved, unresolved, prefixed }) => {
+						resolvedConsumes = resolved;
+						unresolvedConsumes = unresolved;
+						prefixedConsumes = prefixed;
+					}
+				);
+
+				const resolver = compilation.resolverFactory.get(
+					"normal",
+					RESOLVE_OPTIONS
+				);
+
+				/**
+				 * @param {string} context issuer directory
+				 * @param {string} request request
+				 * @param {ConsumeOptions} config options
+				 * @returns {Promise<ConsumeSharedModule>} create module
+				 */
+				const createConsumeSharedModule = (context, request, config) => {
+					const requiredVersionWarning = details => {
+						const error = new WebpackError(
+							`No required version specified and unable to automatically determine one. ${details}`
+						);
+						error.file = `shared module ${request}`;
+						compilation.warnings.push(error);
+					};
+					const directFallback =
+						config.import &&
+						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
+					return Promise.all([
+						new Promise(resolve => {
+							if (!config.import) return resolve();
+							const resolveContext = {
+								/** @type {LazySet<string>} */
+								fileDependencies: new LazySet(),
+								/** @type {LazySet<string>} */
+								contextDependencies: new LazySet(),
+								/** @type {LazySet<string>} */
+								missingDependencies: new LazySet()
+							};
+							resolver.resolve(
+								{},
+								directFallback ? compiler.context : context,
+								config.import,
+								resolveContext,
+								(err, result) => {
+									compilation.contextDependencies.addAll(
+										resolveContext.contextDependencies
+									);
+									compilation.fileDependencies.addAll(
+										resolveContext.fileDependencies
+									);
+									compilation.missingDependencies.addAll(
+										resolveContext.missingDependencies
+									);
+									if (err) {
+										compilation.errors.push(
+											new ModuleNotFoundError(null, err, {
+												name: `resolving fallback for shared module ${request}`
+											})
+										);
+										return resolve();
+									}
+									resolve(result);
+								}
+							);
+						}),
+						new Promise(resolve => {
+							if (config.requiredVersion !== undefined)
+								return resolve(config.requiredVersion);
+							let packageName = config.packageName;
+							if (packageName === undefined) {
+								if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
+									// For relative or absolute requests we don't automatically use a packageName.
+									// If wished one can specify one with the packageName option.
+									return resolve();
+								}
+								const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
+								if (!match) {
+									requiredVersionWarning(
+										"Unable to extract the package name from request."
+									);
+									return resolve();
+								}
+								packageName = match[0];
+							}
+
+							getDescriptionFile(
+								compilation.inputFileSystem,
+								context,
+								["package.json"],
+								(err, result) => {
+									if (err) {
+										requiredVersionWarning(
+											`Unable to read description file: ${err}`
+										);
+										return resolve();
+									}
+									const { data, path: descriptionPath } = result;
+									if (!data) {
+										requiredVersionWarning(
+											`Unable to find description file in ${context}.`
+										);
+										return resolve();
+									}
+									const requiredVersion = getRequiredVersionFromDescriptionFile(
+										data,
+										packageName
+									);
+									if (typeof requiredVersion !== "string") {
+										requiredVersionWarning(
+											`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
+										);
+										return resolve();
+									}
+									resolve(parseRange(requiredVersion));
+								}
+							);
+						})
+					]).then(([importResolved, requiredVersion]) => {
+						return new ConsumeSharedModule(
+							directFallback ? compiler.context : context,
+							{
+								...config,
+								importResolved,
+								import: importResolved ? config.import : undefined,
+								requiredVersion
+							}
+						);
+					});
+				};
+
+				normalModuleFactory.hooks.factorize.tapPromise(
+					PLUGIN_NAME,
+					({ context, request, dependencies }) =>
+						// wait for resolving to be complete
+						promise.then(() => {
+							if (
+								dependencies[0] instanceof ConsumeSharedFallbackDependency ||
+								dependencies[0] instanceof ProvideForSharedDependency
+							) {
+								return;
+							}
+							const match = unresolvedConsumes.get(request);
+							if (match !== undefined) {
+								return createConsumeSharedModule(context, request, match);
+							}
+							for (const [prefix, options] of prefixedConsumes) {
+								if (request.startsWith(prefix)) {
+									const remainder = request.slice(prefix.length);
+									return createConsumeSharedModule(context, request, {
+										...options,
+										import: options.import
+											? options.import + remainder
+											: undefined,
+										shareKey: options.shareKey + remainder
+									});
+								}
+							}
+						})
+				);
+				normalModuleFactory.hooks.createModule.tapPromise(
+					PLUGIN_NAME,
+					({ resource }, { context, dependencies }) => {
+						if (
+							dependencies[0] instanceof ConsumeSharedFallbackDependency ||
+							dependencies[0] instanceof ProvideForSharedDependency
+						) {
+							return Promise.resolve();
+						}
+						const options = resolvedConsumes.get(resource);
+						if (options !== undefined) {
+							return createConsumeSharedModule(context, resource, options);
+						}
+						return Promise.resolve();
+					}
+				);
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					PLUGIN_NAME,
+					(chunk, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+						set.add(RuntimeGlobals.shareScopeMap);
+						set.add(RuntimeGlobals.initializeSharing);
+						set.add(RuntimeGlobals.hasOwnProperty);
+						compilation.addRuntimeModule(
+							chunk,
+							new ConsumeSharedRuntimeModule(set)
+						);
+					}
+				);
+			}
+		);
 	}
+}
 
-	// early exit when there is only a single item
-	if (itemToNode.size <= 1) return items;
+module.exports = ConsumeSharedPlugin;
 
-	// grab all the dependencies
-	for (const node of itemToNode.values()) {
-		for (const dep of getDependencies(node.item)) {
-			const depNode = itemToNode.get(dep);
-			if (depNode !== undefined) {
-				node.dependencies.add(depNode);
-			}
-		}
-	}
 
-	// Set of current root modules
-	// items will be removed if a new reference to it has been found
-	/** @type {Set<Node<T>>} */
-	const roots = new Set();
+/***/ }),
 
-	// Set of current cycles without references to it
-	// cycles will be removed if a new reference to it has been found
-	// that is not part of the cycle
-	/** @type {Set<Cycle<T>>} */
-	const rootCycles = new Set();
+/***/ 10394:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	// For all non-marked nodes
-	for (const selectedNode of itemToNode.values()) {
-		if (selectedNode.marker === NO_MARKER) {
-			// deep-walk all referenced modules
-			// in a non-recursive way
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			// start by entering the selected node
-			selectedNode.marker = IN_PROGRESS_MARKER;
 
-			// keep a stack to avoid recursive walk
-			/** @type {StackEntry<T>[]} */
-			const stack = [
-				{
-					node: selectedNode,
-					openEdges: Array.from(selectedNode.dependencies)
-				}
-			];
 
-			// process the top item until stack is empty
-			while (stack.length > 0) {
-				const topOfStack = stack[stack.length - 1];
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const {
+	parseVersionRuntimeCode,
+	versionLtRuntimeCode,
+	rangeToStringRuntimeCode,
+	satisfyRuntimeCode
+} = __webpack_require__(19702);
 
-				// Are there still edges unprocessed in the current node?
-				if (topOfStack.openEdges.length > 0) {
-					// Process one dependency
-					const dependency = topOfStack.openEdges.pop();
-					switch (dependency.marker) {
-						case NO_MARKER:
-							// dependency has not be visited yet
-							// mark it as in-progress and recurse
-							stack.push({
-								node: dependency,
-								openEdges: Array.from(dependency.dependencies)
-							});
-							dependency.marker = IN_PROGRESS_MARKER;
-							break;
-						case IN_PROGRESS_MARKER: {
-							// It's a in-progress cycle
-							let cycle = dependency.cycle;
-							if (!cycle) {
-								cycle = new Cycle();
-								cycle.nodes.add(dependency);
-								dependency.cycle = cycle;
-							}
-							// set cycle property for each node in the cycle
-							// if nodes are already part of a cycle
-							// we merge the cycles to a shared cycle
-							for (
-								let i = stack.length - 1;
-								stack[i].node !== dependency;
-								i--
-							) {
-								const node = stack[i].node;
-								if (node.cycle) {
-									if (node.cycle !== cycle) {
-										// merge cycles
-										for (const cycleNode of node.cycle.nodes) {
-											cycleNode.cycle = cycle;
-											cycle.nodes.add(cycleNode);
-										}
-									}
-								} else {
-									node.cycle = cycle;
-									cycle.nodes.add(node);
-								}
-							}
-							// don't recurse into dependencies
-							// these are already on the stack
-							break;
-						}
-						case DONE_AND_ROOT_MARKER:
-							// This node has be visited yet and is currently a root node
-							// But as this is a new reference to the node
-							// it's not really a root
-							// so we have to convert it to a normal node
-							dependency.marker = DONE_MARKER;
-							roots.delete(dependency);
-							break;
-						case DONE_MAYBE_ROOT_CYCLE_MARKER:
-							// This node has be visited yet and
-							// is maybe currently part of a completed root cycle
-							// we found a new reference to the cycle
-							// so it's not really a root cycle
-							// remove the cycle from the root cycles
-							// and convert it to a normal node
-							rootCycles.delete(dependency.cycle);
-							dependency.marker = DONE_MARKER;
-							break;
-						// DONE_MARKER: nothing to do, don't recurse into dependencies
-					}
-				} else {
-					// All dependencies of the current node has been visited
-					// we leave the node
-					stack.pop();
-					topOfStack.node.marker = DONE_MARKER;
-				}
-			}
-			const cycle = selectedNode.cycle;
-			if (cycle) {
-				for (const node of cycle.nodes) {
-					node.marker = DONE_MAYBE_ROOT_CYCLE_MARKER;
-				}
-				rootCycles.add(cycle);
-			} else {
-				selectedNode.marker = DONE_AND_ROOT_MARKER;
-				roots.add(selectedNode);
-			}
-		}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
+
+class ConsumeSharedRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("consumes", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
 	}
 
-	// Extract roots from root cycles
-	// We take the nodes with most incoming edges
-	// inside of the cycle
-	for (const cycle of rootCycles) {
-		let max = 0;
-		/** @type {Set<Node<T>>} */
-		const cycleRoots = new Set();
-		const nodes = cycle.nodes;
-		for (const node of nodes) {
-			for (const dep of node.dependencies) {
-				if (nodes.has(dep)) {
-					dep.incoming++;
-					if (dep.incoming < max) continue;
-					if (dep.incoming > max) {
-						cycleRoots.clear();
-						max = dep.incoming;
-					}
-					cycleRoots.add(dep);
-				}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunkGraph } = this;
+		const { runtimeTemplate, codeGenerationResults } = compilation;
+		const chunkToModuleMapping = {};
+		/** @type {Map<string | number, Source>} */
+		const moduleIdToSourceMapping = new Map();
+		const initialConsumes = [];
+		/**
+		 *
+		 * @param {Iterable<Module>} modules modules
+		 * @param {Chunk} chunk the chunk
+		 * @param {(string | number)[]} list list of ids
+		 */
+		const addModules = (modules, chunk, list) => {
+			for (const m of modules) {
+				const module = /** @type {ConsumeSharedModule} */ (m);
+				const id = chunkGraph.getModuleId(module);
+				list.push(id);
+				moduleIdToSourceMapping.set(
+					id,
+					codeGenerationResults.getSource(
+						module,
+						chunk.runtime,
+						"consume-shared"
+					)
+				);
 			}
+		};
+		for (const chunk of this.chunk.getAllAsyncChunks()) {
+			const modules = chunkGraph.getChunkModulesIterableBySourceType(
+				chunk,
+				"consume-shared"
+			);
+			if (!modules) continue;
+			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
 		}
-		for (const cycleRoot of cycleRoots) {
-			roots.add(cycleRoot);
+		for (const chunk of this.chunk.getAllInitialChunks()) {
+			const modules = chunkGraph.getChunkModulesIterableBySourceType(
+				chunk,
+				"consume-shared"
+			);
+			if (!modules) continue;
+			addModules(modules, chunk, initialConsumes);
 		}
-	}
+		if (moduleIdToSourceMapping.size === 0) return null;
+		return Template.asString([
+			parseVersionRuntimeCode(runtimeTemplate),
+			versionLtRuntimeCode(runtimeTemplate),
+			rangeToStringRuntimeCode(runtimeTemplate),
+			satisfyRuntimeCode(runtimeTemplate),
+			`var ensureExistence = ${runtimeTemplate.basicFunction("scopeName, key", [
+				`var scope = ${RuntimeGlobals.shareScopeMap}[scopeName];`,
+				`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) throw new Error("Shared module " + key + " doesn't exist in shared scope " + scopeName);`,
+				"return scope;"
+			])};`,
+			`var findVersion = ${runtimeTemplate.basicFunction("scope, key", [
+				"var versions = scope[key];",
+				`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+					"a, b",
+					["return !a || versionLt(a, b) ? b : a;"]
+				)}, 0);`,
+				"return key && versions[key]"
+			])};`,
+			`var findSingletonVersionKey = ${runtimeTemplate.basicFunction(
+				"scope, key",
+				[
+					"var versions = scope[key];",
+					`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+						"a, b",
+						["return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;"]
+					)}, 0);`
+				]
+			)};`,
+			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
+				"scope, key, version, requiredVersion",
+				[
+					`return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
+				]
+			)};`,
+			`var getSingleton = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"return get(scope[key][version]);"
+				]
+			)};`,
+			`var getSingletonVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"if (!satisfy(requiredVersion, version)) " +
+						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));',
+					"return get(scope[key][version]);"
+				]
+			)};`,
+			`var getStrictSingletonVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"if (!satisfy(requiredVersion, version)) " +
+						"throw new Error(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));",
+					"return get(scope[key][version]);"
+				]
+			)};`,
+			`var findValidVersion = ${runtimeTemplate.basicFunction(
+				"scope, key, requiredVersion",
+				[
+					"var versions = scope[key];",
+					`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+						"a, b",
+						[
+							"if (!satisfy(requiredVersion, b)) return a;",
+							"return !a || versionLt(a, b) ? b : a;"
+						]
+					)}, 0);`,
+					"return key && versions[key]"
+				]
+			)};`,
+			`var getInvalidVersionMessage = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var versions = scope[key];",
+					'return "No satisfying version (" + rangeToString(requiredVersion) + ") of shared module " + key + " found in shared scope " + scopeName + ".\\n" +',
+					`\t"Available versions: " + Object.keys(versions).map(${runtimeTemplate.basicFunction(
+						"key",
+						['return key + " from " + versions[key].from;']
+					)}).join(", ");`
+				]
+			)};`,
+			`var getValidVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var entry = findValidVersion(scope, key, requiredVersion);",
+					"if(entry) return get(entry);",
+					"throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
+				]
+			)};`,
+			`var warnInvalidVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					'typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));'
+				]
+			)};`,
+			`var get = ${runtimeTemplate.basicFunction("entry", [
+				"entry.loaded = 1;",
+				"return entry.get()"
+			])};`,
+			`var init = ${runtimeTemplate.returningFunction(
+				Template.asString([
+					"function(scopeName, a, b, c) {",
+					Template.indent([
+						`var promise = ${RuntimeGlobals.initializeSharing}(scopeName);`,
+						`if (promise && promise.then) return promise.then(fn.bind(fn, scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c));`,
+						`return fn(scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c);`
+					]),
+					"}"
+				]),
+				"fn"
+			)};`,
+			"",
+			`var load = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key",
+				[
+					"ensureExistence(scopeName, key);",
+					"return get(findVersion(scope, key));"
+				]
+			)});`,
+			`var loadFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, fallback",
+				[
+					`return scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) ? get(findVersion(scope, key)) : fallback();`
+				]
+			)});`,
+			`var loadVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
+				]
+			)});`,
+			`var loadSingleton = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getSingleton(scope, scopeName, key);"
+				]
+			)});`,
+			`var loadSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadStrictVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getValidVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadStrictSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getStrictSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
+				]
+			)});`,
+			`var loadSingletonFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getSingleton(scope, scopeName, key);"
+				]
+			)});`,
+			`var loadSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadStrictVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`var entry = scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) && findValidVersion(scope, key, version);`,
+					`return entry ? get(entry) : fallback();`
+				]
+			)});`,
+			`var loadStrictSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getStrictSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			"var installedModules = {};",
+			"var moduleToHandlerMapping = {",
+			Template.indent(
+				Array.from(
+					moduleIdToSourceMapping,
+					([key, source]) => `${JSON.stringify(key)}: ${source.source()}`
+				).join(",\n")
+			),
+			"};",
 
-	// When roots were found, return them
-	if (roots.size > 0) {
-		return Array.from(roots, r => r.item);
-	} else {
-		throw new Error("Implementation of findGraphRoots is broken");
+			initialConsumes.length > 0
+				? Template.asString([
+						`var initialConsumes = ${JSON.stringify(initialConsumes)};`,
+						`initialConsumes.forEach(${runtimeTemplate.basicFunction("id", [
+							`${
+								RuntimeGlobals.moduleFactories
+							}[id] = ${runtimeTemplate.basicFunction("module", [
+								"// Handle case when module is used sync",
+								"installedModules[id] = 0;",
+								`delete ${RuntimeGlobals.moduleCache}[id];`,
+								"var factory = moduleToHandlerMapping[id]();",
+								'if(typeof factory !== "function") throw new Error("Shared module is not available for eager consumption: " + id);',
+								`module.exports = factory();`
+							])}`
+						])});`
+				  ])
+				: "// no consumes in initial chunks",
+			this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+				? Template.asString([
+						`var chunkMapping = ${JSON.stringify(
+							chunkToModuleMapping,
+							null,
+							"\t"
+						)};`,
+						`${
+							RuntimeGlobals.ensureChunkHandlers
+						}.consumes = ${runtimeTemplate.basicFunction("chunkId, promises", [
+							`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
+							Template.indent([
+								`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction(
+									"id",
+									[
+										`if(${RuntimeGlobals.hasOwnProperty}(installedModules, id)) return promises.push(installedModules[id]);`,
+										`var onFactory = ${runtimeTemplate.basicFunction(
+											"factory",
+											[
+												"installedModules[id] = 0;",
+												`${
+													RuntimeGlobals.moduleFactories
+												}[id] = ${runtimeTemplate.basicFunction("module", [
+													`delete ${RuntimeGlobals.moduleCache}[id];`,
+													"module.exports = factory();"
+												])}`
+											]
+										)};`,
+										`var onError = ${runtimeTemplate.basicFunction("error", [
+											"delete installedModules[id];",
+											`${
+												RuntimeGlobals.moduleFactories
+											}[id] = ${runtimeTemplate.basicFunction("module", [
+												`delete ${RuntimeGlobals.moduleCache}[id];`,
+												"throw error;"
+											])}`
+										])};`,
+										"try {",
+										Template.indent([
+											"var promise = moduleToHandlerMapping[id]();",
+											"if(promise.then) {",
+											Template.indent(
+												"promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));"
+											),
+											"} else onFactory(promise);"
+										]),
+										"} catch(e) { onError(e); }"
+									]
+								)});`
+							]),
+							"}"
+						])}`
+				  ])
+				: "// no chunk loading of consumes"
+		]);
 	}
-};
+}
+
+module.exports = ConsumeSharedRuntimeModule;
 
 
 /***/ }),
 
-/***/ 17139:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 40017:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -126149,1009 +122610,938 @@ module.exports = (items, getDependencies) => {
 
 
 
-const path = __webpack_require__(71017);
-
-/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-/**
- * @typedef {Object} IStats
- * @property {() => boolean} isFile
- * @property {() => boolean} isDirectory
- * @property {() => boolean} isBlockDevice
- * @property {() => boolean} isCharacterDevice
- * @property {() => boolean} isSymbolicLink
- * @property {() => boolean} isFIFO
- * @property {() => boolean} isSocket
- * @property {number | bigint} dev
- * @property {number | bigint} ino
- * @property {number | bigint} mode
- * @property {number | bigint} nlink
- * @property {number | bigint} uid
- * @property {number | bigint} gid
- * @property {number | bigint} rdev
- * @property {number | bigint} size
- * @property {number | bigint} blksize
- * @property {number | bigint} blocks
- * @property {number | bigint} atimeMs
- * @property {number | bigint} mtimeMs
- * @property {number | bigint} ctimeMs
- * @property {number | bigint} birthtimeMs
- * @property {Date} atime
- * @property {Date} mtime
- * @property {Date} ctime
- * @property {Date} birthtime
- */
+class ProvideForSharedDependency extends ModuleDependency {
+	/**
+	 *
+	 * @param {string} request request string
+	 */
+	constructor(request) {
+		super(request);
+	}
 
-/**
- * @typedef {Object} IDirent
- * @property {() => boolean} isFile
- * @property {() => boolean} isDirectory
- * @property {() => boolean} isBlockDevice
- * @property {() => boolean} isCharacterDevice
- * @property {() => boolean} isSymbolicLink
- * @property {() => boolean} isFIFO
- * @property {() => boolean} isSocket
- * @property {string | Buffer} name
- */
+	get type() {
+		return "provide module for shared";
+	}
 
-/** @typedef {function((NodeJS.ErrnoException | null)=): void} Callback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer=): void} BufferCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer|string=): void} BufferOrStringCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, string=): void} StringCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, number=): void} NumberCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, IStats=): void} StatsCallback */
-/** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
-/** @typedef {function((NodeJS.ErrnoException | Error | null)=, IStats|string=): void} LstatReadlinkAbsoluteCallback */
+	get category() {
+		return "esm";
+	}
+}
 
-/**
- * @typedef {Object} WatcherInfo
- * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
- * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
- * @property {Map<string, FileSystemInfoEntry | "ignore">} fileTimeInfoEntries get info about files
- * @property {Map<string, FileSystemInfoEntry | "ignore">} contextTimeInfoEntries get info about directories
- */
+makeSerializable(
+	ProvideForSharedDependency,
+	"webpack/lib/sharing/ProvideForSharedDependency"
+);
 
-// TODO webpack 6 deprecate missing getInfo
-/**
- * @typedef {Object} Watcher
- * @property {function(): void} close closes the watcher and all underlying file watchers
- * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
- * @property {function(): Set<string>=} getAggregatedChanges get current aggregated changes that have not yet send to callback
- * @property {function(): Set<string>=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
- * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getFileTimeInfoEntries get info about files
- * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getContextTimeInfoEntries get info about directories
- * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
- */
+module.exports = ProvideForSharedDependency;
 
-/**
- * @callback WatchMethod
- * @param {Iterable<string>} files watched files
- * @param {Iterable<string>} directories watched directories
- * @param {Iterable<string>} missing watched exitance entries
- * @param {number} startTime timestamp of start time
- * @param {WatchOptions} options options object
- * @param {function(Error=, Map<string, FileSystemInfoEntry | "ignore">, Map<string, FileSystemInfoEntry | "ignore">, Set<string>, Set<string>): void} callback aggregated callback
- * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
- * @returns {Watcher} a watcher
- */
 
-// TODO webpack 6 make optional methods required
+/***/ }),
 
-/**
- * @typedef {Object} OutputFileSystem
- * @property {function(string, Buffer|string, Callback): void} writeFile
- * @property {function(string, Callback): void} mkdir
- * @property {function(string, DirentArrayCallback): void=} readdir
- * @property {function(string, Callback): void=} rmdir
- * @property {function(string, Callback): void=} unlink
- * @property {function(string, StatsCallback): void} stat
- * @property {function(string, StatsCallback): void=} lstat
- * @property {function(string, BufferOrStringCallback): void} readFile
- * @property {(function(string, string): string)=} join
- * @property {(function(string, string): string)=} relative
- * @property {(function(string): string)=} dirname
- */
+/***/ 1798:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * @typedef {Object} InputFileSystem
- * @property {function(string, BufferOrStringCallback): void} readFile
- * @property {(function(string, ReadJsonCallback): void)=} readJson
- * @property {function(string, BufferOrStringCallback): void} readlink
- * @property {function(string, DirentArrayCallback): void} readdir
- * @property {function(string, StatsCallback): void} stat
- * @property {function(string, StatsCallback): void=} lstat
- * @property {(function(string, BufferOrStringCallback): void)=} realpath
- * @property {(function(string=): void)=} purge
- * @property {(function(string, string): string)=} join
- * @property {(function(string, string): string)=} relative
- * @property {(function(string): string)=} dirname
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @typedef {Object} WatchFileSystem
- * @property {WatchMethod} watch
- */
 
-/**
- * @typedef {Object} IntermediateFileSystemExtras
- * @property {function(string): void} mkdirSync
- * @property {function(string): NodeJS.WritableStream} createWriteStream
- * @property {function(string, string, NumberCallback): void} open
- * @property {function(number, Buffer, number, number, number, NumberCallback): void} read
- * @property {function(number, Callback): void} close
- * @property {function(string, string, Callback): void} rename
- */
 
-/** @typedef {InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras} IntermediateFileSystem */
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
 
-/**
- *
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
- * @param {string} rootPath the root path
- * @param {string} targetPath the target path
- * @returns {string} location of targetPath relative to rootPath
- */
-const relative = (fs, rootPath, targetPath) => {
-	if (fs && fs.relative) {
-		return fs.relative(rootPath, targetPath);
-	} else if (path.posix.isAbsolute(rootPath)) {
-		return path.posix.relative(rootPath, targetPath);
-	} else if (path.win32.isAbsolute(rootPath)) {
-		return path.win32.relative(rootPath, targetPath);
-	} else {
-		throw new Error(
-			`${rootPath} is neither a posix nor a windows path, and there is no 'relative' method defined in the file system`
-		);
+class ProvideSharedDependency extends Dependency {
+	constructor(shareScope, name, version, request, eager) {
+		super();
+		this.shareScope = shareScope;
+		this.name = name;
+		this.version = version;
+		this.request = request;
+		this.eager = eager;
 	}
-};
-exports.relative = relative;
 
-/**
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
- * @param {string} rootPath a path
- * @param {string} filename a filename
- * @returns {string} the joined path
- */
-const join = (fs, rootPath, filename) => {
-	if (fs && fs.join) {
-		return fs.join(rootPath, filename);
-	} else if (path.posix.isAbsolute(rootPath)) {
-		return path.posix.join(rootPath, filename);
-	} else if (path.win32.isAbsolute(rootPath)) {
-		return path.win32.join(rootPath, filename);
-	} else {
-		throw new Error(
-			`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`
-		);
+	get type() {
+		return "provide shared module";
 	}
-};
-exports.join = join;
 
-/**
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
- * @param {string} absPath an absolute path
- * @returns {string} the parent directory of the absolute path
- */
-const dirname = (fs, absPath) => {
-	if (fs && fs.dirname) {
-		return fs.dirname(absPath);
-	} else if (path.posix.isAbsolute(absPath)) {
-		return path.posix.dirname(absPath);
-	} else if (path.win32.isAbsolute(absPath)) {
-		return path.win32.dirname(absPath);
-	} else {
-		throw new Error(
-			`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`
-		);
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `provide module (${this.shareScope}) ${this.request} as ${
+			this.name
+		} @ ${this.version}${this.eager ? " (eager)" : ""}`;
 	}
-};
-exports.dirname = dirname;
 
-/**
- * @param {OutputFileSystem} fs a file system
- * @param {string} p an absolute path
- * @param {function(Error=): void} callback callback function for the error
- * @returns {void}
- */
-const mkdirp = (fs, p, callback) => {
-	fs.mkdir(p, err => {
-		if (err) {
-			if (err.code === "ENOENT") {
-				const dir = dirname(fs, p);
-				if (dir === p) {
-					callback(err);
-					return;
-				}
-				mkdirp(fs, dir, err => {
-					if (err) {
-						callback(err);
-						return;
-					}
-					fs.mkdir(p, err => {
-						if (err) {
-							if (err.code === "EEXIST") {
-								callback();
-								return;
-							}
-							callback(err);
-							return;
-						}
-						callback();
-					});
-				});
-				return;
-			} else if (err.code === "EEXIST") {
-				callback();
-				return;
-			}
-			callback(err);
-			return;
-		}
-		callback();
-	});
-};
-exports.mkdirp = mkdirp;
+	serialize(context) {
+		context.write(this.shareScope);
+		context.write(this.name);
+		context.write(this.request);
+		context.write(this.version);
+		context.write(this.eager);
+		super.serialize(context);
+	}
 
-/**
- * @param {IntermediateFileSystem} fs a file system
- * @param {string} p an absolute path
- * @returns {void}
- */
-const mkdirpSync = (fs, p) => {
-	try {
-		fs.mkdirSync(p);
-	} catch (err) {
-		if (err) {
-			if (err.code === "ENOENT") {
-				const dir = dirname(fs, p);
-				if (dir === p) {
-					throw err;
-				}
-				mkdirpSync(fs, dir);
-				fs.mkdirSync(p);
-				return;
-			} else if (err.code === "EEXIST") {
-				return;
-			}
-			throw err;
-		}
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new ProvideSharedDependency(
+			read(),
+			read(),
+			read(),
+			read(),
+			read()
+		);
+		this.shareScope = context.read();
+		obj.deserialize(context);
+		return obj;
 	}
-};
-exports.mkdirpSync = mkdirpSync;
+}
 
-/**
- * @param {InputFileSystem} fs a file system
- * @param {string} p an absolute path
- * @param {ReadJsonCallback} callback callback
- * @returns {void}
- */
-const readJson = (fs, p, callback) => {
-	if ("readJson" in fs) return fs.readJson(p, callback);
-	fs.readFile(p, (err, buf) => {
-		if (err) return callback(err);
-		let data;
-		try {
-			data = JSON.parse(buf.toString("utf-8"));
-		} catch (e) {
-			return callback(e);
-		}
-		return callback(null, data);
-	});
-};
-exports.readJson = readJson;
+makeSerializable(
+	ProvideSharedDependency,
+	"webpack/lib/sharing/ProvideSharedDependency"
+);
 
-/**
- * @param {InputFileSystem} fs a file system
- * @param {string} p an absolute path
- * @param {ReadJsonCallback} callback callback
- * @returns {void}
- */
-const lstatReadlinkAbsolute = (fs, p, callback) => {
-	let i = 3;
-	const doReadLink = () => {
-		fs.readlink(p, (err, target) => {
-			if (err && --i > 0) {
-				// It might was just changed from symlink to file
-				// we retry 2 times to catch this case before throwing the error
-				return doStat();
-			}
-			if (err || !target) return doStat();
-			const value = target.toString();
-			callback(null, join(fs, dirname(fs, p), value));
-		});
-	};
-	const doStat = () => {
-		if ("lstat" in fs) {
-			return fs.lstat(p, (err, stats) => {
-				if (err) return callback(err);
-				if (stats.isSymbolicLink()) {
-					return doReadLink();
-				}
-				callback(null, stats);
-			});
-		} else {
-			return fs.stat(p, callback);
-		}
-	};
-	if ("lstat" in fs) return doStat();
-	doReadLink();
-};
-exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
+module.exports = ProvideSharedDependency;
 
 
 /***/ }),
 
-/***/ 59461:
+/***/ 50821:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const Hash = __webpack_require__(36692);
-const MAX_SHORT_STRING = (__webpack_require__(1842).MAX_SHORT_STRING);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const ProvideForSharedDependency = __webpack_require__(40017);
 
-class BatchedHash extends Hash {
-	constructor(hash) {
-		super();
-		this.string = undefined;
-		this.encoding = undefined;
-		this.hash = hash;
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["share-init"]);
+
+class ProvideSharedModule extends Module {
+	/**
+	 * @param {string} shareScope shared scope name
+	 * @param {string} name shared key
+	 * @param {string | false} version version
+	 * @param {string} request request to the provided module
+	 * @param {boolean} eager include the module in sync way
+	 */
+	constructor(shareScope, name, version, request, eager) {
+		super("provide-module");
+		this._shareScope = shareScope;
+		this._name = name;
+		this._version = version;
+		this._request = request;
+		this._eager = eager;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `provide module (${this._shareScope}) ${this._name}@${this._version} = ${this._request}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `provide shared module (${this._shareScope}) ${this._name}@${
+			this._version
+		} = ${requestShortener.shorten(this._request)}`;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
+			this._shareScope
+		}/${this._name}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true
+		};
+
+		this.clearDependenciesAndBlocks();
+		const dep = new ProvideForSharedDependency(this._request);
+		if (this._eager) {
+			this.addDependency(dep);
+		} else {
+			const block = new AsyncDependenciesBlock({});
+			block.addDependency(dep);
+			this.addBlock(block);
+		}
+
+		callback();
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
+	}
+
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	update(data, inputEncoding) {
-		if (this.string !== undefined) {
-			if (
-				typeof data === "string" &&
-				inputEncoding === this.encoding &&
-				this.string.length + data.length < MAX_SHORT_STRING
-			) {
-				this.string += data;
-				return this;
-			}
-			this.hash.update(this.string, this.encoding);
-			this.string = undefined;
-		}
-		if (typeof data === "string") {
-			if (
-				data.length < MAX_SHORT_STRING &&
-				// base64 encoding is not valid since it may contain padding chars
-				(!inputEncoding || !inputEncoding.startsWith("ba"))
-			) {
-				this.string = data;
-				this.encoding = inputEncoding;
-			} else {
-				this.hash.update(data, inputEncoding);
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const runtimeRequirements = new Set([RuntimeGlobals.initializeSharing]);
+		const code = `register(${JSON.stringify(this._name)}, ${JSON.stringify(
+			this._version || "0"
+		)}, ${
+			this._eager
+				? runtimeTemplate.syncModuleFactory({
+						dependency: this.dependencies[0],
+						chunkGraph,
+						request: this._request,
+						runtimeRequirements
+				  })
+				: runtimeTemplate.asyncModuleFactory({
+						block: this.blocks[0],
+						chunkGraph,
+						request: this._request,
+						runtimeRequirements
+				  })
+		}${this._eager ? ", 1" : ""});`;
+		const sources = new Map();
+		const data = new Map();
+		data.set("share-init", [
+			{
+				shareScope: this._shareScope,
+				initStage: 10,
+				init: code
 			}
-		} else {
-			this.hash.update(data);
-		}
-		return this;
+		]);
+		return { sources, data, runtimeRequirements };
 	}
 
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
-	 */
-	digest(encoding) {
-		if (this.string !== undefined) {
-			this.hash.update(this.string, this.encoding);
-		}
-		return this.hash.digest(encoding);
+	serialize(context) {
+		const { write } = context;
+		write(this._shareScope);
+		write(this._name);
+		write(this._version);
+		write(this._request);
+		write(this._eager);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new ProvideSharedModule(read(), read(), read(), read(), read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-module.exports = BatchedHash;
+makeSerializable(
+	ProvideSharedModule,
+	"webpack/lib/sharing/ProvideSharedModule"
+);
+
+module.exports = ProvideSharedModule;
 
 
 /***/ }),
 
-/***/ 86884:
+/***/ 39344:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const create = __webpack_require__(1842);
+const ModuleFactory = __webpack_require__(51010);
+const ProvideSharedModule = __webpack_require__(50821);
 
-//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
-const md4 = new WebAssembly.Module(
-	Buffer.from(
-		// 2156 bytes
-		"AGFzbQEAAAABCAJgAX8AYAAAAwUEAQAAAAUDAQABBhoFfwFBAAt/AUEAC38BQQALfwFBAAt/AUEACwciBARpbml0AAAGdXBkYXRlAAIFZmluYWwAAwZtZW1vcnkCAAqLEAQmAEGBxpS6BiQBQYnXtv5+JAJB/rnrxXkkA0H2qMmBASQEQQAkAAvSCgEZfyMBIQUjAiECIwMhAyMEIQQDQCAAIAFLBEAgASgCJCISIAEoAiAiEyABKAIcIgkgASgCGCIIIAEoAhQiByABKAIQIg4gASgCDCIGIAEoAggiDyABKAIEIhAgASgCACIRIAMgBHMgAnEgBHMgBWpqQQN3IgogAiADc3EgA3MgBGpqQQd3IgsgAiAKc3EgAnMgA2pqQQt3IgwgCiALc3EgCnMgAmpqQRN3Ig0gCyAMc3EgC3MgCmpqQQN3IgogDCANc3EgDHMgC2pqQQd3IgsgCiANc3EgDXMgDGpqQQt3IgwgCiALc3EgCnMgDWpqQRN3Ig0gCyAMc3EgC3MgCmpqQQN3IhQgDCANc3EgDHMgC2pqQQd3IRUgASgCLCILIAEoAigiCiAMIA0gDSAUcyAVcXNqakELdyIWIBQgFXNxIBRzIA1qakETdyEXIAEoAjQiGCABKAIwIhkgFSAWcyAXcSAVcyAUampBA3ciFCAWIBdzcSAWcyAVampBB3chFSABKAI8Ig0gASgCOCIMIBQgF3MgFXEgF3MgFmpqQQt3IhYgFCAVc3EgFHMgF2pqQRN3IRcgEyAOIBEgFCAVIBZyIBdxIBUgFnFyampBmfOJ1AVqQQN3IhQgFiAXcnEgFiAXcXIgFWpqQZnzidQFakEFdyIVIBQgF3JxIBQgF3FyIBZqakGZ84nUBWpBCXchFiAPIBggEiAWIAcgFSAQIBQgGSAUIBVyIBZxIBQgFXFyIBdqakGZ84nUBWpBDXciFCAVIBZycSAVIBZxcmpqQZnzidQFakEDdyIVIBQgFnJxIBQgFnFyampBmfOJ1AVqQQV3IhcgFCAVcnEgFCAVcXJqakGZ84nUBWpBCXciFiAVIBdycSAVIBdxciAUampBmfOJ1AVqQQ13IhQgFiAXcnEgFiAXcXIgFWpqQZnzidQFakEDdyEVIBEgBiAVIAwgFCAKIBYgCCAUIBZyIBVxIBQgFnFyIBdqakGZ84nUBWpBBXciFyAUIBVycSAUIBVxcmpqQZnzidQFakEJdyIWIBUgF3JxIBUgF3FyampBmfOJ1AVqQQ13IhQgFiAXcnEgFiAXcXJqakGZ84nUBWpBA3ciFSALIBYgCSAUIBZyIBVxIBQgFnFyIBdqakGZ84nUBWpBBXciFiAUIBVycSAUIBVxcmpqQZnzidQFakEJdyIXIA0gFSAWciAXcSAVIBZxciAUampBmfOJ1AVqQQ13IhRzIBZzampBodfn9gZqQQN3IREgByAIIA4gFCARIBcgESAUc3MgFmogE2pBodfn9gZqQQl3IhNzcyAXampBodfn9gZqQQt3Ig4gDyARIBMgDiARIA4gE3NzIBRqIBlqQaHX5/YGakEPdyIRc3NqakGh1+f2BmpBA3ciDyAOIA8gEXNzIBNqIApqQaHX5/YGakEJdyIKcyARc2pqQaHX5/YGakELdyIIIBAgDyAKIAggDCAPIAggCnNzIBFqakGh1+f2BmpBD3ciDHNzampBodfn9gZqQQN3Ig4gEiAIIAwgDnNzIApqakGh1+f2BmpBCXciCHMgDHNqakGh1+f2BmpBC3chByAFIAYgCCAHIBggDiAHIAhzcyAMampBodfn9gZqQQ93IgpzcyAOampBodfn9gZqQQN3IgZqIQUgDSAGIAkgByAGIAsgByAGIApzcyAIampBodfn9gZqQQl3IgdzIApzampBodfn9gZqQQt3IgYgB3NzIApqakGh1+f2BmpBD3cgAmohAiADIAZqIQMgBCAHaiEEIAFBQGshAQwBCwsgBSQBIAIkAiADJAMgBCQECw0AIAAQASAAIwBqJAAL/wQCA38BfiAAIwBqrUIDhiEEIABByABqQUBxIgJBCGshAyAAIgFBAWohACABQYABOgAAA0AgACACSUEAIABBB3EbBEAgAEEAOgAAIABBAWohAAwBCwsDQCAAIAJJBEAgAEIANwMAIABBCGohAAwBCwsgAyAENwMAIAIQAUEAIwGtIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEIIwKtIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEQIwOtIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEYIwStIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAAs=",
-		"base64"
-	)
-);
-//#endregion
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
 
-module.exports = create.bind(null, md4, [], 64, 32);
+class ProvideSharedModuleFactory extends ModuleFactory {
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dep = /** @type {ProvideSharedDependency} */ (data.dependencies[0]);
+		callback(null, {
+			module: new ProvideSharedModule(
+				dep.shareScope,
+				dep.name,
+				dep.version,
+				dep.request,
+				dep.eager
+			)
+		});
+	}
+}
+
+module.exports = ProvideSharedModuleFactory;
 
 
 /***/ }),
 
-/***/ 1842:
-/***/ (function(module) {
+/***/ 31225:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-// 65536 is the size of a wasm memory page
-// 64 is the maximum chunk size for every possible wasm hash implementation
-// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
-// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
-const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+const WebpackError = __webpack_require__(53799);
+const { parseOptions } = __webpack_require__(3083);
+const createSchemaValidation = __webpack_require__(32540);
+const ProvideForSharedDependency = __webpack_require__(40017);
+const ProvideSharedDependency = __webpack_require__(1798);
+const ProvideSharedModuleFactory = __webpack_require__(39344);
 
-class WasmHash {
-	/**
-	 * @param {WebAssembly.Instance} instance wasm instance
-	 * @param {WebAssembly.Instance[]} instancesPool pool of instances
-	 * @param {number} chunkSize size of data chunks passed to wasm
-	 * @param {number} digestSize size of digest returned by wasm
-	 */
-	constructor(instance, instancesPool, chunkSize, digestSize) {
-		const exports = /** @type {any} */ (instance.exports);
-		exports.init();
-		this.exports = exports;
-		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
-		this.buffered = 0;
-		this.instancesPool = instancesPool;
-		this.chunkSize = chunkSize;
-		this.digestSize = digestSize;
-	}
+/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
 
-	reset() {
-		this.buffered = 0;
-		this.exports.init();
+const validate = createSchemaValidation(
+	__webpack_require__(91924),
+	() => __webpack_require__(438),
+	{
+		name: "Provide Shared Plugin",
+		baseDataPath: "options"
 	}
+);
+
+/**
+ * @typedef {Object} ProvideOptions
+ * @property {string} shareKey
+ * @property {string} shareScope
+ * @property {string | undefined | false} version
+ * @property {boolean} eager
+ */
+
+/** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
 
+class ProvideSharedPlugin {
 	/**
-	 * @param {Buffer | string} data data
-	 * @param {BufferEncoding=} encoding encoding
-	 * @returns {this} itself
+	 * @param {ProvideSharedPluginOptions} options options
 	 */
-	update(data, encoding) {
-		if (typeof data === "string") {
-			while (data.length > MAX_SHORT_STRING) {
-				this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
-				data = data.slice(MAX_SHORT_STRING);
-			}
-			this._updateWithShortString(data, encoding);
-			return this;
-		}
-		this._updateWithBuffer(data);
-		return this;
+	constructor(options) {
+		validate(options);
+
+		/** @type {[string, ProvideOptions][]} */
+		this._provides = parseOptions(
+			options.provides,
+			item => {
+				if (Array.isArray(item))
+					throw new Error("Unexpected array of provides");
+				/** @type {ProvideOptions} */
+				const result = {
+					shareKey: item,
+					version: undefined,
+					shareScope: options.shareScope || "default",
+					eager: false
+				};
+				return result;
+			},
+			item => ({
+				shareKey: item.shareKey,
+				version: item.version,
+				shareScope: item.shareScope || options.shareScope || "default",
+				eager: !!item.eager
+			})
+		);
+		this._provides.sort(([a], [b]) => {
+			if (a < b) return -1;
+			if (b < a) return 1;
+			return 0;
+		});
 	}
 
 	/**
-	 * @param {string} data data
-	 * @param {BufferEncoding=} encoding encoding
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	_updateWithShortString(data, encoding) {
-		const { exports, buffered, mem, chunkSize } = this;
-		let endPos;
-		if (data.length < 70) {
-			if (!encoding || encoding === "utf-8" || encoding === "utf8") {
-				endPos = buffered;
-				for (let i = 0; i < data.length; i++) {
-					const cc = data.charCodeAt(i);
-					if (cc < 0x80) mem[endPos++] = cc;
-					else if (cc < 0x800) {
-						mem[endPos] = (cc >> 6) | 0xc0;
-						mem[endPos + 1] = (cc & 0x3f) | 0x80;
-						endPos += 2;
+	apply(compiler) {
+		/** @type {WeakMap<Compilation, ResolvedProvideMap>} */
+		const compilationData = new WeakMap();
+
+		compiler.hooks.compilation.tap(
+			"ProvideSharedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/** @type {ResolvedProvideMap} */
+				const resolvedProvideMap = new Map();
+				/** @type {Map<string, ProvideOptions>} */
+				const matchProvides = new Map();
+				/** @type {Map<string, ProvideOptions>} */
+				const prefixMatchProvides = new Map();
+				for (const [request, config] of this._provides) {
+					if (/^(\/|[A-Za-z]:\\|\\\\|\.\.?(\/|$))/.test(request)) {
+						// relative request
+						resolvedProvideMap.set(request, {
+							config,
+							version: config.version
+						});
+					} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+						// absolute path
+						resolvedProvideMap.set(request, {
+							config,
+							version: config.version
+						});
+					} else if (request.endsWith("/")) {
+						// module request prefix
+						prefixMatchProvides.set(request, config);
 					} else {
-						// bail-out for weird chars
-						endPos += mem.write(data.slice(i), endPos, encoding);
-						break;
+						// module request
+						matchProvides.set(request, config);
 					}
 				}
-			} else if (encoding === "latin1") {
-				endPos = buffered;
-				for (let i = 0; i < data.length; i++) {
-					const cc = data.charCodeAt(i);
-					mem[endPos++] = cc;
-				}
-			} else {
-				endPos = buffered + mem.write(data, buffered, encoding);
-			}
-		} else {
-			endPos = buffered + mem.write(data, buffered, encoding);
-		}
-		if (endPos < chunkSize) {
-			this.buffered = endPos;
-		} else {
-			const l = endPos & ~(this.chunkSize - 1);
-			exports.update(l);
-			const newBuffered = endPos - l;
-			this.buffered = newBuffered;
-			if (newBuffered > 0) mem.copyWithin(0, l, endPos);
-		}
-	}
-
-	/**
-	 * @param {Buffer} data data
-	 * @returns {void}
-	 */
-	_updateWithBuffer(data) {
-		const { exports, buffered, mem } = this;
-		const length = data.length;
-		if (buffered + length < this.chunkSize) {
-			data.copy(mem, buffered, 0, length);
-			this.buffered += length;
-		} else {
-			const l = (buffered + length) & ~(this.chunkSize - 1);
-			if (l > 65536) {
-				let i = 65536 - buffered;
-				data.copy(mem, buffered, 0, i);
-				exports.update(65536);
-				const stop = l - buffered - 65536;
-				while (i < stop) {
-					data.copy(mem, 0, i, i + 65536);
-					exports.update(65536);
-					i += 65536;
-				}
-				data.copy(mem, 0, i, l - buffered);
-				exports.update(l - buffered - i);
-			} else {
-				data.copy(mem, buffered, 0, l - buffered);
-				exports.update(l);
+				compilationData.set(compilation, resolvedProvideMap);
+				const provideSharedModule = (
+					key,
+					config,
+					resource,
+					resourceResolveData
+				) => {
+					let version = config.version;
+					if (version === undefined) {
+						let details = "";
+						if (!resourceResolveData) {
+							details = `No resolve data provided from resolver.`;
+						} else {
+							const descriptionFileData =
+								resourceResolveData.descriptionFileData;
+							if (!descriptionFileData) {
+								details =
+									"No description file (usually package.json) found. Add description file with name and version, or manually specify version in shared config.";
+							} else if (!descriptionFileData.version) {
+								details =
+									"No version in description file (usually package.json). Add version to description file, or manually specify version in shared config.";
+							} else {
+								version = descriptionFileData.version;
+							}
+						}
+						if (!version) {
+							const error = new WebpackError(
+								`No version specified and unable to automatically determine one. ${details}`
+							);
+							error.file = `shared module ${key} -> ${resource}`;
+							compilation.warnings.push(error);
+						}
+					}
+					resolvedProvideMap.set(resource, {
+						config,
+						version
+					});
+				};
+				normalModuleFactory.hooks.module.tap(
+					"ProvideSharedPlugin",
+					(module, { resource, resourceResolveData }, resolveData) => {
+						if (resolvedProvideMap.has(resource)) {
+							return module;
+						}
+						const { request } = resolveData;
+						{
+							const config = matchProvides.get(request);
+							if (config !== undefined) {
+								provideSharedModule(
+									request,
+									config,
+									resource,
+									resourceResolveData
+								);
+								resolveData.cacheable = false;
+							}
+						}
+						for (const [prefix, config] of prefixMatchProvides) {
+							if (request.startsWith(prefix)) {
+								const remainder = request.slice(prefix.length);
+								provideSharedModule(
+									resource,
+									{
+										...config,
+										shareKey: config.shareKey + remainder
+									},
+									resource,
+									resourceResolveData
+								);
+								resolveData.cacheable = false;
+							}
+						}
+						return module;
+					}
+				);
 			}
-			const newBuffered = length + buffered - l;
-			this.buffered = newBuffered;
-			if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
-		}
-	}
-
-	digest(type) {
-		const { exports, buffered, mem, digestSize } = this;
-		exports.final(buffered);
-		this.instancesPool.push(this);
-		const hex = mem.toString("latin1", 0, digestSize);
-		if (type === "hex") return hex;
-		if (type === "binary" || !type) return Buffer.from(hex, "hex");
-		return Buffer.from(hex, "hex").toString(type);
-	}
-}
-
-const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
-	if (instancesPool.length > 0) {
-		const old = instancesPool.pop();
-		old.reset();
-		return old;
-	} else {
-		return new WasmHash(
-			new WebAssembly.Instance(wasmModule),
-			instancesPool,
-			chunkSize,
-			digestSize
 		);
-	}
-};
-
-module.exports = create;
-module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
-
-
-/***/ }),
-
-/***/ 35028:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
+			const resolvedProvideMap = compilationData.get(compilation);
+			if (!resolvedProvideMap) return Promise.resolve();
+			return Promise.all(
+				Array.from(
+					resolvedProvideMap,
+					([resource, { config, version }]) =>
+						new Promise((resolve, reject) => {
+							compilation.addInclude(
+								compiler.context,
+								new ProvideSharedDependency(
+									config.shareScope,
+									config.shareKey,
+									version || false,
+									resource,
+									config.eager
+								),
+								{
+									name: undefined
+								},
+								err => {
+									if (err) return reject(err);
+									resolve();
+								}
+							);
+						})
+				)
+			).then(() => {});
+		});
 
-const create = __webpack_require__(1842);
+		compiler.hooks.compilation.tap(
+			"ProvideSharedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ProvideForSharedDependency,
+					normalModuleFactory
+				);
 
-//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
-const xxhash64 = new WebAssembly.Module(
-	Buffer.from(
-		// 1170 bytes
-		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrIIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqAYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEAgAiABNQIAQoeVr6+Ytt6bnn9+hUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAkIdiCAChUL5893xmfaZqxZ+IgJCIIggAoUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL",
-		"base64"
-	)
-);
-//#endregion
+				compilation.dependencyFactories.set(
+					ProvideSharedDependency,
+					new ProvideSharedModuleFactory()
+				);
+			}
+		);
+	}
+}
 
-module.exports = create.bind(null, xxhash64, [], 32, 16);
+module.exports = ProvideSharedPlugin;
 
 
 /***/ }),
 
-/***/ 82186:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 26335:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const path = __webpack_require__(71017);
-
-const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
-const SEGMENTS_SPLIT_REGEXP = /([|!])/;
-const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
-
-/**
- * @typedef {Object} MakeRelativePathsCache
- * @property {Map<string, Map<string, string>>=} relativePaths
- */
-
-const relativePathToRequest = relativePath => {
-	if (relativePath === "") return "./.";
-	if (relativePath === "..") return "../.";
-	if (relativePath.startsWith("../")) return relativePath;
-	return `./${relativePath}`;
-};
+const { parseOptions } = __webpack_require__(3083);
+const ConsumeSharedPlugin = __webpack_require__(15046);
+const ProvideSharedPlugin = __webpack_require__(31225);
+const { isRequiredVersion } = __webpack_require__(84379);
 
-/**
- * @param {string} context context for relative path
- * @param {string} maybeAbsolutePath path to make relative
- * @returns {string} relative path in request style
- */
-const absoluteToRequest = (context, maybeAbsolutePath) => {
-	if (maybeAbsolutePath[0] === "/") {
-		if (
-			maybeAbsolutePath.length > 1 &&
-			maybeAbsolutePath[maybeAbsolutePath.length - 1] === "/"
-		) {
-			// this 'path' is actually a regexp generated by dynamic requires.
-			// Don't treat it as an absolute path.
-			return maybeAbsolutePath;
-		}
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
+/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvidesConfig} ProvidesConfig */
+/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharePluginOptions} SharePluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharedConfig} SharedConfig */
+/** @typedef {import("../Compiler")} Compiler */
 
-		const querySplitPos = maybeAbsolutePath.indexOf("?");
-		let resource =
-			querySplitPos === -1
-				? maybeAbsolutePath
-				: maybeAbsolutePath.slice(0, querySplitPos);
-		resource = relativePathToRequest(path.posix.relative(context, resource));
-		return querySplitPos === -1
-			? resource
-			: resource + maybeAbsolutePath.slice(querySplitPos);
+class SharePlugin {
+	/**
+	 * @param {SharePluginOptions} options options
+	 */
+	constructor(options) {
+		/** @type {[string, SharedConfig][]} */
+		const sharedOptions = parseOptions(
+			options.shared,
+			(item, key) => {
+				if (typeof item !== "string")
+					throw new Error("Unexpected array in shared");
+				/** @type {SharedConfig} */
+				const config =
+					item === key || !isRequiredVersion(item)
+						? {
+								import: item
+						  }
+						: {
+								import: key,
+								requiredVersion: item
+						  };
+				return config;
+			},
+			item => item
+		);
+		/** @type {Record<string, ConsumesConfig>[]} */
+		const consumes = sharedOptions.map(([key, options]) => ({
+			[key]: {
+				import: options.import,
+				shareKey: options.shareKey || key,
+				shareScope: options.shareScope,
+				requiredVersion: options.requiredVersion,
+				strictVersion: options.strictVersion,
+				singleton: options.singleton,
+				packageName: options.packageName,
+				eager: options.eager
+			}
+		}));
+		/** @type {Record<string, ProvidesConfig>[]} */
+		const provides = sharedOptions
+			.filter(([, options]) => options.import !== false)
+			.map(([key, options]) => ({
+				[options.import || key]: {
+					shareKey: options.shareKey || key,
+					shareScope: options.shareScope,
+					version: options.version,
+					eager: options.eager
+				}
+			}));
+		this._shareScope = options.shareScope;
+		this._consumes = consumes;
+		this._provides = provides;
 	}
 
-	if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
-		const querySplitPos = maybeAbsolutePath.indexOf("?");
-		let resource =
-			querySplitPos === -1
-				? maybeAbsolutePath
-				: maybeAbsolutePath.slice(0, querySplitPos);
-		resource = path.win32.relative(context, resource);
-		if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
-			resource = relativePathToRequest(
-				resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/")
-			);
-		}
-		return querySplitPos === -1
-			? resource
-			: resource + maybeAbsolutePath.slice(querySplitPos);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ConsumeSharedPlugin({
+			shareScope: this._shareScope,
+			consumes: this._consumes
+		}).apply(compiler);
+		new ProvideSharedPlugin({
+			shareScope: this._shareScope,
+			provides: this._provides
+		}).apply(compiler);
 	}
+}
 
-	// not an absolute path
-	return maybeAbsolutePath;
-};
-
-/**
- * @param {string} context context for relative path
- * @param {string} relativePath path
- * @returns {string} absolute path
- */
-const requestToAbsolute = (context, relativePath) => {
-	if (relativePath.startsWith("./") || relativePath.startsWith("../"))
-		return path.join(context, relativePath);
-	return relativePath;
-};
-
-const makeCacheable = fn => {
-	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
-	const cache = new WeakMap();
+module.exports = SharePlugin;
 
-	/**
-	 * @param {string} context context used to create relative path
-	 * @param {string} identifier identifier used to create relative path
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {string} the returned relative path
-	 */
-	const cachedFn = (context, identifier, associatedObjectForCache) => {
-		if (!associatedObjectForCache) return fn(context, identifier);
 
-		let innerCache = cache.get(associatedObjectForCache);
-		if (innerCache === undefined) {
-			innerCache = new Map();
-			cache.set(associatedObjectForCache, innerCache);
-		}
+/***/ }),
 
-		let cachedResult;
-		let innerSubCache = innerCache.get(context);
-		if (innerSubCache === undefined) {
-			innerCache.set(context, (innerSubCache = new Map()));
-		} else {
-			cachedResult = innerSubCache.get(identifier);
-		}
+/***/ 96066:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (cachedResult !== undefined) {
-			return cachedResult;
-		} else {
-			const result = fn(context, identifier);
-			innerSubCache.set(identifier, result);
-			return result;
-		}
-	};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {function(string, string): string} cached function
-	 */
-	cachedFn.bindCache = associatedObjectForCache => {
-		let innerCache;
-		if (associatedObjectForCache) {
-			innerCache = cache.get(associatedObjectForCache);
-			if (innerCache === undefined) {
-				innerCache = new Map();
-				cache.set(associatedObjectForCache, innerCache);
-			}
-		} else {
-			innerCache = new Map();
-		}
 
-		/**
-		 * @param {string} context context used to create relative path
-		 * @param {string} identifier identifier used to create relative path
-		 * @returns {string} the returned relative path
-		 */
-		const boundFn = (context, identifier) => {
-			let cachedResult;
-			let innerSubCache = innerCache.get(context);
-			if (innerSubCache === undefined) {
-				innerCache.set(context, (innerSubCache = new Map()));
-			} else {
-				cachedResult = innerSubCache.get(identifier);
-			}
 
-			if (cachedResult !== undefined) {
-				return cachedResult;
-			} else {
-				const result = fn(context, identifier);
-				innerSubCache.set(identifier, result);
-				return result;
-			}
-		};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const {
+	compareModulesByIdentifier,
+	compareStrings
+} = __webpack_require__(29579);
 
-		return boundFn;
-	};
+class ShareRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("sharing");
+	}
 
 	/**
-	 * @param {string} context context used to create relative path
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {function(string): string} cached function
+	 * @returns {string} runtime code
 	 */
-	cachedFn.bindContextCache = (context, associatedObjectForCache) => {
-		let innerSubCache;
-		if (associatedObjectForCache) {
-			let innerCache = cache.get(associatedObjectForCache);
-			if (innerCache === undefined) {
-				innerCache = new Map();
-				cache.set(associatedObjectForCache, innerCache);
-			}
-
-			innerSubCache = innerCache.get(context);
-			if (innerSubCache === undefined) {
-				innerCache.set(context, (innerSubCache = new Map()));
+	generate() {
+		const { compilation, chunkGraph } = this;
+		const {
+			runtimeTemplate,
+			codeGenerationResults,
+			outputOptions: { uniqueName }
+		} = compilation;
+		/** @type {Map<string, Map<number, Set<string>>>} */
+		const initCodePerScope = new Map();
+		for (const chunk of this.chunk.getAllReferencedChunks()) {
+			const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+				chunk,
+				"share-init",
+				compareModulesByIdentifier
+			);
+			if (!modules) continue;
+			for (const m of modules) {
+				const data = codeGenerationResults.getData(
+					m,
+					chunk.runtime,
+					"share-init"
+				);
+				if (!data) continue;
+				for (const item of data) {
+					const { shareScope, initStage, init } = item;
+					let stages = initCodePerScope.get(shareScope);
+					if (stages === undefined) {
+						initCodePerScope.set(shareScope, (stages = new Map()));
+					}
+					let list = stages.get(initStage || 0);
+					if (list === undefined) {
+						stages.set(initStage || 0, (list = new Set()));
+					}
+					list.add(init);
+				}
 			}
-		} else {
-			innerSubCache = new Map();
 		}
+		return Template.asString([
+			`${RuntimeGlobals.shareScopeMap} = {};`,
+			"var initPromises = {};",
+			"var initTokens = {};",
+			`${RuntimeGlobals.initializeSharing} = ${runtimeTemplate.basicFunction(
+				"name, initScope",
+				[
+					"if(!initScope) initScope = [];",
+					"// handling circular init calls",
+					"var initToken = initTokens[name];",
+					"if(!initToken) initToken = initTokens[name] = {};",
+					"if(initScope.indexOf(initToken) >= 0) return;",
+					"initScope.push(initToken);",
+					"// only runs once",
+					"if(initPromises[name]) return initPromises[name];",
+					"// creates a new share scope if needed",
+					`if(!${RuntimeGlobals.hasOwnProperty}(${RuntimeGlobals.shareScopeMap}, name)) ${RuntimeGlobals.shareScopeMap}[name] = {};`,
+					"// runs all init snippets from all modules reachable",
+					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
+					`var warn = ${runtimeTemplate.returningFunction(
+						'typeof console !== "undefined" && console.warn && console.warn(msg)',
+						"msg"
+					)};`,
+					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
+					`var register = ${runtimeTemplate.basicFunction(
+						"name, version, factory, eager",
+						[
+							"var versions = scope[name] = scope[name] || {};",
+							"var activeVersion = versions[version];",
+							"if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };"
+						]
+					)};`,
+					`var initExternal = ${runtimeTemplate.basicFunction("id", [
+						`var handleError = ${runtimeTemplate.expressionFunction(
+							'warn("Initialization of sharing external failed: " + err)',
+							"err"
+						)};`,
+						"try {",
+						Template.indent([
+							"var module = __webpack_require__(id);",
+							"if(!module) return;",
+							`var initFn = ${runtimeTemplate.returningFunction(
+								`module && module.init && module.init(${RuntimeGlobals.shareScopeMap}[name], initScope)`,
+								"module"
+							)}`,
+							"if(module.then) return promises.push(module.then(initFn, handleError));",
+							"var initResult = initFn(module);",
+							"if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));"
+						]),
+						"} catch(err) { handleError(err); }"
+					])}`,
+					"var promises = [];",
+					"switch(name) {",
+					...Array.from(initCodePerScope)
+						.sort(([a], [b]) => compareStrings(a, b))
+						.map(([name, stages]) =>
+							Template.indent([
+								`case ${JSON.stringify(name)}: {`,
+								Template.indent(
+									Array.from(stages)
+										.sort(([a], [b]) => a - b)
+										.map(([, initCode]) =>
+											Template.asString(Array.from(initCode))
+										)
+								),
+								"}",
+								"break;"
+							])
+						),
+					"}",
+					"if(!promises.length) return initPromises[name] = 1;",
+					`return initPromises[name] = Promise.all(promises).then(${runtimeTemplate.returningFunction(
+						"initPromises[name] = 1"
+					)});`
+				]
+			)};`
+		]);
+	}
+}
 
-		/**
-		 * @param {string} identifier identifier used to create relative path
-		 * @returns {string} the returned relative path
-		 */
-		const boundFn = identifier => {
-			const cachedResult = innerSubCache.get(identifier);
-			if (cachedResult !== undefined) {
-				return cachedResult;
-			} else {
-				const result = fn(context, identifier);
-				innerSubCache.set(identifier, result);
-				return result;
-			}
-		};
-
-		return boundFn;
-	};
-
-	return cachedFn;
-};
-
-/**
- *
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */
-const _makePathsRelative = (context, identifier) => {
-	return identifier
-		.split(SEGMENTS_SPLIT_REGEXP)
-		.map(str => absoluteToRequest(context, str))
-		.join("");
-};
-
-exports.makePathsRelative = makeCacheable(_makePathsRelative);
-
-/**
- *
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */
-const _makePathsAbsolute = (context, identifier) => {
-	return identifier
-		.split(SEGMENTS_SPLIT_REGEXP)
-		.map(str => requestToAbsolute(context, str))
-		.join("");
-};
-
-exports.makePathsAbsolute = makeCacheable(_makePathsAbsolute);
-
-/**
- * @param {string} context absolute context path
- * @param {string} request any request string may containing absolute paths, query string, etc.
- * @returns {string} a new request string avoiding absolute paths when possible
- */
-const _contextify = (context, request) => {
-	return request
-		.split("!")
-		.map(r => absoluteToRequest(context, r))
-		.join("!");
-};
-
-const contextify = makeCacheable(_contextify);
-exports.contextify = contextify;
-
-/**
- * @param {string} context absolute context path
- * @param {string} request any request string
- * @returns {string} a new request string using absolute paths when possible
- */
-const _absolutify = (context, request) => {
-	return request
-		.split("!")
-		.map(r => requestToAbsolute(context, r))
-		.join("!");
-};
-
-const absolutify = makeCacheable(_absolutify);
-exports.absolutify = absolutify;
-
-const PATH_QUERY_FRAGMENT_REGEXP =
-	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+module.exports = ShareRuntimeModule;
 
-/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
 
-/**
- * @param {string} str the path with query and fragment
- * @returns {ParsedResource} parsed parts
- */
-const _parseResource = str => {
-	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-	return {
-		resource: str,
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		fragment: match[3] || ""
-	};
-};
-exports.parseResource = (realFn => {
-	/** @type {WeakMap<object, Map<string, ParsedResource>>} */
-	const cache = new WeakMap();
+/***/ }),
 
-	const getCache = associatedObjectForCache => {
-		const entry = cache.get(associatedObjectForCache);
-		if (entry !== undefined) return entry;
-		/** @type {Map<string, ParsedResource>} */
-		const map = new Map();
-		cache.set(associatedObjectForCache, map);
-		return map;
-	};
+/***/ 3591:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-	/**
-	 * @param {string} str the path with query and fragment
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {ParsedResource} parsed parts
-	 */
-	const fn = (str, associatedObjectForCache) => {
-		if (!associatedObjectForCache) return realFn(str);
-		const cache = getCache(associatedObjectForCache);
-		const entry = cache.get(str);
-		if (entry !== undefined) return entry;
-		const result = realFn(str);
-		cache.set(str, result);
-		return result;
-	};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	fn.bindCache = associatedObjectForCache => {
-		const cache = getCache(associatedObjectForCache);
-		return str => {
-			const entry = cache.get(str);
-			if (entry !== undefined) return entry;
-			const result = realFn(str);
-			cache.set(str, result);
-			return result;
-		};
-	};
 
-	return fn;
-})(_parseResource);
+
+const ModuleNotFoundError = __webpack_require__(32882);
+const LazySet = __webpack_require__(38938);
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 
 /**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ * @template T
+ * @typedef {Object} MatchedConfigs
+ * @property {Map<string, T>} resolved
+ * @property {Map<string, T>} unresolved
+ * @property {Map<string, T>} prefixed
  */
-exports.getUndoPath = (filename, outputPath, enforceRelative) => {
-	let depth = -1;
-	let append = "";
-	outputPath = outputPath.replace(/[\\/]$/, "");
-	for (const part of filename.split(/[/\\]+/)) {
-		if (part === "..") {
-			if (depth > -1) {
-				depth--;
+
+/** @type {ResolveOptionsWithDependencyType} */
+const RESOLVE_OPTIONS = { dependencyType: "esm" };
+
+/**
+ * @template T
+ * @param {Compilation} compilation the compilation
+ * @param {[string, T][]} configs to be processed configs
+ * @returns {Promise<MatchedConfigs<T>>} resolved matchers
+ */
+exports.resolveMatchedConfigs = (compilation, configs) => {
+	/** @type {Map<string, T>} */
+	const resolved = new Map();
+	/** @type {Map<string, T>} */
+	const unresolved = new Map();
+	/** @type {Map<string, T>} */
+	const prefixed = new Map();
+	const resolveContext = {
+		/** @type {LazySet<string>} */
+		fileDependencies: new LazySet(),
+		/** @type {LazySet<string>} */
+		contextDependencies: new LazySet(),
+		/** @type {LazySet<string>} */
+		missingDependencies: new LazySet()
+	};
+	const resolver = compilation.resolverFactory.get("normal", RESOLVE_OPTIONS);
+	const context = compilation.compiler.context;
+
+	return Promise.all(
+		configs.map(([request, config]) => {
+			if (/^\.\.?(\/|$)/.test(request)) {
+				// relative request
+				return new Promise(resolve => {
+					resolver.resolve(
+						{},
+						context,
+						request,
+						resolveContext,
+						(err, result) => {
+							if (err || result === false) {
+								err = err || new Error(`Can't resolve ${request}`);
+								compilation.errors.push(
+									new ModuleNotFoundError(null, err, {
+										name: `shared module ${request}`
+									})
+								);
+								return resolve();
+							}
+							resolved.set(result, config);
+							resolve();
+						}
+					);
+				});
+			} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+				// absolute path
+				resolved.set(request, config);
+			} else if (request.endsWith("/")) {
+				// module request prefix
+				prefixed.set(request, config);
 			} else {
-				const i = outputPath.lastIndexOf("/");
-				const j = outputPath.lastIndexOf("\\");
-				const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
-				if (pos < 0) return outputPath + "/";
-				append = outputPath.slice(pos + 1) + "/" + append;
-				outputPath = outputPath.slice(0, pos);
+				// module request
+				unresolved.set(request, config);
 			}
-		} else if (part !== ".") {
-			depth++;
-		}
-	}
-	return depth > 0
-		? `${"../".repeat(depth)}${append}`
-		: enforceRelative
-		? `./${append}`
-		: append;
+		})
+	).then(() => {
+		compilation.contextDependencies.addAll(resolveContext.contextDependencies);
+		compilation.fileDependencies.addAll(resolveContext.fileDependencies);
+		compilation.missingDependencies.addAll(resolveContext.missingDependencies);
+		return { resolved, unresolved, prefixed };
+	});
 };
 
 
 /***/ }),
 
-/***/ 53023:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 84379:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -127161,1477 +123551,2501 @@ exports.getUndoPath = (filename, outputPath, enforceRelative) => {
 
 
 
-// We need to include a list of requires here
-// to allow webpack to be bundled with only static requires
-// We could use a dynamic require(`../${request}`) but this
-// would include too many modules and not every tool is able
-// to process this
-module.exports = {
-	AsyncDependenciesBlock: () => __webpack_require__(47736),
-	CommentCompilationWarning: () => __webpack_require__(98427),
-	ContextModule: () => __webpack_require__(76729),
-	"cache/PackFileCacheStrategy": () =>
-		__webpack_require__(86180),
-	"cache/ResolverCachePlugin": () => __webpack_require__(97347),
-	"container/ContainerEntryDependency": () =>
-		__webpack_require__(64813),
-	"container/ContainerEntryModule": () =>
-		__webpack_require__(80580),
-	"container/ContainerExposedDependency": () =>
-		__webpack_require__(72374),
-	"container/FallbackDependency": () =>
-		__webpack_require__(57764),
-	"container/FallbackItemDependency": () =>
-		__webpack_require__(29593),
-	"container/FallbackModule": () => __webpack_require__(82886),
-	"container/RemoteModule": () => __webpack_require__(62916),
-	"container/RemoteToExternalDependency": () =>
-		__webpack_require__(14389),
-	"dependencies/AMDDefineDependency": () =>
-		__webpack_require__(96816),
-	"dependencies/AMDRequireArrayDependency": () =>
-		__webpack_require__(33516),
-	"dependencies/AMDRequireContextDependency": () =>
-		__webpack_require__(96123),
-	"dependencies/AMDRequireDependenciesBlock": () =>
-		__webpack_require__(76932),
-	"dependencies/AMDRequireDependency": () =>
-		__webpack_require__(43911),
-	"dependencies/AMDRequireItemDependency": () =>
-		__webpack_require__(71806),
-	"dependencies/CachedConstDependency": () =>
-		__webpack_require__(57403),
-	"dependencies/CreateScriptUrlDependency": () =>
-		__webpack_require__(79062),
-	"dependencies/CommonJsRequireContextDependency": () =>
-		__webpack_require__(23962),
-	"dependencies/CommonJsExportRequireDependency": () =>
-		__webpack_require__(62892),
-	"dependencies/CommonJsExportsDependency": () =>
-		__webpack_require__(45598),
-	"dependencies/CommonJsFullRequireDependency": () =>
-		__webpack_require__(59440),
-	"dependencies/CommonJsRequireDependency": () =>
-		__webpack_require__(21264),
-	"dependencies/CommonJsSelfReferenceDependency": () =>
-		__webpack_require__(52225),
-	"dependencies/ConstDependency": () =>
-		__webpack_require__(76911),
-	"dependencies/ContextDependency": () =>
-		__webpack_require__(88101),
-	"dependencies/ContextElementDependency": () =>
-		__webpack_require__(58477),
-	"dependencies/CriticalDependencyWarning": () =>
-		__webpack_require__(15427),
-	"dependencies/CssImportDependency": () =>
-		__webpack_require__(90542),
-	"dependencies/CssLocalIdentifierDependency": () =>
-		__webpack_require__(92328),
-	"dependencies/CssSelfLocalIdentifierDependency": () =>
-		__webpack_require__(29094),
-	"dependencies/CssExportDependency": () =>
-		__webpack_require__(76760),
-	"dependencies/CssUrlDependency": () =>
-		__webpack_require__(70749),
-	"dependencies/DelegatedSourceDependency": () =>
-		__webpack_require__(22914),
-	"dependencies/DllEntryDependency": () =>
-		__webpack_require__(95666),
-	"dependencies/EntryDependency": () =>
-		__webpack_require__(3979),
-	"dependencies/ExportsInfoDependency": () =>
-		__webpack_require__(78988),
-	"dependencies/HarmonyAcceptDependency": () =>
-		__webpack_require__(23624),
-	"dependencies/HarmonyAcceptImportDependency": () =>
-		__webpack_require__(99843),
-	"dependencies/HarmonyCompatibilityDependency": () =>
-		__webpack_require__(72906),
-	"dependencies/HarmonyExportExpressionDependency": () =>
-		__webpack_require__(51340),
-	"dependencies/HarmonyExportHeaderDependency": () =>
-		__webpack_require__(38873),
-	"dependencies/HarmonyExportImportedSpecifierDependency": () =>
-		__webpack_require__(67157),
-	"dependencies/HarmonyExportSpecifierDependency": () =>
-		__webpack_require__(48567),
-	"dependencies/HarmonyImportSideEffectDependency": () =>
-		__webpack_require__(73132),
-	"dependencies/HarmonyImportSpecifierDependency": () =>
-		__webpack_require__(14077),
-	"dependencies/ImportContextDependency": () =>
-		__webpack_require__(1902),
-	"dependencies/ImportDependency": () =>
-		__webpack_require__(89376),
-	"dependencies/ImportEagerDependency": () =>
-		__webpack_require__(50718),
-	"dependencies/ImportWeakDependency": () =>
-		__webpack_require__(82483),
-	"dependencies/JsonExportsDependency": () =>
-		__webpack_require__(750),
-	"dependencies/LocalModule": () => __webpack_require__(5826),
-	"dependencies/LocalModuleDependency": () =>
-		__webpack_require__(52805),
-	"dependencies/ModuleDecoratorDependency": () =>
-		__webpack_require__(88488),
-	"dependencies/ModuleHotAcceptDependency": () =>
-		__webpack_require__(47511),
-	"dependencies/ModuleHotDeclineDependency": () =>
-		__webpack_require__(86301),
-	"dependencies/ImportMetaHotAcceptDependency": () =>
-		__webpack_require__(51274),
-	"dependencies/ImportMetaHotDeclineDependency": () =>
-		__webpack_require__(53141),
-	"dependencies/ProvidedDependency": () =>
-		__webpack_require__(95770),
-	"dependencies/PureExpressionDependency": () =>
-		__webpack_require__(55799),
-	"dependencies/RequireContextDependency": () =>
-		__webpack_require__(46917),
-	"dependencies/RequireEnsureDependenciesBlock": () =>
-		__webpack_require__(27153),
-	"dependencies/RequireEnsureDependency": () =>
-		__webpack_require__(27223),
-	"dependencies/RequireEnsureItemDependency": () =>
-		__webpack_require__(50329),
-	"dependencies/RequireHeaderDependency": () =>
-		__webpack_require__(89183),
-	"dependencies/RequireIncludeDependency": () =>
-		__webpack_require__(71284),
-	"dependencies/RequireIncludeDependencyParserPlugin": () =>
-		__webpack_require__(35768),
-	"dependencies/RequireResolveContextDependency": () =>
-		__webpack_require__(55627),
-	"dependencies/RequireResolveDependency": () =>
-		__webpack_require__(68582),
-	"dependencies/RequireResolveHeaderDependency": () =>
-		__webpack_require__(9880),
-	"dependencies/RuntimeRequirementsDependency": () =>
-		__webpack_require__(24187),
-	"dependencies/StaticExportsDependency": () =>
-		__webpack_require__(91418),
-	"dependencies/SystemPlugin": () => __webpack_require__(97981),
-	"dependencies/UnsupportedDependency": () =>
-		__webpack_require__(51669),
-	"dependencies/URLDependency": () => __webpack_require__(58612),
-	"dependencies/WebAssemblyExportImportedDependency": () =>
-		__webpack_require__(52204),
-	"dependencies/WebAssemblyImportDependency": () =>
-		__webpack_require__(5239),
-	"dependencies/WebpackIsIncludedDependency": () =>
-		__webpack_require__(26505),
-	"dependencies/WorkerDependency": () =>
-		__webpack_require__(1466),
-	"json/JsonData": () => __webpack_require__(90490),
-	"optimize/ConcatenatedModule": () =>
-		__webpack_require__(97198),
-	DelegatedModule: () => __webpack_require__(28623),
-	DependenciesBlock: () => __webpack_require__(71040),
-	DllModule: () => __webpack_require__(28280),
-	ExternalModule: () => __webpack_require__(73071),
-	FileSystemInfo: () => __webpack_require__(79453),
-	InitFragment: () => __webpack_require__(55870),
-	InvalidDependenciesModuleWarning: () =>
-		__webpack_require__(68257),
-	Module: () => __webpack_require__(73208),
-	ModuleBuildError: () => __webpack_require__(21305),
-	ModuleDependencyWarning: () => __webpack_require__(29656),
-	ModuleError: () => __webpack_require__(23744),
-	ModuleGraph: () => __webpack_require__(99988),
-	ModuleParseError: () => __webpack_require__(58443),
-	ModuleWarning: () => __webpack_require__(11234),
-	NormalModule: () => __webpack_require__(39),
-	RawDataUrlModule: () => __webpack_require__(19684),
-	RawModule: () => __webpack_require__(84929),
-	"sharing/ConsumeSharedModule": () =>
-		__webpack_require__(62286),
-	"sharing/ConsumeSharedFallbackDependency": () =>
-		__webpack_require__(58831),
-	"sharing/ProvideSharedModule": () =>
-		__webpack_require__(50821),
-	"sharing/ProvideSharedDependency": () =>
-		__webpack_require__(1798),
-	"sharing/ProvideForSharedDependency": () =>
-		__webpack_require__(40017),
-	UnsupportedFeatureWarning: () => __webpack_require__(42495),
-	"util/LazySet": () => __webpack_require__(38938),
-	UnhandledSchemeError: () => __webpack_require__(68099),
-	NodeStuffInWebError: () => __webpack_require__(6325),
-	WebpackError: () => __webpack_require__(53799),
+const { join, dirname, readJson } = __webpack_require__(17139);
 
-	"util/registerExternalSerializer": () => {
-		// already registered
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+/**
+ * @param {string} str maybe required version
+ * @returns {boolean} true, if it looks like a version
+ */
+exports.isRequiredVersion = str => {
+	return /^([\d^=v<>~]|[*xX]$)/.test(str);
+};
+
+/**
+ *
+ * @param {InputFileSystem} fs file system
+ * @param {string} directory directory to start looking into
+ * @param {string[]} descriptionFiles possible description filenames
+ * @param {function((Error | null)=, {data: object, path: string}=): void} callback callback
+ */
+const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
+	let i = 0;
+	const tryLoadCurrent = () => {
+		if (i >= descriptionFiles.length) {
+			const parentDirectory = dirname(fs, directory);
+			if (!parentDirectory || parentDirectory === directory) return callback();
+			return getDescriptionFile(
+				fs,
+				parentDirectory,
+				descriptionFiles,
+				callback
+			);
+		}
+		const filePath = join(fs, directory, descriptionFiles[i]);
+		readJson(fs, filePath, (err, data) => {
+			if (err) {
+				if ("code" in err && err.code === "ENOENT") {
+					i++;
+					return tryLoadCurrent();
+				}
+				return callback(err);
+			}
+			if (!data || typeof data !== "object" || Array.isArray(data)) {
+				return callback(
+					new Error(`Description file ${filePath} is not an object`)
+				);
+			}
+			callback(null, { data, path: filePath });
+		});
+	};
+	tryLoadCurrent();
+};
+exports.getDescriptionFile = getDescriptionFile;
+
+exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
+	if (
+		data.optionalDependencies &&
+		typeof data.optionalDependencies === "object" &&
+		packageName in data.optionalDependencies
+	) {
+		return data.optionalDependencies[packageName];
+	}
+	if (
+		data.dependencies &&
+		typeof data.dependencies === "object" &&
+		packageName in data.dependencies
+	) {
+		return data.dependencies[packageName];
+	}
+	if (
+		data.peerDependencies &&
+		typeof data.peerDependencies === "object" &&
+		packageName in data.peerDependencies
+	) {
+		return data.peerDependencies[packageName];
+	}
+	if (
+		data.devDependencies &&
+		typeof data.devDependencies === "object" &&
+		packageName in data.devDependencies
+	) {
+		return data.devDependencies[packageName];
 	}
 };
 
 
 /***/ }),
 
-/***/ 33032:
+/***/ 71760:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { register } = __webpack_require__(8282);
-
-class ClassSerializer {
-	constructor(Constructor) {
-		this.Constructor = Constructor;
-	}
-
-	serialize(obj, context) {
-		obj.serialize(context);
-	}
+const util = __webpack_require__(73837);
+const ModuleDependency = __webpack_require__(80321);
+const formatLocation = __webpack_require__(16734);
+const { LogType } = __webpack_require__(32597);
+const AggressiveSplittingPlugin = __webpack_require__(15543);
+const SizeLimitsPlugin = __webpack_require__(32557);
+const { countIterable } = __webpack_require__(39104);
+const {
+	compareLocations,
+	compareChunksById,
+	compareNumbers,
+	compareIds,
+	concatComparators,
+	compareSelect,
+	compareModulesByIdentifier
+} = __webpack_require__(29579);
+const { makePathsRelative, parseResource } = __webpack_require__(82186);
 
-	deserialize(context) {
-		if (typeof this.Constructor.deserialize === "function") {
-			return this.Constructor.deserialize(context);
-		}
-		const obj = new this.Constructor();
-		obj.deserialize(context);
-		return obj;
-	}
-}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").Asset} Asset */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleProfile")} ModuleProfile */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @template T @typedef {import("../util/comparators").Comparator<T>} Comparator<T> */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
+/** @typedef {import("./StatsFactory")} StatsFactory */
+/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
 
-module.exports = (Constructor, request, name = null) => {
-	register(Constructor, request, name, new ClassSerializer(Constructor));
-};
+/** @typedef {KnownStatsCompilation & Record<string, any>} StatsCompilation */
+/**
+ * @typedef {Object} KnownStatsCompilation
+ * @property {any=} env
+ * @property {string=} name
+ * @property {string=} hash
+ * @property {string=} version
+ * @property {number=} time
+ * @property {number=} builtAt
+ * @property {boolean=} needAdditionalPass
+ * @property {string=} publicPath
+ * @property {string=} outputPath
+ * @property {Record<string, string[]>=} assetsByChunkName
+ * @property {StatsAsset[]=} assets
+ * @property {number=} filteredAssets
+ * @property {StatsChunk[]=} chunks
+ * @property {StatsModule[]=} modules
+ * @property {number=} filteredModules
+ * @property {Record<string, StatsChunkGroup>=} entrypoints
+ * @property {Record<string, StatsChunkGroup>=} namedChunkGroups
+ * @property {StatsError[]=} errors
+ * @property {number=} errorsCount
+ * @property {StatsError[]=} warnings
+ * @property {number=} warningsCount
+ * @property {StatsCompilation[]=} children
+ * @property {Record<string, StatsLogging>=} logging
+ */
 
+/** @typedef {KnownStatsLogging & Record<string, any>} StatsLogging */
+/**
+ * @typedef {Object} KnownStatsLogging
+ * @property {StatsLoggingEntry[]} entries
+ * @property {number} filteredEntries
+ * @property {boolean} debug
+ */
 
-/***/ }),
+/** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
+/**
+ * @typedef {Object} KnownStatsLoggingEntry
+ * @property {string} type
+ * @property {string} message
+ * @property {string[]=} trace
+ * @property {StatsLoggingEntry[]=} children
+ * @property {any[]=} args
+ * @property {number=} time
+ */
 
-/***/ 78676:
-/***/ (function(module) {
+/** @typedef {KnownStatsAsset & Record<string, any>} StatsAsset */
+/**
+ * @typedef {Object} KnownStatsAsset
+ * @property {string} type
+ * @property {string} name
+ * @property {AssetInfo} info
+ * @property {number} size
+ * @property {boolean} emitted
+ * @property {boolean} comparedForEmit
+ * @property {boolean} cached
+ * @property {StatsAsset[]=} related
+ * @property {(string|number)[]=} chunkNames
+ * @property {(string|number)[]=} chunkIdHints
+ * @property {(string|number)[]=} chunks
+ * @property {(string|number)[]=} auxiliaryChunkNames
+ * @property {(string|number)[]=} auxiliaryChunks
+ * @property {(string|number)[]=} auxiliaryChunkIdHints
+ * @property {number=} filteredRelated
+ * @property {boolean=} isOverSizeLimit
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+/** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
+/**
+ * @typedef {Object} KnownStatsChunkGroup
+ * @property {string=} name
+ * @property {(string|number)[]=} chunks
+ * @property {({ name: string, size?: number })[]=} assets
+ * @property {number=} filteredAssets
+ * @property {number=} assetsSize
+ * @property {({ name: string, size?: number })[]=} auxiliaryAssets
+ * @property {number=} filteredAuxiliaryAssets
+ * @property {number=} auxiliaryAssetsSize
+ * @property {{ [x: string]: StatsChunkGroup[] }=} children
+ * @property {{ [x: string]: string[] }=} childAssets
+ * @property {boolean=} isOverSizeLimit
+ */
 
+/** @typedef {KnownStatsModule & Record<string, any>} StatsModule */
+/**
+ * @typedef {Object} KnownStatsModule
+ * @property {string=} type
+ * @property {string=} moduleType
+ * @property {string=} layer
+ * @property {string=} identifier
+ * @property {string=} name
+ * @property {string=} nameForCondition
+ * @property {number=} index
+ * @property {number=} preOrderIndex
+ * @property {number=} index2
+ * @property {number=} postOrderIndex
+ * @property {number=} size
+ * @property {{[x: string]: number}=} sizes
+ * @property {boolean=} cacheable
+ * @property {boolean=} built
+ * @property {boolean=} codeGenerated
+ * @property {boolean=} buildTimeExecuted
+ * @property {boolean=} cached
+ * @property {boolean=} optional
+ * @property {boolean=} orphan
+ * @property {string|number=} id
+ * @property {string|number=} issuerId
+ * @property {(string|number)[]=} chunks
+ * @property {(string|number)[]=} assets
+ * @property {boolean=} dependent
+ * @property {string=} issuer
+ * @property {string=} issuerName
+ * @property {StatsModuleIssuer[]=} issuerPath
+ * @property {boolean=} failed
+ * @property {number=} errors
+ * @property {number=} warnings
+ * @property {StatsProfile=} profile
+ * @property {StatsModuleReason[]=} reasons
+ * @property {(boolean | string[])=} usedExports
+ * @property {string[]=} providedExports
+ * @property {string[]=} optimizationBailout
+ * @property {number=} depth
+ * @property {StatsModule[]=} modules
+ * @property {number=} filteredModules
+ * @property {ReturnType<Source["source"]>=} source
+ */
 
+/** @typedef {KnownStatsProfile & Record<string, any>} StatsProfile */
+/**
+ * @typedef {Object} KnownStatsProfile
+ * @property {number} total
+ * @property {number} resolving
+ * @property {number} restoring
+ * @property {number} building
+ * @property {number} integration
+ * @property {number} storing
+ * @property {number} additionalResolving
+ * @property {number} additionalIntegration
+ * @property {number} factory
+ * @property {number} dependencies
+ */
 
-/** @template T @typedef {function(): T} FunctionReturning */
+/** @typedef {KnownStatsModuleIssuer & Record<string, any>} StatsModuleIssuer */
+/**
+ * @typedef {Object} KnownStatsModuleIssuer
+ * @property {string=} identifier
+ * @property {string=} name
+ * @property {(string|number)=} id
+ * @property {StatsProfile=} profile
+ */
 
+/** @typedef {KnownStatsModuleReason & Record<string, any>} StatsModuleReason */
 /**
- * @template T
- * @param {FunctionReturning<T>} fn memorized function
- * @returns {FunctionReturning<T>} new function
+ * @typedef {Object} KnownStatsModuleReason
+ * @property {string=} moduleIdentifier
+ * @property {string=} module
+ * @property {string=} moduleName
+ * @property {string=} resolvedModuleIdentifier
+ * @property {string=} resolvedModule
+ * @property {string=} type
+ * @property {boolean} active
+ * @property {string=} explanation
+ * @property {string=} userRequest
+ * @property {string=} loc
+ * @property {(string|number)=} moduleId
+ * @property {(string|number)=} resolvedModuleId
  */
-const memoize = fn => {
-	let cache = false;
-	/** @type {T} */
-	let result = undefined;
-	return () => {
-		if (cache) {
-			return result;
-		} else {
-			result = fn();
-			cache = true;
-			// Allow to clean up memory for fn
-			// and all dependent resources
-			fn = undefined;
-			return result;
-		}
-	};
-};
 
-module.exports = memoize;
+/** @typedef {KnownStatsChunk & Record<string, any>} StatsChunk */
+/**
+ * @typedef {Object} KnownStatsChunk
+ * @property {boolean} rendered
+ * @property {boolean} initial
+ * @property {boolean} entry
+ * @property {boolean} recorded
+ * @property {string=} reason
+ * @property {number} size
+ * @property {Record<string, number>=} sizes
+ * @property {string[]=} names
+ * @property {string[]=} idHints
+ * @property {string[]=} runtime
+ * @property {string[]=} files
+ * @property {string[]=} auxiliaryFiles
+ * @property {string} hash
+ * @property {Record<string, (string|number)[]>=} childrenByOrder
+ * @property {(string|number)=} id
+ * @property {(string|number)[]=} siblings
+ * @property {(string|number)[]=} parents
+ * @property {(string|number)[]=} children
+ * @property {StatsModule[]=} modules
+ * @property {number=} filteredModules
+ * @property {StatsChunkOrigin[]=} origins
+ */
 
+/** @typedef {KnownStatsChunkOrigin & Record<string, any>} StatsChunkOrigin */
+/**
+ * @typedef {Object} KnownStatsChunkOrigin
+ * @property {string=} module
+ * @property {string=} moduleIdentifier
+ * @property {string=} moduleName
+ * @property {string=} loc
+ * @property {string=} request
+ * @property {(string|number)=} moduleId
+ */
 
-/***/ }),
+/** @typedef {KnownStatsModuleTraceItem & Record<string, any>} StatsModuleTraceItem */
+/**
+ * @typedef {Object} KnownStatsModuleTraceItem
+ * @property {string=} originIdentifier
+ * @property {string=} originName
+ * @property {string=} moduleIdentifier
+ * @property {string=} moduleName
+ * @property {StatsModuleTraceDependency[]=} dependencies
+ * @property {(string|number)=} originId
+ * @property {(string|number)=} moduleId
+ */
 
-/***/ 70002:
-/***/ (function(module) {
+/** @typedef {KnownStatsModuleTraceDependency & Record<string, any>} StatsModuleTraceDependency */
+/**
+ * @typedef {Object} KnownStatsModuleTraceDependency
+ * @property {string=} loc
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/** @typedef {KnownStatsError & Record<string, any>} StatsError */
+/**
+ * @typedef {Object} KnownStatsError
+ * @property {string} message
+ * @property {string=} chunkName
+ * @property {boolean=} chunkEntry
+ * @property {boolean=} chunkInitial
+ * @property {string=} file
+ * @property {string=} moduleIdentifier
+ * @property {string=} moduleName
+ * @property {string=} loc
+ * @property {string|number=} chunkId
+ * @property {string|number=} moduleId
+ * @property {StatsModuleTraceItem[]=} moduleTrace
+ * @property {any=} details
+ * @property {string=} stack
+ */
 
+/** @typedef {Asset & { type: string, related: PreprocessedAsset[] }} PreprocessedAsset */
 
+/**
+ * @template T
+ * @template O
+ * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
+ */
 
-const SAFE_LIMIT = 0x80000000;
-const SAFE_PART = SAFE_LIMIT - 1;
-const COUNT = 4;
-const arr = [0, 0, 0, 0, 0];
-const primes = [3, 7, 17, 19];
+/**
+ * @typedef {Object} SimpleExtractors
+ * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
+ * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
+ * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
+ * @property {ExtractorsByOption<{ name: string, chunkGroup: ChunkGroup }, StatsChunkGroup>} chunkGroup
+ * @property {ExtractorsByOption<Module, StatsModule>} module
+ * @property {ExtractorsByOption<Module, StatsModule>} module$visible
+ * @property {ExtractorsByOption<Module, StatsModuleIssuer>} moduleIssuer
+ * @property {ExtractorsByOption<ModuleProfile, StatsProfile>} profile
+ * @property {ExtractorsByOption<ModuleGraphConnection, StatsModuleReason>} moduleReason
+ * @property {ExtractorsByOption<Chunk, StatsChunk>} chunk
+ * @property {ExtractorsByOption<OriginRecord, StatsChunkOrigin>} chunkOrigin
+ * @property {ExtractorsByOption<WebpackError, StatsError>} error
+ * @property {ExtractorsByOption<WebpackError, StatsError>} warning
+ * @property {ExtractorsByOption<{ origin: Module, module: Module }, StatsModuleTraceItem>} moduleTraceItem
+ * @property {ExtractorsByOption<Dependency, StatsModuleTraceDependency>} moduleTraceDependency
+ */
 
-module.exports = (str, range) => {
-	arr.fill(0);
-	for (let i = 0; i < str.length; i++) {
-		const c = str.charCodeAt(i);
-		for (let j = 0; j < COUNT; j++) {
-			const p = (j + COUNT - 1) % COUNT;
-			arr[j] = (arr[j] + c * primes[j] + arr[p]) & SAFE_PART;
-		}
-		for (let j = 0; j < COUNT; j++) {
-			const q = arr[j] % COUNT;
-			arr[j] = arr[j] ^ (arr[q] >> 1);
-		}
-	}
-	if (range <= SAFE_PART) {
-		let sum = 0;
-		for (let j = 0; j < COUNT; j++) {
-			sum = (sum + arr[j]) % range;
-		}
-		return sum;
-	} else {
-		let sum1 = 0;
-		let sum2 = 0;
-		const rangeExt = Math.floor(range / SAFE_LIMIT);
-		for (let j = 0; j < COUNT; j += 2) {
-			sum1 = (sum1 + arr[j]) & SAFE_PART;
-		}
-		for (let j = 1; j < COUNT; j += 2) {
-			sum2 = (sum2 + arr[j]) % rangeExt;
+/**
+ * @template T
+ * @template I
+ * @param {Iterable<T>} items items to select from
+ * @param {function(T): Iterable<I>} selector selector function to select values from item
+ * @returns {I[]} array of values
+ */
+const uniqueArray = (items, selector) => {
+	/** @type {Set<I>} */
+	const set = new Set();
+	for (const item of items) {
+		for (const i of selector(item)) {
+			set.add(i);
 		}
-		return (sum2 * SAFE_LIMIT + sum1) % range;
 	}
+	return Array.from(set);
 };
 
-
-/***/ }),
-
-/***/ 42791:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
 /**
  * @template T
- * @template {Error} E
- * @param {Iterable<T>} items initial items
- * @param {number} concurrency number of items running in parallel
- * @param {function(T, function(T): void, function(E=): void): void} processor worker which pushes more items
- * @param {function(E=): void} callback all items processed
- * @returns {void}
+ * @template I
+ * @param {Iterable<T>} items items to select from
+ * @param {function(T): Iterable<I>} selector selector function to select values from item
+ * @param {Comparator<I>} comparator comparator function
+ * @returns {I[]} array of values
  */
-const processAsyncTree = (items, concurrency, processor, callback) => {
-	const queue = Array.from(items);
-	if (queue.length === 0) return callback();
-	let processing = 0;
-	let finished = false;
-	let processScheduled = true;
-
-	const push = item => {
-		queue.push(item);
-		if (!processScheduled && processing < concurrency) {
-			processScheduled = true;
-			process.nextTick(processQueue);
-		}
-	};
-
-	const processorCallback = err => {
-		processing--;
-		if (err && !finished) {
-			finished = true;
-			callback(err);
-			return;
-		}
-		if (!processScheduled) {
-			processScheduled = true;
-			process.nextTick(processQueue);
-		}
-	};
-
-	const processQueue = () => {
-		if (finished) return;
-		while (processing < concurrency && queue.length > 0) {
-			processing++;
-			const item = queue.pop();
-			processor(item, push, processorCallback);
-		}
-		processScheduled = false;
-		if (queue.length === 0 && processing === 0 && !finished) {
-			finished = true;
-			callback();
-		}
-	};
-
-	processQueue();
+const uniqueOrderedArray = (items, selector, comparator) => {
+	return uniqueArray(items, selector).sort(comparator);
 };
 
-module.exports = processAsyncTree;
-
-
-/***/ }),
-
-/***/ 54190:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+/** @template T @template R @typedef {{ [P in keyof T]: R }} MappedValues<T, R> */
 
+/**
+ * @template T
+ * @template R
+ * @param {T} obj object to be mapped
+ * @param {function(T[keyof T], keyof T): R} fn mapping function
+ * @returns {MappedValues<T, R>} mapped object
+ */
+const mapObject = (obj, fn) => {
+	const newObj = Object.create(null);
+	for (const key of Object.keys(obj)) {
+		newObj[key] = fn(obj[key], /** @type {keyof T} */ (key));
+	}
+	return newObj;
+};
 
-const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
-const RESERVED_IDENTIFIER = new Set([
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"export",
-	"extends",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"import",
-	"in",
-	"instanceof",
-	"new",
-	"return",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"while",
-	"with",
-	"enum",
-	// strict mode
-	"implements",
-	"interface",
-	"let",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"static",
-	"yield",
-	"yield",
-	// module code
-	"await",
-	// skip future reserved keywords defined under ES1 till ES3
-	// additional
-	"null",
-	"true",
-	"false"
-]);
+/**
+ * @param {Compilation} compilation the compilation
+ * @param {function(Compilation, string): any[]} getItems get items
+ * @returns {number} total number
+ */
+const countWithChildren = (compilation, getItems) => {
+	let count = getItems(compilation, "").length;
+	for (const child of compilation.children) {
+		count += countWithChildren(child, (c, type) =>
+			getItems(c, `.children[].compilation${type}`)
+		);
+	}
+	return count;
+};
 
-const propertyAccess = (properties, start = 0) => {
-	let str = "";
-	for (let i = start; i < properties.length; i++) {
-		const p = properties[i];
-		if (`${+p}` === p) {
-			str += `[${p}]`;
-		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
-			str += `.${p}`;
+/** @type {ExtractorsByOption<WebpackError | string, StatsError>} */
+const EXTRACT_ERROR = {
+	_: (object, error, context, { requestShortener }) => {
+		// TODO webpack 6 disallow strings in the errors/warnings list
+		if (typeof error === "string") {
+			object.message = error;
 		} else {
-			str += `[${JSON.stringify(p)}]`;
+			if (error.chunk) {
+				object.chunkName = error.chunk.name;
+				object.chunkEntry = error.chunk.hasRuntime();
+				object.chunkInitial = error.chunk.canBeInitial();
+			}
+			if (error.file) {
+				object.file = error.file;
+			}
+			if (error.module) {
+				object.moduleIdentifier = error.module.identifier();
+				object.moduleName = error.module.readableIdentifier(requestShortener);
+			}
+			if (error.loc) {
+				object.loc = formatLocation(error.loc);
+			}
+			object.message = error.message;
+		}
+	},
+	ids: (object, error, { compilation: { chunkGraph } }) => {
+		if (typeof error !== "string") {
+			if (error.chunk) {
+				object.chunkId = error.chunk.id;
+			}
+			if (error.module) {
+				object.moduleId = chunkGraph.getModuleId(error.module);
+			}
+		}
+	},
+	moduleTrace: (object, error, context, options, factory) => {
+		if (typeof error !== "string" && error.module) {
+			const {
+				type,
+				compilation: { moduleGraph }
+			} = context;
+			/** @type {Set<Module>} */
+			const visitedModules = new Set();
+			const moduleTrace = [];
+			let current = error.module;
+			while (current) {
+				if (visitedModules.has(current)) break; // circular (technically impossible, but how knows)
+				visitedModules.add(current);
+				const origin = moduleGraph.getIssuer(current);
+				if (!origin) break;
+				moduleTrace.push({ origin, module: current });
+				current = origin;
+			}
+			object.moduleTrace = factory.create(
+				`${type}.moduleTrace`,
+				moduleTrace,
+				context
+			);
+		}
+	},
+	errorDetails: (
+		object,
+		error,
+		{ type, compilation, cachedGetErrors, cachedGetWarnings },
+		{ errorDetails }
+	) => {
+		if (
+			typeof error !== "string" &&
+			(errorDetails === true ||
+				(type.endsWith(".error") && cachedGetErrors(compilation).length < 3))
+		) {
+			object.details = error.details;
+		}
+	},
+	errorStack: (object, error) => {
+		if (typeof error !== "string") {
+			object.stack = error.stack;
 		}
 	}
-	return str;
 };
 
-module.exports = propertyAccess;
-
-
-/***/ }),
-
-/***/ 26611:
-/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { register } = __webpack_require__(8282);
-
-const Position = /** @type {TODO} */ (__webpack_require__(31988).Position);
-const SourceLocation = (__webpack_require__(31988).SourceLocation);
-const ValidationError = (__webpack_require__(54983)/* ["default"] */ .Z);
-const {
-	CachedSource,
-	ConcatSource,
-	OriginalSource,
-	PrefixSource,
-	RawSource,
-	ReplaceSource,
-	SourceMapSource
-} = __webpack_require__(51255);
+/** @type {SimpleExtractors} */
+const SIMPLE_EXTRACTORS = {
+	compilation: {
+		_: (object, compilation, context, options) => {
+			if (!context.makePathsRelative) {
+				context.makePathsRelative = makePathsRelative.bindContextCache(
+					compilation.compiler.context,
+					compilation.compiler.root
+				);
+			}
+			if (!context.cachedGetErrors) {
+				const map = new WeakMap();
+				context.cachedGetErrors = compilation => {
+					return (
+						map.get(compilation) ||
+						(errors => (map.set(compilation, errors), errors))(
+							compilation.getErrors()
+						)
+					);
+				};
+			}
+			if (!context.cachedGetWarnings) {
+				const map = new WeakMap();
+				context.cachedGetWarnings = compilation => {
+					return (
+						map.get(compilation) ||
+						(warnings => (map.set(compilation, warnings), warnings))(
+							compilation.getWarnings()
+						)
+					);
+				};
+			}
+			if (compilation.name) {
+				object.name = compilation.name;
+			}
+			if (compilation.needAdditionalPass) {
+				object.needAdditionalPass = true;
+			}
 
-/** @typedef {import("acorn").Position} Position */
-/** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
-/** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
+			const { logging, loggingDebug, loggingTrace } = options;
+			if (logging || (loggingDebug && loggingDebug.length > 0)) {
+				const util = __webpack_require__(73837);
+				object.logging = {};
+				let acceptedTypes;
+				let collapsedGroups = false;
+				switch (logging) {
+					default:
+						acceptedTypes = new Set();
+						break;
+					case "error":
+						acceptedTypes = new Set([LogType.error]);
+						break;
+					case "warn":
+						acceptedTypes = new Set([LogType.error, LogType.warn]);
+						break;
+					case "info":
+						acceptedTypes = new Set([
+							LogType.error,
+							LogType.warn,
+							LogType.info
+						]);
+						break;
+					case "log":
+						acceptedTypes = new Set([
+							LogType.error,
+							LogType.warn,
+							LogType.info,
+							LogType.log,
+							LogType.group,
+							LogType.groupEnd,
+							LogType.groupCollapsed,
+							LogType.clear
+						]);
+						break;
+					case "verbose":
+						acceptedTypes = new Set([
+							LogType.error,
+							LogType.warn,
+							LogType.info,
+							LogType.log,
+							LogType.group,
+							LogType.groupEnd,
+							LogType.groupCollapsed,
+							LogType.profile,
+							LogType.profileEnd,
+							LogType.time,
+							LogType.status,
+							LogType.clear
+						]);
+						collapsedGroups = true;
+						break;
+				}
+				const cachedMakePathsRelative = makePathsRelative.bindContextCache(
+					options.context,
+					compilation.compiler.root
+				);
+				let depthInCollapsedGroup = 0;
+				for (const [origin, logEntries] of compilation.logging) {
+					const debugMode = loggingDebug.some(fn => fn(origin));
+					if (logging === false && !debugMode) continue;
+					/** @type {KnownStatsLoggingEntry[]} */
+					const groupStack = [];
+					/** @type {KnownStatsLoggingEntry[]} */
+					const rootList = [];
+					let currentList = rootList;
+					let processedLogEntries = 0;
+					for (const entry of logEntries) {
+						let type = entry.type;
+						if (!debugMode && !acceptedTypes.has(type)) continue;
 
-/** @typedef {ObjectSerializerContext & { writeLazy?: (any) => void }} WebpackObjectSerializerContext */
+						// Expand groups in verbose and debug modes
+						if (
+							type === LogType.groupCollapsed &&
+							(debugMode || collapsedGroups)
+						)
+							type = LogType.group;
 
-const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
+						if (depthInCollapsedGroup === 0) {
+							processedLogEntries++;
+						}
 
-register(
-	CachedSource,
-	CURRENT_MODULE,
-	"webpack-sources/CachedSource",
-	new (class CachedSourceSerializer {
-		/**
-		 * @param {CachedSource} source the cached source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write, writeLazy }) {
-			if (writeLazy) {
-				writeLazy(source.originalLazy());
-			} else {
-				write(source.original());
+						if (type === LogType.groupEnd) {
+							groupStack.pop();
+							if (groupStack.length > 0) {
+								currentList = groupStack[groupStack.length - 1].children;
+							} else {
+								currentList = rootList;
+							}
+							if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
+							continue;
+						}
+						let message = undefined;
+						if (entry.type === LogType.time) {
+							message = `${entry.args[0]}: ${
+								entry.args[1] * 1000 + entry.args[2] / 1000000
+							} ms`;
+						} else if (entry.args && entry.args.length > 0) {
+							message = util.format(entry.args[0], ...entry.args.slice(1));
+						}
+						/** @type {KnownStatsLoggingEntry} */
+						const newEntry = {
+							...entry,
+							type,
+							message,
+							trace: loggingTrace ? entry.trace : undefined,
+							children:
+								type === LogType.group || type === LogType.groupCollapsed
+									? []
+									: undefined
+						};
+						currentList.push(newEntry);
+						if (newEntry.children) {
+							groupStack.push(newEntry);
+							currentList = newEntry.children;
+							if (depthInCollapsedGroup > 0) {
+								depthInCollapsedGroup++;
+							} else if (type === LogType.groupCollapsed) {
+								depthInCollapsedGroup = 1;
+							}
+						}
+					}
+					let name = cachedMakePathsRelative(origin).replace(/\|/g, " ");
+					if (name in object.logging) {
+						let i = 1;
+						while (`${name}#${i}` in object.logging) {
+							i++;
+						}
+						name = `${name}#${i}`;
+					}
+					object.logging[name] = {
+						entries: rootList,
+						filteredEntries: logEntries.length - processedLogEntries,
+						debug: debugMode
+					};
+				}
+			}
+		},
+		hash: (object, compilation) => {
+			object.hash = compilation.hash;
+		},
+		version: object => {
+			object.version = (__webpack_require__(32702)/* .version */ .i8);
+		},
+		env: (object, compilation, context, { _env }) => {
+			object.env = _env;
+		},
+		timings: (object, compilation) => {
+			object.time = compilation.endTime - compilation.startTime;
+		},
+		builtAt: (object, compilation) => {
+			object.builtAt = compilation.endTime;
+		},
+		publicPath: (object, compilation) => {
+			object.publicPath = compilation.getPath(
+				compilation.outputOptions.publicPath
+			);
+		},
+		outputPath: (object, compilation) => {
+			object.outputPath = compilation.outputOptions.path;
+		},
+		assets: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			/** @type {Map<string, Chunk[]>} */
+			const compilationFileToChunks = new Map();
+			/** @type {Map<string, Chunk[]>} */
+			const compilationAuxiliaryFileToChunks = new Map();
+			for (const chunk of compilation.chunks) {
+				for (const file of chunk.files) {
+					let array = compilationFileToChunks.get(file);
+					if (array === undefined) {
+						array = [];
+						compilationFileToChunks.set(file, array);
+					}
+					array.push(chunk);
+				}
+				for (const file of chunk.auxiliaryFiles) {
+					let array = compilationAuxiliaryFileToChunks.get(file);
+					if (array === undefined) {
+						array = [];
+						compilationAuxiliaryFileToChunks.set(file, array);
+					}
+					array.push(chunk);
+				}
+			}
+			/** @type {Map<string, PreprocessedAsset>} */
+			const assetMap = new Map();
+			/** @type {Set<PreprocessedAsset>} */
+			const assets = new Set();
+			for (const asset of compilation.getAssets()) {
+				/** @type {PreprocessedAsset} */
+				const item = {
+					...asset,
+					type: "asset",
+					related: undefined
+				};
+				assets.add(item);
+				assetMap.set(asset.name, item);
+			}
+			for (const item of assetMap.values()) {
+				const related = item.info.related;
+				if (!related) continue;
+				for (const type of Object.keys(related)) {
+					const relatedEntry = related[type];
+					const deps = Array.isArray(relatedEntry)
+						? relatedEntry
+						: [relatedEntry];
+					for (const dep of deps) {
+						const depItem = assetMap.get(dep);
+						if (!depItem) continue;
+						assets.delete(depItem);
+						depItem.type = type;
+						item.related = item.related || [];
+						item.related.push(depItem);
+					}
+				}
 			}
-			write(source.getCachedData());
-		}
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {CachedSource} cached source
-		 */
-		deserialize({ read }) {
-			const source = read();
-			const cachedData = read();
-			return new CachedSource(source, cachedData);
-		}
-	})()
-);
+			object.assetsByChunkName = {};
+			for (const [file, chunks] of compilationFileToChunks) {
+				for (const chunk of chunks) {
+					const name = chunk.name;
+					if (!name) continue;
+					if (
+						!Object.prototype.hasOwnProperty.call(
+							object.assetsByChunkName,
+							name
+						)
+					) {
+						object.assetsByChunkName[name] = [];
+					}
+					object.assetsByChunkName[name].push(file);
+				}
+			}
 
-register(
-	RawSource,
-	CURRENT_MODULE,
-	"webpack-sources/RawSource",
-	new (class RawSourceSerializer {
-		/**
-		 * @param {RawSource} source the raw source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.buffer());
-			write(!source.isBuffer());
+			const groupedAssets = factory.create(
+				`${type}.assets`,
+				Array.from(assets),
+				{
+					...context,
+					compilationFileToChunks,
+					compilationAuxiliaryFileToChunks
+				}
+			);
+			const limited = spaceLimited(groupedAssets, options.assetsSpace);
+			object.assets = limited.children;
+			object.filteredAssets = limited.filteredChildren;
+		},
+		chunks: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			object.chunks = factory.create(
+				`${type}.chunks`,
+				Array.from(compilation.chunks),
+				context
+			);
+		},
+		modules: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			const array = Array.from(compilation.modules);
+			const groupedModules = factory.create(`${type}.modules`, array, context);
+			const limited = spaceLimited(groupedModules, options.modulesSpace);
+			object.modules = limited.children;
+			object.filteredModules = limited.filteredChildren;
+		},
+		entrypoints: (
+			object,
+			compilation,
+			context,
+			{ entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren },
+			factory
+		) => {
+			const { type } = context;
+			const array = Array.from(compilation.entrypoints, ([key, value]) => ({
+				name: key,
+				chunkGroup: value
+			}));
+			if (entrypoints === "auto" && !chunkGroups) {
+				if (array.length > 5) return;
+				if (
+					!chunkGroupChildren &&
+					array.every(({ chunkGroup }) => {
+						if (chunkGroup.chunks.length !== 1) return false;
+						const chunk = chunkGroup.chunks[0];
+						return (
+							chunk.files.size === 1 &&
+							(!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0)
+						);
+					})
+				) {
+					return;
+				}
+			}
+			object.entrypoints = factory.create(
+				`${type}.entrypoints`,
+				array,
+				context
+			);
+		},
+		chunkGroups: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			const array = Array.from(
+				compilation.namedChunkGroups,
+				([key, value]) => ({
+					name: key,
+					chunkGroup: value
+				})
+			);
+			object.namedChunkGroups = factory.create(
+				`${type}.namedChunkGroups`,
+				array,
+				context
+			);
+		},
+		errors: (object, compilation, context, options, factory) => {
+			const { type, cachedGetErrors } = context;
+			object.errors = factory.create(
+				`${type}.errors`,
+				cachedGetErrors(compilation),
+				context
+			);
+		},
+		errorsCount: (object, compilation, { cachedGetErrors }) => {
+			object.errorsCount = countWithChildren(compilation, c =>
+				cachedGetErrors(c)
+			);
+		},
+		warnings: (object, compilation, context, options, factory) => {
+			const { type, cachedGetWarnings } = context;
+			object.warnings = factory.create(
+				`${type}.warnings`,
+				cachedGetWarnings(compilation),
+				context
+			);
+		},
+		warningsCount: (
+			object,
+			compilation,
+			context,
+			{ warningsFilter },
+			factory
+		) => {
+			const { type, cachedGetWarnings } = context;
+			object.warningsCount = countWithChildren(compilation, (c, childType) => {
+				if (!warningsFilter && warningsFilter.length === 0)
+					return cachedGetWarnings(c);
+				return factory
+					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
+					.filter(warning => {
+						const warningString = Object.keys(warning)
+							.map(key => `${warning[key]}`)
+							.join("\n");
+						return !warningsFilter.some(filter =>
+							filter(warning, warningString)
+						);
+					});
+			});
+		},
+		errorDetails: (
+			object,
+			compilation,
+			{ cachedGetErrors, cachedGetWarnings },
+			{ errorDetails, errors, warnings }
+		) => {
+			if (errorDetails === "auto") {
+				if (warnings) {
+					const warnings = cachedGetWarnings(compilation);
+					object.filteredWarningDetailsCount = warnings
+						.map(e => typeof e !== "string" && e.details)
+						.filter(Boolean).length;
+				}
+				if (errors) {
+					const errors = cachedGetErrors(compilation);
+					if (errors.length >= 3) {
+						object.filteredErrorDetailsCount = errors
+							.map(e => typeof e !== "string" && e.details)
+							.filter(Boolean).length;
+					}
+				}
+			}
+		},
+		children: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			object.children = factory.create(
+				`${type}.children`,
+				compilation.children,
+				context
+			);
 		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {RawSource} raw source
-		 */
-		deserialize({ read }) {
-			const source = read();
-			const convertToString = read();
-			return new RawSource(source, convertToString);
+	},
+	asset: {
+		_: (object, asset, context, options, factory) => {
+			const { compilation } = context;
+			object.type = asset.type;
+			object.name = asset.name;
+			object.size = asset.source.size();
+			object.emitted = compilation.emittedAssets.has(asset.name);
+			object.comparedForEmit = compilation.comparedForEmitAssets.has(
+				asset.name
+			);
+			const cached = !object.emitted && !object.comparedForEmit;
+			object.cached = cached;
+			object.info = asset.info;
+			if (!cached || options.cachedAssets) {
+				Object.assign(
+					object,
+					factory.create(`${context.type}$visible`, asset, context)
+				);
+			}
 		}
-	})()
-);
-
-register(
-	ConcatSource,
-	CURRENT_MODULE,
-	"webpack-sources/ConcatSource",
-	new (class ConcatSourceSerializer {
-		/**
-		 * @param {ConcatSource} source the concat source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.getChildren());
+	},
+	asset$visible: {
+		_: (
+			object,
+			asset,
+			{ compilation, compilationFileToChunks, compilationAuxiliaryFileToChunks }
+		) => {
+			const chunks = compilationFileToChunks.get(asset.name) || [];
+			const auxiliaryChunks =
+				compilationAuxiliaryFileToChunks.get(asset.name) || [];
+			object.chunkNames = uniqueOrderedArray(
+				chunks,
+				c => (c.name ? [c.name] : []),
+				compareIds
+			);
+			object.chunkIdHints = uniqueOrderedArray(
+				chunks,
+				c => Array.from(c.idNameHints),
+				compareIds
+			);
+			object.auxiliaryChunkNames = uniqueOrderedArray(
+				auxiliaryChunks,
+				c => (c.name ? [c.name] : []),
+				compareIds
+			);
+			object.auxiliaryChunkIdHints = uniqueOrderedArray(
+				auxiliaryChunks,
+				c => Array.from(c.idNameHints),
+				compareIds
+			);
+			object.filteredRelated = asset.related ? asset.related.length : undefined;
+		},
+		relatedAssets: (object, asset, context, options, factory) => {
+			const { type } = context;
+			object.related = factory.create(
+				`${type.slice(0, -8)}.related`,
+				asset.related,
+				context
+			);
+			object.filteredRelated = asset.related
+				? asset.related.length - object.related.length
+				: undefined;
+		},
+		ids: (
+			object,
+			asset,
+			{ compilationFileToChunks, compilationAuxiliaryFileToChunks }
+		) => {
+			const chunks = compilationFileToChunks.get(asset.name) || [];
+			const auxiliaryChunks =
+				compilationAuxiliaryFileToChunks.get(asset.name) || [];
+			object.chunks = uniqueOrderedArray(chunks, c => c.ids, compareIds);
+			object.auxiliaryChunks = uniqueOrderedArray(
+				auxiliaryChunks,
+				c => c.ids,
+				compareIds
+			);
+		},
+		performance: (object, asset) => {
+			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(asset.source);
 		}
+	},
+	chunkGroup: {
+		_: (
+			object,
+			{ name, chunkGroup },
+			{ compilation, compilation: { moduleGraph, chunkGraph } },
+			{ ids, chunkGroupAuxiliary, chunkGroupChildren, chunkGroupMaxAssets }
+		) => {
+			const children =
+				chunkGroupChildren &&
+				chunkGroup.getChildrenByOrders(moduleGraph, chunkGraph);
+			/**
+			 * @param {string} name Name
+			 * @returns {{ name: string, size: number }} Asset object
+			 */
+			const toAsset = name => {
+				const asset = compilation.getAsset(name);
+				return {
+					name,
+					size: asset ? asset.info.size : -1
+				};
+			};
+			/** @type {(total: number, asset: { size: number }) => number} */
+			const sizeReducer = (total, { size }) => total + size;
+			const assets = uniqueArray(chunkGroup.chunks, c => c.files).map(toAsset);
+			const auxiliaryAssets = uniqueOrderedArray(
+				chunkGroup.chunks,
+				c => c.auxiliaryFiles,
+				compareIds
+			).map(toAsset);
+			const assetsSize = assets.reduce(sizeReducer, 0);
+			const auxiliaryAssetsSize = auxiliaryAssets.reduce(sizeReducer, 0);
+			/** @type {KnownStatsChunkGroup} */
+			const statsChunkGroup = {
+				name,
+				chunks: ids ? chunkGroup.chunks.map(c => c.id) : undefined,
+				assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
+				filteredAssets:
+					assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
+				assetsSize,
+				auxiliaryAssets:
+					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+						? auxiliaryAssets
+						: undefined,
+				filteredAuxiliaryAssets:
+					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+						? 0
+						: auxiliaryAssets.length,
+				auxiliaryAssetsSize,
+				children: children
+					? mapObject(children, groups =>
+							groups.map(group => {
+								const assets = uniqueArray(group.chunks, c => c.files).map(
+									toAsset
+								);
+								const auxiliaryAssets = uniqueOrderedArray(
+									group.chunks,
+									c => c.auxiliaryFiles,
+									compareIds
+								).map(toAsset);
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {ConcatSource} concat source
-		 */
-		deserialize({ read }) {
-			const source = new ConcatSource();
-			source.addAllSkipOptimizing(read());
-			return source;
-		}
-	})()
-);
+								/** @type {KnownStatsChunkGroup} */
+								const childStatsChunkGroup = {
+									name: group.name,
+									chunks: ids ? group.chunks.map(c => c.id) : undefined,
+									assets:
+										assets.length <= chunkGroupMaxAssets ? assets : undefined,
+									filteredAssets:
+										assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
+									auxiliaryAssets:
+										chunkGroupAuxiliary &&
+										auxiliaryAssets.length <= chunkGroupMaxAssets
+											? auxiliaryAssets
+											: undefined,
+									filteredAuxiliaryAssets:
+										chunkGroupAuxiliary &&
+										auxiliaryAssets.length <= chunkGroupMaxAssets
+											? 0
+											: auxiliaryAssets.length
+								};
 
-register(
-	PrefixSource,
-	CURRENT_MODULE,
-	"webpack-sources/PrefixSource",
-	new (class PrefixSourceSerializer {
-		/**
-		 * @param {PrefixSource} source the prefix source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.getPrefix());
-			write(source.original());
+								return childStatsChunkGroup;
+							})
+					  )
+					: undefined,
+				childAssets: children
+					? mapObject(children, groups => {
+							/** @type {Set<string>} */
+							const set = new Set();
+							for (const group of groups) {
+								for (const chunk of group.chunks) {
+									for (const asset of chunk.files) {
+										set.add(asset);
+									}
+								}
+							}
+							return Array.from(set);
+					  })
+					: undefined
+			};
+			Object.assign(object, statsChunkGroup);
+		},
+		performance: (object, { chunkGroup }) => {
+			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(chunkGroup);
 		}
+	},
+	module: {
+		_: (object, module, context, options, factory) => {
+			const { compilation, type } = context;
+			const built = compilation.builtModules.has(module);
+			const codeGenerated = compilation.codeGeneratedModules.has(module);
+			const buildTimeExecuted =
+				compilation.buildTimeExecutedModules.has(module);
+			/** @type {{[x: string]: number}} */
+			const sizes = {};
+			for (const sourceType of module.getSourceTypes()) {
+				sizes[sourceType] = module.size(sourceType);
+			}
+			/** @type {KnownStatsModule} */
+			const statsModule = {
+				type: "module",
+				moduleType: module.type,
+				layer: module.layer,
+				size: module.size(),
+				sizes,
+				built,
+				codeGenerated,
+				buildTimeExecuted,
+				cached: !built && !codeGenerated
+			};
+			Object.assign(object, statsModule);
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {PrefixSource} prefix source
-		 */
-		deserialize({ read }) {
-			return new PrefixSource(read(), read());
+			if (built || codeGenerated || options.cachedModules) {
+				Object.assign(
+					object,
+					factory.create(`${type}$visible`, module, context)
+				);
+			}
 		}
-	})()
-);
-
-register(
-	ReplaceSource,
-	CURRENT_MODULE,
-	"webpack-sources/ReplaceSource",
-	new (class ReplaceSourceSerializer {
-		/**
-		 * @param {ReplaceSource} source the replace source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.original());
-			write(source.getName());
-			const replacements = source.getReplacements();
-			write(replacements.length);
-			for (const repl of replacements) {
-				write(repl.start);
-				write(repl.end);
+	},
+	module$visible: {
+		_: (object, module, context, { requestShortener }, factory) => {
+			const { compilation, type, rootModules } = context;
+			const { moduleGraph } = compilation;
+			/** @type {Module[]} */
+			const path = [];
+			const issuer = moduleGraph.getIssuer(module);
+			let current = issuer;
+			while (current) {
+				path.push(current);
+				current = moduleGraph.getIssuer(current);
 			}
-			for (const repl of replacements) {
-				write(repl.content);
-				write(repl.name);
+			path.reverse();
+			const profile = moduleGraph.getProfile(module);
+			const errors = module.getErrors();
+			const errorsCount = errors !== undefined ? countIterable(errors) : 0;
+			const warnings = module.getWarnings();
+			const warningsCount =
+				warnings !== undefined ? countIterable(warnings) : 0;
+			/** @type {{[x: string]: number}} */
+			const sizes = {};
+			for (const sourceType of module.getSourceTypes()) {
+				sizes[sourceType] = module.size(sourceType);
 			}
-		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {ReplaceSource} replace source
-		 */
-		deserialize({ read }) {
-			const source = new ReplaceSource(read(), read());
-			const len = read();
-			const startEndBuffer = [];
-			for (let i = 0; i < len; i++) {
-				startEndBuffer.push(read(), read());
+			/** @type {KnownStatsModule} */
+			const statsModule = {
+				identifier: module.identifier(),
+				name: module.readableIdentifier(requestShortener),
+				nameForCondition: module.nameForCondition(),
+				index: moduleGraph.getPreOrderIndex(module),
+				preOrderIndex: moduleGraph.getPreOrderIndex(module),
+				index2: moduleGraph.getPostOrderIndex(module),
+				postOrderIndex: moduleGraph.getPostOrderIndex(module),
+				cacheable: module.buildInfo.cacheable,
+				optional: module.isOptional(moduleGraph),
+				orphan:
+					!type.endsWith("module.modules[].module$visible") &&
+					compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
+				dependent: rootModules ? !rootModules.has(module) : undefined,
+				issuer: issuer && issuer.identifier(),
+				issuerName: issuer && issuer.readableIdentifier(requestShortener),
+				issuerPath:
+					issuer &&
+					factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
+				failed: errorsCount > 0,
+				errors: errorsCount,
+				warnings: warningsCount
+			};
+			Object.assign(object, statsModule);
+			if (profile) {
+				object.profile = factory.create(
+					`${type.slice(0, -8)}.profile`,
+					profile,
+					context
+				);
 			}
-			let j = 0;
-			for (let i = 0; i < len; i++) {
-				source.replace(
-					startEndBuffer[j++],
-					startEndBuffer[j++],
-					read(),
-					read()
+		},
+		ids: (object, module, { compilation: { chunkGraph, moduleGraph } }) => {
+			object.id = chunkGraph.getModuleId(module);
+			const issuer = moduleGraph.getIssuer(module);
+			object.issuerId = issuer && chunkGraph.getModuleId(issuer);
+			object.chunks = Array.from(
+				chunkGraph.getOrderedModuleChunksIterable(module, compareChunksById),
+				chunk => chunk.id
+			);
+		},
+		moduleAssets: (object, module) => {
+			object.assets = module.buildInfo.assets
+				? Object.keys(module.buildInfo.assets)
+				: [];
+		},
+		reasons: (object, module, context, options, factory) => {
+			const {
+				type,
+				compilation: { moduleGraph }
+			} = context;
+			const groupsReasons = factory.create(
+				`${type.slice(0, -8)}.reasons`,
+				Array.from(moduleGraph.getIncomingConnections(module)),
+				context
+			);
+			const limited = spaceLimited(groupsReasons, options.reasonsSpace);
+			object.reasons = limited.children;
+			object.filteredReasons = limited.filteredChildren;
+		},
+		usedExports: (
+			object,
+			module,
+			{ runtime, compilation: { moduleGraph } }
+		) => {
+			const usedExports = moduleGraph.getUsedExports(module, runtime);
+			if (usedExports === null) {
+				object.usedExports = null;
+			} else if (typeof usedExports === "boolean") {
+				object.usedExports = usedExports;
+			} else {
+				object.usedExports = Array.from(usedExports);
+			}
+		},
+		providedExports: (object, module, { compilation: { moduleGraph } }) => {
+			const providedExports = moduleGraph.getProvidedExports(module);
+			object.providedExports = Array.isArray(providedExports)
+				? providedExports
+				: null;
+		},
+		optimizationBailout: (
+			object,
+			module,
+			{ compilation: { moduleGraph } },
+			{ requestShortener }
+		) => {
+			object.optimizationBailout = moduleGraph
+				.getOptimizationBailout(module)
+				.map(item => {
+					if (typeof item === "function") return item(requestShortener);
+					return item;
+				});
+		},
+		depth: (object, module, { compilation: { moduleGraph } }) => {
+			object.depth = moduleGraph.getDepth(module);
+		},
+		nestedModules: (object, module, context, options, factory) => {
+			const { type } = context;
+			const innerModules = /** @type {Module & { modules?: Module[] }} */ (
+				module
+			).modules;
+			if (Array.isArray(innerModules)) {
+				const groupedModules = factory.create(
+					`${type.slice(0, -8)}.modules`,
+					innerModules,
+					context
+				);
+				const limited = spaceLimited(
+					groupedModules,
+					options.nestedModulesSpace
 				);
+				object.modules = limited.children;
+				object.filteredModules = limited.filteredChildren;
+			}
+		},
+		source: (object, module) => {
+			const originalSource = module.originalSource();
+			if (originalSource) {
+				object.source = originalSource.source();
 			}
-			return source;
-		}
-	})()
-);
-
-register(
-	OriginalSource,
-	CURRENT_MODULE,
-	"webpack-sources/OriginalSource",
-	new (class OriginalSourceSerializer {
-		/**
-		 * @param {OriginalSource} source the original source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.buffer());
-			write(source.getName());
-		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {OriginalSource} original source
-		 */
-		deserialize({ read }) {
-			const buffer = read();
-			const name = read();
-			return new OriginalSource(buffer, name);
-		}
-	})()
-);
-
-register(
-	SourceLocation,
-	CURRENT_MODULE,
-	"acorn/SourceLocation",
-	new (class SourceLocationSerializer {
-		/**
-		 * @param {SourceLocation} loc the location to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(loc, { write }) {
-			write(loc.start.line);
-			write(loc.start.column);
-			write(loc.end.line);
-			write(loc.end.column);
 		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {RealDependencyLocation} location
-		 */
-		deserialize({ read }) {
-			return {
-				start: {
-					line: read(),
-					column: read()
-				},
-				end: {
-					line: read(),
-					column: read()
-				}
+	},
+	profile: {
+		_: (object, profile) => {
+			/** @type {KnownStatsProfile} */
+			const statsProfile = {
+				total:
+					profile.factory +
+					profile.restoring +
+					profile.integration +
+					profile.building +
+					profile.storing,
+				resolving: profile.factory,
+				restoring: profile.restoring,
+				building: profile.building,
+				integration: profile.integration,
+				storing: profile.storing,
+				additionalResolving: profile.additionalFactories,
+				additionalIntegration: profile.additionalIntegration,
+				// TODO remove this in webpack 6
+				factory: profile.factory,
+				// TODO remove this in webpack 6
+				dependencies: profile.additionalFactories
 			};
+			Object.assign(object, statsProfile);
 		}
-	})()
-);
-
-register(
-	Position,
-	CURRENT_MODULE,
-	"acorn/Position",
-	new (class PositionSerializer {
-		/**
-		 * @param {Position} pos the position to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(pos, { write }) {
-			write(pos.line);
-			write(pos.column);
-		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {SourcePosition} position
-		 */
-		deserialize({ read }) {
-			return {
-				line: read(),
-				column: read()
+	},
+	moduleIssuer: {
+		_: (object, module, context, { requestShortener }, factory) => {
+			const { compilation, type } = context;
+			const { moduleGraph } = compilation;
+			const profile = moduleGraph.getProfile(module);
+			/** @type {KnownStatsModuleIssuer} */
+			const statsModuleIssuer = {
+				identifier: module.identifier(),
+				name: module.readableIdentifier(requestShortener)
 			};
+			Object.assign(object, statsModuleIssuer);
+			if (profile) {
+				object.profile = factory.create(`${type}.profile`, profile, context);
+			}
+		},
+		ids: (object, module, { compilation: { chunkGraph } }) => {
+			object.id = chunkGraph.getModuleId(module);
 		}
-	})()
-);
-
-register(
-	SourceMapSource,
-	CURRENT_MODULE,
-	"webpack-sources/SourceMapSource",
-	new (class SourceMapSourceSerializer {
-		/**
-		 * @param {SourceMapSource} source the source map source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.getArgsAsBuffers());
+	},
+	moduleReason: {
+		_: (object, reason, { runtime }, { requestShortener }) => {
+			const dep = reason.dependency;
+			const moduleDep =
+				dep && dep instanceof ModuleDependency ? dep : undefined;
+			/** @type {KnownStatsModuleReason} */
+			const statsModuleReason = {
+				moduleIdentifier: reason.originModule
+					? reason.originModule.identifier()
+					: null,
+				module: reason.originModule
+					? reason.originModule.readableIdentifier(requestShortener)
+					: null,
+				moduleName: reason.originModule
+					? reason.originModule.readableIdentifier(requestShortener)
+					: null,
+				resolvedModuleIdentifier: reason.resolvedOriginModule
+					? reason.resolvedOriginModule.identifier()
+					: null,
+				resolvedModule: reason.resolvedOriginModule
+					? reason.resolvedOriginModule.readableIdentifier(requestShortener)
+					: null,
+				type: reason.dependency ? reason.dependency.type : null,
+				active: reason.isActive(runtime),
+				explanation: reason.explanation,
+				userRequest: (moduleDep && moduleDep.userRequest) || null
+			};
+			Object.assign(object, statsModuleReason);
+			if (reason.dependency) {
+				const locInfo = formatLocation(reason.dependency.loc);
+				if (locInfo) {
+					object.loc = locInfo;
+				}
+			}
+		},
+		ids: (object, reason, { compilation: { chunkGraph } }) => {
+			object.moduleId = reason.originModule
+				? chunkGraph.getModuleId(reason.originModule)
+				: null;
+			object.resolvedModuleId = reason.resolvedOriginModule
+				? chunkGraph.getModuleId(reason.resolvedOriginModule)
+				: null;
 		}
+	},
+	chunk: {
+		_: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
+			const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {SourceMapSource} source source map source
-		 */
-		deserialize({ read }) {
-			// @ts-expect-error
-			return new SourceMapSource(...read());
-		}
-	})()
-);
+			/** @type {KnownStatsChunk} */
+			const statsChunk = {
+				rendered: chunk.rendered,
+				initial: chunk.canBeInitial(),
+				entry: chunk.hasRuntime(),
+				recorded: AggressiveSplittingPlugin.wasChunkRecorded(chunk),
+				reason: chunk.chunkReason,
+				size: chunkGraph.getChunkModulesSize(chunk),
+				sizes: chunkGraph.getChunkModulesSizes(chunk),
+				names: chunk.name ? [chunk.name] : [],
+				idHints: Array.from(chunk.idNameHints),
+				runtime:
+					chunk.runtime === undefined
+						? undefined
+						: typeof chunk.runtime === "string"
+						? [makePathsRelative(chunk.runtime)]
+						: Array.from(chunk.runtime.sort(), makePathsRelative),
+				files: Array.from(chunk.files),
+				auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(compareIds),
+				hash: chunk.renderedHash,
+				childrenByOrder: childIdByOrder
+			};
+			Object.assign(object, statsChunk);
+		},
+		ids: (object, chunk) => {
+			object.id = chunk.id;
+		},
+		chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
+			/** @type {Set<string|number>} */
+			const parents = new Set();
+			/** @type {Set<string|number>} */
+			const children = new Set();
+			/** @type {Set<string|number>} */
+			const siblings = new Set();
 
-register(
-	ValidationError,
-	CURRENT_MODULE,
-	"schema-utils/ValidationError",
-	new (class ValidationErrorSerializer {
-		// TODO error should be ValidationError, but this fails the type checks
-		/**
-		 * @param {TODO} error the source map source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(error, { write }) {
-			write(error.errors);
-			write(error.schema);
-			write({
-				name: error.headerName,
-				baseDataPath: error.baseDataPath,
-				postFormatter: error.postFormatter
+			for (const chunkGroup of chunk.groupsIterable) {
+				for (const parentGroup of chunkGroup.parentsIterable) {
+					for (const chunk of parentGroup.chunks) {
+						parents.add(chunk.id);
+					}
+				}
+				for (const childGroup of chunkGroup.childrenIterable) {
+					for (const chunk of childGroup.chunks) {
+						children.add(chunk.id);
+					}
+				}
+				for (const sibling of chunkGroup.chunks) {
+					if (sibling !== chunk) siblings.add(sibling.id);
+				}
+			}
+			object.siblings = Array.from(siblings).sort(compareIds);
+			object.parents = Array.from(parents).sort(compareIds);
+			object.children = Array.from(children).sort(compareIds);
+		},
+		chunkModules: (object, chunk, context, options, factory) => {
+			const {
+				type,
+				compilation: { chunkGraph }
+			} = context;
+			const array = chunkGraph.getChunkModules(chunk);
+			const groupedModules = factory.create(`${type}.modules`, array, {
+				...context,
+				runtime: chunk.runtime,
+				rootModules: new Set(chunkGraph.getChunkRootModules(chunk))
+			});
+			const limited = spaceLimited(groupedModules, options.chunkModulesSpace);
+			object.modules = limited.children;
+			object.filteredModules = limited.filteredChildren;
+		},
+		chunkOrigins: (object, chunk, context, options, factory) => {
+			const {
+				type,
+				compilation: { chunkGraph }
+			} = context;
+			/** @type {Set<string>} */
+			const originsKeySet = new Set();
+			const origins = [];
+			for (const g of chunk.groupsIterable) {
+				origins.push(...g.origins);
+			}
+			const array = origins.filter(origin => {
+				const key = [
+					origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
+					formatLocation(origin.loc),
+					origin.request
+				].join();
+				if (originsKeySet.has(key)) return false;
+				originsKeySet.add(key);
+				return true;
 			});
+			object.origins = factory.create(`${type}.origins`, array, context);
 		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {TODO} error
-		 */
-		deserialize({ read }) {
-			return new ValidationError(read(), read(), read());
+	},
+	chunkOrigin: {
+		_: (object, origin, context, { requestShortener }) => {
+			/** @type {KnownStatsChunkOrigin} */
+			const statsChunkOrigin = {
+				module: origin.module ? origin.module.identifier() : "",
+				moduleIdentifier: origin.module ? origin.module.identifier() : "",
+				moduleName: origin.module
+					? origin.module.readableIdentifier(requestShortener)
+					: "",
+				loc: formatLocation(origin.loc),
+				request: origin.request
+			};
+			Object.assign(object, statsChunkOrigin);
+		},
+		ids: (object, origin, { compilation: { chunkGraph } }) => {
+			object.moduleId = origin.module
+				? chunkGraph.getModuleId(origin.module)
+				: undefined;
 		}
-	})()
-);
-
-
-/***/ }),
-
-/***/ 17156:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const SortableSet = __webpack_require__(13098);
-
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
-
-/** @typedef {string | SortableSet<string> | undefined} RuntimeSpec */
-/** @typedef {RuntimeSpec | boolean} RuntimeCondition */
-
-/**
- * @param {Compilation} compilation the compilation
- * @param {string} name name of the entry
- * @param {EntryOptions=} options optionally already received entry options
- * @returns {RuntimeSpec} runtime
- */
-exports.getEntryRuntime = (compilation, name, options) => {
-	let dependOn;
-	let runtime;
-	if (options) {
-		({ dependOn, runtime } = options);
-	} else {
-		const entry = compilation.entries.get(name);
-		if (!entry) return name;
-		({ dependOn, runtime } = entry.options);
-	}
-	if (dependOn) {
-		/** @type {RuntimeSpec} */
-		let result = undefined;
-		const queue = new Set(dependOn);
-		for (const name of queue) {
-			const dep = compilation.entries.get(name);
-			if (!dep) continue;
-			const { dependOn, runtime } = dep.options;
-			if (dependOn) {
-				for (const name of dependOn) {
-					queue.add(name);
-				}
-			} else {
-				result = mergeRuntimeOwned(result, runtime || name);
-			}
+	},
+	error: EXTRACT_ERROR,
+	warning: EXTRACT_ERROR,
+	moduleTraceItem: {
+		_: (object, { origin, module }, context, { requestShortener }, factory) => {
+			const {
+				type,
+				compilation: { moduleGraph }
+			} = context;
+			object.originIdentifier = origin.identifier();
+			object.originName = origin.readableIdentifier(requestShortener);
+			object.moduleIdentifier = module.identifier();
+			object.moduleName = module.readableIdentifier(requestShortener);
+			const dependencies = Array.from(
+				moduleGraph.getIncomingConnections(module)
+			)
+				.filter(c => c.resolvedOriginModule === origin && c.dependency)
+				.map(c => c.dependency);
+			object.dependencies = factory.create(
+				`${type}.dependencies`,
+				Array.from(new Set(dependencies)),
+				context
+			);
+		},
+		ids: (object, { origin, module }, { compilation: { chunkGraph } }) => {
+			object.originId = chunkGraph.getModuleId(origin);
+			object.moduleId = chunkGraph.getModuleId(module);
+		}
+	},
+	moduleTraceDependency: {
+		_: (object, dependency) => {
+			object.loc = formatLocation(dependency.loc);
 		}
-		return result || name;
-	} else {
-		return runtime || name;
 	}
 };
 
-/**
- * @param {RuntimeSpec} runtime runtime
- * @param {function(string): void} fn functor
- * @param {boolean} deterministicOrder enforce a deterministic order
- * @returns {void}
- */
-exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
-	if (runtime === undefined) {
-		fn(undefined);
-	} else if (typeof runtime === "string") {
-		fn(runtime);
-	} else {
-		if (deterministicOrder) runtime.sort();
-		for (const r of runtime) {
-			fn(r);
+/** @type {Record<string, Record<string, (thing: any, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+const FILTER = {
+	"module.reasons": {
+		"!orphanModules": (reason, { compilation: { chunkGraph } }) => {
+			if (
+				reason.originModule &&
+				chunkGraph.getNumberOfModuleChunks(reason.originModule) === 0
+			) {
+				return false;
+			}
 		}
 	}
 };
 
-const getRuntimesKey = set => {
-	set.sort();
-	return Array.from(set).join("\n");
+/** @type {Record<string, Record<string, (thing: Object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+const FILTER_RESULTS = {
+	"compilation.warnings": {
+		warningsFilter: util.deprecate(
+			(warning, context, { warningsFilter }) => {
+				const warningString = Object.keys(warning)
+					.map(key => `${warning[key]}`)
+					.join("\n");
+				return !warningsFilter.some(filter => filter(warning, warningString));
+			},
+			"config.stats.warningsFilter is deprecated in favor of config.ignoreWarnings",
+			"DEP_WEBPACK_STATS_WARNINGS_FILTER"
+		)
+	}
 };
 
-/**
- * @param {RuntimeSpec} runtime runtime(s)
- * @returns {string} key of runtimes
- */
-const getRuntimeKey = runtime => {
-	if (runtime === undefined) return "*";
-	if (typeof runtime === "string") return runtime;
-	return runtime.getFromUnorderedCache(getRuntimesKey);
+/** @type {Record<string, (comparators: Function[], context: StatsFactoryContext) => void>} */
+const MODULES_SORTER = {
+	_: (comparators, { compilation: { moduleGraph } }) => {
+		comparators.push(
+			compareSelect(
+				/**
+				 * @param {Module} m module
+				 * @returns {number} depth
+				 */
+				m => moduleGraph.getDepth(m),
+				compareNumbers
+			),
+			compareSelect(
+				/**
+				 * @param {Module} m module
+				 * @returns {number} index
+				 */
+				m => moduleGraph.getPreOrderIndex(m),
+				compareNumbers
+			),
+			compareSelect(
+				/**
+				 * @param {Module} m module
+				 * @returns {string} identifier
+				 */
+				m => m.identifier(),
+				compareIds
+			)
+		);
+	}
 };
-exports.getRuntimeKey = getRuntimeKey;
 
-/**
- * @param {string} key key of runtimes
- * @returns {RuntimeSpec} runtime(s)
- */
-const keyToRuntime = key => {
-	if (key === "*") return undefined;
-	const items = key.split("\n");
-	if (items.length === 1) return items[0];
-	return new SortableSet(items);
+/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext) => void>>} */
+const SORTERS = {
+	"compilation.chunks": {
+		_: comparators => {
+			comparators.push(compareSelect(c => c.id, compareIds));
+		}
+	},
+	"compilation.modules": MODULES_SORTER,
+	"chunk.rootModules": MODULES_SORTER,
+	"chunk.modules": MODULES_SORTER,
+	"module.modules": MODULES_SORTER,
+	"module.reasons": {
+		_: (comparators, { compilation: { chunkGraph } }) => {
+			comparators.push(
+				compareSelect(x => x.originModule, compareModulesByIdentifier)
+			);
+			comparators.push(
+				compareSelect(x => x.resolvedOriginModule, compareModulesByIdentifier)
+			);
+			comparators.push(
+				compareSelect(
+					x => x.dependency,
+					concatComparators(
+						compareSelect(
+							/**
+							 * @param {Dependency} x dependency
+							 * @returns {DependencyLocation} location
+							 */
+							x => x.loc,
+							compareLocations
+						),
+						compareSelect(x => x.type, compareIds)
+					)
+				)
+			);
+		}
+	},
+	"chunk.origins": {
+		_: (comparators, { compilation: { chunkGraph } }) => {
+			comparators.push(
+				compareSelect(
+					origin =>
+						origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
+					compareIds
+				),
+				compareSelect(origin => formatLocation(origin.loc), compareIds),
+				compareSelect(origin => origin.request, compareIds)
+			);
+		}
+	}
 };
-exports.keyToRuntime = keyToRuntime;
 
-const getRuntimesString = set => {
-	set.sort();
-	return Array.from(set).join("+");
+const getItemSize = item => {
+	// Each item takes 1 line
+	// + the size of the children
+	// + 1 extra line when it has children and filteredChildren
+	return !item.children
+		? 1
+		: item.filteredChildren
+		? 2 + getTotalSize(item.children)
+		: 1 + getTotalSize(item.children);
 };
 
-/**
- * @param {RuntimeSpec} runtime runtime(s)
- * @returns {string} readable version
- */
-const runtimeToString = runtime => {
-	if (runtime === undefined) return "*";
-	if (typeof runtime === "string") return runtime;
-	return runtime.getFromUnorderedCache(getRuntimesString);
+const getTotalSize = children => {
+	let size = 0;
+	for (const child of children) {
+		size += getItemSize(child);
+	}
+	return size;
 };
-exports.runtimeToString = runtimeToString;
 
-/**
- * @param {RuntimeCondition} runtimeCondition runtime condition
- * @returns {string} readable version
- */
-exports.runtimeConditionToString = runtimeCondition => {
-	if (runtimeCondition === true) return "true";
-	if (runtimeCondition === false) return "false";
-	return runtimeToString(runtimeCondition);
+const getTotalItems = children => {
+	let count = 0;
+	for (const child of children) {
+		if (!child.children && !child.filteredChildren) {
+			count++;
+		} else {
+			if (child.children) count += getTotalItems(child.children);
+			if (child.filteredChildren) count += child.filteredChildren;
+		}
+	}
+	return count;
 };
 
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {boolean} true, when they are equal
- */
-const runtimeEqual = (a, b) => {
-	if (a === b) {
-		return true;
-	} else if (
-		a === undefined ||
-		b === undefined ||
-		typeof a === "string" ||
-		typeof b === "string"
-	) {
-		return false;
-	} else if (a.size !== b.size) {
-		return false;
-	} else {
-		a.sort();
-		b.sort();
-		const aIt = a[Symbol.iterator]();
-		const bIt = b[Symbol.iterator]();
-		for (;;) {
-			const aV = aIt.next();
-			if (aV.done) return true;
-			const bV = bIt.next();
-			if (aV.value !== bV.value) return false;
+const collapse = children => {
+	// After collapse each child must take exactly one line
+	const newChildren = [];
+	for (const child of children) {
+		if (child.children) {
+			let filteredChildren = child.filteredChildren || 0;
+			filteredChildren += getTotalItems(child.children);
+			newChildren.push({
+				...child,
+				children: undefined,
+				filteredChildren
+			});
+		} else {
+			newChildren.push(child);
 		}
 	}
+	return newChildren;
 };
-exports.runtimeEqual = runtimeEqual;
 
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {-1|0|1} compare
- */
-exports.compareRuntime = (a, b) => {
-	if (a === b) {
-		return 0;
-	} else if (a === undefined) {
-		return -1;
-	} else if (b === undefined) {
-		return 1;
-	} else {
-		const aKey = getRuntimeKey(a);
-		const bKey = getRuntimeKey(b);
-		if (aKey < bKey) return -1;
-		if (aKey > bKey) return 1;
-		return 0;
+const spaceLimited = (
+	itemsAndGroups,
+	max,
+	filteredChildrenLineReserved = false
+) => {
+	if (max < 1) {
+		return {
+			children: undefined,
+			filteredChildren: getTotalItems(itemsAndGroups)
+		};
 	}
-};
+	/** @type {any[] | undefined} */
+	let children = undefined;
+	/** @type {number | undefined} */
+	let filteredChildren = undefined;
+	// This are the groups, which take 1+ lines each
+	const groups = [];
+	// The sizes of the groups are stored in groupSizes
+	const groupSizes = [];
+	// This are the items, which take 1 line each
+	const items = [];
+	// The total of group sizes
+	let groupsSize = 0;
 
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} merged
- */
-const mergeRuntime = (a, b) => {
-	if (a === undefined) {
-		return b;
-	} else if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return a;
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			const set = new SortableSet();
-			set.add(a);
-			set.add(b);
-			return set;
-		} else if (b.has(a)) {
-			return b;
+	for (const itemOrGroup of itemsAndGroups) {
+		// is item
+		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
+			items.push(itemOrGroup);
 		} else {
-			const set = new SortableSet(b);
-			set.add(a);
-			return set;
+			groups.push(itemOrGroup);
+			const size = getItemSize(itemOrGroup);
+			groupSizes.push(size);
+			groupsSize += size;
 		}
+	}
+
+	if (groupsSize + items.length <= max) {
+		// The total size in the current state fits into the max
+		// keep all
+		children = groups.length > 0 ? groups.concat(items) : items;
+	} else if (groups.length === 0) {
+		// slice items to max
+		// inner space marks that lines for filteredChildren already reserved
+		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
+		filteredChildren = items.length - limit;
+		items.length = limit;
+		children = items;
 	} else {
-		if (typeof b === "string") {
-			if (a.has(b)) return a;
-			const set = new SortableSet(a);
-			set.add(b);
-			return set;
+		// limit is the size when all groups are collapsed
+		const limit =
+			groups.length +
+			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
+		if (limit < max) {
+			// calculate how much we are over the size limit
+			// this allows to approach the limit faster
+			let oversize;
+			// If each group would take 1 line the total would be below the maximum
+			// collapse some groups, keep items
+			while (
+				(oversize =
+					groupsSize +
+					items.length +
+					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
+					max) > 0
+			) {
+				// Find the maximum group and process only this one
+				const maxGroupSize = Math.max(...groupSizes);
+				if (maxGroupSize < items.length) {
+					filteredChildren = items.length;
+					items.length = 0;
+					continue;
+				}
+				for (let i = 0; i < groups.length; i++) {
+					if (groupSizes[i] === maxGroupSize) {
+						const group = groups[i];
+						// run this algorithm recursively and limit the size of the children to
+						// current size - oversize / number of groups
+						// So it should always end up being smaller
+						const headerSize = group.filteredChildren ? 2 : 1;
+						const limited = spaceLimited(
+							group.children,
+							maxGroupSize -
+								// we should use ceil to always feet in max
+								Math.ceil(oversize / groups.length) -
+								// we substitute size of group head
+								headerSize,
+							headerSize === 2
+						);
+						groups[i] = {
+							...group,
+							children: limited.children,
+							filteredChildren: limited.filteredChildren
+								? (group.filteredChildren || 0) + limited.filteredChildren
+								: group.filteredChildren
+						};
+						const newSize = getItemSize(groups[i]);
+						groupsSize -= maxGroupSize - newSize;
+						groupSizes[i] = newSize;
+						break;
+					}
+				}
+			}
+			children = groups.concat(items);
+		} else if (limit === max) {
+			// If we have only enough space to show one line per group and one line for the filtered items
+			// collapse all groups and items
+			children = collapse(groups);
+			filteredChildren = items.length;
 		} else {
-			const set = new SortableSet(a);
-			for (const item of b) set.add(item);
-			if (set.size === a.size) return a;
-			return set;
+			// If we have no space
+			// collapse complete group
+			filteredChildren = getTotalItems(itemsAndGroups);
+		}
+	}
+
+	return {
+		children,
+		filteredChildren
+	};
+};
+
+const assetGroup = (children, assets) => {
+	let size = 0;
+	for (const asset of children) {
+		size += asset.size;
+	}
+	return {
+		size
+	};
+};
+
+const moduleGroup = (children, modules) => {
+	let size = 0;
+	const sizes = {};
+	for (const module of children) {
+		size += module.size;
+		for (const key of Object.keys(module.sizes)) {
+			sizes[key] = (sizes[key] || 0) + module.sizes[key];
 		}
 	}
+	return {
+		size,
+		sizes
+	};
 };
-exports.mergeRuntime = mergeRuntime;
 
-/**
- * @param {RuntimeCondition} a first
- * @param {RuntimeCondition} b second
- * @param {RuntimeSpec} runtime full runtime
- * @returns {RuntimeCondition} result
- */
-exports.mergeRuntimeCondition = (a, b, runtime) => {
-	if (a === false) return b;
-	if (b === false) return a;
-	if (a === true || b === true) return true;
-	const merged = mergeRuntime(a, b);
-	if (merged === undefined) return undefined;
-	if (typeof merged === "string") {
-		if (typeof runtime === "string" && merged === runtime) return true;
-		return merged;
+const reasonGroup = (children, reasons) => {
+	let active = false;
+	for (const reason of children) {
+		active = active || reason.active;
 	}
-	if (typeof runtime === "string" || runtime === undefined) return merged;
-	if (merged.size === runtime.size) return true;
-	return merged;
+	return {
+		active
+	};
 };
 
-/**
- * @param {RuntimeSpec | true} a first
- * @param {RuntimeSpec | true} b second
- * @param {RuntimeSpec} runtime full runtime
- * @returns {RuntimeSpec | true} result
- */
-exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
-	if (a === true || b === true) return true;
-	const merged = mergeRuntime(a, b);
-	if (merged === undefined) return undefined;
-	if (typeof merged === "string") {
-		if (typeof runtime === "string" && merged === runtime) return true;
-		return merged;
+const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
+const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+
+/** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+const ASSETS_GROUPERS = {
+	_: (groupConfigs, context, options) => {
+		const groupByFlag = (name, exclude) => {
+			groupConfigs.push({
+				getKeys: asset => {
+					return asset[name] ? ["1"] : undefined;
+				},
+				getOptions: () => {
+					return {
+						groupChildren: !exclude,
+						force: exclude
+					};
+				},
+				createGroup: (key, children, assets) => {
+					return exclude
+						? {
+								type: "assets by status",
+								[name]: !!key,
+								filteredChildren: assets.length,
+								...assetGroup(children, assets)
+						  }
+						: {
+								type: "assets by status",
+								[name]: !!key,
+								children,
+								...assetGroup(children, assets)
+						  };
+				}
+			});
+		};
+		const {
+			groupAssetsByEmitStatus,
+			groupAssetsByPath,
+			groupAssetsByExtension
+		} = options;
+		if (groupAssetsByEmitStatus) {
+			groupByFlag("emitted");
+			groupByFlag("comparedForEmit");
+			groupByFlag("isOverSizeLimit");
+		}
+		if (groupAssetsByEmitStatus || !options.cachedAssets) {
+			groupByFlag("cached", !options.cachedAssets);
+		}
+		if (groupAssetsByPath || groupAssetsByExtension) {
+			groupConfigs.push({
+				getKeys: asset => {
+					const extensionMatch =
+						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
+					const extension = extensionMatch ? extensionMatch[1] : "";
+					const pathMatch =
+						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
+					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					const keys = [];
+					if (groupAssetsByPath) {
+						keys.push(".");
+						if (extension)
+							keys.push(
+								path.length
+									? `${path.join("/")}/*${extension}`
+									: `*${extension}`
+							);
+						while (path.length > 0) {
+							keys.push(path.join("/") + "/");
+							path.pop();
+						}
+					} else {
+						if (extension) keys.push(`*${extension}`);
+					}
+					return keys;
+				},
+				createGroup: (key, children, assets) => {
+					return {
+						type: groupAssetsByPath ? "assets by path" : "assets by extension",
+						name: key,
+						children,
+						...assetGroup(children, assets)
+					};
+				}
+			});
+		}
+	},
+	groupAssetsByInfo: (groupConfigs, context, options) => {
+		const groupByAssetInfoFlag = name => {
+			groupConfigs.push({
+				getKeys: asset => {
+					return asset.info && asset.info[name] ? ["1"] : undefined;
+				},
+				createGroup: (key, children, assets) => {
+					return {
+						type: "assets by info",
+						info: {
+							[name]: !!key
+						},
+						children,
+						...assetGroup(children, assets)
+					};
+				}
+			});
+		};
+		groupByAssetInfoFlag("immutable");
+		groupByAssetInfoFlag("development");
+		groupByAssetInfoFlag("hotModuleReplacement");
+	},
+	groupAssetsByChunk: (groupConfigs, context, options) => {
+		const groupByNames = name => {
+			groupConfigs.push({
+				getKeys: asset => {
+					return asset[name];
+				},
+				createGroup: (key, children, assets) => {
+					return {
+						type: "assets by chunk",
+						[name]: [key],
+						children,
+						...assetGroup(children, assets)
+					};
+				}
+			});
+		};
+		groupByNames("chunkNames");
+		groupByNames("auxiliaryChunkNames");
+		groupByNames("chunkIdHints");
+		groupByNames("auxiliaryChunkIdHints");
+	},
+	excludeAssets: (groupConfigs, context, { excludeAssets }) => {
+		groupConfigs.push({
+			getKeys: asset => {
+				const ident = asset.name;
+				const excluded = excludeAssets.some(fn => fn(ident, asset));
+				if (excluded) return ["excluded"];
+			},
+			getOptions: () => ({
+				groupChildren: false,
+				force: true
+			}),
+			createGroup: (key, children, assets) => ({
+				type: "hidden assets",
+				filteredChildren: assets.length,
+				...assetGroup(children, assets)
+			})
+		});
 	}
-	if (typeof runtime === "string" || runtime === undefined) return merged;
-	if (merged.size === runtime.size) return true;
-	return merged;
 };
 
-/**
- * @param {RuntimeSpec} a first (may be modified)
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} merged
- */
-const mergeRuntimeOwned = (a, b) => {
-	if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return a;
-	} else if (a === undefined) {
-		if (typeof b === "string") {
-			return b;
-		} else {
-			return new SortableSet(b);
+/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+const MODULES_GROUPERS = type => ({
+	_: (groupConfigs, context, options) => {
+		const groupByFlag = (name, type, exclude) => {
+			groupConfigs.push({
+				getKeys: module => {
+					return module[name] ? ["1"] : undefined;
+				},
+				getOptions: () => {
+					return {
+						groupChildren: !exclude,
+						force: exclude
+					};
+				},
+				createGroup: (key, children, modules) => {
+					return {
+						type,
+						[name]: !!key,
+						...(exclude ? { filteredChildren: modules.length } : { children }),
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		};
+		const {
+			groupModulesByCacheStatus,
+			groupModulesByLayer,
+			groupModulesByAttributes,
+			groupModulesByType,
+			groupModulesByPath,
+			groupModulesByExtension
+		} = options;
+		if (groupModulesByAttributes) {
+			groupByFlag("errors", "modules with errors");
+			groupByFlag("warnings", "modules with warnings");
+			groupByFlag("assets", "modules with assets");
+			groupByFlag("optional", "optional modules");
 		}
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			const set = new SortableSet();
-			set.add(a);
-			set.add(b);
-			return set;
-		} else {
-			const set = new SortableSet(b);
-			set.add(a);
-			return set;
+		if (groupModulesByCacheStatus) {
+			groupByFlag("cacheable", "cacheable modules");
+			groupByFlag("built", "built modules");
+			groupByFlag("codeGenerated", "code generated modules");
 		}
-	} else {
-		if (typeof b === "string") {
-			a.add(b);
-			return a;
-		} else {
-			for (const item of b) a.add(item);
-			return a;
+		if (groupModulesByCacheStatus || !options.cachedModules) {
+			groupByFlag("cached", "cached modules", !options.cachedModules);
 		}
-	}
-};
-exports.mergeRuntimeOwned = mergeRuntimeOwned;
-
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} merged
- */
-exports.intersectRuntime = (a, b) => {
-	if (a === undefined) {
-		return b;
-	} else if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return a;
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			return undefined;
-		} else if (b.has(a)) {
-			return a;
-		} else {
-			return undefined;
+		if (groupModulesByAttributes || !options.orphanModules) {
+			groupByFlag("orphan", "orphan modules", !options.orphanModules);
 		}
-	} else {
-		if (typeof b === "string") {
-			if (a.has(b)) return b;
-			return undefined;
-		} else {
-			const set = new SortableSet();
-			for (const item of b) {
-				if (a.has(item)) set.add(item);
-			}
-			if (set.size === 0) return undefined;
-			if (set.size === 1) for (const item of set) return item;
-			return set;
+		if (groupModulesByAttributes || !options.dependentModules) {
+			groupByFlag("dependent", "dependent modules", !options.dependentModules);
+		}
+		if (groupModulesByType || !options.runtimeModules) {
+			groupConfigs.push({
+				getKeys: module => {
+					if (!module.moduleType) return;
+					if (groupModulesByType) {
+						return [module.moduleType.split("/", 1)[0]];
+					} else if (module.moduleType === "runtime") {
+						return ["runtime"];
+					}
+				},
+				getOptions: key => {
+					const exclude = key === "runtime" && !options.runtimeModules;
+					return {
+						groupChildren: !exclude,
+						force: exclude
+					};
+				},
+				createGroup: (key, children, modules) => {
+					const exclude = key === "runtime" && !options.runtimeModules;
+					return {
+						type: `${key} modules`,
+						moduleType: key,
+						...(exclude ? { filteredChildren: modules.length } : { children }),
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		}
+		if (groupModulesByLayer) {
+			groupConfigs.push({
+				getKeys: module => {
+					return [module.layer];
+				},
+				createGroup: (key, children, modules) => {
+					return {
+						type: "modules by layer",
+						layer: key,
+						children,
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		}
+		if (groupModulesByPath || groupModulesByExtension) {
+			groupConfigs.push({
+				getKeys: module => {
+					if (!module.name) return;
+					const resource = parseResource(module.name.split("!").pop()).path;
+					const dataUrl = /^data:[^,;]+/.exec(resource);
+					if (dataUrl) return [dataUrl[0]];
+					const extensionMatch =
+						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
+					const extension = extensionMatch ? extensionMatch[1] : "";
+					const pathMatch =
+						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
+					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					const keys = [];
+					if (groupModulesByPath) {
+						if (extension)
+							keys.push(
+								path.length
+									? `${path.join("/")}/*${extension}`
+									: `*${extension}`
+							);
+						while (path.length > 0) {
+							keys.push(path.join("/") + "/");
+							path.pop();
+						}
+					} else {
+						if (extension) keys.push(`*${extension}`);
+					}
+					return keys;
+				},
+				createGroup: (key, children, modules) => {
+					const isDataUrl = key.startsWith("data:");
+					return {
+						type: isDataUrl
+							? "modules by mime type"
+							: groupModulesByPath
+							? "modules by path"
+							: "modules by extension",
+						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
+						children,
+						...moduleGroup(children, modules)
+					};
+				}
+			});
 		}
+	},
+	excludeModules: (groupConfigs, context, { excludeModules }) => {
+		groupConfigs.push({
+			getKeys: module => {
+				const name = module.name;
+				if (name) {
+					const excluded = excludeModules.some(fn => fn(name, module, type));
+					if (excluded) return ["1"];
+				}
+			},
+			getOptions: () => ({
+				groupChildren: false,
+				force: true
+			}),
+			createGroup: (key, children, modules) => ({
+				type: "hidden modules",
+				filteredChildren: children.length,
+				...moduleGroup(children, modules)
+			})
+		});
 	}
-};
+});
 
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} result
- */
-const subtractRuntime = (a, b) => {
-	if (a === undefined) {
-		return undefined;
-	} else if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return undefined;
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			return a;
-		} else if (b.has(a)) {
-			return undefined;
-		} else {
-			return a;
-		}
-	} else {
-		if (typeof b === "string") {
-			if (!a.has(b)) return a;
-			if (a.size === 2) {
-				for (const item of a) {
-					if (item !== b) return item;
+/** @type {Record<string, Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+const RESULT_GROUPERS = {
+	"compilation.assets": ASSETS_GROUPERS,
+	"asset.related": ASSETS_GROUPERS,
+	"compilation.modules": MODULES_GROUPERS("module"),
+	"chunk.modules": MODULES_GROUPERS("chunk"),
+	"chunk.rootModules": MODULES_GROUPERS("root-of-chunk"),
+	"module.modules": MODULES_GROUPERS("nested"),
+	"module.reasons": {
+		groupReasonsByOrigin: groupConfigs => {
+			groupConfigs.push({
+				getKeys: reason => {
+					return [reason.module];
+				},
+				createGroup: (key, children, reasons) => {
+					return {
+						type: "from origin",
+						module: key,
+						children,
+						...reasonGroup(children, reasons)
+					};
 				}
-			}
-			const set = new SortableSet(a);
-			set.delete(b);
-		} else {
-			const set = new SortableSet();
-			for (const item of a) {
-				if (!b.has(item)) set.add(item);
-			}
-			if (set.size === 0) return undefined;
-			if (set.size === 1) for (const item of set) return item;
-			return set;
+			});
 		}
 	}
 };
-exports.subtractRuntime = subtractRuntime;
 
-/**
- * @param {RuntimeCondition} a first
- * @param {RuntimeCondition} b second
- * @param {RuntimeSpec} runtime runtime
- * @returns {RuntimeCondition} result
- */
-exports.subtractRuntimeCondition = (a, b, runtime) => {
-	if (b === true) return false;
-	if (b === false) return a;
-	if (a === false) return false;
-	const result = subtractRuntime(a === true ? runtime : a, b);
-	return result === undefined ? false : result;
+// remove a prefixed "!" that can be specified to reverse sort order
+const normalizeFieldKey = field => {
+	if (field[0] === "!") {
+		return field.substr(1);
+	}
+	return field;
 };
 
-/**
- * @param {RuntimeSpec} runtime runtime
- * @param {function(RuntimeSpec): boolean} filter filter function
- * @returns {boolean | RuntimeSpec} true/false if filter is constant for all runtimes, otherwise runtimes that are active
- */
-exports.filterRuntime = (runtime, filter) => {
-	if (runtime === undefined) return filter(undefined);
-	if (typeof runtime === "string") return filter(runtime);
-	let some = false;
-	let every = true;
-	let result = undefined;
-	for (const r of runtime) {
-		const v = filter(r);
-		if (v) {
-			some = true;
-			result = mergeRuntimeOwned(result, r);
-		} else {
-			every = false;
-		}
+// if a field is prefixed by a "!" reverse sort order
+const sortOrderRegular = field => {
+	if (field[0] === "!") {
+		return false;
 	}
-	if (!some) return false;
-	if (every) return true;
-	return result;
+	return true;
 };
 
 /**
- * @template T
+ * @param {string} field field name
+ * @returns {function(Object, Object): number} comparators
  */
-class RuntimeSpecMap {
-	/**
-	 * @param {RuntimeSpecMap<T>=} clone copy form this
-	 */
-	constructor(clone) {
-		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
-		/** @type {RuntimeSpec} */
-		this._singleRuntime = clone ? clone._singleRuntime : undefined;
-		/** @type {T} */
-		this._singleValue = clone ? clone._singleValue : undefined;
-		/** @type {Map<string, T> | undefined} */
-		this._map = clone && clone._map ? new Map(clone._map) : undefined;
+const sortByField = field => {
+	if (!field) {
+		/**
+		 * @param {any} a first
+		 * @param {any} b second
+		 * @returns {-1|0|1} zero
+		 */
+		const noSort = (a, b) => 0;
+		return noSort;
 	}
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {T} value
-	 */
-	get(runtime) {
-		switch (this._mode) {
-			case 0:
-				return undefined;
-			case 1:
-				return runtimeEqual(this._singleRuntime, runtime)
-					? this._singleValue
-					: undefined;
-			default:
-				return this._map.get(getRuntimeKey(runtime));
-		}
-	}
+	const fieldKey = normalizeFieldKey(field);
 
-	/**
-	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {boolean} true, when the runtime is stored
-	 */
-	has(runtime) {
-		switch (this._mode) {
-			case 0:
-				return false;
-			case 1:
-				return runtimeEqual(this._singleRuntime, runtime);
-			default:
-				return this._map.has(getRuntimeKey(runtime));
-		}
-	}
+	let sortFn = compareSelect(m => m[fieldKey], compareIds);
 
-	set(runtime, value) {
-		switch (this._mode) {
-			case 0:
-				this._mode = 1;
-				this._singleRuntime = runtime;
-				this._singleValue = value;
-				break;
-			case 1:
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					this._singleValue = value;
-					break;
-				}
-				this._mode = 2;
-				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
-				this._singleRuntime = undefined;
-				this._singleValue = undefined;
-			/* falls through */
-			default:
-				this._map.set(getRuntimeKey(runtime), value);
-		}
-	}
+	// if a field is prefixed with a "!" the sort is reversed!
+	const sortIsRegular = sortOrderRegular(field);
 
-	provide(runtime, computer) {
-		switch (this._mode) {
-			case 0:
-				this._mode = 1;
-				this._singleRuntime = runtime;
-				return (this._singleValue = computer());
-			case 1: {
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					return this._singleValue;
-				}
-				this._mode = 2;
-				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
-				this._singleRuntime = undefined;
-				this._singleValue = undefined;
-				const newValue = computer();
-				this._map.set(getRuntimeKey(runtime), newValue);
-				return newValue;
-			}
-			default: {
-				const key = getRuntimeKey(runtime);
-				const value = this._map.get(key);
-				if (value !== undefined) return value;
-				const newValue = computer();
-				this._map.set(key, newValue);
-				return newValue;
-			}
-		}
+	if (!sortIsRegular) {
+		const oldSortFn = sortFn;
+		sortFn = (a, b) => oldSortFn(b, a);
 	}
 
-	delete(runtime) {
-		switch (this._mode) {
-			case 0:
-				return;
-			case 1:
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					this._mode = 0;
-					this._singleRuntime = undefined;
-					this._singleValue = undefined;
-				}
-				return;
-			default:
-				this._map.delete(getRuntimeKey(runtime));
-		}
-	}
+	return sortFn;
+};
 
-	update(runtime, fn) {
-		switch (this._mode) {
-			case 0:
-				throw new Error("runtime passed to update must exist");
-			case 1: {
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					this._singleValue = fn(this._singleValue);
-					break;
-				}
-				const newValue = fn(undefined);
-				if (newValue !== undefined) {
-					this._mode = 2;
-					this._map = new Map();
-					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
-					this._singleRuntime = undefined;
-					this._singleValue = undefined;
-					this._map.set(getRuntimeKey(runtime), newValue);
-				}
-				break;
-			}
-			default: {
-				const key = getRuntimeKey(runtime);
-				const oldValue = this._map.get(key);
-				const newValue = fn(oldValue);
-				if (newValue !== oldValue) this._map.set(key, newValue);
-			}
-		}
+const ASSET_SORTERS = {
+	/** @type {(comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void} */
+	assetsSort: (comparators, context, { assetsSort }) => {
+		comparators.push(sortByField(assetsSort));
+	},
+	_: comparators => {
+		comparators.push(compareSelect(a => a.name, compareIds));
 	}
+};
 
-	keys() {
-		switch (this._mode) {
-			case 0:
-				return [];
-			case 1:
-				return [this._singleRuntime];
-			default:
-				return Array.from(this._map.keys(), keyToRuntime);
+/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+const RESULT_SORTERS = {
+	"compilation.chunks": {
+		chunksSort: (comparators, context, { chunksSort }) => {
+			comparators.push(sortByField(chunksSort));
 		}
-	}
-
-	values() {
-		switch (this._mode) {
-			case 0:
-				return [][Symbol.iterator]();
-			case 1:
-				return [this._singleValue][Symbol.iterator]();
-			default:
-				return this._map.values();
+	},
+	"compilation.modules": {
+		modulesSort: (comparators, context, { modulesSort }) => {
+			comparators.push(sortByField(modulesSort));
 		}
-	}
-
-	get size() {
-		if (this._mode <= 1) return this._mode;
-		return this._map.size;
-	}
-}
-
-exports.RuntimeSpecMap = RuntimeSpecMap;
+	},
+	"chunk.modules": {
+		chunkModulesSort: (comparators, context, { chunkModulesSort }) => {
+			comparators.push(sortByField(chunkModulesSort));
+		}
+	},
+	"module.modules": {
+		nestedModulesSort: (comparators, context, { nestedModulesSort }) => {
+			comparators.push(sortByField(nestedModulesSort));
+		}
+	},
+	"compilation.assets": ASSET_SORTERS,
+	"asset.related": ASSET_SORTERS
+};
 
-class RuntimeSpecSet {
-	constructor(iterable) {
-		/** @type {Map<string, RuntimeSpec>} */
-		this._map = new Map();
-		if (iterable) {
-			for (const item of iterable) {
-				this.add(item);
+/**
+ * @param {Record<string, Record<string, Function>>} config the config see above
+ * @param {NormalizedStatsOptions} options stats options
+ * @param {function(string, Function): void} fn handler function called for every active line in config
+ * @returns {void}
+ */
+const iterateConfig = (config, options, fn) => {
+	for (const hookFor of Object.keys(config)) {
+		const subConfig = config[hookFor];
+		for (const option of Object.keys(subConfig)) {
+			if (option !== "_") {
+				if (option.startsWith("!")) {
+					if (options[option.slice(1)]) continue;
+				} else {
+					const value = options[option];
+					if (
+						value === false ||
+						value === undefined ||
+						(Array.isArray(value) && value.length === 0)
+					)
+						continue;
+				}
 			}
+			fn(hookFor, subConfig[option]);
 		}
 	}
+};
 
-	add(runtime) {
-		this._map.set(getRuntimeKey(runtime), runtime);
-	}
+/** @type {Record<string, string>} */
+const ITEM_NAMES = {
+	"compilation.children[]": "compilation",
+	"compilation.modules[]": "module",
+	"compilation.entrypoints[]": "chunkGroup",
+	"compilation.namedChunkGroups[]": "chunkGroup",
+	"compilation.errors[]": "error",
+	"compilation.warnings[]": "warning",
+	"chunk.modules[]": "module",
+	"chunk.rootModules[]": "module",
+	"chunk.origins[]": "chunkOrigin",
+	"compilation.chunks[]": "chunk",
+	"compilation.assets[]": "asset",
+	"asset.related[]": "asset",
+	"module.issuerPath[]": "moduleIssuer",
+	"module.reasons[]": "moduleReason",
+	"module.modules[]": "module",
+	"module.children[]": "module",
+	"moduleTrace[]": "moduleTraceItem",
+	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
+};
 
-	has(runtime) {
-		return this._map.has(getRuntimeKey(runtime));
+/**
+ * @param {Object[]} items items to be merged
+ * @returns {Object} an object
+ */
+const mergeToObject = items => {
+	const obj = Object.create(null);
+	for (const item of items) {
+		obj[item.name] = item;
 	}
+	return obj;
+};
 
-	[Symbol.iterator]() {
-		return this._map.values();
-	}
+/** @type {Record<string, (items: Object[]) => any>} */
+const MERGER = {
+	"compilation.entrypoints": mergeToObject,
+	"compilation.namedChunkGroups": mergeToObject
+};
 
-	get size() {
-		return this._map.size;
+class DefaultStatsFactoryPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
+			compilation.hooks.statsFactory.tap(
+				"DefaultStatsFactoryPlugin",
+				(stats, options, context) => {
+					iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
+						stats.hooks.extract
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (obj, data, ctx) =>
+								fn(obj, data, ctx, options, stats)
+							);
+					});
+					iterateConfig(FILTER, options, (hookFor, fn) => {
+						stats.hooks.filter
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+								fn(item, ctx, options, idx, i)
+							);
+					});
+					iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
+						stats.hooks.filterResults
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+								fn(item, ctx, options, idx, i)
+							);
+					});
+					iterateConfig(SORTERS, options, (hookFor, fn) => {
+						stats.hooks.sort
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+								fn(comparators, ctx, options)
+							);
+					});
+					iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
+						stats.hooks.sortResults
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+								fn(comparators, ctx, options)
+							);
+					});
+					iterateConfig(RESULT_GROUPERS, options, (hookFor, fn) => {
+						stats.hooks.groupResults
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (groupConfigs, ctx) =>
+								fn(groupConfigs, ctx, options)
+							);
+					});
+					for (const key of Object.keys(ITEM_NAMES)) {
+						const itemName = ITEM_NAMES[key];
+						stats.hooks.getItemName
+							.for(key)
+							.tap("DefaultStatsFactoryPlugin", () => itemName);
+					}
+					for (const key of Object.keys(MERGER)) {
+						const merger = MERGER[key];
+						stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
+					}
+					if (options.children) {
+						if (Array.isArray(options.children)) {
+							stats.hooks.getItemFactory
+								.for("compilation.children[].compilation")
+								.tap("DefaultStatsFactoryPlugin", (comp, { _index: idx }) => {
+									if (idx < options.children.length) {
+										return compilation.createStatsFactory(
+											compilation.createStatsOptions(
+												options.children[idx],
+												context
+											)
+										);
+									}
+								});
+						} else if (options.children !== true) {
+							const childFactory = compilation.createStatsFactory(
+								compilation.createStatsOptions(options.children, context)
+							);
+							stats.hooks.getItemFactory
+								.for("compilation.children[].compilation")
+								.tap("DefaultStatsFactoryPlugin", () => {
+									return childFactory;
+								});
+						}
+					}
+				}
+			);
+		});
 	}
 }
-
-exports.RuntimeSpecSet = RuntimeSpecSet;
+module.exports = DefaultStatsFactoryPlugin;
 
 
 /***/ }),
 
-/***/ 19702:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 55442:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -128641,900 +126055,1718 @@ exports.RuntimeSpecSet = RuntimeSpecSet;
 
 
 
-/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+const RequestShortener = __webpack_require__(73406);
 
-/**
- * @param {string} str version string
- * @returns {(string|number|undefined|[])[]} parsed version
- */
-const parseVersion = str => {
-	var splitAndConvert = function (str) {
-		return str.split(".").map(function (item) {
-			// eslint-disable-next-line eqeqeq
-			return +item == item ? +item : item;
-		});
-	};
-	var match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-	/** @type {(string|number|undefined|[])[]} */
-	var ver = match[1] ? splitAndConvert(match[1]) : [];
-	if (match[2]) {
-		ver.length++;
-		ver.push.apply(ver, splitAndConvert(match[2]));
+/** @typedef {import("../../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
+/** @typedef {import("../Compiler")} Compiler */
+
+const applyDefaults = (options, defaults) => {
+	for (const key of Object.keys(defaults)) {
+		if (typeof options[key] === "undefined") {
+			options[key] = defaults[key];
+		}
 	}
-	if (match[3]) {
-		ver.push([]);
-		ver.push.apply(ver, splitAndConvert(match[3]));
+};
+
+const NAMED_PRESETS = {
+	verbose: {
+		hash: true,
+		builtAt: true,
+		relatedAssets: true,
+		entrypoints: true,
+		chunkGroups: true,
+		ids: true,
+		modules: false,
+		chunks: true,
+		chunkRelations: true,
+		chunkModules: true,
+		dependentModules: true,
+		chunkOrigins: true,
+		depth: true,
+		env: true,
+		reasons: true,
+		usedExports: true,
+		providedExports: true,
+		optimizationBailout: true,
+		errorDetails: true,
+		errorStack: true,
+		publicPath: true,
+		logging: "verbose",
+		orphanModules: true,
+		runtimeModules: true,
+		exclude: false,
+		modulesSpace: Infinity,
+		chunkModulesSpace: Infinity,
+		assetsSpace: Infinity,
+		reasonsSpace: Infinity,
+		children: true
+	},
+	detailed: {
+		hash: true,
+		builtAt: true,
+		relatedAssets: true,
+		entrypoints: true,
+		chunkGroups: true,
+		ids: true,
+		chunks: true,
+		chunkRelations: true,
+		chunkModules: false,
+		chunkOrigins: true,
+		depth: true,
+		usedExports: true,
+		providedExports: true,
+		optimizationBailout: true,
+		errorDetails: true,
+		publicPath: true,
+		logging: true,
+		runtimeModules: true,
+		exclude: false,
+		modulesSpace: 1000,
+		assetsSpace: 1000,
+		reasonsSpace: 1000
+	},
+	minimal: {
+		all: false,
+		version: true,
+		timings: true,
+		modules: true,
+		modulesSpace: 0,
+		assets: true,
+		assetsSpace: 0,
+		errors: true,
+		errorsCount: true,
+		warnings: true,
+		warningsCount: true,
+		logging: "warn"
+	},
+	"errors-only": {
+		all: false,
+		errors: true,
+		errorsCount: true,
+		moduleTrace: true,
+		logging: "error"
+	},
+	"errors-warnings": {
+		all: false,
+		errors: true,
+		errorsCount: true,
+		warnings: true,
+		warningsCount: true,
+		logging: "warn"
+	},
+	summary: {
+		all: false,
+		version: true,
+		errorsCount: true,
+		warningsCount: true
+	},
+	none: {
+		all: false
 	}
-	return ver;
 };
-exports.parseVersion = parseVersion;
 
-/* eslint-disable eqeqeq */
-/**
- * @param {string} a version
- * @param {string} b version
- * @returns {boolean} true, iff a < b
- */
-const versionLt = (a, b) => {
-	// @ts-expect-error
-	a = parseVersion(a);
-	// @ts-expect-error
-	b = parseVersion(b);
-	var i = 0;
-	for (;;) {
-		// a       b  EOA     object  undefined  number  string
-		// EOA        a == b  a < b   b < a      a < b   a < b
-		// object     b < a   (0)     b < a      a < b   a < b
-		// undefined  a < b   a < b   (0)        a < b   a < b
-		// number     b < a   b < a   b < a      (1)     a < b
-		// string     b < a   b < a   b < a      b < a   (1)
-		// EOA end of array
-		// (0) continue on
-		// (1) compare them via "<"
+const NORMAL_ON = ({ all }) => all !== false;
+const NORMAL_OFF = ({ all }) => all === true;
+const ON_FOR_TO_STRING = ({ all }, { forToString }) =>
+	forToString ? all !== false : all === true;
+const OFF_FOR_TO_STRING = ({ all }, { forToString }) =>
+	forToString ? all === true : all !== false;
+const AUTO_FOR_TO_STRING = ({ all }, { forToString }) => {
+	if (all === false) return false;
+	if (all === true) return true;
+	if (forToString) return "auto";
+	return true;
+};
+
+/** @type {Record<string, (options: StatsOptions, context: CreateStatsOptionsContext, compilation: Compilation) => any>} */
+const DEFAULTS = {
+	context: (options, context, compilation) => compilation.compiler.context,
+	requestShortener: (options, context, compilation) =>
+		compilation.compiler.context === options.context
+			? compilation.requestShortener
+			: new RequestShortener(options.context, compilation.compiler.root),
+	performance: NORMAL_ON,
+	hash: OFF_FOR_TO_STRING,
+	env: NORMAL_OFF,
+	version: NORMAL_ON,
+	timings: NORMAL_ON,
+	builtAt: OFF_FOR_TO_STRING,
+	assets: NORMAL_ON,
+	entrypoints: AUTO_FOR_TO_STRING,
+	chunkGroups: OFF_FOR_TO_STRING,
+	chunkGroupAuxiliary: OFF_FOR_TO_STRING,
+	chunkGroupChildren: OFF_FOR_TO_STRING,
+	chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
+	chunks: OFF_FOR_TO_STRING,
+	chunkRelations: OFF_FOR_TO_STRING,
+	chunkModules: ({ all, modules }) => {
+		if (all === false) return false;
+		if (all === true) return true;
+		if (modules) return false;
+		return true;
+	},
+	dependentModules: OFF_FOR_TO_STRING,
+	chunkOrigins: OFF_FOR_TO_STRING,
+	ids: OFF_FOR_TO_STRING,
+	modules: ({ all, chunks, chunkModules }, { forToString }) => {
+		if (all === false) return false;
+		if (all === true) return true;
+		if (forToString && chunks && chunkModules) return false;
+		return true;
+	},
+	nestedModules: OFF_FOR_TO_STRING,
+	groupModulesByType: ON_FOR_TO_STRING,
+	groupModulesByCacheStatus: ON_FOR_TO_STRING,
+	groupModulesByLayer: ON_FOR_TO_STRING,
+	groupModulesByAttributes: ON_FOR_TO_STRING,
+	groupModulesByPath: ON_FOR_TO_STRING,
+	groupModulesByExtension: ON_FOR_TO_STRING,
+	modulesSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+	chunkModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
+	nestedModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
+	relatedAssets: OFF_FOR_TO_STRING,
+	groupAssetsByEmitStatus: ON_FOR_TO_STRING,
+	groupAssetsByInfo: ON_FOR_TO_STRING,
+	groupAssetsByPath: ON_FOR_TO_STRING,
+	groupAssetsByExtension: ON_FOR_TO_STRING,
+	groupAssetsByChunk: ON_FOR_TO_STRING,
+	assetsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+	orphanModules: OFF_FOR_TO_STRING,
+	runtimeModules: ({ all, runtime }, { forToString }) =>
+		runtime !== undefined
+			? runtime
+			: forToString
+			? all === true
+			: all !== false,
+	cachedModules: ({ all, cached }, { forToString }) =>
+		cached !== undefined ? cached : forToString ? all === true : all !== false,
+	moduleAssets: OFF_FOR_TO_STRING,
+	depth: OFF_FOR_TO_STRING,
+	cachedAssets: OFF_FOR_TO_STRING,
+	reasons: OFF_FOR_TO_STRING,
+	reasonsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+	groupReasonsByOrigin: ON_FOR_TO_STRING,
+	usedExports: OFF_FOR_TO_STRING,
+	providedExports: OFF_FOR_TO_STRING,
+	optimizationBailout: OFF_FOR_TO_STRING,
+	children: OFF_FOR_TO_STRING,
+	source: NORMAL_OFF,
+	moduleTrace: NORMAL_ON,
+	errors: NORMAL_ON,
+	errorsCount: NORMAL_ON,
+	errorDetails: AUTO_FOR_TO_STRING,
+	errorStack: OFF_FOR_TO_STRING,
+	warnings: NORMAL_ON,
+	warningsCount: NORMAL_ON,
+	publicPath: OFF_FOR_TO_STRING,
+	logging: ({ all }, { forToString }) =>
+		forToString && all !== false ? "info" : false,
+	loggingDebug: () => [],
+	loggingTrace: OFF_FOR_TO_STRING,
+	excludeModules: () => [],
+	excludeAssets: () => [],
+	modulesSort: () => "depth",
+	chunkModulesSort: () => "name",
+	nestedModulesSort: () => false,
+	chunksSort: () => false,
+	assetsSort: () => "!size",
+	outputPath: OFF_FOR_TO_STRING,
+	colors: () => false
+};
+
+const normalizeFilter = item => {
+	if (typeof item === "string") {
+		const regExp = new RegExp(
+			`[\\\\/]${item.replace(
+				// eslint-disable-next-line no-useless-escape
+				/[-[\]{}()*+?.\\^$|]/g,
+				"\\$&"
+			)}([\\\\/]|$|!|\\?)`
+		);
+		return ident => regExp.test(ident);
+	}
+	if (item && typeof item === "object" && typeof item.test === "function") {
+		return ident => item.test(ident);
+	}
+	if (typeof item === "function") {
+		return item;
+	}
+	if (typeof item === "boolean") {
+		return () => item;
+	}
+};
+
+const NORMALIZER = {
+	excludeModules: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(normalizeFilter);
+	},
+	excludeAssets: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(normalizeFilter);
+	},
+	warningsFilter: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(filter => {
+			if (typeof filter === "string") {
+				return (warning, warningString) => warningString.includes(filter);
+			}
+			if (filter instanceof RegExp) {
+				return (warning, warningString) => filter.test(warningString);
+			}
+			if (typeof filter === "function") {
+				return filter;
+			}
+			throw new Error(
+				`Can only filter warnings with Strings or RegExps. (Given: ${filter})`
+			);
+		});
+	},
+	logging: value => {
+		if (value === true) value = "log";
+		return value;
+	},
+	loggingDebug: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(normalizeFilter);
+	}
+};
+
+class DefaultStatsPresetPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("DefaultStatsPresetPlugin", compilation => {
+			for (const key of Object.keys(NAMED_PRESETS)) {
+				const defaults = NAMED_PRESETS[key];
+				compilation.hooks.statsPreset
+					.for(key)
+					.tap("DefaultStatsPresetPlugin", (options, context) => {
+						applyDefaults(options, defaults);
+					});
+			}
+			compilation.hooks.statsNormalize.tap(
+				"DefaultStatsPresetPlugin",
+				(options, context) => {
+					for (const key of Object.keys(DEFAULTS)) {
+						if (options[key] === undefined)
+							options[key] = DEFAULTS[key](options, context, compilation);
+					}
+					for (const key of Object.keys(NORMALIZER)) {
+						options[key] = NORMALIZER[key](options[key]);
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = DefaultStatsPresetPlugin;
 
-		// Handles first row in table
-		if (i >= a.length) return i < b.length && (typeof b[i])[0] != "u";
 
-		var aValue = a[i];
-		var aType = (typeof aValue)[0];
+/***/ }),
 
-		// Handles first column in table
-		if (i >= b.length) return aType == "u";
+/***/ 58692:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		var bValue = b[i];
-		var bType = (typeof bValue)[0];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (aType == bType) {
-			if (aType != "o" && aType != "u" && aValue != bValue) {
-				return aValue < bValue;
-			}
-			i++;
-		} else {
-			// Handles remaining cases
-			if (aType == "o" && bType == "n") return true;
-			return bType == "s" || aType == "u";
-		}
-	}
-};
-/* eslint-enable eqeqeq */
-exports.versionLt = versionLt;
+
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./StatsPrinter")} StatsPrinter */
+/** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
+
+const DATA_URI_CONTENT_LENGTH = 16;
+
+const plural = (n, singular, plural) => (n === 1 ? singular : plural);
 
 /**
- * @param {string} str range string
- * @returns {SemVerRange} parsed range
+ * @param {Record<string, number>} sizes sizes by source type
+ * @param {Object} options options
+ * @param {(number) => string=} options.formatSize size formatter
+ * @returns {string} text
  */
-exports.parseRange = str => {
-	const splitAndConvert = str => {
-		return str.split(".").map(item => (`${+item}` === item ? +item : item));
-	};
-	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
-	const parsePartial = str => {
-		const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-		/** @type {(string|number|undefined|[])[]} */
-		const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
-		if (match[2]) {
-			ver.length++;
-			ver.push.apply(ver, splitAndConvert(match[2]));
-		}
+const printSizes = (sizes, { formatSize = n => `${n}` }) => {
+	const keys = Object.keys(sizes);
+	if (keys.length > 1) {
+		return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
+	} else if (keys.length === 1) {
+		return formatSize(sizes[keys[0]]);
+	}
+};
 
-		// remove trailing any matchers
-		let last = ver[ver.length - 1];
-		while (
-			ver.length &&
-			(last === undefined || /^[*xX]$/.test(/** @type {string} */ (last)))
-		) {
-			ver.pop();
-			last = ver[ver.length - 1];
-		}
+const getResourceName = resource => {
+	const dataUrl = /^data:[^,]+,/.exec(resource);
+	if (!dataUrl) return resource;
 
-		return ver;
-	};
-	const toFixed = range => {
-		if (range.length === 1) {
-			// Special case for "*" is "x.x.x" instead of "="
-			return [0];
-		} else if (range.length === 2) {
-			// Special case for "1" is "1.x.x" instead of "=1"
-			return [1, ...range.slice(1)];
-		} else if (range.length === 3) {
-			// Special case for "1.2" is "1.2.x" instead of "=1.2"
-			return [2, ...range.slice(1)];
-		} else {
-			return [range.length, ...range.slice(1)];
-		}
-	};
-	const negate = range => {
-		return [-range[0] - 1, ...range.slice(1)];
-	};
-	const parseSimple = str => {
-		// simple     ::= primitive | partial | tilde | caret
-		// primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
-		// tilde      ::= '~' partial
-		// caret      ::= '^' partial
-		const match = /^(\^|~|<=|<|>=|>|=|v|!)/.exec(str);
-		const start = match ? match[0] : "";
-		const remainder = parsePartial(str.slice(start.length));
-		switch (start) {
-			case "^":
-				if (remainder.length > 1 && remainder[1] === 0) {
-					if (remainder.length > 2 && remainder[2] === 0) {
-						return [3, ...remainder.slice(1)];
-					}
-					return [2, ...remainder.slice(1)];
-				}
-				return [1, ...remainder.slice(1)];
-			case "~":
-				return [2, ...remainder.slice(1)];
-			case ">=":
-				return remainder;
-			case "=":
-			case "v":
-			case "":
-				return toFixed(remainder);
-			case "<":
-				return negate(remainder);
-			case ">": {
-				// and( >=, not( = ) ) => >=, =, not, and
-				const fixed = toFixed(remainder);
-				// eslint-disable-next-line no-sparse-arrays
-				return [, fixed, 0, remainder, 2];
-			}
-			case "<=":
-				// or( <, = ) => <, =, or
-				// eslint-disable-next-line no-sparse-arrays
-				return [, toFixed(remainder), negate(remainder), 1];
-			case "!": {
-				// not =
-				const fixed = toFixed(remainder);
-				// eslint-disable-next-line no-sparse-arrays
-				return [, fixed, 0];
-			}
-			default:
-				throw new Error("Unexpected start value");
-		}
-	};
-	const combine = (items, fn) => {
-		if (items.length === 1) return items[0];
-		const arr = [];
-		for (const item of items.slice().reverse()) {
-			if (0 in item) {
-				arr.push(item);
-			} else {
-				arr.push(...item.slice(1));
-			}
-		}
-		// eslint-disable-next-line no-sparse-arrays
-		return [, ...arr, ...items.slice(1).map(() => fn)];
-	};
-	const parseRange = str => {
-		// range      ::= hyphen | simple ( ' ' simple ) * | ''
-		// hyphen     ::= partial ' - ' partial
-		const items = str.split(" - ");
-		if (items.length === 1) {
-			const items = str.trim().split(/\s+/g).map(parseSimple);
-			return combine(items, 2);
-		}
-		const a = parsePartial(items[0]);
-		const b = parsePartial(items[1]);
-		// >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
-		// eslint-disable-next-line no-sparse-arrays
-		return [, toFixed(b), negate(b), 1, a, 2];
-	};
-	const parseLogicalOr = str => {
-		// range-set  ::= range ( logical-or range ) *
-		// logical-or ::= ( ' ' ) * '||' ( ' ' ) *
-		const items = str.split(/\s*\|\|\s*/).map(parseRange);
-		return combine(items, 1);
-	};
-	return parseLogicalOr(str);
+	const len = dataUrl[0].length + DATA_URI_CONTENT_LENGTH;
+	if (resource.length < len) return resource;
+	return `${resource.slice(
+		0,
+		Math.min(resource.length - /* '..'.length */ 2, len)
+	)}..`;
 };
 
-/* eslint-disable eqeqeq */
-const rangeToString = range => {
-	var fixCount = range[0];
-	var str = "";
-	if (range.length === 1) {
-		return "*";
-	} else if (fixCount + 0.5) {
-		str +=
-			fixCount == 0
-				? ">="
-				: fixCount == -1
-				? "<"
-				: fixCount == 1
-				? "^"
-				: fixCount == 2
-				? "~"
-				: fixCount > 0
-				? "="
-				: "!=";
-		var needDot = 1;
-		// eslint-disable-next-line no-redeclare
-		for (var i = 1; i < range.length; i++) {
-			var item = range[i];
-			var t = (typeof item)[0];
-			needDot--;
-			str +=
-				t == "u"
-					? // undefined: prerelease marker, add an "-"
-					  "-"
-					: // number or string: add the item, set flag to add an "." between two of them
-					  (needDot > 0 ? "." : "") + ((needDot = 2), item);
-		}
-		return str;
-	} else {
-		var stack = [];
-		// eslint-disable-next-line no-redeclare
-		for (var i = 1; i < range.length; i++) {
-			// eslint-disable-next-line no-redeclare
-			var item = range[i];
-			stack.push(
-				item === 0
-					? "not(" + pop() + ")"
-					: item === 1
-					? "(" + pop() + " || " + pop() + ")"
-					: item === 2
-					? stack.pop() + " " + stack.pop()
-					: rangeToString(item)
-			);
-		}
-		return pop();
-	}
-	function pop() {
-		return stack.pop().replace(/^\((.+)\)$/, "$1");
-	}
+const getModuleName = name => {
+	const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
+	return [prefix, getResourceName(resource)];
 };
-/* eslint-enable eqeqeq */
-exports.rangeToString = rangeToString;
 
-/* eslint-disable eqeqeq */
+const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
+
 /**
- * @param {SemVerRange} range version range
- * @param {string} version the version
- * @returns {boolean} if version satisfy the range
+ * @param {number} n a number
+ * @returns {string} number as two digit string, leading 0
  */
-const satisfy = (range, version) => {
-	if (0 in range) {
-		// @ts-expect-error
-		version = parseVersion(version);
-		var fixCount = range[0];
-		// when negated is set it swill set for < instead of >=
-		var negated = fixCount < 0;
-		if (negated) fixCount = -fixCount - 1;
-		for (var i = 0, j = 1, isEqual = true; ; j++, i++) {
-			// cspell:word nequal nequ
-
-			// when isEqual = true:
-			// range         version: EOA/object  undefined  number    string
-			// EOA                    equal       block      big-ver   big-ver
-			// undefined              bigger      next       big-ver   big-ver
-			// number                 smaller     block      cmp       big-cmp
-			// fixed number           smaller     block      cmp-fix   differ
-			// string                 smaller     block      differ    cmp
-			// fixed string           smaller     block      small-cmp cmp-fix
-
-			// when isEqual = false:
-			// range         version: EOA/object  undefined  number    string
-			// EOA                    nequal      block      next-ver  next-ver
-			// undefined              nequal      block      next-ver  next-ver
-			// number                 nequal      block      next      next
-			// fixed number           nequal      block      next      next   (this never happens)
-			// string                 nequal      block      next      next
-			// fixed string           nequal      block      next      next   (this never happens)
+const twoDigit = n => (n >= 10 ? `${n}` : `0${n}`);
 
-			// EOA end of array
-			// equal (version is equal range):
-			//   when !negated: return true,
-			//   when negated: return false
-			// bigger (version is bigger as range):
-			//   when fixed: return false,
-			//   when !negated: return true,
-			//   when negated: return false,
-			// smaller (version is smaller as range):
-			//   when !negated: return false,
-			//   when negated: return true
-			// nequal (version is not equal range (> resp <)): return true
-			// block (version is in different prerelease area): return false
-			// differ (version is different from fixed range (string vs. number)): return false
-			// next: continues to the next items
-			// next-ver: when fixed: return false, continues to the next item only for the version, sets isEqual=false
-			// big-ver: when fixed || negated: return false, continues to the next item only for the version, sets isEqual=false
-			// next-nequ: continues to the next items, sets isEqual=false
-			// cmp (negated === false): version < range => return false, version > range => next-nequ, else => next
-			// cmp (negated === true): version > range => return false, version < range => next-nequ, else => next
-			// cmp-fix: version == range => next, else => return false
-			// big-cmp: when negated => return false, else => next-nequ
-			// small-cmp: when negated => next-nequ, else => return false
+const isValidId = id => {
+	return typeof id === "number" || id;
+};
 
-			var rangeType = j < range.length ? (typeof range[j])[0] : "";
+const moreCount = (list, count) => {
+	return list && list.length > 0 ? `+ ${count}` : `${count}`;
+};
 
-			var versionValue;
-			var versionType;
+/** @type {Record<string, (thing: any, context: StatsPrinterContext, printer: StatsPrinter) => string | void>} */
+const SIMPLE_PRINTERS = {
+	"compilation.summary!": (
+		_,
+		{
+			type,
+			bold,
+			green,
+			red,
+			yellow,
+			formatDateTime,
+			formatTime,
+			compilation: {
+				name,
+				hash,
+				version,
+				time,
+				builtAt,
+				errorsCount,
+				warningsCount
+			}
+		}
+	) => {
+		const root = type === "compilation.summary!";
+		const warningsMessage =
+			warningsCount > 0
+				? yellow(
+						`${warningsCount} ${plural(warningsCount, "warning", "warnings")}`
+				  )
+				: "";
+		const errorsMessage =
+			errorsCount > 0
+				? red(`${errorsCount} ${plural(errorsCount, "error", "errors")}`)
+				: "";
+		const timeMessage = root && time ? ` in ${formatTime(time)}` : "";
+		const hashMessage = hash ? ` (${hash})` : "";
+		const builtAtMessage =
+			root && builtAt ? `${formatDateTime(builtAt)}: ` : "";
+		const versionMessage = root && version ? `webpack ${version}` : "";
+		const nameMessage =
+			root && name
+				? bold(name)
+				: name
+				? `Child ${bold(name)}`
+				: root
+				? ""
+				: "Child";
+		const subjectMessage =
+			nameMessage && versionMessage
+				? `${nameMessage} (${versionMessage})`
+				: versionMessage || nameMessage || "webpack";
+		let statusMessage;
+		if (errorsMessage && warningsMessage) {
+			statusMessage = `compiled with ${errorsMessage} and ${warningsMessage}`;
+		} else if (errorsMessage) {
+			statusMessage = `compiled with ${errorsMessage}`;
+		} else if (warningsMessage) {
+			statusMessage = `compiled with ${warningsMessage}`;
+		} else if (errorsCount === 0 && warningsCount === 0) {
+			statusMessage = `compiled ${green("successfully")}`;
+		} else {
+			statusMessage = `compiled`;
+		}
+		if (
+			builtAtMessage ||
+			versionMessage ||
+			errorsMessage ||
+			warningsMessage ||
+			(errorsCount === 0 && warningsCount === 0) ||
+			timeMessage ||
+			hashMessage
+		)
+			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
+	},
+	"compilation.filteredWarningDetailsCount": count =>
+		count
+			? `${count} ${plural(
+					count,
+					"warning has",
+					"warnings have"
+			  )} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+			: undefined,
+	"compilation.filteredErrorDetailsCount": (count, { yellow }) =>
+		count
+			? yellow(
+					`${count} ${plural(
+						count,
+						"error has",
+						"errors have"
+					)} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+			  )
+			: undefined,
+	"compilation.env": (env, { bold }) =>
+		env
+			? `Environment (--env): ${bold(JSON.stringify(env, null, 2))}`
+			: undefined,
+	"compilation.publicPath": (publicPath, { bold }) =>
+		`PublicPath: ${bold(publicPath || "(none)")}`,
+	"compilation.entrypoints": (entrypoints, context, printer) =>
+		Array.isArray(entrypoints)
+			? undefined
+			: printer.print(context.type, Object.values(entrypoints), {
+					...context,
+					chunkGroupKind: "Entrypoint"
+			  }),
+	"compilation.namedChunkGroups": (namedChunkGroups, context, printer) => {
+		if (!Array.isArray(namedChunkGroups)) {
+			const {
+				compilation: { entrypoints }
+			} = context;
+			let chunkGroups = Object.values(namedChunkGroups);
+			if (entrypoints) {
+				chunkGroups = chunkGroups.filter(
+					group =>
+						!Object.prototype.hasOwnProperty.call(entrypoints, group.name)
+				);
+			}
+			return printer.print(context.type, chunkGroups, {
+				...context,
+				chunkGroupKind: "Chunk Group"
+			});
+		}
+	},
+	"compilation.assetsByChunkName": () => "",
 
-			// Handles first column in both tables (end of version or object)
-			if (
-				i >= version.length ||
-				((versionValue = version[i]),
-				(versionType = (typeof versionValue)[0]) == "o")
-			) {
-				// Handles nequal
-				if (!isEqual) return true;
-				// Handles bigger
-				if (rangeType == "u") return j > fixCount && !negated;
-				// Handles equal and smaller: (range === EOA) XOR negated
-				return (rangeType == "") != negated; // equal + smaller
+	"compilation.filteredModules": (
+		filteredModules,
+		{ compilation: { modules } }
+	) =>
+		filteredModules > 0
+			? `${moreCount(modules, filteredModules)} ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"compilation.filteredAssets": (filteredAssets, { compilation: { assets } }) =>
+		filteredAssets > 0
+			? `${moreCount(assets, filteredAssets)} ${plural(
+					filteredAssets,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+	"compilation.logging": (logging, context, printer) =>
+		Array.isArray(logging)
+			? undefined
+			: printer.print(
+					context.type,
+					Object.entries(logging).map(([name, value]) => ({ ...value, name })),
+					context
+			  ),
+	"compilation.warningsInChildren!": (_, { yellow, compilation }) => {
+		if (
+			!compilation.children &&
+			compilation.warningsCount > 0 &&
+			compilation.warnings
+		) {
+			const childWarnings =
+				compilation.warningsCount - compilation.warnings.length;
+			if (childWarnings > 0) {
+				return yellow(
+					`${childWarnings} ${plural(
+						childWarnings,
+						"WARNING",
+						"WARNINGS"
+					)} in child compilations${
+						compilation.children
+							? ""
+							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
+					}`
+				);
+			}
+		}
+	},
+	"compilation.errorsInChildren!": (_, { red, compilation }) => {
+		if (
+			!compilation.children &&
+			compilation.errorsCount > 0 &&
+			compilation.errors
+		) {
+			const childErrors = compilation.errorsCount - compilation.errors.length;
+			if (childErrors > 0) {
+				return red(
+					`${childErrors} ${plural(
+						childErrors,
+						"ERROR",
+						"ERRORS"
+					)} in child compilations${
+						compilation.children
+							? ""
+							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
+					}`
+				);
 			}
+		}
+	},
 
-			// Handles second column in both tables (version = undefined)
-			if (versionType == "u") {
-				if (!isEqual || rangeType != "u") {
-					return false;
-				}
-			}
+	"asset.type": type => type,
+	"asset.name": (name, { formatFilename, asset: { isOverSizeLimit } }) =>
+		formatFilename(name, isOverSizeLimit),
+	"asset.size": (
+		size,
+		{ asset: { isOverSizeLimit }, yellow, green, formatSize }
+	) => (isOverSizeLimit ? yellow(formatSize(size)) : formatSize(size)),
+	"asset.emitted": (emitted, { green, formatFlag }) =>
+		emitted ? green(formatFlag("emitted")) : undefined,
+	"asset.comparedForEmit": (comparedForEmit, { yellow, formatFlag }) =>
+		comparedForEmit ? yellow(formatFlag("compared for emit")) : undefined,
+	"asset.cached": (cached, { green, formatFlag }) =>
+		cached ? green(formatFlag("cached")) : undefined,
+	"asset.isOverSizeLimit": (isOverSizeLimit, { yellow, formatFlag }) =>
+		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
 
-			// switch between first and second table
-			else if (isEqual) {
-				// Handle diagonal
-				if (rangeType == versionType) {
-					if (j <= fixCount) {
-						// Handles "cmp-fix" cases
-						if (versionValue != range[j]) {
-							return false;
-						}
-					} else {
-						// Handles "cmp" cases
-						if (negated ? versionValue > range[j] : versionValue < range[j]) {
-							return false;
-						}
-						if (versionValue != range[j]) isEqual = false;
-					}
-				}
+	"asset.info.immutable": (immutable, { green, formatFlag }) =>
+		immutable ? green(formatFlag("immutable")) : undefined,
+	"asset.info.javascriptModule": (javascriptModule, { formatFlag }) =>
+		javascriptModule ? formatFlag("javascript module") : undefined,
+	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
+		sourceFilename
+			? formatFlag(
+					sourceFilename === true
+						? "from source file"
+						: `from: ${sourceFilename}`
+			  )
+			: undefined,
+	"asset.info.development": (development, { green, formatFlag }) =>
+		development ? green(formatFlag("dev")) : undefined,
+	"asset.info.hotModuleReplacement": (
+		hotModuleReplacement,
+		{ green, formatFlag }
+	) => (hotModuleReplacement ? green(formatFlag("hmr")) : undefined),
+	"asset.separator!": () => "\n",
+	"asset.filteredRelated": (filteredRelated, { asset: { related } }) =>
+		filteredRelated > 0
+			? `${moreCount(related, filteredRelated)} related ${plural(
+					filteredRelated,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+	"asset.filteredChildren": (filteredChildren, { asset: { children } }) =>
+		filteredChildren > 0
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
 
-				// Handle big-ver
-				else if (rangeType != "s" && rangeType != "n") {
-					if (negated || j <= fixCount) return false;
-					isEqual = false;
-					j--;
-				}
+	assetChunk: (id, { formatChunkId }) => formatChunkId(id),
 
-				// Handle differ, big-cmp and small-cmp
-				else if (j <= fixCount || versionType < rangeType != negated) {
-					return false;
-				} else {
-					isEqual = false;
-				}
-			} else {
-				// Handles all "next-ver" cases in the second table
-				if (rangeType != "s" && rangeType != "n") {
-					isEqual = false;
-					j--;
-				}
+	assetChunkName: name => name,
+	assetChunkIdHint: name => name,
 
-				// next is applied by default
-			}
+	"module.type": type => (type !== "module" ? type : undefined),
+	"module.id": (id, { formatModuleId }) =>
+		isValidId(id) ? formatModuleId(id) : undefined,
+	"module.name": (name, { bold }) => {
+		const [prefix, resource] = getModuleName(name);
+		return `${prefix || ""}${bold(resource || "")}`;
+	},
+	"module.identifier": identifier => undefined,
+	"module.layer": (layer, { formatLayer }) =>
+		layer ? formatLayer(layer) : undefined,
+	"module.sizes": printSizes,
+	"module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
+	"module.depth": (depth, { formatFlag }) =>
+		depth !== null ? formatFlag(`depth ${depth}`) : undefined,
+	"module.cacheable": (cacheable, { formatFlag, red }) =>
+		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
+	"module.orphan": (orphan, { formatFlag, yellow }) =>
+		orphan ? yellow(formatFlag("orphan")) : undefined,
+	"module.runtime": (runtime, { formatFlag, yellow }) =>
+		runtime ? yellow(formatFlag("runtime")) : undefined,
+	"module.optional": (optional, { formatFlag, yellow }) =>
+		optional ? yellow(formatFlag("optional")) : undefined,
+	"module.dependent": (dependent, { formatFlag, cyan }) =>
+		dependent ? cyan(formatFlag("dependent")) : undefined,
+	"module.built": (built, { formatFlag, yellow }) =>
+		built ? yellow(formatFlag("built")) : undefined,
+	"module.codeGenerated": (codeGenerated, { formatFlag, yellow }) =>
+		codeGenerated ? yellow(formatFlag("code generated")) : undefined,
+	"module.buildTimeExecuted": (buildTimeExecuted, { formatFlag, green }) =>
+		buildTimeExecuted ? green(formatFlag("build time executed")) : undefined,
+	"module.cached": (cached, { formatFlag, green }) =>
+		cached ? green(formatFlag("cached")) : undefined,
+	"module.assets": (assets, { formatFlag, magenta }) =>
+		assets && assets.length
+			? magenta(
+					formatFlag(
+						`${assets.length} ${plural(assets.length, "asset", "assets")}`
+					)
+			  )
+			: undefined,
+	"module.warnings": (warnings, { formatFlag, yellow }) =>
+		warnings === true
+			? yellow(formatFlag("warnings"))
+			: warnings
+			? yellow(
+					formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`)
+			  )
+			: undefined,
+	"module.errors": (errors, { formatFlag, red }) =>
+		errors === true
+			? red(formatFlag("errors"))
+			: errors
+			? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
+			: undefined,
+	"module.providedExports": (providedExports, { formatFlag, cyan }) => {
+		if (Array.isArray(providedExports)) {
+			if (providedExports.length === 0) return cyan(formatFlag("no exports"));
+			return cyan(formatFlag(`exports: ${providedExports.join(", ")}`));
 		}
-	}
-	/** @type {(boolean | number)[]} */
-	var stack = [];
-	var p = stack.pop.bind(stack);
-	// eslint-disable-next-line no-redeclare
-	for (var i = 1; i < range.length; i++) {
-		var item = /** @type {SemVerRange | 0 | 1 | 2} */ (range[i]);
-		stack.push(
-			item == 1
-				? p() | p()
-				: item == 2
-				? p() & p()
-				: item
-				? satisfy(item, version)
-				: !p()
-		);
-	}
-	return !!p();
-};
-/* eslint-enable eqeqeq */
-exports.satisfy = satisfy;
-
-exports.stringifyHoley = json => {
-	switch (typeof json) {
-		case "undefined":
-			return "";
-		case "object":
-			if (Array.isArray(json)) {
-				let str = "[";
-				for (let i = 0; i < json.length; i++) {
-					if (i !== 0) str += ",";
-					str += this.stringifyHoley(json[i]);
+	},
+	"module.usedExports": (usedExports, { formatFlag, cyan, module }) => {
+		if (usedExports !== true) {
+			if (usedExports === null) return cyan(formatFlag("used exports unknown"));
+			if (usedExports === false) return cyan(formatFlag("module unused"));
+			if (Array.isArray(usedExports)) {
+				if (usedExports.length === 0)
+					return cyan(formatFlag("no exports used"));
+				const providedExportsCount = Array.isArray(module.providedExports)
+					? module.providedExports.length
+					: null;
+				if (
+					providedExportsCount !== null &&
+					providedExportsCount === usedExports.length
+				) {
+					return cyan(formatFlag("all exports used"));
+				} else {
+					return cyan(
+						formatFlag(`only some exports used: ${usedExports.join(", ")}`)
+					);
 				}
-				str += "]";
-				return str;
-			} else {
-				return JSON.stringify(json);
 			}
-		default:
-			return JSON.stringify(json);
-	}
-};
-
-//#region runtime code: parseVersion
-exports.parseVersionRuntimeCode = runtimeTemplate =>
-	`var parseVersion = ${runtimeTemplate.basicFunction("str", [
-		"// see webpack/lib/util/semver.js for original code",
-		`var p=${
-			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
-		}{return p.split(".").map((${
-			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
-		}{return+p==p?+p:p}))},n=/^([^-+]+)?(?:-([^+]+))?(?:\\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;`
-	])}`;
-//#endregion
-
-//#region runtime code: versionLt
-exports.versionLtRuntimeCode = runtimeTemplate =>
-	`var versionLt = ${runtimeTemplate.basicFunction("a, b", [
-		"// see webpack/lib/util/semver.js for original code",
-		'a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}'
-	])}`;
-//#endregion
-
-//#region runtime code: rangeToString
-exports.rangeToStringRuntimeCode = runtimeTemplate =>
-	`var rangeToString = ${runtimeTemplate.basicFunction("range", [
-		"// see webpack/lib/util/semver.js for original code",
-		'var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\\((.+)\\)$/,"$1")}'
-	])}`;
-//#endregion
-
-//#region runtime code: satisfy
-exports.satisfyRuntimeCode = runtimeTemplate =>
-	`var satisfy = ${runtimeTemplate.basicFunction("range, version", [
-		"// see webpack/lib/util/semver.js for original code",
-		'if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1;a=!1}else"s"!=g&&"n"!=g&&(a=!1,i--)}}var t=[],o=t.pop.bind(t);for(n=1;n<range.length;n++){var u=range[n];t.push(1==u?o()|o():2==u?o()&o():u?satisfy(u,version):!o())}return!!o();'
-	])}`;
-//#endregion
-
-
-/***/ }),
-
-/***/ 8282:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../serialization/Serializer")} Serializer */
-
-const getBinaryMiddleware = memoize(() =>
-	__webpack_require__(97059)
-);
-const getObjectMiddleware = memoize(() =>
-	__webpack_require__(34795)
-);
-const getSingleItemMiddleware = memoize(() =>
-	__webpack_require__(65112)
-);
-const getSerializer = memoize(() => __webpack_require__(53080));
-const getSerializerMiddleware = memoize(() =>
-	__webpack_require__(83137)
-);
-
-const getBinaryMiddlewareInstance = memoize(
-	() => new (getBinaryMiddleware())()
-);
+		}
+	},
+	"module.optimizationBailout[]": (optimizationBailout, { yellow }) =>
+		yellow(optimizationBailout),
+	"module.issuerPath": (issuerPath, { module }) =>
+		module.profile ? undefined : "",
+	"module.profile": profile => undefined,
+	"module.filteredModules": (filteredModules, { module: { modules } }) =>
+		filteredModules > 0
+			? `${moreCount(modules, filteredModules)} nested ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"module.filteredReasons": (filteredReasons, { module: { reasons } }) =>
+		filteredReasons > 0
+			? `${moreCount(reasons, filteredReasons)} ${plural(
+					filteredReasons,
+					"reason",
+					"reasons"
+			  )}`
+			: undefined,
+	"module.filteredChildren": (filteredChildren, { module: { children } }) =>
+		filteredChildren > 0
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"module.separator!": () => "\n",
 
-const registerSerializers = memoize(() => {
-	__webpack_require__(26611);
+	"moduleIssuer.id": (id, { formatModuleId }) => formatModuleId(id),
+	"moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value),
 
-	// Load internal paths with a relative require
-	// This allows bundling all internal serializers
-	const internalSerializables = __webpack_require__(53023);
-	getObjectMiddleware().registerLoader(/^webpack\/lib\//, req => {
-		const loader = internalSerializables[req.slice("webpack/lib/".length)];
-		if (loader) {
-			loader();
-		} else {
-			console.warn(`${req} not found in internalSerializables`);
-		}
-		return true;
-	});
-});
+	"moduleReason.type": type => type,
+	"moduleReason.userRequest": (userRequest, { cyan }) =>
+		cyan(getResourceName(userRequest)),
+	"moduleReason.moduleId": (moduleId, { formatModuleId }) =>
+		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
+	"moduleReason.module": (module, { magenta }) => magenta(module),
+	"moduleReason.loc": loc => loc,
+	"moduleReason.explanation": (explanation, { cyan }) => cyan(explanation),
+	"moduleReason.active": (active, { formatFlag }) =>
+		active ? undefined : formatFlag("inactive"),
+	"moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
+	"moduleReason.filteredChildren": (
+		filteredChildren,
+		{ moduleReason: { children } }
+	) =>
+		filteredChildren > 0
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"reason",
+					"reasons"
+			  )}`
+			: undefined,
 
-/** @type {Serializer} */
-let buffersSerializer;
+	"module.profile.total": (value, { formatTime }) => formatTime(value),
+	"module.profile.resolving": (value, { formatTime }) =>
+		`resolving: ${formatTime(value)}`,
+	"module.profile.restoring": (value, { formatTime }) =>
+		`restoring: ${formatTime(value)}`,
+	"module.profile.integration": (value, { formatTime }) =>
+		`integration: ${formatTime(value)}`,
+	"module.profile.building": (value, { formatTime }) =>
+		`building: ${formatTime(value)}`,
+	"module.profile.storing": (value, { formatTime }) =>
+		`storing: ${formatTime(value)}`,
+	"module.profile.additionalResolving": (value, { formatTime }) =>
+		value ? `additional resolving: ${formatTime(value)}` : undefined,
+	"module.profile.additionalIntegration": (value, { formatTime }) =>
+		value ? `additional integration: ${formatTime(value)}` : undefined,
 
-// Expose serialization API
-module.exports = {
-	get register() {
-		return getObjectMiddleware().register;
-	},
-	get registerLoader() {
-		return getObjectMiddleware().registerLoader;
-	},
-	get registerNotSerializable() {
-		return getObjectMiddleware().registerNotSerializable;
-	},
-	get NOT_SERIALIZABLE() {
-		return getObjectMiddleware().NOT_SERIALIZABLE;
-	},
-	/** @type {MEASURE_START_OPERATION} */
-	get MEASURE_START_OPERATION() {
-		return getBinaryMiddleware().MEASURE_START_OPERATION;
-	},
-	/** @type {MEASURE_END_OPERATION} */
-	get MEASURE_END_OPERATION() {
-		return getBinaryMiddleware().MEASURE_END_OPERATION;
-	},
-	get buffersSerializer() {
-		if (buffersSerializer !== undefined) return buffersSerializer;
-		registerSerializers();
-		const Serializer = getSerializer();
-		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
-		const SingleItemMiddleware = getSingleItemMiddleware();
-		return (buffersSerializer = new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if (context.write) {
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-				}
-			}, "md4"),
-			binaryMiddleware
-		]));
-	},
-	createFileSerializer: (fs, hashFunction) => {
-		registerSerializers();
-		const Serializer = getSerializer();
-		const FileMiddleware = __webpack_require__(65321);
-		const fileMiddleware = new FileMiddleware(fs, hashFunction);
-		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
-		const SingleItemMiddleware = getSingleItemMiddleware();
-		return new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if (context.write) {
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-					context.writeSeparate = (value, options) => {
-						const lazy = SerializerMiddleware.createLazy(
-							value,
-							fileMiddleware,
-							options
-						);
-						context.write(lazy);
-						return lazy;
-					};
-				}
-			}, hashFunction),
-			binaryMiddleware,
-			fileMiddleware
-		]);
-	}
-};
+	"chunkGroup.kind!": (_, { chunkGroupKind }) => chunkGroupKind,
+	"chunkGroup.separator!": () => "\n",
+	"chunkGroup.name": (name, { bold }) => bold(name),
+	"chunkGroup.isOverSizeLimit": (isOverSizeLimit, { formatFlag, yellow }) =>
+		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
+	"chunkGroup.assetsSize": (size, { formatSize }) =>
+		size ? formatSize(size) : undefined,
+	"chunkGroup.auxiliaryAssetsSize": (size, { formatSize }) =>
+		size ? `(${formatSize(size)})` : undefined,
+	"chunkGroup.filteredAssets": (n, { chunkGroup: { assets } }) =>
+		n > 0
+			? `${moreCount(assets, n)} ${plural(n, "asset", "assets")}`
+			: undefined,
+	"chunkGroup.filteredAuxiliaryAssets": (
+		n,
+		{ chunkGroup: { auxiliaryAssets } }
+	) =>
+		n > 0
+			? `${moreCount(auxiliaryAssets, n)} auxiliary ${plural(
+					n,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+	"chunkGroup.is!": () => "=",
+	"chunkGroupAsset.name": (asset, { green }) => green(asset),
+	"chunkGroupAsset.size": (size, { formatSize, chunkGroup }) =>
+		chunkGroup.assets.length > 1 ||
+		(chunkGroup.auxiliaryAssets && chunkGroup.auxiliaryAssets.length > 0)
+			? formatSize(size)
+			: undefined,
+	"chunkGroup.children": (children, context, printer) =>
+		Array.isArray(children)
+			? undefined
+			: printer.print(
+					context.type,
+					Object.keys(children).map(key => ({
+						type: key,
+						children: children[key]
+					})),
+					context
+			  ),
+	"chunkGroupChildGroup.type": type => `${type}:`,
+	"chunkGroupChild.assets[]": (file, { formatFilename }) =>
+		formatFilename(file),
+	"chunkGroupChild.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
+	"chunkGroupChild.name": name => (name ? `(name: ${name})` : undefined),
 
+	"chunk.id": (id, { formatChunkId }) => formatChunkId(id),
+	"chunk.files[]": (file, { formatFilename }) => formatFilename(file),
+	"chunk.names[]": name => name,
+	"chunk.idHints[]": name => name,
+	"chunk.runtime[]": name => name,
+	"chunk.sizes": (sizes, context) => printSizes(sizes, context),
+	"chunk.parents[]": (parents, context) =>
+		context.formatChunkId(parents, "parent"),
+	"chunk.siblings[]": (siblings, context) =>
+		context.formatChunkId(siblings, "sibling"),
+	"chunk.children[]": (children, context) =>
+		context.formatChunkId(children, "child"),
+	"chunk.childrenByOrder": (childrenByOrder, context, printer) =>
+		Array.isArray(childrenByOrder)
+			? undefined
+			: printer.print(
+					context.type,
+					Object.keys(childrenByOrder).map(key => ({
+						type: key,
+						children: childrenByOrder[key]
+					})),
+					context
+			  ),
+	"chunk.childrenByOrder[].type": type => `${type}:`,
+	"chunk.childrenByOrder[].children[]": (id, { formatChunkId }) =>
+		isValidId(id) ? formatChunkId(id) : undefined,
+	"chunk.entry": (entry, { formatFlag, yellow }) =>
+		entry ? yellow(formatFlag("entry")) : undefined,
+	"chunk.initial": (initial, { formatFlag, yellow }) =>
+		initial ? yellow(formatFlag("initial")) : undefined,
+	"chunk.rendered": (rendered, { formatFlag, green }) =>
+		rendered ? green(formatFlag("rendered")) : undefined,
+	"chunk.recorded": (recorded, { formatFlag, green }) =>
+		recorded ? green(formatFlag("recorded")) : undefined,
+	"chunk.reason": (reason, { yellow }) => (reason ? yellow(reason) : undefined),
+	"chunk.filteredModules": (filteredModules, { chunk: { modules } }) =>
+		filteredModules > 0
+			? `${moreCount(modules, filteredModules)} chunk ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"chunk.separator!": () => "\n",
 
-/***/ }),
+	"chunkOrigin.request": request => request,
+	"chunkOrigin.moduleId": (moduleId, { formatModuleId }) =>
+		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
+	"chunkOrigin.moduleName": (moduleName, { bold }) => bold(moduleName),
+	"chunkOrigin.loc": loc => loc,
 
-/***/ 15652:
-/***/ (function(module) {
+	"error.compilerPath": (compilerPath, { bold }) =>
+		compilerPath ? bold(`(${compilerPath})`) : undefined,
+	"error.chunkId": (chunkId, { formatChunkId }) =>
+		isValidId(chunkId) ? formatChunkId(chunkId) : undefined,
+	"error.chunkEntry": (chunkEntry, { formatFlag }) =>
+		chunkEntry ? formatFlag("entry") : undefined,
+	"error.chunkInitial": (chunkInitial, { formatFlag }) =>
+		chunkInitial ? formatFlag("initial") : undefined,
+	"error.file": (file, { bold }) => bold(file),
+	"error.moduleName": (moduleName, { bold }) => {
+		return moduleName.includes("!")
+			? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})`
+			: `${bold(moduleName)}`;
+	},
+	"error.loc": (loc, { green }) => green(loc),
+	"error.message": (message, { bold, formatError }) =>
+		message.includes("\u001b[") ? message : bold(formatError(message)),
+	"error.details": (details, { formatError }) => formatError(details),
+	"error.stack": stack => stack,
+	"error.moduleTrace": moduleTrace => undefined,
+	"error.separator!": () => "\n",
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	"loggingEntry(error).loggingEntry.message": (message, { red }) =>
+		mapLines(message, x => `<e> ${red(x)}`),
+	"loggingEntry(warn).loggingEntry.message": (message, { yellow }) =>
+		mapLines(message, x => `<w> ${yellow(x)}`),
+	"loggingEntry(info).loggingEntry.message": (message, { green }) =>
+		mapLines(message, x => `<i> ${green(x)}`),
+	"loggingEntry(log).loggingEntry.message": (message, { bold }) =>
+		mapLines(message, x => `    ${bold(x)}`),
+	"loggingEntry(debug).loggingEntry.message": message =>
+		mapLines(message, x => `    ${x}`),
+	"loggingEntry(trace).loggingEntry.message": message =>
+		mapLines(message, x => `    ${x}`),
+	"loggingEntry(status).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `<s> ${magenta(x)}`),
+	"loggingEntry(profile).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `<p> ${magenta(x)}`),
+	"loggingEntry(profileEnd).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `</p> ${magenta(x)}`),
+	"loggingEntry(time).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `<t> ${magenta(x)}`),
+	"loggingEntry(group).loggingEntry.message": (message, { cyan }) =>
+		mapLines(message, x => `<-> ${cyan(x)}`),
+	"loggingEntry(groupCollapsed).loggingEntry.message": (message, { cyan }) =>
+		mapLines(message, x => `<+> ${cyan(x)}`),
+	"loggingEntry(clear).loggingEntry": () => "    -------",
+	"loggingEntry(groupCollapsed).loggingEntry.children": () => "",
+	"loggingEntry.trace[]": trace =>
+		trace ? mapLines(trace, x => `| ${x}`) : undefined,
 
+	"moduleTraceItem.originName": originName => originName,
 
+	loggingGroup: loggingGroup =>
+		loggingGroup.entries.length === 0 ? "" : undefined,
+	"loggingGroup.debug": (flag, { red }) => (flag ? red("DEBUG") : undefined),
+	"loggingGroup.name": (name, { bold }) => bold(`LOG from ${name}`),
+	"loggingGroup.separator!": () => "\n",
+	"loggingGroup.filteredEntries": filteredEntries =>
+		filteredEntries > 0 ? `+ ${filteredEntries} hidden lines` : undefined,
 
-/**
- * @typedef {Object} GroupOptions
- * @property {boolean=} groupChildren
- * @property {boolean=} force
- * @property {number=} targetGroupCount
- */
+	"moduleTraceDependency.loc": loc => loc
+};
 
-/**
- * @template T
- * @template R
- * @typedef {Object} GroupConfig
- * @property {function(T): string[]} getKeys
- * @property {function(string, (R | T)[], T[]): R} createGroup
- * @property {function(string, T[]): GroupOptions=} getOptions
- */
+/** @type {Record<string, string | Function>} */
+const ITEM_NAMES = {
+	"compilation.assets[]": "asset",
+	"compilation.modules[]": "module",
+	"compilation.chunks[]": "chunk",
+	"compilation.entrypoints[]": "chunkGroup",
+	"compilation.namedChunkGroups[]": "chunkGroup",
+	"compilation.errors[]": "error",
+	"compilation.warnings[]": "error",
+	"compilation.logging[]": "loggingGroup",
+	"compilation.children[]": "compilation",
+	"asset.related[]": "asset",
+	"asset.children[]": "asset",
+	"asset.chunks[]": "assetChunk",
+	"asset.auxiliaryChunks[]": "assetChunk",
+	"asset.chunkNames[]": "assetChunkName",
+	"asset.chunkIdHints[]": "assetChunkIdHint",
+	"asset.auxiliaryChunkNames[]": "assetChunkName",
+	"asset.auxiliaryChunkIdHints[]": "assetChunkIdHint",
+	"chunkGroup.assets[]": "chunkGroupAsset",
+	"chunkGroup.auxiliaryAssets[]": "chunkGroupAsset",
+	"chunkGroupChild.assets[]": "chunkGroupAsset",
+	"chunkGroupChild.auxiliaryAssets[]": "chunkGroupAsset",
+	"chunkGroup.children[]": "chunkGroupChildGroup",
+	"chunkGroupChildGroup.children[]": "chunkGroupChild",
+	"module.modules[]": "module",
+	"module.children[]": "module",
+	"module.reasons[]": "moduleReason",
+	"moduleReason.children[]": "moduleReason",
+	"module.issuerPath[]": "moduleIssuer",
+	"chunk.origins[]": "chunkOrigin",
+	"chunk.modules[]": "module",
+	"loggingGroup.entries[]": logEntry =>
+		`loggingEntry(${logEntry.type}).loggingEntry`,
+	"loggingEntry.children[]": logEntry =>
+		`loggingEntry(${logEntry.type}).loggingEntry`,
+	"error.moduleTrace[]": "moduleTraceItem",
+	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
+};
 
-/**
- * @template T
- * @template R
- * @typedef {Object} ItemWithGroups
- * @property {T} item
- * @property {Set<Group<T, R>>} groups
- */
+const ERROR_PREFERRED_ORDER = [
+	"compilerPath",
+	"chunkId",
+	"chunkEntry",
+	"chunkInitial",
+	"file",
+	"separator!",
+	"moduleName",
+	"loc",
+	"separator!",
+	"message",
+	"separator!",
+	"details",
+	"separator!",
+	"stack",
+	"separator!",
+	"missing",
+	"separator!",
+	"moduleTrace"
+];
 
-/**
- * @template T
- * @template R
- * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
- */
+/** @type {Record<string, string[]>} */
+const PREFERRED_ORDERS = {
+	compilation: [
+		"name",
+		"hash",
+		"version",
+		"time",
+		"builtAt",
+		"env",
+		"publicPath",
+		"assets",
+		"filteredAssets",
+		"entrypoints",
+		"namedChunkGroups",
+		"chunks",
+		"modules",
+		"filteredModules",
+		"children",
+		"logging",
+		"warnings",
+		"warningsInChildren!",
+		"filteredWarningDetailsCount",
+		"errors",
+		"errorsInChildren!",
+		"filteredErrorDetailsCount",
+		"summary!",
+		"needAdditionalPass"
+	],
+	asset: [
+		"type",
+		"name",
+		"size",
+		"chunks",
+		"auxiliaryChunks",
+		"emitted",
+		"comparedForEmit",
+		"cached",
+		"info",
+		"isOverSizeLimit",
+		"chunkNames",
+		"auxiliaryChunkNames",
+		"chunkIdHints",
+		"auxiliaryChunkIdHints",
+		"related",
+		"filteredRelated",
+		"children",
+		"filteredChildren"
+	],
+	"asset.info": [
+		"immutable",
+		"sourceFilename",
+		"javascriptModule",
+		"development",
+		"hotModuleReplacement"
+	],
+	chunkGroup: [
+		"kind!",
+		"name",
+		"isOverSizeLimit",
+		"assetsSize",
+		"auxiliaryAssetsSize",
+		"is!",
+		"assets",
+		"filteredAssets",
+		"auxiliaryAssets",
+		"filteredAuxiliaryAssets",
+		"separator!",
+		"children"
+	],
+	chunkGroupAsset: ["name", "size"],
+	chunkGroupChildGroup: ["type", "children"],
+	chunkGroupChild: ["assets", "chunks", "name"],
+	module: [
+		"type",
+		"name",
+		"identifier",
+		"id",
+		"layer",
+		"sizes",
+		"chunks",
+		"depth",
+		"cacheable",
+		"orphan",
+		"runtime",
+		"optional",
+		"dependent",
+		"built",
+		"codeGenerated",
+		"cached",
+		"assets",
+		"failed",
+		"warnings",
+		"errors",
+		"children",
+		"filteredChildren",
+		"providedExports",
+		"usedExports",
+		"optimizationBailout",
+		"reasons",
+		"filteredReasons",
+		"issuerPath",
+		"profile",
+		"modules",
+		"filteredModules"
+	],
+	moduleReason: [
+		"active",
+		"type",
+		"userRequest",
+		"moduleId",
+		"module",
+		"resolvedModule",
+		"loc",
+		"explanation",
+		"children",
+		"filteredChildren"
+	],
+	"module.profile": [
+		"total",
+		"separator!",
+		"resolving",
+		"restoring",
+		"integration",
+		"building",
+		"storing",
+		"additionalResolving",
+		"additionalIntegration"
+	],
+	chunk: [
+		"id",
+		"runtime",
+		"files",
+		"names",
+		"idHints",
+		"sizes",
+		"parents",
+		"siblings",
+		"children",
+		"childrenByOrder",
+		"entry",
+		"initial",
+		"rendered",
+		"recorded",
+		"reason",
+		"separator!",
+		"origins",
+		"separator!",
+		"modules",
+		"separator!",
+		"filteredModules"
+	],
+	chunkOrigin: ["request", "moduleId", "moduleName", "loc"],
+	error: ERROR_PREFERRED_ORDER,
+	warning: ERROR_PREFERRED_ORDER,
+	"chunk.childrenByOrder[]": ["type", "children"],
+	loggingGroup: [
+		"debug",
+		"name",
+		"separator!",
+		"entries",
+		"separator!",
+		"filteredEntries"
+	],
+	loggingEntry: ["message", "trace", "children"]
+};
 
-/**
- * @template T
- * @template R
- * @param {T[]} items the list of items
- * @param {GroupConfig<T, R>[]} groupConfigs configuration
- * @returns {(R | T)[]} grouped items
- */
-const smartGrouping = (items, groupConfigs) => {
-	/** @type {Set<ItemWithGroups<T, R>>} */
-	const itemsWithGroups = new Set();
-	/** @type {Map<string, Group<T, R>>} */
-	const allGroups = new Map();
-	for (const item of items) {
-		/** @type {Set<Group<T, R>>} */
-		const groups = new Set();
-		for (let i = 0; i < groupConfigs.length; i++) {
-			const groupConfig = groupConfigs[i];
-			const keys = groupConfig.getKeys(item);
-			if (keys) {
-				for (const name of keys) {
-					const key = `${i}:${name}`;
-					let group = allGroups.get(key);
-					if (group === undefined) {
-						allGroups.set(
-							key,
-							(group = {
-								config: groupConfig,
-								name,
-								alreadyGrouped: false,
-								items: undefined
-							})
-						);
-					}
-					groups.add(group);
-				}
-			}
-		}
-		itemsWithGroups.add({
-			item,
-			groups
-		});
-	}
-	/**
-	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
-	 * @returns {(T | R)[]} groups items
-	 */
-	const runGrouping = itemsWithGroups => {
-		const totalSize = itemsWithGroups.size;
-		for (const entry of itemsWithGroups) {
-			for (const group of entry.groups) {
-				if (group.alreadyGrouped) continue;
-				const items = group.items;
-				if (items === undefined) {
-					group.items = new Set([entry]);
-				} else {
-					items.add(entry);
-				}
-			}
-		}
-		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
-		const groupMap = new Map();
-		for (const group of allGroups.values()) {
-			if (group.items) {
-				const items = group.items;
-				group.items = undefined;
-				groupMap.set(group, {
-					items,
-					options: undefined,
-					used: false
-				});
-			}
-		}
-		/** @type {(T | R)[]} */
-		const results = [];
-		for (;;) {
-			/** @type {Group<T, R>} */
-			let bestGroup = undefined;
-			let bestGroupSize = -1;
-			let bestGroupItems = undefined;
-			let bestGroupOptions = undefined;
-			for (const [group, state] of groupMap) {
-				const { items, used } = state;
-				let options = state.options;
-				if (options === undefined) {
-					const groupConfig = group.config;
-					state.options = options =
-						(groupConfig.getOptions &&
-							groupConfig.getOptions(
-								group.name,
-								Array.from(items, ({ item }) => item)
-							)) ||
-						false;
-				}
+const itemsJoinOneLine = items => items.filter(Boolean).join(" ");
+const itemsJoinOneLineBrackets = items =>
+	items.length > 0 ? `(${items.filter(Boolean).join(" ")})` : undefined;
+const itemsJoinMoreSpacing = items => items.filter(Boolean).join("\n\n");
+const itemsJoinComma = items => items.filter(Boolean).join(", ");
+const itemsJoinCommaBrackets = items =>
+	items.length > 0 ? `(${items.filter(Boolean).join(", ")})` : undefined;
+const itemsJoinCommaBracketsWithName = name => items =>
+	items.length > 0
+		? `(${name}: ${items.filter(Boolean).join(", ")})`
+		: undefined;
+
+/** @type {Record<string, (items: string[]) => string>} */
+const SIMPLE_ITEMS_JOINER = {
+	"chunk.parents": itemsJoinOneLine,
+	"chunk.siblings": itemsJoinOneLine,
+	"chunk.children": itemsJoinOneLine,
+	"chunk.names": itemsJoinCommaBrackets,
+	"chunk.idHints": itemsJoinCommaBracketsWithName("id hint"),
+	"chunk.runtime": itemsJoinCommaBracketsWithName("runtime"),
+	"chunk.files": itemsJoinComma,
+	"chunk.childrenByOrder": itemsJoinOneLine,
+	"chunk.childrenByOrder[].children": itemsJoinOneLine,
+	"chunkGroup.assets": itemsJoinOneLine,
+	"chunkGroup.auxiliaryAssets": itemsJoinOneLineBrackets,
+	"chunkGroupChildGroup.children": itemsJoinComma,
+	"chunkGroupChild.assets": itemsJoinOneLine,
+	"chunkGroupChild.auxiliaryAssets": itemsJoinOneLineBrackets,
+	"asset.chunks": itemsJoinComma,
+	"asset.auxiliaryChunks": itemsJoinCommaBrackets,
+	"asset.chunkNames": itemsJoinCommaBracketsWithName("name"),
+	"asset.auxiliaryChunkNames": itemsJoinCommaBracketsWithName("auxiliary name"),
+	"asset.chunkIdHints": itemsJoinCommaBracketsWithName("id hint"),
+	"asset.auxiliaryChunkIdHints":
+		itemsJoinCommaBracketsWithName("auxiliary id hint"),
+	"module.chunks": itemsJoinOneLine,
+	"module.issuerPath": items =>
+		items
+			.filter(Boolean)
+			.map(item => `${item} ->`)
+			.join(" "),
+	"compilation.errors": itemsJoinMoreSpacing,
+	"compilation.warnings": itemsJoinMoreSpacing,
+	"compilation.logging": itemsJoinMoreSpacing,
+	"compilation.children": items => indent(itemsJoinMoreSpacing(items), "  "),
+	"moduleTraceItem.dependencies": itemsJoinOneLine,
+	"loggingEntry.children": items =>
+		indent(items.filter(Boolean).join("\n"), "  ", false)
+};
 
-				const force = options && options.force;
-				if (!force) {
-					if (bestGroupOptions && bestGroupOptions.force) continue;
-					if (used) continue;
-					if (items.size <= 1 || totalSize - items.size <= 1) {
-						continue;
-					}
-				}
-				const targetGroupCount = (options && options.targetGroupCount) || 4;
-				let sizeValue = force
-					? items.size
-					: Math.min(
-							items.size,
-							(totalSize * 2) / targetGroupCount +
-								itemsWithGroups.size -
-								items.size
-					  );
-				if (
-					sizeValue > bestGroupSize ||
-					(force && (!bestGroupOptions || !bestGroupOptions.force))
-				) {
-					bestGroup = group;
-					bestGroupSize = sizeValue;
-					bestGroupItems = items;
-					bestGroupOptions = options;
-				}
+const joinOneLine = items =>
+	items
+		.map(item => item.content)
+		.filter(Boolean)
+		.join(" ");
+
+const joinInBrackets = items => {
+	const res = [];
+	let mode = 0;
+	for (const item of items) {
+		if (item.element === "separator!") {
+			switch (mode) {
+				case 0:
+				case 1:
+					mode += 2;
+					break;
+				case 4:
+					res.push(")");
+					mode = 3;
+					break;
 			}
-			if (bestGroup === undefined) {
+		}
+		if (!item.content) continue;
+		switch (mode) {
+			case 0:
+				mode = 1;
+				break;
+			case 1:
+				res.push(" ");
+				break;
+			case 2:
+				res.push("(");
+				mode = 4;
+				break;
+			case 3:
+				res.push(" (");
+				mode = 4;
 				break;
+			case 4:
+				res.push(", ");
+				break;
+		}
+		res.push(item.content);
+	}
+	if (mode === 4) res.push(")");
+	return res.join("");
+};
+
+const indent = (str, prefix, noPrefixInFirstLine) => {
+	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	if (noPrefixInFirstLine) return rem;
+	const ind = str[0] === "\n" ? "" : prefix;
+	return ind + rem;
+};
+
+const joinExplicitNewLine = (items, indenter) => {
+	let firstInLine = true;
+	let first = true;
+	return items
+		.map(item => {
+			if (!item || !item.content) return;
+			let content = indent(item.content, first ? "" : indenter, !firstInLine);
+			if (firstInLine) {
+				content = content.replace(/^\n+/, "");
 			}
-			const items = new Set(bestGroupItems);
-			const options = bestGroupOptions;
+			if (!content) return;
+			first = false;
+			const noJoiner = firstInLine || content.startsWith("\n");
+			firstInLine = content.endsWith("\n");
+			return noJoiner ? content : " " + content;
+		})
+		.filter(Boolean)
+		.join("")
+		.trim();
+};
 
-			const groupChildren = !options || options.groupChildren !== false;
+const joinError =
+	error =>
+	(items, { red, yellow }) =>
+		`${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(
+			items,
+			""
+		)}`;
 
-			for (const item of items) {
-				itemsWithGroups.delete(item);
-				// Remove all groups that items have from the map to not select them again
-				for (const group of item.groups) {
-					const state = groupMap.get(group);
-					if (state !== undefined) {
-						state.items.delete(item);
-						if (state.items.size === 0) {
-							groupMap.delete(group);
-						} else {
-							state.options = undefined;
-							if (groupChildren) {
-								state.used = true;
-							}
+/** @type {Record<string, (items: ({ element: string, content: string })[], context: StatsPrinterContext) => string>} */
+const SIMPLE_ELEMENT_JOINERS = {
+	compilation: items => {
+		const result = [];
+		let lastNeedMore = false;
+		for (const item of items) {
+			if (!item.content) continue;
+			const needMoreSpace =
+				item.element === "warnings" ||
+				item.element === "filteredWarningDetailsCount" ||
+				item.element === "errors" ||
+				item.element === "filteredErrorDetailsCount" ||
+				item.element === "logging";
+			if (result.length !== 0) {
+				result.push(needMoreSpace || lastNeedMore ? "\n\n" : "\n");
+			}
+			result.push(item.content);
+			lastNeedMore = needMoreSpace;
+		}
+		if (lastNeedMore) result.push("\n");
+		return result.join("");
+	},
+	asset: items =>
+		joinExplicitNewLine(
+			items.map(item => {
+				if (
+					(item.element === "related" || item.element === "children") &&
+					item.content
+				) {
+					return {
+						...item,
+						content: `\n${item.content}\n`
+					};
+				}
+				return item;
+			}),
+			"  "
+		),
+	"asset.info": joinOneLine,
+	module: (items, { module }) => {
+		let hasName = false;
+		return joinExplicitNewLine(
+			items.map(item => {
+				switch (item.element) {
+					case "id":
+						if (module.id === module.name) {
+							if (hasName) return false;
+							if (item.content) hasName = true;
+						}
+						break;
+					case "name":
+						if (hasName) return false;
+						if (item.content) hasName = true;
+						break;
+					case "providedExports":
+					case "usedExports":
+					case "optimizationBailout":
+					case "reasons":
+					case "issuerPath":
+					case "profile":
+					case "children":
+					case "modules":
+						if (item.content) {
+							return {
+								...item,
+								content: `\n${item.content}\n`
+							};
 						}
+						break;
+				}
+				return item;
+			}),
+			"  "
+		);
+	},
+	chunk: items => {
+		let hasEntry = false;
+		return (
+			"chunk " +
+			joinExplicitNewLine(
+				items.filter(item => {
+					switch (item.element) {
+						case "entry":
+							if (item.content) hasEntry = true;
+							break;
+						case "initial":
+							if (hasEntry) return false;
+							break;
 					}
+					return true;
+				}),
+				"  "
+			)
+		);
+	},
+	"chunk.childrenByOrder[]": items => `(${joinOneLine(items)})`,
+	chunkGroup: items => joinExplicitNewLine(items, "  "),
+	chunkGroupAsset: joinOneLine,
+	chunkGroupChildGroup: joinOneLine,
+	chunkGroupChild: joinOneLine,
+	// moduleReason: (items, { moduleReason }) => {
+	// 	let hasName = false;
+	// 	return joinOneLine(
+	// 		items.filter(item => {
+	// 			switch (item.element) {
+	// 				case "moduleId":
+	// 					if (moduleReason.moduleId === moduleReason.module && item.content)
+	// 						hasName = true;
+	// 					break;
+	// 				case "module":
+	// 					if (hasName) return false;
+	// 					break;
+	// 				case "resolvedModule":
+	// 					return (
+	// 						moduleReason.module !== moduleReason.resolvedModule &&
+	// 						item.content
+	// 					);
+	// 			}
+	// 			return true;
+	// 		})
+	// 	);
+	// },
+	moduleReason: (items, { moduleReason }) => {
+		let hasName = false;
+		return joinExplicitNewLine(
+			items.map(item => {
+				switch (item.element) {
+					case "moduleId":
+						if (moduleReason.moduleId === moduleReason.module && item.content)
+							hasName = true;
+						break;
+					case "module":
+						if (hasName) return false;
+						break;
+					case "resolvedModule":
+						if (moduleReason.module === moduleReason.resolvedModule)
+							return false;
+						break;
+					case "children":
+						if (item.content) {
+							return {
+								...item,
+								content: `\n${item.content}\n`
+							};
+						}
+						break;
 				}
-			}
-			groupMap.delete(bestGroup);
-
-			const key = bestGroup.name;
-			const groupConfig = bestGroup.config;
-
-			const allItems = Array.from(items, ({ item }) => item);
+				return item;
+			}),
+			"  "
+		);
+	},
+	"module.profile": joinInBrackets,
+	moduleIssuer: joinOneLine,
+	chunkOrigin: items => "> " + joinOneLine(items),
+	"errors[].error": joinError(true),
+	"warnings[].error": joinError(false),
+	loggingGroup: items => joinExplicitNewLine(items, "").trimRight(),
+	moduleTraceItem: items => " @ " + joinOneLine(items),
+	moduleTraceDependency: joinOneLine
+};
 
-			bestGroup.alreadyGrouped = true;
-			const children = groupChildren ? runGrouping(items) : allItems;
-			bestGroup.alreadyGrouped = false;
+const AVAILABLE_COLORS = {
+	bold: "\u001b[1m",
+	yellow: "\u001b[1m\u001b[33m",
+	red: "\u001b[1m\u001b[31m",
+	green: "\u001b[1m\u001b[32m",
+	cyan: "\u001b[1m\u001b[36m",
+	magenta: "\u001b[1m\u001b[35m"
+};
 
-			results.push(groupConfig.createGroup(key, children, allItems));
+const AVAILABLE_FORMATS = {
+	formatChunkId: (id, { yellow }, direction) => {
+		switch (direction) {
+			case "parent":
+				return `<{${yellow(id)}}>`;
+			case "sibling":
+				return `={${yellow(id)}}=`;
+			case "child":
+				return `>{${yellow(id)}}<`;
+			default:
+				return `{${yellow(id)}}`;
 		}
-		for (const { item } of itemsWithGroups) {
-			results.push(item);
+	},
+	formatModuleId: id => `[${id}]`,
+	formatFilename: (filename, { green, yellow }, oversize) =>
+		(oversize ? yellow : green)(filename),
+	formatFlag: flag => `[${flag}]`,
+	formatLayer: layer => `(in ${layer})`,
+	formatSize: (__webpack_require__(71070).formatSize),
+	formatDateTime: (dateTime, { bold }) => {
+		const d = new Date(dateTime);
+		const x = twoDigit;
+		const date = `${d.getFullYear()}-${x(d.getMonth() + 1)}-${x(d.getDate())}`;
+		const time = `${x(d.getHours())}:${x(d.getMinutes())}:${x(d.getSeconds())}`;
+		return `${date} ${bold(time)}`;
+	},
+	formatTime: (
+		time,
+		{ timeReference, bold, green, yellow, red },
+		boldQuantity
+	) => {
+		const unit = " ms";
+		if (timeReference && time !== timeReference) {
+			const times = [
+				timeReference / 2,
+				timeReference / 4,
+				timeReference / 8,
+				timeReference / 16
+			];
+			if (time < times[3]) return `${time}${unit}`;
+			else if (time < times[2]) return bold(`${time}${unit}`);
+			else if (time < times[1]) return green(`${time}${unit}`);
+			else if (time < times[0]) return yellow(`${time}${unit}`);
+			else return red(`${time}${unit}`);
+		} else {
+			return `${boldQuantity ? bold(time) : time}${unit}`;
 		}
-		return results;
-	};
-	return runGrouping(itemsWithGroups);
+	},
+	formatError: (message, { green, yellow, red }) => {
+		if (message.includes("\u001b[")) return message;
+		const highlights = [
+			{ regExp: /(Did you mean .+)/g, format: green },
+			{
+				regExp: /(Set 'mode' option to 'development' or 'production')/g,
+				format: green
+			},
+			{ regExp: /(\(module has no exports\))/g, format: red },
+			{ regExp: /\(possible exports: (.+)\)/g, format: green },
+			{ regExp: /(?:^|\n)(.* doesn't exist)/g, format: red },
+			{ regExp: /('\w+' option has not been set)/g, format: red },
+			{
+				regExp: /(Emitted value instead of an instance of Error)/g,
+				format: yellow
+			},
+			{ regExp: /(Used? .+ instead)/gi, format: yellow },
+			{ regExp: /\b(deprecated|must|required)\b/g, format: yellow },
+			{
+				regExp: /\b(BREAKING CHANGE)\b/gi,
+				format: red
+			},
+			{
+				regExp:
+					/\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
+				format: red
+			}
+		];
+		for (const { regExp, format } of highlights) {
+			message = message.replace(regExp, (match, content) => {
+				return match.replace(content, format(content));
+			});
+		}
+		return message;
+	}
 };
 
-module.exports = smartGrouping;
-
-
-/***/ }),
-
-/***/ 41245:
-/***/ (function(__unused_webpack_module, exports) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const RESULT_MODIFIER = {
+	"module.modules": result => {
+		return indent(result, "| ");
+	}
+};
 
+const createOrder = (array, preferredOrder) => {
+	const originalArray = array.slice();
+	const set = new Set(array);
+	const usedSet = new Set();
+	array.length = 0;
+	for (const element of preferredOrder) {
+		if (element.endsWith("!") || set.has(element)) {
+			array.push(element);
+			usedSet.add(element);
+		}
+	}
+	for (const element of originalArray) {
+		if (!usedSet.has(element)) {
+			array.push(element);
+		}
+	}
+	return array;
+};
 
+class DefaultStatsPrinterPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("DefaultStatsPrinterPlugin", compilation => {
+			compilation.hooks.statsPrinter.tap(
+				"DefaultStatsPrinterPlugin",
+				(stats, options, context) => {
+					// Put colors into context
+					stats.hooks.print
+						.for("compilation")
+						.tap("DefaultStatsPrinterPlugin", (compilation, context) => {
+							for (const color of Object.keys(AVAILABLE_COLORS)) {
+								let start;
+								if (options.colors) {
+									if (
+										typeof options.colors === "object" &&
+										typeof options.colors[color] === "string"
+									) {
+										start = options.colors[color];
+									} else {
+										start = AVAILABLE_COLORS[color];
+									}
+								}
+								if (start) {
+									context[color] = str =>
+										`${start}${
+											typeof str === "string"
+												? str.replace(
+														/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
+														`$1${start}`
+												  )
+												: str
+										}\u001b[39m\u001b[22m`;
+								} else {
+									context[color] = str => str;
+								}
+							}
+							for (const format of Object.keys(AVAILABLE_FORMATS)) {
+								context[format] = (content, ...args) =>
+									AVAILABLE_FORMATS[format](content, context, ...args);
+							}
+							context.timeReference = compilation.time;
+						});
 
-/** @typedef {import("webpack-sources").Source} Source */
+					for (const key of Object.keys(SIMPLE_PRINTERS)) {
+						stats.hooks.print
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
+								SIMPLE_PRINTERS[key](obj, ctx, stats)
+							);
+					}
 
-/** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
-const equalityCache = new WeakMap();
+					for (const key of Object.keys(PREFERRED_ORDERS)) {
+						const preferredOrder = PREFERRED_ORDERS[key];
+						stats.hooks.sortElements
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", (elements, context) => {
+								createOrder(elements, preferredOrder);
+							});
+					}
 
-/**
- * @param {Source} a a source
- * @param {Source} b another source
- * @returns {boolean} true, when both sources are equal
- */
-const _isSourceEqual = (a, b) => {
-	// prefer .buffer(), it's called anyway during emit
-	/** @type {Buffer|string} */
-	let aSource = typeof a.buffer === "function" ? a.buffer() : a.source();
-	/** @type {Buffer|string} */
-	let bSource = typeof b.buffer === "function" ? b.buffer() : b.source();
-	if (aSource === bSource) return true;
-	if (typeof aSource === "string" && typeof bSource === "string") return false;
-	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf-8");
-	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf-8");
-	return aSource.equals(bSource);
-};
+					for (const key of Object.keys(ITEM_NAMES)) {
+						const itemName = ITEM_NAMES[key];
+						stats.hooks.getItemName
+							.for(key)
+							.tap(
+								"DefaultStatsPrinterPlugin",
+								typeof itemName === "string" ? () => itemName : itemName
+							);
+					}
 
-/**
- * @param {Source} a a source
- * @param {Source} b another source
- * @returns {boolean} true, when both sources are equal
- */
-const isSourceEqual = (a, b) => {
-	if (a === b) return true;
-	const cache1 = equalityCache.get(a);
-	if (cache1 !== undefined) {
-		const result = cache1.get(b);
-		if (result !== undefined) return result;
-	}
-	const result = _isSourceEqual(a, b);
-	if (cache1 !== undefined) {
-		cache1.set(b, result);
-	} else {
-		const map = new WeakMap();
-		map.set(b, result);
-		equalityCache.set(a, map);
-	}
-	const cache2 = equalityCache.get(b);
-	if (cache2 !== undefined) {
-		cache2.set(a, result);
-	} else {
-		const map = new WeakMap();
-		map.set(a, result);
-		equalityCache.set(b, map);
+					for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
+						const joiner = SIMPLE_ITEMS_JOINER[key];
+						stats.hooks.printItems
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", joiner);
+					}
+
+					for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
+						const joiner = SIMPLE_ELEMENT_JOINERS[key];
+						stats.hooks.printElements
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", joiner);
+					}
+
+					for (const key of Object.keys(RESULT_MODIFIER)) {
+						const modifier = RESULT_MODIFIER[key];
+						stats.hooks.result
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", modifier);
+					}
+				}
+			);
+		});
 	}
-	return result;
-};
-exports.isSourceEqual = isSourceEqual;
+}
+module.exports = DefaultStatsPrinterPlugin;
 
 
 /***/ }),
 
-/***/ 12047:
+/***/ 92629:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -129545,265 +127777,296 @@ exports.isSourceEqual = isSourceEqual;
 
 
 
-const { validate } = __webpack_require__(38476);
+const { HookMap, SyncBailHook, SyncWaterfallHook } = __webpack_require__(41242);
+const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
+const smartGrouping = __webpack_require__(15652);
 
-/* cSpell:disable */
-const DID_YOU_MEAN = {
-	rules: "module.rules",
-	loaders: "module.rules or module.rules.*.use",
-	query: "module.rules.*.options (BREAKING CHANGE since webpack 5)",
-	noParse: "module.noParse",
-	filename: "output.filename or module.rules.*.generator.filename",
-	file: "output.filename",
-	chunkFilename: "output.chunkFilename",
-	chunkfilename: "output.chunkFilename",
-	ecmaVersion:
-		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	ecmaversion:
-		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	ecma: "output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	path: "output.path",
-	pathinfo: "output.pathinfo",
-	pathInfo: "output.pathinfo",
-	jsonpFunction: "output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
-	chunkCallbackName:
-		"output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
-	jsonpScriptType: "output.scriptType (BREAKING CHANGE since webpack 5)",
-	hotUpdateFunction: "output.hotUpdateGlobal (BREAKING CHANGE since webpack 5)",
-	splitChunks: "optimization.splitChunks",
-	immutablePaths: "snapshot.immutablePaths",
-	managedPaths: "snapshot.managedPaths",
-	maxModules: "stats.modulesSpace (BREAKING CHANGE since webpack 5)",
-	hashedModuleIds:
-		'optimization.moduleIds: "hashed" (BREAKING CHANGE since webpack 5)',
-	namedChunks:
-		'optimization.chunkIds: "named" (BREAKING CHANGE since webpack 5)',
-	namedModules:
-		'optimization.moduleIds: "named" (BREAKING CHANGE since webpack 5)',
-	occurrenceOrder:
-		'optimization.chunkIds: "size" and optimization.moduleIds: "size" (BREAKING CHANGE since webpack 5)',
-	automaticNamePrefix:
-		"optimization.splitChunks.[cacheGroups.*].idHint (BREAKING CHANGE since webpack 5)",
-	noEmitOnErrors:
-		"optimization.emitOnErrors (BREAKING CHANGE since webpack 5: logic is inverted to avoid negative flags)",
-	Buffer:
-		"to use the ProvidePlugin to process the Buffer variable to modules as polyfill\n" +
-		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
-		"Note: if you are using 'node.Buffer: false', you can just remove that as this is the default behavior now.\n" +
-		"To provide a polyfill to modules use:\n" +
-		'new ProvidePlugin({ Buffer: ["buffer", "Buffer"] }) and npm install buffer.',
-	process:
-		"to use the ProvidePlugin to process the process variable to modules as polyfill\n" +
-		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
-		"Note: if you are using 'node.process: false', you can just remove that as this is the default behavior now.\n" +
-		"To provide a polyfill to modules use:\n" +
-		'new ProvidePlugin({ process: "process" }) and npm install buffer.'
-};
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const REMOVED = {
-	concord:
-		"BREAKING CHANGE: resolve.concord has been removed and is no longer available.",
-	devtoolLineToLine:
-		"BREAKING CHANGE: output.devtoolLineToLine has been removed and is no longer available."
-};
-/* cSpell:enable */
+/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
 
 /**
- * @param {Parameters<typeof validate>[0]} schema a json schema
- * @param {Parameters<typeof validate>[1]} options the options that should be validated
- * @param {Parameters<typeof validate>[2]=} validationConfiguration configuration for generating errors
- * @returns {void}
+ * @typedef {Object} KnownStatsFactoryContext
+ * @property {string} type
+ * @property {function(string): string=} makePathsRelative
+ * @property {Compilation=} compilation
+ * @property {Set<Module>=} rootModules
+ * @property {Map<string,Chunk[]>=} compilationFileToChunks
+ * @property {Map<string,Chunk[]>=} compilationAuxiliaryFileToChunks
+ * @property {RuntimeSpec=} runtime
+ * @property {function(Compilation): WebpackError[]=} cachedGetErrors
+ * @property {function(Compilation): WebpackError[]=} cachedGetWarnings
  */
-const validateSchema = (schema, options, validationConfiguration) => {
-	validate(
-		schema,
-		options,
-		validationConfiguration || {
-			name: "Webpack",
-			postFormatter: (formattedError, error) => {
-				const children = error.children;
-				if (
-					children &&
-					children.some(
-						child =>
-							child.keyword === "absolutePath" &&
-							child.dataPath === ".output.filename"
-					)
-				) {
-					return `${formattedError}\nPlease use output.path to specify absolute path and output.filename for the file name.`;
-				}
 
-				if (
-					children &&
-					children.some(
-						child =>
-							child.keyword === "pattern" && child.dataPath === ".devtool"
-					)
-				) {
-					return (
-						`${formattedError}\n` +
-						"BREAKING CHANGE since webpack 5: The devtool option is more strict.\n" +
-						"Please strictly follow the order of the keywords in the pattern."
-					);
-				}
+/** @typedef {KnownStatsFactoryContext & Record<string, any>} StatsFactoryContext */
 
-				if (error.keyword === "additionalProperties") {
-					const params =
-						/** @type {import("ajv").AdditionalPropertiesParams} */ (
-							error.params
-						);
-					if (
-						Object.prototype.hasOwnProperty.call(
-							DID_YOU_MEAN,
-							params.additionalProperty
-						)
-					) {
-						return `${formattedError}\nDid you mean ${
-							DID_YOU_MEAN[params.additionalProperty]
-						}?`;
-					}
+class StatsFactory {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[Object, any, StatsFactoryContext]>>} */
+			extract: new HookMap(
+				() => new SyncBailHook(["object", "data", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
+			filter: new HookMap(
+				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
+			),
+			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
+			sort: new HookMap(() => new SyncBailHook(["comparators", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
+			filterSorted: new HookMap(
+				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
+			),
+			/** @type {HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext]>>} */
+			groupResults: new HookMap(
+				() => new SyncBailHook(["groupConfigs", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
+			sortResults: new HookMap(
+				() => new SyncBailHook(["comparators", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
+			filterResults: new HookMap(
+				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
+			),
+			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
+			merge: new HookMap(() => new SyncBailHook(["items", "context"])),
+			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
+			result: new HookMap(() => new SyncWaterfallHook(["result", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
+			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
+			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
+		});
+		const hooks = this.hooks;
+		this._caches =
+			/** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
+		for (const key of Object.keys(hooks)) {
+			this._caches[key] = new Map();
+		}
+		this._inCreate = false;
+	}
 
-					if (
-						Object.prototype.hasOwnProperty.call(
-							REMOVED,
-							params.additionalProperty
-						)
-					) {
-						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
-					}
+	_getAllLevelHooks(hookMap, cache, type) {
+		const cacheEntry = cache.get(type);
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
+		const hooks = [];
+		const typeParts = type.split(".");
+		for (let i = 0; i < typeParts.length; i++) {
+			const hook = hookMap.get(typeParts.slice(i).join("."));
+			if (hook) {
+				hooks.push(hook);
+			}
+		}
+		cache.set(type, hooks);
+		return hooks;
+	}
 
-					if (!error.dataPath) {
-						if (params.additionalProperty === "debug") {
-							return (
-								`${formattedError}\n` +
-								"The 'debug' property was removed in webpack 2.0.0.\n" +
-								"Loaders should be updated to allow passing this option via loader options in module.rules.\n" +
-								"Until loaders are updated one can use the LoaderOptionsPlugin to switch loaders into debug mode:\n" +
-								"plugins: [\n" +
-								"  new webpack.LoaderOptionsPlugin({\n" +
-								"    debug: true\n" +
-								"  })\n" +
-								"]"
-							);
-						}
+	_forEachLevel(hookMap, cache, type, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
+			const result = fn(hook);
+			if (result !== undefined) return result;
+		}
+	}
 
-						if (params.additionalProperty) {
-							return (
-								`${formattedError}\n` +
-								"For typos: please correct them.\n" +
-								"For loader options: webpack >= v2.0.0 no longer allows custom properties in configuration.\n" +
-								"  Loaders should be updated to allow passing options via loader options in module.rules.\n" +
-								"  Until loaders are updated one can use the LoaderOptionsPlugin to pass these options to the loader:\n" +
-								"  plugins: [\n" +
-								"    new webpack.LoaderOptionsPlugin({\n" +
-								"      // test: /\\.xxx$/, // may apply this only for some modules\n" +
-								"      options: {\n" +
-								`        ${params.additionalProperty}: …\n` +
-								"      }\n" +
-								"    })\n" +
-								"  ]"
-							);
-						}
-					}
+	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
+			data = fn(hook, data);
+		}
+		return data;
+	}
+
+	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
+		const hooks = this._getAllLevelHooks(hookMap, cache, type);
+		if (hooks.length === 0) return forceClone ? items.slice() : items;
+		let i = 0;
+		return items.filter((item, idx) => {
+			for (const hook of hooks) {
+				const r = fn(hook, item, idx, i);
+				if (r !== undefined) {
+					if (r) i++;
+					return r;
 				}
+			}
+			i++;
+			return true;
+		});
+	}
 
-				return formattedError;
+	/**
+	 * @param {string} type type
+	 * @param {any} data factory data
+	 * @param {Omit<StatsFactoryContext, "type">} baseContext context used as base
+	 * @returns {any} created object
+	 */
+	create(type, data, baseContext) {
+		if (this._inCreate) {
+			return this._create(type, data, baseContext);
+		} else {
+			try {
+				this._inCreate = true;
+				return this._create(type, data, baseContext);
+			} finally {
+				for (const key of Object.keys(this._caches)) this._caches[key].clear();
+				this._inCreate = false;
 			}
 		}
-	);
-};
-module.exports = validateSchema;
+	}
 
+	_create(type, data, baseContext) {
+		const context = {
+			...baseContext,
+			type,
+			[type]: data
+		};
+		if (Array.isArray(data)) {
+			// run filter on unsorted items
+			const items = this._forEachLevelFilter(
+				this.hooks.filter,
+				this._caches.filter,
+				type,
+				data,
+				(h, r, idx, i) => h.call(r, context, idx, i),
+				true
+			);
 
-/***/ }),
+			// sort items
+			const comparators = [];
+			this._forEachLevel(this.hooks.sort, this._caches.sort, type, h =>
+				h.call(comparators, context)
+			);
+			if (comparators.length > 0) {
+				items.sort(
+					// @ts-expect-error number of arguments is correct
+					concatComparators(...comparators, keepOriginalOrder(items))
+				);
+			}
 
-/***/ 5434:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			// run filter on sorted items
+			const items2 = this._forEachLevelFilter(
+				this.hooks.filterSorted,
+				this._caches.filterSorted,
+				type,
+				items,
+				(h, r, idx, i) => h.call(r, context, idx, i),
+				false
+			);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			// for each item
+			let resultItems = items2.map((item, i) => {
+				const itemContext = {
+					...context,
+					_index: i
+				};
 
+				// run getItemName
+				const itemName = this._forEachLevel(
+					this.hooks.getItemName,
+					this._caches.getItemName,
+					`${type}[]`,
+					h => h.call(item, itemContext)
+				);
+				if (itemName) itemContext[itemName] = item;
+				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
 
+				// run getItemFactory
+				const itemFactory =
+					this._forEachLevel(
+						this.hooks.getItemFactory,
+						this._caches.getItemFactory,
+						innerType,
+						h => h.call(item, itemContext)
+					) || this;
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
+				// run item factory
+				return itemFactory.create(innerType, item, itemContext);
+			});
 
-class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
-	constructor({ generateLoadBinaryCode, supportsStreaming }) {
-		super("wasm loading", RuntimeModule.STAGE_NORMAL);
-		this.generateLoadBinaryCode = generateLoadBinaryCode;
-		this.supportsStreaming = supportsStreaming;
-	}
+			// sort result items
+			const comparators2 = [];
+			this._forEachLevel(
+				this.hooks.sortResults,
+				this._caches.sortResults,
+				type,
+				h => h.call(comparators2, context)
+			);
+			if (comparators2.length > 0) {
+				resultItems.sort(
+					// @ts-expect-error number of arguments is correct
+					concatComparators(...comparators2, keepOriginalOrder(resultItems))
+				);
+			}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, chunk } = this;
-		const { outputOptions, runtimeTemplate } = compilation;
-		const fn = RuntimeGlobals.instantiateWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: `" + wasmModuleHash + "`,
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
+			// group result items
+			const groupConfigs = [];
+			this._forEachLevel(
+				this.hooks.groupResults,
+				this._caches.groupResults,
+				type,
+				h => h.call(groupConfigs, context)
+			);
+			if (groupConfigs.length > 0) {
+				resultItems = smartGrouping(resultItems, groupConfigs);
 			}
-		);
-		return `${fn} = ${runtimeTemplate.basicFunction(
-			"exports, wasmModuleId, wasmModuleHash, importsObj",
-			[
-				`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
-				this.supportsStreaming
-					? Template.asString([
-							"if (typeof WebAssembly.instantiateStreaming === 'function') {",
-							Template.indent([
-								"return WebAssembly.instantiateStreaming(req, importsObj)",
-								Template.indent([
-									`.then(${runtimeTemplate.returningFunction(
-										"Object.assign(exports, res.instance.exports)",
-										"res"
-									)});`
-								])
-							]),
-							"}"
-					  ])
-					: "// no support for streaming compilation",
-				"return req",
-				Template.indent([
-					`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"WebAssembly.instantiate(bytes, importsObj)",
-						"bytes"
-					)})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"Object.assign(exports, res.instance.exports)",
-						"res"
-					)});`
-				])
-			]
-		)};`;
+
+			// run filter on sorted result items
+			const finalResultItems = this._forEachLevelFilter(
+				this.hooks.filterResults,
+				this._caches.filterResults,
+				type,
+				resultItems,
+				(h, r, idx, i) => h.call(r, context, idx, i),
+				false
+			);
+
+			// run merge on mapped items
+			let result = this._forEachLevel(
+				this.hooks.merge,
+				this._caches.merge,
+				type,
+				h => h.call(finalResultItems, context)
+			);
+			if (result === undefined) result = finalResultItems;
+
+			// run result on merged items
+			return this._forEachLevelWaterfall(
+				this.hooks.result,
+				this._caches.result,
+				type,
+				result,
+				(h, r) => h.call(r, context)
+			);
+		} else {
+			const object = {};
+
+			// run extract on value
+			this._forEachLevel(this.hooks.extract, this._caches.extract, type, h =>
+				h.call(object, data, context)
+			);
+
+			// run result on extracted object
+			return this._forEachLevelWaterfall(
+				this.hooks.result,
+				this._caches.result,
+				type,
+				object,
+				(h, r) => h.call(r, context)
+			);
+		}
 	}
 }
-
-module.exports = AsyncWasmLoadingRuntimeModule;
+module.exports = StatsFactory;
 
 
 /***/ }),
 
-/***/ 58461:
+/***/ 30198:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -129814,58 +128077,254 @@ module.exports = AsyncWasmLoadingRuntimeModule;
 
 
 
-const Generator = __webpack_require__(93401);
+const { HookMap, SyncWaterfallHook, SyncBailHook } = __webpack_require__(41242);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("tapable").Hook} Hook */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
 
-const TYPES = new Set(["webassembly"]);
+/**
+ * @typedef {Object} PrintedElement
+ * @property {string} element
+ * @property {string} content
+ */
 
-class AsyncWebAssemblyGenerator extends Generator {
-	constructor(options) {
-		super();
-		this.options = options;
+/**
+ * @typedef {Object} KnownStatsPrinterContext
+ * @property {string=} type
+ * @property {StatsCompilation=} compilation
+ * @property {StatsChunkGroup=} chunkGroup
+ * @property {StatsAsset=} asset
+ * @property {StatsModule=} module
+ * @property {StatsChunk=} chunk
+ * @property {StatsModuleReason=} moduleReason
+ * @property {(str: string) => string=} bold
+ * @property {(str: string) => string=} yellow
+ * @property {(str: string) => string=} red
+ * @property {(str: string) => string=} green
+ * @property {(str: string) => string=} magenta
+ * @property {(str: string) => string=} cyan
+ * @property {(file: string, oversize?: boolean) => string=} formatFilename
+ * @property {(id: string) => string=} formatModuleId
+ * @property {(id: string, direction?: "parent"|"child"|"sibling") => string=} formatChunkId
+ * @property {(size: number) => string=} formatSize
+ * @property {(dateTime: number) => string=} formatDateTime
+ * @property {(flag: string) => string=} formatFlag
+ * @property {(time: number, boldQuantity?: boolean) => string=} formatTime
+ * @property {string=} chunkGroupKind
+ */
+
+/** @typedef {KnownStatsPrinterContext & Record<string, any>} StatsPrinterContext */
+
+class StatsPrinter {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], true>>} */
+			sortElements: new HookMap(
+				() => new SyncBailHook(["elements", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string>>} */
+			printElements: new HookMap(
+				() => new SyncBailHook(["printedElements", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>} */
+			sortItems: new HookMap(() => new SyncBailHook(["items", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsPrinterContext], string>>} */
+			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
+			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>} */
+			printItems: new HookMap(
+				() => new SyncBailHook(["printedItems", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>} */
+			print: new HookMap(() => new SyncBailHook(["object", "context"])),
+			/** @type {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} */
+			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
+		});
+		/** @type {Map<HookMap<Hook>, Map<string, Hook[]>>} */
+		this._levelHookCache = new Map();
+		this._inPrint = false;
 	}
 
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * get all level hooks
+	 * @private
+	 * @template {Hook} T
+	 * @param {HookMap<T>} hookMap HookMap
+	 * @param {string} type type
+	 * @returns {T[]} hooks
 	 */
-	getTypes(module) {
-		return TYPES;
+	_getAllLevelHooks(hookMap, type) {
+		let cache = /** @type {Map<string, T[]>} */ (
+			this._levelHookCache.get(hookMap)
+		);
+		if (cache === undefined) {
+			cache = new Map();
+			this._levelHookCache.set(hookMap, cache);
+		}
+		const cacheEntry = cache.get(type);
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
+		/** @type {T[]} */
+		const hooks = [];
+		const typeParts = type.split(".");
+		for (let i = 0; i < typeParts.length; i++) {
+			const hook = hookMap.get(typeParts.slice(i).join("."));
+			if (hook) {
+				hooks.push(hook);
+			}
+		}
+		cache.set(type, hooks);
+		return hooks;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * Run `fn` for each level
+	 * @private
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap HookMap
+	 * @param {string} type type
+	 * @param {(hook: SyncBailHook<T, R>) => R} fn function
+	 * @returns {R} result of `fn`
 	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 0;
+	_forEachLevel(hookMap, type, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, type)) {
+			const result = fn(hook);
+			if (result !== undefined) return result;
 		}
-		return originalSource.size();
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Run `fn` for each level
+	 * @private
+	 * @template T
+	 * @param {HookMap<SyncWaterfallHook<T>>} hookMap HookMap
+	 * @param {string} type type
+	 * @param {AsArray<T>[0]} data data
+	 * @param {(hook: SyncWaterfallHook<T>, data: AsArray<T>[0]) => AsArray<T>[0]} fn function
+	 * @returns {AsArray<T>[0]} result of `fn`
 	 */
-	generate(module, generateContext) {
-		return module.originalSource();
+	_forEachLevelWaterfall(hookMap, type, data, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, type)) {
+			data = fn(hook, data);
+		}
+		return data;
 	}
-}
 
-module.exports = AsyncWebAssemblyGenerator;
+	/**
+	 * @param {string} type The type
+	 * @param {Object} object Object to print
+	 * @param {Object=} baseContext The base context
+	 * @returns {string} printed result
+	 */
+	print(type, object, baseContext) {
+		if (this._inPrint) {
+			return this._print(type, object, baseContext);
+		} else {
+			try {
+				this._inPrint = true;
+				return this._print(type, object, baseContext);
+			} finally {
+				this._levelHookCache.clear();
+				this._inPrint = false;
+			}
+		}
+	}
+
+	/**
+	 * @private
+	 * @param {string} type type
+	 * @param {Object} object object
+	 * @param {Object=} baseContext context
+	 * @returns {string} printed result
+	 */
+	_print(type, object, baseContext) {
+		const context = {
+			...baseContext,
+			type,
+			[type]: object
+		};
+
+		let printResult = this._forEachLevel(this.hooks.print, type, hook =>
+			hook.call(object, context)
+		);
+		if (printResult === undefined) {
+			if (Array.isArray(object)) {
+				const sortedItems = object.slice();
+				this._forEachLevel(this.hooks.sortItems, type, h =>
+					h.call(sortedItems, context)
+				);
+				const printedItems = sortedItems.map((item, i) => {
+					const itemContext = {
+						...context,
+						_index: i
+					};
+					const itemName = this._forEachLevel(
+						this.hooks.getItemName,
+						`${type}[]`,
+						h => h.call(item, itemContext)
+					);
+					if (itemName) itemContext[itemName] = item;
+					return this.print(
+						itemName ? `${type}[].${itemName}` : `${type}[]`,
+						item,
+						itemContext
+					);
+				});
+				printResult = this._forEachLevel(this.hooks.printItems, type, h =>
+					h.call(printedItems, context)
+				);
+				if (printResult === undefined) {
+					const result = printedItems.filter(Boolean);
+					if (result.length > 0) printResult = result.join("\n");
+				}
+			} else if (object !== null && typeof object === "object") {
+				const elements = Object.keys(object).filter(
+					key => object[key] !== undefined
+				);
+				this._forEachLevel(this.hooks.sortElements, type, h =>
+					h.call(elements, context)
+				);
+				const printedElements = elements.map(element => {
+					const content = this.print(`${type}.${element}`, object[element], {
+						...context,
+						_parent: object,
+						_element: element,
+						[element]: object[element]
+					});
+					return { element, content };
+				});
+				printResult = this._forEachLevel(this.hooks.printElements, type, h =>
+					h.call(printedElements, context)
+				);
+				if (printResult === undefined) {
+					const result = printedElements.map(e => e.content).filter(Boolean);
+					if (result.length > 0) printResult = result.join("\n");
+				}
+			}
+		}
+
+		return this._forEachLevelWaterfall(
+			this.hooks.result,
+			type,
+			printResult,
+			(h, r) => h.call(r, context)
+		);
+	}
+}
+module.exports = StatsPrinter;
 
 
 /***/ }),
 
-/***/ 95614:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 84953:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -129875,198 +128334,167 @@ module.exports = AsyncWebAssemblyGenerator;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+/**
+ * Compare two arrays or strings by performing strict equality check for each value.
+ * @template T [T=any]
+ * @param {ArrayLike<T>} a Array of values to be compared
+ * @param {ArrayLike<T>} b Array of values to be compared
+ * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
+ */
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+exports.equals = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false;
+	}
+	return true;
+};
 
-const TYPES = new Set(["webassembly"]);
+/**
+ * Partition an array by calling a predicate function on each value.
+ * @template T [T=any]
+ * @param {Array<T>} arr Array of values to be partitioned
+ * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
+ * @returns {[Array<T>, Array<T>]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
+ */
+exports.groupBy = (arr = [], fn) => {
+	return arr.reduce(
+		/**
+		 * @param {[Array<T>, Array<T>]} groups An accumulator storing already partitioned values returned from previous call.
+		 * @param {T} value The value of the current element
+		 * @returns {[Array<T>, Array<T>]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
+		 */
+		(groups, value) => {
+			groups[fn(value) ? 0 : 1].push(value);
+			return groups;
+		},
+		[[], []]
+	);
+};
 
-class AsyncWebAssemblyJavascriptGenerator extends Generator {
-	constructor(filenameTemplate) {
-		super();
-		this.filenameTemplate = filenameTemplate;
-	}
 
+/***/ }),
+
+/***/ 41792:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/**
+ * @template T
+ */
+class ArrayQueue {
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {Iterable<T>=} items The initial elements.
 	 */
-	getTypes(module) {
-		return TYPES;
+	constructor(items) {
+		/** @private @type {T[]} */
+		this._list = items ? Array.from(items) : [];
+		/** @private @type {T[]} */
+		this._listReversed = [];
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
 	 */
-	getSize(module, type) {
-		return 40 + module.dependencies.length * 10;
+	get length() {
+		return this._list.length + this._listReversed.length;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Empties the queue.
 	 */
-	generate(module, generateContext) {
-		const {
-			runtimeTemplate,
-			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
-			runtime
-		} = generateContext;
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment[]} */
-		const initFragments = [];
-		/** @type {Map<Module, { request: string, importVar: string }>} */
-		const depModules = new Map();
-		/** @type {Map<string, WebAssemblyImportDependency[]>} */
-		const wasmDepsByRequest = new Map();
-		for (const dep of module.dependencies) {
-			if (dep instanceof WebAssemblyImportDependency) {
-				const module = moduleGraph.getModule(dep);
-				if (!depModules.has(module)) {
-					depModules.set(module, {
-						request: dep.request,
-						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
-					});
-				}
-				let list = wasmDepsByRequest.get(dep.request);
-				if (list === undefined) {
-					list = [];
-					wasmDepsByRequest.set(dep.request, list);
-				}
-				list.push(dep);
-			}
-		}
-
-		const promises = [];
-
-		const importStatements = Array.from(
-			depModules,
-			([importedModule, { request, importVar }]) => {
-				if (moduleGraph.isAsync(importedModule)) {
-					promises.push(importVar);
-				}
-				return runtimeTemplate.importStatement({
-					update: false,
-					module: importedModule,
-					chunkGraph,
-					request,
-					originModule: module,
-					importVar,
-					runtimeRequirements
-				});
-			}
-		);
-		const importsCode = importStatements.map(([x]) => x).join("");
-		const importsCompatCode = importStatements.map(([_, x]) => x).join("");
-
-		const importObjRequestItems = Array.from(
-			wasmDepsByRequest,
-			([request, deps]) => {
-				const exportItems = deps.map(dep => {
-					const importedModule = moduleGraph.getModule(dep);
-					const importVar = depModules.get(importedModule).importVar;
-					return `${JSON.stringify(
-						dep.name
-					)}: ${runtimeTemplate.exportFromImport({
-						moduleGraph,
-						module: importedModule,
-						request,
-						exportName: dep.name,
-						originModule: module,
-						asiSafe: true,
-						isCall: false,
-						callContext: false,
-						defaultInterop: true,
-						importVar,
-						initFragments,
-						runtime,
-						runtimeRequirements
-					})}`;
-				});
-				return Template.asString([
-					`${JSON.stringify(request)}: {`,
-					Template.indent(exportItems.join(",\n")),
-					"}"
-				]);
-			}
-		);
-
-		const importsObj =
-			importObjRequestItems.length > 0
-				? Template.asString([
-						"{",
-						Template.indent(importObjRequestItems.join(",\n")),
-						"}"
-				  ])
-				: undefined;
+	clear() {
+		this._list.length = 0;
+		this._listReversed.length = 0;
+	}
 
-		const instantiateCall =
-			`${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
-				module.moduleArgument
-			}.id, ${JSON.stringify(
-				chunkGraph.getRenderedModuleHash(module, runtime)
-			)}` + (importsObj ? `, ${importsObj})` : `)`);
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
+	 */
+	enqueue(item) {
+		this._list.push(item);
+	}
 
-		if (promises.length > 0)
-			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+	/**
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 */
+	dequeue() {
+		if (this._listReversed.length === 0) {
+			if (this._list.length === 0) return undefined;
+			if (this._list.length === 1) return this._list.pop();
+			if (this._list.length < 16) return this._list.shift();
+			const temp = this._listReversed;
+			this._listReversed = this._list;
+			this._listReversed.reverse();
+			this._list = temp;
+		}
+		return this._listReversed.pop();
+	}
 
-		const source = new RawSource(
-			promises.length > 0
-				? Template.asString([
-						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
-							`[${promises.join(", ")}]`,
-							`${importsCompatCode}return ${instantiateCall};`
-						)}`,
-						`${RuntimeGlobals.asyncModule}(${
-							module.moduleArgument
-						}, async ${runtimeTemplate.basicFunction(
-							"__webpack_handle_async_dependencies__, __webpack_async_result__",
-							[
-								"try {",
-								importsCode,
-								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
-									", "
-								)}]);`,
-								`var [${promises.join(
-									", "
-								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
-								`${importsCompatCode}await ${instantiateCall};`,
-								"__webpack_async_result__();",
-								"} catch(e) { __webpack_async_result__(e); }"
-							]
-						)}, 1);`
-				  ])
-				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
-		);
+	/**
+	 * Finds and removes an item
+	 * @param {T} item the item
+	 * @returns {void}
+	 */
+	delete(item) {
+		const i = this._list.indexOf(item);
+		if (i >= 0) {
+			this._list.splice(i, 1);
+		} else {
+			const i = this._listReversed.indexOf(item);
+			if (i >= 0) this._listReversed.splice(i, 1);
+		}
+	}
 
-		return InitFragment.addToSource(source, initFragments, generateContext);
+	[Symbol.iterator]() {
+		let i = -1;
+		let reversed = false;
+		return {
+			next: () => {
+				if (!reversed) {
+					i++;
+					if (i < this._list.length) {
+						return {
+							done: false,
+							value: this._list[i]
+						};
+					}
+					reversed = true;
+					i = this._listReversed.length;
+				}
+				i--;
+				if (i < 0) {
+					return {
+						done: true,
+						value: undefined
+					};
+				}
+				return {
+					done: false,
+					value: this._listReversed[i]
+				};
+			}
+		};
 	}
 }
 
-module.exports = AsyncWebAssemblyJavascriptGenerator;
+module.exports = ArrayQueue;
 
 
 /***/ }),
 
-/***/ 7538:
+/***/ 12260:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -130077,689 +128505,474 @@ module.exports = AsyncWebAssemblyJavascriptGenerator;
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(6967);
-const Compilation = __webpack_require__(85720);
-const Generator = __webpack_require__(93401);
-const { tryRunOrWebpackError } = __webpack_require__(11351);
-const WebAssemblyImportDependency = __webpack_require__(5239);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const memoize = __webpack_require__(78676);
+const { SyncHook, AsyncSeriesHook } = __webpack_require__(41242);
+const { makeWebpackError } = __webpack_require__(11351);
+const WebpackError = __webpack_require__(53799);
+const ArrayQueue = __webpack_require__(41792);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
+const QUEUED_STATE = 0;
+const PROCESSING_STATE = 1;
+const DONE_STATE = 2;
 
-const getAsyncWebAssemblyGenerator = memoize(() =>
-	__webpack_require__(58461)
-);
-const getAsyncWebAssemblyJavascriptGenerator = memoize(() =>
-	__webpack_require__(95614)
-);
-const getAsyncWebAssemblyParser = memoize(() =>
-	__webpack_require__(96305)
-);
+let inHandleResult = 0;
 
 /**
- * @typedef {Object} WebAssemblyRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @template T
+ * @callback Callback
+ * @param {(WebpackError | null)=} err
+ * @param {T=} result
  */
 
 /**
- * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
+ * @template T
+ * @template K
+ * @template R
  */
+class AsyncQueueEntry {
+	/**
+	 * @param {T} item the item
+	 * @param {Callback<R>} callback the callback
+	 */
+	constructor(item, callback) {
+		this.item = item;
+		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
+		this.state = QUEUED_STATE;
+		this.callback = callback;
+		/** @type {Callback<R>[] | undefined} */
+		this.callbacks = undefined;
+		this.result = undefined;
+		/** @type {WebpackError | undefined} */
+		this.error = undefined;
+	}
+}
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class AsyncWebAssemblyModulesPlugin {
+/**
+ * @template T
+ * @template K
+ * @template R
+ */
+class AsyncQueue {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
+	 * @param {Object} options options object
+	 * @param {string=} options.name name of the queue
+	 * @param {number=} options.parallelism how many items should be processed at once
+	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
+	 * @param {function(T): K=} options.getKey extract key from item
+	 * @param {function(T, Callback<R>): void} options.processor async function to process items
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				])
-			};
-			compilationHooksMap.set(compilation, hooks);
+	constructor({ name, parallelism, parent, processor, getKey }) {
+		this._name = name;
+		this._parallelism = parallelism || 1;
+		this._processor = processor;
+		this._getKey =
+			getKey || /** @type {(T) => K} */ (item => /** @type {any} */ (item));
+		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
+		this._entries = new Map();
+		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
+		this._queued = new ArrayQueue();
+		/** @type {AsyncQueue<any, any, any>[]} */
+		this._children = undefined;
+		this._activeTasks = 0;
+		this._willEnsureProcessing = false;
+		this._needProcessing = false;
+		this._stopped = false;
+		this._root = parent ? parent._root : this;
+		if (parent) {
+			if (this._root._children === undefined) {
+				this._root._children = [this];
+			} else {
+				this._root._children.push(this);
+			}
 		}
-		return hooks;
-	}
 
-	constructor(options) {
-		this.options = options;
+		this.hooks = {
+			/** @type {AsyncSeriesHook<[T]>} */
+			beforeAdd: new AsyncSeriesHook(["item"]),
+			/** @type {SyncHook<[T]>} */
+			added: new SyncHook(["item"]),
+			/** @type {AsyncSeriesHook<[T]>} */
+			beforeStart: new AsyncSeriesHook(["item"]),
+			/** @type {SyncHook<[T]>} */
+			started: new SyncHook(["item"]),
+			/** @type {SyncHook<[T, Error, R]>} */
+			result: new SyncHook(["item", "error", "result"])
+		};
+
+		this._ensureProcessing = this._ensureProcessing.bind(this);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AsyncWebAssemblyModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const hooks =
-					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
-				compilation.dependencyFactories.set(
-					WebAssemblyImportDependency,
-					normalModuleFactory
+	add(item, callback) {
+		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
+		this.hooks.beforeAdd.callAsync(item, err => {
+			if (err) {
+				callback(
+					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeAdd`)
 				);
-
-				normalModuleFactory.hooks.createParser
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
-						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
-
-						return new AsyncWebAssemblyParser();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
-						const AsyncWebAssemblyJavascriptGenerator =
-							getAsyncWebAssemblyJavascriptGenerator();
-						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
-
-						return Generator.byType({
-							javascript: new AsyncWebAssemblyJavascriptGenerator(
-								compilation.outputOptions.webassemblyModuleFilename
-							),
-							webassembly: new AsyncWebAssemblyGenerator(this.options)
-						});
-					});
-
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
-						const {
-							chunk,
-							outputOptions,
-							dependencyTemplates,
-							codeGenerationResults
-						} = options;
-
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === "webassembly/async") {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
-
-								result.push({
-									render: () =>
-										this.renderModule(
-											module,
-											{
-												chunk,
-												dependencyTemplates,
-												runtimeTemplate,
-												moduleGraph,
-												chunkGraph,
-												codeGenerationResults
-											},
-											hooks
-										),
-									filenameTemplate,
-									pathOptions: {
-										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
-						}
-
-						return result;
+				return;
+			}
+			const key = this._getKey(item);
+			const entry = this._entries.get(key);
+			if (entry !== undefined) {
+				if (entry.state === DONE_STATE) {
+					if (inHandleResult++ > 3) {
+						process.nextTick(() => callback(entry.error, entry.result));
+					} else {
+						callback(entry.error, entry.result);
 					}
+					inHandleResult--;
+				} else if (entry.callbacks === undefined) {
+					entry.callbacks = [callback];
+				} else {
+					entry.callbacks.push(callback);
+				}
+				return;
+			}
+			const newEntry = new AsyncQueueEntry(item, callback);
+			if (this._stopped) {
+				this.hooks.added.call(item);
+				this._root._activeTasks++;
+				process.nextTick(() =>
+					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
 				);
+			} else {
+				this._entries.set(key, newEntry);
+				this._queued.enqueue(newEntry);
+				const root = this._root;
+				root._needProcessing = true;
+				if (root._willEnsureProcessing === false) {
+					root._willEnsureProcessing = true;
+					setImmediate(root._ensureProcessing);
+				}
+				this.hooks.added.call(item);
 			}
-		);
+		});
 	}
 
-	renderModule(module, renderContext, hooks) {
-		const { codeGenerationResults, chunk } = renderContext;
-		try {
-			const moduleSource = codeGenerationResults.getSource(
-				module,
-				chunk.runtime,
-				"webassembly"
-			);
-			return tryRunOrWebpackError(
-				() =>
-					hooks.renderModuleContent.call(moduleSource, module, renderContext),
-				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
-			);
-		} catch (e) {
-			e.module = module;
-			throw e;
+	/**
+	 * @param {T} item an item
+	 * @returns {void}
+	 */
+	invalidate(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		this._entries.delete(key);
+		if (entry.state === QUEUED_STATE) {
+			this._queued.delete(entry);
 		}
 	}
-}
-
-module.exports = AsyncWebAssemblyModulesPlugin;
 
+	/**
+	 * Waits for an already started item
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
+	 * @returns {void}
+	 */
+	waitFor(item, callback) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		if (entry === undefined) {
+			return callback(
+				new WebpackError(
+					"waitFor can only be called for an already started item"
+				)
+			);
+		}
+		if (entry.state === DONE_STATE) {
+			process.nextTick(() => callback(entry.error, entry.result));
+		} else if (entry.callbacks === undefined) {
+			entry.callbacks = [callback];
+		} else {
+			entry.callbacks.push(callback);
+		}
+	}
 
-/***/ }),
-
-/***/ 96305:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+	/**
+	 * @returns {void}
+	 */
+	stop() {
+		this._stopped = true;
+		const queue = this._queued;
+		this._queued = new ArrayQueue();
+		const root = this._root;
+		for (const entry of queue) {
+			this._entries.delete(this._getKey(entry.item));
+			root._activeTasks++;
+			this._handleResult(entry, new WebpackError("Queue was stopped"));
+		}
+	}
 
+	/**
+	 * @returns {void}
+	 */
+	increaseParallelism() {
+		const root = this._root;
+		root._parallelism++;
+		/* istanbul ignore next */
+		if (root._willEnsureProcessing === false && root._needProcessing) {
+			root._willEnsureProcessing = true;
+			setImmediate(root._ensureProcessing);
+		}
+	}
 
-const t = __webpack_require__(51826);
-const { decode } = __webpack_require__(73726);
-const Parser = __webpack_require__(11715);
-const StaticExportsDependency = __webpack_require__(91418);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+	/**
+	 * @returns {void}
+	 */
+	decreaseParallelism() {
+		const root = this._root;
+		root._parallelism--;
+	}
 
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+	/**
+	 * @param {T} item an item
+	 * @returns {boolean} true, if the item is currently being processed
+	 */
+	isProcessing(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		return entry !== undefined && entry.state === PROCESSING_STATE;
+	}
 
-const decoderOpts = {
-	ignoreCodeSection: true,
-	ignoreDataSection: true,
+	/**
+	 * @param {T} item an item
+	 * @returns {boolean} true, if the item is currently queued
+	 */
+	isQueued(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		return entry !== undefined && entry.state === QUEUED_STATE;
+	}
 
-	// this will avoid having to lookup with identifiers in the ModuleContext
-	ignoreCustomNameSection: true
-};
+	/**
+	 * @param {T} item an item
+	 * @returns {boolean} true, if the item is currently queued
+	 */
+	isDone(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		return entry !== undefined && entry.state === DONE_STATE;
+	}
 
-class WebAssemblyParser extends Parser {
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
+	/**
+	 * @returns {void}
+	 */
+	_ensureProcessing() {
+		while (this._activeTasks < this._parallelism) {
+			const entry = this._queued.dequeue();
+			if (entry === undefined) break;
+			this._activeTasks++;
+			entry.state = PROCESSING_STATE;
+			this._startProcessing(entry);
+		}
+		this._willEnsureProcessing = false;
+		if (this._queued.length > 0) return;
+		if (this._children !== undefined) {
+			for (const child of this._children) {
+				while (this._activeTasks < this._parallelism) {
+					const entry = child._queued.dequeue();
+					if (entry === undefined) break;
+					this._activeTasks++;
+					entry.state = PROCESSING_STATE;
+					child._startProcessing(entry);
+				}
+				if (child._queued.length > 0) return;
+			}
+		}
+		if (!this._willEnsureProcessing) this._needProcessing = false;
 	}
 
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @returns {void}
 	 */
-	parse(source, state) {
-		if (!Buffer.isBuffer(source)) {
-			throw new Error("WebAssemblyParser input must be a Buffer");
-		}
-
-		// flag it as async module
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
-		state.module.buildMeta.async = true;
+	_startProcessing(entry) {
+		this.hooks.beforeStart.callAsync(entry.item, err => {
+			if (err) {
+				this._handleResult(
+					entry,
+					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeStart`)
+				);
+				return;
+			}
+			let inCallback = false;
+			try {
+				this._processor(entry.item, (e, r) => {
+					inCallback = true;
+					this._handleResult(entry, e, r);
+				});
+			} catch (err) {
+				if (inCallback) throw err;
+				this._handleResult(entry, err, null);
+			}
+			this.hooks.started.call(entry.item);
+		});
+	}
 
-		// parse it
-		const program = decode(source, decoderOpts);
-		const module = program.body[0];
+	/**
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @param {WebpackError=} err error, if any
+	 * @param {R=} result result, if any
+	 * @returns {void}
+	 */
+	_handleResult(entry, err, result) {
+		this.hooks.result.callAsync(entry.item, err, result, hookError => {
+			const error = hookError
+				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
+				: err;
 
-		const exports = [];
-		t.traverse(module, {
-			ModuleExport({ node }) {
-				exports.push(node.name);
-			},
+			const callback = entry.callback;
+			const callbacks = entry.callbacks;
+			entry.state = DONE_STATE;
+			entry.callback = undefined;
+			entry.callbacks = undefined;
+			entry.result = result;
+			entry.error = error;
 
-			ModuleImport({ node }) {
-				const dep = new WebAssemblyImportDependency(
-					node.module,
-					node.name,
-					node.descr,
-					false
-				);
+			const root = this._root;
+			root._activeTasks--;
+			if (root._willEnsureProcessing === false && root._needProcessing) {
+				root._willEnsureProcessing = true;
+				setImmediate(root._ensureProcessing);
+			}
 
-				state.module.addDependency(dep);
+			if (inHandleResult++ > 3) {
+				process.nextTick(() => {
+					callback(error, result);
+					if (callbacks !== undefined) {
+						for (const callback of callbacks) {
+							callback(error, result);
+						}
+					}
+				});
+			} else {
+				callback(error, result);
+				if (callbacks !== undefined) {
+					for (const callback of callbacks) {
+						callback(error, result);
+					}
+				}
 			}
+			inHandleResult--;
 		});
+	}
 
-		state.module.addDependency(new StaticExportsDependency(exports, false));
-
-		return state;
+	clear() {
+		this._entries.clear();
+		this._queued.clear();
+		this._activeTasks = 0;
+		this._willEnsureProcessing = false;
+		this._needProcessing = false;
+		this._stopped = false;
 	}
 }
 
-module.exports = WebAssemblyParser;
+module.exports = AsyncQueue;
 
 
 /***/ }),
 
-/***/ 78455:
+/***/ 36692:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
+class Hash {
+	/* istanbul ignore next */
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @abstract
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
-module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
-	/** @param {string} message Error message */
-	constructor(message) {
-		super(message);
-		this.name = "UnsupportedWebAssemblyFeatureError";
-		this.hideStack = true;
+	/* istanbul ignore next */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @abstract
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
-};
+}
+
+module.exports = Hash;
 
 
 /***/ }),
 
-/***/ 87394:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 39104:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const WebAssemblyUtils = __webpack_require__(18650);
-
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-// TODO webpack 6 remove the whole folder
-
-// Get all wasm modules
-const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
-	const wasmModules = chunk.getAllAsyncChunks();
-	const array = [];
-	for (const chunk of wasmModules) {
-		for (const m of chunkGraph.getOrderedChunkModulesIterable(
-			chunk,
-			compareModulesByIdentifier
-		)) {
-			if (m.type.startsWith("webassembly")) {
-				array.push(m);
-			}
-		}
-	}
-
-	return array;
-};
-
-/**
- * generates the import object function for a module
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Module} module the module
- * @param {boolean} mangle mangle imports
- * @param {string[]} declarations array where declarations are pushed to
- * @param {RuntimeSpec} runtime the runtime
- * @returns {string} source code
- */
-const generateImportObject = (
-	chunkGraph,
-	module,
-	mangle,
-	declarations,
-	runtime
-) => {
-	const moduleGraph = chunkGraph.moduleGraph;
-	const waitForInstances = new Map();
-	const properties = [];
-	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
-		moduleGraph,
-		module,
-		mangle
-	);
-	for (const usedDep of usedWasmDependencies) {
-		const dep = usedDep.dependency;
-		const importedModule = moduleGraph.getModule(dep);
-		const exportName = dep.name;
-		const usedName =
-			importedModule &&
-			moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(exportName, runtime);
-		const description = dep.description;
-		const direct = dep.onlyDirectImport;
-
-		const module = usedDep.module;
-		const name = usedDep.name;
-
-		if (direct) {
-			const instanceVar = `m${waitForInstances.size}`;
-			waitForInstances.set(instanceVar, chunkGraph.getModuleId(importedModule));
-			properties.push({
-				module,
-				name,
-				value: `${instanceVar}[${JSON.stringify(usedName)}]`
-			});
-		} else {
-			const params = description.signature.params.map(
-				(param, k) => "p" + k + param.valtype
-			);
-
-			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
-				chunkGraph.getModuleId(importedModule)
-			)}]`;
-			const modExports = `${mod}.exports`;
-
-			const cache = `wasmImportedFuncCache${declarations.length}`;
-			declarations.push(`var ${cache};`);
-
-			properties.push({
-				module,
-				name,
-				value: Template.asString([
-					(importedModule.type.startsWith("webassembly")
-						? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
-						: "") + `function(${params}) {`,
-					Template.indent([
-						`if(${cache} === undefined) ${cache} = ${modExports};`,
-						`return ${cache}[${JSON.stringify(usedName)}](${params});`
-					]),
-					"}"
-				])
-			});
-		}
-	}
-
-	let importObject;
-	if (mangle) {
-		importObject = [
-			"return {",
-			Template.indent([
-				properties.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
-			]),
-			"};"
-		];
-	} else {
-		const propertiesByModule = new Map();
-		for (const p of properties) {
-			let list = propertiesByModule.get(p.module);
-			if (list === undefined) {
-				propertiesByModule.set(p.module, (list = []));
-			}
-			list.push(p);
-		}
-		importObject = [
-			"return {",
-			Template.indent([
-				Array.from(propertiesByModule, ([module, list]) => {
-					return Template.asString([
-						`${JSON.stringify(module)}: {`,
-						Template.indent([
-							list.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
-						]),
-						"}"
-					]);
-				}).join(",\n")
-			]),
-			"};"
-		];
-	}
-
-	const moduleIdStringified = JSON.stringify(chunkGraph.getModuleId(module));
-	if (waitForInstances.size === 1) {
-		const moduleId = Array.from(waitForInstances.values())[0];
-		const promise = `installedWasmModules[${JSON.stringify(moduleId)}]`;
-		const variable = Array.from(waitForInstances.keys())[0];
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent([
-				`return promiseResolve().then(function() { return ${promise}; }).then(function(${variable}) {`,
-				Template.indent(importObject),
-				"});"
-			]),
-			"},"
-		]);
-	} else if (waitForInstances.size > 0) {
-		const promises = Array.from(
-			waitForInstances.values(),
-			id => `installedWasmModules[${JSON.stringify(id)}]`
-		).join(", ");
-		const variables = Array.from(
-			waitForInstances.keys(),
-			(name, i) => `${name} = array[${i}]`
-		).join(", ");
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent([
-				`return promiseResolve().then(function() { return Promise.all([${promises}]); }).then(function(array) {`,
-				Template.indent([`var ${variables};`, ...importObject]),
-				"});"
-			]),
-			"},"
-		]);
-	} else {
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent(importObject),
-			"},"
-		]);
-	}
-};
-
-class WasmChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor({
-		generateLoadBinaryCode,
-		supportsStreaming,
-		mangleImports,
-		runtimeRequirements
-	}) {
-		super("wasm chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.generateLoadBinaryCode = generateLoadBinaryCode;
-		this.supportsStreaming = supportsStreaming;
-		this.mangleImports = mangleImports;
-		this._runtimeRequirements = runtimeRequirements;
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, compilation, chunk, mangleImports } = this;
-		const { moduleGraph, outputOptions } = compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withHmr = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
-		const declarations = [];
-		const importObjects = wasmModules.map(module => {
-			return generateImportObject(
-				chunkGraph,
-				module,
-				this.mangleImports,
-				declarations,
-				chunk.runtime
-			);
-		});
-		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
-			m.type.startsWith("webassembly")
-		);
-		const createImportObject = content =>
-			mangleImports
-				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
-				: content;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: `" + ${JSON.stringify(
-						chunkGraph.getChunkModuleRenderedHashMap(chunk, m =>
-							m.type.startsWith("webassembly")
-						)
-					)}[chunkId][wasmModuleId] + "`,
-					hashWithLength(length) {
-						return `" + ${JSON.stringify(
-							chunkGraph.getChunkModuleRenderedHashMap(
-								chunk,
-								m => m.type.startsWith("webassembly"),
-								length
-							)
-						)}[chunkId][wasmModuleId] + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
-		);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_wasm`
-			: undefined;
-
-		return Template.asString([
-			"// object to store loaded and loading wasm modules",
-			`var installedWasmModules = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{};`,
-			"",
-			// This function is used to delay reading the installed wasm module promises
-			// by a microtask. Sorting them doesn't help because there are edge cases where
-			// sorting is not possible (modules splitted into different chunks).
-			// So we not even trying and solve this by a microtask delay.
-			"function promiseResolve() { return Promise.resolve(); }",
-			"",
-			Template.asString(declarations),
-			"var wasmImportObjects = {",
-			Template.indent(importObjects),
-			"};",
-			"",
-			`var wasmModuleMap = ${JSON.stringify(
-				chunkModuleIdMap,
-				undefined,
-				"\t"
-			)};`,
-			"",
-			"// object with all WebAssembly.instance exports",
-			`${RuntimeGlobals.wasmInstances} = {};`,
-			"",
-			"// Fetch + compile chunk loading for webassembly",
-			`${fn}.wasm = function(chunkId, promises) {`,
-			Template.indent([
-				"",
-				`var wasmModules = wasmModuleMap[chunkId] || [];`,
-				"",
-				"wasmModules.forEach(function(wasmModuleId, idx) {",
-				Template.indent([
-					"var installedWasmModuleData = installedWasmModules[wasmModuleId];",
-					"",
-					'// a Promise means "currently loading" or "already loaded".',
-					"if(installedWasmModuleData)",
-					Template.indent(["promises.push(installedWasmModuleData);"]),
-					"else {",
-					Template.indent([
-						`var importObject = wasmImportObjects[wasmModuleId]();`,
-						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
-						"var promise;",
-						this.supportsStreaming
-							? Template.asString([
-									"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
-									Template.indent([
-										"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
-										Template.indent([
-											`return WebAssembly.instantiate(items[0], ${createImportObject(
-												"items[1]"
-											)});`
-										]),
-										"});"
-									]),
-									"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
-									Template.indent([
-										`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
-											"importObject"
-										)});`
-									])
-							  ])
-							: Template.asString([
-									"if(importObject && typeof importObject.then === 'function') {",
-									Template.indent([
-										"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
-										"promise = Promise.all([",
-										Template.indent([
-											"bytesPromise.then(function(bytes) { return WebAssembly.compile(bytes); }),",
-											"importObject"
-										]),
-										"]).then(function(items) {",
-										Template.indent([
-											`return WebAssembly.instantiate(items[0], ${createImportObject(
-												"items[1]"
-											)});`
-										]),
-										"});"
-									])
-							  ]),
-						"} else {",
-						Template.indent([
-							"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
-							"promise = bytesPromise.then(function(bytes) {",
-							Template.indent([
-								`return WebAssembly.instantiate(bytes, ${createImportObject(
-									"importObject"
-								)});`
-							]),
-							"});"
-						]),
-						"}",
-						"promises.push(installedWasmModules[wasmModuleId] = promise.then(function(res) {",
-						Template.indent([
-							`return ${RuntimeGlobals.wasmInstances}[wasmModuleId] = (res.instance || res).exports;`
-						]),
-						"}));"
-					]),
-					"}"
-				]),
-				"});"
-			]),
-			"};"
-		]);
+/**
+ * @template T
+ * @param {Iterable<T>} set a set
+ * @returns {T | undefined} last item
+ */
+const last = set => {
+	let last;
+	for (const item of set) last = item;
+	return last;
+};
+
+/**
+ * @template T
+ * @param {Iterable<T>} iterable iterable
+ * @param {function(T): boolean} filter predicate
+ * @returns {boolean} true, if some items match the filter predicate
+ */
+const someInIterable = (iterable, filter) => {
+	for (const item of iterable) {
+		if (filter(item)) return true;
 	}
-}
+	return false;
+};
 
-module.exports = WasmChunkLoadingRuntimeModule;
+/**
+ * @template T
+ * @param {Iterable<T>} iterable an iterable
+ * @returns {number} count of items
+ */
+const countIterable = iterable => {
+	let i = 0;
+	// eslint-disable-next-line no-unused-vars
+	for (const _ of iterable) i++;
+	return i;
+};
+
+exports.last = last;
+exports.someInIterable = someInIterable;
+exports.countIterable = countIterable;
 
 
 /***/ }),
 
-/***/ 19810:
+/***/ 48424:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -130770,86 +128983,240 @@ module.exports = WasmChunkLoadingRuntimeModule;
 
 
 
-const formatLocation = __webpack_require__(16734);
-const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
+const { first } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
 
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * Multi layer bucket sorted set:
+ * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
+ * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET),
+ * Supports popping the first items according to defined order,
+ * Supports iterating all items without order,
+ * Supports updating an item in an efficient way,
+ * Supports size property, which is the number of items,
+ * Items are lazy partially sorted when needed
+ * @template T
+ * @template K
+ */
+class LazyBucketSortedSet {
+	/**
+	 * @param {function(T): K} getKey function to get key from item
+	 * @param {function(K, K): number} comparator comparator to sort keys
+	 * @param  {...((function(T): any) | (function(any, any): number))} args more pairs of getKey and comparator plus optional final comparator for the last layer
+	 */
+	constructor(getKey, comparator, ...args) {
+		this._getKey = getKey;
+		this._innerArgs = args;
+		this._leaf = args.length <= 1;
+		this._keys = new SortableSet(undefined, comparator);
+		/** @type {Map<K, LazyBucketSortedSet<T, any> | SortableSet<T>>} */
+		this._map = new Map();
+		this._unsortedItems = new Set();
+		this.size = 0;
+	}
 
-class WasmFinalizeExportsPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {T} item an item
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("WasmFinalizeExportsPlugin", compilation => {
-			compilation.hooks.finishModules.tap(
-				"WasmFinalizeExportsPlugin",
-				modules => {
-					for (const module of modules) {
-						// 1. if a WebAssembly module
-						if (module.type.startsWith("webassembly") === true) {
-							const jsIncompatibleExports =
-								module.buildMeta.jsIncompatibleExports;
+	add(item) {
+		this.size++;
+		this._unsortedItems.add(item);
+	}
 
-							if (jsIncompatibleExports === undefined) {
-								continue;
-							}
+	/**
+	 * @param {K} key key of item
+	 * @param {T} item the item
+	 * @returns {void}
+	 */
+	_addInternal(key, item) {
+		let entry = this._map.get(key);
+		if (entry === undefined) {
+			entry = this._leaf
+				? new SortableSet(undefined, this._innerArgs[0])
+				: new /** @type {any} */ (LazyBucketSortedSet)(...this._innerArgs);
+			this._keys.add(key);
+			this._map.set(key, entry);
+		}
+		entry.add(item);
+	}
 
-							for (const connection of compilation.moduleGraph.getIncomingConnections(
-								module
-							)) {
-								// 2. is active and referenced by a non-WebAssembly module
-								if (
-									connection.isTargetActive(undefined) &&
-									connection.originModule.type.startsWith("webassembly") ===
-										false
-								) {
-									const referencedExports =
-										compilation.getDependencyReferencedExports(
-											connection.dependency,
-											undefined
-										);
+	/**
+	 * @param {T} item an item
+	 * @returns {void}
+	 */
+	delete(item) {
+		this.size--;
+		if (this._unsortedItems.has(item)) {
+			this._unsortedItems.delete(item);
+			return;
+		}
+		const key = this._getKey(item);
+		const entry = this._map.get(key);
+		entry.delete(item);
+		if (entry.size === 0) {
+			this._deleteKey(key);
+		}
+	}
 
-									for (const info of referencedExports) {
-										const names = Array.isArray(info) ? info : info.name;
-										if (names.length === 0) continue;
-										const name = names[0];
-										if (typeof name === "object") continue;
-										// 3. and uses a func with an incompatible JS signature
-										if (
-											Object.prototype.hasOwnProperty.call(
-												jsIncompatibleExports,
-												name
-											)
-										) {
-											// 4. error
-											const error = new UnsupportedWebAssemblyFeatureError(
-												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
-													`It's used from ${connection.originModule.readableIdentifier(
-														compilation.requestShortener
-													)} at ${formatLocation(connection.dependency.loc)}.`
-											);
-											error.module = module;
-											compilation.errors.push(error);
-										}
-									}
-								}
-							}
-						}
+	/**
+	 * @param {K} key key to be removed
+	 * @returns {void}
+	 */
+	_deleteKey(key) {
+		this._keys.delete(key);
+		this._map.delete(key);
+	}
+
+	/**
+	 * @returns {T | undefined} an item
+	 */
+	popFirst() {
+		if (this.size === 0) return undefined;
+		this.size--;
+		if (this._unsortedItems.size > 0) {
+			for (const item of this._unsortedItems) {
+				const key = this._getKey(item);
+				this._addInternal(key, item);
+			}
+			this._unsortedItems.clear();
+		}
+		this._keys.sort();
+		const key = first(this._keys);
+		const entry = this._map.get(key);
+		if (this._leaf) {
+			const leafEntry = /** @type {SortableSet<T>} */ (entry);
+			leafEntry.sort();
+			const item = first(leafEntry);
+			leafEntry.delete(item);
+			if (leafEntry.size === 0) {
+				this._deleteKey(key);
+			}
+			return item;
+		} else {
+			const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+			const item = nodeEntry.popFirst();
+			if (nodeEntry.size === 0) {
+				this._deleteKey(key);
+			}
+			return item;
+		}
+	}
+
+	/**
+	 * @param {T} item to be updated item
+	 * @returns {function(true=): void} finish update
+	 */
+	startUpdate(item) {
+		if (this._unsortedItems.has(item)) {
+			return remove => {
+				if (remove) {
+					this._unsortedItems.delete(item);
+					this.size--;
+					return;
+				}
+			};
+		}
+		const key = this._getKey(item);
+		if (this._leaf) {
+			const oldEntry = /** @type {SortableSet<T>} */ (this._map.get(key));
+			return remove => {
+				if (remove) {
+					this.size--;
+					oldEntry.delete(item);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					return;
+				}
+				const newKey = this._getKey(item);
+				if (key === newKey) {
+					// This flags the sortable set as unordered
+					oldEntry.add(item);
+				} else {
+					oldEntry.delete(item);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
 					}
+					this._addInternal(newKey, item);
 				}
+			};
+		} else {
+			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
+				this._map.get(key)
 			);
-		});
+			const finishUpdate = oldEntry.startUpdate(item);
+			return remove => {
+				if (remove) {
+					this.size--;
+					finishUpdate(true);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					return;
+				}
+				const newKey = this._getKey(item);
+				if (key === newKey) {
+					finishUpdate();
+				} else {
+					finishUpdate(true);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					this._addInternal(newKey, item);
+				}
+			};
+		}
+	}
+
+	/**
+	 * @param {Iterator<T>[]} iterators list of iterators to append to
+	 * @returns {void}
+	 */
+	_appendIterators(iterators) {
+		if (this._unsortedItems.size > 0)
+			iterators.push(this._unsortedItems[Symbol.iterator]());
+		for (const key of this._keys) {
+			const entry = this._map.get(key);
+			if (this._leaf) {
+				const leafEntry = /** @type {SortableSet<T>} */ (entry);
+				const iterator = leafEntry[Symbol.iterator]();
+				iterators.push(iterator);
+			} else {
+				const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+				nodeEntry._appendIterators(iterators);
+			}
+		}
+	}
+
+	/**
+	 * @returns {Iterator<T>} the iterator
+	 */
+	[Symbol.iterator]() {
+		const iterators = [];
+		this._appendIterators(iterators);
+		iterators.reverse();
+		let currentIterator = iterators.pop();
+		return {
+			next: () => {
+				const res = currentIterator.next();
+				if (res.done) {
+					if (iterators.length === 0) return res;
+					currentIterator = iterators.pop();
+					return currentIterator.next();
+				}
+				return res;
+			}
+		};
 	}
 }
 
-module.exports = WasmFinalizeExportsPlugin;
+module.exports = LazyBucketSortedSet;
 
 
 /***/ }),
 
-/***/ 47012:
+/***/ 38938:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -130860,620 +129227,471 @@ module.exports = WasmFinalizeExportsPlugin;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const WebAssemblyUtils = __webpack_require__(18650);
-
-const t = __webpack_require__(51826);
-const { moduleContextFromModuleAST } = __webpack_require__(51826);
-const { editWithAST, addWithAST } = __webpack_require__(87362);
-const { decode } = __webpack_require__(73726);
-
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
-
-/**
- * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
- */
+const makeSerializable = __webpack_require__(33032);
 
 /**
  * @template T
- * @param {Function[]} fns transforms
- * @returns {Function} composed transform
+ * @param {Set<T>} targetSet set where items should be added
+ * @param {Set<Iterable<T>>} toMerge iterables to be merged
+ * @returns {void}
  */
-const compose = (...fns) => {
-	return fns.reduce(
-		(prevFn, nextFn) => {
-			return value => nextFn(prevFn(value));
-		},
-		value => value
-	);
+const merge = (targetSet, toMerge) => {
+	for (const set of toMerge) {
+		for (const item of set) {
+			targetSet.add(item);
+		}
+	}
 };
 
 /**
- * Removes the start instruction
- *
- * @param {Object} state unused state
- * @returns {ArrayBufferTransform} transform
+ * @template T
+ * @param {Set<Iterable<T>>} targetSet set where iterables should be added
+ * @param {Array<LazySet<T>>} toDeepMerge lazy sets to be flattened
+ * @returns {void}
  */
-const removeStartFunc = state => bin => {
-	return editWithAST(state.ast, bin, {
-		Start(path) {
-			path.remove();
+const flatten = (targetSet, toDeepMerge) => {
+	for (const set of toDeepMerge) {
+		if (set._set.size > 0) targetSet.add(set._set);
+		if (set._needMerge) {
+			for (const mergedSet of set._toMerge) {
+				targetSet.add(mergedSet);
+			}
+			flatten(targetSet, set._toDeepMerge);
 		}
-	});
+	}
 };
 
 /**
- * Get imported globals
- *
- * @param {Object} ast Module's AST
- * @returns {Array<t.ModuleImport>} - nodes
+ * Like Set but with an addAll method to eventually add items from another iterable.
+ * Access methods make sure that all delayed operations are executed.
+ * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
+ * @template T
  */
-const getImportedGlobals = ast => {
-	const importedGlobals = [];
+class LazySet {
+	/**
+	 * @param {Iterable<T>=} iterable init iterable
+	 */
+	constructor(iterable) {
+		/** @type {Set<T>} */
+		this._set = new Set(iterable);
+		/** @type {Set<Iterable<T>>} */
+		this._toMerge = new Set();
+		/** @type {Array<LazySet<T>>} */
+		this._toDeepMerge = [];
+		this._needMerge = false;
+		this._deopt = false;
+	}
 
-	t.traverse(ast, {
-		ModuleImport({ node }) {
-			if (t.isGlobalType(node.descr)) {
-				importedGlobals.push(node);
-			}
-		}
-	});
+	_flatten() {
+		flatten(this._toMerge, this._toDeepMerge);
+		this._toDeepMerge.length = 0;
+	}
 
-	return importedGlobals;
-};
+	_merge() {
+		this._flatten();
+		merge(this._set, this._toMerge);
+		this._toMerge.clear();
+		this._needMerge = false;
+	}
 
-/**
- * Get the count for imported func
- *
- * @param {Object} ast Module's AST
- * @returns {Number} - count
- */
-const getCountImportedFunc = ast => {
-	let count = 0;
+	_isEmpty() {
+		return (
+			this._set.size === 0 &&
+			this._toMerge.size === 0 &&
+			this._toDeepMerge.length === 0
+		);
+	}
 
-	t.traverse(ast, {
-		ModuleImport({ node }) {
-			if (t.isFuncImportDescr(node.descr)) {
-				count++;
+	get size() {
+		if (this._needMerge) this._merge();
+		return this._set.size;
+	}
+
+	/**
+	 * @param {T} item an item
+	 * @returns {this} itself
+	 */
+	add(item) {
+		this._set.add(item);
+		return this;
+	}
+
+	/**
+	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
+	 * @returns {this} itself
+	 */
+	addAll(iterable) {
+		if (this._deopt) {
+			const _set = this._set;
+			for (const item of iterable) {
+				_set.add(item);
+			}
+		} else {
+			if (iterable instanceof LazySet) {
+				if (iterable._isEmpty()) return this;
+				this._toDeepMerge.push(iterable);
+				this._needMerge = true;
+				if (this._toDeepMerge.length > 100000) {
+					this._flatten();
+				}
+			} else {
+				this._toMerge.add(iterable);
+				this._needMerge = true;
 			}
+			if (this._toMerge.size > 100000) this._merge();
 		}
-	});
-
-	return count;
-};
+		return this;
+	}
 
-/**
- * Get next type index
- *
- * @param {Object} ast Module's AST
- * @returns {t.Index} - index
- */
-const getNextTypeIndex = ast => {
-	const typeSectionMetadata = t.getSectionMetadata(ast, "type");
+	clear() {
+		this._set.clear();
+		this._toMerge.clear();
+		this._toDeepMerge.length = 0;
+		this._needMerge = false;
+		this._deopt = false;
+	}
 
-	if (typeSectionMetadata === undefined) {
-		return t.indexLiteral(0);
+	/**
+	 * @param {T} value an item
+	 * @returns {boolean} true, if the value was in the Set before
+	 */
+	delete(value) {
+		if (this._needMerge) this._merge();
+		return this._set.delete(value);
 	}
 
-	return t.indexLiteral(typeSectionMetadata.vectorOfSize.value);
-};
+	entries() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set.entries();
+	}
 
-/**
- * Get next func index
- *
- * The Func section metadata provide informations for implemented funcs
- * in order to have the correct index we shift the index by number of external
- * functions.
- *
- * @param {Object} ast Module's AST
- * @param {Number} countImportedFunc number of imported funcs
- * @returns {t.Index} - index
- */
-const getNextFuncIndex = (ast, countImportedFunc) => {
-	const funcSectionMetadata = t.getSectionMetadata(ast, "func");
+	/**
+	 * @param {function(T, T, Set<T>): void} callbackFn function called for each entry
+	 * @param {any} thisArg this argument for the callbackFn
+	 * @returns {void}
+	 */
+	forEach(callbackFn, thisArg) {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		this._set.forEach(callbackFn, thisArg);
+	}
 
-	if (funcSectionMetadata === undefined) {
-		return t.indexLiteral(0 + countImportedFunc);
+	/**
+	 * @param {T} item an item
+	 * @returns {boolean} true, when the item is in the Set
+	 */
+	has(item) {
+		if (this._needMerge) this._merge();
+		return this._set.has(item);
 	}
 
-	const vectorOfSize = funcSectionMetadata.vectorOfSize.value;
+	keys() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set.keys();
+	}
 
-	return t.indexLiteral(vectorOfSize + countImportedFunc);
-};
+	values() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set.values();
+	}
 
-/**
- * Creates an init instruction for a global type
- * @param {t.GlobalType} globalType the global type
- * @returns {t.Instruction} init expression
- */
-const createDefaultInitForGlobal = globalType => {
-	if (globalType.valtype[0] === "i") {
-		// create NumberLiteral global initializer
-		return t.objectInstruction("const", globalType.valtype, [
-			t.numberLiteralFromRaw(66)
-		]);
-	} else if (globalType.valtype[0] === "f") {
-		// create FloatLiteral global initializer
-		return t.objectInstruction("const", globalType.valtype, [
-			t.floatLiteral(66, false, false, "66")
-		]);
-	} else {
-		throw new Error("unknown type: " + globalType.valtype);
+	[Symbol.iterator]() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set[Symbol.iterator]();
 	}
-};
 
-/**
- * Rewrite the import globals:
- * - removes the ModuleImport instruction
- * - injects at the same offset a mutable global of the same type
- *
- * Since the imported globals are before the other global declarations, our
- * indices will be preserved.
- *
- * Note that globals will become mutable.
- *
- * @param {Object} state unused state
- * @returns {ArrayBufferTransform} transform
- */
-const rewriteImportedGlobals = state => bin => {
-	const additionalInitCode = state.additionalInitCode;
-	const newGlobals = [];
+	/* istanbul ignore next */
+	get [Symbol.toStringTag]() {
+		return "LazySet";
+	}
 
-	bin = editWithAST(state.ast, bin, {
-		ModuleImport(path) {
-			if (t.isGlobalType(path.node.descr)) {
-				const globalType = path.node.descr;
+	serialize({ write }) {
+		if (this._needMerge) this._merge();
+		write(this._set.size);
+		for (const item of this._set) write(item);
+	}
 
-				globalType.mutability = "var";
+	static deserialize({ read }) {
+		const count = read();
+		const items = [];
+		for (let i = 0; i < count; i++) {
+			items.push(read());
+		}
+		return new LazySet(items);
+	}
+}
 
-				const init = [
-					createDefaultInitForGlobal(globalType),
-					t.instruction("end")
-				];
+makeSerializable(LazySet, "webpack/lib/util/LazySet");
 
-				newGlobals.push(t.global(globalType, init));
+module.exports = LazySet;
 
-				path.remove();
-			}
-		},
 
-		// in order to preserve non-imported global's order we need to re-inject
-		// those as well
-		Global(path) {
-			const { node } = path;
-			const [init] = node.init;
+/***/ }),
 
-			if (init.id === "get_global") {
-				node.globalType.mutability = "var";
+/***/ 82482:
+/***/ (function(__unused_webpack_module, exports) {
 
-				const initialGlobalIdx = init.args[0];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				node.init = [
-					createDefaultInitForGlobal(node.globalType),
-					t.instruction("end")
-				];
 
-				additionalInitCode.push(
-					/**
-					 * get_global in global initializer only works for imported globals.
-					 * They have the same indices as the init params, so use the
-					 * same index.
-					 */
-					t.instruction("get_local", [initialGlobalIdx]),
-					t.instruction("set_global", [t.indexLiteral(newGlobals.length)])
-				);
-			}
 
-			newGlobals.push(node);
+/**
+ * @template K
+ * @template V
+ * @param {Map<K, V>} map a map
+ * @param {K} key the key
+ * @param {function(): V} computer compute value
+ * @returns {V} value
+ */
+exports.provide = (map, key, computer) => {
+	const value = map.get(key);
+	if (value !== undefined) return value;
+	const newValue = computer();
+	map.set(key, newValue);
+	return newValue;
+};
 
-			path.remove();
-		}
-	});
 
-	// Add global declaration instructions
-	return addWithAST(state.ast, bin, newGlobals);
-};
+/***/ }),
 
-/**
- * Rewrite the export names
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
- * @param {Module} state.module Module
- * @param {ModuleGraph} state.moduleGraph module graph
- * @param {Set<string>} state.externalExports Module
- * @param {RuntimeSpec} state.runtime runtime
- * @returns {ArrayBufferTransform} transform
- */
-const rewriteExportNames =
-	({ ast, moduleGraph, module, externalExports, runtime }) =>
-	bin => {
-		return editWithAST(ast, bin, {
-			ModuleExport(path) {
-				const isExternal = externalExports.has(path.node.name);
-				if (isExternal) {
-					path.remove();
-					return;
-				}
-				const usedName = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName(path.node.name, runtime);
-				if (!usedName) {
-					path.remove();
-					return;
-				}
-				path.node.name = usedName;
-			}
-		});
-	};
+/***/ 50780:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * Mangle import names and modules
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
- * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
- * @returns {ArrayBufferTransform} transform
- */
-const rewriteImports =
-	({ ast, usedDependencyMap }) =>
-	bin => {
-		return editWithAST(ast, bin, {
-			ModuleImport(path) {
-				const result = usedDependencyMap.get(
-					path.node.module + ":" + path.node.name
-				);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				if (result !== undefined) {
-					path.node.module = result.module;
-					path.node.name = result.name;
-				}
-			}
-		});
-	};
 
-/**
- * Add an init function.
- *
- * The init function fills the globals given input arguments.
- *
- * @param {Object} state transformation state
- * @param {Object} state.ast Module's ast
- * @param {t.Identifier} state.initFuncId identifier of the init function
- * @param {t.Index} state.startAtFuncOffset index of the start function
- * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
- * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
- * @param {t.Index} state.nextFuncIndex index of the next function
- * @param {t.Index} state.nextTypeIndex index of the next type
- * @returns {ArrayBufferTransform} transform
- */
-const addInitFunction =
-	({
-		ast,
-		initFuncId,
-		startAtFuncOffset,
-		importedGlobals,
-		additionalInitCode,
-		nextFuncIndex,
-		nextTypeIndex
-	}) =>
-	bin => {
-		const funcParams = importedGlobals.map(importedGlobal => {
-			// used for debugging
-			const id = t.identifier(
-				`${importedGlobal.module}.${importedGlobal.name}`
-			);
 
-			return t.funcParam(importedGlobal.descr.valtype, id);
-		});
+const binarySearchBounds = __webpack_require__(92229);
 
-		const funcBody = [];
-		importedGlobals.forEach((importedGlobal, index) => {
-			const args = [t.indexLiteral(index)];
-			const body = [
-				t.instruction("get_local", args),
-				t.instruction("set_global", args)
-			];
+class ParallelismFactorCalculator {
+	constructor() {
+		this._rangePoints = [];
+		this._rangeCallbacks = [];
+	}
 
-			funcBody.push(...body);
-		});
+	range(start, end, callback) {
+		if (start === end) return callback(1);
+		this._rangePoints.push(start);
+		this._rangePoints.push(end);
+		this._rangeCallbacks.push(callback);
+	}
 
-		if (typeof startAtFuncOffset === "number") {
-			funcBody.push(
-				t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset))
-			);
+	calculate() {
+		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
+			a < b ? -1 : 1
+		);
+		const parallelism = segments.map(() => 0);
+		const rangeStartIndices = [];
+		for (let i = 0; i < this._rangePoints.length; i += 2) {
+			const start = this._rangePoints[i];
+			const end = this._rangePoints[i + 1];
+			let idx = binarySearchBounds.eq(segments, start);
+			rangeStartIndices.push(idx);
+			do {
+				parallelism[idx]++;
+				idx++;
+			} while (segments[idx] < end);
 		}
-
-		for (const instr of additionalInitCode) {
-			funcBody.push(instr);
+		for (let i = 0; i < this._rangeCallbacks.length; i++) {
+			const start = this._rangePoints[i * 2];
+			const end = this._rangePoints[i * 2 + 1];
+			let idx = rangeStartIndices[i];
+			let sum = 0;
+			let totalDuration = 0;
+			let current = start;
+			do {
+				const p = parallelism[idx];
+				idx++;
+				const duration = segments[idx] - current;
+				totalDuration += duration;
+				current = segments[idx];
+				sum += p * duration;
+			} while (current < end);
+			this._rangeCallbacks[i](sum / totalDuration);
 		}
+	}
+}
 
-		funcBody.push(t.instruction("end"));
+module.exports = ParallelismFactorCalculator;
 
-		const funcResults = [];
 
-		// Code section
-		const funcSignature = t.signature(funcParams, funcResults);
-		const func = t.func(initFuncId, funcSignature, funcBody);
+/***/ }),
 
-		// Type section
-		const functype = t.typeInstruction(undefined, funcSignature);
+/***/ 65930:
+/***/ (function(module) {
 
-		// Func section
-		const funcindex = t.indexInFuncSection(nextTypeIndex);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		// Export section
-		const moduleExport = t.moduleExport(
-			initFuncId.value,
-			t.moduleExportDescr("Func", nextFuncIndex)
-		);
 
-		return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
-	};
 
 /**
- * Extract mangle mappings from module
- * @param {ModuleGraph} moduleGraph module graph
- * @param {Module} module current module
- * @param {boolean} mangle mangle imports
- * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
+ * @template T
  */
-const getUsedDependencyMap = (moduleGraph, module, mangle) => {
-	/** @type {Map<string, UsedWasmDependency>} */
-	const map = new Map();
-	for (const usedDep of WebAssemblyUtils.getUsedDependencies(
-		moduleGraph,
-		module,
-		mangle
-	)) {
-		const dep = usedDep.dependency;
-		const request = dep.request;
-		const exportName = dep.name;
-		map.set(request + ":" + exportName, usedDep);
-	}
-	return map;
-};
-
-const TYPES = new Set(["webassembly"]);
-
-class WebAssemblyGenerator extends Generator {
-	constructor(options) {
-		super();
-		this.options = options;
+class Queue {
+	/**
+	 * @param {Iterable<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/** @private @type {Set<T>} */
+		this._set = new Set(items);
+		/** @private @type {Iterator<T>} */
+		this._iterator = this._set[Symbol.iterator]();
 	}
 
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
 	 */
-	getTypes(module) {
-		return TYPES;
+	get length() {
+		return this._set.size;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
 	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 0;
-		}
-		return originalSource.size();
+	enqueue(item) {
+		this._set.add(item);
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
-	generate(module, { moduleGraph, runtime }) {
-		const bin = module.originalSource().source();
-
-		const initFuncId = t.identifier("");
-
-		// parse it
-		const ast = decode(bin, {
-			ignoreDataSection: true,
-			ignoreCodeSection: true,
-			ignoreCustomNameSection: true
-		});
-
-		const moduleContext = moduleContextFromModuleAST(ast.body[0]);
-
-		const importedGlobals = getImportedGlobals(ast);
-		const countImportedFunc = getCountImportedFunc(ast);
-		const startAtFuncOffset = moduleContext.getStart();
-		const nextFuncIndex = getNextFuncIndex(ast, countImportedFunc);
-		const nextTypeIndex = getNextTypeIndex(ast);
-
-		const usedDependencyMap = getUsedDependencyMap(
-			moduleGraph,
-			module,
-			this.options.mangleImports
-		);
-		const externalExports = new Set(
-			module.dependencies
-				.filter(d => d instanceof WebAssemblyExportImportedDependency)
-				.map(d => {
-					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (
-						d
-					);
-					return wasmDep.exportName;
-				})
-		);
-
-		/** @type {t.Instruction[]} */
-		const additionalInitCode = [];
-
-		const transform = compose(
-			rewriteExportNames({
-				ast,
-				moduleGraph,
-				module,
-				externalExports,
-				runtime
-			}),
-
-			removeStartFunc({ ast }),
-
-			rewriteImportedGlobals({ ast, additionalInitCode }),
-
-			rewriteImports({
-				ast,
-				usedDependencyMap
-			}),
-
-			addInitFunction({
-				ast,
-				initFuncId,
-				importedGlobals,
-				additionalInitCode,
-				startAtFuncOffset,
-				nextFuncIndex,
-				nextTypeIndex
-			})
-		);
-
-		const newBin = transform(bin);
-
-		const newBuf = Buffer.from(newBin);
-
-		return new RawSource(newBuf);
+	dequeue() {
+		const result = this._iterator.next();
+		if (result.done) return undefined;
+		this._set.delete(result.value);
+		return result.value;
 	}
 }
 
-module.exports = WebAssemblyGenerator;
+module.exports = Queue;
 
 
 /***/ }),
 
-/***/ 47342:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 93347:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-
 /**
- * @param {Module} module module to get chains from
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {RequestShortener} requestShortener to make readable identifiers
- * @returns {string[]} all chains to the module
+ * intersect creates Set containing the intersection of elements between all sets
+ * @template T
+ * @param {Set<T>[]} sets an array of sets being checked for shared elements
+ * @returns {Set<T>} returns a new Set containing the intersecting items
  */
-const getInitialModuleChains = (
-	module,
-	moduleGraph,
-	chunkGraph,
-	requestShortener
-) => {
-	const queue = [
-		{ head: module, message: module.readableIdentifier(requestShortener) }
-	];
-	/** @type {Set<string>} */
-	const results = new Set();
-	/** @type {Set<string>} */
-	const incompleteResults = new Set();
-	/** @type {Set<Module>} */
-	const visitedModules = new Set();
-
-	for (const chain of queue) {
-		const { head, message } = chain;
-		let final = true;
-		/** @type {Set<Module>} */
-		const alreadyReferencedModules = new Set();
-		for (const connection of moduleGraph.getIncomingConnections(head)) {
-			const newHead = connection.originModule;
-			if (newHead) {
-				if (!chunkGraph.getModuleChunks(newHead).some(c => c.canBeInitial()))
-					continue;
-				final = false;
-				if (alreadyReferencedModules.has(newHead)) continue;
-				alreadyReferencedModules.add(newHead);
-				const moduleName = newHead.readableIdentifier(requestShortener);
-				const detail = connection.explanation
-					? ` (${connection.explanation})`
-					: "";
-				const newMessage = `${moduleName}${detail} --> ${message}`;
-				if (visitedModules.has(newHead)) {
-					incompleteResults.add(`... --> ${newMessage}`);
-					continue;
-				}
-				visitedModules.add(newHead);
-				queue.push({
-					head: newHead,
-					message: newMessage
-				});
-			} else {
-				final = false;
-				const newMessage = connection.explanation
-					? `(${connection.explanation}) --> ${message}`
-					: message;
-				results.add(newMessage);
-			}
-		}
-		if (final) {
-			results.add(message);
+const intersect = sets => {
+	if (sets.length === 0) return new Set();
+	if (sets.length === 1) return new Set(sets[0]);
+	let minSize = Infinity;
+	let minIndex = -1;
+	for (let i = 0; i < sets.length; i++) {
+		const size = sets[i].size;
+		if (size < minSize) {
+			minIndex = i;
+			minSize = size;
 		}
 	}
-	for (const result of incompleteResults) {
-		results.add(result);
+	const current = new Set(sets[minIndex]);
+	for (let i = 0; i < sets.length; i++) {
+		if (i === minIndex) continue;
+		const set = sets[i];
+		for (const item of current) {
+			if (!set.has(item)) {
+				current.delete(item);
+			}
+		}
 	}
-	return Array.from(results);
+	return current;
 };
 
-module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
-	/**
-	 * @param {Module} module WASM module
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {RequestShortener} requestShortener request shortener
-	 */
-	constructor(module, moduleGraph, chunkGraph, requestShortener) {
-		const moduleChains = getInitialModuleChains(
-			module,
-			moduleGraph,
-			chunkGraph,
-			requestShortener
-		);
-		const message = `WebAssembly module is included in initial chunk.
-This is not allowed, because WebAssembly download and compilation must happen asynchronous.
-Add an async split point (i. e. import()) somewhere between your entrypoint and the WebAssembly module:
-${moduleChains.map(s => `* ${s}`).join("\n")}`;
+/**
+ * Checks if a set is the subset of another set
+ * @template T
+ * @param {Set<T>} bigSet a Set which contains the original elements to compare against
+ * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
+ * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ */
+const isSubset = (bigSet, smallSet) => {
+	if (bigSet.size < smallSet.size) return false;
+	for (const item of smallSet) {
+		if (!bigSet.has(item)) return false;
+	}
+	return true;
+};
 
-		super(message);
-		this.name = "WebAssemblyInInitialChunkError";
-		this.hideStack = true;
-		this.module = module;
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @param {function(T): boolean} fn selector function
+ * @returns {T | undefined} found item
+ */
+const find = (set, fn) => {
+	for (const item of set) {
+		if (fn(item)) return item;
 	}
 };
 
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @returns {T | undefined} first item
+ */
+const first = set => {
+	const entry = set.values().next();
+	return entry.done ? undefined : entry.value;
+};
+
+/**
+ * @template T
+ * @param {Set<T>} a first
+ * @param {Set<T>} b second
+ * @returns {Set<T>} combined set, may be identical to a or b
+ */
+const combine = (a, b) => {
+	if (b.size === 0) return a;
+	if (a.size === 0) return b;
+	const set = new Set(a);
+	for (const item of b) set.add(item);
+	return set;
+};
+
+exports.intersect = intersect;
+exports.isSubset = isSubset;
+exports.find = find;
+exports.first = first;
+exports.combine = combine;
+
 
 /***/ }),
 
-/***/ 46545:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 13098:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -131483,221 +129701,165 @@ ${moduleChains.map(s => `* ${s}`).join("\n")}`;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(1626);
-const ModuleDependency = __webpack_require__(80321);
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+const NONE = Symbol("not sorted");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/**
+ * A subset of Set that offers sorting functionality
+ * @template T item type in set
+ * @extends {Set<T>}
+ */
+class SortableSet extends Set {
+	/**
+	 * Create a new sortable set
+	 * @param {Iterable<T>=} initialIterable The initial iterable value
+	 * @typedef {function(T, T): number} SortFunction
+	 * @param {SortFunction=} defaultSort Default sorting function
+	 */
+	constructor(initialIterable, defaultSort) {
+		super(initialIterable);
+		/** @private @type {undefined | function(T, T): number}} */
+		this._sortFn = defaultSort;
+		/** @private @type {typeof NONE | undefined | function(T, T): number}} */
+		this._lastActiveSortFn = NONE;
+		/** @private @type {Map<Function, any> | undefined} */
+		this._cache = undefined;
+		/** @private @type {Map<Function, any> | undefined} */
+		this._cacheOrderIndependent = undefined;
+	}
 
-const TYPES = new Set(["webassembly"]);
+	/**
+	 * @param {T} value value to add to set
+	 * @returns {this} returns itself
+	 */
+	add(value) {
+		this._lastActiveSortFn = NONE;
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		super.add(value);
+		return this;
+	}
 
-class WebAssemblyJavascriptGenerator extends Generator {
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {T} value value to delete
+	 * @returns {boolean} true if value existed in set, false otherwise
 	 */
-	getTypes(module) {
-		return TYPES;
+	delete(value) {
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		return super.delete(value);
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @returns {void}
 	 */
-	getSize(module, type) {
-		return 95 + module.dependencies.length * 5;
+	clear() {
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		return super.clear();
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Sort with a comparer function
+	 * @param {SortFunction} sortFn Sorting comparer function
+	 * @returns {void}
 	 */
-	generate(module, generateContext) {
-		const {
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph,
-			runtimeRequirements,
-			runtime
-		} = generateContext;
-		/** @type {InitFragment[]} */
-		const initFragments = [];
+	sortWith(sortFn) {
+		if (this.size <= 1 || sortFn === this._lastActiveSortFn) {
+			// already sorted - nothing to do
+			return;
+		}
 
-		const exportsInfo = moduleGraph.getExportsInfo(module);
+		const sortedArray = Array.from(this).sort(sortFn);
+		super.clear();
+		for (let i = 0; i < sortedArray.length; i += 1) {
+			super.add(sortedArray[i]);
+		}
+		this._lastActiveSortFn = sortFn;
+		this._invalidateCache();
+	}
 
-		let needExportsCopy = false;
-		const importedModules = new Map();
-		const initParams = [];
-		let index = 0;
-		for (const dep of module.dependencies) {
-			const moduleDep =
-				dep && dep instanceof ModuleDependency ? dep : undefined;
-			if (moduleGraph.getModule(dep)) {
-				let importData = importedModules.get(moduleGraph.getModule(dep));
-				if (importData === undefined) {
-					importedModules.set(
-						moduleGraph.getModule(dep),
-						(importData = {
-							importVar: `m${index}`,
-							index,
-							request: (moduleDep && moduleDep.userRequest) || undefined,
-							names: new Set(),
-							reexports: []
-						})
-					);
-					index++;
-				}
-				if (dep instanceof WebAssemblyImportDependency) {
-					importData.names.add(dep.name);
-					if (dep.description.type === "GlobalType") {
-						const exportName = dep.name;
-						const importedModule = moduleGraph.getModule(dep);
+	sort() {
+		this.sortWith(this._sortFn);
+		return this;
+	}
 
-						if (importedModule) {
-							const usedName = moduleGraph
-								.getExportsInfo(importedModule)
-								.getUsedName(exportName, runtime);
-							if (usedName) {
-								initParams.push(
-									runtimeTemplate.exportFromImport({
-										moduleGraph,
-										module: importedModule,
-										request: dep.request,
-										importVar: importData.importVar,
-										originModule: module,
-										exportName: dep.name,
-										asiSafe: true,
-										isCall: false,
-										callContext: null,
-										defaultInterop: true,
-										initFragments,
-										runtime,
-										runtimeRequirements
-									})
-								);
-							}
-						}
-					}
-				}
-				if (dep instanceof WebAssemblyExportImportedDependency) {
-					importData.names.add(dep.name);
-					const usedName = moduleGraph
-						.getExportsInfo(module)
-						.getUsedName(dep.exportName, runtime);
-					if (usedName) {
-						runtimeRequirements.add(RuntimeGlobals.exports);
-						const exportProp = `${module.exportsArgument}[${JSON.stringify(
-							usedName
-						)}]`;
-						const defineStatement = Template.asString([
-							`${exportProp} = ${runtimeTemplate.exportFromImport({
-								moduleGraph,
-								module: moduleGraph.getModule(dep),
-								request: dep.request,
-								importVar: importData.importVar,
-								originModule: module,
-								exportName: dep.name,
-								asiSafe: true,
-								isCall: false,
-								callContext: null,
-								defaultInterop: true,
-								initFragments,
-								runtime,
-								runtimeRequirements
-							})};`,
-							`if(WebAssembly.Global) ${exportProp} = ` +
-								`new WebAssembly.Global({ value: ${JSON.stringify(
-									dep.valueType
-								)} }, ${exportProp});`
-						]);
-						importData.reexports.push(defineStatement);
-						needExportsCopy = true;
-					}
-				}
+	/**
+	 * Get data from cache
+	 * @template R
+	 * @param {function(SortableSet<T>): R} fn function to calculate value
+	 * @returns {R} returns result of fn(this), cached until set changes
+	 */
+	getFromCache(fn) {
+		if (this._cache === undefined) {
+			this._cache = new Map();
+		} else {
+			const result = this._cache.get(fn);
+			const data = /** @type {R} */ (result);
+			if (data !== undefined) {
+				return data;
 			}
 		}
-		const importsCode = Template.asString(
-			Array.from(
-				importedModules,
-				([module, { importVar, request, reexports }]) => {
-					const importStatement = runtimeTemplate.importStatement({
-						module,
-						chunkGraph,
-						request,
-						importVar,
-						originModule: module,
-						runtimeRequirements
-					});
-					return importStatement[0] + importStatement[1] + reexports.join("\n");
-				}
-			)
-		);
-
-		const copyAllExports =
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused &&
-			!needExportsCopy;
+		const newData = fn(this);
+		this._cache.set(fn, newData);
+		return newData;
+	}
 
-		// need these globals
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.wasmInstances);
-		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
-			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
-			runtimeRequirements.add(RuntimeGlobals.exports);
-		}
-		if (!copyAllExports) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
+	/**
+	 * Get data from cache (ignoring sorting)
+	 * @template R
+	 * @param {function(SortableSet<T>): R} fn function to calculate value
+	 * @returns {R} returns result of fn(this), cached until set changes
+	 */
+	getFromUnorderedCache(fn) {
+		if (this._cacheOrderIndependent === undefined) {
+			this._cacheOrderIndependent = new Map();
+		} else {
+			const result = this._cacheOrderIndependent.get(fn);
+			const data = /** @type {R} */ (result);
+			if (data !== undefined) {
+				return data;
+			}
 		}
+		const newData = fn(this);
+		this._cacheOrderIndependent.set(fn, newData);
+		return newData;
+	}
 
-		// create source
-		const source = new RawSource(
-			[
-				'"use strict";',
-				"// Instantiate WebAssembly module",
-				`var wasmExports = ${RuntimeGlobals.wasmInstances}[${module.moduleArgument}.id];`,
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_invalidateCache() {
+		if (this._cache !== undefined) {
+			this._cache.clear();
+		}
+	}
 
-				exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused
-					? `${RuntimeGlobals.makeNamespaceObject}(${module.exportsArgument});`
-					: "",
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_invalidateOrderedCache() {
+		if (this._cacheOrderIndependent !== undefined) {
+			this._cacheOrderIndependent.clear();
+		}
+	}
 
-				// this must be before import for circular dependencies
-				"// export exports from WebAssembly module",
-				copyAllExports
-					? `${module.moduleArgument}.exports = wasmExports;`
-					: "for(var name in wasmExports) " +
-					  `if(name) ` +
-					  `${module.exportsArgument}[name] = wasmExports[name];`,
-				"// exec imports from WebAssembly module (for esm order)",
-				importsCode,
-				"",
-				"// exec wasm module",
-				`wasmExports[""](${initParams.join(", ")})`
-			].join("\n")
-		);
-		return InitFragment.addToSource(source, initFragments, generateContext);
+	/**
+	 * @returns {T[]} the raw array
+	 */
+	toJSON() {
+		return Array.from(this);
 	}
 }
 
-module.exports = WebAssemblyJavascriptGenerator;
+module.exports = SortableSet;
 
 
 /***/ }),
 
-/***/ 53639:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 64985:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -131707,147 +129869,115 @@ module.exports = WebAssemblyJavascriptGenerator;
 
 
 
-const Generator = __webpack_require__(93401);
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-const WebAssemblyImportDependency = __webpack_require__(5239);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const memoize = __webpack_require__(78676);
-const WebAssemblyInInitialChunkError = __webpack_require__(47342);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/**
+ * @template K
+ * @template V
+ */
+class StackedCacheMap {
+	constructor() {
+		/** @type {Map<K, V>} */
+		this.map = new Map();
+		/** @type {ReadonlyMap<K, V>[]} */
+		this.stack = [];
+	}
 
-const getWebAssemblyGenerator = memoize(() =>
-	__webpack_require__(47012)
-);
-const getWebAssemblyJavascriptGenerator = memoize(() =>
-	__webpack_require__(46545)
-);
-const getWebAssemblyParser = memoize(() => __webpack_require__(57059));
+	/**
+	 * @param {ReadonlyMap<K, V>} map map to add
+	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
+	 */
+	addAll(map, immutable) {
+		if (immutable) {
+			this.stack.push(map);
 
-class WebAssemblyModulesPlugin {
-	constructor(options) {
-		this.options = options;
+			// largest map should go first
+			for (let i = this.stack.length - 1; i > 0; i--) {
+				const beforeLast = this.stack[i - 1];
+				if (beforeLast.size >= map.size) break;
+				this.stack[i] = beforeLast;
+				this.stack[i - 1] = map;
+			}
+		} else {
+			for (const [key, value] of map) {
+				this.map.set(key, value);
+			}
+		}
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {K} item the key of the element to add
+	 * @param {V} value the value of the element to add
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WebAssemblyModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WebAssemblyImportDependency,
-					normalModuleFactory
-				);
-
-				compilation.dependencyFactories.set(
-					WebAssemblyExportImportedDependency,
-					normalModuleFactory
-				);
-
-				normalModuleFactory.hooks.createParser
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
-						const WebAssemblyParser = getWebAssemblyParser();
-
-						return new WebAssemblyParser();
-					});
-
-				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
-						const WebAssemblyJavascriptGenerator =
-							getWebAssemblyJavascriptGenerator();
-						const WebAssemblyGenerator = getWebAssemblyGenerator();
+	set(item, value) {
+		this.map.set(item, value);
+	}
 
-						return Generator.byType({
-							javascript: new WebAssemblyJavascriptGenerator(),
-							webassembly: new WebAssemblyGenerator(this.options)
-						});
-					});
+	/**
+	 * @param {K} item the item to delete
+	 * @returns {void}
+	 */
+	delete(item) {
+		throw new Error("Items can't be deleted from a StackedCacheMap");
+	}
 
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { chunkGraph } = compilation;
-						const { chunk, outputOptions, codeGenerationResults } = options;
+	/**
+	 * @param {K} item the item to test
+	 * @returns {boolean} true if the item exists in this set
+	 */
+	has(item) {
+		throw new Error(
+			"Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined"
+		);
+	}
 
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === "webassembly/sync") {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
+	/**
+	 * @param {K} item the key of the element to return
+	 * @returns {V} the value of the element
+	 */
+	get(item) {
+		for (const map of this.stack) {
+			const value = map.get(item);
+			if (value !== undefined) return value;
+		}
+		return this.map.get(item);
+	}
 
-								result.push({
-									render: () =>
-										codeGenerationResults.getSource(
-											module,
-											chunk.runtime,
-											"webassembly"
-										),
-									filenameTemplate,
-									pathOptions: {
-										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
-						}
+	clear() {
+		this.stack.length = 0;
+		this.map.clear();
+	}
 
-						return result;
-					}
-				);
+	get size() {
+		let size = this.map.size;
+		for (const map of this.stack) {
+			size += map.size;
+		}
+		return size;
+	}
 
-				compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
-					const chunkGraph = compilation.chunkGraph;
-					const initialWasmModules = new Set();
-					for (const chunk of compilation.chunks) {
-						if (chunk.canBeInitial()) {
-							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								if (module.type === "webassembly/sync") {
-									initialWasmModules.add(module);
-								}
-							}
-						}
-					}
-					for (const module of initialWasmModules) {
-						compilation.errors.push(
-							new WebAssemblyInInitialChunkError(
-								module,
-								compilation.moduleGraph,
-								compilation.chunkGraph,
-								compilation.requestShortener
-							)
-						);
-					}
-				});
+	[Symbol.iterator]() {
+		const iterators = this.stack.map(map => map[Symbol.iterator]());
+		let current = this.map[Symbol.iterator]();
+		return {
+			next() {
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = iterators.pop();
+					result = current.next();
+				}
+				return result;
 			}
-		);
+		};
 	}
 }
 
-module.exports = WebAssemblyModulesPlugin;
+module.exports = StackedCacheMap;
 
 
 /***/ }),
 
-/***/ 57059:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 58845:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -131857,197 +129987,171 @@ module.exports = WebAssemblyModulesPlugin;
 
 
 
-const t = __webpack_require__(51826);
-const { moduleContextFromModuleAST } = __webpack_require__(51826);
-const { decode } = __webpack_require__(73726);
-const Parser = __webpack_require__(11715);
-const StaticExportsDependency = __webpack_require__(91418);
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+const TOMBSTONE = Symbol("tombstone");
+const UNDEFINED_MARKER = Symbol("undefined");
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/**
+ * @template T
+ * @typedef {T | undefined} Cell<T>
+ */
 
-const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
+/**
+ * @template T
+ * @typedef {T | typeof TOMBSTONE | typeof UNDEFINED_MARKER} InternalCell<T>
+ */
 
 /**
- * @param {t.Signature} signature the func signature
- * @returns {null | string} the type incompatible with js types
+ * @template K
+ * @template V
+ * @param {[K, InternalCell<V>]} pair the internal cell
+ * @returns {[K, Cell<V>]} its “safe” representation
  */
-const getJsIncompatibleType = signature => {
-	for (const param of signature.params) {
-		if (!JS_COMPAT_TYPES.has(param.valtype)) {
-			return `${param.valtype} as parameter`;
-		}
-	}
-	for (const type of signature.results) {
-		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+const extractPair = pair => {
+	const key = pair[0];
+	const val = pair[1];
+	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
+		return [key, undefined];
+	} else {
+		return /** @type {[K, Cell<V>]} */ (pair);
 	}
-	return null;
 };
 
 /**
- * TODO why are there two different Signature types?
- * @param {t.FuncSignature} signature the func signature
- * @returns {null | string} the type incompatible with js types
+ * @template K
+ * @template V
  */
-const getJsIncompatibleTypeOfFuncSignature = signature => {
-	for (const param of signature.args) {
-		if (!JS_COMPAT_TYPES.has(param)) {
-			return `${param} as parameter`;
-		}
-	}
-	for (const type of signature.result) {
-		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+class StackedMap {
+	/**
+	 * @param {Map<K, InternalCell<V>>[]=} parentStack an optional parent
+	 */
+	constructor(parentStack) {
+		/** @type {Map<K, InternalCell<V>>} */
+		this.map = new Map();
+		/** @type {Map<K, InternalCell<V>>[]} */
+		this.stack = parentStack === undefined ? [] : parentStack.slice();
+		this.stack.push(this.map);
 	}
-	return null;
-};
-
-const decoderOpts = {
-	ignoreCodeSection: true,
-	ignoreDataSection: true,
-
-	// this will avoid having to lookup with identifiers in the ModuleContext
-	ignoreCustomNameSection: true
-};
 
-class WebAssemblyParser extends Parser {
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
+	/**
+	 * @param {K} item the key of the element to add
+	 * @param {V} value the value of the element to add
+	 * @returns {void}
+	 */
+	set(item, value) {
+		this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
 	}
 
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {K} item the item to delete
+	 * @returns {void}
 	 */
-	parse(source, state) {
-		if (!Buffer.isBuffer(source)) {
-			throw new Error("WebAssemblyParser input must be a Buffer");
+	delete(item) {
+		if (this.stack.length > 1) {
+			this.map.set(item, TOMBSTONE);
+		} else {
+			this.map.delete(item);
 		}
+	}
 
-		// flag it as ESM
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
-
-		// parse it
-		const program = decode(source, decoderOpts);
-		const module = program.body[0];
-
-		const moduleContext = moduleContextFromModuleAST(module);
-
-		// extract imports and exports
-		const exports = [];
-		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
-			undefined);
-
-		const importedGlobals = [];
-		t.traverse(module, {
-			ModuleExport({ node }) {
-				const descriptor = node.descr;
-
-				if (descriptor.exportType === "Func") {
-					const funcIdx = descriptor.id.value;
-
-					/** @type {t.FuncSignature} */
-					const funcSignature = moduleContext.getFunction(funcIdx);
-
-					const incompatibleType =
-						getJsIncompatibleTypeOfFuncSignature(funcSignature);
-
-					if (incompatibleType) {
-						if (jsIncompatibleExports === undefined) {
-							jsIncompatibleExports =
-								state.module.buildMeta.jsIncompatibleExports = {};
-						}
-						jsIncompatibleExports[node.name] = incompatibleType;
-					}
+	/**
+	 * @param {K} item the item to test
+	 * @returns {boolean} true if the item exists in this set
+	 */
+	has(item) {
+		const topValue = this.map.get(item);
+		if (topValue !== undefined) {
+			return topValue !== TOMBSTONE;
+		}
+		if (this.stack.length > 1) {
+			for (let i = this.stack.length - 2; i >= 0; i--) {
+				const value = this.stack[i].get(item);
+				if (value !== undefined) {
+					this.map.set(item, value);
+					return value !== TOMBSTONE;
 				}
+			}
+			this.map.set(item, TOMBSTONE);
+		}
+		return false;
+	}
 
-				exports.push(node.name);
-
-				if (node.descr && node.descr.exportType === "Global") {
-					const refNode = importedGlobals[node.descr.id.value];
-					if (refNode) {
-						const dep = new WebAssemblyExportImportedDependency(
-							node.name,
-							refNode.module,
-							refNode.name,
-							refNode.descr.valtype
-						);
-
-						state.module.addDependency(dep);
-					}
+	/**
+	 * @param {K} item the key of the element to return
+	 * @returns {Cell<V>} the value of the element
+	 */
+	get(item) {
+		const topValue = this.map.get(item);
+		if (topValue !== undefined) {
+			return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
+				? undefined
+				: topValue;
+		}
+		if (this.stack.length > 1) {
+			for (let i = this.stack.length - 2; i >= 0; i--) {
+				const value = this.stack[i].get(item);
+				if (value !== undefined) {
+					this.map.set(item, value);
+					return value === TOMBSTONE || value === UNDEFINED_MARKER
+						? undefined
+						: value;
 				}
-			},
-
-			Global({ node }) {
-				const init = node.init[0];
-
-				let importNode = null;
-
-				if (init.id === "get_global") {
-					const globalIdx = init.args[0].value;
+			}
+			this.map.set(item, TOMBSTONE);
+		}
+		return undefined;
+	}
 
-					if (globalIdx < importedGlobals.length) {
-						importNode = importedGlobals[globalIdx];
-					}
+	_compress() {
+		if (this.stack.length === 1) return;
+		this.map = new Map();
+		for (const data of this.stack) {
+			for (const pair of data) {
+				if (pair[1] === TOMBSTONE) {
+					this.map.delete(pair[0]);
+				} else {
+					this.map.set(pair[0], pair[1]);
 				}
+			}
+		}
+		this.stack = [this.map];
+	}
 
-				importedGlobals.push(importNode);
-			},
-
-			ModuleImport({ node }) {
-				/** @type {false | string} */
-				let onlyDirectImport = false;
-
-				if (t.isMemory(node.descr) === true) {
-					onlyDirectImport = "Memory";
-				} else if (t.isTable(node.descr) === true) {
-					onlyDirectImport = "Table";
-				} else if (t.isFuncImportDescr(node.descr) === true) {
-					const incompatibleType = getJsIncompatibleType(node.descr.signature);
-					if (incompatibleType) {
-						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
-					}
-				} else if (t.isGlobalType(node.descr) === true) {
-					const type = node.descr.valtype;
-					if (!JS_COMPAT_TYPES.has(type)) {
-						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
-					}
-				}
+	asArray() {
+		this._compress();
+		return Array.from(this.map.keys());
+	}
 
-				const dep = new WebAssemblyImportDependency(
-					node.module,
-					node.name,
-					node.descr,
-					onlyDirectImport
-				);
+	asSet() {
+		this._compress();
+		return new Set(this.map.keys());
+	}
 
-				state.module.addDependency(dep);
+	asPairArray() {
+		this._compress();
+		return Array.from(this.map.entries(), extractPair);
+	}
 
-				if (t.isGlobalType(node.descr)) {
-					importedGlobals.push(node);
-				}
-			}
-		});
+	asMap() {
+		return new Map(this.asPairArray());
+	}
 
-		state.module.addDependency(new StaticExportsDependency(exports, false));
+	get size() {
+		this._compress();
+		return this.map.size;
+	}
 
-		return state;
+	createChild() {
+		return new StackedMap(this.stack);
 	}
 }
 
-module.exports = WebAssemblyParser;
+module.exports = StackedMap;
 
 
 /***/ }),
 
-/***/ 18650:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 40293:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -132057,69 +130161,59 @@ module.exports = WebAssemblyParser;
 
 
 
-const Template = __webpack_require__(1626);
-const WebAssemblyImportDependency = __webpack_require__(5239);
-
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-
-/** @typedef {Object} UsedWasmDependency
- * @property {WebAssemblyImportDependency} dependency the dependency
- * @property {string} name the export name
- * @property {string} module the module name
- */
-
-const MANGLED_MODULE = "a";
+class StringXor {
+	constructor() {
+		this._value = undefined;
+	}
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} module the module
- * @param {boolean} mangle mangle module and export names
- * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
- */
-const getUsedDependencies = (moduleGraph, module, mangle) => {
-	/** @type {UsedWasmDependency[]} */
-	const array = [];
-	let importIndex = 0;
-	for (const dep of module.dependencies) {
-		if (dep instanceof WebAssemblyImportDependency) {
-			if (
-				dep.description.type === "GlobalType" ||
-				moduleGraph.getModule(dep) === null
-			) {
-				continue;
+	/**
+	 * @param {string} str string
+	 * @returns {void}
+	 */
+	add(str) {
+		const len = str.length;
+		const value = this._value;
+		if (value === undefined) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			for (let i = 0; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
+			}
+			return;
+		}
+		const valueLen = value.length;
+		if (valueLen < len) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			let i;
+			for (i = 0; i < valueLen; i++) {
+				newValue[i] = value[i] ^ str.charCodeAt(i);
+			}
+			for (; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
 			}
-
-			const exportName = dep.name;
-			// TODO add the following 3 lines when removing of ModuleExport is possible
-			// const importedModule = moduleGraph.getModule(dep);
-			// const usedName = importedModule && moduleGraph.getExportsInfo(importedModule).getUsedName(exportName, runtime);
-			// if (usedName !== false) {
-			if (mangle) {
-				array.push({
-					dependency: dep,
-					name: Template.numberToIdentifier(importIndex++),
-					module: MANGLED_MODULE
-				});
-			} else {
-				array.push({
-					dependency: dep,
-					name: exportName,
-					module: dep.request
-				});
+		} else {
+			for (let i = 0; i < len; i++) {
+				value[i] = value[i] ^ str.charCodeAt(i);
 			}
 		}
 	}
-	return array;
-};
 
-exports.getUsedDependencies = getUsedDependencies;
-exports.MANGLED_MODULE = MANGLED_MODULE;
+	toString() {
+		const value = this._value;
+		return value === undefined ? "" : value.toString("latin1");
+	}
+
+	updateHash(hash) {
+		const value = this._value;
+		if (value !== undefined) hash.update(value);
+	}
+}
+
+module.exports = StringXor;
 
 
 /***/ }),
 
-/***/ 78613:
+/***/ 38415:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -132130,123 +130224,66 @@ exports.MANGLED_MODULE = MANGLED_MODULE;
 
 
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
-/** @typedef {import("../Compiler")} Compiler */
-
-/** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
-const enabledTypes = new WeakMap();
-
-const getEnabledTypes = compiler => {
-	let set = enabledTypes.get(compiler);
-	if (set === undefined) {
-		set = new Set();
-		enabledTypes.set(compiler, set);
-	}
-	return set;
-};
+const TupleSet = __webpack_require__(76455);
 
-class EnableWasmLoadingPlugin {
+/**
+ * @template {any[]} T
+ */
+class TupleQueue {
 	/**
-	 * @param {WasmLoadingType} type library type that should be available
+	 * @param {Iterable<T>=} items The initial elements.
 	 */
-	constructor(type) {
-		this.type = type;
+	constructor(items) {
+		/** @private @type {TupleSet<T>} */
+		this._set = new TupleSet(items);
+		/** @private @type {Iterator<T>} */
+		this._iterator = this._set[Symbol.iterator]();
 	}
 
 	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {WasmLoadingType} type type of library
-	 * @returns {void}
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
 	 */
-	static setEnabled(compiler, type) {
-		getEnabledTypes(compiler).add(type);
+	get length() {
+		return this._set.size;
 	}
 
 	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {WasmLoadingType} type type of library
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
 	 * @returns {void}
 	 */
-	static checkEnabled(compiler, type) {
-		if (!getEnabledTypes(compiler).has(type)) {
-			throw new Error(
-				`Library type "${type}" is not enabled. ` +
-					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
-					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
-					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
-					"These types are enabled: " +
-					Array.from(getEnabledTypes(compiler)).join(", ")
-			);
-		}
+	enqueue(...item) {
+		this._set.add(...item);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
-	apply(compiler) {
-		const { type } = this;
-
-		// Only enable once
-		const enabled = getEnabledTypes(compiler);
-		if (enabled.has(type)) return;
-		enabled.add(type);
-
-		if (typeof type === "string") {
-			switch (type) {
-				case "fetch": {
-					// TODO webpack 6 remove FetchCompileWasmPlugin
-					const FetchCompileWasmPlugin = __webpack_require__(35537);
-					const FetchCompileAsyncWasmPlugin = __webpack_require__(8437);
-					new FetchCompileWasmPlugin({
-						mangleImports: compiler.options.optimization.mangleWasmImports
-					}).apply(compiler);
-					new FetchCompileAsyncWasmPlugin().apply(compiler);
-					break;
-				}
-				case "async-node": {
-					// TODO webpack 6 remove ReadFileCompileWasmPlugin
-					const ReadFileCompileWasmPlugin = __webpack_require__(98939);
-					// @ts-expect-error typescript bug for duplicate require
-					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
-					new ReadFileCompileWasmPlugin({
-						mangleImports: compiler.options.optimization.mangleWasmImports
-					}).apply(compiler);
-					new ReadFileCompileAsyncWasmPlugin({ type }).apply(compiler);
-					break;
-				}
-				case "async-node-module": {
-					// @ts-expect-error typescript bug for duplicate require
-					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
-					new ReadFileCompileAsyncWasmPlugin({ type, import: true }).apply(
-						compiler
-					);
-					break;
-				}
-				case "universal":
-					throw new Error(
-						"Universal WebAssembly Loading is not implemented yet"
-					);
-				default:
-					throw new Error(`Unsupported wasm loading type ${type}.
-Plugins which provide custom wasm loading types must call EnableWasmLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
+	dequeue() {
+		const result = this._iterator.next();
+		if (result.done) {
+			if (this._set.size > 0) {
+				this._iterator = this._set[Symbol.iterator]();
+				const value = this._iterator.next().value;
+				this._set.delete(...value);
+				return value;
 			}
-		} else {
-			// TODO support plugin instances here
-			// apply them to the compiler
+			return undefined;
 		}
+		this._set.delete(...result.value);
+		return result.value;
 	}
 }
 
-module.exports = EnableWasmLoadingPlugin;
+module.exports = TupleQueue;
 
 
 /***/ }),
 
-/***/ 8437:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 76455:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -132256,739 +130293,523 @@ module.exports = EnableWasmLoadingPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
-
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @template {any[]} T
+ */
+class TupleSet {
+	constructor(init) {
+		this._map = new Map();
+		this.size = 0;
+		if (init) {
+			for (const tuple of init) {
+				this.add(...tuple);
+			}
+		}
+	}
 
-class FetchCompileAsyncWasmPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param  {T} args tuple
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileAsyncWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.instantiateWasm)
-					.tap("FetchCompileAsyncWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/async"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
-							chunk,
-							new AsyncWasmLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true
-							})
-						);
-					});
+	add(...args) {
+		let map = this._map;
+		for (let i = 0; i < args.length - 2; i++) {
+			const arg = args[i];
+			const innerMap = map.get(arg);
+			if (innerMap === undefined) {
+				map.set(arg, (map = new Map()));
+			} else {
+				map = innerMap;
 			}
-		);
-	}
-}
-
-module.exports = FetchCompileAsyncWasmPlugin;
-
-
-/***/ }),
+		}
 
-/***/ 35537:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const beforeLast = args[args.length - 2];
+		let set = map.get(beforeLast);
+		if (set === undefined) {
+			map.set(beforeLast, (set = new Set()));
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const last = args[args.length - 1];
+		this.size -= set.size;
+		set.add(last);
+		this.size += set.size;
+	}
 
+	/**
+	 * @param  {T} args tuple
+	 * @returns {boolean} true, if the tuple is in the Set
+	 */
+	has(...args) {
+		let map = this._map;
+		for (let i = 0; i < args.length - 2; i++) {
+			const arg = args[i];
+			map = map.get(arg);
+			if (map === undefined) {
+				return false;
+			}
+		}
 
+		const beforeLast = args[args.length - 2];
+		let set = map.get(beforeLast);
+		if (set === undefined) {
+			return false;
+		}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
+		const last = args[args.length - 1];
+		return set.has(last);
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	/**
+	 * @param {T} args tuple
+	 * @returns {void}
+	 */
+	delete(...args) {
+		let map = this._map;
+		for (let i = 0; i < args.length - 2; i++) {
+			const arg = args[i];
+			map = map.get(arg);
+			if (map === undefined) {
+				return;
+			}
+		}
 
-// TODO webpack 6 remove
+		const beforeLast = args[args.length - 2];
+		let set = map.get(beforeLast);
+		if (set === undefined) {
+			return;
+		}
 
-class FetchCompileWasmPlugin {
-	constructor(options) {
-		this.options = options || {};
+		const last = args[args.length - 1];
+		this.size -= set.size;
+		set.delete(last);
+		this.size += set.size;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {Iterator<T>} iterator
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+	[Symbol.iterator]() {
+		const iteratorStack = [];
+		const tuple = [];
+		let currentSetIterator = undefined;
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("FetchCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
+		const next = it => {
+			const result = it.next();
+			if (result.done) {
+				if (iteratorStack.length === 0) return false;
+				tuple.pop();
+				return next(iteratorStack.pop());
+			}
+			const [key, value] = result.value;
+			iteratorStack.push(it);
+			tuple.push(key);
+			if (value instanceof Set) {
+				currentSetIterator = value[Symbol.iterator]();
+				return true;
+			} else {
+				return next(value[Symbol.iterator]());
+			}
+		};
+
+		next(this._map[Symbol.iterator]());
+
+		return {
+			next() {
+				while (currentSetIterator) {
+					const result = currentSetIterator.next();
+					if (result.done) {
+						tuple.pop();
+						if (!next(iteratorStack.pop())) {
+							currentSetIterator = undefined;
 						}
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
-							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
+					} else {
+						return {
+							done: false,
+							value: /** @type {T} */ (tuple.concat(result.value))
+						};
+					}
+				}
+				return { done: true, value: undefined };
 			}
-		);
+		};
 	}
 }
 
-module.exports = FetchCompileWasmPlugin;
+module.exports = TupleSet;
 
 
 /***/ }),
 
-/***/ 83121:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 54500:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
+/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
+/** @typedef {(error: Error|null, result?: Buffer) => void} ErrorFirstCallback */
 
-/** @typedef {import("../Compiler")} Compiler */
+const backSlashCharCode = "\\".charCodeAt(0);
+const slashCharCode = "/".charCodeAt(0);
+const aLowerCaseCharCode = "a".charCodeAt(0);
+const zLowerCaseCharCode = "z".charCodeAt(0);
+const aUpperCaseCharCode = "A".charCodeAt(0);
+const zUpperCaseCharCode = "Z".charCodeAt(0);
+const _0CharCode = "0".charCodeAt(0);
+const _9CharCode = "9".charCodeAt(0);
+const plusCharCode = "+".charCodeAt(0);
+const hyphenCharCode = "-".charCodeAt(0);
+const colonCharCode = ":".charCodeAt(0);
+const hashCharCode = "#".charCodeAt(0);
+const queryCharCode = "?".charCodeAt(0);
+/**
+ * Get scheme if specifier is an absolute URL specifier
+ * e.g. Absolute specifiers like 'file:///user/webpack/index.js'
+ * https://tools.ietf.org/html/rfc3986#section-3.1
+ * @param {string} specifier specifier
+ * @returns {string|undefined} scheme if absolute URL specifier provided
+ */
+function getScheme(specifier) {
+	const start = specifier.charCodeAt(0);
 
-class JsonpChunkLoadingPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"JsonpChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === "jsonp";
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new JsonpChunkLoadingRuntimeModule(set)
-					);
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("JsonpChunkLoadingPlugin", handler);
+	// First char maybe only a letter
+	if (
+		(start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
+		(start < aUpperCaseCharCode || start > zUpperCaseCharCode)
+	) {
+		return undefined;
+	}
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.loadScript);
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.loadScript);
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
-			}
-		);
+	let i = 1;
+	let ch = specifier.charCodeAt(i);
+
+	while (
+		(ch >= aLowerCaseCharCode && ch <= zLowerCaseCharCode) ||
+		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
+		(ch >= _0CharCode && ch <= _9CharCode) ||
+		ch === plusCharCode ||
+		ch === hyphenCharCode
+	) {
+		if (++i === specifier.length) return undefined;
+		ch = specifier.charCodeAt(i);
+	}
+
+	// Scheme must end with colon
+	if (ch !== colonCharCode) return undefined;
+
+	// Check for Windows absolute path
+	// https://url.spec.whatwg.org/#url-miscellaneous
+	if (i === 1) {
+		const nextChar = i + 1 < specifier.length ? specifier.charCodeAt(i + 1) : 0;
+		if (
+			nextChar === 0 ||
+			nextChar === backSlashCharCode ||
+			nextChar === slashCharCode ||
+			nextChar === hashCharCode ||
+			nextChar === queryCharCode
+		) {
+			return undefined;
+		}
 	}
+
+	return specifier.slice(0, i).toLowerCase();
 }
 
-module.exports = JsonpChunkLoadingPlugin;
+/**
+ * @param {string} specifier specifier
+ * @returns {string|null} protocol if absolute URL specifier provided
+ */
+function getProtocol(specifier) {
+	const scheme = getScheme(specifier);
+	return scheme === undefined ? undefined : scheme + ":";
+}
+
+exports.getScheme = getScheme;
+exports.getProtocol = getProtocol;
 
 
 /***/ }),
 
-/***/ 84154:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 28745:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(6967);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const chunkHasJs = (__webpack_require__(89464).chunkHasJs);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-
-/** @typedef {import("../Chunk")} Chunk */
+const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
 /**
- * @typedef {Object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ * @template {any[]} T
+ * @template V
  */
+class WeakTupleMap {
+	constructor() {
+		/** @private */
+		this.f = 0;
+		/** @private @type {any} */
+		this.v = undefined;
+		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+		this.m = undefined;
+		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+		this.w = undefined;
+	}
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
+	 * @param {[...T, V]} args tuple
+	 * @returns {void}
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
+	set(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length - 1; i++) {
+			node = node._get(args[i]);
 		}
-		return hooks;
+		node._setValue(args[args.length - 1]);
 	}
 
-	constructor(runtimeRequirements) {
-		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
-		this._runtimeRequirements = runtimeRequirements;
+	/**
+	 * @param {T} args tuple
+	 * @returns {boolean} true, if the tuple is in the Set
+	 */
+	has(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length; i++) {
+			node = node._peek(args[i]);
+			if (node === undefined) return false;
+		}
+		return node._hasValue();
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {T} args tuple
+	 * @returns {V} the value
 	 */
-	generate() {
-		const { chunkGraph, compilation, chunk } = this;
-		const {
-			runtimeTemplate,
-			outputOptions: {
-				chunkLoadingGlobal,
-				hotUpdateGlobal,
-				crossOriginLoading,
-				scriptType
-			}
-		} = compilation;
-		const globalObject = runtimeTemplate.globalObject;
-		const { linkPreload, linkPrefetch } =
-			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withLoading = this._runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withCallback = this._runtimeRequirements.has(
-			RuntimeGlobals.chunkCallback
-		);
-		const withOnChunkLoad = this._runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withHmr = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const withPrefetch = this._runtimeRequirements.has(
-			RuntimeGlobals.prefetchChunkHandlers
-		);
-		const withPreload = this._runtimeRequirements.has(
-			RuntimeGlobals.preloadChunkHandlers
-		);
-		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
-			chunkLoadingGlobal
-		)}]`;
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp`
-			: undefined;
+	get(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length; i++) {
+			node = node._peek(args[i]);
+			if (node === undefined) return undefined;
+		}
+		return node._getValue();
+	}
 
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withLoading
-				? Template.asString([
-						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? Template.indent([
-										"// JSONP chunk loading for javascript",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[2]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasJsMatcher === true
-													? "if(true) { // all chunks have JS"
-													: `if(${hasJsMatcher("chunkId")}) {`,
-												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
-														"resolve, reject"
-													)});`,
-													"promises.push(installedChunkData[2] = promise);",
-													"",
-													"// start chunk loading",
-													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
-													"// create error before stack unwound to get useful stacktrace later",
-													"var error = new Error();",
-													`var loadingEnded = ${runtimeTemplate.basicFunction(
-														"event",
-														[
-															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
-															Template.indent([
-																"installedChunkData = installedChunks[chunkId];",
-																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
-																"if(installedChunkData) {",
-																Template.indent([
-																	"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-																	"var realSrc = event && event.target && event.target.src;",
-																	"error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-																	"error.name = 'ChunkLoadError';",
-																	"error.type = errorType;",
-																	"error.request = realSrc;",
-																	"installedChunkData[1](error);"
-																]),
-																"}"
-															]),
-															"}"
-														]
-													)};`,
-													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
-												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ])
-								: Template.indent(["installedChunks[chunkId] = 0;"])
-						)};`
-				  ])
-				: "// no chunk on demand loading",
-			"",
-			withPrefetch && hasJsMatcher !== false
-				? `${
-						RuntimeGlobals.prefetchChunkHandlers
-				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
-						`if((!${
-							RuntimeGlobals.hasOwnProperty
-						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
-							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
-						}) {`,
-						Template.indent([
-							"installedChunks[chunkId] = null;",
-							linkPrefetch.call(
-								Template.asString([
-									"var link = document.createElement('link');",
-									crossOriginLoading
-										? `link.crossOrigin = ${JSON.stringify(
-												crossOriginLoading
-										  )};`
-										: "",
-									`if (${RuntimeGlobals.scriptNonce}) {`,
-									Template.indent(
-										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
-									),
-									"}",
-									'link.rel = "prefetch";',
-									'link.as = "script";',
-									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`
-								]),
-								chunk
-							),
-							"document.head.appendChild(link);"
-						]),
-						"}"
-				  ])};`
-				: "// no prefetching",
-			"",
-			withPreload && hasJsMatcher !== false
-				? `${
-						RuntimeGlobals.preloadChunkHandlers
-				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
-						`if((!${
-							RuntimeGlobals.hasOwnProperty
-						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
-							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
-						}) {`,
-						Template.indent([
-							"installedChunks[chunkId] = null;",
-							linkPreload.call(
-								Template.asString([
-									"var link = document.createElement('link');",
-									scriptType
-										? `link.type = ${JSON.stringify(scriptType)};`
-										: "",
-									"link.charset = 'utf-8';",
-									`if (${RuntimeGlobals.scriptNonce}) {`,
-									Template.indent(
-										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
-									),
-									"}",
-									'link.rel = "preload";',
-									'link.as = "script";',
-									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
-									crossOriginLoading
-										? Template.asString([
-												"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
-												Template.indent(
-													`link.crossOrigin = ${JSON.stringify(
-														crossOriginLoading
-													)};`
-												),
-												"}"
-										  ])
-										: ""
-								]),
-								chunk
-							),
-							"document.head.appendChild(link);"
-						]),
-						"}"
-				  ])};`
-				: "// no preloaded",
-			"",
-			withHmr
-				? Template.asString([
-						"var currentUpdatedModulesList;",
-						"var waitingUpdateResolves = {};",
-						"function loadUpdateChunk(chunkId) {",
-						Template.indent([
-							`return new Promise(${runtimeTemplate.basicFunction(
-								"resolve, reject",
-								[
-									"waitingUpdateResolves[chunkId] = resolve;",
-									"// start update chunk loading",
-									`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
-									"// create error before stack unwound to get useful stacktrace later",
-									"var error = new Error();",
-									`var loadingEnded = ${runtimeTemplate.basicFunction("event", [
-										"if(waitingUpdateResolves[chunkId]) {",
-										Template.indent([
-											"waitingUpdateResolves[chunkId] = undefined",
-											"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-											"var realSrc = event && event.target && event.target.src;",
-											"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-											"error.name = 'ChunkLoadError';",
-											"error.type = errorType;",
-											"error.request = realSrc;",
-											"reject(error);"
-										]),
-										"}"
-									])};`,
-									`${RuntimeGlobals.loadScript}(url, loadingEnded);`
-								]
-							)});`
-						]),
-						"}",
-						"",
-						`${globalObject}[${JSON.stringify(
-							hotUpdateGlobal
-						)}] = ${runtimeTemplate.basicFunction(
-							"chunkId, moreModules, runtime",
-							[
-								"for(var moduleId in moreModules) {",
-								Template.indent([
-									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-									Template.indent([
-										"currentUpdate[moduleId] = moreModules[moduleId];",
-										"if(currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);"
-									]),
-									"}"
-								]),
-								"}",
-								"if(runtime) currentUpdateRuntime.push(runtime);",
-								"if(waitingUpdateResolves[chunkId]) {",
-								Template.indent([
-									"waitingUpdateResolves[chunkId]();",
-									"waitingUpdateResolves[chunkId] = undefined;"
-								]),
-								"}"
-							]
-						)};`,
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "jsonp")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${
-							RuntimeGlobals.hmrDownloadManifest
-						} = ${runtimeTemplate.basicFunction("", [
-							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
-							`return fetch(${RuntimeGlobals.publicPath} + ${
-								RuntimeGlobals.getUpdateManifestFilename
-							}()).then(${runtimeTemplate.basicFunction("response", [
-								"if(response.status === 404) return; // no update available",
-								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
-								"return response.json();"
-							])});`
-						])};`
-				  ])
-				: "// no HMR manifest",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.j = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId] === 0",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded",
-			"",
-			withCallback || withLoading
-				? Template.asString([
-						"// install a JSONP callback for chunk loading",
-						`var webpackJsonpCallback = ${runtimeTemplate.basicFunction(
-							"parentChunkLoadingFunction, data",
-							[
-								runtimeTemplate.destructureArray(
-									["chunkIds", "moreModules", "runtime"],
-									"data"
-								),
-								'// add "moreModules" to the modules object,',
-								'// then flag all "chunkIds" as loaded and fire callback',
-								"var moduleId, chunkId, i = 0;",
-								`if(chunkIds.some(${runtimeTemplate.returningFunction(
-									"installedChunks[id] !== 0",
-									"id"
-								)})) {`,
-								Template.indent([
-									"for(moduleId in moreModules) {",
-									Template.indent([
-										`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-										Template.indent(
-											`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-										),
-										"}"
-									]),
-									"}",
-									"if(runtime) var result = runtime(__webpack_require__);"
-								]),
-								"}",
-								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",
-								"for(;i < chunkIds.length; i++) {",
-								Template.indent([
-									"chunkId = chunkIds[i];",
-									`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
-									Template.indent("installedChunks[chunkId][0]();"),
-									"}",
-									"installedChunks[chunkId] = 0;"
-								]),
-								"}",
-								withOnChunkLoad
-									? `return ${RuntimeGlobals.onChunksLoaded}(result);`
-									: ""
-							]
-						)}`,
-						"",
-						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
-						"chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));",
-						"chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));"
-				  ])
-				: "// no jsonp function"
-		]);
+	/**
+	 * @param {[...T, function(): V]} args tuple
+	 * @returns {V} the value
+	 */
+	provide(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length - 1; i++) {
+			node = node._get(args[i]);
+		}
+		if (node._hasValue()) return node._getValue();
+		const fn = args[args.length - 1];
+		const newValue = fn(...args.slice(0, -1));
+		node._setValue(newValue);
+		return newValue;
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {void}
+	 */
+	delete(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length; i++) {
+			node = node._peek(args[i]);
+			if (node === undefined) return;
+		}
+		node._deleteValue();
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	clear() {
+		this.f = 0;
+		this.v = undefined;
+		this.w = undefined;
+		this.m = undefined;
+	}
+
+	_getValue() {
+		return this.v;
+	}
+
+	_hasValue() {
+		return (this.f & 1) === 1;
+	}
+
+	_setValue(v) {
+		this.f |= 1;
+		this.v = v;
+	}
+
+	_deleteValue() {
+		this.f &= 6;
+		this.v = undefined;
+	}
+
+	_peek(thing) {
+		if (isWeakKey(thing)) {
+			if ((this.f & 4) !== 4) return undefined;
+			return this.w.get(thing);
+		} else {
+			if ((this.f & 2) !== 2) return undefined;
+			return this.m.get(thing);
+		}
+	}
+
+	_get(thing) {
+		if (isWeakKey(thing)) {
+			if ((this.f & 4) !== 4) {
+				const newMap = new WeakMap();
+				this.f |= 4;
+				const newNode = new WeakTupleMap();
+				(this.w = newMap).set(thing, newNode);
+				return newNode;
+			}
+			const entry = this.w.get(thing);
+			if (entry !== undefined) {
+				return entry;
+			}
+			const newNode = new WeakTupleMap();
+			this.w.set(thing, newNode);
+			return newNode;
+		} else {
+			if ((this.f & 2) !== 2) {
+				const newMap = new Map();
+				this.f |= 2;
+				const newNode = new WeakTupleMap();
+				(this.m = newMap).set(thing, newNode);
+				return newNode;
+			}
+			const entry = this.m.get(thing);
+			if (entry !== undefined) {
+				return entry;
+			}
+			const newNode = new WeakTupleMap();
+			this.m.set(thing, newNode);
+			return newNode;
+		}
 	}
 }
 
-module.exports = JsonpChunkLoadingRuntimeModule;
+module.exports = WeakTupleMap;
 
 
 /***/ }),
 
-/***/ 4607:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 92229:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Mikola Lysenko @mikolalysenko
 */
 
 
 
-const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
-const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
+/* cspell:disable-next-line */
+// Refactor: Peter Somogyvari @petermetz
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
+const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
+	const code = [
+		"function ",
+		funcName,
+		"(a,l,h,",
+		extraArgs.join(","),
+		"){",
+		earlyOut ? "" : "var i=",
+		reversed ? "l-1" : "h+1",
+		";while(l<=h){var m=(l+h)>>>1,x=a[m]"
+	];
 
-class JsonpTemplatePlugin {
-	/**
-	 * @deprecated use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpChunkLoadingRuntimeModule.JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		return JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
+	if (earlyOut) {
+		if (predicate.indexOf("c") < 0) {
+			code.push(";if(x===y){return m}else if(x<=y){");
+		} else {
+			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
+		}
+	} else {
+		code.push(";if(", predicate, "){i=m;");
 	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.options.output.chunkLoading = "jsonp";
-		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
-		new EnableChunkLoadingPlugin("jsonp").apply(compiler);
+	if (reversed) {
+		code.push("l=m+1}else{h=m-1}");
+	} else {
+		code.push("h=m-1}else{l=m+1}");
 	}
-}
+	code.push("}");
+	if (earlyOut) {
+		code.push("return -1};");
+	} else {
+		code.push("return i};");
+	}
+	return code.join("");
+};
 
-module.exports = JsonpTemplatePlugin;
+const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
+	const arg1 = compileSearch(
+		"A",
+		"x" + predicate + "y",
+		reversed,
+		["y"],
+		earlyOut
+	);
+
+	const arg2 = compileSearch(
+		"P",
+		"c(x,y)" + predicate + "0",
+		reversed,
+		["y", "c"],
+		earlyOut
+	);
+
+	const fnHeader = "function dispatchBinarySearch";
+
+	const fnBody =
+		"(a,y,c,l,h){\
+if(typeof(c)==='function'){\
+return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
+}else{\
+return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
+}}\
+return dispatchBinarySearch";
+
+	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
+	const fnSource = fnArgList.join("");
+	const result = new Function(fnSource);
+	return result();
+};
+
+module.exports = {
+	ge: compileBoundsSearch(">=", false, "GE"),
+	gt: compileBoundsSearch(">", false, "GT"),
+	lt: compileBoundsSearch("<", true, "LT"),
+	le: compileBoundsSearch("<=", true, "LE"),
+	eq: compileBoundsSearch("-", true, "EQ", true)
+};
 
 
 /***/ }),
 
-/***/ 36243:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 60839:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -132998,514 +130819,573 @@ module.exports = JsonpTemplatePlugin;
 
 
 
-const util = __webpack_require__(73837);
-const webpackOptionsSchemaCheck = __webpack_require__(10382);
-const webpackOptionsSchema = __webpack_require__(73342);
-const Compiler = __webpack_require__(70845);
-const MultiCompiler = __webpack_require__(33370);
-const WebpackOptionsApply = __webpack_require__(88422);
-const {
-	applyWebpackOptionsDefaults,
-	applyWebpackOptionsBaseDefaults
-} = __webpack_require__(92988);
-const { getNormalizedWebpackOptions } = __webpack_require__(26693);
-const NodeEnvironmentPlugin = __webpack_require__(7553);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
-/** @typedef {import("./Compiler").WatchOptions} WatchOptions */
-/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
-/** @typedef {import("./MultiStats")} MultiStats */
-/** @typedef {import("./Stats")} Stats */
-
-const getValidateSchema = memoize(() => __webpack_require__(12047));
+/** @type {WeakMap<object, WeakMap<object, object>>} */
+const mergeCache = new WeakMap();
+/** @type {WeakMap<object, Map<string, Map<string|number|boolean, object>>>} */
+const setPropertyCache = new WeakMap();
+const DELETE = Symbol("DELETE");
+const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 
 /**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
  * @template T
- * @callback Callback
- * @param {Error=} err
- * @param {T=} stats
- * @returns {void}
+ * @template O
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {T} first first object
+ * @param {O} second second object
+ * @returns {T & O | T | O} merged object of first and second object
  */
+const cachedCleverMerge = (first, second) => {
+	if (second === undefined) return first;
+	if (first === undefined) return second;
+	if (typeof second !== "object" || second === null) return second;
+	if (typeof first !== "object" || first === null) return first;
 
-/**
- * @param {ReadonlyArray<WebpackOptions>} childOptions options array
- * @param {MultiCompilerOptions} options options
- * @returns {MultiCompiler} a multi-compiler
- */
-const createMultiCompiler = (childOptions, options) => {
-	const compilers = childOptions.map(options => createCompiler(options));
-	const compiler = new MultiCompiler(compilers, options);
-	for (const childCompiler of compilers) {
-		if (childCompiler.options.dependencies) {
-			compiler.setDependencies(
-				childCompiler,
-				childCompiler.options.dependencies
-			);
-		}
+	let innerCache = mergeCache.get(first);
+	if (innerCache === undefined) {
+		innerCache = new WeakMap();
+		mergeCache.set(first, innerCache);
 	}
-	return compiler;
+	const prevMerge = innerCache.get(second);
+	if (prevMerge !== undefined) return prevMerge;
+	const newMerge = _cleverMerge(first, second, true);
+	innerCache.set(second, newMerge);
+	return newMerge;
 };
 
 /**
- * @param {WebpackOptions} rawOptions options object
- * @returns {Compiler} a compiler
+ * @template T
+ * @param {Partial<T>} obj object
+ * @param {string} property property
+ * @param {string|number|boolean} value assignment value
+ * @returns {T} new object
  */
-const createCompiler = rawOptions => {
-	const options = getNormalizedWebpackOptions(rawOptions);
-	applyWebpackOptionsBaseDefaults(options);
-	const compiler = new Compiler(options.context, options);
-	new NodeEnvironmentPlugin({
-		infrastructureLogging: options.infrastructureLogging
-	}).apply(compiler);
-	if (Array.isArray(options.plugins)) {
-		for (const plugin of options.plugins) {
-			if (typeof plugin === "function") {
-				plugin.call(compiler, compiler);
-			} else {
-				plugin.apply(compiler);
-			}
-		}
+const cachedSetProperty = (obj, property, value) => {
+	let mapByProperty = setPropertyCache.get(obj);
+
+	if (mapByProperty === undefined) {
+		mapByProperty = new Map();
+		setPropertyCache.set(obj, mapByProperty);
 	}
-	applyWebpackOptionsDefaults(options);
-	compiler.hooks.environment.call();
-	compiler.hooks.afterEnvironment.call();
-	new WebpackOptionsApply().process(options, compiler);
-	compiler.hooks.initialize.call();
-	return compiler;
+
+	let mapByValue = mapByProperty.get(property);
+
+	if (mapByValue === undefined) {
+		mapByValue = new Map();
+		mapByProperty.set(property, mapByValue);
+	}
+
+	let result = mapByValue.get(value);
+
+	if (result) return result;
+
+	result = {
+		...obj,
+		[property]: value
+	};
+	mapByValue.set(value, result);
+
+	return result;
 };
 
 /**
- * @callback WebpackFunctionSingle
- * @param {WebpackOptions} options options object
- * @param {Callback<Stats>=} callback callback
- * @returns {Compiler} the compiler object
+ * @typedef {Object} ObjectParsedPropertyEntry
+ * @property {any | undefined} base base value
+ * @property {string | undefined} byProperty the name of the selector property
+ * @property {Map<string, any>} byValues value depending on selector property, merged with base
  */
 
 /**
- * @callback WebpackFunctionMulti
- * @param {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} options options objects
- * @param {Callback<MultiStats>=} callback callback
- * @returns {MultiCompiler} the multi compiler object
+ * @typedef {Object} ParsedObject
+ * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
+ * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
  */
 
-const asArray = options =>
-	Array.isArray(options) ? Array.from(options) : [options];
+/** @type {WeakMap<object, ParsedObject>} */
+const parseCache = new WeakMap();
 
-const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
-	/**
-	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
-	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
-	 * @returns {Compiler | MultiCompiler}
-	 */
-	(options, callback) => {
-		const create = () => {
-			if (!asArray(options).every(webpackOptionsSchemaCheck)) {
-				getValidateSchema()(webpackOptionsSchema, options);
-				util.deprecate(
-					() => {},
-					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
-					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
-				)();
-			}
-			/** @type {MultiCompiler|Compiler} */
-			let compiler;
-			let watch = false;
-			/** @type {WatchOptions|WatchOptions[]} */
-			let watchOptions;
-			if (Array.isArray(options)) {
-				/** @type {MultiCompiler} */
-				compiler = createMultiCompiler(
-					options,
-					/** @type {MultiCompilerOptions} */ (options)
-				);
-				watch = options.some(options => options.watch);
-				watchOptions = options.map(options => options.watchOptions || {});
-			} else {
-				const webpackOptions = /** @type {WebpackOptions} */ (options);
-				/** @type {Compiler} */
-				compiler = createCompiler(webpackOptions);
-				watch = webpackOptions.watch;
-				watchOptions = webpackOptions.watchOptions || {};
-			}
-			return { compiler, watch, watchOptions };
+/**
+ * @param {object} obj the object
+ * @returns {ParsedObject} parsed object
+ */
+const cachedParseObject = obj => {
+	const entry = parseCache.get(obj);
+	if (entry !== undefined) return entry;
+	const result = parseObject(obj);
+	parseCache.set(obj, result);
+	return result;
+};
+
+/**
+ * @param {object} obj the object
+ * @returns {ParsedObject} parsed object
+ */
+const parseObject = obj => {
+	const info = new Map();
+	let dynamicInfo;
+	const getInfo = p => {
+		const entry = info.get(p);
+		if (entry !== undefined) return entry;
+		const newEntry = {
+			base: undefined,
+			byProperty: undefined,
+			byValues: undefined
 		};
-		if (callback) {
-			try {
-				const { compiler, watch, watchOptions } = create();
-				if (watch) {
-					compiler.watch(watchOptions, callback);
+		info.set(p, newEntry);
+		return newEntry;
+	};
+	for (const key of Object.keys(obj)) {
+		if (key.startsWith("by")) {
+			const byProperty = key;
+			const byObj = obj[byProperty];
+			if (typeof byObj === "object") {
+				for (const byValue of Object.keys(byObj)) {
+					const obj = byObj[byValue];
+					for (const key of Object.keys(obj)) {
+						const entry = getInfo(key);
+						if (entry.byProperty === undefined) {
+							entry.byProperty = byProperty;
+							entry.byValues = new Map();
+						} else if (entry.byProperty !== byProperty) {
+							throw new Error(
+								`${byProperty} and ${entry.byProperty} for a single property is not supported`
+							);
+						}
+						entry.byValues.set(byValue, obj[key]);
+						if (byValue === "default") {
+							for (const otherByValue of Object.keys(byObj)) {
+								if (!entry.byValues.has(otherByValue))
+									entry.byValues.set(otherByValue, undefined);
+							}
+						}
+					}
+				}
+			} else if (typeof byObj === "function") {
+				if (dynamicInfo === undefined) {
+					dynamicInfo = {
+						byProperty: key,
+						fn: byObj
+					};
 				} else {
-					compiler.run((err, stats) => {
-						compiler.close(err2 => {
-							callback(err || err2, stats);
-						});
-					});
+					throw new Error(
+						`${key} and ${dynamicInfo.byProperty} when both are functions is not supported`
+					);
 				}
-				return compiler;
-			} catch (err) {
-				process.nextTick(() => callback(err));
-				return null;
+			} else {
+				const entry = getInfo(key);
+				entry.base = obj[key];
 			}
 		} else {
-			const { compiler, watch } = create();
-			if (watch) {
-				util.deprecate(
-					() => {},
-					"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
-					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
-				)();
+			const entry = getInfo(key);
+			entry.base = obj[key];
+		}
+	}
+	return {
+		static: info,
+		dynamic: dynamicInfo
+	};
+};
+
+/**
+ * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
+ * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
+ * @returns {object} the object
+ */
+const serializeObject = (info, dynamicInfo) => {
+	const obj = {};
+	// Setup byProperty structure
+	for (const entry of info.values()) {
+		if (entry.byProperty !== undefined) {
+			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+			for (const byValue of entry.byValues.keys()) {
+				byObj[byValue] = byObj[byValue] || {};
+			}
+		}
+	}
+	for (const [key, entry] of info) {
+		if (entry.base !== undefined) {
+			obj[key] = entry.base;
+		}
+		// Fill byProperty structure
+		if (entry.byProperty !== undefined) {
+			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+			for (const byValue of Object.keys(byObj)) {
+				const value = getFromByValues(entry.byValues, byValue);
+				if (value !== undefined) byObj[byValue][key] = value;
 			}
-			return compiler;
 		}
 	}
-);
-
-module.exports = webpack;
-
+	if (dynamicInfo !== undefined) {
+		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
+	}
+	return obj;
+};
 
-/***/ }),
+const VALUE_TYPE_UNDEFINED = 0;
+const VALUE_TYPE_ATOM = 1;
+const VALUE_TYPE_ARRAY_EXTEND = 2;
+const VALUE_TYPE_OBJECT = 3;
+const VALUE_TYPE_DELETE = 4;
 
-/***/ 54182:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {any} value a single value
+ * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
+ */
+const getValueType = value => {
+	if (value === undefined) {
+		return VALUE_TYPE_UNDEFINED;
+	} else if (value === DELETE) {
+		return VALUE_TYPE_DELETE;
+	} else if (Array.isArray(value)) {
+		if (value.lastIndexOf("...") !== -1) return VALUE_TYPE_ARRAY_EXTEND;
+		return VALUE_TYPE_ATOM;
+	} else if (
+		typeof value === "object" &&
+		value !== null &&
+		(!value.constructor || value.constructor === Object)
+	) {
+		return VALUE_TYPE_OBJECT;
+	}
+	return VALUE_TYPE_ATOM;
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * Arrays might reference the old value with "...".
+ * Non-object values take preference over object values.
+ * @template T
+ * @template O
+ * @param {T} first first object
+ * @param {O} second second object
+ * @returns {T & O | T | O} merged object of first and second object
+ */
+const cleverMerge = (first, second) => {
+	if (second === undefined) return first;
+	if (first === undefined) return second;
+	if (typeof second !== "object" || second === null) return second;
+	if (typeof first !== "object" || first === null) return first;
 
+	return _cleverMerge(first, second, false);
+};
 
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * @param {object} first first object
+ * @param {object} second second object
+ * @param {boolean} internalCaching should parsing of objects and nested merges be cached
+ * @returns {object} merged object of first and second object
+ */
+const _cleverMerge = (first, second, internalCaching = false) => {
+	const firstObject = internalCaching
+		? cachedParseObject(first)
+		: parseObject(first);
+	const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
 
-const RuntimeGlobals = __webpack_require__(16475);
-const StartupChunkDependenciesPlugin = __webpack_require__(22339);
-const ImportScriptsChunkLoadingRuntimeModule = __webpack_require__(96952);
+	// If the first argument has a dynamic part we modify the dynamic part to merge the second argument
+	if (firstDynamicInfo !== undefined) {
+		let { byProperty, fn } = firstDynamicInfo;
+		const fnInfo = fn[DYNAMIC_INFO];
+		if (fnInfo) {
+			second = internalCaching
+				? cachedCleverMerge(fnInfo[1], second)
+				: cleverMerge(fnInfo[1], second);
+			fn = fnInfo[0];
+		}
+		const newFn = (...args) => {
+			const fnResult = fn(...args);
+			return internalCaching
+				? cachedCleverMerge(fnResult, second)
+				: cleverMerge(fnResult, second);
+		};
+		newFn[DYNAMIC_INFO] = [fn, second];
+		return serializeObject(firstObject.static, { byProperty, fn: newFn });
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	// If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
+	const secondObject = internalCaching
+		? cachedParseObject(second)
+		: parseObject(second);
+	const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
+	/** @type {Map<string, ObjectParsedPropertyEntry>} */
+	const resultInfo = new Map();
+	for (const [key, firstEntry] of firstInfo) {
+		const secondEntry = secondInfo.get(key);
+		const entry =
+			secondEntry !== undefined
+				? mergeEntries(firstEntry, secondEntry, internalCaching)
+				: firstEntry;
+		resultInfo.set(key, entry);
+	}
+	for (const [key, secondEntry] of secondInfo) {
+		if (!firstInfo.has(key)) {
+			resultInfo.set(key, secondEntry);
+		}
+	}
+	return serializeObject(resultInfo, secondDynamicInfo);
+};
 
-class ImportScriptsChunkLoadingPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		new StartupChunkDependenciesPlugin({
-			chunkLoading: "import-scripts",
-			asyncChunkLoading: true
-		}).apply(compiler);
-		compiler.hooks.thisCompilation.tap(
-			"ImportScriptsChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === "import-scripts";
+/**
+ * @param {ObjectParsedPropertyEntry} firstEntry a
+ * @param {ObjectParsedPropertyEntry} secondEntry b
+ * @param {boolean} internalCaching should parsing of objects and nested merges be cached
+ * @returns {ObjectParsedPropertyEntry} new entry
+ */
+const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
+	switch (getValueType(secondEntry.base)) {
+		case VALUE_TYPE_ATOM:
+		case VALUE_TYPE_DELETE:
+			// No need to consider firstEntry at all
+			// second value override everything
+			// = second.base + second.byProperty
+			return secondEntry;
+		case VALUE_TYPE_UNDEFINED:
+			if (!firstEntry.byProperty) {
+				// = first.base + second.byProperty
+				return {
+					base: firstEntry.base,
+					byProperty: secondEntry.byProperty,
+					byValues: secondEntry.byValues
 				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					if (withCreateScriptUrl) {
-						set.add(RuntimeGlobals.createScriptUrl);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
+			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
+				throw new Error(
+					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
+				);
+			} else {
+				// = first.base + (first.byProperty + second.byProperty)
+				// need to merge first and second byValues
+				const newByValues = new Map(firstEntry.byValues);
+				for (const [key, value] of secondEntry.byValues) {
+					const firstValue = getFromByValues(firstEntry.byValues, key);
+					newByValues.set(
+						key,
+						mergeSingleValue(firstValue, value, internalCaching)
 					);
+				}
+				return {
+					base: firstEntry.base,
+					byProperty: firstEntry.byProperty,
+					byValues: newByValues
 				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
 			}
-		);
-	}
-}
-module.exports = ImportScriptsChunkLoadingPlugin;
-
-
-/***/ }),
-
-/***/ 96952:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(1626);
-const {
-	getChunkFilenameTemplate,
-	chunkHasJs
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
-
-class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements, withCreateScriptUrl) {
-		super("importScripts chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.runtimeRequirements = runtimeRequirements;
-		this._withCreateScriptUrl = withCreateScriptUrl;
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const {
-			chunk,
-			chunkGraph,
-			compilation: {
-				runtimeTemplate,
-				outputOptions: { chunkLoadingGlobal, hotUpdateGlobal }
-			},
-			_withCreateScriptUrl: withCreateScriptUrl
-		} = this;
-		const globalObject = runtimeTemplate.globalObject;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withLoading = this.runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withHmr = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
-			chunkLoadingGlobal
-		)}]`;
-		const hasJsMatcher = compileBooleanMatcher(
-			chunkGraph.getChunkConditionMap(chunk, chunkHasJs)
-		);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
-
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
+		default: {
+			if (!firstEntry.byProperty) {
+				// The simple case
+				// = (first.base + second.base) + second.byProperty
+				return {
+					base: mergeSingleValue(
+						firstEntry.base,
+						secondEntry.base,
+						internalCaching
+					),
+					byProperty: secondEntry.byProperty,
+					byValues: secondEntry.byValues
+				};
 			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			false
-		);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_importScripts`
-			: undefined;
-
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = self.location + ${JSON.stringify(
-							rootOutputDir ? "/../" + rootOutputDir : ""
-						)};`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded chunks",
-			'// "1" means "already loaded"',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withLoading
-				? Template.asString([
-						"// importScripts chunk loading",
-						`var installChunk = ${runtimeTemplate.basicFunction("data", [
-							runtimeTemplate.destructureArray(
-								["chunkIds", "moreModules", "runtime"],
-								"data"
-							),
-							"for(var moduleId in moreModules) {",
-							Template.indent([
-								`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-								Template.indent(
-									`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-								),
-								"}"
-							]),
-							"}",
-							"if(runtime) runtime(__webpack_require__);",
-							"while(chunkIds.length)",
-							Template.indent("installedChunks[chunkIds.pop()] = 1;"),
-							"parentChunkLoadingFunction(data);"
-						])};`
-				  ])
-				: "// no chunk install function needed",
-			withLoading
-				? Template.asString([
-						`${fn}.i = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? [
-										'// "1" is the signal for "already loaded"',
-										"if(!installedChunks[chunkId]) {",
-										Template.indent([
-											hasJsMatcher === true
-												? "if(true) { // all chunks have JS"
-												: `if(${hasJsMatcher("chunkId")}) {`,
-											Template.indent(
-												`importScripts(${
-													withCreateScriptUrl
-														? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`
-														: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId)`
-												});`
-											),
-											"}"
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 1;"
-						)};`,
-						"",
-						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
-						"var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);",
-						"chunkLoadingGlobal.push = installChunk;"
-				  ])
-				: "// no chunk loading",
-			"",
-			withHmr
-				? Template.asString([
-						"function loadUpdateChunk(chunkId, updatedModulesList) {",
-						Template.indent([
-							"var success = false;",
-							`${globalObject}[${JSON.stringify(
-								hotUpdateGlobal
-							)}] = ${runtimeTemplate.basicFunction("_, moreModules, runtime", [
-								"for(var moduleId in moreModules) {",
-								Template.indent([
-									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-									Template.indent([
-										"currentUpdate[moduleId] = moreModules[moduleId];",
-										"if(updatedModulesList) updatedModulesList.push(moduleId);"
-									]),
-									"}"
-								]),
-								"}",
-								"if(runtime) currentUpdateRuntime.push(runtime);",
-								"success = true;"
-							])};`,
-							"// start update chunk loading",
-							`importScripts(${
-								withCreateScriptUrl
-									? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId))`
-									: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId)`
-							});`,
-							'if(!success) throw new Error("Loading update chunk failed for unknown reason");'
-						]),
-						"}",
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "importScrips")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${
-							RuntimeGlobals.hmrDownloadManifest
-						} = ${runtimeTemplate.basicFunction("", [
-							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
-							`return fetch(${RuntimeGlobals.publicPath} + ${
-								RuntimeGlobals.getUpdateManifestFilename
-							}()).then(${runtimeTemplate.basicFunction("response", [
-								"if(response.status === 404) return; // no update available",
-								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
-								"return response.json();"
-							])});`
-						])};`
-				  ])
-				: "// no HMR manifest"
-		]);
+			let newBase;
+			const intermediateByValues = new Map(firstEntry.byValues);
+			for (const [key, value] of intermediateByValues) {
+				intermediateByValues.set(
+					key,
+					mergeSingleValue(value, secondEntry.base, internalCaching)
+				);
+			}
+			if (
+				Array.from(firstEntry.byValues.values()).every(value => {
+					const type = getValueType(value);
+					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+				})
+			) {
+				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
+				newBase = mergeSingleValue(
+					firstEntry.base,
+					secondEntry.base,
+					internalCaching
+				);
+			} else {
+				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
+				newBase = firstEntry.base;
+				if (!intermediateByValues.has("default"))
+					intermediateByValues.set("default", secondEntry.base);
+			}
+			if (!secondEntry.byProperty) {
+				// = first.base + (first.byProperty + second.base)
+				return {
+					base: newBase,
+					byProperty: firstEntry.byProperty,
+					byValues: intermediateByValues
+				};
+			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
+				throw new Error(
+					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
+				);
+			}
+			const newByValues = new Map(intermediateByValues);
+			for (const [key, value] of secondEntry.byValues) {
+				const firstValue = getFromByValues(intermediateByValues, key);
+				newByValues.set(
+					key,
+					mergeSingleValue(firstValue, value, internalCaching)
+				);
+			}
+			return {
+				base: newBase,
+				byProperty: firstEntry.byProperty,
+				byValues: newByValues
+			};
+		}
 	}
-}
+};
 
-module.exports = ImportScriptsChunkLoadingRuntimeModule;
+/**
+ * @param {Map<string, any>} byValues all values
+ * @param {string} key value of the selector
+ * @returns {any | undefined} value
+ */
+const getFromByValues = (byValues, key) => {
+	if (key !== "default" && byValues.has(key)) {
+		return byValues.get(key);
+	}
+	return byValues.get("default");
+};
+
+/**
+ * @param {any} a value
+ * @param {any} b value
+ * @param {boolean} internalCaching should parsing of objects and nested merges be cached
+ * @returns {any} value
+ */
+const mergeSingleValue = (a, b, internalCaching) => {
+	const bType = getValueType(b);
+	const aType = getValueType(a);
+	switch (bType) {
+		case VALUE_TYPE_DELETE:
+		case VALUE_TYPE_ATOM:
+			return b;
+		case VALUE_TYPE_OBJECT: {
+			return aType !== VALUE_TYPE_OBJECT
+				? b
+				: internalCaching
+				? cachedCleverMerge(a, b)
+				: cleverMerge(a, b);
+		}
+		case VALUE_TYPE_UNDEFINED:
+			return a;
+		case VALUE_TYPE_ARRAY_EXTEND:
+			switch (
+				aType !== VALUE_TYPE_ATOM
+					? aType
+					: Array.isArray(a)
+					? VALUE_TYPE_ARRAY_EXTEND
+					: VALUE_TYPE_OBJECT
+			) {
+				case VALUE_TYPE_UNDEFINED:
+					return b;
+				case VALUE_TYPE_DELETE:
+					return b.filter(item => item !== "...");
+				case VALUE_TYPE_ARRAY_EXTEND: {
+					const newArray = [];
+					for (const item of b) {
+						if (item === "...") {
+							for (const item of a) {
+								newArray.push(item);
+							}
+						} else {
+							newArray.push(item);
+						}
+					}
+					return newArray;
+				}
+				case VALUE_TYPE_OBJECT:
+					return b.map(item => (item === "..." ? a : item));
+				default:
+					throw new Error("Not implemented");
+			}
+		default:
+			throw new Error("Not implemented");
+	}
+};
+
+/**
+ * @template T
+ * @param {T} obj the object
+ * @returns {T} the object without operations like "..." or DELETE
+ */
+const removeOperations = obj => {
+	const newObj = /** @type {T} */ ({});
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		const type = getValueType(value);
+		switch (type) {
+			case VALUE_TYPE_UNDEFINED:
+			case VALUE_TYPE_DELETE:
+				break;
+			case VALUE_TYPE_OBJECT:
+				newObj[key] = removeOperations(value);
+				break;
+			case VALUE_TYPE_ARRAY_EXTEND:
+				newObj[key] = value.filter(i => i !== "...");
+				break;
+			default:
+				newObj[key] = value;
+				break;
+		}
+	}
+	return newObj;
+};
+
+/**
+ * @template T
+ * @template {string} P
+ * @param {T} obj the object
+ * @param {P} byProperty the by description
+ * @param  {...any} values values
+ * @returns {Omit<T, P>} object with merged byProperty
+ */
+const resolveByProperty = (obj, byProperty, ...values) => {
+	if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
+		return obj;
+	}
+	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
+	const remaining = /** @type {T} */ (_remaining);
+	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
+		_byValue
+	);
+	if (typeof byValue === "object") {
+		const key = values[0];
+		if (key in byValue) {
+			return cachedCleverMerge(remaining, byValue[key]);
+		} else if ("default" in byValue) {
+			return cachedCleverMerge(remaining, byValue.default);
+		} else {
+			return /** @type {T} */ (remaining);
+		}
+	} else if (typeof byValue === "function") {
+		const result = byValue.apply(null, values);
+		return cachedCleverMerge(
+			remaining,
+			resolveByProperty(result, byProperty, ...values)
+		);
+	}
+};
+
+exports.cachedSetProperty = cachedSetProperty;
+exports.cachedCleverMerge = cachedCleverMerge;
+exports.cleverMerge = cleverMerge;
+exports.resolveByProperty = resolveByProperty;
+exports.removeOperations = removeOperations;
+exports.DELETE = DELETE;
 
 
 /***/ }),
 
-/***/ 68693:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 29579:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -133515,246 +131395,463 @@ module.exports = ImportScriptsChunkLoadingRuntimeModule;
 
 
 
-const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const { compareRuntime } = __webpack_require__(17156);
 
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-class WebWorkerTemplatePlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.options.output.chunkLoading = "import-scripts";
-		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
-		new EnableChunkLoadingPlugin("import-scripts").apply(compiler);
+/** @template T @typedef {function(T, T): -1|0|1} Comparator */
+/** @template TArg @template T @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator */
+/** @template TArg @template T @typedef {function(TArg): Comparator<T>} ParameterizedComparator */
+
+/**
+ * @template T
+ * @param {RawParameterizedComparator<any, T>} fn comparator with argument
+ * @returns {ParameterizedComparator<any, T>} comparator
+ */
+const createCachedParameterizedComparator = fn => {
+	/** @type {WeakMap<object, Comparator<T>>} */
+	const map = new WeakMap();
+	return arg => {
+		const cachedResult = map.get(arg);
+		if (cachedResult !== undefined) return cachedResult;
+		/**
+		 * @param {T} a first item
+		 * @param {T} b second item
+		 * @returns {-1|0|1} compare result
+		 */
+		const result = fn.bind(null, arg);
+		map.set(arg, result);
+		return result;
+	};
+};
+
+/**
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {-1|0|1} compare result
+ */
+exports.compareChunksById = (a, b) => {
+	return compareIds(a.id, b.id);
+};
+
+/**
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+exports.compareModulesByIdentifier = (a, b) => {
+	return compareIds(a.identifier(), b.identifier());
+};
+
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+const compareModulesById = (chunkGraph, a, b) => {
+	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+};
+/** @type {ParameterizedComparator<ChunkGraph, Module>} */
+exports.compareModulesById =
+	createCachedParameterizedComparator(compareModulesById);
+
+/**
+ * @param {number} a number
+ * @param {number} b number
+ * @returns {-1|0|1} compare result
+ */
+const compareNumbers = (a, b) => {
+	if (typeof a !== typeof b) {
+		return typeof a < typeof b ? -1 : 1;
 	}
-}
-module.exports = WebWorkerTemplatePlugin;
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
+exports.compareNumbers = compareNumbers;
 
+/**
+ * @param {string} a string
+ * @param {string} b string
+ * @returns {-1|0|1} compare result
+ */
+const compareStringsNumeric = (a, b) => {
+	const partsA = a.split(/(\d+)/);
+	const partsB = b.split(/(\d+)/);
+	const len = Math.min(partsA.length, partsB.length);
+	for (let i = 0; i < len; i++) {
+		const pA = partsA[i];
+		const pB = partsB[i];
+		if (i % 2 === 0) {
+			if (pA.length > pB.length) {
+				if (pA.slice(0, pB.length) > pB) return 1;
+				return -1;
+			} else if (pB.length > pA.length) {
+				if (pB.slice(0, pA.length) > pA) return -1;
+				return 1;
+			} else {
+				if (pA < pB) return -1;
+				if (pA > pB) return 1;
+			}
+		} else {
+			const nA = +pA;
+			const nB = +pB;
+			if (nA < nB) return -1;
+			if (nA > nB) return 1;
+		}
+	}
+	if (partsB.length < partsA.length) return 1;
+	if (partsB.length > partsA.length) return -1;
+	return 0;
+};
+exports.compareStringsNumeric = compareStringsNumeric;
 
-/***/ }),
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
+	const cmp = compareNumbers(
+		moduleGraph.getPostOrderIndex(a),
+		moduleGraph.getPostOrderIndex(b)
+	);
+	if (cmp !== 0) return cmp;
+	return compareIds(a.identifier(), b.identifier());
+};
+/** @type {ParameterizedComparator<ModuleGraph, Module>} */
+exports.compareModulesByPostOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPostOrderIndexOrIdentifier
+	);
 
-/***/ 14819:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
+	const cmp = compareNumbers(
+		moduleGraph.getPreOrderIndex(a),
+		moduleGraph.getPreOrderIndex(b)
+	);
+	if (cmp !== 0) return cmp;
+	return compareIds(a.identifier(), b.identifier());
+};
+/** @type {ParameterizedComparator<ModuleGraph, Module>} */
+exports.compareModulesByPreOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPreOrderIndexOrIdentifier
+	);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
+	const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+	if (cmp !== 0) return cmp;
+	return compareIds(a.identifier(), b.identifier());
+};
+/** @type {ParameterizedComparator<ChunkGraph, Module>} */
+exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
+	compareModulesByIdOrIdentifier
+);
 
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {-1|0|1} compare result
+ */
+const compareChunks = (chunkGraph, a, b) => {
+	return chunkGraph.compareChunks(a, b);
+};
+/** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
+exports.compareChunks = createCachedParameterizedComparator(compareChunks);
 
+/**
+ * @param {string|number} a first id
+ * @param {string|number} b second id
+ * @returns {-1|0|1} compare result
+ */
+const compareIds = (a, b) => {
+	if (typeof a !== typeof b) {
+		return typeof a < typeof b ? -1 : 1;
+	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
 
-const DescriptionFileUtils = __webpack_require__(25424);
-const getInnerRequest = __webpack_require__(47956);
+exports.compareIds = compareIds;
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/**
+ * @param {string} a first string
+ * @param {string} b second string
+ * @returns {-1|0|1} compare result
+ */
+const compareStrings = (a, b) => {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
+
+exports.compareStrings = compareStrings;
+
+/**
+ * @param {ChunkGroup} a first chunk group
+ * @param {ChunkGroup} b second chunk group
+ * @returns {-1|0|1} compare result
+ */
+const compareChunkGroupsByIndex = (a, b) => {
+	return a.index < b.index ? -1 : 1;
+};
+
+exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
+
+/**
+ * @template K1 {Object}
+ * @template K2
+ * @template T
+ */
+class TwoKeyWeakMap {
+	constructor() {
+		/** @private @type {WeakMap<any, WeakMap<any, T>>} */
+		this._map = new WeakMap();
+	}
 
-module.exports = class AliasFieldPlugin {
 	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | Array<string>} field field
-	 * @param {string | ResolveStepHook} target target
+	 * @param {K1} key1 first key
+	 * @param {K2} key2 second key
+	 * @returns {T | undefined} value
 	 */
-	constructor(source, field, target) {
-		this.source = source;
-		this.field = field;
-		this.target = target;
+	get(key1, key2) {
+		const childMap = this._map.get(key1);
+		if (childMap === undefined) {
+			return undefined;
+		}
+		return childMap.get(key2);
 	}
 
 	/**
-	 * @param {Resolver} resolver the resolver
+	 * @param {K1} key1 first key
+	 * @param {K2} key2 second key
+	 * @param {T | undefined} value new value
 	 * @returns {void}
 	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => {
-				if (!request.descriptionFileData) return callback();
-				const innerRequest = getInnerRequest(resolver, request);
-				if (!innerRequest) return callback();
-				const fieldData = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.field
-				);
-				if (fieldData === null || typeof fieldData !== "object") {
-					if (resolveContext.log)
-						resolveContext.log(
-							"Field '" +
-								this.field +
-								"' doesn't contain a valid alias configuration"
-						);
-					return callback();
-				}
-				const data1 = fieldData[innerRequest];
-				const data2 = fieldData[innerRequest.replace(/^\.\//, "")];
-				const data = typeof data1 !== "undefined" ? data1 : data2;
-				if (data === innerRequest) return callback();
-				if (data === undefined) return callback();
-				if (data === false) {
-					/** @type {ResolveRequest} */
-					const ignoreObj = {
-						...request,
-						path: false
-					};
-					return callback(null, ignoreObj);
-				}
-				const obj = {
-					...request,
-					path: request.descriptionFileRoot,
-					request: data,
-					fullySpecified: false
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"aliased from description file " +
-						request.descriptionFilePath +
-						" with mapping '" +
-						innerRequest +
-						"' to '" +
-						data +
-						"'",
-					resolveContext,
-					(err, result) => {
-						if (err) return callback(err);
+	set(key1, key2, value) {
+		let childMap = this._map.get(key1);
+		if (childMap === undefined) {
+			childMap = new WeakMap();
+			this._map.set(key1, childMap);
+		}
+		childMap.set(key2, value);
+	}
+}
 
-						// Don't allow other aliasing or raw request
-						if (result === undefined) return callback(null, null);
-						callback(null, result);
-					}
-				);
-			});
+/** @type {TwoKeyWeakMap<Comparator<any>, Comparator<any>, Comparator<any>>}} */
+const concatComparatorsCache = new TwoKeyWeakMap();
+
+/**
+ * @template T
+ * @param {Comparator<T>} c1 comparator
+ * @param {Comparator<T>} c2 comparator
+ * @param {Comparator<T>[]} cRest comparators
+ * @returns {Comparator<T>} comparator
+ */
+const concatComparators = (c1, c2, ...cRest) => {
+	if (cRest.length > 0) {
+		const [c3, ...cRest2] = cRest;
+		return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
 	}
+	const cacheEntry = /** @type {Comparator<T>} */ (
+		concatComparatorsCache.get(c1, c2)
+	);
+	if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {T} a first value
+	 * @param {T} b second value
+	 * @returns {-1|0|1} compare result
+	 */
+	const result = (a, b) => {
+		const res = c1(a, b);
+		if (res !== 0) return res;
+		return c2(a, b);
+	};
+	concatComparatorsCache.set(c1, c2, result);
+	return result;
 };
+exports.concatComparators = concatComparators;
 
+/** @template A, B @typedef {(input: A) => B} Selector */
 
-/***/ }),
-
-/***/ 63676:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+/** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
+const compareSelectCache = new TwoKeyWeakMap();
 
-const forEachBail = __webpack_require__(78565);
+/**
+ * @template T
+ * @template R
+ * @param {Selector<T, R>} getter getter for value
+ * @param {Comparator<R>} comparator comparator
+ * @returns {Comparator<T>} comparator
+ */
+const compareSelect = (getter, comparator) => {
+	const cacheEntry = compareSelectCache.get(getter, comparator);
+	if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {T} a first value
+	 * @param {T} b second value
+	 * @returns {-1|0|1} compare result
+	 */
+	const result = (a, b) => {
+		const aValue = getter(a);
+		const bValue = getter(b);
+		if (aValue !== undefined && aValue !== null) {
+			if (bValue !== undefined && bValue !== null) {
+				return comparator(aValue, bValue);
+			}
+			return -1;
+		} else {
+			if (bValue !== undefined && bValue !== null) {
+				return 1;
+			}
+			return 0;
+		}
+	};
+	compareSelectCache.set(getter, comparator, result);
+	return result;
+};
+exports.compareSelect = compareSelect;
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {{alias: string|Array<string>|false, name: string, onlyModule?: boolean}} AliasOption */
+/** @type {WeakMap<Comparator<any>, Comparator<Iterable<any>>>} */
+const compareIteratorsCache = new WeakMap();
 
-module.exports = class AliasPlugin {
+/**
+ * @template T
+ * @param {Comparator<T>} elementComparator comparator for elements
+ * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
+ */
+const compareIterables = elementComparator => {
+	const cacheEntry = compareIteratorsCache.get(elementComparator);
+	if (cacheEntry !== undefined) return cacheEntry;
 	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {AliasOption | Array<AliasOption>} options options
-	 * @param {string | ResolveStepHook} target target
+	 * @param {Iterable<T>} a first value
+	 * @param {Iterable<T>} b second value
+	 * @returns {-1|0|1} compare result
 	 */
-	constructor(source, options, target) {
-		this.source = source;
-		this.options = Array.isArray(options) ? options : [options];
-		this.target = target;
+	const result = (a, b) => {
+		const aI = a[Symbol.iterator]();
+		const bI = b[Symbol.iterator]();
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const aItem = aI.next();
+			const bItem = bI.next();
+			if (aItem.done) {
+				return bItem.done ? 0 : -1;
+			} else if (bItem.done) {
+				return 1;
+			}
+			const res = elementComparator(aItem.value, bItem.value);
+			if (res !== 0) return res;
+		}
+	};
+	compareIteratorsCache.set(elementComparator, result);
+	return result;
+};
+exports.compareIterables = compareIterables;
+
+// TODO this is no longer needed when minimum node.js version is >= 12
+// since these versions ship with a stable sort function
+/**
+ * @template T
+ * @param {Iterable<T>} iterable original ordered list
+ * @returns {Comparator<T>} comparator
+ */
+exports.keepOriginalOrder = iterable => {
+	/** @type {Map<T, number>} */
+	const map = new Map();
+	let i = 0;
+	for (const item of iterable) {
+		map.set(item, i++);
 	}
+	return (a, b) => compareNumbers(map.get(a), map.get(b));
+};
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("AliasPlugin", (request, resolveContext, callback) => {
-				const innerRequest = request.request || request.path;
-				if (!innerRequest) return callback();
-				forEachBail(
-					this.options,
-					(item, callback) => {
-						let shouldStop = false;
-						if (
-							innerRequest === item.name ||
-							(!item.onlyModule && innerRequest.startsWith(item.name + "/"))
-						) {
-							const remainingRequest = innerRequest.substr(item.name.length);
-							const resolveWithAlias = (alias, callback) => {
-								if (alias === false) {
-									const ignoreObj = {
-										...request,
-										path: false
-									};
-									return callback(null, ignoreObj);
-								}
-								if (
-									innerRequest !== alias &&
-									!innerRequest.startsWith(alias + "/")
-								) {
-									shouldStop = true;
-									const newRequestStr = alias + remainingRequest;
-									const obj = {
-										...request,
-										request: newRequestStr,
-										fullySpecified: false
-									};
-									return resolver.doResolve(
-										target,
-										obj,
-										"aliased with mapping '" +
-											item.name +
-											"': '" +
-											alias +
-											"' to '" +
-											newRequestStr +
-											"'",
-										resolveContext,
-										(err, result) => {
-											if (err) return callback(err);
-											if (result) return callback(null, result);
-											return callback();
-										}
-									);
-								}
-								return callback();
-							};
-							const stoppingCallback = (err, result) => {
-								if (err) return callback(err);
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {Comparator<Chunk>} comparator
+ */
+exports.compareChunksNatural = chunkGraph => {
+	const cmpFn = exports.compareModulesById(chunkGraph);
+	const cmpIterableFn = compareIterables(cmpFn);
+	return concatComparators(
+		compareSelect(chunk => chunk.name, compareIds),
+		compareSelect(chunk => chunk.runtime, compareRuntime),
+		compareSelect(
+			/**
+			 * @param {Chunk} chunk a chunk
+			 * @returns {Iterable<Module>} modules
+			 */
+			chunk => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn),
+			cmpIterableFn
+		)
+	);
+};
 
-								if (result) return callback(null, result);
-								// Don't allow other aliasing or raw request
-								if (shouldStop) return callback(null, null);
-								return callback();
-							};
-							if (Array.isArray(item.alias)) {
-								return forEachBail(
-									item.alias,
-									resolveWithAlias,
-									stoppingCallback
-								);
-							} else {
-								return resolveWithAlias(item.alias, stoppingCallback);
-							}
-						}
-						return callback();
-					},
-					callback
-				);
-			});
+/**
+ * Compare two locations
+ * @param {DependencyLocation} a A location node
+ * @param {DependencyLocation} b A location node
+ * @returns {-1|0|1} sorting comparator value
+ */
+exports.compareLocations = (a, b) => {
+	let isObjectA = typeof a === "object" && a !== null;
+	let isObjectB = typeof b === "object" && b !== null;
+	if (!isObjectA || !isObjectB) {
+		if (isObjectA) return 1;
+		if (isObjectB) return -1;
+		return 0;
 	}
+	if ("start" in a) {
+		if ("start" in b) {
+			const ap = a.start;
+			const bp = b.start;
+			if (ap.line < bp.line) return -1;
+			if (ap.line > bp.line) return 1;
+			if (ap.column < bp.column) return -1;
+			if (ap.column > bp.column) return 1;
+		} else return -1;
+	} else if ("start" in b) return 1;
+	if ("name" in a) {
+		if ("name" in b) {
+			if (a.name < b.name) return -1;
+			if (a.name > b.name) return 1;
+		} else return -1;
+	} else if ("name" in b) return 1;
+	if ("index" in a) {
+		if ("index" in b) {
+			if (a.index < b.index) return -1;
+			if (a.index > b.index) return 1;
+		} else return -1;
+	} else if ("index" in b) return 1;
+	return 0;
 };
 
 
 /***/ }),
 
-/***/ 92088:
+/***/ 29404:
 /***/ (function(module) {
 
 "use strict";
@@ -133765,537 +131862,426 @@ module.exports = class AliasPlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-
-module.exports = class AppendPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} appending appending
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, appending, target) {
-		this.source = source;
-		this.appending = appending;
-		this.target = target;
-	}
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+};
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("AppendPlugin", (request, resolveContext, callback) => {
-				const obj = {
-					...request,
-					path: request.path + this.appending,
-					relativePath:
-						request.relativePath && request.relativePath + this.appending
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					this.appending,
-					resolveContext,
-					callback
-				);
-			});
+const toSimpleString = str => {
+	if (`${+str}` === str) {
+		return str;
 	}
+	return JSON.stringify(str);
 };
 
+/**
+ * @param {Record<string|number, boolean>} map value map
+ * @returns {true|false|function(string): string} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+ */
+const compileBooleanMatcher = map => {
+	const positiveItems = Object.keys(map).filter(i => map[i]);
+	const negativeItems = Object.keys(map).filter(i => !map[i]);
+	if (positiveItems.length === 0) return false;
+	if (negativeItems.length === 0) return true;
+	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
+};
 
-/***/ }),
-
-/***/ 52788:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+/**
+ * @param {string[]} positiveItems positive items
+ * @param {string[]} negativeItems negative items
+ * @returns {function(string): string} a template function to determine the value at runtime
+ */
+const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
+	if (positiveItems.length === 0) return () => "false";
+	if (negativeItems.length === 0) return () => "true";
+	if (positiveItems.length === 1)
+		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
+	if (negativeItems.length === 1)
+		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
+	const positiveRegexp = itemsToRegexp(positiveItems);
+	const negativeRegexp = itemsToRegexp(negativeItems);
+	if (positiveRegexp.length <= negativeRegexp.length) {
+		return value => `/^${positiveRegexp}$/.test(${value})`;
+	} else {
+		return value => `!/^${negativeRegexp}$/.test(${value})`;
+	}
+};
 
-const nextTick = (__webpack_require__(77282).nextTick);
+const popCommonItems = (itemsSet, getKey, condition) => {
+	const map = new Map();
+	for (const item of itemsSet) {
+		const key = getKey(item);
+		if (key) {
+			let list = map.get(key);
+			if (list === undefined) {
+				list = [];
+				map.set(key, list);
+			}
+			list.push(item);
+		}
+	}
+	const result = [];
+	for (const list of map.values()) {
+		if (condition(list)) {
+			for (const item of list) {
+				itemsSet.delete(item);
+			}
+			result.push(list);
+		}
+	}
+	return result;
+};
 
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+const getCommonPrefix = items => {
+	let prefix = items[0];
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		for (let p = 0; p < prefix.length; p++) {
+			if (item[p] !== prefix[p]) {
+				prefix = prefix.slice(0, p);
+				break;
+			}
+		}
+	}
+	return prefix;
+};
 
-const dirname = path => {
-	let idx = path.length - 1;
-	while (idx >= 0) {
-		const c = path.charCodeAt(idx);
-		// slash or backslash
-		if (c === 47 || c === 92) break;
-		idx--;
+const getCommonSuffix = items => {
+	let suffix = items[0];
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		for (let p = item.length - 1, s = suffix.length - 1; s >= 0; p--, s--) {
+			if (item[p] !== suffix[s]) {
+				suffix = suffix.slice(s + 1);
+				break;
+			}
+		}
 	}
-	if (idx < 0) return "";
-	return path.slice(0, idx);
+	return suffix;
 };
 
-const runCallbacks = (callbacks, err, result) => {
-	if (callbacks.length === 1) {
-		callbacks[0](err, result);
-		callbacks.length = 0;
-		return;
+const itemsToRegexp = itemsArr => {
+	if (itemsArr.length === 1) {
+		return quoteMeta(itemsArr[0]);
 	}
-	let error;
-	for (const callback of callbacks) {
-		try {
-			callback(err, result);
-		} catch (e) {
-			if (!error) error = e;
+	const finishedItems = [];
+
+	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
+	let countOfSingleCharItems = 0;
+	for (const item of itemsArr) {
+		if (item.length === 1) {
+			countOfSingleCharItems++;
 		}
 	}
-	callbacks.length = 0;
-	if (error) throw error;
-};
+	// special case for only single char items
+	if (countOfSingleCharItems === itemsArr.length) {
+		return `[${quoteMeta(itemsArr.sort().join(""))}]`;
+	}
+	const items = new Set(itemsArr.sort());
+	if (countOfSingleCharItems > 2) {
+		let singleCharItems = "";
+		for (const item of items) {
+			if (item.length === 1) {
+				singleCharItems += item;
+				items.delete(item);
+			}
+		}
+		finishedItems.push(`[${quoteMeta(singleCharItems)}]`);
+	}
 
-class OperationMergerBackend {
-	/**
-	 * @param {any} provider async method
-	 * @param {any} syncProvider sync method
-	 * @param {any} providerContext call context for the provider methods
-	 */
-	constructor(provider, syncProvider, providerContext) {
-		this._provider = provider;
-		this._syncProvider = syncProvider;
-		this._providerContext = providerContext;
-		this._activeAsyncOperations = new Map();
+	// special case for 2 items with common prefix/suffix
+	if (finishedItems.length === 0 && items.size === 2) {
+		const prefix = getCommonPrefix(itemsArr);
+		const suffix = getCommonSuffix(
+			itemsArr.map(item => item.slice(prefix.length))
+		);
+		if (prefix.length > 0 || suffix.length > 0) {
+			return `${quoteMeta(prefix)}${itemsToRegexp(
+				itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined))
+			)}${quoteMeta(suffix)}`;
+		}
+	}
 
-		this.provide = this._provider
-			? (path, options, callback) => {
-					if (typeof options === "function") {
-						callback = options;
-						options = undefined;
-					}
-					if (options) {
-						return this._provider.call(
-							this._providerContext,
-							path,
-							options,
-							callback
-						);
-					}
-					if (typeof path !== "string") {
-						callback(new TypeError("path must be a string"));
-						return;
-					}
-					let callbacks = this._activeAsyncOperations.get(path);
-					if (callbacks) {
-						callbacks.push(callback);
-						return;
-					}
-					this._activeAsyncOperations.set(path, (callbacks = [callback]));
-					provider(path, (err, result) => {
-						this._activeAsyncOperations.delete(path);
-						runCallbacks(callbacks, err, result);
-					});
-			  }
-			: null;
-		this.provideSync = this._syncProvider
-			? (path, options) => {
-					return this._syncProvider.call(this._providerContext, path, options);
-			  }
-			: null;
+	// special case for 2 items with common suffix
+	if (finishedItems.length === 0 && items.size === 2) {
+		const it = items[Symbol.iterator]();
+		const a = it.next().value;
+		const b = it.next().value;
+		if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
+			return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(
+				a.slice(-1)
+			)}`;
+		}
 	}
 
-	purge() {}
-	purgeParent() {}
-}
+	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
+	const prefixed = popCommonItems(
+		items,
+		item => (item.length >= 1 ? item[0] : false),
+		list => {
+			if (list.length >= 3) return true;
+			if (list.length <= 1) return false;
+			return list[0][1] === list[1][1];
+		}
+	);
+	for (const prefixedItems of prefixed) {
+		const prefix = getCommonPrefix(prefixedItems);
+		finishedItems.push(
+			`${quoteMeta(prefix)}${itemsToRegexp(
+				prefixedItems.map(i => i.slice(prefix.length))
+			)}`
+		);
+	}
 
-/*
+	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
+	const suffixed = popCommonItems(
+		items,
+		item => (item.length >= 1 ? item.slice(-1) : false),
+		list => {
+			if (list.length >= 3) return true;
+			if (list.length <= 1) return false;
+			return list[0].slice(-2) === list[1].slice(-2);
+		}
+	);
+	for (const suffixedItems of suffixed) {
+		const suffix = getCommonSuffix(suffixedItems);
+		finishedItems.push(
+			`${itemsToRegexp(
+				suffixedItems.map(i => i.slice(0, -suffix.length))
+			)}${quoteMeta(suffix)}`
+		);
+	}
 
-IDLE:
-	insert data: goto SYNC
+	// TODO further optimize regexp, i. e.
+	// use ranges: (1|2|3|4|a) => [1-4a]
+	const conditional = finishedItems.concat(Array.from(items, quoteMeta));
+	if (conditional.length === 1) return conditional[0];
+	return `(${conditional.join("|")})`;
+};
 
-SYNC:
-	before provide: run ticks
-	event loop tick: goto ASYNC_ACTIVE
+compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
+compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
+module.exports = compileBooleanMatcher;
 
-ASYNC:
-	timeout: run tick, goto ASYNC_PASSIVE
 
-ASYNC_PASSIVE:
-	before provide: run ticks
+/***/ }),
 
-IDLE --[insert data]--> SYNC --[event loop tick]--> ASYNC_ACTIVE --[interval tick]-> ASYNC_PASSIVE
-                                                          ^                             |
-                                                          +---------[insert data]-------+
+/***/ 32540:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
-const STORAGE_MODE_IDLE = 0;
-const STORAGE_MODE_SYNC = 1;
-const STORAGE_MODE_ASYNC = 2;
 
-class CacheBackend {
-	/**
-	 * @param {number} duration max cache duration of items
-	 * @param {any} provider async method
-	 * @param {any} syncProvider sync method
-	 * @param {any} providerContext call context for the provider methods
-	 */
-	constructor(duration, provider, syncProvider, providerContext) {
-		this._duration = duration;
-		this._provider = provider;
-		this._syncProvider = syncProvider;
-		this._providerContext = providerContext;
-		/** @type {Map<string, (function(Error, any): void)[]>} */
-		this._activeAsyncOperations = new Map();
-		/** @type {Map<string, { err: Error, result: any, level: Set<string> }>} */
-		this._data = new Map();
-		/** @type {Set<string>[]} */
-		this._levels = [];
-		for (let i = 0; i < 10; i++) this._levels.push(new Set());
-		for (let i = 5000; i < duration; i += 500) this._levels.push(new Set());
-		this._currentLevel = 0;
-		this._tickInterval = Math.floor(duration / this._levels.length);
-		/** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */
-		this._mode = STORAGE_MODE_IDLE;
 
-		/** @type {NodeJS.Timeout | undefined} */
-		this._timeout = undefined;
-		/** @type {number | undefined} */
-		this._nextDecay = undefined;
+const memoize = __webpack_require__(78676);
 
-		this.provide = provider ? this.provide.bind(this) : null;
-		this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
-	}
+const getValidate = memoize(() => (__webpack_require__(38476).validate));
 
-	provide(path, options, callback) {
-		if (typeof options === "function") {
-			callback = options;
-			options = undefined;
-		}
-		if (typeof path !== "string") {
-			callback(new TypeError("path must be a string"));
-			return;
-		}
-		if (options) {
-			return this._provider.call(
-				this._providerContext,
-				path,
-				options,
-				callback
-			);
+const createSchemaValidation = (check, getSchema, options) => {
+	getSchema = memoize(getSchema);
+	return value => {
+		if (check && !check(value)) {
+			getValidate()(getSchema(), value, options);
+			if (check) {
+				(__webpack_require__(73837).deprecate)(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
+			}
 		}
+	};
+};
 
-		// When in sync mode we can move to async mode
-		if (this._mode === STORAGE_MODE_SYNC) {
-			this._enterAsyncMode();
-		}
+module.exports = createSchemaValidation;
 
-		// Check in cache
-		let cacheEntry = this._data.get(path);
-		if (cacheEntry !== undefined) {
-			if (cacheEntry.err) return nextTick(callback, cacheEntry.err);
-			return nextTick(callback, null, cacheEntry.result);
-		}
 
-		// Check if there is already the same operation running
-		let callbacks = this._activeAsyncOperations.get(path);
-		if (callbacks !== undefined) {
-			callbacks.push(callback);
-			return;
-		}
-		this._activeAsyncOperations.set(path, (callbacks = [callback]));
+/***/ }),
 
-		// Run the operation
-		this._provider.call(this._providerContext, path, (err, result) => {
-			this._activeAsyncOperations.delete(path);
-			this._storeResult(path, err, result);
+/***/ 49835:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			// Enter async mode if not yet done
-			this._enterAsyncMode();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			runCallbacks(callbacks, err, result);
-		});
-	}
 
-	provideSync(path, options) {
-		if (typeof path !== "string") {
-			throw new TypeError("path must be a string");
-		}
-		if (options) {
-			return this._syncProvider.call(this._providerContext, path, options);
-		}
 
-		// In sync mode we may have to decay some cache items
-		if (this._mode === STORAGE_MODE_SYNC) {
-			this._runDecays();
-		}
+const Hash = __webpack_require__(36692);
 
-		// Check in cache
-		let cacheEntry = this._data.get(path);
-		if (cacheEntry !== undefined) {
-			if (cacheEntry.err) throw cacheEntry.err;
-			return cacheEntry.result;
-		}
+const BULK_SIZE = 2000;
 
-		// Get all active async operations
-		// This sync operation will also complete them
-		const callbacks = this._activeAsyncOperations.get(path);
-		this._activeAsyncOperations.delete(path);
+// We are using an object instead of a Map as this will stay static during the runtime
+// so access to it can be optimized by v8
+const digestCaches = {};
 
-		// Run the operation
-		// When in idle mode, we will enter sync mode
-		let result;
-		try {
-			result = this._syncProvider.call(this._providerContext, path);
-		} catch (err) {
-			this._storeResult(path, err, undefined);
-			this._enterSyncModeWhenIdle();
-			if (callbacks) runCallbacks(callbacks, err, undefined);
-			throw err;
+class BulkUpdateDecorator extends Hash {
+	/**
+	 * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+	 * @param {string=} hashKey key for caching
+	 */
+	constructor(hashOrFactory, hashKey) {
+		super();
+		this.hashKey = hashKey;
+		if (typeof hashOrFactory === "function") {
+			this.hashFactory = hashOrFactory;
+			this.hash = undefined;
+		} else {
+			this.hashFactory = undefined;
+			this.hash = hashOrFactory;
 		}
-		this._storeResult(path, undefined, result);
-		this._enterSyncModeWhenIdle();
-		if (callbacks) runCallbacks(callbacks, undefined, result);
-		return result;
+		this.buffer = "";
 	}
 
-	purge(what) {
-		if (!what) {
-			if (this._mode !== STORAGE_MODE_IDLE) {
-				this._data.clear();
-				for (const level of this._levels) {
-					level.clear();
-				}
-				this._enterIdleMode();
-			}
-		} else if (typeof what === "string") {
-			for (let [key, data] of this._data) {
-				if (key.startsWith(what)) {
-					this._data.delete(key);
-					data.level.delete(key);
-				}
-			}
-			if (this._data.size === 0) {
-				this._enterIdleMode();
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (
+			inputEncoding !== undefined ||
+			typeof data !== "string" ||
+			data.length > BULK_SIZE
+		) {
+			if (this.hash === undefined) this.hash = this.hashFactory();
+			if (this.buffer.length > 0) {
+				this.hash.update(this.buffer);
+				this.buffer = "";
 			}
+			this.hash.update(data, inputEncoding);
 		} else {
-			for (let [key, data] of this._data) {
-				for (const item of what) {
-					if (key.startsWith(item)) {
-						this._data.delete(key);
-						data.level.delete(key);
-						break;
-					}
-				}
-			}
-			if (this._data.size === 0) {
-				this._enterIdleMode();
+			this.buffer += data;
+			if (this.buffer.length > BULK_SIZE) {
+				if (this.hash === undefined) this.hash = this.hashFactory();
+				this.hash.update(this.buffer);
+				this.buffer = "";
 			}
 		}
+		return this;
 	}
 
-	purgeParent(what) {
-		if (!what) {
-			this.purge();
-		} else if (typeof what === "string") {
-			this.purge(dirname(what));
-		} else {
-			const set = new Set();
-			for (const item of what) {
-				set.add(dirname(item));
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		let digestCache;
+		const buffer = this.buffer;
+		if (this.hash === undefined) {
+			// short data for hash, we can use caching
+			const cacheKey = `${this.hashKey}-${encoding}`;
+			digestCache = digestCaches[cacheKey];
+			if (digestCache === undefined) {
+				digestCache = digestCaches[cacheKey] = new Map();
 			}
-			this.purge(set);
-		}
-	}
-
-	_storeResult(path, err, result) {
-		if (this._data.has(path)) return;
-		const level = this._levels[this._currentLevel];
-		this._data.set(path, { err, result, level });
-		level.add(path);
-	}
-
-	_decayLevel() {
-		const nextLevel = (this._currentLevel + 1) % this._levels.length;
-		const decay = this._levels[nextLevel];
-		this._currentLevel = nextLevel;
-		for (let item of decay) {
-			this._data.delete(item);
+			const cacheEntry = digestCache.get(buffer);
+			if (cacheEntry !== undefined) return cacheEntry;
+			this.hash = this.hashFactory();
 		}
-		decay.clear();
-		if (this._data.size === 0) {
-			this._enterIdleMode();
-		} else {
-			// @ts-ignore _nextDecay is always a number in sync mode
-			this._nextDecay += this._tickInterval;
+		if (buffer.length > 0) {
+			this.hash.update(buffer);
 		}
-	}
-
-	_runDecays() {
-		while (
-			/** @type {number} */ (this._nextDecay) <= Date.now() &&
-			this._mode !== STORAGE_MODE_IDLE
-		) {
-			this._decayLevel();
+		const digestResult = this.hash.digest(encoding);
+		const result =
+			typeof digestResult === "string" ? digestResult : digestResult.toString();
+		if (digestCache !== undefined) {
+			digestCache.set(buffer, result);
 		}
+		return result;
 	}
+}
 
-	_enterAsyncMode() {
-		let timeout = 0;
-		switch (this._mode) {
-			case STORAGE_MODE_ASYNC:
-				return;
-			case STORAGE_MODE_IDLE:
-				this._nextDecay = Date.now() + this._tickInterval;
-				timeout = this._tickInterval;
-				break;
-			case STORAGE_MODE_SYNC:
-				this._runDecays();
-				// @ts-ignore _runDecays may change the mode
-				if (this._mode === STORAGE_MODE_IDLE) return;
-				timeout = Math.max(
-					0,
-					/** @type {number} */ (this._nextDecay) - Date.now()
-				);
-				break;
-		}
-		this._mode = STORAGE_MODE_ASYNC;
-		const ref = setTimeout(() => {
-			this._mode = STORAGE_MODE_SYNC;
-			this._runDecays();
-		}, timeout);
-		if (ref.unref) ref.unref();
-		this._timeout = ref;
+/* istanbul ignore next */
+class DebugHash extends Hash {
+	constructor() {
+		super();
+		this.string = "";
 	}
 
-	_enterSyncModeWhenIdle() {
-		if (this._mode === STORAGE_MODE_IDLE) {
-			this._mode = STORAGE_MODE_SYNC;
-			this._nextDecay = Date.now() + this._tickInterval;
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (typeof data !== "string") data = data.toString("utf-8");
+		if (data.startsWith("debug-digest-")) {
+			data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
 		}
+		this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
+		return this;
 	}
 
-	_enterIdleMode() {
-		this._mode = STORAGE_MODE_IDLE;
-		this._nextDecay = undefined;
-		if (this._timeout) clearTimeout(this._timeout);
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		return "debug-digest-" + Buffer.from(this.string).toString("hex");
 	}
 }
 
-const createBackend = (duration, provider, syncProvider, providerContext) => {
-	if (duration > 0) {
-		return new CacheBackend(duration, provider, syncProvider, providerContext);
-	}
-	return new OperationMergerBackend(provider, syncProvider, providerContext);
-};
-
-module.exports = class CachedInputFileSystem {
-	constructor(fileSystem, duration) {
-		this.fileSystem = fileSystem;
-
-		this._lstatBackend = createBackend(
-			duration,
-			this.fileSystem.lstat,
-			this.fileSystem.lstatSync,
-			this.fileSystem
-		);
-		const lstat = this._lstatBackend.provide;
-		this.lstat = /** @type {FileSystem["lstat"]} */ (lstat);
-		const lstatSync = this._lstatBackend.provideSync;
-		this.lstatSync = /** @type {SyncFileSystem["lstatSync"]} */ (lstatSync);
-
-		this._statBackend = createBackend(
-			duration,
-			this.fileSystem.stat,
-			this.fileSystem.statSync,
-			this.fileSystem
-		);
-		const stat = this._statBackend.provide;
-		this.stat = /** @type {FileSystem["stat"]} */ (stat);
-		const statSync = this._statBackend.provideSync;
-		this.statSync = /** @type {SyncFileSystem["statSync"]} */ (statSync);
-
-		this._readdirBackend = createBackend(
-			duration,
-			this.fileSystem.readdir,
-			this.fileSystem.readdirSync,
-			this.fileSystem
-		);
-		const readdir = this._readdirBackend.provide;
-		this.readdir = /** @type {FileSystem["readdir"]} */ (readdir);
-		const readdirSync = this._readdirBackend.provideSync;
-		this.readdirSync = /** @type {SyncFileSystem["readdirSync"]} */ (readdirSync);
-
-		this._readFileBackend = createBackend(
-			duration,
-			this.fileSystem.readFile,
-			this.fileSystem.readFileSync,
-			this.fileSystem
-		);
-		const readFile = this._readFileBackend.provide;
-		this.readFile = /** @type {FileSystem["readFile"]} */ (readFile);
-		const readFileSync = this._readFileBackend.provideSync;
-		this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */ (readFileSync);
-
-		this._readJsonBackend = createBackend(
-			duration,
-			this.fileSystem.readJson ||
-				(this.readFile &&
-					((path, callback) => {
-						// @ts-ignore
-						this.readFile(path, (err, buffer) => {
-							if (err) return callback(err);
-							if (!buffer || buffer.length === 0)
-								return callback(new Error("No file content"));
-							let data;
-							try {
-								data = JSON.parse(buffer.toString("utf-8"));
-							} catch (e) {
-								return callback(e);
-							}
-							callback(null, data);
-						});
-					})),
-			this.fileSystem.readJsonSync ||
-				(this.readFileSync &&
-					(path => {
-						const buffer = this.readFileSync(path);
-						const data = JSON.parse(buffer.toString("utf-8"));
-						return data;
-					})),
-			this.fileSystem
-		);
-		const readJson = this._readJsonBackend.provide;
-		this.readJson = /** @type {FileSystem["readJson"]} */ (readJson);
-		const readJsonSync = this._readJsonBackend.provideSync;
-		this.readJsonSync = /** @type {SyncFileSystem["readJsonSync"]} */ (readJsonSync);
+let crypto = undefined;
+let createXXHash64 = undefined;
+let createMd4 = undefined;
+let BatchedHash = undefined;
 
-		this._readlinkBackend = createBackend(
-			duration,
-			this.fileSystem.readlink,
-			this.fileSystem.readlinkSync,
-			this.fileSystem
-		);
-		const readlink = this._readlinkBackend.provide;
-		this.readlink = /** @type {FileSystem["readlink"]} */ (readlink);
-		const readlinkSync = this._readlinkBackend.provideSync;
-		this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */ (readlinkSync);
+/**
+ * Creates a hash by name or function
+ * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @returns {Hash} the hash
+ */
+module.exports = algorithm => {
+	if (typeof algorithm === "function") {
+		return new BulkUpdateDecorator(() => new algorithm());
 	}
-
-	purge(what) {
-		this._statBackend.purge(what);
-		this._lstatBackend.purge(what);
-		this._readdirBackend.purgeParent(what);
-		this._readFileBackend.purge(what);
-		this._readlinkBackend.purge(what);
-		this._readJsonBackend.purge(what);
+	switch (algorithm) {
+		// TODO add non-cryptographic algorithm here
+		case "debug":
+			return new DebugHash();
+		case "xxhash64":
+			if (createXXHash64 === undefined) {
+				createXXHash64 = __webpack_require__(35028);
+				if (BatchedHash === undefined) {
+					BatchedHash = __webpack_require__(59461);
+				}
+			}
+			return new BatchedHash(createXXHash64());
+		case "md4":
+			if (createMd4 === undefined) {
+				createMd4 = __webpack_require__(86884);
+				if (BatchedHash === undefined) {
+					BatchedHash = __webpack_require__(59461);
+				}
+			}
+			return new BatchedHash(createMd4());
+		case "native-md4":
+			if (crypto === undefined) crypto = __webpack_require__(6113);
+			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+		default:
+			if (crypto === undefined) crypto = __webpack_require__(6113);
+			return new BulkUpdateDecorator(
+				() => crypto.createHash(algorithm),
+				algorithm
+			);
 	}
 };
 
 
 /***/ }),
 
-/***/ 22254:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 64518:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -134305,49 +132291,268 @@ module.exports = class CachedInputFileSystem {
 
 
 
-const basename = (__webpack_require__(82918).basename);
+const util = __webpack_require__(73837);
+
+/** @type {Map<string, Function>} */
+const deprecationCache = new Map();
 
-/** @typedef {import("./Resolver")} Resolver */
+/**
+ * @typedef {Object} FakeHookMarker
+ * @property {true} _fakeHook it's a fake hook
+ */
 
-module.exports = class CloneBasenamePlugin {
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+/** @template T @typedef {T & FakeHookMarker} FakeHook<T> */
+
+/**
+ * @param {string} message deprecation message
+ * @param {string} code deprecation code
+ * @returns {Function} function to trigger deprecation
+ */
+const createDeprecation = (message, code) => {
+	const cached = deprecationCache.get(message);
+	if (cached !== undefined) return cached;
+	const fn = util.deprecate(
+		() => {},
+		message,
+		"DEP_WEBPACK_DEPRECATION_" + code
+	);
+	deprecationCache.set(message, fn);
+	return fn;
+};
+
+const COPY_METHODS = [
+	"concat",
+	"entry",
+	"filter",
+	"find",
+	"findIndex",
+	"includes",
+	"indexOf",
+	"join",
+	"lastIndexOf",
+	"map",
+	"reduce",
+	"reduceRight",
+	"slice",
+	"some"
+];
 
+const DISABLED_METHODS = [
+	"copyWithin",
+	"entries",
+	"fill",
+	"keys",
+	"pop",
+	"reverse",
+	"shift",
+	"splice",
+	"sort",
+	"unshift"
+];
+
+/**
+ * @param {any} set new set
+ * @param {string} name property name
+ * @returns {void}
+ */
+exports.arrayToSetDeprecation = (set, name) => {
+	for (const method of COPY_METHODS) {
+		if (set[method]) continue;
+		const d = createDeprecation(
+			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
+			"ARRAY_TO_SET"
+		);
+		/**
+		 * @deprecated
+		 * @this {Set}
+		 * @returns {number} count
+		 */
+		set[method] = function () {
+			d();
+			const array = Array.from(this);
+			return Array.prototype[method].apply(array, arguments);
+		};
+	}
+	const dPush = createDeprecation(
+		`${name} was changed from Array to Set (using Array method 'push' is deprecated)`,
+		"ARRAY_TO_SET_PUSH"
+	);
+	const dLength = createDeprecation(
+		`${name} was changed from Array to Set (using Array property 'length' is deprecated)`,
+		"ARRAY_TO_SET_LENGTH"
+	);
+	const dIndexer = createDeprecation(
+		`${name} was changed from Array to Set (indexing Array is deprecated)`,
+		"ARRAY_TO_SET_INDEXER"
+	);
 	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
+	 * @deprecated
+	 * @this {Set}
+	 * @returns {number} count
 	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
-				const filename = basename(request.path);
-				const filePath = resolver.join(request.path, filename);
-				const obj = {
-					...request,
-					path: filePath,
-					relativePath:
-						request.relativePath &&
-						resolver.join(request.relativePath, filename)
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"using path: " + filePath,
-					resolveContext,
-					callback
+	set.push = function () {
+		dPush();
+		for (const item of Array.from(arguments)) {
+			this.add(item);
+		}
+		return this.size;
+	};
+	for (const method of DISABLED_METHODS) {
+		if (set[method]) continue;
+		set[method] = () => {
+			throw new Error(
+				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
+			);
+		};
+	}
+	const createIndexGetter = index => {
+		/**
+		 * @this {Set} a Set
+		 * @returns {any} the value at this location
+		 */
+		const fn = function () {
+			dIndexer();
+			let i = 0;
+			for (const item of this) {
+				if (i++ === index) return item;
+			}
+			return undefined;
+		};
+		return fn;
+	};
+	const defineIndexGetter = index => {
+		Object.defineProperty(set, index, {
+			get: createIndexGetter(index),
+			set(value) {
+				throw new Error(
+					`${name} was changed from Array to Set (indexing Array with write is not possible)`
 				);
+			}
+		});
+	};
+	defineIndexGetter(0);
+	let indexerDefined = 1;
+	Object.defineProperty(set, "length", {
+		get() {
+			dLength();
+			const length = this.size;
+			for (indexerDefined; indexerDefined < length + 1; indexerDefined++) {
+				defineIndexGetter(indexerDefined);
+			}
+			return length;
+		},
+		set(value) {
+			throw new Error(
+				`${name} was changed from Array to Set (writing to Array property 'length' is not possible)`
+			);
+		}
+	});
+	set[Symbol.isConcatSpreadable] = true;
+};
+
+exports.createArrayToSetDeprecationSet = name => {
+	let initialized = false;
+	class SetDeprecatedArray extends Set {
+		constructor(items) {
+			super(items);
+			if (!initialized) {
+				initialized = true;
+				exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
+			}
+		}
+	}
+	return SetDeprecatedArray;
+};
+
+exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
+	const message = `${name} will be frozen in future, all modifications are deprecated.${
+		note && `\n${note}`
+	}`;
+	return new Proxy(obj, {
+		set: util.deprecate(
+			(target, property, value, receiver) =>
+				Reflect.set(target, property, value, receiver),
+			message,
+			code
+		),
+		defineProperty: util.deprecate(
+			(target, property, descriptor) =>
+				Reflect.defineProperty(target, property, descriptor),
+			message,
+			code
+		),
+		deleteProperty: util.deprecate(
+			(target, property) => Reflect.deleteProperty(target, property),
+			message,
+			code
+		),
+		setPrototypeOf: util.deprecate(
+			(target, proto) => Reflect.setPrototypeOf(target, proto),
+			message,
+			code
+		)
+	});
+};
+
+/**
+ * @template T
+ * @param {T} obj object
+ * @param {string} message deprecation message
+ * @param {string} code deprecation code
+ * @returns {T} object with property access deprecated
+ */
+const deprecateAllProperties = (obj, message, code) => {
+	const newObj = {};
+	const descriptors = Object.getOwnPropertyDescriptors(obj);
+	for (const name of Object.keys(descriptors)) {
+		const descriptor = descriptors[name];
+		if (typeof descriptor.value === "function") {
+			Object.defineProperty(newObj, name, {
+				...descriptor,
+				value: util.deprecate(descriptor.value, message, code)
 			});
+		} else if (descriptor.get || descriptor.set) {
+			Object.defineProperty(newObj, name, {
+				...descriptor,
+				get: descriptor.get && util.deprecate(descriptor.get, message, code),
+				set: descriptor.set && util.deprecate(descriptor.set, message, code)
+			});
+		} else {
+			let value = descriptor.value;
+			Object.defineProperty(newObj, name, {
+				configurable: descriptor.configurable,
+				enumerable: descriptor.enumerable,
+				get: util.deprecate(() => value, message, code),
+				set: descriptor.writable
+					? util.deprecate(v => (value = v), message, code)
+					: undefined
+			});
+		}
+	}
+	return /** @type {T} */ (newObj);
+};
+exports.deprecateAllProperties = deprecateAllProperties;
+
+/**
+ * @template T
+ * @param {T} fakeHook fake hook implementation
+ * @param {string=} message deprecation message (not deprecated when unset)
+ * @param {string=} code deprecation code (not deprecated when unset)
+ * @returns {FakeHook<T>} fake hook which redirects
+ */
+exports.createFakeHook = (fakeHook, message, code) => {
+	if (message && code) {
+		fakeHook = deprecateAllProperties(fakeHook, message, code);
 	}
+	return Object.freeze(
+		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
+	);
 };
 
 
 /***/ }),
 
-/***/ 6953:
+/***/ 59836:
 /***/ (function(module) {
 
 "use strict";
@@ -134358,574 +132563,776 @@ module.exports = class CloneBasenamePlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+// Simulations show these probabilities for a single change
+// 93.1% that one group is invalidated
+// 4.8% that two groups are invalidated
+// 1.1% that 3 groups are invalidated
+// 0.1% that 4 or more groups are invalidated
+//
+// And these for removing/adding 10 lexically adjacent files
+// 64.5% that one group is invalidated
+// 24.8% that two groups are invalidated
+// 7.8% that 3 groups are invalidated
+// 2.7% that 4 or more groups are invalidated
+//
+// And these for removing/adding 3 random files
+// 0% that one group is invalidated
+// 3.7% that two groups are invalidated
+// 80.8% that 3 groups are invalidated
+// 12.3% that 4 groups are invalidated
+// 3.2% that 5 or more groups are invalidated
 
-module.exports = class ConditionalPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Partial<ResolveRequest>} test compare object
-	 * @param {string | null} message log message
-	 * @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, test, message, allowAlternatives, target) {
-		this.source = source;
-		this.test = test;
-		this.message = message;
-		this.allowAlternatives = allowAlternatives;
-		this.target = target;
+/**
+ *
+ * @param {string} a key
+ * @param {string} b key
+ * @returns {number} the similarity as number
+ */
+const similarity = (a, b) => {
+	const l = Math.min(a.length, b.length);
+	let dist = 0;
+	for (let i = 0; i < l; i++) {
+		const ca = a.charCodeAt(i);
+		const cb = b.charCodeAt(i);
+		dist += Math.max(0, 10 - Math.abs(ca - cb));
 	}
+	return dist;
+};
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		const { test, message, allowAlternatives } = this;
-		const keys = Object.keys(test);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ConditionalPlugin", (request, resolveContext, callback) => {
-				for (const prop of keys) {
-					if (request[prop] !== test[prop]) return callback();
-				}
-				resolver.doResolve(
-					target,
-					request,
-					message,
-					resolveContext,
-					allowAlternatives
-						? callback
-						: (err, result) => {
-								if (err) return callback(err);
-
-								// Don't allow other alternatives
-								if (result === undefined) return callback(null, null);
-								callback(null, result);
-						  }
-				);
-			});
+/**
+ * @param {string} a key
+ * @param {string} b key
+ * @param {Set<string>} usedNames set of already used names
+ * @returns {string} the common part and a single char for the difference
+ */
+const getName = (a, b, usedNames) => {
+	const l = Math.min(a.length, b.length);
+	let i = 0;
+	while (i < l) {
+		if (a.charCodeAt(i) !== b.charCodeAt(i)) {
+			i++;
+			break;
+		}
+		i++;
+	}
+	while (i < l) {
+		const name = a.slice(0, i);
+		const lowerName = name.toLowerCase();
+		if (!usedNames.has(lowerName)) {
+			usedNames.add(lowerName);
+			return name;
+		}
+		i++;
 	}
+	// names always contain a hash, so this is always unique
+	// we don't need to check usedNames nor add it
+	return a;
 };
 
+/**
+ * @param {Record<string, number>} total total size
+ * @param {Record<string, number>} size single size
+ * @returns {void}
+ */
+const addSizeTo = (total, size) => {
+	for (const key of Object.keys(size)) {
+		total[key] = (total[key] || 0) + size[key];
+	}
+};
 
-/***/ }),
+/**
+ * @param {Record<string, number>} total total size
+ * @param {Record<string, number>} size single size
+ * @returns {void}
+ */
+const subtractSizeFrom = (total, size) => {
+	for (const key of Object.keys(size)) {
+		total[key] -= size[key];
+	}
+};
 
-/***/ 44112:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {Iterable<Node>} nodes some nodes
+ * @returns {Record<string, number>} total size
+ */
+const sumSize = nodes => {
+	const sum = Object.create(null);
+	for (const node of nodes) {
+		addSizeTo(sum, node.size);
+	}
+	return sum;
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const isTooBig = (size, maxSize) => {
+	for (const key of Object.keys(size)) {
+		const s = size[key];
+		if (s === 0) continue;
+		const maxSizeValue = maxSize[key];
+		if (typeof maxSizeValue === "number") {
+			if (s > maxSizeValue) return true;
+		}
+	}
+	return false;
+};
 
+const isTooSmall = (size, minSize) => {
+	for (const key of Object.keys(size)) {
+		const s = size[key];
+		if (s === 0) continue;
+		const minSizeValue = minSize[key];
+		if (typeof minSizeValue === "number") {
+			if (s < minSizeValue) return true;
+		}
+	}
+	return false;
+};
 
+const getTooSmallTypes = (size, minSize) => {
+	const types = new Set();
+	for (const key of Object.keys(size)) {
+		const s = size[key];
+		if (s === 0) continue;
+		const minSizeValue = minSize[key];
+		if (typeof minSizeValue === "number") {
+			if (s < minSizeValue) types.add(key);
+		}
+	}
+	return types;
+};
 
-const DescriptionFileUtils = __webpack_require__(25424);
+const getNumberOfMatchingSizeTypes = (size, types) => {
+	let i = 0;
+	for (const key of Object.keys(size)) {
+		if (size[key] !== 0 && types.has(key)) i++;
+	}
+	return i;
+};
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+const selectiveSizeSum = (size, types) => {
+	let sum = 0;
+	for (const key of Object.keys(size)) {
+		if (size[key] !== 0 && types.has(key)) sum += size[key];
+	}
+	return sum;
+};
 
-module.exports = class DescriptionFilePlugin {
+/**
+ * @template T
+ */
+class Node {
 	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string[]} filenames filenames
-	 * @param {boolean} pathIsFile pathIsFile
-	 * @param {string | ResolveStepHook} target target
+	 * @param {T} item item
+	 * @param {string} key key
+	 * @param {Record<string, number>} size size
 	 */
-	constructor(source, filenames, pathIsFile, target) {
-		this.source = source;
-		this.filenames = filenames;
-		this.pathIsFile = pathIsFile;
-		this.target = target;
+	constructor(item, key, size) {
+		this.item = item;
+		this.key = key;
+		this.size = size;
 	}
+}
 
+/**
+ * @template T
+ */
+class Group {
 	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
+	 * @param {Node<T>[]} nodes nodes
+	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {Record<string, number>=} size size of the group
 	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"DescriptionFilePlugin",
-				(request, resolveContext, callback) => {
-					const path = request.path;
-					if (!path) return callback();
-					const directory = this.pathIsFile
-						? DescriptionFileUtils.cdUp(path)
-						: path;
-					if (!directory) return callback();
-					DescriptionFileUtils.loadDescriptionFile(
-						resolver,
-						directory,
-						this.filenames,
-						request.descriptionFilePath
-							? {
-									path: request.descriptionFilePath,
-									content: request.descriptionFileData,
-									directory: /** @type {string} */ (request.descriptionFileRoot)
-							  }
-							: undefined,
-						resolveContext,
-						(err, result) => {
-							if (err) return callback(err);
-							if (!result) {
-								if (resolveContext.log)
-									resolveContext.log(
-										`No description file found in ${directory} or above`
-									);
-								return callback();
-							}
-							const relativePath =
-								"." + path.substr(result.directory.length).replace(/\\/g, "/");
-							const obj = {
-								...request,
-								descriptionFilePath: result.path,
-								descriptionFileData: result.content,
-								descriptionFileRoot: result.directory,
-								relativePath: relativePath
-							};
-							resolver.doResolve(
-								target,
-								obj,
-								"using description file: " +
-									result.path +
-									" (relative path: " +
-									relativePath +
-									")",
-								resolveContext,
-								(err, result) => {
-									if (err) return callback(err);
+	constructor(nodes, similarities, size) {
+		this.nodes = nodes;
+		this.similarities = similarities;
+		this.size = size || sumSize(nodes);
+		/** @type {string} */
+		this.key = undefined;
+	}
 
-									// Don't allow other processing
-									if (result === undefined) return callback(null, null);
-									callback(null, result);
-								}
-							);
-						}
+	/**
+	 * @param {function(Node): boolean} filter filter function
+	 * @returns {Node[]} removed nodes
+	 */
+	popNodes(filter) {
+		const newNodes = [];
+		const newSimilarities = [];
+		const resultNodes = [];
+		let lastNode;
+		for (let i = 0; i < this.nodes.length; i++) {
+			const node = this.nodes[i];
+			if (filter(node)) {
+				resultNodes.push(node);
+			} else {
+				if (newNodes.length > 0) {
+					newSimilarities.push(
+						lastNode === this.nodes[i - 1]
+							? this.similarities[i - 1]
+							: similarity(lastNode.key, node.key)
 					);
 				}
-			);
+				newNodes.push(node);
+				lastNode = node;
+			}
+		}
+		if (resultNodes.length === this.nodes.length) return undefined;
+		this.nodes = newNodes;
+		this.similarities = newSimilarities;
+		this.size = sumSize(newNodes);
+		return resultNodes;
 	}
-};
-
-
-/***/ }),
-
-/***/ 25424:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const forEachBail = __webpack_require__(78565);
+}
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+/**
+ * @param {Iterable<Node>} nodes nodes
+ * @returns {number[]} similarities
+ */
+const getSimilarities = nodes => {
+	// calculate similarities between lexically adjacent nodes
+	/** @type {number[]} */
+	const similarities = [];
+	let last = undefined;
+	for (const node of nodes) {
+		if (last !== undefined) {
+			similarities.push(similarity(last.key, node.key));
+		}
+		last = node;
+	}
+	return similarities;
+};
 
 /**
- * @typedef {Object} DescriptionFileInfo
- * @property {any=} content
- * @property {string} path
- * @property {string} directory
+ * @template T
+ * @typedef {Object} GroupedItems<T>
+ * @property {string} key
+ * @property {T[]} items
+ * @property {Record<string, number>} size
  */
 
 /**
- * @callback ErrorFirstCallback
- * @param {Error|null=} error
- * @param {DescriptionFileInfo=} result
+ * @template T
+ * @typedef {Object} Options
+ * @property {Record<string, number>} maxSize maximum size of a group
+ * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
+ * @property {Iterable<T>} items a list of items
+ * @property {function(T): Record<string, number>} getSize function to get size of an item
+ * @property {function(T): string} getKey function to get the key of an item
  */
 
 /**
- * @param {Resolver} resolver resolver
- * @param {string} directory directory
- * @param {string[]} filenames filenames
- * @param {DescriptionFileInfo|undefined} oldInfo oldInfo
- * @param {ResolveContext} resolveContext resolveContext
- * @param {ErrorFirstCallback} callback callback
+ * @template T
+ * @param {Options<T>} options options object
+ * @returns {GroupedItems<T>[]} grouped items
  */
-function loadDescriptionFile(
-	resolver,
-	directory,
-	filenames,
-	oldInfo,
-	resolveContext,
-	callback
-) {
-	(function findDescriptionFile() {
-		if (oldInfo && oldInfo.directory === directory) {
-			// We already have info for this directory and can reuse it
-			return callback(null, oldInfo);
+module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
+	/** @type {Group<T>[]} */
+	const result = [];
+
+	const nodes = Array.from(
+		items,
+		item => new Node(item, getKey(item), getSize(item))
+	);
+
+	/** @type {Node<T>[]} */
+	const initialNodes = [];
+
+	// lexically ordering of keys
+	nodes.sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+
+	// return nodes bigger than maxSize directly as group
+	// But make sure that minSize is not violated
+	for (const node of nodes) {
+		if (isTooBig(node.size, maxSize) && !isTooSmall(node.size, minSize)) {
+			result.push(new Group([node], []));
+		} else {
+			initialNodes.push(node);
 		}
-		forEachBail(
-			filenames,
-			(filename, callback) => {
-				const descriptionFilePath = resolver.join(directory, filename);
-				if (resolver.fileSystem.readJson) {
-					resolver.fileSystem.readJson(descriptionFilePath, (err, content) => {
-						if (err) {
-							if (typeof err.code !== "undefined") {
-								if (resolveContext.missingDependencies) {
-									resolveContext.missingDependencies.add(descriptionFilePath);
-								}
-								return callback();
-							}
-							if (resolveContext.fileDependencies) {
-								resolveContext.fileDependencies.add(descriptionFilePath);
-							}
-							return onJson(err);
-						}
-						if (resolveContext.fileDependencies) {
-							resolveContext.fileDependencies.add(descriptionFilePath);
-						}
-						onJson(null, content);
+	}
+
+	if (initialNodes.length > 0) {
+		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
+
+		const removeProblematicNodes = (group, consideredSize = group.size) => {
+			const problemTypes = getTooSmallTypes(consideredSize, minSize);
+			if (problemTypes.size > 0) {
+				// We hit an edge case where the working set is already smaller than minSize
+				// We merge problematic nodes with the smallest result node to keep minSize intact
+				const problemNodes = group.popNodes(
+					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
+				);
+				if (problemNodes === undefined) return false;
+				// Only merge it with result nodes that have the problematic size type
+				const possibleResultGroups = result.filter(
+					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
+				);
+				if (possibleResultGroups.length > 0) {
+					const bestGroup = possibleResultGroups.reduce((min, group) => {
+						const minMatches = getNumberOfMatchingSizeTypes(min, problemTypes);
+						const groupMatches = getNumberOfMatchingSizeTypes(
+							group,
+							problemTypes
+						);
+						if (minMatches !== groupMatches)
+							return minMatches < groupMatches ? group : min;
+						if (
+							selectiveSizeSum(min.size, problemTypes) >
+							selectiveSizeSum(group.size, problemTypes)
+						)
+							return group;
+						return min;
+					});
+					for (const node of problemNodes) bestGroup.nodes.push(node);
+					bestGroup.nodes.sort((a, b) => {
+						if (a.key < b.key) return -1;
+						if (a.key > b.key) return 1;
+						return 0;
 					});
 				} else {
-					resolver.fileSystem.readFile(descriptionFilePath, (err, content) => {
-						if (err) {
-							if (resolveContext.missingDependencies) {
-								resolveContext.missingDependencies.add(descriptionFilePath);
-							}
-							return callback();
-						}
-						if (resolveContext.fileDependencies) {
-							resolveContext.fileDependencies.add(descriptionFilePath);
-						}
-						let json;
+					// There are no other nodes with the same size types
+					// We create a new group and have to accept that it's smaller than minSize
+					result.push(new Group(problemNodes, null));
+				}
+				return true;
+			} else {
+				return false;
+			}
+		};
 
-						if (content) {
-							try {
-								json = JSON.parse(content.toString());
-							} catch (e) {
-								return onJson(e);
-							}
-						} else {
-							return onJson(new Error("No content in file"));
-						}
+		if (initialGroup.nodes.length > 0) {
+			const queue = [initialGroup];
 
-						onJson(null, json);
-					});
+			while (queue.length) {
+				const group = queue.pop();
+				// only groups bigger than maxSize need to be splitted
+				if (!isTooBig(group.size, maxSize)) {
+					result.push(group);
+					continue;
+				}
+				// If the group is already too small
+				// we try to work only with the unproblematic nodes
+				if (removeProblematicNodes(group)) {
+					// This changed something, so we try this group again
+					queue.push(group);
+					continue;
 				}
 
-				function onJson(err, content) {
-					if (err) {
-						if (resolveContext.log)
-							resolveContext.log(
-								descriptionFilePath + " (directory description file): " + err
-							);
-						else
-							err.message =
-								descriptionFilePath + " (directory description file): " + err;
-						return callback(err);
-					}
-					callback(null, {
-						content,
-						directory,
-						path: descriptionFilePath
-					});
+				// find unsplittable area from left and right
+				// going minSize from left and right
+				// at least one node need to be included otherwise we get stuck
+				let left = 1;
+				let leftSize = Object.create(null);
+				addSizeTo(leftSize, group.nodes[0].size);
+				while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
+					addSizeTo(leftSize, group.nodes[left].size);
+					left++;
 				}
-			},
-			(err, result) => {
-				if (err) return callback(err);
-				if (result) {
-					return callback(null, result);
-				} else {
-					const dir = cdUp(directory);
-					if (!dir) {
-						return callback();
+				let right = group.nodes.length - 2;
+				let rightSize = Object.create(null);
+				addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
+				while (right >= 0 && isTooSmall(rightSize, minSize)) {
+					addSizeTo(rightSize, group.nodes[right].size);
+					right--;
+				}
+
+				//      left v   v right
+				// [ O O O ] O O O [ O O O ]
+				// ^^^^^^^^^ leftSize
+				//       rightSize ^^^^^^^^^
+				// leftSize > minSize
+				// rightSize > minSize
+
+				// Perfect split: [ O O O ] [ O O O ]
+				//                right === left - 1
+
+				if (left - 1 > right) {
+					// We try to remove some problematic nodes to "fix" that
+					let prevSize;
+					if (right < group.nodes.length - left) {
+						subtractSizeFrom(rightSize, group.nodes[right + 1].size);
+						prevSize = rightSize;
 					} else {
-						directory = dir;
-						return findDescriptionFile();
+						subtractSizeFrom(leftSize, group.nodes[left - 1].size);
+						prevSize = leftSize;
+					}
+					if (removeProblematicNodes(group, prevSize)) {
+						// This changed something, so we try this group again
+						queue.push(group);
+						continue;
 					}
+					// can't split group while holding minSize
+					// because minSize is preferred of maxSize we return
+					// the problematic nodes as result here even while it's too big
+					// To avoid this make sure maxSize > minSize * 3
+					result.push(group);
+					continue;
 				}
-			}
-		);
-	})();
-}
+				if (left <= right) {
+					// when there is a area between left and right
+					// we look for best split point
+					// we split at the minimum similarity
+					// here key space is separated the most
+					// But we also need to make sure to not create too small groups
+					let best = -1;
+					let bestSimilarity = Infinity;
+					let pos = left;
+					let rightSize = sumSize(group.nodes.slice(pos));
 
-/**
- * @param {any} content content
- * @param {string|string[]} field field
- * @returns {object|string|number|boolean|undefined} field data
- */
-function getField(content, field) {
-	if (!content) return undefined;
-	if (Array.isArray(field)) {
-		let current = content;
-		for (let j = 0; j < field.length; j++) {
-			if (current === null || typeof current !== "object") {
-				current = null;
-				break;
+					//       pos v   v right
+					// [ O O O ] O O O [ O O O ]
+					// ^^^^^^^^^ leftSize
+					// rightSize ^^^^^^^^^^^^^^^
+
+					while (pos <= right + 1) {
+						const similarity = group.similarities[pos - 1];
+						if (
+							similarity < bestSimilarity &&
+							!isTooSmall(leftSize, minSize) &&
+							!isTooSmall(rightSize, minSize)
+						) {
+							best = pos;
+							bestSimilarity = similarity;
+						}
+						addSizeTo(leftSize, group.nodes[pos].size);
+						subtractSizeFrom(rightSize, group.nodes[pos].size);
+						pos++;
+					}
+					if (best < 0) {
+						// This can't happen
+						// but if that assumption is wrong
+						// fallback to a big group
+						result.push(group);
+						continue;
+					}
+					left = best;
+					right = best - 1;
+				}
+
+				// create two new groups for left and right area
+				// and queue them up
+				const rightNodes = [group.nodes[right + 1]];
+				/** @type {number[]} */
+				const rightSimilarities = [];
+				for (let i = right + 2; i < group.nodes.length; i++) {
+					rightSimilarities.push(group.similarities[i - 1]);
+					rightNodes.push(group.nodes[i]);
+				}
+				queue.push(new Group(rightNodes, rightSimilarities));
+
+				const leftNodes = [group.nodes[0]];
+				/** @type {number[]} */
+				const leftSimilarities = [];
+				for (let i = 1; i < left; i++) {
+					leftSimilarities.push(group.similarities[i - 1]);
+					leftNodes.push(group.nodes[i]);
+				}
+				queue.push(new Group(leftNodes, leftSimilarities));
 			}
-			current = current[field[j]];
 		}
-		return current;
-	} else {
-		return content[field];
 	}
-}
-
-/**
- * @param {string} directory directory
- * @returns {string|null} parent directory or null
- */
-function cdUp(directory) {
-	if (directory === "/") return null;
-	const i = directory.lastIndexOf("/"),
-		j = directory.lastIndexOf("\\");
-	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
-	if (p < 0) return null;
-	return directory.substr(0, p || 1);
-}
 
-exports.loadDescriptionFile = loadDescriptionFile;
-exports.getField = getField;
-exports.cdUp = cdUp;
+	// lexically ordering
+	result.sort((a, b) => {
+		if (a.nodes[0].key < b.nodes[0].key) return -1;
+		if (a.nodes[0].key > b.nodes[0].key) return 1;
+		return 0;
+	});
+
+	// give every group a name
+	const usedNames = new Set();
+	for (let i = 0; i < result.length; i++) {
+		const group = result[i];
+		if (group.nodes.length === 1) {
+			group.key = group.nodes[0].key;
+		} else {
+			const first = group.nodes[0];
+			const last = group.nodes[group.nodes.length - 1];
+			const name = getName(first.key, last.key, usedNames);
+			group.key = name;
+		}
+	}
+
+	// return the results
+	return result.map(group => {
+		/** @type {GroupedItems} */
+		return {
+			key: group.key,
+			items: group.nodes.map(node => node.item),
+			size: group.size
+		};
+	});
+};
 
 
 /***/ }),
 
-/***/ 60895:
+/***/ 11850:
 /***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sam Chen @chenxsan
 */
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-
-module.exports = class DirectoryExistsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
-
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"DirectoryExistsPlugin",
-				(request, resolveContext, callback) => {
-					const fs = resolver.fileSystem;
-					const directory = request.path;
-					if (!directory) return callback();
-					fs.stat(directory, (err, stat) => {
-						if (err || !stat) {
-							if (resolveContext.missingDependencies)
-								resolveContext.missingDependencies.add(directory);
-							if (resolveContext.log)
-								resolveContext.log(directory + " doesn't exist");
-							return callback();
-						}
-						if (!stat.isDirectory()) {
-							if (resolveContext.missingDependencies)
-								resolveContext.missingDependencies.add(directory);
-							if (resolveContext.log)
-								resolveContext.log(directory + " is not a directory");
-							return callback();
-						}
-						if (resolveContext.fileDependencies)
-							resolveContext.fileDependencies.add(directory);
-						resolver.doResolve(
-							target,
-							request,
-							`existing directory ${directory}`,
-							resolveContext,
-							callback
-						);
-					});
-				}
-			);
+/**
+ * @param {string} urlAndGlobal the script request
+ * @returns {string[]} script url and its global variable
+ */
+module.exports = function extractUrlAndGlobal(urlAndGlobal) {
+	const index = urlAndGlobal.indexOf("@");
+	if (index <= 0 || index === urlAndGlobal.length - 1) {
+		throw new Error(`Invalid request "${urlAndGlobal}"`);
 	}
+	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
 };
 
 
 /***/ }),
 
-/***/ 83849:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 6261:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const path = __webpack_require__(71017);
-const DescriptionFileUtils = __webpack_require__(25424);
-const forEachBail = __webpack_require__(78565);
-const { processExportsField } = __webpack_require__(55863);
-const { parseIdentifier } = __webpack_require__(71053);
-const { checkExportsFieldTarget } = __webpack_require__(67079);
-
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {import("./util/entrypoints").ExportsField} ExportsField */
-/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
+const NO_MARKER = 0;
+const IN_PROGRESS_MARKER = 1;
+const DONE_MARKER = 2;
+const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
+const DONE_AND_ROOT_MARKER = 4;
 
-module.exports = class ExportsFieldPlugin {
+/**
+ * @template T
+ */
+class Node {
 	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Set<string>} conditionNames condition names
-	 * @param {string | string[]} fieldNamePath name path
-	 * @param {string | ResolveStepHook} target target
+	 * @param {T} item the value of the node
 	 */
-	constructor(source, conditionNames, fieldNamePath, target) {
-		this.source = source;
-		this.target = target;
-		this.conditionNames = conditionNames;
-		this.fieldName = fieldNamePath;
-		/** @type {WeakMap<any, FieldProcessor>} */
-		this.fieldProcessorCache = new WeakMap();
+	constructor(item) {
+		this.item = item;
+		/** @type {Set<Node<T>>} */
+		this.dependencies = new Set();
+		this.marker = NO_MARKER;
+		/** @type {Cycle<T> | undefined} */
+		this.cycle = undefined;
+		this.incoming = 0;
 	}
+}
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ExportsFieldPlugin", (request, resolveContext, callback) => {
-				// When there is no description file, abort
-				if (!request.descriptionFilePath) return callback();
-				if (
-					// When the description file is inherited from parent, abort
-					// (There is no description file inside of this package)
-					request.relativePath !== "." ||
-					request.request === undefined
-				)
-					return callback();
+/**
+ * @template T
+ */
+class Cycle {
+	constructor() {
+		/** @type {Set<Node<T>>} */
+		this.nodes = new Set();
+	}
+}
 
-				const remainingRequest =
-					request.query || request.fragment
-						? (request.request === "." ? "./" : request.request) +
-						  request.query +
-						  request.fragment
-						: request.request;
-				/** @type {ExportsField|null} */
-				const exportsField = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.fieldName
-				);
-				if (!exportsField) return callback();
+/**
+ * @template T
+ * @typedef {Object} StackEntry
+ * @property {Node<T>} node
+ * @property {Node<T>[]} openEdges
+ */
 
-				if (request.directory) {
-					return callback(
-						new Error(
-							`Resolving to directories is not possible with the exports field (request was ${remainingRequest}/)`
-						)
-					);
-				}
+/**
+ * @template T
+ * @param {Iterable<T>} items list of items
+ * @param {function(T): Iterable<T>} getDependencies function to get dependencies of an item (items that are not in list are ignored)
+ * @returns {Iterable<T>} graph roots of the items
+ */
+module.exports = (items, getDependencies) => {
+	/** @type {Map<T, Node<T>>} */
+	const itemToNode = new Map();
+	for (const item of items) {
+		const node = new Node(item);
+		itemToNode.set(item, node);
+	}
 
-				let paths;
+	// early exit when there is only a single item
+	if (itemToNode.size <= 1) return items;
 
-				try {
-					// We attach the cache to the description file instead of the exportsField value
-					// because we use a WeakMap and the exportsField could be a string too.
-					// Description file is always an object when exports field can be accessed.
-					let fieldProcessor = this.fieldProcessorCache.get(
-						request.descriptionFileData
-					);
-					if (fieldProcessor === undefined) {
-						fieldProcessor = processExportsField(exportsField);
-						this.fieldProcessorCache.set(
-							request.descriptionFileData,
-							fieldProcessor
-						);
-					}
-					paths = fieldProcessor(remainingRequest, this.conditionNames);
-				} catch (err) {
-					if (resolveContext.log) {
-						resolveContext.log(
-							`Exports field in ${request.descriptionFilePath} can't be processed: ${err}`
-						);
-					}
-					return callback(err);
-				}
+	// grab all the dependencies
+	for (const node of itemToNode.values()) {
+		for (const dep of getDependencies(node.item)) {
+			const depNode = itemToNode.get(dep);
+			if (depNode !== undefined) {
+				node.dependencies.add(depNode);
+			}
+		}
+	}
 
-				if (paths.length === 0) {
-					return callback(
-						new Error(
-							`Package path ${remainingRequest} is not exported from package ${request.descriptionFileRoot} (see exports field in ${request.descriptionFilePath})`
-						)
-					);
-				}
+	// Set of current root modules
+	// items will be removed if a new reference to it has been found
+	/** @type {Set<Node<T>>} */
+	const roots = new Set();
 
-				forEachBail(
-					paths,
-					(p, callback) => {
-						const parsedIdentifier = parseIdentifier(p);
+	// Set of current cycles without references to it
+	// cycles will be removed if a new reference to it has been found
+	// that is not part of the cycle
+	/** @type {Set<Cycle<T>>} */
+	const rootCycles = new Set();
 
-						if (!parsedIdentifier) return callback();
+	// For all non-marked nodes
+	for (const selectedNode of itemToNode.values()) {
+		if (selectedNode.marker === NO_MARKER) {
+			// deep-walk all referenced modules
+			// in a non-recursive way
 
-						const [relativePath, query, fragment] = parsedIdentifier;
+			// start by entering the selected node
+			selectedNode.marker = IN_PROGRESS_MARKER;
 
-						const error = checkExportsFieldTarget(relativePath);
+			// keep a stack to avoid recursive walk
+			/** @type {StackEntry<T>[]} */
+			const stack = [
+				{
+					node: selectedNode,
+					openEdges: Array.from(selectedNode.dependencies)
+				}
+			];
 
-						if (error) {
-							return callback(error);
+			// process the top item until stack is empty
+			while (stack.length > 0) {
+				const topOfStack = stack[stack.length - 1];
+
+				// Are there still edges unprocessed in the current node?
+				if (topOfStack.openEdges.length > 0) {
+					// Process one dependency
+					const dependency = topOfStack.openEdges.pop();
+					switch (dependency.marker) {
+						case NO_MARKER:
+							// dependency has not be visited yet
+							// mark it as in-progress and recurse
+							stack.push({
+								node: dependency,
+								openEdges: Array.from(dependency.dependencies)
+							});
+							dependency.marker = IN_PROGRESS_MARKER;
+							break;
+						case IN_PROGRESS_MARKER: {
+							// It's a in-progress cycle
+							let cycle = dependency.cycle;
+							if (!cycle) {
+								cycle = new Cycle();
+								cycle.nodes.add(dependency);
+								dependency.cycle = cycle;
+							}
+							// set cycle property for each node in the cycle
+							// if nodes are already part of a cycle
+							// we merge the cycles to a shared cycle
+							for (
+								let i = stack.length - 1;
+								stack[i].node !== dependency;
+								i--
+							) {
+								const node = stack[i].node;
+								if (node.cycle) {
+									if (node.cycle !== cycle) {
+										// merge cycles
+										for (const cycleNode of node.cycle.nodes) {
+											cycleNode.cycle = cycle;
+											cycle.nodes.add(cycleNode);
+										}
+									}
+								} else {
+									node.cycle = cycle;
+									cycle.nodes.add(node);
+								}
+							}
+							// don't recurse into dependencies
+							// these are already on the stack
+							break;
 						}
+						case DONE_AND_ROOT_MARKER:
+							// This node has be visited yet and is currently a root node
+							// But as this is a new reference to the node
+							// it's not really a root
+							// so we have to convert it to a normal node
+							dependency.marker = DONE_MARKER;
+							roots.delete(dependency);
+							break;
+						case DONE_MAYBE_ROOT_CYCLE_MARKER:
+							// This node has be visited yet and
+							// is maybe currently part of a completed root cycle
+							// we found a new reference to the cycle
+							// so it's not really a root cycle
+							// remove the cycle from the root cycles
+							// and convert it to a normal node
+							rootCycles.delete(dependency.cycle);
+							dependency.marker = DONE_MARKER;
+							break;
+						// DONE_MARKER: nothing to do, don't recurse into dependencies
+					}
+				} else {
+					// All dependencies of the current node has been visited
+					// we leave the node
+					stack.pop();
+					topOfStack.node.marker = DONE_MARKER;
+				}
+			}
+			const cycle = selectedNode.cycle;
+			if (cycle) {
+				for (const node of cycle.nodes) {
+					node.marker = DONE_MAYBE_ROOT_CYCLE_MARKER;
+				}
+				rootCycles.add(cycle);
+			} else {
+				selectedNode.marker = DONE_AND_ROOT_MARKER;
+				roots.add(selectedNode);
+			}
+		}
+	}
 
-						const obj = {
-							...request,
-							request: undefined,
-							path: path.join(
-								/** @type {string} */ (request.descriptionFileRoot),
-								relativePath
-							),
-							relativePath,
-							query,
-							fragment
-						};
+	// Extract roots from root cycles
+	// We take the nodes with most incoming edges
+	// inside of the cycle
+	for (const cycle of rootCycles) {
+		let max = 0;
+		/** @type {Set<Node<T>>} */
+		const cycleRoots = new Set();
+		const nodes = cycle.nodes;
+		for (const node of nodes) {
+			for (const dep of node.dependencies) {
+				if (nodes.has(dep)) {
+					dep.incoming++;
+					if (dep.incoming < max) continue;
+					if (dep.incoming > max) {
+						cycleRoots.clear();
+						max = dep.incoming;
+					}
+					cycleRoots.add(dep);
+				}
+			}
+		}
+		for (const cycleRoot of cycleRoots) {
+			roots.add(cycleRoot);
+		}
+	}
 
-						resolver.doResolve(
-							target,
-							obj,
-							"using exports field: " + p,
-							resolveContext,
-							callback
-						);
-					},
-					(err, result) => callback(err, result || null)
-				);
-			});
+	// When roots were found, return them
+	if (roots.size > 0) {
+		return Array.from(roots, r => r.item);
+	} else {
+		throw new Error("Implementation of findGraphRoots is broken");
 	}
 };
 
 
 /***/ }),
 
-/***/ 50295:
-/***/ (function(module) {
+/***/ 17139:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -134935,242 +133342,342 @@ module.exports = class ExportsFieldPlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+const path = __webpack_require__(71017);
 
-module.exports = class FileExistsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		const fs = resolver.fileSystem;
-		resolver
-			.getHook(this.source)
-			.tapAsync("FileExistsPlugin", (request, resolveContext, callback) => {
-				const file = request.path;
-				if (!file) return callback();
-				fs.stat(file, (err, stat) => {
-					if (err || !stat) {
-						if (resolveContext.missingDependencies)
-							resolveContext.missingDependencies.add(file);
-						if (resolveContext.log) resolveContext.log(file + " doesn't exist");
-						return callback();
-					}
-					if (!stat.isFile()) {
-						if (resolveContext.missingDependencies)
-							resolveContext.missingDependencies.add(file);
-						if (resolveContext.log) resolveContext.log(file + " is not a file");
-						return callback();
-					}
-					if (resolveContext.fileDependencies)
-						resolveContext.fileDependencies.add(file);
-					resolver.doResolve(
-						target,
-						request,
-						"existing file: " + file,
-						resolveContext,
-						callback
-					);
-				});
-			});
-	}
-};
+/**
+ * @typedef {Object} IStats
+ * @property {() => boolean} isFile
+ * @property {() => boolean} isDirectory
+ * @property {() => boolean} isBlockDevice
+ * @property {() => boolean} isCharacterDevice
+ * @property {() => boolean} isSymbolicLink
+ * @property {() => boolean} isFIFO
+ * @property {() => boolean} isSocket
+ * @property {number | bigint} dev
+ * @property {number | bigint} ino
+ * @property {number | bigint} mode
+ * @property {number | bigint} nlink
+ * @property {number | bigint} uid
+ * @property {number | bigint} gid
+ * @property {number | bigint} rdev
+ * @property {number | bigint} size
+ * @property {number | bigint} blksize
+ * @property {number | bigint} blocks
+ * @property {number | bigint} atimeMs
+ * @property {number | bigint} mtimeMs
+ * @property {number | bigint} ctimeMs
+ * @property {number | bigint} birthtimeMs
+ * @property {Date} atime
+ * @property {Date} mtime
+ * @property {Date} ctime
+ * @property {Date} birthtime
+ */
+
+/**
+ * @typedef {Object} IDirent
+ * @property {() => boolean} isFile
+ * @property {() => boolean} isDirectory
+ * @property {() => boolean} isBlockDevice
+ * @property {() => boolean} isCharacterDevice
+ * @property {() => boolean} isSymbolicLink
+ * @property {() => boolean} isFIFO
+ * @property {() => boolean} isSocket
+ * @property {string | Buffer} name
+ */
 
+/** @typedef {function((NodeJS.ErrnoException | null)=): void} Callback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer=): void} BufferCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer|string=): void} BufferOrStringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, string=): void} StringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, number=): void} NumberCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, IStats=): void} StatsCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, IStats|string=): void} LstatReadlinkAbsoluteCallback */
 
-/***/ }),
+/**
+ * @typedef {Object} WatcherInfo
+ * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
+ * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} fileTimeInfoEntries get info about files
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} contextTimeInfoEntries get info about directories
+ */
 
-/***/ 7317:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+// TODO webpack 6 deprecate missing getInfo
+/**
+ * @typedef {Object} Watcher
+ * @property {function(): void} close closes the watcher and all underlying file watchers
+ * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
+ * @property {function(): Set<string>=} getAggregatedChanges get current aggregated changes that have not yet send to callback
+ * @property {function(): Set<string>=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
+ * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getFileTimeInfoEntries get info about files
+ * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getContextTimeInfoEntries get info about directories
+ * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+/**
+ * @callback WatchMethod
+ * @param {Iterable<string>} files watched files
+ * @param {Iterable<string>} directories watched directories
+ * @param {Iterable<string>} missing watched exitance entries
+ * @param {number} startTime timestamp of start time
+ * @param {WatchOptions} options options object
+ * @param {function(Error=, Map<string, FileSystemInfoEntry | "ignore">, Map<string, FileSystemInfoEntry | "ignore">, Set<string>, Set<string>): void} callback aggregated callback
+ * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
+ * @returns {Watcher} a watcher
+ */
 
+// TODO webpack 6 make optional methods required
 
+/**
+ * @typedef {Object} OutputFileSystem
+ * @property {function(string, Buffer|string, Callback): void} writeFile
+ * @property {function(string, Callback): void} mkdir
+ * @property {function(string, DirentArrayCallback): void=} readdir
+ * @property {function(string, Callback): void=} rmdir
+ * @property {function(string, Callback): void=} unlink
+ * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
+ * @property {function(string, BufferOrStringCallback): void} readFile
+ * @property {(function(string, string): string)=} join
+ * @property {(function(string, string): string)=} relative
+ * @property {(function(string): string)=} dirname
+ */
 
-const path = __webpack_require__(71017);
-const DescriptionFileUtils = __webpack_require__(25424);
-const forEachBail = __webpack_require__(78565);
-const { processImportsField } = __webpack_require__(55863);
-const { parseIdentifier } = __webpack_require__(71053);
+/**
+ * @typedef {Object} InputFileSystem
+ * @property {function(string, BufferOrStringCallback): void} readFile
+ * @property {(function(string, ReadJsonCallback): void)=} readJson
+ * @property {function(string, BufferOrStringCallback): void} readlink
+ * @property {function(string, DirentArrayCallback): void} readdir
+ * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
+ * @property {(function(string, BufferOrStringCallback): void)=} realpath
+ * @property {(function(string=): void)=} purge
+ * @property {(function(string, string): string)=} join
+ * @property {(function(string, string): string)=} relative
+ * @property {(function(string): string)=} dirname
+ */
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
-/** @typedef {import("./util/entrypoints").ImportsField} ImportsField */
+/**
+ * @typedef {Object} WatchFileSystem
+ * @property {WatchMethod} watch
+ */
 
-const dotCode = ".".charCodeAt(0);
+/**
+ * @typedef {Object} IntermediateFileSystemExtras
+ * @property {function(string): void} mkdirSync
+ * @property {function(string): NodeJS.WritableStream} createWriteStream
+ * @property {function(string, string, NumberCallback): void} open
+ * @property {function(number, Buffer, number, number, number, NumberCallback): void} read
+ * @property {function(number, Callback): void} close
+ * @property {function(string, string, Callback): void} rename
+ */
 
-module.exports = class ImportsFieldPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Set<string>} conditionNames condition names
-	 * @param {string | string[]} fieldNamePath name path
-	 * @param {string | ResolveStepHook} targetFile target file
-	 * @param {string | ResolveStepHook} targetPackage target package
-	 */
-	constructor(
-		source,
-		conditionNames,
-		fieldNamePath,
-		targetFile,
-		targetPackage
-	) {
-		this.source = source;
-		this.targetFile = targetFile;
-		this.targetPackage = targetPackage;
-		this.conditionNames = conditionNames;
-		this.fieldName = fieldNamePath;
-		/** @type {WeakMap<any, FieldProcessor>} */
-		this.fieldProcessorCache = new WeakMap();
-	}
+/** @typedef {InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras} IntermediateFileSystem */
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const targetFile = resolver.ensureHook(this.targetFile);
-		const targetPackage = resolver.ensureHook(this.targetPackage);
+/**
+ *
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} rootPath the root path
+ * @param {string} targetPath the target path
+ * @returns {string} location of targetPath relative to rootPath
+ */
+const relative = (fs, rootPath, targetPath) => {
+	if (fs && fs.relative) {
+		return fs.relative(rootPath, targetPath);
+	} else if (path.posix.isAbsolute(rootPath)) {
+		return path.posix.relative(rootPath, targetPath);
+	} else if (path.win32.isAbsolute(rootPath)) {
+		return path.win32.relative(rootPath, targetPath);
+	} else {
+		throw new Error(
+			`${rootPath} is neither a posix nor a windows path, and there is no 'relative' method defined in the file system`
+		);
+	}
+};
+exports.relative = relative;
 
-		resolver
-			.getHook(this.source)
-			.tapAsync("ImportsFieldPlugin", (request, resolveContext, callback) => {
-				// When there is no description file, abort
-				if (!request.descriptionFilePath || request.request === undefined) {
-					return callback();
-				}
+/**
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} rootPath a path
+ * @param {string} filename a filename
+ * @returns {string} the joined path
+ */
+const join = (fs, rootPath, filename) => {
+	if (fs && fs.join) {
+		return fs.join(rootPath, filename);
+	} else if (path.posix.isAbsolute(rootPath)) {
+		return path.posix.join(rootPath, filename);
+	} else if (path.win32.isAbsolute(rootPath)) {
+		return path.win32.join(rootPath, filename);
+	} else {
+		throw new Error(
+			`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`
+		);
+	}
+};
+exports.join = join;
 
-				const remainingRequest =
-					request.request + request.query + request.fragment;
-				/** @type {ImportsField|null} */
-				const importsField = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.fieldName
-				);
-				if (!importsField) return callback();
+/**
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} absPath an absolute path
+ * @returns {string} the parent directory of the absolute path
+ */
+const dirname = (fs, absPath) => {
+	if (fs && fs.dirname) {
+		return fs.dirname(absPath);
+	} else if (path.posix.isAbsolute(absPath)) {
+		return path.posix.dirname(absPath);
+	} else if (path.win32.isAbsolute(absPath)) {
+		return path.win32.dirname(absPath);
+	} else {
+		throw new Error(
+			`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`
+		);
+	}
+};
+exports.dirname = dirname;
 
-				if (request.directory) {
-					return callback(
-						new Error(
-							`Resolving to directories is not possible with the imports field (request was ${remainingRequest}/)`
-						)
-					);
+/**
+ * @param {OutputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {function(Error=): void} callback callback function for the error
+ * @returns {void}
+ */
+const mkdirp = (fs, p, callback) => {
+	fs.mkdir(p, err => {
+		if (err) {
+			if (err.code === "ENOENT") {
+				const dir = dirname(fs, p);
+				if (dir === p) {
+					callback(err);
+					return;
 				}
-
-				let paths;
-
-				try {
-					// We attach the cache to the description file instead of the importsField value
-					// because we use a WeakMap and the importsField could be a string too.
-					// Description file is always an object when exports field can be accessed.
-					let fieldProcessor = this.fieldProcessorCache.get(
-						request.descriptionFileData
-					);
-					if (fieldProcessor === undefined) {
-						fieldProcessor = processImportsField(importsField);
-						this.fieldProcessorCache.set(
-							request.descriptionFileData,
-							fieldProcessor
-						);
-					}
-					paths = fieldProcessor(remainingRequest, this.conditionNames);
-				} catch (err) {
-					if (resolveContext.log) {
-						resolveContext.log(
-							`Imports field in ${request.descriptionFilePath} can't be processed: ${err}`
-						);
+				mkdirp(fs, dir, err => {
+					if (err) {
+						callback(err);
+						return;
 					}
-					return callback(err);
-				}
+					fs.mkdir(p, err => {
+						if (err) {
+							if (err.code === "EEXIST") {
+								callback();
+								return;
+							}
+							callback(err);
+							return;
+						}
+						callback();
+					});
+				});
+				return;
+			} else if (err.code === "EEXIST") {
+				callback();
+				return;
+			}
+			callback(err);
+			return;
+		}
+		callback();
+	});
+};
+exports.mkdirp = mkdirp;
 
-				if (paths.length === 0) {
-					return callback(
-						new Error(
-							`Package import ${remainingRequest} is not imported from package ${request.descriptionFileRoot} (see imports field in ${request.descriptionFilePath})`
-						)
-					);
+/**
+ * @param {IntermediateFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @returns {void}
+ */
+const mkdirpSync = (fs, p) => {
+	try {
+		fs.mkdirSync(p);
+	} catch (err) {
+		if (err) {
+			if (err.code === "ENOENT") {
+				const dir = dirname(fs, p);
+				if (dir === p) {
+					throw err;
 				}
+				mkdirpSync(fs, dir);
+				fs.mkdirSync(p);
+				return;
+			} else if (err.code === "EEXIST") {
+				return;
+			}
+			throw err;
+		}
+	}
+};
+exports.mkdirpSync = mkdirpSync;
 
-				forEachBail(
-					paths,
-					(p, callback) => {
-						const parsedIdentifier = parseIdentifier(p);
-
-						if (!parsedIdentifier) return callback();
-
-						const [path_, query, fragment] = parsedIdentifier;
-
-						switch (path_.charCodeAt(0)) {
-							// should be relative
-							case dotCode: {
-								const obj = {
-									...request,
-									request: undefined,
-									path: path.join(
-										/** @type {string} */ (request.descriptionFileRoot),
-										path_
-									),
-									relativePath: path_,
-									query,
-									fragment
-								};
-
-								resolver.doResolve(
-									targetFile,
-									obj,
-									"using imports field: " + p,
-									resolveContext,
-									callback
-								);
-								break;
-							}
-
-							// package resolving
-							default: {
-								const obj = {
-									...request,
-									request: path_,
-									relativePath: path_,
-									fullySpecified: true,
-									query,
-									fragment
-								};
+/**
+ * @param {InputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {ReadJsonCallback} callback callback
+ * @returns {void}
+ */
+const readJson = (fs, p, callback) => {
+	if ("readJson" in fs) return fs.readJson(p, callback);
+	fs.readFile(p, (err, buf) => {
+		if (err) return callback(err);
+		let data;
+		try {
+			data = JSON.parse(buf.toString("utf-8"));
+		} catch (e) {
+			return callback(e);
+		}
+		return callback(null, data);
+	});
+};
+exports.readJson = readJson;
 
-								resolver.doResolve(
-									targetPackage,
-									obj,
-									"using imports field: " + p,
-									resolveContext,
-									callback
-								);
-							}
-						}
-					},
-					(err, result) => callback(err, result || null)
-				);
+/**
+ * @param {InputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {ReadJsonCallback} callback callback
+ * @returns {void}
+ */
+const lstatReadlinkAbsolute = (fs, p, callback) => {
+	let i = 3;
+	const doReadLink = () => {
+		fs.readlink(p, (err, target) => {
+			if (err && --i > 0) {
+				// It might was just changed from symlink to file
+				// we retry 2 times to catch this case before throwing the error
+				return doStat();
+			}
+			if (err || !target) return doStat();
+			const value = target.toString();
+			callback(null, join(fs, dirname(fs, p), value));
+		});
+	};
+	const doStat = () => {
+		if ("lstat" in fs) {
+			return fs.lstat(p, (err, stats) => {
+				if (err) return callback(err);
+				if (stats.isSymbolicLink()) {
+					return doReadLink();
+				}
+				callback(null, stats);
 			});
-	}
+		} else {
+			return fs.stat(p, callback);
+		}
+	};
+	if ("lstat" in fs) return doStat();
+	doReadLink();
 };
+exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
 
 
 /***/ }),
 
-/***/ 35949:
-/***/ (function(module) {
+/***/ 59461:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -135180,69 +133687,73 @@ module.exports = class ImportsFieldPlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+const Hash = __webpack_require__(36692);
+const MAX_SHORT_STRING = (__webpack_require__(1842).MAX_SHORT_STRING);
 
-const namespaceStartCharCode = "@".charCodeAt(0);
+class BatchedHash extends Hash {
+	constructor(hash) {
+		super();
+		this.string = undefined;
+		this.encoding = undefined;
+		this.hash = hash;
+	}
 
-module.exports = class JoinRequestPartPlugin {
 	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
 	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
+	update(data, inputEncoding) {
+		if (this.string !== undefined) {
+			if (
+				typeof data === "string" &&
+				inputEncoding === this.encoding &&
+				this.string.length + data.length < MAX_SHORT_STRING
+			) {
+				this.string += data;
+				return this;
+			}
+			this.hash.update(this.string, this.encoding);
+			this.string = undefined;
+		}
+		if (typeof data === "string") {
+			if (
+				data.length < MAX_SHORT_STRING &&
+				// base64 encoding is not valid since it may contain padding chars
+				(!inputEncoding || !inputEncoding.startsWith("ba"))
+			) {
+				this.string = data;
+				this.encoding = inputEncoding;
+			} else {
+				this.hash.update(data, inputEncoding);
+			}
+		} else {
+			this.hash.update(data);
+		}
+		return this;
 	}
 
 	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"JoinRequestPartPlugin",
-				(request, resolveContext, callback) => {
-					const req = request.request || "";
-					let i = req.indexOf("/", 3);
-
-					if (i >= 0 && req.charCodeAt(2) === namespaceStartCharCode) {
-						i = req.indexOf("/", i + 1);
-					}
-
-					let moduleName, remainingRequest, fullySpecified;
-					if (i < 0) {
-						moduleName = req;
-						remainingRequest = ".";
-						fullySpecified = false;
-					} else {
-						moduleName = req.slice(0, i);
-						remainingRequest = "." + req.slice(i);
-						fullySpecified = request.fullySpecified;
-					}
-					const obj = {
-						...request,
-						path: resolver.join(request.path, moduleName),
-						relativePath:
-							request.relativePath &&
-							resolver.join(request.relativePath, moduleName),
-						request: remainingRequest,
-						fullySpecified
-					};
-					resolver.doResolve(target, obj, null, resolveContext, callback);
-				}
-			);
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		if (this.string !== undefined) {
+			this.hash.update(this.string, this.encoding);
+		}
+		return this.hash.digest(encoding);
 	}
-};
+}
+
+module.exports = BatchedHash;
 
 
 /***/ }),
 
-/***/ 5190:
-/***/ (function(module) {
+/***/ 86884:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -135252,45 +133763,24 @@ module.exports = class JoinRequestPartPlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+const create = __webpack_require__(1842);
 
-module.exports = class JoinRequestPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+const md4 = new WebAssembly.Module(
+	Buffer.from(
+		// 2156 bytes
+		"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",
+		"base64"
+	)
+);
+//#endregion
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => {
-				const obj = {
-					...request,
-					path: resolver.join(request.path, request.request),
-					relativePath:
-						request.relativePath &&
-						resolver.join(request.relativePath, request.request),
-					request: undefined
-				};
-				resolver.doResolve(target, obj, null, resolveContext, callback);
-			});
-	}
-};
+module.exports = create.bind(null, md4, [], 64, 32);
 
 
 /***/ }),
 
-/***/ 5049:
+/***/ 1842:
 /***/ (function(module) {
 
 "use strict";
@@ -135301,54 +133791,167 @@ module.exports = class JoinRequestPlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
+// 65536 is the size of a wasm memory page
+// 64 is the maximum chunk size for every possible wasm hash implementation
+// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 
-module.exports = class LogInfoPlugin {
-	constructor(source) {
-		this.source = source;
+class WasmHash {
+	/**
+	 * @param {WebAssembly.Instance} instance wasm instance
+	 * @param {WebAssembly.Instance[]} instancesPool pool of instances
+	 * @param {number} chunkSize size of data chunks passed to wasm
+	 * @param {number} digestSize size of digest returned by wasm
+	 */
+	constructor(instance, instancesPool, chunkSize, digestSize) {
+		const exports = /** @type {any} */ (instance.exports);
+		exports.init();
+		this.exports = exports;
+		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+		this.buffered = 0;
+		this.instancesPool = instancesPool;
+		this.chunkSize = chunkSize;
+		this.digestSize = digestSize;
+	}
+
+	reset() {
+		this.buffered = 0;
+		this.exports.init();
 	}
 
 	/**
-	 * @param {Resolver} resolver the resolver
+	 * @param {Buffer | string} data data
+	 * @param {BufferEncoding=} encoding encoding
+	 * @returns {this} itself
+	 */
+	update(data, encoding) {
+		if (typeof data === "string") {
+			while (data.length > MAX_SHORT_STRING) {
+				this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+				data = data.slice(MAX_SHORT_STRING);
+			}
+			this._updateWithShortString(data, encoding);
+			return this;
+		}
+		this._updateWithBuffer(data);
+		return this;
+	}
+
+	/**
+	 * @param {string} data data
+	 * @param {BufferEncoding=} encoding encoding
 	 * @returns {void}
 	 */
-	apply(resolver) {
-		const source = this.source;
-		resolver
-			.getHook(this.source)
-			.tapAsync("LogInfoPlugin", (request, resolveContext, callback) => {
-				if (!resolveContext.log) return callback();
-				const log = resolveContext.log;
-				const prefix = "[" + source + "] ";
-				if (request.path)
-					log(prefix + "Resolving in directory: " + request.path);
-				if (request.request)
-					log(prefix + "Resolving request: " + request.request);
-				if (request.module) log(prefix + "Request is an module request.");
-				if (request.directory) log(prefix + "Request is a directory request.");
-				if (request.query)
-					log(prefix + "Resolving request query: " + request.query);
-				if (request.fragment)
-					log(prefix + "Resolving request fragment: " + request.fragment);
-				if (request.descriptionFilePath)
-					log(
-						prefix + "Has description data from " + request.descriptionFilePath
-					);
-				if (request.relativePath)
-					log(
-						prefix +
-							"Relative path from description file is: " +
-							request.relativePath
-					);
-				callback();
-			});
+	_updateWithShortString(data, encoding) {
+		const { exports, buffered, mem, chunkSize } = this;
+		let endPos;
+		if (data.length < 70) {
+			if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					if (cc < 0x80) mem[endPos++] = cc;
+					else if (cc < 0x800) {
+						mem[endPos] = (cc >> 6) | 0xc0;
+						mem[endPos + 1] = (cc & 0x3f) | 0x80;
+						endPos += 2;
+					} else {
+						// bail-out for weird chars
+						endPos += mem.write(data.slice(i), endPos, encoding);
+						break;
+					}
+				}
+			} else if (encoding === "latin1") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					mem[endPos++] = cc;
+				}
+			} else {
+				endPos = buffered + mem.write(data, buffered, encoding);
+			}
+		} else {
+			endPos = buffered + mem.write(data, buffered, encoding);
+		}
+		if (endPos < chunkSize) {
+			this.buffered = endPos;
+		} else {
+			const l = endPos & ~(this.chunkSize - 1);
+			exports.update(l);
+			const newBuffered = endPos - l;
+			this.buffered = newBuffered;
+			if (newBuffered > 0) mem.copyWithin(0, l, endPos);
+		}
+	}
+
+	/**
+	 * @param {Buffer} data data
+	 * @returns {void}
+	 */
+	_updateWithBuffer(data) {
+		const { exports, buffered, mem } = this;
+		const length = data.length;
+		if (buffered + length < this.chunkSize) {
+			data.copy(mem, buffered, 0, length);
+			this.buffered += length;
+		} else {
+			const l = (buffered + length) & ~(this.chunkSize - 1);
+			if (l > 65536) {
+				let i = 65536 - buffered;
+				data.copy(mem, buffered, 0, i);
+				exports.update(65536);
+				const stop = l - buffered - 65536;
+				while (i < stop) {
+					data.copy(mem, 0, i, i + 65536);
+					exports.update(65536);
+					i += 65536;
+				}
+				data.copy(mem, 0, i, l - buffered);
+				exports.update(l - buffered - i);
+			} else {
+				data.copy(mem, buffered, 0, l - buffered);
+				exports.update(l);
+			}
+			const newBuffered = length + buffered - l;
+			this.buffered = newBuffered;
+			if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
+		}
+	}
+
+	digest(type) {
+		const { exports, buffered, mem, digestSize } = this;
+		exports.final(buffered);
+		this.instancesPool.push(this);
+		const hex = mem.toString("latin1", 0, digestSize);
+		if (type === "hex") return hex;
+		if (type === "binary" || !type) return Buffer.from(hex, "hex");
+		return Buffer.from(hex, "hex").toString(type);
+	}
+}
+
+const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+	if (instancesPool.length > 0) {
+		const old = instancesPool.pop();
+		old.reset();
+		return old;
+	} else {
+		return new WasmHash(
+			new WebAssembly.Instance(wasmModule),
+			instancesPool,
+			chunkSize,
+			digestSize
+		);
 	}
 };
 
+module.exports = create;
+module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
+
 
 /***/ }),
 
-/***/ 47450:
+/***/ 35028:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -135359,270 +133962,389 @@ module.exports = class LogInfoPlugin {
 
 
 
-const path = __webpack_require__(71017);
-const DescriptionFileUtils = __webpack_require__(25424);
-
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {{name: string|Array<string>, forceRelative: boolean}} MainFieldOptions */
-
-const alreadyTriedMainField = Symbol("alreadyTriedMainField");
-
-module.exports = class MainFieldPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {MainFieldOptions} options options
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, options, target) {
-		this.source = source;
-		this.options = options;
-		this.target = target;
-	}
+const create = __webpack_require__(1842);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("MainFieldPlugin", (request, resolveContext, callback) => {
-				if (
-					request.path !== request.descriptionFileRoot ||
-					request[alreadyTriedMainField] === request.descriptionFilePath ||
-					!request.descriptionFilePath
-				)
-					return callback();
-				const filename = path.basename(request.descriptionFilePath);
-				let mainModule = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.options.name
-				);
+//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+const xxhash64 = new WebAssembly.Module(
+	Buffer.from(
+		// 1170 bytes
+		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrIIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqAYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEAgAiABNQIAQoeVr6+Ytt6bnn9+hUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAkIdiCAChUL5893xmfaZqxZ+IgJCIIggAoUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL",
+		"base64"
+	)
+);
+//#endregion
 
-				if (
-					!mainModule ||
-					typeof mainModule !== "string" ||
-					mainModule === "." ||
-					mainModule === "./"
-				) {
-					return callback();
-				}
-				if (this.options.forceRelative && !/^\.\.?\//.test(mainModule))
-					mainModule = "./" + mainModule;
-				const obj = {
-					...request,
-					request: mainModule,
-					module: false,
-					directory: mainModule.endsWith("/"),
-					[alreadyTriedMainField]: request.descriptionFilePath
-				};
-				return resolver.doResolve(
-					target,
-					obj,
-					"use " +
-						mainModule +
-						" from " +
-						this.options.name +
-						" in " +
-						filename,
-					resolveContext,
-					callback
-				);
-			});
-	}
-};
+module.exports = create.bind(null, xxhash64, [], 32, 16);
 
 
 /***/ }),
 
-/***/ 48506:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 82186:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const forEachBail = __webpack_require__(78565);
-const getPaths = __webpack_require__(82918);
+const path = __webpack_require__(71017);
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const SEGMENTS_SPLIT_REGEXP = /([|!])/;
+const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
 
-module.exports = class ModulesInHierachicDirectoriesPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | Array<string>} directories directories
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, directories, target) {
-		this.source = source;
-		this.directories = /** @type {Array<string>} */ ([]).concat(directories);
-		this.target = target;
+/**
+ * @typedef {Object} MakeRelativePathsCache
+ * @property {Map<string, Map<string, string>>=} relativePaths
+ */
+
+const relativePathToRequest = relativePath => {
+	if (relativePath === "") return "./.";
+	if (relativePath === "..") return "../.";
+	if (relativePath.startsWith("../")) return relativePath;
+	return `./${relativePath}`;
+};
+
+/**
+ * @param {string} context context for relative path
+ * @param {string} maybeAbsolutePath path to make relative
+ * @returns {string} relative path in request style
+ */
+const absoluteToRequest = (context, maybeAbsolutePath) => {
+	if (maybeAbsolutePath[0] === "/") {
+		if (
+			maybeAbsolutePath.length > 1 &&
+			maybeAbsolutePath[maybeAbsolutePath.length - 1] === "/"
+		) {
+			// this 'path' is actually a regexp generated by dynamic requires.
+			// Don't treat it as an absolute path.
+			return maybeAbsolutePath;
+		}
+
+		const querySplitPos = maybeAbsolutePath.indexOf("?");
+		let resource =
+			querySplitPos === -1
+				? maybeAbsolutePath
+				: maybeAbsolutePath.slice(0, querySplitPos);
+		resource = relativePathToRequest(path.posix.relative(context, resource));
+		return querySplitPos === -1
+			? resource
+			: resource + maybeAbsolutePath.slice(querySplitPos);
 	}
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"ModulesInHierachicDirectoriesPlugin",
-				(request, resolveContext, callback) => {
-					const fs = resolver.fileSystem;
-					const addrs = getPaths(request.path)
-						.paths.map(p => {
-							return this.directories.map(d => resolver.join(p, d));
-						})
-						.reduce((array, p) => {
-							array.push.apply(array, p);
-							return array;
-						}, []);
-					forEachBail(
-						addrs,
-						(addr, callback) => {
-							fs.stat(addr, (err, stat) => {
-								if (!err && stat && stat.isDirectory()) {
-									const obj = {
-										...request,
-										path: addr,
-										request: "./" + request.request,
-										module: false
-									};
-									const message = "looking for modules in " + addr;
-									return resolver.doResolve(
-										target,
-										obj,
-										message,
-										resolveContext,
-										callback
-									);
-								}
-								if (resolveContext.log)
-									resolveContext.log(
-										addr + " doesn't exist or is not a directory"
-									);
-								if (resolveContext.missingDependencies)
-									resolveContext.missingDependencies.add(addr);
-								return callback();
-							});
-						},
-						callback
-					);
-				}
+	if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
+		const querySplitPos = maybeAbsolutePath.indexOf("?");
+		let resource =
+			querySplitPos === -1
+				? maybeAbsolutePath
+				: maybeAbsolutePath.slice(0, querySplitPos);
+		resource = path.win32.relative(context, resource);
+		if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
+			resource = relativePathToRequest(
+				resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/")
 			);
+		}
+		return querySplitPos === -1
+			? resource
+			: resource + maybeAbsolutePath.slice(querySplitPos);
 	}
+
+	// not an absolute path
+	return maybeAbsolutePath;
+};
+
+/**
+ * @param {string} context context for relative path
+ * @param {string} relativePath path
+ * @returns {string} absolute path
+ */
+const requestToAbsolute = (context, relativePath) => {
+	if (relativePath.startsWith("./") || relativePath.startsWith("../"))
+		return path.join(context, relativePath);
+	return relativePath;
 };
 
+const makeCacheable = fn => {
+	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
+	const cache = new WeakMap();
+
+	/**
+	 * @param {string} context context used to create relative path
+	 * @param {string} identifier identifier used to create relative path
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {string} the returned relative path
+	 */
+	const cachedFn = (context, identifier, associatedObjectForCache) => {
+		if (!associatedObjectForCache) return fn(context, identifier);
+
+		let innerCache = cache.get(associatedObjectForCache);
+		if (innerCache === undefined) {
+			innerCache = new Map();
+			cache.set(associatedObjectForCache, innerCache);
+		}
+
+		let cachedResult;
+		let innerSubCache = innerCache.get(context);
+		if (innerSubCache === undefined) {
+			innerCache.set(context, (innerSubCache = new Map()));
+		} else {
+			cachedResult = innerSubCache.get(identifier);
+		}
+
+		if (cachedResult !== undefined) {
+			return cachedResult;
+		} else {
+			const result = fn(context, identifier);
+			innerSubCache.set(identifier, result);
+			return result;
+		}
+	};
+
+	/**
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {function(string, string): string} cached function
+	 */
+	cachedFn.bindCache = associatedObjectForCache => {
+		let innerCache;
+		if (associatedObjectForCache) {
+			innerCache = cache.get(associatedObjectForCache);
+			if (innerCache === undefined) {
+				innerCache = new Map();
+				cache.set(associatedObjectForCache, innerCache);
+			}
+		} else {
+			innerCache = new Map();
+		}
+
+		/**
+		 * @param {string} context context used to create relative path
+		 * @param {string} identifier identifier used to create relative path
+		 * @returns {string} the returned relative path
+		 */
+		const boundFn = (context, identifier) => {
+			let cachedResult;
+			let innerSubCache = innerCache.get(context);
+			if (innerSubCache === undefined) {
+				innerCache.set(context, (innerSubCache = new Map()));
+			} else {
+				cachedResult = innerSubCache.get(identifier);
+			}
 
-/***/ }),
+			if (cachedResult !== undefined) {
+				return cachedResult;
+			} else {
+				const result = fn(context, identifier);
+				innerSubCache.set(identifier, result);
+				return result;
+			}
+		};
 
-/***/ 88138:
-/***/ (function(module) {
+		return boundFn;
+	};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {string} context context used to create relative path
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {function(string): string} cached function
+	 */
+	cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+		let innerSubCache;
+		if (associatedObjectForCache) {
+			let innerCache = cache.get(associatedObjectForCache);
+			if (innerCache === undefined) {
+				innerCache = new Map();
+				cache.set(associatedObjectForCache, innerCache);
+			}
 
+			innerSubCache = innerCache.get(context);
+			if (innerSubCache === undefined) {
+				innerCache.set(context, (innerSubCache = new Map()));
+			}
+		} else {
+			innerSubCache = new Map();
+		}
 
+		/**
+		 * @param {string} identifier identifier used to create relative path
+		 * @returns {string} the returned relative path
+		 */
+		const boundFn = identifier => {
+			const cachedResult = innerSubCache.get(identifier);
+			if (cachedResult !== undefined) {
+				return cachedResult;
+			} else {
+				const result = fn(context, identifier);
+				innerSubCache.set(identifier, result);
+				return result;
+			}
+		};
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+		return boundFn;
+	};
 
-module.exports = class ModulesInRootPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} path path
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, path, target) {
-		this.source = source;
-		this.path = path;
-		this.target = target;
-	}
+	return cachedFn;
+};
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => {
-				const obj = {
-					...request,
-					path: this.path,
-					request: "./" + request.request,
-					module: false
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"looking for modules in " + this.path,
-					resolveContext,
-					callback
-				);
-			});
-	}
+/**
+ *
+ * @param {string} context context for relative path
+ * @param {string} identifier identifier for path
+ * @returns {string} a converted relative path
+ */
+const _makePathsRelative = (context, identifier) => {
+	return identifier
+		.split(SEGMENTS_SPLIT_REGEXP)
+		.map(str => absoluteToRequest(context, str))
+		.join("");
 };
 
+exports.makePathsRelative = makeCacheable(_makePathsRelative);
 
-/***/ }),
+/**
+ *
+ * @param {string} context context for relative path
+ * @param {string} identifier identifier for path
+ * @returns {string} a converted relative path
+ */
+const _makePathsAbsolute = (context, identifier) => {
+	return identifier
+		.split(SEGMENTS_SPLIT_REGEXP)
+		.map(str => requestToAbsolute(context, str))
+		.join("");
+};
 
-/***/ 40777:
-/***/ (function(module) {
+exports.makePathsAbsolute = makeCacheable(_makePathsAbsolute);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {string} context absolute context path
+ * @param {string} request any request string may containing absolute paths, query string, etc.
+ * @returns {string} a new request string avoiding absolute paths when possible
+ */
+const _contextify = (context, request) => {
+	return request
+		.split("!")
+		.map(r => absoluteToRequest(context, r))
+		.join("!");
+};
+
+const contextify = makeCacheable(_contextify);
+exports.contextify = contextify;
+
+/**
+ * @param {string} context absolute context path
+ * @param {string} request any request string
+ * @returns {string} a new request string using absolute paths when possible
+ */
+const _absolutify = (context, request) => {
+	return request
+		.split("!")
+		.map(r => requestToAbsolute(context, r))
+		.join("!");
+};
 
+const absolutify = makeCacheable(_absolutify);
+exports.absolutify = absolutify;
 
+const PATH_QUERY_FRAGMENT_REGEXP =
+	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
 
-module.exports = class NextPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+/**
+ * @param {string} str the path with query and fragment
+ * @returns {ParsedResource} parsed parts
+ */
+const _parseResource = str => {
+	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+	return {
+		resource: str,
+		path: match[1].replace(/\0(.)/g, "$1"),
+		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		fragment: match[3] || ""
+	};
+};
+exports.parseResource = (realFn => {
+	/** @type {WeakMap<object, Map<string, ParsedResource>>} */
+	const cache = new WeakMap();
+
+	const getCache = associatedObjectForCache => {
+		const entry = cache.get(associatedObjectForCache);
+		if (entry !== undefined) return entry;
+		/** @type {Map<string, ParsedResource>} */
+		const map = new Map();
+		cache.set(associatedObjectForCache, map);
+		return map;
+	};
 
 	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
+	 * @param {string} str the path with query and fragment
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {ParsedResource} parsed parts
 	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("NextPlugin", (request, resolveContext, callback) => {
-				resolver.doResolve(target, request, null, resolveContext, callback);
-			});
+	const fn = (str, associatedObjectForCache) => {
+		if (!associatedObjectForCache) return realFn(str);
+		const cache = getCache(associatedObjectForCache);
+		const entry = cache.get(str);
+		if (entry !== undefined) return entry;
+		const result = realFn(str);
+		cache.set(str, result);
+		return result;
+	};
+
+	fn.bindCache = associatedObjectForCache => {
+		const cache = getCache(associatedObjectForCache);
+		return str => {
+			const entry = cache.get(str);
+			if (entry !== undefined) return entry;
+			const result = realFn(str);
+			cache.set(str, result);
+			return result;
+		};
+	};
+
+	return fn;
+})(_parseResource);
+
+/**
+ * @param {string} filename the filename which should be undone
+ * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param {boolean} enforceRelative true returns ./ for empty paths
+ * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ */
+exports.getUndoPath = (filename, outputPath, enforceRelative) => {
+	let depth = -1;
+	let append = "";
+	outputPath = outputPath.replace(/[\\/]$/, "");
+	for (const part of filename.split(/[/\\]+/)) {
+		if (part === "..") {
+			if (depth > -1) {
+				depth--;
+			} else {
+				const i = outputPath.lastIndexOf("/");
+				const j = outputPath.lastIndexOf("\\");
+				const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+				if (pos < 0) return outputPath + "/";
+				append = outputPath.slice(pos + 1) + "/" + append;
+				outputPath = outputPath.slice(0, pos);
+			}
+		} else if (part !== ".") {
+			depth++;
+		}
 	}
+	return depth > 0
+		? `${"../".repeat(depth)}${append}`
+		: enforceRelative
+		? `./${append}`
+		: append;
 };
 
 
 /***/ }),
 
-/***/ 97849:
-/***/ (function(module) {
+/***/ 53023:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -135632,190 +134354,292 @@ module.exports = class NextPlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-
-module.exports = class ParsePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Partial<ResolveRequest>} requestOptions request options
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, requestOptions, target) {
-		this.source = source;
-		this.requestOptions = requestOptions;
-		this.target = target;
-	}
-
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ParsePlugin", (request, resolveContext, callback) => {
-				const parsed = resolver.parse(/** @type {string} */ (request.request));
-				const obj = { ...request, ...parsed, ...this.requestOptions };
-				if (request.query && !parsed.query) {
-					obj.query = request.query;
-				}
-				if (request.fragment && !parsed.fragment) {
-					obj.fragment = request.fragment;
-				}
-				if (parsed && resolveContext.log) {
-					if (parsed.module) resolveContext.log("Parsed request is a module");
-					if (parsed.directory)
-						resolveContext.log("Parsed request is a directory");
-				}
-				// There is an edge-case where a request with # can be a path or a fragment -> try both
-				if (obj.request && !obj.query && obj.fragment) {
-					const directory = obj.fragment.endsWith("/");
-					const alternative = {
-						...obj,
-						directory,
-						request:
-							obj.request +
-							(obj.directory ? "/" : "") +
-							(directory ? obj.fragment.slice(0, -1) : obj.fragment),
-						fragment: ""
-					};
-					resolver.doResolve(
-						target,
-						alternative,
-						null,
-						resolveContext,
-						(err, result) => {
-							if (err) return callback(err);
-							if (result) return callback(null, result);
-							resolver.doResolve(target, obj, null, resolveContext, callback);
-						}
-					);
-					return;
-				}
-				resolver.doResolve(target, obj, null, resolveContext, callback);
-			});
+// We need to include a list of requires here
+// to allow webpack to be bundled with only static requires
+// We could use a dynamic require(`../${request}`) but this
+// would include too many modules and not every tool is able
+// to process this
+module.exports = {
+	AsyncDependenciesBlock: () => __webpack_require__(47736),
+	CommentCompilationWarning: () => __webpack_require__(98427),
+	ContextModule: () => __webpack_require__(76729),
+	"cache/PackFileCacheStrategy": () =>
+		__webpack_require__(86180),
+	"cache/ResolverCachePlugin": () => __webpack_require__(97347),
+	"container/ContainerEntryDependency": () =>
+		__webpack_require__(64813),
+	"container/ContainerEntryModule": () =>
+		__webpack_require__(80580),
+	"container/ContainerExposedDependency": () =>
+		__webpack_require__(72374),
+	"container/FallbackDependency": () =>
+		__webpack_require__(57764),
+	"container/FallbackItemDependency": () =>
+		__webpack_require__(29593),
+	"container/FallbackModule": () => __webpack_require__(82886),
+	"container/RemoteModule": () => __webpack_require__(62916),
+	"container/RemoteToExternalDependency": () =>
+		__webpack_require__(14389),
+	"dependencies/AMDDefineDependency": () =>
+		__webpack_require__(96816),
+	"dependencies/AMDRequireArrayDependency": () =>
+		__webpack_require__(33516),
+	"dependencies/AMDRequireContextDependency": () =>
+		__webpack_require__(96123),
+	"dependencies/AMDRequireDependenciesBlock": () =>
+		__webpack_require__(76932),
+	"dependencies/AMDRequireDependency": () =>
+		__webpack_require__(43911),
+	"dependencies/AMDRequireItemDependency": () =>
+		__webpack_require__(71806),
+	"dependencies/CachedConstDependency": () =>
+		__webpack_require__(57403),
+	"dependencies/CreateScriptUrlDependency": () =>
+		__webpack_require__(79062),
+	"dependencies/CommonJsRequireContextDependency": () =>
+		__webpack_require__(23962),
+	"dependencies/CommonJsExportRequireDependency": () =>
+		__webpack_require__(62892),
+	"dependencies/CommonJsExportsDependency": () =>
+		__webpack_require__(45598),
+	"dependencies/CommonJsFullRequireDependency": () =>
+		__webpack_require__(59440),
+	"dependencies/CommonJsRequireDependency": () =>
+		__webpack_require__(21264),
+	"dependencies/CommonJsSelfReferenceDependency": () =>
+		__webpack_require__(52225),
+	"dependencies/ConstDependency": () =>
+		__webpack_require__(76911),
+	"dependencies/ContextDependency": () =>
+		__webpack_require__(88101),
+	"dependencies/ContextElementDependency": () =>
+		__webpack_require__(58477),
+	"dependencies/CriticalDependencyWarning": () =>
+		__webpack_require__(15427),
+	"dependencies/CssImportDependency": () =>
+		__webpack_require__(90542),
+	"dependencies/CssLocalIdentifierDependency": () =>
+		__webpack_require__(92328),
+	"dependencies/CssSelfLocalIdentifierDependency": () =>
+		__webpack_require__(29094),
+	"dependencies/CssExportDependency": () =>
+		__webpack_require__(76760),
+	"dependencies/CssUrlDependency": () =>
+		__webpack_require__(70749),
+	"dependencies/DelegatedSourceDependency": () =>
+		__webpack_require__(22914),
+	"dependencies/DllEntryDependency": () =>
+		__webpack_require__(95666),
+	"dependencies/EntryDependency": () =>
+		__webpack_require__(3979),
+	"dependencies/ExportsInfoDependency": () =>
+		__webpack_require__(78988),
+	"dependencies/HarmonyAcceptDependency": () =>
+		__webpack_require__(23624),
+	"dependencies/HarmonyAcceptImportDependency": () =>
+		__webpack_require__(99843),
+	"dependencies/HarmonyCompatibilityDependency": () =>
+		__webpack_require__(72906),
+	"dependencies/HarmonyExportExpressionDependency": () =>
+		__webpack_require__(51340),
+	"dependencies/HarmonyExportHeaderDependency": () =>
+		__webpack_require__(38873),
+	"dependencies/HarmonyExportImportedSpecifierDependency": () =>
+		__webpack_require__(67157),
+	"dependencies/HarmonyExportSpecifierDependency": () =>
+		__webpack_require__(48567),
+	"dependencies/HarmonyImportSideEffectDependency": () =>
+		__webpack_require__(73132),
+	"dependencies/HarmonyImportSpecifierDependency": () =>
+		__webpack_require__(14077),
+	"dependencies/ImportContextDependency": () =>
+		__webpack_require__(1902),
+	"dependencies/ImportDependency": () =>
+		__webpack_require__(89376),
+	"dependencies/ImportEagerDependency": () =>
+		__webpack_require__(50718),
+	"dependencies/ImportWeakDependency": () =>
+		__webpack_require__(82483),
+	"dependencies/JsonExportsDependency": () =>
+		__webpack_require__(750),
+	"dependencies/LocalModule": () => __webpack_require__(5826),
+	"dependencies/LocalModuleDependency": () =>
+		__webpack_require__(52805),
+	"dependencies/ModuleDecoratorDependency": () =>
+		__webpack_require__(88488),
+	"dependencies/ModuleHotAcceptDependency": () =>
+		__webpack_require__(47511),
+	"dependencies/ModuleHotDeclineDependency": () =>
+		__webpack_require__(86301),
+	"dependencies/ImportMetaHotAcceptDependency": () =>
+		__webpack_require__(51274),
+	"dependencies/ImportMetaHotDeclineDependency": () =>
+		__webpack_require__(53141),
+	"dependencies/ProvidedDependency": () =>
+		__webpack_require__(95770),
+	"dependencies/PureExpressionDependency": () =>
+		__webpack_require__(55799),
+	"dependencies/RequireContextDependency": () =>
+		__webpack_require__(46917),
+	"dependencies/RequireEnsureDependenciesBlock": () =>
+		__webpack_require__(27153),
+	"dependencies/RequireEnsureDependency": () =>
+		__webpack_require__(27223),
+	"dependencies/RequireEnsureItemDependency": () =>
+		__webpack_require__(50329),
+	"dependencies/RequireHeaderDependency": () =>
+		__webpack_require__(89183),
+	"dependencies/RequireIncludeDependency": () =>
+		__webpack_require__(71284),
+	"dependencies/RequireIncludeDependencyParserPlugin": () =>
+		__webpack_require__(35768),
+	"dependencies/RequireResolveContextDependency": () =>
+		__webpack_require__(55627),
+	"dependencies/RequireResolveDependency": () =>
+		__webpack_require__(68582),
+	"dependencies/RequireResolveHeaderDependency": () =>
+		__webpack_require__(9880),
+	"dependencies/RuntimeRequirementsDependency": () =>
+		__webpack_require__(24187),
+	"dependencies/StaticExportsDependency": () =>
+		__webpack_require__(91418),
+	"dependencies/SystemPlugin": () => __webpack_require__(97981),
+	"dependencies/UnsupportedDependency": () =>
+		__webpack_require__(51669),
+	"dependencies/URLDependency": () => __webpack_require__(58612),
+	"dependencies/WebAssemblyExportImportedDependency": () =>
+		__webpack_require__(52204),
+	"dependencies/WebAssemblyImportDependency": () =>
+		__webpack_require__(5239),
+	"dependencies/WebpackIsIncludedDependency": () =>
+		__webpack_require__(26505),
+	"dependencies/WorkerDependency": () =>
+		__webpack_require__(1466),
+	"json/JsonData": () => __webpack_require__(90490),
+	"optimize/ConcatenatedModule": () =>
+		__webpack_require__(97198),
+	DelegatedModule: () => __webpack_require__(28623),
+	DependenciesBlock: () => __webpack_require__(71040),
+	DllModule: () => __webpack_require__(28280),
+	ExternalModule: () => __webpack_require__(73071),
+	FileSystemInfo: () => __webpack_require__(79453),
+	InitFragment: () => __webpack_require__(55870),
+	InvalidDependenciesModuleWarning: () =>
+		__webpack_require__(68257),
+	Module: () => __webpack_require__(73208),
+	ModuleBuildError: () => __webpack_require__(21305),
+	ModuleDependencyWarning: () => __webpack_require__(29656),
+	ModuleError: () => __webpack_require__(23744),
+	ModuleGraph: () => __webpack_require__(99988),
+	ModuleParseError: () => __webpack_require__(58443),
+	ModuleWarning: () => __webpack_require__(11234),
+	NormalModule: () => __webpack_require__(39),
+	RawDataUrlModule: () => __webpack_require__(19684),
+	RawModule: () => __webpack_require__(84929),
+	"sharing/ConsumeSharedModule": () =>
+		__webpack_require__(62286),
+	"sharing/ConsumeSharedFallbackDependency": () =>
+		__webpack_require__(58831),
+	"sharing/ProvideSharedModule": () =>
+		__webpack_require__(50821),
+	"sharing/ProvideSharedDependency": () =>
+		__webpack_require__(1798),
+	"sharing/ProvideForSharedDependency": () =>
+		__webpack_require__(40017),
+	UnsupportedFeatureWarning: () => __webpack_require__(42495),
+	"util/LazySet": () => __webpack_require__(38938),
+	UnhandledSchemeError: () => __webpack_require__(68099),
+	NodeStuffInWebError: () => __webpack_require__(6325),
+	WebpackError: () => __webpack_require__(53799),
+
+	"util/registerExternalSerializer": () => {
+		// already registered
 	}
 };
 
 
 /***/ }),
 
-/***/ 44222:
-/***/ (function(module) {
+/***/ 33032:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Maël Nison @arcanis
 */
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/**
- * @typedef {Object} PnpApiImpl
- * @property {function(string, string, object): string} resolveToUnqualified
- */
+const { register } = __webpack_require__(8282);
 
-module.exports = class PnpPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {PnpApiImpl} pnpApi pnpApi
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, pnpApi, target) {
-		this.source = source;
-		this.pnpApi = pnpApi;
-		this.target = target;
+class ClassSerializer {
+	constructor(Constructor) {
+		this.Constructor = Constructor;
 	}
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("PnpPlugin", (request, resolveContext, callback) => {
-				const req = request.request;
-				if (!req) return callback();
+	serialize(obj, context) {
+		obj.serialize(context);
+	}
 
-				// The trailing slash indicates to PnP that this value is a folder rather than a file
-				const issuer = `${request.path}/`;
+	deserialize(context) {
+		if (typeof this.Constructor.deserialize === "function") {
+			return this.Constructor.deserialize(context);
+		}
+		const obj = new this.Constructor();
+		obj.deserialize(context);
+		return obj;
+	}
+}
 
-				const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req);
-				if (!packageMatch) return callback();
+module.exports = (Constructor, request, name = null) => {
+	register(Constructor, request, name, new ClassSerializer(Constructor));
+};
 
-				const packageName = packageMatch[0];
-				const innerRequest = `.${req.slice(packageName.length)}`;
 
-				let resolution;
-				let apiResolution;
-				try {
-					resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, {
-						considerBuiltins: false
-					});
-					if (resolveContext.fileDependencies) {
-						apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, {
-							considerBuiltins: false
-						});
-					}
-				} catch (error) {
-					if (
-						error.code === "MODULE_NOT_FOUND" &&
-						error.pnpCode === "UNDECLARED_DEPENDENCY"
-					) {
-						// This is not a PnP managed dependency.
-						// Try to continue resolving with our alternatives
-						if (resolveContext.log) {
-							resolveContext.log(`request is not managed by the pnpapi`);
-							for (const line of error.message.split("\n").filter(Boolean))
-								resolveContext.log(`  ${line}`);
-						}
-						return callback();
-					}
-					return callback(error);
-				}
+/***/ }),
 
-				if (resolution === packageName) return callback();
+/***/ 78676:
+/***/ (function(module) {
 
-				if (apiResolution && resolveContext.fileDependencies) {
-					resolveContext.fileDependencies.add(apiResolution);
-				}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-				const obj = {
-					...request,
-					path: resolution,
-					request: innerRequest,
-					ignoreSymlinks: true,
-					fullySpecified: request.fullySpecified && innerRequest !== "."
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					`resolved by pnp to ${resolution}`,
-					resolveContext,
-					(err, result) => {
-						if (err) return callback(err);
-						if (result) return callback(null, result);
-						// Skip alternatives
-						return callback(null, null);
-					}
-				);
-			});
-	}
+
+
+/** @template T @typedef {function(): T} FunctionReturning */
+
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
+ */
+const memoize = fn => {
+	let cache = false;
+	/** @type {T} */
+	let result = undefined;
+	return () => {
+		if (cache) {
+			return result;
+		} else {
+			result = fn();
+			cache = true;
+			// Allow to clean up memory for fn
+			// and all dependent resources
+			fn = undefined;
+			return result;
+		}
+	};
 };
 
+module.exports = memoize;
+
 
 /***/ }),
 
-/***/ 55516:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 70002:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -135825,479 +134649,550 @@ module.exports = class PnpPlugin {
 
 
 
-const { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } = __webpack_require__(6967);
-const createInnerContext = __webpack_require__(81218);
-const { parseIdentifier } = __webpack_require__(71053);
-const {
-	normalize,
-	cachedJoin: join,
-	getType,
-	PathType
-} = __webpack_require__(67079);
+const SAFE_LIMIT = 0x80000000;
+const SAFE_PART = SAFE_LIMIT - 1;
+const COUNT = 4;
+const arr = [0, 0, 0, 0, 0];
+const primes = [3, 7, 17, 19];
 
-/** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */
+module.exports = (str, range) => {
+	arr.fill(0);
+	for (let i = 0; i < str.length; i++) {
+		const c = str.charCodeAt(i);
+		for (let j = 0; j < COUNT; j++) {
+			const p = (j + COUNT - 1) % COUNT;
+			arr[j] = (arr[j] + c * primes[j] + arr[p]) & SAFE_PART;
+		}
+		for (let j = 0; j < COUNT; j++) {
+			const q = arr[j] % COUNT;
+			arr[j] = arr[j] ^ (arr[q] >> 1);
+		}
+	}
+	if (range <= SAFE_PART) {
+		let sum = 0;
+		for (let j = 0; j < COUNT; j++) {
+			sum = (sum + arr[j]) % range;
+		}
+		return sum;
+	} else {
+		let sum1 = 0;
+		let sum2 = 0;
+		const rangeExt = Math.floor(range / SAFE_LIMIT);
+		for (let j = 0; j < COUNT; j += 2) {
+			sum1 = (sum1 + arr[j]) & SAFE_PART;
+		}
+		for (let j = 1; j < COUNT; j += 2) {
+			sum2 = (sum2 + arr[j]) % rangeExt;
+		}
+		return (sum2 * SAFE_LIMIT + sum1) % range;
+	}
+};
 
-/**
- * @typedef {Object} FileSystemStats
- * @property {function(): boolean} isDirectory
- * @property {function(): boolean} isFile
- */
 
-/**
- * @typedef {Object} FileSystemDirent
- * @property {Buffer | string} name
- * @property {function(): boolean} isDirectory
- * @property {function(): boolean} isFile
- */
+/***/ }),
 
-/**
- * @typedef {Object} PossibleFileSystemError
- * @property {string=} code
- * @property {number=} errno
- * @property {string=} path
- * @property {string=} syscall
- */
+/***/ 42791:
+/***/ (function(module) {
 
-/**
- * @template T
- * @callback FileSystemCallback
- * @param {PossibleFileSystemError & Error | null | undefined} err
- * @param {T=} result
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @typedef {Object} FileSystem
- * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readFile
- * @property {(function(string, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void) & function(string, object, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void} readdir
- * @property {((function(string, FileSystemCallback<object>): void) & function(string, object, FileSystemCallback<object>): void)=} readJson
- * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readlink
- * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void=} lstat
- * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} stat
- */
 
-/**
- * @typedef {Object} SyncFileSystem
- * @property {function(string, object=): Buffer | string} readFileSync
- * @property {function(string, object=): (Buffer | string)[] | FileSystemDirent[]} readdirSync
- * @property {(function(string, object=): object)=} readJsonSync
- * @property {function(string, object=): Buffer | string} readlinkSync
- * @property {function(string, object=): FileSystemStats=} lstatSync
- * @property {function(string, object=): FileSystemStats} statSync
- */
 
 /**
- * @typedef {Object} ParsedIdentifier
- * @property {string} request
- * @property {string} query
- * @property {string} fragment
- * @property {boolean} directory
- * @property {boolean} module
- * @property {boolean} file
- * @property {boolean} internal
+ * @template T
+ * @template {Error} E
+ * @param {Iterable<T>} items initial items
+ * @param {number} concurrency number of items running in parallel
+ * @param {function(T, function(T): void, function(E=): void): void} processor worker which pushes more items
+ * @param {function(E=): void} callback all items processed
+ * @returns {void}
  */
+const processAsyncTree = (items, concurrency, processor, callback) => {
+	const queue = Array.from(items);
+	if (queue.length === 0) return callback();
+	let processing = 0;
+	let finished = false;
+	let processScheduled = true;
 
-/**
- * @typedef {Object} BaseResolveRequest
- * @property {string | false} path
- * @property {string=} descriptionFilePath
- * @property {string=} descriptionFileRoot
- * @property {object=} descriptionFileData
- * @property {string=} relativePath
- * @property {boolean=} ignoreSymlinks
- * @property {boolean=} fullySpecified
- */
+	const push = item => {
+		queue.push(item);
+		if (!processScheduled && processing < concurrency) {
+			processScheduled = true;
+			process.nextTick(processQueue);
+		}
+	};
 
-/** @typedef {BaseResolveRequest & Partial<ParsedIdentifier>} ResolveRequest */
+	const processorCallback = err => {
+		processing--;
+		if (err && !finished) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (!processScheduled) {
+			processScheduled = true;
+			process.nextTick(processQueue);
+		}
+	};
 
-/**
- * String with special formatting
- * @typedef {string} StackEntry
- */
+	const processQueue = () => {
+		if (finished) return;
+		while (processing < concurrency && queue.length > 0) {
+			processing++;
+			const item = queue.pop();
+			processor(item, push, processorCallback);
+		}
+		processScheduled = false;
+		if (queue.length === 0 && processing === 0 && !finished) {
+			finished = true;
+			callback();
+		}
+	};
 
-/** @template T @typedef {{ add: (T) => void }} WriteOnlySet */
+	processQueue();
+};
 
-/**
- * Resolve context
- * @typedef {Object} ResolveContext
- * @property {WriteOnlySet<string>=} contextDependencies
- * @property {WriteOnlySet<string>=} fileDependencies files that was found on file system
- * @property {WriteOnlySet<string>=} missingDependencies dependencies that was not found on file system
- * @property {Set<StackEntry>=} stack set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`,
- * @property {(function(string): void)=} log log function
- */
+module.exports = processAsyncTree;
 
-/** @typedef {AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest | null>} ResolveStepHook */
 
-/**
- * @param {string} str input string
- * @returns {string} in camel case
- */
-function toCamelCase(str) {
-	return str.replace(/-([a-z])/g, str => str.substr(1).toUpperCase());
-}
+/***/ }),
 
-class Resolver {
-	/**
-	 * @param {ResolveStepHook} hook hook
-	 * @param {ResolveRequest} request request
-	 * @returns {StackEntry} stack entry
-	 */
-	static createStackEntry(hook, request) {
-		return (
-			hook.name +
-			": (" +
-			request.path +
-			") " +
-			(request.request || "") +
-			(request.query || "") +
-			(request.fragment || "") +
-			(request.directory ? " directory" : "") +
-			(request.module ? " module" : "")
-		);
-	}
+/***/ 54190:
+/***/ (function(module) {
 
-	/**
-	 * @param {FileSystem} fileSystem a filesystem
-	 * @param {ResolveOptions} options options
-	 */
-	constructor(fileSystem, options) {
-		this.fileSystem = fileSystem;
-		this.options = options;
-		this.hooks = {
-			/** @type {SyncHook<[ResolveStepHook, ResolveRequest], void>} */
-			resolveStep: new SyncHook(["hook", "request"], "resolveStep"),
-			/** @type {SyncHook<[ResolveRequest, Error]>} */
-			noResolve: new SyncHook(["request", "error"], "noResolve"),
-			/** @type {ResolveStepHook} */
-			resolve: new AsyncSeriesBailHook(
-				["request", "resolveContext"],
-				"resolve"
-			),
-			/** @type {AsyncSeriesHook<[ResolveRequest, ResolveContext]>} */
-			result: new AsyncSeriesHook(["result", "resolveContext"], "result")
-		};
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @param {string | ResolveStepHook} name hook name or hook itself
-	 * @returns {ResolveStepHook} the hook
-	 */
-	ensureHook(name) {
-		if (typeof name !== "string") {
-			return name;
-		}
-		name = toCamelCase(name);
-		if (/^before/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.ensureHook(
-				name[6].toLowerCase() + name.substr(7)
-			).withOptions({
-				stage: -10
-			}));
-		}
-		if (/^after/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.ensureHook(
-				name[5].toLowerCase() + name.substr(6)
-			).withOptions({
-				stage: 10
-			}));
-		}
-		const hook = this.hooks[name];
-		if (!hook) {
-			return (this.hooks[name] = new AsyncSeriesBailHook(
-				["request", "resolveContext"],
-				name
-			));
-		}
-		return hook;
-	}
 
-	/**
-	 * @param {string | ResolveStepHook} name hook name or hook itself
-	 * @returns {ResolveStepHook} the hook
-	 */
-	getHook(name) {
-		if (typeof name !== "string") {
-			return name;
-		}
-		name = toCamelCase(name);
-		if (/^before/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.getHook(
-				name[6].toLowerCase() + name.substr(7)
-			).withOptions({
-				stage: -10
-			}));
-		}
-		if (/^after/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.getHook(
-				name[5].toLowerCase() + name.substr(6)
-			).withOptions({
-				stage: 10
-			}));
-		}
-		const hook = this.hooks[name];
-		if (!hook) {
-			throw new Error(`Hook ${name} doesn't exist`);
-		}
-		return hook;
-	}
 
-	/**
-	 * @param {object} context context information object
-	 * @param {string} path context path
-	 * @param {string} request request string
-	 * @returns {string | false} result
-	 */
-	resolveSync(context, path, request) {
-		/** @type {Error | null | undefined} */
-		let err = undefined;
-		/** @type {string | false | undefined} */
-		let result = undefined;
-		let sync = false;
-		this.resolve(context, path, request, {}, (e, r) => {
-			err = e;
-			result = r;
-			sync = true;
-		});
-		if (!sync) {
-			throw new Error(
-				"Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!"
-			);
+const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
+const RESERVED_IDENTIFIER = new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"enum",
+	// strict mode
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield",
+	"yield",
+	// module code
+	"await",
+	// skip future reserved keywords defined under ES1 till ES3
+	// additional
+	"null",
+	"true",
+	"false"
+]);
+
+const propertyAccess = (properties, start = 0) => {
+	let str = "";
+	for (let i = start; i < properties.length; i++) {
+		const p = properties[i];
+		if (`${+p}` === p) {
+			str += `[${p}]`;
+		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
+			str += `.${p}`;
+		} else {
+			str += `[${JSON.stringify(p)}]`;
 		}
-		if (err) throw err;
-		if (result === undefined) throw new Error("No result");
-		return result;
 	}
+	return str;
+};
 
-	/**
-	 * @param {object} context context information object
-	 * @param {string} path context path
-	 * @param {string} request request string
-	 * @param {ResolveContext} resolveContext resolve context
-	 * @param {function(Error | null, (string|false)=, ResolveRequest=): void} callback callback function
-	 * @returns {void}
-	 */
-	resolve(context, path, request, resolveContext, callback) {
-		if (!context || typeof context !== "object")
-			return callback(new Error("context argument is not an object"));
-		if (typeof path !== "string")
-			return callback(new Error("path argument is not a string"));
-		if (typeof request !== "string")
-			return callback(new Error("path argument is not a string"));
-		if (!resolveContext)
-			return callback(new Error("resolveContext argument is not set"));
+module.exports = propertyAccess;
 
-		const obj = {
-			context: context,
-			path: path,
-			request: request
-		};
 
-		const message = `resolve '${request}' in '${path}'`;
+/***/ }),
 
-		const finishResolved = result => {
-			return callback(
-				null,
-				result.path === false
-					? false
-					: `${result.path.replace(/#/g, "\0#")}${
-							result.query ? result.query.replace(/#/g, "\0#") : ""
-					  }${result.fragment || ""}`,
-				result
-			);
-		};
+/***/ 26611:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
 
-		const finishWithoutResolve = log => {
-			/**
-			 * @type {Error & {details?: string}}
-			 */
-			const error = new Error("Can't " + message);
-			error.details = log.join("\n");
-			this.hooks.noResolve.call(obj, error);
-			return callback(error);
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (resolveContext.log) {
-			// We need log anyway to capture it in case of an error
-			const parentLog = resolveContext.log;
-			const log = [];
-			return this.doResolve(
-				this.hooks.resolve,
-				obj,
-				message,
-				{
-					log: msg => {
-						parentLog(msg);
-						log.push(msg);
-					},
-					fileDependencies: resolveContext.fileDependencies,
-					contextDependencies: resolveContext.contextDependencies,
-					missingDependencies: resolveContext.missingDependencies,
-					stack: resolveContext.stack
-				},
-				(err, result) => {
-					if (err) return callback(err);
 
-					if (result) return finishResolved(result);
 
-					return finishWithoutResolve(log);
-				}
-			);
-		} else {
-			// Try to resolve assuming there is no error
-			// We don't log stuff in this case
-			return this.doResolve(
-				this.hooks.resolve,
-				obj,
-				message,
-				{
-					log: undefined,
-					fileDependencies: resolveContext.fileDependencies,
-					contextDependencies: resolveContext.contextDependencies,
-					missingDependencies: resolveContext.missingDependencies,
-					stack: resolveContext.stack
-				},
-				(err, result) => {
-					if (err) return callback(err);
+const { register } = __webpack_require__(8282);
 
-					if (result) return finishResolved(result);
+const Position = /** @type {TODO} */ (__webpack_require__(31988).Position);
+const SourceLocation = (__webpack_require__(31988).SourceLocation);
+const ValidationError = (__webpack_require__(54983)/* ["default"] */ .Z);
+const {
+	CachedSource,
+	ConcatSource,
+	OriginalSource,
+	PrefixSource,
+	RawSource,
+	ReplaceSource,
+	SourceMapSource
+} = __webpack_require__(51255);
 
-					// log is missing for the error details
-					// so we redo the resolving for the log info
-					// this is more expensive to the success case
-					// is assumed by default
+/** @typedef {import("acorn").Position} Position */
+/** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
+/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
 
-					const log = [];
+/** @typedef {ObjectSerializerContext & { writeLazy?: (any) => void }} WebpackObjectSerializerContext */
 
-					return this.doResolve(
-						this.hooks.resolve,
-						obj,
-						message,
-						{
-							log: msg => log.push(msg),
-							stack: resolveContext.stack
-						},
-						(err, result) => {
-							if (err) return callback(err);
+const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 
-							return finishWithoutResolve(log);
-						}
-					);
-				}
-			);
+register(
+	CachedSource,
+	CURRENT_MODULE,
+	"webpack-sources/CachedSource",
+	new (class CachedSourceSerializer {
+		/**
+		 * @param {CachedSource} source the cached source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write, writeLazy }) {
+			if (writeLazy) {
+				writeLazy(source.originalLazy());
+			} else {
+				write(source.original());
+			}
+			write(source.getCachedData());
 		}
-	}
 
-	doResolve(hook, request, message, resolveContext, callback) {
-		const stackEntry = Resolver.createStackEntry(hook, request);
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {CachedSource} cached source
+		 */
+		deserialize({ read }) {
+			const source = read();
+			const cachedData = read();
+			return new CachedSource(source, cachedData);
+		}
+	})()
+);
 
-		let newStack;
-		if (resolveContext.stack) {
-			newStack = new Set(resolveContext.stack);
-			if (resolveContext.stack.has(stackEntry)) {
-				/**
-				 * Prevent recursion
-				 * @type {Error & {recursion?: boolean}}
-				 */
-				const recursionError = new Error(
-					"Recursion in resolving\nStack:\n  " +
-						Array.from(newStack).join("\n  ")
-				);
-				recursionError.recursion = true;
-				if (resolveContext.log)
-					resolveContext.log("abort resolving because of recursion");
-				return callback(recursionError);
-			}
-			newStack.add(stackEntry);
-		} else {
-			newStack = new Set([stackEntry]);
+register(
+	RawSource,
+	CURRENT_MODULE,
+	"webpack-sources/RawSource",
+	new (class RawSourceSerializer {
+		/**
+		 * @param {RawSource} source the raw source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.buffer());
+			write(!source.isBuffer());
 		}
-		this.hooks.resolveStep.call(hook, request);
 
-		if (hook.isUsed()) {
-			const innerContext = createInnerContext(
-				{
-					log: resolveContext.log,
-					fileDependencies: resolveContext.fileDependencies,
-					contextDependencies: resolveContext.contextDependencies,
-					missingDependencies: resolveContext.missingDependencies,
-					stack: newStack
-				},
-				message
-			);
-			return hook.callAsync(request, innerContext, (err, result) => {
-				if (err) return callback(err);
-				if (result) return callback(null, result);
-				callback();
-			});
-		} else {
-			callback();
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {RawSource} raw source
+		 */
+		deserialize({ read }) {
+			const source = read();
+			const convertToString = read();
+			return new RawSource(source, convertToString);
 		}
-	}
+	})()
+);
 
-	/**
-	 * @param {string} identifier identifier
-	 * @returns {ParsedIdentifier} parsed identifier
-	 */
-	parse(identifier) {
-		const part = {
-			request: "",
-			query: "",
-			fragment: "",
-			module: false,
-			directory: false,
-			file: false,
-			internal: false
-		};
+register(
+	ConcatSource,
+	CURRENT_MODULE,
+	"webpack-sources/ConcatSource",
+	new (class ConcatSourceSerializer {
+		/**
+		 * @param {ConcatSource} source the concat source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.getChildren());
+		}
 
-		const parsedIdentifier = parseIdentifier(identifier);
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {ConcatSource} concat source
+		 */
+		deserialize({ read }) {
+			const source = new ConcatSource();
+			source.addAllSkipOptimizing(read());
+			return source;
+		}
+	})()
+);
 
-		if (!parsedIdentifier) return part;
+register(
+	PrefixSource,
+	CURRENT_MODULE,
+	"webpack-sources/PrefixSource",
+	new (class PrefixSourceSerializer {
+		/**
+		 * @param {PrefixSource} source the prefix source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.getPrefix());
+			write(source.original());
+		}
 
-		[part.request, part.query, part.fragment] = parsedIdentifier;
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {PrefixSource} prefix source
+		 */
+		deserialize({ read }) {
+			return new PrefixSource(read(), read());
+		}
+	})()
+);
 
-		if (part.request.length > 0) {
-			part.internal = this.isPrivate(identifier);
-			part.module = this.isModule(part.request);
-			part.directory = this.isDirectory(part.request);
-			if (part.directory) {
-				part.request = part.request.substr(0, part.request.length - 1);
+register(
+	ReplaceSource,
+	CURRENT_MODULE,
+	"webpack-sources/ReplaceSource",
+	new (class ReplaceSourceSerializer {
+		/**
+		 * @param {ReplaceSource} source the replace source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.original());
+			write(source.getName());
+			const replacements = source.getReplacements();
+			write(replacements.length);
+			for (const repl of replacements) {
+				write(repl.start);
+				write(repl.end);
+			}
+			for (const repl of replacements) {
+				write(repl.content);
+				write(repl.name);
 			}
 		}
 
-		return part;
-	}
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {ReplaceSource} replace source
+		 */
+		deserialize({ read }) {
+			const source = new ReplaceSource(read(), read());
+			const len = read();
+			const startEndBuffer = [];
+			for (let i = 0; i < len; i++) {
+				startEndBuffer.push(read(), read());
+			}
+			let j = 0;
+			for (let i = 0; i < len; i++) {
+				source.replace(
+					startEndBuffer[j++],
+					startEndBuffer[j++],
+					read(),
+					read()
+				);
+			}
+			return source;
+		}
+	})()
+);
 
-	isModule(path) {
-		return getType(path) === PathType.Normal;
-	}
+register(
+	OriginalSource,
+	CURRENT_MODULE,
+	"webpack-sources/OriginalSource",
+	new (class OriginalSourceSerializer {
+		/**
+		 * @param {OriginalSource} source the original source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.buffer());
+			write(source.getName());
+		}
 
-	isPrivate(path) {
-		return getType(path) === PathType.Internal;
-	}
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {OriginalSource} original source
+		 */
+		deserialize({ read }) {
+			const buffer = read();
+			const name = read();
+			return new OriginalSource(buffer, name);
+		}
+	})()
+);
 
-	/**
-	 * @param {string} path a path
-	 * @returns {boolean} true, if the path is a directory path
-	 */
-	isDirectory(path) {
-		return path.endsWith("/");
-	}
+register(
+	SourceLocation,
+	CURRENT_MODULE,
+	"acorn/SourceLocation",
+	new (class SourceLocationSerializer {
+		/**
+		 * @param {SourceLocation} loc the location to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(loc, { write }) {
+			write(loc.start.line);
+			write(loc.start.column);
+			write(loc.end.line);
+			write(loc.end.column);
+		}
 
-	join(path, request) {
-		return join(path, request);
-	}
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {RealDependencyLocation} location
+		 */
+		deserialize({ read }) {
+			return {
+				start: {
+					line: read(),
+					column: read()
+				},
+				end: {
+					line: read(),
+					column: read()
+				}
+			};
+		}
+	})()
+);
+
+register(
+	Position,
+	CURRENT_MODULE,
+	"acorn/Position",
+	new (class PositionSerializer {
+		/**
+		 * @param {Position} pos the position to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(pos, { write }) {
+			write(pos.line);
+			write(pos.column);
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {SourcePosition} position
+		 */
+		deserialize({ read }) {
+			return {
+				line: read(),
+				column: read()
+			};
+		}
+	})()
+);
+
+register(
+	SourceMapSource,
+	CURRENT_MODULE,
+	"webpack-sources/SourceMapSource",
+	new (class SourceMapSourceSerializer {
+		/**
+		 * @param {SourceMapSource} source the source map source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.getArgsAsBuffers());
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {SourceMapSource} source source map source
+		 */
+		deserialize({ read }) {
+			// @ts-expect-error
+			return new SourceMapSource(...read());
+		}
+	})()
+);
 
-	normalize(path) {
-		return normalize(path);
-	}
-}
+register(
+	ValidationError,
+	CURRENT_MODULE,
+	"schema-utils/ValidationError",
+	new (class ValidationErrorSerializer {
+		// TODO error should be ValidationError, but this fails the type checks
+		/**
+		 * @param {TODO} error the source map source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(error, { write }) {
+			write(error.errors);
+			write(error.schema);
+			write({
+				name: error.headerName,
+				baseDataPath: error.baseDataPath,
+				postFormatter: error.postFormatter
+			});
+		}
 
-module.exports = Resolver;
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {TODO} error
+		 */
+		deserialize({ read }) {
+			return new ValidationError(read(), read(), read());
+		}
+	})()
+);
 
 
 /***/ }),
 
-/***/ 47716:
+/***/ 17156:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -136308,845 +135203,1249 @@ module.exports = Resolver;
 
 
 
-const versions = (__webpack_require__(77282).versions);
-const Resolver = __webpack_require__(55516);
-const { getType, PathType } = __webpack_require__(67079);
-
-const SyncAsyncFileSystemDecorator = __webpack_require__(87474);
-
-const AliasFieldPlugin = __webpack_require__(14819);
-const AliasPlugin = __webpack_require__(63676);
-const AppendPlugin = __webpack_require__(92088);
-const ConditionalPlugin = __webpack_require__(6953);
-const DescriptionFilePlugin = __webpack_require__(44112);
-const DirectoryExistsPlugin = __webpack_require__(60895);
-const ExportsFieldPlugin = __webpack_require__(83849);
-const FileExistsPlugin = __webpack_require__(50295);
-const ImportsFieldPlugin = __webpack_require__(7317);
-const JoinRequestPartPlugin = __webpack_require__(35949);
-const JoinRequestPlugin = __webpack_require__(5190);
-const MainFieldPlugin = __webpack_require__(47450);
-const ModulesInHierachicDirectoriesPlugin = __webpack_require__(48506);
-const ModulesInRootPlugin = __webpack_require__(88138);
-const NextPlugin = __webpack_require__(40777);
-const ParsePlugin = __webpack_require__(97849);
-const PnpPlugin = __webpack_require__(44222);
-const RestrictionsPlugin = __webpack_require__(36400);
-const ResultPlugin = __webpack_require__(13965);
-const RootsPlugin = __webpack_require__(66737);
-const SelfReferencePlugin = __webpack_require__(52232);
-const SymlinkPlugin = __webpack_require__(58885);
-const TryNextPlugin = __webpack_require__(99324);
-const UnsafeCachePlugin = __webpack_require__(41606);
-const UseFilePlugin = __webpack_require__(96972);
+const SortableSet = __webpack_require__(13098);
 
-/** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */
-/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
 
-/** @typedef {string|string[]|false} AliasOptionNewRequest */
-/** @typedef {{[k: string]: AliasOptionNewRequest}} AliasOptions */
-/** @typedef {{apply: function(Resolver): void} | function(this: Resolver, Resolver): void} Plugin */
+/** @typedef {string | SortableSet<string> | undefined} RuntimeSpec */
+/** @typedef {RuntimeSpec | boolean} RuntimeCondition */
 
 /**
- * @typedef {Object} UserResolveOptions
- * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value
- * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option
- * @property {(string | string[])[]=} aliasFields A list of alias fields in description files
- * @property {(function(ResolveRequest): boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
- * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key.
- * @property {string[]=} descriptionFiles A list of description files to read from
- * @property {string[]=} conditionNames A list of exports field condition names.
- * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used
- * @property {(string | string[])[]=} exportsFields A list of exports fields in description files
- * @property {(string | string[])[]=} importsFields A list of imports fields in description files
- * @property {string[]=} extensions A list of extensions which should be tried for files
- * @property {FileSystem} fileSystem The file system which should be used
- * @property {(object | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests
- * @property {boolean=} symlinks Resolve symlinks to their symlinked location
- * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached
- * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name
- * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files
- * @property {string[]=} mainFiles  A list of main files in directories
- * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied
- * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto"
- * @property {string[]=} roots A list of root paths
- * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it
- * @property {boolean=} resolveToContext Resolve to a context instead of a file
- * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions
- * @property {boolean=} useSyncFileSystemCalls Use only the sync constiants of the file system calls
- * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules
- * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
+ * @param {Compilation} compilation the compilation
+ * @param {string} name name of the entry
+ * @param {EntryOptions=} options optionally already received entry options
+ * @returns {RuntimeSpec} runtime
  */
+exports.getEntryRuntime = (compilation, name, options) => {
+	let dependOn;
+	let runtime;
+	if (options) {
+		({ dependOn, runtime } = options);
+	} else {
+		const entry = compilation.entries.get(name);
+		if (!entry) return name;
+		({ dependOn, runtime } = entry.options);
+	}
+	if (dependOn) {
+		/** @type {RuntimeSpec} */
+		let result = undefined;
+		const queue = new Set(dependOn);
+		for (const name of queue) {
+			const dep = compilation.entries.get(name);
+			if (!dep) continue;
+			const { dependOn, runtime } = dep.options;
+			if (dependOn) {
+				for (const name of dependOn) {
+					queue.add(name);
+				}
+			} else {
+				result = mergeRuntimeOwned(result, runtime || name);
+			}
+		}
+		return result || name;
+	} else {
+		return runtime || name;
+	}
+};
 
 /**
- * @typedef {Object} ResolveOptions
- * @property {AliasOptionEntry[]} alias
- * @property {AliasOptionEntry[]} fallback
- * @property {Set<string | string[]>} aliasFields
- * @property {(function(ResolveRequest): boolean)} cachePredicate
- * @property {boolean} cacheWithContext
- * @property {Set<string>} conditionNames A list of exports field condition names.
- * @property {string[]} descriptionFiles
- * @property {boolean} enforceExtension
- * @property {Set<string | string[]>} exportsFields
- * @property {Set<string | string[]>} importsFields
- * @property {Set<string>} extensions
- * @property {FileSystem} fileSystem
- * @property {object | false} unsafeCache
- * @property {boolean} symlinks
- * @property {Resolver=} resolver
- * @property {Array<string | string[]>} modules
- * @property {{name: string[], forceRelative: boolean}[]} mainFields
- * @property {Set<string>} mainFiles
- * @property {Plugin[]} plugins
- * @property {PnpApi | null} pnpApi
- * @property {Set<string>} roots
- * @property {boolean} fullySpecified
- * @property {boolean} resolveToContext
- * @property {Set<string|RegExp>} restrictions
- * @property {boolean} preferRelative
- * @property {boolean} preferAbsolute
+ * @param {RuntimeSpec} runtime runtime
+ * @param {function(string): void} fn functor
+ * @param {boolean} deterministicOrder enforce a deterministic order
+ * @returns {void}
+ */
+exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
+	if (runtime === undefined) {
+		fn(undefined);
+	} else if (typeof runtime === "string") {
+		fn(runtime);
+	} else {
+		if (deterministicOrder) runtime.sort();
+		for (const r of runtime) {
+			fn(r);
+		}
+	}
+};
+
+const getRuntimesKey = set => {
+	set.sort();
+	return Array.from(set).join("\n");
+};
+
+/**
+ * @param {RuntimeSpec} runtime runtime(s)
+ * @returns {string} key of runtimes
  */
+const getRuntimeKey = runtime => {
+	if (runtime === undefined) return "*";
+	if (typeof runtime === "string") return runtime;
+	return runtime.getFromUnorderedCache(getRuntimesKey);
+};
+exports.getRuntimeKey = getRuntimeKey;
 
 /**
- * @param {PnpApi | null=} option option
- * @returns {PnpApi | null} processed option
+ * @param {string} key key of runtimes
+ * @returns {RuntimeSpec} runtime(s)
  */
-function processPnpApiOption(option) {
-	if (
-		option === undefined &&
-		/** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp
+const keyToRuntime = key => {
+	if (key === "*") return undefined;
+	const items = key.split("\n");
+	if (items.length === 1) return items[0];
+	return new SortableSet(items);
+};
+exports.keyToRuntime = keyToRuntime;
+
+const getRuntimesString = set => {
+	set.sort();
+	return Array.from(set).join("+");
+};
+
+/**
+ * @param {RuntimeSpec} runtime runtime(s)
+ * @returns {string} readable version
+ */
+const runtimeToString = runtime => {
+	if (runtime === undefined) return "*";
+	if (typeof runtime === "string") return runtime;
+	return runtime.getFromUnorderedCache(getRuntimesString);
+};
+exports.runtimeToString = runtimeToString;
+
+/**
+ * @param {RuntimeCondition} runtimeCondition runtime condition
+ * @returns {string} readable version
+ */
+exports.runtimeConditionToString = runtimeCondition => {
+	if (runtimeCondition === true) return "true";
+	if (runtimeCondition === false) return "false";
+	return runtimeToString(runtimeCondition);
+};
+
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {boolean} true, when they are equal
+ */
+const runtimeEqual = (a, b) => {
+	if (a === b) {
+		return true;
+	} else if (
+		a === undefined ||
+		b === undefined ||
+		typeof a === "string" ||
+		typeof b === "string"
 	) {
-		// @ts-ignore
-		return __webpack_require__(35125); // eslint-disable-line node/no-missing-require
+		return false;
+	} else if (a.size !== b.size) {
+		return false;
+	} else {
+		a.sort();
+		b.sort();
+		const aIt = a[Symbol.iterator]();
+		const bIt = b[Symbol.iterator]();
+		for (;;) {
+			const aV = aIt.next();
+			if (aV.done) return true;
+			const bV = bIt.next();
+			if (aV.value !== bV.value) return false;
+		}
 	}
+};
+exports.runtimeEqual = runtimeEqual;
 
-	return option || null;
-}
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {-1|0|1} compare
+ */
+exports.compareRuntime = (a, b) => {
+	if (a === b) {
+		return 0;
+	} else if (a === undefined) {
+		return -1;
+	} else if (b === undefined) {
+		return 1;
+	} else {
+		const aKey = getRuntimeKey(a);
+		const bKey = getRuntimeKey(b);
+		if (aKey < bKey) return -1;
+		if (aKey > bKey) return 1;
+		return 0;
+	}
+};
 
 /**
- * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias
- * @returns {AliasOptionEntry[]} normalized aliases
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} merged
  */
-function normalizeAlias(alias) {
-	return typeof alias === "object" && !Array.isArray(alias) && alias !== null
-		? Object.keys(alias).map(key => {
-				/** @type {AliasOptionEntry} */
-				const obj = { name: key, onlyModule: false, alias: alias[key] };
+const mergeRuntime = (a, b) => {
+	if (a === undefined) {
+		return b;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return a;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			const set = new SortableSet();
+			set.add(a);
+			set.add(b);
+			return set;
+		} else if (b.has(a)) {
+			return b;
+		} else {
+			const set = new SortableSet(b);
+			set.add(a);
+			return set;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (a.has(b)) return a;
+			const set = new SortableSet(a);
+			set.add(b);
+			return set;
+		} else {
+			const set = new SortableSet(a);
+			for (const item of b) set.add(item);
+			if (set.size === a.size) return a;
+			return set;
+		}
+	}
+};
+exports.mergeRuntime = mergeRuntime;
 
-				if (/\$$/.test(key)) {
-					obj.onlyModule = true;
-					obj.name = key.substr(0, key.length - 1);
-				}
+/**
+ * @param {RuntimeCondition} a first
+ * @param {RuntimeCondition} b second
+ * @param {RuntimeSpec} runtime full runtime
+ * @returns {RuntimeCondition} result
+ */
+exports.mergeRuntimeCondition = (a, b, runtime) => {
+	if (a === false) return b;
+	if (b === false) return a;
+	if (a === true || b === true) return true;
+	const merged = mergeRuntime(a, b);
+	if (merged === undefined) return undefined;
+	if (typeof merged === "string") {
+		if (typeof runtime === "string" && merged === runtime) return true;
+		return merged;
+	}
+	if (typeof runtime === "string" || runtime === undefined) return merged;
+	if (merged.size === runtime.size) return true;
+	return merged;
+};
 
-				return obj;
-		  })
-		: /** @type {Array<AliasOptionEntry>} */ (alias) || [];
-}
+/**
+ * @param {RuntimeSpec | true} a first
+ * @param {RuntimeSpec | true} b second
+ * @param {RuntimeSpec} runtime full runtime
+ * @returns {RuntimeSpec | true} result
+ */
+exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
+	if (a === true || b === true) return true;
+	const merged = mergeRuntime(a, b);
+	if (merged === undefined) return undefined;
+	if (typeof merged === "string") {
+		if (typeof runtime === "string" && merged === runtime) return true;
+		return merged;
+	}
+	if (typeof runtime === "string" || runtime === undefined) return merged;
+	if (merged.size === runtime.size) return true;
+	return merged;
+};
 
 /**
- * @param {UserResolveOptions} options input options
- * @returns {ResolveOptions} output options
+ * @param {RuntimeSpec} a first (may be modified)
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} merged
  */
-function createOptions(options) {
-	const mainFieldsSet = new Set(options.mainFields || ["main"]);
-	const mainFields = [];
+const mergeRuntimeOwned = (a, b) => {
+	if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return a;
+	} else if (a === undefined) {
+		if (typeof b === "string") {
+			return b;
+		} else {
+			return new SortableSet(b);
+		}
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			const set = new SortableSet();
+			set.add(a);
+			set.add(b);
+			return set;
+		} else {
+			const set = new SortableSet(b);
+			set.add(a);
+			return set;
+		}
+	} else {
+		if (typeof b === "string") {
+			a.add(b);
+			return a;
+		} else {
+			for (const item of b) a.add(item);
+			return a;
+		}
+	}
+};
+exports.mergeRuntimeOwned = mergeRuntimeOwned;
 
-	for (const item of mainFieldsSet) {
-		if (typeof item === "string") {
-			mainFields.push({
-				name: [item],
-				forceRelative: true
-			});
-		} else if (Array.isArray(item)) {
-			mainFields.push({
-				name: item,
-				forceRelative: true
-			});
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} merged
+ */
+exports.intersectRuntime = (a, b) => {
+	if (a === undefined) {
+		return b;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return a;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			return undefined;
+		} else if (b.has(a)) {
+			return a;
 		} else {
-			mainFields.push({
-				name: Array.isArray(item.name) ? item.name : [item.name],
-				forceRelative: item.forceRelative
-			});
+			return undefined;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (a.has(b)) return b;
+			return undefined;
+		} else {
+			const set = new SortableSet();
+			for (const item of b) {
+				if (a.has(item)) set.add(item);
+			}
+			if (set.size === 0) return undefined;
+			if (set.size === 1) for (const item of set) return item;
+			return set;
 		}
 	}
+};
 
-	return {
-		alias: normalizeAlias(options.alias),
-		fallback: normalizeAlias(options.fallback),
-		aliasFields: new Set(options.aliasFields),
-		cachePredicate:
-			options.cachePredicate ||
-			function () {
-				return true;
-			},
-		cacheWithContext:
-			typeof options.cacheWithContext !== "undefined"
-				? options.cacheWithContext
-				: true,
-		exportsFields: new Set(options.exportsFields || ["exports"]),
-		importsFields: new Set(options.importsFields || ["imports"]),
-		conditionNames: new Set(options.conditionNames),
-		descriptionFiles: Array.from(
-			new Set(options.descriptionFiles || ["package.json"])
-		),
-		enforceExtension:
-			options.enforceExtension === undefined
-				? options.extensions && options.extensions.includes("")
-					? true
-					: false
-				: options.enforceExtension,
-		extensions: new Set(options.extensions || [".js", ".json", ".node"]),
-		fileSystem: options.useSyncFileSystemCalls
-			? new SyncAsyncFileSystemDecorator(
-					/** @type {SyncFileSystem} */ (
-						/** @type {unknown} */ (options.fileSystem)
-					)
-			  )
-			: options.fileSystem,
-		unsafeCache:
-			options.unsafeCache && typeof options.unsafeCache !== "object"
-				? {}
-				: options.unsafeCache || false,
-		symlinks: typeof options.symlinks !== "undefined" ? options.symlinks : true,
-		resolver: options.resolver,
-		modules: mergeFilteredToArray(
-			Array.isArray(options.modules)
-				? options.modules
-				: options.modules
-				? [options.modules]
-				: ["node_modules"],
-			item => {
-				const type = getType(item);
-				return type === PathType.Normal || type === PathType.Relative;
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} result
+ */
+const subtractRuntime = (a, b) => {
+	if (a === undefined) {
+		return undefined;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return undefined;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			return a;
+		} else if (b.has(a)) {
+			return undefined;
+		} else {
+			return a;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (!a.has(b)) return a;
+			if (a.size === 2) {
+				for (const item of a) {
+					if (item !== b) return item;
+				}
 			}
-		),
-		mainFields,
-		mainFiles: new Set(options.mainFiles || ["index"]),
-		plugins: options.plugins || [],
-		pnpApi: processPnpApiOption(options.pnpApi),
-		roots: new Set(options.roots || undefined),
-		fullySpecified: options.fullySpecified || false,
-		resolveToContext: options.resolveToContext || false,
-		preferRelative: options.preferRelative || false,
-		preferAbsolute: options.preferAbsolute || false,
-		restrictions: new Set(options.restrictions)
-	};
-}
+			const set = new SortableSet(a);
+			set.delete(b);
+		} else {
+			const set = new SortableSet();
+			for (const item of a) {
+				if (!b.has(item)) set.add(item);
+			}
+			if (set.size === 0) return undefined;
+			if (set.size === 1) for (const item of set) return item;
+			return set;
+		}
+	}
+};
+exports.subtractRuntime = subtractRuntime;
 
 /**
- * @param {UserResolveOptions} options resolve options
- * @returns {Resolver} created resolver
+ * @param {RuntimeCondition} a first
+ * @param {RuntimeCondition} b second
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {RuntimeCondition} result
  */
-exports.createResolver = function (options) {
-	const normalizedOptions = createOptions(options);
-
-	const {
-		alias,
-		fallback,
-		aliasFields,
-		cachePredicate,
-		cacheWithContext,
-		conditionNames,
-		descriptionFiles,
-		enforceExtension,
-		exportsFields,
-		importsFields,
-		extensions,
-		fileSystem,
-		fullySpecified,
-		mainFields,
-		mainFiles,
-		modules,
-		plugins: userPlugins,
-		pnpApi,
-		resolveToContext,
-		preferRelative,
-		preferAbsolute,
-		symlinks,
-		unsafeCache,
-		resolver: customResolver,
-		restrictions,
-		roots
-	} = normalizedOptions;
-
-	const plugins = userPlugins.slice();
-
-	const resolver = customResolver
-		? customResolver
-		: new Resolver(fileSystem, normalizedOptions);
-
-	//// pipeline ////
-
-	resolver.ensureHook("resolve");
-	resolver.ensureHook("internalResolve");
-	resolver.ensureHook("newInteralResolve");
-	resolver.ensureHook("parsedResolve");
-	resolver.ensureHook("describedResolve");
-	resolver.ensureHook("internal");
-	resolver.ensureHook("rawModule");
-	resolver.ensureHook("module");
-	resolver.ensureHook("resolveAsModule");
-	resolver.ensureHook("undescribedResolveInPackage");
-	resolver.ensureHook("resolveInPackage");
-	resolver.ensureHook("resolveInExistingDirectory");
-	resolver.ensureHook("relative");
-	resolver.ensureHook("describedRelative");
-	resolver.ensureHook("directory");
-	resolver.ensureHook("undescribedExistingDirectory");
-	resolver.ensureHook("existingDirectory");
-	resolver.ensureHook("undescribedRawFile");
-	resolver.ensureHook("rawFile");
-	resolver.ensureHook("file");
-	resolver.ensureHook("finalFile");
-	resolver.ensureHook("existingFile");
-	resolver.ensureHook("resolved");
+exports.subtractRuntimeCondition = (a, b, runtime) => {
+	if (b === true) return false;
+	if (b === false) return a;
+	if (a === false) return false;
+	const result = subtractRuntime(a === true ? runtime : a, b);
+	return result === undefined ? false : result;
+};
 
-	// resolve
-	for (const { source, resolveOptions } of [
-		{ source: "resolve", resolveOptions: { fullySpecified } },
-		{ source: "internal-resolve", resolveOptions: { fullySpecified: false } }
-	]) {
-		if (unsafeCache) {
-			plugins.push(
-				new UnsafeCachePlugin(
-					source,
-					cachePredicate,
-					unsafeCache,
-					cacheWithContext,
-					`new-${source}`
-				)
-			);
-			plugins.push(
-				new ParsePlugin(`new-${source}`, resolveOptions, "parsed-resolve")
-			);
+/**
+ * @param {RuntimeSpec} runtime runtime
+ * @param {function(RuntimeSpec): boolean} filter filter function
+ * @returns {boolean | RuntimeSpec} true/false if filter is constant for all runtimes, otherwise runtimes that are active
+ */
+exports.filterRuntime = (runtime, filter) => {
+	if (runtime === undefined) return filter(undefined);
+	if (typeof runtime === "string") return filter(runtime);
+	let some = false;
+	let every = true;
+	let result = undefined;
+	for (const r of runtime) {
+		const v = filter(r);
+		if (v) {
+			some = true;
+			result = mergeRuntimeOwned(result, r);
 		} else {
-			plugins.push(new ParsePlugin(source, resolveOptions, "parsed-resolve"));
+			every = false;
 		}
 	}
+	if (!some) return false;
+	if (every) return true;
+	return result;
+};
 
-	// parsed-resolve
-	plugins.push(
-		new DescriptionFilePlugin(
-			"parsed-resolve",
-			descriptionFiles,
-			false,
-			"described-resolve"
-		)
-	);
-	plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve"));
-
-	// described-resolve
-	plugins.push(new NextPlugin("described-resolve", "normal-resolve"));
-	if (fallback.length > 0) {
-		plugins.push(
-			new AliasPlugin("described-resolve", fallback, "internal-resolve")
-		);
+/**
+ * @template T
+ */
+class RuntimeSpecMap {
+	/**
+	 * @param {RuntimeSpecMap<T>=} clone copy form this
+	 */
+	constructor(clone) {
+		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
+		/** @type {RuntimeSpec} */
+		this._singleRuntime = clone ? clone._singleRuntime : undefined;
+		/** @type {T} */
+		this._singleValue = clone ? clone._singleValue : undefined;
+		/** @type {Map<string, T> | undefined} */
+		this._map = clone && clone._map ? new Map(clone._map) : undefined;
 	}
 
-	// normal-resolve
-	if (alias.length > 0)
-		plugins.push(new AliasPlugin("normal-resolve", alias, "internal-resolve"));
-	aliasFields.forEach(item => {
-		plugins.push(
-			new AliasFieldPlugin("normal-resolve", item, "internal-resolve")
-		);
-	});
-	if (preferRelative) {
-		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
-	}
-	plugins.push(
-		new ConditionalPlugin(
-			"after-normal-resolve",
-			{ module: true },
-			"resolve as module",
-			false,
-			"raw-module"
-		)
-	);
-	plugins.push(
-		new ConditionalPlugin(
-			"after-normal-resolve",
-			{ internal: true },
-			"resolve as internal import",
-			false,
-			"internal"
-		)
-	);
-	if (preferAbsolute) {
-		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
-	}
-	if (roots.size > 0) {
-		plugins.push(new RootsPlugin("after-normal-resolve", roots, "relative"));
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @returns {T} value
+	 */
+	get(runtime) {
+		switch (this._mode) {
+			case 0:
+				return undefined;
+			case 1:
+				return runtimeEqual(this._singleRuntime, runtime)
+					? this._singleValue
+					: undefined;
+			default:
+				return this._map.get(getRuntimeKey(runtime));
+		}
 	}
-	if (!preferRelative && !preferAbsolute) {
-		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @returns {boolean} true, when the runtime is stored
+	 */
+	has(runtime) {
+		switch (this._mode) {
+			case 0:
+				return false;
+			case 1:
+				return runtimeEqual(this._singleRuntime, runtime);
+			default:
+				return this._map.has(getRuntimeKey(runtime));
+		}
 	}
 
-	// internal
-	importsFields.forEach(importsField => {
-		plugins.push(
-			new ImportsFieldPlugin(
-				"internal",
-				conditionNames,
-				importsField,
-				"relative",
-				"internal-resolve"
-			)
-		);
-	});
+	set(runtime, value) {
+		switch (this._mode) {
+			case 0:
+				this._mode = 1;
+				this._singleRuntime = runtime;
+				this._singleValue = value;
+				break;
+			case 1:
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._singleValue = value;
+					break;
+				}
+				this._mode = 2;
+				this._map = new Map();
+				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._singleRuntime = undefined;
+				this._singleValue = undefined;
+			/* falls through */
+			default:
+				this._map.set(getRuntimeKey(runtime), value);
+		}
+	}
 
-	// raw-module
-	exportsFields.forEach(exportsField => {
-		plugins.push(
-			new SelfReferencePlugin("raw-module", exportsField, "resolve-as-module")
-		);
-	});
-	modules.forEach(item => {
-		if (Array.isArray(item)) {
-			if (item.includes("node_modules") && pnpApi) {
-				plugins.push(
-					new ModulesInHierachicDirectoriesPlugin(
-						"raw-module",
-						item.filter(i => i !== "node_modules"),
-						"module"
-					)
-				);
-				plugins.push(
-					new PnpPlugin("raw-module", pnpApi, "undescribed-resolve-in-package")
-				);
-			} else {
-				plugins.push(
-					new ModulesInHierachicDirectoriesPlugin("raw-module", item, "module")
-				);
+	provide(runtime, computer) {
+		switch (this._mode) {
+			case 0:
+				this._mode = 1;
+				this._singleRuntime = runtime;
+				return (this._singleValue = computer());
+			case 1: {
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					return this._singleValue;
+				}
+				this._mode = 2;
+				this._map = new Map();
+				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._singleRuntime = undefined;
+				this._singleValue = undefined;
+				const newValue = computer();
+				this._map.set(getRuntimeKey(runtime), newValue);
+				return newValue;
+			}
+			default: {
+				const key = getRuntimeKey(runtime);
+				const value = this._map.get(key);
+				if (value !== undefined) return value;
+				const newValue = computer();
+				this._map.set(key, newValue);
+				return newValue;
 			}
-		} else {
-			plugins.push(new ModulesInRootPlugin("raw-module", item, "module"));
 		}
-	});
-
-	// module
-	plugins.push(new JoinRequestPartPlugin("module", "resolve-as-module"));
-
-	// resolve-as-module
-	if (!resolveToContext) {
-		plugins.push(
-			new ConditionalPlugin(
-				"resolve-as-module",
-				{ directory: false, request: "." },
-				"single file module",
-				true,
-				"undescribed-raw-file"
-			)
-		);
 	}
-	plugins.push(
-		new DirectoryExistsPlugin(
-			"resolve-as-module",
-			"undescribed-resolve-in-package"
-		)
-	);
-
-	// undescribed-resolve-in-package
-	plugins.push(
-		new DescriptionFilePlugin(
-			"undescribed-resolve-in-package",
-			descriptionFiles,
-			false,
-			"resolve-in-package"
-		)
-	);
-	plugins.push(
-		new NextPlugin("after-undescribed-resolve-in-package", "resolve-in-package")
-	);
-
-	// resolve-in-package
-	exportsFields.forEach(exportsField => {
-		plugins.push(
-			new ExportsFieldPlugin(
-				"resolve-in-package",
-				conditionNames,
-				exportsField,
-				"relative"
-			)
-		);
-	});
-	plugins.push(
-		new NextPlugin("resolve-in-package", "resolve-in-existing-directory")
-	);
-
-	// resolve-in-existing-directory
-	plugins.push(
-		new JoinRequestPlugin("resolve-in-existing-directory", "relative")
-	);
-
-	// relative
-	plugins.push(
-		new DescriptionFilePlugin(
-			"relative",
-			descriptionFiles,
-			true,
-			"described-relative"
-		)
-	);
-	plugins.push(new NextPlugin("after-relative", "described-relative"));
 
-	// described-relative
-	if (resolveToContext) {
-		plugins.push(new NextPlugin("described-relative", "directory"));
-	} else {
-		plugins.push(
-			new ConditionalPlugin(
-				"described-relative",
-				{ directory: false },
-				null,
-				true,
-				"raw-file"
-			)
-		);
-		plugins.push(
-			new ConditionalPlugin(
-				"described-relative",
-				{ fullySpecified: false },
-				"as directory",
-				true,
-				"directory"
-			)
-		);
+	delete(runtime) {
+		switch (this._mode) {
+			case 0:
+				return;
+			case 1:
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._mode = 0;
+					this._singleRuntime = undefined;
+					this._singleValue = undefined;
+				}
+				return;
+			default:
+				this._map.delete(getRuntimeKey(runtime));
+		}
 	}
 
-	// directory
-	plugins.push(
-		new DirectoryExistsPlugin("directory", "undescribed-existing-directory")
-	);
-
-	if (resolveToContext) {
-		// undescribed-existing-directory
-		plugins.push(new NextPlugin("undescribed-existing-directory", "resolved"));
-	} else {
-		// undescribed-existing-directory
-		plugins.push(
-			new DescriptionFilePlugin(
-				"undescribed-existing-directory",
-				descriptionFiles,
-				false,
-				"existing-directory"
-			)
-		);
-		mainFiles.forEach(item => {
-			plugins.push(
-				new UseFilePlugin(
-					"undescribed-existing-directory",
-					item,
-					"undescribed-raw-file"
-				)
-			);
-		});
-
-		// described-existing-directory
-		mainFields.forEach(item => {
-			plugins.push(
-				new MainFieldPlugin(
-					"existing-directory",
-					item,
-					"resolve-in-existing-directory"
-				)
-			);
-		});
-		mainFiles.forEach(item => {
-			plugins.push(
-				new UseFilePlugin("existing-directory", item, "undescribed-raw-file")
-			);
-		});
-
-		// undescribed-raw-file
-		plugins.push(
-			new DescriptionFilePlugin(
-				"undescribed-raw-file",
-				descriptionFiles,
-				true,
-				"raw-file"
-			)
-		);
-		plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file"));
-
-		// raw-file
-		plugins.push(
-			new ConditionalPlugin(
-				"raw-file",
-				{ fullySpecified: true },
-				null,
-				false,
-				"file"
-			)
-		);
-		if (!enforceExtension) {
-			plugins.push(new TryNextPlugin("raw-file", "no extension", "file"));
+	update(runtime, fn) {
+		switch (this._mode) {
+			case 0:
+				throw new Error("runtime passed to update must exist");
+			case 1: {
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._singleValue = fn(this._singleValue);
+					break;
+				}
+				const newValue = fn(undefined);
+				if (newValue !== undefined) {
+					this._mode = 2;
+					this._map = new Map();
+					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+					this._singleRuntime = undefined;
+					this._singleValue = undefined;
+					this._map.set(getRuntimeKey(runtime), newValue);
+				}
+				break;
+			}
+			default: {
+				const key = getRuntimeKey(runtime);
+				const oldValue = this._map.get(key);
+				const newValue = fn(oldValue);
+				if (newValue !== oldValue) this._map.set(key, newValue);
+			}
 		}
-		extensions.forEach(item => {
-			plugins.push(new AppendPlugin("raw-file", item, "file"));
-		});
-
-		// file
-		if (alias.length > 0)
-			plugins.push(new AliasPlugin("file", alias, "internal-resolve"));
-		aliasFields.forEach(item => {
-			plugins.push(new AliasFieldPlugin("file", item, "internal-resolve"));
-		});
-		plugins.push(new NextPlugin("file", "final-file"));
+	}
 
-		// final-file
-		plugins.push(new FileExistsPlugin("final-file", "existing-file"));
+	keys() {
+		switch (this._mode) {
+			case 0:
+				return [];
+			case 1:
+				return [this._singleRuntime];
+			default:
+				return Array.from(this._map.keys(), keyToRuntime);
+		}
+	}
 
-		// existing-file
-		if (symlinks)
-			plugins.push(new SymlinkPlugin("existing-file", "existing-file"));
-		plugins.push(new NextPlugin("existing-file", "resolved"));
+	values() {
+		switch (this._mode) {
+			case 0:
+				return [][Symbol.iterator]();
+			case 1:
+				return [this._singleValue][Symbol.iterator]();
+			default:
+				return this._map.values();
+		}
 	}
 
-	// resolved
-	if (restrictions.size > 0) {
-		plugins.push(new RestrictionsPlugin(resolver.hooks.resolved, restrictions));
+	get size() {
+		if (this._mode <= 1) return this._mode;
+		return this._map.size;
 	}
-	plugins.push(new ResultPlugin(resolver.hooks.resolved));
+}
 
-	//// RESOLVER ////
+exports.RuntimeSpecMap = RuntimeSpecMap;
 
-	for (const plugin of plugins) {
-		if (typeof plugin === "function") {
-			plugin.call(resolver, resolver);
-		} else {
-			plugin.apply(resolver);
+class RuntimeSpecSet {
+	constructor(iterable) {
+		/** @type {Map<string, RuntimeSpec>} */
+		this._map = new Map();
+		if (iterable) {
+			for (const item of iterable) {
+				this.add(item);
+			}
 		}
 	}
 
-	return resolver;
-};
+	add(runtime) {
+		this._map.set(getRuntimeKey(runtime), runtime);
+	}
 
-/**
- * Merging filtered elements
- * @param {string[]} array source array
- * @param {function(string): boolean} filter predicate
- * @returns {Array<string | string[]>} merge result
- */
-function mergeFilteredToArray(array, filter) {
-	/** @type {Array<string | string[]>} */
-	const result = [];
-	const set = new Set(array);
+	has(runtime) {
+		return this._map.has(getRuntimeKey(runtime));
+	}
 
-	for (const item of set) {
-		if (filter(item)) {
-			const lastElement =
-				result.length > 0 ? result[result.length - 1] : undefined;
-			if (Array.isArray(lastElement)) {
-				lastElement.push(item);
-			} else {
-				result.push([item]);
-			}
-		} else {
-			result.push(item);
-		}
+	[Symbol.iterator]() {
+		return this._map.values();
 	}
 
-	return result;
+	get size() {
+		return this._map.size;
+	}
 }
 
+exports.RuntimeSpecSet = RuntimeSpecSet;
+
 
 /***/ }),
 
-/***/ 36400:
-/***/ (function(module) {
+/***/ 19702:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {(string|number|undefined|[])[]} SemVerRange */
 
-const slashCode = "/".charCodeAt(0);
-const backslashCode = "\\".charCodeAt(0);
+/**
+ * @param {string} str version string
+ * @returns {(string|number|undefined|[])[]} parsed version
+ */
+const parseVersion = str => {
+	var splitAndConvert = function (str) {
+		return str.split(".").map(function (item) {
+			// eslint-disable-next-line eqeqeq
+			return +item == item ? +item : item;
+		});
+	};
+	var match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
+	/** @type {(string|number|undefined|[])[]} */
+	var ver = match[1] ? splitAndConvert(match[1]) : [];
+	if (match[2]) {
+		ver.length++;
+		ver.push.apply(ver, splitAndConvert(match[2]));
+	}
+	if (match[3]) {
+		ver.push([]);
+		ver.push.apply(ver, splitAndConvert(match[3]));
+	}
+	return ver;
+};
+exports.parseVersion = parseVersion;
 
-const isInside = (path, parent) => {
-	if (!path.startsWith(parent)) return false;
-	if (path.length === parent.length) return true;
-	const charCode = path.charCodeAt(parent.length);
-	return charCode === slashCode || charCode === backslashCode;
+/* eslint-disable eqeqeq */
+/**
+ * @param {string} a version
+ * @param {string} b version
+ * @returns {boolean} true, iff a < b
+ */
+const versionLt = (a, b) => {
+	// @ts-expect-error
+	a = parseVersion(a);
+	// @ts-expect-error
+	b = parseVersion(b);
+	var i = 0;
+	for (;;) {
+		// a       b  EOA     object  undefined  number  string
+		// EOA        a == b  a < b   b < a      a < b   a < b
+		// object     b < a   (0)     b < a      a < b   a < b
+		// undefined  a < b   a < b   (0)        a < b   a < b
+		// number     b < a   b < a   b < a      (1)     a < b
+		// string     b < a   b < a   b < a      b < a   (1)
+		// EOA end of array
+		// (0) continue on
+		// (1) compare them via "<"
+
+		// Handles first row in table
+		if (i >= a.length) return i < b.length && (typeof b[i])[0] != "u";
+
+		var aValue = a[i];
+		var aType = (typeof aValue)[0];
+
+		// Handles first column in table
+		if (i >= b.length) return aType == "u";
+
+		var bValue = b[i];
+		var bType = (typeof bValue)[0];
+
+		if (aType == bType) {
+			if (aType != "o" && aType != "u" && aValue != bValue) {
+				return aValue < bValue;
+			}
+			i++;
+		} else {
+			// Handles remaining cases
+			if (aType == "o" && bType == "n") return true;
+			return bType == "s" || aType == "u";
+		}
+	}
 };
+/* eslint-enable eqeqeq */
+exports.versionLt = versionLt;
 
-module.exports = class RestrictionsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Set<string | RegExp>} restrictions restrictions
-	 */
-	constructor(source, restrictions) {
-		this.source = source;
-		this.restrictions = restrictions;
+/**
+ * @param {string} str range string
+ * @returns {SemVerRange} parsed range
+ */
+exports.parseRange = str => {
+	const splitAndConvert = str => {
+		return str.split(".").map(item => (`${+item}` === item ? +item : item));
+	};
+	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
+	const parsePartial = str => {
+		const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
+		/** @type {(string|number|undefined|[])[]} */
+		const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
+		if (match[2]) {
+			ver.length++;
+			ver.push.apply(ver, splitAndConvert(match[2]));
+		}
+
+		// remove trailing any matchers
+		let last = ver[ver.length - 1];
+		while (
+			ver.length &&
+			(last === undefined || /^[*xX]$/.test(/** @type {string} */ (last)))
+		) {
+			ver.pop();
+			last = ver[ver.length - 1];
+		}
+
+		return ver;
+	};
+	const toFixed = range => {
+		if (range.length === 1) {
+			// Special case for "*" is "x.x.x" instead of "="
+			return [0];
+		} else if (range.length === 2) {
+			// Special case for "1" is "1.x.x" instead of "=1"
+			return [1, ...range.slice(1)];
+		} else if (range.length === 3) {
+			// Special case for "1.2" is "1.2.x" instead of "=1.2"
+			return [2, ...range.slice(1)];
+		} else {
+			return [range.length, ...range.slice(1)];
+		}
+	};
+	const negate = range => {
+		return [-range[0] - 1, ...range.slice(1)];
+	};
+	const parseSimple = str => {
+		// simple     ::= primitive | partial | tilde | caret
+		// primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+		// tilde      ::= '~' partial
+		// caret      ::= '^' partial
+		const match = /^(\^|~|<=|<|>=|>|=|v|!)/.exec(str);
+		const start = match ? match[0] : "";
+		const remainder = parsePartial(str.slice(start.length));
+		switch (start) {
+			case "^":
+				if (remainder.length > 1 && remainder[1] === 0) {
+					if (remainder.length > 2 && remainder[2] === 0) {
+						return [3, ...remainder.slice(1)];
+					}
+					return [2, ...remainder.slice(1)];
+				}
+				return [1, ...remainder.slice(1)];
+			case "~":
+				return [2, ...remainder.slice(1)];
+			case ">=":
+				return remainder;
+			case "=":
+			case "v":
+			case "":
+				return toFixed(remainder);
+			case "<":
+				return negate(remainder);
+			case ">": {
+				// and( >=, not( = ) ) => >=, =, not, and
+				const fixed = toFixed(remainder);
+				// eslint-disable-next-line no-sparse-arrays
+				return [, fixed, 0, remainder, 2];
+			}
+			case "<=":
+				// or( <, = ) => <, =, or
+				// eslint-disable-next-line no-sparse-arrays
+				return [, toFixed(remainder), negate(remainder), 1];
+			case "!": {
+				// not =
+				const fixed = toFixed(remainder);
+				// eslint-disable-next-line no-sparse-arrays
+				return [, fixed, 0];
+			}
+			default:
+				throw new Error("Unexpected start value");
+		}
+	};
+	const combine = (items, fn) => {
+		if (items.length === 1) return items[0];
+		const arr = [];
+		for (const item of items.slice().reverse()) {
+			if (0 in item) {
+				arr.push(item);
+			} else {
+				arr.push(...item.slice(1));
+			}
+		}
+		// eslint-disable-next-line no-sparse-arrays
+		return [, ...arr, ...items.slice(1).map(() => fn)];
+	};
+	const parseRange = str => {
+		// range      ::= hyphen | simple ( ' ' simple ) * | ''
+		// hyphen     ::= partial ' - ' partial
+		const items = str.split(" - ");
+		if (items.length === 1) {
+			const items = str.trim().split(/\s+/g).map(parseSimple);
+			return combine(items, 2);
+		}
+		const a = parsePartial(items[0]);
+		const b = parsePartial(items[1]);
+		// >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
+		// eslint-disable-next-line no-sparse-arrays
+		return [, toFixed(b), negate(b), 1, a, 2];
+	};
+	const parseLogicalOr = str => {
+		// range-set  ::= range ( logical-or range ) *
+		// logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+		const items = str.split(/\s*\|\|\s*/).map(parseRange);
+		return combine(items, 1);
+	};
+	return parseLogicalOr(str);
+};
+
+/* eslint-disable eqeqeq */
+const rangeToString = range => {
+	var fixCount = range[0];
+	var str = "";
+	if (range.length === 1) {
+		return "*";
+	} else if (fixCount + 0.5) {
+		str +=
+			fixCount == 0
+				? ">="
+				: fixCount == -1
+				? "<"
+				: fixCount == 1
+				? "^"
+				: fixCount == 2
+				? "~"
+				: fixCount > 0
+				? "="
+				: "!=";
+		var needDot = 1;
+		// eslint-disable-next-line no-redeclare
+		for (var i = 1; i < range.length; i++) {
+			var item = range[i];
+			var t = (typeof item)[0];
+			needDot--;
+			str +=
+				t == "u"
+					? // undefined: prerelease marker, add an "-"
+					  "-"
+					: // number or string: add the item, set flag to add an "." between two of them
+					  (needDot > 0 ? "." : "") + ((needDot = 2), item);
+		}
+		return str;
+	} else {
+		var stack = [];
+		// eslint-disable-next-line no-redeclare
+		for (var i = 1; i < range.length; i++) {
+			// eslint-disable-next-line no-redeclare
+			var item = range[i];
+			stack.push(
+				item === 0
+					? "not(" + pop() + ")"
+					: item === 1
+					? "(" + pop() + " || " + pop() + ")"
+					: item === 2
+					? stack.pop() + " " + stack.pop()
+					: rangeToString(item)
+			);
+		}
+		return pop();
+	}
+	function pop() {
+		return stack.pop().replace(/^\((.+)\)$/, "$1");
 	}
+};
+/* eslint-enable eqeqeq */
+exports.rangeToString = rangeToString;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		resolver
-			.getHook(this.source)
-			.tapAsync("RestrictionsPlugin", (request, resolveContext, callback) => {
-				if (typeof request.path === "string") {
-					const path = request.path;
-					for (const rule of this.restrictions) {
-						if (typeof rule === "string") {
-							if (!isInside(path, rule)) {
-								if (resolveContext.log) {
-									resolveContext.log(
-										`${path} is not inside of the restriction ${rule}`
-									);
-								}
-								return callback(null, null);
-							}
-						} else if (!rule.test(path)) {
-							if (resolveContext.log) {
-								resolveContext.log(
-									`${path} doesn't match the restriction ${rule}`
-								);
-							}
-							return callback(null, null);
+/* eslint-disable eqeqeq */
+/**
+ * @param {SemVerRange} range version range
+ * @param {string} version the version
+ * @returns {boolean} if version satisfy the range
+ */
+const satisfy = (range, version) => {
+	if (0 in range) {
+		// @ts-expect-error
+		version = parseVersion(version);
+		var fixCount = range[0];
+		// when negated is set it swill set for < instead of >=
+		var negated = fixCount < 0;
+		if (negated) fixCount = -fixCount - 1;
+		for (var i = 0, j = 1, isEqual = true; ; j++, i++) {
+			// cspell:word nequal nequ
+
+			// when isEqual = true:
+			// range         version: EOA/object  undefined  number    string
+			// EOA                    equal       block      big-ver   big-ver
+			// undefined              bigger      next       big-ver   big-ver
+			// number                 smaller     block      cmp       big-cmp
+			// fixed number           smaller     block      cmp-fix   differ
+			// string                 smaller     block      differ    cmp
+			// fixed string           smaller     block      small-cmp cmp-fix
+
+			// when isEqual = false:
+			// range         version: EOA/object  undefined  number    string
+			// EOA                    nequal      block      next-ver  next-ver
+			// undefined              nequal      block      next-ver  next-ver
+			// number                 nequal      block      next      next
+			// fixed number           nequal      block      next      next   (this never happens)
+			// string                 nequal      block      next      next
+			// fixed string           nequal      block      next      next   (this never happens)
+
+			// EOA end of array
+			// equal (version is equal range):
+			//   when !negated: return true,
+			//   when negated: return false
+			// bigger (version is bigger as range):
+			//   when fixed: return false,
+			//   when !negated: return true,
+			//   when negated: return false,
+			// smaller (version is smaller as range):
+			//   when !negated: return false,
+			//   when negated: return true
+			// nequal (version is not equal range (> resp <)): return true
+			// block (version is in different prerelease area): return false
+			// differ (version is different from fixed range (string vs. number)): return false
+			// next: continues to the next items
+			// next-ver: when fixed: return false, continues to the next item only for the version, sets isEqual=false
+			// big-ver: when fixed || negated: return false, continues to the next item only for the version, sets isEqual=false
+			// next-nequ: continues to the next items, sets isEqual=false
+			// cmp (negated === false): version < range => return false, version > range => next-nequ, else => next
+			// cmp (negated === true): version > range => return false, version < range => next-nequ, else => next
+			// cmp-fix: version == range => next, else => return false
+			// big-cmp: when negated => return false, else => next-nequ
+			// small-cmp: when negated => next-nequ, else => return false
+
+			var rangeType = j < range.length ? (typeof range[j])[0] : "";
+
+			var versionValue;
+			var versionType;
+
+			// Handles first column in both tables (end of version or object)
+			if (
+				i >= version.length ||
+				((versionValue = version[i]),
+				(versionType = (typeof versionValue)[0]) == "o")
+			) {
+				// Handles nequal
+				if (!isEqual) return true;
+				// Handles bigger
+				if (rangeType == "u") return j > fixCount && !negated;
+				// Handles equal and smaller: (range === EOA) XOR negated
+				return (rangeType == "") != negated; // equal + smaller
+			}
+
+			// Handles second column in both tables (version = undefined)
+			if (versionType == "u") {
+				if (!isEqual || rangeType != "u") {
+					return false;
+				}
+			}
+
+			// switch between first and second table
+			else if (isEqual) {
+				// Handle diagonal
+				if (rangeType == versionType) {
+					if (j <= fixCount) {
+						// Handles "cmp-fix" cases
+						if (versionValue != range[j]) {
+							return false;
 						}
+					} else {
+						// Handles "cmp" cases
+						if (negated ? versionValue > range[j] : versionValue < range[j]) {
+							return false;
+						}
+						if (versionValue != range[j]) isEqual = false;
 					}
 				}
 
-				callback();
-			});
-	}
-};
-
-
-/***/ }),
-
-/***/ 13965:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+				// Handle big-ver
+				else if (rangeType != "s" && rangeType != "n") {
+					if (negated || j <= fixCount) return false;
+					isEqual = false;
+					j--;
+				}
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+				// Handle differ, big-cmp and small-cmp
+				else if (j <= fixCount || versionType < rangeType != negated) {
+					return false;
+				} else {
+					isEqual = false;
+				}
+			} else {
+				// Handles all "next-ver" cases in the second table
+				if (rangeType != "s" && rangeType != "n") {
+					isEqual = false;
+					j--;
+				}
 
-module.exports = class ResultPlugin {
-	/**
-	 * @param {ResolveStepHook} source source
-	 */
-	constructor(source) {
-		this.source = source;
+				// next is applied by default
+			}
+		}
+	}
+	/** @type {(boolean | number)[]} */
+	var stack = [];
+	var p = stack.pop.bind(stack);
+	// eslint-disable-next-line no-redeclare
+	for (var i = 1; i < range.length; i++) {
+		var item = /** @type {SemVerRange | 0 | 1 | 2} */ (range[i]);
+		stack.push(
+			item == 1
+				? p() | p()
+				: item == 2
+				? p() & p()
+				: item
+				? satisfy(item, version)
+				: !p()
+		);
 	}
+	return !!p();
+};
+/* eslint-enable eqeqeq */
+exports.satisfy = satisfy;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		this.source.tapAsync(
-			"ResultPlugin",
-			(request, resolverContext, callback) => {
-				const obj = { ...request };
-				if (resolverContext.log)
-					resolverContext.log("reporting result " + obj.path);
-				resolver.hooks.result.callAsync(obj, resolverContext, err => {
-					if (err) return callback(err);
-					callback(null, obj);
-				});
+exports.stringifyHoley = json => {
+	switch (typeof json) {
+		case "undefined":
+			return "";
+		case "object":
+			if (Array.isArray(json)) {
+				let str = "[";
+				for (let i = 0; i < json.length; i++) {
+					if (i !== 0) str += ",";
+					str += this.stringifyHoley(json[i]);
+				}
+				str += "]";
+				return str;
+			} else {
+				return JSON.stringify(json);
 			}
-		);
+		default:
+			return JSON.stringify(json);
 	}
 };
 
+//#region runtime code: parseVersion
+exports.parseVersionRuntimeCode = runtimeTemplate =>
+	`var parseVersion = ${runtimeTemplate.basicFunction("str", [
+		"// see webpack/lib/util/semver.js for original code",
+		`var p=${
+			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
+		}{return p.split(".").map((${
+			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
+		}{return+p==p?+p:p}))},n=/^([^-+]+)?(?:-([^+]+))?(?:\\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;`
+	])}`;
+//#endregion
+
+//#region runtime code: versionLt
+exports.versionLtRuntimeCode = runtimeTemplate =>
+	`var versionLt = ${runtimeTemplate.basicFunction("a, b", [
+		"// see webpack/lib/util/semver.js for original code",
+		'a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}'
+	])}`;
+//#endregion
+
+//#region runtime code: rangeToString
+exports.rangeToStringRuntimeCode = runtimeTemplate =>
+	`var rangeToString = ${runtimeTemplate.basicFunction("range", [
+		"// see webpack/lib/util/semver.js for original code",
+		'var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\\((.+)\\)$/,"$1")}'
+	])}`;
+//#endregion
+
+//#region runtime code: satisfy
+exports.satisfyRuntimeCode = runtimeTemplate =>
+	`var satisfy = ${runtimeTemplate.basicFunction("range, version", [
+		"// see webpack/lib/util/semver.js for original code",
+		'if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1;a=!1}else"s"!=g&&"n"!=g&&(a=!1,i--)}}var t=[],o=t.pop.bind(t);for(n=1;n<range.length;n++){var u=range[n];t.push(1==u?o()|o():2==u?o()&o():u?satisfy(u,version):!o())}return!!o();'
+	])}`;
+//#endregion
+
 
 /***/ }),
 
-/***/ 66737:
+/***/ 8282:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
 */
 
 
 
-const forEachBail = __webpack_require__(78565);
+const memoize = __webpack_require__(78676);
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
+/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/Serializer")} Serializer */
 
-class RootsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source hook
-	 * @param {Set<string>} roots roots
-	 * @param {string | ResolveStepHook} target target hook
-	 */
-	constructor(source, roots, target) {
-		this.roots = Array.from(roots);
-		this.source = source;
-		this.target = target;
-	}
+const getBinaryMiddleware = memoize(() =>
+	__webpack_require__(97059)
+);
+const getObjectMiddleware = memoize(() =>
+	__webpack_require__(34795)
+);
+const getSingleItemMiddleware = memoize(() =>
+	__webpack_require__(65112)
+);
+const getSerializer = memoize(() => __webpack_require__(53080));
+const getSerializerMiddleware = memoize(() =>
+	__webpack_require__(83137)
+);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
+const getBinaryMiddlewareInstance = memoize(
+	() => new (getBinaryMiddleware())()
+);
 
-		resolver
-			.getHook(this.source)
-			.tapAsync("RootsPlugin", (request, resolveContext, callback) => {
-				const req = request.request;
-				if (!req) return callback();
-				if (!req.startsWith("/")) return callback();
+const registerSerializers = memoize(() => {
+	__webpack_require__(26611);
 
-				forEachBail(
-					this.roots,
-					(root, callback) => {
-						const path = resolver.join(root, req.slice(1));
-						const obj = {
-							...request,
-							path,
-							relativePath: request.relativePath && path
-						};
-						resolver.doResolve(
-							target,
-							obj,
-							`root path ${root}`,
-							resolveContext,
-							callback
+	// Load internal paths with a relative require
+	// This allows bundling all internal serializers
+	const internalSerializables = __webpack_require__(53023);
+	getObjectMiddleware().registerLoader(/^webpack\/lib\//, req => {
+		const loader = internalSerializables[req.slice("webpack/lib/".length)];
+		if (loader) {
+			loader();
+		} else {
+			console.warn(`${req} not found in internalSerializables`);
+		}
+		return true;
+	});
+});
+
+/** @type {Serializer} */
+let buffersSerializer;
+
+// Expose serialization API
+module.exports = {
+	get register() {
+		return getObjectMiddleware().register;
+	},
+	get registerLoader() {
+		return getObjectMiddleware().registerLoader;
+	},
+	get registerNotSerializable() {
+		return getObjectMiddleware().registerNotSerializable;
+	},
+	get NOT_SERIALIZABLE() {
+		return getObjectMiddleware().NOT_SERIALIZABLE;
+	},
+	/** @type {MEASURE_START_OPERATION} */
+	get MEASURE_START_OPERATION() {
+		return getBinaryMiddleware().MEASURE_START_OPERATION;
+	},
+	/** @type {MEASURE_END_OPERATION} */
+	get MEASURE_END_OPERATION() {
+		return getBinaryMiddleware().MEASURE_END_OPERATION;
+	},
+	get buffersSerializer() {
+		if (buffersSerializer !== undefined) return buffersSerializer;
+		registerSerializers();
+		const Serializer = getSerializer();
+		const binaryMiddleware = getBinaryMiddlewareInstance();
+		const SerializerMiddleware = getSerializerMiddleware();
+		const SingleItemMiddleware = getSingleItemMiddleware();
+		return (buffersSerializer = new Serializer([
+			new SingleItemMiddleware(),
+			new (getObjectMiddleware())(context => {
+				if (context.write) {
+					context.writeLazy = value => {
+						context.write(
+							SerializerMiddleware.createLazy(value, binaryMiddleware)
 						);
-					},
-					callback
-				);
-			});
+					};
+				}
+			}, "md4"),
+			binaryMiddleware
+		]));
+	},
+	createFileSerializer: (fs, hashFunction) => {
+		registerSerializers();
+		const Serializer = getSerializer();
+		const FileMiddleware = __webpack_require__(65321);
+		const fileMiddleware = new FileMiddleware(fs, hashFunction);
+		const binaryMiddleware = getBinaryMiddlewareInstance();
+		const SerializerMiddleware = getSerializerMiddleware();
+		const SingleItemMiddleware = getSingleItemMiddleware();
+		return new Serializer([
+			new SingleItemMiddleware(),
+			new (getObjectMiddleware())(context => {
+				if (context.write) {
+					context.writeLazy = value => {
+						context.write(
+							SerializerMiddleware.createLazy(value, binaryMiddleware)
+						);
+					};
+					context.writeSeparate = (value, options) => {
+						const lazy = SerializerMiddleware.createLazy(
+							value,
+							fileMiddleware,
+							options
+						);
+						context.write(lazy);
+						return lazy;
+					};
+				}
+			}, hashFunction),
+			binaryMiddleware,
+			fileMiddleware
+		]);
 	}
-}
-
-module.exports = RootsPlugin;
+};
 
 
 /***/ }),
 
-/***/ 52232:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 15652:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -137156,181 +136455,211 @@ module.exports = RootsPlugin;
 
 
 
-const DescriptionFileUtils = __webpack_require__(25424);
+/**
+ * @typedef {Object} GroupOptions
+ * @property {boolean=} groupChildren
+ * @property {boolean=} force
+ * @property {number=} targetGroupCount
+ */
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/**
+ * @template T
+ * @template R
+ * @typedef {Object} GroupConfig
+ * @property {function(T): string[]} getKeys
+ * @property {function(string, (R | T)[], T[]): R} createGroup
+ * @property {function(string, T[]): GroupOptions=} getOptions
+ */
 
-const slashCode = "/".charCodeAt(0);
+/**
+ * @template T
+ * @template R
+ * @typedef {Object} ItemWithGroups
+ * @property {T} item
+ * @property {Set<Group<T, R>>} groups
+ */
 
-module.exports = class SelfReferencePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | string[]} fieldNamePath name path
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, fieldNamePath, target) {
-		this.source = source;
-		this.target = target;
-		this.fieldName = fieldNamePath;
-	}
+/**
+ * @template T
+ * @template R
+ * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
+ */
 
+/**
+ * @template T
+ * @template R
+ * @param {T[]} items the list of items
+ * @param {GroupConfig<T, R>[]} groupConfigs configuration
+ * @returns {(R | T)[]} grouped items
+ */
+const smartGrouping = (items, groupConfigs) => {
+	/** @type {Set<ItemWithGroups<T, R>>} */
+	const itemsWithGroups = new Set();
+	/** @type {Map<string, Group<T, R>>} */
+	const allGroups = new Map();
+	for (const item of items) {
+		/** @type {Set<Group<T, R>>} */
+		const groups = new Set();
+		for (let i = 0; i < groupConfigs.length; i++) {
+			const groupConfig = groupConfigs[i];
+			const keys = groupConfig.getKeys(item);
+			if (keys) {
+				for (const name of keys) {
+					const key = `${i}:${name}`;
+					let group = allGroups.get(key);
+					if (group === undefined) {
+						allGroups.set(
+							key,
+							(group = {
+								config: groupConfig,
+								name,
+								alreadyGrouped: false,
+								items: undefined
+							})
+						);
+					}
+					groups.add(group);
+				}
+			}
+		}
+		itemsWithGroups.add({
+			item,
+			groups
+		});
+	}
 	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
+	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
+	 * @returns {(T | R)[]} groups items
 	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("SelfReferencePlugin", (request, resolveContext, callback) => {
-				if (!request.descriptionFilePath) return callback();
-
-				const req = request.request;
-				if (!req) return callback();
-
-				// Feature is only enabled when an exports field is present
-				const exportsField = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.fieldName
-				);
-				if (!exportsField) return callback();
-
-				const name = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					"name"
-				);
-				if (typeof name !== "string") return callback();
+	const runGrouping = itemsWithGroups => {
+		const totalSize = itemsWithGroups.size;
+		for (const entry of itemsWithGroups) {
+			for (const group of entry.groups) {
+				if (group.alreadyGrouped) continue;
+				const items = group.items;
+				if (items === undefined) {
+					group.items = new Set([entry]);
+				} else {
+					items.add(entry);
+				}
+			}
+		}
+		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
+		const groupMap = new Map();
+		for (const group of allGroups.values()) {
+			if (group.items) {
+				const items = group.items;
+				group.items = undefined;
+				groupMap.set(group, {
+					items,
+					options: undefined,
+					used: false
+				});
+			}
+		}
+		/** @type {(T | R)[]} */
+		const results = [];
+		for (;;) {
+			/** @type {Group<T, R>} */
+			let bestGroup = undefined;
+			let bestGroupSize = -1;
+			let bestGroupItems = undefined;
+			let bestGroupOptions = undefined;
+			for (const [group, state] of groupMap) {
+				const { items, used } = state;
+				let options = state.options;
+				if (options === undefined) {
+					const groupConfig = group.config;
+					state.options = options =
+						(groupConfig.getOptions &&
+							groupConfig.getOptions(
+								group.name,
+								Array.from(items, ({ item }) => item)
+							)) ||
+						false;
+				}
 
+				const force = options && options.force;
+				if (!force) {
+					if (bestGroupOptions && bestGroupOptions.force) continue;
+					if (used) continue;
+					if (items.size <= 1 || totalSize - items.size <= 1) {
+						continue;
+					}
+				}
+				const targetGroupCount = (options && options.targetGroupCount) || 4;
+				let sizeValue = force
+					? items.size
+					: Math.min(
+							items.size,
+							(totalSize * 2) / targetGroupCount +
+								itemsWithGroups.size -
+								items.size
+					  );
 				if (
-					req.startsWith(name) &&
-					(req.length === name.length ||
-						req.charCodeAt(name.length) === slashCode)
-				) {
-					const remainingRequest = `.${req.slice(name.length)}`;
-
-					const obj = {
-						...request,
-						request: remainingRequest,
-						path: /** @type {string} */ (request.descriptionFileRoot),
-						relativePath: "."
-					};
-
-					resolver.doResolve(
-						target,
-						obj,
-						"self reference",
-						resolveContext,
-						callback
-					);
-				} else {
-					return callback();
+					sizeValue > bestGroupSize ||
+					(force && (!bestGroupOptions || !bestGroupOptions.force))
+				) {
+					bestGroup = group;
+					bestGroupSize = sizeValue;
+					bestGroupItems = items;
+					bestGroupOptions = options;
 				}
-			});
-	}
-};
-
-
-/***/ }),
-
-/***/ 58885:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+			}
+			if (bestGroup === undefined) {
+				break;
+			}
+			const items = new Set(bestGroupItems);
+			const options = bestGroupOptions;
 
+			const groupChildren = !options || options.groupChildren !== false;
 
-const forEachBail = __webpack_require__(78565);
-const getPaths = __webpack_require__(82918);
-const { getType, PathType } = __webpack_require__(67079);
+			for (const item of items) {
+				itemsWithGroups.delete(item);
+				// Remove all groups that items have from the map to not select them again
+				for (const group of item.groups) {
+					const state = groupMap.get(group);
+					if (state !== undefined) {
+						state.items.delete(item);
+						if (state.items.size === 0) {
+							groupMap.delete(group);
+						} else {
+							state.options = undefined;
+							if (groupChildren) {
+								state.used = true;
+							}
+						}
+					}
+				}
+			}
+			groupMap.delete(bestGroup);
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+			const key = bestGroup.name;
+			const groupConfig = bestGroup.config;
 
-module.exports = class SymlinkPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+			const allItems = Array.from(items, ({ item }) => item);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		const fs = resolver.fileSystem;
-		resolver
-			.getHook(this.source)
-			.tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
-				if (request.ignoreSymlinks) return callback();
-				const pathsResult = getPaths(request.path);
-				const pathSeqments = pathsResult.seqments;
-				const paths = pathsResult.paths;
+			bestGroup.alreadyGrouped = true;
+			const children = groupChildren ? runGrouping(items) : allItems;
+			bestGroup.alreadyGrouped = false;
 
-				let containsSymlink = false;
-				let idx = -1;
-				forEachBail(
-					paths,
-					(path, callback) => {
-						idx++;
-						if (resolveContext.fileDependencies)
-							resolveContext.fileDependencies.add(path);
-						fs.readlink(path, (err, result) => {
-							if (!err && result) {
-								pathSeqments[idx] = result;
-								containsSymlink = true;
-								// Shortcut when absolute symlink found
-								const resultType = getType(result.toString());
-								if (
-									resultType === PathType.AbsoluteWin ||
-									resultType === PathType.AbsolutePosix
-								) {
-									return callback(null, idx);
-								}
-							}
-							callback();
-						});
-					},
-					(err, idx) => {
-						if (!containsSymlink) return callback();
-						const resultSeqments =
-							typeof idx === "number"
-								? pathSeqments.slice(0, idx + 1)
-								: pathSeqments.slice();
-						const result = resultSeqments.reduceRight((a, b) => {
-							return resolver.join(a, b);
-						});
-						const obj = {
-							...request,
-							path: result
-						};
-						resolver.doResolve(
-							target,
-							obj,
-							"resolved symlink to " + result,
-							resolveContext,
-							callback
-						);
-					}
-				);
-			});
-	}
+			results.push(groupConfig.createGroup(key, children, allItems));
+		}
+		for (const { item } of itemsWithGroups) {
+			results.push(item);
+		}
+		return results;
+	};
+	return runGrouping(itemsWithGroups);
 };
 
+module.exports = smartGrouping;
+
 
 /***/ }),
 
-/***/ 87474:
-/***/ (function(module) {
+/***/ 41245:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -137340,100 +136669,66 @@ module.exports = class SymlinkPlugin {
 
 
 
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+/** @typedef {import("webpack-sources").Source} Source */
+
+/** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
+const equalityCache = new WeakMap();
 
 /**
- * @param {SyncFileSystem} fs file system implementation
- * @constructor
+ * @param {Source} a a source
+ * @param {Source} b another source
+ * @returns {boolean} true, when both sources are equal
  */
-function SyncAsyncFileSystemDecorator(fs) {
-	this.fs = fs;
+const _isSourceEqual = (a, b) => {
+	// prefer .buffer(), it's called anyway during emit
+	/** @type {Buffer|string} */
+	let aSource = typeof a.buffer === "function" ? a.buffer() : a.source();
+	/** @type {Buffer|string} */
+	let bSource = typeof b.buffer === "function" ? b.buffer() : b.source();
+	if (aSource === bSource) return true;
+	if (typeof aSource === "string" && typeof bSource === "string") return false;
+	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf-8");
+	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf-8");
+	return aSource.equals(bSource);
+};
 
-	this.lstat = undefined;
-	this.lstatSync = undefined;
-	const lstatSync = fs.lstatSync;
-	if (lstatSync) {
-		this.lstat = (arg, options, callback) => {
-			let result;
-			try {
-				result = lstatSync.call(fs, arg);
-			} catch (e) {
-				return (callback || options)(e);
-			}
-			(callback || options)(null, result);
-		};
-		this.lstatSync = (arg, options) => lstatSync.call(fs, arg, options);
+/**
+ * @param {Source} a a source
+ * @param {Source} b another source
+ * @returns {boolean} true, when both sources are equal
+ */
+const isSourceEqual = (a, b) => {
+	if (a === b) return true;
+	const cache1 = equalityCache.get(a);
+	if (cache1 !== undefined) {
+		const result = cache1.get(b);
+		if (result !== undefined) return result;
 	}
-
-	this.stat = (arg, options, callback) => {
-		let result;
-		try {
-			result = callback ? fs.statSync(arg, options) : fs.statSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.statSync = (arg, options) => fs.statSync(arg, options);
-
-	this.readdir = (arg, options, callback) => {
-		let result;
-		try {
-			result = fs.readdirSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.readdirSync = (arg, options) => fs.readdirSync(arg, options);
-
-	this.readFile = (arg, options, callback) => {
-		let result;
-		try {
-			result = fs.readFileSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.readFileSync = (arg, options) => fs.readFileSync(arg, options);
-
-	this.readlink = (arg, options, callback) => {
-		let result;
-		try {
-			result = fs.readlinkSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.readlinkSync = (arg, options) => fs.readlinkSync(arg, options);
-
-	this.readJson = undefined;
-	this.readJsonSync = undefined;
-	const readJsonSync = fs.readJsonSync;
-	if (readJsonSync) {
-		this.readJson = (arg, options, callback) => {
-			let result;
-			try {
-				result = readJsonSync.call(fs, arg);
-			} catch (e) {
-				return (callback || options)(e);
-			}
-			(callback || options)(null, result);
-		};
-
-		this.readJsonSync = (arg, options) => readJsonSync.call(fs, arg, options);
+	const result = _isSourceEqual(a, b);
+	if (cache1 !== undefined) {
+		cache1.set(b, result);
+	} else {
+		const map = new WeakMap();
+		map.set(b, result);
+		equalityCache.set(a, map);
 	}
-}
-module.exports = SyncAsyncFileSystemDecorator;
+	const cache2 = equalityCache.get(b);
+	if (cache2 !== undefined) {
+		cache2.set(a, result);
+	} else {
+		const map = new WeakMap();
+		map.set(a, result);
+		equalityCache.set(b, map);
+	}
+	return result;
+};
+exports.isSourceEqual = isSourceEqual;
 
 
 /***/ }),
 
-/***/ 99324:
-/***/ (function(module) {
+/***/ 12047:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -137443,121 +136738,180 @@ module.exports = SyncAsyncFileSystemDecorator;
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-
-module.exports = class TryNextPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} message message
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, message, target) {
-		this.source = source;
-		this.message = message;
-		this.target = target;
-	}
+const { validate } = __webpack_require__(38476);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("TryNextPlugin", (request, resolveContext, callback) => {
-				resolver.doResolve(
-					target,
-					request,
-					this.message,
-					resolveContext,
-					callback
-				);
-			});
-	}
+/* cSpell:disable */
+const DID_YOU_MEAN = {
+	rules: "module.rules",
+	loaders: "module.rules or module.rules.*.use",
+	query: "module.rules.*.options (BREAKING CHANGE since webpack 5)",
+	noParse: "module.noParse",
+	filename: "output.filename or module.rules.*.generator.filename",
+	file: "output.filename",
+	chunkFilename: "output.chunkFilename",
+	chunkfilename: "output.chunkFilename",
+	ecmaVersion:
+		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	ecmaversion:
+		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	ecma: "output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	path: "output.path",
+	pathinfo: "output.pathinfo",
+	pathInfo: "output.pathinfo",
+	jsonpFunction: "output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
+	chunkCallbackName:
+		"output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
+	jsonpScriptType: "output.scriptType (BREAKING CHANGE since webpack 5)",
+	hotUpdateFunction: "output.hotUpdateGlobal (BREAKING CHANGE since webpack 5)",
+	splitChunks: "optimization.splitChunks",
+	immutablePaths: "snapshot.immutablePaths",
+	managedPaths: "snapshot.managedPaths",
+	maxModules: "stats.modulesSpace (BREAKING CHANGE since webpack 5)",
+	hashedModuleIds:
+		'optimization.moduleIds: "hashed" (BREAKING CHANGE since webpack 5)',
+	namedChunks:
+		'optimization.chunkIds: "named" (BREAKING CHANGE since webpack 5)',
+	namedModules:
+		'optimization.moduleIds: "named" (BREAKING CHANGE since webpack 5)',
+	occurrenceOrder:
+		'optimization.chunkIds: "size" and optimization.moduleIds: "size" (BREAKING CHANGE since webpack 5)',
+	automaticNamePrefix:
+		"optimization.splitChunks.[cacheGroups.*].idHint (BREAKING CHANGE since webpack 5)",
+	noEmitOnErrors:
+		"optimization.emitOnErrors (BREAKING CHANGE since webpack 5: logic is inverted to avoid negative flags)",
+	Buffer:
+		"to use the ProvidePlugin to process the Buffer variable to modules as polyfill\n" +
+		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
+		"Note: if you are using 'node.Buffer: false', you can just remove that as this is the default behavior now.\n" +
+		"To provide a polyfill to modules use:\n" +
+		'new ProvidePlugin({ Buffer: ["buffer", "Buffer"] }) and npm install buffer.',
+	process:
+		"to use the ProvidePlugin to process the process variable to modules as polyfill\n" +
+		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
+		"Note: if you are using 'node.process: false', you can just remove that as this is the default behavior now.\n" +
+		"To provide a polyfill to modules use:\n" +
+		'new ProvidePlugin({ process: "process" }) and npm install buffer.'
 };
 
+const REMOVED = {
+	concord:
+		"BREAKING CHANGE: resolve.concord has been removed and is no longer available.",
+	devtoolLineToLine:
+		"BREAKING CHANGE: output.devtoolLineToLine has been removed and is no longer available."
+};
+/* cSpell:enable */
 
-/***/ }),
-
-/***/ 41606:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+/**
+ * @param {Parameters<typeof validate>[0]} schema a json schema
+ * @param {Parameters<typeof validate>[1]} options the options that should be validated
+ * @param {Parameters<typeof validate>[2]=} validationConfiguration configuration for generating errors
+ * @returns {void}
+ */
+const validateSchema = (schema, options, validationConfiguration) => {
+	validate(
+		schema,
+		options,
+		validationConfiguration || {
+			name: "Webpack",
+			postFormatter: (formattedError, error) => {
+				const children = error.children;
+				if (
+					children &&
+					children.some(
+						child =>
+							child.keyword === "absolutePath" &&
+							child.dataPath === ".output.filename"
+					)
+				) {
+					return `${formattedError}\nPlease use output.path to specify absolute path and output.filename for the file name.`;
+				}
 
+				if (
+					children &&
+					children.some(
+						child =>
+							child.keyword === "pattern" && child.dataPath === ".devtool"
+					)
+				) {
+					return (
+						`${formattedError}\n` +
+						"BREAKING CHANGE since webpack 5: The devtool option is more strict.\n" +
+						"Please strictly follow the order of the keywords in the pattern."
+					);
+				}
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {{[k: string]: any}} Cache */
+				if (error.keyword === "additionalProperties") {
+					const params =
+						/** @type {import("ajv").AdditionalPropertiesParams} */ (
+							error.params
+						);
+					if (
+						Object.prototype.hasOwnProperty.call(
+							DID_YOU_MEAN,
+							params.additionalProperty
+						)
+					) {
+						return `${formattedError}\nDid you mean ${
+							DID_YOU_MEAN[params.additionalProperty]
+						}?`;
+					}
 
-function getCacheId(request, withContext) {
-	return JSON.stringify({
-		context: withContext ? request.context : "",
-		path: request.path,
-		query: request.query,
-		fragment: request.fragment,
-		request: request.request
-	});
-}
+					if (
+						Object.prototype.hasOwnProperty.call(
+							REMOVED,
+							params.additionalProperty
+						)
+					) {
+						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
+					}
 
-module.exports = class UnsafeCachePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {function(ResolveRequest): boolean} filterPredicate filterPredicate
-	 * @param {Cache} cache cache
-	 * @param {boolean} withContext withContext
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, filterPredicate, cache, withContext, target) {
-		this.source = source;
-		this.filterPredicate = filterPredicate;
-		this.withContext = withContext;
-		this.cache = cache;
-		this.target = target;
-	}
+					if (!error.dataPath) {
+						if (params.additionalProperty === "debug") {
+							return (
+								`${formattedError}\n` +
+								"The 'debug' property was removed in webpack 2.0.0.\n" +
+								"Loaders should be updated to allow passing this option via loader options in module.rules.\n" +
+								"Until loaders are updated one can use the LoaderOptionsPlugin to switch loaders into debug mode:\n" +
+								"plugins: [\n" +
+								"  new webpack.LoaderOptionsPlugin({\n" +
+								"    debug: true\n" +
+								"  })\n" +
+								"]"
+							);
+						}
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
-				if (!this.filterPredicate(request)) return callback();
-				const cacheId = getCacheId(request, this.withContext);
-				const cacheEntry = this.cache[cacheId];
-				if (cacheEntry) {
-					return callback(null, cacheEntry);
-				}
-				resolver.doResolve(
-					target,
-					request,
-					null,
-					resolveContext,
-					(err, result) => {
-						if (err) return callback(err);
-						if (result) return callback(null, (this.cache[cacheId] = result));
-						callback();
+						if (params.additionalProperty) {
+							return (
+								`${formattedError}\n` +
+								"For typos: please correct them.\n" +
+								"For loader options: webpack >= v2.0.0 no longer allows custom properties in configuration.\n" +
+								"  Loaders should be updated to allow passing options via loader options in module.rules.\n" +
+								"  Until loaders are updated one can use the LoaderOptionsPlugin to pass these options to the loader:\n" +
+								"  plugins: [\n" +
+								"    new webpack.LoaderOptionsPlugin({\n" +
+								"      // test: /\\.xxx$/, // may apply this only for some modules\n" +
+								"      options: {\n" +
+								`        ${params.additionalProperty}: …\n` +
+								"      }\n" +
+								"    })\n" +
+								"  ]"
+							);
+						}
 					}
-				);
-			});
-	}
+				}
+
+				return formattedError;
+			}
+		}
+	);
 };
+module.exports = validateSchema;
 
 
 /***/ }),
 
-/***/ 96972:
-/***/ (function(module) {
+/***/ 5434:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -137567,98 +136921,83 @@ module.exports = class UnsafeCachePlugin {
 
 
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
 
-module.exports = class UseFilePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} filename filename
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, filename, target) {
-		this.source = source;
-		this.filename = filename;
-		this.target = target;
+class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
+	constructor({ generateLoadBinaryCode, supportsStreaming }) {
+		super("wasm loading", RuntimeModule.STAGE_NORMAL);
+		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		this.supportsStreaming = supportsStreaming;
 	}
 
 	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
-				const filePath = resolver.join(request.path, this.filename);
-				const obj = {
-					...request,
-					path: filePath,
-					relativePath:
-						request.relativePath &&
-						resolver.join(request.relativePath, this.filename)
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"using path: " + filePath,
-					resolveContext,
-					callback
-				);
-			});
+	generate() {
+		const { compilation, chunk } = this;
+		const { outputOptions, runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.instantiateWasm;
+		const wasmModuleSrcPath = compilation.getPath(
+			JSON.stringify(outputOptions.webassemblyModuleFilename),
+			{
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+				module: {
+					id: '" + wasmModuleId + "',
+					hash: `" + wasmModuleHash + "`,
+					hashWithLength(length) {
+						return `" + wasmModuleHash.slice(0, ${length}) + "`;
+					}
+				},
+				runtime: chunk.runtime
+			}
+		);
+		return `${fn} = ${runtimeTemplate.basicFunction(
+			"exports, wasmModuleId, wasmModuleHash, importsObj",
+			[
+				`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
+				this.supportsStreaming
+					? Template.asString([
+							"if (typeof WebAssembly.instantiateStreaming === 'function') {",
+							Template.indent([
+								"return WebAssembly.instantiateStreaming(req, importsObj)",
+								Template.indent([
+									`.then(${runtimeTemplate.returningFunction(
+										"Object.assign(exports, res.instance.exports)",
+										"res"
+									)});`
+								])
+							]),
+							"}"
+					  ])
+					: "// no support for streaming compilation",
+				"return req",
+				Template.indent([
+					`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
+					`.then(${runtimeTemplate.returningFunction(
+						"WebAssembly.instantiate(bytes, importsObj)",
+						"bytes"
+					)})`,
+					`.then(${runtimeTemplate.returningFunction(
+						"Object.assign(exports, res.instance.exports)",
+						"res"
+					)});`
+				])
+			]
+		)};`;
 	}
-};
-
-
-/***/ }),
-
-/***/ 81218:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+}
 
-module.exports = function createInnerContext(
-	options,
-	message,
-	messageOptional
-) {
-	let messageReported = false;
-	let innerLog = undefined;
-	if (options.log) {
-		if (message) {
-			innerLog = msg => {
-				if (!messageReported) {
-					options.log(message);
-					messageReported = true;
-				}
-				options.log("  " + msg);
-			};
-		} else {
-			innerLog = options.log;
-		}
-	}
-	const childContext = {
-		log: innerLog,
-		fileDependencies: options.fileDependencies,
-		contextDependencies: options.contextDependencies,
-		missingDependencies: options.missingDependencies,
-		stack: options.stack
-	};
-	return childContext;
-};
+module.exports = AsyncWasmLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 78565:
-/***/ (function(module) {
+/***/ 58461:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -137668,108 +137007,57 @@ module.exports = function createInnerContext(
 
 
 
-module.exports = function forEachBail(array, iterator, callback) {
-	if (array.length === 0) return callback();
-
-	let i = 0;
-	const next = () => {
-		let loop = undefined;
-		iterator(array[i++], (err, result) => {
-			if (err || result !== undefined || i >= array.length) {
-				return callback(err, result);
-			}
-			if (loop === false) while (next());
-			loop = true;
-		});
-		if (!loop) loop = false;
-		return loop;
-	};
-	while (next());
-};
-
-
-/***/ }),
+const Generator = __webpack_require__(93401);
 
-/***/ 47956:
-/***/ (function(module) {
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const TYPES = new Set(["webassembly"]);
 
+class AsyncWebAssemblyGenerator extends Generator {
+	constructor(options) {
+		super();
+		this.options = options;
+	}
 
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
 
-module.exports = function getInnerRequest(resolver, request) {
-	if (
-		typeof request.__innerRequest === "string" &&
-		request.__innerRequest_request === request.request &&
-		request.__innerRequest_relativePath === request.relativePath
-	)
-		return request.__innerRequest;
-	let innerRequest;
-	if (request.request) {
-		innerRequest = request.request;
-		if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) {
-			innerRequest = resolver.join(request.relativePath, innerRequest);
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 0;
 		}
-	} else {
-		innerRequest = request.relativePath;
+		return originalSource.size();
 	}
-	request.__innerRequest_request = request.request;
-	request.__innerRequest_relativePath = request.relativePath;
-	return (request.__innerRequest = innerRequest);
-};
-
-
-/***/ }),
-
-/***/ 82918:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
-
-
-module.exports = function getPaths(path) {
-	const parts = path.split(/(.*?[\\/]+)/);
-	const paths = [path];
-	const seqments = [parts[parts.length - 1]];
-	let part = parts[parts.length - 1];
-	path = path.substr(0, path.length - part.length - 1);
-	for (let i = parts.length - 2; i > 2; i -= 2) {
-		paths.push(path);
-		part = parts[i];
-		path = path.substr(0, path.length - part.length) || "/";
-		seqments.push(part.substr(0, part.length - 1));
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		return module.originalSource();
 	}
-	part = parts[1];
-	seqments.push(part);
-	paths.push(part);
-	return {
-		paths: paths,
-		seqments: seqments
-	};
-};
+}
 
-module.exports.basename = function basename(path) {
-	const i = path.lastIndexOf("/"),
-		j = path.lastIndexOf("\\");
-	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
-	if (p < 0) return null;
-	const s = path.substr(p + 1);
-	return s;
-};
+module.exports = AsyncWebAssemblyGenerator;
 
 
 /***/ }),
 
-/***/ 9256:
+/***/ 95614:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -137780,845 +137068,982 @@ module.exports.basename = function basename(path) {
 
 
 
-const fs = __webpack_require__(90552);
-const CachedInputFileSystem = __webpack_require__(52788);
-const ResolverFactory = __webpack_require__(47716);
-
-/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./ResolverFactory").Plugin} Plugin */
-/** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-const nodeFileSystem = new CachedInputFileSystem(fs, 4000);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
-const nodeContext = {
-	environments: ["node+es3+es5+process+native"]
-};
+const TYPES = new Set(["webassembly"]);
 
-const asyncResolver = ResolverFactory.createResolver({
-	conditionNames: ["node"],
-	extensions: [".js", ".json", ".node"],
-	fileSystem: nodeFileSystem
-});
-function resolve(context, path, request, resolveContext, callback) {
-	if (typeof context === "string") {
-		callback = resolveContext;
-		resolveContext = request;
-		request = path;
-		path = context;
-		context = nodeContext;
+class AsyncWebAssemblyJavascriptGenerator extends Generator {
+	constructor(filenameTemplate) {
+		super();
+		this.filenameTemplate = filenameTemplate;
 	}
-	if (typeof callback !== "function") {
-		callback = resolveContext;
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
 	}
-	asyncResolver.resolve(context, path, request, resolveContext, callback);
-}
 
-const syncResolver = ResolverFactory.createResolver({
-	conditionNames: ["node"],
-	extensions: [".js", ".json", ".node"],
-	useSyncFileSystemCalls: true,
-	fileSystem: nodeFileSystem
-});
-function resolveSync(context, path, request) {
-	if (typeof context === "string") {
-		request = path;
-		path = context;
-		context = nodeContext;
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 40 + module.dependencies.length * 10;
 	}
-	return syncResolver.resolveSync(context, path, request);
-}
 
-function create(options) {
-	options = {
-		fileSystem: nodeFileSystem,
-		...options
-	};
-	const resolver = ResolverFactory.createResolver(options);
-	return function (context, path, request, resolveContext, callback) {
-		if (typeof context === "string") {
-			callback = resolveContext;
-			resolveContext = request;
-			request = path;
-			path = context;
-			context = nodeContext;
-		}
-		if (typeof callback !== "function") {
-			callback = resolveContext;
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtime
+		} = generateContext;
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
+		/** @type {InitFragment[]} */
+		const initFragments = [];
+		/** @type {Map<Module, { request: string, importVar: string }>} */
+		const depModules = new Map();
+		/** @type {Map<string, WebAssemblyImportDependency[]>} */
+		const wasmDepsByRequest = new Map();
+		for (const dep of module.dependencies) {
+			if (dep instanceof WebAssemblyImportDependency) {
+				const module = moduleGraph.getModule(dep);
+				if (!depModules.has(module)) {
+					depModules.set(module, {
+						request: dep.request,
+						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
+					});
+				}
+				let list = wasmDepsByRequest.get(dep.request);
+				if (list === undefined) {
+					list = [];
+					wasmDepsByRequest.set(dep.request, list);
+				}
+				list.push(dep);
+			}
 		}
-		resolver.resolve(context, path, request, resolveContext, callback);
-	};
-}
 
-function createSync(options) {
-	options = {
-		useSyncFileSystemCalls: true,
-		fileSystem: nodeFileSystem,
-		...options
-	};
-	const resolver = ResolverFactory.createResolver(options);
-	return function (context, path, request) {
-		if (typeof context === "string") {
-			request = path;
-			path = context;
-			context = nodeContext;
-		}
-		return resolver.resolveSync(context, path, request);
-	};
+		const promises = [];
+
+		const importStatements = Array.from(
+			depModules,
+			([importedModule, { request, importVar }]) => {
+				if (moduleGraph.isAsync(importedModule)) {
+					promises.push(importVar);
+				}
+				return runtimeTemplate.importStatement({
+					update: false,
+					module: importedModule,
+					chunkGraph,
+					request,
+					originModule: module,
+					importVar,
+					runtimeRequirements
+				});
+			}
+		);
+		const importsCode = importStatements.map(([x]) => x).join("");
+		const importsCompatCode = importStatements.map(([_, x]) => x).join("");
+
+		const importObjRequestItems = Array.from(
+			wasmDepsByRequest,
+			([request, deps]) => {
+				const exportItems = deps.map(dep => {
+					const importedModule = moduleGraph.getModule(dep);
+					const importVar = depModules.get(importedModule).importVar;
+					return `${JSON.stringify(
+						dep.name
+					)}: ${runtimeTemplate.exportFromImport({
+						moduleGraph,
+						module: importedModule,
+						request,
+						exportName: dep.name,
+						originModule: module,
+						asiSafe: true,
+						isCall: false,
+						callContext: false,
+						defaultInterop: true,
+						importVar,
+						initFragments,
+						runtime,
+						runtimeRequirements
+					})}`;
+				});
+				return Template.asString([
+					`${JSON.stringify(request)}: {`,
+					Template.indent(exportItems.join(",\n")),
+					"}"
+				]);
+			}
+		);
+
+		const importsObj =
+			importObjRequestItems.length > 0
+				? Template.asString([
+						"{",
+						Template.indent(importObjRequestItems.join(",\n")),
+						"}"
+				  ])
+				: undefined;
+
+		const instantiateCall =
+			`${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
+				module.moduleArgument
+			}.id, ${JSON.stringify(
+				chunkGraph.getRenderedModuleHash(module, runtime)
+			)}` + (importsObj ? `, ${importsObj})` : `)`);
+
+		if (promises.length > 0)
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+
+		const source = new RawSource(
+			promises.length > 0
+				? Template.asString([
+						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
+							`[${promises.join(", ")}]`,
+							`${importsCompatCode}return ${instantiateCall};`
+						)}`,
+						`${RuntimeGlobals.asyncModule}(${
+							module.moduleArgument
+						}, async ${runtimeTemplate.basicFunction(
+							"__webpack_handle_async_dependencies__, __webpack_async_result__",
+							[
+								"try {",
+								importsCode,
+								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
+									", "
+								)}]);`,
+								`var [${promises.join(
+									", "
+								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
+								`${importsCompatCode}await ${instantiateCall};`,
+								"__webpack_async_result__();",
+								"} catch(e) { __webpack_async_result__(e); }"
+							]
+						)}, 1);`
+				  ])
+				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
+		);
+
+		return InitFragment.addToSource(source, initFragments, generateContext);
+	}
 }
 
-/**
- * @template A
- * @template B
- * @param {A} obj input a
- * @param {B} exports input b
- * @returns {A & B} merged
- */
-const mergeExports = (obj, exports) => {
-	const descriptors = Object.getOwnPropertyDescriptors(exports);
-	Object.defineProperties(obj, descriptors);
-	return /** @type {A & B} */ (Object.freeze(obj));
-};
-
-module.exports = mergeExports(resolve, {
-	get sync() {
-		return resolveSync;
-	},
-	create: mergeExports(create, {
-		get sync() {
-			return createSync;
-		}
-	}),
-	ResolverFactory,
-	CachedInputFileSystem,
-	get CloneBasenamePlugin() {
-		return __webpack_require__(22254);
-	},
-	get LogInfoPlugin() {
-		return __webpack_require__(5049);
-	},
-	get forEachBail() {
-		return __webpack_require__(78565);
-	}
-});
+module.exports = AsyncWebAssemblyJavascriptGenerator;
 
 
 /***/ }),
 
-/***/ 55863:
-/***/ (function(module) {
+/***/ 7538:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-/** @typedef {string|(string|ConditionalMapping)[]} DirectMapping */
-/** @typedef {{[k: string]: MappingValue}} ConditionalMapping */
-/** @typedef {ConditionalMapping|DirectMapping|null} MappingValue */
-/** @typedef {Record<string, MappingValue>|ConditionalMapping|DirectMapping} ExportsField */
-/** @typedef {Record<string, MappingValue>} ImportsField */
-
-/**
- * @typedef {Object} PathTreeNode
- * @property {Map<string, PathTreeNode>|null} children
- * @property {MappingValue} folder
- * @property {Map<string, MappingValue>|null} wildcards
- * @property {Map<string, MappingValue>} files
- */
-
-/**
- * Processing exports/imports field
- * @callback FieldProcessor
- * @param {string} request request
- * @param {Set<string>} conditionNames condition names
- * @returns {string[]} resolved paths
- */
-
-/*
-Example exports field:
-{
-  ".": "./main.js",
-  "./feature": {
-    "browser": "./feature-browser.js",
-    "default": "./feature.js"
-  }
-}
-Terminology:
-
-Enhanced-resolve name keys ("." and "./feature") as exports field keys.
-
-If value is string or string[], mapping is called as a direct mapping
-and value called as a direct export.
-
-If value is key-value object, mapping is called as a conditional mapping
-and value called as a conditional export.
-
-Key in conditional mapping is called condition name.
-
-Conditional mapping nested in another conditional mapping is called nested mapping.
-
-----------
-
-Example imports field:
-{
-  "#a": "./main.js",
-  "#moment": {
-    "browser": "./moment/index.js",
-    "default": "moment"
-  },
-  "#moment/": {
-    "browser": "./moment/",
-    "default": "moment/"
-  }
-}
-Terminology:
-
-Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys.
-
-If value is string or string[], mapping is called as a direct mapping
-and value called as a direct export.
-
-If value is key-value object, mapping is called as a conditional mapping
-and value called as a conditional export.
-
-Key in conditional mapping is called condition name.
-
-Conditional mapping nested in another conditional mapping is called nested mapping.
-
-*/
+const { SyncWaterfallHook } = __webpack_require__(41242);
+const Compilation = __webpack_require__(85720);
+const Generator = __webpack_require__(93401);
+const { tryRunOrWebpackError } = __webpack_require__(11351);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const memoize = __webpack_require__(78676);
 
-const slashCode = "/".charCodeAt(0);
-const dotCode = ".".charCodeAt(0);
-const hashCode = "#".charCodeAt(0);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
 
-/**
- * @param {ExportsField} exportsField the exports field
- * @returns {FieldProcessor} process callback
- */
-module.exports.processExportsField = function processExportsField(
-	exportsField
-) {
-	return createFieldProcessor(
-		buildExportsFieldPathTree(exportsField),
-		assertExportsFieldRequest,
-		assertExportTarget
-	);
-};
+const getAsyncWebAssemblyGenerator = memoize(() =>
+	__webpack_require__(58461)
+);
+const getAsyncWebAssemblyJavascriptGenerator = memoize(() =>
+	__webpack_require__(95614)
+);
+const getAsyncWebAssemblyParser = memoize(() =>
+	__webpack_require__(96305)
+);
 
 /**
- * @param {ImportsField} importsField the exports field
- * @returns {FieldProcessor} process callback
+ * @typedef {Object} WebAssemblyRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
  */
-module.exports.processImportsField = function processImportsField(
-	importsField
-) {
-	return createFieldProcessor(
-		buildImportsFieldPathTree(importsField),
-		assertImportsFieldRequest,
-		assertImportTarget
-	);
-};
 
 /**
- * @param {PathTreeNode} treeRoot root
- * @param {(s: string) => string} assertRequest assertRequest
- * @param {(s: string, f: boolean) => void} assertTarget assertTarget
- * @returns {FieldProcessor} field processor
+ * @typedef {Object} CompilationHooks
+ * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
  */
-function createFieldProcessor(treeRoot, assertRequest, assertTarget) {
-	return function fieldProcessor(request, conditionNames) {
-		request = assertRequest(request);
 
-		const match = findMatch(request, treeRoot);
-
-		if (match === null) return [];
-
-		const [mapping, remainRequestIndex] = match;
-
-		/** @type {DirectMapping|null} */
-		let direct = null;
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-		if (isConditionalMapping(mapping)) {
-			direct = conditionalMapping(
-				/** @type {ConditionalMapping} */ (mapping),
-				conditionNames
+class AsyncWebAssemblyModulesPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
 			);
-
-			// matching not found
-			if (direct === null) return [];
-		} else {
-			direct = /** @type {DirectMapping} */ (mapping);
 		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				renderModuleContent: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
 
-		const remainingRequest =
-			remainRequestIndex === request.length + 1
-				? undefined
-				: remainRequestIndex < 0
-				? request.slice(-remainRequestIndex - 1)
-				: request.slice(remainRequestIndex);
+	constructor(options) {
+		this.options = options;
+	}
 
-		return directMapping(
-			remainingRequest,
-			remainRequestIndex < 0,
-			direct,
-			conditionNames,
-			assertTarget
-		);
-	};
-}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"AsyncWebAssemblyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const hooks =
+					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
+				compilation.dependencyFactories.set(
+					WebAssemblyImportDependency,
+					normalModuleFactory
+				);
 
-/**
- * @param {string} request request
- * @returns {string} updated request
- */
-function assertExportsFieldRequest(request) {
-	if (request.charCodeAt(0) !== dotCode) {
-		throw new Error('Request should be relative path and start with "."');
-	}
-	if (request.length === 1) return "";
-	if (request.charCodeAt(1) !== slashCode) {
-		throw new Error('Request should be relative path and start with "./"');
-	}
-	if (request.charCodeAt(request.length - 1) === slashCode) {
-		throw new Error("Only requesting file allowed");
-	}
+				normalModuleFactory.hooks.createParser
+					.for("webassembly/async")
+					.tap("AsyncWebAssemblyModulesPlugin", () => {
+						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
 
-	return request.slice(2);
-}
+						return new AsyncWebAssemblyParser();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("webassembly/async")
+					.tap("AsyncWebAssemblyModulesPlugin", () => {
+						const AsyncWebAssemblyJavascriptGenerator =
+							getAsyncWebAssemblyJavascriptGenerator();
+						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
 
-/**
- * @param {string} request request
- * @returns {string} updated request
- */
-function assertImportsFieldRequest(request) {
-	if (request.charCodeAt(0) !== hashCode) {
-		throw new Error('Request should start with "#"');
-	}
-	if (request.length === 1) {
-		throw new Error("Request should have at least 2 characters");
-	}
-	if (request.charCodeAt(1) === slashCode) {
-		throw new Error('Request should not start with "#/"');
-	}
-	if (request.charCodeAt(request.length - 1) === slashCode) {
-		throw new Error("Only requesting file allowed");
-	}
+						return Generator.byType({
+							javascript: new AsyncWebAssemblyJavascriptGenerator(
+								compilation.outputOptions.webassemblyModuleFilename
+							),
+							webassembly: new AsyncWebAssemblyGenerator(this.options)
+						});
+					});
 
-	return request.slice(1);
-}
+				compilation.hooks.renderManifest.tap(
+					"WebAssemblyModulesPlugin",
+					(result, options) => {
+						const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
+						const {
+							chunk,
+							outputOptions,
+							dependencyTemplates,
+							codeGenerationResults
+						} = options;
 
-/**
- * @param {string} exp export target
- * @param {boolean} expectFolder is folder expected
- */
-function assertExportTarget(exp, expectFolder) {
-	if (
-		exp.charCodeAt(0) === slashCode ||
-		(exp.charCodeAt(0) === dotCode && exp.charCodeAt(1) !== slashCode)
-	) {
-		throw new Error(
-			`Export should be relative path and start with "./", got ${JSON.stringify(
-				exp
-			)}.`
-		);
-	}
+						for (const module of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesByIdentifier
+						)) {
+							if (module.type === "webassembly/async") {
+								const filenameTemplate =
+									outputOptions.webassemblyModuleFilename;
 
-	const isFolder = exp.charCodeAt(exp.length - 1) === slashCode;
+								result.push({
+									render: () =>
+										this.renderModule(
+											module,
+											{
+												chunk,
+												dependencyTemplates,
+												runtimeTemplate,
+												moduleGraph,
+												chunkGraph,
+												codeGenerationResults
+											},
+											hooks
+										),
+									filenameTemplate,
+									pathOptions: {
+										module,
+										runtime: chunk.runtime,
+										chunkGraph
+									},
+									auxiliary: true,
+									identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
+										module
+									)}`,
+									hash: chunkGraph.getModuleHash(module, chunk.runtime)
+								});
+							}
+						}
 
-	if (isFolder !== expectFolder) {
-		throw new Error(
-			expectFolder
-				? `Expecting folder to folder mapping. ${JSON.stringify(
-						exp
-				  )} should end with "/"`
-				: `Expecting file to file mapping. ${JSON.stringify(
-						exp
-				  )} should not end with "/"`
+						return result;
+					}
+				);
+			}
 		);
 	}
-}
-
-/**
- * @param {string} imp import target
- * @param {boolean} expectFolder is folder expected
- */
-function assertImportTarget(imp, expectFolder) {
-	const isFolder = imp.charCodeAt(imp.length - 1) === slashCode;
 
-	if (isFolder !== expectFolder) {
-		throw new Error(
-			expectFolder
-				? `Expecting folder to folder mapping. ${JSON.stringify(
-						imp
-				  )} should end with "/"`
-				: `Expecting file to file mapping. ${JSON.stringify(
-						imp
-				  )} should not end with "/"`
-		);
+	renderModule(module, renderContext, hooks) {
+		const { codeGenerationResults, chunk } = renderContext;
+		try {
+			const moduleSource = codeGenerationResults.getSource(
+				module,
+				chunk.runtime,
+				"webassembly"
+			);
+			return tryRunOrWebpackError(
+				() =>
+					hooks.renderModuleContent.call(moduleSource, module, renderContext),
+				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
+			);
+		} catch (e) {
+			e.module = module;
+			throw e;
+		}
 	}
 }
 
-/**
- * Trying to match request to field
- * @param {string} request request
- * @param {PathTreeNode} treeRoot path tree root
- * @returns {[MappingValue, number]|null} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings
- */
-function findMatch(request, treeRoot) {
-	if (request.length === 0) {
-		const value = treeRoot.files.get("");
+module.exports = AsyncWebAssemblyModulesPlugin;
 
-		return value ? [value, 1] : null;
-	}
 
-	if (
-		treeRoot.children === null &&
-		treeRoot.folder === null &&
-		treeRoot.wildcards === null
-	) {
-		const value = treeRoot.files.get(request);
+/***/ }),
 
-		return value ? [value, request.length + 1] : null;
-	}
+/***/ 96305:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	let node = treeRoot;
-	let lastNonSlashIndex = 0;
-	let slashIndex = request.indexOf("/", 0);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/** @type {[MappingValue, number]|null} */
-	let lastFolderMatch = null;
 
-	const applyFolderMapping = () => {
-		const folderMapping = node.folder;
-		if (folderMapping) {
-			if (lastFolderMatch) {
-				lastFolderMatch[0] = folderMapping;
-				lastFolderMatch[1] = -lastNonSlashIndex - 1;
-			} else {
-				lastFolderMatch = [folderMapping, -lastNonSlashIndex - 1];
-			}
-		}
-	};
 
-	const applyWildcardMappings = (wildcardMappings, remainingRequest) => {
-		if (wildcardMappings) {
-			for (const [key, target] of wildcardMappings) {
-				if (remainingRequest.startsWith(key)) {
-					if (!lastFolderMatch) {
-						lastFolderMatch = [target, lastNonSlashIndex + key.length];
-					} else if (lastFolderMatch[1] < lastNonSlashIndex + key.length) {
-						lastFolderMatch[0] = target;
-						lastFolderMatch[1] = lastNonSlashIndex + key.length;
-					}
-				}
-			}
-		}
-	};
+const t = __webpack_require__(51826);
+const { decode } = __webpack_require__(73726);
+const Parser = __webpack_require__(11715);
+const StaticExportsDependency = __webpack_require__(91418);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-	while (slashIndex !== -1) {
-		applyFolderMapping();
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-		const wildcardMappings = node.wildcards;
+const decoderOpts = {
+	ignoreCodeSection: true,
+	ignoreDataSection: true,
 
-		if (!wildcardMappings && node.children === null) return lastFolderMatch;
+	// this will avoid having to lookup with identifiers in the ModuleContext
+	ignoreCustomNameSection: true
+};
 
-		const folder = request.slice(lastNonSlashIndex, slashIndex);
+class WebAssemblyParser extends Parser {
+	constructor(options) {
+		super();
+		this.hooks = Object.freeze({});
+		this.options = options;
+	}
 
-		applyWildcardMappings(wildcardMappings, folder);
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (!Buffer.isBuffer(source)) {
+			throw new Error("WebAssemblyParser input must be a Buffer");
+		}
 
-		if (node.children === null) return lastFolderMatch;
+		// flag it as async module
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "namespace";
+		state.module.buildMeta.async = true;
 
-		const newNode = node.children.get(folder);
+		// parse it
+		const program = decode(source, decoderOpts);
+		const module = program.body[0];
 
-		if (!newNode) {
-			return lastFolderMatch;
-		}
+		const exports = [];
+		t.traverse(module, {
+			ModuleExport({ node }) {
+				exports.push(node.name);
+			},
 
-		node = newNode;
-		lastNonSlashIndex = slashIndex + 1;
-		slashIndex = request.indexOf("/", lastNonSlashIndex);
-	}
+			ModuleImport({ node }) {
+				const dep = new WebAssemblyImportDependency(
+					node.module,
+					node.name,
+					node.descr,
+					false
+				);
 
-	const remainingRequest =
-		lastNonSlashIndex > 0 ? request.slice(lastNonSlashIndex) : request;
+				state.module.addDependency(dep);
+			}
+		});
 
-	const value = node.files.get(remainingRequest);
+		state.module.addDependency(new StaticExportsDependency(exports, false));
 
-	if (value) {
-		return [value, request.length + 1];
+		return state;
 	}
+}
 
-	applyFolderMapping();
+module.exports = WebAssemblyParser;
 
-	applyWildcardMappings(node.wildcards, remainingRequest);
 
-	return lastFolderMatch;
-}
+/***/ }),
 
-/**
- * @param {ConditionalMapping|DirectMapping|null} mapping mapping
- * @returns {boolean} is conditional mapping
- */
-function isConditionalMapping(mapping) {
-	return (
-		mapping !== null && typeof mapping === "object" && !Array.isArray(mapping)
-	);
-}
+/***/ 78455:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
- * @param {boolean} subpathMapping true, for subpath mappings
- * @param {DirectMapping|null} mappingTarget direct export
- * @param {Set<string>} conditionNames condition names
- * @param {(d: string, f: boolean) => void} assert asserting direct value
- * @returns {string[]} mapping result
- */
-function directMapping(
-	remainingRequest,
-	subpathMapping,
-	mappingTarget,
-	conditionNames,
-	assert
-) {
-	if (mappingTarget === null) return [];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-	if (typeof mappingTarget === "string") {
-		return [
-			targetMapping(remainingRequest, subpathMapping, mappingTarget, assert)
-		];
-	}
 
-	const targets = [];
 
-	for (const exp of mappingTarget) {
-		if (typeof exp === "string") {
-			targets.push(
-				targetMapping(remainingRequest, subpathMapping, exp, assert)
-			);
-			continue;
-		}
+const WebpackError = __webpack_require__(53799);
 
-		const mapping = conditionalMapping(exp, conditionNames);
-		if (!mapping) continue;
-		const innerExports = directMapping(
-			remainingRequest,
-			subpathMapping,
-			mapping,
-			conditionNames,
-			assert
-		);
-		for (const innerExport of innerExports) {
-			targets.push(innerExport);
-		}
+module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
+	/** @param {string} message Error message */
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedWebAssemblyFeatureError";
+		this.hideStack = true;
 	}
+};
 
-	return targets;
-}
 
-/**
- * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
- * @param {boolean} subpathMapping true, for subpath mappings
- * @param {string} mappingTarget direct export
- * @param {(d: string, f: boolean) => void} assert asserting direct value
- * @returns {string} mapping result
- */
-function targetMapping(
-	remainingRequest,
-	subpathMapping,
-	mappingTarget,
-	assert
-) {
-	if (remainingRequest === undefined) {
-		assert(mappingTarget, false);
-		return mappingTarget;
-	}
-	if (subpathMapping) {
-		assert(mappingTarget, true);
-		return mappingTarget + remainingRequest;
-	}
-	assert(mappingTarget, false);
-	return mappingTarget.replace(/\*/g, remainingRequest.replace(/\$/g, "$$"));
-}
+/***/ }),
 
-/**
- * @param {ConditionalMapping} conditionalMapping_ conditional mapping
- * @param {Set<string>} conditionNames condition names
- * @returns {DirectMapping|null} direct mapping if found
- */
-function conditionalMapping(conditionalMapping_, conditionNames) {
-	/** @type {[ConditionalMapping, string[], number][]} */
-	let lookup = [[conditionalMapping_, Object.keys(conditionalMapping_), 0]];
+/***/ 87394:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	loop: while (lookup.length > 0) {
-		const [mapping, conditions, j] = lookup[lookup.length - 1];
-		const last = conditions.length - 1;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-		for (let i = j; i < conditions.length; i++) {
-			const condition = conditions[i];
 
-			// assert default. Could be last only
-			if (i !== last) {
-				if (condition === "default") {
-					throw new Error("Default condition should be last one");
-				}
-			} else if (condition === "default") {
-				const innerMapping = mapping[condition];
-				// is nested
-				if (isConditionalMapping(innerMapping)) {
-					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
-					lookup[lookup.length - 1][2] = i + 1;
-					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
-					continue loop;
-				}
 
-				return /** @type {DirectMapping} */ (innerMapping);
-			}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const WebAssemblyUtils = __webpack_require__(18650);
 
-			if (conditionNames.has(condition)) {
-				const innerMapping = mapping[condition];
-				// is nested
-				if (isConditionalMapping(innerMapping)) {
-					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
-					lookup[lookup.length - 1][2] = i + 1;
-					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
-					continue loop;
-				}
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-				return /** @type {DirectMapping} */ (innerMapping);
+// TODO webpack 6 remove the whole folder
+
+// Get all wasm modules
+const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
+	const wasmModules = chunk.getAllAsyncChunks();
+	const array = [];
+	for (const chunk of wasmModules) {
+		for (const m of chunkGraph.getOrderedChunkModulesIterable(
+			chunk,
+			compareModulesByIdentifier
+		)) {
+			if (m.type.startsWith("webassembly")) {
+				array.push(m);
 			}
 		}
-
-		lookup.pop();
 	}
 
-	return null;
-}
+	return array;
+};
 
 /**
- * Internal helper to create path tree node
- * to ensure that each node gets the same hidden class
- * @returns {PathTreeNode} node
+ * generates the import object function for a module
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} module the module
+ * @param {boolean} mangle mangle imports
+ * @param {string[]} declarations array where declarations are pushed to
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {string} source code
  */
-function createNode() {
-	return {
-		children: null,
-		folder: null,
-		wildcards: null,
-		files: new Map()
-	};
-}
+const generateImportObject = (
+	chunkGraph,
+	module,
+	mangle,
+	declarations,
+	runtime
+) => {
+	const moduleGraph = chunkGraph.moduleGraph;
+	const waitForInstances = new Map();
+	const properties = [];
+	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
+		moduleGraph,
+		module,
+		mangle
+	);
+	for (const usedDep of usedWasmDependencies) {
+		const dep = usedDep.dependency;
+		const importedModule = moduleGraph.getModule(dep);
+		const exportName = dep.name;
+		const usedName =
+			importedModule &&
+			moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(exportName, runtime);
+		const description = dep.description;
+		const direct = dep.onlyDirectImport;
 
-/**
- * Internal helper for building path tree
- * @param {PathTreeNode} root root
- * @param {string} path path
- * @param {MappingValue} target target
- */
-function walkPath(root, path, target) {
-	if (path.length === 0) {
-		root.folder = target;
-		return;
-	}
+		const module = usedDep.module;
+		const name = usedDep.name;
 
-	let node = root;
-	// Typical path tree can looks like
-	// root
-	// - files: ["a.js", "b.js"]
-	// - children:
-	//    node1:
-	//    - files: ["a.js", "b.js"]
-	let lastNonSlashIndex = 0;
-	let slashIndex = path.indexOf("/", 0);
+		if (direct) {
+			const instanceVar = `m${waitForInstances.size}`;
+			waitForInstances.set(instanceVar, chunkGraph.getModuleId(importedModule));
+			properties.push({
+				module,
+				name,
+				value: `${instanceVar}[${JSON.stringify(usedName)}]`
+			});
+		} else {
+			const params = description.signature.params.map(
+				(param, k) => "p" + k + param.valtype
+			);
 
-	while (slashIndex !== -1) {
-		const folder = path.slice(lastNonSlashIndex, slashIndex);
-		let newNode;
+			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
+				chunkGraph.getModuleId(importedModule)
+			)}]`;
+			const modExports = `${mod}.exports`;
 
-		if (node.children === null) {
-			newNode = createNode();
-			node.children = new Map();
-			node.children.set(folder, newNode);
-		} else {
-			newNode = node.children.get(folder);
+			const cache = `wasmImportedFuncCache${declarations.length}`;
+			declarations.push(`var ${cache};`);
 
-			if (!newNode) {
-				newNode = createNode();
-				node.children.set(folder, newNode);
-			}
+			properties.push({
+				module,
+				name,
+				value: Template.asString([
+					(importedModule.type.startsWith("webassembly")
+						? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
+						: "") + `function(${params}) {`,
+					Template.indent([
+						`if(${cache} === undefined) ${cache} = ${modExports};`,
+						`return ${cache}[${JSON.stringify(usedName)}](${params});`
+					]),
+					"}"
+				])
+			});
 		}
-
-		node = newNode;
-		lastNonSlashIndex = slashIndex + 1;
-		slashIndex = path.indexOf("/", lastNonSlashIndex);
 	}
 
-	if (lastNonSlashIndex >= path.length) {
-		node.folder = target;
+	let importObject;
+	if (mangle) {
+		importObject = [
+			"return {",
+			Template.indent([
+				properties.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
+			]),
+			"};"
+		];
 	} else {
-		const file = lastNonSlashIndex > 0 ? path.slice(lastNonSlashIndex) : path;
-		if (file.endsWith("*")) {
-			if (node.wildcards === null) node.wildcards = new Map();
-			node.wildcards.set(file.slice(0, -1), target);
-		} else {
-			node.files.set(file, target);
+		const propertiesByModule = new Map();
+		for (const p of properties) {
+			let list = propertiesByModule.get(p.module);
+			if (list === undefined) {
+				propertiesByModule.set(p.module, (list = []));
+			}
+			list.push(p);
 		}
+		importObject = [
+			"return {",
+			Template.indent([
+				Array.from(propertiesByModule, ([module, list]) => {
+					return Template.asString([
+						`${JSON.stringify(module)}: {`,
+						Template.indent([
+							list.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
+						]),
+						"}"
+					]);
+				}).join(",\n")
+			]),
+			"};"
+		];
 	}
-}
-
-/**
- * @param {ExportsField} field exports field
- * @returns {PathTreeNode} tree root
- */
-function buildExportsFieldPathTree(field) {
-	const root = createNode();
-
-	// handle syntax sugar, if exports field is direct mapping for "."
-	if (typeof field === "string") {
-		root.files.set("", field);
 
-		return root;
-	} else if (Array.isArray(field)) {
-		root.files.set("", field.slice());
-
-		return root;
+	const moduleIdStringified = JSON.stringify(chunkGraph.getModuleId(module));
+	if (waitForInstances.size === 1) {
+		const moduleId = Array.from(waitForInstances.values())[0];
+		const promise = `installedWasmModules[${JSON.stringify(moduleId)}]`;
+		const variable = Array.from(waitForInstances.keys())[0];
+		return Template.asString([
+			`${moduleIdStringified}: function() {`,
+			Template.indent([
+				`return promiseResolve().then(function() { return ${promise}; }).then(function(${variable}) {`,
+				Template.indent(importObject),
+				"});"
+			]),
+			"},"
+		]);
+	} else if (waitForInstances.size > 0) {
+		const promises = Array.from(
+			waitForInstances.values(),
+			id => `installedWasmModules[${JSON.stringify(id)}]`
+		).join(", ");
+		const variables = Array.from(
+			waitForInstances.keys(),
+			(name, i) => `${name} = array[${i}]`
+		).join(", ");
+		return Template.asString([
+			`${moduleIdStringified}: function() {`,
+			Template.indent([
+				`return promiseResolve().then(function() { return Promise.all([${promises}]); }).then(function(array) {`,
+				Template.indent([`var ${variables};`, ...importObject]),
+				"});"
+			]),
+			"},"
+		]);
+	} else {
+		return Template.asString([
+			`${moduleIdStringified}: function() {`,
+			Template.indent(importObject),
+			"},"
+		]);
 	}
+};
 
-	const keys = Object.keys(field);
-
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
+class WasmChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor({
+		generateLoadBinaryCode,
+		supportsStreaming,
+		mangleImports,
+		runtimeRequirements
+	}) {
+		super("wasm chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		this.supportsStreaming = supportsStreaming;
+		this.mangleImports = mangleImports;
+		this._runtimeRequirements = runtimeRequirements;
+	}
 
-		if (key.charCodeAt(0) !== dotCode) {
-			// handle syntax sugar, if exports field is conditional mapping for "."
-			if (i === 0) {
-				while (i < keys.length) {
-					const charCode = keys[i].charCodeAt(0);
-					if (charCode === dotCode || charCode === slashCode) {
-						throw new Error(
-							`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
-								key
-							)})`
-						);
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, compilation, chunk, mangleImports } = this;
+		const { moduleGraph, outputOptions } = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withHmr = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		const declarations = [];
+		const importObjects = wasmModules.map(module => {
+			return generateImportObject(
+				chunkGraph,
+				module,
+				this.mangleImports,
+				declarations,
+				chunk.runtime
+			);
+		});
+		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
+			m.type.startsWith("webassembly")
+		);
+		const createImportObject = content =>
+			mangleImports
+				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
+				: content;
+		const wasmModuleSrcPath = compilation.getPath(
+			JSON.stringify(outputOptions.webassemblyModuleFilename),
+			{
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+				module: {
+					id: '" + wasmModuleId + "',
+					hash: `" + ${JSON.stringify(
+						chunkGraph.getChunkModuleRenderedHashMap(chunk, m =>
+							m.type.startsWith("webassembly")
+						)
+					)}[chunkId][wasmModuleId] + "`,
+					hashWithLength(length) {
+						return `" + ${JSON.stringify(
+							chunkGraph.getChunkModuleRenderedHashMap(
+								chunk,
+								m => m.type.startsWith("webassembly"),
+								length
+							)
+						)}[chunkId][wasmModuleId] + "`;
 					}
-					i++;
-				}
-
-				root.files.set("", field);
-				return root;
+				},
+				runtime: chunk.runtime
 			}
+		);
 
-			throw new Error(
-				`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
-
-		if (key.length === 1) {
-			root.files.set("", field[key]);
-			continue;
-		}
-
-		if (key.charCodeAt(1) !== slashCode) {
-			throw new Error(
-				`Exports field key should be relative path and start with "./" (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_wasm`
+			: undefined;
 
-		walkPath(root, key.slice(2), field[key]);
+		return Template.asString([
+			"// object to store loaded and loading wasm modules",
+			`var installedWasmModules = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{};`,
+			"",
+			// This function is used to delay reading the installed wasm module promises
+			// by a microtask. Sorting them doesn't help because there are edge cases where
+			// sorting is not possible (modules splitted into different chunks).
+			// So we not even trying and solve this by a microtask delay.
+			"function promiseResolve() { return Promise.resolve(); }",
+			"",
+			Template.asString(declarations),
+			"var wasmImportObjects = {",
+			Template.indent(importObjects),
+			"};",
+			"",
+			`var wasmModuleMap = ${JSON.stringify(
+				chunkModuleIdMap,
+				undefined,
+				"\t"
+			)};`,
+			"",
+			"// object with all WebAssembly.instance exports",
+			`${RuntimeGlobals.wasmInstances} = {};`,
+			"",
+			"// Fetch + compile chunk loading for webassembly",
+			`${fn}.wasm = function(chunkId, promises) {`,
+			Template.indent([
+				"",
+				`var wasmModules = wasmModuleMap[chunkId] || [];`,
+				"",
+				"wasmModules.forEach(function(wasmModuleId, idx) {",
+				Template.indent([
+					"var installedWasmModuleData = installedWasmModules[wasmModuleId];",
+					"",
+					'// a Promise means "currently loading" or "already loaded".',
+					"if(installedWasmModuleData)",
+					Template.indent(["promises.push(installedWasmModuleData);"]),
+					"else {",
+					Template.indent([
+						`var importObject = wasmImportObjects[wasmModuleId]();`,
+						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
+						"var promise;",
+						this.supportsStreaming
+							? Template.asString([
+									"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
+									Template.indent([
+										"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
+										Template.indent([
+											`return WebAssembly.instantiate(items[0], ${createImportObject(
+												"items[1]"
+											)});`
+										]),
+										"});"
+									]),
+									"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
+									Template.indent([
+										`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
+											"importObject"
+										)});`
+									])
+							  ])
+							: Template.asString([
+									"if(importObject && typeof importObject.then === 'function') {",
+									Template.indent([
+										"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
+										"promise = Promise.all([",
+										Template.indent([
+											"bytesPromise.then(function(bytes) { return WebAssembly.compile(bytes); }),",
+											"importObject"
+										]),
+										"]).then(function(items) {",
+										Template.indent([
+											`return WebAssembly.instantiate(items[0], ${createImportObject(
+												"items[1]"
+											)});`
+										]),
+										"});"
+									])
+							  ]),
+						"} else {",
+						Template.indent([
+							"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
+							"promise = bytesPromise.then(function(bytes) {",
+							Template.indent([
+								`return WebAssembly.instantiate(bytes, ${createImportObject(
+									"importObject"
+								)});`
+							]),
+							"});"
+						]),
+						"}",
+						"promises.push(installedWasmModules[wasmModuleId] = promise.then(function(res) {",
+						Template.indent([
+							`return ${RuntimeGlobals.wasmInstances}[wasmModuleId] = (res.instance || res).exports;`
+						]),
+						"}));"
+					]),
+					"}"
+				]),
+				"});"
+			]),
+			"};"
+		]);
 	}
-
-	return root;
 }
 
-/**
- * @param {ImportsField} field imports field
- * @returns {PathTreeNode} root
- */
-function buildImportsFieldPathTree(field) {
-	const root = createNode();
-
-	const keys = Object.keys(field);
-
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-
-		if (key.charCodeAt(0) !== hashCode) {
-			throw new Error(
-				`Imports field key should start with "#" (key: ${JSON.stringify(key)})`
-			);
-		}
-
-		if (key.length === 1) {
-			throw new Error(
-				`Imports field key should have at least 2 characters (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
-
-		if (key.charCodeAt(1) === slashCode) {
-			throw new Error(
-				`Imports field key should not start with "#/" (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
-
-		walkPath(root, key.slice(1), field[key]);
-	}
-
-	return root;
-}
+module.exports = WasmChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 71053:
-/***/ (function(module) {
+/***/ 19810:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const PATH_QUERY_FRAGMENT_REGEXP = /^(#?(?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+const formatLocation = __webpack_require__(16734);
+const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
 
-/**
- * @param {string} identifier identifier
- * @returns {[string, string, string]|null} parsed identifier
- */
-function parseIdentifier(identifier) {
-	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier);
+/** @typedef {import("../Compiler")} Compiler */
 
-	if (!match) return null;
+class WasmFinalizeExportsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("WasmFinalizeExportsPlugin", compilation => {
+			compilation.hooks.finishModules.tap(
+				"WasmFinalizeExportsPlugin",
+				modules => {
+					for (const module of modules) {
+						// 1. if a WebAssembly module
+						if (module.type.startsWith("webassembly") === true) {
+							const jsIncompatibleExports =
+								module.buildMeta.jsIncompatibleExports;
 
-	return [
-		match[1].replace(/\0(.)/g, "$1"),
-		match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		match[3] || ""
-	];
+							if (jsIncompatibleExports === undefined) {
+								continue;
+							}
+
+							for (const connection of compilation.moduleGraph.getIncomingConnections(
+								module
+							)) {
+								// 2. is active and referenced by a non-WebAssembly module
+								if (
+									connection.isTargetActive(undefined) &&
+									connection.originModule.type.startsWith("webassembly") ===
+										false
+								) {
+									const referencedExports =
+										compilation.getDependencyReferencedExports(
+											connection.dependency,
+											undefined
+										);
+
+									for (const info of referencedExports) {
+										const names = Array.isArray(info) ? info : info.name;
+										if (names.length === 0) continue;
+										const name = names[0];
+										if (typeof name === "object") continue;
+										// 3. and uses a func with an incompatible JS signature
+										if (
+											Object.prototype.hasOwnProperty.call(
+												jsIncompatibleExports,
+												name
+											)
+										) {
+											// 4. error
+											const error = new UnsupportedWebAssemblyFeatureError(
+												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
+													`It's used from ${connection.originModule.readableIdentifier(
+														compilation.requestShortener
+													)} at ${formatLocation(connection.dependency.loc)}.`
+											);
+											error.module = module;
+											compilation.errors.push(error);
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			);
+		});
+	}
 }
 
-module.exports.parseIdentifier = parseIdentifier;
+module.exports = WasmFinalizeExportsPlugin;
 
 
 /***/ }),
 
-/***/ 67079:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 47012:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -138628,942 +138053,1194 @@ module.exports.parseIdentifier = parseIdentifier;
 
 
 
-const path = __webpack_require__(71017);
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const WebAssemblyUtils = __webpack_require__(18650);
 
-const CHAR_HASH = "#".charCodeAt(0);
-const CHAR_SLASH = "/".charCodeAt(0);
-const CHAR_BACKSLASH = "\\".charCodeAt(0);
-const CHAR_A = "A".charCodeAt(0);
-const CHAR_Z = "Z".charCodeAt(0);
-const CHAR_LOWER_A = "a".charCodeAt(0);
-const CHAR_LOWER_Z = "z".charCodeAt(0);
-const CHAR_DOT = ".".charCodeAt(0);
-const CHAR_COLON = ":".charCodeAt(0);
+const t = __webpack_require__(51826);
+const { moduleContextFromModuleAST } = __webpack_require__(51826);
+const { editWithAST, addWithAST } = __webpack_require__(87362);
+const { decode } = __webpack_require__(73726);
 
-const posixNormalize = path.posix.normalize;
-const winNormalize = path.win32.normalize;
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 
 /**
- * @enum {number}
+ * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
  */
-const PathType = Object.freeze({
-	Empty: 0,
-	Normal: 1,
-	Relative: 2,
-	AbsoluteWin: 3,
-	AbsolutePosix: 4,
-	Internal: 5
-});
-exports.PathType = PathType;
 
 /**
- * @param {string} p a path
- * @returns {PathType} type of path
+ * @template T
+ * @param {Function[]} fns transforms
+ * @returns {Function} composed transform
  */
-const getType = p => {
-	switch (p.length) {
-		case 0:
-			return PathType.Empty;
-		case 1: {
-			const c0 = p.charCodeAt(0);
-			switch (c0) {
-				case CHAR_DOT:
-					return PathType.Relative;
-				case CHAR_SLASH:
-					return PathType.AbsolutePosix;
-				case CHAR_HASH:
-					return PathType.Internal;
-			}
-			return PathType.Normal;
+const compose = (...fns) => {
+	return fns.reduce(
+		(prevFn, nextFn) => {
+			return value => nextFn(prevFn(value));
+		},
+		value => value
+	);
+};
+
+/**
+ * Removes the start instruction
+ *
+ * @param {Object} state unused state
+ * @returns {ArrayBufferTransform} transform
+ */
+const removeStartFunc = state => bin => {
+	return editWithAST(state.ast, bin, {
+		Start(path) {
+			path.remove();
 		}
-		case 2: {
-			const c0 = p.charCodeAt(0);
-			switch (c0) {
-				case CHAR_DOT: {
-					const c1 = p.charCodeAt(1);
-					switch (c1) {
-						case CHAR_DOT:
-						case CHAR_SLASH:
-							return PathType.Relative;
-					}
-					return PathType.Normal;
-				}
-				case CHAR_SLASH:
-					return PathType.AbsolutePosix;
-				case CHAR_HASH:
-					return PathType.Internal;
-			}
-			const c1 = p.charCodeAt(1);
-			if (c1 === CHAR_COLON) {
-				if (
-					(c0 >= CHAR_A && c0 <= CHAR_Z) ||
-					(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)
-				) {
-					return PathType.AbsoluteWin;
-				}
+	});
+};
+
+/**
+ * Get imported globals
+ *
+ * @param {Object} ast Module's AST
+ * @returns {Array<t.ModuleImport>} - nodes
+ */
+const getImportedGlobals = ast => {
+	const importedGlobals = [];
+
+	t.traverse(ast, {
+		ModuleImport({ node }) {
+			if (t.isGlobalType(node.descr)) {
+				importedGlobals.push(node);
 			}
-			return PathType.Normal;
 		}
-	}
-	const c0 = p.charCodeAt(0);
-	switch (c0) {
-		case CHAR_DOT: {
-			const c1 = p.charCodeAt(1);
-			switch (c1) {
-				case CHAR_SLASH:
-					return PathType.Relative;
-				case CHAR_DOT: {
-					const c2 = p.charCodeAt(2);
-					if (c2 === CHAR_SLASH) return PathType.Relative;
-					return PathType.Normal;
-				}
+	});
+
+	return importedGlobals;
+};
+
+/**
+ * Get the count for imported func
+ *
+ * @param {Object} ast Module's AST
+ * @returns {Number} - count
+ */
+const getCountImportedFunc = ast => {
+	let count = 0;
+
+	t.traverse(ast, {
+		ModuleImport({ node }) {
+			if (t.isFuncImportDescr(node.descr)) {
+				count++;
 			}
-			return PathType.Normal;
-		}
-		case CHAR_SLASH:
-			return PathType.AbsolutePosix;
-		case CHAR_HASH:
-			return PathType.Internal;
-	}
-	const c1 = p.charCodeAt(1);
-	if (c1 === CHAR_COLON) {
-		const c2 = p.charCodeAt(2);
-		if (
-			(c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) &&
-			((c0 >= CHAR_A && c0 <= CHAR_Z) ||
-				(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z))
-		) {
-			return PathType.AbsoluteWin;
 		}
-	}
-	return PathType.Normal;
+	});
+
+	return count;
 };
-exports.getType = getType;
 
 /**
- * @param {string} p a path
- * @returns {string} the normalized path
+ * Get next type index
+ *
+ * @param {Object} ast Module's AST
+ * @returns {t.Index} - index
  */
-const normalize = p => {
-	switch (getType(p)) {
-		case PathType.Empty:
-			return p;
-		case PathType.AbsoluteWin:
-			return winNormalize(p);
-		case PathType.Relative: {
-			const r = posixNormalize(p);
-			return getType(r) === PathType.Relative ? r : `./${r}`;
-		}
+const getNextTypeIndex = ast => {
+	const typeSectionMetadata = t.getSectionMetadata(ast, "type");
+
+	if (typeSectionMetadata === undefined) {
+		return t.indexLiteral(0);
 	}
-	return posixNormalize(p);
+
+	return t.indexLiteral(typeSectionMetadata.vectorOfSize.value);
 };
-exports.normalize = normalize;
 
 /**
- * @param {string} rootPath the root path
- * @param {string | undefined} request the request path
- * @returns {string} the joined path
+ * Get next func index
+ *
+ * The Func section metadata provide informations for implemented funcs
+ * in order to have the correct index we shift the index by number of external
+ * functions.
+ *
+ * @param {Object} ast Module's AST
+ * @param {Number} countImportedFunc number of imported funcs
+ * @returns {t.Index} - index
  */
-const join = (rootPath, request) => {
-	if (!request) return normalize(rootPath);
-	const requestType = getType(request);
-	switch (requestType) {
-		case PathType.AbsolutePosix:
-			return posixNormalize(request);
-		case PathType.AbsoluteWin:
-			return winNormalize(request);
-	}
-	switch (getType(rootPath)) {
-		case PathType.Normal:
-		case PathType.Relative:
-		case PathType.AbsolutePosix:
-			return posixNormalize(`${rootPath}/${request}`);
-		case PathType.AbsoluteWin:
-			return winNormalize(`${rootPath}\\${request}`);
-	}
-	switch (requestType) {
-		case PathType.Empty:
-			return rootPath;
-		case PathType.Relative: {
-			const r = posixNormalize(rootPath);
-			return getType(r) === PathType.Relative ? r : `./${r}`;
-		}
+const getNextFuncIndex = (ast, countImportedFunc) => {
+	const funcSectionMetadata = t.getSectionMetadata(ast, "func");
+
+	if (funcSectionMetadata === undefined) {
+		return t.indexLiteral(0 + countImportedFunc);
 	}
-	return posixNormalize(rootPath);
-};
-exports.join = join;
 
-const joinCache = new Map();
+	const vectorOfSize = funcSectionMetadata.vectorOfSize.value;
+
+	return t.indexLiteral(vectorOfSize + countImportedFunc);
+};
 
 /**
- * @param {string} rootPath the root path
- * @param {string | undefined} request the request path
- * @returns {string} the joined path
+ * Creates an init instruction for a global type
+ * @param {t.GlobalType} globalType the global type
+ * @returns {t.Instruction} init expression
  */
-const cachedJoin = (rootPath, request) => {
-	let cacheEntry;
-	let cache = joinCache.get(rootPath);
-	if (cache === undefined) {
-		joinCache.set(rootPath, (cache = new Map()));
+const createDefaultInitForGlobal = globalType => {
+	if (globalType.valtype[0] === "i") {
+		// create NumberLiteral global initializer
+		return t.objectInstruction("const", globalType.valtype, [
+			t.numberLiteralFromRaw(66)
+		]);
+	} else if (globalType.valtype[0] === "f") {
+		// create FloatLiteral global initializer
+		return t.objectInstruction("const", globalType.valtype, [
+			t.floatLiteral(66, false, false, "66")
+		]);
 	} else {
-		cacheEntry = cache.get(request);
-		if (cacheEntry !== undefined) return cacheEntry;
+		throw new Error("unknown type: " + globalType.valtype);
 	}
-	cacheEntry = join(rootPath, request);
-	cache.set(request, cacheEntry);
-	return cacheEntry;
 };
-exports.cachedJoin = cachedJoin;
 
-const checkExportsFieldTarget = relativePath => {
-	let lastNonSlashIndex = 2;
-	let slashIndex = relativePath.indexOf("/", 2);
-	let cd = 0;
+/**
+ * Rewrite the import globals:
+ * - removes the ModuleImport instruction
+ * - injects at the same offset a mutable global of the same type
+ *
+ * Since the imported globals are before the other global declarations, our
+ * indices will be preserved.
+ *
+ * Note that globals will become mutable.
+ *
+ * @param {Object} state unused state
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteImportedGlobals = state => bin => {
+	const additionalInitCode = state.additionalInitCode;
+	const newGlobals = [];
 
-	while (slashIndex !== -1) {
-		const folder = relativePath.slice(lastNonSlashIndex, slashIndex);
+	bin = editWithAST(state.ast, bin, {
+		ModuleImport(path) {
+			if (t.isGlobalType(path.node.descr)) {
+				const globalType = path.node.descr;
 
-		switch (folder) {
-			case "..": {
-				cd--;
-				if (cd < 0)
-					return new Error(
-						`Trying to access out of package scope. Requesting ${relativePath}`
-					);
-				break;
+				globalType.mutability = "var";
+
+				const init = [
+					createDefaultInitForGlobal(globalType),
+					t.instruction("end")
+				];
+
+				newGlobals.push(t.global(globalType, init));
+
+				path.remove();
 			}
-			default:
-				cd++;
-				break;
+		},
+
+		// in order to preserve non-imported global's order we need to re-inject
+		// those as well
+		Global(path) {
+			const { node } = path;
+			const [init] = node.init;
+
+			if (init.id === "get_global") {
+				node.globalType.mutability = "var";
+
+				const initialGlobalIdx = init.args[0];
+
+				node.init = [
+					createDefaultInitForGlobal(node.globalType),
+					t.instruction("end")
+				];
+
+				additionalInitCode.push(
+					/**
+					 * get_global in global initializer only works for imported globals.
+					 * They have the same indices as the init params, so use the
+					 * same index.
+					 */
+					t.instruction("get_local", [initialGlobalIdx]),
+					t.instruction("set_global", [t.indexLiteral(newGlobals.length)])
+				);
+			}
+
+			newGlobals.push(node);
+
+			path.remove();
 		}
+	});
 
-		lastNonSlashIndex = slashIndex + 1;
-		slashIndex = relativePath.indexOf("/", lastNonSlashIndex);
-	}
+	// Add global declaration instructions
+	return addWithAST(state.ast, bin, newGlobals);
 };
-exports.checkExportsFieldTarget = checkExportsFieldTarget;
 
+/**
+ * Rewrite the export names
+ * @param {Object} state state
+ * @param {Object} state.ast Module's ast
+ * @param {Module} state.module Module
+ * @param {ModuleGraph} state.moduleGraph module graph
+ * @param {Set<string>} state.externalExports Module
+ * @param {RuntimeSpec} state.runtime runtime
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteExportNames =
+	({ ast, moduleGraph, module, externalExports, runtime }) =>
+	bin => {
+		return editWithAST(ast, bin, {
+			ModuleExport(path) {
+				const isExternal = externalExports.has(path.node.name);
+				if (isExternal) {
+					path.remove();
+					return;
+				}
+				const usedName = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName(path.node.name, runtime);
+				if (!usedName) {
+					path.remove();
+					return;
+				}
+				path.node.name = usedName;
+			}
+		});
+	};
 
-/***/ }),
+/**
+ * Mangle import names and modules
+ * @param {Object} state state
+ * @param {Object} state.ast Module's ast
+ * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteImports =
+	({ ast, usedDependencyMap }) =>
+	bin => {
+		return editWithAST(ast, bin, {
+			ModuleImport(path) {
+				const result = usedDependencyMap.get(
+					path.node.module + ":" + path.node.name
+				);
 
-/***/ 39102:
-/***/ (function(module) {
+				if (result !== undefined) {
+					path.node.module = result.module;
+					path.node.name = result.name;
+				}
+			}
+		});
+	};
 
-"use strict";
+/**
+ * Add an init function.
+ *
+ * The init function fills the globals given input arguments.
+ *
+ * @param {Object} state transformation state
+ * @param {Object} state.ast Module's ast
+ * @param {t.Identifier} state.initFuncId identifier of the init function
+ * @param {t.Index} state.startAtFuncOffset index of the start function
+ * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
+ * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
+ * @param {t.Index} state.nextFuncIndex index of the next function
+ * @param {t.Index} state.nextTypeIndex index of the next type
+ * @returns {ArrayBufferTransform} transform
+ */
+const addInitFunction =
+	({
+		ast,
+		initFuncId,
+		startAtFuncOffset,
+		importedGlobals,
+		additionalInitCode,
+		nextFuncIndex,
+		nextTypeIndex
+	}) =>
+	bin => {
+		const funcParams = importedGlobals.map(importedGlobal => {
+			// used for debugging
+			const id = t.identifier(
+				`${importedGlobal.module}.${importedGlobal.name}`
+			);
 
+			return t.funcParam(importedGlobal.descr.valtype, id);
+		});
 
-class LoadingLoaderError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "LoaderRunnerError";
-		Error.captureStackTrace(this, this.constructor);
-	}
-}
+		const funcBody = [];
+		importedGlobals.forEach((importedGlobal, index) => {
+			const args = [t.indexLiteral(index)];
+			const body = [
+				t.instruction("get_local", args),
+				t.instruction("set_global", args)
+			];
 
-module.exports = LoadingLoaderError;
+			funcBody.push(...body);
+		});
 
+		if (typeof startAtFuncOffset === "number") {
+			funcBody.push(
+				t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset))
+			);
+		}
 
-/***/ }),
+		for (const instr of additionalInitCode) {
+			funcBody.push(instr);
+		}
 
-/***/ 8255:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+		funcBody.push(t.instruction("end"));
 
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-var fs = __webpack_require__(57147);
-var readFile = fs.readFile.bind(fs);
-var loadLoader = __webpack_require__(44690);
+		const funcResults = [];
 
-function utf8BufferToString(buf) {
-	var str = buf.toString("utf-8");
-	if(str.charCodeAt(0) === 0xFEFF) {
-		return str.substr(1);
-	} else {
-		return str;
-	}
-}
+		// Code section
+		const funcSignature = t.signature(funcParams, funcResults);
+		const func = t.func(initFuncId, funcSignature, funcBody);
 
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+		// Type section
+		const functype = t.typeInstruction(undefined, funcSignature);
+
+		// Func section
+		const funcindex = t.indexInFuncSection(nextTypeIndex);
+
+		// Export section
+		const moduleExport = t.moduleExport(
+			initFuncId.value,
+			t.moduleExportDescr("Func", nextFuncIndex)
+		);
+
+		return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
+	};
 
 /**
- * @param {string} str the path with query and fragment
- * @returns {{ path: string, query: string, fragment: string }} parsed parts
+ * Extract mangle mappings from module
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Module} module current module
+ * @param {boolean} mangle mangle imports
+ * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
  */
-function parsePathQueryFragment(str) {
-	var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-	return {
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		fragment: match[3] || ""
-	};
-}
+const getUsedDependencyMap = (moduleGraph, module, mangle) => {
+	/** @type {Map<string, UsedWasmDependency>} */
+	const map = new Map();
+	for (const usedDep of WebAssemblyUtils.getUsedDependencies(
+		moduleGraph,
+		module,
+		mangle
+	)) {
+		const dep = usedDep.dependency;
+		const request = dep.request;
+		const exportName = dep.name;
+		map.set(request + ":" + exportName, usedDep);
+	}
+	return map;
+};
 
-function dirname(path) {
-	if(path === "/") return "/";
-	var i = path.lastIndexOf("/");
-	var j = path.lastIndexOf("\\");
-	var i2 = path.indexOf("/");
-	var j2 = path.indexOf("\\");
-	var idx = i > j ? i : j;
-	var idx2 = i > j ? i2 : j2;
-	if(idx < 0) return path;
-	if(idx === idx2) return path.substr(0, idx + 1);
-	return path.substr(0, idx);
-}
+const TYPES = new Set(["webassembly"]);
 
-function createLoaderObject(loader) {
-	var obj = {
-		path: null,
-		query: null,
-		fragment: null,
-		options: null,
-		ident: null,
-		normal: null,
-		pitch: null,
-		raw: null,
-		data: null,
-		pitchExecuted: false,
-		normalExecuted: false
-	};
-	Object.defineProperty(obj, "request", {
-		enumerable: true,
-		get: function() {
-			return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
-		},
-		set: function(value) {
-			if(typeof value === "string") {
-				var splittedRequest = parsePathQueryFragment(value);
-				obj.path = splittedRequest.path;
-				obj.query = splittedRequest.query;
-				obj.fragment = splittedRequest.fragment;
-				obj.options = undefined;
-				obj.ident = undefined;
-			} else {
-				if(!value.loader)
-					throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
-				obj.path = value.loader;
-				obj.fragment = value.fragment || "";
-				obj.type = value.type;
-				obj.options = value.options;
-				obj.ident = value.ident;
-				if(obj.options === null)
-					obj.query = "";
-				else if(obj.options === undefined)
-					obj.query = "";
-				else if(typeof obj.options === "string")
-					obj.query = "?" + obj.options;
-				else if(obj.ident)
-					obj.query = "??" + obj.ident;
-				else if(typeof obj.options === "object" && obj.options.ident)
-					obj.query = "??" + obj.options.ident;
-				else
-					obj.query = "?" + JSON.stringify(obj.options);
-			}
-		}
-	});
-	obj.request = loader;
-	if(Object.preventExtensions) {
-		Object.preventExtensions(obj);
+class WebAssemblyGenerator extends Generator {
+	constructor(options) {
+		super();
+		this.options = options;
 	}
-	return obj;
-}
 
-function runSyncOrAsync(fn, context, args, callback) {
-	var isSync = true;
-	var isDone = false;
-	var isError = false; // internal error
-	var reportedError = false;
-	context.async = function async() {
-		if(isDone) {
-			if(reportedError) return; // ignore
-			throw new Error("async(): The callback was already called.");
-		}
-		isSync = false;
-		return innerCallback;
-	};
-	var innerCallback = context.callback = function() {
-		if(isDone) {
-			if(reportedError) return; // ignore
-			throw new Error("callback(): The callback was already called.");
-		}
-		isDone = true;
-		isSync = false;
-		try {
-			callback.apply(null, arguments);
-		} catch(e) {
-			isError = true;
-			throw e;
-		}
-	};
-	try {
-		var result = (function LOADER_EXECUTION() {
-			return fn.apply(context, args);
-		}());
-		if(isSync) {
-			isDone = true;
-			if(result === undefined)
-				return callback();
-			if(result && typeof result === "object" && typeof result.then === "function") {
-				return result.then(function(r) {
-					callback(null, r);
-				}, callback);
-			}
-			return callback(null, result);
-		}
-	} catch(e) {
-		if(isError) throw e;
-		if(isDone) {
-			// loader is already "done", so we cannot use the callback function
-			// for better debugging we print the error on the console
-			if(typeof e === "object" && e.stack) console.error(e.stack);
-			else console.error(e);
-			return;
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 0;
 		}
-		isDone = true;
-		reportedError = true;
-		callback(e);
+		return originalSource.size();
 	}
 
-}
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, { moduleGraph, runtime }) {
+		const bin = module.originalSource().source();
+
+		const initFuncId = t.identifier("");
+
+		// parse it
+		const ast = decode(bin, {
+			ignoreDataSection: true,
+			ignoreCodeSection: true,
+			ignoreCustomNameSection: true
+		});
+
+		const moduleContext = moduleContextFromModuleAST(ast.body[0]);
+
+		const importedGlobals = getImportedGlobals(ast);
+		const countImportedFunc = getCountImportedFunc(ast);
+		const startAtFuncOffset = moduleContext.getStart();
+		const nextFuncIndex = getNextFuncIndex(ast, countImportedFunc);
+		const nextTypeIndex = getNextTypeIndex(ast);
+
+		const usedDependencyMap = getUsedDependencyMap(
+			moduleGraph,
+			module,
+			this.options.mangleImports
+		);
+		const externalExports = new Set(
+			module.dependencies
+				.filter(d => d instanceof WebAssemblyExportImportedDependency)
+				.map(d => {
+					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (
+						d
+					);
+					return wasmDep.exportName;
+				})
+		);
+
+		/** @type {t.Instruction[]} */
+		const additionalInitCode = [];
+
+		const transform = compose(
+			rewriteExportNames({
+				ast,
+				moduleGraph,
+				module,
+				externalExports,
+				runtime
+			}),
+
+			removeStartFunc({ ast }),
+
+			rewriteImportedGlobals({ ast, additionalInitCode }),
+
+			rewriteImports({
+				ast,
+				usedDependencyMap
+			}),
+
+			addInitFunction({
+				ast,
+				initFuncId,
+				importedGlobals,
+				additionalInitCode,
+				startAtFuncOffset,
+				nextFuncIndex,
+				nextTypeIndex
+			})
+		);
+
+		const newBin = transform(bin);
 
-function convertArgs(args, raw) {
-	if(!raw && Buffer.isBuffer(args[0]))
-		args[0] = utf8BufferToString(args[0]);
-	else if(raw && typeof args[0] === "string")
-		args[0] = Buffer.from(args[0], "utf-8");
+		const newBuf = Buffer.from(newBin);
+
+		return new RawSource(newBuf);
+	}
 }
 
-function iteratePitchingLoaders(options, loaderContext, callback) {
-	// abort after last loader
-	if(loaderContext.loaderIndex >= loaderContext.loaders.length)
-		return processResource(options, loaderContext, callback);
+module.exports = WebAssemblyGenerator;
 
-	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
 
-	// iterate
-	if(currentLoaderObject.pitchExecuted) {
-		loaderContext.loaderIndex++;
-		return iteratePitchingLoaders(options, loaderContext, callback);
-	}
+/***/ }),
 
-	// load loader module
-	loadLoader(currentLoaderObject, function(err) {
-		if(err) {
-			loaderContext.cacheable(false);
-			return callback(err);
-		}
-		var fn = currentLoaderObject.pitch;
-		currentLoaderObject.pitchExecuted = true;
-		if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
+/***/ 47342:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		runSyncOrAsync(
-			fn,
-			loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
-			function(err) {
-				if(err) return callback(err);
-				var args = Array.prototype.slice.call(arguments, 1);
-				// Determine whether to continue the pitching process based on
-				// argument values (as opposed to argument presence) in order
-				// to support synchronous and asynchronous usages.
-				var hasArg = args.some(function(value) {
-					return value !== undefined;
-				});
-				if(hasArg) {
-					loaderContext.loaderIndex--;
-					iterateNormalLoaders(options, loaderContext, args, callback);
-				} else {
-					iteratePitchingLoaders(options, loaderContext, callback);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+
+/**
+ * @param {Module} module module to get chains from
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {RequestShortener} requestShortener to make readable identifiers
+ * @returns {string[]} all chains to the module
+ */
+const getInitialModuleChains = (
+	module,
+	moduleGraph,
+	chunkGraph,
+	requestShortener
+) => {
+	const queue = [
+		{ head: module, message: module.readableIdentifier(requestShortener) }
+	];
+	/** @type {Set<string>} */
+	const results = new Set();
+	/** @type {Set<string>} */
+	const incompleteResults = new Set();
+	/** @type {Set<Module>} */
+	const visitedModules = new Set();
+
+	for (const chain of queue) {
+		const { head, message } = chain;
+		let final = true;
+		/** @type {Set<Module>} */
+		const alreadyReferencedModules = new Set();
+		for (const connection of moduleGraph.getIncomingConnections(head)) {
+			const newHead = connection.originModule;
+			if (newHead) {
+				if (!chunkGraph.getModuleChunks(newHead).some(c => c.canBeInitial()))
+					continue;
+				final = false;
+				if (alreadyReferencedModules.has(newHead)) continue;
+				alreadyReferencedModules.add(newHead);
+				const moduleName = newHead.readableIdentifier(requestShortener);
+				const detail = connection.explanation
+					? ` (${connection.explanation})`
+					: "";
+				const newMessage = `${moduleName}${detail} --> ${message}`;
+				if (visitedModules.has(newHead)) {
+					incompleteResults.add(`... --> ${newMessage}`);
+					continue;
 				}
+				visitedModules.add(newHead);
+				queue.push({
+					head: newHead,
+					message: newMessage
+				});
+			} else {
+				final = false;
+				const newMessage = connection.explanation
+					? `(${connection.explanation}) --> ${message}`
+					: message;
+				results.add(newMessage);
 			}
-		);
-	});
-}
+		}
+		if (final) {
+			results.add(message);
+		}
+	}
+	for (const result of incompleteResults) {
+		results.add(result);
+	}
+	return Array.from(results);
+};
 
-function processResource(options, loaderContext, callback) {
-	// set loader index to last loader
-	loaderContext.loaderIndex = loaderContext.loaders.length - 1;
+module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
+	/**
+	 * @param {Module} module WASM module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RequestShortener} requestShortener request shortener
+	 */
+	constructor(module, moduleGraph, chunkGraph, requestShortener) {
+		const moduleChains = getInitialModuleChains(
+			module,
+			moduleGraph,
+			chunkGraph,
+			requestShortener
+		);
+		const message = `WebAssembly module is included in initial chunk.
+This is not allowed, because WebAssembly download and compilation must happen asynchronous.
+Add an async split point (i. e. import()) somewhere between your entrypoint and the WebAssembly module:
+${moduleChains.map(s => `* ${s}`).join("\n")}`;
 
-	var resourcePath = loaderContext.resourcePath;
-	if(resourcePath) {
-		options.processResource(loaderContext, resourcePath, function(err, buffer) {
-			if(err) return callback(err);
-			options.resourceBuffer = buffer;
-			iterateNormalLoaders(options, loaderContext, [buffer], callback);
-		});
-	} else {
-		iterateNormalLoaders(options, loaderContext, [null], callback);
+		super(message);
+		this.name = "WebAssemblyInInitialChunkError";
+		this.hideStack = true;
+		this.module = module;
 	}
-}
+};
 
-function iterateNormalLoaders(options, loaderContext, args, callback) {
-	if(loaderContext.loaderIndex < 0)
-		return callback(null, args);
 
-	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+/***/ }),
 
-	// iterate
-	if(currentLoaderObject.normalExecuted) {
-		loaderContext.loaderIndex--;
-		return iterateNormalLoaders(options, loaderContext, args, callback);
-	}
+/***/ 46545:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	var fn = currentLoaderObject.normal;
-	currentLoaderObject.normalExecuted = true;
-	if(!fn) {
-		return iterateNormalLoaders(options, loaderContext, args, callback);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	convertArgs(args, currentLoaderObject.raw);
 
-	runSyncOrAsync(fn, loaderContext, args, function(err) {
-		if(err) return callback(err);
 
-		var args = Array.prototype.slice.call(arguments, 1);
-		iterateNormalLoaders(options, loaderContext, args, callback);
-	});
-}
+const { RawSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(39722);
+const ModuleDependency = __webpack_require__(80321);
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-exports.getContext = function getContext(resource) {
-	var path = parsePathQueryFragment(resource).path;
-	return dirname(path);
-};
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
-exports.runLoaders = function runLoaders(options, callback) {
-	// read options
-	var resource = options.resource || "";
-	var loaders = options.loaders || [];
-	var loaderContext = options.context || {};
-	var processResource = options.processResource || ((readResource, context, resource, callback) => {
-		context.addDependency(resource);
-		readResource(resource, callback);
-	}).bind(null, options.readResource || readFile);
+const TYPES = new Set(["webassembly"]);
 
-	//
-	var splittedResource = resource && parsePathQueryFragment(resource);
-	var resourcePath = splittedResource ? splittedResource.path : undefined;
-	var resourceQuery = splittedResource ? splittedResource.query : undefined;
-	var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
-	var contextDirectory = resourcePath ? dirname(resourcePath) : null;
+class WebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
 
-	// execution state
-	var requestCacheable = true;
-	var fileDependencies = [];
-	var contextDependencies = [];
-	var missingDependencies = [];
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 95 + module.dependencies.length * 5;
+	}
 
-	// prepare loader objects
-	loaders = loaders.map(createLoaderObject);
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		const {
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime
+		} = generateContext;
+		/** @type {InitFragment[]} */
+		const initFragments = [];
 
-	loaderContext.context = contextDirectory;
-	loaderContext.loaderIndex = 0;
-	loaderContext.loaders = loaders;
-	loaderContext.resourcePath = resourcePath;
-	loaderContext.resourceQuery = resourceQuery;
-	loaderContext.resourceFragment = resourceFragment;
-	loaderContext.async = null;
-	loaderContext.callback = null;
-	loaderContext.cacheable = function cacheable(flag) {
-		if(flag === false) {
-			requestCacheable = false;
-		}
-	};
-	loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
-		fileDependencies.push(file);
-	};
-	loaderContext.addContextDependency = function addContextDependency(context) {
-		contextDependencies.push(context);
-	};
-	loaderContext.addMissingDependency = function addMissingDependency(context) {
-		missingDependencies.push(context);
-	};
-	loaderContext.getDependencies = function getDependencies() {
-		return fileDependencies.slice();
-	};
-	loaderContext.getContextDependencies = function getContextDependencies() {
-		return contextDependencies.slice();
-	};
-	loaderContext.getMissingDependencies = function getMissingDependencies() {
-		return missingDependencies.slice();
-	};
-	loaderContext.clearDependencies = function clearDependencies() {
-		fileDependencies.length = 0;
-		contextDependencies.length = 0;
-		missingDependencies.length = 0;
-		requestCacheable = true;
-	};
-	Object.defineProperty(loaderContext, "resource", {
-		enumerable: true,
-		get: function() {
-			if(loaderContext.resourcePath === undefined)
-				return undefined;
-			return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
-		},
-		set: function(value) {
-			var splittedResource = value && parsePathQueryFragment(value);
-			loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
-			loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
-			loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
-		}
-	});
-	Object.defineProperty(loaderContext, "request", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders.map(function(o) {
-				return o.request;
-			}).concat(loaderContext.resource || "").join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "remainingRequest", {
-		enumerable: true,
-		get: function() {
-			if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
-				return "";
-			return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
-				return o.request;
-			}).concat(loaderContext.resource || "").join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "currentRequest", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
-				return o.request;
-			}).concat(loaderContext.resource || "").join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "previousRequest", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
-				return o.request;
-			}).join("!");
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+
+		let needExportsCopy = false;
+		const importedModules = new Map();
+		const initParams = [];
+		let index = 0;
+		for (const dep of module.dependencies) {
+			const moduleDep =
+				dep && dep instanceof ModuleDependency ? dep : undefined;
+			if (moduleGraph.getModule(dep)) {
+				let importData = importedModules.get(moduleGraph.getModule(dep));
+				if (importData === undefined) {
+					importedModules.set(
+						moduleGraph.getModule(dep),
+						(importData = {
+							importVar: `m${index}`,
+							index,
+							request: (moduleDep && moduleDep.userRequest) || undefined,
+							names: new Set(),
+							reexports: []
+						})
+					);
+					index++;
+				}
+				if (dep instanceof WebAssemblyImportDependency) {
+					importData.names.add(dep.name);
+					if (dep.description.type === "GlobalType") {
+						const exportName = dep.name;
+						const importedModule = moduleGraph.getModule(dep);
+
+						if (importedModule) {
+							const usedName = moduleGraph
+								.getExportsInfo(importedModule)
+								.getUsedName(exportName, runtime);
+							if (usedName) {
+								initParams.push(
+									runtimeTemplate.exportFromImport({
+										moduleGraph,
+										module: importedModule,
+										request: dep.request,
+										importVar: importData.importVar,
+										originModule: module,
+										exportName: dep.name,
+										asiSafe: true,
+										isCall: false,
+										callContext: null,
+										defaultInterop: true,
+										initFragments,
+										runtime,
+										runtimeRequirements
+									})
+								);
+							}
+						}
+					}
+				}
+				if (dep instanceof WebAssemblyExportImportedDependency) {
+					importData.names.add(dep.name);
+					const usedName = moduleGraph
+						.getExportsInfo(module)
+						.getUsedName(dep.exportName, runtime);
+					if (usedName) {
+						runtimeRequirements.add(RuntimeGlobals.exports);
+						const exportProp = `${module.exportsArgument}[${JSON.stringify(
+							usedName
+						)}]`;
+						const defineStatement = Template.asString([
+							`${exportProp} = ${runtimeTemplate.exportFromImport({
+								moduleGraph,
+								module: moduleGraph.getModule(dep),
+								request: dep.request,
+								importVar: importData.importVar,
+								originModule: module,
+								exportName: dep.name,
+								asiSafe: true,
+								isCall: false,
+								callContext: null,
+								defaultInterop: true,
+								initFragments,
+								runtime,
+								runtimeRequirements
+							})};`,
+							`if(WebAssembly.Global) ${exportProp} = ` +
+								`new WebAssembly.Global({ value: ${JSON.stringify(
+									dep.valueType
+								)} }, ${exportProp});`
+						]);
+						importData.reexports.push(defineStatement);
+						needExportsCopy = true;
+					}
+				}
+			}
 		}
-	});
-	Object.defineProperty(loaderContext, "query", {
-		enumerable: true,
-		get: function() {
-			var entry = loaderContext.loaders[loaderContext.loaderIndex];
-			return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
+		const importsCode = Template.asString(
+			Array.from(
+				importedModules,
+				([module, { importVar, request, reexports }]) => {
+					const importStatement = runtimeTemplate.importStatement({
+						module,
+						chunkGraph,
+						request,
+						importVar,
+						originModule: module,
+						runtimeRequirements
+					});
+					return importStatement[0] + importStatement[1] + reexports.join("\n");
+				}
+			)
+		);
+
+		const copyAllExports =
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused &&
+			!needExportsCopy;
+
+		// need these globals
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.wasmInstances);
+		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+			runtimeRequirements.add(RuntimeGlobals.exports);
 		}
-	});
-	Object.defineProperty(loaderContext, "data", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders[loaderContext.loaderIndex].data;
+		if (!copyAllExports) {
+			runtimeRequirements.add(RuntimeGlobals.exports);
 		}
-	});
 
-	// finish loader context
-	if(Object.preventExtensions) {
-		Object.preventExtensions(loaderContext);
+		// create source
+		const source = new RawSource(
+			[
+				'"use strict";',
+				"// Instantiate WebAssembly module",
+				`var wasmExports = ${RuntimeGlobals.wasmInstances}[${module.moduleArgument}.id];`,
+
+				exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused
+					? `${RuntimeGlobals.makeNamespaceObject}(${module.exportsArgument});`
+					: "",
+
+				// this must be before import for circular dependencies
+				"// export exports from WebAssembly module",
+				copyAllExports
+					? `${module.moduleArgument}.exports = wasmExports;`
+					: "for(var name in wasmExports) " +
+					  `if(name) ` +
+					  `${module.exportsArgument}[name] = wasmExports[name];`,
+				"// exec imports from WebAssembly module (for esm order)",
+				importsCode,
+				"",
+				"// exec wasm module",
+				`wasmExports[""](${initParams.join(", ")})`
+			].join("\n")
+		);
+		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
+}
 
-	var processOptions = {
-		resourceBuffer: null,
-		processResource: processResource
-	};
-	iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
-		if(err) {
-			return callback(err, {
-				cacheable: requestCacheable,
-				fileDependencies: fileDependencies,
-				contextDependencies: contextDependencies,
-				missingDependencies: missingDependencies
-			});
-		}
-		callback(null, {
-			result: result,
-			resourceBuffer: processOptions.resourceBuffer,
-			cacheable: requestCacheable,
-			fileDependencies: fileDependencies,
-			contextDependencies: contextDependencies,
-			missingDependencies: missingDependencies
-		});
-	});
-};
+module.exports = WebAssemblyJavascriptGenerator;
 
 
 /***/ }),
 
-/***/ 44690:
+/***/ 53639:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-var LoaderLoadingError = __webpack_require__(39102);
-var url;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-module.exports = function loadLoader(loader, callback) {
-	if(loader.type === "module") {
-		try {
-			if(url === undefined) url = __webpack_require__(57310);
-			var loaderUrl = url.pathToFileURL(loader.path);
-			var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
-			modulePromise.then(function(module) {
-				handleResult(loader, module, callback);
-			}, callback);
-			return;
-		} catch(e) {
-			callback(e);
-		}
-	} else {
-		try {
-			var module = require(loader.path);
-		} catch(e) {
-			// it is possible for node to choke on a require if the FD descriptor
-			// limit has been reached. give it a chance to recover.
-			if(e instanceof Error && e.code === "EMFILE") {
-				var retry = loadLoader.bind(null, loader, callback);
-				if(typeof setImmediate === "function") {
-					// node >= 0.9.0
-					return setImmediate(retry);
-				} else {
-					// node < 0.9.0
-					return process.nextTick(retry);
-				}
-			}
-			return callback(e);
-		}
-		return handleResult(loader, module, callback);
-	}
-};
 
-function handleResult(loader, module, callback) {
-	if(typeof module !== "function" && typeof module !== "object") {
-		return callback(new LoaderLoadingError(
-			"Module '" + loader.path + "' is not a loader (export function or es6 module)"
-		));
-	}
-	loader.normal = typeof module === "function" ? module : module.default;
-	loader.pitch = module.pitch;
-	loader.raw = module.raw;
-	if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
-		return callback(new LoaderLoadingError(
-			"Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
-		));
-	}
-	callback();
-}
 
+const Generator = __webpack_require__(93401);
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const memoize = __webpack_require__(78676);
+const WebAssemblyInInitialChunkError = __webpack_require__(47342);
 
-/***/ }),
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
-/***/ 50569:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const getWebAssemblyGenerator = memoize(() =>
+	__webpack_require__(47012)
+);
+const getWebAssemblyJavascriptGenerator = memoize(() =>
+	__webpack_require__(46545)
+);
+const getWebAssemblyParser = memoize(() => __webpack_require__(57059));
 
-/*!
- * mime-db
- * Copyright(c) 2014 Jonathan Ong
- * MIT Licensed
- */
+class WebAssemblyModulesPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-/**
- * Module exports.
- */
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WebAssemblyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebAssemblyImportDependency,
+					normalModuleFactory
+				);
 
-module.exports = __webpack_require__(58750)
+				compilation.dependencyFactories.set(
+					WebAssemblyExportImportedDependency,
+					normalModuleFactory
+				);
 
+				normalModuleFactory.hooks.createParser
+					.for("webassembly/sync")
+					.tap("WebAssemblyModulesPlugin", () => {
+						const WebAssemblyParser = getWebAssemblyParser();
 
-/***/ }),
+						return new WebAssemblyParser();
+					});
 
-/***/ 78585:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+				normalModuleFactory.hooks.createGenerator
+					.for("webassembly/sync")
+					.tap("WebAssemblyModulesPlugin", () => {
+						const WebAssemblyJavascriptGenerator =
+							getWebAssemblyJavascriptGenerator();
+						const WebAssemblyGenerator = getWebAssemblyGenerator();
 
-"use strict";
-/*!
- * mime-types
- * Copyright(c) 2014 Jonathan Ong
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
+						return Generator.byType({
+							javascript: new WebAssemblyJavascriptGenerator(),
+							webassembly: new WebAssemblyGenerator(this.options)
+						});
+					});
 
+				compilation.hooks.renderManifest.tap(
+					"WebAssemblyModulesPlugin",
+					(result, options) => {
+						const { chunkGraph } = compilation;
+						const { chunk, outputOptions, codeGenerationResults } = options;
 
+						for (const module of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesByIdentifier
+						)) {
+							if (module.type === "webassembly/sync") {
+								const filenameTemplate =
+									outputOptions.webassemblyModuleFilename;
 
-/**
- * Module dependencies.
- * @private
- */
+								result.push({
+									render: () =>
+										codeGenerationResults.getSource(
+											module,
+											chunk.runtime,
+											"webassembly"
+										),
+									filenameTemplate,
+									pathOptions: {
+										module,
+										runtime: chunk.runtime,
+										chunkGraph
+									},
+									auxiliary: true,
+									identifier: `webassemblyModule${chunkGraph.getModuleId(
+										module
+									)}`,
+									hash: chunkGraph.getModuleHash(module, chunk.runtime)
+								});
+							}
+						}
 
-var db = __webpack_require__(50569)
-var extname = (__webpack_require__(71017).extname)
+						return result;
+					}
+				);
 
-/**
- * Module variables.
- * @private
- */
+				compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
+					const chunkGraph = compilation.chunkGraph;
+					const initialWasmModules = new Set();
+					for (const chunk of compilation.chunks) {
+						if (chunk.canBeInitial()) {
+							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+								if (module.type === "webassembly/sync") {
+									initialWasmModules.add(module);
+								}
+							}
+						}
+					}
+					for (const module of initialWasmModules) {
+						compilation.errors.push(
+							new WebAssemblyInInitialChunkError(
+								module,
+								compilation.moduleGraph,
+								compilation.chunkGraph,
+								compilation.requestShortener
+							)
+						);
+					}
+				});
+			}
+		);
+	}
+}
 
-var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
-var TEXT_TYPE_REGEXP = /^text\//i
+module.exports = WebAssemblyModulesPlugin;
 
-/**
- * Module exports.
- * @public
- */
 
-exports.charset = charset
-exports.charsets = { lookup: charset }
-exports.contentType = contentType
-exports.extension = extension
-exports.extensions = Object.create(null)
-exports.lookup = lookup
-exports.types = Object.create(null)
+/***/ }),
 
-// Populate the extensions/types maps
-populateMaps(exports.extensions, exports.types)
+/***/ 57059:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * Get the default charset for a MIME type.
- *
- * @param {string} type
- * @return {boolean|string}
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-function charset (type) {
-  if (!type || typeof type !== 'string') {
-    return false
-  }
 
-  // TODO: use media-typer
-  var match = EXTRACT_TYPE_REGEXP.exec(type)
-  var mime = match && db[match[1].toLowerCase()]
 
-  if (mime && mime.charset) {
-    return mime.charset
-  }
+const t = __webpack_require__(51826);
+const { moduleContextFromModuleAST } = __webpack_require__(51826);
+const { decode } = __webpack_require__(73726);
+const Parser = __webpack_require__(11715);
+const StaticExportsDependency = __webpack_require__(91418);
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-  // default text/* to utf-8
-  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
-    return 'UTF-8'
-  }
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-  return false
-}
+const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
 
 /**
- * Create a full Content-Type header given a MIME type or extension.
- *
- * @param {string} str
- * @return {boolean|string}
+ * @param {t.Signature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
  */
+const getJsIncompatibleType = signature => {
+	for (const param of signature.params) {
+		if (!JS_COMPAT_TYPES.has(param.valtype)) {
+			return `${param.valtype} as parameter`;
+		}
+	}
+	for (const type of signature.results) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
+};
 
-function contentType (str) {
-  // TODO: should this even be in this module?
-  if (!str || typeof str !== 'string') {
-    return false
-  }
+/**
+ * TODO why are there two different Signature types?
+ * @param {t.FuncSignature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
+ */
+const getJsIncompatibleTypeOfFuncSignature = signature => {
+	for (const param of signature.args) {
+		if (!JS_COMPAT_TYPES.has(param)) {
+			return `${param} as parameter`;
+		}
+	}
+	for (const type of signature.result) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
+};
 
-  var mime = str.indexOf('/') === -1
-    ? exports.lookup(str)
-    : str
+const decoderOpts = {
+	ignoreCodeSection: true,
+	ignoreDataSection: true,
 
-  if (!mime) {
-    return false
-  }
+	// this will avoid having to lookup with identifiers in the ModuleContext
+	ignoreCustomNameSection: true
+};
 
-  // TODO: use content-type or other module
-  if (mime.indexOf('charset') === -1) {
-    var charset = exports.charset(mime)
-    if (charset) mime += '; charset=' + charset.toLowerCase()
-  }
+class WebAssemblyParser extends Parser {
+	constructor(options) {
+		super();
+		this.hooks = Object.freeze({});
+		this.options = options;
+	}
 
-  return mime
-}
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (!Buffer.isBuffer(source)) {
+			throw new Error("WebAssemblyParser input must be a Buffer");
+		}
 
-/**
- * Get the default extension for a MIME type.
- *
- * @param {string} type
- * @return {boolean|string}
- */
+		// flag it as ESM
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "namespace";
 
-function extension (type) {
-  if (!type || typeof type !== 'string') {
-    return false
-  }
+		// parse it
+		const program = decode(source, decoderOpts);
+		const module = program.body[0];
 
-  // TODO: use media-typer
-  var match = EXTRACT_TYPE_REGEXP.exec(type)
+		const moduleContext = moduleContextFromModuleAST(module);
 
-  // get extensions
-  var exts = match && exports.extensions[match[1].toLowerCase()]
+		// extract imports and exports
+		const exports = [];
+		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
+			undefined);
 
-  if (!exts || !exts.length) {
-    return false
-  }
+		const importedGlobals = [];
+		t.traverse(module, {
+			ModuleExport({ node }) {
+				const descriptor = node.descr;
 
-  return exts[0]
-}
+				if (descriptor.exportType === "Func") {
+					const funcIdx = descriptor.id.value;
 
-/**
- * Lookup the MIME type for a file path/extension.
- *
- * @param {string} path
- * @return {boolean|string}
- */
+					/** @type {t.FuncSignature} */
+					const funcSignature = moduleContext.getFunction(funcIdx);
 
-function lookup (path) {
-  if (!path || typeof path !== 'string') {
-    return false
-  }
+					const incompatibleType =
+						getJsIncompatibleTypeOfFuncSignature(funcSignature);
 
-  // get the extension ("ext" or ".ext" or full path)
-  var extension = extname('x.' + path)
-    .toLowerCase()
-    .substr(1)
+					if (incompatibleType) {
+						if (jsIncompatibleExports === undefined) {
+							jsIncompatibleExports =
+								state.module.buildMeta.jsIncompatibleExports = {};
+						}
+						jsIncompatibleExports[node.name] = incompatibleType;
+					}
+				}
 
-  if (!extension) {
-    return false
-  }
+				exports.push(node.name);
 
-  return exports.types[extension] || false
-}
+				if (node.descr && node.descr.exportType === "Global") {
+					const refNode = importedGlobals[node.descr.id.value];
+					if (refNode) {
+						const dep = new WebAssemblyExportImportedDependency(
+							node.name,
+							refNode.module,
+							refNode.name,
+							refNode.descr.valtype
+						);
 
-/**
- * Populate the extensions and types maps.
- * @private
- */
+						state.module.addDependency(dep);
+					}
+				}
+			},
 
-function populateMaps (extensions, types) {
-  // source preference (least -> most)
-  var preference = ['nginx', 'apache', undefined, 'iana']
+			Global({ node }) {
+				const init = node.init[0];
 
-  Object.keys(db).forEach(function forEachMimeType (type) {
-    var mime = db[type]
-    var exts = mime.extensions
+				let importNode = null;
 
-    if (!exts || !exts.length) {
-      return
-    }
+				if (init.id === "get_global") {
+					const globalIdx = init.args[0].value;
 
-    // mime -> extensions
-    extensions[type] = exts
+					if (globalIdx < importedGlobals.length) {
+						importNode = importedGlobals[globalIdx];
+					}
+				}
 
-    // extension -> mime
-    for (var i = 0; i < exts.length; i++) {
-      var extension = exts[i]
+				importedGlobals.push(importNode);
+			},
+
+			ModuleImport({ node }) {
+				/** @type {false | string} */
+				let onlyDirectImport = false;
+
+				if (t.isMemory(node.descr) === true) {
+					onlyDirectImport = "Memory";
+				} else if (t.isTable(node.descr) === true) {
+					onlyDirectImport = "Table";
+				} else if (t.isFuncImportDescr(node.descr) === true) {
+					const incompatibleType = getJsIncompatibleType(node.descr.signature);
+					if (incompatibleType) {
+						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
+					}
+				} else if (t.isGlobalType(node.descr) === true) {
+					const type = node.descr.valtype;
+					if (!JS_COMPAT_TYPES.has(type)) {
+						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
+					}
+				}
+
+				const dep = new WebAssemblyImportDependency(
+					node.module,
+					node.name,
+					node.descr,
+					onlyDirectImport
+				);
+
+				state.module.addDependency(dep);
 
-      if (types[extension]) {
-        var from = preference.indexOf(db[types[extension]].source)
-        var to = preference.indexOf(mime.source)
+				if (t.isGlobalType(node.descr)) {
+					importedGlobals.push(node);
+				}
+			}
+		});
 
-        if (types[extension] !== 'application/octet-stream' &&
-          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
-          // skip the remapping
-          continue
-        }
-      }
+		state.module.addDependency(new StaticExportsDependency(exports, false));
 
-      // set the extension -> mime
-      types[extension] = type
-    }
-  })
+		return state;
+	}
 }
 
+module.exports = WebAssemblyParser;
+
 
 /***/ }),
 
-/***/ 76297:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 18650:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -139572,90 +139249,70 @@ function populateMaps (extensions, types) {
 */
 
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
 
-class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, onDone }) {
-		let code = "";
-		code += `var _results = new Array(${this.options.taps.length});\n`;
-		code += "var _checkDone = function() {\n";
-		code += "for(var i = 0; i < _results.length; i++) {\n";
-		code += "var item = _results[i];\n";
-		code += "if(item === undefined) return false;\n";
-		code += "if(item.result !== undefined) {\n";
-		code += onResult("item.result");
-		code += "return true;\n";
-		code += "}\n";
-		code += "if(item.error) {\n";
-		code += onError("item.error");
-		code += "return true;\n";
-		code += "}\n";
-		code += "}\n";
-		code += "return false;\n";
-		code += "}\n";
-		code += this.callTapsParallel({
-			onError: (i, err, done, doneBreak) => {
-				let code = "";
-				code += `if(${i} < _results.length && ((_results.length = ${i +
-					1}), (_results[${i}] = { error: ${err} }), _checkDone())) {\n`;
-				code += doneBreak(true);
-				code += "} else {\n";
-				code += done();
-				code += "}\n";
-				return code;
-			},
-			onResult: (i, result, done, doneBreak) => {
-				let code = "";
-				code += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i +
-					1}), (_results[${i}] = { result: ${result} }), _checkDone())) {\n`;
-				code += doneBreak(true);
-				code += "} else {\n";
-				code += done();
-				code += "}\n";
-				return code;
-			},
-			onTap: (i, run, done, doneBreak) => {
-				let code = "";
-				if (i > 0) {
-					code += `if(${i} >= _results.length) {\n`;
-					code += done();
-					code += "} else {\n";
-				}
-				code += run();
-				if (i > 0) code += "}\n";
-				return code;
-			},
-			onDone
-		});
-		return code;
-	}
-}
+const Template = __webpack_require__(39722);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-const factory = new AsyncParallelBailHookCodeFactory();
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+/** @typedef {Object} UsedWasmDependency
+ * @property {WebAssemblyImportDependency} dependency the dependency
+ * @property {string} name the export name
+ * @property {string} module the module name
+ */
 
-function AsyncParallelBailHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncParallelBailHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
+const MANGLED_MODULE = "a";
 
-AsyncParallelBailHook.prototype = null;
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the module
+ * @param {boolean} mangle mangle module and export names
+ * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
+ */
+const getUsedDependencies = (moduleGraph, module, mangle) => {
+	/** @type {UsedWasmDependency[]} */
+	const array = [];
+	let importIndex = 0;
+	for (const dep of module.dependencies) {
+		if (dep instanceof WebAssemblyImportDependency) {
+			if (
+				dep.description.type === "GlobalType" ||
+				moduleGraph.getModule(dep) === null
+			) {
+				continue;
+			}
 
-module.exports = AsyncParallelBailHook;
+			const exportName = dep.name;
+			// TODO add the following 3 lines when removing of ModuleExport is possible
+			// const importedModule = moduleGraph.getModule(dep);
+			// const usedName = importedModule && moduleGraph.getExportsInfo(importedModule).getUsedName(exportName, runtime);
+			// if (usedName !== false) {
+			if (mangle) {
+				array.push({
+					dependency: dep,
+					name: Template.numberToIdentifier(importIndex++),
+					module: MANGLED_MODULE
+				});
+			} else {
+				array.push({
+					dependency: dep,
+					name: exportName,
+					module: dep.request
+				});
+			}
+		}
+	}
+	return array;
+};
+
+exports.getUsedDependencies = getUsedDependencies;
+exports.MANGLED_MODULE = MANGLED_MODULE;
 
 
 /***/ }),
 
-/***/ 45874:
+/***/ 78613:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139665,92 +139322,123 @@ module.exports = AsyncParallelBailHook;
 */
 
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
 
-class AsyncParallelHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone }) {
-		return this.callTapsParallel({
-			onError: (i, err, done, doneBreak) => onError(err) + doneBreak(true),
-			onDone
-		});
-	}
-}
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
+/** @typedef {import("../Compiler")} Compiler */
 
-const factory = new AsyncParallelHookCodeFactory();
+/** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
+const enabledTypes = new WeakMap();
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
+const getEnabledTypes = compiler => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
+	}
+	return set;
 };
 
-function AsyncParallelHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncParallelHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncParallelHook.prototype = null;
-
-module.exports = AsyncParallelHook;
-
-
-/***/ }),
-
-/***/ 13633:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+class EnableWasmLoadingPlugin {
+	/**
+	 * @param {WasmLoadingType} type library type that should be available
+	 */
+	constructor(type) {
+		this.type = type;
+	}
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {WasmLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
+	}
 
-class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, resultReturns, onDone }) {
-		return this.callTapsSeries({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onResult: (i, result, next) =>
-				`if(${result} !== undefined) {\n${onResult(
-					result
-				)}\n} else {\n${next()}}\n`,
-			resultReturns,
-			onDone
-		});
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {WasmLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Library type "${type}" is not enabled. ` +
+					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
+					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
+					"These types are enabled: " +
+					Array.from(getEnabledTypes(compiler)).join(", ")
+			);
+		}
 	}
-}
 
-const factory = new AsyncSeriesBailHookCodeFactory();
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { type } = this;
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
 
-function AsyncSeriesBailHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesBailHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
+		if (typeof type === "string") {
+			switch (type) {
+				case "fetch": {
+					// TODO webpack 6 remove FetchCompileWasmPlugin
+					const FetchCompileWasmPlugin = __webpack_require__(35537);
+					const FetchCompileAsyncWasmPlugin = __webpack_require__(8437);
+					new FetchCompileWasmPlugin({
+						mangleImports: compiler.options.optimization.mangleWasmImports
+					}).apply(compiler);
+					new FetchCompileAsyncWasmPlugin().apply(compiler);
+					break;
+				}
+				case "async-node": {
+					// TODO webpack 6 remove ReadFileCompileWasmPlugin
+					const ReadFileCompileWasmPlugin = __webpack_require__(98939);
+					// @ts-expect-error typescript bug for duplicate require
+					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
+					new ReadFileCompileWasmPlugin({
+						mangleImports: compiler.options.optimization.mangleWasmImports
+					}).apply(compiler);
+					new ReadFileCompileAsyncWasmPlugin({ type }).apply(compiler);
+					break;
+				}
+				case "async-node-module": {
+					// @ts-expect-error typescript bug for duplicate require
+					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
+					new ReadFileCompileAsyncWasmPlugin({ type, import: true }).apply(
+						compiler
+					);
+					break;
+				}
+				case "universal":
+					throw new Error(
+						"Universal WebAssembly Loading is not implemented yet"
+					);
+				default:
+					throw new Error(`Unsupported wasm loading type ${type}.
+Plugins which provide custom wasm loading types must call EnableWasmLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
+			}
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
+		}
+	}
 }
 
-AsyncSeriesBailHook.prototype = null;
-
-module.exports = AsyncSeriesBailHook;
+module.exports = EnableWasmLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 40436:
+/***/ 8437:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139760,42 +139448,67 @@ module.exports = AsyncSeriesBailHook;
 */
 
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
 
-class AsyncSeriesHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone }) {
-		return this.callTapsSeries({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onDone
-		});
-	}
-}
+const RuntimeGlobals = __webpack_require__(16475);
+const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
 
-const factory = new AsyncSeriesHookCodeFactory();
+/** @typedef {import("../Compiler")} Compiler */
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+class FetchCompileAsyncWasmPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"FetchCompileAsyncWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === "fetch";
+				};
+				const generateLoadBinaryCode = path =>
+					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
-function AsyncSeriesHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.instantiateWasm)
+					.tap("FetchCompileAsyncWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/async"
+							)
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.publicPath);
+						compilation.addRuntimeModule(
+							chunk,
+							new AsyncWasmLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: true
+							})
+						);
+					});
+			}
+		);
+	}
 }
 
-AsyncSeriesHook.prototype = null;
-
-module.exports = AsyncSeriesHook;
+module.exports = FetchCompileAsyncWasmPlugin;
 
 
 /***/ }),
 
-/***/ 34656:
+/***/ 35537:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139805,42 +139518,76 @@ module.exports = AsyncSeriesHook;
 */
 
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
 
-class AsyncSeriesLoopHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone }) {
-		return this.callTapsLooping({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onDone
-		});
-	}
-}
+const RuntimeGlobals = __webpack_require__(16475);
+const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
 
-const factory = new AsyncSeriesLoopHookCodeFactory();
+/** @typedef {import("../Compiler")} Compiler */
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+// TODO webpack 6 remove
 
-function AsyncSeriesLoopHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesLoopHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
+class FetchCompileWasmPlugin {
+	constructor(options) {
+		this.options = options || {};
+	}
 
-AsyncSeriesLoopHook.prototype = null;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"FetchCompileWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === "fetch";
+				};
+				const generateLoadBinaryCode = path =>
+					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
-module.exports = AsyncSeriesLoopHook;
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("FetchCompileWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/sync"
+							)
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.publicPath);
+						compilation.addRuntimeModule(
+							chunk,
+							new WasmChunkLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: true,
+								mangleImports: this.options.mangleImports,
+								runtimeRequirements: set
+							})
+						);
+					});
+			}
+		);
+	}
+}
+
+module.exports = FetchCompileWasmPlugin;
 
 
 /***/ }),
 
-/***/ 47794:
+/***/ 83121:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139850,236 +139597,591 @@ module.exports = AsyncSeriesLoopHook;
 */
 
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
 
-class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, onDone }) {
-		return this.callTapsSeries({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onResult: (i, result, next) => {
-				let code = "";
-				code += `if(${result} !== undefined) {\n`;
-				code += `${this._args[0]} = ${result};\n`;
-				code += `}\n`;
-				code += next();
-				return code;
-			},
-			onDone: () => onResult(this._args[0])
-		});
+const RuntimeGlobals = __webpack_require__(16475);
+const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class JsonpChunkLoadingPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"JsonpChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === "jsonp";
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
+						chunk,
+						new JsonpChunkLoadingRuntimeModule(set)
+					);
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("JsonpChunkLoadingPlugin", handler);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.loadScript);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.loadScript);
+						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.hmrModuleData);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getUpdateManifestFilename);
+					});
+			}
+		);
 	}
 }
 
-const factory = new AsyncSeriesWaterfallHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncSeriesWaterfallHook(args = [], name = undefined) {
-	if (args.length < 1)
-		throw new Error("Waterfall hooks must have at least one argument");
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesWaterfallHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncSeriesWaterfallHook.prototype = null;
-
-module.exports = AsyncSeriesWaterfallHook;
+module.exports = JsonpChunkLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 72258:
+/***/ 84154:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
-const util = __webpack_require__(73837);
 
-const deprecateContext = util.deprecate(() => {},
-"Hook.context is deprecated and will be removed");
+const { SyncWaterfallHook } = __webpack_require__(41242);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const chunkHasJs = (__webpack_require__(89464).chunkHasJs);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
 
-const CALL_DELEGATE = function(...args) {
-	this.call = this._createCall("sync");
-	return this.call(...args);
-};
-const CALL_ASYNC_DELEGATE = function(...args) {
-	this.callAsync = this._createCall("async");
-	return this.callAsync(...args);
-};
-const PROMISE_DELEGATE = function(...args) {
-	this.promise = this._createCall("promise");
-	return this.promise(...args);
-};
+/** @typedef {import("../Chunk")} Chunk */
 
-class Hook {
-	constructor(args = [], name = undefined) {
-		this._args = args;
-		this.name = name;
-		this.taps = [];
-		this.interceptors = [];
-		this._call = CALL_DELEGATE;
-		this.call = CALL_DELEGATE;
-		this._callAsync = CALL_ASYNC_DELEGATE;
-		this.callAsync = CALL_ASYNC_DELEGATE;
-		this._promise = PROMISE_DELEGATE;
-		this.promise = PROMISE_DELEGATE;
-		this._x = undefined;
+/**
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ */
 
-		this.compile = this.compile;
-		this.tap = this.tap;
-		this.tapAsync = this.tapAsync;
-		this.tapPromise = this.tapPromise;
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
+class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
 	}
 
-	compile(options) {
-		throw new Error("Abstract: should be overridden");
+	constructor(runtimeRequirements) {
+		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
 	}
 
-	_createCall(type) {
-		return this.compile({
-			taps: this.taps,
-			interceptors: this.interceptors,
-			args: this._args,
-			type: type
-		});
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, compilation, chunk } = this;
+		const {
+			runtimeTemplate,
+			outputOptions: {
+				chunkLoadingGlobal,
+				hotUpdateGlobal,
+				crossOriginLoading,
+				scriptType
+			}
+		} = compilation;
+		const globalObject = runtimeTemplate.globalObject;
+		const { linkPreload, linkPrefetch } =
+			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this._runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withCallback = this._runtimeRequirements.has(
+			RuntimeGlobals.chunkCallback
+		);
+		const withOnChunkLoad = this._runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withHmr = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const withPrefetch = this._runtimeRequirements.has(
+			RuntimeGlobals.prefetchChunkHandlers
+		);
+		const withPreload = this._runtimeRequirements.has(
+			RuntimeGlobals.preloadChunkHandlers
+		);
+		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
+			chunkLoadingGlobal
+		)}]`;
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp`
+			: undefined;
+
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.j = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? Template.indent([
+										"// JSONP chunk loading for javascript",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[2]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasJsMatcher === true
+													? "if(true) { // all chunks have JS"
+													: `if(${hasJsMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
+														"resolve, reject"
+													)});`,
+													"promises.push(installedChunkData[2] = promise);",
+													"",
+													"// start chunk loading",
+													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+													"// create error before stack unwound to get useful stacktrace later",
+													"var error = new Error();",
+													`var loadingEnded = ${runtimeTemplate.basicFunction(
+														"event",
+														[
+															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
+															Template.indent([
+																"installedChunkData = installedChunks[chunkId];",
+																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
+																"if(installedChunkData) {",
+																Template.indent([
+																	"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+																	"var realSrc = event && event.target && event.target.src;",
+																	"error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+																	"error.name = 'ChunkLoadError';",
+																	"error.type = errorType;",
+																	"error.request = realSrc;",
+																	"installedChunkData[1](error);"
+																]),
+																"}"
+															]),
+															"}"
+														]
+													)};`,
+													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ])
+								: Template.indent(["installedChunks[chunkId] = 0;"])
+						)};`
+				  ])
+				: "// no chunk on demand loading",
+			"",
+			withPrefetch && hasJsMatcher !== false
+				? `${
+						RuntimeGlobals.prefetchChunkHandlers
+				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
+						`if((!${
+							RuntimeGlobals.hasOwnProperty
+						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
+							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
+						}) {`,
+						Template.indent([
+							"installedChunks[chunkId] = null;",
+							linkPrefetch.call(
+								Template.asString([
+									"var link = document.createElement('link');",
+									crossOriginLoading
+										? `link.crossOrigin = ${JSON.stringify(
+												crossOriginLoading
+										  )};`
+										: "",
+									`if (${RuntimeGlobals.scriptNonce}) {`,
+									Template.indent(
+										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+									),
+									"}",
+									'link.rel = "prefetch";',
+									'link.as = "script";',
+									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`
+								]),
+								chunk
+							),
+							"document.head.appendChild(link);"
+						]),
+						"}"
+				  ])};`
+				: "// no prefetching",
+			"",
+			withPreload && hasJsMatcher !== false
+				? `${
+						RuntimeGlobals.preloadChunkHandlers
+				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
+						`if((!${
+							RuntimeGlobals.hasOwnProperty
+						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
+							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
+						}) {`,
+						Template.indent([
+							"installedChunks[chunkId] = null;",
+							linkPreload.call(
+								Template.asString([
+									"var link = document.createElement('link');",
+									scriptType
+										? `link.type = ${JSON.stringify(scriptType)};`
+										: "",
+									"link.charset = 'utf-8';",
+									`if (${RuntimeGlobals.scriptNonce}) {`,
+									Template.indent(
+										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+									),
+									"}",
+									'link.rel = "preload";',
+									'link.as = "script";',
+									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+									crossOriginLoading
+										? Template.asString([
+												"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
+												Template.indent(
+													`link.crossOrigin = ${JSON.stringify(
+														crossOriginLoading
+													)};`
+												),
+												"}"
+										  ])
+										: ""
+								]),
+								chunk
+							),
+							"document.head.appendChild(link);"
+						]),
+						"}"
+				  ])};`
+				: "// no preloaded",
+			"",
+			withHmr
+				? Template.asString([
+						"var currentUpdatedModulesList;",
+						"var waitingUpdateResolves = {};",
+						"function loadUpdateChunk(chunkId) {",
+						Template.indent([
+							`return new Promise(${runtimeTemplate.basicFunction(
+								"resolve, reject",
+								[
+									"waitingUpdateResolves[chunkId] = resolve;",
+									"// start update chunk loading",
+									`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
+									"// create error before stack unwound to get useful stacktrace later",
+									"var error = new Error();",
+									`var loadingEnded = ${runtimeTemplate.basicFunction("event", [
+										"if(waitingUpdateResolves[chunkId]) {",
+										Template.indent([
+											"waitingUpdateResolves[chunkId] = undefined",
+											"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+											"var realSrc = event && event.target && event.target.src;",
+											"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+											"error.name = 'ChunkLoadError';",
+											"error.type = errorType;",
+											"error.request = realSrc;",
+											"reject(error);"
+										]),
+										"}"
+									])};`,
+									`${RuntimeGlobals.loadScript}(url, loadingEnded);`
+								]
+							)});`
+						]),
+						"}",
+						"",
+						`${globalObject}[${JSON.stringify(
+							hotUpdateGlobal
+						)}] = ${runtimeTemplate.basicFunction(
+							"chunkId, moreModules, runtime",
+							[
+								"for(var moduleId in moreModules) {",
+								Template.indent([
+									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+									Template.indent([
+										"currentUpdate[moduleId] = moreModules[moduleId];",
+										"if(currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);"
+									]),
+									"}"
+								]),
+								"}",
+								"if(runtime) currentUpdateRuntime.push(runtime);",
+								"if(waitingUpdateResolves[chunkId]) {",
+								Template.indent([
+									"waitingUpdateResolves[chunkId]();",
+									"waitingUpdateResolves[chunkId] = undefined;"
+								]),
+								"}"
+							]
+						)};`,
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "jsonp")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${
+							RuntimeGlobals.hmrDownloadManifest
+						} = ${runtimeTemplate.basicFunction("", [
+							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
+							`return fetch(${RuntimeGlobals.publicPath} + ${
+								RuntimeGlobals.getUpdateManifestFilename
+							}()).then(${runtimeTemplate.basicFunction("response", [
+								"if(response.status === 404) return; // no update available",
+								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
+								"return response.json();"
+							])});`
+						])};`
+				  ])
+				: "// no HMR manifest",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.j = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded",
+			"",
+			withCallback || withLoading
+				? Template.asString([
+						"// install a JSONP callback for chunk loading",
+						`var webpackJsonpCallback = ${runtimeTemplate.basicFunction(
+							"parentChunkLoadingFunction, data",
+							[
+								runtimeTemplate.destructureArray(
+									["chunkIds", "moreModules", "runtime"],
+									"data"
+								),
+								'// add "moreModules" to the modules object,',
+								'// then flag all "chunkIds" as loaded and fire callback',
+								"var moduleId, chunkId, i = 0;",
+								`if(chunkIds.some(${runtimeTemplate.returningFunction(
+									"installedChunks[id] !== 0",
+									"id"
+								)})) {`,
+								Template.indent([
+									"for(moduleId in moreModules) {",
+									Template.indent([
+										`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+										Template.indent(
+											`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+										),
+										"}"
+									]),
+									"}",
+									"if(runtime) var result = runtime(__webpack_require__);"
+								]),
+								"}",
+								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",
+								"for(;i < chunkIds.length; i++) {",
+								Template.indent([
+									"chunkId = chunkIds[i];",
+									`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+									Template.indent("installedChunks[chunkId][0]();"),
+									"}",
+									"installedChunks[chunkId] = 0;"
+								]),
+								"}",
+								withOnChunkLoad
+									? `return ${RuntimeGlobals.onChunksLoaded}(result);`
+									: ""
+							]
+						)}`,
+						"",
+						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+						"chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));",
+						"chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));"
+				  ])
+				: "// no jsonp function"
+		]);
 	}
+}
 
-	_tap(type, options, fn) {
-		if (typeof options === "string") {
-			options = {
-				name: options.trim()
-			};
-		} else if (typeof options !== "object" || options === null) {
-			throw new Error("Invalid tap options");
-		}
-		if (typeof options.name !== "string" || options.name === "") {
-			throw new Error("Missing name for tap");
-		}
-		if (typeof options.context !== "undefined") {
-			deprecateContext();
-		}
-		options = Object.assign({ type, fn }, options);
-		options = this._runRegisterInterceptors(options);
-		this._insert(options);
-	}
+module.exports = JsonpChunkLoadingRuntimeModule;
 
-	tap(options, fn) {
-		this._tap("sync", options, fn);
-	}
 
-	tapAsync(options, fn) {
-		this._tap("async", options, fn);
-	}
+/***/ }),
 
-	tapPromise(options, fn) {
-		this._tap("promise", options, fn);
-	}
+/***/ 4607:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	_runRegisterInterceptors(options) {
-		for (const interceptor of this.interceptors) {
-			if (interceptor.register) {
-				const newOptions = interceptor.register(options);
-				if (newOptions !== undefined) {
-					options = newOptions;
-				}
-			}
-		}
-		return options;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	withOptions(options) {
-		const mergeOptions = opt =>
-			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
 
-		return {
-			name: this.name,
-			tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
-			tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
-			tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
-			intercept: interceptor => this.intercept(interceptor),
-			isUsed: () => this.isUsed(),
-			withOptions: opt => this.withOptions(mergeOptions(opt))
-		};
-	}
 
-	isUsed() {
-		return this.taps.length > 0 || this.interceptors.length > 0;
-	}
+const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
 
-	intercept(interceptor) {
-		this._resetCompilation();
-		this.interceptors.push(Object.assign({}, interceptor));
-		if (interceptor.register) {
-			for (let i = 0; i < this.taps.length; i++) {
-				this.taps[i] = interceptor.register(this.taps[i]);
-			}
-		}
-	}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
 
-	_resetCompilation() {
-		this.call = this._call;
-		this.callAsync = this._callAsync;
-		this.promise = this._promise;
+class JsonpTemplatePlugin {
+	/**
+	 * @deprecated use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpChunkLoadingRuntimeModule.JsonpCompilationPluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		return JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
 	}
 
-	_insert(item) {
-		this._resetCompilation();
-		let before;
-		if (typeof item.before === "string") {
-			before = new Set([item.before]);
-		} else if (Array.isArray(item.before)) {
-			before = new Set(item.before);
-		}
-		let stage = 0;
-		if (typeof item.stage === "number") {
-			stage = item.stage;
-		}
-		let i = this.taps.length;
-		while (i > 0) {
-			i--;
-			const x = this.taps[i];
-			this.taps[i + 1] = x;
-			const xStage = x.stage || 0;
-			if (before) {
-				if (before.has(x.name)) {
-					before.delete(x.name);
-					continue;
-				}
-				if (before.size > 0) {
-					continue;
-				}
-			}
-			if (xStage > stage) {
-				continue;
-			}
-			i++;
-			break;
-		}
-		this.taps[i] = item;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.options.output.chunkLoading = "jsonp";
+		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin("jsonp").apply(compiler);
 	}
 }
 
-Object.setPrototypeOf(Hook.prototype, null);
-
-module.exports = Hook;
+module.exports = JsonpTemplatePlugin;
 
 
 /***/ }),
 
-/***/ 177:
-/***/ (function(module) {
+/***/ 36243:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -140088,473 +140190,514 @@ module.exports = Hook;
 */
 
 
-class HookCodeFactory {
-	constructor(config) {
-		this.config = config;
-		this.options = undefined;
-		this._args = undefined;
-	}
 
-	create(options) {
-		this.init(options);
-		let fn;
-		switch (this.options.type) {
-			case "sync":
-				fn = new Function(
-					this.args(),
-					'"use strict";\n' +
-						this.header() +
-						this.contentWithInterceptors({
-							onError: err => `throw ${err};\n`,
-							onResult: result => `return ${result};\n`,
-							resultReturns: true,
-							onDone: () => "",
-							rethrowIfPossible: true
-						})
-				);
-				break;
-			case "async":
-				fn = new Function(
-					this.args({
-						after: "_callback"
-					}),
-					'"use strict";\n' +
-						this.header() +
-						this.contentWithInterceptors({
-							onError: err => `_callback(${err});\n`,
-							onResult: result => `_callback(null, ${result});\n`,
-							onDone: () => "_callback();\n"
-						})
-				);
-				break;
-			case "promise":
-				let errorHelperUsed = false;
-				const content = this.contentWithInterceptors({
-					onError: err => {
-						errorHelperUsed = true;
-						return `_error(${err});\n`;
-					},
-					onResult: result => `_resolve(${result});\n`,
-					onDone: () => "_resolve();\n"
-				});
-				let code = "";
-				code += '"use strict";\n';
-				code += this.header();
-				code += "return new Promise((function(_resolve, _reject) {\n";
-				if (errorHelperUsed) {
-					code += "var _sync = true;\n";
-					code += "function _error(_err) {\n";
-					code += "if(_sync)\n";
-					code +=
-						"_resolve(Promise.resolve().then((function() { throw _err; })));\n";
-					code += "else\n";
-					code += "_reject(_err);\n";
-					code += "};\n";
-				}
-				code += content;
-				if (errorHelperUsed) {
-					code += "_sync = false;\n";
-				}
-				code += "}));\n";
-				fn = new Function(this.args(), code);
-				break;
-		}
-		this.deinit();
-		return fn;
-	}
+const util = __webpack_require__(73837);
+const webpackOptionsSchemaCheck = __webpack_require__(10382);
+const webpackOptionsSchema = __webpack_require__(73342);
+const Compiler = __webpack_require__(70845);
+const MultiCompiler = __webpack_require__(33370);
+const WebpackOptionsApply = __webpack_require__(88422);
+const {
+	applyWebpackOptionsDefaults,
+	applyWebpackOptionsBaseDefaults
+} = __webpack_require__(92988);
+const { getNormalizedWebpackOptions } = __webpack_require__(26693);
+const NodeEnvironmentPlugin = __webpack_require__(7553);
+const memoize = __webpack_require__(78676);
 
-	setup(instance, options) {
-		instance._x = options.taps.map(t => t.fn);
-	}
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("./Compiler").WatchOptions} WatchOptions */
+/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
+/** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./Stats")} Stats */
 
-	/**
-	 * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
-	 */
-	init(options) {
-		this.options = options;
-		this._args = options.args.slice();
-	}
+const getValidateSchema = memoize(() => __webpack_require__(12047));
 
-	deinit() {
-		this.options = undefined;
-		this._args = undefined;
-	}
+/**
+ * @template T
+ * @callback Callback
+ * @param {Error=} err
+ * @param {T=} stats
+ * @returns {void}
+ */
 
-	contentWithInterceptors(options) {
-		if (this.options.interceptors.length > 0) {
-			const onError = options.onError;
-			const onResult = options.onResult;
-			const onDone = options.onDone;
-			let code = "";
-			for (let i = 0; i < this.options.interceptors.length; i++) {
-				const interceptor = this.options.interceptors[i];
-				if (interceptor.call) {
-					code += `${this.getInterceptor(i)}.call(${this.args({
-						before: interceptor.context ? "_context" : undefined
-					})});\n`;
-				}
-			}
-			code += this.content(
-				Object.assign(options, {
-					onError:
-						onError &&
-						(err => {
-							let code = "";
-							for (let i = 0; i < this.options.interceptors.length; i++) {
-								const interceptor = this.options.interceptors[i];
-								if (interceptor.error) {
-									code += `${this.getInterceptor(i)}.error(${err});\n`;
-								}
-							}
-							code += onError(err);
-							return code;
-						}),
-					onResult:
-						onResult &&
-						(result => {
-							let code = "";
-							for (let i = 0; i < this.options.interceptors.length; i++) {
-								const interceptor = this.options.interceptors[i];
-								if (interceptor.result) {
-									code += `${this.getInterceptor(i)}.result(${result});\n`;
-								}
-							}
-							code += onResult(result);
-							return code;
-						}),
-					onDone:
-						onDone &&
-						(() => {
-							let code = "";
-							for (let i = 0; i < this.options.interceptors.length; i++) {
-								const interceptor = this.options.interceptors[i];
-								if (interceptor.done) {
-									code += `${this.getInterceptor(i)}.done();\n`;
-								}
-							}
-							code += onDone();
-							return code;
-						})
-				})
+/**
+ * @param {ReadonlyArray<WebpackOptions>} childOptions options array
+ * @param {MultiCompilerOptions} options options
+ * @returns {MultiCompiler} a multi-compiler
+ */
+const createMultiCompiler = (childOptions, options) => {
+	const compilers = childOptions.map(options => createCompiler(options));
+	const compiler = new MultiCompiler(compilers, options);
+	for (const childCompiler of compilers) {
+		if (childCompiler.options.dependencies) {
+			compiler.setDependencies(
+				childCompiler,
+				childCompiler.options.dependencies
 			);
-			return code;
-		} else {
-			return this.content(options);
-		}
-	}
-
-	header() {
-		let code = "";
-		if (this.needContext()) {
-			code += "var _context = {};\n";
-		} else {
-			code += "var _context;\n";
-		}
-		code += "var _x = this._x;\n";
-		if (this.options.interceptors.length > 0) {
-			code += "var _taps = this.taps;\n";
-			code += "var _interceptors = this.interceptors;\n";
-		}
-		return code;
-	}
-
-	needContext() {
-		for (const tap of this.options.taps) if (tap.context) return true;
-		return false;
-	}
-
-	callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
-		let code = "";
-		let hasTapCached = false;
-		for (let i = 0; i < this.options.interceptors.length; i++) {
-			const interceptor = this.options.interceptors[i];
-			if (interceptor.tap) {
-				if (!hasTapCached) {
-					code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};\n`;
-					hasTapCached = true;
-				}
-				code += `${this.getInterceptor(i)}.tap(${
-					interceptor.context ? "_context, " : ""
-				}_tap${tapIndex});\n`;
-			}
-		}
-		code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};\n`;
-		const tap = this.options.taps[tapIndex];
-		switch (tap.type) {
-			case "sync":
-				if (!rethrowIfPossible) {
-					code += `var _hasError${tapIndex} = false;\n`;
-					code += "try {\n";
-				}
-				if (onResult) {
-					code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
-						before: tap.context ? "_context" : undefined
-					})});\n`;
-				} else {
-					code += `_fn${tapIndex}(${this.args({
-						before: tap.context ? "_context" : undefined
-					})});\n`;
-				}
-				if (!rethrowIfPossible) {
-					code += "} catch(_err) {\n";
-					code += `_hasError${tapIndex} = true;\n`;
-					code += onError("_err");
-					code += "}\n";
-					code += `if(!_hasError${tapIndex}) {\n`;
-				}
-				if (onResult) {
-					code += onResult(`_result${tapIndex}`);
-				}
-				if (onDone) {
-					code += onDone();
-				}
-				if (!rethrowIfPossible) {
-					code += "}\n";
-				}
-				break;
-			case "async":
-				let cbCode = "";
-				if (onResult)
-					cbCode += `(function(_err${tapIndex}, _result${tapIndex}) {\n`;
-				else cbCode += `(function(_err${tapIndex}) {\n`;
-				cbCode += `if(_err${tapIndex}) {\n`;
-				cbCode += onError(`_err${tapIndex}`);
-				cbCode += "} else {\n";
-				if (onResult) {
-					cbCode += onResult(`_result${tapIndex}`);
-				}
-				if (onDone) {
-					cbCode += onDone();
-				}
-				cbCode += "}\n";
-				cbCode += "})";
-				code += `_fn${tapIndex}(${this.args({
-					before: tap.context ? "_context" : undefined,
-					after: cbCode
-				})});\n`;
-				break;
-			case "promise":
-				code += `var _hasResult${tapIndex} = false;\n`;
-				code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
-					before: tap.context ? "_context" : undefined
-				})});\n`;
-				code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)\n`;
-				code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');\n`;
-				code += `_promise${tapIndex}.then((function(_result${tapIndex}) {\n`;
-				code += `_hasResult${tapIndex} = true;\n`;
-				if (onResult) {
-					code += onResult(`_result${tapIndex}`);
-				}
-				if (onDone) {
-					code += onDone();
-				}
-				code += `}), function(_err${tapIndex}) {\n`;
-				code += `if(_hasResult${tapIndex}) throw _err${tapIndex};\n`;
-				code += onError(`_err${tapIndex}`);
-				code += "});\n";
-				break;
-		}
-		return code;
-	}
-
-	callTapsSeries({
-		onError,
-		onResult,
-		resultReturns,
-		onDone,
-		doneReturns,
-		rethrowIfPossible
-	}) {
-		if (this.options.taps.length === 0) return onDone();
-		const firstAsync = this.options.taps.findIndex(t => t.type !== "sync");
-		const somethingReturns = resultReturns || doneReturns;
-		let code = "";
-		let current = onDone;
-		let unrollCounter = 0;
-		for (let j = this.options.taps.length - 1; j >= 0; j--) {
-			const i = j;
-			const unroll =
-				current !== onDone &&
-				(this.options.taps[i].type !== "sync" || unrollCounter++ > 20);
-			if (unroll) {
-				unrollCounter = 0;
-				code += `function _next${i}() {\n`;
-				code += current();
-				code += `}\n`;
-				current = () => `${somethingReturns ? "return " : ""}_next${i}();\n`;
-			}
-			const done = current;
-			const doneBreak = skipDone => {
-				if (skipDone) return "";
-				return onDone();
-			};
-			const content = this.callTap(i, {
-				onError: error => onError(i, error, done, doneBreak),
-				onResult:
-					onResult &&
-					(result => {
-						return onResult(i, result, done, doneBreak);
-					}),
-				onDone: !onResult && done,
-				rethrowIfPossible:
-					rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
-			});
-			current = () => content;
 		}
-		code += current();
-		return code;
 	}
+	return compiler;
+};
 
-	callTapsLooping({ onError, onDone, rethrowIfPossible }) {
-		if (this.options.taps.length === 0) return onDone();
-		const syncOnly = this.options.taps.every(t => t.type === "sync");
-		let code = "";
-		if (!syncOnly) {
-			code += "var _looper = (function() {\n";
-			code += "var _loopAsync = false;\n";
-		}
-		code += "var _loop;\n";
-		code += "do {\n";
-		code += "_loop = false;\n";
-		for (let i = 0; i < this.options.interceptors.length; i++) {
-			const interceptor = this.options.interceptors[i];
-			if (interceptor.loop) {
-				code += `${this.getInterceptor(i)}.loop(${this.args({
-					before: interceptor.context ? "_context" : undefined
-				})});\n`;
+/**
+ * @param {WebpackOptions} rawOptions options object
+ * @returns {Compiler} a compiler
+ */
+const createCompiler = rawOptions => {
+	const options = getNormalizedWebpackOptions(rawOptions);
+	applyWebpackOptionsBaseDefaults(options);
+	const compiler = new Compiler(options.context, options);
+	new NodeEnvironmentPlugin({
+		infrastructureLogging: options.infrastructureLogging
+	}).apply(compiler);
+	if (Array.isArray(options.plugins)) {
+		for (const plugin of options.plugins) {
+			if (typeof plugin === "function") {
+				plugin.call(compiler, compiler);
+			} else {
+				plugin.apply(compiler);
 			}
 		}
-		code += this.callTapsSeries({
-			onError,
-			onResult: (i, result, next, doneBreak) => {
-				let code = "";
-				code += `if(${result} !== undefined) {\n`;
-				code += "_loop = true;\n";
-				if (!syncOnly) code += "if(_loopAsync) _looper();\n";
-				code += doneBreak(true);
-				code += `} else {\n`;
-				code += next();
-				code += `}\n`;
-				return code;
-			},
-			onDone:
-				onDone &&
-				(() => {
-					let code = "";
-					code += "if(!_loop) {\n";
-					code += onDone();
-					code += "}\n";
-					return code;
-				}),
-			rethrowIfPossible: rethrowIfPossible && syncOnly
-		});
-		code += "} while(_loop);\n";
-		if (!syncOnly) {
-			code += "_loopAsync = true;\n";
-			code += "});\n";
-			code += "_looper();\n";
-		}
-		return code;
 	}
+	applyWebpackOptionsDefaults(options);
+	compiler.hooks.environment.call();
+	compiler.hooks.afterEnvironment.call();
+	new WebpackOptionsApply().process(options, compiler);
+	compiler.hooks.initialize.call();
+	return compiler;
+};
 
-	callTapsParallel({
-		onError,
-		onResult,
-		onDone,
-		rethrowIfPossible,
-		onTap = (i, run) => run()
-	}) {
-		if (this.options.taps.length <= 1) {
-			return this.callTapsSeries({
-				onError,
-				onResult,
-				onDone,
-				rethrowIfPossible
-			});
-		}
-		let code = "";
-		code += "do {\n";
-		code += `var _counter = ${this.options.taps.length};\n`;
-		if (onDone) {
-			code += "var _done = (function() {\n";
-			code += onDone();
-			code += "});\n";
-		}
-		for (let i = 0; i < this.options.taps.length; i++) {
-			const done = () => {
-				if (onDone) return "if(--_counter === 0) _done();\n";
-				else return "--_counter;";
-			};
-			const doneBreak = skipDone => {
-				if (skipDone || !onDone) return "_counter = 0;\n";
-				else return "_counter = 0;\n_done();\n";
-			};
-			code += "if(_counter <= 0) break;\n";
-			code += onTap(
-				i,
-				() =>
-					this.callTap(i, {
-						onError: error => {
-							let code = "";
-							code += "if(_counter > 0) {\n";
-							code += onError(i, error, done, doneBreak);
-							code += "}\n";
-							return code;
-						},
-						onResult:
-							onResult &&
-							(result => {
-								let code = "";
-								code += "if(_counter > 0) {\n";
-								code += onResult(i, result, done, doneBreak);
-								code += "}\n";
-								return code;
-							}),
-						onDone:
-							!onResult &&
-							(() => {
-								return done();
-							}),
-						rethrowIfPossible
-					}),
-				done,
-				doneBreak
-			);
-		}
-		code += "} while(false);\n";
-		return code;
-	}
+/**
+ * @callback WebpackFunctionSingle
+ * @param {WebpackOptions} options options object
+ * @param {Callback<Stats>=} callback callback
+ * @returns {Compiler} the compiler object
+ */
 
-	args({ before, after } = {}) {
-		let allArgs = this._args;
-		if (before) allArgs = [before].concat(allArgs);
-		if (after) allArgs = allArgs.concat(after);
-		if (allArgs.length === 0) {
-			return "";
+/**
+ * @callback WebpackFunctionMulti
+ * @param {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} options options objects
+ * @param {Callback<MultiStats>=} callback callback
+ * @returns {MultiCompiler} the multi compiler object
+ */
+
+const asArray = options =>
+	Array.isArray(options) ? Array.from(options) : [options];
+
+const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
+	/**
+	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
+	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
+	 * @returns {Compiler | MultiCompiler}
+	 */
+	(options, callback) => {
+		const create = () => {
+			if (!asArray(options).every(webpackOptionsSchemaCheck)) {
+				getValidateSchema()(webpackOptionsSchema, options);
+				util.deprecate(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
+			}
+			/** @type {MultiCompiler|Compiler} */
+			let compiler;
+			let watch = false;
+			/** @type {WatchOptions|WatchOptions[]} */
+			let watchOptions;
+			if (Array.isArray(options)) {
+				/** @type {MultiCompiler} */
+				compiler = createMultiCompiler(
+					options,
+					/** @type {MultiCompilerOptions} */ (options)
+				);
+				watch = options.some(options => options.watch);
+				watchOptions = options.map(options => options.watchOptions || {});
+			} else {
+				const webpackOptions = /** @type {WebpackOptions} */ (options);
+				/** @type {Compiler} */
+				compiler = createCompiler(webpackOptions);
+				watch = webpackOptions.watch;
+				watchOptions = webpackOptions.watchOptions || {};
+			}
+			return { compiler, watch, watchOptions };
+		};
+		if (callback) {
+			try {
+				const { compiler, watch, watchOptions } = create();
+				if (watch) {
+					compiler.watch(watchOptions, callback);
+				} else {
+					compiler.run((err, stats) => {
+						compiler.close(err2 => {
+							callback(err || err2, stats);
+						});
+					});
+				}
+				return compiler;
+			} catch (err) {
+				process.nextTick(() => callback(err));
+				return null;
+			}
 		} else {
-			return allArgs.join(", ");
+			const { compiler, watch } = create();
+			if (watch) {
+				util.deprecate(
+					() => {},
+					"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
+					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
+				)();
+			}
+			return compiler;
 		}
 	}
+);
 
-	getTapFn(idx) {
-		return `_x[${idx}]`;
+module.exports = webpack;
+
+
+/***/ }),
+
+/***/ 54182:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const StartupChunkDependenciesPlugin = __webpack_require__(22339);
+const ImportScriptsChunkLoadingRuntimeModule = __webpack_require__(96952);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ImportScriptsChunkLoadingPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new StartupChunkDependenciesPlugin({
+			chunkLoading: "import-scripts",
+			asyncChunkLoading: true
+		}).apply(compiler);
+		compiler.hooks.thisCompilation.tap(
+			"ImportScriptsChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === "import-scripts";
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					if (withCreateScriptUrl) {
+						set.add(RuntimeGlobals.createScriptUrl);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
+					);
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.hmrModuleData);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getUpdateManifestFilename);
+					});
+			}
+		);
 	}
+}
+module.exports = ImportScriptsChunkLoadingPlugin;
 
-	getTap(idx) {
-		return `_taps[${idx}]`;
+
+/***/ }),
+
+/***/ 96952:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(39722);
+const {
+	getChunkFilenameTemplate,
+	chunkHasJs
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
+
+class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements, withCreateScriptUrl) {
+		super("importScripts chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
+		this._withCreateScriptUrl = withCreateScriptUrl;
 	}
 
-	getInterceptor(idx) {
-		return `_interceptors[${idx}]`;
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const {
+			chunk,
+			chunkGraph,
+			compilation: {
+				runtimeTemplate,
+				outputOptions: { chunkLoadingGlobal, hotUpdateGlobal }
+			},
+			_withCreateScriptUrl: withCreateScriptUrl
+		} = this;
+		const globalObject = runtimeTemplate.globalObject;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
+			chunkLoadingGlobal
+		)}]`;
+		const hasJsMatcher = compileBooleanMatcher(
+			chunkGraph.getChunkConditionMap(chunk, chunkHasJs)
+		);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			false
+		);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_importScripts`
+			: undefined;
+
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = self.location + ${JSON.stringify(
+							rootOutputDir ? "/../" + rootOutputDir : ""
+						)};`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "1" means "already loaded"',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading
+				? Template.asString([
+						"// importScripts chunk loading",
+						`var installChunk = ${runtimeTemplate.basicFunction("data", [
+							runtimeTemplate.destructureArray(
+								["chunkIds", "moreModules", "runtime"],
+								"data"
+							),
+							"for(var moduleId in moreModules) {",
+							Template.indent([
+								`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+								Template.indent(
+									`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+								),
+								"}"
+							]),
+							"}",
+							"if(runtime) runtime(__webpack_require__);",
+							"while(chunkIds.length)",
+							Template.indent("installedChunks[chunkIds.pop()] = 1;"),
+							"parentChunkLoadingFunction(data);"
+						])};`
+				  ])
+				: "// no chunk install function needed",
+			withLoading
+				? Template.asString([
+						`${fn}.i = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? [
+										'// "1" is the signal for "already loaded"',
+										"if(!installedChunks[chunkId]) {",
+										Template.indent([
+											hasJsMatcher === true
+												? "if(true) { // all chunks have JS"
+												: `if(${hasJsMatcher("chunkId")}) {`,
+											Template.indent(
+												`importScripts(${
+													withCreateScriptUrl
+														? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`
+														: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId)`
+												});`
+											),
+											"}"
+										]),
+										"}"
+								  ]
+								: "installedChunks[chunkId] = 1;"
+						)};`,
+						"",
+						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+						"var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);",
+						"chunkLoadingGlobal.push = installChunk;"
+				  ])
+				: "// no chunk loading",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							"var success = false;",
+							`${globalObject}[${JSON.stringify(
+								hotUpdateGlobal
+							)}] = ${runtimeTemplate.basicFunction("_, moreModules, runtime", [
+								"for(var moduleId in moreModules) {",
+								Template.indent([
+									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+									Template.indent([
+										"currentUpdate[moduleId] = moreModules[moduleId];",
+										"if(updatedModulesList) updatedModulesList.push(moduleId);"
+									]),
+									"}"
+								]),
+								"}",
+								"if(runtime) currentUpdateRuntime.push(runtime);",
+								"success = true;"
+							])};`,
+							"// start update chunk loading",
+							`importScripts(${
+								withCreateScriptUrl
+									? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId))`
+									: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId)`
+							});`,
+							'if(!success) throw new Error("Loading update chunk failed for unknown reason");'
+						]),
+						"}",
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "importScrips")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${
+							RuntimeGlobals.hmrDownloadManifest
+						} = ${runtimeTemplate.basicFunction("", [
+							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
+							`return fetch(${RuntimeGlobals.publicPath} + ${
+								RuntimeGlobals.getUpdateManifestFilename
+							}()).then(${runtimeTemplate.basicFunction("response", [
+								"if(response.status === 404) return; // no update available",
+								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
+								"return response.json();"
+							])});`
+						])};`
+				  ])
+				: "// no HMR manifest"
+		]);
 	}
 }
 
-module.exports = HookCodeFactory;
+module.exports = ImportScriptsChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 5504:
+/***/ 68693:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -140564,383 +140707,240 @@ module.exports = HookCodeFactory;
 */
 
 
-const util = __webpack_require__(73837);
-
-const defaultFactory = (key, hook) => hook;
-
-class HookMap {
-	constructor(factory, name = undefined) {
-		this._map = new Map();
-		this.name = name;
-		this._factory = factory;
-		this._interceptors = [];
-	}
 
-	get(key) {
-		return this._map.get(key);
-	}
+const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
 
-	for(key) {
-		const hook = this.get(key);
-		if (hook !== undefined) {
-			return hook;
-		}
-		let newHook = this._factory(key);
-		const interceptors = this._interceptors;
-		for (let i = 0; i < interceptors.length; i++) {
-			newHook = interceptors[i].factory(key, newHook);
-		}
-		this._map.set(key, newHook);
-		return newHook;
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
-	intercept(interceptor) {
-		this._interceptors.push(
-			Object.assign(
-				{
-					factory: defaultFactory
-				},
-				interceptor
-			)
-		);
+class WebWorkerTemplatePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.options.output.chunkLoading = "import-scripts";
+		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin("import-scripts").apply(compiler);
 	}
 }
-
-HookMap.prototype.tap = util.deprecate(function(key, options, fn) {
-	return this.for(key).tap(options, fn);
-}, "HookMap#tap(key,…) is deprecated. Use HookMap#for(key).tap(…) instead.");
-
-HookMap.prototype.tapAsync = util.deprecate(function(key, options, fn) {
-	return this.for(key).tapAsync(options, fn);
-}, "HookMap#tapAsync(key,…) is deprecated. Use HookMap#for(key).tapAsync(…) instead.");
-
-HookMap.prototype.tapPromise = util.deprecate(function(key, options, fn) {
-	return this.for(key).tapPromise(options, fn);
-}, "HookMap#tapPromise(key,…) is deprecated. Use HookMap#for(key).tapPromise(…) instead.");
-
-module.exports = HookMap;
+module.exports = WebWorkerTemplatePlugin;
 
 
 /***/ }),
 
-/***/ 1081:
+/***/ 50569:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-const Hook = __webpack_require__(72258);
-
-class MultiHook {
-	constructor(hooks, name = undefined) {
-		this.hooks = hooks;
-		this.name = name;
-	}
-
-	tap(options, fn) {
-		for (const hook of this.hooks) {
-			hook.tap(options, fn);
-		}
-	}
-
-	tapAsync(options, fn) {
-		for (const hook of this.hooks) {
-			hook.tapAsync(options, fn);
-		}
-	}
-
-	tapPromise(options, fn) {
-		for (const hook of this.hooks) {
-			hook.tapPromise(options, fn);
-		}
-	}
-
-	isUsed() {
-		for (const hook of this.hooks) {
-			if (hook.isUsed()) return true;
-		}
-		return false;
-	}
-
-	intercept(interceptor) {
-		for (const hook of this.hooks) {
-			hook.intercept(interceptor);
-		}
-	}
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
 
-	withOptions(options) {
-		return new MultiHook(
-			this.hooks.map(h => h.withOptions(options)),
-			this.name
-		);
-	}
-}
+/**
+ * Module exports.
+ */
 
-module.exports = MultiHook;
+module.exports = __webpack_require__(58750)
 
 
 /***/ }),
 
-/***/ 79106:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 78585:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
 
-class SyncBailHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
-		return this.callTapsSeries({
-			onError: (i, err) => onError(err),
-			onResult: (i, result, next) =>
-				`if(${result} !== undefined) {\n${onResult(
-					result
-				)};\n} else {\n${next()}}\n`,
-			resultReturns,
-			onDone,
-			rethrowIfPossible
-		});
-	}
-}
 
-const factory = new SyncBailHookCodeFactory();
 
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncBailHook");
-};
+/**
+ * Module dependencies.
+ * @private
+ */
 
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncBailHook");
-};
+var db = __webpack_require__(50569)
+var extname = (__webpack_require__(71017).extname)
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+/**
+ * Module variables.
+ * @private
+ */
 
-function SyncBailHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = SyncBailHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
-}
+var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
+var TEXT_TYPE_REGEXP = /^text\//i
 
-SyncBailHook.prototype = null;
+/**
+ * Module exports.
+ * @public
+ */
 
-module.exports = SyncBailHook;
+exports.charset = charset
+exports.charsets = { lookup: charset }
+exports.contentType = contentType
+exports.extension = extension
+exports.extensions = Object.create(null)
+exports.lookup = lookup
+exports.types = Object.create(null)
 
+// Populate the extensions/types maps
+populateMaps(exports.extensions, exports.types)
 
-/***/ }),
+/**
+ * Get the default charset for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
 
-/***/ 10533:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+function charset (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+  var mime = match && db[match[1].toLowerCase()]
 
+  if (mime && mime.charset) {
+    return mime.charset
+  }
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
+  // default text/* to utf-8
+  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+    return 'UTF-8'
+  }
 
-class SyncHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone, rethrowIfPossible }) {
-		return this.callTapsSeries({
-			onError: (i, err) => onError(err),
-			onDone,
-			rethrowIfPossible
-		});
-	}
+  return false
 }
 
-const factory = new SyncHookCodeFactory();
-
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncHook");
-};
-
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncHook");
-};
+/**
+ * Create a full Content-Type header given a MIME type or extension.
+ *
+ * @param {string} str
+ * @return {boolean|string}
+ */
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+function contentType (str) {
+  // TODO: should this even be in this module?
+  if (!str || typeof str !== 'string') {
+    return false
+  }
 
-function SyncHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = SyncHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
-}
+  var mime = str.indexOf('/') === -1
+    ? exports.lookup(str)
+    : str
 
-SyncHook.prototype = null;
+  if (!mime) {
+    return false
+  }
 
-module.exports = SyncHook;
+  // TODO: use content-type or other module
+  if (mime.indexOf('charset') === -1) {
+    var charset = exports.charset(mime)
+    if (charset) mime += '; charset=' + charset.toLowerCase()
+  }
 
+  return mime
+}
 
-/***/ }),
+/**
+ * Get the default extension for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
 
-/***/ 95854:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+function extension (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
 
+  // get extensions
+  var exts = match && exports.extensions[match[1].toLowerCase()]
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
+  if (!exts || !exts.length) {
+    return false
+  }
 
-class SyncLoopHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone, rethrowIfPossible }) {
-		return this.callTapsLooping({
-			onError: (i, err) => onError(err),
-			onDone,
-			rethrowIfPossible
-		});
-	}
+  return exts[0]
 }
 
-const factory = new SyncLoopHookCodeFactory();
+/**
+ * Lookup the MIME type for a file path/extension.
+ *
+ * @param {string} path
+ * @return {boolean|string}
+ */
 
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncLoopHook");
-};
+function lookup (path) {
+  if (!path || typeof path !== 'string') {
+    return false
+  }
 
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncLoopHook");
-};
+  // get the extension ("ext" or ".ext" or full path)
+  var extension = extname('x.' + path)
+    .toLowerCase()
+    .substr(1)
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+  if (!extension) {
+    return false
+  }
 
-function SyncLoopHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = SyncLoopHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
+  return exports.types[extension] || false
 }
 
-SyncLoopHook.prototype = null;
-
-module.exports = SyncLoopHook;
-
-
-/***/ }),
-
-/***/ 60176:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
 
+function populateMaps (extensions, types) {
+  // source preference (least -> most)
+  var preference = ['nginx', 'apache', undefined, 'iana']
 
-const Hook = __webpack_require__(72258);
-const HookCodeFactory = __webpack_require__(177);
+  Object.keys(db).forEach(function forEachMimeType (type) {
+    var mime = db[type]
+    var exts = mime.extensions
 
-class SyncWaterfallHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, resultReturns, rethrowIfPossible }) {
-		return this.callTapsSeries({
-			onError: (i, err) => onError(err),
-			onResult: (i, result, next) => {
-				let code = "";
-				code += `if(${result} !== undefined) {\n`;
-				code += `${this._args[0]} = ${result};\n`;
-				code += `}\n`;
-				code += next();
-				return code;
-			},
-			onDone: () => onResult(this._args[0]),
-			doneReturns: resultReturns,
-			rethrowIfPossible
-		});
-	}
-}
+    if (!exts || !exts.length) {
+      return
+    }
 
-const factory = new SyncWaterfallHookCodeFactory();
+    // mime -> extensions
+    extensions[type] = exts
 
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncWaterfallHook");
-};
+    // extension -> mime
+    for (var i = 0; i < exts.length; i++) {
+      var extension = exts[i]
 
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncWaterfallHook");
-};
+      if (types[extension]) {
+        var from = preference.indexOf(db[types[extension]].source)
+        var to = preference.indexOf(mime.source)
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+        if (types[extension] !== 'application/octet-stream' &&
+          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+          // skip the remapping
+          continue
+        }
+      }
 
-function SyncWaterfallHook(args = [], name = undefined) {
-	if (args.length < 1)
-		throw new Error("Waterfall hooks must have at least one argument");
-	const hook = new Hook(args, name);
-	hook.constructor = SyncWaterfallHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
+      // set the extension -> mime
+      types[extension] = type
+    }
+  })
 }
 
-SyncWaterfallHook.prototype = null;
-
-module.exports = SyncWaterfallHook;
-
-
-/***/ }),
-
-/***/ 6967:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-exports.__esModule = true;
-exports.SyncHook = __webpack_require__(10533);
-exports.SyncBailHook = __webpack_require__(79106);
-exports.SyncWaterfallHook = __webpack_require__(60176);
-exports.SyncLoopHook = __webpack_require__(95854);
-exports.AsyncParallelHook = __webpack_require__(45874);
-exports.AsyncParallelBailHook = __webpack_require__(76297);
-exports.AsyncSeriesHook = __webpack_require__(40436);
-exports.AsyncSeriesBailHook = __webpack_require__(13633);
-exports.AsyncSeriesLoopHook = __webpack_require__(34656);
-exports.AsyncSeriesWaterfallHook = __webpack_require__(47794);
-exports.HookMap = __webpack_require__(5504);
-exports.MultiHook = __webpack_require__(1081);
-
 
 /***/ }),
 
diff --git a/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts b/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
index d4b5814bc6eb8..b8c8a00bbdc8d 100644
--- a/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+++ b/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
@@ -3,7 +3,7 @@ import { RefreshRuntimeGlobals } from '../runtime'
 declare const self: Window & RefreshRuntimeGlobals
 
 type Dictionary = { [key: string]: unknown }
-declare const module: {
+declare const __webpack_module__: {
   id: string
   __proto__: { exports: unknown }
   hot: {
@@ -27,14 +27,16 @@ export default function () {
       // AMP / No-JS mode does not inject these helpers:
       '$RefreshHelpers$' in self
     ) {
-      var currentExports = module.__proto__.exports
-      var prevExports = module.hot.data?.prevExports ?? null
+      // @ts-ignore __webpack_module__ is global
+      var currentExports = __webpack_module__.__proto__.exports
+      // @ts-ignore __webpack_module__ is global
+      var prevExports = __webpack_module__.hot.data?.prevExports ?? null
 
       // This cannot happen in MainTemplate because the exports mismatch between
       // templating and execution.
       self.$RefreshHelpers$.registerExportsForReactRefresh(
         currentExports,
-        module.id
+        __webpack_module__.id
       )
 
       // A module can be accepted automatically based on its exports, e.g. when
@@ -42,12 +44,12 @@ export default function () {
       if (self.$RefreshHelpers$.isReactRefreshBoundary(currentExports)) {
         // Save the previous exports on update so we can compare the boundary
         // signatures.
-        module.hot.dispose(function (data) {
+        __webpack_module__.hot.dispose(function (data) {
           data.prevExports = currentExports
         })
         // Unconditionally accept an update to this module, we'll check if it's
         // still a Refresh Boundary later.
-        module.hot.accept()
+        __webpack_module__.hot.accept()
 
         // This field is set when the previous version of this module was a
         // Refresh Boundary, letting us know we need to check for invalidation or
@@ -66,7 +68,7 @@ export default function () {
               currentExports
             )
           ) {
-            module.hot.invalidate()
+            __webpack_module__.hot.invalidate()
           } else {
             self.$RefreshHelpers$.scheduleUpdate()
           }
@@ -78,7 +80,7 @@ export default function () {
         // because we already accepted this update (accidental side effect).
         var isNoLongerABoundary = prevExports !== null
         if (isNoLongerABoundary) {
-          module.hot.invalidate()
+          __webpack_module__.hot.invalidate()
         }
       }
     }

From ef38e247031765c4e31c5374a361d7b46e1c92d0 Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Mon, 14 Feb 2022 11:44:42 +0100
Subject: [PATCH 5/8] Use right path for distDir

---
 packages/next/build/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/next/build/index.ts b/packages/next/build/index.ts
index 6529829cc698e..1e6eaff734339 100644
--- a/packages/next/build/index.ts
+++ b/packages/next/build/index.ts
@@ -535,7 +535,7 @@ export default async function build(
     // Ensure commonjs handling is used for files in the distDir (generally .next)
     // Files outside of the distDir can be "type": "module"
     await promises.writeFile(
-      path.join(config.distDir, 'package.json'),
+      path.join(distDir, 'package.json'),
       '{"type": "commonjs"}'
     )
 

From fcf8b3409ab2b2b82487990a39932ae8fe426eec Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Tue, 15 Feb 2022 13:51:57 +0100
Subject: [PATCH 6/8] Fix hot accept

---
 packages/next/build/webpack-config.ts         |     29 +-
 packages/next/compiled/webpack/bundle5.js     | 224024 +++++++--------
 .../internal/ReactRefreshModule.runtime.ts    |      7 +-
 packages/react-refresh-utils/loader.ts        |     10 +-
 4 files changed, 112042 insertions(+), 112028 deletions(-)

diff --git a/packages/next/build/webpack-config.ts b/packages/next/build/webpack-config.ts
index 20c86444faa5a..d84778ead0e3c 100644
--- a/packages/next/build/webpack-config.ts
+++ b/packages/next/build/webpack-config.ts
@@ -1265,15 +1265,26 @@ export default async function getBaseWebpackConfig(
               use: getBabelOrSwcLoader(true),
             },
             {
-              ...codeCondition,
-              use: hasReactRefresh
-                ? [
-                    require.resolve(
-                      'next/dist/compiled/@next/react-refresh-utils/loader'
-                    ),
-                    defaultLoaders.babel,
-                  ]
-                : defaultLoaders.babel,
+              rules: [
+                hasReactRefresh && {
+                  ...codeCondition,
+                  exclude: (excludePath: string) => {
+                    // Unlike the normal code condition react-refresh-utils should only be applied to first-party code
+                    // Because of this Next.js internals are excluded as well in this condition
+                    if (babelIncludeRegexes.some((r) => r.test(excludePath))) {
+                      return true
+                    }
+                    return codeCondition.exclude(excludePath)
+                  },
+                  use: require.resolve(
+                    'next/dist/compiled/@next/react-refresh-utils/loader'
+                  ),
+                },
+                {
+                  ...codeCondition,
+                  use: defaultLoaders.babel,
+                },
+              ].filter(Boolean),
             },
           ],
         },
diff --git a/packages/next/compiled/webpack/bundle5.js b/packages/next/compiled/webpack/bundle5.js
index 6f57a1885204f..093c9ba888ef5 100644
--- a/packages/next/compiled/webpack/bundle5.js
+++ b/packages/next/compiled/webpack/bundle5.js
@@ -10139,15228 +10139,17433 @@ var __classPrivateFieldSet;
 
 /***/ }),
 
-/***/ 42752:
+/***/ 70665:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 
+const Variable = __webpack_require__(82971);
 
-const DescriptionFileUtils = __webpack_require__(702);
-const getInnerRequest = __webpack_require__(50290);
+/**
+ * @class Definition
+ */
+class Definition {
+    constructor(type, name, node, parent, index, kind) {
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        /**
+         * @member {String} Definition#type - type of the occurrence (e.g. "Parameter", "Variable", ...).
+         */
+        this.type = type;
 
-module.exports = class AliasFieldPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | Array<string>} field field
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, field, target) {
-		this.source = source;
-		this.field = field;
-		this.target = target;
-	}
+        /**
+         * @member {espree.Identifier} Definition#name - the identifier AST node of the occurrence.
+         */
+        this.name = name;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => {
-				if (!request.descriptionFileData) return callback();
-				const innerRequest = getInnerRequest(resolver, request);
-				if (!innerRequest) return callback();
-				const fieldData = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.field
-				);
-				if (fieldData === null || typeof fieldData !== "object") {
-					if (resolveContext.log)
-						resolveContext.log(
-							"Field '" +
-								this.field +
-								"' doesn't contain a valid alias configuration"
-						);
-					return callback();
-				}
-				const data1 = fieldData[innerRequest];
-				const data2 = fieldData[innerRequest.replace(/^\.\//, "")];
-				const data = typeof data1 !== "undefined" ? data1 : data2;
-				if (data === innerRequest) return callback();
-				if (data === undefined) return callback();
-				if (data === false) {
-					/** @type {ResolveRequest} */
-					const ignoreObj = {
-						...request,
-						path: false
-					};
-					return callback(null, ignoreObj);
-				}
-				const obj = {
-					...request,
-					path: request.descriptionFileRoot,
-					request: data,
-					fullySpecified: false
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"aliased from description file " +
-						request.descriptionFilePath +
-						" with mapping '" +
-						innerRequest +
-						"' to '" +
-						data +
-						"'",
-					resolveContext,
-					(err, result) => {
-						if (err) return callback(err);
+        /**
+         * @member {espree.Node} Definition#node - the enclosing node of the identifier.
+         */
+        this.node = node;
 
-						// Don't allow other aliasing or raw request
-						if (result === undefined) return callback(null, null);
-						callback(null, result);
-					}
-				);
-			});
-	}
+        /**
+         * @member {espree.Node?} Definition#parent - the enclosing statement node of the identifier.
+         */
+        this.parent = parent;
+
+        /**
+         * @member {Number?} Definition#index - the index in the declaration statement.
+         */
+        this.index = index;
+
+        /**
+         * @member {String?} Definition#kind - the kind of the declaration statement.
+         */
+        this.kind = kind;
+    }
+}
+
+/**
+ * @class ParameterDefinition
+ */
+class ParameterDefinition extends Definition {
+    constructor(name, node, index, rest) {
+        super(Variable.Parameter, name, node, null, index, null);
+
+        /**
+         * Whether the parameter definition is a part of a rest parameter.
+         * @member {boolean} ParameterDefinition#rest
+         */
+        this.rest = rest;
+    }
+}
+
+module.exports = {
+    ParameterDefinition,
+    Definition
 };
 
+/* vim: set sw=4 ts=4 et tw=80 : */
+
 
 /***/ }),
 
-/***/ 51547:
+/***/ 36007:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2013 Alex Seville <hi@alexanderseville.com>
+  Copyright (C) 2014 Thiago de Arruda <tpadilha84@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
+/**
+ * Escope (<a href="http://github.com/estools/escope">escope</a>) is an <a
+ * href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript</a>
+ * scope analyzer extracted from the <a
+ * href="http://github.com/estools/esmangle">esmangle project</a/>.
+ * <p>
+ * <em>escope</em> finds lexical scopes in a source program, i.e. areas of that
+ * program where different occurrences of the same identifier refer to the same
+ * variable. With each scope the contained variables are collected, and each
+ * identifier reference in code is linked to its corresponding variable (if
+ * possible).
+ * <p>
+ * <em>escope</em> works on a syntax tree of the parsed source code which has
+ * to adhere to the <a
+ * href="https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API">
+ * Mozilla Parser API</a>. E.g. <a href="https://github.com/eslint/espree">espree</a> is a parser
+ * that produces such syntax trees.
+ * <p>
+ * The main interface is the {@link analyze} function.
+ * @module escope
+ */
 
 
-const forEachBail = __webpack_require__(8266);
+/* eslint no-underscore-dangle: ["error", { "allow": ["__currentScope"] }] */
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {{alias: string|Array<string>|false, name: string, onlyModule?: boolean}} AliasOption */
+const assert = __webpack_require__(39491);
 
-module.exports = class AliasPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {AliasOption | Array<AliasOption>} options options
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, options, target) {
-		this.source = source;
-		this.options = Array.isArray(options) ? options : [options];
-		this.target = target;
-	}
+const ScopeManager = __webpack_require__(96988);
+const Referencer = __webpack_require__(44585);
+const Reference = __webpack_require__(64945);
+const Variable = __webpack_require__(82971);
+const Scope = (__webpack_require__(16313).Scope);
+const version = (__webpack_require__(30290)/* .version */ .i8);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("AliasPlugin", (request, resolveContext, callback) => {
-				const innerRequest = request.request || request.path;
-				if (!innerRequest) return callback();
-				forEachBail(
-					this.options,
-					(item, callback) => {
-						let shouldStop = false;
-						if (
-							innerRequest === item.name ||
-							(!item.onlyModule && innerRequest.startsWith(item.name + "/"))
-						) {
-							const remainingRequest = innerRequest.substr(item.name.length);
-							const resolveWithAlias = (alias, callback) => {
-								if (alias === false) {
-									const ignoreObj = {
-										...request,
-										path: false
-									};
-									return callback(null, ignoreObj);
-								}
-								if (
-									innerRequest !== alias &&
-									!innerRequest.startsWith(alias + "/")
-								) {
-									shouldStop = true;
-									const newRequestStr = alias + remainingRequest;
-									const obj = {
-										...request,
-										request: newRequestStr,
-										fullySpecified: false
-									};
-									return resolver.doResolve(
-										target,
-										obj,
-										"aliased with mapping '" +
-											item.name +
-											"': '" +
-											alias +
-											"' to '" +
-											newRequestStr +
-											"'",
-										resolveContext,
-										(err, result) => {
-											if (err) return callback(err);
-											if (result) return callback(null, result);
-											return callback();
-										}
-									);
-								}
-								return callback();
-							};
-							const stoppingCallback = (err, result) => {
-								if (err) return callback(err);
+/**
+ * Set the default options
+ * @returns {Object} options
+ */
+function defaultOptions() {
+    return {
+        optimistic: false,
+        directive: false,
+        nodejsScope: false,
+        impliedStrict: false,
+        sourceType: "script", // one of ['script', 'module']
+        ecmaVersion: 5,
+        childVisitorKeys: null,
+        fallback: "iteration"
+    };
+}
 
-								if (result) return callback(null, result);
-								// Don't allow other aliasing or raw request
-								if (shouldStop) return callback(null, null);
-								return callback();
-							};
-							if (Array.isArray(item.alias)) {
-								return forEachBail(
-									item.alias,
-									resolveWithAlias,
-									stoppingCallback
-								);
-							} else {
-								return resolveWithAlias(item.alias, stoppingCallback);
-							}
-						}
-						return callback();
-					},
-					callback
-				);
-			});
-	}
-};
+/**
+ * Preform deep update on option object
+ * @param {Object} target - Options
+ * @param {Object} override - Updates
+ * @returns {Object} Updated options
+ */
+function updateDeeply(target, override) {
 
+    /**
+     * Is hash object
+     * @param {Object} value - Test value
+     * @returns {boolean} Result
+     */
+    function isHashObject(value) {
+        return typeof value === "object" && value instanceof Object && !(value instanceof Array) && !(value instanceof RegExp);
+    }
 
-/***/ }),
+    for (const key in override) {
+        if (Object.prototype.hasOwnProperty.call(override, key)) {
+            const val = override[key];
 
-/***/ 66477:
-/***/ (function(module) {
+            if (isHashObject(val)) {
+                if (isHashObject(target[key])) {
+                    updateDeeply(target[key], val);
+                } else {
+                    target[key] = updateDeeply({}, val);
+                }
+            } else {
+                target[key] = val;
+            }
+        }
+    }
+    return target;
+}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * Main interface function. Takes an Espree syntax tree and returns the
+ * analyzed scopes.
+ * @function analyze
+ * @param {espree.Tree} tree - Abstract Syntax Tree
+ * @param {Object} providedOptions - Options that tailor the scope analysis
+ * @param {boolean} [providedOptions.optimistic=false] - the optimistic flag
+ * @param {boolean} [providedOptions.directive=false]- the directive flag
+ * @param {boolean} [providedOptions.ignoreEval=false]- whether to check 'eval()' calls
+ * @param {boolean} [providedOptions.nodejsScope=false]- whether the whole
+ * script is executed under node.js environment. When enabled, escope adds
+ * a function scope immediately following the global scope.
+ * @param {boolean} [providedOptions.impliedStrict=false]- implied strict mode
+ * (if ecmaVersion >= 5).
+ * @param {string} [providedOptions.sourceType='script']- the source type of the script. one of 'script' and 'module'
+ * @param {number} [providedOptions.ecmaVersion=5]- which ECMAScript version is considered
+ * @param {Object} [providedOptions.childVisitorKeys=null] - Additional known visitor keys. See [esrecurse](https://github.com/estools/esrecurse)'s the `childVisitorKeys` option.
+ * @param {string} [providedOptions.fallback='iteration'] - A kind of the fallback in order to encounter with unknown node. See [esrecurse](https://github.com/estools/esrecurse)'s the `fallback` option.
+ * @returns {ScopeManager} ScopeManager
+ */
+function analyze(tree, providedOptions) {
+    const options = updateDeeply(defaultOptions(), providedOptions);
+    const scopeManager = new ScopeManager(options);
+    const referencer = new Referencer(options, scopeManager);
 
+    referencer.visit(tree);
 
+    assert(scopeManager.__currentScope === null, "currentScope should be null.");
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    return scopeManager;
+}
 
-module.exports = class AppendPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} appending appending
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, appending, target) {
-		this.source = source;
-		this.appending = appending;
-		this.target = target;
-	}
+module.exports = {
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("AppendPlugin", (request, resolveContext, callback) => {
-				const obj = {
-					...request,
-					path: request.path + this.appending,
-					relativePath:
-						request.relativePath && request.relativePath + this.appending
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					this.appending,
-					resolveContext,
-					callback
-				);
-			});
-	}
+    /** @name module:escope.version */
+    version,
+
+    /** @name module:escope.Reference */
+    Reference,
+
+    /** @name module:escope.Variable */
+    Variable,
+
+    /** @name module:escope.Scope */
+    Scope,
+
+    /** @name module:escope.ScopeManager */
+    ScopeManager,
+    analyze
 };
 
 
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+
 /***/ }),
 
-/***/ 89429:
+/***/ 54162:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-const nextTick = (__webpack_require__(77282).nextTick);
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
 
-const dirname = path => {
-	let idx = path.length - 1;
-	while (idx >= 0) {
-		const c = path.charCodeAt(idx);
-		// slash or backslash
-		if (c === 47 || c === 92) break;
-		idx--;
-	}
-	if (idx < 0) return "";
-	return path.slice(0, idx);
-};
+/* eslint-disable no-undefined */
 
-const runCallbacks = (callbacks, err, result) => {
-	if (callbacks.length === 1) {
-		callbacks[0](err, result);
-		callbacks.length = 0;
-		return;
-	}
-	let error;
-	for (const callback of callbacks) {
-		try {
-			callback(err, result);
-		} catch (e) {
-			if (!error) error = e;
-		}
-	}
-	callbacks.length = 0;
-	if (error) throw error;
-};
+const Syntax = (__webpack_require__(18350).Syntax);
+const esrecurse = __webpack_require__(81217);
 
-class OperationMergerBackend {
-	/**
-	 * @param {any} provider async method
-	 * @param {any} syncProvider sync method
-	 * @param {any} providerContext call context for the provider methods
-	 */
-	constructor(provider, syncProvider, providerContext) {
-		this._provider = provider;
-		this._syncProvider = syncProvider;
-		this._providerContext = providerContext;
-		this._activeAsyncOperations = new Map();
+/**
+ * Get last array element
+ * @param {array} xs - array
+ * @returns {any} Last elment
+ */
+function getLast(xs) {
+    return xs[xs.length - 1] || null;
+}
 
-		this.provide = this._provider
-			? (path, options, callback) => {
-					if (typeof options === "function") {
-						callback = options;
-						options = undefined;
-					}
-					if (options) {
-						return this._provider.call(
-							this._providerContext,
-							path,
-							options,
-							callback
-						);
-					}
-					if (typeof path !== "string") {
-						callback(new TypeError("path must be a string"));
-						return;
-					}
-					let callbacks = this._activeAsyncOperations.get(path);
-					if (callbacks) {
-						callbacks.push(callback);
-						return;
-					}
-					this._activeAsyncOperations.set(path, (callbacks = [callback]));
-					provider(path, (err, result) => {
-						this._activeAsyncOperations.delete(path);
-						runCallbacks(callbacks, err, result);
-					});
-			  }
-			: null;
-		this.provideSync = this._syncProvider
-			? (path, options) => {
-					return this._syncProvider.call(this._providerContext, path, options);
-			  }
-			: null;
-	}
+class PatternVisitor extends esrecurse.Visitor {
+    static isPattern(node) {
+        const nodeType = node.type;
 
-	purge() {}
-	purgeParent() {}
-}
+        return (
+            nodeType === Syntax.Identifier ||
+            nodeType === Syntax.ObjectPattern ||
+            nodeType === Syntax.ArrayPattern ||
+            nodeType === Syntax.SpreadElement ||
+            nodeType === Syntax.RestElement ||
+            nodeType === Syntax.AssignmentPattern
+        );
+    }
 
-/*
+    constructor(options, rootPattern, callback) {
+        super(null, options);
+        this.rootPattern = rootPattern;
+        this.callback = callback;
+        this.assignments = [];
+        this.rightHandNodes = [];
+        this.restElements = [];
+    }
 
-IDLE:
-	insert data: goto SYNC
+    Identifier(pattern) {
+        const lastRestElement = getLast(this.restElements);
 
-SYNC:
-	before provide: run ticks
-	event loop tick: goto ASYNC_ACTIVE
+        this.callback(pattern, {
+            topLevel: pattern === this.rootPattern,
+            rest: lastRestElement !== null && lastRestElement !== undefined && lastRestElement.argument === pattern,
+            assignments: this.assignments
+        });
+    }
 
-ASYNC:
-	timeout: run tick, goto ASYNC_PASSIVE
+    Property(property) {
 
-ASYNC_PASSIVE:
-	before provide: run ticks
+        // Computed property's key is a right hand node.
+        if (property.computed) {
+            this.rightHandNodes.push(property.key);
+        }
 
-IDLE --[insert data]--> SYNC --[event loop tick]--> ASYNC_ACTIVE --[interval tick]-> ASYNC_PASSIVE
-                                                          ^                             |
-                                                          +---------[insert data]-------+
-*/
+        // If it's shorthand, its key is same as its value.
+        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).
+        // If it's not shorthand, the name of new variable is its value's.
+        this.visit(property.value);
+    }
 
-const STORAGE_MODE_IDLE = 0;
-const STORAGE_MODE_SYNC = 1;
-const STORAGE_MODE_ASYNC = 2;
+    ArrayPattern(pattern) {
+        for (let i = 0, iz = pattern.elements.length; i < iz; ++i) {
+            const element = pattern.elements[i];
 
-class CacheBackend {
-	/**
-	 * @param {number} duration max cache duration of items
-	 * @param {any} provider async method
-	 * @param {any} syncProvider sync method
-	 * @param {any} providerContext call context for the provider methods
-	 */
-	constructor(duration, provider, syncProvider, providerContext) {
-		this._duration = duration;
-		this._provider = provider;
-		this._syncProvider = syncProvider;
-		this._providerContext = providerContext;
-		/** @type {Map<string, (function(Error, any): void)[]>} */
-		this._activeAsyncOperations = new Map();
-		/** @type {Map<string, { err: Error, result: any, level: Set<string> }>} */
-		this._data = new Map();
-		/** @type {Set<string>[]} */
-		this._levels = [];
-		for (let i = 0; i < 10; i++) this._levels.push(new Set());
-		for (let i = 5000; i < duration; i += 500) this._levels.push(new Set());
-		this._currentLevel = 0;
-		this._tickInterval = Math.floor(duration / this._levels.length);
-		/** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */
-		this._mode = STORAGE_MODE_IDLE;
+            this.visit(element);
+        }
+    }
 
-		/** @type {NodeJS.Timeout | undefined} */
-		this._timeout = undefined;
-		/** @type {number | undefined} */
-		this._nextDecay = undefined;
+    AssignmentPattern(pattern) {
+        this.assignments.push(pattern);
+        this.visit(pattern.left);
+        this.rightHandNodes.push(pattern.right);
+        this.assignments.pop();
+    }
 
-		this.provide = provider ? this.provide.bind(this) : null;
-		this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
-	}
+    RestElement(pattern) {
+        this.restElements.push(pattern);
+        this.visit(pattern.argument);
+        this.restElements.pop();
+    }
 
-	provide(path, options, callback) {
-		if (typeof options === "function") {
-			callback = options;
-			options = undefined;
-		}
-		if (typeof path !== "string") {
-			callback(new TypeError("path must be a string"));
-			return;
-		}
-		if (options) {
-			return this._provider.call(
-				this._providerContext,
-				path,
-				options,
-				callback
-			);
-		}
+    MemberExpression(node) {
 
-		// When in sync mode we can move to async mode
-		if (this._mode === STORAGE_MODE_SYNC) {
-			this._enterAsyncMode();
-		}
+        // Computed property's key is a right hand node.
+        if (node.computed) {
+            this.rightHandNodes.push(node.property);
+        }
 
-		// Check in cache
-		let cacheEntry = this._data.get(path);
-		if (cacheEntry !== undefined) {
-			if (cacheEntry.err) return nextTick(callback, cacheEntry.err);
-			return nextTick(callback, null, cacheEntry.result);
-		}
+        // the object is only read, write to its property.
+        this.rightHandNodes.push(node.object);
+    }
 
-		// Check if there is already the same operation running
-		let callbacks = this._activeAsyncOperations.get(path);
-		if (callbacks !== undefined) {
-			callbacks.push(callback);
-			return;
-		}
-		this._activeAsyncOperations.set(path, (callbacks = [callback]));
+    //
+    // ForInStatement.left and AssignmentExpression.left are LeftHandSideExpression.
+    // By spec, LeftHandSideExpression is Pattern or MemberExpression.
+    //   (see also: https://github.com/estree/estree/pull/20#issuecomment-74584758)
+    // But espree 2.0 parses to ArrayExpression, ObjectExpression, etc...
+    //
 
-		// Run the operation
-		this._provider.call(this._providerContext, path, (err, result) => {
-			this._activeAsyncOperations.delete(path);
-			this._storeResult(path, err, result);
+    SpreadElement(node) {
+        this.visit(node.argument);
+    }
 
-			// Enter async mode if not yet done
-			this._enterAsyncMode();
+    ArrayExpression(node) {
+        node.elements.forEach(this.visit, this);
+    }
 
-			runCallbacks(callbacks, err, result);
-		});
-	}
+    AssignmentExpression(node) {
+        this.assignments.push(node);
+        this.visit(node.left);
+        this.rightHandNodes.push(node.right);
+        this.assignments.pop();
+    }
 
-	provideSync(path, options) {
-		if (typeof path !== "string") {
-			throw new TypeError("path must be a string");
-		}
-		if (options) {
-			return this._syncProvider.call(this._providerContext, path, options);
-		}
+    CallExpression(node) {
 
-		// In sync mode we may have to decay some cache items
-		if (this._mode === STORAGE_MODE_SYNC) {
-			this._runDecays();
-		}
+        // arguments are right hand nodes.
+        node.arguments.forEach(a => {
+            this.rightHandNodes.push(a);
+        });
+        this.visit(node.callee);
+    }
+}
 
-		// Check in cache
-		let cacheEntry = this._data.get(path);
-		if (cacheEntry !== undefined) {
-			if (cacheEntry.err) throw cacheEntry.err;
-			return cacheEntry.result;
-		}
+module.exports = PatternVisitor;
 
-		// Get all active async operations
-		// This sync operation will also complete them
-		const callbacks = this._activeAsyncOperations.get(path);
-		this._activeAsyncOperations.delete(path);
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-		// Run the operation
-		// When in idle mode, we will enter sync mode
-		let result;
-		try {
-			result = this._syncProvider.call(this._providerContext, path);
-		} catch (err) {
-			this._storeResult(path, err, undefined);
-			this._enterSyncModeWhenIdle();
-			if (callbacks) runCallbacks(callbacks, err, undefined);
-			throw err;
-		}
-		this._storeResult(path, undefined, result);
-		this._enterSyncModeWhenIdle();
-		if (callbacks) runCallbacks(callbacks, undefined, result);
-		return result;
-	}
 
-	purge(what) {
-		if (!what) {
-			if (this._mode !== STORAGE_MODE_IDLE) {
-				this._data.clear();
-				for (const level of this._levels) {
-					level.clear();
-				}
-				this._enterIdleMode();
-			}
-		} else if (typeof what === "string") {
-			for (let [key, data] of this._data) {
-				if (key.startsWith(what)) {
-					this._data.delete(key);
-					data.level.delete(key);
-				}
-			}
-			if (this._data.size === 0) {
-				this._enterIdleMode();
-			}
-		} else {
-			for (let [key, data] of this._data) {
-				for (const item of what) {
-					if (key.startsWith(item)) {
-						this._data.delete(key);
-						data.level.delete(key);
-						break;
-					}
-				}
-			}
-			if (this._data.size === 0) {
-				this._enterIdleMode();
-			}
-		}
-	}
+/***/ }),
 
-	purgeParent(what) {
-		if (!what) {
-			this.purge();
-		} else if (typeof what === "string") {
-			this.purge(dirname(what));
-		} else {
-			const set = new Set();
-			for (const item of what) {
-				set.add(dirname(item));
-			}
-			this.purge(set);
-		}
-	}
+/***/ 64945:
+/***/ (function(module) {
 
-	_storeResult(path, err, result) {
-		if (this._data.has(path)) return;
-		const level = this._levels[this._currentLevel];
-		this._data.set(path, { err, result, level });
-		level.add(path);
-	}
+"use strict";
+/*
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-	_decayLevel() {
-		const nextLevel = (this._currentLevel + 1) % this._levels.length;
-		const decay = this._levels[nextLevel];
-		this._currentLevel = nextLevel;
-		for (let item of decay) {
-			this._data.delete(item);
-		}
-		decay.clear();
-		if (this._data.size === 0) {
-			this._enterIdleMode();
-		} else {
-			// @ts-ignore _nextDecay is always a number in sync mode
-			this._nextDecay += this._tickInterval;
-		}
-	}
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-	_runDecays() {
-		while (
-			/** @type {number} */ (this._nextDecay) <= Date.now() &&
-			this._mode !== STORAGE_MODE_IDLE
-		) {
-			this._decayLevel();
-		}
-	}
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-	_enterAsyncMode() {
-		let timeout = 0;
-		switch (this._mode) {
-			case STORAGE_MODE_ASYNC:
-				return;
-			case STORAGE_MODE_IDLE:
-				this._nextDecay = Date.now() + this._tickInterval;
-				timeout = this._tickInterval;
-				break;
-			case STORAGE_MODE_SYNC:
-				this._runDecays();
-				// @ts-ignore _runDecays may change the mode
-				if (this._mode === STORAGE_MODE_IDLE) return;
-				timeout = Math.max(
-					0,
-					/** @type {number} */ (this._nextDecay) - Date.now()
-				);
-				break;
-		}
-		this._mode = STORAGE_MODE_ASYNC;
-		const ref = setTimeout(() => {
-			this._mode = STORAGE_MODE_SYNC;
-			this._runDecays();
-		}, timeout);
-		if (ref.unref) ref.unref();
-		this._timeout = ref;
-	}
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-	_enterSyncModeWhenIdle() {
-		if (this._mode === STORAGE_MODE_IDLE) {
-			this._mode = STORAGE_MODE_SYNC;
-			this._nextDecay = Date.now() + this._tickInterval;
-		}
-	}
 
-	_enterIdleMode() {
-		this._mode = STORAGE_MODE_IDLE;
-		this._nextDecay = undefined;
-		if (this._timeout) clearTimeout(this._timeout);
-	}
-}
+const READ = 0x1;
+const WRITE = 0x2;
+const RW = READ | WRITE;
 
-const createBackend = (duration, provider, syncProvider, providerContext) => {
-	if (duration > 0) {
-		return new CacheBackend(duration, provider, syncProvider, providerContext);
-	}
-	return new OperationMergerBackend(provider, syncProvider, providerContext);
-};
+/**
+ * A Reference represents a single occurrence of an identifier in code.
+ * @class Reference
+ */
+class Reference {
+    constructor(ident, scope, flag, writeExpr, maybeImplicitGlobal, partial, init) {
 
-module.exports = class CachedInputFileSystem {
-	constructor(fileSystem, duration) {
-		this.fileSystem = fileSystem;
+        /**
+         * Identifier syntax node.
+         * @member {espreeIdentifier} Reference#identifier
+         */
+        this.identifier = ident;
 
-		this._lstatBackend = createBackend(
-			duration,
-			this.fileSystem.lstat,
-			this.fileSystem.lstatSync,
-			this.fileSystem
-		);
-		const lstat = this._lstatBackend.provide;
-		this.lstat = /** @type {FileSystem["lstat"]} */ (lstat);
-		const lstatSync = this._lstatBackend.provideSync;
-		this.lstatSync = /** @type {SyncFileSystem["lstatSync"]} */ (lstatSync);
+        /**
+         * Reference to the enclosing Scope.
+         * @member {Scope} Reference#from
+         */
+        this.from = scope;
 
-		this._statBackend = createBackend(
-			duration,
-			this.fileSystem.stat,
-			this.fileSystem.statSync,
-			this.fileSystem
-		);
-		const stat = this._statBackend.provide;
-		this.stat = /** @type {FileSystem["stat"]} */ (stat);
-		const statSync = this._statBackend.provideSync;
-		this.statSync = /** @type {SyncFileSystem["statSync"]} */ (statSync);
+        /**
+         * Whether the reference comes from a dynamic scope (such as 'eval',
+         * 'with', etc.), and may be trapped by dynamic scopes.
+         * @member {boolean} Reference#tainted
+         */
+        this.tainted = false;
 
-		this._readdirBackend = createBackend(
-			duration,
-			this.fileSystem.readdir,
-			this.fileSystem.readdirSync,
-			this.fileSystem
-		);
-		const readdir = this._readdirBackend.provide;
-		this.readdir = /** @type {FileSystem["readdir"]} */ (readdir);
-		const readdirSync = this._readdirBackend.provideSync;
-		this.readdirSync = /** @type {SyncFileSystem["readdirSync"]} */ (readdirSync);
+        /**
+         * The variable this reference is resolved with.
+         * @member {Variable} Reference#resolved
+         */
+        this.resolved = null;
 
-		this._readFileBackend = createBackend(
-			duration,
-			this.fileSystem.readFile,
-			this.fileSystem.readFileSync,
-			this.fileSystem
-		);
-		const readFile = this._readFileBackend.provide;
-		this.readFile = /** @type {FileSystem["readFile"]} */ (readFile);
-		const readFileSync = this._readFileBackend.provideSync;
-		this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */ (readFileSync);
+        /**
+         * The read-write mode of the reference. (Value is one of {@link
+         * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).
+         * @member {number} Reference#flag
+         * @private
+         */
+        this.flag = flag;
+        if (this.isWrite()) {
 
-		this._readJsonBackend = createBackend(
-			duration,
-			this.fileSystem.readJson ||
-				(this.readFile &&
-					((path, callback) => {
-						// @ts-ignore
-						this.readFile(path, (err, buffer) => {
-							if (err) return callback(err);
-							if (!buffer || buffer.length === 0)
-								return callback(new Error("No file content"));
-							let data;
-							try {
-								data = JSON.parse(buffer.toString("utf-8"));
-							} catch (e) {
-								return callback(e);
-							}
-							callback(null, data);
-						});
-					})),
-			this.fileSystem.readJsonSync ||
-				(this.readFileSync &&
-					(path => {
-						const buffer = this.readFileSync(path);
-						const data = JSON.parse(buffer.toString("utf-8"));
-						return data;
-					})),
-			this.fileSystem
-		);
-		const readJson = this._readJsonBackend.provide;
-		this.readJson = /** @type {FileSystem["readJson"]} */ (readJson);
-		const readJsonSync = this._readJsonBackend.provideSync;
-		this.readJsonSync = /** @type {SyncFileSystem["readJsonSync"]} */ (readJsonSync);
+            /**
+             * If reference is writeable, this is the tree being written to it.
+             * @member {espreeNode} Reference#writeExpr
+             */
+            this.writeExpr = writeExpr;
 
-		this._readlinkBackend = createBackend(
-			duration,
-			this.fileSystem.readlink,
-			this.fileSystem.readlinkSync,
-			this.fileSystem
-		);
-		const readlink = this._readlinkBackend.provide;
-		this.readlink = /** @type {FileSystem["readlink"]} */ (readlink);
-		const readlinkSync = this._readlinkBackend.provideSync;
-		this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */ (readlinkSync);
-	}
+            /**
+             * Whether the Reference might refer to a partial value of writeExpr.
+             * @member {boolean} Reference#partial
+             */
+            this.partial = partial;
 
-	purge(what) {
-		this._statBackend.purge(what);
-		this._lstatBackend.purge(what);
-		this._readdirBackend.purgeParent(what);
-		this._readFileBackend.purge(what);
-		this._readlinkBackend.purge(what);
-		this._readJsonBackend.purge(what);
-	}
-};
+            /**
+             * Whether the Reference is to write of initialization.
+             * @member {boolean} Reference#init
+             */
+            this.init = init;
+        }
+        this.__maybeImplicitGlobal = maybeImplicitGlobal;
+    }
 
+    /**
+     * Whether the reference is static.
+     * @method Reference#isStatic
+     * @returns {boolean} static
+     */
+    isStatic() {
+        return !this.tainted && this.resolved && this.resolved.scope.isStatic();
+    }
 
-/***/ }),
+    /**
+     * Whether the reference is writeable.
+     * @method Reference#isWrite
+     * @returns {boolean} write
+     */
+    isWrite() {
+        return !!(this.flag & Reference.WRITE);
+    }
 
-/***/ 2020:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    /**
+     * Whether the reference is readable.
+     * @method Reference#isRead
+     * @returns {boolean} read
+     */
+    isRead() {
+        return !!(this.flag & Reference.READ);
+    }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    /**
+     * Whether the reference is read-only.
+     * @method Reference#isReadOnly
+     * @returns {boolean} read only
+     */
+    isReadOnly() {
+        return this.flag === Reference.READ;
+    }
 
+    /**
+     * Whether the reference is write-only.
+     * @method Reference#isWriteOnly
+     * @returns {boolean} write only
+     */
+    isWriteOnly() {
+        return this.flag === Reference.WRITE;
+    }
 
+    /**
+     * Whether the reference is read-write.
+     * @method Reference#isReadWrite
+     * @returns {boolean} read write
+     */
+    isReadWrite() {
+        return this.flag === Reference.RW;
+    }
+}
 
-const basename = (__webpack_require__(48608).basename);
+/**
+ * @constant Reference.READ
+ * @private
+ */
+Reference.READ = READ;
 
-/** @typedef {import("./Resolver")} Resolver */
+/**
+ * @constant Reference.WRITE
+ * @private
+ */
+Reference.WRITE = WRITE;
 
-module.exports = class CloneBasenamePlugin {
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+/**
+ * @constant Reference.RW
+ * @private
+ */
+Reference.RW = RW;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
-				const filename = basename(request.path);
-				const filePath = resolver.join(request.path, filename);
-				const obj = {
-					...request,
-					path: filePath,
-					relativePath:
-						request.relativePath &&
-						resolver.join(request.relativePath, filename)
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"using path: " + filePath,
-					resolveContext,
-					callback
-				);
-			});
-	}
-};
+module.exports = Reference;
+
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 44193:
-/***/ (function(module) {
+/***/ 44585:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-module.exports = class ConditionalPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Partial<ResolveRequest>} test compare object
-	 * @param {string | null} message log message
-	 * @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, test, message, allowAlternatives, target) {
-		this.source = source;
-		this.test = test;
-		this.message = message;
-		this.allowAlternatives = allowAlternatives;
-		this.target = target;
-	}
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		const { test, message, allowAlternatives } = this;
-		const keys = Object.keys(test);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ConditionalPlugin", (request, resolveContext, callback) => {
-				for (const prop of keys) {
-					if (request[prop] !== test[prop]) return callback();
-				}
-				resolver.doResolve(
-					target,
-					request,
-					message,
-					resolveContext,
-					allowAlternatives
-						? callback
-						: (err, result) => {
-								if (err) return callback(err);
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-undefined */
 
-								// Don't allow other alternatives
-								if (result === undefined) return callback(null, null);
-								callback(null, result);
-						  }
-				);
-			});
-	}
-};
+const Syntax = (__webpack_require__(18350).Syntax);
+const esrecurse = __webpack_require__(81217);
+const Reference = __webpack_require__(64945);
+const Variable = __webpack_require__(82971);
+const PatternVisitor = __webpack_require__(54162);
+const definition = __webpack_require__(70665);
+const assert = __webpack_require__(39491);
 
+const ParameterDefinition = definition.ParameterDefinition;
+const Definition = definition.Definition;
 
-/***/ }),
+/**
+ * Traverse identifier in pattern
+ * @param {Object} options - options
+ * @param {pattern} rootPattern - root pattern
+ * @param {Refencer} referencer - referencer
+ * @param {callback} callback - callback
+ * @returns {void}
+ */
+function traverseIdentifierInPattern(options, rootPattern, referencer, callback) {
 
-/***/ 66826:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    // Call the callback at left hand identifier nodes, and Collect right hand nodes.
+    const visitor = new PatternVisitor(options, rootPattern, callback);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    visitor.visit(rootPattern);
 
+    // Process the right hand nodes recursively.
+    if (referencer !== null && referencer !== undefined) {
+        visitor.rightHandNodes.forEach(referencer.visit, referencer);
+    }
+}
 
+// Importing ImportDeclaration.
+// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-moduledeclarationinstantiation
+// https://github.com/estree/estree/blob/master/es6.md#importdeclaration
+// FIXME: Now, we don't create module environment, because the context is
+// implementation dependent.
 
-const DescriptionFileUtils = __webpack_require__(702);
+class Importer extends esrecurse.Visitor {
+    constructor(declaration, referencer) {
+        super(null, referencer.options);
+        this.declaration = declaration;
+        this.referencer = referencer;
+    }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    visitImport(id, specifier) {
+        this.referencer.visitPattern(id, pattern => {
+            this.referencer.currentScope().__define(pattern,
+                new Definition(
+                    Variable.ImportBinding,
+                    pattern,
+                    specifier,
+                    this.declaration,
+                    null,
+                    null
+                ));
+        });
+    }
 
-module.exports = class DescriptionFilePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string[]} filenames filenames
-	 * @param {boolean} pathIsFile pathIsFile
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, filenames, pathIsFile, target) {
-		this.source = source;
-		this.filenames = filenames;
-		this.pathIsFile = pathIsFile;
-		this.target = target;
-	}
+    ImportNamespaceSpecifier(node) {
+        const local = (node.local || node.id);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"DescriptionFilePlugin",
-				(request, resolveContext, callback) => {
-					const path = request.path;
-					if (!path) return callback();
-					const directory = this.pathIsFile
-						? DescriptionFileUtils.cdUp(path)
-						: path;
-					if (!directory) return callback();
-					DescriptionFileUtils.loadDescriptionFile(
-						resolver,
-						directory,
-						this.filenames,
-						request.descriptionFilePath
-							? {
-									path: request.descriptionFilePath,
-									content: request.descriptionFileData,
-									directory: /** @type {string} */ (request.descriptionFileRoot)
-							  }
-							: undefined,
-						resolveContext,
-						(err, result) => {
-							if (err) return callback(err);
-							if (!result) {
-								if (resolveContext.log)
-									resolveContext.log(
-										`No description file found in ${directory} or above`
-									);
-								return callback();
-							}
-							const relativePath =
-								"." + path.substr(result.directory.length).replace(/\\/g, "/");
-							const obj = {
-								...request,
-								descriptionFilePath: result.path,
-								descriptionFileData: result.content,
-								descriptionFileRoot: result.directory,
-								relativePath: relativePath
-							};
-							resolver.doResolve(
-								target,
-								obj,
-								"using description file: " +
-									result.path +
-									" (relative path: " +
-									relativePath +
-									")",
-								resolveContext,
-								(err, result) => {
-									if (err) return callback(err);
+        if (local) {
+            this.visitImport(local, node);
+        }
+    }
 
-									// Don't allow other processing
-									if (result === undefined) return callback(null, null);
-									callback(null, result);
-								}
-							);
-						}
-					);
-				}
-			);
-	}
-};
+    ImportDefaultSpecifier(node) {
+        const local = (node.local || node.id);
 
+        this.visitImport(local, node);
+    }
 
-/***/ }),
+    ImportSpecifier(node) {
+        const local = (node.local || node.id);
 
-/***/ 702:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+        if (node.name) {
+            this.visitImport(node.name, node);
+        } else {
+            this.visitImport(local, node);
+        }
+    }
+}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+// Referencing variables and creating bindings.
+class Referencer extends esrecurse.Visitor {
+    constructor(options, scopeManager) {
+        super(null, options);
+        this.options = options;
+        this.scopeManager = scopeManager;
+        this.parent = null;
+        this.isInnerMethodDefinition = false;
+    }
 
+    currentScope() {
+        return this.scopeManager.__currentScope;
+    }
 
+    close(node) {
+        while (this.currentScope() && node === this.currentScope().block) {
+            this.scopeManager.__currentScope = this.currentScope().__close(this.scopeManager);
+        }
+    }
 
-const forEachBail = __webpack_require__(8266);
+    pushInnerMethodDefinition(isInnerMethodDefinition) {
+        const previous = this.isInnerMethodDefinition;
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+        this.isInnerMethodDefinition = isInnerMethodDefinition;
+        return previous;
+    }
 
-/**
- * @typedef {Object} DescriptionFileInfo
- * @property {any=} content
- * @property {string} path
- * @property {string} directory
- */
+    popInnerMethodDefinition(isInnerMethodDefinition) {
+        this.isInnerMethodDefinition = isInnerMethodDefinition;
+    }
 
-/**
- * @callback ErrorFirstCallback
- * @param {Error|null=} error
- * @param {DescriptionFileInfo=} result
- */
+    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {
+        const scope = this.currentScope();
 
-/**
- * @param {Resolver} resolver resolver
- * @param {string} directory directory
- * @param {string[]} filenames filenames
- * @param {DescriptionFileInfo|undefined} oldInfo oldInfo
- * @param {ResolveContext} resolveContext resolveContext
- * @param {ErrorFirstCallback} callback callback
- */
-function loadDescriptionFile(
-	resolver,
-	directory,
-	filenames,
-	oldInfo,
-	resolveContext,
-	callback
-) {
-	(function findDescriptionFile() {
-		if (oldInfo && oldInfo.directory === directory) {
-			// We already have info for this directory and can reuse it
-			return callback(null, oldInfo);
-		}
-		forEachBail(
-			filenames,
-			(filename, callback) => {
-				const descriptionFilePath = resolver.join(directory, filename);
-				if (resolver.fileSystem.readJson) {
-					resolver.fileSystem.readJson(descriptionFilePath, (err, content) => {
-						if (err) {
-							if (typeof err.code !== "undefined") {
-								if (resolveContext.missingDependencies) {
-									resolveContext.missingDependencies.add(descriptionFilePath);
-								}
-								return callback();
-							}
-							if (resolveContext.fileDependencies) {
-								resolveContext.fileDependencies.add(descriptionFilePath);
-							}
-							return onJson(err);
-						}
-						if (resolveContext.fileDependencies) {
-							resolveContext.fileDependencies.add(descriptionFilePath);
-						}
-						onJson(null, content);
-					});
-				} else {
-					resolver.fileSystem.readFile(descriptionFilePath, (err, content) => {
-						if (err) {
-							if (resolveContext.missingDependencies) {
-								resolveContext.missingDependencies.add(descriptionFilePath);
-							}
-							return callback();
-						}
-						if (resolveContext.fileDependencies) {
-							resolveContext.fileDependencies.add(descriptionFilePath);
-						}
-						let json;
+        assignments.forEach(assignment => {
+            scope.__referencing(
+                pattern,
+                Reference.WRITE,
+                assignment.right,
+                maybeImplicitGlobal,
+                pattern !== assignment.left,
+                init
+            );
+        });
+    }
 
-						if (content) {
-							try {
-								json = JSON.parse(content.toString());
-							} catch (e) {
-								return onJson(e);
-							}
-						} else {
-							return onJson(new Error("No content in file"));
-						}
+    visitPattern(node, options, callback) {
+        let visitPatternOptions = options;
+        let visitPatternCallback = callback;
 
-						onJson(null, json);
-					});
-				}
+        if (typeof options === "function") {
+            visitPatternCallback = options;
+            visitPatternOptions = { processRightHandNodes: false };
+        }
 
-				function onJson(err, content) {
-					if (err) {
-						if (resolveContext.log)
-							resolveContext.log(
-								descriptionFilePath + " (directory description file): " + err
-							);
-						else
-							err.message =
-								descriptionFilePath + " (directory description file): " + err;
-						return callback(err);
-					}
-					callback(null, {
-						content,
-						directory,
-						path: descriptionFilePath
-					});
-				}
-			},
-			(err, result) => {
-				if (err) return callback(err);
-				if (result) {
-					return callback(null, result);
-				} else {
-					const dir = cdUp(directory);
-					if (!dir) {
-						return callback();
-					} else {
-						directory = dir;
-						return findDescriptionFile();
-					}
-				}
-			}
-		);
-	})();
-}
+        traverseIdentifierInPattern(
+            this.options,
+            node,
+            visitPatternOptions.processRightHandNodes ? this : null,
+            visitPatternCallback
+        );
+    }
 
-/**
- * @param {any} content content
- * @param {string|string[]} field field
- * @returns {object|string|number|boolean|undefined} field data
- */
-function getField(content, field) {
-	if (!content) return undefined;
-	if (Array.isArray(field)) {
-		let current = content;
-		for (let j = 0; j < field.length; j++) {
-			if (current === null || typeof current !== "object") {
-				current = null;
-				break;
-			}
-			current = current[field[j]];
-		}
-		return current;
-	} else {
-		return content[field];
-	}
-}
+    visitFunction(node) {
+        let i, iz;
 
-/**
- * @param {string} directory directory
- * @returns {string|null} parent directory or null
- */
-function cdUp(directory) {
-	if (directory === "/") return null;
-	const i = directory.lastIndexOf("/"),
-		j = directory.lastIndexOf("\\");
-	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
-	if (p < 0) return null;
-	return directory.substr(0, p || 1);
-}
+        // FunctionDeclaration name is defined in upper scope
+        // NOTE: Not referring variableScope. It is intended.
+        // Since
+        //  in ES5, FunctionDeclaration should be in FunctionBody.
+        //  in ES6, FunctionDeclaration should be block scoped.
 
-exports.loadDescriptionFile = loadDescriptionFile;
-exports.getField = getField;
-exports.cdUp = cdUp;
+        if (node.type === Syntax.FunctionDeclaration) {
 
+            // id is defined in upper scope
+            this.currentScope().__define(node.id,
+                new Definition(
+                    Variable.FunctionName,
+                    node.id,
+                    node,
+                    null,
+                    null,
+                    null
+                ));
+        }
 
-/***/ }),
+        // FunctionExpression with name creates its special scope;
+        // FunctionExpressionNameScope.
+        if (node.type === Syntax.FunctionExpression && node.id) {
+            this.scopeManager.__nestFunctionExpressionNameScope(node);
+        }
 
-/***/ 73688:
-/***/ (function(module) {
+        // Consider this function is in the MethodDefinition.
+        this.scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        const that = this;
 
+        /**
+         * Visit pattern callback
+         * @param {pattern} pattern - pattern
+         * @param {Object} info - info
+         * @returns {void}
+         */
+        function visitPatternCallback(pattern, info) {
+            that.currentScope().__define(pattern,
+                new ParameterDefinition(
+                    pattern,
+                    node,
+                    i,
+                    info.rest
+                ));
 
+            that.referencingDefaultValue(pattern, info.assignments, null, true);
+        }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        // Process parameter declarations.
+        for (i = 0, iz = node.params.length; i < iz; ++i) {
+            this.visitPattern(node.params[i], { processRightHandNodes: true }, visitPatternCallback);
+        }
 
-module.exports = class DirectoryExistsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+        // if there's a rest argument, add that
+        if (node.rest) {
+            this.visitPattern({
+                type: "RestElement",
+                argument: node.rest
+            }, pattern => {
+                this.currentScope().__define(pattern,
+                    new ParameterDefinition(
+                        pattern,
+                        node,
+                        node.params.length,
+                        true
+                    ));
+            });
+        }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"DirectoryExistsPlugin",
-				(request, resolveContext, callback) => {
-					const fs = resolver.fileSystem;
-					const directory = request.path;
-					if (!directory) return callback();
-					fs.stat(directory, (err, stat) => {
-						if (err || !stat) {
-							if (resolveContext.missingDependencies)
-								resolveContext.missingDependencies.add(directory);
-							if (resolveContext.log)
-								resolveContext.log(directory + " doesn't exist");
-							return callback();
-						}
-						if (!stat.isDirectory()) {
-							if (resolveContext.missingDependencies)
-								resolveContext.missingDependencies.add(directory);
-							if (resolveContext.log)
-								resolveContext.log(directory + " is not a directory");
-							return callback();
-						}
-						if (resolveContext.fileDependencies)
-							resolveContext.fileDependencies.add(directory);
-						resolver.doResolve(
-							target,
-							request,
-							`existing directory ${directory}`,
-							resolveContext,
-							callback
-						);
-					});
-				}
-			);
-	}
-};
+        // In TypeScript there are a number of function-like constructs which have no body,
+        // so check it exists before traversing
+        if (node.body) {
 
+            // Skip BlockStatement to prevent creating BlockStatement scope.
+            if (node.body.type === Syntax.BlockStatement) {
+                this.visitChildren(node.body);
+            } else {
+                this.visit(node.body);
+            }
+        }
 
-/***/ }),
+        this.close(node);
+    }
 
-/***/ 80163:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    visitClass(node) {
+        if (node.type === Syntax.ClassDeclaration) {
+            this.currentScope().__define(node.id,
+                new Definition(
+                    Variable.ClassName,
+                    node.id,
+                    node,
+                    null,
+                    null,
+                    null
+                ));
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+        this.visit(node.superClass);
 
+        this.scopeManager.__nestClassScope(node);
 
+        if (node.id) {
+            this.currentScope().__define(node.id,
+                new Definition(
+                    Variable.ClassName,
+                    node.id,
+                    node
+                ));
+        }
+        this.visit(node.body);
 
-const path = __webpack_require__(71017);
-const DescriptionFileUtils = __webpack_require__(702);
-const forEachBail = __webpack_require__(8266);
-const { processExportsField } = __webpack_require__(28348);
-const { parseIdentifier } = __webpack_require__(7780);
-const { checkExportsFieldTarget } = __webpack_require__(3011);
+        this.close(node);
+    }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {import("./util/entrypoints").ExportsField} ExportsField */
-/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
+    visitProperty(node) {
+        let previous;
 
-module.exports = class ExportsFieldPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Set<string>} conditionNames condition names
-	 * @param {string | string[]} fieldNamePath name path
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, conditionNames, fieldNamePath, target) {
-		this.source = source;
-		this.target = target;
-		this.conditionNames = conditionNames;
-		this.fieldName = fieldNamePath;
-		/** @type {WeakMap<any, FieldProcessor>} */
-		this.fieldProcessorCache = new WeakMap();
-	}
+        if (node.computed) {
+            this.visit(node.key);
+        }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ExportsFieldPlugin", (request, resolveContext, callback) => {
-				// When there is no description file, abort
-				if (!request.descriptionFilePath) return callback();
-				if (
-					// When the description file is inherited from parent, abort
-					// (There is no description file inside of this package)
-					request.relativePath !== "." ||
-					request.request === undefined
-				)
-					return callback();
+        const isMethodDefinition = node.type === Syntax.MethodDefinition;
 
-				const remainingRequest =
-					request.query || request.fragment
-						? (request.request === "." ? "./" : request.request) +
-						  request.query +
-						  request.fragment
-						: request.request;
-				/** @type {ExportsField|null} */
-				const exportsField = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.fieldName
-				);
-				if (!exportsField) return callback();
+        if (isMethodDefinition) {
+            previous = this.pushInnerMethodDefinition(true);
+        }
+        this.visit(node.value);
+        if (isMethodDefinition) {
+            this.popInnerMethodDefinition(previous);
+        }
+    }
 
-				if (request.directory) {
-					return callback(
-						new Error(
-							`Resolving to directories is not possible with the exports field (request was ${remainingRequest}/)`
-						)
-					);
-				}
+    visitForIn(node) {
+        if (node.left.type === Syntax.VariableDeclaration && node.left.kind !== "var") {
+            this.scopeManager.__nestForScope(node);
+        }
 
-				let paths;
+        if (node.left.type === Syntax.VariableDeclaration) {
+            this.visit(node.left);
+            this.visitPattern(node.left.declarations[0].id, pattern => {
+                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, null, true, true);
+            });
+        } else {
+            this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
+                let maybeImplicitGlobal = null;
 
-				try {
-					// We attach the cache to the description file instead of the exportsField value
-					// because we use a WeakMap and the exportsField could be a string too.
-					// Description file is always an object when exports field can be accessed.
-					let fieldProcessor = this.fieldProcessorCache.get(
-						request.descriptionFileData
-					);
-					if (fieldProcessor === undefined) {
-						fieldProcessor = processExportsField(exportsField);
-						this.fieldProcessorCache.set(
-							request.descriptionFileData,
-							fieldProcessor
-						);
-					}
-					paths = fieldProcessor(remainingRequest, this.conditionNames);
-				} catch (err) {
-					if (resolveContext.log) {
-						resolveContext.log(
-							`Exports field in ${request.descriptionFilePath} can't be processed: ${err}`
-						);
-					}
-					return callback(err);
-				}
+                if (!this.currentScope().isStrict) {
+                    maybeImplicitGlobal = {
+                        pattern,
+                        node
+                    };
+                }
+                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
+                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, true, false);
+            });
+        }
+        this.visit(node.right);
+        this.visit(node.body);
 
-				if (paths.length === 0) {
-					return callback(
-						new Error(
-							`Package path ${remainingRequest} is not exported from package ${request.descriptionFileRoot} (see exports field in ${request.descriptionFilePath})`
-						)
-					);
-				}
+        this.close(node);
+    }
 
-				forEachBail(
-					paths,
-					(p, callback) => {
-						const parsedIdentifier = parseIdentifier(p);
+    visitVariableDeclaration(variableTargetScope, type, node, index) {
 
-						if (!parsedIdentifier) return callback();
+        const decl = node.declarations[index];
+        const init = decl.init;
 
-						const [relativePath, query, fragment] = parsedIdentifier;
+        this.visitPattern(decl.id, { processRightHandNodes: true }, (pattern, info) => {
+            variableTargetScope.__define(
+                pattern,
+                new Definition(
+                    type,
+                    pattern,
+                    decl,
+                    node,
+                    index,
+                    node.kind
+                )
+            );
 
-						const error = checkExportsFieldTarget(relativePath);
+            this.referencingDefaultValue(pattern, info.assignments, null, true);
+            if (init) {
+                this.currentScope().__referencing(pattern, Reference.WRITE, init, null, !info.topLevel, true);
+            }
+        });
+    }
 
-						if (error) {
-							return callback(error);
-						}
+    AssignmentExpression(node) {
+        if (PatternVisitor.isPattern(node.left)) {
+            if (node.operator === "=") {
+                this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
+                    let maybeImplicitGlobal = null;
 
-						const obj = {
-							...request,
-							request: undefined,
-							path: path.join(
-								/** @type {string} */ (request.descriptionFileRoot),
-								relativePath
-							),
-							relativePath,
-							query,
-							fragment
-						};
+                    if (!this.currentScope().isStrict) {
+                        maybeImplicitGlobal = {
+                            pattern,
+                            node
+                        };
+                    }
+                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
+                    this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, !info.topLevel, false);
+                });
+            } else {
+                this.currentScope().__referencing(node.left, Reference.RW, node.right);
+            }
+        } else {
+            this.visit(node.left);
+        }
+        this.visit(node.right);
+    }
 
-						resolver.doResolve(
-							target,
-							obj,
-							"using exports field: " + p,
-							resolveContext,
-							callback
-						);
-					},
-					(err, result) => callback(err, result || null)
-				);
-			});
-	}
-};
+    CatchClause(node) {
+        this.scopeManager.__nestCatchScope(node);
 
+        this.visitPattern(node.param, { processRightHandNodes: true }, (pattern, info) => {
+            this.currentScope().__define(pattern,
+                new Definition(
+                    Variable.CatchClause,
+                    node.param,
+                    node,
+                    null,
+                    null,
+                    null
+                ));
+            this.referencingDefaultValue(pattern, info.assignments, null, true);
+        });
+        this.visit(node.body);
 
-/***/ }),
+        this.close(node);
+    }
 
-/***/ 98699:
-/***/ (function(module) {
+    Program(node) {
+        this.scopeManager.__nestGlobalScope(node);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        if (this.scopeManager.__isNodejsScope()) {
 
+            // Force strictness of GlobalScope to false when using node.js scope.
+            this.currentScope().isStrict = false;
+            this.scopeManager.__nestFunctionScope(node, false);
+        }
 
+        if (this.scopeManager.__isES6() && this.scopeManager.isModule()) {
+            this.scopeManager.__nestModuleScope(node);
+        }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-
-module.exports = class FileExistsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
-
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		const fs = resolver.fileSystem;
-		resolver
-			.getHook(this.source)
-			.tapAsync("FileExistsPlugin", (request, resolveContext, callback) => {
-				const file = request.path;
-				if (!file) return callback();
-				fs.stat(file, (err, stat) => {
-					if (err || !stat) {
-						if (resolveContext.missingDependencies)
-							resolveContext.missingDependencies.add(file);
-						if (resolveContext.log) resolveContext.log(file + " doesn't exist");
-						return callback();
-					}
-					if (!stat.isFile()) {
-						if (resolveContext.missingDependencies)
-							resolveContext.missingDependencies.add(file);
-						if (resolveContext.log) resolveContext.log(file + " is not a file");
-						return callback();
-					}
-					if (resolveContext.fileDependencies)
-						resolveContext.fileDependencies.add(file);
-					resolver.doResolve(
-						target,
-						request,
-						"existing file: " + file,
-						resolveContext,
-						callback
-					);
-				});
-			});
-	}
-};
+        if (this.scopeManager.isStrictModeSupported() && this.scopeManager.isImpliedStrict()) {
+            this.currentScope().isStrict = true;
+        }
 
+        this.visitChildren(node);
+        this.close(node);
+    }
 
-/***/ }),
+    Identifier(node) {
+        this.currentScope().__referencing(node);
+    }
 
-/***/ 86058:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    UpdateExpression(node) {
+        if (PatternVisitor.isPattern(node.argument)) {
+            this.currentScope().__referencing(node.argument, Reference.RW, null);
+        } else {
+            this.visitChildren(node);
+        }
+    }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+    MemberExpression(node) {
+        this.visit(node.object);
+        if (node.computed) {
+            this.visit(node.property);
+        }
+    }
 
+    Property(node) {
+        this.visitProperty(node);
+    }
 
+    MethodDefinition(node) {
+        this.visitProperty(node);
+    }
 
-const path = __webpack_require__(71017);
-const DescriptionFileUtils = __webpack_require__(702);
-const forEachBail = __webpack_require__(8266);
-const { processImportsField } = __webpack_require__(28348);
-const { parseIdentifier } = __webpack_require__(7780);
+    BreakStatement() {} // eslint-disable-line class-methods-use-this
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
-/** @typedef {import("./util/entrypoints").ImportsField} ImportsField */
+    ContinueStatement() {} // eslint-disable-line class-methods-use-this
 
-const dotCode = ".".charCodeAt(0);
+    LabeledStatement(node) {
+        this.visit(node.body);
+    }
 
-module.exports = class ImportsFieldPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Set<string>} conditionNames condition names
-	 * @param {string | string[]} fieldNamePath name path
-	 * @param {string | ResolveStepHook} targetFile target file
-	 * @param {string | ResolveStepHook} targetPackage target package
-	 */
-	constructor(
-		source,
-		conditionNames,
-		fieldNamePath,
-		targetFile,
-		targetPackage
-	) {
-		this.source = source;
-		this.targetFile = targetFile;
-		this.targetPackage = targetPackage;
-		this.conditionNames = conditionNames;
-		this.fieldName = fieldNamePath;
-		/** @type {WeakMap<any, FieldProcessor>} */
-		this.fieldProcessorCache = new WeakMap();
-	}
+    ForStatement(node) {
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const targetFile = resolver.ensureHook(this.targetFile);
-		const targetPackage = resolver.ensureHook(this.targetPackage);
+        // Create ForStatement declaration.
+        // NOTE: In ES6, ForStatement dynamically generates
+        // per iteration environment. However, escope is
+        // a static analyzer, we only generate one scope for ForStatement.
+        if (node.init && node.init.type === Syntax.VariableDeclaration && node.init.kind !== "var") {
+            this.scopeManager.__nestForScope(node);
+        }
 
-		resolver
-			.getHook(this.source)
-			.tapAsync("ImportsFieldPlugin", (request, resolveContext, callback) => {
-				// When there is no description file, abort
-				if (!request.descriptionFilePath || request.request === undefined) {
-					return callback();
-				}
+        this.visitChildren(node);
 
-				const remainingRequest =
-					request.request + request.query + request.fragment;
-				/** @type {ImportsField|null} */
-				const importsField = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.fieldName
-				);
-				if (!importsField) return callback();
+        this.close(node);
+    }
 
-				if (request.directory) {
-					return callback(
-						new Error(
-							`Resolving to directories is not possible with the imports field (request was ${remainingRequest}/)`
-						)
-					);
-				}
+    ClassExpression(node) {
+        this.visitClass(node);
+    }
 
-				let paths;
+    ClassDeclaration(node) {
+        this.visitClass(node);
+    }
 
-				try {
-					// We attach the cache to the description file instead of the importsField value
-					// because we use a WeakMap and the importsField could be a string too.
-					// Description file is always an object when exports field can be accessed.
-					let fieldProcessor = this.fieldProcessorCache.get(
-						request.descriptionFileData
-					);
-					if (fieldProcessor === undefined) {
-						fieldProcessor = processImportsField(importsField);
-						this.fieldProcessorCache.set(
-							request.descriptionFileData,
-							fieldProcessor
-						);
-					}
-					paths = fieldProcessor(remainingRequest, this.conditionNames);
-				} catch (err) {
-					if (resolveContext.log) {
-						resolveContext.log(
-							`Imports field in ${request.descriptionFilePath} can't be processed: ${err}`
-						);
-					}
-					return callback(err);
-				}
+    CallExpression(node) {
 
-				if (paths.length === 0) {
-					return callback(
-						new Error(
-							`Package import ${remainingRequest} is not imported from package ${request.descriptionFileRoot} (see imports field in ${request.descriptionFilePath})`
-						)
-					);
-				}
+        // Check this is direct call to eval
+        if (!this.scopeManager.__ignoreEval() && node.callee.type === Syntax.Identifier && node.callee.name === "eval") {
 
-				forEachBail(
-					paths,
-					(p, callback) => {
-						const parsedIdentifier = parseIdentifier(p);
+            // NOTE: This should be `variableScope`. Since direct eval call always creates Lexical environment and
+            // let / const should be enclosed into it. Only VariableDeclaration affects on the caller's environment.
+            this.currentScope().variableScope.__detectEval();
+        }
+        this.visitChildren(node);
+    }
 
-						if (!parsedIdentifier) return callback();
+    BlockStatement(node) {
+        if (this.scopeManager.__isES6()) {
+            this.scopeManager.__nestBlockScope(node);
+        }
 
-						const [path_, query, fragment] = parsedIdentifier;
+        this.visitChildren(node);
 
-						switch (path_.charCodeAt(0)) {
-							// should be relative
-							case dotCode: {
-								const obj = {
-									...request,
-									request: undefined,
-									path: path.join(
-										/** @type {string} */ (request.descriptionFileRoot),
-										path_
-									),
-									relativePath: path_,
-									query,
-									fragment
-								};
+        this.close(node);
+    }
 
-								resolver.doResolve(
-									targetFile,
-									obj,
-									"using imports field: " + p,
-									resolveContext,
-									callback
-								);
-								break;
-							}
+    ThisExpression() {
+        this.currentScope().variableScope.__detectThis();
+    }
 
-							// package resolving
-							default: {
-								const obj = {
-									...request,
-									request: path_,
-									relativePath: path_,
-									fullySpecified: true,
-									query,
-									fragment
-								};
+    WithStatement(node) {
+        this.visit(node.object);
 
-								resolver.doResolve(
-									targetPackage,
-									obj,
-									"using imports field: " + p,
-									resolveContext,
-									callback
-								);
-							}
-						}
-					},
-					(err, result) => callback(err, result || null)
-				);
-			});
-	}
-};
+        // Then nest scope for WithStatement.
+        this.scopeManager.__nestWithScope(node);
 
+        this.visit(node.body);
 
-/***/ }),
+        this.close(node);
+    }
 
-/***/ 20879:
-/***/ (function(module) {
+    VariableDeclaration(node) {
+        const variableTargetScope = (node.kind === "var") ? this.currentScope().variableScope : this.currentScope();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        for (let i = 0, iz = node.declarations.length; i < iz; ++i) {
+            const decl = node.declarations[i];
 
+            this.visitVariableDeclaration(variableTargetScope, Variable.Variable, node, i);
+            if (decl.init) {
+                this.visit(decl.init);
+            }
+        }
+    }
 
+    // sec 13.11.8
+    SwitchStatement(node) {
+        this.visit(node.discriminant);
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        if (this.scopeManager.__isES6()) {
+            this.scopeManager.__nestSwitchScope(node);
+        }
 
-const namespaceStartCharCode = "@".charCodeAt(0);
+        for (let i = 0, iz = node.cases.length; i < iz; ++i) {
+            this.visit(node.cases[i]);
+        }
 
-module.exports = class JoinRequestPartPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+        this.close(node);
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"JoinRequestPartPlugin",
-				(request, resolveContext, callback) => {
-					const req = request.request || "";
-					let i = req.indexOf("/", 3);
+    FunctionDeclaration(node) {
+        this.visitFunction(node);
+    }
 
-					if (i >= 0 && req.charCodeAt(2) === namespaceStartCharCode) {
-						i = req.indexOf("/", i + 1);
-					}
+    FunctionExpression(node) {
+        this.visitFunction(node);
+    }
 
-					let moduleName, remainingRequest, fullySpecified;
-					if (i < 0) {
-						moduleName = req;
-						remainingRequest = ".";
-						fullySpecified = false;
-					} else {
-						moduleName = req.slice(0, i);
-						remainingRequest = "." + req.slice(i);
-						fullySpecified = request.fullySpecified;
-					}
-					const obj = {
-						...request,
-						path: resolver.join(request.path, moduleName),
-						relativePath:
-							request.relativePath &&
-							resolver.join(request.relativePath, moduleName),
-						request: remainingRequest,
-						fullySpecified
-					};
-					resolver.doResolve(target, obj, null, resolveContext, callback);
-				}
-			);
-	}
-};
+    ForOfStatement(node) {
+        this.visitForIn(node);
+    }
 
+    ForInStatement(node) {
+        this.visitForIn(node);
+    }
 
-/***/ }),
+    ArrowFunctionExpression(node) {
+        this.visitFunction(node);
+    }
 
-/***/ 71474:
-/***/ (function(module) {
+    ImportDeclaration(node) {
+        assert(this.scopeManager.__isES6() && this.scopeManager.isModule(), "ImportDeclaration should appear when the mode is ES6 and in the module context.");
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        const importer = new Importer(node, this);
 
+        importer.visit(node);
+    }
 
+    visitExportDeclaration(node) {
+        if (node.source) {
+            return;
+        }
+        if (node.declaration) {
+            this.visit(node.declaration);
+            return;
+        }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        this.visitChildren(node);
+    }
 
-module.exports = class JoinRequestPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+    // TODO: ExportDeclaration doesn't exist. for bc?
+    ExportDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => {
-				const obj = {
-					...request,
-					path: resolver.join(request.path, request.request),
-					relativePath:
-						request.relativePath &&
-						resolver.join(request.relativePath, request.request),
-					request: undefined
-				};
-				resolver.doResolve(target, obj, null, resolveContext, callback);
-			});
-	}
-};
+    ExportAllDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
+    ExportDefaultDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
-/***/ }),
+    ExportNamedDeclaration(node) {
+        this.visitExportDeclaration(node);
+    }
 
-/***/ 47032:
-/***/ (function(module) {
+    ExportSpecifier(node) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        // TODO: `node.id` doesn't exist. for bc?
+        const local = (node.id || node.local);
 
+        this.visit(local);
+    }
 
+    MetaProperty() { // eslint-disable-line class-methods-use-this
 
-/** @typedef {import("./Resolver")} Resolver */
+        // do nothing.
+    }
+}
 
-module.exports = class LogInfoPlugin {
-	constructor(source) {
-		this.source = source;
-	}
+module.exports = Referencer;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const source = this.source;
-		resolver
-			.getHook(this.source)
-			.tapAsync("LogInfoPlugin", (request, resolveContext, callback) => {
-				if (!resolveContext.log) return callback();
-				const log = resolveContext.log;
-				const prefix = "[" + source + "] ";
-				if (request.path)
-					log(prefix + "Resolving in directory: " + request.path);
-				if (request.request)
-					log(prefix + "Resolving request: " + request.request);
-				if (request.module) log(prefix + "Request is an module request.");
-				if (request.directory) log(prefix + "Request is a directory request.");
-				if (request.query)
-					log(prefix + "Resolving request query: " + request.query);
-				if (request.fragment)
-					log(prefix + "Resolving request fragment: " + request.fragment);
-				if (request.descriptionFilePath)
-					log(
-						prefix + "Has description data from " + request.descriptionFilePath
-					);
-				if (request.relativePath)
-					log(
-						prefix +
-							"Relative path from description file is: " +
-							request.relativePath
-					);
-				callback();
-			});
-	}
-};
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 73507:
+/***/ 96988:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-const path = __webpack_require__(71017);
-const DescriptionFileUtils = __webpack_require__(702);
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {{name: string|Array<string>, forceRelative: boolean}} MainFieldOptions */
 
-const alreadyTriedMainField = Symbol("alreadyTriedMainField");
+/* eslint-disable no-underscore-dangle */
 
-module.exports = class MainFieldPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {MainFieldOptions} options options
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, options, target) {
-		this.source = source;
-		this.options = options;
-		this.target = target;
-	}
+const Scope = __webpack_require__(16313);
+const assert = __webpack_require__(39491);
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("MainFieldPlugin", (request, resolveContext, callback) => {
-				if (
-					request.path !== request.descriptionFileRoot ||
-					request[alreadyTriedMainField] === request.descriptionFilePath ||
-					!request.descriptionFilePath
-				)
-					return callback();
-				const filename = path.basename(request.descriptionFilePath);
-				let mainModule = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.options.name
-				);
+const GlobalScope = Scope.GlobalScope;
+const CatchScope = Scope.CatchScope;
+const WithScope = Scope.WithScope;
+const ModuleScope = Scope.ModuleScope;
+const ClassScope = Scope.ClassScope;
+const SwitchScope = Scope.SwitchScope;
+const FunctionScope = Scope.FunctionScope;
+const ForScope = Scope.ForScope;
+const FunctionExpressionNameScope = Scope.FunctionExpressionNameScope;
+const BlockScope = Scope.BlockScope;
 
-				if (
-					!mainModule ||
-					typeof mainModule !== "string" ||
-					mainModule === "." ||
-					mainModule === "./"
-				) {
-					return callback();
-				}
-				if (this.options.forceRelative && !/^\.\.?\//.test(mainModule))
-					mainModule = "./" + mainModule;
-				const obj = {
-					...request,
-					request: mainModule,
-					module: false,
-					directory: mainModule.endsWith("/"),
-					[alreadyTriedMainField]: request.descriptionFilePath
-				};
-				return resolver.doResolve(
-					target,
-					obj,
-					"use " +
-						mainModule +
-						" from " +
-						this.options.name +
-						" in " +
-						filename,
-					resolveContext,
-					callback
-				);
-			});
-	}
-};
+/**
+ * @class ScopeManager
+ */
+class ScopeManager {
+    constructor(options) {
+        this.scopes = [];
+        this.globalScope = null;
+        this.__nodeToScope = new WeakMap();
+        this.__currentScope = null;
+        this.__options = options;
+        this.__declaredVariables = new WeakMap();
+    }
 
+    __useDirective() {
+        return this.__options.directive;
+    }
 
-/***/ }),
+    __isOptimistic() {
+        return this.__options.optimistic;
+    }
 
-/***/ 3688:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    __ignoreEval() {
+        return this.__options.ignoreEval;
+    }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    __isNodejsScope() {
+        return this.__options.nodejsScope;
+    }
 
+    isModule() {
+        return this.__options.sourceType === "module";
+    }
 
+    isImpliedStrict() {
+        return this.__options.impliedStrict;
+    }
 
-const forEachBail = __webpack_require__(8266);
-const getPaths = __webpack_require__(48608);
+    isStrictModeSupported() {
+        return this.__options.ecmaVersion >= 5;
+    }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    // Returns appropriate scope for this node.
+    __get(node) {
+        return this.__nodeToScope.get(node);
+    }
 
-module.exports = class ModulesInHierachicDirectoriesPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | Array<string>} directories directories
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, directories, target) {
-		this.source = source;
-		this.directories = /** @type {Array<string>} */ ([]).concat(directories);
-		this.target = target;
-	}
+    /**
+     * Get variables that are declared by the node.
+     *
+     * "are declared by the node" means the node is same as `Variable.defs[].node` or `Variable.defs[].parent`.
+     * If the node declares nothing, this method returns an empty array.
+     * CAUTION: This API is experimental. See https://github.com/estools/escope/pull/69 for more details.
+     *
+     * @param {Espree.Node} node - a node to get.
+     * @returns {Variable[]} variables that declared by the node.
+     */
+    getDeclaredVariables(node) {
+        return this.__declaredVariables.get(node) || [];
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync(
-				"ModulesInHierachicDirectoriesPlugin",
-				(request, resolveContext, callback) => {
-					const fs = resolver.fileSystem;
-					const addrs = getPaths(request.path)
-						.paths.map(p => {
-							return this.directories.map(d => resolver.join(p, d));
-						})
-						.reduce((array, p) => {
-							array.push.apply(array, p);
-							return array;
-						}, []);
-					forEachBail(
-						addrs,
-						(addr, callback) => {
-							fs.stat(addr, (err, stat) => {
-								if (!err && stat && stat.isDirectory()) {
-									const obj = {
-										...request,
-										path: addr,
-										request: "./" + request.request,
-										module: false
-									};
-									const message = "looking for modules in " + addr;
-									return resolver.doResolve(
-										target,
-										obj,
-										message,
-										resolveContext,
-										callback
-									);
-								}
-								if (resolveContext.log)
-									resolveContext.log(
-										addr + " doesn't exist or is not a directory"
-									);
-								if (resolveContext.missingDependencies)
-									resolveContext.missingDependencies.add(addr);
-								return callback();
-							});
-						},
-						callback
-					);
-				}
-			);
-	}
-};
+    /**
+     * acquire scope from node.
+     * @method ScopeManager#acquire
+     * @param {Espree.Node} node - node for the acquired scope.
+     * @param {boolean=} inner - look up the most inner scope, default value is false.
+     * @returns {Scope?} Scope from node
+     */
+    acquire(node, inner) {
 
+        /**
+         * predicate
+         * @param {Scope} testScope - scope to test
+         * @returns {boolean} predicate
+         */
+        function predicate(testScope) {
+            if (testScope.type === "function" && testScope.functionExpressionScope) {
+                return false;
+            }
+            return true;
+        }
 
-/***/ }),
+        const scopes = this.__get(node);
 
-/***/ 48952:
-/***/ (function(module) {
+        if (!scopes || scopes.length === 0) {
+            return null;
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        // Heuristic selection from all scopes.
+        // If you would like to get all scopes, please use ScopeManager#acquireAll.
+        if (scopes.length === 1) {
+            return scopes[0];
+        }
 
+        if (inner) {
+            for (let i = scopes.length - 1; i >= 0; --i) {
+                const scope = scopes[i];
 
+                if (predicate(scope)) {
+                    return scope;
+                }
+            }
+        } else {
+            for (let i = 0, iz = scopes.length; i < iz; ++i) {
+                const scope = scopes[i];
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+                if (predicate(scope)) {
+                    return scope;
+                }
+            }
+        }
 
-module.exports = class ModulesInRootPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} path path
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, path, target) {
-		this.source = source;
-		this.path = path;
-		this.target = target;
-	}
+        return null;
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => {
-				const obj = {
-					...request,
-					path: this.path,
-					request: "./" + request.request,
-					module: false
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"looking for modules in " + this.path,
-					resolveContext,
-					callback
-				);
-			});
-	}
-};
+    /**
+     * acquire all scopes from node.
+     * @method ScopeManager#acquireAll
+     * @param {Espree.Node} node - node for the acquired scope.
+     * @returns {Scopes?} Scope array
+     */
+    acquireAll(node) {
+        return this.__get(node);
+    }
 
+    /**
+     * release the node.
+     * @method ScopeManager#release
+     * @param {Espree.Node} node - releasing node.
+     * @param {boolean=} inner - look up the most inner scope, default value is false.
+     * @returns {Scope?} upper scope for the node.
+     */
+    release(node, inner) {
+        const scopes = this.__get(node);
 
-/***/ }),
+        if (scopes && scopes.length) {
+            const scope = scopes[0].upper;
 
-/***/ 79135:
-/***/ (function(module) {
+            if (!scope) {
+                return null;
+            }
+            return this.acquire(scope.block, inner);
+        }
+        return null;
+    }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    attach() { } // eslint-disable-line class-methods-use-this
 
+    detach() { } // eslint-disable-line class-methods-use-this
 
+    __nestScope(scope) {
+        if (scope instanceof GlobalScope) {
+            assert(this.__currentScope === null);
+            this.globalScope = scope;
+        }
+        this.__currentScope = scope;
+        return scope;
+    }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    __nestGlobalScope(node) {
+        return this.__nestScope(new GlobalScope(this, node));
+    }
 
-module.exports = class NextPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+    __nestBlockScope(node) {
+        return this.__nestScope(new BlockScope(this, this.__currentScope, node));
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("NextPlugin", (request, resolveContext, callback) => {
-				resolver.doResolve(target, request, null, resolveContext, callback);
-			});
-	}
-};
+    __nestFunctionScope(node, isMethodDefinition) {
+        return this.__nestScope(new FunctionScope(this, this.__currentScope, node, isMethodDefinition));
+    }
 
+    __nestForScope(node) {
+        return this.__nestScope(new ForScope(this, this.__currentScope, node));
+    }
 
-/***/ }),
+    __nestCatchScope(node) {
+        return this.__nestScope(new CatchScope(this, this.__currentScope, node));
+    }
 
-/***/ 15234:
-/***/ (function(module) {
+    __nestWithScope(node) {
+        return this.__nestScope(new WithScope(this, this.__currentScope, node));
+    }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    __nestClassScope(node) {
+        return this.__nestScope(new ClassScope(this, this.__currentScope, node));
+    }
 
+    __nestSwitchScope(node) {
+        return this.__nestScope(new SwitchScope(this, this.__currentScope, node));
+    }
 
+    __nestModuleScope(node) {
+        return this.__nestScope(new ModuleScope(this, this.__currentScope, node));
+    }
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    __nestFunctionExpressionNameScope(node) {
+        return this.__nestScope(new FunctionExpressionNameScope(this, this.__currentScope, node));
+    }
 
-module.exports = class ParsePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Partial<ResolveRequest>} requestOptions request options
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, requestOptions, target) {
-		this.source = source;
-		this.requestOptions = requestOptions;
-		this.target = target;
-	}
+    __isES6() {
+        return this.__options.ecmaVersion >= 6;
+    }
+}
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("ParsePlugin", (request, resolveContext, callback) => {
-				const parsed = resolver.parse(/** @type {string} */ (request.request));
-				const obj = { ...request, ...parsed, ...this.requestOptions };
-				if (request.query && !parsed.query) {
-					obj.query = request.query;
-				}
-				if (request.fragment && !parsed.fragment) {
-					obj.fragment = request.fragment;
-				}
-				if (parsed && resolveContext.log) {
-					if (parsed.module) resolveContext.log("Parsed request is a module");
-					if (parsed.directory)
-						resolveContext.log("Parsed request is a directory");
-				}
-				// There is an edge-case where a request with # can be a path or a fragment -> try both
-				if (obj.request && !obj.query && obj.fragment) {
-					const directory = obj.fragment.endsWith("/");
-					const alternative = {
-						...obj,
-						directory,
-						request:
-							obj.request +
-							(obj.directory ? "/" : "") +
-							(directory ? obj.fragment.slice(0, -1) : obj.fragment),
-						fragment: ""
-					};
-					resolver.doResolve(
-						target,
-						alternative,
-						null,
-						resolveContext,
-						(err, result) => {
-							if (err) return callback(err);
-							if (result) return callback(null, result);
-							resolver.doResolve(target, obj, null, resolveContext, callback);
-						}
-					);
-					return;
-				}
-				resolver.doResolve(target, obj, null, resolveContext, callback);
-			});
-	}
-};
+module.exports = ScopeManager;
+
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 71488:
-/***/ (function(module) {
+/***/ 16313:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Maël Nison @arcanis
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-undefined */
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/**
- * @typedef {Object} PnpApiImpl
- * @property {function(string, string, object): string} resolveToUnqualified
- */
+const Syntax = (__webpack_require__(18350).Syntax);
 
-module.exports = class PnpPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {PnpApiImpl} pnpApi pnpApi
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, pnpApi, target) {
-		this.source = source;
-		this.pnpApi = pnpApi;
-		this.target = target;
-	}
-
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("PnpPlugin", (request, resolveContext, callback) => {
-				const req = request.request;
-				if (!req) return callback();
-
-				// The trailing slash indicates to PnP that this value is a folder rather than a file
-				const issuer = `${request.path}/`;
-
-				const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req);
-				if (!packageMatch) return callback();
-
-				const packageName = packageMatch[0];
-				const innerRequest = `.${req.slice(packageName.length)}`;
-
-				let resolution;
-				let apiResolution;
-				try {
-					resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, {
-						considerBuiltins: false
-					});
-					if (resolveContext.fileDependencies) {
-						apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, {
-							considerBuiltins: false
-						});
-					}
-				} catch (error) {
-					if (
-						error.code === "MODULE_NOT_FOUND" &&
-						error.pnpCode === "UNDECLARED_DEPENDENCY"
-					) {
-						// This is not a PnP managed dependency.
-						// Try to continue resolving with our alternatives
-						if (resolveContext.log) {
-							resolveContext.log(`request is not managed by the pnpapi`);
-							for (const line of error.message.split("\n").filter(Boolean))
-								resolveContext.log(`  ${line}`);
-						}
-						return callback();
-					}
-					return callback(error);
-				}
+const Reference = __webpack_require__(64945);
+const Variable = __webpack_require__(82971);
+const Definition = (__webpack_require__(70665).Definition);
+const assert = __webpack_require__(39491);
 
-				if (resolution === packageName) return callback();
+/**
+ * Test if scope is struct
+ * @param {Scope} scope - scope
+ * @param {Block} block - block
+ * @param {boolean} isMethodDefinition - is method definition
+ * @param {boolean} useDirective - use directive
+ * @returns {boolean} is strict scope
+ */
+function isStrictScope(scope, block, isMethodDefinition, useDirective) {
+    let body;
 
-				if (apiResolution && resolveContext.fileDependencies) {
-					resolveContext.fileDependencies.add(apiResolution);
-				}
+    // When upper scope is exists and strict, inner scope is also strict.
+    if (scope.upper && scope.upper.isStrict) {
+        return true;
+    }
 
-				const obj = {
-					...request,
-					path: resolution,
-					request: innerRequest,
-					ignoreSymlinks: true,
-					fullySpecified: request.fullySpecified && innerRequest !== "."
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					`resolved by pnp to ${resolution}`,
-					resolveContext,
-					(err, result) => {
-						if (err) return callback(err);
-						if (result) return callback(null, result);
-						// Skip alternatives
-						return callback(null, null);
-					}
-				);
-			});
-	}
-};
+    if (isMethodDefinition) {
+        return true;
+    }
 
+    if (scope.type === "class" || scope.type === "module") {
+        return true;
+    }
 
-/***/ }),
+    if (scope.type === "block" || scope.type === "switch") {
+        return false;
+    }
 
-/***/ 37432:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    if (scope.type === "function") {
+        if (block.type === Syntax.ArrowFunctionExpression && block.body.type !== Syntax.BlockStatement) {
+            return false;
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        if (block.type === Syntax.Program) {
+            body = block;
+        } else {
+            body = block.body;
+        }
 
+        if (!body) {
+            return false;
+        }
+    } else if (scope.type === "global") {
+        body = block;
+    } else {
+        return false;
+    }
 
+    // Search 'use strict' directive.
+    if (useDirective) {
+        for (let i = 0, iz = body.body.length; i < iz; ++i) {
+            const stmt = body.body[i];
 
-const { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } = __webpack_require__(41242);
-const createInnerContext = __webpack_require__(95478);
-const { parseIdentifier } = __webpack_require__(7780);
-const {
-	normalize,
-	cachedJoin: join,
-	getType,
-	PathType
-} = __webpack_require__(3011);
+            if (stmt.type !== Syntax.DirectiveStatement) {
+                break;
+            }
+            if (stmt.raw === "\"use strict\"" || stmt.raw === "'use strict'") {
+                return true;
+            }
+        }
+    } else {
+        for (let i = 0, iz = body.body.length; i < iz; ++i) {
+            const stmt = body.body[i];
 
-/** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */
+            if (stmt.type !== Syntax.ExpressionStatement) {
+                break;
+            }
+            const expr = stmt.expression;
 
-/**
- * @typedef {Object} FileSystemStats
- * @property {function(): boolean} isDirectory
- * @property {function(): boolean} isFile
- */
+            if (expr.type !== Syntax.Literal || typeof expr.value !== "string") {
+                break;
+            }
+            if (expr.raw !== null && expr.raw !== undefined) {
+                if (expr.raw === "\"use strict\"" || expr.raw === "'use strict'") {
+                    return true;
+                }
+            } else {
+                if (expr.value === "use strict") {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
 
 /**
- * @typedef {Object} FileSystemDirent
- * @property {Buffer | string} name
- * @property {function(): boolean} isDirectory
- * @property {function(): boolean} isFile
+ * Register scope
+ * @param {ScopeManager} scopeManager - scope manager
+ * @param {Scope} scope - scope
+ * @returns {void}
  */
+function registerScope(scopeManager, scope) {
+    scopeManager.scopes.push(scope);
 
-/**
- * @typedef {Object} PossibleFileSystemError
- * @property {string=} code
- * @property {number=} errno
- * @property {string=} path
- * @property {string=} syscall
- */
+    const scopes = scopeManager.__nodeToScope.get(scope.block);
 
-/**
- * @template T
- * @callback FileSystemCallback
- * @param {PossibleFileSystemError & Error | null | undefined} err
- * @param {T=} result
- */
+    if (scopes) {
+        scopes.push(scope);
+    } else {
+        scopeManager.__nodeToScope.set(scope.block, [scope]);
+    }
+}
 
 /**
- * @typedef {Object} FileSystem
- * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readFile
- * @property {(function(string, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void) & function(string, object, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void} readdir
- * @property {((function(string, FileSystemCallback<object>): void) & function(string, object, FileSystemCallback<object>): void)=} readJson
- * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readlink
- * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void=} lstat
- * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} stat
+ * Should be statically
+ * @param {Object} def - def
+ * @returns {boolean} should be statically
  */
+function shouldBeStatically(def) {
+    return (
+        (def.type === Variable.ClassName) ||
+        (def.type === Variable.Variable && def.parent.kind !== "var")
+    );
+}
 
 /**
- * @typedef {Object} SyncFileSystem
- * @property {function(string, object=): Buffer | string} readFileSync
- * @property {function(string, object=): (Buffer | string)[] | FileSystemDirent[]} readdirSync
- * @property {(function(string, object=): object)=} readJsonSync
- * @property {function(string, object=): Buffer | string} readlinkSync
- * @property {function(string, object=): FileSystemStats=} lstatSync
- * @property {function(string, object=): FileSystemStats} statSync
+ * @class Scope
  */
+class Scope {
+    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
 
-/**
- * @typedef {Object} ParsedIdentifier
- * @property {string} request
- * @property {string} query
- * @property {string} fragment
- * @property {boolean} directory
- * @property {boolean} module
- * @property {boolean} file
- * @property {boolean} internal
- */
+        /**
+         * One of 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.
+         * @member {String} Scope#type
+         */
+        this.type = type;
 
-/**
- * @typedef {Object} BaseResolveRequest
- * @property {string | false} path
- * @property {string=} descriptionFilePath
- * @property {string=} descriptionFileRoot
- * @property {object=} descriptionFileData
- * @property {string=} relativePath
- * @property {boolean=} ignoreSymlinks
- * @property {boolean=} fullySpecified
- */
+        /**
+         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name
+         * : Variable }</code>.
+         * @member {Map} Scope#set
+         */
+        this.set = new Map();
 
-/** @typedef {BaseResolveRequest & Partial<ParsedIdentifier>} ResolveRequest */
+        /**
+         * The tainted variables of this scope, as <code>{ Variable.name :
+         * boolean }</code>.
+         * @member {Map} Scope#taints */
+        this.taints = new Map();
 
-/**
- * String with special formatting
- * @typedef {string} StackEntry
- */
+        /**
+         * Generally, through the lexical scoping of JS you can always know
+         * which variable an identifier in the source code refers to. There are
+         * a few exceptions to this rule. With 'global' and 'with' scopes you
+         * can only decide at runtime which variable a reference refers to.
+         * Moreover, if 'eval()' is used in a scope, it might introduce new
+         * bindings in this or its parent scopes.
+         * All those scopes are considered 'dynamic'.
+         * @member {boolean} Scope#dynamic
+         */
+        this.dynamic = this.type === "global" || this.type === "with";
 
-/** @template T @typedef {{ add: (T) => void }} WriteOnlySet */
+        /**
+         * A reference to the scope-defining syntax node.
+         * @member {espree.Node} Scope#block
+         */
+        this.block = block;
 
-/**
- * Resolve context
- * @typedef {Object} ResolveContext
- * @property {WriteOnlySet<string>=} contextDependencies
- * @property {WriteOnlySet<string>=} fileDependencies files that was found on file system
- * @property {WriteOnlySet<string>=} missingDependencies dependencies that was not found on file system
- * @property {Set<StackEntry>=} stack set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`,
- * @property {(function(string): void)=} log log function
- */
+        /**
+         * The {@link Reference|references} that are not resolved with this scope.
+         * @member {Reference[]} Scope#through
+         */
+        this.through = [];
 
-/** @typedef {AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest | null>} ResolveStepHook */
+        /**
+         * The scoped {@link Variable}s of this scope. In the case of a
+         * 'function' scope this includes the automatic argument <em>arguments</em> as
+         * its first element, as well as all further formal arguments.
+         * @member {Variable[]} Scope#variables
+         */
+        this.variables = [];
 
-/**
- * @param {string} str input string
- * @returns {string} in camel case
- */
-function toCamelCase(str) {
-	return str.replace(/-([a-z])/g, str => str.substr(1).toUpperCase());
-}
+        /**
+         * Any variable {@link Reference|reference} found in this scope. This
+         * includes occurrences of local variables as well as variables from
+         * parent scopes (including the global scope). For local variables
+         * this also includes defining occurrences (like in a 'var' statement).
+         * In a 'function' scope this does not include the occurrences of the
+         * formal parameter in the parameter list.
+         * @member {Reference[]} Scope#references
+         */
+        this.references = [];
 
-class Resolver {
-	/**
-	 * @param {ResolveStepHook} hook hook
-	 * @param {ResolveRequest} request request
-	 * @returns {StackEntry} stack entry
-	 */
-	static createStackEntry(hook, request) {
-		return (
-			hook.name +
-			": (" +
-			request.path +
-			") " +
-			(request.request || "") +
-			(request.query || "") +
-			(request.fragment || "") +
-			(request.directory ? " directory" : "") +
-			(request.module ? " module" : "")
-		);
-	}
+        /**
+         * For 'global' and 'function' scopes, this is a self-reference. For
+         * other scope types this is the <em>variableScope</em> value of the
+         * parent scope.
+         * @member {Scope} Scope#variableScope
+         */
+        this.variableScope =
+            (this.type === "global" || this.type === "function" || this.type === "module") ? this : upperScope.variableScope;
 
-	/**
-	 * @param {FileSystem} fileSystem a filesystem
-	 * @param {ResolveOptions} options options
-	 */
-	constructor(fileSystem, options) {
-		this.fileSystem = fileSystem;
-		this.options = options;
-		this.hooks = {
-			/** @type {SyncHook<[ResolveStepHook, ResolveRequest], void>} */
-			resolveStep: new SyncHook(["hook", "request"], "resolveStep"),
-			/** @type {SyncHook<[ResolveRequest, Error]>} */
-			noResolve: new SyncHook(["request", "error"], "noResolve"),
-			/** @type {ResolveStepHook} */
-			resolve: new AsyncSeriesBailHook(
-				["request", "resolveContext"],
-				"resolve"
-			),
-			/** @type {AsyncSeriesHook<[ResolveRequest, ResolveContext]>} */
-			result: new AsyncSeriesHook(["result", "resolveContext"], "result")
-		};
-	}
+        /**
+         * Whether this scope is created by a FunctionExpression.
+         * @member {boolean} Scope#functionExpressionScope
+         */
+        this.functionExpressionScope = false;
 
-	/**
-	 * @param {string | ResolveStepHook} name hook name or hook itself
-	 * @returns {ResolveStepHook} the hook
-	 */
-	ensureHook(name) {
-		if (typeof name !== "string") {
-			return name;
-		}
-		name = toCamelCase(name);
-		if (/^before/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.ensureHook(
-				name[6].toLowerCase() + name.substr(7)
-			).withOptions({
-				stage: -10
-			}));
-		}
-		if (/^after/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.ensureHook(
-				name[5].toLowerCase() + name.substr(6)
-			).withOptions({
-				stage: 10
-			}));
-		}
-		const hook = this.hooks[name];
-		if (!hook) {
-			return (this.hooks[name] = new AsyncSeriesBailHook(
-				["request", "resolveContext"],
-				name
-			));
-		}
-		return hook;
-	}
+        /**
+         * Whether this is a scope that contains an 'eval()' invocation.
+         * @member {boolean} Scope#directCallToEvalScope
+         */
+        this.directCallToEvalScope = false;
 
-	/**
-	 * @param {string | ResolveStepHook} name hook name or hook itself
-	 * @returns {ResolveStepHook} the hook
-	 */
-	getHook(name) {
-		if (typeof name !== "string") {
-			return name;
-		}
-		name = toCamelCase(name);
-		if (/^before/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.getHook(
-				name[6].toLowerCase() + name.substr(7)
-			).withOptions({
-				stage: -10
-			}));
-		}
-		if (/^after/.test(name)) {
-			return /** @type {ResolveStepHook} */ (this.getHook(
-				name[5].toLowerCase() + name.substr(6)
-			).withOptions({
-				stage: 10
-			}));
-		}
-		const hook = this.hooks[name];
-		if (!hook) {
-			throw new Error(`Hook ${name} doesn't exist`);
-		}
-		return hook;
-	}
+        /**
+         * @member {boolean} Scope#thisFound
+         */
+        this.thisFound = false;
 
-	/**
-	 * @param {object} context context information object
-	 * @param {string} path context path
-	 * @param {string} request request string
-	 * @returns {string | false} result
-	 */
-	resolveSync(context, path, request) {
-		/** @type {Error | null | undefined} */
-		let err = undefined;
-		/** @type {string | false | undefined} */
-		let result = undefined;
-		let sync = false;
-		this.resolve(context, path, request, {}, (e, r) => {
-			err = e;
-			result = r;
-			sync = true;
-		});
-		if (!sync) {
-			throw new Error(
-				"Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!"
-			);
-		}
-		if (err) throw err;
-		if (result === undefined) throw new Error("No result");
-		return result;
-	}
+        this.__left = [];
 
-	/**
-	 * @param {object} context context information object
-	 * @param {string} path context path
-	 * @param {string} request request string
-	 * @param {ResolveContext} resolveContext resolve context
-	 * @param {function(Error | null, (string|false)=, ResolveRequest=): void} callback callback function
-	 * @returns {void}
-	 */
-	resolve(context, path, request, resolveContext, callback) {
-		if (!context || typeof context !== "object")
-			return callback(new Error("context argument is not an object"));
-		if (typeof path !== "string")
-			return callback(new Error("path argument is not a string"));
-		if (typeof request !== "string")
-			return callback(new Error("path argument is not a string"));
-		if (!resolveContext)
-			return callback(new Error("resolveContext argument is not set"));
+        /**
+         * Reference to the parent {@link Scope|scope}.
+         * @member {Scope} Scope#upper
+         */
+        this.upper = upperScope;
 
-		const obj = {
-			context: context,
-			path: path,
-			request: request
-		};
+        /**
+         * Whether 'use strict' is in effect in this scope.
+         * @member {boolean} Scope#isStrict
+         */
+        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());
 
-		const message = `resolve '${request}' in '${path}'`;
+        /**
+         * List of nested {@link Scope}s.
+         * @member {Scope[]} Scope#childScopes
+         */
+        this.childScopes = [];
+        if (this.upper) {
+            this.upper.childScopes.push(this);
+        }
 
-		const finishResolved = result => {
-			return callback(
-				null,
-				result.path === false
-					? false
-					: `${result.path.replace(/#/g, "\0#")}${
-							result.query ? result.query.replace(/#/g, "\0#") : ""
-					  }${result.fragment || ""}`,
-				result
-			);
-		};
+        this.__declaredVariables = scopeManager.__declaredVariables;
 
-		const finishWithoutResolve = log => {
-			/**
-			 * @type {Error & {details?: string}}
-			 */
-			const error = new Error("Can't " + message);
-			error.details = log.join("\n");
-			this.hooks.noResolve.call(obj, error);
-			return callback(error);
-		};
+        registerScope(scopeManager, this);
+    }
 
-		if (resolveContext.log) {
-			// We need log anyway to capture it in case of an error
-			const parentLog = resolveContext.log;
-			const log = [];
-			return this.doResolve(
-				this.hooks.resolve,
-				obj,
-				message,
-				{
-					log: msg => {
-						parentLog(msg);
-						log.push(msg);
-					},
-					fileDependencies: resolveContext.fileDependencies,
-					contextDependencies: resolveContext.contextDependencies,
-					missingDependencies: resolveContext.missingDependencies,
-					stack: resolveContext.stack
-				},
-				(err, result) => {
-					if (err) return callback(err);
+    __shouldStaticallyClose(scopeManager) {
+        return (!this.dynamic || scopeManager.__isOptimistic());
+    }
 
-					if (result) return finishResolved(result);
+    __shouldStaticallyCloseForGlobal(ref) {
 
-					return finishWithoutResolve(log);
-				}
-			);
-		} else {
-			// Try to resolve assuming there is no error
-			// We don't log stuff in this case
-			return this.doResolve(
-				this.hooks.resolve,
-				obj,
-				message,
-				{
-					log: undefined,
-					fileDependencies: resolveContext.fileDependencies,
-					contextDependencies: resolveContext.contextDependencies,
-					missingDependencies: resolveContext.missingDependencies,
-					stack: resolveContext.stack
-				},
-				(err, result) => {
-					if (err) return callback(err);
+        // On global scope, let/const/class declarations should be resolved statically.
+        const name = ref.identifier.name;
 
-					if (result) return finishResolved(result);
+        if (!this.set.has(name)) {
+            return false;
+        }
 
-					// log is missing for the error details
-					// so we redo the resolving for the log info
-					// this is more expensive to the success case
-					// is assumed by default
+        const variable = this.set.get(name);
+        const defs = variable.defs;
 
-					const log = [];
+        return defs.length > 0 && defs.every(shouldBeStatically);
+    }
 
-					return this.doResolve(
-						this.hooks.resolve,
-						obj,
-						message,
-						{
-							log: msg => log.push(msg),
-							stack: resolveContext.stack
-						},
-						(err, result) => {
-							if (err) return callback(err);
+    __staticCloseRef(ref) {
+        if (!this.__resolve(ref)) {
+            this.__delegateToUpperScope(ref);
+        }
+    }
 
-							return finishWithoutResolve(log);
-						}
-					);
-				}
-			);
-		}
-	}
+    __dynamicCloseRef(ref) {
 
-	doResolve(hook, request, message, resolveContext, callback) {
-		const stackEntry = Resolver.createStackEntry(hook, request);
+        // notify all names are through to global
+        let current = this;
 
-		let newStack;
-		if (resolveContext.stack) {
-			newStack = new Set(resolveContext.stack);
-			if (resolveContext.stack.has(stackEntry)) {
-				/**
-				 * Prevent recursion
-				 * @type {Error & {recursion?: boolean}}
-				 */
-				const recursionError = new Error(
-					"Recursion in resolving\nStack:\n  " +
-						Array.from(newStack).join("\n  ")
-				);
-				recursionError.recursion = true;
-				if (resolveContext.log)
-					resolveContext.log("abort resolving because of recursion");
-				return callback(recursionError);
-			}
-			newStack.add(stackEntry);
-		} else {
-			newStack = new Set([stackEntry]);
-		}
-		this.hooks.resolveStep.call(hook, request);
+        do {
+            current.through.push(ref);
+            current = current.upper;
+        } while (current);
+    }
 
-		if (hook.isUsed()) {
-			const innerContext = createInnerContext(
-				{
-					log: resolveContext.log,
-					fileDependencies: resolveContext.fileDependencies,
-					contextDependencies: resolveContext.contextDependencies,
-					missingDependencies: resolveContext.missingDependencies,
-					stack: newStack
-				},
-				message
-			);
-			return hook.callAsync(request, innerContext, (err, result) => {
-				if (err) return callback(err);
-				if (result) return callback(null, result);
-				callback();
-			});
-		} else {
-			callback();
-		}
-	}
+    __globalCloseRef(ref) {
 
-	/**
-	 * @param {string} identifier identifier
-	 * @returns {ParsedIdentifier} parsed identifier
-	 */
-	parse(identifier) {
-		const part = {
-			request: "",
-			query: "",
-			fragment: "",
-			module: false,
-			directory: false,
-			file: false,
-			internal: false
-		};
+        // let/const/class declarations should be resolved statically.
+        // others should be resolved dynamically.
+        if (this.__shouldStaticallyCloseForGlobal(ref)) {
+            this.__staticCloseRef(ref);
+        } else {
+            this.__dynamicCloseRef(ref);
+        }
+    }
 
-		const parsedIdentifier = parseIdentifier(identifier);
+    __close(scopeManager) {
+        let closeRef;
 
-		if (!parsedIdentifier) return part;
+        if (this.__shouldStaticallyClose(scopeManager)) {
+            closeRef = this.__staticCloseRef;
+        } else if (this.type !== "global") {
+            closeRef = this.__dynamicCloseRef;
+        } else {
+            closeRef = this.__globalCloseRef;
+        }
 
-		[part.request, part.query, part.fragment] = parsedIdentifier;
+        // Try Resolving all references in this scope.
+        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
+            const ref = this.__left[i];
 
-		if (part.request.length > 0) {
-			part.internal = this.isPrivate(identifier);
-			part.module = this.isModule(part.request);
-			part.directory = this.isDirectory(part.request);
-			if (part.directory) {
-				part.request = part.request.substr(0, part.request.length - 1);
-			}
-		}
+            closeRef.call(this, ref);
+        }
+        this.__left = null;
 
-		return part;
-	}
+        return this.upper;
+    }
 
-	isModule(path) {
-		return getType(path) === PathType.Normal;
-	}
+    // To override by function scopes.
+    // References in default parameters isn't resolved to variables which are in their function body.
+    __isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars
+        return true;
+    }
 
-	isPrivate(path) {
-		return getType(path) === PathType.Internal;
-	}
+    __resolve(ref) {
+        const name = ref.identifier.name;
 
-	/**
-	 * @param {string} path a path
-	 * @returns {boolean} true, if the path is a directory path
-	 */
-	isDirectory(path) {
-		return path.endsWith("/");
-	}
+        if (!this.set.has(name)) {
+            return false;
+        }
+        const variable = this.set.get(name);
 
-	join(path, request) {
-		return join(path, request);
-	}
+        if (!this.__isValidResolution(ref, variable)) {
+            return false;
+        }
+        variable.references.push(ref);
+        variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
+        if (ref.tainted) {
+            variable.tainted = true;
+            this.taints.set(variable.name, true);
+        }
+        ref.resolved = variable;
 
-	normalize(path) {
-		return normalize(path);
-	}
-}
+        return true;
+    }
 
-module.exports = Resolver;
+    __delegateToUpperScope(ref) {
+        if (this.upper) {
+            this.upper.__left.push(ref);
+        }
+        this.through.push(ref);
+    }
 
+    __addDeclaredVariablesOfNode(variable, node) {
+        if (node === null || node === undefined) {
+            return;
+        }
 
-/***/ }),
+        let variables = this.__declaredVariables.get(node);
 
-/***/ 53990:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+        if (variables === null || variables === undefined) {
+            variables = [];
+            this.__declaredVariables.set(node, variables);
+        }
+        if (variables.indexOf(variable) === -1) {
+            variables.push(variable);
+        }
+    }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    __defineGeneric(name, set, variables, node, def) {
+        let variable;
 
+        variable = set.get(name);
+        if (!variable) {
+            variable = new Variable(name, this);
+            set.set(name, variable);
+            variables.push(variable);
+        }
 
+        if (def) {
+            variable.defs.push(def);
+            this.__addDeclaredVariablesOfNode(variable, def.node);
+            this.__addDeclaredVariablesOfNode(variable, def.parent);
+        }
+        if (node) {
+            variable.identifiers.push(node);
+        }
+    }
 
-const versions = (__webpack_require__(77282).versions);
-const Resolver = __webpack_require__(37432);
-const { getType, PathType } = __webpack_require__(3011);
-
-const SyncAsyncFileSystemDecorator = __webpack_require__(57746);
-
-const AliasFieldPlugin = __webpack_require__(42752);
-const AliasPlugin = __webpack_require__(51547);
-const AppendPlugin = __webpack_require__(66477);
-const ConditionalPlugin = __webpack_require__(44193);
-const DescriptionFilePlugin = __webpack_require__(66826);
-const DirectoryExistsPlugin = __webpack_require__(73688);
-const ExportsFieldPlugin = __webpack_require__(80163);
-const FileExistsPlugin = __webpack_require__(98699);
-const ImportsFieldPlugin = __webpack_require__(86058);
-const JoinRequestPartPlugin = __webpack_require__(20879);
-const JoinRequestPlugin = __webpack_require__(71474);
-const MainFieldPlugin = __webpack_require__(73507);
-const ModulesInHierachicDirectoriesPlugin = __webpack_require__(3688);
-const ModulesInRootPlugin = __webpack_require__(48952);
-const NextPlugin = __webpack_require__(79135);
-const ParsePlugin = __webpack_require__(15234);
-const PnpPlugin = __webpack_require__(71488);
-const RestrictionsPlugin = __webpack_require__(39222);
-const ResultPlugin = __webpack_require__(10615);
-const RootsPlugin = __webpack_require__(34403);
-const SelfReferencePlugin = __webpack_require__(32317);
-const SymlinkPlugin = __webpack_require__(21300);
-const TryNextPlugin = __webpack_require__(16442);
-const UnsafeCachePlugin = __webpack_require__(3501);
-const UseFilePlugin = __webpack_require__(50318);
+    __define(node, def) {
+        if (node && node.type === Syntax.Identifier) {
+            this.__defineGeneric(
+                node.name,
+                this.set,
+                this.variables,
+                node,
+                def
+            );
+        }
+    }
 
-/** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */
-/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
 
-/** @typedef {string|string[]|false} AliasOptionNewRequest */
-/** @typedef {{[k: string]: AliasOptionNewRequest}} AliasOptions */
-/** @typedef {{apply: function(Resolver): void} | function(this: Resolver, Resolver): void} Plugin */
+        // because Array element may be null
+        if (!node || node.type !== Syntax.Identifier) {
+            return;
+        }
 
-/**
- * @typedef {Object} UserResolveOptions
- * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value
- * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option
- * @property {(string | string[])[]=} aliasFields A list of alias fields in description files
- * @property {(function(ResolveRequest): boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
- * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key.
- * @property {string[]=} descriptionFiles A list of description files to read from
- * @property {string[]=} conditionNames A list of exports field condition names.
- * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used
- * @property {(string | string[])[]=} exportsFields A list of exports fields in description files
- * @property {(string | string[])[]=} importsFields A list of imports fields in description files
- * @property {string[]=} extensions A list of extensions which should be tried for files
- * @property {FileSystem} fileSystem The file system which should be used
- * @property {(object | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests
- * @property {boolean=} symlinks Resolve symlinks to their symlinked location
- * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached
- * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name
- * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files
- * @property {string[]=} mainFiles  A list of main files in directories
- * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied
- * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto"
- * @property {string[]=} roots A list of root paths
- * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it
- * @property {boolean=} resolveToContext Resolve to a context instead of a file
- * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions
- * @property {boolean=} useSyncFileSystemCalls Use only the sync constiants of the file system calls
- * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules
- * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
- */
+        // Specially handle like `this`.
+        if (node.name === "super") {
+            return;
+        }
 
-/**
- * @typedef {Object} ResolveOptions
- * @property {AliasOptionEntry[]} alias
- * @property {AliasOptionEntry[]} fallback
- * @property {Set<string | string[]>} aliasFields
- * @property {(function(ResolveRequest): boolean)} cachePredicate
- * @property {boolean} cacheWithContext
- * @property {Set<string>} conditionNames A list of exports field condition names.
- * @property {string[]} descriptionFiles
- * @property {boolean} enforceExtension
- * @property {Set<string | string[]>} exportsFields
- * @property {Set<string | string[]>} importsFields
- * @property {Set<string>} extensions
- * @property {FileSystem} fileSystem
- * @property {object | false} unsafeCache
- * @property {boolean} symlinks
- * @property {Resolver=} resolver
- * @property {Array<string | string[]>} modules
- * @property {{name: string[], forceRelative: boolean}[]} mainFields
- * @property {Set<string>} mainFiles
- * @property {Plugin[]} plugins
- * @property {PnpApi | null} pnpApi
- * @property {Set<string>} roots
- * @property {boolean} fullySpecified
- * @property {boolean} resolveToContext
- * @property {Set<string|RegExp>} restrictions
- * @property {boolean} preferRelative
- * @property {boolean} preferAbsolute
- */
+        const ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
 
-/**
- * @param {PnpApi | null=} option option
- * @returns {PnpApi | null} processed option
- */
-function processPnpApiOption(option) {
-	if (
-		option === undefined &&
-		/** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp
-	) {
-		// @ts-ignore
-		return __webpack_require__(35125); // eslint-disable-line node/no-missing-require
-	}
+        this.references.push(ref);
+        this.__left.push(ref);
+    }
 
-	return option || null;
-}
+    __detectEval() {
+        let current = this;
 
-/**
- * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias
- * @returns {AliasOptionEntry[]} normalized aliases
- */
-function normalizeAlias(alias) {
-	return typeof alias === "object" && !Array.isArray(alias) && alias !== null
-		? Object.keys(alias).map(key => {
-				/** @type {AliasOptionEntry} */
-				const obj = { name: key, onlyModule: false, alias: alias[key] };
+        this.directCallToEvalScope = true;
+        do {
+            current.dynamic = true;
+            current = current.upper;
+        } while (current);
+    }
 
-				if (/\$$/.test(key)) {
-					obj.onlyModule = true;
-					obj.name = key.substr(0, key.length - 1);
-				}
+    __detectThis() {
+        this.thisFound = true;
+    }
 
-				return obj;
-		  })
-		: /** @type {Array<AliasOptionEntry>} */ (alias) || [];
-}
+    __isClosed() {
+        return this.__left === null;
+    }
 
-/**
- * @param {UserResolveOptions} options input options
- * @returns {ResolveOptions} output options
- */
-function createOptions(options) {
-	const mainFieldsSet = new Set(options.mainFields || ["main"]);
-	const mainFields = [];
+    /**
+     * returns resolved {Reference}
+     * @method Scope#resolve
+     * @param {Espree.Identifier} ident - identifier to be resolved.
+     * @returns {Reference} reference
+     */
+    resolve(ident) {
+        let ref, i, iz;
 
-	for (const item of mainFieldsSet) {
-		if (typeof item === "string") {
-			mainFields.push({
-				name: [item],
-				forceRelative: true
-			});
-		} else if (Array.isArray(item)) {
-			mainFields.push({
-				name: item,
-				forceRelative: true
-			});
-		} else {
-			mainFields.push({
-				name: Array.isArray(item.name) ? item.name : [item.name],
-				forceRelative: item.forceRelative
-			});
-		}
-	}
+        assert(this.__isClosed(), "Scope should be closed.");
+        assert(ident.type === Syntax.Identifier, "Target should be identifier.");
+        for (i = 0, iz = this.references.length; i < iz; ++i) {
+            ref = this.references[i];
+            if (ref.identifier === ident) {
+                return ref;
+            }
+        }
+        return null;
+    }
 
-	return {
-		alias: normalizeAlias(options.alias),
-		fallback: normalizeAlias(options.fallback),
-		aliasFields: new Set(options.aliasFields),
-		cachePredicate:
-			options.cachePredicate ||
-			function () {
-				return true;
-			},
-		cacheWithContext:
-			typeof options.cacheWithContext !== "undefined"
-				? options.cacheWithContext
-				: true,
-		exportsFields: new Set(options.exportsFields || ["exports"]),
-		importsFields: new Set(options.importsFields || ["imports"]),
-		conditionNames: new Set(options.conditionNames),
-		descriptionFiles: Array.from(
-			new Set(options.descriptionFiles || ["package.json"])
-		),
-		enforceExtension:
-			options.enforceExtension === undefined
-				? options.extensions && options.extensions.includes("")
-					? true
-					: false
-				: options.enforceExtension,
-		extensions: new Set(options.extensions || [".js", ".json", ".node"]),
-		fileSystem: options.useSyncFileSystemCalls
-			? new SyncAsyncFileSystemDecorator(
-					/** @type {SyncFileSystem} */ (
-						/** @type {unknown} */ (options.fileSystem)
-					)
-			  )
-			: options.fileSystem,
-		unsafeCache:
-			options.unsafeCache && typeof options.unsafeCache !== "object"
-				? {}
-				: options.unsafeCache || false,
-		symlinks: typeof options.symlinks !== "undefined" ? options.symlinks : true,
-		resolver: options.resolver,
-		modules: mergeFilteredToArray(
-			Array.isArray(options.modules)
-				? options.modules
-				: options.modules
-				? [options.modules]
-				: ["node_modules"],
-			item => {
-				const type = getType(item);
-				return type === PathType.Normal || type === PathType.Relative;
-			}
-		),
-		mainFields,
-		mainFiles: new Set(options.mainFiles || ["index"]),
-		plugins: options.plugins || [],
-		pnpApi: processPnpApiOption(options.pnpApi),
-		roots: new Set(options.roots || undefined),
-		fullySpecified: options.fullySpecified || false,
-		resolveToContext: options.resolveToContext || false,
-		preferRelative: options.preferRelative || false,
-		preferAbsolute: options.preferAbsolute || false,
-		restrictions: new Set(options.restrictions)
-	};
-}
+    /**
+     * returns this scope is static
+     * @method Scope#isStatic
+     * @returns {boolean} static
+     */
+    isStatic() {
+        return !this.dynamic;
+    }
 
-/**
- * @param {UserResolveOptions} options resolve options
- * @returns {Resolver} created resolver
- */
-exports.createResolver = function (options) {
-	const normalizedOptions = createOptions(options);
+    /**
+     * returns this scope has materialized arguments
+     * @method Scope#isArgumentsMaterialized
+     * @returns {boolean} arguemnts materialized
+     */
+    isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this
+        return true;
+    }
 
-	const {
-		alias,
-		fallback,
-		aliasFields,
-		cachePredicate,
-		cacheWithContext,
-		conditionNames,
-		descriptionFiles,
-		enforceExtension,
-		exportsFields,
-		importsFields,
-		extensions,
-		fileSystem,
-		fullySpecified,
-		mainFields,
-		mainFiles,
-		modules,
-		plugins: userPlugins,
-		pnpApi,
-		resolveToContext,
-		preferRelative,
-		preferAbsolute,
-		symlinks,
-		unsafeCache,
-		resolver: customResolver,
-		restrictions,
-		roots
-	} = normalizedOptions;
+    /**
+     * returns this scope has materialized `this` reference
+     * @method Scope#isThisMaterialized
+     * @returns {boolean} this materialized
+     */
+    isThisMaterialized() { // eslint-disable-line class-methods-use-this
+        return true;
+    }
 
-	const plugins = userPlugins.slice();
+    isUsedName(name) {
+        if (this.set.has(name)) {
+            return true;
+        }
+        for (let i = 0, iz = this.through.length; i < iz; ++i) {
+            if (this.through[i].identifier.name === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
 
-	const resolver = customResolver
-		? customResolver
-		: new Resolver(fileSystem, normalizedOptions);
+class GlobalScope extends Scope {
+    constructor(scopeManager, block) {
+        super(scopeManager, "global", null, block, false);
+        this.implicit = {
+            set: new Map(),
+            variables: [],
 
-	//// pipeline ////
+            /**
+            * List of {@link Reference}s that are left to be resolved (i.e. which
+            * need to be linked to the variable they refer to).
+            * @member {Reference[]} Scope#implicit#left
+            */
+            left: []
+        };
+    }
 
-	resolver.ensureHook("resolve");
-	resolver.ensureHook("internalResolve");
-	resolver.ensureHook("newInteralResolve");
-	resolver.ensureHook("parsedResolve");
-	resolver.ensureHook("describedResolve");
-	resolver.ensureHook("internal");
-	resolver.ensureHook("rawModule");
-	resolver.ensureHook("module");
-	resolver.ensureHook("resolveAsModule");
-	resolver.ensureHook("undescribedResolveInPackage");
-	resolver.ensureHook("resolveInPackage");
-	resolver.ensureHook("resolveInExistingDirectory");
-	resolver.ensureHook("relative");
-	resolver.ensureHook("describedRelative");
-	resolver.ensureHook("directory");
-	resolver.ensureHook("undescribedExistingDirectory");
-	resolver.ensureHook("existingDirectory");
-	resolver.ensureHook("undescribedRawFile");
-	resolver.ensureHook("rawFile");
-	resolver.ensureHook("file");
-	resolver.ensureHook("finalFile");
-	resolver.ensureHook("existingFile");
-	resolver.ensureHook("resolved");
+    __close(scopeManager) {
+        const implicit = [];
 
-	// resolve
-	for (const { source, resolveOptions } of [
-		{ source: "resolve", resolveOptions: { fullySpecified } },
-		{ source: "internal-resolve", resolveOptions: { fullySpecified: false } }
-	]) {
-		if (unsafeCache) {
-			plugins.push(
-				new UnsafeCachePlugin(
-					source,
-					cachePredicate,
-					unsafeCache,
-					cacheWithContext,
-					`new-${source}`
-				)
-			);
-			plugins.push(
-				new ParsePlugin(`new-${source}`, resolveOptions, "parsed-resolve")
-			);
-		} else {
-			plugins.push(new ParsePlugin(source, resolveOptions, "parsed-resolve"));
-		}
-	}
+        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
+            const ref = this.__left[i];
 
-	// parsed-resolve
-	plugins.push(
-		new DescriptionFilePlugin(
-			"parsed-resolve",
-			descriptionFiles,
-			false,
-			"described-resolve"
-		)
-	);
-	plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve"));
+            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
+                implicit.push(ref.__maybeImplicitGlobal);
+            }
+        }
 
-	// described-resolve
-	plugins.push(new NextPlugin("described-resolve", "normal-resolve"));
-	if (fallback.length > 0) {
-		plugins.push(
-			new AliasPlugin("described-resolve", fallback, "internal-resolve")
-		);
-	}
+        // create an implicit global variable from assignment expression
+        for (let i = 0, iz = implicit.length; i < iz; ++i) {
+            const info = implicit[i];
 
-	// normal-resolve
-	if (alias.length > 0)
-		plugins.push(new AliasPlugin("normal-resolve", alias, "internal-resolve"));
-	aliasFields.forEach(item => {
-		plugins.push(
-			new AliasFieldPlugin("normal-resolve", item, "internal-resolve")
-		);
-	});
-	if (preferRelative) {
-		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
-	}
-	plugins.push(
-		new ConditionalPlugin(
-			"after-normal-resolve",
-			{ module: true },
-			"resolve as module",
-			false,
-			"raw-module"
-		)
-	);
-	plugins.push(
-		new ConditionalPlugin(
-			"after-normal-resolve",
-			{ internal: true },
-			"resolve as internal import",
-			false,
-			"internal"
-		)
-	);
-	if (preferAbsolute) {
-		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
-	}
-	if (roots.size > 0) {
-		plugins.push(new RootsPlugin("after-normal-resolve", roots, "relative"));
-	}
-	if (!preferRelative && !preferAbsolute) {
-		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
-	}
+            this.__defineImplicit(info.pattern,
+                new Definition(
+                    Variable.ImplicitGlobalVariable,
+                    info.pattern,
+                    info.node,
+                    null,
+                    null,
+                    null
+                ));
 
-	// internal
-	importsFields.forEach(importsField => {
-		plugins.push(
-			new ImportsFieldPlugin(
-				"internal",
-				conditionNames,
-				importsField,
-				"relative",
-				"internal-resolve"
-			)
-		);
-	});
+        }
 
-	// raw-module
-	exportsFields.forEach(exportsField => {
-		plugins.push(
-			new SelfReferencePlugin("raw-module", exportsField, "resolve-as-module")
-		);
-	});
-	modules.forEach(item => {
-		if (Array.isArray(item)) {
-			if (item.includes("node_modules") && pnpApi) {
-				plugins.push(
-					new ModulesInHierachicDirectoriesPlugin(
-						"raw-module",
-						item.filter(i => i !== "node_modules"),
-						"module"
-					)
-				);
-				plugins.push(
-					new PnpPlugin("raw-module", pnpApi, "undescribed-resolve-in-package")
-				);
-			} else {
-				plugins.push(
-					new ModulesInHierachicDirectoriesPlugin("raw-module", item, "module")
-				);
-			}
-		} else {
-			plugins.push(new ModulesInRootPlugin("raw-module", item, "module"));
-		}
-	});
+        this.implicit.left = this.__left;
 
-	// module
-	plugins.push(new JoinRequestPartPlugin("module", "resolve-as-module"));
+        return super.__close(scopeManager);
+    }
 
-	// resolve-as-module
-	if (!resolveToContext) {
-		plugins.push(
-			new ConditionalPlugin(
-				"resolve-as-module",
-				{ directory: false, request: "." },
-				"single file module",
-				true,
-				"undescribed-raw-file"
-			)
-		);
-	}
-	plugins.push(
-		new DirectoryExistsPlugin(
-			"resolve-as-module",
-			"undescribed-resolve-in-package"
-		)
-	);
+    __defineImplicit(node, def) {
+        if (node && node.type === Syntax.Identifier) {
+            this.__defineGeneric(
+                node.name,
+                this.implicit.set,
+                this.implicit.variables,
+                node,
+                def
+            );
+        }
+    }
+}
 
-	// undescribed-resolve-in-package
-	plugins.push(
-		new DescriptionFilePlugin(
-			"undescribed-resolve-in-package",
-			descriptionFiles,
-			false,
-			"resolve-in-package"
-		)
-	);
-	plugins.push(
-		new NextPlugin("after-undescribed-resolve-in-package", "resolve-in-package")
-	);
+class ModuleScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "module", upperScope, block, false);
+    }
+}
 
-	// resolve-in-package
-	exportsFields.forEach(exportsField => {
-		plugins.push(
-			new ExportsFieldPlugin(
-				"resolve-in-package",
-				conditionNames,
-				exportsField,
-				"relative"
-			)
-		);
-	});
-	plugins.push(
-		new NextPlugin("resolve-in-package", "resolve-in-existing-directory")
-	);
+class FunctionExpressionNameScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "function-expression-name", upperScope, block, false);
+        this.__define(block.id,
+            new Definition(
+                Variable.FunctionName,
+                block.id,
+                block,
+                null,
+                null,
+                null
+            ));
+        this.functionExpressionScope = true;
+    }
+}
 
-	// resolve-in-existing-directory
-	plugins.push(
-		new JoinRequestPlugin("resolve-in-existing-directory", "relative")
-	);
+class CatchScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "catch", upperScope, block, false);
+    }
+}
 
-	// relative
-	plugins.push(
-		new DescriptionFilePlugin(
-			"relative",
-			descriptionFiles,
-			true,
-			"described-relative"
-		)
-	);
-	plugins.push(new NextPlugin("after-relative", "described-relative"));
+class WithScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "with", upperScope, block, false);
+    }
 
-	// described-relative
-	if (resolveToContext) {
-		plugins.push(new NextPlugin("described-relative", "directory"));
-	} else {
-		plugins.push(
-			new ConditionalPlugin(
-				"described-relative",
-				{ directory: false },
-				null,
-				true,
-				"raw-file"
-			)
-		);
-		plugins.push(
-			new ConditionalPlugin(
-				"described-relative",
-				{ fullySpecified: false },
-				"as directory",
-				true,
-				"directory"
-			)
-		);
-	}
+    __close(scopeManager) {
+        if (this.__shouldStaticallyClose(scopeManager)) {
+            return super.__close(scopeManager);
+        }
 
-	// directory
-	plugins.push(
-		new DirectoryExistsPlugin("directory", "undescribed-existing-directory")
-	);
+        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
+            const ref = this.__left[i];
 
-	if (resolveToContext) {
-		// undescribed-existing-directory
-		plugins.push(new NextPlugin("undescribed-existing-directory", "resolved"));
-	} else {
-		// undescribed-existing-directory
-		plugins.push(
-			new DescriptionFilePlugin(
-				"undescribed-existing-directory",
-				descriptionFiles,
-				false,
-				"existing-directory"
-			)
-		);
-		mainFiles.forEach(item => {
-			plugins.push(
-				new UseFilePlugin(
-					"undescribed-existing-directory",
-					item,
-					"undescribed-raw-file"
-				)
-			);
-		});
+            ref.tainted = true;
+            this.__delegateToUpperScope(ref);
+        }
+        this.__left = null;
 
-		// described-existing-directory
-		mainFields.forEach(item => {
-			plugins.push(
-				new MainFieldPlugin(
-					"existing-directory",
-					item,
-					"resolve-in-existing-directory"
-				)
-			);
-		});
-		mainFiles.forEach(item => {
-			plugins.push(
-				new UseFilePlugin("existing-directory", item, "undescribed-raw-file")
-			);
-		});
+        return this.upper;
+    }
+}
 
-		// undescribed-raw-file
-		plugins.push(
-			new DescriptionFilePlugin(
-				"undescribed-raw-file",
-				descriptionFiles,
-				true,
-				"raw-file"
-			)
-		);
-		plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file"));
+class BlockScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "block", upperScope, block, false);
+    }
+}
 
-		// raw-file
-		plugins.push(
-			new ConditionalPlugin(
-				"raw-file",
-				{ fullySpecified: true },
-				null,
-				false,
-				"file"
-			)
-		);
-		if (!enforceExtension) {
-			plugins.push(new TryNextPlugin("raw-file", "no extension", "file"));
-		}
-		extensions.forEach(item => {
-			plugins.push(new AppendPlugin("raw-file", item, "file"));
-		});
+class SwitchScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "switch", upperScope, block, false);
+    }
+}
 
-		// file
-		if (alias.length > 0)
-			plugins.push(new AliasPlugin("file", alias, "internal-resolve"));
-		aliasFields.forEach(item => {
-			plugins.push(new AliasFieldPlugin("file", item, "internal-resolve"));
-		});
-		plugins.push(new NextPlugin("file", "final-file"));
+class FunctionScope extends Scope {
+    constructor(scopeManager, upperScope, block, isMethodDefinition) {
+        super(scopeManager, "function", upperScope, block, isMethodDefinition);
 
-		// final-file
-		plugins.push(new FileExistsPlugin("final-file", "existing-file"));
-
-		// existing-file
-		if (symlinks)
-			plugins.push(new SymlinkPlugin("existing-file", "existing-file"));
-		plugins.push(new NextPlugin("existing-file", "resolved"));
-	}
-
-	// resolved
-	if (restrictions.size > 0) {
-		plugins.push(new RestrictionsPlugin(resolver.hooks.resolved, restrictions));
-	}
-	plugins.push(new ResultPlugin(resolver.hooks.resolved));
-
-	//// RESOLVER ////
+        // section 9.2.13, FunctionDeclarationInstantiation.
+        // NOTE Arrow functions never have an arguments objects.
+        if (this.block.type !== Syntax.ArrowFunctionExpression) {
+            this.__defineArguments();
+        }
+    }
 
-	for (const plugin of plugins) {
-		if (typeof plugin === "function") {
-			plugin.call(resolver, resolver);
-		} else {
-			plugin.apply(resolver);
-		}
-	}
+    isArgumentsMaterialized() {
 
-	return resolver;
-};
+        // TODO(Constellation)
+        // We can more aggressive on this condition like this.
+        //
+        // function t() {
+        //     // arguments of t is always hidden.
+        //     function arguments() {
+        //     }
+        // }
+        if (this.block.type === Syntax.ArrowFunctionExpression) {
+            return false;
+        }
 
-/**
- * Merging filtered elements
- * @param {string[]} array source array
- * @param {function(string): boolean} filter predicate
- * @returns {Array<string | string[]>} merge result
- */
-function mergeFilteredToArray(array, filter) {
-	/** @type {Array<string | string[]>} */
-	const result = [];
-	const set = new Set(array);
+        if (!this.isStatic()) {
+            return true;
+        }
 
-	for (const item of set) {
-		if (filter(item)) {
-			const lastElement =
-				result.length > 0 ? result[result.length - 1] : undefined;
-			if (Array.isArray(lastElement)) {
-				lastElement.push(item);
-			} else {
-				result.push([item]);
-			}
-		} else {
-			result.push(item);
-		}
-	}
+        const variable = this.set.get("arguments");
 
-	return result;
-}
+        assert(variable, "Always have arguments variable.");
+        return variable.tainted || variable.references.length !== 0;
+    }
 
+    isThisMaterialized() {
+        if (!this.isStatic()) {
+            return true;
+        }
+        return this.thisFound;
+    }
 
-/***/ }),
+    __defineArguments() {
+        this.__defineGeneric(
+            "arguments",
+            this.set,
+            this.variables,
+            null,
+            null
+        );
+        this.taints.set("arguments", true);
+    }
 
-/***/ 39222:
-/***/ (function(module) {
+    // References in default parameters isn't resolved to variables which are in their function body.
+    //     const x = 1
+    //     function f(a = x) { // This `x` is resolved to the `x` in the outer scope.
+    //         const x = 2
+    //         console.log(a)
+    //     }
+    __isValidResolution(ref, variable) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+        // If `options.nodejsScope` is true, `this.block` becomes a Program node.
+        if (this.block.type === "Program") {
+            return true;
+        }
 
+        const bodyStart = this.block.body.range[0];
 
+        // It's invalid resolution in the following case:
+        return !(
+            variable.scope === this &&
+            ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.
+            variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.
+        );
+    }
+}
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+class ForScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "for", upperScope, block, false);
+    }
+}
 
-const slashCode = "/".charCodeAt(0);
-const backslashCode = "\\".charCodeAt(0);
+class ClassScope extends Scope {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, "class", upperScope, block, false);
+    }
+}
 
-const isInside = (path, parent) => {
-	if (!path.startsWith(parent)) return false;
-	if (path.length === parent.length) return true;
-	const charCode = path.charCodeAt(parent.length);
-	return charCode === slashCode || charCode === backslashCode;
+module.exports = {
+    Scope,
+    GlobalScope,
+    ModuleScope,
+    FunctionExpressionNameScope,
+    CatchScope,
+    WithScope,
+    BlockScope,
+    SwitchScope,
+    FunctionScope,
+    ForScope,
+    ClassScope
 };
 
-module.exports = class RestrictionsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {Set<string | RegExp>} restrictions restrictions
-	 */
-	constructor(source, restrictions) {
-		this.source = source;
-		this.restrictions = restrictions;
-	}
-
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		resolver
-			.getHook(this.source)
-			.tapAsync("RestrictionsPlugin", (request, resolveContext, callback) => {
-				if (typeof request.path === "string") {
-					const path = request.path;
-					for (const rule of this.restrictions) {
-						if (typeof rule === "string") {
-							if (!isInside(path, rule)) {
-								if (resolveContext.log) {
-									resolveContext.log(
-										`${path} is not inside of the restriction ${rule}`
-									);
-								}
-								return callback(null, null);
-							}
-						} else if (!rule.test(path)) {
-							if (resolveContext.log) {
-								resolveContext.log(
-									`${path} doesn't match the restriction ${rule}`
-								);
-							}
-							return callback(null, null);
-						}
-					}
-				}
-
-				callback();
-			});
-	}
-};
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 10615:
+/***/ 82971:
 /***/ (function(module) {
 
 "use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
 
-module.exports = class ResultPlugin {
-	/**
-	 * @param {ResolveStepHook} source source
-	 */
-	constructor(source) {
-		this.source = source;
-	}
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		this.source.tapAsync(
-			"ResultPlugin",
-			(request, resolverContext, callback) => {
-				const obj = { ...request };
-				if (resolverContext.log)
-					resolverContext.log("reporting result " + obj.path);
-				resolver.hooks.result.callAsync(obj, resolverContext, err => {
-					if (err) return callback(err);
-					callback(null, obj);
-				});
-			}
-		);
-	}
-};
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
 
-/***/ }),
 
-/***/ 34403:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * A Variable represents a locally scoped identifier. These include arguments to
+ * functions.
+ * @class Variable
+ */
+class Variable {
+    constructor(name, scope) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+        /**
+         * The variable name, as given in the source code.
+         * @member {String} Variable#name
+         */
+        this.name = name;
 
+        /**
+         * List of defining occurrences of this variable (like in 'var ...'
+         * statements or as parameter), as AST nodes.
+         * @member {espree.Identifier[]} Variable#identifiers
+         */
+        this.identifiers = [];
 
+        /**
+         * List of {@link Reference|references} of this variable (excluding parameter entries)
+         * in its defining scope and all nested scopes. For defining
+         * occurrences only see {@link Variable#defs}.
+         * @member {Reference[]} Variable#references
+         */
+        this.references = [];
 
-const forEachBail = __webpack_require__(8266);
+        /**
+         * List of defining occurrences of this variable (like in 'var ...'
+         * statements or as parameter), as custom objects.
+         * @member {Definition[]} Variable#defs
+         */
+        this.defs = [];
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        this.tainted = false;
 
-class RootsPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source hook
-	 * @param {Set<string>} roots roots
-	 * @param {string | ResolveStepHook} target target hook
-	 */
-	constructor(source, roots, target) {
-		this.roots = Array.from(roots);
-		this.source = source;
-		this.target = target;
-	}
+        /**
+         * Whether this is a stack variable.
+         * @member {boolean} Variable#stack
+         */
+        this.stack = true;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
+        /**
+         * Reference to the enclosing Scope.
+         * @member {Scope} Variable#scope
+         */
+        this.scope = scope;
+    }
+}
 
-		resolver
-			.getHook(this.source)
-			.tapAsync("RootsPlugin", (request, resolveContext, callback) => {
-				const req = request.request;
-				if (!req) return callback();
-				if (!req.startsWith("/")) return callback();
+Variable.CatchClause = "CatchClause";
+Variable.Parameter = "Parameter";
+Variable.FunctionName = "FunctionName";
+Variable.ClassName = "ClassName";
+Variable.Variable = "Variable";
+Variable.ImportBinding = "ImportBinding";
+Variable.ImplicitGlobalVariable = "ImplicitGlobalVariable";
 
-				forEachBail(
-					this.roots,
-					(root, callback) => {
-						const path = resolver.join(root, req.slice(1));
-						const obj = {
-							...request,
-							path,
-							relativePath: request.relativePath && path
-						};
-						resolver.doResolve(
-							target,
-							obj,
-							`root path ${root}`,
-							resolveContext,
-							callback
-						);
-					},
-					callback
-				);
-			});
-	}
-}
+module.exports = Variable;
 
-module.exports = RootsPlugin;
+/* vim: set sw=4 ts=4 et tw=80 : */
 
 
 /***/ }),
 
-/***/ 32317:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 81217:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-"use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-const DescriptionFileUtils = __webpack_require__(702);
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+(function () {
+    'use strict';
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    var estraverse = __webpack_require__(50165);
 
-const slashCode = "/".charCodeAt(0);
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
 
-module.exports = class SelfReferencePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | string[]} fieldNamePath name path
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, fieldNamePath, target) {
-		this.source = source;
-		this.target = target;
-		this.fieldName = fieldNamePath;
-	}
+    function isProperty(nodeType, key) {
+        return (nodeType === estraverse.Syntax.ObjectExpression || nodeType === estraverse.Syntax.ObjectPattern) && key === 'properties';
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("SelfReferencePlugin", (request, resolveContext, callback) => {
-				if (!request.descriptionFilePath) return callback();
+    function Visitor(visitor, options) {
+        options = options || {};
 
-				const req = request.request;
-				if (!req) return callback();
+        this.__visitor = visitor ||  this;
+        this.__childVisitorKeys = options.childVisitorKeys
+            ? Object.assign({}, estraverse.VisitorKeys, options.childVisitorKeys)
+            : estraverse.VisitorKeys;
+        if (options.fallback === 'iteration') {
+            this.__fallback = Object.keys;
+        } else if (typeof options.fallback === 'function') {
+            this.__fallback = options.fallback;
+        }
+    }
 
-				// Feature is only enabled when an exports field is present
-				const exportsField = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					this.fieldName
-				);
-				if (!exportsField) return callback();
+    /* Default method for visiting children.
+     * When you need to call default visiting operation inside custom visiting
+     * operation, you can use it with `this.visitChildren(node)`.
+     */
+    Visitor.prototype.visitChildren = function (node) {
+        var type, children, i, iz, j, jz, child;
 
-				const name = DescriptionFileUtils.getField(
-					request.descriptionFileData,
-					"name"
-				);
-				if (typeof name !== "string") return callback();
+        if (node == null) {
+            return;
+        }
 
-				if (
-					req.startsWith(name) &&
-					(req.length === name.length ||
-						req.charCodeAt(name.length) === slashCode)
-				) {
-					const remainingRequest = `.${req.slice(name.length)}`;
+        type = node.type || estraverse.Syntax.Property;
 
-					const obj = {
-						...request,
-						request: remainingRequest,
-						path: /** @type {string} */ (request.descriptionFileRoot),
-						relativePath: "."
-					};
+        children = this.__childVisitorKeys[type];
+        if (!children) {
+            if (this.__fallback) {
+                children = this.__fallback(node);
+            } else {
+                throw new Error('Unknown node type ' + type + '.');
+            }
+        }
 
-					resolver.doResolve(
-						target,
-						obj,
-						"self reference",
-						resolveContext,
-						callback
-					);
-				} else {
-					return callback();
-				}
-			});
-	}
-};
+        for (i = 0, iz = children.length; i < iz; ++i) {
+            child = node[children[i]];
+            if (child) {
+                if (Array.isArray(child)) {
+                    for (j = 0, jz = child.length; j < jz; ++j) {
+                        if (child[j]) {
+                            if (isNode(child[j]) || isProperty(type, children[i])) {
+                                this.visit(child[j]);
+                            }
+                        }
+                    }
+                } else if (isNode(child)) {
+                    this.visit(child);
+                }
+            }
+        }
+    };
 
+    /* Dispatching node. */
+    Visitor.prototype.visit = function (node) {
+        var type;
 
-/***/ }),
+        if (node == null) {
+            return;
+        }
 
-/***/ 21300:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+        type = node.type || estraverse.Syntax.Property;
+        if (this.__visitor[type]) {
+            this.__visitor[type].call(this, node);
+            return;
+        }
+        this.visitChildren(node);
+    };
+
+    exports.version = __webpack_require__(12166).version;
+    exports.Visitor = Visitor;
+    exports.visit = function (node, visitor, options) {
+        var v = new Visitor(visitor, options);
+        v.visit(node);
+    };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
+
+
+/***/ }),
+
+/***/ 50165:
+/***/ (function(__unused_webpack_module, exports) {
 
-"use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
-const forEachBail = __webpack_require__(8266);
-const getPaths = __webpack_require__(48608);
-const { getType, PathType } = __webpack_require__(3011);
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true*/
+(function clone(exports) {
+    'use strict';
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+    var Syntax,
+        VisitorOption,
+        VisitorKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
 
-module.exports = class SymlinkPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, target) {
-		this.source = source;
-		this.target = target;
-	}
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		const fs = resolver.fileSystem;
-		resolver
-			.getHook(this.source)
-			.tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
-				if (request.ignoreSymlinks) return callback();
-				const pathsResult = getPaths(request.path);
-				const pathSeqments = pathsResult.seqments;
-				const paths = pathsResult.paths;
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
 
-				let containsSymlink = false;
-				let idx = -1;
-				forEachBail(
-					paths,
-					(path, callback) => {
-						idx++;
-						if (resolveContext.fileDependencies)
-							resolveContext.fileDependencies.add(path);
-						fs.readlink(path, (err, result) => {
-							if (!err && result) {
-								pathSeqments[idx] = result;
-								containsSymlink = true;
-								// Shortcut when absolute symlink found
-								const resultType = getType(result.toString());
-								if (
-									resultType === PathType.AbsoluteWin ||
-									resultType === PathType.AbsolutePosix
-								) {
-									return callback(null, idx);
-								}
-							}
-							callback();
-						});
-					},
-					(err, idx) => {
-						if (!containsSymlink) return callback();
-						const resultSeqments =
-							typeof idx === "number"
-								? pathSeqments.slice(0, idx + 1)
-								: pathSeqments.slice();
-						const result = resultSeqments.reduceRight((a, b) => {
-							return resolver.join(a, b);
-						});
-						const obj = {
-							...request,
-							path: result
-						};
-						resolver.doResolve(
-							target,
-							obj,
-							"resolved symlink to " + result,
-							resolveContext,
-							callback
-						);
-					}
-				);
-			});
-	}
-};
+    function upperBound(array, func) {
+        var diff, len, i, current;
 
+        len = array.length;
+        i = 0;
 
-/***/ }),
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
 
-/***/ 57746:
-/***/ (function(module) {
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        AssignmentPattern: 'AssignmentPattern',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ChainExpression: 'ChainExpression',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportAllDeclaration: 'ExportAllDeclaration',
+        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
+        ExportNamedDeclaration: 'ExportNamedDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportExpression: 'ImportExpression',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MetaProperty: 'MetaProperty',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        RestElement: 'RestElement',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        Super: 'Super',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        AssignmentPattern: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'body'],
+        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ChainExpression: ['expression'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'superClass', 'body'],
+        ClassExpression: ['id', 'superClass', 'body'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportAllDeclaration: ['source'],
+        ExportDefaultDeclaration: ['declaration'],
+        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['exported', 'local'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'body'],
+        FunctionExpression: ['id', 'params', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportExpression: ['source'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['local'],
+        ImportNamespaceSpecifier: ['local'],
+        ImportSpecifier: ['imported', 'local'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MetaProperty: ['meta', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        RestElement: [ 'argument' ],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        Super: [],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handler', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
 
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
 
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
 
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
 
-/**
- * @param {SyncFileSystem} fs file system implementation
- * @constructor
- */
-function SyncAsyncFileSystemDecorator(fs) {
-	this.fs = fs;
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
 
-	this.lstat = undefined;
-	this.lstatSync = undefined;
-	const lstatSync = fs.lstatSync;
-	if (lstatSync) {
-		this.lstat = (arg, options, callback) => {
-			let result;
-			try {
-				result = lstatSync.call(fs, arg);
-			} catch (e) {
-				return (callback || options)(e);
-			}
-			(callback || options)(null, result);
-		};
-		this.lstatSync = (arg, options) => lstatSync.call(fs, arg, options);
-	}
+    Reference.prototype.remove = function remove() {
+        if (Array.isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
 
-	this.stat = (arg, options, callback) => {
-		let result;
-		try {
-			result = callback ? fs.statSync(arg, options) : fs.statSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.statSync = (arg, options) => fs.statSync(arg, options);
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
 
-	this.readdir = (arg, options, callback) => {
-		let result;
-		try {
-			result = fs.readdirSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.readdirSync = (arg, options) => fs.readdirSync(arg, options);
+    function Controller() { }
 
-	this.readFile = (arg, options, callback) => {
-		let result;
-		try {
-			result = fs.readFileSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.readFileSync = (arg, options) => fs.readFileSync(arg, options);
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
 
-	this.readlink = (arg, options, callback) => {
-		let result;
-		try {
-			result = fs.readlinkSync(arg);
-		} catch (e) {
-			return (callback || options)(e);
-		}
-		(callback || options)(null, result);
-	};
-	this.readlinkSync = (arg, options) => fs.readlinkSync(arg, options);
+        function addToPath(result, path) {
+            if (Array.isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
 
-	this.readJson = undefined;
-	this.readJsonSync = undefined;
-	const readJsonSync = fs.readJsonSync;
-	if (readJsonSync) {
-		this.readJson = (arg, options, callback) => {
-			let result;
-			try {
-				result = readJsonSync.call(fs, arg);
-			} catch (e) {
-				return (callback || options)(e);
-			}
-			(callback || options)(null, result);
-		};
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
 
-		this.readJsonSync = (arg, options) => readJsonSync.call(fs, arg, options);
-	}
-}
-module.exports = SyncAsyncFileSystemDecorator;
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
 
+    // API:
+    // return type of current node
+    Controller.prototype.type = function () {
+        var node = this.current();
+        return node.type || this.__current.wrap;
+    };
 
-/***/ }),
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
 
-/***/ 16442:
-/***/ (function(module) {
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        return result;
+    };
 
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
 
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        result = undefined;
 
-module.exports = class TryNextPlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} message message
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, message, target) {
-		this.source = source;
-		this.message = message;
-		this.target = target;
-	}
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("TryNextPlugin", (request, resolveContext, callback) => {
-				resolver.doResolve(
-					target,
-					request,
-					this.message,
-					resolveContext,
-					callback
-				);
-			});
-	}
-};
-
-
-/***/ }),
-
-/***/ 3501:
-/***/ (function(module) {
+        return result;
+    };
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
 
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
 
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
-/** @typedef {{[k: string]: any}} Cache */
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
 
-function getCacheId(request, withContext) {
-	return JSON.stringify({
-		context: withContext ? request.context : "",
-		path: request.path,
-		query: request.query,
-		fragment: request.fragment,
-		request: request.request
-	});
-}
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = null;
+        if (visitor.fallback === 'iteration') {
+            this.__fallback = Object.keys;
+        } else if (typeof visitor.fallback === 'function') {
+            this.__fallback = visitor.fallback;
+        }
 
-module.exports = class UnsafeCachePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {function(ResolveRequest): boolean} filterPredicate filterPredicate
-	 * @param {Cache} cache cache
-	 * @param {boolean} withContext withContext
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, filterPredicate, cache, withContext, target) {
-		this.source = source;
-		this.filterPredicate = filterPredicate;
-		this.withContext = withContext;
-		this.cache = cache;
-		this.target = target;
-	}
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
+        }
+    };
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
-				if (!this.filterPredicate(request)) return callback();
-				const cacheId = getCacheId(request, this.withContext);
-				const cacheEntry = this.cache[cacheId];
-				if (cacheEntry) {
-					return callback(null, cacheEntry);
-				}
-				resolver.doResolve(
-					target,
-					request,
-					null,
-					resolveContext,
-					(err, result) => {
-						if (err) return callback(err);
-						if (result) return callback(null, (this.cache[cacheId] = result));
-						callback();
-					}
-				);
-			});
-	}
-};
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
 
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
+  
+    function candidateExistsInLeaveList(leavelist, candidate) {
+        for (var i = leavelist.length - 1; i >= 0; --i) {
+            if (leavelist[i].node === candidate) {
+                return true;
+            }
+        }
+        return false;
+    }
 
-/***/ }),
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
 
-/***/ 50318:
-/***/ (function(module) {
+        this.__initialize(root, visitor);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        sentinel = {};
 
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
 
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+        while (worklist.length) {
+            element = worklist.pop();
 
-module.exports = class UseFilePlugin {
-	/**
-	 * @param {string | ResolveStepHook} source source
-	 * @param {string} filename filename
-	 * @param {string | ResolveStepHook} target target
-	 */
-	constructor(source, filename, target) {
-		this.source = source;
-		this.filename = filename;
-		this.target = target;
-	}
+            if (element === sentinel) {
+                element = leavelist.pop();
 
-	/**
-	 * @param {Resolver} resolver the resolver
-	 * @returns {void}
-	 */
-	apply(resolver) {
-		const target = resolver.ensureHook(this.target);
-		resolver
-			.getHook(this.source)
-			.tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
-				const filePath = resolver.join(request.path, this.filename);
-				const obj = {
-					...request,
-					path: filePath,
-					relativePath:
-						request.relativePath &&
-						resolver.join(request.relativePath, this.filename)
-				};
-				resolver.doResolve(
-					target,
-					obj,
-					"using path: " + filePath,
-					resolveContext,
-					callback
-				);
-			});
-	}
-};
+                ret = this.__execute(visitor.leave, element);
 
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
 
-/***/ }),
+            if (element.node) {
 
-/***/ 95478:
-/***/ (function(module) {
+                ret = this.__execute(visitor.enter, element);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
 
+                worklist.push(sentinel);
+                leavelist.push(element);
 
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
 
-module.exports = function createInnerContext(
-	options,
-	message,
-	messageOptional
-) {
-	let messageReported = false;
-	let innerLog = undefined;
-	if (options.log) {
-		if (message) {
-			innerLog = msg => {
-				if (!messageReported) {
-					options.log(message);
-					messageReported = true;
-				}
-				options.log("  " + msg);
-			};
-		} else {
-			innerLog = options.log;
-		}
-	}
-	const childContext = {
-		log: innerLog,
-		fileDependencies: options.fileDependencies,
-		contextDependencies: options.contextDependencies,
-		missingDependencies: options.missingDependencies,
-		stack: options.stack
-	};
-	return childContext;
-};
+                node = element.node;
+                nodeType = node.type || element.wrap;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = this.__fallback(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
 
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
 
-/***/ }),
+                    if (Array.isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
 
-/***/ 8266:
-/***/ (function(module) {
+                            if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
+                              continue;
+                            }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        if (candidateExistsInLeaveList(leavelist, candidate)) {
+                          continue;
+                        }
 
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
 
+    Controller.prototype.replace = function replace(root, visitor) {
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
 
-module.exports = function forEachBail(array, iterator, callback) {
-	if (array.length === 0) return callback();
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
 
-	let i = 0;
-	const next = () => {
-		let loop = undefined;
-		iterator(array[i++], (err, result) => {
-			if (err || result !== undefined || i >= array.length) {
-				return callback(err, result);
-			}
-			if (loop === false) while (next());
-			loop = true;
-		});
-		if (!loop) loop = false;
-		return loop;
-	};
-	while (next());
-};
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
 
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
 
-/***/ }),
+        this.__initialize(root, visitor);
 
-/***/ 50290:
-/***/ (function(module) {
+        sentinel = {};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
 
+        while (worklist.length) {
+            element = worklist.pop();
 
-module.exports = function getInnerRequest(resolver, request) {
-	if (
-		typeof request.__innerRequest === "string" &&
-		request.__innerRequest_request === request.request &&
-		request.__innerRequest_relativePath === request.relativePath
-	)
-		return request.__innerRequest;
-	let innerRequest;
-	if (request.request) {
-		innerRequest = request.request;
-		if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) {
-			innerRequest = resolver.join(request.relativePath, innerRequest);
-		}
-	} else {
-		innerRequest = request.relativePath;
-	}
-	request.__innerRequest_request = request.request;
-	request.__innerRequest_relativePath = request.relativePath;
-	return (request.__innerRequest = innerRequest);
-};
+            if (element === sentinel) {
+                element = leavelist.pop();
 
+                target = this.__execute(visitor.leave, element);
 
-/***/ }),
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
 
-/***/ 48608:
-/***/ (function(module) {
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
 
+            target = this.__execute(visitor.enter, element);
 
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
 
-module.exports = function getPaths(path) {
-	const parts = path.split(/(.*?[\\/]+)/);
-	const paths = [path];
-	const seqments = [parts[parts.length - 1]];
-	let part = parts[parts.length - 1];
-	path = path.substr(0, path.length - part.length - 1);
-	for (let i = parts.length - 2; i > 2; i -= 2) {
-		paths.push(path);
-		part = parts[i];
-		path = path.substr(0, path.length - part.length) || "/";
-		seqments.push(part.substr(0, part.length - 1));
-	}
-	part = parts[1];
-	seqments.push(part);
-	paths.push(part);
-	return {
-		paths: paths,
-		seqments: seqments
-	};
-};
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
 
-module.exports.basename = function basename(path) {
-	const i = path.lastIndexOf("/"),
-		j = path.lastIndexOf("\\");
-	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
-	if (p < 0) return null;
-	const s = path.substr(p + 1);
-	return s;
-};
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
 
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
 
-/***/ }),
+            worklist.push(sentinel);
+            leavelist.push(element);
 
-/***/ 30662:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+            nodeType = node.type || element.wrap;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = this.__fallback(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
 
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
 
+                if (Array.isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
 
-const fs = __webpack_require__(90552);
-const CachedInputFileSystem = __webpack_require__(89429);
-const ResolverFactory = __webpack_require__(53990);
+        return outer.root;
+    };
 
-/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
-/** @typedef {import("./Resolver")} Resolver */
-/** @typedef {import("./Resolver").FileSystem} FileSystem */
-/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
-/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
-/** @typedef {import("./ResolverFactory").Plugin} Plugin */
-/** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
 
-const nodeFileSystem = new CachedInputFileSystem(fs, 4000);
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
 
-const nodeContext = {
-	environments: ["node+es3+es5+process+native"]
-};
+    function extendCommentRange(comment, tokens) {
+        var target;
 
-const asyncResolver = ResolverFactory.createResolver({
-	conditionNames: ["node"],
-	extensions: [".js", ".json", ".node"],
-	fileSystem: nodeFileSystem
-});
-function resolve(context, path, request, resolveContext, callback) {
-	if (typeof context === "string") {
-		callback = resolveContext;
-		resolveContext = request;
-		request = path;
-		path = context;
-		context = nodeContext;
-	}
-	if (typeof callback !== "function") {
-		callback = resolveContext;
-	}
-	asyncResolver.resolve(context, path, request, resolveContext, callback);
-}
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
 
-const syncResolver = ResolverFactory.createResolver({
-	conditionNames: ["node"],
-	extensions: [".js", ".json", ".node"],
-	useSyncFileSystemCalls: true,
-	fileSystem: nodeFileSystem
-});
-function resolveSync(context, path, request) {
-	if (typeof context === "string") {
-		request = path;
-		path = context;
-		context = nodeContext;
-	}
-	return syncResolver.resolveSync(context, path, request);
-}
+        comment.extendedRange = [comment.range[0], comment.range[1]];
 
-function create(options) {
-	options = {
-		fileSystem: nodeFileSystem,
-		...options
-	};
-	const resolver = ResolverFactory.createResolver(options);
-	return function (context, path, request, resolveContext, callback) {
-		if (typeof context === "string") {
-			callback = resolveContext;
-			resolveContext = request;
-			request = path;
-			path = context;
-			context = nodeContext;
-		}
-		if (typeof callback !== "function") {
-			callback = resolveContext;
-		}
-		resolver.resolve(context, path, request, resolveContext, callback);
-	};
-}
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
 
-function createSync(options) {
-	options = {
-		useSyncFileSystemCalls: true,
-		fileSystem: nodeFileSystem,
-		...options
-	};
-	const resolver = ResolverFactory.createResolver(options);
-	return function (context, path, request) {
-		if (typeof context === "string") {
-			request = path;
-			path = context;
-			context = nodeContext;
-		}
-		return resolver.resolveSync(context, path, request);
-	};
-}
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
 
-/**
- * @template A
- * @template B
- * @param {A} obj input a
- * @param {B} exports input b
- * @returns {A & B} merged
- */
-const mergeExports = (obj, exports) => {
-	const descriptors = Object.getOwnPropertyDescriptors(exports);
-	Object.defineProperties(obj, descriptors);
-	return /** @type {A & B} */ (Object.freeze(obj));
-};
+        return comment;
+    }
 
-module.exports = mergeExports(resolve, {
-	get sync() {
-		return resolveSync;
-	},
-	create: mergeExports(create, {
-		get sync() {
-			return createSync;
-		}
-	}),
-	ResolverFactory,
-	CachedInputFileSystem,
-	get CloneBasenamePlugin() {
-		return __webpack_require__(2020);
-	},
-	get LogInfoPlugin() {
-		return __webpack_require__(47032);
-	},
-	get forEachBail() {
-		return __webpack_require__(8266);
-	}
-});
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
 
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
 
-/***/ }),
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
 
-/***/ 28348:
-/***/ (function(module) {
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
 
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
 
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-/** @typedef {string|(string|ConditionalMapping)[]} DirectMapping */
-/** @typedef {{[k: string]: MappingValue}} ConditionalMapping */
-/** @typedef {ConditionalMapping|DirectMapping|null} MappingValue */
-/** @typedef {Record<string, MappingValue>|ConditionalMapping|DirectMapping} ExportsField */
-/** @typedef {Record<string, MappingValue>} ImportsField */
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-/**
- * @typedef {Object} PathTreeNode
- * @property {Map<string, PathTreeNode>|null} children
- * @property {MappingValue} folder
- * @property {Map<string, MappingValue>|null} wildcards
- * @property {Map<string, MappingValue>} files
- */
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
-/**
- * Processing exports/imports field
- * @callback FieldProcessor
- * @param {string} request request
- * @param {Set<string>} conditionNames condition names
- * @returns {string[]} resolved paths
- */
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
 
-/*
-Example exports field:
-{
-  ".": "./main.js",
-  "./feature": {
-    "browser": "./feature-browser.js",
-    "default": "./feature.js"
-  }
-}
-Terminology:
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
 
-Enhanced-resolve name keys ("." and "./feature") as exports field keys.
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-If value is string or string[], mapping is called as a direct mapping
-and value called as a direct export.
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-If value is key-value object, mapping is called as a conditional mapping
-and value called as a conditional export.
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
-Key in conditional mapping is called condition name.
+        return tree;
+    }
 
-Conditional mapping nested in another conditional mapping is called nested mapping.
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+    exports.cloneEnvironment = function () { return clone({}); };
 
-----------
+    return exports;
+}(exports));
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-Example imports field:
-{
-  "#a": "./main.js",
-  "#moment": {
-    "browser": "./moment/index.js",
-    "default": "moment"
-  },
-  "#moment/": {
-    "browser": "./moment/",
-    "default": "moment/"
-  }
-}
-Terminology:
 
-Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys.
+/***/ }),
 
-If value is string or string[], mapping is called as a direct mapping
-and value called as a direct export.
+/***/ 18350:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-If value is key-value object, mapping is called as a conditional mapping
-and value called as a conditional export.
+/*
+  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
 
-Key in conditional mapping is called condition name.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
 
-Conditional mapping nested in another conditional mapping is called nested mapping.
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
 
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true*/
+(function clone(exports) {
+    'use strict';
 
-const slashCode = "/".charCodeAt(0);
-const dotCode = ".".charCodeAt(0);
-const hashCode = "#".charCodeAt(0);
-
-/**
- * @param {ExportsField} exportsField the exports field
- * @returns {FieldProcessor} process callback
- */
-module.exports.processExportsField = function processExportsField(
-	exportsField
-) {
-	return createFieldProcessor(
-		buildExportsFieldPathTree(exportsField),
-		assertExportsFieldRequest,
-		assertExportTarget
-	);
-};
-
-/**
- * @param {ImportsField} importsField the exports field
- * @returns {FieldProcessor} process callback
- */
-module.exports.processImportsField = function processImportsField(
-	importsField
-) {
-	return createFieldProcessor(
-		buildImportsFieldPathTree(importsField),
-		assertImportsFieldRequest,
-		assertImportTarget
-	);
-};
-
-/**
- * @param {PathTreeNode} treeRoot root
- * @param {(s: string) => string} assertRequest assertRequest
- * @param {(s: string, f: boolean) => void} assertTarget assertTarget
- * @returns {FieldProcessor} field processor
- */
-function createFieldProcessor(treeRoot, assertRequest, assertTarget) {
-	return function fieldProcessor(request, conditionNames) {
-		request = assertRequest(request);
+    var Syntax,
+        VisitorOption,
+        VisitorKeys,
+        BREAK,
+        SKIP,
+        REMOVE;
 
-		const match = findMatch(request, treeRoot);
+    function deepCopy(obj) {
+        var ret = {}, key, val;
+        for (key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                val = obj[key];
+                if (typeof val === 'object' && val !== null) {
+                    ret[key] = deepCopy(val);
+                } else {
+                    ret[key] = val;
+                }
+            }
+        }
+        return ret;
+    }
 
-		if (match === null) return [];
+    // based on LLVM libc++ upper_bound / lower_bound
+    // MIT License
 
-		const [mapping, remainRequestIndex] = match;
+    function upperBound(array, func) {
+        var diff, len, i, current;
 
-		/** @type {DirectMapping|null} */
-		let direct = null;
+        len = array.length;
+        i = 0;
 
-		if (isConditionalMapping(mapping)) {
-			direct = conditionalMapping(
-				/** @type {ConditionalMapping} */ (mapping),
-				conditionNames
-			);
+        while (len) {
+            diff = len >>> 1;
+            current = i + diff;
+            if (func(array[current])) {
+                len = diff;
+            } else {
+                i = current + 1;
+                len -= diff + 1;
+            }
+        }
+        return i;
+    }
 
-			// matching not found
-			if (direct === null) return [];
-		} else {
-			direct = /** @type {DirectMapping} */ (mapping);
-		}
+    Syntax = {
+        AssignmentExpression: 'AssignmentExpression',
+        AssignmentPattern: 'AssignmentPattern',
+        ArrayExpression: 'ArrayExpression',
+        ArrayPattern: 'ArrayPattern',
+        ArrowFunctionExpression: 'ArrowFunctionExpression',
+        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
+        BlockStatement: 'BlockStatement',
+        BinaryExpression: 'BinaryExpression',
+        BreakStatement: 'BreakStatement',
+        CallExpression: 'CallExpression',
+        CatchClause: 'CatchClause',
+        ClassBody: 'ClassBody',
+        ClassDeclaration: 'ClassDeclaration',
+        ClassExpression: 'ClassExpression',
+        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: 'ConditionalExpression',
+        ContinueStatement: 'ContinueStatement',
+        DebuggerStatement: 'DebuggerStatement',
+        DirectiveStatement: 'DirectiveStatement',
+        DoWhileStatement: 'DoWhileStatement',
+        EmptyStatement: 'EmptyStatement',
+        ExportAllDeclaration: 'ExportAllDeclaration',
+        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
+        ExportNamedDeclaration: 'ExportNamedDeclaration',
+        ExportSpecifier: 'ExportSpecifier',
+        ExpressionStatement: 'ExpressionStatement',
+        ForStatement: 'ForStatement',
+        ForInStatement: 'ForInStatement',
+        ForOfStatement: 'ForOfStatement',
+        FunctionDeclaration: 'FunctionDeclaration',
+        FunctionExpression: 'FunctionExpression',
+        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
+        Identifier: 'Identifier',
+        IfStatement: 'IfStatement',
+        ImportExpression: 'ImportExpression',
+        ImportDeclaration: 'ImportDeclaration',
+        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+        ImportSpecifier: 'ImportSpecifier',
+        Literal: 'Literal',
+        LabeledStatement: 'LabeledStatement',
+        LogicalExpression: 'LogicalExpression',
+        MemberExpression: 'MemberExpression',
+        MetaProperty: 'MetaProperty',
+        MethodDefinition: 'MethodDefinition',
+        ModuleSpecifier: 'ModuleSpecifier',
+        NewExpression: 'NewExpression',
+        ObjectExpression: 'ObjectExpression',
+        ObjectPattern: 'ObjectPattern',
+        Program: 'Program',
+        Property: 'Property',
+        RestElement: 'RestElement',
+        ReturnStatement: 'ReturnStatement',
+        SequenceExpression: 'SequenceExpression',
+        SpreadElement: 'SpreadElement',
+        Super: 'Super',
+        SwitchStatement: 'SwitchStatement',
+        SwitchCase: 'SwitchCase',
+        TaggedTemplateExpression: 'TaggedTemplateExpression',
+        TemplateElement: 'TemplateElement',
+        TemplateLiteral: 'TemplateLiteral',
+        ThisExpression: 'ThisExpression',
+        ThrowStatement: 'ThrowStatement',
+        TryStatement: 'TryStatement',
+        UnaryExpression: 'UnaryExpression',
+        UpdateExpression: 'UpdateExpression',
+        VariableDeclaration: 'VariableDeclaration',
+        VariableDeclarator: 'VariableDeclarator',
+        WhileStatement: 'WhileStatement',
+        WithStatement: 'WithStatement',
+        YieldExpression: 'YieldExpression'
+    };
 
-		const remainingRequest =
-			remainRequestIndex === request.length + 1
-				? undefined
-				: remainRequestIndex < 0
-				? request.slice(-remainRequestIndex - 1)
-				: request.slice(remainRequestIndex);
-
-		return directMapping(
-			remainingRequest,
-			remainRequestIndex < 0,
-			direct,
-			conditionNames,
-			assertTarget
-		);
-	};
-}
-
-/**
- * @param {string} request request
- * @returns {string} updated request
- */
-function assertExportsFieldRequest(request) {
-	if (request.charCodeAt(0) !== dotCode) {
-		throw new Error('Request should be relative path and start with "."');
-	}
-	if (request.length === 1) return "";
-	if (request.charCodeAt(1) !== slashCode) {
-		throw new Error('Request should be relative path and start with "./"');
-	}
-	if (request.charCodeAt(request.length - 1) === slashCode) {
-		throw new Error("Only requesting file allowed");
-	}
+    VisitorKeys = {
+        AssignmentExpression: ['left', 'right'],
+        AssignmentPattern: ['left', 'right'],
+        ArrayExpression: ['elements'],
+        ArrayPattern: ['elements'],
+        ArrowFunctionExpression: ['params', 'body'],
+        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
+        BlockStatement: ['body'],
+        BinaryExpression: ['left', 'right'],
+        BreakStatement: ['label'],
+        CallExpression: ['callee', 'arguments'],
+        CatchClause: ['param', 'body'],
+        ClassBody: ['body'],
+        ClassDeclaration: ['id', 'superClass', 'body'],
+        ClassExpression: ['id', 'superClass', 'body'],
+        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
+        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        ConditionalExpression: ['test', 'consequent', 'alternate'],
+        ContinueStatement: ['label'],
+        DebuggerStatement: [],
+        DirectiveStatement: [],
+        DoWhileStatement: ['body', 'test'],
+        EmptyStatement: [],
+        ExportAllDeclaration: ['source'],
+        ExportDefaultDeclaration: ['declaration'],
+        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+        ExportSpecifier: ['exported', 'local'],
+        ExpressionStatement: ['expression'],
+        ForStatement: ['init', 'test', 'update', 'body'],
+        ForInStatement: ['left', 'right', 'body'],
+        ForOfStatement: ['left', 'right', 'body'],
+        FunctionDeclaration: ['id', 'params', 'body'],
+        FunctionExpression: ['id', 'params', 'body'],
+        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
+        Identifier: [],
+        IfStatement: ['test', 'consequent', 'alternate'],
+        ImportExpression: ['source'],
+        ImportDeclaration: ['specifiers', 'source'],
+        ImportDefaultSpecifier: ['local'],
+        ImportNamespaceSpecifier: ['local'],
+        ImportSpecifier: ['imported', 'local'],
+        Literal: [],
+        LabeledStatement: ['label', 'body'],
+        LogicalExpression: ['left', 'right'],
+        MemberExpression: ['object', 'property'],
+        MetaProperty: ['meta', 'property'],
+        MethodDefinition: ['key', 'value'],
+        ModuleSpecifier: [],
+        NewExpression: ['callee', 'arguments'],
+        ObjectExpression: ['properties'],
+        ObjectPattern: ['properties'],
+        Program: ['body'],
+        Property: ['key', 'value'],
+        RestElement: [ 'argument' ],
+        ReturnStatement: ['argument'],
+        SequenceExpression: ['expressions'],
+        SpreadElement: ['argument'],
+        Super: [],
+        SwitchStatement: ['discriminant', 'cases'],
+        SwitchCase: ['test', 'consequent'],
+        TaggedTemplateExpression: ['tag', 'quasi'],
+        TemplateElement: [],
+        TemplateLiteral: ['quasis', 'expressions'],
+        ThisExpression: [],
+        ThrowStatement: ['argument'],
+        TryStatement: ['block', 'handler', 'finalizer'],
+        UnaryExpression: ['argument'],
+        UpdateExpression: ['argument'],
+        VariableDeclaration: ['declarations'],
+        VariableDeclarator: ['id', 'init'],
+        WhileStatement: ['test', 'body'],
+        WithStatement: ['object', 'body'],
+        YieldExpression: ['argument']
+    };
 
-	return request.slice(2);
-}
+    // unique id
+    BREAK = {};
+    SKIP = {};
+    REMOVE = {};
 
-/**
- * @param {string} request request
- * @returns {string} updated request
- */
-function assertImportsFieldRequest(request) {
-	if (request.charCodeAt(0) !== hashCode) {
-		throw new Error('Request should start with "#"');
-	}
-	if (request.length === 1) {
-		throw new Error("Request should have at least 2 characters");
-	}
-	if (request.charCodeAt(1) === slashCode) {
-		throw new Error('Request should not start with "#/"');
-	}
-	if (request.charCodeAt(request.length - 1) === slashCode) {
-		throw new Error("Only requesting file allowed");
-	}
+    VisitorOption = {
+        Break: BREAK,
+        Skip: SKIP,
+        Remove: REMOVE
+    };
 
-	return request.slice(1);
-}
+    function Reference(parent, key) {
+        this.parent = parent;
+        this.key = key;
+    }
 
-/**
- * @param {string} exp export target
- * @param {boolean} expectFolder is folder expected
- */
-function assertExportTarget(exp, expectFolder) {
-	if (
-		exp.charCodeAt(0) === slashCode ||
-		(exp.charCodeAt(0) === dotCode && exp.charCodeAt(1) !== slashCode)
-	) {
-		throw new Error(
-			`Export should be relative path and start with "./", got ${JSON.stringify(
-				exp
-			)}.`
-		);
-	}
+    Reference.prototype.replace = function replace(node) {
+        this.parent[this.key] = node;
+    };
 
-	const isFolder = exp.charCodeAt(exp.length - 1) === slashCode;
+    Reference.prototype.remove = function remove() {
+        if (Array.isArray(this.parent)) {
+            this.parent.splice(this.key, 1);
+            return true;
+        } else {
+            this.replace(null);
+            return false;
+        }
+    };
 
-	if (isFolder !== expectFolder) {
-		throw new Error(
-			expectFolder
-				? `Expecting folder to folder mapping. ${JSON.stringify(
-						exp
-				  )} should end with "/"`
-				: `Expecting file to file mapping. ${JSON.stringify(
-						exp
-				  )} should not end with "/"`
-		);
-	}
-}
+    function Element(node, path, wrap, ref) {
+        this.node = node;
+        this.path = path;
+        this.wrap = wrap;
+        this.ref = ref;
+    }
 
-/**
- * @param {string} imp import target
- * @param {boolean} expectFolder is folder expected
- */
-function assertImportTarget(imp, expectFolder) {
-	const isFolder = imp.charCodeAt(imp.length - 1) === slashCode;
+    function Controller() { }
 
-	if (isFolder !== expectFolder) {
-		throw new Error(
-			expectFolder
-				? `Expecting folder to folder mapping. ${JSON.stringify(
-						imp
-				  )} should end with "/"`
-				: `Expecting file to file mapping. ${JSON.stringify(
-						imp
-				  )} should not end with "/"`
-		);
-	}
-}
+    // API:
+    // return property path array from root to current node
+    Controller.prototype.path = function path() {
+        var i, iz, j, jz, result, element;
 
-/**
- * Trying to match request to field
- * @param {string} request request
- * @param {PathTreeNode} treeRoot path tree root
- * @returns {[MappingValue, number]|null} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings
- */
-function findMatch(request, treeRoot) {
-	if (request.length === 0) {
-		const value = treeRoot.files.get("");
+        function addToPath(result, path) {
+            if (Array.isArray(path)) {
+                for (j = 0, jz = path.length; j < jz; ++j) {
+                    result.push(path[j]);
+                }
+            } else {
+                result.push(path);
+            }
+        }
 
-		return value ? [value, 1] : null;
-	}
+        // root node
+        if (!this.__current.path) {
+            return null;
+        }
 
-	if (
-		treeRoot.children === null &&
-		treeRoot.folder === null &&
-		treeRoot.wildcards === null
-	) {
-		const value = treeRoot.files.get(request);
+        // first node is sentinel, second node is root element
+        result = [];
+        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+            element = this.__leavelist[i];
+            addToPath(result, element.path);
+        }
+        addToPath(result, this.__current.path);
+        return result;
+    };
 
-		return value ? [value, request.length + 1] : null;
-	}
+    // API:
+    // return type of current node
+    Controller.prototype.type = function () {
+        var node = this.current();
+        return node.type || this.__current.wrap;
+    };
 
-	let node = treeRoot;
-	let lastNonSlashIndex = 0;
-	let slashIndex = request.indexOf("/", 0);
+    // API:
+    // return array of parent elements
+    Controller.prototype.parents = function parents() {
+        var i, iz, result;
 
-	/** @type {[MappingValue, number]|null} */
-	let lastFolderMatch = null;
+        // first node is sentinel
+        result = [];
+        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+            result.push(this.__leavelist[i].node);
+        }
 
-	const applyFolderMapping = () => {
-		const folderMapping = node.folder;
-		if (folderMapping) {
-			if (lastFolderMatch) {
-				lastFolderMatch[0] = folderMapping;
-				lastFolderMatch[1] = -lastNonSlashIndex - 1;
-			} else {
-				lastFolderMatch = [folderMapping, -lastNonSlashIndex - 1];
-			}
-		}
-	};
+        return result;
+    };
 
-	const applyWildcardMappings = (wildcardMappings, remainingRequest) => {
-		if (wildcardMappings) {
-			for (const [key, target] of wildcardMappings) {
-				if (remainingRequest.startsWith(key)) {
-					if (!lastFolderMatch) {
-						lastFolderMatch = [target, lastNonSlashIndex + key.length];
-					} else if (lastFolderMatch[1] < lastNonSlashIndex + key.length) {
-						lastFolderMatch[0] = target;
-						lastFolderMatch[1] = lastNonSlashIndex + key.length;
-					}
-				}
-			}
-		}
-	};
+    // API:
+    // return current node
+    Controller.prototype.current = function current() {
+        return this.__current.node;
+    };
 
-	while (slashIndex !== -1) {
-		applyFolderMapping();
+    Controller.prototype.__execute = function __execute(callback, element) {
+        var previous, result;
 
-		const wildcardMappings = node.wildcards;
+        result = undefined;
 
-		if (!wildcardMappings && node.children === null) return lastFolderMatch;
+        previous  = this.__current;
+        this.__current = element;
+        this.__state = null;
+        if (callback) {
+            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+        }
+        this.__current = previous;
 
-		const folder = request.slice(lastNonSlashIndex, slashIndex);
+        return result;
+    };
 
-		applyWildcardMappings(wildcardMappings, folder);
+    // API:
+    // notify control skip / break
+    Controller.prototype.notify = function notify(flag) {
+        this.__state = flag;
+    };
 
-		if (node.children === null) return lastFolderMatch;
+    // API:
+    // skip child nodes of current node
+    Controller.prototype.skip = function () {
+        this.notify(SKIP);
+    };
 
-		const newNode = node.children.get(folder);
+    // API:
+    // break traversals
+    Controller.prototype['break'] = function () {
+        this.notify(BREAK);
+    };
 
-		if (!newNode) {
-			return lastFolderMatch;
-		}
+    // API:
+    // remove node
+    Controller.prototype.remove = function () {
+        this.notify(REMOVE);
+    };
 
-		node = newNode;
-		lastNonSlashIndex = slashIndex + 1;
-		slashIndex = request.indexOf("/", lastNonSlashIndex);
-	}
+    Controller.prototype.__initialize = function(root, visitor) {
+        this.visitor = visitor;
+        this.root = root;
+        this.__worklist = [];
+        this.__leavelist = [];
+        this.__current = null;
+        this.__state = null;
+        this.__fallback = null;
+        if (visitor.fallback === 'iteration') {
+            this.__fallback = Object.keys;
+        } else if (typeof visitor.fallback === 'function') {
+            this.__fallback = visitor.fallback;
+        }
 
-	const remainingRequest =
-		lastNonSlashIndex > 0 ? request.slice(lastNonSlashIndex) : request;
+        this.__keys = VisitorKeys;
+        if (visitor.keys) {
+            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
+        }
+    };
 
-	const value = node.files.get(remainingRequest);
+    function isNode(node) {
+        if (node == null) {
+            return false;
+        }
+        return typeof node === 'object' && typeof node.type === 'string';
+    }
 
-	if (value) {
-		return [value, request.length + 1];
-	}
+    function isProperty(nodeType, key) {
+        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+    }
 
-	applyFolderMapping();
+    Controller.prototype.traverse = function traverse(root, visitor) {
+        var worklist,
+            leavelist,
+            element,
+            node,
+            nodeType,
+            ret,
+            key,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel;
 
-	applyWildcardMappings(node.wildcards, remainingRequest);
+        this.__initialize(root, visitor);
 
-	return lastFolderMatch;
-}
+        sentinel = {};
 
-/**
- * @param {ConditionalMapping|DirectMapping|null} mapping mapping
- * @returns {boolean} is conditional mapping
- */
-function isConditionalMapping(mapping) {
-	return (
-		mapping !== null && typeof mapping === "object" && !Array.isArray(mapping)
-	);
-}
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
-/**
- * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
- * @param {boolean} subpathMapping true, for subpath mappings
- * @param {DirectMapping|null} mappingTarget direct export
- * @param {Set<string>} conditionNames condition names
- * @param {(d: string, f: boolean) => void} assert asserting direct value
- * @returns {string[]} mapping result
- */
-function directMapping(
-	remainingRequest,
-	subpathMapping,
-	mappingTarget,
-	conditionNames,
-	assert
-) {
-	if (mappingTarget === null) return [];
+        // initialize
+        worklist.push(new Element(root, null, null, null));
+        leavelist.push(new Element(null, null, null, null));
 
-	if (typeof mappingTarget === "string") {
-		return [
-			targetMapping(remainingRequest, subpathMapping, mappingTarget, assert)
-		];
-	}
+        while (worklist.length) {
+            element = worklist.pop();
 
-	const targets = [];
+            if (element === sentinel) {
+                element = leavelist.pop();
 
-	for (const exp of mappingTarget) {
-		if (typeof exp === "string") {
-			targets.push(
-				targetMapping(remainingRequest, subpathMapping, exp, assert)
-			);
-			continue;
-		}
+                ret = this.__execute(visitor.leave, element);
 
-		const mapping = conditionalMapping(exp, conditionNames);
-		if (!mapping) continue;
-		const innerExports = directMapping(
-			remainingRequest,
-			subpathMapping,
-			mapping,
-			conditionNames,
-			assert
-		);
-		for (const innerExport of innerExports) {
-			targets.push(innerExport);
-		}
-	}
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
+                continue;
+            }
 
-	return targets;
-}
+            if (element.node) {
 
-/**
- * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
- * @param {boolean} subpathMapping true, for subpath mappings
- * @param {string} mappingTarget direct export
- * @param {(d: string, f: boolean) => void} assert asserting direct value
- * @returns {string} mapping result
- */
-function targetMapping(
-	remainingRequest,
-	subpathMapping,
-	mappingTarget,
-	assert
-) {
-	if (remainingRequest === undefined) {
-		assert(mappingTarget, false);
-		return mappingTarget;
-	}
-	if (subpathMapping) {
-		assert(mappingTarget, true);
-		return mappingTarget + remainingRequest;
-	}
-	assert(mappingTarget, false);
-	return mappingTarget.replace(/\*/g, remainingRequest.replace(/\$/g, "$$"));
-}
+                ret = this.__execute(visitor.enter, element);
 
-/**
- * @param {ConditionalMapping} conditionalMapping_ conditional mapping
- * @param {Set<string>} conditionNames condition names
- * @returns {DirectMapping|null} direct mapping if found
- */
-function conditionalMapping(conditionalMapping_, conditionNames) {
-	/** @type {[ConditionalMapping, string[], number][]} */
-	let lookup = [[conditionalMapping_, Object.keys(conditionalMapping_), 0]];
+                if (this.__state === BREAK || ret === BREAK) {
+                    return;
+                }
 
-	loop: while (lookup.length > 0) {
-		const [mapping, conditions, j] = lookup[lookup.length - 1];
-		const last = conditions.length - 1;
+                worklist.push(sentinel);
+                leavelist.push(element);
 
-		for (let i = j; i < conditions.length; i++) {
-			const condition = conditions[i];
+                if (this.__state === SKIP || ret === SKIP) {
+                    continue;
+                }
 
-			// assert default. Could be last only
-			if (i !== last) {
-				if (condition === "default") {
-					throw new Error("Default condition should be last one");
-				}
-			} else if (condition === "default") {
-				const innerMapping = mapping[condition];
-				// is nested
-				if (isConditionalMapping(innerMapping)) {
-					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
-					lookup[lookup.length - 1][2] = i + 1;
-					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
-					continue loop;
-				}
+                node = element.node;
+                nodeType = node.type || element.wrap;
+                candidates = this.__keys[nodeType];
+                if (!candidates) {
+                    if (this.__fallback) {
+                        candidates = this.__fallback(node);
+                    } else {
+                        throw new Error('Unknown node type ' + nodeType + '.');
+                    }
+                }
 
-				return /** @type {DirectMapping} */ (innerMapping);
-			}
+                current = candidates.length;
+                while ((current -= 1) >= 0) {
+                    key = candidates[current];
+                    candidate = node[key];
+                    if (!candidate) {
+                        continue;
+                    }
 
-			if (conditionNames.has(condition)) {
-				const innerMapping = mapping[condition];
-				// is nested
-				if (isConditionalMapping(innerMapping)) {
-					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
-					lookup[lookup.length - 1][2] = i + 1;
-					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
-					continue loop;
-				}
+                    if (Array.isArray(candidate)) {
+                        current2 = candidate.length;
+                        while ((current2 -= 1) >= 0) {
+                            if (!candidate[current2]) {
+                                continue;
+                            }
+                            if (isProperty(nodeType, candidates[current])) {
+                                element = new Element(candidate[current2], [key, current2], 'Property', null);
+                            } else if (isNode(candidate[current2])) {
+                                element = new Element(candidate[current2], [key, current2], null, null);
+                            } else {
+                                continue;
+                            }
+                            worklist.push(element);
+                        }
+                    } else if (isNode(candidate)) {
+                        worklist.push(new Element(candidate, key, null, null));
+                    }
+                }
+            }
+        }
+    };
 
-				return /** @type {DirectMapping} */ (innerMapping);
-			}
-		}
+    Controller.prototype.replace = function replace(root, visitor) {
+        var worklist,
+            leavelist,
+            node,
+            nodeType,
+            target,
+            element,
+            current,
+            current2,
+            candidates,
+            candidate,
+            sentinel,
+            outer,
+            key;
 
-		lookup.pop();
-	}
+        function removeElem(element) {
+            var i,
+                key,
+                nextElem,
+                parent;
 
-	return null;
-}
+            if (element.ref.remove()) {
+                // When the reference is an element of an array.
+                key = element.ref.key;
+                parent = element.ref.parent;
 
-/**
- * Internal helper to create path tree node
- * to ensure that each node gets the same hidden class
- * @returns {PathTreeNode} node
- */
-function createNode() {
-	return {
-		children: null,
-		folder: null,
-		wildcards: null,
-		files: new Map()
-	};
-}
+                // If removed from array, then decrease following items' keys.
+                i = worklist.length;
+                while (i--) {
+                    nextElem = worklist[i];
+                    if (nextElem.ref && nextElem.ref.parent === parent) {
+                        if  (nextElem.ref.key < key) {
+                            break;
+                        }
+                        --nextElem.ref.key;
+                    }
+                }
+            }
+        }
 
-/**
- * Internal helper for building path tree
- * @param {PathTreeNode} root root
- * @param {string} path path
- * @param {MappingValue} target target
- */
-function walkPath(root, path, target) {
-	if (path.length === 0) {
-		root.folder = target;
-		return;
-	}
+        this.__initialize(root, visitor);
 
-	let node = root;
-	// Typical path tree can looks like
-	// root
-	// - files: ["a.js", "b.js"]
-	// - children:
-	//    node1:
-	//    - files: ["a.js", "b.js"]
-	let lastNonSlashIndex = 0;
-	let slashIndex = path.indexOf("/", 0);
+        sentinel = {};
 
-	while (slashIndex !== -1) {
-		const folder = path.slice(lastNonSlashIndex, slashIndex);
-		let newNode;
+        // reference
+        worklist = this.__worklist;
+        leavelist = this.__leavelist;
 
-		if (node.children === null) {
-			newNode = createNode();
-			node.children = new Map();
-			node.children.set(folder, newNode);
-		} else {
-			newNode = node.children.get(folder);
+        // initialize
+        outer = {
+            root: root
+        };
+        element = new Element(root, null, null, new Reference(outer, 'root'));
+        worklist.push(element);
+        leavelist.push(element);
 
-			if (!newNode) {
-				newNode = createNode();
-				node.children.set(folder, newNode);
-			}
-		}
+        while (worklist.length) {
+            element = worklist.pop();
 
-		node = newNode;
-		lastNonSlashIndex = slashIndex + 1;
-		slashIndex = path.indexOf("/", lastNonSlashIndex);
-	}
+            if (element === sentinel) {
+                element = leavelist.pop();
 
-	if (lastNonSlashIndex >= path.length) {
-		node.folder = target;
-	} else {
-		const file = lastNonSlashIndex > 0 ? path.slice(lastNonSlashIndex) : path;
-		if (file.endsWith("*")) {
-			if (node.wildcards === null) node.wildcards = new Map();
-			node.wildcards.set(file.slice(0, -1), target);
-		} else {
-			node.files.set(file, target);
-		}
-	}
-}
+                target = this.__execute(visitor.leave, element);
 
-/**
- * @param {ExportsField} field exports field
- * @returns {PathTreeNode} tree root
- */
-function buildExportsFieldPathTree(field) {
-	const root = createNode();
+                // node may be replaced with null,
+                // so distinguish between undefined and null in this place
+                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                    // replace
+                    element.ref.replace(target);
+                }
 
-	// handle syntax sugar, if exports field is direct mapping for "."
-	if (typeof field === "string") {
-		root.files.set("", field);
+                if (this.__state === REMOVE || target === REMOVE) {
+                    removeElem(element);
+                }
 
-		return root;
-	} else if (Array.isArray(field)) {
-		root.files.set("", field.slice());
+                if (this.__state === BREAK || target === BREAK) {
+                    return outer.root;
+                }
+                continue;
+            }
 
-		return root;
-	}
+            target = this.__execute(visitor.enter, element);
 
-	const keys = Object.keys(field);
+            // node may be replaced with null,
+            // so distinguish between undefined and null in this place
+            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+                // replace
+                element.ref.replace(target);
+                element.node = target;
+            }
 
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
+            if (this.__state === REMOVE || target === REMOVE) {
+                removeElem(element);
+                element.node = null;
+            }
 
-		if (key.charCodeAt(0) !== dotCode) {
-			// handle syntax sugar, if exports field is conditional mapping for "."
-			if (i === 0) {
-				while (i < keys.length) {
-					const charCode = keys[i].charCodeAt(0);
-					if (charCode === dotCode || charCode === slashCode) {
-						throw new Error(
-							`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
-								key
-							)})`
-						);
-					}
-					i++;
-				}
+            if (this.__state === BREAK || target === BREAK) {
+                return outer.root;
+            }
 
-				root.files.set("", field);
-				return root;
-			}
+            // node may be null
+            node = element.node;
+            if (!node) {
+                continue;
+            }
 
-			throw new Error(
-				`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
+            worklist.push(sentinel);
+            leavelist.push(element);
 
-		if (key.length === 1) {
-			root.files.set("", field[key]);
-			continue;
-		}
+            if (this.__state === SKIP || target === SKIP) {
+                continue;
+            }
 
-		if (key.charCodeAt(1) !== slashCode) {
-			throw new Error(
-				`Exports field key should be relative path and start with "./" (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
+            nodeType = node.type || element.wrap;
+            candidates = this.__keys[nodeType];
+            if (!candidates) {
+                if (this.__fallback) {
+                    candidates = this.__fallback(node);
+                } else {
+                    throw new Error('Unknown node type ' + nodeType + '.');
+                }
+            }
 
-		walkPath(root, key.slice(2), field[key]);
-	}
+            current = candidates.length;
+            while ((current -= 1) >= 0) {
+                key = candidates[current];
+                candidate = node[key];
+                if (!candidate) {
+                    continue;
+                }
 
-	return root;
-}
+                if (Array.isArray(candidate)) {
+                    current2 = candidate.length;
+                    while ((current2 -= 1) >= 0) {
+                        if (!candidate[current2]) {
+                            continue;
+                        }
+                        if (isProperty(nodeType, candidates[current])) {
+                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+                        } else if (isNode(candidate[current2])) {
+                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+                        } else {
+                            continue;
+                        }
+                        worklist.push(element);
+                    }
+                } else if (isNode(candidate)) {
+                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+                }
+            }
+        }
 
-/**
- * @param {ImportsField} field imports field
- * @returns {PathTreeNode} root
- */
-function buildImportsFieldPathTree(field) {
-	const root = createNode();
+        return outer.root;
+    };
 
-	const keys = Object.keys(field);
+    function traverse(root, visitor) {
+        var controller = new Controller();
+        return controller.traverse(root, visitor);
+    }
 
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
+    function replace(root, visitor) {
+        var controller = new Controller();
+        return controller.replace(root, visitor);
+    }
 
-		if (key.charCodeAt(0) !== hashCode) {
-			throw new Error(
-				`Imports field key should start with "#" (key: ${JSON.stringify(key)})`
-			);
-		}
+    function extendCommentRange(comment, tokens) {
+        var target;
 
-		if (key.length === 1) {
-			throw new Error(
-				`Imports field key should have at least 2 characters (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
+        target = upperBound(tokens, function search(token) {
+            return token.range[0] > comment.range[0];
+        });
 
-		if (key.charCodeAt(1) === slashCode) {
-			throw new Error(
-				`Imports field key should not start with "#/" (key: ${JSON.stringify(
-					key
-				)})`
-			);
-		}
+        comment.extendedRange = [comment.range[0], comment.range[1]];
 
-		walkPath(root, key.slice(1), field[key]);
-	}
+        if (target !== tokens.length) {
+            comment.extendedRange[1] = tokens[target].range[0];
+        }
 
-	return root;
-}
+        target -= 1;
+        if (target >= 0) {
+            comment.extendedRange[0] = tokens[target].range[1];
+        }
 
+        return comment;
+    }
 
-/***/ }),
+    function attachComments(tree, providedComments, tokens) {
+        // At first, we should calculate extended comment ranges.
+        var comments = [], comment, len, i, cursor;
 
-/***/ 7780:
-/***/ (function(module) {
+        if (!tree.range) {
+            throw new Error('attachComments needs range information');
+        }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+        // tokens array is empty, we attach comments to tree as 'leadingComments'
+        if (!tokens.length) {
+            if (providedComments.length) {
+                for (i = 0, len = providedComments.length; i < len; i += 1) {
+                    comment = deepCopy(providedComments[i]);
+                    comment.extendedRange = [0, tree.range[0]];
+                    comments.push(comment);
+                }
+                tree.leadingComments = comments;
+            }
+            return tree;
+        }
 
+        for (i = 0, len = providedComments.length; i < len; i += 1) {
+            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+        }
 
+        // This is based on John Freeman's implementation.
+        cursor = 0;
+        traverse(tree, {
+            enter: function (node) {
+                var comment;
 
-const PATH_QUERY_FRAGMENT_REGEXP = /^(#?(?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (comment.extendedRange[1] > node.range[0]) {
+                        break;
+                    }
 
-/**
- * @param {string} identifier identifier
- * @returns {[string, string, string]|null} parsed identifier
- */
-function parseIdentifier(identifier) {
-	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier);
+                    if (comment.extendedRange[1] === node.range[0]) {
+                        if (!node.leadingComments) {
+                            node.leadingComments = [];
+                        }
+                        node.leadingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-	if (!match) return null;
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-	return [
-		match[1].replace(/\0(.)/g, "$1"),
-		match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		match[3] || ""
-	];
-}
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
-module.exports.parseIdentifier = parseIdentifier;
+        cursor = 0;
+        traverse(tree, {
+            leave: function (node) {
+                var comment;
 
+                while (cursor < comments.length) {
+                    comment = comments[cursor];
+                    if (node.range[1] < comment.extendedRange[0]) {
+                        break;
+                    }
 
-/***/ }),
+                    if (node.range[1] === comment.extendedRange[0]) {
+                        if (!node.trailingComments) {
+                            node.trailingComments = [];
+                        }
+                        node.trailingComments.push(comment);
+                        comments.splice(cursor, 1);
+                    } else {
+                        cursor += 1;
+                    }
+                }
 
-/***/ 3011:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+                // already out of owned node
+                if (cursor === comments.length) {
+                    return VisitorOption.Break;
+                }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+                if (comments[cursor].extendedRange[0] > node.range[1]) {
+                    return VisitorOption.Skip;
+                }
+            }
+        });
 
+        return tree;
+    }
 
+    exports.version = (__webpack_require__(15535)/* .version */ .i8);
+    exports.Syntax = Syntax;
+    exports.traverse = traverse;
+    exports.replace = replace;
+    exports.attachComments = attachComments;
+    exports.VisitorKeys = VisitorKeys;
+    exports.VisitorOption = VisitorOption;
+    exports.Controller = Controller;
+    exports.cloneEnvironment = function () { return clone({}); };
 
-const path = __webpack_require__(71017);
+    return exports;
+}(exports));
+/* vim: set sw=4 ts=4 et tw=80 : */
 
-const CHAR_HASH = "#".charCodeAt(0);
-const CHAR_SLASH = "/".charCodeAt(0);
-const CHAR_BACKSLASH = "\\".charCodeAt(0);
-const CHAR_A = "A".charCodeAt(0);
-const CHAR_Z = "Z".charCodeAt(0);
-const CHAR_LOWER_A = "a".charCodeAt(0);
-const CHAR_LOWER_Z = "z".charCodeAt(0);
-const CHAR_DOT = ".".charCodeAt(0);
-const CHAR_COLON = ":".charCodeAt(0);
 
-const posixNormalize = path.posix.normalize;
-const winNormalize = path.win32.normalize;
+/***/ }),
 
-/**
- * @enum {number}
- */
-const PathType = Object.freeze({
-	Empty: 0,
-	Normal: 1,
-	Relative: 2,
-	AbsoluteWin: 3,
-	AbsolutePosix: 4,
-	Internal: 5
-});
-exports.PathType = PathType;
+/***/ 86140:
+/***/ (function(module) {
 
-/**
- * @param {string} p a path
- * @returns {PathType} type of path
- */
-const getType = p => {
-	switch (p.length) {
-		case 0:
-			return PathType.Empty;
-		case 1: {
-			const c0 = p.charCodeAt(0);
-			switch (c0) {
-				case CHAR_DOT:
-					return PathType.Relative;
-				case CHAR_SLASH:
-					return PathType.AbsolutePosix;
-				case CHAR_HASH:
-					return PathType.Internal;
-			}
-			return PathType.Normal;
-		}
-		case 2: {
-			const c0 = p.charCodeAt(0);
-			switch (c0) {
-				case CHAR_DOT: {
-					const c1 = p.charCodeAt(1);
-					switch (c1) {
-						case CHAR_DOT:
-						case CHAR_SLASH:
-							return PathType.Relative;
-					}
-					return PathType.Normal;
-				}
-				case CHAR_SLASH:
-					return PathType.AbsolutePosix;
-				case CHAR_HASH:
-					return PathType.Internal;
-			}
-			const c1 = p.charCodeAt(1);
-			if (c1 === CHAR_COLON) {
-				if (
-					(c0 >= CHAR_A && c0 <= CHAR_Z) ||
-					(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)
-				) {
-					return PathType.AbsoluteWin;
-				}
-			}
-			return PathType.Normal;
-		}
-	}
-	const c0 = p.charCodeAt(0);
-	switch (c0) {
-		case CHAR_DOT: {
-			const c1 = p.charCodeAt(1);
-			switch (c1) {
-				case CHAR_SLASH:
-					return PathType.Relative;
-				case CHAR_DOT: {
-					const c2 = p.charCodeAt(2);
-					if (c2 === CHAR_SLASH) return PathType.Relative;
-					return PathType.Normal;
-				}
-			}
-			return PathType.Normal;
-		}
-		case CHAR_SLASH:
-			return PathType.AbsolutePosix;
-		case CHAR_HASH:
-			return PathType.Internal;
-	}
-	const c1 = p.charCodeAt(1);
-	if (c1 === CHAR_COLON) {
-		const c2 = p.charCodeAt(2);
-		if (
-			(c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) &&
-			((c0 >= CHAR_A && c0 <= CHAR_Z) ||
-				(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z))
-		) {
-			return PathType.AbsoluteWin;
-		}
-	}
-	return PathType.Normal;
-};
-exports.getType = getType;
+module.exports = function (glob, opts) {
+  if (typeof glob !== 'string') {
+    throw new TypeError('Expected a string');
+  }
 
-/**
- * @param {string} p a path
- * @returns {string} the normalized path
- */
-const normalize = p => {
-	switch (getType(p)) {
-		case PathType.Empty:
-			return p;
-		case PathType.AbsoluteWin:
-			return winNormalize(p);
-		case PathType.Relative: {
-			const r = posixNormalize(p);
-			return getType(r) === PathType.Relative ? r : `./${r}`;
-		}
-	}
-	return posixNormalize(p);
-};
-exports.normalize = normalize;
+  var str = String(glob);
 
-/**
- * @param {string} rootPath the root path
- * @param {string | undefined} request the request path
- * @returns {string} the joined path
- */
-const join = (rootPath, request) => {
-	if (!request) return normalize(rootPath);
-	const requestType = getType(request);
-	switch (requestType) {
-		case PathType.AbsolutePosix:
-			return posixNormalize(request);
-		case PathType.AbsoluteWin:
-			return winNormalize(request);
-	}
-	switch (getType(rootPath)) {
-		case PathType.Normal:
-		case PathType.Relative:
-		case PathType.AbsolutePosix:
-			return posixNormalize(`${rootPath}/${request}`);
-		case PathType.AbsoluteWin:
-			return winNormalize(`${rootPath}\\${request}`);
-	}
-	switch (requestType) {
-		case PathType.Empty:
-			return rootPath;
-		case PathType.Relative: {
-			const r = posixNormalize(rootPath);
-			return getType(r) === PathType.Relative ? r : `./${r}`;
-		}
-	}
-	return posixNormalize(rootPath);
-};
-exports.join = join;
+  // The regexp we are building, as a string.
+  var reStr = "";
 
-const joinCache = new Map();
+  // Whether we are matching so called "extended" globs (like bash) and should
+  // support single character matching, matching ranges of characters, group
+  // matching, etc.
+  var extended = opts ? !!opts.extended : false;
 
-/**
- * @param {string} rootPath the root path
- * @param {string | undefined} request the request path
- * @returns {string} the joined path
- */
-const cachedJoin = (rootPath, request) => {
-	let cacheEntry;
-	let cache = joinCache.get(rootPath);
-	if (cache === undefined) {
-		joinCache.set(rootPath, (cache = new Map()));
-	} else {
-		cacheEntry = cache.get(request);
-		if (cacheEntry !== undefined) return cacheEntry;
-	}
-	cacheEntry = join(rootPath, request);
-	cache.set(request, cacheEntry);
-	return cacheEntry;
-};
-exports.cachedJoin = cachedJoin;
+  // When globstar is _false_ (default), '/foo/*' is translated a regexp like
+  // '^\/foo\/.*$' which will match any string beginning with '/foo/'
+  // When globstar is _true_, '/foo/*' is translated to regexp like
+  // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
+  // which does not have a '/' to the right of it.
+  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
+  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
+  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
+  // globstar is _false_
+  var globstar = opts ? !!opts.globstar : false;
 
-const checkExportsFieldTarget = relativePath => {
-	let lastNonSlashIndex = 2;
-	let slashIndex = relativePath.indexOf("/", 2);
-	let cd = 0;
+  // If we are doing extended matching, this boolean is true when we are inside
+  // a group (eg {*.html,*.js}), and false otherwise.
+  var inGroup = false;
 
-	while (slashIndex !== -1) {
-		const folder = relativePath.slice(lastNonSlashIndex, slashIndex);
+  // RegExp flags (eg "i" ) to pass in to RegExp constructor.
+  var flags = opts && typeof( opts.flags ) === "string" ? opts.flags : "";
 
-		switch (folder) {
-			case "..": {
-				cd--;
-				if (cd < 0)
-					return new Error(
-						`Trying to access out of package scope. Requesting ${relativePath}`
-					);
-				break;
-			}
-			default:
-				cd++;
-				break;
-		}
+  var c;
+  for (var i = 0, len = str.length; i < len; i++) {
+    c = str[i];
 
-		lastNonSlashIndex = slashIndex + 1;
-		slashIndex = relativePath.indexOf("/", lastNonSlashIndex);
-	}
-};
-exports.checkExportsFieldTarget = checkExportsFieldTarget;
+    switch (c) {
+    case "/":
+    case "$":
+    case "^":
+    case "+":
+    case ".":
+    case "(":
+    case ")":
+    case "=":
+    case "!":
+    case "|":
+      reStr += "\\" + c;
+      break;
 
+    case "?":
+      if (extended) {
+        reStr += ".";
+	    break;
+      }
 
-/***/ }),
+    case "[":
+    case "]":
+      if (extended) {
+        reStr += c;
+	    break;
+      }
 
-/***/ 70665:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+    case "{":
+      if (extended) {
+        inGroup = true;
+	    reStr += "(";
+	    break;
+      }
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+    case "}":
+      if (extended) {
+        inGroup = false;
+	    reStr += ")";
+	    break;
+      }
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+    case ",":
+      if (inGroup) {
+        reStr += "|";
+	    break;
+      }
+      reStr += "\\" + c;
+      break;
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+    case "*":
+      // Move over all consecutive "*"'s.
+      // Also store the previous and next characters
+      var prevChar = str[i - 1];
+      var starCount = 1;
+      while(str[i + 1] === "*") {
+        starCount++;
+        i++;
+      }
+      var nextChar = str[i + 1];
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+      if (!globstar) {
+        // globstar is disabled, so treat any number of "*" as one
+        reStr += ".*";
+      } else {
+        // globstar is enabled, so determine if this is a globstar segment
+        var isGlobstar = starCount > 1                      // multiple "*"'s
+          && (prevChar === "/" || prevChar === undefined)   // from the start of the segment
+          && (nextChar === "/" || nextChar === undefined)   // to the end of the segment
 
+        if (isGlobstar) {
+          // it's a globstar, so match zero or more path segments
+          reStr += "((?:[^/]*(?:\/|$))*)";
+          i++; // move over the "/"
+        } else {
+          // it's not a globstar, so only match one path segment
+          reStr += "([^/]*)";
+        }
+      }
+      break;
 
-const Variable = __webpack_require__(82971);
+    default:
+      reStr += c;
+    }
+  }
 
-/**
- * @class Definition
- */
-class Definition {
-    constructor(type, name, node, parent, index, kind) {
+  // When regexp 'g' flag is specified don't
+  // constrain the regular expression with ^ & $
+  if (!flags || !~flags.indexOf('g')) {
+    reStr = "^" + reStr + "$";
+  }
 
-        /**
-         * @member {String} Definition#type - type of the occurrence (e.g. "Parameter", "Variable", ...).
-         */
-        this.type = type;
+  return new RegExp(reStr, flags);
+};
 
-        /**
-         * @member {espree.Identifier} Definition#name - the identifier AST node of the occurrence.
-         */
-        this.name = name;
 
-        /**
-         * @member {espree.Node} Definition#node - the enclosing node of the identifier.
-         */
-        this.node = node;
+/***/ }),
 
-        /**
-         * @member {espree.Node?} Definition#parent - the enclosing statement node of the identifier.
-         */
-        this.parent = parent;
+/***/ 89132:
+/***/ (function(module) {
 
-        /**
-         * @member {Number?} Definition#index - the index in the declaration statement.
-         */
-        this.index = index;
+"use strict";
 
-        /**
-         * @member {String?} Definition#kind - the kind of the declaration statement.
-         */
-        this.kind = kind;
-    }
-}
 
-/**
- * @class ParameterDefinition
- */
-class ParameterDefinition extends Definition {
-    constructor(name, node, index, rest) {
-        super(Variable.Parameter, name, node, null, index, null);
+module.exports = clone
 
-        /**
-         * Whether the parameter definition is a part of a rest parameter.
-         * @member {boolean} ParameterDefinition#rest
-         */
-        this.rest = rest;
-    }
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
 }
 
-module.exports = {
-    ParameterDefinition,
-    Definition
-};
+function clone (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) }
+  else
+    var copy = Object.create(null)
+
+  Object.getOwnPropertyNames(obj).forEach(function (key) {
+    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+  })
+
+  return copy
+}
 
 
 /***/ }),
 
-/***/ 36007:
+/***/ 90552:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2013 Alex Seville <hi@alexanderseville.com>
-  Copyright (C) 2014 Thiago de Arruda <tpadilha84@gmail.com>
+var fs = __webpack_require__(57147)
+var polyfills = __webpack_require__(11290)
+var legacy = __webpack_require__(54410)
+var clone = __webpack_require__(89132)
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+var util = __webpack_require__(73837)
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue
+var previousSymbol
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+  gracefulQueue = Symbol.for('graceful-fs.queue')
+  // This is used in testing by future versions
+  previousSymbol = Symbol.for('graceful-fs.previous')
+} else {
+  gracefulQueue = '___graceful-fs.queue'
+  previousSymbol = '___graceful-fs.previous'
+}
 
-/**
- * Escope (<a href="http://github.com/estools/escope">escope</a>) is an <a
- * href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript</a>
- * scope analyzer extracted from the <a
- * href="http://github.com/estools/esmangle">esmangle project</a/>.
- * <p>
- * <em>escope</em> finds lexical scopes in a source program, i.e. areas of that
- * program where different occurrences of the same identifier refer to the same
- * variable. With each scope the contained variables are collected, and each
- * identifier reference in code is linked to its corresponding variable (if
- * possible).
- * <p>
- * <em>escope</em> works on a syntax tree of the parsed source code which has
- * to adhere to the <a
- * href="https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API">
- * Mozilla Parser API</a>. E.g. <a href="https://github.com/eslint/espree">espree</a> is a parser
- * that produces such syntax trees.
- * <p>
- * The main interface is the {@link analyze} function.
- * @module escope
- */
+function noop () {}
 
+function publishQueue(context, queue) {
+  Object.defineProperty(context, gracefulQueue, {
+    get: function() {
+      return queue
+    }
+  })
+}
 
-/* eslint no-underscore-dangle: ["error", { "allow": ["__currentScope"] }] */
+var debug = noop
+if (util.debuglog)
+  debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments)
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+    console.error(m)
+  }
 
-const assert = __webpack_require__(39491);
+// Once time initialization
+if (!fs[gracefulQueue]) {
+  // This queue can be shared by multiple loaded instances
+  var queue = global[gracefulQueue] || []
+  publishQueue(fs, queue)
 
-const ScopeManager = __webpack_require__(96988);
-const Referencer = __webpack_require__(44585);
-const Reference = __webpack_require__(64945);
-const Variable = __webpack_require__(82971);
-const Scope = (__webpack_require__(16313).Scope);
-const version = (__webpack_require__(30290)/* .version */ .i8);
+  // Patch fs.close/closeSync to shared queue version, because we need
+  // to retry() whenever a close happens *anywhere* in the program.
+  // This is essential when multiple graceful-fs instances are
+  // in play at the same time.
+  fs.close = (function (fs$close) {
+    function close (fd, cb) {
+      return fs$close.call(fs, fd, function (err) {
+        // This function uses the graceful-fs shared queue
+        if (!err) {
+          resetQueue()
+        }
 
-/**
- * Set the default options
- * @returns {Object} options
- */
-function defaultOptions() {
-    return {
-        optimistic: false,
-        directive: false,
-        nodejsScope: false,
-        impliedStrict: false,
-        sourceType: "script", // one of ['script', 'module']
-        ecmaVersion: 5,
-        childVisitorKeys: null,
-        fallback: "iteration"
-    };
-}
+        if (typeof cb === 'function')
+          cb.apply(this, arguments)
+      })
+    }
 
-/**
- * Preform deep update on option object
- * @param {Object} target - Options
- * @param {Object} override - Updates
- * @returns {Object} Updated options
- */
-function updateDeeply(target, override) {
+    Object.defineProperty(close, previousSymbol, {
+      value: fs$close
+    })
+    return close
+  })(fs.close)
 
-    /**
-     * Is hash object
-     * @param {Object} value - Test value
-     * @returns {boolean} Result
-     */
-    function isHashObject(value) {
-        return typeof value === "object" && value instanceof Object && !(value instanceof Array) && !(value instanceof RegExp);
+  fs.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
+      // This function uses the graceful-fs shared queue
+      fs$closeSync.apply(fs, arguments)
+      resetQueue()
     }
 
-    for (const key in override) {
-        if (Object.prototype.hasOwnProperty.call(override, key)) {
-            const val = override[key];
+    Object.defineProperty(closeSync, previousSymbol, {
+      value: fs$closeSync
+    })
+    return closeSync
+  })(fs.closeSync)
 
-            if (isHashObject(val)) {
-                if (isHashObject(target[key])) {
-                    updateDeeply(target[key], val);
-                } else {
-                    target[key] = updateDeeply({}, val);
-                }
-            } else {
-                target[key] = val;
-            }
-        }
-    }
-    return target;
+  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+    process.on('exit', function() {
+      debug(fs[gracefulQueue])
+      __webpack_require__(39491).equal(fs[gracefulQueue].length, 0)
+    })
+  }
 }
 
-/**
- * Main interface function. Takes an Espree syntax tree and returns the
- * analyzed scopes.
- * @function analyze
- * @param {espree.Tree} tree - Abstract Syntax Tree
- * @param {Object} providedOptions - Options that tailor the scope analysis
- * @param {boolean} [providedOptions.optimistic=false] - the optimistic flag
- * @param {boolean} [providedOptions.directive=false]- the directive flag
- * @param {boolean} [providedOptions.ignoreEval=false]- whether to check 'eval()' calls
- * @param {boolean} [providedOptions.nodejsScope=false]- whether the whole
- * script is executed under node.js environment. When enabled, escope adds
- * a function scope immediately following the global scope.
- * @param {boolean} [providedOptions.impliedStrict=false]- implied strict mode
- * (if ecmaVersion >= 5).
- * @param {string} [providedOptions.sourceType='script']- the source type of the script. one of 'script' and 'module'
- * @param {number} [providedOptions.ecmaVersion=5]- which ECMAScript version is considered
- * @param {Object} [providedOptions.childVisitorKeys=null] - Additional known visitor keys. See [esrecurse](https://github.com/estools/esrecurse)'s the `childVisitorKeys` option.
- * @param {string} [providedOptions.fallback='iteration'] - A kind of the fallback in order to encounter with unknown node. See [esrecurse](https://github.com/estools/esrecurse)'s the `fallback` option.
- * @returns {ScopeManager} ScopeManager
- */
-function analyze(tree, providedOptions) {
-    const options = updateDeeply(defaultOptions(), providedOptions);
-    const scopeManager = new ScopeManager(options);
-    const referencer = new Referencer(options, scopeManager);
+if (!global[gracefulQueue]) {
+  publishQueue(global, fs[gracefulQueue]);
+}
 
-    referencer.visit(tree);
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    module.exports = patch(fs)
+    fs.__patched = true;
+}
 
-    assert(scopeManager.__currentScope === null, "currentScope should be null.");
+function patch (fs) {
+  // Everything that references the open() function needs to be in here
+  polyfills(fs)
+  fs.gracefulify = patch
 
-    return scopeManager;
-}
+  fs.createReadStream = createReadStream
+  fs.createWriteStream = createWriteStream
+  var fs$readFile = fs.readFile
+  fs.readFile = readFile
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-module.exports = {
+    return go$readFile(path, options, cb)
 
-    /** @name module:escope.version */
-    version,
+    function go$readFile (path, options, cb, startTime) {
+      return fs$readFile(path, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-    /** @name module:escope.Reference */
-    Reference,
+  var fs$writeFile = fs.writeFile
+  fs.writeFile = writeFile
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-    /** @name module:escope.Variable */
-    Variable,
+    return go$writeFile(path, data, options, cb)
 
-    /** @name module:escope.Scope */
-    Scope,
+    function go$writeFile (path, data, options, cb, startTime) {
+      return fs$writeFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-    /** @name module:escope.ScopeManager */
-    ScopeManager,
-    analyze
-};
+  var fs$appendFile = fs.appendFile
+  if (fs$appendFile)
+    fs.appendFile = appendFile
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
+    return go$appendFile(path, data, options, cb)
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+    function go$appendFile (path, data, options, cb, startTime) {
+      return fs$appendFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
+  var fs$copyFile = fs.copyFile
+  if (fs$copyFile)
+    fs.copyFile = copyFile
+  function copyFile (src, dest, flags, cb) {
+    if (typeof flags === 'function') {
+      cb = flags
+      flags = 0
+    }
+    return go$copyFile(src, dest, flags, cb)
 
-/***/ }),
+    function go$copyFile (src, dest, flags, cb, startTime) {
+      return fs$copyFile(src, dest, flags, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
 
-/***/ 54162:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+  var fs$readdir = fs.readdir
+  fs.readdir = readdir
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+    return go$readdir(path, options, cb)
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+    function go$readdir (path, options, cb, startTime) {
+      return fs$readdir(path, options, function (err, files) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (files && files.sort)
+            files.sort()
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+          if (typeof cb === 'function')
+            cb.call(this, err, files)
+        }
+      })
+    }
+  }
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+  if (process.version.substr(0, 4) === 'v0.8') {
+    var legStreams = legacy(fs)
+    ReadStream = legStreams.ReadStream
+    WriteStream = legStreams.WriteStream
+  }
 
+  var fs$ReadStream = fs.ReadStream
+  if (fs$ReadStream) {
+    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+    ReadStream.prototype.open = ReadStream$open
+  }
 
-/* eslint-disable no-undefined */
+  var fs$WriteStream = fs.WriteStream
+  if (fs$WriteStream) {
+    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+    WriteStream.prototype.open = WriteStream$open
+  }
 
-const Syntax = (__webpack_require__(18350).Syntax);
-const esrecurse = __webpack_require__(81217);
+  Object.defineProperty(fs, 'ReadStream', {
+    get: function () {
+      return ReadStream
+    },
+    set: function (val) {
+      ReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  Object.defineProperty(fs, 'WriteStream', {
+    get: function () {
+      return WriteStream
+    },
+    set: function (val) {
+      WriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
 
-/**
- * Get last array element
- * @param {array} xs - array
- * @returns {any} Last elment
- */
-function getLast(xs) {
-    return xs[xs.length - 1] || null;
-}
+  // legacy names
+  var FileReadStream = ReadStream
+  Object.defineProperty(fs, 'FileReadStream', {
+    get: function () {
+      return FileReadStream
+    },
+    set: function (val) {
+      FileReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  var FileWriteStream = WriteStream
+  Object.defineProperty(fs, 'FileWriteStream', {
+    get: function () {
+      return FileWriteStream
+    },
+    set: function (val) {
+      FileWriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
 
-class PatternVisitor extends esrecurse.Visitor {
-    static isPattern(node) {
-        const nodeType = node.type;
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+  }
 
-        return (
-            nodeType === Syntax.Identifier ||
-            nodeType === Syntax.ObjectPattern ||
-            nodeType === Syntax.ArrayPattern ||
-            nodeType === Syntax.SpreadElement ||
-            nodeType === Syntax.RestElement ||
-            nodeType === Syntax.AssignmentPattern
-        );
-    }
+  function ReadStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        if (that.autoClose)
+          that.destroy()
 
-    constructor(options, rootPattern, callback) {
-        super(null, options);
-        this.rootPattern = rootPattern;
-        this.callback = callback;
-        this.assignments = [];
-        this.rightHandNodes = [];
-        this.restElements = [];
-    }
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+        that.read()
+      }
+    })
+  }
 
-    Identifier(pattern) {
-        const lastRestElement = getLast(this.restElements);
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+  }
 
-        this.callback(pattern, {
-            topLevel: pattern === this.rootPattern,
-            rest: lastRestElement !== null && lastRestElement !== undefined && lastRestElement.argument === pattern,
-            assignments: this.assignments
-        });
-    }
+  function WriteStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        that.destroy()
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+      }
+    })
+  }
 
-    Property(property) {
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
+  }
 
-        // Computed property's key is a right hand node.
-        if (property.computed) {
-            this.rightHandNodes.push(property.key);
-        }
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
+  }
 
-        // If it's shorthand, its key is same as its value.
-        // If it's shorthand and has its default value, its key is same as its value.left (the value is AssignmentPattern).
-        // If it's not shorthand, the name of new variable is its value's.
-        this.visit(property.value);
-    }
+  var fs$open = fs.open
+  fs.open = open
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null
 
-    ArrayPattern(pattern) {
-        for (let i = 0, iz = pattern.elements.length; i < iz; ++i) {
-            const element = pattern.elements[i];
+    return go$open(path, flags, mode, cb)
 
-            this.visit(element);
+    function go$open (path, flags, mode, cb, startTime) {
+      return fs$open(path, flags, mode, function (err, fd) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
         }
+      })
     }
+  }
 
-    AssignmentPattern(pattern) {
-        this.assignments.push(pattern);
-        this.visit(pattern.left);
-        this.rightHandNodes.push(pattern.right);
-        this.assignments.pop();
-    }
-
-    RestElement(pattern) {
-        this.restElements.push(pattern);
-        this.visit(pattern.argument);
-        this.restElements.pop();
-    }
+  return fs
+}
 
-    MemberExpression(node) {
+function enqueue (elem) {
+  debug('ENQUEUE', elem[0].name, elem[1])
+  fs[gracefulQueue].push(elem)
+  retry()
+}
 
-        // Computed property's key is a right hand node.
-        if (node.computed) {
-            this.rightHandNodes.push(node.property);
-        }
+// keep track of the timeout between retry() calls
+var retryTimer
 
-        // the object is only read, write to its property.
-        this.rightHandNodes.push(node.object);
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+  var now = Date.now()
+  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+    // entries that are only a length of 2 are from an older version, don't
+    // bother modifying those since they'll be retried anyway.
+    if (fs[gracefulQueue][i].length > 2) {
+      fs[gracefulQueue][i][3] = now // startTime
+      fs[gracefulQueue][i][4] = now // lastTime
     }
+  }
+  // call retry to make sure we're actively processing the queue
+  retry()
+}
 
-    //
-    // ForInStatement.left and AssignmentExpression.left are LeftHandSideExpression.
-    // By spec, LeftHandSideExpression is Pattern or MemberExpression.
-    //   (see also: https://github.com/estree/estree/pull/20#issuecomment-74584758)
-    // But espree 2.0 parses to ArrayExpression, ObjectExpression, etc...
-    //
+function retry () {
+  // clear the timer and remove it to help prevent unintended concurrency
+  clearTimeout(retryTimer)
+  retryTimer = undefined
 
-    SpreadElement(node) {
-        this.visit(node.argument);
-    }
+  if (fs[gracefulQueue].length === 0)
+    return
 
-    ArrayExpression(node) {
-        node.elements.forEach(this.visit, this);
-    }
+  var elem = fs[gracefulQueue].shift()
+  var fn = elem[0]
+  var args = elem[1]
+  // these items may be unset if they were added by an older graceful-fs
+  var err = elem[2]
+  var startTime = elem[3]
+  var lastTime = elem[4]
 
-    AssignmentExpression(node) {
-        this.assignments.push(node);
-        this.visit(node.left);
-        this.rightHandNodes.push(node.right);
-        this.assignments.pop();
+  // if we don't have a startTime we have no way of knowing if we've waited
+  // long enough, so go ahead and retry this item now
+  if (startTime === undefined) {
+    debug('RETRY', fn.name, args)
+    fn.apply(null, args)
+  } else if (Date.now() - startTime >= 60000) {
+    // it's been more than 60 seconds total, bail now
+    debug('TIMEOUT', fn.name, args)
+    var cb = args.pop()
+    if (typeof cb === 'function')
+      cb.call(null, err)
+  } else {
+    // the amount of time between the last attempt and right now
+    var sinceAttempt = Date.now() - lastTime
+    // the amount of time between when we first tried, and when we last tried
+    // rounded up to at least 1
+    var sinceStart = Math.max(lastTime - startTime, 1)
+    // backoff. wait longer than the total time we've been retrying, but only
+    // up to a maximum of 100ms
+    var desiredDelay = Math.min(sinceStart * 1.2, 100)
+    // it's been long enough since the last retry, do it again
+    if (sinceAttempt >= desiredDelay) {
+      debug('RETRY', fn.name, args)
+      fn.apply(null, args.concat([startTime]))
+    } else {
+      // if we can't do this job yet, push it to the end of the queue
+      // and let the next iteration check again
+      fs[gracefulQueue].push(elem)
     }
+  }
 
-    CallExpression(node) {
-
-        // arguments are right hand nodes.
-        node.arguments.forEach(a => {
-            this.rightHandNodes.push(a);
-        });
-        this.visit(node.callee);
-    }
+  // schedule our next run if one isn't already scheduled
+  if (retryTimer === undefined) {
+    retryTimer = setTimeout(retry, 0)
+  }
 }
 
-module.exports = PatternVisitor;
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+/***/ }),
 
+/***/ 54410:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/***/ }),
+var Stream = (__webpack_require__(12781).Stream)
 
-/***/ 64945:
-/***/ (function(module) {
+module.exports = legacy
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+function legacy (fs) {
+  return {
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+  }
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+  function ReadStream (path, options) {
+    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+    Stream.call(this);
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+    var self = this;
 
+    this.path = path;
+    this.fd = null;
+    this.readable = true;
+    this.paused = false;
 
-const READ = 0x1;
-const WRITE = 0x2;
-const RW = READ | WRITE;
+    this.flags = 'r';
+    this.mode = 438; /*=0666*/
+    this.bufferSize = 64 * 1024;
 
-/**
- * A Reference represents a single occurrence of an identifier in code.
- * @class Reference
- */
-class Reference {
-    constructor(ident, scope, flag, writeExpr, maybeImplicitGlobal, partial, init) {
+    options = options || {};
 
-        /**
-         * Identifier syntax node.
-         * @member {espreeIdentifier} Reference#identifier
-         */
-        this.identifier = ident;
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
 
-        /**
-         * Reference to the enclosing Scope.
-         * @member {Scope} Reference#from
-         */
-        this.from = scope;
+    if (this.encoding) this.setEncoding(this.encoding);
 
-        /**
-         * Whether the reference comes from a dynamic scope (such as 'eval',
-         * 'with', etc.), and may be trapped by dynamic scopes.
-         * @member {boolean} Reference#tainted
-         */
-        this.tainted = false;
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.end === undefined) {
+        this.end = Infinity;
+      } else if ('number' !== typeof this.end) {
+        throw TypeError('end must be a Number');
+      }
 
-        /**
-         * The variable this reference is resolved with.
-         * @member {Variable} Reference#resolved
-         */
-        this.resolved = null;
+      if (this.start > this.end) {
+        throw new Error('start must be <= end');
+      }
 
-        /**
-         * The read-write mode of the reference. (Value is one of {@link
-         * Reference.READ}, {@link Reference.RW}, {@link Reference.WRITE}).
-         * @member {number} Reference#flag
-         * @private
-         */
-        this.flag = flag;
-        if (this.isWrite()) {
+      this.pos = this.start;
+    }
 
-            /**
-             * If reference is writeable, this is the tree being written to it.
-             * @member {espreeNode} Reference#writeExpr
-             */
-            this.writeExpr = writeExpr;
+    if (this.fd !== null) {
+      process.nextTick(function() {
+        self._read();
+      });
+      return;
+    }
 
-            /**
-             * Whether the Reference might refer to a partial value of writeExpr.
-             * @member {boolean} Reference#partial
-             */
-            this.partial = partial;
+    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+      if (err) {
+        self.emit('error', err);
+        self.readable = false;
+        return;
+      }
 
-            /**
-             * Whether the Reference is to write of initialization.
-             * @member {boolean} Reference#init
-             */
-            this.init = init;
-        }
-        this.__maybeImplicitGlobal = maybeImplicitGlobal;
-    }
+      self.fd = fd;
+      self.emit('open', fd);
+      self._read();
+    })
+  }
 
-    /**
-     * Whether the reference is static.
-     * @method Reference#isStatic
-     * @returns {boolean} static
-     */
-    isStatic() {
-        return !this.tainted && this.resolved && this.resolved.scope.isStatic();
-    }
+  function WriteStream (path, options) {
+    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
 
-    /**
-     * Whether the reference is writeable.
-     * @method Reference#isWrite
-     * @returns {boolean} write
-     */
-    isWrite() {
-        return !!(this.flag & Reference.WRITE);
-    }
+    Stream.call(this);
 
-    /**
-     * Whether the reference is readable.
-     * @method Reference#isRead
-     * @returns {boolean} read
-     */
-    isRead() {
-        return !!(this.flag & Reference.READ);
-    }
+    this.path = path;
+    this.fd = null;
+    this.writable = true;
 
-    /**
-     * Whether the reference is read-only.
-     * @method Reference#isReadOnly
-     * @returns {boolean} read only
-     */
-    isReadOnly() {
-        return this.flag === Reference.READ;
-    }
+    this.flags = 'w';
+    this.encoding = 'binary';
+    this.mode = 438; /*=0666*/
+    this.bytesWritten = 0;
 
-    /**
-     * Whether the reference is write-only.
-     * @method Reference#isWriteOnly
-     * @returns {boolean} write only
-     */
-    isWriteOnly() {
-        return this.flag === Reference.WRITE;
-    }
+    options = options || {};
 
-    /**
-     * Whether the reference is read-write.
-     * @method Reference#isReadWrite
-     * @returns {boolean} read write
-     */
-    isReadWrite() {
-        return this.flag === Reference.RW;
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
     }
-}
-
-/**
- * @constant Reference.READ
- * @private
- */
-Reference.READ = READ;
 
-/**
- * @constant Reference.WRITE
- * @private
- */
-Reference.WRITE = WRITE;
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.start < 0) {
+        throw new Error('start must be >= zero');
+      }
 
-/**
- * @constant Reference.RW
- * @private
- */
-Reference.RW = RW;
+      this.pos = this.start;
+    }
 
-module.exports = Reference;
+    this.busy = false;
+    this._queue = [];
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+    if (this.fd === null) {
+      this._open = fs.open;
+      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+      this.flush();
+    }
+  }
+}
 
 
 /***/ }),
 
-/***/ 44585:
+/***/ 11290:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+var constants = __webpack_require__(22057)
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+var origCwd = process.cwd
+var cwd = null
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+try {
+  process.cwd()
+} catch (er) {}
 
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir
+  process.chdir = function (d) {
+    cwd = null
+    chdir.call(process, d)
+  }
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
+}
 
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable no-undefined */
+module.exports = patch
 
-const Syntax = (__webpack_require__(18350).Syntax);
-const esrecurse = __webpack_require__(81217);
-const Reference = __webpack_require__(64945);
-const Variable = __webpack_require__(82971);
-const PatternVisitor = __webpack_require__(54162);
-const definition = __webpack_require__(70665);
-const assert = __webpack_require__(39491);
+function patch (fs) {
+  // (re-)implement some things that are known busted or missing.
 
-const ParameterDefinition = definition.ParameterDefinition;
-const Definition = definition.Definition;
+  // lchmod, broken prior to 0.6.2
+  // back-port the fix here.
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    patchLchmod(fs)
+  }
 
-/**
- * Traverse identifier in pattern
- * @param {Object} options - options
- * @param {pattern} rootPattern - root pattern
- * @param {Refencer} referencer - referencer
- * @param {callback} callback - callback
- * @returns {void}
- */
-function traverseIdentifierInPattern(options, rootPattern, referencer, callback) {
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs)
+  }
 
-    // Call the callback at left hand identifier nodes, and Collect right hand nodes.
-    const visitor = new PatternVisitor(options, rootPattern, callback);
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
 
-    visitor.visit(rootPattern);
+  fs.chown = chownFix(fs.chown)
+  fs.fchown = chownFix(fs.fchown)
+  fs.lchown = chownFix(fs.lchown)
 
-    // Process the right hand nodes recursively.
-    if (referencer !== null && referencer !== undefined) {
-        visitor.rightHandNodes.forEach(referencer.visit, referencer);
-    }
-}
+  fs.chmod = chmodFix(fs.chmod)
+  fs.fchmod = chmodFix(fs.fchmod)
+  fs.lchmod = chmodFix(fs.lchmod)
 
-// Importing ImportDeclaration.
-// http://people.mozilla.org/~jorendorff/es6-draft.html#sec-moduledeclarationinstantiation
-// https://github.com/estree/estree/blob/master/es6.md#importdeclaration
-// FIXME: Now, we don't create module environment, because the context is
-// implementation dependent.
+  fs.chownSync = chownFixSync(fs.chownSync)
+  fs.fchownSync = chownFixSync(fs.fchownSync)
+  fs.lchownSync = chownFixSync(fs.lchownSync)
 
-class Importer extends esrecurse.Visitor {
-    constructor(declaration, referencer) {
-        super(null, referencer.options);
-        this.declaration = declaration;
-        this.referencer = referencer;
-    }
+  fs.chmodSync = chmodFixSync(fs.chmodSync)
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
 
-    visitImport(id, specifier) {
-        this.referencer.visitPattern(id, pattern => {
-            this.referencer.currentScope().__define(pattern,
-                new Definition(
-                    Variable.ImportBinding,
-                    pattern,
-                    specifier,
-                    this.declaration,
-                    null,
-                    null
-                ));
-        });
-    }
+  fs.stat = statFix(fs.stat)
+  fs.fstat = statFix(fs.fstat)
+  fs.lstat = statFix(fs.lstat)
 
-    ImportNamespaceSpecifier(node) {
-        const local = (node.local || node.id);
+  fs.statSync = statFixSync(fs.statSync)
+  fs.fstatSync = statFixSync(fs.fstatSync)
+  fs.lstatSync = statFixSync(fs.lstatSync)
 
-        if (local) {
-            this.visitImport(local, node);
-        }
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (!fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb)
     }
-
-    ImportDefaultSpecifier(node) {
-        const local = (node.local || node.id);
-
-        this.visitImport(local, node);
+    fs.lchmodSync = function () {}
+  }
+  if (!fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb)
     }
+    fs.lchownSync = function () {}
+  }
 
-    ImportSpecifier(node) {
-        const local = (node.local || node.id);
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
 
-        if (node.name) {
-            this.visitImport(node.name, node);
-        } else {
-            this.visitImport(local, node);
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = (function (fs$rename) { return function (from, to, cb) {
+      var start = Date.now()
+      var backoff = 0;
+      fs$rename(from, to, function CB (er) {
+        if (er
+            && (er.code === "EACCES" || er.code === "EPERM")
+            && Date.now() - start < 60000) {
+          setTimeout(function() {
+            fs.stat(to, function (stater, st) {
+              if (stater && stater.code === "ENOENT")
+                fs$rename(from, to, CB);
+              else
+                cb(er)
+            })
+          }, backoff)
+          if (backoff < 100)
+            backoff += 10;
+          return;
         }
-    }
-}
-
-// Referencing variables and creating bindings.
-class Referencer extends esrecurse.Visitor {
-    constructor(options, scopeManager) {
-        super(null, options);
-        this.options = options;
-        this.scopeManager = scopeManager;
-        this.parent = null;
-        this.isInnerMethodDefinition = false;
-    }
-
-    currentScope() {
-        return this.scopeManager.__currentScope;
-    }
+        if (cb) cb(er)
+      })
+    }})(fs.rename)
+  }
 
-    close(node) {
-        while (this.currentScope() && node === this.currentScope().block) {
-            this.scopeManager.__currentScope = this.currentScope().__close(this.scopeManager);
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments)
         }
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
     }
 
-    pushInnerMethodDefinition(isInnerMethodDefinition) {
-        const previous = this.isInnerMethodDefinition;
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
+    return read
+  })(fs.read)
 
-        this.isInnerMethodDefinition = isInnerMethodDefinition;
-        return previous;
+  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++
+          continue
+        }
+        throw er
+      }
     }
+  }})(fs.readSync)
 
-    popInnerMethodDefinition(isInnerMethodDefinition) {
-        this.isInnerMethodDefinition = isInnerMethodDefinition;
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err)
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2)
+          })
+        })
+      })
     }
 
-    referencingDefaultValue(pattern, assignments, maybeImplicitGlobal, init) {
-        const scope = this.currentScope();
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
 
-        assignments.forEach(assignment => {
-            scope.__referencing(
-                pattern,
-                Reference.WRITE,
-                assignment.right,
-                maybeImplicitGlobal,
-                pattern !== assignment.left,
-                init
-            );
-        });
-    }
-
-    visitPattern(node, options, callback) {
-        let visitPatternOptions = options;
-        let visitPatternCallback = callback;
-
-        if (typeof options === "function") {
-            visitPatternCallback = options;
-            visitPatternOptions = { processRightHandNodes: false };
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true
+      var ret
+      try {
+        ret = fs.fchmodSync(fd, mode)
+        threw = false
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd)
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd)
         }
-
-        traverseIdentifierInPattern(
-            this.options,
-            node,
-            visitPatternOptions.processRightHandNodes ? this : null,
-            visitPatternCallback
-        );
+      }
+      return ret
     }
+  }
 
-    visitFunction(node) {
-        let i, iz;
-
-        // FunctionDeclaration name is defined in upper scope
-        // NOTE: Not referring variableScope. It is intended.
-        // Since
-        //  in ES5, FunctionDeclaration should be in FunctionBody.
-        //  in ES6, FunctionDeclaration should be block scoped.
-
-        if (node.type === Syntax.FunctionDeclaration) {
-
-            // id is defined in upper scope
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.FunctionName,
-                    node.id,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-        }
-
-        // FunctionExpression with name creates its special scope;
-        // FunctionExpressionNameScope.
-        if (node.type === Syntax.FunctionExpression && node.id) {
-            this.scopeManager.__nestFunctionExpressionNameScope(node);
-        }
-
-        // Consider this function is in the MethodDefinition.
-        this.scopeManager.__nestFunctionScope(node, this.isInnerMethodDefinition);
-
-        const that = this;
-
-        /**
-         * Visit pattern callback
-         * @param {pattern} pattern - pattern
-         * @param {Object} info - info
-         * @returns {void}
-         */
-        function visitPatternCallback(pattern, info) {
-            that.currentScope().__define(pattern,
-                new ParameterDefinition(
-                    pattern,
-                    node,
-                    i,
-                    info.rest
-                ));
-
-            that.referencingDefaultValue(pattern, info.assignments, null, true);
-        }
-
-        // Process parameter declarations.
-        for (i = 0, iz = node.params.length; i < iz; ++i) {
-            this.visitPattern(node.params[i], { processRightHandNodes: true }, visitPatternCallback);
-        }
-
-        // if there's a rest argument, add that
-        if (node.rest) {
-            this.visitPattern({
-                type: "RestElement",
-                argument: node.rest
-            }, pattern => {
-                this.currentScope().__define(pattern,
-                    new ParameterDefinition(
-                        pattern,
-                        node,
-                        node.params.length,
-                        true
-                    ));
-            });
-        }
-
-        // In TypeScript there are a number of function-like constructs which have no body,
-        // so check it exists before traversing
-        if (node.body) {
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK")) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er)
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2)
+            })
+          })
+        })
+      }
 
-            // Skip BlockStatement to prevent creating BlockStatement scope.
-            if (node.body.type === Syntax.BlockStatement) {
-                this.visitChildren(node.body);
-            } else {
-                this.visit(node.body);
-            }
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK)
+        var ret
+        var threw = true
+        try {
+          ret = fs.futimesSync(fd, at, mt)
+          threw = false
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd)
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd)
+          }
         }
+        return ret
+      }
 
-        this.close(node);
+    } else {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+      fs.lutimesSync = function () {}
     }
+  }
 
-    visitClass(node) {
-        if (node.type === Syntax.ClassDeclaration) {
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.ClassName,
-                    node.id,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-        }
-
-        this.visit(node.superClass);
-
-        this.scopeManager.__nestClassScope(node);
-
-        if (node.id) {
-            this.currentScope().__define(node.id,
-                new Definition(
-                    Variable.ClassName,
-                    node.id,
-                    node
-                ));
-        }
-        this.visit(node.body);
-
-        this.close(node);
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
     }
+  }
 
-    visitProperty(node) {
-        let previous;
-
-        if (node.computed) {
-            this.visit(node.key);
-        }
-
-        const isMethodDefinition = node.type === Syntax.MethodDefinition;
-
-        if (isMethodDefinition) {
-            previous = this.pushInnerMethodDefinition(true);
-        }
-        this.visit(node.value);
-        if (isMethodDefinition) {
-            this.popInnerMethodDefinition(previous);
-        }
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
     }
+  }
 
-    visitForIn(node) {
-        if (node.left.type === Syntax.VariableDeclaration && node.left.kind !== "var") {
-            this.scopeManager.__nestForScope(node);
-        }
-
-        if (node.left.type === Syntax.VariableDeclaration) {
-            this.visit(node.left);
-            this.visitPattern(node.left.declarations[0].id, pattern => {
-                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, null, true, true);
-            });
-        } else {
-            this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
-                let maybeImplicitGlobal = null;
-
-                if (!this.currentScope().isStrict) {
-                    maybeImplicitGlobal = {
-                        pattern,
-                        node
-                    };
-                }
-                this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
-                this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, true, false);
-            });
-        }
-        this.visit(node.right);
-        this.visit(node.body);
 
-        this.close(node);
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
     }
+  }
 
-    visitVariableDeclaration(variableTargetScope, type, node, index) {
-
-        const decl = node.declarations[index];
-        const init = decl.init;
-
-        this.visitPattern(decl.id, { processRightHandNodes: true }, (pattern, info) => {
-            variableTargetScope.__define(
-                pattern,
-                new Definition(
-                    type,
-                    pattern,
-                    decl,
-                    node,
-                    index,
-                    node.kind
-                )
-            );
-
-            this.referencingDefaultValue(pattern, info.assignments, null, true);
-            if (init) {
-                this.currentScope().__referencing(pattern, Reference.WRITE, init, null, !info.topLevel, true);
-            }
-        });
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
     }
+  }
 
-    AssignmentExpression(node) {
-        if (PatternVisitor.isPattern(node.left)) {
-            if (node.operator === "=") {
-                this.visitPattern(node.left, { processRightHandNodes: true }, (pattern, info) => {
-                    let maybeImplicitGlobal = null;
-
-                    if (!this.currentScope().isStrict) {
-                        maybeImplicitGlobal = {
-                            pattern,
-                            node
-                        };
-                    }
-                    this.referencingDefaultValue(pattern, info.assignments, maybeImplicitGlobal, false);
-                    this.currentScope().__referencing(pattern, Reference.WRITE, node.right, maybeImplicitGlobal, !info.topLevel, false);
-                });
-            } else {
-                this.currentScope().__referencing(node.left, Reference.RW, node.right);
-            }
-        } else {
-            this.visit(node.left);
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options
+        options = null
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000
+          if (stats.gid < 0) stats.gid += 0x100000000
         }
-        this.visit(node.right);
+        if (cb) cb.apply(this, arguments)
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
     }
+  }
 
-    CatchClause(node) {
-        this.scopeManager.__nestCatchScope(node);
-
-        this.visitPattern(node.param, { processRightHandNodes: true }, (pattern, info) => {
-            this.currentScope().__define(pattern,
-                new Definition(
-                    Variable.CatchClause,
-                    node.param,
-                    node,
-                    null,
-                    null,
-                    null
-                ));
-            this.referencingDefaultValue(pattern, info.assignments, null, true);
-        });
-        this.visit(node.body);
-
-        this.close(node);
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target)
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000
+        if (stats.gid < 0) stats.gid += 0x100000000
+      }
+      return stats;
     }
+  }
 
-    Program(node) {
-        this.scopeManager.__nestGlobalScope(node);
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
 
-        if (this.scopeManager.__isNodejsScope()) {
+    if (er.code === "ENOSYS")
+      return true
 
-            // Force strictness of GlobalScope to false when using node.js scope.
-            this.currentScope().isStrict = false;
-            this.scopeManager.__nestFunctionScope(node, false);
-        }
+    var nonroot = !process.getuid || process.getuid() !== 0
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
 
-        if (this.scopeManager.__isES6() && this.scopeManager.isModule()) {
-            this.scopeManager.__nestModuleScope(node);
-        }
+    return false
+  }
+}
 
-        if (this.scopeManager.isStrictModeSupported() && this.scopeManager.isImpliedStrict()) {
-            this.currentScope().isStrict = true;
-        }
 
-        this.visitChildren(node);
-        this.close(node);
-    }
+/***/ }),
 
-    Identifier(node) {
-        this.currentScope().__referencing(node);
-    }
+/***/ 15235:
+/***/ (function(module) {
 
-    UpdateExpression(node) {
-        if (PatternVisitor.isPattern(node.argument)) {
-            this.currentScope().__referencing(node.argument, Reference.RW, null);
-        } else {
-            this.visitChildren(node);
-        }
-    }
+"use strict";
 
-    MemberExpression(node) {
-        this.visit(node.object);
-        if (node.computed) {
-            this.visit(node.property);
-        }
-    }
 
-    Property(node) {
-        this.visitProperty(node);
+module.exports = parseJson
+function parseJson (txt, reviver, context) {
+  context = context || 20
+  try {
+    return JSON.parse(txt, reviver)
+  } catch (e) {
+    if (typeof txt !== 'string') {
+      const isEmptyArray = Array.isArray(txt) && txt.length === 0
+      const errorMessage = 'Cannot parse ' +
+      (isEmptyArray ? 'an empty array' : String(txt))
+      throw new TypeError(errorMessage)
     }
-
-    MethodDefinition(node) {
-        this.visitProperty(node);
+    const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
+    const errIdx = syntaxErr
+    ? +syntaxErr[1]
+    : e.message.match(/^Unexpected end of JSON.*/i)
+    ? txt.length - 1
+    : null
+    if (errIdx != null) {
+      const start = errIdx <= context
+      ? 0
+      : errIdx - context
+      const end = errIdx + context >= txt.length
+      ? txt.length
+      : errIdx + context
+      e.message += ` while parsing near '${
+        start === 0 ? '' : '...'
+      }${txt.slice(start, end)}${
+        end === txt.length ? '' : '...'
+      }'`
+    } else {
+      e.message += ` while parsing '${txt.slice(0, context * 2)}'`
     }
+    throw e
+  }
+}
 
-    BreakStatement() {} // eslint-disable-line class-methods-use-this
 
-    ContinueStatement() {} // eslint-disable-line class-methods-use-this
+/***/ }),
 
-    LabeledStatement(node) {
-        this.visit(node.body);
-    }
+/***/ 54983:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-    ForStatement(node) {
+"use strict";
+var __webpack_unused_export__;
 
-        // Create ForStatement declaration.
-        // NOTE: In ES6, ForStatement dynamically generates
-        // per iteration environment. However, escope is
-        // a static analyzer, we only generate one scope for ForStatement.
-        if (node.init && node.init.type === Syntax.VariableDeclaration && node.init.kind !== "var") {
-            this.scopeManager.__nestForScope(node);
-        }
 
-        this.visitChildren(node);
+__webpack_unused_export__ = ({
+  value: true
+});
+exports.Z = void 0;
 
-        this.close(node);
-    }
+const {
+  stringHints,
+  numberHints
+} = __webpack_require__(79926);
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
 
-    ClassExpression(node) {
-        this.visitClass(node);
-    }
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
 
-    ClassDeclaration(node) {
-        this.visitClass(node);
-    }
+/** @typedef {import("./validate").Schema} Schema */
 
-    CallExpression(node) {
+/** @typedef {import("./validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
 
-        // Check this is direct call to eval
-        if (!this.scopeManager.__ignoreEval() && node.callee.type === Syntax.Identifier && node.callee.name === "eval") {
+/** @typedef {import("./validate").PostFormatter} PostFormatter */
 
-            // NOTE: This should be `variableScope`. Since direct eval call always creates Lexical environment and
-            // let / const should be enclosed into it. Only VariableDeclaration affects on the caller's environment.
-            this.currentScope().variableScope.__detectEval();
-        }
-        this.visitChildren(node);
-    }
+/** @typedef {import("./validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
 
-    BlockStatement(node) {
-        if (this.scopeManager.__isES6()) {
-            this.scopeManager.__nestBlockScope(node);
-        }
+/** @enum {number} */
 
-        this.visitChildren(node);
 
-        this.close(node);
-    }
+const SPECIFICITY = {
+  type: 1,
+  not: 1,
+  oneOf: 1,
+  anyOf: 1,
+  if: 1,
+  enum: 1,
+  const: 1,
+  instanceof: 1,
+  required: 2,
+  pattern: 2,
+  patternRequired: 2,
+  format: 2,
+  formatMinimum: 2,
+  formatMaximum: 2,
+  minimum: 2,
+  exclusiveMinimum: 2,
+  maximum: 2,
+  exclusiveMaximum: 2,
+  multipleOf: 2,
+  uniqueItems: 2,
+  contains: 2,
+  minLength: 2,
+  maxLength: 2,
+  minItems: 2,
+  maxItems: 2,
+  minProperties: 2,
+  maxProperties: 2,
+  dependencies: 2,
+  propertyNames: 2,
+  additionalItems: 2,
+  additionalProperties: 2,
+  absolutePath: 2
+};
+/**
+ *
+ * @param {Array<SchemaUtilErrorObject>} array
+ * @param {(item: SchemaUtilErrorObject) => number} fn
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
 
-    ThisExpression() {
-        this.currentScope().variableScope.__detectThis();
-    }
+function filterMax(array, fn) {
+  const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
+  return array.filter(item => fn(item) === evaluatedMax);
+}
+/**
+ *
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
 
-    WithStatement(node) {
-        this.visit(node.object);
 
-        // Then nest scope for WithStatement.
-        this.scopeManager.__nestWithScope(node);
+function filterChildren(children) {
+  let newChildren = children;
+  newChildren = filterMax(newChildren,
+  /**
+   *
+   * @param {SchemaUtilErrorObject} error
+   * @returns {number}
+   */
+  error => error.dataPath ? error.dataPath.length : 0);
+  newChildren = filterMax(newChildren,
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {number}
+   */
+  error => SPECIFICITY[
+  /** @type {keyof typeof SPECIFICITY} */
+  error.keyword] || 2);
+  return newChildren;
+}
+/**
+ * Find all children errors
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @param {Array<string>} schemaPaths
+ * @return {number} returns index of first child
+ */
 
-        this.visit(node.body);
 
-        this.close(node);
+function findAllChildren(children, schemaPaths) {
+  let i = children.length - 1;
+
+  const predicate =
+  /**
+   * @param {string} schemaPath
+   * @returns {boolean}
+   */
+  schemaPath => children[i].schemaPath.indexOf(schemaPath) !== 0;
+
+  while (i > -1 && !schemaPaths.every(predicate)) {
+    if (children[i].keyword === "anyOf" || children[i].keyword === "oneOf") {
+      const refs = extractRefs(children[i]);
+      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(children[i].schemaPath));
+      i = childrenStart - 1;
+    } else {
+      i -= 1;
     }
+  }
 
-    VariableDeclaration(node) {
-        const variableTargetScope = (node.kind === "var") ? this.currentScope().variableScope : this.currentScope();
+  return i + 1;
+}
+/**
+ * Extracts all refs from schema
+ * @param {SchemaUtilErrorObject} error
+ * @return {Array<string>}
+ */
 
-        for (let i = 0, iz = node.declarations.length; i < iz; ++i) {
-            const decl = node.declarations[i];
 
-            this.visitVariableDeclaration(variableTargetScope, Variable.Variable, node, i);
-            if (decl.init) {
-                this.visit(decl.init);
-            }
-        }
-    }
+function extractRefs(error) {
+  const {
+    schema
+  } = error;
 
-    // sec 13.11.8
-    SwitchStatement(node) {
-        this.visit(node.discriminant);
+  if (!Array.isArray(schema)) {
+    return [];
+  }
 
-        if (this.scopeManager.__isES6()) {
-            this.scopeManager.__nestSwitchScope(node);
-        }
+  return schema.map(({
+    $ref
+  }) => $ref).filter(s => s);
+}
+/**
+ * Groups children by their first level parent (assuming that error is root)
+ * @param {Array<SchemaUtilErrorObject>} children
+ * @return {Array<SchemaUtilErrorObject>}
+ */
 
-        for (let i = 0, iz = node.cases.length; i < iz; ++i) {
-            this.visit(node.cases[i]);
-        }
 
-        this.close(node);
-    }
+function groupChildrenByFirstChild(children) {
+  const result = [];
+  let i = children.length - 1;
 
-    FunctionDeclaration(node) {
-        this.visitFunction(node);
-    }
+  while (i > 0) {
+    const child = children[i];
 
-    FunctionExpression(node) {
-        this.visitFunction(node);
-    }
+    if (child.keyword === "anyOf" || child.keyword === "oneOf") {
+      const refs = extractRefs(child);
+      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(child.schemaPath));
 
-    ForOfStatement(node) {
-        this.visitForIn(node);
+      if (childrenStart !== i) {
+        result.push(Object.assign({}, child, {
+          children: children.slice(childrenStart, i)
+        }));
+        i = childrenStart;
+      } else {
+        result.push(child);
+      }
+    } else {
+      result.push(child);
     }
 
-    ForInStatement(node) {
-        this.visitForIn(node);
-    }
+    i -= 1;
+  }
 
-    ArrowFunctionExpression(node) {
-        this.visitFunction(node);
-    }
+  if (i === 0) {
+    result.push(children[i]);
+  }
 
-    ImportDeclaration(node) {
-        assert(this.scopeManager.__isES6() && this.scopeManager.isModule(), "ImportDeclaration should appear when the mode is ES6 and in the module context.");
+  return result.reverse();
+}
+/**
+ * @param {string} str
+ * @param {string} prefix
+ * @returns {string}
+ */
 
-        const importer = new Importer(node, this);
 
-        importer.visit(node);
-    }
+function indent(str, prefix) {
+  return str.replace(/\n(?!$)/g, `\n${prefix}`);
+}
+/**
+ * @param {Schema} schema
+ * @returns {schema is (Schema & {not: Schema})}
+ */
 
-    visitExportDeclaration(node) {
-        if (node.source) {
-            return;
-        }
-        if (node.declaration) {
-            this.visit(node.declaration);
-            return;
-        }
 
-        this.visitChildren(node);
-    }
+function hasNotInSchema(schema) {
+  return !!schema.not;
+}
+/**
+ * @param {Schema} schema
+ * @return {Schema}
+ */
 
-    // TODO: ExportDeclaration doesn't exist. for bc?
-    ExportDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
 
-    ExportAllDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
+function findFirstTypedSchema(schema) {
+  if (hasNotInSchema(schema)) {
+    return findFirstTypedSchema(schema.not);
+  }
 
-    ExportDefaultDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
+  return schema;
+}
+/**
+ * @param {Schema} schema
+ * @return {boolean}
+ */
 
-    ExportNamedDeclaration(node) {
-        this.visitExportDeclaration(node);
-    }
 
-    ExportSpecifier(node) {
+function canApplyNot(schema) {
+  const typedSchema = findFirstTypedSchema(schema);
+  return likeNumber(typedSchema) || likeInteger(typedSchema) || likeString(typedSchema) || likeNull(typedSchema) || likeBoolean(typedSchema);
+}
+/**
+ * @param {any} maybeObj
+ * @returns {boolean}
+ */
 
-        // TODO: `node.id` doesn't exist. for bc?
-        const local = (node.id || node.local);
 
-        this.visit(local);
-    }
+function isObject(maybeObj) {
+  return typeof maybeObj === "object" && maybeObj !== null;
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-    MetaProperty() { // eslint-disable-line class-methods-use-this
 
-        // do nothing.
-    }
+function likeNumber(schema) {
+  return schema.type === "number" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
 }
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-module.exports = Referencer;
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+function likeInteger(schema) {
+  return schema.type === "integer" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
 
-/***/ }),
+function likeString(schema) {
+  return schema.type === "string" || typeof schema.minLength !== "undefined" || typeof schema.maxLength !== "undefined" || typeof schema.pattern !== "undefined" || typeof schema.format !== "undefined" || typeof schema.formatMinimum !== "undefined" || typeof schema.formatMaximum !== "undefined";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-/***/ 96988:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+function likeBoolean(schema) {
+  return schema.type === "boolean";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+function likeArray(schema) {
+  return schema.type === "array" || typeof schema.minItems === "number" || typeof schema.maxItems === "number" || typeof schema.uniqueItems !== "undefined" || typeof schema.items !== "undefined" || typeof schema.additionalItems !== "undefined" || typeof schema.contains !== "undefined";
+}
+/**
+ * @param {Schema & {patternRequired?: Array<string>}} schema
+ * @returns {boolean}
+ */
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
 
+function likeObject(schema) {
+  return schema.type === "object" || typeof schema.minProperties !== "undefined" || typeof schema.maxProperties !== "undefined" || typeof schema.required !== "undefined" || typeof schema.properties !== "undefined" || typeof schema.patternProperties !== "undefined" || typeof schema.additionalProperties !== "undefined" || typeof schema.dependencies !== "undefined" || typeof schema.propertyNames !== "undefined" || typeof schema.patternRequired !== "undefined";
+}
+/**
+ * @param {Schema} schema
+ * @returns {boolean}
+ */
 
-/* eslint-disable no-underscore-dangle */
 
-const Scope = __webpack_require__(16313);
-const assert = __webpack_require__(39491);
+function likeNull(schema) {
+  return schema.type === "null";
+}
+/**
+ * @param {string} type
+ * @returns {string}
+ */
 
-const GlobalScope = Scope.GlobalScope;
-const CatchScope = Scope.CatchScope;
-const WithScope = Scope.WithScope;
-const ModuleScope = Scope.ModuleScope;
-const ClassScope = Scope.ClassScope;
-const SwitchScope = Scope.SwitchScope;
-const FunctionScope = Scope.FunctionScope;
-const ForScope = Scope.ForScope;
-const FunctionExpressionNameScope = Scope.FunctionExpressionNameScope;
-const BlockScope = Scope.BlockScope;
 
+function getArticle(type) {
+  if (/^[aeiou]/i.test(type)) {
+    return "an";
+  }
+
+  return "a";
+}
 /**
- * @class ScopeManager
+ * @param {Schema=} schema
+ * @returns {string}
  */
-class ScopeManager {
-    constructor(options) {
-        this.scopes = [];
-        this.globalScope = null;
-        this.__nodeToScope = new WeakMap();
-        this.__currentScope = null;
-        this.__options = options;
-        this.__declaredVariables = new WeakMap();
-    }
 
-    __useDirective() {
-        return this.__options.directive;
-    }
 
-    __isOptimistic() {
-        return this.__options.optimistic;
-    }
+function getSchemaNonTypes(schema) {
+  if (!schema) {
+    return "";
+  }
 
-    __ignoreEval() {
-        return this.__options.ignoreEval;
+  if (!schema.type) {
+    if (likeNumber(schema) || likeInteger(schema)) {
+      return " | should be any non-number";
     }
 
-    __isNodejsScope() {
-        return this.__options.nodejsScope;
+    if (likeString(schema)) {
+      return " | should be any non-string";
     }
 
-    isModule() {
-        return this.__options.sourceType === "module";
+    if (likeArray(schema)) {
+      return " | should be any non-array";
     }
 
-    isImpliedStrict() {
-        return this.__options.impliedStrict;
+    if (likeObject(schema)) {
+      return " | should be any non-object";
     }
+  }
 
-    isStrictModeSupported() {
-        return this.__options.ecmaVersion >= 5;
-    }
+  return "";
+}
+/**
+ * @param {Array<string>} hints
+ * @returns {string}
+ */
 
-    // Returns appropriate scope for this node.
-    __get(node) {
-        return this.__nodeToScope.get(node);
-    }
 
-    /**
-     * Get variables that are declared by the node.
-     *
-     * "are declared by the node" means the node is same as `Variable.defs[].node` or `Variable.defs[].parent`.
-     * If the node declares nothing, this method returns an empty array.
-     * CAUTION: This API is experimental. See https://github.com/estools/escope/pull/69 for more details.
-     *
-     * @param {Espree.Node} node - a node to get.
-     * @returns {Variable[]} variables that declared by the node.
-     */
-    getDeclaredVariables(node) {
-        return this.__declaredVariables.get(node) || [];
-    }
+function formatHints(hints) {
+  return hints.length > 0 ? `(${hints.join(", ")})` : "";
+}
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @returns {string[]}
+ */
 
-    /**
-     * acquire scope from node.
-     * @method ScopeManager#acquire
-     * @param {Espree.Node} node - node for the acquired scope.
-     * @param {boolean=} inner - look up the most inner scope, default value is false.
-     * @returns {Scope?} Scope from node
-     */
-    acquire(node, inner) {
 
-        /**
-         * predicate
-         * @param {Scope} testScope - scope to test
-         * @returns {boolean} predicate
-         */
-        function predicate(testScope) {
-            if (testScope.type === "function" && testScope.functionExpressionScope) {
-                return false;
-            }
-            return true;
-        }
+function getHints(schema, logic) {
+  if (likeNumber(schema) || likeInteger(schema)) {
+    return numberHints(schema, logic);
+  } else if (likeString(schema)) {
+    return stringHints(schema, logic);
+  }
 
-        const scopes = this.__get(node);
+  return [];
+}
 
-        if (!scopes || scopes.length === 0) {
-            return null;
-        }
+class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(errors, schema, configuration = {}) {
+    super();
+    /** @type {string} */
 
-        // Heuristic selection from all scopes.
-        // If you would like to get all scopes, please use ScopeManager#acquireAll.
-        if (scopes.length === 1) {
-            return scopes[0];
-        }
+    this.name = "ValidationError";
+    /** @type {Array<SchemaUtilErrorObject>} */
 
-        if (inner) {
-            for (let i = scopes.length - 1; i >= 0; --i) {
-                const scope = scopes[i];
+    this.errors = errors;
+    /** @type {Schema} */
 
-                if (predicate(scope)) {
-                    return scope;
-                }
-            }
-        } else {
-            for (let i = 0, iz = scopes.length; i < iz; ++i) {
-                const scope = scopes[i];
+    this.schema = schema;
+    let headerNameFromSchema;
+    let baseDataPathFromSchema;
 
-                if (predicate(scope)) {
-                    return scope;
-                }
-            }
+    if (schema.title && (!configuration.name || !configuration.baseDataPath)) {
+      const splittedTitleFromSchema = schema.title.match(/^(.+) (.+)$/);
+
+      if (splittedTitleFromSchema) {
+        if (!configuration.name) {
+          [, headerNameFromSchema] = splittedTitleFromSchema;
         }
 
-        return null;
+        if (!configuration.baseDataPath) {
+          [,, baseDataPathFromSchema] = splittedTitleFromSchema;
+        }
+      }
     }
+    /** @type {string} */
 
-    /**
-     * acquire all scopes from node.
-     * @method ScopeManager#acquireAll
-     * @param {Espree.Node} node - node for the acquired scope.
-     * @returns {Scopes?} Scope array
-     */
-    acquireAll(node) {
-        return this.__get(node);
+
+    this.headerName = configuration.name || headerNameFromSchema || "Object";
+    /** @type {string} */
+
+    this.baseDataPath = configuration.baseDataPath || baseDataPathFromSchema || "configuration";
+    /** @type {PostFormatter | null} */
+
+    this.postFormatter = configuration.postFormatter || null;
+    const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialized using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
+    /** @type {string} */
+
+    this.message = `${header}${this.formatValidationErrors(errors)}`;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+
+
+  getSchemaPart(path) {
+    const newPath = path.split("/");
+    let schemaPart = this.schema;
+
+    for (let i = 1; i < newPath.length; i++) {
+      const inner = schemaPart[
+      /** @type {keyof Schema} */
+      newPath[i]];
+
+      if (!inner) {
+        break;
+      }
+
+      schemaPart = inner;
     }
 
+    return schemaPart;
+  }
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+
+
+  formatSchema(schema, logic = true, prevSchemas = []) {
+    let newLogic = logic;
+
+    const formatInnerSchema =
     /**
-     * release the node.
-     * @method ScopeManager#release
-     * @param {Espree.Node} node - releasing node.
-     * @param {boolean=} inner - look up the most inner scope, default value is false.
-     * @returns {Scope?} upper scope for the node.
+     *
+     * @param {Object} innerSchema
+     * @param {boolean=} addSelf
+     * @returns {string}
      */
-    release(node, inner) {
-        const scopes = this.__get(node);
-
-        if (scopes && scopes.length) {
-            const scope = scopes[0].upper;
+    (innerSchema, addSelf) => {
+      if (!addSelf) {
+        return this.formatSchema(innerSchema, newLogic, prevSchemas);
+      }
 
-            if (!scope) {
-                return null;
-            }
-            return this.acquire(scope.block, inner);
-        }
-        return null;
-    }
+      if (prevSchemas.includes(innerSchema)) {
+        return "(recursive)";
+      }
 
-    attach() { } // eslint-disable-line class-methods-use-this
+      return this.formatSchema(innerSchema, newLogic, prevSchemas.concat(schema));
+    };
 
-    detach() { } // eslint-disable-line class-methods-use-this
+    if (hasNotInSchema(schema) && !likeObject(schema)) {
+      if (canApplyNot(schema.not)) {
+        newLogic = !logic;
+        return formatInnerSchema(schema.not);
+      }
 
-    __nestScope(scope) {
-        if (scope instanceof GlobalScope) {
-            assert(this.__currentScope === null);
-            this.globalScope = scope;
-        }
-        this.__currentScope = scope;
-        return scope;
+      const needApplyLogicHere = !schema.not.not;
+      const prefix = logic ? "" : "non ";
+      newLogic = !logic;
+      return needApplyLogicHere ? prefix + formatInnerSchema(schema.not) : formatInnerSchema(schema.not);
     }
 
-    __nestGlobalScope(node) {
-        return this.__nestScope(new GlobalScope(this, node));
+    if (
+    /** @type {Schema & {instanceof: string | Array<string>}} */
+    schema.instanceof) {
+      const {
+        instanceof: value
+      } =
+      /** @type {Schema & {instanceof: string | Array<string>}} */
+      schema;
+      const values = !Array.isArray(value) ? [value] : value;
+      return values.map(
+      /**
+       * @param {string} item
+       * @returns {string}
+       */
+      item => item === "Function" ? "function" : item).join(" | ");
     }
 
-    __nestBlockScope(node) {
-        return this.__nestScope(new BlockScope(this, this.__currentScope, node));
+    if (schema.enum) {
+      return (
+        /** @type {Array<any>} */
+        schema.enum.map(item => JSON.stringify(item)).join(" | ")
+      );
     }
 
-    __nestFunctionScope(node, isMethodDefinition) {
-        return this.__nestScope(new FunctionScope(this, this.__currentScope, node, isMethodDefinition));
+    if (typeof schema.const !== "undefined") {
+      return JSON.stringify(schema.const);
     }
 
-    __nestForScope(node) {
-        return this.__nestScope(new ForScope(this, this.__currentScope, node));
+    if (schema.oneOf) {
+      return (
+        /** @type {Array<Schema>} */
+        schema.oneOf.map(item => formatInnerSchema(item, true)).join(" | ")
+      );
     }
 
-    __nestCatchScope(node) {
-        return this.__nestScope(new CatchScope(this, this.__currentScope, node));
+    if (schema.anyOf) {
+      return (
+        /** @type {Array<Schema>} */
+        schema.anyOf.map(item => formatInnerSchema(item, true)).join(" | ")
+      );
     }
 
-    __nestWithScope(node) {
-        return this.__nestScope(new WithScope(this, this.__currentScope, node));
+    if (schema.allOf) {
+      return (
+        /** @type {Array<Schema>} */
+        schema.allOf.map(item => formatInnerSchema(item, true)).join(" & ")
+      );
     }
 
-    __nestClassScope(node) {
-        return this.__nestScope(new ClassScope(this, this.__currentScope, node));
+    if (
+    /** @type {JSONSchema7} */
+    schema.if) {
+      const {
+        if: ifValue,
+        then: thenValue,
+        else: elseValue
+      } =
+      /** @type {JSONSchema7} */
+      schema;
+      return `${ifValue ? `if ${formatInnerSchema(ifValue)}` : ""}${thenValue ? ` then ${formatInnerSchema(thenValue)}` : ""}${elseValue ? ` else ${formatInnerSchema(elseValue)}` : ""}`;
     }
 
-    __nestSwitchScope(node) {
-        return this.__nestScope(new SwitchScope(this, this.__currentScope, node));
+    if (schema.$ref) {
+      return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
     }
 
-    __nestModuleScope(node) {
-        return this.__nestScope(new ModuleScope(this, this.__currentScope, node));
+    if (likeNumber(schema) || likeInteger(schema)) {
+      const [type, ...hints] = getHints(schema, logic);
+      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
+      return logic ? str : hints.length > 0 ? `non-${type} | ${str}` : `non-${type}`;
     }
 
-    __nestFunctionExpressionNameScope(node) {
-        return this.__nestScope(new FunctionExpressionNameScope(this, this.__currentScope, node));
+    if (likeString(schema)) {
+      const [type, ...hints] = getHints(schema, logic);
+      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
+      return logic ? str : str === "string" ? "non-string" : `non-string | ${str}`;
     }
 
-    __isES6() {
-        return this.__options.ecmaVersion >= 6;
+    if (likeBoolean(schema)) {
+      return `${logic ? "" : "non-"}boolean`;
     }
-}
 
-module.exports = ScopeManager;
+    if (likeArray(schema)) {
+      // not logic already applied in formatValidationError
+      newLogic = true;
+      const hints = [];
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+      if (typeof schema.minItems === "number") {
+        hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? "s" : ""}`);
+      }
 
+      if (typeof schema.maxItems === "number") {
+        hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? "s" : ""}`);
+      }
 
-/***/ }),
+      if (schema.uniqueItems) {
+        hints.push("should not have duplicate items");
+      }
 
-/***/ 16313:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+      const hasAdditionalItems = typeof schema.additionalItems === "undefined" || Boolean(schema.additionalItems);
+      let items = "";
 
-"use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
+      if (schema.items) {
+        if (Array.isArray(schema.items) && schema.items.length > 0) {
+          items = `${
+          /** @type {Array<Schema>} */
+          schema.items.map(item => formatInnerSchema(item)).join(", ")}`;
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+          if (hasAdditionalItems) {
+            if (schema.additionalItems && isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
+              hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
+            }
+          }
+        } else if (schema.items && Object.keys(schema.items).length > 0) {
+          // "additionalItems" is ignored
+          items = `${formatInnerSchema(schema.items)}`;
+        } else {
+          // Fallback for empty `items` value
+          items = "any";
+        }
+      } else {
+        // "additionalItems" is ignored
+        items = "any";
+      }
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+      if (schema.contains && Object.keys(schema.contains).length > 0) {
+        hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
+      }
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+      return `[${items}${hasAdditionalItems ? ", ..." : ""}]${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
+    }
+
+    if (likeObject(schema)) {
+      // not logic already applied in formatValidationError
+      newLogic = true;
+      const hints = [];
 
+      if (typeof schema.minProperties === "number") {
+        hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? "properties" : "property"}`);
+      }
 
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable no-undefined */
+      if (typeof schema.maxProperties === "number") {
+        hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties && schema.minProperties > 1 ? "properties" : "property"}`);
+      }
 
-const Syntax = (__webpack_require__(18350).Syntax);
+      if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
+        const patternProperties = Object.keys(schema.patternProperties);
+        hints.push(`additional property names should match pattern${patternProperties.length > 1 ? "s" : ""} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(" | ")}`);
+      }
 
-const Reference = __webpack_require__(64945);
-const Variable = __webpack_require__(82971);
-const Definition = (__webpack_require__(70665).Definition);
-const assert = __webpack_require__(39491);
+      const properties = schema.properties ? Object.keys(schema.properties) : [];
+      const required = schema.required ? schema.required : [];
+      const allProperties = [...new Set(
+      /** @type {Array<string>} */
+      [].concat(required).concat(properties))];
+      const objectStructure = allProperties.map(property => {
+        const isRequired = required.includes(property); // Some properties need quotes, maybe we should add check
+        // Maybe we should output type of property (`foo: string`), but it is looks very unreadable
 
-/**
- * Test if scope is struct
- * @param {Scope} scope - scope
- * @param {Block} block - block
- * @param {boolean} isMethodDefinition - is method definition
- * @param {boolean} useDirective - use directive
- * @returns {boolean} is strict scope
- */
-function isStrictScope(scope, block, isMethodDefinition, useDirective) {
-    let body;
+        return `${property}${isRequired ? "" : "?"}`;
+      }).concat(typeof schema.additionalProperties === "undefined" || Boolean(schema.additionalProperties) ? schema.additionalProperties && isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ["…"] : []).join(", ");
+      const {
+        dependencies,
+        propertyNames,
+        patternRequired
+      } =
+      /** @type {Schema & {patternRequired?: Array<string>;}} */
+      schema;
 
-    // When upper scope is exists and strict, inner scope is also strict.
-    if (scope.upper && scope.upper.isStrict) {
-        return true;
-    }
+      if (dependencies) {
+        Object.keys(dependencies).forEach(dependencyName => {
+          const dependency = dependencies[dependencyName];
 
-    if (isMethodDefinition) {
-        return true;
-    }
+          if (Array.isArray(dependency)) {
+            hints.push(`should have ${dependency.length > 1 ? "properties" : "property"} ${dependency.map(dep => `'${dep}'`).join(", ")} when property '${dependencyName}' is present`);
+          } else {
+            hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
+          }
+        });
+      }
 
-    if (scope.type === "class" || scope.type === "module") {
-        return true;
+      if (propertyNames && Object.keys(propertyNames).length > 0) {
+        hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
+      }
+
+      if (patternRequired && patternRequired.length > 0) {
+        hints.push(`should have property matching pattern ${patternRequired.map(
+        /**
+         * @param {string} item
+         * @returns {string}
+         */
+        item => JSON.stringify(item))}`);
+      }
+
+      return `object {${objectStructure ? ` ${objectStructure} ` : ""}}${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
     }
 
-    if (scope.type === "block" || scope.type === "switch") {
-        return false;
+    if (likeNull(schema)) {
+      return `${logic ? "" : "non-"}null`;
     }
 
-    if (scope.type === "function") {
-        if (block.type === Syntax.ArrowFunctionExpression && block.body.type !== Syntax.BlockStatement) {
-            return false;
-        }
+    if (Array.isArray(schema.type)) {
+      // not logic already applied in formatValidationError
+      return `${schema.type.join(" | ")}`;
+    } // Fallback for unknown keywords
+    // not logic already applied in formatValidationError
 
-        if (block.type === Syntax.Program) {
-            body = block;
-        } else {
-            body = block.body;
-        }
+    /* istanbul ignore next */
 
-        if (!body) {
-            return false;
-        }
-    } else if (scope.type === "global") {
-        body = block;
-    } else {
-        return false;
-    }
 
-    // Search 'use strict' directive.
-    if (useDirective) {
-        for (let i = 0, iz = body.body.length; i < iz; ++i) {
-            const stmt = body.body[i];
+    return JSON.stringify(schema, null, 2);
+  }
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
 
-            if (stmt.type !== Syntax.DirectiveStatement) {
-                break;
-            }
-            if (stmt.raw === "\"use strict\"" || stmt.raw === "'use strict'") {
-                return true;
-            }
-        }
-    } else {
-        for (let i = 0, iz = body.body.length; i < iz; ++i) {
-            const stmt = body.body[i];
 
-            if (stmt.type !== Syntax.ExpressionStatement) {
-                break;
-            }
-            const expr = stmt.expression;
+  getSchemaPartText(schemaPart, additionalPath, needDot = false, logic = true) {
+    if (!schemaPart) {
+      return "";
+    }
 
-            if (expr.type !== Syntax.Literal || typeof expr.value !== "string") {
-                break;
-            }
-            if (expr.raw !== null && expr.raw !== undefined) {
-                if (expr.raw === "\"use strict\"" || expr.raw === "'use strict'") {
-                    return true;
-                }
-            } else {
-                if (expr.value === "use strict") {
-                    return true;
-                }
-            }
+    if (Array.isArray(additionalPath)) {
+      for (let i = 0; i < additionalPath.length; i++) {
+        /** @type {Schema | undefined} */
+        const inner = schemaPart[
+        /** @type {keyof Schema} */
+        additionalPath[i]];
+
+        if (inner) {
+          // eslint-disable-next-line no-param-reassign
+          schemaPart = inner;
+        } else {
+          break;
         }
+      }
     }
-    return false;
-}
 
-/**
- * Register scope
- * @param {ScopeManager} scopeManager - scope manager
- * @param {Scope} scope - scope
- * @returns {void}
- */
-function registerScope(scopeManager, scope) {
-    scopeManager.scopes.push(scope);
+    while (schemaPart.$ref) {
+      // eslint-disable-next-line no-param-reassign
+      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    }
 
-    const scopes = scopeManager.__nodeToScope.get(scope.block);
+    let schemaText = `${this.formatSchema(schemaPart, logic)}${needDot ? "." : ""}`;
 
-    if (scopes) {
-        scopes.push(scope);
-    } else {
-        scopeManager.__nodeToScope.set(scope.block, [scope]);
+    if (schemaPart.description) {
+      schemaText += `\n-> ${schemaPart.description}`;
     }
-}
 
-/**
- * Should be statically
- * @param {Object} def - def
- * @returns {boolean} should be statically
- */
-function shouldBeStatically(def) {
-    return (
-        (def.type === Variable.ClassName) ||
-        (def.type === Variable.Variable && def.parent.kind !== "var")
-    );
-}
+    if (schemaPart.link) {
+      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    }
 
-/**
- * @class Scope
- */
-class Scope {
-    constructor(scopeManager, type, upperScope, block, isMethodDefinition) {
+    return schemaText;
+  }
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
 
-        /**
-         * One of 'module', 'block', 'switch', 'function', 'catch', 'with', 'function', 'class', 'global'.
-         * @member {String} Scope#type
-         */
-        this.type = type;
 
-        /**
-         * The scoped {@link Variable}s of this scope, as <code>{ Variable.name
-         * : Variable }</code>.
-         * @member {Map} Scope#set
-         */
-        this.set = new Map();
+  getSchemaPartDescription(schemaPart) {
+    if (!schemaPart) {
+      return "";
+    }
 
-        /**
-         * The tainted variables of this scope, as <code>{ Variable.name :
-         * boolean }</code>.
-         * @member {Map} Scope#taints */
-        this.taints = new Map();
+    while (schemaPart.$ref) {
+      // eslint-disable-next-line no-param-reassign
+      schemaPart = this.getSchemaPart(schemaPart.$ref);
+    }
 
-        /**
-         * Generally, through the lexical scoping of JS you can always know
-         * which variable an identifier in the source code refers to. There are
-         * a few exceptions to this rule. With 'global' and 'with' scopes you
-         * can only decide at runtime which variable a reference refers to.
-         * Moreover, if 'eval()' is used in a scope, it might introduce new
-         * bindings in this or its parent scopes.
-         * All those scopes are considered 'dynamic'.
-         * @member {boolean} Scope#dynamic
-         */
-        this.dynamic = this.type === "global" || this.type === "with";
+    let schemaText = "";
 
-        /**
-         * A reference to the scope-defining syntax node.
-         * @member {espree.Node} Scope#block
-         */
-        this.block = block;
+    if (schemaPart.description) {
+      schemaText += `\n-> ${schemaPart.description}`;
+    }
 
-        /**
-         * The {@link Reference|references} that are not resolved with this scope.
-         * @member {Reference[]} Scope#through
-         */
-        this.through = [];
+    if (schemaPart.link) {
+      schemaText += `\n-> Read more at ${schemaPart.link}`;
+    }
 
-        /**
-         * The scoped {@link Variable}s of this scope. In the case of a
-         * 'function' scope this includes the automatic argument <em>arguments</em> as
-         * its first element, as well as all further formal arguments.
-         * @member {Variable[]} Scope#variables
-         */
-        this.variables = [];
+    return schemaText;
+  }
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
 
-        /**
-         * Any variable {@link Reference|reference} found in this scope. This
-         * includes occurrences of local variables as well as variables from
-         * parent scopes (including the global scope). For local variables
-         * this also includes defining occurrences (like in a 'var' statement).
-         * In a 'function' scope this does not include the occurrences of the
-         * formal parameter in the parameter list.
-         * @member {Reference[]} Scope#references
-         */
-        this.references = [];
 
-        /**
-         * For 'global' and 'function' scopes, this is a self-reference. For
-         * other scope types this is the <em>variableScope</em> value of the
-         * parent scope.
-         * @member {Scope} Scope#variableScope
-         */
-        this.variableScope =
-            (this.type === "global" || this.type === "function" || this.type === "module") ? this : upperScope.variableScope;
+  formatValidationError(error) {
+    const {
+      keyword,
+      dataPath: errorDataPath
+    } = error;
+    const dataPath = `${this.baseDataPath}${errorDataPath}`;
 
-        /**
-         * Whether this scope is created by a FunctionExpression.
-         * @member {boolean} Scope#functionExpressionScope
-         */
-        this.functionExpressionScope = false;
+    switch (keyword) {
+      case "type":
+        {
+          const {
+            parentSchema,
+            params
+          } = error; // eslint-disable-next-line default-case
 
-        /**
-         * Whether this is a scope that contains an 'eval()' invocation.
-         * @member {boolean} Scope#directCallToEvalScope
-         */
-        this.directCallToEvalScope = false;
+          switch (
+          /** @type {import("ajv").TypeParams} */
+          params.type) {
+            case "number":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-        /**
-         * @member {boolean} Scope#thisFound
-         */
-        this.thisFound = false;
+            case "integer":
+              return `${dataPath} should be an ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-        this.__left = [];
+            case "string":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-        /**
-         * Reference to the parent {@link Scope|scope}.
-         * @member {Scope} Scope#upper
-         */
-        this.upper = upperScope;
+            case "boolean":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-        /**
-         * Whether 'use strict' is in effect in this scope.
-         * @member {boolean} Scope#isStrict
-         */
-        this.isStrict = isStrictScope(this, block, isMethodDefinition, scopeManager.__useDirective());
+            case "array":
+              return `${dataPath} should be an array:\n${this.getSchemaPartText(parentSchema)}`;
 
-        /**
-         * List of nested {@link Scope}s.
-         * @member {Scope[]} Scope#childScopes
-         */
-        this.childScopes = [];
-        if (this.upper) {
-            this.upper.childScopes.push(this);
-        }
+            case "object":
+              return `${dataPath} should be an object:\n${this.getSchemaPartText(parentSchema)}`;
 
-        this.__declaredVariables = scopeManager.__declaredVariables;
+            case "null":
+              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
 
-        registerScope(scopeManager, this);
-    }
+            default:
+              return `${dataPath} should be:\n${this.getSchemaPartText(parentSchema)}`;
+          }
+        }
 
-    __shouldStaticallyClose(scopeManager) {
-        return (!this.dynamic || scopeManager.__isOptimistic());
-    }
+      case "instanceof":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${dataPath} should be an instance of ${this.getSchemaPartText(parentSchema, false, true)}`;
+        }
 
-    __shouldStaticallyCloseForGlobal(ref) {
+      case "pattern":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            pattern
+          } =
+          /** @type {import("ajv").PatternParams} */
+          params;
+          return `${dataPath} should match pattern ${JSON.stringify(pattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-        // On global scope, let/const/class declarations should be resolved statically.
-        const name = ref.identifier.name;
+      case "format":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            format
+          } =
+          /** @type {import("ajv").FormatParams} */
+          params;
+          return `${dataPath} should match format ${JSON.stringify(format)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-        if (!this.set.has(name)) {
-            return false;
+      case "formatMinimum":
+      case "formatMaximum":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            comparison,
+            limit
+          } =
+          /** @type {import("ajv").ComparisonParams} */
+          params;
+          return `${dataPath} should be ${comparison} ${JSON.stringify(limit)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
 
-        const variable = this.set.get(name);
-        const defs = variable.defs;
+      case "minimum":
+      case "maximum":
+      case "exclusiveMinimum":
+      case "exclusiveMaximum":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          const {
+            comparison,
+            limit
+          } =
+          /** @type {import("ajv").ComparisonParams} */
+          params;
+          const [, ...hints] = getHints(
+          /** @type {Schema} */
+          parentSchema, true);
 
-        return defs.length > 0 && defs.every(shouldBeStatically);
-    }
+          if (hints.length === 0) {
+            hints.push(`should be ${comparison} ${limit}`);
+          }
 
-    __staticCloseRef(ref) {
-        if (!this.__resolve(ref)) {
-            this.__delegateToUpperScope(ref);
+          return `${dataPath} ${hints.join(" ")}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-    }
 
-    __dynamicCloseRef(ref) {
+      case "multipleOf":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            multipleOf
+          } =
+          /** @type {import("ajv").MultipleOfParams} */
+          params;
+          return `${dataPath} should be multiple of ${multipleOf}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-        // notify all names are through to global
-        let current = this;
+      case "patternRequired":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            missingPattern
+          } =
+          /** @type {import("ajv").PatternRequiredParams} */
+          params;
+          return `${dataPath} should have property matching pattern ${JSON.stringify(missingPattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+        }
 
-        do {
-            current.through.push(ref);
-            current = current.upper;
-        } while (current);
-    }
+      case "minLength":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
 
-    __globalCloseRef(ref) {
+          if (limit === 1) {
+            return `${dataPath} should be a non-empty string${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
 
-        // let/const/class declarations should be resolved statically.
-        // others should be resolved dynamically.
-        if (this.__shouldStaticallyCloseForGlobal(ref)) {
-            this.__staticCloseRef(ref);
-        } else {
-            this.__dynamicCloseRef(ref);
+          const length = limit - 1;
+          return `${dataPath} should be longer than ${length} character${length > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-    }
-
-    __close(scopeManager) {
-        let closeRef;
 
-        if (this.__shouldStaticallyClose(scopeManager)) {
-            closeRef = this.__staticCloseRef;
-        } else if (this.type !== "global") {
-            closeRef = this.__dynamicCloseRef;
-        } else {
-            closeRef = this.__globalCloseRef;
-        }
+      case "minItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
 
-        // Try Resolving all references in this scope.
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
+          if (limit === 1) {
+            return `${dataPath} should be a non-empty array${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
 
-            closeRef.call(this, ref);
+          return `${dataPath} should not have fewer than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-        this.__left = null;
-
-        return this.upper;
-    }
 
-    // To override by function scopes.
-    // References in default parameters isn't resolved to variables which are in their function body.
-    __isValidResolution(ref, variable) { // eslint-disable-line class-methods-use-this, no-unused-vars
-        return true;
-    }
+      case "minProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
 
-    __resolve(ref) {
-        const name = ref.identifier.name;
+          if (limit === 1) {
+            return `${dataPath} should be a non-empty object${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
+          }
 
-        if (!this.set.has(name)) {
-            return false;
+          return `${dataPath} should not have fewer than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-        const variable = this.set.get(name);
 
-        if (!this.__isValidResolution(ref, variable)) {
-            return false;
-        }
-        variable.references.push(ref);
-        variable.stack = variable.stack && ref.from.variableScope === this.variableScope;
-        if (ref.tainted) {
-            variable.tainted = true;
-            this.taints.set(variable.name, true);
+      case "maxLength":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          const max = limit + 1;
+          return `${dataPath} should be shorter than ${max} character${max > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-        ref.resolved = variable;
-
-        return true;
-    }
 
-    __delegateToUpperScope(ref) {
-        if (this.upper) {
-            this.upper.__left.push(ref);
+      case "maxItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-        this.through.push(ref);
-    }
 
-    __addDeclaredVariablesOfNode(variable, node) {
-        if (node === null || node === undefined) {
-            return;
+      case "maxProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          return `${dataPath} should not have more than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
 
-        let variables = this.__declaredVariables.get(node);
-
-        if (variables === null || variables === undefined) {
-            variables = [];
-            this.__declaredVariables.set(node, variables);
-        }
-        if (variables.indexOf(variable) === -1) {
-            variables.push(variable);
+      case "uniqueItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            i
+          } =
+          /** @type {import("ajv").UniqueItemsParams} */
+          params;
+          return `${dataPath} should not contain the item '${error.data[i]}' twice${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
-    }
-
-    __defineGeneric(name, set, variables, node, def) {
-        let variable;
 
-        variable = set.get(name);
-        if (!variable) {
-            variable = new Variable(name, this);
-            set.set(name, variable);
-            variables.push(variable);
+      case "additionalItems":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            limit
+          } =
+          /** @type {import("ajv").LimitParams} */
+          params;
+          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}. These items are valid:\n${this.getSchemaPartText(parentSchema)}`;
         }
 
-        if (def) {
-            variable.defs.push(def);
-            this.__addDeclaredVariablesOfNode(variable, def.node);
-            this.__addDeclaredVariablesOfNode(variable, def.parent);
-        }
-        if (node) {
-            variable.identifiers.push(node);
+      case "contains":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${dataPath} should contains at least one ${this.getSchemaPartText(parentSchema, ["contains"])} item${getSchemaNonTypes(parentSchema)}.`;
         }
-    }
 
-    __define(node, def) {
-        if (node && node.type === Syntax.Identifier) {
-            this.__defineGeneric(
-                node.name,
-                this.set,
-                this.variables,
-                node,
-                def
-            );
+      case "required":
+        {
+          const {
+            parentSchema,
+            params
+          } = error;
+          const missingProperty =
+          /** @type {import("ajv").DependenciesParams} */
+          params.missingProperty.replace(/^\./, "");
+          const hasProperty = parentSchema && Boolean(
+          /** @type {Schema} */
+          parentSchema.properties &&
+          /** @type {Schema} */
+          parentSchema.properties[missingProperty]);
+          return `${dataPath} misses the property '${missingProperty}'${getSchemaNonTypes(parentSchema)}.${hasProperty ? ` Should be:\n${this.getSchemaPartText(parentSchema, ["properties", missingProperty])}` : this.getSchemaPartDescription(parentSchema)}`;
         }
-    }
 
-    __referencing(node, assign, writeExpr, maybeImplicitGlobal, partial, init) {
+      case "additionalProperties":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            additionalProperty
+          } =
+          /** @type {import("ajv").AdditionalPropertiesParams} */
+          params;
+          return `${dataPath} has an unknown property '${additionalProperty}'${getSchemaNonTypes(parentSchema)}. These properties are valid:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-        // because Array element may be null
-        if (!node || node.type !== Syntax.Identifier) {
-            return;
+      case "dependencies":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            property,
+            deps
+          } =
+          /** @type {import("ajv").DependenciesParams} */
+          params;
+          const dependencies = deps.split(",").map(
+          /**
+           * @param {string} dep
+           * @returns {string}
+           */
+          dep => `'${dep.trim()}'`).join(", ");
+          return `${dataPath} should have properties ${dependencies} when property '${property}' is present${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
 
-        // Specially handle like `this`.
-        if (node.name === "super") {
-            return;
+      case "propertyNames":
+        {
+          const {
+            params,
+            parentSchema,
+            schema
+          } = error;
+          const {
+            propertyName
+          } =
+          /** @type {import("ajv").PropertyNamesParams} */
+          params;
+          return `${dataPath} property name '${propertyName}' is invalid${getSchemaNonTypes(parentSchema)}. Property names should be match format ${JSON.stringify(schema.format)}.${this.getSchemaPartDescription(parentSchema)}`;
         }
 
-        const ref = new Reference(node, this, assign || Reference.READ, writeExpr, maybeImplicitGlobal, !!partial, !!init);
+      case "enum":
+        {
+          const {
+            parentSchema
+          } = error;
 
-        this.references.push(ref);
-        this.__left.push(ref);
-    }
+          if (parentSchema &&
+          /** @type {Schema} */
+          parentSchema.enum &&
+          /** @type {Schema} */
+          parentSchema.enum.length === 1) {
+            return `${dataPath} should be ${this.getSchemaPartText(parentSchema, false, true)}`;
+          }
 
-    __detectEval() {
-        let current = this;
-
-        this.directCallToEvalScope = true;
-        do {
-            current.dynamic = true;
-            current = current.upper;
-        } while (current);
-    }
+          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-    __detectThis() {
-        this.thisFound = true;
-    }
+      case "const":
+        {
+          const {
+            parentSchema
+          } = error;
+          return `${dataPath} should be equal to constant ${this.getSchemaPartText(parentSchema, false, true)}`;
+        }
 
-    __isClosed() {
-        return this.__left === null;
-    }
+      case "not":
+        {
+          const postfix = likeObject(
+          /** @type {Schema} */
+          error.parentSchema) ? `\n${this.getSchemaPartText(error.parentSchema)}` : "";
+          const schemaOutput = this.getSchemaPartText(error.schema, false, false, false);
 
-    /**
-     * returns resolved {Reference}
-     * @method Scope#resolve
-     * @param {Espree.Identifier} ident - identifier to be resolved.
-     * @returns {Reference} reference
-     */
-    resolve(ident) {
-        let ref, i, iz;
+          if (canApplyNot(error.schema)) {
+            return `${dataPath} should be any ${schemaOutput}${postfix}.`;
+          }
 
-        assert(this.__isClosed(), "Scope should be closed.");
-        assert(ident.type === Syntax.Identifier, "Target should be identifier.");
-        for (i = 0, iz = this.references.length; i < iz; ++i) {
-            ref = this.references[i];
-            if (ref.identifier === ident) {
-                return ref;
-            }
+          const {
+            schema,
+            parentSchema
+          } = error;
+          return `${dataPath} should not be ${this.getSchemaPartText(schema, false, true)}${parentSchema && likeObject(parentSchema) ? `\n${this.getSchemaPartText(parentSchema)}` : ""}`;
         }
-        return null;
-    }
 
-    /**
-     * returns this scope is static
-     * @method Scope#isStatic
-     * @returns {boolean} static
-     */
-    isStatic() {
-        return !this.dynamic;
-    }
+      case "oneOf":
+      case "anyOf":
+        {
+          const {
+            parentSchema,
+            children
+          } = error;
 
-    /**
-     * returns this scope has materialized arguments
-     * @method Scope#isArgumentsMaterialized
-     * @returns {boolean} arguemnts materialized
-     */
-    isArgumentsMaterialized() { // eslint-disable-line class-methods-use-this
-        return true;
-    }
+          if (children && children.length > 0) {
+            if (error.schema.length === 1) {
+              const lastChild = children[children.length - 1];
+              const remainingChildren = children.slice(0, children.length - 1);
+              return this.formatValidationError(Object.assign({}, lastChild, {
+                children: remainingChildren,
+                parentSchema: Object.assign({}, parentSchema, lastChild.parentSchema)
+              }));
+            }
 
-    /**
-     * returns this scope has materialized `this` reference
-     * @method Scope#isThisMaterialized
-     * @returns {boolean} this materialized
-     */
-    isThisMaterialized() { // eslint-disable-line class-methods-use-this
-        return true;
-    }
+            let filteredChildren = filterChildren(children);
 
-    isUsedName(name) {
-        if (this.set.has(name)) {
-            return true;
-        }
-        for (let i = 0, iz = this.through.length; i < iz; ++i) {
-            if (this.through[i].identifier.name === name) {
-                return true;
+            if (filteredChildren.length === 1) {
+              return this.formatValidationError(filteredChildren[0]);
             }
-        }
-        return false;
-    }
-}
-
-class GlobalScope extends Scope {
-    constructor(scopeManager, block) {
-        super(scopeManager, "global", null, block, false);
-        this.implicit = {
-            set: new Map(),
-            variables: [],
 
+            filteredChildren = groupChildrenByFirstChild(filteredChildren);
+            return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}\nDetails:\n${filteredChildren.map(
             /**
-            * List of {@link Reference}s that are left to be resolved (i.e. which
-            * need to be linked to the variable they refer to).
-            * @member {Reference[]} Scope#implicit#left
-            */
-            left: []
-        };
-    }
+             * @param {SchemaUtilErrorObject} nestedError
+             * @returns {string}
+             */
+            nestedError => ` * ${indent(this.formatValidationError(nestedError), "   ")}`).join("\n")}`;
+          }
 
-    __close(scopeManager) {
-        const implicit = [];
+          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
+        }
 
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
+      case "if":
+        {
+          const {
+            params,
+            parentSchema
+          } = error;
+          const {
+            failingKeyword
+          } =
+          /** @type {import("ajv").IfParams} */
+          params;
+          return `${dataPath} should match "${failingKeyword}" schema:\n${this.getSchemaPartText(parentSchema, [failingKeyword])}`;
+        }
 
-            if (ref.__maybeImplicitGlobal && !this.set.has(ref.identifier.name)) {
-                implicit.push(ref.__maybeImplicitGlobal);
-            }
+      case "absolutePath":
+        {
+          const {
+            message,
+            parentSchema
+          } = error;
+          return `${dataPath}: ${message}${this.getSchemaPartDescription(parentSchema)}`;
         }
 
-        // create an implicit global variable from assignment expression
-        for (let i = 0, iz = implicit.length; i < iz; ++i) {
-            const info = implicit[i];
+      /* istanbul ignore next */
 
-            this.__defineImplicit(info.pattern,
-                new Definition(
-                    Variable.ImplicitGlobalVariable,
-                    info.pattern,
-                    info.node,
-                    null,
-                    null,
-                    null
-                ));
+      default:
+        {
+          const {
+            message,
+            parentSchema
+          } = error;
+          const ErrorInJSON = JSON.stringify(error, null, 2); // For `custom`, `false schema`, `$ref` keywords
+          // Fallback for unknown keywords
 
+          return `${dataPath} ${message} (${ErrorInJSON}).\n${this.getSchemaPartText(parentSchema, false)}`;
         }
+    }
+  }
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
 
-        this.implicit.left = this.__left;
 
-        return super.__close(scopeManager);
-    }
+  formatValidationErrors(errors) {
+    return errors.map(error => {
+      let formattedError = this.formatValidationError(error);
 
-    __defineImplicit(node, def) {
-        if (node && node.type === Syntax.Identifier) {
-            this.__defineGeneric(
-                node.name,
-                this.implicit.set,
-                this.implicit.variables,
-                node,
-                def
-            );
-        }
-    }
-}
+      if (this.postFormatter) {
+        formattedError = this.postFormatter(formattedError, error);
+      }
 
-class ModuleScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "module", upperScope, block, false);
-    }
-}
+      return ` - ${indent(formattedError, "   ")}`;
+    }).join("\n");
+  }
 
-class FunctionExpressionNameScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "function-expression-name", upperScope, block, false);
-        this.__define(block.id,
-            new Definition(
-                Variable.FunctionName,
-                block.id,
-                block,
-                null,
-                null,
-                null
-            ));
-        this.functionExpressionScope = true;
-    }
 }
 
-class CatchScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "catch", upperScope, block, false);
-    }
-}
+var _default = ValidationError;
+exports.Z = _default;
 
-class WithScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "with", upperScope, block, false);
-    }
+/***/ }),
 
-    __close(scopeManager) {
-        if (this.__shouldStaticallyClose(scopeManager)) {
-            return super.__close(scopeManager);
-        }
+/***/ 81184:
+/***/ (function(module) {
 
-        for (let i = 0, iz = this.__left.length; i < iz; ++i) {
-            const ref = this.__left[i];
+"use strict";
 
-            ref.tainted = true;
-            this.__delegateToUpperScope(ref);
-        }
-        this.__left = null;
 
-        return this.upper;
-    }
-}
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
 
-class BlockScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "block", upperScope, block, false);
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(side, exclusive) {
+    if (side === "left") {
+      return exclusive ? ">" : ">=";
     }
-}
 
-class SwitchScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "switch", upperScope, block, false);
+    return exclusive ? "<" : "<=";
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatRight(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatLeft(value, !logic, !exclusive);
     }
-}
 
-class FunctionScope extends Scope {
-    constructor(scopeManager, upperScope, block, isMethodDefinition) {
-        super(scopeManager, "function", upperScope, block, isMethodDefinition);
+    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
 
-        // section 9.2.13, FunctionDeclarationInstantiation.
-        // NOTE Arrow functions never have an arguments objects.
-        if (this.block.type !== Syntax.ArrowFunctionExpression) {
-            this.__defineArguments();
-        }
+
+  static formatLeft(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatRight(value, !logic, !exclusive);
     }
 
-    isArgumentsMaterialized() {
+    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
 
-        // TODO(Constellation)
-        // We can more aggressive on this condition like this.
-        //
-        // function t() {
-        //     // arguments of t is always hidden.
-        //     function arguments() {
-        //     }
-        // }
-        if (this.block.type === Syntax.ArrowFunctionExpression) {
-            return false;
-        }
 
-        if (!this.isStatic()) {
-            return true;
-        }
+  static formatRange(start, end, startExclusive, endExclusive, logic) {
+    let result = "should be";
+    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
+    result += logic ? "and" : "or";
+    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
+    return result;
+  }
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
 
-        const variable = this.set.get("arguments");
 
-        assert(variable, "Always have arguments variable.");
-        return variable.tainted || variable.references.length !== 0;
-    }
+  static getRangeValue(values, logic) {
+    let minMax = logic ? Infinity : -Infinity;
+    let j = -1;
+    const predicate = logic ?
+    /** @type {RangeValueCallback} */
+    ([value]) => value <= minMax :
+    /** @type {RangeValueCallback} */
+    ([value]) => value >= minMax;
 
-    isThisMaterialized() {
-        if (!this.isStatic()) {
-            return true;
-        }
-        return this.thisFound;
+    for (let i = 0; i < values.length; i++) {
+      if (predicate(values[i])) {
+        [minMax] = values[i];
+        j = i;
+      }
     }
 
-    __defineArguments() {
-        this.__defineGeneric(
-            "arguments",
-            this.set,
-            this.variables,
-            null,
-            null
-        );
-        this.taints.set("arguments", true);
+    if (j > -1) {
+      return values[j];
     }
 
-    // References in default parameters isn't resolved to variables which are in their function body.
-    //     const x = 1
-    //     function f(a = x) { // This `x` is resolved to the `x` in the outer scope.
-    //         const x = 2
-    //         console.log(a)
-    //     }
-    __isValidResolution(ref, variable) {
+    return [Infinity, true];
+  }
 
-        // If `options.nodejsScope` is true, `this.block` becomes a Program node.
-        if (this.block.type === "Program") {
-            return true;
-        }
+  constructor() {
+    /** @type {Array<RangeValue>} */
+    this._left = [];
+    /** @type {Array<RangeValue>} */
 
-        const bodyStart = this.block.body.range[0];
+    this._right = [];
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
 
-        // It's invalid resolution in the following case:
-        return !(
-            variable.scope === this &&
-            ref.identifier.range[0] < bodyStart && // the reference is in the parameter part.
-            variable.defs.every(d => d.name.range[0] >= bodyStart) // the variable is in the body.
-        );
-    }
-}
 
-class ForScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "for", upperScope, block, false);
+  left(value, exclusive = false) {
+    this._left.push([value, exclusive]);
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  right(value, exclusive = false) {
+    this._right.push([value, exclusive]);
+  }
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+
+
+  format(logic = true) {
+    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
+    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
+
+    if (!Number.isFinite(start) && !Number.isFinite(end)) {
+      return "";
     }
-}
 
-class ClassScope extends Scope {
-    constructor(scopeManager, upperScope, block) {
-        super(scopeManager, "class", upperScope, block, false);
+    const realStart = leftExclusive ? start + 1 : start;
+    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
+
+    if (realStart === realEnd) {
+      return `should be ${logic ? "" : "!"}= ${realStart}`;
+    } // e.g. 4 < x < ∞
+
+
+    if (Number.isFinite(start) && !Number.isFinite(end)) {
+      return Range.formatLeft(start, logic, leftExclusive);
+    } // e.g. ∞ < x < 4
+
+
+    if (!Number.isFinite(start) && Number.isFinite(end)) {
+      return Range.formatRight(end, logic, rightExclusive);
     }
-}
 
-module.exports = {
-    Scope,
-    GlobalScope,
-    ModuleScope,
-    FunctionExpressionNameScope,
-    CatchScope,
-    WithScope,
-    BlockScope,
-    SwitchScope,
-    FunctionScope,
-    ForScope,
-    ClassScope
-};
+    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
+  }
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+}
 
+module.exports = Range;
 
 /***/ }),
 
-/***/ 82971:
-/***/ (function(module) {
+/***/ 79926:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
-/*
-  Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
 
+const Range = __webpack_require__(81184);
+/** @typedef {import("../validate").Schema} Schema */
 
 /**
- * A Variable represents a locally scoped identifier. These include arguments to
- * functions.
- * @class Variable
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
  */
-class Variable {
-    constructor(name, scope) {
 
-        /**
-         * The variable name, as given in the source code.
-         * @member {String} Variable#name
-         */
-        this.name = name;
 
-        /**
-         * List of defining occurrences of this variable (like in 'var ...'
-         * statements or as parameter), as AST nodes.
-         * @member {espree.Identifier[]} Variable#identifiers
-         */
-        this.identifiers = [];
+module.exports.stringHints = function stringHints(schema, logic) {
+  const hints = [];
+  let type = "string";
+  const currentSchema = { ...schema
+  };
 
-        /**
-         * List of {@link Reference|references} of this variable (excluding parameter entries)
-         * in its defining scope and all nested scopes. For defining
-         * occurrences only see {@link Variable#defs}.
-         * @member {Reference[]} Variable#references
-         */
-        this.references = [];
+  if (!logic) {
+    const tmpLength = currentSchema.minLength;
+    const tmpFormat = currentSchema.formatMinimum;
+    const tmpExclusive = currentSchema.formatExclusiveMaximum;
+    currentSchema.minLength = currentSchema.maxLength;
+    currentSchema.maxLength = tmpLength;
+    currentSchema.formatMinimum = currentSchema.formatMaximum;
+    currentSchema.formatMaximum = tmpFormat;
+    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
+    currentSchema.formatExclusiveMinimum = !tmpExclusive;
+  }
 
-        /**
-         * List of defining occurrences of this variable (like in 'var ...'
-         * statements or as parameter), as custom objects.
-         * @member {Definition[]} Variable#defs
-         */
-        this.defs = [];
+  if (typeof currentSchema.minLength === "number") {
+    if (currentSchema.minLength === 1) {
+      type = "non-empty string";
+    } else {
+      const length = Math.max(currentSchema.minLength - 1, 0);
+      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
 
-        this.tainted = false;
+  if (typeof currentSchema.maxLength === "number") {
+    if (currentSchema.maxLength === 0) {
+      type = "empty string";
+    } else {
+      const length = currentSchema.maxLength + 1;
+      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
+    }
+  }
 
-        /**
-         * Whether this is a stack variable.
-         * @member {boolean} Variable#stack
-         */
-        this.stack = true;
+  if (currentSchema.pattern) {
+    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
+  }
 
-        /**
-         * Reference to the enclosing Scope.
-         * @member {Scope} Variable#scope
-         */
-        this.scope = scope;
-    }
-}
+  if (currentSchema.format) {
+    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
+  }
 
-Variable.CatchClause = "CatchClause";
-Variable.Parameter = "Parameter";
-Variable.FunctionName = "FunctionName";
-Variable.ClassName = "ClassName";
-Variable.Variable = "Variable";
-Variable.ImportBinding = "ImportBinding";
-Variable.ImplicitGlobalVariable = "ImplicitGlobalVariable";
+  if (currentSchema.formatMinimum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
+  }
 
-module.exports = Variable;
+  if (currentSchema.formatMaximum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
+  }
 
-/* vim: set sw=4 ts=4 et tw=80 : */
+  return [type].concat(hints);
+};
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
 
 
-/***/ }),
+module.exports.numberHints = function numberHints(schema, logic) {
+  const hints = [schema.type === "integer" ? "integer" : "number"];
+  const range = new Range();
 
-/***/ 81217:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+  if (typeof schema.minimum === "number") {
+    range.left(schema.minimum);
+  }
 
-/*
-  Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
+  if (typeof schema.exclusiveMinimum === "number") {
+    range.left(schema.exclusiveMinimum, true);
+  }
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+  if (typeof schema.maximum === "number") {
+    range.right(schema.maximum);
+  }
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+  if (typeof schema.exclusiveMaximum === "number") {
+    range.right(schema.exclusiveMaximum, true);
+  }
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  const rangeFormat = range.format(logic);
+
+  if (rangeFormat) {
+    hints.push(rangeFormat);
+  }
+
+  if (typeof schema.multipleOf === "number") {
+    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
+  }
+
+  return hints;
+};
+
+/***/ }),
+
+/***/ 74315:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
-(function () {
-    'use strict';
 
-    var estraverse = __webpack_require__(50165);
 
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
 
-    function isProperty(nodeType, key) {
-        return (nodeType === estraverse.Syntax.ObjectExpression || nodeType === estraverse.Syntax.ObjectPattern) && key === 'properties';
-    }
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const ConstDependency = __webpack_require__(76911);
+const BasicEvaluatedExpression = __webpack_require__(950);
+const {
+	toConstantDependency,
+	evaluateToString
+} = __webpack_require__(93998);
+const ChunkNameRuntimeModule = __webpack_require__(84519);
+const GetFullHashRuntimeModule = __webpack_require__(88732);
 
-    function Visitor(visitor, options) {
-        options = options || {};
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-        this.__visitor = visitor ||  this;
-        this.__childVisitorKeys = options.childVisitorKeys
-            ? Object.assign({}, estraverse.VisitorKeys, options.childVisitorKeys)
-            : estraverse.VisitorKeys;
-        if (options.fallback === 'iteration') {
-            this.__fallback = Object.keys;
-        } else if (typeof options.fallback === 'function') {
-            this.__fallback = options.fallback;
-        }
-    }
+/* eslint-disable camelcase */
+const REPLACEMENTS = {
+	__webpack_require__: {
+		expr: RuntimeGlobals.require,
+		req: [RuntimeGlobals.require],
+		type: "function",
+		assign: false
+	},
+	__webpack_public_path__: {
+		expr: RuntimeGlobals.publicPath,
+		req: [RuntimeGlobals.publicPath],
+		type: "string",
+		assign: true
+	},
+	__webpack_base_uri__: {
+		expr: RuntimeGlobals.baseURI,
+		req: [RuntimeGlobals.baseURI],
+		type: "string",
+		assign: true
+	},
+	__webpack_modules__: {
+		expr: RuntimeGlobals.moduleFactories,
+		req: [RuntimeGlobals.moduleFactories],
+		type: "object",
+		assign: false
+	},
+	__webpack_chunk_load__: {
+		expr: RuntimeGlobals.ensureChunk,
+		req: [RuntimeGlobals.ensureChunk],
+		type: "function",
+		assign: true
+	},
+	__non_webpack_require__: {
+		expr: "require",
+		req: null,
+		type: undefined, // type is not known, depends on environment
+		assign: true
+	},
+	__webpack_nonce__: {
+		expr: RuntimeGlobals.scriptNonce,
+		req: [RuntimeGlobals.scriptNonce],
+		type: "string",
+		assign: true
+	},
+	__webpack_hash__: {
+		expr: `${RuntimeGlobals.getFullHash}()`,
+		req: [RuntimeGlobals.getFullHash],
+		type: "string",
+		assign: false
+	},
+	__webpack_chunkname__: {
+		expr: RuntimeGlobals.chunkName,
+		req: [RuntimeGlobals.chunkName],
+		type: "string",
+		assign: false
+	},
+	__webpack_get_script_filename__: {
+		expr: RuntimeGlobals.getChunkScriptFilename,
+		req: [RuntimeGlobals.getChunkScriptFilename],
+		type: "function",
+		assign: true
+	},
+	__webpack_runtime_id__: {
+		expr: RuntimeGlobals.runtimeId,
+		req: [RuntimeGlobals.runtimeId],
+		assign: false
+	},
+	"require.onError": {
+		expr: RuntimeGlobals.uncaughtErrorHandler,
+		req: [RuntimeGlobals.uncaughtErrorHandler],
+		type: undefined, // type is not known, could be function or undefined
+		assign: true // is never a pattern
+	},
+	__system_context__: {
+		expr: RuntimeGlobals.systemContext,
+		req: [RuntimeGlobals.systemContext],
+		type: "object",
+		assign: false
+	},
+	__webpack_share_scopes__: {
+		expr: RuntimeGlobals.shareScopeMap,
+		req: [RuntimeGlobals.shareScopeMap],
+		type: "object",
+		assign: false
+	},
+	__webpack_init_sharing__: {
+		expr: RuntimeGlobals.initializeSharing,
+		req: [RuntimeGlobals.initializeSharing],
+		type: "function",
+		assign: true
+	}
+};
+/* eslint-enable camelcase */
 
-    /* Default method for visiting children.
-     * When you need to call default visiting operation inside custom visiting
-     * operation, you can use it with `this.visitChildren(node)`.
-     */
-    Visitor.prototype.visitChildren = function (node) {
-        var type, children, i, iz, j, jz, child;
+class APIPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"APIPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
 
-        if (node == null) {
-            return;
-        }
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.chunkName)
+					.tap("APIPlugin", chunk => {
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkNameRuntimeModule(chunk.name)
+						);
+						return true;
+					});
 
-        type = node.type || estraverse.Syntax.Property;
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.getFullHash)
+					.tap("APIPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new GetFullHashRuntimeModule());
+						return true;
+					});
 
-        children = this.__childVisitorKeys[type];
-        if (!children) {
-            if (this.__fallback) {
-                children = this.__fallback(node);
-            } else {
-                throw new Error('Unknown node type ' + type + '.');
-            }
-        }
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 */
+				const handler = parser => {
+					Object.keys(REPLACEMENTS).forEach(key => {
+						const info = REPLACEMENTS[key];
+						parser.hooks.expression
+							.for(key)
+							.tap(
+								"APIPlugin",
+								toConstantDependency(parser, info.expr, info.req)
+							);
+						if (info.assign === false) {
+							parser.hooks.assign.for(key).tap("APIPlugin", expr => {
+								const err = new WebpackError(`${key} must not be assigned`);
+								err.loc = expr.loc;
+								throw err;
+							});
+						}
+						if (info.type) {
+							parser.hooks.evaluateTypeof
+								.for(key)
+								.tap("APIPlugin", evaluateToString(info.type));
+						}
+					});
 
-        for (i = 0, iz = children.length; i < iz; ++i) {
-            child = node[children[i]];
-            if (child) {
-                if (Array.isArray(child)) {
-                    for (j = 0, jz = child.length; j < jz; ++j) {
-                        if (child[j]) {
-                            if (isNode(child[j]) || isProperty(type, children[i])) {
-                                this.visit(child[j]);
-                            }
-                        }
-                    }
-                } else if (isNode(child)) {
-                    this.visit(child);
-                }
-            }
-        }
-    };
+					parser.hooks.expression
+						.for("__webpack_layer__")
+						.tap("APIPlugin", expr => {
+							const dep = new ConstDependency(
+								JSON.stringify(parser.state.module.layer),
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateIdentifier
+						.for("__webpack_layer__")
+						.tap("APIPlugin", expr =>
+							(parser.state.module.layer === null
+								? new BasicEvaluatedExpression().setNull()
+								: new BasicEvaluatedExpression().setString(
+										parser.state.module.layer
+								  )
+							).setRange(expr.range)
+						);
+					parser.hooks.evaluateTypeof
+						.for("__webpack_layer__")
+						.tap("APIPlugin", expr =>
+							new BasicEvaluatedExpression()
+								.setString(
+									parser.state.module.layer === null ? "object" : "string"
+								)
+								.setRange(expr.range)
+						);
 
-    /* Dispatching node. */
-    Visitor.prototype.visit = function (node) {
-        var type;
+					parser.hooks.expression
+						.for("__webpack_module__.id")
+						.tap("APIPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"__webpack_module__.id";
+							const dep = new ConstDependency(
+								parser.state.module.moduleArgument + ".id",
+								expr.range,
+								[RuntimeGlobals.moduleId]
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
-        if (node == null) {
-            return;
-        }
+					parser.hooks.expression
+						.for("__webpack_module__")
+						.tap("APIPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"__webpack_module__";
+							const dep = new ConstDependency(
+								parser.state.module.moduleArgument,
+								expr.range,
+								[RuntimeGlobals.module]
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("__webpack_module__")
+						.tap("APIPlugin", evaluateToString("object"));
+				};
 
-        type = node.type || estraverse.Syntax.Property;
-        if (this.__visitor[type]) {
-            this.__visitor[type].call(this, node);
-            return;
-        }
-        this.visitChildren(node);
-    };
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("APIPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("APIPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("APIPlugin", handler);
+			}
+		);
+	}
+}
 
-    exports.version = __webpack_require__(12166).version;
-    exports.Visitor = Visitor;
-    exports.visit = function (node, visitor, options) {
-        var v = new Visitor(visitor, options);
-        v.visit(node);
-    };
-}());
-/* vim: set sw=4 ts=4 et tw=80 : */
+module.exports = APIPlugin;
 
 
 /***/ }),
 
-/***/ 50165:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 77198:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+"use strict";
 /*
-  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-/*jslint vars:false, bitwise:true*/
-/*jshint indent:4*/
-/*global exports:true*/
-(function clone(exports) {
-    'use strict';
 
-    var Syntax,
-        VisitorOption,
-        VisitorKeys,
-        BREAK,
-        SKIP,
-        REMOVE;
+const WebpackError = __webpack_require__(53799);
+const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
 
-    function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                val = obj[key];
-                if (typeof val === 'object' && val !== null) {
-                    ret[key] = deepCopy(val);
-                } else {
-                    ret[key] = val;
-                }
-            }
-        }
-        return ret;
-    }
+/**
+ * @param {string=} method method name
+ * @returns {string} message
+ */
+function createMessage(method) {
+	return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
+}
 
-    // based on LLVM libc++ upper_bound / lower_bound
-    // MIT License
+/**
+ * @constructor
+ */
+function Message() {
+	/** @type {string} */
+	this.stack = undefined;
+	Error.captureStackTrace(this);
+	/** @type {RegExpMatchArray} */
+	const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
 
-    function upperBound(array, func) {
-        var diff, len, i, current;
+	this.message = match && match[1] ? createMessage(match[1]) : createMessage();
+}
 
-        len = array.length;
-        i = 0;
+/**
+ * Error for abstract method
+ * @example
+ * class FooClass {
+ *     abstractMethod() {
+ *         throw new AbstractMethodError(); // error message: Abstract method FooClass.abstractMethod. Must be overridden.
+ *     }
+ * }
+ *
+ */
+class AbstractMethodError extends WebpackError {
+	constructor() {
+		super(new Message().message);
+		this.name = "AbstractMethodError";
+	}
+}
 
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                len = diff;
-            } else {
-                i = current + 1;
-                len -= diff + 1;
-            }
-        }
-        return i;
-    }
+module.exports = AbstractMethodError;
 
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        AssignmentPattern: 'AssignmentPattern',
-        ArrayExpression: 'ArrayExpression',
-        ArrayPattern: 'ArrayPattern',
-        ArrowFunctionExpression: 'ArrowFunctionExpression',
-        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ChainExpression: 'ChainExpression',
-        ClassBody: 'ClassBody',
-        ClassDeclaration: 'ClassDeclaration',
-        ClassExpression: 'ClassExpression',
-        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        DirectiveStatement: 'DirectiveStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExportAllDeclaration: 'ExportAllDeclaration',
-        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
-        ExportNamedDeclaration: 'ExportNamedDeclaration',
-        ExportSpecifier: 'ExportSpecifier',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        ForOfStatement: 'ForOfStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        ImportExpression: 'ImportExpression',
-        ImportDeclaration: 'ImportDeclaration',
-        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
-        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
-        ImportSpecifier: 'ImportSpecifier',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        MetaProperty: 'MetaProperty',
-        MethodDefinition: 'MethodDefinition',
-        ModuleSpecifier: 'ModuleSpecifier',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        ObjectPattern: 'ObjectPattern',
-        Program: 'Program',
-        Property: 'Property',
-        RestElement: 'RestElement',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SpreadElement: 'SpreadElement',
-        Super: 'Super',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        TaggedTemplateExpression: 'TaggedTemplateExpression',
-        TemplateElement: 'TemplateElement',
-        TemplateLiteral: 'TemplateLiteral',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement',
-        YieldExpression: 'YieldExpression'
-    };
 
-    VisitorKeys = {
-        AssignmentExpression: ['left', 'right'],
-        AssignmentPattern: ['left', 'right'],
-        ArrayExpression: ['elements'],
-        ArrayPattern: ['elements'],
-        ArrowFunctionExpression: ['params', 'body'],
-        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
-        BlockStatement: ['body'],
-        BinaryExpression: ['left', 'right'],
-        BreakStatement: ['label'],
-        CallExpression: ['callee', 'arguments'],
-        CatchClause: ['param', 'body'],
-        ChainExpression: ['expression'],
-        ClassBody: ['body'],
-        ClassDeclaration: ['id', 'superClass', 'body'],
-        ClassExpression: ['id', 'superClass', 'body'],
-        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ['test', 'consequent', 'alternate'],
-        ContinueStatement: ['label'],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ['body', 'test'],
-        EmptyStatement: [],
-        ExportAllDeclaration: ['source'],
-        ExportDefaultDeclaration: ['declaration'],
-        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
-        ExportSpecifier: ['exported', 'local'],
-        ExpressionStatement: ['expression'],
-        ForStatement: ['init', 'test', 'update', 'body'],
-        ForInStatement: ['left', 'right', 'body'],
-        ForOfStatement: ['left', 'right', 'body'],
-        FunctionDeclaration: ['id', 'params', 'body'],
-        FunctionExpression: ['id', 'params', 'body'],
-        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ['test', 'consequent', 'alternate'],
-        ImportExpression: ['source'],
-        ImportDeclaration: ['specifiers', 'source'],
-        ImportDefaultSpecifier: ['local'],
-        ImportNamespaceSpecifier: ['local'],
-        ImportSpecifier: ['imported', 'local'],
-        Literal: [],
-        LabeledStatement: ['label', 'body'],
-        LogicalExpression: ['left', 'right'],
-        MemberExpression: ['object', 'property'],
-        MetaProperty: ['meta', 'property'],
-        MethodDefinition: ['key', 'value'],
-        ModuleSpecifier: [],
-        NewExpression: ['callee', 'arguments'],
-        ObjectExpression: ['properties'],
-        ObjectPattern: ['properties'],
-        Program: ['body'],
-        Property: ['key', 'value'],
-        RestElement: [ 'argument' ],
-        ReturnStatement: ['argument'],
-        SequenceExpression: ['expressions'],
-        SpreadElement: ['argument'],
-        Super: [],
-        SwitchStatement: ['discriminant', 'cases'],
-        SwitchCase: ['test', 'consequent'],
-        TaggedTemplateExpression: ['tag', 'quasi'],
-        TemplateElement: [],
-        TemplateLiteral: ['quasis', 'expressions'],
-        ThisExpression: [],
-        ThrowStatement: ['argument'],
-        TryStatement: ['block', 'handler', 'finalizer'],
-        UnaryExpression: ['argument'],
-        UpdateExpression: ['argument'],
-        VariableDeclaration: ['declarations'],
-        VariableDeclarator: ['id', 'init'],
-        WhileStatement: ['test', 'body'],
-        WithStatement: ['object', 'body'],
-        YieldExpression: ['argument']
-    };
+/***/ }),
 
-    // unique id
-    BREAK = {};
-    SKIP = {};
-    REMOVE = {};
+/***/ 47736:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-    };
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-    }
 
-    Reference.prototype.replace = function replace(node) {
-        this.parent[this.key] = node;
-    };
 
-    Reference.prototype.remove = function remove() {
-        if (Array.isArray(this.parent)) {
-            this.parent.splice(this.key, 1);
-            return true;
-        } else {
-            this.replace(null);
-            return false;
-        }
-    };
+const DependenciesBlock = __webpack_require__(71040);
+const makeSerializable = __webpack_require__(33032);
 
-    function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-    }
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/Hash")} Hash */
 
-    function Controller() { }
+class AsyncDependenciesBlock extends DependenciesBlock {
+	/**
+	 * @param {ChunkGroupOptions & { entryOptions?: EntryOptions }} groupOptions options for the group
+	 * @param {DependencyLocation=} loc the line of code
+	 * @param {string=} request the request
+	 */
+	constructor(groupOptions, loc, request) {
+		super();
+		if (typeof groupOptions === "string") {
+			groupOptions = { name: groupOptions };
+		} else if (!groupOptions) {
+			groupOptions = { name: undefined };
+		}
+		this.groupOptions = groupOptions;
+		this.loc = loc;
+		this.request = request;
+		this._stringifiedGroupOptions = undefined;
+	}
 
-    // API:
-    // return property path array from root to current node
-    Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
+	/**
+	 * @returns {string} The name of the chunk
+	 */
+	get chunkName() {
+		return this.groupOptions.name;
+	}
 
-        function addToPath(result, path) {
-            if (Array.isArray(path)) {
-                for (j = 0, jz = path.length; j < jz; ++j) {
-                    result.push(path[j]);
-                }
-            } else {
-                result.push(path);
-            }
-        }
+	/**
+	 * @param {string} value The new chunk name
+	 * @returns {void}
+	 */
+	set chunkName(value) {
+		if (this.groupOptions.name !== value) {
+			this.groupOptions.name = value;
+			this._stringifiedGroupOptions = undefined;
+		}
+	}
 
-        // root node
-        if (!this.__current.path) {
-            return null;
-        }
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph } = context;
+		if (this._stringifiedGroupOptions === undefined) {
+			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+		}
+		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
+		hash.update(
+			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
+		);
+		super.updateHash(hash, context);
+	}
 
-        // first node is sentinel, second node is root element
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-            element = this.__leavelist[i];
-            addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-    };
+	serialize(context) {
+		const { write } = context;
+		write(this.groupOptions);
+		write(this.loc);
+		write(this.request);
+		super.serialize(context);
+	}
 
-    // API:
-    // return type of current node
-    Controller.prototype.type = function () {
-        var node = this.current();
-        return node.type || this.__current.wrap;
-    };
+	deserialize(context) {
+		const { read } = context;
+		this.groupOptions = read();
+		this.loc = read();
+		this.request = read();
+		super.deserialize(context);
+	}
+}
 
-    // API:
-    // return array of parent elements
-    Controller.prototype.parents = function parents() {
-        var i, iz, result;
+makeSerializable(AsyncDependenciesBlock, "webpack/lib/AsyncDependenciesBlock");
 
-        // first node is sentinel
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-            result.push(this.__leavelist[i].node);
-        }
+Object.defineProperty(AsyncDependenciesBlock.prototype, "module", {
+	get() {
+		throw new Error(
+			"module property was removed from AsyncDependenciesBlock (it's not needed)"
+		);
+	},
+	set() {
+		throw new Error(
+			"module property was removed from AsyncDependenciesBlock (it's not needed)"
+		);
+	}
+});
 
-        return result;
-    };
+module.exports = AsyncDependenciesBlock;
 
-    // API:
-    // return current node
-    Controller.prototype.current = function current() {
-        return this.__current.node;
-    };
 
-    Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
+/***/ }),
 
-        result = undefined;
+/***/ 30111:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        previous  = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
 
-        return result;
-    };
 
-    // API:
-    // notify control skip / break
-    Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-    };
 
-    // API:
-    // skip child nodes of current node
-    Controller.prototype.skip = function () {
-        this.notify(SKIP);
-    };
+const WebpackError = __webpack_require__(53799);
 
-    // API:
-    // break traversals
-    Controller.prototype['break'] = function () {
-        this.notify(BREAK);
-    };
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
-    // API:
-    // remove node
-    Controller.prototype.remove = function () {
-        this.notify(REMOVE);
-    };
+class AsyncDependencyToInitialChunkError extends WebpackError {
+	/**
+	 * Creates an instance of AsyncDependencyToInitialChunkError.
+	 * @param {string} chunkName Name of Chunk
+	 * @param {Module} module module tied to dependency
+	 * @param {DependencyLocation} loc location of dependency
+	 */
+	constructor(chunkName, module, loc) {
+		super(
+			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
+		);
 
-    Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = null;
-        if (visitor.fallback === 'iteration') {
-            this.__fallback = Object.keys;
-        } else if (typeof visitor.fallback === 'function') {
-            this.__fallback = visitor.fallback;
-        }
+		this.name = "AsyncDependencyToInitialChunkError";
+		this.module = module;
+		this.loc = loc;
+	}
+}
 
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
-        }
-    };
+module.exports = AsyncDependencyToInitialChunkError;
 
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
 
-    function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
-    }
-  
-    function candidateExistsInLeaveList(leavelist, candidate) {
-        for (var i = leavelist.length - 1; i >= 0; --i) {
-            if (leavelist[i].node === candidate) {
-                return true;
-            }
-        }
-        return false;
-    }
+/***/ }),
 
-    Controller.prototype.traverse = function traverse(root, visitor) {
-        var worklist,
-            leavelist,
-            element,
-            node,
-            nodeType,
-            ret,
-            key,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel;
-
-        this.__initialize(root, visitor);
+/***/ 17714:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        sentinel = {};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
 
-        // initialize
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
 
-        while (worklist.length) {
-            element = worklist.pop();
+const asyncLib = __webpack_require__(78175);
+const NormalModule = __webpack_require__(39);
+const PrefetchDependency = __webpack_require__(31618);
 
-            if (element === sentinel) {
-                element = leavelist.pop();
+/** @typedef {import("./Compiler")} Compiler */
 
-                ret = this.__execute(visitor.leave, element);
+class AutomaticPrefetchPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"AutomaticPrefetchPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					PrefetchDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		let lastModules = null;
+		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
+			lastModules = [];
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-                continue;
-            }
+			for (const m of compilation.modules) {
+				if (m instanceof NormalModule) {
+					lastModules.push({
+						context: m.context,
+						request: m.request
+					});
+				}
+			}
+		});
+		compiler.hooks.make.tapAsync(
+			"AutomaticPrefetchPlugin",
+			(compilation, callback) => {
+				if (!lastModules) return callback();
+				asyncLib.forEach(
+					lastModules,
+					(m, callback) => {
+						compilation.addModuleChain(
+							m.context || compiler.context,
+							new PrefetchDependency(`!!${m.request}`),
+							callback
+						);
+					},
+					err => {
+						lastModules = null;
+						callback(err);
+					}
+				);
+			}
+		);
+	}
+}
+module.exports = AutomaticPrefetchPlugin;
 
-            if (element.node) {
 
-                ret = this.__execute(visitor.enter, element);
+/***/ }),
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
+/***/ 21242:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-                worklist.push(sentinel);
-                leavelist.push(element);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-                if (this.__state === SKIP || ret === SKIP) {
-                    continue;
-                }
 
-                node = element.node;
-                nodeType = node.type || element.wrap;
-                candidates = this.__keys[nodeType];
-                if (!candidates) {
-                    if (this.__fallback) {
-                        candidates = this.__fallback(node);
-                    } else {
-                        throw new Error('Unknown node type ' + nodeType + '.');
-                    }
-                }
 
-                current = candidates.length;
-                while ((current -= 1) >= 0) {
-                    key = candidates[current];
-                    candidate = node[key];
-                    if (!candidate) {
-                        continue;
-                    }
+const { ConcatSource } = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const Template = __webpack_require__(1626);
+const createSchemaValidation = __webpack_require__(32540);
 
-                    if (Array.isArray(candidate)) {
-                        current2 = candidate.length;
-                        while ((current2 -= 1) >= 0) {
-                            if (!candidate[current2]) {
-                                continue;
-                            }
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
 
-                            if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
-                              continue;
-                            }
+const validate = createSchemaValidation(
+	__webpack_require__(42173),
+	() => __webpack_require__(49052),
+	{
+		name: "Banner Plugin",
+		baseDataPath: "options"
+	}
+);
 
-                            if (isProperty(nodeType, candidates[current])) {
-                                element = new Element(candidate[current2], [key, current2], 'Property', null);
-                            } else if (isNode(candidate[current2])) {
-                                element = new Element(candidate[current2], [key, current2], null, null);
-                            } else {
-                                continue;
-                            }
-                            worklist.push(element);
-                        }
-                    } else if (isNode(candidate)) {
-                        if (candidateExistsInLeaveList(leavelist, candidate)) {
-                          continue;
-                        }
+const wrapComment = str => {
+	if (!str.includes("\n")) {
+		return Template.toComment(str);
+	}
+	return `/*!\n * ${str
+		.replace(/\*\//g, "* /")
+		.split("\n")
+		.join("\n * ")
+		.replace(/\s+\n/g, "\n")
+		.trimRight()}\n */`;
+};
 
-                        worklist.push(new Element(candidate, key, null, null));
-                    }
-                }
-            }
-        }
-    };
+class BannerPlugin {
+	/**
+	 * @param {BannerPluginArgument} options options object
+	 */
+	constructor(options) {
+		if (typeof options === "string" || typeof options === "function") {
+			options = {
+				banner: options
+			};
+		}
 
-    Controller.prototype.replace = function replace(root, visitor) {
-        var worklist,
-            leavelist,
-            node,
-            nodeType,
-            target,
-            element,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel,
-            outer,
-            key;
+		validate(options);
 
-        function removeElem(element) {
-            var i,
-                key,
-                nextElem,
-                parent;
+		this.options = options;
 
-            if (element.ref.remove()) {
-                // When the reference is an element of an array.
-                key = element.ref.key;
-                parent = element.ref.parent;
+		const bannerOption = options.banner;
+		if (typeof bannerOption === "function") {
+			const getBanner = bannerOption;
+			this.banner = this.options.raw
+				? getBanner
+				: data => wrapComment(getBanner(data));
+		} else {
+			const banner = this.options.raw
+				? bannerOption
+				: wrapComment(bannerOption);
+			this.banner = () => banner;
+		}
+	}
 
-                // If removed from array, then decrease following items' keys.
-                i = worklist.length;
-                while (i--) {
-                    nextElem = worklist[i];
-                    if (nextElem.ref && nextElem.ref.parent === parent) {
-                        if  (nextElem.ref.key < key) {
-                            break;
-                        }
-                        --nextElem.ref.key;
-                    }
-                }
-            }
-        }
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const options = this.options;
+		const banner = this.banner;
+		const matchObject = ModuleFilenameHelpers.matchObject.bind(
+			undefined,
+			options
+		);
 
-        this.__initialize(root, visitor);
+		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
+			compilation.hooks.processAssets.tap(
+				{
+					name: "BannerPlugin",
+					stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+				},
+				() => {
+					for (const chunk of compilation.chunks) {
+						if (options.entryOnly && !chunk.canBeInitial()) {
+							continue;
+						}
 
-        sentinel = {};
+						for (const file of chunk.files) {
+							if (!matchObject(file)) {
+								continue;
+							}
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+							const data = {
+								chunk,
+								filename: file
+							};
 
-        // initialize
-        outer = {
-            root: root
-        };
-        element = new Element(root, null, null, new Reference(outer, 'root'));
-        worklist.push(element);
-        leavelist.push(element);
+							const comment = compilation.getPath(banner, data);
 
-        while (worklist.length) {
-            element = worklist.pop();
+							compilation.updateAsset(
+								file,
+								old => new ConcatSource(comment, "\n", old)
+							);
+						}
+					}
+				}
+			);
+		});
+	}
+}
 
-            if (element === sentinel) {
-                element = leavelist.pop();
+module.exports = BannerPlugin;
 
-                target = this.__execute(visitor.leave, element);
 
-                // node may be replaced with null,
-                // so distinguish between undefined and null in this place
-                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                    // replace
-                    element.ref.replace(target);
-                }
+/***/ }),
 
-                if (this.__state === REMOVE || target === REMOVE) {
-                    removeElem(element);
-                }
+/***/ 7592:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-                if (this.__state === BREAK || target === BREAK) {
-                    return outer.root;
-                }
-                continue;
-            }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-            target = this.__execute(visitor.enter, element);
 
-            // node may be replaced with null,
-            // so distinguish between undefined and null in this place
-            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                // replace
-                element.ref.replace(target);
-                element.node = target;
-            }
 
-            if (this.__state === REMOVE || target === REMOVE) {
-                removeElem(element);
-                element.node = null;
-            }
+const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = __webpack_require__(6967);
+const {
+	makeWebpackError,
+	makeWebpackErrorCallback
+} = __webpack_require__(11351);
 
-            if (this.__state === BREAK || target === BREAK) {
-                return outer.root;
-            }
+/** @typedef {import("./WebpackError")} WebpackError */
 
-            // node may be null
-            node = element.node;
-            if (!node) {
-                continue;
-            }
+/**
+ * @typedef {Object} Etag
+ * @property {function(): string} toString
+ */
 
-            worklist.push(sentinel);
-            leavelist.push(element);
+/**
+ * @template T
+ * @callback CallbackCache
+ * @param {(WebpackError | null)=} err
+ * @param {T=} result
+ * @returns {void}
+ */
 
-            if (this.__state === SKIP || target === SKIP) {
-                continue;
-            }
+/**
+ * @callback GotHandler
+ * @param {any} result
+ * @param {function(Error=): void} callback
+ * @returns {void}
+ */
 
-            nodeType = node.type || element.wrap;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-                if (this.__fallback) {
-                    candidates = this.__fallback(node);
-                } else {
-                    throw new Error('Unknown node type ' + nodeType + '.');
-                }
-            }
+const needCalls = (times, callback) => {
+	return err => {
+		if (--times === 0) {
+			return callback(err);
+		}
+		if (err && times > 0) {
+			times = 0;
+			return callback(err);
+		}
+	};
+};
 
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-                key = candidates[current];
-                candidate = node[key];
-                if (!candidate) {
-                    continue;
-                }
+class Cache {
+	constructor() {
+		this.hooks = {
+			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
+			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
+			/** @type {AsyncParallelHook<[string, Etag | null, any]>} */
+			store: new AsyncParallelHook(["identifier", "etag", "data"]),
+			/** @type {AsyncParallelHook<[Iterable<string>]>} */
+			storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
+			/** @type {SyncHook<[]>} */
+			beginIdle: new SyncHook([]),
+			/** @type {AsyncParallelHook<[]>} */
+			endIdle: new AsyncParallelHook([]),
+			/** @type {AsyncParallelHook<[]>} */
+			shutdown: new AsyncParallelHook([])
+		};
+	}
 
-                if (Array.isArray(candidate)) {
-                    current2 = candidate.length;
-                    while ((current2 -= 1) >= 0) {
-                        if (!candidate[current2]) {
-                            continue;
-                        }
-                        if (isProperty(nodeType, candidates[current])) {
-                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
-                        } else if (isNode(candidate[current2])) {
-                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                        } else {
-                            continue;
-                        }
-                        worklist.push(element);
-                    }
-                } else if (isNode(candidate)) {
-                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-                }
-            }
-        }
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	get(identifier, etag, callback) {
+		const gotHandlers = [];
+		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
+			if (err) {
+				callback(makeWebpackError(err, "Cache.hooks.get"));
+				return;
+			}
+			if (result === null) {
+				result = undefined;
+			}
+			if (gotHandlers.length > 1) {
+				const innerCallback = needCalls(gotHandlers.length, () =>
+					callback(null, result)
+				);
+				for (const gotHandler of gotHandlers) {
+					gotHandler(result, innerCallback);
+				}
+			} else if (gotHandlers.length === 1) {
+				gotHandlers[0](result, () => callback(null, result));
+			} else {
+				callback(null, result);
+			}
+		});
+	}
 
-        return outer.root;
-    };
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(identifier, etag, data, callback) {
+		this.hooks.store.callAsync(
+			identifier,
+			etag,
+			data,
+			makeWebpackErrorCallback(callback, "Cache.hooks.store")
+		);
+	}
 
-    function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-    }
+	/**
+	 * After this method has succeeded the cache can only be restored when build dependencies are
+	 * @param {Iterable<string>} dependencies list of all build dependencies
+	 * @param {CallbackCache<void>} callback signals when the dependencies are stored
+	 * @returns {void}
+	 */
+	storeBuildDependencies(dependencies, callback) {
+		this.hooks.storeBuildDependencies.callAsync(
+			dependencies,
+			makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies")
+		);
+	}
 
-    function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-    }
+	/**
+	 * @returns {void}
+	 */
+	beginIdle() {
+		this.hooks.beginIdle.call();
+	}
 
-    function extendCommentRange(comment, tokens) {
-        var target;
+	/**
+	 * @param {CallbackCache<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	endIdle(callback) {
+		this.hooks.endIdle.callAsync(
+			makeWebpackErrorCallback(callback, "Cache.hooks.endIdle")
+		);
+	}
 
-        target = upperBound(tokens, function search(token) {
-            return token.range[0] > comment.range[0];
-        });
+	/**
+	 * @param {CallbackCache<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	shutdown(callback) {
+		this.hooks.shutdown.callAsync(
+			makeWebpackErrorCallback(callback, "Cache.hooks.shutdown")
+		);
+	}
+}
 
-        comment.extendedRange = [comment.range[0], comment.range[1]];
+Cache.STAGE_MEMORY = -10;
+Cache.STAGE_DEFAULT = 0;
+Cache.STAGE_DISK = 10;
+Cache.STAGE_NETWORK = 20;
 
-        if (target !== tokens.length) {
-            comment.extendedRange[1] = tokens[target].range[0];
-        }
+module.exports = Cache;
 
-        target -= 1;
-        if (target >= 0) {
-            comment.extendedRange[0] = tokens[target].range[1];
-        }
 
-        return comment;
-    }
+/***/ }),
 
-    function attachComments(tree, providedComments, tokens) {
-        // At first, we should calculate extended comment ranges.
-        var comments = [], comment, len, i, cursor;
+/***/ 55392:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        if (!tree.range) {
-            throw new Error('attachComments needs range information');
-        }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-        // tokens array is empty, we attach comments to tree as 'leadingComments'
-        if (!tokens.length) {
-            if (providedComments.length) {
-                for (i = 0, len = providedComments.length; i < len; i += 1) {
-                    comment = deepCopy(providedComments[i]);
-                    comment.extendedRange = [0, tree.range[0]];
-                    comments.push(comment);
-                }
-                tree.leadingComments = comments;
-            }
-            return tree;
-        }
 
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
 
-        // This is based on John Freeman's implementation.
-        cursor = 0;
-        traverse(tree, {
-            enter: function (node) {
-                var comment;
+const { forEachBail } = __webpack_require__(9256);
+const asyncLib = __webpack_require__(78175);
+const getLazyHashedEtag = __webpack_require__(94075);
+const mergeEtags = __webpack_require__(54980);
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (comment.extendedRange[1] > node.range[0]) {
-                        break;
-                    }
+/** @typedef {import("./Cache")} Cache */
+/** @typedef {import("./Cache").Etag} Etag */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
+/** @typedef {typeof import("./util/Hash")} HashConstructor */
 
-                    if (comment.extendedRange[1] === node.range[0]) {
-                        if (!node.leadingComments) {
-                            node.leadingComments = [];
-                        }
-                        node.leadingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
+/**
+ * @template T
+ * @callback CallbackCache
+ * @param {(WebpackError | null)=} err
+ * @param {T=} result
+ * @returns {void}
+ */
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+/**
+ * @template T
+ * @callback CallbackNormalErrorCache
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ * @returns {void}
+ */
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+class MultiItemCache {
+	/**
+	 * @param {ItemCacheFacade[]} items item caches
+	 */
+	constructor(items) {
+		this._items = items;
+		if (items.length === 1) return /** @type {any} */ (items[0]);
+	}
 
-        cursor = 0;
-        traverse(tree, {
-            leave: function (node) {
-                var comment;
+	/**
+	 * @template T
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	get(callback) {
+		forEachBail(this._items, (item, callback) => item.get(callback), callback);
+	}
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (node.range[1] < comment.extendedRange[0]) {
-                        break;
-                    }
+	/**
+	 * @template T
+	 * @returns {Promise<T>} promise with the data
+	 */
+	getPromise() {
+		const next = i => {
+			return this._items[i].getPromise().then(result => {
+				if (result !== undefined) return result;
+				if (++i < this._items.length) return next(i);
+			});
+		};
+		return next(0);
+	}
 
-                    if (node.range[1] === comment.extendedRange[0]) {
-                        if (!node.trailingComments) {
-                            node.trailingComments = [];
-                        }
-                        node.trailingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
+	/**
+	 * @template T
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(data, callback) {
+		asyncLib.each(
+			this._items,
+			(item, callback) => item.store(data, callback),
+			callback
+		);
+	}
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+	/**
+	 * @template T
+	 * @param {T} data the value to store
+	 * @returns {Promise<void>} promise signals when the value is stored
+	 */
+	storePromise(data) {
+		return Promise.all(this._items.map(item => item.storePromise(data))).then(
+			() => {}
+		);
+	}
+}
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+class ItemCacheFacade {
+	/**
+	 * @param {Cache} cache the root cache
+	 * @param {string} name the child cache item name
+	 * @param {Etag | null} etag the etag
+	 */
+	constructor(cache, name, etag) {
+		this._cache = cache;
+		this._name = name;
+		this._etag = etag;
+	}
 
-        return tree;
-    }
+	/**
+	 * @template T
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	get(callback) {
+		this._cache.get(this._name, this._etag, callback);
+	}
 
-    exports.Syntax = Syntax;
-    exports.traverse = traverse;
-    exports.replace = replace;
-    exports.attachComments = attachComments;
-    exports.VisitorKeys = VisitorKeys;
-    exports.VisitorOption = VisitorOption;
-    exports.Controller = Controller;
-    exports.cloneEnvironment = function () { return clone({}); };
+	/**
+	 * @template T
+	 * @returns {Promise<T>} promise with the data
+	 */
+	getPromise() {
+		return new Promise((resolve, reject) => {
+			this._cache.get(this._name, this._etag, (err, data) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(data);
+				}
+			});
+		});
+	}
 
-    return exports;
-}(exports));
-/* vim: set sw=4 ts=4 et tw=80 : */
+	/**
+	 * @template T
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(data, callback) {
+		this._cache.store(this._name, this._etag, data, callback);
+	}
 
+	/**
+	 * @template T
+	 * @param {T} data the value to store
+	 * @returns {Promise<void>} promise signals when the value is stored
+	 */
+	storePromise(data) {
+		return new Promise((resolve, reject) => {
+			this._cache.store(this._name, this._etag, data, err => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	}
 
-/***/ }),
+	/**
+	 * @template T
+	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
+	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	provide(computer, callback) {
+		this.get((err, cacheEntry) => {
+			if (err) return callback(err);
+			if (cacheEntry !== undefined) return cacheEntry;
+			computer((err, result) => {
+				if (err) return callback(err);
+				this.store(result, err => {
+					if (err) return callback(err);
+					callback(null, result);
+				});
+			});
+		});
+	}
 
-/***/ 18350:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+	/**
+	 * @template T
+	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
+	 * @returns {Promise<T>} promise with the data
+	 */
+	async providePromise(computer) {
+		const cacheEntry = await this.getPromise();
+		if (cacheEntry !== undefined) return cacheEntry;
+		const result = await computer();
+		await this.storePromise(result);
+		return result;
+	}
+}
 
-/*
-  Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
-  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+class CacheFacade {
+	/**
+	 * @param {Cache} cache the root cache
+	 * @param {string} name the child cache name
+	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 */
+	constructor(cache, name, hashFunction) {
+		this._cache = cache;
+		this._name = name;
+		this._hashFunction = hashFunction;
+	}
 
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are met:
+	/**
+	 * @param {string} name the child cache name#
+	 * @returns {CacheFacade} child cache
+	 */
+	getChildCache(name) {
+		return new CacheFacade(
+			this._cache,
+			`${this._name}|${name}`,
+			this._hashFunction
+		);
+	}
 
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
+	/**
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @returns {ItemCacheFacade} item cache
+	 */
+	getItemCache(identifier, etag) {
+		return new ItemCacheFacade(
+			this._cache,
+			`${this._name}|${identifier}`,
+			etag
+		);
+	}
 
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-/*jslint vars:false, bitwise:true*/
-/*jshint indent:4*/
-/*global exports:true*/
-(function clone(exports) {
-    'use strict';
+	/**
+	 * @param {HashableObject} obj an hashable object
+	 * @returns {Etag} an etag that is lazy hashed
+	 */
+	getLazyHashedEtag(obj) {
+		return getLazyHashedEtag(obj, this._hashFunction);
+	}
 
-    var Syntax,
-        VisitorOption,
-        VisitorKeys,
-        BREAK,
-        SKIP,
-        REMOVE;
+	/**
+	 * @param {Etag} a an etag
+	 * @param {Etag} b another etag
+	 * @returns {Etag} an etag that represents both
+	 */
+	mergeEtags(a, b) {
+		return mergeEtags(a, b);
+	}
 
-    function deepCopy(obj) {
-        var ret = {}, key, val;
-        for (key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                val = obj[key];
-                if (typeof val === 'object' && val !== null) {
-                    ret[key] = deepCopy(val);
-                } else {
-                    ret[key] = val;
-                }
-            }
-        }
-        return ret;
-    }
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {CallbackCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	get(identifier, etag, callback) {
+		this._cache.get(`${this._name}|${identifier}`, etag, callback);
+	}
 
-    // based on LLVM libc++ upper_bound / lower_bound
-    // MIT License
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @returns {Promise<T>} promise with the data
+	 */
+	getPromise(identifier, etag) {
+		return new Promise((resolve, reject) => {
+			this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(data);
+				}
+			});
+		});
+	}
 
-    function upperBound(array, func) {
-        var diff, len, i, current;
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @param {CallbackCache<void>} callback signals when the value is stored
+	 * @returns {void}
+	 */
+	store(identifier, etag, data, callback) {
+		this._cache.store(`${this._name}|${identifier}`, etag, data, callback);
+	}
 
-        len = array.length;
-        i = 0;
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {T} data the value to store
+	 * @returns {Promise<void>} promise signals when the value is stored
+	 */
+	storePromise(identifier, etag, data) {
+		return new Promise((resolve, reject) => {
+			this._cache.store(`${this._name}|${identifier}`, etag, data, err => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve();
+				}
+			});
+		});
+	}
 
-        while (len) {
-            diff = len >>> 1;
-            current = i + diff;
-            if (func(array[current])) {
-                len = diff;
-            } else {
-                i = current + 1;
-                len -= diff + 1;
-            }
-        }
-        return i;
-    }
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
+	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
+	 * @returns {void}
+	 */
+	provide(identifier, etag, computer, callback) {
+		this.get(identifier, etag, (err, cacheEntry) => {
+			if (err) return callback(err);
+			if (cacheEntry !== undefined) return cacheEntry;
+			computer((err, result) => {
+				if (err) return callback(err);
+				this.store(identifier, etag, result, err => {
+					if (err) return callback(err);
+					callback(null, result);
+				});
+			});
+		});
+	}
 
-    Syntax = {
-        AssignmentExpression: 'AssignmentExpression',
-        AssignmentPattern: 'AssignmentPattern',
-        ArrayExpression: 'ArrayExpression',
-        ArrayPattern: 'ArrayPattern',
-        ArrowFunctionExpression: 'ArrowFunctionExpression',
-        AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
-        BlockStatement: 'BlockStatement',
-        BinaryExpression: 'BinaryExpression',
-        BreakStatement: 'BreakStatement',
-        CallExpression: 'CallExpression',
-        CatchClause: 'CatchClause',
-        ClassBody: 'ClassBody',
-        ClassDeclaration: 'ClassDeclaration',
-        ClassExpression: 'ClassExpression',
-        ComprehensionBlock: 'ComprehensionBlock',  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: 'ComprehensionExpression',  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: 'ConditionalExpression',
-        ContinueStatement: 'ContinueStatement',
-        DebuggerStatement: 'DebuggerStatement',
-        DirectiveStatement: 'DirectiveStatement',
-        DoWhileStatement: 'DoWhileStatement',
-        EmptyStatement: 'EmptyStatement',
-        ExportAllDeclaration: 'ExportAllDeclaration',
-        ExportDefaultDeclaration: 'ExportDefaultDeclaration',
-        ExportNamedDeclaration: 'ExportNamedDeclaration',
-        ExportSpecifier: 'ExportSpecifier',
-        ExpressionStatement: 'ExpressionStatement',
-        ForStatement: 'ForStatement',
-        ForInStatement: 'ForInStatement',
-        ForOfStatement: 'ForOfStatement',
-        FunctionDeclaration: 'FunctionDeclaration',
-        FunctionExpression: 'FunctionExpression',
-        GeneratorExpression: 'GeneratorExpression',  // CAUTION: It's deferred to ES7.
-        Identifier: 'Identifier',
-        IfStatement: 'IfStatement',
-        ImportExpression: 'ImportExpression',
-        ImportDeclaration: 'ImportDeclaration',
-        ImportDefaultSpecifier: 'ImportDefaultSpecifier',
-        ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
-        ImportSpecifier: 'ImportSpecifier',
-        Literal: 'Literal',
-        LabeledStatement: 'LabeledStatement',
-        LogicalExpression: 'LogicalExpression',
-        MemberExpression: 'MemberExpression',
-        MetaProperty: 'MetaProperty',
-        MethodDefinition: 'MethodDefinition',
-        ModuleSpecifier: 'ModuleSpecifier',
-        NewExpression: 'NewExpression',
-        ObjectExpression: 'ObjectExpression',
-        ObjectPattern: 'ObjectPattern',
-        Program: 'Program',
-        Property: 'Property',
-        RestElement: 'RestElement',
-        ReturnStatement: 'ReturnStatement',
-        SequenceExpression: 'SequenceExpression',
-        SpreadElement: 'SpreadElement',
-        Super: 'Super',
-        SwitchStatement: 'SwitchStatement',
-        SwitchCase: 'SwitchCase',
-        TaggedTemplateExpression: 'TaggedTemplateExpression',
-        TemplateElement: 'TemplateElement',
-        TemplateLiteral: 'TemplateLiteral',
-        ThisExpression: 'ThisExpression',
-        ThrowStatement: 'ThrowStatement',
-        TryStatement: 'TryStatement',
-        UnaryExpression: 'UnaryExpression',
-        UpdateExpression: 'UpdateExpression',
-        VariableDeclaration: 'VariableDeclaration',
-        VariableDeclarator: 'VariableDeclarator',
-        WhileStatement: 'WhileStatement',
-        WithStatement: 'WithStatement',
-        YieldExpression: 'YieldExpression'
-    };
-
-    VisitorKeys = {
-        AssignmentExpression: ['left', 'right'],
-        AssignmentPattern: ['left', 'right'],
-        ArrayExpression: ['elements'],
-        ArrayPattern: ['elements'],
-        ArrowFunctionExpression: ['params', 'body'],
-        AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
-        BlockStatement: ['body'],
-        BinaryExpression: ['left', 'right'],
-        BreakStatement: ['label'],
-        CallExpression: ['callee', 'arguments'],
-        CatchClause: ['param', 'body'],
-        ClassBody: ['body'],
-        ClassDeclaration: ['id', 'superClass', 'body'],
-        ClassExpression: ['id', 'superClass', 'body'],
-        ComprehensionBlock: ['left', 'right'],  // CAUTION: It's deferred to ES7.
-        ComprehensionExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        ConditionalExpression: ['test', 'consequent', 'alternate'],
-        ContinueStatement: ['label'],
-        DebuggerStatement: [],
-        DirectiveStatement: [],
-        DoWhileStatement: ['body', 'test'],
-        EmptyStatement: [],
-        ExportAllDeclaration: ['source'],
-        ExportDefaultDeclaration: ['declaration'],
-        ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
-        ExportSpecifier: ['exported', 'local'],
-        ExpressionStatement: ['expression'],
-        ForStatement: ['init', 'test', 'update', 'body'],
-        ForInStatement: ['left', 'right', 'body'],
-        ForOfStatement: ['left', 'right', 'body'],
-        FunctionDeclaration: ['id', 'params', 'body'],
-        FunctionExpression: ['id', 'params', 'body'],
-        GeneratorExpression: ['blocks', 'filter', 'body'],  // CAUTION: It's deferred to ES7.
-        Identifier: [],
-        IfStatement: ['test', 'consequent', 'alternate'],
-        ImportExpression: ['source'],
-        ImportDeclaration: ['specifiers', 'source'],
-        ImportDefaultSpecifier: ['local'],
-        ImportNamespaceSpecifier: ['local'],
-        ImportSpecifier: ['imported', 'local'],
-        Literal: [],
-        LabeledStatement: ['label', 'body'],
-        LogicalExpression: ['left', 'right'],
-        MemberExpression: ['object', 'property'],
-        MetaProperty: ['meta', 'property'],
-        MethodDefinition: ['key', 'value'],
-        ModuleSpecifier: [],
-        NewExpression: ['callee', 'arguments'],
-        ObjectExpression: ['properties'],
-        ObjectPattern: ['properties'],
-        Program: ['body'],
-        Property: ['key', 'value'],
-        RestElement: [ 'argument' ],
-        ReturnStatement: ['argument'],
-        SequenceExpression: ['expressions'],
-        SpreadElement: ['argument'],
-        Super: [],
-        SwitchStatement: ['discriminant', 'cases'],
-        SwitchCase: ['test', 'consequent'],
-        TaggedTemplateExpression: ['tag', 'quasi'],
-        TemplateElement: [],
-        TemplateLiteral: ['quasis', 'expressions'],
-        ThisExpression: [],
-        ThrowStatement: ['argument'],
-        TryStatement: ['block', 'handler', 'finalizer'],
-        UnaryExpression: ['argument'],
-        UpdateExpression: ['argument'],
-        VariableDeclaration: ['declarations'],
-        VariableDeclarator: ['id', 'init'],
-        WhileStatement: ['test', 'body'],
-        WithStatement: ['object', 'body'],
-        YieldExpression: ['argument']
-    };
-
-    // unique id
-    BREAK = {};
-    SKIP = {};
-    REMOVE = {};
+	/**
+	 * @template T
+	 * @param {string} identifier the cache identifier
+	 * @param {Etag | null} etag the etag
+	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
+	 * @returns {Promise<T>} promise with the data
+	 */
+	async providePromise(identifier, etag, computer) {
+		const cacheEntry = await this.getPromise(identifier, etag);
+		if (cacheEntry !== undefined) return cacheEntry;
+		const result = await computer();
+		await this.storePromise(identifier, etag, result);
+		return result;
+	}
+}
 
-    VisitorOption = {
-        Break: BREAK,
-        Skip: SKIP,
-        Remove: REMOVE
-    };
+module.exports = CacheFacade;
+module.exports.ItemCacheFacade = ItemCacheFacade;
+module.exports.MultiItemCache = MultiItemCache;
 
-    function Reference(parent, key) {
-        this.parent = parent;
-        this.key = key;
-    }
 
-    Reference.prototype.replace = function replace(node) {
-        this.parent[this.key] = node;
-    };
+/***/ }),
 
-    Reference.prototype.remove = function remove() {
-        if (Array.isArray(this.parent)) {
-            this.parent.splice(this.key, 1);
-            return true;
-        } else {
-            this.replace(null);
-            return false;
-        }
-    };
+/***/ 77975:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    function Element(node, path, wrap, ref) {
-        this.node = node;
-        this.path = path;
-        this.wrap = wrap;
-        this.ref = ref;
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    function Controller() { }
 
-    // API:
-    // return property path array from root to current node
-    Controller.prototype.path = function path() {
-        var i, iz, j, jz, result, element;
 
-        function addToPath(result, path) {
-            if (Array.isArray(path)) {
-                for (j = 0, jz = path.length; j < jz; ++j) {
-                    result.push(path[j]);
-                }
-            } else {
-                result.push(path);
-            }
-        }
+const WebpackError = __webpack_require__(53799);
 
-        // root node
-        if (!this.__current.path) {
-            return null;
-        }
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
 
-        // first node is sentinel, second node is root element
-        result = [];
-        for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
-            element = this.__leavelist[i];
-            addToPath(result, element.path);
-        }
-        addToPath(result, this.__current.path);
-        return result;
-    };
+/**
+ * @param {Module[]} modules the modules to be sorted
+ * @returns {Module[]} sorted version of original modules
+ */
+const sortModules = modules => {
+	return modules.sort((a, b) => {
+		const aIdent = a.identifier();
+		const bIdent = b.identifier();
+		/* istanbul ignore next */
+		if (aIdent < bIdent) return -1;
+		/* istanbul ignore next */
+		if (aIdent > bIdent) return 1;
+		/* istanbul ignore next */
+		return 0;
+	});
+};
 
-    // API:
-    // return type of current node
-    Controller.prototype.type = function () {
-        var node = this.current();
-        return node.type || this.__current.wrap;
-    };
+/**
+ * @param {Module[]} modules each module from throw
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {string} each message from provided modules
+ */
+const createModulesListMessage = (modules, moduleGraph) => {
+	return modules
+		.map(m => {
+			let message = `* ${m.identifier()}`;
+			const validReasons = Array.from(
+				moduleGraph.getIncomingConnectionsByOriginModule(m).keys()
+			).filter(x => x);
 
-    // API:
-    // return array of parent elements
-    Controller.prototype.parents = function parents() {
-        var i, iz, result;
+			if (validReasons.length > 0) {
+				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
+				message += `\n    ${validReasons[0].identifier()}`;
+			}
+			return message;
+		})
+		.join("\n");
+};
 
-        // first node is sentinel
-        result = [];
-        for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
-            result.push(this.__leavelist[i].node);
-        }
+class CaseSensitiveModulesWarning extends WebpackError {
+	/**
+	 * Creates an instance of CaseSensitiveModulesWarning.
+	 * @param {Iterable<Module>} modules modules that were detected
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 */
+	constructor(modules, moduleGraph) {
+		const sortedModules = sortModules(Array.from(modules));
+		const modulesList = createModulesListMessage(sortedModules, moduleGraph);
+		super(`There are multiple modules with names that only differ in casing.
+This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.
+Use equal casing. Compare these module identifiers:
+${modulesList}`);
 
-        return result;
-    };
+		this.name = "CaseSensitiveModulesWarning";
+		this.module = sortedModules[0];
+	}
+}
 
-    // API:
-    // return current node
-    Controller.prototype.current = function current() {
-        return this.__current.node;
-    };
+module.exports = CaseSensitiveModulesWarning;
 
-    Controller.prototype.__execute = function __execute(callback, element) {
-        var previous, result;
 
-        result = undefined;
+/***/ }),
 
-        previous  = this.__current;
-        this.__current = element;
-        this.__state = null;
-        if (callback) {
-            result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
-        }
-        this.__current = previous;
+/***/ 39385:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        return result;
-    };
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    // API:
-    // notify control skip / break
-    Controller.prototype.notify = function notify(flag) {
-        this.__state = flag;
-    };
 
-    // API:
-    // skip child nodes of current node
-    Controller.prototype.skip = function () {
-        this.notify(SKIP);
-    };
 
-    // API:
-    // break traversals
-    Controller.prototype['break'] = function () {
-        this.notify(BREAK);
-    };
+const ChunkGraph = __webpack_require__(64971);
+const Entrypoint = __webpack_require__(13795);
+const { intersect } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
+const StringXor = __webpack_require__(40293);
+const {
+	compareModulesByIdentifier,
+	compareChunkGroupsByIndex,
+	compareModulesById
+} = __webpack_require__(29579);
+const { createArrayToSetDeprecationSet } = __webpack_require__(64518);
+const { mergeRuntime } = __webpack_require__(17156);
 
-    // API:
-    // remove node
-    Controller.prototype.remove = function () {
-        this.notify(REMOVE);
-    };
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
+/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
+/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-    Controller.prototype.__initialize = function(root, visitor) {
-        this.visitor = visitor;
-        this.root = root;
-        this.__worklist = [];
-        this.__leavelist = [];
-        this.__current = null;
-        this.__state = null;
-        this.__fallback = null;
-        if (visitor.fallback === 'iteration') {
-            this.__fallback = Object.keys;
-        } else if (typeof visitor.fallback === 'function') {
-            this.__fallback = visitor.fallback;
-        }
+const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
 
-        this.__keys = VisitorKeys;
-        if (visitor.keys) {
-            this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
-        }
-    };
+/**
+ * @typedef {Object} WithId an object who has an id property *
+ * @property {string | number} id the id of the object
+ */
 
-    function isNode(node) {
-        if (node == null) {
-            return false;
-        }
-        return typeof node === 'object' && typeof node.type === 'string';
-    }
+/**
+ * @deprecated
+ * @typedef {Object} ChunkMaps
+ * @property {Record<string|number, string>} hash
+ * @property {Record<string|number, Record<string, string>>} contentHash
+ * @property {Record<string|number, string>} name
+ */
 
-    function isProperty(nodeType, key) {
-        return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
-    }
+/**
+ * @deprecated
+ * @typedef {Object} ChunkModuleMaps
+ * @property {Record<string|number, (string|number)[]>} id
+ * @property {Record<string|number, string>} hash
+ */
 
-    Controller.prototype.traverse = function traverse(root, visitor) {
-        var worklist,
-            leavelist,
-            element,
-            node,
-            nodeType,
-            ret,
-            key,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel;
+let debugId = 1000;
 
-        this.__initialize(root, visitor);
+/**
+ * A Chunk is a unit of encapsulation for Modules.
+ * Chunks are "rendered" into bundles that get emitted when the build completes.
+ */
+class Chunk {
+	/**
+	 * @param {string=} name of chunk being created, is optional (for subclasses)
+	 * @param {boolean} backCompat enable backward-compatibility
+	 */
+	constructor(name, backCompat = true) {
+		/** @type {number | string | null} */
+		this.id = null;
+		/** @type {(number|string)[] | null} */
+		this.ids = null;
+		/** @type {number} */
+		this.debugId = debugId++;
+		/** @type {string} */
+		this.name = name;
+		/** @type {SortableSet<string>} */
+		this.idNameHints = new SortableSet();
+		/** @type {boolean} */
+		this.preventIntegration = false;
+		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		this.filenameTemplate = undefined;
+		/** @type {(string | function(PathData, AssetInfo=): string)?} */
+		this.cssFilenameTemplate = undefined;
+		/** @private @type {SortableSet<ChunkGroup>} */
+		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
+		/** @type {RuntimeSpec} */
+		this.runtime = undefined;
+		/** @type {Set<string>} */
+		this.files = backCompat ? new ChunkFilesSet() : new Set();
+		/** @type {Set<string>} */
+		this.auxiliaryFiles = new Set();
+		/** @type {boolean} */
+		this.rendered = false;
+		/** @type {string=} */
+		this.hash = undefined;
+		/** @type {Record<string, string>} */
+		this.contentHash = Object.create(null);
+		/** @type {string=} */
+		this.renderedHash = undefined;
+		/** @type {string=} */
+		this.chunkReason = undefined;
+		/** @type {boolean} */
+		this.extraAsync = false;
+	}
 
-        sentinel = {};
+	// TODO remove in webpack 6
+	// BACKWARD-COMPAT START
+	get entryModule() {
+		const entryModules = Array.from(
+			ChunkGraph.getChunkGraphForChunk(
+				this,
+				"Chunk.entryModule",
+				"DEP_WEBPACK_CHUNK_ENTRY_MODULE"
+			).getChunkEntryModulesIterable(this)
+		);
+		if (entryModules.length === 0) {
+			return undefined;
+		} else if (entryModules.length === 1) {
+			return entryModules[0];
+		} else {
+			throw new Error(
+				"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
+			);
+		}
+	}
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+	/**
+	 * @returns {boolean} true, if the chunk contains an entry module
+	 */
+	hasEntryModule() {
+		return (
+			ChunkGraph.getChunkGraphForChunk(
+				this,
+				"Chunk.hasEntryModule",
+				"DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE"
+			).getNumberOfEntryModules(this) > 0
+		);
+	}
 
-        // initialize
-        worklist.push(new Element(root, null, null, null));
-        leavelist.push(new Element(null, null, null, null));
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the chunk could be added
+	 */
+	addModule(module) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.addModule",
+			"DEP_WEBPACK_CHUNK_ADD_MODULE"
+		);
+		if (chunkGraph.isModuleInChunk(module, this)) return false;
+		chunkGraph.connectChunkAndModule(this, module);
+		return true;
+	}
 
-        while (worklist.length) {
-            element = worklist.pop();
-
-            if (element === sentinel) {
-                element = leavelist.pop();
-
-                ret = this.__execute(visitor.leave, element);
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	removeModule(module) {
+		ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.removeModule",
+			"DEP_WEBPACK_CHUNK_REMOVE_MODULE"
+		).disconnectChunkAndModule(this, module);
+	}
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
-                continue;
-            }
+	/**
+	 * @returns {number} the number of module which are contained in this chunk
+	 */
+	getNumberOfModules() {
+		return ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.getNumberOfModules",
+			"DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES"
+		).getNumberOfChunkModules(this);
+	}
 
-            if (element.node) {
+	get modulesIterable() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.modulesIterable",
+			"DEP_WEBPACK_CHUNK_MODULES_ITERABLE"
+		);
+		return chunkGraph.getOrderedChunkModulesIterable(
+			this,
+			compareModulesByIdentifier
+		);
+	}
 
-                ret = this.__execute(visitor.enter, element);
+	/**
+	 * @param {Chunk} otherChunk the chunk to compare with
+	 * @returns {-1|0|1} the comparison result
+	 */
+	compareTo(otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.compareTo",
+			"DEP_WEBPACK_CHUNK_COMPARE_TO"
+		);
+		return chunkGraph.compareChunks(this, otherChunk);
+	}
 
-                if (this.__state === BREAK || ret === BREAK) {
-                    return;
-                }
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the chunk contains the module
+	 */
+	containsModule(module) {
+		return ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.containsModule",
+			"DEP_WEBPACK_CHUNK_CONTAINS_MODULE"
+		).isModuleInChunk(module, this);
+	}
 
-                worklist.push(sentinel);
-                leavelist.push(element);
+	/**
+	 * @returns {Module[]} the modules for this chunk
+	 */
+	getModules() {
+		return ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.getModules",
+			"DEP_WEBPACK_CHUNK_GET_MODULES"
+		).getChunkModules(this);
+	}
 
-                if (this.__state === SKIP || ret === SKIP) {
-                    continue;
-                }
+	/**
+	 * @returns {void}
+	 */
+	remove() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.remove",
+			"DEP_WEBPACK_CHUNK_REMOVE"
+		);
+		chunkGraph.disconnectChunk(this);
+		this.disconnectFromGroups();
+	}
 
-                node = element.node;
-                nodeType = node.type || element.wrap;
-                candidates = this.__keys[nodeType];
-                if (!candidates) {
-                    if (this.__fallback) {
-                        candidates = this.__fallback(node);
-                    } else {
-                        throw new Error('Unknown node type ' + nodeType + '.');
-                    }
-                }
+	/**
+	 * @param {Module} module the module
+	 * @param {Chunk} otherChunk the target chunk
+	 * @returns {void}
+	 */
+	moveModule(module, otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.moveModule",
+			"DEP_WEBPACK_CHUNK_MOVE_MODULE"
+		);
+		chunkGraph.disconnectChunkAndModule(this, module);
+		chunkGraph.connectChunkAndModule(otherChunk, module);
+	}
 
-                current = candidates.length;
-                while ((current -= 1) >= 0) {
-                    key = candidates[current];
-                    candidate = node[key];
-                    if (!candidate) {
-                        continue;
-                    }
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @returns {boolean} true, if the specified chunk has been integrated
+	 */
+	integrate(otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.integrate",
+			"DEP_WEBPACK_CHUNK_INTEGRATE"
+		);
+		if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
+			chunkGraph.integrateChunks(this, otherChunk);
+			return true;
+		} else {
+			return false;
+		}
+	}
 
-                    if (Array.isArray(candidate)) {
-                        current2 = candidate.length;
-                        while ((current2 -= 1) >= 0) {
-                            if (!candidate[current2]) {
-                                continue;
-                            }
-                            if (isProperty(nodeType, candidates[current])) {
-                                element = new Element(candidate[current2], [key, current2], 'Property', null);
-                            } else if (isNode(candidate[current2])) {
-                                element = new Element(candidate[current2], [key, current2], null, null);
-                            } else {
-                                continue;
-                            }
-                            worklist.push(element);
-                        }
-                    } else if (isNode(candidate)) {
-                        worklist.push(new Element(candidate, key, null, null));
-                    }
-                }
-            }
-        }
-    };
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @returns {boolean} true, if chunks could be integrated
+	 */
+	canBeIntegrated(otherChunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.canBeIntegrated",
+			"DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED"
+		);
+		return chunkGraph.canChunksBeIntegrated(this, otherChunk);
+	}
 
-    Controller.prototype.replace = function replace(root, visitor) {
-        var worklist,
-            leavelist,
-            node,
-            nodeType,
-            target,
-            element,
-            current,
-            current2,
-            candidates,
-            candidate,
-            sentinel,
-            outer,
-            key;
+	/**
+	 * @returns {boolean} true, if this chunk contains no module
+	 */
+	isEmpty() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.isEmpty",
+			"DEP_WEBPACK_CHUNK_IS_EMPTY"
+		);
+		return chunkGraph.getNumberOfChunkModules(this) === 0;
+	}
 
-        function removeElem(element) {
-            var i,
-                key,
-                nextElem,
-                parent;
+	/**
+	 * @returns {number} total size of all modules in this chunk
+	 */
+	modulesSize() {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.modulesSize",
+			"DEP_WEBPACK_CHUNK_MODULES_SIZE"
+		);
+		return chunkGraph.getChunkModulesSize(this);
+	}
 
-            if (element.ref.remove()) {
-                // When the reference is an element of an array.
-                key = element.ref.key;
-                parent = element.ref.parent;
+	/**
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of this chunk
+	 */
+	size(options = {}) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.size",
+			"DEP_WEBPACK_CHUNK_SIZE"
+		);
+		return chunkGraph.getChunkSize(this, options);
+	}
 
-                // If removed from array, then decrease following items' keys.
-                i = worklist.length;
-                while (i--) {
-                    nextElem = worklist[i];
-                    if (nextElem.ref && nextElem.ref.parent === parent) {
-                        if  (nextElem.ref.key < key) {
-                            break;
-                        }
-                        --nextElem.ref.key;
-                    }
-                }
-            }
-        }
+	/**
+	 * @param {Chunk} otherChunk the other chunk
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of the chunk or false if the chunk can't be integrated
+	 */
+	integratedSize(otherChunk, options) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.integratedSize",
+			"DEP_WEBPACK_CHUNK_INTEGRATED_SIZE"
+		);
+		return chunkGraph.getIntegratedChunksSize(this, otherChunk, options);
+	}
 
-        this.__initialize(root, visitor);
+	/**
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @returns {ChunkModuleMaps} module map information
+	 */
+	getChunkModuleMaps(filterFn) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.getChunkModuleMaps",
+			"DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS"
+		);
+		/** @type {Record<string|number, (string|number)[]>} */
+		const chunkModuleIdMap = Object.create(null);
+		/** @type {Record<string|number, string>} */
+		const chunkModuleHashMap = Object.create(null);
 
-        sentinel = {};
+		for (const asyncChunk of this.getAllAsyncChunks()) {
+			/** @type {(string|number)[]} */
+			let array;
+			for (const module of chunkGraph.getOrderedChunkModulesIterable(
+				asyncChunk,
+				compareModulesById(chunkGraph)
+			)) {
+				if (filterFn(module)) {
+					if (array === undefined) {
+						array = [];
+						chunkModuleIdMap[asyncChunk.id] = array;
+					}
+					const moduleId = chunkGraph.getModuleId(module);
+					array.push(moduleId);
+					chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash(
+						module,
+						undefined
+					);
+				}
+			}
+		}
 
-        // reference
-        worklist = this.__worklist;
-        leavelist = this.__leavelist;
+		return {
+			id: chunkModuleIdMap,
+			hash: chunkModuleHashMap
+		};
+	}
 
-        // initialize
-        outer = {
-            root: root
-        };
-        element = new Element(root, null, null, new Reference(outer, 'root'));
-        worklist.push(element);
-        leavelist.push(element);
+	/**
+	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
+	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
+	 * @returns {boolean} return true if module exists in graph
+	 */
+	hasModuleInGraph(filterFn, filterChunkFn) {
+		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
+			this,
+			"Chunk.hasModuleInGraph",
+			"DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH"
+		);
+		return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn);
+	}
 
-        while (worklist.length) {
-            element = worklist.pop();
+	/**
+	 * @deprecated
+	 * @param {boolean} realHash whether the full hash or the rendered hash is to be used
+	 * @returns {ChunkMaps} the chunk map information
+	 */
+	getChunkMaps(realHash) {
+		/** @type {Record<string|number, string>} */
+		const chunkHashMap = Object.create(null);
+		/** @type {Record<string|number, Record<string, string>>} */
+		const chunkContentHashMap = Object.create(null);
+		/** @type {Record<string|number, string>} */
+		const chunkNameMap = Object.create(null);
 
-            if (element === sentinel) {
-                element = leavelist.pop();
+		for (const chunk of this.getAllAsyncChunks()) {
+			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
+			for (const key of Object.keys(chunk.contentHash)) {
+				if (!chunkContentHashMap[key]) {
+					chunkContentHashMap[key] = Object.create(null);
+				}
+				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
+			}
+			if (chunk.name) {
+				chunkNameMap[chunk.id] = chunk.name;
+			}
+		}
 
-                target = this.__execute(visitor.leave, element);
+		return {
+			hash: chunkHashMap,
+			contentHash: chunkContentHashMap,
+			name: chunkNameMap
+		};
+	}
+	// BACKWARD-COMPAT END
 
-                // node may be replaced with null,
-                // so distinguish between undefined and null in this place
-                if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                    // replace
-                    element.ref.replace(target);
-                }
+	/**
+	 * @returns {boolean} whether or not the Chunk will have a runtime
+	 */
+	hasRuntime() {
+		for (const chunkGroup of this._groups) {
+			if (
+				chunkGroup instanceof Entrypoint &&
+				chunkGroup.getRuntimeChunk() === this
+			) {
+				return true;
+			}
+		}
+		return false;
+	}
 
-                if (this.__state === REMOVE || target === REMOVE) {
-                    removeElem(element);
-                }
+	/**
+	 * @returns {boolean} whether or not this chunk can be an initial chunk
+	 */
+	canBeInitial() {
+		for (const chunkGroup of this._groups) {
+			if (chunkGroup.isInitial()) return true;
+		}
+		return false;
+	}
 
-                if (this.__state === BREAK || target === BREAK) {
-                    return outer.root;
-                }
-                continue;
-            }
+	/**
+	 * @returns {boolean} whether this chunk can only be an initial chunk
+	 */
+	isOnlyInitial() {
+		if (this._groups.size <= 0) return false;
+		for (const chunkGroup of this._groups) {
+			if (!chunkGroup.isInitial()) return false;
+		}
+		return true;
+	}
 
-            target = this.__execute(visitor.enter, element);
+	/**
+	 * @returns {EntryOptions | undefined} the entry options for this chunk
+	 */
+	getEntryOptions() {
+		for (const chunkGroup of this._groups) {
+			if (chunkGroup instanceof Entrypoint) {
+				return chunkGroup.options;
+			}
+		}
+		return undefined;
+	}
 
-            // node may be replaced with null,
-            // so distinguish between undefined and null in this place
-            if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
-                // replace
-                element.ref.replace(target);
-                element.node = target;
-            }
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
+	 * @returns {void}
+	 */
+	addGroup(chunkGroup) {
+		this._groups.add(chunkGroup);
+	}
 
-            if (this.__state === REMOVE || target === REMOVE) {
-                removeElem(element);
-                element.node = null;
-            }
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
+	 * @returns {void}
+	 */
+	removeGroup(chunkGroup) {
+		this._groups.delete(chunkGroup);
+	}
 
-            if (this.__state === BREAK || target === BREAK) {
-                return outer.root;
-            }
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunkGroup to check
+	 * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup
+	 */
+	isInGroup(chunkGroup) {
+		return this._groups.has(chunkGroup);
+	}
 
-            // node may be null
-            node = element.node;
-            if (!node) {
-                continue;
-            }
+	/**
+	 * @returns {number} the amount of groups that the said chunk is in
+	 */
+	getNumberOfGroups() {
+		return this._groups.size;
+	}
 
-            worklist.push(sentinel);
-            leavelist.push(element);
+	/**
+	 * @returns {Iterable<ChunkGroup>} the chunkGroups that the said chunk is referenced in
+	 */
+	get groupsIterable() {
+		this._groups.sort();
+		return this._groups;
+	}
 
-            if (this.__state === SKIP || target === SKIP) {
-                continue;
-            }
+	/**
+	 * @returns {void}
+	 */
+	disconnectFromGroups() {
+		for (const chunkGroup of this._groups) {
+			chunkGroup.removeChunk(this);
+		}
+	}
 
-            nodeType = node.type || element.wrap;
-            candidates = this.__keys[nodeType];
-            if (!candidates) {
-                if (this.__fallback) {
-                    candidates = this.__fallback(node);
-                } else {
-                    throw new Error('Unknown node type ' + nodeType + '.');
-                }
-            }
+	/**
+	 * @param {Chunk} newChunk the new chunk that will be split out of
+	 * @returns {void}
+	 */
+	split(newChunk) {
+		for (const chunkGroup of this._groups) {
+			chunkGroup.insertChunk(newChunk, this);
+			newChunk.addGroup(chunkGroup);
+		}
+		for (const idHint of this.idNameHints) {
+			newChunk.idNameHints.add(idHint);
+		}
+		newChunk.runtime = mergeRuntime(newChunk.runtime, this.runtime);
+	}
 
-            current = candidates.length;
-            while ((current -= 1) >= 0) {
-                key = candidates[current];
-                candidate = node[key];
-                if (!candidate) {
-                    continue;
-                }
-
-                if (Array.isArray(candidate)) {
-                    current2 = candidate.length;
-                    while ((current2 -= 1) >= 0) {
-                        if (!candidate[current2]) {
-                            continue;
-                        }
-                        if (isProperty(nodeType, candidates[current])) {
-                            element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
-                        } else if (isNode(candidate[current2])) {
-                            element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
-                        } else {
-                            continue;
-                        }
-                        worklist.push(element);
-                    }
-                } else if (isNode(candidate)) {
-                    worklist.push(new Element(candidate, key, null, new Reference(node, key)));
-                }
-            }
-        }
+	/**
+	 * @param {Hash} hash hash (will be modified)
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	updateHash(hash, chunkGraph) {
+		hash.update(
+			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
+		);
+		const xor = new StringXor();
+		for (const m of chunkGraph.getChunkModulesIterable(this)) {
+			xor.add(chunkGraph.getModuleHash(m, this.runtime));
+		}
+		xor.updateHash(hash);
+		const entryModules =
+			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
+		for (const [m, chunkGroup] of entryModules) {
+			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
+		}
+	}
 
-        return outer.root;
-    };
+	/**
+	 * @returns {Set<Chunk>} a set of all the async chunks
+	 */
+	getAllAsyncChunks() {
+		const queue = new Set();
+		const chunks = new Set();
 
-    function traverse(root, visitor) {
-        var controller = new Controller();
-        return controller.traverse(root, visitor);
-    }
+		const initialChunks = intersect(
+			Array.from(this.groupsIterable, g => new Set(g.chunks))
+		);
 
-    function replace(root, visitor) {
-        var controller = new Controller();
-        return controller.replace(root, visitor);
-    }
+		const initialQueue = new Set(this.groupsIterable);
 
-    function extendCommentRange(comment, tokens) {
-        var target;
+		for (const chunkGroup of initialQueue) {
+			for (const child of chunkGroup.childrenIterable) {
+				if (child instanceof Entrypoint) {
+					initialQueue.add(child);
+				} else {
+					queue.add(child);
+				}
+			}
+		}
 
-        target = upperBound(tokens, function search(token) {
-            return token.range[0] > comment.range[0];
-        });
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				if (!initialChunks.has(chunk)) {
+					chunks.add(chunk);
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
 
-        comment.extendedRange = [comment.range[0], comment.range[1]];
+		return chunks;
+	}
 
-        if (target !== tokens.length) {
-            comment.extendedRange[1] = tokens[target].range[0];
-        }
+	/**
+	 * @returns {Set<Chunk>} a set of all the initial chunks (including itself)
+	 */
+	getAllInitialChunks() {
+		const chunks = new Set();
+		const queue = new Set(this.groupsIterable);
+		for (const group of queue) {
+			if (group.isInitial()) {
+				for (const c of group.chunks) chunks.add(c);
+				for (const g of group.childrenIterable) queue.add(g);
+			}
+		}
+		return chunks;
+	}
 
-        target -= 1;
-        if (target >= 0) {
-            comment.extendedRange[0] = tokens[target].range[1];
-        }
+	/**
+	 * @returns {Set<Chunk>} a set of all the referenced chunks (including itself)
+	 */
+	getAllReferencedChunks() {
+		const queue = new Set(this.groupsIterable);
+		const chunks = new Set();
 
-        return comment;
-    }
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				chunks.add(chunk);
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
 
-    function attachComments(tree, providedComments, tokens) {
-        // At first, we should calculate extended comment ranges.
-        var comments = [], comment, len, i, cursor;
+		return chunks;
+	}
 
-        if (!tree.range) {
-            throw new Error('attachComments needs range information');
-        }
+	/**
+	 * @returns {Set<Entrypoint>} a set of all the referenced entrypoints
+	 */
+	getAllReferencedAsyncEntrypoints() {
+		const queue = new Set(this.groupsIterable);
+		const entrypoints = new Set();
 
-        // tokens array is empty, we attach comments to tree as 'leadingComments'
-        if (!tokens.length) {
-            if (providedComments.length) {
-                for (i = 0, len = providedComments.length; i < len; i += 1) {
-                    comment = deepCopy(providedComments[i]);
-                    comment.extendedRange = [0, tree.range[0]];
-                    comments.push(comment);
-                }
-                tree.leadingComments = comments;
-            }
-            return tree;
-        }
+		for (const chunkGroup of queue) {
+			for (const entrypoint of chunkGroup.asyncEntrypointsIterable) {
+				entrypoints.add(entrypoint);
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
 
-        for (i = 0, len = providedComments.length; i < len; i += 1) {
-            comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
-        }
+		return entrypoints;
+	}
 
-        // This is based on John Freeman's implementation.
-        cursor = 0;
-        traverse(tree, {
-            enter: function (node) {
-                var comment;
+	/**
+	 * @returns {boolean} true, if the chunk references async chunks
+	 */
+	hasAsyncChunks() {
+		const queue = new Set();
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (comment.extendedRange[1] > node.range[0]) {
-                        break;
-                    }
+		const initialChunks = intersect(
+			Array.from(this.groupsIterable, g => new Set(g.chunks))
+		);
 
-                    if (comment.extendedRange[1] === node.range[0]) {
-                        if (!node.leadingComments) {
-                            node.leadingComments = [];
-                        }
-                        node.leadingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
+		for (const chunkGroup of this.groupsIterable) {
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+		for (const chunkGroup of queue) {
+			for (const chunk of chunkGroup.chunks) {
+				if (!initialChunks.has(chunk)) {
+					return true;
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+		return false;
+	}
 
-        cursor = 0;
-        traverse(tree, {
-            leave: function (node) {
-                var comment;
+	/**
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
+	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
+	 */
+	getChildIdsByOrders(chunkGraph, filterFn) {
+		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
+		const lists = new Map();
+		for (const group of this.groupsIterable) {
+			if (group.chunks[group.chunks.length - 1] === this) {
+				for (const childGroup of group.childrenIterable) {
+					for (const key of Object.keys(childGroup.options)) {
+						if (key.endsWith("Order")) {
+							const name = key.substr(0, key.length - "Order".length);
+							let list = lists.get(name);
+							if (list === undefined) {
+								list = [];
+								lists.set(name, list);
+							}
+							list.push({
+								order: childGroup.options[key],
+								group: childGroup
+							});
+						}
+					}
+				}
+			}
+		}
+		/** @type {Record<string, (string | number)[]>} */
+		const result = Object.create(null);
+		for (const [name, list] of lists) {
+			list.sort((a, b) => {
+				const cmp = b.order - a.order;
+				if (cmp !== 0) return cmp;
+				return a.group.compareTo(chunkGraph, b.group);
+			});
+			/** @type {Set<string | number>} */
+			const chunkIdSet = new Set();
+			for (const item of list) {
+				for (const chunk of item.group.chunks) {
+					if (filterFn && !filterFn(chunk, chunkGraph)) continue;
+					chunkIdSet.add(chunk.id);
+				}
+			}
+			if (chunkIdSet.size > 0) {
+				result[name] = Array.from(chunkIdSet);
+			}
+		}
+		return result;
+	}
 
-                while (cursor < comments.length) {
-                    comment = comments[cursor];
-                    if (node.range[1] < comment.extendedRange[0]) {
-                        break;
-                    }
+	/**
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {string} type option name
+	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
+	 */
+	getChildrenOfTypeInOrder(chunkGraph, type) {
+		const list = [];
+		for (const group of this.groupsIterable) {
+			for (const childGroup of group.childrenIterable) {
+				const order = childGroup.options[type];
+				if (order === undefined) continue;
+				list.push({
+					order,
+					group,
+					childGroup
+				});
+			}
+		}
+		if (list.length === 0) return undefined;
+		list.sort((a, b) => {
+			const cmp = b.order - a.order;
+			if (cmp !== 0) return cmp;
+			return a.group.compareTo(chunkGraph, b.group);
+		});
+		const result = [];
+		let lastEntry;
+		for (const { group, childGroup } of list) {
+			if (lastEntry && lastEntry.onChunks === group.chunks) {
+				for (const chunk of childGroup.chunks) {
+					lastEntry.chunks.add(chunk);
+				}
+			} else {
+				result.push(
+					(lastEntry = {
+						onChunks: group.chunks,
+						chunks: new Set(childGroup.chunks)
+					})
+				);
+			}
+		}
+		return result;
+	}
 
-                    if (node.range[1] === comment.extendedRange[0]) {
-                        if (!node.trailingComments) {
-                            node.trailingComments = [];
-                        }
-                        node.trailingComments.push(comment);
-                        comments.splice(cursor, 1);
-                    } else {
-                        cursor += 1;
-                    }
-                }
+	/**
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
+	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
+	 * @returns {Record<string|number, Record<string, (string | number)[]>>} a record object of names to lists of child ids(?) by chunk id
+	 */
+	getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
+		/** @type {Record<string|number, Record<string, (string | number)[]>>} */
+		const chunkMaps = Object.create(null);
 
-                // already out of owned node
-                if (cursor === comments.length) {
-                    return VisitorOption.Break;
-                }
+		/**
+		 * @param {Chunk} chunk a chunk
+		 * @returns {void}
+		 */
+		const addChildIdsByOrdersToMap = chunk => {
+			const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
+			for (const key of Object.keys(data)) {
+				let chunkMap = chunkMaps[key];
+				if (chunkMap === undefined) {
+					chunkMaps[key] = chunkMap = Object.create(null);
+				}
+				chunkMap[chunk.id] = data[key];
+			}
+		};
 
-                if (comments[cursor].extendedRange[0] > node.range[1]) {
-                    return VisitorOption.Skip;
-                }
-            }
-        });
+		if (includeDirectChildren) {
+			/** @type {Set<Chunk>} */
+			const chunks = new Set();
+			for (const chunkGroup of this.groupsIterable) {
+				for (const chunk of chunkGroup.chunks) {
+					chunks.add(chunk);
+				}
+			}
+			for (const chunk of chunks) {
+				addChildIdsByOrdersToMap(chunk);
+			}
+		}
 
-        return tree;
-    }
+		for (const chunk of this.getAllAsyncChunks()) {
+			addChildIdsByOrdersToMap(chunk);
+		}
 
-    exports.version = (__webpack_require__(15535)/* .version */ .i8);
-    exports.Syntax = Syntax;
-    exports.traverse = traverse;
-    exports.replace = replace;
-    exports.attachComments = attachComments;
-    exports.VisitorKeys = VisitorKeys;
-    exports.VisitorOption = VisitorOption;
-    exports.Controller = Controller;
-    exports.cloneEnvironment = function () { return clone({}); };
+		return chunkMaps;
+	}
+}
 
-    return exports;
-}(exports));
-/* vim: set sw=4 ts=4 et tw=80 : */
+module.exports = Chunk;
 
 
 /***/ }),
 
-/***/ 86140:
-/***/ (function(module) {
+/***/ 64971:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-module.exports = function (glob, opts) {
-  if (typeof glob !== 'string') {
-    throw new TypeError('Expected a string');
-  }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-  var str = String(glob);
 
-  // The regexp we are building, as a string.
-  var reStr = "";
 
-  // Whether we are matching so called "extended" globs (like bash) and should
-  // support single character matching, matching ranges of characters, group
-  // matching, etc.
-  var extended = opts ? !!opts.extended : false;
+const util = __webpack_require__(73837);
+const Entrypoint = __webpack_require__(13795);
+const ModuleGraphConnection = __webpack_require__(40639);
+const { first } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
+const {
+	compareModulesById,
+	compareIterables,
+	compareModulesByIdentifier,
+	concatComparators,
+	compareSelect,
+	compareIds
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const findGraphRoots = __webpack_require__(6261);
+const {
+	RuntimeSpecMap,
+	RuntimeSpecSet,
+	runtimeToString,
+	mergeRuntime,
+	forEachRuntime
+} = __webpack_require__(17156);
 
-  // When globstar is _false_ (default), '/foo/*' is translated a regexp like
-  // '^\/foo\/.*$' which will match any string beginning with '/foo/'
-  // When globstar is _true_, '/foo/*' is translated to regexp like
-  // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
-  // which does not have a '/' to the right of it.
-  // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
-  // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
-  // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
-  // globstar is _false_
-  var globstar = opts ? !!opts.globstar : false;
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-  // If we are doing extended matching, this boolean is true when we are inside
-  // a group (eg {*.html,*.js}), and false otherwise.
-  var inGroup = false;
+/** @type {ReadonlySet<string>} */
+const EMPTY_SET = new Set();
 
-  // RegExp flags (eg "i" ) to pass in to RegExp constructor.
-  var flags = opts && typeof( opts.flags ) === "string" ? opts.flags : "";
+const ZERO_BIG_INT = BigInt(0);
 
-  var c;
-  for (var i = 0, len = str.length; i < len; i++) {
-    c = str[i];
+const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
-    switch (c) {
-    case "/":
-    case "$":
-    case "^":
-    case "+":
-    case ".":
-    case "(":
-    case ")":
-    case "=":
-    case "!":
-    case "|":
-      reStr += "\\" + c;
-      break;
+/** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
+/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
 
-    case "?":
-      if (extended) {
-        reStr += ".";
-	    break;
-      }
+/**
+ * @typedef {Object} ChunkSizeOptions
+ * @property {number=} chunkOverhead constant overhead for a chunk
+ * @property {number=} entryChunkMultiplicator multiplicator for initial chunks
+ */
 
-    case "[":
-    case "]":
-      if (extended) {
-        reStr += c;
-	    break;
-      }
+class ModuleHashInfo {
+	constructor(hash, renderedHash) {
+		this.hash = hash;
+		this.renderedHash = renderedHash;
+	}
+}
 
-    case "{":
-      if (extended) {
-        inGroup = true;
-	    reStr += "(";
-	    break;
-      }
+/** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
 
-    case "}":
-      if (extended) {
-        inGroup = false;
-	    reStr += ")";
-	    break;
-      }
+/**
+ * @template T
+ * @param {SortableSet<T>} set the set
+ * @returns {T[]} set as array
+ */
+const getArray = set => {
+	return Array.from(set);
+};
 
-    case ",":
-      if (inGroup) {
-        reStr += "|";
-	    break;
-      }
-      reStr += "\\" + c;
-      break;
+/**
+ * @param {SortableSet<Chunk>} chunks the chunks
+ * @returns {RuntimeSpecSet} runtimes
+ */
+const getModuleRuntimes = chunks => {
+	const runtimes = new RuntimeSpecSet();
+	for (const chunk of chunks) {
+		runtimes.add(chunk.runtime);
+	}
+	return runtimes;
+};
 
-    case "*":
-      // Move over all consecutive "*"'s.
-      // Also store the previous and next characters
-      var prevChar = str[i - 1];
-      var starCount = 1;
-      while(str[i + 1] === "*") {
-        starCount++;
-        i++;
-      }
-      var nextChar = str[i + 1];
+/**
+ * @param {SortableSet<Module>} set the set
+ * @returns {Map<string, SortableSet<Module>>} modules by source type
+ */
+const modulesBySourceType = set => {
+	/** @type {Map<string, SortableSet<Module>>} */
+	const map = new Map();
+	for (const module of set) {
+		for (const sourceType of module.getSourceTypes()) {
+			let innerSet = map.get(sourceType);
+			if (innerSet === undefined) {
+				innerSet = new SortableSet();
+				map.set(sourceType, innerSet);
+			}
+			innerSet.add(module);
+		}
+	}
+	for (const [key, innerSet] of map) {
+		// When all modules have the source type, we reuse the original SortableSet
+		// to benefit from the shared cache (especially for sorting)
+		if (innerSet.size === set.size) {
+			map.set(key, set);
+		}
+	}
+	return map;
+};
 
-      if (!globstar) {
-        // globstar is disabled, so treat any number of "*" as one
-        reStr += ".*";
-      } else {
-        // globstar is enabled, so determine if this is a globstar segment
-        var isGlobstar = starCount > 1                      // multiple "*"'s
-          && (prevChar === "/" || prevChar === undefined)   // from the start of the segment
-          && (nextChar === "/" || nextChar === undefined)   // to the end of the segment
+/** @type {WeakMap<Function, any>} */
+const createOrderedArrayFunctionMap = new WeakMap();
 
-        if (isGlobstar) {
-          // it's a globstar, so match zero or more path segments
-          reStr += "((?:[^/]*(?:\/|$))*)";
-          i++; // move over the "/"
-        } else {
-          // it's not a globstar, so only match one path segment
-          reStr += "([^/]*)";
-        }
-      }
-      break;
+/**
+ * @template T
+ * @param {function(T, T): -1|0|1} comparator comparator function
+ * @returns {SetToArrayFunction<T>} set as ordered array
+ */
+const createOrderedArrayFunction = comparator => {
+	/** @type {SetToArrayFunction<T>} */
+	let fn = createOrderedArrayFunctionMap.get(comparator);
+	if (fn !== undefined) return fn;
+	fn = set => {
+		set.sortWith(comparator);
+		return Array.from(set);
+	};
+	createOrderedArrayFunctionMap.set(comparator, fn);
+	return fn;
+};
 
-    default:
-      reStr += c;
-    }
-  }
+/**
+ * @param {Iterable<Module>} modules the modules to get the count/size of
+ * @returns {number} the size of the modules
+ */
+const getModulesSize = modules => {
+	let size = 0;
+	for (const module of modules) {
+		for (const type of module.getSourceTypes()) {
+			size += module.size(type);
+		}
+	}
+	return size;
+};
 
-  // When regexp 'g' flag is specified don't
-  // constrain the regular expression with ^ & $
-  if (!flags || !~flags.indexOf('g')) {
-    reStr = "^" + reStr + "$";
-  }
+/**
+ * @param {Iterable<Module>} modules the sortable Set to get the size of
+ * @returns {Record<string, number>} the sizes of the modules
+ */
+const getModulesSizes = modules => {
+	let sizes = Object.create(null);
+	for (const module of modules) {
+		for (const type of module.getSourceTypes()) {
+			sizes[type] = (sizes[type] || 0) + module.size(type);
+		}
+	}
+	return sizes;
+};
 
-  return new RegExp(reStr, flags);
+/**
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {boolean} true, if a is always a parent of b
+ */
+const isAvailableChunk = (a, b) => {
+	const queue = new Set(b.groupsIterable);
+	for (const chunkGroup of queue) {
+		if (a.isInGroup(chunkGroup)) continue;
+		if (chunkGroup.isInitial()) return false;
+		for (const parent of chunkGroup.parentsIterable) {
+			queue.add(parent);
+		}
+	}
+	return true;
 };
 
+class ChunkGraphModule {
+	constructor() {
+		/** @type {SortableSet<Chunk>} */
+		this.chunks = new SortableSet();
+		/** @type {Set<Chunk> | undefined} */
+		this.entryInChunks = undefined;
+		/** @type {Set<Chunk> | undefined} */
+		this.runtimeInChunks = undefined;
+		/** @type {RuntimeSpecMap<ModuleHashInfo>} */
+		this.hashes = undefined;
+		/** @type {string | number} */
+		this.id = null;
+		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
+		this.runtimeRequirements = undefined;
+		/** @type {RuntimeSpecMap<string>} */
+		this.graphHashes = undefined;
+		/** @type {RuntimeSpecMap<string>} */
+		this.graphHashesWithConnections = undefined;
+	}
+}
 
-/***/ }),
+class ChunkGraphChunk {
+	constructor() {
+		/** @type {SortableSet<Module>} */
+		this.modules = new SortableSet();
+		/** @type {Map<Module, Entrypoint>} */
+		this.entryModules = new Map();
+		/** @type {SortableSet<RuntimeModule>} */
+		this.runtimeModules = new SortableSet();
+		/** @type {Set<RuntimeModule> | undefined} */
+		this.fullHashModules = undefined;
+		/** @type {Set<RuntimeModule> | undefined} */
+		this.dependentHashModules = undefined;
+		/** @type {Set<string> | undefined} */
+		this.runtimeRequirements = undefined;
+		/** @type {Set<string>} */
+		this.runtimeRequirementsInTree = new Set();
+	}
+}
 
-/***/ 89132:
-/***/ (function(module) {
+class ChunkGraph {
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string | Hash} hashFunction the hash function to use
+	 */
+	constructor(moduleGraph, hashFunction = "md4") {
+		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
+		this._modules = new WeakMap();
+		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
+		this._chunks = new WeakMap();
+		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
+		this._blockChunkGroups = new WeakMap();
+		/** @private @type {Map<string, string | number>} */
+		this._runtimeIds = new Map();
+		/** @type {ModuleGraph} */
+		this.moduleGraph = moduleGraph;
 
-"use strict";
+		this._hashFunction = hashFunction;
 
+		this._getGraphRoots = this._getGraphRoots.bind(this);
+	}
 
-module.exports = clone
+	/**
+	 * @private
+	 * @param {Module} module the module
+	 * @returns {ChunkGraphModule} internal module
+	 */
+	_getChunkGraphModule(module) {
+		let cgm = this._modules.get(module);
+		if (cgm === undefined) {
+			cgm = new ChunkGraphModule();
+			this._modules.set(module, cgm);
+		}
+		return cgm;
+	}
 
-var getPrototypeOf = Object.getPrototypeOf || function (obj) {
-  return obj.__proto__
-}
+	/**
+	 * @private
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ChunkGraphChunk} internal chunk
+	 */
+	_getChunkGraphChunk(chunk) {
+		let cgc = this._chunks.get(chunk);
+		if (cgc === undefined) {
+			cgc = new ChunkGraphChunk();
+			this._chunks.set(chunk, cgc);
+		}
+		return cgc;
+	}
 
-function clone (obj) {
-  if (obj === null || typeof obj !== 'object')
-    return obj
+	/**
+	 * @param {SortableSet<Module>} set the sortable Set to get the roots of
+	 * @returns {Module[]} the graph roots
+	 */
+	_getGraphRoots(set) {
+		const { moduleGraph } = this;
+		return Array.from(
+			findGraphRoots(set, module => {
+				/** @type {Set<Module>} */
+				const set = new Set();
+				const addDependencies = module => {
+					for (const connection of moduleGraph.getOutgoingConnections(module)) {
+						if (!connection.module) continue;
+						const activeState = connection.getActiveState(undefined);
+						if (activeState === false) continue;
+						if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
+							addDependencies(connection.module);
+							continue;
+						}
+						set.add(connection.module);
+					}
+				};
+				addDependencies(module);
+				return set;
+			})
+		).sort(compareModulesByIdentifier);
+	}
 
-  if (obj instanceof Object)
-    var copy = { __proto__: getPrototypeOf(obj) }
-  else
-    var copy = Object.create(null)
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	connectChunkAndModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgm.chunks.add(chunk);
+		cgc.modules.add(module);
+	}
 
-  Object.getOwnPropertyNames(obj).forEach(function (key) {
-    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
-  })
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	disconnectChunkAndModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgc.modules.delete(module);
+		cgm.chunks.delete(chunk);
+	}
 
-  return copy
-}
+	/**
+	 * @param {Chunk} chunk the chunk which will be disconnected
+	 * @returns {void}
+	 */
+	disconnectChunk(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of cgc.modules) {
+			const cgm = this._getChunkGraphModule(module);
+			cgm.chunks.delete(chunk);
+		}
+		cgc.modules.clear();
+		chunk.disconnectFromGroups();
+		ChunkGraph.clearChunkGraphForChunk(chunk);
+	}
 
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<Module>} modules the modules
+	 * @returns {void}
+	 */
+	attachModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of modules) {
+			cgc.modules.add(module);
+		}
+	}
 
-/***/ }),
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the runtime modules
+	 * @returns {void}
+	 */
+	attachRuntimeModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of modules) {
+			cgc.runtimeModules.add(module);
+		}
+	}
 
-/***/ 90552:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
+	 * @returns {void}
+	 */
+	attachFullHashModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
+		for (const module of modules) {
+			cgc.fullHashModules.add(module);
+		}
+	}
 
-var fs = __webpack_require__(57147)
-var polyfills = __webpack_require__(11290)
-var legacy = __webpack_require__(54410)
-var clone = __webpack_require__(89132)
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
+	 * @returns {void}
+	 */
+	attachDependentHashModules(chunk, modules) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined)
+			cgc.dependentHashModules = new Set();
+		for (const module of modules) {
+			cgc.dependentHashModules.add(module);
+		}
+	}
 
-var util = __webpack_require__(73837)
+	/**
+	 * @param {Module} oldModule the replaced module
+	 * @param {Module} newModule the replacing module
+	 * @returns {void}
+	 */
+	replaceModule(oldModule, newModule) {
+		const oldCgm = this._getChunkGraphModule(oldModule);
+		const newCgm = this._getChunkGraphModule(newModule);
 
-/* istanbul ignore next - node 0.x polyfill */
-var gracefulQueue
-var previousSymbol
+		for (const chunk of oldCgm.chunks) {
+			const cgc = this._getChunkGraphChunk(chunk);
+			cgc.modules.delete(oldModule);
+			cgc.modules.add(newModule);
+			newCgm.chunks.add(chunk);
+		}
+		oldCgm.chunks.clear();
 
-/* istanbul ignore else - node 0.x polyfill */
-if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
-  gracefulQueue = Symbol.for('graceful-fs.queue')
-  // This is used in testing by future versions
-  previousSymbol = Symbol.for('graceful-fs.previous')
-} else {
-  gracefulQueue = '___graceful-fs.queue'
-  previousSymbol = '___graceful-fs.previous'
-}
+		if (oldCgm.entryInChunks !== undefined) {
+			if (newCgm.entryInChunks === undefined) {
+				newCgm.entryInChunks = new Set();
+			}
+			for (const chunk of oldCgm.entryInChunks) {
+				const cgc = this._getChunkGraphChunk(chunk);
+				const old = cgc.entryModules.get(oldModule);
+				/** @type {Map<Module, Entrypoint>} */
+				const newEntryModules = new Map();
+				for (const [m, cg] of cgc.entryModules) {
+					if (m === oldModule) {
+						newEntryModules.set(newModule, old);
+					} else {
+						newEntryModules.set(m, cg);
+					}
+				}
+				cgc.entryModules = newEntryModules;
+				newCgm.entryInChunks.add(chunk);
+			}
+			oldCgm.entryInChunks = undefined;
+		}
 
-function noop () {}
+		if (oldCgm.runtimeInChunks !== undefined) {
+			if (newCgm.runtimeInChunks === undefined) {
+				newCgm.runtimeInChunks = new Set();
+			}
+			for (const chunk of oldCgm.runtimeInChunks) {
+				const cgc = this._getChunkGraphChunk(chunk);
+				cgc.runtimeModules.delete(/** @type {RuntimeModule} */ (oldModule));
+				cgc.runtimeModules.add(/** @type {RuntimeModule} */ (newModule));
+				newCgm.runtimeInChunks.add(chunk);
+				if (
+					cgc.fullHashModules !== undefined &&
+					cgc.fullHashModules.has(/** @type {RuntimeModule} */ (oldModule))
+				) {
+					cgc.fullHashModules.delete(/** @type {RuntimeModule} */ (oldModule));
+					cgc.fullHashModules.add(/** @type {RuntimeModule} */ (newModule));
+				}
+				if (
+					cgc.dependentHashModules !== undefined &&
+					cgc.dependentHashModules.has(/** @type {RuntimeModule} */ (oldModule))
+				) {
+					cgc.dependentHashModules.delete(
+						/** @type {RuntimeModule} */ (oldModule)
+					);
+					cgc.dependentHashModules.add(
+						/** @type {RuntimeModule} */ (newModule)
+					);
+				}
+			}
+			oldCgm.runtimeInChunks = undefined;
+		}
+	}
 
-function publishQueue(context, queue) {
-  Object.defineProperty(context, gracefulQueue, {
-    get: function() {
-      return queue
-    }
-  })
-}
+	/**
+	 * @param {Module} module the checked module
+	 * @param {Chunk} chunk the checked chunk
+	 * @returns {boolean} true, if the chunk contains the module
+	 */
+	isModuleInChunk(module, chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.has(module);
+	}
 
-var debug = noop
-if (util.debuglog)
-  debug = util.debuglog('gfs4')
-else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
-  debug = function() {
-    var m = util.format.apply(util, arguments)
-    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
-    console.error(m)
-  }
+	/**
+	 * @param {Module} module the checked module
+	 * @param {ChunkGroup} chunkGroup the checked chunk group
+	 * @returns {boolean} true, if the chunk contains the module
+	 */
+	isModuleInChunkGroup(module, chunkGroup) {
+		for (const chunk of chunkGroup.chunks) {
+			if (this.isModuleInChunk(module, chunk)) return true;
+		}
+		return false;
+	}
 
-// Once time initialization
-if (!fs[gracefulQueue]) {
-  // This queue can be shared by multiple loaded instances
-  var queue = global[gracefulQueue] || []
-  publishQueue(fs, queue)
+	/**
+	 * @param {Module} module the checked module
+	 * @returns {boolean} true, if the module is entry of any chunk
+	 */
+	isEntryModule(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.entryInChunks !== undefined;
+	}
 
-  // Patch fs.close/closeSync to shared queue version, because we need
-  // to retry() whenever a close happens *anywhere* in the program.
-  // This is essential when multiple graceful-fs instances are
-  // in play at the same time.
-  fs.close = (function (fs$close) {
-    function close (fd, cb) {
-      return fs$close.call(fs, fd, function (err) {
-        // This function uses the graceful-fs shared queue
-        if (!err) {
-          resetQueue()
-        }
-
-        if (typeof cb === 'function')
-          cb.apply(this, arguments)
-      })
-    }
+	/**
+	 * @param {Module} module the module
+	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
+	 */
+	getModuleChunksIterable(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks;
+	}
 
-    Object.defineProperty(close, previousSymbol, {
-      value: fs$close
-    })
-    return close
-  })(fs.close)
+	/**
+	 * @param {Module} module the module
+	 * @param {function(Chunk, Chunk): -1|0|1} sortFn sort function
+	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
+	 */
+	getOrderedModuleChunksIterable(module, sortFn) {
+		const cgm = this._getChunkGraphModule(module);
+		cgm.chunks.sortWith(sortFn);
+		return cgm.chunks;
+	}
 
-  fs.closeSync = (function (fs$closeSync) {
-    function closeSync (fd) {
-      // This function uses the graceful-fs shared queue
-      fs$closeSync.apply(fs, arguments)
-      resetQueue()
-    }
+	/**
+	 * @param {Module} module the module
+	 * @returns {Chunk[]} array of chunks (cached, do not modify)
+	 */
+	getModuleChunks(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks.getFromCache(getArray);
+	}
 
-    Object.defineProperty(closeSync, previousSymbol, {
-      value: fs$closeSync
-    })
-    return closeSync
-  })(fs.closeSync)
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the number of chunk which contain the module
+	 */
+	getNumberOfModuleChunks(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks.size;
+	}
 
-  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
-    process.on('exit', function() {
-      debug(fs[gracefulQueue])
-      __webpack_require__(39491).equal(fs[gracefulQueue].length, 0)
-    })
-  }
-}
+	/**
+	 * @param {Module} module the module
+	 * @returns {RuntimeSpecSet} runtimes
+	 */
+	getModuleRuntimes(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
+	}
 
-if (!global[gracefulQueue]) {
-  publishQueue(global, fs[gracefulQueue]);
-}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the number of modules which are contained in this chunk
+	 */
+	getNumberOfChunkModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.size;
+	}
 
-module.exports = patch(clone(fs))
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-    module.exports = patch(fs)
-    fs.__patched = true;
-}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the number of full hash modules which are contained in this chunk
+	 */
+	getNumberOfChunkFullHashModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size;
+	}
 
-function patch (fs) {
-  // Everything that references the open() function needs to be in here
-  polyfills(fs)
-  fs.gracefulify = patch
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Module>} return the modules for this chunk
+	 */
+	getChunkModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules;
+	}
 
-  fs.createReadStream = createReadStream
-  fs.createWriteStream = createWriteStream
-  var fs$readFile = fs.readFile
-  fs.readFile = readFile
-  function readFile (path, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} sourceType source type
+	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
+	 */
+	getChunkModulesIterableBySourceType(chunk, sourceType) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const modulesWithSourceType = cgc.modules
+			.getFromUnorderedCache(modulesBySourceType)
+			.get(sourceType);
+		return modulesWithSourceType;
+	}
 
-    return go$readFile(path, options, cb)
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @returns {Iterable<Module>} return the modules for this chunk
+	 */
+	getOrderedChunkModulesIterable(chunk, comparator) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgc.modules.sortWith(comparator);
+		return cgc.modules;
+	}
 
-    function go$readFile (path, options, cb, startTime) {
-      return fs$readFile(path, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} sourceType source type
+	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
+	 */
+	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const modulesWithSourceType = cgc.modules
+			.getFromUnorderedCache(modulesBySourceType)
+			.get(sourceType);
+		if (modulesWithSourceType === undefined) return undefined;
+		modulesWithSourceType.sortWith(comparator);
+		return modulesWithSourceType;
+	}
 
-  var fs$writeFile = fs.writeFile
-  fs.writeFile = writeFile
-  function writeFile (path, data, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
+	 */
+	getChunkModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(getArray);
+	}
 
-    return go$writeFile(path, data, options, cb)
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {function(Module, Module): -1|0|1} comparator comparator function
+	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
+	 */
+	getOrderedChunkModules(chunk, comparator) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const arrayFunction = createOrderedArrayFunction(comparator);
+		return cgc.modules.getFromUnorderedCache(arrayFunction);
+	}
 
-    function go$writeFile (path, data, options, cb, startTime) {
-      return fs$writeFile(path, data, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @param {boolean} includeAllChunks all chunks or only async chunks
+	 * @returns {Record<string|number, (string|number)[]>} chunk to module ids object
+	 */
+	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
+		/** @type {Record<string|number, (string|number)[]>} */
+		const chunkModuleIdMap = Object.create(null);
 
-  var fs$appendFile = fs.appendFile
-  if (fs$appendFile)
-    fs.appendFile = appendFile
-  function appendFile (path, data, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+		for (const asyncChunk of includeAllChunks
+			? chunk.getAllReferencedChunks()
+			: chunk.getAllAsyncChunks()) {
+			/** @type {(string|number)[]} */
+			let array;
+			for (const module of this.getOrderedChunkModulesIterable(
+				asyncChunk,
+				compareModulesById(this)
+			)) {
+				if (filterFn(module)) {
+					if (array === undefined) {
+						array = [];
+						chunkModuleIdMap[asyncChunk.id] = array;
+					}
+					const moduleId = this.getModuleId(module);
+					array.push(moduleId);
+				}
+			}
+		}
 
-    return go$appendFile(path, data, options, cb)
+		return chunkModuleIdMap;
+	}
 
-    function go$appendFile (path, data, options, cb, startTime) {
-      return fs$appendFile(path, data, options, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
+	 * @param {number} hashLength length of the hash
+	 * @param {boolean} includeAllChunks all chunks or only async chunks
+	 * @returns {Record<string|number, Record<string|number, string>>} chunk to module id to module hash object
+	 */
+	getChunkModuleRenderedHashMap(
+		chunk,
+		filterFn,
+		hashLength = 0,
+		includeAllChunks = false
+	) {
+		/** @type {Record<string|number, Record<string|number, string>>} */
+		const chunkModuleHashMap = Object.create(null);
 
-  var fs$copyFile = fs.copyFile
-  if (fs$copyFile)
-    fs.copyFile = copyFile
-  function copyFile (src, dest, flags, cb) {
-    if (typeof flags === 'function') {
-      cb = flags
-      flags = 0
-    }
-    return go$copyFile(src, dest, flags, cb)
+		for (const asyncChunk of includeAllChunks
+			? chunk.getAllReferencedChunks()
+			: chunk.getAllAsyncChunks()) {
+			/** @type {Record<string|number, string>} */
+			let idToHashMap;
+			for (const module of this.getOrderedChunkModulesIterable(
+				asyncChunk,
+				compareModulesById(this)
+			)) {
+				if (filterFn(module)) {
+					if (idToHashMap === undefined) {
+						idToHashMap = Object.create(null);
+						chunkModuleHashMap[asyncChunk.id] = idToHashMap;
+					}
+					const moduleId = this.getModuleId(module);
+					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
+					idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
+				}
+			}
+		}
 
-    function go$copyFile (src, dest, flags, cb, startTime) {
-      return fs$copyFile(src, dest, flags, function (err) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+		return chunkModuleHashMap;
+	}
 
-  var fs$readdir = fs.readdir
-  fs.readdir = readdir
-  function readdir (path, options, cb) {
-    if (typeof options === 'function')
-      cb = options, options = null
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
+	 * @returns {Record<string|number, boolean>} chunk map
+	 */
+	getChunkConditionMap(chunk, filterFn) {
+		const map = Object.create(null);
+		for (const c of chunk.getAllReferencedChunks()) {
+			map[c.id] = filterFn(c, this);
+		}
+		return map;
+	}
 
-    return go$readdir(path, options, cb)
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
+	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
+	 * @returns {boolean} return true if module exists in graph
+	 */
+	hasModuleInGraph(chunk, filterFn, filterChunkFn) {
+		const queue = new Set(chunk.groupsIterable);
+		const chunksProcessed = new Set();
 
-    function go$readdir (path, options, cb, startTime) {
-      return fs$readdir(path, options, function (err, files) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$readdir, [path, options, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (files && files.sort)
-            files.sort()
+		for (const chunkGroup of queue) {
+			for (const innerChunk of chunkGroup.chunks) {
+				if (!chunksProcessed.has(innerChunk)) {
+					chunksProcessed.add(innerChunk);
+					if (!filterChunkFn || filterChunkFn(innerChunk, this)) {
+						for (const module of this.getChunkModulesIterable(innerChunk)) {
+							if (filterFn(module)) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+			for (const child of chunkGroup.childrenIterable) {
+				queue.add(child);
+			}
+		}
+		return false;
+	}
 
-          if (typeof cb === 'function')
-            cb.call(this, err, files)
-        }
-      })
-    }
-  }
+	/**
+	 * @param {Chunk} chunkA first chunk
+	 * @param {Chunk} chunkB second chunk
+	 * @returns {-1|0|1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
+	 */
+	compareChunks(chunkA, chunkB) {
+		const cgcA = this._getChunkGraphChunk(chunkA);
+		const cgcB = this._getChunkGraphChunk(chunkB);
+		if (cgcA.modules.size > cgcB.modules.size) return -1;
+		if (cgcA.modules.size < cgcB.modules.size) return 1;
+		cgcA.modules.sortWith(compareModulesByIdentifier);
+		cgcB.modules.sortWith(compareModulesByIdentifier);
+		return compareModuleIterables(cgcA.modules, cgcB.modules);
+	}
 
-  if (process.version.substr(0, 4) === 'v0.8') {
-    var legStreams = legacy(fs)
-    ReadStream = legStreams.ReadStream
-    WriteStream = legStreams.WriteStream
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} total size of all modules in the chunk
+	 */
+	getChunkModulesSize(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(getModulesSize);
+	}
 
-  var fs$ReadStream = fs.ReadStream
-  if (fs$ReadStream) {
-    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
-    ReadStream.prototype.open = ReadStream$open
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Record<string, number>} total sizes of all modules in the chunk by source type
+	 */
+	getChunkModulesSizes(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(getModulesSizes);
+	}
 
-  var fs$WriteStream = fs.WriteStream
-  if (fs$WriteStream) {
-    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
-    WriteStream.prototype.open = WriteStream$open
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Module[]} root modules of the chunks (ordered by identifier)
+	 */
+	getChunkRootModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.modules.getFromUnorderedCache(this._getGraphRoots);
+	}
 
-  Object.defineProperty(fs, 'ReadStream', {
-    get: function () {
-      return ReadStream
-    },
-    set: function (val) {
-      ReadStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
-  Object.defineProperty(fs, 'WriteStream', {
-    get: function () {
-      return WriteStream
-    },
-    set: function (val) {
-      WriteStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of the chunk
+	 */
+	getChunkSize(chunk, options = {}) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const modulesSize = cgc.modules.getFromUnorderedCache(getModulesSize);
+		const chunkOverhead =
+			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
+		const entryChunkMultiplicator =
+			typeof options.entryChunkMultiplicator === "number"
+				? options.entryChunkMultiplicator
+				: 10;
+		return (
+			chunkOverhead +
+			modulesSize * (chunk.canBeInitial() ? entryChunkMultiplicator : 1)
+		);
+	}
 
-  // legacy names
-  var FileReadStream = ReadStream
-  Object.defineProperty(fs, 'FileReadStream', {
-    get: function () {
-      return FileReadStream
-    },
-    set: function (val) {
-      FileReadStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
-  var FileWriteStream = WriteStream
-  Object.defineProperty(fs, 'FileWriteStream', {
-    get: function () {
-      return FileWriteStream
-    },
-    set: function (val) {
-      FileWriteStream = val
-    },
-    enumerable: true,
-    configurable: true
-  })
+	/**
+	 * @param {Chunk} chunkA chunk
+	 * @param {Chunk} chunkB chunk
+	 * @param {ChunkSizeOptions} options options object
+	 * @returns {number} total size of the chunk or false if chunks can't be integrated
+	 */
+	getIntegratedChunksSize(chunkA, chunkB, options = {}) {
+		const cgcA = this._getChunkGraphChunk(chunkA);
+		const cgcB = this._getChunkGraphChunk(chunkB);
+		const allModules = new Set(cgcA.modules);
+		for (const m of cgcB.modules) allModules.add(m);
+		let modulesSize = getModulesSize(allModules);
+		const chunkOverhead =
+			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
+		const entryChunkMultiplicator =
+			typeof options.entryChunkMultiplicator === "number"
+				? options.entryChunkMultiplicator
+				: 10;
+		return (
+			chunkOverhead +
+			modulesSize *
+				(chunkA.canBeInitial() || chunkB.canBeInitial()
+					? entryChunkMultiplicator
+					: 1)
+		);
+	}
 
-  function ReadStream (path, options) {
-    if (this instanceof ReadStream)
-      return fs$ReadStream.apply(this, arguments), this
-    else
-      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
-  }
-
-  function ReadStream$open () {
-    var that = this
-    open(that.path, that.flags, that.mode, function (err, fd) {
-      if (err) {
-        if (that.autoClose)
-          that.destroy()
-
-        that.emit('error', err)
-      } else {
-        that.fd = fd
-        that.emit('open', fd)
-        that.read()
-      }
-    })
-  }
+	/**
+	 * @param {Chunk} chunkA chunk
+	 * @param {Chunk} chunkB chunk
+	 * @returns {boolean} true, if chunks could be integrated
+	 */
+	canChunksBeIntegrated(chunkA, chunkB) {
+		if (chunkA.preventIntegration || chunkB.preventIntegration) {
+			return false;
+		}
 
-  function WriteStream (path, options) {
-    if (this instanceof WriteStream)
-      return fs$WriteStream.apply(this, arguments), this
-    else
-      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
-  }
+		const hasRuntimeA = chunkA.hasRuntime();
+		const hasRuntimeB = chunkB.hasRuntime();
 
-  function WriteStream$open () {
-    var that = this
-    open(that.path, that.flags, that.mode, function (err, fd) {
-      if (err) {
-        that.destroy()
-        that.emit('error', err)
-      } else {
-        that.fd = fd
-        that.emit('open', fd)
-      }
-    })
-  }
+		if (hasRuntimeA !== hasRuntimeB) {
+			if (hasRuntimeA) {
+				return isAvailableChunk(chunkA, chunkB);
+			} else if (hasRuntimeB) {
+				return isAvailableChunk(chunkB, chunkA);
+			} else {
+				return false;
+			}
+		}
 
-  function createReadStream (path, options) {
-    return new fs.ReadStream(path, options)
-  }
+		if (
+			this.getNumberOfEntryModules(chunkA) > 0 ||
+			this.getNumberOfEntryModules(chunkB) > 0
+		) {
+			return false;
+		}
 
-  function createWriteStream (path, options) {
-    return new fs.WriteStream(path, options)
-  }
+		return true;
+	}
 
-  var fs$open = fs.open
-  fs.open = open
-  function open (path, flags, mode, cb) {
-    if (typeof mode === 'function')
-      cb = mode, mode = null
+	/**
+	 * @param {Chunk} chunkA the target chunk
+	 * @param {Chunk} chunkB the chunk to integrate
+	 * @returns {void}
+	 */
+	integrateChunks(chunkA, chunkB) {
+		// Decide for one name (deterministic)
+		if (chunkA.name && chunkB.name) {
+			if (
+				this.getNumberOfEntryModules(chunkA) > 0 ===
+				this.getNumberOfEntryModules(chunkB) > 0
+			) {
+				// When both chunks have entry modules or none have one, use
+				// shortest name
+				if (chunkA.name.length !== chunkB.name.length) {
+					chunkA.name =
+						chunkA.name.length < chunkB.name.length ? chunkA.name : chunkB.name;
+				} else {
+					chunkA.name = chunkA.name < chunkB.name ? chunkA.name : chunkB.name;
+				}
+			} else if (this.getNumberOfEntryModules(chunkB) > 0) {
+				// Pick the name of the chunk with the entry module
+				chunkA.name = chunkB.name;
+			}
+		} else if (chunkB.name) {
+			chunkA.name = chunkB.name;
+		}
 
-    return go$open(path, flags, mode, cb)
+		// Merge id name hints
+		for (const hint of chunkB.idNameHints) {
+			chunkA.idNameHints.add(hint);
+		}
 
-    function go$open (path, flags, mode, cb, startTime) {
-      return fs$open(path, flags, mode, function (err, fd) {
-        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
-          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
-        else {
-          if (typeof cb === 'function')
-            cb.apply(this, arguments)
-        }
-      })
-    }
-  }
+		// Merge runtime
+		chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime);
 
-  return fs
-}
+		// getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
+		for (const module of this.getChunkModules(chunkB)) {
+			this.disconnectChunkAndModule(chunkB, module);
+			this.connectChunkAndModule(chunkA, module);
+		}
 
-function enqueue (elem) {
-  debug('ENQUEUE', elem[0].name, elem[1])
-  fs[gracefulQueue].push(elem)
-  retry()
-}
+		for (const [module, chunkGroup] of Array.from(
+			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
+		)) {
+			this.disconnectChunkAndEntryModule(chunkB, module);
+			this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
+		}
 
-// keep track of the timeout between retry() calls
-var retryTimer
+		for (const chunkGroup of chunkB.groupsIterable) {
+			chunkGroup.replaceChunk(chunkB, chunkA);
+			chunkA.addGroup(chunkGroup);
+			chunkB.removeGroup(chunkGroup);
+		}
+		ChunkGraph.clearChunkGraphForChunk(chunkB);
+	}
 
-// reset the startTime and lastTime to now
-// this resets the start of the 60 second overall timeout as well as the
-// delay between attempts so that we'll retry these jobs sooner
-function resetQueue () {
-  var now = Date.now()
-  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
-    // entries that are only a length of 2 are from an older version, don't
-    // bother modifying those since they'll be retried anyway.
-    if (fs[gracefulQueue][i].length > 2) {
-      fs[gracefulQueue][i][3] = now // startTime
-      fs[gracefulQueue][i][4] = now // lastTime
-    }
-  }
-  // call retry to make sure we're actively processing the queue
-  retry()
-}
+	/**
+	 * @param {Chunk} chunk the chunk to upgrade
+	 * @returns {void}
+	 */
+	upgradeDependentToFullHashModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined) return;
+		if (cgc.fullHashModules === undefined) {
+			cgc.fullHashModules = cgc.dependentHashModules;
+		} else {
+			for (const m of cgc.dependentHashModules) {
+				cgc.fullHashModules.add(m);
+			}
+			cgc.dependentHashModules = undefined;
+		}
+	}
 
-function retry () {
-  // clear the timer and remove it to help prevent unintended concurrency
-  clearTimeout(retryTimer)
-  retryTimer = undefined
+	/**
+	 * @param {Module} module the checked module
+	 * @param {Chunk} chunk the checked chunk
+	 * @returns {boolean} true, if the chunk contains the module as entry
+	 */
+	isEntryModuleInChunk(module, chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules.has(module);
+	}
 
-  if (fs[gracefulQueue].length === 0)
-    return
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {Module} module the entry module
+	 * @param {Entrypoint=} entrypoint the chunk group which must be loaded before the module is executed
+	 * @returns {void}
+	 */
+	connectChunkAndEntryModule(chunk, module, entrypoint) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgm.entryInChunks === undefined) {
+			cgm.entryInChunks = new Set();
+		}
+		cgm.entryInChunks.add(chunk);
+		cgc.entryModules.set(module, entrypoint);
+	}
 
-  var elem = fs[gracefulQueue].shift()
-  var fn = elem[0]
-  var args = elem[1]
-  // these items may be unset if they were added by an older graceful-fs
-  var err = elem[2]
-  var startTime = elem[3]
-  var lastTime = elem[4]
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the runtime module
+	 * @returns {void}
+	 */
+	connectChunkAndRuntimeModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgm.runtimeInChunks === undefined) {
+			cgm.runtimeInChunks = new Set();
+		}
+		cgm.runtimeInChunks.add(chunk);
+		cgc.runtimeModules.add(module);
+	}
 
-  // if we don't have a startTime we have no way of knowing if we've waited
-  // long enough, so go ahead and retry this item now
-  if (startTime === undefined) {
-    debug('RETRY', fn.name, args)
-    fn.apply(null, args)
-  } else if (Date.now() - startTime >= 60000) {
-    // it's been more than 60 seconds total, bail now
-    debug('TIMEOUT', fn.name, args)
-    var cb = args.pop()
-    if (typeof cb === 'function')
-      cb.call(null, err)
-  } else {
-    // the amount of time between the last attempt and right now
-    var sinceAttempt = Date.now() - lastTime
-    // the amount of time between when we first tried, and when we last tried
-    // rounded up to at least 1
-    var sinceStart = Math.max(lastTime - startTime, 1)
-    // backoff. wait longer than the total time we've been retrying, but only
-    // up to a maximum of 100ms
-    var desiredDelay = Math.min(sinceStart * 1.2, 100)
-    // it's been long enough since the last retry, do it again
-    if (sinceAttempt >= desiredDelay) {
-      debug('RETRY', fn.name, args)
-      fn.apply(null, args.concat([startTime]))
-    } else {
-      // if we can't do this job yet, push it to the end of the queue
-      // and let the next iteration check again
-      fs[gracefulQueue].push(elem)
-    }
-  }
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the module that require a full hash
+	 * @returns {void}
+	 */
+	addFullHashModuleToChunk(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
+		cgc.fullHashModules.add(module);
+	}
 
-  // schedule our next run if one isn't already scheduled
-  if (retryTimer === undefined) {
-    retryTimer = setTimeout(retry, 0)
-  }
-}
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the module that require a full hash
+	 * @returns {void}
+	 */
+	addDependentHashModuleToChunk(chunk, module) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		if (cgc.dependentHashModules === undefined)
+			cgc.dependentHashModules = new Set();
+		cgc.dependentHashModules.add(module);
+	}
 
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {Module} module the entry module
+	 * @returns {void}
+	 */
+	disconnectChunkAndEntryModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgm.entryInChunks.delete(chunk);
+		if (cgm.entryInChunks.size === 0) {
+			cgm.entryInChunks = undefined;
+		}
+		cgc.entryModules.delete(module);
+	}
 
-/***/ }),
+	/**
+	 * @param {Chunk} chunk the new chunk
+	 * @param {RuntimeModule} module the runtime module
+	 * @returns {void}
+	 */
+	disconnectChunkAndRuntimeModule(chunk, module) {
+		const cgm = this._getChunkGraphModule(module);
+		const cgc = this._getChunkGraphChunk(chunk);
+		cgm.runtimeInChunks.delete(chunk);
+		if (cgm.runtimeInChunks.size === 0) {
+			cgm.runtimeInChunks = undefined;
+		}
+		cgc.runtimeModules.delete(module);
+	}
 
-/***/ 54410:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Module} module the entry module, it will no longer be entry
+	 * @returns {void}
+	 */
+	disconnectEntryModule(module) {
+		const cgm = this._getChunkGraphModule(module);
+		for (const chunk of cgm.entryInChunks) {
+			const cgc = this._getChunkGraphChunk(chunk);
+			cgc.entryModules.delete(module);
+		}
+		cgm.entryInChunks = undefined;
+	}
 
-var Stream = (__webpack_require__(12781).Stream)
+	/**
+	 * @param {Chunk} chunk the chunk, for which all entries will be removed
+	 * @returns {void}
+	 */
+	disconnectEntries(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const module of cgc.entryModules.keys()) {
+			const cgm = this._getChunkGraphModule(module);
+			cgm.entryInChunks.delete(chunk);
+			if (cgm.entryInChunks.size === 0) {
+				cgm.entryInChunks = undefined;
+			}
+		}
+		cgc.entryModules.clear();
+	}
 
-module.exports = legacy
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the amount of entry modules in chunk
+	 */
+	getNumberOfEntryModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules.size;
+	}
 
-function legacy (fs) {
-  return {
-    ReadStream: ReadStream,
-    WriteStream: WriteStream
-  }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {number} the amount of entry modules in chunk
+	 */
+	getNumberOfRuntimeModules(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.runtimeModules.size;
+	}
 
-  function ReadStream (path, options) {
-    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Module>} iterable of modules (do not modify)
+	 */
+	getChunkEntryModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules.keys();
+	}
 
-    Stream.call(this);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<Chunk>} iterable of chunks
+	 */
+	getChunkEntryDependentChunksIterable(chunk) {
+		/** @type {Set<Chunk>} */
+		const set = new Set();
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (chunkGroup instanceof Entrypoint) {
+				const entrypointChunk = chunkGroup.getEntrypointChunk();
+				const cgc = this._getChunkGraphChunk(entrypointChunk);
+				for (const chunkGroup of cgc.entryModules.values()) {
+					for (const c of chunkGroup.chunks) {
+						if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+							set.add(c);
+						}
+					}
+				}
+			}
+		}
 
-    var self = this;
+		return set;
+	}
 
-    this.path = path;
-    this.fd = null;
-    this.readable = true;
-    this.paused = false;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {boolean} true, when it has dependent chunks
+	 */
+	hasChunkEntryDependentChunks(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		for (const chunkGroup of cgc.entryModules.values()) {
+			for (const c of chunkGroup.chunks) {
+				if (c !== chunk) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
 
-    this.flags = 'r';
-    this.mode = 438; /*=0666*/
-    this.bufferSize = 64 * 1024;
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule>} iterable of modules (do not modify)
+	 */
+	getChunkRuntimeModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.runtimeModules;
+	}
 
-    options = options || {};
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {RuntimeModule[]} array of modules in order of execution
+	 */
+	getChunkRuntimeModulesInOrder(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const array = Array.from(cgc.runtimeModules);
+		array.sort(
+			concatComparators(
+				compareSelect(
+					/**
+					 * @param {RuntimeModule} r runtime module
+					 * @returns {number=} stage
+					 */
+					r => r.stage,
+					compareIds
+				),
+				compareModulesByIdentifier
+			)
+		);
+		return array;
+	}
 
-    // Mixin options into this
-    var keys = Object.keys(options);
-    for (var index = 0, length = keys.length; index < length; index++) {
-      var key = keys[index];
-      this[key] = options[key];
-    }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
+	 */
+	getChunkFullHashModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules;
+	}
 
-    if (this.encoding) this.setEncoding(this.encoding);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<RuntimeModule> | undefined} set of modules (do not modify)
+	 */
+	getChunkFullHashModulesSet(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.fullHashModules;
+	}
 
-    if (this.start !== undefined) {
-      if ('number' !== typeof this.start) {
-        throw TypeError('start must be a Number');
-      }
-      if (this.end === undefined) {
-        this.end = Infinity;
-      } else if ('number' !== typeof this.end) {
-        throw TypeError('end must be a Number');
-      }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
+	 */
+	getChunkDependentHashModulesIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.dependentHashModules;
+	}
 
-      if (this.start > this.end) {
-        throw new Error('start must be <= end');
-      }
+	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
 
-      this.pos = this.start;
-    }
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {Iterable<EntryModuleWithChunkGroup>} iterable of modules (do not modify)
+	 */
+	getChunkEntryModulesWithChunkGroupIterable(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.entryModules;
+	}
 
-    if (this.fd !== null) {
-      process.nextTick(function() {
-        self._read();
-      });
-      return;
-    }
-
-    fs.open(this.path, this.flags, this.mode, function (err, fd) {
-      if (err) {
-        self.emit('error', err);
-        self.readable = false;
-        return;
-      }
+	/**
+	 * @param {AsyncDependenciesBlock} depBlock the async block
+	 * @returns {ChunkGroup} the chunk group
+	 */
+	getBlockChunkGroup(depBlock) {
+		return this._blockChunkGroups.get(depBlock);
+	}
 
-      self.fd = fd;
-      self.emit('open', fd);
-      self._read();
-    })
-  }
+	/**
+	 * @param {AsyncDependenciesBlock} depBlock the async block
+	 * @param {ChunkGroup} chunkGroup the chunk group
+	 * @returns {void}
+	 */
+	connectBlockAndChunkGroup(depBlock, chunkGroup) {
+		this._blockChunkGroups.set(depBlock, chunkGroup);
+		chunkGroup.addBlock(depBlock);
+	}
 
-  function WriteStream (path, options) {
-    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+	/**
+	 * @param {ChunkGroup} chunkGroup the chunk group
+	 * @returns {void}
+	 */
+	disconnectChunkGroup(chunkGroup) {
+		for (const block of chunkGroup.blocksIterable) {
+			this._blockChunkGroups.delete(block);
+		}
+		// TODO refactor by moving blocks list into ChunkGraph
+		chunkGroup._blocks.clear();
+	}
 
-    Stream.call(this);
+	/**
+	 * @param {Module} module the module
+	 * @returns {string | number} the id of the module
+	 */
+	getModuleId(module) {
+		const cgm = this._getChunkGraphModule(module);
+		return cgm.id;
+	}
 
-    this.path = path;
-    this.fd = null;
-    this.writable = true;
+	/**
+	 * @param {Module} module the module
+	 * @param {string | number} id the id of the module
+	 * @returns {void}
+	 */
+	setModuleId(module, id) {
+		const cgm = this._getChunkGraphModule(module);
+		cgm.id = id;
+	}
 
-    this.flags = 'w';
-    this.encoding = 'binary';
-    this.mode = 438; /*=0666*/
-    this.bytesWritten = 0;
+	/**
+	 * @param {string} runtime runtime
+	 * @returns {string | number} the id of the runtime
+	 */
+	getRuntimeId(runtime) {
+		return this._runtimeIds.get(runtime);
+	}
 
-    options = options || {};
+	/**
+	 * @param {string} runtime runtime
+	 * @param {string | number} id the id of the runtime
+	 * @returns {void}
+	 */
+	setRuntimeId(runtime, id) {
+		this._runtimeIds.set(runtime, id);
+	}
 
-    // Mixin options into this
-    var keys = Object.keys(options);
-    for (var index = 0, length = keys.length; index < length; index++) {
-      var key = keys[index];
-      this[key] = options[key];
-    }
+	/**
+	 * @template T
+	 * @param {Module} module the module
+	 * @param {RuntimeSpecMap<T>} hashes hashes data
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {T} hash
+	 */
+	_getModuleHashInfo(module, hashes, runtime) {
+		if (!hashes) {
+			throw new Error(
+				`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
+					runtime
+				)} (hashes not set at all)`
+			);
+		} else if (runtime === undefined) {
+			const hashInfoItems = new Set(hashes.values());
+			if (hashInfoItems.size !== 1) {
+				throw new Error(
+					`No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
+						hashes.keys(),
+						r => runtimeToString(r)
+					).join(", ")}).
+Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
+				);
+			}
+			return first(hashInfoItems);
+		} else {
+			const hashInfo = hashes.get(runtime);
+			if (!hashInfo) {
+				throw new Error(
+					`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
+						runtime
+					)} (available runtimes ${Array.from(
+						hashes.keys(),
+						runtimeToString
+					).join(", ")})`
+				);
+			}
+			return hashInfo;
+		}
+	}
 
-    if (this.start !== undefined) {
-      if ('number' !== typeof this.start) {
-        throw TypeError('start must be a Number');
-      }
-      if (this.start < 0) {
-        throw new Error('start must be >= zero');
-      }
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, if the module has hashes for this runtime
+	 */
+	hasModuleHashes(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return hashes && hashes.has(runtime);
+	}
 
-      this.pos = this.start;
-    }
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
+	 */
+	getModuleHash(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return this._getModuleHashInfo(module, hashes, runtime).hash;
+	}
 
-    this.busy = false;
-    this._queue = [];
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
+	 */
+	getRenderedModuleHash(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const hashes = cgm.hashes;
+		return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
+	}
 
-    if (this.fd === null) {
-      this._open = fs.open;
-      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
-      this.flush();
-    }
-  }
-}
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {string} hash the full hash
+	 * @param {string} renderedHash the shortened hash for rendering
+	 * @returns {void}
+	 */
+	setModuleHashes(module, runtime, hash, renderedHash) {
+		const cgm = this._getChunkGraphModule(module);
+		if (cgm.hashes === undefined) {
+			cgm.hashes = new RuntimeSpecMap();
+		}
+		cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash));
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
+	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
+	 * @returns {void}
+	 */
+	addModuleRuntimeRequirements(
+		module,
+		runtime,
+		items,
+		transferOwnership = true
+	) {
+		const cgm = this._getChunkGraphModule(module);
+		const runtimeRequirementsMap = cgm.runtimeRequirements;
+		if (runtimeRequirementsMap === undefined) {
+			const map = new RuntimeSpecMap();
+			// TODO avoid cloning item and track ownership instead
+			map.set(runtime, transferOwnership ? items : new Set(items));
+			cgm.runtimeRequirements = map;
+			return;
+		}
+		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
+			if (runtimeRequirements === undefined) {
+				return transferOwnership ? items : new Set(items);
+			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
+				for (const item of items) runtimeRequirements.add(item);
+				return runtimeRequirements;
+			} else {
+				for (const item of runtimeRequirements) items.add(item);
+				return items;
+			}
+		});
+	}
 
-/***/ }),
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
+	 * @returns {void}
+	 */
+	addChunkRuntimeRequirements(chunk, items) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const runtimeRequirements = cgc.runtimeRequirements;
+		if (runtimeRequirements === undefined) {
+			cgc.runtimeRequirements = items;
+		} else if (runtimeRequirements.size >= items.size) {
+			for (const item of items) runtimeRequirements.add(item);
+		} else {
+			for (const item of runtimeRequirements) items.add(item);
+			cgc.runtimeRequirements = items;
+		}
+	}
 
-/***/ 11290:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Iterable<string>} items runtime requirements to be added
+	 * @returns {void}
+	 */
+	addTreeRuntimeRequirements(chunk, items) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const runtimeRequirements = cgc.runtimeRequirementsInTree;
+		for (const item of items) runtimeRequirements.add(item);
+	}
 
-var constants = __webpack_require__(22057)
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ReadonlySet<string>} runtime requirements
+	 */
+	getModuleRuntimeRequirements(module, runtime) {
+		const cgm = this._getChunkGraphModule(module);
+		const runtimeRequirements =
+			cgm.runtimeRequirements && cgm.runtimeRequirements.get(runtime);
+		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
+	}
 
-var origCwd = process.cwd
-var cwd = null
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<string>} runtime requirements
+	 */
+	getChunkRuntimeRequirements(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		const runtimeRequirements = cgc.runtimeRequirements;
+		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
+	}
 
-var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {boolean} withConnections include connections
+	 * @returns {string} hash
+	 */
+	getModuleGraphHash(module, runtime, withConnections = true) {
+		const cgm = this._getChunkGraphModule(module);
+		return withConnections
+			? this._getModuleGraphHashWithConnections(cgm, module, runtime)
+			: this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
+	}
 
-process.cwd = function() {
-  if (!cwd)
-    cwd = origCwd.call(process)
-  return cwd
-}
-try {
-  process.cwd()
-} catch (er) {}
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {boolean} withConnections include connections
+	 * @returns {bigint} hash
+	 */
+	getModuleGraphHashBigInt(module, runtime, withConnections = true) {
+		const cgm = this._getChunkGraphModule(module);
+		return withConnections
+			? BigInt(
+					`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`
+			  )
+			: this._getModuleGraphHashBigInt(cgm, module, runtime);
+	}
 
-// This check is needed until node.js 12 is required
-if (typeof process.chdir === 'function') {
-  var chdir = process.chdir
-  process.chdir = function (d) {
-    cwd = null
-    chdir.call(process, d)
-  }
-  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
-}
+	/**
+	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {bigint} hash as big int
+	 */
+	_getModuleGraphHashBigInt(cgm, module, runtime) {
+		if (cgm.graphHashes === undefined) {
+			cgm.graphHashes = new RuntimeSpecMap();
+		}
+		const graphHash = cgm.graphHashes.provide(runtime, () => {
+			const hash = createHash(this._hashFunction);
+			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
+			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
+			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
+		});
+		return graphHash;
+	}
 
-module.exports = patch
+	/**
+	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} hash
+	 */
+	_getModuleGraphHashWithConnections(cgm, module, runtime) {
+		if (cgm.graphHashesWithConnections === undefined) {
+			cgm.graphHashesWithConnections = new RuntimeSpecMap();
+		}
+		const activeStateToString = state => {
+			if (state === false) return "F";
+			if (state === true) return "T";
+			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
+			throw new Error("Not implemented active state");
+		};
+		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
+		return cgm.graphHashesWithConnections.provide(runtime, () => {
+			const graphHash = this._getModuleGraphHashBigInt(
+				cgm,
+				module,
+				runtime
+			).toString(16);
+			const connections = this.moduleGraph.getOutgoingConnections(module);
+			/** @type {Set<Module>} */
+			const activeNamespaceModules = new Set();
+			/** @type {Map<string, Module | Set<Module>>} */
+			const connectedModules = new Map();
+			const processConnection = (connection, stateInfo) => {
+				const module = connection.module;
+				stateInfo += module.getExportsType(this.moduleGraph, strict);
+				// cspell:word Tnamespace
+				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
+				else {
+					const oldModule = connectedModules.get(stateInfo);
+					if (oldModule === undefined) {
+						connectedModules.set(stateInfo, module);
+					} else if (oldModule instanceof Set) {
+						oldModule.add(module);
+					} else if (oldModule !== module) {
+						connectedModules.set(stateInfo, new Set([oldModule, module]));
+					}
+				}
+			};
+			if (runtime === undefined || typeof runtime === "string") {
+				for (const connection of connections) {
+					const state = connection.getActiveState(runtime);
+					if (state === false) continue;
+					processConnection(connection, state === true ? "T" : "O");
+				}
+			} else {
+				// cspell:word Tnamespace
+				for (const connection of connections) {
+					const states = new Set();
+					let stateInfo = "";
+					forEachRuntime(
+						runtime,
+						runtime => {
+							const state = connection.getActiveState(runtime);
+							states.add(state);
+							stateInfo += activeStateToString(state) + runtime;
+						},
+						true
+					);
+					if (states.size === 1) {
+						const state = first(states);
+						if (state === false) continue;
+						stateInfo = activeStateToString(state);
+					}
+					processConnection(connection, stateInfo);
+				}
+			}
+			// cspell:word Tnamespace
+			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
+				return graphHash;
+			const connectedModulesInOrder =
+				connectedModules.size > 1
+					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
+					: connectedModules;
+			const hash = createHash(this._hashFunction);
+			const addModuleToHash = module => {
+				hash.update(
+					this._getModuleGraphHashBigInt(
+						this._getChunkGraphModule(module),
+						module,
+						runtime
+					).toString(16)
+				);
+			};
+			const addModulesToHash = modules => {
+				let xor = ZERO_BIG_INT;
+				for (const m of modules) {
+					xor =
+						xor ^
+						this._getModuleGraphHashBigInt(
+							this._getChunkGraphModule(m),
+							m,
+							runtime
+						);
+				}
+				hash.update(xor.toString(16));
+			};
+			if (activeNamespaceModules.size === 1)
+				addModuleToHash(activeNamespaceModules.values().next().value);
+			else if (activeNamespaceModules.size > 1)
+				addModulesToHash(activeNamespaceModules);
+			for (const [stateInfo, modules] of connectedModulesInOrder) {
+				hash.update(stateInfo);
+				if (modules instanceof Set) {
+					addModulesToHash(modules);
+				} else {
+					addModuleToHash(modules);
+				}
+			}
+			hash.update(graphHash);
+			return /** @type {string} */ (hash.digest("hex"));
+		});
+	}
 
-function patch (fs) {
-  // (re-)implement some things that are known busted or missing.
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {ReadonlySet<string>} runtime requirements
+	 */
+	getTreeRuntimeRequirements(chunk) {
+		const cgc = this._getChunkGraphChunk(chunk);
+		return cgc.runtimeRequirementsInTree;
+	}
 
-  // lchmod, broken prior to 0.6.2
-  // back-port the fix here.
-  if (constants.hasOwnProperty('O_SYMLINK') &&
-      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-    patchLchmod(fs)
-  }
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @param {string} deprecateMessage message for the deprecation message
+	 * @param {string} deprecationCode code for the deprecation
+	 * @returns {ChunkGraph} the chunk graph
+	 */
+	static getChunkGraphForModule(module, deprecateMessage, deprecationCode) {
+		const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage);
+		if (fn) return fn(module);
+		const newFn = util.deprecate(
+			/**
+			 * @param {Module} module the module
+			 * @returns {ChunkGraph} the chunk graph
+			 */
+			module => {
+				const chunkGraph = chunkGraphForModuleMap.get(module);
+				if (!chunkGraph)
+					throw new Error(
+						deprecateMessage +
+							": There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)"
+					);
+				return chunkGraph;
+			},
+			deprecateMessage + ": Use new ChunkGraph API",
+			deprecationCode
+		);
+		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
+		return newFn(module);
+	}
 
-  // lutimes implementation, or no-op
-  if (!fs.lutimes) {
-    patchLutimes(fs)
-  }
-
-  // https://github.com/isaacs/node-graceful-fs/issues/4
-  // Chown should not fail on einval or eperm if non-root.
-  // It should not fail on enosys ever, as this just indicates
-  // that a fs doesn't support the intended operation.
-
-  fs.chown = chownFix(fs.chown)
-  fs.fchown = chownFix(fs.fchown)
-  fs.lchown = chownFix(fs.lchown)
-
-  fs.chmod = chmodFix(fs.chmod)
-  fs.fchmod = chmodFix(fs.fchmod)
-  fs.lchmod = chmodFix(fs.lchmod)
-
-  fs.chownSync = chownFixSync(fs.chownSync)
-  fs.fchownSync = chownFixSync(fs.fchownSync)
-  fs.lchownSync = chownFixSync(fs.lchownSync)
-
-  fs.chmodSync = chmodFixSync(fs.chmodSync)
-  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
-  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	static setChunkGraphForModule(module, chunkGraph) {
+		chunkGraphForModuleMap.set(module, chunkGraph);
+	}
 
-  fs.stat = statFix(fs.stat)
-  fs.fstat = statFix(fs.fstat)
-  fs.lstat = statFix(fs.lstat)
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	static clearChunkGraphForModule(module) {
+		chunkGraphForModuleMap.delete(module);
+	}
 
-  fs.statSync = statFixSync(fs.statSync)
-  fs.fstatSync = statFixSync(fs.fstatSync)
-  fs.lstatSync = statFixSync(fs.lstatSync)
+	// TODO remove in webpack 6
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} deprecateMessage message for the deprecation message
+	 * @param {string} deprecationCode code for the deprecation
+	 * @returns {ChunkGraph} the chunk graph
+	 */
+	static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) {
+		const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage);
+		if (fn) return fn(chunk);
+		const newFn = util.deprecate(
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @returns {ChunkGraph} the chunk graph
+			 */
+			chunk => {
+				const chunkGraph = chunkGraphForChunkMap.get(chunk);
+				if (!chunkGraph)
+					throw new Error(
+						deprecateMessage +
+							"There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)"
+					);
+				return chunkGraph;
+			},
+			deprecateMessage + ": Use new ChunkGraph API",
+			deprecationCode
+		);
+		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);
+		return newFn(chunk);
+	}
 
-  // if lchmod/lchown do not exist, then make them no-ops
-  if (!fs.lchmod) {
-    fs.lchmod = function (path, mode, cb) {
-      if (cb) process.nextTick(cb)
-    }
-    fs.lchmodSync = function () {}
-  }
-  if (!fs.lchown) {
-    fs.lchown = function (path, uid, gid, cb) {
-      if (cb) process.nextTick(cb)
-    }
-    fs.lchownSync = function () {}
-  }
+	// TODO remove in webpack 6
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	static setChunkGraphForChunk(chunk, chunkGraph) {
+		chunkGraphForChunkMap.set(chunk, chunkGraph);
+	}
 
-  // on Windows, A/V software can lock the directory, causing this
-  // to fail with an EACCES or EPERM if the directory contains newly
-  // created files.  Try again on failure, for up to 60 seconds.
+	// TODO remove in webpack 6
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @returns {void}
+	 */
+	static clearChunkGraphForChunk(chunk) {
+		chunkGraphForChunkMap.delete(chunk);
+	}
+}
 
-  // Set the timeout this long because some Windows Anti-Virus, such as Parity
-  // bit9, may lock files for up to a minute, causing npm package install
-  // failures. Also, take care to yield the scheduler. Windows scheduling gives
-  // CPU to a busy looping process, which can cause the program causing the lock
-  // contention to be starved of CPU by node, so the contention doesn't resolve.
-  if (platform === "win32") {
-    fs.rename = (function (fs$rename) { return function (from, to, cb) {
-      var start = Date.now()
-      var backoff = 0;
-      fs$rename(from, to, function CB (er) {
-        if (er
-            && (er.code === "EACCES" || er.code === "EPERM")
-            && Date.now() - start < 60000) {
-          setTimeout(function() {
-            fs.stat(to, function (stater, st) {
-              if (stater && stater.code === "ENOENT")
-                fs$rename(from, to, CB);
-              else
-                cb(er)
-            })
-          }, backoff)
-          if (backoff < 100)
-            backoff += 10;
-          return;
-        }
-        if (cb) cb(er)
-      })
-    }})(fs.rename)
-  }
+// TODO remove in webpack 6
+/** @type {WeakMap<Module, ChunkGraph>} */
+const chunkGraphForModuleMap = new WeakMap();
 
-  // if read() returns EAGAIN, then just try it again.
-  fs.read = (function (fs$read) {
-    function read (fd, buffer, offset, length, position, callback_) {
-      var callback
-      if (callback_ && typeof callback_ === 'function') {
-        var eagCounter = 0
-        callback = function (er, _, __) {
-          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
-            eagCounter ++
-            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-          }
-          callback_.apply(this, arguments)
-        }
-      }
-      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
-    }
+// TODO remove in webpack 6
+/** @type {WeakMap<Chunk, ChunkGraph>} */
+const chunkGraphForChunkMap = new WeakMap();
 
-    // This ensures `util.promisify` works as it does for native `fs.read`.
-    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
-    return read
-  })(fs.read)
+// TODO remove in webpack 6
+/** @type {Map<string, (module: Module) => ChunkGraph>} */
+const deprecateGetChunkGraphForModuleMap = new Map();
 
-  fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
-    var eagCounter = 0
-    while (true) {
-      try {
-        return fs$readSync.call(fs, fd, buffer, offset, length, position)
-      } catch (er) {
-        if (er.code === 'EAGAIN' && eagCounter < 10) {
-          eagCounter ++
-          continue
-        }
-        throw er
-      }
-    }
-  }})(fs.readSync)
+// TODO remove in webpack 6
+/** @type {Map<string, (chunk: Chunk) => ChunkGraph>} */
+const deprecateGetChunkGraphForChunkMap = new Map();
 
-  function patchLchmod (fs) {
-    fs.lchmod = function (path, mode, callback) {
-      fs.open( path
-             , constants.O_WRONLY | constants.O_SYMLINK
-             , mode
-             , function (err, fd) {
-        if (err) {
-          if (callback) callback(err)
-          return
-        }
-        // prefer to return the chmod error, if one occurs,
-        // but still try to close, and report closing errors if they occur.
-        fs.fchmod(fd, mode, function (err) {
-          fs.close(fd, function(err2) {
-            if (callback) callback(err || err2)
-          })
-        })
-      })
-    }
+module.exports = ChunkGraph;
 
-    fs.lchmodSync = function (path, mode) {
-      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
 
-      // prefer to return the chmod error, if one occurs,
-      // but still try to close, and report closing errors if they occur.
-      var threw = true
-      var ret
-      try {
-        ret = fs.fchmodSync(fd, mode)
-        threw = false
-      } finally {
-        if (threw) {
-          try {
-            fs.closeSync(fd)
-          } catch (er) {}
-        } else {
-          fs.closeSync(fd)
-        }
-      }
-      return ret
-    }
-  }
+/***/ }),
 
-  function patchLutimes (fs) {
-    if (constants.hasOwnProperty("O_SYMLINK")) {
-      fs.lutimes = function (path, at, mt, cb) {
-        fs.open(path, constants.O_SYMLINK, function (er, fd) {
-          if (er) {
-            if (cb) cb(er)
-            return
-          }
-          fs.futimes(fd, at, mt, function (er) {
-            fs.close(fd, function (er2) {
-              if (cb) cb(er || er2)
-            })
-          })
-        })
-      }
+/***/ 15626:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-      fs.lutimesSync = function (path, at, mt) {
-        var fd = fs.openSync(path, constants.O_SYMLINK)
-        var ret
-        var threw = true
-        try {
-          ret = fs.futimesSync(fd, at, mt)
-          threw = false
-        } finally {
-          if (threw) {
-            try {
-              fs.closeSync(fd)
-            } catch (er) {}
-          } else {
-            fs.closeSync(fd)
-          }
-        }
-        return ret
-      }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    } else {
-      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
-      fs.lutimesSync = function () {}
-    }
-  }
 
-  function chmodFix (orig) {
-    if (!orig) return orig
-    return function (target, mode, cb) {
-      return orig.call(fs, target, mode, function (er) {
-        if (chownErOk(er)) er = null
-        if (cb) cb.apply(this, arguments)
-      })
-    }
-  }
 
-  function chmodFixSync (orig) {
-    if (!orig) return orig
-    return function (target, mode) {
-      try {
-        return orig.call(fs, target, mode)
-      } catch (er) {
-        if (!chownErOk(er)) throw er
-      }
-    }
-  }
+const util = __webpack_require__(73837);
+const SortableSet = __webpack_require__(13098);
+const {
+	compareLocations,
+	compareChunks,
+	compareIterables
+} = __webpack_require__(29579);
 
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
 
-  function chownFix (orig) {
-    if (!orig) return orig
-    return function (target, uid, gid, cb) {
-      return orig.call(fs, target, uid, gid, function (er) {
-        if (chownErOk(er)) er = null
-        if (cb) cb.apply(this, arguments)
-      })
-    }
-  }
+/** @typedef {{id: number}} HasId */
+/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */
 
-  function chownFixSync (orig) {
-    if (!orig) return orig
-    return function (target, uid, gid) {
-      try {
-        return orig.call(fs, target, uid, gid)
-      } catch (er) {
-        if (!chownErOk(er)) throw er
-      }
-    }
-  }
+/**
+ * @typedef {Object} RawChunkGroupOptions
+ * @property {number=} preloadOrder
+ * @property {number=} prefetchOrder
+ */
 
-  function statFix (orig) {
-    if (!orig) return orig
-    // Older versions of Node erroneously returned signed integers for
-    // uid + gid.
-    return function (target, options, cb) {
-      if (typeof options === 'function') {
-        cb = options
-        options = null
-      }
-      function callback (er, stats) {
-        if (stats) {
-          if (stats.uid < 0) stats.uid += 0x100000000
-          if (stats.gid < 0) stats.gid += 0x100000000
-        }
-        if (cb) cb.apply(this, arguments)
-      }
-      return options ? orig.call(fs, target, options, callback)
-        : orig.call(fs, target, callback)
-    }
-  }
+/** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
 
-  function statFixSync (orig) {
-    if (!orig) return orig
-    // Older versions of Node erroneously returned signed integers for
-    // uid + gid.
-    return function (target, options) {
-      var stats = options ? orig.call(fs, target, options)
-        : orig.call(fs, target)
-      if (stats) {
-        if (stats.uid < 0) stats.uid += 0x100000000
-        if (stats.gid < 0) stats.gid += 0x100000000
-      }
-      return stats;
-    }
-  }
+let debugId = 5000;
 
-  // ENOSYS means that the fs doesn't support the op. Just ignore
-  // that, because it doesn't matter.
-  //
-  // if there's no getuid, or if getuid() is something other
-  // than 0, and the error is EINVAL or EPERM, then just ignore
-  // it.
-  //
-  // This specific case is a silent failure in cp, install, tar,
-  // and most other unix tools that manage permissions.
-  //
-  // When running as root, or if other types of errors are
-  // encountered, then it's strict.
-  function chownErOk (er) {
-    if (!er)
-      return true
+/**
+ * @template T
+ * @param {SortableSet<T>} set set to convert to array.
+ * @returns {T[]} the array format of existing set
+ */
+const getArray = set => Array.from(set);
 
-    if (er.code === "ENOSYS")
-      return true
+/**
+ * A convenience method used to sort chunks based on their id's
+ * @param {ChunkGroup} a first sorting comparator
+ * @param {ChunkGroup} b second sorting comparator
+ * @returns {1|0|-1} a sorting index to determine order
+ */
+const sortById = (a, b) => {
+	if (a.id < b.id) return -1;
+	if (b.id < a.id) return 1;
+	return 0;
+};
 
-    var nonroot = !process.getuid || process.getuid() !== 0
-    if (nonroot) {
-      if (er.code === "EINVAL" || er.code === "EPERM")
-        return true
-    }
+/**
+ * @param {OriginRecord} a the first comparator in sort
+ * @param {OriginRecord} b the second comparator in sort
+ * @returns {1|-1|0} returns sorting order as index
+ */
+const sortOrigin = (a, b) => {
+	const aIdent = a.module ? a.module.identifier() : "";
+	const bIdent = b.module ? b.module.identifier() : "";
+	if (aIdent < bIdent) return -1;
+	if (aIdent > bIdent) return 1;
+	return compareLocations(a.loc, b.loc);
+};
 
-    return false
-  }
-}
+class ChunkGroup {
+	/**
+	 * Creates an instance of ChunkGroup.
+	 * @param {string|ChunkGroupOptions=} options chunk group options passed to chunkGroup
+	 */
+	constructor(options) {
+		if (typeof options === "string") {
+			options = { name: options };
+		} else if (!options) {
+			options = { name: undefined };
+		}
+		/** @type {number} */
+		this.groupDebugId = debugId++;
+		this.options = options;
+		/** @type {SortableSet<ChunkGroup>} */
+		this._children = new SortableSet(undefined, sortById);
+		/** @type {SortableSet<ChunkGroup>} */
+		this._parents = new SortableSet(undefined, sortById);
+		/** @type {SortableSet<ChunkGroup>} */
+		this._asyncEntrypoints = new SortableSet(undefined, sortById);
+		this._blocks = new SortableSet();
+		/** @type {Chunk[]} */
+		this.chunks = [];
+		/** @type {OriginRecord[]} */
+		this.origins = [];
+		/** Indices in top-down order */
+		/** @private @type {Map<Module, number>} */
+		this._modulePreOrderIndices = new Map();
+		/** Indices in bottom-up order */
+		/** @private @type {Map<Module, number>} */
+		this._modulePostOrderIndices = new Map();
+		/** @type {number} */
+		this.index = undefined;
+	}
 
+	/**
+	 * when a new chunk is added to a chunkGroup, addingOptions will occur.
+	 * @param {ChunkGroupOptions} options the chunkGroup options passed to addOptions
+	 * @returns {void}
+	 */
+	addOptions(options) {
+		for (const key of Object.keys(options)) {
+			if (this.options[key] === undefined) {
+				this.options[key] = options[key];
+			} else if (this.options[key] !== options[key]) {
+				if (key.endsWith("Order")) {
+					this.options[key] = Math.max(this.options[key], options[key]);
+				} else {
+					throw new Error(
+						`ChunkGroup.addOptions: No option merge strategy for ${key}`
+					);
+				}
+			}
+		}
+	}
 
-/***/ }),
+	/**
+	 * returns the name of current ChunkGroup
+	 * @returns {string|undefined} returns the ChunkGroup name
+	 */
+	get name() {
+		return this.options.name;
+	}
 
-/***/ 15235:
-/***/ (function(module) {
+	/**
+	 * sets a new name for current ChunkGroup
+	 * @param {string} value the new name for ChunkGroup
+	 * @returns {void}
+	 */
+	set name(value) {
+		this.options.name = value;
+	}
 
-"use strict";
+	/* istanbul ignore next */
+	/**
+	 * get a uniqueId for ChunkGroup, made up of its member Chunk debugId's
+	 * @returns {string} a unique concatenation of chunk debugId's
+	 */
+	get debugId() {
+		return Array.from(this.chunks, x => x.debugId).join("+");
+	}
 
+	/**
+	 * get a unique id for ChunkGroup, made up of its member Chunk id's
+	 * @returns {string} a unique concatenation of chunk ids
+	 */
+	get id() {
+		return Array.from(this.chunks, x => x.id).join("+");
+	}
 
-module.exports = parseJson
-function parseJson (txt, reviver, context) {
-  context = context || 20
-  try {
-    return JSON.parse(txt, reviver)
-  } catch (e) {
-    if (typeof txt !== 'string') {
-      const isEmptyArray = Array.isArray(txt) && txt.length === 0
-      const errorMessage = 'Cannot parse ' +
-      (isEmptyArray ? 'an empty array' : String(txt))
-      throw new TypeError(errorMessage)
-    }
-    const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
-    const errIdx = syntaxErr
-    ? +syntaxErr[1]
-    : e.message.match(/^Unexpected end of JSON.*/i)
-    ? txt.length - 1
-    : null
-    if (errIdx != null) {
-      const start = errIdx <= context
-      ? 0
-      : errIdx - context
-      const end = errIdx + context >= txt.length
-      ? txt.length
-      : errIdx + context
-      e.message += ` while parsing near '${
-        start === 0 ? '' : '...'
-      }${txt.slice(start, end)}${
-        end === txt.length ? '' : '...'
-      }'`
-    } else {
-      e.message += ` while parsing '${txt.slice(0, context * 2)}'`
-    }
-    throw e
-  }
-}
+	/**
+	 * Performs an unshift of a specific chunk
+	 * @param {Chunk} chunk chunk being unshifted
+	 * @returns {boolean} returns true if attempted chunk shift is accepted
+	 */
+	unshiftChunk(chunk) {
+		const oldIdx = this.chunks.indexOf(chunk);
+		if (oldIdx > 0) {
+			this.chunks.splice(oldIdx, 1);
+			this.chunks.unshift(chunk);
+		} else if (oldIdx < 0) {
+			this.chunks.unshift(chunk);
+			return true;
+		}
+		return false;
+	}
 
+	/**
+	 * inserts a chunk before another existing chunk in group
+	 * @param {Chunk} chunk Chunk being inserted
+	 * @param {Chunk} before Placeholder/target chunk marking new chunk insertion point
+	 * @returns {boolean} return true if insertion was successful
+	 */
+	insertChunk(chunk, before) {
+		const oldIdx = this.chunks.indexOf(chunk);
+		const idx = this.chunks.indexOf(before);
+		if (idx < 0) {
+			throw new Error("before chunk not found");
+		}
+		if (oldIdx >= 0 && oldIdx > idx) {
+			this.chunks.splice(oldIdx, 1);
+			this.chunks.splice(idx, 0, chunk);
+		} else if (oldIdx < 0) {
+			this.chunks.splice(idx, 0, chunk);
+			return true;
+		}
+		return false;
+	}
 
-/***/ }),
+	/**
+	 * add a chunk into ChunkGroup. Is pushed on or prepended
+	 * @param {Chunk} chunk chunk being pushed into ChunkGroupS
+	 * @returns {boolean} returns true if chunk addition was successful.
+	 */
+	pushChunk(chunk) {
+		const oldIdx = this.chunks.indexOf(chunk);
+		if (oldIdx >= 0) {
+			return false;
+		}
+		this.chunks.push(chunk);
+		return true;
+	}
 
-/***/ 49448:
-/***/ (function(module) {
+	/**
+	 * @param {Chunk} oldChunk chunk to be replaced
+	 * @param {Chunk} newChunk New chunk that will be replaced with
+	 * @returns {boolean} returns true if the replacement was successful
+	 */
+	replaceChunk(oldChunk, newChunk) {
+		const oldIdx = this.chunks.indexOf(oldChunk);
+		if (oldIdx < 0) return false;
+		const newIdx = this.chunks.indexOf(newChunk);
+		if (newIdx < 0) {
+			this.chunks[oldIdx] = newChunk;
+			return true;
+		}
+		if (newIdx < oldIdx) {
+			this.chunks.splice(oldIdx, 1);
+			return true;
+		} else if (newIdx !== oldIdx) {
+			this.chunks[oldIdx] = newChunk;
+			this.chunks.splice(newIdx, 1);
+			return true;
+		}
+	}
 
-"use strict";
+	/**
+	 * @param {Chunk} chunk chunk to remove
+	 * @returns {boolean} returns true if chunk was removed
+	 */
+	removeChunk(chunk) {
+		const idx = this.chunks.indexOf(chunk);
+		if (idx >= 0) {
+			this.chunks.splice(idx, 1);
+			return true;
+		}
+		return false;
+	}
 
+	/**
+	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
+	 */
+	isInitial() {
+		return false;
+	}
 
-class LoadingLoaderError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "LoaderRunnerError";
-		Error.captureStackTrace(this, this.constructor);
+	/**
+	 * @param {ChunkGroup} group chunk group to add
+	 * @returns {boolean} returns true if chunk group was added
+	 */
+	addChild(group) {
+		const size = this._children.size;
+		this._children.add(group);
+		return size !== this._children.size;
 	}
-}
 
-module.exports = LoadingLoaderError;
+	/**
+	 * @returns {ChunkGroup[]} returns the children of this group
+	 */
+	getChildren() {
+		return this._children.getFromCache(getArray);
+	}
 
+	getNumberOfChildren() {
+		return this._children.size;
+	}
 
-/***/ }),
+	get childrenIterable() {
+		return this._children;
+	}
 
-/***/ 68318:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+	/**
+	 * @param {ChunkGroup} group the chunk group to remove
+	 * @returns {boolean} returns true if the chunk group was removed
+	 */
+	removeChild(group) {
+		if (!this._children.has(group)) {
+			return false;
+		}
 
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-var fs = __webpack_require__(57147);
-var readFile = fs.readFile.bind(fs);
-var loadLoader = __webpack_require__(55102);
+		this._children.delete(group);
+		group.removeParent(this);
+		return true;
+	}
 
-function utf8BufferToString(buf) {
-	var str = buf.toString("utf-8");
-	if(str.charCodeAt(0) === 0xFEFF) {
-		return str.substr(1);
-	} else {
-		return str;
+	/**
+	 * @param {ChunkGroup} parentChunk the parent group to be added into
+	 * @returns {boolean} returns true if this chunk group was added to the parent group
+	 */
+	addParent(parentChunk) {
+		if (!this._parents.has(parentChunk)) {
+			this._parents.add(parentChunk);
+			return true;
+		}
+		return false;
 	}
-}
 
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+	/**
+	 * @returns {ChunkGroup[]} returns the parents of this group
+	 */
+	getParents() {
+		return this._parents.getFromCache(getArray);
+	}
 
-/**
- * @param {string} str the path with query and fragment
- * @returns {{ path: string, query: string, fragment: string }} parsed parts
- */
-function parsePathQueryFragment(str) {
-	var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-	return {
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		fragment: match[3] || ""
-	};
-}
+	getNumberOfParents() {
+		return this._parents.size;
+	}
 
-function dirname(path) {
-	if(path === "/") return "/";
-	var i = path.lastIndexOf("/");
-	var j = path.lastIndexOf("\\");
-	var i2 = path.indexOf("/");
-	var j2 = path.indexOf("\\");
-	var idx = i > j ? i : j;
-	var idx2 = i > j ? i2 : j2;
-	if(idx < 0) return path;
-	if(idx === idx2) return path.substr(0, idx + 1);
-	return path.substr(0, idx);
-}
+	/**
+	 * @param {ChunkGroup} parent the parent group
+	 * @returns {boolean} returns true if the parent group contains this group
+	 */
+	hasParent(parent) {
+		return this._parents.has(parent);
+	}
 
-function createLoaderObject(loader) {
-	var obj = {
-		path: null,
-		query: null,
-		fragment: null,
-		options: null,
-		ident: null,
-		normal: null,
-		pitch: null,
-		raw: null,
-		data: null,
-		pitchExecuted: false,
-		normalExecuted: false
-	};
-	Object.defineProperty(obj, "request", {
-		enumerable: true,
-		get: function() {
-			return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
-		},
-		set: function(value) {
-			if(typeof value === "string") {
-				var splittedRequest = parsePathQueryFragment(value);
-				obj.path = splittedRequest.path;
-				obj.query = splittedRequest.query;
-				obj.fragment = splittedRequest.fragment;
-				obj.options = undefined;
-				obj.ident = undefined;
-			} else {
-				if(!value.loader)
-					throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
-				obj.path = value.loader;
-				obj.fragment = value.fragment || "";
-				obj.type = value.type;
-				obj.options = value.options;
-				obj.ident = value.ident;
-				if(obj.options === null)
-					obj.query = "";
-				else if(obj.options === undefined)
-					obj.query = "";
-				else if(typeof obj.options === "string")
-					obj.query = "?" + obj.options;
-				else if(obj.ident)
-					obj.query = "??" + obj.ident;
-				else if(typeof obj.options === "object" && obj.options.ident)
-					obj.query = "??" + obj.options.ident;
-				else
-					obj.query = "?" + JSON.stringify(obj.options);
-			}
-		}
-	});
-	obj.request = loader;
-	if(Object.preventExtensions) {
-		Object.preventExtensions(obj);
+	get parentsIterable() {
+		return this._parents;
 	}
-	return obj;
-}
 
-function runSyncOrAsync(fn, context, args, callback) {
-	var isSync = true;
-	var isDone = false;
-	var isError = false; // internal error
-	var reportedError = false;
-	context.async = function async() {
-		if(isDone) {
-			if(reportedError) return; // ignore
-			throw new Error("async(): The callback was already called.");
-		}
-		isSync = false;
-		return innerCallback;
-	};
-	var innerCallback = context.callback = function() {
-		if(isDone) {
-			if(reportedError) return; // ignore
-			throw new Error("callback(): The callback was already called.");
-		}
-		isDone = true;
-		isSync = false;
-		try {
-			callback.apply(null, arguments);
-		} catch(e) {
-			isError = true;
-			throw e;
-		}
-	};
-	try {
-		var result = (function LOADER_EXECUTION() {
-			return fn.apply(context, args);
-		}());
-		if(isSync) {
-			isDone = true;
-			if(result === undefined)
-				return callback();
-			if(result && typeof result === "object" && typeof result.then === "function") {
-				return result.then(function(r) {
-					callback(null, r);
-				}, callback);
-			}
-			return callback(null, result);
-		}
-	} catch(e) {
-		if(isError) throw e;
-		if(isDone) {
-			// loader is already "done", so we cannot use the callback function
-			// for better debugging we print the error on the console
-			if(typeof e === "object" && e.stack) console.error(e.stack);
-			else console.error(e);
-			return;
+	/**
+	 * @param {ChunkGroup} chunkGroup the parent group
+	 * @returns {boolean} returns true if this group has been removed from the parent
+	 */
+	removeParent(chunkGroup) {
+		if (this._parents.delete(chunkGroup)) {
+			chunkGroup.removeChild(this);
+			return true;
 		}
-		isDone = true;
-		reportedError = true;
-		callback(e);
+		return false;
 	}
 
-}
-
-function convertArgs(args, raw) {
-	if(!raw && Buffer.isBuffer(args[0]))
-		args[0] = utf8BufferToString(args[0]);
-	else if(raw && typeof args[0] === "string")
-		args[0] = Buffer.from(args[0], "utf-8");
-}
+	/**
+	 * @param {Entrypoint} entrypoint entrypoint to add
+	 * @returns {boolean} returns true if entrypoint was added
+	 */
+	addAsyncEntrypoint(entrypoint) {
+		const size = this._asyncEntrypoints.size;
+		this._asyncEntrypoints.add(entrypoint);
+		return size !== this._asyncEntrypoints.size;
+	}
 
-function iteratePitchingLoaders(options, loaderContext, callback) {
-	// abort after last loader
-	if(loaderContext.loaderIndex >= loaderContext.loaders.length)
-		return processResource(options, loaderContext, callback);
+	get asyncEntrypointsIterable() {
+		return this._asyncEntrypoints;
+	}
 
-	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+	/**
+	 * @returns {Array} an array containing the blocks
+	 */
+	getBlocks() {
+		return this._blocks.getFromCache(getArray);
+	}
 
-	// iterate
-	if(currentLoaderObject.pitchExecuted) {
-		loaderContext.loaderIndex++;
-		return iteratePitchingLoaders(options, loaderContext, callback);
+	getNumberOfBlocks() {
+		return this._blocks.size;
 	}
 
-	// load loader module
-	loadLoader(currentLoaderObject, function(err) {
-		if(err) {
-			loaderContext.cacheable(false);
-			return callback(err);
-		}
-		var fn = currentLoaderObject.pitch;
-		currentLoaderObject.pitchExecuted = true;
-		if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
+	hasBlock(block) {
+		return this._blocks.has(block);
+	}
 
-		runSyncOrAsync(
-			fn,
-			loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
-			function(err) {
-				if(err) return callback(err);
-				var args = Array.prototype.slice.call(arguments, 1);
-				// Determine whether to continue the pitching process based on
-				// argument values (as opposed to argument presence) in order
-				// to support synchronous and asynchronous usages.
-				var hasArg = args.some(function(value) {
-					return value !== undefined;
-				});
-				if(hasArg) {
-					loaderContext.loaderIndex--;
-					iterateNormalLoaders(options, loaderContext, args, callback);
-				} else {
-					iteratePitchingLoaders(options, loaderContext, callback);
-				}
-			}
-		);
-	});
-}
+	/**
+	 * @returns {Iterable<AsyncDependenciesBlock>} blocks
+	 */
+	get blocksIterable() {
+		return this._blocks;
+	}
 
-function processResource(options, loaderContext, callback) {
-	// set loader index to last loader
-	loaderContext.loaderIndex = loaderContext.loaders.length - 1;
+	/**
+	 * @param {AsyncDependenciesBlock} block a block
+	 * @returns {boolean} false, if block was already added
+	 */
+	addBlock(block) {
+		if (!this._blocks.has(block)) {
+			this._blocks.add(block);
+			return true;
+		}
+		return false;
+	}
 
-	var resourcePath = loaderContext.resourcePath;
-	if(resourcePath) {
-		options.processResource(loaderContext, resourcePath, function(err, buffer) {
-			if(err) return callback(err);
-			options.resourceBuffer = buffer;
-			iterateNormalLoaders(options, loaderContext, [buffer], callback);
+	/**
+	 * @param {Module} module origin module
+	 * @param {DependencyLocation} loc location of the reference in the origin module
+	 * @param {string} request request name of the reference
+	 * @returns {void}
+	 */
+	addOrigin(module, loc, request) {
+		this.origins.push({
+			module,
+			loc,
+			request
 		});
-	} else {
-		iterateNormalLoaders(options, loaderContext, [null], callback);
 	}
-}
-
-function iterateNormalLoaders(options, loaderContext, args, callback) {
-	if(loaderContext.loaderIndex < 0)
-		return callback(null, args);
 
-	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+	/**
+	 * @returns {string[]} the files contained this chunk group
+	 */
+	getFiles() {
+		const files = new Set();
 
-	// iterate
-	if(currentLoaderObject.normalExecuted) {
-		loaderContext.loaderIndex--;
-		return iterateNormalLoaders(options, loaderContext, args, callback);
-	}
+		for (const chunk of this.chunks) {
+			for (const file of chunk.files) {
+				files.add(file);
+			}
+		}
 
-	var fn = currentLoaderObject.normal;
-	currentLoaderObject.normalExecuted = true;
-	if(!fn) {
-		return iterateNormalLoaders(options, loaderContext, args, callback);
+		return Array.from(files);
 	}
 
-	convertArgs(args, currentLoaderObject.raw);
+	/**
+	 * @returns {void}
+	 */
+	remove() {
+		// cleanup parents
+		for (const parentChunkGroup of this._parents) {
+			// remove this chunk from its parents
+			parentChunkGroup._children.delete(this);
 
-	runSyncOrAsync(fn, loaderContext, args, function(err) {
-		if(err) return callback(err);
+			// cleanup "sub chunks"
+			for (const chunkGroup of this._children) {
+				/**
+				 * remove this chunk as "intermediary" and connect
+				 * it "sub chunks" and parents directly
+				 */
+				// add parent to each "sub chunk"
+				chunkGroup.addParent(parentChunkGroup);
+				// add "sub chunk" to parent
+				parentChunkGroup.addChild(chunkGroup);
+			}
+		}
 
-		var args = Array.prototype.slice.call(arguments, 1);
-		iterateNormalLoaders(options, loaderContext, args, callback);
-	});
-}
-
-exports.getContext = function getContext(resource) {
-	var path = parsePathQueryFragment(resource).path;
-	return dirname(path);
-};
-
-exports.runLoaders = function runLoaders(options, callback) {
-	// read options
-	var resource = options.resource || "";
-	var loaders = options.loaders || [];
-	var loaderContext = options.context || {};
-	var processResource = options.processResource || ((readResource, context, resource, callback) => {
-		context.addDependency(resource);
-		readResource(resource, callback);
-	}).bind(null, options.readResource || readFile);
-
-	//
-	var splittedResource = resource && parsePathQueryFragment(resource);
-	var resourcePath = splittedResource ? splittedResource.path : undefined;
-	var resourceQuery = splittedResource ? splittedResource.query : undefined;
-	var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
-	var contextDirectory = resourcePath ? dirname(resourcePath) : null;
-
-	// execution state
-	var requestCacheable = true;
-	var fileDependencies = [];
-	var contextDependencies = [];
-	var missingDependencies = [];
-
-	// prepare loader objects
-	loaders = loaders.map(createLoaderObject);
-
-	loaderContext.context = contextDirectory;
-	loaderContext.loaderIndex = 0;
-	loaderContext.loaders = loaders;
-	loaderContext.resourcePath = resourcePath;
-	loaderContext.resourceQuery = resourceQuery;
-	loaderContext.resourceFragment = resourceFragment;
-	loaderContext.async = null;
-	loaderContext.callback = null;
-	loaderContext.cacheable = function cacheable(flag) {
-		if(flag === false) {
-			requestCacheable = false;
-		}
-	};
-	loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
-		fileDependencies.push(file);
-	};
-	loaderContext.addContextDependency = function addContextDependency(context) {
-		contextDependencies.push(context);
-	};
-	loaderContext.addMissingDependency = function addMissingDependency(context) {
-		missingDependencies.push(context);
-	};
-	loaderContext.getDependencies = function getDependencies() {
-		return fileDependencies.slice();
-	};
-	loaderContext.getContextDependencies = function getContextDependencies() {
-		return contextDependencies.slice();
-	};
-	loaderContext.getMissingDependencies = function getMissingDependencies() {
-		return missingDependencies.slice();
-	};
-	loaderContext.clearDependencies = function clearDependencies() {
-		fileDependencies.length = 0;
-		contextDependencies.length = 0;
-		missingDependencies.length = 0;
-		requestCacheable = true;
-	};
-	Object.defineProperty(loaderContext, "resource", {
-		enumerable: true,
-		get: function() {
-			if(loaderContext.resourcePath === undefined)
-				return undefined;
-			return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
-		},
-		set: function(value) {
-			var splittedResource = value && parsePathQueryFragment(value);
-			loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
-			loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
-			loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
-		}
-	});
-	Object.defineProperty(loaderContext, "request", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders.map(function(o) {
-				return o.request;
-			}).concat(loaderContext.resource || "").join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "remainingRequest", {
-		enumerable: true,
-		get: function() {
-			if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
-				return "";
-			return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
-				return o.request;
-			}).concat(loaderContext.resource || "").join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "currentRequest", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
-				return o.request;
-			}).concat(loaderContext.resource || "").join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "previousRequest", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
-				return o.request;
-			}).join("!");
-		}
-	});
-	Object.defineProperty(loaderContext, "query", {
-		enumerable: true,
-		get: function() {
-			var entry = loaderContext.loaders[loaderContext.loaderIndex];
-			return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
+		/**
+		 * we need to iterate again over the children
+		 * to remove this from the child's parents.
+		 * This can not be done in the above loop
+		 * as it is not guaranteed that `this._parents` contains anything.
+		 */
+		for (const chunkGroup of this._children) {
+			// remove this as parent of every "sub chunk"
+			chunkGroup._parents.delete(this);
 		}
-	});
-	Object.defineProperty(loaderContext, "data", {
-		enumerable: true,
-		get: function() {
-			return loaderContext.loaders[loaderContext.loaderIndex].data;
+
+		// remove chunks
+		for (const chunk of this.chunks) {
+			chunk.removeGroup(this);
 		}
-	});
+	}
 
-	// finish loader context
-	if(Object.preventExtensions) {
-		Object.preventExtensions(loaderContext);
+	sortItems() {
+		this.origins.sort(sortOrigin);
 	}
 
-	var processOptions = {
-		resourceBuffer: null,
-		processResource: processResource
-	};
-	iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
-		if(err) {
-			return callback(err, {
-				cacheable: requestCacheable,
-				fileDependencies: fileDependencies,
-				contextDependencies: contextDependencies,
-				missingDependencies: missingDependencies
+	/**
+	 * Sorting predicate which allows current ChunkGroup to be compared against another.
+	 * Sorting values are based off of number of chunks in ChunkGroup.
+	 *
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
+	 * @returns {-1|0|1} sort position for comparison
+	 */
+	compareTo(chunkGraph, otherGroup) {
+		if (this.chunks.length > otherGroup.chunks.length) return -1;
+		if (this.chunks.length < otherGroup.chunks.length) return 1;
+		return compareIterables(compareChunks(chunkGraph))(
+			this.chunks,
+			otherGroup.chunks
+		);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {Record<string, ChunkGroup[]>} mapping from children type to ordered list of ChunkGroups
+	 */
+	getChildrenByOrders(moduleGraph, chunkGraph) {
+		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
+		const lists = new Map();
+		for (const childGroup of this._children) {
+			for (const key of Object.keys(childGroup.options)) {
+				if (key.endsWith("Order")) {
+					const name = key.substr(0, key.length - "Order".length);
+					let list = lists.get(name);
+					if (list === undefined) {
+						lists.set(name, (list = []));
+					}
+					list.push({
+						order: childGroup.options[key],
+						group: childGroup
+					});
+				}
+			}
+		}
+		/** @type {Record<string, ChunkGroup[]>} */
+		const result = Object.create(null);
+		for (const [name, list] of lists) {
+			list.sort((a, b) => {
+				const cmp = b.order - a.order;
+				if (cmp !== 0) return cmp;
+				return a.group.compareTo(chunkGraph, b.group);
 			});
+			result[name] = list.map(i => i.group);
 		}
-		callback(null, {
-			result: result,
-			resourceBuffer: processOptions.resourceBuffer,
-			cacheable: requestCacheable,
-			fileDependencies: fileDependencies,
-			contextDependencies: contextDependencies,
-			missingDependencies: missingDependencies
-		});
-	});
-};
+		return result;
+	}
 
+	/**
+	 * Sets the top-down index of a module in this ChunkGroup
+	 * @param {Module} module module for which the index should be set
+	 * @param {number} index the index of the module
+	 * @returns {void}
+	 */
+	setModulePreOrderIndex(module, index) {
+		this._modulePreOrderIndices.set(module, index);
+	}
 
-/***/ }),
+	/**
+	 * Gets the top-down index of a module in this ChunkGroup
+	 * @param {Module} module the module
+	 * @returns {number} index
+	 */
+	getModulePreOrderIndex(module) {
+		return this._modulePreOrderIndices.get(module);
+	}
 
-/***/ 55102:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * Sets the bottom-up index of a module in this ChunkGroup
+	 * @param {Module} module module for which the index should be set
+	 * @param {number} index the index of the module
+	 * @returns {void}
+	 */
+	setModulePostOrderIndex(module, index) {
+		this._modulePostOrderIndices.set(module, index);
+	}
 
-var LoaderLoadingError = __webpack_require__(49448);
-var url;
+	/**
+	 * Gets the bottom-up index of a module in this ChunkGroup
+	 * @param {Module} module the module
+	 * @returns {number} index
+	 */
+	getModulePostOrderIndex(module) {
+		return this._modulePostOrderIndices.get(module);
+	}
 
-module.exports = function loadLoader(loader, callback) {
-	if(loader.type === "module") {
-		try {
-			if(url === undefined) url = __webpack_require__(57310);
-			var loaderUrl = url.pathToFileURL(loader.path);
-			var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
-			modulePromise.then(function(module) {
-				handleResult(loader, module, callback);
-			}, callback);
-			return;
-		} catch(e) {
-			callback(e);
+	/* istanbul ignore next */
+	checkConstraints() {
+		const chunk = this;
+		for (const child of chunk._children) {
+			if (!child._parents.has(chunk)) {
+				throw new Error(
+					`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`
+				);
+			}
 		}
-	} else {
-		try {
-			var module = require(loader.path);
-		} catch(e) {
-			// it is possible for node to choke on a require if the FD descriptor
-			// limit has been reached. give it a chance to recover.
-			if(e instanceof Error && e.code === "EMFILE") {
-				var retry = loadLoader.bind(null, loader, callback);
-				if(typeof setImmediate === "function") {
-					// node >= 0.9.0
-					return setImmediate(retry);
-				} else {
-					// node < 0.9.0
-					return process.nextTick(retry);
-				}
+		for (const parentChunk of chunk._parents) {
+			if (!parentChunk._children.has(chunk)) {
+				throw new Error(
+					`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`
+				);
 			}
-			return callback(e);
 		}
-		return handleResult(loader, module, callback);
-	}
-};
-
-function handleResult(loader, module, callback) {
-	if(typeof module !== "function" && typeof module !== "object") {
-		return callback(new LoaderLoadingError(
-			"Module '" + loader.path + "' is not a loader (export function or es6 module)"
-		));
-	}
-	loader.normal = typeof module === "function" ? module : module.default;
-	loader.pitch = module.pitch;
-	loader.raw = module.raw;
-	if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
-		return callback(new LoaderLoadingError(
-			"Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
-		));
 	}
-	callback();
 }
 
+ChunkGroup.prototype.getModuleIndex = util.deprecate(
+	ChunkGroup.prototype.getModulePreOrderIndex,
+	"ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex",
+	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX"
+);
 
-/***/ }),
-
-/***/ 54983:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-var __webpack_unused_export__;
-
-
-__webpack_unused_export__ = ({
-  value: true
-});
-exports.Z = void 0;
-
-const {
-  stringHints,
-  numberHints
-} = __webpack_require__(79926);
-/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+ChunkGroup.prototype.getModuleIndex2 = util.deprecate(
+	ChunkGroup.prototype.getModulePostOrderIndex,
+	"ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex",
+	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2"
+);
 
-/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+module.exports = ChunkGroup;
 
-/** @typedef {import("./validate").Schema} Schema */
 
-/** @typedef {import("./validate").ValidationErrorConfiguration} ValidationErrorConfiguration */
+/***/ }),
 
-/** @typedef {import("./validate").PostFormatter} PostFormatter */
+/***/ 918:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/** @typedef {import("./validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/** @enum {number} */
 
 
-const SPECIFICITY = {
-  type: 1,
-  not: 1,
-  oneOf: 1,
-  anyOf: 1,
-  if: 1,
-  enum: 1,
-  const: 1,
-  instanceof: 1,
-  required: 2,
-  pattern: 2,
-  patternRequired: 2,
-  format: 2,
-  formatMinimum: 2,
-  formatMaximum: 2,
-  minimum: 2,
-  exclusiveMinimum: 2,
-  maximum: 2,
-  exclusiveMaximum: 2,
-  multipleOf: 2,
-  uniqueItems: 2,
-  contains: 2,
-  minLength: 2,
-  maxLength: 2,
-  minItems: 2,
-  maxItems: 2,
-  minProperties: 2,
-  maxProperties: 2,
-  dependencies: 2,
-  propertyNames: 2,
-  additionalItems: 2,
-  additionalProperties: 2,
-  absolutePath: 2
-};
-/**
- *
- * @param {Array<SchemaUtilErrorObject>} array
- * @param {(item: SchemaUtilErrorObject) => number} fn
- * @returns {Array<SchemaUtilErrorObject>}
- */
+const WebpackError = __webpack_require__(53799);
 
-function filterMax(array, fn) {
-  const evaluatedMax = array.reduce((max, item) => Math.max(max, fn(item)), 0);
-  return array.filter(item => fn(item) === evaluatedMax);
-}
-/**
- *
- * @param {Array<SchemaUtilErrorObject>} children
- * @returns {Array<SchemaUtilErrorObject>}
- */
+/** @typedef {import("./Chunk")} Chunk */
 
+class ChunkRenderError extends WebpackError {
+	/**
+	 * Create a new ChunkRenderError
+	 * @param {Chunk} chunk A chunk
+	 * @param {string} file Related file
+	 * @param {Error} error Original error
+	 */
+	constructor(chunk, file, error) {
+		super();
 
-function filterChildren(children) {
-  let newChildren = children;
-  newChildren = filterMax(newChildren,
-  /**
-   *
-   * @param {SchemaUtilErrorObject} error
-   * @returns {number}
-   */
-  error => error.dataPath ? error.dataPath.length : 0);
-  newChildren = filterMax(newChildren,
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {number}
-   */
-  error => SPECIFICITY[
-  /** @type {keyof typeof SPECIFICITY} */
-  error.keyword] || 2);
-  return newChildren;
+		this.name = "ChunkRenderError";
+		this.error = error;
+		this.message = error.message;
+		this.details = error.stack;
+		this.file = file;
+		this.chunk = chunk;
+	}
 }
-/**
- * Find all children errors
- * @param {Array<SchemaUtilErrorObject>} children
- * @param {Array<string>} schemaPaths
- * @return {number} returns index of first child
- */
-
 
-function findAllChildren(children, schemaPaths) {
-  let i = children.length - 1;
+module.exports = ChunkRenderError;
 
-  const predicate =
-  /**
-   * @param {string} schemaPath
-   * @returns {boolean}
-   */
-  schemaPath => children[i].schemaPath.indexOf(schemaPath) !== 0;
 
-  while (i > -1 && !schemaPaths.every(predicate)) {
-    if (children[i].keyword === "anyOf" || children[i].keyword === "oneOf") {
-      const refs = extractRefs(children[i]);
-      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(children[i].schemaPath));
-      i = childrenStart - 1;
-    } else {
-      i -= 1;
-    }
-  }
+/***/ }),
 
-  return i + 1;
-}
-/**
- * Extracts all refs from schema
- * @param {SchemaUtilErrorObject} error
- * @return {Array<string>}
- */
+/***/ 46341:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-function extractRefs(error) {
-  const {
-    schema
-  } = error;
 
-  if (!Array.isArray(schema)) {
-    return [];
-  }
 
-  return schema.map(({
-    $ref
-  }) => $ref).filter(s => s);
-}
-/**
- * Groups children by their first level parent (assuming that error is root)
- * @param {Array<SchemaUtilErrorObject>} children
- * @return {Array<SchemaUtilErrorObject>}
- */
+const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
 
+/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./Compilation")} Compilation */
 
-function groupChildrenByFirstChild(children) {
-  const result = [];
-  let i = children.length - 1;
+const getJavascriptModulesPlugin = memoize(() =>
+	__webpack_require__(89464)
+);
 
-  while (i > 0) {
-    const child = children[i];
-
-    if (child.keyword === "anyOf" || child.keyword === "oneOf") {
-      const refs = extractRefs(child);
-      const childrenStart = findAllChildren(children.slice(0, i), refs.concat(child.schemaPath));
-
-      if (childrenStart !== i) {
-        result.push(Object.assign({}, child, {
-          children: children.slice(childrenStart, i)
-        }));
-        i = childrenStart;
-      } else {
-        result.push(child);
-      }
-    } else {
-      result.push(child);
-    }
+// TODO webpack 6 remove this class
+class ChunkTemplate {
+	/**
+	 * @param {OutputOptions} outputOptions output options
+	 * @param {Compilation} compilation the compilation
+	 */
+	constructor(outputOptions, compilation) {
+		this._outputOptions = outputOptions || {};
+		this.hooks = Object.freeze({
+			renderManifest: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.renderManifest.tap(
+							options,
+							(entries, options) => {
+								if (options.chunk.hasRuntime()) return entries;
+								return fn(entries, options);
+							}
+						);
+					},
+					"ChunkTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_MANIFEST"
+				)
+			},
+			modules: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderChunk.tap(options, (source, renderContext) =>
+								fn(
+									source,
+									compilation.moduleTemplates.javascript,
+									renderContext
+								)
+							);
+					},
+					"ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_MODULES"
+				)
+			},
+			render: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderChunk.tap(options, (source, renderContext) =>
+								fn(
+									source,
+									compilation.moduleTemplates.javascript,
+									renderContext
+								)
+							);
+					},
+					"ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER"
+				)
+			},
+			renderWithEntry: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.render.tap(options, (source, renderContext) => {
+								if (
+									renderContext.chunkGraph.getNumberOfEntryModules(
+										renderContext.chunk
+									) === 0 ||
+									renderContext.chunk.hasRuntime()
+								) {
+									return source;
+								}
+								return fn(source, renderContext.chunk);
+							});
+					},
+					"ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY"
+				)
+			},
+			hash: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.fullHash.tap(options, fn);
+					},
+					"ChunkTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH"
+				)
+			},
+			hashForChunk: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.chunkHash.tap(options, (chunk, hash, context) => {
+								if (chunk.hasRuntime()) return;
+								fn(hash, chunk, context);
+							});
+					},
+					"ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
+					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			}
+		});
+	}
+}
 
-    i -= 1;
-  }
+Object.defineProperty(ChunkTemplate.prototype, "outputOptions", {
+	get: util.deprecate(
+		/**
+		 * @this {ChunkTemplate}
+		 * @returns {OutputOptions} output options
+		 */
+		function () {
+			return this._outputOptions;
+		},
+		"ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
+		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
 
-  if (i === 0) {
-    result.push(children[i]);
-  }
+module.exports = ChunkTemplate;
 
-  return result.reverse();
-}
-/**
- * @param {string} str
- * @param {string} prefix
- * @returns {string}
- */
 
+/***/ }),
 
-function indent(str, prefix) {
-  return str.replace(/\n(?!$)/g, `\n${prefix}`);
-}
-/**
- * @param {Schema} schema
- * @returns {schema is (Schema & {not: Schema})}
- */
+/***/ 31085:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
 
-function hasNotInSchema(schema) {
-  return !!schema.not;
-}
-/**
- * @param {Schema} schema
- * @return {Schema}
- */
 
 
-function findFirstTypedSchema(schema) {
-  if (hasNotInSchema(schema)) {
-    return findFirstTypedSchema(schema.not);
-  }
+const asyncLib = __webpack_require__(78175);
+const { SyncBailHook } = __webpack_require__(6967);
+const Compilation = __webpack_require__(85720);
+const createSchemaValidation = __webpack_require__(32540);
+const { join } = __webpack_require__(17139);
+const processAsyncTree = __webpack_require__(42791);
 
-  return schema;
-}
-/**
- * @param {Schema} schema
- * @return {boolean}
- */
+/** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").StatsCallback} StatsCallback */
 
+/** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
+/** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
 
-function canApplyNot(schema) {
-  const typedSchema = findFirstTypedSchema(schema);
-  return likeNumber(typedSchema) || likeInteger(typedSchema) || likeString(typedSchema) || likeNull(typedSchema) || likeBoolean(typedSchema);
-}
 /**
- * @param {any} maybeObj
- * @returns {boolean}
+ * @typedef {Object} CleanPluginCompilationHooks
+ * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
  */
 
+const validate = createSchemaValidation(
+	undefined,
+	() => {
+		const { definitions } = __webpack_require__(73342);
+		return {
+			definitions,
+			oneOf: [{ $ref: "#/definitions/CleanOptions" }]
+		};
+	},
+	{
+		name: "Clean Plugin",
+		baseDataPath: "options"
+	}
+);
 
-function isObject(maybeObj) {
-  return typeof maybeObj === "object" && maybeObj !== null;
-}
 /**
- * @param {Schema} schema
- * @returns {boolean}
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} outputPath output path
+ * @param {Set<string>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
+ * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
+ * @returns {void}
  */
+const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
+	const directories = new Set();
+	// get directories of assets
+	for (const asset of currentAssets) {
+		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
+	}
+	// and all parent directories
+	for (const directory of directories) {
+		directories.add(directory.replace(/(^|\/)[^/]*$/, ""));
+	}
+	const diff = new Set();
+	asyncLib.forEachLimit(
+		directories,
+		10,
+		(directory, callback) => {
+			fs.readdir(join(fs, outputPath, directory), (err, entries) => {
+				if (err) {
+					if (err.code === "ENOENT") return callback();
+					if (err.code === "ENOTDIR") {
+						diff.add(directory);
+						return callback();
+					}
+					return callback(err);
+				}
+				for (const entry of entries) {
+					const file = /** @type {string} */ (entry);
+					const filename = directory ? `${directory}/${file}` : file;
+					if (!directories.has(filename) && !currentAssets.has(filename)) {
+						diff.add(filename);
+					}
+				}
+				callback();
+			});
+		},
+		err => {
+			if (err) return callback(err);
 
+			callback(null, diff);
+		}
+	);
+};
 
-function likeNumber(schema) {
-  return schema.type === "number" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
-}
 /**
- * @param {Schema} schema
- * @returns {boolean}
+ * @param {Set<string>} currentAssets assets list
+ * @param {Set<string>} oldAssets old assets list
+ * @returns {Set<string>} diff
  */
+const getDiffToOldAssets = (currentAssets, oldAssets) => {
+	const diff = new Set();
+	for (const asset of oldAssets) {
+		if (!currentAssets.has(asset)) diff.add(asset);
+	}
+	return diff;
+};
 
-
-function likeInteger(schema) {
-  return schema.type === "integer" || typeof schema.minimum !== "undefined" || typeof schema.exclusiveMinimum !== "undefined" || typeof schema.maximum !== "undefined" || typeof schema.exclusiveMaximum !== "undefined" || typeof schema.multipleOf !== "undefined";
-}
 /**
- * @param {Schema} schema
- * @returns {boolean}
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} filename path to file
+ * @param {StatsCallback} callback callback for provided filename
+ * @returns {void}
  */
+const doStat = (fs, filename, callback) => {
+	if ("lstat" in fs) {
+		fs.lstat(filename, callback);
+	} else {
+		fs.stat(filename, callback);
+	}
+};
 
-
-function likeString(schema) {
-  return schema.type === "string" || typeof schema.minLength !== "undefined" || typeof schema.maxLength !== "undefined" || typeof schema.pattern !== "undefined" || typeof schema.format !== "undefined" || typeof schema.formatMinimum !== "undefined" || typeof schema.formatMaximum !== "undefined";
-}
 /**
- * @param {Schema} schema
- * @returns {boolean}
+ * @param {OutputFileSystem} fs filesystem
+ * @param {string} outputPath output path
+ * @param {boolean} dry only log instead of fs modification
+ * @param {Logger} logger logger
+ * @param {Set<string>} diff filenames of the assets that shouldn't be there
+ * @param {function(string): boolean} isKept check if the entry is ignored
+ * @param {function(Error=): void} callback callback
+ * @returns {void}
  */
+const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
+	const log = msg => {
+		if (dry) {
+			logger.info(msg);
+		} else {
+			logger.log(msg);
+		}
+	};
+	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
+	/** @type {Job[]} */
+	const jobs = Array.from(diff, filename => ({
+		type: "check",
+		filename,
+		parent: undefined
+	}));
+	processAsyncTree(
+		jobs,
+		10,
+		({ type, filename, parent }, push, callback) => {
+			const handleError = err => {
+				if (err.code === "ENOENT") {
+					log(`${filename} was removed during cleaning by something else`);
+					handleParent();
+					return callback();
+				}
+				return callback(err);
+			};
+			const handleParent = () => {
+				if (parent && --parent.remaining === 0) push(parent.job);
+			};
+			const path = join(fs, outputPath, filename);
+			switch (type) {
+				case "check":
+					if (isKept(filename)) {
+						// do not decrement parent entry as we don't want to delete the parent
+						log(`${filename} will be kept`);
+						return process.nextTick(callback);
+					}
+					doStat(fs, path, (err, stats) => {
+						if (err) return handleError(err);
+						if (!stats.isDirectory()) {
+							push({
+								type: "unlink",
+								filename,
+								parent
+							});
+							return callback();
+						}
+						fs.readdir(path, (err, entries) => {
+							if (err) return handleError(err);
+							/** @type {Job} */
+							const deleteJob = {
+								type: "rmdir",
+								filename,
+								parent
+							};
+							if (entries.length === 0) {
+								push(deleteJob);
+							} else {
+								const parentToken = {
+									remaining: entries.length,
+									job: deleteJob
+								};
+								for (const entry of entries) {
+									const file = /** @type {string} */ (entry);
+									if (file.startsWith(".")) {
+										log(
+											`${filename} will be kept (dot-files will never be removed)`
+										);
+										continue;
+									}
+									push({
+										type: "check",
+										filename: `${filename}/${file}`,
+										parent: parentToken
+									});
+								}
+							}
+							return callback();
+						});
+					});
+					break;
+				case "rmdir":
+					log(`${filename} will be removed`);
+					if (dry) {
+						handleParent();
+						return process.nextTick(callback);
+					}
+					if (!fs.rmdir) {
+						logger.warn(
+							`${filename} can't be removed because output file system doesn't support removing directories (rmdir)`
+						);
+						return process.nextTick(callback);
+					}
+					fs.rmdir(path, err => {
+						if (err) return handleError(err);
+						handleParent();
+						callback();
+					});
+					break;
+				case "unlink":
+					log(`${filename} will be removed`);
+					if (dry) {
+						handleParent();
+						return process.nextTick(callback);
+					}
+					if (!fs.unlink) {
+						logger.warn(
+							`${filename} can't be removed because output file system doesn't support removing files (rmdir)`
+						);
+						return process.nextTick(callback);
+					}
+					fs.unlink(path, err => {
+						if (err) return handleError(err);
+						handleParent();
+						callback();
+					});
+					break;
+			}
+		},
+		callback
+	);
+};
 
+/** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-function likeBoolean(schema) {
-  return schema.type === "boolean";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+class CleanPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CleanPluginCompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				/** @type {SyncBailHook<[string], boolean>} */
+				keep: new SyncBailHook(["ignore"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
 
+	/** @param {CleanOptions} options options */
+	constructor(options = {}) {
+		validate(options);
+		this.options = { dry: false, ...options };
+	}
 
-function likeArray(schema) {
-  return schema.type === "array" || typeof schema.minItems === "number" || typeof schema.maxItems === "number" || typeof schema.uniqueItems !== "undefined" || typeof schema.items !== "undefined" || typeof schema.additionalItems !== "undefined" || typeof schema.contains !== "undefined";
-}
-/**
- * @param {Schema & {patternRequired?: Array<string>}} schema
- * @returns {boolean}
- */
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { dry, keep } = this.options;
 
+		const keepFn =
+			typeof keep === "function"
+				? keep
+				: typeof keep === "string"
+				? path => path.startsWith(keep)
+				: typeof keep === "object" && keep.test
+				? path => keep.test(path)
+				: () => false;
 
-function likeObject(schema) {
-  return schema.type === "object" || typeof schema.minProperties !== "undefined" || typeof schema.maxProperties !== "undefined" || typeof schema.required !== "undefined" || typeof schema.properties !== "undefined" || typeof schema.patternProperties !== "undefined" || typeof schema.additionalProperties !== "undefined" || typeof schema.dependencies !== "undefined" || typeof schema.propertyNames !== "undefined" || typeof schema.patternRequired !== "undefined";
-}
-/**
- * @param {Schema} schema
- * @returns {boolean}
- */
+		// We assume that no external modification happens while the compiler is active
+		// So we can store the old assets and only diff to them to avoid fs access on
+		// incremental builds
+		let oldAssets;
 
+		compiler.hooks.emit.tapAsync(
+			{
+				name: "CleanPlugin",
+				stage: 100
+			},
+			(compilation, callback) => {
+				const hooks = CleanPlugin.getCompilationHooks(compilation);
+				const logger = compilation.getLogger("webpack.CleanPlugin");
+				const fs = compiler.outputFileSystem;
 
-function likeNull(schema) {
-  return schema.type === "null";
-}
-/**
- * @param {string} type
- * @returns {string}
- */
+				if (!fs.readdir) {
+					return callback(
+						new Error(
+							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
+						)
+					);
+				}
 
+				const currentAssets = new Set();
+				for (const asset of Object.keys(compilation.assets)) {
+					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
+					let normalizedAsset;
+					let newNormalizedAsset = asset.replace(/\\/g, "/");
+					do {
+						normalizedAsset = newNormalizedAsset;
+						newNormalizedAsset = normalizedAsset.replace(
+							/(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
+							"$1"
+						);
+					} while (newNormalizedAsset !== normalizedAsset);
+					if (normalizedAsset.startsWith("../")) continue;
+					currentAssets.add(normalizedAsset);
+				}
 
-function getArticle(type) {
-  if (/^[aeiou]/i.test(type)) {
-    return "an";
-  }
+				const outputPath = compilation.getPath(compiler.outputPath, {});
 
-  return "a";
-}
-/**
- * @param {Schema=} schema
- * @returns {string}
- */
+				const isKept = path => {
+					const result = hooks.keep.call(path);
+					if (result !== undefined) return result;
+					return keepFn(path);
+				};
 
+				const diffCallback = (err, diff) => {
+					if (err) {
+						oldAssets = undefined;
+						return callback(err);
+					}
+					applyDiff(fs, outputPath, dry, logger, diff, isKept, err => {
+						if (err) {
+							oldAssets = undefined;
+						} else {
+							oldAssets = currentAssets;
+						}
+						callback(err);
+					});
+				};
 
-function getSchemaNonTypes(schema) {
-  if (!schema) {
-    return "";
-  }
+				if (oldAssets) {
+					diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets));
+				} else {
+					getDiffToFs(fs, outputPath, currentAssets, diffCallback);
+				}
+			}
+		);
+	}
+}
 
-  if (!schema.type) {
-    if (likeNumber(schema) || likeInteger(schema)) {
-      return " | should be any non-number";
-    }
+module.exports = CleanPlugin;
 
-    if (likeString(schema)) {
-      return " | should be any non-string";
-    }
 
-    if (likeArray(schema)) {
-      return " | should be any non-array";
-    }
+/***/ }),
 
-    if (likeObject(schema)) {
-      return " | should be any non-object";
-    }
-  }
+/***/ 2102:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-  return "";
-}
-/**
- * @param {Array<string>} hints
- * @returns {string}
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
 
-function formatHints(hints) {
-  return hints.length > 0 ? `(${hints.join(", ")})` : "";
-}
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @returns {string[]}
- */
 
+const WebpackError = __webpack_require__(53799);
 
-function getHints(schema, logic) {
-  if (likeNumber(schema) || likeInteger(schema)) {
-    return numberHints(schema, logic);
-  } else if (likeString(schema)) {
-    return stringHints(schema, logic);
-  }
+/** @typedef {import("./Module")} Module */
 
-  return [];
+class CodeGenerationError extends WebpackError {
+	/**
+	 * Create a new CodeGenerationError
+	 * @param {Module} module related module
+	 * @param {Error} error Original error
+	 */
+	constructor(module, error) {
+		super();
+
+		this.name = "CodeGenerationError";
+		this.error = error;
+		this.message = error.message;
+		this.details = error.stack;
+		this.module = module;
+	}
 }
 
-class ValidationError extends Error {
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @param {Schema} schema
-   * @param {ValidationErrorConfiguration} configuration
-   */
-  constructor(errors, schema, configuration = {}) {
-    super();
-    /** @type {string} */
+module.exports = CodeGenerationError;
 
-    this.name = "ValidationError";
-    /** @type {Array<SchemaUtilErrorObject>} */
 
-    this.errors = errors;
-    /** @type {Schema} */
+/***/ }),
 
-    this.schema = schema;
-    let headerNameFromSchema;
-    let baseDataPathFromSchema;
+/***/ 71426:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    if (schema.title && (!configuration.name || !configuration.baseDataPath)) {
-      const splittedTitleFromSchema = schema.title.match(/^(.+) (.+)$/);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-      if (splittedTitleFromSchema) {
-        if (!configuration.name) {
-          [, headerNameFromSchema] = splittedTitleFromSchema;
-        }
 
-        if (!configuration.baseDataPath) {
-          [,, baseDataPathFromSchema] = splittedTitleFromSchema;
-        }
-      }
-    }
-    /** @type {string} */
 
+const { provide } = __webpack_require__(82482);
+const { first } = __webpack_require__(93347);
+const createHash = __webpack_require__(49835);
+const { runtimeToString, RuntimeSpecMap } = __webpack_require__(17156);
 
-    this.headerName = configuration.name || headerNameFromSchema || "Object";
-    /** @type {string} */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-    this.baseDataPath = configuration.baseDataPath || baseDataPathFromSchema || "configuration";
-    /** @type {PostFormatter | null} */
+class CodeGenerationResults {
+	/**
+	 * @param {string | Hash} hashFunction the hash function to use
+	 */
+	constructor(hashFunction = "md4") {
+		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
+		this.map = new Map();
+		this._hashFunction = hashFunction;
+	}
 
-    this.postFormatter = configuration.postFormatter || null;
-    const header = `Invalid ${this.baseDataPath} object. ${this.headerName} has been initialized using ${getArticle(this.baseDataPath)} ${this.baseDataPath} object that does not match the API schema.\n`;
-    /** @type {string} */
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {CodeGenerationResult} the CodeGenerationResult
+	 */
+	get(module, runtime) {
+		const entry = this.map.get(module);
+		if (entry === undefined) {
+			throw new Error(
+				`No code generation entry for ${module.identifier()} (existing entries: ${Array.from(
+					this.map.keys(),
+					m => m.identifier()
+				).join(", ")})`
+			);
+		}
+		if (runtime === undefined) {
+			if (entry.size > 1) {
+				const results = new Set(entry.values());
+				if (results.size !== 1) {
+					throw new Error(
+						`No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
+							entry.keys(),
+							r => runtimeToString(r)
+						).join(", ")}).
+Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
+					);
+				}
+				return first(results);
+			}
+			return entry.values().next().value;
+		}
+		const result = entry.get(runtime);
+		if (result === undefined) {
+			throw new Error(
+				`No code generation entry for runtime ${runtimeToString(
+					runtime
+				)} for ${module.identifier()} (existing runtimes: ${Array.from(
+					entry.keys(),
+					r => runtimeToString(r)
+				).join(", ")})`
+			);
+		}
+		return result;
+	}
 
-    this.message = `${header}${this.formatValidationErrors(errors)}`;
-    Error.captureStackTrace(this, this.constructor);
-  }
-  /**
-   * @param {string} path
-   * @returns {Schema}
-   */
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {boolean} true, when we have data for this
+	 */
+	has(module, runtime) {
+		const entry = this.map.get(module);
+		if (entry === undefined) {
+			return false;
+		}
+		if (runtime !== undefined) {
+			return entry.has(runtime);
+		} else if (entry.size > 1) {
+			const results = new Set(entry.values());
+			return results.size === 1;
+		} else {
+			return entry.size === 1;
+		}
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @param {string} sourceType the source type
+	 * @returns {Source} a source
+	 */
+	getSource(module, runtime, sourceType) {
+		return this.get(module, runtime).sources.get(sourceType);
+	}
 
-  getSchemaPart(path) {
-    const newPath = path.split("/");
-    let schemaPart = this.schema;
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {ReadonlySet<string>} runtime requirements
+	 */
+	getRuntimeRequirements(module, runtime) {
+		return this.get(module, runtime).runtimeRequirements;
+	}
 
-    for (let i = 1; i < newPath.length; i++) {
-      const inner = schemaPart[
-      /** @type {keyof Schema} */
-      newPath[i]];
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @param {string} key data key
+	 * @returns {any} data generated by code generation
+	 */
+	getData(module, runtime, key) {
+		const data = this.get(module, runtime).data;
+		return data === undefined ? undefined : data.get(key);
+	}
 
-      if (!inner) {
-        break;
-      }
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @returns {any} hash of the code generation
+	 */
+	getHash(module, runtime) {
+		const info = this.get(module, runtime);
+		if (info.hash !== undefined) return info.hash;
+		const hash = createHash(this._hashFunction);
+		for (const [type, source] of info.sources) {
+			hash.update(type);
+			source.updateHash(hash);
+		}
+		if (info.runtimeRequirements) {
+			for (const rr of info.runtimeRequirements) hash.update(rr);
+		}
+		return (info.hash = /** @type {string} */ (hash.digest("hex")));
+	}
 
-      schemaPart = inner;
-    }
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime runtime(s)
+	 * @param {CodeGenerationResult} result result from module
+	 * @returns {void}
+	 */
+	add(module, runtime, result) {
+		const map = provide(this.map, module, () => new RuntimeSpecMap());
+		map.set(runtime, result);
+	}
+}
 
-    return schemaPart;
-  }
-  /**
-   * @param {Schema} schema
-   * @param {boolean} logic
-   * @param {Array<Object>} prevSchemas
-   * @returns {string}
-   */
+module.exports = CodeGenerationResults;
 
 
-  formatSchema(schema, logic = true, prevSchemas = []) {
-    let newLogic = logic;
+/***/ }),
 
-    const formatInnerSchema =
-    /**
-     *
-     * @param {Object} innerSchema
-     * @param {boolean=} addSelf
-     * @returns {string}
-     */
-    (innerSchema, addSelf) => {
-      if (!addSelf) {
-        return this.formatSchema(innerSchema, newLogic, prevSchemas);
-      }
+/***/ 98427:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-      if (prevSchemas.includes(innerSchema)) {
-        return "(recursive)";
-      }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-      return this.formatSchema(innerSchema, newLogic, prevSchemas.concat(schema));
-    };
 
-    if (hasNotInSchema(schema) && !likeObject(schema)) {
-      if (canApplyNot(schema.not)) {
-        newLogic = !logic;
-        return formatInnerSchema(schema.not);
-      }
 
-      const needApplyLogicHere = !schema.not.not;
-      const prefix = logic ? "" : "non ";
-      newLogic = !logic;
-      return needApplyLogicHere ? prefix + formatInnerSchema(schema.not) : formatInnerSchema(schema.not);
-    }
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-    if (
-    /** @type {Schema & {instanceof: string | Array<string>}} */
-    schema.instanceof) {
-      const {
-        instanceof: value
-      } =
-      /** @type {Schema & {instanceof: string | Array<string>}} */
-      schema;
-      const values = !Array.isArray(value) ? [value] : value;
-      return values.map(
-      /**
-       * @param {string} item
-       * @returns {string}
-       */
-      item => item === "Function" ? "function" : item).join(" | ");
-    }
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 
-    if (schema.enum) {
-      return (
-        /** @type {Array<any>} */
-        schema.enum.map(item => JSON.stringify(item)).join(" | ")
-      );
-    }
+class CommentCompilationWarning extends WebpackError {
+	/**
+	 *
+	 * @param {string} message warning message
+	 * @param {DependencyLocation} loc affected lines of code
+	 */
+	constructor(message, loc) {
+		super(message);
 
-    if (typeof schema.const !== "undefined") {
-      return JSON.stringify(schema.const);
-    }
+		this.name = "CommentCompilationWarning";
 
-    if (schema.oneOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.oneOf.map(item => formatInnerSchema(item, true)).join(" | ")
-      );
-    }
+		this.loc = loc;
+	}
+}
 
-    if (schema.anyOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.anyOf.map(item => formatInnerSchema(item, true)).join(" | ")
-      );
-    }
+makeSerializable(
+	CommentCompilationWarning,
+	"webpack/lib/CommentCompilationWarning"
+);
 
-    if (schema.allOf) {
-      return (
-        /** @type {Array<Schema>} */
-        schema.allOf.map(item => formatInnerSchema(item, true)).join(" & ")
-      );
-    }
+module.exports = CommentCompilationWarning;
 
-    if (
-    /** @type {JSONSchema7} */
-    schema.if) {
-      const {
-        if: ifValue,
-        then: thenValue,
-        else: elseValue
-      } =
-      /** @type {JSONSchema7} */
-      schema;
-      return `${ifValue ? `if ${formatInnerSchema(ifValue)}` : ""}${thenValue ? ` then ${formatInnerSchema(thenValue)}` : ""}${elseValue ? ` else ${formatInnerSchema(elseValue)}` : ""}`;
-    }
 
-    if (schema.$ref) {
-      return formatInnerSchema(this.getSchemaPart(schema.$ref), true);
-    }
+/***/ }),
 
-    if (likeNumber(schema) || likeInteger(schema)) {
-      const [type, ...hints] = getHints(schema, logic);
-      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
-      return logic ? str : hints.length > 0 ? `non-${type} | ${str}` : `non-${type}`;
-    }
+/***/ 94258:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    if (likeString(schema)) {
-      const [type, ...hints] = getHints(schema, logic);
-      const str = `${type}${hints.length > 0 ? ` ${formatHints(hints)}` : ""}`;
-      return logic ? str : str === "string" ? "non-string" : `non-string | ${str}`;
-    }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-    if (likeBoolean(schema)) {
-      return `${logic ? "" : "non-"}boolean`;
-    }
 
-    if (likeArray(schema)) {
-      // not logic already applied in formatValidationError
-      newLogic = true;
-      const hints = [];
 
-      if (typeof schema.minItems === "number") {
-        hints.push(`should not have fewer than ${schema.minItems} item${schema.minItems > 1 ? "s" : ""}`);
-      }
+const ConstDependency = __webpack_require__(76911);
 
-      if (typeof schema.maxItems === "number") {
-        hints.push(`should not have more than ${schema.maxItems} item${schema.maxItems > 1 ? "s" : ""}`);
-      }
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-      if (schema.uniqueItems) {
-        hints.push("should not have duplicate items");
-      }
+const nestedWebpackRequireTag = Symbol("nested __webpack_require__");
 
-      const hasAdditionalItems = typeof schema.additionalItems === "undefined" || Boolean(schema.additionalItems);
-      let items = "";
+class CompatibilityPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"CompatibilityPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
 
-      if (schema.items) {
-        if (Array.isArray(schema.items) && schema.items.length > 0) {
-          items = `${
-          /** @type {Array<Schema>} */
-          schema.items.map(item => formatInnerSchema(item)).join(", ")}`;
-
-          if (hasAdditionalItems) {
-            if (schema.additionalItems && isObject(schema.additionalItems) && Object.keys(schema.additionalItems).length > 0) {
-              hints.push(`additional items should be ${formatInnerSchema(schema.additionalItems)}`);
-            }
-          }
-        } else if (schema.items && Object.keys(schema.items).length > 0) {
-          // "additionalItems" is ignored
-          items = `${formatInnerSchema(schema.items)}`;
-        } else {
-          // Fallback for empty `items` value
-          items = "any";
-        }
-      } else {
-        // "additionalItems" is ignored
-        items = "any";
-      }
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("CompatibilityPlugin", (parser, parserOptions) => {
+						if (
+							parserOptions.browserify !== undefined &&
+							!parserOptions.browserify
+						)
+							return;
 
-      if (schema.contains && Object.keys(schema.contains).length > 0) {
-        hints.push(`should contains at least one ${this.formatSchema(schema.contains)} item`);
-      }
+						parser.hooks.call
+							.for("require")
+							.tap("CompatibilityPlugin", expr => {
+								// support for browserify style require delegator: "require(o, !0)"
+								if (expr.arguments.length !== 2) return;
+								const second = parser.evaluateExpression(expr.arguments[1]);
+								if (!second.isBoolean()) return;
+								if (second.asBool() !== true) return;
+								const dep = new ConstDependency("require", expr.callee.range);
+								dep.loc = expr.loc;
+								if (parser.state.current.dependencies.length > 0) {
+									const last =
+										parser.state.current.dependencies[
+											parser.state.current.dependencies.length - 1
+										];
+									if (
+										last.critical &&
+										last.options &&
+										last.options.request === "." &&
+										last.userRequest === "." &&
+										last.options.recursive
+									)
+										parser.state.current.dependencies.pop();
+								}
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+					});
 
-      return `[${items}${hasAdditionalItems ? ", ..." : ""}]${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
-    }
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					// Handle nested requires
+					parser.hooks.preStatement.tap("CompatibilityPlugin", statement => {
+						if (
+							statement.type === "FunctionDeclaration" &&
+							statement.id &&
+							statement.id.name === "__webpack_require__"
+						) {
+							const newName = `__nested_webpack_require_${statement.range[0]}__`;
+							parser.tagVariable(statement.id.name, nestedWebpackRequireTag, {
+								name: newName,
+								declaration: {
+									updated: false,
+									loc: statement.id.loc,
+									range: statement.id.range
+								}
+							});
+							return true;
+						}
+					});
+					parser.hooks.pattern
+						.for("__webpack_require__")
+						.tap("CompatibilityPlugin", pattern => {
+							const newName = `__nested_webpack_require_${pattern.range[0]}__`;
+							parser.tagVariable(pattern.name, nestedWebpackRequireTag, {
+								name: newName,
+								declaration: {
+									updated: false,
+									loc: pattern.loc,
+									range: pattern.range
+								}
+							});
+							return true;
+						});
+					parser.hooks.expression
+						.for(nestedWebpackRequireTag)
+						.tap("CompatibilityPlugin", expr => {
+							const { name, declaration } = parser.currentTagData;
+							if (!declaration.updated) {
+								const dep = new ConstDependency(name, declaration.range);
+								dep.loc = declaration.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								declaration.updated = true;
+							}
+							const dep = new ConstDependency(name, expr.range);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
-    if (likeObject(schema)) {
-      // not logic already applied in formatValidationError
-      newLogic = true;
-      const hints = [];
+					// Handle hashbang
+					parser.hooks.program.tap(
+						"CompatibilityPlugin",
+						(program, comments) => {
+							if (comments.length === 0) return;
+							const c = comments[0];
+							if (c.type === "Line" && c.range[0] === 0) {
+								if (parser.state.source.slice(0, 2).toString() !== "#!") return;
+								// this is a hashbang comment
+								const dep = new ConstDependency("//", 0);
+								dep.loc = c.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
+						}
+					);
+				};
 
-      if (typeof schema.minProperties === "number") {
-        hints.push(`should not have fewer than ${schema.minProperties} ${schema.minProperties > 1 ? "properties" : "property"}`);
-      }
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("CompatibilityPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("CompatibilityPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("CompatibilityPlugin", handler);
+			}
+		);
+	}
+}
+module.exports = CompatibilityPlugin;
 
-      if (typeof schema.maxProperties === "number") {
-        hints.push(`should not have more than ${schema.maxProperties} ${schema.minProperties && schema.minProperties > 1 ? "properties" : "property"}`);
-      }
 
-      if (schema.patternProperties && Object.keys(schema.patternProperties).length > 0) {
-        const patternProperties = Object.keys(schema.patternProperties);
-        hints.push(`additional property names should match pattern${patternProperties.length > 1 ? "s" : ""} ${patternProperties.map(pattern => JSON.stringify(pattern)).join(" | ")}`);
-      }
+/***/ }),
 
-      const properties = schema.properties ? Object.keys(schema.properties) : [];
-      const required = schema.required ? schema.required : [];
-      const allProperties = [...new Set(
-      /** @type {Array<string>} */
-      [].concat(required).concat(properties))];
-      const objectStructure = allProperties.map(property => {
-        const isRequired = required.includes(property); // Some properties need quotes, maybe we should add check
-        // Maybe we should output type of property (`foo: string`), but it is looks very unreadable
+/***/ 85720:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-        return `${property}${isRequired ? "" : "?"}`;
-      }).concat(typeof schema.additionalProperties === "undefined" || Boolean(schema.additionalProperties) ? schema.additionalProperties && isObject(schema.additionalProperties) ? [`<key>: ${formatInnerSchema(schema.additionalProperties)}`] : ["…"] : []).join(", ");
-      const {
-        dependencies,
-        propertyNames,
-        patternRequired
-      } =
-      /** @type {Schema & {patternRequired?: Array<string>;}} */
-      schema;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-      if (dependencies) {
-        Object.keys(dependencies).forEach(dependencyName => {
-          const dependency = dependencies[dependencyName];
 
-          if (Array.isArray(dependency)) {
-            hints.push(`should have ${dependency.length > 1 ? "properties" : "property"} ${dependency.map(dep => `'${dep}'`).join(", ")} when property '${dependencyName}' is present`);
-          } else {
-            hints.push(`should be valid according to the schema ${formatInnerSchema(dependency)} when property '${dependencyName}' is present`);
-          }
-        });
-      }
 
-      if (propertyNames && Object.keys(propertyNames).length > 0) {
-        hints.push(`each property name should match format ${JSON.stringify(schema.propertyNames.format)}`);
-      }
+const asyncLib = __webpack_require__(78175);
+const {
+	HookMap,
+	SyncHook,
+	SyncBailHook,
+	SyncWaterfallHook,
+	AsyncSeriesHook,
+	AsyncSeriesBailHook,
+	AsyncParallelHook
+} = __webpack_require__(6967);
+const util = __webpack_require__(73837);
+const { CachedSource } = __webpack_require__(51255);
+const { MultiItemCache } = __webpack_require__(55392);
+const Chunk = __webpack_require__(39385);
+const ChunkGraph = __webpack_require__(64971);
+const ChunkGroup = __webpack_require__(15626);
+const ChunkRenderError = __webpack_require__(918);
+const ChunkTemplate = __webpack_require__(46341);
+const CodeGenerationError = __webpack_require__(2102);
+const CodeGenerationResults = __webpack_require__(71426);
+const Dependency = __webpack_require__(54912);
+const DependencyTemplates = __webpack_require__(9163);
+const Entrypoint = __webpack_require__(13795);
+const ErrorHelpers = __webpack_require__(59985);
+const FileSystemInfo = __webpack_require__(79453);
+const {
+	connectChunkGroupAndChunk,
+	connectChunkGroupParentAndChild
+} = __webpack_require__(37234);
+const {
+	makeWebpackError,
+	tryRunOrWebpackError
+} = __webpack_require__(11351);
+const MainTemplate = __webpack_require__(12856);
+const Module = __webpack_require__(73208);
+const ModuleDependencyError = __webpack_require__(67409);
+const ModuleDependencyWarning = __webpack_require__(29656);
+const ModuleGraph = __webpack_require__(99988);
+const ModuleNotFoundError = __webpack_require__(32882);
+const ModuleProfile = __webpack_require__(36418);
+const ModuleRestoreError = __webpack_require__(94560);
+const ModuleStoreError = __webpack_require__(59001);
+const ModuleTemplate = __webpack_require__(62677);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeTemplate = __webpack_require__(18777);
+const Stats = __webpack_require__(31743);
+const WebpackError = __webpack_require__(53799);
+const buildChunkGraph = __webpack_require__(79233);
+const BuildCycleError = __webpack_require__(22273);
+const { Logger, LogType } = __webpack_require__(32597);
+const StatsFactory = __webpack_require__(92629);
+const StatsPrinter = __webpack_require__(30198);
+const { equals: arrayEquals } = __webpack_require__(84953);
+const AsyncQueue = __webpack_require__(12260);
+const LazySet = __webpack_require__(38938);
+const { provide } = __webpack_require__(82482);
+const WeakTupleMap = __webpack_require__(28745);
+const { cachedCleverMerge } = __webpack_require__(60839);
+const {
+	compareLocations,
+	concatComparators,
+	compareSelect,
+	compareIds,
+	compareStringsNumeric,
+	compareModulesByIdentifier
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const {
+	arrayToSetDeprecation,
+	soonFrozenObjectDeprecation,
+	createFakeHook
+} = __webpack_require__(64518);
+const processAsyncTree = __webpack_require__(42791);
+const { getRuntimeKey } = __webpack_require__(17156);
+const { isSourceEqual } = __webpack_require__(41245);
 
-      if (patternRequired && patternRequired.length > 0) {
-        hints.push(`should have property matching pattern ${patternRequired.map(
-        /**
-         * @param {string} item
-         * @returns {string}
-         */
-        item => JSON.stringify(item))}`);
-      }
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Cache")} Cache */
+/** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./util/Hash")} Hash */
+/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-      return `object {${objectStructure ? ` ${objectStructure} ` : ""}}${hints.length > 0 ? ` (${hints.join(", ")})` : ""}`;
-    }
+/**
+ * @callback Callback
+ * @param {(WebpackError | null)=} err
+ * @returns {void}
+ */
 
-    if (likeNull(schema)) {
-      return `${logic ? "" : "non-"}null`;
-    }
+/**
+ * @callback ModuleCallback
+ * @param {(WebpackError | null)=} err
+ * @param {Module=} result
+ * @returns {void}
+ */
 
-    if (Array.isArray(schema.type)) {
-      // not logic already applied in formatValidationError
-      return `${schema.type.join(" | ")}`;
-    } // Fallback for unknown keywords
-    // not logic already applied in formatValidationError
+/**
+ * @callback ModuleFactoryResultCallback
+ * @param {(WebpackError | null)=} err
+ * @param {ModuleFactoryResult=} result
+ * @returns {void}
+ */
 
-    /* istanbul ignore next */
+/**
+ * @callback ModuleOrFactoryResultCallback
+ * @param {(WebpackError | null)=} err
+ * @param {Module | ModuleFactoryResult=} result
+ * @returns {void}
+ */
 
+/**
+ * @callback ExecuteModuleCallback
+ * @param {(WebpackError | null)=} err
+ * @param {ExecuteModuleResult=} result
+ * @returns {void}
+ */
 
-    return JSON.stringify(schema, null, 2);
-  }
-  /**
-   * @param {Schema=} schemaPart
-   * @param {(boolean | Array<string>)=} additionalPath
-   * @param {boolean=} needDot
-   * @param {boolean=} logic
-   * @returns {string}
-   */
+/**
+ * @callback DepBlockVarDependenciesCallback
+ * @param {Dependency} dependency
+ * @returns {any}
+ */
 
+/** @typedef {new (...args: any[]) => Dependency} DepConstructor */
+/** @typedef {Record<string, Source>} CompilationAssets */
 
-  getSchemaPartText(schemaPart, additionalPath, needDot = false, logic = true) {
-    if (!schemaPart) {
-      return "";
-    }
+/**
+ * @typedef {Object} AvailableModulesChunkGroupMapping
+ * @property {ChunkGroup} chunkGroup
+ * @property {Set<Module>} availableModules
+ * @property {boolean} needCopy
+ */
 
-    if (Array.isArray(additionalPath)) {
-      for (let i = 0; i < additionalPath.length; i++) {
-        /** @type {Schema | undefined} */
-        const inner = schemaPart[
-        /** @type {keyof Schema} */
-        additionalPath[i]];
+/**
+ * @typedef {Object} DependenciesBlockLike
+ * @property {Dependency[]} dependencies
+ * @property {AsyncDependenciesBlock[]} blocks
+ */
 
-        if (inner) {
-          // eslint-disable-next-line no-param-reassign
-          schemaPart = inner;
-        } else {
-          break;
-        }
-      }
-    }
+/**
+ * @typedef {Object} ChunkPathData
+ * @property {string|number} id
+ * @property {string=} name
+ * @property {string} hash
+ * @property {function(number): string=} hashWithLength
+ * @property {(Record<string, string>)=} contentHash
+ * @property {(Record<string, (length: number) => string>)=} contentHashWithLength
+ */
 
-    while (schemaPart.$ref) {
-      // eslint-disable-next-line no-param-reassign
-      schemaPart = this.getSchemaPart(schemaPart.$ref);
-    }
+/**
+ * @typedef {Object} ChunkHashContext
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ */
 
-    let schemaText = `${this.formatSchema(schemaPart, logic)}${needDot ? "." : ""}`;
+/**
+ * @typedef {Object} RuntimeRequirementsContext
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults the code generation results
+ */
 
-    if (schemaPart.description) {
-      schemaText += `\n-> ${schemaPart.description}`;
-    }
+/**
+ * @typedef {Object} ExecuteModuleOptions
+ * @property {EntryOptions=} entryOptions
+ */
 
-    if (schemaPart.link) {
-      schemaText += `\n-> Read more at ${schemaPart.link}`;
-    }
+/**
+ * @typedef {Object} ExecuteModuleResult
+ * @property {any} exports
+ * @property {boolean} cacheable
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} buildDependencies
+ */
 
-    return schemaText;
-  }
-  /**
-   * @param {Schema=} schemaPart
-   * @returns {string}
-   */
+/**
+ * @typedef {Object} ExecuteModuleArgument
+ * @property {Module} module
+ * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
+ * @property {any} preparedInfo
+ * @property {CodeGenerationResult} codeGenerationResult
+ */
 
+/**
+ * @typedef {Object} ExecuteModuleContext
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {Chunk} chunk
+ * @property {ChunkGraph} chunkGraph
+ * @property {function(string): any=} __webpack_require__
+ */
 
-  getSchemaPartDescription(schemaPart) {
-    if (!schemaPart) {
-      return "";
-    }
+/**
+ * @typedef {Object} EntryData
+ * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
+ * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated
+ * @property {EntryOptions} options options of the entrypoint
+ */
 
-    while (schemaPart.$ref) {
-      // eslint-disable-next-line no-param-reassign
-      schemaPart = this.getSchemaPart(schemaPart.$ref);
-    }
+/**
+ * @typedef {Object} LogEntry
+ * @property {string} type
+ * @property {any[]} args
+ * @property {number} time
+ * @property {string[]=} trace
+ */
 
-    let schemaText = "";
+/**
+ * @typedef {Object} KnownAssetInfo
+ * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
+ * @property {boolean=} minimized whether the asset is minimized
+ * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset
+ * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
+ * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
+ * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
+ * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
+ * @property {number=} size size in bytes, only set after asset has been emitted
+ * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
+ * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
+ * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
+ * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
+ */
 
-    if (schemaPart.description) {
-      schemaText += `\n-> ${schemaPart.description}`;
-    }
+/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
 
-    if (schemaPart.link) {
-      schemaText += `\n-> Read more at ${schemaPart.link}`;
-    }
+/**
+ * @typedef {Object} Asset
+ * @property {string} name the filename of the asset
+ * @property {Source} source source of the asset
+ * @property {AssetInfo} info info about the asset
+ */
 
-    return schemaText;
-  }
-  /**
-   * @param {SchemaUtilErrorObject} error
-   * @returns {string}
-   */
-
-
-  formatValidationError(error) {
-    const {
-      keyword,
-      dataPath: errorDataPath
-    } = error;
-    const dataPath = `${this.baseDataPath}${errorDataPath}`;
+/**
+ * @typedef {Object} ModulePathData
+ * @property {string|number} id
+ * @property {string} hash
+ * @property {function(number): string=} hashWithLength
+ */
 
-    switch (keyword) {
-      case "type":
-        {
-          const {
-            parentSchema,
-            params
-          } = error; // eslint-disable-next-line default-case
+/**
+ * @typedef {Object} PathData
+ * @property {ChunkGraph=} chunkGraph
+ * @property {string=} hash
+ * @property {function(number): string=} hashWithLength
+ * @property {(Chunk|ChunkPathData)=} chunk
+ * @property {(Module|ModulePathData)=} module
+ * @property {RuntimeSpec=} runtime
+ * @property {string=} filename
+ * @property {string=} basename
+ * @property {string=} query
+ * @property {string=} contentHashType
+ * @property {string=} contentHash
+ * @property {function(number): string=} contentHashWithLength
+ * @property {boolean=} noChunkHash
+ * @property {string=} url
+ */
 
-          switch (
-          /** @type {import("ajv").TypeParams} */
-          params.type) {
-            case "number":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+/**
+ * @typedef {Object} KnownNormalizedStatsOptions
+ * @property {string} context
+ * @property {RequestShortener} requestShortener
+ * @property {string} chunksSort
+ * @property {string} modulesSort
+ * @property {string} chunkModulesSort
+ * @property {string} nestedModulesSort
+ * @property {string} assetsSort
+ * @property {boolean} ids
+ * @property {boolean} cachedAssets
+ * @property {boolean} groupAssetsByEmitStatus
+ * @property {boolean} groupAssetsByPath
+ * @property {boolean} groupAssetsByExtension
+ * @property {number} assetsSpace
+ * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
+ * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
+ * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
+ * @property {boolean} cachedModules
+ * @property {boolean} orphanModules
+ * @property {boolean} dependentModules
+ * @property {boolean} runtimeModules
+ * @property {boolean} groupModulesByCacheStatus
+ * @property {boolean} groupModulesByLayer
+ * @property {boolean} groupModulesByAttributes
+ * @property {boolean} groupModulesByPath
+ * @property {boolean} groupModulesByExtension
+ * @property {boolean} groupModulesByType
+ * @property {boolean | "auto"} entrypoints
+ * @property {boolean} chunkGroups
+ * @property {boolean} chunkGroupAuxiliary
+ * @property {boolean} chunkGroupChildren
+ * @property {number} chunkGroupMaxAssets
+ * @property {number} modulesSpace
+ * @property {number} chunkModulesSpace
+ * @property {number} nestedModulesSpace
+ * @property {false|"none"|"error"|"warn"|"info"|"log"|"verbose"} logging
+ * @property {((value: string) => boolean)[]} loggingDebug
+ * @property {boolean} loggingTrace
+ * @property {any} _env
+ */
 
-            case "integer":
-              return `${dataPath} should be an ${this.getSchemaPartText(parentSchema, false, true)}`;
+/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
 
-            case "string":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+/**
+ * @typedef {Object} KnownCreateStatsOptionsContext
+ * @property {boolean=} forToString
+ */
 
-            case "boolean":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
 
-            case "array":
-              return `${dataPath} should be an array:\n${this.getSchemaPartText(parentSchema)}`;
+/** @type {AssetInfo} */
+const EMPTY_ASSET_INFO = Object.freeze({});
 
-            case "object":
-              return `${dataPath} should be an object:\n${this.getSchemaPartText(parentSchema)}`;
+const esmDependencyCategory = "esm";
+// TODO webpack 6: remove
+const deprecatedNormalModuleLoaderHook = util.deprecate(
+	compilation => {
+		return (__webpack_require__(39).getCompilationHooks)(compilation).loader;
+	},
+	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
+	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
+);
 
-            case "null":
-              return `${dataPath} should be a ${this.getSchemaPartText(parentSchema, false, true)}`;
+// TODO webpack 6: remove
+const defineRemovedModuleTemplates = moduleTemplates => {
+	Object.defineProperties(moduleTemplates, {
+		asset: {
+			enumerable: false,
+			configurable: false,
+			get: () => {
+				throw new WebpackError(
+					"Compilation.moduleTemplates.asset has been removed"
+				);
+			}
+		},
+		webassembly: {
+			enumerable: false,
+			configurable: false,
+			get: () => {
+				throw new WebpackError(
+					"Compilation.moduleTemplates.webassembly has been removed"
+				);
+			}
+		}
+	});
+	moduleTemplates = undefined;
+};
 
-            default:
-              return `${dataPath} should be:\n${this.getSchemaPartText(parentSchema)}`;
-          }
-        }
+const byId = compareSelect(
+	/**
+	 * @param {Chunk} c chunk
+	 * @returns {number | string} id
+	 */ c => c.id,
+	compareIds
+);
 
-      case "instanceof":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should be an instance of ${this.getSchemaPartText(parentSchema, false, true)}`;
-        }
+const byNameOrHash = concatComparators(
+	compareSelect(
+		/**
+		 * @param {Compilation} c compilation
+		 * @returns {string} name
+		 */
+		c => c.name,
+		compareIds
+	),
+	compareSelect(
+		/**
+		 * @param {Compilation} c compilation
+		 * @returns {string} hash
+		 */ c => c.fullHash,
+		compareIds
+	)
+);
 
-      case "pattern":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            pattern
-          } =
-          /** @type {import("ajv").PatternParams} */
-          params;
-          return `${dataPath} should match pattern ${JSON.stringify(pattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
 
-      case "format":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            format
-          } =
-          /** @type {import("ajv").FormatParams} */
-          params;
-          return `${dataPath} should match format ${JSON.stringify(format)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+const byModule = compareSelect(
+	err => (err.module && err.module.identifier()) || "",
+	compareStringsNumeric
+);
 
-      case "formatMinimum":
-      case "formatMaximum":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            comparison,
-            limit
-          } =
-          /** @type {import("ajv").ComparisonParams} */
-          params;
-          return `${dataPath} should be ${comparison} ${JSON.stringify(limit)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+const byLocation = compareSelect(err => err.loc, compareLocations);
 
-      case "minimum":
-      case "maximum":
-      case "exclusiveMinimum":
-      case "exclusiveMaximum":
-        {
-          const {
-            parentSchema,
-            params
-          } = error;
-          const {
-            comparison,
-            limit
-          } =
-          /** @type {import("ajv").ComparisonParams} */
-          params;
-          const [, ...hints] = getHints(
-          /** @type {Schema} */
-          parentSchema, true);
+const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
-          if (hints.length === 0) {
-            hints.push(`should be ${comparison} ${limit}`);
-          }
+/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
+const unsafeCacheDependencies = new WeakMap();
 
-          return `${dataPath} ${hints.join(" ")}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
+const unsafeCacheData = new WeakMap();
 
-      case "multipleOf":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            multipleOf
-          } =
-          /** @type {import("ajv").MultipleOfParams} */
-          params;
-          return `${dataPath} should be multiple of ${multipleOf}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+class Compilation {
+	/**
+	 * Creates an instance of Compilation.
+	 * @param {Compiler} compiler the compiler which created the compilation
+	 * @param {CompilationParams} params the compilation parameters
+	 */
+	constructor(compiler, params) {
+		this._backCompat = compiler._backCompat;
 
-      case "patternRequired":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            missingPattern
-          } =
-          /** @type {import("ajv").PatternRequiredParams} */
-          params;
-          return `${dataPath} should have property matching pattern ${JSON.stringify(missingPattern)}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
+		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
+		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
+		const processAssetsHook = new AsyncSeriesHook(["assets"]);
 
-      case "minLength":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
+		let savedAssets = new Set();
+		const popNewAssets = assets => {
+			let newAssets = undefined;
+			for (const file of Object.keys(assets)) {
+				if (savedAssets.has(file)) continue;
+				if (newAssets === undefined) {
+					newAssets = Object.create(null);
+				}
+				newAssets[file] = assets[file];
+				savedAssets.add(file);
+			}
+			return newAssets;
+		};
+		processAssetsHook.intercept({
+			name: "Compilation",
+			call: () => {
+				savedAssets = new Set(Object.keys(this.assets));
+			},
+			register: tap => {
+				const { type, name } = tap;
+				const { fn, additionalAssets, ...remainingTap } = tap;
+				const additionalAssetsFn =
+					additionalAssets === true ? fn : additionalAssets;
+				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
+				switch (type) {
+					case "sync":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tap(name, assets => {
+								if (processedAssets.has(this.assets))
+									additionalAssetsFn(assets);
+							});
+						}
+						return {
+							...remainingTap,
+							type: "async",
+							fn: (assets, callback) => {
+								try {
+									fn(assets);
+								} catch (e) {
+									return callback(e);
+								}
+								if (processedAssets !== undefined)
+									processedAssets.add(this.assets);
+								const newAssets = popNewAssets(assets);
+								if (newAssets !== undefined) {
+									this.hooks.processAdditionalAssets.callAsync(
+										newAssets,
+										callback
+									);
+									return;
+								}
+								callback();
+							}
+						};
+					case "async":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tapAsync(
+								name,
+								(assets, callback) => {
+									if (processedAssets.has(this.assets))
+										return additionalAssetsFn(assets, callback);
+									callback();
+								}
+							);
+						}
+						return {
+							...remainingTap,
+							fn: (assets, callback) => {
+								fn(assets, err => {
+									if (err) return callback(err);
+									if (processedAssets !== undefined)
+										processedAssets.add(this.assets);
+									const newAssets = popNewAssets(assets);
+									if (newAssets !== undefined) {
+										this.hooks.processAdditionalAssets.callAsync(
+											newAssets,
+											callback
+										);
+										return;
+									}
+									callback();
+								});
+							}
+						};
+					case "promise":
+						if (additionalAssetsFn) {
+							this.hooks.processAdditionalAssets.tapPromise(name, assets => {
+								if (processedAssets.has(this.assets))
+									return additionalAssetsFn(assets);
+								return Promise.resolve();
+							});
+						}
+						return {
+							...remainingTap,
+							fn: assets => {
+								const p = fn(assets);
+								if (!p || !p.then) return p;
+								return p.then(() => {
+									if (processedAssets !== undefined)
+										processedAssets.add(this.assets);
+									const newAssets = popNewAssets(assets);
+									if (newAssets !== undefined) {
+										return this.hooks.processAdditionalAssets.promise(
+											newAssets
+										);
+									}
+								});
+							}
+						};
+				}
+			}
+		});
 
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty string${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
+		/** @type {SyncHook<[CompilationAssets]>} */
+		const afterProcessAssetsHook = new SyncHook(["assets"]);
 
-          const length = limit - 1;
-          return `${dataPath} should be longer than ${length} character${length > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+		/**
+		 * @template T
+		 * @param {string} name name of the hook
+		 * @param {number} stage new stage
+		 * @param {function(): AsArray<T>} getArgs get old hook function args
+		 * @param {string=} code deprecation code (not deprecated when unset)
+		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
+		 */
+		const createProcessAssetsHook = (name, stage, getArgs, code) => {
+			if (!this._backCompat && code) return undefined;
+			const errorMessage =
+				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
+BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
+			const getOptions = options => {
+				if (typeof options === "string") options = { name: options };
+				if (options.stage) {
+					throw new Error(errorMessage("it's using the 'stage' option"));
+				}
+				return { ...options, stage: stage };
+			};
+			return createFakeHook(
+				{
+					name,
+					/** @type {AsyncSeriesHook<T>["intercept"]} */
+					intercept(interceptor) {
+						throw new Error(errorMessage("it's using 'intercept'"));
+					},
+					/** @type {AsyncSeriesHook<T>["tap"]} */
+					tap: (options, fn) => {
+						processAssetsHook.tap(getOptions(options), () => fn(...getArgs()));
+					},
+					/** @type {AsyncSeriesHook<T>["tapAsync"]} */
+					tapAsync: (options, fn) => {
+						processAssetsHook.tapAsync(
+							getOptions(options),
+							(assets, callback) =>
+								/** @type {any} */ (fn)(...getArgs(), callback)
+						);
+					},
+					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
+					tapPromise: (options, fn) => {
+						processAssetsHook.tapPromise(getOptions(options), () =>
+							fn(...getArgs())
+						);
+					}
+				},
+				`${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,
+				code
+			);
+		};
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[Module]>} */
+			buildModule: new SyncHook(["module"]),
+			/** @type {SyncHook<[Module]>} */
+			rebuildModule: new SyncHook(["module"]),
+			/** @type {SyncHook<[Module, WebpackError]>} */
+			failedModule: new SyncHook(["module", "error"]),
+			/** @type {SyncHook<[Module]>} */
+			succeedModule: new SyncHook(["module"]),
+			/** @type {SyncHook<[Module]>} */
+			stillValidModule: new SyncHook(["module"]),
 
-      case "minItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
+			/** @type {SyncHook<[Dependency, EntryOptions]>} */
+			addEntry: new SyncHook(["entry", "options"]),
+			/** @type {SyncHook<[Dependency, EntryOptions, Error]>} */
+			failedEntry: new SyncHook(["entry", "options", "error"]),
+			/** @type {SyncHook<[Dependency, EntryOptions, Module]>} */
+			succeedEntry: new SyncHook(["entry", "options", "module"]),
 
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty array${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
+			/** @type {SyncWaterfallHook<[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]>} */
+			dependencyReferencedExports: new SyncWaterfallHook([
+				"referencedExports",
+				"dependency",
+				"runtime"
+			]),
 
-          return `${dataPath} should not have fewer than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			executeModule: new SyncHook(["options", "context"]),
+			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
 
-      case "minProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-
-          if (limit === 1) {
-            return `${dataPath} should be a non-empty object${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-          }
-
-          return `${dataPath} should not have fewer than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "maxLength":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          const max = limit + 1;
-          return `${dataPath} should be shorter than ${max} character${max > 1 ? "s" : ""}${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
-
-      case "maxItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
+			finishModules: new AsyncSeriesHook(["modules"]),
+			/** @type {AsyncSeriesHook<[Module]>} */
+			finishRebuildingModule: new AsyncSeriesHook(["module"]),
+			/** @type {SyncHook<[]>} */
+			unseal: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			seal: new SyncHook([]),
 
-      case "maxProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} properties${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {SyncHook<[]>} */
+			beforeChunks: new SyncHook([]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			afterChunks: new SyncHook(["chunks"]),
 
-      case "uniqueItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            i
-          } =
-          /** @type {import("ajv").UniqueItemsParams} */
-          params;
-          return `${dataPath} should not contain the item '${error.data[i]}' twice${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			optimizeDependencies: new SyncBailHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			afterOptimizeDependencies: new SyncHook(["modules"]),
 
-      case "additionalItems":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            limit
-          } =
-          /** @type {import("ajv").LimitParams} */
-          params;
-          return `${dataPath} should not have more than ${limit} items${getSchemaNonTypes(parentSchema)}. These items are valid:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+			/** @type {SyncHook<[]>} */
+			optimize: new SyncHook([]),
+			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			optimizeModules: new SyncBailHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			afterOptimizeModules: new SyncHook(["modules"]),
 
-      case "contains":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should contains at least one ${this.getSchemaPartText(parentSchema, ["contains"])} item${getSchemaNonTypes(parentSchema)}.`;
-        }
+			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+			optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),
+			/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+			afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),
 
-      case "required":
-        {
-          const {
-            parentSchema,
-            params
-          } = error;
-          const missingProperty =
-          /** @type {import("ajv").DependenciesParams} */
-          params.missingProperty.replace(/^\./, "");
-          const hasProperty = parentSchema && Boolean(
-          /** @type {Schema} */
-          parentSchema.properties &&
-          /** @type {Schema} */
-          parentSchema.properties[missingProperty]);
-          return `${dataPath} misses the property '${missingProperty}'${getSchemaNonTypes(parentSchema)}.${hasProperty ? ` Should be:\n${this.getSchemaPartText(parentSchema, ["properties", missingProperty])}` : this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			optimizeTree: new AsyncSeriesHook(["chunks", "modules"]),
+			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			afterOptimizeTree: new SyncHook(["chunks", "modules"]),
 
-      case "additionalProperties":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            additionalProperty
-          } =
-          /** @type {import("ajv").AdditionalPropertiesParams} */
-          params;
-          return `${dataPath} has an unknown property '${additionalProperty}'${getSchemaNonTypes(parentSchema)}. These properties are valid:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
+			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
+			/** @type {SyncBailHook<[], boolean>} */
+			shouldRecord: new SyncBailHook([]),
 
-      case "dependencies":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            property,
-            deps
-          } =
-          /** @type {import("ajv").DependenciesParams} */
-          params;
-          const dependencies = deps.split(",").map(
-          /**
-           * @param {string} dep
-           * @returns {string}
-           */
-          dep => `'${dep.trim()}'`).join(", ");
-          return `${dataPath} should have properties ${dependencies} when property '${property}' is present${getSchemaNonTypes(parentSchema)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+			additionalChunkRuntimeRequirements: new SyncHook([
+				"chunk",
+				"runtimeRequirements",
+				"context"
+			]),
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			runtimeRequirementInChunk: new HookMap(
+				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
+			),
+			/** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
+			additionalModuleRuntimeRequirements: new SyncHook([
+				"module",
+				"runtimeRequirements",
+				"context"
+			]),
+			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
+			runtimeRequirementInModule: new HookMap(
+				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
+			),
+			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+			additionalTreeRuntimeRequirements: new SyncHook([
+				"chunk",
+				"runtimeRequirements",
+				"context"
+			]),
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			runtimeRequirementInTree: new HookMap(
+				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
+			),
 
-      case "propertyNames":
-        {
-          const {
-            params,
-            parentSchema,
-            schema
-          } = error;
-          const {
-            propertyName
-          } =
-          /** @type {import("ajv").PropertyNamesParams} */
-          params;
-          return `${dataPath} property name '${propertyName}' is invalid${getSchemaNonTypes(parentSchema)}. Property names should be match format ${JSON.stringify(schema.format)}.${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {SyncHook<[RuntimeModule, Chunk]>} */
+			runtimeModule: new SyncHook(["module", "chunk"]),
 
-      case "enum":
-        {
-          const {
-            parentSchema
-          } = error;
+			/** @type {SyncHook<[Iterable<Module>, any]>} */
+			reviveModules: new SyncHook(["modules", "records"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			beforeModuleIds: new SyncHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			moduleIds: new SyncHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			optimizeModuleIds: new SyncHook(["modules"]),
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			afterOptimizeModuleIds: new SyncHook(["modules"]),
 
-          if (parentSchema &&
-          /** @type {Schema} */
-          parentSchema.enum &&
-          /** @type {Schema} */
-          parentSchema.enum.length === 1) {
-            return `${dataPath} should be ${this.getSchemaPartText(parentSchema, false, true)}`;
-          }
+			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
+			reviveChunks: new SyncHook(["chunks", "records"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			beforeChunkIds: new SyncHook(["chunks"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			chunkIds: new SyncHook(["chunks"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			optimizeChunkIds: new SyncHook(["chunks"]),
+			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			afterOptimizeChunkIds: new SyncHook(["chunks"]),
 
-          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+			/** @type {SyncHook<[Iterable<Module>, any]>} */
+			recordModules: new SyncHook(["modules", "records"]),
+			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
+			recordChunks: new SyncHook(["chunks", "records"]),
 
-      case "const":
-        {
-          const {
-            parentSchema
-          } = error;
-          return `${dataPath} should be equal to constant ${this.getSchemaPartText(parentSchema, false, true)}`;
-        }
+			/** @type {SyncHook<[Iterable<Module>]>} */
+			optimizeCodeGeneration: new SyncHook(["modules"]),
 
-      case "not":
-        {
-          const postfix = likeObject(
-          /** @type {Schema} */
-          error.parentSchema) ? `\n${this.getSchemaPartText(error.parentSchema)}` : "";
-          const schemaOutput = this.getSchemaPartText(error.schema, false, false, false);
+			/** @type {SyncHook<[]>} */
+			beforeModuleHash: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterModuleHash: new SyncHook([]),
 
-          if (canApplyNot(error.schema)) {
-            return `${dataPath} should be any ${schemaOutput}${postfix}.`;
-          }
+			/** @type {SyncHook<[]>} */
+			beforeCodeGeneration: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterCodeGeneration: new SyncHook([]),
 
-          const {
-            schema,
-            parentSchema
-          } = error;
-          return `${dataPath} should not be ${this.getSchemaPartText(schema, false, true)}${parentSchema && likeObject(parentSchema) ? `\n${this.getSchemaPartText(parentSchema)}` : ""}`;
-        }
+			/** @type {SyncHook<[]>} */
+			beforeRuntimeRequirements: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterRuntimeRequirements: new SyncHook([]),
 
-      case "oneOf":
-      case "anyOf":
-        {
-          const {
-            parentSchema,
-            children
-          } = error;
+			/** @type {SyncHook<[]>} */
+			beforeHash: new SyncHook([]),
+			/** @type {SyncHook<[Chunk]>} */
+			contentHash: new SyncHook(["chunk"]),
+			/** @type {SyncHook<[]>} */
+			afterHash: new SyncHook([]),
+			/** @type {SyncHook<[any]>} */
+			recordHash: new SyncHook(["records"]),
+			/** @type {SyncHook<[Compilation, any]>} */
+			record: new SyncHook(["compilation", "records"]),
 
-          if (children && children.length > 0) {
-            if (error.schema.length === 1) {
-              const lastChild = children[children.length - 1];
-              const remainingChildren = children.slice(0, children.length - 1);
-              return this.formatValidationError(Object.assign({}, lastChild, {
-                children: remainingChildren,
-                parentSchema: Object.assign({}, parentSchema, lastChild.parentSchema)
-              }));
-            }
+			/** @type {SyncHook<[]>} */
+			beforeModuleAssets: new SyncHook([]),
+			/** @type {SyncBailHook<[], boolean>} */
+			shouldGenerateChunkAssets: new SyncBailHook([]),
+			/** @type {SyncHook<[]>} */
+			beforeChunkAssets: new SyncHook([]),
+			// TODO webpack 6 remove
+			/** @deprecated */
+			additionalChunkAssets: createProcessAssetsHook(
+				"additionalChunkAssets",
+				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+				() => [this.chunks],
+				"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
+			),
 
-            let filteredChildren = filterChildren(children);
+			// TODO webpack 6 deprecate
+			/** @deprecated */
+			additionalAssets: createProcessAssetsHook(
+				"additionalAssets",
+				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+				() => []
+			),
+			// TODO webpack 6 remove
+			/** @deprecated */
+			optimizeChunkAssets: createProcessAssetsHook(
+				"optimizeChunkAssets",
+				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
+				() => [this.chunks],
+				"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
+			),
+			// TODO webpack 6 remove
+			/** @deprecated */
+			afterOptimizeChunkAssets: createProcessAssetsHook(
+				"afterOptimizeChunkAssets",
+				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
+				() => [this.chunks],
+				"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
+			),
+			// TODO webpack 6 deprecate
+			/** @deprecated */
+			optimizeAssets: processAssetsHook,
+			// TODO webpack 6 deprecate
+			/** @deprecated */
+			afterOptimizeAssets: afterProcessAssetsHook,
 
-            if (filteredChildren.length === 1) {
-              return this.formatValidationError(filteredChildren[0]);
-            }
+			processAssets: processAssetsHook,
+			afterProcessAssets: afterProcessAssetsHook,
+			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
-            filteredChildren = groupChildrenByFirstChild(filteredChildren);
-            return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}\nDetails:\n${filteredChildren.map(
-            /**
-             * @param {SchemaUtilErrorObject} nestedError
-             * @returns {string}
-             */
-            nestedError => ` * ${indent(this.formatValidationError(nestedError), "   ")}`).join("\n")}`;
-          }
+			/** @type {SyncBailHook<[], boolean>} */
+			needAdditionalSeal: new SyncBailHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			afterSeal: new AsyncSeriesHook([]),
 
-          return `${dataPath} should be one of these:\n${this.getSchemaPartText(parentSchema)}`;
-        }
+			/** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */
+			renderManifest: new SyncWaterfallHook(["result", "options"]),
 
-      case "if":
-        {
-          const {
-            params,
-            parentSchema
-          } = error;
-          const {
-            failingKeyword
-          } =
-          /** @type {import("ajv").IfParams} */
-          params;
-          return `${dataPath} should match "${failingKeyword}" schema:\n${this.getSchemaPartText(parentSchema, [failingKeyword])}`;
-        }
+			/** @type {SyncHook<[Hash]>} */
+			fullHash: new SyncHook(["hash"]),
+			/** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */
+			chunkHash: new SyncHook(["chunk", "chunkHash", "ChunkHashContext"]),
 
-      case "absolutePath":
-        {
-          const {
-            message,
-            parentSchema
-          } = error;
-          return `${dataPath}: ${message}${this.getSchemaPartDescription(parentSchema)}`;
-        }
+			/** @type {SyncHook<[Module, string]>} */
+			moduleAsset: new SyncHook(["module", "filename"]),
+			/** @type {SyncHook<[Chunk, string]>} */
+			chunkAsset: new SyncHook(["chunk", "filename"]),
 
-      /* istanbul ignore next */
+			/** @type {SyncWaterfallHook<[string, object, AssetInfo]>} */
+			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
 
-      default:
-        {
-          const {
-            message,
-            parentSchema
-          } = error;
-          const ErrorInJSON = JSON.stringify(error, null, 2); // For `custom`, `false schema`, `$ref` keywords
-          // Fallback for unknown keywords
+			/** @type {SyncBailHook<[], boolean>} */
+			needAdditionalPass: new SyncBailHook([]),
 
-          return `${dataPath} ${message} (${ErrorInJSON}).\n${this.getSchemaPartText(parentSchema, false)}`;
-        }
-    }
-  }
-  /**
-   * @param {Array<SchemaUtilErrorObject>} errors
-   * @returns {string}
-   */
+			/** @type {SyncHook<[Compiler, string, number]>} */
+			childCompiler: new SyncHook([
+				"childCompiler",
+				"compilerName",
+				"compilerIndex"
+			]),
 
+			/** @type {SyncBailHook<[string, LogEntry], true>} */
+			log: new SyncBailHook(["origin", "logEntry"]),
 
-  formatValidationErrors(errors) {
-    return errors.map(error => {
-      let formattedError = this.formatValidationError(error);
+			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			processWarnings: new SyncWaterfallHook(["warnings"]),
+			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			processErrors: new SyncWaterfallHook(["errors"]),
 
-      if (this.postFormatter) {
-        formattedError = this.postFormatter(formattedError, error);
-      }
+			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
+			statsPreset: new HookMap(() => new SyncHook(["options", "context"])),
+			/** @type {SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>} */
+			statsNormalize: new SyncHook(["options", "context"]),
+			/** @type {SyncHook<[StatsFactory, NormalizedStatsOptions]>} */
+			statsFactory: new SyncHook(["statsFactory", "options"]),
+			/** @type {SyncHook<[StatsPrinter, NormalizedStatsOptions]>} */
+			statsPrinter: new SyncHook(["statsPrinter", "options"]),
 
-      return ` - ${indent(formattedError, "   ")}`;
-    }).join("\n");
-  }
+			get normalModuleLoader() {
+				return getNormalModuleLoader();
+			}
+		});
+		/** @type {string=} */
+		this.name = undefined;
+		this.startTime = undefined;
+		this.endTime = undefined;
+		/** @type {Compiler} */
+		this.compiler = compiler;
+		this.resolverFactory = compiler.resolverFactory;
+		this.inputFileSystem = compiler.inputFileSystem;
+		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
+			managedPaths: compiler.managedPaths,
+			immutablePaths: compiler.immutablePaths,
+			logger: this.getLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
+		});
+		if (compiler.fileTimestamps) {
+			this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
+		}
+		if (compiler.contextTimestamps) {
+			this.fileSystemInfo.addContextTimestamps(
+				compiler.contextTimestamps,
+				true
+			);
+		}
+		/** @type {Map<string, string | Set<string>>} */
+		this.valueCacheVersions = new Map();
+		this.requestShortener = compiler.requestShortener;
+		this.compilerPath = compiler.compilerPath;
 
-}
+		this.logger = this.getLogger("webpack.Compilation");
 
-var _default = ValidationError;
-exports.Z = _default;
+		const options = compiler.options;
+		this.options = options;
+		this.outputOptions = options && options.output;
+		/** @type {boolean} */
+		this.bail = (options && options.bail) || false;
+		/** @type {boolean} */
+		this.profile = (options && options.profile) || false;
 
-/***/ }),
-
-/***/ 81184:
-/***/ (function(module) {
-
-"use strict";
+		this.params = params;
+		this.mainTemplate = new MainTemplate(this.outputOptions, this);
+		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
+		this.runtimeTemplate = new RuntimeTemplate(
+			this,
+			this.outputOptions,
+			this.requestShortener
+		);
+		/** @type {{javascript: ModuleTemplate}} */
+		this.moduleTemplates = {
+			javascript: new ModuleTemplate(this.runtimeTemplate, this)
+		};
+		defineRemovedModuleTemplates(this.moduleTemplates);
 
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches = undefined;
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches2 = undefined;
+		this.moduleGraph = new ModuleGraph();
+		/** @type {ChunkGraph} */
+		this.chunkGraph = undefined;
+		/** @type {CodeGenerationResults} */
+		this.codeGenerationResults = undefined;
 
-/**
- * @typedef {[number, boolean]} RangeValue
- */
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.processDependenciesQueue = new AsyncQueue({
+			name: "processDependencies",
+			parallelism: options.parallelism || 100,
+			processor: this._processModuleDependencies.bind(this)
+		});
+		/** @type {AsyncQueue<Module, string, Module>} */
+		this.addModuleQueue = new AsyncQueue({
+			name: "addModule",
+			parent: this.processDependenciesQueue,
+			getKey: module => module.identifier(),
+			processor: this._addModule.bind(this)
+		});
+		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
+		this.factorizeQueue = new AsyncQueue({
+			name: "factorize",
+			parent: this.addModuleQueue,
+			processor: this._factorizeModule.bind(this)
+		});
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.buildQueue = new AsyncQueue({
+			name: "build",
+			parent: this.factorizeQueue,
+			processor: this._buildModule.bind(this)
+		});
+		/** @type {AsyncQueue<Module, Module, Module>} */
+		this.rebuildQueue = new AsyncQueue({
+			name: "rebuild",
+			parallelism: options.parallelism || 100,
+			processor: this._rebuildModule.bind(this)
+		});
 
-/**
- * @callback RangeValueCallback
- * @param {RangeValue} rangeValue
- * @returns {boolean}
- */
-class Range {
-  /**
-   * @param {"left" | "right"} side
-   * @param {boolean} exclusive
-   * @returns {">" | ">=" | "<" | "<="}
-   */
-  static getOperator(side, exclusive) {
-    if (side === "left") {
-      return exclusive ? ">" : ">=";
-    }
+		/**
+		 * Modules in value are building during the build of Module in key.
+		 * Means value blocking key from finishing.
+		 * Needed to detect build cycles.
+		 * @type {WeakMap<Module, Set<Module>>}
+		 */
+		this.creatingModuleDuringBuild = new WeakMap();
 
-    return exclusive ? "<" : "<=";
-  }
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
+		/** @type {Map<string, EntryData>} */
+		this.entries = new Map();
+		/** @type {EntryData} */
+		this.globalEntry = {
+			dependencies: [],
+			includeDependencies: [],
+			options: {
+				name: undefined
+			}
+		};
+		/** @type {Map<string, Entrypoint>} */
+		this.entrypoints = new Map();
+		/** @type {Entrypoint[]} */
+		this.asyncEntrypoints = [];
+		/** @type {Set<Chunk>} */
+		this.chunks = new Set();
+		/** @type {ChunkGroup[]} */
+		this.chunkGroups = [];
+		/** @type {Map<string, ChunkGroup>} */
+		this.namedChunkGroups = new Map();
+		/** @type {Map<string, Chunk>} */
+		this.namedChunks = new Map();
+		/** @type {Set<Module>} */
+		this.modules = new Set();
+		if (this._backCompat) {
+			arrayToSetDeprecation(this.chunks, "Compilation.chunks");
+			arrayToSetDeprecation(this.modules, "Compilation.modules");
+		}
+		/** @private @type {Map<string, Module>} */
+		this._modules = new Map();
+		this.records = null;
+		/** @type {string[]} */
+		this.additionalChunkAssets = [];
+		/** @type {CompilationAssets} */
+		this.assets = {};
+		/** @type {Map<string, AssetInfo>} */
+		this.assetsInfo = new Map();
+		/** @type {Map<string, Map<string, Set<string>>>} */
+		this._assetsRelatedIn = new Map();
+		/** @type {WebpackError[]} */
+		this.errors = [];
+		/** @type {WebpackError[]} */
+		this.warnings = [];
+		/** @type {Compilation[]} */
+		this.children = [];
+		/** @type {Map<string, LogEntry[]>} */
+		this.logging = new Map();
+		/** @type {Map<DepConstructor, ModuleFactory>} */
+		this.dependencyFactories = new Map();
+		/** @type {DependencyTemplates} */
+		this.dependencyTemplates = new DependencyTemplates(
+			this.outputOptions.hashFunction
+		);
+		this.childrenCounters = {};
+		/** @type {Set<number|string>} */
+		this.usedChunkIds = null;
+		/** @type {Set<number>} */
+		this.usedModuleIds = null;
+		/** @type {boolean} */
+		this.needAdditionalPass = false;
+		/** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheModuleEntries = new Set();
+		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
+		this._restoredUnsafeCacheEntries = new Map();
+		/** @type {WeakSet<Module>} */
+		this.builtModules = new WeakSet();
+		/** @type {WeakSet<Module>} */
+		this.codeGeneratedModules = new WeakSet();
+		/** @type {WeakSet<Module>} */
+		this.buildTimeExecutedModules = new WeakSet();
+		/** @private @type {Map<Module, Callback[]>} */
+		this._rebuildingModules = new Map();
+		/** @type {Set<string>} */
+		this.emittedAssets = new Set();
+		/** @type {Set<string>} */
+		this.comparedForEmitAssets = new Set();
+		/** @type {LazySet<string>} */
+		this.fileDependencies = new LazySet();
+		/** @type {LazySet<string>} */
+		this.contextDependencies = new LazySet();
+		/** @type {LazySet<string>} */
+		this.missingDependencies = new LazySet();
+		/** @type {LazySet<string>} */
+		this.buildDependencies = new LazySet();
+		// TODO webpack 6 remove
+		this.compilationDependencies = {
+			add: util.deprecate(
+				item => this.fileDependencies.add(item),
+				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
+				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
+			)
+		};
 
+		this._modulesCache = this.getCache("Compilation/modules");
+		this._assetsCache = this.getCache("Compilation/assets");
+		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
 
-  static formatRight(value, logic, exclusive) {
-    if (logic === false) {
-      return Range.formatLeft(value, !logic, !exclusive);
-    }
+		const unsafeCache = options.module.unsafeCache;
+		this._unsafeCache = !!unsafeCache;
+		this._unsafeCachePredicate =
+			typeof unsafeCache === "function" ? unsafeCache : () => true;
+	}
 
-    return `should be ${Range.getOperator("right", exclusive)} ${value}`;
-  }
-  /**
-   * @param {number} value
-   * @param {boolean} logic is not logic applied
-   * @param {boolean} exclusive is range exclusive
-   * @returns {string}
-   */
+	getStats() {
+		return new Stats(this);
+	}
 
+	/**
+	 * @param {StatsOptions | string} optionsOrPreset stats option value
+	 * @param {CreateStatsOptionsContext} context context
+	 * @returns {NormalizedStatsOptions} normalized options
+	 */
+	createStatsOptions(optionsOrPreset, context = {}) {
+		if (
+			typeof optionsOrPreset === "boolean" ||
+			typeof optionsOrPreset === "string"
+		) {
+			optionsOrPreset = { preset: optionsOrPreset };
+		}
+		if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
+			// We use this method of shallow cloning this object to include
+			// properties in the prototype chain
+			/** @type {Partial<NormalizedStatsOptions>} */
+			const options = {};
+			for (const key in optionsOrPreset) {
+				options[key] = optionsOrPreset[key];
+			}
+			if (options.preset !== undefined) {
+				this.hooks.statsPreset.for(options.preset).call(options, context);
+			}
+			this.hooks.statsNormalize.call(options, context);
+			return /** @type {NormalizedStatsOptions} */ (options);
+		} else {
+			/** @type {Partial<NormalizedStatsOptions>} */
+			const options = {};
+			this.hooks.statsNormalize.call(options, context);
+			return /** @type {NormalizedStatsOptions} */ (options);
+		}
+	}
 
-  static formatLeft(value, logic, exclusive) {
-    if (logic === false) {
-      return Range.formatRight(value, !logic, !exclusive);
-    }
+	createStatsFactory(options) {
+		const statsFactory = new StatsFactory();
+		this.hooks.statsFactory.call(statsFactory, options);
+		return statsFactory;
+	}
 
-    return `should be ${Range.getOperator("left", exclusive)} ${value}`;
-  }
-  /**
-   * @param {number} start left side value
-   * @param {number} end right side value
-   * @param {boolean} startExclusive is range exclusive from left side
-   * @param {boolean} endExclusive is range exclusive from right side
-   * @param {boolean} logic is not logic applied
-   * @returns {string}
-   */
+	createStatsPrinter(options) {
+		const statsPrinter = new StatsPrinter();
+		this.hooks.statsPrinter.call(statsPrinter, options);
+		return statsPrinter;
+	}
 
+	/**
+	 * @param {string} name cache name
+	 * @returns {CacheFacade} the cache facade instance
+	 */
+	getCache(name) {
+		return this.compiler.getCache(name);
+	}
 
-  static formatRange(start, end, startExclusive, endExclusive, logic) {
-    let result = "should be";
-    result += ` ${Range.getOperator(logic ? "left" : "right", logic ? startExclusive : !startExclusive)} ${start} `;
-    result += logic ? "and" : "or";
-    result += ` ${Range.getOperator(logic ? "right" : "left", logic ? endExclusive : !endExclusive)} ${end}`;
-    return result;
-  }
-  /**
-   * @param {Array<RangeValue>} values
-   * @param {boolean} logic is not logic applied
-   * @return {RangeValue} computed value and it's exclusive flag
-   */
+	/**
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
+	 */
+	getLogger(name) {
+		if (!name) {
+			throw new TypeError("Compilation.getLogger(name) called without a name");
+		}
+		/** @type {LogEntry[] | undefined} */
+		let logEntries;
+		return new Logger(
+			(type, args) => {
+				if (typeof name === "function") {
+					name = name();
+					if (!name) {
+						throw new TypeError(
+							"Compilation.getLogger(name) called with a function not returning a name"
+						);
+					}
+				}
+				let trace;
+				switch (type) {
+					case LogType.warn:
+					case LogType.error:
+					case LogType.trace:
+						trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+							.split("\n")
+							.slice(3);
+						break;
+				}
+				/** @type {LogEntry} */
+				const logEntry = {
+					time: Date.now(),
+					type,
+					args,
+					trace
+				};
+				if (this.hooks.log.call(name, logEntry) === undefined) {
+					if (logEntry.type === LogType.profileEnd) {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						if (typeof console.profileEnd === "function") {
+							// eslint-disable-next-line node/no-unsupported-features/node-builtins
+							console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+						}
+					}
+					if (logEntries === undefined) {
+						logEntries = this.logging.get(name);
+						if (logEntries === undefined) {
+							logEntries = [];
+							this.logging.set(name, logEntries);
+						}
+					}
+					logEntries.push(logEntry);
+					if (logEntry.type === LogType.profile) {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						if (typeof console.profile === "function") {
+							// eslint-disable-next-line node/no-unsupported-features/node-builtins
+							console.profile(`[${name}] ${logEntry.args[0]}`);
+						}
+					}
+				}
+			},
+			childName => {
+				if (typeof name === "function") {
+					if (typeof childName === "function") {
+						return this.getLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compilation.getLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
+						});
+					} else {
+						return this.getLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compilation.getLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
+						});
+					}
+				} else {
+					if (typeof childName === "function") {
+						return this.getLogger(() => {
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
+						});
+					} else {
+						return this.getLogger(`${name}/${childName}`);
+					}
+				}
+			}
+		);
+	}
 
+	/**
+	 * @param {Module} module module to be added that was created
+	 * @param {ModuleCallback} callback returns the module in the compilation,
+	 * it could be the passed one (if new), or an already existing in the compilation
+	 * @returns {void}
+	 */
+	addModule(module, callback) {
+		this.addModuleQueue.add(module, callback);
+	}
 
-  static getRangeValue(values, logic) {
-    let minMax = logic ? Infinity : -Infinity;
-    let j = -1;
-    const predicate = logic ?
-    /** @type {RangeValueCallback} */
-    ([value]) => value <= minMax :
-    /** @type {RangeValueCallback} */
-    ([value]) => value >= minMax;
+	/**
+	 * @param {Module} module module to be added that was created
+	 * @param {ModuleCallback} callback returns the module in the compilation,
+	 * it could be the passed one (if new), or an already existing in the compilation
+	 * @returns {void}
+	 */
+	_addModule(module, callback) {
+		const identifier = module.identifier();
+		const alreadyAddedModule = this._modules.get(identifier);
+		if (alreadyAddedModule) {
+			return callback(null, alreadyAddedModule);
+		}
 
-    for (let i = 0; i < values.length; i++) {
-      if (predicate(values[i])) {
-        [minMax] = values[i];
-        j = i;
-      }
-    }
+		const currentProfile = this.profile
+			? this.moduleGraph.getProfile(module)
+			: undefined;
+		if (currentProfile !== undefined) {
+			currentProfile.markRestoringStart();
+		}
 
-    if (j > -1) {
-      return values[j];
-    }
+		this._modulesCache.get(identifier, null, (err, cacheModule) => {
+			if (err) return callback(new ModuleRestoreError(module, err));
 
-    return [Infinity, true];
-  }
+			if (currentProfile !== undefined) {
+				currentProfile.markRestoringEnd();
+				currentProfile.markIntegrationStart();
+			}
 
-  constructor() {
-    /** @type {Array<RangeValue>} */
-    this._left = [];
-    /** @type {Array<RangeValue>} */
+			if (cacheModule) {
+				cacheModule.updateCacheModule(module);
 
-    this._right = [];
-  }
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
+				module = cacheModule;
+			}
+			this._modules.set(identifier, module);
+			this.modules.add(module);
+			if (this._backCompat)
+				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+			if (currentProfile !== undefined) {
+				currentProfile.markIntegrationEnd();
+			}
+			callback(null, module);
+		});
+	}
 
+	/**
+	 * Fetches a module from a compilation by its identifier
+	 * @param {Module} module the module provided
+	 * @returns {Module} the module requested
+	 */
+	getModule(module) {
+		const identifier = module.identifier();
+		return this._modules.get(identifier);
+	}
 
-  left(value, exclusive = false) {
-    this._left.push([value, exclusive]);
-  }
-  /**
-   * @param {number} value
-   * @param {boolean=} exclusive
-   */
+	/**
+	 * Attempts to search for a module by its identifier
+	 * @param {string} identifier identifier (usually path) for module
+	 * @returns {Module|undefined} attempt to search for module and return it, else undefined
+	 */
+	findModule(identifier) {
+		return this._modules.get(identifier);
+	}
 
+	/**
+	 * Schedules a build of the module object
+	 *
+	 * @param {Module} module module to be built
+	 * @param {ModuleCallback} callback the callback
+	 * @returns {void}
+	 */
+	buildModule(module, callback) {
+		this.buildQueue.add(module, callback);
+	}
 
-  right(value, exclusive = false) {
-    this._right.push([value, exclusive]);
-  }
-  /**
-   * @param {boolean} logic is not logic applied
-   * @return {string} "smart" range string representation
-   */
-
-
-  format(logic = true) {
-    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
-    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
-
-    if (!Number.isFinite(start) && !Number.isFinite(end)) {
-      return "";
-    }
-
-    const realStart = leftExclusive ? start + 1 : start;
-    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
-
-    if (realStart === realEnd) {
-      return `should be ${logic ? "" : "!"}= ${realStart}`;
-    } // e.g. 4 < x < ∞
-
-
-    if (Number.isFinite(start) && !Number.isFinite(end)) {
-      return Range.formatLeft(start, logic, leftExclusive);
-    } // e.g. ∞ < x < 4
+	/**
+	 * Builds the module object
+	 *
+	 * @param {Module} module module to be built
+	 * @param {ModuleCallback} callback the callback
+	 * @returns {void}
+	 */
+	_buildModule(module, callback) {
+		const currentProfile = this.profile
+			? this.moduleGraph.getProfile(module)
+			: undefined;
+		if (currentProfile !== undefined) {
+			currentProfile.markBuildingStart();
+		}
 
+		module.needBuild(
+			{
+				compilation: this,
+				fileSystemInfo: this.fileSystemInfo,
+				valueCacheVersions: this.valueCacheVersions
+			},
+			(err, needBuild) => {
+				if (err) return callback(err);
 
-    if (!Number.isFinite(start) && Number.isFinite(end)) {
-      return Range.formatRight(end, logic, rightExclusive);
-    }
+				if (!needBuild) {
+					if (currentProfile !== undefined) {
+						currentProfile.markBuildingEnd();
+					}
+					this.hooks.stillValidModule.call(module);
+					return callback();
+				}
 
-    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
-  }
+				this.hooks.buildModule.call(module);
+				this.builtModules.add(module);
+				module.build(
+					this.options,
+					this,
+					this.resolverFactory.get("normal", module.resolveOptions),
+					this.inputFileSystem,
+					err => {
+						if (currentProfile !== undefined) {
+							currentProfile.markBuildingEnd();
+						}
+						if (err) {
+							this.hooks.failedModule.call(module, err);
+							return callback(err);
+						}
+						if (currentProfile !== undefined) {
+							currentProfile.markStoringStart();
+						}
+						this._modulesCache.store(module.identifier(), null, module, err => {
+							if (currentProfile !== undefined) {
+								currentProfile.markStoringEnd();
+							}
+							if (err) {
+								this.hooks.failedModule.call(module, err);
+								return callback(new ModuleStoreError(module, err));
+							}
+							this.hooks.succeedModule.call(module);
+							return callback();
+						});
+					}
+				);
+			}
+		);
+	}
 
-}
+	/**
+	 * @param {Module} module to be processed for deps
+	 * @param {ModuleCallback} callback callback to be triggered
+	 * @returns {void}
+	 */
+	processModuleDependencies(module, callback) {
+		this.processDependenciesQueue.add(module, callback);
+	}
 
-module.exports = Range;
+	/**
+	 * @param {Module} module to be processed for deps
+	 * @returns {void}
+	 */
+	processModuleDependenciesNonRecursive(module) {
+		const processDependenciesBlock = block => {
+			if (block.dependencies) {
+				let i = 0;
+				for (const dep of block.dependencies) {
+					this.moduleGraph.setParents(dep, block, module, i++);
+				}
+			}
+			if (block.blocks) {
+				for (const b of block.blocks) processDependenciesBlock(b);
+			}
+		};
 
-/***/ }),
+		processDependenciesBlock(module);
+	}
 
-/***/ 79926:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Module} module to be processed for deps
+	 * @param {ModuleCallback} callback callback to be triggered
+	 * @returns {void}
+	 */
+	_processModuleDependencies(module, callback) {
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
+		const sortedDependencies = [];
 
-"use strict";
+		/** @type {DependenciesBlock} */
+		let currentBlock;
 
+		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
+		let dependencies;
+		/** @type {DepConstructor} */
+		let factoryCacheKey;
+		/** @type {ModuleFactory} */
+		let factoryCacheKey2;
+		/** @type {Map<string, Dependency[]>} */
+		let factoryCacheValue;
+		/** @type {string} */
+		let listCacheKey1;
+		/** @type {string} */
+		let listCacheKey2;
+		/** @type {Dependency[]} */
+		let listCacheValue;
 
-const Range = __webpack_require__(81184);
-/** @typedef {import("../validate").Schema} Schema */
+		let inProgressSorting = 1;
+		let inProgressTransitive = 1;
 
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @return {string[]}
- */
+		const onDependenciesSorted = err => {
+			if (err) return callback(err);
 
+			// early exit without changing parallelism back and forth
+			if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
+				return callback();
+			}
 
-module.exports.stringHints = function stringHints(schema, logic) {
-  const hints = [];
-  let type = "string";
-  const currentSchema = { ...schema
-  };
+			// This is nested so we need to allow one additional task
+			this.processDependenciesQueue.increaseParallelism();
 
-  if (!logic) {
-    const tmpLength = currentSchema.minLength;
-    const tmpFormat = currentSchema.formatMinimum;
-    const tmpExclusive = currentSchema.formatExclusiveMaximum;
-    currentSchema.minLength = currentSchema.maxLength;
-    currentSchema.maxLength = tmpLength;
-    currentSchema.formatMinimum = currentSchema.formatMaximum;
-    currentSchema.formatMaximum = tmpFormat;
-    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
-    currentSchema.formatExclusiveMinimum = !tmpExclusive;
-  }
+			for (const item of sortedDependencies) {
+				inProgressTransitive++;
+				this.handleModuleCreation(item, err => {
+					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
+					// errors are created inside closures that keep a reference to the Compilation, so errors are
+					// leaking the Compilation object.
+					if (err && this.bail) {
+						if (inProgressTransitive <= 0) return;
+						inProgressTransitive = -1;
+						// eslint-disable-next-line no-self-assign
+						err.stack = err.stack;
+						onTransitiveTasksFinished(err);
+						return;
+					}
+					if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+				});
+			}
+			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+		};
 
-  if (typeof currentSchema.minLength === "number") {
-    if (currentSchema.minLength === 1) {
-      type = "non-empty string";
-    } else {
-      const length = Math.max(currentSchema.minLength - 1, 0);
-      hints.push(`should be longer than ${length} character${length > 1 ? "s" : ""}`);
-    }
-  }
+		const onTransitiveTasksFinished = err => {
+			if (err) return callback(err);
+			this.processDependenciesQueue.decreaseParallelism();
 
-  if (typeof currentSchema.maxLength === "number") {
-    if (currentSchema.maxLength === 0) {
-      type = "empty string";
-    } else {
-      const length = currentSchema.maxLength + 1;
-      hints.push(`should be shorter than ${length} character${length > 1 ? "s" : ""}`);
-    }
-  }
+			return callback();
+		};
 
-  if (currentSchema.pattern) {
-    hints.push(`should${logic ? "" : " not"} match pattern ${JSON.stringify(currentSchema.pattern)}`);
-  }
+		/**
+		 * @param {Dependency} dep dependency
+		 * @param {number} index index in block
+		 * @returns {void}
+		 */
+		const processDependency = (dep, index) => {
+			this.moduleGraph.setParents(dep, currentBlock, module, index);
+			if (this._unsafeCache) {
+				try {
+					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
+					if (unsafeCachedModule === null) return;
+					if (unsafeCachedModule !== undefined) {
+						if (
+							this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
+						) {
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								unsafeCachedModule
+							);
+							return;
+						}
+						const identifier = unsafeCachedModule.identifier();
+						const cachedModule =
+							this._restoredUnsafeCacheEntries.get(identifier);
+						if (cachedModule !== undefined) {
+							// update unsafe cache to new module
+							unsafeCacheDependencies.set(dep, cachedModule);
+							this._handleExistingModuleFromUnsafeCache(
+								module,
+								dep,
+								cachedModule
+							);
+							return;
+						}
+						inProgressSorting++;
+						this._modulesCache.get(identifier, null, (err, cachedModule) => {
+							if (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
+								return;
+							}
+							try {
+								if (!this._restoredUnsafeCacheEntries.has(identifier)) {
+									const data = unsafeCacheData.get(cachedModule);
+									if (data === undefined) {
+										processDependencyForResolving(dep);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+									if (cachedModule !== unsafeCachedModule) {
+										unsafeCacheDependencies.set(dep, cachedModule);
+									}
+									cachedModule.restoreFromUnsafeCache(
+										data,
+										this.params.normalModuleFactory,
+										this.params
+									);
+									this._restoredUnsafeCacheEntries.set(
+										identifier,
+										cachedModule
+									);
+									this._restoredUnsafeCacheModuleEntries.add(cachedModule);
+									if (!this.modules.has(cachedModule)) {
+										inProgressTransitive++;
+										this._handleNewModuleFromUnsafeCache(
+											module,
+											dep,
+											cachedModule,
+											err => {
+												if (err) {
+													if (inProgressTransitive <= 0) return;
+													inProgressTransitive = -1;
+													onTransitiveTasksFinished(err);
+												}
+												if (--inProgressTransitive === 0)
+													return onTransitiveTasksFinished();
+											}
+										);
+										if (--inProgressSorting === 0) onDependenciesSorted();
+										return;
+									}
+								}
+								if (unsafeCachedModule !== cachedModule) {
+									unsafeCacheDependencies.set(dep, cachedModule);
+								}
+								this._handleExistingModuleFromUnsafeCache(
+									module,
+									dep,
+									cachedModule
+								); // a3
+							} catch (err) {
+								if (inProgressSorting <= 0) return;
+								inProgressSorting = -1;
+								onDependenciesSorted(err);
+								return;
+							}
+							if (--inProgressSorting === 0) onDependenciesSorted();
+						});
+						return;
+					}
+				} catch (e) {
+					console.error(e);
+				}
+			}
+			processDependencyForResolving(dep);
+		};
 
-  if (currentSchema.format) {
-    hints.push(`should${logic ? "" : " not"} match format ${JSON.stringify(currentSchema.format)}`);
-  }
+		/**
+		 * @param {Dependency} dep dependency
+		 * @returns {void}
+		 */
+		const processDependencyForResolving = dep => {
+			const resourceIdent = dep.getResourceIdentifier();
+			if (resourceIdent !== undefined && resourceIdent !== null) {
+				const category = dep.category;
+				const constructor = /** @type {DepConstructor} */ (dep.constructor);
+				if (factoryCacheKey === constructor) {
+					// Fast path 1: same constructor as prev item
+					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+						// Super fast path 1: also same resource
+						listCacheValue.push(dep);
+						return;
+					}
+				} else {
+					const factory = this.dependencyFactories.get(constructor);
+					if (factory === undefined) {
+						throw new Error(
+							`No module factory available for dependency type: ${constructor.name}`
+						);
+					}
+					if (factoryCacheKey2 === factory) {
+						// Fast path 2: same factory as prev item
+						factoryCacheKey = constructor;
+						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+							// Super fast path 2: also same resource
+							listCacheValue.push(dep);
+							return;
+						}
+					} else {
+						// Slow path
+						if (factoryCacheKey2 !== undefined) {
+							// Archive last cache entry
+							if (dependencies === undefined) dependencies = new Map();
+							dependencies.set(factoryCacheKey2, factoryCacheValue);
+							factoryCacheValue = dependencies.get(factory);
+							if (factoryCacheValue === undefined) {
+								factoryCacheValue = new Map();
+							}
+						} else {
+							factoryCacheValue = new Map();
+						}
+						factoryCacheKey = constructor;
+						factoryCacheKey2 = factory;
+					}
+				}
+				// Here webpack is using heuristic that assumes
+				// mostly esm dependencies would be used
+				// so we don't allocate extra string for them
+				const cacheKey =
+					category === esmDependencyCategory
+						? resourceIdent
+						: `${category}${resourceIdent}`;
+				let list = factoryCacheValue.get(cacheKey);
+				if (list === undefined) {
+					factoryCacheValue.set(cacheKey, (list = []));
+					sortedDependencies.push({
+						factory: factoryCacheKey2,
+						dependencies: list,
+						originModule: module
+					});
+				}
+				list.push(dep);
+				listCacheKey1 = category;
+				listCacheKey2 = resourceIdent;
+				listCacheValue = list;
+			}
+		};
 
-  if (currentSchema.formatMinimum) {
-    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? ">" : ">="} ${JSON.stringify(currentSchema.formatMinimum)}`);
-  }
+		try {
+			/** @type {DependenciesBlock[]} */
+			const queue = [module];
+			do {
+				const block = queue.pop();
+				if (block.dependencies) {
+					currentBlock = block;
+					let i = 0;
+					for (const dep of block.dependencies) processDependency(dep, i++);
+				}
+				if (block.blocks) {
+					for (const b of block.blocks) queue.push(b);
+				}
+			} while (queue.length !== 0);
+		} catch (e) {
+			return callback(e);
+		}
 
-  if (currentSchema.formatMaximum) {
-    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? "<" : "<="} ${JSON.stringify(currentSchema.formatMaximum)}`);
-  }
+		if (--inProgressSorting === 0) onDependenciesSorted();
+	}
 
-  return [type].concat(hints);
-};
-/**
- * @param {Schema} schema
- * @param {boolean} logic
- * @return {string[]}
- */
+	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
+		const moduleGraph = this.moduleGraph;
 
+		moduleGraph.setResolvedModule(originModule, dependency, module);
 
-module.exports.numberHints = function numberHints(schema, logic) {
-  const hints = [schema.type === "integer" ? "integer" : "number"];
-  const range = new Range();
+		moduleGraph.setIssuerIfUnset(
+			module,
+			originModule !== undefined ? originModule : null
+		);
 
-  if (typeof schema.minimum === "number") {
-    range.left(schema.minimum);
-  }
+		this._modules.set(module.identifier(), module);
+		this.modules.add(module);
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
-  if (typeof schema.exclusiveMinimum === "number") {
-    range.left(schema.exclusiveMinimum, true);
-  }
+		this._handleModuleBuildAndDependencies(
+			originModule,
+			module,
+			true,
+			callback
+		);
+	}
 
-  if (typeof schema.maximum === "number") {
-    range.right(schema.maximum);
-  }
+	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
+		const moduleGraph = this.moduleGraph;
 
-  if (typeof schema.exclusiveMaximum === "number") {
-    range.right(schema.exclusiveMaximum, true);
-  }
+		moduleGraph.setResolvedModule(originModule, dependency, module);
+	}
 
-  const rangeFormat = range.format(logic);
+	/**
+	 * @typedef {Object} HandleModuleCreationOptions
+	 * @property {ModuleFactory} factory
+	 * @property {Dependency[]} dependencies
+	 * @property {Module | null} originModule
+	 * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+	 * @property {string=} context
+	 * @property {boolean=} recursive recurse into dependencies of the created module
+	 * @property {boolean=} connectOrigin connect the resolved module with the origin module
+	 */
 
-  if (rangeFormat) {
-    hints.push(rangeFormat);
-  }
+	/**
+	 * @param {HandleModuleCreationOptions} options options object
+	 * @param {ModuleCallback} callback callback
+	 * @returns {void}
+	 */
+	handleModuleCreation(
+		{
+			factory,
+			dependencies,
+			originModule,
+			contextInfo,
+			context,
+			recursive = true,
+			connectOrigin = recursive
+		},
+		callback
+	) {
+		const moduleGraph = this.moduleGraph;
 
-  if (typeof schema.multipleOf === "number") {
-    hints.push(`should${logic ? "" : " not"} be multiple of ${schema.multipleOf}`);
-  }
+		const currentProfile = this.profile ? new ModuleProfile() : undefined;
 
-  return hints;
-};
-
-/***/ }),
-
-/***/ 18151:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
-
-class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, onDone }) {
-		let code = "";
-		code += `var _results = new Array(${this.options.taps.length});\n`;
-		code += "var _checkDone = function() {\n";
-		code += "for(var i = 0; i < _results.length; i++) {\n";
-		code += "var item = _results[i];\n";
-		code += "if(item === undefined) return false;\n";
-		code += "if(item.result !== undefined) {\n";
-		code += onResult("item.result");
-		code += "return true;\n";
-		code += "}\n";
-		code += "if(item.error) {\n";
-		code += onError("item.error");
-		code += "return true;\n";
-		code += "}\n";
-		code += "}\n";
-		code += "return false;\n";
-		code += "}\n";
-		code += this.callTapsParallel({
-			onError: (i, err, done, doneBreak) => {
-				let code = "";
-				code += `if(${i} < _results.length && ((_results.length = ${i +
-					1}), (_results[${i}] = { error: ${err} }), _checkDone())) {\n`;
-				code += doneBreak(true);
-				code += "} else {\n";
-				code += done();
-				code += "}\n";
-				return code;
-			},
-			onResult: (i, result, done, doneBreak) => {
-				let code = "";
-				code += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i +
-					1}), (_results[${i}] = { result: ${result} }), _checkDone())) {\n`;
-				code += doneBreak(true);
-				code += "} else {\n";
-				code += done();
-				code += "}\n";
-				return code;
+		this.factorizeModule(
+			{
+				currentProfile,
+				factory,
+				dependencies,
+				factoryResult: true,
+				originModule,
+				contextInfo,
+				context
 			},
-			onTap: (i, run, done, doneBreak) => {
-				let code = "";
-				if (i > 0) {
-					code += `if(${i} >= _results.length) {\n`;
-					code += done();
-					code += "} else {\n";
+			(err, factoryResult) => {
+				const applyFactoryResultDependencies = () => {
+					const { fileDependencies, contextDependencies, missingDependencies } =
+						factoryResult;
+					if (fileDependencies) {
+						this.fileDependencies.addAll(fileDependencies);
+					}
+					if (contextDependencies) {
+						this.contextDependencies.addAll(contextDependencies);
+					}
+					if (missingDependencies) {
+						this.missingDependencies.addAll(missingDependencies);
+					}
+				};
+				if (err) {
+					if (factoryResult) applyFactoryResultDependencies();
+					if (dependencies.every(d => d.optional)) {
+						this.warnings.push(err);
+						return callback();
+					} else {
+						this.errors.push(err);
+						return callback(err);
+					}
 				}
-				code += run();
-				if (i > 0) code += "}\n";
-				return code;
-			},
-			onDone
-		});
-		return code;
-	}
-}
-
-const factory = new AsyncParallelBailHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncParallelBailHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncParallelBailHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncParallelBailHook.prototype = null;
 
-module.exports = AsyncParallelBailHook;
+				const newModule = factoryResult.module;
 
+				if (!newModule) {
+					applyFactoryResultDependencies();
+					return callback();
+				}
 
-/***/ }),
+				if (currentProfile !== undefined) {
+					moduleGraph.setProfile(newModule, currentProfile);
+				}
 
-/***/ 31684:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				this.addModule(newModule, (err, module) => {
+					if (err) {
+						applyFactoryResultDependencies();
+						if (!err.module) {
+							err.module = module;
+						}
+						this.errors.push(err);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+						return callback(err);
+					}
 
+					if (
+						this._unsafeCache &&
+						factoryResult.cacheable !== false &&
+						/** @type {any} */ (module).restoreFromUnsafeCache &&
+						this._unsafeCachePredicate(module)
+					) {
+						const unsafeCacheableModule =
+							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
+								module
+							);
+						for (let i = 0; i < dependencies.length; i++) {
+							const dependency = dependencies[i];
+							moduleGraph.setResolvedModule(
+								connectOrigin ? originModule : null,
+								dependency,
+								unsafeCacheableModule
+							);
+							unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
+						}
+						if (!unsafeCacheData.has(unsafeCacheableModule)) {
+							unsafeCacheData.set(
+								unsafeCacheableModule,
+								unsafeCacheableModule.getUnsafeCacheData()
+							);
+						}
+					} else {
+						applyFactoryResultDependencies();
+						for (let i = 0; i < dependencies.length; i++) {
+							const dependency = dependencies[i];
+							moduleGraph.setResolvedModule(
+								connectOrigin ? originModule : null,
+								dependency,
+								module
+							);
+						}
+					}
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+					moduleGraph.setIssuerIfUnset(
+						module,
+						originModule !== undefined ? originModule : null
+					);
+					if (module !== newModule) {
+						if (currentProfile !== undefined) {
+							const otherProfile = moduleGraph.getProfile(module);
+							if (otherProfile !== undefined) {
+								currentProfile.mergeInto(otherProfile);
+							} else {
+								moduleGraph.setProfile(module, currentProfile);
+							}
+						}
+					}
 
-class AsyncParallelHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone }) {
-		return this.callTapsParallel({
-			onError: (i, err, done, doneBreak) => onError(err) + doneBreak(true),
-			onDone
-		});
+					this._handleModuleBuildAndDependencies(
+						originModule,
+						module,
+						recursive,
+						callback
+					);
+				});
+			}
+		);
 	}
-}
-
-const factory = new AsyncParallelHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncParallelHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncParallelHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncParallelHook.prototype = null;
-
-module.exports = AsyncParallelHook;
 
+	_handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
+		// Check for cycles when build is trigger inside another build
+		let creatingModuleDuringBuildSet = undefined;
+		if (!recursive && this.buildQueue.isProcessing(originModule)) {
+			// Track build dependency
+			creatingModuleDuringBuildSet =
+				this.creatingModuleDuringBuild.get(originModule);
+			if (creatingModuleDuringBuildSet === undefined) {
+				creatingModuleDuringBuildSet = new Set();
+				this.creatingModuleDuringBuild.set(
+					originModule,
+					creatingModuleDuringBuildSet
+				);
+			}
+			creatingModuleDuringBuildSet.add(module);
 
-/***/ }),
+			// When building is blocked by another module
+			// search for a cycle, cancel the cycle by throwing
+			// an error (otherwise this would deadlock)
+			const blockReasons = this.creatingModuleDuringBuild.get(module);
+			if (blockReasons !== undefined) {
+				const set = new Set(blockReasons);
+				for (const item of set) {
+					const blockReasons = this.creatingModuleDuringBuild.get(item);
+					if (blockReasons !== undefined) {
+						for (const m of blockReasons) {
+							if (m === module) {
+								return callback(new BuildCycleError(module));
+							}
+							set.add(m);
+						}
+					}
+				}
+			}
+		}
 
-/***/ 95734:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		this.buildModule(module, err => {
+			if (creatingModuleDuringBuildSet !== undefined) {
+				creatingModuleDuringBuildSet.delete(module);
+			}
+			if (err) {
+				if (!err.module) {
+					err.module = module;
+				}
+				this.errors.push(err);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				return callback(err);
+			}
 
+			if (!recursive) {
+				this.processModuleDependenciesNonRecursive(module);
+				callback(null, module);
+				return;
+			}
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+			// This avoids deadlocks for circular dependencies
+			if (this.processDependenciesQueue.isProcessing(module)) {
+				return callback();
+			}
 
-class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, resultReturns, onDone }) {
-		return this.callTapsSeries({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onResult: (i, result, next) =>
-				`if(${result} !== undefined) {\n${onResult(
-					result
-				)}\n} else {\n${next()}}\n`,
-			resultReturns,
-			onDone
+			this.processModuleDependencies(module, err => {
+				if (err) {
+					return callback(err);
+				}
+				callback(null, module);
+			});
 		});
 	}
-}
-
-const factory = new AsyncSeriesBailHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncSeriesBailHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesBailHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncSeriesBailHook.prototype = null;
 
-module.exports = AsyncSeriesBailHook;
+	/**
+	 * @param {FactorizeModuleOptions} options options object
+	 * @param {ModuleOrFactoryResultCallback} callback callback
+	 * @returns {void}
+	 */
+	_factorizeModule(
+		{
+			currentProfile,
+			factory,
+			dependencies,
+			originModule,
+			factoryResult,
+			contextInfo,
+			context
+		},
+		callback
+	) {
+		if (currentProfile !== undefined) {
+			currentProfile.markFactoryStart();
+		}
+		factory.create(
+			{
+				contextInfo: {
+					issuer: originModule ? originModule.nameForCondition() : "",
+					issuerLayer: originModule ? originModule.layer : null,
+					compiler: this.compiler.name,
+					...contextInfo
+				},
+				resolveOptions: originModule ? originModule.resolveOptions : undefined,
+				context: context
+					? context
+					: originModule
+					? originModule.context
+					: this.compiler.context,
+				dependencies: dependencies
+			},
+			(err, result) => {
+				if (result) {
+					// TODO webpack 6: remove
+					// For backward-compat
+					if (result.module === undefined && result instanceof Module) {
+						result = {
+							module: result
+						};
+					}
+					if (!factoryResult) {
+						const {
+							fileDependencies,
+							contextDependencies,
+							missingDependencies
+						} = result;
+						if (fileDependencies) {
+							this.fileDependencies.addAll(fileDependencies);
+						}
+						if (contextDependencies) {
+							this.contextDependencies.addAll(contextDependencies);
+						}
+						if (missingDependencies) {
+							this.missingDependencies.addAll(missingDependencies);
+						}
+					}
+				}
+				if (err) {
+					const notFoundError = new ModuleNotFoundError(
+						originModule,
+						err,
+						dependencies.map(d => d.loc).filter(Boolean)[0]
+					);
+					return callback(notFoundError, factoryResult ? result : undefined);
+				}
+				if (!result) {
+					return callback();
+				}
 
+				if (currentProfile !== undefined) {
+					currentProfile.markFactoryEnd();
+				}
 
-/***/ }),
+				callback(null, factoryResult ? result : result.module);
+			}
+		);
+	}
 
-/***/ 96496:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {string} context context string path
+	 * @param {Dependency} dependency dependency used to create Module chain
+	 * @param {ModuleCallback} callback callback for when module chain is complete
+	 * @returns {void} will throw if dependency instance is not a valid Dependency
+	 */
+	addModuleChain(context, dependency, callback) {
+		return this.addModuleTree({ context, dependency }, callback);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.context context string path
+	 * @param {Dependency} options.dependency dependency used to create Module chain
+	 * @param {Partial<ModuleFactoryCreateDataContextInfo>=} options.contextInfo additional context info for the root module
+	 * @param {ModuleCallback} callback callback for when module chain is complete
+	 * @returns {void} will throw if dependency instance is not a valid Dependency
+	 */
+	addModuleTree({ context, dependency, contextInfo }, callback) {
+		if (
+			typeof dependency !== "object" ||
+			dependency === null ||
+			!dependency.constructor
+		) {
+			return callback(
+				new WebpackError("Parameter 'dependency' must be a Dependency")
+			);
+		}
+		const Dep = /** @type {DepConstructor} */ (dependency.constructor);
+		const moduleFactory = this.dependencyFactories.get(Dep);
+		if (!moduleFactory) {
+			return callback(
+				new WebpackError(
+					`No dependency factory available for this dependency type: ${dependency.constructor.name}`
+				)
+			);
+		}
 
+		this.handleModuleCreation(
+			{
+				factory: moduleFactory,
+				dependencies: [dependency],
+				originModule: null,
+				contextInfo,
+				context
+			},
+			(err, result) => {
+				if (err && this.bail) {
+					callback(err);
+					this.buildQueue.stop();
+					this.rebuildQueue.stop();
+					this.processDependenciesQueue.stop();
+					this.factorizeQueue.stop();
+				} else if (!err && result) {
+					callback(null, result);
+				} else {
+					callback();
+				}
+			}
+		);
+	}
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+	/**
+	 * @param {string} context context path for entry
+	 * @param {Dependency} entry entry dependency that should be followed
+	 * @param {string | EntryOptions} optionsOrName options or deprecated name of entry
+	 * @param {ModuleCallback} callback callback function
+	 * @returns {void} returns
+	 */
+	addEntry(context, entry, optionsOrName, callback) {
+		// TODO webpack 6 remove
+		const options =
+			typeof optionsOrName === "object"
+				? optionsOrName
+				: { name: optionsOrName };
 
-class AsyncSeriesHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone }) {
-		return this.callTapsSeries({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onDone
-		});
+		this._addEntryItem(context, entry, "dependencies", options, callback);
 	}
-}
 
-const factory = new AsyncSeriesHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncSeriesHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncSeriesHook.prototype = null;
-
-module.exports = AsyncSeriesHook;
-
-
-/***/ }),
-
-/***/ 95999:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
-
-class AsyncSeriesLoopHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone }) {
-		return this.callTapsLooping({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onDone
-		});
-	}
-}
-
-const factory = new AsyncSeriesLoopHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncSeriesLoopHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesLoopHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncSeriesLoopHook.prototype = null;
-
-module.exports = AsyncSeriesLoopHook;
-
-
-/***/ }),
-
-/***/ 58118:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {string} context context path for entry
+	 * @param {Dependency} dependency dependency that should be followed
+	 * @param {EntryOptions} options options
+	 * @param {ModuleCallback} callback callback function
+	 * @returns {void} returns
+	 */
+	addInclude(context, dependency, options, callback) {
+		this._addEntryItem(
+			context,
+			dependency,
+			"includeDependencies",
+			options,
+			callback
+		);
+	}
 
+	/**
+	 * @param {string} context context path for entry
+	 * @param {Dependency} entry entry dependency that should be followed
+	 * @param {"dependencies" | "includeDependencies"} target type of entry
+	 * @param {EntryOptions} options options
+	 * @param {ModuleCallback} callback callback function
+	 * @returns {void} returns
+	 */
+	_addEntryItem(context, entry, target, options, callback) {
+		const { name } = options;
+		let entryData =
+			name !== undefined ? this.entries.get(name) : this.globalEntry;
+		if (entryData === undefined) {
+			entryData = {
+				dependencies: [],
+				includeDependencies: [],
+				options: {
+					name: undefined,
+					...options
+				}
+			};
+			entryData[target].push(entry);
+			this.entries.set(name, entryData);
+		} else {
+			entryData[target].push(entry);
+			for (const key of Object.keys(options)) {
+				if (options[key] === undefined) continue;
+				if (entryData.options[key] === options[key]) continue;
+				if (
+					Array.isArray(entryData.options[key]) &&
+					Array.isArray(options[key]) &&
+					arrayEquals(entryData.options[key], options[key])
+				) {
+					continue;
+				}
+				if (entryData.options[key] === undefined) {
+					entryData.options[key] = options[key];
+				} else {
+					return callback(
+						new WebpackError(
+							`Conflicting entry option ${key} = ${entryData.options[key]} vs ${options[key]}`
+						)
+					);
+				}
+			}
+		}
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+		this.hooks.addEntry.call(entry, options);
 
-class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, onDone }) {
-		return this.callTapsSeries({
-			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-			onResult: (i, result, next) => {
-				let code = "";
-				code += `if(${result} !== undefined) {\n`;
-				code += `${this._args[0]} = ${result};\n`;
-				code += `}\n`;
-				code += next();
-				return code;
+		this.addModuleTree(
+			{
+				context,
+				dependency: entry,
+				contextInfo: entryData.options.layer
+					? { issuerLayer: entryData.options.layer }
+					: undefined
 			},
-			onDone: () => onResult(this._args[0])
-		});
+			(err, module) => {
+				if (err) {
+					this.hooks.failedEntry.call(entry, options, err);
+					return callback(err);
+				}
+				this.hooks.succeedEntry.call(entry, options, module);
+				return callback(null, module);
+			}
+		);
 	}
-}
-
-const factory = new AsyncSeriesWaterfallHookCodeFactory();
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function AsyncSeriesWaterfallHook(args = [], name = undefined) {
-	if (args.length < 1)
-		throw new Error("Waterfall hooks must have at least one argument");
-	const hook = new Hook(args, name);
-	hook.constructor = AsyncSeriesWaterfallHook;
-	hook.compile = COMPILE;
-	hook._call = undefined;
-	hook.call = undefined;
-	return hook;
-}
-
-AsyncSeriesWaterfallHook.prototype = null;
-
-module.exports = AsyncSeriesWaterfallHook;
-
-
-/***/ }),
-
-/***/ 21468:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-const util = __webpack_require__(73837);
-
-const deprecateContext = util.deprecate(() => {},
-"Hook.context is deprecated and will be removed");
-
-const CALL_DELEGATE = function(...args) {
-	this.call = this._createCall("sync");
-	return this.call(...args);
-};
-const CALL_ASYNC_DELEGATE = function(...args) {
-	this.callAsync = this._createCall("async");
-	return this.callAsync(...args);
-};
-const PROMISE_DELEGATE = function(...args) {
-	this.promise = this._createCall("promise");
-	return this.promise(...args);
-};
-
-class Hook {
-	constructor(args = [], name = undefined) {
-		this._args = args;
-		this.name = name;
-		this.taps = [];
-		this.interceptors = [];
-		this._call = CALL_DELEGATE;
-		this.call = CALL_DELEGATE;
-		this._callAsync = CALL_ASYNC_DELEGATE;
-		this.callAsync = CALL_ASYNC_DELEGATE;
-		this._promise = PROMISE_DELEGATE;
-		this.promise = PROMISE_DELEGATE;
-		this._x = undefined;
 
-		this.compile = this.compile;
-		this.tap = this.tap;
-		this.tapAsync = this.tapAsync;
-		this.tapPromise = this.tapPromise;
+	/**
+	 * @param {Module} module module to be rebuilt
+	 * @param {ModuleCallback} callback callback when module finishes rebuilding
+	 * @returns {void}
+	 */
+	rebuildModule(module, callback) {
+		this.rebuildQueue.add(module, callback);
 	}
 
-	compile(options) {
-		throw new Error("Abstract: should be overridden");
-	}
+	/**
+	 * @param {Module} module module to be rebuilt
+	 * @param {ModuleCallback} callback callback when module finishes rebuilding
+	 * @returns {void}
+	 */
+	_rebuildModule(module, callback) {
+		this.hooks.rebuildModule.call(module);
+		const oldDependencies = module.dependencies.slice();
+		const oldBlocks = module.blocks.slice();
+		module.invalidateBuild();
+		this.buildQueue.invalidate(module);
+		this.buildModule(module, err => {
+			if (err) {
+				return this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+					if (err2) {
+						callback(
+							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
+						);
+						return;
+					}
+					callback(err);
+				});
+			}
 
-	_createCall(type) {
-		return this.compile({
-			taps: this.taps,
-			interceptors: this.interceptors,
-			args: this._args,
-			type: type
+			this.processDependenciesQueue.invalidate(module);
+			this.moduleGraph.unfreeze();
+			this.processModuleDependencies(module, err => {
+				if (err) return callback(err);
+				this.removeReasonsOfDependencyBlock(module, {
+					dependencies: oldDependencies,
+					blocks: oldBlocks
+				});
+				this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+					if (err2) {
+						callback(
+							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
+						);
+						return;
+					}
+					callback(null, module);
+				});
+			});
 		});
 	}
 
-	_tap(type, options, fn) {
-		if (typeof options === "string") {
-			options = {
-				name: options.trim()
-			};
-		} else if (typeof options !== "object" || options === null) {
-			throw new Error("Invalid tap options");
-		}
-		if (typeof options.name !== "string" || options.name === "") {
-			throw new Error("Missing name for tap");
-		}
-		if (typeof options.context !== "undefined") {
-			deprecateContext();
+	_computeAffectedModules(modules) {
+		const moduleMemCacheCache = this.compiler.moduleMemCaches;
+		if (!moduleMemCacheCache) return;
+		if (!this.moduleMemCaches) {
+			this.moduleMemCaches = new Map();
+			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
 		}
-		options = Object.assign({ type, fn }, options);
-		options = this._runRegisterInterceptors(options);
-		this._insert(options);
-	}
-
-	tap(options, fn) {
-		this._tap("sync", options, fn);
-	}
+		const { moduleGraph, moduleMemCaches } = this;
+		const affectedModules = new Set();
+		const infectedModules = new Set();
+		let statNew = 0;
+		let statChanged = 0;
+		let statUnchanged = 0;
+		let statReferencesChanged = 0;
+		let statWithoutBuild = 0;
 
-	tapAsync(options, fn) {
-		this._tap("async", options, fn);
-	}
+		const computeReferences = module => {
+			/** @type {WeakMap<Dependency, Module>} */
+			let references = undefined;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				const m = connection.module;
+				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
+				if (references === undefined) references = new WeakMap();
+				references.set(d, m);
+			}
+			return references;
+		};
 
-	tapPromise(options, fn) {
-		this._tap("promise", options, fn);
-	}
+		/**
+		 * @param {Module} module the module
+		 * @param {WeakMap<Dependency, Module>} references references
+		 * @returns {boolean} true, when the references differ
+		 */
+		const compareReferences = (module, references) => {
+			if (references === undefined) return true;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				if (!d) continue;
+				const entry = references.get(d);
+				if (entry === undefined) continue;
+				if (entry !== connection.module) return false;
+			}
+			return true;
+		};
 
-	_runRegisterInterceptors(options) {
-		for (const interceptor of this.interceptors) {
-			if (interceptor.register) {
-				const newOptions = interceptor.register(options);
-				if (newOptions !== undefined) {
-					options = newOptions;
+		const modulesWithoutCache = new Set(modules);
+		for (const [module, cachedMemCache] of moduleMemCacheCache) {
+			if (modulesWithoutCache.has(module)) {
+				const buildInfo = module.buildInfo;
+				if (buildInfo) {
+					if (cachedMemCache.buildInfo !== buildInfo) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.buildInfo = buildInfo;
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statChanged++;
+					} else if (!compareReferences(module, cachedMemCache.references)) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statReferencesChanged++;
+					} else {
+						// keep the old mem cache
+						moduleMemCaches.set(module, cachedMemCache.memCache);
+						statUnchanged++;
+					}
+				} else {
+					infectedModules.add(module);
+					moduleMemCacheCache.delete(module);
+					statWithoutBuild++;
 				}
+				modulesWithoutCache.delete(module);
+			} else {
+				moduleMemCacheCache.delete(module);
 			}
 		}
-		return options;
-	}
-
-	withOptions(options) {
-		const mergeOptions = opt =>
-			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
-
-		return {
-			name: this.name,
-			tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
-			tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
-			tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
-			intercept: interceptor => this.intercept(interceptor),
-			isUsed: () => this.isUsed(),
-			withOptions: opt => this.withOptions(mergeOptions(opt))
-		};
-	}
-
-	isUsed() {
-		return this.taps.length > 0 || this.interceptors.length > 0;
-	}
 
-	intercept(interceptor) {
-		this._resetCompilation();
-		this.interceptors.push(Object.assign({}, interceptor));
-		if (interceptor.register) {
-			for (let i = 0; i < this.taps.length; i++) {
-				this.taps[i] = interceptor.register(this.taps[i]);
+		for (const module of modulesWithoutCache) {
+			const buildInfo = module.buildInfo;
+			if (buildInfo) {
+				// create a new entry
+				const memCache = new WeakTupleMap();
+				moduleMemCacheCache.set(module, {
+					buildInfo,
+					references: computeReferences(module),
+					memCache
+				});
+				moduleMemCaches.set(module, memCache);
+				affectedModules.add(module);
+				statNew++;
+			} else {
+				infectedModules.add(module);
+				statWithoutBuild++;
 			}
 		}
-	}
-
-	_resetCompilation() {
-		this.call = this._call;
-		this.callAsync = this._callAsync;
-		this.promise = this._promise;
-	}
 
-	_insert(item) {
-		this._resetCompilation();
-		let before;
-		if (typeof item.before === "string") {
-			before = new Set([item.before]);
-		} else if (Array.isArray(item.before)) {
-			before = new Set(item.before);
-		}
-		let stage = 0;
-		if (typeof item.stage === "number") {
-			stage = item.stage;
-		}
-		let i = this.taps.length;
-		while (i > 0) {
-			i--;
-			const x = this.taps[i];
-			this.taps[i + 1] = x;
-			const xStage = x.stage || 0;
-			if (before) {
-				if (before.has(x.name)) {
-					before.delete(x.name);
-					continue;
-				}
-				if (before.size > 0) {
-					continue;
+		const reduceAffectType = connections => {
+			let affected = false;
+			for (const { dependency } of connections) {
+				if (!dependency) continue;
+				const type = dependency.couldAffectReferencingModule();
+				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
+				if (type === false) continue;
+				affected = true;
+			}
+			return affected;
+		};
+		const directOnlyInfectedModules = new Set();
+		for (const module of infectedModules) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				const type = reduceAffectType(connections);
+				if (!type) continue;
+				if (type === true) {
+					directOnlyInfectedModules.add(referencingModule);
+				} else {
+					infectedModules.add(referencingModule);
 				}
 			}
-			if (xStage > stage) {
-				continue;
+		}
+		for (const module of directOnlyInfectedModules) infectedModules.add(module);
+		const directOnlyAffectModules = new Set();
+		for (const module of affectedModules) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				if (affectedModules.has(referencingModule)) continue;
+				const type = reduceAffectType(connections);
+				if (!type) continue;
+				if (type === true) {
+					directOnlyAffectModules.add(referencingModule);
+				} else {
+					affectedModules.add(referencingModule);
+				}
+				const memCache = new WeakTupleMap();
+				const cache = moduleMemCacheCache.get(referencingModule);
+				cache.memCache = memCache;
+				moduleMemCaches.set(referencingModule, memCache);
 			}
-			i++;
-			break;
 		}
-		this.taps[i] = item;
-	}
-}
-
-Object.setPrototypeOf(Hook.prototype, null);
-
-module.exports = Hook;
-
-
-/***/ }),
-
-/***/ 66443:
-/***/ (function(module) {
+		for (const module of directOnlyAffectModules) affectedModules.add(module);
+		this.logger.log(
+			`${Math.round(
+				(100 * (affectedModules.size + infectedModules.size)) /
+					this.modules.size
+			)}% (${affectedModules.size} affected + ${
+				infectedModules.size
+			} infected of ${
+				this.modules.size
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
+		);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	_computeAffectedModulesWithChunkGraph() {
+		const { moduleMemCaches } = this;
+		if (!moduleMemCaches) return;
+		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
+		const { moduleGraph, chunkGraph } = this;
+		const key = "memCache2";
+		let statUnchanged = 0;
+		let statChanged = 0;
+		let statNew = 0;
+		/**
+		 * @param {Module} module module
+		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+		 */
+		const computeReferences = module => {
+			const id = chunkGraph.getModuleId(module);
+			/** @type {Map<Module, string | number | undefined>} */
+			let modules = undefined;
+			/** @type {(string | number)[] | undefined} */
+			let blocks = undefined;
+			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
+			if (outgoing !== undefined) {
+				for (const m of outgoing.keys()) {
+					if (!m) continue;
+					if (modules === undefined) modules = new Map();
+					modules.set(m, chunkGraph.getModuleId(m));
+				}
+			}
+			if (module.blocks.length > 0) {
+				blocks = [];
+				const queue = Array.from(module.blocks);
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							blocks.push(chunk.id);
+						}
+					} else {
+						blocks.push(null);
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+			}
+			return { id, modules, blocks };
+		};
+		/**
+		 * @param {Module} module module
+		 * @param {Object} references references
+		 * @param {string | number} references.id id
+		 * @param {Map<Module, string | number>=} references.modules modules
+		 * @param {(string | number)[]=} references.blocks blocks
+		 * @returns {boolean} ok?
+		 */
+		const compareReferences = (module, { id, modules, blocks }) => {
+			if (id !== chunkGraph.getModuleId(module)) return false;
+			if (modules !== undefined) {
+				for (const [module, id] of modules) {
+					if (chunkGraph.getModuleId(module) !== id) return false;
+				}
+			}
+			if (blocks !== undefined) {
+				const queue = Array.from(module.blocks);
+				let i = 0;
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
+						}
+					} else {
+						if (i >= blocks.length || blocks[i++] !== null) return false;
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+				if (i !== blocks.length) return false;
+			}
+			return true;
+		};
 
+		for (const [module, memCache] of moduleMemCaches) {
+			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+			const cache = memCache.get(key);
+			if (cache === undefined) {
+				const memCache2 = new WeakTupleMap();
+				memCache.set(key, {
+					references: computeReferences(module),
+					memCache: memCache2
+				});
+				moduleMemCaches2.set(module, memCache2);
+				statNew++;
+			} else if (!compareReferences(module, cache.references)) {
+				const memCache = new WeakTupleMap();
+				cache.references = computeReferences(module);
+				cache.memCache = memCache;
+				moduleMemCaches2.set(module, memCache);
+				statChanged++;
+			} else {
+				moduleMemCaches2.set(module, cache.memCache);
+				statUnchanged++;
+			}
+		}
 
-class HookCodeFactory {
-	constructor(config) {
-		this.config = config;
-		this.options = undefined;
-		this._args = undefined;
+		this.logger.log(
+			`${Math.round(
+				(100 * statChanged) / (statNew + statChanged + statUnchanged)
+			)}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)`
+		);
 	}
 
-	create(options) {
-		this.init(options);
-		let fn;
-		switch (this.options.type) {
-			case "sync":
-				fn = new Function(
-					this.args(),
-					'"use strict";\n' +
-						this.header() +
-						this.contentWithInterceptors({
-							onError: err => `throw ${err};\n`,
-							onResult: result => `return ${result};\n`,
-							resultReturns: true,
-							onDone: () => "",
-							rethrowIfPossible: true
-						})
+	finish(callback) {
+		this.factorizeQueue.clear();
+		if (this.profile) {
+			this.logger.time("finish module profiles");
+			const ParallelismFactorCalculator = __webpack_require__(50780);
+			const p = new ParallelismFactorCalculator();
+			const moduleGraph = this.moduleGraph;
+			const modulesWithProfiles = new Map();
+			for (const module of this.modules) {
+				const profile = moduleGraph.getProfile(module);
+				if (!profile) continue;
+				modulesWithProfiles.set(module, profile);
+				p.range(
+					profile.buildingStartTime,
+					profile.buildingEndTime,
+					f => (profile.buildingParallelismFactor = f)
 				);
-				break;
-			case "async":
-				fn = new Function(
-					this.args({
-						after: "_callback"
-					}),
-					'"use strict";\n' +
-						this.header() +
-						this.contentWithInterceptors({
-							onError: err => `_callback(${err});\n`,
-							onResult: result => `_callback(null, ${result});\n`,
-							onDone: () => "_callback();\n"
-						})
+				p.range(
+					profile.factoryStartTime,
+					profile.factoryEndTime,
+					f => (profile.factoryParallelismFactor = f)
 				);
-				break;
-			case "promise":
-				let errorHelperUsed = false;
-				const content = this.contentWithInterceptors({
-					onError: err => {
-						errorHelperUsed = true;
-						return `_error(${err});\n`;
-					},
-					onResult: result => `_resolve(${result});\n`,
-					onDone: () => "_resolve();\n"
-				});
-				let code = "";
-				code += '"use strict";\n';
-				code += this.header();
-				code += "return new Promise((function(_resolve, _reject) {\n";
-				if (errorHelperUsed) {
-					code += "var _sync = true;\n";
-					code += "function _error(_err) {\n";
-					code += "if(_sync)\n";
-					code +=
-						"_resolve(Promise.resolve().then((function() { throw _err; })));\n";
-					code += "else\n";
-					code += "_reject(_err);\n";
-					code += "};\n";
+				p.range(
+					profile.integrationStartTime,
+					profile.integrationEndTime,
+					f => (profile.integrationParallelismFactor = f)
+				);
+				p.range(
+					profile.storingStartTime,
+					profile.storingEndTime,
+					f => (profile.storingParallelismFactor = f)
+				);
+				p.range(
+					profile.restoringStartTime,
+					profile.restoringEndTime,
+					f => (profile.restoringParallelismFactor = f)
+				);
+				if (profile.additionalFactoryTimes) {
+					for (const { start, end } of profile.additionalFactoryTimes) {
+						const influence = (end - start) / profile.additionalFactories;
+						p.range(
+							start,
+							end,
+							f =>
+								(profile.additionalFactoriesParallelismFactor += f * influence)
+						);
+					}
 				}
-				code += content;
-				if (errorHelperUsed) {
-					code += "_sync = false;\n";
+			}
+			p.calculate();
+
+			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
+			const logByValue = (value, msg) => {
+				if (value > 1000) {
+					logger.error(msg);
+				} else if (value > 500) {
+					logger.warn(msg);
+				} else if (value > 200) {
+					logger.info(msg);
+				} else if (value > 30) {
+					logger.log(msg);
+				} else {
+					logger.debug(msg);
 				}
-				code += "}));\n";
-				fn = new Function(this.args(), code);
-				break;
+			};
+			const logNormalSummary = (category, getDuration, getParallelism) => {
+				let sum = 0;
+				let max = 0;
+				for (const [module, profile] of modulesWithProfiles) {
+					const p = getParallelism(profile);
+					const d = getDuration(profile);
+					if (d === 0 || p === 0) continue;
+					const t = d / p;
+					sum += t;
+					if (t <= 10) continue;
+					logByValue(
+						t,
+						` | ${Math.round(t)} ms${
+							p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+						} ${category} > ${module.readableIdentifier(this.requestShortener)}`
+					);
+					max = Math.max(max, t);
+				}
+				if (sum <= 10) return;
+				logByValue(
+					Math.max(sum / 10, max),
+					`${Math.round(sum)} ms ${category}`
+				);
+			};
+			const logByLoadersSummary = (category, getDuration, getParallelism) => {
+				const map = new Map();
+				for (const [module, profile] of modulesWithProfiles) {
+					const list = provide(
+						map,
+						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
+						() => []
+					);
+					list.push({ module, profile });
+				}
+
+				let sum = 0;
+				let max = 0;
+				for (const [key, modules] of map) {
+					let innerSum = 0;
+					let innerMax = 0;
+					for (const { module, profile } of modules) {
+						const p = getParallelism(profile);
+						const d = getDuration(profile);
+						if (d === 0 || p === 0) continue;
+						const t = d / p;
+						innerSum += t;
+						if (t <= 10) continue;
+						logByValue(
+							t,
+							` |  | ${Math.round(t)} ms${
+								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+							} ${category} > ${module.readableIdentifier(
+								this.requestShortener
+							)}`
+						);
+						innerMax = Math.max(innerMax, t);
+					}
+					sum += innerSum;
+					if (innerSum <= 10) continue;
+					const idx = key.indexOf("!");
+					const loaders = key.slice(idx + 1);
+					const moduleType = key.slice(0, idx);
+					const t = Math.max(innerSum / 10, innerMax);
+					logByValue(
+						t,
+						` | ${Math.round(innerSum)} ms ${category} > ${
+							loaders
+								? `${
+										modules.length
+								  } x ${moduleType} with ${this.requestShortener.shorten(
+										loaders
+								  )}`
+								: `${modules.length} x ${moduleType}`
+						}`
+					);
+					max = Math.max(max, t);
+				}
+				if (sum <= 10) return;
+				logByValue(
+					Math.max(sum / 10, max),
+					`${Math.round(sum)} ms ${category}`
+				);
+			};
+			logNormalSummary(
+				"resolve to new modules",
+				p => p.factory,
+				p => p.factoryParallelismFactor
+			);
+			logNormalSummary(
+				"resolve to existing modules",
+				p => p.additionalFactories,
+				p => p.additionalFactoriesParallelismFactor
+			);
+			logNormalSummary(
+				"integrate modules",
+				p => p.restoring,
+				p => p.restoringParallelismFactor
+			);
+			logByLoadersSummary(
+				"build modules",
+				p => p.building,
+				p => p.buildingParallelismFactor
+			);
+			logNormalSummary(
+				"store modules",
+				p => p.storing,
+				p => p.storingParallelismFactor
+			);
+			logNormalSummary(
+				"restore modules",
+				p => p.restoring,
+				p => p.restoringParallelismFactor
+			);
+			this.logger.timeEnd("finish module profiles");
 		}
-		this.deinit();
-		return fn;
+		this.logger.time("compute affected modules");
+		this._computeAffectedModules(this.modules);
+		this.logger.timeEnd("compute affected modules");
+		this.logger.time("finish modules");
+		const { modules, moduleMemCaches } = this;
+		this.hooks.finishModules.callAsync(modules, err => {
+			this.logger.timeEnd("finish modules");
+			if (err) return callback(err);
+
+			// extract warnings and errors from modules
+			this.moduleGraph.freeze("dependency errors");
+			// TODO keep a cacheToken (= {}) for each module in the graph
+			// create a new one per compilation and flag all updated files
+			// and parents with it
+			this.logger.time("report dependency errors and warnings");
+			for (const module of modules) {
+				// TODO only run for modules with changed cacheToken
+				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
+				const memCache = moduleMemCaches && moduleMemCaches.get(module);
+				if (memCache && memCache.get("noWarningsOrErrors")) continue;
+				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
+					module
+				]);
+				const errors = module.getErrors();
+				if (errors !== undefined) {
+					for (const error of errors) {
+						if (!error.module) {
+							error.module = module;
+						}
+						this.errors.push(error);
+						hasProblems = true;
+					}
+				}
+				const warnings = module.getWarnings();
+				if (warnings !== undefined) {
+					for (const warning of warnings) {
+						if (!warning.module) {
+							warning.module = module;
+						}
+						this.warnings.push(warning);
+						hasProblems = true;
+					}
+				}
+				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
+			}
+			this.moduleGraph.unfreeze();
+			this.logger.timeEnd("report dependency errors and warnings");
+
+			callback();
+		});
 	}
 
-	setup(instance, options) {
-		instance._x = options.taps.map(t => t.fn);
+	unseal() {
+		this.hooks.unseal.call();
+		this.chunks.clear();
+		this.chunkGroups.length = 0;
+		this.namedChunks.clear();
+		this.namedChunkGroups.clear();
+		this.entrypoints.clear();
+		this.additionalChunkAssets.length = 0;
+		this.assets = {};
+		this.assetsInfo.clear();
+		this.moduleGraph.removeAllModuleAttributes();
+		this.moduleGraph.unfreeze();
+		this.moduleMemCaches2 = undefined;
 	}
 
 	/**
-	 * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
+	 * @param {Callback} callback signals when the call finishes
+	 * @returns {void}
 	 */
-	init(options) {
-		this.options = options;
-		this._args = options.args.slice();
-	}
+	seal(callback) {
+		const finalCallback = err => {
+			this.factorizeQueue.clear();
+			this.buildQueue.clear();
+			this.rebuildQueue.clear();
+			this.processDependenciesQueue.clear();
+			this.addModuleQueue.clear();
+			return callback(err);
+		};
+		const chunkGraph = new ChunkGraph(
+			this.moduleGraph,
+			this.outputOptions.hashFunction
+		);
+		this.chunkGraph = chunkGraph;
 
-	deinit() {
-		this.options = undefined;
-		this._args = undefined;
-	}
+		if (this._backCompat) {
+			for (const module of this.modules) {
+				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+			}
+		}
 
-	contentWithInterceptors(options) {
-		if (this.options.interceptors.length > 0) {
-			const onError = options.onError;
-			const onResult = options.onResult;
-			const onDone = options.onDone;
-			let code = "";
-			for (let i = 0; i < this.options.interceptors.length; i++) {
-				const interceptor = this.options.interceptors[i];
-				if (interceptor.call) {
-					code += `${this.getInterceptor(i)}.call(${this.args({
-						before: interceptor.context ? "_context" : undefined
-					})});\n`;
-				}
+		this.hooks.seal.call();
+
+		this.logger.time("optimize dependencies");
+		while (this.hooks.optimizeDependencies.call(this.modules)) {
+			/* empty */
+		}
+		this.hooks.afterOptimizeDependencies.call(this.modules);
+		this.logger.timeEnd("optimize dependencies");
+
+		this.logger.time("create chunks");
+		this.hooks.beforeChunks.call();
+		this.moduleGraph.freeze("seal");
+		/** @type {Map<Entrypoint, Module[]>} */
+		const chunkGraphInit = new Map();
+		for (const [name, { dependencies, includeDependencies, options }] of this
+			.entries) {
+			const chunk = this.addChunk(name);
+			if (options.filename) {
+				chunk.filenameTemplate = options.filename;
 			}
-			code += this.content(
-				Object.assign(options, {
-					onError:
-						onError &&
-						(err => {
-							let code = "";
-							for (let i = 0; i < this.options.interceptors.length; i++) {
-								const interceptor = this.options.interceptors[i];
-								if (interceptor.error) {
-									code += `${this.getInterceptor(i)}.error(${err});\n`;
-								}
-							}
-							code += onError(err);
-							return code;
-						}),
-					onResult:
-						onResult &&
-						(result => {
-							let code = "";
-							for (let i = 0; i < this.options.interceptors.length; i++) {
-								const interceptor = this.options.interceptors[i];
-								if (interceptor.result) {
-									code += `${this.getInterceptor(i)}.result(${result});\n`;
-								}
-							}
-							code += onResult(result);
-							return code;
-						}),
-					onDone:
-						onDone &&
-						(() => {
-							let code = "";
-							for (let i = 0; i < this.options.interceptors.length; i++) {
-								const interceptor = this.options.interceptors[i];
-								if (interceptor.done) {
-									code += `${this.getInterceptor(i)}.done();\n`;
-								}
-							}
-							code += onDone();
-							return code;
-						})
-				})
-			);
-			return code;
-		} else {
-			return this.content(options);
-		}
-	}
-
-	header() {
-		let code = "";
-		if (this.needContext()) {
-			code += "var _context = {};\n";
-		} else {
-			code += "var _context;\n";
-		}
-		code += "var _x = this._x;\n";
-		if (this.options.interceptors.length > 0) {
-			code += "var _taps = this.taps;\n";
-			code += "var _interceptors = this.interceptors;\n";
-		}
-		return code;
-	}
+			const entrypoint = new Entrypoint(options);
+			if (!options.dependOn && !options.runtime) {
+				entrypoint.setRuntimeChunk(chunk);
+			}
+			entrypoint.setEntrypointChunk(chunk);
+			this.namedChunkGroups.set(name, entrypoint);
+			this.entrypoints.set(name, entrypoint);
+			this.chunkGroups.push(entrypoint);
+			connectChunkGroupAndChunk(entrypoint, chunk);
 
-	needContext() {
-		for (const tap of this.options.taps) if (tap.context) return true;
-		return false;
-	}
+			const entryModules = new Set();
+			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
+				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
 
-	callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
-		let code = "";
-		let hasTapCached = false;
-		for (let i = 0; i < this.options.interceptors.length; i++) {
-			const interceptor = this.options.interceptors[i];
-			if (interceptor.tap) {
-				if (!hasTapCached) {
-					code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};\n`;
-					hasTapCached = true;
+				const module = this.moduleGraph.getModule(dep);
+				if (module) {
+					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+					entryModules.add(module);
+					const modulesList = chunkGraphInit.get(entrypoint);
+					if (modulesList === undefined) {
+						chunkGraphInit.set(entrypoint, [module]);
+					} else {
+						modulesList.push(module);
+					}
 				}
-				code += `${this.getInterceptor(i)}.tap(${
-					interceptor.context ? "_context, " : ""
-				}_tap${tapIndex});\n`;
+			}
+
+			this.assignDepths(entryModules);
+
+			const mapAndSort = deps =>
+				deps
+					.map(dep => this.moduleGraph.getModule(dep))
+					.filter(Boolean)
+					.sort(compareModulesByIdentifier);
+			const includedModules = [
+				...mapAndSort(this.globalEntry.includeDependencies),
+				...mapAndSort(includeDependencies)
+			];
+
+			let modulesList = chunkGraphInit.get(entrypoint);
+			if (modulesList === undefined) {
+				chunkGraphInit.set(entrypoint, (modulesList = []));
+			}
+			for (const module of includedModules) {
+				this.assignDepth(module);
+				modulesList.push(module);
 			}
 		}
-		code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};\n`;
-		const tap = this.options.taps[tapIndex];
-		switch (tap.type) {
-			case "sync":
-				if (!rethrowIfPossible) {
-					code += `var _hasError${tapIndex} = false;\n`;
-					code += "try {\n";
-				}
-				if (onResult) {
-					code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
-						before: tap.context ? "_context" : undefined
-					})});\n`;
-				} else {
-					code += `_fn${tapIndex}(${this.args({
-						before: tap.context ? "_context" : undefined
-					})});\n`;
-				}
-				if (!rethrowIfPossible) {
-					code += "} catch(_err) {\n";
-					code += `_hasError${tapIndex} = true;\n`;
-					code += onError("_err");
-					code += "}\n";
-					code += `if(!_hasError${tapIndex}) {\n`;
-				}
-				if (onResult) {
-					code += onResult(`_result${tapIndex}`);
-				}
-				if (onDone) {
-					code += onDone();
-				}
-				if (!rethrowIfPossible) {
-					code += "}\n";
-				}
-				break;
-			case "async":
-				let cbCode = "";
-				if (onResult)
-					cbCode += `(function(_err${tapIndex}, _result${tapIndex}) {\n`;
-				else cbCode += `(function(_err${tapIndex}) {\n`;
-				cbCode += `if(_err${tapIndex}) {\n`;
-				cbCode += onError(`_err${tapIndex}`);
-				cbCode += "} else {\n";
-				if (onResult) {
-					cbCode += onResult(`_result${tapIndex}`);
-				}
-				if (onDone) {
-					cbCode += onDone();
+		const runtimeChunks = new Set();
+		outer: for (const [
+			name,
+			{
+				options: { dependOn, runtime }
+			}
+		] of this.entries) {
+			if (dependOn && runtime) {
+				const err =
+					new WebpackError(`Entrypoint '${name}' has 'dependOn' and 'runtime' specified. This is not valid.
+Entrypoints that depend on other entrypoints do not have their own runtime.
+They will use the runtime(s) from referenced entrypoints instead.
+Remove the 'runtime' option from the entrypoint.`);
+				const entry = this.entrypoints.get(name);
+				err.chunk = entry.getEntrypointChunk();
+				this.errors.push(err);
+			}
+			if (dependOn) {
+				const entry = this.entrypoints.get(name);
+				const referencedChunks = entry
+					.getEntrypointChunk()
+					.getAllReferencedChunks();
+				const dependOnEntries = [];
+				for (const dep of dependOn) {
+					const dependency = this.entrypoints.get(dep);
+					if (!dependency) {
+						throw new Error(
+							`Entry ${name} depends on ${dep}, but this entry was not found`
+						);
+					}
+					if (referencedChunks.has(dependency.getEntrypointChunk())) {
+						const err = new WebpackError(
+							`Entrypoints '${name}' and '${dep}' use 'dependOn' to depend on each other in a circular way.`
+						);
+						const entryChunk = entry.getEntrypointChunk();
+						err.chunk = entryChunk;
+						this.errors.push(err);
+						entry.setRuntimeChunk(entryChunk);
+						continue outer;
+					}
+					dependOnEntries.push(dependency);
 				}
-				cbCode += "}\n";
-				cbCode += "})";
-				code += `_fn${tapIndex}(${this.args({
-					before: tap.context ? "_context" : undefined,
-					after: cbCode
-				})});\n`;
-				break;
-			case "promise":
-				code += `var _hasResult${tapIndex} = false;\n`;
-				code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
-					before: tap.context ? "_context" : undefined
-				})});\n`;
-				code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)\n`;
-				code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');\n`;
-				code += `_promise${tapIndex}.then((function(_result${tapIndex}) {\n`;
-				code += `_hasResult${tapIndex} = true;\n`;
-				if (onResult) {
-					code += onResult(`_result${tapIndex}`);
+				for (const dependency of dependOnEntries) {
+					connectChunkGroupParentAndChild(dependency, entry);
 				}
-				if (onDone) {
-					code += onDone();
+			} else if (runtime) {
+				const entry = this.entrypoints.get(name);
+				let chunk = this.namedChunks.get(runtime);
+				if (chunk) {
+					if (!runtimeChunks.has(chunk)) {
+						const err =
+							new WebpackError(`Entrypoint '${name}' has a 'runtime' option which points to another entrypoint named '${runtime}'.
+It's not valid to use other entrypoints as runtime chunk.
+Did you mean to use 'dependOn: ${JSON.stringify(
+								runtime
+							)}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
+Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
+						const entryChunk = entry.getEntrypointChunk();
+						err.chunk = entryChunk;
+						this.errors.push(err);
+						entry.setRuntimeChunk(entryChunk);
+						continue;
+					}
+				} else {
+					chunk = this.addChunk(runtime);
+					chunk.preventIntegration = true;
+					runtimeChunks.add(chunk);
 				}
-				code += `}), function(_err${tapIndex}) {\n`;
-				code += `if(_hasResult${tapIndex}) throw _err${tapIndex};\n`;
-				code += onError(`_err${tapIndex}`);
-				code += "});\n";
-				break;
-		}
-		return code;
-	}
-
-	callTapsSeries({
-		onError,
-		onResult,
-		resultReturns,
-		onDone,
-		doneReturns,
-		rethrowIfPossible
-	}) {
-		if (this.options.taps.length === 0) return onDone();
-		const firstAsync = this.options.taps.findIndex(t => t.type !== "sync");
-		const somethingReturns = resultReturns || doneReturns;
-		let code = "";
-		let current = onDone;
-		let unrollCounter = 0;
-		for (let j = this.options.taps.length - 1; j >= 0; j--) {
-			const i = j;
-			const unroll =
-				current !== onDone &&
-				(this.options.taps[i].type !== "sync" || unrollCounter++ > 20);
-			if (unroll) {
-				unrollCounter = 0;
-				code += `function _next${i}() {\n`;
-				code += current();
-				code += `}\n`;
-				current = () => `${somethingReturns ? "return " : ""}_next${i}();\n`;
+				entry.unshiftChunk(chunk);
+				chunk.addGroup(entry);
+				entry.setRuntimeChunk(chunk);
 			}
-			const done = current;
-			const doneBreak = skipDone => {
-				if (skipDone) return "";
-				return onDone();
-			};
-			const content = this.callTap(i, {
-				onError: error => onError(i, error, done, doneBreak),
-				onResult:
-					onResult &&
-					(result => {
-						return onResult(i, result, done, doneBreak);
-					}),
-				onDone: !onResult && done,
-				rethrowIfPossible:
-					rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
-			});
-			current = () => content;
 		}
-		code += current();
-		return code;
-	}
+		buildChunkGraph(this, chunkGraphInit);
+		this.hooks.afterChunks.call(this.chunks);
+		this.logger.timeEnd("create chunks");
 
-	callTapsLooping({ onError, onDone, rethrowIfPossible }) {
-		if (this.options.taps.length === 0) return onDone();
-		const syncOnly = this.options.taps.every(t => t.type === "sync");
-		let code = "";
-		if (!syncOnly) {
-			code += "var _looper = (function() {\n";
-			code += "var _loopAsync = false;\n";
-		}
-		code += "var _loop;\n";
-		code += "do {\n";
-		code += "_loop = false;\n";
-		for (let i = 0; i < this.options.interceptors.length; i++) {
-			const interceptor = this.options.interceptors[i];
-			if (interceptor.loop) {
-				code += `${this.getInterceptor(i)}.loop(${this.args({
-					before: interceptor.context ? "_context" : undefined
-				})});\n`;
-			}
-		}
-		code += this.callTapsSeries({
-			onError,
-			onResult: (i, result, next, doneBreak) => {
-				let code = "";
-				code += `if(${result} !== undefined) {\n`;
-				code += "_loop = true;\n";
-				if (!syncOnly) code += "if(_loopAsync) _looper();\n";
-				code += doneBreak(true);
-				code += `} else {\n`;
-				code += next();
-				code += `}\n`;
-				return code;
-			},
-			onDone:
-				onDone &&
-				(() => {
-					let code = "";
-					code += "if(!_loop) {\n";
-					code += onDone();
-					code += "}\n";
-					return code;
-				}),
-			rethrowIfPossible: rethrowIfPossible && syncOnly
-		});
-		code += "} while(_loop);\n";
-		if (!syncOnly) {
-			code += "_loopAsync = true;\n";
-			code += "});\n";
-			code += "_looper();\n";
-		}
-		return code;
-	}
+		this.logger.time("optimize");
+		this.hooks.optimize.call();
 
-	callTapsParallel({
-		onError,
-		onResult,
-		onDone,
-		rethrowIfPossible,
-		onTap = (i, run) => run()
-	}) {
-		if (this.options.taps.length <= 1) {
-			return this.callTapsSeries({
-				onError,
-				onResult,
-				onDone,
-				rethrowIfPossible
-			});
-		}
-		let code = "";
-		code += "do {\n";
-		code += `var _counter = ${this.options.taps.length};\n`;
-		if (onDone) {
-			code += "var _done = (function() {\n";
-			code += onDone();
-			code += "});\n";
-		}
-		for (let i = 0; i < this.options.taps.length; i++) {
-			const done = () => {
-				if (onDone) return "if(--_counter === 0) _done();\n";
-				else return "--_counter;";
-			};
-			const doneBreak = skipDone => {
-				if (skipDone || !onDone) return "_counter = 0;\n";
-				else return "_counter = 0;\n_done();\n";
-			};
-			code += "if(_counter <= 0) break;\n";
-			code += onTap(
-				i,
-				() =>
-					this.callTap(i, {
-						onError: error => {
-							let code = "";
-							code += "if(_counter > 0) {\n";
-							code += onError(i, error, done, doneBreak);
-							code += "}\n";
-							return code;
-						},
-						onResult:
-							onResult &&
-							(result => {
-								let code = "";
-								code += "if(_counter > 0) {\n";
-								code += onResult(i, result, done, doneBreak);
-								code += "}\n";
-								return code;
-							}),
-						onDone:
-							!onResult &&
-							(() => {
-								return done();
-							}),
-						rethrowIfPossible
-					}),
-				done,
-				doneBreak
-			);
+		while (this.hooks.optimizeModules.call(this.modules)) {
+			/* empty */
 		}
-		code += "} while(false);\n";
-		return code;
-	}
+		this.hooks.afterOptimizeModules.call(this.modules);
 
-	args({ before, after } = {}) {
-		let allArgs = this._args;
-		if (before) allArgs = [before].concat(allArgs);
-		if (after) allArgs = allArgs.concat(after);
-		if (allArgs.length === 0) {
-			return "";
-		} else {
-			return allArgs.join(", ");
+		while (this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups)) {
+			/* empty */
 		}
-	}
+		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
 
-	getTapFn(idx) {
-		return `_x[${idx}]`;
-	}
+		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {
+			if (err) {
+				return finalCallback(
+					makeWebpackError(err, "Compilation.hooks.optimizeTree")
+				);
+			}
 
-	getTap(idx) {
-		return `_taps[${idx}]`;
-	}
+			this.hooks.afterOptimizeTree.call(this.chunks, this.modules);
 
-	getInterceptor(idx) {
-		return `_interceptors[${idx}]`;
-	}
-}
+			this.hooks.optimizeChunkModules.callAsync(
+				this.chunks,
+				this.modules,
+				err => {
+					if (err) {
+						return finalCallback(
+							makeWebpackError(err, "Compilation.hooks.optimizeChunkModules")
+						);
+					}
 
-module.exports = HookCodeFactory;
+					this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);
 
+					const shouldRecord = this.hooks.shouldRecord.call() !== false;
 
-/***/ }),
+					this.hooks.reviveModules.call(this.modules, this.records);
+					this.hooks.beforeModuleIds.call(this.modules);
+					this.hooks.moduleIds.call(this.modules);
+					this.hooks.optimizeModuleIds.call(this.modules);
+					this.hooks.afterOptimizeModuleIds.call(this.modules);
 
-/***/ 77079:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					this.hooks.reviveChunks.call(this.chunks, this.records);
+					this.hooks.beforeChunkIds.call(this.chunks);
+					this.hooks.chunkIds.call(this.chunks);
+					this.hooks.optimizeChunkIds.call(this.chunks);
+					this.hooks.afterOptimizeChunkIds.call(this.chunks);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					this.assignRuntimeIds();
 
+					this.logger.time("compute affected modules with chunk graph");
+					this._computeAffectedModulesWithChunkGraph();
+					this.logger.timeEnd("compute affected modules with chunk graph");
 
-const util = __webpack_require__(73837);
+					this.sortItemsWithChunkIds();
 
-const defaultFactory = (key, hook) => hook;
+					if (shouldRecord) {
+						this.hooks.recordModules.call(this.modules, this.records);
+						this.hooks.recordChunks.call(this.chunks, this.records);
+					}
 
-class HookMap {
-	constructor(factory, name = undefined) {
-		this._map = new Map();
-		this.name = name;
-		this._factory = factory;
-		this._interceptors = [];
-	}
+					this.hooks.optimizeCodeGeneration.call(this.modules);
+					this.logger.timeEnd("optimize");
 
-	get(key) {
-		return this._map.get(key);
-	}
+					this.logger.time("module hashing");
+					this.hooks.beforeModuleHash.call();
+					this.createModuleHashes();
+					this.hooks.afterModuleHash.call();
+					this.logger.timeEnd("module hashing");
 
-	for(key) {
-		const hook = this.get(key);
-		if (hook !== undefined) {
-			return hook;
-		}
-		let newHook = this._factory(key);
-		const interceptors = this._interceptors;
-		for (let i = 0; i < interceptors.length; i++) {
-			newHook = interceptors[i].factory(key, newHook);
-		}
-		this._map.set(key, newHook);
-		return newHook;
-	}
+					this.logger.time("code generation");
+					this.hooks.beforeCodeGeneration.call();
+					this.codeGeneration(err => {
+						if (err) {
+							return finalCallback(err);
+						}
+						this.hooks.afterCodeGeneration.call();
+						this.logger.timeEnd("code generation");
 
-	intercept(interceptor) {
-		this._interceptors.push(
-			Object.assign(
-				{
-					factory: defaultFactory
-				},
-				interceptor
-			)
-		);
-	}
-}
+						this.logger.time("runtime requirements");
+						this.hooks.beforeRuntimeRequirements.call();
+						this.processRuntimeRequirements();
+						this.hooks.afterRuntimeRequirements.call();
+						this.logger.timeEnd("runtime requirements");
 
-HookMap.prototype.tap = util.deprecate(function(key, options, fn) {
-	return this.for(key).tap(options, fn);
-}, "HookMap#tap(key,…) is deprecated. Use HookMap#for(key).tap(…) instead.");
+						this.logger.time("hashing");
+						this.hooks.beforeHash.call();
+						const codeGenerationJobs = this.createHash();
+						this.hooks.afterHash.call();
+						this.logger.timeEnd("hashing");
 
-HookMap.prototype.tapAsync = util.deprecate(function(key, options, fn) {
-	return this.for(key).tapAsync(options, fn);
-}, "HookMap#tapAsync(key,…) is deprecated. Use HookMap#for(key).tapAsync(…) instead.");
+						this._runCodeGenerationJobs(codeGenerationJobs, err => {
+							if (err) {
+								return finalCallback(err);
+							}
 
-HookMap.prototype.tapPromise = util.deprecate(function(key, options, fn) {
-	return this.for(key).tapPromise(options, fn);
-}, "HookMap#tapPromise(key,…) is deprecated. Use HookMap#for(key).tapPromise(…) instead.");
+							if (shouldRecord) {
+								this.logger.time("record hash");
+								this.hooks.recordHash.call(this.records);
+								this.logger.timeEnd("record hash");
+							}
 
-module.exports = HookMap;
+							this.logger.time("module assets");
+							this.clearAssets();
 
+							this.hooks.beforeModuleAssets.call();
+							this.createModuleAssets();
+							this.logger.timeEnd("module assets");
 
-/***/ }),
+							const cont = () => {
+								this.logger.time("process assets");
+								this.hooks.processAssets.callAsync(this.assets, err => {
+									if (err) {
+										return finalCallback(
+											makeWebpackError(err, "Compilation.hooks.processAssets")
+										);
+									}
+									this.hooks.afterProcessAssets.call(this.assets);
+									this.logger.timeEnd("process assets");
+									this.assets = this._backCompat
+										? soonFrozenObjectDeprecation(
+												this.assets,
+												"Compilation.assets",
+												"DEP_WEBPACK_COMPILATION_ASSETS",
+												`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
+	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
+										  )
+										: Object.freeze(this.assets);
 
-/***/ 13103:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+									this.summarizeDependencies();
+									if (shouldRecord) {
+										this.hooks.record.call(this, this.records);
+									}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+									if (this.hooks.needAdditionalSeal.call()) {
+										this.unseal();
+										return this.seal(callback);
+									}
+									return this.hooks.afterSeal.callAsync(err => {
+										if (err) {
+											return finalCallback(
+												makeWebpackError(err, "Compilation.hooks.afterSeal")
+											);
+										}
+										this.fileSystemInfo.logStatistics();
+										finalCallback();
+									});
+								});
+							};
+
+							this.logger.time("create chunk assets");
+							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
+								this.hooks.beforeChunkAssets.call();
+								this.createChunkAssets(err => {
+									this.logger.timeEnd("create chunk assets");
+									if (err) {
+										return finalCallback(err);
+									}
+									cont();
+								});
+							} else {
+								this.logger.timeEnd("create chunk assets");
+								cont();
+							}
+						});
+					});
+				}
+			);
+		});
+	}
+
+	/**
+	 * @param {Module} module module to report from
+	 * @param {DependenciesBlock[]} blocks blocks to report from
+	 * @returns {boolean} true, when it has warnings or errors
+	 */
+	reportDependencyErrorsAndWarnings(module, blocks) {
+		let hasProblems = false;
+		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+			const block = blocks[indexBlock];
+			const dependencies = block.dependencies;
 
+			for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {
+				const d = dependencies[indexDep];
 
-const Hook = __webpack_require__(21468);
+				const warnings = d.getWarnings(this.moduleGraph);
+				if (warnings) {
+					for (let indexWar = 0; indexWar < warnings.length; indexWar++) {
+						const w = warnings[indexWar];
 
-class MultiHook {
-	constructor(hooks, name = undefined) {
-		this.hooks = hooks;
-		this.name = name;
-	}
+						const warning = new ModuleDependencyWarning(module, w, d.loc);
+						this.warnings.push(warning);
+						hasProblems = true;
+					}
+				}
+				const errors = d.getErrors(this.moduleGraph);
+				if (errors) {
+					for (let indexErr = 0; indexErr < errors.length; indexErr++) {
+						const e = errors[indexErr];
 
-	tap(options, fn) {
-		for (const hook of this.hooks) {
-			hook.tap(options, fn);
-		}
-	}
+						const error = new ModuleDependencyError(module, e, d.loc);
+						this.errors.push(error);
+						hasProblems = true;
+					}
+				}
+			}
 
-	tapAsync(options, fn) {
-		for (const hook of this.hooks) {
-			hook.tapAsync(options, fn);
+			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
+				hasProblems = true;
 		}
+		return hasProblems;
 	}
 
-	tapPromise(options, fn) {
-		for (const hook of this.hooks) {
-			hook.tapPromise(options, fn);
+	codeGeneration(callback) {
+		const { chunkGraph } = this;
+		this.codeGenerationResults = new CodeGenerationResults(
+			this.outputOptions.hashFunction
+		);
+		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		const jobs = [];
+		for (const module of this.modules) {
+			const runtimes = chunkGraph.getModuleRuntimes(module);
+			if (runtimes.size === 1) {
+				for (const runtime of runtimes) {
+					const hash = chunkGraph.getModuleHash(module, runtime);
+					jobs.push({ module, hash, runtime, runtimes: [runtime] });
+				}
+			} else if (runtimes.size > 1) {
+				/** @type {Map<string, { runtimes: RuntimeSpec[] }>} */
+				const map = new Map();
+				for (const runtime of runtimes) {
+					const hash = chunkGraph.getModuleHash(module, runtime);
+					const job = map.get(hash);
+					if (job === undefined) {
+						const newJob = { module, hash, runtime, runtimes: [runtime] };
+						jobs.push(newJob);
+						map.set(hash, newJob);
+					} else {
+						job.runtimes.push(runtime);
+					}
+				}
+			}
 		}
-	}
 
-	isUsed() {
-		for (const hook of this.hooks) {
-			if (hook.isUsed()) return true;
-		}
-		return false;
+		this._runCodeGenerationJobs(jobs, callback);
 	}
 
-	intercept(interceptor) {
-		for (const hook of this.hooks) {
-			hook.intercept(interceptor);
-		}
+	_runCodeGenerationJobs(jobs, callback) {
+		let statModulesFromCache = 0;
+		let statModulesGenerated = 0;
+		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
+			this;
+		const results = this.codeGenerationResults;
+		const errors = [];
+		/** @type {Set<Module> | undefined} */
+		let notCodeGeneratedModules = undefined;
+		const runIteration = () => {
+			let delayedJobs = [];
+			let delayedModules = new Set();
+			asyncLib.eachLimit(
+				jobs,
+				this.options.parallelism,
+				(job, callback) => {
+					const { module } = job;
+					const { codeGenerationDependencies } = module;
+					if (codeGenerationDependencies !== undefined) {
+						if (
+							notCodeGeneratedModules === undefined ||
+							codeGenerationDependencies.some(dep => {
+								const referencedModule = moduleGraph.getModule(dep);
+								return notCodeGeneratedModules.has(referencedModule);
+							})
+						) {
+							delayedJobs.push(job);
+							delayedModules.add(module);
+							return callback();
+						}
+					}
+					const { hash, runtime, runtimes } = job;
+					this._codeGenerationModule(
+						module,
+						runtime,
+						runtimes,
+						hash,
+						dependencyTemplates,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						errors,
+						results,
+						(err, codeGenerated) => {
+							if (codeGenerated) statModulesGenerated++;
+							else statModulesFromCache++;
+							callback(err);
+						}
+					);
+				},
+				err => {
+					if (err) return callback(err);
+					if (delayedJobs.length > 0) {
+						if (delayedJobs.length === jobs.length) {
+							return callback(
+								new Error(
+									`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
+										delayedModules,
+										m => m.identifier()
+									).join(", ")}`
+								)
+							);
+						}
+						jobs = delayedJobs;
+						delayedJobs = [];
+						notCodeGeneratedModules = delayedModules;
+						delayedModules = new Set();
+						return runIteration();
+					}
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
+						}
+					}
+					this.logger.log(
+						`${Math.round(
+							(100 * statModulesGenerated) /
+								(statModulesGenerated + statModulesFromCache)
+						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
+					);
+					callback();
+				}
+			);
+		};
+		runIteration();
 	}
 
-	withOptions(options) {
-		return new MultiHook(
-			this.hooks.map(h => h.withOptions(options)),
-			this.name
+	/**
+	 * @param {Module} module module
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {RuntimeSpec[]} runtimes runtimes
+	 * @param {string} hash hash
+	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
+	 * @param {ChunkGraph} chunkGraph chunkGraph
+	 * @param {ModuleGraph} moduleGraph moduleGraph
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+	 * @param {WebpackError[]} errors errors
+	 * @param {CodeGenerationResults} results results
+	 * @param {function(WebpackError=, boolean=): void} callback callback
+	 */
+	_codeGenerationModule(
+		module,
+		runtime,
+		runtimes,
+		hash,
+		dependencyTemplates,
+		chunkGraph,
+		moduleGraph,
+		runtimeTemplate,
+		errors,
+		results,
+		callback
+	) {
+		let codeGenerated = false;
+		const cache = new MultiItemCache(
+			runtimes.map(runtime =>
+				this._codeGenerationCache.getItemCache(
+					`${module.identifier()}|${getRuntimeKey(runtime)}`,
+					`${hash}|${dependencyTemplates.getHash()}`
+				)
+			)
 		);
+		cache.get((err, cachedResult) => {
+			if (err) return callback(err);
+			let result;
+			if (!cachedResult) {
+				try {
+					codeGenerated = true;
+					this.codeGeneratedModules.add(module);
+					result = module.codeGeneration({
+						chunkGraph,
+						moduleGraph,
+						dependencyTemplates,
+						runtimeTemplate,
+						runtime,
+						codeGenerationResults: results
+					});
+				} catch (err) {
+					errors.push(new CodeGenerationError(module, err));
+					result = cachedResult = {
+						sources: new Map(),
+						runtimeRequirements: null
+					};
+				}
+			} else {
+				result = cachedResult;
+			}
+			for (const runtime of runtimes) {
+				results.add(module, runtime, result);
+			}
+			if (!cachedResult) {
+				cache.store(result, err => callback(err, codeGenerated));
+			} else {
+				callback(null, codeGenerated);
+			}
+		});
 	}
-}
-
-module.exports = MultiHook;
 
+	_getChunkGraphEntries() {
+		/** @type {Set<Chunk>} */
+		const treeEntries = new Set();
+		for (const ep of this.entrypoints.values()) {
+			const chunk = ep.getRuntimeChunk();
+			if (chunk) treeEntries.add(chunk);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			const chunk = ep.getRuntimeChunk();
+			if (chunk) treeEntries.add(chunk);
+		}
+		return treeEntries;
+	}
 
-/***/ }),
+	/**
+	 * @param {Object} options options
+	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
+	 * @param {Iterable<Module>=} options.modules modules
+	 * @param {Iterable<Chunk>=} options.chunks chunks
+	 * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults
+	 * @param {Iterable<Chunk>=} options.chunkGraphEntries chunkGraphEntries
+	 * @returns {void}
+	 */
+	processRuntimeRequirements({
+		chunkGraph = this.chunkGraph,
+		modules = this.modules,
+		chunks = this.chunks,
+		codeGenerationResults = this.codeGenerationResults,
+		chunkGraphEntries = this._getChunkGraphEntries()
+	} = {}) {
+		const context = { chunkGraph, codeGenerationResults };
+		const { moduleMemCaches2 } = this;
+		this.logger.time("runtime requirements.modules");
+		const additionalModuleRuntimeRequirements =
+			this.hooks.additionalModuleRuntimeRequirements;
+		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
+		for (const module of modules) {
+			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
+				const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
+				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+					if (memCache) {
+						const cached = memCache.get(
+							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
+						);
+						if (cached !== undefined) {
+							if (cached !== null) {
+								chunkGraph.addModuleRuntimeRequirements(
+									module,
+									runtime,
+									cached,
+									false
+								);
+							}
+							continue;
+						}
+					}
+					let set;
+					const runtimeRequirements =
+						codeGenerationResults.getRuntimeRequirements(module, runtime);
+					if (runtimeRequirements && runtimeRequirements.size > 0) {
+						set = new Set(runtimeRequirements);
+					} else if (additionalModuleRuntimeRequirements.isUsed()) {
+						set = new Set();
+					} else {
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
+						}
+						continue;
+					}
+					additionalModuleRuntimeRequirements.call(module, set, context);
 
-/***/ 1626:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					for (const r of set) {
+						const hook = runtimeRequirementInModule.get(r);
+						if (hook !== undefined) hook.call(module, set, context);
+					}
+					if (set.size === 0) {
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
+						}
+					} else {
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								set
+							);
+							chunkGraph.addModuleRuntimeRequirements(
+								module,
+								runtime,
+								set,
+								false
+							);
+						} else {
+							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+						}
+					}
+				}
+			}
+		}
+		this.logger.timeEnd("runtime requirements.modules");
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		this.logger.time("runtime requirements.chunks");
+		for (const chunk of chunks) {
+			const set = new Set();
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+					module,
+					chunk.runtime
+				);
+				for (const r of runtimeRequirements) set.add(r);
+			}
+			this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context);
 
+			for (const r of set) {
+				this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context);
+			}
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+			chunkGraph.addChunkRuntimeRequirements(chunk, set);
+		}
+		this.logger.timeEnd("runtime requirements.chunks");
 
-class SyncBailHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
-		return this.callTapsSeries({
-			onError: (i, err) => onError(err),
-			onResult: (i, result, next) =>
-				`if(${result} !== undefined) {\n${onResult(
-					result
-				)};\n} else {\n${next()}}\n`,
-			resultReturns,
-			onDone,
-			rethrowIfPossible
-		});
-	}
-}
-
-const factory = new SyncBailHookCodeFactory();
-
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncBailHook");
-};
-
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncBailHook");
-};
-
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+		this.logger.time("runtime requirements.entries");
+		for (const treeEntry of chunkGraphEntries) {
+			const set = new Set();
+			for (const chunk of treeEntry.getAllReferencedChunks()) {
+				const runtimeRequirements =
+					chunkGraph.getChunkRuntimeRequirements(chunk);
+				for (const r of runtimeRequirements) set.add(r);
+			}
 
-function SyncBailHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = SyncBailHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
-}
+			this.hooks.additionalTreeRuntimeRequirements.call(
+				treeEntry,
+				set,
+				context
+			);
 
-SyncBailHook.prototype = null;
+			for (const r of set) {
+				this.hooks.runtimeRequirementInTree
+					.for(r)
+					.call(treeEntry, set, context);
+			}
 
-module.exports = SyncBailHook;
+			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
+		}
+		this.logger.timeEnd("runtime requirements.entries");
+	}
 
+	// TODO webpack 6 make chunkGraph argument non-optional
+	/**
+	 * @param {Chunk} chunk target chunk
+	 * @param {RuntimeModule} module runtime module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
+		// Deprecated ModuleGraph association
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
-/***/ }),
+		// add it to the list
+		this.modules.add(module);
+		this._modules.set(module.identifier(), module);
 
-/***/ 69689:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// connect to the chunk graph
+		chunkGraph.connectChunkAndModule(chunk, module);
+		chunkGraph.connectChunkAndRuntimeModule(chunk, module);
+		if (module.fullHash) {
+			chunkGraph.addFullHashModuleToChunk(chunk, module);
+		} else if (module.dependentHash) {
+			chunkGraph.addDependentHashModuleToChunk(chunk, module);
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		// attach runtime module
+		module.attach(this, chunk, chunkGraph);
 
+		// Setup internals
+		const exportsInfo = this.moduleGraph.getExportsInfo(module);
+		exportsInfo.setHasProvideInfo();
+		if (typeof chunk.runtime === "string") {
+			exportsInfo.setUsedForSideEffectsOnly(chunk.runtime);
+		} else if (chunk.runtime === undefined) {
+			exportsInfo.setUsedForSideEffectsOnly(undefined);
+		} else {
+			for (const runtime of chunk.runtime) {
+				exportsInfo.setUsedForSideEffectsOnly(runtime);
+			}
+		}
+		chunkGraph.addModuleRuntimeRequirements(
+			module,
+			chunk.runtime,
+			new Set([RuntimeGlobals.requireScope])
+		);
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+		// runtime modules don't need ids
+		chunkGraph.setModuleId(module, "");
 
-class SyncHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone, rethrowIfPossible }) {
-		return this.callTapsSeries({
-			onError: (i, err) => onError(err),
-			onDone,
-			rethrowIfPossible
-		});
+		// Call hook
+		this.hooks.runtimeModule.call(module, chunk);
 	}
-}
-
-const factory = new SyncHookCodeFactory();
 
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncHook");
-};
-
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncHook");
-};
+	/**
+	 * If `module` is passed, `loc` and `request` must also be passed.
+	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
+	 * @param {Module=} module the module the references the chunk group
+	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
+	 * @param {string=} request the request from which the the chunk group is referenced
+	 * @returns {ChunkGroup} the new or existing chunk group
+	 */
+	addChunkInGroup(groupOptions, module, loc, request) {
+		if (typeof groupOptions === "string") {
+			groupOptions = { name: groupOptions };
+		}
+		const name = groupOptions.name;
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+		if (name) {
+			const chunkGroup = this.namedChunkGroups.get(name);
+			if (chunkGroup !== undefined) {
+				chunkGroup.addOptions(groupOptions);
+				if (module) {
+					chunkGroup.addOrigin(module, loc, request);
+				}
+				return chunkGroup;
+			}
+		}
+		const chunkGroup = new ChunkGroup(groupOptions);
+		if (module) chunkGroup.addOrigin(module, loc, request);
+		const chunk = this.addChunk(name);
 
-function SyncHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = SyncHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
-}
+		connectChunkGroupAndChunk(chunkGroup, chunk);
 
-SyncHook.prototype = null;
+		this.chunkGroups.push(chunkGroup);
+		if (name) {
+			this.namedChunkGroups.set(name, chunkGroup);
+		}
+		return chunkGroup;
+	}
 
-module.exports = SyncHook;
+	/**
+	 * @param {EntryOptions} options options for the entrypoint
+	 * @param {Module} module the module the references the chunk group
+	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
+	 * @param {string} request the request from which the the chunk group is referenced
+	 * @returns {Entrypoint} the new or existing entrypoint
+	 */
+	addAsyncEntrypoint(options, module, loc, request) {
+		const name = options.name;
+		if (name) {
+			const entrypoint = this.namedChunkGroups.get(name);
+			if (entrypoint instanceof Entrypoint) {
+				if (entrypoint !== undefined) {
+					if (module) {
+						entrypoint.addOrigin(module, loc, request);
+					}
+					return entrypoint;
+				}
+			} else if (entrypoint) {
+				throw new Error(
+					`Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name`
+				);
+			}
+		}
+		const chunk = this.addChunk(name);
+		if (options.filename) {
+			chunk.filenameTemplate = options.filename;
+		}
+		const entrypoint = new Entrypoint(options, false);
+		entrypoint.setRuntimeChunk(chunk);
+		entrypoint.setEntrypointChunk(chunk);
+		if (name) {
+			this.namedChunkGroups.set(name, entrypoint);
+		}
+		this.chunkGroups.push(entrypoint);
+		this.asyncEntrypoints.push(entrypoint);
+		connectChunkGroupAndChunk(entrypoint, chunk);
+		if (module) {
+			entrypoint.addOrigin(module, loc, request);
+		}
+		return entrypoint;
+	}
 
+	/**
+	 * This method first looks to see if a name is provided for a new chunk,
+	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
+	 *
+	 * @param {string=} name optional chunk name to be provided
+	 * @returns {Chunk} create a chunk (invoked during seal event)
+	 */
+	addChunk(name) {
+		if (name) {
+			const chunk = this.namedChunks.get(name);
+			if (chunk !== undefined) {
+				return chunk;
+			}
+		}
+		const chunk = new Chunk(name, this._backCompat);
+		this.chunks.add(chunk);
+		if (this._backCompat)
+			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
+		if (name) {
+			this.namedChunks.set(name, chunk);
+		}
+		return chunk;
+	}
 
-/***/ }),
+	/**
+	 * @deprecated
+	 * @param {Module} module module to assign depth
+	 * @returns {void}
+	 */
+	assignDepth(module) {
+		const moduleGraph = this.moduleGraph;
 
-/***/ 50179:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const queue = new Set([module]);
+		let depth;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		moduleGraph.setDepth(module, 0);
 
+		/**
+		 * @param {Module} module module for processing
+		 * @returns {void}
+		 */
+		const processModule = module => {
+			if (!moduleGraph.setDepthIfLower(module, depth)) return;
+			queue.add(module);
+		};
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+		for (module of queue) {
+			queue.delete(module);
+			depth = moduleGraph.getDepth(module) + 1;
 
-class SyncLoopHookCodeFactory extends HookCodeFactory {
-	content({ onError, onDone, rethrowIfPossible }) {
-		return this.callTapsLooping({
-			onError: (i, err) => onError(err),
-			onDone,
-			rethrowIfPossible
-		});
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const refModule = connection.module;
+				if (refModule) {
+					processModule(refModule);
+				}
+			}
+		}
 	}
-}
 
-const factory = new SyncLoopHookCodeFactory();
+	/**
+	 * @param {Set<Module>} modules module to assign depth
+	 * @returns {void}
+	 */
+	assignDepths(modules) {
+		const moduleGraph = this.moduleGraph;
 
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncLoopHook");
-};
+		/** @type {Set<Module | number>} */
+		const queue = new Set(modules);
+		queue.add(1);
+		let depth = 0;
 
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncLoopHook");
-};
+		let i = 0;
+		for (const module of queue) {
+			i++;
+			if (typeof module === "number") {
+				depth = module;
+				if (queue.size === i) return;
+				queue.add(depth + 1);
+			} else {
+				moduleGraph.setDepth(module, depth);
+				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
+					module
+				)) {
+					if (refModule) {
+						queue.add(refModule);
+					}
+				}
+			}
+		}
+	}
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getDependencyReferencedExports(dependency, runtime) {
+		const referencedExports = dependency.getReferencedExports(
+			this.moduleGraph,
+			runtime
+		);
+		return this.hooks.dependencyReferencedExports.call(
+			referencedExports,
+			dependency,
+			runtime
+		);
+	}
 
-function SyncLoopHook(args = [], name = undefined) {
-	const hook = new Hook(args, name);
-	hook.constructor = SyncLoopHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
-}
+	/**
+	 *
+	 * @param {Module} module module relationship for removal
+	 * @param {DependenciesBlockLike} block //TODO: good description
+	 * @returns {void}
+	 */
+	removeReasonsOfDependencyBlock(module, block) {
+		if (block.blocks) {
+			for (const b of block.blocks) {
+				this.removeReasonsOfDependencyBlock(module, b);
+			}
+		}
 
-SyncLoopHook.prototype = null;
+		if (block.dependencies) {
+			for (const dep of block.dependencies) {
+				const originalModule = this.moduleGraph.getModule(dep);
+				if (originalModule) {
+					this.moduleGraph.removeConnection(dep);
 
-module.exports = SyncLoopHook;
+					if (this.chunkGraph) {
+						for (const chunk of this.chunkGraph.getModuleChunks(
+							originalModule
+						)) {
+							this.patchChunksAfterReasonRemoval(originalModule, chunk);
+						}
+					}
+				}
+			}
+		}
+	}
 
+	/**
+	 * @param {Module} module module to patch tie
+	 * @param {Chunk} chunk chunk to patch tie
+	 * @returns {void}
+	 */
+	patchChunksAfterReasonRemoval(module, chunk) {
+		if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
+			this.removeReasonsOfDependencyBlock(module, module);
+		}
+		if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
+			if (this.chunkGraph.isModuleInChunk(module, chunk)) {
+				this.chunkGraph.disconnectChunkAndModule(chunk, module);
+				this.removeChunkFromDependencies(module, chunk);
+			}
+		}
+	}
 
-/***/ }),
+	/**
+	 *
+	 * @param {DependenciesBlock} block block tie for Chunk
+	 * @param {Chunk} chunk chunk to remove from dep
+	 * @returns {void}
+	 */
+	removeChunkFromDependencies(block, chunk) {
+		/**
+		 * @param {Dependency} d dependency to (maybe) patch up
+		 */
+		const iteratorDependency = d => {
+			const depModule = this.moduleGraph.getModule(d);
+			if (!depModule) {
+				return;
+			}
+			this.patchChunksAfterReasonRemoval(depModule, chunk);
+		};
 
-/***/ 36093:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const blocks = block.blocks;
+		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+			const asyncBlock = blocks[indexBlock];
+			const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
+			// Grab all chunks from the first Block's AsyncDepBlock
+			const chunks = chunkGroup.chunks;
+			// For each chunk in chunkGroup
+			for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+				const iteratedChunk = chunks[indexChunk];
+				chunkGroup.removeChunk(iteratedChunk);
+				// Recurse
+				this.removeChunkFromDependencies(block, iteratedChunk);
+			}
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		if (block.dependencies) {
+			for (const dep of block.dependencies) iteratorDependency(dep);
+		}
+	}
 
+	assignRuntimeIds() {
+		const { chunkGraph } = this;
+		const processEntrypoint = ep => {
+			const runtime = ep.options.runtime || ep.name;
+			const chunk = ep.getRuntimeChunk();
+			chunkGraph.setRuntimeId(runtime, chunk.id);
+		};
+		for (const ep of this.entrypoints.values()) {
+			processEntrypoint(ep);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			processEntrypoint(ep);
+		}
+	}
 
-const Hook = __webpack_require__(21468);
-const HookCodeFactory = __webpack_require__(66443);
+	sortItemsWithChunkIds() {
+		for (const chunkGroup of this.chunkGroups) {
+			chunkGroup.sortItems();
+		}
 
-class SyncWaterfallHookCodeFactory extends HookCodeFactory {
-	content({ onError, onResult, resultReturns, rethrowIfPossible }) {
-		return this.callTapsSeries({
-			onError: (i, err) => onError(err),
-			onResult: (i, result, next) => {
-				let code = "";
-				code += `if(${result} !== undefined) {\n`;
-				code += `${this._args[0]} = ${result};\n`;
-				code += `}\n`;
-				code += next();
-				return code;
-			},
-			onDone: () => onResult(this._args[0]),
-			doneReturns: resultReturns,
-			rethrowIfPossible
-		});
+		this.errors.sort(compareErrors);
+		this.warnings.sort(compareErrors);
+		this.children.sort(byNameOrHash);
 	}
-}
 
-const factory = new SyncWaterfallHookCodeFactory();
-
-const TAP_ASYNC = () => {
-	throw new Error("tapAsync is not supported on a SyncWaterfallHook");
-};
+	summarizeDependencies() {
+		for (
+			let indexChildren = 0;
+			indexChildren < this.children.length;
+			indexChildren++
+		) {
+			const child = this.children[indexChildren];
 
-const TAP_PROMISE = () => {
-	throw new Error("tapPromise is not supported on a SyncWaterfallHook");
-};
+			this.fileDependencies.addAll(child.fileDependencies);
+			this.contextDependencies.addAll(child.contextDependencies);
+			this.missingDependencies.addAll(child.missingDependencies);
+			this.buildDependencies.addAll(child.buildDependencies);
+		}
 
-const COMPILE = function(options) {
-	factory.setup(this, options);
-	return factory.create(options);
-};
-
-function SyncWaterfallHook(args = [], name = undefined) {
-	if (args.length < 1)
-		throw new Error("Waterfall hooks must have at least one argument");
-	const hook = new Hook(args, name);
-	hook.constructor = SyncWaterfallHook;
-	hook.tapAsync = TAP_ASYNC;
-	hook.tapPromise = TAP_PROMISE;
-	hook.compile = COMPILE;
-	return hook;
-}
-
-SyncWaterfallHook.prototype = null;
-
-module.exports = SyncWaterfallHook;
-
-
-/***/ }),
-
-/***/ 41242:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-exports.__esModule = true;
-exports.SyncHook = __webpack_require__(69689);
-exports.SyncBailHook = __webpack_require__(1626);
-exports.SyncWaterfallHook = __webpack_require__(36093);
-exports.SyncLoopHook = __webpack_require__(50179);
-exports.AsyncParallelHook = __webpack_require__(31684);
-exports.AsyncParallelBailHook = __webpack_require__(18151);
-exports.AsyncSeriesHook = __webpack_require__(96496);
-exports.AsyncSeriesBailHook = __webpack_require__(95734);
-exports.AsyncSeriesLoopHook = __webpack_require__(95999);
-exports.AsyncSeriesWaterfallHook = __webpack_require__(58118);
-exports.HookMap = __webpack_require__(77079);
-exports.MultiHook = __webpack_require__(13103);
+		for (const module of this.modules) {
+			module.addCacheDependencies(
+				this.fileDependencies,
+				this.contextDependencies,
+				this.missingDependencies,
+				this.buildDependencies
+			);
+		}
+	}
 
+	createModuleHashes() {
+		let statModulesHashed = 0;
+		let statModulesFromCache = 0;
+		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
+		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
+		for (const module of this.modules) {
+			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
+			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				if (memCache) {
+					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
+					if (digest !== undefined) {
+						chunkGraph.setModuleHashes(
+							module,
+							runtime,
+							digest,
+							digest.substr(0, hashDigestLength)
+						);
+						statModulesFromCache++;
+						continue;
+					}
+				}
+				statModulesHashed++;
+				const digest = this._createModuleHash(
+					module,
+					chunkGraph,
+					runtime,
+					hashFunction,
+					runtimeTemplate,
+					hashDigest,
+					hashDigestLength
+				);
+				if (memCache) {
+					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+				}
+			}
+		}
+		this.logger.log(
+			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
+				Math.round(
+					(100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
+				) / 100
+			} variants per module in average)`
+		);
+	}
 
-/***/ }),
+	_createModuleHash(
+		module,
+		chunkGraph,
+		runtime,
+		hashFunction,
+		runtimeTemplate,
+		hashDigest,
+		hashDigestLength
+	) {
+		const moduleHash = createHash(hashFunction);
+		module.updateHash(moduleHash, {
+			chunkGraph,
+			runtime,
+			runtimeTemplate
+		});
+		const moduleHashDigest = /** @type {string} */ (
+			moduleHash.digest(hashDigest)
+		);
+		chunkGraph.setModuleHashes(
+			module,
+			runtime,
+			moduleHashDigest,
+			moduleHashDigest.substr(0, hashDigestLength)
+		);
+		return moduleHashDigest;
+	}
 
-/***/ 74315:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	createHash() {
+		this.logger.time("hashing: initialize hash");
+		const chunkGraph = this.chunkGraph;
+		const runtimeTemplate = this.runtimeTemplate;
+		const outputOptions = this.outputOptions;
+		const hashFunction = outputOptions.hashFunction;
+		const hashDigest = outputOptions.hashDigest;
+		const hashDigestLength = outputOptions.hashDigestLength;
+		const hash = createHash(hashFunction);
+		if (outputOptions.hashSalt) {
+			hash.update(outputOptions.hashSalt);
+		}
+		this.logger.timeEnd("hashing: initialize hash");
+		if (this.children.length > 0) {
+			this.logger.time("hashing: hash child compilations");
+			for (const child of this.children) {
+				hash.update(child.hash);
+			}
+			this.logger.timeEnd("hashing: hash child compilations");
+		}
+		if (this.warnings.length > 0) {
+			this.logger.time("hashing: hash warnings");
+			for (const warning of this.warnings) {
+				hash.update(`${warning.message}`);
+			}
+			this.logger.timeEnd("hashing: hash warnings");
+		}
+		if (this.errors.length > 0) {
+			this.logger.time("hashing: hash errors");
+			for (const error of this.errors) {
+				hash.update(`${error.message}`);
+			}
+			this.logger.timeEnd("hashing: hash errors");
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		this.logger.time("hashing: sort chunks");
+		/*
+		 * all non-runtime chunks need to be hashes first,
+		 * since runtime chunk might use their hashes.
+		 * runtime chunks need to be hashed in the correct order
+		 * since they may depend on each other (for async entrypoints).
+		 * So we put all non-runtime chunks first and hash them in any order.
+		 * And order runtime chunks according to referenced between each other.
+		 * Chunks need to be in deterministic order since we add hashes to full chunk
+		 * during these hashing.
+		 */
+		/** @type {Chunk[]} */
+		const unorderedRuntimeChunks = [];
+		/** @type {Chunk[]} */
+		const otherChunks = [];
+		for (const c of this.chunks) {
+			if (c.hasRuntime()) {
+				unorderedRuntimeChunks.push(c);
+			} else {
+				otherChunks.push(c);
+			}
+		}
+		unorderedRuntimeChunks.sort(byId);
+		otherChunks.sort(byId);
 
+		/** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
+		/** @type {Map<Chunk, RuntimeChunkInfo>} */
+		const runtimeChunksMap = new Map();
+		for (const chunk of unorderedRuntimeChunks) {
+			runtimeChunksMap.set(chunk, {
+				chunk,
+				referencedBy: [],
+				remaining: 0
+			});
+		}
+		let remaining = 0;
+		for (const info of runtimeChunksMap.values()) {
+			for (const other of new Set(
+				Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
+					e => e.chunks[e.chunks.length - 1]
+				)
+			)) {
+				const otherInfo = runtimeChunksMap.get(other);
+				otherInfo.referencedBy.push(info);
+				info.remaining++;
+				remaining++;
+			}
+		}
+		/** @type {Chunk[]} */
+		const runtimeChunks = [];
+		for (const info of runtimeChunksMap.values()) {
+			if (info.remaining === 0) {
+				runtimeChunks.push(info.chunk);
+			}
+		}
+		// If there are any references between chunks
+		// make sure to follow these chains
+		if (remaining > 0) {
+			const readyChunks = [];
+			for (const chunk of runtimeChunks) {
+				const hasFullHashModules =
+					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
+				const info = runtimeChunksMap.get(chunk);
+				for (const otherInfo of info.referencedBy) {
+					if (hasFullHashModules) {
+						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
+					}
+					remaining--;
+					if (--otherInfo.remaining === 0) {
+						readyChunks.push(otherInfo.chunk);
+					}
+				}
+				if (readyChunks.length > 0) {
+					// This ensures deterministic ordering, since referencedBy is non-deterministic
+					readyChunks.sort(byId);
+					for (const c of readyChunks) runtimeChunks.push(c);
+					readyChunks.length = 0;
+				}
+			}
+		}
+		// If there are still remaining references we have cycles and want to create a warning
+		if (remaining > 0) {
+			let circularRuntimeChunkInfo = [];
+			for (const info of runtimeChunksMap.values()) {
+				if (info.remaining !== 0) {
+					circularRuntimeChunkInfo.push(info);
+				}
+			}
+			circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
+			const err =
+				new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
+					circularRuntimeChunkInfo,
+					c => c.chunk.name || c.chunk.id
+				).join(", ")})
+This prevents using hashes of each other and should be avoided.`);
+			err.chunk = circularRuntimeChunkInfo[0].chunk;
+			this.warnings.push(err);
+			for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
+		}
+		this.logger.timeEnd("hashing: sort chunks");
 
+		const fullHashChunks = new Set();
+		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		const codeGenerationJobs = [];
+		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
+		const codeGenerationJobsMap = new Map();
 
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const ConstDependency = __webpack_require__(76911);
-const BasicEvaluatedExpression = __webpack_require__(950);
-const {
-	toConstantDependency,
-	evaluateToString
-} = __webpack_require__(93998);
-const ChunkNameRuntimeModule = __webpack_require__(84519);
-const GetFullHashRuntimeModule = __webpack_require__(88732);
+		const processChunk = chunk => {
+			// Last minute module hash generation for modules that depend on chunk hashes
+			this.logger.time("hashing: hash runtime modules");
+			const runtime = chunk.runtime;
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!chunkGraph.hasModuleHashes(module, runtime)) {
+					const hash = this._createModuleHash(
+						module,
+						chunkGraph,
+						runtime,
+						hashFunction,
+						runtimeTemplate,
+						hashDigest,
+						hashDigestLength
+					);
+					let hashMap = codeGenerationJobsMap.get(hash);
+					if (hashMap) {
+						const moduleJob = hashMap.get(module);
+						if (moduleJob) {
+							moduleJob.runtimes.push(runtime);
+							continue;
+						}
+					} else {
+						hashMap = new Map();
+						codeGenerationJobsMap.set(hash, hashMap);
+					}
+					const job = {
+						module,
+						hash,
+						runtime,
+						runtimes: [runtime]
+					};
+					hashMap.set(module, job);
+					codeGenerationJobs.push(job);
+				}
+			}
+			this.logger.timeAggregate("hashing: hash runtime modules");
+			this.logger.time("hashing: hash chunks");
+			const chunkHash = createHash(hashFunction);
+			try {
+				if (outputOptions.hashSalt) {
+					chunkHash.update(outputOptions.hashSalt);
+				}
+				chunk.updateHash(chunkHash, chunkGraph);
+				this.hooks.chunkHash.call(chunk, chunkHash, {
+					chunkGraph,
+					moduleGraph: this.moduleGraph,
+					runtimeTemplate: this.runtimeTemplate
+				});
+				const chunkHashDigest = /** @type {string} */ (
+					chunkHash.digest(hashDigest)
+				);
+				hash.update(chunkHashDigest);
+				chunk.hash = chunkHashDigest;
+				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+				const fullHashModules =
+					chunkGraph.getChunkFullHashModulesIterable(chunk);
+				if (fullHashModules) {
+					fullHashChunks.add(chunk);
+				} else {
+					this.hooks.contentHash.call(chunk);
+				}
+			} catch (err) {
+				this.errors.push(new ChunkRenderError(chunk, "", err));
+			}
+			this.logger.timeAggregate("hashing: hash chunks");
+		};
+		otherChunks.forEach(processChunk);
+		for (const chunk of runtimeChunks) processChunk(chunk);
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+		this.logger.timeAggregateEnd("hashing: hash runtime modules");
+		this.logger.timeAggregateEnd("hashing: hash chunks");
+		this.logger.time("hashing: hash digest");
+		this.hooks.fullHash.call(hash);
+		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
+		this.hash = this.fullHash.substr(0, hashDigestLength);
+		this.logger.timeEnd("hashing: hash digest");
 
-/* eslint-disable camelcase */
-const REPLACEMENTS = {
-	__webpack_require__: {
-		expr: RuntimeGlobals.require,
-		req: [RuntimeGlobals.require],
-		type: "function",
-		assign: false
-	},
-	__webpack_public_path__: {
-		expr: RuntimeGlobals.publicPath,
-		req: [RuntimeGlobals.publicPath],
-		type: "string",
-		assign: true
-	},
-	__webpack_base_uri__: {
-		expr: RuntimeGlobals.baseURI,
-		req: [RuntimeGlobals.baseURI],
-		type: "string",
-		assign: true
-	},
-	__webpack_modules__: {
-		expr: RuntimeGlobals.moduleFactories,
-		req: [RuntimeGlobals.moduleFactories],
-		type: "object",
-		assign: false
-	},
-	__webpack_chunk_load__: {
-		expr: RuntimeGlobals.ensureChunk,
-		req: [RuntimeGlobals.ensureChunk],
-		type: "function",
-		assign: true
-	},
-	__non_webpack_require__: {
-		expr: "require",
-		req: null,
-		type: undefined, // type is not known, depends on environment
-		assign: true
-	},
-	__webpack_nonce__: {
-		expr: RuntimeGlobals.scriptNonce,
-		req: [RuntimeGlobals.scriptNonce],
-		type: "string",
-		assign: true
-	},
-	__webpack_hash__: {
-		expr: `${RuntimeGlobals.getFullHash}()`,
-		req: [RuntimeGlobals.getFullHash],
-		type: "string",
-		assign: false
-	},
-	__webpack_chunkname__: {
-		expr: RuntimeGlobals.chunkName,
-		req: [RuntimeGlobals.chunkName],
-		type: "string",
-		assign: false
-	},
-	__webpack_get_script_filename__: {
-		expr: RuntimeGlobals.getChunkScriptFilename,
-		req: [RuntimeGlobals.getChunkScriptFilename],
-		type: "function",
-		assign: true
-	},
-	__webpack_runtime_id__: {
-		expr: RuntimeGlobals.runtimeId,
-		req: [RuntimeGlobals.runtimeId],
-		assign: false
-	},
-	"require.onError": {
-		expr: RuntimeGlobals.uncaughtErrorHandler,
-		req: [RuntimeGlobals.uncaughtErrorHandler],
-		type: undefined, // type is not known, could be function or undefined
-		assign: true // is never a pattern
-	},
-	__system_context__: {
-		expr: RuntimeGlobals.systemContext,
-		req: [RuntimeGlobals.systemContext],
-		type: "object",
-		assign: false
-	},
-	__webpack_share_scopes__: {
-		expr: RuntimeGlobals.shareScopeMap,
-		req: [RuntimeGlobals.shareScopeMap],
-		type: "object",
-		assign: false
-	},
-	__webpack_init_sharing__: {
-		expr: RuntimeGlobals.initializeSharing,
-		req: [RuntimeGlobals.initializeSharing],
-		type: "function",
-		assign: true
+		this.logger.time("hashing: process full hash modules");
+		for (const chunk of fullHashChunks) {
+			for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
+				const moduleHash = createHash(hashFunction);
+				module.updateHash(moduleHash, {
+					chunkGraph,
+					runtime: chunk.runtime,
+					runtimeTemplate
+				});
+				const moduleHashDigest = /** @type {string} */ (
+					moduleHash.digest(hashDigest)
+				);
+				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
+				chunkGraph.setModuleHashes(
+					module,
+					chunk.runtime,
+					moduleHashDigest,
+					moduleHashDigest.substr(0, hashDigestLength)
+				);
+				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
+			}
+			const chunkHash = createHash(hashFunction);
+			chunkHash.update(chunk.hash);
+			chunkHash.update(this.hash);
+			const chunkHashDigest = /** @type {string} */ (
+				chunkHash.digest(hashDigest)
+			);
+			chunk.hash = chunkHashDigest;
+			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+			this.hooks.contentHash.call(chunk);
+		}
+		this.logger.timeEnd("hashing: process full hash modules");
+		return codeGenerationJobs;
 	}
-};
-/* eslint-enable camelcase */
 
-class APIPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {string} file file name
+	 * @param {Source} source asset source
+	 * @param {AssetInfo} assetInfo extra asset information
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"APIPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
+	emitAsset(file, source, assetInfo = {}) {
+		if (this.assets[file]) {
+			if (!isSourceEqual(this.assets[file], source)) {
+				this.errors.push(
+					new WebpackError(
+						`Conflict: Multiple assets emit different content to the same filename ${file}`
+					)
 				);
+				this.assets[file] = source;
+				this._setAssetInfo(file, assetInfo);
+				return;
+			}
+			const oldInfo = this.assetsInfo.get(file);
+			const newInfo = Object.assign({}, oldInfo, assetInfo);
+			this._setAssetInfo(file, newInfo, oldInfo);
+			return;
+		}
+		this.assets[file] = source;
+		this._setAssetInfo(file, assetInfo, undefined);
+	}
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.chunkName)
-					.tap("APIPlugin", chunk => {
-						compilation.addRuntimeModule(
-							chunk,
-							new ChunkNameRuntimeModule(chunk.name)
-						);
-						return true;
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.getFullHash)
-					.tap("APIPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(chunk, new GetFullHashRuntimeModule());
-						return true;
-					});
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 */
-				const handler = parser => {
-					Object.keys(REPLACEMENTS).forEach(key => {
-						const info = REPLACEMENTS[key];
-						parser.hooks.expression
-							.for(key)
-							.tap(
-								"APIPlugin",
-								toConstantDependency(parser, info.expr, info.req)
-							);
-						if (info.assign === false) {
-							parser.hooks.assign.for(key).tap("APIPlugin", expr => {
-								const err = new WebpackError(`${key} must not be assigned`);
-								err.loc = expr.loc;
-								throw err;
-							});
-						}
-						if (info.type) {
-							parser.hooks.evaluateTypeof
-								.for(key)
-								.tap("APIPlugin", evaluateToString(info.type));
-						}
-					});
-
-					parser.hooks.expression
-						.for("__webpack_layer__")
-						.tap("APIPlugin", expr => {
-							const dep = new ConstDependency(
-								JSON.stringify(parser.state.module.layer),
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateIdentifier
-						.for("__webpack_layer__")
-						.tap("APIPlugin", expr =>
-							(parser.state.module.layer === null
-								? new BasicEvaluatedExpression().setNull()
-								: new BasicEvaluatedExpression().setString(
-										parser.state.module.layer
-								  )
-							).setRange(expr.range)
-						);
-					parser.hooks.evaluateTypeof
-						.for("__webpack_layer__")
-						.tap("APIPlugin", expr =>
-							new BasicEvaluatedExpression()
-								.setString(
-									parser.state.module.layer === null ? "object" : "string"
-								)
-								.setRange(expr.range)
-						);
-
-					parser.hooks.expression
-						.for("__webpack_module__.id")
-						.tap("APIPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"__webpack_module__.id";
-							const dep = new ConstDependency(
-								parser.state.module.moduleArgument + ".id",
-								expr.range,
-								[RuntimeGlobals.moduleId]
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-
-					parser.hooks.expression
-						.for("__webpack_module__")
-						.tap("APIPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"__webpack_module__";
-							const dep = new ConstDependency(
-								parser.state.module.moduleArgument,
-								expr.range,
-								[RuntimeGlobals.module]
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for("__webpack_module__")
-						.tap("APIPlugin", evaluateToString("object"));
+	_setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
+		if (newInfo === undefined) {
+			this.assetsInfo.delete(file);
+		} else {
+			this.assetsInfo.set(file, newInfo);
+		}
+		const oldRelated = oldInfo && oldInfo.related;
+		const newRelated = newInfo && newInfo.related;
+		if (oldRelated) {
+			for (const key of Object.keys(oldRelated)) {
+				const remove = name => {
+					const relatedIn = this._assetsRelatedIn.get(name);
+					if (relatedIn === undefined) return;
+					const entry = relatedIn.get(key);
+					if (entry === undefined) return;
+					entry.delete(file);
+					if (entry.size !== 0) return;
+					relatedIn.delete(key);
+					if (relatedIn.size === 0) this._assetsRelatedIn.delete(name);
 				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("APIPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("APIPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("APIPlugin", handler);
+				const entry = oldRelated[key];
+				if (Array.isArray(entry)) {
+					entry.forEach(remove);
+				} else if (entry) {
+					remove(entry);
+				}
 			}
-		);
-	}
-}
-
-module.exports = APIPlugin;
-
-
-/***/ }),
-
-/***/ 77198:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
-
-/**
- * @param {string=} method method name
- * @returns {string} message
- */
-function createMessage(method) {
-	return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
-}
-
-/**
- * @constructor
- */
-function Message() {
-	/** @type {string} */
-	this.stack = undefined;
-	Error.captureStackTrace(this);
-	/** @type {RegExpMatchArray} */
-	const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
-
-	this.message = match && match[1] ? createMessage(match[1]) : createMessage();
-}
-
-/**
- * Error for abstract method
- * @example
- * class FooClass {
- *     abstractMethod() {
- *         throw new AbstractMethodError(); // error message: Abstract method FooClass.abstractMethod. Must be overridden.
- *     }
- * }
- *
- */
-class AbstractMethodError extends WebpackError {
-	constructor() {
-		super(new Message().message);
-		this.name = "AbstractMethodError";
+		}
+		if (newRelated) {
+			for (const key of Object.keys(newRelated)) {
+				const add = name => {
+					let relatedIn = this._assetsRelatedIn.get(name);
+					if (relatedIn === undefined) {
+						this._assetsRelatedIn.set(name, (relatedIn = new Map()));
+					}
+					let entry = relatedIn.get(key);
+					if (entry === undefined) {
+						relatedIn.set(key, (entry = new Set()));
+					}
+					entry.add(file);
+				};
+				const entry = newRelated[key];
+				if (Array.isArray(entry)) {
+					entry.forEach(add);
+				} else if (entry) {
+					add(entry);
+				}
+			}
+		}
 	}
-}
-
-module.exports = AbstractMethodError;
-
-
-/***/ }),
-
-/***/ 47736:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
-
-const DependenciesBlock = __webpack_require__(71040);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/Hash")} Hash */
-
-class AsyncDependenciesBlock extends DependenciesBlock {
 	/**
-	 * @param {ChunkGroupOptions & { entryOptions?: EntryOptions }} groupOptions options for the group
-	 * @param {DependencyLocation=} loc the line of code
-	 * @param {string=} request the request
+	 * @param {string} file file name
+	 * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
+	 * @param {AssetInfo | function(AssetInfo | undefined): AssetInfo} assetInfoUpdateOrFunction new asset info or function converting old to new
 	 */
-	constructor(groupOptions, loc, request) {
-		super();
-		if (typeof groupOptions === "string") {
-			groupOptions = { name: groupOptions };
-		} else if (!groupOptions) {
-			groupOptions = { name: undefined };
+	updateAsset(
+		file,
+		newSourceOrFunction,
+		assetInfoUpdateOrFunction = undefined
+	) {
+		if (!this.assets[file]) {
+			throw new Error(
+				`Called Compilation.updateAsset for not existing filename ${file}`
+			);
+		}
+		if (typeof newSourceOrFunction === "function") {
+			this.assets[file] = newSourceOrFunction(this.assets[file]);
+		} else {
+			this.assets[file] = newSourceOrFunction;
+		}
+		if (assetInfoUpdateOrFunction !== undefined) {
+			const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
+			if (typeof assetInfoUpdateOrFunction === "function") {
+				this._setAssetInfo(file, assetInfoUpdateOrFunction(oldInfo), oldInfo);
+			} else {
+				this._setAssetInfo(
+					file,
+					cachedCleverMerge(oldInfo, assetInfoUpdateOrFunction),
+					oldInfo
+				);
+			}
 		}
-		this.groupOptions = groupOptions;
-		this.loc = loc;
-		this.request = request;
-		this._stringifiedGroupOptions = undefined;
 	}
 
-	/**
-	 * @returns {string} The name of the chunk
-	 */
-	get chunkName() {
-		return this.groupOptions.name;
+	renameAsset(file, newFile) {
+		const source = this.assets[file];
+		if (!source) {
+			throw new Error(
+				`Called Compilation.renameAsset for not existing filename ${file}`
+			);
+		}
+		if (this.assets[newFile]) {
+			if (!isSourceEqual(this.assets[file], source)) {
+				this.errors.push(
+					new WebpackError(
+						`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
+					)
+				);
+			}
+		}
+		const assetInfo = this.assetsInfo.get(file);
+		// Update related in all other assets
+		const relatedInInfo = this._assetsRelatedIn.get(file);
+		if (relatedInInfo) {
+			for (const [key, assets] of relatedInInfo) {
+				for (const name of assets) {
+					const info = this.assetsInfo.get(name);
+					if (!info) continue;
+					const related = info.related;
+					if (!related) continue;
+					const entry = related[key];
+					let newEntry;
+					if (Array.isArray(entry)) {
+						newEntry = entry.map(x => (x === file ? newFile : x));
+					} else if (entry === file) {
+						newEntry = newFile;
+					} else continue;
+					this.assetsInfo.set(name, {
+						...info,
+						related: {
+							...related,
+							[key]: newEntry
+						}
+					});
+				}
+			}
+		}
+		this._setAssetInfo(file, undefined, assetInfo);
+		this._setAssetInfo(newFile, assetInfo);
+		delete this.assets[file];
+		this.assets[newFile] = source;
+		for (const chunk of this.chunks) {
+			{
+				const size = chunk.files.size;
+				chunk.files.delete(file);
+				if (size !== chunk.files.size) {
+					chunk.files.add(newFile);
+				}
+			}
+			{
+				const size = chunk.auxiliaryFiles.size;
+				chunk.auxiliaryFiles.delete(file);
+				if (size !== chunk.auxiliaryFiles.size) {
+					chunk.auxiliaryFiles.add(newFile);
+				}
+			}
+		}
 	}
 
 	/**
-	 * @param {string} value The new chunk name
-	 * @returns {void}
+	 * @param {string} file file name
 	 */
-	set chunkName(value) {
-		if (this.groupOptions.name !== value) {
-			this.groupOptions.name = value;
-			this._stringifiedGroupOptions = undefined;
+	deleteAsset(file) {
+		if (!this.assets[file]) {
+			return;
+		}
+		delete this.assets[file];
+		const assetInfo = this.assetsInfo.get(file);
+		this._setAssetInfo(file, undefined, assetInfo);
+		const related = assetInfo && assetInfo.related;
+		if (related) {
+			for (const key of Object.keys(related)) {
+				const checkUsedAndDelete = file => {
+					if (!this._assetsRelatedIn.has(file)) {
+						this.deleteAsset(file);
+					}
+				};
+				const items = related[key];
+				if (Array.isArray(items)) {
+					items.forEach(checkUsedAndDelete);
+				} else if (items) {
+					checkUsedAndDelete(items);
+				}
+			}
+		}
+		// TODO If this becomes a performance problem
+		// store a reverse mapping from asset to chunk
+		for (const chunk of this.chunks) {
+			chunk.files.delete(file);
+			chunk.auxiliaryFiles.delete(file);
 		}
 	}
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph } = context;
-		if (this._stringifiedGroupOptions === undefined) {
-			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+	getAssets() {
+		/** @type {Readonly<Asset>[]} */
+		const array = [];
+		for (const assetName of Object.keys(this.assets)) {
+			if (Object.prototype.hasOwnProperty.call(this.assets, assetName)) {
+				array.push({
+					name: assetName,
+					source: this.assets[assetName],
+					info: this.assetsInfo.get(assetName) || EMPTY_ASSET_INFO
+				});
+			}
 		}
-		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
-		hash.update(
-			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
-		);
-		super.updateHash(hash, context);
+		return array;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.groupOptions);
-		write(this.loc);
-		write(this.request);
-		super.serialize(context);
+	/**
+	 * @param {string} name the name of the asset
+	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
+	 */
+	getAsset(name) {
+		if (!Object.prototype.hasOwnProperty.call(this.assets, name))
+			return undefined;
+		return {
+			name,
+			source: this.assets[name],
+			info: this.assetsInfo.get(name) || EMPTY_ASSET_INFO
+		};
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.groupOptions = read();
-		this.loc = read();
-		this.request = read();
-		super.deserialize(context);
+	clearAssets() {
+		for (const chunk of this.chunks) {
+			chunk.files.clear();
+			chunk.auxiliaryFiles.clear();
+		}
 	}
-}
-
-makeSerializable(AsyncDependenciesBlock, "webpack/lib/AsyncDependenciesBlock");
 
-Object.defineProperty(AsyncDependenciesBlock.prototype, "module", {
-	get() {
-		throw new Error(
-			"module property was removed from AsyncDependenciesBlock (it's not needed)"
-		);
-	},
-	set() {
-		throw new Error(
-			"module property was removed from AsyncDependenciesBlock (it's not needed)"
-		);
+	createModuleAssets() {
+		const { chunkGraph } = this;
+		for (const module of this.modules) {
+			if (module.buildInfo.assets) {
+				const assetsInfo = module.buildInfo.assetsInfo;
+				for (const assetName of Object.keys(module.buildInfo.assets)) {
+					const fileName = this.getPath(assetName, {
+						chunkGraph: this.chunkGraph,
+						module
+					});
+					for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+						chunk.auxiliaryFiles.add(fileName);
+					}
+					this.emitAsset(
+						fileName,
+						module.buildInfo.assets[assetName],
+						assetsInfo ? assetsInfo.get(assetName) : undefined
+					);
+					this.hooks.moduleAsset.call(module, fileName);
+				}
+			}
+		}
 	}
-});
-
-module.exports = AsyncDependenciesBlock;
-
-
-/***/ }),
-
-/***/ 30111:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
 
-
-
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-
-class AsyncDependencyToInitialChunkError extends WebpackError {
 	/**
-	 * Creates an instance of AsyncDependencyToInitialChunkError.
-	 * @param {string} chunkName Name of Chunk
-	 * @param {Module} module module tied to dependency
-	 * @param {DependencyLocation} loc location of dependency
+	 * @param {RenderManifestOptions} options options object
+	 * @returns {RenderManifestEntry[]} manifest entries
 	 */
-	constructor(chunkName, module, loc) {
-		super(
-			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
-		);
-
-		this.name = "AsyncDependencyToInitialChunkError";
-		this.module = module;
-		this.loc = loc;
+	getRenderManifest(options) {
+		return this.hooks.renderManifest.call([], options);
 	}
-}
-
-module.exports = AsyncDependencyToInitialChunkError;
-
 
-/***/ }),
+	/**
+	 * @param {Callback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	createChunkAssets(callback) {
+		const outputOptions = this.outputOptions;
+		const cachedSourceMap = new WeakMap();
+		/** @type {Map<string, {hash: string, source: Source, chunk: Chunk}>} */
+		const alreadyWrittenFiles = new Map();
 
-/***/ 17714:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const asyncLib = __webpack_require__(78175);
-const NormalModule = __webpack_require__(39);
-const PrefetchDependency = __webpack_require__(31618);
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class AutomaticPrefetchPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AutomaticPrefetchPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					PrefetchDependency,
-					normalModuleFactory
-				);
-			}
-		);
-		let lastModules = null;
-		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
-			lastModules = [];
-
-			for (const m of compilation.modules) {
-				if (m instanceof NormalModule) {
-					lastModules.push({
-						context: m.context,
-						request: m.request
+		asyncLib.forEachLimit(
+			this.chunks,
+			15,
+			(chunk, callback) => {
+				/** @type {RenderManifestEntry[]} */
+				let manifest;
+				try {
+					manifest = this.getRenderManifest({
+						chunk,
+						hash: this.hash,
+						fullHash: this.fullHash,
+						outputOptions,
+						codeGenerationResults: this.codeGenerationResults,
+						moduleTemplates: this.moduleTemplates,
+						dependencyTemplates: this.dependencyTemplates,
+						chunkGraph: this.chunkGraph,
+						moduleGraph: this.moduleGraph,
+						runtimeTemplate: this.runtimeTemplate
 					});
+				} catch (err) {
+					this.errors.push(new ChunkRenderError(chunk, "", err));
+					return callback();
 				}
-			}
-		});
-		compiler.hooks.make.tapAsync(
-			"AutomaticPrefetchPlugin",
-			(compilation, callback) => {
-				if (!lastModules) return callback();
 				asyncLib.forEach(
-					lastModules,
-					(m, callback) => {
-						compilation.addModuleChain(
-							m.context || compiler.context,
-							new PrefetchDependency(`!!${m.request}`),
-							callback
-						);
-					},
-					err => {
-						lastModules = null;
-						callback(err);
-					}
-				);
-			}
-		);
-	}
-}
-module.exports = AutomaticPrefetchPlugin;
-
+					manifest,
+					(fileManifest, callback) => {
+						const ident = fileManifest.identifier;
+						const usedHash = fileManifest.hash;
 
-/***/ }),
+						const assetCacheItem = this._assetsCache.getItemCache(
+							ident,
+							usedHash
+						);
 
-/***/ 21242:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+						assetCacheItem.get((err, sourceFromCache) => {
+							/** @type {string | function(PathData, AssetInfo=): string} */
+							let filenameTemplate;
+							/** @type {string} */
+							let file;
+							/** @type {AssetInfo} */
+							let assetInfo;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+							let inTry = true;
+							const errorAndCallback = err => {
+								const filename =
+									file ||
+									(typeof file === "string"
+										? file
+										: typeof filenameTemplate === "string"
+										? filenameTemplate
+										: "");
 
+								this.errors.push(new ChunkRenderError(chunk, filename, err));
+								inTry = false;
+								return callback();
+							};
 
+							try {
+								if ("filename" in fileManifest) {
+									file = fileManifest.filename;
+									assetInfo = fileManifest.info;
+								} else {
+									filenameTemplate = fileManifest.filenameTemplate;
+									const pathAndInfo = this.getPathWithInfo(
+										filenameTemplate,
+										fileManifest.pathOptions
+									);
+									file = pathAndInfo.path;
+									assetInfo = fileManifest.info
+										? {
+												...pathAndInfo.info,
+												...fileManifest.info
+										  }
+										: pathAndInfo.info;
+								}
 
-const { ConcatSource } = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const Template = __webpack_require__(39722);
-const createSchemaValidation = __webpack_require__(32540);
+								if (err) {
+									return errorAndCallback(err);
+								}
 
-/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
-/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
+								let source = sourceFromCache;
 
-const validate = createSchemaValidation(
-	__webpack_require__(42173),
-	() => __webpack_require__(49052),
-	{
-		name: "Banner Plugin",
-		baseDataPath: "options"
-	}
-);
+								// check if the same filename was already written by another chunk
+								const alreadyWritten = alreadyWrittenFiles.get(file);
+								if (alreadyWritten !== undefined) {
+									if (alreadyWritten.hash !== usedHash) {
+										inTry = false;
+										return callback(
+											new WebpackError(
+												`Conflict: Multiple chunks emit assets to the same filename ${file}` +
+													` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
+											)
+										);
+									} else {
+										source = alreadyWritten.source;
+									}
+								} else if (!source) {
+									// render the asset
+									source = fileManifest.render();
 
-const wrapComment = str => {
-	if (!str.includes("\n")) {
-		return Template.toComment(str);
+									// Ensure that source is a cached source to avoid additional cost because of repeated access
+									if (!(source instanceof CachedSource)) {
+										const cacheEntry = cachedSourceMap.get(source);
+										if (cacheEntry) {
+											source = cacheEntry;
+										} else {
+											const cachedSource = new CachedSource(source);
+											cachedSourceMap.set(source, cachedSource);
+											source = cachedSource;
+										}
+									}
+								}
+								this.emitAsset(file, source, assetInfo);
+								if (fileManifest.auxiliary) {
+									chunk.auxiliaryFiles.add(file);
+								} else {
+									chunk.files.add(file);
+								}
+								this.hooks.chunkAsset.call(chunk, file);
+								alreadyWrittenFiles.set(file, {
+									hash: usedHash,
+									source,
+									chunk
+								});
+								if (source !== sourceFromCache) {
+									assetCacheItem.store(source, err => {
+										if (err) return errorAndCallback(err);
+										inTry = false;
+										return callback();
+									});
+								} else {
+									inTry = false;
+									callback();
+								}
+							} catch (err) {
+								if (!inTry) throw err;
+								errorAndCallback(err);
+							}
+						});
+					},
+					callback
+				);
+			},
+			callback
+		);
 	}
-	return `/*!\n * ${str
-		.replace(/\*\//g, "* /")
-		.split("\n")
-		.join("\n * ")
-		.replace(/\s+\n/g, "\n")
-		.trimRight()}\n */`;
-};
 
-class BannerPlugin {
 	/**
-	 * @param {BannerPluginArgument} options options object
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {string} interpolated path
 	 */
-	constructor(options) {
-		if (typeof options === "string" || typeof options === "function") {
-			options = {
-				banner: options
+	getPath(filename, data = {}) {
+		if (!data.hash) {
+			data = {
+				hash: this.hash,
+				...data
 			};
 		}
-
-		validate(options);
-
-		this.options = options;
-
-		const bannerOption = options.banner;
-		if (typeof bannerOption === "function") {
-			const getBanner = bannerOption;
-			this.banner = this.options.raw
-				? getBanner
-				: data => wrapComment(getBanner(data));
-		} else {
-			const banner = this.options.raw
-				? bannerOption
-				: wrapComment(bannerOption);
-			this.banner = () => banner;
-		}
+		return this.getAssetPath(filename, data);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
 	 */
-	apply(compiler) {
-		const options = this.options;
-		const banner = this.banner;
-		const matchObject = ModuleFilenameHelpers.matchObject.bind(
-			undefined,
-			options
-		);
-
-		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
-			compilation.hooks.processAssets.tap(
-				{
-					name: "BannerPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-				},
-				() => {
-					for (const chunk of compilation.chunks) {
-						if (options.entryOnly && !chunk.canBeInitial()) {
-							continue;
-						}
-
-						for (const file of chunk.files) {
-							if (!matchObject(file)) {
-								continue;
-							}
-
-							const data = {
-								chunk,
-								filename: file
-							};
-
-							const comment = compilation.getPath(banner, data);
-
-							compilation.updateAsset(
-								file,
-								old => new ConcatSource(comment, "\n", old)
-							);
-						}
-					}
-				}
-			);
-		});
-	}
-}
-
-module.exports = BannerPlugin;
-
-
-/***/ }),
-
-/***/ 7592:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = __webpack_require__(41242);
-const {
-	makeWebpackError,
-	makeWebpackErrorCallback
-} = __webpack_require__(11351);
-
-/** @typedef {import("./WebpackError")} WebpackError */
-
-/**
- * @typedef {Object} Etag
- * @property {function(): string} toString
- */
-
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
-
-/**
- * @callback GotHandler
- * @param {any} result
- * @param {function(Error=): void} callback
- * @returns {void}
- */
-
-const needCalls = (times, callback) => {
-	return err => {
-		if (--times === 0) {
-			return callback(err);
-		}
-		if (err && times > 0) {
-			times = 0;
-			return callback(err);
+	getPathWithInfo(filename, data = {}) {
+		if (!data.hash) {
+			data = {
+				hash: this.hash,
+				...data
+			};
 		}
-	};
-};
-
-class Cache {
-	constructor() {
-		this.hooks = {
-			/** @type {AsyncSeriesBailHook<[string, Etag | null, GotHandler[]], any>} */
-			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
-			/** @type {AsyncParallelHook<[string, Etag | null, any]>} */
-			store: new AsyncParallelHook(["identifier", "etag", "data"]),
-			/** @type {AsyncParallelHook<[Iterable<string>]>} */
-			storeBuildDependencies: new AsyncParallelHook(["dependencies"]),
-			/** @type {SyncHook<[]>} */
-			beginIdle: new SyncHook([]),
-			/** @type {AsyncParallelHook<[]>} */
-			endIdle: new AsyncParallelHook([]),
-			/** @type {AsyncParallelHook<[]>} */
-			shutdown: new AsyncParallelHook([])
-		};
+		return this.getAssetPathWithInfo(filename, data);
 	}
 
 	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {string} interpolated path
 	 */
-	get(identifier, etag, callback) {
-		const gotHandlers = [];
-		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
-			if (err) {
-				callback(makeWebpackError(err, "Cache.hooks.get"));
-				return;
-			}
-			if (result === null) {
-				result = undefined;
-			}
-			if (gotHandlers.length > 1) {
-				const innerCallback = needCalls(gotHandlers.length, () =>
-					callback(null, result)
-				);
-				for (const gotHandler of gotHandlers) {
-					gotHandler(result, innerCallback);
-				}
-			} else if (gotHandlers.length === 1) {
-				gotHandlers[0](result, () => callback(null, result));
-			} else {
-				callback(null, result);
-			}
-		});
+	getAssetPath(filename, data) {
+		return this.hooks.assetPath.call(
+			typeof filename === "function" ? filename(data) : filename,
+			data,
+			undefined
+		);
 	}
 
 	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
+	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {PathData} data context data
+	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
 	 */
-	store(identifier, etag, data, callback) {
-		this.hooks.store.callAsync(
-			identifier,
-			etag,
+	getAssetPathWithInfo(filename, data) {
+		const assetInfo = {};
+		// TODO webpack 5: refactor assetPath hook to receive { path, info } object
+		const newPath = this.hooks.assetPath.call(
+			typeof filename === "function" ? filename(data, assetInfo) : filename,
 			data,
-			makeWebpackErrorCallback(callback, "Cache.hooks.store")
+			assetInfo
 		);
+		return { path: newPath, info: assetInfo };
 	}
 
-	/**
-	 * After this method has succeeded the cache can only be restored when build dependencies are
-	 * @param {Iterable<string>} dependencies list of all build dependencies
-	 * @param {CallbackCache<void>} callback signals when the dependencies are stored
-	 * @returns {void}
-	 */
-	storeBuildDependencies(dependencies, callback) {
-		this.hooks.storeBuildDependencies.callAsync(
-			dependencies,
-			makeWebpackErrorCallback(callback, "Cache.hooks.storeBuildDependencies")
-		);
+	getWarnings() {
+		return this.hooks.processWarnings.call(this.warnings);
 	}
 
-	/**
-	 * @returns {void}
-	 */
-	beginIdle() {
-		this.hooks.beginIdle.call();
+	getErrors() {
+		return this.hooks.processErrors.call(this.errors);
 	}
 
 	/**
-	 * @param {CallbackCache<void>} callback signals when the call finishes
-	 * @returns {void}
+	 * This function allows you to run another instance of webpack inside of webpack however as
+	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
+	 * from parent (or top level compiler) and creates a child Compilation
+	 *
+	 * @param {string} name name of the child compiler
+	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
+	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
+	 * @returns {Compiler} creates a child Compiler instance
 	 */
-	endIdle(callback) {
-		this.hooks.endIdle.callAsync(
-			makeWebpackErrorCallback(callback, "Cache.hooks.endIdle")
+	createChildCompiler(name, outputOptions, plugins) {
+		const idx = this.childrenCounters[name] || 0;
+		this.childrenCounters[name] = idx + 1;
+		return this.compiler.createChildCompiler(
+			this,
+			name,
+			idx,
+			outputOptions,
+			plugins
 		);
 	}
 
 	/**
-	 * @param {CallbackCache<void>} callback signals when the call finishes
-	 * @returns {void}
+	 * @param {Module} module the module
+	 * @param {ExecuteModuleOptions} options options
+	 * @param {ExecuteModuleCallback} callback callback
 	 */
-	shutdown(callback) {
-		this.hooks.shutdown.callAsync(
-			makeWebpackErrorCallback(callback, "Cache.hooks.shutdown")
-		);
-	}
-}
-
-Cache.STAGE_MEMORY = -10;
-Cache.STAGE_DEFAULT = 0;
-Cache.STAGE_DISK = 10;
-Cache.STAGE_NETWORK = 20;
-
-module.exports = Cache;
-
-
-/***/ }),
-
-/***/ 55392:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	executeModule(module, options, callback) {
+		// Aggregate all referenced modules and ensure they are ready
+		const modules = new Set([module]);
+		processAsyncTree(
+			modules,
+			10,
+			/**
+			 * @param {Module} module the module
+			 * @param {function(Module): void} push push more jobs
+			 * @param {Callback} callback callback
+			 * @returns {void}
+			 */
+			(module, push, callback) => {
+				this.buildQueue.waitFor(module, err => {
+					if (err) return callback(err);
+					this.processDependenciesQueue.waitFor(module, err => {
+						if (err) return callback(err);
+						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
+							module
+						)) {
+							const size = modules.size;
+							modules.add(m);
+							if (modules.size !== size) push(m);
+						}
+						callback();
+					});
+				});
+			},
+			err => {
+				if (err) return callback(err);
 
+				// Create new chunk graph, chunk and entrypoint for the build time execution
+				const chunkGraph = new ChunkGraph(
+					this.moduleGraph,
+					this.outputOptions.hashFunction
+				);
+				const runtime = "build time";
+				const { hashFunction, hashDigest, hashDigestLength } =
+					this.outputOptions;
+				const runtimeTemplate = this.runtimeTemplate;
 
+				const chunk = new Chunk("build time chunk", this._backCompat);
+				chunk.id = chunk.name;
+				chunk.ids = [chunk.id];
+				chunk.runtime = runtime;
 
-const { forEachBail } = __webpack_require__(30662);
-const asyncLib = __webpack_require__(78175);
-const getLazyHashedEtag = __webpack_require__(94075);
-const mergeEtags = __webpack_require__(54980);
+				const entrypoint = new Entrypoint({
+					runtime,
+					chunkLoading: false,
+					...options.entryOptions
+				});
+				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+				connectChunkGroupAndChunk(entrypoint, chunk);
+				entrypoint.setRuntimeChunk(chunk);
+				entrypoint.setEntrypointChunk(chunk);
 
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
-/** @typedef {typeof import("./util/Hash")} HashConstructor */
+				const chunks = new Set([chunk]);
 
-/**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
+				// Assign ids to modules and modules to the chunk
+				for (const module of modules) {
+					const id = module.identifier();
+					chunkGraph.setModuleId(module, id);
+					chunkGraph.connectChunkAndModule(chunk, module);
+				}
 
-/**
- * @template T
- * @callback CallbackNormalErrorCache
- * @param {(Error | null)=} err
- * @param {T=} result
- * @returns {void}
- */
+				// Hash modules
+				for (const module of modules) {
+					this._createModuleHash(
+						module,
+						chunkGraph,
+						runtime,
+						hashFunction,
+						runtimeTemplate,
+						hashDigest,
+						hashDigestLength
+					);
+				}
 
-class MultiItemCache {
-	/**
-	 * @param {ItemCacheFacade[]} items item caches
-	 */
-	constructor(items) {
-		this._items = items;
-		if (items.length === 1) return /** @type {any} */ (items[0]);
-	}
+				const codeGenerationResults = new CodeGenerationResults(
+					this.outputOptions.hashFunction
+				);
+				/** @type {WebpackError[]} */
+				const errors = [];
+				/**
+				 * @param {Module} module the module
+				 * @param {Callback} callback callback
+				 * @returns {void}
+				 */
+				const codeGen = (module, callback) => {
+					this._codeGenerationModule(
+						module,
+						runtime,
+						[runtime],
+						chunkGraph.getModuleHash(module, runtime),
+						this.dependencyTemplates,
+						chunkGraph,
+						this.moduleGraph,
+						runtimeTemplate,
+						errors,
+						codeGenerationResults,
+						(err, codeGenerated) => {
+							callback(err);
+						}
+					);
+				};
 
-	/**
-	 * @template T
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(callback) {
-		forEachBail(this._items, (item, callback) => item.get(callback), callback);
-	}
+				const reportErrors = () => {
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
+						}
+						errors.length = 0;
+					}
+				};
 
-	/**
-	 * @template T
-	 * @returns {Promise<T>} promise with the data
-	 */
-	getPromise() {
-		const next = i => {
-			return this._items[i].getPromise().then(result => {
-				if (result !== undefined) return result;
-				if (++i < this._items.length) return next(i);
-			});
-		};
-		return next(0);
-	}
+				// Generate code for all aggregated modules
+				asyncLib.eachLimit(modules, 10, codeGen, err => {
+					if (err) return callback(err);
+					reportErrors();
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(data, callback) {
-		asyncLib.each(
-			this._items,
-			(item, callback) => item.store(data, callback),
-			callback
-		);
-	}
+					// for backward-compat temporary set the chunk graph
+					// TODO webpack 6
+					const old = this.chunkGraph;
+					this.chunkGraph = chunkGraph;
+					this.processRuntimeRequirements({
+						chunkGraph,
+						modules,
+						chunks,
+						codeGenerationResults,
+						chunkGraphEntries: chunks
+					});
+					this.chunkGraph = old;
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @returns {Promise<void>} promise signals when the value is stored
-	 */
-	storePromise(data) {
-		return Promise.all(this._items.map(item => item.storePromise(data))).then(
-			() => {}
-		);
-	}
-}
+					const runtimeModules =
+						chunkGraph.getChunkRuntimeModulesIterable(chunk);
 
-class ItemCacheFacade {
-	/**
-	 * @param {Cache} cache the root cache
-	 * @param {string} name the child cache item name
-	 * @param {Etag | null} etag the etag
-	 */
-	constructor(cache, name, etag) {
-		this._cache = cache;
-		this._name = name;
-		this._etag = etag;
-	}
+					// Hash runtime modules
+					for (const module of runtimeModules) {
+						modules.add(module);
+						this._createModuleHash(
+							module,
+							chunkGraph,
+							runtime,
+							hashFunction,
+							runtimeTemplate,
+							hashDigest,
+							hashDigestLength
+						);
+					}
 
-	/**
-	 * @template T
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(callback) {
-		this._cache.get(this._name, this._etag, callback);
-	}
+					// Generate code for all runtime modules
+					asyncLib.eachLimit(runtimeModules, 10, codeGen, err => {
+						if (err) return callback(err);
+						reportErrors();
 
-	/**
-	 * @template T
-	 * @returns {Promise<T>} promise with the data
-	 */
-	getPromise() {
-		return new Promise((resolve, reject) => {
-			this._cache.get(this._name, this._etag, (err, data) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(data);
-				}
-			});
-		});
-	}
+						/** @type {Map<Module, ExecuteModuleArgument>} */
+						const moduleArgumentsMap = new Map();
+						/** @type {Map<string, ExecuteModuleArgument>} */
+						const moduleArgumentsById = new Map();
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(data, callback) {
-		this._cache.store(this._name, this._etag, data, callback);
-	}
+						/** @type {ExecuteModuleResult["fileDependencies"]} */
+						const fileDependencies = new LazySet();
+						/** @type {ExecuteModuleResult["contextDependencies"]} */
+						const contextDependencies = new LazySet();
+						/** @type {ExecuteModuleResult["missingDependencies"]} */
+						const missingDependencies = new LazySet();
+						/** @type {ExecuteModuleResult["buildDependencies"]} */
+						const buildDependencies = new LazySet();
 
-	/**
-	 * @template T
-	 * @param {T} data the value to store
-	 * @returns {Promise<void>} promise signals when the value is stored
-	 */
-	storePromise(data) {
-		return new Promise((resolve, reject) => {
-			this._cache.store(this._name, this._etag, data, err => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
-				}
-			});
-		});
-	}
+						/** @type {ExecuteModuleResult["assets"]} */
+						const assets = new Map();
 
-	/**
-	 * @template T
-	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	provide(computer, callback) {
-		this.get((err, cacheEntry) => {
-			if (err) return callback(err);
-			if (cacheEntry !== undefined) return cacheEntry;
-			computer((err, result) => {
-				if (err) return callback(err);
-				this.store(result, err => {
-					if (err) return callback(err);
-					callback(null, result);
-				});
-			});
-		});
-	}
+						let cacheable = true;
 
-	/**
-	 * @template T
-	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-	 * @returns {Promise<T>} promise with the data
-	 */
-	async providePromise(computer) {
-		const cacheEntry = await this.getPromise();
-		if (cacheEntry !== undefined) return cacheEntry;
-		const result = await computer();
-		await this.storePromise(result);
-		return result;
-	}
-}
+						/** @type {ExecuteModuleContext} */
+						const context = {
+							assets,
+							__webpack_require__: undefined,
+							chunk,
+							chunkGraph
+						};
 
-class CacheFacade {
-	/**
-	 * @param {Cache} cache the root cache
-	 * @param {string} name the child cache name
-	 * @param {string | HashConstructor} hashFunction the hash function to use
-	 */
-	constructor(cache, name, hashFunction) {
-		this._cache = cache;
-		this._name = name;
-		this._hashFunction = hashFunction;
-	}
+						// Prepare execution
+						asyncLib.eachLimit(
+							modules,
+							10,
+							(module, callback) => {
+								const codeGenerationResult = codeGenerationResults.get(
+									module,
+									runtime
+								);
+								/** @type {ExecuteModuleArgument} */
+								const moduleArgument = {
+									module,
+									codeGenerationResult,
+									preparedInfo: undefined,
+									moduleObject: undefined
+								};
+								moduleArgumentsMap.set(module, moduleArgument);
+								moduleArgumentsById.set(module.identifier(), moduleArgument);
+								module.addCacheDependencies(
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								);
+								if (module.buildInfo.cacheable === false) {
+									cacheable = false;
+								}
+								if (module.buildInfo && module.buildInfo.assets) {
+									const { assets: moduleAssets, assetsInfo } = module.buildInfo;
+									for (const assetName of Object.keys(moduleAssets)) {
+										assets.set(assetName, {
+											source: moduleAssets[assetName],
+											info: assetsInfo ? assetsInfo.get(assetName) : undefined
+										});
+									}
+								}
+								this.hooks.prepareModuleExecution.callAsync(
+									moduleArgument,
+									context,
+									callback
+								);
+							},
+							err => {
+								if (err) return callback(err);
 
-	/**
-	 * @param {string} name the child cache name#
-	 * @returns {CacheFacade} child cache
-	 */
-	getChildCache(name) {
-		return new CacheFacade(
-			this._cache,
-			`${this._name}|${name}`,
-			this._hashFunction
-		);
-	}
+								let exports;
+								try {
+									const {
+										strictModuleErrorHandling,
+										strictModuleExceptionHandling
+									} = this.outputOptions;
+									const __nested_webpack_require_152290__ = id => {
+										const cached = moduleCache[id];
+										if (cached !== undefined) {
+											if (cached.error) throw cached.error;
+											return cached.exports;
+										}
+										const moduleArgument = moduleArgumentsById.get(id);
+										return __webpack_require_module__(moduleArgument, id);
+									};
+									const interceptModuleExecution = (__nested_webpack_require_152290__[
+										RuntimeGlobals.interceptModuleExecution.replace(
+											"__webpack_require__.",
+											""
+										)
+									] = []);
+									const moduleCache = (__nested_webpack_require_152290__[
+										RuntimeGlobals.moduleCache.replace(
+											"__webpack_require__.",
+											""
+										)
+									] = {});
 
-	/**
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @returns {ItemCacheFacade} item cache
-	 */
-	getItemCache(identifier, etag) {
-		return new ItemCacheFacade(
-			this._cache,
-			`${this._name}|${identifier}`,
-			etag
-		);
-	}
+									context.__webpack_require__ = __nested_webpack_require_152290__;
 
-	/**
-	 * @param {HashableObject} obj an hashable object
-	 * @returns {Etag} an etag that is lazy hashed
-	 */
-	getLazyHashedEtag(obj) {
-		return getLazyHashedEtag(obj, this._hashFunction);
-	}
+									/**
+									 * @param {ExecuteModuleArgument} moduleArgument the module argument
+									 * @param {string=} id id
+									 * @returns {any} exports
+									 */
+									const __webpack_require_module__ = (moduleArgument, id) => {
+										var execOptions = {
+											id,
+											module: {
+												id,
+												exports: {},
+												loaded: false,
+												error: undefined
+											},
+											require: __nested_webpack_require_152290__
+										};
+										interceptModuleExecution.forEach(handler =>
+											handler(execOptions)
+										);
+										const module = moduleArgument.module;
+										this.buildTimeExecutedModules.add(module);
+										const moduleObject = execOptions.module;
+										moduleArgument.moduleObject = moduleObject;
+										try {
+											if (id) moduleCache[id] = moduleObject;
 
-	/**
-	 * @param {Etag} a an etag
-	 * @param {Etag} b another etag
-	 * @returns {Etag} an etag that represents both
-	 */
-	mergeEtags(a, b) {
-		return mergeEtags(a, b);
-	}
+											tryRunOrWebpackError(
+												() =>
+													this.hooks.executeModule.call(
+														moduleArgument,
+														context
+													),
+												"Compilation.hooks.executeModule"
+											);
+											moduleObject.loaded = true;
+											return moduleObject.exports;
+										} catch (e) {
+											if (strictModuleExceptionHandling) {
+												if (id) delete moduleCache[id];
+											} else if (strictModuleErrorHandling) {
+												moduleObject.error = e;
+											}
+											if (!e.module) e.module = module;
+											throw e;
+										}
+									};
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {CallbackCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	get(identifier, etag, callback) {
-		this._cache.get(`${this._name}|${identifier}`, etag, callback);
-	}
+									for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
+										chunk
+									)) {
+										__webpack_require_module__(
+											moduleArgumentsMap.get(runtimeModule)
+										);
+									}
+									exports = __nested_webpack_require_152290__(module.identifier());
+								} catch (e) {
+									const err = new WebpackError(
+										`Execution of module code from module graph (${module.readableIdentifier(
+											this.requestShortener
+										)}) failed: ${e.message}`
+									);
+									err.stack = e.stack;
+									err.module = e.module;
+									return callback(err);
+								}
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @returns {Promise<T>} promise with the data
-	 */
-	getPromise(identifier, etag) {
-		return new Promise((resolve, reject) => {
-			this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve(data);
-				}
-			});
-		});
+								callback(null, {
+									exports,
+									assets,
+									cacheable,
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								});
+							}
+						);
+					});
+				});
+			}
+		);
 	}
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {T} data the value to store
-	 * @param {CallbackCache<void>} callback signals when the value is stored
-	 * @returns {void}
-	 */
-	store(identifier, etag, data, callback) {
-		this._cache.store(`${this._name}|${identifier}`, etag, data, callback);
-	}
+	checkConstraints() {
+		const chunkGraph = this.chunkGraph;
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {T} data the value to store
-	 * @returns {Promise<void>} promise signals when the value is stored
-	 */
-	storePromise(identifier, etag, data) {
-		return new Promise((resolve, reject) => {
-			this._cache.store(`${this._name}|${identifier}`, etag, data, err => {
-				if (err) {
-					reject(err);
-				} else {
-					resolve();
+		/** @type {Set<number|string>} */
+		const usedIds = new Set();
+
+		for (const module of this.modules) {
+			if (module.type === "runtime") continue;
+			const moduleId = chunkGraph.getModuleId(module);
+			if (moduleId === null) continue;
+			if (usedIds.has(moduleId)) {
+				throw new Error(`checkConstraints: duplicate module id ${moduleId}`);
+			}
+			usedIds.add(moduleId);
+		}
+
+		for (const chunk of this.chunks) {
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!this.modules.has(module)) {
+					throw new Error(
+						"checkConstraints: module in chunk but not in compilation " +
+							` ${chunk.debugId} ${module.debugId}`
+					);
 				}
-			});
-		});
+			}
+			for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+				if (!this.modules.has(module)) {
+					throw new Error(
+						"checkConstraints: entry module in chunk but not in compilation " +
+							` ${chunk.debugId} ${module.debugId}`
+					);
+				}
+			}
+		}
+
+		for (const chunkGroup of this.chunkGroups) {
+			chunkGroup.checkConstraints();
+		}
 	}
+}
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-	 * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-	 * @returns {void}
-	 */
-	provide(identifier, etag, computer, callback) {
-		this.get(identifier, etag, (err, cacheEntry) => {
-			if (err) return callback(err);
-			if (cacheEntry !== undefined) return cacheEntry;
-			computer((err, result) => {
-				if (err) return callback(err);
-				this.store(identifier, etag, result, err => {
-					if (err) return callback(err);
-					callback(null, result);
-				});
-			});
-		});
+/**
+ * @typedef {Object} FactorizeModuleOptions
+ * @property {ModuleProfile} currentProfile
+ * @property {ModuleFactory} factory
+ * @property {Dependency[]} dependencies
+ * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module
+ * @property {Module | null} originModule
+ * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+ * @property {string=} context
+ */
+
+/**
+ * @param {FactorizeModuleOptions} options options object
+ * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
+ * @returns {void}
+ */
+
+// Workaround for typescript as it doesn't support function overloading in jsdoc within a class
+Compilation.prototype.factorizeModule = /** @type {{
+	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
+	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
+}} */ (
+	function (options, callback) {
+		this.factorizeQueue.add(options, callback);
 	}
+);
 
-	/**
-	 * @template T
-	 * @param {string} identifier the cache identifier
-	 * @param {Etag | null} etag the etag
-	 * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-	 * @returns {Promise<T>} promise with the data
-	 */
-	async providePromise(identifier, etag, computer) {
-		const cacheEntry = await this.getPromise(identifier, etag);
-		if (cacheEntry !== undefined) return cacheEntry;
-		const result = await computer();
-		await this.storePromise(identifier, etag, result);
-		return result;
+// Hide from typescript
+const compilationPrototype = Compilation.prototype;
+
+// TODO webpack 6 remove
+Object.defineProperty(compilationPrototype, "modifyHash", {
+	writable: false,
+	enumerable: false,
+	configurable: false,
+	value: () => {
+		throw new Error(
+			"Compilation.modifyHash was removed in favor of Compilation.hooks.fullHash"
+		);
 	}
-}
+});
 
-module.exports = CacheFacade;
-module.exports.ItemCacheFacade = ItemCacheFacade;
-module.exports.MultiItemCache = MultiItemCache;
+// TODO webpack 6 remove
+Object.defineProperty(compilationPrototype, "cache", {
+	enumerable: false,
+	configurable: false,
+	get: util.deprecate(
+		/**
+		 * @this {Compilation} the compilation
+		 * @returns {Cache} the cache
+		 */
+		function () {
+			return this.compiler.cache;
+		},
+		"Compilation.cache was removed in favor of Compilation.getCache()",
+		"DEP_WEBPACK_COMPILATION_CACHE"
+	),
+	set: util.deprecate(
+		v => {},
+		"Compilation.cache was removed in favor of Compilation.getCache()",
+		"DEP_WEBPACK_COMPILATION_CACHE"
+	)
+});
 
+/**
+ * Add additional assets to the compilation.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000;
 
-/***/ }),
+/**
+ * Basic preprocessing of assets.
+ */
+Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1000;
 
-/***/ 77975:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * Derive new assets from existing assets.
+ * Existing assets should not be treated as complete.
+ */
+Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * Add additional sections to existing assets, like a banner or initialization code.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ADDITIONS = -100;
 
+/**
+ * Optimize existing assets in a general way.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100;
 
+/**
+ * Optimize the count of existing assets, e. g. by merging them.
+ * Only assets of the same type should be merged.
+ * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200;
 
-const WebpackError = __webpack_require__(53799);
+/**
+ * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300;
 
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/**
+ * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400;
 
 /**
- * @param {Module[]} modules the modules to be sorted
- * @returns {Module[]} sorted version of original modules
+ * Add development tooling to assets, e. g. by extracting a SourceMap.
  */
-const sortModules = modules => {
-	return modules.sort((a, b) => {
-		const aIdent = a.identifier();
-		const bIdent = b.identifier();
-		/* istanbul ignore next */
-		if (aIdent < bIdent) return -1;
-		/* istanbul ignore next */
-		if (aIdent > bIdent) return 1;
-		/* istanbul ignore next */
-		return 0;
-	});
-};
+Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500;
 
 /**
- * @param {Module[]} modules each module from throw
- * @param {ModuleGraph} moduleGraph the module graph
- * @returns {string} each message from provided modules
+ * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
+ * Only assets of different types should be inlined.
+ * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
  */
-const createModulesListMessage = (modules, moduleGraph) => {
-	return modules
-		.map(m => {
-			let message = `* ${m.identifier()}`;
-			const validReasons = Array.from(
-				moduleGraph.getIncomingConnectionsByOriginModule(m).keys()
-			).filter(x => x);
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700;
 
-			if (validReasons.length > 0) {
-				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
-				message += `\n    ${validReasons[0].identifier()}`;
-			}
-			return message;
-		})
-		.join("\n");
-};
+/**
+ * Summarize the list of existing assets
+ * e. g. creating an assets manifest of Service Workers.
+ */
+Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
 
-class CaseSensitiveModulesWarning extends WebpackError {
-	/**
-	 * Creates an instance of CaseSensitiveModulesWarning.
-	 * @param {Iterable<Module>} modules modules that were detected
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 */
-	constructor(modules, moduleGraph) {
-		const sortedModules = sortModules(Array.from(modules));
-		const modulesList = createModulesListMessage(sortedModules, moduleGraph);
-		super(`There are multiple modules with names that only differ in casing.
-This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.
-Use equal casing. Compare these module identifiers:
-${modulesList}`);
+/**
+ * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
 
-		this.name = "CaseSensitiveModulesWarning";
-		this.module = sortedModules[0];
-	}
-}
+/**
+ * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
 
-module.exports = CaseSensitiveModulesWarning;
+/**
+ * Analyse existing assets.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
+
+/**
+ * Creating assets for reporting purposes.
+ */
+Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
+
+module.exports = Compilation;
 
 
 /***/ }),
 
-/***/ 39385:
+/***/ 70845:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -25371,2560 +27576,2079 @@ module.exports = CaseSensitiveModulesWarning;
 
 
 
-const ChunkGraph = __webpack_require__(64971);
-const Entrypoint = __webpack_require__(13795);
-const { intersect } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-const StringXor = __webpack_require__(40293);
+const parseJson = __webpack_require__(15235);
+const asyncLib = __webpack_require__(78175);
 const {
-	compareModulesByIdentifier,
-	compareChunkGroupsByIndex,
-	compareModulesById
-} = __webpack_require__(29579);
-const { createArrayToSetDeprecationSet } = __webpack_require__(64518);
-const { mergeRuntime } = __webpack_require__(17156);
+	SyncHook,
+	SyncBailHook,
+	AsyncParallelHook,
+	AsyncSeriesHook
+} = __webpack_require__(6967);
+const { SizeOnlySource } = __webpack_require__(51255);
+const webpack = __webpack_require__(91919);
+const Cache = __webpack_require__(7592);
+const CacheFacade = __webpack_require__(55392);
+const ChunkGraph = __webpack_require__(64971);
+const Compilation = __webpack_require__(85720);
+const ConcurrentCompilationError = __webpack_require__(95735);
+const ContextModuleFactory = __webpack_require__(62471);
+const ModuleGraph = __webpack_require__(99988);
+const NormalModuleFactory = __webpack_require__(68860);
+const RequestShortener = __webpack_require__(73406);
+const ResolverFactory = __webpack_require__(30217);
+const Stats = __webpack_require__(31743);
+const Watching = __webpack_require__(84275);
+const WebpackError = __webpack_require__(53799);
+const { Logger } = __webpack_require__(32597);
+const { join, dirname, mkdirp } = __webpack_require__(17139);
+const { makePathsRelative } = __webpack_require__(82186);
+const { isSourceEqual } = __webpack_require__(41245);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
-/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
-/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 /** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
-const ChunkFilesSet = createArrayToSetDeprecationSet("chunk.files");
+/**
+ * @typedef {Object} CompilationParams
+ * @property {NormalModuleFactory} normalModuleFactory
+ * @property {ContextModuleFactory} contextModuleFactory
+ */
 
 /**
- * @typedef {Object} WithId an object who has an id property *
- * @property {string | number} id the id of the object
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
  */
 
 /**
- * @deprecated
- * @typedef {Object} ChunkMaps
- * @property {Record<string|number, string>} hash
- * @property {Record<string|number, Record<string, string>>} contentHash
- * @property {Record<string|number, string>} name
+ * @callback RunAsChildCallback
+ * @param {(Error | null)=} err
+ * @param {Chunk[]=} entries
+ * @param {Compilation=} compilation
  */
 
 /**
- * @deprecated
- * @typedef {Object} ChunkModuleMaps
- * @property {Record<string|number, (string|number)[]>} id
- * @property {Record<string|number, string>} hash
+ * @typedef {Object} AssetEmittedInfo
+ * @property {Buffer} content
+ * @property {Source} source
+ * @property {Compilation} compilation
+ * @property {string} outputPath
+ * @property {string} targetPath
  */
 
-let debugId = 1000;
+/**
+ * @param {string[]} array an array
+ * @returns {boolean} true, if the array is sorted
+ */
+const isSorted = array => {
+	for (let i = 1; i < array.length; i++) {
+		if (array[i - 1] > array[i]) return false;
+	}
+	return true;
+};
 
 /**
- * A Chunk is a unit of encapsulation for Modules.
- * Chunks are "rendered" into bundles that get emitted when the build completes.
+ * @param {Object} obj an object
+ * @param {string[]} keys the keys of the object
+ * @returns {Object} the object with properties sorted by property name
  */
-class Chunk {
-	/**
-	 * @param {string=} name of chunk being created, is optional (for subclasses)
-	 * @param {boolean} backCompat enable backward-compatibility
-	 */
-	constructor(name, backCompat = true) {
-		/** @type {number | string | null} */
-		this.id = null;
-		/** @type {(number|string)[] | null} */
-		this.ids = null;
-		/** @type {number} */
-		this.debugId = debugId++;
-		/** @type {string} */
-		this.name = name;
-		/** @type {SortableSet<string>} */
-		this.idNameHints = new SortableSet();
-		/** @type {boolean} */
-		this.preventIntegration = false;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
-		this.filenameTemplate = undefined;
-		/** @type {(string | function(PathData, AssetInfo=): string)?} */
-		this.cssFilenameTemplate = undefined;
-		/** @private @type {SortableSet<ChunkGroup>} */
-		this._groups = new SortableSet(undefined, compareChunkGroupsByIndex);
-		/** @type {RuntimeSpec} */
-		this.runtime = undefined;
-		/** @type {Set<string>} */
-		this.files = backCompat ? new ChunkFilesSet() : new Set();
-		/** @type {Set<string>} */
-		this.auxiliaryFiles = new Set();
-		/** @type {boolean} */
-		this.rendered = false;
-		/** @type {string=} */
-		this.hash = undefined;
-		/** @type {Record<string, string>} */
-		this.contentHash = Object.create(null);
-		/** @type {string=} */
-		this.renderedHash = undefined;
-		/** @type {string=} */
-		this.chunkReason = undefined;
-		/** @type {boolean} */
-		this.extraAsync = false;
+const sortObject = (obj, keys) => {
+	const o = {};
+	for (const k of keys.sort()) {
+		o[k] = obj[k];
 	}
+	return o;
+};
 
-	// TODO remove in webpack 6
-	// BACKWARD-COMPAT START
-	get entryModule() {
-		const entryModules = Array.from(
-			ChunkGraph.getChunkGraphForChunk(
-				this,
-				"Chunk.entryModule",
-				"DEP_WEBPACK_CHUNK_ENTRY_MODULE"
-			).getChunkEntryModulesIterable(this)
-		);
-		if (entryModules.length === 0) {
-			return undefined;
-		} else if (entryModules.length === 1) {
-			return entryModules[0];
-		} else {
-			throw new Error(
-				"Module.entryModule: Multiple entry modules are not supported by the deprecated API (Use the new ChunkGroup API)"
-			);
-		}
+/**
+ * @param {string} filename filename
+ * @param {string | string[] | undefined} hashes list of hashes
+ * @returns {boolean} true, if the filename contains any hash
+ */
+const includesHash = (filename, hashes) => {
+	if (!hashes) return false;
+	if (Array.isArray(hashes)) {
+		return hashes.some(hash => filename.includes(hash));
+	} else {
+		return filename.includes(hashes);
 	}
+};
 
+class Compiler {
 	/**
-	 * @returns {boolean} true, if the chunk contains an entry module
+	 * @param {string} context the compilation path
+	 * @param {WebpackOptions} options options
 	 */
-	hasEntryModule() {
-		return (
-			ChunkGraph.getChunkGraphForChunk(
-				this,
-				"Chunk.hasEntryModule",
-				"DEP_WEBPACK_CHUNK_HAS_ENTRY_MODULE"
-			).getNumberOfEntryModules(this) > 0
-		);
-	}
+	constructor(context, options = /** @type {WebpackOptions} */ ({})) {
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[]>} */
+			initialize: new SyncHook([]),
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the chunk could be added
-	 */
-	addModule(module) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.addModule",
-			"DEP_WEBPACK_CHUNK_ADD_MODULE"
-		);
-		if (chunkGraph.isModuleInChunk(module, this)) return false;
-		chunkGraph.connectChunkAndModule(this, module);
-		return true;
-	}
+			/** @type {SyncBailHook<[Compilation], boolean>} */
+			shouldEmit: new SyncBailHook(["compilation"]),
+			/** @type {AsyncSeriesHook<[Stats]>} */
+			done: new AsyncSeriesHook(["stats"]),
+			/** @type {SyncHook<[Stats]>} */
+			afterDone: new SyncHook(["stats"]),
+			/** @type {AsyncSeriesHook<[]>} */
+			additionalPass: new AsyncSeriesHook([]),
+			/** @type {AsyncSeriesHook<[Compiler]>} */
+			beforeRun: new AsyncSeriesHook(["compiler"]),
+			/** @type {AsyncSeriesHook<[Compiler]>} */
+			run: new AsyncSeriesHook(["compiler"]),
+			/** @type {AsyncSeriesHook<[Compilation]>} */
+			emit: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<[string, AssetEmittedInfo]>} */
+			assetEmitted: new AsyncSeriesHook(["file", "info"]),
+			/** @type {AsyncSeriesHook<[Compilation]>} */
+			afterEmit: new AsyncSeriesHook(["compilation"]),
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	removeModule(module) {
-		ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.removeModule",
-			"DEP_WEBPACK_CHUNK_REMOVE_MODULE"
-		).disconnectChunkAndModule(this, module);
-	}
+			/** @type {SyncHook<[Compilation, CompilationParams]>} */
+			thisCompilation: new SyncHook(["compilation", "params"]),
+			/** @type {SyncHook<[Compilation, CompilationParams]>} */
+			compilation: new SyncHook(["compilation", "params"]),
+			/** @type {SyncHook<[NormalModuleFactory]>} */
+			normalModuleFactory: new SyncHook(["normalModuleFactory"]),
+			/** @type {SyncHook<[ContextModuleFactory]>}  */
+			contextModuleFactory: new SyncHook(["contextModuleFactory"]),
 
-	/**
-	 * @returns {number} the number of module which are contained in this chunk
-	 */
-	getNumberOfModules() {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getNumberOfModules",
-			"DEP_WEBPACK_CHUNK_GET_NUMBER_OF_MODULES"
-		).getNumberOfChunkModules(this);
-	}
+			/** @type {AsyncSeriesHook<[CompilationParams]>} */
+			beforeCompile: new AsyncSeriesHook(["params"]),
+			/** @type {SyncHook<[CompilationParams]>} */
+			compile: new SyncHook(["params"]),
+			/** @type {AsyncParallelHook<[Compilation]>} */
+			make: new AsyncParallelHook(["compilation"]),
+			/** @type {AsyncParallelHook<[Compilation]>} */
+			finishMake: new AsyncSeriesHook(["compilation"]),
+			/** @type {AsyncSeriesHook<[Compilation]>} */
+			afterCompile: new AsyncSeriesHook(["compilation"]),
 
-	get modulesIterable() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.modulesIterable",
-			"DEP_WEBPACK_CHUNK_MODULES_ITERABLE"
-		);
-		return chunkGraph.getOrderedChunkModulesIterable(
-			this,
-			compareModulesByIdentifier
-		);
-	}
+			/** @type {AsyncSeriesHook<[]>} */
+			readRecords: new AsyncSeriesHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			emitRecords: new AsyncSeriesHook([]),
 
-	/**
-	 * @param {Chunk} otherChunk the chunk to compare with
-	 * @returns {-1|0|1} the comparison result
-	 */
-	compareTo(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.compareTo",
-			"DEP_WEBPACK_CHUNK_COMPARE_TO"
-		);
-		return chunkGraph.compareChunks(this, otherChunk);
-	}
+			/** @type {AsyncSeriesHook<[Compiler]>} */
+			watchRun: new AsyncSeriesHook(["compiler"]),
+			/** @type {SyncHook<[Error]>} */
+			failed: new SyncHook(["error"]),
+			/** @type {SyncHook<[string | null, number]>} */
+			invalid: new SyncHook(["filename", "changeTime"]),
+			/** @type {SyncHook<[]>} */
+			watchClose: new SyncHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			shutdown: new AsyncSeriesHook([]),
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the chunk contains the module
-	 */
-	containsModule(module) {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.containsModule",
-			"DEP_WEBPACK_CHUNK_CONTAINS_MODULE"
-		).isModuleInChunk(module, this);
-	}
+			/** @type {SyncBailHook<[string, string, any[]], true>} */
+			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
 
-	/**
-	 * @returns {Module[]} the modules for this chunk
-	 */
-	getModules() {
-		return ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getModules",
-			"DEP_WEBPACK_CHUNK_GET_MODULES"
-		).getChunkModules(this);
-	}
+			// TODO the following hooks are weirdly located here
+			// TODO move them for webpack 5
+			/** @type {SyncHook<[]>} */
+			environment: new SyncHook([]),
+			/** @type {SyncHook<[]>} */
+			afterEnvironment: new SyncHook([]),
+			/** @type {SyncHook<[Compiler]>} */
+			afterPlugins: new SyncHook(["compiler"]),
+			/** @type {SyncHook<[Compiler]>} */
+			afterResolvers: new SyncHook(["compiler"]),
+			/** @type {SyncBailHook<[string, Entry], boolean>} */
+			entryOption: new SyncBailHook(["context", "entry"])
+		});
 
-	/**
-	 * @returns {void}
-	 */
-	remove() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.remove",
-			"DEP_WEBPACK_CHUNK_REMOVE"
-		);
-		chunkGraph.disconnectChunk(this);
-		this.disconnectFromGroups();
-	}
+		this.webpack = webpack;
 
-	/**
-	 * @param {Module} module the module
-	 * @param {Chunk} otherChunk the target chunk
-	 * @returns {void}
-	 */
-	moveModule(module, otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.moveModule",
-			"DEP_WEBPACK_CHUNK_MOVE_MODULE"
-		);
-		chunkGraph.disconnectChunkAndModule(this, module);
-		chunkGraph.connectChunkAndModule(otherChunk, module);
-	}
+		/** @type {string=} */
+		this.name = undefined;
+		/** @type {Compilation=} */
+		this.parentCompilation = undefined;
+		/** @type {Compiler} */
+		this.root = this;
+		/** @type {string} */
+		this.outputPath = "";
+		/** @type {Watching} */
+		this.watching = undefined;
 
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @returns {boolean} true, if the specified chunk has been integrated
-	 */
-	integrate(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.integrate",
-			"DEP_WEBPACK_CHUNK_INTEGRATE"
-		);
-		if (chunkGraph.canChunksBeIntegrated(this, otherChunk)) {
-			chunkGraph.integrateChunks(this, otherChunk);
-			return true;
-		} else {
-			return false;
-		}
-	}
+		/** @type {OutputFileSystem} */
+		this.outputFileSystem = null;
+		/** @type {IntermediateFileSystem} */
+		this.intermediateFileSystem = null;
+		/** @type {InputFileSystem} */
+		this.inputFileSystem = null;
+		/** @type {WatchFileSystem} */
+		this.watchFileSystem = null;
 
-	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @returns {boolean} true, if chunks could be integrated
-	 */
-	canBeIntegrated(otherChunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.canBeIntegrated",
-			"DEP_WEBPACK_CHUNK_CAN_BE_INTEGRATED"
-		);
-		return chunkGraph.canChunksBeIntegrated(this, otherChunk);
-	}
+		/** @type {string|null} */
+		this.recordsInputPath = null;
+		/** @type {string|null} */
+		this.recordsOutputPath = null;
+		this.records = {};
+		/** @type {Set<string | RegExp>} */
+		this.managedPaths = new Set();
+		/** @type {Set<string | RegExp>} */
+		this.immutablePaths = new Set();
 
-	/**
-	 * @returns {boolean} true, if this chunk contains no module
-	 */
-	isEmpty() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.isEmpty",
-			"DEP_WEBPACK_CHUNK_IS_EMPTY"
-		);
-		return chunkGraph.getNumberOfChunkModules(this) === 0;
-	}
+		/** @type {ReadonlySet<string>} */
+		this.modifiedFiles = undefined;
+		/** @type {ReadonlySet<string>} */
+		this.removedFiles = undefined;
+		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		this.fileTimestamps = undefined;
+		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		this.contextTimestamps = undefined;
+		/** @type {number} */
+		this.fsStartTime = undefined;
 
-	/**
-	 * @returns {number} total size of all modules in this chunk
-	 */
-	modulesSize() {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.modulesSize",
-			"DEP_WEBPACK_CHUNK_MODULES_SIZE"
-		);
-		return chunkGraph.getChunkModulesSize(this);
-	}
+		/** @type {ResolverFactory} */
+		this.resolverFactory = new ResolverFactory();
 
-	/**
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of this chunk
-	 */
-	size(options = {}) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.size",
-			"DEP_WEBPACK_CHUNK_SIZE"
-		);
-		return chunkGraph.getChunkSize(this, options);
+		this.infrastructureLogger = undefined;
+
+		this.options = options;
+
+		this.context = context;
+
+		this.requestShortener = new RequestShortener(context, this.root);
+
+		this.cache = new Cache();
+
+		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
+		this.moduleMemCaches = undefined;
+
+		this.compilerPath = "";
+
+		/** @type {boolean} */
+		this.running = false;
+
+		/** @type {boolean} */
+		this.idle = false;
+
+		/** @type {boolean} */
+		this.watchMode = false;
+
+		this._backCompat = this.options.experiments.backCompat !== false;
+
+		/** @type {Compilation} */
+		this._lastCompilation = undefined;
+		/** @type {NormalModuleFactory} */
+		this._lastNormalModuleFactory = undefined;
+
+		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
+		this._assetEmittingSourceCache = new WeakMap();
+		/** @private @type {Map<string, number>} */
+		this._assetEmittingWrittenFiles = new Map();
+		/** @private @type {Set<string>} */
+		this._assetEmittingPreviousFiles = new Set();
 	}
 
 	/**
-	 * @param {Chunk} otherChunk the other chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk or false if the chunk can't be integrated
+	 * @param {string} name cache name
+	 * @returns {CacheFacade} the cache facade instance
 	 */
-	integratedSize(otherChunk, options) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.integratedSize",
-			"DEP_WEBPACK_CHUNK_INTEGRATED_SIZE"
+	getCache(name) {
+		return new CacheFacade(
+			this.cache,
+			`${this.compilerPath}${name}`,
+			this.options.output.hashFunction
 		);
-		return chunkGraph.getIntegratedChunksSize(this, otherChunk, options);
 	}
 
 	/**
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @returns {ChunkModuleMaps} module map information
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
 	 */
-	getChunkModuleMaps(filterFn) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.getChunkModuleMaps",
-			"DEP_WEBPACK_CHUNK_GET_CHUNK_MODULE_MAPS"
-		);
-		/** @type {Record<string|number, (string|number)[]>} */
-		const chunkModuleIdMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
-		const chunkModuleHashMap = Object.create(null);
-
-		for (const asyncChunk of this.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
-			let array;
-			for (const module of chunkGraph.getOrderedChunkModulesIterable(
-				asyncChunk,
-				compareModulesById(chunkGraph)
-			)) {
-				if (filterFn(module)) {
-					if (array === undefined) {
-						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
+	getInfrastructureLogger(name) {
+		if (!name) {
+			throw new TypeError(
+				"Compiler.getInfrastructureLogger(name) called without a name"
+			);
+		}
+		return new Logger(
+			(type, args) => {
+				if (typeof name === "function") {
+					name = name();
+					if (!name) {
+						throw new TypeError(
+							"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+						);
+					}
+				}
+				if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
+					if (this.infrastructureLogger !== undefined) {
+						this.infrastructureLogger(name, type, args);
+					}
+				}
+			},
+			childName => {
+				if (typeof name === "function") {
+					if (typeof childName === "function") {
+						return this.getInfrastructureLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
+						});
+					} else {
+						return this.getInfrastructureLogger(() => {
+							if (typeof name === "function") {
+								name = name();
+								if (!name) {
+									throw new TypeError(
+										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
+						});
+					}
+				} else {
+					if (typeof childName === "function") {
+						return this.getInfrastructureLogger(() => {
+							if (typeof childName === "function") {
+								childName = childName();
+								if (!childName) {
+									throw new TypeError(
+										"Logger.getChildLogger(name) called with a function not returning a name"
+									);
+								}
+							}
+							return `${name}/${childName}`;
+						});
+					} else {
+						return this.getInfrastructureLogger(`${name}/${childName}`);
 					}
-					const moduleId = chunkGraph.getModuleId(module);
-					array.push(moduleId);
-					chunkModuleHashMap[moduleId] = chunkGraph.getRenderedModuleHash(
-						module,
-						undefined
-					);
 				}
 			}
+		);
+	}
+
+	// TODO webpack 6: solve this in a better way
+	// e.g. move compilation specific info from Modules into ModuleGraph
+	_cleanupLastCompilation() {
+		if (this._lastCompilation !== undefined) {
+			for (const module of this._lastCompilation.modules) {
+				ChunkGraph.clearChunkGraphForModule(module);
+				ModuleGraph.clearModuleGraphForModule(module);
+				module.cleanupForCache();
+			}
+			for (const chunk of this._lastCompilation.chunks) {
+				ChunkGraph.clearChunkGraphForChunk(chunk);
+			}
+			this._lastCompilation = undefined;
 		}
+	}
 
-		return {
-			id: chunkModuleIdMap,
-			hash: chunkModuleHashMap
-		};
+	// TODO webpack 6: solve this in a better way
+	_cleanupLastNormalModuleFactory() {
+		if (this._lastNormalModuleFactory !== undefined) {
+			this._lastNormalModuleFactory.cleanupForCache();
+			this._lastNormalModuleFactory = undefined;
+		}
 	}
 
 	/**
-	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
-	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
-	 * @returns {boolean} return true if module exists in graph
+	 * @param {WatchOptions} watchOptions the watcher's options
+	 * @param {Callback<Stats>} handler signals when the call finishes
+	 * @returns {Watching} a compiler watcher
 	 */
-	hasModuleInGraph(filterFn, filterChunkFn) {
-		const chunkGraph = ChunkGraph.getChunkGraphForChunk(
-			this,
-			"Chunk.hasModuleInGraph",
-			"DEP_WEBPACK_CHUNK_HAS_MODULE_IN_GRAPH"
-		);
-		return chunkGraph.hasModuleInGraph(this, filterFn, filterChunkFn);
+	watch(watchOptions, handler) {
+		if (this.running) {
+			return handler(new ConcurrentCompilationError());
+		}
+
+		this.running = true;
+		this.watchMode = true;
+		this.watching = new Watching(this, watchOptions, handler);
+		return this.watching;
 	}
 
 	/**
-	 * @deprecated
-	 * @param {boolean} realHash whether the full hash or the rendered hash is to be used
-	 * @returns {ChunkMaps} the chunk map information
+	 * @param {Callback<Stats>} callback signals when the call finishes
+	 * @returns {void}
 	 */
-	getChunkMaps(realHash) {
-		/** @type {Record<string|number, string>} */
-		const chunkHashMap = Object.create(null);
-		/** @type {Record<string|number, Record<string, string>>} */
-		const chunkContentHashMap = Object.create(null);
-		/** @type {Record<string|number, string>} */
-		const chunkNameMap = Object.create(null);
-
-		for (const chunk of this.getAllAsyncChunks()) {
-			chunkHashMap[chunk.id] = realHash ? chunk.hash : chunk.renderedHash;
-			for (const key of Object.keys(chunk.contentHash)) {
-				if (!chunkContentHashMap[key]) {
-					chunkContentHashMap[key] = Object.create(null);
-				}
-				chunkContentHashMap[key][chunk.id] = chunk.contentHash[key];
-			}
-			if (chunk.name) {
-				chunkNameMap[chunk.id] = chunk.name;
-			}
+	run(callback) {
+		if (this.running) {
+			return callback(new ConcurrentCompilationError());
 		}
 
-		return {
-			hash: chunkHashMap,
-			contentHash: chunkContentHashMap,
-			name: chunkNameMap
-		};
-	}
-	// BACKWARD-COMPAT END
+		let logger;
 
-	/**
-	 * @returns {boolean} whether or not the Chunk will have a runtime
-	 */
-	hasRuntime() {
-		for (const chunkGroup of this._groups) {
-			if (
-				chunkGroup instanceof Entrypoint &&
-				chunkGroup.getRuntimeChunk() === this
-			) {
-				return true;
+		const finalCallback = (err, stats) => {
+			if (logger) logger.time("beginIdle");
+			this.idle = true;
+			this.cache.beginIdle();
+			this.idle = true;
+			if (logger) logger.timeEnd("beginIdle");
+			this.running = false;
+			if (err) {
+				this.hooks.failed.call(err);
 			}
-		}
-		return false;
-	}
-
-	/**
-	 * @returns {boolean} whether or not this chunk can be an initial chunk
-	 */
-	canBeInitial() {
-		for (const chunkGroup of this._groups) {
-			if (chunkGroup.isInitial()) return true;
-		}
-		return false;
-	}
-
-	/**
-	 * @returns {boolean} whether this chunk can only be an initial chunk
-	 */
-	isOnlyInitial() {
-		if (this._groups.size <= 0) return false;
-		for (const chunkGroup of this._groups) {
-			if (!chunkGroup.isInitial()) return false;
-		}
-		return true;
-	}
+			if (callback !== undefined) callback(err, stats);
+			this.hooks.afterDone.call(stats);
+		};
 
-	/**
-	 * @returns {EntryOptions | undefined} the entry options for this chunk
-	 */
-	getEntryOptions() {
-		for (const chunkGroup of this._groups) {
-			if (chunkGroup instanceof Entrypoint) {
-				return chunkGroup.options;
-			}
-		}
-		return undefined;
-	}
+		const startTime = Date.now();
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being added
-	 * @returns {void}
-	 */
-	addGroup(chunkGroup) {
-		this._groups.add(chunkGroup);
-	}
+		this.running = true;
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup the chunk is being removed from
-	 * @returns {void}
-	 */
-	removeGroup(chunkGroup) {
-		this._groups.delete(chunkGroup);
-	}
+		const onCompiled = (err, compilation) => {
+			if (err) return finalCallback(err);
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunkGroup to check
-	 * @returns {boolean} returns true if chunk has chunkGroup reference and exists in chunkGroup
-	 */
-	isInGroup(chunkGroup) {
-		return this._groups.has(chunkGroup);
-	}
+			if (this.hooks.shouldEmit.call(compilation) === false) {
+				compilation.startTime = startTime;
+				compilation.endTime = Date.now();
+				const stats = new Stats(compilation);
+				this.hooks.done.callAsync(stats, err => {
+					if (err) return finalCallback(err);
+					return finalCallback(null, stats);
+				});
+				return;
+			}
 
-	/**
-	 * @returns {number} the amount of groups that the said chunk is in
-	 */
-	getNumberOfGroups() {
-		return this._groups.size;
-	}
+			process.nextTick(() => {
+				logger = compilation.getLogger("webpack.Compiler");
+				logger.time("emitAssets");
+				this.emitAssets(compilation, err => {
+					logger.timeEnd("emitAssets");
+					if (err) return finalCallback(err);
 
-	/**
-	 * @returns {Iterable<ChunkGroup>} the chunkGroups that the said chunk is referenced in
-	 */
-	get groupsIterable() {
-		this._groups.sort();
-		return this._groups;
-	}
+					if (compilation.hooks.needAdditionalPass.call()) {
+						compilation.needAdditionalPass = true;
 
-	/**
-	 * @returns {void}
-	 */
-	disconnectFromGroups() {
-		for (const chunkGroup of this._groups) {
-			chunkGroup.removeChunk(this);
-		}
-	}
+						compilation.startTime = startTime;
+						compilation.endTime = Date.now();
+						logger.time("done hook");
+						const stats = new Stats(compilation);
+						this.hooks.done.callAsync(stats, err => {
+							logger.timeEnd("done hook");
+							if (err) return finalCallback(err);
 
-	/**
-	 * @param {Chunk} newChunk the new chunk that will be split out of
-	 * @returns {void}
-	 */
-	split(newChunk) {
-		for (const chunkGroup of this._groups) {
-			chunkGroup.insertChunk(newChunk, this);
-			newChunk.addGroup(chunkGroup);
-		}
-		for (const idHint of this.idNameHints) {
-			newChunk.idNameHints.add(idHint);
-		}
-		newChunk.runtime = mergeRuntime(newChunk.runtime, this.runtime);
-	}
+							this.hooks.additionalPass.callAsync(err => {
+								if (err) return finalCallback(err);
+								this.compile(onCompiled);
+							});
+						});
+						return;
+					}
 
-	/**
-	 * @param {Hash} hash hash (will be modified)
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	updateHash(hash, chunkGraph) {
-		hash.update(
-			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
-		);
-		const xor = new StringXor();
-		for (const m of chunkGraph.getChunkModulesIterable(this)) {
-			xor.add(chunkGraph.getModuleHash(m, this.runtime));
-		}
-		xor.updateHash(hash);
-		const entryModules =
-			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
-		for (const [m, chunkGroup] of entryModules) {
-			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
-		}
-	}
+					logger.time("emitRecords");
+					this.emitRecords(err => {
+						logger.timeEnd("emitRecords");
+						if (err) return finalCallback(err);
 
-	/**
-	 * @returns {Set<Chunk>} a set of all the async chunks
-	 */
-	getAllAsyncChunks() {
-		const queue = new Set();
-		const chunks = new Set();
+						compilation.startTime = startTime;
+						compilation.endTime = Date.now();
+						logger.time("done hook");
+						const stats = new Stats(compilation);
+						this.hooks.done.callAsync(stats, err => {
+							logger.timeEnd("done hook");
+							if (err) return finalCallback(err);
+							this.cache.storeBuildDependencies(
+								compilation.buildDependencies,
+								err => {
+									if (err) return finalCallback(err);
+									return finalCallback(null, stats);
+								}
+							);
+						});
+					});
+				});
+			});
+		};
 
-		const initialChunks = intersect(
-			Array.from(this.groupsIterable, g => new Set(g.chunks))
-		);
+		const run = () => {
+			this.hooks.beforeRun.callAsync(this, err => {
+				if (err) return finalCallback(err);
 
-		const initialQueue = new Set(this.groupsIterable);
+				this.hooks.run.callAsync(this, err => {
+					if (err) return finalCallback(err);
 
-		for (const chunkGroup of initialQueue) {
-			for (const child of chunkGroup.childrenIterable) {
-				if (child instanceof Entrypoint) {
-					initialQueue.add(child);
-				} else {
-					queue.add(child);
-				}
-			}
-		}
+					this.readRecords(err => {
+						if (err) return finalCallback(err);
 
-		for (const chunkGroup of queue) {
-			for (const chunk of chunkGroup.chunks) {
-				if (!initialChunks.has(chunk)) {
-					chunks.add(chunk);
-				}
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+						this.compile(onCompiled);
+					});
+				});
+			});
+		};
 
-		return chunks;
-	}
+		if (this.idle) {
+			this.cache.endIdle(err => {
+				if (err) return finalCallback(err);
 
-	/**
-	 * @returns {Set<Chunk>} a set of all the initial chunks (including itself)
-	 */
-	getAllInitialChunks() {
-		const chunks = new Set();
-		const queue = new Set(this.groupsIterable);
-		for (const group of queue) {
-			if (group.isInitial()) {
-				for (const c of group.chunks) chunks.add(c);
-				for (const g of group.childrenIterable) queue.add(g);
-			}
+				this.idle = false;
+				run();
+			});
+		} else {
+			run();
 		}
-		return chunks;
 	}
 
 	/**
-	 * @returns {Set<Chunk>} a set of all the referenced chunks (including itself)
+	 * @param {RunAsChildCallback} callback signals when the call finishes
+	 * @returns {void}
 	 */
-	getAllReferencedChunks() {
-		const queue = new Set(this.groupsIterable);
-		const chunks = new Set();
+	runAsChild(callback) {
+		const startTime = Date.now();
+		this.compile((err, compilation) => {
+			if (err) return callback(err);
 
-		for (const chunkGroup of queue) {
-			for (const chunk of chunkGroup.chunks) {
-				chunks.add(chunk);
+			this.parentCompilation.children.push(compilation);
+			for (const { name, source, info } of compilation.getAssets()) {
+				this.parentCompilation.emitAsset(name, source, info);
 			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
+
+			const entries = [];
+			for (const ep of compilation.entrypoints.values()) {
+				entries.push(...ep.chunks);
 			}
-		}
 
-		return chunks;
-	}
+			compilation.startTime = startTime;
+			compilation.endTime = Date.now();
 
-	/**
-	 * @returns {Set<Entrypoint>} a set of all the referenced entrypoints
-	 */
-	getAllReferencedAsyncEntrypoints() {
-		const queue = new Set(this.groupsIterable);
-		const entrypoints = new Set();
+			return callback(null, entries, compilation);
+		});
+	}
 
-		for (const chunkGroup of queue) {
-			for (const entrypoint of chunkGroup.asyncEntrypointsIterable) {
-				entrypoints.add(entrypoint);
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
+	purgeInputFileSystem() {
+		if (this.inputFileSystem && this.inputFileSystem.purge) {
+			this.inputFileSystem.purge();
 		}
-
-		return entrypoints;
 	}
 
 	/**
-	 * @returns {boolean} true, if the chunk references async chunks
+	 * @param {Compilation} compilation the compilation
+	 * @param {Callback<void>} callback signals when the assets are emitted
+	 * @returns {void}
 	 */
-	hasAsyncChunks() {
-		const queue = new Set();
+	emitAssets(compilation, callback) {
+		let outputPath;
 
-		const initialChunks = intersect(
-			Array.from(this.groupsIterable, g => new Set(g.chunks))
-		);
+		const emitFiles = err => {
+			if (err) return callback(err);
 
-		for (const chunkGroup of this.groupsIterable) {
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+			const assets = compilation.getAssets();
+			compilation.assets = { ...compilation.assets };
+			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
+			const caseInsensitiveMap = new Map();
+			/** @type {Set<string>} */
+			const allTargetPaths = new Set();
+			asyncLib.forEachLimit(
+				assets,
+				15,
+				({ name: file, source, info }, callback) => {
+					let targetFile = file;
+					let immutable = info.immutable;
+					const queryStringIdx = targetFile.indexOf("?");
+					if (queryStringIdx >= 0) {
+						targetFile = targetFile.substr(0, queryStringIdx);
+						// We may remove the hash, which is in the query string
+						// So we recheck if the file is immutable
+						// This doesn't cover all cases, but immutable is only a performance optimization anyway
+						immutable =
+							immutable &&
+							(includesHash(targetFile, info.contenthash) ||
+								includesHash(targetFile, info.chunkhash) ||
+								includesHash(targetFile, info.modulehash) ||
+								includesHash(targetFile, info.fullhash));
+					}
 
-		for (const chunkGroup of queue) {
-			for (const chunk of chunkGroup.chunks) {
-				if (!initialChunks.has(chunk)) {
-					return true;
-				}
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
+					const writeOut = err => {
+						if (err) return callback(err);
+						const targetPath = join(
+							this.outputFileSystem,
+							outputPath,
+							targetFile
+						);
+						allTargetPaths.add(targetPath);
 
-		return false;
-	}
+						// check if the target file has already been written by this Compiler
+						const targetFileGeneration =
+							this._assetEmittingWrittenFiles.get(targetPath);
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string, (string | number)[]>} a record object of names to lists of child ids(?)
-	 */
-	getChildIdsByOrders(chunkGraph, filterFn) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
-		const lists = new Map();
-		for (const group of this.groupsIterable) {
-			if (group.chunks[group.chunks.length - 1] === this) {
-				for (const childGroup of group.childrenIterable) {
-					for (const key of Object.keys(childGroup.options)) {
-						if (key.endsWith("Order")) {
-							const name = key.substr(0, key.length - "Order".length);
-							let list = lists.get(name);
-							if (list === undefined) {
-								list = [];
-								lists.set(name, list);
-							}
-							list.push({
-								order: childGroup.options[key],
-								group: childGroup
-							});
+						// create an cache entry for this Source if not already existing
+						let cacheEntry = this._assetEmittingSourceCache.get(source);
+						if (cacheEntry === undefined) {
+							cacheEntry = {
+								sizeOnlySource: undefined,
+								writtenTo: new Map()
+							};
+							this._assetEmittingSourceCache.set(source, cacheEntry);
 						}
-					}
-				}
-			}
-		}
-		/** @type {Record<string, (string | number)[]>} */
-		const result = Object.create(null);
-		for (const [name, list] of lists) {
-			list.sort((a, b) => {
-				const cmp = b.order - a.order;
-				if (cmp !== 0) return cmp;
-				return a.group.compareTo(chunkGraph, b.group);
-			});
-			/** @type {Set<string | number>} */
-			const chunkIdSet = new Set();
-			for (const item of list) {
-				for (const chunk of item.group.chunks) {
-					if (filterFn && !filterFn(chunk, chunkGraph)) continue;
-					chunkIdSet.add(chunk.id);
-				}
-			}
-			if (chunkIdSet.size > 0) {
-				result[name] = Array.from(chunkIdSet);
-			}
-		}
-		return result;
-	}
-
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {string} type option name
-	 * @returns {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} referenced chunks for a specific type
-	 */
-	getChildrenOfTypeInOrder(chunkGraph, type) {
-		const list = [];
-		for (const group of this.groupsIterable) {
-			for (const childGroup of group.childrenIterable) {
-				const order = childGroup.options[type];
-				if (order === undefined) continue;
-				list.push({
-					order,
-					group,
-					childGroup
-				});
-			}
-		}
-		if (list.length === 0) return undefined;
-		list.sort((a, b) => {
-			const cmp = b.order - a.order;
-			if (cmp !== 0) return cmp;
-			return a.group.compareTo(chunkGraph, b.group);
-		});
-		const result = [];
-		let lastEntry;
-		for (const { group, childGroup } of list) {
-			if (lastEntry && lastEntry.onChunks === group.chunks) {
-				for (const chunk of childGroup.chunks) {
-					lastEntry.chunks.add(chunk);
-				}
-			} else {
-				result.push(
-					(lastEntry = {
-						onChunks: group.chunks,
-						chunks: new Set(childGroup.chunks)
-					})
-				);
-			}
-		}
-		return result;
-	}
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {boolean=} includeDirectChildren include direct children (by default only children of async children are included)
-	 * @param {ChunkFilterPredicate=} filterFn function used to filter chunks
-	 * @returns {Record<string|number, Record<string, (string | number)[]>>} a record object of names to lists of child ids(?) by chunk id
-	 */
-	getChildIdsByOrdersMap(chunkGraph, includeDirectChildren, filterFn) {
-		/** @type {Record<string|number, Record<string, (string | number)[]>>} */
-		const chunkMaps = Object.create(null);
+						let similarEntry;
 
-		/**
-		 * @param {Chunk} chunk a chunk
-		 * @returns {void}
-		 */
-		const addChildIdsByOrdersToMap = chunk => {
-			const data = chunk.getChildIdsByOrders(chunkGraph, filterFn);
-			for (const key of Object.keys(data)) {
-				let chunkMap = chunkMaps[key];
-				if (chunkMap === undefined) {
-					chunkMaps[key] = chunkMap = Object.create(null);
-				}
-				chunkMap[chunk.id] = data[key];
-			}
-		};
+						const checkSimilarFile = () => {
+							const caseInsensitiveTargetPath = targetPath.toLowerCase();
+							similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath);
+							if (similarEntry !== undefined) {
+								const { path: other, source: otherSource } = similarEntry;
+								if (isSourceEqual(otherSource, source)) {
+									// Size may or may not be available at this point.
+									// If it's not available add to "waiting" list and it will be updated once available
+									if (similarEntry.size !== undefined) {
+										updateWithReplacementSource(similarEntry.size);
+									} else {
+										if (!similarEntry.waiting) similarEntry.waiting = [];
+										similarEntry.waiting.push({ file, cacheEntry });
+									}
+									alreadyWritten();
+								} else {
+									const err =
+										new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file.
+This will lead to a race-condition and corrupted files on case-insensitive file systems.
+${targetPath}
+${other}`);
+									err.file = file;
+									callback(err);
+								}
+								return true;
+							} else {
+								caseInsensitiveMap.set(
+									caseInsensitiveTargetPath,
+									(similarEntry = {
+										path: targetPath,
+										source,
+										size: undefined,
+										waiting: undefined
+									})
+								);
+								return false;
+							}
+						};
 
-		if (includeDirectChildren) {
-			/** @type {Set<Chunk>} */
-			const chunks = new Set();
-			for (const chunkGroup of this.groupsIterable) {
-				for (const chunk of chunkGroup.chunks) {
-					chunks.add(chunk);
-				}
-			}
-			for (const chunk of chunks) {
-				addChildIdsByOrdersToMap(chunk);
-			}
-		}
+						/**
+						 * get the binary (Buffer) content from the Source
+						 * @returns {Buffer} content for the source
+						 */
+						const getContent = () => {
+							if (typeof source.buffer === "function") {
+								return source.buffer();
+							} else {
+								const bufferOrString = source.source();
+								if (Buffer.isBuffer(bufferOrString)) {
+									return bufferOrString;
+								} else {
+									return Buffer.from(bufferOrString, "utf8");
+								}
+							}
+						};
 
-		for (const chunk of this.getAllAsyncChunks()) {
-			addChildIdsByOrdersToMap(chunk);
-		}
+						const alreadyWritten = () => {
+							// cache the information that the Source has been already been written to that location
+							if (targetFileGeneration === undefined) {
+								const newGeneration = 1;
+								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
+								cacheEntry.writtenTo.set(targetPath, newGeneration);
+							} else {
+								cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
+							}
+							callback();
+						};
 
-		return chunkMaps;
-	}
-}
+						/**
+						 * Write the file to output file system
+						 * @param {Buffer} content content to be written
+						 * @returns {void}
+						 */
+						const doWrite = content => {
+							this.outputFileSystem.writeFile(targetPath, content, err => {
+								if (err) return callback(err);
 
-module.exports = Chunk;
+								// information marker that the asset has been emitted
+								compilation.emittedAssets.add(file);
 
+								// cache the information that the Source has been written to that location
+								const newGeneration =
+									targetFileGeneration === undefined
+										? 1
+										: targetFileGeneration + 1;
+								cacheEntry.writtenTo.set(targetPath, newGeneration);
+								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
+								this.hooks.assetEmitted.callAsync(
+									file,
+									{
+										content,
+										source,
+										outputPath,
+										compilation,
+										targetPath
+									},
+									callback
+								);
+							});
+						};
 
-/***/ }),
+						const updateWithReplacementSource = size => {
+							updateFileWithReplacementSource(file, cacheEntry, size);
+							similarEntry.size = size;
+							if (similarEntry.waiting !== undefined) {
+								for (const { file, cacheEntry } of similarEntry.waiting) {
+									updateFileWithReplacementSource(file, cacheEntry, size);
+								}
+							}
+						};
 
-/***/ 64971:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+						const updateFileWithReplacementSource = (
+							file,
+							cacheEntry,
+							size
+						) => {
+							// Create a replacement resource which only allows to ask for size
+							// This allows to GC all memory allocated by the Source
+							// (expect when the Source is stored in any other cache)
+							if (!cacheEntry.sizeOnlySource) {
+								cacheEntry.sizeOnlySource = new SizeOnlySource(size);
+							}
+							compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+								size
+							});
+						};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+						const processExistingFile = stats => {
+							// skip emitting if it's already there and an immutable file
+							if (immutable) {
+								updateWithReplacementSource(stats.size);
+								return alreadyWritten();
+							}
 
+							const content = getContent();
 
+							updateWithReplacementSource(content.length);
 
-const util = __webpack_require__(73837);
-const Entrypoint = __webpack_require__(13795);
-const ModuleGraphConnection = __webpack_require__(40639);
-const { first } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-const {
-	compareModulesById,
-	compareIterables,
-	compareModulesByIdentifier,
-	concatComparators,
-	compareSelect,
-	compareIds
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const findGraphRoots = __webpack_require__(6261);
-const {
-	RuntimeSpecMap,
-	RuntimeSpecSet,
-	runtimeToString,
-	mergeRuntime,
-	forEachRuntime
-} = __webpack_require__(17156);
+							// if it exists and content on disk matches content
+							// skip writing the same content again
+							// (to keep mtime and don't trigger watchers)
+							// for a fast negative match file size is compared first
+							if (content.length === stats.size) {
+								compilation.comparedForEmitAssets.add(file);
+								return this.outputFileSystem.readFile(
+									targetPath,
+									(err, existingContent) => {
+										if (
+											err ||
+											!content.equals(/** @type {Buffer} */ (existingContent))
+										) {
+											return doWrite(content);
+										} else {
+											return alreadyWritten();
+										}
+									}
+								);
+							}
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {typeof import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+							return doWrite(content);
+						};
 
-/** @type {ReadonlySet<string>} */
-const EMPTY_SET = new Set();
+						const processMissingFile = () => {
+							const content = getContent();
 
-const ZERO_BIG_INT = BigInt(0);
+							updateWithReplacementSource(content.length);
 
-const compareModuleIterables = compareIterables(compareModulesByIdentifier);
+							return doWrite(content);
+						};
 
-/** @typedef {(c: Chunk, chunkGraph: ChunkGraph) => boolean} ChunkFilterPredicate */
-/** @typedef {(m: Module) => boolean} ModuleFilterPredicate */
+						// if the target file has already been written
+						if (targetFileGeneration !== undefined) {
+							// check if the Source has been written to this target file
+							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
+							if (writtenGeneration === targetFileGeneration) {
+								// if yes, we may skip writing the file
+								// if it's already there
+								// (we assume one doesn't modify files while the Compiler is running, other then removing them)
 
-/**
- * @typedef {Object} ChunkSizeOptions
- * @property {number=} chunkOverhead constant overhead for a chunk
- * @property {number=} entryChunkMultiplicator multiplicator for initial chunks
- */
+								if (this._assetEmittingPreviousFiles.has(targetPath)) {
+									// We assume that assets from the last compilation say intact on disk (they are not removed)
+									compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
+										size: cacheEntry.sizeOnlySource.size()
+									});
 
-class ModuleHashInfo {
-	constructor(hash, renderedHash) {
-		this.hash = hash;
-		this.renderedHash = renderedHash;
-	}
-}
+									return callback();
+								} else {
+									// Settings immutable will make it accept file content without comparing when file exist
+									immutable = true;
+								}
+							} else if (!immutable) {
+								if (checkSimilarFile()) return;
+								// We wrote to this file before which has very likely a different content
+								// skip comparing and assume content is different for performance
+								// This case happens often during watch mode.
+								return processMissingFile();
+							}
+						}
 
-/** @template T @typedef {(set: SortableSet<T>) => T[]} SetToArrayFunction<T> */
+						if (checkSimilarFile()) return;
+						if (this.options.output.compareBeforeEmit) {
+							this.outputFileSystem.stat(targetPath, (err, stats) => {
+								const exists = !err && stats.isFile();
 
-/**
- * @template T
- * @param {SortableSet<T>} set the set
- * @returns {T[]} set as array
- */
-const getArray = set => {
-	return Array.from(set);
-};
+								if (exists) {
+									processExistingFile(stats);
+								} else {
+									processMissingFile();
+								}
+							});
+						} else {
+							processMissingFile();
+						}
+					};
 
-/**
- * @param {SortableSet<Chunk>} chunks the chunks
- * @returns {RuntimeSpecSet} runtimes
- */
-const getModuleRuntimes = chunks => {
-	const runtimes = new RuntimeSpecSet();
-	for (const chunk of chunks) {
-		runtimes.add(chunk.runtime);
+					if (targetFile.match(/\/|\\/)) {
+						const fs = this.outputFileSystem;
+						const dir = dirname(fs, join(fs, outputPath, targetFile));
+						mkdirp(fs, dir, writeOut);
+					} else {
+						writeOut();
+					}
+				},
+				err => {
+					// Clear map to free up memory
+					caseInsensitiveMap.clear();
+					if (err) {
+						this._assetEmittingPreviousFiles.clear();
+						return callback(err);
+					}
+
+					this._assetEmittingPreviousFiles = allTargetPaths;
+
+					this.hooks.afterEmit.callAsync(compilation, err => {
+						if (err) return callback(err);
+
+						return callback();
+					});
+				}
+			);
+		};
+
+		this.hooks.emit.callAsync(compilation, err => {
+			if (err) return callback(err);
+			outputPath = compilation.getPath(this.outputPath, {});
+			mkdirp(this.outputFileSystem, outputPath, emitFiles);
+		});
 	}
-	return runtimes;
-};
 
-/**
- * @param {SortableSet<Module>} set the set
- * @returns {Map<string, SortableSet<Module>>} modules by source type
- */
-const modulesBySourceType = set => {
-	/** @type {Map<string, SortableSet<Module>>} */
-	const map = new Map();
-	for (const module of set) {
-		for (const sourceType of module.getSourceTypes()) {
-			let innerSet = map.get(sourceType);
-			if (innerSet === undefined) {
-				innerSet = new SortableSet();
-				map.set(sourceType, innerSet);
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	emitRecords(callback) {
+		if (this.hooks.emitRecords.isUsed()) {
+			if (this.recordsOutputPath) {
+				asyncLib.parallel(
+					[
+						cb => this.hooks.emitRecords.callAsync(cb),
+						this._emitRecords.bind(this)
+					],
+					err => callback(err)
+				);
+			} else {
+				this.hooks.emitRecords.callAsync(callback);
+			}
+		} else {
+			if (this.recordsOutputPath) {
+				this._emitRecords(callback);
+			} else {
+				callback();
 			}
-			innerSet.add(module);
-		}
-	}
-	for (const [key, innerSet] of map) {
-		// When all modules have the source type, we reuse the original SortableSet
-		// to benefit from the shared cache (especially for sorting)
-		if (innerSet.size === set.size) {
-			map.set(key, set);
 		}
 	}
-	return map;
-};
-
-/** @type {WeakMap<Function, any>} */
-const createOrderedArrayFunctionMap = new WeakMap();
 
-/**
- * @template T
- * @param {function(T, T): -1|0|1} comparator comparator function
- * @returns {SetToArrayFunction<T>} set as ordered array
- */
-const createOrderedArrayFunction = comparator => {
-	/** @type {SetToArrayFunction<T>} */
-	let fn = createOrderedArrayFunctionMap.get(comparator);
-	if (fn !== undefined) return fn;
-	fn = set => {
-		set.sortWith(comparator);
-		return Array.from(set);
-	};
-	createOrderedArrayFunctionMap.set(comparator, fn);
-	return fn;
-};
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_emitRecords(callback) {
+		const writeFile = () => {
+			this.outputFileSystem.writeFile(
+				this.recordsOutputPath,
+				JSON.stringify(
+					this.records,
+					(n, value) => {
+						if (
+							typeof value === "object" &&
+							value !== null &&
+							!Array.isArray(value)
+						) {
+							const keys = Object.keys(value);
+							if (!isSorted(keys)) {
+								return sortObject(value, keys);
+							}
+						}
+						return value;
+					},
+					2
+				),
+				callback
+			);
+		};
 
-/**
- * @param {Iterable<Module>} modules the modules to get the count/size of
- * @returns {number} the size of the modules
- */
-const getModulesSize = modules => {
-	let size = 0;
-	for (const module of modules) {
-		for (const type of module.getSourceTypes()) {
-			size += module.size(type);
+		const recordsOutputPathDirectory = dirname(
+			this.outputFileSystem,
+			this.recordsOutputPath
+		);
+		if (!recordsOutputPathDirectory) {
+			return writeFile();
 		}
+		mkdirp(this.outputFileSystem, recordsOutputPathDirectory, err => {
+			if (err) return callback(err);
+			writeFile();
+		});
 	}
-	return size;
-};
 
-/**
- * @param {Iterable<Module>} modules the sortable Set to get the size of
- * @returns {Record<string, number>} the sizes of the modules
- */
-const getModulesSizes = modules => {
-	let sizes = Object.create(null);
-	for (const module of modules) {
-		for (const type of module.getSourceTypes()) {
-			sizes[type] = (sizes[type] || 0) + module.size(type);
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	readRecords(callback) {
+		if (this.hooks.readRecords.isUsed()) {
+			if (this.recordsInputPath) {
+				asyncLib.parallel([
+					cb => this.hooks.readRecords.callAsync(cb),
+					this._readRecords.bind(this)
+				]);
+			} else {
+				this.records = {};
+				this.hooks.readRecords.callAsync(callback);
+			}
+		} else {
+			if (this.recordsInputPath) {
+				this._readRecords(callback);
+			} else {
+				this.records = {};
+				callback();
+			}
 		}
 	}
-	return sizes;
-};
 
-/**
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {boolean} true, if a is always a parent of b
- */
-const isAvailableChunk = (a, b) => {
-	const queue = new Set(b.groupsIterable);
-	for (const chunkGroup of queue) {
-		if (a.isInGroup(chunkGroup)) continue;
-		if (chunkGroup.isInitial()) return false;
-		for (const parent of chunkGroup.parentsIterable) {
-			queue.add(parent);
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_readRecords(callback) {
+		if (!this.recordsInputPath) {
+			this.records = {};
+			return callback();
 		}
-	}
-	return true;
-};
+		this.inputFileSystem.stat(this.recordsInputPath, err => {
+			// It doesn't exist
+			// We can ignore this.
+			if (err) return callback();
 
-class ChunkGraphModule {
-	constructor() {
-		/** @type {SortableSet<Chunk>} */
-		this.chunks = new SortableSet();
-		/** @type {Set<Chunk> | undefined} */
-		this.entryInChunks = undefined;
-		/** @type {Set<Chunk> | undefined} */
-		this.runtimeInChunks = undefined;
-		/** @type {RuntimeSpecMap<ModuleHashInfo>} */
-		this.hashes = undefined;
-		/** @type {string | number} */
-		this.id = null;
-		/** @type {RuntimeSpecMap<Set<string>> | undefined} */
-		this.runtimeRequirements = undefined;
-		/** @type {RuntimeSpecMap<string>} */
-		this.graphHashes = undefined;
-		/** @type {RuntimeSpecMap<string>} */
-		this.graphHashesWithConnections = undefined;
-	}
-}
+			this.inputFileSystem.readFile(this.recordsInputPath, (err, content) => {
+				if (err) return callback(err);
 
-class ChunkGraphChunk {
-	constructor() {
-		/** @type {SortableSet<Module>} */
-		this.modules = new SortableSet();
-		/** @type {Map<Module, Entrypoint>} */
-		this.entryModules = new Map();
-		/** @type {SortableSet<RuntimeModule>} */
-		this.runtimeModules = new SortableSet();
-		/** @type {Set<RuntimeModule> | undefined} */
-		this.fullHashModules = undefined;
-		/** @type {Set<RuntimeModule> | undefined} */
-		this.dependentHashModules = undefined;
-		/** @type {Set<string> | undefined} */
-		this.runtimeRequirements = undefined;
-		/** @type {Set<string>} */
-		this.runtimeRequirementsInTree = new Set();
+				try {
+					this.records = parseJson(content.toString("utf-8"));
+				} catch (e) {
+					e.message = "Cannot parse records: " + e.message;
+					return callback(e);
+				}
+
+				return callback();
+			});
+		});
 	}
-}
 
-class ChunkGraph {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string | Hash} hashFunction the hash function to use
+	 * @param {Compilation} compilation the compilation
+	 * @param {string} compilerName the compiler's name
+	 * @param {number} compilerIndex the compiler's index
+	 * @param {OutputOptions=} outputOptions the output options
+	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
+	 * @returns {Compiler} a child compiler
 	 */
-	constructor(moduleGraph, hashFunction = "md4") {
-		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
-		this._modules = new WeakMap();
-		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
-		this._chunks = new WeakMap();
-		/** @private @type {WeakMap<AsyncDependenciesBlock, ChunkGroup>} */
-		this._blockChunkGroups = new WeakMap();
-		/** @private @type {Map<string, string | number>} */
-		this._runtimeIds = new Map();
-		/** @type {ModuleGraph} */
-		this.moduleGraph = moduleGraph;
+	createChildCompiler(
+		compilation,
+		compilerName,
+		compilerIndex,
+		outputOptions,
+		plugins
+	) {
+		const childCompiler = new Compiler(this.context, {
+			...this.options,
+			output: {
+				...this.options.output,
+				...outputOptions
+			}
+		});
+		childCompiler.name = compilerName;
+		childCompiler.outputPath = this.outputPath;
+		childCompiler.inputFileSystem = this.inputFileSystem;
+		childCompiler.outputFileSystem = null;
+		childCompiler.resolverFactory = this.resolverFactory;
+		childCompiler.modifiedFiles = this.modifiedFiles;
+		childCompiler.removedFiles = this.removedFiles;
+		childCompiler.fileTimestamps = this.fileTimestamps;
+		childCompiler.contextTimestamps = this.contextTimestamps;
+		childCompiler.fsStartTime = this.fsStartTime;
+		childCompiler.cache = this.cache;
+		childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
+		childCompiler._backCompat = this._backCompat;
 
-		this._hashFunction = hashFunction;
+		const relativeCompilerName = makePathsRelative(
+			this.context,
+			compilerName,
+			this.root
+		);
+		if (!this.records[relativeCompilerName]) {
+			this.records[relativeCompilerName] = [];
+		}
+		if (this.records[relativeCompilerName][compilerIndex]) {
+			childCompiler.records = this.records[relativeCompilerName][compilerIndex];
+		} else {
+			this.records[relativeCompilerName].push((childCompiler.records = {}));
+		}
 
-		this._getGraphRoots = this._getGraphRoots.bind(this);
+		childCompiler.parentCompilation = compilation;
+		childCompiler.root = this.root;
+		if (Array.isArray(plugins)) {
+			for (const plugin of plugins) {
+				plugin.apply(childCompiler);
+			}
+		}
+		for (const name in this.hooks) {
+			if (
+				![
+					"make",
+					"compile",
+					"emit",
+					"afterEmit",
+					"invalid",
+					"done",
+					"thisCompilation"
+				].includes(name)
+			) {
+				if (childCompiler.hooks[name]) {
+					childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
+				}
+			}
+		}
+
+		compilation.hooks.childCompiler.call(
+			childCompiler,
+			compilerName,
+			compilerIndex
+		);
+
+		return childCompiler;
 	}
 
-	/**
-	 * @private
-	 * @param {Module} module the module
-	 * @returns {ChunkGraphModule} internal module
-	 */
-	_getChunkGraphModule(module) {
-		let cgm = this._modules.get(module);
-		if (cgm === undefined) {
-			cgm = new ChunkGraphModule();
-			this._modules.set(module, cgm);
-		}
-		return cgm;
+	isChild() {
+		return !!this.parentCompilation;
 	}
 
-	/**
-	 * @private
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ChunkGraphChunk} internal chunk
-	 */
-	_getChunkGraphChunk(chunk) {
-		let cgc = this._chunks.get(chunk);
-		if (cgc === undefined) {
-			cgc = new ChunkGraphChunk();
-			this._chunks.set(chunk, cgc);
-		}
-		return cgc;
+	createCompilation(params) {
+		this._cleanupLastCompilation();
+		return (this._lastCompilation = new Compilation(this, params));
 	}
 
 	/**
-	 * @param {SortableSet<Module>} set the sortable Set to get the roots of
-	 * @returns {Module[]} the graph roots
+	 * @param {CompilationParams} params the compilation parameters
+	 * @returns {Compilation} the created compilation
 	 */
-	_getGraphRoots(set) {
-		const { moduleGraph } = this;
-		return Array.from(
-			findGraphRoots(set, module => {
-				/** @type {Set<Module>} */
-				const set = new Set();
-				const addDependencies = module => {
-					for (const connection of moduleGraph.getOutgoingConnections(module)) {
-						if (!connection.module) continue;
-						const activeState = connection.getActiveState(undefined);
-						if (activeState === false) continue;
-						if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-							addDependencies(connection.module);
-							continue;
-						}
-						set.add(connection.module);
-					}
-				};
-				addDependencies(module);
-				return set;
-			})
-		).sort(compareModulesByIdentifier);
+	newCompilation(params) {
+		const compilation = this.createCompilation(params);
+		compilation.name = this.name;
+		compilation.records = this.records;
+		this.hooks.thisCompilation.call(compilation, params);
+		this.hooks.compilation.call(compilation, params);
+		return compilation;
 	}
 
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	connectChunkAndModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.chunks.add(chunk);
-		cgc.modules.add(module);
+	createNormalModuleFactory() {
+		this._cleanupLastNormalModuleFactory();
+		const normalModuleFactory = new NormalModuleFactory({
+			context: this.options.context,
+			fs: this.inputFileSystem,
+			resolverFactory: this.resolverFactory,
+			options: this.options.module,
+			associatedObjectForCache: this.root,
+			layers: this.options.experiments.layers
+		});
+		this._lastNormalModuleFactory = normalModuleFactory;
+		this.hooks.normalModuleFactory.call(normalModuleFactory);
+		return normalModuleFactory;
 	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	disconnectChunkAndModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgc.modules.delete(module);
-		cgm.chunks.delete(chunk);
+	createContextModuleFactory() {
+		const contextModuleFactory = new ContextModuleFactory(this.resolverFactory);
+		this.hooks.contextModuleFactory.call(contextModuleFactory);
+		return contextModuleFactory;
+	}
+
+	newCompilationParams() {
+		const params = {
+			normalModuleFactory: this.createNormalModuleFactory(),
+			contextModuleFactory: this.createContextModuleFactory()
+		};
+		return params;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk which will be disconnected
+	 * @param {Callback<Compilation>} callback signals when the compilation finishes
 	 * @returns {void}
 	 */
-	disconnectChunk(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of cgc.modules) {
-			const cgm = this._getChunkGraphModule(module);
-			cgm.chunks.delete(chunk);
-		}
-		cgc.modules.clear();
-		chunk.disconnectFromGroups();
-		ChunkGraph.clearChunkGraphForChunk(chunk);
+	compile(callback) {
+		const params = this.newCompilationParams();
+		this.hooks.beforeCompile.callAsync(params, err => {
+			if (err) return callback(err);
+
+			this.hooks.compile.call(params);
+
+			const compilation = this.newCompilation(params);
+
+			const logger = compilation.getLogger("webpack.Compiler");
+
+			logger.time("make hook");
+			this.hooks.make.callAsync(compilation, err => {
+				logger.timeEnd("make hook");
+				if (err) return callback(err);
+
+				logger.time("finish make hook");
+				this.hooks.finishMake.callAsync(compilation, err => {
+					logger.timeEnd("finish make hook");
+					if (err) return callback(err);
+
+					process.nextTick(() => {
+						logger.time("finish compilation");
+						compilation.finish(err => {
+							logger.timeEnd("finish compilation");
+							if (err) return callback(err);
+
+							logger.time("seal compilation");
+							compilation.seal(err => {
+								logger.timeEnd("seal compilation");
+								if (err) return callback(err);
+
+								logger.time("afterCompile hook");
+								this.hooks.afterCompile.callAsync(compilation, err => {
+									logger.timeEnd("afterCompile hook");
+									if (err) return callback(err);
+
+									return callback(null, compilation);
+								});
+							});
+						});
+					});
+				});
+			});
+		});
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<Module>} modules the modules
+	 * @param {Callback<void>} callback signals when the compiler closes
 	 * @returns {void}
 	 */
-	attachModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of modules) {
-			cgc.modules.add(module);
+	close(callback) {
+		if (this.watching) {
+			// When there is still an active watching, close this first
+			this.watching.close(err => {
+				this.close(callback);
+			});
+			return;
 		}
+		this.hooks.shutdown.callAsync(err => {
+			if (err) return callback(err);
+			// Get rid of reference to last compilation to avoid leaking memory
+			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
+			// might be still in use. We try to get rid of the reference to the cache instead.
+			this._lastCompilation = undefined;
+			this._lastNormalModuleFactory = undefined;
+			this.cache.shutdown(callback);
+		});
 	}
+}
+
+module.exports = Compiler;
+
+
+/***/ }),
+
+/***/ 98229:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./Module")} Module */
+
+const MODULE_REFERENCE_REGEXP =
+	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(?:_asiSafe(\d))?__$/;
+
+const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
+const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
+
+/**
+ * @typedef {Object} ExternalModuleInfo
+ * @property {number} index
+ * @property {Module} module
+ */
+
+/**
+ * @typedef {Object} ConcatenatedModuleInfo
+ * @property {number} index
+ * @property {Module} module
+ * @property {Map<string, string>} exportMap mapping from export name to symbol
+ * @property {Map<string, string>} rawExportMap mapping from export name to symbol
+ * @property {string=} namespaceExportSymbol
+ */
+
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo} ModuleInfo */
+
+/**
+ * @typedef {Object} ModuleReferenceOptions
+ * @property {string[]} ids the properties/exports of the module
+ * @property {boolean} call true, when this referenced export is called
+ * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
+ * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
+ */
 
+class ConcatenationScope {
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<RuntimeModule>} modules the runtime modules
-	 * @returns {void}
+	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
+	 * @param {ConcatenatedModuleInfo} currentModule the current module info
 	 */
-	attachRuntimeModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of modules) {
-			cgc.runtimeModules.add(module);
+	constructor(modulesMap, currentModule) {
+		this._currentModule = currentModule;
+		if (Array.isArray(modulesMap)) {
+			const map = new Map();
+			for (const info of modulesMap) {
+				map.set(info.module, info);
+			}
+			modulesMap = map;
 		}
+		this._modulesMap = modulesMap;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
-	 * @returns {void}
+	 * @param {Module} module the referenced module
+	 * @returns {boolean} true, when it's in the scope
 	 */
-	attachFullHashModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
-		for (const module of modules) {
-			cgc.fullHashModules.add(module);
-		}
+	isModuleInScope(module) {
+		return this._modulesMap.has(module);
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<RuntimeModule>} modules the modules that require a full hash
-	 * @returns {void}
+	 *
+	 * @param {string} exportName name of the export
+	 * @param {string} symbol identifier of the export in source code
 	 */
-	attachDependentHashModules(chunk, modules) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined)
-			cgc.dependentHashModules = new Set();
-		for (const module of modules) {
-			cgc.dependentHashModules.add(module);
+	registerExport(exportName, symbol) {
+		if (!this._currentModule.exportMap) {
+			this._currentModule.exportMap = new Map();
+		}
+		if (!this._currentModule.exportMap.has(exportName)) {
+			this._currentModule.exportMap.set(exportName, symbol);
 		}
 	}
 
 	/**
-	 * @param {Module} oldModule the replaced module
-	 * @param {Module} newModule the replacing module
-	 * @returns {void}
+	 *
+	 * @param {string} exportName name of the export
+	 * @param {string} expression expression to be used
 	 */
-	replaceModule(oldModule, newModule) {
-		const oldCgm = this._getChunkGraphModule(oldModule);
-		const newCgm = this._getChunkGraphModule(newModule);
-
-		for (const chunk of oldCgm.chunks) {
-			const cgc = this._getChunkGraphChunk(chunk);
-			cgc.modules.delete(oldModule);
-			cgc.modules.add(newModule);
-			newCgm.chunks.add(chunk);
-		}
-		oldCgm.chunks.clear();
-
-		if (oldCgm.entryInChunks !== undefined) {
-			if (newCgm.entryInChunks === undefined) {
-				newCgm.entryInChunks = new Set();
-			}
-			for (const chunk of oldCgm.entryInChunks) {
-				const cgc = this._getChunkGraphChunk(chunk);
-				const old = cgc.entryModules.get(oldModule);
-				/** @type {Map<Module, Entrypoint>} */
-				const newEntryModules = new Map();
-				for (const [m, cg] of cgc.entryModules) {
-					if (m === oldModule) {
-						newEntryModules.set(newModule, old);
-					} else {
-						newEntryModules.set(m, cg);
-					}
-				}
-				cgc.entryModules = newEntryModules;
-				newCgm.entryInChunks.add(chunk);
-			}
-			oldCgm.entryInChunks = undefined;
+	registerRawExport(exportName, expression) {
+		if (!this._currentModule.rawExportMap) {
+			this._currentModule.rawExportMap = new Map();
 		}
-
-		if (oldCgm.runtimeInChunks !== undefined) {
-			if (newCgm.runtimeInChunks === undefined) {
-				newCgm.runtimeInChunks = new Set();
-			}
-			for (const chunk of oldCgm.runtimeInChunks) {
-				const cgc = this._getChunkGraphChunk(chunk);
-				cgc.runtimeModules.delete(/** @type {RuntimeModule} */ (oldModule));
-				cgc.runtimeModules.add(/** @type {RuntimeModule} */ (newModule));
-				newCgm.runtimeInChunks.add(chunk);
-				if (
-					cgc.fullHashModules !== undefined &&
-					cgc.fullHashModules.has(/** @type {RuntimeModule} */ (oldModule))
-				) {
-					cgc.fullHashModules.delete(/** @type {RuntimeModule} */ (oldModule));
-					cgc.fullHashModules.add(/** @type {RuntimeModule} */ (newModule));
-				}
-				if (
-					cgc.dependentHashModules !== undefined &&
-					cgc.dependentHashModules.has(/** @type {RuntimeModule} */ (oldModule))
-				) {
-					cgc.dependentHashModules.delete(
-						/** @type {RuntimeModule} */ (oldModule)
-					);
-					cgc.dependentHashModules.add(
-						/** @type {RuntimeModule} */ (newModule)
-					);
-				}
-			}
-			oldCgm.runtimeInChunks = undefined;
+		if (!this._currentModule.rawExportMap.has(exportName)) {
+			this._currentModule.rawExportMap.set(exportName, expression);
 		}
 	}
 
 	/**
-	 * @param {Module} module the checked module
-	 * @param {Chunk} chunk the checked chunk
-	 * @returns {boolean} true, if the chunk contains the module
+	 * @param {string} symbol identifier of the export in source code
 	 */
-	isModuleInChunk(module, chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.has(module);
+	registerNamespaceExport(symbol) {
+		this._currentModule.namespaceExportSymbol = symbol;
 	}
 
 	/**
-	 * @param {Module} module the checked module
-	 * @param {ChunkGroup} chunkGroup the checked chunk group
-	 * @returns {boolean} true, if the chunk contains the module
+	 *
+	 * @param {Module} module the referenced module
+	 * @param {Partial<ModuleReferenceOptions>} options options
+	 * @returns {string} the reference as identifier
 	 */
-	isModuleInChunkGroup(module, chunkGroup) {
-		for (const chunk of chunkGroup.chunks) {
-			if (this.isModuleInChunk(module, chunk)) return true;
-		}
-		return false;
-	}
-
-	/**
-	 * @param {Module} module the checked module
-	 * @returns {boolean} true, if the module is entry of any chunk
-	 */
-	isEntryModule(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.entryInChunks !== undefined;
+	createModuleReference(
+		module,
+		{ ids = undefined, call = false, directImport = false, asiSafe = false }
+	) {
+		const info = this._modulesMap.get(module);
+		const callFlag = call ? "_call" : "";
+		const directImportFlag = directImport ? "_directImport" : "";
+		const asiSafeFlag = asiSafe
+			? "_asiSafe1"
+			: asiSafe === false
+			? "_asiSafe0"
+			: "";
+		const exportData = ids
+			? Buffer.from(JSON.stringify(ids), "utf-8").toString("hex")
+			: "ns";
+		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
+		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${asiSafeFlag}__._`;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
+	 * @param {string} name the identifier
+	 * @returns {boolean} true, when it's an module reference
 	 */
-	getModuleChunksIterable(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks;
+	static isModuleReference(name) {
+		return MODULE_REFERENCE_REGEXP.test(name);
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {function(Chunk, Chunk): -1|0|1} sortFn sort function
-	 * @returns {Iterable<Chunk>} iterable of chunks (do not modify)
+	 * @param {string} name the identifier
+	 * @returns {ModuleReferenceOptions & { index: number }} parsed options and index
 	 */
-	getOrderedModuleChunksIterable(module, sortFn) {
-		const cgm = this._getChunkGraphModule(module);
-		cgm.chunks.sortWith(sortFn);
-		return cgm.chunks;
+	static matchModuleReference(name) {
+		const match = MODULE_REFERENCE_REGEXP.exec(name);
+		if (!match) return null;
+		const index = +match[1];
+		const asiSafe = match[5];
+		return {
+			index,
+			ids:
+				match[2] === "ns"
+					? []
+					: JSON.parse(Buffer.from(match[2], "hex").toString("utf-8")),
+			call: !!match[3],
+			directImport: !!match[4],
+			asiSafe: asiSafe ? asiSafe === "1" : undefined
+		};
 	}
+}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {Chunk[]} array of chunks (cached, do not modify)
-	 */
-	getModuleChunks(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromCache(getArray);
-	}
+ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
+ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {number} the number of chunk which contain the module
-	 */
-	getNumberOfModuleChunks(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.size;
-	}
+module.exports = ConcatenationScope;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {RuntimeSpecSet} runtimes
-	 */
-	getModuleRuntimes(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.chunks.getFromUnorderedCache(getModuleRuntimes);
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the number of modules which are contained in this chunk
-	 */
-	getNumberOfChunkModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.size;
-	}
+/***/ }),
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the number of full hash modules which are contained in this chunk
-	 */
-	getNumberOfChunkFullHashModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.fullHashModules === undefined ? 0 : cgc.fullHashModules.size;
-	}
+/***/ 95735:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<Module>} return the modules for this chunk
-	 */
-	getChunkModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Maksim Nazarjev @acupofspirt
+*/
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {string} sourceType source type
-	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
-	 */
-	getChunkModulesIterableBySourceType(chunk, sourceType) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType)
-			.get(sourceType);
-		return modulesWithSourceType;
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
-	 * @returns {Iterable<Module>} return the modules for this chunk
-	 */
-	getOrderedChunkModulesIterable(chunk, comparator) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgc.modules.sortWith(comparator);
-		return cgc.modules;
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {string} sourceType source type
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
-	 * @returns {Iterable<Module> | undefined} return the modules for this chunk
-	 */
-	getOrderedChunkModulesIterableBySourceType(chunk, sourceType, comparator) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const modulesWithSourceType = cgc.modules
-			.getFromUnorderedCache(modulesBySourceType)
-			.get(sourceType);
-		if (modulesWithSourceType === undefined) return undefined;
-		modulesWithSourceType.sortWith(comparator);
-		return modulesWithSourceType;
-	}
+const WebpackError = __webpack_require__(53799);
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
-	 */
-	getChunkModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(getArray);
-	}
+module.exports = class ConcurrentCompilationError extends WebpackError {
+	constructor() {
+		super();
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {function(Module, Module): -1|0|1} comparator comparator function
-	 * @returns {Module[]} return the modules for this chunk (cached, do not modify)
-	 */
-	getOrderedChunkModules(chunk, comparator) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const arrayFunction = createOrderedArrayFunction(comparator);
-		return cgc.modules.getFromUnorderedCache(arrayFunction);
+		this.name = "ConcurrentCompilationError";
+		this.message =
+			"You ran Webpack twice. Each instance only supports a single concurrent compilation at a time.";
 	}
+};
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, (string|number)[]>} chunk to module ids object
-	 */
-	getChunkModuleIdMap(chunk, filterFn, includeAllChunks = false) {
-		/** @type {Record<string|number, (string|number)[]>} */
-		const chunkModuleIdMap = Object.create(null);
-
-		for (const asyncChunk of includeAllChunks
-			? chunk.getAllReferencedChunks()
-			: chunk.getAllAsyncChunks()) {
-			/** @type {(string|number)[]} */
-			let array;
-			for (const module of this.getOrderedChunkModulesIterable(
-				asyncChunk,
-				compareModulesById(this)
-			)) {
-				if (filterFn(module)) {
-					if (array === undefined) {
-						array = [];
-						chunkModuleIdMap[asyncChunk.id] = array;
-					}
-					const moduleId = this.getModuleId(module);
-					array.push(moduleId);
-				}
-			}
-		}
 
-		return chunkModuleIdMap;
-	}
+/***/ }),
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ModuleFilterPredicate} filterFn function used to filter modules
-	 * @param {number} hashLength length of the hash
-	 * @param {boolean} includeAllChunks all chunks or only async chunks
-	 * @returns {Record<string|number, Record<string|number, string>>} chunk to module id to module hash object
-	 */
-	getChunkModuleRenderedHashMap(
-		chunk,
-		filterFn,
-		hashLength = 0,
-		includeAllChunks = false
-	) {
-		/** @type {Record<string|number, Record<string|number, string>>} */
-		const chunkModuleHashMap = Object.create(null);
+/***/ 61333:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		for (const asyncChunk of includeAllChunks
-			? chunk.getAllReferencedChunks()
-			: chunk.getAllAsyncChunks()) {
-			/** @type {Record<string|number, string>} */
-			let idToHashMap;
-			for (const module of this.getOrderedChunkModulesIterable(
-				asyncChunk,
-				compareModulesById(this)
-			)) {
-				if (filterFn(module)) {
-					if (idToHashMap === undefined) {
-						idToHashMap = Object.create(null);
-						chunkModuleHashMap[asyncChunk.id] = idToHashMap;
-					}
-					const moduleId = this.getModuleId(module);
-					const hash = this.getRenderedModuleHash(module, asyncChunk.runtime);
-					idToHashMap[moduleId] = hashLength ? hash.slice(0, hashLength) : hash;
-				}
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		return chunkModuleHashMap;
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
-	 * @returns {Record<string|number, boolean>} chunk map
-	 */
-	getChunkConditionMap(chunk, filterFn) {
-		const map = Object.create(null);
-		for (const c of chunk.getAllReferencedChunks()) {
-			map[c.id] = filterFn(c, this);
-		}
-		return map;
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ModuleFilterPredicate} filterFn predicate function used to filter modules
-	 * @param {ChunkFilterPredicate=} filterChunkFn predicate function used to filter chunks
-	 * @returns {boolean} return true if module exists in graph
-	 */
-	hasModuleInGraph(chunk, filterFn, filterChunkFn) {
-		const queue = new Set(chunk.groupsIterable);
-		const chunksProcessed = new Set();
+const { ConcatSource, PrefixSource } = __webpack_require__(51255);
+const InitFragment = __webpack_require__(55870);
+const Template = __webpack_require__(1626);
+const { mergeRuntime } = __webpack_require__(17156);
 
-		for (const chunkGroup of queue) {
-			for (const innerChunk of chunkGroup.chunks) {
-				if (!chunksProcessed.has(innerChunk)) {
-					chunksProcessed.add(innerChunk);
-					if (!filterChunkFn || filterChunkFn(innerChunk, this)) {
-						for (const module of this.getChunkModulesIterable(innerChunk)) {
-							if (filterFn(module)) {
-								return true;
-							}
-						}
-					}
-				}
-			}
-			for (const child of chunkGroup.childrenIterable) {
-				queue.add(child);
-			}
-		}
-		return false;
-	}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-	/**
-	 * @param {Chunk} chunkA first chunk
-	 * @param {Chunk} chunkB second chunk
-	 * @returns {-1|0|1} this is a comparator function like sort and returns -1, 0, or 1 based on sort order
-	 */
-	compareChunks(chunkA, chunkB) {
-		const cgcA = this._getChunkGraphChunk(chunkA);
-		const cgcB = this._getChunkGraphChunk(chunkB);
-		if (cgcA.modules.size > cgcB.modules.size) return -1;
-		if (cgcA.modules.size < cgcB.modules.size) return 1;
-		cgcA.modules.sortWith(compareModulesByIdentifier);
-		cgcB.modules.sortWith(compareModulesByIdentifier);
-		return compareModuleIterables(cgcA.modules, cgcB.modules);
+const wrapInCondition = (condition, source) => {
+	if (typeof source === "string") {
+		return Template.asString([
+			`if (${condition}) {`,
+			Template.indent(source),
+			"}",
+			""
+		]);
+	} else {
+		return new ConcatSource(
+			`if (${condition}) {\n`,
+			new PrefixSource("\t", source),
+			"}\n"
+		);
 	}
+};
 
+/**
+ * @typedef {GenerateContext} Context
+ */
+class ConditionalInitFragment extends InitFragment {
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} total size of all modules in the chunk
+	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {string} key unique key to avoid emitting the same initialization code twice
+	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
+	 * @param {string|Source=} endContent the source code that will be included at the end of the module
 	 */
-	getChunkModulesSize(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(getModulesSize);
+	constructor(
+		content,
+		stage,
+		position,
+		key,
+		runtimeCondition = true,
+		endContent
+	) {
+		super(content, stage, position, key, endContent);
+		this.runtimeCondition = runtimeCondition;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Record<string, number>} total sizes of all modules in the chunk by source type
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	getChunkModulesSizes(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(getModulesSizes);
+	getContent(context) {
+		if (this.runtimeCondition === false || !this.content) return "";
+		if (this.runtimeCondition === true) return this.content;
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.content;
+		return wrapInCondition(expr, this.content);
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Module[]} root modules of the chunks (ordered by identifier)
+	 * @param {Context} context context
+	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	getChunkRootModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.modules.getFromUnorderedCache(this._getGraphRoots);
+	getEndContent(context) {
+		if (this.runtimeCondition === false || !this.endContent) return "";
+		if (this.runtimeCondition === true) return this.endContent;
+		const expr = context.runtimeTemplate.runtimeConditionExpression({
+			chunkGraph: context.chunkGraph,
+			runtimeRequirements: context.runtimeRequirements,
+			runtime: context.runtime,
+			runtimeCondition: this.runtimeCondition
+		});
+		if (expr === "true") return this.endContent;
+		return wrapInCondition(expr, this.endContent);
 	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk
-	 */
-	getChunkSize(chunk, options = {}) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const modulesSize = cgc.modules.getFromUnorderedCache(getModulesSize);
-		const chunkOverhead =
-			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
-		const entryChunkMultiplicator =
-			typeof options.entryChunkMultiplicator === "number"
-				? options.entryChunkMultiplicator
-				: 10;
-		return (
-			chunkOverhead +
-			modulesSize * (chunk.canBeInitial() ? entryChunkMultiplicator : 1)
+	merge(other) {
+		if (this.runtimeCondition === true) return this;
+		if (other.runtimeCondition === true) return other;
+		if (this.runtimeCondition === false) return other;
+		if (other.runtimeCondition === false) return this;
+		const runtimeCondition = mergeRuntime(
+			this.runtimeCondition,
+			other.runtimeCondition
 		);
-	}
-
-	/**
-	 * @param {Chunk} chunkA chunk
-	 * @param {Chunk} chunkB chunk
-	 * @param {ChunkSizeOptions} options options object
-	 * @returns {number} total size of the chunk or false if chunks can't be integrated
-	 */
-	getIntegratedChunksSize(chunkA, chunkB, options = {}) {
-		const cgcA = this._getChunkGraphChunk(chunkA);
-		const cgcB = this._getChunkGraphChunk(chunkB);
-		const allModules = new Set(cgcA.modules);
-		for (const m of cgcB.modules) allModules.add(m);
-		let modulesSize = getModulesSize(allModules);
-		const chunkOverhead =
-			typeof options.chunkOverhead === "number" ? options.chunkOverhead : 10000;
-		const entryChunkMultiplicator =
-			typeof options.entryChunkMultiplicator === "number"
-				? options.entryChunkMultiplicator
-				: 10;
-		return (
-			chunkOverhead +
-			modulesSize *
-				(chunkA.canBeInitial() || chunkB.canBeInitial()
-					? entryChunkMultiplicator
-					: 1)
+		return new ConditionalInitFragment(
+			this.content,
+			this.stage,
+			this.position,
+			this.key,
+			runtimeCondition,
+			this.endContent
 		);
 	}
+}
 
-	/**
-	 * @param {Chunk} chunkA chunk
-	 * @param {Chunk} chunkB chunk
-	 * @returns {boolean} true, if chunks could be integrated
-	 */
-	canChunksBeIntegrated(chunkA, chunkB) {
-		if (chunkA.preventIntegration || chunkB.preventIntegration) {
-			return false;
-		}
+module.exports = ConditionalInitFragment;
 
-		const hasRuntimeA = chunkA.hasRuntime();
-		const hasRuntimeB = chunkB.hasRuntime();
 
-		if (hasRuntimeA !== hasRuntimeB) {
-			if (hasRuntimeA) {
-				return isAvailableChunk(chunkA, chunkB);
-			} else if (hasRuntimeB) {
-				return isAvailableChunk(chunkB, chunkA);
-			} else {
-				return false;
-			}
-		}
+/***/ }),
 
-		if (
-			this.getNumberOfEntryModules(chunkA) > 0 ||
-			this.getNumberOfEntryModules(chunkB) > 0
-		) {
-			return false;
-		}
+/***/ 11146:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		return true;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @param {Chunk} chunkA the target chunk
-	 * @param {Chunk} chunkB the chunk to integrate
-	 * @returns {void}
-	 */
-	integrateChunks(chunkA, chunkB) {
-		// Decide for one name (deterministic)
-		if (chunkA.name && chunkB.name) {
-			if (
-				this.getNumberOfEntryModules(chunkA) > 0 ===
-				this.getNumberOfEntryModules(chunkB) > 0
-			) {
-				// When both chunks have entry modules or none have one, use
-				// shortest name
-				if (chunkA.name.length !== chunkB.name.length) {
-					chunkA.name =
-						chunkA.name.length < chunkB.name.length ? chunkA.name : chunkB.name;
-				} else {
-					chunkA.name = chunkA.name < chunkB.name ? chunkA.name : chunkB.name;
-				}
-			} else if (this.getNumberOfEntryModules(chunkB) > 0) {
-				// Pick the name of the chunk with the entry module
-				chunkA.name = chunkB.name;
-			}
-		} else if (chunkB.name) {
-			chunkA.name = chunkB.name;
-		}
-
-		// Merge id name hints
-		for (const hint of chunkB.idNameHints) {
-			chunkA.idNameHints.add(hint);
-		}
-
-		// Merge runtime
-		chunkA.runtime = mergeRuntime(chunkA.runtime, chunkB.runtime);
-
-		// getChunkModules is used here to create a clone, because disconnectChunkAndModule modifies
-		for (const module of this.getChunkModules(chunkB)) {
-			this.disconnectChunkAndModule(chunkB, module);
-			this.connectChunkAndModule(chunkA, module);
-		}
-
-		for (const [module, chunkGroup] of Array.from(
-			this.getChunkEntryModulesWithChunkGroupIterable(chunkB)
-		)) {
-			this.disconnectChunkAndEntryModule(chunkB, module);
-			this.connectChunkAndEntryModule(chunkA, module, chunkGroup);
-		}
-
-		for (const chunkGroup of chunkB.groupsIterable) {
-			chunkGroup.replaceChunk(chunkB, chunkA);
-			chunkA.addGroup(chunkGroup);
-			chunkB.removeGroup(chunkGroup);
-		}
-		ChunkGraph.clearChunkGraphForChunk(chunkB);
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk to upgrade
-	 * @returns {void}
-	 */
-	upgradeDependentToFullHashModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined) return;
-		if (cgc.fullHashModules === undefined) {
-			cgc.fullHashModules = cgc.dependentHashModules;
-		} else {
-			for (const m of cgc.dependentHashModules) {
-				cgc.fullHashModules.add(m);
-			}
-			cgc.dependentHashModules = undefined;
-		}
-	}
-
-	/**
-	 * @param {Module} module the checked module
-	 * @param {Chunk} chunk the checked chunk
-	 * @returns {boolean} true, if the chunk contains the module as entry
-	 */
-	isEntryModuleInChunk(module, chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules.has(module);
-	}
-
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {Module} module the entry module
-	 * @param {Entrypoint=} entrypoint the chunk group which must be loaded before the module is executed
-	 * @returns {void}
-	 */
-	connectChunkAndEntryModule(chunk, module, entrypoint) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgm.entryInChunks === undefined) {
-			cgm.entryInChunks = new Set();
-		}
-		cgm.entryInChunks.add(chunk);
-		cgc.entryModules.set(module, entrypoint);
-	}
-
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the runtime module
-	 * @returns {void}
-	 */
-	connectChunkAndRuntimeModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgm.runtimeInChunks === undefined) {
-			cgm.runtimeInChunks = new Set();
-		}
-		cgm.runtimeInChunks.add(chunk);
-		cgc.runtimeModules.add(module);
-	}
-
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the module that require a full hash
-	 * @returns {void}
-	 */
-	addFullHashModuleToChunk(chunk, module) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.fullHashModules === undefined) cgc.fullHashModules = new Set();
-		cgc.fullHashModules.add(module);
-	}
-
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the module that require a full hash
-	 * @returns {void}
-	 */
-	addDependentHashModuleToChunk(chunk, module) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		if (cgc.dependentHashModules === undefined)
-			cgc.dependentHashModules = new Set();
-		cgc.dependentHashModules.add(module);
-	}
-
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {Module} module the entry module
-	 * @returns {void}
-	 */
-	disconnectChunkAndEntryModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.entryInChunks.delete(chunk);
-		if (cgm.entryInChunks.size === 0) {
-			cgm.entryInChunks = undefined;
-		}
-		cgc.entryModules.delete(module);
-	}
-
-	/**
-	 * @param {Chunk} chunk the new chunk
-	 * @param {RuntimeModule} module the runtime module
-	 * @returns {void}
-	 */
-	disconnectChunkAndRuntimeModule(chunk, module) {
-		const cgm = this._getChunkGraphModule(module);
-		const cgc = this._getChunkGraphChunk(chunk);
-		cgm.runtimeInChunks.delete(chunk);
-		if (cgm.runtimeInChunks.size === 0) {
-			cgm.runtimeInChunks = undefined;
-		}
-		cgc.runtimeModules.delete(module);
-	}
-
-	/**
-	 * @param {Module} module the entry module, it will no longer be entry
-	 * @returns {void}
-	 */
-	disconnectEntryModule(module) {
-		const cgm = this._getChunkGraphModule(module);
-		for (const chunk of cgm.entryInChunks) {
-			const cgc = this._getChunkGraphChunk(chunk);
-			cgc.entryModules.delete(module);
-		}
-		cgm.entryInChunks = undefined;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk, for which all entries will be removed
-	 * @returns {void}
-	 */
-	disconnectEntries(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const module of cgc.entryModules.keys()) {
-			const cgm = this._getChunkGraphModule(module);
-			cgm.entryInChunks.delete(chunk);
-			if (cgm.entryInChunks.size === 0) {
-				cgm.entryInChunks = undefined;
-			}
-		}
-		cgc.entryModules.clear();
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the amount of entry modules in chunk
-	 */
-	getNumberOfEntryModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules.size;
-	}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {number} the amount of entry modules in chunk
-	 */
-	getNumberOfRuntimeModules(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.runtimeModules.size;
-	}
+const CachedConstDependency = __webpack_require__(57403);
+const ConstDependency = __webpack_require__(76911);
+const { evaluateToString } = __webpack_require__(93998);
+const { parseResource } = __webpack_require__(82186);
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<Module>} iterable of modules (do not modify)
-	 */
-	getChunkEntryModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules.keys();
-	}
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Super} SuperNode */
+/** @typedef {import("./Compiler")} Compiler */
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<Chunk>} iterable of chunks
-	 */
-	getChunkEntryDependentChunksIterable(chunk) {
-		/** @type {Set<Chunk>} */
-		const set = new Set();
-		for (const chunkGroup of chunk.groupsIterable) {
-			if (chunkGroup instanceof Entrypoint) {
-				const entrypointChunk = chunkGroup.getEntrypointChunk();
-				const cgc = this._getChunkGraphChunk(entrypointChunk);
-				for (const chunkGroup of cgc.entryModules.values()) {
-					for (const c of chunkGroup.chunks) {
-						if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
-							set.add(c);
-						}
+const collectDeclaration = (declarations, pattern) => {
+	const stack = [pattern];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		switch (node.type) {
+			case "Identifier":
+				declarations.add(node.name);
+				break;
+			case "ArrayPattern":
+				for (const element of node.elements) {
+					if (element) {
+						stack.push(element);
 					}
 				}
-			}
-		}
-
-		return set;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {boolean} true, when it has dependent chunks
-	 */
-	hasChunkEntryDependentChunks(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		for (const chunkGroup of cgc.entryModules.values()) {
-			for (const c of chunkGroup.chunks) {
-				if (c !== chunk) {
-					return true;
+				break;
+			case "AssignmentPattern":
+				stack.push(node.left);
+				break;
+			case "ObjectPattern":
+				for (const property of node.properties) {
+					stack.push(property.value);
 				}
-			}
+				break;
+			case "RestElement":
+				stack.push(node.argument);
+				break;
 		}
-		return false;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<RuntimeModule>} iterable of modules (do not modify)
-	 */
-	getChunkRuntimeModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.runtimeModules;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {RuntimeModule[]} array of modules in order of execution
-	 */
-	getChunkRuntimeModulesInOrder(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const array = Array.from(cgc.runtimeModules);
-		array.sort(
-			concatComparators(
-				compareSelect(
-					/**
-					 * @param {RuntimeModule} r runtime module
-					 * @returns {number=} stage
-					 */
-					r => r.stage,
-					compareIds
-				),
-				compareModulesByIdentifier
-			)
-		);
-		return array;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
-	 */
-	getChunkFullHashModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.fullHashModules;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<RuntimeModule> | undefined} set of modules (do not modify)
-	 */
-	getChunkFullHashModulesSet(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.fullHashModules;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<RuntimeModule> | undefined} iterable of modules (do not modify)
-	 */
-	getChunkDependentHashModulesIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.dependentHashModules;
-	}
-
-	/** @typedef {[Module, Entrypoint | undefined]} EntryModuleWithChunkGroup */
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {Iterable<EntryModuleWithChunkGroup>} iterable of modules (do not modify)
-	 */
-	getChunkEntryModulesWithChunkGroupIterable(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.entryModules;
-	}
-
-	/**
-	 * @param {AsyncDependenciesBlock} depBlock the async block
-	 * @returns {ChunkGroup} the chunk group
-	 */
-	getBlockChunkGroup(depBlock) {
-		return this._blockChunkGroups.get(depBlock);
-	}
-
-	/**
-	 * @param {AsyncDependenciesBlock} depBlock the async block
-	 * @param {ChunkGroup} chunkGroup the chunk group
-	 * @returns {void}
-	 */
-	connectBlockAndChunkGroup(depBlock, chunkGroup) {
-		this._blockChunkGroups.set(depBlock, chunkGroup);
-		chunkGroup.addBlock(depBlock);
 	}
+};
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the chunk group
-	 * @returns {void}
-	 */
-	disconnectChunkGroup(chunkGroup) {
-		for (const block of chunkGroup.blocksIterable) {
-			this._blockChunkGroups.delete(block);
+const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
+	const declarations = new Set();
+	const stack = [branch];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		// Some node could be `null` or `undefined`.
+		if (!node) continue;
+		switch (node.type) {
+			// Walk through control statements to look for hoisted declarations.
+			// Some branches are skipped since they do not allow declarations.
+			case "BlockStatement":
+				for (const stmt of node.body) {
+					stack.push(stmt);
+				}
+				break;
+			case "IfStatement":
+				stack.push(node.consequent);
+				stack.push(node.alternate);
+				break;
+			case "ForStatement":
+				stack.push(node.init);
+				stack.push(node.body);
+				break;
+			case "ForInStatement":
+			case "ForOfStatement":
+				stack.push(node.left);
+				stack.push(node.body);
+				break;
+			case "DoWhileStatement":
+			case "WhileStatement":
+			case "LabeledStatement":
+				stack.push(node.body);
+				break;
+			case "SwitchStatement":
+				for (const cs of node.cases) {
+					for (const consequent of cs.consequent) {
+						stack.push(consequent);
+					}
+				}
+				break;
+			case "TryStatement":
+				stack.push(node.block);
+				if (node.handler) {
+					stack.push(node.handler.body);
+				}
+				stack.push(node.finalizer);
+				break;
+			case "FunctionDeclaration":
+				if (includeFunctionDeclarations) {
+					collectDeclaration(declarations, node.id);
+				}
+				break;
+			case "VariableDeclaration":
+				if (node.kind === "var") {
+					for (const decl of node.declarations) {
+						collectDeclaration(declarations, decl.id);
+					}
+				}
+				break;
 		}
-		// TODO refactor by moving blocks list into ChunkGraph
-		chunkGroup._blocks.clear();
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @returns {string | number} the id of the module
-	 */
-	getModuleId(module) {
-		const cgm = this._getChunkGraphModule(module);
-		return cgm.id;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {string | number} id the id of the module
-	 * @returns {void}
-	 */
-	setModuleId(module, id) {
-		const cgm = this._getChunkGraphModule(module);
-		cgm.id = id;
-	}
-
-	/**
-	 * @param {string} runtime runtime
-	 * @returns {string | number} the id of the runtime
-	 */
-	getRuntimeId(runtime) {
-		return this._runtimeIds.get(runtime);
 	}
+	return Array.from(declarations);
+};
 
+class ConstPlugin {
 	/**
-	 * @param {string} runtime runtime
-	 * @param {string | number} id the id of the runtime
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	setRuntimeId(runtime, id) {
-		this._runtimeIds.set(runtime, id);
-	}
-
-	/**
-	 * @template T
-	 * @param {Module} module the module
-	 * @param {RuntimeSpecMap<T>} hashes hashes data
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {T} hash
-	 */
-	_getModuleHashInfo(module, hashes, runtime) {
-		if (!hashes) {
-			throw new Error(
-				`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
-					runtime
-				)} (hashes not set at all)`
-			);
-		} else if (runtime === undefined) {
-			const hashInfoItems = new Set(hashes.values());
-			if (hashInfoItems.size !== 1) {
-				throw new Error(
-					`No unique hash info entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
-						hashes.keys(),
-						r => runtimeToString(r)
-					).join(", ")}).
-Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
+	apply(compiler) {
+		const cachedParseResource = parseResource.bindCache(compiler.root);
+		compiler.hooks.compilation.tap(
+			"ConstPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
 				);
-			}
-			return first(hashInfoItems);
-		} else {
-			const hashInfo = hashes.get(runtime);
-			if (!hashInfo) {
-				throw new Error(
-					`Module ${module.identifier()} has no hash info for runtime ${runtimeToString(
-						runtime
-					)} (available runtimes ${Array.from(
-						hashes.keys(),
-						runtimeToString
-					).join(", ")})`
+
+				compilation.dependencyTemplates.set(
+					CachedConstDependency,
+					new CachedConstDependency.Template()
 				);
-			}
-			return hashInfo;
-		}
-	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, if the module has hashes for this runtime
-	 */
-	hasModuleHashes(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		return hashes && hashes.has(runtime);
-	}
+				const handler = parser => {
+					parser.hooks.statementIf.tap("ConstPlugin", statement => {
+						if (parser.scope.isAsmJs) return;
+						const param = parser.evaluateExpression(statement.test);
+						const bool = param.asBool();
+						if (typeof bool === "boolean") {
+							if (!param.couldHaveSideEffects()) {
+								const dep = new ConstDependency(`${bool}`, param.range);
+								dep.loc = statement.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							} else {
+								parser.walkExpression(statement.test);
+							}
+							const branchToRemove = bool
+								? statement.alternate
+								: statement.consequent;
+							if (branchToRemove) {
+								// Before removing the dead branch, the hoisted declarations
+								// must be collected.
+								//
+								// Given the following code:
+								//
+								//     if (true) f() else g()
+								//     if (false) {
+								//       function f() {}
+								//       const g = function g() {}
+								//       if (someTest) {
+								//         let a = 1
+								//         var x, {y, z} = obj
+								//       }
+								//     } else {
+								//       …
+								//     }
+								//
+								// the generated code is:
+								//
+								//     if (true) f() else {}
+								//     if (false) {
+								//       var f, x, y, z;   (in loose mode)
+								//       var x, y, z;      (in strict mode)
+								//     } else {
+								//       …
+								//     }
+								//
+								// NOTE: When code runs in strict mode, `var` declarations
+								// are hoisted but `function` declarations don't.
+								//
+								let declarations;
+								if (parser.scope.isStrict) {
+									// If the code runs in strict mode, variable declarations
+									// using `var` must be hoisted.
+									declarations = getHoistedDeclarations(branchToRemove, false);
+								} else {
+									// Otherwise, collect all hoisted declaration.
+									declarations = getHoistedDeclarations(branchToRemove, true);
+								}
+								let replacement;
+								if (declarations.length > 0) {
+									replacement = `{ var ${declarations.join(", ")}; }`;
+								} else {
+									replacement = "{}";
+								}
+								const dep = new ConstDependency(
+									replacement,
+									branchToRemove.range
+								);
+								dep.loc = branchToRemove.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
+							return bool;
+						}
+					});
+					parser.hooks.expressionConditionalOperator.tap(
+						"ConstPlugin",
+						expression => {
+							if (parser.scope.isAsmJs) return;
+							const param = parser.evaluateExpression(expression.test);
+							const bool = param.asBool();
+							if (typeof bool === "boolean") {
+								if (!param.couldHaveSideEffects()) {
+									const dep = new ConstDependency(` ${bool}`, param.range);
+									dep.loc = expression.loc;
+									parser.state.module.addPresentationalDependency(dep);
+								} else {
+									parser.walkExpression(expression.test);
+								}
+								// Expressions do not hoist.
+								// It is safe to remove the dead branch.
+								//
+								// Given the following code:
+								//
+								//   false ? someExpression() : otherExpression();
+								//
+								// the generated code is:
+								//
+								//   false ? 0 : otherExpression();
+								//
+								const branchToRemove = bool
+									? expression.alternate
+									: expression.consequent;
+								const dep = new ConstDependency("0", branchToRemove.range);
+								dep.loc = branchToRemove.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return bool;
+							}
+						}
+					);
+					parser.hooks.expressionLogicalOperator.tap(
+						"ConstPlugin",
+						expression => {
+							if (parser.scope.isAsmJs) return;
+							if (
+								expression.operator === "&&" ||
+								expression.operator === "||"
+							) {
+								const param = parser.evaluateExpression(expression.left);
+								const bool = param.asBool();
+								if (typeof bool === "boolean") {
+									// Expressions do not hoist.
+									// It is safe to remove the dead branch.
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   falsyExpression() && someExpression();
+									//
+									// the generated code is:
+									//
+									//   falsyExpression() && false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   truthyExpression() && someExpression();
+									//
+									// the generated code is:
+									//
+									//   true && someExpression();
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   truthyExpression() || someExpression();
+									//
+									// the generated code is:
+									//
+									//   truthyExpression() || false;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   falsyExpression() || someExpression();
+									//
+									// the generated code is:
+									//
+									//   false && someExpression();
+									//
+									const keepRight =
+										(expression.operator === "&&" && bool) ||
+										(expression.operator === "||" && !bool);
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	getModuleHash(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		return this._getModuleHashInfo(module, hashes, runtime).hash;
-	}
+									if (
+										!param.couldHaveSideEffects() &&
+										(param.isBoolean() || keepRight)
+									) {
+										// for case like
+										//
+										//   return'development'===process.env.NODE_ENV&&'foo'
+										//
+										// we need a space before the bool to prevent result like
+										//
+										//   returnfalse&&'foo'
+										//
+										const dep = new ConstDependency(` ${bool}`, param.range);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+									} else {
+										parser.walkExpression(expression.left);
+									}
+									if (!keepRight) {
+										const dep = new ConstDependency(
+											"0",
+											expression.right.range
+										);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+									}
+									return keepRight;
+								}
+							} else if (expression.operator === "??") {
+								const param = parser.evaluateExpression(expression.left);
+								const keepRight = param && param.asNullish();
+								if (typeof keepRight === "boolean") {
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   nonNullish ?? someExpression();
+									//
+									// the generated code is:
+									//
+									//   nonNullish ?? 0;
+									//
+									// ------------------------------------------
+									//
+									// Given the following code:
+									//
+									//   nullish ?? someExpression();
+									//
+									// the generated code is:
+									//
+									//   null ?? someExpression();
+									//
+									if (!param.couldHaveSideEffects() && keepRight) {
+										// cspell:word returnnull
+										// for case like
+										//
+										//   return('development'===process.env.NODE_ENV&&null)??'foo'
+										//
+										// we need a space before the bool to prevent result like
+										//
+										//   returnnull??'foo'
+										//
+										const dep = new ConstDependency(" null", param.range);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+									} else {
+										const dep = new ConstDependency(
+											"0",
+											expression.right.range
+										);
+										dep.loc = expression.loc;
+										parser.state.module.addPresentationalDependency(dep);
+										parser.walkExpression(expression.left);
+									}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	getRenderedModuleHash(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const hashes = cgm.hashes;
-		return this._getModuleHashInfo(module, hashes, runtime).renderedHash;
-	}
+									return keepRight;
+								}
+							}
+						}
+					);
+					parser.hooks.optionalChaining.tap("ConstPlugin", expr => {
+						/** @type {ExpressionNode[]} */
+						const optionalExpressionsStack = [];
+						/** @type {ExpressionNode|SuperNode} */
+						let next = expr.expression;
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {string} hash the full hash
-	 * @param {string} renderedHash the shortened hash for rendering
-	 * @returns {void}
-	 */
-	setModuleHashes(module, runtime, hash, renderedHash) {
-		const cgm = this._getChunkGraphModule(module);
-		if (cgm.hashes === undefined) {
-			cgm.hashes = new RuntimeSpecMap();
-		}
-		cgm.hashes.set(runtime, new ModuleHashInfo(hash, renderedHash));
-	}
+						while (
+							next.type === "MemberExpression" ||
+							next.type === "CallExpression"
+						) {
+							if (next.type === "MemberExpression") {
+								if (next.optional) {
+									// SuperNode can not be optional
+									optionalExpressionsStack.push(
+										/** @type {ExpressionNode} */ (next.object)
+									);
+								}
+								next = next.object;
+							} else {
+								if (next.optional) {
+									// SuperNode can not be optional
+									optionalExpressionsStack.push(
+										/** @type {ExpressionNode} */ (next.callee)
+									);
+								}
+								next = next.callee;
+							}
+						}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
-	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
-	 * @returns {void}
-	 */
-	addModuleRuntimeRequirements(
-		module,
-		runtime,
-		items,
-		transferOwnership = true
-	) {
-		const cgm = this._getChunkGraphModule(module);
-		const runtimeRequirementsMap = cgm.runtimeRequirements;
-		if (runtimeRequirementsMap === undefined) {
-			const map = new RuntimeSpecMap();
-			// TODO avoid cloning item and track ownership instead
-			map.set(runtime, transferOwnership ? items : new Set(items));
-			cgm.runtimeRequirements = map;
-			return;
-		}
-		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
-			if (runtimeRequirements === undefined) {
-				return transferOwnership ? items : new Set(items);
-			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
-				for (const item of items) runtimeRequirements.add(item);
-				return runtimeRequirements;
-			} else {
-				for (const item of runtimeRequirements) items.add(item);
-				return items;
+						while (optionalExpressionsStack.length) {
+							const expression = optionalExpressionsStack.pop();
+							const evaluated = parser.evaluateExpression(expression);
+
+							if (evaluated && evaluated.asNullish()) {
+								// ------------------------------------------
+								//
+								// Given the following code:
+								//
+								//   nullishMemberChain?.a.b();
+								//
+								// the generated code is:
+								//
+								//   undefined;
+								//
+								// ------------------------------------------
+								//
+								const dep = new ConstDependency(" undefined", expr.range);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
+						}
+					});
+					parser.hooks.evaluateIdentifier
+						.for("__resourceQuery")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							return evaluateToString(
+								cachedParseResource(parser.state.module.resource).query
+							)(expr);
+						});
+					parser.hooks.expression
+						.for("__resourceQuery")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							const dep = new CachedConstDependency(
+								JSON.stringify(
+									cachedParseResource(parser.state.module.resource).query
+								),
+								expr.range,
+								"__resourceQuery"
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					parser.hooks.evaluateIdentifier
+						.for("__resourceFragment")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							return evaluateToString(
+								cachedParseResource(parser.state.module.resource).fragment
+							)(expr);
+						});
+					parser.hooks.expression
+						.for("__resourceFragment")
+						.tap("ConstPlugin", expr => {
+							if (parser.scope.isAsmJs) return;
+							if (!parser.state.module) return;
+							const dep = new CachedConstDependency(
+								JSON.stringify(
+									cachedParseResource(parser.state.module.resource).fragment
+								),
+								expr.range,
+								"__resourceFragment"
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ConstPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ConstPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ConstPlugin", handler);
 			}
-		});
+		);
 	}
+}
+
+module.exports = ConstPlugin;
+
+
+/***/ }),
+
+/***/ 21411:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
 
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
+
+class ContextExclusionPlugin {
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
-	 * @returns {void}
+	 * @param {RegExp} negativeMatcher Matcher regular expression
 	 */
-	addChunkRuntimeRequirements(chunk, items) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const runtimeRequirements = cgc.runtimeRequirements;
-		if (runtimeRequirements === undefined) {
-			cgc.runtimeRequirements = items;
-		} else if (runtimeRequirements.size >= items.size) {
-			for (const item of items) runtimeRequirements.add(item);
-		} else {
-			for (const item of runtimeRequirements) items.add(item);
-			cgc.runtimeRequirements = items;
-		}
+	constructor(negativeMatcher) {
+		this.negativeMatcher = negativeMatcher;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Iterable<string>} items runtime requirements to be added
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	addTreeRuntimeRequirements(chunk, items) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const runtimeRequirements = cgc.runtimeRequirementsInTree;
-		for (const item of items) runtimeRequirements.add(item);
+	apply(compiler) {
+		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
+			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files => {
+				return files.filter(filePath => !this.negativeMatcher.test(filePath));
+			});
+		});
 	}
+}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getModuleRuntimeRequirements(module, runtime) {
-		const cgm = this._getChunkGraphModule(module);
-		const runtimeRequirements =
-			cgm.runtimeRequirements && cgm.runtimeRequirements.get(runtime);
-		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getChunkRuntimeRequirements(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		const runtimeRequirements = cgc.runtimeRequirements;
-		return runtimeRequirements === undefined ? EMPTY_SET : runtimeRequirements;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {boolean} withConnections include connections
-	 * @returns {string} hash
-	 */
-	getModuleGraphHash(module, runtime, withConnections = true) {
-		const cgm = this._getChunkGraphModule(module);
-		return withConnections
-			? this._getModuleGraphHashWithConnections(cgm, module, runtime)
-			: this._getModuleGraphHashBigInt(cgm, module, runtime).toString(16);
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {boolean} withConnections include connections
-	 * @returns {bigint} hash
-	 */
-	getModuleGraphHashBigInt(module, runtime, withConnections = true) {
-		const cgm = this._getChunkGraphModule(module);
-		return withConnections
-			? BigInt(
-					`0x${this._getModuleGraphHashWithConnections(cgm, module, runtime)}`
-			  )
-			: this._getModuleGraphHashBigInt(cgm, module, runtime);
-	}
-
-	/**
-	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {bigint} hash as big int
-	 */
-	_getModuleGraphHashBigInt(cgm, module, runtime) {
-		if (cgm.graphHashes === undefined) {
-			cgm.graphHashes = new RuntimeSpecMap();
-		}
-		const graphHash = cgm.graphHashes.provide(runtime, () => {
-			const hash = createHash(this._hashFunction);
-			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
-			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
-			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
-		});
-		return graphHash;
-	}
-
-	/**
-	 * @param {ChunkGraphModule} cgm the ChunkGraphModule
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	_getModuleGraphHashWithConnections(cgm, module, runtime) {
-		if (cgm.graphHashesWithConnections === undefined) {
-			cgm.graphHashesWithConnections = new RuntimeSpecMap();
-		}
-		const activeStateToString = state => {
-			if (state === false) return "F";
-			if (state === true) return "T";
-			if (state === ModuleGraphConnection.TRANSITIVE_ONLY) return "O";
-			throw new Error("Not implemented active state");
-		};
-		const strict = module.buildMeta && module.buildMeta.strictHarmonyModule;
-		return cgm.graphHashesWithConnections.provide(runtime, () => {
-			const graphHash = this._getModuleGraphHashBigInt(
-				cgm,
-				module,
-				runtime
-			).toString(16);
-			const connections = this.moduleGraph.getOutgoingConnections(module);
-			/** @type {Set<Module>} */
-			const activeNamespaceModules = new Set();
-			/** @type {Map<string, Module | Set<Module>>} */
-			const connectedModules = new Map();
-			const processConnection = (connection, stateInfo) => {
-				const module = connection.module;
-				stateInfo += module.getExportsType(this.moduleGraph, strict);
-				// cspell:word Tnamespace
-				if (stateInfo === "Tnamespace") activeNamespaceModules.add(module);
-				else {
-					const oldModule = connectedModules.get(stateInfo);
-					if (oldModule === undefined) {
-						connectedModules.set(stateInfo, module);
-					} else if (oldModule instanceof Set) {
-						oldModule.add(module);
-					} else if (oldModule !== module) {
-						connectedModules.set(stateInfo, new Set([oldModule, module]));
-					}
-				}
-			};
-			if (runtime === undefined || typeof runtime === "string") {
-				for (const connection of connections) {
-					const state = connection.getActiveState(runtime);
-					if (state === false) continue;
-					processConnection(connection, state === true ? "T" : "O");
-				}
-			} else {
-				// cspell:word Tnamespace
-				for (const connection of connections) {
-					const states = new Set();
-					let stateInfo = "";
-					forEachRuntime(
-						runtime,
-						runtime => {
-							const state = connection.getActiveState(runtime);
-							states.add(state);
-							stateInfo += activeStateToString(state) + runtime;
-						},
-						true
-					);
-					if (states.size === 1) {
-						const state = first(states);
-						if (state === false) continue;
-						stateInfo = activeStateToString(state);
-					}
-					processConnection(connection, stateInfo);
-				}
-			}
-			// cspell:word Tnamespace
-			if (activeNamespaceModules.size === 0 && connectedModules.size === 0)
-				return graphHash;
-			const connectedModulesInOrder =
-				connectedModules.size > 1
-					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
-					: connectedModules;
-			const hash = createHash(this._hashFunction);
-			const addModuleToHash = module => {
-				hash.update(
-					this._getModuleGraphHashBigInt(
-						this._getChunkGraphModule(module),
-						module,
-						runtime
-					).toString(16)
-				);
-			};
-			const addModulesToHash = modules => {
-				let xor = ZERO_BIG_INT;
-				for (const m of modules) {
-					xor =
-						xor ^
-						this._getModuleGraphHashBigInt(
-							this._getChunkGraphModule(m),
-							m,
-							runtime
-						);
-				}
-				hash.update(xor.toString(16));
-			};
-			if (activeNamespaceModules.size === 1)
-				addModuleToHash(activeNamespaceModules.values().next().value);
-			else if (activeNamespaceModules.size > 1)
-				addModulesToHash(activeNamespaceModules);
-			for (const [stateInfo, modules] of connectedModulesInOrder) {
-				hash.update(stateInfo);
-				if (modules instanceof Set) {
-					addModulesToHash(modules);
-				} else {
-					addModuleToHash(modules);
-				}
-			}
-			hash.update(graphHash);
-			return /** @type {string} */ (hash.digest("hex"));
-		});
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getTreeRuntimeRequirements(chunk) {
-		const cgc = this._getChunkGraphChunk(chunk);
-		return cgc.runtimeRequirementsInTree;
-	}
-
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @param {string} deprecateMessage message for the deprecation message
-	 * @param {string} deprecationCode code for the deprecation
-	 * @returns {ChunkGraph} the chunk graph
-	 */
-	static getChunkGraphForModule(module, deprecateMessage, deprecationCode) {
-		const fn = deprecateGetChunkGraphForModuleMap.get(deprecateMessage);
-		if (fn) return fn(module);
-		const newFn = util.deprecate(
-			/**
-			 * @param {Module} module the module
-			 * @returns {ChunkGraph} the chunk graph
-			 */
-			module => {
-				const chunkGraph = chunkGraphForModuleMap.get(module);
-				if (!chunkGraph)
-					throw new Error(
-						deprecateMessage +
-							": There was no ChunkGraph assigned to the Module for backward-compat (Use the new API)"
-					);
-				return chunkGraph;
-			},
-			deprecateMessage + ": Use new ChunkGraph API",
-			deprecationCode
-		);
-		deprecateGetChunkGraphForModuleMap.set(deprecateMessage, newFn);
-		return newFn(module);
-	}
-
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	static setChunkGraphForModule(module, chunkGraph) {
-		chunkGraphForModuleMap.set(module, chunkGraph);
-	}
-
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	static clearChunkGraphForModule(module) {
-		chunkGraphForModuleMap.delete(module);
-	}
-
-	// TODO remove in webpack 6
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {string} deprecateMessage message for the deprecation message
-	 * @param {string} deprecationCode code for the deprecation
-	 * @returns {ChunkGraph} the chunk graph
-	 */
-	static getChunkGraphForChunk(chunk, deprecateMessage, deprecationCode) {
-		const fn = deprecateGetChunkGraphForChunkMap.get(deprecateMessage);
-		if (fn) return fn(chunk);
-		const newFn = util.deprecate(
-			/**
-			 * @param {Chunk} chunk the chunk
-			 * @returns {ChunkGraph} the chunk graph
-			 */
-			chunk => {
-				const chunkGraph = chunkGraphForChunkMap.get(chunk);
-				if (!chunkGraph)
-					throw new Error(
-						deprecateMessage +
-							"There was no ChunkGraph assigned to the Chunk for backward-compat (Use the new API)"
-					);
-				return chunkGraph;
-			},
-			deprecateMessage + ": Use new ChunkGraph API",
-			deprecationCode
-		);
-		deprecateGetChunkGraphForChunkMap.set(deprecateMessage, newFn);
-		return newFn(chunk);
-	}
-
-	// TODO remove in webpack 6
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	static setChunkGraphForChunk(chunk, chunkGraph) {
-		chunkGraphForChunkMap.set(chunk, chunkGraph);
-	}
-
-	// TODO remove in webpack 6
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @returns {void}
-	 */
-	static clearChunkGraphForChunk(chunk) {
-		chunkGraphForChunkMap.delete(chunk);
-	}
-}
-
-// TODO remove in webpack 6
-/** @type {WeakMap<Module, ChunkGraph>} */
-const chunkGraphForModuleMap = new WeakMap();
-
-// TODO remove in webpack 6
-/** @type {WeakMap<Chunk, ChunkGraph>} */
-const chunkGraphForChunkMap = new WeakMap();
-
-// TODO remove in webpack 6
-/** @type {Map<string, (module: Module) => ChunkGraph>} */
-const deprecateGetChunkGraphForModuleMap = new Map();
-
-// TODO remove in webpack 6
-/** @type {Map<string, (chunk: Chunk) => ChunkGraph>} */
-const deprecateGetChunkGraphForChunkMap = new Map();
-
-module.exports = ChunkGraph;
+module.exports = ContextExclusionPlugin;
 
 
 /***/ }),
 
-/***/ 15626:
+/***/ 76729:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -27935,627 +29659,1087 @@ module.exports = ChunkGraph;
 
 
 
-const util = __webpack_require__(73837);
-const SortableSet = __webpack_require__(13098);
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const { makeWebpackError } = __webpack_require__(11351);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const WebpackError = __webpack_require__(53799);
 const {
 	compareLocations,
-	compareChunks,
-	compareIterables
+	concatComparators,
+	compareSelect,
+	keepOriginalOrder,
+	compareModulesById
 } = __webpack_require__(29579);
+const { contextify, parseResource } = __webpack_require__(82186);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Entrypoint")} Entrypoint */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
+/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {{id: number}} HasId */
-/** @typedef {{module: Module, loc: DependencyLocation, request: string}} OriginRecord */
+/** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
 
 /**
- * @typedef {Object} RawChunkGroupOptions
- * @property {number=} preloadOrder
- * @property {number=} prefetchOrder
+ * @typedef {Object} ContextOptions
+ * @property {ContextMode} mode
+ * @property {boolean} recursive
+ * @property {RegExp} regExp
+ * @property {"strict"|boolean=} namespaceObject
+ * @property {string=} addon
+ * @property {string=} chunkName
+ * @property {RegExp=} include
+ * @property {RegExp=} exclude
+ * @property {RawChunkGroupOptions=} groupOptions
+ * @property {string=} typePrefix
+ * @property {string=} category
+ * @property {string[][]=} referencedExports exports referenced from modules (won't be mangled)
  */
 
-/** @typedef {RawChunkGroupOptions & { name?: string }} ChunkGroupOptions */
-
-let debugId = 5000;
-
 /**
- * @template T
- * @param {SortableSet<T>} set set to convert to array.
- * @returns {T[]} the array format of existing set
+ * @typedef {Object} ContextModuleOptionsExtras
+ * @property {string} resource
+ * @property {string=} resourceQuery
+ * @property {string=} resourceFragment
+ * @property {TODO} resolveOptions
  */
-const getArray = set => Array.from(set);
+
+/** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */
 
 /**
- * A convenience method used to sort chunks based on their id's
- * @param {ChunkGroup} a first sorting comparator
- * @param {ChunkGroup} b second sorting comparator
- * @returns {1|0|-1} a sorting index to determine order
+ * @callback ResolveDependenciesCallback
+ * @param {(Error | null)=} err
+ * @param {ContextElementDependency[]=} dependencies
  */
-const sortById = (a, b) => {
-	if (a.id < b.id) return -1;
-	if (b.id < a.id) return 1;
-	return 0;
-};
 
 /**
- * @param {OriginRecord} a the first comparator in sort
- * @param {OriginRecord} b the second comparator in sort
- * @returns {1|-1|0} returns sorting order as index
+ * @callback ResolveDependencies
+ * @param {InputFileSystem} fs
+ * @param {ContextModuleOptions} options
+ * @param {ResolveDependenciesCallback} callback
  */
-const sortOrigin = (a, b) => {
-	const aIdent = a.module ? a.module.identifier() : "";
-	const bIdent = b.module ? b.module.identifier() : "";
-	if (aIdent < bIdent) return -1;
-	if (aIdent > bIdent) return 1;
-	return compareLocations(a.loc, b.loc);
-};
 
-class ChunkGroup {
+const SNAPSHOT_OPTIONS = { timestamp: true };
+
+const TYPES = new Set(["javascript"]);
+
+class ContextModule extends Module {
 	/**
-	 * Creates an instance of ChunkGroup.
-	 * @param {string|ChunkGroupOptions=} options chunk group options passed to chunkGroup
+	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
+	 * @param {ContextModuleOptions} options options object
 	 */
-	constructor(options) {
-		if (typeof options === "string") {
-			options = { name: options };
-		} else if (!options) {
-			options = { name: undefined };
+	constructor(resolveDependencies, options) {
+		const parsed = parseResource(options ? options.resource : "");
+		const resource = parsed.path;
+		const resourceQuery = (options && options.resourceQuery) || parsed.query;
+		const resourceFragment =
+			(options && options.resourceFragment) || parsed.fragment;
+
+		super("javascript/dynamic", resource);
+
+		// Info from Factory
+		this.resolveDependencies = resolveDependencies;
+		/** @type {ContextModuleOptions} */
+		this.options = {
+			...options,
+			resource,
+			resourceQuery,
+			resourceFragment
+		};
+		if (options && options.resolveOptions !== undefined) {
+			this.resolveOptions = options.resolveOptions;
 		}
-		/** @type {number} */
-		this.groupDebugId = debugId++;
-		this.options = options;
-		/** @type {SortableSet<ChunkGroup>} */
-		this._children = new SortableSet(undefined, sortById);
-		/** @type {SortableSet<ChunkGroup>} */
-		this._parents = new SortableSet(undefined, sortById);
-		/** @type {SortableSet<ChunkGroup>} */
-		this._asyncEntrypoints = new SortableSet(undefined, sortById);
-		this._blocks = new SortableSet();
-		/** @type {Chunk[]} */
-		this.chunks = [];
-		/** @type {OriginRecord[]} */
-		this.origins = [];
-		/** Indices in top-down order */
-		/** @private @type {Map<Module, number>} */
-		this._modulePreOrderIndices = new Map();
-		/** Indices in bottom-up order */
-		/** @private @type {Map<Module, number>} */
-		this._modulePostOrderIndices = new Map();
-		/** @type {number} */
-		this.index = undefined;
-	}
 
-	/**
-	 * when a new chunk is added to a chunkGroup, addingOptions will occur.
-	 * @param {ChunkGroupOptions} options the chunkGroup options passed to addOptions
-	 * @returns {void}
-	 */
-	addOptions(options) {
-		for (const key of Object.keys(options)) {
-			if (this.options[key] === undefined) {
-				this.options[key] = options[key];
-			} else if (this.options[key] !== options[key]) {
-				if (key.endsWith("Order")) {
-					this.options[key] = Math.max(this.options[key], options[key]);
-				} else {
-					throw new Error(
-						`ChunkGroup.addOptions: No option merge strategy for ${key}`
-					);
-				}
-			}
+		if (options && typeof options.mode !== "string") {
+			throw new Error("options.mode is a required option");
 		}
+
+		this._identifier = this._createIdentifier();
+		this._forceBuild = true;
 	}
 
 	/**
-	 * returns the name of current ChunkGroup
-	 * @returns {string|undefined} returns the ChunkGroup name
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	get name() {
-		return this.options.name;
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * sets a new name for current ChunkGroup
-	 * @param {string} value the new name for ChunkGroup
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
 	 * @returns {void}
 	 */
-	set name(value) {
-		this.options.name = value;
+	updateCacheModule(module) {
+		const m = /** @type {ContextModule} */ (module);
+		this.resolveDependencies = m.resolveDependencies;
+		this.options = m.options;
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * get a uniqueId for ChunkGroup, made up of its member Chunk debugId's
-	 * @returns {string} a unique concatenation of chunk debugId's
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
 	 */
-	get debugId() {
-		return Array.from(this.chunks, x => x.debugId).join("+");
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.resolveDependencies = undefined;
 	}
 
-	/**
-	 * get a unique id for ChunkGroup, made up of its member Chunk id's
-	 * @returns {string} a unique concatenation of chunk ids
-	 */
-	get id() {
-		return Array.from(this.chunks, x => x.id).join("+");
+	_prettyRegExp(regexString, stripSlash = true) {
+		const str = (regexString + "").replace(/!/g, "%21").replace(/\|/g, "%7C");
+		return stripSlash ? str.substring(1, str.length - 1) : str;
 	}
 
-	/**
-	 * Performs an unshift of a specific chunk
-	 * @param {Chunk} chunk chunk being unshifted
-	 * @returns {boolean} returns true if attempted chunk shift is accepted
-	 */
-	unshiftChunk(chunk) {
-		const oldIdx = this.chunks.indexOf(chunk);
-		if (oldIdx > 0) {
-			this.chunks.splice(oldIdx, 1);
-			this.chunks.unshift(chunk);
-		} else if (oldIdx < 0) {
-			this.chunks.unshift(chunk);
-			return true;
+	_createIdentifier() {
+		let identifier = this.context;
+		if (this.options.resourceQuery) {
+			identifier += `|${this.options.resourceQuery}`;
 		}
-		return false;
-	}
-
-	/**
-	 * inserts a chunk before another existing chunk in group
-	 * @param {Chunk} chunk Chunk being inserted
-	 * @param {Chunk} before Placeholder/target chunk marking new chunk insertion point
-	 * @returns {boolean} return true if insertion was successful
-	 */
-	insertChunk(chunk, before) {
-		const oldIdx = this.chunks.indexOf(chunk);
-		const idx = this.chunks.indexOf(before);
-		if (idx < 0) {
-			throw new Error("before chunk not found");
+		if (this.options.resourceFragment) {
+			identifier += `|${this.options.resourceFragment}`;
 		}
-		if (oldIdx >= 0 && oldIdx > idx) {
-			this.chunks.splice(oldIdx, 1);
-			this.chunks.splice(idx, 0, chunk);
-		} else if (oldIdx < 0) {
-			this.chunks.splice(idx, 0, chunk);
-			return true;
+		if (this.options.mode) {
+			identifier += `|${this.options.mode}`;
 		}
-		return false;
+		if (!this.options.recursive) {
+			identifier += "|nonrecursive";
+		}
+		if (this.options.addon) {
+			identifier += `|${this.options.addon}`;
+		}
+		if (this.options.regExp) {
+			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
+		}
+		if (this.options.include) {
+			identifier += `|include: ${this._prettyRegExp(
+				this.options.include,
+				false
+			)}`;
+		}
+		if (this.options.exclude) {
+			identifier += `|exclude: ${this._prettyRegExp(
+				this.options.exclude,
+				false
+			)}`;
+		}
+		if (this.options.referencedExports) {
+			identifier += `|referencedExports: ${JSON.stringify(
+				this.options.referencedExports
+			)}`;
+		}
+		if (this.options.chunkName) {
+			identifier += `|chunkName: ${this.options.chunkName}`;
+		}
+		if (this.options.groupOptions) {
+			identifier += `|groupOptions: ${JSON.stringify(
+				this.options.groupOptions
+			)}`;
+		}
+		if (this.options.namespaceObject === "strict") {
+			identifier += "|strict namespace object";
+		} else if (this.options.namespaceObject) {
+			identifier += "|namespace object";
+		}
+
+		return identifier;
 	}
 
 	/**
-	 * add a chunk into ChunkGroup. Is pushed on or prepended
-	 * @param {Chunk} chunk chunk being pushed into ChunkGroupS
-	 * @returns {boolean} returns true if chunk addition was successful.
+	 * @returns {string} a unique identifier of the module
 	 */
-	pushChunk(chunk) {
-		const oldIdx = this.chunks.indexOf(chunk);
-		if (oldIdx >= 0) {
-			return false;
-		}
-		this.chunks.push(chunk);
-		return true;
+	identifier() {
+		return this._identifier;
 	}
 
 	/**
-	 * @param {Chunk} oldChunk chunk to be replaced
-	 * @param {Chunk} newChunk New chunk that will be replaced with
-	 * @returns {boolean} returns true if the replacement was successful
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	replaceChunk(oldChunk, newChunk) {
-		const oldIdx = this.chunks.indexOf(oldChunk);
-		if (oldIdx < 0) return false;
-		const newIdx = this.chunks.indexOf(newChunk);
-		if (newIdx < 0) {
-			this.chunks[oldIdx] = newChunk;
-			return true;
+	readableIdentifier(requestShortener) {
+		let identifier = requestShortener.shorten(this.context) + "/";
+		if (this.options.resourceQuery) {
+			identifier += ` ${this.options.resourceQuery}`;
 		}
-		if (newIdx < oldIdx) {
-			this.chunks.splice(oldIdx, 1);
-			return true;
-		} else if (newIdx !== oldIdx) {
-			this.chunks[oldIdx] = newChunk;
-			this.chunks.splice(newIdx, 1);
-			return true;
+		if (this.options.mode) {
+			identifier += ` ${this.options.mode}`;
+		}
+		if (!this.options.recursive) {
+			identifier += " nonrecursive";
+		}
+		if (this.options.addon) {
+			identifier += ` ${requestShortener.shorten(this.options.addon)}`;
+		}
+		if (this.options.regExp) {
+			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		}
+		if (this.options.include) {
+			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
+		}
+		if (this.options.exclude) {
+			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+		}
+		if (this.options.referencedExports) {
+			identifier += ` referencedExports: ${this.options.referencedExports
+				.map(e => e.join("."))
+				.join(", ")}`;
+		}
+		if (this.options.chunkName) {
+			identifier += ` chunkName: ${this.options.chunkName}`;
+		}
+		if (this.options.groupOptions) {
+			const groupOptions = this.options.groupOptions;
+			for (const key of Object.keys(groupOptions)) {
+				identifier += ` ${key}: ${groupOptions[key]}`;
+			}
+		}
+		if (this.options.namespaceObject === "strict") {
+			identifier += " strict namespace object";
+		} else if (this.options.namespaceObject) {
+			identifier += " namespace object";
 		}
+
+		return identifier;
 	}
 
 	/**
-	 * @param {Chunk} chunk chunk to remove
-	 * @returns {boolean} returns true if chunk was removed
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	removeChunk(chunk) {
-		const idx = this.chunks.indexOf(chunk);
-		if (idx >= 0) {
-			this.chunks.splice(idx, 1);
-			return true;
+	libIdent(options) {
+		let identifier = contextify(
+			options.context,
+			this.context,
+			options.associatedObjectForCache
+		);
+		if (this.layer) identifier = `(${this.layer})/${identifier}`;
+		if (this.options.mode) {
+			identifier += ` ${this.options.mode}`;
 		}
-		return false;
+		if (this.options.recursive) {
+			identifier += " recursive";
+		}
+		if (this.options.addon) {
+			identifier += ` ${contextify(
+				options.context,
+				this.options.addon,
+				options.associatedObjectForCache
+			)}`;
+		}
+		if (this.options.regExp) {
+			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		}
+		if (this.options.include) {
+			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
+		}
+		if (this.options.exclude) {
+			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
+		}
+		if (this.options.referencedExports) {
+			identifier += ` referencedExports: ${this.options.referencedExports
+				.map(e => e.join("."))
+				.join(", ")}`;
+		}
+
+		return identifier;
 	}
 
 	/**
-	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
+	 * @returns {void}
 	 */
-	isInitial() {
-		return false;
+	invalidateBuild() {
+		this._forceBuild = true;
 	}
 
 	/**
-	 * @param {ChunkGroup} group chunk group to add
-	 * @returns {boolean} returns true if chunk group was added
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
 	 */
-	addChild(group) {
-		const size = this._children.size;
-		this._children.add(group);
-		return size !== this._children.size;
+	needBuild({ fileSystemInfo }, callback) {
+		// build if enforced
+		if (this._forceBuild) return callback(null, true);
+
+		// always build when we have no snapshot
+		if (!this.buildInfo.snapshot) return callback(null, true);
+
+		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+			callback(err, !valid);
+		});
 	}
 
 	/**
-	 * @returns {ChunkGroup[]} returns the children of this group
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
 	 */
-	getChildren() {
-		return this._children.getFromCache(getArray);
-	}
+	build(options, compilation, resolver, fs, callback) {
+		this._forceBuild = false;
+		/** @type {BuildMeta} */
+		this.buildMeta = {
+			exportsType: "default",
+			defaultObject: "redirect-warn"
+		};
+		this.buildInfo = {
+			snapshot: undefined
+		};
+		this.dependencies.length = 0;
+		this.blocks.length = 0;
+		const startTime = Date.now();
+		this.resolveDependencies(fs, this.options, (err, dependencies) => {
+			if (err) {
+				return callback(
+					makeWebpackError(err, "ContextModule.resolveDependencies")
+				);
+			}
 
-	getNumberOfChildren() {
-		return this._children.size;
-	}
+			// abort if something failed
+			// this will create an empty context
+			if (!dependencies) {
+				callback();
+				return;
+			}
 
-	get childrenIterable() {
-		return this._children;
+			// enhance dependencies with meta info
+			for (const dep of dependencies) {
+				dep.loc = {
+					name: dep.userRequest
+				};
+				dep.request = this.options.addon + dep.request;
+			}
+			dependencies.sort(
+				concatComparators(
+					compareSelect(a => a.loc, compareLocations),
+					keepOriginalOrder(this.dependencies)
+				)
+			);
+
+			if (this.options.mode === "sync" || this.options.mode === "eager") {
+				// if we have an sync or eager context
+				// just add all dependencies and continue
+				this.dependencies = dependencies;
+			} else if (this.options.mode === "lazy-once") {
+				// for the lazy-once mode create a new async dependency block
+				// and add that block to this context
+				if (dependencies.length > 0) {
+					const block = new AsyncDependenciesBlock({
+						...this.options.groupOptions,
+						name: this.options.chunkName
+					});
+					for (const dep of dependencies) {
+						block.addDependency(dep);
+					}
+					this.addBlock(block);
+				}
+			} else if (
+				this.options.mode === "weak" ||
+				this.options.mode === "async-weak"
+			) {
+				// we mark all dependencies as weak
+				for (const dep of dependencies) {
+					dep.weak = true;
+				}
+				this.dependencies = dependencies;
+			} else if (this.options.mode === "lazy") {
+				// if we are lazy create a new async dependency block per dependency
+				// and add all blocks to this context
+				let index = 0;
+				for (const dep of dependencies) {
+					let chunkName = this.options.chunkName;
+					if (chunkName) {
+						if (!/\[(index|request)\]/.test(chunkName)) {
+							chunkName += "[index]";
+						}
+						chunkName = chunkName.replace(/\[index\]/g, `${index++}`);
+						chunkName = chunkName.replace(
+							/\[request\]/g,
+							Template.toPath(dep.userRequest)
+						);
+					}
+					const block = new AsyncDependenciesBlock(
+						{
+							...this.options.groupOptions,
+							name: chunkName
+						},
+						dep.loc,
+						dep.userRequest
+					);
+					block.addDependency(dep);
+					this.addBlock(block);
+				}
+			} else {
+				callback(
+					new WebpackError(`Unsupported mode "${this.options.mode}" in context`)
+				);
+				return;
+			}
+			compilation.fileSystemInfo.createSnapshot(
+				startTime,
+				null,
+				[this.context],
+				null,
+				SNAPSHOT_OPTIONS,
+				(err, snapshot) => {
+					if (err) return callback(err);
+					this.buildInfo.snapshot = snapshot;
+					callback();
+				}
+			);
+		});
 	}
 
 	/**
-	 * @param {ChunkGroup} group the chunk group to remove
-	 * @returns {boolean} returns true if the chunk group was removed
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
 	 */
-	removeChild(group) {
-		if (!this._children.has(group)) {
-			return false;
-		}
-
-		this._children.delete(group);
-		group.removeParent(this);
-		return true;
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {
+		contextDependencies.add(this.context);
 	}
 
 	/**
-	 * @param {ChunkGroup} parentChunk the parent group to be added into
-	 * @returns {boolean} returns true if this chunk group was added to the parent group
+	 * @param {ContextElementDependency[]} dependencies all dependencies
+	 * @param {ChunkGraph} chunkGraph chunk graph
+	 * @returns {TODO} TODO
 	 */
-	addParent(parentChunk) {
-		if (!this._parents.has(parentChunk)) {
-			this._parents.add(parentChunk);
-			return true;
+	getUserRequestMap(dependencies, chunkGraph) {
+		const moduleGraph = chunkGraph.moduleGraph;
+		// if we filter first we get a new array
+		// therefore we don't need to create a clone of dependencies explicitly
+		// therefore the order of this is !important!
+		const sortedDependencies = dependencies
+			.filter(dependency => moduleGraph.getModule(dependency))
+			.sort((a, b) => {
+				if (a.userRequest === b.userRequest) {
+					return 0;
+				}
+				return a.userRequest < b.userRequest ? -1 : 1;
+			});
+		const map = Object.create(null);
+		for (const dep of sortedDependencies) {
+			const module = moduleGraph.getModule(dep);
+			map[dep.userRequest] = chunkGraph.getModuleId(module);
 		}
-		return false;
+		return map;
 	}
 
 	/**
-	 * @returns {ChunkGroup[]} returns the parents of this group
+	 * @param {ContextElementDependency[]} dependencies all dependencies
+	 * @param {ChunkGraph} chunkGraph chunk graph
+	 * @returns {TODO} TODO
 	 */
-	getParents() {
-		return this._parents.getFromCache(getArray);
-	}
-
-	getNumberOfParents() {
-		return this._parents.size;
+	getFakeMap(dependencies, chunkGraph) {
+		if (!this.options.namespaceObject) {
+			return 9;
+		}
+		const moduleGraph = chunkGraph.moduleGraph;
+		// bitfield
+		let hasType = 0;
+		const comparator = compareModulesById(chunkGraph);
+		// if we filter first we get a new array
+		// therefore we don't need to create a clone of dependencies explicitly
+		// therefore the order of this is !important!
+		const sortedModules = dependencies
+			.map(dependency => moduleGraph.getModule(dependency))
+			.filter(Boolean)
+			.sort(comparator);
+		const fakeMap = Object.create(null);
+		for (const module of sortedModules) {
+			const exportsType = module.getExportsType(
+				moduleGraph,
+				this.options.namespaceObject === "strict"
+			);
+			const id = chunkGraph.getModuleId(module);
+			switch (exportsType) {
+				case "namespace":
+					fakeMap[id] = 9;
+					hasType |= 1;
+					break;
+				case "dynamic":
+					fakeMap[id] = 7;
+					hasType |= 2;
+					break;
+				case "default-only":
+					fakeMap[id] = 1;
+					hasType |= 4;
+					break;
+				case "default-with-named":
+					fakeMap[id] = 3;
+					hasType |= 8;
+					break;
+				default:
+					throw new Error(`Unexpected exports type ${exportsType}`);
+			}
+		}
+		if (hasType === 1) {
+			return 9;
+		}
+		if (hasType === 2) {
+			return 7;
+		}
+		if (hasType === 4) {
+			return 1;
+		}
+		if (hasType === 8) {
+			return 3;
+		}
+		if (hasType === 0) {
+			return 9;
+		}
+		return fakeMap;
 	}
 
-	/**
-	 * @param {ChunkGroup} parent the parent group
-	 * @returns {boolean} returns true if the parent group contains this group
-	 */
-	hasParent(parent) {
-		return this._parents.has(parent);
+	getFakeMapInitStatement(fakeMap) {
+		return typeof fakeMap === "object"
+			? `var fakeMap = ${JSON.stringify(fakeMap, null, "\t")};`
+			: "";
 	}
 
-	get parentsIterable() {
-		return this._parents;
+	getReturn(type, asyncModule) {
+		if (type === 9) {
+			return "__webpack_require__(id)";
+		}
+		return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${
+			asyncModule ? " | 16" : ""
+		})`;
 	}
 
-	/**
-	 * @param {ChunkGroup} chunkGroup the parent group
-	 * @returns {boolean} returns true if this group has been removed from the parent
-	 */
-	removeParent(chunkGroup) {
-		if (this._parents.delete(chunkGroup)) {
-			chunkGroup.removeChild(this);
-			return true;
+	getReturnModuleObjectSource(
+		fakeMap,
+		asyncModule,
+		fakeMapDataExpression = "fakeMap[id]"
+	) {
+		if (typeof fakeMap === "number") {
+			return `return ${this.getReturn(fakeMap, asyncModule)};`;
 		}
-		return false;
+		return `return ${
+			RuntimeGlobals.createFakeNamespaceObject
+		}(id, ${fakeMapDataExpression}${asyncModule ? " | 16" : ""})`;
 	}
 
 	/**
-	 * @param {Entrypoint} entrypoint entrypoint to add
-	 * @returns {boolean} returns true if entrypoint was added
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string} source code
 	 */
-	addAsyncEntrypoint(entrypoint) {
-		const size = this._asyncEntrypoints.size;
-		this._asyncEntrypoints.add(entrypoint);
-		return size !== this._asyncEntrypoints.size;
-	}
+	getSyncSource(dependencies, id, chunkGraph) {
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
 
-	get asyncEntrypointsIterable() {
-		return this._asyncEntrypoints;
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	${returnModuleObject}
+}
+function webpackContextResolve(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+module.exports = webpackContext;
+webpackContext.id = ${JSON.stringify(id)};`;
 	}
 
 	/**
-	 * @returns {Array} an array containing the blocks
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string} source code
 	 */
-	getBlocks() {
-		return this._blocks.getFromCache(getArray);
-	}
+	getWeakSyncSource(dependencies, id, chunkGraph) {
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
 
-	getNumberOfBlocks() {
-		return this._blocks.size;
-	}
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
 
-	hasBlock(block) {
-		return this._blocks.has(block);
+function webpackContext(req) {
+	var id = webpackContextResolve(req);
+	if(!${RuntimeGlobals.moduleFactories}[id]) {
+		var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	${returnModuleObject}
+}
+function webpackContextResolve(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	}
+	return map[req];
+}
+webpackContext.keys = function webpackContextKeys() {
+	return Object.keys(map);
+};
+webpackContext.resolve = webpackContextResolve;
+webpackContext.id = ${JSON.stringify(id)};
+module.exports = webpackContext;`;
 	}
 
 	/**
-	 * @returns {Iterable<AsyncDependenciesBlock>} blocks
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} context context
+	 * @param {ChunkGraph} context.chunkGraph the chunk graph
+	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @returns {string} source code
 	 */
-	get blocksIterable() {
-		return this._blocks;
+	getAsyncWeakSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap, true);
+
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${
+		arrow ? "id =>" : "function(id)"
+	} {
+		if(!${RuntimeGlobals.moduleFactories}[id]) {
+			var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		${returnModuleObject}
+	});
+}
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		}
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
 	/**
-	 * @param {AsyncDependenciesBlock} block a block
-	 * @returns {boolean} false, if block was already added
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} context context
+	 * @param {ChunkGraph} context.chunkGraph the chunk graph
+	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @returns {string} source code
 	 */
-	addBlock(block) {
-		if (!this._blocks.has(block)) {
-			this._blocks.add(block);
-			return true;
+	getEagerSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const thenFunction =
+			fakeMap !== 9
+				? `${arrow ? "id =>" : "function(id)"} {
+		${this.getReturnModuleObjectSource(fakeMap)}
+	}`
+				: "__webpack_require__";
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
+
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${thenFunction});
+}
+function webpackAsyncContextResolve(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
 		}
-		return false;
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
 	/**
-	 * @param {Module} module origin module
-	 * @param {DependencyLocation} loc location of the reference in the origin module
-	 * @param {string} request request name of the reference
-	 * @returns {void}
+	 * @param {TODO} block TODO
+	 * @param {TODO} dependencies TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} options options object
+	 * @param {RuntimeTemplate} options.runtimeTemplate the runtime template
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @returns {string} source code
 	 */
-	addOrigin(module, loc, request) {
-		this.origins.push({
-			module,
-			loc,
-			request
+	getLazyOnceSource(block, dependencies, id, { runtimeTemplate, chunkGraph }) {
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block,
+			message: "lazy-once context",
+			runtimeRequirements: new Set()
 		});
-	}
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		const map = this.getUserRequestMap(dependencies, chunkGraph);
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const thenFunction =
+			fakeMap !== 9
+				? `${arrow ? "id =>" : "function(id)"} {
+		${this.getReturnModuleObjectSource(fakeMap, true)};
+	}`
+				: "__webpack_require__";
 
-	/**
-	 * @returns {string[]} the files contained this chunk group
-	 */
-	getFiles() {
-		const files = new Set();
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap)}
 
-		for (const chunk of this.chunks) {
-			for (const file of chunk.files) {
-				files.add(file);
-			}
+function webpackAsyncContext(req) {
+	return webpackAsyncContextResolve(req).then(${thenFunction});
+}
+function webpackAsyncContextResolve(req) {
+	return ${promise}.then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
 		}
-
-		return Array.from(files);
+		return map[req];
+	});
+}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.resolve = webpackAsyncContextResolve;
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
 	/**
-	 * @returns {void}
+	 * @param {TODO} blocks TODO
+	 * @param {TODO} id TODO
+	 * @param {Object} context context
+	 * @param {ChunkGraph} context.chunkGraph the chunk graph
+	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
+	 * @returns {string} source code
 	 */
-	remove() {
-		// cleanup parents
-		for (const parentChunkGroup of this._parents) {
-			// remove this chunk from its parents
-			parentChunkGroup._children.delete(this);
-
-			// cleanup "sub chunks"
-			for (const chunkGroup of this._children) {
-				/**
-				 * remove this chunk as "intermediary" and connect
-				 * it "sub chunks" and parents directly
-				 */
-				// add parent to each "sub chunk"
-				chunkGroup.addParent(parentChunkGroup);
-				// add "sub chunk" to parent
-				parentChunkGroup.addChild(chunkGroup);
+	getLazySource(blocks, id, { chunkGraph, runtimeTemplate }) {
+		const moduleGraph = chunkGraph.moduleGraph;
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		let hasMultipleOrNoChunks = false;
+		let hasNoChunk = true;
+		const fakeMap = this.getFakeMap(
+			blocks.map(b => b.dependencies[0]),
+			chunkGraph
+		);
+		const hasFakeMap = typeof fakeMap === "object";
+		const items = blocks
+			.map(block => {
+				const dependency = block.dependencies[0];
+				return {
+					dependency: dependency,
+					module: moduleGraph.getModule(dependency),
+					block: block,
+					userRequest: dependency.userRequest,
+					chunks: undefined
+				};
+			})
+			.filter(item => item.module);
+		for (const item of items) {
+			const chunkGroup = chunkGraph.getBlockChunkGroup(item.block);
+			const chunks = (chunkGroup && chunkGroup.chunks) || [];
+			item.chunks = chunks;
+			if (chunks.length > 0) {
+				hasNoChunk = false;
+			}
+			if (chunks.length !== 1) {
+				hasMultipleOrNoChunks = true;
 			}
 		}
-
-		/**
-		 * we need to iterate again over the children
-		 * to remove this from the child's parents.
-		 * This can not be done in the above loop
-		 * as it is not guaranteed that `this._parents` contains anything.
-		 */
-		for (const chunkGroup of this._children) {
-			// remove this as parent of every "sub chunk"
-			chunkGroup._parents.delete(this);
+		const shortMode = hasNoChunk && !hasFakeMap;
+		const sortedItems = items.sort((a, b) => {
+			if (a.userRequest === b.userRequest) return 0;
+			return a.userRequest < b.userRequest ? -1 : 1;
+		});
+		const map = Object.create(null);
+		for (const item of sortedItems) {
+			const moduleId = chunkGraph.getModuleId(item.module);
+			if (shortMode) {
+				map[item.userRequest] = moduleId;
+			} else {
+				const arrayStart = [moduleId];
+				if (hasFakeMap) {
+					arrayStart.push(fakeMap[moduleId]);
+				}
+				map[item.userRequest] = arrayStart.concat(
+					item.chunks.map(chunk => chunk.id)
+				);
+			}
 		}
 
-		// remove chunks
-		for (const chunk of this.chunks) {
-			chunk.removeGroup(this);
+		const chunksStartPosition = hasFakeMap ? 2 : 1;
+		const requestPrefix = hasNoChunk
+			? "Promise.resolve()"
+			: hasMultipleOrNoChunks
+			? `Promise.all(ids.slice(${chunksStartPosition}).map(${RuntimeGlobals.ensureChunk}))`
+			: `${RuntimeGlobals.ensureChunk}(ids[${chunksStartPosition}])`;
+		const returnModuleObject = this.getReturnModuleObjectSource(
+			fakeMap,
+			true,
+			shortMode ? "invalid" : "ids[1]"
+		);
+
+		const webpackAsyncContext =
+			requestPrefix === "Promise.resolve()"
+				? `
+function webpackAsyncContext(req) {
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
 		}
+
+		${shortMode ? "var id = map[req];" : "var ids = map[req], id = ids[0];"}
+		${returnModuleObject}
+	});
+}`
+				: `function webpackAsyncContext(req) {
+	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
+		return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+			var e = new Error("Cannot find module '" + req + "'");
+			e.code = 'MODULE_NOT_FOUND';
+			throw e;
+		});
 	}
 
-	sortItems() {
-		this.origins.sort(sortOrigin);
+	var ids = map[req], id = ids[0];
+	return ${requestPrefix}.then(${arrow ? "() =>" : "function()"} {
+		${returnModuleObject}
+	});
+}`;
+
+		return `var map = ${JSON.stringify(map, null, "\t")};
+${webpackAsyncContext}
+webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
+			"Object.keys(map)"
+		)};
+webpackAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackAsyncContext;`;
 	}
 
-	/**
-	 * Sorting predicate which allows current ChunkGroup to be compared against another.
-	 * Sorting values are based off of number of chunks in ChunkGroup.
-	 *
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkGroup} otherGroup the chunkGroup to compare this against
-	 * @returns {-1|0|1} sort position for comparison
-	 */
-	compareTo(chunkGraph, otherGroup) {
-		if (this.chunks.length > otherGroup.chunks.length) return -1;
-		if (this.chunks.length < otherGroup.chunks.length) return 1;
-		return compareIterables(compareChunks(chunkGraph))(
-			this.chunks,
-			otherGroup.chunks
-		);
+	getSourceForEmptyContext(id, runtimeTemplate) {
+		return `function webpackEmptyContext(req) {
+	var e = new Error("Cannot find module '" + req + "'");
+	e.code = 'MODULE_NOT_FOUND';
+	throw e;
+}
+webpackEmptyContext.keys = ${runtimeTemplate.returningFunction("[]")};
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = ${JSON.stringify(id)};
+module.exports = webpackEmptyContext;`;
+	}
+
+	getSourceForEmptyAsyncContext(id, runtimeTemplate) {
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		return `function webpackEmptyAsyncContext(req) {
+	// Here Promise.resolve().then() is used instead of new Promise() to prevent
+	// uncaught exception popping up in devtools
+	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
+		var e = new Error("Cannot find module '" + req + "'");
+		e.code = 'MODULE_NOT_FOUND';
+		throw e;
+	});
+}
+webpackEmptyAsyncContext.keys = ${runtimeTemplate.returningFunction("[]")};
+webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
+webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
+module.exports = webpackEmptyAsyncContext;`;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {Record<string, ChunkGroup[]>} mapping from children type to ordered list of ChunkGroups
+	 * @param {string} asyncMode module mode
+	 * @param {CodeGenerationContext} context context info
+	 * @returns {string} the source code
 	 */
-	getChildrenByOrders(moduleGraph, chunkGraph) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
-		const lists = new Map();
-		for (const childGroup of this._children) {
-			for (const key of Object.keys(childGroup.options)) {
-				if (key.endsWith("Order")) {
-					const name = key.substr(0, key.length - "Order".length);
-					let list = lists.get(name);
-					if (list === undefined) {
-						lists.set(name, (list = []));
-					}
-					list.push({
-						order: childGroup.options[key],
-						group: childGroup
-					});
-				}
+	getSourceString(asyncMode, { runtimeTemplate, chunkGraph }) {
+		const id = chunkGraph.getModuleId(this);
+		if (asyncMode === "lazy") {
+			if (this.blocks && this.blocks.length > 0) {
+				return this.getLazySource(this.blocks, id, {
+					runtimeTemplate,
+					chunkGraph
+				});
 			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		/** @type {Record<string, ChunkGroup[]>} */
-		const result = Object.create(null);
-		for (const [name, list] of lists) {
-			list.sort((a, b) => {
-				const cmp = b.order - a.order;
-				if (cmp !== 0) return cmp;
-				return a.group.compareTo(chunkGraph, b.group);
-			});
-			result[name] = list.map(i => i.group);
+		if (asyncMode === "eager") {
+			if (this.dependencies && this.dependencies.length > 0) {
+				return this.getEagerSource(this.dependencies, id, {
+					chunkGraph,
+					runtimeTemplate
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		return result;
-	}
-
-	/**
-	 * Sets the top-down index of a module in this ChunkGroup
-	 * @param {Module} module module for which the index should be set
-	 * @param {number} index the index of the module
-	 * @returns {void}
-	 */
-	setModulePreOrderIndex(module, index) {
-		this._modulePreOrderIndices.set(module, index);
+		if (asyncMode === "lazy-once") {
+			const block = this.blocks[0];
+			if (block) {
+				return this.getLazyOnceSource(block, block.dependencies, id, {
+					runtimeTemplate,
+					chunkGraph
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+		}
+		if (asyncMode === "async-weak") {
+			if (this.dependencies && this.dependencies.length > 0) {
+				return this.getAsyncWeakSource(this.dependencies, id, {
+					chunkGraph,
+					runtimeTemplate
+				});
+			}
+			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+		}
+		if (asyncMode === "weak") {
+			if (this.dependencies && this.dependencies.length > 0) {
+				return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
+			}
+		}
+		if (this.dependencies && this.dependencies.length > 0) {
+			return this.getSyncSource(this.dependencies, id, chunkGraph);
+		}
+		return this.getSourceForEmptyContext(id, runtimeTemplate);
 	}
 
-	/**
-	 * Gets the top-down index of a module in this ChunkGroup
-	 * @param {Module} module the module
-	 * @returns {number} index
-	 */
-	getModulePreOrderIndex(module) {
-		return this._modulePreOrderIndices.get(module);
+	getSource(sourceString) {
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			return new OriginalSource(sourceString, this.identifier());
+		}
+		return new RawSource(sourceString);
 	}
 
 	/**
-	 * Sets the bottom-up index of a module in this ChunkGroup
-	 * @param {Module} module module for which the index should be set
-	 * @param {number} index the index of the module
-	 * @returns {void}
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	setModulePostOrderIndex(module, index) {
-		this._modulePostOrderIndices.set(module, index);
-	}
-
-	/**
-	 * Gets the bottom-up index of a module in this ChunkGroup
-	 * @param {Module} module the module
-	 * @returns {number} index
-	 */
-	getModulePostOrderIndex(module) {
-		return this._modulePostOrderIndices.get(module);
-	}
-
-	/* istanbul ignore next */
-	checkConstraints() {
-		const chunk = this;
-		for (const child of chunk._children) {
-			if (!child._parents.has(chunk)) {
-				throw new Error(
-					`checkConstraints: child missing parent ${chunk.debugId} -> ${child.debugId}`
-				);
+	codeGeneration(context) {
+		const { chunkGraph } = context;
+		const sources = new Map();
+		sources.set(
+			"javascript",
+			this.getSource(this.getSourceString(this.options.mode, context))
+		);
+		const set = new Set();
+		const allDeps = /** @type {ContextElementDependency[]} */ (
+			this.dependencies.concat(this.blocks.map(b => b.dependencies[0]))
+		);
+		set.add(RuntimeGlobals.module);
+		set.add(RuntimeGlobals.hasOwnProperty);
+		if (allDeps.length > 0) {
+			const asyncMode = this.options.mode;
+			set.add(RuntimeGlobals.require);
+			if (asyncMode === "weak") {
+				set.add(RuntimeGlobals.moduleFactories);
+			} else if (asyncMode === "async-weak") {
+				set.add(RuntimeGlobals.moduleFactories);
+				set.add(RuntimeGlobals.ensureChunk);
+			} else if (asyncMode === "lazy" || asyncMode === "lazy-once") {
+				set.add(RuntimeGlobals.ensureChunk);
 			}
-		}
-		for (const parentChunk of chunk._parents) {
-			if (!parentChunk._children.has(chunk)) {
-				throw new Error(
-					`checkConstraints: parent missing child ${parentChunk.debugId} <- ${chunk.debugId}`
-				);
+			if (this.getFakeMap(allDeps, chunkGraph) !== 9) {
+				set.add(RuntimeGlobals.createFakeNamespaceObject);
 			}
 		}
+		return {
+			sources,
+			runtimeRequirements: set
+		};
 	}
-}
-
-ChunkGroup.prototype.getModuleIndex = util.deprecate(
-	ChunkGroup.prototype.getModulePreOrderIndex,
-	"ChunkGroup.getModuleIndex was renamed to getModulePreOrderIndex",
-	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX"
-);
-
-ChunkGroup.prototype.getModuleIndex2 = util.deprecate(
-	ChunkGroup.prototype.getModulePostOrderIndex,
-	"ChunkGroup.getModuleIndex2 was renamed to getModulePostOrderIndex",
-	"DEP_WEBPACK_CHUNK_GROUP_GET_MODULE_INDEX_2"
-);
-
-module.exports = ChunkGroup;
-
-
-/***/ }),
-
-/***/ 918:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
-
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Chunk")} Chunk */
-
-class ChunkRenderError extends WebpackError {
 	/**
-	 * Create a new ChunkRenderError
-	 * @param {Chunk} chunk A chunk
-	 * @param {string} file Related file
-	 * @param {Error} error Original error
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	constructor(chunk, file, error) {
-		super();
+	size(type) {
+		// base penalty
+		let size = 160;
 
-		this.name = "ChunkRenderError";
-		this.error = error;
-		this.message = error.message;
-		this.details = error.stack;
-		this.file = file;
-		this.chunk = chunk;
+		// if we don't have dependencies we stop here.
+		for (const dependency of this.dependencies) {
+			const element = /** @type {ContextElementDependency} */ (dependency);
+			size += 5 + element.userRequest.length;
+		}
+		return size;
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this._identifier);
+		write(this._forceBuild);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this._identifier = read();
+		this._forceBuild = read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = ChunkRenderError;
+makeSerializable(ContextModule, "webpack/lib/ContextModule");
+
+module.exports = ContextModule;
 
 
 /***/ }),
 
-/***/ 46341:
+/***/ 62471:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -28566,524 +30750,397 @@ module.exports = ChunkRenderError;
 
 
 
-const util = __webpack_require__(73837);
-const memoize = __webpack_require__(78676);
+const asyncLib = __webpack_require__(78175);
+const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = __webpack_require__(6967);
+const ContextModule = __webpack_require__(76729);
+const ModuleFactory = __webpack_require__(51010);
+const ContextElementDependency = __webpack_require__(58477);
+const LazySet = __webpack_require__(38938);
+const { cachedSetProperty } = __webpack_require__(60839);
+const { createFakeHook } = __webpack_require__(64518);
+const { join } = __webpack_require__(17139);
 
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
+/** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ResolverFactory")} ResolverFactory */
+/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
+/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-const getJavascriptModulesPlugin = memoize(() =>
-	__webpack_require__(89464)
-);
+const EMPTY_RESOLVE_OPTIONS = {};
 
-// TODO webpack 6 remove this class
-class ChunkTemplate {
+module.exports = class ContextModuleFactory extends ModuleFactory {
 	/**
-	 * @param {OutputOptions} outputOptions output options
-	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverFactory} resolverFactory resolverFactory
 	 */
-	constructor(outputOptions, compilation) {
-		this._outputOptions = outputOptions || {};
+	constructor(resolverFactory) {
+		super();
+		/** @type {AsyncSeriesWaterfallHook<[TODO[], ContextModuleOptions]>} */
+		const alternativeRequests = new AsyncSeriesWaterfallHook([
+			"modules",
+			"options"
+		]);
 		this.hooks = Object.freeze({
-			renderManifest: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.renderManifest.tap(
-							options,
-							(entries, options) => {
-								if (options.chunk.hasRuntime()) return entries;
-								return fn(entries, options);
-							}
+			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
+			beforeResolve: new AsyncSeriesWaterfallHook(["data"]),
+			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
+			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
+			/** @type {SyncWaterfallHook<[string[]]>} */
+			contextModuleFiles: new SyncWaterfallHook(["files"]),
+			/** @type {FakeHook<Pick<AsyncSeriesWaterfallHook<[TODO[]]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+			alternatives: createFakeHook(
+				{
+					name: "alternatives",
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["intercept"]} */
+					intercept: interceptor => {
+						throw new Error(
+							"Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead"
 						);
 					},
-					"ChunkTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_MANIFEST"
-				)
-			},
-			modules: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderChunk.tap(options, (source, renderContext) =>
-								fn(
-									source,
-									compilation.moduleTemplates.javascript,
-									renderContext
-								)
-							);
-					},
-					"ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_MODULES"
-				)
-			},
-			render: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderChunk.tap(options, (source, renderContext) =>
-								fn(
-									source,
-									compilation.moduleTemplates.javascript,
-									renderContext
-								)
-							);
-					},
-					"ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER"
-				)
-			},
-			renderWithEntry: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
-								if (
-									renderContext.chunkGraph.getNumberOfEntryModules(
-										renderContext.chunk
-									) === 0 ||
-									renderContext.chunk.hasRuntime()
-								) {
-									return source;
-								}
-								return fn(source, renderContext.chunk);
-							});
-					},
-					"ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY"
-				)
-			},
-			hash: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.fullHash.tap(options, fn);
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tap"]} */
+					tap: (options, fn) => {
+						alternativeRequests.tap(options, fn);
 					},
-					"ChunkTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH"
-				)
-			},
-			hashForChunk: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.chunkHash.tap(options, (chunk, hash, context) => {
-								if (chunk.hasRuntime()) return;
-								fn(hash, chunk, context);
-							});
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapAsync"]} */
+					tapAsync: (options, fn) => {
+						alternativeRequests.tapAsync(options, (items, _options, callback) =>
+							fn(items, callback)
+						);
 					},
-					"ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
-					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			}
+					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapPromise"]} */
+					tapPromise: (options, fn) => {
+						alternativeRequests.tapPromise(options, fn);
+					}
+				},
+				"ContextModuleFactory.hooks.alternatives has deprecated in favor of ContextModuleFactory.hooks.alternativeRequests with an additional options argument.",
+				"DEP_WEBPACK_CONTEXT_MODULE_FACTORY_ALTERNATIVES"
+			),
+			alternativeRequests
 		});
+		this.resolverFactory = resolverFactory;
 	}
-}
-
-Object.defineProperty(ChunkTemplate.prototype, "outputOptions", {
-	get: util.deprecate(
-		/**
-		 * @this {ChunkTemplate}
-		 * @returns {OutputOptions} output options
-		 */
-		function () {
-			return this._outputOptions;
-		},
-		"ChunkTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
-		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
-	)
-});
-
-module.exports = ChunkTemplate;
-
 
-/***/ }),
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const context = data.context;
+		const dependencies = data.dependencies;
+		const resolveOptions = data.resolveOptions;
+		const dependency = /** @type {ContextDependency} */ (dependencies[0]);
+		const fileDependencies = new LazySet();
+		const missingDependencies = new LazySet();
+		const contextDependencies = new LazySet();
+		this.hooks.beforeResolve.callAsync(
+			{
+				context: context,
+				dependencies: dependencies,
+				resolveOptions,
+				fileDependencies,
+				missingDependencies,
+				contextDependencies,
+				...dependency.options
+			},
+			(err, beforeResolveResult) => {
+				if (err) {
+					return callback(err, {
+						fileDependencies,
+						missingDependencies,
+						contextDependencies
+					});
+				}
 
-/***/ 31085:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				// Ignored
+				if (!beforeResolveResult) {
+					return callback(null, {
+						fileDependencies,
+						missingDependencies,
+						contextDependencies
+					});
+				}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
+				const context = beforeResolveResult.context;
+				const request = beforeResolveResult.request;
+				const resolveOptions = beforeResolveResult.resolveOptions;
 
+				let loaders,
+					resource,
+					loadersPrefix = "";
+				const idx = request.lastIndexOf("!");
+				if (idx >= 0) {
+					let loadersRequest = request.substr(0, idx + 1);
+					let i;
+					for (
+						i = 0;
+						i < loadersRequest.length && loadersRequest[i] === "!";
+						i++
+					) {
+						loadersPrefix += "!";
+					}
+					loadersRequest = loadersRequest
+						.substr(i)
+						.replace(/!+$/, "")
+						.replace(/!!+/g, "!");
+					if (loadersRequest === "") {
+						loaders = [];
+					} else {
+						loaders = loadersRequest.split("!");
+					}
+					resource = request.substr(idx + 1);
+				} else {
+					loaders = [];
+					resource = request;
+				}
 
+				const contextResolver = this.resolverFactory.get(
+					"context",
+					dependencies.length > 0
+						? cachedSetProperty(
+								resolveOptions || EMPTY_RESOLVE_OPTIONS,
+								"dependencyType",
+								dependencies[0].category
+						  )
+						: resolveOptions
+				);
+				const loaderResolver = this.resolverFactory.get("loader");
 
-const asyncLib = __webpack_require__(78175);
-const { SyncBailHook } = __webpack_require__(41242);
-const Compilation = __webpack_require__(85720);
-const createSchemaValidation = __webpack_require__(32540);
-const { join } = __webpack_require__(17139);
-const processAsyncTree = __webpack_require__(42791);
+				asyncLib.parallel(
+					[
+						callback => {
+							contextResolver.resolve(
+								{},
+								context,
+								resource,
+								{
+									fileDependencies,
+									missingDependencies,
+									contextDependencies
+								},
+								(err, result) => {
+									if (err) return callback(err);
+									callback(null, result);
+								}
+							);
+						},
+						callback => {
+							asyncLib.map(
+								loaders,
+								(loader, callback) => {
+									loaderResolver.resolve(
+										{},
+										context,
+										loader,
+										{
+											fileDependencies,
+											missingDependencies,
+											contextDependencies
+										},
+										(err, result) => {
+											if (err) return callback(err);
+											callback(null, result);
+										}
+									);
+								},
+								callback
+							);
+						}
+					],
+					(err, result) => {
+						if (err) {
+							return callback(err, {
+								fileDependencies,
+								missingDependencies,
+								contextDependencies
+							});
+						}
 
-/** @typedef {import("../declarations/WebpackOptions").CleanOptions} CleanOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").StatsCallback} StatsCallback */
+						this.hooks.afterResolve.callAsync(
+							{
+								addon:
+									loadersPrefix +
+									result[1].join("!") +
+									(result[1].length > 0 ? "!" : ""),
+								resource: result[0],
+								resolveDependencies: this.resolveDependencies.bind(this),
+								...beforeResolveResult
+							},
+							(err, result) => {
+								if (err) {
+									return callback(err, {
+										fileDependencies,
+										missingDependencies,
+										contextDependencies
+									});
+								}
 
-/** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
-/** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
+								// Ignored
+								if (!result) {
+									return callback(null, {
+										fileDependencies,
+										missingDependencies,
+										contextDependencies
+									});
+								}
 
-/**
- * @typedef {Object} CleanPluginCompilationHooks
- * @property {SyncBailHook<[string], boolean>} keep when returning true the file/directory will be kept during cleaning, returning false will clean it and ignore the following plugins and config
- */
+								return callback(null, {
+									module: new ContextModule(result.resolveDependencies, result),
+									fileDependencies,
+									missingDependencies,
+									contextDependencies
+								});
+							}
+						);
+					}
+				);
+			}
+		);
+	}
 
-const validate = createSchemaValidation(
-	undefined,
-	() => {
-		const { definitions } = __webpack_require__(73342);
-		return {
-			definitions,
-			oneOf: [{ $ref: "#/definitions/CleanOptions" }]
-		};
-	},
-	{
-		name: "Clean Plugin",
-		baseDataPath: "options"
-	}
-);
+	/**
+	 * @param {InputFileSystem} fs file system
+	 * @param {ContextModuleOptions} options options
+	 * @param {ResolveDependenciesCallback} callback callback function
+	 * @returns {void}
+	 */
+	resolveDependencies(fs, options, callback) {
+		const cmf = this;
+		const {
+			resource,
+			resourceQuery,
+			resourceFragment,
+			recursive,
+			regExp,
+			include,
+			exclude,
+			referencedExports,
+			category,
+			typePrefix
+		} = options;
+		if (!regExp || !resource) return callback(null, []);
 
-/**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} outputPath output path
- * @param {Set<string>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
- * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
- * @returns {void}
- */
-const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
-	const directories = new Set();
-	// get directories of assets
-	for (const asset of currentAssets) {
-		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
-	}
-	// and all parent directories
-	for (const directory of directories) {
-		directories.add(directory.replace(/(^|\/)[^/]*$/, ""));
-	}
-	const diff = new Set();
-	asyncLib.forEachLimit(
-		directories,
-		10,
-		(directory, callback) => {
-			fs.readdir(join(fs, outputPath, directory), (err, entries) => {
-				if (err) {
-					if (err.code === "ENOENT") return callback();
-					if (err.code === "ENOTDIR") {
-						diff.add(directory);
-						return callback();
-					}
-					return callback(err);
-				}
-				for (const entry of entries) {
-					const file = /** @type {string} */ (entry);
-					const filename = directory ? `${directory}/${file}` : file;
-					if (!directories.has(filename) && !currentAssets.has(filename)) {
-						diff.add(filename);
-					}
-				}
-				callback();
+		const addDirectoryChecked = (directory, visited, callback) => {
+			fs.realpath(directory, (err, realPath) => {
+				if (err) return callback(err);
+				if (visited.has(realPath)) return callback(null, []);
+				let recursionStack;
+				addDirectory(
+					directory,
+					(dir, callback) => {
+						if (recursionStack === undefined) {
+							recursionStack = new Set(visited);
+							recursionStack.add(realPath);
+						}
+						addDirectoryChecked(dir, recursionStack, callback);
+					},
+					callback
+				);
 			});
-		},
-		err => {
-			if (err) return callback(err);
-
-			callback(null, diff);
-		}
-	);
-};
-
-/**
- * @param {Set<string>} currentAssets assets list
- * @param {Set<string>} oldAssets old assets list
- * @returns {Set<string>} diff
- */
-const getDiffToOldAssets = (currentAssets, oldAssets) => {
-	const diff = new Set();
-	for (const asset of oldAssets) {
-		if (!currentAssets.has(asset)) diff.add(asset);
-	}
-	return diff;
-};
+		};
 
-/**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} filename path to file
- * @param {StatsCallback} callback callback for provided filename
- * @returns {void}
- */
-const doStat = (fs, filename, callback) => {
-	if ("lstat" in fs) {
-		fs.lstat(filename, callback);
-	} else {
-		fs.stat(filename, callback);
-	}
-};
+		const addDirectory = (directory, addSubDirectory, callback) => {
+			fs.readdir(directory, (err, files) => {
+				if (err) return callback(err);
+				const processedFiles = cmf.hooks.contextModuleFiles.call(
+					/** @type {string[]} */ (files).map(file => file.normalize("NFC"))
+				);
+				if (!processedFiles || processedFiles.length === 0)
+					return callback(null, []);
+				asyncLib.map(
+					processedFiles.filter(p => p.indexOf(".") !== 0),
+					(segment, callback) => {
+						const subResource = join(fs, directory, segment);
 
-/**
- * @param {OutputFileSystem} fs filesystem
- * @param {string} outputPath output path
- * @param {boolean} dry only log instead of fs modification
- * @param {Logger} logger logger
- * @param {Set<string>} diff filenames of the assets that shouldn't be there
- * @param {function(string): boolean} isKept check if the entry is ignored
- * @param {function(Error=): void} callback callback
- * @returns {void}
- */
-const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
-	const log = msg => {
-		if (dry) {
-			logger.info(msg);
-		} else {
-			logger.log(msg);
-		}
-	};
-	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
-	/** @type {Job[]} */
-	const jobs = Array.from(diff, filename => ({
-		type: "check",
-		filename,
-		parent: undefined
-	}));
-	processAsyncTree(
-		jobs,
-		10,
-		({ type, filename, parent }, push, callback) => {
-			const handleError = err => {
-				if (err.code === "ENOENT") {
-					log(`${filename} was removed during cleaning by something else`);
-					handleParent();
-					return callback();
-				}
-				return callback(err);
-			};
-			const handleParent = () => {
-				if (parent && --parent.remaining === 0) push(parent.job);
-			};
-			const path = join(fs, outputPath, filename);
-			switch (type) {
-				case "check":
-					if (isKept(filename)) {
-						// do not decrement parent entry as we don't want to delete the parent
-						log(`${filename} will be kept`);
-						return process.nextTick(callback);
-					}
-					doStat(fs, path, (err, stats) => {
-						if (err) return handleError(err);
-						if (!stats.isDirectory()) {
-							push({
-								type: "unlink",
-								filename,
-								parent
-							});
-							return callback();
-						}
-						fs.readdir(path, (err, entries) => {
-							if (err) return handleError(err);
-							/** @type {Job} */
-							const deleteJob = {
-								type: "rmdir",
-								filename,
-								parent
-							};
-							if (entries.length === 0) {
-								push(deleteJob);
-							} else {
-								const parentToken = {
-									remaining: entries.length,
-									job: deleteJob
-								};
-								for (const entry of entries) {
-									const file = /** @type {string} */ (entry);
-									if (file.startsWith(".")) {
-										log(
-											`${filename} will be kept (dot-files will never be removed)`
-										);
-										continue;
+						if (!exclude || !subResource.match(exclude)) {
+							fs.stat(subResource, (err, stat) => {
+								if (err) {
+									if (err.code === "ENOENT") {
+										// ENOENT is ok here because the file may have been deleted between
+										// the readdir and stat calls.
+										return callback();
+									} else {
+										return callback(err);
 									}
-									push({
-										type: "check",
-										filename: `${filename}/${file}`,
-										parent: parentToken
-									});
 								}
-							}
-							return callback();
-						});
-					});
-					break;
-				case "rmdir":
-					log(`${filename} will be removed`);
-					if (dry) {
-						handleParent();
-						return process.nextTick(callback);
-					}
-					if (!fs.rmdir) {
-						logger.warn(
-							`${filename} can't be removed because output file system doesn't support removing directories (rmdir)`
-						);
-						return process.nextTick(callback);
-					}
-					fs.rmdir(path, err => {
-						if (err) return handleError(err);
-						handleParent();
-						callback();
-					});
-					break;
-				case "unlink":
-					log(`${filename} will be removed`);
-					if (dry) {
-						handleParent();
-						return process.nextTick(callback);
-					}
-					if (!fs.unlink) {
-						logger.warn(
-							`${filename} can't be removed because output file system doesn't support removing files (rmdir)`
-						);
-						return process.nextTick(callback);
-					}
-					fs.unlink(path, err => {
-						if (err) return handleError(err);
-						handleParent();
-						callback();
-					});
-					break;
-			}
-		},
-		callback
-	);
-};
-
-/** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class CleanPlugin {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CleanPluginCompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				/** @type {SyncBailHook<[string], boolean>} */
-				keep: new SyncBailHook(["ignore"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/** @param {CleanOptions} options options */
-	constructor(options = {}) {
-		validate(options);
-		this.options = { dry: false, ...options };
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { dry, keep } = this.options;
-
-		const keepFn =
-			typeof keep === "function"
-				? keep
-				: typeof keep === "string"
-				? path => path.startsWith(keep)
-				: typeof keep === "object" && keep.test
-				? path => keep.test(path)
-				: () => false;
-
-		// We assume that no external modification happens while the compiler is active
-		// So we can store the old assets and only diff to them to avoid fs access on
-		// incremental builds
-		let oldAssets;
 
-		compiler.hooks.emit.tapAsync(
-			{
-				name: "CleanPlugin",
-				stage: 100
-			},
-			(compilation, callback) => {
-				const hooks = CleanPlugin.getCompilationHooks(compilation);
-				const logger = compilation.getLogger("webpack.CleanPlugin");
-				const fs = compiler.outputFileSystem;
+								if (stat.isDirectory()) {
+									if (!recursive) return callback();
+									addSubDirectory(subResource, callback);
+								} else if (
+									stat.isFile() &&
+									(!include || subResource.match(include))
+								) {
+									const obj = {
+										context: resource,
+										request:
+											"." +
+											subResource.substr(resource.length).replace(/\\/g, "/")
+									};
 
-				if (!fs.readdir) {
-					return callback(
-						new Error(
-							"CleanPlugin: Output filesystem doesn't support listing directories (readdir)"
-						)
-					);
-				}
+									this.hooks.alternativeRequests.callAsync(
+										[obj],
+										options,
+										(err, alternatives) => {
+											if (err) return callback(err);
+											alternatives = alternatives
+												.filter(obj => regExp.test(obj.request))
+												.map(obj => {
+													const dep = new ContextElementDependency(
+														obj.request + resourceQuery + resourceFragment,
+														obj.request,
+														typePrefix,
+														category,
+														referencedExports
+													);
+													dep.optional = true;
+													return dep;
+												});
+											callback(null, alternatives);
+										}
+									);
+								} else {
+									callback();
+								}
+							});
+						} else {
+							callback();
+						}
+					},
+					(err, result) => {
+						if (err) return callback(err);
 
-				const currentAssets = new Set();
-				for (const asset of Object.keys(compilation.assets)) {
-					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
-					let normalizedAsset;
-					let newNormalizedAsset = asset.replace(/\\/g, "/");
-					do {
-						normalizedAsset = newNormalizedAsset;
-						newNormalizedAsset = normalizedAsset.replace(
-							/(^|\/)(?!\.\.)[^/]+\/\.\.\//g,
-							"$1"
-						);
-					} while (newNormalizedAsset !== normalizedAsset);
-					if (normalizedAsset.startsWith("../")) continue;
-					currentAssets.add(normalizedAsset);
-				}
+						if (!result) return callback(null, []);
 
-				const outputPath = compilation.getPath(compiler.outputPath, {});
+						const flattenedResult = [];
 
-				const isKept = path => {
-					const result = hooks.keep.call(path);
-					if (result !== undefined) return result;
-					return keepFn(path);
-				};
+						for (const item of result) {
+							if (item) flattenedResult.push(...item);
+						}
 
-				const diffCallback = (err, diff) => {
-					if (err) {
-						oldAssets = undefined;
-						return callback(err);
+						callback(null, flattenedResult);
 					}
-					applyDiff(fs, outputPath, dry, logger, diff, isKept, err => {
-						if (err) {
-							oldAssets = undefined;
-						} else {
-							oldAssets = currentAssets;
-						}
-						callback(err);
-					});
-				};
+				);
+			});
+		};
 
-				if (oldAssets) {
-					diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets));
-				} else {
-					getDiffToFs(fs, outputPath, currentAssets, diffCallback);
-				}
-			}
-		);
+		if (typeof fs.realpath === "function") {
+			addDirectoryChecked(resource, new Set(), callback);
+		} else {
+			const addSubDirectory = (dir, callback) =>
+				addDirectory(dir, addSubDirectory, callback);
+			addDirectory(resource, addSubDirectory, callback);
+		}
 	}
-}
-
-module.exports = CleanPlugin;
+};
 
 
 /***/ }),
 
-/***/ 2102:
+/***/ 12206:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -29094,34 +31151,162 @@ module.exports = CleanPlugin;
 
 
 
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Module")} Module */
+const ContextElementDependency = __webpack_require__(58477);
+const { join } = __webpack_require__(17139);
 
-class CodeGenerationError extends WebpackError {
-	/**
-	 * Create a new CodeGenerationError
-	 * @param {Module} module related module
-	 * @param {Error} error Original error
-	 */
-	constructor(module, error) {
-		super();
+class ContextReplacementPlugin {
+	constructor(
+		resourceRegExp,
+		newContentResource,
+		newContentRecursive,
+		newContentRegExp
+	) {
+		this.resourceRegExp = resourceRegExp;
 
-		this.name = "CodeGenerationError";
-		this.error = error;
-		this.message = error.message;
-		this.details = error.stack;
-		this.module = module;
+		if (typeof newContentResource === "function") {
+			this.newContentCallback = newContentResource;
+		} else if (
+			typeof newContentResource === "string" &&
+			typeof newContentRecursive === "object"
+		) {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = (fs, callback) => {
+				callback(null, newContentRecursive);
+			};
+		} else if (
+			typeof newContentResource === "string" &&
+			typeof newContentRecursive === "function"
+		) {
+			this.newContentResource = newContentResource;
+			this.newContentCreateContextMap = newContentRecursive;
+		} else {
+			if (typeof newContentResource !== "string") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = newContentResource;
+				newContentResource = undefined;
+			}
+			if (typeof newContentRecursive !== "boolean") {
+				newContentRegExp = newContentRecursive;
+				newContentRecursive = undefined;
+			}
+			this.newContentResource = newContentResource;
+			this.newContentRecursive = newContentRecursive;
+			this.newContentRegExp = newContentRegExp;
+		}
 	}
-}
-
-module.exports = CodeGenerationError;
-
 
-/***/ }),
+	apply(compiler) {
+		const resourceRegExp = this.resourceRegExp;
+		const newContentCallback = this.newContentCallback;
+		const newContentResource = this.newContentResource;
+		const newContentRecursive = this.newContentRecursive;
+		const newContentRegExp = this.newContentRegExp;
+		const newContentCreateContextMap = this.newContentCreateContextMap;
 
-/***/ 71426:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
+			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
+				if (!result) return;
+				if (resourceRegExp.test(result.request)) {
+					if (newContentResource !== undefined) {
+						result.request = newContentResource;
+					}
+					if (newContentRecursive !== undefined) {
+						result.recursive = newContentRecursive;
+					}
+					if (newContentRegExp !== undefined) {
+						result.regExp = newContentRegExp;
+					}
+					if (typeof newContentCallback === "function") {
+						newContentCallback(result);
+					} else {
+						for (const d of result.dependencies) {
+							if (d.critical) d.critical = false;
+						}
+					}
+				}
+				return result;
+			});
+			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
+				if (!result) return;
+				if (resourceRegExp.test(result.resource)) {
+					if (newContentResource !== undefined) {
+						if (
+							newContentResource.startsWith("/") ||
+							(newContentResource.length > 1 && newContentResource[1] === ":")
+						) {
+							result.resource = newContentResource;
+						} else {
+							result.resource = join(
+								compiler.inputFileSystem,
+								result.resource,
+								newContentResource
+							);
+						}
+					}
+					if (newContentRecursive !== undefined) {
+						result.recursive = newContentRecursive;
+					}
+					if (newContentRegExp !== undefined) {
+						result.regExp = newContentRegExp;
+					}
+					if (typeof newContentCreateContextMap === "function") {
+						result.resolveDependencies =
+							createResolveDependenciesFromContextMap(
+								newContentCreateContextMap
+							);
+					}
+					if (typeof newContentCallback === "function") {
+						const origResource = result.resource;
+						newContentCallback(result);
+						if (
+							result.resource !== origResource &&
+							!result.resource.startsWith("/") &&
+							(result.resource.length <= 1 || result.resource[1] !== ":")
+						) {
+							// When the function changed it to an relative path
+							result.resource = join(
+								compiler.inputFileSystem,
+								origResource,
+								result.resource
+							);
+						}
+					} else {
+						for (const d of result.dependencies) {
+							if (d.critical) d.critical = false;
+						}
+					}
+				}
+				return result;
+			});
+		});
+	}
+}
+
+const createResolveDependenciesFromContextMap = createContextMap => {
+	const resolveDependenciesFromContextMap = (fs, options, callback) => {
+		createContextMap(fs, (err, map) => {
+			if (err) return callback(err);
+			const dependencies = Object.keys(map).map(key => {
+				return new ContextElementDependency(
+					map[key] + options.resourceQuery + options.resourceFragment,
+					key,
+					options.category,
+					options.referencedExports
+				);
+			});
+			callback(null, dependencies);
+		});
+	};
+	return resolveDependenciesFromContextMap;
+};
+
+module.exports = ContextReplacementPlugin;
+
+
+/***/ }),
+
+/***/ 79065:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -29131,360 +31316,605 @@ module.exports = CodeGenerationError;
 
 
 
-const { provide } = __webpack_require__(82482);
-const { first } = __webpack_require__(93347);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const ConstDependency = __webpack_require__(76911);
+const BasicEvaluatedExpression = __webpack_require__(950);
+const {
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
 const createHash = __webpack_require__(49835);
-const { runtimeToString, RuntimeSpecMap } = __webpack_require__(17156);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {typeof import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./NormalModule")} NormalModule */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-class CodeGenerationResults {
+/** @typedef {null|undefined|RegExp|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
+/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive|RuntimeValue>} CodeValue */
+
+/**
+ * @typedef {Object} RuntimeValueOptions
+ * @property {string[]=} fileDependencies
+ * @property {string[]=} contextDependencies
+ * @property {string[]=} missingDependencies
+ * @property {string[]=} buildDependencies
+ * @property {string|function(): string=} version
+ */
+
+class RuntimeValue {
 	/**
-	 * @param {string | Hash} hashFunction the hash function to use
+	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
+	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 */
-	constructor(hashFunction = "md4") {
-		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
-		this.map = new Map();
-		this._hashFunction = hashFunction;
+	constructor(fn, options) {
+		this.fn = fn;
+		if (Array.isArray(options)) {
+			options = {
+				fileDependencies: options
+			};
+		}
+		this.options = options || {};
+	}
+
+	get fileDependencies() {
+		return this.options === true ? true : this.options.fileDependencies;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {CodeGenerationResult} the CodeGenerationResult
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+	 * @param {string} key the defined key
+	 * @returns {CodeValuePrimitive} code
 	 */
-	get(module, runtime) {
-		const entry = this.map.get(module);
-		if (entry === undefined) {
-			throw new Error(
-				`No code generation entry for ${module.identifier()} (existing entries: ${Array.from(
-					this.map.keys(),
-					m => m.identifier()
-				).join(", ")})`
-			);
-		}
-		if (runtime === undefined) {
-			if (entry.size > 1) {
-				const results = new Set(entry.values());
-				if (results.size !== 1) {
-					throw new Error(
-						`No unique code generation entry for unspecified runtime for ${module.identifier()} (existing runtimes: ${Array.from(
-							entry.keys(),
-							r => runtimeToString(r)
-						).join(", ")}).
-Caller might not support runtime-dependent code generation (opt-out via optimization.usedExports: "global").`
-					);
+	exec(parser, valueCacheVersions, key) {
+		const buildInfo = parser.state.module.buildInfo;
+		if (this.options === true) {
+			buildInfo.cacheable = false;
+		} else {
+			if (this.options.fileDependencies) {
+				for (const dep of this.options.fileDependencies) {
+					buildInfo.fileDependencies.add(dep);
+				}
+			}
+			if (this.options.contextDependencies) {
+				for (const dep of this.options.contextDependencies) {
+					buildInfo.contextDependencies.add(dep);
+				}
+			}
+			if (this.options.missingDependencies) {
+				for (const dep of this.options.missingDependencies) {
+					buildInfo.missingDependencies.add(dep);
+				}
+			}
+			if (this.options.buildDependencies) {
+				for (const dep of this.options.buildDependencies) {
+					buildInfo.buildDependencies.add(dep);
 				}
-				return first(results);
 			}
-			return entry.values().next().value;
-		}
-		const result = entry.get(runtime);
-		if (result === undefined) {
-			throw new Error(
-				`No code generation entry for runtime ${runtimeToString(
-					runtime
-				)} for ${module.identifier()} (existing runtimes: ${Array.from(
-					entry.keys(),
-					r => runtimeToString(r)
-				).join(", ")})`
-			);
 		}
-		return result;
+
+		return this.fn({
+			module: parser.state.module,
+			key,
+			get version() {
+				return /** @type {string} */ (
+					valueCacheVersions.get(VALUE_DEP_PREFIX + key)
+				);
+			}
+		});
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {boolean} true, when we have data for this
-	 */
-	has(module, runtime) {
-		const entry = this.map.get(module);
-		if (entry === undefined) {
-			return false;
-		}
-		if (runtime !== undefined) {
-			return entry.has(runtime);
-		} else if (entry.size > 1) {
-			const results = new Set(entry.values());
-			return results.size === 1;
-		} else {
-			return entry.size === 1;
-		}
+	getCacheVersion() {
+		return this.options === true
+			? undefined
+			: (typeof this.options.version === "function"
+					? this.options.version()
+					: this.options.version) || "unset";
 	}
+}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {string} sourceType the source type
-	 * @returns {Source} a source
-	 */
-	getSource(module, runtime, sourceType) {
-		return this.get(module, runtime).sources.get(sourceType);
+/**
+ * @param {any[]|{[k: string]: any}} obj obj
+ * @param {JavascriptParser} parser Parser
+ * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+ * @param {string} key the defined key
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @returns {string} code converted to string that evaluates
+ */
+const stringifyObj = (
+	obj,
+	parser,
+	valueCacheVersions,
+	key,
+	runtimeTemplate,
+	asiSafe
+) => {
+	let code;
+	let arr = Array.isArray(obj);
+	if (arr) {
+		code = `[${obj
+			.map(code =>
+				toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
+			)
+			.join(",")}]`;
+	} else {
+		code = `{${Object.keys(obj)
+			.map(key => {
+				const code = obj[key];
+				return (
+					JSON.stringify(key) +
+					":" +
+					toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
+				);
+			})
+			.join(",")}}`;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {ReadonlySet<string>} runtime requirements
-	 */
-	getRuntimeRequirements(module, runtime) {
-		return this.get(module, runtime).runtimeRequirements;
+	switch (asiSafe) {
+		case null:
+			return code;
+		case true:
+			return arr ? code : `(${code})`;
+		case false:
+			return arr ? `;${code}` : `;(${code})`;
+		default:
+			return `/*#__PURE__*/Object(${code})`;
+	}
+};
+
+/**
+ * Convert code to a string that evaluates
+ * @param {CodeValue} code Code to evaluate
+ * @param {JavascriptParser} parser Parser
+ * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
+ * @param {string} key the defined key
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
+ * @returns {string} code converted to string that evaluates
+ */
+const toCode = (
+	code,
+	parser,
+	valueCacheVersions,
+	key,
+	runtimeTemplate,
+	asiSafe
+) => {
+	if (code === null) {
+		return "null";
+	}
+	if (code === undefined) {
+		return "undefined";
+	}
+	if (Object.is(code, -0)) {
+		return "-0";
+	}
+	if (code instanceof RuntimeValue) {
+		return toCode(
+			code.exec(parser, valueCacheVersions, key),
+			parser,
+			valueCacheVersions,
+			key,
+			runtimeTemplate,
+			asiSafe
+		);
+	}
+	if (code instanceof RegExp && code.toString) {
+		return code.toString();
+	}
+	if (typeof code === "function" && code.toString) {
+		return "(" + code.toString() + ")";
+	}
+	if (typeof code === "object") {
+		return stringifyObj(
+			code,
+			parser,
+			valueCacheVersions,
+			key,
+			runtimeTemplate,
+			asiSafe
+		);
+	}
+	if (typeof code === "bigint") {
+		return runtimeTemplate.supportsBigIntLiteral()
+			? `${code}n`
+			: `BigInt("${code}")`;
+	}
+	return code + "";
+};
+
+const toCacheVersion = code => {
+	if (code === null) {
+		return "null";
+	}
+	if (code === undefined) {
+		return "undefined";
+	}
+	if (Object.is(code, -0)) {
+		return "-0";
+	}
+	if (code instanceof RuntimeValue) {
+		return code.getCacheVersion();
+	}
+	if (code instanceof RegExp && code.toString) {
+		return code.toString();
+	}
+	if (typeof code === "function" && code.toString) {
+		return "(" + code.toString() + ")";
 	}
+	if (typeof code === "object") {
+		const items = Object.keys(code).map(key => ({
+			key,
+			value: toCacheVersion(code[key])
+		}));
+		if (items.some(({ value }) => value === undefined)) return undefined;
+		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
+	}
+	if (typeof code === "bigint") {
+		return `${code}n`;
+	}
+	return code + "";
+};
+
+const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
+const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
 
+class DefinePlugin {
 	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {string} key data key
-	 * @returns {any} data generated by code generation
+	 * Create a new define plugin
+	 * @param {Record<string, CodeValue>} definitions A map of global object definitions
 	 */
-	getData(module, runtime, key) {
-		const data = this.get(module, runtime).data;
-		return data === undefined ? undefined : data.get(key);
+	constructor(definitions) {
+		this.definitions = definitions;
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @returns {any} hash of the code generation
+	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
+	 * @param {true | string[] | RuntimeValueOptions=} options options
+	 * @returns {RuntimeValue} runtime value
 	 */
-	getHash(module, runtime) {
-		const info = this.get(module, runtime);
-		if (info.hash !== undefined) return info.hash;
-		const hash = createHash(this._hashFunction);
-		for (const [type, source] of info.sources) {
-			hash.update(type);
-			source.updateHash(hash);
-		}
-		if (info.runtimeRequirements) {
-			for (const rr of info.runtimeRequirements) hash.update(rr);
-		}
-		return (info.hash = /** @type {string} */ (hash.digest("hex")));
+	static runtimeValue(fn, options) {
+		return new RuntimeValue(fn, options);
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime runtime(s)
-	 * @param {CodeGenerationResult} result result from module
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	add(module, runtime, result) {
-		const map = provide(this.map, module, () => new RuntimeSpecMap());
-		map.set(runtime, result);
-	}
-}
-
-module.exports = CodeGenerationResults;
-
-
-/***/ }),
+	apply(compiler) {
+		const definitions = this.definitions;
+		compiler.hooks.compilation.tap(
+			"DefinePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				const { runtimeTemplate } = compilation;
 
-/***/ 98427:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				const mainHash = createHash(compilation.outputOptions.hashFunction);
+				mainHash.update(
+					/** @type {string} */ (
+						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
+					) || ""
+				);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				/**
+				 * Handler
+				 * @param {JavascriptParser} parser Parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
+					parser.hooks.program.tap("DefinePlugin", () => {
+						const { buildInfo } = parser.state.module;
+						if (!buildInfo.valueDependencies)
+							buildInfo.valueDependencies = new Map();
+						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
+					});
 
+					const addValueDependency = key => {
+						const { buildInfo } = parser.state.module;
+						buildInfo.valueDependencies.set(
+							VALUE_DEP_PREFIX + key,
+							compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)
+						);
+					};
 
+					const withValueDependency =
+						(key, fn) =>
+						(...args) => {
+							addValueDependency(key);
+							return fn(...args);
+						};
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-
-class CommentCompilationWarning extends WebpackError {
-	/**
-	 *
-	 * @param {string} message warning message
-	 * @param {DependencyLocation} loc affected lines of code
-	 */
-	constructor(message, loc) {
-		super(message);
-
-		this.name = "CommentCompilationWarning";
-
-		this.loc = loc;
-	}
-}
-
-makeSerializable(
-	CommentCompilationWarning,
-	"webpack/lib/CommentCompilationWarning"
-);
-
-module.exports = CommentCompilationWarning;
-
-
-/***/ }),
-
-/***/ 94258:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ConstDependency = __webpack_require__(76911);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-
-const nestedWebpackRequireTag = Symbol("nested __webpack_require__");
-
-class CompatibilityPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"CompatibilityPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("CompatibilityPlugin", (parser, parserOptions) => {
-						if (
-							parserOptions.browserify !== undefined &&
-							!parserOptions.browserify
-						)
-							return;
+					/**
+					 * Walk definitions
+					 * @param {Object} definitions Definitions map
+					 * @param {string} prefix Prefix string
+					 * @returns {void}
+					 */
+					const walkDefinitions = (definitions, prefix) => {
+						Object.keys(definitions).forEach(key => {
+							const code = definitions[key];
+							if (
+								code &&
+								typeof code === "object" &&
+								!(code instanceof RuntimeValue) &&
+								!(code instanceof RegExp)
+							) {
+								walkDefinitions(code, prefix + key + ".");
+								applyObjectDefine(prefix + key, code);
+								return;
+							}
+							applyDefineKey(prefix, key);
+							applyDefine(prefix + key, code);
+						});
+					};
 
-						parser.hooks.call
-							.for("require")
-							.tap("CompatibilityPlugin", expr => {
-								// support for browserify style require delegator: "require(o, !0)"
-								if (expr.arguments.length !== 2) return;
-								const second = parser.evaluateExpression(expr.arguments[1]);
-								if (!second.isBoolean()) return;
-								if (second.asBool() !== true) return;
-								const dep = new ConstDependency("require", expr.callee.range);
-								dep.loc = expr.loc;
-								if (parser.state.current.dependencies.length > 0) {
-									const last =
-										parser.state.current.dependencies[
-											parser.state.current.dependencies.length - 1
-										];
-									if (
-										last.critical &&
-										last.options &&
-										last.options.request === "." &&
-										last.userRequest === "." &&
-										last.options.recursive
-									)
-										parser.state.current.dependencies.pop();
-								}
-								parser.state.module.addPresentationalDependency(dep);
+					/**
+					 * Apply define key
+					 * @param {string} prefix Prefix
+					 * @param {string} key Key
+					 * @returns {void}
+					 */
+					const applyDefineKey = (prefix, key) => {
+						const splittedKey = key.split(".");
+						splittedKey.slice(1).forEach((_, i) => {
+							const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
+							parser.hooks.canRename.for(fullKey).tap("DefinePlugin", () => {
+								addValueDependency(key);
 								return true;
 							});
-					});
+						});
+					};
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					// Handle nested requires
-					parser.hooks.preStatement.tap("CompatibilityPlugin", statement => {
-						if (
-							statement.type === "FunctionDeclaration" &&
-							statement.id &&
-							statement.id.name === "__webpack_require__"
-						) {
-							const newName = `__nested_webpack_require_${statement.range[0]}__`;
-							parser.tagVariable(statement.id.name, nestedWebpackRequireTag, {
-								name: newName,
-								declaration: {
-									updated: false,
-									loc: statement.id.loc,
-									range: statement.id.range
-								}
+					/**
+					 * Apply Code
+					 * @param {string} key Key
+					 * @param {CodeValue} code Code
+					 * @returns {void}
+					 */
+					const applyDefine = (key, code) => {
+						const originalKey = key;
+						const isTypeof = /^typeof\s+/.test(key);
+						if (isTypeof) key = key.replace(/^typeof\s+/, "");
+						let recurse = false;
+						let recurseTypeof = false;
+						if (!isTypeof) {
+							parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
+								addValueDependency(originalKey);
+								return true;
 							});
-							return true;
-						}
-					});
-					parser.hooks.pattern
-						.for("__webpack_require__")
-						.tap("CompatibilityPlugin", pattern => {
-							const newName = `__nested_webpack_require_${pattern.range[0]}__`;
-							parser.tagVariable(pattern.name, nestedWebpackRequireTag, {
-								name: newName,
-								declaration: {
-									updated: false,
-									loc: pattern.loc,
-									range: pattern.range
+							parser.hooks.evaluateIdentifier
+								.for(key)
+								.tap("DefinePlugin", expr => {
+									/**
+									 * this is needed in case there is a recursion in the DefinePlugin
+									 * to prevent an endless recursion
+									 * e.g.: new DefinePlugin({
+									 * "a": "b",
+									 * "b": "a"
+									 * });
+									 */
+									if (recurse) return;
+									addValueDependency(originalKey);
+									recurse = true;
+									const res = parser.evaluate(
+										toCode(
+											code,
+											parser,
+											compilation.valueCacheVersions,
+											key,
+											runtimeTemplate,
+											null
+										)
+									);
+									recurse = false;
+									res.setRange(expr.range);
+									return res;
+								});
+							parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
+								addValueDependency(originalKey);
+								const strCode = toCode(
+									code,
+									parser,
+									compilation.valueCacheVersions,
+									originalKey,
+									runtimeTemplate,
+									!parser.isAsiPosition(expr.range[0])
+								);
+								if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
+									return toConstantDependency(parser, strCode, [
+										RuntimeGlobals.require
+									])(expr);
+								} else if (/__webpack_require__/.test(strCode)) {
+									return toConstantDependency(parser, strCode, [
+										RuntimeGlobals.requireScope
+									])(expr);
+								} else {
+									return toConstantDependency(parser, strCode)(expr);
 								}
 							});
-							return true;
+						}
+						parser.hooks.evaluateTypeof.for(key).tap("DefinePlugin", expr => {
+							/**
+							 * this is needed in case there is a recursion in the DefinePlugin
+							 * to prevent an endless recursion
+							 * e.g.: new DefinePlugin({
+							 * "typeof a": "typeof b",
+							 * "typeof b": "typeof a"
+							 * });
+							 */
+							if (recurseTypeof) return;
+							recurseTypeof = true;
+							addValueDependency(originalKey);
+							const codeCode = toCode(
+								code,
+								parser,
+								compilation.valueCacheVersions,
+								originalKey,
+								runtimeTemplate,
+								null
+							);
+							const typeofCode = isTypeof
+								? codeCode
+								: "typeof (" + codeCode + ")";
+							const res = parser.evaluate(typeofCode);
+							recurseTypeof = false;
+							res.setRange(expr.range);
+							return res;
 						});
-					parser.hooks.expression
-						.for(nestedWebpackRequireTag)
-						.tap("CompatibilityPlugin", expr => {
-							const { name, declaration } = parser.currentTagData;
-							if (!declaration.updated) {
-								const dep = new ConstDependency(name, declaration.range);
-								dep.loc = declaration.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								declaration.updated = true;
-							}
-							const dep = new ConstDependency(name, expr.range);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
+						parser.hooks.typeof.for(key).tap("DefinePlugin", expr => {
+							addValueDependency(originalKey);
+							const codeCode = toCode(
+								code,
+								parser,
+								compilation.valueCacheVersions,
+								originalKey,
+								runtimeTemplate,
+								null
+							);
+							const typeofCode = isTypeof
+								? codeCode
+								: "typeof (" + codeCode + ")";
+							const res = parser.evaluate(typeofCode);
+							if (!res.isString()) return;
+							return toConstantDependency(
+								parser,
+								JSON.stringify(res.string)
+							).bind(parser)(expr);
+						});
+					};
+
+					/**
+					 * Apply Object
+					 * @param {string} key Key
+					 * @param {Object} obj Object
+					 * @returns {void}
+					 */
+					const applyObjectDefine = (key, obj) => {
+						parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
+							addValueDependency(key);
 							return true;
 						});
+						parser.hooks.evaluateIdentifier
+							.for(key)
+							.tap("DefinePlugin", expr => {
+								addValueDependency(key);
+								return new BasicEvaluatedExpression()
+									.setTruthy()
+									.setSideEffects(false)
+									.setRange(expr.range);
+							});
+						parser.hooks.evaluateTypeof
+							.for(key)
+							.tap(
+								"DefinePlugin",
+								withValueDependency(key, evaluateToString("object"))
+							);
+						parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
+							addValueDependency(key);
+							const strCode = stringifyObj(
+								obj,
+								parser,
+								compilation.valueCacheVersions,
+								key,
+								runtimeTemplate,
+								!parser.isAsiPosition(expr.range[0])
+							);
 
-					// Handle hashbang
-					parser.hooks.program.tap(
-						"CompatibilityPlugin",
-						(program, comments) => {
-							if (comments.length === 0) return;
-							const c = comments[0];
-							if (c.type === "Line" && c.range[0] === 0) {
-								if (parser.state.source.slice(0, 2).toString() !== "#!") return;
-								// this is a hashbang comment
-								const dep = new ConstDependency("//", 0);
-								dep.loc = c.loc;
-								parser.state.module.addPresentationalDependency(dep);
+							if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
+								return toConstantDependency(parser, strCode, [
+									RuntimeGlobals.require
+								])(expr);
+							} else if (/__webpack_require__/.test(strCode)) {
+								return toConstantDependency(parser, strCode, [
+									RuntimeGlobals.requireScope
+								])(expr);
+							} else {
+								return toConstantDependency(parser, strCode)(expr);
 							}
-						}
-					);
+						});
+						parser.hooks.typeof
+							.for(key)
+							.tap(
+								"DefinePlugin",
+								withValueDependency(
+									key,
+									toConstantDependency(parser, JSON.stringify("object"))
+								)
+							);
+					};
+
+					walkDefinitions(definitions, "");
 				};
 
 				normalModuleFactory.hooks.parser
 					.for("javascript/auto")
-					.tap("CompatibilityPlugin", handler);
+					.tap("DefinePlugin", handler);
 				normalModuleFactory.hooks.parser
 					.for("javascript/dynamic")
-					.tap("CompatibilityPlugin", handler);
+					.tap("DefinePlugin", handler);
 				normalModuleFactory.hooks.parser
 					.for("javascript/esm")
-					.tap("CompatibilityPlugin", handler);
+					.tap("DefinePlugin", handler);
+
+				/**
+				 * Walk definitions
+				 * @param {Object} definitions Definitions map
+				 * @param {string} prefix Prefix string
+				 * @returns {void}
+				 */
+				const walkDefinitionsForValues = (definitions, prefix) => {
+					Object.keys(definitions).forEach(key => {
+						const code = definitions[key];
+						const version = toCacheVersion(code);
+						const name = VALUE_DEP_PREFIX + prefix + key;
+						mainHash.update("|" + prefix + key);
+						const oldVersion = compilation.valueCacheVersions.get(name);
+						if (oldVersion === undefined) {
+							compilation.valueCacheVersions.set(name, version);
+						} else if (oldVersion !== version) {
+							const warning = new WebpackError(
+								`DefinePlugin\nConflicting values for '${prefix + key}'`
+							);
+							warning.details = `'${oldVersion}' !== '${version}'`;
+							warning.hideStack = true;
+							compilation.warnings.push(warning);
+						}
+						if (
+							code &&
+							typeof code === "object" &&
+							!(code instanceof RuntimeValue) &&
+							!(code instanceof RegExp)
+						) {
+							walkDefinitionsForValues(code, prefix + key + ".");
+						}
+					});
+				};
+
+				walkDefinitionsForValues(definitions, "");
+
+				compilation.valueCacheVersions.set(
+					VALUE_DEP_MAIN,
+					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
+				);
 			}
 		);
 	}
 }
-module.exports = CompatibilityPlugin;
+module.exports = DefinePlugin;
 
 
 /***/ }),
 
-/***/ 85720:
+/***/ 28623:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -29495,8845 +31925,8623 @@ module.exports = CompatibilityPlugin;
 
 
 
-const asyncLib = __webpack_require__(78175);
-const {
-	HookMap,
-	SyncHook,
-	SyncBailHook,
-	SyncWaterfallHook,
-	AsyncSeriesHook,
-	AsyncSeriesBailHook,
-	AsyncParallelHook
-} = __webpack_require__(41242);
-const util = __webpack_require__(73837);
-const { CachedSource } = __webpack_require__(51255);
-const { MultiItemCache } = __webpack_require__(55392);
-const Chunk = __webpack_require__(39385);
-const ChunkGraph = __webpack_require__(64971);
-const ChunkGroup = __webpack_require__(15626);
-const ChunkRenderError = __webpack_require__(918);
-const ChunkTemplate = __webpack_require__(46341);
-const CodeGenerationError = __webpack_require__(2102);
-const CodeGenerationResults = __webpack_require__(71426);
-const Dependency = __webpack_require__(54912);
-const DependencyTemplates = __webpack_require__(9163);
-const Entrypoint = __webpack_require__(13795);
-const ErrorHelpers = __webpack_require__(59985);
-const FileSystemInfo = __webpack_require__(79453);
-const {
-	connectChunkGroupAndChunk,
-	connectChunkGroupParentAndChild
-} = __webpack_require__(37234);
-const {
-	makeWebpackError,
-	tryRunOrWebpackError
-} = __webpack_require__(11351);
-const MainTemplate = __webpack_require__(12856);
+const { OriginalSource, RawSource } = __webpack_require__(51255);
 const Module = __webpack_require__(73208);
-const ModuleDependencyError = __webpack_require__(67409);
-const ModuleDependencyWarning = __webpack_require__(29656);
-const ModuleGraph = __webpack_require__(99988);
-const ModuleNotFoundError = __webpack_require__(32882);
-const ModuleProfile = __webpack_require__(36418);
-const ModuleRestoreError = __webpack_require__(94560);
-const ModuleStoreError = __webpack_require__(59001);
-const ModuleTemplate = __webpack_require__(62677);
 const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeTemplate = __webpack_require__(18777);
-const Stats = __webpack_require__(31743);
-const WebpackError = __webpack_require__(53799);
-const buildChunkGraph = __webpack_require__(79233);
-const BuildCycleError = __webpack_require__(22273);
-const { Logger, LogType } = __webpack_require__(32597);
-const StatsFactory = __webpack_require__(92629);
-const StatsPrinter = __webpack_require__(30198);
-const { equals: arrayEquals } = __webpack_require__(84953);
-const AsyncQueue = __webpack_require__(12260);
-const LazySet = __webpack_require__(38938);
-const { provide } = __webpack_require__(82482);
-const WeakTupleMap = __webpack_require__(28745);
-const { cachedCleverMerge } = __webpack_require__(60839);
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	compareIds,
-	compareStringsNumeric,
-	compareModulesByIdentifier
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const {
-	arrayToSetDeprecation,
-	soonFrozenObjectDeprecation,
-	createFakeHook
-} = __webpack_require__(64518);
-const processAsyncTree = __webpack_require__(42791);
-const { getRuntimeKey } = __webpack_require__(17156);
-const { isSourceEqual } = __webpack_require__(41245);
+const DelegatedSourceDependency = __webpack_require__(22914);
+const StaticExportsDependency = __webpack_require__(91418);
+const makeSerializable = __webpack_require__(33032);
 
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./CacheFacade")} CacheFacade */
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./ModuleFactory")} ModuleFactory */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").SourceContext} SourceContext */
 /** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
-/**
- * @callback Callback
- * @param {(WebpackError | null)=} err
- * @returns {void}
- */
-
-/**
- * @callback ModuleCallback
- * @param {(WebpackError | null)=} err
- * @param {Module=} result
- * @returns {void}
- */
-
-/**
- * @callback ModuleFactoryResultCallback
- * @param {(WebpackError | null)=} err
- * @param {ModuleFactoryResult=} result
- * @returns {void}
- */
-
-/**
- * @callback ModuleOrFactoryResultCallback
- * @param {(WebpackError | null)=} err
- * @param {Module | ModuleFactoryResult=} result
- * @returns {void}
- */
-
-/**
- * @callback ExecuteModuleCallback
- * @param {(WebpackError | null)=} err
- * @param {ExecuteModuleResult=} result
- * @returns {void}
- */
-
-/**
- * @callback DepBlockVarDependenciesCallback
- * @param {Dependency} dependency
- * @returns {any}
- */
-
-/** @typedef {new (...args: any[]) => Dependency} DepConstructor */
-/** @typedef {Record<string, Source>} CompilationAssets */
-
-/**
- * @typedef {Object} AvailableModulesChunkGroupMapping
- * @property {ChunkGroup} chunkGroup
- * @property {Set<Module>} availableModules
- * @property {boolean} needCopy
- */
-
-/**
- * @typedef {Object} DependenciesBlockLike
- * @property {Dependency[]} dependencies
- * @property {AsyncDependenciesBlock[]} blocks
- */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-/**
- * @typedef {Object} ChunkPathData
- * @property {string|number} id
- * @property {string=} name
- * @property {string} hash
- * @property {function(number): string=} hashWithLength
- * @property {(Record<string, string>)=} contentHash
- * @property {(Record<string, (length: number) => string>)=} contentHashWithLength
- */
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([
+	RuntimeGlobals.module,
+	RuntimeGlobals.require
+]);
 
-/**
- * @typedef {Object} ChunkHashContext
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- */
+class DelegatedModule extends Module {
+	constructor(sourceRequest, data, type, userRequest, originalRequest) {
+		super("javascript/dynamic", null);
 
-/**
- * @typedef {Object} RuntimeRequirementsContext
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults the code generation results
- */
+		// Info from Factory
+		this.sourceRequest = sourceRequest;
+		this.request = data.id;
+		this.delegationType = type;
+		this.userRequest = userRequest;
+		this.originalRequest = originalRequest;
+		/** @type {ManifestModuleData} */
+		this.delegateData = data;
 
-/**
- * @typedef {Object} ExecuteModuleOptions
- * @property {EntryOptions=} entryOptions
- */
+		// Build info
+		this.delegatedSourceDependency = undefined;
+	}
 
-/**
- * @typedef {Object} ExecuteModuleResult
- * @property {any} exports
- * @property {boolean} cacheable
- * @property {Map<string, { source: Source, info: AssetInfo }>} assets
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} contextDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} buildDependencies
- */
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
 
-/**
- * @typedef {Object} ExecuteModuleArgument
- * @property {Module} module
- * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
- * @property {any} preparedInfo
- * @property {CodeGenerationResult} codeGenerationResult
- */
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return typeof this.originalRequest === "string"
+			? this.originalRequest
+			: this.originalRequest.libIdent(options);
+	}
 
-/**
- * @typedef {Object} ExecuteModuleContext
- * @property {Map<string, { source: Source, info: AssetInfo }>} assets
- * @property {Chunk} chunk
- * @property {ChunkGraph} chunkGraph
- * @property {function(string): any=} __webpack_require__
- */
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `delegated ${JSON.stringify(this.request)} from ${
+			this.sourceRequest
+		}`;
+	}
 
-/**
- * @typedef {Object} EntryData
- * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
- * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated
- * @property {EntryOptions} options options of the entrypoint
- */
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
+	}
 
-/**
- * @typedef {Object} LogEntry
- * @property {string} type
- * @property {any[]} args
- * @property {number} time
- * @property {string[]=} trace
- */
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
 
-/**
- * @typedef {Object} KnownAssetInfo
- * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
- * @property {boolean=} minimized whether the asset is minimized
- * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset
- * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
- * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
- * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
- * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
- * @property {number=} size size in bytes, only set after asset has been emitted
- * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
- * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
- * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
- * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
- */
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = { ...this.delegateData.buildMeta };
+		this.buildInfo = {};
+		this.dependencies.length = 0;
+		this.delegatedSourceDependency = new DelegatedSourceDependency(
+			this.sourceRequest
+		);
+		this.addDependency(this.delegatedSourceDependency);
+		this.addDependency(
+			new StaticExportsDependency(this.delegateData.exports || true, false)
+		);
+		callback();
+	}
 
-/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const dep = /** @type {DelegatedSourceDependency} */ (this.dependencies[0]);
+		const sourceModule = moduleGraph.getModule(dep);
+		let str;
 
-/**
- * @typedef {Object} Asset
- * @property {string} name the filename of the asset
- * @property {Source} source source of the asset
- * @property {AssetInfo} info info about the asset
- */
+		if (!sourceModule) {
+			str = runtimeTemplate.throwMissingModuleErrorBlock({
+				request: this.sourceRequest
+			});
+		} else {
+			str = `module.exports = (${runtimeTemplate.moduleExports({
+				module: sourceModule,
+				chunkGraph,
+				request: dep.request,
+				runtimeRequirements: new Set()
+			})})`;
 
-/**
- * @typedef {Object} ModulePathData
- * @property {string|number} id
- * @property {string} hash
- * @property {function(number): string=} hashWithLength
- */
+			switch (this.delegationType) {
+				case "require":
+					str += `(${JSON.stringify(this.request)})`;
+					break;
+				case "object":
+					str += `[${JSON.stringify(this.request)}]`;
+					break;
+			}
 
-/**
- * @typedef {Object} PathData
- * @property {ChunkGraph=} chunkGraph
- * @property {string=} hash
- * @property {function(number): string=} hashWithLength
- * @property {(Chunk|ChunkPathData)=} chunk
- * @property {(Module|ModulePathData)=} module
- * @property {RuntimeSpec=} runtime
- * @property {string=} filename
- * @property {string=} basename
- * @property {string=} query
- * @property {string=} contentHashType
- * @property {string=} contentHash
- * @property {function(number): string=} contentHashWithLength
- * @property {boolean=} noChunkHash
- * @property {string=} url
- */
+			str += ";";
+		}
 
-/**
- * @typedef {Object} KnownNormalizedStatsOptions
- * @property {string} context
- * @property {RequestShortener} requestShortener
- * @property {string} chunksSort
- * @property {string} modulesSort
- * @property {string} chunkModulesSort
- * @property {string} nestedModulesSort
- * @property {string} assetsSort
- * @property {boolean} ids
- * @property {boolean} cachedAssets
- * @property {boolean} groupAssetsByEmitStatus
- * @property {boolean} groupAssetsByPath
- * @property {boolean} groupAssetsByExtension
- * @property {number} assetsSpace
- * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
- * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
- * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
- * @property {boolean} cachedModules
- * @property {boolean} orphanModules
- * @property {boolean} dependentModules
- * @property {boolean} runtimeModules
- * @property {boolean} groupModulesByCacheStatus
- * @property {boolean} groupModulesByLayer
- * @property {boolean} groupModulesByAttributes
- * @property {boolean} groupModulesByPath
- * @property {boolean} groupModulesByExtension
- * @property {boolean} groupModulesByType
- * @property {boolean | "auto"} entrypoints
- * @property {boolean} chunkGroups
- * @property {boolean} chunkGroupAuxiliary
- * @property {boolean} chunkGroupChildren
- * @property {number} chunkGroupMaxAssets
- * @property {number} modulesSpace
- * @property {number} chunkModulesSpace
- * @property {number} nestedModulesSpace
- * @property {false|"none"|"error"|"warn"|"info"|"log"|"verbose"} logging
- * @property {((value: string) => boolean)[]} loggingDebug
- * @property {boolean} loggingTrace
- * @property {any} _env
- */
+		const sources = new Map();
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			sources.set("javascript", new OriginalSource(str, this.identifier()));
+		} else {
+			sources.set("javascript", new RawSource(str));
+		}
 
-/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
+		return {
+			sources,
+			runtimeRequirements: RUNTIME_REQUIREMENTS
+		};
+	}
 
-/**
- * @typedef {Object} KnownCreateStatsOptionsContext
- * @property {boolean=} forToString
- */
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
+	}
 
-/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(this.delegationType);
+		hash.update(JSON.stringify(this.request));
+		super.updateHash(hash, context);
+	}
 
-/** @type {AssetInfo} */
-const EMPTY_ASSET_INFO = Object.freeze({});
+	serialize(context) {
+		const { write } = context;
+		// constructor
+		write(this.sourceRequest);
+		write(this.delegateData);
+		write(this.delegationType);
+		write(this.userRequest);
+		write(this.originalRequest);
+		super.serialize(context);
+	}
 
-const esmDependencyCategory = "esm";
-// TODO webpack 6: remove
-const deprecatedNormalModuleLoaderHook = util.deprecate(
-	compilation => {
-		return (__webpack_require__(39).getCompilationHooks)(compilation).loader;
-	},
-	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
-	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
-);
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new DelegatedModule(
+			read(), // sourceRequest
+			read(), // delegateData
+			read(), // delegationType
+			read(), // userRequest
+			read() // originalRequest
+		);
+		obj.deserialize(context);
+		return obj;
+	}
 
-// TODO webpack 6: remove
-const defineRemovedModuleTemplates = moduleTemplates => {
-	Object.defineProperties(moduleTemplates, {
-		asset: {
-			enumerable: false,
-			configurable: false,
-			get: () => {
-				throw new WebpackError(
-					"Compilation.moduleTemplates.asset has been removed"
-				);
-			}
-		},
-		webassembly: {
-			enumerable: false,
-			configurable: false,
-			get: () => {
-				throw new WebpackError(
-					"Compilation.moduleTemplates.webassembly has been removed"
-				);
-			}
-		}
-	});
-	moduleTemplates = undefined;
-};
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {DelegatedModule} */ (module);
+		this.delegationType = m.delegationType;
+		this.userRequest = m.userRequest;
+		this.originalRequest = m.originalRequest;
+		this.delegateData = m.delegateData;
+	}
 
-const byId = compareSelect(
 	/**
-	 * @param {Chunk} c chunk
-	 * @returns {number | string} id
-	 */ c => c.id,
-	compareIds
-);
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.delegateData = undefined;
+	}
+}
 
-const byNameOrHash = concatComparators(
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} name
-		 */
-		c => c.name,
-		compareIds
-	),
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} hash
-		 */ c => c.fullHash,
-		compareIds
-	)
-);
+makeSerializable(DelegatedModule, "webpack/lib/DelegatedModule");
 
-const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
+module.exports = DelegatedModule;
 
-const byModule = compareSelect(
-	err => (err.module && err.module.identifier()) || "",
-	compareStringsNumeric
-);
 
-const byLocation = compareSelect(err => err.loc, compareLocations);
+/***/ }),
 
-const compareErrors = concatComparators(byModule, byLocation, byMessage);
+/***/ 51387:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
-const unsafeCacheDependencies = new WeakMap();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
-const unsafeCacheData = new WeakMap();
 
-class Compilation {
-	/**
-	 * Creates an instance of Compilation.
-	 * @param {Compiler} compiler the compiler which created the compilation
-	 * @param {CompilationParams} params the compilation parameters
-	 */
-	constructor(compiler, params) {
-		this._backCompat = compiler._backCompat;
 
-		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
-		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
-		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
-		const processAssetsHook = new AsyncSeriesHook(["assets"]);
+const DelegatedModule = __webpack_require__(28623);
 
-		let savedAssets = new Set();
-		const popNewAssets = assets => {
-			let newAssets = undefined;
-			for (const file of Object.keys(assets)) {
-				if (savedAssets.has(file)) continue;
-				if (newAssets === undefined) {
-					newAssets = Object.create(null);
-				}
-				newAssets[file] = assets[file];
-				savedAssets.add(file);
-			}
-			return newAssets;
-		};
-		processAssetsHook.intercept({
-			name: "Compilation",
-			call: () => {
-				savedAssets = new Set(Object.keys(this.assets));
-			},
-			register: tap => {
-				const { type, name } = tap;
-				const { fn, additionalAssets, ...remainingTap } = tap;
-				const additionalAssetsFn =
-					additionalAssets === true ? fn : additionalAssets;
-				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
-				switch (type) {
-					case "sync":
-						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tap(name, assets => {
-								if (processedAssets.has(this.assets))
-									additionalAssetsFn(assets);
-							});
-						}
-						return {
-							...remainingTap,
-							type: "async",
-							fn: (assets, callback) => {
-								try {
-									fn(assets);
-								} catch (e) {
-									return callback(e);
-								}
-								if (processedAssets !== undefined)
-									processedAssets.add(this.assets);
-								const newAssets = popNewAssets(assets);
-								if (newAssets !== undefined) {
-									this.hooks.processAdditionalAssets.callAsync(
-										newAssets,
-										callback
-									);
-									return;
-								}
-								callback();
-							}
-						};
-					case "async":
-						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tapAsync(
-								name,
-								(assets, callback) => {
-									if (processedAssets.has(this.assets))
-										return additionalAssetsFn(assets, callback);
-									callback();
-								}
+// options.source
+// options.type
+// options.context
+// options.scope
+// options.content
+// options.associatedObjectForCache
+class DelegatedModuleFactoryPlugin {
+	constructor(options) {
+		this.options = options;
+		options.type = options.type || "require";
+		options.extensions = options.extensions || ["", ".js", ".json", ".wasm"];
+	}
+
+	apply(normalModuleFactory) {
+		const scope = this.options.scope;
+		if (scope) {
+			normalModuleFactory.hooks.factorize.tapAsync(
+				"DelegatedModuleFactoryPlugin",
+				(data, callback) => {
+					const [dependency] = data.dependencies;
+					const { request } = dependency;
+					if (request && request.startsWith(`${scope}/`)) {
+						const innerRequest = "." + request.substr(scope.length);
+						let resolved;
+						if (innerRequest in this.options.content) {
+							resolved = this.options.content[innerRequest];
+							return callback(
+								null,
+								new DelegatedModule(
+									this.options.source,
+									resolved,
+									this.options.type,
+									innerRequest,
+									request
+								)
 							);
 						}
-						return {
-							...remainingTap,
-							fn: (assets, callback) => {
-								fn(assets, err => {
-									if (err) return callback(err);
-									if (processedAssets !== undefined)
-										processedAssets.add(this.assets);
-									const newAssets = popNewAssets(assets);
-									if (newAssets !== undefined) {
-										this.hooks.processAdditionalAssets.callAsync(
-											newAssets,
-											callback
-										);
-										return;
-									}
-									callback();
-								});
+						for (let i = 0; i < this.options.extensions.length; i++) {
+							const extension = this.options.extensions[i];
+							const requestPlusExt = innerRequest + extension;
+							if (requestPlusExt in this.options.content) {
+								resolved = this.options.content[requestPlusExt];
+								return callback(
+									null,
+									new DelegatedModule(
+										this.options.source,
+										resolved,
+										this.options.type,
+										requestPlusExt,
+										request + extension
+									)
+								);
 							}
-						};
-					case "promise":
-						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tapPromise(name, assets => {
-								if (processedAssets.has(this.assets))
-									return additionalAssetsFn(assets);
-								return Promise.resolve();
-							});
 						}
-						return {
-							...remainingTap,
-							fn: assets => {
-								const p = fn(assets);
-								if (!p || !p.then) return p;
-								return p.then(() => {
-									if (processedAssets !== undefined)
-										processedAssets.add(this.assets);
-									const newAssets = popNewAssets(assets);
-									if (newAssets !== undefined) {
-										return this.hooks.processAdditionalAssets.promise(
-											newAssets
-										);
-									}
-								});
-							}
-						};
-				}
-			}
-		});
-
-		/** @type {SyncHook<[CompilationAssets]>} */
-		const afterProcessAssetsHook = new SyncHook(["assets"]);
-
-		/**
-		 * @template T
-		 * @param {string} name name of the hook
-		 * @param {number} stage new stage
-		 * @param {function(): AsArray<T>} getArgs get old hook function args
-		 * @param {string=} code deprecation code (not deprecated when unset)
-		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
-		 */
-		const createProcessAssetsHook = (name, stage, getArgs, code) => {
-			if (!this._backCompat && code) return undefined;
-			const errorMessage =
-				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
-BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
-			const getOptions = options => {
-				if (typeof options === "string") options = { name: options };
-				if (options.stage) {
-					throw new Error(errorMessage("it's using the 'stage' option"));
+					}
+					return callback();
 				}
-				return { ...options, stage: stage };
-			};
-			return createFakeHook(
-				{
-					name,
-					/** @type {AsyncSeriesHook<T>["intercept"]} */
-					intercept(interceptor) {
-						throw new Error(errorMessage("it's using 'intercept'"));
-					},
-					/** @type {AsyncSeriesHook<T>["tap"]} */
-					tap: (options, fn) => {
-						processAssetsHook.tap(getOptions(options), () => fn(...getArgs()));
-					},
-					/** @type {AsyncSeriesHook<T>["tapAsync"]} */
-					tapAsync: (options, fn) => {
-						processAssetsHook.tapAsync(
-							getOptions(options),
-							(assets, callback) =>
-								/** @type {any} */ (fn)(...getArgs(), callback)
-						);
-					},
-					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
-					tapPromise: (options, fn) => {
-						processAssetsHook.tapPromise(getOptions(options), () =>
-							fn(...getArgs())
-						);
+			);
+		} else {
+			normalModuleFactory.hooks.module.tap(
+				"DelegatedModuleFactoryPlugin",
+				module => {
+					const request = module.libIdent(this.options);
+					if (request) {
+						if (request in this.options.content) {
+							const resolved = this.options.content[request];
+							return new DelegatedModule(
+								this.options.source,
+								resolved,
+								this.options.type,
+								request,
+								module
+							);
+						}
 					}
-				},
-				`${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,
-				code
+					return module;
+				}
 			);
-		};
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[Module]>} */
-			buildModule: new SyncHook(["module"]),
-			/** @type {SyncHook<[Module]>} */
-			rebuildModule: new SyncHook(["module"]),
-			/** @type {SyncHook<[Module, WebpackError]>} */
-			failedModule: new SyncHook(["module", "error"]),
-			/** @type {SyncHook<[Module]>} */
-			succeedModule: new SyncHook(["module"]),
-			/** @type {SyncHook<[Module]>} */
-			stillValidModule: new SyncHook(["module"]),
-
-			/** @type {SyncHook<[Dependency, EntryOptions]>} */
-			addEntry: new SyncHook(["entry", "options"]),
-			/** @type {SyncHook<[Dependency, EntryOptions, Error]>} */
-			failedEntry: new SyncHook(["entry", "options", "error"]),
-			/** @type {SyncHook<[Dependency, EntryOptions, Module]>} */
-			succeedEntry: new SyncHook(["entry", "options", "module"]),
-
-			/** @type {SyncWaterfallHook<[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]>} */
-			dependencyReferencedExports: new SyncWaterfallHook([
-				"referencedExports",
-				"dependency",
-				"runtime"
-			]),
+		}
+	}
+}
+module.exports = DelegatedModuleFactoryPlugin;
 
-			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
-			executeModule: new SyncHook(["options", "context"]),
-			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
-			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
 
-			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
-			finishModules: new AsyncSeriesHook(["modules"]),
-			/** @type {AsyncSeriesHook<[Module]>} */
-			finishRebuildingModule: new AsyncSeriesHook(["module"]),
-			/** @type {SyncHook<[]>} */
-			unseal: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			seal: new SyncHook([]),
+/***/ }),
 
-			/** @type {SyncHook<[]>} */
-			beforeChunks: new SyncHook([]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			afterChunks: new SyncHook(["chunks"]),
+/***/ 80632:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
-			optimizeDependencies: new SyncBailHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			afterOptimizeDependencies: new SyncHook(["modules"]),
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			/** @type {SyncHook<[]>} */
-			optimize: new SyncHook([]),
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
-			optimizeModules: new SyncBailHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			afterOptimizeModules: new SyncHook(["modules"]),
 
-			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
-			optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),
-			/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */
-			afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),
 
-			/** @type {AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			optimizeTree: new AsyncSeriesHook(["chunks", "modules"]),
-			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			afterOptimizeTree: new SyncHook(["chunks", "modules"]),
+const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
+const DelegatedSourceDependency = __webpack_require__(22914);
 
-			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
-			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
-			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
-			/** @type {SyncBailHook<[], boolean>} */
-			shouldRecord: new SyncBailHook([]),
+/** @typedef {import("./Compiler")} Compiler */
 
-			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
-			additionalChunkRuntimeRequirements: new SyncHook([
-				"chunk",
-				"runtimeRequirements",
-				"context"
-			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
-			runtimeRequirementInChunk: new HookMap(
-				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
-			),
-			/** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
-			additionalModuleRuntimeRequirements: new SyncHook([
-				"module",
-				"runtimeRequirements",
-				"context"
-			]),
-			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
-			runtimeRequirementInModule: new HookMap(
-				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
-			),
-			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
-			additionalTreeRuntimeRequirements: new SyncHook([
-				"chunk",
-				"runtimeRequirements",
-				"context"
-			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
-			runtimeRequirementInTree: new HookMap(
-				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
-			),
+class DelegatedPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-			/** @type {SyncHook<[RuntimeModule, Chunk]>} */
-			runtimeModule: new SyncHook(["module", "chunk"]),
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DelegatedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					DelegatedSourceDependency,
+					normalModuleFactory
+				);
+			}
+		);
 
-			/** @type {SyncHook<[Iterable<Module>, any]>} */
-			reviveModules: new SyncHook(["modules", "records"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			beforeModuleIds: new SyncHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			moduleIds: new SyncHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			optimizeModuleIds: new SyncHook(["modules"]),
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			afterOptimizeModuleIds: new SyncHook(["modules"]),
+		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
+			new DelegatedModuleFactoryPlugin({
+				associatedObjectForCache: compiler.root,
+				...this.options
+			}).apply(normalModuleFactory);
+		});
+	}
+}
 
-			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
-			reviveChunks: new SyncHook(["chunks", "records"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			beforeChunkIds: new SyncHook(["chunks"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			chunkIds: new SyncHook(["chunks"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			optimizeChunkIds: new SyncHook(["chunks"]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
-			afterOptimizeChunkIds: new SyncHook(["chunks"]),
+module.exports = DelegatedPlugin;
 
-			/** @type {SyncHook<[Iterable<Module>, any]>} */
-			recordModules: new SyncHook(["modules", "records"]),
-			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
-			recordChunks: new SyncHook(["chunks", "records"]),
 
-			/** @type {SyncHook<[Iterable<Module>]>} */
-			optimizeCodeGeneration: new SyncHook(["modules"]),
+/***/ }),
 
-			/** @type {SyncHook<[]>} */
-			beforeModuleHash: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterModuleHash: new SyncHook([]),
+/***/ 71040:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			/** @type {SyncHook<[]>} */
-			beforeCodeGeneration: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterCodeGeneration: new SyncHook([]),
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			/** @type {SyncHook<[]>} */
-			beforeRuntimeRequirements: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterRuntimeRequirements: new SyncHook([]),
 
-			/** @type {SyncHook<[]>} */
-			beforeHash: new SyncHook([]),
-			/** @type {SyncHook<[Chunk]>} */
-			contentHash: new SyncHook(["chunk"]),
-			/** @type {SyncHook<[]>} */
-			afterHash: new SyncHook([]),
-			/** @type {SyncHook<[any]>} */
-			recordHash: new SyncHook(["records"]),
-			/** @type {SyncHook<[Compilation, any]>} */
-			record: new SyncHook(["compilation", "records"]),
 
-			/** @type {SyncHook<[]>} */
-			beforeModuleAssets: new SyncHook([]),
-			/** @type {SyncBailHook<[], boolean>} */
-			shouldGenerateChunkAssets: new SyncBailHook([]),
-			/** @type {SyncHook<[]>} */
-			beforeChunkAssets: new SyncHook([]),
-			// TODO webpack 6 remove
-			/** @deprecated */
-			additionalChunkAssets: createProcessAssetsHook(
-				"additionalChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
-			),
+const makeSerializable = __webpack_require__(33032);
 
-			// TODO webpack 6 deprecate
-			/** @deprecated */
-			additionalAssets: createProcessAssetsHook(
-				"additionalAssets",
-				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-				() => []
-			),
-			// TODO webpack 6 remove
-			/** @deprecated */
-			optimizeChunkAssets: createProcessAssetsHook(
-				"optimizeChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
-			),
-			// TODO webpack 6 remove
-			/** @deprecated */
-			afterOptimizeChunkAssets: createProcessAssetsHook(
-				"afterOptimizeChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
-			),
-			// TODO webpack 6 deprecate
-			/** @deprecated */
-			optimizeAssets: processAssetsHook,
-			// TODO webpack 6 deprecate
-			/** @deprecated */
-			afterOptimizeAssets: afterProcessAssetsHook,
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./util/Hash")} Hash */
 
-			processAssets: processAssetsHook,
-			afterProcessAssets: afterProcessAssetsHook,
-			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
-			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
+/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
 
-			/** @type {SyncBailHook<[], boolean>} */
-			needAdditionalSeal: new SyncBailHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
-			afterSeal: new AsyncSeriesHook([]),
+class DependenciesBlock {
+	constructor() {
+		/** @type {Dependency[]} */
+		this.dependencies = [];
+		/** @type {AsyncDependenciesBlock[]} */
+		this.blocks = [];
+		/** @type {DependenciesBlock} */
+		this.parent = undefined;
+	}
 
-			/** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */
-			renderManifest: new SyncWaterfallHook(["result", "options"]),
+	getRootBlock() {
+		/** @type {DependenciesBlock} */
+		let current = this;
+		while (current.parent) current = current.parent;
+		return current;
+	}
 
-			/** @type {SyncHook<[Hash]>} */
-			fullHash: new SyncHook(["hash"]),
-			/** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */
-			chunkHash: new SyncHook(["chunk", "chunkHash", "ChunkHashContext"]),
+	/**
+	 * Adds a DependencyBlock to DependencyBlock relationship.
+	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
+	 *
+	 * @param {AsyncDependenciesBlock} block block being added
+	 * @returns {void}
+	 */
+	addBlock(block) {
+		this.blocks.push(block);
+		block.parent = this;
+	}
 
-			/** @type {SyncHook<[Module, string]>} */
-			moduleAsset: new SyncHook(["module", "filename"]),
-			/** @type {SyncHook<[Chunk, string]>} */
-			chunkAsset: new SyncHook(["chunk", "filename"]),
+	/**
+	 * @param {Dependency} dependency dependency being tied to block.
+	 * This is an "edge" pointing to another "node" on module graph.
+	 * @returns {void}
+	 */
+	addDependency(dependency) {
+		this.dependencies.push(dependency);
+	}
 
-			/** @type {SyncWaterfallHook<[string, object, AssetInfo]>} */
-			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
+	/**
+	 * @param {Dependency} dependency dependency being removed
+	 * @returns {void}
+	 */
+	removeDependency(dependency) {
+		const idx = this.dependencies.indexOf(dependency);
+		if (idx >= 0) {
+			this.dependencies.splice(idx, 1);
+		}
+	}
 
-			/** @type {SyncBailHook<[], boolean>} */
-			needAdditionalPass: new SyncBailHook([]),
+	/**
+	 * Removes all dependencies and blocks
+	 * @returns {void}
+	 */
+	clearDependenciesAndBlocks() {
+		this.dependencies.length = 0;
+		this.blocks.length = 0;
+	}
 
-			/** @type {SyncHook<[Compiler, string, number]>} */
-			childCompiler: new SyncHook([
-				"childCompiler",
-				"compilerName",
-				"compilerIndex"
-			]),
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		for (const dep of this.dependencies) {
+			dep.updateHash(hash, context);
+		}
+		for (const block of this.blocks) {
+			block.updateHash(hash, context);
+		}
+	}
 
-			/** @type {SyncBailHook<[string, LogEntry], true>} */
-			log: new SyncBailHook(["origin", "logEntry"]),
+	serialize({ write }) {
+		write(this.dependencies);
+		write(this.blocks);
+	}
 
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
-			processWarnings: new SyncWaterfallHook(["warnings"]),
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
-			processErrors: new SyncWaterfallHook(["errors"]),
+	deserialize({ read }) {
+		this.dependencies = read();
+		this.blocks = read();
+		for (const block of this.blocks) {
+			block.parent = this;
+		}
+	}
+}
 
-			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
-			statsPreset: new HookMap(() => new SyncHook(["options", "context"])),
-			/** @type {SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>} */
-			statsNormalize: new SyncHook(["options", "context"]),
-			/** @type {SyncHook<[StatsFactory, NormalizedStatsOptions]>} */
-			statsFactory: new SyncHook(["statsFactory", "options"]),
-			/** @type {SyncHook<[StatsPrinter, NormalizedStatsOptions]>} */
-			statsPrinter: new SyncHook(["statsPrinter", "options"]),
+makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock");
 
-			get normalModuleLoader() {
-				return getNormalModuleLoader();
-			}
-		});
-		/** @type {string=} */
-		this.name = undefined;
-		this.startTime = undefined;
-		this.endTime = undefined;
-		/** @type {Compiler} */
-		this.compiler = compiler;
-		this.resolverFactory = compiler.resolverFactory;
-		this.inputFileSystem = compiler.inputFileSystem;
-		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
-			managedPaths: compiler.managedPaths,
-			immutablePaths: compiler.immutablePaths,
-			logger: this.getLogger("webpack.FileSystemInfo"),
-			hashFunction: compiler.options.output.hashFunction
-		});
-		if (compiler.fileTimestamps) {
-			this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
-		}
-		if (compiler.contextTimestamps) {
-			this.fileSystemInfo.addContextTimestamps(
-				compiler.contextTimestamps,
-				true
-			);
-		}
-		/** @type {Map<string, string | Set<string>>} */
-		this.valueCacheVersions = new Map();
-		this.requestShortener = compiler.requestShortener;
-		this.compilerPath = compiler.compilerPath;
+module.exports = DependenciesBlock;
 
-		this.logger = this.getLogger("webpack.Compilation");
 
-		const options = compiler.options;
-		this.options = options;
-		this.outputOptions = options && options.output;
-		/** @type {boolean} */
-		this.bail = (options && options.bail) || false;
-		/** @type {boolean} */
-		this.profile = (options && options.profile) || false;
+/***/ }),
 
-		this.params = params;
-		this.mainTemplate = new MainTemplate(this.outputOptions, this);
-		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
-		this.runtimeTemplate = new RuntimeTemplate(
-			this,
-			this.outputOptions,
-			this.requestShortener
-		);
-		/** @type {{javascript: ModuleTemplate}} */
-		this.moduleTemplates = {
-			javascript: new ModuleTemplate(this.runtimeTemplate, this)
-		};
-		defineRemovedModuleTemplates(this.moduleTemplates);
+/***/ 54912:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
-		this.moduleMemCaches = undefined;
-		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
-		this.moduleMemCaches2 = undefined;
-		this.moduleGraph = new ModuleGraph();
-		/** @type {ChunkGraph} */
-		this.chunkGraph = undefined;
-		/** @type {CodeGenerationResults} */
-		this.codeGenerationResults = undefined;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.processDependenciesQueue = new AsyncQueue({
-			name: "processDependencies",
-			parallelism: options.parallelism || 100,
-			processor: this._processModuleDependencies.bind(this)
-		});
-		/** @type {AsyncQueue<Module, string, Module>} */
-		this.addModuleQueue = new AsyncQueue({
-			name: "addModule",
-			parent: this.processDependenciesQueue,
-			getKey: module => module.identifier(),
-			processor: this._addModule.bind(this)
-		});
-		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
-		this.factorizeQueue = new AsyncQueue({
-			name: "factorize",
-			parent: this.addModuleQueue,
-			processor: this._factorizeModule.bind(this)
-		});
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.buildQueue = new AsyncQueue({
-			name: "build",
-			parent: this.factorizeQueue,
-			processor: this._buildModule.bind(this)
-		});
-		/** @type {AsyncQueue<Module, Module, Module>} */
-		this.rebuildQueue = new AsyncQueue({
-			name: "rebuild",
-			parallelism: options.parallelism || 100,
-			processor: this._rebuildModule.bind(this)
-		});
 
-		/**
-		 * Modules in value are building during the build of Module in key.
-		 * Means value blocking key from finishing.
-		 * Needed to detect build cycles.
-		 * @type {WeakMap<Module, Set<Module>>}
-		 */
-		this.creatingModuleDuringBuild = new WeakMap();
 
-		/** @type {Map<string, EntryData>} */
-		this.entries = new Map();
-		/** @type {EntryData} */
-		this.globalEntry = {
-			dependencies: [],
-			includeDependencies: [],
-			options: {
-				name: undefined
-			}
-		};
-		/** @type {Map<string, Entrypoint>} */
-		this.entrypoints = new Map();
-		/** @type {Entrypoint[]} */
-		this.asyncEntrypoints = [];
-		/** @type {Set<Chunk>} */
-		this.chunks = new Set();
-		/** @type {ChunkGroup[]} */
-		this.chunkGroups = [];
-		/** @type {Map<string, ChunkGroup>} */
-		this.namedChunkGroups = new Map();
-		/** @type {Map<string, Chunk>} */
-		this.namedChunks = new Map();
-		/** @type {Set<Module>} */
-		this.modules = new Set();
-		if (this._backCompat) {
-			arrayToSetDeprecation(this.chunks, "Compilation.chunks");
-			arrayToSetDeprecation(this.modules, "Compilation.modules");
-		}
-		/** @private @type {Map<string, Module>} */
-		this._modules = new Map();
-		this.records = null;
-		/** @type {string[]} */
-		this.additionalChunkAssets = [];
-		/** @type {CompilationAssets} */
-		this.assets = {};
-		/** @type {Map<string, AssetInfo>} */
-		this.assetsInfo = new Map();
-		/** @type {Map<string, Map<string, Set<string>>>} */
-		this._assetsRelatedIn = new Map();
-		/** @type {WebpackError[]} */
-		this.errors = [];
-		/** @type {WebpackError[]} */
-		this.warnings = [];
-		/** @type {Compilation[]} */
-		this.children = [];
-		/** @type {Map<string, LogEntry[]>} */
-		this.logging = new Map();
-		/** @type {Map<DepConstructor, ModuleFactory>} */
-		this.dependencyFactories = new Map();
-		/** @type {DependencyTemplates} */
-		this.dependencyTemplates = new DependencyTemplates(
-			this.outputOptions.hashFunction
-		);
-		this.childrenCounters = {};
-		/** @type {Set<number|string>} */
-		this.usedChunkIds = null;
-		/** @type {Set<number>} */
-		this.usedModuleIds = null;
-		/** @type {boolean} */
-		this.needAdditionalPass = false;
-		/** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
-		this._restoredUnsafeCacheModuleEntries = new Set();
-		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
-		this._restoredUnsafeCacheEntries = new Map();
-		/** @type {WeakSet<Module>} */
-		this.builtModules = new WeakSet();
-		/** @type {WeakSet<Module>} */
-		this.codeGeneratedModules = new WeakSet();
-		/** @type {WeakSet<Module>} */
-		this.buildTimeExecutedModules = new WeakSet();
-		/** @private @type {Map<Module, Callback[]>} */
-		this._rebuildingModules = new Map();
-		/** @type {Set<string>} */
-		this.emittedAssets = new Set();
-		/** @type {Set<string>} */
-		this.comparedForEmitAssets = new Set();
-		/** @type {LazySet<string>} */
-		this.fileDependencies = new LazySet();
-		/** @type {LazySet<string>} */
-		this.contextDependencies = new LazySet();
-		/** @type {LazySet<string>} */
-		this.missingDependencies = new LazySet();
-		/** @type {LazySet<string>} */
-		this.buildDependencies = new LazySet();
-		// TODO webpack 6 remove
-		this.compilationDependencies = {
-			add: util.deprecate(
-				item => this.fileDependencies.add(item),
-				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
-				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
-			)
-		};
+const memoize = __webpack_require__(78676);
 
-		this._modulesCache = this.getCache("Compilation/modules");
-		this._assetsCache = this.getCache("Compilation/assets");
-		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-		const unsafeCache = options.module.unsafeCache;
-		this._unsafeCache = !!unsafeCache;
-		this._unsafeCachePredicate =
-			typeof unsafeCache === "function" ? unsafeCache : () => true;
+/**
+ * @typedef {Object} UpdateHashContext
+ * @property {ChunkGraph} chunkGraph
+ * @property {RuntimeSpec} runtime
+ * @property {RuntimeTemplate=} runtimeTemplate
+ */
+
+/**
+ * @typedef {Object} SourcePosition
+ * @property {number} line
+ * @property {number=} column
+ */
+
+/**
+ * @typedef {Object} RealDependencyLocation
+ * @property {SourcePosition} start
+ * @property {SourcePosition=} end
+ * @property {number=} index
+ */
+
+/**
+ * @typedef {Object} SyntheticDependencyLocation
+ * @property {string} name
+ * @property {number=} index
+ */
+
+/** @typedef {SyntheticDependencyLocation|RealDependencyLocation} DependencyLocation */
+
+/**
+ * @typedef {Object} ExportSpec
+ * @property {string} name the name of the export
+ * @property {boolean=} canMangle can the export be renamed (defaults to true)
+ * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts
+ * @property {(string | ExportSpec)[]=} exports nested exports
+ * @property {ModuleGraphConnection=} from when reexported: from which module
+ * @property {string[] | null=} export when reexported: from which export
+ * @property {number=} priority when reexported: with which priority
+ * @property {boolean=} hidden export is not visible, because another export blends over it
+ */
+
+/**
+ * @typedef {Object} ExportsSpec
+ * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
+ * @property {Set<string>=} excludeExports when exports = true, list of unaffected exports
+ * @property {Set<string>=} hideExports list of maybe prior exposed, but now hidden exports
+ * @property {ModuleGraphConnection=} from when reexported: from which module
+ * @property {number=} priority when reexported: with which priority
+ * @property {boolean=} canMangle can the export be renamed (defaults to true)
+ * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts
+ * @property {Module[]=} dependencies module on which the result depends on
+ */
+
+/**
+ * @typedef {Object} ReferencedExport
+ * @property {string[]} name name of the referenced export
+ * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
+ */
+
+const TRANSITIVE = Symbol("transitive");
+
+const getIgnoredModule = memoize(() => {
+	const RawModule = __webpack_require__(84929);
+	return new RawModule("/* (ignored) */", `ignored`, `(ignored)`);
+});
+
+class Dependency {
+	constructor() {
+		/** @type {Module} */
+		this._parentModule = undefined;
+		/** @type {DependenciesBlock} */
+		this._parentDependenciesBlock = undefined;
+		/** @type {number} */
+		this._parentDependenciesBlockIndex = -1;
+		// TODO check if this can be moved into ModuleDependency
+		/** @type {boolean} */
+		this.weak = false;
+		// TODO check if this can be moved into ModuleDependency
+		/** @type {boolean} */
+		this.optional = false;
+		this._locSL = 0;
+		this._locSC = 0;
+		this._locEL = 0;
+		this._locEC = 0;
+		this._locI = undefined;
+		this._locN = undefined;
+		this._loc = undefined;
 	}
 
-	getStats() {
-		return new Stats(this);
+	/**
+	 * @returns {string} a display name for the type of dependency
+	 */
+	get type() {
+		return "unknown";
 	}
 
 	/**
-	 * @param {StatsOptions | string} optionsOrPreset stats option value
-	 * @param {CreateStatsOptionsContext} context context
-	 * @returns {NormalizedStatsOptions} normalized options
+	 * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm"
 	 */
-	createStatsOptions(optionsOrPreset, context = {}) {
-		if (
-			typeof optionsOrPreset === "boolean" ||
-			typeof optionsOrPreset === "string"
-		) {
-			optionsOrPreset = { preset: optionsOrPreset };
+	get category() {
+		return "unknown";
+	}
+
+	/**
+	 * @returns {DependencyLocation} location
+	 */
+	get loc() {
+		if (this._loc !== undefined) return this._loc;
+		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
+		const loc = {};
+		if (this._locSL > 0) {
+			loc.start = { line: this._locSL, column: this._locSC };
 		}
-		if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
-			// We use this method of shallow cloning this object to include
-			// properties in the prototype chain
-			/** @type {Partial<NormalizedStatsOptions>} */
-			const options = {};
-			for (const key in optionsOrPreset) {
-				options[key] = optionsOrPreset[key];
-			}
-			if (options.preset !== undefined) {
-				this.hooks.statsPreset.for(options.preset).call(options, context);
-			}
-			this.hooks.statsNormalize.call(options, context);
-			return /** @type {NormalizedStatsOptions} */ (options);
+		if (this._locEL > 0) {
+			loc.end = { line: this._locEL, column: this._locEC };
+		}
+		if (this._locN !== undefined) {
+			loc.name = this._locN;
+		}
+		if (this._locI !== undefined) {
+			loc.index = this._locI;
+		}
+		return (this._loc = loc);
+	}
+
+	set loc(loc) {
+		if ("start" in loc && typeof loc.start === "object") {
+			this._locSL = loc.start.line || 0;
+			this._locSC = loc.start.column || 0;
 		} else {
-			/** @type {Partial<NormalizedStatsOptions>} */
-			const options = {};
-			this.hooks.statsNormalize.call(options, context);
-			return /** @type {NormalizedStatsOptions} */ (options);
+			this._locSL = 0;
+			this._locSC = 0;
+		}
+		if ("end" in loc && typeof loc.end === "object") {
+			this._locEL = loc.end.line || 0;
+			this._locEC = loc.end.column || 0;
+		} else {
+			this._locEL = 0;
+			this._locEC = 0;
+		}
+		if ("index" in loc) {
+			this._locI = loc.index;
+		} else {
+			this._locI = undefined;
+		}
+		if ("name" in loc) {
+			this._locN = loc.name;
+		} else {
+			this._locN = undefined;
 		}
+		this._loc = loc;
 	}
 
-	createStatsFactory(options) {
-		const statsFactory = new StatsFactory();
-		this.hooks.statsFactory.call(statsFactory, options);
-		return statsFactory;
+	setLoc(startLine, startColumn, endLine, endColumn) {
+		this._locSL = startLine;
+		this._locSC = startColumn;
+		this._locEL = endLine;
+		this._locEC = endColumn;
+		this._locI = undefined;
+		this._locN = undefined;
+		this._loc = undefined;
 	}
 
-	createStatsPrinter(options) {
-		const statsPrinter = new StatsPrinter();
-		this.hooks.statsPrinter.call(statsPrinter, options);
-		return statsPrinter;
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return null;
 	}
 
 	/**
-	 * @param {string} name cache name
-	 * @returns {CacheFacade} the cache facade instance
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
 	 */
-	getCache(name) {
-		return this.compiler.getCache(name);
+	couldAffectReferencingModule() {
+		return TRANSITIVE;
 	}
 
 	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
-	 * @returns {Logger} a logger with that name
+	 * Returns the referenced module and export
+	 * @deprecated
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {never} throws error
 	 */
-	getLogger(name) {
-		if (!name) {
-			throw new TypeError("Compilation.getLogger(name) called without a name");
-		}
-		/** @type {LogEntry[] | undefined} */
-		let logEntries;
-		return new Logger(
-			(type, args) => {
-				if (typeof name === "function") {
-					name = name();
-					if (!name) {
-						throw new TypeError(
-							"Compilation.getLogger(name) called with a function not returning a name"
-						);
-					}
-				}
-				let trace;
-				switch (type) {
-					case LogType.warn:
-					case LogType.error:
-					case LogType.trace:
-						trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
-							.split("\n")
-							.slice(3);
-						break;
-				}
-				/** @type {LogEntry} */
-				const logEntry = {
-					time: Date.now(),
-					type,
-					args,
-					trace
-				};
-				if (this.hooks.log.call(name, logEntry) === undefined) {
-					if (logEntry.type === LogType.profileEnd) {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						if (typeof console.profileEnd === "function") {
-							// eslint-disable-next-line node/no-unsupported-features/node-builtins
-							console.profileEnd(`[${name}] ${logEntry.args[0]}`);
-						}
-					}
-					if (logEntries === undefined) {
-						logEntries = this.logging.get(name);
-						if (logEntries === undefined) {
-							logEntries = [];
-							this.logging.set(name, logEntries);
-						}
-					}
-					logEntries.push(logEntry);
-					if (logEntry.type === LogType.profile) {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						if (typeof console.profile === "function") {
-							// eslint-disable-next-line node/no-unsupported-features/node-builtins
-							console.profile(`[${name}] ${logEntry.args[0]}`);
-						}
-					}
-				}
-			},
-			childName => {
-				if (typeof name === "function") {
-					if (typeof childName === "function") {
-						return this.getLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compilation.getLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compilation.getLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getLogger(`${name}/${childName}`);
-					}
-				}
-			}
+	getReference(moduleGraph) {
+		throw new Error(
+			"Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule and ModuleGraph.getConnection().active"
 		);
 	}
 
 	/**
-	 * @param {Module} module module to be added that was created
-	 * @param {ModuleCallback} callback returns the module in the compilation,
-	 * it could be the passed one (if new), or an already existing in the compilation
-	 * @returns {void}
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	addModule(module, callback) {
-		this.addModuleQueue.add(module, callback);
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
 	/**
-	 * @param {Module} module module to be added that was created
-	 * @param {ModuleCallback} callback returns the module in the compilation,
-	 * it could be the passed one (if new), or an already existing in the compilation
-	 * @returns {void}
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
-	_addModule(module, callback) {
-		const identifier = module.identifier();
-		const alreadyAddedModule = this._modules.get(identifier);
-		if (alreadyAddedModule) {
-			return callback(null, alreadyAddedModule);
-		}
+	getCondition(moduleGraph) {
+		return null;
+	}
 
-		const currentProfile = this.profile
-			? this.moduleGraph.getProfile(module)
-			: undefined;
-		if (currentProfile !== undefined) {
-			currentProfile.markRestoringStart();
-		}
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return undefined;
+	}
 
-		this._modulesCache.get(identifier, null, (err, cacheModule) => {
-			if (err) return callback(new ModuleRestoreError(module, err));
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
+	 */
+	getWarnings(moduleGraph) {
+		return null;
+	}
 
-			if (currentProfile !== undefined) {
-				currentProfile.markRestoringEnd();
-				currentProfile.markIntegrationStart();
-			}
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
+	 */
+	getErrors(moduleGraph) {
+		return null;
+	}
 
-			if (cacheModule) {
-				cacheModule.updateCacheModule(module);
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {}
 
-				module = cacheModule;
-			}
-			this._modules.set(identifier, module);
-			this.modules.add(module);
-			if (this._backCompat)
-				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
-			if (currentProfile !== undefined) {
-				currentProfile.markIntegrationEnd();
-			}
-			callback(null, module);
-		});
+	/**
+	 * implement this method to allow the occurrence order plugin to count correctly
+	 * @returns {number} count how often the id is used in this dependency
+	 */
+	getNumberOfIdOccurrences() {
+		return 1;
 	}
 
 	/**
-	 * Fetches a module from a compilation by its identifier
-	 * @param {Module} module the module provided
-	 * @returns {Module} the module requested
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
 	 */
-	getModule(module) {
-		const identifier = module.identifier();
-		return this._modules.get(identifier);
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return true;
 	}
 
 	/**
-	 * Attempts to search for a module by its identifier
-	 * @param {string} identifier identifier (usually path) for module
-	 * @returns {Module|undefined} attempt to search for module and return it, else undefined
+	 * @param {string} context context directory
+	 * @returns {Module} a module
 	 */
-	findModule(identifier) {
-		return this._modules.get(identifier);
+	createIgnoredModule(context) {
+		return getIgnoredModule();
+	}
+
+	serialize({ write }) {
+		write(this.weak);
+		write(this.optional);
+		write(this._locSL);
+		write(this._locSC);
+		write(this._locEL);
+		write(this._locEC);
+		write(this._locI);
+		write(this._locN);
+	}
+
+	deserialize({ read }) {
+		this.weak = read();
+		this.optional = read();
+		this._locSL = read();
+		this._locSC = read();
+		this._locEL = read();
+		this._locEC = read();
+		this._locI = read();
+		this._locN = read();
 	}
+}
+
+/** @type {string[][]} */
+Dependency.NO_EXPORTS_REFERENCED = [];
+/** @type {string[][]} */
+Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
 
+Object.defineProperty(Dependency.prototype, "module", {
 	/**
-	 * Schedules a build of the module object
-	 *
-	 * @param {Module} module module to be built
-	 * @param {ModuleCallback} callback the callback
-	 * @returns {void}
+	 * @deprecated
+	 * @returns {never} throws
 	 */
-	buildModule(module, callback) {
-		this.buildQueue.add(module, callback);
+	get() {
+		throw new Error(
+			"module property was removed from Dependency (use compilation.moduleGraph.getModule(dependency) instead)"
+		);
+	},
+
+	/**
+	 * @deprecated
+	 * @returns {never} throws
+	 */
+	set() {
+		throw new Error(
+			"module property was removed from Dependency (use compilation.moduleGraph.updateModule(dependency, module) instead)"
+		);
+	}
+});
+
+Object.defineProperty(Dependency.prototype, "disconnect", {
+	get() {
+		throw new Error(
+			"disconnect was removed from Dependency (Dependency no longer carries graph specific information)"
+		);
 	}
+});
+
+Dependency.TRANSITIVE = TRANSITIVE;
+
+module.exports = Dependency;
+
+
+/***/ }),
+
+/***/ 5160:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @template T @typedef {import("./InitFragment")<T>} InitFragment */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+
+/**
+ * @typedef {Object} DependencyTemplateContext
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {Set<string>} runtimeRequirements the requirements for runtime
+ * @property {Module} module current module
+ * @property {RuntimeSpec} runtime current runtimes, for which code is generated
+ * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
+ * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults} codeGenerationResults the code generation results
+ */
+
+/**
+ * @typedef {Object} CssDependencyTemplateContextExtras
+ * @property {Map<string, string>} cssExports the css exports
+ */
+
+/** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */
 
+class DependencyTemplate {
+	/* istanbul ignore next */
 	/**
-	 * Builds the module object
-	 *
-	 * @param {Module} module module to be built
-	 * @param {ModuleCallback} callback the callback
+	 * @abstract
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	_buildModule(module, callback) {
-		const currentProfile = this.profile
-			? this.moduleGraph.getProfile(module)
-			: undefined;
-		if (currentProfile !== undefined) {
-			currentProfile.markBuildingStart();
-		}
+	apply(dependency, source, templateContext) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+}
 
-		module.needBuild(
-			{
-				compilation: this,
-				fileSystemInfo: this.fileSystemInfo,
-				valueCacheVersions: this.valueCacheVersions
-			},
-			(err, needBuild) => {
-				if (err) return callback(err);
+module.exports = DependencyTemplate;
 
-				if (!needBuild) {
-					if (currentProfile !== undefined) {
-						currentProfile.markBuildingEnd();
-					}
-					this.hooks.stillValidModule.call(module);
-					return callback();
-				}
 
-				this.hooks.buildModule.call(module);
-				this.builtModules.add(module);
-				module.build(
-					this.options,
-					this,
-					this.resolverFactory.get("normal", module.resolveOptions),
-					this.inputFileSystem,
-					err => {
-						if (currentProfile !== undefined) {
-							currentProfile.markBuildingEnd();
-						}
-						if (err) {
-							this.hooks.failedModule.call(module, err);
-							return callback(err);
-						}
-						if (currentProfile !== undefined) {
-							currentProfile.markStoringStart();
-						}
-						this._modulesCache.store(module.identifier(), null, module, err => {
-							if (currentProfile !== undefined) {
-								currentProfile.markStoringEnd();
-							}
-							if (err) {
-								this.hooks.failedModule.call(module, err);
-								return callback(new ModuleStoreError(module, err));
-							}
-							this.hooks.succeedModule.call(module);
-							return callback();
-						});
-					}
-				);
-			}
-		);
+/***/ }),
+
+/***/ 9163:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const createHash = __webpack_require__(49835);
+
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {typeof import("./util/Hash")} Hash */
+
+/** @typedef {new (...args: any[]) => Dependency} DependencyConstructor */
+
+class DependencyTemplates {
+	/**
+	 * @param {string | Hash} hashFunction the hash function to use
+	 */
+	constructor(hashFunction = "md4") {
+		/** @type {Map<Function, DependencyTemplate>} */
+		this._map = new Map();
+		/** @type {string} */
+		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
+		this._hashFunction = hashFunction;
 	}
 
 	/**
-	 * @param {Module} module to be processed for deps
-	 * @param {ModuleCallback} callback callback to be triggered
-	 * @returns {void}
+	 * @param {DependencyConstructor} dependency Constructor of Dependency
+	 * @returns {DependencyTemplate} template for this dependency
 	 */
-	processModuleDependencies(module, callback) {
-		this.processDependenciesQueue.add(module, callback);
+	get(dependency) {
+		return this._map.get(dependency);
 	}
 
 	/**
-	 * @param {Module} module to be processed for deps
+	 * @param {DependencyConstructor} dependency Constructor of Dependency
+	 * @param {DependencyTemplate} dependencyTemplate template for this dependency
 	 * @returns {void}
 	 */
-	processModuleDependenciesNonRecursive(module) {
-		const processDependenciesBlock = block => {
-			if (block.dependencies) {
-				let i = 0;
-				for (const dep of block.dependencies) {
-					this.moduleGraph.setParents(dep, block, module, i++);
-				}
-			}
-			if (block.blocks) {
-				for (const b of block.blocks) processDependenciesBlock(b);
-			}
-		};
-
-		processDependenciesBlock(module);
+	set(dependency, dependencyTemplate) {
+		this._map.set(dependency, dependencyTemplate);
 	}
 
 	/**
-	 * @param {Module} module to be processed for deps
-	 * @param {ModuleCallback} callback callback to be triggered
+	 * @param {string} part additional hash contributor
 	 * @returns {void}
 	 */
-	_processModuleDependencies(module, callback) {
-		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
-		const sortedDependencies = [];
+	updateHash(part) {
+		const hash = createHash(this._hashFunction);
+		hash.update(`${this._hash}${part}`);
+		this._hash = /** @type {string} */ (hash.digest("hex"));
+	}
 
-		/** @type {DependenciesBlock} */
-		let currentBlock;
+	getHash() {
+		return this._hash;
+	}
 
-		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
-		let dependencies;
-		/** @type {DepConstructor} */
-		let factoryCacheKey;
-		/** @type {ModuleFactory} */
-		let factoryCacheKey2;
-		/** @type {Map<string, Dependency[]>} */
-		let factoryCacheValue;
-		/** @type {string} */
-		let listCacheKey1;
-		/** @type {string} */
-		let listCacheKey2;
-		/** @type {Dependency[]} */
-		let listCacheValue;
+	clone() {
+		const newInstance = new DependencyTemplates(this._hashFunction);
+		newInstance._map = new Map(this._map);
+		newInstance._hash = this._hash;
+		return newInstance;
+	}
+}
 
-		let inProgressSorting = 1;
-		let inProgressTransitive = 1;
+module.exports = DependencyTemplates;
 
-		const onDependenciesSorted = err => {
-			if (err) return callback(err);
 
-			// early exit without changing parallelism back and forth
-			if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
-				return callback();
-			}
+/***/ }),
 
-			// This is nested so we need to allow one additional task
-			this.processDependenciesQueue.increaseParallelism();
+/***/ 62790:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			for (const item of sortedDependencies) {
-				inProgressTransitive++;
-				this.handleModuleCreation(item, err => {
-					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
-					// errors are created inside closures that keep a reference to the Compilation, so errors are
-					// leaking the Compilation object.
-					if (err && this.bail) {
-						if (inProgressTransitive <= 0) return;
-						inProgressTransitive = -1;
-						// eslint-disable-next-line no-self-assign
-						err.stack = err.stack;
-						onTransitiveTasksFinished(err);
-						return;
-					}
-					if (--inProgressTransitive === 0) onTransitiveTasksFinished();
-				});
-			}
-			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const onTransitiveTasksFinished = err => {
-			if (err) return callback(err);
-			this.processDependenciesQueue.decreaseParallelism();
 
-			return callback();
-		};
 
-		/**
-		 * @param {Dependency} dep dependency
-		 * @param {number} index index in block
-		 * @returns {void}
-		 */
-		const processDependency = (dep, index) => {
-			this.moduleGraph.setParents(dep, currentBlock, module, index);
-			if (this._unsafeCache) {
-				try {
-					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
-					if (unsafeCachedModule === null) return;
-					if (unsafeCachedModule !== undefined) {
-						if (
-							this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
-						) {
-							this._handleExistingModuleFromUnsafeCache(
-								module,
-								dep,
-								unsafeCachedModule
-							);
-							return;
-						}
-						const identifier = unsafeCachedModule.identifier();
-						const cachedModule =
-							this._restoredUnsafeCacheEntries.get(identifier);
-						if (cachedModule !== undefined) {
-							// update unsafe cache to new module
-							unsafeCacheDependencies.set(dep, cachedModule);
-							this._handleExistingModuleFromUnsafeCache(
-								module,
-								dep,
-								cachedModule
-							);
-							return;
-						}
-						inProgressSorting++;
-						this._modulesCache.get(identifier, null, (err, cachedModule) => {
-							if (err) {
-								if (inProgressSorting <= 0) return;
-								inProgressSorting = -1;
-								onDependenciesSorted(err);
-								return;
-							}
-							try {
-								if (!this._restoredUnsafeCacheEntries.has(identifier)) {
-									const data = unsafeCacheData.get(cachedModule);
-									if (data === undefined) {
-										processDependencyForResolving(dep);
-										if (--inProgressSorting === 0) onDependenciesSorted();
-										return;
-									}
-									if (cachedModule !== unsafeCachedModule) {
-										unsafeCacheDependencies.set(dep, cachedModule);
-									}
-									cachedModule.restoreFromUnsafeCache(
-										data,
-										this.params.normalModuleFactory,
-										this.params
-									);
-									this._restoredUnsafeCacheEntries.set(
-										identifier,
-										cachedModule
-									);
-									this._restoredUnsafeCacheModuleEntries.add(cachedModule);
-									if (!this.modules.has(cachedModule)) {
-										inProgressTransitive++;
-										this._handleNewModuleFromUnsafeCache(
-											module,
-											dep,
-											cachedModule,
-											err => {
-												if (err) {
-													if (inProgressTransitive <= 0) return;
-													inProgressTransitive = -1;
-													onTransitiveTasksFinished(err);
-												}
-												if (--inProgressTransitive === 0)
-													return onTransitiveTasksFinished();
-											}
-										);
-										if (--inProgressSorting === 0) onDependenciesSorted();
-										return;
-									}
-								}
-								if (unsafeCachedModule !== cachedModule) {
-									unsafeCacheDependencies.set(dep, cachedModule);
-								}
-								this._handleExistingModuleFromUnsafeCache(
-									module,
-									dep,
-									cachedModule
-								); // a3
-							} catch (err) {
-								if (inProgressSorting <= 0) return;
-								inProgressSorting = -1;
-								onDependenciesSorted(err);
-								return;
-							}
-							if (--inProgressSorting === 0) onDependenciesSorted();
-						});
-						return;
-					}
-				} catch (e) {
-					console.error(e);
-				}
-			}
-			processDependencyForResolving(dep);
-		};
+const DllModuleFactory = __webpack_require__(68703);
+const DllEntryDependency = __webpack_require__(95666);
+const EntryDependency = __webpack_require__(3979);
 
-		/**
-		 * @param {Dependency} dep dependency
-		 * @returns {void}
-		 */
-		const processDependencyForResolving = dep => {
-			const resourceIdent = dep.getResourceIdentifier();
-			if (resourceIdent !== undefined && resourceIdent !== null) {
-				const category = dep.category;
-				const constructor = /** @type {DepConstructor} */ (dep.constructor);
-				if (factoryCacheKey === constructor) {
-					// Fast path 1: same constructor as prev item
-					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
-						// Super fast path 1: also same resource
-						listCacheValue.push(dep);
-						return;
-					}
-				} else {
-					const factory = this.dependencyFactories.get(constructor);
-					if (factory === undefined) {
-						throw new Error(
-							`No module factory available for dependency type: ${constructor.name}`
-						);
-					}
-					if (factoryCacheKey2 === factory) {
-						// Fast path 2: same factory as prev item
-						factoryCacheKey = constructor;
-						if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
-							// Super fast path 2: also same resource
-							listCacheValue.push(dep);
-							return;
-						}
-					} else {
-						// Slow path
-						if (factoryCacheKey2 !== undefined) {
-							// Archive last cache entry
-							if (dependencies === undefined) dependencies = new Map();
-							dependencies.set(factoryCacheKey2, factoryCacheValue);
-							factoryCacheValue = dependencies.get(factory);
-							if (factoryCacheValue === undefined) {
-								factoryCacheValue = new Map();
-							}
-						} else {
-							factoryCacheValue = new Map();
-						}
-						factoryCacheKey = constructor;
-						factoryCacheKey2 = factory;
-					}
-				}
-				// Here webpack is using heuristic that assumes
-				// mostly esm dependencies would be used
-				// so we don't allocate extra string for them
-				const cacheKey =
-					category === esmDependencyCategory
-						? resourceIdent
-						: `${category}${resourceIdent}`;
-				let list = factoryCacheValue.get(cacheKey);
-				if (list === undefined) {
-					factoryCacheValue.set(cacheKey, (list = []));
-					sortedDependencies.push({
-						factory: factoryCacheKey2,
-						dependencies: list,
-						originModule: module
-					});
-				}
-				list.push(dep);
-				listCacheKey1 = category;
-				listCacheKey2 = resourceIdent;
-				listCacheValue = list;
+class DllEntryPlugin {
+	constructor(context, entries, options) {
+		this.context = context;
+		this.entries = entries;
+		this.options = options;
+	}
+
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DllEntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const dllModuleFactory = new DllModuleFactory();
+				compilation.dependencyFactories.set(
+					DllEntryDependency,
+					dllModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					EntryDependency,
+					normalModuleFactory
+				);
 			}
-		};
+		);
+		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
+			compilation.addEntry(
+				this.context,
+				new DllEntryDependency(
+					this.entries.map((e, idx) => {
+						const dep = new EntryDependency(e);
+						dep.loc = {
+							name: this.options.name,
+							index: idx
+						};
+						return dep;
+					}),
+					this.options.name
+				),
+				this.options,
+				callback
+			);
+		});
+	}
+}
 
-		try {
-			/** @type {DependenciesBlock[]} */
-			const queue = [module];
-			do {
-				const block = queue.pop();
-				if (block.dependencies) {
-					currentBlock = block;
-					let i = 0;
-					for (const dep of block.dependencies) processDependency(dep, i++);
-				}
-				if (block.blocks) {
-					for (const b of block.blocks) queue.push(b);
-				}
-			} while (queue.length !== 0);
-		} catch (e) {
-			return callback(e);
-		}
+module.exports = DllEntryPlugin;
 
-		if (--inProgressSorting === 0) onDependenciesSorted();
+
+/***/ }),
+
+/***/ 28280:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").SourceContext} SourceContext */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([
+	RuntimeGlobals.require,
+	RuntimeGlobals.module
+]);
+
+class DllModule extends Module {
+	constructor(context, dependencies, name) {
+		super("javascript/dynamic", context);
+
+		// Info from Factory
+		this.dependencies = dependencies;
+		this.name = name;
 	}
 
-	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
-		const moduleGraph = this.moduleGraph;
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
 
-		moduleGraph.setResolvedModule(originModule, dependency, module);
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `dll ${this.name}`;
+	}
 
-		moduleGraph.setIssuerIfUnset(
-			module,
-			originModule !== undefined ? originModule : null
-		);
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `dll ${this.name}`;
+	}
 
-		this._modules.set(module.identifier(), module);
-		this.modules.add(module);
-		if (this._backCompat)
-			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {};
+		return callback();
+	}
 
-		this._handleModuleBuildAndDependencies(
-			originModule,
-			module,
-			true,
-			callback
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		const sources = new Map();
+		sources.set(
+			"javascript",
+			new RawSource("module.exports = __webpack_require__;")
 		);
+		return {
+			sources,
+			runtimeRequirements: RUNTIME_REQUIREMENTS
+		};
 	}
 
-	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
-		const moduleGraph = this.moduleGraph;
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
+	}
 
-		moduleGraph.setResolvedModule(originModule, dependency, module);
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 12;
 	}
 
 	/**
-	 * @typedef {Object} HandleModuleCreationOptions
-	 * @property {ModuleFactory} factory
-	 * @property {Dependency[]} dependencies
-	 * @property {Module | null} originModule
-	 * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
-	 * @property {string=} context
-	 * @property {boolean=} recursive recurse into dependencies of the created module
-	 * @property {boolean=} connectOrigin connect the resolved module with the origin module
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
 	 */
+	updateHash(hash, context) {
+		hash.update(`dll module${this.name || ""}`);
+		super.updateHash(hash, context);
+	}
+
+	serialize(context) {
+		context.write(this.name);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		this.name = context.read();
+		super.deserialize(context);
+	}
 
 	/**
-	 * @param {HandleModuleCreationOptions} options options object
-	 * @param {ModuleCallback} callback callback
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
 	 * @returns {void}
 	 */
-	handleModuleCreation(
-		{
-			factory,
-			dependencies,
-			originModule,
-			contextInfo,
-			context,
-			recursive = true,
-			connectOrigin = recursive
-		},
-		callback
-	) {
-		const moduleGraph = this.moduleGraph;
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		this.dependencies = module.dependencies;
+	}
 
-		const currentProfile = this.profile ? new ModuleProfile() : undefined;
+	/**
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		super.cleanupForCache();
+		this.dependencies = undefined;
+	}
+}
 
-		this.factorizeModule(
-			{
-				currentProfile,
-				factory,
-				dependencies,
-				factoryResult: true,
-				originModule,
-				contextInfo,
-				context
-			},
-			(err, factoryResult) => {
-				const applyFactoryResultDependencies = () => {
-					const { fileDependencies, contextDependencies, missingDependencies } =
-						factoryResult;
-					if (fileDependencies) {
-						this.fileDependencies.addAll(fileDependencies);
-					}
-					if (contextDependencies) {
-						this.contextDependencies.addAll(contextDependencies);
-					}
-					if (missingDependencies) {
-						this.missingDependencies.addAll(missingDependencies);
-					}
-				};
-				if (err) {
-					if (factoryResult) applyFactoryResultDependencies();
-					if (dependencies.every(d => d.optional)) {
-						this.warnings.push(err);
-						return callback();
-					} else {
-						this.errors.push(err);
-						return callback(err);
-					}
-				}
+makeSerializable(DllModule, "webpack/lib/DllModule");
 
-				const newModule = factoryResult.module;
+module.exports = DllModule;
 
-				if (!newModule) {
-					applyFactoryResultDependencies();
-					return callback();
-				}
 
-				if (currentProfile !== undefined) {
-					moduleGraph.setProfile(newModule, currentProfile);
-				}
+/***/ }),
 
-				this.addModule(newModule, (err, module) => {
-					if (err) {
-						applyFactoryResultDependencies();
-						if (!err.module) {
-							err.module = module;
-						}
-						this.errors.push(err);
+/***/ 68703:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						return callback(err);
-					}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					if (
-						this._unsafeCache &&
-						factoryResult.cacheable !== false &&
-						/** @type {any} */ (module).restoreFromUnsafeCache &&
-						this._unsafeCachePredicate(module)
-					) {
-						const unsafeCacheableModule =
-							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
-								module
-							);
-						for (let i = 0; i < dependencies.length; i++) {
-							const dependency = dependencies[i];
-							moduleGraph.setResolvedModule(
-								connectOrigin ? originModule : null,
-								dependency,
-								unsafeCacheableModule
-							);
-							unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
-						}
-						if (!unsafeCacheData.has(unsafeCacheableModule)) {
-							unsafeCacheData.set(
-								unsafeCacheableModule,
-								unsafeCacheableModule.getUnsafeCacheData()
-							);
-						}
-					} else {
-						applyFactoryResultDependencies();
-						for (let i = 0; i < dependencies.length; i++) {
-							const dependency = dependencies[i];
-							moduleGraph.setResolvedModule(
-								connectOrigin ? originModule : null,
-								dependency,
-								module
-							);
-						}
-					}
 
-					moduleGraph.setIssuerIfUnset(
-						module,
-						originModule !== undefined ? originModule : null
-					);
-					if (module !== newModule) {
-						if (currentProfile !== undefined) {
-							const otherProfile = moduleGraph.getProfile(module);
-							if (otherProfile !== undefined) {
-								currentProfile.mergeInto(otherProfile);
-							} else {
-								moduleGraph.setProfile(module, currentProfile);
-							}
-						}
-					}
 
-					this._handleModuleBuildAndDependencies(
-						originModule,
-						module,
-						recursive,
-						callback
-					);
-				});
-			}
-		);
+const DllModule = __webpack_require__(28280);
+const ModuleFactory = __webpack_require__(51010);
+
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./dependencies/DllEntryDependency")} DllEntryDependency */
+
+class DllModuleFactory extends ModuleFactory {
+	constructor() {
+		super();
+		this.hooks = Object.freeze({});
+	}
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dependency = /** @type {DllEntryDependency} */ (data.dependencies[0]);
+		callback(null, {
+			module: new DllModule(
+				data.context,
+				dependency.dependencies,
+				dependency.name
+			)
+		});
 	}
+}
 
-	_handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
-		// Check for cycles when build is trigger inside another build
-		let creatingModuleDuringBuildSet = undefined;
-		if (!recursive && this.buildQueue.isProcessing(originModule)) {
-			// Track build dependency
-			creatingModuleDuringBuildSet =
-				this.creatingModuleDuringBuild.get(originModule);
-			if (creatingModuleDuringBuildSet === undefined) {
-				creatingModuleDuringBuildSet = new Set();
-				this.creatingModuleDuringBuild.set(
-					originModule,
-					creatingModuleDuringBuildSet
-				);
-			}
-			creatingModuleDuringBuildSet.add(module);
+module.exports = DllModuleFactory;
 
-			// When building is blocked by another module
-			// search for a cycle, cancel the cycle by throwing
-			// an error (otherwise this would deadlock)
-			const blockReasons = this.creatingModuleDuringBuild.get(module);
-			if (blockReasons !== undefined) {
-				const set = new Set(blockReasons);
-				for (const item of set) {
-					const blockReasons = this.creatingModuleDuringBuild.get(item);
-					if (blockReasons !== undefined) {
-						for (const m of blockReasons) {
-							if (m === module) {
-								return callback(new BuildCycleError(module));
-							}
-							set.add(m);
-						}
-					}
-				}
-			}
-		}
 
-		this.buildModule(module, err => {
-			if (creatingModuleDuringBuildSet !== undefined) {
-				creatingModuleDuringBuildSet.delete(module);
-			}
-			if (err) {
-				if (!err.module) {
-					err.module = module;
-				}
-				this.errors.push(err);
+/***/ }),
 
-				return callback(err);
-			}
+/***/ 40038:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			if (!recursive) {
-				this.processModuleDependenciesNonRecursive(module);
-				callback(null, module);
-				return;
-			}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			// This avoids deadlocks for circular dependencies
-			if (this.processDependenciesQueue.isProcessing(module)) {
-				return callback();
-			}
 
-			this.processModuleDependencies(module, err => {
-				if (err) {
-					return callback(err);
-				}
-				callback(null, module);
-			});
-		});
-	}
 
-	/**
-	 * @param {FactorizeModuleOptions} options options object
-	 * @param {ModuleOrFactoryResultCallback} callback callback
-	 * @returns {void}
-	 */
-	_factorizeModule(
-		{
-			currentProfile,
-			factory,
-			dependencies,
-			originModule,
-			factoryResult,
-			contextInfo,
-			context
-		},
-		callback
-	) {
-		if (currentProfile !== undefined) {
-			currentProfile.markFactoryStart();
-		}
-		factory.create(
-			{
-				contextInfo: {
-					issuer: originModule ? originModule.nameForCondition() : "",
-					issuerLayer: originModule ? originModule.layer : null,
-					compiler: this.compiler.name,
-					...contextInfo
-				},
-				resolveOptions: originModule ? originModule.resolveOptions : undefined,
-				context: context
-					? context
-					: originModule
-					? originModule.context
-					: this.compiler.context,
-				dependencies: dependencies
-			},
-			(err, result) => {
-				if (result) {
-					// TODO webpack 6: remove
-					// For backward-compat
-					if (result.module === undefined && result instanceof Module) {
-						result = {
-							module: result
-						};
-					}
-					if (!factoryResult) {
-						const {
-							fileDependencies,
-							contextDependencies,
-							missingDependencies
-						} = result;
-						if (fileDependencies) {
-							this.fileDependencies.addAll(fileDependencies);
-						}
-						if (contextDependencies) {
-							this.contextDependencies.addAll(contextDependencies);
-						}
-						if (missingDependencies) {
-							this.missingDependencies.addAll(missingDependencies);
-						}
-					}
-				}
-				if (err) {
-					const notFoundError = new ModuleNotFoundError(
-						originModule,
-						err,
-						dependencies.map(d => d.loc).filter(Boolean)[0]
-					);
-					return callback(notFoundError, factoryResult ? result : undefined);
-				}
-				if (!result) {
-					return callback();
-				}
+const DllEntryPlugin = __webpack_require__(62790);
+const FlagAllModulesAsUsedPlugin = __webpack_require__(58727);
+const LibManifestPlugin = __webpack_require__(93837);
+const createSchemaValidation = __webpack_require__(32540);
 
-				if (currentProfile !== undefined) {
-					currentProfile.markFactoryEnd();
-				}
+/** @typedef {import("../declarations/plugins/DllPlugin").DllPluginOptions} DllPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
 
-				callback(null, factoryResult ? result : result.module);
-			}
-		);
+const validate = createSchemaValidation(
+	__webpack_require__(9667),
+	() => __webpack_require__(99926),
+	{
+		name: "Dll Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class DllPlugin {
 	/**
-	 * @param {string} context context string path
-	 * @param {Dependency} dependency dependency used to create Module chain
-	 * @param {ModuleCallback} callback callback for when module chain is complete
-	 * @returns {void} will throw if dependency instance is not a valid Dependency
+	 * @param {DllPluginOptions} options options object
 	 */
-	addModuleChain(context, dependency, callback) {
-		return this.addModuleTree({ context, dependency }, callback);
+	constructor(options) {
+		validate(options);
+		this.options = {
+			...options,
+			entryOnly: options.entryOnly !== false
+		};
 	}
 
 	/**
-	 * @param {Object} options options
-	 * @param {string} options.context context string path
-	 * @param {Dependency} options.dependency dependency used to create Module chain
-	 * @param {Partial<ModuleFactoryCreateDataContextInfo>=} options.contextInfo additional context info for the root module
-	 * @param {ModuleCallback} callback callback for when module chain is complete
-	 * @returns {void} will throw if dependency instance is not a valid Dependency
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	addModuleTree({ context, dependency, contextInfo }, callback) {
-		if (
-			typeof dependency !== "object" ||
-			dependency === null ||
-			!dependency.constructor
-		) {
-			return callback(
-				new WebpackError("Parameter 'dependency' must be a Dependency")
-			);
-		}
-		const Dep = /** @type {DepConstructor} */ (dependency.constructor);
-		const moduleFactory = this.dependencyFactories.get(Dep);
-		if (!moduleFactory) {
-			return callback(
-				new WebpackError(
-					`No dependency factory available for this dependency type: ${dependency.constructor.name}`
-				)
-			);
-		}
-
-		this.handleModuleCreation(
-			{
-				factory: moduleFactory,
-				dependencies: [dependency],
-				originModule: null,
-				contextInfo,
-				context
-			},
-			(err, result) => {
-				if (err && this.bail) {
-					callback(err);
-					this.buildQueue.stop();
-					this.rebuildQueue.stop();
-					this.processDependenciesQueue.stop();
-					this.factorizeQueue.stop();
-				} else if (!err && result) {
-					callback(null, result);
-				} else {
-					callback();
+	apply(compiler) {
+		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
+			if (typeof entry !== "function") {
+				for (const name of Object.keys(entry)) {
+					const options = {
+						name,
+						filename: entry.filename
+					};
+					new DllEntryPlugin(context, entry[name].import, options).apply(
+						compiler
+					);
 				}
+			} else {
+				throw new Error(
+					"DllPlugin doesn't support dynamic entry (function) yet"
+				);
 			}
-		);
+			return true;
+		});
+		new LibManifestPlugin(this.options).apply(compiler);
+		if (!this.options.entryOnly) {
+			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
+		}
 	}
+}
 
-	/**
-	 * @param {string} context context path for entry
-	 * @param {Dependency} entry entry dependency that should be followed
-	 * @param {string | EntryOptions} optionsOrName options or deprecated name of entry
-	 * @param {ModuleCallback} callback callback function
-	 * @returns {void} returns
-	 */
-	addEntry(context, entry, optionsOrName, callback) {
-		// TODO webpack 6 remove
-		const options =
-			typeof optionsOrName === "object"
-				? optionsOrName
-				: { name: optionsOrName };
+module.exports = DllPlugin;
 
-		this._addEntryItem(context, entry, "dependencies", options, callback);
-	}
 
-	/**
-	 * @param {string} context context path for entry
-	 * @param {Dependency} dependency dependency that should be followed
-	 * @param {EntryOptions} options options
-	 * @param {ModuleCallback} callback callback function
-	 * @returns {void} returns
-	 */
-	addInclude(context, dependency, options, callback) {
-		this._addEntryItem(
-			context,
-			dependency,
-			"includeDependencies",
-			options,
-			callback
-		);
-	}
+/***/ }),
 
-	/**
-	 * @param {string} context context path for entry
-	 * @param {Dependency} entry entry dependency that should be followed
-	 * @param {"dependencies" | "includeDependencies"} target type of entry
-	 * @param {EntryOptions} options options
-	 * @param {ModuleCallback} callback callback function
-	 * @returns {void} returns
-	 */
-	_addEntryItem(context, entry, target, options, callback) {
-		const { name } = options;
-		let entryData =
-			name !== undefined ? this.entries.get(name) : this.globalEntry;
-		if (entryData === undefined) {
-			entryData = {
-				dependencies: [],
-				includeDependencies: [],
-				options: {
-					name: undefined,
-					...options
-				}
-			};
-			entryData[target].push(entry);
-			this.entries.set(name, entryData);
-		} else {
-			entryData[target].push(entry);
-			for (const key of Object.keys(options)) {
-				if (options[key] === undefined) continue;
-				if (entryData.options[key] === options[key]) continue;
-				if (
-					Array.isArray(entryData.options[key]) &&
-					Array.isArray(options[key]) &&
-					arrayEquals(entryData.options[key], options[key])
-				) {
-					continue;
-				}
-				if (entryData.options[key] === undefined) {
-					entryData.options[key] = options[key];
-				} else {
-					return callback(
-						new WebpackError(
-							`Conflicting entry option ${key} = ${entryData.options[key]} vs ${options[key]}`
-						)
-					);
-				}
-			}
-		}
+/***/ 90999:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		this.hooks.addEntry.call(entry, options);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		this.addModuleTree(
-			{
-				context,
-				dependency: entry,
-				contextInfo: entryData.options.layer
-					? { issuerLayer: entryData.options.layer }
-					: undefined
-			},
-			(err, module) => {
-				if (err) {
-					this.hooks.failedEntry.call(entry, options, err);
-					return callback(err);
-				}
-				this.hooks.succeedEntry.call(entry, options, module);
-				return callback(null, module);
-			}
-		);
+
+
+const parseJson = __webpack_require__(15235);
+const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
+const ExternalModuleFactoryPlugin = __webpack_require__(62153);
+const WebpackError = __webpack_require__(53799);
+const DelegatedSourceDependency = __webpack_require__(22914);
+const createSchemaValidation = __webpack_require__(32540);
+const makePathsRelative = (__webpack_require__(82186).makePathsRelative);
+
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
+/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
+
+const validate = createSchemaValidation(
+	__webpack_require__(28534),
+	() => __webpack_require__(46552),
+	{
+		name: "Dll Reference Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class DllReferencePlugin {
 	/**
-	 * @param {Module} module module to be rebuilt
-	 * @param {ModuleCallback} callback callback when module finishes rebuilding
-	 * @returns {void}
+	 * @param {DllReferencePluginOptions} options options object
 	 */
-	rebuildModule(module, callback) {
-		this.rebuildQueue.add(module, callback);
+	constructor(options) {
+		validate(options);
+		this.options = options;
+		/** @type {WeakMap<Object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
+		this._compilationData = new WeakMap();
 	}
 
-	/**
-	 * @param {Module} module module to be rebuilt
-	 * @param {ModuleCallback} callback callback when module finishes rebuilding
-	 * @returns {void}
-	 */
-	_rebuildModule(module, callback) {
-		this.hooks.rebuildModule.call(module);
-		const oldDependencies = module.dependencies.slice();
-		const oldBlocks = module.blocks.slice();
-		module.invalidateBuild();
-		this.buildQueue.invalidate(module);
-		this.buildModule(module, err => {
-			if (err) {
-				return this.hooks.finishRebuildingModule.callAsync(module, err2 => {
-					if (err2) {
-						callback(
-							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
-						);
-						return;
-					}
-					callback(err);
-				});
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DllReferencePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					DelegatedSourceDependency,
+					normalModuleFactory
+				);
 			}
+		);
 
-			this.processDependenciesQueue.invalidate(module);
-			this.moduleGraph.unfreeze();
-			this.processModuleDependencies(module, err => {
-				if (err) return callback(err);
-				this.removeReasonsOfDependencyBlock(module, {
-					dependencies: oldDependencies,
-					blocks: oldBlocks
-				});
-				this.hooks.finishRebuildingModule.callAsync(module, err2 => {
-					if (err2) {
-						callback(
-							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
-						);
-						return;
-					}
-					callback(null, module);
-				});
-			});
-		});
-	}
-
-	_computeAffectedModules(modules) {
-		const moduleMemCacheCache = this.compiler.moduleMemCaches;
-		if (!moduleMemCacheCache) return;
-		if (!this.moduleMemCaches) {
-			this.moduleMemCaches = new Map();
-			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
-		}
-		const { moduleGraph, moduleMemCaches } = this;
-		const affectedModules = new Set();
-		const infectedModules = new Set();
-		let statNew = 0;
-		let statChanged = 0;
-		let statUnchanged = 0;
-		let statReferencesChanged = 0;
-		let statWithoutBuild = 0;
-
-		const computeReferences = module => {
-			/** @type {WeakMap<Dependency, Module>} */
-			let references = undefined;
-			for (const connection of moduleGraph.getOutgoingConnections(module)) {
-				const d = connection.dependency;
-				const m = connection.module;
-				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
-				if (references === undefined) references = new WeakMap();
-				references.set(d, m);
-			}
-			return references;
-		};
-
-		/**
-		 * @param {Module} module the module
-		 * @param {WeakMap<Dependency, Module>} references references
-		 * @returns {boolean} true, when the references differ
-		 */
-		const compareReferences = (module, references) => {
-			if (references === undefined) return true;
-			for (const connection of moduleGraph.getOutgoingConnections(module)) {
-				const d = connection.dependency;
-				if (!d) continue;
-				const entry = references.get(d);
-				if (entry === undefined) continue;
-				if (entry !== connection.module) return false;
-			}
-			return true;
-		};
-
-		const modulesWithoutCache = new Set(modules);
-		for (const [module, cachedMemCache] of moduleMemCacheCache) {
-			if (modulesWithoutCache.has(module)) {
-				const buildInfo = module.buildInfo;
-				if (buildInfo) {
-					if (cachedMemCache.buildInfo !== buildInfo) {
-						// use a new one
-						const memCache = new WeakTupleMap();
-						moduleMemCaches.set(module, memCache);
-						affectedModules.add(module);
-						cachedMemCache.buildInfo = buildInfo;
-						cachedMemCache.references = computeReferences(module);
-						cachedMemCache.memCache = memCache;
-						statChanged++;
-					} else if (!compareReferences(module, cachedMemCache.references)) {
-						// use a new one
-						const memCache = new WeakTupleMap();
-						moduleMemCaches.set(module, memCache);
-						affectedModules.add(module);
-						cachedMemCache.references = computeReferences(module);
-						cachedMemCache.memCache = memCache;
-						statReferencesChanged++;
-					} else {
-						// keep the old mem cache
-						moduleMemCaches.set(module, cachedMemCache.memCache);
-						statUnchanged++;
+		compiler.hooks.beforeCompile.tapAsync(
+			"DllReferencePlugin",
+			(params, callback) => {
+				if ("manifest" in this.options) {
+					const manifest = this.options.manifest;
+					if (typeof manifest === "string") {
+						compiler.inputFileSystem.readFile(manifest, (err, result) => {
+							if (err) return callback(err);
+							const data = {
+								path: manifest,
+								data: undefined,
+								error: undefined
+							};
+							// Catch errors parsing the manifest so that blank
+							// or malformed manifest files don't kill the process.
+							try {
+								data.data = parseJson(result.toString("utf-8"));
+							} catch (e) {
+								// Store the error in the params so that it can
+								// be added as a compilation error later on.
+								const manifestPath = makePathsRelative(
+									compiler.options.context,
+									manifest,
+									compiler.root
+								);
+								data.error = new DllManifestError(manifestPath, e.message);
+							}
+							this._compilationData.set(params, data);
+							return callback();
+						});
+						return;
 					}
-				} else {
-					infectedModules.add(module);
-					moduleMemCacheCache.delete(module);
-					statWithoutBuild++;
 				}
-				modulesWithoutCache.delete(module);
-			} else {
-				moduleMemCacheCache.delete(module);
-			}
-		}
-
-		for (const module of modulesWithoutCache) {
-			const buildInfo = module.buildInfo;
-			if (buildInfo) {
-				// create a new entry
-				const memCache = new WeakTupleMap();
-				moduleMemCacheCache.set(module, {
-					buildInfo,
-					references: computeReferences(module),
-					memCache
-				});
-				moduleMemCaches.set(module, memCache);
-				affectedModules.add(module);
-				statNew++;
-			} else {
-				infectedModules.add(module);
-				statWithoutBuild++;
+				return callback();
 			}
-		}
+		);
 
-		const reduceAffectType = connections => {
-			let affected = false;
-			for (const { dependency } of connections) {
-				if (!dependency) continue;
-				const type = dependency.couldAffectReferencingModule();
-				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
-				if (type === false) continue;
-				affected = true;
-			}
-			return affected;
-		};
-		const directOnlyInfectedModules = new Set();
-		for (const module of infectedModules) {
-			for (const [
-				referencingModule,
-				connections
-			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-				if (!referencingModule) continue;
-				if (infectedModules.has(referencingModule)) continue;
-				const type = reduceAffectType(connections);
-				if (!type) continue;
-				if (type === true) {
-					directOnlyInfectedModules.add(referencingModule);
+		compiler.hooks.compile.tap("DllReferencePlugin", params => {
+			let name = this.options.name;
+			let sourceType = this.options.sourceType;
+			let content =
+				"content" in this.options ? this.options.content : undefined;
+			if ("manifest" in this.options) {
+				let manifestParameter = this.options.manifest;
+				let manifest;
+				if (typeof manifestParameter === "string") {
+					const data = this._compilationData.get(params);
+					// If there was an error parsing the manifest
+					// file, exit now because the error will be added
+					// as a compilation error in the "compilation" hook.
+					if (data.error) {
+						return;
+					}
+					manifest = data.data;
 				} else {
-					infectedModules.add(referencingModule);
+					manifest = manifestParameter;
 				}
-			}
-		}
-		for (const module of directOnlyInfectedModules) infectedModules.add(module);
-		const directOnlyAffectModules = new Set();
-		for (const module of affectedModules) {
-			for (const [
-				referencingModule,
-				connections
-			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-				if (!referencingModule) continue;
-				if (infectedModules.has(referencingModule)) continue;
-				if (affectedModules.has(referencingModule)) continue;
-				const type = reduceAffectType(connections);
-				if (!type) continue;
-				if (type === true) {
-					directOnlyAffectModules.add(referencingModule);
-				} else {
-					affectedModules.add(referencingModule);
+				if (manifest) {
+					if (!name) name = manifest.name;
+					if (!sourceType) sourceType = manifest.type;
+					if (!content) content = manifest.content;
 				}
-				const memCache = new WeakTupleMap();
-				const cache = moduleMemCacheCache.get(referencingModule);
-				cache.memCache = memCache;
-				moduleMemCaches.set(referencingModule, memCache);
 			}
-		}
-		for (const module of directOnlyAffectModules) affectedModules.add(module);
-		this.logger.log(
-			`${Math.round(
-				(100 * (affectedModules.size + infectedModules.size)) /
-					this.modules.size
-			)}% (${affectedModules.size} affected + ${
-				infectedModules.size
-			} infected of ${
-				this.modules.size
-			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
-		);
-	}
+			/** @type {Externals} */
+			const externals = {};
+			const source = "dll-reference " + name;
+			externals[source] = name;
+			const normalModuleFactory = params.normalModuleFactory;
+			new ExternalModuleFactoryPlugin(sourceType || "var", externals).apply(
+				normalModuleFactory
+			);
+			new DelegatedModuleFactoryPlugin({
+				source: source,
+				type: this.options.type,
+				scope: this.options.scope,
+				context: this.options.context || compiler.options.context,
+				content,
+				extensions: this.options.extensions,
+				associatedObjectForCache: compiler.root
+			}).apply(normalModuleFactory);
+		});
 
-	_computeAffectedModulesWithChunkGraph() {
-		const { moduleMemCaches } = this;
-		if (!moduleMemCaches) return;
-		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
-		const { moduleGraph, chunkGraph } = this;
-		const key = "memCache2";
-		let statUnchanged = 0;
-		let statChanged = 0;
-		let statNew = 0;
-		/**
-		 * @param {Module} module module
-		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
-		 */
-		const computeReferences = module => {
-			const id = chunkGraph.getModuleId(module);
-			/** @type {Map<Module, string | number | undefined>} */
-			let modules = undefined;
-			/** @type {(string | number)[] | undefined} */
-			let blocks = undefined;
-			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
-			if (outgoing !== undefined) {
-				for (const m of outgoing.keys()) {
-					if (!m) continue;
-					if (modules === undefined) modules = new Map();
-					modules.set(m, chunkGraph.getModuleId(m));
-				}
-			}
-			if (module.blocks.length > 0) {
-				blocks = [];
-				const queue = Array.from(module.blocks);
-				for (const block of queue) {
-					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-					if (chunkGroup) {
-						for (const chunk of chunkGroup.chunks) {
-							blocks.push(chunk.id);
+		compiler.hooks.compilation.tap(
+			"DllReferencePlugin",
+			(compilation, params) => {
+				if ("manifest" in this.options) {
+					let manifest = this.options.manifest;
+					if (typeof manifest === "string") {
+						const data = this._compilationData.get(params);
+						// If there was an error parsing the manifest file, add the
+						// error as a compilation error to make the compilation fail.
+						if (data.error) {
+							compilation.errors.push(data.error);
 						}
-					} else {
-						blocks.push(null);
+						compilation.fileDependencies.add(manifest);
 					}
-					queue.push.apply(queue, block.blocks);
 				}
 			}
-			return { id, modules, blocks };
-		};
-		/**
-		 * @param {Module} module module
-		 * @param {Object} references references
-		 * @param {string | number} references.id id
-		 * @param {Map<Module, string | number>=} references.modules modules
-		 * @param {(string | number)[]=} references.blocks blocks
-		 * @returns {boolean} ok?
-		 */
-		const compareReferences = (module, { id, modules, blocks }) => {
-			if (id !== chunkGraph.getModuleId(module)) return false;
-			if (modules !== undefined) {
-				for (const [module, id] of modules) {
-					if (chunkGraph.getModuleId(module) !== id) return false;
-				}
+		);
+	}
+}
+
+class DllManifestError extends WebpackError {
+	constructor(filename, message) {
+		super();
+
+		this.name = "DllManifestError";
+		this.message = `Dll manifest ${filename}\n${message}`;
+	}
+}
+
+module.exports = DllReferencePlugin;
+
+
+/***/ }),
+
+/***/ 96475:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Naoyuki Kanezawa @nkzawa
+*/
+
+
+
+const EntryOptionPlugin = __webpack_require__(9909);
+const EntryPlugin = __webpack_require__(96953);
+const EntryDependency = __webpack_require__(3979);
+
+/** @typedef {import("../declarations/WebpackOptions").EntryDynamicNormalized} EntryDynamic */
+/** @typedef {import("../declarations/WebpackOptions").EntryItem} EntryItem */
+/** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStatic */
+/** @typedef {import("./Compiler")} Compiler */
+
+class DynamicEntryPlugin {
+	/**
+	 * @param {string} context the context path
+	 * @param {EntryDynamic} entry the entry value
+	 */
+	constructor(context, entry) {
+		this.context = context;
+		this.entry = entry;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DynamicEntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					EntryDependency,
+					normalModuleFactory
+				);
 			}
-			if (blocks !== undefined) {
-				const queue = Array.from(module.blocks);
-				let i = 0;
-				for (const block of queue) {
-					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-					if (chunkGroup) {
-						for (const chunk of chunkGroup.chunks) {
-							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
+		);
+
+		compiler.hooks.make.tapPromise(
+			"DynamicEntryPlugin",
+			(compilation, callback) =>
+				Promise.resolve(this.entry())
+					.then(entry => {
+						const promises = [];
+						for (const name of Object.keys(entry)) {
+							const desc = entry[name];
+							const options = EntryOptionPlugin.entryDescriptionToOptions(
+								compiler,
+								name,
+								desc
+							);
+							for (const entry of desc.import) {
+								promises.push(
+									new Promise((resolve, reject) => {
+										compilation.addEntry(
+											this.context,
+											EntryPlugin.createDependency(entry, options),
+											options,
+											err => {
+												if (err) return reject(err);
+												resolve();
+											}
+										);
+									})
+								);
+							}
 						}
-					} else {
-						if (i >= blocks.length || blocks[i++] !== null) return false;
-					}
-					queue.push.apply(queue, block.blocks);
-				}
-				if (i !== blocks.length) return false;
-			}
+						return Promise.all(promises);
+					})
+					.then(x => {})
+		);
+	}
+}
+
+module.exports = DynamicEntryPlugin;
+
+
+/***/ }),
+
+/***/ 9909:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+
+class EntryOptionPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler instance one is tapping into
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
+			EntryOptionPlugin.applyEntryOption(compiler, context, entry);
 			return true;
-		};
+		});
+	}
 
-		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
-			const cache = memCache.get(key);
-			if (cache === undefined) {
-				const memCache2 = new WeakTupleMap();
-				memCache.set(key, {
-					references: computeReferences(module),
-					memCache: memCache2
-				});
-				moduleMemCaches2.set(module, memCache2);
-				statNew++;
-			} else if (!compareReferences(module, cache.references)) {
-				const memCache = new WeakTupleMap();
-				cache.references = computeReferences(module);
-				cache.memCache = memCache;
-				moduleMemCaches2.set(module, memCache);
-				statChanged++;
-			} else {
-				moduleMemCaches2.set(module, cache.memCache);
-				statUnchanged++;
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @param {string} context context directory
+	 * @param {Entry} entry request
+	 * @returns {void}
+	 */
+	static applyEntryOption(compiler, context, entry) {
+		if (typeof entry === "function") {
+			const DynamicEntryPlugin = __webpack_require__(96475);
+			new DynamicEntryPlugin(context, entry).apply(compiler);
+		} else {
+			const EntryPlugin = __webpack_require__(96953);
+			for (const name of Object.keys(entry)) {
+				const desc = entry[name];
+				const options = EntryOptionPlugin.entryDescriptionToOptions(
+					compiler,
+					name,
+					desc
+				);
+				for (const entry of desc.import) {
+					new EntryPlugin(context, entry, options).apply(compiler);
+				}
 			}
 		}
-
-		this.logger.log(
-			`${Math.round(
-				(100 * statChanged) / (statNew + statChanged + statUnchanged)
-			)}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)`
-		);
 	}
 
-	finish(callback) {
-		this.factorizeQueue.clear();
-		if (this.profile) {
-			this.logger.time("finish module profiles");
-			const ParallelismFactorCalculator = __webpack_require__(50780);
-			const p = new ParallelismFactorCalculator();
-			const moduleGraph = this.moduleGraph;
-			const modulesWithProfiles = new Map();
-			for (const module of this.modules) {
-				const profile = moduleGraph.getProfile(module);
-				if (!profile) continue;
-				modulesWithProfiles.set(module, profile);
-				p.range(
-					profile.buildingStartTime,
-					profile.buildingEndTime,
-					f => (profile.buildingParallelismFactor = f)
-				);
-				p.range(
-					profile.factoryStartTime,
-					profile.factoryEndTime,
-					f => (profile.factoryParallelismFactor = f)
-				);
-				p.range(
-					profile.integrationStartTime,
-					profile.integrationEndTime,
-					f => (profile.integrationParallelismFactor = f)
-				);
-				p.range(
-					profile.storingStartTime,
-					profile.storingEndTime,
-					f => (profile.storingParallelismFactor = f)
-				);
-				p.range(
-					profile.restoringStartTime,
-					profile.restoringEndTime,
-					f => (profile.restoringParallelismFactor = f)
-				);
-				if (profile.additionalFactoryTimes) {
-					for (const { start, end } of profile.additionalFactoryTimes) {
-						const influence = (end - start) / profile.additionalFactories;
-						p.range(
-							start,
-							end,
-							f =>
-								(profile.additionalFactoriesParallelismFactor += f * influence)
-						);
-					}
-				}
-			}
-			p.calculate();
-
-			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
-			const logByValue = (value, msg) => {
-				if (value > 1000) {
-					logger.error(msg);
-				} else if (value > 500) {
-					logger.warn(msg);
-				} else if (value > 200) {
-					logger.info(msg);
-				} else if (value > 30) {
-					logger.log(msg);
-				} else {
-					logger.debug(msg);
-				}
-			};
-			const logNormalSummary = (category, getDuration, getParallelism) => {
-				let sum = 0;
-				let max = 0;
-				for (const [module, profile] of modulesWithProfiles) {
-					const p = getParallelism(profile);
-					const d = getDuration(profile);
-					if (d === 0 || p === 0) continue;
-					const t = d / p;
-					sum += t;
-					if (t <= 10) continue;
-					logByValue(
-						t,
-						` | ${Math.round(t)} ms${
-							p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-						} ${category} > ${module.readableIdentifier(this.requestShortener)}`
-					);
-					max = Math.max(max, t);
-				}
-				if (sum <= 10) return;
-				logByValue(
-					Math.max(sum / 10, max),
-					`${Math.round(sum)} ms ${category}`
-				);
-			};
-			const logByLoadersSummary = (category, getDuration, getParallelism) => {
-				const map = new Map();
-				for (const [module, profile] of modulesWithProfiles) {
-					const list = provide(
-						map,
-						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
-						() => []
-					);
-					list.push({ module, profile });
-				}
-
-				let sum = 0;
-				let max = 0;
-				for (const [key, modules] of map) {
-					let innerSum = 0;
-					let innerMax = 0;
-					for (const { module, profile } of modules) {
-						const p = getParallelism(profile);
-						const d = getDuration(profile);
-						if (d === 0 || p === 0) continue;
-						const t = d / p;
-						innerSum += t;
-						if (t <= 10) continue;
-						logByValue(
-							t,
-							` |  | ${Math.round(t)} ms${
-								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-							} ${category} > ${module.readableIdentifier(
-								this.requestShortener
-							)}`
-						);
-						innerMax = Math.max(innerMax, t);
-					}
-					sum += innerSum;
-					if (innerSum <= 10) continue;
-					const idx = key.indexOf("!");
-					const loaders = key.slice(idx + 1);
-					const moduleType = key.slice(0, idx);
-					const t = Math.max(innerSum / 10, innerMax);
-					logByValue(
-						t,
-						` | ${Math.round(innerSum)} ms ${category} > ${
-							loaders
-								? `${
-										modules.length
-								  } x ${moduleType} with ${this.requestShortener.shorten(
-										loaders
-								  )}`
-								: `${modules.length} x ${moduleType}`
-						}`
-					);
-					max = Math.max(max, t);
-				}
-				if (sum <= 10) return;
-				logByValue(
-					Math.max(sum / 10, max),
-					`${Math.round(sum)} ms ${category}`
-				);
-			};
-			logNormalSummary(
-				"resolve to new modules",
-				p => p.factory,
-				p => p.factoryParallelismFactor
-			);
-			logNormalSummary(
-				"resolve to existing modules",
-				p => p.additionalFactories,
-				p => p.additionalFactoriesParallelismFactor
-			);
-			logNormalSummary(
-				"integrate modules",
-				p => p.restoring,
-				p => p.restoringParallelismFactor
-			);
-			logByLoadersSummary(
-				"build modules",
-				p => p.building,
-				p => p.buildingParallelismFactor
-			);
-			logNormalSummary(
-				"store modules",
-				p => p.storing,
-				p => p.storingParallelismFactor
-			);
-			logNormalSummary(
-				"restore modules",
-				p => p.restoring,
-				p => p.restoringParallelismFactor
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @param {string} name entry name
+	 * @param {EntryDescription} desc entry description
+	 * @returns {EntryOptions} options for the entry
+	 */
+	static entryDescriptionToOptions(compiler, name, desc) {
+		/** @type {EntryOptions} */
+		const options = {
+			name,
+			filename: desc.filename,
+			runtime: desc.runtime,
+			layer: desc.layer,
+			dependOn: desc.dependOn,
+			publicPath: desc.publicPath,
+			chunkLoading: desc.chunkLoading,
+			asyncChunks: desc.asyncChunks,
+			wasmLoading: desc.wasmLoading,
+			library: desc.library
+		};
+		if (desc.layer !== undefined && !compiler.options.experiments.layers) {
+			throw new Error(
+				"'entryOptions.layer' is only allowed when 'experiments.layers' is enabled"
 			);
-			this.logger.timeEnd("finish module profiles");
 		}
-		this.logger.time("compute affected modules");
-		this._computeAffectedModules(this.modules);
-		this.logger.timeEnd("compute affected modules");
-		this.logger.time("finish modules");
-		const { modules, moduleMemCaches } = this;
-		this.hooks.finishModules.callAsync(modules, err => {
-			this.logger.timeEnd("finish modules");
-			if (err) return callback(err);
+		if (desc.chunkLoading) {
+			const EnableChunkLoadingPlugin = __webpack_require__(61291);
+			EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading);
+		}
+		if (desc.wasmLoading) {
+			const EnableWasmLoadingPlugin = __webpack_require__(78613);
+			EnableWasmLoadingPlugin.checkEnabled(compiler, desc.wasmLoading);
+		}
+		if (desc.library) {
+			const EnableLibraryPlugin = __webpack_require__(91452);
+			EnableLibraryPlugin.checkEnabled(compiler, desc.library.type);
+		}
+		return options;
+	}
+}
 
-			// extract warnings and errors from modules
-			this.moduleGraph.freeze("dependency errors");
-			// TODO keep a cacheToken (= {}) for each module in the graph
-			// create a new one per compilation and flag all updated files
-			// and parents with it
-			this.logger.time("report dependency errors and warnings");
-			for (const module of modules) {
-				// TODO only run for modules with changed cacheToken
-				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
-				const memCache = moduleMemCaches && moduleMemCaches.get(module);
-				if (memCache && memCache.get("noWarningsOrErrors")) continue;
-				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
-					module
-				]);
-				const errors = module.getErrors();
-				if (errors !== undefined) {
-					for (const error of errors) {
-						if (!error.module) {
-							error.module = module;
-						}
-						this.errors.push(error);
-						hasProblems = true;
-					}
-				}
-				const warnings = module.getWarnings();
-				if (warnings !== undefined) {
-					for (const warning of warnings) {
-						if (!warning.module) {
-							warning.module = module;
-						}
-						this.warnings.push(warning);
-						hasProblems = true;
-					}
-				}
-				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
-			}
-			this.moduleGraph.unfreeze();
-			this.logger.timeEnd("report dependency errors and warnings");
+module.exports = EntryOptionPlugin;
 
-			callback();
-		});
-	}
 
-	unseal() {
-		this.hooks.unseal.call();
-		this.chunks.clear();
-		this.chunkGroups.length = 0;
-		this.namedChunks.clear();
-		this.namedChunkGroups.clear();
-		this.entrypoints.clear();
-		this.additionalChunkAssets.length = 0;
-		this.assets = {};
-		this.assetsInfo.clear();
-		this.moduleGraph.removeAllModuleAttributes();
-		this.moduleGraph.unfreeze();
-		this.moduleMemCaches2 = undefined;
+/***/ }),
+
+/***/ 96953:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const EntryDependency = __webpack_require__(3979);
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+
+class EntryPlugin {
+	/**
+	 * An entry plugin which will handle
+	 * creation of the EntryDependency
+	 *
+	 * @param {string} context context path
+	 * @param {string} entry entry path
+	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
+	 */
+	constructor(context, entry, options) {
+		this.context = context;
+		this.entry = entry;
+		this.options = options || "";
 	}
 
 	/**
-	 * @param {Callback} callback signals when the call finishes
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	seal(callback) {
-		const finalCallback = err => {
-			this.factorizeQueue.clear();
-			this.buildQueue.clear();
-			this.rebuildQueue.clear();
-			this.processDependenciesQueue.clear();
-			this.addModuleQueue.clear();
-			return callback(err);
-		};
-		const chunkGraph = new ChunkGraph(
-			this.moduleGraph,
-			this.outputOptions.hashFunction
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"EntryPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					EntryDependency,
+					normalModuleFactory
+				);
+			}
 		);
-		this.chunkGraph = chunkGraph;
 
-		if (this._backCompat) {
-			for (const module of this.modules) {
-				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
-			}
-		}
+		const { entry, options, context } = this;
+		const dep = EntryPlugin.createDependency(entry, options);
 
-		this.hooks.seal.call();
+		compiler.hooks.make.tapAsync("EntryPlugin", (compilation, callback) => {
+			compilation.addEntry(context, dep, options, err => {
+				callback(err);
+			});
+		});
+	}
 
-		this.logger.time("optimize dependencies");
-		while (this.hooks.optimizeDependencies.call(this.modules)) {
-			/* empty */
-		}
-		this.hooks.afterOptimizeDependencies.call(this.modules);
-		this.logger.timeEnd("optimize dependencies");
+	/**
+	 * @param {string} entry entry request
+	 * @param {EntryOptions | string} options entry options (passing string is deprecated)
+	 * @returns {EntryDependency} the dependency
+	 */
+	static createDependency(entry, options) {
+		const dep = new EntryDependency(entry);
+		// TODO webpack 6 remove string option
+		dep.loc = { name: typeof options === "object" ? options.name : options };
+		return dep;
+	}
+}
 
-		this.logger.time("create chunks");
-		this.hooks.beforeChunks.call();
-		this.moduleGraph.freeze("seal");
-		/** @type {Map<Entrypoint, Module[]>} */
-		const chunkGraphInit = new Map();
-		for (const [name, { dependencies, includeDependencies, options }] of this
-			.entries) {
-			const chunk = this.addChunk(name);
-			if (options.filename) {
-				chunk.filenameTemplate = options.filename;
-			}
-			const entrypoint = new Entrypoint(options);
-			if (!options.dependOn && !options.runtime) {
-				entrypoint.setRuntimeChunk(chunk);
-			}
-			entrypoint.setEntrypointChunk(chunk);
-			this.namedChunkGroups.set(name, entrypoint);
-			this.entrypoints.set(name, entrypoint);
-			this.chunkGroups.push(entrypoint);
-			connectChunkGroupAndChunk(entrypoint, chunk);
+module.exports = EntryPlugin;
 
-			const entryModules = new Set();
-			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
-				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
 
-				const module = this.moduleGraph.getModule(dep);
-				if (module) {
-					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-					entryModules.add(module);
-					const modulesList = chunkGraphInit.get(entrypoint);
-					if (modulesList === undefined) {
-						chunkGraphInit.set(entrypoint, [module]);
-					} else {
-						modulesList.push(module);
-					}
-				}
-			}
+/***/ }),
 
-			this.assignDepths(entryModules);
+/***/ 13795:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			const mapAndSort = deps =>
-				deps
-					.map(dep => this.moduleGraph.getModule(dep))
-					.filter(Boolean)
-					.sort(compareModulesByIdentifier);
-			const includedModules = [
-				...mapAndSort(this.globalEntry.includeDependencies),
-				...mapAndSort(includeDependencies)
-			];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			let modulesList = chunkGraphInit.get(entrypoint);
-			if (modulesList === undefined) {
-				chunkGraphInit.set(entrypoint, (modulesList = []));
-			}
-			for (const module of includedModules) {
-				this.assignDepth(module);
-				modulesList.push(module);
-			}
-		}
-		const runtimeChunks = new Set();
-		outer: for (const [
-			name,
-			{
-				options: { dependOn, runtime }
-			}
-		] of this.entries) {
-			if (dependOn && runtime) {
-				const err =
-					new WebpackError(`Entrypoint '${name}' has 'dependOn' and 'runtime' specified. This is not valid.
-Entrypoints that depend on other entrypoints do not have their own runtime.
-They will use the runtime(s) from referenced entrypoints instead.
-Remove the 'runtime' option from the entrypoint.`);
-				const entry = this.entrypoints.get(name);
-				err.chunk = entry.getEntrypointChunk();
-				this.errors.push(err);
-			}
-			if (dependOn) {
-				const entry = this.entrypoints.get(name);
-				const referencedChunks = entry
-					.getEntrypointChunk()
-					.getAllReferencedChunks();
-				const dependOnEntries = [];
-				for (const dep of dependOn) {
-					const dependency = this.entrypoints.get(dep);
-					if (!dependency) {
-						throw new Error(
-							`Entry ${name} depends on ${dep}, but this entry was not found`
-						);
-					}
-					if (referencedChunks.has(dependency.getEntrypointChunk())) {
-						const err = new WebpackError(
-							`Entrypoints '${name}' and '${dep}' use 'dependOn' to depend on each other in a circular way.`
-						);
-						const entryChunk = entry.getEntrypointChunk();
-						err.chunk = entryChunk;
-						this.errors.push(err);
-						entry.setRuntimeChunk(entryChunk);
-						continue outer;
-					}
-					dependOnEntries.push(dependency);
-				}
-				for (const dependency of dependOnEntries) {
-					connectChunkGroupParentAndChild(dependency, entry);
-				}
-			} else if (runtime) {
-				const entry = this.entrypoints.get(name);
-				let chunk = this.namedChunks.get(runtime);
-				if (chunk) {
-					if (!runtimeChunks.has(chunk)) {
-						const err =
-							new WebpackError(`Entrypoint '${name}' has a 'runtime' option which points to another entrypoint named '${runtime}'.
-It's not valid to use other entrypoints as runtime chunk.
-Did you mean to use 'dependOn: ${JSON.stringify(
-								runtime
-							)}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
-Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
-						const entryChunk = entry.getEntrypointChunk();
-						err.chunk = entryChunk;
-						this.errors.push(err);
-						entry.setRuntimeChunk(entryChunk);
-						continue;
-					}
-				} else {
-					chunk = this.addChunk(runtime);
-					chunk.preventIntegration = true;
-					runtimeChunks.add(chunk);
-				}
-				entry.unshiftChunk(chunk);
-				chunk.addGroup(entry);
-				entry.setRuntimeChunk(chunk);
-			}
-		}
-		buildChunkGraph(this, chunkGraphInit);
-		this.hooks.afterChunks.call(this.chunks);
-		this.logger.timeEnd("create chunks");
 
-		this.logger.time("optimize");
-		this.hooks.optimize.call();
 
-		while (this.hooks.optimizeModules.call(this.modules)) {
-			/* empty */
-		}
-		this.hooks.afterOptimizeModules.call(this.modules);
+const ChunkGroup = __webpack_require__(15626);
 
-		while (this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups)) {
-			/* empty */
-		}
-		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("./Chunk")} Chunk */
 
-		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {
-			if (err) {
-				return finalCallback(
-					makeWebpackError(err, "Compilation.hooks.optimizeTree")
-				);
-			}
+/** @typedef {{ name?: string } & Omit<EntryDescription, "import">} EntryOptions */
 
-			this.hooks.afterOptimizeTree.call(this.chunks, this.modules);
-
-			this.hooks.optimizeChunkModules.callAsync(
-				this.chunks,
-				this.modules,
-				err => {
-					if (err) {
-						return finalCallback(
-							makeWebpackError(err, "Compilation.hooks.optimizeChunkModules")
-						);
-					}
+/**
+ * Entrypoint serves as an encapsulation primitive for chunks that are
+ * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
+ * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
+ * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
+ */
+class Entrypoint extends ChunkGroup {
+	/**
+	 * Creates an instance of Entrypoint.
+	 * @param {EntryOptions | string} entryOptions the options for the entrypoint (or name)
+	 * @param {boolean=} initial false, when the entrypoint is not initial loaded
+	 */
+	constructor(entryOptions, initial = true) {
+		if (typeof entryOptions === "string") {
+			entryOptions = { name: entryOptions };
+		}
+		super({
+			name: entryOptions.name
+		});
+		this.options = entryOptions;
+		/** @type {Chunk=} */
+		this._runtimeChunk = undefined;
+		/** @type {Chunk=} */
+		this._entrypointChunk = undefined;
+		/** @type {boolean} */
+		this._initial = initial;
+	}
 
-					this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);
+	/**
+	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
+	 */
+	isInitial() {
+		return this._initial;
+	}
 
-					const shouldRecord = this.hooks.shouldRecord.call() !== false;
+	/**
+	 * Sets the runtimeChunk for an entrypoint.
+	 * @param {Chunk} chunk the chunk being set as the runtime chunk.
+	 * @returns {void}
+	 */
+	setRuntimeChunk(chunk) {
+		this._runtimeChunk = chunk;
+	}
 
-					this.hooks.reviveModules.call(this.modules, this.records);
-					this.hooks.beforeModuleIds.call(this.modules);
-					this.hooks.moduleIds.call(this.modules);
-					this.hooks.optimizeModuleIds.call(this.modules);
-					this.hooks.afterOptimizeModuleIds.call(this.modules);
+	/**
+	 * Fetches the chunk reference containing the webpack bootstrap code
+	 * @returns {Chunk | null} returns the runtime chunk or null if there is none
+	 */
+	getRuntimeChunk() {
+		if (this._runtimeChunk) return this._runtimeChunk;
+		for (const parent of this.parentsIterable) {
+			if (parent instanceof Entrypoint) return parent.getRuntimeChunk();
+		}
+		return null;
+	}
 
-					this.hooks.reviveChunks.call(this.chunks, this.records);
-					this.hooks.beforeChunkIds.call(this.chunks);
-					this.hooks.chunkIds.call(this.chunks);
-					this.hooks.optimizeChunkIds.call(this.chunks);
-					this.hooks.afterOptimizeChunkIds.call(this.chunks);
+	/**
+	 * Sets the chunk with the entrypoint modules for an entrypoint.
+	 * @param {Chunk} chunk the chunk being set as the entrypoint chunk.
+	 * @returns {void}
+	 */
+	setEntrypointChunk(chunk) {
+		this._entrypointChunk = chunk;
+	}
 
-					this.assignRuntimeIds();
+	/**
+	 * Returns the chunk which contains the entrypoint modules
+	 * (or at least the execution of them)
+	 * @returns {Chunk} chunk
+	 */
+	getEntrypointChunk() {
+		return this._entrypointChunk;
+	}
 
-					this.logger.time("compute affected modules with chunk graph");
-					this._computeAffectedModulesWithChunkGraph();
-					this.logger.timeEnd("compute affected modules with chunk graph");
+	/**
+	 * @param {Chunk} oldChunk chunk to be replaced
+	 * @param {Chunk} newChunk New chunk that will be replaced with
+	 * @returns {boolean} returns true if the replacement was successful
+	 */
+	replaceChunk(oldChunk, newChunk) {
+		if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk;
+		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
+		return super.replaceChunk(oldChunk, newChunk);
+	}
+}
 
-					this.sortItemsWithChunkIds();
+module.exports = Entrypoint;
 
-					if (shouldRecord) {
-						this.hooks.recordModules.call(this.modules, this.records);
-						this.hooks.recordChunks.call(this.chunks, this.records);
-					}
 
-					this.hooks.optimizeCodeGeneration.call(this.modules);
-					this.logger.timeEnd("optimize");
+/***/ }),
 
-					this.logger.time("module hashing");
-					this.hooks.beforeModuleHash.call();
-					this.createModuleHashes();
-					this.hooks.afterModuleHash.call();
-					this.logger.timeEnd("module hashing");
+/***/ 22070:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					this.logger.time("code generation");
-					this.hooks.beforeCodeGeneration.call();
-					this.codeGeneration(err => {
-						if (err) {
-							return finalCallback(err);
-						}
-						this.hooks.afterCodeGeneration.call();
-						this.logger.timeEnd("code generation");
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Authors Simen Brekken @simenbrekken, Einar Löve @einarlove
+*/
 
-						this.logger.time("runtime requirements");
-						this.hooks.beforeRuntimeRequirements.call();
-						this.processRuntimeRequirements();
-						this.hooks.afterRuntimeRequirements.call();
-						this.logger.timeEnd("runtime requirements");
 
-						this.logger.time("hashing");
-						this.hooks.beforeHash.call();
-						const codeGenerationJobs = this.createHash();
-						this.hooks.afterHash.call();
-						this.logger.timeEnd("hashing");
 
-						this._runCodeGenerationJobs(codeGenerationJobs, err => {
-							if (err) {
-								return finalCallback(err);
-							}
+const DefinePlugin = __webpack_require__(79065);
+const WebpackError = __webpack_require__(53799);
 
-							if (shouldRecord) {
-								this.logger.time("record hash");
-								this.hooks.recordHash.call(this.records);
-								this.logger.timeEnd("record hash");
-							}
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./DefinePlugin").CodeValue} CodeValue */
 
-							this.logger.time("module assets");
-							this.clearAssets();
+class EnvironmentPlugin {
+	constructor(...keys) {
+		if (keys.length === 1 && Array.isArray(keys[0])) {
+			this.keys = keys[0];
+			this.defaultValues = {};
+		} else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
+			this.keys = Object.keys(keys[0]);
+			this.defaultValues = keys[0];
+		} else {
+			this.keys = keys;
+			this.defaultValues = {};
+		}
+	}
 
-							this.hooks.beforeModuleAssets.call();
-							this.createModuleAssets();
-							this.logger.timeEnd("module assets");
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Record<string, CodeValue>} */
+		const definitions = {};
+		for (const key of this.keys) {
+			const value =
+				process.env[key] !== undefined
+					? process.env[key]
+					: this.defaultValues[key];
 
-							const cont = () => {
-								this.logger.time("process assets");
-								this.hooks.processAssets.callAsync(this.assets, err => {
-									if (err) {
-										return finalCallback(
-											makeWebpackError(err, "Compilation.hooks.processAssets")
-										);
-									}
-									this.hooks.afterProcessAssets.call(this.assets);
-									this.logger.timeEnd("process assets");
-									this.assets = this._backCompat
-										? soonFrozenObjectDeprecation(
-												this.assets,
-												"Compilation.assets",
-												"DEP_WEBPACK_COMPILATION_ASSETS",
-												`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
-	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
-	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
-										  )
-										: Object.freeze(this.assets);
+			if (value === undefined) {
+				compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
+					const error = new WebpackError(
+						`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
+							"You can pass an object with default values to suppress this warning.\n" +
+							"See https://webpack.js.org/plugins/environment-plugin for example."
+					);
 
-									this.summarizeDependencies();
-									if (shouldRecord) {
-										this.hooks.record.call(this, this.records);
-									}
+					error.name = "EnvVariableNotDefinedError";
+					compilation.errors.push(error);
+				});
+			}
 
-									if (this.hooks.needAdditionalSeal.call()) {
-										this.unseal();
-										return this.seal(callback);
-									}
-									return this.hooks.afterSeal.callAsync(err => {
-										if (err) {
-											return finalCallback(
-												makeWebpackError(err, "Compilation.hooks.afterSeal")
-											);
-										}
-										this.fileSystemInfo.logStatistics();
-										finalCallback();
-									});
-								});
-							};
+			definitions[`process.env.${key}`] =
+				value === undefined ? "undefined" : JSON.stringify(value);
+		}
 
-							this.logger.time("create chunk assets");
-							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
-								this.hooks.beforeChunkAssets.call();
-								this.createChunkAssets(err => {
-									this.logger.timeEnd("create chunk assets");
-									if (err) {
-										return finalCallback(err);
-									}
-									cont();
-								});
-							} else {
-								this.logger.timeEnd("create chunk assets");
-								cont();
-							}
-						});
-					});
-				}
-			);
-		});
+		new DefinePlugin(definitions).apply(compiler);
 	}
+}
 
-	/**
-	 * @param {Module} module module to report from
-	 * @param {DependenciesBlock[]} blocks blocks to report from
-	 * @returns {boolean} true, when it has warnings or errors
-	 */
-	reportDependencyErrorsAndWarnings(module, blocks) {
-		let hasProblems = false;
-		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
-			const block = blocks[indexBlock];
-			const dependencies = block.dependencies;
+module.exports = EnvironmentPlugin;
 
-			for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {
-				const d = dependencies[indexDep];
 
-				const warnings = d.getWarnings(this.moduleGraph);
-				if (warnings) {
-					for (let indexWar = 0; indexWar < warnings.length; indexWar++) {
-						const w = warnings[indexWar];
+/***/ }),
 
-						const warning = new ModuleDependencyWarning(module, w, d.loc);
-						this.warnings.push(warning);
-						hasProblems = true;
-					}
-				}
-				const errors = d.getErrors(this.moduleGraph);
-				if (errors) {
-					for (let indexErr = 0; indexErr < errors.length; indexErr++) {
-						const e = errors[indexErr];
+/***/ 59985:
+/***/ (function(__unused_webpack_module, exports) {
 
-						const error = new ModuleDependencyError(module, e, d.loc);
-						this.errors.push(error);
-						hasProblems = true;
-					}
-				}
-			}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
-				hasProblems = true;
+
+
+const loaderFlag = "LOADER_EXECUTION";
+
+const webpackOptionsFlag = "WEBPACK_OPTIONS";
+
+exports.cutOffByFlag = (stack, flag) => {
+	stack = stack.split("\n");
+	for (let i = 0; i < stack.length; i++) {
+		if (stack[i].includes(flag)) {
+			stack.length = i;
 		}
-		return hasProblems;
 	}
+	return stack.join("\n");
+};
 
-	codeGeneration(callback) {
-		const { chunkGraph } = this;
-		this.codeGenerationResults = new CodeGenerationResults(
-			this.outputOptions.hashFunction
-		);
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
-		const jobs = [];
-		for (const module of this.modules) {
-			const runtimes = chunkGraph.getModuleRuntimes(module);
-			if (runtimes.size === 1) {
-				for (const runtime of runtimes) {
-					const hash = chunkGraph.getModuleHash(module, runtime);
-					jobs.push({ module, hash, runtime, runtimes: [runtime] });
-				}
-			} else if (runtimes.size > 1) {
-				/** @type {Map<string, { runtimes: RuntimeSpec[] }>} */
-				const map = new Map();
-				for (const runtime of runtimes) {
-					const hash = chunkGraph.getModuleHash(module, runtime);
-					const job = map.get(hash);
-					if (job === undefined) {
-						const newJob = { module, hash, runtime, runtimes: [runtime] };
-						jobs.push(newJob);
-						map.set(hash, newJob);
-					} else {
-						job.runtimes.push(runtime);
-					}
-				}
-			}
-		}
+exports.cutOffLoaderExecution = stack =>
+	exports.cutOffByFlag(stack, loaderFlag);
 
-		this._runCodeGenerationJobs(jobs, callback);
+exports.cutOffWebpackOptions = stack =>
+	exports.cutOffByFlag(stack, webpackOptionsFlag);
+
+exports.cutOffMultilineMessage = (stack, message) => {
+	stack = stack.split("\n");
+	message = message.split("\n");
+
+	const result = [];
+
+	stack.forEach((line, idx) => {
+		if (!line.includes(message[idx])) result.push(line);
+	});
+
+	return result.join("\n");
+};
+
+exports.cutOffMessage = (stack, message) => {
+	const nextLine = stack.indexOf("\n");
+	if (nextLine === -1) {
+		return stack === message ? "" : stack;
+	} else {
+		const firstLine = stack.substr(0, nextLine);
+		return firstLine === message ? stack.substr(nextLine + 1) : stack;
 	}
+};
 
-	_runCodeGenerationJobs(jobs, callback) {
-		let statModulesFromCache = 0;
-		let statModulesGenerated = 0;
-		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
-			this;
-		const results = this.codeGenerationResults;
-		const errors = [];
-		/** @type {Set<Module> | undefined} */
-		let notCodeGeneratedModules = undefined;
-		const runIteration = () => {
-			let delayedJobs = [];
-			let delayedModules = new Set();
-			asyncLib.eachLimit(
-				jobs,
-				this.options.parallelism,
-				(job, callback) => {
-					const { module } = job;
-					const { codeGenerationDependencies } = module;
-					if (codeGenerationDependencies !== undefined) {
-						if (
-							notCodeGeneratedModules === undefined ||
-							codeGenerationDependencies.some(dep => {
-								const referencedModule = moduleGraph.getModule(dep);
-								return notCodeGeneratedModules.has(referencedModule);
-							})
-						) {
-							delayedJobs.push(job);
-							delayedModules.add(module);
-							return callback();
-						}
+exports.cleanUp = (stack, message) => {
+	stack = exports.cutOffLoaderExecution(stack);
+	stack = exports.cutOffMessage(stack, message);
+	return stack;
+};
+
+exports.cleanUpWebpackOptions = (stack, message) => {
+	stack = exports.cutOffWebpackOptions(stack);
+	stack = exports.cutOffMultilineMessage(stack, message);
+	return stack;
+};
+
+
+/***/ }),
+
+/***/ 65218:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const ExternalModule = __webpack_require__(73071);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const RuntimeGlobals = __webpack_require__(16475);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Compiler")} Compiler */
+
+/** @type {WeakMap<Source, Source>} */
+const cache = new WeakMap();
+
+const devtoolWarning = new RawSource(`/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+`);
+
+class EvalDevToolModulePlugin {
+	constructor(options) {
+		this.namespace = options.namespace || "";
+		this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]";
+		this.moduleFilenameTemplate =
+			options.moduleFilenameTemplate ||
+			"webpack://[namespace]/[resourcePath]?[loaders]";
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("EvalDevToolModulePlugin", compilation => {
+			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+			hooks.renderModuleContent.tap(
+				"EvalDevToolModulePlugin",
+				(source, module, { runtimeTemplate, chunkGraph }) => {
+					const cacheEntry = cache.get(source);
+					if (cacheEntry !== undefined) return cacheEntry;
+					if (module instanceof ExternalModule) {
+						cache.set(source, source);
+						return source;
 					}
-					const { hash, runtime, runtimes } = job;
-					this._codeGenerationModule(
+					const content = source.source();
+					const str = ModuleFilenameHelpers.createFilename(
 						module,
-						runtime,
-						runtimes,
-						hash,
-						dependencyTemplates,
-						chunkGraph,
-						moduleGraph,
-						runtimeTemplate,
-						errors,
-						results,
-						(err, codeGenerated) => {
-							if (codeGenerated) statModulesGenerated++;
-							else statModulesFromCache++;
-							callback(err);
+						{
+							moduleFilenameTemplate: this.moduleFilenameTemplate,
+							namespace: this.namespace
+						},
+						{
+							requestShortener: runtimeTemplate.requestShortener,
+							chunkGraph,
+							hashFunction: compilation.outputOptions.hashFunction
 						}
 					);
-				},
-				err => {
-					if (err) return callback(err);
-					if (delayedJobs.length > 0) {
-						if (delayedJobs.length === jobs.length) {
-							return callback(
-								new Error(
-									`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
-										delayedModules,
-										m => m.identifier()
-									).join(", ")}`
-								)
-							);
-						}
-						jobs = delayedJobs;
-						delayedJobs = [];
-						notCodeGeneratedModules = delayedModules;
-						delayedModules = new Set();
-						return runIteration();
-					}
-					if (errors.length > 0) {
-						errors.sort(
-							compareSelect(err => err.module, compareModulesByIdentifier)
+					const footer =
+						"\n" +
+						this.sourceUrlComment.replace(
+							/\[url\]/g,
+							encodeURI(str)
+								.replace(/%2F/g, "/")
+								.replace(/%20/g, "_")
+								.replace(/%5E/g, "^")
+								.replace(/%5C/g, "\\")
+								.replace(/^\//, "")
 						);
-						for (const error of errors) {
-							this.errors.push(error);
-						}
-					}
-					this.logger.log(
-						`${Math.round(
-							(100 * statModulesGenerated) /
-								(statModulesGenerated + statModulesFromCache)
-						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
+					const result = new RawSource(
+						`eval(${
+							compilation.outputOptions.trustedTypes
+								? `${RuntimeGlobals.createScript}(${JSON.stringify(
+										content + footer
+								  )})`
+								: JSON.stringify(content + footer)
+						});`
 					);
-					callback();
+					cache.set(source, result);
+					return result;
 				}
 			);
-		};
-		runIteration();
-	}
-
-	/**
-	 * @param {Module} module module
-	 * @param {RuntimeSpec} runtime runtime
-	 * @param {RuntimeSpec[]} runtimes runtimes
-	 * @param {string} hash hash
-	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
-	 * @param {ChunkGraph} chunkGraph chunkGraph
-	 * @param {ModuleGraph} moduleGraph moduleGraph
-	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
-	 * @param {WebpackError[]} errors errors
-	 * @param {CodeGenerationResults} results results
-	 * @param {function(WebpackError=, boolean=): void} callback callback
-	 */
-	_codeGenerationModule(
-		module,
-		runtime,
-		runtimes,
-		hash,
-		dependencyTemplates,
-		chunkGraph,
-		moduleGraph,
-		runtimeTemplate,
-		errors,
-		results,
-		callback
-	) {
-		let codeGenerated = false;
-		const cache = new MultiItemCache(
-			runtimes.map(runtime =>
-				this._codeGenerationCache.getItemCache(
-					`${module.identifier()}|${getRuntimeKey(runtime)}`,
-					`${hash}|${dependencyTemplates.getHash()}`
-				)
-			)
-		);
-		cache.get((err, cachedResult) => {
-			if (err) return callback(err);
-			let result;
-			if (!cachedResult) {
-				try {
-					codeGenerated = true;
-					this.codeGeneratedModules.add(module);
-					result = module.codeGeneration({
-						chunkGraph,
-						moduleGraph,
-						dependencyTemplates,
-						runtimeTemplate,
-						runtime,
-						codeGenerationResults: results
-					});
-				} catch (err) {
-					errors.push(new CodeGenerationError(module, err));
-					result = cachedResult = {
-						sources: new Map(),
-						runtimeRequirements: null
-					};
-				}
-			} else {
-				result = cachedResult;
-			}
-			for (const runtime of runtimes) {
-				results.add(module, runtime, result);
-			}
-			if (!cachedResult) {
-				cache.store(result, err => callback(err, codeGenerated));
-			} else {
-				callback(null, codeGenerated);
+			hooks.inlineInRuntimeBailout.tap(
+				"EvalDevToolModulePlugin",
+				() => "the eval devtool is used."
+			);
+			hooks.render.tap(
+				"EvalDevToolModulePlugin",
+				source => new ConcatSource(devtoolWarning, source)
+			);
+			hooks.chunkHash.tap("EvalDevToolModulePlugin", (chunk, hash) => {
+				hash.update("EvalDevToolModulePlugin");
+				hash.update("2");
+			});
+			if (compilation.outputOptions.trustedTypes) {
+				compilation.hooks.additionalModuleRuntimeRequirements.tap(
+					"EvalDevToolModulePlugin",
+					(module, set, context) => {
+						set.add(RuntimeGlobals.createScript);
+					}
+				);
 			}
 		});
 	}
+}
 
-	_getChunkGraphEntries() {
-		/** @type {Set<Chunk>} */
-		const treeEntries = new Set();
-		for (const ep of this.entrypoints.values()) {
-			const chunk = ep.getRuntimeChunk();
-			if (chunk) treeEntries.add(chunk);
-		}
-		for (const ep of this.asyncEntrypoints) {
-			const chunk = ep.getRuntimeChunk();
-			if (chunk) treeEntries.add(chunk);
+module.exports = EvalDevToolModulePlugin;
+
+
+/***/ }),
+
+/***/ 14790:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const NormalModule = __webpack_require__(39);
+const RuntimeGlobals = __webpack_require__(16475);
+const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const ConcatenatedModule = __webpack_require__(97198);
+const { makePathsAbsolute } = __webpack_require__(82186);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").DevTool} DevToolOptions */
+/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
+
+/** @type {WeakMap<Source, Source>} */
+const cache = new WeakMap();
+
+const devtoolWarning = new RawSource(`/*
+ * ATTENTION: An "eval-source-map" devtool has been used.
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
+ */
+`);
+
+class EvalSourceMapDevToolPlugin {
+	/**
+	 * @param {SourceMapDevToolPluginOptions|string} inputOptions Options object
+	 */
+	constructor(inputOptions) {
+		/** @type {SourceMapDevToolPluginOptions} */
+		let options;
+		if (typeof inputOptions === "string") {
+			options = {
+				append: inputOptions
+			};
+		} else {
+			options = inputOptions;
 		}
-		return treeEntries;
+		this.sourceMapComment =
+			options.append || "//# sourceURL=[module]\n//# sourceMappingURL=[url]";
+		this.moduleFilenameTemplate =
+			options.moduleFilenameTemplate ||
+			"webpack://[namespace]/[resource-path]?[hash]";
+		this.namespace = options.namespace || "";
+		this.options = options;
 	}
 
 	/**
-	 * @param {Object} options options
-	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
-	 * @param {Iterable<Module>=} options.modules modules
-	 * @param {Iterable<Chunk>=} options.chunks chunks
-	 * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults
-	 * @param {Iterable<Chunk>=} options.chunkGraphEntries chunkGraphEntries
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	processRuntimeRequirements({
-		chunkGraph = this.chunkGraph,
-		modules = this.modules,
-		chunks = this.chunks,
-		codeGenerationResults = this.codeGenerationResults,
-		chunkGraphEntries = this._getChunkGraphEntries()
-	} = {}) {
-		const context = { chunkGraph, codeGenerationResults };
-		const { moduleMemCaches2 } = this;
-		this.logger.time("runtime requirements.modules");
-		const additionalModuleRuntimeRequirements =
-			this.hooks.additionalModuleRuntimeRequirements;
-		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
-		for (const module of modules) {
-			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
-				const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
-				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-					if (memCache) {
-						const cached = memCache.get(
-							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
-						);
-						if (cached !== undefined) {
-							if (cached !== null) {
-								chunkGraph.addModuleRuntimeRequirements(
-									module,
-									runtime,
-									cached,
-									false
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap(
+			"EvalSourceMapDevToolPlugin",
+			compilation => {
+				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+				new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
+				const matchModule = ModuleFilenameHelpers.matchObject.bind(
+					ModuleFilenameHelpers,
+					options
+				);
+				hooks.renderModuleContent.tap(
+					"EvalSourceMapDevToolPlugin",
+					(source, m, { runtimeTemplate, chunkGraph }) => {
+						const cachedSource = cache.get(source);
+						if (cachedSource !== undefined) {
+							return cachedSource;
+						}
+
+						const result = r => {
+							cache.set(source, r);
+							return r;
+						};
+
+						if (m instanceof NormalModule) {
+							const module = /** @type {NormalModule} */ (m);
+							if (!matchModule(module.resource)) {
+								return result(source);
+							}
+						} else if (m instanceof ConcatenatedModule) {
+							const concatModule = /** @type {ConcatenatedModule} */ (m);
+							if (concatModule.rootModule instanceof NormalModule) {
+								const module = /** @type {NormalModule} */ (
+									concatModule.rootModule
 								);
+								if (!matchModule(module.resource)) {
+									return result(source);
+								}
+							} else {
+								return result(source);
 							}
-							continue;
-						}
-					}
-					let set;
-					const runtimeRequirements =
-						codeGenerationResults.getRuntimeRequirements(module, runtime);
-					if (runtimeRequirements && runtimeRequirements.size > 0) {
-						set = new Set(runtimeRequirements);
-					} else if (additionalModuleRuntimeRequirements.isUsed()) {
-						set = new Set();
-					} else {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								null
-							);
+						} else {
+							return result(source);
 						}
-						continue;
-					}
-					additionalModuleRuntimeRequirements.call(module, set, context);
 
-					for (const r of set) {
-						const hook = runtimeRequirementInModule.get(r);
-						if (hook !== undefined) hook.call(module, set, context);
-					}
-					if (set.size === 0) {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								null
-							);
+						/** @type {{ [key: string]: TODO; }} */
+						let sourceMap;
+						let content;
+						if (source.sourceAndMap) {
+							const sourceAndMap = source.sourceAndMap(options);
+							sourceMap = sourceAndMap.map;
+							content = sourceAndMap.source;
+						} else {
+							sourceMap = source.map(options);
+							content = source.source();
 						}
-					} else {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								set
-							);
-							chunkGraph.addModuleRuntimeRequirements(
+						if (!sourceMap) {
+							return result(source);
+						}
+
+						// Clone (flat) the sourcemap to ensure that the mutations below do not persist.
+						sourceMap = { ...sourceMap };
+						const context = compiler.options.context;
+						const root = compiler.root;
+						const modules = sourceMap.sources.map(source => {
+							if (!source.startsWith("webpack://")) return source;
+							source = makePathsAbsolute(context, source.slice(10), root);
+							const module = compilation.findModule(source);
+							return module || source;
+						});
+						let moduleFilenames = modules.map(module => {
+							return ModuleFilenameHelpers.createFilename(
 								module,
-								runtime,
-								set,
-								false
+								{
+									moduleFilenameTemplate: this.moduleFilenameTemplate,
+									namespace: this.namespace
+								},
+								{
+									requestShortener: runtimeTemplate.requestShortener,
+									chunkGraph,
+									hashFunction: compilation.outputOptions.hashFunction
+								}
 							);
-						} else {
-							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
-						}
+						});
+						moduleFilenames = ModuleFilenameHelpers.replaceDuplicates(
+							moduleFilenames,
+							(filename, i, n) => {
+								for (let j = 0; j < n; j++) filename += "*";
+								return filename;
+							}
+						);
+						sourceMap.sources = moduleFilenames;
+						sourceMap.sourceRoot = options.sourceRoot || "";
+						const moduleId = chunkGraph.getModuleId(m);
+						sourceMap.file = `${moduleId}.js`;
+
+						const footer =
+							this.sourceMapComment.replace(
+								/\[url\]/g,
+								`data:application/json;charset=utf-8;base64,${Buffer.from(
+									JSON.stringify(sourceMap),
+									"utf8"
+								).toString("base64")}`
+							) + `\n//# sourceURL=webpack-internal:///${moduleId}\n`; // workaround for chrome bug
+
+						return result(
+							new RawSource(
+								`eval(${
+									compilation.outputOptions.trustedTypes
+										? `${RuntimeGlobals.createScript}(${JSON.stringify(
+												content + footer
+										  )})`
+										: JSON.stringify(content + footer)
+								});`
+							)
+						);
 					}
+				);
+				hooks.inlineInRuntimeBailout.tap(
+					"EvalDevToolModulePlugin",
+					() => "the eval-source-map devtool is used."
+				);
+				hooks.render.tap(
+					"EvalSourceMapDevToolPlugin",
+					source => new ConcatSource(devtoolWarning, source)
+				);
+				hooks.chunkHash.tap("EvalSourceMapDevToolPlugin", (chunk, hash) => {
+					hash.update("EvalSourceMapDevToolPlugin");
+					hash.update("2");
+				});
+				if (compilation.outputOptions.trustedTypes) {
+					compilation.hooks.additionalModuleRuntimeRequirements.tap(
+						"EvalSourceMapDevToolPlugin",
+						(module, set, context) => {
+							set.add(RuntimeGlobals.createScript);
+						}
+					);
 				}
 			}
-		}
-		this.logger.timeEnd("runtime requirements.modules");
+		);
+	}
+}
 
-		this.logger.time("runtime requirements.chunks");
-		for (const chunk of chunks) {
-			const set = new Set();
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-					module,
-					chunk.runtime
-				);
-				for (const r of runtimeRequirements) set.add(r);
-			}
-			this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context);
+module.exports = EvalSourceMapDevToolPlugin;
 
-			for (const r of set) {
-				this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context);
-			}
 
-			chunkGraph.addChunkRuntimeRequirements(chunk, set);
-		}
-		this.logger.timeEnd("runtime requirements.chunks");
+/***/ }),
 
-		this.logger.time("runtime requirements.entries");
-		for (const treeEntry of chunkGraphEntries) {
-			const set = new Set();
-			for (const chunk of treeEntry.getAllReferencedChunks()) {
-				const runtimeRequirements =
-					chunkGraph.getChunkRuntimeRequirements(chunk);
-				for (const r of runtimeRequirements) set.add(r);
-			}
+/***/ 63686:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			this.hooks.additionalTreeRuntimeRequirements.call(
-				treeEntry,
-				set,
-				context
-			);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			for (const r of set) {
-				this.hooks.runtimeRequirementInTree
-					.for(r)
-					.call(treeEntry, set, context);
-			}
 
-			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
-		}
-		this.logger.timeEnd("runtime requirements.entries");
-	}
 
-	// TODO webpack 6 make chunkGraph argument non-optional
-	/**
-	 * @param {Chunk} chunk target chunk
-	 * @param {RuntimeModule} module runtime module
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {void}
-	 */
-	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
-		// Deprecated ModuleGraph association
-		if (this._backCompat)
-			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+const { equals } = __webpack_require__(84953);
+const SortableSet = __webpack_require__(13098);
+const makeSerializable = __webpack_require__(33032);
+const { forEachRuntime } = __webpack_require__(17156);
 
-		// add it to the list
-		this.modules.add(module);
-		this._modules.set(module.identifier(), module);
+/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("./util/Hash")} Hash */
 
-		// connect to the chunk graph
-		chunkGraph.connectChunkAndModule(chunk, module);
-		chunkGraph.connectChunkAndRuntimeModule(chunk, module);
-		if (module.fullHash) {
-			chunkGraph.addFullHashModuleToChunk(chunk, module);
-		} else if (module.dependentHash) {
-			chunkGraph.addDependentHashModuleToChunk(chunk, module);
-		}
+/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
+/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
 
-		// attach runtime module
-		module.attach(this, chunk, chunkGraph);
+const UsageState = Object.freeze({
+	Unused: /** @type {0} */ (0),
+	OnlyPropertiesUsed: /** @type {1} */ (1),
+	NoInfo: /** @type {2} */ (2),
+	Unknown: /** @type {3} */ (3),
+	Used: /** @type {4} */ (4)
+});
 
-		// Setup internals
-		const exportsInfo = this.moduleGraph.getExportsInfo(module);
-		exportsInfo.setHasProvideInfo();
-		if (typeof chunk.runtime === "string") {
-			exportsInfo.setUsedForSideEffectsOnly(chunk.runtime);
-		} else if (chunk.runtime === undefined) {
-			exportsInfo.setUsedForSideEffectsOnly(undefined);
-		} else {
-			for (const runtime of chunk.runtime) {
-				exportsInfo.setUsedForSideEffectsOnly(runtime);
-			}
-		}
-		chunkGraph.addModuleRuntimeRequirements(
-			module,
-			chunk.runtime,
-			new Set([RuntimeGlobals.requireScope])
-		);
+const RETURNS_TRUE = () => true;
 
-		// runtime modules don't need ids
-		chunkGraph.setModuleId(module, "");
+const CIRCULAR = Symbol("circular target");
 
-		// Call hook
-		this.hooks.runtimeModule.call(module, chunk);
+class RestoreProvidedData {
+	constructor(
+		exports,
+		otherProvided,
+		otherCanMangleProvide,
+		otherTerminalBinding
+	) {
+		this.exports = exports;
+		this.otherProvided = otherProvided;
+		this.otherCanMangleProvide = otherCanMangleProvide;
+		this.otherTerminalBinding = otherTerminalBinding;
 	}
 
-	/**
-	 * If `module` is passed, `loc` and `request` must also be passed.
-	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
-	 * @param {Module=} module the module the references the chunk group
-	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string=} request the request from which the the chunk group is referenced
-	 * @returns {ChunkGroup} the new or existing chunk group
-	 */
-	addChunkInGroup(groupOptions, module, loc, request) {
-		if (typeof groupOptions === "string") {
-			groupOptions = { name: groupOptions };
-		}
-		const name = groupOptions.name;
+	serialize({ write }) {
+		write(this.exports);
+		write(this.otherProvided);
+		write(this.otherCanMangleProvide);
+		write(this.otherTerminalBinding);
+	}
 
-		if (name) {
-			const chunkGroup = this.namedChunkGroups.get(name);
-			if (chunkGroup !== undefined) {
-				chunkGroup.addOptions(groupOptions);
-				if (module) {
-					chunkGroup.addOrigin(module, loc, request);
-				}
-				return chunkGroup;
-			}
-		}
-		const chunkGroup = new ChunkGroup(groupOptions);
-		if (module) chunkGroup.addOrigin(module, loc, request);
-		const chunk = this.addChunk(name);
+	static deserialize({ read }) {
+		return new RestoreProvidedData(read(), read(), read(), read());
+	}
+}
 
-		connectChunkGroupAndChunk(chunkGroup, chunk);
+makeSerializable(
+	RestoreProvidedData,
+	"webpack/lib/ModuleGraph",
+	"RestoreProvidedData"
+);
 
-		this.chunkGroups.push(chunkGroup);
-		if (name) {
-			this.namedChunkGroups.set(name, chunkGroup);
+class ExportsInfo {
+	constructor() {
+		/** @type {Map<string, ExportInfo>} */
+		this._exports = new Map();
+		this._otherExportsInfo = new ExportInfo(null);
+		this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
+		this._exportsAreOrdered = false;
+		/** @type {ExportsInfo=} */
+		this._redirectTo = undefined;
+	}
+
+	/**
+	 * @returns {Iterable<ExportInfo>} all owned exports in any order
+	 */
+	get ownedExports() {
+		return this._exports.values();
+	}
+
+	/**
+	 * @returns {Iterable<ExportInfo>} all owned exports in order
+	 */
+	get orderedOwnedExports() {
+		if (!this._exportsAreOrdered) {
+			this._sortExports();
 		}
-		return chunkGroup;
+		return this._exports.values();
 	}
 
 	/**
-	 * @param {EntryOptions} options options for the entrypoint
-	 * @param {Module} module the module the references the chunk group
-	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string} request the request from which the the chunk group is referenced
-	 * @returns {Entrypoint} the new or existing entrypoint
+	 * @returns {Iterable<ExportInfo>} all exports in any order
 	 */
-	addAsyncEntrypoint(options, module, loc, request) {
-		const name = options.name;
-		if (name) {
-			const entrypoint = this.namedChunkGroups.get(name);
-			if (entrypoint instanceof Entrypoint) {
-				if (entrypoint !== undefined) {
-					if (module) {
-						entrypoint.addOrigin(module, loc, request);
-					}
-					return entrypoint;
-				}
-			} else if (entrypoint) {
-				throw new Error(
-					`Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name`
-				);
+	get exports() {
+		if (this._redirectTo !== undefined) {
+			const map = new Map(this._redirectTo._exports);
+			for (const [key, value] of this._exports) {
+				map.set(key, value);
 			}
+			return map.values();
 		}
-		const chunk = this.addChunk(name);
-		if (options.filename) {
-			chunk.filenameTemplate = options.filename;
-		}
-		const entrypoint = new Entrypoint(options, false);
-		entrypoint.setRuntimeChunk(chunk);
-		entrypoint.setEntrypointChunk(chunk);
-		if (name) {
-			this.namedChunkGroups.set(name, entrypoint);
-		}
-		this.chunkGroups.push(entrypoint);
-		this.asyncEntrypoints.push(entrypoint);
-		connectChunkGroupAndChunk(entrypoint, chunk);
-		if (module) {
-			entrypoint.addOrigin(module, loc, request);
-		}
-		return entrypoint;
+		return this._exports.values();
 	}
 
 	/**
-	 * This method first looks to see if a name is provided for a new chunk,
-	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
-	 *
-	 * @param {string=} name optional chunk name to be provided
-	 * @returns {Chunk} create a chunk (invoked during seal event)
+	 * @returns {Iterable<ExportInfo>} all exports in order
 	 */
-	addChunk(name) {
-		if (name) {
-			const chunk = this.namedChunks.get(name);
-			if (chunk !== undefined) {
-				return chunk;
-			}
+	get orderedExports() {
+		if (!this._exportsAreOrdered) {
+			this._sortExports();
 		}
-		const chunk = new Chunk(name, this._backCompat);
-		this.chunks.add(chunk);
-		if (this._backCompat)
-			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
-		if (name) {
-			this.namedChunks.set(name, chunk);
+		if (this._redirectTo !== undefined) {
+			const map = new Map(
+				Array.from(this._redirectTo.orderedExports, item => [item.name, item])
+			);
+			for (const [key, value] of this._exports) {
+				map.set(key, value);
+			}
+			// sorting should be pretty fast as map contains
+			// a lot of presorted items
+			this._sortExportsMap(map);
+			return map.values();
 		}
-		return chunk;
+		return this._exports.values();
 	}
 
 	/**
-	 * @deprecated
-	 * @param {Module} module module to assign depth
-	 * @returns {void}
+	 * @returns {ExportInfo} the export info of unlisted exports
 	 */
-	assignDepth(module) {
-		const moduleGraph = this.moduleGraph;
+	get otherExportsInfo() {
+		if (this._redirectTo !== undefined)
+			return this._redirectTo.otherExportsInfo;
+		return this._otherExportsInfo;
+	}
 
-		const queue = new Set([module]);
-		let depth;
+	_sortExportsMap(exports) {
+		if (exports.size > 1) {
+			const namesInOrder = [];
+			for (const entry of exports.values()) {
+				namesInOrder.push(entry.name);
+			}
+			namesInOrder.sort();
+			let i = 0;
+			for (const entry of exports.values()) {
+				const name = namesInOrder[i];
+				if (entry.name !== name) break;
+				i++;
+			}
+			for (; i < namesInOrder.length; i++) {
+				const name = namesInOrder[i];
+				const correctEntry = exports.get(name);
+				exports.delete(name);
+				exports.set(name, correctEntry);
+			}
+		}
+	}
 
-		moduleGraph.setDepth(module, 0);
+	_sortExports() {
+		this._sortExportsMap(this._exports);
+		this._exportsAreOrdered = true;
+	}
 
-		/**
-		 * @param {Module} module module for processing
-		 * @returns {void}
-		 */
-		const processModule = module => {
-			if (!moduleGraph.setDepthIfLower(module, depth)) return;
-			queue.add(module);
-		};
+	setRedirectNamedTo(exportsInfo) {
+		if (this._redirectTo === exportsInfo) return false;
+		this._redirectTo = exportsInfo;
+		return true;
+	}
 
-		for (module of queue) {
-			queue.delete(module);
-			depth = moduleGraph.getDepth(module) + 1;
+	setHasProvideInfo() {
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.provided === undefined) {
+				exportInfo.provided = false;
+			}
+			if (exportInfo.canMangleProvide === undefined) {
+				exportInfo.canMangleProvide = true;
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			this._redirectTo.setHasProvideInfo();
+		} else {
+			if (this._otherExportsInfo.provided === undefined) {
+				this._otherExportsInfo.provided = false;
+			}
+			if (this._otherExportsInfo.canMangleProvide === undefined) {
+				this._otherExportsInfo.canMangleProvide = true;
+			}
+		}
+	}
 
-			for (const connection of moduleGraph.getOutgoingConnections(module)) {
-				const refModule = connection.module;
-				if (refModule) {
-					processModule(refModule);
-				}
+	setHasUseInfo() {
+		for (const exportInfo of this._exports.values()) {
+			exportInfo.setHasUseInfo();
+		}
+		this._sideEffectsOnlyInfo.setHasUseInfo();
+		if (this._redirectTo !== undefined) {
+			this._redirectTo.setHasUseInfo();
+		} else {
+			this._otherExportsInfo.setHasUseInfo();
+			if (this._otherExportsInfo.canMangleUse === undefined) {
+				this._otherExportsInfo.canMangleUse = true;
 			}
 		}
 	}
 
 	/**
-	 * @param {Set<Module>} modules module to assign depth
-	 * @returns {void}
+	 * @param {string} name export name
+	 * @returns {ExportInfo} export info for this name
 	 */
-	assignDepths(modules) {
-		const moduleGraph = this.moduleGraph;
+	getOwnExportInfo(name) {
+		const info = this._exports.get(name);
+		if (info !== undefined) return info;
+		const newInfo = new ExportInfo(name, this._otherExportsInfo);
+		this._exports.set(name, newInfo);
+		this._exportsAreOrdered = false;
+		return newInfo;
+	}
 
-		/** @type {Set<Module | number>} */
-		const queue = new Set(modules);
-		queue.add(1);
-		let depth = 0;
+	/**
+	 * @param {string} name export name
+	 * @returns {ExportInfo} export info for this name
+	 */
+	getExportInfo(name) {
+		const info = this._exports.get(name);
+		if (info !== undefined) return info;
+		if (this._redirectTo !== undefined)
+			return this._redirectTo.getExportInfo(name);
+		const newInfo = new ExportInfo(name, this._otherExportsInfo);
+		this._exports.set(name, newInfo);
+		this._exportsAreOrdered = false;
+		return newInfo;
+	}
 
-		let i = 0;
-		for (const module of queue) {
-			i++;
-			if (typeof module === "number") {
-				depth = module;
-				if (queue.size === i) return;
-				queue.add(depth + 1);
-			} else {
-				moduleGraph.setDepth(module, depth);
-				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
-					module
-				)) {
-					if (refModule) {
-						queue.add(refModule);
-					}
-				}
-			}
-		}
+	/**
+	 * @param {string} name export name
+	 * @returns {ExportInfo} export info for this name
+	 */
+	getReadOnlyExportInfo(name) {
+		const info = this._exports.get(name);
+		if (info !== undefined) return info;
+		if (this._redirectTo !== undefined)
+			return this._redirectTo.getReadOnlyExportInfo(name);
+		return this._otherExportsInfo;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @param {string[]} name export name
+	 * @returns {ExportInfo | undefined} export info for this name
 	 */
-	getDependencyReferencedExports(dependency, runtime) {
-		const referencedExports = dependency.getReferencedExports(
-			this.moduleGraph,
-			runtime
-		);
-		return this.hooks.dependencyReferencedExports.call(
-			referencedExports,
-			dependency,
-			runtime
-		);
+	getReadOnlyExportInfoRecursive(name) {
+		const exportInfo = this.getReadOnlyExportInfo(name[0]);
+		if (name.length === 1) return exportInfo;
+		if (!exportInfo.exportsInfo) return undefined;
+		return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
 	}
 
 	/**
-	 *
-	 * @param {Module} module module relationship for removal
-	 * @param {DependenciesBlockLike} block //TODO: good description
-	 * @returns {void}
+	 * @param {string[]=} name the export name
+	 * @returns {ExportsInfo | undefined} the nested exports info
 	 */
-	removeReasonsOfDependencyBlock(module, block) {
-		if (block.blocks) {
-			for (const b of block.blocks) {
-				this.removeReasonsOfDependencyBlock(module, b);
-			}
+	getNestedExportsInfo(name) {
+		if (Array.isArray(name) && name.length > 0) {
+			const info = this.getReadOnlyExportInfo(name[0]);
+			if (!info.exportsInfo) return undefined;
+			return info.exportsInfo.getNestedExportsInfo(name.slice(1));
 		}
+		return this;
+	}
 
-		if (block.dependencies) {
-			for (const dep of block.dependencies) {
-				const originalModule = this.moduleGraph.getModule(dep);
-				if (originalModule) {
-					this.moduleGraph.removeConnection(dep);
-
-					if (this.chunkGraph) {
-						for (const chunk of this.chunkGraph.getModuleChunks(
-							originalModule
-						)) {
-							this.patchChunksAfterReasonRemoval(originalModule, chunk);
-						}
-					}
-				}
+	/**
+	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
+	 * @param {Set<string>=} excludeExports list of unaffected exports
+	 * @param {any=} targetKey use this as key for the target
+	 * @param {ModuleGraphConnection=} targetModule set this module as target
+	 * @param {number=} priority priority
+	 * @returns {boolean} true, if this call changed something
+	 */
+	setUnknownExportsProvided(
+		canMangle,
+		excludeExports,
+		targetKey,
+		targetModule,
+		priority
+	) {
+		let changed = false;
+		if (excludeExports) {
+			for (const name of excludeExports) {
+				// Make sure these entries exist, so they can get different info
+				this.getExportInfo(name);
+			}
+		}
+		for (const exportInfo of this._exports.values()) {
+			if (excludeExports && excludeExports.has(exportInfo.name)) continue;
+			if (exportInfo.provided !== true && exportInfo.provided !== null) {
+				exportInfo.provided = null;
+				changed = true;
+			}
+			if (!canMangle && exportInfo.canMangleProvide !== false) {
+				exportInfo.canMangleProvide = false;
+				changed = true;
+			}
+			if (targetKey) {
+				exportInfo.setTarget(targetKey, targetModule, [exportInfo.name], -1);
+			}
+		}
+		if (this._redirectTo !== undefined) {
+			if (
+				this._redirectTo.setUnknownExportsProvided(
+					canMangle,
+					excludeExports,
+					targetKey,
+					targetModule,
+					priority
+				)
+			) {
+				changed = true;
+			}
+		} else {
+			if (
+				this._otherExportsInfo.provided !== true &&
+				this._otherExportsInfo.provided !== null
+			) {
+				this._otherExportsInfo.provided = null;
+				changed = true;
+			}
+			if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) {
+				this._otherExportsInfo.canMangleProvide = false;
+				changed = true;
+			}
+			if (targetKey) {
+				this._otherExportsInfo.setTarget(
+					targetKey,
+					targetModule,
+					undefined,
+					priority
+				);
 			}
 		}
+		return changed;
 	}
 
 	/**
-	 * @param {Module} module module to patch tie
-	 * @param {Chunk} chunk chunk to patch tie
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	patchChunksAfterReasonRemoval(module, chunk) {
-		if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
-			this.removeReasonsOfDependencyBlock(module, module);
+	setUsedInUnknownWay(runtime) {
+		let changed = false;
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.setUsedInUnknownWay(runtime)) {
+				changed = true;
+			}
 		}
-		if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
-			if (this.chunkGraph.isModuleInChunk(module, chunk)) {
-				this.chunkGraph.disconnectChunkAndModule(chunk, module);
-				this.removeChunkFromDependencies(module, chunk);
+		if (this._redirectTo !== undefined) {
+			if (this._redirectTo.setUsedInUnknownWay(runtime)) {
+				changed = true;
+			}
+		} else {
+			if (
+				this._otherExportsInfo.setUsedConditionally(
+					used => used < UsageState.Unknown,
+					UsageState.Unknown,
+					runtime
+				)
+			) {
+				changed = true;
+			}
+			if (this._otherExportsInfo.canMangleUse !== false) {
+				this._otherExportsInfo.canMangleUse = false;
+				changed = true;
 			}
 		}
+		return changed;
 	}
 
 	/**
-	 *
-	 * @param {DependenciesBlock} block block tie for Chunk
-	 * @param {Chunk} chunk chunk to remove from dep
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	removeChunkFromDependencies(block, chunk) {
-		/**
-		 * @param {Dependency} d dependency to (maybe) patch up
-		 */
-		const iteratorDependency = d => {
-			const depModule = this.moduleGraph.getModule(d);
-			if (!depModule) {
-				return;
+	setUsedWithoutInfo(runtime) {
+		let changed = false;
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.setUsedWithoutInfo(runtime)) {
+				changed = true;
 			}
-			this.patchChunksAfterReasonRemoval(depModule, chunk);
-		};
-
-		const blocks = block.blocks;
-		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
-			const asyncBlock = blocks[indexBlock];
-			const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
-			// Grab all chunks from the first Block's AsyncDepBlock
-			const chunks = chunkGroup.chunks;
-			// For each chunk in chunkGroup
-			for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
-				const iteratedChunk = chunks[indexChunk];
-				chunkGroup.removeChunk(iteratedChunk);
-				// Recurse
-				this.removeChunkFromDependencies(block, iteratedChunk);
+		}
+		if (this._redirectTo !== undefined) {
+			if (this._redirectTo.setUsedWithoutInfo(runtime)) {
+				changed = true;
+			}
+		} else {
+			if (this._otherExportsInfo.setUsed(UsageState.NoInfo, runtime)) {
+				changed = true;
+			}
+			if (this._otherExportsInfo.canMangleUse !== false) {
+				this._otherExportsInfo.canMangleUse = false;
+				changed = true;
 			}
 		}
+		return changed;
+	}
 
-		if (block.dependencies) {
-			for (const dep of block.dependencies) iteratorDependency(dep);
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
+	 */
+	setAllKnownExportsUsed(runtime) {
+		let changed = false;
+		for (const exportInfo of this._exports.values()) {
+			if (!exportInfo.provided) continue;
+			if (exportInfo.setUsed(UsageState.Used, runtime)) {
+				changed = true;
+			}
 		}
+		return changed;
 	}
 
-	assignRuntimeIds() {
-		const { chunkGraph } = this;
-		const processEntrypoint = ep => {
-			const runtime = ep.options.runtime || ep.name;
-			const chunk = ep.getRuntimeChunk();
-			chunkGraph.setRuntimeId(runtime, chunk.id);
-		};
-		for (const ep of this.entrypoints.values()) {
-			processEntrypoint(ep);
-		}
-		for (const ep of this.asyncEntrypoints) {
-			processEntrypoint(ep);
-		}
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when something changed
+	 */
+	setUsedForSideEffectsOnly(runtime) {
+		return this._sideEffectsOnlyInfo.setUsedConditionally(
+			used => used === UsageState.Unused,
+			UsageState.Used,
+			runtime
+		);
 	}
 
-	sortItemsWithChunkIds() {
-		for (const chunkGroup of this.chunkGroups) {
-			chunkGroup.sortItems();
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when the module exports are used in any way
+	 */
+	isUsed(runtime) {
+		if (this._redirectTo !== undefined) {
+			if (this._redirectTo.isUsed(runtime)) {
+				return true;
+			}
+		} else {
+			if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+				return true;
+			}
 		}
-
-		this.errors.sort(compareErrors);
-		this.warnings.sort(compareErrors);
-		this.children.sort(byNameOrHash);
+		for (const exportInfo of this._exports.values()) {
+			if (exportInfo.getUsed(runtime) !== UsageState.Unused) {
+				return true;
+			}
+		}
+		return false;
 	}
 
-	summarizeDependencies() {
-		for (
-			let indexChildren = 0;
-			indexChildren < this.children.length;
-			indexChildren++
-		) {
-			const child = this.children[indexChildren];
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, when the module is used in any way
+	 */
+	isModuleUsed(runtime) {
+		if (this.isUsed(runtime)) return true;
+		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
+			return true;
+		return false;
+	}
 
-			this.fileDependencies.addAll(child.fileDependencies);
-			this.contextDependencies.addAll(child.contextDependencies);
-			this.missingDependencies.addAll(child.missingDependencies);
-			this.buildDependencies.addAll(child.buildDependencies);
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
+	 */
+	getUsedExports(runtime) {
+		if (!this._redirectTo !== undefined) {
+			switch (this._otherExportsInfo.getUsed(runtime)) {
+				case UsageState.NoInfo:
+					return null;
+				case UsageState.Unknown:
+				case UsageState.OnlyPropertiesUsed:
+				case UsageState.Used:
+					return true;
+			}
 		}
-
-		for (const module of this.modules) {
-			module.addCacheDependencies(
-				this.fileDependencies,
-				this.contextDependencies,
-				this.missingDependencies,
-				this.buildDependencies
-			);
+		const array = [];
+		if (!this._exportsAreOrdered) this._sortExports();
+		for (const exportInfo of this._exports.values()) {
+			switch (exportInfo.getUsed(runtime)) {
+				case UsageState.NoInfo:
+					return null;
+				case UsageState.Unknown:
+					return true;
+				case UsageState.OnlyPropertiesUsed:
+				case UsageState.Used:
+					array.push(exportInfo.name);
+			}
 		}
-	}
-
-	createModuleHashes() {
-		let statModulesHashed = 0;
-		let statModulesFromCache = 0;
-		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
-		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
-		for (const module of this.modules) {
-			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
-			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-				if (memCache) {
-					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
-					if (digest !== undefined) {
-						chunkGraph.setModuleHashes(
-							module,
-							runtime,
-							digest,
-							digest.substr(0, hashDigestLength)
-						);
-						statModulesFromCache++;
-						continue;
-					}
-				}
-				statModulesHashed++;
-				const digest = this._createModuleHash(
-					module,
-					chunkGraph,
-					runtime,
-					hashFunction,
-					runtimeTemplate,
-					hashDigest,
-					hashDigestLength
-				);
-				if (memCache) {
-					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+		if (this._redirectTo !== undefined) {
+			const inner = this._redirectTo.getUsedExports(runtime);
+			if (inner === null) return null;
+			if (inner === true) return true;
+			if (inner !== false) {
+				for (const item of inner) {
+					array.push(item);
 				}
 			}
 		}
-		this.logger.log(
-			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
-				Math.round(
-					(100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
-				) / 100
-			} variants per module in average)`
-		);
-	}
-
-	_createModuleHash(
-		module,
-		chunkGraph,
-		runtime,
-		hashFunction,
-		runtimeTemplate,
-		hashDigest,
-		hashDigestLength
-	) {
-		const moduleHash = createHash(hashFunction);
-		module.updateHash(moduleHash, {
-			chunkGraph,
-			runtime,
-			runtimeTemplate
-		});
-		const moduleHashDigest = /** @type {string} */ (
-			moduleHash.digest(hashDigest)
-		);
-		chunkGraph.setModuleHashes(
-			module,
-			runtime,
-			moduleHashDigest,
-			moduleHashDigest.substr(0, hashDigestLength)
-		);
-		return moduleHashDigest;
+		if (array.length === 0) {
+			switch (this._sideEffectsOnlyInfo.getUsed(runtime)) {
+				case UsageState.NoInfo:
+					return null;
+				case UsageState.Unused:
+					return false;
+			}
+		}
+		return new SortableSet(array);
 	}
 
-	createHash() {
-		this.logger.time("hashing: initialize hash");
-		const chunkGraph = this.chunkGraph;
-		const runtimeTemplate = this.runtimeTemplate;
-		const outputOptions = this.outputOptions;
-		const hashFunction = outputOptions.hashFunction;
-		const hashDigest = outputOptions.hashDigest;
-		const hashDigestLength = outputOptions.hashDigestLength;
-		const hash = createHash(hashFunction);
-		if (outputOptions.hashSalt) {
-			hash.update(outputOptions.hashSalt);
+	/**
+	 * @returns {null | true | string[]} list of exports when known
+	 */
+	getProvidedExports() {
+		if (!this._redirectTo !== undefined) {
+			switch (this._otherExportsInfo.provided) {
+				case undefined:
+					return null;
+				case null:
+					return true;
+				case true:
+					return true;
+			}
 		}
-		this.logger.timeEnd("hashing: initialize hash");
-		if (this.children.length > 0) {
-			this.logger.time("hashing: hash child compilations");
-			for (const child of this.children) {
-				hash.update(child.hash);
+		const array = [];
+		if (!this._exportsAreOrdered) this._sortExports();
+		for (const exportInfo of this._exports.values()) {
+			switch (exportInfo.provided) {
+				case undefined:
+					return null;
+				case null:
+					return true;
+				case true:
+					array.push(exportInfo.name);
 			}
-			this.logger.timeEnd("hashing: hash child compilations");
 		}
-		if (this.warnings.length > 0) {
-			this.logger.time("hashing: hash warnings");
-			for (const warning of this.warnings) {
-				hash.update(`${warning.message}`);
+		if (this._redirectTo !== undefined) {
+			const inner = this._redirectTo.getProvidedExports();
+			if (inner === null) return null;
+			if (inner === true) return true;
+			for (const item of inner) {
+				if (!array.includes(item)) {
+					array.push(item);
+				}
 			}
-			this.logger.timeEnd("hashing: hash warnings");
 		}
-		if (this.errors.length > 0) {
-			this.logger.time("hashing: hash errors");
-			for (const error of this.errors) {
-				hash.update(`${error.message}`);
+		return array;
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ExportInfo[]} exports that are relevant (not unused and potential provided)
+	 */
+	getRelevantExports(runtime) {
+		const list = [];
+		for (const exportInfo of this._exports.values()) {
+			const used = exportInfo.getUsed(runtime);
+			if (used === UsageState.Unused) continue;
+			if (exportInfo.provided === false) continue;
+			list.push(exportInfo);
+		}
+		if (this._redirectTo !== undefined) {
+			for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) {
+				if (!this._exports.has(exportInfo.name)) list.push(exportInfo);
 			}
-			this.logger.timeEnd("hashing: hash errors");
 		}
+		if (
+			this._otherExportsInfo.provided !== false &&
+			this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused
+		) {
+			list.push(this._otherExportsInfo);
+		}
+		return list;
+	}
 
-		this.logger.time("hashing: sort chunks");
-		/*
-		 * all non-runtime chunks need to be hashes first,
-		 * since runtime chunk might use their hashes.
-		 * runtime chunks need to be hashed in the correct order
-		 * since they may depend on each other (for async entrypoints).
-		 * So we put all non-runtime chunks first and hash them in any order.
-		 * And order runtime chunks according to referenced between each other.
-		 * Chunks need to be in deterministic order since we add hashes to full chunk
-		 * during these hashing.
-		 */
-		/** @type {Chunk[]} */
-		const unorderedRuntimeChunks = [];
-		/** @type {Chunk[]} */
-		const otherChunks = [];
-		for (const c of this.chunks) {
-			if (c.hasRuntime()) {
-				unorderedRuntimeChunks.push(c);
-			} else {
-				otherChunks.push(c);
+	/**
+	 * @param {string | string[]} name the name of the export
+	 * @returns {boolean | undefined | null} if the export is provided
+	 */
+	isExportProvided(name) {
+		if (Array.isArray(name)) {
+			const info = this.getReadOnlyExportInfo(name[0]);
+			if (info.exportsInfo && name.length > 1) {
+				return info.exportsInfo.isExportProvided(name.slice(1));
 			}
+			return info.provided;
 		}
-		unorderedRuntimeChunks.sort(byId);
-		otherChunks.sort(byId);
+		const info = this.getReadOnlyExportInfo(name);
+		return info.provided;
+	}
 
-		/** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
-		/** @type {Map<Chunk, RuntimeChunkInfo>} */
-		const runtimeChunksMap = new Map();
-		for (const chunk of unorderedRuntimeChunks) {
-			runtimeChunksMap.set(chunk, {
-				chunk,
-				referencedBy: [],
-				remaining: 0
-			});
+	/**
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {string} key representing the usage
+	 */
+	getUsageKey(runtime) {
+		const key = [];
+		if (this._redirectTo !== undefined) {
+			key.push(this._redirectTo.getUsageKey(runtime));
+		} else {
+			key.push(this._otherExportsInfo.getUsed(runtime));
 		}
-		let remaining = 0;
-		for (const info of runtimeChunksMap.values()) {
-			for (const other of new Set(
-				Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
-					e => e.chunks[e.chunks.length - 1]
-				)
-			)) {
-				const otherInfo = runtimeChunksMap.get(other);
-				otherInfo.referencedBy.push(info);
-				info.remaining++;
-				remaining++;
-			}
+		key.push(this._sideEffectsOnlyInfo.getUsed(runtime));
+		for (const exportInfo of this.orderedOwnedExports) {
+			key.push(exportInfo.getUsed(runtime));
 		}
-		/** @type {Chunk[]} */
-		const runtimeChunks = [];
-		for (const info of runtimeChunksMap.values()) {
-			if (info.remaining === 0) {
-				runtimeChunks.push(info.chunk);
+		return key.join("|");
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtimeA first runtime
+	 * @param {RuntimeSpec} runtimeB second runtime
+	 * @returns {boolean} true, when equally used
+	 */
+	isEquallyUsed(runtimeA, runtimeB) {
+		if (this._redirectTo !== undefined) {
+			if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false;
+		} else {
+			if (
+				this._otherExportsInfo.getUsed(runtimeA) !==
+				this._otherExportsInfo.getUsed(runtimeB)
+			) {
+				return false;
 			}
 		}
-		// If there are any references between chunks
-		// make sure to follow these chains
-		if (remaining > 0) {
-			const readyChunks = [];
-			for (const chunk of runtimeChunks) {
-				const hasFullHashModules =
-					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
-				const info = runtimeChunksMap.get(chunk);
-				for (const otherInfo of info.referencedBy) {
-					if (hasFullHashModules) {
-						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
-					}
-					remaining--;
-					if (--otherInfo.remaining === 0) {
-						readyChunks.push(otherInfo.chunk);
-					}
-				}
-				if (readyChunks.length > 0) {
-					// This ensures deterministic ordering, since referencedBy is non-deterministic
-					readyChunks.sort(byId);
-					for (const c of readyChunks) runtimeChunks.push(c);
-					readyChunks.length = 0;
-				}
+		if (
+			this._sideEffectsOnlyInfo.getUsed(runtimeA) !==
+			this._sideEffectsOnlyInfo.getUsed(runtimeB)
+		) {
+			return false;
+		}
+		for (const exportInfo of this.ownedExports) {
+			if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB))
+				return false;
+		}
+		return true;
+	}
+
+	/**
+	 * @param {string | string[]} name export name
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {UsageStateType} usage status
+	 */
+	getUsed(name, runtime) {
+		if (Array.isArray(name)) {
+			if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);
+			let info = this.getReadOnlyExportInfo(name[0]);
+			if (info.exportsInfo && name.length > 1) {
+				return info.exportsInfo.getUsed(name.slice(1), runtime);
 			}
+			return info.getUsed(runtime);
 		}
-		// If there are still remaining references we have cycles and want to create a warning
-		if (remaining > 0) {
-			let circularRuntimeChunkInfo = [];
-			for (const info of runtimeChunksMap.values()) {
-				if (info.remaining !== 0) {
-					circularRuntimeChunkInfo.push(info);
-				}
+		let info = this.getReadOnlyExportInfo(name);
+		return info.getUsed(runtime);
+	}
+
+	/**
+	 * @param {string | string[]} name the export name
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {string | string[] | false} the used name
+	 */
+	getUsedName(name, runtime) {
+		if (Array.isArray(name)) {
+			// TODO improve this
+			if (name.length === 0) {
+				if (!this.isUsed(runtime)) return false;
+				return name;
 			}
-			circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
-			const err =
-				new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
-					circularRuntimeChunkInfo,
-					c => c.chunk.name || c.chunk.id
-				).join(", ")})
-This prevents using hashes of each other and should be avoided.`);
-			err.chunk = circularRuntimeChunkInfo[0].chunk;
-			this.warnings.push(err);
-			for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
+			let info = this.getReadOnlyExportInfo(name[0]);
+			const x = info.getUsedName(name[0], runtime);
+			if (x === false) return false;
+			const arr = x === name[0] && name.length === 1 ? name : [x];
+			if (name.length === 1) {
+				return arr;
+			}
+			if (
+				info.exportsInfo &&
+				info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
+			) {
+				const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
+				if (!nested) return false;
+				return arr.concat(nested);
+			} else {
+				return arr.concat(name.slice(1));
+			}
+		} else {
+			let info = this.getReadOnlyExportInfo(name);
+			const usedName = info.getUsedName(name, runtime);
+			return usedName;
 		}
-		this.logger.timeEnd("hashing: sort chunks");
+	}
 
-		const fullHashChunks = new Set();
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
-		const codeGenerationJobs = [];
-		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
-		const codeGenerationJobsMap = new Map();
+	/**
+	 * @param {Hash} hash the hash
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {void}
+	 */
+	updateHash(hash, runtime) {
+		this._updateHash(hash, runtime, new Set());
+	}
 
-		const processChunk = chunk => {
-			// Last minute module hash generation for modules that depend on chunk hashes
-			this.logger.time("hashing: hash runtime modules");
-			const runtime = chunk.runtime;
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!chunkGraph.hasModuleHashes(module, runtime)) {
-					const hash = this._createModuleHash(
-						module,
-						chunkGraph,
-						runtime,
-						hashFunction,
-						runtimeTemplate,
-						hashDigest,
-						hashDigestLength
-					);
-					let hashMap = codeGenerationJobsMap.get(hash);
-					if (hashMap) {
-						const moduleJob = hashMap.get(module);
-						if (moduleJob) {
-							moduleJob.runtimes.push(runtime);
-							continue;
-						}
-					} else {
-						hashMap = new Map();
-						codeGenerationJobsMap.set(hash, hashMap);
-					}
-					const job = {
-						module,
-						hash,
-						runtime,
-						runtimes: [runtime]
-					};
-					hashMap.set(module, job);
-					codeGenerationJobs.push(job);
-				}
+	/**
+	 * @param {Hash} hash the hash
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
+	 * @returns {void}
+	 */
+	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+		const set = new Set(alreadyVisitedExportsInfo);
+		set.add(this);
+		for (const exportInfo of this.orderedExports) {
+			if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {
+				exportInfo._updateHash(hash, runtime, set);
 			}
-			this.logger.timeAggregate("hashing: hash runtime modules");
-			this.logger.time("hashing: hash chunks");
-			const chunkHash = createHash(hashFunction);
-			try {
-				if (outputOptions.hashSalt) {
-					chunkHash.update(outputOptions.hashSalt);
-				}
-				chunk.updateHash(chunkHash, chunkGraph);
-				this.hooks.chunkHash.call(chunk, chunkHash, {
-					chunkGraph,
-					moduleGraph: this.moduleGraph,
-					runtimeTemplate: this.runtimeTemplate
+		}
+		this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);
+		this._otherExportsInfo._updateHash(hash, runtime, set);
+		if (this._redirectTo !== undefined) {
+			this._redirectTo._updateHash(hash, runtime, set);
+		}
+	}
+
+	getRestoreProvidedData() {
+		const otherProvided = this._otherExportsInfo.provided;
+		const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
+		const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
+		const exports = [];
+		for (const exportInfo of this.orderedExports) {
+			if (
+				exportInfo.provided !== otherProvided ||
+				exportInfo.canMangleProvide !== otherCanMangleProvide ||
+				exportInfo.terminalBinding !== otherTerminalBinding ||
+				exportInfo.exportsInfoOwned
+			) {
+				exports.push({
+					name: exportInfo.name,
+					provided: exportInfo.provided,
+					canMangleProvide: exportInfo.canMangleProvide,
+					terminalBinding: exportInfo.terminalBinding,
+					exportsInfo: exportInfo.exportsInfoOwned
+						? exportInfo.exportsInfo.getRestoreProvidedData()
+						: undefined
 				});
-				const chunkHashDigest = /** @type {string} */ (
-					chunkHash.digest(hashDigest)
-				);
-				hash.update(chunkHashDigest);
-				chunk.hash = chunkHashDigest;
-				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
-				const fullHashModules =
-					chunkGraph.getChunkFullHashModulesIterable(chunk);
-				if (fullHashModules) {
-					fullHashChunks.add(chunk);
-				} else {
-					this.hooks.contentHash.call(chunk);
-				}
-			} catch (err) {
-				this.errors.push(new ChunkRenderError(chunk, "", err));
 			}
-			this.logger.timeAggregate("hashing: hash chunks");
-		};
-		otherChunks.forEach(processChunk);
-		for (const chunk of runtimeChunks) processChunk(chunk);
-
-		this.logger.timeAggregateEnd("hashing: hash runtime modules");
-		this.logger.timeAggregateEnd("hashing: hash chunks");
-		this.logger.time("hashing: hash digest");
-		this.hooks.fullHash.call(hash);
-		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
-		this.hash = this.fullHash.substr(0, hashDigestLength);
-		this.logger.timeEnd("hashing: hash digest");
+		}
+		return new RestoreProvidedData(
+			exports,
+			otherProvided,
+			otherCanMangleProvide,
+			otherTerminalBinding
+		);
+	}
 
-		this.logger.time("hashing: process full hash modules");
-		for (const chunk of fullHashChunks) {
-			for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
-				const moduleHash = createHash(hashFunction);
-				module.updateHash(moduleHash, {
-					chunkGraph,
-					runtime: chunk.runtime,
-					runtimeTemplate
-				});
-				const moduleHashDigest = /** @type {string} */ (
-					moduleHash.digest(hashDigest)
-				);
-				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
-				chunkGraph.setModuleHashes(
-					module,
-					chunk.runtime,
-					moduleHashDigest,
-					moduleHashDigest.substr(0, hashDigestLength)
-				);
-				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
+	restoreProvided({
+		otherProvided,
+		otherCanMangleProvide,
+		otherTerminalBinding,
+		exports
+	}) {
+		let wasEmpty = true;
+		for (const exportInfo of this._exports.values()) {
+			wasEmpty = false;
+			exportInfo.provided = otherProvided;
+			exportInfo.canMangleProvide = otherCanMangleProvide;
+			exportInfo.terminalBinding = otherTerminalBinding;
+		}
+		this._otherExportsInfo.provided = otherProvided;
+		this._otherExportsInfo.canMangleProvide = otherCanMangleProvide;
+		this._otherExportsInfo.terminalBinding = otherTerminalBinding;
+		for (const exp of exports) {
+			const exportInfo = this.getExportInfo(exp.name);
+			exportInfo.provided = exp.provided;
+			exportInfo.canMangleProvide = exp.canMangleProvide;
+			exportInfo.terminalBinding = exp.terminalBinding;
+			if (exp.exportsInfo) {
+				const exportsInfo = exportInfo.createNestedExportsInfo();
+				exportsInfo.restoreProvided(exp.exportsInfo);
 			}
-			const chunkHash = createHash(hashFunction);
-			chunkHash.update(chunk.hash);
-			chunkHash.update(this.hash);
-			const chunkHashDigest = /** @type {string} */ (
-				chunkHash.digest(hashDigest)
-			);
-			chunk.hash = chunkHashDigest;
-			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
-			this.hooks.contentHash.call(chunk);
 		}
-		this.logger.timeEnd("hashing: process full hash modules");
-		return codeGenerationJobs;
+		if (wasEmpty) this._exportsAreOrdered = true;
 	}
+}
 
+class ExportInfo {
 	/**
-	 * @param {string} file file name
-	 * @param {Source} source asset source
-	 * @param {AssetInfo} assetInfo extra asset information
-	 * @returns {void}
+	 * @param {string} name the original name of the export
+	 * @param {ExportInfo=} initFrom init values from this ExportInfo
 	 */
-	emitAsset(file, source, assetInfo = {}) {
-		if (this.assets[file]) {
-			if (!isSourceEqual(this.assets[file], source)) {
-				this.errors.push(
-					new WebpackError(
-						`Conflict: Multiple assets emit different content to the same filename ${file}`
-					)
-				);
-				this.assets[file] = source;
-				this._setAssetInfo(file, assetInfo);
-				return;
+	constructor(name, initFrom) {
+		/** @type {string} */
+		this.name = name;
+		/** @private @type {string | null} */
+		this._usedName = initFrom ? initFrom._usedName : null;
+		/** @private @type {UsageStateType} */
+		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
+		/** @private @type {Map<string, RuntimeUsageStateType>} */
+		this._usedInRuntime =
+			initFrom && initFrom._usedInRuntime
+				? new Map(initFrom._usedInRuntime)
+				: undefined;
+		/** @private @type {boolean} */
+		this._hasUseInRuntimeInfo = initFrom
+			? initFrom._hasUseInRuntimeInfo
+			: false;
+		/**
+		 * true: it is provided
+		 * false: it is not provided
+		 * null: only the runtime knows if it is provided
+		 * undefined: it was not determined if it is provided
+		 * @type {boolean | null | undefined}
+		 */
+		this.provided = initFrom ? initFrom.provided : undefined;
+		/**
+		 * is the export a terminal binding that should be checked for export star conflicts
+		 * @type {boolean}
+		 */
+		this.terminalBinding = initFrom ? initFrom.terminalBinding : false;
+		/**
+		 * true: it can be mangled
+		 * false: is can not be mangled
+		 * undefined: it was not determined if it can be mangled
+		 * @type {boolean | undefined}
+		 */
+		this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
+		/**
+		 * true: it can be mangled
+		 * false: is can not be mangled
+		 * undefined: it was not determined if it can be mangled
+		 * @type {boolean | undefined}
+		 */
+		this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
+		/** @type {boolean} */
+		this.exportsInfoOwned = false;
+		/** @type {ExportsInfo=} */
+		this.exportsInfo = undefined;
+		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
+		this._target = undefined;
+		if (initFrom && initFrom._target) {
+			this._target = new Map();
+			for (const [key, value] of initFrom._target) {
+				this._target.set(key, {
+					connection: value.connection,
+					export: value.export || [name],
+					priority: value.priority
+				});
 			}
-			const oldInfo = this.assetsInfo.get(file);
-			const newInfo = Object.assign({}, oldInfo, assetInfo);
-			this._setAssetInfo(file, newInfo, oldInfo);
-			return;
 		}
-		this.assets[file] = source;
-		this._setAssetInfo(file, assetInfo, undefined);
+		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
+		this._maxTarget = undefined;
 	}
 
-	_setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
-		if (newInfo === undefined) {
-			this.assetsInfo.delete(file);
-		} else {
-			this.assetsInfo.set(file, newInfo);
-		}
-		const oldRelated = oldInfo && oldInfo.related;
-		const newRelated = newInfo && newInfo.related;
-		if (oldRelated) {
-			for (const key of Object.keys(oldRelated)) {
-				const remove = name => {
-					const relatedIn = this._assetsRelatedIn.get(name);
-					if (relatedIn === undefined) return;
-					const entry = relatedIn.get(key);
-					if (entry === undefined) return;
-					entry.delete(file);
-					if (entry.size !== 0) return;
-					relatedIn.delete(key);
-					if (relatedIn.size === 0) this._assetsRelatedIn.delete(name);
-				};
-				const entry = oldRelated[key];
-				if (Array.isArray(entry)) {
-					entry.forEach(remove);
-				} else if (entry) {
-					remove(entry);
-				}
-			}
-		}
-		if (newRelated) {
-			for (const key of Object.keys(newRelated)) {
-				const add = name => {
-					let relatedIn = this._assetsRelatedIn.get(name);
-					if (relatedIn === undefined) {
-						this._assetsRelatedIn.set(name, (relatedIn = new Map()));
-					}
-					let entry = relatedIn.get(key);
-					if (entry === undefined) {
-						relatedIn.set(key, (entry = new Set()));
-					}
-					entry.add(file);
-				};
-				const entry = newRelated[key];
-				if (Array.isArray(entry)) {
-					entry.forEach(add);
-				} else if (entry) {
-					add(entry);
+	// TODO webpack 5 remove
+	/** @private */
+	get used() {
+		throw new Error("REMOVED");
+	}
+	/** @private */
+	get usedName() {
+		throw new Error("REMOVED");
+	}
+	/**
+	 * @private
+	 * @param {*} v v
+	 */
+	set used(v) {
+		throw new Error("REMOVED");
+	}
+	/**
+	 * @private
+	 * @param {*} v v
+	 */
+	set usedName(v) {
+		throw new Error("REMOVED");
+	}
+
+	get canMangle() {
+		switch (this.canMangleProvide) {
+			case undefined:
+				return this.canMangleUse === false ? false : undefined;
+			case false:
+				return false;
+			case true:
+				switch (this.canMangleUse) {
+					case undefined:
+						return undefined;
+					case false:
+						return false;
+					case true:
+						return true;
 				}
-			}
 		}
+		throw new Error(
+			`Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}`
+		);
 	}
 
 	/**
-	 * @param {string} file file name
-	 * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
-	 * @param {AssetInfo | function(AssetInfo | undefined): AssetInfo} assetInfoUpdateOrFunction new asset info or function converting old to new
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true, when something changed
 	 */
-	updateAsset(
-		file,
-		newSourceOrFunction,
-		assetInfoUpdateOrFunction = undefined
-	) {
-		if (!this.assets[file]) {
-			throw new Error(
-				`Called Compilation.updateAsset for not existing filename ${file}`
-			);
-		}
-		if (typeof newSourceOrFunction === "function") {
-			this.assets[file] = newSourceOrFunction(this.assets[file]);
-		} else {
-			this.assets[file] = newSourceOrFunction;
+	setUsedInUnknownWay(runtime) {
+		let changed = false;
+		if (
+			this.setUsedConditionally(
+				used => used < UsageState.Unknown,
+				UsageState.Unknown,
+				runtime
+			)
+		) {
+			changed = true;
 		}
-		if (assetInfoUpdateOrFunction !== undefined) {
-			const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
-			if (typeof assetInfoUpdateOrFunction === "function") {
-				this._setAssetInfo(file, assetInfoUpdateOrFunction(oldInfo), oldInfo);
-			} else {
-				this._setAssetInfo(
-					file,
-					cachedCleverMerge(oldInfo, assetInfoUpdateOrFunction),
-					oldInfo
-				);
-			}
+		if (this.canMangleUse !== false) {
+			this.canMangleUse = false;
+			changed = true;
 		}
+		return changed;
 	}
 
-	renameAsset(file, newFile) {
-		const source = this.assets[file];
-		if (!source) {
-			throw new Error(
-				`Called Compilation.renameAsset for not existing filename ${file}`
-			);
-		}
-		if (this.assets[newFile]) {
-			if (!isSourceEqual(this.assets[file], source)) {
-				this.errors.push(
-					new WebpackError(
-						`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
-					)
-				);
-			}
-		}
-		const assetInfo = this.assetsInfo.get(file);
-		// Update related in all other assets
-		const relatedInInfo = this._assetsRelatedIn.get(file);
-		if (relatedInInfo) {
-			for (const [key, assets] of relatedInInfo) {
-				for (const name of assets) {
-					const info = this.assetsInfo.get(name);
-					if (!info) continue;
-					const related = info.related;
-					if (!related) continue;
-					const entry = related[key];
-					let newEntry;
-					if (Array.isArray(entry)) {
-						newEntry = entry.map(x => (x === file ? newFile : x));
-					} else if (entry === file) {
-						newEntry = newFile;
-					} else continue;
-					this.assetsInfo.set(name, {
-						...info,
-						related: {
-							...related,
-							[key]: newEntry
-						}
-					});
-				}
-			}
+	/**
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true, when something changed
+	 */
+	setUsedWithoutInfo(runtime) {
+		let changed = false;
+		if (this.setUsed(UsageState.NoInfo, runtime)) {
+			changed = true;
 		}
-		this._setAssetInfo(file, undefined, assetInfo);
-		this._setAssetInfo(newFile, assetInfo);
-		delete this.assets[file];
-		this.assets[newFile] = source;
-		for (const chunk of this.chunks) {
-			{
-				const size = chunk.files.size;
-				chunk.files.delete(file);
-				if (size !== chunk.files.size) {
-					chunk.files.add(newFile);
-				}
-			}
-			{
-				const size = chunk.auxiliaryFiles.size;
-				chunk.auxiliaryFiles.delete(file);
-				if (size !== chunk.auxiliaryFiles.size) {
-					chunk.auxiliaryFiles.add(newFile);
-				}
-			}
+		if (this.canMangleUse !== false) {
+			this.canMangleUse = false;
+			changed = true;
 		}
+		return changed;
 	}
 
-	/**
-	 * @param {string} file file name
-	 */
-	deleteAsset(file) {
-		if (!this.assets[file]) {
-			return;
+	setHasUseInfo() {
+		if (!this._hasUseInRuntimeInfo) {
+			this._hasUseInRuntimeInfo = true;
 		}
-		delete this.assets[file];
-		const assetInfo = this.assetsInfo.get(file);
-		this._setAssetInfo(file, undefined, assetInfo);
-		const related = assetInfo && assetInfo.related;
-		if (related) {
-			for (const key of Object.keys(related)) {
-				const checkUsedAndDelete = file => {
-					if (!this._assetsRelatedIn.has(file)) {
-						this.deleteAsset(file);
-					}
-				};
-				const items = related[key];
-				if (Array.isArray(items)) {
-					items.forEach(checkUsedAndDelete);
-				} else if (items) {
-					checkUsedAndDelete(items);
-				}
-			}
+		if (this.canMangleUse === undefined) {
+			this.canMangleUse = true;
 		}
-		// TODO If this becomes a performance problem
-		// store a reverse mapping from asset to chunk
-		for (const chunk of this.chunks) {
-			chunk.files.delete(file);
-			chunk.auxiliaryFiles.delete(file);
+		if (this.exportsInfoOwned) {
+			this.exportsInfo.setHasUseInfo();
 		}
 	}
 
-	getAssets() {
-		/** @type {Readonly<Asset>[]} */
-		const array = [];
-		for (const assetName of Object.keys(this.assets)) {
-			if (Object.prototype.hasOwnProperty.call(this.assets, assetName)) {
-				array.push({
-					name: assetName,
-					source: this.assets[assetName],
-					info: this.assetsInfo.get(assetName) || EMPTY_ASSET_INFO
-				});
+	/**
+	 * @param {function(UsageStateType): boolean} condition compare with old value
+	 * @param {UsageStateType} newValue set when condition is true
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true when something has changed
+	 */
+	setUsedConditionally(condition, newValue, runtime) {
+		if (runtime === undefined) {
+			if (this._globalUsed === undefined) {
+				this._globalUsed = newValue;
+				return true;
+			} else {
+				if (this._globalUsed !== newValue && condition(this._globalUsed)) {
+					this._globalUsed = newValue;
+					return true;
+				}
+			}
+		} else if (this._usedInRuntime === undefined) {
+			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
+				this._usedInRuntime = new Map();
+				forEachRuntime(runtime, runtime =>
+					this._usedInRuntime.set(runtime, newValue)
+				);
+				return true;
+			}
+		} else {
+			let changed = false;
+			forEachRuntime(runtime, runtime => {
+				/** @type {UsageStateType} */
+				let oldValue = this._usedInRuntime.get(runtime);
+				if (oldValue === undefined) oldValue = UsageState.Unused;
+				if (newValue !== oldValue && condition(oldValue)) {
+					if (newValue === UsageState.Unused) {
+						this._usedInRuntime.delete(runtime);
+					} else {
+						this._usedInRuntime.set(runtime, newValue);
+					}
+					changed = true;
+				}
+			});
+			if (changed) {
+				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
+				return true;
 			}
 		}
-		return array;
+		return false;
 	}
 
 	/**
-	 * @param {string} name the name of the asset
-	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
+	 * @param {UsageStateType} newValue new value of the used state
+	 * @param {RuntimeSpec} runtime only apply to this runtime
+	 * @returns {boolean} true when something has changed
 	 */
-	getAsset(name) {
-		if (!Object.prototype.hasOwnProperty.call(this.assets, name))
-			return undefined;
-		return {
-			name,
-			source: this.assets[name],
-			info: this.assetsInfo.get(name) || EMPTY_ASSET_INFO
-		};
-	}
-
-	clearAssets() {
-		for (const chunk of this.chunks) {
-			chunk.files.clear();
-			chunk.auxiliaryFiles.clear();
-		}
-	}
-
-	createModuleAssets() {
-		const { chunkGraph } = this;
-		for (const module of this.modules) {
-			if (module.buildInfo.assets) {
-				const assetsInfo = module.buildInfo.assetsInfo;
-				for (const assetName of Object.keys(module.buildInfo.assets)) {
-					const fileName = this.getPath(assetName, {
-						chunkGraph: this.chunkGraph,
-						module
-					});
-					for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-						chunk.auxiliaryFiles.add(fileName);
+	setUsed(newValue, runtime) {
+		if (runtime === undefined) {
+			if (this._globalUsed !== newValue) {
+				this._globalUsed = newValue;
+				return true;
+			}
+		} else if (this._usedInRuntime === undefined) {
+			if (newValue !== UsageState.Unused) {
+				this._usedInRuntime = new Map();
+				forEachRuntime(runtime, runtime =>
+					this._usedInRuntime.set(runtime, newValue)
+				);
+				return true;
+			}
+		} else {
+			let changed = false;
+			forEachRuntime(runtime, runtime => {
+				/** @type {UsageStateType} */
+				let oldValue = this._usedInRuntime.get(runtime);
+				if (oldValue === undefined) oldValue = UsageState.Unused;
+				if (newValue !== oldValue) {
+					if (newValue === UsageState.Unused) {
+						this._usedInRuntime.delete(runtime);
+					} else {
+						this._usedInRuntime.set(runtime, newValue);
 					}
-					this.emitAsset(
-						fileName,
-						module.buildInfo.assets[assetName],
-						assetsInfo ? assetsInfo.get(assetName) : undefined
-					);
-					this.hooks.moduleAsset.call(module, fileName);
+					changed = true;
 				}
+			});
+			if (changed) {
+				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
+				return true;
 			}
 		}
+		return false;
 	}
 
 	/**
-	 * @param {RenderManifestOptions} options options object
-	 * @returns {RenderManifestEntry[]} manifest entries
+	 * @param {any} key the key
+	 * @returns {boolean} true, if something has changed
 	 */
-	getRenderManifest(options) {
-		return this.hooks.renderManifest.call([], options);
+	unsetTarget(key) {
+		if (!this._target) return false;
+		if (this._target.delete(key)) {
+			this._maxTarget = undefined;
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * @param {Callback} callback signals when the call finishes
-	 * @returns {void}
+	 * @param {any} key the key
+	 * @param {ModuleGraphConnection} connection the target module if a single one
+	 * @param {string[]=} exportName the exported name
+	 * @param {number=} priority priority
+	 * @returns {boolean} true, if something has changed
 	 */
-	createChunkAssets(callback) {
-		const outputOptions = this.outputOptions;
-		const cachedSourceMap = new WeakMap();
-		/** @type {Map<string, {hash: string, source: Source, chunk: Chunk}>} */
-		const alreadyWrittenFiles = new Map();
+	setTarget(key, connection, exportName, priority = 0) {
+		if (exportName) exportName = [...exportName];
+		if (!this._target) {
+			this._target = new Map();
+			this._target.set(key, { connection, export: exportName, priority });
+			return true;
+		}
+		const oldTarget = this._target.get(key);
+		if (!oldTarget) {
+			if (oldTarget === null && !connection) return false;
+			this._target.set(key, { connection, export: exportName, priority });
+			this._maxTarget = undefined;
+			return true;
+		}
+		if (
+			oldTarget.connection !== connection ||
+			oldTarget.priority !== priority ||
+			(exportName
+				? !oldTarget.export || !equals(oldTarget.export, exportName)
+				: oldTarget.export)
+		) {
+			oldTarget.connection = connection;
+			oldTarget.export = exportName;
+			oldTarget.priority = priority;
+			this._maxTarget = undefined;
+			return true;
+		}
+		return false;
+	}
 
-		asyncLib.forEachLimit(
-			this.chunks,
-			15,
-			(chunk, callback) => {
-				/** @type {RenderManifestEntry[]} */
-				let manifest;
-				try {
-					manifest = this.getRenderManifest({
-						chunk,
-						hash: this.hash,
-						fullHash: this.fullHash,
-						outputOptions,
-						codeGenerationResults: this.codeGenerationResults,
-						moduleTemplates: this.moduleTemplates,
-						dependencyTemplates: this.dependencyTemplates,
-						chunkGraph: this.chunkGraph,
-						moduleGraph: this.moduleGraph,
-						runtimeTemplate: this.runtimeTemplate
-					});
-				} catch (err) {
-					this.errors.push(new ChunkRenderError(chunk, "", err));
-					return callback();
+	/**
+	 * @param {RuntimeSpec} runtime for this runtime
+	 * @returns {UsageStateType} usage state
+	 */
+	getUsed(runtime) {
+		if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
+		if (this._globalUsed !== undefined) return this._globalUsed;
+		if (this._usedInRuntime === undefined) {
+			return UsageState.Unused;
+		} else if (typeof runtime === "string") {
+			const value = this._usedInRuntime.get(runtime);
+			return value === undefined ? UsageState.Unused : value;
+		} else if (runtime === undefined) {
+			/** @type {UsageStateType} */
+			let max = UsageState.Unused;
+			for (const value of this._usedInRuntime.values()) {
+				if (value === UsageState.Used) {
+					return UsageState.Used;
 				}
-				asyncLib.forEach(
-					manifest,
-					(fileManifest, callback) => {
-						const ident = fileManifest.identifier;
-						const usedHash = fileManifest.hash;
-
-						const assetCacheItem = this._assetsCache.getItemCache(
-							ident,
-							usedHash
-						);
-
-						assetCacheItem.get((err, sourceFromCache) => {
-							/** @type {string | function(PathData, AssetInfo=): string} */
-							let filenameTemplate;
-							/** @type {string} */
-							let file;
-							/** @type {AssetInfo} */
-							let assetInfo;
-
-							let inTry = true;
-							const errorAndCallback = err => {
-								const filename =
-									file ||
-									(typeof file === "string"
-										? file
-										: typeof filenameTemplate === "string"
-										? filenameTemplate
-										: "");
-
-								this.errors.push(new ChunkRenderError(chunk, filename, err));
-								inTry = false;
-								return callback();
-							};
-
-							try {
-								if ("filename" in fileManifest) {
-									file = fileManifest.filename;
-									assetInfo = fileManifest.info;
-								} else {
-									filenameTemplate = fileManifest.filenameTemplate;
-									const pathAndInfo = this.getPathWithInfo(
-										filenameTemplate,
-										fileManifest.pathOptions
-									);
-									file = pathAndInfo.path;
-									assetInfo = fileManifest.info
-										? {
-												...pathAndInfo.info,
-												...fileManifest.info
-										  }
-										: pathAndInfo.info;
-								}
-
-								if (err) {
-									return errorAndCallback(err);
-								}
-
-								let source = sourceFromCache;
-
-								// check if the same filename was already written by another chunk
-								const alreadyWritten = alreadyWrittenFiles.get(file);
-								if (alreadyWritten !== undefined) {
-									if (alreadyWritten.hash !== usedHash) {
-										inTry = false;
-										return callback(
-											new WebpackError(
-												`Conflict: Multiple chunks emit assets to the same filename ${file}` +
-													` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
-											)
-										);
-									} else {
-										source = alreadyWritten.source;
-									}
-								} else if (!source) {
-									// render the asset
-									source = fileManifest.render();
-
-									// Ensure that source is a cached source to avoid additional cost because of repeated access
-									if (!(source instanceof CachedSource)) {
-										const cacheEntry = cachedSourceMap.get(source);
-										if (cacheEntry) {
-											source = cacheEntry;
-										} else {
-											const cachedSource = new CachedSource(source);
-											cachedSourceMap.set(source, cachedSource);
-											source = cachedSource;
-										}
-									}
-								}
-								this.emitAsset(file, source, assetInfo);
-								if (fileManifest.auxiliary) {
-									chunk.auxiliaryFiles.add(file);
-								} else {
-									chunk.files.add(file);
-								}
-								this.hooks.chunkAsset.call(chunk, file);
-								alreadyWrittenFiles.set(file, {
-									hash: usedHash,
-									source,
-									chunk
-								});
-								if (source !== sourceFromCache) {
-									assetCacheItem.store(source, err => {
-										if (err) return errorAndCallback(err);
-										inTry = false;
-										return callback();
-									});
-								} else {
-									inTry = false;
-									callback();
-								}
-							} catch (err) {
-								if (!inTry) throw err;
-								errorAndCallback(err);
-							}
-						});
-					},
-					callback
-				);
-			},
-			callback
-		);
+				if (max < value) max = value;
+			}
+			return max;
+		} else {
+			/** @type {UsageStateType} */
+			let max = UsageState.Unused;
+			for (const item of runtime) {
+				const value = this._usedInRuntime.get(item);
+				if (value !== undefined) {
+					if (value === UsageState.Used) {
+						return UsageState.Used;
+					}
+					if (max < value) max = value;
+				}
+			}
+			return max;
+		}
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {string} interpolated path
+	 * get used name
+	 * @param {string | undefined} fallbackName fallback name for used exports with no name
+	 * @param {RuntimeSpec} runtime check usage for this runtime only
+	 * @returns {string | false} used name
 	 */
-	getPath(filename, data = {}) {
-		if (!data.hash) {
-			data = {
-				hash: this.hash,
-				...data
-			};
+	getUsedName(fallbackName, runtime) {
+		if (this._hasUseInRuntimeInfo) {
+			if (this._globalUsed !== undefined) {
+				if (this._globalUsed === UsageState.Unused) return false;
+			} else {
+				if (this._usedInRuntime === undefined) return false;
+				if (typeof runtime === "string") {
+					if (!this._usedInRuntime.has(runtime)) {
+						return false;
+					}
+				} else if (runtime !== undefined) {
+					if (
+						Array.from(runtime).every(
+							runtime => !this._usedInRuntime.has(runtime)
+						)
+					) {
+						return false;
+					}
+				}
+			}
 		}
-		return this.getAssetPath(filename, data);
+		if (this._usedName !== null) return this._usedName;
+		return this.name || fallbackName;
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+	 * @returns {boolean} true, when a mangled name of this export is set
 	 */
-	getPathWithInfo(filename, data = {}) {
-		if (!data.hash) {
-			data = {
-				hash: this.hash,
-				...data
-			};
-		}
-		return this.getAssetPathWithInfo(filename, data);
+	hasUsedName() {
+		return this._usedName !== null;
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {string} interpolated path
+	 * Sets the mangled name of this export
+	 * @param {string} name the new name
+	 * @returns {void}
 	 */
-	getAssetPath(filename, data) {
-		return this.hooks.assetPath.call(
-			typeof filename === "function" ? filename(data) : filename,
-			data,
-			undefined
-		);
+	setUsedName(name) {
+		this._usedName = name;
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
-	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
 	 */
-	getAssetPathWithInfo(filename, data) {
-		const assetInfo = {};
-		// TODO webpack 5: refactor assetPath hook to receive { path, info } object
-		const newPath = this.hooks.assetPath.call(
-			typeof filename === "function" ? filename(data, assetInfo) : filename,
-			data,
-			assetInfo
-		);
-		return { path: newPath, info: assetInfo };
+	getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
+		if (this.terminalBinding) return this;
+		const target = this.getTarget(moduleGraph, resolveTargetFilter);
+		if (!target) return undefined;
+		const exportsInfo = moduleGraph.getExportsInfo(target.module);
+		if (!target.export) return exportsInfo;
+		return exportsInfo.getReadOnlyExportInfoRecursive(target.export);
 	}
 
-	getWarnings() {
-		return this.hooks.processWarnings.call(this.warnings);
+	isReexport() {
+		return !this.terminalBinding && this._target && this._target.size > 0;
 	}
 
-	getErrors() {
-		return this.hooks.processErrors.call(this.errors);
+	_getMaxTarget() {
+		if (this._maxTarget !== undefined) return this._maxTarget;
+		if (this._target.size <= 1) return (this._maxTarget = this._target);
+		let maxPriority = -Infinity;
+		let minPriority = Infinity;
+		for (const { priority } of this._target.values()) {
+			if (maxPriority < priority) maxPriority = priority;
+			if (minPriority > priority) minPriority = priority;
+		}
+		// This should be very common
+		if (maxPriority === minPriority) return (this._maxTarget = this._target);
+
+		// This is an edge case
+		const map = new Map();
+		for (const [key, value] of this._target) {
+			if (maxPriority === value.priority) {
+				map.set(key, value);
+			}
+		}
+		this._maxTarget = map;
+		return map;
 	}
 
 	/**
-	 * This function allows you to run another instance of webpack inside of webpack however as
-	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
-	 * from parent (or top level compiler) and creates a child Compilation
-	 *
-	 * @param {string} name name of the child compiler
-	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
-	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
-	 * @returns {Compiler} creates a child Compiler instance
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
-	createChildCompiler(name, outputOptions, plugins) {
-		const idx = this.childrenCounters[name] || 0;
-		this.childrenCounters[name] = idx + 1;
-		return this.compiler.createChildCompiler(
-			this,
-			name,
-			idx,
-			outputOptions,
-			plugins
-		);
+	findTarget(moduleGraph, validTargetModuleFilter) {
+		return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @param {ExecuteModuleOptions} options options
-	 * @param {ExecuteModuleCallback} callback callback
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
+	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
 	 */
-	executeModule(module, options, callback) {
-		// Aggregate all referenced modules and ensure they are ready
-		const modules = new Set([module]);
-		processAsyncTree(
-			modules,
-			10,
-			/**
-			 * @param {Module} module the module
-			 * @param {function(Module): void} push push more jobs
-			 * @param {Callback} callback callback
-			 * @returns {void}
-			 */
-			(module, push, callback) => {
-				this.buildQueue.waitFor(module, err => {
-					if (err) return callback(err);
-					this.processDependenciesQueue.waitFor(module, err => {
-						if (err) return callback(err);
-						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
-							module
-						)) {
-							const size = modules.size;
-							modules.add(m);
-							if (modules.size !== size) push(m);
-						}
-						callback();
-					});
-				});
-			},
-			err => {
-				if (err) return callback(err);
+	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
+		if (!this._target || this._target.size === 0) return undefined;
+		let rawTarget = this._getMaxTarget().values().next().value;
+		if (!rawTarget) return undefined;
+		/** @type {{ module: Module, export: string[] | undefined }} */
+		let target = {
+			module: rawTarget.connection.module,
+			export: rawTarget.export
+		};
+		for (;;) {
+			if (validTargetModuleFilter(target.module)) return target;
+			const exportsInfo = moduleGraph.getExportsInfo(target.module);
+			const exportInfo = exportsInfo.getExportInfo(target.export[0]);
+			if (alreadyVisited.has(exportInfo)) return null;
+			const newTarget = exportInfo._findTarget(
+				moduleGraph,
+				validTargetModuleFilter,
+				alreadyVisited
+			);
+			if (!newTarget) return false;
+			if (target.export.length === 1) {
+				target = newTarget;
+			} else {
+				target = {
+					module: newTarget.module,
+					export: newTarget.export
+						? newTarget.export.concat(target.export.slice(1))
+						: target.export.slice(1)
+				};
+			}
+		}
+	}
 
-				// Create new chunk graph, chunk and entrypoint for the build time execution
-				const chunkGraph = new ChunkGraph(
-					this.moduleGraph,
-					this.outputOptions.hashFunction
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the target
+	 */
+	getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
+		const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
+		if (result === CIRCULAR) return undefined;
+		return result;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
+	 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | undefined} the target
+	 */
+	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
+		/**
+		 * @param {{ connection: ModuleGraphConnection, export: string[] | undefined } | null} inputTarget unresolved target
+		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
+		 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | null} resolved target
+		 */
+		const resolveTarget = (inputTarget, alreadyVisited) => {
+			if (!inputTarget) return null;
+			if (!inputTarget.export) {
+				return {
+					module: inputTarget.connection.module,
+					connection: inputTarget.connection,
+					export: undefined
+				};
+			}
+			/** @type {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} */
+			let target = {
+				module: inputTarget.connection.module,
+				connection: inputTarget.connection,
+				export: inputTarget.export
+			};
+			if (!resolveTargetFilter(target)) return target;
+			let alreadyVisitedOwned = false;
+			for (;;) {
+				const exportsInfo = moduleGraph.getExportsInfo(target.module);
+				const exportInfo = exportsInfo.getExportInfo(target.export[0]);
+				if (!exportInfo) return target;
+				if (alreadyVisited.has(exportInfo)) return CIRCULAR;
+				const newTarget = exportInfo._getTarget(
+					moduleGraph,
+					resolveTargetFilter,
+					alreadyVisited
 				);
-				const runtime = "build time";
-				const { hashFunction, hashDigest, hashDigestLength } =
-					this.outputOptions;
-				const runtimeTemplate = this.runtimeTemplate;
+				if (newTarget === CIRCULAR) return CIRCULAR;
+				if (!newTarget) return target;
+				if (target.export.length === 1) {
+					target = newTarget;
+					if (!target.export) return target;
+				} else {
+					target = {
+						module: newTarget.module,
+						connection: newTarget.connection,
+						export: newTarget.export
+							? newTarget.export.concat(target.export.slice(1))
+							: target.export.slice(1)
+					};
+				}
+				if (!resolveTargetFilter(target)) return target;
+				if (!alreadyVisitedOwned) {
+					alreadyVisited = new Set(alreadyVisited);
+					alreadyVisitedOwned = true;
+				}
+				alreadyVisited.add(exportInfo);
+			}
+		};
 
-				const chunk = new Chunk("build time chunk", this._backCompat);
-				chunk.id = chunk.name;
-				chunk.ids = [chunk.id];
-				chunk.runtime = runtime;
+		if (!this._target || this._target.size === 0) return undefined;
+		if (alreadyVisited && alreadyVisited.has(this)) return CIRCULAR;
+		const newAlreadyVisited = new Set(alreadyVisited);
+		newAlreadyVisited.add(this);
+		const values = this._getMaxTarget().values();
+		const target = resolveTarget(values.next().value, newAlreadyVisited);
+		if (target === CIRCULAR) return CIRCULAR;
+		if (target === null) return undefined;
+		let result = values.next();
+		while (!result.done) {
+			const t = resolveTarget(result.value, newAlreadyVisited);
+			if (t === CIRCULAR) return CIRCULAR;
+			if (t === null) return undefined;
+			if (t.module !== target.module) return undefined;
+			if (!t.export !== !target.export) return undefined;
+			if (target.export && !equals(t.export, target.export)) return undefined;
+			result = values.next();
+		}
+		return target;
+	}
 
-				const entrypoint = new Entrypoint({
-					runtime,
-					chunkLoading: false,
-					...options.entryOptions
-				});
-				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
-				connectChunkGroupAndChunk(entrypoint, chunk);
-				entrypoint.setRuntimeChunk(chunk);
-				entrypoint.setEntrypointChunk(chunk);
+	/**
+	 * Move the target forward as long resolveTargetFilter is fulfilled
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
+	 * @param {function({ module: Module, export: string[] | undefined }): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
+	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the resolved target when moved
+	 */
+	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
+		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
+		if (target === CIRCULAR) return undefined;
+		if (!target) return undefined;
+		const originalTarget = this._getMaxTarget().values().next().value;
+		if (
+			originalTarget.connection === target.connection &&
+			originalTarget.export === target.export
+		) {
+			return undefined;
+		}
+		this._target.clear();
+		this._target.set(undefined, {
+			connection: updateOriginalConnection
+				? updateOriginalConnection(target)
+				: target.connection,
+			export: target.export,
+			priority: 0
+		});
+		return target;
+	}
 
-				const chunks = new Set([chunk]);
+	createNestedExportsInfo() {
+		if (this.exportsInfoOwned) return this.exportsInfo;
+		this.exportsInfoOwned = true;
+		const oldExportsInfo = this.exportsInfo;
+		this.exportsInfo = new ExportsInfo();
+		this.exportsInfo.setHasProvideInfo();
+		if (oldExportsInfo) {
+			this.exportsInfo.setRedirectNamedTo(oldExportsInfo);
+		}
+		return this.exportsInfo;
+	}
 
-				// Assign ids to modules and modules to the chunk
-				for (const module of modules) {
-					const id = module.identifier();
-					chunkGraph.setModuleId(module, id);
-					chunkGraph.connectChunkAndModule(chunk, module);
+	getNestedExportsInfo() {
+		return this.exportsInfo;
+	}
+
+	hasInfo(baseInfo, runtime) {
+		return (
+			(this._usedName && this._usedName !== this.name) ||
+			this.provided ||
+			this.terminalBinding ||
+			this.getUsed(runtime) !== baseInfo.getUsed(runtime)
+		);
+	}
+
+	updateHash(hash, runtime) {
+		this._updateHash(hash, runtime, new Set());
+	}
+
+	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
+		hash.update(
+			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
+				this.terminalBinding
+			}`
+		);
+		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
+			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
+		}
+	}
+
+	getUsedInfo() {
+		if (this._globalUsed !== undefined) {
+			switch (this._globalUsed) {
+				case UsageState.Unused:
+					return "unused";
+				case UsageState.NoInfo:
+					return "no usage info";
+				case UsageState.Unknown:
+					return "maybe used (runtime-defined)";
+				case UsageState.Used:
+					return "used";
+				case UsageState.OnlyPropertiesUsed:
+					return "only properties used";
+			}
+		} else if (this._usedInRuntime !== undefined) {
+			/** @type {Map<RuntimeUsageStateType, string[]>} */
+			const map = new Map();
+			for (const [runtime, used] of this._usedInRuntime) {
+				const list = map.get(used);
+				if (list !== undefined) list.push(runtime);
+				else map.set(used, [runtime]);
+			}
+			const specificInfo = Array.from(map, ([used, runtimes]) => {
+				switch (used) {
+					case UsageState.NoInfo:
+						return `no usage info in ${runtimes.join(", ")}`;
+					case UsageState.Unknown:
+						return `maybe used in ${runtimes.join(", ")} (runtime-defined)`;
+					case UsageState.Used:
+						return `used in ${runtimes.join(", ")}`;
+					case UsageState.OnlyPropertiesUsed:
+						return `only properties used in ${runtimes.join(", ")}`;
 				}
+			});
+			if (specificInfo.length > 0) {
+				return specificInfo.join("; ");
+			}
+		}
+		return this._hasUseInRuntimeInfo ? "unused" : "no usage info";
+	}
 
-				// Hash modules
-				for (const module of modules) {
-					this._createModuleHash(
-						module,
-						chunkGraph,
-						runtime,
-						hashFunction,
-						runtimeTemplate,
-						hashDigest,
-						hashDigestLength
-					);
+	getProvidedInfo() {
+		switch (this.provided) {
+			case undefined:
+				return "no provided info";
+			case null:
+				return "maybe provided (runtime-defined)";
+			case true:
+				return "provided";
+			case false:
+				return "not provided";
+		}
+	}
+
+	getRenameInfo() {
+		if (this._usedName !== null && this._usedName !== this.name) {
+			return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`;
+		}
+		switch (this.canMangleProvide) {
+			case undefined:
+				switch (this.canMangleUse) {
+					case undefined:
+						return "missing provision and use info prevents renaming";
+					case false:
+						return "usage prevents renaming (no provision info)";
+					case true:
+						return "missing provision info prevents renaming";
+				}
+				break;
+			case true:
+				switch (this.canMangleUse) {
+					case undefined:
+						return "missing usage info prevents renaming";
+					case false:
+						return "usage prevents renaming";
+					case true:
+						return "could be renamed";
+				}
+				break;
+			case false:
+				switch (this.canMangleUse) {
+					case undefined:
+						return "provision prevents renaming (no use info)";
+					case false:
+						return "usage and provision prevents renaming";
+					case true:
+						return "provision prevents renaming";
 				}
+				break;
+		}
+		throw new Error(
+			`Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}`
+		);
+	}
+}
 
-				const codeGenerationResults = new CodeGenerationResults(
-					this.outputOptions.hashFunction
+module.exports = ExportsInfo;
+module.exports.ExportInfo = ExportInfo;
+module.exports.UsageState = UsageState;
+
+
+/***/ }),
+
+/***/ 7145:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ConstDependency = __webpack_require__(76911);
+const ExportsInfoDependency = __webpack_require__(78988);
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class ExportsInfoApiPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ExportsInfoApiPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ExportsInfoDependency,
+					new ExportsInfoDependency.Template()
 				);
-				/** @type {WebpackError[]} */
-				const errors = [];
 				/**
-				 * @param {Module} module the module
-				 * @param {Callback} callback callback
+				 * @param {JavascriptParser} parser the parser
 				 * @returns {void}
 				 */
-				const codeGen = (module, callback) => {
-					this._codeGenerationModule(
-						module,
-						runtime,
-						[runtime],
-						chunkGraph.getModuleHash(module, runtime),
-						this.dependencyTemplates,
-						chunkGraph,
-						this.moduleGraph,
-						runtimeTemplate,
-						errors,
-						codeGenerationResults,
-						(err, codeGenerated) => {
-							callback(err);
-						}
-					);
-				};
-
-				const reportErrors = () => {
-					if (errors.length > 0) {
-						errors.sort(
-							compareSelect(err => err.module, compareModulesByIdentifier)
-						);
-						for (const error of errors) {
-							this.errors.push(error);
-						}
-						errors.length = 0;
-					}
+				const handler = parser => {
+					parser.hooks.expressionMemberChain
+						.for("__webpack_exports_info__")
+						.tap("ExportsInfoApiPlugin", (expr, members) => {
+							const dep =
+								members.length >= 2
+									? new ExportsInfoDependency(
+											expr.range,
+											members.slice(0, -1),
+											members[members.length - 1]
+									  )
+									: new ExportsInfoDependency(expr.range, null, members[0]);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+					parser.hooks.expression
+						.for("__webpack_exports_info__")
+						.tap("ExportsInfoApiPlugin", expr => {
+							const dep = new ConstDependency("true", expr.range);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ExportsInfoApiPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ExportsInfoApiPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ExportsInfoApiPlugin", handler);
+			}
+		);
+	}
+}
 
-				// Generate code for all aggregated modules
-				asyncLib.eachLimit(modules, 10, codeGen, err => {
-					if (err) return callback(err);
-					reportErrors();
-
-					// for backward-compat temporary set the chunk graph
-					// TODO webpack 6
-					const old = this.chunkGraph;
-					this.chunkGraph = chunkGraph;
-					this.processRuntimeRequirements({
-						chunkGraph,
-						modules,
-						chunks,
-						codeGenerationResults,
-						chunkGraphEntries: chunks
-					});
-					this.chunkGraph = old;
-
-					const runtimeModules =
-						chunkGraph.getChunkRuntimeModulesIterable(chunk);
+module.exports = ExportsInfoApiPlugin;
 
-					// Hash runtime modules
-					for (const module of runtimeModules) {
-						modules.add(module);
-						this._createModuleHash(
-							module,
-							chunkGraph,
-							runtime,
-							hashFunction,
-							runtimeTemplate,
-							hashDigest,
-							hashDigestLength
-						);
-					}
 
-					// Generate code for all runtime modules
-					asyncLib.eachLimit(runtimeModules, 10, codeGen, err => {
-						if (err) return callback(err);
-						reportErrors();
+/***/ }),
 
-						/** @type {Map<Module, ExecuteModuleArgument>} */
-						const moduleArgumentsMap = new Map();
-						/** @type {Map<string, ExecuteModuleArgument>} */
-						const moduleArgumentsById = new Map();
+/***/ 73071:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						/** @type {ExecuteModuleResult["fileDependencies"]} */
-						const fileDependencies = new LazySet();
-						/** @type {ExecuteModuleResult["contextDependencies"]} */
-						const contextDependencies = new LazySet();
-						/** @type {ExecuteModuleResult["missingDependencies"]} */
-						const missingDependencies = new LazySet();
-						/** @type {ExecuteModuleResult["buildDependencies"]} */
-						const buildDependencies = new LazySet();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						/** @type {ExecuteModuleResult["assets"]} */
-						const assets = new Map();
 
-						let cacheable = true;
 
-						/** @type {ExecuteModuleContext} */
-						const context = {
-							assets,
-							__webpack_require__: undefined,
-							chunk,
-							chunkGraph
-						};
-
-						// Prepare execution
-						asyncLib.eachLimit(
-							modules,
-							10,
-							(module, callback) => {
-								const codeGenerationResult = codeGenerationResults.get(
-									module,
-									runtime
-								);
-								/** @type {ExecuteModuleArgument} */
-								const moduleArgument = {
-									module,
-									codeGenerationResult,
-									preparedInfo: undefined,
-									moduleObject: undefined
-								};
-								moduleArgumentsMap.set(module, moduleArgument);
-								moduleArgumentsById.set(module.identifier(), moduleArgument);
-								module.addCacheDependencies(
-									fileDependencies,
-									contextDependencies,
-									missingDependencies,
-									buildDependencies
-								);
-								if (module.buildInfo.cacheable === false) {
-									cacheable = false;
-								}
-								if (module.buildInfo && module.buildInfo.assets) {
-									const { assets: moduleAssets, assetsInfo } = module.buildInfo;
-									for (const assetName of Object.keys(moduleAssets)) {
-										assets.set(assetName, {
-											source: moduleAssets[assetName],
-											info: assetsInfo ? assetsInfo.get(assetName) : undefined
-										});
-									}
-								}
-								this.hooks.prepareModuleExecution.callAsync(
-									moduleArgument,
-									context,
-									callback
-								);
-							},
-							err => {
-								if (err) return callback(err);
-
-								let exports;
-								try {
-									const {
-										strictModuleErrorHandling,
-										strictModuleExceptionHandling
-									} = this.outputOptions;
-									const __nested_webpack_require_152290__ = id => {
-										const cached = moduleCache[id];
-										if (cached !== undefined) {
-											if (cached.error) throw cached.error;
-											return cached.exports;
-										}
-										const moduleArgument = moduleArgumentsById.get(id);
-										return __webpack_require_module__(moduleArgument, id);
-									};
-									const interceptModuleExecution = (__nested_webpack_require_152290__[
-										RuntimeGlobals.interceptModuleExecution.replace(
-											"__webpack_require__.",
-											""
-										)
-									] = []);
-									const moduleCache = (__nested_webpack_require_152290__[
-										RuntimeGlobals.moduleCache.replace(
-											"__webpack_require__.",
-											""
-										)
-									] = {});
-
-									context.__webpack_require__ = __nested_webpack_require_152290__;
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const ConcatenationScope = __webpack_require__(98229);
+const { UsageState } = __webpack_require__(63686);
+const InitFragment = __webpack_require__(55870);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const StaticExportsDependency = __webpack_require__(91418);
+const createHash = __webpack_require__(49835);
+const extractUrlAndGlobal = __webpack_require__(11850);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { register } = __webpack_require__(8282);
 
-									/**
-									 * @param {ExecuteModuleArgument} moduleArgument the module argument
-									 * @param {string=} id id
-									 * @returns {any} exports
-									 */
-									const __webpack_require_module__ = (moduleArgument, id) => {
-										var execOptions = {
-											id,
-											module: {
-												id,
-												exports: {},
-												loaded: false,
-												error: undefined
-											},
-											require: __nested_webpack_require_152290__
-										};
-										interceptModuleExecution.forEach(handler =>
-											handler(execOptions)
-										);
-										const module = moduleArgument.module;
-										this.buildTimeExecutedModules.add(module);
-										const moduleObject = execOptions.module;
-										moduleArgument.moduleObject = moduleObject;
-										try {
-											if (id) moduleCache[id] = moduleObject;
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {typeof import("./util/Hash")} HashConstructor */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-											tryRunOrWebpackError(
-												() =>
-													this.hooks.executeModule.call(
-														moduleArgument,
-														context
-													),
-												"Compilation.hooks.executeModule"
-											);
-											moduleObject.loaded = true;
-											return moduleObject.exports;
-										} catch (e) {
-											if (strictModuleExceptionHandling) {
-												if (id) delete moduleCache[id];
-											} else if (strictModuleErrorHandling) {
-												moduleObject.error = e;
-											}
-											if (!e.module) e.module = module;
-											throw e;
-										}
-									};
+/**
+ * @typedef {Object} SourceData
+ * @property {boolean=} iife
+ * @property {string=} init
+ * @property {string} expression
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {ReadonlySet<string>=} runtimeRequirements
+ */
 
-									for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
-										chunk
-									)) {
-										__webpack_require_module__(
-											moduleArgumentsMap.get(runtimeModule)
-										);
-									}
-									exports = __nested_webpack_require_152290__(module.identifier());
-								} catch (e) {
-									const err = new WebpackError(
-										`Execution of module code from module graph (${module.readableIdentifier(
-											this.requestShortener
-										)}) failed: ${e.message}`
-									);
-									err.stack = e.stack;
-									err.module = e.module;
-									return callback(err);
-								}
+const TYPES = new Set(["javascript"]);
+const CSS_TYPES = new Set(["css-import"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
+const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
+	RuntimeGlobals.definePropertyGetters
+]);
+const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
 
-								callback(null, {
-									exports,
-									assets,
-									cacheable,
-									fileDependencies,
-									contextDependencies,
-									missingDependencies,
-									buildDependencies
-								});
-							}
-						);
-					});
-				});
-			}
-		);
+/**
+ * @param {string|string[]} variableName the variable name or path
+ * @param {string} type the module system
+ * @returns {SourceData} the generated source
+ */
+const getSourceForGlobalVariableExternal = (variableName, type) => {
+	if (!Array.isArray(variableName)) {
+		// make it an array as the look up works the same basically
+		variableName = [variableName];
 	}
 
-	checkConstraints() {
-		const chunkGraph = this.chunkGraph;
-
-		/** @type {Set<number|string>} */
-		const usedIds = new Set();
-
-		for (const module of this.modules) {
-			if (module.type === "runtime") continue;
-			const moduleId = chunkGraph.getModuleId(module);
-			if (moduleId === null) continue;
-			if (usedIds.has(moduleId)) {
-				throw new Error(`checkConstraints: duplicate module id ${moduleId}`);
-			}
-			usedIds.add(moduleId);
-		}
-
-		for (const chunk of this.chunks) {
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!this.modules.has(module)) {
-					throw new Error(
-						"checkConstraints: module in chunk but not in compilation " +
-							` ${chunk.debugId} ${module.debugId}`
-					);
-				}
-			}
-			for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
-				if (!this.modules.has(module)) {
-					throw new Error(
-						"checkConstraints: entry module in chunk but not in compilation " +
-							` ${chunk.debugId} ${module.debugId}`
-					);
-				}
-			}
-		}
+	// needed for e.g. window["some"]["thing"]
+	const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join("");
+	return {
+		iife: type === "this",
+		expression: `${type}${objectLookup}`
+	};
+};
 
-		for (const chunkGroup of this.chunkGroups) {
-			chunkGroup.checkConstraints();
-		}
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
+ */
+const getSourceForCommonJsExternal = moduleAndSpecifiers => {
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
+		};
 	}
-}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
+			moduleAndSpecifiers,
+			1
+		)}`
+	};
+};
 
 /**
- * @typedef {Object} FactorizeModuleOptions
- * @property {ModuleProfile} currentProfile
- * @property {ModuleFactory} factory
- * @property {Dependency[]} dependencies
- * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module
- * @property {Module | null} originModule
- * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
- * @property {string=} context
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
  */
+const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
+	const chunkInitFragments = [
+		new InitFragment(
+			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		)
+	];
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+				moduleAndSpecifiers
+			)})`,
+			chunkInitFragments
+		};
+	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+			moduleName
+		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
+		chunkInitFragments
+	};
+};
 
 /**
- * @param {FactorizeModuleOptions} options options object
- * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
- * @returns {void}
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
  */
-
-// Workaround for typescript as it doesn't support function overloading in jsdoc within a class
-Compilation.prototype.factorizeModule = /** @type {{
-	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
-	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
-}} */ (
-	function (options, callback) {
-		this.factorizeQueue.add(options, callback);
+const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
+	const importName = runtimeTemplate.outputOptions.importFunctionName;
+	if (!runtimeTemplate.supportsDynamicImport() && importName === "import") {
+		throw new Error(
+			"The target environment doesn't support 'import()' so it's not possible to use external type 'import'"
+		);
 	}
-);
-
-// Hide from typescript
-const compilationPrototype = Compilation.prototype;
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers)});`
+		};
+	}
+	if (moduleAndSpecifiers.length === 1) {
+		return {
+			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers[0])});`
+		};
+	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `${importName}(${JSON.stringify(
+			moduleName
+		)}).then(${runtimeTemplate.returningFunction(
+			`module${propertyAccess(moduleAndSpecifiers, 1)}`,
+			"module"
+		)});`
+	};
+};
 
-// TODO webpack 6 remove
-Object.defineProperty(compilationPrototype, "modifyHash", {
-	writable: false,
-	enumerable: false,
-	configurable: false,
-	value: () => {
-		throw new Error(
-			"Compilation.modifyHash was removed in favor of Compilation.hooks.fullHash"
+class ModuleExternalInitFragment extends InitFragment {
+	/**
+	 * @param {string} request import source
+	 * @param {string=} ident recomputed ident
+	 * @param {string | HashConstructor=} hashFunction the hash function to use
+	 */
+	constructor(request, ident, hashFunction = "md4") {
+		if (ident === undefined) {
+			ident = Template.toIdentifier(request);
+			if (ident !== request) {
+				ident += `_${createHash(hashFunction)
+					.update(request)
+					.digest("hex")
+					.slice(0, 8)}`;
+			}
+		}
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
+		super(
+			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			`external module import ${ident}`
 		);
+		this._ident = ident;
+		this._identifier = identifier;
+		this._request = request;
 	}
-});
 
-// TODO webpack 6 remove
-Object.defineProperty(compilationPrototype, "cache", {
-	enumerable: false,
-	configurable: false,
-	get: util.deprecate(
-		/**
-		 * @this {Compilation} the compilation
-		 * @returns {Cache} the cache
-		 */
-		function () {
-			return this.compiler.cache;
-		},
-		"Compilation.cache was removed in favor of Compilation.getCache()",
-		"DEP_WEBPACK_COMPILATION_CACHE"
-	),
-	set: util.deprecate(
-		v => {},
-		"Compilation.cache was removed in favor of Compilation.getCache()",
-		"DEP_WEBPACK_COMPILATION_CACHE"
-	)
-});
+	getNamespaceIdentifier() {
+		return this._identifier;
+	}
+}
 
-/**
- * Add additional assets to the compilation.
- */
-Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000;
+register(
+	ModuleExternalInitFragment,
+	"webpack/lib/ExternalModule",
+	"ModuleExternalInitFragment",
+	{
+		serialize(obj, { write }) {
+			write(obj._request);
+			write(obj._ident);
+		},
+		deserialize({ read }) {
+			return new ModuleExternalInitFragment(read(), read());
+		}
+	}
+);
 
-/**
- * Basic preprocessing of assets.
- */
-Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1000;
+const generateModuleRemapping = (input, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
+		const properties = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const used = exportInfo.getUsedName(exportInfo.name, runtime);
+			if (!used) continue;
+			const nestedInfo = exportInfo.getNestedExportsInfo();
+			if (nestedInfo) {
+				const nestedExpr = generateModuleRemapping(
+					`${input}${propertyAccess([exportInfo.name])}`,
+					nestedInfo
+				);
+				if (nestedExpr) {
+					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
+					continue;
+				}
+			}
+			properties.push(
+				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
+					exportInfo.name
+				])}`
+			);
+		}
+		return `x({ ${properties.join(", ")} })`;
+	}
+};
 
 /**
- * Derive new assets from existing assets.
- * Existing assets should not be treated as complete.
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ExportsInfo} exportsInfo exports info of this module
+ * @param {RuntimeSpec} runtime the runtime
+ * @param {string | HashConstructor=} hashFunction the hash function to use
+ * @returns {SourceData} the generated source
  */
-Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200;
+const getSourceForModuleExternal = (
+	moduleAndSpecifiers,
+	exportsInfo,
+	runtime,
+	hashFunction
+) => {
+	if (!Array.isArray(moduleAndSpecifiers))
+		moduleAndSpecifiers = [moduleAndSpecifiers];
+	const initFragment = new ModuleExternalInitFragment(
+		moduleAndSpecifiers[0],
+		undefined,
+		hashFunction
+	);
+	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
+		moduleAndSpecifiers,
+		1
+	)}`;
+	const moduleRemapping = generateModuleRemapping(
+		baseAccess,
+		exportsInfo,
+		runtime
+	);
+	let expression = moduleRemapping || baseAccess;
+	return {
+		expression,
+		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
+		runtimeRequirements: moduleRemapping
+			? RUNTIME_REQUIREMENTS_FOR_MODULE
+			: undefined,
+		chunkInitFragments: [initFragment]
+	};
+};
 
 /**
- * Add additional sections to existing assets, like a banner or initialization code.
+ * @param {string|string[]} urlAndGlobal the script request
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
  */
-Compilation.PROCESS_ASSETS_STAGE_ADDITIONS = -100;
-
-/**
- * Optimize existing assets in a general way.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100;
-
-/**
- * Optimize the count of existing assets, e. g. by merging them.
- * Only assets of the same type should be merged.
- * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200;
-
-/**
- * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300;
-
-/**
- * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400;
-
-/**
- * Add development tooling to assets, e. g. by extracting a SourceMap.
- */
-Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500;
-
-/**
- * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
- * Only assets of different types should be inlined.
- * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700;
-
-/**
- * Summarize the list of existing assets
- * e. g. creating an assets manifest of Service Workers.
- */
-Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
-
-/**
- * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
-
-/**
- * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
- */
-Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
-
-/**
- * Analyse existing assets.
- */
-Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
+const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
+	if (typeof urlAndGlobal === "string") {
+		urlAndGlobal = extractUrlAndGlobal(urlAndGlobal);
+	}
+	const url = urlAndGlobal[0];
+	const globalName = urlAndGlobal[1];
+	return {
+		init: "var __webpack_error__ = new Error();",
+		expression: `new Promise(${runtimeTemplate.basicFunction(
+			"resolve, reject",
+			[
+				`if(typeof ${globalName} !== "undefined") return resolve();`,
+				`${RuntimeGlobals.loadScript}(${JSON.stringify(
+					url
+				)}, ${runtimeTemplate.basicFunction("event", [
+					`if(typeof ${globalName} !== "undefined") return resolve();`,
+					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+					"var realSrc = event && event.target && event.target.src;",
+					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
+					"__webpack_error__.name = 'ScriptExternalLoadError';",
+					"__webpack_error__.type = errorType;",
+					"__webpack_error__.request = realSrc;",
+					"reject(__webpack_error__);"
+				])}, ${JSON.stringify(globalName)});`
+			]
+		)}).then(${runtimeTemplate.returningFunction(
+			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
+		)})`,
+		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
+	};
+};
 
 /**
- * Creating assets for reporting purposes.
+ * @param {string} variableName the variable name to check
+ * @param {string} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {string} the generated source
  */
-Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
-
-module.exports = Compilation;
-
-
-/***/ }),
-
-/***/ 70845:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const parseJson = __webpack_require__(15235);
-const asyncLib = __webpack_require__(78175);
-const {
-	SyncHook,
-	SyncBailHook,
-	AsyncParallelHook,
-	AsyncSeriesHook
-} = __webpack_require__(41242);
-const { SizeOnlySource } = __webpack_require__(51255);
-const webpack = __webpack_require__(91919);
-const Cache = __webpack_require__(7592);
-const CacheFacade = __webpack_require__(55392);
-const ChunkGraph = __webpack_require__(64971);
-const Compilation = __webpack_require__(85720);
-const ConcurrentCompilationError = __webpack_require__(95735);
-const ContextModuleFactory = __webpack_require__(62471);
-const ModuleGraph = __webpack_require__(99988);
-const NormalModuleFactory = __webpack_require__(68860);
-const RequestShortener = __webpack_require__(73406);
-const ResolverFactory = __webpack_require__(30217);
-const Stats = __webpack_require__(31743);
-const Watching = __webpack_require__(84275);
-const WebpackError = __webpack_require__(53799);
-const { Logger } = __webpack_require__(32597);
-const { join, dirname, mkdirp } = __webpack_require__(17139);
-const { makePathsRelative } = __webpack_require__(82186);
-const { isSourceEqual } = __webpack_require__(41245);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+const checkExternalVariable = (variableName, request, runtimeTemplate) => {
+	return `if(typeof ${variableName} === 'undefined') { ${runtimeTemplate.throwMissingModuleErrorBlock(
+		{ request }
+	)} }\n`;
+};
 
 /**
- * @typedef {Object} CompilationParams
- * @property {NormalModuleFactory} normalModuleFactory
- * @property {ContextModuleFactory} contextModuleFactory
+ * @param {string|number} id the module id
+ * @param {boolean} optional true, if the module is optional
+ * @param {string|string[]} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
  */
+const getSourceForAmdOrUmdExternal = (
+	id,
+	optional,
+	request,
+	runtimeTemplate
+) => {
+	const externalVariable = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+		`${id}`
+	)}__`;
+	return {
+		init: optional
+			? checkExternalVariable(
+					externalVariable,
+					Array.isArray(request) ? request.join(".") : request,
+					runtimeTemplate
+			  )
+			: undefined,
+		expression: externalVariable
+	};
+};
 
 /**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
+ * @param {boolean} optional true, if the module is optional
+ * @param {string|string[]} request the request path
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {SourceData} the generated source
  */
+const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
+	if (!Array.isArray(request)) {
+		// make it an array as the look up works the same basically
+		request = [request];
+	}
 
-/**
- * @callback RunAsChildCallback
- * @param {(Error | null)=} err
- * @param {Chunk[]=} entries
- * @param {Compilation=} compilation
- */
+	const variableName = request[0];
+	const objectLookup = propertyAccess(request, 1);
+	return {
+		init: optional
+			? checkExternalVariable(variableName, request.join("."), runtimeTemplate)
+			: undefined,
+		expression: `${variableName}${objectLookup}`
+	};
+};
 
-/**
- * @typedef {Object} AssetEmittedInfo
- * @property {Buffer} content
- * @property {Source} source
- * @property {Compilation} compilation
- * @property {string} outputPath
- * @property {string} targetPath
- */
+class ExternalModule extends Module {
+	constructor(request, type, userRequest) {
+		super("javascript/dynamic", null);
 
-/**
- * @param {string[]} array an array
- * @returns {boolean} true, if the array is sorted
- */
-const isSorted = array => {
-	for (let i = 1; i < array.length; i++) {
-		if (array[i - 1] > array[i]) return false;
+		// Info from Factory
+		/** @type {string | string[] | Record<string, string | string[]>} */
+		this.request = request;
+		/** @type {string} */
+		this.externalType = type;
+		/** @type {string} */
+		this.userRequest = userRequest;
 	}
-	return true;
-};
 
-/**
- * @param {Object} obj an object
- * @param {string[]} keys the keys of the object
- * @returns {Object} the object with properties sorted by property name
- */
-const sortObject = (obj, keys) => {
-	const o = {};
-	for (const k of keys.sort()) {
-		o[k] = obj[k];
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return this.externalType === "css-import" ? CSS_TYPES : TYPES;
 	}
-	return o;
-};
 
-/**
- * @param {string} filename filename
- * @param {string | string[] | undefined} hashes list of hashes
- * @returns {boolean} true, if the filename contains any hash
- */
-const includesHash = (filename, hashes) => {
-	if (!hashes) return false;
-	if (Array.isArray(hashes)) {
-		return hashes.some(hash => filename.includes(hash));
-	} else {
-		return filename.includes(hashes);
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return this.userRequest;
 	}
-};
 
-class Compiler {
 	/**
-	 * @param {string} context the compilation path
-	 * @param {WebpackOptions} options options
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
 	 */
-	constructor(context, options = /** @type {WebpackOptions} */ ({})) {
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[]>} */
-			initialize: new SyncHook([]),
-
-			/** @type {SyncBailHook<[Compilation], boolean>} */
-			shouldEmit: new SyncBailHook(["compilation"]),
-			/** @type {AsyncSeriesHook<[Stats]>} */
-			done: new AsyncSeriesHook(["stats"]),
-			/** @type {SyncHook<[Stats]>} */
-			afterDone: new SyncHook(["stats"]),
-			/** @type {AsyncSeriesHook<[]>} */
-			additionalPass: new AsyncSeriesHook([]),
-			/** @type {AsyncSeriesHook<[Compiler]>} */
-			beforeRun: new AsyncSeriesHook(["compiler"]),
-			/** @type {AsyncSeriesHook<[Compiler]>} */
-			run: new AsyncSeriesHook(["compiler"]),
-			/** @type {AsyncSeriesHook<[Compilation]>} */
-			emit: new AsyncSeriesHook(["compilation"]),
-			/** @type {AsyncSeriesHook<[string, AssetEmittedInfo]>} */
-			assetEmitted: new AsyncSeriesHook(["file", "info"]),
-			/** @type {AsyncSeriesHook<[Compilation]>} */
-			afterEmit: new AsyncSeriesHook(["compilation"]),
-
-			/** @type {SyncHook<[Compilation, CompilationParams]>} */
-			thisCompilation: new SyncHook(["compilation", "params"]),
-			/** @type {SyncHook<[Compilation, CompilationParams]>} */
-			compilation: new SyncHook(["compilation", "params"]),
-			/** @type {SyncHook<[NormalModuleFactory]>} */
-			normalModuleFactory: new SyncHook(["normalModuleFactory"]),
-			/** @type {SyncHook<[ContextModuleFactory]>}  */
-			contextModuleFactory: new SyncHook(["contextModuleFactory"]),
-
-			/** @type {AsyncSeriesHook<[CompilationParams]>} */
-			beforeCompile: new AsyncSeriesHook(["params"]),
-			/** @type {SyncHook<[CompilationParams]>} */
-			compile: new SyncHook(["params"]),
-			/** @type {AsyncParallelHook<[Compilation]>} */
-			make: new AsyncParallelHook(["compilation"]),
-			/** @type {AsyncParallelHook<[Compilation]>} */
-			finishMake: new AsyncSeriesHook(["compilation"]),
-			/** @type {AsyncSeriesHook<[Compilation]>} */
-			afterCompile: new AsyncSeriesHook(["compilation"]),
-
-			/** @type {AsyncSeriesHook<[]>} */
-			readRecords: new AsyncSeriesHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
-			emitRecords: new AsyncSeriesHook([]),
-
-			/** @type {AsyncSeriesHook<[Compiler]>} */
-			watchRun: new AsyncSeriesHook(["compiler"]),
-			/** @type {SyncHook<[Error]>} */
-			failed: new SyncHook(["error"]),
-			/** @type {SyncHook<[string | null, number]>} */
-			invalid: new SyncHook(["filename", "changeTime"]),
-			/** @type {SyncHook<[]>} */
-			watchClose: new SyncHook([]),
-			/** @type {AsyncSeriesHook<[]>} */
-			shutdown: new AsyncSeriesHook([]),
-
-			/** @type {SyncBailHook<[string, string, any[]], true>} */
-			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
-
-			// TODO the following hooks are weirdly located here
-			// TODO move them for webpack 5
-			/** @type {SyncHook<[]>} */
-			environment: new SyncHook([]),
-			/** @type {SyncHook<[]>} */
-			afterEnvironment: new SyncHook([]),
-			/** @type {SyncHook<[Compiler]>} */
-			afterPlugins: new SyncHook(["compiler"]),
-			/** @type {SyncHook<[Compiler]>} */
-			afterResolvers: new SyncHook(["compiler"]),
-			/** @type {SyncBailHook<[string, Entry], boolean>} */
-			entryOption: new SyncBailHook(["context", "entry"])
-		});
-
-		this.webpack = webpack;
-
-		/** @type {string=} */
-		this.name = undefined;
-		/** @type {Compilation=} */
-		this.parentCompilation = undefined;
-		/** @type {Compiler} */
-		this.root = this;
-		/** @type {string} */
-		this.outputPath = "";
-		/** @type {Watching} */
-		this.watching = undefined;
-
-		/** @type {OutputFileSystem} */
-		this.outputFileSystem = null;
-		/** @type {IntermediateFileSystem} */
-		this.intermediateFileSystem = null;
-		/** @type {InputFileSystem} */
-		this.inputFileSystem = null;
-		/** @type {WatchFileSystem} */
-		this.watchFileSystem = null;
-
-		/** @type {string|null} */
-		this.recordsInputPath = null;
-		/** @type {string|null} */
-		this.recordsOutputPath = null;
-		this.records = {};
-		/** @type {Set<string | RegExp>} */
-		this.managedPaths = new Set();
-		/** @type {Set<string | RegExp>} */
-		this.immutablePaths = new Set();
-
-		/** @type {ReadonlySet<string>} */
-		this.modifiedFiles = undefined;
-		/** @type {ReadonlySet<string>} */
-		this.removedFiles = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
-		this.fileTimestamps = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
-		this.contextTimestamps = undefined;
-		/** @type {number} */
-		this.fsStartTime = undefined;
-
-		/** @type {ResolverFactory} */
-		this.resolverFactory = new ResolverFactory();
-
-		this.infrastructureLogger = undefined;
-
-		this.options = options;
-
-		this.context = context;
-
-		this.requestShortener = new RequestShortener(context, this.root);
-
-		this.cache = new Cache();
-
-		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
-		this.moduleMemCaches = undefined;
-
-		this.compilerPath = "";
-
-		/** @type {boolean} */
-		this.running = false;
-
-		/** @type {boolean} */
-		this.idle = false;
-
-		/** @type {boolean} */
-		this.watchMode = false;
-
-		this._backCompat = this.options.experiments.backCompat !== false;
+	chunkCondition(chunk, { chunkGraph }) {
+		return this.externalType === "css-import"
+			? true
+			: chunkGraph.getNumberOfEntryModules(chunk) > 0;
+	}
 
-		/** @type {Compilation} */
-		this._lastCompilation = undefined;
-		/** @type {NormalModuleFactory} */
-		this._lastNormalModuleFactory = undefined;
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
+	}
 
-		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
-		this._assetEmittingSourceCache = new WeakMap();
-		/** @private @type {Map<string, number>} */
-		this._assetEmittingWrittenFiles = new Map();
-		/** @private @type {Set<string>} */
-		this._assetEmittingPreviousFiles = new Set();
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return "external " + JSON.stringify(this.request);
 	}
 
 	/**
-	 * @param {string} name cache name
-	 * @returns {CacheFacade} the cache facade instance
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
 	 */
-	getCache(name) {
-		return new CacheFacade(
-			this.cache,
-			`${this.compilerPath}${name}`,
-			this.options.output.hashFunction
-		);
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
 	}
 
 	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
-	 * @returns {Logger} a logger with that name
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
 	 */
-	getInfrastructureLogger(name) {
-		if (!name) {
-			throw new TypeError(
-				"Compiler.getInfrastructureLogger(name) called without a name"
-			);
-		}
-		return new Logger(
-			(type, args) => {
-				if (typeof name === "function") {
-					name = name();
-					if (!name) {
-						throw new TypeError(
-							"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-						);
-					}
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {
+			async: false,
+			exportsType: undefined
+		};
+		this.buildInfo = {
+			strict: true,
+			topLevelDeclarations: new Set(),
+			module: compilation.outputOptions.module
+		};
+		const { request, externalType } = this._getRequestAndExternalType();
+		this.buildMeta.exportsType = "dynamic";
+		let canMangle = false;
+		this.clearDependenciesAndBlocks();
+		switch (externalType) {
+			case "this":
+				this.buildInfo.strict = false;
+				break;
+			case "system":
+				if (!Array.isArray(request) || request.length === 1) {
+					this.buildMeta.exportsType = "namespace";
+					canMangle = true;
 				}
-				if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
-					if (this.infrastructureLogger !== undefined) {
-						this.infrastructureLogger(name, type, args);
-					}
-				}
-			},
-			childName => {
-				if (typeof name === "function") {
-					if (typeof childName === "function") {
-						return this.getInfrastructureLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getInfrastructureLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
+				break;
+			case "module":
+				if (this.buildInfo.module) {
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = true;
 					}
 				} else {
-					if (typeof childName === "function") {
-						return this.getInfrastructureLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getInfrastructureLogger(`${name}/${childName}`);
+					this.buildMeta.async = true;
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = false;
 					}
 				}
-			}
-		);
-	}
-
-	// TODO webpack 6: solve this in a better way
-	// e.g. move compilation specific info from Modules into ModuleGraph
-	_cleanupLastCompilation() {
-		if (this._lastCompilation !== undefined) {
-			for (const module of this._lastCompilation.modules) {
-				ChunkGraph.clearChunkGraphForModule(module);
-				ModuleGraph.clearModuleGraphForModule(module);
-				module.cleanupForCache();
-			}
-			for (const chunk of this._lastCompilation.chunks) {
-				ChunkGraph.clearChunkGraphForChunk(chunk);
-			}
-			this._lastCompilation = undefined;
+				break;
+			case "script":
+			case "promise":
+				this.buildMeta.async = true;
+				break;
+			case "import":
+				this.buildMeta.async = true;
+				if (!Array.isArray(request) || request.length === 1) {
+					this.buildMeta.exportsType = "namespace";
+					canMangle = false;
+				}
+				break;
 		}
+		this.addDependency(new StaticExportsDependency(true, canMangle));
+		callback();
 	}
 
-	// TODO webpack 6: solve this in a better way
-	_cleanupLastNormalModuleFactory() {
-		if (this._lastNormalModuleFactory !== undefined) {
-			this._lastNormalModuleFactory.cleanupForCache();
-			this._lastNormalModuleFactory = undefined;
-		}
+	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
 	}
 
 	/**
-	 * @param {WatchOptions} watchOptions the watcher's options
-	 * @param {Callback<Stats>} handler signals when the call finishes
-	 * @returns {Watching} a compiler watcher
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
-	watch(watchOptions, handler) {
-		if (this.running) {
-			return handler(new ConcurrentCompilationError());
+	getConcatenationBailoutReason({ moduleGraph }) {
+		switch (this.externalType) {
+			case "amd":
+			case "amd-require":
+			case "umd":
+			case "umd2":
+			case "system":
+			case "jsonp":
+				return `${this.externalType} externals can't be concatenated`;
 		}
+		return undefined;
+	}
 
-		this.running = true;
-		this.watchMode = true;
-		this.watching = new Watching(this, watchOptions, handler);
-		return this.watching;
+	_getRequestAndExternalType() {
+		let { request, externalType } = this;
+		if (typeof request === "object" && !Array.isArray(request))
+			request = request[externalType];
+		return { request, externalType };
+	}
+
+	_getSourceData(
+		request,
+		externalType,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime
+	) {
+		switch (externalType) {
+			case "this":
+			case "window":
+			case "self":
+				return getSourceForGlobalVariableExternal(request, this.externalType);
+			case "global":
+				return getSourceForGlobalVariableExternal(
+					request,
+					runtimeTemplate.globalObject
+				);
+			case "commonjs":
+			case "commonjs2":
+			case "commonjs-module":
+			case "commonjs-static":
+				return getSourceForCommonJsExternal(request);
+			case "node-commonjs":
+				return this.buildInfo.module
+					? getSourceForCommonJsExternalInNodeModule(request)
+					: getSourceForCommonJsExternal(request);
+			case "amd":
+			case "amd-require":
+			case "umd":
+			case "umd2":
+			case "system":
+			case "jsonp": {
+				const id = chunkGraph.getModuleId(this);
+				return getSourceForAmdOrUmdExternal(
+					id !== null ? id : this.identifier(),
+					this.isOptional(moduleGraph),
+					request,
+					runtimeTemplate
+				);
+			}
+			case "import":
+				return getSourceForImportExternal(request, runtimeTemplate);
+			case "script":
+				return getSourceForScriptExternal(request, runtimeTemplate);
+			case "module": {
+				if (!this.buildInfo.module) {
+					if (!runtimeTemplate.supportsDynamicImport()) {
+						throw new Error(
+							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
+								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
+									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+									: "")
+						);
+					}
+					return getSourceForImportExternal(request, runtimeTemplate);
+				}
+				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
+					throw new Error(
+						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
+					);
+				}
+				return getSourceForModuleExternal(
+					request,
+					moduleGraph.getExportsInfo(this),
+					runtime,
+					runtimeTemplate.outputOptions.hashFunction
+				);
+			}
+			case "var":
+			case "promise":
+			case "const":
+			case "let":
+			case "assign":
+			default:
+				return getSourceForDefaultCase(
+					this.isOptional(moduleGraph),
+					request,
+					runtimeTemplate
+				);
+		}
 	}
 
 	/**
-	 * @param {Callback<Stats>} callback signals when the call finishes
-	 * @returns {void}
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	run(callback) {
-		if (this.running) {
-			return callback(new ConcurrentCompilationError());
-		}
+	codeGeneration({
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime,
+		concatenationScope
+	}) {
+		const { request, externalType } = this._getRequestAndExternalType();
+		switch (externalType) {
+			case "asset": {
+				const sources = new Map();
+				sources.set(
+					"javascript",
+					new RawSource(`module.exports = ${JSON.stringify(request)};`)
+				);
+				const data = new Map();
+				data.set("url", request);
+				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
+			}
+			case "css-import": {
+				const sources = new Map();
+				sources.set(
+					"css-import",
+					new RawSource(`@import url(${JSON.stringify(request)});`)
+				);
+				return {
+					sources,
+					runtimeRequirements: EMPTY_RUNTIME_REQUIREMENTS
+				};
+			}
+			default: {
+				const sourceData = this._getSourceData(
+					request,
+					externalType,
+					runtimeTemplate,
+					moduleGraph,
+					chunkGraph,
+					runtime
+				);
 
-		let logger;
+				let sourceString = sourceData.expression;
+				if (sourceData.iife)
+					sourceString = `(function() { return ${sourceString}; }())`;
+				if (concatenationScope) {
+					sourceString = `${
+						runtimeTemplate.supportsConst() ? "const" : "var"
+					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
+					concatenationScope.registerNamespaceExport(
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					);
+				} else {
+					sourceString = `module.exports = ${sourceString};`;
+				}
+				if (sourceData.init)
+					sourceString = `${sourceData.init}\n${sourceString}`;
 
-		const finalCallback = (err, stats) => {
-			if (logger) logger.time("beginIdle");
-			this.idle = true;
-			this.cache.beginIdle();
-			this.idle = true;
-			if (logger) logger.timeEnd("beginIdle");
-			this.running = false;
-			if (err) {
-				this.hooks.failed.call(err);
+				let data = undefined;
+				if (sourceData.chunkInitFragments) {
+					data = new Map();
+					data.set("chunkInitFragments", sourceData.chunkInitFragments);
+				}
+
+				const sources = new Map();
+				if (this.useSourceMap || this.useSimpleSourceMap) {
+					sources.set(
+						"javascript",
+						new OriginalSource(sourceString, this.identifier())
+					);
+				} else {
+					sources.set("javascript", new RawSource(sourceString));
+				}
+
+				let runtimeRequirements = sourceData.runtimeRequirements;
+				if (!concatenationScope) {
+					if (!runtimeRequirements) {
+						runtimeRequirements = RUNTIME_REQUIREMENTS;
+					} else {
+						const set = new Set(runtimeRequirements);
+						set.add(RuntimeGlobals.module);
+						runtimeRequirements = set;
+					}
+				}
+
+				return {
+					sources,
+					runtimeRequirements:
+						runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
+					data
+				};
 			}
-			if (callback !== undefined) callback(err, stats);
-			this.hooks.afterDone.call(stats);
-		};
+		}
+	}
 
-		const startTime = Date.now();
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
+	}
 
-		this.running = true;
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph } = context;
+		hash.update(
+			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
+				chunkGraph.moduleGraph
+			)}`
+		);
+		super.updateHash(hash, context);
+	}
 
-		const onCompiled = (err, compilation) => {
-			if (err) return finalCallback(err);
+	serialize(context) {
+		const { write } = context;
 
-			if (this.hooks.shouldEmit.call(compilation) === false) {
-				compilation.startTime = startTime;
-				compilation.endTime = Date.now();
-				const stats = new Stats(compilation);
-				this.hooks.done.callAsync(stats, err => {
-					if (err) return finalCallback(err);
-					return finalCallback(null, stats);
-				});
-				return;
-			}
+		write(this.request);
+		write(this.externalType);
+		write(this.userRequest);
 
-			process.nextTick(() => {
-				logger = compilation.getLogger("webpack.Compiler");
-				logger.time("emitAssets");
-				this.emitAssets(compilation, err => {
-					logger.timeEnd("emitAssets");
-					if (err) return finalCallback(err);
+		super.serialize(context);
+	}
 
-					if (compilation.hooks.needAdditionalPass.call()) {
-						compilation.needAdditionalPass = true;
+	deserialize(context) {
+		const { read } = context;
 
-						compilation.startTime = startTime;
-						compilation.endTime = Date.now();
-						logger.time("done hook");
-						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
-							logger.timeEnd("done hook");
-							if (err) return finalCallback(err);
+		this.request = read();
+		this.externalType = read();
+		this.userRequest = read();
 
-							this.hooks.additionalPass.callAsync(err => {
-								if (err) return finalCallback(err);
-								this.compile(onCompiled);
-							});
-						});
-						return;
-					}
+		super.deserialize(context);
+	}
+}
 
-					logger.time("emitRecords");
-					this.emitRecords(err => {
-						logger.timeEnd("emitRecords");
-						if (err) return finalCallback(err);
+makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
-						compilation.startTime = startTime;
-						compilation.endTime = Date.now();
-						logger.time("done hook");
-						const stats = new Stats(compilation);
-						this.hooks.done.callAsync(stats, err => {
-							logger.timeEnd("done hook");
-							if (err) return finalCallback(err);
-							this.cache.storeBuildDependencies(
-								compilation.buildDependencies,
-								err => {
-									if (err) return finalCallback(err);
-									return finalCallback(null, stats);
-								}
-							);
-						});
-					});
-				});
-			});
-		};
+module.exports = ExternalModule;
 
-		const run = () => {
-			this.hooks.beforeRun.callAsync(this, err => {
-				if (err) return finalCallback(err);
 
-				this.hooks.run.callAsync(this, err => {
-					if (err) return finalCallback(err);
+/***/ }),
 
-					this.readRecords(err => {
-						if (err) return finalCallback(err);
+/***/ 62153:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						this.compile(onCompiled);
-					});
-				});
-			});
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (this.idle) {
-			this.cache.endIdle(err => {
-				if (err) return finalCallback(err);
 
-				this.idle = false;
-				run();
-			});
-		} else {
-			run();
-		}
-	}
 
-	/**
-	 * @param {RunAsChildCallback} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	runAsChild(callback) {
-		const startTime = Date.now();
-		this.compile((err, compilation) => {
-			if (err) return callback(err);
+const util = __webpack_require__(73837);
+const ExternalModule = __webpack_require__(73071);
+const { resolveByProperty, cachedSetProperty } = __webpack_require__(60839);
 
-			this.parentCompilation.children.push(compilation);
-			for (const { name, source, info } of compilation.getAssets()) {
-				this.parentCompilation.emitAsset(name, source, info);
-			}
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
-			const entries = [];
-			for (const ep of compilation.entrypoints.values()) {
-				entries.push(...ep.chunks);
-			}
+const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
+const EMPTY_RESOLVE_OPTIONS = {};
 
-			compilation.startTime = startTime;
-			compilation.endTime = Date.now();
+// TODO webpack 6 remove this
+const callDeprecatedExternals = util.deprecate(
+	(externalsFunction, context, request, cb) => {
+		externalsFunction.call(null, context, request, cb);
+	},
+	"The externals-function should be defined like ({context, request}, cb) => { ... }",
+	"DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS"
+);
 
-			return callback(null, entries, compilation);
-		});
-	}
+const cache = new WeakMap();
 
-	purgeInputFileSystem() {
-		if (this.inputFileSystem && this.inputFileSystem.purge) {
-			this.inputFileSystem.purge();
-		}
+const resolveLayer = (obj, layer) => {
+	let map = cache.get(obj);
+	if (map === undefined) {
+		map = new Map();
+		cache.set(obj, map);
+	} else {
+		const cacheEntry = map.get(layer);
+		if (cacheEntry !== undefined) return cacheEntry;
 	}
+	const result = resolveByProperty(obj, "byLayer", layer);
+	map.set(layer, result);
+	return result;
+};
 
+class ExternalModuleFactoryPlugin {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {Callback<void>} callback signals when the assets are emitted
-	 * @returns {void}
+	 * @param {string | undefined} type default external type
+	 * @param {Externals} externals externals config
 	 */
-	emitAssets(compilation, callback) {
-		let outputPath;
-
-		const emitFiles = err => {
-			if (err) return callback(err);
-
-			const assets = compilation.getAssets();
-			compilation.assets = { ...compilation.assets };
-			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
-			const caseInsensitiveMap = new Map();
-			/** @type {Set<string>} */
-			const allTargetPaths = new Set();
-			asyncLib.forEachLimit(
-				assets,
-				15,
-				({ name: file, source, info }, callback) => {
-					let targetFile = file;
-					let immutable = info.immutable;
-					const queryStringIdx = targetFile.indexOf("?");
-					if (queryStringIdx >= 0) {
-						targetFile = targetFile.substr(0, queryStringIdx);
-						// We may remove the hash, which is in the query string
-						// So we recheck if the file is immutable
-						// This doesn't cover all cases, but immutable is only a performance optimization anyway
-						immutable =
-							immutable &&
-							(includesHash(targetFile, info.contenthash) ||
-								includesHash(targetFile, info.chunkhash) ||
-								includesHash(targetFile, info.modulehash) ||
-								includesHash(targetFile, info.fullhash));
-					}
-
-					const writeOut = err => {
-						if (err) return callback(err);
-						const targetPath = join(
-							this.outputFileSystem,
-							outputPath,
-							targetFile
-						);
-						allTargetPaths.add(targetPath);
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
+	}
 
-						// check if the target file has already been written by this Compiler
-						const targetFileGeneration =
-							this._assetEmittingWrittenFiles.get(targetPath);
+	/**
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+	 * @returns {void}
+	 */
+	apply(normalModuleFactory) {
+		const globalType = this.type;
+		normalModuleFactory.hooks.factorize.tapAsync(
+			"ExternalModuleFactoryPlugin",
+			(data, callback) => {
+				const context = data.context;
+				const contextInfo = data.contextInfo;
+				const dependency = data.dependencies[0];
+				const dependencyType = data.dependencyType;
 
-						// create an cache entry for this Source if not already existing
-						let cacheEntry = this._assetEmittingSourceCache.get(source);
-						if (cacheEntry === undefined) {
-							cacheEntry = {
-								sizeOnlySource: undefined,
-								writtenTo: new Map()
-							};
-							this._assetEmittingSourceCache.set(source, cacheEntry);
+				/**
+				 * @param {string|string[]|boolean|Record<string, string|string[]>} value the external config
+				 * @param {string|undefined} type type of external
+				 * @param {function(Error=, ExternalModule=): void} callback callback
+				 * @returns {void}
+				 */
+				const handleExternal = (value, type, callback) => {
+					if (value === false) {
+						// Not externals, fallback to original factory
+						return callback();
+					}
+					/** @type {string | string[] | Record<string, string|string[]>} */
+					let externalConfig;
+					if (value === true) {
+						externalConfig = dependency.request;
+					} else {
+						externalConfig = value;
+					}
+					// When no explicit type is specified, extract it from the externalConfig
+					if (type === undefined) {
+						if (
+							typeof externalConfig === "string" &&
+							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig)
+						) {
+							const idx = externalConfig.indexOf(" ");
+							type = externalConfig.substr(0, idx);
+							externalConfig = externalConfig.substr(idx + 1);
+						} else if (
+							Array.isArray(externalConfig) &&
+							externalConfig.length > 0 &&
+							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig[0])
+						) {
+							const firstItem = externalConfig[0];
+							const idx = firstItem.indexOf(" ");
+							type = firstItem.substr(0, idx);
+							externalConfig = [
+								firstItem.substr(idx + 1),
+								...externalConfig.slice(1)
+							];
 						}
+					}
+					callback(
+						null,
+						new ExternalModule(
+							externalConfig,
+							type || globalType,
+							dependency.request
+						)
+					);
+				};
 
-						let similarEntry;
-
-						const checkSimilarFile = () => {
-							const caseInsensitiveTargetPath = targetPath.toLowerCase();
-							similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath);
-							if (similarEntry !== undefined) {
-								const { path: other, source: otherSource } = similarEntry;
-								if (isSourceEqual(otherSource, source)) {
-									// Size may or may not be available at this point.
-									// If it's not available add to "waiting" list and it will be updated once available
-									if (similarEntry.size !== undefined) {
-										updateWithReplacementSource(similarEntry.size);
-									} else {
-										if (!similarEntry.waiting) similarEntry.waiting = [];
-										similarEntry.waiting.push({ file, cacheEntry });
+				/**
+				 * @param {Externals} externals externals config
+				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
+				 * @returns {void}
+				 */
+				const handleExternals = (externals, callback) => {
+					if (typeof externals === "string") {
+						if (externals === dependency.request) {
+							return handleExternal(dependency.request, undefined, callback);
+						}
+					} else if (Array.isArray(externals)) {
+						let i = 0;
+						const next = () => {
+							let asyncFlag;
+							const handleExternalsAndCallback = (err, module) => {
+								if (err) return callback(err);
+								if (!module) {
+									if (asyncFlag) {
+										asyncFlag = false;
+										return;
 									}
-									alreadyWritten();
-								} else {
-									const err =
-										new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file.
-This will lead to a race-condition and corrupted files on case-insensitive file systems.
-${targetPath}
-${other}`);
-									err.file = file;
-									callback(err);
+									return next();
 								}
-								return true;
-							} else {
-								caseInsensitiveMap.set(
-									caseInsensitiveTargetPath,
-									(similarEntry = {
-										path: targetPath,
-										source,
-										size: undefined,
-										waiting: undefined
-									})
-								);
-								return false;
-							}
-						};
+								callback(null, module);
+							};
 
-						/**
-						 * get the binary (Buffer) content from the Source
-						 * @returns {Buffer} content for the source
-						 */
-						const getContent = () => {
-							if (typeof source.buffer === "function") {
-								return source.buffer();
-							} else {
-								const bufferOrString = source.source();
-								if (Buffer.isBuffer(bufferOrString)) {
-									return bufferOrString;
-								} else {
-									return Buffer.from(bufferOrString, "utf8");
-								}
-							}
+							do {
+								asyncFlag = true;
+								if (i >= externals.length) return callback();
+								handleExternals(externals[i++], handleExternalsAndCallback);
+							} while (!asyncFlag);
+							asyncFlag = false;
 						};
 
-						const alreadyWritten = () => {
-							// cache the information that the Source has been already been written to that location
-							if (targetFileGeneration === undefined) {
-								const newGeneration = 1;
-								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								cacheEntry.writtenTo.set(targetPath, newGeneration);
+						next();
+						return;
+					} else if (externals instanceof RegExp) {
+						if (externals.test(dependency.request)) {
+							return handleExternal(dependency.request, undefined, callback);
+						}
+					} else if (typeof externals === "function") {
+						const cb = (err, value, type) => {
+							if (err) return callback(err);
+							if (value !== undefined) {
+								handleExternal(value, type, callback);
 							} else {
-								cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
+								callback();
 							}
-							callback();
 						};
+						if (externals.length === 3) {
+							// TODO webpack 6 remove this
+							callDeprecatedExternals(
+								externals,
+								context,
+								dependency.request,
+								cb
+							);
+						} else {
+							const promise = externals(
+								{
+									context,
+									request: dependency.request,
+									dependencyType,
+									contextInfo,
+									getResolve: options => (context, request, callback) => {
+										const resolveContext = {
+											fileDependencies: data.fileDependencies,
+											missingDependencies: data.missingDependencies,
+											contextDependencies: data.contextDependencies
+										};
+										let resolver = normalModuleFactory.getResolver(
+											"normal",
+											dependencyType
+												? cachedSetProperty(
+														data.resolveOptions || EMPTY_RESOLVE_OPTIONS,
+														"dependencyType",
+														dependencyType
+												  )
+												: data.resolveOptions
+										);
+										if (options) resolver = resolver.withOptions(options);
+										if (callback) {
+											resolver.resolve(
+												{},
+												context,
+												request,
+												resolveContext,
+												callback
+											);
+										} else {
+											return new Promise((resolve, reject) => {
+												resolver.resolve(
+													{},
+													context,
+													request,
+													resolveContext,
+													(err, result) => {
+														if (err) reject(err);
+														else resolve(result);
+													}
+												);
+											});
+										}
+									}
+								},
+								cb
+							);
+							if (promise && promise.then) promise.then(r => cb(null, r), cb);
+						}
+						return;
+					} else if (typeof externals === "object") {
+						const resolvedExternals = resolveLayer(
+							externals,
+							contextInfo.issuerLayer
+						);
+						if (
+							Object.prototype.hasOwnProperty.call(
+								resolvedExternals,
+								dependency.request
+							)
+						) {
+							return handleExternal(
+								resolvedExternals[dependency.request],
+								undefined,
+								callback
+							);
+						}
+					}
+					callback();
+				};
 
-						/**
-						 * Write the file to output file system
-						 * @param {Buffer} content content to be written
-						 * @returns {void}
-						 */
-						const doWrite = content => {
-							this.outputFileSystem.writeFile(targetPath, content, err => {
-								if (err) return callback(err);
+				handleExternals(this.externals, callback);
+			}
+		);
+	}
+}
+module.exports = ExternalModuleFactoryPlugin;
 
-								// information marker that the asset has been emitted
-								compilation.emittedAssets.add(file);
 
-								// cache the information that the Source has been written to that location
-								const newGeneration =
-									targetFileGeneration === undefined
-										? 1
-										: targetFileGeneration + 1;
-								cacheEntry.writtenTo.set(targetPath, newGeneration);
-								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								this.hooks.assetEmitted.callAsync(
-									file,
-									{
-										content,
-										source,
-										outputPath,
-										compilation,
-										targetPath
-									},
-									callback
-								);
-							});
-						};
+/***/ }),
 
-						const updateWithReplacementSource = size => {
-							updateFileWithReplacementSource(file, cacheEntry, size);
-							similarEntry.size = size;
-							if (similarEntry.waiting !== undefined) {
-								for (const { file, cacheEntry } of similarEntry.waiting) {
-									updateFileWithReplacementSource(file, cacheEntry, size);
-								}
-							}
-						};
+/***/ 6652:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-						const updateFileWithReplacementSource = (
-							file,
-							cacheEntry,
-							size
-						) => {
-							// Create a replacement resource which only allows to ask for size
-							// This allows to GC all memory allocated by the Source
-							// (expect when the Source is stored in any other cache)
-							if (!cacheEntry.sizeOnlySource) {
-								cacheEntry.sizeOnlySource = new SizeOnlySource(size);
-							}
-							compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
-								size
-							});
-						};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						const processExistingFile = stats => {
-							// skip emitting if it's already there and an immutable file
-							if (immutable) {
-								updateWithReplacementSource(stats.size);
-								return alreadyWritten();
-							}
 
-							const content = getContent();
 
-							updateWithReplacementSource(content.length);
+const ExternalModuleFactoryPlugin = __webpack_require__(62153);
 
-							// if it exists and content on disk matches content
-							// skip writing the same content again
-							// (to keep mtime and don't trigger watchers)
-							// for a fast negative match file size is compared first
-							if (content.length === stats.size) {
-								compilation.comparedForEmitAssets.add(file);
-								return this.outputFileSystem.readFile(
-									targetPath,
-									(err, existingContent) => {
-										if (
-											err ||
-											!content.equals(/** @type {Buffer} */ (existingContent))
-										) {
-											return doWrite(content);
-										} else {
-											return alreadyWritten();
-										}
-									}
-								);
-							}
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("./Compiler")} Compiler */
 
-							return doWrite(content);
-						};
+class ExternalsPlugin {
+	/**
+	 * @param {string | undefined} type default external type
+	 * @param {Externals} externals externals config
+	 */
+	constructor(type, externals) {
+		this.type = type;
+		this.externals = externals;
+	}
 
-						const processMissingFile = () => {
-							const content = getContent();
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
+			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
+				normalModuleFactory
+			);
+		});
+	}
+}
 
-							updateWithReplacementSource(content.length);
+module.exports = ExternalsPlugin;
 
-							return doWrite(content);
-						};
 
-						// if the target file has already been written
-						if (targetFileGeneration !== undefined) {
-							// check if the Source has been written to this target file
-							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
-							if (writtenGeneration === targetFileGeneration) {
-								// if yes, we may skip writing the file
-								// if it's already there
-								// (we assume one doesn't modify files while the Compiler is running, other then removing them)
+/***/ }),
 
-								if (this._assetEmittingPreviousFiles.has(targetPath)) {
-									// We assume that assets from the last compilation say intact on disk (they are not removed)
-									compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
-										size: cacheEntry.sizeOnlySource.size()
-									});
+/***/ 79453:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-									return callback();
-								} else {
-									// Settings immutable will make it accept file content without comparing when file exist
-									immutable = true;
-								}
-							} else if (!immutable) {
-								if (checkSimilarFile()) return;
-								// We wrote to this file before which has very likely a different content
-								// skip comparing and assume content is different for performance
-								// This case happens often during watch mode.
-								return processMissingFile();
-							}
-						}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						if (checkSimilarFile()) return;
-						if (this.options.output.compareBeforeEmit) {
-							this.outputFileSystem.stat(targetPath, (err, stats) => {
-								const exists = !err && stats.isFile();
 
-								if (exists) {
-									processExistingFile(stats);
-								} else {
-									processMissingFile();
-								}
-							});
-						} else {
-							processMissingFile();
-						}
-					};
 
-					if (targetFile.match(/\/|\\/)) {
-						const fs = this.outputFileSystem;
-						const dir = dirname(fs, join(fs, outputPath, targetFile));
-						mkdirp(fs, dir, writeOut);
-					} else {
-						writeOut();
-					}
-				},
-				err => {
-					// Clear map to free up memory
-					caseInsensitiveMap.clear();
-					if (err) {
-						this._assetEmittingPreviousFiles.clear();
-						return callback(err);
-					}
+const { create: createResolver } = __webpack_require__(9256);
+const asyncLib = __webpack_require__(78175);
+const AsyncQueue = __webpack_require__(12260);
+const StackedCacheMap = __webpack_require__(64985);
+const createHash = __webpack_require__(49835);
+const { join, dirname, relative, lstatReadlinkAbsolute } = __webpack_require__(17139);
+const makeSerializable = __webpack_require__(33032);
+const processAsyncTree = __webpack_require__(42791);
 
-					this._assetEmittingPreviousFiles = allTargetPaths;
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").IStats} IStats */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-					this.hooks.afterEmit.callAsync(compilation, err => {
-						if (err) return callback(err);
+const supportsEsm = +process.versions.modules >= 83;
 
-						return callback();
-					});
-				}
-			);
-		};
+let FS_ACCURACY = 2000;
 
-		this.hooks.emit.callAsync(compilation, err => {
-			if (err) return callback(err);
-			outputPath = compilation.getPath(this.outputPath, {});
-			mkdirp(this.outputFileSystem, outputPath, emitFiles);
-		});
+const EMPTY_SET = new Set();
+
+const RBDT_RESOLVE_CJS = 0;
+const RBDT_RESOLVE_ESM = 1;
+const RBDT_RESOLVE_DIRECTORY = 2;
+const RBDT_RESOLVE_CJS_FILE = 3;
+const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4;
+const RBDT_RESOLVE_ESM_FILE = 5;
+const RBDT_DIRECTORY = 6;
+const RBDT_FILE = 7;
+const RBDT_DIRECTORY_DEPENDENCIES = 8;
+const RBDT_FILE_DEPENDENCIES = 9;
+
+const INVALID = Symbol("invalid");
+
+/**
+ * @typedef {Object} FileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {number=} timestamp
+ */
+
+/**
+ * @typedef {Object} ResolvedContextFileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ */
+
+/**
+ * @typedef {Object} ContextFileSystemInfoEntry
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {ResolvedContextFileSystemInfoEntry=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
+/**
+ * @typedef {Object} TimestampAndHash
+ * @property {number} safeTime
+ * @property {number=} timestamp
+ * @property {string} hash
+ */
+
+/**
+ * @typedef {Object} ResolvedContextTimestampAndHash
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {string} hash
+ */
+
+/**
+ * @typedef {Object} ContextTimestampAndHash
+ * @property {number} safeTime
+ * @property {string=} timestampHash
+ * @property {string} hash
+ * @property {ResolvedContextTimestampAndHash=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
+/**
+ * @typedef {Object} ContextHash
+ * @property {string} hash
+ * @property {string=} resolved
+ * @property {Set<string>=} symlinks
+ */
+
+/**
+ * @typedef {Object} SnapshotOptimizationEntry
+ * @property {Snapshot} snapshot
+ * @property {number} shared
+ * @property {Set<string>} snapshotContent
+ * @property {Set<SnapshotOptimizationEntry>} children
+ */
+
+/**
+ * @typedef {Object} ResolveBuildDependenciesResult
+ * @property {Set<string>} files list of files
+ * @property {Set<string>} directories list of directories
+ * @property {Set<string>} missing list of missing entries
+ * @property {Map<string, string | false>} resolveResults stored resolve results
+ * @property {Object} resolveDependencies dependencies of the resolving
+ * @property {Set<string>} resolveDependencies.files list of files
+ * @property {Set<string>} resolveDependencies.directories list of directories
+ * @property {Set<string>} resolveDependencies.missing list of missing entries
+ */
+
+const DONE_ITERATOR_RESULT = new Set().keys().next();
+
+// cspell:word tshs
+// Tsh = Timestamp + Hash
+// Tshs = Timestamp + Hash combinations
+
+class SnapshotIterator {
+	constructor(next) {
+		this.next = next;
 	}
+}
 
-	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	emitRecords(callback) {
-		if (this.hooks.emitRecords.isUsed()) {
-			if (this.recordsOutputPath) {
-				asyncLib.parallel(
-					[
-						cb => this.hooks.emitRecords.callAsync(cb),
-						this._emitRecords.bind(this)
-					],
-					err => callback(err)
-				);
-			} else {
-				this.hooks.emitRecords.callAsync(callback);
-			}
-		} else {
-			if (this.recordsOutputPath) {
-				this._emitRecords(callback);
-			} else {
-				callback();
-			}
-		}
+class SnapshotIterable {
+	constructor(snapshot, getMaps) {
+		this.snapshot = snapshot;
+		this.getMaps = getMaps;
 	}
 
-	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	_emitRecords(callback) {
-		const writeFile = () => {
-			this.outputFileSystem.writeFile(
-				this.recordsOutputPath,
-				JSON.stringify(
-					this.records,
-					(n, value) => {
-						if (
-							typeof value === "object" &&
-							value !== null &&
-							!Array.isArray(value)
-						) {
-							const keys = Object.keys(value);
-							if (!isSorted(keys)) {
-								return sortObject(value, keys);
+	[Symbol.iterator]() {
+		let state = 0;
+		/** @type {IterableIterator<string>} */
+		let it;
+		/** @type {(Snapshot) => (Map<string, any> | Set<string>)[]} */
+		let getMaps;
+		/** @type {(Map<string, any> | Set<string>)[]} */
+		let maps;
+		/** @type {Snapshot} */
+		let snapshot;
+		let queue;
+		return new SnapshotIterator(() => {
+			for (;;) {
+				switch (state) {
+					case 0:
+						snapshot = this.snapshot;
+						getMaps = this.getMaps;
+						maps = getMaps(snapshot);
+						state = 1;
+					/* falls through */
+					case 1:
+						if (maps.length > 0) {
+							const map = maps.pop();
+							if (map !== undefined) {
+								it = map.keys();
+								state = 2;
+							} else {
+								break;
 							}
+						} else {
+							state = 3;
+							break;
 						}
-						return value;
-					},
-					2
-				),
-				callback
-			);
-		};
-
-		const recordsOutputPathDirectory = dirname(
-			this.outputFileSystem,
-			this.recordsOutputPath
-		);
-		if (!recordsOutputPathDirectory) {
-			return writeFile();
-		}
-		mkdirp(this.outputFileSystem, recordsOutputPathDirectory, err => {
-			if (err) return callback(err);
-			writeFile();
+					/* falls through */
+					case 2: {
+						const result = it.next();
+						if (!result.done) return result;
+						state = 1;
+						break;
+					}
+					case 3: {
+						const children = snapshot.children;
+						if (children !== undefined) {
+							if (children.size === 1) {
+								// shortcut for a single child
+								// avoids allocation of queue
+								for (const child of children) snapshot = child;
+								maps = getMaps(snapshot);
+								state = 1;
+								break;
+							}
+							if (queue === undefined) queue = [];
+							for (const child of children) {
+								queue.push(child);
+							}
+						}
+						if (queue !== undefined && queue.length > 0) {
+							snapshot = queue.pop();
+							maps = getMaps(snapshot);
+							state = 1;
+							break;
+						} else {
+							state = 4;
+						}
+					}
+					/* falls through */
+					case 4:
+						return DONE_ITERATOR_RESULT;
+				}
+			}
 		});
 	}
+}
 
-	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	readRecords(callback) {
-		if (this.hooks.readRecords.isUsed()) {
-			if (this.recordsInputPath) {
-				asyncLib.parallel([
-					cb => this.hooks.readRecords.callAsync(cb),
-					this._readRecords.bind(this)
-				]);
+class Snapshot {
+	constructor() {
+		this._flags = 0;
+		/** @type {number | undefined} */
+		this.startTime = undefined;
+		/** @type {Map<string, FileSystemInfoEntry | null> | undefined} */
+		this.fileTimestamps = undefined;
+		/** @type {Map<string, string | null> | undefined} */
+		this.fileHashes = undefined;
+		/** @type {Map<string, TimestampAndHash | string | null> | undefined} */
+		this.fileTshs = undefined;
+		/** @type {Map<string, ResolvedContextFileSystemInfoEntry | null> | undefined} */
+		this.contextTimestamps = undefined;
+		/** @type {Map<string, string | null> | undefined} */
+		this.contextHashes = undefined;
+		/** @type {Map<string, ResolvedContextTimestampAndHash | null> | undefined} */
+		this.contextTshs = undefined;
+		/** @type {Map<string, boolean> | undefined} */
+		this.missingExistence = undefined;
+		/** @type {Map<string, string> | undefined} */
+		this.managedItemInfo = undefined;
+		/** @type {Set<string> | undefined} */
+		this.managedFiles = undefined;
+		/** @type {Set<string> | undefined} */
+		this.managedContexts = undefined;
+		/** @type {Set<string> | undefined} */
+		this.managedMissing = undefined;
+		/** @type {Set<Snapshot> | undefined} */
+		this.children = undefined;
+	}
+
+	hasStartTime() {
+		return (this._flags & 1) !== 0;
+	}
+
+	setStartTime(value) {
+		this._flags = this._flags | 1;
+		this.startTime = value;
+	}
+
+	setMergedStartTime(value, snapshot) {
+		if (value) {
+			if (snapshot.hasStartTime()) {
+				this.setStartTime(Math.min(value, snapshot.startTime));
 			} else {
-				this.records = {};
-				this.hooks.readRecords.callAsync(callback);
+				this.setStartTime(value);
 			}
 		} else {
-			if (this.recordsInputPath) {
-				this._readRecords(callback);
-			} else {
-				this.records = {};
-				callback();
-			}
+			if (snapshot.hasStartTime()) this.setStartTime(snapshot.startTime);
 		}
 	}
 
-	/**
-	 * @param {Callback<void>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	_readRecords(callback) {
-		if (!this.recordsInputPath) {
-			this.records = {};
-			return callback();
-		}
-		this.inputFileSystem.stat(this.recordsInputPath, err => {
-			// It doesn't exist
-			// We can ignore this.
-			if (err) return callback();
-
-			this.inputFileSystem.readFile(this.recordsInputPath, (err, content) => {
-				if (err) return callback(err);
+	hasFileTimestamps() {
+		return (this._flags & 2) !== 0;
+	}
 
-				try {
-					this.records = parseJson(content.toString("utf-8"));
-				} catch (e) {
-					e.message = "Cannot parse records: " + e.message;
-					return callback(e);
-				}
+	setFileTimestamps(value) {
+		this._flags = this._flags | 2;
+		this.fileTimestamps = value;
+	}
 
-				return callback();
-			});
-		});
+	hasFileHashes() {
+		return (this._flags & 4) !== 0;
 	}
 
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {string} compilerName the compiler's name
-	 * @param {number} compilerIndex the compiler's index
-	 * @param {OutputOptions=} outputOptions the output options
-	 * @param {WebpackPluginInstance[]=} plugins the plugins to apply
-	 * @returns {Compiler} a child compiler
-	 */
-	createChildCompiler(
-		compilation,
-		compilerName,
-		compilerIndex,
-		outputOptions,
-		plugins
-	) {
-		const childCompiler = new Compiler(this.context, {
-			...this.options,
-			output: {
-				...this.options.output,
-				...outputOptions
-			}
-		});
-		childCompiler.name = compilerName;
-		childCompiler.outputPath = this.outputPath;
-		childCompiler.inputFileSystem = this.inputFileSystem;
-		childCompiler.outputFileSystem = null;
-		childCompiler.resolverFactory = this.resolverFactory;
-		childCompiler.modifiedFiles = this.modifiedFiles;
-		childCompiler.removedFiles = this.removedFiles;
-		childCompiler.fileTimestamps = this.fileTimestamps;
-		childCompiler.contextTimestamps = this.contextTimestamps;
-		childCompiler.fsStartTime = this.fsStartTime;
-		childCompiler.cache = this.cache;
-		childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
-		childCompiler._backCompat = this._backCompat;
+	setFileHashes(value) {
+		this._flags = this._flags | 4;
+		this.fileHashes = value;
+	}
 
-		const relativeCompilerName = makePathsRelative(
-			this.context,
-			compilerName,
-			this.root
-		);
-		if (!this.records[relativeCompilerName]) {
-			this.records[relativeCompilerName] = [];
-		}
-		if (this.records[relativeCompilerName][compilerIndex]) {
-			childCompiler.records = this.records[relativeCompilerName][compilerIndex];
-		} else {
-			this.records[relativeCompilerName].push((childCompiler.records = {}));
-		}
+	hasFileTshs() {
+		return (this._flags & 8) !== 0;
+	}
 
-		childCompiler.parentCompilation = compilation;
-		childCompiler.root = this.root;
-		if (Array.isArray(plugins)) {
-			for (const plugin of plugins) {
-				plugin.apply(childCompiler);
-			}
-		}
-		for (const name in this.hooks) {
-			if (
-				![
-					"make",
-					"compile",
-					"emit",
-					"afterEmit",
-					"invalid",
-					"done",
-					"thisCompilation"
-				].includes(name)
-			) {
-				if (childCompiler.hooks[name]) {
-					childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
-				}
-			}
-		}
+	setFileTshs(value) {
+		this._flags = this._flags | 8;
+		this.fileTshs = value;
+	}
 
-		compilation.hooks.childCompiler.call(
-			childCompiler,
-			compilerName,
-			compilerIndex
-		);
+	hasContextTimestamps() {
+		return (this._flags & 0x10) !== 0;
+	}
 
-		return childCompiler;
+	setContextTimestamps(value) {
+		this._flags = this._flags | 0x10;
+		this.contextTimestamps = value;
 	}
 
-	isChild() {
-		return !!this.parentCompilation;
+	hasContextHashes() {
+		return (this._flags & 0x20) !== 0;
 	}
 
-	createCompilation(params) {
-		this._cleanupLastCompilation();
-		return (this._lastCompilation = new Compilation(this, params));
+	setContextHashes(value) {
+		this._flags = this._flags | 0x20;
+		this.contextHashes = value;
 	}
 
-	/**
-	 * @param {CompilationParams} params the compilation parameters
-	 * @returns {Compilation} the created compilation
-	 */
-	newCompilation(params) {
-		const compilation = this.createCompilation(params);
-		compilation.name = this.name;
-		compilation.records = this.records;
-		this.hooks.thisCompilation.call(compilation, params);
-		this.hooks.compilation.call(compilation, params);
-		return compilation;
+	hasContextTshs() {
+		return (this._flags & 0x40) !== 0;
 	}
 
-	createNormalModuleFactory() {
-		this._cleanupLastNormalModuleFactory();
-		const normalModuleFactory = new NormalModuleFactory({
-			context: this.options.context,
-			fs: this.inputFileSystem,
-			resolverFactory: this.resolverFactory,
-			options: this.options.module,
-			associatedObjectForCache: this.root,
-			layers: this.options.experiments.layers
-		});
-		this._lastNormalModuleFactory = normalModuleFactory;
-		this.hooks.normalModuleFactory.call(normalModuleFactory);
-		return normalModuleFactory;
+	setContextTshs(value) {
+		this._flags = this._flags | 0x40;
+		this.contextTshs = value;
 	}
 
-	createContextModuleFactory() {
-		const contextModuleFactory = new ContextModuleFactory(this.resolverFactory);
-		this.hooks.contextModuleFactory.call(contextModuleFactory);
-		return contextModuleFactory;
+	hasMissingExistence() {
+		return (this._flags & 0x80) !== 0;
 	}
 
-	newCompilationParams() {
-		const params = {
-			normalModuleFactory: this.createNormalModuleFactory(),
-			contextModuleFactory: this.createContextModuleFactory()
-		};
-		return params;
+	setMissingExistence(value) {
+		this._flags = this._flags | 0x80;
+		this.missingExistence = value;
 	}
 
-	/**
-	 * @param {Callback<Compilation>} callback signals when the compilation finishes
-	 * @returns {void}
-	 */
-	compile(callback) {
-		const params = this.newCompilationParams();
-		this.hooks.beforeCompile.callAsync(params, err => {
-			if (err) return callback(err);
+	hasManagedItemInfo() {
+		return (this._flags & 0x100) !== 0;
+	}
 
-			this.hooks.compile.call(params);
+	setManagedItemInfo(value) {
+		this._flags = this._flags | 0x100;
+		this.managedItemInfo = value;
+	}
 
-			const compilation = this.newCompilation(params);
+	hasManagedFiles() {
+		return (this._flags & 0x200) !== 0;
+	}
 
-			const logger = compilation.getLogger("webpack.Compiler");
+	setManagedFiles(value) {
+		this._flags = this._flags | 0x200;
+		this.managedFiles = value;
+	}
 
-			logger.time("make hook");
-			this.hooks.make.callAsync(compilation, err => {
-				logger.timeEnd("make hook");
-				if (err) return callback(err);
+	hasManagedContexts() {
+		return (this._flags & 0x400) !== 0;
+	}
 
-				logger.time("finish make hook");
-				this.hooks.finishMake.callAsync(compilation, err => {
-					logger.timeEnd("finish make hook");
-					if (err) return callback(err);
-
-					process.nextTick(() => {
-						logger.time("finish compilation");
-						compilation.finish(err => {
-							logger.timeEnd("finish compilation");
-							if (err) return callback(err);
-
-							logger.time("seal compilation");
-							compilation.seal(err => {
-								logger.timeEnd("seal compilation");
-								if (err) return callback(err);
-
-								logger.time("afterCompile hook");
-								this.hooks.afterCompile.callAsync(compilation, err => {
-									logger.timeEnd("afterCompile hook");
-									if (err) return callback(err);
-
-									return callback(null, compilation);
-								});
-							});
-						});
-					});
-				});
-			});
-		});
+	setManagedContexts(value) {
+		this._flags = this._flags | 0x400;
+		this.managedContexts = value;
 	}
 
-	/**
-	 * @param {Callback<void>} callback signals when the compiler closes
-	 * @returns {void}
-	 */
-	close(callback) {
-		if (this.watching) {
-			// When there is still an active watching, close this first
-			this.watching.close(err => {
-				this.close(callback);
-			});
-			return;
-		}
-		this.hooks.shutdown.callAsync(err => {
-			if (err) return callback(err);
-			// Get rid of reference to last compilation to avoid leaking memory
-			// We can't run this._cleanupLastCompilation() as the Stats to this compilation
-			// might be still in use. We try to get rid of the reference to the cache instead.
-			this._lastCompilation = undefined;
-			this._lastNormalModuleFactory = undefined;
-			this.cache.shutdown(callback);
-		});
+	hasManagedMissing() {
+		return (this._flags & 0x800) !== 0;
 	}
-}
-
-module.exports = Compiler;
-
-
-/***/ }),
-
-/***/ 98229:
-/***/ (function(module) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./Module")} Module */
-
-const MODULE_REFERENCE_REGEXP =
-	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(?:_asiSafe(\d))?__$/;
-
-const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
-const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
-
-/**
- * @typedef {Object} ExternalModuleInfo
- * @property {number} index
- * @property {Module} module
- */
-
-/**
- * @typedef {Object} ConcatenatedModuleInfo
- * @property {number} index
- * @property {Module} module
- * @property {Map<string, string>} exportMap mapping from export name to symbol
- * @property {Map<string, string>} rawExportMap mapping from export name to symbol
- * @property {string=} namespaceExportSymbol
- */
-
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo} ModuleInfo */
-
-/**
- * @typedef {Object} ModuleReferenceOptions
- * @property {string[]} ids the properties/exports of the module
- * @property {boolean} call true, when this referenced export is called
- * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
- * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
- */
+	setManagedMissing(value) {
+		this._flags = this._flags | 0x800;
+		this.managedMissing = value;
+	}
 
-class ConcatenationScope {
-	/**
-	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
-	 * @param {ConcatenatedModuleInfo} currentModule the current module info
-	 */
-	constructor(modulesMap, currentModule) {
-		this._currentModule = currentModule;
-		if (Array.isArray(modulesMap)) {
-			const map = new Map();
-			for (const info of modulesMap) {
-				map.set(info.module, info);
-			}
-			modulesMap = map;
-		}
-		this._modulesMap = modulesMap;
+	hasChildren() {
+		return (this._flags & 0x1000) !== 0;
 	}
 
-	/**
-	 * @param {Module} module the referenced module
-	 * @returns {boolean} true, when it's in the scope
-	 */
-	isModuleInScope(module) {
-		return this._modulesMap.has(module);
+	setChildren(value) {
+		this._flags = this._flags | 0x1000;
+		this.children = value;
 	}
 
-	/**
-	 *
-	 * @param {string} exportName name of the export
-	 * @param {string} symbol identifier of the export in source code
-	 */
-	registerExport(exportName, symbol) {
-		if (!this._currentModule.exportMap) {
-			this._currentModule.exportMap = new Map();
-		}
-		if (!this._currentModule.exportMap.has(exportName)) {
-			this._currentModule.exportMap.set(exportName, symbol);
+	addChild(child) {
+		if (!this.hasChildren()) {
+			this.setChildren(new Set());
 		}
+		this.children.add(child);
 	}
 
-	/**
-	 *
-	 * @param {string} exportName name of the export
-	 * @param {string} expression expression to be used
-	 */
-	registerRawExport(exportName, expression) {
-		if (!this._currentModule.rawExportMap) {
-			this._currentModule.rawExportMap = new Map();
-		}
-		if (!this._currentModule.rawExportMap.has(exportName)) {
-			this._currentModule.rawExportMap.set(exportName, expression);
-		}
+	serialize({ write }) {
+		write(this._flags);
+		if (this.hasStartTime()) write(this.startTime);
+		if (this.hasFileTimestamps()) write(this.fileTimestamps);
+		if (this.hasFileHashes()) write(this.fileHashes);
+		if (this.hasFileTshs()) write(this.fileTshs);
+		if (this.hasContextTimestamps()) write(this.contextTimestamps);
+		if (this.hasContextHashes()) write(this.contextHashes);
+		if (this.hasContextTshs()) write(this.contextTshs);
+		if (this.hasMissingExistence()) write(this.missingExistence);
+		if (this.hasManagedItemInfo()) write(this.managedItemInfo);
+		if (this.hasManagedFiles()) write(this.managedFiles);
+		if (this.hasManagedContexts()) write(this.managedContexts);
+		if (this.hasManagedMissing()) write(this.managedMissing);
+		if (this.hasChildren()) write(this.children);
+	}
+
+	deserialize({ read }) {
+		this._flags = read();
+		if (this.hasStartTime()) this.startTime = read();
+		if (this.hasFileTimestamps()) this.fileTimestamps = read();
+		if (this.hasFileHashes()) this.fileHashes = read();
+		if (this.hasFileTshs()) this.fileTshs = read();
+		if (this.hasContextTimestamps()) this.contextTimestamps = read();
+		if (this.hasContextHashes()) this.contextHashes = read();
+		if (this.hasContextTshs()) this.contextTshs = read();
+		if (this.hasMissingExistence()) this.missingExistence = read();
+		if (this.hasManagedItemInfo()) this.managedItemInfo = read();
+		if (this.hasManagedFiles()) this.managedFiles = read();
+		if (this.hasManagedContexts()) this.managedContexts = read();
+		if (this.hasManagedMissing()) this.managedMissing = read();
+		if (this.hasChildren()) this.children = read();
 	}
 
 	/**
-	 * @param {string} symbol identifier of the export in source code
+	 * @param {function(Snapshot): (ReadonlyMap<string, any> | ReadonlySet<string>)[]} getMaps first
+	 * @returns {Iterable<string>} iterable
 	 */
-	registerNamespaceExport(symbol) {
-		this._currentModule.namespaceExportSymbol = symbol;
+	_createIterable(getMaps) {
+		return new SnapshotIterable(this, getMaps);
 	}
 
 	/**
-	 *
-	 * @param {Module} module the referenced module
-	 * @param {Partial<ModuleReferenceOptions>} options options
-	 * @returns {string} the reference as identifier
+	 * @returns {Iterable<string>} iterable
 	 */
-	createModuleReference(
-		module,
-		{ ids = undefined, call = false, directImport = false, asiSafe = false }
-	) {
-		const info = this._modulesMap.get(module);
-		const callFlag = call ? "_call" : "";
-		const directImportFlag = directImport ? "_directImport" : "";
-		const asiSafeFlag = asiSafe
-			? "_asiSafe1"
-			: asiSafe === false
-			? "_asiSafe0"
-			: "";
-		const exportData = ids
-			? Buffer.from(JSON.stringify(ids), "utf-8").toString("hex")
-			: "ns";
-		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
-		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${asiSafeFlag}__._`;
+	getFileIterable() {
+		return this._createIterable(s => [
+			s.fileTimestamps,
+			s.fileHashes,
+			s.fileTshs,
+			s.managedFiles
+		]);
 	}
 
 	/**
-	 * @param {string} name the identifier
-	 * @returns {boolean} true, when it's an module reference
+	 * @returns {Iterable<string>} iterable
 	 */
-	static isModuleReference(name) {
-		return MODULE_REFERENCE_REGEXP.test(name);
+	getContextIterable() {
+		return this._createIterable(s => [
+			s.contextTimestamps,
+			s.contextHashes,
+			s.contextTshs,
+			s.managedContexts
+		]);
 	}
 
 	/**
-	 * @param {string} name the identifier
-	 * @returns {ModuleReferenceOptions & { index: number }} parsed options and index
+	 * @returns {Iterable<string>} iterable
 	 */
-	static matchModuleReference(name) {
-		const match = MODULE_REFERENCE_REGEXP.exec(name);
-		if (!match) return null;
-		const index = +match[1];
-		const asiSafe = match[5];
-		return {
-			index,
-			ids:
-				match[2] === "ns"
-					? []
-					: JSON.parse(Buffer.from(match[2], "hex").toString("utf-8")),
-			call: !!match[3],
-			directImport: !!match[4],
-			asiSafe: asiSafe ? asiSafe === "1" : undefined
-		};
+	getMissingIterable() {
+		return this._createIterable(s => [s.missingExistence, s.managedMissing]);
 	}
 }
 
-ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
-ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
-
-module.exports = ConcatenationScope;
-
-
-/***/ }),
-
-/***/ 95735:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Maksim Nazarjev @acupofspirt
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-
-module.exports = class ConcurrentCompilationError extends WebpackError {
-	constructor() {
-		super();
-
-		this.name = "ConcurrentCompilationError";
-		this.message =
-			"You ran Webpack twice. Each instance only supports a single concurrent compilation at a time.";
-	}
-};
-
-
-/***/ }),
-
-/***/ 61333:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { ConcatSource, PrefixSource } = __webpack_require__(51255);
-const InitFragment = __webpack_require__(55870);
-const Template = __webpack_require__(39722);
-const { mergeRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot");
 
-const wrapInCondition = (condition, source) => {
-	if (typeof source === "string") {
-		return Template.asString([
-			`if (${condition}) {`,
-			Template.indent(source),
-			"}",
-			""
-		]);
-	} else {
-		return new ConcatSource(
-			`if (${condition}) {\n`,
-			new PrefixSource("\t", source),
-			"}\n"
-		);
-	}
-};
+const MIN_COMMON_SNAPSHOT_SIZE = 3;
 
 /**
- * @typedef {GenerateContext} Context
+ * @template T
  */
-class ConditionalInitFragment extends InitFragment {
-	/**
-	 * @param {string|Source} content the source code that will be included as initialization code
-	 * @param {number} stage category of initialization code (contribute to order)
-	 * @param {number} position position in the category (contribute to order)
-	 * @param {string} key unique key to avoid emitting the same initialization code twice
-	 * @param {RuntimeSpec | boolean} runtimeCondition in which runtime this fragment should be executed
-	 * @param {string|Source=} endContent the source code that will be included at the end of the module
-	 */
-	constructor(
-		content,
-		stage,
-		position,
-		key,
-		runtimeCondition = true,
-		endContent
-	) {
-		super(content, stage, position, key, endContent);
-		this.runtimeCondition = runtimeCondition;
-	}
-
+class SnapshotOptimization {
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {function(Snapshot): boolean} has has value
+	 * @param {function(Snapshot): Map<string, T> | Set<string>} get get value
+	 * @param {function(Snapshot, Map<string, T> | Set<string>): void} set set value
+	 * @param {boolean=} useStartTime use the start time of snapshots
+	 * @param {boolean=} isSet value is an Set instead of a Map
 	 */
-	getContent(context) {
-		if (this.runtimeCondition === false || !this.content) return "";
-		if (this.runtimeCondition === true) return this.content;
-		const expr = context.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: context.chunkGraph,
-			runtimeRequirements: context.runtimeRequirements,
-			runtime: context.runtime,
-			runtimeCondition: this.runtimeCondition
-		});
-		if (expr === "true") return this.content;
-		return wrapInCondition(expr, this.content);
+	constructor(has, get, set, useStartTime = true, isSet = false) {
+		this._has = has;
+		this._get = get;
+		this._set = set;
+		this._useStartTime = useStartTime;
+		this._isSet = isSet;
+		/** @type {Map<string, SnapshotOptimizationEntry>} */
+		this._map = new Map();
+		this._statItemsShared = 0;
+		this._statItemsUnshared = 0;
+		this._statSharedSnapshots = 0;
+		this._statReusedSharedSnapshots = 0;
 	}
 
-	/**
-	 * @param {Context} context context
-	 * @returns {string|Source=} the source code that will be included at the end of the module
-	 */
-	getEndContent(context) {
-		if (this.runtimeCondition === false || !this.endContent) return "";
-		if (this.runtimeCondition === true) return this.endContent;
-		const expr = context.runtimeTemplate.runtimeConditionExpression({
-			chunkGraph: context.chunkGraph,
-			runtimeRequirements: context.runtimeRequirements,
-			runtime: context.runtime,
-			runtimeCondition: this.runtimeCondition
-		});
-		if (expr === "true") return this.endContent;
-		return wrapInCondition(expr, this.endContent);
+	getStatisticMessage() {
+		const total = this._statItemsShared + this._statItemsUnshared;
+		if (total === 0) return undefined;
+		return `${
+			this._statItemsShared && Math.round((this._statItemsShared * 100) / total)
+		}% (${this._statItemsShared}/${total}) entries shared via ${
+			this._statSharedSnapshots
+		} shared snapshots (${
+			this._statReusedSharedSnapshots + this._statSharedSnapshots
+		} times referenced)`;
 	}
 
-	merge(other) {
-		if (this.runtimeCondition === true) return this;
-		if (other.runtimeCondition === true) return other;
-		if (this.runtimeCondition === false) return other;
-		if (other.runtimeCondition === false) return this;
-		const runtimeCondition = mergeRuntime(
-			this.runtimeCondition,
-			other.runtimeCondition
-		);
-		return new ConditionalInitFragment(
-			this.content,
-			this.stage,
-			this.position,
-			this.key,
-			runtimeCondition,
-			this.endContent
-		);
+	clear() {
+		this._map.clear();
+		this._statItemsShared = 0;
+		this._statItemsUnshared = 0;
+		this._statSharedSnapshots = 0;
+		this._statReusedSharedSnapshots = 0;
 	}
-}
-
-module.exports = ConditionalInitFragment;
-
-
-/***/ }),
-
-/***/ 11146:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {Snapshot} newSnapshot snapshot
+	 * @param {Set<string>} capturedFiles files to snapshot/share
+	 * @returns {void}
+	 */
+	optimize(newSnapshot, capturedFiles) {
+		/**
+		 * @param {SnapshotOptimizationEntry} entry optimization entry
+		 * @returns {void}
+		 */
+		const increaseSharedAndStoreOptimizationEntry = entry => {
+			if (entry.children !== undefined) {
+				entry.children.forEach(increaseSharedAndStoreOptimizationEntry);
+			}
+			entry.shared++;
+			storeOptimizationEntry(entry);
+		};
+		/**
+		 * @param {SnapshotOptimizationEntry} entry optimization entry
+		 * @returns {void}
+		 */
+		const storeOptimizationEntry = entry => {
+			for (const path of entry.snapshotContent) {
+				const old = this._map.get(path);
+				if (old.shared < entry.shared) {
+					this._map.set(path, entry);
+				}
+				capturedFiles.delete(path);
+			}
+		};
 
+		/** @type {SnapshotOptimizationEntry} */
+		let newOptimizationEntry = undefined;
 
+		const capturedFilesSize = capturedFiles.size;
 
-const CachedConstDependency = __webpack_require__(57403);
-const ConstDependency = __webpack_require__(76911);
-const { evaluateToString } = __webpack_require__(93998);
-const { parseResource } = __webpack_require__(82186);
+		/** @type {Set<SnapshotOptimizationEntry> | undefined} */
+		const optimizationEntries = new Set();
 
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Super} SuperNode */
-/** @typedef {import("./Compiler")} Compiler */
+		for (const path of capturedFiles) {
+			const optimizationEntry = this._map.get(path);
+			if (optimizationEntry === undefined) {
+				if (newOptimizationEntry === undefined) {
+					newOptimizationEntry = {
+						snapshot: newSnapshot,
+						shared: 0,
+						snapshotContent: undefined,
+						children: undefined
+					};
+				}
+				this._map.set(path, newOptimizationEntry);
+				continue;
+			} else {
+				optimizationEntries.add(optimizationEntry);
+			}
+		}
 
-const collectDeclaration = (declarations, pattern) => {
-	const stack = [pattern];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		switch (node.type) {
-			case "Identifier":
-				declarations.add(node.name);
-				break;
-			case "ArrayPattern":
-				for (const element of node.elements) {
-					if (element) {
-						stack.push(element);
+		optimizationEntries: for (const optimizationEntry of optimizationEntries) {
+			const snapshot = optimizationEntry.snapshot;
+			if (optimizationEntry.shared > 0) {
+				// It's a shared snapshot
+				// We can't change it, so we can only use it when all files match
+				// and startTime is compatible
+				if (
+					this._useStartTime &&
+					newSnapshot.startTime &&
+					(!snapshot.startTime || snapshot.startTime > newSnapshot.startTime)
+				) {
+					continue;
+				}
+				const nonSharedFiles = new Set();
+				const snapshotContent = optimizationEntry.snapshotContent;
+				const snapshotEntries = this._get(snapshot);
+				for (const path of snapshotContent) {
+					if (!capturedFiles.has(path)) {
+						if (!snapshotEntries.has(path)) {
+							// File is not shared and can't be removed from the snapshot
+							// because it's in a child of the snapshot
+							continue optimizationEntries;
+						}
+						nonSharedFiles.add(path);
+						continue;
 					}
 				}
-				break;
-			case "AssignmentPattern":
-				stack.push(node.left);
-				break;
-			case "ObjectPattern":
-				for (const property of node.properties) {
-					stack.push(property.value);
+				if (nonSharedFiles.size === 0) {
+					// The complete snapshot is shared
+					// add it as child
+					newSnapshot.addChild(snapshot);
+					increaseSharedAndStoreOptimizationEntry(optimizationEntry);
+					this._statReusedSharedSnapshots++;
+				} else {
+					// Only a part of the snapshot is shared
+					const sharedCount = snapshotContent.size - nonSharedFiles.size;
+					if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {
+						// Common part it too small
+						continue optimizationEntries;
+					}
+					// Extract common timestamps from both snapshots
+					let commonMap;
+					if (this._isSet) {
+						commonMap = new Set();
+						for (const path of /** @type {Set<string>} */ (snapshotEntries)) {
+							if (nonSharedFiles.has(path)) continue;
+							commonMap.add(path);
+							snapshotEntries.delete(path);
+						}
+					} else {
+						commonMap = new Map();
+						const map = /** @type {Map<string, T>} */ (snapshotEntries);
+						for (const [path, value] of map) {
+							if (nonSharedFiles.has(path)) continue;
+							commonMap.set(path, value);
+							snapshotEntries.delete(path);
+						}
+					}
+					// Create and attach snapshot
+					const commonSnapshot = new Snapshot();
+					if (this._useStartTime) {
+						commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
+					}
+					this._set(commonSnapshot, commonMap);
+					newSnapshot.addChild(commonSnapshot);
+					snapshot.addChild(commonSnapshot);
+					// Create optimization entry
+					const newEntry = {
+						snapshot: commonSnapshot,
+						shared: optimizationEntry.shared + 1,
+						snapshotContent: new Set(commonMap.keys()),
+						children: undefined
+					};
+					if (optimizationEntry.children === undefined)
+						optimizationEntry.children = new Set();
+					optimizationEntry.children.add(newEntry);
+					storeOptimizationEntry(newEntry);
+					this._statSharedSnapshots++;
 				}
-				break;
-			case "RestElement":
-				stack.push(node.argument);
-				break;
+			} else {
+				// It's a unshared snapshot
+				// We can extract a common shared snapshot
+				// with all common files
+				const snapshotEntries = this._get(snapshot);
+				if (snapshotEntries === undefined) {
+					// Incomplete snapshot, that can't be used
+					continue optimizationEntries;
+				}
+				let commonMap;
+				if (this._isSet) {
+					commonMap = new Set();
+					const set = /** @type {Set<string>} */ (snapshotEntries);
+					if (capturedFiles.size < set.size) {
+						for (const path of capturedFiles) {
+							if (set.has(path)) commonMap.add(path);
+						}
+					} else {
+						for (const path of set) {
+							if (capturedFiles.has(path)) commonMap.add(path);
+						}
+					}
+				} else {
+					commonMap = new Map();
+					const map = /** @type {Map<string, T>} */ (snapshotEntries);
+					for (const path of capturedFiles) {
+						const ts = map.get(path);
+						if (ts === undefined) continue;
+						commonMap.set(path, ts);
+					}
+				}
+
+				if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {
+					// Common part it too small
+					continue optimizationEntries;
+				}
+				// Create and attach snapshot
+				const commonSnapshot = new Snapshot();
+				if (this._useStartTime) {
+					commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
+				}
+				this._set(commonSnapshot, commonMap);
+				newSnapshot.addChild(commonSnapshot);
+				snapshot.addChild(commonSnapshot);
+				// Remove files from snapshot
+				for (const path of commonMap.keys()) snapshotEntries.delete(path);
+				const sharedCount = commonMap.size;
+				this._statItemsUnshared -= sharedCount;
+				this._statItemsShared += sharedCount;
+				// Create optimization entry
+				storeOptimizationEntry({
+					snapshot: commonSnapshot,
+					shared: 2,
+					snapshotContent: new Set(commonMap.keys()),
+					children: undefined
+				});
+				this._statSharedSnapshots++;
+			}
 		}
+		const unshared = capturedFiles.size;
+		this._statItemsUnshared += unshared;
+		this._statItemsShared += capturedFilesSize - unshared;
 	}
+}
+
+const parseString = str => {
+	if (str[0] === "'") str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
+	return JSON.parse(str);
 };
 
-const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
-	const declarations = new Set();
-	const stack = [branch];
-	while (stack.length > 0) {
-		const node = stack.pop();
-		// Some node could be `null` or `undefined`.
-		if (!node) continue;
-		switch (node.type) {
-			// Walk through control statements to look for hoisted declarations.
-			// Some branches are skipped since they do not allow declarations.
-			case "BlockStatement":
-				for (const stmt of node.body) {
-					stack.push(stmt);
-				}
-				break;
-			case "IfStatement":
-				stack.push(node.consequent);
-				stack.push(node.alternate);
-				break;
-			case "ForStatement":
-				stack.push(node.init);
-				stack.push(node.body);
-				break;
-			case "ForInStatement":
-			case "ForOfStatement":
-				stack.push(node.left);
-				stack.push(node.body);
-				break;
-			case "DoWhileStatement":
-			case "WhileStatement":
-			case "LabeledStatement":
-				stack.push(node.body);
-				break;
-			case "SwitchStatement":
-				for (const cs of node.cases) {
-					for (const consequent of cs.consequent) {
-						stack.push(consequent);
-					}
-				}
+/* istanbul ignore next */
+/**
+ * @param {number} mtime mtime
+ */
+const applyMtime = mtime => {
+	if (FS_ACCURACY > 1 && mtime % 2 !== 0) FS_ACCURACY = 1;
+	else if (FS_ACCURACY > 10 && mtime % 20 !== 0) FS_ACCURACY = 10;
+	else if (FS_ACCURACY > 100 && mtime % 200 !== 0) FS_ACCURACY = 100;
+	else if (FS_ACCURACY > 1000 && mtime % 2000 !== 0) FS_ACCURACY = 1000;
+};
+
+/**
+ * @template T
+ * @template K
+ * @param {Map<T, K>} a source map
+ * @param {Map<T, K>} b joining map
+ * @returns {Map<T, K>} joined map
+ */
+const mergeMaps = (a, b) => {
+	if (!b || b.size === 0) return a;
+	if (!a || a.size === 0) return b;
+	const map = new Map(a);
+	for (const [key, value] of b) {
+		map.set(key, value);
+	}
+	return map;
+};
+
+/**
+ * @template T
+ * @template K
+ * @param {Set<T, K>} a source map
+ * @param {Set<T, K>} b joining map
+ * @returns {Set<T, K>} joined map
+ */
+const mergeSets = (a, b) => {
+	if (!b || b.size === 0) return a;
+	if (!a || a.size === 0) return b;
+	const map = new Set(a);
+	for (const item of b) {
+		map.add(item);
+	}
+	return map;
+};
+
+/**
+ * Finding file or directory to manage
+ * @param {string} managedPath path that is managing by {@link FileSystemInfo}
+ * @param {string} path path to file or directory
+ * @returns {string|null} managed item
+ * @example
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/package/index.js'
+ * ) === '/Users/user/my-project/node_modules/package'
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/package1/node_modules/package2'
+ * ) === '/Users/user/my-project/node_modules/package1/node_modules/package2'
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/.bin/script.js'
+ * ) === null // hidden files are disallowed as managed items
+ * getManagedItem(
+ *   '/Users/user/my-project/node_modules/',
+ *   '/Users/user/my-project/node_modules/package'
+ * ) === '/Users/user/my-project/node_modules/package'
+ */
+const getManagedItem = (managedPath, path) => {
+	let i = managedPath.length;
+	let slashes = 1;
+	let startingPosition = true;
+	loop: while (i < path.length) {
+		switch (path.charCodeAt(i)) {
+			case 47: // slash
+			case 92: // backslash
+				if (--slashes === 0) break loop;
+				startingPosition = true;
 				break;
-			case "TryStatement":
-				stack.push(node.block);
-				if (node.handler) {
-					stack.push(node.handler.body);
-				}
-				stack.push(node.finalizer);
+			case 46: // .
+				// hidden files are disallowed as managed items
+				// it's probably .yarn-integrity or .cache
+				if (startingPosition) return null;
 				break;
-			case "FunctionDeclaration":
-				if (includeFunctionDeclarations) {
-					collectDeclaration(declarations, node.id);
-				}
+			case 64: // @
+				if (!startingPosition) return null;
+				slashes++;
 				break;
-			case "VariableDeclaration":
-				if (node.kind === "var") {
-					for (const decl of node.declarations) {
-						collectDeclaration(declarations, decl.id);
-					}
-				}
+			default:
+				startingPosition = false;
 				break;
 		}
+		i++;
 	}
-	return Array.from(declarations);
+	if (i === path.length) slashes--;
+	// return null when path is incomplete
+	if (slashes !== 0) return null;
+	// if (path.slice(i + 1, i + 13) === "node_modules")
+	if (
+		path.length >= i + 13 &&
+		path.charCodeAt(i + 1) === 110 &&
+		path.charCodeAt(i + 2) === 111 &&
+		path.charCodeAt(i + 3) === 100 &&
+		path.charCodeAt(i + 4) === 101 &&
+		path.charCodeAt(i + 5) === 95 &&
+		path.charCodeAt(i + 6) === 109 &&
+		path.charCodeAt(i + 7) === 111 &&
+		path.charCodeAt(i + 8) === 100 &&
+		path.charCodeAt(i + 9) === 117 &&
+		path.charCodeAt(i + 10) === 108 &&
+		path.charCodeAt(i + 11) === 101 &&
+		path.charCodeAt(i + 12) === 115
+	) {
+		// if this is the end of the path
+		if (path.length === i + 13) {
+			// return the node_modules directory
+			// it's special
+			return path;
+		}
+		const c = path.charCodeAt(i + 13);
+		// if next symbol is slash or backslash
+		if (c === 47 || c === 92) {
+			// Managed subpath
+			return getManagedItem(path.slice(0, i + 14), path);
+		}
+	}
+	return path.slice(0, i);
 };
 
-class ConstPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const cachedParseResource = parseResource.bindCache(compiler.root);
-		compiler.hooks.compilation.tap(
-			"ConstPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
+/**
+ * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
+ * @param {T} entry entry
+ * @returns {T["resolved"] | undefined} the resolved entry
+ */
+const getResolvedTimestamp = entry => {
+	if (entry === null) return null;
+	if (entry.resolved !== undefined) return entry.resolved;
+	return entry.symlinks === undefined ? entry : undefined;
+};
 
-				compilation.dependencyTemplates.set(
-					CachedConstDependency,
-					new CachedConstDependency.Template()
-				);
+/**
+ * @param {ContextHash} entry entry
+ * @returns {string | undefined} the resolved entry
+ */
+const getResolvedHash = entry => {
+	if (entry === null) return null;
+	if (entry.resolved !== undefined) return entry.resolved;
+	return entry.symlinks === undefined ? entry.hash : undefined;
+};
 
-				const handler = parser => {
-					parser.hooks.statementIf.tap("ConstPlugin", statement => {
-						if (parser.scope.isAsmJs) return;
-						const param = parser.evaluateExpression(statement.test);
-						const bool = param.asBool();
-						if (typeof bool === "boolean") {
-							if (!param.couldHaveSideEffects()) {
-								const dep = new ConstDependency(`${bool}`, param.range);
-								dep.loc = statement.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							} else {
-								parser.walkExpression(statement.test);
-							}
-							const branchToRemove = bool
-								? statement.alternate
-								: statement.consequent;
-							if (branchToRemove) {
-								// Before removing the dead branch, the hoisted declarations
-								// must be collected.
-								//
-								// Given the following code:
-								//
-								//     if (true) f() else g()
-								//     if (false) {
-								//       function f() {}
-								//       const g = function g() {}
-								//       if (someTest) {
-								//         let a = 1
-								//         var x, {y, z} = obj
-								//       }
-								//     } else {
-								//       …
-								//     }
-								//
-								// the generated code is:
-								//
-								//     if (true) f() else {}
-								//     if (false) {
-								//       var f, x, y, z;   (in loose mode)
-								//       var x, y, z;      (in strict mode)
-								//     } else {
-								//       …
-								//     }
-								//
-								// NOTE: When code runs in strict mode, `var` declarations
-								// are hoisted but `function` declarations don't.
-								//
-								let declarations;
-								if (parser.scope.isStrict) {
-									// If the code runs in strict mode, variable declarations
-									// using `var` must be hoisted.
-									declarations = getHoistedDeclarations(branchToRemove, false);
-								} else {
-									// Otherwise, collect all hoisted declaration.
-									declarations = getHoistedDeclarations(branchToRemove, true);
-								}
-								let replacement;
-								if (declarations.length > 0) {
-									replacement = `{ var ${declarations.join(", ")}; }`;
-								} else {
-									replacement = "{}";
-								}
-								const dep = new ConstDependency(
-									replacement,
-									branchToRemove.range
-								);
-								dep.loc = branchToRemove.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
-							return bool;
-						}
-					});
-					parser.hooks.expressionConditionalOperator.tap(
-						"ConstPlugin",
-						expression => {
-							if (parser.scope.isAsmJs) return;
-							const param = parser.evaluateExpression(expression.test);
-							const bool = param.asBool();
-							if (typeof bool === "boolean") {
-								if (!param.couldHaveSideEffects()) {
-									const dep = new ConstDependency(` ${bool}`, param.range);
-									dep.loc = expression.loc;
-									parser.state.module.addPresentationalDependency(dep);
-								} else {
-									parser.walkExpression(expression.test);
-								}
-								// Expressions do not hoist.
-								// It is safe to remove the dead branch.
-								//
-								// Given the following code:
-								//
-								//   false ? someExpression() : otherExpression();
-								//
-								// the generated code is:
-								//
-								//   false ? 0 : otherExpression();
-								//
-								const branchToRemove = bool
-									? expression.alternate
-									: expression.consequent;
-								const dep = new ConstDependency("0", branchToRemove.range);
-								dep.loc = branchToRemove.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								return bool;
-							}
-						}
-					);
-					parser.hooks.expressionLogicalOperator.tap(
-						"ConstPlugin",
-						expression => {
-							if (parser.scope.isAsmJs) return;
-							if (
-								expression.operator === "&&" ||
-								expression.operator === "||"
-							) {
-								const param = parser.evaluateExpression(expression.left);
-								const bool = param.asBool();
-								if (typeof bool === "boolean") {
-									// Expressions do not hoist.
-									// It is safe to remove the dead branch.
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   falsyExpression() && false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   true && someExpression();
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   truthyExpression() || false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   false && someExpression();
-									//
-									const keepRight =
-										(expression.operator === "&&" && bool) ||
-										(expression.operator === "||" && !bool);
-
-									if (
-										!param.couldHaveSideEffects() &&
-										(param.isBoolean() || keepRight)
-									) {
-										// for case like
-										//
-										//   return'development'===process.env.NODE_ENV&&'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnfalse&&'foo'
-										//
-										const dep = new ConstDependency(` ${bool}`, param.range);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-									} else {
-										parser.walkExpression(expression.left);
-									}
-									if (!keepRight) {
-										const dep = new ConstDependency(
-											"0",
-											expression.right.range
-										);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-									}
-									return keepRight;
-								}
-							} else if (expression.operator === "??") {
-								const param = parser.evaluateExpression(expression.left);
-								const keepRight = param && param.asNullish();
-								if (typeof keepRight === "boolean") {
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nonNullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   nonNullish ?? 0;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   null ?? someExpression();
-									//
-									if (!param.couldHaveSideEffects() && keepRight) {
-										// cspell:word returnnull
-										// for case like
-										//
-										//   return('development'===process.env.NODE_ENV&&null)??'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnnull??'foo'
-										//
-										const dep = new ConstDependency(" null", param.range);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-									} else {
-										const dep = new ConstDependency(
-											"0",
-											expression.right.range
-										);
-										dep.loc = expression.loc;
-										parser.state.module.addPresentationalDependency(dep);
-										parser.walkExpression(expression.left);
-									}
+const addAll = (source, target) => {
+	for (const key of source) target.add(key);
+};
 
-									return keepRight;
-								}
-							}
-						}
-					);
-					parser.hooks.optionalChaining.tap("ConstPlugin", expr => {
-						/** @type {ExpressionNode[]} */
-						const optionalExpressionsStack = [];
-						/** @type {ExpressionNode|SuperNode} */
-						let next = expr.expression;
+/**
+ * Used to access information about the filesystem in a cached way
+ */
+class FileSystemInfo {
+	/**
+	 * @param {InputFileSystem} fs file system
+	 * @param {Object} options options
+	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
+	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
+	 * @param {Logger=} options.logger logger used to log invalid snapshots
+	 * @param {string | Hash=} options.hashFunction the hash function to use
+	 */
+	constructor(
+		fs,
+		{
+			managedPaths = [],
+			immutablePaths = [],
+			logger,
+			hashFunction = "md4"
+		} = {}
+	) {
+		this.fs = fs;
+		this.logger = logger;
+		this._remainingLogs = logger ? 40 : 0;
+		this._loggedPaths = logger ? new Set() : undefined;
+		this._hashFunction = hashFunction;
+		/** @type {WeakMap<Snapshot, boolean | (function(WebpackError=, boolean=): void)[]>} */
+		this._snapshotCache = new WeakMap();
+		this._fileTimestampsOptimization = new SnapshotOptimization(
+			s => s.hasFileTimestamps(),
+			s => s.fileTimestamps,
+			(s, v) => s.setFileTimestamps(v)
+		);
+		this._fileHashesOptimization = new SnapshotOptimization(
+			s => s.hasFileHashes(),
+			s => s.fileHashes,
+			(s, v) => s.setFileHashes(v),
+			false
+		);
+		this._fileTshsOptimization = new SnapshotOptimization(
+			s => s.hasFileTshs(),
+			s => s.fileTshs,
+			(s, v) => s.setFileTshs(v)
+		);
+		this._contextTimestampsOptimization = new SnapshotOptimization(
+			s => s.hasContextTimestamps(),
+			s => s.contextTimestamps,
+			(s, v) => s.setContextTimestamps(v)
+		);
+		this._contextHashesOptimization = new SnapshotOptimization(
+			s => s.hasContextHashes(),
+			s => s.contextHashes,
+			(s, v) => s.setContextHashes(v),
+			false
+		);
+		this._contextTshsOptimization = new SnapshotOptimization(
+			s => s.hasContextTshs(),
+			s => s.contextTshs,
+			(s, v) => s.setContextTshs(v)
+		);
+		this._missingExistenceOptimization = new SnapshotOptimization(
+			s => s.hasMissingExistence(),
+			s => s.missingExistence,
+			(s, v) => s.setMissingExistence(v),
+			false
+		);
+		this._managedItemInfoOptimization = new SnapshotOptimization(
+			s => s.hasManagedItemInfo(),
+			s => s.managedItemInfo,
+			(s, v) => s.setManagedItemInfo(v),
+			false
+		);
+		this._managedFilesOptimization = new SnapshotOptimization(
+			s => s.hasManagedFiles(),
+			s => s.managedFiles,
+			(s, v) => s.setManagedFiles(v),
+			false,
+			true
+		);
+		this._managedContextsOptimization = new SnapshotOptimization(
+			s => s.hasManagedContexts(),
+			s => s.managedContexts,
+			(s, v) => s.setManagedContexts(v),
+			false,
+			true
+		);
+		this._managedMissingOptimization = new SnapshotOptimization(
+			s => s.hasManagedMissing(),
+			s => s.managedMissing,
+			(s, v) => s.setManagedMissing(v),
+			false,
+			true
+		);
+		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		this._fileTimestamps = new StackedCacheMap();
+		/** @type {Map<string, string>} */
+		this._fileHashes = new Map();
+		/** @type {Map<string, TimestampAndHash | string>} */
+		this._fileTshs = new Map();
+		/** @type {StackedCacheMap<string, ContextFileSystemInfoEntry | "ignore" | null>} */
+		this._contextTimestamps = new StackedCacheMap();
+		/** @type {Map<string, ContextHash>} */
+		this._contextHashes = new Map();
+		/** @type {Map<string, ContextTimestampAndHash>} */
+		this._contextTshs = new Map();
+		/** @type {Map<string, string>} */
+		this._managedItems = new Map();
+		/** @type {AsyncQueue<string, string, FileSystemInfoEntry | null>} */
+		this.fileTimestampQueue = new AsyncQueue({
+			name: "file timestamp",
+			parallelism: 30,
+			processor: this._readFileTimestamp.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, string | null>} */
+		this.fileHashQueue = new AsyncQueue({
+			name: "file hash",
+			parallelism: 10,
+			processor: this._readFileHash.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry | null>} */
+		this.contextTimestampQueue = new AsyncQueue({
+			name: "context timestamp",
+			parallelism: 2,
+			processor: this._readContextTimestamp.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, ContextHash | null>} */
+		this.contextHashQueue = new AsyncQueue({
+			name: "context hash",
+			parallelism: 2,
+			processor: this._readContextHash.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, ContextTimestampAndHash | null>} */
+		this.contextTshQueue = new AsyncQueue({
+			name: "context hash and timestamp",
+			parallelism: 2,
+			processor: this._readContextTimestampAndHash.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, string | null>} */
+		this.managedItemQueue = new AsyncQueue({
+			name: "managed item info",
+			parallelism: 10,
+			processor: this._getManagedItemInfo.bind(this)
+		});
+		/** @type {AsyncQueue<string, string, Set<string>>} */
+		this.managedItemDirectoryQueue = new AsyncQueue({
+			name: "managed item directory info",
+			parallelism: 10,
+			processor: this._getManagedItemDirectoryInfo.bind(this)
+		});
+		this.managedPaths = Array.from(managedPaths);
+		this.managedPathsWithSlash = /** @type {string[]} */ (
+			this.managedPaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
 
-						while (
-							next.type === "MemberExpression" ||
-							next.type === "CallExpression"
-						) {
-							if (next.type === "MemberExpression") {
-								if (next.optional) {
-									// SuperNode can not be optional
-									optionalExpressionsStack.push(
-										/** @type {ExpressionNode} */ (next.object)
-									);
-								}
-								next = next.object;
-							} else {
-								if (next.optional) {
-									// SuperNode can not be optional
-									optionalExpressionsStack.push(
-										/** @type {ExpressionNode} */ (next.callee)
-									);
-								}
-								next = next.callee;
-							}
-						}
+		this.managedPathsRegExps = /** @type {RegExp[]} */ (
+			this.managedPaths.filter(p => typeof p !== "string")
+		);
+		this.immutablePaths = Array.from(immutablePaths);
+		this.immutablePathsWithSlash = /** @type {string[]} */ (
+			this.immutablePaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
+			this.immutablePaths.filter(p => typeof p !== "string")
+		);
 
-						while (optionalExpressionsStack.length) {
-							const expression = optionalExpressionsStack.pop();
-							const evaluated = parser.evaluateExpression(expression);
+		this._cachedDeprecatedFileTimestamps = undefined;
+		this._cachedDeprecatedContextTimestamps = undefined;
 
-							if (evaluated && evaluated.asNullish()) {
-								// ------------------------------------------
-								//
-								// Given the following code:
-								//
-								//   nullishMemberChain?.a.b();
-								//
-								// the generated code is:
-								//
-								//   undefined;
-								//
-								// ------------------------------------------
-								//
-								const dep = new ConstDependency(" undefined", expr.range);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								return true;
-							}
-						}
-					});
-					parser.hooks.evaluateIdentifier
-						.for("__resourceQuery")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							return evaluateToString(
-								cachedParseResource(parser.state.module.resource).query
-							)(expr);
-						});
-					parser.hooks.expression
-						.for("__resourceQuery")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							const dep = new CachedConstDependency(
-								JSON.stringify(
-									cachedParseResource(parser.state.module.resource).query
-								),
-								expr.range,
-								"__resourceQuery"
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
+		this._warnAboutExperimentalEsmTracking = false;
 
-					parser.hooks.evaluateIdentifier
-						.for("__resourceFragment")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							return evaluateToString(
-								cachedParseResource(parser.state.module.resource).fragment
-							)(expr);
-						});
-					parser.hooks.expression
-						.for("__resourceFragment")
-						.tap("ConstPlugin", expr => {
-							if (parser.scope.isAsmJs) return;
-							if (!parser.state.module) return;
-							const dep = new CachedConstDependency(
-								JSON.stringify(
-									cachedParseResource(parser.state.module.resource).fragment
-								),
-								expr.range,
-								"__resourceFragment"
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-				};
+		this._statCreatedSnapshots = 0;
+		this._statTestedSnapshotsCached = 0;
+		this._statTestedSnapshotsNotCached = 0;
+		this._statTestedChildrenCached = 0;
+		this._statTestedChildrenNotCached = 0;
+		this._statTestedEntries = 0;
+	}
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ConstPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ConstPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ConstPlugin", handler);
+	logStatistics() {
+		const logWhenMessage = (header, message) => {
+			if (message) {
+				this.logger.log(`${header}: ${message}`);
 			}
+		};
+		this.logger.log(`${this._statCreatedSnapshots} new snapshots created`);
+		this.logger.log(
+			`${
+				this._statTestedSnapshotsNotCached &&
+				Math.round(
+					(this._statTestedSnapshotsNotCached * 100) /
+						(this._statTestedSnapshotsCached +
+							this._statTestedSnapshotsNotCached)
+				)
+			}% root snapshot uncached (${this._statTestedSnapshotsNotCached} / ${
+				this._statTestedSnapshotsCached + this._statTestedSnapshotsNotCached
+			})`
+		);
+		this.logger.log(
+			`${
+				this._statTestedChildrenNotCached &&
+				Math.round(
+					(this._statTestedChildrenNotCached * 100) /
+						(this._statTestedChildrenCached + this._statTestedChildrenNotCached)
+				)
+			}% children snapshot uncached (${this._statTestedChildrenNotCached} / ${
+				this._statTestedChildrenCached + this._statTestedChildrenNotCached
+			})`
+		);
+		this.logger.log(`${this._statTestedEntries} entries tested`);
+		this.logger.log(
+			`File info in cache: ${this._fileTimestamps.size} timestamps ${this._fileHashes.size} hashes ${this._fileTshs.size} timestamp hash combinations`
+		);
+		logWhenMessage(
+			`File timestamp snapshot optimization`,
+			this._fileTimestampsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`File hash snapshot optimization`,
+			this._fileHashesOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`File timestamp hash combination snapshot optimization`,
+			this._fileTshsOptimization.getStatisticMessage()
+		);
+		this.logger.log(
+			`Directory info in cache: ${this._contextTimestamps.size} timestamps ${this._contextHashes.size} hashes ${this._contextTshs.size} timestamp hash combinations`
+		);
+		logWhenMessage(
+			`Directory timestamp snapshot optimization`,
+			this._contextTimestampsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Directory hash snapshot optimization`,
+			this._contextHashesOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Directory timestamp hash combination snapshot optimization`,
+			this._contextTshsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Missing items snapshot optimization`,
+			this._missingExistenceOptimization.getStatisticMessage()
+		);
+		this.logger.log(
+			`Managed items info in cache: ${this._managedItems.size} items`
+		);
+		logWhenMessage(
+			`Managed items snapshot optimization`,
+			this._managedItemInfoOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Managed files snapshot optimization`,
+			this._managedFilesOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Managed contexts snapshot optimization`,
+			this._managedContextsOptimization.getStatisticMessage()
+		);
+		logWhenMessage(
+			`Managed missing snapshot optimization`,
+			this._managedMissingOptimization.getStatisticMessage()
 		);
 	}
-}
 
-module.exports = ConstPlugin;
+	_log(path, reason, ...args) {
+		const key = path + reason;
+		if (this._loggedPaths.has(key)) return;
+		this._loggedPaths.add(key);
+		this.logger.debug(`${path} invalidated because ${reason}`, ...args);
+		if (--this._remainingLogs === 0) {
+			this.logger.debug(
+				"Logging limit has been reached and no further logging will be emitted by FileSystemInfo"
+			);
+		}
+	}
 
+	clear() {
+		this._remainingLogs = this.logger ? 40 : 0;
+		if (this._loggedPaths !== undefined) this._loggedPaths.clear();
 
-/***/ }),
+		this._snapshotCache = new WeakMap();
+		this._fileTimestampsOptimization.clear();
+		this._fileHashesOptimization.clear();
+		this._fileTshsOptimization.clear();
+		this._contextTimestampsOptimization.clear();
+		this._contextHashesOptimization.clear();
+		this._contextTshsOptimization.clear();
+		this._missingExistenceOptimization.clear();
+		this._managedItemInfoOptimization.clear();
+		this._managedFilesOptimization.clear();
+		this._managedContextsOptimization.clear();
+		this._managedMissingOptimization.clear();
+		this._fileTimestamps.clear();
+		this._fileHashes.clear();
+		this._fileTshs.clear();
+		this._contextTimestamps.clear();
+		this._contextHashes.clear();
+		this._contextTshs.clear();
+		this._managedItems.clear();
+		this._managedItems.clear();
 
-/***/ 21411:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
+		this._cachedDeprecatedFileTimestamps = undefined;
+		this._cachedDeprecatedContextTimestamps = undefined;
 
-class ContextExclusionPlugin {
-	/**
-	 * @param {RegExp} negativeMatcher Matcher regular expression
-	 */
-	constructor(negativeMatcher) {
-		this.negativeMatcher = negativeMatcher;
+		this._statCreatedSnapshots = 0;
+		this._statTestedSnapshotsCached = 0;
+		this._statTestedSnapshotsNotCached = 0;
+		this._statTestedChildrenCached = 0;
+		this._statTestedChildrenNotCached = 0;
+		this._statTestedEntries = 0;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
+	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files => {
-				return files.filter(filePath => !this.negativeMatcher.test(filePath));
-			});
-		});
+	addFileTimestamps(map, immutable) {
+		this._fileTimestamps.addAll(map, immutable);
+		this._cachedDeprecatedFileTimestamps = undefined;
 	}
-}
-
-module.exports = ContextExclusionPlugin;
-
-
-/***/ }),
-
-/***/ 76729:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const { makeWebpackError } = __webpack_require__(11351);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const WebpackError = __webpack_require__(53799);
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	keepOriginalOrder,
-	compareModulesById
-} = __webpack_require__(29579);
-const { contextify, parseResource } = __webpack_require__(82186);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").BuildMeta} BuildMeta */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
-/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-/** @typedef {"sync" | "eager" | "weak" | "async-weak" | "lazy" | "lazy-once"} ContextMode Context mode */
-
-/**
- * @typedef {Object} ContextOptions
- * @property {ContextMode} mode
- * @property {boolean} recursive
- * @property {RegExp} regExp
- * @property {"strict"|boolean=} namespaceObject
- * @property {string=} addon
- * @property {string=} chunkName
- * @property {RegExp=} include
- * @property {RegExp=} exclude
- * @property {RawChunkGroupOptions=} groupOptions
- * @property {string=} typePrefix
- * @property {string=} category
- * @property {string[][]=} referencedExports exports referenced from modules (won't be mangled)
- */
-
-/**
- * @typedef {Object} ContextModuleOptionsExtras
- * @property {string} resource
- * @property {string=} resourceQuery
- * @property {string=} resourceFragment
- * @property {TODO} resolveOptions
- */
-
-/** @typedef {ContextOptions & ContextModuleOptionsExtras} ContextModuleOptions */
-
-/**
- * @callback ResolveDependenciesCallback
- * @param {(Error | null)=} err
- * @param {ContextElementDependency[]=} dependencies
- */
-
-/**
- * @callback ResolveDependencies
- * @param {InputFileSystem} fs
- * @param {ContextModuleOptions} options
- * @param {ResolveDependenciesCallback} callback
- */
-
-const SNAPSHOT_OPTIONS = { timestamp: true };
-
-const TYPES = new Set(["javascript"]);
 
-class ContextModule extends Module {
 	/**
-	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
-	 * @param {ContextModuleOptions} options options object
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
+	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
+	 * @returns {void}
 	 */
-	constructor(resolveDependencies, options) {
-		const parsed = parseResource(options ? options.resource : "");
-		const resource = parsed.path;
-		const resourceQuery = (options && options.resourceQuery) || parsed.query;
-		const resourceFragment =
-			(options && options.resourceFragment) || parsed.fragment;
-
-		super("javascript/dynamic", resource);
-
-		// Info from Factory
-		this.resolveDependencies = resolveDependencies;
-		/** @type {ContextModuleOptions} */
-		this.options = {
-			...options,
-			resource,
-			resourceQuery,
-			resourceFragment
-		};
-		if (options && options.resolveOptions !== undefined) {
-			this.resolveOptions = options.resolveOptions;
-		}
-
-		if (options && typeof options.mode !== "string") {
-			throw new Error("options.mode is a required option");
-		}
-
-		this._identifier = this._createIdentifier();
-		this._forceBuild = true;
+	addContextTimestamps(map, immutable) {
+		this._contextTimestamps.addAll(map, immutable);
+		this._cachedDeprecatedContextTimestamps = undefined;
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @param {string} path file path
+	 * @param {function((WebpackError | null)=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @returns {void}
 	 */
-	getSourceTypes() {
-		return TYPES;
+	getFileTimestamp(path, callback) {
+		const cache = this._fileTimestamps.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.fileTimestampQueue.add(path, callback);
 	}
 
 	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
 	 * @returns {void}
 	 */
-	updateCacheModule(module) {
-		const m = /** @type {ContextModule} */ (module);
-		this.resolveDependencies = m.resolveDependencies;
-		this.options = m.options;
+	getContextTimestamp(path, callback) {
+		const cache = this._contextTimestamps.get(path);
+		if (cache !== undefined) {
+			if (cache === "ignore") return callback(null, "ignore");
+			const resolved = getResolvedTimestamp(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextTimestamp(cache, callback);
+		}
+		this.contextTimestampQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedTimestamp(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextTimestamp(entry, callback);
+		});
 	}
 
 	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @returns {void}
 	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.resolveDependencies = undefined;
-	}
-
-	_prettyRegExp(regexString, stripSlash = true) {
-		const str = (regexString + "").replace(/!/g, "%21").replace(/\|/g, "%7C");
-		return stripSlash ? str.substring(1, str.length - 1) : str;
-	}
-
-	_createIdentifier() {
-		let identifier = this.context;
-		if (this.options.resourceQuery) {
-			identifier += `|${this.options.resourceQuery}`;
-		}
-		if (this.options.resourceFragment) {
-			identifier += `|${this.options.resourceFragment}`;
-		}
-		if (this.options.mode) {
-			identifier += `|${this.options.mode}`;
-		}
-		if (!this.options.recursive) {
-			identifier += "|nonrecursive";
-		}
-		if (this.options.addon) {
-			identifier += `|${this.options.addon}`;
-		}
-		if (this.options.regExp) {
-			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
-		}
-		if (this.options.include) {
-			identifier += `|include: ${this._prettyRegExp(
-				this.options.include,
-				false
-			)}`;
-		}
-		if (this.options.exclude) {
-			identifier += `|exclude: ${this._prettyRegExp(
-				this.options.exclude,
-				false
-			)}`;
-		}
-		if (this.options.referencedExports) {
-			identifier += `|referencedExports: ${JSON.stringify(
-				this.options.referencedExports
-			)}`;
-		}
-		if (this.options.chunkName) {
-			identifier += `|chunkName: ${this.options.chunkName}`;
-		}
-		if (this.options.groupOptions) {
-			identifier += `|groupOptions: ${JSON.stringify(
-				this.options.groupOptions
-			)}`;
-		}
-		if (this.options.namespaceObject === "strict") {
-			identifier += "|strict namespace object";
-		} else if (this.options.namespaceObject) {
-			identifier += "|namespace object";
-		}
-
-		return identifier;
+	_getUnresolvedContextTimestamp(path, callback) {
+		const cache = this._contextTimestamps.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextTimestampQueue.add(path, callback);
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {string} path file path
+	 * @param {function((WebpackError | null)=, string=): void} callback callback function
+	 * @returns {void}
 	 */
-	identifier() {
-		return this._identifier;
+	getFileHash(path, callback) {
+		const cache = this._fileHashes.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.fileHashQueue.add(path, callback);
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, string=): void} callback callback function
+	 * @returns {void}
 	 */
-	readableIdentifier(requestShortener) {
-		let identifier = requestShortener.shorten(this.context) + "/";
-		if (this.options.resourceQuery) {
-			identifier += ` ${this.options.resourceQuery}`;
-		}
-		if (this.options.mode) {
-			identifier += ` ${this.options.mode}`;
-		}
-		if (!this.options.recursive) {
-			identifier += " nonrecursive";
-		}
-		if (this.options.addon) {
-			identifier += ` ${requestShortener.shorten(this.options.addon)}`;
-		}
-		if (this.options.regExp) {
-			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
-		}
-		if (this.options.include) {
-			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
-		}
-		if (this.options.exclude) {
-			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
-		}
-		if (this.options.referencedExports) {
-			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
-				.join(", ")}`;
-		}
-		if (this.options.chunkName) {
-			identifier += ` chunkName: ${this.options.chunkName}`;
-		}
-		if (this.options.groupOptions) {
-			const groupOptions = this.options.groupOptions;
-			for (const key of Object.keys(groupOptions)) {
-				identifier += ` ${key}: ${groupOptions[key]}`;
-			}
-		}
-		if (this.options.namespaceObject === "strict") {
-			identifier += " strict namespace object";
-		} else if (this.options.namespaceObject) {
-			identifier += " namespace object";
+	getContextHash(path, callback) {
+		const cache = this._contextHashes.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedHash(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextHash(cache, callback);
 		}
-
-		return identifier;
+		this.contextHashQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedHash(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextHash(entry, callback);
+		});
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, ContextHash=): void} callback callback function
+	 * @returns {void}
 	 */
-	libIdent(options) {
-		let identifier = contextify(
-			options.context,
-			this.context,
-			options.associatedObjectForCache
-		);
-		if (this.layer) identifier = `(${this.layer})/${identifier}`;
-		if (this.options.mode) {
-			identifier += ` ${this.options.mode}`;
-		}
-		if (this.options.recursive) {
-			identifier += " recursive";
-		}
-		if (this.options.addon) {
-			identifier += ` ${contextify(
-				options.context,
-				this.options.addon,
-				options.associatedObjectForCache
-			)}`;
-		}
-		if (this.options.regExp) {
-			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
-		}
-		if (this.options.include) {
-			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
-		}
-		if (this.options.exclude) {
-			identifier += ` exclude: ${this._prettyRegExp(this.options.exclude)}`;
-		}
-		if (this.options.referencedExports) {
-			identifier += ` referencedExports: ${this.options.referencedExports
-				.map(e => e.join("."))
-				.join(", ")}`;
-		}
-
-		return identifier;
+	_getUnresolvedContextHash(path, callback) {
+		const cache = this._contextHashes.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextHashQueue.add(path, callback);
 	}
 
 	/**
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, ResolvedContextTimestampAndHash=): void} callback callback function
 	 * @returns {void}
 	 */
-	invalidateBuild() {
-		this._forceBuild = true;
+	getContextTsh(path, callback) {
+		const cache = this._contextTshs.get(path);
+		if (cache !== undefined) {
+			const resolved = getResolvedTimestamp(cache);
+			if (resolved !== undefined) return callback(null, resolved);
+			return this._resolveContextTsh(cache, callback);
+		}
+		this.contextTshQueue.add(path, (err, entry) => {
+			if (err) return callback(err);
+			const resolved = getResolvedTimestamp(entry);
+			if (resolved !== undefined) return callback(null, resolved);
+			this._resolveContextTsh(entry, callback);
+		});
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {string} path context path
+	 * @param {function((WebpackError | null)=, ContextTimestampAndHash=): void} callback callback function
 	 * @returns {void}
 	 */
-	needBuild({ fileSystemInfo }, callback) {
-		// build if enforced
-		if (this._forceBuild) return callback(null, true);
-
-		// always build when we have no snapshot
-		if (!this.buildInfo.snapshot) return callback(null, true);
+	_getUnresolvedContextTsh(path, callback) {
+		const cache = this._contextTshs.get(path);
+		if (cache !== undefined) return callback(null, cache);
+		this.contextTshQueue.add(path, callback);
+	}
 
-		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
-			callback(err, !valid);
+	_createBuildDependenciesResolvers() {
+		const resolveContext = createResolver({
+			resolveToContext: true,
+			exportsFields: [],
+			fileSystem: this.fs
+		});
+		const resolveCjs = createResolver({
+			extensions: [".js", ".json", ".node"],
+			conditionNames: ["require", "node"],
+			exportsFields: ["exports"],
+			fileSystem: this.fs
+		});
+		const resolveCjsAsChild = createResolver({
+			extensions: [".js", ".json", ".node"],
+			conditionNames: ["require", "node"],
+			exportsFields: [],
+			fileSystem: this.fs
+		});
+		const resolveEsm = createResolver({
+			extensions: [".js", ".json", ".node"],
+			fullySpecified: true,
+			conditionNames: ["import", "node"],
+			exportsFields: ["exports"],
+			fileSystem: this.fs
 		});
+		return { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild };
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {string} context context directory
+	 * @param {Iterable<string>} deps dependencies
+	 * @param {function((Error | null)=, ResolveBuildDependenciesResult=): void} callback callback function
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this._forceBuild = false;
-		/** @type {BuildMeta} */
-		this.buildMeta = {
-			exportsType: "default",
-			defaultObject: "redirect-warn"
+	resolveBuildDependencies(context, deps, callback) {
+		const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } =
+			this._createBuildDependenciesResolvers();
+
+		/** @type {Set<string>} */
+		const files = new Set();
+		/** @type {Set<string>} */
+		const fileSymlinks = new Set();
+		/** @type {Set<string>} */
+		const directories = new Set();
+		/** @type {Set<string>} */
+		const directorySymlinks = new Set();
+		/** @type {Set<string>} */
+		const missing = new Set();
+		/** @type {Set<string>} */
+		const resolveFiles = new Set();
+		/** @type {Set<string>} */
+		const resolveDirectories = new Set();
+		/** @type {Set<string>} */
+		const resolveMissing = new Set();
+		/** @type {Map<string, string | false>} */
+		const resolveResults = new Map();
+		const invalidResolveResults = new Set();
+		const resolverContext = {
+			fileDependencies: resolveFiles,
+			contextDependencies: resolveDirectories,
+			missingDependencies: resolveMissing
 		};
-		this.buildInfo = {
-			snapshot: undefined
+		const expectedToString = expected => {
+			return expected ? ` (expected ${expected})` : "";
 		};
-		this.dependencies.length = 0;
-		this.blocks.length = 0;
-		const startTime = Date.now();
-		this.resolveDependencies(fs, this.options, (err, dependencies) => {
-			if (err) {
-				return callback(
-					makeWebpackError(err, "ContextModule.resolveDependencies")
-				);
-			}
-
-			// abort if something failed
-			// this will create an empty context
-			if (!dependencies) {
-				callback();
-				return;
-			}
-
-			// enhance dependencies with meta info
-			for (const dep of dependencies) {
-				dep.loc = {
-					name: dep.userRequest
-				};
-				dep.request = this.options.addon + dep.request;
+		const jobToString = job => {
+			switch (job.type) {
+				case RBDT_RESOLVE_CJS:
+					return `resolve commonjs ${job.path}${expectedToString(
+						job.expected
+					)}`;
+				case RBDT_RESOLVE_ESM:
+					return `resolve esm ${job.path}${expectedToString(job.expected)}`;
+				case RBDT_RESOLVE_DIRECTORY:
+					return `resolve directory ${job.path}`;
+				case RBDT_RESOLVE_CJS_FILE:
+					return `resolve commonjs file ${job.path}${expectedToString(
+						job.expected
+					)}`;
+				case RBDT_RESOLVE_ESM_FILE:
+					return `resolve esm file ${job.path}${expectedToString(
+						job.expected
+					)}`;
+				case RBDT_DIRECTORY:
+					return `directory ${job.path}`;
+				case RBDT_FILE:
+					return `file ${job.path}`;
+				case RBDT_DIRECTORY_DEPENDENCIES:
+					return `directory dependencies ${job.path}`;
+				case RBDT_FILE_DEPENDENCIES:
+					return `file dependencies ${job.path}`;
 			}
-			dependencies.sort(
-				concatComparators(
-					compareSelect(a => a.loc, compareLocations),
-					keepOriginalOrder(this.dependencies)
-				)
-			);
-
-			if (this.options.mode === "sync" || this.options.mode === "eager") {
-				// if we have an sync or eager context
-				// just add all dependencies and continue
-				this.dependencies = dependencies;
-			} else if (this.options.mode === "lazy-once") {
-				// for the lazy-once mode create a new async dependency block
-				// and add that block to this context
-				if (dependencies.length > 0) {
-					const block = new AsyncDependenciesBlock({
-						...this.options.groupOptions,
-						name: this.options.chunkName
+			return `unknown ${job.type} ${job.path}`;
+		};
+		const pathToString = job => {
+			let result = ` at ${jobToString(job)}`;
+			job = job.issuer;
+			while (job !== undefined) {
+				result += `\n at ${jobToString(job)}`;
+				job = job.issuer;
+			}
+			return result;
+		};
+		processAsyncTree(
+			Array.from(deps, dep => ({
+				type: RBDT_RESOLVE_CJS,
+				context,
+				path: dep,
+				expected: undefined,
+				issuer: undefined
+			})),
+			20,
+			(job, push, callback) => {
+				const { type, context, path, expected } = job;
+				const resolveDirectory = path => {
+					const key = `d\n${context}\n${path}`;
+					if (resolveResults.has(key)) {
+						return callback();
+					}
+					resolveResults.set(key, undefined);
+					resolveContext(context, path, resolverContext, (err, _, result) => {
+						if (err) {
+							if (expected === false) {
+								resolveResults.set(key, false);
+								return callback();
+							}
+							invalidResolveResults.add(key);
+							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
+							return callback(err);
+						}
+						const resultPath = result.path;
+						resolveResults.set(key, resultPath);
+						push({
+							type: RBDT_DIRECTORY,
+							context: undefined,
+							path: resultPath,
+							expected: undefined,
+							issuer: job
+						});
+						callback();
 					});
-					for (const dep of dependencies) {
-						block.addDependency(dep);
+				};
+				const resolveFile = (path, symbol, resolve) => {
+					const key = `${symbol}\n${context}\n${path}`;
+					if (resolveResults.has(key)) {
+						return callback();
 					}
-					this.addBlock(block);
-				}
-			} else if (
-				this.options.mode === "weak" ||
-				this.options.mode === "async-weak"
-			) {
-				// we mark all dependencies as weak
-				for (const dep of dependencies) {
-					dep.weak = true;
-				}
-				this.dependencies = dependencies;
-			} else if (this.options.mode === "lazy") {
-				// if we are lazy create a new async dependency block per dependency
-				// and add all blocks to this context
-				let index = 0;
-				for (const dep of dependencies) {
-					let chunkName = this.options.chunkName;
-					if (chunkName) {
-						if (!/\[(index|request)\]/.test(chunkName)) {
-							chunkName += "[index]";
+					resolveResults.set(key, undefined);
+					resolve(context, path, resolverContext, (err, _, result) => {
+						if (typeof expected === "string") {
+							if (!err && result && result.path === expected) {
+								resolveResults.set(key, result.path);
+							} else {
+								invalidResolveResults.add(key);
+								this.logger.warn(
+									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
+										err || (result && result.path)
+									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
+										job
+									)}`
+								);
+							}
+						} else {
+							if (err) {
+								if (expected === false) {
+									resolveResults.set(key, false);
+									return callback();
+								}
+								invalidResolveResults.add(key);
+								err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString(
+									job
+								)}`;
+								return callback(err);
+							}
+							const resultPath = result.path;
+							resolveResults.set(key, resultPath);
+							push({
+								type: RBDT_FILE,
+								context: undefined,
+								path: resultPath,
+								expected: undefined,
+								issuer: job
+							});
 						}
-						chunkName = chunkName.replace(/\[index\]/g, `${index++}`);
-						chunkName = chunkName.replace(
-							/\[request\]/g,
-							Template.toPath(dep.userRequest)
-						);
+						callback();
+					});
+				};
+				switch (type) {
+					case RBDT_RESOLVE_CJS: {
+						const isDirectory = /[\\/]$/.test(path);
+						if (isDirectory) {
+							resolveDirectory(path.slice(0, path.length - 1));
+						} else {
+							resolveFile(path, "f", resolveCjs);
+						}
+						break;
+					}
+					case RBDT_RESOLVE_ESM: {
+						const isDirectory = /[\\/]$/.test(path);
+						if (isDirectory) {
+							resolveDirectory(path.slice(0, path.length - 1));
+						} else {
+							resolveFile(path);
+						}
+						break;
+					}
+					case RBDT_RESOLVE_DIRECTORY: {
+						resolveDirectory(path);
+						break;
+					}
+					case RBDT_RESOLVE_CJS_FILE: {
+						resolveFile(path, "f", resolveCjs);
+						break;
+					}
+					case RBDT_RESOLVE_CJS_FILE_AS_CHILD: {
+						resolveFile(path, "c", resolveCjsAsChild);
+						break;
+					}
+					case RBDT_RESOLVE_ESM_FILE: {
+						resolveFile(path, "e", resolveEsm);
+						break;
+					}
+					case RBDT_FILE: {
+						if (files.has(path)) {
+							callback();
+							break;
+						}
+						files.add(path);
+						this.fs.realpath(path, (err, _realPath) => {
+							if (err) return callback(err);
+							const realPath = /** @type {string} */ (_realPath);
+							if (realPath !== path) {
+								fileSymlinks.add(path);
+								resolveFiles.add(path);
+								if (files.has(realPath)) return callback();
+								files.add(realPath);
+							}
+							push({
+								type: RBDT_FILE_DEPENDENCIES,
+								context: undefined,
+								path: realPath,
+								expected: undefined,
+								issuer: job
+							});
+							callback();
+						});
+						break;
+					}
+					case RBDT_DIRECTORY: {
+						if (directories.has(path)) {
+							callback();
+							break;
+						}
+						directories.add(path);
+						this.fs.realpath(path, (err, _realPath) => {
+							if (err) return callback(err);
+							const realPath = /** @type {string} */ (_realPath);
+							if (realPath !== path) {
+								directorySymlinks.add(path);
+								resolveFiles.add(path);
+								if (directories.has(realPath)) return callback();
+								directories.add(realPath);
+							}
+							push({
+								type: RBDT_DIRECTORY_DEPENDENCIES,
+								context: undefined,
+								path: realPath,
+								expected: undefined,
+								issuer: job
+							});
+							callback();
+						});
+						break;
+					}
+					case RBDT_FILE_DEPENDENCIES: {
+						// Check for known files without dependencies
+						if (/\.json5?$|\.yarn-integrity$|yarn\.lock$|\.ya?ml/.test(path)) {
+							process.nextTick(callback);
+							break;
+						}
+						// Check commonjs cache for the module
+						/** @type {NodeModule} */
+						const module = require.cache[path];
+						if (module && Array.isArray(module.children)) {
+							children: for (const child of module.children) {
+								let childPath = child.filename;
+								if (childPath) {
+									push({
+										type: RBDT_FILE,
+										context: undefined,
+										path: childPath,
+										expected: undefined,
+										issuer: job
+									});
+									const context = dirname(this.fs, path);
+									for (const modulePath of module.paths) {
+										if (childPath.startsWith(modulePath)) {
+											let subPath = childPath.slice(modulePath.length + 1);
+											const packageMatch = /^(@[^\\/]+[\\/])[^\\/]+/.exec(
+												subPath
+											);
+											if (packageMatch) {
+												push({
+													type: RBDT_FILE,
+													context: undefined,
+													path:
+														modulePath +
+														childPath[modulePath.length] +
+														packageMatch[0] +
+														childPath[modulePath.length] +
+														"package.json",
+													expected: false,
+													issuer: job
+												});
+											}
+											let request = subPath.replace(/\\/g, "/");
+											if (request.endsWith(".js"))
+												request = request.slice(0, -3);
+											push({
+												type: RBDT_RESOLVE_CJS_FILE_AS_CHILD,
+												context,
+												path: request,
+												expected: child.filename,
+												issuer: job
+											});
+											continue children;
+										}
+									}
+									let request = relative(this.fs, context, childPath);
+									if (request.endsWith(".js")) request = request.slice(0, -3);
+									request = request.replace(/\\/g, "/");
+									if (!request.startsWith("../")) request = `./${request}`;
+									push({
+										type: RBDT_RESOLVE_CJS_FILE,
+										context,
+										path: request,
+										expected: child.filename,
+										issuer: job
+									});
+								}
+							}
+						} else if (supportsEsm && /\.m?js$/.test(path)) {
+							if (!this._warnAboutExperimentalEsmTracking) {
+								this.logger.log(
+									"Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" +
+										"Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" +
+										"As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking."
+								);
+								this._warnAboutExperimentalEsmTracking = true;
+							}
+							const lexer = __webpack_require__(54392);
+							lexer.init.then(() => {
+								this.fs.readFile(path, (err, content) => {
+									if (err) return callback(err);
+									try {
+										const context = dirname(this.fs, path);
+										const source = content.toString();
+										const [imports] = lexer.parse(source);
+										for (const imp of imports) {
+											try {
+												let dependency;
+												if (imp.d === -1) {
+													// import ... from "..."
+													dependency = parseString(
+														source.substring(imp.s - 1, imp.e + 1)
+													);
+												} else if (imp.d > -1) {
+													// import()
+													let expr = source.substring(imp.s, imp.e).trim();
+													dependency = parseString(expr);
+												} else {
+													// e.g. import.meta
+													continue;
+												}
+												push({
+													type: RBDT_RESOLVE_ESM_FILE,
+													context,
+													path: dependency,
+													expected: undefined,
+													issuer: job
+												});
+											} catch (e) {
+												this.logger.warn(
+													`Parsing of ${path} for build dependencies failed at 'import(${source.substring(
+														imp.s,
+														imp.e
+													)})'.\n` +
+														"Build dependencies behind this expression are ignored and might cause incorrect cache invalidation."
+												);
+												this.logger.debug(pathToString(job));
+												this.logger.debug(e.stack);
+											}
+										}
+									} catch (e) {
+										this.logger.warn(
+											`Parsing of ${path} for build dependencies failed and all dependencies of this file are ignored, which might cause incorrect cache invalidation..`
+										);
+										this.logger.debug(pathToString(job));
+										this.logger.debug(e.stack);
+									}
+									process.nextTick(callback);
+								});
+							}, callback);
+							break;
+						} else {
+							this.logger.log(
+								`Assuming ${path} has no dependencies as we were unable to assign it to any module system.`
+							);
+							this.logger.debug(pathToString(job));
+						}
+						process.nextTick(callback);
+						break;
+					}
+					case RBDT_DIRECTORY_DEPENDENCIES: {
+						const match =
+							/(^.+[\\/]node_modules[\\/](?:@[^\\/]+[\\/])?[^\\/]+)/.exec(path);
+						const packagePath = match ? match[1] : path;
+						const packageJson = join(this.fs, packagePath, "package.json");
+						this.fs.readFile(packageJson, (err, content) => {
+							if (err) {
+								if (err.code === "ENOENT") {
+									resolveMissing.add(packageJson);
+									const parent = dirname(this.fs, packagePath);
+									if (parent !== packagePath) {
+										push({
+											type: RBDT_DIRECTORY_DEPENDENCIES,
+											context: undefined,
+											path: parent,
+											expected: undefined,
+											issuer: job
+										});
+									}
+									callback();
+									return;
+								}
+								return callback(err);
+							}
+							resolveFiles.add(packageJson);
+							let packageData;
+							try {
+								packageData = JSON.parse(content.toString("utf-8"));
+							} catch (e) {
+								return callback(e);
+							}
+							const depsObject = packageData.dependencies;
+							const optionalDepsObject = packageData.optionalDependencies;
+							const allDeps = new Set();
+							const optionalDeps = new Set();
+							if (typeof depsObject === "object" && depsObject) {
+								for (const dep of Object.keys(depsObject)) {
+									allDeps.add(dep);
+								}
+							}
+							if (
+								typeof optionalDepsObject === "object" &&
+								optionalDepsObject
+							) {
+								for (const dep of Object.keys(optionalDepsObject)) {
+									allDeps.add(dep);
+									optionalDeps.add(dep);
+								}
+							}
+							for (const dep of allDeps) {
+								push({
+									type: RBDT_RESOLVE_DIRECTORY,
+									context: packagePath,
+									path: dep,
+									expected: !optionalDeps.has(dep),
+									issuer: job
+								});
+							}
+							callback();
+						});
+						break;
 					}
-					const block = new AsyncDependenciesBlock(
-						{
-							...this.options.groupOptions,
-							name: chunkName
-						},
-						dep.loc,
-						dep.userRequest
-					);
-					block.addDependency(dep);
-					this.addBlock(block);
 				}
-			} else {
-				callback(
-					new WebpackError(`Unsupported mode "${this.options.mode}" in context`)
-				);
-				return;
+			},
+			err => {
+				if (err) return callback(err);
+				for (const l of fileSymlinks) files.delete(l);
+				for (const l of directorySymlinks) directories.delete(l);
+				for (const k of invalidResolveResults) resolveResults.delete(k);
+				callback(null, {
+					files,
+					directories,
+					missing,
+					resolveResults,
+					resolveDependencies: {
+						files: resolveFiles,
+						directories: resolveDirectories,
+						missing: resolveMissing
+					}
+				});
 			}
-			compilation.fileSystemInfo.createSnapshot(
-				startTime,
-				null,
-				[this.context],
-				null,
-				SNAPSHOT_OPTIONS,
-				(err, snapshot) => {
-					if (err) return callback(err);
-					this.buildInfo.snapshot = snapshot;
-					callback();
-				}
-			);
-		});
+		);
 	}
 
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {Map<string, string | false>} resolveResults results from resolving
+	 * @param {function((Error | null)=, boolean=): void} callback callback with true when resolveResults resolve the same way
+	 * @returns {void}
 	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {
-		contextDependencies.add(this.context);
+	checkResolveResultsValid(resolveResults, callback) {
+		const { resolveCjs, resolveCjsAsChild, resolveEsm, resolveContext } =
+			this._createBuildDependenciesResolvers();
+		asyncLib.eachLimit(
+			resolveResults,
+			20,
+			([key, expectedResult], callback) => {
+				const [type, context, path] = key.split("\n");
+				switch (type) {
+					case "d":
+						resolveContext(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "f":
+						resolveCjs(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "c":
+						resolveCjsAsChild(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					case "e":
+						resolveEsm(context, path, {}, (err, _, result) => {
+							if (expectedResult === false)
+								return callback(err ? undefined : INVALID);
+							if (err) return callback(err);
+							const resultPath = result.path;
+							if (resultPath !== expectedResult) return callback(INVALID);
+							callback();
+						});
+						break;
+					default:
+						callback(new Error("Unexpected type in resolve result key"));
+						break;
+				}
+			},
+			/**
+			 * @param {Error | typeof INVALID=} err error or invalid flag
+			 * @returns {void}
+			 */
+			err => {
+				if (err === INVALID) {
+					return callback(null, false);
+				}
+				if (err) {
+					return callback(err);
+				}
+				return callback(null, true);
+			}
+		);
 	}
 
 	/**
-	 * @param {ContextElementDependency[]} dependencies all dependencies
-	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {TODO} TODO
+	 *
+	 * @param {number} startTime when processing the files has started
+	 * @param {Iterable<string>} files all files
+	 * @param {Iterable<string>} directories all directories
+	 * @param {Iterable<string>} missing all missing files or directories
+	 * @param {Object} options options object (for future extensions)
+	 * @param {boolean=} options.hash should use hash to snapshot
+	 * @param {boolean=} options.timestamp should use timestamp to snapshot
+	 * @param {function((WebpackError | null)=, (Snapshot | null)=): void} callback callback function
+	 * @returns {void}
 	 */
-	getUserRequestMap(dependencies, chunkGraph) {
-		const moduleGraph = chunkGraph.moduleGraph;
-		// if we filter first we get a new array
-		// therefore we don't need to create a clone of dependencies explicitly
-		// therefore the order of this is !important!
-		const sortedDependencies = dependencies
-			.filter(dependency => moduleGraph.getModule(dependency))
-			.sort((a, b) => {
-				if (a.userRequest === b.userRequest) {
-					return 0;
+	createSnapshot(startTime, files, directories, missing, options, callback) {
+		/** @type {Map<string, FileSystemInfoEntry | null>} */
+		const fileTimestamps = new Map();
+		/** @type {Map<string, string | null>} */
+		const fileHashes = new Map();
+		/** @type {Map<string, TimestampAndHash | string | null>} */
+		const fileTshs = new Map();
+		/** @type {Map<string, FileSystemInfoEntry | null>} */
+		const contextTimestamps = new Map();
+		/** @type {Map<string, string | null>} */
+		const contextHashes = new Map();
+		/** @type {Map<string, ResolvedContextTimestampAndHash | null>} */
+		const contextTshs = new Map();
+		/** @type {Map<string, boolean>} */
+		const missingExistence = new Map();
+		/** @type {Map<string, string>} */
+		const managedItemInfo = new Map();
+		/** @type {Set<string>} */
+		const managedFiles = new Set();
+		/** @type {Set<string>} */
+		const managedContexts = new Set();
+		/** @type {Set<string>} */
+		const managedMissing = new Set();
+		/** @type {Set<Snapshot>} */
+		const children = new Set();
+
+		const snapshot = new Snapshot();
+		if (startTime) snapshot.setStartTime(startTime);
+
+		/** @type {Set<string>} */
+		const managedItems = new Set();
+
+		/** 1 = timestamp, 2 = hash, 3 = timestamp + hash */
+		const mode = options && options.hash ? (options.timestamp ? 3 : 2) : 1;
+
+		let jobs = 1;
+		const jobDone = () => {
+			if (--jobs === 0) {
+				if (fileTimestamps.size !== 0) {
+					snapshot.setFileTimestamps(fileTimestamps);
 				}
-				return a.userRequest < b.userRequest ? -1 : 1;
-			});
-		const map = Object.create(null);
-		for (const dep of sortedDependencies) {
-			const module = moduleGraph.getModule(dep);
-			map[dep.userRequest] = chunkGraph.getModuleId(module);
-		}
-		return map;
-	}
+				if (fileHashes.size !== 0) {
+					snapshot.setFileHashes(fileHashes);
+				}
+				if (fileTshs.size !== 0) {
+					snapshot.setFileTshs(fileTshs);
+				}
+				if (contextTimestamps.size !== 0) {
+					snapshot.setContextTimestamps(contextTimestamps);
+				}
+				if (contextHashes.size !== 0) {
+					snapshot.setContextHashes(contextHashes);
+				}
+				if (contextTshs.size !== 0) {
+					snapshot.setContextTshs(contextTshs);
+				}
+				if (missingExistence.size !== 0) {
+					snapshot.setMissingExistence(missingExistence);
+				}
+				if (managedItemInfo.size !== 0) {
+					snapshot.setManagedItemInfo(managedItemInfo);
+				}
+				this._managedFilesOptimization.optimize(snapshot, managedFiles);
+				if (managedFiles.size !== 0) {
+					snapshot.setManagedFiles(managedFiles);
+				}
+				this._managedContextsOptimization.optimize(snapshot, managedContexts);
+				if (managedContexts.size !== 0) {
+					snapshot.setManagedContexts(managedContexts);
+				}
+				this._managedMissingOptimization.optimize(snapshot, managedMissing);
+				if (managedMissing.size !== 0) {
+					snapshot.setManagedMissing(managedMissing);
+				}
+				if (children.size !== 0) {
+					snapshot.setChildren(children);
+				}
+				this._snapshotCache.set(snapshot, true);
+				this._statCreatedSnapshots++;
 
-	/**
-	 * @param {ContextElementDependency[]} dependencies all dependencies
-	 * @param {ChunkGraph} chunkGraph chunk graph
-	 * @returns {TODO} TODO
-	 */
-	getFakeMap(dependencies, chunkGraph) {
-		if (!this.options.namespaceObject) {
-			return 9;
-		}
-		const moduleGraph = chunkGraph.moduleGraph;
-		// bitfield
-		let hasType = 0;
-		const comparator = compareModulesById(chunkGraph);
-		// if we filter first we get a new array
-		// therefore we don't need to create a clone of dependencies explicitly
-		// therefore the order of this is !important!
-		const sortedModules = dependencies
-			.map(dependency => moduleGraph.getModule(dependency))
-			.filter(Boolean)
-			.sort(comparator);
-		const fakeMap = Object.create(null);
-		for (const module of sortedModules) {
-			const exportsType = module.getExportsType(
-				moduleGraph,
-				this.options.namespaceObject === "strict"
-			);
-			const id = chunkGraph.getModuleId(module);
-			switch (exportsType) {
-				case "namespace":
-					fakeMap[id] = 9;
-					hasType |= 1;
-					break;
-				case "dynamic":
-					fakeMap[id] = 7;
-					hasType |= 2;
+				callback(null, snapshot);
+			}
+		};
+		const jobError = () => {
+			if (jobs > 0) {
+				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
+				jobs = -100000000;
+				callback(null, null);
+			}
+		};
+		const checkManaged = (path, managedSet) => {
+			for (const immutablePath of this.immutablePathsRegExps) {
+				if (immutablePath.test(path)) {
+					managedSet.add(path);
+					return true;
+				}
+			}
+			for (const immutablePath of this.immutablePathsWithSlash) {
+				if (path.startsWith(immutablePath)) {
+					managedSet.add(path);
+					return true;
+				}
+			}
+			for (const managedPath of this.managedPathsRegExps) {
+				const match = managedPath.exec(path);
+				if (match) {
+					const managedItem = getManagedItem(match[1], path);
+					if (managedItem) {
+						managedItems.add(managedItem);
+						managedSet.add(path);
+						return true;
+					}
+				}
+			}
+			for (const managedPath of this.managedPathsWithSlash) {
+				if (path.startsWith(managedPath)) {
+					const managedItem = getManagedItem(managedPath, path);
+					if (managedItem) {
+						managedItems.add(managedItem);
+						managedSet.add(path);
+						return true;
+					}
+				}
+			}
+			return false;
+		};
+		const captureNonManaged = (items, managedSet) => {
+			const capturedItems = new Set();
+			for (const path of items) {
+				if (!checkManaged(path, managedSet)) capturedItems.add(path);
+			}
+			return capturedItems;
+		};
+		const processCapturedFiles = capturedFiles => {
+			switch (mode) {
+				case 3:
+					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
+					for (const path of capturedFiles) {
+						const cache = this._fileTshs.get(path);
+						if (cache !== undefined) {
+							fileTshs.set(path, cache);
+						} else {
+							jobs++;
+							this._getFileTimestampAndHash(path, (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting file timestamp hash combination of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									fileTshs.set(path, entry);
+									jobDone();
+								}
+							});
+						}
+					}
 					break;
-				case "default-only":
-					fakeMap[id] = 1;
-					hasType |= 4;
+				case 2:
+					this._fileHashesOptimization.optimize(snapshot, capturedFiles);
+					for (const path of capturedFiles) {
+						const cache = this._fileHashes.get(path);
+						if (cache !== undefined) {
+							fileHashes.set(path, cache);
+						} else {
+							jobs++;
+							this.fileHashQueue.add(path, (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting file hash of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									fileHashes.set(path, entry);
+									jobDone();
+								}
+							});
+						}
+					}
 					break;
-				case "default-with-named":
-					fakeMap[id] = 3;
-					hasType |= 8;
+				case 1:
+					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
+					for (const path of capturedFiles) {
+						const cache = this._fileTimestamps.get(path);
+						if (cache !== undefined) {
+							if (cache !== "ignore") {
+								fileTimestamps.set(path, cache);
+							}
+						} else {
+							jobs++;
+							this.fileTimestampQueue.add(path, (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting file timestamp of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									fileTimestamps.set(path, entry);
+									jobDone();
+								}
+							});
+						}
+					}
 					break;
-				default:
-					throw new Error(`Unexpected exports type ${exportsType}`);
 			}
+		};
+		if (files) {
+			processCapturedFiles(captureNonManaged(files, managedFiles));
 		}
-		if (hasType === 1) {
-			return 9;
+		const processCapturedDirectories = capturedDirectories => {
+			switch (mode) {
+				case 3:
+					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
+					for (const path of capturedDirectories) {
+						const cache = this._contextTshs.get(path);
+						/** @type {ResolvedContextTimestampAndHash} */
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedTimestamp(cache)) !== undefined
+						) {
+							contextTshs.set(path, resolved);
+						} else {
+							jobs++;
+							/**
+							 * @param {Error=} err error
+							 * @param {ResolvedContextTimestampAndHash=} entry entry
+							 * @returns {void}
+							 */
+							const callback = (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting context timestamp hash combination of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									contextTshs.set(path, entry);
+									jobDone();
+								}
+							};
+							if (cache !== undefined) {
+								this._resolveContextTsh(cache, callback);
+							} else {
+								this.getContextTsh(path, callback);
+							}
+						}
+					}
+					break;
+				case 2:
+					this._contextHashesOptimization.optimize(
+						snapshot,
+						capturedDirectories
+					);
+					for (const path of capturedDirectories) {
+						const cache = this._contextHashes.get(path);
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedHash(cache)) !== undefined
+						) {
+							contextHashes.set(path, resolved);
+						} else {
+							jobs++;
+							const callback = (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting context hash of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									contextHashes.set(path, entry);
+									jobDone();
+								}
+							};
+							if (cache !== undefined) {
+								this._resolveContextHash(cache, callback);
+							} else {
+								this.getContextHash(path, callback);
+							}
+						}
+					}
+					break;
+				case 1:
+					this._contextTimestampsOptimization.optimize(
+						snapshot,
+						capturedDirectories
+					);
+					for (const path of capturedDirectories) {
+						const cache = this._contextTimestamps.get(path);
+						if (cache === "ignore") continue;
+						let resolved;
+						if (
+							cache !== undefined &&
+							(resolved = getResolvedTimestamp(cache)) !== undefined
+						) {
+							contextTimestamps.set(path, resolved);
+						} else {
+							jobs++;
+							/**
+							 * @param {Error=} err error
+							 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+							 * @returns {void}
+							 */
+							const callback = (err, entry) => {
+								if (err) {
+									if (this.logger) {
+										this.logger.debug(
+											`Error snapshotting context timestamp of ${path}: ${err.stack}`
+										);
+									}
+									jobError();
+								} else {
+									contextTimestamps.set(path, entry);
+									jobDone();
+								}
+							};
+							if (cache !== undefined) {
+								this._resolveContextTimestamp(cache, callback);
+							} else {
+								this.getContextTimestamp(path, callback);
+							}
+						}
+					}
+					break;
+			}
+		};
+		if (directories) {
+			processCapturedDirectories(
+				captureNonManaged(directories, managedContexts)
+			);
 		}
-		if (hasType === 2) {
-			return 7;
+		const processCapturedMissing = capturedMissing => {
+			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
+			for (const path of capturedMissing) {
+				const cache = this._fileTimestamps.get(path);
+				if (cache !== undefined) {
+					if (cache !== "ignore") {
+						missingExistence.set(path, Boolean(cache));
+					}
+				} else {
+					jobs++;
+					this.fileTimestampQueue.add(path, (err, entry) => {
+						if (err) {
+							if (this.logger) {
+								this.logger.debug(
+									`Error snapshotting missing timestamp of ${path}: ${err.stack}`
+								);
+							}
+							jobError();
+						} else {
+							missingExistence.set(path, Boolean(entry));
+							jobDone();
+						}
+					});
+				}
+			}
+		};
+		if (missing) {
+			processCapturedMissing(captureNonManaged(missing, managedMissing));
 		}
-		if (hasType === 4) {
-			return 1;
-		}
-		if (hasType === 8) {
-			return 3;
-		}
-		if (hasType === 0) {
-			return 9;
-		}
-		return fakeMap;
-	}
-
-	getFakeMapInitStatement(fakeMap) {
-		return typeof fakeMap === "object"
-			? `var fakeMap = ${JSON.stringify(fakeMap, null, "\t")};`
-			: "";
-	}
-
-	getReturn(type, asyncModule) {
-		if (type === 9) {
-			return "__webpack_require__(id)";
-		}
-		return `${RuntimeGlobals.createFakeNamespaceObject}(id, ${type}${
-			asyncModule ? " | 16" : ""
-		})`;
-	}
-
-	getReturnModuleObjectSource(
-		fakeMap,
-		asyncModule,
-		fakeMapDataExpression = "fakeMap[id]"
-	) {
-		if (typeof fakeMap === "number") {
-			return `return ${this.getReturn(fakeMap, asyncModule)};`;
+		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
+		for (const path of managedItems) {
+			const cache = this._managedItems.get(path);
+			if (cache !== undefined) {
+				if (!cache.startsWith("*")) {
+					managedFiles.add(join(this.fs, path, "package.json"));
+				} else if (cache === "*nested") {
+					managedMissing.add(join(this.fs, path, "package.json"));
+				}
+				managedItemInfo.set(path, cache);
+			} else {
+				jobs++;
+				this.managedItemQueue.add(path, (err, entry) => {
+					if (err) {
+						if (this.logger) {
+							this.logger.debug(
+								`Error snapshotting managed item ${path}: ${err.stack}`
+							);
+						}
+						jobError();
+					} else if (entry) {
+						if (!entry.startsWith("*")) {
+							managedFiles.add(join(this.fs, path, "package.json"));
+						} else if (cache === "*nested") {
+							managedMissing.add(join(this.fs, path, "package.json"));
+						}
+						managedItemInfo.set(path, entry);
+						jobDone();
+					} else {
+						// Fallback to normal snapshotting
+						const process = (set, fn) => {
+							if (set.size === 0) return;
+							const captured = new Set();
+							for (const file of set) {
+								if (file.startsWith(path)) captured.add(file);
+							}
+							if (captured.size > 0) fn(captured);
+						};
+						process(managedFiles, processCapturedFiles);
+						process(managedContexts, processCapturedDirectories);
+						process(managedMissing, processCapturedMissing);
+						jobDone();
+					}
+				});
+			}
 		}
-		return `return ${
-			RuntimeGlobals.createFakeNamespaceObject
-		}(id, ${fakeMapDataExpression}${asyncModule ? " | 16" : ""})`;
-	}
-
-	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {string} source code
-	 */
-	getSyncSource(dependencies, id, chunkGraph) {
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-
-function webpackContext(req) {
-	var id = webpackContextResolve(req);
-	${returnModuleObject}
-}
-function webpackContextResolve(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		var e = new Error("Cannot find module '" + req + "'");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	}
-	return map[req];
-}
-webpackContext.keys = function webpackContextKeys() {
-	return Object.keys(map);
-};
-webpackContext.resolve = webpackContextResolve;
-module.exports = webpackContext;
-webpackContext.id = ${JSON.stringify(id)};`;
-	}
-
-	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {string} source code
-	 */
-	getWeakSyncSource(dependencies, id, chunkGraph) {
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-
-function webpackContext(req) {
-	var id = webpackContextResolve(req);
-	if(!${RuntimeGlobals.moduleFactories}[id]) {
-		var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	}
-	${returnModuleObject}
-}
-function webpackContextResolve(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		var e = new Error("Cannot find module '" + req + "'");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	}
-	return map[req];
-}
-webpackContext.keys = function webpackContextKeys() {
-	return Object.keys(map);
-};
-webpackContext.resolve = webpackContextResolve;
-webpackContext.id = ${JSON.stringify(id)};
-module.exports = webpackContext;`;
+		jobDone();
 	}
 
 	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} context context
-	 * @param {ChunkGraph} context.chunkGraph the chunk graph
-	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
-	 * @returns {string} source code
+	 * @param {Snapshot} snapshot1 a snapshot
+	 * @param {Snapshot} snapshot2 a snapshot
+	 * @returns {Snapshot} merged snapshot
 	 */
-	getAsyncWeakSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap, true);
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-
-function webpackAsyncContext(req) {
-	return webpackAsyncContextResolve(req).then(${
-		arrow ? "id =>" : "function(id)"
-	} {
-		if(!${RuntimeGlobals.moduleFactories}[id]) {
-			var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
+	mergeSnapshots(snapshot1, snapshot2) {
+		const snapshot = new Snapshot();
+		if (snapshot1.hasStartTime() && snapshot2.hasStartTime())
+			snapshot.setStartTime(Math.min(snapshot1.startTime, snapshot2.startTime));
+		else if (snapshot2.hasStartTime()) snapshot.startTime = snapshot2.startTime;
+		else if (snapshot1.hasStartTime()) snapshot.startTime = snapshot1.startTime;
+		if (snapshot1.hasFileTimestamps() || snapshot2.hasFileTimestamps()) {
+			snapshot.setFileTimestamps(
+				mergeMaps(snapshot1.fileTimestamps, snapshot2.fileTimestamps)
+			);
 		}
-		${returnModuleObject}
-	});
-}
-function webpackAsyncContextResolve(req) {
-	// Here Promise.resolve().then() is used instead of new Promise() to prevent
-	// uncaught exception popping up in devtools
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
+		if (snapshot1.hasFileHashes() || snapshot2.hasFileHashes()) {
+			snapshot.setFileHashes(
+				mergeMaps(snapshot1.fileHashes, snapshot2.fileHashes)
+			);
 		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
-	}
-
-	/**
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} context context
-	 * @param {ChunkGraph} context.chunkGraph the chunk graph
-	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
-	 * @returns {string} source code
-	 */
-	getEagerSource(dependencies, id, { chunkGraph, runtimeTemplate }) {
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const thenFunction =
-			fakeMap !== 9
-				? `${arrow ? "id =>" : "function(id)"} {
-		${this.getReturnModuleObjectSource(fakeMap)}
-	}`
-				: "__webpack_require__";
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-
-function webpackAsyncContext(req) {
-	return webpackAsyncContextResolve(req).then(${thenFunction});
-}
-function webpackAsyncContextResolve(req) {
-	// Here Promise.resolve().then() is used instead of new Promise() to prevent
-	// uncaught exception popping up in devtools
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
+		if (snapshot1.hasFileTshs() || snapshot2.hasFileTshs()) {
+			snapshot.setFileTshs(mergeMaps(snapshot1.fileTshs, snapshot2.fileTshs));
 		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
+		if (snapshot1.hasContextTimestamps() || snapshot2.hasContextTimestamps()) {
+			snapshot.setContextTimestamps(
+				mergeMaps(snapshot1.contextTimestamps, snapshot2.contextTimestamps)
+			);
+		}
+		if (snapshot1.hasContextHashes() || snapshot2.hasContextHashes()) {
+			snapshot.setContextHashes(
+				mergeMaps(snapshot1.contextHashes, snapshot2.contextHashes)
+			);
+		}
+		if (snapshot1.hasContextTshs() || snapshot2.hasContextTshs()) {
+			snapshot.setContextTshs(
+				mergeMaps(snapshot1.contextTshs, snapshot2.contextTshs)
+			);
+		}
+		if (snapshot1.hasMissingExistence() || snapshot2.hasMissingExistence()) {
+			snapshot.setMissingExistence(
+				mergeMaps(snapshot1.missingExistence, snapshot2.missingExistence)
+			);
+		}
+		if (snapshot1.hasManagedItemInfo() || snapshot2.hasManagedItemInfo()) {
+			snapshot.setManagedItemInfo(
+				mergeMaps(snapshot1.managedItemInfo, snapshot2.managedItemInfo)
+			);
+		}
+		if (snapshot1.hasManagedFiles() || snapshot2.hasManagedFiles()) {
+			snapshot.setManagedFiles(
+				mergeSets(snapshot1.managedFiles, snapshot2.managedFiles)
+			);
+		}
+		if (snapshot1.hasManagedContexts() || snapshot2.hasManagedContexts()) {
+			snapshot.setManagedContexts(
+				mergeSets(snapshot1.managedContexts, snapshot2.managedContexts)
+			);
+		}
+		if (snapshot1.hasManagedMissing() || snapshot2.hasManagedMissing()) {
+			snapshot.setManagedMissing(
+				mergeSets(snapshot1.managedMissing, snapshot2.managedMissing)
+			);
+		}
+		if (snapshot1.hasChildren() || snapshot2.hasChildren()) {
+			snapshot.setChildren(mergeSets(snapshot1.children, snapshot2.children));
+		}
+		if (
+			this._snapshotCache.get(snapshot1) === true &&
+			this._snapshotCache.get(snapshot2) === true
+		) {
+			this._snapshotCache.set(snapshot, true);
+		}
+		return snapshot;
 	}
 
 	/**
-	 * @param {TODO} block TODO
-	 * @param {TODO} dependencies TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} options options object
-	 * @param {RuntimeTemplate} options.runtimeTemplate the runtime template
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @returns {string} source code
+	 * @param {Snapshot} snapshot the snapshot made
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @returns {void}
 	 */
-	getLazyOnceSource(block, dependencies, id, { runtimeTemplate, chunkGraph }) {
-		const promise = runtimeTemplate.blockPromise({
-			chunkGraph,
-			block,
-			message: "lazy-once context",
-			runtimeRequirements: new Set()
-		});
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		const map = this.getUserRequestMap(dependencies, chunkGraph);
-		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
-		const thenFunction =
-			fakeMap !== 9
-				? `${arrow ? "id =>" : "function(id)"} {
-		${this.getReturnModuleObjectSource(fakeMap, true)};
-	}`
-				: "__webpack_require__";
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-
-function webpackAsyncContext(req) {
-	return webpackAsyncContextResolve(req).then(${thenFunction});
-}
-function webpackAsyncContextResolve(req) {
-	return ${promise}.then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
+	checkSnapshotValid(snapshot, callback) {
+		const cachedResult = this._snapshotCache.get(snapshot);
+		if (cachedResult !== undefined) {
+			this._statTestedSnapshotsCached++;
+			if (typeof cachedResult === "boolean") {
+				callback(null, cachedResult);
+			} else {
+				cachedResult.push(callback);
+			}
+			return;
 		}
-		return map[req];
-	});
-}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.resolve = webpackAsyncContextResolve;
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
+		this._statTestedSnapshotsNotCached++;
+		this._checkSnapshotValidNoCache(snapshot, callback);
 	}
 
 	/**
-	 * @param {TODO} blocks TODO
-	 * @param {TODO} id TODO
-	 * @param {Object} context context
-	 * @param {ChunkGraph} context.chunkGraph the chunk graph
-	 * @param {RuntimeTemplate} context.runtimeTemplate the chunk graph
-	 * @returns {string} source code
+	 * @param {Snapshot} snapshot the snapshot made
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @returns {void}
 	 */
-	getLazySource(blocks, id, { chunkGraph, runtimeTemplate }) {
-		const moduleGraph = chunkGraph.moduleGraph;
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		let hasMultipleOrNoChunks = false;
-		let hasNoChunk = true;
-		const fakeMap = this.getFakeMap(
-			blocks.map(b => b.dependencies[0]),
-			chunkGraph
-		);
-		const hasFakeMap = typeof fakeMap === "object";
-		const items = blocks
-			.map(block => {
-				const dependency = block.dependencies[0];
-				return {
-					dependency: dependency,
-					module: moduleGraph.getModule(dependency),
-					block: block,
-					userRequest: dependency.userRequest,
-					chunks: undefined
-				};
-			})
-			.filter(item => item.module);
-		for (const item of items) {
-			const chunkGroup = chunkGraph.getBlockChunkGroup(item.block);
-			const chunks = (chunkGroup && chunkGroup.chunks) || [];
-			item.chunks = chunks;
-			if (chunks.length > 0) {
-				hasNoChunk = false;
+	_checkSnapshotValidNoCache(snapshot, callback) {
+		/** @type {number | undefined} */
+		let startTime = undefined;
+		if (snapshot.hasStartTime()) {
+			startTime = snapshot.startTime;
+		}
+		let jobs = 1;
+		const jobDone = () => {
+			if (--jobs === 0) {
+				this._snapshotCache.set(snapshot, true);
+				callback(null, true);
 			}
-			if (chunks.length !== 1) {
-				hasMultipleOrNoChunks = true;
+		};
+		const invalid = () => {
+			if (jobs > 0) {
+				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
+				jobs = -100000000;
+				this._snapshotCache.set(snapshot, false);
+				callback(null, false);
 			}
-		}
-		const shortMode = hasNoChunk && !hasFakeMap;
-		const sortedItems = items.sort((a, b) => {
-			if (a.userRequest === b.userRequest) return 0;
-			return a.userRequest < b.userRequest ? -1 : 1;
-		});
-		const map = Object.create(null);
-		for (const item of sortedItems) {
-			const moduleId = chunkGraph.getModuleId(item.module);
-			if (shortMode) {
-				map[item.userRequest] = moduleId;
-			} else {
-				const arrayStart = [moduleId];
-				if (hasFakeMap) {
-					arrayStart.push(fakeMap[moduleId]);
+		};
+		const invalidWithError = (path, err) => {
+			if (this._remainingLogs > 0) {
+				this._log(path, `error occurred: %s`, err);
+			}
+			invalid();
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {string} current current hash
+		 * @param {string} snap snapshot hash
+		 * @returns {boolean} true, if ok
+		 */
+		const checkHash = (path, current, snap) => {
+			if (current !== snap) {
+				// If hash differ it's invalid
+				if (this._remainingLogs > 0) {
+					this._log(path, `hashes differ (%s != %s)`, current, snap);
 				}
-				map[item.userRequest] = arrayStart.concat(
-					item.chunks.map(chunk => chunk.id)
-				);
+				return false;
 			}
-		}
-
-		const chunksStartPosition = hasFakeMap ? 2 : 1;
-		const requestPrefix = hasNoChunk
-			? "Promise.resolve()"
-			: hasMultipleOrNoChunks
-			? `Promise.all(ids.slice(${chunksStartPosition}).map(${RuntimeGlobals.ensureChunk}))`
-			: `${RuntimeGlobals.ensureChunk}(ids[${chunksStartPosition}])`;
-		const returnModuleObject = this.getReturnModuleObjectSource(
-			fakeMap,
-			true,
-			shortMode ? "invalid" : "ids[1]"
-		);
-
-		const webpackAsyncContext =
-			requestPrefix === "Promise.resolve()"
-				? `
-function webpackAsyncContext(req) {
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
-		}
-
-		${shortMode ? "var id = map[req];" : "var ids = map[req], id = ids[0];"}
-		${returnModuleObject}
-	});
-}`
-				: `function webpackAsyncContext(req) {
-	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-			var e = new Error("Cannot find module '" + req + "'");
-			e.code = 'MODULE_NOT_FOUND';
-			throw e;
-		});
-	}
-
-	var ids = map[req], id = ids[0];
-	return ${requestPrefix}.then(${arrow ? "() =>" : "function()"} {
-		${returnModuleObject}
-	});
-}`;
-
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${webpackAsyncContext}
-webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
-			"Object.keys(map)"
-		)};
-webpackAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackAsyncContext;`;
-	}
-
-	getSourceForEmptyContext(id, runtimeTemplate) {
-		return `function webpackEmptyContext(req) {
-	var e = new Error("Cannot find module '" + req + "'");
-	e.code = 'MODULE_NOT_FOUND';
-	throw e;
-}
-webpackEmptyContext.keys = ${runtimeTemplate.returningFunction("[]")};
-webpackEmptyContext.resolve = webpackEmptyContext;
-webpackEmptyContext.id = ${JSON.stringify(id)};
-module.exports = webpackEmptyContext;`;
-	}
-
-	getSourceForEmptyAsyncContext(id, runtimeTemplate) {
-		const arrow = runtimeTemplate.supportsArrowFunction();
-		return `function webpackEmptyAsyncContext(req) {
-	// Here Promise.resolve().then() is used instead of new Promise() to prevent
-	// uncaught exception popping up in devtools
-	return Promise.resolve().then(${arrow ? "() =>" : "function()"} {
-		var e = new Error("Cannot find module '" + req + "'");
-		e.code = 'MODULE_NOT_FOUND';
-		throw e;
-	});
-}
-webpackEmptyAsyncContext.keys = ${runtimeTemplate.returningFunction("[]")};
-webpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;
-webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
-module.exports = webpackEmptyAsyncContext;`;
-	}
-
-	/**
-	 * @param {string} asyncMode module mode
-	 * @param {CodeGenerationContext} context context info
-	 * @returns {string} the source code
-	 */
-	getSourceString(asyncMode, { runtimeTemplate, chunkGraph }) {
-		const id = chunkGraph.getModuleId(this);
-		if (asyncMode === "lazy") {
-			if (this.blocks && this.blocks.length > 0) {
-				return this.getLazySource(this.blocks, id, {
-					runtimeTemplate,
-					chunkGraph
-				});
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {boolean} current current entry
+		 * @param {boolean} snap entry from snapshot
+		 * @returns {boolean} true, if ok
+		 */
+		const checkExistence = (path, current, snap) => {
+			if (!current !== !snap) {
+				// If existence of item differs
+				// it's invalid
+				if (this._remainingLogs > 0) {
+					this._log(
+						path,
+						current ? "it didn't exist before" : "it does no longer exist"
+					);
+				}
+				return false;
+			}
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {FileSystemInfoEntry} current current entry
+		 * @param {FileSystemInfoEntry} snap entry from snapshot
+		 * @param {boolean} log log reason
+		 * @returns {boolean} true, if ok
+		 */
+		const checkFile = (path, current, snap, log = true) => {
+			if (current === snap) return true;
+			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
+			if (current) {
+				// For existing items only
+				if (typeof startTime === "number" && current.safeTime > startTime) {
+					// If a change happened after starting reading the item
+					// this may no longer be valid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`it may have changed (%d) after the start time of the snapshot (%d)`,
+							current.safeTime,
+							startTime
+						);
+					}
+					return false;
+				}
+				if (
+					snap.timestamp !== undefined &&
+					current.timestamp !== snap.timestamp
+				) {
+					// If we have a timestamp (it was a file or symlink) and it differs from current timestamp
+					// it's invalid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`timestamps differ (%d != %d)`,
+							current.timestamp,
+							snap.timestamp
+						);
+					}
+					return false;
+				}
+			}
+			return true;
+		};
+		/**
+		 * @param {string} path file path
+		 * @param {ResolvedContextFileSystemInfoEntry} current current entry
+		 * @param {ResolvedContextFileSystemInfoEntry} snap entry from snapshot
+		 * @param {boolean} log log reason
+		 * @returns {boolean} true, if ok
+		 */
+		const checkContext = (path, current, snap, log = true) => {
+			if (current === snap) return true;
+			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
+			if (current) {
+				// For existing items only
+				if (typeof startTime === "number" && current.safeTime > startTime) {
+					// If a change happened after starting reading the item
+					// this may no longer be valid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`it may have changed (%d) after the start time of the snapshot (%d)`,
+							current.safeTime,
+							startTime
+						);
+					}
+					return false;
+				}
+				if (
+					snap.timestampHash !== undefined &&
+					current.timestampHash !== snap.timestampHash
+				) {
+					// If we have a timestampHash (it was a directory) and it differs from current timestampHash
+					// it's invalid
+					if (log && this._remainingLogs > 0) {
+						this._log(
+							path,
+							`timestamps hashes differ (%s != %s)`,
+							current.timestampHash,
+							snap.timestampHash
+						);
+					}
+					return false;
+				}
+			}
+			return true;
+		};
+		if (snapshot.hasChildren()) {
+			const childCallback = (err, result) => {
+				if (err || !result) return invalid();
+				else jobDone();
+			};
+			for (const child of snapshot.children) {
+				const cache = this._snapshotCache.get(child);
+				if (cache !== undefined) {
+					this._statTestedChildrenCached++;
+					/* istanbul ignore else */
+					if (typeof cache === "boolean") {
+						if (cache === false) {
+							invalid();
+							return;
+						}
+					} else {
+						jobs++;
+						cache.push(childCallback);
+					}
+				} else {
+					this._statTestedChildrenNotCached++;
+					jobs++;
+					this._checkSnapshotValidNoCache(child, childCallback);
+				}
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		if (asyncMode === "eager") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getEagerSource(this.dependencies, id, {
-					chunkGraph,
-					runtimeTemplate
-				});
+		if (snapshot.hasFileTimestamps()) {
+			const { fileTimestamps } = snapshot;
+			this._statTestedEntries += fileTimestamps.size;
+			for (const [path, ts] of fileTimestamps) {
+				const cache = this._fileTimestamps.get(path);
+				if (cache !== undefined) {
+					if (cache !== "ignore" && !checkFile(path, cache, ts)) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					this.fileTimestampQueue.add(path, (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkFile(path, entry, ts)) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					});
+				}
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		if (asyncMode === "lazy-once") {
-			const block = this.blocks[0];
-			if (block) {
-				return this.getLazyOnceSource(block, block.dependencies, id, {
-					runtimeTemplate,
-					chunkGraph
+		const processFileHashSnapshot = (path, hash) => {
+			const cache = this._fileHashes.get(path);
+			if (cache !== undefined) {
+				if (cache !== "ignore" && !checkHash(path, cache, hash)) {
+					invalid();
+					return;
+				}
+			} else {
+				jobs++;
+				this.fileHashQueue.add(path, (err, entry) => {
+					if (err) return invalidWithError(path, err);
+					if (!checkHash(path, entry, hash)) {
+						invalid();
+					} else {
+						jobDone();
+					}
 				});
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
+		};
+		if (snapshot.hasFileHashes()) {
+			const { fileHashes } = snapshot;
+			this._statTestedEntries += fileHashes.size;
+			for (const [path, hash] of fileHashes) {
+				processFileHashSnapshot(path, hash);
+			}
 		}
-		if (asyncMode === "async-weak") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getAsyncWeakSource(this.dependencies, id, {
-					chunkGraph,
-					runtimeTemplate
-				});
+		if (snapshot.hasFileTshs()) {
+			const { fileTshs } = snapshot;
+			this._statTestedEntries += fileTshs.size;
+			for (const [path, tsh] of fileTshs) {
+				if (typeof tsh === "string") {
+					processFileHashSnapshot(path, tsh);
+				} else {
+					const cache = this._fileTimestamps.get(path);
+					if (cache !== undefined) {
+						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
+							processFileHashSnapshot(path, tsh && tsh.hash);
+						}
+					} else {
+						jobs++;
+						this.fileTimestampQueue.add(path, (err, entry) => {
+							if (err) return invalidWithError(path, err);
+							if (!checkFile(path, entry, tsh, false)) {
+								processFileHashSnapshot(path, tsh && tsh.hash);
+							}
+							jobDone();
+						});
+					}
+				}
 			}
-			return this.getSourceForEmptyAsyncContext(id, runtimeTemplate);
 		}
-		if (asyncMode === "weak") {
-			if (this.dependencies && this.dependencies.length > 0) {
-				return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
+		if (snapshot.hasContextTimestamps()) {
+			const { contextTimestamps } = snapshot;
+			this._statTestedEntries += contextTimestamps.size;
+			for (const [path, ts] of contextTimestamps) {
+				const cache = this._contextTimestamps.get(path);
+				if (cache === "ignore") continue;
+				let resolved;
+				if (
+					cache !== undefined &&
+					(resolved = getResolvedTimestamp(cache)) !== undefined
+				) {
+					if (!checkContext(path, resolved, ts)) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					/**
+					 * @param {Error=} err error
+					 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+					 * @returns {void}
+					 */
+					const callback = (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkContext(path, entry, ts)) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					};
+					if (cache !== undefined) {
+						this._resolveContextTimestamp(cache, callback);
+					} else {
+						this.getContextTimestamp(path, callback);
+					}
+				}
 			}
 		}
-		if (this.dependencies && this.dependencies.length > 0) {
-			return this.getSyncSource(this.dependencies, id, chunkGraph);
+		const processContextHashSnapshot = (path, hash) => {
+			const cache = this._contextHashes.get(path);
+			let resolved;
+			if (
+				cache !== undefined &&
+				(resolved = getResolvedHash(cache)) !== undefined
+			) {
+				if (!checkHash(path, resolved, hash)) {
+					invalid();
+					return;
+				}
+			} else {
+				jobs++;
+				const callback = (err, entry) => {
+					if (err) return invalidWithError(path, err);
+					if (!checkHash(path, entry, hash)) {
+						invalid();
+					} else {
+						jobDone();
+					}
+				};
+				if (cache !== undefined) {
+					this._resolveContextHash(cache, callback);
+				} else {
+					this.getContextHash(path, callback);
+				}
+			}
+		};
+		if (snapshot.hasContextHashes()) {
+			const { contextHashes } = snapshot;
+			this._statTestedEntries += contextHashes.size;
+			for (const [path, hash] of contextHashes) {
+				processContextHashSnapshot(path, hash);
+			}
 		}
-		return this.getSourceForEmptyContext(id, runtimeTemplate);
-	}
-
-	getSource(sourceString) {
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(sourceString, this.identifier());
+		if (snapshot.hasContextTshs()) {
+			const { contextTshs } = snapshot;
+			this._statTestedEntries += contextTshs.size;
+			for (const [path, tsh] of contextTshs) {
+				if (typeof tsh === "string") {
+					processContextHashSnapshot(path, tsh);
+				} else {
+					const cache = this._contextTimestamps.get(path);
+					if (cache === "ignore") continue;
+					let resolved;
+					if (
+						cache !== undefined &&
+						(resolved = getResolvedTimestamp(cache)) !== undefined
+					) {
+						if (!checkContext(path, resolved, tsh, false)) {
+							processContextHashSnapshot(path, tsh && tsh.hash);
+						}
+					} else {
+						jobs++;
+						/**
+						 * @param {Error=} err error
+						 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+						 * @returns {void}
+						 */
+						const callback = (err, entry) => {
+							if (err) return invalidWithError(path, err);
+							if (!checkContext(path, entry, tsh, false)) {
+								processContextHashSnapshot(path, tsh && tsh.hash);
+							}
+							jobDone();
+						};
+						if (cache !== undefined) {
+							this._resolveContextTimestamp(cache, callback);
+						} else {
+							this.getContextTimestamp(path, callback);
+						}
+					}
+				}
+			}
 		}
-		return new RawSource(sourceString);
-	}
-
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		const { chunkGraph } = context;
-		const sources = new Map();
-		sources.set(
-			"javascript",
-			this.getSource(this.getSourceString(this.options.mode, context))
-		);
-		const set = new Set();
-		const allDeps = /** @type {ContextElementDependency[]} */ (
-			this.dependencies.concat(this.blocks.map(b => b.dependencies[0]))
-		);
-		set.add(RuntimeGlobals.module);
-		set.add(RuntimeGlobals.hasOwnProperty);
-		if (allDeps.length > 0) {
-			const asyncMode = this.options.mode;
-			set.add(RuntimeGlobals.require);
-			if (asyncMode === "weak") {
-				set.add(RuntimeGlobals.moduleFactories);
-			} else if (asyncMode === "async-weak") {
-				set.add(RuntimeGlobals.moduleFactories);
-				set.add(RuntimeGlobals.ensureChunk);
-			} else if (asyncMode === "lazy" || asyncMode === "lazy-once") {
-				set.add(RuntimeGlobals.ensureChunk);
+		if (snapshot.hasMissingExistence()) {
+			const { missingExistence } = snapshot;
+			this._statTestedEntries += missingExistence.size;
+			for (const [path, existence] of missingExistence) {
+				const cache = this._fileTimestamps.get(path);
+				if (cache !== undefined) {
+					if (
+						cache !== "ignore" &&
+						!checkExistence(path, Boolean(cache), Boolean(existence))
+					) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					this.fileTimestampQueue.add(path, (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkExistence(path, Boolean(entry), Boolean(existence))) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					});
+				}
 			}
-			if (this.getFakeMap(allDeps, chunkGraph) !== 9) {
-				set.add(RuntimeGlobals.createFakeNamespaceObject);
+		}
+		if (snapshot.hasManagedItemInfo()) {
+			const { managedItemInfo } = snapshot;
+			this._statTestedEntries += managedItemInfo.size;
+			for (const [path, info] of managedItemInfo) {
+				const cache = this._managedItems.get(path);
+				if (cache !== undefined) {
+					if (!checkHash(path, cache, info)) {
+						invalid();
+						return;
+					}
+				} else {
+					jobs++;
+					this.managedItemQueue.add(path, (err, entry) => {
+						if (err) return invalidWithError(path, err);
+						if (!checkHash(path, entry, info)) {
+							invalid();
+						} else {
+							jobDone();
+						}
+					});
+				}
 			}
 		}
-		return {
-			sources,
-			runtimeRequirements: set
-		};
-	}
-
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		// base penalty
-		let size = 160;
+		jobDone();
 
-		// if we don't have dependencies we stop here.
-		for (const dependency of this.dependencies) {
-			const element = /** @type {ContextElementDependency} */ (dependency);
-			size += 5 + element.userRequest.length;
+		// if there was an async action
+		// try to join multiple concurrent request for this snapshot
+		if (jobs > 0) {
+			const callbacks = [callback];
+			callback = (err, result) => {
+				for (const callback of callbacks) callback(err, result);
+			};
+			this._snapshotCache.set(snapshot, callbacks);
 		}
-		return size;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this._identifier);
-		write(this._forceBuild);
-		super.serialize(context);
-	}
+	_readFileTimestamp(path, callback) {
+		this.fs.stat(path, (err, stat) => {
+			if (err) {
+				if (err.code === "ENOENT") {
+					this._fileTimestamps.set(path, null);
+					this._cachedDeprecatedFileTimestamps = undefined;
+					return callback(null, null);
+				}
+				return callback(err);
+			}
 
-	deserialize(context) {
-		const { read } = context;
-		this._identifier = read();
-		this._forceBuild = read();
-		super.deserialize(context);
-	}
-}
+			let ts;
+			if (stat.isDirectory()) {
+				ts = {
+					safeTime: 0,
+					timestamp: undefined
+				};
+			} else {
+				const mtime = +stat.mtime;
 
-makeSerializable(ContextModule, "webpack/lib/ContextModule");
+				if (mtime) applyMtime(mtime);
 
-module.exports = ContextModule;
+				ts = {
+					safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
+					timestamp: mtime
+				};
+			}
 
+			this._fileTimestamps.set(path, ts);
+			this._cachedDeprecatedFileTimestamps = undefined;
 
-/***/ }),
+			callback(null, ts);
+		});
+	}
 
-/***/ 62471:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	_readFileHash(path, callback) {
+		this.fs.readFile(path, (err, content) => {
+			if (err) {
+				if (err.code === "EISDIR") {
+					this._fileHashes.set(path, "directory");
+					return callback(null, "directory");
+				}
+				if (err.code === "ENOENT") {
+					this._fileHashes.set(path, null);
+					return callback(null, null);
+				}
+				if (err.code === "ERR_FS_FILE_TOO_LARGE") {
+					this.logger.warn(`Ignoring ${path} for hashing as it's very large`);
+					this._fileHashes.set(path, "too large");
+					return callback(null, "too large");
+				}
+				return callback(err);
+			}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			const hash = createHash(this._hashFunction);
 
+			hash.update(content);
 
+			const digest = /** @type {string} */ (hash.digest("hex"));
 
-const asyncLib = __webpack_require__(78175);
-const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = __webpack_require__(41242);
-const ContextModule = __webpack_require__(76729);
-const ModuleFactory = __webpack_require__(51010);
-const ContextElementDependency = __webpack_require__(58477);
-const LazySet = __webpack_require__(38938);
-const { cachedSetProperty } = __webpack_require__(60839);
-const { createFakeHook } = __webpack_require__(64518);
-const { join } = __webpack_require__(17139);
+			this._fileHashes.set(path, digest);
 
-/** @typedef {import("./ContextModule").ContextModuleOptions} ContextModuleOptions */
-/** @typedef {import("./ContextModule").ResolveDependenciesCallback} ResolveDependenciesCallback */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./dependencies/ContextDependency")} ContextDependency */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+			callback(null, digest);
+		});
+	}
 
-const EMPTY_RESOLVE_OPTIONS = {};
+	_getFileTimestampAndHash(path, callback) {
+		const continueWithHash = hash => {
+			const cache = this._fileTimestamps.get(path);
+			if (cache !== undefined) {
+				if (cache !== "ignore") {
+					const result = {
+						...cache,
+						hash
+					};
+					this._fileTshs.set(path, result);
+					return callback(null, result);
+				} else {
+					this._fileTshs.set(path, hash);
+					return callback(null, hash);
+				}
+			} else {
+				this.fileTimestampQueue.add(path, (err, entry) => {
+					if (err) {
+						return callback(err);
+					}
+					const result = {
+						...entry,
+						hash
+					};
+					this._fileTshs.set(path, result);
+					return callback(null, result);
+				});
+			}
+		};
+
+		const cache = this._fileHashes.get(path);
+		if (cache !== undefined) {
+			continueWithHash(cache);
+		} else {
+			this.fileHashQueue.add(path, (err, entry) => {
+				if (err) {
+					return callback(err);
+				}
+				continueWithHash(entry);
+			});
+		}
+	}
 
-module.exports = class ContextModuleFactory extends ModuleFactory {
 	/**
-	 * @param {ResolverFactory} resolverFactory resolverFactory
+	 * @template T
+	 * @template ItemType
+	 * @param {Object} options options
+	 * @param {string} options.path path
+	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
+	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
+	 * @param {function(string, string, function(Error=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
+	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromFile called when context item is a file
+	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromDirectory called when context item is a directory
+	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
+	 * @param {function((Error | null)=, (T)=): void} callback callback
 	 */
-	constructor(resolverFactory) {
-		super();
-		/** @type {AsyncSeriesWaterfallHook<[TODO[], ContextModuleOptions]>} */
-		const alternativeRequests = new AsyncSeriesWaterfallHook([
-			"modules",
-			"options"
-		]);
-		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
-			beforeResolve: new AsyncSeriesWaterfallHook(["data"]),
-			/** @type {AsyncSeriesWaterfallHook<[TODO]>} */
-			afterResolve: new AsyncSeriesWaterfallHook(["data"]),
-			/** @type {SyncWaterfallHook<[string[]]>} */
-			contextModuleFiles: new SyncWaterfallHook(["files"]),
-			/** @type {FakeHook<Pick<AsyncSeriesWaterfallHook<[TODO[]]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
-			alternatives: createFakeHook(
-				{
-					name: "alternatives",
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["intercept"]} */
-					intercept: interceptor => {
-						throw new Error(
-							"Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead"
-						);
-					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tap"]} */
-					tap: (options, fn) => {
-						alternativeRequests.tap(options, fn);
-					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapAsync"]} */
-					tapAsync: (options, fn) => {
-						alternativeRequests.tapAsync(options, (items, _options, callback) =>
-							fn(items, callback)
-						);
-					},
-					/** @type {AsyncSeriesWaterfallHook<[TODO[]]>["tapPromise"]} */
-					tapPromise: (options, fn) => {
-						alternativeRequests.tapPromise(options, fn);
+	_readContext(
+		{
+			path,
+			fromImmutablePath,
+			fromManagedItem,
+			fromSymlink,
+			fromFile,
+			fromDirectory,
+			reduce
+		},
+		callback
+	) {
+		this.fs.readdir(path, (err, _files) => {
+			if (err) {
+				if (err.code === "ENOENT") {
+					return callback(null, null);
+				}
+				return callback(err);
+			}
+			const files = /** @type {string[]} */ (_files)
+				.map(file => file.normalize("NFC"))
+				.filter(file => !/^\./.test(file))
+				.sort();
+			asyncLib.map(
+				files,
+				(file, callback) => {
+					const child = join(this.fs, path, file);
+					for (const immutablePath of this.immutablePathsRegExps) {
+						if (immutablePath.test(path)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(path));
+						}
+					}
+					for (const immutablePath of this.immutablePathsWithSlash) {
+						if (path.startsWith(immutablePath)) {
+							// ignore any immutable path for timestamping
+							return callback(null, fromImmutablePath(path));
+						}
+					}
+					for (const managedPath of this.managedPathsRegExps) {
+						const match = managedPath.exec(path);
+						if (match) {
+							const managedItem = getManagedItem(match[1], path);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
+							}
+						}
+					}
+					for (const managedPath of this.managedPathsWithSlash) {
+						if (path.startsWith(managedPath)) {
+							const managedItem = getManagedItem(managedPath, child);
+							if (managedItem) {
+								// construct timestampHash from managed info
+								return this.managedItemQueue.add(managedItem, (err, info) => {
+									if (err) return callback(err);
+									return callback(null, fromManagedItem(info));
+								});
+							}
+						}
 					}
+
+					lstatReadlinkAbsolute(this.fs, child, (err, stat) => {
+						if (err) return callback(err);
+
+						if (typeof stat === "string") {
+							return fromSymlink(child, stat, callback);
+						}
+
+						if (stat.isFile()) {
+							return fromFile(child, stat, callback);
+						}
+						if (stat.isDirectory()) {
+							return fromDirectory(child, stat, callback);
+						}
+						callback(null, null);
+					});
 				},
-				"ContextModuleFactory.hooks.alternatives has deprecated in favor of ContextModuleFactory.hooks.alternativeRequests with an additional options argument.",
-				"DEP_WEBPACK_CONTEXT_MODULE_FACTORY_ALTERNATIVES"
-			),
-			alternativeRequests
+				(err, results) => {
+					if (err) return callback(err);
+					const result = reduce(files, results);
+					callback(null, result);
+				}
+			);
 		});
-		this.resolverFactory = resolverFactory;
 	}
 
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		const context = data.context;
-		const dependencies = data.dependencies;
-		const resolveOptions = data.resolveOptions;
-		const dependency = /** @type {ContextDependency} */ (dependencies[0]);
-		const fileDependencies = new LazySet();
-		const missingDependencies = new LazySet();
-		const contextDependencies = new LazySet();
-		this.hooks.beforeResolve.callAsync(
+	_readContextTimestamp(path, callback) {
+		this._readContext(
 			{
-				context: context,
-				dependencies: dependencies,
-				resolveOptions,
-				fileDependencies,
-				missingDependencies,
-				contextDependencies,
-				...dependency.options
-			},
-			(err, beforeResolveResult) => {
-				if (err) {
-					return callback(err, {
-						fileDependencies,
-						missingDependencies,
-						contextDependencies
+				path,
+				fromImmutablePath: () => null,
+				fromManagedItem: info => ({
+					safeTime: 0,
+					timestampHash: info
+				}),
+				fromSymlink: (file, target, callback) => {
+					callback(null, {
+						timestampHash: target,
+						symlinks: new Set([target])
 					});
-				}
+				},
+				fromFile: (file, stat, callback) => {
+					// Prefer the cached value over our new stat to report consistent results
+					const cache = this._fileTimestamps.get(file);
+					if (cache !== undefined)
+						return callback(null, cache === "ignore" ? null : cache);
 
-				// Ignored
-				if (!beforeResolveResult) {
-					return callback(null, {
-						fileDependencies,
-						missingDependencies,
-						contextDependencies
-					});
-				}
+					const mtime = +stat.mtime;
 
-				const context = beforeResolveResult.context;
-				const request = beforeResolveResult.request;
-				const resolveOptions = beforeResolveResult.resolveOptions;
+					if (mtime) applyMtime(mtime);
 
-				let loaders,
-					resource,
-					loadersPrefix = "";
-				const idx = request.lastIndexOf("!");
-				if (idx >= 0) {
-					let loadersRequest = request.substr(0, idx + 1);
-					let i;
-					for (
-						i = 0;
-						i < loadersRequest.length && loadersRequest[i] === "!";
-						i++
-					) {
-						loadersPrefix += "!";
-					}
-					loadersRequest = loadersRequest
-						.substr(i)
-						.replace(/!+$/, "")
-						.replace(/!!+/g, "!");
-					if (loadersRequest === "") {
-						loaders = [];
-					} else {
-						loaders = loadersRequest.split("!");
-					}
-					resource = request.substr(idx + 1);
-				} else {
-					loaders = [];
-					resource = request;
-				}
+					const ts = {
+						safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
+						timestamp: mtime
+					};
 
-				const contextResolver = this.resolverFactory.get(
-					"context",
-					dependencies.length > 0
-						? cachedSetProperty(
-								resolveOptions || EMPTY_RESOLVE_OPTIONS,
-								"dependencyType",
-								dependencies[0].category
-						  )
-						: resolveOptions
-				);
-				const loaderResolver = this.resolverFactory.get("loader");
+					this._fileTimestamps.set(file, ts);
+					this._cachedDeprecatedFileTimestamps = undefined;
+					callback(null, ts);
+				},
+				fromDirectory: (directory, stat, callback) => {
+					this.contextTimestampQueue.increaseParallelism();
+					this._getUnresolvedContextTimestamp(directory, (err, tsEntry) => {
+						this.contextTimestampQueue.decreaseParallelism();
+						callback(err, tsEntry);
+					});
+				},
+				reduce: (files, tsEntries) => {
+					let symlinks = undefined;
 
-				asyncLib.parallel(
-					[
-						callback => {
-							contextResolver.resolve(
-								{},
-								context,
-								resource,
-								{
-									fileDependencies,
-									missingDependencies,
-									contextDependencies
-								},
-								(err, result) => {
-									if (err) return callback(err);
-									callback(null, result);
-								}
-							);
-						},
-						callback => {
-							asyncLib.map(
-								loaders,
-								(loader, callback) => {
-									loaderResolver.resolve(
-										{},
-										context,
-										loader,
-										{
-											fileDependencies,
-											missingDependencies,
-											contextDependencies
-										},
-										(err, result) => {
-											if (err) return callback(err);
-											callback(null, result);
-										}
-									);
-								},
-								callback
-							);
+					const hash = createHash(this._hashFunction);
+
+					for (const file of files) hash.update(file);
+					let safeTime = 0;
+					for (const entry of tsEntries) {
+						if (!entry) {
+							hash.update("n");
+							continue;
 						}
-					],
-					(err, result) => {
-						if (err) {
-							return callback(err, {
-								fileDependencies,
-								missingDependencies,
-								contextDependencies
-							});
+						if (entry.timestamp) {
+							hash.update("f");
+							hash.update(`${entry.timestamp}`);
+						} else if (entry.timestampHash) {
+							hash.update("d");
+							hash.update(`${entry.timestampHash}`);
+						}
+						if (entry.symlinks !== undefined) {
+							if (symlinks === undefined) symlinks = new Set();
+							addAll(entry.symlinks, symlinks);
+						}
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
 						}
+					}
 
-						this.hooks.afterResolve.callAsync(
-							{
-								addon:
-									loadersPrefix +
-									result[1].join("!") +
-									(result[1].length > 0 ? "!" : ""),
-								resource: result[0],
-								resolveDependencies: this.resolveDependencies.bind(this),
-								...beforeResolveResult
-							},
-							(err, result) => {
-								if (err) {
-									return callback(err, {
-										fileDependencies,
-										missingDependencies,
-										contextDependencies
-									});
-								}
+					const digest = /** @type {string} */ (hash.digest("hex"));
 
-								// Ignored
-								if (!result) {
-									return callback(null, {
-										fileDependencies,
-										missingDependencies,
-										contextDependencies
-									});
-								}
+					const result = {
+						safeTime,
+						timestampHash: digest
+					};
+					if (symlinks) result.symlinks = symlinks;
+					return result;
+				}
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				this._contextTimestamps.set(path, result);
+				this._cachedDeprecatedContextTimestamps = undefined;
 
-								return callback(null, {
-									module: new ContextModule(result.resolveDependencies, result),
-									fileDependencies,
-									missingDependencies,
-									contextDependencies
-								});
-							}
-						);
-					}
-				);
+				callback(null, result);
 			}
 		);
 	}
 
 	/**
-	 * @param {InputFileSystem} fs file system
-	 * @param {ContextModuleOptions} options options
-	 * @param {ResolveDependenciesCallback} callback callback function
+	 * @param {ContextFileSystemInfoEntry} entry entry
+	 * @param {function((Error | null)=, ResolvedContextFileSystemInfoEntry=): void} callback callback
 	 * @returns {void}
 	 */
-	resolveDependencies(fs, options, callback) {
-		const cmf = this;
-		const {
-			resource,
-			resourceQuery,
-			resourceFragment,
-			recursive,
-			regExp,
-			include,
-			exclude,
-			referencedExports,
-			category,
-			typePrefix
-		} = options;
-		if (!regExp || !resource) return callback(null, []);
-
-		const addDirectoryChecked = (directory, visited, callback) => {
-			fs.realpath(directory, (err, realPath) => {
-				if (err) return callback(err);
-				if (visited.has(realPath)) return callback(null, []);
-				let recursionStack;
-				addDirectory(
-					directory,
-					(dir, callback) => {
-						if (recursionStack === undefined) {
-							recursionStack = new Set(visited);
-							recursionStack.add(realPath);
+	_resolveContextTimestamp(entry, callback) {
+		const hashes = [];
+		let safeTime = 0;
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextTimestamp(target, (err, entry) => {
+					if (err) return callback(err);
+					if (entry && entry !== "ignore") {
+						hashes.push(entry.timestampHash);
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
 						}
-						addDirectoryChecked(dir, recursionStack, callback);
-					},
-					callback
+						if (entry.symlinks !== undefined) {
+							for (const target of entry.symlinks) push(target);
+						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash(this._hashFunction);
+				hash.update(entry.timestampHash);
+				if (entry.safeTime) {
+					safeTime = Math.max(safeTime, entry.safeTime);
+				}
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = {
+						safeTime,
+						timestampHash: /** @type {string} */ (hash.digest("hex"))
+					})
 				);
-			});
-		};
+			}
+		);
+	}
 
-		const addDirectory = (directory, addSubDirectory, callback) => {
-			fs.readdir(directory, (err, files) => {
+	_readContextHash(path, callback) {
+		this._readContext(
+			{
+				path,
+				fromImmutablePath: () => "",
+				fromManagedItem: info => info || "",
+				fromSymlink: (file, target, callback) => {
+					callback(null, {
+						hash: target,
+						symlinks: new Set([target])
+					});
+				},
+				fromFile: (file, stat, callback) =>
+					this.getFileHash(file, (err, hash) => {
+						callback(err, hash || "");
+					}),
+				fromDirectory: (directory, stat, callback) => {
+					this.contextHashQueue.increaseParallelism();
+					this._getUnresolvedContextHash(directory, (err, hash) => {
+						this.contextHashQueue.decreaseParallelism();
+						callback(err, hash || "");
+					});
+				},
+				/**
+				 * @param {string[]} files files
+				 * @param {(string | ContextHash)[]} fileHashes hashes
+				 * @returns {ContextHash} reduced hash
+				 */
+				reduce: (files, fileHashes) => {
+					let symlinks = undefined;
+					const hash = createHash(this._hashFunction);
+
+					for (const file of files) hash.update(file);
+					for (const entry of fileHashes) {
+						if (typeof entry === "string") {
+							hash.update(entry);
+						} else {
+							hash.update(entry.hash);
+							if (entry.symlinks) {
+								if (symlinks === undefined) symlinks = new Set();
+								addAll(entry.symlinks, symlinks);
+							}
+						}
+					}
+
+					const result = {
+						hash: /** @type {string} */ (hash.digest("hex"))
+					};
+					if (symlinks) result.symlinks = symlinks;
+					return result;
+				}
+			},
+			(err, result) => {
 				if (err) return callback(err);
-				const processedFiles = cmf.hooks.contextModuleFiles.call(
-					/** @type {string[]} */ (files).map(file => file.normalize("NFC"))
+				this._contextHashes.set(path, result);
+				return callback(null, result);
+			}
+		);
+	}
+
+	/**
+	 * @param {ContextHash} entry context hash
+	 * @param {function((Error | null)=, string=): void} callback callback
+	 * @returns {void}
+	 */
+	_resolveContextHash(entry, callback) {
+		const hashes = [];
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextHash(target, (err, hash) => {
+					if (err) return callback(err);
+					if (hash) {
+						hashes.push(hash.hash);
+						if (hash.symlinks !== undefined) {
+							for (const target of hash.symlinks) push(target);
+						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash(this._hashFunction);
+				hash.update(entry.hash);
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = /** @type {string} */ (hash.digest("hex")))
 				);
-				if (!processedFiles || processedFiles.length === 0)
-					return callback(null, []);
-				asyncLib.map(
-					processedFiles.filter(p => p.indexOf(".") !== 0),
-					(segment, callback) => {
-						const subResource = join(fs, directory, segment);
+			}
+		);
+	}
 
-						if (!exclude || !subResource.match(exclude)) {
-							fs.stat(subResource, (err, stat) => {
-								if (err) {
-									if (err.code === "ENOENT") {
-										// ENOENT is ok here because the file may have been deleted between
-										// the readdir and stat calls.
-										return callback();
-									} else {
-										return callback(err);
-									}
-								}
+	_readContextTimestampAndHash(path, callback) {
+		const finalize = (timestamp, hash) => {
+			const result =
+				timestamp === "ignore"
+					? hash
+					: {
+							...timestamp,
+							...hash
+					  };
+			this._contextTshs.set(path, result);
+			callback(null, result);
+		};
+		const cachedHash = this._contextHashes.get(path);
+		const cachedTimestamp = this._contextTimestamps.get(path);
+		if (cachedHash !== undefined) {
+			if (cachedTimestamp !== undefined) {
+				finalize(cachedTimestamp, cachedHash);
+			} else {
+				this.contextTimestampQueue.add(path, (err, entry) => {
+					if (err) return callback(err);
+					finalize(entry, cachedHash);
+				});
+			}
+		} else {
+			if (cachedTimestamp !== undefined) {
+				this.contextHashQueue.add(path, (err, entry) => {
+					if (err) return callback(err);
+					finalize(cachedTimestamp, entry);
+				});
+			} else {
+				this._readContext(
+					{
+						path,
+						fromImmutablePath: () => null,
+						fromManagedItem: info => ({
+							safeTime: 0,
+							timestampHash: info,
+							hash: info || ""
+						}),
+						fromSymlink: (fle, target, callback) => {
+							callback(null, {
+								timestampHash: target,
+								hash: target,
+								symlinks: new Set([target])
+							});
+						},
+						fromFile: (file, stat, callback) => {
+							this._getFileTimestampAndHash(file, callback);
+						},
+						fromDirectory: (directory, stat, callback) => {
+							this.contextTshQueue.increaseParallelism();
+							this.contextTshQueue.add(directory, (err, result) => {
+								this.contextTshQueue.decreaseParallelism();
+								callback(err, result);
+							});
+						},
+						/**
+						 * @param {string[]} files files
+						 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
+						 * @returns {ContextTimestampAndHash} tsh
+						 */
+						reduce: (files, results) => {
+							let symlinks = undefined;
 
-								if (stat.isDirectory()) {
-									if (!recursive) return callback();
-									addSubDirectory(subResource, callback);
-								} else if (
-									stat.isFile() &&
-									(!include || subResource.match(include))
-								) {
-									const obj = {
-										context: resource,
-										request:
-											"." +
-											subResource.substr(resource.length).replace(/\\/g, "/")
-									};
+							const tsHash = createHash(this._hashFunction);
+							const hash = createHash(this._hashFunction);
 
-									this.hooks.alternativeRequests.callAsync(
-										[obj],
-										options,
-										(err, alternatives) => {
-											if (err) return callback(err);
-											alternatives = alternatives
-												.filter(obj => regExp.test(obj.request))
-												.map(obj => {
-													const dep = new ContextElementDependency(
-														obj.request + resourceQuery + resourceFragment,
-														obj.request,
-														typePrefix,
-														category,
-														referencedExports
-													);
-													dep.optional = true;
-													return dep;
-												});
-											callback(null, alternatives);
-										}
-									);
-								} else {
-									callback();
+							for (const file of files) {
+								tsHash.update(file);
+								hash.update(file);
+							}
+							let safeTime = 0;
+							for (const entry of results) {
+								if (!entry) {
+									tsHash.update("n");
+									continue;
 								}
-							});
-						} else {
-							callback();
+								if (typeof entry === "string") {
+									tsHash.update("n");
+									hash.update(entry);
+									continue;
+								}
+								if (entry.timestamp) {
+									tsHash.update("f");
+									tsHash.update(`${entry.timestamp}`);
+								} else if (entry.timestampHash) {
+									tsHash.update("d");
+									tsHash.update(`${entry.timestampHash}`);
+								}
+								if (entry.symlinks !== undefined) {
+									if (symlinks === undefined) symlinks = new Set();
+									addAll(entry.symlinks, symlinks);
+								}
+								if (entry.safeTime) {
+									safeTime = Math.max(safeTime, entry.safeTime);
+								}
+								hash.update(entry.hash);
+							}
+
+							const result = {
+								safeTime,
+								timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+								hash: /** @type {string} */ (hash.digest("hex"))
+							};
+							if (symlinks) result.symlinks = symlinks;
+							return result;
 						}
 					},
 					(err, result) => {
 						if (err) return callback(err);
+						this._contextTshs.set(path, result);
+						return callback(null, result);
+					}
+				);
+			}
+		}
+	}
 
-						if (!result) return callback(null, []);
+	/**
+	 * @param {ContextTimestampAndHash} entry entry
+	 * @param {function((Error | null)=, ResolvedContextTimestampAndHash=): void} callback callback
+	 * @returns {void}
+	 */
+	_resolveContextTsh(entry, callback) {
+		const hashes = [];
+		const tsHashes = [];
+		let safeTime = 0;
+		processAsyncTree(
+			entry.symlinks,
+			10,
+			(target, push, callback) => {
+				this._getUnresolvedContextTsh(target, (err, entry) => {
+					if (err) return callback(err);
+					if (entry) {
+						hashes.push(entry.hash);
+						if (entry.timestampHash) tsHashes.push(entry.timestampHash);
+						if (entry.safeTime) {
+							safeTime = Math.max(safeTime, entry.safeTime);
+						}
+						if (entry.symlinks !== undefined) {
+							for (const target of entry.symlinks) push(target);
+						}
+					}
+					callback();
+				});
+			},
+			err => {
+				if (err) return callback(err);
+				const hash = createHash(this._hashFunction);
+				const tsHash = createHash(this._hashFunction);
+				hash.update(entry.hash);
+				if (entry.timestampHash) tsHash.update(entry.timestampHash);
+				if (entry.safeTime) {
+					safeTime = Math.max(safeTime, entry.safeTime);
+				}
+				hashes.sort();
+				for (const h of hashes) {
+					hash.update(h);
+				}
+				tsHashes.sort();
+				for (const h of tsHashes) {
+					tsHash.update(h);
+				}
+				callback(
+					null,
+					(entry.resolved = {
+						safeTime,
+						timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+						hash: /** @type {string} */ (hash.digest("hex"))
+					})
+				);
+			}
+		);
+	}
 
-						const flattenedResult = [];
+	_getManagedItemDirectoryInfo(path, callback) {
+		this.fs.readdir(path, (err, elements) => {
+			if (err) {
+				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
+					return callback(null, EMPTY_SET);
+				}
+				return callback(err);
+			}
+			const set = new Set(
+				/** @type {string[]} */ (elements).map(element =>
+					join(this.fs, path, element)
+				)
+			);
+			callback(null, set);
+		});
+	}
 
-						for (const item of result) {
-							if (item) flattenedResult.push(...item);
-						}
+	_getManagedItemInfo(path, callback) {
+		const dir = dirname(this.fs, path);
+		this.managedItemDirectoryQueue.add(dir, (err, elements) => {
+			if (err) {
+				return callback(err);
+			}
+			if (!elements.has(path)) {
+				// file or directory doesn't exist
+				this._managedItems.set(path, "*missing");
+				return callback(null, "*missing");
+			}
+			// something exists
+			// it may be a file or directory
+			if (
+				path.endsWith("node_modules") &&
+				(path.endsWith("/node_modules") || path.endsWith("\\node_modules"))
+			) {
+				// we are only interested in existence of this special directory
+				this._managedItems.set(path, "*node_modules");
+				return callback(null, "*node_modules");
+			}
 
-						callback(null, flattenedResult);
+			// we assume it's a directory, as files shouldn't occur in managed paths
+			const packageJsonPath = join(this.fs, path, "package.json");
+			this.fs.readFile(packageJsonPath, (err, content) => {
+				if (err) {
+					if (err.code === "ENOENT" || err.code === "ENOTDIR") {
+						// no package.json or path is not a directory
+						this.fs.readdir(path, (err, elements) => {
+							if (
+								!err &&
+								elements.length === 1 &&
+								elements[0] === "node_modules"
+							) {
+								// This is only a grouping folder e. g. used by yarn
+								// we are only interested in existence of this special directory
+								this._managedItems.set(path, "*nested");
+								return callback(null, "*nested");
+							}
+							this.logger.warn(
+								`Managed item ${path} isn't a directory or doesn't contain a package.json (see snapshot.managedPaths option)`
+							);
+							return callback();
+						});
+						return;
 					}
-				);
+					return callback(err);
+				}
+				let data;
+				try {
+					data = JSON.parse(content.toString("utf-8"));
+				} catch (e) {
+					return callback(e);
+				}
+				if (!data.name) {
+					this.logger.warn(
+						`${packageJsonPath} doesn't contain a "name" property (see snapshot.managedPaths option)`
+					);
+					return callback();
+				}
+				const info = `${data.name || ""}@${data.version || ""}`;
+				this._managedItems.set(path, info);
+				callback(null, info);
 			});
-		};
+		});
+	}
 
-		if (typeof fs.realpath === "function") {
-			addDirectoryChecked(resource, new Set(), callback);
-		} else {
-			const addSubDirectory = (dir, callback) =>
-				addDirectory(dir, addSubDirectory, callback);
-			addDirectory(resource, addSubDirectory, callback);
+	getDeprecatedFileTimestamps() {
+		if (this._cachedDeprecatedFileTimestamps !== undefined)
+			return this._cachedDeprecatedFileTimestamps;
+		const map = new Map();
+		for (const [path, info] of this._fileTimestamps) {
+			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
 		}
+		return (this._cachedDeprecatedFileTimestamps = map);
 	}
-};
+
+	getDeprecatedContextTimestamps() {
+		if (this._cachedDeprecatedContextTimestamps !== undefined)
+			return this._cachedDeprecatedContextTimestamps;
+		const map = new Map();
+		for (const [path, info] of this._contextTimestamps) {
+			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
+		}
+		return (this._cachedDeprecatedContextTimestamps = map);
+	}
+}
+
+module.exports = FileSystemInfo;
+module.exports.Snapshot = Snapshot;
 
 
 /***/ }),
 
-/***/ 12206:
+/***/ 58727:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -38344,161 +40552,59 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 
 
 
-const ContextElementDependency = __webpack_require__(58477);
-const { join } = __webpack_require__(17139);
+const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
 
-class ContextReplacementPlugin {
-	constructor(
-		resourceRegExp,
-		newContentResource,
-		newContentRecursive,
-		newContentRegExp
-	) {
-		this.resourceRegExp = resourceRegExp;
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-		if (typeof newContentResource === "function") {
-			this.newContentCallback = newContentResource;
-		} else if (
-			typeof newContentResource === "string" &&
-			typeof newContentRecursive === "object"
-		) {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = (fs, callback) => {
-				callback(null, newContentRecursive);
-			};
-		} else if (
-			typeof newContentResource === "string" &&
-			typeof newContentRecursive === "function"
-		) {
-			this.newContentResource = newContentResource;
-			this.newContentCreateContextMap = newContentRecursive;
-		} else {
-			if (typeof newContentResource !== "string") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = newContentResource;
-				newContentResource = undefined;
-			}
-			if (typeof newContentRecursive !== "boolean") {
-				newContentRegExp = newContentRecursive;
-				newContentRecursive = undefined;
-			}
-			this.newContentResource = newContentResource;
-			this.newContentRecursive = newContentRecursive;
-			this.newContentRegExp = newContentRegExp;
-		}
+class FlagAllModulesAsUsedPlugin {
+	constructor(explanation) {
+		this.explanation = explanation;
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
-		const resourceRegExp = this.resourceRegExp;
-		const newContentCallback = this.newContentCallback;
-		const newContentResource = this.newContentResource;
-		const newContentRecursive = this.newContentRecursive;
-		const newContentRegExp = this.newContentRegExp;
-		const newContentCreateContextMap = this.newContentCreateContextMap;
-
-		compiler.hooks.contextModuleFactory.tap("ContextReplacementPlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("ContextReplacementPlugin", result => {
-				if (!result) return;
-				if (resourceRegExp.test(result.request)) {
-					if (newContentResource !== undefined) {
-						result.request = newContentResource;
-					}
-					if (newContentRecursive !== undefined) {
-						result.recursive = newContentRecursive;
-					}
-					if (newContentRegExp !== undefined) {
-						result.regExp = newContentRegExp;
-					}
-					if (typeof newContentCallback === "function") {
-						newContentCallback(result);
-					} else {
-						for (const d of result.dependencies) {
-							if (d.critical) d.critical = false;
-						}
-					}
-				}
-				return result;
-			});
-			cmf.hooks.afterResolve.tap("ContextReplacementPlugin", result => {
-				if (!result) return;
-				if (resourceRegExp.test(result.resource)) {
-					if (newContentResource !== undefined) {
-						if (
-							newContentResource.startsWith("/") ||
-							(newContentResource.length > 1 && newContentResource[1] === ":")
-						) {
-							result.resource = newContentResource;
-						} else {
-							result.resource = join(
-								compiler.inputFileSystem,
-								result.resource,
-								newContentResource
-							);
-						}
-					}
-					if (newContentRecursive !== undefined) {
-						result.recursive = newContentRecursive;
-					}
-					if (newContentRegExp !== undefined) {
-						result.regExp = newContentRegExp;
-					}
-					if (typeof newContentCreateContextMap === "function") {
-						result.resolveDependencies =
-							createResolveDependenciesFromContextMap(
-								newContentCreateContextMap
-							);
-					}
-					if (typeof newContentCallback === "function") {
-						const origResource = result.resource;
-						newContentCallback(result);
-						if (
-							result.resource !== origResource &&
-							!result.resource.startsWith("/") &&
-							(result.resource.length <= 1 || result.resource[1] !== ":")
-						) {
-							// When the function changed it to an relative path
-							result.resource = join(
-								compiler.inputFileSystem,
-								origResource,
-								result.resource
+		compiler.hooks.compilation.tap(
+			"FlagAllModulesAsUsedPlugin",
+			compilation => {
+				const moduleGraph = compilation.moduleGraph;
+				compilation.hooks.optimizeDependencies.tap(
+					"FlagAllModulesAsUsedPlugin",
+					modules => {
+						/** @type {RuntimeSpec} */
+						let runtime = undefined;
+						for (const [name, { options }] of compilation.entries) {
+							runtime = mergeRuntimeOwned(
+								runtime,
+								getEntryRuntime(compilation, name, options)
 							);
 						}
-					} else {
-						for (const d of result.dependencies) {
-							if (d.critical) d.critical = false;
+						for (const module of modules) {
+							const exportsInfo = moduleGraph.getExportsInfo(module);
+							exportsInfo.setUsedInUnknownWay(runtime);
+							moduleGraph.addExtraReason(module, this.explanation);
+							if (module.factoryMeta === undefined) {
+								module.factoryMeta = {};
+							}
+							module.factoryMeta.sideEffectFree = false;
 						}
 					}
-				}
-				return result;
-			});
-		});
+				);
+			}
+		);
 	}
 }
 
-const createResolveDependenciesFromContextMap = createContextMap => {
-	const resolveDependenciesFromContextMap = (fs, options, callback) => {
-		createContextMap(fs, (err, map) => {
-			if (err) return callback(err);
-			const dependencies = Object.keys(map).map(key => {
-				return new ContextElementDependency(
-					map[key] + options.resourceQuery + options.resourceFragment,
-					key,
-					options.category,
-					options.referencedExports
-				);
-			});
-			callback(null, dependencies);
-		});
-	};
-	return resolveDependenciesFromContextMap;
-};
-
-module.exports = ContextReplacementPlugin;
+module.exports = FlagAllModulesAsUsedPlugin;
 
 
 /***/ }),
 
-/***/ 79065:
+/***/ 84506:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -38509,605 +40615,776 @@ module.exports = ContextReplacementPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const ConstDependency = __webpack_require__(76911);
-const BasicEvaluatedExpression = __webpack_require__(950);
-const {
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
-const createHash = __webpack_require__(49835);
+const asyncLib = __webpack_require__(78175);
+const Queue = __webpack_require__(65930);
 
-/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-
-/** @typedef {null|undefined|RegExp|Function|string|number|boolean|bigint|undefined} CodeValuePrimitive */
-/** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive|RuntimeValue>} CodeValue */
-
-/**
- * @typedef {Object} RuntimeValueOptions
- * @property {string[]=} fileDependencies
- * @property {string[]=} contextDependencies
- * @property {string[]=} missingDependencies
- * @property {string[]=} buildDependencies
- * @property {string|function(): string=} version
- */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").ExportSpec} ExportSpec */
+/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./Module")} Module */
 
-class RuntimeValue {
+class FlagDependencyExportsPlugin {
 	/**
-	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
-	 * @param {true | string[] | RuntimeValueOptions=} options options
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(fn, options) {
-		this.fn = fn;
-		if (Array.isArray(options)) {
-			options = {
-				fileDependencies: options
-			};
-		}
-		this.options = options || {};
-	}
-
-	get fileDependencies() {
-		return this.options === true ? true : this.options.fileDependencies;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FlagDependencyExportsPlugin",
+			compilation => {
+				const moduleGraph = compilation.moduleGraph;
+				const cache = compilation.getCache("FlagDependencyExportsPlugin");
+				compilation.hooks.finishModules.tapAsync(
+					"FlagDependencyExportsPlugin",
+					(modules, callback) => {
+						const logger = compilation.getLogger(
+							"webpack.FlagDependencyExportsPlugin"
+						);
+						let statRestoredFromMemCache = 0;
+						let statRestoredFromCache = 0;
+						let statNoExports = 0;
+						let statFlaggedUncached = 0;
+						let statNotCached = 0;
+						let statQueueItemsProcessed = 0;
 
-	/**
-	 * @param {JavascriptParser} parser the parser
-	 * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
-	 * @param {string} key the defined key
-	 * @returns {CodeValuePrimitive} code
-	 */
-	exec(parser, valueCacheVersions, key) {
-		const buildInfo = parser.state.module.buildInfo;
-		if (this.options === true) {
-			buildInfo.cacheable = false;
-		} else {
-			if (this.options.fileDependencies) {
-				for (const dep of this.options.fileDependencies) {
-					buildInfo.fileDependencies.add(dep);
-				}
-			}
-			if (this.options.contextDependencies) {
-				for (const dep of this.options.contextDependencies) {
-					buildInfo.contextDependencies.add(dep);
-				}
-			}
-			if (this.options.missingDependencies) {
-				for (const dep of this.options.missingDependencies) {
-					buildInfo.missingDependencies.add(dep);
-				}
-			}
-			if (this.options.buildDependencies) {
-				for (const dep of this.options.buildDependencies) {
-					buildInfo.buildDependencies.add(dep);
-				}
-			}
-		}
+						const { moduleMemCaches } = compilation;
 
-		return this.fn({
-			module: parser.state.module,
-			key,
-			get version() {
-				return /** @type {string} */ (
-					valueCacheVersions.get(VALUE_DEP_PREFIX + key)
-				);
-			}
-		});
-	}
+						/** @type {Queue<Module>} */
+						const queue = new Queue();
 
-	getCacheVersion() {
-		return this.options === true
-			? undefined
-			: (typeof this.options.version === "function"
-					? this.options.version()
-					: this.options.version) || "unset";
-	}
-}
+						// Step 1: Try to restore cached provided export info from cache
+						logger.time("restore cached provided exports");
+						asyncLib.each(
+							modules,
+							(module, callback) => {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								if (!module.buildMeta || !module.buildMeta.exportsType) {
+									if (exportsInfo.otherExportsInfo.provided !== null) {
+										// It's a module without declared exports
+										statNoExports++;
+										exportsInfo.setHasProvideInfo();
+										exportsInfo.setUnknownExportsProvided();
+										return callback();
+									}
+								}
+								if (typeof module.buildInfo.hash !== "string") {
+									statFlaggedUncached++;
+									// Enqueue uncacheable module for determining the exports
+									queue.enqueue(module);
+									exportsInfo.setHasProvideInfo();
+									return callback();
+								}
+								const memCache = moduleMemCaches && moduleMemCaches.get(module);
+								const memCacheValue = memCache && memCache.get(this);
+								if (memCacheValue !== undefined) {
+									statRestoredFromMemCache++;
+									exportsInfo.restoreProvided(memCacheValue);
+									return callback();
+								}
+								cache.get(
+									module.identifier(),
+									module.buildInfo.hash,
+									(err, result) => {
+										if (err) return callback(err);
 
-/**
- * @param {any[]|{[k: string]: any}} obj obj
- * @param {JavascriptParser} parser Parser
- * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
- * @param {string} key the defined key
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
- * @returns {string} code converted to string that evaluates
- */
-const stringifyObj = (
-	obj,
-	parser,
-	valueCacheVersions,
-	key,
-	runtimeTemplate,
-	asiSafe
-) => {
-	let code;
-	let arr = Array.isArray(obj);
-	if (arr) {
-		code = `[${obj
-			.map(code =>
-				toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
-			)
-			.join(",")}]`;
-	} else {
-		code = `{${Object.keys(obj)
-			.map(key => {
-				const code = obj[key];
-				return (
-					JSON.stringify(key) +
-					":" +
-					toCode(code, parser, valueCacheVersions, key, runtimeTemplate, null)
-				);
-			})
-			.join(",")}}`;
-	}
+										if (result !== undefined) {
+											statRestoredFromCache++;
+											exportsInfo.restoreProvided(result);
+										} else {
+											statNotCached++;
+											// Without cached info enqueue module for determining the exports
+											queue.enqueue(module);
+											exportsInfo.setHasProvideInfo();
+										}
+										callback();
+									}
+								);
+							},
+							err => {
+								logger.timeEnd("restore cached provided exports");
+								if (err) return callback(err);
 
-	switch (asiSafe) {
-		case null:
-			return code;
-		case true:
-			return arr ? code : `(${code})`;
-		case false:
-			return arr ? `;${code}` : `;(${code})`;
-		default:
-			return `/*#__PURE__*/Object(${code})`;
-	}
-};
+								/** @type {Set<Module>} */
+								const modulesToStore = new Set();
 
-/**
- * Convert code to a string that evaluates
- * @param {CodeValue} code Code to evaluate
- * @param {JavascriptParser} parser Parser
- * @param {Map<string, string | Set<string>>} valueCacheVersions valueCacheVersions
- * @param {string} key the defined key
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {boolean|undefined|null=} asiSafe asi safe (undefined: unknown, null: unneeded)
- * @returns {string} code converted to string that evaluates
- */
-const toCode = (
-	code,
-	parser,
-	valueCacheVersions,
-	key,
-	runtimeTemplate,
-	asiSafe
-) => {
-	if (code === null) {
-		return "null";
-	}
-	if (code === undefined) {
-		return "undefined";
-	}
-	if (Object.is(code, -0)) {
-		return "-0";
-	}
-	if (code instanceof RuntimeValue) {
-		return toCode(
-			code.exec(parser, valueCacheVersions, key),
-			parser,
-			valueCacheVersions,
-			key,
-			runtimeTemplate,
-			asiSafe
-		);
-	}
-	if (code instanceof RegExp && code.toString) {
-		return code.toString();
-	}
-	if (typeof code === "function" && code.toString) {
-		return "(" + code.toString() + ")";
-	}
-	if (typeof code === "object") {
-		return stringifyObj(
-			code,
-			parser,
-			valueCacheVersions,
-			key,
-			runtimeTemplate,
-			asiSafe
-		);
-	}
-	if (typeof code === "bigint") {
-		return runtimeTemplate.supportsBigIntLiteral()
-			? `${code}n`
-			: `BigInt("${code}")`;
-	}
-	return code + "";
-};
+								/** @type {Map<Module, Set<Module>>} */
+								const dependencies = new Map();
 
-const toCacheVersion = code => {
-	if (code === null) {
-		return "null";
-	}
-	if (code === undefined) {
-		return "undefined";
-	}
-	if (Object.is(code, -0)) {
-		return "-0";
-	}
-	if (code instanceof RuntimeValue) {
-		return code.getCacheVersion();
-	}
-	if (code instanceof RegExp && code.toString) {
-		return code.toString();
-	}
-	if (typeof code === "function" && code.toString) {
-		return "(" + code.toString() + ")";
-	}
-	if (typeof code === "object") {
-		const items = Object.keys(code).map(key => ({
-			key,
-			value: toCacheVersion(code[key])
-		}));
-		if (items.some(({ value }) => value === undefined)) return undefined;
-		return `{${items.map(({ key, value }) => `${key}: ${value}`).join(", ")}}`;
-	}
-	if (typeof code === "bigint") {
-		return `${code}n`;
-	}
-	return code + "";
-};
+								/** @type {Module} */
+								let module;
 
-const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
-const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
+								/** @type {ExportsInfo} */
+								let exportsInfo;
 
-class DefinePlugin {
-	/**
-	 * Create a new define plugin
-	 * @param {Record<string, CodeValue>} definitions A map of global object definitions
-	 */
-	constructor(definitions) {
-		this.definitions = definitions;
-	}
+								/** @type {Map<Dependency, ExportsSpec>} */
+								const exportsSpecsFromDependencies = new Map();
 
-	/**
-	 * @param {function({ module: NormalModule, key: string, readonly version: string | undefined }): CodeValuePrimitive} fn generator function
-	 * @param {true | string[] | RuntimeValueOptions=} options options
-	 * @returns {RuntimeValue} runtime value
-	 */
-	static runtimeValue(fn, options) {
-		return new RuntimeValue(fn, options);
-	}
+								let cacheable = true;
+								let changed = false;
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const definitions = this.definitions;
-		compiler.hooks.compilation.tap(
-			"DefinePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
+								/**
+								 * @param {DependenciesBlock} depBlock the dependencies block
+								 * @returns {void}
+								 */
+								const processDependenciesBlock = depBlock => {
+									for (const dep of depBlock.dependencies) {
+										processDependency(dep);
+									}
+									for (const block of depBlock.blocks) {
+										processDependenciesBlock(block);
+									}
+								};
+
+								/**
+								 * @param {Dependency} dep the dependency
+								 * @returns {void}
+								 */
+								const processDependency = dep => {
+									const exportDesc = dep.getExports(moduleGraph);
+									if (!exportDesc) return;
+									exportsSpecsFromDependencies.set(dep, exportDesc);
+								};
+
+								/**
+								 * @param {Dependency} dep dependency
+								 * @param {ExportsSpec} exportDesc info
+								 * @returns {void}
+								 */
+								const processExportsSpec = (dep, exportDesc) => {
+									const exports = exportDesc.exports;
+									const globalCanMangle = exportDesc.canMangle;
+									const globalFrom = exportDesc.from;
+									const globalPriority = exportDesc.priority;
+									const globalTerminalBinding =
+										exportDesc.terminalBinding || false;
+									const exportDeps = exportDesc.dependencies;
+									if (exportDesc.hideExports) {
+										for (const name of exportDesc.hideExports) {
+											const exportInfo = exportsInfo.getExportInfo(name);
+											exportInfo.unsetTarget(dep);
+										}
+									}
+									if (exports === true) {
+										// unknown exports
+										if (
+											exportsInfo.setUnknownExportsProvided(
+												globalCanMangle,
+												exportDesc.excludeExports,
+												globalFrom && dep,
+												globalFrom,
+												globalPriority
+											)
+										) {
+											changed = true;
+										}
+									} else if (Array.isArray(exports)) {
+										/**
+										 * merge in new exports
+										 * @param {ExportsInfo} exportsInfo own exports info
+										 * @param {(ExportSpec | string)[]} exports list of exports
+										 */
+										const mergeExports = (exportsInfo, exports) => {
+											for (const exportNameOrSpec of exports) {
+												let name;
+												let canMangle = globalCanMangle;
+												let terminalBinding = globalTerminalBinding;
+												let exports = undefined;
+												let from = globalFrom;
+												let fromExport = undefined;
+												let priority = globalPriority;
+												let hidden = false;
+												if (typeof exportNameOrSpec === "string") {
+													name = exportNameOrSpec;
+												} else {
+													name = exportNameOrSpec.name;
+													if (exportNameOrSpec.canMangle !== undefined)
+														canMangle = exportNameOrSpec.canMangle;
+													if (exportNameOrSpec.export !== undefined)
+														fromExport = exportNameOrSpec.export;
+													if (exportNameOrSpec.exports !== undefined)
+														exports = exportNameOrSpec.exports;
+													if (exportNameOrSpec.from !== undefined)
+														from = exportNameOrSpec.from;
+													if (exportNameOrSpec.priority !== undefined)
+														priority = exportNameOrSpec.priority;
+													if (exportNameOrSpec.terminalBinding !== undefined)
+														terminalBinding = exportNameOrSpec.terminalBinding;
+													if (exportNameOrSpec.hidden !== undefined)
+														hidden = exportNameOrSpec.hidden;
+												}
+												const exportInfo = exportsInfo.getExportInfo(name);
+
+												if (
+													exportInfo.provided === false ||
+													exportInfo.provided === null
+												) {
+													exportInfo.provided = true;
+													changed = true;
+												}
+
+												if (
+													exportInfo.canMangleProvide !== false &&
+													canMangle === false
+												) {
+													exportInfo.canMangleProvide = false;
+													changed = true;
+												}
+
+												if (terminalBinding && !exportInfo.terminalBinding) {
+													exportInfo.terminalBinding = true;
+													changed = true;
+												}
+
+												if (exports) {
+													const nestedExportsInfo =
+														exportInfo.createNestedExportsInfo();
+													mergeExports(nestedExportsInfo, exports);
+												}
+
+												if (
+													from &&
+													(hidden
+														? exportInfo.unsetTarget(dep)
+														: exportInfo.setTarget(
+																dep,
+																from,
+																fromExport === undefined ? [name] : fromExport,
+																priority
+														  ))
+												) {
+													changed = true;
+												}
+
+												// Recalculate target exportsInfo
+												const target = exportInfo.getTarget(moduleGraph);
+												let targetExportsInfo = undefined;
+												if (target) {
+													const targetModuleExportsInfo =
+														moduleGraph.getExportsInfo(target.module);
+													targetExportsInfo =
+														targetModuleExportsInfo.getNestedExportsInfo(
+															target.export
+														);
+													// add dependency for this module
+													const set = dependencies.get(target.module);
+													if (set === undefined) {
+														dependencies.set(target.module, new Set([module]));
+													} else {
+														set.add(module);
+													}
+												}
+
+												if (exportInfo.exportsInfoOwned) {
+													if (
+														exportInfo.exportsInfo.setRedirectNamedTo(
+															targetExportsInfo
+														)
+													) {
+														changed = true;
+													}
+												} else if (
+													exportInfo.exportsInfo !== targetExportsInfo
+												) {
+													exportInfo.exportsInfo = targetExportsInfo;
+													changed = true;
+												}
+											}
+										};
+										mergeExports(exportsInfo, exports);
+									}
+									// store dependencies
+									if (exportDeps) {
+										cacheable = false;
+										for (const exportDependency of exportDeps) {
+											// add dependency for this module
+											const set = dependencies.get(exportDependency);
+											if (set === undefined) {
+												dependencies.set(exportDependency, new Set([module]));
+											} else {
+												set.add(module);
+											}
+										}
+									}
+								};
+
+								const notifyDependencies = () => {
+									const deps = dependencies.get(module);
+									if (deps !== undefined) {
+										for (const dep of deps) {
+											queue.enqueue(dep);
+										}
+									}
+								};
+
+								logger.time("figure out provided exports");
+								while (queue.length > 0) {
+									module = queue.dequeue();
+
+									statQueueItemsProcessed++;
+
+									exportsInfo = moduleGraph.getExportsInfo(module);
+
+									cacheable = true;
+									changed = false;
+
+									exportsSpecsFromDependencies.clear();
+									moduleGraph.freeze();
+									processDependenciesBlock(module);
+									moduleGraph.unfreeze();
+									for (const [
+										dep,
+										exportsSpec
+									] of exportsSpecsFromDependencies) {
+										processExportsSpec(dep, exportsSpec);
+									}
+
+									if (cacheable) {
+										modulesToStore.add(module);
+									}
+
+									if (changed) {
+										notifyDependencies();
+									}
+								}
+								logger.timeEnd("figure out provided exports");
+
+								logger.log(
+									`${Math.round(
+										(100 * (statFlaggedUncached + statNotCached)) /
+											(statRestoredFromMemCache +
+												statRestoredFromCache +
+												statNotCached +
+												statFlaggedUncached +
+												statNoExports)
+									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${
+										statQueueItemsProcessed -
+										statNotCached -
+										statFlaggedUncached
+									} additional calculations due to dependencies)`
+								);
+
+								logger.time("store provided exports into cache");
+								asyncLib.each(
+									modulesToStore,
+									(module, callback) => {
+										if (typeof module.buildInfo.hash !== "string") {
+											// not cacheable
+											return callback();
+										}
+										const cachedData = moduleGraph
+											.getExportsInfo(module)
+											.getRestoreProvidedData();
+										const memCache =
+											moduleMemCaches && moduleMemCaches.get(module);
+										if (memCache) {
+											memCache.set(this, cachedData);
+										}
+										cache.store(
+											module.identifier(),
+											module.buildInfo.hash,
+											cachedData,
+											callback
+										);
+									},
+									err => {
+										logger.timeEnd("store provided exports into cache");
+										callback(err);
+									}
+								);
+							}
+						);
+					}
 				);
-				const { runtimeTemplate } = compilation;
 
-				const mainHash = createHash(compilation.outputOptions.hashFunction);
-				mainHash.update(
-					/** @type {string} */ (
-						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
-					) || ""
+				/** @type {WeakMap<Module, any>} */
+				const providedExportsCache = new WeakMap();
+				compilation.hooks.rebuildModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						providedExportsCache.set(
+							module,
+							moduleGraph.getExportsInfo(module).getRestoreProvidedData()
+						);
+					}
+				);
+				compilation.hooks.finishRebuildingModule.tap(
+					"FlagDependencyExportsPlugin",
+					module => {
+						moduleGraph
+							.getExportsInfo(module)
+							.restoreProvided(providedExportsCache.get(module));
+					}
 				);
+			}
+		);
+	}
+}
 
-				/**
-				 * Handler
-				 * @param {JavascriptParser} parser Parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
-					parser.hooks.program.tap("DefinePlugin", () => {
-						const { buildInfo } = parser.state.module;
-						if (!buildInfo.valueDependencies)
-							buildInfo.valueDependencies = new Map();
-						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
-					});
+module.exports = FlagDependencyExportsPlugin;
 
-					const addValueDependency = key => {
-						const { buildInfo } = parser.state.module;
-						buildInfo.valueDependencies.set(
-							VALUE_DEP_PREFIX + key,
-							compilation.valueCacheVersions.get(VALUE_DEP_PREFIX + key)
+
+/***/ }),
+
+/***/ 58812:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const { UsageState } = __webpack_require__(63686);
+const ModuleGraphConnection = __webpack_require__(40639);
+const { STAGE_DEFAULT } = __webpack_require__(80057);
+const ArrayQueue = __webpack_require__(41792);
+const TupleQueue = __webpack_require__(38415);
+const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
+
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency;
+
+class FlagDependencyUsagePlugin {
+	/**
+	 * @param {boolean} global do a global analysis instead of per runtime
+	 */
+	constructor(global) {
+		this.global = global;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("FlagDependencyUsagePlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			compilation.hooks.optimizeDependencies.tap(
+				{
+					name: "FlagDependencyUsagePlugin",
+					stage: STAGE_DEFAULT
+				},
+				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
 						);
-					};
+					}
 
-					const withValueDependency =
-						(key, fn) =>
-						(...args) => {
-							addValueDependency(key);
-							return fn(...args);
-						};
+					const logger = compilation.getLogger(
+						"webpack.FlagDependencyUsagePlugin"
+					);
+					/** @type {Map<ExportsInfo, Module>} */
+					const exportInfoToModuleMap = new Map();
+
+					/** @type {TupleQueue<[Module, RuntimeSpec]>} */
+					const queue = new TupleQueue();
 
 					/**
-					 * Walk definitions
-					 * @param {Object} definitions Definitions map
-					 * @param {string} prefix Prefix string
+					 * @param {Module} module module to process
+					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
+					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const walkDefinitions = (definitions, prefix) => {
-						Object.keys(definitions).forEach(key => {
-							const code = definitions[key];
+					const processReferencedModule = (
+						module,
+						usedExports,
+						runtime,
+						forceSideEffects
+					) => {
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						if (usedExports.length > 0) {
+							if (!module.buildMeta || !module.buildMeta.exportsType) {
+								if (exportsInfo.setUsedWithoutInfo(runtime)) {
+									queue.enqueue(module, runtime);
+								}
+								return;
+							}
+							for (const usedExportInfo of usedExports) {
+								let usedExport;
+								let canMangle = true;
+								if (Array.isArray(usedExportInfo)) {
+									usedExport = usedExportInfo;
+								} else {
+									usedExport = usedExportInfo.name;
+									canMangle = usedExportInfo.canMangle !== false;
+								}
+								if (usedExport.length === 0) {
+									if (exportsInfo.setUsedInUnknownWay(runtime)) {
+										queue.enqueue(module, runtime);
+									}
+								} else {
+									let currentExportsInfo = exportsInfo;
+									for (let i = 0; i < usedExport.length; i++) {
+										const exportInfo = currentExportsInfo.getExportInfo(
+											usedExport[i]
+										);
+										if (canMangle === false) {
+											exportInfo.canMangleUse = false;
+										}
+										const lastOne = i === usedExport.length - 1;
+										if (!lastOne) {
+											const nestedInfo = exportInfo.getNestedExportsInfo();
+											if (nestedInfo) {
+												if (
+													exportInfo.setUsedConditionally(
+														used => used === UsageState.Unused,
+														UsageState.OnlyPropertiesUsed,
+														runtime
+													)
+												) {
+													const currentModule =
+														currentExportsInfo === exportsInfo
+															? module
+															: exportInfoToModuleMap.get(currentExportsInfo);
+													if (currentModule) {
+														queue.enqueue(currentModule, runtime);
+													}
+												}
+												currentExportsInfo = nestedInfo;
+												continue;
+											}
+										}
+										if (
+											exportInfo.setUsedConditionally(
+												v => v !== UsageState.Used,
+												UsageState.Used,
+												runtime
+											)
+										) {
+											const currentModule =
+												currentExportsInfo === exportsInfo
+													? module
+													: exportInfoToModuleMap.get(currentExportsInfo);
+											if (currentModule) {
+												queue.enqueue(currentModule, runtime);
+											}
+										}
+										break;
+									}
+								}
+							}
+						} else {
+							// for a module without side effects we stop tracking usage here when no export is used
+							// This module won't be evaluated in this case
+							// TODO webpack 6 remove this check
 							if (
-								code &&
-								typeof code === "object" &&
-								!(code instanceof RuntimeValue) &&
-								!(code instanceof RegExp)
+								!forceSideEffects &&
+								module.factoryMeta !== undefined &&
+								module.factoryMeta.sideEffectFree
 							) {
-								walkDefinitions(code, prefix + key + ".");
-								applyObjectDefine(prefix + key, code);
 								return;
 							}
-							applyDefineKey(prefix, key);
-							applyDefine(prefix + key, code);
-						});
+							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
+								queue.enqueue(module, runtime);
+							}
+						}
 					};
 
 					/**
-					 * Apply define key
-					 * @param {string} prefix Prefix
-					 * @param {string} key Key
-					 * @returns {void}
-					 */
-					const applyDefineKey = (prefix, key) => {
-						const splittedKey = key.split(".");
-						splittedKey.slice(1).forEach((_, i) => {
-							const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
-							parser.hooks.canRename.for(fullKey).tap("DefinePlugin", () => {
-								addValueDependency(key);
-								return true;
-							});
-						});
-					};
-
-					/**
-					 * Apply Code
-					 * @param {string} key Key
-					 * @param {CodeValue} code Code
+					 * @param {DependenciesBlock} module the module
+					 * @param {RuntimeSpec} runtime part of which runtime
+					 * @param {boolean} forceSideEffects always apply side effects
 					 * @returns {void}
 					 */
-					const applyDefine = (key, code) => {
-						const originalKey = key;
-						const isTypeof = /^typeof\s+/.test(key);
-						if (isTypeof) key = key.replace(/^typeof\s+/, "");
-						let recurse = false;
-						let recurseTypeof = false;
-						if (!isTypeof) {
-							parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
-								addValueDependency(originalKey);
-								return true;
-							});
-							parser.hooks.evaluateIdentifier
-								.for(key)
-								.tap("DefinePlugin", expr => {
-									/**
-									 * this is needed in case there is a recursion in the DefinePlugin
-									 * to prevent an endless recursion
-									 * e.g.: new DefinePlugin({
-									 * "a": "b",
-									 * "b": "a"
-									 * });
-									 */
-									if (recurse) return;
-									addValueDependency(originalKey);
-									recurse = true;
-									const res = parser.evaluate(
-										toCode(
-											code,
-											parser,
-											compilation.valueCacheVersions,
-											key,
-											runtimeTemplate,
-											null
-										)
+					const processModule = (module, runtime, forceSideEffects) => {
+						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
+						const map = new Map();
+
+						/** @type {ArrayQueue<DependenciesBlock>} */
+						const queue = new ArrayQueue();
+						queue.enqueue(module);
+						for (;;) {
+							const block = queue.dequeue();
+							if (block === undefined) break;
+							for (const b of block.blocks) {
+								if (
+									!this.global &&
+									b.groupOptions &&
+									b.groupOptions.entryOptions
+								) {
+									processModule(
+										b,
+										b.groupOptions.entryOptions.runtime || undefined,
+										true
 									);
-									recurse = false;
-									res.setRange(expr.range);
-									return res;
-								});
-							parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
-								addValueDependency(originalKey);
-								const strCode = toCode(
-									code,
-									parser,
-									compilation.valueCacheVersions,
-									originalKey,
-									runtimeTemplate,
-									!parser.isAsiPosition(expr.range[0])
-								);
-								if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
-									return toConstantDependency(parser, strCode, [
-										RuntimeGlobals.require
-									])(expr);
-								} else if (/__webpack_require__/.test(strCode)) {
-									return toConstantDependency(parser, strCode, [
-										RuntimeGlobals.requireScope
-									])(expr);
 								} else {
-									return toConstantDependency(parser, strCode)(expr);
+									queue.enqueue(b);
 								}
-							});
+							}
+							for (const dep of block.dependencies) {
+								const connection = moduleGraph.getConnection(dep);
+								if (!connection || !connection.module) {
+									continue;
+								}
+								const activeState = connection.getActiveState(runtime);
+								if (activeState === false) continue;
+								const { module } = connection;
+								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
+									processModule(module, runtime, false);
+									continue;
+								}
+								const oldReferencedExports = map.get(module);
+								if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
+									continue;
+								}
+								const referencedExports =
+									compilation.getDependencyReferencedExports(dep, runtime);
+								if (
+									oldReferencedExports === undefined ||
+									oldReferencedExports === NO_EXPORTS_REFERENCED ||
+									referencedExports === EXPORTS_OBJECT_REFERENCED
+								) {
+									map.set(module, referencedExports);
+								} else if (
+									oldReferencedExports !== undefined &&
+									referencedExports === NO_EXPORTS_REFERENCED
+								) {
+									continue;
+								} else {
+									let exportsMap;
+									if (Array.isArray(oldReferencedExports)) {
+										exportsMap = new Map();
+										for (const item of oldReferencedExports) {
+											if (Array.isArray(item)) {
+												exportsMap.set(item.join("\n"), item);
+											} else {
+												exportsMap.set(item.name.join("\n"), item);
+											}
+										}
+										map.set(module, exportsMap);
+									} else {
+										exportsMap = oldReferencedExports;
+									}
+									for (const item of referencedExports) {
+										if (Array.isArray(item)) {
+											const key = item.join("\n");
+											const oldItem = exportsMap.get(key);
+											if (oldItem === undefined) {
+												exportsMap.set(key, item);
+											}
+											// if oldItem is already an array we have to do nothing
+											// if oldItem is an ReferencedExport object, we don't have to do anything
+											// as canMangle defaults to true for arrays
+										} else {
+											const key = item.name.join("\n");
+											const oldItem = exportsMap.get(key);
+											if (oldItem === undefined || Array.isArray(oldItem)) {
+												exportsMap.set(key, item);
+											} else {
+												exportsMap.set(key, {
+													name: item.name,
+													canMangle: item.canMangle && oldItem.canMangle
+												});
+											}
+										}
+									}
+								}
+							}
 						}
-						parser.hooks.evaluateTypeof.for(key).tap("DefinePlugin", expr => {
-							/**
-							 * this is needed in case there is a recursion in the DefinePlugin
-							 * to prevent an endless recursion
-							 * e.g.: new DefinePlugin({
-							 * "typeof a": "typeof b",
-							 * "typeof b": "typeof a"
-							 * });
-							 */
-							if (recurseTypeof) return;
-							recurseTypeof = true;
-							addValueDependency(originalKey);
-							const codeCode = toCode(
-								code,
-								parser,
-								compilation.valueCacheVersions,
-								originalKey,
-								runtimeTemplate,
-								null
-							);
-							const typeofCode = isTypeof
-								? codeCode
-								: "typeof (" + codeCode + ")";
-							const res = parser.evaluate(typeofCode);
-							recurseTypeof = false;
-							res.setRange(expr.range);
-							return res;
-						});
-						parser.hooks.typeof.for(key).tap("DefinePlugin", expr => {
-							addValueDependency(originalKey);
-							const codeCode = toCode(
-								code,
-								parser,
-								compilation.valueCacheVersions,
-								originalKey,
-								runtimeTemplate,
-								null
-							);
-							const typeofCode = isTypeof
-								? codeCode
-								: "typeof (" + codeCode + ")";
-							const res = parser.evaluate(typeofCode);
-							if (!res.isString()) return;
-							return toConstantDependency(
-								parser,
-								JSON.stringify(res.string)
-							).bind(parser)(expr);
-						});
-					};
-
-					/**
-					 * Apply Object
-					 * @param {string} key Key
-					 * @param {Object} obj Object
-					 * @returns {void}
-					 */
-					const applyObjectDefine = (key, obj) => {
-						parser.hooks.canRename.for(key).tap("DefinePlugin", () => {
-							addValueDependency(key);
-							return true;
-						});
-						parser.hooks.evaluateIdentifier
-							.for(key)
-							.tap("DefinePlugin", expr => {
-								addValueDependency(key);
-								return new BasicEvaluatedExpression()
-									.setTruthy()
-									.setSideEffects(false)
-									.setRange(expr.range);
-							});
-						parser.hooks.evaluateTypeof
-							.for(key)
-							.tap(
-								"DefinePlugin",
-								withValueDependency(key, evaluateToString("object"))
-							);
-						parser.hooks.expression.for(key).tap("DefinePlugin", expr => {
-							addValueDependency(key);
-							const strCode = stringifyObj(
-								obj,
-								parser,
-								compilation.valueCacheVersions,
-								key,
-								runtimeTemplate,
-								!parser.isAsiPosition(expr.range[0])
-							);
 
-							if (/__webpack_require__\s*(!?\.)/.test(strCode)) {
-								return toConstantDependency(parser, strCode, [
-									RuntimeGlobals.require
-								])(expr);
-							} else if (/__webpack_require__/.test(strCode)) {
-								return toConstantDependency(parser, strCode, [
-									RuntimeGlobals.requireScope
-								])(expr);
+						for (const [module, referencedExports] of map) {
+							if (Array.isArray(referencedExports)) {
+								processReferencedModule(
+									module,
+									referencedExports,
+									runtime,
+									forceSideEffects
+								);
 							} else {
-								return toConstantDependency(parser, strCode)(expr);
+								processReferencedModule(
+									module,
+									Array.from(referencedExports.values()),
+									runtime,
+									forceSideEffects
+								);
 							}
-						});
-						parser.hooks.typeof
-							.for(key)
-							.tap(
-								"DefinePlugin",
-								withValueDependency(
-									key,
-									toConstantDependency(parser, JSON.stringify("object"))
-								)
-							);
+						}
 					};
 
-					walkDefinitions(definitions, "");
-				};
+					logger.time("initialize exports usage");
+					for (const module of modules) {
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						exportInfoToModuleMap.set(exportsInfo, module);
+						exportsInfo.setHasUseInfo();
+					}
+					logger.timeEnd("initialize exports usage");
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("DefinePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("DefinePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("DefinePlugin", handler);
+					logger.time("trace exports usage in graph");
 
-				/**
-				 * Walk definitions
-				 * @param {Object} definitions Definitions map
-				 * @param {string} prefix Prefix string
-				 * @returns {void}
-				 */
-				const walkDefinitionsForValues = (definitions, prefix) => {
-					Object.keys(definitions).forEach(key => {
-						const code = definitions[key];
-						const version = toCacheVersion(code);
-						const name = VALUE_DEP_PREFIX + prefix + key;
-						mainHash.update("|" + prefix + key);
-						const oldVersion = compilation.valueCacheVersions.get(name);
-						if (oldVersion === undefined) {
-							compilation.valueCacheVersions.set(name, version);
-						} else if (oldVersion !== version) {
-							const warning = new WebpackError(
-								`DefinePlugin\nConflicting values for '${prefix + key}'`
+					/**
+					 * @param {Dependency} dep dependency
+					 * @param {RuntimeSpec} runtime runtime
+					 */
+					const processEntryDependency = (dep, runtime) => {
+						const module = moduleGraph.getModule(dep);
+						if (module) {
+							processReferencedModule(
+								module,
+								NO_EXPORTS_REFERENCED,
+								runtime,
+								true
 							);
-							warning.details = `'${oldVersion}' !== '${version}'`;
-							warning.hideStack = true;
-							compilation.warnings.push(warning);
 						}
-						if (
-							code &&
-							typeof code === "object" &&
-							!(code instanceof RuntimeValue) &&
-							!(code instanceof RegExp)
-						) {
-							walkDefinitionsForValues(code, prefix + key + ".");
+					};
+					/** @type {RuntimeSpec} */
+					let globalRuntime = undefined;
+					for (const [
+						entryName,
+						{ dependencies: deps, includeDependencies: includeDeps, options }
+					] of compilation.entries) {
+						const runtime = this.global
+							? undefined
+							: getEntryRuntime(compilation, entryName, options);
+						for (const dep of deps) {
+							processEntryDependency(dep, runtime);
 						}
-					});
-				};
-
-				walkDefinitionsForValues(definitions, "");
+						for (const dep of includeDeps) {
+							processEntryDependency(dep, runtime);
+						}
+						globalRuntime = mergeRuntimeOwned(globalRuntime, runtime);
+					}
+					for (const dep of compilation.globalEntry.dependencies) {
+						processEntryDependency(dep, globalRuntime);
+					}
+					for (const dep of compilation.globalEntry.includeDependencies) {
+						processEntryDependency(dep, globalRuntime);
+					}
 
-				compilation.valueCacheVersions.set(
-					VALUE_DEP_MAIN,
-					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
-				);
-			}
-		);
+					while (queue.length) {
+						const [module, runtime] = queue.dequeue();
+						processModule(module, runtime, false);
+					}
+					logger.timeEnd("trace exports usage in graph");
+				}
+			);
+		});
 	}
 }
-module.exports = DefinePlugin;
+
+module.exports = FlagDependencyUsagePlugin;
 
 
 /***/ }),
 
-/***/ 28623:
+/***/ 93401:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -39118,244 +41395,153 @@ module.exports = DefinePlugin;
 
 
 
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const DelegatedSourceDependency = __webpack_require__(22914);
-const StaticExportsDependency = __webpack_require__(91418);
-const makeSerializable = __webpack_require__(33032);
-
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./LibManifestPlugin").ManifestModuleData} ManifestModuleData */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceContext} SourceContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./NormalModule")} NormalModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
 /** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([
-	RuntimeGlobals.module,
-	RuntimeGlobals.require
-]);
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-class DelegatedModule extends Module {
-	constructor(sourceRequest, data, type, userRequest, originalRequest) {
-		super("javascript/dynamic", null);
+/**
+ * @typedef {Object} GenerateContext
+ * @property {DependencyTemplates} dependencyTemplates mapping from dependencies to templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {Set<string>} runtimeRequirements the requirements for runtime
+ * @property {RuntimeSpec} runtime the runtime
+ * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults=} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
+ * @property {string} type which kind of code should be generated
+ * @property {function(): Map<string, any>=} getData get access to the code generation data
+ */
 
-		// Info from Factory
-		this.sourceRequest = sourceRequest;
-		this.request = data.id;
-		this.delegationType = type;
-		this.userRequest = userRequest;
-		this.originalRequest = originalRequest;
-		/** @type {ManifestModuleData} */
-		this.delegateData = data;
+/**
+ * @typedef {Object} UpdateHashContext
+ * @property {NormalModule} module the module
+ * @property {ChunkGraph} chunkGraph
+ * @property {RuntimeSpec} runtime
+ */
 
-		// Build info
-		this.delegatedSourceDependency = undefined;
+/**
+ *
+ */
+class Generator {
+	static byType(map) {
+		return new ByTypeGenerator(map);
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @abstract
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	getSourceTypes() {
-		return TYPES;
+	getTypes(module) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @abstract
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	libIdent(options) {
-		return typeof this.originalRequest === "string"
-			? this.originalRequest
-			: this.originalRequest.libIdent(options);
+	getSize(module, type) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @abstract
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	identifier() {
-		return `delegated ${JSON.stringify(this.request)} from ${
-			this.sourceRequest
-		}`;
+	generate(
+		module,
+		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
+	) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
-	readableIdentifier(requestShortener) {
-		return `delegated ${this.userRequest} from ${this.sourceRequest}`;
-	}
-
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
-	}
-
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = { ...this.delegateData.buildMeta };
-		this.buildInfo = {};
-		this.dependencies.length = 0;
-		this.delegatedSourceDependency = new DelegatedSourceDependency(
-			this.sourceRequest
-		);
-		this.addDependency(this.delegatedSourceDependency);
-		this.addDependency(
-			new StaticExportsDependency(this.delegateData.exports || true, false)
-		);
-		callback();
+	getConcatenationBailoutReason(module, context) {
+		return `Module Concatenation is not implemented for ${this.constructor.name}`;
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const dep = /** @type {DelegatedSourceDependency} */ (this.dependencies[0]);
-		const sourceModule = moduleGraph.getModule(dep);
-		let str;
-
-		if (!sourceModule) {
-			str = runtimeTemplate.throwMissingModuleErrorBlock({
-				request: this.sourceRequest
-			});
-		} else {
-			str = `module.exports = (${runtimeTemplate.moduleExports({
-				module: sourceModule,
-				chunkGraph,
-				request: dep.request,
-				runtimeRequirements: new Set()
-			})})`;
-
-			switch (this.delegationType) {
-				case "require":
-					str += `(${JSON.stringify(this.request)})`;
-					break;
-				case "object":
-					str += `[${JSON.stringify(this.request)}]`;
-					break;
-			}
-
-			str += ";";
-		}
-
-		const sources = new Map();
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			sources.set("javascript", new OriginalSource(str, this.identifier()));
-		} else {
-			sources.set("javascript", new RawSource(str));
-		}
-
-		return {
-			sources,
-			runtimeRequirements: RUNTIME_REQUIREMENTS
-		};
+	updateHash(hash, { module, runtime }) {
+		// no nothing
 	}
+}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 42;
+class ByTypeGenerator extends Generator {
+	constructor(map) {
+		super();
+		this.map = map;
+		this._types = new Set(Object.keys(map));
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	updateHash(hash, context) {
-		hash.update(this.delegationType);
-		hash.update(JSON.stringify(this.request));
-		super.updateHash(hash, context);
-	}
-
-	serialize(context) {
-		const { write } = context;
-		// constructor
-		write(this.sourceRequest);
-		write(this.delegateData);
-		write(this.delegationType);
-		write(this.userRequest);
-		write(this.originalRequest);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new DelegatedModule(
-			read(), // sourceRequest
-			read(), // delegateData
-			read(), // delegationType
-			read(), // userRequest
-			read() // originalRequest
-		);
-		obj.deserialize(context);
-		return obj;
+	getTypes(module) {
+		return this._types;
 	}
 
 	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {DelegatedModule} */ (module);
-		this.delegationType = m.delegationType;
-		this.userRequest = m.userRequest;
-		this.originalRequest = m.originalRequest;
-		this.delegateData = m.delegateData;
+	getSize(module, type) {
+		const t = type || "javascript";
+		const generator = this.map[t];
+		return generator ? generator.getSize(module, t) : 0;
 	}
 
 	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.delegateData = undefined;
+	generate(module, generateContext) {
+		const type = generateContext.type;
+		const generator = this.map[type];
+		if (!generator) {
+			throw new Error(`Generator.byType: no generator specified for ${type}`);
+		}
+		return generator.generate(module, generateContext);
 	}
 }
 
-makeSerializable(DelegatedModule, "webpack/lib/DelegatedModule");
-
-module.exports = DelegatedModule;
+module.exports = Generator;
 
 
 /***/ }),
 
-/***/ 51387:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 37234:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -39365,261 +41551,166 @@ module.exports = DelegatedModule;
 
 
 
-const DelegatedModule = __webpack_require__(28623);
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Module")} Module */
 
-// options.source
-// options.type
-// options.context
-// options.scope
-// options.content
-// options.associatedObjectForCache
-class DelegatedModuleFactoryPlugin {
-	constructor(options) {
-		this.options = options;
-		options.type = options.type || "require";
-		options.extensions = options.extensions || ["", ".js", ".json", ".wasm"];
+/**
+ * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
+ * @param {Chunk} chunk chunk to tie to ChunkGroup
+ * @returns {void}
+ */
+const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
+	if (chunkGroup.pushChunk(chunk)) {
+		chunk.addGroup(chunkGroup);
 	}
+};
 
-	apply(normalModuleFactory) {
-		const scope = this.options.scope;
-		if (scope) {
-			normalModuleFactory.hooks.factorize.tapAsync(
-				"DelegatedModuleFactoryPlugin",
-				(data, callback) => {
-					const [dependency] = data.dependencies;
-					const { request } = dependency;
-					if (request && request.startsWith(`${scope}/`)) {
-						const innerRequest = "." + request.substr(scope.length);
-						let resolved;
-						if (innerRequest in this.options.content) {
-							resolved = this.options.content[innerRequest];
-							return callback(
-								null,
-								new DelegatedModule(
-									this.options.source,
-									resolved,
-									this.options.type,
-									innerRequest,
-									request
-								)
-							);
-						}
-						for (let i = 0; i < this.options.extensions.length; i++) {
-							const extension = this.options.extensions[i];
-							const requestPlusExt = innerRequest + extension;
-							if (requestPlusExt in this.options.content) {
-								resolved = this.options.content[requestPlusExt];
-								return callback(
-									null,
-									new DelegatedModule(
-										this.options.source,
-										resolved,
-										this.options.type,
-										requestPlusExt,
-										request + extension
-									)
-								);
-							}
-						}
-					}
-					return callback();
-				}
-			);
-		} else {
-			normalModuleFactory.hooks.module.tap(
-				"DelegatedModuleFactoryPlugin",
-				module => {
-					const request = module.libIdent(this.options);
-					if (request) {
-						if (request in this.options.content) {
-							const resolved = this.options.content[request];
-							return new DelegatedModule(
-								this.options.source,
-								resolved,
-								this.options.type,
-								request,
-								module
-							);
-						}
-					}
-					return module;
-				}
-			);
-		}
+/**
+ * @param {ChunkGroup} parent parent ChunkGroup to connect
+ * @param {ChunkGroup} child child ChunkGroup to connect
+ * @returns {void}
+ */
+const connectChunkGroupParentAndChild = (parent, child) => {
+	if (parent.addChild(child)) {
+		child.addParent(parent);
 	}
-}
-module.exports = DelegatedModuleFactoryPlugin;
+};
+
+exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
+exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;
 
 
 /***/ }),
 
-/***/ 80632:
+/***/ 97511:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
-const DelegatedSourceDependency = __webpack_require__(22914);
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class DelegatedPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DelegatedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					DelegatedSourceDependency,
-					normalModuleFactory
-				);
-			}
-		);
+const WebpackError = __webpack_require__(53799);
 
-		compiler.hooks.compile.tap("DelegatedPlugin", ({ normalModuleFactory }) => {
-			new DelegatedModuleFactoryPlugin({
-				associatedObjectForCache: compiler.root,
-				...this.options
-			}).apply(normalModuleFactory);
-		});
+module.exports = class HarmonyLinkingError extends WebpackError {
+	/** @param {string} message Error message */
+	constructor(message) {
+		super(message);
+		this.name = "HarmonyLinkingError";
+		this.hideStack = true;
 	}
-}
-
-module.exports = DelegatedPlugin;
+};
 
 
 /***/ }),
 
-/***/ 71040:
+/***/ 11351:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./util/Hash")} Hash */
-
-/** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
+const WebpackError = __webpack_require__(53799);
 
-class DependenciesBlock {
-	constructor() {
-		/** @type {Dependency[]} */
-		this.dependencies = [];
-		/** @type {AsyncDependenciesBlock[]} */
-		this.blocks = [];
-		/** @type {DependenciesBlock} */
-		this.parent = undefined;
-	}
+/** @typedef {import("./Module")} Module */
 
-	getRootBlock() {
-		/** @type {DependenciesBlock} */
-		let current = this;
-		while (current.parent) current = current.parent;
-		return current;
-	}
+/**
+ * @template T
+ * @callback Callback
+ * @param {Error=} err
+ * @param {T=} stats
+ * @returns {void}
+ */
 
+class HookWebpackError extends WebpackError {
 	/**
-	 * Adds a DependencyBlock to DependencyBlock relationship.
-	 * This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)
-	 *
-	 * @param {AsyncDependenciesBlock} block block being added
-	 * @returns {void}
+	 * Creates an instance of HookWebpackError.
+	 * @param {Error} error inner error
+	 * @param {string} hook name of hook
 	 */
-	addBlock(block) {
-		this.blocks.push(block);
-		block.parent = this;
-	}
+	constructor(error, hook) {
+		super(error.message);
 
-	/**
-	 * @param {Dependency} dependency dependency being tied to block.
-	 * This is an "edge" pointing to another "node" on module graph.
-	 * @returns {void}
-	 */
-	addDependency(dependency) {
-		this.dependencies.push(dependency);
-	}
+		this.name = "HookWebpackError";
+		this.hook = hook;
+		this.error = error;
+		this.hideStack = true;
+		this.details = `caused by plugins in ${hook}\n${error.stack}`;
 
-	/**
-	 * @param {Dependency} dependency dependency being removed
-	 * @returns {void}
-	 */
-	removeDependency(dependency) {
-		const idx = this.dependencies.indexOf(dependency);
-		if (idx >= 0) {
-			this.dependencies.splice(idx, 1);
-		}
+		this.stack += `\n-- inner error --\n${error.stack}`;
 	}
+}
 
-	/**
-	 * Removes all dependencies and blocks
-	 * @returns {void}
-	 */
-	clearDependenciesAndBlocks() {
-		this.dependencies.length = 0;
-		this.blocks.length = 0;
-	}
+module.exports = HookWebpackError;
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		for (const dep of this.dependencies) {
-			dep.updateHash(hash, context);
-		}
-		for (const block of this.blocks) {
-			block.updateHash(hash, context);
+/**
+ * @param {Error} error an error
+ * @param {string} hook name of the hook
+ * @returns {WebpackError} a webpack error
+ */
+const makeWebpackError = (error, hook) => {
+	if (error instanceof WebpackError) return error;
+	return new HookWebpackError(error, hook);
+};
+module.exports.makeWebpackError = makeWebpackError;
+
+/**
+ * @template T
+ * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
+ * @param {string} hook name of hook
+ * @returns {Callback<T>} generic callback
+ */
+const makeWebpackErrorCallback = (callback, hook) => {
+	return (err, result) => {
+		if (err) {
+			if (err instanceof WebpackError) {
+				callback(err);
+				return;
+			}
+			callback(new HookWebpackError(err, hook));
+			return;
 		}
-	}
+		callback(null, result);
+	};
+};
 
-	serialize({ write }) {
-		write(this.dependencies);
-		write(this.blocks);
-	}
+module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
 
-	deserialize({ read }) {
-		this.dependencies = read();
-		this.blocks = read();
-		for (const block of this.blocks) {
-			block.parent = this;
+/**
+ * @template T
+ * @param {function(): T} fn function which will be wrapping in try catch
+ * @param {string} hook name of hook
+ * @returns {T} the result
+ */
+const tryRunOrWebpackError = (fn, hook) => {
+	let r;
+	try {
+		r = fn();
+	} catch (err) {
+		if (err instanceof WebpackError) {
+			throw err;
 		}
+		throw new HookWebpackError(err, hook);
 	}
-}
-
-makeSerializable(DependenciesBlock, "webpack/lib/DependenciesBlock");
+	return r;
+};
 
-module.exports = DependenciesBlock;
+module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
 
 
 /***/ }),
 
-/***/ 54912:
+/***/ 6404:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -39630,352 +41721,782 @@ module.exports = DependenciesBlock;
 
 
 
-const memoize = __webpack_require__(78676);
+const { SyncBailHook } = __webpack_require__(6967);
+const { RawSource } = __webpack_require__(51255);
+const ChunkGraph = __webpack_require__(64971);
+const Compilation = __webpack_require__(85720);
+const HotUpdateChunk = __webpack_require__(9597);
+const NormalModule = __webpack_require__(39);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const ConstDependency = __webpack_require__(76911);
+const ImportMetaHotAcceptDependency = __webpack_require__(51274);
+const ImportMetaHotDeclineDependency = __webpack_require__(53141);
+const ModuleHotAcceptDependency = __webpack_require__(47511);
+const ModuleHotDeclineDependency = __webpack_require__(86301);
+const HotModuleReplacementRuntimeModule = __webpack_require__(27899);
+const JavascriptParser = __webpack_require__(29050);
+const {
+	evaluateToIdentifier
+} = __webpack_require__(93998);
+const { find, isSubset } = __webpack_require__(93347);
+const TupleSet = __webpack_require__(76455);
+const { compareModulesById } = __webpack_require__(29579);
+const {
+	getRuntimeKey,
+	keyToRuntime,
+	forEachRuntime,
+	mergeRuntimeOwned,
+	subtractRuntime,
+	intersectRuntime
+} = __webpack_require__(17156);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} UpdateHashContext
- * @property {ChunkGraph} chunkGraph
- * @property {RuntimeSpec} runtime
- * @property {RuntimeTemplate=} runtimeTemplate
- */
-
-/**
- * @typedef {Object} SourcePosition
- * @property {number} line
- * @property {number=} column
- */
-
-/**
- * @typedef {Object} RealDependencyLocation
- * @property {SourcePosition} start
- * @property {SourcePosition=} end
- * @property {number=} index
- */
-
-/**
- * @typedef {Object} SyntheticDependencyLocation
- * @property {string} name
- * @property {number=} index
- */
-
-/** @typedef {SyntheticDependencyLocation|RealDependencyLocation} DependencyLocation */
-
-/**
- * @typedef {Object} ExportSpec
- * @property {string} name the name of the export
- * @property {boolean=} canMangle can the export be renamed (defaults to true)
- * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts
- * @property {(string | ExportSpec)[]=} exports nested exports
- * @property {ModuleGraphConnection=} from when reexported: from which module
- * @property {string[] | null=} export when reexported: from which export
- * @property {number=} priority when reexported: with which priority
- * @property {boolean=} hidden export is not visible, because another export blends over it
- */
-
-/**
- * @typedef {Object} ExportsSpec
- * @property {(string | ExportSpec)[] | true | null} exports exported names, true for unknown exports or null for no exports
- * @property {Set<string>=} excludeExports when exports = true, list of unaffected exports
- * @property {Set<string>=} hideExports list of maybe prior exposed, but now hidden exports
- * @property {ModuleGraphConnection=} from when reexported: from which module
- * @property {number=} priority when reexported: with which priority
- * @property {boolean=} canMangle can the export be renamed (defaults to true)
- * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts
- * @property {Module[]=} dependencies module on which the result depends on
- */
-
-/**
- * @typedef {Object} ReferencedExport
- * @property {string[]} name name of the referenced export
- * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
+ * @typedef {Object} HMRJavascriptParserHooks
+ * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptCallback
+ * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptWithoutCallback
  */
 
-const TRANSITIVE = Symbol("transitive");
-
-const getIgnoredModule = memoize(() => {
-	const RawModule = __webpack_require__(84929);
-	return new RawModule("/* (ignored) */", `ignored`, `(ignored)`);
-});
-
-class Dependency {
-	constructor() {
-		/** @type {Module} */
-		this._parentModule = undefined;
-		/** @type {DependenciesBlock} */
-		this._parentDependenciesBlock = undefined;
-		/** @type {number} */
-		this._parentDependenciesBlockIndex = -1;
-		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
-		this.weak = false;
-		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
-		this.optional = false;
-		this._locSL = 0;
-		this._locSC = 0;
-		this._locEL = 0;
-		this._locEC = 0;
-		this._locI = undefined;
-		this._locN = undefined;
-		this._loc = undefined;
-	}
-
-	/**
-	 * @returns {string} a display name for the type of dependency
-	 */
-	get type() {
-		return "unknown";
-	}
-
-	/**
-	 * @returns {string} a dependency category, typical categories are "commonjs", "amd", "esm"
-	 */
-	get category() {
-		return "unknown";
-	}
+/** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
+const parserHooksMap = new WeakMap();
 
+class HotModuleReplacementPlugin {
 	/**
-	 * @returns {DependencyLocation} location
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {HMRJavascriptParserHooks} the attached hooks
 	 */
-	get loc() {
-		if (this._loc !== undefined) return this._loc;
-		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
-		const loc = {};
-		if (this._locSL > 0) {
-			loc.start = { line: this._locSL, column: this._locSC };
-		}
-		if (this._locEL > 0) {
-			loc.end = { line: this._locEL, column: this._locEC };
-		}
-		if (this._locN !== undefined) {
-			loc.name = this._locN;
-		}
-		if (this._locI !== undefined) {
-			loc.index = this._locI;
-		}
-		return (this._loc = loc);
-	}
-
-	set loc(loc) {
-		if ("start" in loc && typeof loc.start === "object") {
-			this._locSL = loc.start.line || 0;
-			this._locSC = loc.start.column || 0;
-		} else {
-			this._locSL = 0;
-			this._locSC = 0;
-		}
-		if ("end" in loc && typeof loc.end === "object") {
-			this._locEL = loc.end.line || 0;
-			this._locEC = loc.end.column || 0;
-		} else {
-			this._locEL = 0;
-			this._locEC = 0;
-		}
-		if ("index" in loc) {
-			this._locI = loc.index;
-		} else {
-			this._locI = undefined;
+	static getParserHooks(parser) {
+		if (!(parser instanceof JavascriptParser)) {
+			throw new TypeError(
+				"The 'parser' argument must be an instance of JavascriptParser"
+			);
 		}
-		if ("name" in loc) {
-			this._locN = loc.name;
-		} else {
-			this._locN = undefined;
+		let hooks = parserHooksMap.get(parser);
+		if (hooks === undefined) {
+			hooks = {
+				hotAcceptCallback: new SyncBailHook(["expression", "requests"]),
+				hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"])
+			};
+			parserHooksMap.set(parser, hooks);
 		}
-		this._loc = loc;
-	}
-
-	setLoc(startLine, startColumn, endLine, endColumn) {
-		this._locSL = startLine;
-		this._locSC = startColumn;
-		this._locEL = endLine;
-		this._locEC = endColumn;
-		this._locI = undefined;
-		this._locN = undefined;
-		this._loc = undefined;
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return null;
-	}
-
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return TRANSITIVE;
-	}
-
-	/**
-	 * Returns the referenced module and export
-	 * @deprecated
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {never} throws error
-	 */
-	getReference(moduleGraph) {
-		throw new Error(
-			"Dependency.getReference was removed in favor of Dependency.getReferencedExports, ModuleGraph.getModule and ModuleGraph.getConnection().active"
-		);
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return Dependency.EXPORTS_OBJECT_REFERENCED;
+		return hooks;
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
-	 */
-	getCondition(moduleGraph) {
-		return null;
+	constructor(options) {
+		this.options = options || {};
 	}
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getExports(moduleGraph) {
-		return undefined;
-	}
+	apply(compiler) {
+		const { _backCompat: backCompat } = compiler;
+		if (compiler.options.output.strictModuleErrorHandling === undefined)
+			compiler.options.output.strictModuleErrorHandling = true;
+		const runtimeRequirements = [RuntimeGlobals.module];
 
-	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
-	 */
-	getWarnings(moduleGraph) {
-		return null;
-	}
+		const createAcceptHandler = (parser, ParamDependency) => {
+			const { hotAcceptCallback, hotAcceptWithoutCallback } =
+				HotModuleReplacementPlugin.getParserHooks(parser);
 
-	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
-	 */
-	getErrors(moduleGraph) {
-		return null;
-	}
+			return expr => {
+				const module = parser.state.module;
+				const dep = new ConstDependency(
+					`${module.moduleArgument}.hot.accept`,
+					expr.callee.range,
+					runtimeRequirements
+				);
+				dep.loc = expr.loc;
+				module.addPresentationalDependency(dep);
+				module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+				if (expr.arguments.length >= 1) {
+					const arg = parser.evaluateExpression(expr.arguments[0]);
+					let params = [];
+					let requests = [];
+					if (arg.isString()) {
+						params = [arg];
+					} else if (arg.isArray()) {
+						params = arg.items.filter(param => param.isString());
+					}
+					if (params.length > 0) {
+						params.forEach((param, idx) => {
+							const request = param.string;
+							const dep = new ParamDependency(request, param.range);
+							dep.optional = true;
+							dep.loc = Object.create(expr.loc);
+							dep.loc.index = idx;
+							module.addDependency(dep);
+							requests.push(request);
+						});
+						if (expr.arguments.length > 1) {
+							hotAcceptCallback.call(expr.arguments[1], requests);
+							for (let i = 1; i < expr.arguments.length; i++) {
+								parser.walkExpression(expr.arguments[i]);
+							}
+							return true;
+						} else {
+							hotAcceptWithoutCallback.call(expr, requests);
+							return true;
+						}
+					}
+				}
+				parser.walkExpressions(expr.arguments);
+				return true;
+			};
+		};
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {}
+		const createDeclineHandler = (parser, ParamDependency) => expr => {
+			const module = parser.state.module;
+			const dep = new ConstDependency(
+				`${module.moduleArgument}.hot.decline`,
+				expr.callee.range,
+				runtimeRequirements
+			);
+			dep.loc = expr.loc;
+			module.addPresentationalDependency(dep);
+			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+			if (expr.arguments.length === 1) {
+				const arg = parser.evaluateExpression(expr.arguments[0]);
+				let params = [];
+				if (arg.isString()) {
+					params = [arg];
+				} else if (arg.isArray()) {
+					params = arg.items.filter(param => param.isString());
+				}
+				params.forEach((param, idx) => {
+					const dep = new ParamDependency(param.string, param.range);
+					dep.optional = true;
+					dep.loc = Object.create(expr.loc);
+					dep.loc.index = idx;
+					module.addDependency(dep);
+				});
+			}
+			return true;
+		};
 
-	/**
-	 * implement this method to allow the occurrence order plugin to count correctly
-	 * @returns {number} count how often the id is used in this dependency
-	 */
-	getNumberOfIdOccurrences() {
-		return 1;
-	}
+		const createHMRExpressionHandler = parser => expr => {
+			const module = parser.state.module;
+			const dep = new ConstDependency(
+				`${module.moduleArgument}.hot`,
+				expr.range,
+				runtimeRequirements
+			);
+			dep.loc = expr.loc;
+			module.addPresentationalDependency(dep);
+			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
+			return true;
+		};
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return true;
-	}
+		const applyModuleHot = parser => {
+			parser.hooks.evaluateIdentifier.for("module.hot").tap(
+				{
+					name: "HotModuleReplacementPlugin",
+					before: "NodeStuffPlugin"
+				},
+				expr => {
+					return evaluateToIdentifier(
+						"module.hot",
+						"module",
+						() => ["hot"],
+						true
+					)(expr);
+				}
+			);
+			parser.hooks.call
+				.for("module.hot.accept")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createAcceptHandler(parser, ModuleHotAcceptDependency)
+				);
+			parser.hooks.call
+				.for("module.hot.decline")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createDeclineHandler(parser, ModuleHotDeclineDependency)
+				);
+			parser.hooks.expression
+				.for("module.hot")
+				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
+		};
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
-	 */
-	createIgnoredModule(context) {
-		return getIgnoredModule();
-	}
+		const applyImportMetaHot = parser => {
+			parser.hooks.evaluateIdentifier
+				.for("import.meta.webpackHot")
+				.tap("HotModuleReplacementPlugin", expr => {
+					return evaluateToIdentifier(
+						"import.meta.webpackHot",
+						"import.meta",
+						() => ["webpackHot"],
+						true
+					)(expr);
+				});
+			parser.hooks.call
+				.for("import.meta.webpackHot.accept")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createAcceptHandler(parser, ImportMetaHotAcceptDependency)
+				);
+			parser.hooks.call
+				.for("import.meta.webpackHot.decline")
+				.tap(
+					"HotModuleReplacementPlugin",
+					createDeclineHandler(parser, ImportMetaHotDeclineDependency)
+				);
+			parser.hooks.expression
+				.for("import.meta.webpackHot")
+				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
+		};
 
-	serialize({ write }) {
-		write(this.weak);
-		write(this.optional);
-		write(this._locSL);
-		write(this._locSC);
-		write(this._locEL);
-		write(this._locEC);
-		write(this._locI);
-		write(this._locN);
-	}
+		compiler.hooks.compilation.tap(
+			"HotModuleReplacementPlugin",
+			(compilation, { normalModuleFactory }) => {
+				// This applies the HMR plugin only to the targeted compiler
+				// It should not affect child compilations
+				if (compilation.compiler !== compiler) return;
 
-	deserialize({ read }) {
-		this.weak = read();
-		this.optional = read();
-		this._locSL = read();
-		this._locSC = read();
-		this._locEL = read();
-		this._locEC = read();
-		this._locI = read();
-		this._locN = read();
-	}
-}
+				//#region module.hot.* API
+				compilation.dependencyFactories.set(
+					ModuleHotAcceptDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleHotAcceptDependency,
+					new ModuleHotAcceptDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ModuleHotDeclineDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleHotDeclineDependency,
+					new ModuleHotDeclineDependency.Template()
+				);
+				//#endregion
 
-/** @type {string[][]} */
-Dependency.NO_EXPORTS_REFERENCED = [];
-/** @type {string[][]} */
-Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+				//#region import.meta.webpackHot.* API
+				compilation.dependencyFactories.set(
+					ImportMetaHotAcceptDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaHotAcceptDependency,
+					new ImportMetaHotAcceptDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ImportMetaHotDeclineDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaHotDeclineDependency,
+					new ImportMetaHotDeclineDependency.Template()
+				);
+				//#endregion
 
-Object.defineProperty(Dependency.prototype, "module", {
-	/**
-	 * @deprecated
-	 * @returns {never} throws
-	 */
-	get() {
-		throw new Error(
-			"module property was removed from Dependency (use compilation.moduleGraph.getModule(dependency) instead)"
-		);
-	},
+				let hotIndex = 0;
+				const fullHashChunkModuleHashes = {};
+				const chunkModuleHashes = {};
 
-	/**
-	 * @deprecated
-	 * @returns {never} throws
-	 */
-	set() {
-		throw new Error(
-			"module property was removed from Dependency (use compilation.moduleGraph.updateModule(dependency, module) instead)"
-		);
-	}
-});
+				compilation.hooks.record.tap(
+					"HotModuleReplacementPlugin",
+					(compilation, records) => {
+						if (records.hash === compilation.hash) return;
+						const chunkGraph = compilation.chunkGraph;
+						records.hash = compilation.hash;
+						records.hotIndex = hotIndex;
+						records.fullHashChunkModuleHashes = fullHashChunkModuleHashes;
+						records.chunkModuleHashes = chunkModuleHashes;
+						records.chunkHashes = {};
+						records.chunkRuntime = {};
+						for (const chunk of compilation.chunks) {
+							records.chunkHashes[chunk.id] = chunk.hash;
+							records.chunkRuntime[chunk.id] = getRuntimeKey(chunk.runtime);
+						}
+						records.chunkModuleIds = {};
+						for (const chunk of compilation.chunks) {
+							records.chunkModuleIds[chunk.id] = Array.from(
+								chunkGraph.getOrderedChunkModulesIterable(
+									chunk,
+									compareModulesById(chunkGraph)
+								),
+								m => chunkGraph.getModuleId(m)
+							);
+						}
+					}
+				);
+				/** @type {TupleSet<[Module, Chunk]>} */
+				const updatedModules = new TupleSet();
+				/** @type {TupleSet<[Module, Chunk]>} */
+				const fullHashModules = new TupleSet();
+				/** @type {TupleSet<[Module, RuntimeSpec]>} */
+				const nonCodeGeneratedModules = new TupleSet();
+				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
+					const chunkGraph = compilation.chunkGraph;
+					const records = compilation.records;
+					for (const chunk of compilation.chunks) {
+						const getModuleHash = module => {
+							if (
+								compilation.codeGenerationResults.has(module, chunk.runtime)
+							) {
+								return compilation.codeGenerationResults.getHash(
+									module,
+									chunk.runtime
+								);
+							} else {
+								nonCodeGeneratedModules.add(module, chunk.runtime);
+								return chunkGraph.getModuleHash(module, chunk.runtime);
+							}
+						};
+						const fullHashModulesInThisChunk =
+							chunkGraph.getChunkFullHashModulesSet(chunk);
+						if (fullHashModulesInThisChunk !== undefined) {
+							for (const module of fullHashModulesInThisChunk) {
+								fullHashModules.add(module, chunk);
+							}
+						}
+						const modules = chunkGraph.getChunkModulesIterable(chunk);
+						if (modules !== undefined) {
+							if (records.chunkModuleHashes) {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											if (records.fullHashChunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											if (records.chunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											chunkModuleHashes[key] = hash;
+										}
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (records.chunkModuleHashes[key] !== hash) {
+											updatedModules.add(module, chunk);
+										}
+										chunkModuleHashes[key] = hash;
+									}
+								}
+							} else {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											chunkModuleHashes[key] = hash;
+										}
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										chunkModuleHashes[key] = hash;
+									}
+								}
+							}
+						}
+					}
 
-Object.defineProperty(Dependency.prototype, "disconnect", {
-	get() {
-		throw new Error(
-			"disconnect was removed from Dependency (Dependency no longer carries graph specific information)"
+					hotIndex = records.hotIndex || 0;
+					if (updatedModules.size > 0) hotIndex++;
+
+					hash.update(`${hotIndex}`);
+				});
+				compilation.hooks.processAssets.tap(
+					{
+						name: "HotModuleReplacementPlugin",
+						stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+					},
+					() => {
+						const chunkGraph = compilation.chunkGraph;
+						const records = compilation.records;
+						if (records.hash === compilation.hash) return;
+						if (
+							!records.chunkModuleHashes ||
+							!records.chunkHashes ||
+							!records.chunkModuleIds
+						) {
+							return;
+						}
+						for (const [module, chunk] of fullHashModules) {
+							const key = `${chunk.id}|${module.identifier()}`;
+							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
+								? chunkGraph.getModuleHash(module, chunk.runtime)
+								: compilation.codeGenerationResults.getHash(
+										module,
+										chunk.runtime
+								  );
+							if (records.chunkModuleHashes[key] !== hash) {
+								updatedModules.add(module, chunk);
+							}
+							chunkModuleHashes[key] = hash;
+						}
+
+						/** @type {Map<string, { updatedChunkIds: Set<string|number>, removedChunkIds: Set<string|number>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }>} */
+						const hotUpdateMainContentByRuntime = new Map();
+						let allOldRuntime;
+						for (const key of Object.keys(records.chunkRuntime)) {
+							const runtime = keyToRuntime(records.chunkRuntime[key]);
+							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
+						}
+						forEachRuntime(allOldRuntime, runtime => {
+							const { path: filename, info: assetInfo } =
+								compilation.getPathWithInfo(
+									compilation.outputOptions.hotUpdateMainFilename,
+									{
+										hash: records.hash,
+										runtime
+									}
+								);
+							hotUpdateMainContentByRuntime.set(runtime, {
+								updatedChunkIds: new Set(),
+								removedChunkIds: new Set(),
+								removedModules: new Set(),
+								filename,
+								assetInfo
+							});
+						});
+						if (hotUpdateMainContentByRuntime.size === 0) return;
+
+						// Create a list of all active modules to verify which modules are removed completely
+						/** @type {Map<number|string, Module>} */
+						const allModules = new Map();
+						for (const module of compilation.modules) {
+							const id = chunkGraph.getModuleId(module);
+							allModules.set(id, module);
+						}
+
+						// List of completely removed modules
+						/** @type {Set<string | number>} */
+						const completelyRemovedModules = new Set();
+
+						for (const key of Object.keys(records.chunkHashes)) {
+							const oldRuntime = keyToRuntime(records.chunkRuntime[key]);
+							/** @type {Module[]} */
+							const remainingModules = [];
+							// Check which modules are removed
+							for (const id of records.chunkModuleIds[key]) {
+								const module = allModules.get(id);
+								if (module === undefined) {
+									completelyRemovedModules.add(id);
+								} else {
+									remainingModules.push(module);
+								}
+							}
+
+							let chunkId;
+							let newModules;
+							let newRuntimeModules;
+							let newFullHashModules;
+							let newDependentHashModules;
+							let newRuntime;
+							let removedFromRuntime;
+							const currentChunk = find(
+								compilation.chunks,
+								chunk => `${chunk.id}` === key
+							);
+							if (currentChunk) {
+								chunkId = currentChunk.id;
+								newRuntime = intersectRuntime(
+									currentChunk.runtime,
+									allOldRuntime
+								);
+								if (newRuntime === undefined) continue;
+								newModules = chunkGraph
+									.getChunkModules(currentChunk)
+									.filter(module => updatedModules.has(module, currentChunk));
+								newRuntimeModules = Array.from(
+									chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
+								).filter(module => updatedModules.has(module, currentChunk));
+								const fullHashModules =
+									chunkGraph.getChunkFullHashModulesIterable(currentChunk);
+								newFullHashModules =
+									fullHashModules &&
+									Array.from(fullHashModules).filter(module =>
+										updatedModules.has(module, currentChunk)
+									);
+								const dependentHashModules =
+									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
+								newDependentHashModules =
+									dependentHashModules &&
+									Array.from(dependentHashModules).filter(module =>
+										updatedModules.has(module, currentChunk)
+									);
+								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
+							} else {
+								// chunk has completely removed
+								chunkId = `${+key}` === key ? +key : key;
+								removedFromRuntime = oldRuntime;
+								newRuntime = oldRuntime;
+							}
+							if (removedFromRuntime) {
+								// chunk was removed from some runtimes
+								forEachRuntime(removedFromRuntime, runtime => {
+									hotUpdateMainContentByRuntime
+										.get(runtime)
+										.removedChunkIds.add(chunkId);
+								});
+								// dispose modules from the chunk in these runtimes
+								// where they are no longer in this runtime
+								for (const module of remainingModules) {
+									const moduleKey = `${key}|${module.identifier()}`;
+									const oldHash = records.chunkModuleHashes[moduleKey];
+									const runtimes = chunkGraph.getModuleRuntimes(module);
+									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
+										// Module is still in the same runtime combination
+										const hash = nonCodeGeneratedModules.has(module, newRuntime)
+											? chunkGraph.getModuleHash(module, newRuntime)
+											: compilation.codeGenerationResults.getHash(
+													module,
+													newRuntime
+											  );
+										if (hash !== oldHash) {
+											if (module.type === "runtime") {
+												newRuntimeModules = newRuntimeModules || [];
+												newRuntimeModules.push(
+													/** @type {RuntimeModule} */ (module)
+												);
+											} else {
+												newModules = newModules || [];
+												newModules.push(module);
+											}
+										}
+									} else {
+										// module is no longer in this runtime combination
+										// We (incorrectly) assume that it's not in an overlapping runtime combination
+										// and dispose it from the main runtimes the chunk was removed from
+										forEachRuntime(removedFromRuntime, runtime => {
+											// If the module is still used in this runtime, do not dispose it
+											// This could create a bad runtime state where the module is still loaded,
+											// but no chunk which contains it. This means we don't receive further HMR updates
+											// to this module and that's bad.
+											// TODO force load one of the chunks which contains the module
+											for (const moduleRuntime of runtimes) {
+												if (typeof moduleRuntime === "string") {
+													if (moduleRuntime === runtime) return;
+												} else if (moduleRuntime !== undefined) {
+													if (moduleRuntime.has(runtime)) return;
+												}
+											}
+											hotUpdateMainContentByRuntime
+												.get(runtime)
+												.removedModules.add(module);
+										});
+									}
+								}
+							}
+							if (
+								(newModules && newModules.length > 0) ||
+								(newRuntimeModules && newRuntimeModules.length > 0)
+							) {
+								const hotUpdateChunk = new HotUpdateChunk();
+								if (backCompat)
+									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
+								hotUpdateChunk.id = chunkId;
+								hotUpdateChunk.runtime = newRuntime;
+								if (currentChunk) {
+									for (const group of currentChunk.groupsIterable)
+										hotUpdateChunk.addGroup(group);
+								}
+								chunkGraph.attachModules(hotUpdateChunk, newModules || []);
+								chunkGraph.attachRuntimeModules(
+									hotUpdateChunk,
+									newRuntimeModules || []
+								);
+								if (newFullHashModules) {
+									chunkGraph.attachFullHashModules(
+										hotUpdateChunk,
+										newFullHashModules
+									);
+								}
+								if (newDependentHashModules) {
+									chunkGraph.attachDependentHashModules(
+										hotUpdateChunk,
+										newDependentHashModules
+									);
+								}
+								const renderManifest = compilation.getRenderManifest({
+									chunk: hotUpdateChunk,
+									hash: records.hash,
+									fullHash: records.hash,
+									outputOptions: compilation.outputOptions,
+									moduleTemplates: compilation.moduleTemplates,
+									dependencyTemplates: compilation.dependencyTemplates,
+									codeGenerationResults: compilation.codeGenerationResults,
+									runtimeTemplate: compilation.runtimeTemplate,
+									moduleGraph: compilation.moduleGraph,
+									chunkGraph
+								});
+								for (const entry of renderManifest) {
+									/** @type {string} */
+									let filename;
+									/** @type {AssetInfo} */
+									let assetInfo;
+									if ("filename" in entry) {
+										filename = entry.filename;
+										assetInfo = entry.info;
+									} else {
+										({ path: filename, info: assetInfo } =
+											compilation.getPathWithInfo(
+												entry.filenameTemplate,
+												entry.pathOptions
+											));
+									}
+									const source = entry.render();
+									compilation.additionalChunkAssets.push(filename);
+									compilation.emitAsset(filename, source, {
+										hotModuleReplacement: true,
+										...assetInfo
+									});
+									if (currentChunk) {
+										currentChunk.files.add(filename);
+										compilation.hooks.chunkAsset.call(currentChunk, filename);
+									}
+								}
+								forEachRuntime(newRuntime, runtime => {
+									hotUpdateMainContentByRuntime
+										.get(runtime)
+										.updatedChunkIds.add(chunkId);
+								});
+							}
+						}
+						const completelyRemovedModulesArray = Array.from(
+							completelyRemovedModules
+						);
+						const hotUpdateMainContentByFilename = new Map();
+						for (const {
+							removedChunkIds,
+							removedModules,
+							updatedChunkIds,
+							filename,
+							assetInfo
+						} of hotUpdateMainContentByRuntime.values()) {
+							const old = hotUpdateMainContentByFilename.get(filename);
+							if (
+								old &&
+								(!isSubset(old.removedChunkIds, removedChunkIds) ||
+									!isSubset(old.removedModules, removedModules) ||
+									!isSubset(old.updatedChunkIds, updatedChunkIds))
+							) {
+								compilation.warnings.push(
+									new WebpackError(`HotModuleReplacementPlugin
+The configured output.hotUpdateMainFilename doesn't lead to unique filenames per runtime and HMR update differs between runtimes.
+This might lead to incorrect runtime behavior of the applied update.
+To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`)
+								);
+								for (const chunkId of removedChunkIds)
+									old.removedChunkIds.add(chunkId);
+								for (const chunkId of removedModules)
+									old.removedModules.add(chunkId);
+								for (const chunkId of updatedChunkIds)
+									old.updatedChunkIds.add(chunkId);
+								continue;
+							}
+							hotUpdateMainContentByFilename.set(filename, {
+								removedChunkIds,
+								removedModules,
+								updatedChunkIds,
+								assetInfo
+							});
+						}
+						for (const [
+							filename,
+							{ removedChunkIds, removedModules, updatedChunkIds, assetInfo }
+						] of hotUpdateMainContentByFilename) {
+							const hotUpdateMainJson = {
+								c: Array.from(updatedChunkIds),
+								r: Array.from(removedChunkIds),
+								m:
+									removedModules.size === 0
+										? completelyRemovedModulesArray
+										: completelyRemovedModulesArray.concat(
+												Array.from(removedModules, m =>
+													chunkGraph.getModuleId(m)
+												)
+										  )
+							};
+
+							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
+							compilation.emitAsset(filename, source, {
+								hotModuleReplacement: true,
+								...assetInfo
+							});
+						}
+					}
+				);
+
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"HotModuleReplacementPlugin",
+					(chunk, runtimeRequirements) => {
+						runtimeRequirements.add(RuntimeGlobals.hmrDownloadManifest);
+						runtimeRequirements.add(RuntimeGlobals.hmrDownloadUpdateHandlers);
+						runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+						runtimeRequirements.add(RuntimeGlobals.moduleCache);
+						compilation.addRuntimeModule(
+							chunk,
+							new HotModuleReplacementRuntimeModule()
+						);
+					}
+				);
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("HotModuleReplacementPlugin", parser => {
+						applyModuleHot(parser);
+						applyImportMetaHot(parser);
+					});
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("HotModuleReplacementPlugin", parser => {
+						applyModuleHot(parser);
+					});
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("HotModuleReplacementPlugin", parser => {
+						applyImportMetaHot(parser);
+					});
+
+				NormalModule.getCompilationHooks(compilation).loader.tap(
+					"HotModuleReplacementPlugin",
+					context => {
+						context.hot = true;
+					}
+				);
+			}
 		);
 	}
-});
-
-Dependency.TRANSITIVE = TRANSITIVE;
+}
 
-module.exports = Dependency;
+module.exports = HotModuleReplacementPlugin;
 
 
 /***/ }),
 
-/***/ 5160:
+/***/ 9597:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -39986,61 +42507,70 @@ module.exports = Dependency;
 
 
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+const Chunk = __webpack_require__(39385);
+
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @template T @typedef {import("./InitFragment")<T>} InitFragment */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./util/Hash")} Hash */
 
-/**
- * @typedef {Object} DependencyTemplateContext
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {Set<string>} runtimeRequirements the requirements for runtime
- * @property {Module} module current module
- * @property {RuntimeSpec} runtime current runtimes, for which code is generated
- * @property {InitFragment<GenerateContext>[]} initFragments mutable array of init fragments for the current module
- * @property {ConcatenationScope=} concatenationScope when in a concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults} codeGenerationResults the code generation results
- */
+class HotUpdateChunk extends Chunk {
+	constructor() {
+		super();
+	}
+}
+
+module.exports = HotUpdateChunk;
+
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const ModuleFactory = __webpack_require__(51010);
+
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 
 /**
- * @typedef {Object} CssDependencyTemplateContextExtras
- * @property {Map<string, string>} cssExports the css exports
+ * Ignores error when module is unresolved
  */
+class IgnoreErrorModuleFactory extends ModuleFactory {
+	/**
+	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
+	 */
+	constructor(normalModuleFactory) {
+		super();
 
-/** @typedef {DependencyTemplateContext & CssDependencyTemplateContextExtras} CssDependencyTemplateContext */
+		this.normalModuleFactory = normalModuleFactory;
+	}
 
-class DependencyTemplate {
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	create(data, callback) {
+		this.normalModuleFactory.create(data, (err, result) => {
+			return callback(null, result);
+		});
 	}
 }
 
-module.exports = DependencyTemplate;
+module.exports = IgnoreErrorModuleFactory;
 
 
 /***/ }),
 
-/***/ 9163:
+/***/ 84808:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40051,72 +42581,88 @@ module.exports = DependencyTemplate;
 
 
 
-const createHash = __webpack_require__(49835);
-
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
-/** @typedef {typeof import("./util/Hash")} Hash */
+const createSchemaValidation = __webpack_require__(32540);
 
-/** @typedef {new (...args: any[]) => Dependency} DependencyConstructor */
+/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 
-class DependencyTemplates {
-	/**
-	 * @param {string | Hash} hashFunction the hash function to use
-	 */
-	constructor(hashFunction = "md4") {
-		/** @type {Map<Function, DependencyTemplate>} */
-		this._map = new Map();
-		/** @type {string} */
-		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
-		this._hashFunction = hashFunction;
+const validate = createSchemaValidation(
+	__webpack_require__(20858),
+	() => __webpack_require__(3098),
+	{
+		name: "Ignore Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class IgnorePlugin {
 	/**
-	 * @param {DependencyConstructor} dependency Constructor of Dependency
-	 * @returns {DependencyTemplate} template for this dependency
+	 * @param {IgnorePluginOptions} options IgnorePlugin options
 	 */
-	get(dependency) {
-		return this._map.get(dependency);
+	constructor(options) {
+		validate(options);
+		this.options = options;
+
+		/** @private @type {Function} */
+		this.checkIgnore = this.checkIgnore.bind(this);
 	}
 
 	/**
-	 * @param {DependencyConstructor} dependency Constructor of Dependency
-	 * @param {DependencyTemplate} dependencyTemplate template for this dependency
-	 * @returns {void}
+	 * Note that if "contextRegExp" is given, both the "resourceRegExp"
+	 * and "contextRegExp" have to match.
+	 *
+	 * @param {ResolveData} resolveData resolve data
+	 * @returns {false|undefined} returns false when the request should be ignored, otherwise undefined
 	 */
-	set(dependency, dependencyTemplate) {
-		this._map.set(dependency, dependencyTemplate);
+	checkIgnore(resolveData) {
+		if (
+			"checkResource" in this.options &&
+			this.options.checkResource &&
+			this.options.checkResource(resolveData.request, resolveData.context)
+		) {
+			return false;
+		}
+
+		if (
+			"resourceRegExp" in this.options &&
+			this.options.resourceRegExp &&
+			this.options.resourceRegExp.test(resolveData.request)
+		) {
+			if ("contextRegExp" in this.options && this.options.contextRegExp) {
+				// if "contextRegExp" is given,
+				// both the "resourceRegExp" and "contextRegExp" have to match.
+				if (this.options.contextRegExp.test(resolveData.context)) {
+					return false;
+				}
+			} else {
+				return false;
+			}
+		}
 	}
 
 	/**
-	 * @param {string} part additional hash contributor
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	updateHash(part) {
-		const hash = createHash(this._hashFunction);
-		hash.update(`${this._hash}${part}`);
-		this._hash = /** @type {string} */ (hash.digest("hex"));
-	}
-
-	getHash() {
-		return this._hash;
-	}
-
-	clone() {
-		const newInstance = new DependencyTemplates(this._hashFunction);
-		newInstance._map = new Map(this._map);
-		newInstance._hash = this._hash;
-		return newInstance;
+	apply(compiler) {
+		compiler.hooks.normalModuleFactory.tap("IgnorePlugin", nmf => {
+			nmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+		});
+		compiler.hooks.contextModuleFactory.tap("IgnorePlugin", cmf => {
+			cmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+		});
 	}
 }
 
-module.exports = DependencyTemplates;
+module.exports = IgnorePlugin;
 
 
 /***/ }),
 
-/***/ 62790:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 7373:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -40126,224 +42672,212 @@ module.exports = DependencyTemplates;
 
 
 
-const DllModuleFactory = __webpack_require__(68703);
-const DllEntryDependency = __webpack_require__(95666);
-const EntryDependency = __webpack_require__(3979);
+/** @typedef {import("../declarations/WebpackOptions").IgnoreWarningsNormalized} IgnoreWarningsNormalized */
+/** @typedef {import("./Compiler")} Compiler */
 
-class DllEntryPlugin {
-	constructor(context, entries, options) {
-		this.context = context;
-		this.entries = entries;
-		this.options = options;
+class IgnoreWarningsPlugin {
+	/**
+	 * @param {IgnoreWarningsNormalized} ignoreWarnings conditions to ignore warnings
+	 */
+	constructor(ignoreWarnings) {
+		this._ignoreWarnings = ignoreWarnings;
 	}
-
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DllEntryPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const dllModuleFactory = new DllModuleFactory();
-				compilation.dependencyFactories.set(
-					DllEntryDependency,
-					dllModuleFactory
-				);
-				compilation.dependencyFactories.set(
-					EntryDependency,
-					normalModuleFactory
-				);
-			}
-		);
-		compiler.hooks.make.tapAsync("DllEntryPlugin", (compilation, callback) => {
-			compilation.addEntry(
-				this.context,
-				new DllEntryDependency(
-					this.entries.map((e, idx) => {
-						const dep = new EntryDependency(e);
-						dep.loc = {
-							name: this.options.name,
-							index: idx
-						};
-						return dep;
-					}),
-					this.options.name
-				),
-				this.options,
-				callback
+		compiler.hooks.compilation.tap("IgnoreWarningsPlugin", compilation => {
+			compilation.hooks.processWarnings.tap(
+				"IgnoreWarningsPlugin",
+				warnings => {
+					return warnings.filter(warning => {
+						return !this._ignoreWarnings.some(ignore =>
+							ignore(warning, compilation)
+						);
+					});
+				}
 			);
 		});
 	}
 }
 
-module.exports = DllEntryPlugin;
+module.exports = IgnoreWarningsPlugin;
 
 
 /***/ }),
 
-/***/ 28280:
+/***/ 55870:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
+const { ConcatSource } = __webpack_require__(51255);
 const makeSerializable = __webpack_require__(33032);
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").SourceContext} SourceContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([
-	RuntimeGlobals.require,
-	RuntimeGlobals.module
-]);
-
-class DllModule extends Module {
-	constructor(context, dependencies, name) {
-		super("javascript/dynamic", context);
+/** @typedef {import("./Generator").GenerateContext} GenerateContext */
 
-		// Info from Factory
-		this.dependencies = dependencies;
-		this.name = name;
-	}
+/**
+ * @param {InitFragment} fragment the init fragment
+ * @param {number} index index
+ * @returns {[InitFragment, number]} tuple with both
+ */
+const extractFragmentIndex = (fragment, index) => [fragment, index];
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+/**
+ * @param {[InitFragment, number]} a first pair
+ * @param {[InitFragment, number]} b second pair
+ * @returns {number} sort value
+ */
+const sortFragmentWithIndex = ([a, i], [b, j]) => {
+	const stageCmp = a.stage - b.stage;
+	if (stageCmp !== 0) return stageCmp;
+	const positionCmp = a.position - b.position;
+	if (positionCmp !== 0) return positionCmp;
+	return i - j;
+};
 
+/**
+ * @template Context
+ */
+class InitFragment {
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @param {number} stage category of initialization code (contribute to order)
+	 * @param {number} position position in the category (contribute to order)
+	 * @param {string=} key unique key to avoid emitting the same initialization code twice
+	 * @param {string|Source=} endContent the source code that will be included at the end of the module
 	 */
-	identifier() {
-		return `dll ${this.name}`;
+	constructor(content, stage, position, key, endContent) {
+		this.content = content;
+		this.stage = stage;
+		this.position = position;
+		this.key = key;
+		this.endContent = endContent;
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	readableIdentifier(requestShortener) {
-		return `dll ${this.name}`;
+	getContent(context) {
+		return this.content;
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {Context} context context
+	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {};
-		return callback();
+	getEndContent(context) {
+		return this.endContent;
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		const sources = new Map();
-		sources.set(
-			"javascript",
-			new RawSource("module.exports = __webpack_require__;")
-		);
-		return {
-			sources,
-			runtimeRequirements: RUNTIME_REQUIREMENTS
-		};
-	}
+	static addToSource(source, initFragments, context) {
+		if (initFragments.length > 0) {
+			// Sort fragments by position. If 2 fragments have the same position,
+			// use their index.
+			const sortedFragments = initFragments
+				.map(extractFragmentIndex)
+				.sort(sortFragmentWithIndex);
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
-	}
+			// Deduplicate fragments. If a fragment has no key, it is always included.
+			const keyedFragments = new Map();
+			for (const [fragment] of sortedFragments) {
+				if (typeof fragment.mergeAll === "function") {
+					if (!fragment.key) {
+						throw new Error(
+							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
+						);
+					}
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue === undefined) {
+						keyedFragments.set(fragment.key, fragment);
+					} else if (Array.isArray(oldValue)) {
+						oldValue.push(fragment);
+					} else {
+						keyedFragments.set(fragment.key, [oldValue, fragment]);
+					}
+					continue;
+				} else if (typeof fragment.merge === "function") {
+					const oldValue = keyedFragments.get(fragment.key);
+					if (oldValue !== undefined) {
+						keyedFragments.set(fragment.key, fragment.merge(oldValue));
+						continue;
+					}
+				}
+				keyedFragments.set(fragment.key || Symbol(), fragment);
+			}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 12;
-	}
+			const concatSource = new ConcatSource();
+			const endContents = [];
+			for (let fragment of keyedFragments.values()) {
+				if (Array.isArray(fragment)) {
+					fragment = fragment[0].mergeAll(fragment);
+				}
+				concatSource.add(fragment.getContent(context));
+				const endContent = fragment.getEndContent(context);
+				if (endContent) {
+					endContents.push(endContent);
+				}
+			}
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(`dll module${this.name || ""}`);
-		super.updateHash(hash, context);
+			concatSource.add(source);
+			for (const content of endContents.reverse()) {
+				concatSource.add(content);
+			}
+			return concatSource;
+		} else {
+			return source;
+		}
 	}
 
 	serialize(context) {
-		context.write(this.name);
-		super.serialize(context);
-	}
+		const { write } = context;
 
-	deserialize(context) {
-		this.name = context.read();
-		super.deserialize(context);
+		write(this.content);
+		write(this.stage);
+		write(this.position);
+		write(this.key);
+		write(this.endContent);
 	}
 
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		this.dependencies = module.dependencies;
-	}
+	deserialize(context) {
+		const { read } = context;
 
-	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
-	 */
-	cleanupForCache() {
-		super.cleanupForCache();
-		this.dependencies = undefined;
+		this.content = read();
+		this.stage = read();
+		this.position = read();
+		this.key = read();
+		this.endContent = read();
 	}
 }
 
-makeSerializable(DllModule, "webpack/lib/DllModule");
+makeSerializable(InitFragment, "webpack/lib/InitFragment");
 
-module.exports = DllModule;
+InitFragment.prototype.merge = undefined;
+
+InitFragment.STAGE_CONSTANTS = 10;
+InitFragment.STAGE_ASYNC_BOUNDARY = 20;
+InitFragment.STAGE_HARMONY_EXPORTS = 30;
+InitFragment.STAGE_HARMONY_IMPORTS = 40;
+InitFragment.STAGE_PROVIDES = 50;
+InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
+InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70;
+
+module.exports = InitFragment;
 
 
 /***/ }),
 
-/***/ 68703:
+/***/ 68257:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40354,117 +42888,124 @@ module.exports = DllModule;
 
 
 
-const DllModule = __webpack_require__(28280);
-const ModuleFactory = __webpack_require__(51010);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./dependencies/DllEntryDependency")} DllEntryDependency */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
-class DllModuleFactory extends ModuleFactory {
-	constructor() {
-		super();
-		this.hooks = Object.freeze({});
-	}
+class InvalidDependenciesModuleWarning extends WebpackError {
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
+	 * @param {Module} module module tied to dependency
+	 * @param {Iterable<string>} deps invalid dependencies
 	 */
-	create(data, callback) {
-		const dependency = /** @type {DllEntryDependency} */ (data.dependencies[0]);
-		callback(null, {
-			module: new DllModule(
-				data.context,
-				dependency.dependencies,
-				dependency.name
-			)
-		});
+	constructor(module, deps) {
+		const orderedDeps = deps ? Array.from(deps).sort() : [];
+		const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
+		super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
+Invalid dependencies may lead to broken watching and caching.
+As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.
+Loaders: Pass absolute paths to this.addDependency (existing files), this.addMissingDependency (not existing files), and this.addContextDependency (directories).
+Plugins: Pass absolute paths to fileDependencies (existing files), missingDependencies (not existing files), and contextDependencies (directories).
+Globs: They are not supported. Pass absolute path to the directory as context dependencies.
+The following invalid values have been reported:
+${depsList.slice(0, 3).join("\n")}${
+			depsList.length > 3 ? "\n * and more ..." : ""
+		}`);
+
+		this.name = "InvalidDependenciesModuleWarning";
+		this.details = depsList.slice(3).join("\n");
+		this.module = module;
 	}
 }
 
-module.exports = DllModuleFactory;
+makeSerializable(
+	InvalidDependenciesModuleWarning,
+	"webpack/lib/InvalidDependenciesModuleWarning"
+);
+
+module.exports = InvalidDependenciesModuleWarning;
 
 
 /***/ }),
 
-/***/ 40038:
+/***/ 52329:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const DllEntryPlugin = __webpack_require__(62790);
-const FlagAllModulesAsUsedPlugin = __webpack_require__(58727);
-const LibManifestPlugin = __webpack_require__(93837);
-const createSchemaValidation = __webpack_require__(32540);
+const InnerGraph = __webpack_require__(38988);
 
-/** @typedef {import("../declarations/plugins/DllPlugin").DllPluginOptions} DllPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-const validate = createSchemaValidation(
-	__webpack_require__(9667),
-	() => __webpack_require__(99926),
-	{
-		name: "Dll Plugin",
-		baseDataPath: "options"
-	}
-);
-
-class DllPlugin {
-	/**
-	 * @param {DllPluginOptions} options options object
-	 */
-	constructor(options) {
-		validate(options);
-		this.options = {
-			...options,
-			entryOnly: options.entryOnly !== false
-		};
-	}
-
+class JavascriptMetaInfoPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.entryOption.tap("DllPlugin", (context, entry) => {
-			if (typeof entry !== "function") {
-				for (const name of Object.keys(entry)) {
-					const options = {
-						name,
-						filename: entry.filename
-					};
-					new DllEntryPlugin(context, entry[name].import, options).apply(
-						compiler
-					);
-				}
-			} else {
-				throw new Error(
-					"DllPlugin doesn't support dynamic entry (function) yet"
-				);
+		compiler.hooks.compilation.tap(
+			"JavascriptMetaInfoPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
+						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
+						parser.state.module.buildInfo.usingEval = true;
+						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
+						if (currentSymbol) {
+							InnerGraph.addUsage(parser.state, null, currentSymbol);
+						} else {
+							InnerGraph.bailout(parser.state);
+						}
+					});
+					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
+						let topLevelDeclarations =
+							parser.state.module.buildInfo.topLevelDeclarations;
+						if (topLevelDeclarations === undefined) {
+							topLevelDeclarations =
+								parser.state.module.buildInfo.topLevelDeclarations = new Set();
+						}
+						for (const name of parser.scope.definitions.asSet()) {
+							const freeInfo = parser.getFreeInfoFromVariable(name);
+							if (freeInfo === undefined) {
+								topLevelDeclarations.add(name);
+							}
+						}
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("JavascriptMetaInfoPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("JavascriptMetaInfoPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("JavascriptMetaInfoPlugin", handler);
 			}
-			return true;
-		});
-		new LibManifestPlugin(this.options).apply(compiler);
-		if (!this.options.entryOnly) {
-			new FlagAllModulesAsUsedPlugin("DllPlugin").apply(compiler);
-		}
+		);
 	}
 }
 
-module.exports = DllPlugin;
+module.exports = JavascriptMetaInfoPlugin;
 
 
 /***/ }),
 
-/***/ 90999:
+/***/ 93837:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40475,193 +43016,155 @@ module.exports = DllPlugin;
 
 
 
-const parseJson = __webpack_require__(15235);
-const DelegatedModuleFactoryPlugin = __webpack_require__(51387);
-const ExternalModuleFactoryPlugin = __webpack_require__(62153);
-const WebpackError = __webpack_require__(53799);
-const DelegatedSourceDependency = __webpack_require__(22914);
-const createSchemaValidation = __webpack_require__(32540);
-const makePathsRelative = (__webpack_require__(82186).makePathsRelative);
+const asyncLib = __webpack_require__(78175);
+const EntryDependency = __webpack_require__(3979);
+const { someInIterable } = __webpack_require__(39104);
+const { compareModulesById } = __webpack_require__(29579);
+const { dirname, mkdirp } = __webpack_require__(17139);
 
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptions} DllReferencePluginOptions */
-/** @typedef {import("../declarations/plugins/DllReferencePlugin").DllReferencePluginOptionsManifest} DllReferencePluginOptionsManifest */
+/** @typedef {import("./Compiler")} Compiler */
 
-const validate = createSchemaValidation(
-	__webpack_require__(28534),
-	() => __webpack_require__(46552),
-	{
-		name: "Dll Reference Plugin",
-		baseDataPath: "options"
-	}
-);
+/**
+ * @typedef {Object} ManifestModuleData
+ * @property {string | number} id
+ * @property {Object} buildMeta
+ * @property {boolean | string[]} exports
+ */
 
-class DllReferencePlugin {
-	/**
-	 * @param {DllReferencePluginOptions} options options object
-	 */
+class LibManifestPlugin {
 	constructor(options) {
-		validate(options);
 		this.options = options;
-		/** @type {WeakMap<Object, {path: string, data: DllReferencePluginOptionsManifest?, error: Error?}>} */
-		this._compilationData = new WeakMap();
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					DelegatedSourceDependency,
-					normalModuleFactory
-				);
-			}
-		);
-
-		compiler.hooks.beforeCompile.tapAsync(
-			"DllReferencePlugin",
-			(params, callback) => {
-				if ("manifest" in this.options) {
-					const manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						compiler.inputFileSystem.readFile(manifest, (err, result) => {
-							if (err) return callback(err);
-							const data = {
-								path: manifest,
-								data: undefined,
-								error: undefined
-							};
-							// Catch errors parsing the manifest so that blank
-							// or malformed manifest files don't kill the process.
-							try {
-								data.data = parseJson(result.toString("utf-8"));
-							} catch (e) {
-								// Store the error in the params so that it can
-								// be added as a compilation error later on.
-								const manifestPath = makePathsRelative(
-									compiler.options.context,
-									manifest,
-									compiler.root
-								);
-								data.error = new DllManifestError(manifestPath, e.message);
-							}
-							this._compilationData.set(params, data);
-							return callback();
+		compiler.hooks.emit.tapAsync(
+			"LibManifestPlugin",
+			(compilation, callback) => {
+				const moduleGraph = compilation.moduleGraph;
+				asyncLib.forEach(
+					Array.from(compilation.chunks),
+					(chunk, callback) => {
+						if (!chunk.canBeInitial()) {
+							callback();
+							return;
+						}
+						const chunkGraph = compilation.chunkGraph;
+						const targetPath = compilation.getPath(this.options.path, {
+							chunk
 						});
-						return;
-					}
-				}
-				return callback();
-			}
-		);
-
-		compiler.hooks.compile.tap("DllReferencePlugin", params => {
-			let name = this.options.name;
-			let sourceType = this.options.sourceType;
-			let content =
-				"content" in this.options ? this.options.content : undefined;
-			if ("manifest" in this.options) {
-				let manifestParameter = this.options.manifest;
-				let manifest;
-				if (typeof manifestParameter === "string") {
-					const data = this._compilationData.get(params);
-					// If there was an error parsing the manifest
-					// file, exit now because the error will be added
-					// as a compilation error in the "compilation" hook.
-					if (data.error) {
-						return;
-					}
-					manifest = data.data;
-				} else {
-					manifest = manifestParameter;
-				}
-				if (manifest) {
-					if (!name) name = manifest.name;
-					if (!sourceType) sourceType = manifest.type;
-					if (!content) content = manifest.content;
-				}
-			}
-			/** @type {Externals} */
-			const externals = {};
-			const source = "dll-reference " + name;
-			externals[source] = name;
-			const normalModuleFactory = params.normalModuleFactory;
-			new ExternalModuleFactoryPlugin(sourceType || "var", externals).apply(
-				normalModuleFactory
-			);
-			new DelegatedModuleFactoryPlugin({
-				source: source,
-				type: this.options.type,
-				scope: this.options.scope,
-				context: this.options.context || compiler.options.context,
-				content,
-				extensions: this.options.extensions,
-				associatedObjectForCache: compiler.root
-			}).apply(normalModuleFactory);
-		});
-
-		compiler.hooks.compilation.tap(
-			"DllReferencePlugin",
-			(compilation, params) => {
-				if ("manifest" in this.options) {
-					let manifest = this.options.manifest;
-					if (typeof manifest === "string") {
-						const data = this._compilationData.get(params);
-						// If there was an error parsing the manifest file, add the
-						// error as a compilation error to make the compilation fail.
-						if (data.error) {
-							compilation.errors.push(data.error);
+						const name =
+							this.options.name &&
+							compilation.getPath(this.options.name, {
+								chunk
+							});
+						const content = Object.create(null);
+						for (const module of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesById(chunkGraph)
+						)) {
+							if (
+								this.options.entryOnly &&
+								!someInIterable(
+									moduleGraph.getIncomingConnections(module),
+									c => c.dependency instanceof EntryDependency
+								)
+							) {
+								continue;
+							}
+							const ident = module.libIdent({
+								context: this.options.context || compiler.options.context,
+								associatedObjectForCache: compiler.root
+							});
+							if (ident) {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								const providedExports = exportsInfo.getProvidedExports();
+								/** @type {ManifestModuleData} */
+								const data = {
+									id: chunkGraph.getModuleId(module),
+									buildMeta: module.buildMeta,
+									exports: Array.isArray(providedExports)
+										? providedExports
+										: undefined
+								};
+								content[ident] = data;
+							}
 						}
-						compilation.fileDependencies.add(manifest);
-					}
-				}
+						const manifest = {
+							name,
+							type: this.options.type,
+							content
+						};
+						// Apply formatting to content if format flag is true;
+						const manifestContent = this.options.format
+							? JSON.stringify(manifest, null, 2)
+							: JSON.stringify(manifest);
+						const buffer = Buffer.from(manifestContent, "utf8");
+						mkdirp(
+							compiler.intermediateFileSystem,
+							dirname(compiler.intermediateFileSystem, targetPath),
+							err => {
+								if (err) return callback(err);
+								compiler.intermediateFileSystem.writeFile(
+									targetPath,
+									buffer,
+									callback
+								);
+							}
+						);
+					},
+					callback
+				);
 			}
 		);
 	}
 }
-
-class DllManifestError extends WebpackError {
-	constructor(filename, message) {
-		super();
-
-		this.name = "DllManifestError";
-		this.message = `Dll manifest ${filename}\n${message}`;
-	}
-}
-
-module.exports = DllReferencePlugin;
+module.exports = LibManifestPlugin;
 
 
 /***/ }),
 
-/***/ 96475:
+/***/ 14157:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Naoyuki Kanezawa @nkzawa
+	Author Tobias Koppers @sokra
 */
 
 
 
-const EntryOptionPlugin = __webpack_require__(9909);
-const EntryPlugin = __webpack_require__(96953);
-const EntryDependency = __webpack_require__(3979);
+const EnableLibraryPlugin = __webpack_require__(91452);
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDynamicNormalized} EntryDynamic */
-/** @typedef {import("../declarations/WebpackOptions").EntryItem} EntryItem */
-/** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStatic */
+/** @typedef {import("../declarations/WebpackOptions").AuxiliaryComment} AuxiliaryComment */
+/** @typedef {import("../declarations/WebpackOptions").LibraryExport} LibraryExport */
+/** @typedef {import("../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../declarations/WebpackOptions").UmdNamedDefine} UmdNamedDefine */
 /** @typedef {import("./Compiler")} Compiler */
 
-class DynamicEntryPlugin {
+// TODO webpack 6 remove
+class LibraryTemplatePlugin {
 	/**
-	 * @param {string} context the context path
-	 * @param {EntryDynamic} entry the entry value
+	 * @param {LibraryName} name name of library
+	 * @param {LibraryType} target type of library
+	 * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module
+	 * @param {AuxiliaryComment} auxiliaryComment comment in the UMD wrapper
+	 * @param {LibraryExport} exportProperty which export should be exposed as library
 	 */
-	constructor(context, entry) {
-		this.context = context;
-		this.entry = entry;
+	constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) {
+		this.library = {
+			type: target || "var",
+			name,
+			umdNamedDefine,
+			auxiliaryComment,
+			export: exportProperty
+		};
 	}
 
 	/**
@@ -40670,58 +43173,18 @@ class DynamicEntryPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DynamicEntryPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					EntryDependency,
-					normalModuleFactory
-				);
-			}
-		);
-
-		compiler.hooks.make.tapPromise(
-			"DynamicEntryPlugin",
-			(compilation, callback) =>
-				Promise.resolve(this.entry())
-					.then(entry => {
-						const promises = [];
-						for (const name of Object.keys(entry)) {
-							const desc = entry[name];
-							const options = EntryOptionPlugin.entryDescriptionToOptions(
-								compiler,
-								name,
-								desc
-							);
-							for (const entry of desc.import) {
-								promises.push(
-									new Promise((resolve, reject) => {
-										compilation.addEntry(
-											this.context,
-											EntryPlugin.createDependency(entry, options),
-											options,
-											err => {
-												if (err) return reject(err);
-												resolve();
-											}
-										);
-									})
-								);
-							}
-						}
-						return Promise.all(promises);
-					})
-					.then(x => {})
-		);
+		const { output } = compiler.options;
+		output.library = this.library;
+		new EnableLibraryPlugin(this.library.type).apply(compiler);
 	}
 }
 
-module.exports = DynamicEntryPlugin;
+module.exports = LibraryTemplatePlugin;
 
 
 /***/ }),
 
-/***/ 9909:
+/***/ 22078:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40732,96 +43195,75 @@ module.exports = DynamicEntryPlugin;
 
 
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const NormalModule = __webpack_require__(39);
+const createSchemaValidation = __webpack_require__(32540);
+
+/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
-class EntryOptionPlugin {
-	/**
-	 * @param {Compiler} compiler the compiler instance one is tapping into
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
-			EntryOptionPlugin.applyEntryOption(compiler, context, entry);
-			return true;
-		});
+const validate = createSchemaValidation(
+	__webpack_require__(24160),
+	() => __webpack_require__(15965),
+	{
+		name: "Loader Options Plugin",
+		baseDataPath: "options"
 	}
-
+);
+class LoaderOptionsPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @param {string} context context directory
-	 * @param {Entry} entry request
-	 * @returns {void}
+	 * @param {LoaderOptionsPluginOptions} options options object
 	 */
-	static applyEntryOption(compiler, context, entry) {
-		if (typeof entry === "function") {
-			const DynamicEntryPlugin = __webpack_require__(96475);
-			new DynamicEntryPlugin(context, entry).apply(compiler);
-		} else {
-			const EntryPlugin = __webpack_require__(96953);
-			for (const name of Object.keys(entry)) {
-				const desc = entry[name];
-				const options = EntryOptionPlugin.entryDescriptionToOptions(
-					compiler,
-					name,
-					desc
-				);
-				for (const entry of desc.import) {
-					new EntryPlugin(context, entry, options).apply(compiler);
-				}
-			}
+	constructor(options = {}) {
+		validate(options);
+		if (typeof options !== "object") options = {};
+		if (!options.test) {
+			options.test = {
+				test: () => true
+			};
 		}
+		this.options = options;
 	}
 
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @param {string} name entry name
-	 * @param {EntryDescription} desc entry description
-	 * @returns {EntryOptions} options for the entry
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	static entryDescriptionToOptions(compiler, name, desc) {
-		/** @type {EntryOptions} */
-		const options = {
-			name,
-			filename: desc.filename,
-			runtime: desc.runtime,
-			layer: desc.layer,
-			dependOn: desc.dependOn,
-			publicPath: desc.publicPath,
-			chunkLoading: desc.chunkLoading,
-			asyncChunks: desc.asyncChunks,
-			wasmLoading: desc.wasmLoading,
-			library: desc.library
-		};
-		if (desc.layer !== undefined && !compiler.options.experiments.layers) {
-			throw new Error(
-				"'entryOptions.layer' is only allowed when 'experiments.layers' is enabled"
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				"LoaderOptionsPlugin",
+				(context, module) => {
+					const resource = module.resource;
+					if (!resource) return;
+					const i = resource.indexOf("?");
+					if (
+						ModuleFilenameHelpers.matchObject(
+							options,
+							i < 0 ? resource : resource.substr(0, i)
+						)
+					) {
+						for (const key of Object.keys(options)) {
+							if (key === "include" || key === "exclude" || key === "test") {
+								continue;
+							}
+							context[key] = options[key];
+						}
+					}
+				}
 			);
-		}
-		if (desc.chunkLoading) {
-			const EnableChunkLoadingPlugin = __webpack_require__(61291);
-			EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading);
-		}
-		if (desc.wasmLoading) {
-			const EnableWasmLoadingPlugin = __webpack_require__(78613);
-			EnableWasmLoadingPlugin.checkEnabled(compiler, desc.wasmLoading);
-		}
-		if (desc.library) {
-			const EnableLibraryPlugin = __webpack_require__(91452);
-			EnableLibraryPlugin.checkEnabled(compiler, desc.library.type);
-		}
-		return options;
+		});
 	}
 }
 
-module.exports = EntryOptionPlugin;
+module.exports = LoaderOptionsPlugin;
 
 
 /***/ }),
 
-/***/ 96953:
+/***/ 86738:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40832,24 +43274,16 @@ module.exports = EntryOptionPlugin;
 
 
 
-const EntryDependency = __webpack_require__(3979);
+const NormalModule = __webpack_require__(39);
 
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
-class EntryPlugin {
+class LoaderTargetPlugin {
 	/**
-	 * An entry plugin which will handle
-	 * creation of the EntryDependency
-	 *
-	 * @param {string} context context path
-	 * @param {string} entry entry path
-	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
+	 * @param {string} target the target
 	 */
-	constructor(context, entry, options) {
-		this.context = context;
-		this.entry = entry;
-		this.options = options || "";
+	constructor(target) {
+		this.target = target;
 	}
 
 	/**
@@ -40858,45 +43292,23 @@ class EntryPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EntryPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					EntryDependency,
-					normalModuleFactory
-				);
-			}
-		);
-
-		const { entry, options, context } = this;
-		const dep = EntryPlugin.createDependency(entry, options);
-
-		compiler.hooks.make.tapAsync("EntryPlugin", (compilation, callback) => {
-			compilation.addEntry(context, dep, options, err => {
-				callback(err);
-			});
+		compiler.hooks.compilation.tap("LoaderTargetPlugin", compilation => {
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				"LoaderTargetPlugin",
+				loaderContext => {
+					loaderContext.target = this.target;
+				}
+			);
 		});
 	}
-
-	/**
-	 * @param {string} entry entry request
-	 * @param {EntryOptions | string} options entry options (passing string is deprecated)
-	 * @returns {EntryDependency} the dependency
-	 */
-	static createDependency(entry, options) {
-		const dep = new EntryDependency(entry);
-		// TODO webpack 6 remove string option
-		dep.loc = { name: typeof options === "object" ? options.name : options };
-		return dep;
-	}
 }
 
-module.exports = EntryPlugin;
+module.exports = LoaderTargetPlugin;
 
 
 /***/ }),
 
-/***/ 13795:
+/***/ 12856:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -40907,2115 +43319,1687 @@ module.exports = EntryPlugin;
 
 
 
-const ChunkGroup = __webpack_require__(15626);
+const { SyncWaterfallHook } = __webpack_require__(6967);
+const util = __webpack_require__(73837);
+const RuntimeGlobals = __webpack_require__(16475);
+const memoize = __webpack_require__(78676);
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Module")} Module} */
+/** @typedef {import("./util/Hash")} Hash} */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
+/** @typedef {import("./ModuleGraph")} ModuleGraph} */
+/** @typedef {import("./ChunkGraph")} ChunkGraph} */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions} */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry} */
 
-/** @typedef {{ name?: string } & Omit<EntryDescription, "import">} EntryOptions */
+const getJavascriptModulesPlugin = memoize(() =>
+	__webpack_require__(89464)
+);
+const getJsonpTemplatePlugin = memoize(() =>
+	__webpack_require__(4607)
+);
+const getLoadScriptRuntimeModule = memoize(() =>
+	__webpack_require__(19942)
+);
 
-/**
- * Entrypoint serves as an encapsulation primitive for chunks that are
- * a part of a single ChunkGroup. They represent all bundles that need to be loaded for a
- * single instance of a page. Multi-page application architectures will typically yield multiple Entrypoint objects
- * inside of the compilation, whereas a Single Page App may only contain one with many lazy-loaded chunks.
- */
-class Entrypoint extends ChunkGroup {
+// TODO webpack 6 remove this class
+class MainTemplate {
 	/**
-	 * Creates an instance of Entrypoint.
-	 * @param {EntryOptions | string} entryOptions the options for the entrypoint (or name)
-	 * @param {boolean=} initial false, when the entrypoint is not initial loaded
+	 *
+	 * @param {OutputOptions} outputOptions output options for the MainTemplate
+	 * @param {Compilation} compilation the compilation
 	 */
-	constructor(entryOptions, initial = true) {
-		if (typeof entryOptions === "string") {
-			entryOptions = { name: entryOptions };
-		}
-		super({
-			name: entryOptions.name
+	constructor(outputOptions, compilation) {
+		/** @type {OutputOptions} */
+		this._outputOptions = outputOptions || {};
+		this.hooks = Object.freeze({
+			renderManifest: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.renderManifest.tap(
+							options,
+							(entries, options) => {
+								if (!options.chunk.hasRuntime()) return entries;
+								return fn(entries, options);
+							}
+						);
+					},
+					"MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST"
+				)
+			},
+			modules: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)"
+					);
+				}
+			},
+			moduleObj: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)"
+					);
+				}
+			},
+			require: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderRequire.tap(options, fn);
+					},
+					"MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE"
+				)
+			},
+			beforeStartup: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)"
+					);
+				}
+			},
+			startup: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)"
+					);
+				}
+			},
+			afterStartup: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)"
+					);
+				}
+			},
+			render: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.render.tap(options, (source, renderContext) => {
+								if (
+									renderContext.chunkGraph.getNumberOfEntryModules(
+										renderContext.chunk
+									) === 0 ||
+									!renderContext.chunk.hasRuntime()
+								) {
+									return source;
+								}
+								return fn(
+									source,
+									renderContext.chunk,
+									compilation.hash,
+									compilation.moduleTemplates.javascript,
+									compilation.dependencyTemplates
+								);
+							});
+					},
+					"MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER"
+				)
+			},
+			renderWithEntry: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.render.tap(options, (source, renderContext) => {
+								if (
+									renderContext.chunkGraph.getNumberOfEntryModules(
+										renderContext.chunk
+									) === 0 ||
+									!renderContext.chunk.hasRuntime()
+								) {
+									return source;
+								}
+								return fn(source, renderContext.chunk, compilation.hash);
+							});
+					},
+					"MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY"
+				)
+			},
+			assetPath: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.assetPath.tap(options, fn);
+					},
+					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
+				),
+				call: util.deprecate(
+					(filename, options) => {
+						return compilation.getAssetPath(filename, options);
+					},
+					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
+				)
+			},
+			hash: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.fullHash.tap(options, fn);
+					},
+					"MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH"
+				)
+			},
+			hashForChunk: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.chunkHash.tap(options, (chunk, hash) => {
+								if (!chunk.hasRuntime()) return;
+								return fn(hash, chunk);
+							});
+					},
+					"MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			},
+			globalHashPaths: {
+				tap: util.deprecate(
+					() => {},
+					"MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			},
+			globalHash: {
+				tap: util.deprecate(
+					() => {},
+					"MainTemplate.hooks.globalHash has been removed (it's no longer needed)",
+					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
+				)
+			},
+			hotBootstrap: {
+				tap: () => {
+					throw new Error(
+						"MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)"
+					);
+				}
+			},
+
+			// for compatibility:
+			/** @type {SyncWaterfallHook<[string, Chunk, string, ModuleTemplate, DependencyTemplates]>} */
+			bootstrap: new SyncWaterfallHook([
+				"source",
+				"chunk",
+				"hash",
+				"moduleTemplate",
+				"dependencyTemplates"
+			]),
+			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
+			localVars: new SyncWaterfallHook(["source", "chunk", "hash"]),
+			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
+			requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]),
+			/** @type {SyncWaterfallHook<[string, Chunk, string, string]>} */
+			requireEnsure: new SyncWaterfallHook([
+				"source",
+				"chunk",
+				"hash",
+				"chunkIdExpression"
+			]),
+			get jsonpScript() {
+				const hooks =
+					getLoadScriptRuntimeModule().getCompilationHooks(compilation);
+				return hooks.createScript;
+			},
+			get linkPrefetch() {
+				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
+				return hooks.linkPrefetch;
+			},
+			get linkPreload() {
+				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
+				return hooks.linkPreload;
+			}
 		});
-		this.options = entryOptions;
-		/** @type {Chunk=} */
-		this._runtimeChunk = undefined;
-		/** @type {Chunk=} */
-		this._entrypointChunk = undefined;
-		/** @type {boolean} */
-		this._initial = initial;
-	}
 
-	/**
-	 * @returns {boolean} true, when this chunk group will be loaded on initial page load
-	 */
-	isInitial() {
-		return this._initial;
-	}
+		this.renderCurrentHashCode = util.deprecate(
+			/**
+			 * @deprecated
+			 * @param {string} hash the hash
+			 * @param {number=} length length of the hash
+			 * @returns {string} generated code
+			 */ (hash, length) => {
+				if (length) {
+					return `${RuntimeGlobals.getFullHash} ? ${
+						RuntimeGlobals.getFullHash
+					}().slice(0, ${length}) : ${hash.slice(0, length)}`;
+				}
+				return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`;
+			},
+			"MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE"
+		);
 
-	/**
-	 * Sets the runtimeChunk for an entrypoint.
-	 * @param {Chunk} chunk the chunk being set as the runtime chunk.
-	 * @returns {void}
-	 */
-	setRuntimeChunk(chunk) {
-		this._runtimeChunk = chunk;
-	}
+		this.getPublicPath = util.deprecate(
+			/**
+			 *
+			 * @param {object} options get public path options
+			 * @returns {string} hook call
+			 */ options => {
+				return compilation.getAssetPath(
+					compilation.outputOptions.publicPath,
+					options
+				);
+			},
+			"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
+		);
 
-	/**
-	 * Fetches the chunk reference containing the webpack bootstrap code
-	 * @returns {Chunk | null} returns the runtime chunk or null if there is none
-	 */
-	getRuntimeChunk() {
-		if (this._runtimeChunk) return this._runtimeChunk;
-		for (const parent of this.parentsIterable) {
-			if (parent instanceof Entrypoint) return parent.getRuntimeChunk();
-		}
-		return null;
-	}
+		this.getAssetPath = util.deprecate(
+			(path, options) => {
+				return compilation.getAssetPath(path, options);
+			},
+			"MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH"
+		);
 
-	/**
-	 * Sets the chunk with the entrypoint modules for an entrypoint.
-	 * @param {Chunk} chunk the chunk being set as the entrypoint chunk.
-	 * @returns {void}
-	 */
-	setEntrypointChunk(chunk) {
-		this._entrypointChunk = chunk;
+		this.getAssetPathWithInfo = util.deprecate(
+			(path, options) => {
+				return compilation.getAssetPathWithInfo(path, options);
+			},
+			"MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)",
+			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO"
+		);
 	}
+}
 
-	/**
-	 * Returns the chunk which contains the entrypoint modules
-	 * (or at least the execution of them)
-	 * @returns {Chunk} chunk
-	 */
-	getEntrypointChunk() {
-		return this._entrypointChunk;
-	}
+Object.defineProperty(MainTemplate.prototype, "requireFn", {
+	get: util.deprecate(
+		() => "__webpack_require__",
+		'MainTemplate.requireFn is deprecated (use "__webpack_require__")',
+		"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN"
+	)
+});
 
-	/**
-	 * @param {Chunk} oldChunk chunk to be replaced
-	 * @param {Chunk} newChunk New chunk that will be replaced with
-	 * @returns {boolean} returns true if the replacement was successful
-	 */
-	replaceChunk(oldChunk, newChunk) {
-		if (this._runtimeChunk === oldChunk) this._runtimeChunk = newChunk;
-		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
-		return super.replaceChunk(oldChunk, newChunk);
-	}
-}
+Object.defineProperty(MainTemplate.prototype, "outputOptions", {
+	get: util.deprecate(
+		/**
+		 * @this {MainTemplate}
+		 * @returns {OutputOptions} output options
+		 */
+		function () {
+			return this._outputOptions;
+		},
+		"MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
+		"DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
 
-module.exports = Entrypoint;
+module.exports = MainTemplate;
 
 
 /***/ }),
 
-/***/ 22070:
+/***/ 73208:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Authors Simen Brekken @simenbrekken, Einar Löve @einarlove
+	Author Tobias Koppers @sokra
 */
 
 
 
-const DefinePlugin = __webpack_require__(79065);
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DefinePlugin").CodeValue} CodeValue */
-
-class EnvironmentPlugin {
-	constructor(...keys) {
-		if (keys.length === 1 && Array.isArray(keys[0])) {
-			this.keys = keys[0];
-			this.defaultValues = {};
-		} else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
-			this.keys = Object.keys(keys[0]);
-			this.defaultValues = keys[0];
-		} else {
-			this.keys = keys;
-			this.defaultValues = {};
-		}
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		/** @type {Record<string, CodeValue>} */
-		const definitions = {};
-		for (const key of this.keys) {
-			const value =
-				process.env[key] !== undefined
-					? process.env[key]
-					: this.defaultValues[key];
+const util = __webpack_require__(73837);
+const ChunkGraph = __webpack_require__(64971);
+const DependenciesBlock = __webpack_require__(71040);
+const ModuleGraph = __webpack_require__(99988);
+const RuntimeGlobals = __webpack_require__(16475);
+const { first } = __webpack_require__(93347);
+const { compareChunksById } = __webpack_require__(29579);
+const makeSerializable = __webpack_require__(33032);
 
-			if (value === undefined) {
-				compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
-					const error = new WebpackError(
-						`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
-							"You can pass an object with default values to suppress this warning.\n" +
-							"See https://webpack.js.org/plugins/environment-plugin for example."
-					);
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ExportsInfo").UsageStateType} UsageStateType */
+/** @typedef {import("./FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
+/** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-					error.name = "EnvVariableNotDefinedError";
-					compilation.errors.push(error);
-				});
-			}
+/**
+ * @typedef {Object} SourceContext
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {RuntimeSpec} runtime the runtimes code should be generated for
+ * @property {string=} type the type of source that should be generated
+ */
 
-			definitions[`process.env.${key}`] =
-				value === undefined ? "undefined" : JSON.stringify(value);
-		}
+/**
+ * @typedef {Object} CodeGenerationContext
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {RuntimeSpec} runtime the runtimes code should be generated for
+ * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
+ * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
+ */
 
-		new DefinePlugin(definitions).apply(compiler);
-	}
-}
+/**
+ * @typedef {Object} ConcatenationBailoutReasonContext
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ */
 
-module.exports = EnvironmentPlugin;
+/**
+ * @typedef {Object} CodeGenerationResult
+ * @property {Map<string, Source>} sources the resulting sources for all source types
+ * @property {Map<string, any>=} data the resulting data for all source types
+ * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
+ * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
+ */
 
+/**
+ * @typedef {Object} LibIdentOptions
+ * @property {string} context absolute context path to which lib ident is relative to
+ * @property {Object=} associatedObjectForCache object for caching
+ */
 
-/***/ }),
+/**
+ * @typedef {Object} KnownBuildMeta
+ * @property {string=} moduleArgument
+ * @property {string=} exportsArgument
+ * @property {boolean=} strict
+ * @property {string=} moduleConcatenationBailout
+ * @property {("default" | "namespace" | "flagged" | "dynamic")=} exportsType
+ * @property {(false | "redirect" | "redirect-warn")=} defaultObject
+ * @property {boolean=} strictHarmonyModule
+ * @property {boolean=} async
+ * @property {boolean=} sideEffectFree
+ */
 
-/***/ 59985:
-/***/ (function(__unused_webpack_module, exports) {
+/**
+ * @typedef {Object} NeedBuildContext
+ * @property {Compilation} compilation
+ * @property {FileSystemInfo} fileSystemInfo
+ * @property {Map<string, string | Set<string>>} valueCacheVersions
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
 
+const EMPTY_RESOLVE_OPTIONS = {};
 
+let debugId = 1000;
 
-const loaderFlag = "LOADER_EXECUTION";
+const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
+const DEFAULT_TYPES_JS = new Set(["javascript"]);
 
-const webpackOptionsFlag = "WEBPACK_OPTIONS";
+const deprecatedNeedRebuild = util.deprecate(
+	(module, context) => {
+		return module.needRebuild(
+			context.fileSystemInfo.getDeprecatedFileTimestamps(),
+			context.fileSystemInfo.getDeprecatedContextTimestamps()
+		);
+	},
+	"Module.needRebuild is deprecated in favor of Module.needBuild",
+	"DEP_WEBPACK_MODULE_NEED_REBUILD"
+);
 
-exports.cutOffByFlag = (stack, flag) => {
-	stack = stack.split("\n");
-	for (let i = 0; i < stack.length; i++) {
-		if (stack[i].includes(flag)) {
-			stack.length = i;
-		}
-	}
-	return stack.join("\n");
-};
+/** @typedef {(requestShortener: RequestShortener) => string} OptimizationBailoutFunction */
 
-exports.cutOffLoaderExecution = stack =>
-	exports.cutOffByFlag(stack, loaderFlag);
+class Module extends DependenciesBlock {
+	/**
+	 * @param {string} type the module type
+	 * @param {string=} context an optional context
+	 * @param {string=} layer an optional layer in which the module is
+	 */
+	constructor(type, context = null, layer = null) {
+		super();
 
-exports.cutOffWebpackOptions = stack =>
-	exports.cutOffByFlag(stack, webpackOptionsFlag);
+		/** @type {string} */
+		this.type = type;
+		/** @type {string | null} */
+		this.context = context;
+		/** @type {string | null} */
+		this.layer = layer;
+		/** @type {boolean} */
+		this.needId = true;
 
-exports.cutOffMultilineMessage = (stack, message) => {
-	stack = stack.split("\n");
-	message = message.split("\n");
+		// Unique Id
+		/** @type {number} */
+		this.debugId = debugId++;
 
-	const result = [];
+		// Info from Factory
+		/** @type {ResolveOptions} */
+		this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
+		/** @type {object | undefined} */
+		this.factoryMeta = undefined;
+		// TODO refactor this -> options object filled from Factory
+		// TODO webpack 6: use an enum
+		/** @type {boolean} */
+		this.useSourceMap = false;
+		/** @type {boolean} */
+		this.useSimpleSourceMap = false;
 
-	stack.forEach((line, idx) => {
-		if (!line.includes(message[idx])) result.push(line);
-	});
+		// Info from Build
+		/** @type {WebpackError[] | undefined} */
+		this._warnings = undefined;
+		/** @type {WebpackError[] | undefined} */
+		this._errors = undefined;
+		/** @type {BuildMeta} */
+		this.buildMeta = undefined;
+		/** @type {Record<string, any>} */
+		this.buildInfo = undefined;
+		/** @type {Dependency[] | undefined} */
+		this.presentationalDependencies = undefined;
+		/** @type {Dependency[] | undefined} */
+		this.codeGenerationDependencies = undefined;
+	}
 
-	return result.join("\n");
-};
+	// TODO remove in webpack 6
+	// BACKWARD-COMPAT START
+	get id() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.id",
+			"DEP_WEBPACK_MODULE_ID"
+		).getModuleId(this);
+	}
 
-exports.cutOffMessage = (stack, message) => {
-	const nextLine = stack.indexOf("\n");
-	if (nextLine === -1) {
-		return stack === message ? "" : stack;
-	} else {
-		const firstLine = stack.substr(0, nextLine);
-		return firstLine === message ? stack.substr(nextLine + 1) : stack;
+	set id(value) {
+		if (value === "") {
+			this.needId = false;
+			return;
+		}
+		ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.id",
+			"DEP_WEBPACK_MODULE_ID"
+		).setModuleId(this, value);
 	}
-};
 
-exports.cleanUp = (stack, message) => {
-	stack = exports.cutOffLoaderExecution(stack);
-	stack = exports.cutOffMessage(stack, message);
-	return stack;
-};
+	/**
+	 * @returns {string} the hash of the module
+	 */
+	get hash() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.hash",
+			"DEP_WEBPACK_MODULE_HASH"
+		).getModuleHash(this, undefined);
+	}
 
-exports.cleanUpWebpackOptions = (stack, message) => {
-	stack = exports.cutOffWebpackOptions(stack);
-	stack = exports.cutOffMultilineMessage(stack, message);
-	return stack;
-};
+	/**
+	 * @returns {string} the shortened hash of the module
+	 */
+	get renderedHash() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.renderedHash",
+			"DEP_WEBPACK_MODULE_RENDERED_HASH"
+		).getRenderedModuleHash(this, undefined);
+	}
 
+	get profile() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.profile",
+			"DEP_WEBPACK_MODULE_PROFILE"
+		).getProfile(this);
+	}
 
-/***/ }),
+	set profile(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.profile",
+			"DEP_WEBPACK_MODULE_PROFILE"
+		).setProfile(this, value);
+	}
 
-/***/ 65218:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	get index() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index",
+			"DEP_WEBPACK_MODULE_INDEX"
+		).getPreOrderIndex(this);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	set index(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index",
+			"DEP_WEBPACK_MODULE_INDEX"
+		).setPreOrderIndex(this, value);
+	}
 
+	get index2() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index2",
+			"DEP_WEBPACK_MODULE_INDEX2"
+		).getPostOrderIndex(this);
+	}
 
+	set index2(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.index2",
+			"DEP_WEBPACK_MODULE_INDEX2"
+		).setPostOrderIndex(this, value);
+	}
 
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const ExternalModule = __webpack_require__(73071);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const RuntimeGlobals = __webpack_require__(16475);
-const JavascriptModulesPlugin = __webpack_require__(89464);
+	get depth() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.depth",
+			"DEP_WEBPACK_MODULE_DEPTH"
+		).getDepth(this);
+	}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Compiler")} Compiler */
+	set depth(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.depth",
+			"DEP_WEBPACK_MODULE_DEPTH"
+		).setDepth(this, value);
+	}
 
-/** @type {WeakMap<Source, Source>} */
-const cache = new WeakMap();
+	get issuer() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.issuer",
+			"DEP_WEBPACK_MODULE_ISSUER"
+		).getIssuer(this);
+	}
 
-const devtoolWarning = new RawSource(`/*
- * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
- * This devtool is neither made for production nor for readable output files.
- * It uses "eval()" calls to create a separate source file in the browser devtools.
- * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
- * or disable the default devtool with "devtool: false".
- * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
- */
-`);
+	set issuer(value) {
+		ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.issuer",
+			"DEP_WEBPACK_MODULE_ISSUER"
+		).setIssuer(this, value);
+	}
 
-class EvalDevToolModulePlugin {
-	constructor(options) {
-		this.namespace = options.namespace || "";
-		this.sourceUrlComment = options.sourceUrlComment || "\n//# sourceURL=[url]";
-		this.moduleFilenameTemplate =
-			options.moduleFilenameTemplate ||
-			"webpack://[namespace]/[resourcePath]?[loaders]";
+	get usedExports() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.usedExports",
+			"DEP_WEBPACK_MODULE_USED_EXPORTS"
+		).getUsedExports(this, undefined);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @deprecated
+	 * @returns {(string | OptimizationBailoutFunction)[]} list
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("EvalDevToolModulePlugin", compilation => {
-			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-			hooks.renderModuleContent.tap(
-				"EvalDevToolModulePlugin",
-				(source, module, { runtimeTemplate, chunkGraph }) => {
-					const cacheEntry = cache.get(source);
-					if (cacheEntry !== undefined) return cacheEntry;
-					if (module instanceof ExternalModule) {
-						cache.set(source, source);
-						return source;
-					}
-					const content = source.source();
-					const str = ModuleFilenameHelpers.createFilename(
-						module,
-						{
-							moduleFilenameTemplate: this.moduleFilenameTemplate,
-							namespace: this.namespace
-						},
-						{
-							requestShortener: runtimeTemplate.requestShortener,
-							chunkGraph,
-							hashFunction: compilation.outputOptions.hashFunction
-						}
-					);
-					const footer =
-						"\n" +
-						this.sourceUrlComment.replace(
-							/\[url\]/g,
-							encodeURI(str)
-								.replace(/%2F/g, "/")
-								.replace(/%20/g, "_")
-								.replace(/%5E/g, "^")
-								.replace(/%5C/g, "\\")
-								.replace(/^\//, "")
-						);
-					const result = new RawSource(
-						`eval(${
-							compilation.outputOptions.trustedTypes
-								? `${RuntimeGlobals.createScript}(${JSON.stringify(
-										content + footer
-								  )})`
-								: JSON.stringify(content + footer)
-						});`
-					);
-					cache.set(source, result);
-					return result;
-				}
-			);
-			hooks.inlineInRuntimeBailout.tap(
-				"EvalDevToolModulePlugin",
-				() => "the eval devtool is used."
-			);
-			hooks.render.tap(
-				"EvalDevToolModulePlugin",
-				source => new ConcatSource(devtoolWarning, source)
-			);
-			hooks.chunkHash.tap("EvalDevToolModulePlugin", (chunk, hash) => {
-				hash.update("EvalDevToolModulePlugin");
-				hash.update("2");
-			});
-			if (compilation.outputOptions.trustedTypes) {
-				compilation.hooks.additionalModuleRuntimeRequirements.tap(
-					"EvalDevToolModulePlugin",
-					(module, set, context) => {
-						set.add(RuntimeGlobals.createScript);
-					}
-				);
-			}
-		});
+	get optimizationBailout() {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.optimizationBailout",
+			"DEP_WEBPACK_MODULE_OPTIMIZATION_BAILOUT"
+		).getOptimizationBailout(this);
 	}
-}
-
-module.exports = EvalDevToolModulePlugin;
 
+	get optional() {
+		return this.isOptional(
+			ModuleGraph.getModuleGraphForModule(
+				this,
+				"Module.optional",
+				"DEP_WEBPACK_MODULE_OPTIONAL"
+			)
+		);
+	}
 
-/***/ }),
-
-/***/ 14790:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	addChunk(chunk) {
+		const chunkGraph = ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.addChunk",
+			"DEP_WEBPACK_MODULE_ADD_CHUNK"
+		);
+		if (chunkGraph.isModuleInChunk(this, chunk)) return false;
+		chunkGraph.connectChunkAndModule(chunk, this);
+		return true;
+	}
 
+	removeChunk(chunk) {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.removeChunk",
+			"DEP_WEBPACK_MODULE_REMOVE_CHUNK"
+		).disconnectChunkAndModule(chunk, this);
+	}
 
+	isInChunk(chunk) {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.isInChunk",
+			"DEP_WEBPACK_MODULE_IS_IN_CHUNK"
+		).isModuleInChunk(this, chunk);
+	}
 
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const NormalModule = __webpack_require__(39);
-const RuntimeGlobals = __webpack_require__(16475);
-const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const ConcatenatedModule = __webpack_require__(97198);
-const { makePathsAbsolute } = __webpack_require__(82186);
+	isEntryModule() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.isEntryModule",
+			"DEP_WEBPACK_MODULE_IS_ENTRY_MODULE"
+		).isEntryModule(this);
+	}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").DevTool} DevToolOptions */
-/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
+	getChunks() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.getChunks",
+			"DEP_WEBPACK_MODULE_GET_CHUNKS"
+		).getModuleChunks(this);
+	}
 
-/** @type {WeakMap<Source, Source>} */
-const cache = new WeakMap();
+	getNumberOfChunks() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.getNumberOfChunks",
+			"DEP_WEBPACK_MODULE_GET_NUMBER_OF_CHUNKS"
+		).getNumberOfModuleChunks(this);
+	}
 
-const devtoolWarning = new RawSource(`/*
- * ATTENTION: An "eval-source-map" devtool has been used.
- * This devtool is neither made for production nor for readable output files.
- * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
- * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
- * or disable the default devtool with "devtool: false".
- * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
- */
-`);
+	get chunksIterable() {
+		return ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.chunksIterable",
+			"DEP_WEBPACK_MODULE_CHUNKS_ITERABLE"
+		).getOrderedModuleChunksIterable(this, compareChunksById);
+	}
 
-class EvalSourceMapDevToolPlugin {
 	/**
-	 * @param {SourceMapDevToolPluginOptions|string} inputOptions Options object
+	 * @param {string} exportName a name of an export
+	 * @returns {boolean | null} true, if the export is provided why the module.
+	 * null, if it's unknown.
+	 * false, if it's not provided.
 	 */
-	constructor(inputOptions) {
-		/** @type {SourceMapDevToolPluginOptions} */
-		let options;
-		if (typeof inputOptions === "string") {
-			options = {
-				append: inputOptions
-			};
-		} else {
-			options = inputOptions;
-		}
-		this.sourceMapComment =
-			options.append || "//# sourceURL=[module]\n//# sourceMappingURL=[url]";
-		this.moduleFilenameTemplate =
-			options.moduleFilenameTemplate ||
-			"webpack://[namespace]/[resource-path]?[hash]";
-		this.namespace = options.namespace || "";
-		this.options = options;
+	isProvided(exportName) {
+		return ModuleGraph.getModuleGraphForModule(
+			this,
+			"Module.usedExports",
+			"DEP_WEBPACK_MODULE_USED_EXPORTS"
+		).isExportProvided(this, exportName);
 	}
+	// BACKWARD-COMPAT END
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} name of the exports argument
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap(
-			"EvalSourceMapDevToolPlugin",
-			compilation => {
-				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
-				const matchModule = ModuleFilenameHelpers.matchObject.bind(
-					ModuleFilenameHelpers,
-					options
-				);
-				hooks.renderModuleContent.tap(
-					"EvalSourceMapDevToolPlugin",
-					(source, m, { runtimeTemplate, chunkGraph }) => {
-						const cachedSource = cache.get(source);
-						if (cachedSource !== undefined) {
-							return cachedSource;
-						}
-
-						const result = r => {
-							cache.set(source, r);
-							return r;
-						};
-
-						if (m instanceof NormalModule) {
-							const module = /** @type {NormalModule} */ (m);
-							if (!matchModule(module.resource)) {
-								return result(source);
-							}
-						} else if (m instanceof ConcatenatedModule) {
-							const concatModule = /** @type {ConcatenatedModule} */ (m);
-							if (concatModule.rootModule instanceof NormalModule) {
-								const module = /** @type {NormalModule} */ (
-									concatModule.rootModule
-								);
-								if (!matchModule(module.resource)) {
-									return result(source);
-								}
-							} else {
-								return result(source);
-							}
-						} else {
-							return result(source);
-						}
-
-						/** @type {{ [key: string]: TODO; }} */
-						let sourceMap;
-						let content;
-						if (source.sourceAndMap) {
-							const sourceAndMap = source.sourceAndMap(options);
-							sourceMap = sourceAndMap.map;
-							content = sourceAndMap.source;
-						} else {
-							sourceMap = source.map(options);
-							content = source.source();
-						}
-						if (!sourceMap) {
-							return result(source);
-						}
-
-						// Clone (flat) the sourcemap to ensure that the mutations below do not persist.
-						sourceMap = { ...sourceMap };
-						const context = compiler.options.context;
-						const root = compiler.root;
-						const modules = sourceMap.sources.map(source => {
-							if (!source.startsWith("webpack://")) return source;
-							source = makePathsAbsolute(context, source.slice(10), root);
-							const module = compilation.findModule(source);
-							return module || source;
-						});
-						let moduleFilenames = modules.map(module => {
-							return ModuleFilenameHelpers.createFilename(
-								module,
-								{
-									moduleFilenameTemplate: this.moduleFilenameTemplate,
-									namespace: this.namespace
-								},
-								{
-									requestShortener: runtimeTemplate.requestShortener,
-									chunkGraph,
-									hashFunction: compilation.outputOptions.hashFunction
-								}
-							);
-						});
-						moduleFilenames = ModuleFilenameHelpers.replaceDuplicates(
-							moduleFilenames,
-							(filename, i, n) => {
-								for (let j = 0; j < n; j++) filename += "*";
-								return filename;
-							}
-						);
-						sourceMap.sources = moduleFilenames;
-						sourceMap.sourceRoot = options.sourceRoot || "";
-						const moduleId = chunkGraph.getModuleId(m);
-						sourceMap.file = `${moduleId}.js`;
+	get exportsArgument() {
+		return (this.buildInfo && this.buildInfo.exportsArgument) || "exports";
+	}
 
-						const footer =
-							this.sourceMapComment.replace(
-								/\[url\]/g,
-								`data:application/json;charset=utf-8;base64,${Buffer.from(
-									JSON.stringify(sourceMap),
-									"utf8"
-								).toString("base64")}`
-							) + `\n//# sourceURL=webpack-internal:///${moduleId}\n`; // workaround for chrome bug
+	/**
+	 * @returns {string} name of the module argument
+	 */
+	get moduleArgument() {
+		return (this.buildInfo && this.buildInfo.moduleArgument) || "module";
+	}
 
-						return result(
-							new RawSource(
-								`eval(${
-									compilation.outputOptions.trustedTypes
-										? `${RuntimeGlobals.createScript}(${JSON.stringify(
-												content + footer
-										  )})`
-										: JSON.stringify(content + footer)
-								});`
-							)
-						);
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {boolean} strict the importing module is strict
+	 * @returns {"namespace" | "default-only" | "default-with-named" | "dynamic"} export type
+	 * "namespace": Exports is already a namespace object. namespace = exports.
+	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 */
+	getExportsType(moduleGraph, strict) {
+		switch (this.buildMeta && this.buildMeta.exportsType) {
+			case "flagged":
+				return strict ? "default-with-named" : "namespace";
+			case "namespace":
+				return "namespace";
+			case "default":
+				switch (this.buildMeta.defaultObject) {
+					case "redirect":
+						return "default-with-named";
+					case "redirect-warn":
+						return strict ? "default-only" : "default-with-named";
+					default:
+						return "default-only";
+				}
+			case "dynamic": {
+				if (strict) return "default-with-named";
+				// Try to figure out value of __esModule by following reexports
+				const handleDefault = () => {
+					switch (this.buildMeta.defaultObject) {
+						case "redirect":
+						case "redirect-warn":
+							return "default-with-named";
+						default:
+							return "default-only";
 					}
+				};
+				const exportInfo = moduleGraph.getReadOnlyExportInfo(
+					this,
+					"__esModule"
 				);
-				hooks.inlineInRuntimeBailout.tap(
-					"EvalDevToolModulePlugin",
-					() => "the eval-source-map devtool is used."
-				);
-				hooks.render.tap(
-					"EvalSourceMapDevToolPlugin",
-					source => new ConcatSource(devtoolWarning, source)
-				);
-				hooks.chunkHash.tap("EvalSourceMapDevToolPlugin", (chunk, hash) => {
-					hash.update("EvalSourceMapDevToolPlugin");
-					hash.update("2");
-				});
-				if (compilation.outputOptions.trustedTypes) {
-					compilation.hooks.additionalModuleRuntimeRequirements.tap(
-						"EvalSourceMapDevToolPlugin",
-						(module, set, context) => {
-							set.add(RuntimeGlobals.createScript);
-						}
-					);
+				if (exportInfo.provided === false) {
+					return handleDefault();
+				}
+				const target = exportInfo.getTarget(moduleGraph);
+				if (
+					!target ||
+					!target.export ||
+					target.export.length !== 1 ||
+					target.export[0] !== "__esModule"
+				) {
+					return "dynamic";
+				}
+				switch (
+					target.module.buildMeta &&
+					target.module.buildMeta.exportsType
+				) {
+					case "flagged":
+					case "namespace":
+						return "namespace";
+					case "default":
+						return handleDefault();
+					default:
+						return "dynamic";
 				}
 			}
-		);
+			default:
+				return strict ? "default-with-named" : "dynamic";
+		}
 	}
-}
-
-module.exports = EvalSourceMapDevToolPlugin;
-
-
-/***/ }),
-
-/***/ 63686:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { equals } = __webpack_require__(84953);
-const SortableSet = __webpack_require__(13098);
-const makeSerializable = __webpack_require__(33032);
-const { forEachRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./util/Hash")} Hash */
-
-/** @typedef {typeof UsageState.OnlyPropertiesUsed | typeof UsageState.NoInfo | typeof UsageState.Unknown | typeof UsageState.Used} RuntimeUsageStateType */
-/** @typedef {typeof UsageState.Unused | RuntimeUsageStateType} UsageStateType */
 
-const UsageState = Object.freeze({
-	Unused: /** @type {0} */ (0),
-	OnlyPropertiesUsed: /** @type {1} */ (1),
-	NoInfo: /** @type {2} */ (2),
-	Unknown: /** @type {3} */ (3),
-	Used: /** @type {4} */ (4)
-});
+	/**
+	 * @param {Dependency} presentationalDependency dependency being tied to module.
+	 * This is a Dependency without edge in the module graph. It's only for presentation.
+	 * @returns {void}
+	 */
+	addPresentationalDependency(presentationalDependency) {
+		if (this.presentationalDependencies === undefined) {
+			this.presentationalDependencies = [];
+		}
+		this.presentationalDependencies.push(presentationalDependency);
+	}
 
-const RETURNS_TRUE = () => true;
+	/**
+	 * @param {Dependency} codeGenerationDependency dependency being tied to module.
+	 * This is a Dependency where the code generation result of the referenced module is needed during code generation.
+	 * The Dependency should also be added to normal dependencies via addDependency.
+	 * @returns {void}
+	 */
+	addCodeGenerationDependency(codeGenerationDependency) {
+		if (this.codeGenerationDependencies === undefined) {
+			this.codeGenerationDependencies = [];
+		}
+		this.codeGenerationDependencies.push(codeGenerationDependency);
+	}
 
-const CIRCULAR = Symbol("circular target");
+	/**
+	 * Removes all dependencies and blocks
+	 * @returns {void}
+	 */
+	clearDependenciesAndBlocks() {
+		if (this.presentationalDependencies !== undefined) {
+			this.presentationalDependencies.length = 0;
+		}
+		if (this.codeGenerationDependencies !== undefined) {
+			this.codeGenerationDependencies.length = 0;
+		}
+		super.clearDependenciesAndBlocks();
+	}
 
-class RestoreProvidedData {
-	constructor(
-		exports,
-		otherProvided,
-		otherCanMangleProvide,
-		otherTerminalBinding
-	) {
-		this.exports = exports;
-		this.otherProvided = otherProvided;
-		this.otherCanMangleProvide = otherCanMangleProvide;
-		this.otherTerminalBinding = otherTerminalBinding;
+	/**
+	 * @param {WebpackError} warning the warning
+	 * @returns {void}
+	 */
+	addWarning(warning) {
+		if (this._warnings === undefined) {
+			this._warnings = [];
+		}
+		this._warnings.push(warning);
 	}
 
-	serialize({ write }) {
-		write(this.exports);
-		write(this.otherProvided);
-		write(this.otherCanMangleProvide);
-		write(this.otherTerminalBinding);
+	/**
+	 * @returns {Iterable<WebpackError> | undefined} list of warnings if any
+	 */
+	getWarnings() {
+		return this._warnings;
 	}
 
-	static deserialize({ read }) {
-		return new RestoreProvidedData(read(), read(), read(), read());
+	/**
+	 * @returns {number} number of warnings
+	 */
+	getNumberOfWarnings() {
+		return this._warnings !== undefined ? this._warnings.length : 0;
 	}
-}
 
-makeSerializable(
-	RestoreProvidedData,
-	"webpack/lib/ModuleGraph",
-	"RestoreProvidedData"
-);
+	/**
+	 * @param {WebpackError} error the error
+	 * @returns {void}
+	 */
+	addError(error) {
+		if (this._errors === undefined) {
+			this._errors = [];
+		}
+		this._errors.push(error);
+	}
 
-class ExportsInfo {
-	constructor() {
-		/** @type {Map<string, ExportInfo>} */
-		this._exports = new Map();
-		this._otherExportsInfo = new ExportInfo(null);
-		this._sideEffectsOnlyInfo = new ExportInfo("*side effects only*");
-		this._exportsAreOrdered = false;
-		/** @type {ExportsInfo=} */
-		this._redirectTo = undefined;
+	/**
+	 * @returns {Iterable<WebpackError> | undefined} list of errors if any
+	 */
+	getErrors() {
+		return this._errors;
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all owned exports in any order
+	 * @returns {number} number of errors
 	 */
-	get ownedExports() {
-		return this._exports.values();
+	getNumberOfErrors() {
+		return this._errors !== undefined ? this._errors.length : 0;
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all owned exports in order
+	 * removes all warnings and errors
+	 * @returns {void}
 	 */
-	get orderedOwnedExports() {
-		if (!this._exportsAreOrdered) {
-			this._sortExports();
+	clearWarningsAndErrors() {
+		if (this._warnings !== undefined) {
+			this._warnings.length = 0;
+		}
+		if (this._errors !== undefined) {
+			this._errors.length = 0;
 		}
-		return this._exports.values();
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all exports in any order
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {boolean} true, if the module is optional
 	 */
-	get exports() {
-		if (this._redirectTo !== undefined) {
-			const map = new Map(this._redirectTo._exports);
-			for (const [key, value] of this._exports) {
-				map.set(key, value);
+	isOptional(moduleGraph) {
+		let hasConnections = false;
+		for (const r of moduleGraph.getIncomingConnections(this)) {
+			if (
+				!r.dependency ||
+				!r.dependency.optional ||
+				!r.isTargetActive(undefined)
+			) {
+				return false;
 			}
-			return map.values();
+			hasConnections = true;
 		}
-		return this._exports.values();
+		return hasConnections;
 	}
 
 	/**
-	 * @returns {Iterable<ExportInfo>} all exports in order
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {Chunk} chunk a chunk
+	 * @param {Chunk=} ignoreChunk chunk to be ignored
+	 * @returns {boolean} true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
 	 */
-	get orderedExports() {
-		if (!this._exportsAreOrdered) {
-			this._sortExports();
-		}
-		if (this._redirectTo !== undefined) {
-			const map = new Map(
-				Array.from(this._redirectTo.orderedExports, item => [item.name, item])
-			);
-			for (const [key, value] of this._exports) {
-				map.set(key, value);
-			}
-			// sorting should be pretty fast as map contains
-			// a lot of presorted items
-			this._sortExportsMap(map);
-			return map.values();
+	isAccessibleInChunk(chunkGraph, chunk, ignoreChunk) {
+		// Check if module is accessible in ALL chunk groups
+		for (const chunkGroup of chunk.groupsIterable) {
+			if (!this.isAccessibleInChunkGroup(chunkGraph, chunkGroup)) return false;
 		}
-		return this._exports.values();
+		return true;
 	}
 
 	/**
-	 * @returns {ExportInfo} the export info of unlisted exports
-	 */
-	get otherExportsInfo() {
-		if (this._redirectTo !== undefined)
-			return this._redirectTo.otherExportsInfo;
-		return this._otherExportsInfo;
-	}
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ChunkGroup} chunkGroup a chunk group
+	 * @param {Chunk=} ignoreChunk chunk to be ignored
+	 * @returns {boolean} true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"
+	 */
+	isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk) {
+		const queue = new Set([chunkGroup]);
 
-	_sortExportsMap(exports) {
-		if (exports.size > 1) {
-			const namesInOrder = [];
-			for (const entry of exports.values()) {
-				namesInOrder.push(entry.name);
-			}
-			namesInOrder.sort();
-			let i = 0;
-			for (const entry of exports.values()) {
-				const name = namesInOrder[i];
-				if (entry.name !== name) break;
-				i++;
+		// Check if module is accessible from all items of the queue
+		queueFor: for (const cg of queue) {
+			// 1. If module is in one of the chunks of the group we can continue checking the next items
+			//    because it's accessible.
+			for (const chunk of cg.chunks) {
+				if (chunk !== ignoreChunk && chunkGraph.isModuleInChunk(this, chunk))
+					continue queueFor;
 			}
-			for (; i < namesInOrder.length; i++) {
-				const name = namesInOrder[i];
-				const correctEntry = exports.get(name);
-				exports.delete(name);
-				exports.set(name, correctEntry);
+			// 2. If the chunk group is initial, we can break here because it's not accessible.
+			if (chunkGroup.isInitial()) return false;
+			// 3. Enqueue all parents because it must be accessible from ALL parents
+			for (const parent of chunkGroup.parentsIterable) queue.add(parent);
+		}
+		// When we processed through the whole list and we didn't bailout, the module is accessible
+		return true;
+	}
+
+	/**
+	 * @param {Chunk} chunk a chunk
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {boolean} true, if the module has any reason why "chunk" should be included
+	 */
+	hasReasonForChunk(chunk, moduleGraph, chunkGraph) {
+		// check for each reason if we need the chunk
+		for (const [
+			fromModule,
+			connections
+		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
+			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
+			for (const originChunk of chunkGraph.getModuleChunksIterable(
+				fromModule
+			)) {
+				// return true if module this is not reachable from originChunk when ignoring chunk
+				if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk))
+					return true;
 			}
 		}
+		return false;
 	}
 
-	_sortExports() {
-		this._sortExportsMap(this._exports);
-		this._exportsAreOrdered = true;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true if at least one other module depends on this module
+	 */
+	hasReasons(moduleGraph, runtime) {
+		for (const c of moduleGraph.getIncomingConnections(this)) {
+			if (c.isTargetActive(runtime)) return true;
+		}
+		return false;
 	}
 
-	setRedirectNamedTo(exportsInfo) {
-		if (this._redirectTo === exportsInfo) return false;
-		this._redirectTo = exportsInfo;
-		return true;
+	/**
+	 * @returns {string} for debugging
+	 */
+	toString() {
+		return `Module[${this.debugId}: ${this.identifier()}]`;
 	}
 
-	setHasProvideInfo() {
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.provided === undefined) {
-				exportInfo.provided = false;
-			}
-			if (exportInfo.canMangleProvide === undefined) {
-				exportInfo.canMangleProvide = true;
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			this._redirectTo.setHasProvideInfo();
-		} else {
-			if (this._otherExportsInfo.provided === undefined) {
-				this._otherExportsInfo.provided = false;
-			}
-			if (this._otherExportsInfo.canMangleProvide === undefined) {
-				this._otherExportsInfo.canMangleProvide = true;
-			}
-		}
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(
+			null,
+			!this.buildMeta ||
+				this.needRebuild === Module.prototype.needRebuild ||
+				deprecatedNeedRebuild(this, context)
+		);
 	}
 
-	setHasUseInfo() {
-		for (const exportInfo of this._exports.values()) {
-			exportInfo.setHasUseInfo();
+	/**
+	 * @deprecated Use needBuild instead
+	 * @param {Map<string, number|null>} fileTimestamps timestamps of files
+	 * @param {Map<string, number|null>} contextTimestamps timestamps of directories
+	 * @returns {boolean} true, if the module needs a rebuild
+	 */
+	needRebuild(fileTimestamps, contextTimestamps) {
+		return true;
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(
+		hash,
+		context = {
+			chunkGraph: ChunkGraph.getChunkGraphForModule(
+				this,
+				"Module.updateHash",
+				"DEP_WEBPACK_MODULE_UPDATE_HASH"
+			),
+			runtime: undefined
 		}
-		this._sideEffectsOnlyInfo.setHasUseInfo();
-		if (this._redirectTo !== undefined) {
-			this._redirectTo.setHasUseInfo();
-		} else {
-			this._otherExportsInfo.setHasUseInfo();
-			if (this._otherExportsInfo.canMangleUse === undefined) {
-				this._otherExportsInfo.canMangleUse = true;
+	) {
+		const { chunkGraph, runtime } = context;
+		hash.update(chunkGraph.getModuleGraphHash(this, runtime));
+		if (this.presentationalDependencies !== undefined) {
+			for (const dep of this.presentationalDependencies) {
+				dep.updateHash(hash, context);
 			}
 		}
+		super.updateHash(hash, context);
 	}
 
 	/**
-	 * @param {string} name export name
-	 * @returns {ExportInfo} export info for this name
+	 * @returns {void}
 	 */
-	getOwnExportInfo(name) {
-		const info = this._exports.get(name);
-		if (info !== undefined) return info;
-		const newInfo = new ExportInfo(name, this._otherExportsInfo);
-		this._exports.set(name, newInfo);
-		this._exportsAreOrdered = false;
-		return newInfo;
+	invalidateBuild() {
+		// should be overridden to support this feature
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {string} name export name
-	 * @returns {ExportInfo} export info for this name
+	 * @abstract
+	 * @returns {string} a unique identifier of the module
 	 */
-	getExportInfo(name) {
-		const info = this._exports.get(name);
-		if (info !== undefined) return info;
-		if (this._redirectTo !== undefined)
-			return this._redirectTo.getExportInfo(name);
-		const newInfo = new ExportInfo(name, this._otherExportsInfo);
-		this._exports.set(name, newInfo);
-		this._exportsAreOrdered = false;
-		return newInfo;
+	identifier() {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {string} name export name
-	 * @returns {ExportInfo} export info for this name
+	 * @abstract
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	getReadOnlyExportInfo(name) {
-		const info = this._exports.get(name);
-		if (info !== undefined) return info;
-		if (this._redirectTo !== undefined)
-			return this._redirectTo.getReadOnlyExportInfo(name);
-		return this._otherExportsInfo;
+	readableIdentifier(requestShortener) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {string[]} name export name
-	 * @returns {ExportInfo | undefined} export info for this name
+	 * @abstract
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
 	 */
-	getReadOnlyExportInfoRecursive(name) {
-		const exportInfo = this.getReadOnlyExportInfo(name[0]);
-		if (name.length === 1) return exportInfo;
-		if (!exportInfo.exportsInfo) return undefined;
-		return exportInfo.exportsInfo.getReadOnlyExportInfoRecursive(name.slice(1));
+	build(options, compilation, resolver, fs, callback) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
 	/**
-	 * @param {string[]=} name the export name
-	 * @returns {ExportsInfo | undefined} the nested exports info
+	 * @abstract
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	getNestedExportsInfo(name) {
-		if (Array.isArray(name) && name.length > 0) {
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (!info.exportsInfo) return undefined;
-			return info.exportsInfo.getNestedExportsInfo(name.slice(1));
+	getSourceTypes() {
+		// Better override this method to return the correct types
+		if (this.source === Module.prototype.source) {
+			return DEFAULT_TYPES_UNKNOWN;
+		} else {
+			return DEFAULT_TYPES_JS;
 		}
-		return this;
 	}
 
 	/**
-	 * @param {boolean=} canMangle true, if exports can still be mangled (defaults to false)
-	 * @param {Set<string>=} excludeExports list of unaffected exports
-	 * @param {any=} targetKey use this as key for the target
-	 * @param {ModuleGraphConnection=} targetModule set this module as target
-	 * @param {number=} priority priority
-	 * @returns {boolean} true, if this call changed something
+	 * @abstract
+	 * @deprecated Use codeGeneration() instead
+	 * @param {DependencyTemplates} dependencyTemplates the dependency templates
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {string=} type the type of source that should be generated
+	 * @returns {Source} generated source
 	 */
-	setUnknownExportsProvided(
-		canMangle,
-		excludeExports,
-		targetKey,
-		targetModule,
-		priority
-	) {
-		let changed = false;
-		if (excludeExports) {
-			for (const name of excludeExports) {
-				// Make sure these entries exist, so they can get different info
-				this.getExportInfo(name);
-			}
-		}
-		for (const exportInfo of this._exports.values()) {
-			if (excludeExports && excludeExports.has(exportInfo.name)) continue;
-			if (exportInfo.provided !== true && exportInfo.provided !== null) {
-				exportInfo.provided = null;
-				changed = true;
-			}
-			if (!canMangle && exportInfo.canMangleProvide !== false) {
-				exportInfo.canMangleProvide = false;
-				changed = true;
-			}
-			if (targetKey) {
-				exportInfo.setTarget(targetKey, targetModule, [exportInfo.name], -1);
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			if (
-				this._redirectTo.setUnknownExportsProvided(
-					canMangle,
-					excludeExports,
-					targetKey,
-					targetModule,
-					priority
-				)
-			) {
-				changed = true;
-			}
-		} else {
-			if (
-				this._otherExportsInfo.provided !== true &&
-				this._otherExportsInfo.provided !== null
-			) {
-				this._otherExportsInfo.provided = null;
-				changed = true;
-			}
-			if (!canMangle && this._otherExportsInfo.canMangleProvide !== false) {
-				this._otherExportsInfo.canMangleProvide = false;
-				changed = true;
-			}
-			if (targetKey) {
-				this._otherExportsInfo.setTarget(
-					targetKey,
-					targetModule,
-					undefined,
-					priority
-				);
-			}
+	source(dependencyTemplates, runtimeTemplate, type = "javascript") {
+		if (this.codeGeneration === Module.prototype.codeGeneration) {
+			const AbstractMethodError = __webpack_require__(77198);
+			throw new AbstractMethodError();
 		}
-		return changed;
+		const chunkGraph = ChunkGraph.getChunkGraphForModule(
+			this,
+			"Module.source() is deprecated. Use Compilation.codeGenerationResults.getSource(module, runtime, type) instead",
+			"DEP_WEBPACK_MODULE_SOURCE"
+		);
+		/** @type {CodeGenerationContext} */
+		const codeGenContext = {
+			dependencyTemplates,
+			runtimeTemplate,
+			moduleGraph: chunkGraph.moduleGraph,
+			chunkGraph,
+			runtime: undefined,
+			codeGenerationResults: undefined
+		};
+		const sources = this.codeGeneration(codeGenContext).sources;
+		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
+	 * @abstract
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	setUsedInUnknownWay(runtime) {
-		let changed = false;
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.setUsedInUnknownWay(runtime)) {
-				changed = true;
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			if (this._redirectTo.setUsedInUnknownWay(runtime)) {
-				changed = true;
-			}
-		} else {
-			if (
-				this._otherExportsInfo.setUsedConditionally(
-					used => used < UsageState.Unknown,
-					UsageState.Unknown,
-					runtime
-				)
-			) {
-				changed = true;
-			}
-			if (this._otherExportsInfo.canMangleUse !== false) {
-				this._otherExportsInfo.canMangleUse = false;
-				changed = true;
-			}
-		}
-		return changed;
+	size(type) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	setUsedWithoutInfo(runtime) {
-		let changed = false;
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.setUsedWithoutInfo(runtime)) {
-				changed = true;
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			if (this._redirectTo.setUsedWithoutInfo(runtime)) {
-				changed = true;
-			}
-		} else {
-			if (this._otherExportsInfo.setUsed(UsageState.NoInfo, runtime)) {
-				changed = true;
-			}
-			if (this._otherExportsInfo.canMangleUse !== false) {
-				this._otherExportsInfo.canMangleUse = false;
-				changed = true;
-			}
-		}
-		return changed;
+	libIdent(options) {
+		return null;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
-	setAllKnownExportsUsed(runtime) {
-		let changed = false;
-		for (const exportInfo of this._exports.values()) {
-			if (!exportInfo.provided) continue;
-			if (exportInfo.setUsed(UsageState.Used, runtime)) {
-				changed = true;
-			}
-		}
-		return changed;
+	nameForCondition() {
+		return null;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when something changed
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
-	setUsedForSideEffectsOnly(runtime) {
-		return this._sideEffectsOnlyInfo.setUsedConditionally(
-			used => used === UsageState.Unused,
-			UsageState.Used,
-			runtime
-		);
+	getConcatenationBailoutReason(context) {
+		return `Module Concatenation is not implemented for ${this.constructor.name}`;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when the module exports are used in any way
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
-	isUsed(runtime) {
-		if (this._redirectTo !== undefined) {
-			if (this._redirectTo.isUsed(runtime)) {
-				return true;
-			}
-		} else {
-			if (this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
-				return true;
-			}
-		}
-		for (const exportInfo of this._exports.values()) {
-			if (exportInfo.getUsed(runtime) !== UsageState.Unused) {
-				return true;
+	getSideEffectsConnectionState(moduleGraph) {
+		return true;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration(context) {
+		// Best override this method
+		const sources = new Map();
+		for (const type of this.getSourceTypes()) {
+			if (type !== "unknown") {
+				sources.set(
+					type,
+					this.source(
+						context.dependencyTemplates,
+						context.runtimeTemplate,
+						type
+					)
+				);
 			}
 		}
-		return false;
+		return {
+			sources,
+			runtimeRequirements: new Set([
+				RuntimeGlobals.module,
+				RuntimeGlobals.exports,
+				RuntimeGlobals.require
+			])
+		};
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, when the module is used in any way
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
 	 */
-	isModuleUsed(runtime) {
-		if (this.isUsed(runtime)) return true;
-		if (this._sideEffectsOnlyInfo.getUsed(runtime) !== UsageState.Unused)
-			return true;
-		return false;
+	chunkCondition(chunk, compilation) {
+		return true;
+	}
+
+	hasChunkCondition() {
+		return this.chunkCondition !== Module.prototype.chunkCondition;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {SortableSet<string> | boolean | null} set of used exports, or true (when namespace object is used), or false (when unused), or null (when unknown)
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
 	 */
-	getUsedExports(runtime) {
-		if (!this._redirectTo !== undefined) {
-			switch (this._otherExportsInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unknown:
-				case UsageState.OnlyPropertiesUsed:
-				case UsageState.Used:
-					return true;
-			}
-		}
-		const array = [];
-		if (!this._exportsAreOrdered) this._sortExports();
-		for (const exportInfo of this._exports.values()) {
-			switch (exportInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unknown:
-					return true;
-				case UsageState.OnlyPropertiesUsed:
-				case UsageState.Used:
-					array.push(exportInfo.name);
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			const inner = this._redirectTo.getUsedExports(runtime);
-			if (inner === null) return null;
-			if (inner === true) return true;
-			if (inner !== false) {
-				for (const item of inner) {
-					array.push(item);
-				}
-			}
-		}
-		if (array.length === 0) {
-			switch (this._sideEffectsOnlyInfo.getUsed(runtime)) {
-				case UsageState.NoInfo:
-					return null;
-				case UsageState.Unused:
-					return false;
-			}
-		}
-		return new SortableSet(array);
+	updateCacheModule(module) {
+		this.type = module.type;
+		this.layer = module.layer;
+		this.context = module.context;
+		this.factoryMeta = module.factoryMeta;
+		this.resolveOptions = module.resolveOptions;
 	}
 
 	/**
-	 * @returns {null | true | string[]} list of exports when known
+	 * Module should be unsafe cached. Get data that's needed for that.
+	 * This data will be passed to restoreFromUnsafeCache later.
+	 * @returns {object} cached data
 	 */
-	getProvidedExports() {
-		if (!this._redirectTo !== undefined) {
-			switch (this._otherExportsInfo.provided) {
-				case undefined:
-					return null;
-				case null:
-					return true;
-				case true:
-					return true;
-			}
-		}
-		const array = [];
-		if (!this._exportsAreOrdered) this._sortExports();
-		for (const exportInfo of this._exports.values()) {
-			switch (exportInfo.provided) {
-				case undefined:
-					return null;
-				case null:
-					return true;
-				case true:
-					array.push(exportInfo.name);
-			}
-		}
-		if (this._redirectTo !== undefined) {
-			const inner = this._redirectTo.getProvidedExports();
-			if (inner === null) return null;
-			if (inner === true) return true;
-			for (const item of inner) {
-				if (!array.includes(item)) {
-					array.push(item);
-				}
-			}
-		}
-		return array;
+	getUnsafeCacheData() {
+		return {
+			factoryMeta: this.factoryMeta,
+			resolveOptions: this.resolveOptions
+		};
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ExportInfo[]} exports that are relevant (not unused and potential provided)
+	 * restore unsafe cache data
+	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
 	 */
-	getRelevantExports(runtime) {
-		const list = [];
-		for (const exportInfo of this._exports.values()) {
-			const used = exportInfo.getUsed(runtime);
-			if (used === UsageState.Unused) continue;
-			if (exportInfo.provided === false) continue;
-			list.push(exportInfo);
-		}
-		if (this._redirectTo !== undefined) {
-			for (const exportInfo of this._redirectTo.getRelevantExports(runtime)) {
-				if (!this._exports.has(exportInfo.name)) list.push(exportInfo);
-			}
-		}
-		if (
-			this._otherExportsInfo.provided !== false &&
-			this._otherExportsInfo.getUsed(runtime) !== UsageState.Unused
-		) {
-			list.push(this._otherExportsInfo);
-		}
-		return list;
+	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this.factoryMeta = unsafeCacheData.factoryMeta;
+		this.resolveOptions = unsafeCacheData.resolveOptions;
 	}
 
 	/**
-	 * @param {string | string[]} name the name of the export
-	 * @returns {boolean | undefined | null} if the export is provided
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
 	 */
-	isExportProvided(name) {
-		if (Array.isArray(name)) {
-			const info = this.getReadOnlyExportInfo(name[0]);
-			if (info.exportsInfo && name.length > 1) {
-				return info.exportsInfo.isExportProvided(name.slice(1));
-			}
-			return info.provided;
-		}
-		const info = this.getReadOnlyExportInfo(name);
-		return info.provided;
+	cleanupForCache() {
+		this.factoryMeta = undefined;
+		this.resolveOptions = undefined;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {string} key representing the usage
+	 * @returns {Source | null} the original source for the module before webpack transformation
 	 */
-	getUsageKey(runtime) {
-		const key = [];
-		if (this._redirectTo !== undefined) {
-			key.push(this._redirectTo.getUsageKey(runtime));
-		} else {
-			key.push(this._otherExportsInfo.getUsed(runtime));
-		}
-		key.push(this._sideEffectsOnlyInfo.getUsed(runtime));
-		for (const exportInfo of this.orderedOwnedExports) {
-			key.push(exportInfo.getUsed(runtime));
-		}
-		return key.join("|");
+	originalSource() {
+		return null;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtimeA first runtime
-	 * @param {RuntimeSpec} runtimeB second runtime
-	 * @returns {boolean} true, when equally used
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
 	 */
-	isEquallyUsed(runtimeA, runtimeB) {
-		if (this._redirectTo !== undefined) {
-			if (!this._redirectTo.isEquallyUsed(runtimeA, runtimeB)) return false;
-		} else {
-			if (
-				this._otherExportsInfo.getUsed(runtimeA) !==
-				this._otherExportsInfo.getUsed(runtimeB)
-			) {
-				return false;
-			}
-		}
-		if (
-			this._sideEffectsOnlyInfo.getUsed(runtimeA) !==
-			this._sideEffectsOnlyInfo.getUsed(runtimeB)
-		) {
-			return false;
-		}
-		for (const exportInfo of this.ownedExports) {
-			if (exportInfo.getUsed(runtimeA) !== exportInfo.getUsed(runtimeB))
-				return false;
-		}
-		return true;
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.type);
+		write(this.layer);
+		write(this.context);
+		write(this.resolveOptions);
+		write(this.factoryMeta);
+		write(this.useSourceMap);
+		write(this.useSimpleSourceMap);
+		write(
+			this._warnings !== undefined && this._warnings.length === 0
+				? undefined
+				: this._warnings
+		);
+		write(
+			this._errors !== undefined && this._errors.length === 0
+				? undefined
+				: this._errors
+		);
+		write(this.buildMeta);
+		write(this.buildInfo);
+		write(this.presentationalDependencies);
+		write(this.codeGenerationDependencies);
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {string | string[]} name export name
-	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {UsageStateType} usage status
-	 */
-	getUsed(name, runtime) {
-		if (Array.isArray(name)) {
-			if (name.length === 0) return this.otherExportsInfo.getUsed(runtime);
-			let info = this.getReadOnlyExportInfo(name[0]);
-			if (info.exportsInfo && name.length > 1) {
-				return info.exportsInfo.getUsed(name.slice(1), runtime);
-			}
-			return info.getUsed(runtime);
-		}
-		let info = this.getReadOnlyExportInfo(name);
-		return info.getUsed(runtime);
+	deserialize(context) {
+		const { read } = context;
+		this.type = read();
+		this.layer = read();
+		this.context = read();
+		this.resolveOptions = read();
+		this.factoryMeta = read();
+		this.useSourceMap = read();
+		this.useSimpleSourceMap = read();
+		this._warnings = read();
+		this._errors = read();
+		this.buildMeta = read();
+		this.buildInfo = read();
+		this.presentationalDependencies = read();
+		this.codeGenerationDependencies = read();
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {string | string[]} name the export name
-	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {string | string[] | false} the used name
-	 */
-	getUsedName(name, runtime) {
-		if (Array.isArray(name)) {
-			// TODO improve this
-			if (name.length === 0) {
-				if (!this.isUsed(runtime)) return false;
-				return name;
-			}
-			let info = this.getReadOnlyExportInfo(name[0]);
-			const x = info.getUsedName(name[0], runtime);
-			if (x === false) return false;
-			const arr = x === name[0] && name.length === 1 ? name : [x];
-			if (name.length === 1) {
-				return arr;
-			}
-			if (
-				info.exportsInfo &&
-				info.getUsed(runtime) === UsageState.OnlyPropertiesUsed
-			) {
-				const nested = info.exportsInfo.getUsedName(name.slice(1), runtime);
-				if (!nested) return false;
-				return arr.concat(nested);
-			} else {
-				return arr.concat(name.slice(1));
-			}
-		} else {
-			let info = this.getReadOnlyExportInfo(name);
-			const usedName = info.getUsedName(name, runtime);
-			return usedName;
-		}
+makeSerializable(Module, "webpack/lib/Module");
+
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "hasEqualsChunks", {
+	get() {
+		throw new Error(
+			"Module.hasEqualsChunks was renamed (use hasEqualChunks instead)"
+		);
 	}
+});
 
-	/**
-	 * @param {Hash} hash the hash
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {void}
-	 */
-	updateHash(hash, runtime) {
-		this._updateHash(hash, runtime, new Set());
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "isUsed", {
+	get() {
+		throw new Error(
+			"Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)"
+		);
 	}
+});
 
-	/**
-	 * @param {Hash} hash the hash
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<ExportsInfo>} alreadyVisitedExportsInfo for circular references
-	 * @returns {void}
-	 */
-	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		const set = new Set(alreadyVisitedExportsInfo);
-		set.add(this);
-		for (const exportInfo of this.orderedExports) {
-			if (exportInfo.hasInfo(this._otherExportsInfo, runtime)) {
-				exportInfo._updateHash(hash, runtime, set);
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "errors", {
+	get: util.deprecate(
+		/**
+		 * @this {Module}
+		 * @returns {WebpackError[]} array
+		 */
+		function () {
+			if (this._errors === undefined) {
+				this._errors = [];
 			}
-		}
-		this._sideEffectsOnlyInfo._updateHash(hash, runtime, set);
-		this._otherExportsInfo._updateHash(hash, runtime, set);
-		if (this._redirectTo !== undefined) {
-			this._redirectTo._updateHash(hash, runtime, set);
-		}
-	}
+			return this._errors;
+		},
+		"Module.errors was removed (use getErrors instead)",
+		"DEP_WEBPACK_MODULE_ERRORS"
+	)
+});
 
-	getRestoreProvidedData() {
-		const otherProvided = this._otherExportsInfo.provided;
-		const otherCanMangleProvide = this._otherExportsInfo.canMangleProvide;
-		const otherTerminalBinding = this._otherExportsInfo.terminalBinding;
-		const exports = [];
-		for (const exportInfo of this.orderedExports) {
-			if (
-				exportInfo.provided !== otherProvided ||
-				exportInfo.canMangleProvide !== otherCanMangleProvide ||
-				exportInfo.terminalBinding !== otherTerminalBinding ||
-				exportInfo.exportsInfoOwned
-			) {
-				exports.push({
-					name: exportInfo.name,
-					provided: exportInfo.provided,
-					canMangleProvide: exportInfo.canMangleProvide,
-					terminalBinding: exportInfo.terminalBinding,
-					exportsInfo: exportInfo.exportsInfoOwned
-						? exportInfo.exportsInfo.getRestoreProvidedData()
-						: undefined
-				});
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "warnings", {
+	get: util.deprecate(
+		/**
+		 * @this {Module}
+		 * @returns {WebpackError[]} array
+		 */
+		function () {
+			if (this._warnings === undefined) {
+				this._warnings = [];
 			}
-		}
-		return new RestoreProvidedData(
-			exports,
-			otherProvided,
-			otherCanMangleProvide,
-			otherTerminalBinding
+			return this._warnings;
+		},
+		"Module.warnings was removed (use getWarnings instead)",
+		"DEP_WEBPACK_MODULE_WARNINGS"
+	)
+});
+
+// TODO remove in webpack 6
+Object.defineProperty(Module.prototype, "used", {
+	get() {
+		throw new Error(
+			"Module.used was refactored (use ModuleGraph.getUsedExports instead)"
+		);
+	},
+	set(value) {
+		throw new Error(
+			"Module.used was refactored (use ModuleGraph.setUsedExports instead)"
 		);
 	}
+});
 
-	restoreProvided({
-		otherProvided,
-		otherCanMangleProvide,
-		otherTerminalBinding,
-		exports
-	}) {
-		let wasEmpty = true;
-		for (const exportInfo of this._exports.values()) {
-			wasEmpty = false;
-			exportInfo.provided = otherProvided;
-			exportInfo.canMangleProvide = otherCanMangleProvide;
-			exportInfo.terminalBinding = otherTerminalBinding;
+module.exports = Module;
+
+
+/***/ }),
+
+/***/ 21305:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { cutOffLoaderExecution } = __webpack_require__(59985);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+class ModuleBuildError extends WebpackError {
+	/**
+	 * @param {string | Error&any} err error thrown
+	 * @param {{from?: string|null}} info additional info
+	 */
+	constructor(err, { from = null } = {}) {
+		let message = "Module build failed";
+		let details = undefined;
+
+		if (from) {
+			message += ` (from ${from}):\n`;
+		} else {
+			message += ": ";
 		}
-		this._otherExportsInfo.provided = otherProvided;
-		this._otherExportsInfo.canMangleProvide = otherCanMangleProvide;
-		this._otherExportsInfo.terminalBinding = otherTerminalBinding;
-		for (const exp of exports) {
-			const exportInfo = this.getExportInfo(exp.name);
-			exportInfo.provided = exp.provided;
-			exportInfo.canMangleProvide = exp.canMangleProvide;
-			exportInfo.terminalBinding = exp.terminalBinding;
-			if (exp.exportsInfo) {
-				const exportsInfo = exportInfo.createNestedExportsInfo();
-				exportsInfo.restoreProvided(exp.exportsInfo);
+
+		if (err !== null && typeof err === "object") {
+			if (typeof err.stack === "string" && err.stack) {
+				const stack = cutOffLoaderExecution(err.stack);
+
+				if (!err.hideStack) {
+					message += stack;
+				} else {
+					details = stack;
+
+					if (typeof err.message === "string" && err.message) {
+						message += err.message;
+					} else {
+						message += err;
+					}
+				}
+			} else if (typeof err.message === "string" && err.message) {
+				message += err.message;
+			} else {
+				message += String(err);
 			}
+		} else {
+			message += String(err);
 		}
-		if (wasEmpty) this._exportsAreOrdered = true;
+
+		super(message);
+
+		this.name = "ModuleBuildError";
+		this.details = details;
+		this.error = err;
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.error);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.error = read();
+
+		super.deserialize(context);
 	}
 }
 
-class ExportInfo {
+makeSerializable(ModuleBuildError, "webpack/lib/ModuleBuildError");
+
+module.exports = ModuleBuildError;
+
+
+/***/ }),
+
+/***/ 67409:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
+
+class ModuleDependencyError extends WebpackError {
 	/**
-	 * @param {string} name the original name of the export
-	 * @param {ExportInfo=} initFrom init values from this ExportInfo
+	 * Creates an instance of ModuleDependencyError.
+	 * @param {Module} module module tied to dependency
+	 * @param {Error} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
 	 */
-	constructor(name, initFrom) {
-		/** @type {string} */
-		this.name = name;
-		/** @private @type {string | null} */
-		this._usedName = initFrom ? initFrom._usedName : null;
-		/** @private @type {UsageStateType} */
-		this._globalUsed = initFrom ? initFrom._globalUsed : undefined;
-		/** @private @type {Map<string, RuntimeUsageStateType>} */
-		this._usedInRuntime =
-			initFrom && initFrom._usedInRuntime
-				? new Map(initFrom._usedInRuntime)
+	constructor(module, err, loc) {
+		super(err.message);
+
+		this.name = "ModuleDependencyError";
+		this.details =
+			err && !(/** @type {any} */ (err).hideStack)
+				? err.stack.split("\n").slice(1).join("\n")
 				: undefined;
-		/** @private @type {boolean} */
-		this._hasUseInRuntimeInfo = initFrom
-			? initFrom._hasUseInRuntimeInfo
-			: false;
-		/**
-		 * true: it is provided
-		 * false: it is not provided
-		 * null: only the runtime knows if it is provided
-		 * undefined: it was not determined if it is provided
-		 * @type {boolean | null | undefined}
-		 */
-		this.provided = initFrom ? initFrom.provided : undefined;
-		/**
-		 * is the export a terminal binding that should be checked for export star conflicts
-		 * @type {boolean}
-		 */
-		this.terminalBinding = initFrom ? initFrom.terminalBinding : false;
-		/**
-		 * true: it can be mangled
-		 * false: is can not be mangled
-		 * undefined: it was not determined if it can be mangled
-		 * @type {boolean | undefined}
-		 */
-		this.canMangleProvide = initFrom ? initFrom.canMangleProvide : undefined;
-		/**
-		 * true: it can be mangled
-		 * false: is can not be mangled
-		 * undefined: it was not determined if it can be mangled
-		 * @type {boolean | undefined}
-		 */
-		this.canMangleUse = initFrom ? initFrom.canMangleUse : undefined;
-		/** @type {boolean} */
-		this.exportsInfoOwned = false;
-		/** @type {ExportsInfo=} */
-		this.exportsInfo = undefined;
-		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
-		this._target = undefined;
-		if (initFrom && initFrom._target) {
-			this._target = new Map();
-			for (const [key, value] of initFrom._target) {
-				this._target.set(key, {
-					connection: value.connection,
-					export: value.export || [name],
-					priority: value.priority
-				});
-			}
+		this.module = module;
+		this.loc = loc;
+		/** error is not (de)serialized, so it might be undefined after deserialization */
+		this.error = err;
+
+		if (err && /** @type {any} */ (err).hideStack) {
+			this.stack =
+				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
 		}
-		/** @type {Map<any, { connection: ModuleGraphConnection | null, export: string[], priority: number }>=} */
-		this._maxTarget = undefined;
 	}
+}
 
-	// TODO webpack 5 remove
-	/** @private */
-	get used() {
-		throw new Error("REMOVED");
-	}
-	/** @private */
-	get usedName() {
-		throw new Error("REMOVED");
-	}
-	/**
-	 * @private
-	 * @param {*} v v
-	 */
-	set used(v) {
-		throw new Error("REMOVED");
-	}
-	/**
-	 * @private
-	 * @param {*} v v
-	 */
-	set usedName(v) {
-		throw new Error("REMOVED");
-	}
+module.exports = ModuleDependencyError;
 
-	get canMangle() {
-		switch (this.canMangleProvide) {
-			case undefined:
-				return this.canMangleUse === false ? false : undefined;
-			case false:
-				return false;
-			case true:
-				switch (this.canMangleUse) {
-					case undefined:
-						return undefined;
-					case false:
-						return false;
-					case true:
-						return true;
-				}
-		}
-		throw new Error(
-			`Unexpected flags for canMangle ${this.canMangleProvide} ${this.canMangleUse}`
-		);
-	}
 
-	/**
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true, when something changed
-	 */
-	setUsedInUnknownWay(runtime) {
-		let changed = false;
-		if (
-			this.setUsedConditionally(
-				used => used < UsageState.Unknown,
-				UsageState.Unknown,
-				runtime
-			)
-		) {
-			changed = true;
-		}
-		if (this.canMangleUse !== false) {
-			this.canMangleUse = false;
-			changed = true;
-		}
-		return changed;
-	}
+/***/ }),
 
-	/**
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true, when something changed
-	 */
-	setUsedWithoutInfo(runtime) {
-		let changed = false;
-		if (this.setUsed(UsageState.NoInfo, runtime)) {
-			changed = true;
-		}
-		if (this.canMangleUse !== false) {
-			this.canMangleUse = false;
-			changed = true;
-		}
-		return changed;
-	}
+/***/ 29656:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	setHasUseInfo() {
-		if (!this._hasUseInRuntimeInfo) {
-			this._hasUseInRuntimeInfo = true;
-		}
-		if (this.canMangleUse === undefined) {
-			this.canMangleUse = true;
-		}
-		if (this.exportsInfoOwned) {
-			this.exportsInfo.setHasUseInfo();
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @param {function(UsageStateType): boolean} condition compare with old value
-	 * @param {UsageStateType} newValue set when condition is true
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true when something has changed
-	 */
-	setUsedConditionally(condition, newValue, runtime) {
-		if (runtime === undefined) {
-			if (this._globalUsed === undefined) {
-				this._globalUsed = newValue;
-				return true;
-			} else {
-				if (this._globalUsed !== newValue && condition(this._globalUsed)) {
-					this._globalUsed = newValue;
-					return true;
-				}
-			}
-		} else if (this._usedInRuntime === undefined) {
-			if (newValue !== UsageState.Unused && condition(UsageState.Unused)) {
-				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(runtime, newValue)
-				);
-				return true;
-			}
-		} else {
-			let changed = false;
-			forEachRuntime(runtime, runtime => {
-				/** @type {UsageStateType} */
-				let oldValue = this._usedInRuntime.get(runtime);
-				if (oldValue === undefined) oldValue = UsageState.Unused;
-				if (newValue !== oldValue && condition(oldValue)) {
-					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
-					} else {
-						this._usedInRuntime.set(runtime, newValue);
-					}
-					changed = true;
-				}
-			});
-			if (changed) {
-				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
-				return true;
-			}
-		}
-		return false;
-	}
 
-	/**
-	 * @param {UsageStateType} newValue new value of the used state
-	 * @param {RuntimeSpec} runtime only apply to this runtime
-	 * @returns {boolean} true when something has changed
-	 */
-	setUsed(newValue, runtime) {
-		if (runtime === undefined) {
-			if (this._globalUsed !== newValue) {
-				this._globalUsed = newValue;
-				return true;
-			}
-		} else if (this._usedInRuntime === undefined) {
-			if (newValue !== UsageState.Unused) {
-				this._usedInRuntime = new Map();
-				forEachRuntime(runtime, runtime =>
-					this._usedInRuntime.set(runtime, newValue)
-				);
-				return true;
-			}
-		} else {
-			let changed = false;
-			forEachRuntime(runtime, runtime => {
-				/** @type {UsageStateType} */
-				let oldValue = this._usedInRuntime.get(runtime);
-				if (oldValue === undefined) oldValue = UsageState.Unused;
-				if (newValue !== oldValue) {
-					if (newValue === UsageState.Unused) {
-						this._usedInRuntime.delete(runtime);
-					} else {
-						this._usedInRuntime.set(runtime, newValue);
-					}
-					changed = true;
-				}
-			});
-			if (changed) {
-				if (this._usedInRuntime.size === 0) this._usedInRuntime = undefined;
-				return true;
-			}
-		}
-		return false;
-	}
 
-	/**
-	 * @param {any} key the key
-	 * @returns {boolean} true, if something has changed
-	 */
-	unsetTarget(key) {
-		if (!this._target) return false;
-		if (this._target.delete(key)) {
-			this._maxTarget = undefined;
-			return true;
-		}
-		return false;
-	}
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
+class ModuleDependencyWarning extends WebpackError {
 	/**
-	 * @param {any} key the key
-	 * @param {ModuleGraphConnection} connection the target module if a single one
-	 * @param {string[]=} exportName the exported name
-	 * @param {number=} priority priority
-	 * @returns {boolean} true, if something has changed
+	 * @param {Module} module module tied to dependency
+	 * @param {Error} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
 	 */
-	setTarget(key, connection, exportName, priority = 0) {
-		if (exportName) exportName = [...exportName];
-		if (!this._target) {
-			this._target = new Map();
-			this._target.set(key, { connection, export: exportName, priority });
-			return true;
-		}
-		const oldTarget = this._target.get(key);
-		if (!oldTarget) {
-			if (oldTarget === null && !connection) return false;
-			this._target.set(key, { connection, export: exportName, priority });
-			this._maxTarget = undefined;
-			return true;
-		}
-		if (
-			oldTarget.connection !== connection ||
-			oldTarget.priority !== priority ||
-			(exportName
-				? !oldTarget.export || !equals(oldTarget.export, exportName)
-				: oldTarget.export)
-		) {
-			oldTarget.connection = connection;
-			oldTarget.export = exportName;
-			oldTarget.priority = priority;
-			this._maxTarget = undefined;
-			return true;
+	constructor(module, err, loc) {
+		super(err ? err.message : "");
+
+		this.name = "ModuleDependencyWarning";
+		this.details =
+			err && !(/** @type {any} */ (err).hideStack)
+				? err.stack.split("\n").slice(1).join("\n")
+				: undefined;
+		this.module = module;
+		this.loc = loc;
+		/** error is not (de)serialized, so it might be undefined after deserialization */
+		this.error = err;
+
+		if (err && /** @type {any} */ (err).hideStack) {
+			this.stack =
+				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
 		}
-		return false;
 	}
+}
+
+makeSerializable(
+	ModuleDependencyWarning,
+	"webpack/lib/ModuleDependencyWarning"
+);
+
+module.exports = ModuleDependencyWarning;
+
+
+/***/ }),
+
+/***/ 23744:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { cleanUp } = __webpack_require__(59985);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
+class ModuleError extends WebpackError {
 	/**
-	 * @param {RuntimeSpec} runtime for this runtime
-	 * @returns {UsageStateType} usage state
+	 * @param {Error} err error thrown
+	 * @param {{from?: string|null}} info additional info
 	 */
-	getUsed(runtime) {
-		if (!this._hasUseInRuntimeInfo) return UsageState.NoInfo;
-		if (this._globalUsed !== undefined) return this._globalUsed;
-		if (this._usedInRuntime === undefined) {
-			return UsageState.Unused;
-		} else if (typeof runtime === "string") {
-			const value = this._usedInRuntime.get(runtime);
-			return value === undefined ? UsageState.Unused : value;
-		} else if (runtime === undefined) {
-			/** @type {UsageStateType} */
-			let max = UsageState.Unused;
-			for (const value of this._usedInRuntime.values()) {
-				if (value === UsageState.Used) {
-					return UsageState.Used;
-				}
-				if (max < value) max = value;
-			}
-			return max;
+	constructor(err, { from = null } = {}) {
+		let message = "Module Error";
+
+		if (from) {
+			message += ` (from ${from}):\n`;
 		} else {
-			/** @type {UsageStateType} */
-			let max = UsageState.Unused;
-			for (const item of runtime) {
-				const value = this._usedInRuntime.get(item);
-				if (value !== undefined) {
-					if (value === UsageState.Used) {
-						return UsageState.Used;
-					}
-					if (max < value) max = value;
-				}
-			}
-			return max;
+			message += ": ";
 		}
-	}
 
-	/**
-	 * get used name
-	 * @param {string | undefined} fallbackName fallback name for used exports with no name
-	 * @param {RuntimeSpec} runtime check usage for this runtime only
-	 * @returns {string | false} used name
-	 */
-	getUsedName(fallbackName, runtime) {
-		if (this._hasUseInRuntimeInfo) {
-			if (this._globalUsed !== undefined) {
-				if (this._globalUsed === UsageState.Unused) return false;
-			} else {
-				if (this._usedInRuntime === undefined) return false;
-				if (typeof runtime === "string") {
-					if (!this._usedInRuntime.has(runtime)) {
-						return false;
-					}
-				} else if (runtime !== undefined) {
-					if (
-						Array.from(runtime).every(
-							runtime => !this._usedInRuntime.has(runtime)
-						)
-					) {
-						return false;
-					}
-				}
-			}
+		if (err && typeof err === "object" && err.message) {
+			message += err.message;
+		} else if (err) {
+			message += err;
 		}
-		if (this._usedName !== null) return this._usedName;
-		return this.name || fallbackName;
-	}
 
-	/**
-	 * @returns {boolean} true, when a mangled name of this export is set
-	 */
-	hasUsedName() {
-		return this._usedName !== null;
-	}
+		super(message);
 
-	/**
-	 * Sets the mangled name of this export
-	 * @param {string} name the new name
-	 * @returns {void}
-	 */
-	setUsedName(name) {
-		this._usedName = name;
+		this.name = "ModuleError";
+		this.error = err;
+		this.details =
+			err && typeof err === "object" && err.stack
+				? cleanUp(err.stack, this.message)
+				: undefined;
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {ExportInfo | ExportsInfo | undefined} the terminal binding export(s) info if known
-	 */
-	getTerminalBinding(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
-		if (this.terminalBinding) return this;
-		const target = this.getTarget(moduleGraph, resolveTargetFilter);
-		if (!target) return undefined;
-		const exportsInfo = moduleGraph.getExportsInfo(target.module);
-		if (!target.export) return exportsInfo;
-		return exportsInfo.getReadOnlyExportInfoRecursive(target.export);
-	}
+	serialize(context) {
+		const { write } = context;
 
-	isReexport() {
-		return !this.terminalBinding && this._target && this._target.size > 0;
+		write(this.error);
+
+		super.serialize(context);
 	}
 
-	_getMaxTarget() {
-		if (this._maxTarget !== undefined) return this._maxTarget;
-		if (this._target.size <= 1) return (this._maxTarget = this._target);
-		let maxPriority = -Infinity;
-		let minPriority = Infinity;
-		for (const { priority } of this._target.values()) {
-			if (maxPriority < priority) maxPriority = priority;
-			if (minPriority > priority) minPriority = priority;
-		}
-		// This should be very common
-		if (maxPriority === minPriority) return (this._maxTarget = this._target);
+	deserialize(context) {
+		const { read } = context;
 
-		// This is an edge case
-		const map = new Map();
-		for (const [key, value] of this._target) {
-			if (maxPriority === value.priority) {
-				map.set(key, value);
-			}
-		}
-		this._maxTarget = map;
-		return map;
-	}
+		this.error = read();
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
-	 */
-	findTarget(moduleGraph, validTargetModuleFilter) {
-		return this._findTarget(moduleGraph, validTargetModuleFilter, new Set());
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function(Module): boolean} validTargetModuleFilter a valid target module
-	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined | false} the target, undefined when there is no target, false when no target is valid
-	 */
-	_findTarget(moduleGraph, validTargetModuleFilter, alreadyVisited) {
-		if (!this._target || this._target.size === 0) return undefined;
-		let rawTarget = this._getMaxTarget().values().next().value;
-		if (!rawTarget) return undefined;
-		/** @type {{ module: Module, export: string[] | undefined }} */
-		let target = {
-			module: rawTarget.connection.module,
-			export: rawTarget.export
-		};
-		for (;;) {
-			if (validTargetModuleFilter(target.module)) return target;
-			const exportsInfo = moduleGraph.getExportsInfo(target.module);
-			const exportInfo = exportsInfo.getExportInfo(target.export[0]);
-			if (alreadyVisited.has(exportInfo)) return null;
-			const newTarget = exportInfo._findTarget(
-				moduleGraph,
-				validTargetModuleFilter,
-				alreadyVisited
-			);
-			if (!newTarget) return false;
-			if (target.export.length === 1) {
-				target = newTarget;
-			} else {
-				target = {
-					module: newTarget.module,
-					export: newTarget.export
-						? newTarget.export.concat(target.export.slice(1))
-						: target.export.slice(1)
-				};
-			}
-		}
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the target
-	 */
-	getTarget(moduleGraph, resolveTargetFilter = RETURNS_TRUE) {
-		const result = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
-		if (result === CIRCULAR) return undefined;
-		return result;
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {Set<ExportInfo> | undefined} alreadyVisited set of already visited export info to avoid circular references
-	 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | undefined} the target
-	 */
-	_getTarget(moduleGraph, resolveTargetFilter, alreadyVisited) {
-		/**
-		 * @param {{ connection: ModuleGraphConnection, export: string[] | undefined } | null} inputTarget unresolved target
-		 * @param {Set<ExportInfo>} alreadyVisited set of already visited export info to avoid circular references
-		 * @returns {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined } | CIRCULAR | null} resolved target
-		 */
-		const resolveTarget = (inputTarget, alreadyVisited) => {
-			if (!inputTarget) return null;
-			if (!inputTarget.export) {
-				return {
-					module: inputTarget.connection.module,
-					connection: inputTarget.connection,
-					export: undefined
-				};
-			}
-			/** @type {{ module: Module, connection: ModuleGraphConnection, export: string[] | undefined }} */
-			let target = {
-				module: inputTarget.connection.module,
-				connection: inputTarget.connection,
-				export: inputTarget.export
-			};
-			if (!resolveTargetFilter(target)) return target;
-			let alreadyVisitedOwned = false;
-			for (;;) {
-				const exportsInfo = moduleGraph.getExportsInfo(target.module);
-				const exportInfo = exportsInfo.getExportInfo(target.export[0]);
-				if (!exportInfo) return target;
-				if (alreadyVisited.has(exportInfo)) return CIRCULAR;
-				const newTarget = exportInfo._getTarget(
-					moduleGraph,
-					resolveTargetFilter,
-					alreadyVisited
-				);
-				if (newTarget === CIRCULAR) return CIRCULAR;
-				if (!newTarget) return target;
-				if (target.export.length === 1) {
-					target = newTarget;
-					if (!target.export) return target;
-				} else {
-					target = {
-						module: newTarget.module,
-						connection: newTarget.connection,
-						export: newTarget.export
-							? newTarget.export.concat(target.export.slice(1))
-							: target.export.slice(1)
-					};
-				}
-				if (!resolveTargetFilter(target)) return target;
-				if (!alreadyVisitedOwned) {
-					alreadyVisited = new Set(alreadyVisited);
-					alreadyVisitedOwned = true;
-				}
-				alreadyVisited.add(exportInfo);
-			}
-		};
-
-		if (!this._target || this._target.size === 0) return undefined;
-		if (alreadyVisited && alreadyVisited.has(this)) return CIRCULAR;
-		const newAlreadyVisited = new Set(alreadyVisited);
-		newAlreadyVisited.add(this);
-		const values = this._getMaxTarget().values();
-		const target = resolveTarget(values.next().value, newAlreadyVisited);
-		if (target === CIRCULAR) return CIRCULAR;
-		if (target === null) return undefined;
-		let result = values.next();
-		while (!result.done) {
-			const t = resolveTarget(result.value, newAlreadyVisited);
-			if (t === CIRCULAR) return CIRCULAR;
-			if (t === null) return undefined;
-			if (t.module !== target.module) return undefined;
-			if (!t.export !== !target.export) return undefined;
-			if (target.export && !equals(t.export, target.export)) return undefined;
-			result = values.next();
-		}
-		return target;
-	}
-
-	/**
-	 * Move the target forward as long resolveTargetFilter is fulfilled
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {function({ module: Module, export: string[] | undefined }): boolean} resolveTargetFilter filter function to further resolve target
-	 * @param {function({ module: Module, export: string[] | undefined }): ModuleGraphConnection=} updateOriginalConnection updates the original connection instead of using the target connection
-	 * @returns {{ module: Module, export: string[] | undefined } | undefined} the resolved target when moved
-	 */
-	moveTarget(moduleGraph, resolveTargetFilter, updateOriginalConnection) {
-		const target = this._getTarget(moduleGraph, resolveTargetFilter, undefined);
-		if (target === CIRCULAR) return undefined;
-		if (!target) return undefined;
-		const originalTarget = this._getMaxTarget().values().next().value;
-		if (
-			originalTarget.connection === target.connection &&
-			originalTarget.export === target.export
-		) {
-			return undefined;
-		}
-		this._target.clear();
-		this._target.set(undefined, {
-			connection: updateOriginalConnection
-				? updateOriginalConnection(target)
-				: target.connection,
-			export: target.export,
-			priority: 0
-		});
-		return target;
-	}
-
-	createNestedExportsInfo() {
-		if (this.exportsInfoOwned) return this.exportsInfo;
-		this.exportsInfoOwned = true;
-		const oldExportsInfo = this.exportsInfo;
-		this.exportsInfo = new ExportsInfo();
-		this.exportsInfo.setHasProvideInfo();
-		if (oldExportsInfo) {
-			this.exportsInfo.setRedirectNamedTo(oldExportsInfo);
-		}
-		return this.exportsInfo;
-	}
-
-	getNestedExportsInfo() {
-		return this.exportsInfo;
-	}
-
-	hasInfo(baseInfo, runtime) {
-		return (
-			(this._usedName && this._usedName !== this.name) ||
-			this.provided ||
-			this.terminalBinding ||
-			this.getUsed(runtime) !== baseInfo.getUsed(runtime)
-		);
-	}
-
-	updateHash(hash, runtime) {
-		this._updateHash(hash, runtime, new Set());
-	}
-
-	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		hash.update(
-			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
-				this.terminalBinding
-			}`
-		);
-		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
-			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
-		}
-	}
-
-	getUsedInfo() {
-		if (this._globalUsed !== undefined) {
-			switch (this._globalUsed) {
-				case UsageState.Unused:
-					return "unused";
-				case UsageState.NoInfo:
-					return "no usage info";
-				case UsageState.Unknown:
-					return "maybe used (runtime-defined)";
-				case UsageState.Used:
-					return "used";
-				case UsageState.OnlyPropertiesUsed:
-					return "only properties used";
-			}
-		} else if (this._usedInRuntime !== undefined) {
-			/** @type {Map<RuntimeUsageStateType, string[]>} */
-			const map = new Map();
-			for (const [runtime, used] of this._usedInRuntime) {
-				const list = map.get(used);
-				if (list !== undefined) list.push(runtime);
-				else map.set(used, [runtime]);
-			}
-			const specificInfo = Array.from(map, ([used, runtimes]) => {
-				switch (used) {
-					case UsageState.NoInfo:
-						return `no usage info in ${runtimes.join(", ")}`;
-					case UsageState.Unknown:
-						return `maybe used in ${runtimes.join(", ")} (runtime-defined)`;
-					case UsageState.Used:
-						return `used in ${runtimes.join(", ")}`;
-					case UsageState.OnlyPropertiesUsed:
-						return `only properties used in ${runtimes.join(", ")}`;
-				}
-			});
-			if (specificInfo.length > 0) {
-				return specificInfo.join("; ");
-			}
-		}
-		return this._hasUseInRuntimeInfo ? "unused" : "no usage info";
-	}
-
-	getProvidedInfo() {
-		switch (this.provided) {
-			case undefined:
-				return "no provided info";
-			case null:
-				return "maybe provided (runtime-defined)";
-			case true:
-				return "provided";
-			case false:
-				return "not provided";
-		}
-	}
-
-	getRenameInfo() {
-		if (this._usedName !== null && this._usedName !== this.name) {
-			return `renamed to ${JSON.stringify(this._usedName).slice(1, -1)}`;
-		}
-		switch (this.canMangleProvide) {
-			case undefined:
-				switch (this.canMangleUse) {
-					case undefined:
-						return "missing provision and use info prevents renaming";
-					case false:
-						return "usage prevents renaming (no provision info)";
-					case true:
-						return "missing provision info prevents renaming";
-				}
-				break;
-			case true:
-				switch (this.canMangleUse) {
-					case undefined:
-						return "missing usage info prevents renaming";
-					case false:
-						return "usage prevents renaming";
-					case true:
-						return "could be renamed";
-				}
-				break;
-			case false:
-				switch (this.canMangleUse) {
-					case undefined:
-						return "provision prevents renaming (no use info)";
-					case false:
-						return "usage and provision prevents renaming";
-					case true:
-						return "provision prevents renaming";
-				}
-				break;
-		}
-		throw new Error(
-			`Unexpected flags for getRenameInfo ${this.canMangleProvide} ${this.canMangleUse}`
-		);
-	}
-}
+makeSerializable(ModuleError, "webpack/lib/ModuleError");
 
-module.exports = ExportsInfo;
-module.exports.ExportInfo = ExportInfo;
-module.exports.UsageState = UsageState;
+module.exports = ModuleError;
 
 
 /***/ }),
 
-/***/ 7145:
+/***/ 51010:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -43026,76 +45010,55 @@ module.exports.UsageState = UsageState;
 
 
 
-const ConstDependency = __webpack_require__(76911);
-const ExportsInfoDependency = __webpack_require__(78988);
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Module")} Module */
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/**
+ * @typedef {Object} ModuleFactoryResult
+ * @property {Module=} module the created module or unset if no module was created
+ * @property {Set<string>=} fileDependencies
+ * @property {Set<string>=} contextDependencies
+ * @property {Set<string>=} missingDependencies
+ * @property {boolean=} cacheable allow to use the unsafe cache
+ */
 
-class ExportsInfoApiPlugin {
+/**
+ * @typedef {Object} ModuleFactoryCreateDataContextInfo
+ * @property {string} issuer
+ * @property {string | null=} issuerLayer
+ * @property {string} compiler
+ */
+
+/**
+ * @typedef {Object} ModuleFactoryCreateData
+ * @property {ModuleFactoryCreateDataContextInfo} contextInfo
+ * @property {ResolveOptions=} resolveOptions
+ * @property {string} context
+ * @property {Dependency[]} dependencies
+ */
+
+class ModuleFactory {
+	/* istanbul ignore next */
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @abstract
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ExportsInfoApiPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ExportsInfoDependency,
-					new ExportsInfoDependency.Template()
-				);
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					parser.hooks.expressionMemberChain
-						.for("__webpack_exports_info__")
-						.tap("ExportsInfoApiPlugin", (expr, members) => {
-							const dep =
-								members.length >= 2
-									? new ExportsInfoDependency(
-											expr.range,
-											members.slice(0, -1),
-											members[members.length - 1]
-									  )
-									: new ExportsInfoDependency(expr.range, null, members[0]);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-							return true;
-						});
-					parser.hooks.expression
-						.for("__webpack_exports_info__")
-						.tap("ExportsInfoApiPlugin", expr => {
-							const dep = new ConstDependency("true", expr.range);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ExportsInfoApiPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ExportsInfoApiPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ExportsInfoApiPlugin", handler);
-			}
-		);
+	create(data, callback) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 }
 
-module.exports = ExportsInfoApiPlugin;
+module.exports = ModuleFactory;
 
 
 /***/ }),
 
-/***/ 73071:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 88821:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -43105,4636 +45068,3393 @@ module.exports = ExportsInfoApiPlugin;
 
 
 
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const ConcatenationScope = __webpack_require__(98229);
-const { UsageState } = __webpack_require__(63686);
-const InitFragment = __webpack_require__(55870);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const StaticExportsDependency = __webpack_require__(91418);
+const NormalModule = __webpack_require__(39);
 const createHash = __webpack_require__(49835);
-const extractUrlAndGlobal = __webpack_require__(11850);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { register } = __webpack_require__(8282);
+const memoize = __webpack_require__(78676);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./Module")} Module */
 /** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {typeof import("./util/Hash")} HashConstructor */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {typeof import("./util/Hash")} Hash */
 
-/**
- * @typedef {Object} SourceData
- * @property {boolean=} iife
- * @property {string=} init
- * @property {string} expression
- * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {ReadonlySet<string>=} runtimeRequirements
- */
+const ModuleFilenameHelpers = exports;
 
-const TYPES = new Set(["javascript"]);
-const CSS_TYPES = new Set(["css-import"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
-const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
-const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
-	RuntimeGlobals.definePropertyGetters
-]);
-const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
+// TODO webpack 6: consider removing these
+ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
+ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE =
+	/\[all-?loaders\]\[resource\]/gi;
+ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
+ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
+ModuleFilenameHelpers.RESOURCE = "[resource]";
+ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
+ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
+// cSpell:words olute
+ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH =
+	/\[abs(olute)?-?resource-?path\]/gi;
+ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
+ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
+ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
+ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
+ModuleFilenameHelpers.LOADERS = "[loaders]";
+ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
+ModuleFilenameHelpers.QUERY = "[query]";
+ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
+ModuleFilenameHelpers.ID = "[id]";
+ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
+ModuleFilenameHelpers.HASH = "[hash]";
+ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
+ModuleFilenameHelpers.NAMESPACE = "[namespace]";
+ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
 
-/**
- * @param {string|string[]} variableName the variable name or path
- * @param {string} type the module system
- * @returns {SourceData} the generated source
- */
-const getSourceForGlobalVariableExternal = (variableName, type) => {
-	if (!Array.isArray(variableName)) {
-		// make it an array as the look up works the same basically
-		variableName = [variableName];
-	}
+const getAfter = (strFn, token) => {
+	return () => {
+		const str = strFn();
+		const idx = str.indexOf(token);
+		return idx < 0 ? "" : str.substr(idx);
+	};
+};
 
-	// needed for e.g. window["some"]["thing"]
-	const objectLookup = variableName.map(r => `[${JSON.stringify(r)}]`).join("");
-	return {
-		iife: type === "this",
-		expression: `${type}${objectLookup}`
+const getBefore = (strFn, token) => {
+	return () => {
+		const str = strFn();
+		const idx = str.lastIndexOf(token);
+		return idx < 0 ? "" : str.substr(0, idx);
 	};
 };
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @returns {SourceData} the generated source
- */
-const getSourceForCommonJsExternal = moduleAndSpecifiers => {
-	if (!Array.isArray(moduleAndSpecifiers)) {
-		return {
-			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
-		};
-	}
-	const moduleName = moduleAndSpecifiers[0];
-	return {
-		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
-			moduleAndSpecifiers,
-			1
-		)}`
+const getHash = (strFn, hashFunction) => {
+	return () => {
+		const hash = createHash(hashFunction);
+		hash.update(strFn());
+		const digest = /** @type {string} */ (hash.digest("hex"));
+		return digest.substr(0, 4);
 	};
 };
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @returns {SourceData} the generated source
- */
-const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
-	const chunkInitFragments = [
-		new InitFragment(
-			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
-			InitFragment.STAGE_HARMONY_IMPORTS,
-			0,
-			"external module node-commonjs"
-		)
-	];
-	if (!Array.isArray(moduleAndSpecifiers)) {
-		return {
-			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
-				moduleAndSpecifiers
-			)})`,
-			chunkInitFragments
-		};
+const asRegExp = test => {
+	if (typeof test === "string") {
+		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
 	}
-	const moduleName = moduleAndSpecifiers[0];
-	return {
-		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
-			moduleName
-		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
-		chunkInitFragments
-	};
+	return test;
+};
+
+const lazyObject = obj => {
+	const newObj = {};
+	for (const key of Object.keys(obj)) {
+		const fn = obj[key];
+		Object.defineProperty(newObj, key, {
+			get: () => fn(),
+			set: v => {
+				Object.defineProperty(newObj, key, {
+					value: v,
+					enumerable: true,
+					writable: true
+				});
+			},
+			enumerable: true,
+			configurable: true
+		});
+	}
+	return newObj;
 };
 
+const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+
 /**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
+ *
+ * @param {Module | string} module the module
+ * @param {TODO} options options
+ * @param {Object} contextInfo context info
+ * @param {RequestShortener} contextInfo.requestShortener requestShortener
+ * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
+ * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @returns {string} the filename
  */
-const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
-	const importName = runtimeTemplate.outputOptions.importFunctionName;
-	if (!runtimeTemplate.supportsDynamicImport() && importName === "import") {
-		throw new Error(
-			"The target environment doesn't support 'import()' so it's not possible to use external type 'import'"
-		);
-	}
-	if (!Array.isArray(moduleAndSpecifiers)) {
-		return {
-			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers)});`
-		};
-	}
-	if (moduleAndSpecifiers.length === 1) {
-		return {
-			expression: `${importName}(${JSON.stringify(moduleAndSpecifiers[0])});`
-		};
-	}
-	const moduleName = moduleAndSpecifiers[0];
-	return {
-		expression: `${importName}(${JSON.stringify(
-			moduleName
-		)}).then(${runtimeTemplate.returningFunction(
-			`module${propertyAccess(moduleAndSpecifiers, 1)}`,
-			"module"
-		)});`
+ModuleFilenameHelpers.createFilename = (
+	module = "",
+	options,
+	{ requestShortener, chunkGraph, hashFunction = "md4" }
+) => {
+	const opts = {
+		namespace: "",
+		moduleFilenameTemplate: "",
+		...(typeof options === "object"
+			? options
+			: {
+					moduleFilenameTemplate: options
+			  })
 	};
-};
 
-class ModuleExternalInitFragment extends InitFragment {
-	/**
-	 * @param {string} request import source
-	 * @param {string=} ident recomputed ident
-	 * @param {string | HashConstructor=} hashFunction the hash function to use
-	 */
-	constructor(request, ident, hashFunction = "md4") {
-		if (ident === undefined) {
-			ident = Template.toIdentifier(request);
-			if (ident !== request) {
-				ident += `_${createHash(hashFunction)
-					.update(request)
-					.digest("hex")
-					.slice(0, 8)}`;
-			}
-		}
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
-		super(
-			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
-			InitFragment.STAGE_HARMONY_IMPORTS,
-			0,
-			`external module import ${ident}`
+	let absoluteResourcePath;
+	let hash;
+	let identifier;
+	let moduleId;
+	let shortIdentifier;
+	if (typeof module === "string") {
+		shortIdentifier = memoize(() => requestShortener.shorten(module));
+		identifier = shortIdentifier;
+		moduleId = () => "";
+		absoluteResourcePath = () => module.split("!").pop();
+		hash = getHash(identifier, hashFunction);
+	} else {
+		shortIdentifier = memoize(() =>
+			module.readableIdentifier(requestShortener)
 		);
-		this._ident = ident;
-		this._identifier = identifier;
-		this._request = request;
+		identifier = memoize(() => requestShortener.shorten(module.identifier()));
+		moduleId = () => chunkGraph.getModuleId(module);
+		absoluteResourcePath = () =>
+			module instanceof NormalModule
+				? module.resource
+				: module.identifier().split("!").pop();
+		hash = getHash(identifier, hashFunction);
 	}
+	const resource = memoize(() => shortIdentifier().split("!").pop());
 
-	getNamespaceIdentifier() {
-		return this._identifier;
+	const loaders = getBefore(shortIdentifier, "!");
+	const allLoaders = getBefore(identifier, "!");
+	const query = getAfter(resource, "?");
+	const resourcePath = () => {
+		const q = query().length;
+		return q === 0 ? resource() : resource().slice(0, -q);
+	};
+	if (typeof opts.moduleFilenameTemplate === "function") {
+		return opts.moduleFilenameTemplate(
+			lazyObject({
+				identifier: identifier,
+				shortIdentifier: shortIdentifier,
+				resource: resource,
+				resourcePath: memoize(resourcePath),
+				absoluteResourcePath: memoize(absoluteResourcePath),
+				allLoaders: memoize(allLoaders),
+				query: memoize(query),
+				moduleId: memoize(moduleId),
+				hash: memoize(hash),
+				namespace: () => opts.namespace
+			})
+		);
 	}
-}
 
-register(
-	ModuleExternalInitFragment,
-	"webpack/lib/ExternalModule",
-	"ModuleExternalInitFragment",
-	{
-		serialize(obj, { write }) {
-			write(obj._request);
-			write(obj._ident);
-		},
-		deserialize({ read }) {
-			return new ModuleExternalInitFragment(read(), read());
-		}
-	}
-);
+	// TODO webpack 6: consider removing alternatives without dashes
+	/** @type {Map<string, function(): string>} */
+	const replacements = new Map([
+		["identifier", identifier],
+		["short-identifier", shortIdentifier],
+		["resource", resource],
+		["resource-path", resourcePath],
+		// cSpell:words resourcepath
+		["resourcepath", resourcePath],
+		["absolute-resource-path", absoluteResourcePath],
+		["abs-resource-path", absoluteResourcePath],
+		// cSpell:words absoluteresource
+		["absoluteresource-path", absoluteResourcePath],
+		// cSpell:words absresource
+		["absresource-path", absoluteResourcePath],
+		// cSpell:words resourcepath
+		["absolute-resourcepath", absoluteResourcePath],
+		// cSpell:words resourcepath
+		["abs-resourcepath", absoluteResourcePath],
+		// cSpell:words absoluteresourcepath
+		["absoluteresourcepath", absoluteResourcePath],
+		// cSpell:words absresourcepath
+		["absresourcepath", absoluteResourcePath],
+		["all-loaders", allLoaders],
+		// cSpell:words allloaders
+		["allloaders", allLoaders],
+		["loaders", loaders],
+		["query", query],
+		["id", moduleId],
+		["hash", hash],
+		["namespace", () => opts.namespace]
+	]);
 
-const generateModuleRemapping = (input, exportsInfo, runtime) => {
-	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
-		const properties = [];
-		for (const exportInfo of exportsInfo.orderedExports) {
-			const used = exportInfo.getUsedName(exportInfo.name, runtime);
-			if (!used) continue;
-			const nestedInfo = exportInfo.getNestedExportsInfo();
-			if (nestedInfo) {
-				const nestedExpr = generateModuleRemapping(
-					`${input}${propertyAccess([exportInfo.name])}`,
-					nestedInfo
-				);
-				if (nestedExpr) {
-					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
-					continue;
+	// TODO webpack 6: consider removing weird double placeholders
+	return opts.moduleFilenameTemplate
+		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
+		.replace(
+			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
+			"[short-identifier]"
+		)
+		.replace(REGEXP, (match, content) => {
+			if (content.length + 2 === match.length) {
+				const replacement = replacements.get(content.toLowerCase());
+				if (replacement !== undefined) {
+					return replacement();
 				}
+			} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
+				return `[${match.slice(2, -2)}]`;
 			}
-			properties.push(
-				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
-					exportInfo.name
-				])}`
-			);
-		}
-		return `x({ ${properties.join(", ")} })`;
+			return match;
+		});
+};
+
+ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
+	const countMap = Object.create(null);
+	const posMap = Object.create(null);
+	array.forEach((item, idx) => {
+		countMap[item] = countMap[item] || [];
+		countMap[item].push(idx);
+		posMap[item] = 0;
+	});
+	if (comparator) {
+		Object.keys(countMap).forEach(item => {
+			countMap[item].sort(comparator);
+		});
 	}
+	return array.map((item, i) => {
+		if (countMap[item].length > 1) {
+			if (comparator && countMap[item][0] === i) return item;
+			return fn(item, i, posMap[item]++);
+		} else {
+			return item;
+		}
+	});
 };
 
-/**
- * @param {string|string[]} moduleAndSpecifiers the module request
- * @param {ExportsInfo} exportsInfo exports info of this module
- * @param {RuntimeSpec} runtime the runtime
- * @param {string | HashConstructor=} hashFunction the hash function to use
- * @returns {SourceData} the generated source
- */
-const getSourceForModuleExternal = (
-	moduleAndSpecifiers,
-	exportsInfo,
-	runtime,
-	hashFunction
-) => {
-	if (!Array.isArray(moduleAndSpecifiers))
-		moduleAndSpecifiers = [moduleAndSpecifiers];
-	const initFragment = new ModuleExternalInitFragment(
-		moduleAndSpecifiers[0],
-		undefined,
-		hashFunction
-	);
-	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
-		moduleAndSpecifiers,
-		1
-	)}`;
-	const moduleRemapping = generateModuleRemapping(
-		baseAccess,
-		exportsInfo,
-		runtime
-	);
-	let expression = moduleRemapping || baseAccess;
-	return {
-		expression,
-		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
-		runtimeRequirements: moduleRemapping
-			? RUNTIME_REQUIREMENTS_FOR_MODULE
-			: undefined,
-		chunkInitFragments: [initFragment]
-	};
+ModuleFilenameHelpers.matchPart = (str, test) => {
+	if (!test) return true;
+	test = asRegExp(test);
+	if (Array.isArray(test)) {
+		return test.map(asRegExp).some(regExp => regExp.test(str));
+	} else {
+		return test.test(str);
+	}
 };
 
-/**
- * @param {string|string[]} urlAndGlobal the script request
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
- */
-const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
-	if (typeof urlAndGlobal === "string") {
-		urlAndGlobal = extractUrlAndGlobal(urlAndGlobal);
+ModuleFilenameHelpers.matchObject = (obj, str) => {
+	if (obj.test) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
+			return false;
+		}
 	}
-	const url = urlAndGlobal[0];
-	const globalName = urlAndGlobal[1];
-	return {
-		init: "var __webpack_error__ = new Error();",
-		expression: `new Promise(${runtimeTemplate.basicFunction(
-			"resolve, reject",
-			[
-				`if(typeof ${globalName} !== "undefined") return resolve();`,
-				`${RuntimeGlobals.loadScript}(${JSON.stringify(
-					url
-				)}, ${runtimeTemplate.basicFunction("event", [
-					`if(typeof ${globalName} !== "undefined") return resolve();`,
-					"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-					"var realSrc = event && event.target && event.target.src;",
-					"__webpack_error__.message = 'Loading script failed.\\n(' + errorType + ': ' + realSrc + ')';",
-					"__webpack_error__.name = 'ScriptExternalLoadError';",
-					"__webpack_error__.type = errorType;",
-					"__webpack_error__.request = realSrc;",
-					"reject(__webpack_error__);"
-				])}, ${JSON.stringify(globalName)});`
-			]
-		)}).then(${runtimeTemplate.returningFunction(
-			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
-		)})`,
-		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
-	};
+	if (obj.include) {
+		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
+			return false;
+		}
+	}
+	if (obj.exclude) {
+		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
+			return false;
+		}
+	}
+	return true;
 };
 
+
+/***/ }),
+
+/***/ 99988:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const util = __webpack_require__(73837);
+const ExportsInfo = __webpack_require__(63686);
+const ModuleGraphConnection = __webpack_require__(40639);
+const SortableSet = __webpack_require__(13098);
+const WeakTupleMap = __webpack_require__(28745);
+
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleProfile")} ModuleProfile */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
 /**
- * @param {string} variableName the variable name to check
- * @param {string} request the request path
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {string} the generated source
+ * @callback OptimizationBailoutFunction
+ * @param {RequestShortener} requestShortener
+ * @returns {string}
  */
-const checkExternalVariable = (variableName, request, runtimeTemplate) => {
-	return `if(typeof ${variableName} === 'undefined') { ${runtimeTemplate.throwMissingModuleErrorBlock(
-		{ request }
-	)} }\n`;
-};
+
+const EMPTY_SET = new Set();
 
 /**
- * @param {string|number} id the module id
- * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
  */
-const getSourceForAmdOrUmdExternal = (
-	id,
-	optional,
-	request,
-	runtimeTemplate
-) => {
-	const externalVariable = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-		`${id}`
-	)}__`;
-	return {
-		init: optional
-			? checkExternalVariable(
-					externalVariable,
-					Array.isArray(request) ? request.join(".") : request,
-					runtimeTemplate
-			  )
-			: undefined,
-		expression: externalVariable
-	};
+const getConnectionsByOriginModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { originModule } = connection;
+		if (lastModule === originModule) {
+			lastList.push(connection);
+		} else {
+			lastModule = originModule;
+			const list = map.get(originModule);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(originModule, list);
+			}
+		}
+	}
+	return map;
 };
 
 /**
- * @param {boolean} optional true, if the module is optional
- * @param {string|string[]} request the request path
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @returns {SourceData} the generated source
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
  */
-const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
-	if (!Array.isArray(request)) {
-		// make it an array as the look up works the same basically
-		request = [request];
+const getConnectionsByModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { module } = connection;
+		if (lastModule === module) {
+			lastList.push(connection);
+		} else {
+			lastModule = module;
+			const list = map.get(module);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(module, list);
+			}
+		}
 	}
-
-	const variableName = request[0];
-	const objectLookup = propertyAccess(request, 1);
-	return {
-		init: optional
-			? checkExternalVariable(variableName, request.join("."), runtimeTemplate)
-			: undefined,
-		expression: `${variableName}${objectLookup}`
-	};
+	return map;
 };
 
-class ExternalModule extends Module {
-	constructor(request, type, userRequest) {
-		super("javascript/dynamic", null);
+class ModuleGraphModule {
+	constructor() {
+		/** @type {SortableSet<ModuleGraphConnection>} */
+		this.incomingConnections = new SortableSet();
+		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
+		this.outgoingConnections = undefined;
+		/** @type {Module | null} */
+		this.issuer = undefined;
+		/** @type {(string | OptimizationBailoutFunction)[]} */
+		this.optimizationBailout = [];
+		/** @type {ExportsInfo} */
+		this.exports = new ExportsInfo();
+		/** @type {number} */
+		this.preOrderIndex = null;
+		/** @type {number} */
+		this.postOrderIndex = null;
+		/** @type {number} */
+		this.depth = null;
+		/** @type {ModuleProfile} */
+		this.profile = undefined;
+		/** @type {boolean} */
+		this.async = false;
+		/** @type {ModuleGraphConnection[]} */
+		this._unassignedConnections = undefined;
+	}
+}
 
-		// Info from Factory
-		/** @type {string | string[] | Record<string, string | string[]>} */
-		this.request = request;
-		/** @type {string} */
-		this.externalType = type;
-		/** @type {string} */
-		this.userRequest = userRequest;
+class ModuleGraph {
+	constructor() {
+		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
+		this._dependencyMap = new WeakMap();
+		/** @type {Map<Module, ModuleGraphModule>} */
+		this._moduleMap = new Map();
+		/** @type {WeakMap<any, Object>} */
+		this._metaMap = new WeakMap();
+
+		/** @type {WeakTupleMap<any[], any>} */
+		this._cache = undefined;
+
+		/** @type {Map<Module, WeakTupleMap<any, any>>} */
+		this._moduleMemCaches = undefined;
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @param {Module} module the module
+	 * @returns {ModuleGraphModule} the internal module
 	 */
-	getSourceTypes() {
-		return this.externalType === "css-import" ? CSS_TYPES : TYPES;
+	_getModuleGraphModule(module) {
+		let mgm = this._moduleMap.get(module);
+		if (mgm === undefined) {
+			mgm = new ModuleGraphModule();
+			this._moduleMap.set(module, mgm);
+		}
+		return mgm;
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @param {Dependency} dependency the dependency
+	 * @param {DependenciesBlock} block parent block
+	 * @param {Module} module parent module
+	 * @param {number=} indexInBlock position in block
+	 * @returns {void}
 	 */
-	libIdent(options) {
-		return this.userRequest;
+	setParents(dependency, block, module, indexInBlock = -1) {
+		dependency._parentDependenciesBlockIndex = indexInBlock;
+		dependency._parentDependenciesBlock = block;
+		dependency._parentModule = module;
 	}
 
 	/**
-	 * @param {Chunk} chunk the chunk which condition should be checked
-	 * @param {Compilation} compilation the compilation
-	 * @returns {boolean} true, if the chunk is ok for the module
+	 * @param {Dependency} dependency the dependency
+	 * @returns {Module} parent module
 	 */
-	chunkCondition(chunk, { chunkGraph }) {
-		return this.externalType === "css-import"
-			? true
-			: chunkGraph.getNumberOfEntryModules(chunk) > 0;
+	getParentModule(dependency) {
+		return dependency._parentModule;
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {Dependency} dependency the dependency
+	 * @returns {DependenciesBlock} parent block
 	 */
-	identifier() {
-		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
+	getParentBlock(dependency) {
+		return dependency._parentDependenciesBlock;
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {Dependency} dependency the dependency
+	 * @returns {number} index
 	 */
-	readableIdentifier(requestShortener) {
-		return "external " + JSON.stringify(this.request);
+	getParentBlockIndex(dependency) {
+		return dependency._parentDependenciesBlockIndex;
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {Module} originModule the referencing module
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {Module} module the referenced module
 	 * @returns {void}
 	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
+	setResolvedModule(originModule, dependency, module) {
+		const connection = new ModuleGraphConnection(
+			originModule,
+			dependency,
+			module,
+			undefined,
+			dependency.weak,
+			dependency.getCondition(this)
+		);
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		connections.add(connection);
+		if (originModule) {
+			const mgm = this._getModuleGraphModule(originModule);
+			if (mgm._unassignedConnections === undefined) {
+				mgm._unassignedConnections = [];
+			}
+			mgm._unassignedConnections.push(connection);
+			if (mgm.outgoingConnections === undefined) {
+				mgm.outgoingConnections = new SortableSet();
+			}
+			mgm.outgoingConnections.add(connection);
+		} else {
+			this._dependencyMap.set(dependency, connection);
+		}
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {Module} module the referenced module
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {
-			async: false,
-			exportsType: undefined
-		};
-		this.buildInfo = {
-			strict: true,
-			topLevelDeclarations: new Set(),
-			module: compilation.outputOptions.module
-		};
-		const { request, externalType } = this._getRequestAndExternalType();
-		this.buildMeta.exportsType = "dynamic";
-		let canMangle = false;
-		this.clearDependenciesAndBlocks();
-		switch (externalType) {
-			case "this":
-				this.buildInfo.strict = false;
-				break;
-			case "system":
-				if (!Array.isArray(request) || request.length === 1) {
-					this.buildMeta.exportsType = "namespace";
-					canMangle = true;
-				}
-				break;
-			case "module":
-				if (this.buildInfo.module) {
-					if (!Array.isArray(request) || request.length === 1) {
-						this.buildMeta.exportsType = "namespace";
-						canMangle = true;
-					}
-				} else {
-					this.buildMeta.async = true;
-					if (!Array.isArray(request) || request.length === 1) {
-						this.buildMeta.exportsType = "namespace";
-						canMangle = false;
-					}
-				}
-				break;
-			case "script":
-			case "promise":
-				this.buildMeta.async = true;
-				break;
-			case "import":
-				this.buildMeta.async = true;
-				if (!Array.isArray(request) || request.length === 1) {
-					this.buildMeta.exportsType = "namespace";
-					canMangle = false;
-				}
-				break;
-		}
-		this.addDependency(new StaticExportsDependency(true, canMangle));
-		callback();
+	updateModule(dependency, module) {
+		const connection = this.getConnection(dependency);
+		if (connection.module === module) return;
+		const newConnection = connection.clone();
+		newConnection.module = module;
+		this._dependencyMap.set(dependency, newConnection);
+		connection.setActive(false);
+		const originMgm = this._getModuleGraphModule(connection.originModule);
+		originMgm.outgoingConnections.add(newConnection);
+		const targetMgm = this._getModuleGraphModule(module);
+		targetMgm.incomingConnections.add(newConnection);
 	}
 
-	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+	/**
+	 * @param {Dependency} dependency the referencing dependency
+	 * @returns {void}
+	 */
+	removeConnection(dependency) {
+		const connection = this.getConnection(dependency);
+		const targetMgm = this._getModuleGraphModule(connection.module);
+		targetMgm.incomingConnections.delete(connection);
+		const originMgm = this._getModuleGraphModule(connection.originModule);
+		originMgm.outgoingConnections.delete(connection);
+		this._dependencyMap.set(dependency, null);
 	}
 
 	/**
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 * @param {Dependency} dependency the referencing dependency
+	 * @param {string} explanation an explanation
+	 * @returns {void}
 	 */
-	getConcatenationBailoutReason({ moduleGraph }) {
-		switch (this.externalType) {
-			case "amd":
-			case "amd-require":
-			case "umd":
-			case "umd2":
-			case "system":
-			case "jsonp":
-				return `${this.externalType} externals can't be concatenated`;
-		}
-		return undefined;
+	addExplanation(dependency, explanation) {
+		const connection = this.getConnection(dependency);
+		connection.addExplanation(explanation);
 	}
 
-	_getRequestAndExternalType() {
-		let { request, externalType } = this;
-		if (typeof request === "object" && !Array.isArray(request))
-			request = request[externalType];
-		return { request, externalType };
+	/**
+	 * @param {Module} sourceModule the source module
+	 * @param {Module} targetModule the target module
+	 * @returns {void}
+	 */
+	cloneModuleAttributes(sourceModule, targetModule) {
+		const oldMgm = this._getModuleGraphModule(sourceModule);
+		const newMgm = this._getModuleGraphModule(targetModule);
+		newMgm.postOrderIndex = oldMgm.postOrderIndex;
+		newMgm.preOrderIndex = oldMgm.preOrderIndex;
+		newMgm.depth = oldMgm.depth;
+		newMgm.exports = oldMgm.exports;
+		newMgm.async = oldMgm.async;
 	}
 
-	_getSourceData(
-		request,
-		externalType,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime
-	) {
-		switch (externalType) {
-			case "this":
-			case "window":
-			case "self":
-				return getSourceForGlobalVariableExternal(request, this.externalType);
-			case "global":
-				return getSourceForGlobalVariableExternal(
-					request,
-					runtimeTemplate.globalObject
-				);
-			case "commonjs":
-			case "commonjs2":
-			case "commonjs-module":
-			case "commonjs-static":
-				return getSourceForCommonJsExternal(request);
-			case "node-commonjs":
-				return this.buildInfo.module
-					? getSourceForCommonJsExternalInNodeModule(request)
-					: getSourceForCommonJsExternal(request);
-			case "amd":
-			case "amd-require":
-			case "umd":
-			case "umd2":
-			case "system":
-			case "jsonp": {
-				const id = chunkGraph.getModuleId(this);
-				return getSourceForAmdOrUmdExternal(
-					id !== null ? id : this.identifier(),
-					this.isOptional(moduleGraph),
-					request,
-					runtimeTemplate
-				);
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	removeModuleAttributes(module) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.postOrderIndex = null;
+		mgm.preOrderIndex = null;
+		mgm.depth = null;
+		mgm.async = false;
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	removeAllModuleAttributes() {
+		for (const mgm of this._moduleMap.values()) {
+			mgm.postOrderIndex = null;
+			mgm.preOrderIndex = null;
+			mgm.depth = null;
+			mgm.async = false;
+		}
+	}
+
+	/**
+	 * @param {Module} oldModule the old referencing module
+	 * @param {Module} newModule the new referencing module
+	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
+	 * @returns {void}
+	 */
+	moveModuleConnections(oldModule, newModule, filterConnection) {
+		if (oldModule === newModule) return;
+		const oldMgm = this._getModuleGraphModule(oldModule);
+		const newMgm = this._getModuleGraphModule(newModule);
+		// Outgoing connections
+		const oldConnections = oldMgm.outgoingConnections;
+		if (oldConnections !== undefined) {
+			if (newMgm.outgoingConnections === undefined) {
+				newMgm.outgoingConnections = new SortableSet();
 			}
-			case "import":
-				return getSourceForImportExternal(request, runtimeTemplate);
-			case "script":
-				return getSourceForScriptExternal(request, runtimeTemplate);
-			case "module": {
-				if (!this.buildInfo.module) {
-					if (!runtimeTemplate.supportsDynamicImport()) {
-						throw new Error(
-							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
-								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
-									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
-									: "")
-						);
-					}
-					return getSourceForImportExternal(request, runtimeTemplate);
-				}
-				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
-					throw new Error(
-						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
-					);
+			const newConnections = newMgm.outgoingConnections;
+			for (const connection of oldConnections) {
+				if (filterConnection(connection)) {
+					connection.originModule = newModule;
+					newConnections.add(connection);
+					oldConnections.delete(connection);
 				}
-				return getSourceForModuleExternal(
-					request,
-					moduleGraph.getExportsInfo(this),
-					runtime,
-					runtimeTemplate.outputOptions.hashFunction
-				);
 			}
-			case "var":
-			case "promise":
-			case "const":
-			case "let":
-			case "assign":
-			default:
-				return getSourceForDefaultCase(
-					this.isOptional(moduleGraph),
-					request,
-					runtimeTemplate
-				);
+		}
+		// Incoming connections
+		const oldConnections2 = oldMgm.incomingConnections;
+		const newConnections2 = newMgm.incomingConnections;
+		for (const connection of oldConnections2) {
+			if (filterConnection(connection)) {
+				connection.module = newModule;
+				newConnections2.add(connection);
+				oldConnections2.delete(connection);
+			}
 		}
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {Module} oldModule the old referencing module
+	 * @param {Module} newModule the new referencing module
+	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
+	 * @returns {void}
 	 */
-	codeGeneration({
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime,
-		concatenationScope
-	}) {
-		const { request, externalType } = this._getRequestAndExternalType();
-		switch (externalType) {
-			case "asset": {
-				const sources = new Map();
-				sources.set(
-					"javascript",
-					new RawSource(`module.exports = ${JSON.stringify(request)};`)
-				);
-				const data = new Map();
-				data.set("url", request);
-				return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS, data };
-			}
-			case "css-import": {
-				const sources = new Map();
-				sources.set(
-					"css-import",
-					new RawSource(`@import url(${JSON.stringify(request)});`)
-				);
-				return {
-					sources,
-					runtimeRequirements: EMPTY_RUNTIME_REQUIREMENTS
-				};
+	copyOutgoingModuleConnections(oldModule, newModule, filterConnection) {
+		if (oldModule === newModule) return;
+		const oldMgm = this._getModuleGraphModule(oldModule);
+		const newMgm = this._getModuleGraphModule(newModule);
+		// Outgoing connections
+		const oldConnections = oldMgm.outgoingConnections;
+		if (oldConnections !== undefined) {
+			if (newMgm.outgoingConnections === undefined) {
+				newMgm.outgoingConnections = new SortableSet();
 			}
-			default: {
-				const sourceData = this._getSourceData(
-					request,
-					externalType,
-					runtimeTemplate,
-					moduleGraph,
-					chunkGraph,
-					runtime
-				);
-
-				let sourceString = sourceData.expression;
-				if (sourceData.iife)
-					sourceString = `(function() { return ${sourceString}; }())`;
-				if (concatenationScope) {
-					sourceString = `${
-						runtimeTemplate.supportsConst() ? "const" : "var"
-					} ${ConcatenationScope.NAMESPACE_OBJECT_EXPORT} = ${sourceString};`;
-					concatenationScope.registerNamespaceExport(
-						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-					);
-				} else {
-					sourceString = `module.exports = ${sourceString};`;
-				}
-				if (sourceData.init)
-					sourceString = `${sourceData.init}\n${sourceString}`;
-
-				let data = undefined;
-				if (sourceData.chunkInitFragments) {
-					data = new Map();
-					data.set("chunkInitFragments", sourceData.chunkInitFragments);
-				}
-
-				const sources = new Map();
-				if (this.useSourceMap || this.useSimpleSourceMap) {
-					sources.set(
-						"javascript",
-						new OriginalSource(sourceString, this.identifier())
-					);
-				} else {
-					sources.set("javascript", new RawSource(sourceString));
-				}
-
-				let runtimeRequirements = sourceData.runtimeRequirements;
-				if (!concatenationScope) {
-					if (!runtimeRequirements) {
-						runtimeRequirements = RUNTIME_REQUIREMENTS;
-					} else {
-						const set = new Set(runtimeRequirements);
-						set.add(RuntimeGlobals.module);
-						runtimeRequirements = set;
+			const newConnections = newMgm.outgoingConnections;
+			for (const connection of oldConnections) {
+				if (filterConnection(connection)) {
+					const newConnection = connection.clone();
+					newConnection.originModule = newModule;
+					newConnections.add(newConnection);
+					if (newConnection.module !== undefined) {
+						const otherMgm = this._getModuleGraphModule(newConnection.module);
+						otherMgm.incomingConnections.add(newConnection);
 					}
 				}
-
-				return {
-					sources,
-					runtimeRequirements:
-						runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
-					data
-				};
 			}
 		}
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {Module} module the referenced module
+	 * @param {string} explanation an explanation why it's referenced
+	 * @returns {void}
 	 */
-	size(type) {
-		return 42;
+	addExtraReason(module, explanation) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		connections.add(new ModuleGraphConnection(null, null, module, explanation));
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @param {Dependency} dependency the dependency to look for a referenced module
+	 * @returns {Module} the referenced module
 	 */
-	updateHash(hash, context) {
-		const { chunkGraph } = context;
-		hash.update(
-			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
-				chunkGraph.moduleGraph
-			)}`
-		);
-		super.updateHash(hash, context);
+	getResolvedModule(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.resolvedModule : null;
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.request);
-		write(this.externalType);
-		write(this.userRequest);
-
-		super.serialize(context);
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referenced module
+	 * @returns {ModuleGraphConnection | undefined} the connection
+	 */
+	getConnection(dependency) {
+		const connection = this._dependencyMap.get(dependency);
+		if (connection === undefined) {
+			const module = this.getParentModule(dependency);
+			if (module !== undefined) {
+				const mgm = this._getModuleGraphModule(module);
+				if (
+					mgm._unassignedConnections &&
+					mgm._unassignedConnections.length !== 0
+				) {
+					let foundConnection;
+					for (const connection of mgm._unassignedConnections) {
+						this._dependencyMap.set(connection.dependency, connection);
+						if (connection.dependency === dependency)
+							foundConnection = connection;
+					}
+					mgm._unassignedConnections.length = 0;
+					if (foundConnection !== undefined) {
+						return foundConnection;
+					}
+				}
+			}
+			this._dependencyMap.set(dependency, null);
+			return undefined;
+		}
+		return connection === null ? undefined : connection;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.request = read();
-		this.externalType = read();
-		this.userRequest = read();
-
-		super.deserialize(context);
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referenced module
+	 * @returns {Module} the referenced module
+	 */
+	getModule(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.module : null;
 	}
-}
-
-makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
-
-module.exports = ExternalModule;
-
 
-/***/ }),
-
-/***/ 62153:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const util = __webpack_require__(73837);
-const ExternalModule = __webpack_require__(73071);
-const { resolveByProperty, cachedSetProperty } = __webpack_require__(60839);
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referencing module
+	 * @returns {Module} the referencing module
+	 */
+	getOrigin(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.originModule : null;
+	}
 
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+	/**
+	 * @param {Dependency} dependency the dependency to look for a referencing module
+	 * @returns {Module} the original referencing module
+	 */
+	getResolvedOrigin(dependency) {
+		const connection = this.getConnection(dependency);
+		return connection !== undefined ? connection.resolvedOriginModule : null;
+	}
 
-const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
-const EMPTY_RESOLVE_OPTIONS = {};
+	/**
+	 * @param {Module} module the module
+	 * @returns {Iterable<ModuleGraphConnection>} reasons why a module is included
+	 */
+	getIncomingConnections(module) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		return connections;
+	}
 
-// TODO webpack 6 remove this
-const callDeprecatedExternals = util.deprecate(
-	(externalsFunction, context, request, cb) => {
-		externalsFunction.call(null, context, request, cb);
-	},
-	"The externals-function should be defined like ({context, request}, cb) => { ... }",
-	"DEP_WEBPACK_EXTERNALS_FUNCTION_PARAMETERS"
-);
+	/**
+	 * @param {Module} module the module
+	 * @returns {Iterable<ModuleGraphConnection>} list of outgoing connections
+	 */
+	getOutgoingConnections(module) {
+		const connections = this._getModuleGraphModule(module).outgoingConnections;
+		return connections === undefined ? EMPTY_SET : connections;
+	}
 
-const cache = new WeakMap();
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 */
+	getIncomingConnectionsByOriginModule(module) {
+		const connections = this._getModuleGraphModule(module).incomingConnections;
+		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
+	}
 
-const resolveLayer = (obj, layer) => {
-	let map = cache.get(obj);
-	if (map === undefined) {
-		map = new Map();
-		cache.set(obj, map);
-	} else {
-		const cacheEntry = map.get(layer);
-		if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
+	 */
+	getOutgoingConnectionsByModule(module) {
+		const connections = this._getModuleGraphModule(module).outgoingConnections;
+		return connections === undefined
+			? undefined
+			: connections.getFromUnorderedCache(getConnectionsByModule);
 	}
-	const result = resolveByProperty(obj, "byLayer", layer);
-	map.set(layer, result);
-	return result;
-};
 
-class ExternalModuleFactoryPlugin {
 	/**
-	 * @param {string | undefined} type default external type
-	 * @param {Externals} externals externals config
+	 * @param {Module} module the module
+	 * @returns {ModuleProfile | null} the module profile
 	 */
-	constructor(type, externals) {
-		this.type = type;
-		this.externals = externals;
+	getProfile(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.profile;
 	}
 
 	/**
-	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+	 * @param {Module} module the module
+	 * @param {ModuleProfile | null} profile the module profile
 	 * @returns {void}
 	 */
-	apply(normalModuleFactory) {
-		const globalType = this.type;
-		normalModuleFactory.hooks.factorize.tapAsync(
-			"ExternalModuleFactoryPlugin",
-			(data, callback) => {
-				const context = data.context;
-				const contextInfo = data.contextInfo;
-				const dependency = data.dependencies[0];
-				const dependencyType = data.dependencyType;
-
-				/**
-				 * @param {string|string[]|boolean|Record<string, string|string[]>} value the external config
-				 * @param {string|undefined} type type of external
-				 * @param {function(Error=, ExternalModule=): void} callback callback
-				 * @returns {void}
-				 */
-				const handleExternal = (value, type, callback) => {
-					if (value === false) {
-						// Not externals, fallback to original factory
-						return callback();
-					}
-					/** @type {string | string[] | Record<string, string|string[]>} */
-					let externalConfig;
-					if (value === true) {
-						externalConfig = dependency.request;
-					} else {
-						externalConfig = value;
-					}
-					// When no explicit type is specified, extract it from the externalConfig
-					if (type === undefined) {
-						if (
-							typeof externalConfig === "string" &&
-							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig)
-						) {
-							const idx = externalConfig.indexOf(" ");
-							type = externalConfig.substr(0, idx);
-							externalConfig = externalConfig.substr(idx + 1);
-						} else if (
-							Array.isArray(externalConfig) &&
-							externalConfig.length > 0 &&
-							UNSPECIFIED_EXTERNAL_TYPE_REGEXP.test(externalConfig[0])
-						) {
-							const firstItem = externalConfig[0];
-							const idx = firstItem.indexOf(" ");
-							type = firstItem.substr(0, idx);
-							externalConfig = [
-								firstItem.substr(idx + 1),
-								...externalConfig.slice(1)
-							];
-						}
-					}
-					callback(
-						null,
-						new ExternalModule(
-							externalConfig,
-							type || globalType,
-							dependency.request
-						)
-					);
-				};
-
-				/**
-				 * @param {Externals} externals externals config
-				 * @param {function((Error | null)=, ExternalModule=): void} callback callback
-				 * @returns {void}
-				 */
-				const handleExternals = (externals, callback) => {
-					if (typeof externals === "string") {
-						if (externals === dependency.request) {
-							return handleExternal(dependency.request, undefined, callback);
-						}
-					} else if (Array.isArray(externals)) {
-						let i = 0;
-						const next = () => {
-							let asyncFlag;
-							const handleExternalsAndCallback = (err, module) => {
-								if (err) return callback(err);
-								if (!module) {
-									if (asyncFlag) {
-										asyncFlag = false;
-										return;
-									}
-									return next();
-								}
-								callback(null, module);
-							};
+	setProfile(module, profile) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.profile = profile;
+	}
 
-							do {
-								asyncFlag = true;
-								if (i >= externals.length) return callback();
-								handleExternals(externals[i++], handleExternalsAndCallback);
-							} while (!asyncFlag);
-							asyncFlag = false;
-						};
+	/**
+	 * @param {Module} module the module
+	 * @returns {Module | null} the issuer module
+	 */
+	getIssuer(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.issuer;
+	}
 
-						next();
-						return;
-					} else if (externals instanceof RegExp) {
-						if (externals.test(dependency.request)) {
-							return handleExternal(dependency.request, undefined, callback);
-						}
-					} else if (typeof externals === "function") {
-						const cb = (err, value, type) => {
-							if (err) return callback(err);
-							if (value !== undefined) {
-								handleExternal(value, type, callback);
-							} else {
-								callback();
-							}
-						};
-						if (externals.length === 3) {
-							// TODO webpack 6 remove this
-							callDeprecatedExternals(
-								externals,
-								context,
-								dependency.request,
-								cb
-							);
-						} else {
-							const promise = externals(
-								{
-									context,
-									request: dependency.request,
-									dependencyType,
-									contextInfo,
-									getResolve: options => (context, request, callback) => {
-										const resolveContext = {
-											fileDependencies: data.fileDependencies,
-											missingDependencies: data.missingDependencies,
-											contextDependencies: data.contextDependencies
-										};
-										let resolver = normalModuleFactory.getResolver(
-											"normal",
-											dependencyType
-												? cachedSetProperty(
-														data.resolveOptions || EMPTY_RESOLVE_OPTIONS,
-														"dependencyType",
-														dependencyType
-												  )
-												: data.resolveOptions
-										);
-										if (options) resolver = resolver.withOptions(options);
-										if (callback) {
-											resolver.resolve(
-												{},
-												context,
-												request,
-												resolveContext,
-												callback
-											);
-										} else {
-											return new Promise((resolve, reject) => {
-												resolver.resolve(
-													{},
-													context,
-													request,
-													resolveContext,
-													(err, result) => {
-														if (err) reject(err);
-														else resolve(result);
-													}
-												);
-											});
-										}
-									}
-								},
-								cb
-							);
-							if (promise && promise.then) promise.then(r => cb(null, r), cb);
-						}
-						return;
-					} else if (typeof externals === "object") {
-						const resolvedExternals = resolveLayer(
-							externals,
-							contextInfo.issuerLayer
-						);
-						if (
-							Object.prototype.hasOwnProperty.call(
-								resolvedExternals,
-								dependency.request
-							)
-						) {
-							return handleExternal(
-								resolvedExternals[dependency.request],
-								undefined,
-								callback
-							);
-						}
-					}
-					callback();
-				};
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | null} issuer the issuer module
+	 * @returns {void}
+	 */
+	setIssuer(module, issuer) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.issuer = issuer;
+	}
 
-				handleExternals(this.externals, callback);
-			}
-		);
+	/**
+	 * @param {Module} module the module
+	 * @param {Module | null} issuer the issuer module
+	 * @returns {void}
+	 */
+	setIssuerIfUnset(module, issuer) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.issuer === undefined) mgm.issuer = issuer;
 	}
-}
-module.exports = ExternalModuleFactoryPlugin;
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {(string | OptimizationBailoutFunction)[]} optimization bailouts
+	 */
+	getOptimizationBailout(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.optimizationBailout;
+	}
 
-/***/ }),
+	/**
+	 * @param {Module} module the module
+	 * @returns {true | string[] | null} the provided exports
+	 */
+	getProvidedExports(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getProvidedExports();
+	}
 
-/***/ 6652:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {Module} module the module
+	 * @param {string | string[]} exportName a name of an export
+	 * @returns {boolean | null} true, if the export is provided by the module.
+	 * null, if it's unknown.
+	 * false, if it's not provided.
+	 */
+	isExportProvided(module, exportName) {
+		const mgm = this._getModuleGraphModule(module);
+		const result = mgm.exports.isExportProvided(exportName);
+		return result === undefined ? null : result;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {Module} module the module
+	 * @returns {ExportsInfo} info about the exports
+	 */
+	getExportsInfo(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports;
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {string} exportName the export
+	 * @returns {ExportInfo} info about the export
+	 */
+	getExportInfo(module, exportName) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getExportInfo(exportName);
+	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {string} exportName the export
+	 * @returns {ExportInfo} info about the export (do not modify)
+	 */
+	getReadOnlyExportInfo(module, exportName) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getReadOnlyExportInfo(exportName);
+	}
 
-const ExternalModuleFactoryPlugin = __webpack_require__(62153);
+	/**
+	 * @param {Module} module the module
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {false | true | SortableSet<string> | null} the used exports
+	 * false: module is not used at all.
+	 * true: the module namespace/object export is used.
+	 * SortableSet<string>: these export names are used.
+	 * empty SortableSet<string>: module is used but no export.
+	 * null: unknown, worst case should be assumed.
+	 */
+	getUsedExports(module, runtime) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.exports.getUsedExports(runtime);
+	}
 
-/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
-/** @typedef {import("./Compiler")} Compiler */
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the index of the module
+	 */
+	getPreOrderIndex(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.preOrderIndex;
+	}
 
-class ExternalsPlugin {
 	/**
-	 * @param {string | undefined} type default external type
-	 * @param {Externals} externals externals config
+	 * @param {Module} module the module
+	 * @returns {number} the index of the module
 	 */
-	constructor(type, externals) {
-		this.type = type;
-		this.externals = externals;
+	getPostOrderIndex(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.postOrderIndex;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compile.tap("ExternalsPlugin", ({ normalModuleFactory }) => {
-			new ExternalModuleFactoryPlugin(this.type, this.externals).apply(
-				normalModuleFactory
-			);
-		});
+	setPreOrderIndex(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.preOrderIndex = index;
 	}
-}
-
-module.exports = ExternalsPlugin;
-
-
-/***/ }),
 
-/***/ 79453:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { create: createResolver } = __webpack_require__(30662);
-const asyncLib = __webpack_require__(78175);
-const AsyncQueue = __webpack_require__(12260);
-const StackedCacheMap = __webpack_require__(64985);
-const createHash = __webpack_require__(49835);
-const { join, dirname, relative, lstatReadlinkAbsolute } = __webpack_require__(17139);
-const makeSerializable = __webpack_require__(33032);
-const processAsyncTree = __webpack_require__(42791);
-
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {typeof import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").IStats} IStats */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const supportsEsm = +process.versions.modules >= 83;
-
-let FS_ACCURACY = 2000;
-
-const EMPTY_SET = new Set();
-
-const RBDT_RESOLVE_CJS = 0;
-const RBDT_RESOLVE_ESM = 1;
-const RBDT_RESOLVE_DIRECTORY = 2;
-const RBDT_RESOLVE_CJS_FILE = 3;
-const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4;
-const RBDT_RESOLVE_ESM_FILE = 5;
-const RBDT_DIRECTORY = 6;
-const RBDT_FILE = 7;
-const RBDT_DIRECTORY_DEPENDENCIES = 8;
-const RBDT_FILE_DEPENDENCIES = 9;
-
-const INVALID = Symbol("invalid");
-
-/**
- * @typedef {Object} FileSystemInfoEntry
- * @property {number} safeTime
- * @property {number=} timestamp
- */
-
-/**
- * @typedef {Object} ResolvedContextFileSystemInfoEntry
- * @property {number} safeTime
- * @property {string=} timestampHash
- */
-
-/**
- * @typedef {Object} ContextFileSystemInfoEntry
- * @property {number} safeTime
- * @property {string=} timestampHash
- * @property {ResolvedContextFileSystemInfoEntry=} resolved
- * @property {Set<string>=} symlinks
- */
-
-/**
- * @typedef {Object} TimestampAndHash
- * @property {number} safeTime
- * @property {number=} timestamp
- * @property {string} hash
- */
-
-/**
- * @typedef {Object} ResolvedContextTimestampAndHash
- * @property {number} safeTime
- * @property {string=} timestampHash
- * @property {string} hash
- */
-
-/**
- * @typedef {Object} ContextTimestampAndHash
- * @property {number} safeTime
- * @property {string=} timestampHash
- * @property {string} hash
- * @property {ResolvedContextTimestampAndHash=} resolved
- * @property {Set<string>=} symlinks
- */
-
-/**
- * @typedef {Object} ContextHash
- * @property {string} hash
- * @property {string=} resolved
- * @property {Set<string>=} symlinks
- */
-
-/**
- * @typedef {Object} SnapshotOptimizationEntry
- * @property {Snapshot} snapshot
- * @property {number} shared
- * @property {Set<string>} snapshotContent
- * @property {Set<SnapshotOptimizationEntry>} children
- */
-
-/**
- * @typedef {Object} ResolveBuildDependenciesResult
- * @property {Set<string>} files list of files
- * @property {Set<string>} directories list of directories
- * @property {Set<string>} missing list of missing entries
- * @property {Map<string, string | false>} resolveResults stored resolve results
- * @property {Object} resolveDependencies dependencies of the resolving
- * @property {Set<string>} resolveDependencies.files list of files
- * @property {Set<string>} resolveDependencies.directories list of directories
- * @property {Set<string>} resolveDependencies.missing list of missing entries
- */
-
-const DONE_ITERATOR_RESULT = new Set().keys().next();
-
-// cspell:word tshs
-// Tsh = Timestamp + Hash
-// Tshs = Timestamp + Hash combinations
-
-class SnapshotIterator {
-	constructor(next) {
-		this.next = next;
-	}
-}
-
-class SnapshotIterable {
-	constructor(snapshot, getMaps) {
-		this.snapshot = snapshot;
-		this.getMaps = getMaps;
+	/**
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {boolean} true, if the index was set
+	 */
+	setPreOrderIndexIfUnset(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.preOrderIndex === null) {
+			mgm.preOrderIndex = index;
+			return true;
+		}
+		return false;
 	}
 
-	[Symbol.iterator]() {
-		let state = 0;
-		/** @type {IterableIterator<string>} */
-		let it;
-		/** @type {(Snapshot) => (Map<string, any> | Set<string>)[]} */
-		let getMaps;
-		/** @type {(Map<string, any> | Set<string>)[]} */
-		let maps;
-		/** @type {Snapshot} */
-		let snapshot;
-		let queue;
-		return new SnapshotIterator(() => {
-			for (;;) {
-				switch (state) {
-					case 0:
-						snapshot = this.snapshot;
-						getMaps = this.getMaps;
-						maps = getMaps(snapshot);
-						state = 1;
-					/* falls through */
-					case 1:
-						if (maps.length > 0) {
-							const map = maps.pop();
-							if (map !== undefined) {
-								it = map.keys();
-								state = 2;
-							} else {
-								break;
-							}
-						} else {
-							state = 3;
-							break;
-						}
-					/* falls through */
-					case 2: {
-						const result = it.next();
-						if (!result.done) return result;
-						state = 1;
-						break;
-					}
-					case 3: {
-						const children = snapshot.children;
-						if (children !== undefined) {
-							if (children.size === 1) {
-								// shortcut for a single child
-								// avoids allocation of queue
-								for (const child of children) snapshot = child;
-								maps = getMaps(snapshot);
-								state = 1;
-								break;
-							}
-							if (queue === undefined) queue = [];
-							for (const child of children) {
-								queue.push(child);
-							}
-						}
-						if (queue !== undefined && queue.length > 0) {
-							snapshot = queue.pop();
-							maps = getMaps(snapshot);
-							state = 1;
-							break;
-						} else {
-							state = 4;
-						}
-					}
-					/* falls through */
-					case 4:
-						return DONE_ITERATOR_RESULT;
-				}
-			}
-		});
+	/**
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {void}
+	 */
+	setPostOrderIndex(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.postOrderIndex = index;
 	}
-}
 
-class Snapshot {
-	constructor() {
-		this._flags = 0;
-		/** @type {number | undefined} */
-		this.startTime = undefined;
-		/** @type {Map<string, FileSystemInfoEntry | null> | undefined} */
-		this.fileTimestamps = undefined;
-		/** @type {Map<string, string | null> | undefined} */
-		this.fileHashes = undefined;
-		/** @type {Map<string, TimestampAndHash | string | null> | undefined} */
-		this.fileTshs = undefined;
-		/** @type {Map<string, ResolvedContextFileSystemInfoEntry | null> | undefined} */
-		this.contextTimestamps = undefined;
-		/** @type {Map<string, string | null> | undefined} */
-		this.contextHashes = undefined;
-		/** @type {Map<string, ResolvedContextTimestampAndHash | null> | undefined} */
-		this.contextTshs = undefined;
-		/** @type {Map<string, boolean> | undefined} */
-		this.missingExistence = undefined;
-		/** @type {Map<string, string> | undefined} */
-		this.managedItemInfo = undefined;
-		/** @type {Set<string> | undefined} */
-		this.managedFiles = undefined;
-		/** @type {Set<string> | undefined} */
-		this.managedContexts = undefined;
-		/** @type {Set<string> | undefined} */
-		this.managedMissing = undefined;
-		/** @type {Set<Snapshot> | undefined} */
-		this.children = undefined;
+	/**
+	 * @param {Module} module the module
+	 * @param {number} index the index of the module
+	 * @returns {boolean} true, if the index was set
+	 */
+	setPostOrderIndexIfUnset(module, index) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.postOrderIndex === null) {
+			mgm.postOrderIndex = index;
+			return true;
+		}
+		return false;
 	}
 
-	hasStartTime() {
-		return (this._flags & 1) !== 0;
+	/**
+	 * @param {Module} module the module
+	 * @returns {number} the depth of the module
+	 */
+	getDepth(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.depth;
 	}
 
-	setStartTime(value) {
-		this._flags = this._flags | 1;
-		this.startTime = value;
+	/**
+	 * @param {Module} module the module
+	 * @param {number} depth the depth of the module
+	 * @returns {void}
+	 */
+	setDepth(module, depth) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.depth = depth;
 	}
 
-	setMergedStartTime(value, snapshot) {
-		if (value) {
-			if (snapshot.hasStartTime()) {
-				this.setStartTime(Math.min(value, snapshot.startTime));
-			} else {
-				this.setStartTime(value);
-			}
-		} else {
-			if (snapshot.hasStartTime()) this.setStartTime(snapshot.startTime);
+	/**
+	 * @param {Module} module the module
+	 * @param {number} depth the depth of the module
+	 * @returns {boolean} true, if the depth was set
+	 */
+	setDepthIfLower(module, depth) {
+		const mgm = this._getModuleGraphModule(module);
+		if (mgm.depth === null || mgm.depth > depth) {
+			mgm.depth = depth;
+			return true;
 		}
+		return false;
 	}
 
-	hasFileTimestamps() {
-		return (this._flags & 2) !== 0;
+	/**
+	 * @param {Module} module the module
+	 * @returns {boolean} true, if the module is async
+	 */
+	isAsync(module) {
+		const mgm = this._getModuleGraphModule(module);
+		return mgm.async;
 	}
 
-	setFileTimestamps(value) {
-		this._flags = this._flags | 2;
-		this.fileTimestamps = value;
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	setAsync(module) {
+		const mgm = this._getModuleGraphModule(module);
+		mgm.async = true;
 	}
 
-	hasFileHashes() {
-		return (this._flags & 4) !== 0;
+	/**
+	 * @param {any} thing any thing
+	 * @returns {Object} metadata
+	 */
+	getMeta(thing) {
+		let meta = this._metaMap.get(thing);
+		if (meta === undefined) {
+			meta = Object.create(null);
+			this._metaMap.set(thing, meta);
+		}
+		return meta;
 	}
 
-	setFileHashes(value) {
-		this._flags = this._flags | 4;
-		this.fileHashes = value;
+	/**
+	 * @param {any} thing any thing
+	 * @returns {Object} metadata
+	 */
+	getMetaIfExisting(thing) {
+		return this._metaMap.get(thing);
 	}
 
-	hasFileTshs() {
-		return (this._flags & 8) !== 0;
+	/**
+	 * @param {string=} cacheStage a persistent stage name for caching
+	 */
+	freeze(cacheStage) {
+		this._cache = new WeakTupleMap();
+		this._cacheStage = cacheStage;
 	}
 
-	setFileTshs(value) {
-		this._flags = this._flags | 8;
-		this.fileTshs = value;
+	unfreeze() {
+		this._cache = undefined;
+		this._cacheStage = undefined;
 	}
 
-	hasContextTimestamps() {
-		return (this._flags & 0x10) !== 0;
+	/**
+	 * @template {any[]} T
+	 * @template V
+	 * @param {(moduleGraph: ModuleGraph, ...args: T) => V} fn computer
+	 * @param {T} args arguments
+	 * @returns {V} computed value or cached
+	 */
+	cached(fn, ...args) {
+		if (this._cache === undefined) return fn(this, ...args);
+		return this._cache.provide(fn, ...args, () => fn(this, ...args));
 	}
 
-	setContextTimestamps(value) {
-		this._flags = this._flags | 0x10;
-		this.contextTimestamps = value;
+	/**
+	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 */
+	setModuleMemCaches(moduleMemCaches) {
+		this._moduleMemCaches = moduleMemCaches;
 	}
 
-	hasContextHashes() {
-		return (this._flags & 0x20) !== 0;
+	/**
+	 * @param {Dependency} dependency dependency
+	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
+	 * @returns {any} computed value or cached
+	 */
+	dependencyCacheProvide(dependency, ...args) {
+		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
+		const fn = args.pop();
+		if (this._moduleMemCaches && this._cacheStage) {
+			const memCache = this._moduleMemCaches.get(
+				this.getParentModule(dependency)
+			);
+			if (memCache !== undefined) {
+				return memCache.provide(dependency, this._cacheStage, ...args, () =>
+					fn(this, dependency, ...args)
+				);
+			}
+		}
+		if (this._cache === undefined) return fn(this, dependency, ...args);
+		return this._cache.provide(dependency, ...args, () =>
+			fn(this, dependency, ...args)
+		);
 	}
 
-	setContextHashes(value) {
-		this._flags = this._flags | 0x20;
-		this.contextHashes = value;
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @param {string} deprecateMessage message for the deprecation message
+	 * @param {string} deprecationCode code for the deprecation
+	 * @returns {ModuleGraph} the module graph
+	 */
+	static getModuleGraphForModule(module, deprecateMessage, deprecationCode) {
+		const fn = deprecateMap.get(deprecateMessage);
+		if (fn) return fn(module);
+		const newFn = util.deprecate(
+			/**
+			 * @param {Module} module the module
+			 * @returns {ModuleGraph} the module graph
+			 */
+			module => {
+				const moduleGraph = moduleGraphForModuleMap.get(module);
+				if (!moduleGraph)
+					throw new Error(
+						deprecateMessage +
+							"There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)"
+					);
+				return moduleGraph;
+			},
+			deprecateMessage + ": Use new ModuleGraph API",
+			deprecationCode
+		);
+		deprecateMap.set(deprecateMessage, newFn);
+		return newFn(module);
 	}
 
-	hasContextTshs() {
-		return (this._flags & 0x40) !== 0;
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {void}
+	 */
+	static setModuleGraphForModule(module, moduleGraph) {
+		moduleGraphForModuleMap.set(module, moduleGraph);
 	}
 
-	setContextTshs(value) {
-		this._flags = this._flags | 0x40;
-		this.contextTshs = value;
+	// TODO remove in webpack 6
+	/**
+	 * @param {Module} module the module
+	 * @returns {void}
+	 */
+	static clearModuleGraphForModule(module) {
+		moduleGraphForModuleMap.delete(module);
 	}
+}
 
-	hasMissingExistence() {
-		return (this._flags & 0x80) !== 0;
-	}
+// TODO remove in webpack 6
+/** @type {WeakMap<Module, ModuleGraph>} */
+const moduleGraphForModuleMap = new WeakMap();
 
-	setMissingExistence(value) {
-		this._flags = this._flags | 0x80;
-		this.missingExistence = value;
-	}
+// TODO remove in webpack 6
+/** @type {Map<string, (module: Module) => ModuleGraph>} */
+const deprecateMap = new Map();
 
-	hasManagedItemInfo() {
-		return (this._flags & 0x100) !== 0;
-	}
+module.exports = ModuleGraph;
+module.exports.ModuleGraphConnection = ModuleGraphConnection;
 
-	setManagedItemInfo(value) {
-		this._flags = this._flags | 0x100;
-		this.managedItemInfo = value;
-	}
 
-	hasManagedFiles() {
-		return (this._flags & 0x200) !== 0;
-	}
+/***/ }),
 
-	setManagedFiles(value) {
-		this._flags = this._flags | 0x200;
-		this.managedFiles = value;
-	}
+/***/ 40639:
+/***/ (function(module) {
 
-	hasManagedContexts() {
-		return (this._flags & 0x400) !== 0;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	setManagedContexts(value) {
-		this._flags = this._flags | 0x400;
-		this.managedContexts = value;
-	}
 
-	hasManagedMissing() {
-		return (this._flags & 0x800) !== 0;
-	}
 
-	setManagedMissing(value) {
-		this._flags = this._flags | 0x800;
-		this.managedMissing = value;
-	}
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-	hasChildren() {
-		return (this._flags & 0x1000) !== 0;
-	}
+/**
+ * Module itself is not connected, but transitive modules are connected transitively.
+ */
+const TRANSITIVE_ONLY = Symbol("transitive only");
 
-	setChildren(value) {
-		this._flags = this._flags | 0x1000;
-		this.children = value;
-	}
+/**
+ * While determining the active state, this flag is used to signal a circular connection.
+ */
+const CIRCULAR_CONNECTION = Symbol("circular connection");
 
-	addChild(child) {
-		if (!this.hasChildren()) {
-			this.setChildren(new Set());
-		}
-		this.children.add(child);
-	}
+/** @typedef {boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION} ConnectionState */
 
-	serialize({ write }) {
-		write(this._flags);
-		if (this.hasStartTime()) write(this.startTime);
-		if (this.hasFileTimestamps()) write(this.fileTimestamps);
-		if (this.hasFileHashes()) write(this.fileHashes);
-		if (this.hasFileTshs()) write(this.fileTshs);
-		if (this.hasContextTimestamps()) write(this.contextTimestamps);
-		if (this.hasContextHashes()) write(this.contextHashes);
-		if (this.hasContextTshs()) write(this.contextTshs);
-		if (this.hasMissingExistence()) write(this.missingExistence);
-		if (this.hasManagedItemInfo()) write(this.managedItemInfo);
-		if (this.hasManagedFiles()) write(this.managedFiles);
-		if (this.hasManagedContexts()) write(this.managedContexts);
-		if (this.hasManagedMissing()) write(this.managedMissing);
-		if (this.hasChildren()) write(this.children);
-	}
+/**
+ * @param {ConnectionState} a first
+ * @param {ConnectionState} b second
+ * @returns {ConnectionState} merged
+ */
+const addConnectionStates = (a, b) => {
+	if (a === true || b === true) return true;
+	if (a === false) return b;
+	if (b === false) return a;
+	if (a === TRANSITIVE_ONLY) return b;
+	if (b === TRANSITIVE_ONLY) return a;
+	return a;
+};
 
-	deserialize({ read }) {
-		this._flags = read();
-		if (this.hasStartTime()) this.startTime = read();
-		if (this.hasFileTimestamps()) this.fileTimestamps = read();
-		if (this.hasFileHashes()) this.fileHashes = read();
-		if (this.hasFileTshs()) this.fileTshs = read();
-		if (this.hasContextTimestamps()) this.contextTimestamps = read();
-		if (this.hasContextHashes()) this.contextHashes = read();
-		if (this.hasContextTshs()) this.contextTshs = read();
-		if (this.hasMissingExistence()) this.missingExistence = read();
-		if (this.hasManagedItemInfo()) this.managedItemInfo = read();
-		if (this.hasManagedFiles()) this.managedFiles = read();
-		if (this.hasManagedContexts()) this.managedContexts = read();
-		if (this.hasManagedMissing()) this.managedMissing = read();
-		if (this.hasChildren()) this.children = read();
-	}
+/**
+ * @param {ConnectionState} a first
+ * @param {ConnectionState} b second
+ * @returns {ConnectionState} intersected
+ */
+const intersectConnectionStates = (a, b) => {
+	if (a === false || b === false) return false;
+	if (a === true) return b;
+	if (b === true) return a;
+	if (a === CIRCULAR_CONNECTION) return b;
+	if (b === CIRCULAR_CONNECTION) return a;
+	return a;
+};
 
+class ModuleGraphConnection {
 	/**
-	 * @param {function(Snapshot): (ReadonlyMap<string, any> | ReadonlySet<string>)[]} getMaps first
-	 * @returns {Iterable<string>} iterable
+	 * @param {Module|null} originModule the referencing module
+	 * @param {Dependency|null} dependency the referencing dependency
+	 * @param {Module} module the referenced module
+	 * @param {string=} explanation some extra detail
+	 * @param {boolean=} weak the reference is weak
+	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
 	 */
-	_createIterable(getMaps) {
-		return new SnapshotIterable(this, getMaps);
+	constructor(
+		originModule,
+		dependency,
+		module,
+		explanation,
+		weak = false,
+		condition = undefined
+	) {
+		this.originModule = originModule;
+		this.resolvedOriginModule = originModule;
+		this.dependency = dependency;
+		this.resolvedModule = module;
+		this.module = module;
+		this.weak = weak;
+		this.conditional = !!condition;
+		this._active = condition !== false;
+		/** @type {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} */
+		this.condition = condition || undefined;
+		/** @type {Set<string>} */
+		this.explanations = undefined;
+		if (explanation) {
+			this.explanations = new Set();
+			this.explanations.add(explanation);
+		}
 	}
 
-	/**
-	 * @returns {Iterable<string>} iterable
-	 */
-	getFileIterable() {
-		return this._createIterable(s => [
-			s.fileTimestamps,
-			s.fileHashes,
-			s.fileTshs,
-			s.managedFiles
-		]);
+	clone() {
+		const clone = new ModuleGraphConnection(
+			this.resolvedOriginModule,
+			this.dependency,
+			this.resolvedModule,
+			undefined,
+			this.weak,
+			this.condition
+		);
+		clone.originModule = this.originModule;
+		clone.module = this.module;
+		clone.conditional = this.conditional;
+		clone._active = this._active;
+		if (this.explanations) clone.explanations = new Set(this.explanations);
+		return clone;
 	}
 
 	/**
-	 * @returns {Iterable<string>} iterable
+	 * @param {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} condition condition for the connection
+	 * @returns {void}
 	 */
-	getContextIterable() {
-		return this._createIterable(s => [
-			s.contextTimestamps,
-			s.contextHashes,
-			s.contextTshs,
-			s.managedContexts
-		]);
+	addCondition(condition) {
+		if (this.conditional) {
+			const old = this.condition;
+			this.condition = (c, r) =>
+				intersectConnectionStates(old(c, r), condition(c, r));
+		} else if (this._active) {
+			this.conditional = true;
+			this.condition = condition;
+		}
 	}
 
 	/**
-	 * @returns {Iterable<string>} iterable
+	 * @param {string} explanation the explanation to add
+	 * @returns {void}
 	 */
-	getMissingIterable() {
-		return this._createIterable(s => [s.missingExistence, s.managedMissing]);
+	addExplanation(explanation) {
+		if (this.explanations === undefined) {
+			this.explanations = new Set();
+		}
+		this.explanations.add(explanation);
 	}
-}
 
-makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot");
+	get explanation() {
+		if (this.explanations === undefined) return "";
+		return Array.from(this.explanations).join(" ");
+	}
 
-const MIN_COMMON_SNAPSHOT_SIZE = 3;
+	// TODO webpack 5 remove
+	get active() {
+		throw new Error("Use getActiveState instead");
+	}
 
-/**
- * @template T
- */
-class SnapshotOptimization {
 	/**
-	 * @param {function(Snapshot): boolean} has has value
-	 * @param {function(Snapshot): Map<string, T> | Set<string>} get get value
-	 * @param {function(Snapshot, Map<string, T> | Set<string>): void} set set value
-	 * @param {boolean=} useStartTime use the start time of snapshots
-	 * @param {boolean=} isSet value is an Set instead of a Map
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, if the connection is active
 	 */
-	constructor(has, get, set, useStartTime = true, isSet = false) {
-		this._has = has;
-		this._get = get;
-		this._set = set;
-		this._useStartTime = useStartTime;
-		this._isSet = isSet;
-		/** @type {Map<string, SnapshotOptimizationEntry>} */
-		this._map = new Map();
-		this._statItemsShared = 0;
-		this._statItemsUnshared = 0;
-		this._statSharedSnapshots = 0;
-		this._statReusedSharedSnapshots = 0;
+	isActive(runtime) {
+		if (!this.conditional) return this._active;
+		return this.condition(this, runtime) !== false;
 	}
 
-	getStatisticMessage() {
-		const total = this._statItemsShared + this._statItemsUnshared;
-		if (total === 0) return undefined;
-		return `${
-			this._statItemsShared && Math.round((this._statItemsShared * 100) / total)
-		}% (${this._statItemsShared}/${total}) entries shared via ${
-			this._statSharedSnapshots
-		} shared snapshots (${
-			this._statReusedSharedSnapshots + this._statSharedSnapshots
-		} times referenced)`;
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {boolean} true, if the connection is active
+	 */
+	isTargetActive(runtime) {
+		if (!this.conditional) return this._active;
+		return this.condition(this, runtime) === true;
 	}
 
-	clear() {
-		this._map.clear();
-		this._statItemsShared = 0;
-		this._statItemsUnshared = 0;
-		this._statSharedSnapshots = 0;
-		this._statReusedSharedSnapshots = 0;
+	/**
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ConnectionState} true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active
+	 */
+	getActiveState(runtime) {
+		if (!this.conditional) return this._active;
+		return this.condition(this, runtime);
 	}
 
 	/**
-	 * @param {Snapshot} newSnapshot snapshot
-	 * @param {Set<string>} capturedFiles files to snapshot/share
+	 * @param {boolean} value active or not
 	 * @returns {void}
 	 */
-	optimize(newSnapshot, capturedFiles) {
-		/**
-		 * @param {SnapshotOptimizationEntry} entry optimization entry
-		 * @returns {void}
-		 */
-		const increaseSharedAndStoreOptimizationEntry = entry => {
-			if (entry.children !== undefined) {
-				entry.children.forEach(increaseSharedAndStoreOptimizationEntry);
-			}
-			entry.shared++;
-			storeOptimizationEntry(entry);
-		};
-		/**
-		 * @param {SnapshotOptimizationEntry} entry optimization entry
-		 * @returns {void}
-		 */
-		const storeOptimizationEntry = entry => {
-			for (const path of entry.snapshotContent) {
-				const old = this._map.get(path);
-				if (old.shared < entry.shared) {
-					this._map.set(path, entry);
-				}
-				capturedFiles.delete(path);
-			}
-		};
+	setActive(value) {
+		this.conditional = false;
+		this._active = value;
+	}
 
-		/** @type {SnapshotOptimizationEntry} */
-		let newOptimizationEntry = undefined;
+	set active(value) {
+		throw new Error("Use setActive instead");
+	}
+}
 
-		const capturedFilesSize = capturedFiles.size;
+/** @typedef {typeof TRANSITIVE_ONLY} TRANSITIVE_ONLY */
+/** @typedef {typeof CIRCULAR_CONNECTION} CIRCULAR_CONNECTION */
 
-		/** @type {Set<SnapshotOptimizationEntry> | undefined} */
-		const optimizationEntries = new Set();
+module.exports = ModuleGraphConnection;
+module.exports.addConnectionStates = addConnectionStates;
+module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ (
+	TRANSITIVE_ONLY
+);
+module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ (
+	CIRCULAR_CONNECTION
+);
 
-		for (const path of capturedFiles) {
-			const optimizationEntry = this._map.get(path);
-			if (optimizationEntry === undefined) {
-				if (newOptimizationEntry === undefined) {
-					newOptimizationEntry = {
-						snapshot: newSnapshot,
-						shared: 0,
-						snapshotContent: undefined,
-						children: undefined
-					};
-				}
-				this._map.set(path, newOptimizationEntry);
-				continue;
-			} else {
-				optimizationEntries.add(optimizationEntry);
-			}
-		}
 
-		optimizationEntries: for (const optimizationEntry of optimizationEntries) {
-			const snapshot = optimizationEntry.snapshot;
-			if (optimizationEntry.shared > 0) {
-				// It's a shared snapshot
-				// We can't change it, so we can only use it when all files match
-				// and startTime is compatible
-				if (
-					this._useStartTime &&
-					newSnapshot.startTime &&
-					(!snapshot.startTime || snapshot.startTime > newSnapshot.startTime)
-				) {
-					continue;
-				}
-				const nonSharedFiles = new Set();
-				const snapshotContent = optimizationEntry.snapshotContent;
-				const snapshotEntries = this._get(snapshot);
-				for (const path of snapshotContent) {
-					if (!capturedFiles.has(path)) {
-						if (!snapshotEntries.has(path)) {
-							// File is not shared and can't be removed from the snapshot
-							// because it's in a child of the snapshot
-							continue optimizationEntries;
-						}
-						nonSharedFiles.add(path);
-						continue;
-					}
-				}
-				if (nonSharedFiles.size === 0) {
-					// The complete snapshot is shared
-					// add it as child
-					newSnapshot.addChild(snapshot);
-					increaseSharedAndStoreOptimizationEntry(optimizationEntry);
-					this._statReusedSharedSnapshots++;
-				} else {
-					// Only a part of the snapshot is shared
-					const sharedCount = snapshotContent.size - nonSharedFiles.size;
-					if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {
-						// Common part it too small
-						continue optimizationEntries;
-					}
-					// Extract common timestamps from both snapshots
-					let commonMap;
-					if (this._isSet) {
-						commonMap = new Set();
-						for (const path of /** @type {Set<string>} */ (snapshotEntries)) {
-							if (nonSharedFiles.has(path)) continue;
-							commonMap.add(path);
-							snapshotEntries.delete(path);
-						}
-					} else {
-						commonMap = new Map();
-						const map = /** @type {Map<string, T>} */ (snapshotEntries);
-						for (const [path, value] of map) {
-							if (nonSharedFiles.has(path)) continue;
-							commonMap.set(path, value);
-							snapshotEntries.delete(path);
-						}
-					}
-					// Create and attach snapshot
-					const commonSnapshot = new Snapshot();
-					if (this._useStartTime) {
-						commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
-					}
-					this._set(commonSnapshot, commonMap);
-					newSnapshot.addChild(commonSnapshot);
-					snapshot.addChild(commonSnapshot);
-					// Create optimization entry
-					const newEntry = {
-						snapshot: commonSnapshot,
-						shared: optimizationEntry.shared + 1,
-						snapshotContent: new Set(commonMap.keys()),
-						children: undefined
-					};
-					if (optimizationEntry.children === undefined)
-						optimizationEntry.children = new Set();
-					optimizationEntry.children.add(newEntry);
-					storeOptimizationEntry(newEntry);
-					this._statSharedSnapshots++;
-				}
-			} else {
-				// It's a unshared snapshot
-				// We can extract a common shared snapshot
-				// with all common files
-				const snapshotEntries = this._get(snapshot);
-				if (snapshotEntries === undefined) {
-					// Incomplete snapshot, that can't be used
-					continue optimizationEntries;
-				}
-				let commonMap;
-				if (this._isSet) {
-					commonMap = new Set();
-					const set = /** @type {Set<string>} */ (snapshotEntries);
-					if (capturedFiles.size < set.size) {
-						for (const path of capturedFiles) {
-							if (set.has(path)) commonMap.add(path);
-						}
-					} else {
-						for (const path of set) {
-							if (capturedFiles.has(path)) commonMap.add(path);
-						}
-					}
-				} else {
-					commonMap = new Map();
-					const map = /** @type {Map<string, T>} */ (snapshotEntries);
-					for (const path of capturedFiles) {
-						const ts = map.get(path);
-						if (ts === undefined) continue;
-						commonMap.set(path, ts);
-					}
-				}
+/***/ }),
 
-				if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {
-					// Common part it too small
-					continue optimizationEntries;
-				}
-				// Create and attach snapshot
-				const commonSnapshot = new Snapshot();
-				if (this._useStartTime) {
-					commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
-				}
-				this._set(commonSnapshot, commonMap);
-				newSnapshot.addChild(commonSnapshot);
-				snapshot.addChild(commonSnapshot);
-				// Remove files from snapshot
-				for (const path of commonMap.keys()) snapshotEntries.delete(path);
-				const sharedCount = commonMap.size;
-				this._statItemsUnshared -= sharedCount;
-				this._statItemsShared += sharedCount;
-				// Create optimization entry
-				storeOptimizationEntry({
-					snapshot: commonSnapshot,
-					shared: 2,
-					snapshotContent: new Set(commonMap.keys()),
-					children: undefined
-				});
-				this._statSharedSnapshots++;
-			}
-		}
-		const unshared = capturedFiles.size;
-		this._statItemsUnshared += unshared;
-		this._statItemsShared += capturedFilesSize - unshared;
-	}
-}
+/***/ 3454:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const parseString = str => {
-	if (str[0] === "'") str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
-	return JSON.parse(str);
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/* istanbul ignore next */
-/**
- * @param {number} mtime mtime
- */
-const applyMtime = mtime => {
-	if (FS_ACCURACY > 1 && mtime % 2 !== 0) FS_ACCURACY = 1;
-	else if (FS_ACCURACY > 10 && mtime % 20 !== 0) FS_ACCURACY = 10;
-	else if (FS_ACCURACY > 100 && mtime % 200 !== 0) FS_ACCURACY = 100;
-	else if (FS_ACCURACY > 1000 && mtime % 2000 !== 0) FS_ACCURACY = 1000;
-};
 
-/**
- * @template T
- * @template K
- * @param {Map<T, K>} a source map
- * @param {Map<T, K>} b joining map
- * @returns {Map<T, K>} joined map
- */
-const mergeMaps = (a, b) => {
-	if (!b || b.size === 0) return a;
-	if (!a || a.size === 0) return b;
-	const map = new Map(a);
-	for (const [key, value] of b) {
-		map.set(key, value);
+
+const { ConcatSource, RawSource, CachedSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Template = __webpack_require__(1626);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
+/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
 	}
-	return map;
+	return str;
 };
 
 /**
- * @template T
- * @template K
- * @param {Set<T, K>} a source map
- * @param {Set<T, K>} b joining map
- * @returns {Set<T, K>} joined map
- */
-const mergeSets = (a, b) => {
-	if (!b || b.size === 0) return a;
-	if (!a || a.size === 0) return b;
-	const map = new Set(a);
-	for (const item of b) {
-		map.add(item);
-	}
-	return map;
-};
-
-/**
- * Finding file or directory to manage
- * @param {string} managedPath path that is managing by {@link FileSystemInfo}
- * @param {string} path path to file or directory
- * @returns {string|null} managed item
- * @example
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/package/index.js'
- * ) === '/Users/user/my-project/node_modules/package'
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/package1/node_modules/package2'
- * ) === '/Users/user/my-project/node_modules/package1/node_modules/package2'
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/.bin/script.js'
- * ) === null // hidden files are disallowed as managed items
- * getManagedItem(
- *   '/Users/user/my-project/node_modules/',
- *   '/Users/user/my-project/node_modules/package'
- * ) === '/Users/user/my-project/node_modules/package'
+ * @param {ConcatSource} source output
+ * @param {string} indent spacing
+ * @param {ExportsInfo} exportsInfo data
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RequestShortener} requestShortener requestShortener
+ * @param {Set<ExportInfo>} alreadyPrinted deduplication set
+ * @returns {void}
  */
-const getManagedItem = (managedPath, path) => {
-	let i = managedPath.length;
-	let slashes = 1;
-	let startingPosition = true;
-	loop: while (i < path.length) {
-		switch (path.charCodeAt(i)) {
-			case 47: // slash
-			case 92: // backslash
-				if (--slashes === 0) break loop;
-				startingPosition = true;
-				break;
-			case 46: // .
-				// hidden files are disallowed as managed items
-				// it's probably .yarn-integrity or .cache
-				if (startingPosition) return null;
-				break;
-			case 64: // @
-				if (!startingPosition) return null;
-				slashes++;
-				break;
-			default:
-				startingPosition = false;
-				break;
+const printExportsInfoToSource = (
+	source,
+	indent,
+	exportsInfo,
+	moduleGraph,
+	requestShortener,
+	alreadyPrinted = new Set()
+) => {
+	const otherExportsInfo = exportsInfo.otherExportsInfo;
+
+	let alreadyPrintedExports = 0;
+
+	// determine exports to print
+	const printedExports = [];
+	for (const exportInfo of exportsInfo.orderedExports) {
+		if (!alreadyPrinted.has(exportInfo)) {
+			alreadyPrinted.add(exportInfo);
+			printedExports.push(exportInfo);
+		} else {
+			alreadyPrintedExports++;
 		}
-		i++;
 	}
-	if (i === path.length) slashes--;
-	// return null when path is incomplete
-	if (slashes !== 0) return null;
-	// if (path.slice(i + 1, i + 13) === "node_modules")
-	if (
-		path.length >= i + 13 &&
-		path.charCodeAt(i + 1) === 110 &&
-		path.charCodeAt(i + 2) === 111 &&
-		path.charCodeAt(i + 3) === 100 &&
-		path.charCodeAt(i + 4) === 101 &&
-		path.charCodeAt(i + 5) === 95 &&
-		path.charCodeAt(i + 6) === 109 &&
-		path.charCodeAt(i + 7) === 111 &&
-		path.charCodeAt(i + 8) === 100 &&
-		path.charCodeAt(i + 9) === 117 &&
-		path.charCodeAt(i + 10) === 108 &&
-		path.charCodeAt(i + 11) === 101 &&
-		path.charCodeAt(i + 12) === 115
-	) {
-		// if this is the end of the path
-		if (path.length === i + 13) {
-			// return the node_modules directory
-			// it's special
-			return path;
-		}
-		const c = path.charCodeAt(i + 13);
-		// if next symbol is slash or backslash
-		if (c === 47 || c === 92) {
-			// Managed subpath
-			return getManagedItem(path.slice(0, i + 14), path);
-		}
+	let showOtherExports = false;
+	if (!alreadyPrinted.has(otherExportsInfo)) {
+		alreadyPrinted.add(otherExportsInfo);
+		showOtherExports = true;
+	} else {
+		alreadyPrintedExports++;
 	}
-	return path.slice(0, i);
-};
-
-/**
- * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
- * @param {T} entry entry
- * @returns {T["resolved"] | undefined} the resolved entry
- */
-const getResolvedTimestamp = entry => {
-	if (entry === null) return null;
-	if (entry.resolved !== undefined) return entry.resolved;
-	return entry.symlinks === undefined ? entry : undefined;
-};
-
-/**
- * @param {ContextHash} entry entry
- * @returns {string | undefined} the resolved entry
- */
-const getResolvedHash = entry => {
-	if (entry === null) return null;
-	if (entry.resolved !== undefined) return entry.resolved;
-	return entry.symlinks === undefined ? entry.hash : undefined;
-};
-
-const addAll = (source, target) => {
-	for (const key of source) target.add(key);
-};
-
-/**
- * Used to access information about the filesystem in a cached way
- */
-class FileSystemInfo {
-	/**
-	 * @param {InputFileSystem} fs file system
-	 * @param {Object} options options
-	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
-	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
-	 * @param {Logger=} options.logger logger used to log invalid snapshots
-	 * @param {string | Hash=} options.hashFunction the hash function to use
-	 */
-	constructor(
-		fs,
-		{
-			managedPaths = [],
-			immutablePaths = [],
-			logger,
-			hashFunction = "md4"
-		} = {}
-	) {
-		this.fs = fs;
-		this.logger = logger;
-		this._remainingLogs = logger ? 40 : 0;
-		this._loggedPaths = logger ? new Set() : undefined;
-		this._hashFunction = hashFunction;
-		/** @type {WeakMap<Snapshot, boolean | (function(WebpackError=, boolean=): void)[]>} */
-		this._snapshotCache = new WeakMap();
-		this._fileTimestampsOptimization = new SnapshotOptimization(
-			s => s.hasFileTimestamps(),
-			s => s.fileTimestamps,
-			(s, v) => s.setFileTimestamps(v)
-		);
-		this._fileHashesOptimization = new SnapshotOptimization(
-			s => s.hasFileHashes(),
-			s => s.fileHashes,
-			(s, v) => s.setFileHashes(v),
-			false
-		);
-		this._fileTshsOptimization = new SnapshotOptimization(
-			s => s.hasFileTshs(),
-			s => s.fileTshs,
-			(s, v) => s.setFileTshs(v)
-		);
-		this._contextTimestampsOptimization = new SnapshotOptimization(
-			s => s.hasContextTimestamps(),
-			s => s.contextTimestamps,
-			(s, v) => s.setContextTimestamps(v)
-		);
-		this._contextHashesOptimization = new SnapshotOptimization(
-			s => s.hasContextHashes(),
-			s => s.contextHashes,
-			(s, v) => s.setContextHashes(v),
-			false
-		);
-		this._contextTshsOptimization = new SnapshotOptimization(
-			s => s.hasContextTshs(),
-			s => s.contextTshs,
-			(s, v) => s.setContextTshs(v)
-		);
-		this._missingExistenceOptimization = new SnapshotOptimization(
-			s => s.hasMissingExistence(),
-			s => s.missingExistence,
-			(s, v) => s.setMissingExistence(v),
-			false
-		);
-		this._managedItemInfoOptimization = new SnapshotOptimization(
-			s => s.hasManagedItemInfo(),
-			s => s.managedItemInfo,
-			(s, v) => s.setManagedItemInfo(v),
-			false
-		);
-		this._managedFilesOptimization = new SnapshotOptimization(
-			s => s.hasManagedFiles(),
-			s => s.managedFiles,
-			(s, v) => s.setManagedFiles(v),
-			false,
-			true
-		);
-		this._managedContextsOptimization = new SnapshotOptimization(
-			s => s.hasManagedContexts(),
-			s => s.managedContexts,
-			(s, v) => s.setManagedContexts(v),
-			false,
-			true
-		);
-		this._managedMissingOptimization = new SnapshotOptimization(
-			s => s.hasManagedMissing(),
-			s => s.managedMissing,
-			(s, v) => s.setManagedMissing(v),
-			false,
-			true
-		);
-		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
-		this._fileTimestamps = new StackedCacheMap();
-		/** @type {Map<string, string>} */
-		this._fileHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string>} */
-		this._fileTshs = new Map();
-		/** @type {StackedCacheMap<string, ContextFileSystemInfoEntry | "ignore" | null>} */
-		this._contextTimestamps = new StackedCacheMap();
-		/** @type {Map<string, ContextHash>} */
-		this._contextHashes = new Map();
-		/** @type {Map<string, ContextTimestampAndHash>} */
-		this._contextTshs = new Map();
-		/** @type {Map<string, string>} */
-		this._managedItems = new Map();
-		/** @type {AsyncQueue<string, string, FileSystemInfoEntry | null>} */
-		this.fileTimestampQueue = new AsyncQueue({
-			name: "file timestamp",
-			parallelism: 30,
-			processor: this._readFileTimestamp.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, string | null>} */
-		this.fileHashQueue = new AsyncQueue({
-			name: "file hash",
-			parallelism: 10,
-			processor: this._readFileHash.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry | null>} */
-		this.contextTimestampQueue = new AsyncQueue({
-			name: "context timestamp",
-			parallelism: 2,
-			processor: this._readContextTimestamp.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, ContextHash | null>} */
-		this.contextHashQueue = new AsyncQueue({
-			name: "context hash",
-			parallelism: 2,
-			processor: this._readContextHash.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, ContextTimestampAndHash | null>} */
-		this.contextTshQueue = new AsyncQueue({
-			name: "context hash and timestamp",
-			parallelism: 2,
-			processor: this._readContextTimestampAndHash.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, string | null>} */
-		this.managedItemQueue = new AsyncQueue({
-			name: "managed item info",
-			parallelism: 10,
-			processor: this._getManagedItemInfo.bind(this)
-		});
-		/** @type {AsyncQueue<string, string, Set<string>>} */
-		this.managedItemDirectoryQueue = new AsyncQueue({
-			name: "managed item directory info",
-			parallelism: 10,
-			processor: this._getManagedItemDirectoryInfo.bind(this)
-		});
-		this.managedPaths = Array.from(managedPaths);
-		this.managedPathsWithSlash = /** @type {string[]} */ (
-			this.managedPaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
 
-		this.managedPathsRegExps = /** @type {RegExp[]} */ (
-			this.managedPaths.filter(p => typeof p !== "string")
-		);
-		this.immutablePaths = Array.from(immutablePaths);
-		this.immutablePathsWithSlash = /** @type {string[]} */ (
-			this.immutablePaths.filter(p => typeof p === "string")
-		).map(p => join(fs, p, "_").slice(0, -1));
-		this.immutablePathsRegExps = /** @type {RegExp[]} */ (
-			this.immutablePaths.filter(p => typeof p !== "string")
+	// print the exports
+	for (const exportInfo of printedExports) {
+		const target = exportInfo.getTarget(moduleGraph);
+		source.add(
+			Template.toComment(
+				`${indent}export ${JSON.stringify(exportInfo.name).slice(
+					1,
+					-1
+				)} [${exportInfo.getProvidedInfo()}] [${exportInfo.getUsedInfo()}] [${exportInfo.getRenameInfo()}]${
+					target
+						? ` -> ${target.module.readableIdentifier(requestShortener)}${
+								target.export
+									? ` .${target.export
+											.map(e => JSON.stringify(e).slice(1, -1))
+											.join(".")}`
+									: ""
+						  }`
+						: ""
+				}`
+			) + "\n"
 		);
-
-		this._cachedDeprecatedFileTimestamps = undefined;
-		this._cachedDeprecatedContextTimestamps = undefined;
-
-		this._warnAboutExperimentalEsmTracking = false;
-
-		this._statCreatedSnapshots = 0;
-		this._statTestedSnapshotsCached = 0;
-		this._statTestedSnapshotsNotCached = 0;
-		this._statTestedChildrenCached = 0;
-		this._statTestedChildrenNotCached = 0;
-		this._statTestedEntries = 0;
+		if (exportInfo.exportsInfo) {
+			printExportsInfoToSource(
+				source,
+				indent + "  ",
+				exportInfo.exportsInfo,
+				moduleGraph,
+				requestShortener,
+				alreadyPrinted
+			);
+		}
 	}
 
-	logStatistics() {
-		const logWhenMessage = (header, message) => {
-			if (message) {
-				this.logger.log(`${header}: ${message}`);
-			}
-		};
-		this.logger.log(`${this._statCreatedSnapshots} new snapshots created`);
-		this.logger.log(
-			`${
-				this._statTestedSnapshotsNotCached &&
-				Math.round(
-					(this._statTestedSnapshotsNotCached * 100) /
-						(this._statTestedSnapshotsCached +
-							this._statTestedSnapshotsNotCached)
-				)
-			}% root snapshot uncached (${this._statTestedSnapshotsNotCached} / ${
-				this._statTestedSnapshotsCached + this._statTestedSnapshotsNotCached
-			})`
-		);
-		this.logger.log(
-			`${
-				this._statTestedChildrenNotCached &&
-				Math.round(
-					(this._statTestedChildrenNotCached * 100) /
-						(this._statTestedChildrenCached + this._statTestedChildrenNotCached)
-				)
-			}% children snapshot uncached (${this._statTestedChildrenNotCached} / ${
-				this._statTestedChildrenCached + this._statTestedChildrenNotCached
-			})`
-		);
-		this.logger.log(`${this._statTestedEntries} entries tested`);
-		this.logger.log(
-			`File info in cache: ${this._fileTimestamps.size} timestamps ${this._fileHashes.size} hashes ${this._fileTshs.size} timestamp hash combinations`
-		);
-		logWhenMessage(
-			`File timestamp snapshot optimization`,
-			this._fileTimestampsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`File hash snapshot optimization`,
-			this._fileHashesOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`File timestamp hash combination snapshot optimization`,
-			this._fileTshsOptimization.getStatisticMessage()
-		);
-		this.logger.log(
-			`Directory info in cache: ${this._contextTimestamps.size} timestamps ${this._contextHashes.size} hashes ${this._contextTshs.size} timestamp hash combinations`
-		);
-		logWhenMessage(
-			`Directory timestamp snapshot optimization`,
-			this._contextTimestampsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Directory hash snapshot optimization`,
-			this._contextHashesOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Directory timestamp hash combination snapshot optimization`,
-			this._contextTshsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Missing items snapshot optimization`,
-			this._missingExistenceOptimization.getStatisticMessage()
-		);
-		this.logger.log(
-			`Managed items info in cache: ${this._managedItems.size} items`
-		);
-		logWhenMessage(
-			`Managed items snapshot optimization`,
-			this._managedItemInfoOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Managed files snapshot optimization`,
-			this._managedFilesOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Managed contexts snapshot optimization`,
-			this._managedContextsOptimization.getStatisticMessage()
-		);
-		logWhenMessage(
-			`Managed missing snapshot optimization`,
-			this._managedMissingOptimization.getStatisticMessage()
+	if (alreadyPrintedExports) {
+		source.add(
+			Template.toComment(
+				`${indent}... (${alreadyPrintedExports} already listed exports)`
+			) + "\n"
 		);
 	}
 
-	_log(path, reason, ...args) {
-		const key = path + reason;
-		if (this._loggedPaths.has(key)) return;
-		this._loggedPaths.add(key);
-		this.logger.debug(`${path} invalidated because ${reason}`, ...args);
-		if (--this._remainingLogs === 0) {
-			this.logger.debug(
-				"Logging limit has been reached and no further logging will be emitted by FileSystemInfo"
+	if (showOtherExports) {
+		const target = otherExportsInfo.getTarget(moduleGraph);
+		if (
+			target ||
+			otherExportsInfo.provided !== false ||
+			otherExportsInfo.getUsed(undefined) !== UsageState.Unused
+		) {
+			const title =
+				printedExports.length > 0 || alreadyPrintedExports > 0
+					? "other exports"
+					: "exports";
+			source.add(
+				Template.toComment(
+					`${indent}${title} [${otherExportsInfo.getProvidedInfo()}] [${otherExportsInfo.getUsedInfo()}]${
+						target
+							? ` -> ${target.module.readableIdentifier(requestShortener)}`
+							: ""
+					}`
+				) + "\n"
 			);
 		}
 	}
+};
 
-	clear() {
-		this._remainingLogs = this.logger ? 40 : 0;
-		if (this._loggedPaths !== undefined) this._loggedPaths.clear();
-
-		this._snapshotCache = new WeakMap();
-		this._fileTimestampsOptimization.clear();
-		this._fileHashesOptimization.clear();
-		this._fileTshsOptimization.clear();
-		this._contextTimestampsOptimization.clear();
-		this._contextHashesOptimization.clear();
-		this._contextTshsOptimization.clear();
-		this._missingExistenceOptimization.clear();
-		this._managedItemInfoOptimization.clear();
-		this._managedFilesOptimization.clear();
-		this._managedContextsOptimization.clear();
-		this._managedMissingOptimization.clear();
-		this._fileTimestamps.clear();
-		this._fileHashes.clear();
-		this._fileTshs.clear();
-		this._contextTimestamps.clear();
-		this._contextHashes.clear();
-		this._contextTshs.clear();
-		this._managedItems.clear();
-		this._managedItems.clear();
-
-		this._cachedDeprecatedFileTimestamps = undefined;
-		this._cachedDeprecatedContextTimestamps = undefined;
-
-		this._statCreatedSnapshots = 0;
-		this._statTestedSnapshotsCached = 0;
-		this._statTestedSnapshotsNotCached = 0;
-		this._statTestedChildrenCached = 0;
-		this._statTestedChildrenNotCached = 0;
-		this._statTestedEntries = 0;
-	}
+/** @type {WeakMap<RequestShortener, WeakMap<Module, { header: RawSource, full: WeakMap<Source, CachedSource> }>>} */
+const caches = new WeakMap();
 
+class ModuleInfoHeaderPlugin {
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
-	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
-	 * @returns {void}
+	 * @param {boolean=} verbose add more information like exports, runtime requirements and bailouts
 	 */
-	addFileTimestamps(map, immutable) {
-		this._fileTimestamps.addAll(map, immutable);
-		this._cachedDeprecatedFileTimestamps = undefined;
+	constructor(verbose = true) {
+		this._verbose = verbose;
 	}
-
 	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} map timestamps
-	 * @param {boolean=} immutable if 'map' is immutable and FileSystemInfo can keep referencing it
+	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
-	addContextTimestamps(map, immutable) {
-		this._contextTimestamps.addAll(map, immutable);
-		this._cachedDeprecatedContextTimestamps = undefined;
+	apply(compiler) {
+		const { _verbose: verbose } = this;
+		compiler.hooks.compilation.tap("ModuleInfoHeaderPlugin", compilation => {
+			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+			hooks.renderModulePackage.tap(
+				"ModuleInfoHeaderPlugin",
+				(
+					moduleSource,
+					module,
+					{ chunk, chunkGraph, moduleGraph, runtimeTemplate }
+				) => {
+					const { requestShortener } = runtimeTemplate;
+					let cacheEntry;
+					let cache = caches.get(requestShortener);
+					if (cache === undefined) {
+						caches.set(requestShortener, (cache = new WeakMap()));
+						cache.set(
+							module,
+							(cacheEntry = { header: undefined, full: new WeakMap() })
+						);
+					} else {
+						cacheEntry = cache.get(module);
+						if (cacheEntry === undefined) {
+							cache.set(
+								module,
+								(cacheEntry = { header: undefined, full: new WeakMap() })
+							);
+						} else if (!verbose) {
+							const cachedSource = cacheEntry.full.get(moduleSource);
+							if (cachedSource !== undefined) return cachedSource;
+						}
+					}
+					const source = new ConcatSource();
+					let header = cacheEntry.header;
+					if (header === undefined) {
+						const req = module.readableIdentifier(requestShortener);
+						const reqStr = req.replace(/\*\//g, "*_/");
+						const reqStrStar = "*".repeat(reqStr.length);
+						const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
+						header = new RawSource(headerStr);
+						cacheEntry.header = header;
+					}
+					source.add(header);
+					if (verbose) {
+						const exportsType = module.buildMeta.exportsType;
+						source.add(
+							Template.toComment(
+								exportsType
+									? `${exportsType} exports`
+									: "unknown exports (runtime-defined)"
+							) + "\n"
+						);
+						if (exportsType) {
+							const exportsInfo = moduleGraph.getExportsInfo(module);
+							printExportsInfoToSource(
+								source,
+								"",
+								exportsInfo,
+								moduleGraph,
+								requestShortener
+							);
+						}
+						source.add(
+							Template.toComment(
+								`runtime requirements: ${joinIterableWithComma(
+									chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime)
+								)}`
+							) + "\n"
+						);
+						const optimizationBailout =
+							moduleGraph.getOptimizationBailout(module);
+						if (optimizationBailout) {
+							for (const text of optimizationBailout) {
+								let code;
+								if (typeof text === "function") {
+									code = text(requestShortener);
+								} else {
+									code = text;
+								}
+								source.add(Template.toComment(`${code}`) + "\n");
+							}
+						}
+						source.add(moduleSource);
+						return source;
+					} else {
+						source.add(moduleSource);
+						const cachedSource = new CachedSource(source);
+						cacheEntry.full.set(moduleSource, cachedSource);
+						return cachedSource;
+					}
+				}
+			);
+			hooks.chunkHash.tap("ModuleInfoHeaderPlugin", (chunk, hash) => {
+				hash.update("ModuleInfoHeaderPlugin");
+				hash.update("1");
+			});
+		});
 	}
+}
+module.exports = ModuleInfoHeaderPlugin;
+
+
+/***/ }),
+
+/***/ 32882:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
+
+const previouslyPolyfilledBuiltinModules = {
+	assert: "assert/",
+	buffer: "buffer/",
+	console: "console-browserify",
+	constants: "constants-browserify",
+	crypto: "crypto-browserify",
+	domain: "domain-browser",
+	events: "events/",
+	http: "stream-http",
+	https: "https-browserify",
+	os: "os-browserify/browser",
+	path: "path-browserify",
+	punycode: "punycode/",
+	process: "process/browser",
+	querystring: "querystring-es3",
+	stream: "stream-browserify",
+	_stream_duplex: "readable-stream/duplex",
+	_stream_passthrough: "readable-stream/passthrough",
+	_stream_readable: "readable-stream/readable",
+	_stream_transform: "readable-stream/transform",
+	_stream_writable: "readable-stream/writable",
+	string_decoder: "string_decoder/",
+	sys: "util/",
+	timers: "timers-browserify",
+	tty: "tty-browserify",
+	url: "url/",
+	util: "util/",
+	vm: "vm-browserify",
+	zlib: "browserify-zlib"
+};
 
+class ModuleNotFoundError extends WebpackError {
 	/**
-	 * @param {string} path file path
-	 * @param {function((WebpackError | null)=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
-	 * @returns {void}
+	 * @param {Module} module module tied to dependency
+	 * @param {Error&any} err error thrown
+	 * @param {DependencyLocation} loc location of dependency
 	 */
-	getFileTimestamp(path, callback) {
-		const cache = this._fileTimestamps.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.fileTimestampQueue.add(path, callback);
+	constructor(module, err, loc) {
+		let message = `Module not found: ${err.toString()}`;
+
+		// TODO remove in webpack 6
+		const match = err.message.match(/Can't resolve '([^']+)'/);
+		if (match) {
+			const request = match[1];
+			const alias = previouslyPolyfilledBuiltinModules[request];
+			if (alias) {
+				const pathIndex = alias.indexOf("/");
+				const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
+				message +=
+					"\n\n" +
+					"BREAKING CHANGE: " +
+					"webpack < 5 used to include polyfills for node.js core modules by default.\n" +
+					"This is no longer the case. Verify if you need this module and configure a polyfill for it.\n\n";
+				message +=
+					"If you want to include a polyfill, you need to:\n" +
+					`\t- add a fallback 'resolve.fallback: { "${request}": require.resolve("${alias}") }'\n` +
+					`\t- install '${dependency}'\n`;
+				message +=
+					"If you don't want to include a polyfill, you can use an empty module like this:\n" +
+					`\tresolve.fallback: { "${request}": false }`;
+			}
+		}
+
+		super(message);
+
+		this.name = "ModuleNotFoundError";
+		this.details = err.details;
+		this.module = module;
+		this.error = err;
+		this.loc = loc;
 	}
+}
+
+module.exports = ModuleNotFoundError;
+
+
+/***/ }),
+
+/***/ 58443:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
+
+class ModuleParseError extends WebpackError {
 	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
-	 * @returns {void}
+	 * @param {string | Buffer} source source code
+	 * @param {Error&any} err the parse error
+	 * @param {string[]} loaders the loaders used
+	 * @param {string} type module type
 	 */
-	getContextTimestamp(path, callback) {
-		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined) {
-			if (cache === "ignore") return callback(null, "ignore");
-			const resolved = getResolvedTimestamp(cache);
-			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextTimestamp(cache, callback);
+	constructor(source, err, loaders, type) {
+		let message = "Module parse failed: " + (err && err.message);
+		let loc = undefined;
+
+		if (
+			((Buffer.isBuffer(source) && source.slice(0, 4).equals(WASM_HEADER)) ||
+				(typeof source === "string" && /^\0asm/.test(source))) &&
+			!type.startsWith("webassembly")
+		) {
+			message +=
+				"\nThe module seem to be a WebAssembly module, but module is not flagged as WebAssembly module for webpack.";
+			message +=
+				"\nBREAKING CHANGE: Since webpack 5 WebAssembly is not enabled by default and flagged as experimental feature.";
+			message +=
+				"\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
+			message +=
+				"\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
+		} else if (!loaders) {
+			message +=
+				"\nYou may need an appropriate loader to handle this file type.";
+		} else if (loaders.length >= 1) {
+			message += `\nFile was processed with these loaders:${loaders
+				.map(loader => `\n * ${loader}`)
+				.join("")}`;
+			message +=
+				"\nYou may need an additional loader to handle the result of these loaders.";
+		} else {
+			message +=
+				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
 		}
-		this.contextTimestampQueue.add(path, (err, entry) => {
-			if (err) return callback(err);
-			const resolved = getResolvedTimestamp(entry);
-			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextTimestamp(entry, callback);
-		});
+
+		if (
+			err &&
+			err.loc &&
+			typeof err.loc === "object" &&
+			typeof err.loc.line === "number"
+		) {
+			var lineNumber = err.loc.line;
+
+			if (
+				Buffer.isBuffer(source) ||
+				/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)
+			) {
+				// binary file
+				message += "\n(Source code omitted for this binary file)";
+			} else {
+				const sourceLines = source.split(/\r?\n/);
+				const start = Math.max(0, lineNumber - 3);
+				const linesBefore = sourceLines.slice(start, lineNumber - 1);
+				const theLine = sourceLines[lineNumber - 1];
+				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
+
+				message +=
+					linesBefore.map(l => `\n| ${l}`).join("") +
+					`\n> ${theLine}` +
+					linesAfter.map(l => `\n| ${l}`).join("");
+			}
+
+			loc = { start: err.loc };
+		} else if (err && err.stack) {
+			message += "\n" + err.stack;
+		}
+
+		super(message);
+
+		this.name = "ModuleParseError";
+		this.loc = loc;
+		this.error = err;
 	}
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
-	 * @returns {void}
-	 */
-	_getUnresolvedContextTimestamp(path, callback) {
-		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.contextTimestampQueue.add(path, callback);
+	serialize(context) {
+		const { write } = context;
+
+		write(this.error);
+
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {string} path file path
-	 * @param {function((WebpackError | null)=, string=): void} callback callback function
-	 * @returns {void}
-	 */
-	getFileHash(path, callback) {
-		const cache = this._fileHashes.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.fileHashQueue.add(path, callback);
+	deserialize(context) {
+		const { read } = context;
+
+		this.error = read();
+
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, string=): void} callback callback function
-	 * @returns {void}
-	 */
-	getContextHash(path, callback) {
-		const cache = this._contextHashes.get(path);
-		if (cache !== undefined) {
-			const resolved = getResolvedHash(cache);
-			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextHash(cache, callback);
-		}
-		this.contextHashQueue.add(path, (err, entry) => {
-			if (err) return callback(err);
-			const resolved = getResolvedHash(entry);
-			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextHash(entry, callback);
-		});
+makeSerializable(ModuleParseError, "webpack/lib/ModuleParseError");
+
+module.exports = ModuleParseError;
+
+
+/***/ }),
+
+/***/ 36418:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+class ModuleProfile {
+	constructor() {
+		this.startTime = Date.now();
+
+		this.factoryStartTime = 0;
+		this.factoryEndTime = 0;
+		this.factory = 0;
+		this.factoryParallelismFactor = 0;
+
+		this.restoringStartTime = 0;
+		this.restoringEndTime = 0;
+		this.restoring = 0;
+		this.restoringParallelismFactor = 0;
+
+		this.integrationStartTime = 0;
+		this.integrationEndTime = 0;
+		this.integration = 0;
+		this.integrationParallelismFactor = 0;
+
+		this.buildingStartTime = 0;
+		this.buildingEndTime = 0;
+		this.building = 0;
+		this.buildingParallelismFactor = 0;
+
+		this.storingStartTime = 0;
+		this.storingEndTime = 0;
+		this.storing = 0;
+		this.storingParallelismFactor = 0;
+
+		this.additionalFactoryTimes = undefined;
+		this.additionalFactories = 0;
+		this.additionalFactoriesParallelismFactor = 0;
+
+		/** @deprecated */
+		this.additionalIntegration = 0;
 	}
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, ContextHash=): void} callback callback function
-	 * @returns {void}
-	 */
-	_getUnresolvedContextHash(path, callback) {
-		const cache = this._contextHashes.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.contextHashQueue.add(path, callback);
+	markFactoryStart() {
+		this.factoryStartTime = Date.now();
 	}
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, ResolvedContextTimestampAndHash=): void} callback callback function
-	 * @returns {void}
-	 */
-	getContextTsh(path, callback) {
-		const cache = this._contextTshs.get(path);
-		if (cache !== undefined) {
-			const resolved = getResolvedTimestamp(cache);
-			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextTsh(cache, callback);
-		}
-		this.contextTshQueue.add(path, (err, entry) => {
-			if (err) return callback(err);
-			const resolved = getResolvedTimestamp(entry);
-			if (resolved !== undefined) return callback(null, resolved);
-			this._resolveContextTsh(entry, callback);
-		});
+	markFactoryEnd() {
+		this.factoryEndTime = Date.now();
+		this.factory = this.factoryEndTime - this.factoryStartTime;
 	}
 
-	/**
-	 * @param {string} path context path
-	 * @param {function((WebpackError | null)=, ContextTimestampAndHash=): void} callback callback function
-	 * @returns {void}
-	 */
-	_getUnresolvedContextTsh(path, callback) {
-		const cache = this._contextTshs.get(path);
-		if (cache !== undefined) return callback(null, cache);
-		this.contextTshQueue.add(path, callback);
+	markRestoringStart() {
+		this.restoringStartTime = Date.now();
 	}
 
-	_createBuildDependenciesResolvers() {
-		const resolveContext = createResolver({
-			resolveToContext: true,
-			exportsFields: [],
-			fileSystem: this.fs
-		});
-		const resolveCjs = createResolver({
-			extensions: [".js", ".json", ".node"],
-			conditionNames: ["require", "node"],
-			exportsFields: ["exports"],
-			fileSystem: this.fs
-		});
-		const resolveCjsAsChild = createResolver({
-			extensions: [".js", ".json", ".node"],
-			conditionNames: ["require", "node"],
-			exportsFields: [],
-			fileSystem: this.fs
-		});
-		const resolveEsm = createResolver({
-			extensions: [".js", ".json", ".node"],
-			fullySpecified: true,
-			conditionNames: ["import", "node"],
-			exportsFields: ["exports"],
-			fileSystem: this.fs
-		});
-		return { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild };
+	markRestoringEnd() {
+		this.restoringEndTime = Date.now();
+		this.restoring = this.restoringEndTime - this.restoringStartTime;
 	}
 
-	/**
-	 * @param {string} context context directory
-	 * @param {Iterable<string>} deps dependencies
-	 * @param {function((Error | null)=, ResolveBuildDependenciesResult=): void} callback callback function
-	 * @returns {void}
-	 */
-	resolveBuildDependencies(context, deps, callback) {
-		const { resolveContext, resolveEsm, resolveCjs, resolveCjsAsChild } =
-			this._createBuildDependenciesResolvers();
+	markIntegrationStart() {
+		this.integrationStartTime = Date.now();
+	}
 
-		/** @type {Set<string>} */
-		const files = new Set();
-		/** @type {Set<string>} */
-		const fileSymlinks = new Set();
-		/** @type {Set<string>} */
-		const directories = new Set();
-		/** @type {Set<string>} */
-		const directorySymlinks = new Set();
-		/** @type {Set<string>} */
-		const missing = new Set();
-		/** @type {Set<string>} */
-		const resolveFiles = new Set();
-		/** @type {Set<string>} */
-		const resolveDirectories = new Set();
-		/** @type {Set<string>} */
-		const resolveMissing = new Set();
-		/** @type {Map<string, string | false>} */
-		const resolveResults = new Map();
-		const invalidResolveResults = new Set();
-		const resolverContext = {
-			fileDependencies: resolveFiles,
-			contextDependencies: resolveDirectories,
-			missingDependencies: resolveMissing
-		};
-		const expectedToString = expected => {
-			return expected ? ` (expected ${expected})` : "";
-		};
-		const jobToString = job => {
-			switch (job.type) {
-				case RBDT_RESOLVE_CJS:
-					return `resolve commonjs ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_RESOLVE_ESM:
-					return `resolve esm ${job.path}${expectedToString(job.expected)}`;
-				case RBDT_RESOLVE_DIRECTORY:
-					return `resolve directory ${job.path}`;
-				case RBDT_RESOLVE_CJS_FILE:
-					return `resolve commonjs file ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_RESOLVE_ESM_FILE:
-					return `resolve esm file ${job.path}${expectedToString(
-						job.expected
-					)}`;
-				case RBDT_DIRECTORY:
-					return `directory ${job.path}`;
-				case RBDT_FILE:
-					return `file ${job.path}`;
-				case RBDT_DIRECTORY_DEPENDENCIES:
-					return `directory dependencies ${job.path}`;
-				case RBDT_FILE_DEPENDENCIES:
-					return `file dependencies ${job.path}`;
-			}
-			return `unknown ${job.type} ${job.path}`;
-		};
-		const pathToString = job => {
-			let result = ` at ${jobToString(job)}`;
-			job = job.issuer;
-			while (job !== undefined) {
-				result += `\n at ${jobToString(job)}`;
-				job = job.issuer;
-			}
-			return result;
-		};
-		processAsyncTree(
-			Array.from(deps, dep => ({
-				type: RBDT_RESOLVE_CJS,
-				context,
-				path: dep,
-				expected: undefined,
-				issuer: undefined
-			})),
-			20,
-			(job, push, callback) => {
-				const { type, context, path, expected } = job;
-				const resolveDirectory = path => {
-					const key = `d\n${context}\n${path}`;
-					if (resolveResults.has(key)) {
-						return callback();
-					}
-					resolveResults.set(key, undefined);
-					resolveContext(context, path, resolverContext, (err, _, result) => {
-						if (err) {
-							if (expected === false) {
-								resolveResults.set(key, false);
-								return callback();
-							}
-							invalidResolveResults.add(key);
-							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
-							return callback(err);
-						}
-						const resultPath = result.path;
-						resolveResults.set(key, resultPath);
-						push({
-							type: RBDT_DIRECTORY,
-							context: undefined,
-							path: resultPath,
-							expected: undefined,
-							issuer: job
-						});
-						callback();
-					});
-				};
-				const resolveFile = (path, symbol, resolve) => {
-					const key = `${symbol}\n${context}\n${path}`;
-					if (resolveResults.has(key)) {
-						return callback();
-					}
-					resolveResults.set(key, undefined);
-					resolve(context, path, resolverContext, (err, _, result) => {
-						if (typeof expected === "string") {
-							if (!err && result && result.path === expected) {
-								resolveResults.set(key, result.path);
-							} else {
-								invalidResolveResults.add(key);
-								this.logger.warn(
-									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
-										err || (result && result.path)
-									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
-										job
-									)}`
-								);
-							}
-						} else {
-							if (err) {
-								if (expected === false) {
-									resolveResults.set(key, false);
-									return callback();
-								}
-								invalidResolveResults.add(key);
-								err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString(
-									job
-								)}`;
-								return callback(err);
-							}
-							const resultPath = result.path;
-							resolveResults.set(key, resultPath);
-							push({
-								type: RBDT_FILE,
-								context: undefined,
-								path: resultPath,
-								expected: undefined,
-								issuer: job
-							});
-						}
-						callback();
-					});
-				};
-				switch (type) {
-					case RBDT_RESOLVE_CJS: {
-						const isDirectory = /[\\/]$/.test(path);
-						if (isDirectory) {
-							resolveDirectory(path.slice(0, path.length - 1));
-						} else {
-							resolveFile(path, "f", resolveCjs);
-						}
-						break;
-					}
-					case RBDT_RESOLVE_ESM: {
-						const isDirectory = /[\\/]$/.test(path);
-						if (isDirectory) {
-							resolveDirectory(path.slice(0, path.length - 1));
-						} else {
-							resolveFile(path);
-						}
-						break;
-					}
-					case RBDT_RESOLVE_DIRECTORY: {
-						resolveDirectory(path);
-						break;
-					}
-					case RBDT_RESOLVE_CJS_FILE: {
-						resolveFile(path, "f", resolveCjs);
-						break;
-					}
-					case RBDT_RESOLVE_CJS_FILE_AS_CHILD: {
-						resolveFile(path, "c", resolveCjsAsChild);
-						break;
-					}
-					case RBDT_RESOLVE_ESM_FILE: {
-						resolveFile(path, "e", resolveEsm);
-						break;
-					}
-					case RBDT_FILE: {
-						if (files.has(path)) {
-							callback();
-							break;
-						}
-						files.add(path);
-						this.fs.realpath(path, (err, _realPath) => {
-							if (err) return callback(err);
-							const realPath = /** @type {string} */ (_realPath);
-							if (realPath !== path) {
-								fileSymlinks.add(path);
-								resolveFiles.add(path);
-								if (files.has(realPath)) return callback();
-								files.add(realPath);
-							}
-							push({
-								type: RBDT_FILE_DEPENDENCIES,
-								context: undefined,
-								path: realPath,
-								expected: undefined,
-								issuer: job
-							});
-							callback();
-						});
-						break;
-					}
-					case RBDT_DIRECTORY: {
-						if (directories.has(path)) {
-							callback();
-							break;
-						}
-						directories.add(path);
-						this.fs.realpath(path, (err, _realPath) => {
-							if (err) return callback(err);
-							const realPath = /** @type {string} */ (_realPath);
-							if (realPath !== path) {
-								directorySymlinks.add(path);
-								resolveFiles.add(path);
-								if (directories.has(realPath)) return callback();
-								directories.add(realPath);
-							}
-							push({
-								type: RBDT_DIRECTORY_DEPENDENCIES,
-								context: undefined,
-								path: realPath,
-								expected: undefined,
-								issuer: job
-							});
-							callback();
-						});
-						break;
-					}
-					case RBDT_FILE_DEPENDENCIES: {
-						// Check for known files without dependencies
-						if (/\.json5?$|\.yarn-integrity$|yarn\.lock$|\.ya?ml/.test(path)) {
-							process.nextTick(callback);
-							break;
-						}
-						// Check commonjs cache for the module
-						/** @type {NodeModule} */
-						const module = require.cache[path];
-						if (module && Array.isArray(module.children)) {
-							children: for (const child of module.children) {
-								let childPath = child.filename;
-								if (childPath) {
-									push({
-										type: RBDT_FILE,
-										context: undefined,
-										path: childPath,
-										expected: undefined,
-										issuer: job
-									});
-									const context = dirname(this.fs, path);
-									for (const modulePath of module.paths) {
-										if (childPath.startsWith(modulePath)) {
-											let subPath = childPath.slice(modulePath.length + 1);
-											const packageMatch = /^(@[^\\/]+[\\/])[^\\/]+/.exec(
-												subPath
-											);
-											if (packageMatch) {
-												push({
-													type: RBDT_FILE,
-													context: undefined,
-													path:
-														modulePath +
-														childPath[modulePath.length] +
-														packageMatch[0] +
-														childPath[modulePath.length] +
-														"package.json",
-													expected: false,
-													issuer: job
-												});
-											}
-											let request = subPath.replace(/\\/g, "/");
-											if (request.endsWith(".js"))
-												request = request.slice(0, -3);
-											push({
-												type: RBDT_RESOLVE_CJS_FILE_AS_CHILD,
-												context,
-												path: request,
-												expected: child.filename,
-												issuer: job
-											});
-											continue children;
-										}
-									}
-									let request = relative(this.fs, context, childPath);
-									if (request.endsWith(".js")) request = request.slice(0, -3);
-									request = request.replace(/\\/g, "/");
-									if (!request.startsWith("../")) request = `./${request}`;
-									push({
-										type: RBDT_RESOLVE_CJS_FILE,
-										context,
-										path: request,
-										expected: child.filename,
-										issuer: job
-									});
-								}
-							}
-						} else if (supportsEsm && /\.m?js$/.test(path)) {
-							if (!this._warnAboutExperimentalEsmTracking) {
-								this.logger.log(
-									"Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" +
-										"Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" +
-										"As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking."
-								);
-								this._warnAboutExperimentalEsmTracking = true;
-							}
-							const lexer = __webpack_require__(54392);
-							lexer.init.then(() => {
-								this.fs.readFile(path, (err, content) => {
-									if (err) return callback(err);
-									try {
-										const context = dirname(this.fs, path);
-										const source = content.toString();
-										const [imports] = lexer.parse(source);
-										for (const imp of imports) {
-											try {
-												let dependency;
-												if (imp.d === -1) {
-													// import ... from "..."
-													dependency = parseString(
-														source.substring(imp.s - 1, imp.e + 1)
-													);
-												} else if (imp.d > -1) {
-													// import()
-													let expr = source.substring(imp.s, imp.e).trim();
-													dependency = parseString(expr);
-												} else {
-													// e.g. import.meta
-													continue;
-												}
-												push({
-													type: RBDT_RESOLVE_ESM_FILE,
-													context,
-													path: dependency,
-													expected: undefined,
-													issuer: job
-												});
-											} catch (e) {
-												this.logger.warn(
-													`Parsing of ${path} for build dependencies failed at 'import(${source.substring(
-														imp.s,
-														imp.e
-													)})'.\n` +
-														"Build dependencies behind this expression are ignored and might cause incorrect cache invalidation."
-												);
-												this.logger.debug(pathToString(job));
-												this.logger.debug(e.stack);
-											}
-										}
-									} catch (e) {
-										this.logger.warn(
-											`Parsing of ${path} for build dependencies failed and all dependencies of this file are ignored, which might cause incorrect cache invalidation..`
-										);
-										this.logger.debug(pathToString(job));
-										this.logger.debug(e.stack);
-									}
-									process.nextTick(callback);
-								});
-							}, callback);
-							break;
-						} else {
-							this.logger.log(
-								`Assuming ${path} has no dependencies as we were unable to assign it to any module system.`
-							);
-							this.logger.debug(pathToString(job));
-						}
-						process.nextTick(callback);
-						break;
-					}
-					case RBDT_DIRECTORY_DEPENDENCIES: {
-						const match =
-							/(^.+[\\/]node_modules[\\/](?:@[^\\/]+[\\/])?[^\\/]+)/.exec(path);
-						const packagePath = match ? match[1] : path;
-						const packageJson = join(this.fs, packagePath, "package.json");
-						this.fs.readFile(packageJson, (err, content) => {
-							if (err) {
-								if (err.code === "ENOENT") {
-									resolveMissing.add(packageJson);
-									const parent = dirname(this.fs, packagePath);
-									if (parent !== packagePath) {
-										push({
-											type: RBDT_DIRECTORY_DEPENDENCIES,
-											context: undefined,
-											path: parent,
-											expected: undefined,
-											issuer: job
-										});
-									}
-									callback();
-									return;
-								}
-								return callback(err);
-							}
-							resolveFiles.add(packageJson);
-							let packageData;
-							try {
-								packageData = JSON.parse(content.toString("utf-8"));
-							} catch (e) {
-								return callback(e);
-							}
-							const depsObject = packageData.dependencies;
-							const optionalDepsObject = packageData.optionalDependencies;
-							const allDeps = new Set();
-							const optionalDeps = new Set();
-							if (typeof depsObject === "object" && depsObject) {
-								for (const dep of Object.keys(depsObject)) {
-									allDeps.add(dep);
-								}
-							}
-							if (
-								typeof optionalDepsObject === "object" &&
-								optionalDepsObject
-							) {
-								for (const dep of Object.keys(optionalDepsObject)) {
-									allDeps.add(dep);
-									optionalDeps.add(dep);
-								}
-							}
-							for (const dep of allDeps) {
-								push({
-									type: RBDT_RESOLVE_DIRECTORY,
-									context: packagePath,
-									path: dep,
-									expected: !optionalDeps.has(dep),
-									issuer: job
-								});
-							}
-							callback();
-						});
-						break;
-					}
-				}
-			},
-			err => {
-				if (err) return callback(err);
-				for (const l of fileSymlinks) files.delete(l);
-				for (const l of directorySymlinks) directories.delete(l);
-				for (const k of invalidResolveResults) resolveResults.delete(k);
-				callback(null, {
-					files,
-					directories,
-					missing,
-					resolveResults,
-					resolveDependencies: {
-						files: resolveFiles,
-						directories: resolveDirectories,
-						missing: resolveMissing
-					}
-				});
-			}
-		);
+	markIntegrationEnd() {
+		this.integrationEndTime = Date.now();
+		this.integration = this.integrationEndTime - this.integrationStartTime;
+	}
+
+	markBuildingStart() {
+		this.buildingStartTime = Date.now();
+	}
+
+	markBuildingEnd() {
+		this.buildingEndTime = Date.now();
+		this.building = this.buildingEndTime - this.buildingStartTime;
+	}
+
+	markStoringStart() {
+		this.storingStartTime = Date.now();
 	}
 
+	markStoringEnd() {
+		this.storingEndTime = Date.now();
+		this.storing = this.storingEndTime - this.storingStartTime;
+	}
+
+	// This depends on timing so we ignore it for coverage
+	/* istanbul ignore next */
 	/**
-	 * @param {Map<string, string | false>} resolveResults results from resolving
-	 * @param {function((Error | null)=, boolean=): void} callback callback with true when resolveResults resolve the same way
+	 * Merge this profile into another one
+	 * @param {ModuleProfile} realProfile the profile to merge into
 	 * @returns {void}
 	 */
-	checkResolveResultsValid(resolveResults, callback) {
-		const { resolveCjs, resolveCjsAsChild, resolveEsm, resolveContext } =
-			this._createBuildDependenciesResolvers();
-		asyncLib.eachLimit(
-			resolveResults,
-			20,
-			([key, expectedResult], callback) => {
-				const [type, context, path] = key.split("\n");
-				switch (type) {
-					case "d":
-						resolveContext(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					case "f":
-						resolveCjs(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					case "c":
-						resolveCjsAsChild(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					case "e":
-						resolveEsm(context, path, {}, (err, _, result) => {
-							if (expectedResult === false)
-								return callback(err ? undefined : INVALID);
-							if (err) return callback(err);
-							const resultPath = result.path;
-							if (resultPath !== expectedResult) return callback(INVALID);
-							callback();
-						});
-						break;
-					default:
-						callback(new Error("Unexpected type in resolve result key"));
-						break;
-				}
-			},
-			/**
-			 * @param {Error | typeof INVALID=} err error or invalid flag
-			 * @returns {void}
-			 */
-			err => {
-				if (err === INVALID) {
-					return callback(null, false);
-				}
-				if (err) {
-					return callback(err);
-				}
-				return callback(null, true);
-			}
-		);
+	mergeInto(realProfile) {
+		realProfile.additionalFactories = this.factory;
+		(realProfile.additionalFactoryTimes =
+			realProfile.additionalFactoryTimes || []).push({
+			start: this.factoryStartTime,
+			end: this.factoryEndTime
+		});
 	}
+}
 
-	/**
-	 *
-	 * @param {number} startTime when processing the files has started
-	 * @param {Iterable<string>} files all files
-	 * @param {Iterable<string>} directories all directories
-	 * @param {Iterable<string>} missing all missing files or directories
-	 * @param {Object} options options object (for future extensions)
-	 * @param {boolean=} options.hash should use hash to snapshot
-	 * @param {boolean=} options.timestamp should use timestamp to snapshot
-	 * @param {function((WebpackError | null)=, (Snapshot | null)=): void} callback callback function
-	 * @returns {void}
-	 */
-	createSnapshot(startTime, files, directories, missing, options, callback) {
-		/** @type {Map<string, FileSystemInfoEntry | null>} */
-		const fileTimestamps = new Map();
-		/** @type {Map<string, string | null>} */
-		const fileHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string | null>} */
-		const fileTshs = new Map();
-		/** @type {Map<string, FileSystemInfoEntry | null>} */
-		const contextTimestamps = new Map();
-		/** @type {Map<string, string | null>} */
-		const contextHashes = new Map();
-		/** @type {Map<string, ResolvedContextTimestampAndHash | null>} */
-		const contextTshs = new Map();
-		/** @type {Map<string, boolean>} */
-		const missingExistence = new Map();
-		/** @type {Map<string, string>} */
-		const managedItemInfo = new Map();
-		/** @type {Set<string>} */
-		const managedFiles = new Set();
-		/** @type {Set<string>} */
-		const managedContexts = new Set();
-		/** @type {Set<string>} */
-		const managedMissing = new Set();
-		/** @type {Set<Snapshot>} */
-		const children = new Set();
+module.exports = ModuleProfile;
 
-		const snapshot = new Snapshot();
-		if (startTime) snapshot.setStartTime(startTime);
 
-		/** @type {Set<string>} */
-		const managedItems = new Set();
+/***/ }),
 
-		/** 1 = timestamp, 2 = hash, 3 = timestamp + hash */
-		const mode = options && options.hash ? (options.timestamp ? 3 : 2) : 1;
+/***/ 94560:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		let jobs = 1;
-		const jobDone = () => {
-			if (--jobs === 0) {
-				if (fileTimestamps.size !== 0) {
-					snapshot.setFileTimestamps(fileTimestamps);
-				}
-				if (fileHashes.size !== 0) {
-					snapshot.setFileHashes(fileHashes);
-				}
-				if (fileTshs.size !== 0) {
-					snapshot.setFileTshs(fileTshs);
-				}
-				if (contextTimestamps.size !== 0) {
-					snapshot.setContextTimestamps(contextTimestamps);
-				}
-				if (contextHashes.size !== 0) {
-					snapshot.setContextHashes(contextHashes);
-				}
-				if (contextTshs.size !== 0) {
-					snapshot.setContextTshs(contextTshs);
-				}
-				if (missingExistence.size !== 0) {
-					snapshot.setMissingExistence(missingExistence);
-				}
-				if (managedItemInfo.size !== 0) {
-					snapshot.setManagedItemInfo(managedItemInfo);
-				}
-				this._managedFilesOptimization.optimize(snapshot, managedFiles);
-				if (managedFiles.size !== 0) {
-					snapshot.setManagedFiles(managedFiles);
-				}
-				this._managedContextsOptimization.optimize(snapshot, managedContexts);
-				if (managedContexts.size !== 0) {
-					snapshot.setManagedContexts(managedContexts);
-				}
-				this._managedMissingOptimization.optimize(snapshot, managedMissing);
-				if (managedMissing.size !== 0) {
-					snapshot.setManagedMissing(managedMissing);
-				}
-				if (children.size !== 0) {
-					snapshot.setChildren(children);
-				}
-				this._snapshotCache.set(snapshot, true);
-				this._statCreatedSnapshots++;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				callback(null, snapshot);
-			}
-		};
-		const jobError = () => {
-			if (jobs > 0) {
-				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
-				jobs = -100000000;
-				callback(null, null);
-			}
-		};
-		const checkManaged = (path, managedSet) => {
-			for (const immutablePath of this.immutablePathsRegExps) {
-				if (immutablePath.test(path)) {
-					managedSet.add(path);
-					return true;
-				}
-			}
-			for (const immutablePath of this.immutablePathsWithSlash) {
-				if (path.startsWith(immutablePath)) {
-					managedSet.add(path);
-					return true;
-				}
-			}
-			for (const managedPath of this.managedPathsRegExps) {
-				const match = managedPath.exec(path);
-				if (match) {
-					const managedItem = getManagedItem(match[1], path);
-					if (managedItem) {
-						managedItems.add(managedItem);
-						managedSet.add(path);
-						return true;
-					}
-				}
-			}
-			for (const managedPath of this.managedPathsWithSlash) {
-				if (path.startsWith(managedPath)) {
-					const managedItem = getManagedItem(managedPath, path);
-					if (managedItem) {
-						managedItems.add(managedItem);
-						managedSet.add(path);
-						return true;
-					}
-				}
-			}
-			return false;
-		};
-		const captureNonManaged = (items, managedSet) => {
-			const capturedItems = new Set();
-			for (const path of items) {
-				if (!checkManaged(path, managedSet)) capturedItems.add(path);
-			}
-			return capturedItems;
-		};
-		const processCapturedFiles = capturedFiles => {
-			switch (mode) {
-				case 3:
-					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
-					for (const path of capturedFiles) {
-						const cache = this._fileTshs.get(path);
-						if (cache !== undefined) {
-							fileTshs.set(path, cache);
-						} else {
-							jobs++;
-							this._getFileTimestampAndHash(path, (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting file timestamp hash combination of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									fileTshs.set(path, entry);
-									jobDone();
-								}
-							});
-						}
-					}
-					break;
-				case 2:
-					this._fileHashesOptimization.optimize(snapshot, capturedFiles);
-					for (const path of capturedFiles) {
-						const cache = this._fileHashes.get(path);
-						if (cache !== undefined) {
-							fileHashes.set(path, cache);
-						} else {
-							jobs++;
-							this.fileHashQueue.add(path, (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting file hash of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									fileHashes.set(path, entry);
-									jobDone();
-								}
-							});
-						}
-					}
-					break;
-				case 1:
-					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
-					for (const path of capturedFiles) {
-						const cache = this._fileTimestamps.get(path);
-						if (cache !== undefined) {
-							if (cache !== "ignore") {
-								fileTimestamps.set(path, cache);
-							}
-						} else {
-							jobs++;
-							this.fileTimestampQueue.add(path, (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting file timestamp of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									fileTimestamps.set(path, entry);
-									jobDone();
-								}
-							});
-						}
-					}
-					break;
-			}
-		};
-		if (files) {
-			processCapturedFiles(captureNonManaged(files, managedFiles));
-		}
-		const processCapturedDirectories = capturedDirectories => {
-			switch (mode) {
-				case 3:
-					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
-					for (const path of capturedDirectories) {
-						const cache = this._contextTshs.get(path);
-						/** @type {ResolvedContextTimestampAndHash} */
-						let resolved;
-						if (
-							cache !== undefined &&
-							(resolved = getResolvedTimestamp(cache)) !== undefined
-						) {
-							contextTshs.set(path, resolved);
-						} else {
-							jobs++;
-							/**
-							 * @param {Error=} err error
-							 * @param {ResolvedContextTimestampAndHash=} entry entry
-							 * @returns {void}
-							 */
-							const callback = (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting context timestamp hash combination of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									contextTshs.set(path, entry);
-									jobDone();
-								}
-							};
-							if (cache !== undefined) {
-								this._resolveContextTsh(cache, callback);
-							} else {
-								this.getContextTsh(path, callback);
-							}
-						}
-					}
-					break;
-				case 2:
-					this._contextHashesOptimization.optimize(
-						snapshot,
-						capturedDirectories
-					);
-					for (const path of capturedDirectories) {
-						const cache = this._contextHashes.get(path);
-						let resolved;
-						if (
-							cache !== undefined &&
-							(resolved = getResolvedHash(cache)) !== undefined
-						) {
-							contextHashes.set(path, resolved);
-						} else {
-							jobs++;
-							const callback = (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting context hash of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									contextHashes.set(path, entry);
-									jobDone();
-								}
-							};
-							if (cache !== undefined) {
-								this._resolveContextHash(cache, callback);
-							} else {
-								this.getContextHash(path, callback);
-							}
-						}
-					}
-					break;
-				case 1:
-					this._contextTimestampsOptimization.optimize(
-						snapshot,
-						capturedDirectories
-					);
-					for (const path of capturedDirectories) {
-						const cache = this._contextTimestamps.get(path);
-						if (cache === "ignore") continue;
-						let resolved;
-						if (
-							cache !== undefined &&
-							(resolved = getResolvedTimestamp(cache)) !== undefined
-						) {
-							contextTimestamps.set(path, resolved);
-						} else {
-							jobs++;
-							/**
-							 * @param {Error=} err error
-							 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
-							 * @returns {void}
-							 */
-							const callback = (err, entry) => {
-								if (err) {
-									if (this.logger) {
-										this.logger.debug(
-											`Error snapshotting context timestamp of ${path}: ${err.stack}`
-										);
-									}
-									jobError();
-								} else {
-									contextTimestamps.set(path, entry);
-									jobDone();
-								}
-							};
-							if (cache !== undefined) {
-								this._resolveContextTimestamp(cache, callback);
-							} else {
-								this.getContextTimestamp(path, callback);
-							}
-						}
-					}
-					break;
-			}
-		};
-		if (directories) {
-			processCapturedDirectories(
-				captureNonManaged(directories, managedContexts)
-			);
-		}
-		const processCapturedMissing = capturedMissing => {
-			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
-			for (const path of capturedMissing) {
-				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (cache !== "ignore") {
-						missingExistence.set(path, Boolean(cache));
-					}
-				} else {
-					jobs++;
-					this.fileTimestampQueue.add(path, (err, entry) => {
-						if (err) {
-							if (this.logger) {
-								this.logger.debug(
-									`Error snapshotting missing timestamp of ${path}: ${err.stack}`
-								);
-							}
-							jobError();
-						} else {
-							missingExistence.set(path, Boolean(entry));
-							jobDone();
-						}
-					});
-				}
-			}
-		};
-		if (missing) {
-			processCapturedMissing(captureNonManaged(missing, managedMissing));
-		}
-		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
-		for (const path of managedItems) {
-			const cache = this._managedItems.get(path);
-			if (cache !== undefined) {
-				if (!cache.startsWith("*")) {
-					managedFiles.add(join(this.fs, path, "package.json"));
-				} else if (cache === "*nested") {
-					managedMissing.add(join(this.fs, path, "package.json"));
-				}
-				managedItemInfo.set(path, cache);
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Module")} Module */
+
+class ModuleRestoreError extends WebpackError {
+	/**
+	 * @param {Module} module module tied to dependency
+	 * @param {string | Error} err error thrown
+	 */
+	constructor(module, err) {
+		let message = "Module restore failed: ";
+		let details = undefined;
+		if (err !== null && typeof err === "object") {
+			if (typeof err.stack === "string" && err.stack) {
+				const stack = err.stack;
+				message += stack;
+			} else if (typeof err.message === "string" && err.message) {
+				message += err.message;
 			} else {
-				jobs++;
-				this.managedItemQueue.add(path, (err, entry) => {
-					if (err) {
-						if (this.logger) {
-							this.logger.debug(
-								`Error snapshotting managed item ${path}: ${err.stack}`
-							);
-						}
-						jobError();
-					} else if (entry) {
-						if (!entry.startsWith("*")) {
-							managedFiles.add(join(this.fs, path, "package.json"));
-						} else if (cache === "*nested") {
-							managedMissing.add(join(this.fs, path, "package.json"));
-						}
-						managedItemInfo.set(path, entry);
-						jobDone();
-					} else {
-						// Fallback to normal snapshotting
-						const process = (set, fn) => {
-							if (set.size === 0) return;
-							const captured = new Set();
-							for (const file of set) {
-								if (file.startsWith(path)) captured.add(file);
-							}
-							if (captured.size > 0) fn(captured);
-						};
-						process(managedFiles, processCapturedFiles);
-						process(managedContexts, processCapturedDirectories);
-						process(managedMissing, processCapturedMissing);
-						jobDone();
-					}
-				});
+				message += err;
 			}
+		} else {
+			message += String(err);
 		}
-		jobDone();
+
+		super(message);
+
+		this.name = "ModuleRestoreError";
+		this.details = details;
+		this.module = module;
+		this.error = err;
 	}
+}
+
+module.exports = ModuleRestoreError;
+
+
+/***/ }),
 
+/***/ 59001:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Module")} Module */
+
+class ModuleStoreError extends WebpackError {
 	/**
-	 * @param {Snapshot} snapshot1 a snapshot
-	 * @param {Snapshot} snapshot2 a snapshot
-	 * @returns {Snapshot} merged snapshot
+	 * @param {Module} module module tied to dependency
+	 * @param {string | Error} err error thrown
 	 */
-	mergeSnapshots(snapshot1, snapshot2) {
-		const snapshot = new Snapshot();
-		if (snapshot1.hasStartTime() && snapshot2.hasStartTime())
-			snapshot.setStartTime(Math.min(snapshot1.startTime, snapshot2.startTime));
-		else if (snapshot2.hasStartTime()) snapshot.startTime = snapshot2.startTime;
-		else if (snapshot1.hasStartTime()) snapshot.startTime = snapshot1.startTime;
-		if (snapshot1.hasFileTimestamps() || snapshot2.hasFileTimestamps()) {
-			snapshot.setFileTimestamps(
-				mergeMaps(snapshot1.fileTimestamps, snapshot2.fileTimestamps)
-			);
-		}
-		if (snapshot1.hasFileHashes() || snapshot2.hasFileHashes()) {
-			snapshot.setFileHashes(
-				mergeMaps(snapshot1.fileHashes, snapshot2.fileHashes)
-			);
-		}
-		if (snapshot1.hasFileTshs() || snapshot2.hasFileTshs()) {
-			snapshot.setFileTshs(mergeMaps(snapshot1.fileTshs, snapshot2.fileTshs));
-		}
-		if (snapshot1.hasContextTimestamps() || snapshot2.hasContextTimestamps()) {
-			snapshot.setContextTimestamps(
-				mergeMaps(snapshot1.contextTimestamps, snapshot2.contextTimestamps)
-			);
-		}
-		if (snapshot1.hasContextHashes() || snapshot2.hasContextHashes()) {
-			snapshot.setContextHashes(
-				mergeMaps(snapshot1.contextHashes, snapshot2.contextHashes)
-			);
+	constructor(module, err) {
+		let message = "Module storing failed: ";
+		let details = undefined;
+		if (err !== null && typeof err === "object") {
+			if (typeof err.stack === "string" && err.stack) {
+				const stack = err.stack;
+				message += stack;
+			} else if (typeof err.message === "string" && err.message) {
+				message += err.message;
+			} else {
+				message += err;
+			}
+		} else {
+			message += String(err);
 		}
-		if (snapshot1.hasContextTshs() || snapshot2.hasContextTshs()) {
-			snapshot.setContextTshs(
-				mergeMaps(snapshot1.contextTshs, snapshot2.contextTshs)
-			);
+
+		super(message);
+
+		this.name = "ModuleStoreError";
+		this.details = details;
+		this.module = module;
+		this.error = err;
+	}
+}
+
+module.exports = ModuleStoreError;
+
+
+/***/ }),
+
+/***/ 62677:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./util/Hash")} Hash */
+
+const getJavascriptModulesPlugin = memoize(() =>
+	__webpack_require__(89464)
+);
+
+// TODO webpack 6: remove this class
+class ModuleTemplate {
+	/**
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {Compilation} compilation the compilation
+	 */
+	constructor(runtimeTemplate, compilation) {
+		this._runtimeTemplate = runtimeTemplate;
+		this.type = "javascript";
+		this.hooks = Object.freeze({
+			content: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModuleContent.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
+					"DEP_MODULE_TEMPLATE_CONTENT"
+				)
+			},
+			module: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModuleContent.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
+					"DEP_MODULE_TEMPLATE_MODULE"
+				)
+			},
+			render: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModuleContainer.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)",
+					"DEP_MODULE_TEMPLATE_RENDER"
+				)
+			},
+			package: {
+				tap: util.deprecate(
+					(options, fn) => {
+						getJavascriptModulesPlugin()
+							.getCompilationHooks(compilation)
+							.renderModulePackage.tap(
+								options,
+								(source, module, renderContext) =>
+									fn(
+										source,
+										module,
+										renderContext,
+										renderContext.dependencyTemplates
+									)
+							);
+					},
+					"ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)",
+					"DEP_MODULE_TEMPLATE_PACKAGE"
+				)
+			},
+			hash: {
+				tap: util.deprecate(
+					(options, fn) => {
+						compilation.hooks.fullHash.tap(options, fn);
+					},
+					"ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
+					"DEP_MODULE_TEMPLATE_HASH"
+				)
+			}
+		});
+	}
+}
+
+Object.defineProperty(ModuleTemplate.prototype, "runtimeTemplate", {
+	get: util.deprecate(
+		/**
+		 * @this {ModuleTemplate}
+		 * @returns {TODO} output options
+		 */
+		function () {
+			return this._runtimeTemplate;
+		},
+		"ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)",
+		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
+	)
+});
+
+module.exports = ModuleTemplate;
+
+
+/***/ }),
+
+/***/ 11234:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { cleanUp } = __webpack_require__(59985);
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+class ModuleWarning extends WebpackError {
+	/**
+	 * @param {Error} warning error thrown
+	 * @param {{from?: string|null}} info additional info
+	 */
+	constructor(warning, { from = null } = {}) {
+		let message = "Module Warning";
+
+		if (from) {
+			message += ` (from ${from}):\n`;
+		} else {
+			message += ": ";
 		}
-		if (snapshot1.hasMissingExistence() || snapshot2.hasMissingExistence()) {
-			snapshot.setMissingExistence(
-				mergeMaps(snapshot1.missingExistence, snapshot2.missingExistence)
-			);
+
+		if (warning && typeof warning === "object" && warning.message) {
+			message += warning.message;
+		} else if (warning) {
+			message += String(warning);
 		}
-		if (snapshot1.hasManagedItemInfo() || snapshot2.hasManagedItemInfo()) {
-			snapshot.setManagedItemInfo(
-				mergeMaps(snapshot1.managedItemInfo, snapshot2.managedItemInfo)
-			);
+
+		super(message);
+
+		this.name = "ModuleWarning";
+		this.warning = warning;
+		this.details =
+			warning && typeof warning === "object" && warning.stack
+				? cleanUp(warning.stack, this.message)
+				: undefined;
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.warning);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.warning = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(ModuleWarning, "webpack/lib/ModuleWarning");
+
+module.exports = ModuleWarning;
+
+
+/***/ }),
+
+/***/ 33370:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const asyncLib = __webpack_require__(78175);
+const { SyncHook, MultiHook } = __webpack_require__(6967);
+
+const ConcurrentCompilationError = __webpack_require__(95735);
+const MultiStats = __webpack_require__(24170);
+const MultiWatching = __webpack_require__(81128);
+const ArrayQueue = __webpack_require__(41792);
+
+/** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
+/** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Stats")} Stats */
+/** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
+
+/**
+ * @callback RunWithDependenciesHandler
+ * @param {Compiler} compiler
+ * @param {Callback<MultiStats>} callback
+ */
+
+/**
+ * @typedef {Object} MultiCompilerOptions
+ * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
+ */
+
+module.exports = class MultiCompiler {
+	/**
+	 * @param {Compiler[] | Record<string, Compiler>} compilers child compilers
+	 * @param {MultiCompilerOptions} options options
+	 */
+	constructor(compilers, options) {
+		if (!Array.isArray(compilers)) {
+			compilers = Object.keys(compilers).map(name => {
+				compilers[name].name = name;
+				return compilers[name];
+			});
 		}
-		if (snapshot1.hasManagedFiles() || snapshot2.hasManagedFiles()) {
-			snapshot.setManagedFiles(
-				mergeSets(snapshot1.managedFiles, snapshot2.managedFiles)
-			);
+
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[MultiStats]>} */
+			done: new SyncHook(["stats"]),
+			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
+			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
+			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
+			run: new MultiHook(compilers.map(c => c.hooks.run)),
+			/** @type {SyncHook<[]>} */
+			watchClose: new SyncHook([]),
+			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
+			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
+			/** @type {MultiHook<SyncBailHook<[string, string, any[]], true>>} */
+			infrastructureLog: new MultiHook(
+				compilers.map(c => c.hooks.infrastructureLog)
+			)
+		});
+		this.compilers = compilers;
+		/** @type {MultiCompilerOptions} */
+		this._options = {
+			parallelism: options.parallelism || Infinity
+		};
+		/** @type {WeakMap<Compiler, string[]>} */
+		this.dependencies = new WeakMap();
+		this.running = false;
+
+		/** @type {Stats[]} */
+		const compilerStats = this.compilers.map(() => null);
+		let doneCompilers = 0;
+		for (let index = 0; index < this.compilers.length; index++) {
+			const compiler = this.compilers[index];
+			const compilerIndex = index;
+			let compilerDone = false;
+			compiler.hooks.done.tap("MultiCompiler", stats => {
+				if (!compilerDone) {
+					compilerDone = true;
+					doneCompilers++;
+				}
+				compilerStats[compilerIndex] = stats;
+				if (doneCompilers === this.compilers.length) {
+					this.hooks.done.call(new MultiStats(compilerStats));
+				}
+			});
+			compiler.hooks.invalid.tap("MultiCompiler", () => {
+				if (compilerDone) {
+					compilerDone = false;
+					doneCompilers--;
+				}
+			});
 		}
-		if (snapshot1.hasManagedContexts() || snapshot2.hasManagedContexts()) {
-			snapshot.setManagedContexts(
-				mergeSets(snapshot1.managedContexts, snapshot2.managedContexts)
-			);
+	}
+
+	get options() {
+		return Object.assign(
+			this.compilers.map(c => c.options),
+			this._options
+		);
+	}
+
+	get outputPath() {
+		let commonPath = this.compilers[0].outputPath;
+		for (const compiler of this.compilers) {
+			while (
+				compiler.outputPath.indexOf(commonPath) !== 0 &&
+				/[/\\]/.test(commonPath)
+			) {
+				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
+			}
 		}
-		if (snapshot1.hasManagedMissing() || snapshot2.hasManagedMissing()) {
-			snapshot.setManagedMissing(
-				mergeSets(snapshot1.managedMissing, snapshot2.managedMissing)
-			);
+
+		if (!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
+		return commonPath;
+	}
+
+	get inputFileSystem() {
+		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
+	}
+
+	get outputFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
+
+	get watchFileSystem() {
+		throw new Error("Cannot read watchFileSystem of a MultiCompiler");
+	}
+
+	get intermediateFileSystem() {
+		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
+	}
+
+	/**
+	 * @param {InputFileSystem} value the new input file system
+	 */
+	set inputFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.inputFileSystem = value;
 		}
-		if (snapshot1.hasChildren() || snapshot2.hasChildren()) {
-			snapshot.setChildren(mergeSets(snapshot1.children, snapshot2.children));
+	}
+
+	/**
+	 * @param {OutputFileSystem} value the new output file system
+	 */
+	set outputFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.outputFileSystem = value;
 		}
-		if (
-			this._snapshotCache.get(snapshot1) === true &&
-			this._snapshotCache.get(snapshot2) === true
-		) {
-			this._snapshotCache.set(snapshot, true);
+	}
+
+	/**
+	 * @param {WatchFileSystem} value the new watch file system
+	 */
+	set watchFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.watchFileSystem = value;
 		}
-		return snapshot;
 	}
 
 	/**
-	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
-	 * @returns {void}
+	 * @param {IntermediateFileSystem} value the new intermediate file system
 	 */
-	checkSnapshotValid(snapshot, callback) {
-		const cachedResult = this._snapshotCache.get(snapshot);
-		if (cachedResult !== undefined) {
-			this._statTestedSnapshotsCached++;
-			if (typeof cachedResult === "boolean") {
-				callback(null, cachedResult);
-			} else {
-				cachedResult.push(callback);
-			}
-			return;
+	set intermediateFileSystem(value) {
+		for (const compiler of this.compilers) {
+			compiler.intermediateFileSystem = value;
 		}
-		this._statTestedSnapshotsNotCached++;
-		this._checkSnapshotValidNoCache(snapshot, callback);
+	}
+
+	getInfrastructureLogger(name) {
+		return this.compilers[0].getInfrastructureLogger(name);
 	}
 
 	/**
-	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
+	 * @param {Compiler} compiler the child compiler
+	 * @param {string[]} dependencies its dependencies
 	 * @returns {void}
 	 */
-	_checkSnapshotValidNoCache(snapshot, callback) {
-		/** @type {number | undefined} */
-		let startTime = undefined;
-		if (snapshot.hasStartTime()) {
-			startTime = snapshot.startTime;
-		}
-		let jobs = 1;
-		const jobDone = () => {
-			if (--jobs === 0) {
-				this._snapshotCache.set(snapshot, true);
-				callback(null, true);
+	setDependencies(compiler, dependencies) {
+		this.dependencies.set(compiler, dependencies);
+	}
+
+	/**
+	 * @param {Callback<MultiStats>} callback signals when the validation is complete
+	 * @returns {boolean} true if the dependencies are valid
+	 */
+	validateDependencies(callback) {
+		/** @type {Set<{source: Compiler, target: Compiler}>} */
+		const edges = new Set();
+		/** @type {string[]} */
+		const missing = [];
+		const targetFound = compiler => {
+			for (const edge of edges) {
+				if (edge.target === compiler) {
+					return true;
+				}
 			}
+			return false;
 		};
-		const invalid = () => {
-			if (jobs > 0) {
-				// large negative number instead of NaN or something else to keep jobs to stay a SMI (v8)
-				jobs = -100000000;
-				this._snapshotCache.set(snapshot, false);
-				callback(null, false);
-			}
+		const sortEdges = (e1, e2) => {
+			return (
+				e1.source.name.localeCompare(e2.source.name) ||
+				e1.target.name.localeCompare(e2.target.name)
+			);
 		};
-		const invalidWithError = (path, err) => {
-			if (this._remainingLogs > 0) {
-				this._log(path, `error occurred: %s`, err);
+		for (const source of this.compilers) {
+			const dependencies = this.dependencies.get(source);
+			if (dependencies) {
+				for (const dep of dependencies) {
+					const target = this.compilers.find(c => c.name === dep);
+					if (!target) {
+						missing.push(dep);
+					} else {
+						edges.add({
+							source,
+							target
+						});
+					}
+				}
 			}
-			invalid();
+		}
+		/** @type {string[]} */
+		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
+		const stack = this.compilers.filter(c => !targetFound(c));
+		while (stack.length > 0) {
+			const current = stack.pop();
+			for (const edge of edges) {
+				if (edge.source === current) {
+					edges.delete(edge);
+					const target = edge.target;
+					if (!targetFound(target)) {
+						stack.push(target);
+					}
+				}
+			}
+		}
+		if (edges.size > 0) {
+			/** @type {string[]} */
+			const lines = Array.from(edges)
+				.sort(sortEdges)
+				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
+			lines.unshift("Circular dependency found in compiler dependencies.");
+			errors.unshift(lines.join("\n"));
+		}
+		if (errors.length > 0) {
+			const message = errors.join("\n");
+			callback(new Error(message));
+			return false;
+		}
+		return true;
+	}
+
+	// TODO webpack 6 remove
+	/**
+	 * @deprecated This method should have been private
+	 * @param {Compiler[]} compilers the child compilers
+	 * @param {RunWithDependenciesHandler} fn a handler to run for each compiler
+	 * @param {Callback<MultiStats>} callback the compiler's handler
+	 * @returns {void}
+	 */
+	runWithDependencies(compilers, fn, callback) {
+		const fulfilledNames = new Set();
+		let remainingCompilers = compilers;
+		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		const getReadyCompilers = () => {
+			let readyCompilers = [];
+			let list = remainingCompilers;
+			remainingCompilers = [];
+			for (const c of list) {
+				const dependencies = this.dependencies.get(c);
+				const ready =
+					!dependencies || dependencies.every(isDependencyFulfilled);
+				if (ready) {
+					readyCompilers.push(c);
+				} else {
+					remainingCompilers.push(c);
+				}
+			}
+			return readyCompilers;
+		};
+		const runCompilers = callback => {
+			if (remainingCompilers.length === 0) return callback();
+			asyncLib.map(
+				getReadyCompilers(),
+				(compiler, callback) => {
+					fn(compiler, err => {
+						if (err) return callback(err);
+						fulfilledNames.add(compiler.name);
+						runCompilers(callback);
+					});
+				},
+				callback
+			);
 		};
+		runCompilers(callback);
+	}
+
+	/**
+	 * @template SetupResult
+	 * @param {function(Compiler, number, Callback<Stats>, function(): boolean, function(): void, function(): void): SetupResult} setup setup a single compiler
+	 * @param {function(Compiler, SetupResult, Callback<Stats>): void} run run/continue a single compiler
+	 * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
+	 * @returns {SetupResult[]} result of setup
+	 */
+	_runGraph(setup, run, callback) {
+		/** @typedef {{ compiler: Compiler, setupResult: SetupResult, result: Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
+
+		// State transitions for nodes:
+		// -> blocked (initial)
+		// blocked -> starting [running++] (when all parents done)
+		// queued -> starting [running++] (when processing the queue)
+		// starting -> running (when run has been called)
+		// running -> done [running--] (when compilation is done)
+		// done -> pending (when invalidated from file change)
+		// pending -> blocked [add to queue] (when invalidated from aggregated changes)
+		// done -> blocked [add to queue] (when invalidated, from parent invalidation)
+		// running -> running-outdated (when invalidated, either from change or parent invalidation)
+		// running-outdated -> blocked [running--] (when compilation is done)
+
+		/** @type {Node[]} */
+		const nodes = this.compilers.map(compiler => ({
+			compiler,
+			setupResult: undefined,
+			result: undefined,
+			state: "blocked",
+			children: [],
+			parents: []
+		}));
+		/** @type {Map<string, Node>} */
+		const compilerToNode = new Map();
+		for (const node of nodes) compilerToNode.set(node.compiler.name, node);
+		for (const node of nodes) {
+			const dependencies = this.dependencies.get(node.compiler);
+			if (!dependencies) continue;
+			for (const dep of dependencies) {
+				const parent = compilerToNode.get(dep);
+				node.parents.push(parent);
+				parent.children.push(node);
+			}
+		}
+		/** @type {ArrayQueue<Node>} */
+		const queue = new ArrayQueue();
+		for (const node of nodes) {
+			if (node.parents.length === 0) {
+				node.state = "queued";
+				queue.enqueue(node);
+			}
+		}
+		let errored = false;
+		let running = 0;
+		const parallelism = this._options.parallelism;
 		/**
-		 * @param {string} path file path
-		 * @param {string} current current hash
-		 * @param {string} snap snapshot hash
-		 * @returns {boolean} true, if ok
+		 * @param {Node} node node
+		 * @param {Error=} err error
+		 * @param {Stats=} stats result
+		 * @returns {void}
 		 */
-		const checkHash = (path, current, snap) => {
-			if (current !== snap) {
-				// If hash differ it's invalid
-				if (this._remainingLogs > 0) {
-					this._log(path, `hashes differ (%s != %s)`, current, snap);
+		const nodeDone = (node, err, stats) => {
+			if (errored) return;
+			if (err) {
+				errored = true;
+				return asyncLib.each(
+					nodes,
+					(node, callback) => {
+						if (node.compiler.watching) {
+							node.compiler.watching.close(callback);
+						} else {
+							callback();
+						}
+					},
+					() => callback(err)
+				);
+			}
+			node.result = stats;
+			running--;
+			if (node.state === "running") {
+				node.state = "done";
+				for (const child of node.children) {
+					if (child.state === "blocked") queue.enqueue(child);
 				}
-				return false;
+			} else if (node.state === "running-outdated") {
+				node.state = "blocked";
+				queue.enqueue(node);
 			}
-			return true;
+			processQueue();
 		};
 		/**
-		 * @param {string} path file path
-		 * @param {boolean} current current entry
-		 * @param {boolean} snap entry from snapshot
-		 * @returns {boolean} true, if ok
+		 * @param {Node} node node
+		 * @returns {void}
 		 */
-		const checkExistence = (path, current, snap) => {
-			if (!current !== !snap) {
-				// If existence of item differs
-				// it's invalid
-				if (this._remainingLogs > 0) {
-					this._log(
-						path,
-						current ? "it didn't exist before" : "it does no longer exist"
-					);
-				}
-				return false;
+		const nodeInvalidFromParent = node => {
+			if (node.state === "done") {
+				node.state = "blocked";
+			} else if (node.state === "running") {
+				node.state = "running-outdated";
+			}
+			for (const child of node.children) {
+				nodeInvalidFromParent(child);
 			}
-			return true;
 		};
 		/**
-		 * @param {string} path file path
-		 * @param {FileSystemInfoEntry} current current entry
-		 * @param {FileSystemInfoEntry} snap entry from snapshot
-		 * @param {boolean} log log reason
-		 * @returns {boolean} true, if ok
+		 * @param {Node} node node
+		 * @returns {void}
 		 */
-		const checkFile = (path, current, snap, log = true) => {
-			if (current === snap) return true;
-			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
-			if (current) {
-				// For existing items only
-				if (typeof startTime === "number" && current.safeTime > startTime) {
-					// If a change happened after starting reading the item
-					// this may no longer be valid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`it may have changed (%d) after the start time of the snapshot (%d)`,
-							current.safeTime,
-							startTime
-						);
-					}
-					return false;
-				}
-				if (
-					snap.timestamp !== undefined &&
-					current.timestamp !== snap.timestamp
-				) {
-					// If we have a timestamp (it was a file or symlink) and it differs from current timestamp
-					// it's invalid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`timestamps differ (%d != %d)`,
-							current.timestamp,
-							snap.timestamp
-						);
-					}
-					return false;
-				}
+		const nodeInvalid = node => {
+			if (node.state === "done") {
+				node.state = "pending";
+			} else if (node.state === "running") {
+				node.state = "running-outdated";
+			}
+			for (const child of node.children) {
+				nodeInvalidFromParent(child);
 			}
-			return true;
 		};
 		/**
-		 * @param {string} path file path
-		 * @param {ResolvedContextFileSystemInfoEntry} current current entry
-		 * @param {ResolvedContextFileSystemInfoEntry} snap entry from snapshot
-		 * @param {boolean} log log reason
-		 * @returns {boolean} true, if ok
+		 * @param {Node} node node
+		 * @returns {void}
 		 */
-		const checkContext = (path, current, snap, log = true) => {
-			if (current === snap) return true;
-			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
-			if (current) {
-				// For existing items only
-				if (typeof startTime === "number" && current.safeTime > startTime) {
-					// If a change happened after starting reading the item
-					// this may no longer be valid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`it may have changed (%d) after the start time of the snapshot (%d)`,
-							current.safeTime,
-							startTime
-						);
-					}
-					return false;
-				}
+		const nodeChange = node => {
+			nodeInvalid(node);
+			if (node.state === "pending") {
+				node.state = "blocked";
+			}
+			if (node.state === "blocked") {
+				queue.enqueue(node);
+				processQueue();
+			}
+		};
+
+		const setupResults = [];
+		nodes.forEach((node, i) => {
+			setupResults.push(
+				(node.setupResult = setup(
+					node.compiler,
+					i,
+					nodeDone.bind(null, node),
+					() => node.state !== "starting" && node.state !== "running",
+					() => nodeChange(node),
+					() => nodeInvalid(node)
+				))
+			);
+		});
+		let processing = true;
+		const processQueue = () => {
+			if (processing) return;
+			processing = true;
+			process.nextTick(processQueueWorker);
+		};
+		const processQueueWorker = () => {
+			while (running < parallelism && queue.length > 0 && !errored) {
+				const node = queue.dequeue();
 				if (
-					snap.timestampHash !== undefined &&
-					current.timestampHash !== snap.timestampHash
+					node.state === "queued" ||
+					(node.state === "blocked" &&
+						node.parents.every(p => p.state === "done"))
 				) {
-					// If we have a timestampHash (it was a directory) and it differs from current timestampHash
-					// it's invalid
-					if (log && this._remainingLogs > 0) {
-						this._log(
-							path,
-							`timestamps hashes differ (%s != %s)`,
-							current.timestampHash,
-							snap.timestampHash
-						);
-					}
-					return false;
+					running++;
+					node.state = "starting";
+					run(node.compiler, node.setupResult, nodeDone.bind(null, node));
+					node.state = "running";
 				}
 			}
-			return true;
-		};
-		if (snapshot.hasChildren()) {
-			const childCallback = (err, result) => {
-				if (err || !result) return invalid();
-				else jobDone();
-			};
-			for (const child of snapshot.children) {
-				const cache = this._snapshotCache.get(child);
-				if (cache !== undefined) {
-					this._statTestedChildrenCached++;
-					/* istanbul ignore else */
-					if (typeof cache === "boolean") {
-						if (cache === false) {
-							invalid();
-							return;
-						}
-					} else {
-						jobs++;
-						cache.push(childCallback);
+			processing = false;
+			if (
+				!errored &&
+				running === 0 &&
+				nodes.every(node => node.state === "done")
+			) {
+				const stats = [];
+				for (const node of nodes) {
+					const result = node.result;
+					if (result) {
+						node.result = undefined;
+						stats.push(result);
 					}
-				} else {
-					this._statTestedChildrenNotCached++;
-					jobs++;
-					this._checkSnapshotValidNoCache(child, childCallback);
+				}
+				if (stats.length > 0) {
+					callback(null, new MultiStats(stats));
 				}
 			}
+		};
+		processQueueWorker();
+		return setupResults;
+	}
+
+	/**
+	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
+	 * @param {Callback<MultiStats>} handler signals when the call finishes
+	 * @returns {MultiWatching} a compiler watcher
+	 */
+	watch(watchOptions, handler) {
+		if (this.running) {
+			return handler(new ConcurrentCompilationError());
 		}
-		if (snapshot.hasFileTimestamps()) {
-			const { fileTimestamps } = snapshot;
-			this._statTestedEntries += fileTimestamps.size;
-			for (const [path, ts] of fileTimestamps) {
-				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (cache !== "ignore" && !checkFile(path, cache, ts)) {
-						invalid();
-						return;
+		this.running = true;
+
+		if (this.validateDependencies(handler)) {
+			const watchings = this._runGraph(
+				(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
+					const watching = compiler.watch(
+						Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
+						callback
+					);
+					if (watching) {
+						watching._onInvalid = setInvalid;
+						watching._onChange = setChanged;
+						watching._isBlocked = isBlocked;
+					}
+					return watching;
+				},
+				(compiler, watching, callback) => {
+					if (compiler.watching !== watching) return;
+					if (!watching.running) watching.invalidate();
+				},
+				handler
+			);
+			return new MultiWatching(watchings, this);
+		}
+
+		return new MultiWatching([], this);
+	}
+
+	/**
+	 * @param {Callback<MultiStats>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	run(callback) {
+		if (this.running) {
+			return callback(new ConcurrentCompilationError());
+		}
+		this.running = true;
+
+		if (this.validateDependencies(callback)) {
+			this._runGraph(
+				() => {},
+				(compiler, setupResult, callback) => compiler.run(callback),
+				(err, stats) => {
+					this.running = false;
+
+					if (callback !== undefined) {
+						return callback(err, stats);
 					}
-				} else {
-					jobs++;
-					this.fileTimestampQueue.add(path, (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkFile(path, entry, ts)) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					});
 				}
+			);
+		}
+	}
+
+	purgeInputFileSystem() {
+		for (const compiler of this.compilers) {
+			if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
+				compiler.inputFileSystem.purge();
 			}
 		}
-		const processFileHashSnapshot = (path, hash) => {
-			const cache = this._fileHashes.get(path);
-			if (cache !== undefined) {
-				if (cache !== "ignore" && !checkHash(path, cache, hash)) {
-					invalid();
-					return;
-				}
-			} else {
-				jobs++;
-				this.fileHashQueue.add(path, (err, entry) => {
-					if (err) return invalidWithError(path, err);
-					if (!checkHash(path, entry, hash)) {
-						invalid();
-					} else {
-						jobDone();
-					}
-				});
-			}
-		};
-		if (snapshot.hasFileHashes()) {
-			const { fileHashes } = snapshot;
-			this._statTestedEntries += fileHashes.size;
-			for (const [path, hash] of fileHashes) {
-				processFileHashSnapshot(path, hash);
-			}
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the compiler closes
+	 * @returns {void}
+	 */
+	close(callback) {
+		asyncLib.each(
+			this.compilers,
+			(compiler, callback) => {
+				compiler.close(callback);
+			},
+			callback
+		);
+	}
+};
+
+
+/***/ }),
+
+/***/ 24170:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const identifierUtils = __webpack_require__(82186);
+
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("./Stats")} Stats */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+
+const indent = (str, prefix) => {
+	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	return prefix + rem;
+};
+
+class MultiStats {
+	/**
+	 * @param {Stats[]} stats the child stats
+	 */
+	constructor(stats) {
+		this.stats = stats;
+	}
+
+	get hash() {
+		return this.stats.map(stat => stat.hash).join("");
+	}
+
+	/**
+	 * @returns {boolean} true if a child compilation encountered an error
+	 */
+	hasErrors() {
+		return this.stats.some(stat => stat.hasErrors());
+	}
+
+	/**
+	 * @returns {boolean} true if a child compilation had a warning
+	 */
+	hasWarnings() {
+		return this.stats.some(stat => stat.hasWarnings());
+	}
+
+	_createChildOptions(options, context) {
+		if (!options) {
+			options = {};
 		}
-		if (snapshot.hasFileTshs()) {
-			const { fileTshs } = snapshot;
-			this._statTestedEntries += fileTshs.size;
-			for (const [path, tsh] of fileTshs) {
-				if (typeof tsh === "string") {
-					processFileHashSnapshot(path, tsh);
-				} else {
-					const cache = this._fileTimestamps.get(path);
-					if (cache !== undefined) {
-						if (cache === "ignore" || !checkFile(path, cache, tsh, false)) {
-							processFileHashSnapshot(path, tsh && tsh.hash);
-						}
-					} else {
-						jobs++;
-						this.fileTimestampQueue.add(path, (err, entry) => {
-							if (err) return invalidWithError(path, err);
-							if (!checkFile(path, entry, tsh, false)) {
-								processFileHashSnapshot(path, tsh && tsh.hash);
-							}
-							jobDone();
-						});
-					}
-				}
-			}
+		const { children: childrenOptions = undefined, ...baseOptions } =
+			typeof options === "string" ? { preset: options } : options;
+		const children = this.stats.map((stat, idx) => {
+			const childOptions = Array.isArray(childrenOptions)
+				? childrenOptions[idx]
+				: childrenOptions;
+			return stat.compilation.createStatsOptions(
+				{
+					...baseOptions,
+					...(typeof childOptions === "string"
+						? { preset: childOptions }
+						: childOptions && typeof childOptions === "object"
+						? childOptions
+						: undefined)
+				},
+				context
+			);
+		});
+		return {
+			version: children.every(o => o.version),
+			hash: children.every(o => o.hash),
+			errorsCount: children.every(o => o.errorsCount),
+			warningsCount: children.every(o => o.warningsCount),
+			errors: children.every(o => o.errors),
+			warnings: children.every(o => o.warnings),
+			children
+		};
+	}
+
+	/**
+	 * @param {any} options stats options
+	 * @returns {StatsCompilation} json output
+	 */
+	toJson(options) {
+		options = this._createChildOptions(options, { forToString: false });
+		/** @type {KnownStatsCompilation} */
+		const obj = {};
+		obj.children = this.stats.map((stat, idx) => {
+			const obj = stat.toJson(options.children[idx]);
+			const compilationName = stat.compilation.name;
+			const name =
+				compilationName &&
+				identifierUtils.makePathsRelative(
+					options.context,
+					compilationName,
+					stat.compilation.compiler.root
+				);
+			obj.name = name;
+			return obj;
+		});
+		if (options.version) {
+			obj.version = obj.children[0].version;
 		}
-		if (snapshot.hasContextTimestamps()) {
-			const { contextTimestamps } = snapshot;
-			this._statTestedEntries += contextTimestamps.size;
-			for (const [path, ts] of contextTimestamps) {
-				const cache = this._contextTimestamps.get(path);
-				if (cache === "ignore") continue;
-				let resolved;
-				if (
-					cache !== undefined &&
-					(resolved = getResolvedTimestamp(cache)) !== undefined
-				) {
-					if (!checkContext(path, resolved, ts)) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					/**
-					 * @param {Error=} err error
-					 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
-					 * @returns {void}
-					 */
-					const callback = (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkContext(path, entry, ts)) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					};
-					if (cache !== undefined) {
-						this._resolveContextTimestamp(cache, callback);
-					} else {
-						this.getContextTimestamp(path, callback);
-					}
-				}
-			}
+		if (options.hash) {
+			obj.hash = obj.children.map(j => j.hash).join("");
 		}
-		const processContextHashSnapshot = (path, hash) => {
-			const cache = this._contextHashes.get(path);
-			let resolved;
-			if (
-				cache !== undefined &&
-				(resolved = getResolvedHash(cache)) !== undefined
-			) {
-				if (!checkHash(path, resolved, hash)) {
-					invalid();
-					return;
-				}
-			} else {
-				jobs++;
-				const callback = (err, entry) => {
-					if (err) return invalidWithError(path, err);
-					if (!checkHash(path, entry, hash)) {
-						invalid();
-					} else {
-						jobDone();
-					}
-				};
-				if (cache !== undefined) {
-					this._resolveContextHash(cache, callback);
-				} else {
-					this.getContextHash(path, callback);
-				}
-			}
+		const mapError = (j, obj) => {
+			return {
+				...obj,
+				compilerPath: obj.compilerPath
+					? `${j.name}.${obj.compilerPath}`
+					: j.name
+			};
 		};
-		if (snapshot.hasContextHashes()) {
-			const { contextHashes } = snapshot;
-			this._statTestedEntries += contextHashes.size;
-			for (const [path, hash] of contextHashes) {
-				processContextHashSnapshot(path, hash);
-			}
-		}
-		if (snapshot.hasContextTshs()) {
-			const { contextTshs } = snapshot;
-			this._statTestedEntries += contextTshs.size;
-			for (const [path, tsh] of contextTshs) {
-				if (typeof tsh === "string") {
-					processContextHashSnapshot(path, tsh);
-				} else {
-					const cache = this._contextTimestamps.get(path);
-					if (cache === "ignore") continue;
-					let resolved;
-					if (
-						cache !== undefined &&
-						(resolved = getResolvedTimestamp(cache)) !== undefined
-					) {
-						if (!checkContext(path, resolved, tsh, false)) {
-							processContextHashSnapshot(path, tsh && tsh.hash);
-						}
-					} else {
-						jobs++;
-						/**
-						 * @param {Error=} err error
-						 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
-						 * @returns {void}
-						 */
-						const callback = (err, entry) => {
-							if (err) return invalidWithError(path, err);
-							if (!checkContext(path, entry, tsh, false)) {
-								processContextHashSnapshot(path, tsh && tsh.hash);
-							}
-							jobDone();
-						};
-						if (cache !== undefined) {
-							this._resolveContextTimestamp(cache, callback);
-						} else {
-							this.getContextTimestamp(path, callback);
-						}
-					}
+		if (options.errors) {
+			obj.errors = [];
+			for (const j of obj.children) {
+				for (const i of j.errors) {
+					obj.errors.push(mapError(j, i));
 				}
 			}
 		}
-		if (snapshot.hasMissingExistence()) {
-			const { missingExistence } = snapshot;
-			this._statTestedEntries += missingExistence.size;
-			for (const [path, existence] of missingExistence) {
-				const cache = this._fileTimestamps.get(path);
-				if (cache !== undefined) {
-					if (
-						cache !== "ignore" &&
-						!checkExistence(path, Boolean(cache), Boolean(existence))
-					) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					this.fileTimestampQueue.add(path, (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkExistence(path, Boolean(entry), Boolean(existence))) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					});
+		if (options.warnings) {
+			obj.warnings = [];
+			for (const j of obj.children) {
+				for (const i of j.warnings) {
+					obj.warnings.push(mapError(j, i));
 				}
 			}
 		}
-		if (snapshot.hasManagedItemInfo()) {
-			const { managedItemInfo } = snapshot;
-			this._statTestedEntries += managedItemInfo.size;
-			for (const [path, info] of managedItemInfo) {
-				const cache = this._managedItems.get(path);
-				if (cache !== undefined) {
-					if (!checkHash(path, cache, info)) {
-						invalid();
-						return;
-					}
-				} else {
-					jobs++;
-					this.managedItemQueue.add(path, (err, entry) => {
-						if (err) return invalidWithError(path, err);
-						if (!checkHash(path, entry, info)) {
-							invalid();
-						} else {
-							jobDone();
-						}
-					});
-				}
+		if (options.errorsCount) {
+			obj.errorsCount = 0;
+			for (const j of obj.children) {
+				obj.errorsCount += j.errorsCount;
 			}
 		}
-		jobDone();
-
-		// if there was an async action
-		// try to join multiple concurrent request for this snapshot
-		if (jobs > 0) {
-			const callbacks = [callback];
-			callback = (err, result) => {
-				for (const callback of callbacks) callback(err, result);
-			};
-			this._snapshotCache.set(snapshot, callbacks);
+		if (options.warningsCount) {
+			obj.warningsCount = 0;
+			for (const j of obj.children) {
+				obj.warningsCount += j.warningsCount;
+			}
 		}
+		return obj;
 	}
 
-	_readFileTimestamp(path, callback) {
-		this.fs.stat(path, (err, stat) => {
-			if (err) {
-				if (err.code === "ENOENT") {
-					this._fileTimestamps.set(path, null);
-					this._cachedDeprecatedFileTimestamps = undefined;
-					return callback(null, null);
-				}
-				return callback(err);
-			}
+	toString(options) {
+		options = this._createChildOptions(options, { forToString: true });
+		const results = this.stats.map((stat, idx) => {
+			const str = stat.toString(options.children[idx]);
+			const compilationName = stat.compilation.name;
+			const name =
+				compilationName &&
+				identifierUtils
+					.makePathsRelative(
+						options.context,
+						compilationName,
+						stat.compilation.compiler.root
+					)
+					.replace(/\|/g, " ");
+			if (!str) return str;
+			return name ? `${name}:\n${indent(str, "  ")}` : str;
+		});
+		return results.filter(Boolean).join("\n\n");
+	}
+}
 
-			let ts;
-			if (stat.isDirectory()) {
-				ts = {
-					safeTime: 0,
-					timestamp: undefined
-				};
-			} else {
-				const mtime = +stat.mtime;
+module.exports = MultiStats;
 
-				if (mtime) applyMtime(mtime);
 
-				ts = {
-					safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
-					timestamp: mtime
-				};
-			}
+/***/ }),
 
-			this._fileTimestamps.set(path, ts);
-			this._cachedDeprecatedFileTimestamps = undefined;
+/***/ 81128:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			callback(null, ts);
-		});
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	_readFileHash(path, callback) {
-		this.fs.readFile(path, (err, content) => {
-			if (err) {
-				if (err.code === "EISDIR") {
-					this._fileHashes.set(path, "directory");
-					return callback(null, "directory");
-				}
-				if (err.code === "ENOENT") {
-					this._fileHashes.set(path, null);
-					return callback(null, null);
-				}
-				if (err.code === "ERR_FS_FILE_TOO_LARGE") {
-					this.logger.warn(`Ignoring ${path} for hashing as it's very large`);
-					this._fileHashes.set(path, "too large");
-					return callback(null, "too large");
-				}
-				return callback(err);
-			}
 
-			const hash = createHash(this._hashFunction);
 
-			hash.update(content);
+const asyncLib = __webpack_require__(78175);
 
-			const digest = /** @type {string} */ (hash.digest("hex"));
+/** @typedef {import("./MultiCompiler")} MultiCompiler */
+/** @typedef {import("./Watching")} Watching */
 
-			this._fileHashes.set(path, digest);
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
 
-			callback(null, digest);
-		});
+class MultiWatching {
+	/**
+	 * @param {Watching[]} watchings child compilers' watchers
+	 * @param {MultiCompiler} compiler the compiler
+	 */
+	constructor(watchings, compiler) {
+		this.watchings = watchings;
+		this.compiler = compiler;
 	}
 
-	_getFileTimestampAndHash(path, callback) {
-		const continueWithHash = hash => {
-			const cache = this._fileTimestamps.get(path);
-			if (cache !== undefined) {
-				if (cache !== "ignore") {
-					const result = {
-						...cache,
-						hash
-					};
-					this._fileTshs.set(path, result);
-					return callback(null, result);
-				} else {
-					this._fileTshs.set(path, hash);
-					return callback(null, hash);
-				}
-			} else {
-				this.fileTimestampQueue.add(path, (err, entry) => {
-					if (err) {
-						return callback(err);
-					}
-					const result = {
-						...entry,
-						hash
-					};
-					this._fileTshs.set(path, result);
-					return callback(null, result);
-				});
+	invalidate(callback) {
+		if (callback) {
+			asyncLib.each(
+				this.watchings,
+				(watching, callback) => watching.invalidate(callback),
+				callback
+			);
+		} else {
+			for (const watching of this.watchings) {
+				watching.invalidate();
 			}
-		};
+		}
+	}
 
-		const cache = this._fileHashes.get(path);
-		if (cache !== undefined) {
-			continueWithHash(cache);
-		} else {
-			this.fileHashQueue.add(path, (err, entry) => {
-				if (err) {
-					return callback(err);
-				}
-				continueWithHash(entry);
-			});
+	suspend() {
+		for (const watching of this.watchings) {
+			watching.suspend();
 		}
 	}
 
-	/**
-	 * @template T
-	 * @template ItemType
-	 * @param {Object} options options
-	 * @param {string} options.path path
-	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
-	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
-	 * @param {function(string, string, function(Error=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
-	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromFile called when context item is a file
-	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromDirectory called when context item is a directory
-	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
-	 * @param {function((Error | null)=, (T)=): void} callback callback
+	resume() {
+		for (const watching of this.watchings) {
+			watching.resume();
+		}
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the watcher is closed
+	 * @returns {void}
 	 */
-	_readContext(
-		{
-			path,
-			fromImmutablePath,
-			fromManagedItem,
-			fromSymlink,
-			fromFile,
-			fromDirectory,
-			reduce
-		},
-		callback
-	) {
-		this.fs.readdir(path, (err, _files) => {
-			if (err) {
-				if (err.code === "ENOENT") {
-					return callback(null, null);
+	close(callback) {
+		asyncLib.forEach(
+			this.watchings,
+			(watching, finishedCallback) => {
+				watching.close(finishedCallback);
+			},
+			err => {
+				this.compiler.hooks.watchClose.call();
+				if (typeof callback === "function") {
+					this.compiler.running = false;
+					callback(err);
 				}
-				return callback(err);
 			}
-			const files = /** @type {string[]} */ (_files)
-				.map(file => file.normalize("NFC"))
-				.filter(file => !/^\./.test(file))
-				.sort();
-			asyncLib.map(
-				files,
-				(file, callback) => {
-					const child = join(this.fs, path, file);
-					for (const immutablePath of this.immutablePathsRegExps) {
-						if (immutablePath.test(path)) {
-							// ignore any immutable path for timestamping
-							return callback(null, fromImmutablePath(path));
-						}
-					}
-					for (const immutablePath of this.immutablePathsWithSlash) {
-						if (path.startsWith(immutablePath)) {
-							// ignore any immutable path for timestamping
-							return callback(null, fromImmutablePath(path));
-						}
-					}
-					for (const managedPath of this.managedPathsRegExps) {
-						const match = managedPath.exec(path);
-						if (match) {
-							const managedItem = getManagedItem(match[1], path);
-							if (managedItem) {
-								// construct timestampHash from managed info
-								return this.managedItemQueue.add(managedItem, (err, info) => {
-									if (err) return callback(err);
-									return callback(null, fromManagedItem(info));
-								});
-							}
-						}
-					}
-					for (const managedPath of this.managedPathsWithSlash) {
-						if (path.startsWith(managedPath)) {
-							const managedItem = getManagedItem(managedPath, child);
-							if (managedItem) {
-								// construct timestampHash from managed info
-								return this.managedItemQueue.add(managedItem, (err, info) => {
-									if (err) return callback(err);
-									return callback(null, fromManagedItem(info));
-								});
-							}
-						}
-					}
+		);
+	}
+}
 
-					lstatReadlinkAbsolute(this.fs, child, (err, stat) => {
-						if (err) return callback(err);
+module.exports = MultiWatching;
 
-						if (typeof stat === "string") {
-							return fromSymlink(child, stat, callback);
-						}
 
-						if (stat.isFile()) {
-							return fromFile(child, stat, callback);
-						}
-						if (stat.isDirectory()) {
-							return fromDirectory(child, stat, callback);
-						}
-						callback(null, null);
-					});
-				},
-				(err, results) => {
-					if (err) return callback(err);
-					const result = reduce(files, results);
-					callback(null, result);
-				}
-			);
+/***/ }),
+
+/***/ 50169:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./Compiler")} Compiler */
+
+class NoEmitOnErrorsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.shouldEmit.tap("NoEmitOnErrorsPlugin", compilation => {
+			if (compilation.getStats().hasErrors()) return false;
+		});
+		compiler.hooks.compilation.tap("NoEmitOnErrorsPlugin", compilation => {
+			compilation.hooks.shouldRecord.tap("NoEmitOnErrorsPlugin", () => {
+				if (compilation.getStats().hasErrors()) return false;
+			});
 		});
 	}
+}
 
-	_readContextTimestamp(path, callback) {
-		this._readContext(
-			{
-				path,
-				fromImmutablePath: () => null,
-				fromManagedItem: info => ({
-					safeTime: 0,
-					timestampHash: info
-				}),
-				fromSymlink: (file, target, callback) => {
-					callback(null, {
-						timestampHash: target,
-						symlinks: new Set([target])
-					});
-				},
-				fromFile: (file, stat, callback) => {
-					// Prefer the cached value over our new stat to report consistent results
-					const cache = this._fileTimestamps.get(file);
-					if (cache !== undefined)
-						return callback(null, cache === "ignore" ? null : cache);
+module.exports = NoEmitOnErrorsPlugin;
 
-					const mtime = +stat.mtime;
 
-					if (mtime) applyMtime(mtime);
+/***/ }),
 
-					const ts = {
-						safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
-						timestamp: mtime
-					};
+/***/ 80832:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					this._fileTimestamps.set(file, ts);
-					this._cachedDeprecatedFileTimestamps = undefined;
-					callback(null, ts);
-				},
-				fromDirectory: (directory, stat, callback) => {
-					this.contextTimestampQueue.increaseParallelism();
-					this._getUnresolvedContextTimestamp(directory, (err, tsEntry) => {
-						this.contextTimestampQueue.decreaseParallelism();
-						callback(err, tsEntry);
-					});
-				},
-				reduce: (files, tsEntries) => {
-					let symlinks = undefined;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					const hash = createHash(this._hashFunction);
 
-					for (const file of files) hash.update(file);
-					let safeTime = 0;
-					for (const entry of tsEntries) {
-						if (!entry) {
-							hash.update("n");
-							continue;
-						}
-						if (entry.timestamp) {
-							hash.update("f");
-							hash.update(`${entry.timestamp}`);
-						} else if (entry.timestampHash) {
-							hash.update("d");
-							hash.update(`${entry.timestampHash}`);
-						}
-						if (entry.symlinks !== undefined) {
-							if (symlinks === undefined) symlinks = new Set();
-							addAll(entry.symlinks, symlinks);
-						}
-						if (entry.safeTime) {
-							safeTime = Math.max(safeTime, entry.safeTime);
-						}
-					}
 
-					const digest = /** @type {string} */ (hash.digest("hex"));
+const WebpackError = __webpack_require__(53799);
 
-					const result = {
-						safeTime,
-						timestampHash: digest
-					};
-					if (symlinks) result.symlinks = symlinks;
-					return result;
-				}
-			},
-			(err, result) => {
-				if (err) return callback(err);
-				this._contextTimestamps.set(path, result);
-				this._cachedDeprecatedContextTimestamps = undefined;
+module.exports = class NoModeWarning extends WebpackError {
+	constructor() {
+		super();
 
-				callback(null, result);
-			}
-		);
+		this.name = "NoModeWarning";
+		this.message =
+			"configuration\n" +
+			"The 'mode' option has not been set, webpack will fallback to 'production' for this value.\n" +
+			"Set 'mode' option to 'development' or 'production' to enable defaults for each environment.\n" +
+			"You can also set it to 'none' to disable any default behavior. " +
+			"Learn more: https://webpack.js.org/configuration/mode/";
 	}
+};
+
+
+/***/ }),
+
+/***/ 6325:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
+
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+
+class NodeStuffInWebError extends WebpackError {
 	/**
-	 * @param {ContextFileSystemInfoEntry} entry entry
-	 * @param {function((Error | null)=, ResolvedContextFileSystemInfoEntry=): void} callback callback
-	 * @returns {void}
+	 * @param {DependencyLocation} loc loc
+	 * @param {string} expression expression
+	 * @param {string} description description
 	 */
-	_resolveContextTimestamp(entry, callback) {
-		const hashes = [];
-		let safeTime = 0;
-		processAsyncTree(
-			entry.symlinks,
-			10,
-			(target, push, callback) => {
-				this._getUnresolvedContextTimestamp(target, (err, entry) => {
-					if (err) return callback(err);
-					if (entry && entry !== "ignore") {
-						hashes.push(entry.timestampHash);
-						if (entry.safeTime) {
-							safeTime = Math.max(safeTime, entry.safeTime);
-						}
-						if (entry.symlinks !== undefined) {
-							for (const target of entry.symlinks) push(target);
-						}
-					}
-					callback();
-				});
-			},
-			err => {
-				if (err) return callback(err);
-				const hash = createHash(this._hashFunction);
-				hash.update(entry.timestampHash);
-				if (entry.safeTime) {
-					safeTime = Math.max(safeTime, entry.safeTime);
-				}
-				hashes.sort();
-				for (const h of hashes) {
-					hash.update(h);
-				}
-				callback(
-					null,
-					(entry.resolved = {
-						safeTime,
-						timestampHash: /** @type {string} */ (hash.digest("hex"))
-					})
-				);
-			}
+	constructor(loc, expression, description) {
+		super(
+			`${JSON.stringify(
+				expression
+			)} has been used, it will be undefined in next major version.
+${description}`
 		);
+
+		this.name = "NodeStuffInWebError";
+		this.loc = loc;
 	}
+}
 
-	_readContextHash(path, callback) {
-		this._readContext(
-			{
-				path,
-				fromImmutablePath: () => "",
-				fromManagedItem: info => info || "",
-				fromSymlink: (file, target, callback) => {
-					callback(null, {
-						hash: target,
-						symlinks: new Set([target])
-					});
-				},
-				fromFile: (file, stat, callback) =>
-					this.getFileHash(file, (err, hash) => {
-						callback(err, hash || "");
-					}),
-				fromDirectory: (directory, stat, callback) => {
-					this.contextHashQueue.increaseParallelism();
-					this._getUnresolvedContextHash(directory, (err, hash) => {
-						this.contextHashQueue.decreaseParallelism();
-						callback(err, hash || "");
-					});
-				},
-				/**
-				 * @param {string[]} files files
-				 * @param {(string | ContextHash)[]} fileHashes hashes
-				 * @returns {ContextHash} reduced hash
-				 */
-				reduce: (files, fileHashes) => {
-					let symlinks = undefined;
-					const hash = createHash(this._hashFunction);
+makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
 
-					for (const file of files) hash.update(file);
-					for (const entry of fileHashes) {
-						if (typeof entry === "string") {
-							hash.update(entry);
-						} else {
-							hash.update(entry.hash);
-							if (entry.symlinks) {
-								if (symlinks === undefined) symlinks = new Set();
-								addAll(entry.symlinks, symlinks);
-							}
-						}
-					}
+module.exports = NodeStuffInWebError;
 
-					const result = {
-						hash: /** @type {string} */ (hash.digest("hex"))
-					};
-					if (symlinks) result.symlinks = symlinks;
-					return result;
-				}
-			},
-			(err, result) => {
-				if (err) return callback(err);
-				this._contextHashes.set(path, result);
-				return callback(null, result);
-			}
-		);
+
+/***/ }),
+
+/***/ 95287:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const NodeStuffInWebError = __webpack_require__(6325);
+const RuntimeGlobals = __webpack_require__(16475);
+const CachedConstDependency = __webpack_require__(57403);
+const ConstDependency = __webpack_require__(76911);
+const {
+	evaluateToString,
+	expressionIsUnsupported
+} = __webpack_require__(93998);
+const { relative } = __webpack_require__(17139);
+const { parseResource } = __webpack_require__(82186);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+
+class NodeStuffPlugin {
+	constructor(options) {
+		this.options = options;
 	}
 
 	/**
-	 * @param {ContextHash} entry context hash
-	 * @param {function((Error | null)=, string=): void} callback callback
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	_resolveContextHash(entry, callback) {
-		const hashes = [];
-		processAsyncTree(
-			entry.symlinks,
-			10,
-			(target, push, callback) => {
-				this._getUnresolvedContextHash(target, (err, hash) => {
-					if (err) return callback(err);
-					if (hash) {
-						hashes.push(hash.hash);
-						if (hash.symlinks !== undefined) {
-							for (const target of hash.symlinks) push(target);
-						}
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap(
+			"NodeStuffPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.node === false) return;
+
+					let localOptions = options;
+					if (parserOptions.node) {
+						localOptions = { ...localOptions, ...parserOptions.node };
 					}
-					callback();
-				});
-			},
-			err => {
-				if (err) return callback(err);
-				const hash = createHash(this._hashFunction);
-				hash.update(entry.hash);
-				hashes.sort();
-				for (const h of hashes) {
-					hash.update(h);
-				}
-				callback(
-					null,
-					(entry.resolved = /** @type {string} */ (hash.digest("hex")))
-				);
-			}
-		);
-	}
 
-	_readContextTimestampAndHash(path, callback) {
-		const finalize = (timestamp, hash) => {
-			const result =
-				timestamp === "ignore"
-					? hash
-					: {
-							...timestamp,
-							...hash
-					  };
-			this._contextTshs.set(path, result);
-			callback(null, result);
-		};
-		const cachedHash = this._contextHashes.get(path);
-		const cachedTimestamp = this._contextTimestamps.get(path);
-		if (cachedHash !== undefined) {
-			if (cachedTimestamp !== undefined) {
-				finalize(cachedTimestamp, cachedHash);
-			} else {
-				this.contextTimestampQueue.add(path, (err, entry) => {
-					if (err) return callback(err);
-					finalize(entry, cachedHash);
-				});
-			}
-		} else {
-			if (cachedTimestamp !== undefined) {
-				this.contextHashQueue.add(path, (err, entry) => {
-					if (err) return callback(err);
-					finalize(cachedTimestamp, entry);
-				});
-			} else {
-				this._readContext(
-					{
-						path,
-						fromImmutablePath: () => null,
-						fromManagedItem: info => ({
-							safeTime: 0,
-							timestampHash: info,
-							hash: info || ""
-						}),
-						fromSymlink: (fle, target, callback) => {
-							callback(null, {
-								timestampHash: target,
-								hash: target,
-								symlinks: new Set([target])
-							});
-						},
-						fromFile: (file, stat, callback) => {
-							this._getFileTimestampAndHash(file, callback);
-						},
-						fromDirectory: (directory, stat, callback) => {
-							this.contextTshQueue.increaseParallelism();
-							this.contextTshQueue.add(directory, (err, result) => {
-								this.contextTshQueue.decreaseParallelism();
-								callback(err, result);
+					if (localOptions.global !== false) {
+						const withWarning = localOptions.global === "warn";
+						parser.hooks.expression
+							.for("global")
+							.tap("NodeStuffPlugin", expr => {
+								const dep = new ConstDependency(
+									RuntimeGlobals.global,
+									expr.range,
+									[RuntimeGlobals.global]
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+
+								// TODO webpack 6 remove
+								if (withWarning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(
+											dep.loc,
+											"global",
+											"The global namespace object is Node.js feature and doesn't present in browser."
+										)
+									);
+								}
 							});
-						},
-						/**
-						 * @param {string[]} files files
-						 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
-						 * @returns {ContextTimestampAndHash} tsh
-						 */
-						reduce: (files, results) => {
-							let symlinks = undefined;
+					}
 
-							const tsHash = createHash(this._hashFunction);
-							const hash = createHash(this._hashFunction);
+					const setModuleConstant = (expressionName, fn, warning) => {
+						parser.hooks.expression
+							.for(expressionName)
+							.tap("NodeStuffPlugin", expr => {
+								const dep = new CachedConstDependency(
+									JSON.stringify(fn(parser.state.module)),
+									expr.range,
+									expressionName
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
 
-							for (const file of files) {
-								tsHash.update(file);
-								hash.update(file);
-							}
-							let safeTime = 0;
-							for (const entry of results) {
-								if (!entry) {
-									tsHash.update("n");
-									continue;
-								}
-								if (typeof entry === "string") {
-									tsHash.update("n");
-									hash.update(entry);
-									continue;
-								}
-								if (entry.timestamp) {
-									tsHash.update("f");
-									tsHash.update(`${entry.timestamp}`);
-								} else if (entry.timestampHash) {
-									tsHash.update("d");
-									tsHash.update(`${entry.timestampHash}`);
-								}
-								if (entry.symlinks !== undefined) {
-									if (symlinks === undefined) symlinks = new Set();
-									addAll(entry.symlinks, symlinks);
-								}
-								if (entry.safeTime) {
-									safeTime = Math.max(safeTime, entry.safeTime);
+								// TODO webpack 6 remove
+								if (warning) {
+									parser.state.module.addWarning(
+										new NodeStuffInWebError(dep.loc, expressionName, warning)
+									);
 								}
-								hash.update(entry.hash);
-							}
-
-							const result = {
-								safeTime,
-								timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-								hash: /** @type {string} */ (hash.digest("hex"))
-							};
-							if (symlinks) result.symlinks = symlinks;
-							return result;
-						}
-					},
-					(err, result) => {
-						if (err) return callback(err);
-						this._contextTshs.set(path, result);
-						return callback(null, result);
-					}
-				);
-			}
-		}
-	}
 
-	/**
-	 * @param {ContextTimestampAndHash} entry entry
-	 * @param {function((Error | null)=, ResolvedContextTimestampAndHash=): void} callback callback
-	 * @returns {void}
-	 */
-	_resolveContextTsh(entry, callback) {
-		const hashes = [];
-		const tsHashes = [];
-		let safeTime = 0;
-		processAsyncTree(
-			entry.symlinks,
-			10,
-			(target, push, callback) => {
-				this._getUnresolvedContextTsh(target, (err, entry) => {
-					if (err) return callback(err);
-					if (entry) {
-						hashes.push(entry.hash);
-						if (entry.timestampHash) tsHashes.push(entry.timestampHash);
-						if (entry.safeTime) {
-							safeTime = Math.max(safeTime, entry.safeTime);
-						}
-						if (entry.symlinks !== undefined) {
-							for (const target of entry.symlinks) push(target);
-						}
-					}
-					callback();
-				});
-			},
-			err => {
-				if (err) return callback(err);
-				const hash = createHash(this._hashFunction);
-				const tsHash = createHash(this._hashFunction);
-				hash.update(entry.hash);
-				if (entry.timestampHash) tsHash.update(entry.timestampHash);
-				if (entry.safeTime) {
-					safeTime = Math.max(safeTime, entry.safeTime);
-				}
-				hashes.sort();
-				for (const h of hashes) {
-					hash.update(h);
-				}
-				tsHashes.sort();
-				for (const h of tsHashes) {
-					tsHash.update(h);
-				}
-				callback(
-					null,
-					(entry.resolved = {
-						safeTime,
-						timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-						hash: /** @type {string} */ (hash.digest("hex"))
-					})
-				);
-			}
-		);
-	}
+								return true;
+							});
+					};
 
-	_getManagedItemDirectoryInfo(path, callback) {
-		this.fs.readdir(path, (err, elements) => {
-			if (err) {
-				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
-					return callback(null, EMPTY_SET);
-				}
-				return callback(err);
-			}
-			const set = new Set(
-				/** @type {string[]} */ (elements).map(element =>
-					join(this.fs, path, element)
-				)
-			);
-			callback(null, set);
-		});
-	}
+					const setConstant = (expressionName, value, warning) =>
+						setModuleConstant(expressionName, () => value, warning);
 
-	_getManagedItemInfo(path, callback) {
-		const dir = dirname(this.fs, path);
-		this.managedItemDirectoryQueue.add(dir, (err, elements) => {
-			if (err) {
-				return callback(err);
-			}
-			if (!elements.has(path)) {
-				// file or directory doesn't exist
-				this._managedItems.set(path, "*missing");
-				return callback(null, "*missing");
-			}
-			// something exists
-			// it may be a file or directory
-			if (
-				path.endsWith("node_modules") &&
-				(path.endsWith("/node_modules") || path.endsWith("\\node_modules"))
-			) {
-				// we are only interested in existence of this special directory
-				this._managedItems.set(path, "*node_modules");
-				return callback(null, "*node_modules");
-			}
+					const context = compiler.context;
+					if (localOptions.__filename) {
+						switch (localOptions.__filename) {
+							case "mock":
+								setConstant("__filename", "/index.js");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__filename",
+									"/index.js",
+									"The __filename is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__filename", module =>
+									relative(compiler.inputFileSystem, context, module.resource)
+								);
+								break;
+						}
 
-			// we assume it's a directory, as files shouldn't occur in managed paths
-			const packageJsonPath = join(this.fs, path, "package.json");
-			this.fs.readFile(packageJsonPath, (err, content) => {
-				if (err) {
-					if (err.code === "ENOENT" || err.code === "ENOTDIR") {
-						// no package.json or path is not a directory
-						this.fs.readdir(path, (err, elements) => {
-							if (
-								!err &&
-								elements.length === 1 &&
-								elements[0] === "node_modules"
-							) {
-								// This is only a grouping folder e. g. used by yarn
-								// we are only interested in existence of this special directory
-								this._managedItems.set(path, "*nested");
-								return callback(null, "*nested");
-							}
-							this.logger.warn(
-								`Managed item ${path} isn't a directory or doesn't contain a package.json (see snapshot.managedPaths option)`
-							);
-							return callback();
-						});
-						return;
+						parser.hooks.evaluateIdentifier
+							.for("__filename")
+							.tap("NodeStuffPlugin", expr => {
+								if (!parser.state.module) return;
+								const resource = parseResource(parser.state.module.resource);
+								return evaluateToString(resource.path)(expr);
+							});
 					}
-					return callback(err);
-				}
-				let data;
-				try {
-					data = JSON.parse(content.toString("utf-8"));
-				} catch (e) {
-					return callback(e);
-				}
-				if (!data.name) {
-					this.logger.warn(
-						`${packageJsonPath} doesn't contain a "name" property (see snapshot.managedPaths option)`
-					);
-					return callback();
-				}
-				const info = `${data.name || ""}@${data.version || ""}`;
-				this._managedItems.set(path, info);
-				callback(null, info);
-			});
-		});
-	}
+					if (localOptions.__dirname) {
+						switch (localOptions.__dirname) {
+							case "mock":
+								setConstant("__dirname", "/");
+								break;
+							case "warn-mock":
+								setConstant(
+									"__dirname",
+									"/",
+									"The __dirname is Node.js feature and doesn't present in browser."
+								);
+								break;
+							case true:
+								setModuleConstant("__dirname", module =>
+									relative(compiler.inputFileSystem, context, module.context)
+								);
+								break;
+						}
 
-	getDeprecatedFileTimestamps() {
-		if (this._cachedDeprecatedFileTimestamps !== undefined)
-			return this._cachedDeprecatedFileTimestamps;
-		const map = new Map();
-		for (const [path, info] of this._fileTimestamps) {
-			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
-		}
-		return (this._cachedDeprecatedFileTimestamps = map);
-	}
+						parser.hooks.evaluateIdentifier
+							.for("__dirname")
+							.tap("NodeStuffPlugin", expr => {
+								if (!parser.state.module) return;
+								return evaluateToString(parser.state.module.context)(expr);
+							});
+					}
+					parser.hooks.expression
+						.for("require.extensions")
+						.tap(
+							"NodeStuffPlugin",
+							expressionIsUnsupported(
+								parser,
+								"require.extensions is not supported by webpack. Use a loader instead."
+							)
+						);
+				};
 
-	getDeprecatedContextTimestamps() {
-		if (this._cachedDeprecatedContextTimestamps !== undefined)
-			return this._cachedDeprecatedContextTimestamps;
-		const map = new Map();
-		for (const [path, info] of this._contextTimestamps) {
-			if (info) map.set(path, typeof info === "object" ? info.safeTime : null);
-		}
-		return (this._cachedDeprecatedContextTimestamps = map);
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("NodeStuffPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("NodeStuffPlugin", handler);
+			}
+		);
 	}
 }
 
-module.exports = FileSystemInfo;
-module.exports.Snapshot = Snapshot;
+module.exports = NodeStuffPlugin;
 
 
 /***/ }),
 
-/***/ 58727:
+/***/ 39:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -47745,2639 +48465,2531 @@ module.exports.Snapshot = Snapshot;
 
 
 
-const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
+const parseJson = __webpack_require__(15235);
+const { getContext, runLoaders } = __webpack_require__(8255);
+const querystring = __webpack_require__(63477);
+const { HookMap, SyncHook, AsyncSeriesBailHook } = __webpack_require__(6967);
+const {
+	CachedSource,
+	OriginalSource,
+	RawSource,
+	SourceMapSource
+} = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const HookWebpackError = __webpack_require__(11351);
+const Module = __webpack_require__(73208);
+const ModuleBuildError = __webpack_require__(21305);
+const ModuleError = __webpack_require__(23744);
+const ModuleGraphConnection = __webpack_require__(40639);
+const ModuleParseError = __webpack_require__(58443);
+const ModuleWarning = __webpack_require__(11234);
+const RuntimeGlobals = __webpack_require__(16475);
+const UnhandledSchemeError = __webpack_require__(68099);
+const WebpackError = __webpack_require__(53799);
+const formatLocation = __webpack_require__(16734);
+const LazySet = __webpack_require__(38938);
+const { isSubset } = __webpack_require__(93347);
+const { getScheme } = __webpack_require__(54500);
+const {
+	compareLocations,
+	concatComparators,
+	compareSelect,
+	keepOriginalOrder
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const { createFakeHook } = __webpack_require__(64518);
+const { join } = __webpack_require__(17139);
+const {
+	contextify,
+	absolutify,
+	makePathsRelative
+} = __webpack_require__(82186);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
 
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
+/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+/** @typedef {import("./Parser")} Parser */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-class FlagAllModulesAsUsedPlugin {
-	constructor(explanation) {
-		this.explanation = explanation;
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FlagAllModulesAsUsedPlugin",
-			compilation => {
-				const moduleGraph = compilation.moduleGraph;
-				compilation.hooks.optimizeDependencies.tap(
-					"FlagAllModulesAsUsedPlugin",
-					modules => {
-						/** @type {RuntimeSpec} */
-						let runtime = undefined;
-						for (const [name, { options }] of compilation.entries) {
-							runtime = mergeRuntimeOwned(
-								runtime,
-								getEntryRuntime(compilation, name, options)
-							);
-						}
-						for (const module of modules) {
-							const exportsInfo = moduleGraph.getExportsInfo(module);
-							exportsInfo.setUsedInUnknownWay(runtime);
-							moduleGraph.addExtraReason(module, this.explanation);
-							if (module.factoryMeta === undefined) {
-								module.factoryMeta = {};
-							}
-							module.factoryMeta.sideEffectFree = false;
-						}
-					}
-				);
-			}
-		);
-	}
-}
-
-module.exports = FlagAllModulesAsUsedPlugin;
+/**
+ * @typedef {Object} SourceMap
+ * @property {number} version
+ * @property {string[]} sources
+ * @property {string} mappings
+ * @property {string=} file
+ * @property {string=} sourceRoot
+ * @property {string[]=} sourcesContent
+ * @property {string[]=} names
+ */
 
+const getInvalidDependenciesModuleWarning = memoize(() =>
+	__webpack_require__(68257)
+);
+const getValidate = memoize(() => (__webpack_require__(38476).validate));
 
-/***/ }),
+const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 
-/***/ 84506:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @typedef {Object} LoaderItem
+ * @property {string} loader
+ * @property {any} options
+ * @property {string?} ident
+ * @property {string?} type
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {string} context absolute context path
+ * @param {string} source a source path
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} new source path
+ */
+const contextifySourceUrl = (context, source, associatedObjectForCache) => {
+	if (source.startsWith("webpack://")) return source;
+	return `webpack://${makePathsRelative(
+		context,
+		source,
+		associatedObjectForCache
+	)}`;
+};
 
+/**
+ * @param {string} context absolute context path
+ * @param {SourceMap} sourceMap a source map
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {SourceMap} new source map
+ */
+const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
+	if (!Array.isArray(sourceMap.sources)) return sourceMap;
+	const { sourceRoot } = sourceMap;
+	/** @type {function(string): string} */
+	const mapper = !sourceRoot
+		? source => source
+		: sourceRoot.endsWith("/")
+		? source =>
+				source.startsWith("/")
+					? `${sourceRoot.slice(0, -1)}${source}`
+					: `${sourceRoot}${source}`
+		: source =>
+				source.startsWith("/")
+					? `${sourceRoot}${source}`
+					: `${sourceRoot}/${source}`;
+	const newSources = sourceMap.sources.map(source =>
+		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
+	);
+	return {
+		...sourceMap,
+		file: "x",
+		sourceRoot: undefined,
+		sources: newSources
+	};
+};
 
+/**
+ * @param {string | Buffer} input the input
+ * @returns {string} the converted string
+ */
+const asString = input => {
+	if (Buffer.isBuffer(input)) {
+		return input.toString("utf-8");
+	}
+	return input;
+};
 
-const asyncLib = __webpack_require__(78175);
-const Queue = __webpack_require__(65930);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("./Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module")} Module */
+/**
+ * @param {string | Buffer} input the input
+ * @returns {Buffer} the converted buffer
+ */
+const asBuffer = input => {
+	if (!Buffer.isBuffer(input)) {
+		return Buffer.from(input, "utf-8");
+	}
+	return input;
+};
 
-class FlagDependencyExportsPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FlagDependencyExportsPlugin",
-			compilation => {
-				const moduleGraph = compilation.moduleGraph;
-				const cache = compilation.getCache("FlagDependencyExportsPlugin");
-				compilation.hooks.finishModules.tapAsync(
-					"FlagDependencyExportsPlugin",
-					(modules, callback) => {
-						const logger = compilation.getLogger(
-							"webpack.FlagDependencyExportsPlugin"
-						);
-						let statRestoredFromMemCache = 0;
-						let statRestoredFromCache = 0;
-						let statNoExports = 0;
-						let statFlaggedUncached = 0;
-						let statNotCached = 0;
-						let statQueueItemsProcessed = 0;
+class NonErrorEmittedError extends WebpackError {
+	constructor(error) {
+		super();
 
-						const { moduleMemCaches } = compilation;
+		this.name = "NonErrorEmittedError";
+		this.message = "(Emitted value instead of an instance of Error) " + error;
+	}
+}
 
-						/** @type {Queue<Module>} */
-						const queue = new Queue();
+makeSerializable(
+	NonErrorEmittedError,
+	"webpack/lib/NormalModule",
+	"NonErrorEmittedError"
+);
 
-						// Step 1: Try to restore cached provided export info from cache
-						logger.time("restore cached provided exports");
-						asyncLib.each(
-							modules,
-							(module, callback) => {
-								const exportsInfo = moduleGraph.getExportsInfo(module);
-								if (!module.buildMeta || !module.buildMeta.exportsType) {
-									if (exportsInfo.otherExportsInfo.provided !== null) {
-										// It's a module without declared exports
-										statNoExports++;
-										exportsInfo.setHasProvideInfo();
-										exportsInfo.setUnknownExportsProvided();
-										return callback();
-									}
-								}
-								if (typeof module.buildInfo.hash !== "string") {
-									statFlaggedUncached++;
-									// Enqueue uncacheable module for determining the exports
-									queue.enqueue(module);
-									exportsInfo.setHasProvideInfo();
-									return callback();
-								}
-								const memCache = moduleMemCaches && moduleMemCaches.get(module);
-								const memCacheValue = memCache && memCache.get(this);
-								if (memCacheValue !== undefined) {
-									statRestoredFromMemCache++;
-									exportsInfo.restoreProvided(memCacheValue);
-									return callback();
-								}
-								cache.get(
-									module.identifier(),
-									module.buildInfo.hash,
-									(err, result) => {
-										if (err) return callback(err);
+/**
+ * @typedef {Object} NormalModuleCompilationHooks
+ * @property {SyncHook<[object, NormalModule]>} loader
+ * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
+ * @property {SyncHook<[NormalModule]>} beforeParse
+ * @property {SyncHook<[NormalModule]>} beforeSnapshot
+ * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
+ * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
+ */
 
-										if (result !== undefined) {
-											statRestoredFromCache++;
-											exportsInfo.restoreProvided(result);
-										} else {
-											statNotCached++;
-											// Without cached info enqueue module for determining the exports
-											queue.enqueue(module);
-											exportsInfo.setHasProvideInfo();
-										}
-										callback();
-									}
-								);
-							},
-							err => {
-								logger.timeEnd("restore cached provided exports");
-								if (err) return callback(err);
+/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-								/** @type {Set<Module>} */
-								const modulesToStore = new Set();
+class NormalModule extends Module {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {NormalModuleCompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				loader: new SyncHook(["loaderContext", "module"]),
+				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
+				beforeParse: new SyncHook(["module"]),
+				beforeSnapshot: new SyncHook(["module"]),
+				// TODO webpack 6 deprecate
+				readResourceForScheme: new HookMap(scheme => {
+					const hook = hooks.readResource.for(scheme);
+					return createFakeHook(
+						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
+							tap: (options, fn) =>
+								hook.tap(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								),
+							tapAsync: (options, fn) =>
+								hook.tapAsync(options, (loaderContext, callback) =>
+									fn(loaderContext.resource, loaderContext._module, callback)
+								),
+							tapPromise: (options, fn) =>
+								hook.tapPromise(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								)
+						})
+					);
+				}),
+				readResource: new HookMap(
+					() => new AsyncSeriesBailHook(["loaderContext"])
+				),
+				needBuild: new AsyncSeriesBailHook(["module", "context"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
 
-								/** @type {Map<Module, Set<Module>>} */
-								const dependencies = new Map();
+	/**
+	 * @param {Object} options options object
+	 * @param {string=} options.layer an optional layer in which the module is
+	 * @param {string} options.type module type
+	 * @param {string} options.request request string
+	 * @param {string} options.userRequest request intended by user (without loaders from config)
+	 * @param {string} options.rawRequest request without resolving
+	 * @param {LoaderItem[]} options.loaders list of loaders
+	 * @param {string} options.resource path + query of the real resource
+	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
+	 * @param {string} options.context context directory for resolving
+	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
+	 * @param {Parser} options.parser the parser used
+	 * @param {object} options.parserOptions the options of the parser used
+	 * @param {Generator} options.generator the generator used
+	 * @param {object} options.generatorOptions the options of the generator used
+	 * @param {Object} options.resolveOptions options used for resolving requests from this module
+	 */
+	constructor({
+		layer,
+		type,
+		request,
+		userRequest,
+		rawRequest,
+		loaders,
+		resource,
+		resourceResolveData,
+		context,
+		matchResource,
+		parser,
+		parserOptions,
+		generator,
+		generatorOptions,
+		resolveOptions
+	}) {
+		super(type, context || getContext(resource), layer);
 
-								/** @type {Module} */
-								let module;
+		// Info from Factory
+		/** @type {string} */
+		this.request = request;
+		/** @type {string} */
+		this.userRequest = userRequest;
+		/** @type {string} */
+		this.rawRequest = rawRequest;
+		/** @type {boolean} */
+		this.binary = /^(asset|webassembly)\b/.test(type);
+		/** @type {Parser} */
+		this.parser = parser;
+		this.parserOptions = parserOptions;
+		/** @type {Generator} */
+		this.generator = generator;
+		this.generatorOptions = generatorOptions;
+		/** @type {string} */
+		this.resource = resource;
+		this.resourceResolveData = resourceResolveData;
+		/** @type {string | undefined} */
+		this.matchResource = matchResource;
+		/** @type {LoaderItem[]} */
+		this.loaders = loaders;
+		if (resolveOptions !== undefined) {
+			// already declared in super class
+			this.resolveOptions = resolveOptions;
+		}
 
-								/** @type {ExportsInfo} */
-								let exportsInfo;
+		// Info from Build
+		/** @type {(WebpackError | null)=} */
+		this.error = null;
+		/** @private @type {Source=} */
+		this._source = null;
+		/** @private @type {Map<string, number> | undefined} **/
+		this._sourceSizes = undefined;
+		/** @private @type {Set<string>} */
+		this._sourceTypes = undefined;
 
-								/** @type {Map<Dependency, ExportsSpec>} */
-								const exportsSpecsFromDependencies = new Map();
+		// Cache
+		this._lastSuccessfulBuildMeta = {};
+		this._forceBuild = true;
+		this._isEvaluatingSideEffects = false;
+		/** @type {WeakSet<ModuleGraph> | undefined} */
+		this._addedSideEffectsBailout = undefined;
+	}
 
-								let cacheable = true;
-								let changed = false;
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		if (this.layer === null) {
+			if (this.type === "javascript/auto") {
+				return this.request;
+			} else {
+				return `${this.type}|${this.request}`;
+			}
+		} else {
+			return `${this.type}|${this.request}|${this.layer}`;
+		}
+	}
 
-								/**
-								 * @param {DependenciesBlock} depBlock the dependencies block
-								 * @returns {void}
-								 */
-								const processDependenciesBlock = depBlock => {
-									for (const dep of depBlock.dependencies) {
-										processDependency(dep);
-									}
-									for (const block of depBlock.blocks) {
-										processDependenciesBlock(block);
-									}
-								};
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return requestShortener.shorten(this.userRequest);
+	}
 
-								/**
-								 * @param {Dependency} dep the dependency
-								 * @returns {void}
-								 */
-								const processDependency = dep => {
-									const exportDesc = dep.getExports(moduleGraph);
-									if (!exportDesc) return;
-									exportsSpecsFromDependencies.set(dep, exportDesc);
-								};
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		let ident = contextify(
+			options.context,
+			this.userRequest,
+			options.associatedObjectForCache
+		);
+		if (this.layer) ident = `(${this.layer})/${ident}`;
+		return ident;
+	}
 
-								/**
-								 * @param {Dependency} dep dependency
-								 * @param {ExportsSpec} exportDesc info
-								 * @returns {void}
-								 */
-								const processExportsSpec = (dep, exportDesc) => {
-									const exports = exportDesc.exports;
-									const globalCanMangle = exportDesc.canMangle;
-									const globalFrom = exportDesc.from;
-									const globalPriority = exportDesc.priority;
-									const globalTerminalBinding =
-										exportDesc.terminalBinding || false;
-									const exportDeps = exportDesc.dependencies;
-									if (exportDesc.hideExports) {
-										for (const name of exportDesc.hideExports) {
-											const exportInfo = exportsInfo.getExportInfo(name);
-											exportInfo.unsetTarget(dep);
-										}
-									}
-									if (exports === true) {
-										// unknown exports
-										if (
-											exportsInfo.setUnknownExportsProvided(
-												globalCanMangle,
-												exportDesc.excludeExports,
-												globalFrom && dep,
-												globalFrom,
-												globalPriority
-											)
-										) {
-											changed = true;
-										}
-									} else if (Array.isArray(exports)) {
-										/**
-										 * merge in new exports
-										 * @param {ExportsInfo} exportsInfo own exports info
-										 * @param {(ExportSpec | string)[]} exports list of exports
-										 */
-										const mergeExports = (exportsInfo, exports) => {
-											for (const exportNameOrSpec of exports) {
-												let name;
-												let canMangle = globalCanMangle;
-												let terminalBinding = globalTerminalBinding;
-												let exports = undefined;
-												let from = globalFrom;
-												let fromExport = undefined;
-												let priority = globalPriority;
-												let hidden = false;
-												if (typeof exportNameOrSpec === "string") {
-													name = exportNameOrSpec;
-												} else {
-													name = exportNameOrSpec.name;
-													if (exportNameOrSpec.canMangle !== undefined)
-														canMangle = exportNameOrSpec.canMangle;
-													if (exportNameOrSpec.export !== undefined)
-														fromExport = exportNameOrSpec.export;
-													if (exportNameOrSpec.exports !== undefined)
-														exports = exportNameOrSpec.exports;
-													if (exportNameOrSpec.from !== undefined)
-														from = exportNameOrSpec.from;
-													if (exportNameOrSpec.priority !== undefined)
-														priority = exportNameOrSpec.priority;
-													if (exportNameOrSpec.terminalBinding !== undefined)
-														terminalBinding = exportNameOrSpec.terminalBinding;
-													if (exportNameOrSpec.hidden !== undefined)
-														hidden = exportNameOrSpec.hidden;
-												}
-												const exportInfo = exportsInfo.getExportInfo(name);
+	/**
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 */
+	nameForCondition() {
+		const resource = this.matchResource || this.resource;
+		const idx = resource.indexOf("?");
+		if (idx >= 0) return resource.substr(0, idx);
+		return resource;
+	}
 
-												if (
-													exportInfo.provided === false ||
-													exportInfo.provided === null
-												) {
-													exportInfo.provided = true;
-													changed = true;
-												}
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {NormalModule} */ (module);
+		this.binary = m.binary;
+		this.request = m.request;
+		this.userRequest = m.userRequest;
+		this.rawRequest = m.rawRequest;
+		this.parser = m.parser;
+		this.parserOptions = m.parserOptions;
+		this.generator = m.generator;
+		this.generatorOptions = m.generatorOptions;
+		this.resource = m.resource;
+		this.resourceResolveData = m.resourceResolveData;
+		this.context = m.context;
+		this.matchResource = m.matchResource;
+		this.loaders = m.loaders;
+	}
 
-												if (
-													exportInfo.canMangleProvide !== false &&
-													canMangle === false
-												) {
-													exportInfo.canMangleProvide = false;
-													changed = true;
-												}
+	/**
+	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+	 */
+	cleanupForCache() {
+		// Make sure to cache types and sizes before cleanup when this module has been built
+		// They are accessed by the stats and we don't want them to crash after cleanup
+		// TODO reconsider this for webpack 6
+		if (this.buildInfo) {
+			if (this._sourceTypes === undefined) this.getSourceTypes();
+			for (const type of this._sourceTypes) {
+				this.size(type);
+			}
+		}
+		super.cleanupForCache();
+		this.parser = undefined;
+		this.parserOptions = undefined;
+		this.generator = undefined;
+		this.generatorOptions = undefined;
+	}
 
-												if (terminalBinding && !exportInfo.terminalBinding) {
-													exportInfo.terminalBinding = true;
-													changed = true;
-												}
+	/**
+	 * Module should be unsafe cached. Get data that's needed for that.
+	 * This data will be passed to restoreFromUnsafeCache later.
+	 * @returns {object} cached data
+	 */
+	getUnsafeCacheData() {
+		const data = super.getUnsafeCacheData();
+		data.parserOptions = this.parserOptions;
+		data.generatorOptions = this.generatorOptions;
+		return data;
+	}
 
-												if (exports) {
-													const nestedExportsInfo =
-														exportInfo.createNestedExportsInfo();
-													mergeExports(nestedExportsInfo, exports);
-												}
+	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+	}
 
-												if (
-													from &&
-													(hidden
-														? exportInfo.unsetTarget(dep)
-														: exportInfo.setTarget(
-																dep,
-																from,
-																fromExport === undefined ? [name] : fromExport,
-																priority
-														  ))
-												) {
-													changed = true;
-												}
+	/**
+	 * restore unsafe cache data
+	 * @param {object} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 */
+	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+		this.parserOptions = unsafeCacheData.parserOptions;
+		this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);
+		this.generatorOptions = unsafeCacheData.generatorOptions;
+		this.generator = normalModuleFactory.getGenerator(
+			this.type,
+			this.generatorOptions
+		);
+		// we assume the generator behaves identically and keep cached sourceTypes/Sizes
+	}
 
-												// Recalculate target exportsInfo
-												const target = exportInfo.getTarget(moduleGraph);
-												let targetExportsInfo = undefined;
-												if (target) {
-													const targetModuleExportsInfo =
-														moduleGraph.getExportsInfo(target.module);
-													targetExportsInfo =
-														targetModuleExportsInfo.getNestedExportsInfo(
-															target.export
-														);
-													// add dependency for this module
-													const set = dependencies.get(target.module);
-													if (set === undefined) {
-														dependencies.set(target.module, new Set([module]));
-													} else {
-														set.add(module);
-													}
-												}
-
-												if (exportInfo.exportsInfoOwned) {
-													if (
-														exportInfo.exportsInfo.setRedirectNamedTo(
-															targetExportsInfo
-														)
-													) {
-														changed = true;
-													}
-												} else if (
-													exportInfo.exportsInfo !== targetExportsInfo
-												) {
-													exportInfo.exportsInfo = targetExportsInfo;
-													changed = true;
-												}
-											}
-										};
-										mergeExports(exportsInfo, exports);
-									}
-									// store dependencies
-									if (exportDeps) {
-										cacheable = false;
-										for (const exportDependency of exportDeps) {
-											// add dependency for this module
-											const set = dependencies.get(exportDependency);
-											if (set === undefined) {
-												dependencies.set(exportDependency, new Set([module]));
-											} else {
-												set.add(module);
-											}
-										}
-									}
-								};
-
-								const notifyDependencies = () => {
-									const deps = dependencies.get(module);
-									if (deps !== undefined) {
-										for (const dep of deps) {
-											queue.enqueue(dep);
-										}
-									}
-								};
-
-								logger.time("figure out provided exports");
-								while (queue.length > 0) {
-									module = queue.dequeue();
-
-									statQueueItemsProcessed++;
+	/**
+	 * @param {string} context the compilation context
+	 * @param {string} name the asset name
+	 * @param {string} content the content
+	 * @param {string | TODO} sourceMap an optional source map
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @returns {Source} the created source
+	 */
+	createSourceForAsset(
+		context,
+		name,
+		content,
+		sourceMap,
+		associatedObjectForCache
+	) {
+		if (sourceMap) {
+			if (
+				typeof sourceMap === "string" &&
+				(this.useSourceMap || this.useSimpleSourceMap)
+			) {
+				return new OriginalSource(
+					content,
+					contextifySourceUrl(context, sourceMap, associatedObjectForCache)
+				);
+			}
 
-									exportsInfo = moduleGraph.getExportsInfo(module);
+			if (this.useSourceMap) {
+				return new SourceMapSource(
+					content,
+					name,
+					contextifySourceMap(context, sourceMap, associatedObjectForCache)
+				);
+			}
+		}
 
-									cacheable = true;
-									changed = false;
+		return new RawSource(content);
+	}
 
-									exportsSpecsFromDependencies.clear();
-									moduleGraph.freeze();
-									processDependenciesBlock(module);
-									moduleGraph.unfreeze();
-									for (const [
-										dep,
-										exportsSpec
-									] of exportsSpecsFromDependencies) {
-										processExportsSpec(dep, exportsSpec);
-									}
+	/**
+	 * @param {ResolverWithOptions} resolver a resolver
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {InputFileSystem} fs file system from reading
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
+	 * @returns {NormalModuleLoaderContext} loader context
+	 */
+	_createLoaderContext(resolver, options, compilation, fs, hooks) {
+		const { requestShortener } = compilation.runtimeTemplate;
+		const getCurrentLoaderName = () => {
+			const currentLoader = this.getCurrentLoader(loaderContext);
+			if (!currentLoader) return "(not in loader scope)";
+			return requestShortener.shorten(currentLoader.loader);
+		};
+		const getResolveContext = () => {
+			return {
+				fileDependencies: {
+					add: d => loaderContext.addDependency(d)
+				},
+				contextDependencies: {
+					add: d => loaderContext.addContextDependency(d)
+				},
+				missingDependencies: {
+					add: d => loaderContext.addMissingDependency(d)
+				}
+			};
+		};
+		const getAbsolutify = memoize(() =>
+			absolutify.bindCache(compilation.compiler.root)
+		);
+		const getAbsolutifyInContext = memoize(() =>
+			absolutify.bindContextCache(this.context, compilation.compiler.root)
+		);
+		const getContextify = memoize(() =>
+			contextify.bindCache(compilation.compiler.root)
+		);
+		const getContextifyInContext = memoize(() =>
+			contextify.bindContextCache(this.context, compilation.compiler.root)
+		);
+		const utils = {
+			absolutify: (context, request) => {
+				return context === this.context
+					? getAbsolutifyInContext()(request)
+					: getAbsolutify()(context, request);
+			},
+			contextify: (context, request) => {
+				return context === this.context
+					? getContextifyInContext()(request)
+					: getContextify()(context, request);
+			},
+			createHash: type => {
+				return createHash(type || compilation.outputOptions.hashFunction);
+			}
+		};
+		const loaderContext = {
+			version: 2,
+			getOptions: schema => {
+				const loader = this.getCurrentLoader(loaderContext);
 
-									if (cacheable) {
-										modulesToStore.add(module);
-									}
+				let { options } = loader;
 
-									if (changed) {
-										notifyDependencies();
-									}
-								}
-								logger.timeEnd("figure out provided exports");
+				if (typeof options === "string") {
+					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
+						try {
+							options = parseJson(options);
+						} catch (e) {
+							throw new Error(`Cannot parse string options: ${e.message}`);
+						}
+					} else {
+						options = querystring.parse(options, "&", "=", {
+							maxKeys: 0
+						});
+					}
+				}
 
-								logger.log(
-									`${Math.round(
-										(100 * (statFlaggedUncached + statNotCached)) /
-											(statRestoredFromMemCache +
-												statRestoredFromCache +
-												statNotCached +
-												statFlaggedUncached +
-												statNoExports)
-									)}% of exports of modules have been determined (${statNoExports} no declared exports, ${statNotCached} not cached, ${statFlaggedUncached} flagged uncacheable, ${statRestoredFromCache} from cache, ${statRestoredFromMemCache} from mem cache, ${
-										statQueueItemsProcessed -
-										statNotCached -
-										statFlaggedUncached
-									} additional calculations due to dependencies)`
-								);
+				if (options === null || options === undefined) {
+					options = {};
+				}
 
-								logger.time("store provided exports into cache");
-								asyncLib.each(
-									modulesToStore,
-									(module, callback) => {
-										if (typeof module.buildInfo.hash !== "string") {
-											// not cacheable
-											return callback();
-										}
-										const cachedData = moduleGraph
-											.getExportsInfo(module)
-											.getRestoreProvidedData();
-										const memCache =
-											moduleMemCaches && moduleMemCaches.get(module);
-										if (memCache) {
-											memCache.set(this, cachedData);
-										}
-										cache.store(
-											module.identifier(),
-											module.buildInfo.hash,
-											cachedData,
-											callback
-										);
-									},
-									err => {
-										logger.timeEnd("store provided exports into cache");
-										callback(err);
-									}
-								);
-							}
-						);
+				if (schema) {
+					let name = "Loader";
+					let baseDataPath = "options";
+					let match;
+					if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
+						[, name, baseDataPath] = match;
 					}
-				);
+					getValidate()(schema, options, {
+						name,
+						baseDataPath
+					});
+				}
 
-				/** @type {WeakMap<Module, any>} */
-				const providedExportsCache = new WeakMap();
-				compilation.hooks.rebuildModule.tap(
-					"FlagDependencyExportsPlugin",
-					module => {
-						providedExportsCache.set(
-							module,
-							moduleGraph.getExportsInfo(module).getRestoreProvidedData()
-						);
-					}
+				return options;
+			},
+			emitWarning: warning => {
+				if (!(warning instanceof Error)) {
+					warning = new NonErrorEmittedError(warning);
+				}
+				this.addWarning(
+					new ModuleWarning(warning, {
+						from: getCurrentLoaderName()
+					})
 				);
-				compilation.hooks.finishRebuildingModule.tap(
-					"FlagDependencyExportsPlugin",
-					module => {
-						moduleGraph
-							.getExportsInfo(module)
-							.restoreProvided(providedExportsCache.get(module));
+			},
+			emitError: error => {
+				if (!(error instanceof Error)) {
+					error = new NonErrorEmittedError(error);
+				}
+				this.addError(
+					new ModuleError(error, {
+						from: getCurrentLoaderName()
+					})
+				);
+			},
+			getLogger: name => {
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				return compilation.getLogger(() =>
+					[currentLoader && currentLoader.loader, name, this.identifier()]
+						.filter(Boolean)
+						.join("|")
+				);
+			},
+			resolve(context, request, callback) {
+				resolver.resolve({}, context, request, getResolveContext(), callback);
+			},
+			getResolve(options) {
+				const child = options ? resolver.withOptions(options) : resolver;
+				return (context, request, callback) => {
+					if (callback) {
+						child.resolve({}, context, request, getResolveContext(), callback);
+					} else {
+						return new Promise((resolve, reject) => {
+							child.resolve(
+								{},
+								context,
+								request,
+								getResolveContext(),
+								(err, result) => {
+									if (err) reject(err);
+									else resolve(result);
+								}
+							);
+						});
 					}
+				};
+			},
+			emitFile: (name, content, sourceMap, assetInfo) => {
+				if (!this.buildInfo.assets) {
+					this.buildInfo.assets = Object.create(null);
+					this.buildInfo.assetsInfo = new Map();
+				}
+				this.buildInfo.assets[name] = this.createSourceForAsset(
+					options.context,
+					name,
+					content,
+					sourceMap,
+					compilation.compiler.root
 				);
-			}
-		);
-	}
-}
-
-module.exports = FlagDependencyExportsPlugin;
+				this.buildInfo.assetsInfo.set(name, assetInfo);
+			},
+			addBuildDependency: dep => {
+				if (this.buildInfo.buildDependencies === undefined) {
+					this.buildInfo.buildDependencies = new LazySet();
+				}
+				this.buildInfo.buildDependencies.add(dep);
+			},
+			utils,
+			rootContext: options.context,
+			webpack: true,
+			sourceMap: !!this.useSourceMap,
+			mode: options.mode || "production",
+			_module: this,
+			_compilation: compilation,
+			_compiler: compilation.compiler,
+			fs: fs
+		};
 
+		Object.assign(loaderContext, options.loader);
 
-/***/ }),
+		hooks.loader.call(loaderContext, this);
 
-/***/ 58812:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		return loaderContext;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
+		if (
+			this.loaders &&
+			this.loaders.length &&
+			index < this.loaders.length &&
+			index >= 0 &&
+			this.loaders[index]
+		) {
+			return this.loaders[index];
+		}
+		return null;
+	}
 
+	/**
+	 * @param {string} context the compilation context
+	 * @param {string | Buffer} content the content
+	 * @param {string | TODO} sourceMap an optional source map
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @returns {Source} the created source
+	 */
+	createSource(context, content, sourceMap, associatedObjectForCache) {
+		if (Buffer.isBuffer(content)) {
+			return new RawSource(content);
+		}
 
+		// if there is no identifier return raw source
+		if (!this.identifier) {
+			return new RawSource(content);
+		}
 
-const Dependency = __webpack_require__(54912);
-const { UsageState } = __webpack_require__(63686);
-const ModuleGraphConnection = __webpack_require__(40639);
-const { STAGE_DEFAULT } = __webpack_require__(80057);
-const ArrayQueue = __webpack_require__(41792);
-const TupleQueue = __webpack_require__(38415);
-const { getEntryRuntime, mergeRuntimeOwned } = __webpack_require__(17156);
+		// from here on we assume we have an identifier
+		const identifier = this.identifier();
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+		if (this.useSourceMap && sourceMap) {
+			return new SourceMapSource(
+				content,
+				contextifySourceUrl(context, identifier, associatedObjectForCache),
+				contextifySourceMap(context, sourceMap, associatedObjectForCache)
+			);
+		}
 
-const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency;
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			return new OriginalSource(
+				content,
+				contextifySourceUrl(context, identifier, associatedObjectForCache)
+			);
+		}
 
-class FlagDependencyUsagePlugin {
-	/**
-	 * @param {boolean} global do a global analysis instead of per runtime
-	 */
-	constructor(global) {
-		this.global = global;
+		return new RawSource(content);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {NormalModuleCompilationHooks} hooks the hooks
+	 * @param {function((WebpackError | null)=): void} callback callback function
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagDependencyUsagePlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.optimizeDependencies.tap(
-				{
-					name: "FlagDependencyUsagePlugin",
-					stage: STAGE_DEFAULT
-				},
-				modules => {
-					if (compilation.moduleMemCaches) {
-						throw new Error(
-							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
-						);
-					}
+	_doBuild(options, compilation, resolver, fs, hooks, callback) {
+		const loaderContext = this._createLoaderContext(
+			resolver,
+			options,
+			compilation,
+			fs,
+			hooks
+		);
 
-					const logger = compilation.getLogger(
-						"webpack.FlagDependencyUsagePlugin"
-					);
-					/** @type {Map<ExportsInfo, Module>} */
-					const exportInfoToModuleMap = new Map();
+		const processResult = (err, result) => {
+			if (err) {
+				if (!(err instanceof Error)) {
+					err = new NonErrorEmittedError(err);
+				}
+				const currentLoader = this.getCurrentLoader(loaderContext);
+				const error = new ModuleBuildError(err, {
+					from:
+						currentLoader &&
+						compilation.runtimeTemplate.requestShortener.shorten(
+							currentLoader.loader
+						)
+				});
+				return callback(error);
+			}
 
-					/** @type {TupleQueue<[Module, RuntimeSpec]>} */
-					const queue = new TupleQueue();
+			const source = result[0];
+			const sourceMap = result.length >= 1 ? result[1] : null;
+			const extraInfo = result.length >= 2 ? result[2] : null;
 
-					/**
-					 * @param {Module} module module to process
-					 * @param {(string[] | ReferencedExport)[]} usedExports list of used exports
-					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
-					 * @returns {void}
-					 */
-					const processReferencedModule = (
-						module,
-						usedExports,
-						runtime,
-						forceSideEffects
-					) => {
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						if (usedExports.length > 0) {
-							if (!module.buildMeta || !module.buildMeta.exportsType) {
-								if (exportsInfo.setUsedWithoutInfo(runtime)) {
-									queue.enqueue(module, runtime);
-								}
-								return;
-							}
-							for (const usedExportInfo of usedExports) {
-								let usedExport;
-								let canMangle = true;
-								if (Array.isArray(usedExportInfo)) {
-									usedExport = usedExportInfo;
-								} else {
-									usedExport = usedExportInfo.name;
-									canMangle = usedExportInfo.canMangle !== false;
-								}
-								if (usedExport.length === 0) {
-									if (exportsInfo.setUsedInUnknownWay(runtime)) {
-										queue.enqueue(module, runtime);
-									}
-								} else {
-									let currentExportsInfo = exportsInfo;
-									for (let i = 0; i < usedExport.length; i++) {
-										const exportInfo = currentExportsInfo.getExportInfo(
-											usedExport[i]
-										);
-										if (canMangle === false) {
-											exportInfo.canMangleUse = false;
-										}
-										const lastOne = i === usedExport.length - 1;
-										if (!lastOne) {
-											const nestedInfo = exportInfo.getNestedExportsInfo();
-											if (nestedInfo) {
-												if (
-													exportInfo.setUsedConditionally(
-														used => used === UsageState.Unused,
-														UsageState.OnlyPropertiesUsed,
-														runtime
-													)
-												) {
-													const currentModule =
-														currentExportsInfo === exportsInfo
-															? module
-															: exportInfoToModuleMap.get(currentExportsInfo);
-													if (currentModule) {
-														queue.enqueue(currentModule, runtime);
-													}
-												}
-												currentExportsInfo = nestedInfo;
-												continue;
-											}
-										}
-										if (
-											exportInfo.setUsedConditionally(
-												v => v !== UsageState.Used,
-												UsageState.Used,
-												runtime
-											)
-										) {
-											const currentModule =
-												currentExportsInfo === exportsInfo
-													? module
-													: exportInfoToModuleMap.get(currentExportsInfo);
-											if (currentModule) {
-												queue.enqueue(currentModule, runtime);
-											}
-										}
-										break;
-									}
-								}
-							}
-						} else {
-							// for a module without side effects we stop tracking usage here when no export is used
-							// This module won't be evaluated in this case
-							// TODO webpack 6 remove this check
-							if (
-								!forceSideEffects &&
-								module.factoryMeta !== undefined &&
-								module.factoryMeta.sideEffectFree
-							) {
-								return;
-							}
-							if (exportsInfo.setUsedForSideEffectsOnly(runtime)) {
-								queue.enqueue(module, runtime);
-							}
-						}
-					};
-
-					/**
-					 * @param {DependenciesBlock} module the module
-					 * @param {RuntimeSpec} runtime part of which runtime
-					 * @param {boolean} forceSideEffects always apply side effects
-					 * @returns {void}
-					 */
-					const processModule = (module, runtime, forceSideEffects) => {
-						/** @type {Map<Module, (string[] | ReferencedExport)[] | Map<string, string[] | ReferencedExport>>} */
-						const map = new Map();
-
-						/** @type {ArrayQueue<DependenciesBlock>} */
-						const queue = new ArrayQueue();
-						queue.enqueue(module);
-						for (;;) {
-							const block = queue.dequeue();
-							if (block === undefined) break;
-							for (const b of block.blocks) {
-								if (
-									!this.global &&
-									b.groupOptions &&
-									b.groupOptions.entryOptions
-								) {
-									processModule(
-										b,
-										b.groupOptions.entryOptions.runtime || undefined,
-										true
-									);
-								} else {
-									queue.enqueue(b);
-								}
-							}
-							for (const dep of block.dependencies) {
-								const connection = moduleGraph.getConnection(dep);
-								if (!connection || !connection.module) {
-									continue;
-								}
-								const activeState = connection.getActiveState(runtime);
-								if (activeState === false) continue;
-								const { module } = connection;
-								if (activeState === ModuleGraphConnection.TRANSITIVE_ONLY) {
-									processModule(module, runtime, false);
-									continue;
-								}
-								const oldReferencedExports = map.get(module);
-								if (oldReferencedExports === EXPORTS_OBJECT_REFERENCED) {
-									continue;
-								}
-								const referencedExports =
-									compilation.getDependencyReferencedExports(dep, runtime);
-								if (
-									oldReferencedExports === undefined ||
-									oldReferencedExports === NO_EXPORTS_REFERENCED ||
-									referencedExports === EXPORTS_OBJECT_REFERENCED
-								) {
-									map.set(module, referencedExports);
-								} else if (
-									oldReferencedExports !== undefined &&
-									referencedExports === NO_EXPORTS_REFERENCED
-								) {
-									continue;
-								} else {
-									let exportsMap;
-									if (Array.isArray(oldReferencedExports)) {
-										exportsMap = new Map();
-										for (const item of oldReferencedExports) {
-											if (Array.isArray(item)) {
-												exportsMap.set(item.join("\n"), item);
-											} else {
-												exportsMap.set(item.name.join("\n"), item);
-											}
-										}
-										map.set(module, exportsMap);
-									} else {
-										exportsMap = oldReferencedExports;
-									}
-									for (const item of referencedExports) {
-										if (Array.isArray(item)) {
-											const key = item.join("\n");
-											const oldItem = exportsMap.get(key);
-											if (oldItem === undefined) {
-												exportsMap.set(key, item);
-											}
-											// if oldItem is already an array we have to do nothing
-											// if oldItem is an ReferencedExport object, we don't have to do anything
-											// as canMangle defaults to true for arrays
-										} else {
-											const key = item.name.join("\n");
-											const oldItem = exportsMap.get(key);
-											if (oldItem === undefined || Array.isArray(oldItem)) {
-												exportsMap.set(key, item);
-											} else {
-												exportsMap.set(key, {
-													name: item.name,
-													canMangle: item.canMangle && oldItem.canMangle
-												});
-											}
-										}
-									}
-								}
-							}
-						}
-
-						for (const [module, referencedExports] of map) {
-							if (Array.isArray(referencedExports)) {
-								processReferencedModule(
-									module,
-									referencedExports,
-									runtime,
-									forceSideEffects
-								);
-							} else {
-								processReferencedModule(
-									module,
-									Array.from(referencedExports.values()),
-									runtime,
-									forceSideEffects
-								);
-							}
-						}
-					};
-
-					logger.time("initialize exports usage");
-					for (const module of modules) {
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						exportInfoToModuleMap.set(exportsInfo, module);
-						exportsInfo.setHasUseInfo();
-					}
-					logger.timeEnd("initialize exports usage");
-
-					logger.time("trace exports usage in graph");
-
-					/**
-					 * @param {Dependency} dep dependency
-					 * @param {RuntimeSpec} runtime runtime
-					 */
-					const processEntryDependency = (dep, runtime) => {
-						const module = moduleGraph.getModule(dep);
-						if (module) {
-							processReferencedModule(
-								module,
-								NO_EXPORTS_REFERENCED,
-								runtime,
-								true
-							);
-						}
-					};
-					/** @type {RuntimeSpec} */
-					let globalRuntime = undefined;
-					for (const [
-						entryName,
-						{ dependencies: deps, includeDependencies: includeDeps, options }
-					] of compilation.entries) {
-						const runtime = this.global
-							? undefined
-							: getEntryRuntime(compilation, entryName, options);
-						for (const dep of deps) {
-							processEntryDependency(dep, runtime);
-						}
-						for (const dep of includeDeps) {
-							processEntryDependency(dep, runtime);
-						}
-						globalRuntime = mergeRuntimeOwned(globalRuntime, runtime);
-					}
-					for (const dep of compilation.globalEntry.dependencies) {
-						processEntryDependency(dep, globalRuntime);
-					}
-					for (const dep of compilation.globalEntry.includeDependencies) {
-						processEntryDependency(dep, globalRuntime);
-					}
+			if (!Buffer.isBuffer(source) && typeof source !== "string") {
+				const currentLoader = this.getCurrentLoader(loaderContext, 0);
+				const err = new Error(
+					`Final loader (${
+						currentLoader
+							? compilation.runtimeTemplate.requestShortener.shorten(
+									currentLoader.loader
+							  )
+							: "unknown"
+					}) didn't return a Buffer or String`
+				);
+				const error = new ModuleBuildError(err);
+				return callback(error);
+			}
 
-					while (queue.length) {
-						const [module, runtime] = queue.dequeue();
-						processModule(module, runtime, false);
-					}
-					logger.timeEnd("trace exports usage in graph");
-				}
+			this._source = this.createSource(
+				options.context,
+				this.binary ? asBuffer(source) : asString(source),
+				sourceMap,
+				compilation.compiler.root
 			);
-		});
-	}
-}
-
-module.exports = FlagDependencyUsagePlugin;
-
-
-/***/ }),
-
-/***/ 93401:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+			if (this._sourceSizes !== undefined) this._sourceSizes.clear();
+			this._ast =
+				typeof extraInfo === "object" &&
+				extraInfo !== null &&
+				extraInfo.webpackAST !== undefined
+					? extraInfo.webpackAST
+					: null;
+			return callback();
+		};
 
+		this.buildInfo.fileDependencies = new LazySet();
+		this.buildInfo.contextDependencies = new LazySet();
+		this.buildInfo.missingDependencies = new LazySet();
+		this.buildInfo.cacheable = true;
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+		try {
+			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
+		} catch (err) {
+			processResult(err);
+			return;
+		}
 
-/**
- * @typedef {Object} GenerateContext
- * @property {DependencyTemplates} dependencyTemplates mapping from dependencies to templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {Set<string>} runtimeRequirements the requirements for runtime
- * @property {RuntimeSpec} runtime the runtime
- * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults=} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
- * @property {string} type which kind of code should be generated
- * @property {function(): Map<string, any>=} getData get access to the code generation data
- */
+		if (this.loaders.length > 0) {
+			this.buildInfo.buildDependencies = new LazySet();
+		}
 
-/**
- * @typedef {Object} UpdateHashContext
- * @property {NormalModule} module the module
- * @property {ChunkGraph} chunkGraph
- * @property {RuntimeSpec} runtime
- */
+		runLoaders(
+			{
+				resource: this.resource,
+				loaders: this.loaders,
+				context: loaderContext,
+				processResource: (loaderContext, resourcePath, callback) => {
+					const resource = loaderContext.resource;
+					const scheme = getScheme(resource);
+					hooks.readResource
+						.for(scheme)
+						.callAsync(loaderContext, (err, result) => {
+							if (err) return callback(err);
+							if (typeof result !== "string" && !result) {
+								return callback(new UnhandledSchemeError(scheme, resource));
+							}
+							return callback(null, result);
+						});
+				}
+			},
+			(err, result) => {
+				// Cleanup loaderContext to avoid leaking memory in ICs
+				loaderContext._compilation =
+					loaderContext._compiler =
+					loaderContext._module =
+					loaderContext.fs =
+						undefined;
 
-/**
- *
- */
-class Generator {
-	static byType(map) {
-		return new ByTypeGenerator(map);
+				if (!result) {
+					this.buildInfo.cacheable = false;
+					return processResult(
+						err || new Error("No result from loader-runner processing"),
+						null
+					);
+				}
+				this.buildInfo.fileDependencies.addAll(result.fileDependencies);
+				this.buildInfo.contextDependencies.addAll(result.contextDependencies);
+				this.buildInfo.missingDependencies.addAll(result.missingDependencies);
+				for (const loader of this.loaders) {
+					this.buildInfo.buildDependencies.add(loader.loader);
+				}
+				this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
+				processResult(err, result.result);
+			}
+		);
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {WebpackError} error the error
+	 * @returns {void}
 	 */
-	getTypes(module) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	markModuleAsErrored(error) {
+		// Restore build meta from successful build to keep importing state
+		this.buildMeta = { ...this._lastSuccessfulBuildMeta };
+		this.error = error;
+		this.addError(error);
 	}
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+	applyNoParseRule(rule, content) {
+		// must start with "rule" if rule is a string
+		if (typeof rule === "string") {
+			return content.startsWith(rule);
+		}
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(
-		module,
-		{ dependencyTemplates, runtimeTemplate, moduleGraph, type }
-	) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+		if (typeof rule === "function") {
+			return rule(content);
+		}
+		// we assume rule is a regexp
+		return rule.test(content);
 	}
 
-	/**
-	 * @param {NormalModule} module module for which the bailout reason should be determined
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(module, context) {
-		return `Module Concatenation is not implemented for ${this.constructor.name}`;
-	}
+	// check if module should not be parsed
+	// returns "true" if the module should !not! be parsed
+	// returns "false" if the module !must! be parsed
+	shouldPreventParsing(noParseRule, request) {
+		// if no noParseRule exists, return false
+		// the module !must! be parsed.
+		if (!noParseRule) {
+			return false;
+		}
 
-	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
-	 */
-	updateHash(hash, { module, runtime }) {
-		// no nothing
-	}
-}
+		// we only have one rule to check
+		if (!Array.isArray(noParseRule)) {
+			// returns "true" if the module is !not! to be parsed
+			return this.applyNoParseRule(noParseRule, request);
+		}
 
-class ByTypeGenerator extends Generator {
-	constructor(map) {
-		super();
-		this.map = map;
-		this._types = new Set(Object.keys(map));
+		for (let i = 0; i < noParseRule.length; i++) {
+			const rule = noParseRule[i];
+			// early exit on first truthy match
+			// this module is !not! to be parsed
+			if (this.applyNoParseRule(rule, request)) {
+				return true;
+			}
+		}
+		// no match found, so this module !should! be parsed
+		return false;
 	}
 
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return this._types;
+	_initBuildHash(compilation) {
+		const hash = createHash(compilation.outputOptions.hashFunction);
+		if (this._source) {
+			hash.update("source");
+			this._source.updateHash(hash);
+		}
+		hash.update("meta");
+		hash.update(JSON.stringify(this.buildMeta));
+		this.buildInfo.hash = /** @type {string} */ (hash.digest("hex"));
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
 	 */
-	getSize(module, type) {
-		const t = type || "javascript";
-		const generator = this.map[t];
-		return generator ? generator.getSize(module, t) : 0;
-	}
+	build(options, compilation, resolver, fs, callback) {
+		this._forceBuild = false;
+		this._source = null;
+		if (this._sourceSizes !== undefined) this._sourceSizes.clear();
+		this._sourceTypes = undefined;
+		this._ast = null;
+		this.error = null;
+		this.clearWarningsAndErrors();
+		this.clearDependenciesAndBlocks();
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: false,
+			parsed: true,
+			fileDependencies: undefined,
+			contextDependencies: undefined,
+			missingDependencies: undefined,
+			buildDependencies: undefined,
+			valueDependencies: undefined,
+			hash: undefined,
+			assets: undefined,
+			assetsInfo: undefined
+		};
 
-	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(module, generateContext) {
-		const type = generateContext.type;
-		const generator = this.map[type];
-		if (!generator) {
-			throw new Error(`Generator.byType: no generator specified for ${type}`);
-		}
-		return generator.generate(module, generateContext);
-	}
-}
+		const startTime = compilation.compiler.fsStartTime || Date.now();
 
-module.exports = Generator;
+		const hooks = NormalModule.getCompilationHooks(compilation);
 
+		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
+			// if we have an error mark module as failed and exit
+			if (err) {
+				this.markModuleAsErrored(err);
+				this._initBuildHash(compilation);
+				return callback();
+			}
 
-/***/ }),
+			const handleParseError = e => {
+				const source = this._source.source();
+				const loaders = this.loaders.map(item =>
+					contextify(options.context, item.loader, compilation.compiler.root)
+				);
+				const error = new ModuleParseError(source, e, loaders, this.type);
+				this.markModuleAsErrored(error);
+				this._initBuildHash(compilation);
+				return callback();
+			};
 
-/***/ 37234:
-/***/ (function(__unused_webpack_module, exports) {
+			const handleParseResult = result => {
+				this.dependencies.sort(
+					concatComparators(
+						compareSelect(a => a.loc, compareLocations),
+						keepOriginalOrder(this.dependencies)
+					)
+				);
+				this._initBuildHash(compilation);
+				this._lastSuccessfulBuildMeta = this.buildMeta;
+				return handleBuildDone();
+			};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			const handleBuildDone = () => {
+				try {
+					hooks.beforeSnapshot.call(this);
+				} catch (err) {
+					this.markModuleAsErrored(err);
+					return callback();
+				}
 
+				const snapshotOptions = compilation.options.snapshot.module;
+				if (!this.buildInfo.cacheable || !snapshotOptions) {
+					return callback();
+				}
+				// add warning for all non-absolute paths in fileDependencies, etc
+				// This makes it easier to find problems with watching and/or caching
+				let nonAbsoluteDependencies = undefined;
+				const checkDependencies = deps => {
+					for (const dep of deps) {
+						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
+							if (nonAbsoluteDependencies === undefined)
+								nonAbsoluteDependencies = new Set();
+							nonAbsoluteDependencies.add(dep);
+							deps.delete(dep);
+							try {
+								const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, "");
+								const absolute = join(
+									compilation.fileSystemInfo.fs,
+									this.context,
+									depWithoutGlob
+								);
+								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
+									(depWithoutGlob !== dep
+										? this.buildInfo.contextDependencies
+										: deps
+									).add(absolute);
+								}
+							} catch (e) {
+								// ignore
+							}
+						}
+					}
+				};
+				checkDependencies(this.buildInfo.fileDependencies);
+				checkDependencies(this.buildInfo.missingDependencies);
+				checkDependencies(this.buildInfo.contextDependencies);
+				if (nonAbsoluteDependencies !== undefined) {
+					const InvalidDependenciesModuleWarning =
+						getInvalidDependenciesModuleWarning();
+					this.addWarning(
+						new InvalidDependenciesModuleWarning(this, nonAbsoluteDependencies)
+					);
+				}
+				// convert file/context/missingDependencies into filesystem snapshot
+				compilation.fileSystemInfo.createSnapshot(
+					startTime,
+					this.buildInfo.fileDependencies,
+					this.buildInfo.contextDependencies,
+					this.buildInfo.missingDependencies,
+					snapshotOptions,
+					(err, snapshot) => {
+						if (err) {
+							this.markModuleAsErrored(err);
+							return;
+						}
+						this.buildInfo.fileDependencies = undefined;
+						this.buildInfo.contextDependencies = undefined;
+						this.buildInfo.missingDependencies = undefined;
+						this.buildInfo.snapshot = snapshot;
+						return callback();
+					}
+				);
+			};
 
+			try {
+				hooks.beforeParse.call(this);
+			} catch (err) {
+				this.markModuleAsErrored(err);
+				this._initBuildHash(compilation);
+				return callback();
+			}
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Module")} Module */
+			// check if this module should !not! be parsed.
+			// if so, exit here;
+			const noParseRule = options.module && options.module.noParse;
+			if (this.shouldPreventParsing(noParseRule, this.request)) {
+				// We assume that we need module and exports
+				this.buildInfo.parsed = false;
+				this._initBuildHash(compilation);
+				return handleBuildDone();
+			}
 
-/**
- * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
- * @param {Chunk} chunk chunk to tie to ChunkGroup
- * @returns {void}
- */
-const connectChunkGroupAndChunk = (chunkGroup, chunk) => {
-	if (chunkGroup.pushChunk(chunk)) {
-		chunk.addGroup(chunkGroup);
+			let result;
+			try {
+				const source = this._source.source();
+				result = this.parser.parse(this._ast || source, {
+					source,
+					current: this,
+					module: this,
+					compilation: compilation,
+					options: options
+				});
+			} catch (e) {
+				handleParseError(e);
+				return;
+			}
+			handleParseResult(result);
+		});
 	}
-};
 
-/**
- * @param {ChunkGroup} parent parent ChunkGroup to connect
- * @param {ChunkGroup} child child ChunkGroup to connect
- * @returns {void}
- */
-const connectChunkGroupParentAndChild = (parent, child) => {
-	if (parent.addChild(child)) {
-		child.addParent(parent);
+	/**
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(context) {
+		return this.generator.getConcatenationBailoutReason(this, context);
 	}
-};
-
-exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
-exports.connectChunkGroupParentAndChild = connectChunkGroupParentAndChild;
-
-
-/***/ }),
-
-/***/ 97511:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
 
-module.exports = class HarmonyLinkingError extends WebpackError {
-	/** @param {string} message Error message */
-	constructor(message) {
-		super(message);
-		this.name = "HarmonyLinkingError";
-		this.hideStack = true;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		if (this.factoryMeta !== undefined) {
+			if (this.factoryMeta.sideEffectFree) return false;
+			if (this.factoryMeta.sideEffectFree === false) return true;
+		}
+		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
+			if (this._isEvaluatingSideEffects)
+				return ModuleGraphConnection.CIRCULAR_CONNECTION;
+			this._isEvaluatingSideEffects = true;
+			/** @type {ConnectionState} */
+			let current = false;
+			for (const dep of this.dependencies) {
+				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+				if (state === true) {
+					if (
+						this._addedSideEffectsBailout === undefined
+							? ((this._addedSideEffectsBailout = new WeakSet()), true)
+							: !this._addedSideEffectsBailout.has(moduleGraph)
+					) {
+						this._addedSideEffectsBailout.add(moduleGraph);
+						moduleGraph
+							.getOptimizationBailout(this)
+							.push(
+								() =>
+									`Dependency (${
+										dep.type
+									}) with side effects at ${formatLocation(dep.loc)}`
+							);
+					}
+					this._isEvaluatingSideEffects = false;
+					return true;
+				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+					current = ModuleGraphConnection.addConnectionStates(current, state);
+				}
+			}
+			this._isEvaluatingSideEffects = false;
+			// When caching is implemented here, make sure to not cache when
+			// at least one circular connection was in the loop above
+			return current;
+		} else {
+			return true;
+		}
 	}
-};
 
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		if (this._sourceTypes === undefined) {
+			this._sourceTypes = this.generator.getTypes(this);
+		}
+		return this._sourceTypes;
+	}
 
-/***/ }),
-
-/***/ 11351:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({
+		dependencyTemplates,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime,
+		concatenationScope,
+		codeGenerationResults
+	}) {
+		/** @type {Set<string>} */
+		const runtimeRequirements = new Set();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
+		if (!this.buildInfo.parsed) {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+		}
 
+		/** @type {Map<string, any>} */
+		let data;
+		const getData = () => {
+			if (data === undefined) data = new Map();
+			return data;
+		};
 
+		const sources = new Map();
+		for (const type of this.generator.getTypes(this)) {
+			const source = this.error
+				? new RawSource(
+						"throw new Error(" + JSON.stringify(this.error.message) + ");"
+				  )
+				: this.generator.generate(this, {
+						dependencyTemplates,
+						runtimeTemplate,
+						moduleGraph,
+						chunkGraph,
+						runtimeRequirements,
+						runtime,
+						concatenationScope,
+						codeGenerationResults,
+						getData,
+						type
+				  });
 
-const WebpackError = __webpack_require__(53799);
+			if (source) {
+				sources.set(type, new CachedSource(source));
+			}
+		}
 
-/** @typedef {import("./Module")} Module */
+		/** @type {CodeGenerationResult} */
+		const resultEntry = {
+			sources,
+			runtimeRequirements,
+			data
+		};
+		return resultEntry;
+	}
 
-/**
- * @template T
- * @callback Callback
- * @param {Error=} err
- * @param {T=} stats
- * @returns {void}
- */
+	/**
+	 * @returns {Source | null} the original source for the module before webpack transformation
+	 */
+	originalSource() {
+		return this._source;
+	}
 
-class HookWebpackError extends WebpackError {
 	/**
-	 * Creates an instance of HookWebpackError.
-	 * @param {Error} error inner error
-	 * @param {string} hook name of hook
+	 * @returns {void}
 	 */
-	constructor(error, hook) {
-		super(error.message);
+	invalidateBuild() {
+		this._forceBuild = true;
+	}
 
-		this.name = "HookWebpackError";
-		this.hook = hook;
-		this.error = error;
-		this.hideStack = true;
-		this.details = `caused by plugins in ${hook}\n${error.stack}`;
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		const { fileSystemInfo, compilation, valueCacheVersions } = context;
+		// build if enforced
+		if (this._forceBuild) return callback(null, true);
 
-		this.stack += `\n-- inner error --\n${error.stack}`;
-	}
-}
+		// always try to build in case of an error
+		if (this.error) return callback(null, true);
 
-module.exports = HookWebpackError;
+		// always build when module is not cacheable
+		if (!this.buildInfo.cacheable) return callback(null, true);
 
-/**
- * @param {Error} error an error
- * @param {string} hook name of the hook
- * @returns {WebpackError} a webpack error
- */
-const makeWebpackError = (error, hook) => {
-	if (error instanceof WebpackError) return error;
-	return new HookWebpackError(error, hook);
-};
-module.exports.makeWebpackError = makeWebpackError;
+		// build when there is no snapshot to check
+		if (!this.buildInfo.snapshot) return callback(null, true);
 
-/**
- * @template T
- * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
- * @param {string} hook name of hook
- * @returns {Callback<T>} generic callback
- */
-const makeWebpackErrorCallback = (callback, hook) => {
-	return (err, result) => {
-		if (err) {
-			if (err instanceof WebpackError) {
-				callback(err);
-				return;
+		// build when valueDependencies have changed
+		/** @type {Map<string, string | Set<string>>} */
+		const valueDependencies = this.buildInfo.valueDependencies;
+		if (valueDependencies) {
+			if (!valueCacheVersions) return callback(null, true);
+			for (const [key, value] of valueDependencies) {
+				if (value === undefined) return callback(null, true);
+				const current = valueCacheVersions.get(key);
+				if (
+					value !== current &&
+					(typeof value === "string" ||
+						typeof current === "string" ||
+						current === undefined ||
+						!isSubset(value, current))
+				) {
+					return callback(null, true);
+				}
 			}
-			callback(new HookWebpackError(err, hook));
-			return;
 		}
-		callback(null, result);
-	};
-};
 
-module.exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
+		// check snapshot for validity
+		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+			if (err) return callback(err);
+			if (!valid) return callback(null, true);
+			const hooks = NormalModule.getCompilationHooks(compilation);
+			hooks.needBuild.callAsync(this, context, (err, needBuild) => {
+				if (err) {
+					return callback(
+						HookWebpackError.makeWebpackError(
+							err,
+							"NormalModule.getCompilationHooks().needBuild"
+						)
+					);
+				}
+				callback(null, !!needBuild);
+			});
+		});
+	}
 
-/**
- * @template T
- * @param {function(): T} fn function which will be wrapping in try catch
- * @param {string} hook name of hook
- * @returns {T} the result
- */
-const tryRunOrWebpackError = (fn, hook) => {
-	let r;
-	try {
-		r = fn();
-	} catch (err) {
-		if (err instanceof WebpackError) {
-			throw err;
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		const cachedSize =
+			this._sourceSizes === undefined ? undefined : this._sourceSizes.get(type);
+		if (cachedSize !== undefined) {
+			return cachedSize;
 		}
-		throw new HookWebpackError(err, hook);
+		const size = Math.max(1, this.generator.getSize(this, type));
+		if (this._sourceSizes === undefined) {
+			this._sourceSizes = new Map();
+		}
+		this._sourceSizes.set(type, size);
+		return size;
 	}
-	return r;
-};
-
-module.exports.tryRunOrWebpackError = tryRunOrWebpackError;
-
-
-/***/ }),
-
-/***/ 6404:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
-
-const { SyncBailHook } = __webpack_require__(41242);
-const { RawSource } = __webpack_require__(51255);
-const ChunkGraph = __webpack_require__(64971);
-const Compilation = __webpack_require__(85720);
-const HotUpdateChunk = __webpack_require__(9597);
-const NormalModule = __webpack_require__(39);
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const ConstDependency = __webpack_require__(76911);
-const ImportMetaHotAcceptDependency = __webpack_require__(51274);
-const ImportMetaHotDeclineDependency = __webpack_require__(53141);
-const ModuleHotAcceptDependency = __webpack_require__(47511);
-const ModuleHotDeclineDependency = __webpack_require__(86301);
-const HotModuleReplacementRuntimeModule = __webpack_require__(27899);
-const JavascriptParser = __webpack_require__(29050);
-const {
-	evaluateToIdentifier
-} = __webpack_require__(93998);
-const { find, isSubset } = __webpack_require__(93347);
-const TupleSet = __webpack_require__(76455);
-const { compareModulesById } = __webpack_require__(29579);
-const {
-	getRuntimeKey,
-	keyToRuntime,
-	forEachRuntime,
-	mergeRuntimeOwned,
-	subtractRuntime,
-	intersectRuntime
-} = __webpack_require__(17156);
-
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
-/**
- * @typedef {Object} HMRJavascriptParserHooks
- * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptCallback
- * @property {SyncBailHook<[TODO, string[]], void>} hotAcceptWithoutCallback
- */
-
-/** @type {WeakMap<JavascriptParser, HMRJavascriptParserHooks>} */
-const parserHooksMap = new WeakMap();
-
-class HotModuleReplacementPlugin {
 	/**
-	 * @param {JavascriptParser} parser the parser
-	 * @returns {HMRJavascriptParserHooks} the attached hooks
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
 	 */
-	static getParserHooks(parser) {
-		if (!(parser instanceof JavascriptParser)) {
-			throw new TypeError(
-				"The 'parser' argument must be an instance of JavascriptParser"
-			);
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {
+		const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
+		if (snapshot) {
+			fileDependencies.addAll(snapshot.getFileIterable());
+			contextDependencies.addAll(snapshot.getContextIterable());
+			missingDependencies.addAll(snapshot.getMissingIterable());
+		} else {
+			const {
+				fileDependencies: fileDeps,
+				contextDependencies: contextDeps,
+				missingDependencies: missingDeps
+			} = this.buildInfo;
+			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
+			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
+			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
 		}
-		let hooks = parserHooksMap.get(parser);
-		if (hooks === undefined) {
-			hooks = {
-				hotAcceptCallback: new SyncBailHook(["expression", "requests"]),
-				hotAcceptWithoutCallback: new SyncBailHook(["expression", "requests"])
-			};
-			parserHooksMap.set(parser, hooks);
+		if (buildDeps !== undefined) {
+			buildDependencies.addAll(buildDeps);
 		}
-		return hooks;
-	}
-
-	constructor(options) {
-		this.options = options || {};
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		const { _backCompat: backCompat } = compiler;
-		if (compiler.options.output.strictModuleErrorHandling === undefined)
-			compiler.options.output.strictModuleErrorHandling = true;
-		const runtimeRequirements = [RuntimeGlobals.module];
+	updateHash(hash, context) {
+		hash.update(this.buildInfo.hash);
+		this.generator.updateHash(hash, {
+			module: this,
+			...context
+		});
+		super.updateHash(hash, context);
+	}
 
-		const createAcceptHandler = (parser, ParamDependency) => {
-			const { hotAcceptCallback, hotAcceptWithoutCallback } =
-				HotModuleReplacementPlugin.getParserHooks(parser);
+	serialize(context) {
+		const { write } = context;
+		// deserialize
+		write(this._source);
+		write(this.error);
+		write(this._lastSuccessfulBuildMeta);
+		write(this._forceBuild);
+		super.serialize(context);
+	}
 
-			return expr => {
-				const module = parser.state.module;
-				const dep = new ConstDependency(
-					`${module.moduleArgument}.hot.accept`,
-					expr.callee.range,
-					runtimeRequirements
-				);
-				dep.loc = expr.loc;
-				module.addPresentationalDependency(dep);
-				module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
-				if (expr.arguments.length >= 1) {
-					const arg = parser.evaluateExpression(expr.arguments[0]);
-					let params = [];
-					let requests = [];
-					if (arg.isString()) {
-						params = [arg];
-					} else if (arg.isArray()) {
-						params = arg.items.filter(param => param.isString());
-					}
-					if (params.length > 0) {
-						params.forEach((param, idx) => {
-							const request = param.string;
-							const dep = new ParamDependency(request, param.range);
-							dep.optional = true;
-							dep.loc = Object.create(expr.loc);
-							dep.loc.index = idx;
-							module.addDependency(dep);
-							requests.push(request);
-						});
-						if (expr.arguments.length > 1) {
-							hotAcceptCallback.call(expr.arguments[1], requests);
-							for (let i = 1; i < expr.arguments.length; i++) {
-								parser.walkExpression(expr.arguments[i]);
-							}
-							return true;
-						} else {
-							hotAcceptWithoutCallback.call(expr, requests);
-							return true;
-						}
-					}
-				}
-				parser.walkExpressions(expr.arguments);
-				return true;
-			};
-		};
+	static deserialize(context) {
+		const obj = new NormalModule({
+			// will be deserialized by Module
+			layer: null,
+			type: "",
+			// will be filled by updateCacheModule
+			resource: "",
+			context: "",
+			request: null,
+			userRequest: null,
+			rawRequest: null,
+			loaders: null,
+			matchResource: null,
+			parser: null,
+			parserOptions: null,
+			generator: null,
+			generatorOptions: null,
+			resolveOptions: null
+		});
+		obj.deserialize(context);
+		return obj;
+	}
 
-		const createDeclineHandler = (parser, ParamDependency) => expr => {
-			const module = parser.state.module;
-			const dep = new ConstDependency(
-				`${module.moduleArgument}.hot.decline`,
-				expr.callee.range,
-				runtimeRequirements
-			);
-			dep.loc = expr.loc;
-			module.addPresentationalDependency(dep);
-			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
-			if (expr.arguments.length === 1) {
-				const arg = parser.evaluateExpression(expr.arguments[0]);
-				let params = [];
-				if (arg.isString()) {
-					params = [arg];
-				} else if (arg.isArray()) {
-					params = arg.items.filter(param => param.isString());
-				}
-				params.forEach((param, idx) => {
-					const dep = new ParamDependency(param.string, param.range);
-					dep.optional = true;
-					dep.loc = Object.create(expr.loc);
-					dep.loc.index = idx;
-					module.addDependency(dep);
-				});
-			}
-			return true;
-		};
+	deserialize(context) {
+		const { read } = context;
+		this._source = read();
+		this.error = read();
+		this._lastSuccessfulBuildMeta = read();
+		this._forceBuild = read();
+		super.deserialize(context);
+	}
+}
 
-		const createHMRExpressionHandler = parser => expr => {
-			const module = parser.state.module;
-			const dep = new ConstDependency(
-				`${module.moduleArgument}.hot`,
-				expr.range,
-				runtimeRequirements
-			);
-			dep.loc = expr.loc;
-			module.addPresentationalDependency(dep);
-			module.buildInfo.moduleConcatenationBailout = "Hot Module Replacement";
-			return true;
-		};
+makeSerializable(NormalModule, "webpack/lib/NormalModule");
 
-		const applyModuleHot = parser => {
-			parser.hooks.evaluateIdentifier.for("module.hot").tap(
-				{
-					name: "HotModuleReplacementPlugin",
-					before: "NodeStuffPlugin"
-				},
-				expr => {
-					return evaluateToIdentifier(
-						"module.hot",
-						"module",
-						() => ["hot"],
-						true
-					)(expr);
-				}
-			);
-			parser.hooks.call
-				.for("module.hot.accept")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createAcceptHandler(parser, ModuleHotAcceptDependency)
-				);
-			parser.hooks.call
-				.for("module.hot.decline")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createDeclineHandler(parser, ModuleHotDeclineDependency)
-				);
-			parser.hooks.expression
-				.for("module.hot")
-				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
-		};
+module.exports = NormalModule;
 
-		const applyImportMetaHot = parser => {
-			parser.hooks.evaluateIdentifier
-				.for("import.meta.webpackHot")
-				.tap("HotModuleReplacementPlugin", expr => {
-					return evaluateToIdentifier(
-						"import.meta.webpackHot",
-						"import.meta",
-						() => ["webpackHot"],
-						true
-					)(expr);
-				});
-			parser.hooks.call
-				.for("import.meta.webpackHot.accept")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createAcceptHandler(parser, ImportMetaHotAcceptDependency)
-				);
-			parser.hooks.call
-				.for("import.meta.webpackHot.decline")
-				.tap(
-					"HotModuleReplacementPlugin",
-					createDeclineHandler(parser, ImportMetaHotDeclineDependency)
-				);
-			parser.hooks.expression
-				.for("import.meta.webpackHot")
-				.tap("HotModuleReplacementPlugin", createHMRExpressionHandler(parser));
-		};
 
-		compiler.hooks.compilation.tap(
-			"HotModuleReplacementPlugin",
-			(compilation, { normalModuleFactory }) => {
-				// This applies the HMR plugin only to the targeted compiler
-				// It should not affect child compilations
-				if (compilation.compiler !== compiler) return;
+/***/ }),
 
-				//#region module.hot.* API
-				compilation.dependencyFactories.set(
-					ModuleHotAcceptDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ModuleHotAcceptDependency,
-					new ModuleHotAcceptDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					ModuleHotDeclineDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ModuleHotDeclineDependency,
-					new ModuleHotDeclineDependency.Template()
-				);
-				//#endregion
+/***/ 68860:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				//#region import.meta.webpackHot.* API
-				compilation.dependencyFactories.set(
-					ImportMetaHotAcceptDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportMetaHotAcceptDependency,
-					new ImportMetaHotAcceptDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					ImportMetaHotDeclineDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportMetaHotDeclineDependency,
-					new ImportMetaHotDeclineDependency.Template()
-				);
-				//#endregion
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				let hotIndex = 0;
-				const fullHashChunkModuleHashes = {};
-				const chunkModuleHashes = {};
 
-				compilation.hooks.record.tap(
-					"HotModuleReplacementPlugin",
-					(compilation, records) => {
-						if (records.hash === compilation.hash) return;
-						const chunkGraph = compilation.chunkGraph;
-						records.hash = compilation.hash;
-						records.hotIndex = hotIndex;
-						records.fullHashChunkModuleHashes = fullHashChunkModuleHashes;
-						records.chunkModuleHashes = chunkModuleHashes;
-						records.chunkHashes = {};
-						records.chunkRuntime = {};
-						for (const chunk of compilation.chunks) {
-							records.chunkHashes[chunk.id] = chunk.hash;
-							records.chunkRuntime[chunk.id] = getRuntimeKey(chunk.runtime);
-						}
-						records.chunkModuleIds = {};
-						for (const chunk of compilation.chunks) {
-							records.chunkModuleIds[chunk.id] = Array.from(
-								chunkGraph.getOrderedChunkModulesIterable(
-									chunk,
-									compareModulesById(chunkGraph)
-								),
-								m => chunkGraph.getModuleId(m)
-							);
-						}
-					}
-				);
-				/** @type {TupleSet<[Module, Chunk]>} */
-				const updatedModules = new TupleSet();
-				/** @type {TupleSet<[Module, Chunk]>} */
-				const fullHashModules = new TupleSet();
-				/** @type {TupleSet<[Module, RuntimeSpec]>} */
-				const nonCodeGeneratedModules = new TupleSet();
-				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
-					const chunkGraph = compilation.chunkGraph;
-					const records = compilation.records;
-					for (const chunk of compilation.chunks) {
-						const getModuleHash = module => {
-							if (
-								compilation.codeGenerationResults.has(module, chunk.runtime)
-							) {
-								return compilation.codeGenerationResults.getHash(
-									module,
-									chunk.runtime
-								);
-							} else {
-								nonCodeGeneratedModules.add(module, chunk.runtime);
-								return chunkGraph.getModuleHash(module, chunk.runtime);
-							}
-						};
-						const fullHashModulesInThisChunk =
-							chunkGraph.getChunkFullHashModulesSet(chunk);
-						if (fullHashModulesInThisChunk !== undefined) {
-							for (const module of fullHashModulesInThisChunk) {
-								fullHashModules.add(module, chunk);
-							}
-						}
-						const modules = chunkGraph.getChunkModulesIterable(chunk);
-						if (modules !== undefined) {
-							if (records.chunkModuleHashes) {
-								if (fullHashModulesInThisChunk !== undefined) {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (
-											fullHashModulesInThisChunk.has(
-												/** @type {RuntimeModule} */ (module)
-											)
-										) {
-											if (records.fullHashChunkModuleHashes[key] !== hash) {
-												updatedModules.add(module, chunk);
-											}
-											fullHashChunkModuleHashes[key] = hash;
-										} else {
-											if (records.chunkModuleHashes[key] !== hash) {
-												updatedModules.add(module, chunk);
-											}
-											chunkModuleHashes[key] = hash;
-										}
-									}
-								} else {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (records.chunkModuleHashes[key] !== hash) {
-											updatedModules.add(module, chunk);
-										}
-										chunkModuleHashes[key] = hash;
-									}
-								}
-							} else {
-								if (fullHashModulesInThisChunk !== undefined) {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										if (
-											fullHashModulesInThisChunk.has(
-												/** @type {RuntimeModule} */ (module)
-											)
-										) {
-											fullHashChunkModuleHashes[key] = hash;
-										} else {
-											chunkModuleHashes[key] = hash;
-										}
-									}
-								} else {
-									for (const module of modules) {
-										const key = `${chunk.id}|${module.identifier()}`;
-										const hash = getModuleHash(module);
-										chunkModuleHashes[key] = hash;
-									}
-								}
-							}
-						}
-					}
 
-					hotIndex = records.hotIndex || 0;
-					if (updatedModules.size > 0) hotIndex++;
+const { getContext } = __webpack_require__(8255);
+const asyncLib = __webpack_require__(78175);
+const {
+	AsyncSeriesBailHook,
+	SyncWaterfallHook,
+	SyncBailHook,
+	SyncHook,
+	HookMap
+} = __webpack_require__(6967);
+const ChunkGraph = __webpack_require__(64971);
+const Module = __webpack_require__(73208);
+const ModuleFactory = __webpack_require__(51010);
+const ModuleGraph = __webpack_require__(99988);
+const NormalModule = __webpack_require__(39);
+const BasicEffectRulePlugin = __webpack_require__(30318);
+const BasicMatcherRulePlugin = __webpack_require__(94215);
+const ObjectMatcherRulePlugin = __webpack_require__(72021);
+const RuleSetCompiler = __webpack_require__(83349);
+const UseEffectRulePlugin = __webpack_require__(84977);
+const LazySet = __webpack_require__(38938);
+const { getScheme } = __webpack_require__(54500);
+const { cachedCleverMerge, cachedSetProperty } = __webpack_require__(60839);
+const { join } = __webpack_require__(17139);
+const { parseResource } = __webpack_require__(82186);
 
-					hash.update(`${hotIndex}`);
-				});
-				compilation.hooks.processAssets.tap(
-					{
-						name: "HotModuleReplacementPlugin",
-						stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
-					},
-					() => {
-						const chunkGraph = compilation.chunkGraph;
-						const records = compilation.records;
-						if (records.hash === compilation.hash) return;
-						if (
-							!records.chunkModuleHashes ||
-							!records.chunkHashes ||
-							!records.chunkModuleIds
-						) {
-							return;
-						}
-						for (const [module, chunk] of fullHashModules) {
-							const key = `${chunk.id}|${module.identifier()}`;
-							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
-								? chunkGraph.getModuleHash(module, chunk.runtime)
-								: compilation.codeGenerationResults.getHash(
-										module,
-										chunk.runtime
-								  );
-							if (records.chunkModuleHashes[key] !== hash) {
-								updatedModules.add(module, chunk);
-							}
-							chunkModuleHashes[key] = hash;
-						}
-
-						/** @type {Map<string, { updatedChunkIds: Set<string|number>, removedChunkIds: Set<string|number>, removedModules: Set<Module>, filename: string, assetInfo: AssetInfo }>} */
-						const hotUpdateMainContentByRuntime = new Map();
-						let allOldRuntime;
-						for (const key of Object.keys(records.chunkRuntime)) {
-							const runtime = keyToRuntime(records.chunkRuntime[key]);
-							allOldRuntime = mergeRuntimeOwned(allOldRuntime, runtime);
-						}
-						forEachRuntime(allOldRuntime, runtime => {
-							const { path: filename, info: assetInfo } =
-								compilation.getPathWithInfo(
-									compilation.outputOptions.hotUpdateMainFilename,
-									{
-										hash: records.hash,
-										runtime
-									}
-								);
-							hotUpdateMainContentByRuntime.set(runtime, {
-								updatedChunkIds: new Set(),
-								removedChunkIds: new Set(),
-								removedModules: new Set(),
-								filename,
-								assetInfo
-							});
-						});
-						if (hotUpdateMainContentByRuntime.size === 0) return;
-
-						// Create a list of all active modules to verify which modules are removed completely
-						/** @type {Map<number|string, Module>} */
-						const allModules = new Map();
-						for (const module of compilation.modules) {
-							const id = chunkGraph.getModuleId(module);
-							allModules.set(id, module);
-						}
-
-						// List of completely removed modules
-						/** @type {Set<string | number>} */
-						const completelyRemovedModules = new Set();
+/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./Parser")} Parser */
+/** @typedef {import("./ResolverFactory")} ResolverFactory */
+/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
-						for (const key of Object.keys(records.chunkHashes)) {
-							const oldRuntime = keyToRuntime(records.chunkRuntime[key]);
-							/** @type {Module[]} */
-							const remainingModules = [];
-							// Check which modules are removed
-							for (const id of records.chunkModuleIds[key]) {
-								const module = allModules.get(id);
-								if (module === undefined) {
-									completelyRemovedModules.add(id);
-								} else {
-									remainingModules.push(module);
-								}
-							}
+/**
+ * @typedef {Object} ResolveData
+ * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
+ * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
+ * @property {string} context
+ * @property {string} request
+ * @property {Record<string, any> | undefined} assertions
+ * @property {ModuleDependency[]} dependencies
+ * @property {string} dependencyType
+ * @property {Object} createData
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {boolean} cacheable allow to use the unsafe cache
+ */
 
-							let chunkId;
-							let newModules;
-							let newRuntimeModules;
-							let newFullHashModules;
-							let newDependentHashModules;
-							let newRuntime;
-							let removedFromRuntime;
-							const currentChunk = find(
-								compilation.chunks,
-								chunk => `${chunk.id}` === key
-							);
-							if (currentChunk) {
-								chunkId = currentChunk.id;
-								newRuntime = intersectRuntime(
-									currentChunk.runtime,
-									allOldRuntime
-								);
-								if (newRuntime === undefined) continue;
-								newModules = chunkGraph
-									.getChunkModules(currentChunk)
-									.filter(module => updatedModules.has(module, currentChunk));
-								newRuntimeModules = Array.from(
-									chunkGraph.getChunkRuntimeModulesIterable(currentChunk)
-								).filter(module => updatedModules.has(module, currentChunk));
-								const fullHashModules =
-									chunkGraph.getChunkFullHashModulesIterable(currentChunk);
-								newFullHashModules =
-									fullHashModules &&
-									Array.from(fullHashModules).filter(module =>
-										updatedModules.has(module, currentChunk)
-									);
-								const dependentHashModules =
-									chunkGraph.getChunkDependentHashModulesIterable(currentChunk);
-								newDependentHashModules =
-									dependentHashModules &&
-									Array.from(dependentHashModules).filter(module =>
-										updatedModules.has(module, currentChunk)
-									);
-								removedFromRuntime = subtractRuntime(oldRuntime, newRuntime);
-							} else {
-								// chunk has completely removed
-								chunkId = `${+key}` === key ? +key : key;
-								removedFromRuntime = oldRuntime;
-								newRuntime = oldRuntime;
-							}
-							if (removedFromRuntime) {
-								// chunk was removed from some runtimes
-								forEachRuntime(removedFromRuntime, runtime => {
-									hotUpdateMainContentByRuntime
-										.get(runtime)
-										.removedChunkIds.add(chunkId);
-								});
-								// dispose modules from the chunk in these runtimes
-								// where they are no longer in this runtime
-								for (const module of remainingModules) {
-									const moduleKey = `${key}|${module.identifier()}`;
-									const oldHash = records.chunkModuleHashes[moduleKey];
-									const runtimes = chunkGraph.getModuleRuntimes(module);
-									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
-										// Module is still in the same runtime combination
-										const hash = nonCodeGeneratedModules.has(module, newRuntime)
-											? chunkGraph.getModuleHash(module, newRuntime)
-											: compilation.codeGenerationResults.getHash(
-													module,
-													newRuntime
-											  );
-										if (hash !== oldHash) {
-											if (module.type === "runtime") {
-												newRuntimeModules = newRuntimeModules || [];
-												newRuntimeModules.push(
-													/** @type {RuntimeModule} */ (module)
-												);
-											} else {
-												newModules = newModules || [];
-												newModules.push(module);
-											}
-										}
-									} else {
-										// module is no longer in this runtime combination
-										// We (incorrectly) assume that it's not in an overlapping runtime combination
-										// and dispose it from the main runtimes the chunk was removed from
-										forEachRuntime(removedFromRuntime, runtime => {
-											// If the module is still used in this runtime, do not dispose it
-											// This could create a bad runtime state where the module is still loaded,
-											// but no chunk which contains it. This means we don't receive further HMR updates
-											// to this module and that's bad.
-											// TODO force load one of the chunks which contains the module
-											for (const moduleRuntime of runtimes) {
-												if (typeof moduleRuntime === "string") {
-													if (moduleRuntime === runtime) return;
-												} else if (moduleRuntime !== undefined) {
-													if (moduleRuntime.has(runtime)) return;
-												}
-											}
-											hotUpdateMainContentByRuntime
-												.get(runtime)
-												.removedModules.add(module);
-										});
-									}
-								}
-							}
-							if (
-								(newModules && newModules.length > 0) ||
-								(newRuntimeModules && newRuntimeModules.length > 0)
-							) {
-								const hotUpdateChunk = new HotUpdateChunk();
-								if (backCompat)
-									ChunkGraph.setChunkGraphForChunk(hotUpdateChunk, chunkGraph);
-								hotUpdateChunk.id = chunkId;
-								hotUpdateChunk.runtime = newRuntime;
-								if (currentChunk) {
-									for (const group of currentChunk.groupsIterable)
-										hotUpdateChunk.addGroup(group);
-								}
-								chunkGraph.attachModules(hotUpdateChunk, newModules || []);
-								chunkGraph.attachRuntimeModules(
-									hotUpdateChunk,
-									newRuntimeModules || []
-								);
-								if (newFullHashModules) {
-									chunkGraph.attachFullHashModules(
-										hotUpdateChunk,
-										newFullHashModules
-									);
-								}
-								if (newDependentHashModules) {
-									chunkGraph.attachDependentHashModules(
-										hotUpdateChunk,
-										newDependentHashModules
-									);
-								}
-								const renderManifest = compilation.getRenderManifest({
-									chunk: hotUpdateChunk,
-									hash: records.hash,
-									fullHash: records.hash,
-									outputOptions: compilation.outputOptions,
-									moduleTemplates: compilation.moduleTemplates,
-									dependencyTemplates: compilation.dependencyTemplates,
-									codeGenerationResults: compilation.codeGenerationResults,
-									runtimeTemplate: compilation.runtimeTemplate,
-									moduleGraph: compilation.moduleGraph,
-									chunkGraph
-								});
-								for (const entry of renderManifest) {
-									/** @type {string} */
-									let filename;
-									/** @type {AssetInfo} */
-									let assetInfo;
-									if ("filename" in entry) {
-										filename = entry.filename;
-										assetInfo = entry.info;
-									} else {
-										({ path: filename, info: assetInfo } =
-											compilation.getPathWithInfo(
-												entry.filenameTemplate,
-												entry.pathOptions
-											));
-									}
-									const source = entry.render();
-									compilation.additionalChunkAssets.push(filename);
-									compilation.emitAsset(filename, source, {
-										hotModuleReplacement: true,
-										...assetInfo
-									});
-									if (currentChunk) {
-										currentChunk.files.add(filename);
-										compilation.hooks.chunkAsset.call(currentChunk, filename);
-									}
-								}
-								forEachRuntime(newRuntime, runtime => {
-									hotUpdateMainContentByRuntime
-										.get(runtime)
-										.updatedChunkIds.add(chunkId);
-								});
-							}
-						}
-						const completelyRemovedModulesArray = Array.from(
-							completelyRemovedModules
-						);
-						const hotUpdateMainContentByFilename = new Map();
-						for (const {
-							removedChunkIds,
-							removedModules,
-							updatedChunkIds,
-							filename,
-							assetInfo
-						} of hotUpdateMainContentByRuntime.values()) {
-							const old = hotUpdateMainContentByFilename.get(filename);
-							if (
-								old &&
-								(!isSubset(old.removedChunkIds, removedChunkIds) ||
-									!isSubset(old.removedModules, removedModules) ||
-									!isSubset(old.updatedChunkIds, updatedChunkIds))
-							) {
-								compilation.warnings.push(
-									new WebpackError(`HotModuleReplacementPlugin
-The configured output.hotUpdateMainFilename doesn't lead to unique filenames per runtime and HMR update differs between runtimes.
-This might lead to incorrect runtime behavior of the applied update.
-To fix this, make sure to include [runtime] in the output.hotUpdateMainFilename option, or use the default config.`)
-								);
-								for (const chunkId of removedChunkIds)
-									old.removedChunkIds.add(chunkId);
-								for (const chunkId of removedModules)
-									old.removedModules.add(chunkId);
-								for (const chunkId of updatedChunkIds)
-									old.updatedChunkIds.add(chunkId);
-								continue;
-							}
-							hotUpdateMainContentByFilename.set(filename, {
-								removedChunkIds,
-								removedModules,
-								updatedChunkIds,
-								assetInfo
-							});
-						}
-						for (const [
-							filename,
-							{ removedChunkIds, removedModules, updatedChunkIds, assetInfo }
-						] of hotUpdateMainContentByFilename) {
-							const hotUpdateMainJson = {
-								c: Array.from(updatedChunkIds),
-								r: Array.from(removedChunkIds),
-								m:
-									removedModules.size === 0
-										? completelyRemovedModulesArray
-										: completelyRemovedModulesArray.concat(
-												Array.from(removedModules, m =>
-													chunkGraph.getModuleId(m)
-												)
-										  )
-							};
+/**
+ * @typedef {Object} ResourceData
+ * @property {string} resource
+ * @property {string} path
+ * @property {string} query
+ * @property {string} fragment
+ * @property {string=} context
+ */
 
-							const source = new RawSource(JSON.stringify(hotUpdateMainJson));
-							compilation.emitAsset(filename, source, {
-								hotModuleReplacement: true,
-								...assetInfo
-							});
-						}
-					}
-				);
+/** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
 
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"HotModuleReplacementPlugin",
-					(chunk, runtimeRequirements) => {
-						runtimeRequirements.add(RuntimeGlobals.hmrDownloadManifest);
-						runtimeRequirements.add(RuntimeGlobals.hmrDownloadUpdateHandlers);
-						runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
-						runtimeRequirements.add(RuntimeGlobals.moduleCache);
-						compilation.addRuntimeModule(
-							chunk,
-							new HotModuleReplacementRuntimeModule()
-						);
-					}
-				);
+const EMPTY_RESOLVE_OPTIONS = {};
+const EMPTY_PARSER_OPTIONS = {};
+const EMPTY_GENERATOR_OPTIONS = {};
+const EMPTY_ELEMENTS = [];
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("HotModuleReplacementPlugin", parser => {
-						applyModuleHot(parser);
-						applyImportMetaHot(parser);
-					});
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("HotModuleReplacementPlugin", parser => {
-						applyModuleHot(parser);
-					});
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("HotModuleReplacementPlugin", parser => {
-						applyImportMetaHot(parser);
-					});
+const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
 
-				NormalModule.getCompilationHooks(compilation).loader.tap(
-					"HotModuleReplacementPlugin",
-					context => {
-						context.hot = true;
-					}
-				);
-			}
-		);
+const loaderToIdent = data => {
+	if (!data.options) {
+		return data.loader;
 	}
-}
-
-module.exports = HotModuleReplacementPlugin;
-
-
-/***/ }),
-
-/***/ 9597:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Chunk = __webpack_require__(39385);
-
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./util/Hash")} Hash */
-
-class HotUpdateChunk extends Chunk {
-	constructor() {
-		super();
+	if (typeof data.options === "string") {
+		return data.loader + "?" + data.options;
 	}
-}
-
-module.exports = HotUpdateChunk;
-
-
-/***/ }),
-
-/***/ 3:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const ModuleFactory = __webpack_require__(51010);
+	if (typeof data.options !== "object") {
+		throw new Error("loader options must be string or object");
+	}
+	if (data.ident) {
+		return data.loader + "??" + data.ident;
+	}
+	return data.loader + "?" + JSON.stringify(data.options);
+};
 
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+const stringifyLoadersAndResource = (loaders, resource) => {
+	let str = "";
+	for (const loader of loaders) {
+		str += loaderToIdent(loader) + "!";
+	}
+	return str + resource;
+};
 
 /**
- * Ignores error when module is unresolved
+ * @param {string} resultString resultString
+ * @returns {{loader: string, options: string|undefined}} parsed loader request
  */
-class IgnoreErrorModuleFactory extends ModuleFactory {
-	/**
-	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
-	 */
-	constructor(normalModuleFactory) {
-		super();
-
-		this.normalModuleFactory = normalModuleFactory;
-	}
-
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		this.normalModuleFactory.create(data, (err, result) => {
-			return callback(null, result);
-		});
+const identToLoaderRequest = resultString => {
+	const idx = resultString.indexOf("?");
+	if (idx >= 0) {
+		const loader = resultString.substr(0, idx);
+		const options = resultString.substr(idx + 1);
+		return {
+			loader,
+			options
+		};
+	} else {
+		return {
+			loader: resultString,
+			options: undefined
+		};
 	}
-}
-
-module.exports = IgnoreErrorModuleFactory;
+};
 
+const needCalls = (times, callback) => {
+	return err => {
+		if (--times === 0) {
+			return callback(err);
+		}
+		if (err && times > 0) {
+			times = NaN;
+			return callback(err);
+		}
+	};
+};
 
-/***/ }),
+const mergeGlobalOptions = (globalOptions, type, localOptions) => {
+	const parts = type.split("/");
+	let result;
+	let current = "";
+	for (const part of parts) {
+		current = current ? `${current}/${part}` : part;
+		const options = globalOptions[current];
+		if (typeof options === "object") {
+			if (result === undefined) {
+				result = options;
+			} else {
+				result = cachedCleverMerge(result, options);
+			}
+		}
+	}
+	if (result === undefined) {
+		return localOptions;
+	} else {
+		return cachedCleverMerge(result, localOptions);
+	}
+};
 
-/***/ 84808:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const createSchemaValidation = __webpack_require__(32540);
+// TODO webpack 6 remove
+const deprecationChangedHookMessage = (name, hook) => {
+	const names = hook.taps
+		.map(tapped => {
+			return tapped.name;
+		})
+		.join(", ");
 
-/** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
+	return (
+		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
+		"Do not return the passed object, but modify it instead. " +
+		"Returning false will ignore the request and results in no module created."
+	);
+};
 
-const validate = createSchemaValidation(
-	__webpack_require__(20858),
-	() => __webpack_require__(3098),
-	{
-		name: "Ignore Plugin",
-		baseDataPath: "options"
-	}
-);
+const ruleSetCompiler = new RuleSetCompiler([
+	new BasicMatcherRulePlugin("test", "resource"),
+	new BasicMatcherRulePlugin("scheme"),
+	new BasicMatcherRulePlugin("mimetype"),
+	new BasicMatcherRulePlugin("dependency"),
+	new BasicMatcherRulePlugin("include", "resource"),
+	new BasicMatcherRulePlugin("exclude", "resource", true),
+	new BasicMatcherRulePlugin("resource"),
+	new BasicMatcherRulePlugin("resourceQuery"),
+	new BasicMatcherRulePlugin("resourceFragment"),
+	new BasicMatcherRulePlugin("realResource"),
+	new BasicMatcherRulePlugin("issuer"),
+	new BasicMatcherRulePlugin("compiler"),
+	new BasicMatcherRulePlugin("issuerLayer"),
+	new ObjectMatcherRulePlugin("assert", "assertions"),
+	new ObjectMatcherRulePlugin("descriptionData"),
+	new BasicEffectRulePlugin("type"),
+	new BasicEffectRulePlugin("sideEffects"),
+	new BasicEffectRulePlugin("parser"),
+	new BasicEffectRulePlugin("resolve"),
+	new BasicEffectRulePlugin("generator"),
+	new BasicEffectRulePlugin("layer"),
+	new UseEffectRulePlugin()
+]);
 
-class IgnorePlugin {
+class NormalModuleFactory extends ModuleFactory {
 	/**
-	 * @param {IgnorePluginOptions} options IgnorePlugin options
+	 * @param {Object} param params
+	 * @param {string=} param.context context
+	 * @param {InputFileSystem} param.fs file system
+	 * @param {ResolverFactory} param.resolverFactory resolverFactory
+	 * @param {ModuleOptions} param.options options
+	 * @param {Object=} param.associatedObjectForCache an object to which the cache will be attached
+	 * @param {boolean=} param.layers enable layers
 	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
+	constructor({
+		context,
+		fs,
+		resolverFactory,
+		options,
+		associatedObjectForCache,
+		layers = false
+	}) {
+		super();
+		this.hooks = Object.freeze({
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			resolve: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
+			resolveForScheme: new HookMap(
+				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
+			),
+			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
+			resolveInScheme: new HookMap(
+				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
+			),
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			factorize: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
+			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
+			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
+			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
+			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
+			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
+			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
+			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
+			createGenerator: new HookMap(
+				() => new SyncBailHook(["generatorOptions"])
+			),
+			generator: new HookMap(
+				() => new SyncHook(["generator", "generatorOptions"])
+			)
+		});
+		this.resolverFactory = resolverFactory;
+		this.ruleSet = ruleSetCompiler.compile([
+			{
+				rules: options.defaultRules
+			},
+			{
+				rules: options.rules
+			}
+		]);
+		this.context = context || "";
+		this.fs = fs;
+		this._globalParserOptions = options.parser;
+		this._globalGeneratorOptions = options.generator;
+		/** @type {Map<string, WeakMap<Object, TODO>>} */
+		this.parserCache = new Map();
+		/** @type {Map<string, WeakMap<Object, Generator>>} */
+		this.generatorCache = new Map();
+		/** @type {Set<Module>} */
+		this._restoredUnsafeCacheEntries = new Set();
 
-		/** @private @type {Function} */
-		this.checkIgnore = this.checkIgnore.bind(this);
-	}
+		const cacheParseResource = parseResource.bindCache(
+			associatedObjectForCache
+		);
 
-	/**
-	 * Note that if "contextRegExp" is given, both the "resourceRegExp"
-	 * and "contextRegExp" have to match.
-	 *
-	 * @param {ResolveData} resolveData resolve data
-	 * @returns {false|undefined} returns false when the request should be ignored, otherwise undefined
-	 */
-	checkIgnore(resolveData) {
-		if (
-			"checkResource" in this.options &&
-			this.options.checkResource &&
-			this.options.checkResource(resolveData.request, resolveData.context)
-		) {
-			return false;
-		}
+		this.hooks.factorize.tapAsync(
+			{
+				name: "NormalModuleFactory",
+				stage: 100
+			},
+			(resolveData, callback) => {
+				this.hooks.resolve.callAsync(resolveData, (err, result) => {
+					if (err) return callback(err);
 
-		if (
-			"resourceRegExp" in this.options &&
-			this.options.resourceRegExp &&
-			this.options.resourceRegExp.test(resolveData.request)
-		) {
-			if ("contextRegExp" in this.options && this.options.contextRegExp) {
-				// if "contextRegExp" is given,
-				// both the "resourceRegExp" and "contextRegExp" have to match.
-				if (this.options.contextRegExp.test(resolveData.context)) {
-					return false;
-				}
-			} else {
-				return false;
-			}
-		}
-	}
+					// Ignored
+					if (result === false) return callback();
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.normalModuleFactory.tap("IgnorePlugin", nmf => {
-			nmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
-		});
-		compiler.hooks.contextModuleFactory.tap("IgnorePlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
-		});
-	}
-}
+					// direct module
+					if (result instanceof Module) return callback(null, result);
 
-module.exports = IgnorePlugin;
+					if (typeof result === "object")
+						throw new Error(
+							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
+								" Returning a Module object will result in this module used as result."
+						);
 
+					this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
+						if (err) return callback(err);
 
-/***/ }),
+						if (typeof result === "object")
+							throw new Error(
+								deprecationChangedHookMessage(
+									"afterResolve",
+									this.hooks.afterResolve
+								)
+							);
 
-/***/ 41606:
-/***/ (function(module) {
+						// Ignored
+						if (result === false) return callback();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+						const createData = resolveData.createData;
 
+						this.hooks.createModule.callAsync(
+							createData,
+							resolveData,
+							(err, createdModule) => {
+								if (!createdModule) {
+									if (!resolveData.request) {
+										return callback(new Error("Empty dependency (no request)"));
+									}
 
+									createdModule = new NormalModule(createData);
+								}
 
-/** @typedef {import("../declarations/WebpackOptions").IgnoreWarningsNormalized} IgnoreWarningsNormalized */
-/** @typedef {import("./Compiler")} Compiler */
+								createdModule = this.hooks.module.call(
+									createdModule,
+									createData,
+									resolveData
+								);
 
-class IgnoreWarningsPlugin {
-	/**
-	 * @param {IgnoreWarningsNormalized} ignoreWarnings conditions to ignore warnings
-	 */
-	constructor(ignoreWarnings) {
-		this._ignoreWarnings = ignoreWarnings;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("IgnoreWarningsPlugin", compilation => {
-			compilation.hooks.processWarnings.tap(
-				"IgnoreWarningsPlugin",
-				warnings => {
-					return warnings.filter(warning => {
-						return !this._ignoreWarnings.some(ignore =>
-							ignore(warning, compilation)
+								return callback(null, createdModule);
+							}
 						);
 					});
-				}
-			);
-		});
-	}
-}
-
-module.exports = IgnoreWarningsPlugin;
-
+				});
+			}
+		);
+		this.hooks.resolve.tapAsync(
+			{
+				name: "NormalModuleFactory",
+				stage: 100
+			},
+			(data, callback) => {
+				const {
+					contextInfo,
+					context,
+					dependencies,
+					dependencyType,
+					request,
+					assertions,
+					resolveOptions,
+					fileDependencies,
+					missingDependencies,
+					contextDependencies
+				} = data;
+				const loaderResolver = this.getResolver("loader");
 
-/***/ }),
+				/** @type {ResourceData | undefined} */
+				let matchResourceData = undefined;
+				/** @type {string} */
+				let unresolvedResource;
+				/** @type {{loader: string, options: string|undefined}[]} */
+				let elements;
+				let noPreAutoLoaders = false;
+				let noAutoLoaders = false;
+				let noPrePostAutoLoaders = false;
 
-/***/ 55870:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				const contextScheme = getScheme(context);
+				/** @type {string | undefined} */
+				let scheme = getScheme(request);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
+				if (!scheme) {
+					/** @type {string} */
+					let requestWithoutMatchResource = request;
+					const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
+					if (matchResourceMatch) {
+						let matchResource = matchResourceMatch[1];
+						if (matchResource.charCodeAt(0) === 46) {
+							// 46 === ".", 47 === "/"
+							const secondChar = matchResource.charCodeAt(1);
+							if (
+								secondChar === 47 ||
+								(secondChar === 46 && matchResource.charCodeAt(2) === 47)
+							) {
+								// if matchResources startsWith ../ or ./
+								matchResource = join(this.fs, context, matchResource);
+							}
+						}
+						matchResourceData = {
+							resource: matchResource,
+							...cacheParseResource(matchResource)
+						};
+						requestWithoutMatchResource = request.substr(
+							matchResourceMatch[0].length
+						);
+					}
 
+					scheme = getScheme(requestWithoutMatchResource);
 
+					if (!scheme && !contextScheme) {
+						const firstChar = requestWithoutMatchResource.charCodeAt(0);
+						const secondChar = requestWithoutMatchResource.charCodeAt(1);
+						noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!"
+						noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!"
+						noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!";
+						const rawElements = requestWithoutMatchResource
+							.slice(
+								noPreAutoLoaders || noPrePostAutoLoaders
+									? 2
+									: noAutoLoaders
+									? 1
+									: 0
+							)
+							.split(/!+/);
+						unresolvedResource = rawElements.pop();
+						elements = rawElements.map(identToLoaderRequest);
+						scheme = getScheme(unresolvedResource);
+					} else {
+						unresolvedResource = requestWithoutMatchResource;
+						elements = EMPTY_ELEMENTS;
+					}
+				} else {
+					unresolvedResource = request;
+					elements = EMPTY_ELEMENTS;
+				}
 
-const { ConcatSource } = __webpack_require__(51255);
-const makeSerializable = __webpack_require__(33032);
+				const resolveContext = {
+					fileDependencies,
+					missingDependencies,
+					contextDependencies
+				};
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
+				/** @type {ResourceDataWithData} */
+				let resourceData;
 
-/**
- * @param {InitFragment} fragment the init fragment
- * @param {number} index index
- * @returns {[InitFragment, number]} tuple with both
- */
-const extractFragmentIndex = (fragment, index) => [fragment, index];
+				let loaders;
 
-/**
- * @param {[InitFragment, number]} a first pair
- * @param {[InitFragment, number]} b second pair
- * @returns {number} sort value
- */
-const sortFragmentWithIndex = ([a, i], [b, j]) => {
-	const stageCmp = a.stage - b.stage;
-	if (stageCmp !== 0) return stageCmp;
-	const positionCmp = a.position - b.position;
-	if (positionCmp !== 0) return positionCmp;
-	return i - j;
-};
+				const continueCallback = needCalls(2, err => {
+					if (err) return callback(err);
 
-/**
- * @template Context
- */
-class InitFragment {
-	/**
-	 * @param {string|Source} content the source code that will be included as initialization code
-	 * @param {number} stage category of initialization code (contribute to order)
-	 * @param {number} position position in the category (contribute to order)
-	 * @param {string=} key unique key to avoid emitting the same initialization code twice
-	 * @param {string|Source=} endContent the source code that will be included at the end of the module
-	 */
-	constructor(content, stage, position, key, endContent) {
-		this.content = content;
-		this.stage = stage;
-		this.position = position;
-		this.key = key;
-		this.endContent = endContent;
-	}
+					// translate option idents
+					try {
+						for (const item of loaders) {
+							if (typeof item.options === "string" && item.options[0] === "?") {
+								const ident = item.options.substr(1);
+								if (ident === "[[missing ident]]") {
+									throw new Error(
+										"No ident is provided by referenced loader. " +
+											"When using a function for Rule.use in config you need to " +
+											"provide an 'ident' property for referenced loader options."
+									);
+								}
+								item.options = this.ruleSet.references.get(ident);
+								if (item.options === undefined) {
+									throw new Error(
+										"Invalid ident is provided by referenced loader"
+									);
+								}
+								item.ident = ident;
+							}
+						}
+					} catch (e) {
+						return callback(e);
+					}
 
-	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
-	 */
-	getContent(context) {
-		return this.content;
-	}
+					if (!resourceData) {
+						// ignored
+						return callback(null, dependencies[0].createIgnoredModule(context));
+					}
 
-	/**
-	 * @param {Context} context context
-	 * @returns {string|Source=} the source code that will be included at the end of the module
-	 */
-	getEndContent(context) {
-		return this.endContent;
-	}
+					const userRequest =
+						(matchResourceData !== undefined
+							? `${matchResourceData.resource}!=!`
+							: "") +
+						stringifyLoadersAndResource(loaders, resourceData.resource);
 
-	static addToSource(source, initFragments, context) {
-		if (initFragments.length > 0) {
-			// Sort fragments by position. If 2 fragments have the same position,
-			// use their index.
-			const sortedFragments = initFragments
-				.map(extractFragmentIndex)
-				.sort(sortFragmentWithIndex);
+					const settings = {};
+					const useLoadersPost = [];
+					const useLoaders = [];
+					const useLoadersPre = [];
 
-			// Deduplicate fragments. If a fragment has no key, it is always included.
-			const keyedFragments = new Map();
-			for (const [fragment] of sortedFragments) {
-				if (typeof fragment.mergeAll === "function") {
-					if (!fragment.key) {
-						throw new Error(
-							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
+					// handle .webpack[] suffix
+					let resource;
+					let match;
+					if (
+						matchResourceData &&
+						typeof (resource = matchResourceData.resource) === "string" &&
+						(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
+					) {
+						settings.type = match[1];
+						matchResourceData.resource = matchResourceData.resource.slice(
+							0,
+							-settings.type.length - 10
 						);
-					}
-					const oldValue = keyedFragments.get(fragment.key);
-					if (oldValue === undefined) {
-						keyedFragments.set(fragment.key, fragment);
-					} else if (Array.isArray(oldValue)) {
-						oldValue.push(fragment);
 					} else {
-						keyedFragments.set(fragment.key, [oldValue, fragment]);
-					}
-					continue;
-				} else if (typeof fragment.merge === "function") {
-					const oldValue = keyedFragments.get(fragment.key);
-					if (oldValue !== undefined) {
-						keyedFragments.set(fragment.key, fragment.merge(oldValue));
-						continue;
-					}
-				}
-				keyedFragments.set(fragment.key || Symbol(), fragment);
-			}
-
-			const concatSource = new ConcatSource();
-			const endContents = [];
-			for (let fragment of keyedFragments.values()) {
-				if (Array.isArray(fragment)) {
-					fragment = fragment[0].mergeAll(fragment);
-				}
-				concatSource.add(fragment.getContent(context));
-				const endContent = fragment.getEndContent(context);
-				if (endContent) {
-					endContents.push(endContent);
-				}
-			}
-
-			concatSource.add(source);
-			for (const content of endContents.reverse()) {
-				concatSource.add(content);
-			}
-			return concatSource;
-		} else {
-			return source;
-		}
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.content);
-		write(this.stage);
-		write(this.position);
-		write(this.key);
-		write(this.endContent);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.content = read();
-		this.stage = read();
-		this.position = read();
-		this.key = read();
-		this.endContent = read();
-	}
-}
-
-makeSerializable(InitFragment, "webpack/lib/InitFragment");
-
-InitFragment.prototype.merge = undefined;
-
-InitFragment.STAGE_CONSTANTS = 10;
-InitFragment.STAGE_ASYNC_BOUNDARY = 20;
-InitFragment.STAGE_HARMONY_EXPORTS = 30;
-InitFragment.STAGE_HARMONY_IMPORTS = 40;
-InitFragment.STAGE_PROVIDES = 50;
-InitFragment.STAGE_ASYNC_DEPENDENCIES = 60;
-InitFragment.STAGE_ASYNC_HARMONY_IMPORTS = 70;
+						settings.type = "javascript/auto";
+						const resourceDataForRules = matchResourceData || resourceData;
+						const result = this.ruleSet.exec({
+							resource: resourceDataForRules.path,
+							realResource: resourceData.path,
+							resourceQuery: resourceDataForRules.query,
+							resourceFragment: resourceDataForRules.fragment,
+							scheme,
+							assertions,
+							mimetype: matchResourceData
+								? ""
+								: resourceData.data.mimetype || "",
+							dependency: dependencyType,
+							descriptionData: matchResourceData
+								? undefined
+								: resourceData.data.descriptionFileData,
+							issuer: contextInfo.issuer,
+							compiler: contextInfo.compiler,
+							issuerLayer: contextInfo.issuerLayer || ""
+						});
+						for (const r of result) {
+							if (r.type === "use") {
+								if (!noAutoLoaders && !noPrePostAutoLoaders) {
+									useLoaders.push(r.value);
+								}
+							} else if (r.type === "use-post") {
+								if (!noPrePostAutoLoaders) {
+									useLoadersPost.push(r.value);
+								}
+							} else if (r.type === "use-pre") {
+								if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
+									useLoadersPre.push(r.value);
+								}
+							} else if (
+								typeof r.value === "object" &&
+								r.value !== null &&
+								typeof settings[r.type] === "object" &&
+								settings[r.type] !== null
+							) {
+								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
+							} else {
+								settings[r.type] = r.value;
+							}
+						}
+					}
 
-module.exports = InitFragment;
+					let postLoaders, normalLoaders, preLoaders;
 
+					const continueCallback = needCalls(3, err => {
+						if (err) {
+							return callback(err);
+						}
+						const allLoaders = postLoaders;
+						if (matchResourceData === undefined) {
+							for (const loader of loaders) allLoaders.push(loader);
+							for (const loader of normalLoaders) allLoaders.push(loader);
+						} else {
+							for (const loader of normalLoaders) allLoaders.push(loader);
+							for (const loader of loaders) allLoaders.push(loader);
+						}
+						for (const loader of preLoaders) allLoaders.push(loader);
+						let type = settings.type;
+						const resolveOptions = settings.resolve;
+						const layer = settings.layer;
+						if (layer !== undefined && !layers) {
+							return callback(
+								new Error(
+									"'Rule.layer' is only allowed when 'experiments.layers' is enabled"
+								)
+							);
+						}
+						try {
+							Object.assign(data.createData, {
+								layer:
+									layer === undefined ? contextInfo.issuerLayer || null : layer,
+								request: stringifyLoadersAndResource(
+									allLoaders,
+									resourceData.resource
+								),
+								userRequest,
+								rawRequest: request,
+								loaders: allLoaders,
+								resource: resourceData.resource,
+								context:
+									resourceData.context || getContext(resourceData.resource),
+								matchResource: matchResourceData
+									? matchResourceData.resource
+									: undefined,
+								resourceResolveData: resourceData.data,
+								settings,
+								type,
+								parser: this.getParser(type, settings.parser),
+								parserOptions: settings.parser,
+								generator: this.getGenerator(type, settings.generator),
+								generatorOptions: settings.generator,
+								resolveOptions
+							});
+						} catch (e) {
+							return callback(e);
+						}
+						callback();
+					});
+					this.resolveRequestArray(
+						contextInfo,
+						this.context,
+						useLoadersPost,
+						loaderResolver,
+						resolveContext,
+						(err, result) => {
+							postLoaders = result;
+							continueCallback(err);
+						}
+					);
+					this.resolveRequestArray(
+						contextInfo,
+						this.context,
+						useLoaders,
+						loaderResolver,
+						resolveContext,
+						(err, result) => {
+							normalLoaders = result;
+							continueCallback(err);
+						}
+					);
+					this.resolveRequestArray(
+						contextInfo,
+						this.context,
+						useLoadersPre,
+						loaderResolver,
+						resolveContext,
+						(err, result) => {
+							preLoaders = result;
+							continueCallback(err);
+						}
+					);
+				});
 
-/***/ }),
+				this.resolveRequestArray(
+					contextInfo,
+					contextScheme ? this.context : context,
+					elements,
+					loaderResolver,
+					resolveContext,
+					(err, result) => {
+						if (err) return continueCallback(err);
+						loaders = result;
+						continueCallback();
+					}
+				);
 
-/***/ 68257:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				const defaultResolve = context => {
+					if (/^($|\?)/.test(unresolvedResource)) {
+						resourceData = {
+							resource: unresolvedResource,
+							data: {},
+							...cacheParseResource(unresolvedResource)
+						};
+						continueCallback();
+					}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					// resource without scheme and with path
+					else {
+						const normalResolver = this.getResolver(
+							"normal",
+							dependencyType
+								? cachedSetProperty(
+										resolveOptions || EMPTY_RESOLVE_OPTIONS,
+										"dependencyType",
+										dependencyType
+								  )
+								: resolveOptions
+						);
+						this.resolveResource(
+							contextInfo,
+							context,
+							unresolvedResource,
+							normalResolver,
+							resolveContext,
+							(err, resolvedResource, resolvedResourceResolveData) => {
+								if (err) return continueCallback(err);
+								if (resolvedResource !== false) {
+									resourceData = {
+										resource: resolvedResource,
+										data: resolvedResourceResolveData,
+										...cacheParseResource(resolvedResource)
+									};
+								}
+								continueCallback();
+							}
+						);
+					}
+				};
 
+				// resource with scheme
+				if (scheme) {
+					resourceData = {
+						resource: unresolvedResource,
+						data: {},
+						path: undefined,
+						query: undefined,
+						fragment: undefined,
+						context: undefined
+					};
+					this.hooks.resolveForScheme
+						.for(scheme)
+						.callAsync(resourceData, data, err => {
+							if (err) return continueCallback(err);
+							continueCallback();
+						});
+				}
 
+				// resource within scheme
+				else if (contextScheme) {
+					resourceData = {
+						resource: unresolvedResource,
+						data: {},
+						path: undefined,
+						query: undefined,
+						fragment: undefined,
+						context: undefined
+					};
+					this.hooks.resolveInScheme
+						.for(contextScheme)
+						.callAsync(resourceData, data, (err, handled) => {
+							if (err) return continueCallback(err);
+							if (!handled) return defaultResolve(this.context);
+							continueCallback();
+						});
+				}
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+				// resource without scheme and without path
+				else defaultResolve(context);
+			}
+		);
+	}
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+	cleanupForCache() {
+		for (const module of this._restoredUnsafeCacheEntries) {
+			ChunkGraph.clearChunkGraphForModule(module);
+			ModuleGraph.clearModuleGraphForModule(module);
+			module.cleanupForCache();
+		}
+	}
 
-class InvalidDependenciesModuleWarning extends WebpackError {
 	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {Iterable<string>} deps invalid dependencies
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
 	 */
-	constructor(module, deps) {
-		const orderedDeps = deps ? Array.from(deps).sort() : [];
-		const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
-		super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
-Invalid dependencies may lead to broken watching and caching.
-As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.
-Loaders: Pass absolute paths to this.addDependency (existing files), this.addMissingDependency (not existing files), and this.addContextDependency (directories).
-Plugins: Pass absolute paths to fileDependencies (existing files), missingDependencies (not existing files), and contextDependencies (directories).
-Globs: They are not supported. Pass absolute path to the directory as context dependencies.
-The following invalid values have been reported:
-${depsList.slice(0, 3).join("\n")}${
-			depsList.length > 3 ? "\n * and more ..." : ""
-		}`);
-
-		this.name = "InvalidDependenciesModuleWarning";
-		this.details = depsList.slice(3).join("\n");
-		this.module = module;
-	}
-}
-
-makeSerializable(
-	InvalidDependenciesModuleWarning,
-	"webpack/lib/InvalidDependenciesModuleWarning"
-);
-
-module.exports = InvalidDependenciesModuleWarning;
-
-
-/***/ }),
+	create(data, callback) {
+		const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies);
+		const context = data.context || this.context;
+		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
+		const dependency = dependencies[0];
+		const request = dependency.request;
+		const assertions = dependency.assertions;
+		const contextInfo = data.contextInfo;
+		const fileDependencies = new LazySet();
+		const missingDependencies = new LazySet();
+		const contextDependencies = new LazySet();
+		const dependencyType =
+			(dependencies.length > 0 && dependencies[0].category) || "";
+		/** @type {ResolveData} */
+		const resolveData = {
+			contextInfo,
+			resolveOptions,
+			context,
+			request,
+			assertions,
+			dependencies,
+			dependencyType,
+			fileDependencies,
+			missingDependencies,
+			contextDependencies,
+			createData: {},
+			cacheable: true
+		};
+		this.hooks.beforeResolve.callAsync(resolveData, (err, result) => {
+			if (err) {
+				return callback(err, {
+					fileDependencies,
+					missingDependencies,
+					contextDependencies,
+					cacheable: false
+				});
+			}
 
-/***/ 52329:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			// Ignored
+			if (result === false) {
+				return callback(null, {
+					fileDependencies,
+					missingDependencies,
+					contextDependencies,
+					cacheable: resolveData.cacheable
+				});
+			}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
-*/
+			if (typeof result === "object")
+				throw new Error(
+					deprecationChangedHookMessage(
+						"beforeResolve",
+						this.hooks.beforeResolve
+					)
+				);
 
+			this.hooks.factorize.callAsync(resolveData, (err, module) => {
+				if (err) {
+					return callback(err, {
+						fileDependencies,
+						missingDependencies,
+						contextDependencies,
+						cacheable: false
+					});
+				}
 
+				const factoryResult = {
+					module,
+					fileDependencies,
+					missingDependencies,
+					contextDependencies,
+					cacheable: resolveData.cacheable
+				};
 
-const InnerGraph = __webpack_require__(38988);
+				callback(null, factoryResult);
+			});
+		});
+	}
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+	resolveResource(
+		contextInfo,
+		context,
+		unresolvedResource,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		resolver.resolve(
+			contextInfo,
+			context,
+			unresolvedResource,
+			resolveContext,
+			(err, resolvedResource, resolvedResourceResolveData) => {
+				if (err) {
+					return this._resolveResourceErrorHints(
+						err,
+						contextInfo,
+						context,
+						unresolvedResource,
+						resolver,
+						resolveContext,
+						(err2, hints) => {
+							if (err2) {
+								err.message += `
+An fatal error happened during resolving additional hints for this error: ${err2.message}`;
+								err.stack += `
 
-class JavascriptMetaInfoPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"JavascriptMetaInfoPlugin",
-			(compilation, { normalModuleFactory }) => {
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
-						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
-						parser.state.module.buildInfo.usingEval = true;
-						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
-						if (currentSymbol) {
-							InnerGraph.addUsage(parser.state, null, currentSymbol);
-						} else {
-							InnerGraph.bailout(parser.state);
-						}
-					});
-					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
-						let topLevelDeclarations =
-							parser.state.module.buildInfo.topLevelDeclarations;
-						if (topLevelDeclarations === undefined) {
-							topLevelDeclarations =
-								parser.state.module.buildInfo.topLevelDeclarations = new Set();
-						}
-						for (const name of parser.scope.definitions.asSet()) {
-							const freeInfo = parser.getFreeInfoFromVariable(name);
-							if (freeInfo === undefined) {
-								topLevelDeclarations.add(name);
+An fatal error happened during resolving additional hints for this error:
+${err2.stack}`;
+								return callback(err);
 							}
+							if (hints && hints.length > 0) {
+								err.message += `
+${hints.join("\n\n")}`;
+							}
+							callback(err);
 						}
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("JavascriptMetaInfoPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("JavascriptMetaInfoPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("JavascriptMetaInfoPlugin", handler);
+					);
+				}
+				callback(err, resolvedResource, resolvedResourceResolveData);
 			}
 		);
 	}
-}
-
-module.exports = JavascriptMetaInfoPlugin;
-
 
-/***/ }),
-
-/***/ 93837:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	_resolveResourceErrorHints(
+		error,
+		contextInfo,
+		context,
+		unresolvedResource,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		asyncLib.parallel(
+			[
+				callback => {
+					if (!resolver.options.fullySpecified) return callback();
+					resolver
+						.withOptions({
+							fullySpecified: false
+						})
+						.resolve(
+							contextInfo,
+							context,
+							unresolvedResource,
+							resolveContext,
+							(err, resolvedResource) => {
+								if (!err && resolvedResource) {
+									const resource = parseResource(resolvedResource).path.replace(
+										/^.*[\\/]/,
+										""
+									);
+									return callback(
+										null,
+										`Did you mean '${resource}'?
+BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified
+(probably because the origin is strict EcmaScript Module, e. g. a module with javascript mimetype, a '*.mjs' file, or a '*.js' file where the package.json contains '"type": "module"').
+The extension in the request is mandatory for it to be fully specified.
+Add the extension to the request.`
+									);
+								}
+								callback();
+							}
+						);
+				},
+				callback => {
+					if (!resolver.options.enforceExtension) return callback();
+					resolver
+						.withOptions({
+							enforceExtension: false,
+							extensions: []
+						})
+						.resolve(
+							contextInfo,
+							context,
+							unresolvedResource,
+							resolveContext,
+							(err, resolvedResource) => {
+								if (!err && resolvedResource) {
+									let hint = "";
+									const match = /(\.[^.]+)(\?|$)/.exec(unresolvedResource);
+									if (match) {
+										const fixedRequest = unresolvedResource.replace(
+											/(\.[^.]+)(\?|$)/,
+											"$2"
+										);
+										if (resolver.options.extensions.has(match[1])) {
+											hint = `Did you mean '${fixedRequest}'?`;
+										} else {
+											hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
+										}
+									} else {
+										hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
+									}
+									return callback(
+										null,
+										`The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified.
+${hint}
+Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?`
+									);
+								}
+								callback();
+							}
+						);
+				},
+				callback => {
+					if (
+						/^\.\.?\//.test(unresolvedResource) ||
+						resolver.options.preferRelative
+					) {
+						return callback();
+					}
+					resolver.resolve(
+						contextInfo,
+						context,
+						`./${unresolvedResource}`,
+						resolveContext,
+						(err, resolvedResource) => {
+							if (err || !resolvedResource) return callback();
+							const moduleDirectories = resolver.options.modules
+								.map(m => (Array.isArray(m) ? m.join(", ") : m))
+								.join(", ");
+							callback(
+								null,
+								`Did you mean './${unresolvedResource}'?
+Requests that should resolve in the current directory need to start with './'.
+Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}).
+If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.`
+							);
+						}
+					);
+				}
+			],
+			(err, hints) => {
+				if (err) return callback(err);
+				callback(null, hints.filter(Boolean));
+			}
+		);
+	}
+
+	resolveRequestArray(
+		contextInfo,
+		context,
+		array,
+		resolver,
+		resolveContext,
+		callback
+	) {
+		if (array.length === 0) return callback(null, array);
+		asyncLib.map(
+			array,
+			(item, callback) => {
+				resolver.resolve(
+					contextInfo,
+					context,
+					item.loader,
+					resolveContext,
+					(err, result) => {
+						if (
+							err &&
+							/^[^/]*$/.test(item.loader) &&
+							!/-loader$/.test(item.loader)
+						) {
+							return resolver.resolve(
+								contextInfo,
+								context,
+								item.loader + "-loader",
+								resolveContext,
+								err2 => {
+									if (!err2) {
+										err.message =
+											err.message +
+											"\n" +
+											"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
+											`                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
+											"                 see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed";
+									}
+									callback(err);
+								}
+							);
+						}
+						if (err) return callback(err);
 
+						const parsedResult = identToLoaderRequest(result);
+						const resolved = {
+							loader: parsedResult.loader,
+							options:
+								item.options === undefined
+									? parsedResult.options
+									: item.options,
+							ident: item.options === undefined ? undefined : item.ident
+						};
+						return callback(null, resolved);
+					}
+				);
+			},
+			callback
+		);
+	}
 
+	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
+		let cache = this.parserCache.get(type);
 
-const asyncLib = __webpack_require__(78175);
-const EntryDependency = __webpack_require__(3979);
-const { someInIterable } = __webpack_require__(39104);
-const { compareModulesById } = __webpack_require__(29579);
-const { dirname, mkdirp } = __webpack_require__(17139);
+		if (cache === undefined) {
+			cache = new WeakMap();
+			this.parserCache.set(type, cache);
+		}
 
-/** @typedef {import("./Compiler")} Compiler */
+		let parser = cache.get(parserOptions);
 
-/**
- * @typedef {Object} ManifestModuleData
- * @property {string | number} id
- * @property {Object} buildMeta
- * @property {boolean | string[]} exports
- */
+		if (parser === undefined) {
+			parser = this.createParser(type, parserOptions);
+			cache.set(parserOptions, parser);
+		}
 
-class LibManifestPlugin {
-	constructor(options) {
-		this.options = options;
+		return parser;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string} type type
+	 * @param {{[k: string]: any}} parserOptions parser options
+	 * @returns {Parser} parser
 	 */
-	apply(compiler) {
-		compiler.hooks.emit.tapAsync(
-			"LibManifestPlugin",
-			(compilation, callback) => {
-				const moduleGraph = compilation.moduleGraph;
-				asyncLib.forEach(
-					Array.from(compilation.chunks),
-					(chunk, callback) => {
-						if (!chunk.canBeInitial()) {
-							callback();
-							return;
-						}
-						const chunkGraph = compilation.chunkGraph;
-						const targetPath = compilation.getPath(this.options.path, {
-							chunk
-						});
-						const name =
-							this.options.name &&
-							compilation.getPath(this.options.name, {
-								chunk
-							});
-						const content = Object.create(null);
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesById(chunkGraph)
-						)) {
-							if (
-								this.options.entryOnly &&
-								!someInIterable(
-									moduleGraph.getIncomingConnections(module),
-									c => c.dependency instanceof EntryDependency
-								)
-							) {
-								continue;
-							}
-							const ident = module.libIdent({
-								context: this.options.context || compiler.options.context,
-								associatedObjectForCache: compiler.root
-							});
-							if (ident) {
-								const exportsInfo = moduleGraph.getExportsInfo(module);
-								const providedExports = exportsInfo.getProvidedExports();
-								/** @type {ManifestModuleData} */
-								const data = {
-									id: chunkGraph.getModuleId(module),
-									buildMeta: module.buildMeta,
-									exports: Array.isArray(providedExports)
-										? providedExports
-										: undefined
-								};
-								content[ident] = data;
-							}
-						}
-						const manifest = {
-							name,
-							type: this.options.type,
-							content
-						};
-						// Apply formatting to content if format flag is true;
-						const manifestContent = this.options.format
-							? JSON.stringify(manifest, null, 2)
-							: JSON.stringify(manifest);
-						const buffer = Buffer.from(manifestContent, "utf8");
-						mkdirp(
-							compiler.intermediateFileSystem,
-							dirname(compiler.intermediateFileSystem, targetPath),
-							err => {
-								if (err) return callback(err);
-								compiler.intermediateFileSystem.writeFile(
-									targetPath,
-									buffer,
-									callback
-								);
-							}
-						);
-					},
-					callback
-				);
-			}
+	createParser(type, parserOptions = {}) {
+		parserOptions = mergeGlobalOptions(
+			this._globalParserOptions,
+			type,
+			parserOptions
 		);
+		const parser = this.hooks.createParser.for(type).call(parserOptions);
+		if (!parser) {
+			throw new Error(`No parser registered for ${type}`);
+		}
+		this.hooks.parser.for(type).call(parser, parserOptions);
+		return parser;
 	}
-}
-module.exports = LibManifestPlugin;
-
-
-/***/ }),
 
-/***/ 14157:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
+		let cache = this.generatorCache.get(type);
 
+		if (cache === undefined) {
+			cache = new WeakMap();
+			this.generatorCache.set(type, cache);
+		}
 
+		let generator = cache.get(generatorOptions);
 
-const EnableLibraryPlugin = __webpack_require__(91452);
+		if (generator === undefined) {
+			generator = this.createGenerator(type, generatorOptions);
+			cache.set(generatorOptions, generator);
+		}
 
-/** @typedef {import("../declarations/WebpackOptions").AuxiliaryComment} AuxiliaryComment */
-/** @typedef {import("../declarations/WebpackOptions").LibraryExport} LibraryExport */
-/** @typedef {import("../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../declarations/WebpackOptions").UmdNamedDefine} UmdNamedDefine */
-/** @typedef {import("./Compiler")} Compiler */
+		return generator;
+	}
 
-// TODO webpack 6 remove
-class LibraryTemplatePlugin {
-	/**
-	 * @param {LibraryName} name name of library
-	 * @param {LibraryType} target type of library
-	 * @param {UmdNamedDefine} umdNamedDefine setting this to true will name the UMD module
-	 * @param {AuxiliaryComment} auxiliaryComment comment in the UMD wrapper
-	 * @param {LibraryExport} exportProperty which export should be exposed as library
-	 */
-	constructor(name, target, umdNamedDefine, auxiliaryComment, exportProperty) {
-		this.library = {
-			type: target || "var",
-			name,
-			umdNamedDefine,
-			auxiliaryComment,
-			export: exportProperty
-		};
+	createGenerator(type, generatorOptions = {}) {
+		generatorOptions = mergeGlobalOptions(
+			this._globalGeneratorOptions,
+			type,
+			generatorOptions
+		);
+		const generator = this.hooks.createGenerator
+			.for(type)
+			.call(generatorOptions);
+		if (!generator) {
+			throw new Error(`No generator registered for ${type}`);
+		}
+		this.hooks.generator.for(type).call(generator, generatorOptions);
+		return generator;
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { output } = compiler.options;
-		output.library = this.library;
-		new EnableLibraryPlugin(this.library.type).apply(compiler);
+	getResolver(type, resolveOptions) {
+		return this.resolverFactory.get(type, resolveOptions);
 	}
 }
 
-module.exports = LibraryTemplatePlugin;
+module.exports = NormalModuleFactory;
 
 
 /***/ }),
 
-/***/ 22078:
+/***/ 30633:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -50388,34 +51000,20 @@ module.exports = LibraryTemplatePlugin;
 
 
 
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const NormalModule = __webpack_require__(39);
-const createSchemaValidation = __webpack_require__(32540);
+const { join, dirname } = __webpack_require__(17139);
 
-/** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {function(TODO): void} ModuleReplacer */
 
-const validate = createSchemaValidation(
-	__webpack_require__(24160),
-	() => __webpack_require__(15965),
-	{
-		name: "Loader Options Plugin",
-		baseDataPath: "options"
-	}
-);
-class LoaderOptionsPlugin {
+class NormalModuleReplacementPlugin {
 	/**
-	 * @param {LoaderOptionsPluginOptions} options options object
+	 * Create an instance of the plugin
+	 * @param {RegExp} resourceRegExp the resource matcher
+	 * @param {string|ModuleReplacer} newResource the resource replacement
 	 */
-	constructor(options = {}) {
-		validate(options);
-		if (typeof options !== "object") options = {};
-		if (!options.test) {
-			options.test = {
-				test: () => true
-			};
-		}
-		this.options = options;
+	constructor(resourceRegExp, newResource) {
+		this.resourceRegExp = resourceRegExp;
+		this.newResource = newResource;
 	}
 
 	/**
@@ -50424,85 +51022,72 @@ class LoaderOptionsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
-			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderOptionsPlugin",
-				(context, module) => {
-					const resource = module.resource;
-					if (!resource) return;
-					const i = resource.indexOf("?");
-					if (
-						ModuleFilenameHelpers.matchObject(
-							options,
-							i < 0 ? resource : resource.substr(0, i)
-						)
-					) {
-						for (const key of Object.keys(options)) {
-							if (key === "include" || key === "exclude" || key === "test") {
-								continue;
+		const resourceRegExp = this.resourceRegExp;
+		const newResource = this.newResource;
+		compiler.hooks.normalModuleFactory.tap(
+			"NormalModuleReplacementPlugin",
+			nmf => {
+				nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", result => {
+					if (resourceRegExp.test(result.request)) {
+						if (typeof newResource === "function") {
+							newResource(result);
+						} else {
+							result.request = newResource;
+						}
+					}
+				});
+				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
+					const createData = result.createData;
+					if (resourceRegExp.test(createData.resource)) {
+						if (typeof newResource === "function") {
+							newResource(result);
+						} else {
+							const fs = compiler.inputFileSystem;
+							if (
+								newResource.startsWith("/") ||
+								(newResource.length > 1 && newResource[1] === ":")
+							) {
+								createData.resource = newResource;
+							} else {
+								createData.resource = join(
+									fs,
+									dirname(fs, createData.resource),
+									newResource
+								);
 							}
-							context[key] = options[key];
 						}
 					}
-				}
-			);
-		});
+				});
+			}
+		);
 	}
 }
 
-module.exports = LoaderOptionsPlugin;
+module.exports = NormalModuleReplacementPlugin;
 
 
 /***/ }),
 
-/***/ 86738:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 80057:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const NormalModule = __webpack_require__(39);
-
-/** @typedef {import("./Compiler")} Compiler */
-
-class LoaderTargetPlugin {
-	/**
-	 * @param {string} target the target
-	 */
-	constructor(target) {
-		this.target = target;
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("LoaderTargetPlugin", compilation => {
-			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderTargetPlugin",
-				loaderContext => {
-					loaderContext.target = this.target;
-				}
-			);
-		});
-	}
-}
-
-module.exports = LoaderTargetPlugin;
+exports.STAGE_BASIC = -10;
+exports.STAGE_DEFAULT = 0;
+exports.STAGE_ADVANCED = 10;
 
 
 /***/ }),
 
-/***/ 12856:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 81426:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -50512,333 +51097,61 @@ module.exports = LoaderTargetPlugin;
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(41242);
-const util = __webpack_require__(73837);
-const RuntimeGlobals = __webpack_require__(16475);
-const memoize = __webpack_require__(78676);
+class OptionsApply {
+	process(options, compiler) {}
+}
+module.exports = OptionsApply;
 
-/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Module")} Module} */
-/** @typedef {import("./util/Hash")} Hash} */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
-/** @typedef {import("./ModuleGraph")} ModuleGraph} */
-/** @typedef {import("./ChunkGraph")} ChunkGraph} */
-/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions} */
-/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry} */
 
-const getJavascriptModulesPlugin = memoize(() =>
-	__webpack_require__(89464)
-);
-const getJsonpTemplatePlugin = memoize(() =>
-	__webpack_require__(4607)
-);
-const getLoadScriptRuntimeModule = memoize(() =>
-	__webpack_require__(19942)
-);
+/***/ }),
 
-// TODO webpack 6 remove this class
-class MainTemplate {
-	/**
-	 *
-	 * @param {OutputOptions} outputOptions output options for the MainTemplate
-	 * @param {Compilation} compilation the compilation
-	 */
-	constructor(outputOptions, compilation) {
-		/** @type {OutputOptions} */
-		this._outputOptions = outputOptions || {};
-		this.hooks = Object.freeze({
-			renderManifest: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.renderManifest.tap(
-							options,
-							(entries, options) => {
-								if (!options.chunk.hasRuntime()) return entries;
-								return fn(entries, options);
-							}
-						);
-					},
-					"MainTemplate.hooks.renderManifest is deprecated (use Compilation.hooks.renderManifest instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_MANIFEST"
-				)
-			},
-			modules: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.modules has been removed (there is no replacement, please create an issue to request that)"
-					);
-				}
-			},
-			moduleObj: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.moduleObj has been removed (there is no replacement, please create an issue to request that)"
-					);
-				}
-			},
-			require: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderRequire.tap(options, fn);
-					},
-					"MainTemplate.hooks.require is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderRequire instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE"
-				)
-			},
-			beforeStartup: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)"
-					);
-				}
-			},
-			startup: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.startup has been removed (use RuntimeGlobals.startup instead)"
-					);
-				}
-			},
-			afterStartup: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)"
-					);
-				}
-			},
-			render: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
-								if (
-									renderContext.chunkGraph.getNumberOfEntryModules(
-										renderContext.chunk
-									) === 0 ||
-									!renderContext.chunk.hasRuntime()
-								) {
-									return source;
-								}
-								return fn(
-									source,
-									renderContext.chunk,
-									compilation.hash,
-									compilation.moduleTemplates.javascript,
-									compilation.dependencyTemplates
-								);
-							});
-					},
-					"MainTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER"
-				)
-			},
-			renderWithEntry: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
-								if (
-									renderContext.chunkGraph.getNumberOfEntryModules(
-										renderContext.chunk
-									) === 0 ||
-									!renderContext.chunk.hasRuntime()
-								) {
-									return source;
-								}
-								return fn(source, renderContext.chunk, compilation.hash);
-							});
-					},
-					"MainTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_WITH_ENTRY"
-				)
-			},
-			assetPath: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.assetPath.tap(options, fn);
-					},
-					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
-				),
-				call: util.deprecate(
-					(filename, options) => {
-						return compilation.getAssetPath(filename, options);
-					},
-					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
-				)
-			},
-			hash: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.fullHash.tap(options, fn);
-					},
-					"MainTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH"
-				)
-			},
-			hashForChunk: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.chunkHash.tap(options, (chunk, hash) => {
-								if (!chunk.hasRuntime()) return;
-								return fn(hash, chunk);
-							});
-					},
-					"MainTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			},
-			globalHashPaths: {
-				tap: util.deprecate(
-					() => {},
-					"MainTemplate.hooks.globalHashPaths has been removed (it's no longer needed)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			},
-			globalHash: {
-				tap: util.deprecate(
-					() => {},
-					"MainTemplate.hooks.globalHash has been removed (it's no longer needed)",
-					"DEP_WEBPACK_MAIN_TEMPLATE_HASH_FOR_CHUNK"
-				)
-			},
-			hotBootstrap: {
-				tap: () => {
-					throw new Error(
-						"MainTemplate.hooks.hotBootstrap has been removed (use your own RuntimeModule instead)"
-					);
-				}
-			},
+/***/ 11715:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			// for compatibility:
-			/** @type {SyncWaterfallHook<[string, Chunk, string, ModuleTemplate, DependencyTemplates]>} */
-			bootstrap: new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash",
-				"moduleTemplate",
-				"dependencyTemplates"
-			]),
-			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
-			localVars: new SyncWaterfallHook(["source", "chunk", "hash"]),
-			/** @type {SyncWaterfallHook<[string, Chunk, string]>} */
-			requireExtensions: new SyncWaterfallHook(["source", "chunk", "hash"]),
-			/** @type {SyncWaterfallHook<[string, Chunk, string, string]>} */
-			requireEnsure: new SyncWaterfallHook([
-				"source",
-				"chunk",
-				"hash",
-				"chunkIdExpression"
-			]),
-			get jsonpScript() {
-				const hooks =
-					getLoadScriptRuntimeModule().getCompilationHooks(compilation);
-				return hooks.createScript;
-			},
-			get linkPrefetch() {
-				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
-				return hooks.linkPrefetch;
-			},
-			get linkPreload() {
-				const hooks = getJsonpTemplatePlugin().getCompilationHooks(compilation);
-				return hooks.linkPreload;
-			}
-		});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		this.renderCurrentHashCode = util.deprecate(
-			/**
-			 * @deprecated
-			 * @param {string} hash the hash
-			 * @param {number=} length length of the hash
-			 * @returns {string} generated code
-			 */ (hash, length) => {
-				if (length) {
-					return `${RuntimeGlobals.getFullHash} ? ${
-						RuntimeGlobals.getFullHash
-					}().slice(0, ${length}) : ${hash.slice(0, length)}`;
-				}
-				return `${RuntimeGlobals.getFullHash} ? ${RuntimeGlobals.getFullHash}() : ${hash}`;
-			},
-			"MainTemplate.renderCurrentHashCode is deprecated (use RuntimeGlobals.getFullHash runtime function instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_RENDER_CURRENT_HASH_CODE"
-		);
 
-		this.getPublicPath = util.deprecate(
-			/**
-			 *
-			 * @param {object} options get public path options
-			 * @returns {string} hook call
-			 */ options => {
-				return compilation.getAssetPath(
-					compilation.outputOptions.publicPath,
-					options
-				);
-			},
-			"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
-		);
 
-		this.getAssetPath = util.deprecate(
-			(path, options) => {
-				return compilation.getAssetPath(path, options);
-			},
-			"MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH"
-		);
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./NormalModule")} NormalModule */
 
-		this.getAssetPathWithInfo = util.deprecate(
-			(path, options) => {
-				return compilation.getAssetPathWithInfo(path, options);
-			},
-			"MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)",
-			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO"
-		);
-	}
-}
+/** @typedef {Record<string, any>} PreparsedAst */
 
-Object.defineProperty(MainTemplate.prototype, "requireFn", {
-	get: util.deprecate(
-		() => "__webpack_require__",
-		'MainTemplate.requireFn is deprecated (use "__webpack_require__")',
-		"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN"
-	)
-});
+/**
+ * @typedef {Object} ParserStateBase
+ * @property {string | Buffer} source
+ * @property {NormalModule} current
+ * @property {NormalModule} module
+ * @property {Compilation} compilation
+ * @property {{[k: string]: any}} options
+ */
 
-Object.defineProperty(MainTemplate.prototype, "outputOptions", {
-	get: util.deprecate(
-		/**
-		 * @this {MainTemplate}
-		 * @returns {OutputOptions} output options
-		 */
-		function () {
-			return this._outputOptions;
-		},
-		"MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",
-		"DEP_WEBPACK_MAIN_TEMPLATE_OUTPUT_OPTIONS"
-	)
-});
+/** @typedef {Record<string, any> & ParserStateBase} ParserState */
 
-module.exports = MainTemplate;
+class Parser {
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+}
+
+module.exports = Parser;
 
 
 /***/ }),
 
-/***/ 73208:
+/***/ 73850:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -50849,1095 +51162,1169 @@ module.exports = MainTemplate;
 
 
 
-const util = __webpack_require__(73837);
-const ChunkGraph = __webpack_require__(64971);
-const DependenciesBlock = __webpack_require__(71040);
-const ModuleGraph = __webpack_require__(99988);
-const RuntimeGlobals = __webpack_require__(16475);
-const { first } = __webpack_require__(93347);
-const { compareChunksById } = __webpack_require__(29579);
-const makeSerializable = __webpack_require__(33032);
+const PrefetchDependency = __webpack_require__(31618);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./ExportsInfo").UsageStateType} UsageStateType */
-/** @typedef {import("./FileSystemInfo")} FileSystemInfo */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/LazySet")<T>} LazySet<T> */
-/** @template T @typedef {import("./util/SortableSet")<T>} SortableSet<T> */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./Compiler")} Compiler */
 
-/**
- * @typedef {Object} SourceContext
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {RuntimeSpec} runtime the runtimes code should be generated for
- * @property {string=} type the type of source that should be generated
- */
+class PrefetchPlugin {
+	constructor(context, request) {
+		if (request) {
+			this.context = context;
+			this.request = request;
+		} else {
+			this.context = null;
+			this.request = context;
+		}
+	}
 
-/**
- * @typedef {Object} CodeGenerationContext
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {RuntimeSpec} runtime the runtimes code should be generated for
- * @property {ConcatenationScope=} concatenationScope when in concatenated module, information about other concatenated modules
- * @property {CodeGenerationResults} codeGenerationResults code generation results of other modules (need to have a codeGenerationDependency to use that)
- */
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"PrefetchPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					PrefetchDependency,
+					normalModuleFactory
+				);
+			}
+		);
+		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
+			compilation.addModuleChain(
+				this.context || compiler.context,
+				new PrefetchDependency(this.request),
+				err => {
+					callback(err);
+				}
+			);
+		});
+	}
+}
 
-/**
- * @typedef {Object} ConcatenationBailoutReasonContext
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- */
+module.exports = PrefetchPlugin;
 
-/**
- * @typedef {Object} CodeGenerationResult
- * @property {Map<string, Source>} sources the resulting sources for all source types
- * @property {Map<string, any>=} data the resulting data for all source types
- * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
- * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
- */
 
-/**
- * @typedef {Object} LibIdentOptions
- * @property {string} context absolute context path to which lib ident is relative to
- * @property {Object=} associatedObjectForCache object for caching
- */
+/***/ }),
 
-/**
- * @typedef {Object} KnownBuildMeta
- * @property {string=} moduleArgument
- * @property {string=} exportsArgument
- * @property {boolean=} strict
- * @property {string=} moduleConcatenationBailout
- * @property {("default" | "namespace" | "flagged" | "dynamic")=} exportsType
- * @property {(false | "redirect" | "redirect-warn")=} defaultObject
- * @property {boolean=} strictHarmonyModule
- * @property {boolean=} async
- * @property {boolean=} sideEffectFree
- */
+/***/ 13216:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * @typedef {Object} NeedBuildContext
- * @property {Compilation} compilation
- * @property {FileSystemInfo} fileSystemInfo
- * @property {Map<string, string | Set<string>>} valueCacheVersions
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/** @typedef {KnownBuildMeta & Record<string, any>} BuildMeta */
 
-const EMPTY_RESOLVE_OPTIONS = {};
 
-let debugId = 1000;
+const Compiler = __webpack_require__(70845);
+const MultiCompiler = __webpack_require__(33370);
+const NormalModule = __webpack_require__(39);
+const createSchemaValidation = __webpack_require__(32540);
+const { contextify } = __webpack_require__(82186);
 
-const DEFAULT_TYPES_UNKNOWN = new Set(["unknown"]);
-const DEFAULT_TYPES_JS = new Set(["javascript"]);
+/** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
+/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
 
-const deprecatedNeedRebuild = util.deprecate(
-	(module, context) => {
-		return module.needRebuild(
-			context.fileSystemInfo.getDeprecatedFileTimestamps(),
-			context.fileSystemInfo.getDeprecatedContextTimestamps()
-		);
-	},
-	"Module.needRebuild is deprecated in favor of Module.needBuild",
-	"DEP_WEBPACK_MODULE_NEED_REBUILD"
+const validate = createSchemaValidation(
+	__webpack_require__(57647),
+	() => __webpack_require__(75202),
+	{
+		name: "Progress Plugin",
+		baseDataPath: "options"
+	}
 );
+const median3 = (a, b, c) => {
+	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
+};
 
-/** @typedef {(requestShortener: RequestShortener) => string} OptimizationBailoutFunction */
-
-class Module extends DependenciesBlock {
-	/**
-	 * @param {string} type the module type
-	 * @param {string=} context an optional context
-	 * @param {string=} layer an optional layer in which the module is
-	 */
-	constructor(type, context = null, layer = null) {
-		super();
+const createDefaultHandler = (profile, logger) => {
+	/** @type {{ value: string, time: number }[]} */
+	const lastStateInfo = [];
 
-		/** @type {string} */
-		this.type = type;
-		/** @type {string | null} */
-		this.context = context;
-		/** @type {string | null} */
-		this.layer = layer;
-		/** @type {boolean} */
-		this.needId = true;
+	const defaultHandler = (percentage, msg, ...args) => {
+		if (profile) {
+			if (percentage === 0) {
+				lastStateInfo.length = 0;
+			}
+			const fullState = [msg, ...args];
+			const state = fullState.map(s => s.replace(/\d+\/\d+ /g, ""));
+			const now = Date.now();
+			const len = Math.max(state.length, lastStateInfo.length);
+			for (let i = len; i >= 0; i--) {
+				const stateItem = i < state.length ? state[i] : undefined;
+				const lastStateItem =
+					i < lastStateInfo.length ? lastStateInfo[i] : undefined;
+				if (lastStateItem) {
+					if (stateItem !== lastStateItem.value) {
+						const diff = now - lastStateItem.time;
+						if (lastStateItem.value) {
+							let reportState = lastStateItem.value;
+							if (i > 0) {
+								reportState = lastStateInfo[i - 1].value + " > " + reportState;
+							}
+							const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
+							const d = diff;
+							// This depends on timing so we ignore it for coverage
+							/* istanbul ignore next */
+							{
+								if (d > 10000) {
+									logger.error(stateMsg);
+								} else if (d > 1000) {
+									logger.warn(stateMsg);
+								} else if (d > 10) {
+									logger.info(stateMsg);
+								} else if (d > 5) {
+									logger.log(stateMsg);
+								} else {
+									logger.debug(stateMsg);
+								}
+							}
+						}
+						if (stateItem === undefined) {
+							lastStateInfo.length = i;
+						} else {
+							lastStateItem.value = stateItem;
+							lastStateItem.time = now;
+							lastStateInfo.length = i + 1;
+						}
+					}
+				} else {
+					lastStateInfo[i] = {
+						value: stateItem,
+						time: now
+					};
+				}
+			}
+		}
+		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
+		if (percentage === 1 || (!msg && args.length === 0)) logger.status();
+	};
 
-		// Unique Id
-		/** @type {number} */
-		this.debugId = debugId++;
+	return defaultHandler;
+};
 
-		// Info from Factory
-		/** @type {ResolveOptions} */
-		this.resolveOptions = EMPTY_RESOLVE_OPTIONS;
-		/** @type {object | undefined} */
-		this.factoryMeta = undefined;
-		// TODO refactor this -> options object filled from Factory
-		// TODO webpack 6: use an enum
-		/** @type {boolean} */
-		this.useSourceMap = false;
-		/** @type {boolean} */
-		this.useSimpleSourceMap = false;
+/**
+ * @callback ReportProgress
+ * @param {number} p
+ * @param {...string[]} [args]
+ * @returns {void}
+ */
 
-		// Info from Build
-		/** @type {WebpackError[] | undefined} */
-		this._warnings = undefined;
-		/** @type {WebpackError[] | undefined} */
-		this._errors = undefined;
-		/** @type {BuildMeta} */
-		this.buildMeta = undefined;
-		/** @type {Record<string, any>} */
-		this.buildInfo = undefined;
-		/** @type {Dependency[] | undefined} */
-		this.presentationalDependencies = undefined;
-		/** @type {Dependency[] | undefined} */
-		this.codeGenerationDependencies = undefined;
-	}
+/** @type {WeakMap<Compiler,ReportProgress>} */
+const progressReporters = new WeakMap();
 
-	// TODO remove in webpack 6
-	// BACKWARD-COMPAT START
-	get id() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.id",
-			"DEP_WEBPACK_MODULE_ID"
-		).getModuleId(this);
+class ProgressPlugin {
+	/**
+	 * @param {Compiler} compiler the current compiler
+	 * @returns {ReportProgress} a progress reporter, if any
+	 */
+	static getReporter(compiler) {
+		return progressReporters.get(compiler);
 	}
 
-	set id(value) {
-		if (value === "") {
-			this.needId = false;
-			return;
+	/**
+	 * @param {ProgressPluginArgument} options options
+	 */
+	constructor(options = {}) {
+		if (typeof options === "function") {
+			options = {
+				handler: options
+			};
 		}
-		ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.id",
-			"DEP_WEBPACK_MODULE_ID"
-		).setModuleId(this, value);
+
+		validate(options);
+		options = { ...ProgressPlugin.defaultOptions, ...options };
+
+		this.profile = options.profile;
+		this.handler = options.handler;
+		this.modulesCount = options.modulesCount;
+		this.dependenciesCount = options.dependenciesCount;
+		this.showEntries = options.entries;
+		this.showModules = options.modules;
+		this.showDependencies = options.dependencies;
+		this.showActiveModules = options.activeModules;
+		this.percentBy = options.percentBy;
 	}
 
 	/**
-	 * @returns {string} the hash of the module
+	 * @param {Compiler | MultiCompiler} compiler webpack compiler
+	 * @returns {void}
 	 */
-	get hash() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.hash",
-			"DEP_WEBPACK_MODULE_HASH"
-		).getModuleHash(this, undefined);
+	apply(compiler) {
+		const handler =
+			this.handler ||
+			createDefaultHandler(
+				this.profile,
+				compiler.getInfrastructureLogger("webpack.Progress")
+			);
+		if (compiler instanceof MultiCompiler) {
+			this._applyOnMultiCompiler(compiler, handler);
+		} else if (compiler instanceof Compiler) {
+			this._applyOnCompiler(compiler, handler);
+		}
 	}
 
 	/**
-	 * @returns {string} the shortened hash of the module
+	 * @param {MultiCompiler} compiler webpack multi-compiler
+	 * @param {HandlerFunction} handler function that executes for every progress step
+	 * @returns {void}
 	 */
-	get renderedHash() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.renderedHash",
-			"DEP_WEBPACK_MODULE_RENDERED_HASH"
-		).getRenderedModuleHash(this, undefined);
+	_applyOnMultiCompiler(compiler, handler) {
+		const states = compiler.compilers.map(
+			() => /** @type {[number, ...string[]]} */ ([0])
+		);
+		compiler.compilers.forEach((compiler, idx) => {
+			new ProgressPlugin((p, msg, ...args) => {
+				states[idx] = [p, msg, ...args];
+				let sum = 0;
+				for (const [p] of states) sum += p;
+				handler(sum / states.length, `[${idx}] ${msg}`, ...args);
+			}).apply(compiler);
+		});
 	}
 
-	get profile() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.profile",
-			"DEP_WEBPACK_MODULE_PROFILE"
-		).getProfile(this);
-	}
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @param {HandlerFunction} handler function that executes for every progress step
+	 * @returns {void}
+	 */
+	_applyOnCompiler(compiler, handler) {
+		const showEntries = this.showEntries;
+		const showModules = this.showModules;
+		const showDependencies = this.showDependencies;
+		const showActiveModules = this.showActiveModules;
+		let lastActiveModule = "";
+		let currentLoader = "";
+		let lastModulesCount = 0;
+		let lastDependenciesCount = 0;
+		let lastEntriesCount = 0;
+		let modulesCount = 0;
+		let dependenciesCount = 0;
+		let entriesCount = 1;
+		let doneModules = 0;
+		let doneDependencies = 0;
+		let doneEntries = 0;
+		const activeModules = new Set();
+		let lastUpdate = 0;
 
-	set profile(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.profile",
-			"DEP_WEBPACK_MODULE_PROFILE"
-		).setProfile(this, value);
-	}
+		const updateThrottled = () => {
+			if (lastUpdate + 500 < Date.now()) update();
+		};
 
-	get index() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index",
-			"DEP_WEBPACK_MODULE_INDEX"
-		).getPreOrderIndex(this);
-	}
+		const update = () => {
+			/** @type {string[]} */
+			const items = [];
+			const percentByModules =
+				doneModules /
+				Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);
+			const percentByEntries =
+				doneEntries /
+				Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);
+			const percentByDependencies =
+				doneDependencies /
+				Math.max(lastDependenciesCount || 1, dependenciesCount);
+			let percentageFactor;
 
-	set index(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index",
-			"DEP_WEBPACK_MODULE_INDEX"
-		).setPreOrderIndex(this, value);
-	}
+			switch (this.percentBy) {
+				case "entries":
+					percentageFactor = percentByEntries;
+					break;
+				case "dependencies":
+					percentageFactor = percentByDependencies;
+					break;
+				case "modules":
+					percentageFactor = percentByModules;
+					break;
+				default:
+					percentageFactor = median3(
+						percentByModules,
+						percentByEntries,
+						percentByDependencies
+					);
+			}
 
-	get index2() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index2",
-			"DEP_WEBPACK_MODULE_INDEX2"
-		).getPostOrderIndex(this);
-	}
+			const percentage = 0.1 + percentageFactor * 0.55;
 
-	set index2(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.index2",
-			"DEP_WEBPACK_MODULE_INDEX2"
-		).setPostOrderIndex(this, value);
-	}
+			if (currentLoader) {
+				items.push(
+					`import loader ${contextify(
+						compiler.context,
+						currentLoader,
+						compiler.root
+					)}`
+				);
+			} else {
+				const statItems = [];
+				if (showEntries) {
+					statItems.push(`${doneEntries}/${entriesCount} entries`);
+				}
+				if (showDependencies) {
+					statItems.push(
+						`${doneDependencies}/${dependenciesCount} dependencies`
+					);
+				}
+				if (showModules) {
+					statItems.push(`${doneModules}/${modulesCount} modules`);
+				}
+				if (showActiveModules) {
+					statItems.push(`${activeModules.size} active`);
+				}
+				if (statItems.length > 0) {
+					items.push(statItems.join(" "));
+				}
+				if (showActiveModules) {
+					items.push(lastActiveModule);
+				}
+			}
+			handler(percentage, "building", ...items);
+			lastUpdate = Date.now();
+		};
 
-	get depth() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.depth",
-			"DEP_WEBPACK_MODULE_DEPTH"
-		).getDepth(this);
-	}
+		const factorizeAdd = () => {
+			dependenciesCount++;
+			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
+				updateThrottled();
+		};
 
-	set depth(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.depth",
-			"DEP_WEBPACK_MODULE_DEPTH"
-		).setDepth(this, value);
-	}
+		const factorizeDone = () => {
+			doneDependencies++;
+			if (doneDependencies < 50 || doneDependencies % 100 === 0)
+				updateThrottled();
+		};
 
-	get issuer() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.issuer",
-			"DEP_WEBPACK_MODULE_ISSUER"
-		).getIssuer(this);
-	}
+		const moduleAdd = () => {
+			modulesCount++;
+			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
+		};
 
-	set issuer(value) {
-		ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.issuer",
-			"DEP_WEBPACK_MODULE_ISSUER"
-		).setIssuer(this, value);
-	}
+		// only used when showActiveModules is set
+		const moduleBuild = module => {
+			const ident = module.identifier();
+			if (ident) {
+				activeModules.add(ident);
+				lastActiveModule = ident;
+				update();
+			}
+		};
 
-	get usedExports() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.usedExports",
-			"DEP_WEBPACK_MODULE_USED_EXPORTS"
-		).getUsedExports(this, undefined);
-	}
+		const entryAdd = (entry, options) => {
+			entriesCount++;
+			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
+		};
 
-	/**
-	 * @deprecated
-	 * @returns {(string | OptimizationBailoutFunction)[]} list
-	 */
-	get optimizationBailout() {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.optimizationBailout",
-			"DEP_WEBPACK_MODULE_OPTIMIZATION_BAILOUT"
-		).getOptimizationBailout(this);
-	}
+		const moduleDone = module => {
+			doneModules++;
+			if (showActiveModules) {
+				const ident = module.identifier();
+				if (ident) {
+					activeModules.delete(ident);
+					if (lastActiveModule === ident) {
+						lastActiveModule = "";
+						for (const m of activeModules) {
+							lastActiveModule = m;
+						}
+						update();
+						return;
+					}
+				}
+			}
+			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
+		};
 
-	get optional() {
-		return this.isOptional(
-			ModuleGraph.getModuleGraphForModule(
-				this,
-				"Module.optional",
-				"DEP_WEBPACK_MODULE_OPTIONAL"
-			)
-		);
-	}
+		const entryDone = (entry, options) => {
+			doneEntries++;
+			update();
+		};
 
-	addChunk(chunk) {
-		const chunkGraph = ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.addChunk",
-			"DEP_WEBPACK_MODULE_ADD_CHUNK"
-		);
-		if (chunkGraph.isModuleInChunk(this, chunk)) return false;
-		chunkGraph.connectChunkAndModule(chunk, this);
-		return true;
-	}
+		const cache = compiler
+			.getCache("ProgressPlugin")
+			.getItemCache("counts", null);
 
-	removeChunk(chunk) {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.removeChunk",
-			"DEP_WEBPACK_MODULE_REMOVE_CHUNK"
-		).disconnectChunkAndModule(chunk, this);
-	}
+		let cacheGetPromise;
 
-	isInChunk(chunk) {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.isInChunk",
-			"DEP_WEBPACK_MODULE_IS_IN_CHUNK"
-		).isModuleInChunk(this, chunk);
-	}
+		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
+			if (!cacheGetPromise) {
+				cacheGetPromise = cache.getPromise().then(
+					data => {
+						if (data) {
+							lastModulesCount = lastModulesCount || data.modulesCount;
+							lastDependenciesCount =
+								lastDependenciesCount || data.dependenciesCount;
+						}
+						return data;
+					},
+					err => {
+						// Ignore error
+					}
+				);
+			}
+		});
 
-	isEntryModule() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.isEntryModule",
-			"DEP_WEBPACK_MODULE_IS_ENTRY_MODULE"
-		).isEntryModule(this);
-	}
+		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
+			if (compilation.compiler.isChild()) return Promise.resolve();
+			return cacheGetPromise.then(async oldData => {
+				if (
+					!oldData ||
+					oldData.modulesCount !== modulesCount ||
+					oldData.dependenciesCount !== dependenciesCount
+				) {
+					await cache.storePromise({ modulesCount, dependenciesCount });
+				}
+			});
+		});
 
-	getChunks() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.getChunks",
-			"DEP_WEBPACK_MODULE_GET_CHUNKS"
-		).getModuleChunks(this);
-	}
+		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
+			if (compilation.compiler.isChild()) return;
+			lastModulesCount = modulesCount;
+			lastEntriesCount = entriesCount;
+			lastDependenciesCount = dependenciesCount;
+			modulesCount = dependenciesCount = entriesCount = 0;
+			doneModules = doneDependencies = doneEntries = 0;
 
-	getNumberOfChunks() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.getNumberOfChunks",
-			"DEP_WEBPACK_MODULE_GET_NUMBER_OF_CHUNKS"
-		).getNumberOfModuleChunks(this);
+			compilation.factorizeQueue.hooks.added.tap(
+				"ProgressPlugin",
+				factorizeAdd
+			);
+			compilation.factorizeQueue.hooks.result.tap(
+				"ProgressPlugin",
+				factorizeDone
+			);
+
+			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", moduleAdd);
+			compilation.processDependenciesQueue.hooks.result.tap(
+				"ProgressPlugin",
+				moduleDone
+			);
+
+			if (showActiveModules) {
+				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
+			}
+
+			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
+			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
+			compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
+
+			// avoid dynamic require if bundled with webpack
+			// @ts-expect-error
+			if (false) {}
+
+			const hooks = {
+				finishModules: "finish module graph",
+				seal: "plugins",
+				optimizeDependencies: "dependencies optimization",
+				afterOptimizeDependencies: "after dependencies optimization",
+				beforeChunks: "chunk graph",
+				afterChunks: "after chunk graph",
+				optimize: "optimizing",
+				optimizeModules: "module optimization",
+				afterOptimizeModules: "after module optimization",
+				optimizeChunks: "chunk optimization",
+				afterOptimizeChunks: "after chunk optimization",
+				optimizeTree: "module and chunk tree optimization",
+				afterOptimizeTree: "after module and chunk tree optimization",
+				optimizeChunkModules: "chunk modules optimization",
+				afterOptimizeChunkModules: "after chunk modules optimization",
+				reviveModules: "module reviving",
+				beforeModuleIds: "before module ids",
+				moduleIds: "module ids",
+				optimizeModuleIds: "module id optimization",
+				afterOptimizeModuleIds: "module id optimization",
+				reviveChunks: "chunk reviving",
+				beforeChunkIds: "before chunk ids",
+				chunkIds: "chunk ids",
+				optimizeChunkIds: "chunk id optimization",
+				afterOptimizeChunkIds: "after chunk id optimization",
+				recordModules: "record modules",
+				recordChunks: "record chunks",
+				beforeModuleHash: "module hashing",
+				beforeCodeGeneration: "code generation",
+				beforeRuntimeRequirements: "runtime requirements",
+				beforeHash: "hashing",
+				afterHash: "after hashing",
+				recordHash: "record hash",
+				beforeModuleAssets: "module assets processing",
+				beforeChunkAssets: "chunk assets processing",
+				processAssets: "asset processing",
+				afterProcessAssets: "after asset optimization",
+				record: "recording",
+				afterSeal: "after seal"
+			};
+			const numberOfHooks = Object.keys(hooks).length;
+			Object.keys(hooks).forEach((name, idx) => {
+				const title = hooks[name];
+				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
+				compilation.hooks[name].intercept({
+					name: "ProgressPlugin",
+					call() {
+						handler(percentage, "sealing", title);
+					},
+					done() {
+						progressReporters.set(compiler, undefined);
+						handler(percentage, "sealing", title);
+					},
+					result() {
+						handler(percentage, "sealing", title);
+					},
+					error() {
+						handler(percentage, "sealing", title);
+					},
+					tap(tap) {
+						// p is percentage from 0 to 1
+						// args is any number of messages in a hierarchical matter
+						progressReporters.set(compilation.compiler, (p, ...args) => {
+							handler(percentage, "sealing", title, tap.name, ...args);
+						});
+						handler(percentage, "sealing", title, tap.name);
+					}
+				});
+			});
+		});
+		compiler.hooks.make.intercept({
+			name: "ProgressPlugin",
+			call() {
+				handler(0.1, "building");
+			},
+			done() {
+				handler(0.65, "building");
+			}
+		});
+		const interceptHook = (hook, progress, category, name) => {
+			hook.intercept({
+				name: "ProgressPlugin",
+				call() {
+					handler(progress, category, name);
+				},
+				done() {
+					progressReporters.set(compiler, undefined);
+					handler(progress, category, name);
+				},
+				result() {
+					handler(progress, category, name);
+				},
+				error() {
+					handler(progress, category, name);
+				},
+				tap(tap) {
+					progressReporters.set(compiler, (p, ...args) => {
+						handler(progress, category, name, tap.name, ...args);
+					});
+					handler(progress, category, name, tap.name);
+				}
+			});
+		};
+		compiler.cache.hooks.endIdle.intercept({
+			name: "ProgressPlugin",
+			call() {
+				handler(0, "");
+			}
+		});
+		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
+		compiler.hooks.initialize.intercept({
+			name: "ProgressPlugin",
+			call() {
+				handler(0, "");
+			}
+		});
+		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
+		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
+		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
+		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
+		interceptHook(
+			compiler.hooks.normalModuleFactory,
+			0.04,
+			"setup",
+			"normal module factory"
+		);
+		interceptHook(
+			compiler.hooks.contextModuleFactory,
+			0.05,
+			"setup",
+			"context module factory"
+		);
+		interceptHook(
+			compiler.hooks.beforeCompile,
+			0.06,
+			"setup",
+			"before compile"
+		);
+		interceptHook(compiler.hooks.compile, 0.07, "setup", "compile");
+		interceptHook(compiler.hooks.thisCompilation, 0.08, "setup", "compilation");
+		interceptHook(compiler.hooks.compilation, 0.09, "setup", "compilation");
+		interceptHook(compiler.hooks.finishMake, 0.69, "building", "finish");
+		interceptHook(compiler.hooks.emit, 0.95, "emitting", "emit");
+		interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit");
+		interceptHook(compiler.hooks.done, 0.99, "done", "plugins");
+		compiler.hooks.done.intercept({
+			name: "ProgressPlugin",
+			done() {
+				handler(0.99, "");
+			}
+		});
+		interceptHook(
+			compiler.cache.hooks.storeBuildDependencies,
+			0.99,
+			"cache",
+			"store build dependencies"
+		);
+		interceptHook(compiler.cache.hooks.shutdown, 0.99, "cache", "shutdown");
+		interceptHook(compiler.cache.hooks.beginIdle, 0.99, "cache", "begin idle");
+		interceptHook(
+			compiler.hooks.watchClose,
+			0.99,
+			"end",
+			"closing watch compilation"
+		);
+		compiler.cache.hooks.beginIdle.intercept({
+			name: "ProgressPlugin",
+			done() {
+				handler(1, "");
+			}
+		});
+		compiler.cache.hooks.shutdown.intercept({
+			name: "ProgressPlugin",
+			done() {
+				handler(1, "");
+			}
+		});
 	}
+}
 
-	get chunksIterable() {
-		return ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.chunksIterable",
-			"DEP_WEBPACK_MODULE_CHUNKS_ITERABLE"
-		).getOrderedModuleChunksIterable(this, compareChunksById);
+ProgressPlugin.defaultOptions = {
+	profile: false,
+	modulesCount: 5000,
+	dependenciesCount: 10000,
+	modules: true,
+	dependencies: true,
+	activeModules: false,
+	entries: true
+};
+
+module.exports = ProgressPlugin;
+
+
+/***/ }),
+
+/***/ 38309:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ConstDependency = __webpack_require__(76911);
+const ProvidedDependency = __webpack_require__(95770);
+const { approve } = __webpack_require__(93998);
+
+/** @typedef {import("./Compiler")} Compiler */
+
+class ProvidePlugin {
+	/**
+	 * @param {Record<string, string | string[]>} definitions the provided identifiers
+	 */
+	constructor(definitions) {
+		this.definitions = definitions;
 	}
 
 	/**
-	 * @param {string} exportName a name of an export
-	 * @returns {boolean | null} true, if the export is provided why the module.
-	 * null, if it's unknown.
-	 * false, if it's not provided.
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	isProvided(exportName) {
-		return ModuleGraph.getModuleGraphForModule(
-			this,
-			"Module.usedExports",
-			"DEP_WEBPACK_MODULE_USED_EXPORTS"
-		).isExportProvided(this, exportName);
+	apply(compiler) {
+		const definitions = this.definitions;
+		compiler.hooks.compilation.tap(
+			"ProvidePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					ProvidedDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ProvidedDependency,
+					new ProvidedDependency.Template()
+				);
+				const handler = (parser, parserOptions) => {
+					Object.keys(definitions).forEach(name => {
+						const request = [].concat(definitions[name]);
+						const splittedName = name.split(".");
+						if (splittedName.length > 0) {
+							splittedName.slice(1).forEach((_, i) => {
+								const name = splittedName.slice(0, i + 1).join(".");
+								parser.hooks.canRename.for(name).tap("ProvidePlugin", approve);
+							});
+						}
+
+						parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
+							const nameIdentifier = name.includes(".")
+								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
+								: name;
+							const dep = new ProvidedDependency(
+								request[0],
+								nameIdentifier,
+								request.slice(1),
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+
+						parser.hooks.call.for(name).tap("ProvidePlugin", expr => {
+							const nameIdentifier = name.includes(".")
+								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
+								: name;
+							const dep = new ProvidedDependency(
+								request[0],
+								nameIdentifier,
+								request.slice(1),
+								expr.callee.range
+							);
+							dep.loc = expr.callee.loc;
+							parser.state.module.addDependency(dep);
+							parser.walkExpressions(expr.arguments);
+							return true;
+						});
+					});
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ProvidePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ProvidePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ProvidePlugin", handler);
+			}
+		);
 	}
-	// BACKWARD-COMPAT END
+}
+
+module.exports = ProvidePlugin;
+
+
+/***/ }),
+
+/***/ 84929:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const makeSerializable = __webpack_require__(33032);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["javascript"]);
 
+class RawModule extends Module {
 	/**
-	 * @returns {string} name of the exports argument
+	 * @param {string} source source code
+	 * @param {string} identifier unique identifier
+	 * @param {string=} readableIdentifier readable identifier
+	 * @param {ReadonlySet<string>=} runtimeRequirements runtime requirements needed for the source code
 	 */
-	get exportsArgument() {
-		return (this.buildInfo && this.buildInfo.exportsArgument) || "exports";
+	constructor(source, identifier, readableIdentifier, runtimeRequirements) {
+		super("javascript/dynamic", null);
+		this.sourceStr = source;
+		this.identifierStr = identifier || this.sourceStr;
+		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+		this.runtimeRequirements = runtimeRequirements || null;
 	}
 
 	/**
-	 * @returns {string} name of the module argument
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	get moduleArgument() {
-		return (this.buildInfo && this.buildInfo.moduleArgument) || "module";
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {boolean} strict the importing module is strict
-	 * @returns {"namespace" | "default-only" | "default-with-named" | "dynamic"} export type
-	 * "namespace": Exports is already a namespace object. namespace = exports.
-	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
-	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
-	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 * @returns {string} a unique identifier of the module
 	 */
-	getExportsType(moduleGraph, strict) {
-		switch (this.buildMeta && this.buildMeta.exportsType) {
-			case "flagged":
-				return strict ? "default-with-named" : "namespace";
-			case "namespace":
-				return "namespace";
-			case "default":
-				switch (this.buildMeta.defaultObject) {
-					case "redirect":
-						return "default-with-named";
-					case "redirect-warn":
-						return strict ? "default-only" : "default-with-named";
-					default:
-						return "default-only";
-				}
-			case "dynamic": {
-				if (strict) return "default-with-named";
-				// Try to figure out value of __esModule by following reexports
-				const handleDefault = () => {
-					switch (this.buildMeta.defaultObject) {
-						case "redirect":
-						case "redirect-warn":
-							return "default-with-named";
-						default:
-							return "default-only";
-					}
-				};
-				const exportInfo = moduleGraph.getReadOnlyExportInfo(
-					this,
-					"__esModule"
-				);
-				if (exportInfo.provided === false) {
-					return handleDefault();
-				}
-				const target = exportInfo.getTarget(moduleGraph);
-				if (
-					!target ||
-					!target.export ||
-					target.export.length !== 1 ||
-					target.export[0] !== "__esModule"
-				) {
-					return "dynamic";
-				}
-				switch (
-					target.module.buildMeta &&
-					target.module.buildMeta.exportsType
-				) {
-					case "flagged":
-					case "namespace":
-						return "namespace";
-					case "default":
-						return handleDefault();
-					default:
-						return "dynamic";
-				}
-			}
-			default:
-				return strict ? "default-with-named" : "dynamic";
-		}
+	identifier() {
+		return this.identifierStr;
 	}
 
 	/**
-	 * @param {Dependency} presentationalDependency dependency being tied to module.
-	 * This is a Dependency without edge in the module graph. It's only for presentation.
-	 * @returns {void}
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	addPresentationalDependency(presentationalDependency) {
-		if (this.presentationalDependencies === undefined) {
-			this.presentationalDependencies = [];
-		}
-		this.presentationalDependencies.push(presentationalDependency);
+	size(type) {
+		return Math.max(1, this.sourceStr.length);
 	}
 
 	/**
-	 * @param {Dependency} codeGenerationDependency dependency being tied to module.
-	 * This is a Dependency where the code generation result of the referenced module is needed during code generation.
-	 * The Dependency should also be added to normal dependencies via addDependency.
-	 * @returns {void}
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	addCodeGenerationDependency(codeGenerationDependency) {
-		if (this.codeGenerationDependencies === undefined) {
-			this.codeGenerationDependencies = [];
-		}
-		this.codeGenerationDependencies.push(codeGenerationDependency);
+	readableIdentifier(requestShortener) {
+		return requestShortener.shorten(this.readableIdentifierStr);
 	}
 
 	/**
-	 * Removes all dependencies and blocks
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
-	clearDependenciesAndBlocks() {
-		if (this.presentationalDependencies !== undefined) {
-			this.presentationalDependencies.length = 0;
-		}
-		if (this.codeGenerationDependencies !== undefined) {
-			this.codeGenerationDependencies.length = 0;
-		}
-		super.clearDependenciesAndBlocks();
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
 	}
 
 	/**
-	 * @param {WebpackError} warning the warning
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	addWarning(warning) {
-		if (this._warnings === undefined) {
-			this._warnings = [];
-		}
-		this._warnings.push(warning);
-	}
-
-	/**
-	 * @returns {Iterable<WebpackError> | undefined} list of warnings if any
-	 */
-	getWarnings() {
-		return this._warnings;
-	}
-
-	/**
-	 * @returns {number} number of warnings
-	 */
-	getNumberOfWarnings() {
-		return this._warnings !== undefined ? this._warnings.length : 0;
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			cacheable: true
+		};
+		callback();
 	}
 
 	/**
-	 * @param {WebpackError} error the error
-	 * @returns {void}
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	addError(error) {
-		if (this._errors === undefined) {
-			this._errors = [];
+	codeGeneration(context) {
+		const sources = new Map();
+		if (this.useSourceMap || this.useSimpleSourceMap) {
+			sources.set(
+				"javascript",
+				new OriginalSource(this.sourceStr, this.identifier())
+			);
+		} else {
+			sources.set("javascript", new RawSource(this.sourceStr));
 		}
-		this._errors.push(error);
-	}
-
-	/**
-	 * @returns {Iterable<WebpackError> | undefined} list of errors if any
-	 */
-	getErrors() {
-		return this._errors;
-	}
-
-	/**
-	 * @returns {number} number of errors
-	 */
-	getNumberOfErrors() {
-		return this._errors !== undefined ? this._errors.length : 0;
+		return { sources, runtimeRequirements: this.runtimeRequirements };
 	}
 
 	/**
-	 * removes all warnings and errors
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	clearWarningsAndErrors() {
-		if (this._warnings !== undefined) {
-			this._warnings.length = 0;
-		}
-		if (this._errors !== undefined) {
-			this._errors.length = 0;
-		}
+	updateHash(hash, context) {
+		hash.update(this.sourceStr);
+		super.updateHash(hash, context);
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {boolean} true, if the module is optional
-	 */
-	isOptional(moduleGraph) {
-		let hasConnections = false;
-		for (const r of moduleGraph.getIncomingConnections(this)) {
-			if (
-				!r.dependency ||
-				!r.dependency.optional ||
-				!r.isTargetActive(undefined)
-			) {
-				return false;
-			}
-			hasConnections = true;
-		}
-		return hasConnections;
-	}
+	serialize(context) {
+		const { write } = context;
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {Chunk} chunk a chunk
-	 * @param {Chunk=} ignoreChunk chunk to be ignored
-	 * @returns {boolean} true, if the module is accessible from "chunk" when ignoring "ignoreChunk"
-	 */
-	isAccessibleInChunk(chunkGraph, chunk, ignoreChunk) {
-		// Check if module is accessible in ALL chunk groups
-		for (const chunkGroup of chunk.groupsIterable) {
-			if (!this.isAccessibleInChunkGroup(chunkGraph, chunkGroup)) return false;
-		}
-		return true;
+		write(this.sourceStr);
+		write(this.identifierStr);
+		write(this.readableIdentifierStr);
+		write(this.runtimeRequirements);
+
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {ChunkGroup} chunkGroup a chunk group
-	 * @param {Chunk=} ignoreChunk chunk to be ignored
-	 * @returns {boolean} true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"
-	 */
-	isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk) {
-		const queue = new Set([chunkGroup]);
+	deserialize(context) {
+		const { read } = context;
 
-		// Check if module is accessible from all items of the queue
-		queueFor: for (const cg of queue) {
-			// 1. If module is in one of the chunks of the group we can continue checking the next items
-			//    because it's accessible.
-			for (const chunk of cg.chunks) {
-				if (chunk !== ignoreChunk && chunkGraph.isModuleInChunk(this, chunk))
-					continue queueFor;
-			}
-			// 2. If the chunk group is initial, we can break here because it's not accessible.
-			if (chunkGroup.isInitial()) return false;
-			// 3. Enqueue all parents because it must be accessible from ALL parents
-			for (const parent of chunkGroup.parentsIterable) queue.add(parent);
-		}
-		// When we processed through the whole list and we didn't bailout, the module is accessible
-		return true;
-	}
+		this.sourceStr = read();
+		this.identifierStr = read();
+		this.readableIdentifierStr = read();
+		this.runtimeRequirements = read();
 
-	/**
-	 * @param {Chunk} chunk a chunk
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {boolean} true, if the module has any reason why "chunk" should be included
-	 */
-	hasReasonForChunk(chunk, moduleGraph, chunkGraph) {
-		// check for each reason if we need the chunk
-		for (const [
-			fromModule,
-			connections
-		] of moduleGraph.getIncomingConnectionsByOriginModule(this)) {
-			if (!connections.some(c => c.isTargetActive(chunk.runtime))) continue;
-			for (const originChunk of chunkGraph.getModuleChunksIterable(
-				fromModule
-			)) {
-				// return true if module this is not reachable from originChunk when ignoring chunk
-				if (!this.isAccessibleInChunk(chunkGraph, originChunk, chunk))
-					return true;
-			}
-		}
-		return false;
+		super.deserialize(context);
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true if at least one other module depends on this module
-	 */
-	hasReasons(moduleGraph, runtime) {
-		for (const c of moduleGraph.getIncomingConnections(this)) {
-			if (c.isTargetActive(runtime)) return true;
-		}
-		return false;
-	}
+makeSerializable(RawModule, "webpack/lib/RawModule");
 
-	/**
-	 * @returns {string} for debugging
-	 */
-	toString() {
-		return `Module[${this.debugId}: ${this.identifier()}]`;
-	}
+module.exports = RawModule;
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(
-			null,
-			!this.buildMeta ||
-				this.needRebuild === Module.prototype.needRebuild ||
-				deprecatedNeedRebuild(this, context)
-		);
-	}
 
-	/**
-	 * @deprecated Use needBuild instead
-	 * @param {Map<string, number|null>} fileTimestamps timestamps of files
-	 * @param {Map<string, number|null>} contextTimestamps timestamps of directories
-	 * @returns {boolean} true, if the module needs a rebuild
-	 */
-	needRebuild(fileTimestamps, contextTimestamps) {
-		return true;
-	}
+/***/ }),
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(
-		hash,
-		context = {
-			chunkGraph: ChunkGraph.getChunkGraphForModule(
-				this,
-				"Module.updateHash",
-				"DEP_WEBPACK_MODULE_UPDATE_HASH"
-			),
-			runtime: undefined
-		}
-	) {
-		const { chunkGraph, runtime } = context;
-		hash.update(chunkGraph.getModuleGraphHash(this, runtime));
-		if (this.presentationalDependencies !== undefined) {
-			for (const dep of this.presentationalDependencies) {
-				dep.updateHash(hash, context);
-			}
-		}
-		super.updateHash(hash, context);
-	}
+/***/ 11094:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @returns {void}
-	 */
-	invalidateBuild() {
-		// should be overridden to support this feature
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+const { compareNumbers } = __webpack_require__(29579);
+const identifierUtils = __webpack_require__(82186);
 
-	/**
-	 * @abstract
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		// Better override this method to return the correct types
-		if (this.source === Module.prototype.source) {
-			return DEFAULT_TYPES_UNKNOWN;
-		} else {
-			return DEFAULT_TYPES_JS;
-		}
-	}
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
 
-	/**
-	 * @abstract
-	 * @deprecated Use codeGeneration() instead
-	 * @param {DependencyTemplates} dependencyTemplates the dependency templates
-	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {string=} type the type of source that should be generated
-	 * @returns {Source} generated source
-	 */
-	source(dependencyTemplates, runtimeTemplate, type = "javascript") {
-		if (this.codeGeneration === Module.prototype.codeGeneration) {
-			const AbstractMethodError = __webpack_require__(77198);
-			throw new AbstractMethodError();
-		}
-		const chunkGraph = ChunkGraph.getChunkGraphForModule(
-			this,
-			"Module.source() is deprecated. Use Compilation.codeGenerationResults.getSource(module, runtime, type) instead",
-			"DEP_WEBPACK_MODULE_SOURCE"
-		);
-		/** @type {CodeGenerationContext} */
-		const codeGenContext = {
-			dependencyTemplates,
-			runtimeTemplate,
-			moduleGraph: chunkGraph.moduleGraph,
-			chunkGraph,
-			runtime: undefined,
-			codeGenerationResults: undefined
-		};
-		const sources = this.codeGeneration(codeGenContext).sources;
-		return type ? sources.get(type) : sources.get(first(this.getSourceTypes()));
-	}
+/**
+ * @typedef {Object} RecordsChunks
+ * @property {Record<string, number>=} byName
+ * @property {Record<string, number>=} bySource
+ * @property {number[]=} usedIds
+ */
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+/**
+ * @typedef {Object} RecordsModules
+ * @property {Record<string, number>=} byIdentifier
+ * @property {Record<string, number>=} bySource
+ * @property {number[]=} usedIds
+ */
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return null;
-	}
+/**
+ * @typedef {Object} Records
+ * @property {RecordsChunks=} chunks
+ * @property {RecordsModules=} modules
+ */
 
+class RecordIdsPlugin {
 	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 * @param {Object} options Options object
+	 * @param {boolean=} options.portableIds true, when ids need to be portable
 	 */
-	nameForCondition() {
-		return null;
+	constructor(options) {
+		this.options = options || {};
 	}
 
 	/**
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 * @param {Compiler} compiler the Compiler
+	 * @returns {void}
 	 */
-	getConcatenationBailoutReason(context) {
-		return `Module Concatenation is not implemented for ${this.constructor.name}`;
-	}
+	apply(compiler) {
+		const portableIds = this.options.portableIds;
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
-	 */
-	getSideEffectsConnectionState(moduleGraph) {
-		return true;
-	}
+		const makePathsRelative =
+			identifierUtils.makePathsRelative.bindContextCache(
+				compiler.context,
+				compiler.root
+			);
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		// Best override this method
-		const sources = new Map();
-		for (const type of this.getSourceTypes()) {
-			if (type !== "unknown") {
-				sources.set(
-					type,
-					this.source(
-						context.dependencyTemplates,
-						context.runtimeTemplate,
-						type
-					)
-				);
+		/**
+		 * @param {Module} module the module
+		 * @returns {string} the (portable) identifier
+		 */
+		const getModuleIdentifier = module => {
+			if (portableIds) {
+				return makePathsRelative(module.identifier());
 			}
-		}
-		return {
-			sources,
-			runtimeRequirements: new Set([
-				RuntimeGlobals.module,
-				RuntimeGlobals.exports,
-				RuntimeGlobals.require
-			])
+			return module.identifier();
 		};
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk which condition should be checked
-	 * @param {Compilation} compilation the compilation
-	 * @returns {boolean} true, if the chunk is ok for the module
-	 */
-	chunkCondition(chunk, compilation) {
-		return true;
-	}
 
-	hasChunkCondition() {
-		return this.chunkCondition !== Module.prototype.chunkCondition;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		this.type = module.type;
-		this.layer = module.layer;
-		this.context = module.context;
-		this.factoryMeta = module.factoryMeta;
-		this.resolveOptions = module.resolveOptions;
-	}
+		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
+			compilation.hooks.recordModules.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(modules, records) => {
+					const chunkGraph = compilation.chunkGraph;
+					if (!records.modules) records.modules = {};
+					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					for (const module of modules) {
+						const moduleId = chunkGraph.getModuleId(module);
+						if (typeof moduleId !== "number") continue;
+						const identifier = getModuleIdentifier(module);
+						records.modules.byIdentifier[identifier] = moduleId;
+						usedIds.add(moduleId);
+					}
+					records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
+				}
+			);
+			compilation.hooks.reviveModules.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Module[]} modules the modules array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(modules, records) => {
+					if (!records.modules) return;
+					if (records.modules.byIdentifier) {
+						const chunkGraph = compilation.chunkGraph;
+						/** @type {Set<number>} */
+						const usedIds = new Set();
+						for (const module of modules) {
+							const moduleId = chunkGraph.getModuleId(module);
+							if (moduleId !== null) continue;
+							const identifier = getModuleIdentifier(module);
+							const id = records.modules.byIdentifier[identifier];
+							if (id === undefined) continue;
+							if (usedIds.has(id)) continue;
+							usedIds.add(id);
+							chunkGraph.setModuleId(module, id);
+						}
+					}
+					if (Array.isArray(records.modules.usedIds)) {
+						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					}
+				}
+			);
 
-	/**
-	 * Module should be unsafe cached. Get data that's needed for that.
-	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
-	 */
-	getUnsafeCacheData() {
-		return {
-			factoryMeta: this.factoryMeta,
-			resolveOptions: this.resolveOptions
-		};
-	}
-
-	/**
-	 * restore unsafe cache data
-	 * @param {object} unsafeCacheData data from getUnsafeCacheData
-	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
-	 */
-	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		this.factoryMeta = unsafeCacheData.factoryMeta;
-		this.resolveOptions = unsafeCacheData.resolveOptions;
-	}
-
-	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
-	 */
-	cleanupForCache() {
-		this.factoryMeta = undefined;
-		this.resolveOptions = undefined;
-	}
-
-	/**
-	 * @returns {Source | null} the original source for the module before webpack transformation
-	 */
-	originalSource() {
-		return null;
-	}
-
-	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
-	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.type);
-		write(this.layer);
-		write(this.context);
-		write(this.resolveOptions);
-		write(this.factoryMeta);
-		write(this.useSourceMap);
-		write(this.useSimpleSourceMap);
-		write(
-			this._warnings !== undefined && this._warnings.length === 0
-				? undefined
-				: this._warnings
-		);
-		write(
-			this._errors !== undefined && this._errors.length === 0
-				? undefined
-				: this._errors
-		);
-		write(this.buildMeta);
-		write(this.buildInfo);
-		write(this.presentationalDependencies);
-		write(this.codeGenerationDependencies);
-		super.serialize(context);
-	}
+			/**
+			 * @param {Chunk} chunk the chunk
+			 * @returns {string[]} sources of the chunk
+			 */
+			const getChunkSources = chunk => {
+				/** @type {string[]} */
+				const sources = [];
+				for (const chunkGroup of chunk.groupsIterable) {
+					const index = chunkGroup.chunks.indexOf(chunk);
+					if (chunkGroup.name) {
+						sources.push(`${index} ${chunkGroup.name}`);
+					} else {
+						for (const origin of chunkGroup.origins) {
+							if (origin.module) {
+								if (origin.request) {
+									sources.push(
+										`${index} ${getModuleIdentifier(origin.module)} ${
+											origin.request
+										}`
+									);
+								} else if (typeof origin.loc === "string") {
+									sources.push(
+										`${index} ${getModuleIdentifier(origin.module)} ${
+											origin.loc
+										}`
+									);
+								} else if (
+									origin.loc &&
+									typeof origin.loc === "object" &&
+									"start" in origin.loc
+								) {
+									sources.push(
+										`${index} ${getModuleIdentifier(
+											origin.module
+										)} ${JSON.stringify(origin.loc.start)}`
+									);
+								}
+							}
+						}
+					}
+				}
+				return sources;
+			};
 
-	deserialize(context) {
-		const { read } = context;
-		this.type = read();
-		this.layer = read();
-		this.context = read();
-		this.resolveOptions = read();
-		this.factoryMeta = read();
-		this.useSourceMap = read();
-		this.useSimpleSourceMap = read();
-		this._warnings = read();
-		this._errors = read();
-		this.buildMeta = read();
-		this.buildInfo = read();
-		this.presentationalDependencies = read();
-		this.codeGenerationDependencies = read();
-		super.deserialize(context);
+			compilation.hooks.recordChunks.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(chunks, records) => {
+					if (!records.chunks) records.chunks = {};
+					if (!records.chunks.byName) records.chunks.byName = {};
+					if (!records.chunks.bySource) records.chunks.bySource = {};
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					for (const chunk of chunks) {
+						if (typeof chunk.id !== "number") continue;
+						const name = chunk.name;
+						if (name) records.chunks.byName[name] = chunk.id;
+						const sources = getChunkSources(chunk);
+						for (const source of sources) {
+							records.chunks.bySource[source] = chunk.id;
+						}
+						usedIds.add(chunk.id);
+					}
+					records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
+				}
+			);
+			compilation.hooks.reviveChunks.tap(
+				"RecordIdsPlugin",
+				/**
+				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Records} records the records object
+				 * @returns {void}
+				 */
+				(chunks, records) => {
+					if (!records.chunks) return;
+					/** @type {Set<number>} */
+					const usedIds = new Set();
+					if (records.chunks.byName) {
+						for (const chunk of chunks) {
+							if (chunk.id !== null) continue;
+							if (!chunk.name) continue;
+							const id = records.chunks.byName[chunk.name];
+							if (id === undefined) continue;
+							if (usedIds.has(id)) continue;
+							usedIds.add(id);
+							chunk.id = id;
+							chunk.ids = [id];
+						}
+					}
+					if (records.chunks.bySource) {
+						for (const chunk of chunks) {
+							if (chunk.id !== null) continue;
+							const sources = getChunkSources(chunk);
+							for (const source of sources) {
+								const id = records.chunks.bySource[source];
+								if (id === undefined) continue;
+								if (usedIds.has(id)) continue;
+								usedIds.add(id);
+								chunk.id = id;
+								chunk.ids = [id];
+								break;
+							}
+						}
+					}
+					if (Array.isArray(records.chunks.usedIds)) {
+						compilation.usedChunkIds = new Set(records.chunks.usedIds);
+					}
+				}
+			);
+		});
 	}
 }
-
-makeSerializable(Module, "webpack/lib/Module");
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "hasEqualsChunks", {
-	get() {
-		throw new Error(
-			"Module.hasEqualsChunks was renamed (use hasEqualChunks instead)"
-		);
-	}
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "isUsed", {
-	get() {
-		throw new Error(
-			"Module.isUsed was renamed (use getUsedName, isExportUsed or isModuleUsed instead)"
-		);
-	}
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "errors", {
-	get: util.deprecate(
-		/**
-		 * @this {Module}
-		 * @returns {WebpackError[]} array
-		 */
-		function () {
-			if (this._errors === undefined) {
-				this._errors = [];
-			}
-			return this._errors;
-		},
-		"Module.errors was removed (use getErrors instead)",
-		"DEP_WEBPACK_MODULE_ERRORS"
-	)
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "warnings", {
-	get: util.deprecate(
-		/**
-		 * @this {Module}
-		 * @returns {WebpackError[]} array
-		 */
-		function () {
-			if (this._warnings === undefined) {
-				this._warnings = [];
-			}
-			return this._warnings;
-		},
-		"Module.warnings was removed (use getWarnings instead)",
-		"DEP_WEBPACK_MODULE_WARNINGS"
-	)
-});
-
-// TODO remove in webpack 6
-Object.defineProperty(Module.prototype, "used", {
-	get() {
-		throw new Error(
-			"Module.used was refactored (use ModuleGraph.getUsedExports instead)"
-		);
-	},
-	set(value) {
-		throw new Error(
-			"Module.used was refactored (use ModuleGraph.setUsedExports instead)"
-		);
-	}
-});
-
-module.exports = Module;
+module.exports = RecordIdsPlugin;
 
 
 /***/ }),
 
-/***/ 21305:
+/***/ 73406:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -51948,81 +52335,38 @@ module.exports = Module;
 
 
 
-const { cutOffLoaderExecution } = __webpack_require__(59985);
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+const { contextify } = __webpack_require__(82186);
 
-class ModuleBuildError extends WebpackError {
+class RequestShortener {
 	/**
-	 * @param {string | Error&any} err error thrown
-	 * @param {{from?: string|null}} info additional info
+	 * @param {string} dir the directory
+	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
 	 */
-	constructor(err, { from = null } = {}) {
-		let message = "Module build failed";
-		let details = undefined;
-
-		if (from) {
-			message += ` (from ${from}):\n`;
-		} else {
-			message += ": ";
-		}
-
-		if (err !== null && typeof err === "object") {
-			if (typeof err.stack === "string" && err.stack) {
-				const stack = cutOffLoaderExecution(err.stack);
-
-				if (!err.hideStack) {
-					message += stack;
-				} else {
-					details = stack;
-
-					if (typeof err.message === "string" && err.message) {
-						message += err.message;
-					} else {
-						message += err;
-					}
-				}
-			} else if (typeof err.message === "string" && err.message) {
-				message += err.message;
-			} else {
-				message += String(err);
-			}
-		} else {
-			message += String(err);
-		}
-
-		super(message);
-
-		this.name = "ModuleBuildError";
-		this.details = details;
-		this.error = err;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
-
-		super.serialize(context);
+	constructor(dir, associatedObjectForCache) {
+		this.contextify = contextify.bindContextCache(
+			dir,
+			associatedObjectForCache
+		);
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
-
-		super.deserialize(context);
+	/**
+	 * @param {string | undefined | null} request the request to shorten
+	 * @returns {string | undefined | null} the shortened request
+	 */
+	shorten(request) {
+		if (!request) {
+			return request;
+		}
+		return this.contextify(request);
 	}
 }
 
-makeSerializable(ModuleBuildError, "webpack/lib/ModuleBuildError");
-
-module.exports = ModuleBuildError;
+module.exports = RequestShortener;
 
 
 /***/ }),
 
-/***/ 67409:
+/***/ 88846:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -52033,44 +52377,81 @@ module.exports = ModuleBuildError;
 
 
 
-const WebpackError = __webpack_require__(53799);
+const RuntimeGlobals = __webpack_require__(16475);
+const ConstDependency = __webpack_require__(76911);
+const {
+	toConstantDependency
+} = __webpack_require__(93998);
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("./Compiler")} Compiler */
 
-class ModuleDependencyError extends WebpackError {
+module.exports = class RequireJsStuffPlugin {
 	/**
-	 * Creates an instance of ModuleDependencyError.
-	 * @param {Module} module module tied to dependency
-	 * @param {Error} err error thrown
-	 * @param {DependencyLocation} loc location of dependency
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(module, err, loc) {
-		super(err.message);
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireJsStuffPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					ConstDependency,
+					new ConstDependency.Template()
+				);
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireJs === undefined ||
+						!parserOptions.requireJs
+					) {
+						return;
+					}
 
-		this.name = "ModuleDependencyError";
-		this.details =
-			err && !(/** @type {any} */ (err).hideStack)
-				? err.stack.split("\n").slice(1).join("\n")
-				: undefined;
-		this.module = module;
-		this.loc = loc;
-		/** error is not (de)serialized, so it might be undefined after deserialization */
-		this.error = err;
+					parser.hooks.call
+						.for("require.config")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(parser, "undefined")
+						);
+					parser.hooks.call
+						.for("requirejs.config")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(parser, "undefined")
+						);
 
-		if (err && /** @type {any} */ (err).hideStack) {
-			this.stack =
-				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
-		}
+					parser.hooks.expression
+						.for("require.version")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(parser, JSON.stringify("0.0.0"))
+						);
+					parser.hooks.expression
+						.for("requirejs.onError")
+						.tap(
+							"RequireJsStuffPlugin",
+							toConstantDependency(
+								parser,
+								RuntimeGlobals.uncaughtErrorHandler,
+								[RuntimeGlobals.uncaughtErrorHandler]
+							)
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireJsStuffPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireJsStuffPlugin", handler);
+			}
+		);
 	}
-}
-
-module.exports = ModuleDependencyError;
+};
 
 
 /***/ }),
 
-/***/ 29656:
+/***/ 30217:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -52081,119 +52462,156 @@ module.exports = ModuleDependencyError;
 
 
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-
-class ModuleDependencyWarning extends WebpackError {
-	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {Error} err error thrown
-	 * @param {DependencyLocation} loc location of dependency
-	 */
-	constructor(module, err, loc) {
-		super(err ? err.message : "");
-
-		this.name = "ModuleDependencyWarning";
-		this.details =
-			err && !(/** @type {any} */ (err).hideStack)
-				? err.stack.split("\n").slice(1).join("\n")
-				: undefined;
-		this.module = module;
-		this.loc = loc;
-		/** error is not (de)serialized, so it might be undefined after deserialization */
-		this.error = err;
+const Factory = (__webpack_require__(9256).ResolverFactory);
+const { HookMap, SyncHook, SyncWaterfallHook } = __webpack_require__(6967);
+const {
+	cachedCleverMerge,
+	removeOperations,
+	resolveByProperty
+} = __webpack_require__(60839);
 
-		if (err && /** @type {any} */ (err).hideStack) {
-			this.stack =
-				err.stack.split("\n").slice(1).join("\n") + "\n\n" + this.stack;
-		}
-	}
-}
+/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} WebpackResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
 
-makeSerializable(
-	ModuleDependencyWarning,
-	"webpack/lib/ModuleDependencyWarning"
-);
+/** @typedef {WebpackResolveOptions & {dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
+/**
+ * @typedef {Object} WithOptions
+ * @property {function(Partial<ResolveOptionsWithDependencyType>): ResolverWithOptions} withOptions create a resolver with additional/different options
+ */
 
-module.exports = ModuleDependencyWarning;
+/** @typedef {Resolver & WithOptions} ResolverWithOptions */
 
+// need to be hoisted on module level for caching identity
+const EMPTY_RESOLVE_OPTIONS = {};
 
-/***/ }),
+/**
+ * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType enhanced options
+ * @returns {ResolveOptions} merged options
+ */
+const convertToResolveOptions = resolveOptionsWithDepType => {
+	const { dependencyType, plugins, ...remaining } = resolveOptionsWithDepType;
 
-/***/ 23744:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	// check type compat
+	/** @type {Partial<ResolveOptions>} */
+	const partialOptions = {
+		...remaining,
+		plugins:
+			plugins &&
+			/** @type {ResolvePluginInstance[]} */ (
+				plugins.filter(item => item !== "...")
+			)
+	};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	if (!partialOptions.fileSystem) {
+		throw new Error(
+			"fileSystem is missing in resolveOptions, but it's required for enhanced-resolve"
+		);
+	}
+	// These weird types validate that we checked all non-optional properties
+	const options =
+		/** @type {Partial<ResolveOptions> & Pick<ResolveOptions, "fileSystem">} */ (
+			partialOptions
+		);
 
+	return removeOperations(
+		resolveByProperty(options, "byDependency", dependencyType)
+	);
+};
 
+/**
+ * @typedef {Object} ResolverCache
+ * @property {WeakMap<Object, ResolverWithOptions>} direct
+ * @property {Map<string, ResolverWithOptions>} stringified
+ */
 
-const { cleanUp } = __webpack_require__(59985);
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+module.exports = class ResolverFactory {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>} */
+			resolveOptions: new HookMap(
+				() => new SyncWaterfallHook(["resolveOptions"])
+			),
+			/** @type {HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>} */
+			resolver: new HookMap(
+				() => new SyncHook(["resolver", "resolveOptions", "userResolveOptions"])
+			)
+		});
+		/** @type {Map<string, ResolverCache>} */
+		this.cache = new Map();
+	}
 
-class ModuleError extends WebpackError {
 	/**
-	 * @param {Error} err error thrown
-	 * @param {{from?: string|null}} info additional info
+	 * @param {string} type type of resolver
+	 * @param {ResolveOptionsWithDependencyType=} resolveOptions options
+	 * @returns {ResolverWithOptions} the resolver
 	 */
-	constructor(err, { from = null } = {}) {
-		let message = "Module Error";
-
-		if (from) {
-			message += ` (from ${from}):\n`;
-		} else {
-			message += ": ";
+	get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
+		let typedCaches = this.cache.get(type);
+		if (!typedCaches) {
+			typedCaches = {
+				direct: new WeakMap(),
+				stringified: new Map()
+			};
+			this.cache.set(type, typedCaches);
 		}
-
-		if (err && typeof err === "object" && err.message) {
-			message += err.message;
-		} else if (err) {
-			message += err;
+		const cachedResolver = typedCaches.direct.get(resolveOptions);
+		if (cachedResolver) {
+			return cachedResolver;
 		}
-
-		super(message);
-
-		this.name = "ModuleError";
-		this.error = err;
-		this.details =
-			err && typeof err === "object" && err.stack
-				? cleanUp(err.stack, this.message)
-				: undefined;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
-
-		super.serialize(context);
+		const ident = JSON.stringify(resolveOptions);
+		const resolver = typedCaches.stringified.get(ident);
+		if (resolver) {
+			typedCaches.direct.set(resolveOptions, resolver);
+			return resolver;
+		}
+		const newResolver = this._create(type, resolveOptions);
+		typedCaches.direct.set(resolveOptions, newResolver);
+		typedCaches.stringified.set(ident, newResolver);
+		return newResolver;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.error = read();
+	/**
+	 * @param {string} type type of resolver
+	 * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options
+	 * @returns {ResolverWithOptions} the resolver
+	 */
+	_create(type, resolveOptionsWithDepType) {
+		/** @type {ResolveOptionsWithDependencyType} */
+		const originalResolveOptions = { ...resolveOptionsWithDepType };
 
-		super.deserialize(context);
+		const resolveOptions = convertToResolveOptions(
+			this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType)
+		);
+		const resolver = /** @type {ResolverWithOptions} */ (
+			Factory.createResolver(resolveOptions)
+		);
+		if (!resolver) {
+			throw new Error("No resolver created");
+		}
+		/** @type {WeakMap<Partial<ResolveOptionsWithDependencyType>, ResolverWithOptions>} */
+		const childCache = new WeakMap();
+		resolver.withOptions = options => {
+			const cacheEntry = childCache.get(options);
+			if (cacheEntry !== undefined) return cacheEntry;
+			const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
+			const resolver = this.get(type, mergedOptions);
+			childCache.set(options, resolver);
+			return resolver;
+		};
+		this.hooks.resolver
+			.for(type)
+			.call(resolver, resolveOptions, originalResolveOptions);
+		return resolver;
 	}
-}
-
-makeSerializable(ModuleError, "webpack/lib/ModuleError");
-
-module.exports = ModuleError;
+};
 
 
 /***/ }),
 
-/***/ 51010:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 16475:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -52203,1876 +52621,2106 @@ module.exports = ModuleError;
 
 
 
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
+/**
+ * the internal require function
+ */
+exports.require = "__webpack_require__";
 
 /**
- * @typedef {Object} ModuleFactoryResult
- * @property {Module=} module the created module or unset if no module was created
- * @property {Set<string>=} fileDependencies
- * @property {Set<string>=} contextDependencies
- * @property {Set<string>=} missingDependencies
- * @property {boolean=} cacheable allow to use the unsafe cache
+ * access to properties of the internal require function/object
  */
+exports.requireScope = "__webpack_require__.*";
 
 /**
- * @typedef {Object} ModuleFactoryCreateDataContextInfo
- * @property {string} issuer
- * @property {string | null=} issuerLayer
- * @property {string} compiler
+ * the internal exports object
  */
+exports.exports = "__webpack_exports__";
 
 /**
- * @typedef {Object} ModuleFactoryCreateData
- * @property {ModuleFactoryCreateDataContextInfo} contextInfo
- * @property {ResolveOptions=} resolveOptions
- * @property {string} context
- * @property {Dependency[]} dependencies
+ * top-level this need to be the exports object
  */
+exports.thisAsExports = "top-level-this-exports";
 
-class ModuleFactory {
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
-}
+/**
+ * runtime need to return the exports of the last entry module
+ */
+exports.returnExportsFromRuntime = "return-exports-from-runtime";
 
-module.exports = ModuleFactory;
+/**
+ * the internal module object
+ */
+exports.module = "module";
 
+/**
+ * the internal module object
+ */
+exports.moduleId = "module.id";
 
-/***/ }),
+/**
+ * the internal module object
+ */
+exports.moduleLoaded = "module.loaded";
 
-/***/ 88821:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/**
+ * the bundle public path
+ */
+exports.publicPath = "__webpack_require__.p";
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * the module id of the entry point
+ */
+exports.entryModuleId = "__webpack_require__.s";
 
+/**
+ * the module cache
+ */
+exports.moduleCache = "__webpack_require__.c";
 
+/**
+ * the module functions
+ */
+exports.moduleFactories = "__webpack_require__.m";
 
-const NormalModule = __webpack_require__(39);
-const createHash = __webpack_require__(49835);
-const memoize = __webpack_require__(78676);
+/**
+ * the module functions, with only write access
+ */
+exports.moduleFactoriesAddOnly = "__webpack_require__.m (add only)";
 
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {typeof import("./util/Hash")} Hash */
+/**
+ * the chunk ensure function
+ */
+exports.ensureChunk = "__webpack_require__.e";
 
-const ModuleFilenameHelpers = exports;
+/**
+ * an object with handlers to ensure a chunk
+ */
+exports.ensureChunkHandlers = "__webpack_require__.f";
 
-// TODO webpack 6: consider removing these
-ModuleFilenameHelpers.ALL_LOADERS_RESOURCE = "[all-loaders][resource]";
-ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE =
-	/\[all-?loaders\]\[resource\]/gi;
-ModuleFilenameHelpers.LOADERS_RESOURCE = "[loaders][resource]";
-ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
-ModuleFilenameHelpers.RESOURCE = "[resource]";
-ModuleFilenameHelpers.REGEXP_RESOURCE = /\[resource\]/gi;
-ModuleFilenameHelpers.ABSOLUTE_RESOURCE_PATH = "[absolute-resource-path]";
-// cSpell:words olute
-ModuleFilenameHelpers.REGEXP_ABSOLUTE_RESOURCE_PATH =
-	/\[abs(olute)?-?resource-?path\]/gi;
-ModuleFilenameHelpers.RESOURCE_PATH = "[resource-path]";
-ModuleFilenameHelpers.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
-ModuleFilenameHelpers.ALL_LOADERS = "[all-loaders]";
-ModuleFilenameHelpers.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
-ModuleFilenameHelpers.LOADERS = "[loaders]";
-ModuleFilenameHelpers.REGEXP_LOADERS = /\[loaders\]/gi;
-ModuleFilenameHelpers.QUERY = "[query]";
-ModuleFilenameHelpers.REGEXP_QUERY = /\[query\]/gi;
-ModuleFilenameHelpers.ID = "[id]";
-ModuleFilenameHelpers.REGEXP_ID = /\[id\]/gi;
-ModuleFilenameHelpers.HASH = "[hash]";
-ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
-ModuleFilenameHelpers.NAMESPACE = "[namespace]";
-ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
+/**
+ * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
+ */
+exports.ensureChunkIncludeEntries = "__webpack_require__.f (include entries)";
 
-const getAfter = (strFn, token) => {
-	return () => {
-		const str = strFn();
-		const idx = str.indexOf(token);
-		return idx < 0 ? "" : str.substr(idx);
-	};
-};
+/**
+ * the chunk prefetch function
+ */
+exports.prefetchChunk = "__webpack_require__.E";
 
-const getBefore = (strFn, token) => {
-	return () => {
-		const str = strFn();
-		const idx = str.lastIndexOf(token);
-		return idx < 0 ? "" : str.substr(0, idx);
-	};
-};
+/**
+ * an object with handlers to prefetch a chunk
+ */
+exports.prefetchChunkHandlers = "__webpack_require__.F";
 
-const getHash = (strFn, hashFunction) => {
-	return () => {
-		const hash = createHash(hashFunction);
-		hash.update(strFn());
-		const digest = /** @type {string} */ (hash.digest("hex"));
-		return digest.substr(0, 4);
-	};
-};
+/**
+ * the chunk preload function
+ */
+exports.preloadChunk = "__webpack_require__.G";
 
-const asRegExp = test => {
-	if (typeof test === "string") {
-		test = new RegExp("^" + test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"));
-	}
-	return test;
-};
+/**
+ * an object with handlers to preload a chunk
+ */
+exports.preloadChunkHandlers = "__webpack_require__.H";
 
-const lazyObject = obj => {
-	const newObj = {};
-	for (const key of Object.keys(obj)) {
-		const fn = obj[key];
-		Object.defineProperty(newObj, key, {
-			get: () => fn(),
-			set: v => {
-				Object.defineProperty(newObj, key, {
-					value: v,
-					enumerable: true,
-					writable: true
-				});
-			},
-			enumerable: true,
-			configurable: true
-		});
-	}
-	return newObj;
-};
+/**
+ * the exported property define getters function
+ */
+exports.definePropertyGetters = "__webpack_require__.d";
 
-const REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+/**
+ * define compatibility on export
+ */
+exports.makeNamespaceObject = "__webpack_require__.r";
 
 /**
- *
- * @param {Module | string} module the module
- * @param {TODO} options options
- * @param {Object} contextInfo context info
- * @param {RequestShortener} contextInfo.requestShortener requestShortener
- * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
- * @param {string | Hash} contextInfo.hashFunction the hash function to use
- * @returns {string} the filename
+ * create a fake namespace object
  */
-ModuleFilenameHelpers.createFilename = (
-	module = "",
-	options,
-	{ requestShortener, chunkGraph, hashFunction = "md4" }
-) => {
-	const opts = {
-		namespace: "",
-		moduleFilenameTemplate: "",
-		...(typeof options === "object"
-			? options
-			: {
-					moduleFilenameTemplate: options
-			  })
-	};
+exports.createFakeNamespaceObject = "__webpack_require__.t";
 
-	let absoluteResourcePath;
-	let hash;
-	let identifier;
-	let moduleId;
-	let shortIdentifier;
-	if (typeof module === "string") {
-		shortIdentifier = memoize(() => requestShortener.shorten(module));
-		identifier = shortIdentifier;
-		moduleId = () => "";
-		absoluteResourcePath = () => module.split("!").pop();
-		hash = getHash(identifier, hashFunction);
-	} else {
-		shortIdentifier = memoize(() =>
-			module.readableIdentifier(requestShortener)
-		);
-		identifier = memoize(() => requestShortener.shorten(module.identifier()));
-		moduleId = () => chunkGraph.getModuleId(module);
-		absoluteResourcePath = () =>
-			module instanceof NormalModule
-				? module.resource
-				: module.identifier().split("!").pop();
-		hash = getHash(identifier, hashFunction);
-	}
-	const resource = memoize(() => shortIdentifier().split("!").pop());
+/**
+ * compatibility get default export
+ */
+exports.compatGetDefaultExport = "__webpack_require__.n";
 
-	const loaders = getBefore(shortIdentifier, "!");
-	const allLoaders = getBefore(identifier, "!");
-	const query = getAfter(resource, "?");
-	const resourcePath = () => {
-		const q = query().length;
-		return q === 0 ? resource() : resource().slice(0, -q);
-	};
-	if (typeof opts.moduleFilenameTemplate === "function") {
-		return opts.moduleFilenameTemplate(
-			lazyObject({
-				identifier: identifier,
-				shortIdentifier: shortIdentifier,
-				resource: resource,
-				resourcePath: memoize(resourcePath),
-				absoluteResourcePath: memoize(absoluteResourcePath),
-				allLoaders: memoize(allLoaders),
-				query: memoize(query),
-				moduleId: memoize(moduleId),
-				hash: memoize(hash),
-				namespace: () => opts.namespace
-			})
-		);
-	}
+/**
+ * harmony module decorator
+ */
+exports.harmonyModuleDecorator = "__webpack_require__.hmd";
 
-	// TODO webpack 6: consider removing alternatives without dashes
-	/** @type {Map<string, function(): string>} */
-	const replacements = new Map([
-		["identifier", identifier],
-		["short-identifier", shortIdentifier],
-		["resource", resource],
-		["resource-path", resourcePath],
-		// cSpell:words resourcepath
-		["resourcepath", resourcePath],
-		["absolute-resource-path", absoluteResourcePath],
-		["abs-resource-path", absoluteResourcePath],
-		// cSpell:words absoluteresource
-		["absoluteresource-path", absoluteResourcePath],
-		// cSpell:words absresource
-		["absresource-path", absoluteResourcePath],
-		// cSpell:words resourcepath
-		["absolute-resourcepath", absoluteResourcePath],
-		// cSpell:words resourcepath
-		["abs-resourcepath", absoluteResourcePath],
-		// cSpell:words absoluteresourcepath
-		["absoluteresourcepath", absoluteResourcePath],
-		// cSpell:words absresourcepath
-		["absresourcepath", absoluteResourcePath],
-		["all-loaders", allLoaders],
-		// cSpell:words allloaders
-		["allloaders", allLoaders],
-		["loaders", loaders],
-		["query", query],
-		["id", moduleId],
-		["hash", hash],
-		["namespace", () => opts.namespace]
-	]);
+/**
+ * node.js module decorator
+ */
+exports.nodeModuleDecorator = "__webpack_require__.nmd";
 
-	// TODO webpack 6: consider removing weird double placeholders
-	return opts.moduleFilenameTemplate
-		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
-		.replace(
-			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,
-			"[short-identifier]"
-		)
-		.replace(REGEXP, (match, content) => {
-			if (content.length + 2 === match.length) {
-				const replacement = replacements.get(content.toLowerCase());
-				if (replacement !== undefined) {
-					return replacement();
-				}
-			} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
-				return `[${match.slice(2, -2)}]`;
-			}
-			return match;
-		});
-};
+/**
+ * the webpack hash
+ */
+exports.getFullHash = "__webpack_require__.h";
 
-ModuleFilenameHelpers.replaceDuplicates = (array, fn, comparator) => {
-	const countMap = Object.create(null);
-	const posMap = Object.create(null);
-	array.forEach((item, idx) => {
-		countMap[item] = countMap[item] || [];
-		countMap[item].push(idx);
-		posMap[item] = 0;
-	});
-	if (comparator) {
-		Object.keys(countMap).forEach(item => {
-			countMap[item].sort(comparator);
-		});
-	}
-	return array.map((item, i) => {
-		if (countMap[item].length > 1) {
-			if (comparator && countMap[item][0] === i) return item;
-			return fn(item, i, posMap[item]++);
-		} else {
-			return item;
-		}
-	});
-};
+/**
+ * an object containing all installed WebAssembly.Instance export objects keyed by module id
+ */
+exports.wasmInstances = "__webpack_require__.w";
 
-ModuleFilenameHelpers.matchPart = (str, test) => {
-	if (!test) return true;
-	test = asRegExp(test);
-	if (Array.isArray(test)) {
-		return test.map(asRegExp).some(regExp => regExp.test(str));
-	} else {
-		return test.test(str);
-	}
-};
+/**
+ * instantiate a wasm instance from module exports object, id, hash and importsObject
+ */
+exports.instantiateWasm = "__webpack_require__.v";
 
-ModuleFilenameHelpers.matchObject = (obj, str) => {
-	if (obj.test) {
-		if (!ModuleFilenameHelpers.matchPart(str, obj.test)) {
-			return false;
-		}
-	}
-	if (obj.include) {
-		if (!ModuleFilenameHelpers.matchPart(str, obj.include)) {
-			return false;
-		}
-	}
-	if (obj.exclude) {
-		if (ModuleFilenameHelpers.matchPart(str, obj.exclude)) {
-			return false;
-		}
-	}
-	return true;
-};
+/**
+ * the uncaught error handler for the webpack runtime
+ */
+exports.uncaughtErrorHandler = "__webpack_require__.oe";
 
+/**
+ * the script nonce
+ */
+exports.scriptNonce = "__webpack_require__.nc";
 
-/***/ }),
+/**
+ * function to load a script tag.
+ * Arguments: (url: string, done: (event) => void), key?: string | number, chunkId?: string | number) => void
+ * done function is called when loading has finished or timeout occurred.
+ * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
+ */
+exports.loadScript = "__webpack_require__.l";
 
-/***/ 99988:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * function to promote a string to a TrustedScript using webpack's Trusted
+ * Types policy
+ * Arguments: (script: string) => TrustedScript
+ */
+exports.createScript = "__webpack_require__.ts";
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * function to promote a string to a TrustedScriptURL using webpack's Trusted
+ * Types policy
+ * Arguments: (url: string) => TrustedScriptURL
+ */
+exports.createScriptUrl = "__webpack_require__.tu";
 
+/**
+ * function to return webpack's Trusted Types policy
+ * Arguments: () => TrustedTypePolicy
+ */
+exports.getTrustedTypesPolicy = "__webpack_require__.tt";
 
+/**
+ * the chunk name of the chunk with the runtime
+ */
+exports.chunkName = "__webpack_require__.cn";
 
-const util = __webpack_require__(73837);
-const ExportsInfo = __webpack_require__(63686);
-const ModuleGraphConnection = __webpack_require__(40639);
-const SortableSet = __webpack_require__(13098);
-const WeakTupleMap = __webpack_require__(28745);
+/**
+ * the runtime id of the current runtime
+ */
+exports.runtimeId = "__webpack_require__.j";
 
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleProfile")} ModuleProfile */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/**
+ * the filename of the script part of the chunk
+ */
+exports.getChunkScriptFilename = "__webpack_require__.u";
 
 /**
- * @callback OptimizationBailoutFunction
- * @param {RequestShortener} requestShortener
- * @returns {string}
+ * the filename of the css part of the chunk
  */
+exports.getChunkCssFilename = "__webpack_require__.k";
 
-const EMPTY_SET = new Set();
+/**
+ * a flag when a module/chunk/tree has css modules
+ */
+exports.hasCssModules = "has css modules";
 
 /**
- * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
+ * the filename of the script part of the hot update chunk
  */
-const getConnectionsByOriginModule = set => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[]} */
-	let lastList = undefined;
-	for (const connection of set) {
-		const { originModule } = connection;
-		if (lastModule === originModule) {
-			lastList.push(connection);
-		} else {
-			lastModule = originModule;
-			const list = map.get(originModule);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(originModule, list);
-			}
-		}
-	}
-	return map;
-};
+exports.getChunkUpdateScriptFilename = "__webpack_require__.hu";
 
 /**
- * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
+ * the filename of the css part of the hot update chunk
  */
-const getConnectionsByModule = set => {
-	const map = new Map();
-	/** @type {Module | 0} */
-	let lastModule = 0;
-	/** @type {ModuleGraphConnection[]} */
-	let lastList = undefined;
-	for (const connection of set) {
-		const { module } = connection;
-		if (lastModule === module) {
-			lastList.push(connection);
-		} else {
-			lastModule = module;
-			const list = map.get(module);
-			if (list !== undefined) {
-				lastList = list;
-				list.push(connection);
-			} else {
-				const list = [connection];
-				lastList = list;
-				map.set(module, list);
-			}
-		}
-	}
-	return map;
-};
+exports.getChunkUpdateCssFilename = "__webpack_require__.hk";
 
-class ModuleGraphModule {
-	constructor() {
-		/** @type {SortableSet<ModuleGraphConnection>} */
-		this.incomingConnections = new SortableSet();
-		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
-		this.outgoingConnections = undefined;
-		/** @type {Module | null} */
-		this.issuer = undefined;
-		/** @type {(string | OptimizationBailoutFunction)[]} */
-		this.optimizationBailout = [];
-		/** @type {ExportsInfo} */
-		this.exports = new ExportsInfo();
-		/** @type {number} */
-		this.preOrderIndex = null;
-		/** @type {number} */
-		this.postOrderIndex = null;
-		/** @type {number} */
-		this.depth = null;
-		/** @type {ModuleProfile} */
-		this.profile = undefined;
-		/** @type {boolean} */
-		this.async = false;
-		/** @type {ModuleGraphConnection[]} */
-		this._unassignedConnections = undefined;
-	}
-}
+/**
+ * startup signal from runtime
+ * This will be called when the runtime chunk has been loaded.
+ */
+exports.startup = "__webpack_require__.x";
 
-class ModuleGraph {
-	constructor() {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
-		this._dependencyMap = new WeakMap();
-		/** @type {Map<Module, ModuleGraphModule>} */
-		this._moduleMap = new Map();
-		/** @type {WeakMap<any, Object>} */
-		this._metaMap = new WeakMap();
+/**
+ * @deprecated
+ * creating a default startup function with the entry modules
+ */
+exports.startupNoDefault = "__webpack_require__.x (no default handler)";
 
-		/** @type {WeakTupleMap<any[], any>} */
-		this._cache = undefined;
+/**
+ * startup signal from runtime but only used to add logic after the startup
+ */
+exports.startupOnlyAfter = "__webpack_require__.x (only after)";
 
-		/** @type {Map<Module, WeakTupleMap<any, any>>} */
-		this._moduleMemCaches = undefined;
-	}
+/**
+ * startup signal from runtime but only used to add sync logic before the startup
+ */
+exports.startupOnlyBefore = "__webpack_require__.x (only before)";
+
+/**
+ * global callback functions for installing chunks
+ */
+exports.chunkCallback = "webpackChunk";
+
+/**
+ * method to startup an entrypoint with needed chunks.
+ * Signature: (moduleId: Id, chunkIds: Id[]) => any.
+ * Returns the exports of the module or a Promise
+ */
+exports.startupEntrypoint = "__webpack_require__.X";
+
+/**
+ * register deferred code, which will run when certain
+ * chunks are loaded.
+ * Signature: (chunkIds: Id[], fn: () => any, priority: int >= 0 = 0) => any
+ * Returned value will be returned directly when all chunks are already loaded
+ * When (priority & 1) it will wait for all other handlers with lower priority to
+ * be executed before itself is executed
+ */
+exports.onChunksLoaded = "__webpack_require__.O";
+
+/**
+ * method to install a chunk that was loaded somehow
+ * Signature: ({ id, ids, modules, runtime }) => void
+ */
+exports.externalInstallChunk = "__webpack_require__.C";
+
+/**
+ * interceptor for module executions
+ */
+exports.interceptModuleExecution = "__webpack_require__.i";
+
+/**
+ * the global object
+ */
+exports.global = "__webpack_require__.g";
+
+/**
+ * an object with all share scopes
+ */
+exports.shareScopeMap = "__webpack_require__.S";
+
+/**
+ * The sharing init sequence function (only runs once per share scope).
+ * Has one argument, the name of the share scope.
+ * Creates a share scope if not existing
+ */
+exports.initializeSharing = "__webpack_require__.I";
+
+/**
+ * The current scope when getting a module from a remote
+ */
+exports.currentRemoteGetScope = "__webpack_require__.R";
+
+/**
+ * the filename of the HMR manifest
+ */
+exports.getUpdateManifestFilename = "__webpack_require__.hmrF";
+
+/**
+ * function downloading the update manifest
+ */
+exports.hmrDownloadManifest = "__webpack_require__.hmrM";
+
+/**
+ * array with handler functions to download chunk updates
+ */
+exports.hmrDownloadUpdateHandlers = "__webpack_require__.hmrC";
+
+/**
+ * object with all hmr module data for all modules
+ */
+exports.hmrModuleData = "__webpack_require__.hmrD";
+
+/**
+ * array with handler functions when a module should be invalidated
+ */
+exports.hmrInvalidateModuleHandlers = "__webpack_require__.hmrI";
+
+/**
+ * the prefix for storing state of runtime modules when hmr is enabled
+ */
+exports.hmrRuntimeStatePrefix = "__webpack_require__.hmrS";
+
+/**
+ * the AMD define function
+ */
+exports.amdDefine = "__webpack_require__.amdD";
+
+/**
+ * the AMD options
+ */
+exports.amdOptions = "__webpack_require__.amdO";
+
+/**
+ * the System polyfill object
+ */
+exports.system = "__webpack_require__.System";
+
+/**
+ * the shorthand for Object.prototype.hasOwnProperty
+ * using of it decreases the compiled bundle size
+ */
+exports.hasOwnProperty = "__webpack_require__.o";
+
+/**
+ * the System.register context object
+ */
+exports.systemContext = "__webpack_require__.y";
+
+/**
+ * the baseURI of current document
+ */
+exports.baseURI = "__webpack_require__.b";
+
+/**
+ * a RelativeURL class when relative URLs are used
+ */
+exports.relativeUrl = "__webpack_require__.U";
+
+/**
+ * Creates an async module. The body function must be a async function.
+ * "module.exports" will be decorated with an AsyncModulePromise.
+ * The body function will be called.
+ * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
+ * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
+ * Signature: function(
+ * module: Module,
+ * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise<any[]> & () => void,
+ * hasAwaitAfterDependencies?: boolean
+ * ) => void
+ */
+exports.asyncModule = "__webpack_require__.a";
+
+
+/***/ }),
+
+/***/ 16963:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { RawSource } = __webpack_require__(51255);
+const OriginalSource = (__webpack_require__(51255).OriginalSource);
+const Module = __webpack_require__(73208);
 
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["runtime"]);
+
+class RuntimeModule extends Module {
 	/**
-	 * @param {Module} module the module
-	 * @returns {ModuleGraphModule} the internal module
+	 * @param {string} name a readable name
+	 * @param {number=} stage an optional stage
 	 */
-	_getModuleGraphModule(module) {
-		let mgm = this._moduleMap.get(module);
-		if (mgm === undefined) {
-			mgm = new ModuleGraphModule();
-			this._moduleMap.set(module, mgm);
-		}
-		return mgm;
+	constructor(name, stage = 0) {
+		super("runtime");
+		this.name = name;
+		this.stage = stage;
+		this.buildMeta = {};
+		this.buildInfo = {};
+		/** @type {Compilation} */
+		this.compilation = undefined;
+		/** @type {Chunk} */
+		this.chunk = undefined;
+		/** @type {ChunkGraph} */
+		this.chunkGraph = undefined;
+		this.fullHash = false;
+		this.dependentHash = false;
+		/** @type {string} */
+		this._cachedGeneratedCode = undefined;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @param {DependenciesBlock} block parent block
-	 * @param {Module} module parent module
-	 * @param {number=} indexInBlock position in block
+	 * @param {Compilation} compilation the compilation
+	 * @param {Chunk} chunk the chunk
+	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @returns {void}
 	 */
-	setParents(dependency, block, module, indexInBlock = -1) {
-		dependency._parentDependenciesBlockIndex = indexInBlock;
-		dependency._parentDependenciesBlock = block;
-		dependency._parentModule = module;
+	attach(compilation, chunk, chunkGraph = compilation.chunkGraph) {
+		this.compilation = compilation;
+		this.chunk = chunk;
+		this.chunkGraph = chunkGraph;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {Module} parent module
+	 * @returns {string} a unique identifier of the module
 	 */
-	getParentModule(dependency) {
-		return dependency._parentModule;
+	identifier() {
+		return `webpack/runtime/${this.name}`;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {DependenciesBlock} parent block
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	getParentBlock(dependency) {
-		return dependency._parentDependenciesBlock;
+	readableIdentifier(requestShortener) {
+		return `webpack/runtime/${this.name}`;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency
-	 * @returns {number} index
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
 	 */
-	getParentBlockIndex(dependency) {
-		return dependency._parentDependenciesBlockIndex;
+	needBuild(context, callback) {
+		return callback(null, false);
 	}
 
 	/**
-	 * @param {Module} originModule the referencing module
-	 * @param {Dependency} dependency the referencing dependency
-	 * @param {Module} module the referenced module
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	setResolvedModule(originModule, dependency, module) {
-		const connection = new ModuleGraphConnection(
-			originModule,
-			dependency,
-			module,
-			undefined,
-			dependency.weak,
-			dependency.getCondition(this)
-		);
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		connections.add(connection);
-		if (originModule) {
-			const mgm = this._getModuleGraphModule(originModule);
-			if (mgm._unassignedConnections === undefined) {
-				mgm._unassignedConnections = [];
-			}
-			mgm._unassignedConnections.push(connection);
-			if (mgm.outgoingConnections === undefined) {
-				mgm.outgoingConnections = new SortableSet();
-			}
-			mgm.outgoingConnections.add(connection);
-		} else {
-			this._dependencyMap.set(dependency, connection);
-		}
+	build(options, compilation, resolver, fs, callback) {
+		// do nothing
+		// should not be called as runtime modules are added later to the compilation
+		callback();
 	}
 
 	/**
-	 * @param {Dependency} dependency the referencing dependency
-	 * @param {Module} module the referenced module
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
 	 * @returns {void}
 	 */
-	updateModule(dependency, module) {
-		const connection = this.getConnection(dependency);
-		if (connection.module === module) return;
-		const newConnection = connection.clone();
-		newConnection.module = module;
-		this._dependencyMap.set(dependency, newConnection);
-		connection.setActive(false);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.add(newConnection);
-		const targetMgm = this._getModuleGraphModule(module);
-		targetMgm.incomingConnections.add(newConnection);
-	}
-
-	/**
-	 * @param {Dependency} dependency the referencing dependency
-	 * @returns {void}
-	 */
-	removeConnection(dependency) {
-		const connection = this.getConnection(dependency);
-		const targetMgm = this._getModuleGraphModule(connection.module);
-		targetMgm.incomingConnections.delete(connection);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.delete(connection);
-		this._dependencyMap.set(dependency, null);
-	}
-
-	/**
-	 * @param {Dependency} dependency the referencing dependency
-	 * @param {string} explanation an explanation
-	 * @returns {void}
-	 */
-	addExplanation(dependency, explanation) {
-		const connection = this.getConnection(dependency);
-		connection.addExplanation(explanation);
-	}
-
-	/**
-	 * @param {Module} sourceModule the source module
-	 * @param {Module} targetModule the target module
-	 * @returns {void}
-	 */
-	cloneModuleAttributes(sourceModule, targetModule) {
-		const oldMgm = this._getModuleGraphModule(sourceModule);
-		const newMgm = this._getModuleGraphModule(targetModule);
-		newMgm.postOrderIndex = oldMgm.postOrderIndex;
-		newMgm.preOrderIndex = oldMgm.preOrderIndex;
-		newMgm.depth = oldMgm.depth;
-		newMgm.exports = oldMgm.exports;
-		newMgm.async = oldMgm.async;
-	}
-
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	removeModuleAttributes(module) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.postOrderIndex = null;
-		mgm.preOrderIndex = null;
-		mgm.depth = null;
-		mgm.async = false;
-	}
-
-	/**
-	 * @returns {void}
-	 */
-	removeAllModuleAttributes() {
-		for (const mgm of this._moduleMap.values()) {
-			mgm.postOrderIndex = null;
-			mgm.preOrderIndex = null;
-			mgm.depth = null;
-			mgm.async = false;
-		}
-	}
-
-	/**
-	 * @param {Module} oldModule the old referencing module
-	 * @param {Module} newModule the new referencing module
-	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
-	 * @returns {void}
-	 */
-	moveModuleConnections(oldModule, newModule, filterConnection) {
-		if (oldModule === newModule) return;
-		const oldMgm = this._getModuleGraphModule(oldModule);
-		const newMgm = this._getModuleGraphModule(newModule);
-		// Outgoing connections
-		const oldConnections = oldMgm.outgoingConnections;
-		if (oldConnections !== undefined) {
-			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new SortableSet();
-			}
-			const newConnections = newMgm.outgoingConnections;
-			for (const connection of oldConnections) {
-				if (filterConnection(connection)) {
-					connection.originModule = newModule;
-					newConnections.add(connection);
-					oldConnections.delete(connection);
-				}
-			}
-		}
-		// Incoming connections
-		const oldConnections2 = oldMgm.incomingConnections;
-		const newConnections2 = newMgm.incomingConnections;
-		for (const connection of oldConnections2) {
-			if (filterConnection(connection)) {
-				connection.module = newModule;
-				newConnections2.add(connection);
-				oldConnections2.delete(connection);
-			}
-		}
-	}
-
-	/**
-	 * @param {Module} oldModule the old referencing module
-	 * @param {Module} newModule the new referencing module
-	 * @param {function(ModuleGraphConnection): boolean} filterConnection filter predicate for replacement
-	 * @returns {void}
-	 */
-	copyOutgoingModuleConnections(oldModule, newModule, filterConnection) {
-		if (oldModule === newModule) return;
-		const oldMgm = this._getModuleGraphModule(oldModule);
-		const newMgm = this._getModuleGraphModule(newModule);
-		// Outgoing connections
-		const oldConnections = oldMgm.outgoingConnections;
-		if (oldConnections !== undefined) {
-			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new SortableSet();
-			}
-			const newConnections = newMgm.outgoingConnections;
-			for (const connection of oldConnections) {
-				if (filterConnection(connection)) {
-					const newConnection = connection.clone();
-					newConnection.originModule = newModule;
-					newConnections.add(newConnection);
-					if (newConnection.module !== undefined) {
-						const otherMgm = this._getModuleGraphModule(newConnection.module);
-						otherMgm.incomingConnections.add(newConnection);
-					}
-				}
+	updateHash(hash, context) {
+		hash.update(this.name);
+		hash.update(`${this.stage}`);
+		try {
+			if (this.fullHash || this.dependentHash) {
+				// Do not use getGeneratedCode here, because i. e. compilation hash might be not
+				// ready at this point. We will cache it later instead.
+				hash.update(this.generate());
+			} else {
+				hash.update(this.getGeneratedCode());
 			}
+		} catch (err) {
+			hash.update(err.message);
 		}
+		super.updateHash(hash, context);
 	}
 
 	/**
-	 * @param {Module} module the referenced module
-	 * @param {string} explanation an explanation why it's referenced
-	 * @returns {void}
-	 */
-	addExtraReason(module, explanation) {
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		connections.add(new ModuleGraphConnection(null, null, module, explanation));
-	}
-
-	/**
-	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {Module} the referenced module
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	getResolvedModule(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.resolvedModule : null;
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {ModuleGraphConnection | undefined} the connection
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	getConnection(dependency) {
-		const connection = this._dependencyMap.get(dependency);
-		if (connection === undefined) {
-			const module = this.getParentModule(dependency);
-			if (module !== undefined) {
-				const mgm = this._getModuleGraphModule(module);
-				if (
-					mgm._unassignedConnections &&
-					mgm._unassignedConnections.length !== 0
-				) {
-					let foundConnection;
-					for (const connection of mgm._unassignedConnections) {
-						this._dependencyMap.set(connection.dependency, connection);
-						if (connection.dependency === dependency)
-							foundConnection = connection;
-					}
-					mgm._unassignedConnections.length = 0;
-					if (foundConnection !== undefined) {
-						return foundConnection;
-					}
-				}
-			}
-			this._dependencyMap.set(dependency, null);
-			return undefined;
+	codeGeneration(context) {
+		const sources = new Map();
+		const generatedCode = this.getGeneratedCode();
+		if (generatedCode) {
+			sources.set(
+				"runtime",
+				this.useSourceMap || this.useSimpleSourceMap
+					? new OriginalSource(generatedCode, this.identifier())
+					: new RawSource(generatedCode)
+			);
 		}
-		return connection === null ? undefined : connection;
+		return {
+			sources,
+			runtimeRequirements: null
+		};
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referenced module
-	 * @returns {Module} the referenced module
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	getModule(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.module : null;
+	size(type) {
+		try {
+			const source = this.getGeneratedCode();
+			return source ? source.length : 0;
+		} catch (e) {
+			return 0;
+		}
 	}
 
+	/* istanbul ignore next */
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referencing module
-	 * @returns {Module} the referencing module
+	 * @abstract
+	 * @returns {string} runtime code
 	 */
-	getOrigin(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.originModule : null;
+	generate() {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 
 	/**
-	 * @param {Dependency} dependency the dependency to look for a referencing module
-	 * @returns {Module} the original referencing module
+	 * @returns {string} runtime code
 	 */
-	getResolvedOrigin(dependency) {
-		const connection = this.getConnection(dependency);
-		return connection !== undefined ? connection.resolvedOriginModule : null;
+	getGeneratedCode() {
+		if (this._cachedGeneratedCode) {
+			return this._cachedGeneratedCode;
+		}
+		return (this._cachedGeneratedCode = this.generate());
 	}
 
 	/**
-	 * @param {Module} module the module
-	 * @returns {Iterable<ModuleGraphConnection>} reasons why a module is included
+	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
-	getIncomingConnections(module) {
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		return connections;
+	shouldIsolate() {
+		return true;
 	}
+}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {Iterable<ModuleGraphConnection>} list of outgoing connections
-	 */
-	getOutgoingConnections(module) {
-		const connections = this._getModuleGraphModule(module).outgoingConnections;
-		return connections === undefined ? EMPTY_SET : connections;
-	}
+/**
+ * Runtime modules without any dependencies to other runtime modules
+ */
+RuntimeModule.STAGE_NORMAL = 0;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
-	 */
-	getIncomingConnectionsByOriginModule(module) {
-		const connections = this._getModuleGraphModule(module).incomingConnections;
-		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
-	}
+/**
+ * Runtime modules with simple dependencies on other runtime modules
+ */
+RuntimeModule.STAGE_BASIC = 5;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
-	 */
-	getOutgoingConnectionsByModule(module) {
-		const connections = this._getModuleGraphModule(module).outgoingConnections;
-		return connections === undefined
-			? undefined
-			: connections.getFromUnorderedCache(getConnectionsByModule);
-	}
+/**
+ * Runtime modules which attach to handlers of other runtime modules
+ */
+RuntimeModule.STAGE_ATTACH = 10;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {ModuleProfile | null} the module profile
-	 */
-	getProfile(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.profile;
-	}
+/**
+ * Runtime modules which trigger actions on bootstrap
+ */
+RuntimeModule.STAGE_TRIGGER = 20;
 
-	/**
-	 * @param {Module} module the module
-	 * @param {ModuleProfile | null} profile the module profile
-	 * @returns {void}
-	 */
-	setProfile(module, profile) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.profile = profile;
-	}
+module.exports = RuntimeModule;
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {Module | null} the issuer module
-	 */
-	getIssuer(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.issuer;
-	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {Module | null} issuer the issuer module
-	 * @returns {void}
-	 */
-	setIssuer(module, issuer) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.issuer = issuer;
-	}
+/***/ }),
 
-	/**
-	 * @param {Module} module the module
-	 * @param {Module | null} issuer the issuer module
-	 * @returns {void}
-	 */
-	setIssuerIfUnset(module, issuer) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.issuer === undefined) mgm.issuer = issuer;
-	}
+/***/ 2307:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {(string | OptimizationBailoutFunction)[]} optimization bailouts
-	 */
-	getOptimizationBailout(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.optimizationBailout;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {true | string[] | null} the provided exports
-	 */
-	getProvidedExports(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getProvidedExports();
-	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {string | string[]} exportName a name of an export
-	 * @returns {boolean | null} true, if the export is provided by the module.
-	 * null, if it's unknown.
-	 * false, if it's not provided.
-	 */
-	isExportProvided(module, exportName) {
-		const mgm = this._getModuleGraphModule(module);
-		const result = mgm.exports.isExportProvided(exportName);
-		return result === undefined ? null : result;
-	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {ExportsInfo} info about the exports
-	 */
-	getExportsInfo(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports;
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const { getChunkFilenameTemplate } = __webpack_require__(47283);
+const RuntimeRequirementsDependency = __webpack_require__(24187);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const AsyncModuleRuntimeModule = __webpack_require__(63672);
+const AutoPublicPathRuntimeModule = __webpack_require__(66532);
+const CompatGetDefaultExportRuntimeModule = __webpack_require__(44793);
+const CompatRuntimeModule = __webpack_require__(88234);
+const CreateFakeNamespaceObjectRuntimeModule = __webpack_require__(94669);
+const CreateScriptRuntimeModule = __webpack_require__(2759);
+const CreateScriptUrlRuntimeModule = __webpack_require__(21213);
+const DefinePropertyGettersRuntimeModule = __webpack_require__(75481);
+const EnsureChunkRuntimeModule = __webpack_require__(71519);
+const GetChunkFilenameRuntimeModule = __webpack_require__(34277);
+const GetMainFilenameRuntimeModule = __webpack_require__(10029);
+const GetTrustedTypesPolicyRuntimeModule = __webpack_require__(38713);
+const GlobalRuntimeModule = __webpack_require__(23255);
+const HasOwnPropertyRuntimeModule = __webpack_require__(8011);
+const LoadScriptRuntimeModule = __webpack_require__(19942);
+const MakeNamespaceObjectRuntimeModule = __webpack_require__(65714);
+const OnChunksLoadedRuntimeModule = __webpack_require__(44518);
+const PublicPathRuntimeModule = __webpack_require__(56030);
+const RelativeUrlRuntimeModule = __webpack_require__(4537);
+const RuntimeIdRuntimeModule = __webpack_require__(97115);
+const SystemContextRuntimeModule = __webpack_require__(80655);
+const ShareRuntimeModule = __webpack_require__(96066);
+const StringXor = __webpack_require__(40293);
 
-	/**
-	 * @param {Module} module the module
-	 * @param {string} exportName the export
-	 * @returns {ExportInfo} info about the export
-	 */
-	getExportInfo(module, exportName) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getExportInfo(exportName);
-	}
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
 
-	/**
-	 * @param {Module} module the module
-	 * @param {string} exportName the export
-	 * @returns {ExportInfo} info about the export (do not modify)
-	 */
-	getReadOnlyExportInfo(module, exportName) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getReadOnlyExportInfo(exportName);
-	}
+const GLOBALS_ON_REQUIRE = [
+	RuntimeGlobals.chunkName,
+	RuntimeGlobals.runtimeId,
+	RuntimeGlobals.compatGetDefaultExport,
+	RuntimeGlobals.createFakeNamespaceObject,
+	RuntimeGlobals.createScript,
+	RuntimeGlobals.createScriptUrl,
+	RuntimeGlobals.getTrustedTypesPolicy,
+	RuntimeGlobals.definePropertyGetters,
+	RuntimeGlobals.ensureChunk,
+	RuntimeGlobals.entryModuleId,
+	RuntimeGlobals.getFullHash,
+	RuntimeGlobals.global,
+	RuntimeGlobals.makeNamespaceObject,
+	RuntimeGlobals.moduleCache,
+	RuntimeGlobals.moduleFactories,
+	RuntimeGlobals.moduleFactoriesAddOnly,
+	RuntimeGlobals.interceptModuleExecution,
+	RuntimeGlobals.publicPath,
+	RuntimeGlobals.baseURI,
+	RuntimeGlobals.relativeUrl,
+	RuntimeGlobals.scriptNonce,
+	RuntimeGlobals.uncaughtErrorHandler,
+	RuntimeGlobals.asyncModule,
+	RuntimeGlobals.wasmInstances,
+	RuntimeGlobals.instantiateWasm,
+	RuntimeGlobals.shareScopeMap,
+	RuntimeGlobals.initializeSharing,
+	RuntimeGlobals.loadScript,
+	RuntimeGlobals.systemContext,
+	RuntimeGlobals.onChunksLoaded
+];
 
-	/**
-	 * @param {Module} module the module
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {false | true | SortableSet<string> | null} the used exports
-	 * false: module is not used at all.
-	 * true: the module namespace/object export is used.
-	 * SortableSet<string>: these export names are used.
-	 * empty SortableSet<string>: module is used but no export.
-	 * null: unknown, worst case should be assumed.
-	 */
-	getUsedExports(module, runtime) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.exports.getUsedExports(runtime);
-	}
+const MODULE_DEPENDENCIES = {
+	[RuntimeGlobals.moduleLoaded]: [RuntimeGlobals.module],
+	[RuntimeGlobals.moduleId]: [RuntimeGlobals.module]
+};
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {number} the index of the module
-	 */
-	getPreOrderIndex(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.preOrderIndex;
-	}
+const TREE_DEPENDENCIES = {
+	[RuntimeGlobals.definePropertyGetters]: [RuntimeGlobals.hasOwnProperty],
+	[RuntimeGlobals.compatGetDefaultExport]: [
+		RuntimeGlobals.definePropertyGetters
+	],
+	[RuntimeGlobals.createFakeNamespaceObject]: [
+		RuntimeGlobals.definePropertyGetters,
+		RuntimeGlobals.makeNamespaceObject,
+		RuntimeGlobals.require
+	],
+	[RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
+	[RuntimeGlobals.shareScopeMap]: [RuntimeGlobals.hasOwnProperty]
+};
 
+class RuntimePlugin {
 	/**
-	 * @param {Module} module the module
-	 * @returns {number} the index of the module
+	 * @param {Compiler} compiler the Compiler
+	 * @returns {void}
 	 */
-	getPostOrderIndex(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.postOrderIndex;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RuntimePlugin", compilation => {
+			compilation.dependencyTemplates.set(
+				RuntimeRequirementsDependency,
+				new RuntimeRequirementsDependency.Template()
+			);
+			for (const req of GLOBALS_ON_REQUIRE) {
+				compilation.hooks.runtimeRequirementInModule
+					.for(req)
+					.tap("RuntimePlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(req)
+					.tap("RuntimePlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
+			}
+			for (const req of Object.keys(TREE_DEPENDENCIES)) {
+				const deps = TREE_DEPENDENCIES[req];
+				compilation.hooks.runtimeRequirementInTree
+					.for(req)
+					.tap("RuntimePlugin", (chunk, set) => {
+						for (const dep of deps) set.add(dep);
+					});
+			}
+			for (const req of Object.keys(MODULE_DEPENDENCIES)) {
+				const deps = MODULE_DEPENDENCIES[req];
+				compilation.hooks.runtimeRequirementInModule
+					.for(req)
+					.tap("RuntimePlugin", (chunk, set) => {
+						for (const dep of deps) set.add(dep);
+					});
+			}
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.definePropertyGetters)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new DefinePropertyGettersRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.makeNamespaceObject)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new MakeNamespaceObjectRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createFakeNamespaceObject)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new CreateFakeNamespaceObjectRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.hasOwnProperty)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new HasOwnPropertyRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.compatGetDefaultExport)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(
+						chunk,
+						new CompatGetDefaultExportRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.runtimeId)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.publicPath)
+				.tap("RuntimePlugin", (chunk, set) => {
+					const { outputOptions } = compilation;
+					const { publicPath: globalPublicPath, scriptType } = outputOptions;
+					const entryOptions = chunk.getEntryOptions();
+					const publicPath =
+						entryOptions && entryOptions.publicPath !== undefined
+							? entryOptions.publicPath
+							: globalPublicPath;
 
-	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {void}
-	 */
-	setPreOrderIndex(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.preOrderIndex = index;
+					if (publicPath === "auto") {
+						const module = new AutoPublicPathRuntimeModule();
+						if (scriptType !== "module") set.add(RuntimeGlobals.global);
+						compilation.addRuntimeModule(chunk, module);
+					} else {
+						const module = new PublicPathRuntimeModule(publicPath);
+
+						if (
+							typeof publicPath !== "string" ||
+							/\[(full)?hash\]/.test(publicPath)
+						) {
+							module.fullHash = true;
+						}
+
+						compilation.addRuntimeModule(chunk, module);
+					}
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.global)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new GlobalRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.asyncModule)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new AsyncModuleRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.systemContext)
+				.tap("RuntimePlugin", chunk => {
+					const { outputOptions } = compilation;
+					const { library: globalLibrary } = outputOptions;
+					const entryOptions = chunk.getEntryOptions();
+					const libraryType =
+						entryOptions && entryOptions.library !== undefined
+							? entryOptions.library.type
+							: globalLibrary.type;
+
+					if (libraryType === "system") {
+						compilation.addRuntimeModule(
+							chunk,
+							new SystemContextRuntimeModule()
+						);
+					}
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getChunkScriptFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						typeof compilation.outputOptions.chunkFilename === "string" &&
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.chunkFilename
+						)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new GetChunkFilenameRuntimeModule(
+							"javascript",
+							"javascript",
+							RuntimeGlobals.getChunkScriptFilename,
+							chunk =>
+								chunk.filenameTemplate ||
+								(chunk.canBeInitial()
+									? compilation.outputOptions.filename
+									: compilation.outputOptions.chunkFilename),
+							false
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getChunkCssFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						typeof compilation.outputOptions.cssChunkFilename === "string" &&
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.cssChunkFilename
+						)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new GetChunkFilenameRuntimeModule(
+							"css",
+							"css",
+							RuntimeGlobals.getChunkCssFilename,
+							chunk =>
+								getChunkFilenameTemplate(chunk, compilation.outputOptions),
+							set.has(RuntimeGlobals.hmrDownloadUpdateHandlers)
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getChunkUpdateScriptFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.hotUpdateChunkFilename
+						)
+					)
+						set.add(RuntimeGlobals.getFullHash);
+					compilation.addRuntimeModule(
+						chunk,
+						new GetChunkFilenameRuntimeModule(
+							"javascript",
+							"javascript update",
+							RuntimeGlobals.getChunkUpdateScriptFilename,
+							c => compilation.outputOptions.hotUpdateChunkFilename,
+							true
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getUpdateManifestFilename)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (
+						/\[(full)?hash(:\d+)?\]/.test(
+							compilation.outputOptions.hotUpdateMainFilename
+						)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new GetMainFilenameRuntimeModule(
+							"update manifest",
+							RuntimeGlobals.getUpdateManifestFilename,
+							compilation.outputOptions.hotUpdateMainFilename
+						)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunk)
+				.tap("RuntimePlugin", (chunk, set) => {
+					const hasAsyncChunks = chunk.hasAsyncChunks();
+					if (hasAsyncChunks) {
+						set.add(RuntimeGlobals.ensureChunkHandlers);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new EnsureChunkRuntimeModule(set)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkIncludeEntries)
+				.tap("RuntimePlugin", (chunk, set) => {
+					set.add(RuntimeGlobals.ensureChunkHandlers);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.shareScopeMap)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(chunk, new ShareRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.loadScript)
+				.tap("RuntimePlugin", (chunk, set) => {
+					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+					if (withCreateScriptUrl) {
+						set.add(RuntimeGlobals.createScriptUrl);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new LoadScriptRuntimeModule(withCreateScriptUrl)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createScript)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (compilation.outputOptions.trustedTypes) {
+						set.add(RuntimeGlobals.getTrustedTypesPolicy);
+					}
+					compilation.addRuntimeModule(chunk, new CreateScriptRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createScriptUrl)
+				.tap("RuntimePlugin", (chunk, set) => {
+					if (compilation.outputOptions.trustedTypes) {
+						set.add(RuntimeGlobals.getTrustedTypesPolicy);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new CreateScriptUrlRuntimeModule()
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getTrustedTypesPolicy)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new GetTrustedTypesPolicyRuntimeModule(set)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.relativeUrl)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule());
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new OnChunksLoadedRuntimeModule()
+					);
+					return true;
+				});
+			// TODO webpack 6: remove CompatRuntimeModule
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				"RuntimePlugin",
+				(chunk, set) => {
+					const { mainTemplate } = compilation;
+					if (
+						mainTemplate.hooks.bootstrap.isUsed() ||
+						mainTemplate.hooks.localVars.isUsed() ||
+						mainTemplate.hooks.requireEnsure.isUsed() ||
+						mainTemplate.hooks.requireExtensions.isUsed()
+					) {
+						compilation.addRuntimeModule(chunk, new CompatRuntimeModule());
+					}
+				}
+			);
+			JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(
+				"RuntimePlugin",
+				(chunk, hash, { chunkGraph }) => {
+					const xor = new StringXor();
+					for (const m of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
+						xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+					}
+					xor.updateHash(hash);
+				}
+			);
+		});
 	}
+}
+module.exports = RuntimePlugin;
+
+
+/***/ }),
+
+/***/ 18777:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const { equals } = __webpack_require__(84953);
+const compileBooleanMatcher = __webpack_require__(29404);
+const propertyAccess = __webpack_require__(54190);
+const { forEachRuntime, subtractRuntime } = __webpack_require__(17156);
+
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @param {Module} module the module
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {string} error message
+ */
+const noModuleIdErrorMessage = (module, chunkGraph) => {
+	return `Module ${module.identifier()} has no id assigned.
+This should not happen.
+It's in these chunks: ${
+		Array.from(
+			chunkGraph.getModuleChunksIterable(module),
+			c => c.name || c.id || c.debugId
+		).join(", ") || "none"
+	} (If module is in no chunk this indicates a bug in some chunk/module optimization logic)
+Module has these incoming connections: ${Array.from(
+		chunkGraph.moduleGraph.getIncomingConnections(module),
+		connection =>
+			`\n - ${
+				connection.originModule && connection.originModule.identifier()
+			} ${connection.dependency && connection.dependency.type} ${
+				(connection.explanations &&
+					Array.from(connection.explanations).join(", ")) ||
+				""
+			}`
+	).join("")}`;
+};
+
+/**
+ * @param {string|undefined} definition global object definition
+ * @returns {string} save to use global object
+ */
+function getGlobalObject(definition) {
+	if (!definition) return definition;
+	const trimmed = definition.trim();
+
+	if (
+		// identifier, we do not need real identifier regarding ECMAScript/Unicode
+		trimmed.match(/^[_\p{L}][_0-9\p{L}]*$/iu) ||
+		// iife
+		// call expression
+		// expression in parentheses
+		trimmed.match(/^([_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu)
+	)
+		return trimmed;
+
+	return `Object(${trimmed})`;
+}
 
+class RuntimeTemplate {
 	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {boolean} true, if the index was set
+	 * @param {Compilation} compilation the compilation
+	 * @param {OutputOptions} outputOptions the compilation output options
+	 * @param {RequestShortener} requestShortener the request shortener
 	 */
-	setPreOrderIndexIfUnset(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.preOrderIndex === null) {
-			mgm.preOrderIndex = index;
-			return true;
-		}
-		return false;
+	constructor(compilation, outputOptions, requestShortener) {
+		this.compilation = compilation;
+		this.outputOptions = outputOptions || {};
+		this.requestShortener = requestShortener;
+		this.globalObject = getGlobalObject(outputOptions.globalObject);
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {void}
-	 */
-	setPostOrderIndex(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.postOrderIndex = index;
+	isIIFE() {
+		return this.outputOptions.iife;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {number} index the index of the module
-	 * @returns {boolean} true, if the index was set
-	 */
-	setPostOrderIndexIfUnset(module, index) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.postOrderIndex === null) {
-			mgm.postOrderIndex = index;
-			return true;
-		}
-		return false;
+	isModule() {
+		return this.outputOptions.module;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {number} the depth of the module
-	 */
-	getDepth(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.depth;
+	supportsConst() {
+		return this.outputOptions.environment.const;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {number} depth the depth of the module
-	 * @returns {void}
-	 */
-	setDepth(module, depth) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.depth = depth;
+	supportsArrowFunction() {
+		return this.outputOptions.environment.arrowFunction;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @param {number} depth the depth of the module
-	 * @returns {boolean} true, if the depth was set
-	 */
-	setDepthIfLower(module, depth) {
-		const mgm = this._getModuleGraphModule(module);
-		if (mgm.depth === null || mgm.depth > depth) {
-			mgm.depth = depth;
-			return true;
-		}
-		return false;
+	supportsOptionalChaining() {
+		return this.outputOptions.environment.optionalChaining;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {boolean} true, if the module is async
-	 */
-	isAsync(module) {
-		const mgm = this._getModuleGraphModule(module);
-		return mgm.async;
+	supportsForOf() {
+		return this.outputOptions.environment.forOf;
 	}
 
-	/**
-	 * @param {Module} module the module
-	 * @returns {void}
-	 */
-	setAsync(module) {
-		const mgm = this._getModuleGraphModule(module);
-		mgm.async = true;
+	supportsDestructuring() {
+		return this.outputOptions.environment.destructuring;
 	}
 
-	/**
-	 * @param {any} thing any thing
-	 * @returns {Object} metadata
-	 */
-	getMeta(thing) {
-		let meta = this._metaMap.get(thing);
-		if (meta === undefined) {
-			meta = Object.create(null);
-			this._metaMap.set(thing, meta);
-		}
-		return meta;
+	supportsBigIntLiteral() {
+		return this.outputOptions.environment.bigIntLiteral;
 	}
 
-	/**
-	 * @param {any} thing any thing
-	 * @returns {Object} metadata
-	 */
-	getMetaIfExisting(thing) {
-		return this._metaMap.get(thing);
+	supportsDynamicImport() {
+		return this.outputOptions.environment.dynamicImport;
 	}
 
-	/**
-	 * @param {string=} cacheStage a persistent stage name for caching
-	 */
-	freeze(cacheStage) {
-		this._cache = new WeakTupleMap();
-		this._cacheStage = cacheStage;
+	supportsEcmaScriptModuleSyntax() {
+		return this.outputOptions.environment.module;
 	}
 
-	unfreeze() {
-		this._cache = undefined;
-		this._cacheStage = undefined;
+	supportTemplateLiteral() {
+		return this.outputOptions.environment.templateLiteral;
 	}
 
-	/**
-	 * @template {any[]} T
-	 * @template V
-	 * @param {(moduleGraph: ModuleGraph, ...args: T) => V} fn computer
-	 * @param {T} args arguments
-	 * @returns {V} computed value or cached
-	 */
-	cached(fn, ...args) {
-		if (this._cache === undefined) return fn(this, ...args);
-		return this._cache.provide(fn, ...args, () => fn(this, ...args));
+	returningFunction(returnValue, args = "") {
+		return this.supportsArrowFunction()
+			? `(${args}) => (${returnValue})`
+			: `function(${args}) { return ${returnValue}; }`;
 	}
 
-	/**
-	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
-	 */
-	setModuleMemCaches(moduleMemCaches) {
-		this._moduleMemCaches = moduleMemCaches;
+	basicFunction(args, body) {
+		return this.supportsArrowFunction()
+			? `(${args}) => {\n${Template.indent(body)}\n}`
+			: `function(${args}) {\n${Template.indent(body)}\n}`;
 	}
 
 	/**
-	 * @param {Dependency} dependency dependency
-	 * @param {...any} args arguments, last argument is a function called with moduleGraph, dependency, ...args
-	 * @returns {any} computed value or cached
+	 * @param {Array<string|{expr: string}>} args args
+	 * @returns {string} result expression
 	 */
-	dependencyCacheProvide(dependency, ...args) {
-		/** @type {(moduleGraph: ModuleGraph, dependency: Dependency, ...args: any[]) => any} */
-		const fn = args.pop();
-		if (this._moduleMemCaches && this._cacheStage) {
-			const memCache = this._moduleMemCaches.get(
-				this.getParentModule(dependency)
-			);
-			if (memCache !== undefined) {
-				return memCache.provide(dependency, this._cacheStage, ...args, () =>
-					fn(this, dependency, ...args)
-				);
+	concatenation(...args) {
+		const len = args.length;
+
+		if (len === 2) return this._es5Concatenation(args);
+		if (len === 0) return '""';
+		if (len === 1) {
+			return typeof args[0] === "string"
+				? JSON.stringify(args[0])
+				: `"" + ${args[0].expr}`;
+		}
+		if (!this.supportTemplateLiteral()) return this._es5Concatenation(args);
+
+		// cost comparison between template literal and concatenation:
+		// both need equal surroundings: `xxx` vs "xxx"
+		// template literal has constant cost of 3 chars for each expression
+		// es5 concatenation has cost of 3 + n chars for n expressions in row
+		// when a es5 concatenation ends with an expression it reduces cost by 3
+		// when a es5 concatenation starts with an single expression it reduces cost by 3
+		// e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
+		// e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
+
+		let templateCost = 0;
+		let concatenationCost = 0;
+
+		let lastWasExpr = false;
+		for (const arg of args) {
+			const isExpr = typeof arg !== "string";
+			if (isExpr) {
+				templateCost += 3;
+				concatenationCost += lastWasExpr ? 1 : 4;
 			}
+			lastWasExpr = isExpr;
 		}
-		if (this._cache === undefined) return fn(this, dependency, ...args);
-		return this._cache.provide(dependency, ...args, () =>
-			fn(this, dependency, ...args)
-		);
-	}
+		if (lastWasExpr) concatenationCost -= 3;
+		if (typeof args[0] !== "string" && typeof args[1] === "string")
+			concatenationCost -= 3;
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @param {string} deprecateMessage message for the deprecation message
-	 * @param {string} deprecationCode code for the deprecation
-	 * @returns {ModuleGraph} the module graph
-	 */
-	static getModuleGraphForModule(module, deprecateMessage, deprecationCode) {
-		const fn = deprecateMap.get(deprecateMessage);
-		if (fn) return fn(module);
-		const newFn = util.deprecate(
-			/**
-			 * @param {Module} module the module
-			 * @returns {ModuleGraph} the module graph
-			 */
-			module => {
-				const moduleGraph = moduleGraphForModuleMap.get(module);
-				if (!moduleGraph)
-					throw new Error(
-						deprecateMessage +
-							"There was no ModuleGraph assigned to the Module for backward-compat (Use the new API)"
-					);
-				return moduleGraph;
-			},
-			deprecateMessage + ": Use new ModuleGraph API",
-			deprecationCode
-		);
-		deprecateMap.set(deprecateMessage, newFn);
-		return newFn(module);
-	}
+		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
 
-	// TODO remove in webpack 6
-	/**
-	 * @param {Module} module the module
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {void}
-	 */
-	static setModuleGraphForModule(module, moduleGraph) {
-		moduleGraphForModuleMap.set(module, moduleGraph);
+		return `\`${args
+			.map(arg => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
+			.join("")}\``;
 	}
 
-	// TODO remove in webpack 6
 	/**
-	 * @param {Module} module the module
-	 * @returns {void}
+	 * @param {Array<string|{expr: string}>} args args (len >= 2)
+	 * @returns {string} result expression
+	 * @private
 	 */
-	static clearModuleGraphForModule(module) {
-		moduleGraphForModuleMap.delete(module);
-	}
-}
-
-// TODO remove in webpack 6
-/** @type {WeakMap<Module, ModuleGraph>} */
-const moduleGraphForModuleMap = new WeakMap();
-
-// TODO remove in webpack 6
-/** @type {Map<string, (module: Module) => ModuleGraph>} */
-const deprecateMap = new Map();
-
-module.exports = ModuleGraph;
-module.exports.ModuleGraphConnection = ModuleGraphConnection;
-
-
-/***/ }),
-
-/***/ 40639:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+	_es5Concatenation(args) {
+		const str = args
+			.map(arg => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
+			.join(" + ");
 
-/**
- * Module itself is not connected, but transitive modules are connected transitively.
- */
-const TRANSITIVE_ONLY = Symbol("transitive only");
+		// when the first two args are expression, we need to prepend "" + to force string
+		// concatenation instead of number addition.
+		return typeof args[0] !== "string" && typeof args[1] !== "string"
+			? `"" + ${str}`
+			: str;
+	}
 
-/**
- * While determining the active state, this flag is used to signal a circular connection.
- */
-const CIRCULAR_CONNECTION = Symbol("circular connection");
+	expressionFunction(expression, args = "") {
+		return this.supportsArrowFunction()
+			? `(${args}) => (${expression})`
+			: `function(${args}) { ${expression}; }`;
+	}
 
-/** @typedef {boolean | typeof TRANSITIVE_ONLY | typeof CIRCULAR_CONNECTION} ConnectionState */
+	emptyFunction() {
+		return this.supportsArrowFunction() ? "x => {}" : "function() {}";
+	}
 
-/**
- * @param {ConnectionState} a first
- * @param {ConnectionState} b second
- * @returns {ConnectionState} merged
- */
-const addConnectionStates = (a, b) => {
-	if (a === true || b === true) return true;
-	if (a === false) return b;
-	if (b === false) return a;
-	if (a === TRANSITIVE_ONLY) return b;
-	if (b === TRANSITIVE_ONLY) return a;
-	return a;
-};
+	destructureArray(items, value) {
+		return this.supportsDestructuring()
+			? `var [${items.join(", ")}] = ${value};`
+			: Template.asString(
+					items.map((item, i) => `var ${item} = ${value}[${i}];`)
+			  );
+	}
 
-/**
- * @param {ConnectionState} a first
- * @param {ConnectionState} b second
- * @returns {ConnectionState} intersected
- */
-const intersectConnectionStates = (a, b) => {
-	if (a === false || b === false) return false;
-	if (a === true) return b;
-	if (b === true) return a;
-	if (a === CIRCULAR_CONNECTION) return b;
-	if (b === CIRCULAR_CONNECTION) return a;
-	return a;
-};
+	destructureObject(items, value) {
+		return this.supportsDestructuring()
+			? `var {${items.join(", ")}} = ${value};`
+			: Template.asString(
+					items.map(item => `var ${item} = ${value}${propertyAccess([item])};`)
+			  );
+	}
 
-class ModuleGraphConnection {
-	/**
-	 * @param {Module|null} originModule the referencing module
-	 * @param {Dependency|null} dependency the referencing dependency
-	 * @param {Module} module the referenced module
-	 * @param {string=} explanation some extra detail
-	 * @param {boolean=} weak the reference is weak
-	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
-	 */
-	constructor(
-		originModule,
-		dependency,
-		module,
-		explanation,
-		weak = false,
-		condition = undefined
-	) {
-		this.originModule = originModule;
-		this.resolvedOriginModule = originModule;
-		this.dependency = dependency;
-		this.resolvedModule = module;
-		this.module = module;
-		this.weak = weak;
-		this.conditional = !!condition;
-		this._active = condition !== false;
-		/** @type {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} */
-		this.condition = condition || undefined;
-		/** @type {Set<string>} */
-		this.explanations = undefined;
-		if (explanation) {
-			this.explanations = new Set();
-			this.explanations.add(explanation);
-		}
+	iife(args, body) {
+		return `(${this.basicFunction(args, body)})()`;
 	}
 
-	clone() {
-		const clone = new ModuleGraphConnection(
-			this.resolvedOriginModule,
-			this.dependency,
-			this.resolvedModule,
-			undefined,
-			this.weak,
-			this.condition
-		);
-		clone.originModule = this.originModule;
-		clone.module = this.module;
-		clone.conditional = this.conditional;
-		clone._active = this._active;
-		if (this.explanations) clone.explanations = new Set(this.explanations);
-		return clone;
+	forEach(variable, array, body) {
+		return this.supportsForOf()
+			? `for(const ${variable} of ${array}) {\n${Template.indent(body)}\n}`
+			: `${array}.forEach(function(${variable}) {\n${Template.indent(
+					body
+			  )}\n});`;
 	}
 
 	/**
-	 * @param {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} condition condition for the connection
-	 * @returns {void}
+	 * Add a comment
+	 * @param {object} options Information content of the comment
+	 * @param {string=} options.request request string used originally
+	 * @param {string=} options.chunkName name of the chunk referenced
+	 * @param {string=} options.chunkReason reason information of the chunk
+	 * @param {string=} options.message additional message
+	 * @param {string=} options.exportName name of the export
+	 * @returns {string} comment
 	 */
-	addCondition(condition) {
-		if (this.conditional) {
-			const old = this.condition;
-			this.condition = (c, r) =>
-				intersectConnectionStates(old(c, r), condition(c, r));
-		} else if (this._active) {
-			this.conditional = true;
-			this.condition = condition;
+	comment({ request, chunkName, chunkReason, message, exportName }) {
+		let content;
+		if (this.outputOptions.pathinfo) {
+			content = [message, request, chunkName, chunkReason]
+				.filter(Boolean)
+				.map(item => this.requestShortener.shorten(item))
+				.join(" | ");
+		} else {
+			content = [message, chunkName, chunkReason]
+				.filter(Boolean)
+				.map(item => this.requestShortener.shorten(item))
+				.join(" | ");
+		}
+		if (!content) return "";
+		if (this.outputOptions.pathinfo) {
+			return Template.toComment(content) + " ";
+		} else {
+			return Template.toNormalComment(content) + " ";
 		}
 	}
 
 	/**
-	 * @param {string} explanation the explanation to add
-	 * @returns {void}
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error block
 	 */
-	addExplanation(explanation) {
-		if (this.explanations === undefined) {
-			this.explanations = new Set();
-		}
-		this.explanations.add(explanation);
-	}
-
-	get explanation() {
-		if (this.explanations === undefined) return "";
-		return Array.from(this.explanations).join(" ");
+	throwMissingModuleErrorBlock({ request }) {
+		const err = `Cannot find module '${request}'`;
+		return `var e = new Error(${JSON.stringify(
+			err
+		)}); e.code = 'MODULE_NOT_FOUND'; throw e;`;
 	}
 
-	// TODO webpack 5 remove
-	get active() {
-		throw new Error("Use getActiveState instead");
+	/**
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error function
+	 */
+	throwMissingModuleErrorFunction({ request }) {
+		return `function webpackMissingModule() { ${this.throwMissingModuleErrorBlock(
+			{ request }
+		)} }`;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, if the connection is active
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error IIFE
 	 */
-	isActive(runtime) {
-		if (!this.conditional) return this._active;
-		return this.condition(this, runtime) !== false;
+	missingModule({ request }) {
+		return `Object(${this.throwMissingModuleErrorFunction({ request })}())`;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {boolean} true, if the connection is active
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error statement
 	 */
-	isTargetActive(runtime) {
-		if (!this.conditional) return this._active;
-		return this.condition(this, runtime) === true;
+	missingModuleStatement({ request }) {
+		return `${this.missingModule({ request })};\n`;
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ConnectionState} true: fully active, false: inactive, TRANSITIVE: direct module inactive, but transitive connection maybe active
+	 * @param {object} options generation options
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} generated error code
 	 */
-	getActiveState(runtime) {
-		if (!this.conditional) return this._active;
-		return this.condition(this, runtime);
+	missingModulePromise({ request }) {
+		return `Promise.resolve().then(${this.throwMissingModuleErrorFunction({
+			request
+		})})`;
 	}
 
 	/**
-	 * @param {boolean} value active or not
-	 * @returns {void}
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Module} options.module the module
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {string=} options.idExpr expression to use as id expression
+	 * @param {"expression" | "promise" | "statements"} options.type which kind of code should be returned
+	 * @returns {string} the code
 	 */
-	setActive(value) {
-		this.conditional = false;
-		this._active = value;
+	weakError({ module, chunkGraph, request, idExpr, type }) {
+		const moduleId = chunkGraph.getModuleId(module);
+		const errorMessage =
+			moduleId === null
+				? JSON.stringify("Module is not available (weak dependency)")
+				: idExpr
+				? `"Module '" + ${idExpr} + "' is not available (weak dependency)"`
+				: JSON.stringify(
+						`Module '${moduleId}' is not available (weak dependency)`
+				  );
+		const comment = request ? Template.toNormalComment(request) + " " : "";
+		const errorStatements =
+			`var e = new Error(${errorMessage}); ` +
+			comment +
+			"e.code = 'MODULE_NOT_FOUND'; throw e;";
+		switch (type) {
+			case "statements":
+				return errorStatements;
+			case "promise":
+				return `Promise.resolve().then(${this.basicFunction(
+					"",
+					errorStatements
+				)})`;
+			case "expression":
+				return this.iife("", errorStatements);
+		}
 	}
 
-	set active(value) {
-		throw new Error("Use setActive instead");
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @returns {string} the expression
+	 */
+	moduleId({ module, chunkGraph, request, weak }) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
+		}
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId === null) {
+			if (weak) {
+				return "null /* weak dependency, without id */";
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
+			);
+		}
+		return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
 	}
-}
-
-/** @typedef {typeof TRANSITIVE_ONLY} TRANSITIVE_ONLY */
-/** @typedef {typeof CIRCULAR_CONNECTION} CIRCULAR_CONNECTION */
-
-module.exports = ModuleGraphConnection;
-module.exports.addConnectionStates = addConnectionStates;
-module.exports.TRANSITIVE_ONLY = /** @type {typeof TRANSITIVE_ONLY} */ (
-	TRANSITIVE_ONLY
-);
-module.exports.CIRCULAR_CONNECTION = /** @type {typeof CIRCULAR_CONNECTION} */ (
-	CIRCULAR_CONNECTION
-);
 
-
-/***/ }),
-
-/***/ 3454:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { ConcatSource, RawSource, CachedSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Template = __webpack_require__(39722);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ExportsInfo")} ExportsInfo */
-/** @typedef {import("./ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-
-const joinIterableWithComma = iterable => {
-	// This is more performant than Array.from().join(", ")
-	// as it doesn't create an array
-	let str = "";
-	let first = true;
-	for (const item of iterable) {
-		if (first) {
-			first = false;
-		} else {
-			str += ", ";
-		}
-		str += item;
-	}
-	return str;
-};
-
-/**
- * @param {ConcatSource} source output
- * @param {string} indent spacing
- * @param {ExportsInfo} exportsInfo data
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @param {RequestShortener} requestShortener requestShortener
- * @param {Set<ExportInfo>} alreadyPrinted deduplication set
- * @returns {void}
- */
-const printExportsInfoToSource = (
-	source,
-	indent,
-	exportsInfo,
-	moduleGraph,
-	requestShortener,
-	alreadyPrinted = new Set()
-) => {
-	const otherExportsInfo = exportsInfo.otherExportsInfo;
-
-	let alreadyPrintedExports = 0;
-
-	// determine exports to print
-	const printedExports = [];
-	for (const exportInfo of exportsInfo.orderedExports) {
-		if (!alreadyPrinted.has(exportInfo)) {
-			alreadyPrinted.add(exportInfo);
-			printedExports.push(exportInfo);
-		} else {
-			alreadyPrintedExports++;
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the expression
+	 */
+	moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
 		}
-	}
-	let showOtherExports = false;
-	if (!alreadyPrinted.has(otherExportsInfo)) {
-		alreadyPrinted.add(otherExportsInfo);
-		showOtherExports = true;
-	} else {
-		alreadyPrintedExports++;
-	}
-
-	// print the exports
-	for (const exportInfo of printedExports) {
-		const target = exportInfo.getTarget(moduleGraph);
-		source.add(
-			Template.toComment(
-				`${indent}export ${JSON.stringify(exportInfo.name).slice(
-					1,
-					-1
-				)} [${exportInfo.getProvidedInfo()}] [${exportInfo.getUsedInfo()}] [${exportInfo.getRenameInfo()}]${
-					target
-						? ` -> ${target.module.readableIdentifier(requestShortener)}${
-								target.export
-									? ` .${target.export
-											.map(e => JSON.stringify(e).slice(1, -1))
-											.join(".")}`
-									: ""
-						  }`
-						: ""
-				}`
-			) + "\n"
-		);
-		if (exportInfo.exportsInfo) {
-			printExportsInfoToSource(
-				source,
-				indent + "  ",
-				exportInfo.exportsInfo,
-				moduleGraph,
-				requestShortener,
-				alreadyPrinted
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return this.weakError({
+					module,
+					chunkGraph,
+					request,
+					type: "expression"
+				});
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
 			);
 		}
+		runtimeRequirements.add(RuntimeGlobals.require);
+		return `__webpack_require__(${this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		})})`;
 	}
 
-	if (alreadyPrintedExports) {
-		source.add(
-			Template.toComment(
-				`${indent}... (${alreadyPrintedExports} already listed exports)`
-			) + "\n"
-		);
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the expression
+	 */
+	moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }) {
+		return this.moduleRaw({
+			module,
+			chunkGraph,
+			request,
+			weak,
+			runtimeRequirements
+		});
 	}
 
-	if (showOtherExports) {
-		const target = otherExportsInfo.getTarget(moduleGraph);
-		if (
-			target ||
-			otherExportsInfo.provided !== false ||
-			otherExportsInfo.getUsed(undefined) !== UsageState.Unused
-		) {
-			const title =
-				printedExports.length > 0 || alreadyPrintedExports > 0
-					? "other exports"
-					: "exports";
-			source.add(
-				Template.toComment(
-					`${indent}${title} [${otherExportsInfo.getProvidedInfo()}] [${otherExportsInfo.getUsedInfo()}]${
-						target
-							? ` -> ${target.module.readableIdentifier(requestShortener)}`
-							: ""
-					}`
-				) + "\n"
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {boolean=} options.strict if the current module is in strict esm mode
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the expression
+	 */
+	moduleNamespace({
+		module,
+		chunkGraph,
+		request,
+		strict,
+		weak,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
+		}
+		if (chunkGraph.getModuleId(module) === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return this.weakError({
+					module,
+					chunkGraph,
+					request,
+					type: "expression"
+				});
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleNamespace(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
 			);
 		}
+		const moduleId = this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		});
+		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
+		switch (exportsType) {
+			case "namespace":
+				return this.moduleRaw({
+					module,
+					chunkGraph,
+					request,
+					weak,
+					runtimeRequirements
+				});
+			case "default-with-named":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`;
+			case "default-only":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 1)`;
+			case "dynamic":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 7)`;
+		}
 	}
-};
 
-/** @type {WeakMap<RequestShortener, WeakMap<Module, { header: RawSource, full: WeakMap<Source, CachedSource> }>>} */
-const caches = new WeakMap();
-
-class ModuleInfoHeaderPlugin {
-	/**
-	 * @param {boolean=} verbose add more information like exports, runtime requirements and bailouts
-	 */
-	constructor(verbose = true) {
-		this._verbose = verbose;
-	}
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {AsyncDependenciesBlock=} options.block the current dependencies block
+	 * @param {Module} options.module the module
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {string} options.message a message for the comment
+	 * @param {boolean=} options.strict if the current module is in strict esm mode
+	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} the promise expression
 	 */
-	apply(compiler) {
-		const { _verbose: verbose } = this;
-		compiler.hooks.compilation.tap("ModuleInfoHeaderPlugin", compilation => {
-			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-			hooks.renderModulePackage.tap(
-				"ModuleInfoHeaderPlugin",
-				(
-					moduleSource,
+	moduleNamespacePromise({
+		chunkGraph,
+		block,
+		module,
+		request,
+		message,
+		strict,
+		weak,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return this.missingModulePromise({
+				request
+			});
+		}
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return this.weakError({
 					module,
-					{ chunk, chunkGraph, moduleGraph, runtimeTemplate }
-				) => {
-					const { requestShortener } = runtimeTemplate;
-					let cacheEntry;
-					let cache = caches.get(requestShortener);
-					if (cache === undefined) {
-						caches.set(requestShortener, (cache = new WeakMap()));
-						cache.set(
+					chunkGraph,
+					request,
+					type: "promise"
+				});
+			}
+			throw new Error(
+				`RuntimeTemplate.moduleNamespacePromise(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
+			);
+		}
+		const promise = this.blockPromise({
+			chunkGraph,
+			block,
+			message,
+			runtimeRequirements
+		});
+
+		let appending;
+		let idExpr = JSON.stringify(chunkGraph.getModuleId(module));
+		const comment = this.comment({
+			request
+		});
+		let header = "";
+		if (weak) {
+			if (idExpr.length > 8) {
+				// 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"'
+				header += `var id = ${idExpr}; `;
+				idExpr = "id";
+			}
+			runtimeRequirements.add(RuntimeGlobals.moduleFactories);
+			header += `if(!${
+				RuntimeGlobals.moduleFactories
+			}[${idExpr}]) { ${this.weakError({
+				module,
+				chunkGraph,
+				request,
+				idExpr,
+				type: "statements"
+			})} } `;
+		}
+		const moduleIdExpr = this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		});
+		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
+		let fakeType = 16;
+		switch (exportsType) {
+			case "namespace":
+				if (header) {
+					const rawModule = this.moduleRaw({
+						module,
+						chunkGraph,
+						request,
+						weak,
+						runtimeRequirements
+					});
+					appending = `.then(${this.basicFunction(
+						"",
+						`${header}return ${rawModule};`
+					)})`;
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.require);
+					appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
+				}
+				break;
+			case "dynamic":
+				fakeType |= 4;
+			/* fall through */
+			case "default-with-named":
+				fakeType |= 2;
+			/* fall through */
+			case "default-only":
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				if (chunkGraph.moduleGraph.isAsync(module)) {
+					if (header) {
+						const rawModule = this.moduleRaw({
 							module,
-							(cacheEntry = { header: undefined, full: new WeakMap() })
-						);
+							chunkGraph,
+							request,
+							weak,
+							runtimeRequirements
+						});
+						appending = `.then(${this.basicFunction(
+							"",
+							`${header}return ${rawModule};`
+						)})`;
 					} else {
-						cacheEntry = cache.get(module);
-						if (cacheEntry === undefined) {
-							cache.set(
-								module,
-								(cacheEntry = { header: undefined, full: new WeakMap() })
-							);
-						} else if (!verbose) {
-							const cachedSource = cacheEntry.full.get(moduleSource);
-							if (cachedSource !== undefined) return cachedSource;
-						}
-					}
-					const source = new ConcatSource();
-					let header = cacheEntry.header;
-					if (header === undefined) {
-						const req = module.readableIdentifier(requestShortener);
-						const reqStr = req.replace(/\*\//g, "*_/");
-						const reqStrStar = "*".repeat(reqStr.length);
-						const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
-						header = new RawSource(headerStr);
-						cacheEntry.header = header;
+						runtimeRequirements.add(RuntimeGlobals.require);
+						appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
 					}
-					source.add(header);
-					if (verbose) {
-						const exportsType = module.buildMeta.exportsType;
-						source.add(
-							Template.toComment(
-								exportsType
-									? `${exportsType} exports`
-									: "unknown exports (runtime-defined)"
-							) + "\n"
-						);
-						if (exportsType) {
-							const exportsInfo = moduleGraph.getExportsInfo(module);
-							printExportsInfoToSource(
-								source,
-								"",
-								exportsInfo,
-								moduleGraph,
-								requestShortener
-							);
-						}
-						source.add(
-							Template.toComment(
-								`runtime requirements: ${joinIterableWithComma(
-									chunkGraph.getModuleRuntimeRequirements(module, chunk.runtime)
-								)}`
-							) + "\n"
-						);
-						const optimizationBailout =
-							moduleGraph.getOptimizationBailout(module);
-						if (optimizationBailout) {
-							for (const text of optimizationBailout) {
-								let code;
-								if (typeof text === "function") {
-									code = text(requestShortener);
-								} else {
-									code = text;
-								}
-								source.add(Template.toComment(`${code}`) + "\n");
-							}
-						}
-						source.add(moduleSource);
-						return source;
+					appending += `.then(${this.returningFunction(
+						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
+						"m"
+					)})`;
+				} else {
+					fakeType |= 1;
+					if (header) {
+						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
+						appending = `.then(${this.basicFunction(
+							"",
+							`${header}return ${returnExpression};`
+						)})`;
 					} else {
-						source.add(moduleSource);
-						const cachedSource = new CachedSource(source);
-						cacheEntry.full.set(moduleSource, cachedSource);
-						return cachedSource;
+						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(__webpack_require__, ${comment}${idExpr}, ${fakeType}))`;
 					}
 				}
-			);
-			hooks.chunkHash.tap("ModuleInfoHeaderPlugin", (chunk, hash) => {
-				hash.update("ModuleInfoHeaderPlugin");
-				hash.update("1");
-			});
-		});
-	}
-}
-module.exports = ModuleInfoHeaderPlugin;
-
-
-/***/ }),
-
-/***/ 32882:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				break;
+		}
 
+		return `${promise || "Promise.resolve()"}${appending}`;
+	}
 
-
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-
-const previouslyPolyfilledBuiltinModules = {
-	assert: "assert/",
-	buffer: "buffer/",
-	console: "console-browserify",
-	constants: "constants-browserify",
-	crypto: "crypto-browserify",
-	domain: "domain-browser",
-	events: "events/",
-	http: "stream-http",
-	https: "https-browserify",
-	os: "os-browserify/browser",
-	path: "path-browserify",
-	punycode: "punycode/",
-	process: "process/browser",
-	querystring: "querystring-es3",
-	stream: "stream-browserify",
-	_stream_duplex: "readable-stream/duplex",
-	_stream_passthrough: "readable-stream/passthrough",
-	_stream_readable: "readable-stream/readable",
-	_stream_transform: "readable-stream/transform",
-	_stream_writable: "readable-stream/writable",
-	string_decoder: "string_decoder/",
-	sys: "util/",
-	timers: "timers-browserify",
-	tty: "tty-browserify",
-	url: "url/",
-	util: "util/",
-	vm: "vm-browserify",
-	zlib: "browserify-zlib"
-};
-
-class ModuleNotFoundError extends WebpackError {
 	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {Error&any} err error thrown
-	 * @param {DependencyLocation} loc location of dependency
+	 * @param {Object} options options object
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
+	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
 	 */
-	constructor(module, err, loc) {
-		let message = `Module not found: ${err.toString()}`;
+	runtimeConditionExpression({
+		chunkGraph,
+		runtimeCondition,
+		runtime,
+		runtimeRequirements
+	}) {
+		if (runtimeCondition === undefined) return "true";
+		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
+		/** @type {Set<string>} */
+		const positiveRuntimeIds = new Set();
+		forEachRuntime(runtimeCondition, runtime =>
+			positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		/** @type {Set<string>} */
+		const negativeRuntimeIds = new Set();
+		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
+			negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
+		);
+		runtimeRequirements.add(RuntimeGlobals.runtimeId);
+		return compileBooleanMatcher.fromLists(
+			Array.from(positiveRuntimeIds),
+			Array.from(negativeRuntimeIds)
+		)(RuntimeGlobals.runtimeId);
+	}
 
-		// TODO remove in webpack 6
-		const match = err.message.match(/Can't resolve '([^']+)'/);
-		if (match) {
-			const request = match[1];
-			const alias = previouslyPolyfilledBuiltinModules[request];
-			if (alias) {
-				const pathIndex = alias.indexOf("/");
-				const dependency = pathIndex > 0 ? alias.slice(0, pathIndex) : alias;
-				message +=
-					"\n\n" +
-					"BREAKING CHANGE: " +
-					"webpack < 5 used to include polyfills for node.js core modules by default.\n" +
-					"This is no longer the case. Verify if you need this module and configure a polyfill for it.\n\n";
-				message +=
-					"If you want to include a polyfill, you need to:\n" +
-					`\t- add a fallback 'resolve.fallback: { "${request}": require.resolve("${alias}") }'\n` +
-					`\t- install '${dependency}'\n`;
-				message +=
-					"If you don't want to include a polyfill, you can use an empty module like this:\n" +
-					`\tresolve.fallback: { "${request}": false }`;
+	/**
+	 *
+	 * @param {Object} options options object
+	 * @param {boolean=} options.update whether a new variable should be created or the existing one updated
+	 * @param {Module} options.module the module
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {string} options.request the request that should be printed as comment
+	 * @param {string} options.importVar name of the import variable
+	 * @param {Module} options.originModule module in which the statement is emitted
+	 * @param {boolean=} options.weak true, if this is a weak dependency
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {[string, string]} the import statement and the compat statement
+	 */
+	importStatement({
+		update,
+		module,
+		chunkGraph,
+		request,
+		importVar,
+		originModule,
+		weak,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return [
+				this.missingModuleStatement({
+					request
+				}),
+				""
+			];
+		}
+		if (chunkGraph.getModuleId(module) === null) {
+			if (weak) {
+				// only weak referenced modules don't get an id
+				// we can always emit an error emitting code here
+				return [
+					this.weakError({
+						module,
+						chunkGraph,
+						request,
+						type: "statements"
+					}),
+					""
+				];
 			}
+			throw new Error(
+				`RuntimeTemplate.importStatement(): ${noModuleIdErrorMessage(
+					module,
+					chunkGraph
+				)}`
+			);
 		}
+		const moduleId = this.moduleId({
+			module,
+			chunkGraph,
+			request,
+			weak
+		});
+		const optDeclaration = update ? "" : "var ";
 
-		super(message);
+		const exportsType = module.getExportsType(
+			chunkGraph.moduleGraph,
+			originModule.buildMeta.strictHarmonyModule
+		);
+		runtimeRequirements.add(RuntimeGlobals.require);
+		const importContent = `/* harmony import */ ${optDeclaration}${importVar} = __webpack_require__(${moduleId});\n`;
 
-		this.name = "ModuleNotFoundError";
-		this.details = err.details;
-		this.module = module;
-		this.error = err;
-		this.loc = loc;
+		if (exportsType === "dynamic") {
+			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+			return [
+				importContent,
+				`/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${importVar});\n`
+			];
+		}
+		return [importContent, ""];
 	}
-}
-
-module.exports = ModuleNotFoundError;
-
-
-/***/ }),
-
-/***/ 58443:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-const WASM_HEADER = Buffer.from([0x00, 0x61, 0x73, 0x6d]);
 
-class ModuleParseError extends WebpackError {
 	/**
-	 * @param {string | Buffer} source source code
-	 * @param {Error&any} err the parse error
-	 * @param {string[]} loaders the loaders used
-	 * @param {string} type module type
+	 * @param {Object} options options
+	 * @param {ModuleGraph} options.moduleGraph the module graph
+	 * @param {Module} options.module the module
+	 * @param {string} options.request the request
+	 * @param {string | string[]} options.exportName the export name
+	 * @param {Module} options.originModule the origin module
+	 * @param {boolean|undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
+	 * @param {boolean} options.isCall true, if expression will be called
+	 * @param {boolean} options.callContext when false, call context will not be preserved
+	 * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated
+	 * @param {string} options.importVar the identifier name of the import variable
+	 * @param {InitFragment[]} options.initFragments init fragments will be added here
+	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
 	 */
-	constructor(source, err, loaders, type) {
-		let message = "Module parse failed: " + (err && err.message);
-		let loc = undefined;
-
-		if (
-			((Buffer.isBuffer(source) && source.slice(0, 4).equals(WASM_HEADER)) ||
-				(typeof source === "string" && /^\0asm/.test(source))) &&
-			!type.startsWith("webassembly")
-		) {
-			message +=
-				"\nThe module seem to be a WebAssembly module, but module is not flagged as WebAssembly module for webpack.";
-			message +=
-				"\nBREAKING CHANGE: Since webpack 5 WebAssembly is not enabled by default and flagged as experimental feature.";
-			message +=
-				"\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
-			message +=
-				"\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
-		} else if (!loaders) {
-			message +=
-				"\nYou may need an appropriate loader to handle this file type.";
-		} else if (loaders.length >= 1) {
-			message += `\nFile was processed with these loaders:${loaders
-				.map(loader => `\n * ${loader}`)
-				.join("")}`;
-			message +=
-				"\nYou may need an additional loader to handle the result of these loaders.";
-		} else {
-			message +=
-				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+	exportFromImport({
+		moduleGraph,
+		module,
+		request,
+		exportName,
+		originModule,
+		asiSafe,
+		isCall,
+		callContext,
+		defaultInterop,
+		importVar,
+		initFragments,
+		runtime,
+		runtimeRequirements
+	}) {
+		if (!module) {
+			return this.missingModule({
+				request
+			});
 		}
+		if (!Array.isArray(exportName)) {
+			exportName = exportName ? [exportName] : [];
+		}
+		const exportsType = module.getExportsType(
+			moduleGraph,
+			originModule.buildMeta.strictHarmonyModule
+		);
 
-		if (
-			err &&
-			err.loc &&
-			typeof err.loc === "object" &&
-			typeof err.loc.line === "number"
-		) {
-			var lineNumber = err.loc.line;
-
-			if (
-				Buffer.isBuffer(source) ||
-				/[\0\u0001\u0002\u0003\u0004\u0005\u0006\u0007]/.test(source)
+		if (defaultInterop) {
+			if (exportName.length > 0 && exportName[0] === "default") {
+				switch (exportsType) {
+					case "dynamic":
+						if (isCall) {
+							return `${importVar}_default()${propertyAccess(exportName, 1)}`;
+						} else {
+							return asiSafe
+								? `(${importVar}_default()${propertyAccess(exportName, 1)})`
+								: asiSafe === false
+								? `;(${importVar}_default()${propertyAccess(exportName, 1)})`
+								: `${importVar}_default.a${propertyAccess(exportName, 1)}`;
+						}
+					case "default-only":
+					case "default-with-named":
+						exportName = exportName.slice(1);
+						break;
+				}
+			} else if (exportName.length > 0) {
+				if (exportsType === "default-only") {
+					return (
+						"/* non-default import from non-esm module */undefined" +
+						propertyAccess(exportName, 1)
+					);
+				} else if (
+					exportsType !== "namespace" &&
+					exportName[0] === "__esModule"
+				) {
+					return "/* __esModule */true";
+				}
+			} else if (
+				exportsType === "default-only" ||
+				exportsType === "default-with-named"
 			) {
-				// binary file
-				message += "\n(Source code omitted for this binary file)";
-			} else {
-				const sourceLines = source.split(/\r?\n/);
-				const start = Math.max(0, lineNumber - 3);
-				const linesBefore = sourceLines.slice(start, lineNumber - 1);
-				const theLine = sourceLines[lineNumber - 1];
-				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
-
-				message +=
-					linesBefore.map(l => `\n| ${l}`).join("") +
-					`\n> ${theLine}` +
-					linesAfter.map(l => `\n| ${l}`).join("");
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				initFragments.push(
+					new InitFragment(
+						`var ${importVar}_namespace_cache;\n`,
+						InitFragment.STAGE_CONSTANTS,
+						-1,
+						`${importVar}_namespace_cache`
+					)
+				);
+				return `/*#__PURE__*/ ${
+					asiSafe ? "" : asiSafe === false ? ";" : "Object"
+				}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${
+					RuntimeGlobals.createFakeNamespaceObject
+				}(${importVar}${exportsType === "default-only" ? "" : ", 2"})))`;
 			}
-
-			loc = { start: err.loc };
-		} else if (err && err.stack) {
-			message += "\n" + err.stack;
 		}
 
-		super(message);
-
-		this.name = "ModuleParseError";
-		this.loc = loc;
-		this.error = err;
+		if (exportName.length > 0) {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const used = exportsInfo.getUsedName(exportName, runtime);
+			if (!used) {
+				const comment = Template.toNormalComment(
+					`unused export ${propertyAccess(exportName)}`
+				);
+				return `${comment} undefined`;
+			}
+			const comment = equals(used, exportName)
+				? ""
+				: Template.toNormalComment(propertyAccess(exportName)) + " ";
+			const access = `${importVar}${comment}${propertyAccess(used)}`;
+			if (isCall && callContext === false) {
+				return asiSafe
+					? `(0,${access})`
+					: asiSafe === false
+					? `;(0,${access})`
+					: `/*#__PURE__*/Object(${access})`;
+			}
+			return access;
+		} else {
+			return importVar;
+		}
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.error);
+	/**
+	 * @param {Object} options options
+	 * @param {AsyncDependenciesBlock} options.block the async block
+	 * @param {string} options.message the message
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} expression
+	 */
+	blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
+		if (!block) {
+			const comment = this.comment({
+				message
+			});
+			return `Promise.resolve(${comment.trim()})`;
+		}
+		const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+		if (!chunkGroup || chunkGroup.chunks.length === 0) {
+			const comment = this.comment({
+				message
+			});
+			return `Promise.resolve(${comment.trim()})`;
+		}
+		const chunks = chunkGroup.chunks.filter(
+			chunk => !chunk.hasRuntime() && chunk.id !== null
+		);
+		const comment = this.comment({
+			message,
+			chunkName: block.chunkName
+		});
+		if (chunks.length === 1) {
+			const chunkId = JSON.stringify(chunks[0].id);
+			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId})`;
+		} else if (chunks.length > 0) {
+			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+			const requireChunkId = chunk =>
+				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`;
+			return `Promise.all(${comment.trim()}[${chunks
+				.map(requireChunkId)
+				.join(", ")}])`;
+		} else {
+			return `Promise.resolve(${comment.trim()})`;
+		}
+	}
 
-		super.serialize(context);
+	/**
+	 * @param {Object} options options
+	 * @param {AsyncDependenciesBlock} options.block the async block
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} expression
+	 */
+	asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) {
+		const dep = block.dependencies[0];
+		const module = chunkGraph.moduleGraph.getModule(dep);
+		const ensureChunk = this.blockPromise({
+			block,
+			message: "",
+			chunkGraph,
+			runtimeRequirements
+		});
+		const factory = this.returningFunction(
+			this.moduleRaw({
+				module,
+				chunkGraph,
+				request,
+				runtimeRequirements
+			})
+		);
+		return this.returningFunction(
+			ensureChunk.startsWith("Promise.resolve(")
+				? `${factory}`
+				: `${ensureChunk}.then(${this.returningFunction(factory)})`
+		);
 	}
 
-	deserialize(context) {
-		const { read } = context;
+	/**
+	 * @param {Object} options options
+	 * @param {Dependency} options.dependency the dependency
+	 * @param {ChunkGraph} options.chunkGraph the chunk graph
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {string=} options.request request string used originally
+	 * @returns {string} expression
+	 */
+	syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }) {
+		const module = chunkGraph.moduleGraph.getModule(dependency);
+		const factory = this.returningFunction(
+			this.moduleRaw({
+				module,
+				chunkGraph,
+				request,
+				runtimeRequirements
+			})
+		);
+		return this.returningFunction(factory);
+	}
 
-		this.error = read();
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.exportsArgument the name of the exports object
+	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @returns {string} statement
+	 */
+	defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
+	}
 
-		super.deserialize(context);
+	/**
+	 * @param {Object} options options object
+	 * @param {Module} options.module the module
+	 * @param {string} options.publicPath the public path
+	 * @param {RuntimeSpec=} options.runtime runtime
+	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
+	 * @returns {string} the url of the asset
+	 */
+	assetUrl({ publicPath, runtime, module, codeGenerationResults }) {
+		if (!module) {
+			return "data:,";
+		}
+		const codeGen = codeGenerationResults.get(module, runtime);
+		const { data } = codeGen;
+		const url = data.get("url");
+		if (url) return url.toString();
+		const filename = data.get("filename");
+		return publicPath + filename;
 	}
 }
 
-makeSerializable(ModuleParseError, "webpack/lib/ModuleParseError");
-
-module.exports = ModuleParseError;
+module.exports = RuntimeTemplate;
 
 
 /***/ }),
 
-/***/ 36418:
+/***/ 63560:
 /***/ (function(module) {
 
 "use strict";
@@ -54083,211 +54731,76 @@ module.exports = ModuleParseError;
 
 
 
-class ModuleProfile {
-	constructor() {
-		this.startTime = Date.now();
-
-		this.factoryStartTime = 0;
-		this.factoryEndTime = 0;
-		this.factory = 0;
-		this.factoryParallelismFactor = 0;
-
-		this.restoringStartTime = 0;
-		this.restoringEndTime = 0;
-		this.restoring = 0;
-		this.restoringParallelismFactor = 0;
-
-		this.integrationStartTime = 0;
-		this.integrationEndTime = 0;
-		this.integration = 0;
-		this.integrationParallelismFactor = 0;
-
-		this.buildingStartTime = 0;
-		this.buildingEndTime = 0;
-		this.building = 0;
-		this.buildingParallelismFactor = 0;
-
-		this.storingStartTime = 0;
-		this.storingEndTime = 0;
-		this.storing = 0;
-		this.storingParallelismFactor = 0;
-
-		this.additionalFactoryTimes = undefined;
-		this.additionalFactories = 0;
-		this.additionalFactoriesParallelismFactor = 0;
-
-		/** @deprecated */
-		this.additionalIntegration = 0;
-	}
-
-	markFactoryStart() {
-		this.factoryStartTime = Date.now();
-	}
-
-	markFactoryEnd() {
-		this.factoryEndTime = Date.now();
-		this.factory = this.factoryEndTime - this.factoryStartTime;
-	}
-
-	markRestoringStart() {
-		this.restoringStartTime = Date.now();
-	}
-
-	markRestoringEnd() {
-		this.restoringEndTime = Date.now();
-		this.restoring = this.restoringEndTime - this.restoringStartTime;
-	}
-
-	markIntegrationStart() {
-		this.integrationStartTime = Date.now();
-	}
-
-	markIntegrationEnd() {
-		this.integrationEndTime = Date.now();
-		this.integration = this.integrationEndTime - this.integrationStartTime;
-	}
-
-	markBuildingStart() {
-		this.buildingStartTime = Date.now();
-	}
-
-	markBuildingEnd() {
-		this.buildingEndTime = Date.now();
-		this.building = this.buildingEndTime - this.buildingStartTime;
-	}
-
-	markStoringStart() {
-		this.storingStartTime = Date.now();
-	}
-
-	markStoringEnd() {
-		this.storingEndTime = Date.now();
-		this.storing = this.storingEndTime - this.storingStartTime;
+class SelfModuleFactory {
+	constructor(moduleGraph) {
+		this.moduleGraph = moduleGraph;
 	}
 
-	// This depends on timing so we ignore it for coverage
-	/* istanbul ignore next */
-	/**
-	 * Merge this profile into another one
-	 * @param {ModuleProfile} realProfile the profile to merge into
-	 * @returns {void}
-	 */
-	mergeInto(realProfile) {
-		realProfile.additionalFactories = this.factory;
-		(realProfile.additionalFactoryTimes =
-			realProfile.additionalFactoryTimes || []).push({
-			start: this.factoryStartTime,
-			end: this.factoryEndTime
+	create(data, callback) {
+		const module = this.moduleGraph.getParentModule(data.dependencies[0]);
+		callback(null, {
+			module
 		});
 	}
 }
 
-module.exports = ModuleProfile;
+module.exports = SelfModuleFactory;
 
 
 /***/ }),
 
-/***/ 94560:
+/***/ 48076:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Module")} Module */
-
-class ModuleRestoreError extends WebpackError {
-	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {string | Error} err error thrown
-	 */
-	constructor(module, err) {
-		let message = "Module restore failed: ";
-		let details = undefined;
-		if (err !== null && typeof err === "object") {
-			if (typeof err.stack === "string" && err.stack) {
-				const stack = err.stack;
-				message += stack;
-			} else if (typeof err.message === "string" && err.message) {
-				message += err.message;
-			} else {
-				message += err;
-			}
-		} else {
-			message += String(err);
-		}
-
-		super(message);
-
-		this.name = "ModuleRestoreError";
-		this.details = details;
-		this.module = module;
-		this.error = err;
-	}
-}
-
-module.exports = ModuleRestoreError;
+module.exports = __webpack_require__(96953);
 
 
 /***/ }),
 
-/***/ 59001:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 71070:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sean Larkin @thelarkinn
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./Module")} Module */
-
-class ModuleStoreError extends WebpackError {
-	/**
-	 * @param {Module} module module tied to dependency
-	 * @param {string | Error} err error thrown
-	 */
-	constructor(module, err) {
-		let message = "Module storing failed: ";
-		let details = undefined;
-		if (err !== null && typeof err === "object") {
-			if (typeof err.stack === "string" && err.stack) {
-				const stack = err.stack;
-				message += stack;
-			} else if (typeof err.message === "string" && err.message) {
-				message += err.message;
-			} else {
-				message += err;
-			}
-		} else {
-			message += String(err);
-		}
-
-		super(message);
+/**
+ * @param {number} size the size in bytes
+ * @returns {string} the formatted size
+ */
+exports.formatSize = size => {
+	if (typeof size !== "number" || Number.isNaN(size) === true) {
+		return "unknown size";
+	}
 
-		this.name = "ModuleStoreError";
-		this.details = details;
-		this.module = module;
-		this.error = err;
+	if (size <= 0) {
+		return "0 bytes";
 	}
-}
 
-module.exports = ModuleStoreError;
+	const abbreviations = ["bytes", "KiB", "MiB", "GiB"];
+	const index = Math.floor(Math.log(size) / Math.log(1024));
+
+	return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${
+		abbreviations[index]
+	}`;
+};
 
 
 /***/ }),
 
-/***/ 62677:
+/***/ 97513:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -54298,215 +54811,61 @@ module.exports = ModuleStoreError;
 
 
 
-const util = __webpack_require__(73837);
-const memoize = __webpack_require__(78676);
+const JavascriptModulesPlugin = __webpack_require__(89464);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
 /** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./util/Hash")} Hash */
-
-const getJavascriptModulesPlugin = memoize(() =>
-	__webpack_require__(89464)
-);
 
-// TODO webpack 6: remove this class
-class ModuleTemplate {
-	/**
-	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {Compilation} compilation the compilation
-	 */
-	constructor(runtimeTemplate, compilation) {
-		this._runtimeTemplate = runtimeTemplate;
-		this.type = "javascript";
-		this.hooks = Object.freeze({
-			content: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContent.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.content is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
-					"DEP_MODULE_TEMPLATE_CONTENT"
-				)
-			},
-			module: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContent.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.module is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContent instead)",
-					"DEP_MODULE_TEMPLATE_MODULE"
-				)
-			},
-			render: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModuleContainer.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer instead)",
-					"DEP_MODULE_TEMPLATE_RENDER"
-				)
-			},
-			package: {
-				tap: util.deprecate(
-					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderModulePackage.tap(
-								options,
-								(source, module, renderContext) =>
-									fn(
-										source,
-										module,
-										renderContext,
-										renderContext.dependencyTemplates
-									)
-							);
-					},
-					"ModuleTemplate.hooks.package is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderModulePackage instead)",
-					"DEP_MODULE_TEMPLATE_PACKAGE"
-				)
-			},
-			hash: {
-				tap: util.deprecate(
-					(options, fn) => {
-						compilation.hooks.fullHash.tap(options, fn);
-					},
-					"ModuleTemplate.hooks.hash is deprecated (use Compilation.hooks.fullHash instead)",
-					"DEP_MODULE_TEMPLATE_HASH"
-				)
-			}
-		});
+class SourceMapDevToolModuleOptionsPlugin {
+	constructor(options) {
+		this.options = options;
 	}
-}
-
-Object.defineProperty(ModuleTemplate.prototype, "runtimeTemplate", {
-	get: util.deprecate(
-		/**
-		 * @this {ModuleTemplate}
-		 * @returns {TODO} output options
-		 */
-		function () {
-			return this._runtimeTemplate;
-		},
-		"ModuleTemplate.runtimeTemplate is deprecated (use Compilation.runtimeTemplate instead)",
-		"DEP_WEBPACK_CHUNK_TEMPLATE_OUTPUT_OPTIONS"
-	)
-});
-
-module.exports = ModuleTemplate;
-
-
-/***/ }),
-
-/***/ 11234:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
-
-const { cleanUp } = __webpack_require__(59985);
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-class ModuleWarning extends WebpackError {
 	/**
-	 * @param {Error} warning error thrown
-	 * @param {{from?: string|null}} info additional info
+	 * @param {Compilation} compilation the compiler instance
+	 * @returns {void}
 	 */
-	constructor(warning, { from = null } = {}) {
-		let message = "Module Warning";
-
-		if (from) {
-			message += ` (from ${from}):\n`;
+	apply(compilation) {
+		const options = this.options;
+		if (options.module !== false) {
+			compilation.hooks.buildModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSourceMap = true;
+				}
+			);
+			compilation.hooks.runtimeModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSourceMap = true;
+				}
+			);
 		} else {
-			message += ": ";
-		}
-
-		if (warning && typeof warning === "object" && warning.message) {
-			message += warning.message;
-		} else if (warning) {
-			message += String(warning);
+			compilation.hooks.buildModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSimpleSourceMap = true;
+				}
+			);
+			compilation.hooks.runtimeModule.tap(
+				"SourceMapDevToolModuleOptionsPlugin",
+				module => {
+					module.useSimpleSourceMap = true;
+				}
+			);
 		}
-
-		super(message);
-
-		this.name = "ModuleWarning";
-		this.warning = warning;
-		this.details =
-			warning && typeof warning === "object" && warning.stack
-				? cleanUp(warning.stack, this.message)
-				: undefined;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.warning);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.warning = read();
-
-		super.deserialize(context);
+		JavascriptModulesPlugin.getCompilationHooks(compilation).useSourceMap.tap(
+			"SourceMapDevToolModuleOptionsPlugin",
+			() => true
+		);
 	}
 }
 
-makeSerializable(ModuleWarning, "webpack/lib/ModuleWarning");
-
-module.exports = ModuleWarning;
+module.exports = SourceMapDevToolModuleOptionsPlugin;
 
 
 /***/ }),
 
-/***/ 33370:
+/***/ 63872:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -54518,586 +54877,564 @@ module.exports = ModuleWarning;
 
 
 const asyncLib = __webpack_require__(78175);
-const { SyncHook, MultiHook } = __webpack_require__(41242);
-
-const ConcurrentCompilationError = __webpack_require__(95735);
-const MultiStats = __webpack_require__(24170);
-const MultiWatching = __webpack_require__(81128);
-const ArrayQueue = __webpack_require__(41792);
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const ModuleFilenameHelpers = __webpack_require__(88821);
+const ProgressPlugin = __webpack_require__(13216);
+const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const { relative, dirname } = __webpack_require__(17139);
+const { makePathsAbsolute } = __webpack_require__(82186);
 
-/** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
-/** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("webpack-sources").MapOptions} MapOptions */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
+/** @typedef {import("./Cache").Etag} Etag */
+/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Stats")} Stats */
-/** @typedef {import("./Watching")} Watching */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule").SourceMap} SourceMap */
+/** @typedef {import("./util/Hash")} Hash */
 
+const validate = createSchemaValidation(
+	__webpack_require__(2885),
+	() => __webpack_require__(30501),
+	{
+		name: "SourceMap DevTool Plugin",
+		baseDataPath: "options"
+	}
+);
 /**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
+ * @typedef {object} SourceMapTask
+ * @property {Source} asset
+ * @property {AssetInfo} assetInfo
+ * @property {(string | Module)[]} modules
+ * @property {string} source
+ * @property {string} file
+ * @property {SourceMap} sourceMap
+ * @property {ItemCacheFacade} cacheItem cache item
  */
 
 /**
- * @callback RunWithDependenciesHandler
- * @param {Compiler} compiler
- * @param {Callback<MultiStats>} callback
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
  */
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+};
 
 /**
- * @typedef {Object} MultiCompilerOptions
- * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
+ * Creating {@link SourceMapTask} for given file
+ * @param {string} file current compiled file
+ * @param {Source} asset the asset
+ * @param {AssetInfo} assetInfo the asset info
+ * @param {MapOptions} options source map options
+ * @param {Compilation} compilation compilation instance
+ * @param {ItemCacheFacade} cacheItem cache item
+ * @returns {SourceMapTask | undefined} created task instance or `undefined`
  */
+const getTaskForFile = (
+	file,
+	asset,
+	assetInfo,
+	options,
+	compilation,
+	cacheItem
+) => {
+	let source;
+	/** @type {SourceMap} */
+	let sourceMap;
+	/**
+	 * Check if asset can build source map
+	 */
+	if (asset.sourceAndMap) {
+		const sourceAndMap = asset.sourceAndMap(options);
+		sourceMap = /** @type {SourceMap} */ (sourceAndMap.map);
+		source = sourceAndMap.source;
+	} else {
+		sourceMap = /** @type {SourceMap} */ (asset.map(options));
+		source = asset.source();
+	}
+	if (!sourceMap || typeof source !== "string") return;
+	const context = compilation.options.context;
+	const root = compilation.compiler.root;
+	const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root);
+	const modules = sourceMap.sources.map(source => {
+		if (!source.startsWith("webpack://")) return source;
+		source = cachedAbsolutify(source.slice(10));
+		const module = compilation.findModule(source);
+		return module || source;
+	});
 
-module.exports = class MultiCompiler {
-	/**
-	 * @param {Compiler[] | Record<string, Compiler>} compilers child compilers
-	 * @param {MultiCompilerOptions} options options
-	 */
-	constructor(compilers, options) {
-		if (!Array.isArray(compilers)) {
-			compilers = Object.keys(compilers).map(name => {
-				compilers[name].name = name;
-				return compilers[name];
-			});
-		}
-
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[MultiStats]>} */
-			done: new SyncHook(["stats"]),
-			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
-			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
-			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			run: new MultiHook(compilers.map(c => c.hooks.run)),
-			/** @type {SyncHook<[]>} */
-			watchClose: new SyncHook([]),
-			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
-			/** @type {MultiHook<SyncBailHook<[string, string, any[]], true>>} */
-			infrastructureLog: new MultiHook(
-				compilers.map(c => c.hooks.infrastructureLog)
-			)
-		});
-		this.compilers = compilers;
-		/** @type {MultiCompilerOptions} */
-		this._options = {
-			parallelism: options.parallelism || Infinity
-		};
-		/** @type {WeakMap<Compiler, string[]>} */
-		this.dependencies = new WeakMap();
-		this.running = false;
+	return {
+		file,
+		asset,
+		source,
+		assetInfo,
+		sourceMap,
+		modules,
+		cacheItem
+	};
+};
 
-		/** @type {Stats[]} */
-		const compilerStats = this.compilers.map(() => null);
-		let doneCompilers = 0;
-		for (let index = 0; index < this.compilers.length; index++) {
-			const compiler = this.compilers[index];
-			const compilerIndex = index;
-			let compilerDone = false;
-			compiler.hooks.done.tap("MultiCompiler", stats => {
-				if (!compilerDone) {
-					compilerDone = true;
-					doneCompilers++;
-				}
-				compilerStats[compilerIndex] = stats;
-				if (doneCompilers === this.compilers.length) {
-					this.hooks.done.call(new MultiStats(compilerStats));
-				}
-			});
-			compiler.hooks.invalid.tap("MultiCompiler", () => {
-				if (compilerDone) {
-					compilerDone = false;
-					doneCompilers--;
-				}
-			});
-		}
+class SourceMapDevToolPlugin {
+	/**
+	 * @param {SourceMapDevToolPluginOptions} [options] options object
+	 * @throws {Error} throws error, if got more than 1 arguments
+	 */
+	constructor(options = {}) {
+		validate(options);
+
+		/** @type {string | false} */
+		this.sourceMapFilename = options.filename;
+		/** @type {string | false} */
+		this.sourceMappingURLComment =
+			options.append === false
+				? false
+				: options.append || "\n//# source" + "MappingURL=[url]";
+		/** @type {string | Function} */
+		this.moduleFilenameTemplate =
+			options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]";
+		/** @type {string | Function} */
+		this.fallbackModuleFilenameTemplate =
+			options.fallbackModuleFilenameTemplate ||
+			"webpack://[namespace]/[resourcePath]?[hash]";
+		/** @type {string} */
+		this.namespace = options.namespace || "";
+		/** @type {SourceMapDevToolPluginOptions} */
+		this.options = options;
 	}
 
-	get options() {
-		return Object.assign(
-			this.compilers.map(c => c.options),
-			this._options
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const outputFs = compiler.outputFileSystem;
+		const sourceMapFilename = this.sourceMapFilename;
+		const sourceMappingURLComment = this.sourceMappingURLComment;
+		const moduleFilenameTemplate = this.moduleFilenameTemplate;
+		const namespace = this.namespace;
+		const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate;
+		const requestShortener = compiler.requestShortener;
+		const options = this.options;
+		options.test = options.test || /\.((c|m)?js|css)($|\?)/i;
+
+		const matchObject = ModuleFilenameHelpers.matchObject.bind(
+			undefined,
+			options
 		);
-	}
 
-	get outputPath() {
-		let commonPath = this.compilers[0].outputPath;
-		for (const compiler of this.compilers) {
-			while (
-				compiler.outputPath.indexOf(commonPath) !== 0 &&
-				/[/\\]/.test(commonPath)
-			) {
-				commonPath = commonPath.replace(/[/\\][^/\\]*$/, "");
-			}
-		}
+		compiler.hooks.compilation.tap("SourceMapDevToolPlugin", compilation => {
+			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
 
-		if (!commonPath && this.compilers[0].outputPath[0] === "/") return "/";
-		return commonPath;
-	}
+			compilation.hooks.processAssets.tapAsync(
+				{
+					name: "SourceMapDevToolPlugin",
+					stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+					additionalAssets: true
+				},
+				(assets, callback) => {
+					const chunkGraph = compilation.chunkGraph;
+					const cache = compilation.getCache("SourceMapDevToolPlugin");
+					/** @type {Map<string | Module, string>} */
+					const moduleToSourceNameMapping = new Map();
+					/**
+					 * @type {Function}
+					 * @returns {void}
+					 */
+					const reportProgress =
+						ProgressPlugin.getReporter(compilation.compiler) || (() => {});
 
-	get inputFileSystem() {
-		throw new Error("Cannot read inputFileSystem of a MultiCompiler");
-	}
+					/** @type {Map<string, Chunk>} */
+					const fileToChunk = new Map();
+					for (const chunk of compilation.chunks) {
+						for (const file of chunk.files) {
+							fileToChunk.set(file, chunk);
+						}
+						for (const file of chunk.auxiliaryFiles) {
+							fileToChunk.set(file, chunk);
+						}
+					}
 
-	get outputFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
-	}
+					/** @type {string[]} */
+					const files = [];
+					for (const file of Object.keys(assets)) {
+						if (matchObject(file)) {
+							files.push(file);
+						}
+					}
 
-	get watchFileSystem() {
-		throw new Error("Cannot read watchFileSystem of a MultiCompiler");
-	}
+					reportProgress(0.0);
+					/** @type {SourceMapTask[]} */
+					const tasks = [];
+					let fileIndex = 0;
 
-	get intermediateFileSystem() {
-		throw new Error("Cannot read outputFileSystem of a MultiCompiler");
-	}
+					asyncLib.each(
+						files,
+						(file, callback) => {
+							const asset = compilation.getAsset(file);
+							if (asset.info.related && asset.info.related.sourceMap) {
+								fileIndex++;
+								return callback();
+							}
+							const cacheItem = cache.getItemCache(
+								file,
+								cache.mergeEtags(
+									cache.getLazyHashedEtag(asset.source),
+									namespace
+								)
+							);
 
-	/**
-	 * @param {InputFileSystem} value the new input file system
-	 */
-	set inputFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.inputFileSystem = value;
-		}
-	}
+							cacheItem.get((err, cacheEntry) => {
+								if (err) {
+									return callback(err);
+								}
+								/**
+								 * If presented in cache, reassigns assets. Cache assets already have source maps.
+								 */
+								if (cacheEntry) {
+									const { assets, assetsInfo } = cacheEntry;
+									for (const cachedFile of Object.keys(assets)) {
+										if (cachedFile === file) {
+											compilation.updateAsset(
+												cachedFile,
+												assets[cachedFile],
+												assetsInfo[cachedFile]
+											);
+										} else {
+											compilation.emitAsset(
+												cachedFile,
+												assets[cachedFile],
+												assetsInfo[cachedFile]
+											);
+										}
+										/**
+										 * Add file to chunk, if not presented there
+										 */
+										if (cachedFile !== file) {
+											const chunk = fileToChunk.get(file);
+											if (chunk !== undefined)
+												chunk.auxiliaryFiles.add(cachedFile);
+										}
+									}
 
-	/**
-	 * @param {OutputFileSystem} value the new output file system
-	 */
-	set outputFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.outputFileSystem = value;
-		}
-	}
+									reportProgress(
+										(0.5 * ++fileIndex) / files.length,
+										file,
+										"restored cached SourceMap"
+									);
 
-	/**
-	 * @param {WatchFileSystem} value the new watch file system
-	 */
-	set watchFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.watchFileSystem = value;
-		}
-	}
+									return callback();
+								}
 
-	/**
-	 * @param {IntermediateFileSystem} value the new intermediate file system
-	 */
-	set intermediateFileSystem(value) {
-		for (const compiler of this.compilers) {
-			compiler.intermediateFileSystem = value;
-		}
-	}
+								reportProgress(
+									(0.5 * fileIndex) / files.length,
+									file,
+									"generate SourceMap"
+								);
 
-	getInfrastructureLogger(name) {
-		return this.compilers[0].getInfrastructureLogger(name);
-	}
+								/** @type {SourceMapTask | undefined} */
+								const task = getTaskForFile(
+									file,
+									asset.source,
+									asset.info,
+									{
+										module: options.module,
+										columns: options.columns
+									},
+									compilation,
+									cacheItem
+								);
 
-	/**
-	 * @param {Compiler} compiler the child compiler
-	 * @param {string[]} dependencies its dependencies
-	 * @returns {void}
-	 */
-	setDependencies(compiler, dependencies) {
-		this.dependencies.set(compiler, dependencies);
-	}
+								if (task) {
+									const modules = task.modules;
 
-	/**
-	 * @param {Callback<MultiStats>} callback signals when the validation is complete
-	 * @returns {boolean} true if the dependencies are valid
-	 */
-	validateDependencies(callback) {
-		/** @type {Set<{source: Compiler, target: Compiler}>} */
-		const edges = new Set();
-		/** @type {string[]} */
-		const missing = [];
-		const targetFound = compiler => {
-			for (const edge of edges) {
-				if (edge.target === compiler) {
-					return true;
-				}
-			}
-			return false;
-		};
-		const sortEdges = (e1, e2) => {
-			return (
-				e1.source.name.localeCompare(e2.source.name) ||
-				e1.target.name.localeCompare(e2.target.name)
-			);
-		};
-		for (const source of this.compilers) {
-			const dependencies = this.dependencies.get(source);
-			if (dependencies) {
-				for (const dep of dependencies) {
-					const target = this.compilers.find(c => c.name === dep);
-					if (!target) {
-						missing.push(dep);
-					} else {
-						edges.add({
-							source,
-							target
-						});
-					}
-				}
-			}
-		}
-		/** @type {string[]} */
-		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
-		const stack = this.compilers.filter(c => !targetFound(c));
-		while (stack.length > 0) {
-			const current = stack.pop();
-			for (const edge of edges) {
-				if (edge.source === current) {
-					edges.delete(edge);
-					const target = edge.target;
-					if (!targetFound(target)) {
-						stack.push(target);
-					}
-				}
-			}
-		}
-		if (edges.size > 0) {
-			/** @type {string[]} */
-			const lines = Array.from(edges)
-				.sort(sortEdges)
-				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
-			lines.unshift("Circular dependency found in compiler dependencies.");
-			errors.unshift(lines.join("\n"));
-		}
-		if (errors.length > 0) {
-			const message = errors.join("\n");
-			callback(new Error(message));
-			return false;
-		}
-		return true;
-	}
+									for (let idx = 0; idx < modules.length; idx++) {
+										const module = modules[idx];
+										if (!moduleToSourceNameMapping.get(module)) {
+											moduleToSourceNameMapping.set(
+												module,
+												ModuleFilenameHelpers.createFilename(
+													module,
+													{
+														moduleFilenameTemplate: moduleFilenameTemplate,
+														namespace: namespace
+													},
+													{
+														requestShortener,
+														chunkGraph,
+														hashFunction: compilation.outputOptions.hashFunction
+													}
+												)
+											);
+										}
+									}
 
-	// TODO webpack 6 remove
-	/**
-	 * @deprecated This method should have been private
-	 * @param {Compiler[]} compilers the child compilers
-	 * @param {RunWithDependenciesHandler} fn a handler to run for each compiler
-	 * @param {Callback<MultiStats>} callback the compiler's handler
-	 * @returns {void}
-	 */
-	runWithDependencies(compilers, fn, callback) {
-		const fulfilledNames = new Set();
-		let remainingCompilers = compilers;
-		const isDependencyFulfilled = d => fulfilledNames.has(d);
-		const getReadyCompilers = () => {
-			let readyCompilers = [];
-			let list = remainingCompilers;
-			remainingCompilers = [];
-			for (const c of list) {
-				const dependencies = this.dependencies.get(c);
-				const ready =
-					!dependencies || dependencies.every(isDependencyFulfilled);
-				if (ready) {
-					readyCompilers.push(c);
-				} else {
-					remainingCompilers.push(c);
-				}
-			}
-			return readyCompilers;
-		};
-		const runCompilers = callback => {
-			if (remainingCompilers.length === 0) return callback();
-			asyncLib.map(
-				getReadyCompilers(),
-				(compiler, callback) => {
-					fn(compiler, err => {
-						if (err) return callback(err);
-						fulfilledNames.add(compiler.name);
-						runCompilers(callback);
-					});
-				},
-				callback
-			);
-		};
-		runCompilers(callback);
-	}
+									tasks.push(task);
+								}
 
-	/**
-	 * @template SetupResult
-	 * @param {function(Compiler, number, Callback<Stats>, function(): boolean, function(): void, function(): void): SetupResult} setup setup a single compiler
-	 * @param {function(Compiler, SetupResult, Callback<Stats>): void} run run/continue a single compiler
-	 * @param {Callback<MultiStats>} callback callback when all compilers are done, result includes Stats of all changed compilers
-	 * @returns {SetupResult[]} result of setup
-	 */
-	_runGraph(setup, run, callback) {
-		/** @typedef {{ compiler: Compiler, setupResult: SetupResult, result: Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
+								reportProgress(
+									(0.5 * ++fileIndex) / files.length,
+									file,
+									"generated SourceMap"
+								);
 
-		// State transitions for nodes:
-		// -> blocked (initial)
-		// blocked -> starting [running++] (when all parents done)
-		// queued -> starting [running++] (when processing the queue)
-		// starting -> running (when run has been called)
-		// running -> done [running--] (when compilation is done)
-		// done -> pending (when invalidated from file change)
-		// pending -> blocked [add to queue] (when invalidated from aggregated changes)
-		// done -> blocked [add to queue] (when invalidated, from parent invalidation)
-		// running -> running-outdated (when invalidated, either from change or parent invalidation)
-		// running-outdated -> blocked [running--] (when compilation is done)
+								callback();
+							});
+						},
+						err => {
+							if (err) {
+								return callback(err);
+							}
 
-		/** @type {Node[]} */
-		const nodes = this.compilers.map(compiler => ({
-			compiler,
-			setupResult: undefined,
-			result: undefined,
-			state: "blocked",
-			children: [],
-			parents: []
-		}));
-		/** @type {Map<string, Node>} */
-		const compilerToNode = new Map();
-		for (const node of nodes) compilerToNode.set(node.compiler.name, node);
-		for (const node of nodes) {
-			const dependencies = this.dependencies.get(node.compiler);
-			if (!dependencies) continue;
-			for (const dep of dependencies) {
-				const parent = compilerToNode.get(dep);
-				node.parents.push(parent);
-				parent.children.push(node);
-			}
-		}
-		/** @type {ArrayQueue<Node>} */
-		const queue = new ArrayQueue();
-		for (const node of nodes) {
-			if (node.parents.length === 0) {
-				node.state = "queued";
-				queue.enqueue(node);
-			}
-		}
-		let errored = false;
-		let running = 0;
-		const parallelism = this._options.parallelism;
-		/**
-		 * @param {Node} node node
-		 * @param {Error=} err error
-		 * @param {Stats=} stats result
-		 * @returns {void}
-		 */
-		const nodeDone = (node, err, stats) => {
-			if (errored) return;
-			if (err) {
-				errored = true;
-				return asyncLib.each(
-					nodes,
-					(node, callback) => {
-						if (node.compiler.watching) {
-							node.compiler.watching.close(callback);
-						} else {
-							callback();
-						}
-					},
-					() => callback(err)
-				);
-			}
-			node.result = stats;
-			running--;
-			if (node.state === "running") {
-				node.state = "done";
-				for (const child of node.children) {
-					if (child.state === "blocked") queue.enqueue(child);
-				}
-			} else if (node.state === "running-outdated") {
-				node.state = "blocked";
-				queue.enqueue(node);
-			}
-			processQueue();
-		};
-		/**
-		 * @param {Node} node node
-		 * @returns {void}
-		 */
-		const nodeInvalidFromParent = node => {
-			if (node.state === "done") {
-				node.state = "blocked";
-			} else if (node.state === "running") {
-				node.state = "running-outdated";
-			}
-			for (const child of node.children) {
-				nodeInvalidFromParent(child);
-			}
-		};
-		/**
-		 * @param {Node} node node
-		 * @returns {void}
-		 */
-		const nodeInvalid = node => {
-			if (node.state === "done") {
-				node.state = "pending";
-			} else if (node.state === "running") {
-				node.state = "running-outdated";
-			}
-			for (const child of node.children) {
-				nodeInvalidFromParent(child);
-			}
-		};
-		/**
-		 * @param {Node} node node
-		 * @returns {void}
-		 */
-		const nodeChange = node => {
-			nodeInvalid(node);
-			if (node.state === "pending") {
-				node.state = "blocked";
-			}
-			if (node.state === "blocked") {
-				queue.enqueue(node);
-				processQueue();
-			}
-		};
+							reportProgress(0.5, "resolve sources");
+							/** @type {Set<string>} */
+							const usedNamesSet = new Set(moduleToSourceNameMapping.values());
+							/** @type {Set<string>} */
+							const conflictDetectionSet = new Set();
 
-		const setupResults = [];
-		nodes.forEach((node, i) => {
-			setupResults.push(
-				(node.setupResult = setup(
-					node.compiler,
-					i,
-					nodeDone.bind(null, node),
-					() => node.state !== "starting" && node.state !== "running",
-					() => nodeChange(node),
-					() => nodeInvalid(node)
-				))
-			);
-		});
-		let processing = true;
-		const processQueue = () => {
-			if (processing) return;
-			processing = true;
-			process.nextTick(processQueueWorker);
-		};
-		const processQueueWorker = () => {
-			while (running < parallelism && queue.length > 0 && !errored) {
-				const node = queue.dequeue();
-				if (
-					node.state === "queued" ||
-					(node.state === "blocked" &&
-						node.parents.every(p => p.state === "done"))
-				) {
-					running++;
-					node.state = "starting";
-					run(node.compiler, node.setupResult, nodeDone.bind(null, node));
-					node.state = "running";
-				}
-			}
-			processing = false;
-			if (
-				!errored &&
-				running === 0 &&
-				nodes.every(node => node.state === "done")
-			) {
-				const stats = [];
-				for (const node of nodes) {
-					const result = node.result;
-					if (result) {
-						node.result = undefined;
-						stats.push(result);
-					}
-				}
-				if (stats.length > 0) {
-					callback(null, new MultiStats(stats));
-				}
-			}
-		};
-		processQueueWorker();
-		return setupResults;
-	}
+							/**
+							 * all modules in defined order (longest identifier first)
+							 * @type {Array<string | Module>}
+							 */
+							const allModules = Array.from(
+								moduleToSourceNameMapping.keys()
+							).sort((a, b) => {
+								const ai = typeof a === "string" ? a : a.identifier();
+								const bi = typeof b === "string" ? b : b.identifier();
+								return ai.length - bi.length;
+							});
 
-	/**
-	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
-	 * @param {Callback<MultiStats>} handler signals when the call finishes
-	 * @returns {MultiWatching} a compiler watcher
-	 */
-	watch(watchOptions, handler) {
-		if (this.running) {
-			return handler(new ConcurrentCompilationError());
-		}
-		this.running = true;
+							// find modules with conflicting source names
+							for (let idx = 0; idx < allModules.length; idx++) {
+								const module = allModules[idx];
+								let sourceName = moduleToSourceNameMapping.get(module);
+								let hasName = conflictDetectionSet.has(sourceName);
+								if (!hasName) {
+									conflictDetectionSet.add(sourceName);
+									continue;
+								}
 
-		if (this.validateDependencies(handler)) {
-			const watchings = this._runGraph(
-				(compiler, idx, callback, isBlocked, setChanged, setInvalid) => {
-					const watching = compiler.watch(
-						Array.isArray(watchOptions) ? watchOptions[idx] : watchOptions,
-						callback
-					);
-					if (watching) {
-						watching._onInvalid = setInvalid;
-						watching._onChange = setChanged;
-						watching._isBlocked = isBlocked;
-					}
-					return watching;
-				},
-				(compiler, watching, callback) => {
-					if (compiler.watching !== watching) return;
-					if (!watching.running) watching.invalidate();
-				},
-				handler
-			);
-			return new MultiWatching(watchings, this);
-		}
+								// try the fallback name first
+								sourceName = ModuleFilenameHelpers.createFilename(
+									module,
+									{
+										moduleFilenameTemplate: fallbackModuleFilenameTemplate,
+										namespace: namespace
+									},
+									{
+										requestShortener,
+										chunkGraph,
+										hashFunction: compilation.outputOptions.hashFunction
+									}
+								);
+								hasName = usedNamesSet.has(sourceName);
+								if (!hasName) {
+									moduleToSourceNameMapping.set(module, sourceName);
+									usedNamesSet.add(sourceName);
+									continue;
+								}
 
-		return new MultiWatching([], this);
-	}
+								// otherwise just append stars until we have a valid name
+								while (hasName) {
+									sourceName += "*";
+									hasName = usedNamesSet.has(sourceName);
+								}
+								moduleToSourceNameMapping.set(module, sourceName);
+								usedNamesSet.add(sourceName);
+							}
 
-	/**
-	 * @param {Callback<MultiStats>} callback signals when the call finishes
-	 * @returns {void}
-	 */
-	run(callback) {
-		if (this.running) {
-			return callback(new ConcurrentCompilationError());
-		}
-		this.running = true;
+							let taskIndex = 0;
 
-		if (this.validateDependencies(callback)) {
-			this._runGraph(
-				() => {},
-				(compiler, setupResult, callback) => compiler.run(callback),
-				(err, stats) => {
-					this.running = false;
+							asyncLib.each(
+								tasks,
+								(task, callback) => {
+									const assets = Object.create(null);
+									const assetsInfo = Object.create(null);
+									const file = task.file;
+									const chunk = fileToChunk.get(file);
+									const sourceMap = task.sourceMap;
+									const source = task.source;
+									const modules = task.modules;
 
-					if (callback !== undefined) {
-						return callback(err, stats);
-					}
+									reportProgress(
+										0.5 + (0.5 * taskIndex) / tasks.length,
+										file,
+										"attach SourceMap"
+									);
+
+									const moduleFilenames = modules.map(m =>
+										moduleToSourceNameMapping.get(m)
+									);
+									sourceMap.sources = moduleFilenames;
+									if (options.noSources) {
+										sourceMap.sourcesContent = undefined;
+									}
+									sourceMap.sourceRoot = options.sourceRoot || "";
+									sourceMap.file = file;
+									const usesContentHash =
+										sourceMapFilename &&
+										/\[contenthash(:\w+)?\]/.test(sourceMapFilename);
+
+									// If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file`
+									if (usesContentHash && task.assetInfo.contenthash) {
+										const contenthash = task.assetInfo.contenthash;
+										let pattern;
+										if (Array.isArray(contenthash)) {
+											pattern = contenthash.map(quoteMeta).join("|");
+										} else {
+											pattern = quoteMeta(contenthash);
+										}
+										sourceMap.file = sourceMap.file.replace(
+											new RegExp(pattern, "g"),
+											m => "x".repeat(m.length)
+										);
+									}
+
+									/** @type {string | false} */
+									let currentSourceMappingURLComment = sourceMappingURLComment;
+									if (
+										currentSourceMappingURLComment !== false &&
+										/\.css($|\?)/i.test(file)
+									) {
+										currentSourceMappingURLComment =
+											currentSourceMappingURLComment.replace(
+												/^\n\/\/(.*)$/,
+												"\n/*$1*/"
+											);
+									}
+									const sourceMapString = JSON.stringify(sourceMap);
+									if (sourceMapFilename) {
+										let filename = file;
+										const sourceMapContentHash =
+											usesContentHash &&
+											/** @type {string} */ (
+												createHash(compilation.outputOptions.hashFunction)
+													.update(sourceMapString)
+													.digest("hex")
+											);
+										const pathParams = {
+											chunk,
+											filename: options.fileContext
+												? relative(
+														outputFs,
+														`/${options.fileContext}`,
+														`/${filename}`
+												  )
+												: filename,
+											contentHash: sourceMapContentHash
+										};
+										const { path: sourceMapFile, info: sourceMapInfo } =
+											compilation.getPathWithInfo(
+												sourceMapFilename,
+												pathParams
+											);
+										const sourceMapUrl = options.publicPath
+											? options.publicPath + sourceMapFile
+											: relative(
+													outputFs,
+													dirname(outputFs, `/${file}`),
+													`/${sourceMapFile}`
+											  );
+										/** @type {Source} */
+										let asset = new RawSource(source);
+										if (currentSourceMappingURLComment !== false) {
+											// Add source map url to compilation asset, if currentSourceMappingURLComment is set
+											asset = new ConcatSource(
+												asset,
+												compilation.getPath(
+													currentSourceMappingURLComment,
+													Object.assign({ url: sourceMapUrl }, pathParams)
+												)
+											);
+										}
+										const assetInfo = {
+											related: { sourceMap: sourceMapFile }
+										};
+										assets[file] = asset;
+										assetsInfo[file] = assetInfo;
+										compilation.updateAsset(file, asset, assetInfo);
+										// Add source map file to compilation assets and chunk files
+										const sourceMapAsset = new RawSource(sourceMapString);
+										const sourceMapAssetInfo = {
+											...sourceMapInfo,
+											development: true
+										};
+										assets[sourceMapFile] = sourceMapAsset;
+										assetsInfo[sourceMapFile] = sourceMapAssetInfo;
+										compilation.emitAsset(
+											sourceMapFile,
+											sourceMapAsset,
+											sourceMapAssetInfo
+										);
+										if (chunk !== undefined)
+											chunk.auxiliaryFiles.add(sourceMapFile);
+									} else {
+										if (currentSourceMappingURLComment === false) {
+											throw new Error(
+												"SourceMapDevToolPlugin: append can't be false when no filename is provided"
+											);
+										}
+										/**
+										 * Add source map as data url to asset
+										 */
+										const asset = new ConcatSource(
+											new RawSource(source),
+											currentSourceMappingURLComment
+												.replace(/\[map\]/g, () => sourceMapString)
+												.replace(
+													/\[url\]/g,
+													() =>
+														`data:application/json;charset=utf-8;base64,${Buffer.from(
+															sourceMapString,
+															"utf-8"
+														).toString("base64")}`
+												)
+										);
+										assets[file] = asset;
+										assetsInfo[file] = undefined;
+										compilation.updateAsset(file, asset);
+									}
+
+									task.cacheItem.store({ assets, assetsInfo }, err => {
+										reportProgress(
+											0.5 + (0.5 * ++taskIndex) / tasks.length,
+											task.file,
+											"attached SourceMap"
+										);
+
+										if (err) {
+											return callback(err);
+										}
+										callback();
+									});
+								},
+								err => {
+									reportProgress(1.0);
+									callback(err);
+								}
+							);
+						}
+					);
 				}
 			);
-		}
-	}
-
-	purgeInputFileSystem() {
-		for (const compiler of this.compilers) {
-			if (compiler.inputFileSystem && compiler.inputFileSystem.purge) {
-				compiler.inputFileSystem.purge();
-			}
-		}
+		});
 	}
+}
 
-	/**
-	 * @param {Callback<void>} callback signals when the compiler closes
-	 * @returns {void}
-	 */
-	close(callback) {
-		asyncLib.each(
-			this.compilers,
-			(compiler, callback) => {
-				compiler.close(callback);
-			},
-			callback
-		);
-	}
-};
+module.exports = SourceMapDevToolPlugin;
 
 
 /***/ }),
 
-/***/ 24170:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 31743:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -55107,170 +55444,88 @@ module.exports = class MultiCompiler {
 
 
 
-const identifierUtils = __webpack_require__(82186);
-
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("./Stats")} Stats */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */
+/** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
 
-const indent = (str, prefix) => {
-	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
-	return prefix + rem;
-};
-
-class MultiStats {
+class Stats {
 	/**
-	 * @param {Stats[]} stats the child stats
+	 * @param {Compilation} compilation webpack compilation
 	 */
-	constructor(stats) {
-		this.stats = stats;
+	constructor(compilation) {
+		this.compilation = compilation;
 	}
 
 	get hash() {
-		return this.stats.map(stat => stat.hash).join("");
+		return this.compilation.hash;
+	}
+
+	get startTime() {
+		return this.compilation.startTime;
+	}
+
+	get endTime() {
+		return this.compilation.endTime;
 	}
 
 	/**
-	 * @returns {boolean} true if a child compilation encountered an error
+	 * @returns {boolean} true if the compilation had a warning
+	 */
+	hasWarnings() {
+		return (
+			this.compilation.warnings.length > 0 ||
+			this.compilation.children.some(child => child.getStats().hasWarnings())
+		);
+	}
+
+	/**
+	 * @returns {boolean} true if the compilation encountered an error
 	 */
 	hasErrors() {
-		return this.stats.some(stat => stat.hasErrors());
+		return (
+			this.compilation.errors.length > 0 ||
+			this.compilation.children.some(child => child.getStats().hasErrors())
+		);
 	}
 
 	/**
-	 * @returns {boolean} true if a child compilation had a warning
+	 * @param {(string|StatsOptions)=} options stats options
+	 * @returns {StatsCompilation} json output
 	 */
-	hasWarnings() {
-		return this.stats.some(stat => stat.hasWarnings());
+	toJson(options) {
+		options = this.compilation.createStatsOptions(options, {
+			forToString: false
+		});
+
+		const statsFactory = this.compilation.createStatsFactory(options);
+
+		return statsFactory.create("compilation", this.compilation, {
+			compilation: this.compilation
+		});
 	}
 
-	_createChildOptions(options, context) {
-		if (!options) {
-			options = {};
-		}
-		const { children: childrenOptions = undefined, ...baseOptions } =
-			typeof options === "string" ? { preset: options } : options;
-		const children = this.stats.map((stat, idx) => {
-			const childOptions = Array.isArray(childrenOptions)
-				? childrenOptions[idx]
-				: childrenOptions;
-			return stat.compilation.createStatsOptions(
-				{
-					...baseOptions,
-					...(typeof childOptions === "string"
-						? { preset: childOptions }
-						: childOptions && typeof childOptions === "object"
-						? childOptions
-						: undefined)
-				},
-				context
-			);
+	toString(options) {
+		options = this.compilation.createStatsOptions(options, {
+			forToString: true
 		});
-		return {
-			version: children.every(o => o.version),
-			hash: children.every(o => o.hash),
-			errorsCount: children.every(o => o.errorsCount),
-			warningsCount: children.every(o => o.warningsCount),
-			errors: children.every(o => o.errors),
-			warnings: children.every(o => o.warnings),
-			children
-		};
-	}
 
-	/**
-	 * @param {any} options stats options
-	 * @returns {StatsCompilation} json output
-	 */
-	toJson(options) {
-		options = this._createChildOptions(options, { forToString: false });
-		/** @type {KnownStatsCompilation} */
-		const obj = {};
-		obj.children = this.stats.map((stat, idx) => {
-			const obj = stat.toJson(options.children[idx]);
-			const compilationName = stat.compilation.name;
-			const name =
-				compilationName &&
-				identifierUtils.makePathsRelative(
-					options.context,
-					compilationName,
-					stat.compilation.compiler.root
-				);
-			obj.name = name;
-			return obj;
-		});
-		if (options.version) {
-			obj.version = obj.children[0].version;
-		}
-		if (options.hash) {
-			obj.hash = obj.children.map(j => j.hash).join("");
-		}
-		const mapError = (j, obj) => {
-			return {
-				...obj,
-				compilerPath: obj.compilerPath
-					? `${j.name}.${obj.compilerPath}`
-					: j.name
-			};
-		};
-		if (options.errors) {
-			obj.errors = [];
-			for (const j of obj.children) {
-				for (const i of j.errors) {
-					obj.errors.push(mapError(j, i));
-				}
-			}
-		}
-		if (options.warnings) {
-			obj.warnings = [];
-			for (const j of obj.children) {
-				for (const i of j.warnings) {
-					obj.warnings.push(mapError(j, i));
-				}
-			}
-		}
-		if (options.errorsCount) {
-			obj.errorsCount = 0;
-			for (const j of obj.children) {
-				obj.errorsCount += j.errorsCount;
-			}
-		}
-		if (options.warningsCount) {
-			obj.warningsCount = 0;
-			for (const j of obj.children) {
-				obj.warningsCount += j.warningsCount;
-			}
-		}
-		return obj;
-	}
+		const statsFactory = this.compilation.createStatsFactory(options);
+		const statsPrinter = this.compilation.createStatsPrinter(options);
 
-	toString(options) {
-		options = this._createChildOptions(options, { forToString: true });
-		const results = this.stats.map((stat, idx) => {
-			const str = stat.toString(options.children[idx]);
-			const compilationName = stat.compilation.name;
-			const name =
-				compilationName &&
-				identifierUtils
-					.makePathsRelative(
-						options.context,
-						compilationName,
-						stat.compilation.compiler.root
-					)
-					.replace(/\|/g, " ");
-			if (!str) return str;
-			return name ? `${name}:\n${indent(str, "  ")}` : str;
+		const data = statsFactory.create("compilation", this.compilation, {
+			compilation: this.compilation
 		});
-		return results.filter(Boolean).join("\n\n");
+		const result = statsPrinter.print("compilation", data);
+		return result === undefined ? "" : result;
 	}
 }
 
-module.exports = MultiStats;
+module.exports = Stats;
 
 
 /***/ }),
 
-/***/ 81128:
+/***/ 1626:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -55281,3006 +55536,2545 @@ module.exports = MultiStats;
 
 
 
-const asyncLib = __webpack_require__(78175);
+const { ConcatSource, PrefixSource } = __webpack_require__(51255);
 
-/** @typedef {import("./MultiCompiler")} MultiCompiler */
-/** @typedef {import("./Watching")} Watching */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+
+const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);
+const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0);
+const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1;
+const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $
+const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
+	NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9
+const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g;
+const INDENT_MULTILINE_REGEX = /^\t/gm;
+const LINE_SEPARATOR_REGEX = /\r?\n/g;
+const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/;
+const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g;
+const COMMENT_END_REGEX = /\*\//g;
+const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
+const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
 
 /**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
+ * @typedef {Object} RenderManifestOptions
+ * @property {Chunk} chunk the chunk used to render
+ * @property {string} hash
+ * @property {string} fullHash
+ * @property {OutputOptions} outputOptions
+ * @property {CodeGenerationResults} codeGenerationResults
+ * @property {{javascript: ModuleTemplate}} moduleTemplates
+ * @property {DependencyTemplates} dependencyTemplates
+ * @property {RuntimeTemplate} runtimeTemplate
+ * @property {ModuleGraph} moduleGraph
+ * @property {ChunkGraph} chunkGraph
  */
 
-class MultiWatching {
+/** @typedef {RenderManifestEntryTemplated | RenderManifestEntryStatic} RenderManifestEntry */
+
+/**
+ * @typedef {Object} RenderManifestEntryTemplated
+ * @property {function(): Source} render
+ * @property {string | function(PathData, AssetInfo=): string} filenameTemplate
+ * @property {PathData=} pathOptions
+ * @property {AssetInfo=} info
+ * @property {string} identifier
+ * @property {string=} hash
+ * @property {boolean=} auxiliary
+ */
+
+/**
+ * @typedef {Object} RenderManifestEntryStatic
+ * @property {function(): Source} render
+ * @property {string} filename
+ * @property {AssetInfo} info
+ * @property {string} identifier
+ * @property {string=} hash
+ * @property {boolean=} auxiliary
+ */
+
+/**
+ * @typedef {Object} HasId
+ * @property {number | string} id
+ */
+
+/**
+ * @typedef {function(Module, number): boolean} ModuleFilterPredicate
+ */
+
+class Template {
 	/**
-	 * @param {Watching[]} watchings child compilers' watchers
-	 * @param {MultiCompiler} compiler the compiler
+	 *
+	 * @param {Function} fn a runtime function (.runtime.js) "template"
+	 * @returns {string} the updated and normalized function string
 	 */
-	constructor(watchings, compiler) {
-		this.watchings = watchings;
-		this.compiler = compiler;
-	}
-
-	invalidate(callback) {
-		if (callback) {
-			asyncLib.each(
-				this.watchings,
-				(watching, callback) => watching.invalidate(callback),
-				callback
-			);
-		} else {
-			for (const watching of this.watchings) {
-				watching.invalidate();
-			}
-		}
+	static getFunctionContent(fn) {
+		return fn
+			.toString()
+			.replace(FUNCTION_CONTENT_REGEX, "")
+			.replace(INDENT_MULTILINE_REGEX, "")
+			.replace(LINE_SEPARATOR_REGEX, "\n");
 	}
 
-	suspend() {
-		for (const watching of this.watchings) {
-			watching.suspend();
-		}
+	/**
+	 * @param {string} str the string converted to identifier
+	 * @returns {string} created identifier
+	 */
+	static toIdentifier(str) {
+		if (typeof str !== "string") return "";
+		return str
+			.replace(IDENTIFIER_NAME_REPLACE_REGEX, "_$1")
+			.replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, "_");
 	}
-
-	resume() {
-		for (const watching of this.watchings) {
-			watching.resume();
-		}
+	/**
+	 *
+	 * @param {string} str string to be converted to commented in bundle code
+	 * @returns {string} returns a commented version of string
+	 */
+	static toComment(str) {
+		if (!str) return "";
+		return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`;
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the watcher is closed
-	 * @returns {void}
+	 *
+	 * @param {string} str string to be converted to "normal comment"
+	 * @returns {string} returns a commented version of string
 	 */
-	close(callback) {
-		asyncLib.forEach(
-			this.watchings,
-			(watching, finishedCallback) => {
-				watching.close(finishedCallback);
-			},
-			err => {
-				this.compiler.hooks.watchClose.call();
-				if (typeof callback === "function") {
-					this.compiler.running = false;
-					callback(err);
-				}
-			}
-		);
+	static toNormalComment(str) {
+		if (!str) return "";
+		return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`;
 	}
-}
-
-module.exports = MultiWatching;
-
-
-/***/ }),
-
-/***/ 50169:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./Compiler")} Compiler */
 
-class NoEmitOnErrorsPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string} str string path to be normalized
+	 * @returns {string} normalized bundle-safe path
 	 */
-	apply(compiler) {
-		compiler.hooks.shouldEmit.tap("NoEmitOnErrorsPlugin", compilation => {
-			if (compilation.getStats().hasErrors()) return false;
-		});
-		compiler.hooks.compilation.tap("NoEmitOnErrorsPlugin", compilation => {
-			compilation.hooks.shouldRecord.tap("NoEmitOnErrorsPlugin", () => {
-				if (compilation.getStats().hasErrors()) return false;
-			});
-		});
+	static toPath(str) {
+		if (typeof str !== "string") return "";
+		return str
+			.replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, "-")
+			.replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, "");
 	}
-}
-
-module.exports = NoEmitOnErrorsPlugin;
-
-
-/***/ }),
-
-/***/ 80832:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	// map number to a single character a-z, A-Z or multiple characters if number is too big
+	/**
+	 * @param {number} n number to convert to ident
+	 * @returns {string} returns single character ident
+	 */
+	static numberToIdentifier(n) {
+		if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
+			// use multiple letters
+			return (
+				Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) +
+				Template.numberToIdentifierContinuation(
+					Math.floor(n / NUMBER_OF_IDENTIFIER_START_CHARS)
+				)
+			);
+		}
 
-const WebpackError = __webpack_require__(53799);
+		// lower case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+		}
+		n -= DELTA_A_TO_Z;
 
-module.exports = class NoModeWarning extends WebpackError {
-	constructor() {
-		super();
+		// upper case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+		}
 
-		this.name = "NoModeWarning";
-		this.message =
-			"configuration\n" +
-			"The 'mode' option has not been set, webpack will fallback to 'production' for this value.\n" +
-			"Set 'mode' option to 'development' or 'production' to enable defaults for each environment.\n" +
-			"You can also set it to 'none' to disable any default behavior. " +
-			"Learn more: https://webpack.js.org/configuration/mode/";
+		if (n === DELTA_A_TO_Z) return "_";
+		return "$";
 	}
-};
-
-
-/***/ }),
-
-/***/ 6325:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+	/**
+	 * @param {number} n number to convert to ident
+	 * @returns {string} returns single character ident
+	 */
+	static numberToIdentifierContinuation(n) {
+		if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
+			// use multiple letters
+			return (
+				Template.numberToIdentifierContinuation(
+					n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+				) +
+				Template.numberToIdentifierContinuation(
+					Math.floor(n / NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS)
+				)
+			);
+		}
 
+		// lower case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+		}
+		n -= DELTA_A_TO_Z;
 
+		// upper case
+		if (n < DELTA_A_TO_Z) {
+			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+		}
+		n -= DELTA_A_TO_Z;
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+		// numbers
+		if (n < 10) {
+			return `${n}`;
+		}
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+		if (n === 10) return "_";
+		return "$";
+	}
 
-class NodeStuffInWebError extends WebpackError {
 	/**
-	 * @param {DependencyLocation} loc loc
-	 * @param {string} expression expression
-	 * @param {string} description description
+	 *
+	 * @param {string | string[]} s string to convert to identity
+	 * @returns {string} converted identity
 	 */
-	constructor(loc, expression, description) {
-		super(
-			`${JSON.stringify(
-				expression
-			)} has been used, it will be undefined in next major version.
-${description}`
-		);
-
-		this.name = "NodeStuffInWebError";
-		this.loc = loc;
+	static indent(s) {
+		if (Array.isArray(s)) {
+			return s.map(Template.indent).join("\n");
+		} else {
+			const str = s.trimRight();
+			if (!str) return "";
+			const ind = str[0] === "\n" ? "" : "\t";
+			return ind + str.replace(/\n([^\n])/g, "\n\t$1");
+		}
 	}
-}
-
-makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
-
-module.exports = NodeStuffInWebError;
-
-
-/***/ }),
-
-/***/ 95287:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const NodeStuffInWebError = __webpack_require__(6325);
-const RuntimeGlobals = __webpack_require__(16475);
-const CachedConstDependency = __webpack_require__(57403);
-const ConstDependency = __webpack_require__(76911);
-const {
-	evaluateToString,
-	expressionIsUnsupported
-} = __webpack_require__(93998);
-const { relative } = __webpack_require__(17139);
-const { parseResource } = __webpack_require__(82186);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+	/**
+	 *
+	 * @param {string|string[]} s string to create prefix for
+	 * @param {string} prefix prefix to compose
+	 * @returns {string} returns new prefix string
+	 */
+	static prefix(s, prefix) {
+		const str = Template.asString(s).trim();
+		if (!str) return "";
+		const ind = str[0] === "\n" ? "" : prefix;
+		return ind + str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	}
 
-class NodeStuffPlugin {
-	constructor(options) {
-		this.options = options;
+	/**
+	 *
+	 * @param {string|string[]} str string or string collection
+	 * @returns {string} returns a single string from array
+	 */
+	static asString(str) {
+		if (Array.isArray(str)) {
+			return str.join("\n");
+		}
+		return str;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @typedef {Object} WithId
+	 * @property {string|number} id
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap(
-			"NodeStuffPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.node === false) return;
-
-					let localOptions = options;
-					if (parserOptions.node) {
-						localOptions = { ...localOptions, ...parserOptions.node };
-					}
-
-					if (localOptions.global !== false) {
-						const withWarning = localOptions.global === "warn";
-						parser.hooks.expression
-							.for("global")
-							.tap("NodeStuffPlugin", expr => {
-								const dep = new ConstDependency(
-									RuntimeGlobals.global,
-									expr.range,
-									[RuntimeGlobals.global]
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-
-								// TODO webpack 6 remove
-								if (withWarning) {
-									parser.state.module.addWarning(
-										new NodeStuffInWebError(
-											dep.loc,
-											"global",
-											"The global namespace object is Node.js feature and doesn't present in browser."
-										)
-									);
-								}
-							});
-					}
-
-					const setModuleConstant = (expressionName, fn, warning) => {
-						parser.hooks.expression
-							.for(expressionName)
-							.tap("NodeStuffPlugin", expr => {
-								const dep = new CachedConstDependency(
-									JSON.stringify(fn(parser.state.module)),
-									expr.range,
-									expressionName
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-
-								// TODO webpack 6 remove
-								if (warning) {
-									parser.state.module.addWarning(
-										new NodeStuffInWebError(dep.loc, expressionName, warning)
-									);
-								}
-
-								return true;
-							});
-					};
-
-					const setConstant = (expressionName, value, warning) =>
-						setModuleConstant(expressionName, () => value, warning);
-
-					const context = compiler.context;
-					if (localOptions.__filename) {
-						switch (localOptions.__filename) {
-							case "mock":
-								setConstant("__filename", "/index.js");
-								break;
-							case "warn-mock":
-								setConstant(
-									"__filename",
-									"/index.js",
-									"The __filename is Node.js feature and doesn't present in browser."
-								);
-								break;
-							case true:
-								setModuleConstant("__filename", module =>
-									relative(compiler.inputFileSystem, context, module.resource)
-								);
-								break;
-						}
 
-						parser.hooks.evaluateIdentifier
-							.for("__filename")
-							.tap("NodeStuffPlugin", expr => {
-								if (!parser.state.module) return;
-								const resource = parseResource(parser.state.module.resource);
-								return evaluateToString(resource.path)(expr);
-							});
-					}
-					if (localOptions.__dirname) {
-						switch (localOptions.__dirname) {
-							case "mock":
-								setConstant("__dirname", "/");
-								break;
-							case "warn-mock":
-								setConstant(
-									"__dirname",
-									"/",
-									"The __dirname is Node.js feature and doesn't present in browser."
-								);
-								break;
-							case true:
-								setModuleConstant("__dirname", module =>
-									relative(compiler.inputFileSystem, context, module.context)
-								);
-								break;
-						}
+	/**
+	 * @param {WithId[]} modules a collection of modules to get array bounds for
+	 * @returns {[number, number] | false} returns the upper and lower array bounds
+	 * or false if not every module has a number based id
+	 */
+	static getModulesArrayBounds(modules) {
+		let maxId = -Infinity;
+		let minId = Infinity;
+		for (const module of modules) {
+			const moduleId = module.id;
+			if (typeof moduleId !== "number") return false;
+			if (maxId < moduleId) maxId = moduleId;
+			if (minId > moduleId) minId = moduleId;
+		}
+		if (minId < 16 + ("" + minId).length) {
+			// add minId x ',' instead of 'Array(minId).concat(…)'
+			minId = 0;
+		}
+		// start with -1 because the first module needs no comma
+		let objectOverhead = -1;
+		for (const module of modules) {
+			// module id + colon + comma
+			objectOverhead += `${module.id}`.length + 2;
+		}
+		// number of commas, or when starting non-zero the length of Array(minId).concat()
+		const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId;
+		return arrayOverhead < objectOverhead ? [minId, maxId] : false;
+	}
 
-						parser.hooks.evaluateIdentifier
-							.for("__dirname")
-							.tap("NodeStuffPlugin", expr => {
-								if (!parser.state.module) return;
-								return evaluateToString(parser.state.module.context)(expr);
-							});
-					}
-					parser.hooks.expression
-						.for("require.extensions")
-						.tap(
-							"NodeStuffPlugin",
-							expressionIsUnsupported(
-								parser,
-								"require.extensions is not supported by webpack. Use a loader instead."
-							)
-						);
-				};
+	/**
+	 * @param {ChunkRenderContext} renderContext render context
+	 * @param {Module[]} modules modules to render (should be ordered by identifier)
+	 * @param {function(Module): Source} renderModule function to render a module
+	 * @param {string=} prefix applying prefix strings
+	 * @returns {Source} rendered chunk modules in a Source object
+	 */
+	static renderChunkModules(renderContext, modules, renderModule, prefix = "") {
+		const { chunkGraph } = renderContext;
+		var source = new ConcatSource();
+		if (modules.length === 0) {
+			return null;
+		}
+		/** @type {{id: string|number, source: Source|string}[]} */
+		const allModules = modules.map(module => {
+			return {
+				id: chunkGraph.getModuleId(module),
+				source: renderModule(module) || "false"
+			};
+		});
+		const bounds = Template.getModulesArrayBounds(allModules);
+		if (bounds) {
+			// Render a spare array
+			const minId = bounds[0];
+			const maxId = bounds[1];
+			if (minId !== 0) {
+				source.add(`Array(${minId}).concat(`);
+			}
+			source.add("[\n");
+			/** @type {Map<string|number, {id: string|number, source: Source|string}>} */
+			const modules = new Map();
+			for (const module of allModules) {
+				modules.set(module.id, module);
+			}
+			for (let idx = minId; idx <= maxId; idx++) {
+				const module = modules.get(idx);
+				if (idx !== minId) {
+					source.add(",\n");
+				}
+				source.add(`/* ${idx} */`);
+				if (module) {
+					source.add("\n");
+					source.add(module.source);
+				}
+			}
+			source.add("\n" + prefix + "]");
+			if (minId !== 0) {
+				source.add(")");
+			}
+		} else {
+			// Render an object
+			source.add("{\n");
+			for (let i = 0; i < allModules.length; i++) {
+				const module = allModules[i];
+				if (i !== 0) {
+					source.add(",\n");
+				}
+				source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
+				source.add(module.source);
+			}
+			source.add(`\n\n${prefix}}`);
+		}
+		return source;
+	}
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("NodeStuffPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("NodeStuffPlugin", handler);
+	/**
+	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
+	 * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
+	 * @returns {Source} rendered runtime modules in a Source object
+	 */
+	static renderRuntimeModules(runtimeModules, renderContext) {
+		const source = new ConcatSource();
+		for (const module of runtimeModules) {
+			const codeGenerationResults = renderContext.codeGenerationResults;
+			let runtimeSource;
+			if (codeGenerationResults) {
+				runtimeSource = codeGenerationResults.getSource(
+					module,
+					renderContext.chunk.runtime,
+					"runtime"
+				);
+			} else {
+				const codeGenResult = module.codeGeneration({
+					chunkGraph: renderContext.chunkGraph,
+					dependencyTemplates: renderContext.dependencyTemplates,
+					moduleGraph: renderContext.moduleGraph,
+					runtimeTemplate: renderContext.runtimeTemplate,
+					runtime: renderContext.chunk.runtime,
+					codeGenerationResults
+				});
+				if (!codeGenResult) continue;
+				runtimeSource = codeGenResult.sources.get("runtime");
+			}
+			if (runtimeSource) {
+				source.add(Template.toNormalComment(module.identifier()) + "\n");
+				if (!module.shouldIsolate()) {
+					source.add(runtimeSource);
+					source.add("\n\n");
+				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
+					source.add("(() => {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n})();\n\n");
+				} else {
+					source.add("!function() {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n}();\n\n");
+				}
 			}
+		}
+		return source;
+	}
+
+	/**
+	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
+	 * @param {RenderContext} renderContext render context
+	 * @returns {Source} rendered chunk runtime modules in a Source object
+	 */
+	static renderChunkRuntimeModules(runtimeModules, renderContext) {
+		return new PrefixSource(
+			"/******/ ",
+			new ConcatSource(
+				"function(__webpack_require__) { // webpackRuntimeModules\n",
+				this.renderRuntimeModules(runtimeModules, renderContext),
+				"}\n"
+			)
 		);
 	}
 }
 
-module.exports = NodeStuffPlugin;
+module.exports = Template;
+module.exports.NUMBER_OF_IDENTIFIER_START_CHARS =
+	NUMBER_OF_IDENTIFIER_START_CHARS;
+module.exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
+	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS;
 
 
 /***/ }),
 
-/***/ 39:
+/***/ 80734:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Jason Anderson @diurnalist
 */
 
 
 
-const parseJson = __webpack_require__(15235);
-const { getContext, runLoaders } = __webpack_require__(68318);
-const querystring = __webpack_require__(63477);
-const { HookMap, SyncHook, AsyncSeriesBailHook } = __webpack_require__(41242);
-const {
-	CachedSource,
-	OriginalSource,
-	RawSource,
-	SourceMapSource
-} = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const HookWebpackError = __webpack_require__(11351);
+const { basename, extname } = __webpack_require__(71017);
+const util = __webpack_require__(73837);
+const Chunk = __webpack_require__(39385);
 const Module = __webpack_require__(73208);
-const ModuleBuildError = __webpack_require__(21305);
-const ModuleError = __webpack_require__(23744);
-const ModuleGraphConnection = __webpack_require__(40639);
-const ModuleParseError = __webpack_require__(58443);
-const ModuleWarning = __webpack_require__(11234);
-const RuntimeGlobals = __webpack_require__(16475);
-const UnhandledSchemeError = __webpack_require__(68099);
-const WebpackError = __webpack_require__(53799);
-const formatLocation = __webpack_require__(16734);
-const LazySet = __webpack_require__(38938);
-const { isSubset } = __webpack_require__(93347);
-const { getScheme } = __webpack_require__(54500);
-const {
-	compareLocations,
-	concatComparators,
-	compareSelect,
-	keepOriginalOrder
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const { createFakeHook } = __webpack_require__(64518);
-const { join } = __webpack_require__(17139);
-const {
-	contextify,
-	absolutify,
-	makePathsRelative
-} = __webpack_require__(82186);
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
+const { parseResource } = __webpack_require__(82186);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
-/** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Generator")} Generator */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./Parser")} Parser */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./logging/Logger").Logger} WebpackLogger */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @typedef {Object} SourceMap
- * @property {number} version
- * @property {string[]} sources
- * @property {string} mappings
- * @property {string=} file
- * @property {string=} sourceRoot
- * @property {string[]=} sourcesContent
- * @property {string[]=} names
- */
+const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
 
-const getInvalidDependenciesModuleWarning = memoize(() =>
-	__webpack_require__(68257)
-);
-const getValidate = memoize(() => (__webpack_require__(38476).validate));
+const prepareId = id => {
+	if (typeof id !== "string") return id;
 
-const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
+	if (/^"\s\+*.*\+\s*"$/.test(id)) {
+		const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
 
-/**
- * @typedef {Object} LoaderItem
- * @property {string} loader
- * @property {any} options
- * @property {string?} ident
- * @property {string?} type
- */
+		return `" + (${match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
+	}
 
-/**
- * @param {string} context absolute context path
- * @param {string} source a source path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} new source path
- */
-const contextifySourceUrl = (context, source, associatedObjectForCache) => {
-	if (source.startsWith("webpack://")) return source;
-	return `webpack://${makePathsRelative(
-		context,
-		source,
-		associatedObjectForCache
-	)}`;
+	return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
 };
 
-/**
- * @param {string} context absolute context path
- * @param {SourceMap} sourceMap a source map
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {SourceMap} new source map
- */
-const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
-	if (!Array.isArray(sourceMap.sources)) return sourceMap;
-	const { sourceRoot } = sourceMap;
-	/** @type {function(string): string} */
-	const mapper = !sourceRoot
-		? source => source
-		: sourceRoot.endsWith("/")
-		? source =>
-				source.startsWith("/")
-					? `${sourceRoot.slice(0, -1)}${source}`
-					: `${sourceRoot}${source}`
-		: source =>
-				source.startsWith("/")
-					? `${sourceRoot}${source}`
-					: `${sourceRoot}/${source}`;
-	const newSources = sourceMap.sources.map(source =>
-		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
-	);
-	return {
-		...sourceMap,
-		file: "x",
-		sourceRoot: undefined,
-		sources: newSources
+const hashLength = (replacer, handler, assetInfo, hashName) => {
+	const fn = (match, arg, input) => {
+		let result;
+		const length = arg && parseInt(arg, 10);
+
+		if (length && handler) {
+			result = handler(length);
+		} else {
+			const hash = replacer(match, arg, input);
+
+			result = length ? hash.slice(0, length) : hash;
+		}
+		if (assetInfo) {
+			assetInfo.immutable = true;
+			if (Array.isArray(assetInfo[hashName])) {
+				assetInfo[hashName] = [...assetInfo[hashName], result];
+			} else if (assetInfo[hashName]) {
+				assetInfo[hashName] = [assetInfo[hashName], result];
+			} else {
+				assetInfo[hashName] = result;
+			}
+		}
+		return result;
 	};
+
+	return fn;
 };
 
-/**
- * @param {string | Buffer} input the input
- * @returns {string} the converted string
- */
-const asString = input => {
-	if (Buffer.isBuffer(input)) {
-		return input.toString("utf-8");
+const replacer = (value, allowEmpty) => {
+	const fn = (match, arg, input) => {
+		if (typeof value === "function") {
+			value = value();
+		}
+		if (value === null || value === undefined) {
+			if (!allowEmpty) {
+				throw new Error(
+					`Path variable ${match} not implemented in this context: ${input}`
+				);
+			}
+
+			return "";
+		} else {
+			return `${value}`;
+		}
+	};
+
+	return fn;
+};
+
+const deprecationCache = new Map();
+const deprecatedFunction = (() => () => {})();
+const deprecated = (fn, message, code) => {
+	let d = deprecationCache.get(message);
+	if (d === undefined) {
+		d = util.deprecate(deprecatedFunction, message, code);
+		deprecationCache.set(message, d);
 	}
-	return input;
+	return (...args) => {
+		d();
+		return fn(...args);
+	};
 };
 
 /**
- * @param {string | Buffer} input the input
- * @returns {Buffer} the converted buffer
+ * @param {string | function(PathData, AssetInfo=): string} path the raw path
+ * @param {PathData} data context data
+ * @param {AssetInfo} assetInfo extra info about the asset (will be written to)
+ * @returns {string} the interpolated path
  */
-const asBuffer = input => {
-	if (!Buffer.isBuffer(input)) {
-		return Buffer.from(input, "utf-8");
-	}
-	return input;
-};
+const replacePathVariables = (path, data, assetInfo) => {
+	const chunkGraph = data.chunkGraph;
 
-class NonErrorEmittedError extends WebpackError {
-	constructor(error) {
-		super();
+	/** @type {Map<string, Function>} */
+	const replacements = new Map();
 
-		this.name = "NonErrorEmittedError";
-		this.message = "(Emitted value instead of an instance of Error) " + error;
-	}
-}
+	// Filename context
+	//
+	// Placeholders
+	//
+	// for /some/path/file.js?query#fragment:
+	// [file] - /some/path/file.js
+	// [query] - ?query
+	// [fragment] - #fragment
+	// [base] - file.js
+	// [path] - /some/path/
+	// [name] - file
+	// [ext] - .js
+	if (typeof data.filename === "string") {
+		const { path: file, query, fragment } = parseResource(data.filename);
 
-makeSerializable(
-	NonErrorEmittedError,
-	"webpack/lib/NormalModule",
-	"NonErrorEmittedError"
-);
+		const ext = extname(file);
+		const base = basename(file);
+		const name = base.slice(0, base.length - ext.length);
+		const path = file.slice(0, file.length - base.length);
 
-/**
- * @typedef {Object} NormalModuleCompilationHooks
- * @property {SyncHook<[object, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
- * @property {SyncHook<[NormalModule]>} beforeParse
- * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
- * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
- */
+		replacements.set("file", replacer(file));
+		replacements.set("query", replacer(query, true));
+		replacements.set("fragment", replacer(fragment, true));
+		replacements.set("path", replacer(path, true));
+		replacements.set("base", replacer(base));
+		replacements.set("name", replacer(name));
+		replacements.set("ext", replacer(ext, true));
+		// Legacy
+		replacements.set(
+			"filebase",
+			deprecated(
+				replacer(base),
+				"[filebase] is now [base]",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+			)
+		);
+	}
 
-/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+	// Compilation context
+	//
+	// Placeholders
+	//
+	// [fullhash] - data.hash (3a4b5c6e7f)
+	//
+	// Legacy Placeholders
+	//
+	// [hash] - data.hash (3a4b5c6e7f)
+	if (data.hash) {
+		const hashReplacer = hashLength(
+			replacer(data.hash),
+			data.hashWithLength,
+			assetInfo,
+			"fullhash"
+		);
 
-class NormalModule extends Module {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {NormalModuleCompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				loader: new SyncHook(["loaderContext", "module"]),
-				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				beforeParse: new SyncHook(["module"]),
-				beforeSnapshot: new SyncHook(["module"]),
-				// TODO webpack 6 deprecate
-				readResourceForScheme: new HookMap(scheme => {
-					const hook = hooks.readResource.for(scheme);
-					return createFakeHook(
-						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
-							tap: (options, fn) =>
-								hook.tap(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
-								),
-							tapAsync: (options, fn) =>
-								hook.tapAsync(options, (loaderContext, callback) =>
-									fn(loaderContext.resource, loaderContext._module, callback)
-								),
-							tapPromise: (options, fn) =>
-								hook.tapPromise(options, loaderContext =>
-									fn(loaderContext.resource, loaderContext._module)
-								)
-						})
-					);
-				}),
-				readResource: new HookMap(
-					() => new AsyncSeriesBailHook(["loaderContext"])
-				),
-				needBuild: new AsyncSeriesBailHook(["module", "context"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
+		replacements.set("fullhash", hashReplacer);
+
+		// Legacy
+		replacements.set(
+			"hash",
+			deprecated(
+				hashReplacer,
+				"[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH"
+			)
+		);
 	}
 
-	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.layer an optional layer in which the module is
-	 * @param {string} options.type module type
-	 * @param {string} options.request request string
-	 * @param {string} options.userRequest request intended by user (without loaders from config)
-	 * @param {string} options.rawRequest request without resolving
-	 * @param {LoaderItem[]} options.loaders list of loaders
-	 * @param {string} options.resource path + query of the real resource
-	 * @param {Record<string, any>=} options.resourceResolveData resource resolve data
-	 * @param {string} options.context context directory for resolving
-	 * @param {string | undefined} options.matchResource path + query of the matched resource (virtual)
-	 * @param {Parser} options.parser the parser used
-	 * @param {object} options.parserOptions the options of the parser used
-	 * @param {Generator} options.generator the generator used
-	 * @param {object} options.generatorOptions the options of the generator used
-	 * @param {Object} options.resolveOptions options used for resolving requests from this module
-	 */
-	constructor({
-		layer,
-		type,
-		request,
-		userRequest,
-		rawRequest,
-		loaders,
-		resource,
-		resourceResolveData,
-		context,
-		matchResource,
-		parser,
-		parserOptions,
-		generator,
-		generatorOptions,
-		resolveOptions
-	}) {
-		super(type, context || getContext(resource), layer);
+	// Chunk Context
+	//
+	// Placeholders
+	//
+	// [id] - chunk.id (0.js)
+	// [name] - chunk.name (app.js)
+	// [chunkhash] - chunk.hash (7823t4t4.js)
+	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+	if (data.chunk) {
+		const chunk = data.chunk;
 
-		// Info from Factory
-		/** @type {string} */
-		this.request = request;
-		/** @type {string} */
-		this.userRequest = userRequest;
-		/** @type {string} */
-		this.rawRequest = rawRequest;
-		/** @type {boolean} */
-		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {Parser} */
-		this.parser = parser;
-		this.parserOptions = parserOptions;
-		/** @type {Generator} */
-		this.generator = generator;
-		this.generatorOptions = generatorOptions;
-		/** @type {string} */
-		this.resource = resource;
-		this.resourceResolveData = resourceResolveData;
-		/** @type {string | undefined} */
-		this.matchResource = matchResource;
-		/** @type {LoaderItem[]} */
-		this.loaders = loaders;
-		if (resolveOptions !== undefined) {
-			// already declared in super class
-			this.resolveOptions = resolveOptions;
-		}
+		const contentHashType = data.contentHashType;
 
-		// Info from Build
-		/** @type {(WebpackError | null)=} */
-		this.error = null;
-		/** @private @type {Source=} */
-		this._source = null;
-		/** @private @type {Map<string, number> | undefined} **/
-		this._sourceSizes = undefined;
-		/** @private @type {Set<string>} */
-		this._sourceTypes = undefined;
+		const idReplacer = replacer(chunk.id);
+		const nameReplacer = replacer(chunk.name || chunk.id);
+		const chunkhashReplacer = hashLength(
+			replacer(chunk instanceof Chunk ? chunk.renderedHash : chunk.hash),
+			"hashWithLength" in chunk ? chunk.hashWithLength : undefined,
+			assetInfo,
+			"chunkhash"
+		);
+		const contenthashReplacer = hashLength(
+			replacer(
+				data.contentHash ||
+					(contentHashType &&
+						chunk.contentHash &&
+						chunk.contentHash[contentHashType])
+			),
+			data.contentHashWithLength ||
+				("contentHashWithLength" in chunk && chunk.contentHashWithLength
+					? chunk.contentHashWithLength[contentHashType]
+					: undefined),
+			assetInfo,
+			"contenthash"
+		);
 
-		// Cache
-		this._lastSuccessfulBuildMeta = {};
-		this._forceBuild = true;
-		this._isEvaluatingSideEffects = false;
-		/** @type {WeakSet<ModuleGraph> | undefined} */
-		this._addedSideEffectsBailout = undefined;
+		replacements.set("id", idReplacer);
+		replacements.set("name", nameReplacer);
+		replacements.set("chunkhash", chunkhashReplacer);
+		replacements.set("contenthash", contenthashReplacer);
 	}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		if (this.layer === null) {
-			if (this.type === "javascript/auto") {
-				return this.request;
-			} else {
-				return `${this.type}|${this.request}`;
-			}
-		} else {
-			return `${this.type}|${this.request}|${this.layer}`;
-		}
-	}
+	// Module Context
+	//
+	// Placeholders
+	//
+	// [id] - module.id (2.png)
+	// [hash] - module.hash (6237543873.png)
+	//
+	// Legacy Placeholders
+	//
+	// [moduleid] - module.id (2.png)
+	// [modulehash] - module.hash (6237543873.png)
+	if (data.module) {
+		const module = data.module;
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.userRequest);
-	}
+		const idReplacer = replacer(() =>
+			prepareId(
+				module instanceof Module ? chunkGraph.getModuleId(module) : module.id
+			)
+		);
+		const moduleHashReplacer = hashLength(
+			replacer(() =>
+				module instanceof Module
+					? chunkGraph.getRenderedModuleHash(module, data.runtime)
+					: module.hash
+			),
+			"hashWithLength" in module ? module.hashWithLength : undefined,
+			assetInfo,
+			"modulehash"
+		);
+		const contentHashReplacer = hashLength(
+			replacer(data.contentHash),
+			undefined,
+			assetInfo,
+			"contenthash"
+		);
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		let ident = contextify(
-			options.context,
-			this.userRequest,
-			options.associatedObjectForCache
+		replacements.set("id", idReplacer);
+		replacements.set("modulehash", moduleHashReplacer);
+		replacements.set("contenthash", contentHashReplacer);
+		replacements.set(
+			"hash",
+			data.contentHash ? contentHashReplacer : moduleHashReplacer
+		);
+		// Legacy
+		replacements.set(
+			"moduleid",
+			deprecated(
+				idReplacer,
+				"[moduleid] is now [id]",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID"
+			)
 		);
-		if (this.layer) ident = `(${this.layer})/${ident}`;
-		return ident;
 	}
 
-	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
-	 */
-	nameForCondition() {
-		const resource = this.matchResource || this.resource;
-		const idx = resource.indexOf("?");
-		if (idx >= 0) return resource.substr(0, idx);
-		return resource;
+	// Other things
+	if (data.url) {
+		replacements.set("url", replacer(data.url));
+	}
+	if (typeof data.runtime === "string") {
+		replacements.set(
+			"runtime",
+			replacer(() => prepareId(data.runtime))
+		);
+	} else {
+		replacements.set("runtime", replacer("_"));
 	}
 
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {NormalModule} */ (module);
-		this.binary = m.binary;
-		this.request = m.request;
-		this.userRequest = m.userRequest;
-		this.rawRequest = m.rawRequest;
-		this.parser = m.parser;
-		this.parserOptions = m.parserOptions;
-		this.generator = m.generator;
-		this.generatorOptions = m.generatorOptions;
-		this.resource = m.resource;
-		this.resourceResolveData = m.resourceResolveData;
-		this.context = m.context;
-		this.matchResource = m.matchResource;
-		this.loaders = m.loaders;
+	if (typeof path === "function") {
+		path = path(data, assetInfo);
 	}
 
-	/**
-	 * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
-	 */
-	cleanupForCache() {
-		// Make sure to cache types and sizes before cleanup when this module has been built
-		// They are accessed by the stats and we don't want them to crash after cleanup
-		// TODO reconsider this for webpack 6
-		if (this.buildInfo) {
-			if (this._sourceTypes === undefined) this.getSourceTypes();
-			for (const type of this._sourceTypes) {
-				this.size(type);
+	path = path.replace(REGEXP, (match, content) => {
+		if (content.length + 2 === match.length) {
+			const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
+			if (!contentMatch) return match;
+			const [, kind, arg] = contentMatch;
+			const replacer = replacements.get(kind);
+			if (replacer !== undefined) {
+				return replacer(match, arg, path);
 			}
+		} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
+			return `[${match.slice(2, -2)}]`;
 		}
-		super.cleanupForCache();
-		this.parser = undefined;
-		this.parserOptions = undefined;
-		this.generator = undefined;
-		this.generatorOptions = undefined;
-	}
+		return match;
+	});
 
+	return path;
+};
+
+const plugin = "TemplatedPathPlugin";
+
+class TemplatedPathPlugin {
 	/**
-	 * Module should be unsafe cached. Get data that's needed for that.
-	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getUnsafeCacheData() {
-		const data = super.getUnsafeCacheData();
-		data.parserOptions = this.parserOptions;
-		data.generatorOptions = this.generatorOptions;
-		return data;
+	apply(compiler) {
+		compiler.hooks.compilation.tap(plugin, compilation => {
+			compilation.hooks.assetPath.tap(plugin, replacePathVariables);
+		});
 	}
+}
 
-	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
-	}
+module.exports = TemplatedPathPlugin;
+
+
+/***/ }),
+
+/***/ 68099:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
+
+class UnhandledSchemeError extends WebpackError {
 	/**
-	 * restore unsafe cache data
-	 * @param {object} unsafeCacheData data from getUnsafeCacheData
-	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 * @param {string} scheme scheme
+	 * @param {string} resource resource
 	 */
-	_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
-		super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
-		this.parserOptions = unsafeCacheData.parserOptions;
-		this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);
-		this.generatorOptions = unsafeCacheData.generatorOptions;
-		this.generator = normalModuleFactory.getGenerator(
-			this.type,
-			this.generatorOptions
+	constructor(scheme, resource) {
+		super(
+			`Reading from "${resource}" is not handled by plugins (Unhandled scheme).` +
+				'\nWebpack supports "data:" and "file:" URIs by default.' +
+				`\nYou may need an additional plugin to handle "${scheme}:" URIs.`
 		);
-		// we assume the generator behaves identically and keep cached sourceTypes/Sizes
+		this.file = resource;
+		this.name = "UnhandledSchemeError";
 	}
+}
 
-	/**
-	 * @param {string} context the compilation context
-	 * @param {string} name the asset name
-	 * @param {string} content the content
-	 * @param {string | TODO} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @returns {Source} the created source
-	 */
-	createSourceForAsset(
-		context,
-		name,
-		content,
-		sourceMap,
-		associatedObjectForCache
-	) {
-		if (sourceMap) {
-			if (
-				typeof sourceMap === "string" &&
-				(this.useSourceMap || this.useSimpleSourceMap)
-			) {
-				return new OriginalSource(
-					content,
-					contextifySourceUrl(context, sourceMap, associatedObjectForCache)
-				);
-			}
+makeSerializable(
+	UnhandledSchemeError,
+	"webpack/lib/UnhandledSchemeError",
+	"UnhandledSchemeError"
+);
 
-			if (this.useSourceMap) {
-				return new SourceMapSource(
-					content,
-					name,
-					contextifySourceMap(context, sourceMap, associatedObjectForCache)
-				);
-			}
-		}
+module.exports = UnhandledSchemeError;
 
-		return new RawSource(content);
-	}
 
-	/**
-	 * @param {ResolverWithOptions} resolver a resolver
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {InputFileSystem} fs file system from reading
-	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {NormalModuleLoaderContext} loader context
-	 */
-	_createLoaderContext(resolver, options, compilation, fs, hooks) {
-		const { requestShortener } = compilation.runtimeTemplate;
-		const getCurrentLoaderName = () => {
-			const currentLoader = this.getCurrentLoader(loaderContext);
-			if (!currentLoader) return "(not in loader scope)";
-			return requestShortener.shorten(currentLoader.loader);
-		};
-		const getResolveContext = () => {
-			return {
-				fileDependencies: {
-					add: d => loaderContext.addDependency(d)
-				},
-				contextDependencies: {
-					add: d => loaderContext.addContextDependency(d)
-				},
-				missingDependencies: {
-					add: d => loaderContext.addMissingDependency(d)
-				}
-			};
-		};
-		const getAbsolutify = memoize(() =>
-			absolutify.bindCache(compilation.compiler.root)
-		);
-		const getAbsolutifyInContext = memoize(() =>
-			absolutify.bindContextCache(this.context, compilation.compiler.root)
-		);
-		const getContextify = memoize(() =>
-			contextify.bindCache(compilation.compiler.root)
-		);
-		const getContextifyInContext = memoize(() =>
-			contextify.bindContextCache(this.context, compilation.compiler.root)
-		);
-		const utils = {
-			absolutify: (context, request) => {
-				return context === this.context
-					? getAbsolutifyInContext()(request)
-					: getAbsolutify()(context, request);
-			},
-			contextify: (context, request) => {
-				return context === this.context
-					? getContextifyInContext()(request)
-					: getContextify()(context, request);
-			},
-			createHash: type => {
-				return createHash(type || compilation.outputOptions.hashFunction);
-			}
-		};
-		const loaderContext = {
-			version: 2,
-			getOptions: schema => {
-				const loader = this.getCurrentLoader(loaderContext);
+/***/ }),
 
-				let { options } = loader;
+/***/ 42495:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				if (typeof options === "string") {
-					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
-						try {
-							options = parseJson(options);
-						} catch (e) {
-							throw new Error(`Cannot parse string options: ${e.message}`);
-						}
-					} else {
-						options = querystring.parse(options, "&", "=", {
-							maxKeys: 0
-						});
-					}
-				}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				if (options === null || options === undefined) {
-					options = {};
-				}
 
-				if (schema) {
-					let name = "Loader";
-					let baseDataPath = "options";
-					let match;
-					if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {
-						[, name, baseDataPath] = match;
-					}
-					getValidate()(schema, options, {
-						name,
-						baseDataPath
-					});
-				}
 
-				return options;
-			},
-			emitWarning: warning => {
-				if (!(warning instanceof Error)) {
-					warning = new NonErrorEmittedError(warning);
-				}
-				this.addWarning(
-					new ModuleWarning(warning, {
-						from: getCurrentLoaderName()
-					})
-				);
-			},
-			emitError: error => {
-				if (!(error instanceof Error)) {
-					error = new NonErrorEmittedError(error);
-				}
-				this.addError(
-					new ModuleError(error, {
-						from: getCurrentLoaderName()
-					})
-				);
-			},
-			getLogger: name => {
-				const currentLoader = this.getCurrentLoader(loaderContext);
-				return compilation.getLogger(() =>
-					[currentLoader && currentLoader.loader, name, this.identifier()]
-						.filter(Boolean)
-						.join("|")
-				);
-			},
-			resolve(context, request, callback) {
-				resolver.resolve({}, context, request, getResolveContext(), callback);
-			},
-			getResolve(options) {
-				const child = options ? resolver.withOptions(options) : resolver;
-				return (context, request, callback) => {
-					if (callback) {
-						child.resolve({}, context, request, getResolveContext(), callback);
-					} else {
-						return new Promise((resolve, reject) => {
-							child.resolve(
-								{},
-								context,
-								request,
-								getResolveContext(),
-								(err, result) => {
-									if (err) reject(err);
-									else resolve(result);
-								}
-							);
-						});
-					}
-				};
-			},
-			emitFile: (name, content, sourceMap, assetInfo) => {
-				if (!this.buildInfo.assets) {
-					this.buildInfo.assets = Object.create(null);
-					this.buildInfo.assetsInfo = new Map();
-				}
-				this.buildInfo.assets[name] = this.createSourceForAsset(
-					options.context,
-					name,
-					content,
-					sourceMap,
-					compilation.compiler.root
-				);
-				this.buildInfo.assetsInfo.set(name, assetInfo);
-			},
-			addBuildDependency: dep => {
-				if (this.buildInfo.buildDependencies === undefined) {
-					this.buildInfo.buildDependencies = new LazySet();
-				}
-				this.buildInfo.buildDependencies.add(dep);
-			},
-			utils,
-			rootContext: options.context,
-			webpack: true,
-			sourceMap: !!this.useSourceMap,
-			mode: options.mode || "production",
-			_module: this,
-			_compilation: compilation,
-			_compiler: compilation.compiler,
-			fs: fs
-		};
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-		Object.assign(loaderContext, options.loader);
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 
-		hooks.loader.call(loaderContext, this);
+class UnsupportedFeatureWarning extends WebpackError {
+	/**
+	 * @param {string} message description of warning
+	 * @param {DependencyLocation} loc location start and end positions of the module
+	 */
+	constructor(message, loc) {
+		super(message);
 
-		return loaderContext;
+		this.name = "UnsupportedFeatureWarning";
+		this.loc = loc;
+		this.hideStack = true;
 	}
+}
 
-	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
-		if (
-			this.loaders &&
-			this.loaders.length &&
-			index < this.loaders.length &&
-			index >= 0 &&
-			this.loaders[index]
-		) {
-			return this.loaders[index];
-		}
-		return null;
-	}
+makeSerializable(
+	UnsupportedFeatureWarning,
+	"webpack/lib/UnsupportedFeatureWarning"
+);
 
-	/**
-	 * @param {string} context the compilation context
-	 * @param {string | Buffer} content the content
-	 * @param {string | TODO} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @returns {Source} the created source
-	 */
-	createSource(context, content, sourceMap, associatedObjectForCache) {
-		if (Buffer.isBuffer(content)) {
-			return new RawSource(content);
-		}
+module.exports = UnsupportedFeatureWarning;
 
-		// if there is no identifier return raw source
-		if (!this.identifier) {
-			return new RawSource(content);
-		}
 
-		// from here on we assume we have an identifier
-		const identifier = this.identifier();
+/***/ }),
 
-		if (this.useSourceMap && sourceMap) {
-			return new SourceMapSource(
-				content,
-				contextifySourceUrl(context, identifier, associatedObjectForCache),
-				contextifySourceMap(context, sourceMap, associatedObjectForCache)
-			);
-		}
+/***/ 36803:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(
-				content,
-				contextifySourceUrl(context, identifier, associatedObjectForCache)
-			);
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		return new RawSource(content);
-	}
 
+
+const ConstDependency = __webpack_require__(76911);
+
+/** @typedef {import("./Compiler")} Compiler */
+
+class UseStrictPlugin {
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @param {function((WebpackError | null)=): void} callback callback function
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	_doBuild(options, compilation, resolver, fs, hooks, callback) {
-		const loaderContext = this._createLoaderContext(
-			resolver,
-			options,
-			compilation,
-			fs,
-			hooks
-		);
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"UseStrictPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const handler = parser => {
+					parser.hooks.program.tap("UseStrictPlugin", ast => {
+						const firstNode = ast.body[0];
+						if (
+							firstNode &&
+							firstNode.type === "ExpressionStatement" &&
+							firstNode.expression.type === "Literal" &&
+							firstNode.expression.value === "use strict"
+						) {
+							// Remove "use strict" expression. It will be added later by the renderer again.
+							// This is necessary in order to not break the strict mode when webpack prepends code.
+							// @see https://github.com/webpack/webpack/issues/1970
+							const dep = new ConstDependency("", firstNode.range);
+							dep.loc = firstNode.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							parser.state.module.buildInfo.strict = true;
+						}
+					});
+				};
 
-		const processResult = (err, result) => {
-			if (err) {
-				if (!(err instanceof Error)) {
-					err = new NonErrorEmittedError(err);
-				}
-				const currentLoader = this.getCurrentLoader(loaderContext);
-				const error = new ModuleBuildError(err, {
-					from:
-						currentLoader &&
-						compilation.runtimeTemplate.requestShortener.shorten(
-							currentLoader.loader
-						)
-				});
-				return callback(error);
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("UseStrictPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("UseStrictPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("UseStrictPlugin", handler);
 			}
+		);
+	}
+}
 
-			const source = result[0];
-			const sourceMap = result.length >= 1 ? result[1] : null;
-			const extraInfo = result.length >= 2 ? result[2] : null;
+module.exports = UseStrictPlugin;
 
-			if (!Buffer.isBuffer(source) && typeof source !== "string") {
-				const currentLoader = this.getCurrentLoader(loaderContext, 0);
-				const err = new Error(
-					`Final loader (${
-						currentLoader
-							? compilation.runtimeTemplate.requestShortener.shorten(
-									currentLoader.loader
-							  )
-							: "unknown"
-					}) didn't return a Buffer or String`
-				);
-				const error = new ModuleBuildError(err);
-				return callback(error);
-			}
 
-			this._source = this.createSource(
-				options.context,
-				this.binary ? asBuffer(source) : asString(source),
-				sourceMap,
-				compilation.compiler.root
-			);
-			if (this._sourceSizes !== undefined) this._sourceSizes.clear();
-			this._ast =
-				typeof extraInfo === "object" &&
-				extraInfo !== null &&
-				extraInfo.webpackAST !== undefined
-					? extraInfo.webpackAST
-					: null;
-			return callback();
-		};
+/***/ }),
 
-		this.buildInfo.fileDependencies = new LazySet();
-		this.buildInfo.contextDependencies = new LazySet();
-		this.buildInfo.missingDependencies = new LazySet();
-		this.buildInfo.cacheable = true;
+/***/ 56504:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		try {
-			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
-		} catch (err) {
-			processResult(err);
-			return;
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		if (this.loaders.length > 0) {
-			this.buildInfo.buildDependencies = new LazySet();
-		}
 
-		runLoaders(
-			{
-				resource: this.resource,
-				loaders: this.loaders,
-				context: loaderContext,
-				processResource: (loaderContext, resourcePath, callback) => {
-					const resource = loaderContext.resource;
-					const scheme = getScheme(resource);
-					hooks.readResource
-						.for(scheme)
-						.callAsync(loaderContext, (err, result) => {
-							if (err) return callback(err);
-							if (typeof result !== "string" && !result) {
-								return callback(new UnhandledSchemeError(scheme, resource));
-							}
-							return callback(null, result);
-						});
-				}
-			},
-			(err, result) => {
-				// Cleanup loaderContext to avoid leaking memory in ICs
-				loaderContext._compilation =
-					loaderContext._compiler =
-					loaderContext._module =
-					loaderContext.fs =
-						undefined;
 
-				if (!result) {
-					this.buildInfo.cacheable = false;
-					return processResult(
-						err || new Error("No result from loader-runner processing"),
-						null
-					);
-				}
-				this.buildInfo.fileDependencies.addAll(result.fileDependencies);
-				this.buildInfo.contextDependencies.addAll(result.contextDependencies);
-				this.buildInfo.missingDependencies.addAll(result.missingDependencies);
-				for (const loader of this.loaders) {
-					this.buildInfo.buildDependencies.add(loader.loader);
-				}
-				this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
-				processResult(err, result.result);
-			}
-		);
-	}
+const CaseSensitiveModulesWarning = __webpack_require__(77975);
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
 
+class WarnCaseSensitiveModulesPlugin {
 	/**
-	 * @param {WebpackError} error the error
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	markModuleAsErrored(error) {
-		// Restore build meta from successful build to keep importing state
-		this.buildMeta = { ...this._lastSuccessfulBuildMeta };
-		this.error = error;
-		this.addError(error);
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WarnCaseSensitiveModulesPlugin",
+			compilation => {
+				compilation.hooks.seal.tap("WarnCaseSensitiveModulesPlugin", () => {
+					/** @type {Map<string, Map<string, Module>>} */
+					const moduleWithoutCase = new Map();
+					for (const module of compilation.modules) {
+						const identifier = module.identifier();
+						const lowerIdentifier = identifier.toLowerCase();
+						let map = moduleWithoutCase.get(lowerIdentifier);
+						if (map === undefined) {
+							map = new Map();
+							moduleWithoutCase.set(lowerIdentifier, map);
+						}
+						map.set(identifier, module);
+					}
+					for (const pair of moduleWithoutCase) {
+						const map = pair[1];
+						if (map.size > 1) {
+							compilation.warnings.push(
+								new CaseSensitiveModulesWarning(
+									map.values(),
+									compilation.moduleGraph
+								)
+							);
+						}
+					}
+				});
+			}
+		);
 	}
+}
 
-	applyNoParseRule(rule, content) {
-		// must start with "rule" if rule is a string
-		if (typeof rule === "string") {
-			return content.startsWith(rule);
-		}
+module.exports = WarnCaseSensitiveModulesPlugin;
 
-		if (typeof rule === "function") {
-			return rule(content);
-		}
-		// we assume rule is a regexp
-		return rule.test(content);
-	}
 
-	// check if module should not be parsed
-	// returns "true" if the module should !not! be parsed
-	// returns "false" if the module !must! be parsed
-	shouldPreventParsing(noParseRule, request) {
-		// if no noParseRule exists, return false
-		// the module !must! be parsed.
-		if (!noParseRule) {
-			return false;
-		}
+/***/ }),
 
-		// we only have one rule to check
-		if (!Array.isArray(noParseRule)) {
-			// returns "true" if the module is !not! to be parsed
-			return this.applyNoParseRule(noParseRule, request);
-		}
+/***/ 76537:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		for (let i = 0; i < noParseRule.length; i++) {
-			const rule = noParseRule[i];
-			// early exit on first truthy match
-			// this module is !not! to be parsed
-			if (this.applyNoParseRule(rule, request)) {
-				return true;
-			}
-		}
-		// no match found, so this module !should! be parsed
-		return false;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
 
-	_initBuildHash(compilation) {
-		const hash = createHash(compilation.outputOptions.hashFunction);
-		if (this._source) {
-			hash.update("source");
-			this._source.updateHash(hash);
-		}
-		hash.update("meta");
-		hash.update(JSON.stringify(this.buildMeta));
-		this.buildInfo.hash = /** @type {string} */ (hash.digest("hex"));
+
+
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("./Compiler")} Compiler */
+
+class WarnDeprecatedOptionPlugin {
+	/**
+	 * Create an instance of the plugin
+	 * @param {string} option the target option
+	 * @param {string | number} value the deprecated option value
+	 * @param {string} suggestion the suggestion replacement
+	 */
+	constructor(option, value, suggestion) {
+		this.option = option;
+		this.value = value;
+		this.suggestion = suggestion;
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this._forceBuild = false;
-		this._source = null;
-		if (this._sourceSizes !== undefined) this._sourceSizes.clear();
-		this._sourceTypes = undefined;
-		this._ast = null;
-		this.error = null;
-		this.clearWarningsAndErrors();
-		this.clearDependenciesAndBlocks();
-		this.buildMeta = {};
-		this.buildInfo = {
-			cacheable: false,
-			parsed: true,
-			fileDependencies: undefined,
-			contextDependencies: undefined,
-			missingDependencies: undefined,
-			buildDependencies: undefined,
-			valueDependencies: undefined,
-			hash: undefined,
-			assets: undefined,
-			assetsInfo: undefined
-		};
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"WarnDeprecatedOptionPlugin",
+			compilation => {
+				compilation.warnings.push(
+					new DeprecatedOptionWarning(this.option, this.value, this.suggestion)
+				);
+			}
+		);
+	}
+}
 
-		const startTime = compilation.compiler.fsStartTime || Date.now();
+class DeprecatedOptionWarning extends WebpackError {
+	constructor(option, value, suggestion) {
+		super();
 
-		const hooks = NormalModule.getCompilationHooks(compilation);
+		this.name = "DeprecatedOptionWarning";
+		this.message =
+			"configuration\n" +
+			`The value '${value}' for option '${option}' is deprecated. ` +
+			`Use '${suggestion}' instead.`;
+	}
+}
 
-		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
-			// if we have an error mark module as failed and exit
-			if (err) {
-				this.markModuleAsErrored(err);
-				this._initBuildHash(compilation);
-				return callback();
-			}
+module.exports = WarnDeprecatedOptionPlugin;
 
-			const handleParseError = e => {
-				const source = this._source.source();
-				const loaders = this.loaders.map(item =>
-					contextify(options.context, item.loader, compilation.compiler.root)
-				);
-				const error = new ModuleParseError(source, e, loaders, this.type);
-				this.markModuleAsErrored(error);
-				this._initBuildHash(compilation);
-				return callback();
-			};
 
-			const handleParseResult = result => {
-				this.dependencies.sort(
-					concatComparators(
-						compareSelect(a => a.loc, compareLocations),
-						keepOriginalOrder(this.dependencies)
-					)
-				);
-				this._initBuildHash(compilation);
-				this._lastSuccessfulBuildMeta = this.buildMeta;
-				return handleBuildDone();
-			};
+/***/ }),
 
-			const handleBuildDone = () => {
-				try {
-					hooks.beforeSnapshot.call(this);
-				} catch (err) {
-					this.markModuleAsErrored(err);
-					return callback();
-				}
+/***/ 25295:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				const snapshotOptions = compilation.options.snapshot.module;
-				if (!this.buildInfo.cacheable || !snapshotOptions) {
-					return callback();
-				}
-				// add warning for all non-absolute paths in fileDependencies, etc
-				// This makes it easier to find problems with watching and/or caching
-				let nonAbsoluteDependencies = undefined;
-				const checkDependencies = deps => {
-					for (const dep of deps) {
-						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
-							if (nonAbsoluteDependencies === undefined)
-								nonAbsoluteDependencies = new Set();
-							nonAbsoluteDependencies.add(dep);
-							deps.delete(dep);
-							try {
-								const depWithoutGlob = dep.replace(/[\\/]?\*.*$/, "");
-								const absolute = join(
-									compilation.fileSystemInfo.fs,
-									this.context,
-									depWithoutGlob
-								);
-								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
-									(depWithoutGlob !== dep
-										? this.buildInfo.contextDependencies
-										: deps
-									).add(absolute);
-								}
-							} catch (e) {
-								// ignore
-							}
-						}
-					}
-				};
-				checkDependencies(this.buildInfo.fileDependencies);
-				checkDependencies(this.buildInfo.missingDependencies);
-				checkDependencies(this.buildInfo.contextDependencies);
-				if (nonAbsoluteDependencies !== undefined) {
-					const InvalidDependenciesModuleWarning =
-						getInvalidDependenciesModuleWarning();
-					this.addWarning(
-						new InvalidDependenciesModuleWarning(this, nonAbsoluteDependencies)
-					);
-				}
-				// convert file/context/missingDependencies into filesystem snapshot
-				compilation.fileSystemInfo.createSnapshot(
-					startTime,
-					this.buildInfo.fileDependencies,
-					this.buildInfo.contextDependencies,
-					this.buildInfo.missingDependencies,
-					snapshotOptions,
-					(err, snapshot) => {
-						if (err) {
-							this.markModuleAsErrored(err);
-							return;
-						}
-						this.buildInfo.fileDependencies = undefined;
-						this.buildInfo.contextDependencies = undefined;
-						this.buildInfo.missingDependencies = undefined;
-						this.buildInfo.snapshot = snapshot;
-						return callback();
-					}
-				);
-			};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			try {
-				hooks.beforeParse.call(this);
-			} catch (err) {
-				this.markModuleAsErrored(err);
-				this._initBuildHash(compilation);
-				return callback();
-			}
 
-			// check if this module should !not! be parsed.
-			// if so, exit here;
-			const noParseRule = options.module && options.module.noParse;
-			if (this.shouldPreventParsing(noParseRule, this.request)) {
-				// We assume that we need module and exports
-				this.buildInfo.parsed = false;
-				this._initBuildHash(compilation);
-				return handleBuildDone();
-			}
 
-			let result;
-			try {
-				const source = this._source.source();
-				result = this.parser.parse(this._ast || source, {
-					source,
-					current: this,
-					module: this,
-					compilation: compilation,
-					options: options
-				});
-			} catch (e) {
-				handleParseError(e);
-				return;
-			}
-			handleParseResult(result);
-		});
-	}
+const NoModeWarning = __webpack_require__(80832);
+
+/** @typedef {import("./Compiler")} Compiler */
 
+class WarnNoModeSetPlugin {
 	/**
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getConcatenationBailoutReason(context) {
-		return this.generator.getConcatenationBailoutReason(this, context);
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap("WarnNoModeSetPlugin", compilation => {
+			compilation.warnings.push(new NoModeWarning());
+		});
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
-	 */
-	getSideEffectsConnectionState(moduleGraph) {
-		if (this.factoryMeta !== undefined) {
-			if (this.factoryMeta.sideEffectFree) return false;
-			if (this.factoryMeta.sideEffectFree === false) return true;
-		}
-		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
-			if (this._isEvaluatingSideEffects)
-				return ModuleGraphConnection.CIRCULAR_CONNECTION;
-			this._isEvaluatingSideEffects = true;
-			/** @type {ConnectionState} */
-			let current = false;
-			for (const dep of this.dependencies) {
-				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
-				if (state === true) {
-					if (
-						this._addedSideEffectsBailout === undefined
-							? ((this._addedSideEffectsBailout = new WeakSet()), true)
-							: !this._addedSideEffectsBailout.has(moduleGraph)
-					) {
-						this._addedSideEffectsBailout.add(moduleGraph);
-						moduleGraph
-							.getOptimizationBailout(this)
-							.push(
-								() =>
-									`Dependency (${
-										dep.type
-									}) with side effects at ${formatLocation(dep.loc)}`
-							);
-					}
-					this._isEvaluatingSideEffects = false;
-					return true;
-				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
-					current = ModuleGraphConnection.addConnectionStates(current, state);
-				}
-			}
-			this._isEvaluatingSideEffects = false;
-			// When caching is implemented here, make sure to not cache when
-			// at least one circular connection was in the loop above
-			return current;
-		} else {
-			return true;
-		}
+module.exports = WarnNoModeSetPlugin;
+
+
+/***/ }),
+
+/***/ 65193:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { groupBy } = __webpack_require__(84953);
+const createSchemaValidation = __webpack_require__(32540);
+
+/** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+
+const validate = createSchemaValidation(
+	__webpack_require__(16711),
+	() => __webpack_require__(44246),
+	{
+		name: "Watch Ignore Plugin",
+		baseDataPath: "options"
 	}
+);
+
+const IGNORE_TIME_ENTRY = "ignore";
 
+class IgnoringWatchFileSystem {
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @param {WatchFileSystem} wfs original file system
+	 * @param {(string|RegExp)[]} paths ignored paths
 	 */
-	getSourceTypes() {
-		if (this._sourceTypes === undefined) {
-			this._sourceTypes = this.generator.getTypes(this);
-		}
-		return this._sourceTypes;
+	constructor(wfs, paths) {
+		this.wfs = wfs;
+		this.paths = paths;
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({
-		dependencyTemplates,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime,
-		concatenationScope,
-		codeGenerationResults
-	}) {
-		/** @type {Set<string>} */
-		const runtimeRequirements = new Set();
+	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
+		files = Array.from(files);
+		dirs = Array.from(dirs);
+		const ignored = path =>
+			this.paths.some(p =>
+				p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0
+			);
 
-		if (!this.buildInfo.parsed) {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-		}
+		const [ignoredFiles, notIgnoredFiles] = groupBy(files, ignored);
+		const [ignoredDirs, notIgnoredDirs] = groupBy(dirs, ignored);
 
-		/** @type {Map<string, any>} */
-		let data;
-		const getData = () => {
-			if (data === undefined) data = new Map();
-			return data;
-		};
+		const watcher = this.wfs.watch(
+			notIgnoredFiles,
+			notIgnoredDirs,
+			missing,
+			startTime,
+			options,
+			(err, fileTimestamps, dirTimestamps, changedFiles, removedFiles) => {
+				if (err) return callback(err);
+				for (const path of ignoredFiles) {
+					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
+				}
 
-		const sources = new Map();
-		for (const type of this.generator.getTypes(this)) {
-			const source = this.error
-				? new RawSource(
-						"throw new Error(" + JSON.stringify(this.error.message) + ");"
-				  )
-				: this.generator.generate(this, {
-						dependencyTemplates,
-						runtimeTemplate,
-						moduleGraph,
-						chunkGraph,
-						runtimeRequirements,
-						runtime,
-						concatenationScope,
-						codeGenerationResults,
-						getData,
-						type
-				  });
+				for (const path of ignoredDirs) {
+					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
+				}
 
-			if (source) {
-				sources.set(type, new CachedSource(source));
-			}
-		}
+				callback(
+					err,
+					fileTimestamps,
+					dirTimestamps,
+					changedFiles,
+					removedFiles
+				);
+			},
+			callbackUndelayed
+		);
 
-		/** @type {CodeGenerationResult} */
-		const resultEntry = {
-			sources,
-			runtimeRequirements,
-			data
+		return {
+			close: () => watcher.close(),
+			pause: () => watcher.pause(),
+			getContextTimeInfoEntries: () => {
+				const dirTimestamps = watcher.getContextTimeInfoEntries();
+				for (const path of ignoredDirs) {
+					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
+				}
+				return dirTimestamps;
+			},
+			getFileTimeInfoEntries: () => {
+				const fileTimestamps = watcher.getFileTimeInfoEntries();
+				for (const path of ignoredFiles) {
+					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
+				}
+				return fileTimestamps;
+			},
+			getInfo:
+				watcher.getInfo &&
+				(() => {
+					const info = watcher.getInfo();
+					const { fileTimeInfoEntries, contextTimeInfoEntries } = info;
+					for (const path of ignoredFiles) {
+						fileTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
+					}
+					for (const path of ignoredDirs) {
+						contextTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
+					}
+					return info;
+				})
 		};
-		return resultEntry;
 	}
+}
 
+class WatchIgnorePlugin {
 	/**
-	 * @returns {Source | null} the original source for the module before webpack transformation
+	 * @param {WatchIgnorePluginOptions} options options
 	 */
-	originalSource() {
-		return this._source;
+	constructor(options) {
+		validate(options);
+		this.paths = options.paths;
 	}
 
 	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	invalidateBuild() {
-		this._forceBuild = true;
+	apply(compiler) {
+		compiler.hooks.afterEnvironment.tap("WatchIgnorePlugin", () => {
+			compiler.watchFileSystem = new IgnoringWatchFileSystem(
+				compiler.watchFileSystem,
+				this.paths
+			);
+		});
 	}
+}
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		const { fileSystemInfo, compilation, valueCacheVersions } = context;
-		// build if enforced
-		if (this._forceBuild) return callback(null, true);
+module.exports = WatchIgnorePlugin;
 
-		// always try to build in case of an error
-		if (this.error) return callback(null, true);
 
-		// always build when module is not cacheable
-		if (!this.buildInfo.cacheable) return callback(null, true);
+/***/ }),
 
-		// build when there is no snapshot to check
-		if (!this.buildInfo.snapshot) return callback(null, true);
+/***/ 84275:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// build when valueDependencies have changed
-		/** @type {Map<string, string | Set<string>>} */
-		const valueDependencies = this.buildInfo.valueDependencies;
-		if (valueDependencies) {
-			if (!valueCacheVersions) return callback(null, true);
-			for (const [key, value] of valueDependencies) {
-				if (value === undefined) return callback(null, true);
-				const current = valueCacheVersions.get(key);
-				if (
-					value !== current &&
-					(typeof value === "string" ||
-						typeof current === "string" ||
-						current === undefined ||
-						!isSubset(value, current))
-				) {
-					return callback(null, true);
-				}
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		// check snapshot for validity
-		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
-			if (err) return callback(err);
-			if (!valid) return callback(null, true);
-			const hooks = NormalModule.getCompilationHooks(compilation);
-			hooks.needBuild.callAsync(this, context, (err, needBuild) => {
-				if (err) {
-					return callback(
-						HookWebpackError.makeWebpackError(
-							err,
-							"NormalModule.getCompilationHooks().needBuild"
-						)
-					);
-				}
-				callback(null, !!needBuild);
-			});
-		});
-	}
 
+
+const Stats = __webpack_require__(31743);
+
+/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+
+/**
+ * @template T
+ * @callback Callback
+ * @param {(Error | null)=} err
+ * @param {T=} result
+ */
+
+class Watching {
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {Compiler} compiler the compiler
+	 * @param {WatchOptions} watchOptions options
+	 * @param {Callback<Stats>} handler completion handler
 	 */
-	size(type) {
-		const cachedSize =
-			this._sourceSizes === undefined ? undefined : this._sourceSizes.get(type);
-		if (cachedSize !== undefined) {
-			return cachedSize;
+	constructor(compiler, watchOptions, handler) {
+		this.startTime = null;
+		this.invalid = false;
+		this.handler = handler;
+		/** @type {Callback<void>[]} */
+		this.callbacks = [];
+		/** @type {Callback<void>[] | undefined} */
+		this._closeCallbacks = undefined;
+		this.closed = false;
+		this.suspended = false;
+		this.blocked = false;
+		this._isBlocked = () => false;
+		this._onChange = () => {};
+		this._onInvalid = () => {};
+		if (typeof watchOptions === "number") {
+			this.watchOptions = {
+				aggregateTimeout: watchOptions
+			};
+		} else if (watchOptions && typeof watchOptions === "object") {
+			this.watchOptions = { ...watchOptions };
+		} else {
+			this.watchOptions = {};
 		}
-		const size = Math.max(1, this.generator.getSize(this, type));
-		if (this._sourceSizes === undefined) {
-			this._sourceSizes = new Map();
+		if (typeof this.watchOptions.aggregateTimeout !== "number") {
+			this.watchOptions.aggregateTimeout = 20;
 		}
-		this._sourceSizes.set(type, size);
-		return size;
+		this.compiler = compiler;
+		this.running = false;
+		this._initial = true;
+		this._invalidReported = true;
+		this._needRecords = true;
+		this.watcher = undefined;
+		this.pausedWatcher = undefined;
+		/** @type {Set<string>} */
+		this._collectedChangedFiles = undefined;
+		/** @type {Set<string>} */
+		this._collectedRemovedFiles = undefined;
+		this._done = this._done.bind(this);
+		process.nextTick(() => {
+			if (this._initial) this._invalidate();
+		});
 	}
 
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {ReadonlySet<string>} changedFiles changed files
+	 * @param {ReadonlySet<string>} removedFiles removed files
 	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {
-		const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
-		if (snapshot) {
-			fileDependencies.addAll(snapshot.getFileIterable());
-			contextDependencies.addAll(snapshot.getContextIterable());
-			missingDependencies.addAll(snapshot.getMissingIterable());
+	_mergeWithCollected(changedFiles, removedFiles) {
+		if (!changedFiles) return;
+		if (!this._collectedChangedFiles) {
+			this._collectedChangedFiles = new Set(changedFiles);
+			this._collectedRemovedFiles = new Set(removedFiles);
 		} else {
-			const {
-				fileDependencies: fileDeps,
-				contextDependencies: contextDeps,
-				missingDependencies: missingDeps
-			} = this.buildInfo;
-			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
-			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
-			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
-		}
-		if (buildDeps !== undefined) {
-			buildDependencies.addAll(buildDeps);
+			for (const file of changedFiles) {
+				this._collectedChangedFiles.add(file);
+				this._collectedRemovedFiles.delete(file);
+			}
+			for (const file of removedFiles) {
+				this._collectedChangedFiles.delete(file);
+				this._collectedRemovedFiles.add(file);
+			}
 		}
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
+	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
+	 * @param {ReadonlySet<string>=} changedFiles changed files
+	 * @param {ReadonlySet<string>=} removedFiles removed files
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		hash.update(this.buildInfo.hash);
-		this.generator.updateHash(hash, {
-			module: this,
-			...context
-		});
-		super.updateHash(hash, context);
-	}
-
-	serialize(context) {
-		const { write } = context;
-		// deserialize
-		write(this._source);
-		write(this.error);
-		write(this._lastSuccessfulBuildMeta);
-		write(this._forceBuild);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const obj = new NormalModule({
-			// will be deserialized by Module
-			layer: null,
-			type: "",
-			// will be filled by updateCacheModule
-			resource: "",
-			context: "",
-			request: null,
-			userRequest: null,
-			rawRequest: null,
-			loaders: null,
-			matchResource: null,
-			parser: null,
-			parserOptions: null,
-			generator: null,
-			generatorOptions: null,
-			resolveOptions: null
-		});
-		obj.deserialize(context);
-		return obj;
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this._source = read();
-		this.error = read();
-		this._lastSuccessfulBuildMeta = read();
-		this._forceBuild = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(NormalModule, "webpack/lib/NormalModule");
-
-module.exports = NormalModule;
-
-
-/***/ }),
+	_go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
+		this._initial = false;
+		if (this.startTime === null) this.startTime = Date.now();
+		this.running = true;
+		if (this.watcher) {
+			this.pausedWatcher = this.watcher;
+			this.lastWatcherStartTime = Date.now();
+			this.watcher.pause();
+			this.watcher = null;
+		} else if (!this.lastWatcherStartTime) {
+			this.lastWatcherStartTime = Date.now();
+		}
+		this.compiler.fsStartTime = Date.now();
+		if (
+			changedFiles &&
+			removedFiles &&
+			fileTimeInfoEntries &&
+			contextTimeInfoEntries
+		) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			this.compiler.fileTimestamps = fileTimeInfoEntries;
+			this.compiler.contextTimestamps = contextTimeInfoEntries;
+		} else if (this.pausedWatcher) {
+			if (this.pausedWatcher.getInfo) {
+				const {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				} = this.pausedWatcher.getInfo();
+				this._mergeWithCollected(changes, removals);
+				this.compiler.fileTimestamps = fileTimeInfoEntries;
+				this.compiler.contextTimestamps = contextTimeInfoEntries;
+			} else {
+				this._mergeWithCollected(
+					this.pausedWatcher.getAggregatedChanges &&
+						this.pausedWatcher.getAggregatedChanges(),
+					this.pausedWatcher.getAggregatedRemovals &&
+						this.pausedWatcher.getAggregatedRemovals()
+				);
+				this.compiler.fileTimestamps =
+					this.pausedWatcher.getFileTimeInfoEntries();
+				this.compiler.contextTimestamps =
+					this.pausedWatcher.getContextTimeInfoEntries();
+			}
+		}
+		this.compiler.modifiedFiles = this._collectedChangedFiles;
+		this._collectedChangedFiles = undefined;
+		this.compiler.removedFiles = this._collectedRemovedFiles;
+		this._collectedRemovedFiles = undefined;
 
-/***/ 68860:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const run = () => {
+			if (this.compiler.idle) {
+				return this.compiler.cache.endIdle(err => {
+					if (err) return this._done(err);
+					this.compiler.idle = false;
+					run();
+				});
+			}
+			if (this._needRecords) {
+				return this.compiler.readRecords(err => {
+					if (err) return this._done(err);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					this._needRecords = false;
+					run();
+				});
+			}
+			this.invalid = false;
+			this._invalidReported = false;
+			this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
+				if (err) return this._done(err);
+				const onCompiled = (err, compilation) => {
+					if (err) return this._done(err, compilation);
+					if (this.invalid) return this._done(null, compilation);
 
+					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
+						return this._done(null, compilation);
+					}
 
+					process.nextTick(() => {
+						const logger = compilation.getLogger("webpack.Compiler");
+						logger.time("emitAssets");
+						this.compiler.emitAssets(compilation, err => {
+							logger.timeEnd("emitAssets");
+							if (err) return this._done(err, compilation);
+							if (this.invalid) return this._done(null, compilation);
 
-const { getContext } = __webpack_require__(68318);
-const asyncLib = __webpack_require__(78175);
-const {
-	AsyncSeriesBailHook,
-	SyncWaterfallHook,
-	SyncBailHook,
-	SyncHook,
-	HookMap
-} = __webpack_require__(41242);
-const ChunkGraph = __webpack_require__(64971);
-const Module = __webpack_require__(73208);
-const ModuleFactory = __webpack_require__(51010);
-const ModuleGraph = __webpack_require__(99988);
-const NormalModule = __webpack_require__(39);
-const BasicEffectRulePlugin = __webpack_require__(30318);
-const BasicMatcherRulePlugin = __webpack_require__(94215);
-const ObjectMatcherRulePlugin = __webpack_require__(72021);
-const RuleSetCompiler = __webpack_require__(83349);
-const UseEffectRulePlugin = __webpack_require__(84977);
-const LazySet = __webpack_require__(38938);
-const { getScheme } = __webpack_require__(54500);
-const { cachedCleverMerge, cachedSetProperty } = __webpack_require__(60839);
-const { join } = __webpack_require__(17139);
-const { parseResource } = __webpack_require__(82186);
+							logger.time("emitRecords");
+							this.compiler.emitRecords(err => {
+								logger.timeEnd("emitRecords");
+								if (err) return this._done(err, compilation);
 
-/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("./Generator")} Generator */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./Parser")} Parser */
-/** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+								if (compilation.hooks.needAdditionalPass.call()) {
+									compilation.needAdditionalPass = true;
 
-/**
- * @typedef {Object} ResolveData
- * @property {ModuleFactoryCreateData["contextInfo"]} contextInfo
- * @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions
- * @property {string} context
- * @property {string} request
- * @property {Record<string, any> | undefined} assertions
- * @property {ModuleDependency[]} dependencies
- * @property {string} dependencyType
- * @property {Object} createData
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} contextDependencies
- * @property {boolean} cacheable allow to use the unsafe cache
- */
+									compilation.startTime = this.startTime;
+									compilation.endTime = Date.now();
+									logger.time("done hook");
+									const stats = new Stats(compilation);
+									this.compiler.hooks.done.callAsync(stats, err => {
+										logger.timeEnd("done hook");
+										if (err) return this._done(err, compilation);
 
-/**
- * @typedef {Object} ResourceData
- * @property {string} resource
- * @property {string} path
- * @property {string} query
- * @property {string} fragment
- * @property {string=} context
- */
+										this.compiler.hooks.additionalPass.callAsync(err => {
+											if (err) return this._done(err, compilation);
+											this.compiler.compile(onCompiled);
+										});
+									});
+									return;
+								}
+								return this._done(null, compilation);
+							});
+						});
+					});
+				};
+				this.compiler.compile(onCompiled);
+			});
+		};
 
-/** @typedef {ResourceData & { data: Record<string, any> }} ResourceDataWithData */
+		run();
+	}
 
-const EMPTY_RESOLVE_OPTIONS = {};
-const EMPTY_PARSER_OPTIONS = {};
-const EMPTY_GENERATOR_OPTIONS = {};
-const EMPTY_ELEMENTS = [];
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Stats} the compilation stats
+	 */
+	_getStats(compilation) {
+		const stats = new Stats(compilation);
+		return stats;
+	}
 
-const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
+	/**
+	 * @param {Error=} err an optional error
+	 * @param {Compilation=} compilation the compilation
+	 * @returns {void}
+	 */
+	_done(err, compilation) {
+		this.running = false;
 
-const loaderToIdent = data => {
-	if (!data.options) {
-		return data.loader;
-	}
-	if (typeof data.options === "string") {
-		return data.loader + "?" + data.options;
-	}
-	if (typeof data.options !== "object") {
-		throw new Error("loader options must be string or object");
-	}
-	if (data.ident) {
-		return data.loader + "??" + data.ident;
-	}
-	return data.loader + "?" + JSON.stringify(data.options);
-};
+		const logger = compilation && compilation.getLogger("webpack.Watching");
 
-const stringifyLoadersAndResource = (loaders, resource) => {
-	let str = "";
-	for (const loader of loaders) {
-		str += loaderToIdent(loader) + "!";
-	}
-	return str + resource;
-};
+		let stats = null;
 
-/**
- * @param {string} resultString resultString
- * @returns {{loader: string, options: string|undefined}} parsed loader request
- */
-const identToLoaderRequest = resultString => {
-	const idx = resultString.indexOf("?");
-	if (idx >= 0) {
-		const loader = resultString.substr(0, idx);
-		const options = resultString.substr(idx + 1);
-		return {
-			loader,
-			options
-		};
-	} else {
-		return {
-			loader: resultString,
-			options: undefined
+		const handleError = (err, cbs) => {
+			this.compiler.hooks.failed.call(err);
+			this.compiler.cache.beginIdle();
+			this.compiler.idle = true;
+			this.handler(err, stats);
+			if (!cbs) {
+				cbs = this.callbacks;
+				this.callbacks = [];
+			}
+			for (const cb of cbs) cb(err);
 		};
-	}
-};
-
-const needCalls = (times, callback) => {
-	return err => {
-		if (--times === 0) {
-			return callback(err);
-		}
-		if (err && times > 0) {
-			times = NaN;
-			return callback(err);
-		}
-	};
-};
 
-const mergeGlobalOptions = (globalOptions, type, localOptions) => {
-	const parts = type.split("/");
-	let result;
-	let current = "";
-	for (const part of parts) {
-		current = current ? `${current}/${part}` : part;
-		const options = globalOptions[current];
-		if (typeof options === "object") {
-			if (result === undefined) {
-				result = options;
+		if (
+			this.invalid &&
+			!this.suspended &&
+			!this.blocked &&
+			!(this._isBlocked() && (this.blocked = true))
+		) {
+			if (compilation) {
+				logger.time("storeBuildDependencies");
+				this.compiler.cache.storeBuildDependencies(
+					compilation.buildDependencies,
+					err => {
+						logger.timeEnd("storeBuildDependencies");
+						if (err) return handleError(err);
+						this._go();
+					}
+				);
 			} else {
-				result = cachedCleverMerge(result, options);
+				this._go();
 			}
+			return;
 		}
-	}
-	if (result === undefined) {
-		return localOptions;
-	} else {
-		return cachedCleverMerge(result, localOptions);
-	}
-};
-
-// TODO webpack 6 remove
-const deprecationChangedHookMessage = (name, hook) => {
-	const names = hook.taps
-		.map(tapped => {
-			return tapped.name;
-		})
-		.join(", ");
 
-	return (
-		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
-		"Do not return the passed object, but modify it instead. " +
-		"Returning false will ignore the request and results in no module created."
-	);
-};
+		if (compilation) {
+			compilation.startTime = this.startTime;
+			compilation.endTime = Date.now();
+			stats = new Stats(compilation);
+		}
+		this.startTime = null;
+		if (err) return handleError(err);
 
-const ruleSetCompiler = new RuleSetCompiler([
-	new BasicMatcherRulePlugin("test", "resource"),
-	new BasicMatcherRulePlugin("scheme"),
-	new BasicMatcherRulePlugin("mimetype"),
-	new BasicMatcherRulePlugin("dependency"),
-	new BasicMatcherRulePlugin("include", "resource"),
-	new BasicMatcherRulePlugin("exclude", "resource", true),
-	new BasicMatcherRulePlugin("resource"),
-	new BasicMatcherRulePlugin("resourceQuery"),
-	new BasicMatcherRulePlugin("resourceFragment"),
-	new BasicMatcherRulePlugin("realResource"),
-	new BasicMatcherRulePlugin("issuer"),
-	new BasicMatcherRulePlugin("compiler"),
-	new BasicMatcherRulePlugin("issuerLayer"),
-	new ObjectMatcherRulePlugin("assert", "assertions"),
-	new ObjectMatcherRulePlugin("descriptionData"),
-	new BasicEffectRulePlugin("type"),
-	new BasicEffectRulePlugin("sideEffects"),
-	new BasicEffectRulePlugin("parser"),
-	new BasicEffectRulePlugin("resolve"),
-	new BasicEffectRulePlugin("generator"),
-	new BasicEffectRulePlugin("layer"),
-	new UseEffectRulePlugin()
-]);
+		const cbs = this.callbacks;
+		this.callbacks = [];
+		logger.time("done hook");
+		this.compiler.hooks.done.callAsync(stats, err => {
+			logger.timeEnd("done hook");
+			if (err) return handleError(err, cbs);
+			this.handler(null, stats);
+			logger.time("storeBuildDependencies");
+			this.compiler.cache.storeBuildDependencies(
+				compilation.buildDependencies,
+				err => {
+					logger.timeEnd("storeBuildDependencies");
+					if (err) return handleError(err, cbs);
+					logger.time("beginIdle");
+					this.compiler.cache.beginIdle();
+					this.compiler.idle = true;
+					logger.timeEnd("beginIdle");
+					process.nextTick(() => {
+						if (!this.closed) {
+							this.watch(
+								compilation.fileDependencies,
+								compilation.contextDependencies,
+								compilation.missingDependencies
+							);
+						}
+					});
+					for (const cb of cbs) cb(null);
+					this.compiler.hooks.afterDone.call(stats);
+				}
+			);
+		});
+	}
 
-class NormalModuleFactory extends ModuleFactory {
 	/**
-	 * @param {Object} param params
-	 * @param {string=} param.context context
-	 * @param {InputFileSystem} param.fs file system
-	 * @param {ResolverFactory} param.resolverFactory resolverFactory
-	 * @param {ModuleOptions} param.options options
-	 * @param {Object=} param.associatedObjectForCache an object to which the cache will be attached
-	 * @param {boolean=} param.layers enable layers
+	 * @param {Iterable<string>} files watched files
+	 * @param {Iterable<string>} dirs watched directories
+	 * @param {Iterable<string>} missing watched existence entries
+	 * @returns {void}
 	 */
-	constructor({
-		context,
-		fs,
-		resolverFactory,
-		options,
-		associatedObjectForCache,
-		layers = false
-	}) {
-		super();
-		this.hooks = Object.freeze({
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			resolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-			resolveForScheme: new HookMap(
-				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
-			),
-			/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
-			resolveInScheme: new HookMap(
-				() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
-			),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			factorize: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			beforeResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData], TODO>} */
-			afterResolve: new AsyncSeriesBailHook(["resolveData"]),
-			/** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], TODO>} */
-			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
-			/** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], TODO>} */
-			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
-			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
-			parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
-			createGenerator: new HookMap(
-				() => new SyncBailHook(["generatorOptions"])
-			),
-			generator: new HookMap(
-				() => new SyncHook(["generator", "generatorOptions"])
-			)
-		});
-		this.resolverFactory = resolverFactory;
-		this.ruleSet = ruleSetCompiler.compile([
-			{
-				rules: options.defaultRules
+	watch(files, dirs, missing) {
+		this.pausedWatcher = null;
+		this.watcher = this.compiler.watchFileSystem.watch(
+			files,
+			dirs,
+			missing,
+			this.lastWatcherStartTime,
+			this.watchOptions,
+			(
+				err,
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changedFiles,
+				removedFiles
+			) => {
+				if (err) {
+					this.compiler.modifiedFiles = undefined;
+					this.compiler.removedFiles = undefined;
+					this.compiler.fileTimestamps = undefined;
+					this.compiler.contextTimestamps = undefined;
+					this.compiler.fsStartTime = undefined;
+					return this.handler(err);
+				}
+				this._invalidate(
+					fileTimeInfoEntries,
+					contextTimeInfoEntries,
+					changedFiles,
+					removedFiles
+				);
+				this._onChange();
 			},
-			{
-				rules: options.rules
+			(fileName, changeTime) => {
+				if (!this._invalidReported) {
+					this._invalidReported = true;
+					this.compiler.hooks.invalid.call(fileName, changeTime);
+				}
+				this._onInvalid();
 			}
-		]);
-		this.context = context || "";
-		this.fs = fs;
-		this._globalParserOptions = options.parser;
-		this._globalGeneratorOptions = options.generator;
-		/** @type {Map<string, WeakMap<Object, TODO>>} */
-		this.parserCache = new Map();
-		/** @type {Map<string, WeakMap<Object, Generator>>} */
-		this.generatorCache = new Map();
-		/** @type {Set<Module>} */
-		this._restoredUnsafeCacheEntries = new Set();
-
-		const cacheParseResource = parseResource.bindCache(
-			associatedObjectForCache
 		);
+	}
 
-		this.hooks.factorize.tapAsync(
-			{
-				name: "NormalModuleFactory",
-				stage: 100
-			},
-			(resolveData, callback) => {
-				this.hooks.resolve.callAsync(resolveData, (err, result) => {
-					if (err) return callback(err);
+	/**
+	 * @param {Callback<void>=} callback signals when the build has completed again
+	 * @returns {void}
+	 */
+	invalidate(callback) {
+		if (callback) {
+			this.callbacks.push(callback);
+		}
+		if (!this._invalidReported) {
+			this._invalidReported = true;
+			this.compiler.hooks.invalid.call(null, Date.now());
+		}
+		this._onChange();
+		this._invalidate();
+	}
 
-					// Ignored
-					if (result === false) return callback();
+	_invalidate(
+		fileTimeInfoEntries,
+		contextTimeInfoEntries,
+		changedFiles,
+		removedFiles
+	) {
+		if (this.suspended || (this._isBlocked() && (this.blocked = true))) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			return;
+		}
 
-					// direct module
-					if (result instanceof Module) return callback(null, result);
+		if (this.running) {
+			this._mergeWithCollected(changedFiles, removedFiles);
+			this.invalid = true;
+		} else {
+			this._go(
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changedFiles,
+				removedFiles
+			);
+		}
+	}
 
-					if (typeof result === "object")
-						throw new Error(
-							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
-								" Returning a Module object will result in this module used as result."
-						);
+	suspend() {
+		this.suspended = true;
+	}
 
-					this.hooks.afterResolve.callAsync(resolveData, (err, result) => {
-						if (err) return callback(err);
+	resume() {
+		if (this.suspended) {
+			this.suspended = false;
+			this._invalidate();
+		}
+	}
 
-						if (typeof result === "object")
-							throw new Error(
-								deprecationChangedHookMessage(
-									"afterResolve",
-									this.hooks.afterResolve
-								)
-							);
+	/**
+	 * @param {Callback<void>} callback signals when the watcher is closed
+	 * @returns {void}
+	 */
+	close(callback) {
+		if (this._closeCallbacks) {
+			if (callback) {
+				this._closeCallbacks.push(callback);
+			}
+			return;
+		}
+		const finalCallback = (err, compilation) => {
+			this.running = false;
+			this.compiler.running = false;
+			this.compiler.watching = undefined;
+			this.compiler.watchMode = false;
+			this.compiler.modifiedFiles = undefined;
+			this.compiler.removedFiles = undefined;
+			this.compiler.fileTimestamps = undefined;
+			this.compiler.contextTimestamps = undefined;
+			this.compiler.fsStartTime = undefined;
+			const shutdown = err => {
+				this.compiler.hooks.watchClose.call();
+				const closeCallbacks = this._closeCallbacks;
+				this._closeCallbacks = undefined;
+				for (const cb of closeCallbacks) cb(err);
+			};
+			if (compilation) {
+				const logger = compilation.getLogger("webpack.Watching");
+				logger.time("storeBuildDependencies");
+				this.compiler.cache.storeBuildDependencies(
+					compilation.buildDependencies,
+					err2 => {
+						logger.timeEnd("storeBuildDependencies");
+						shutdown(err || err2);
+					}
+				);
+			} else {
+				shutdown(err);
+			}
+		};
 
-						// Ignored
-						if (result === false) return callback();
+		this.closed = true;
+		if (this.watcher) {
+			this.watcher.close();
+			this.watcher = null;
+		}
+		if (this.pausedWatcher) {
+			this.pausedWatcher.close();
+			this.pausedWatcher = null;
+		}
+		this._closeCallbacks = [];
+		if (callback) {
+			this._closeCallbacks.push(callback);
+		}
+		if (this.running) {
+			this.invalid = true;
+			this._done = finalCallback;
+		} else {
+			finalCallback();
+		}
+	}
+}
 
-						const createData = resolveData.createData;
+module.exports = Watching;
 
-						this.hooks.createModule.callAsync(
-							createData,
-							resolveData,
-							(err, createdModule) => {
-								if (!createdModule) {
-									if (!resolveData.request) {
-										return callback(new Error("Empty dependency (no request)"));
-									}
 
-									createdModule = new NormalModule(createData);
-								}
+/***/ }),
 
-								createdModule = this.hooks.module.call(
-									createdModule,
-									createData,
-									resolveData
-								);
+/***/ 53799:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-								return callback(null, createdModule);
-							}
-						);
-					});
-				});
-			}
-		);
-		this.hooks.resolve.tapAsync(
-			{
-				name: "NormalModuleFactory",
-				stage: 100
-			},
-			(data, callback) => {
-				const {
-					contextInfo,
-					context,
-					dependencies,
-					dependencyType,
-					request,
-					assertions,
-					resolveOptions,
-					fileDependencies,
-					missingDependencies,
-					contextDependencies
-				} = data;
-				const loaderResolver = this.getResolver("loader");
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Jarid Margolin @jaridmargolin
+*/
 
-				/** @type {ResourceData | undefined} */
-				let matchResourceData = undefined;
-				/** @type {string} */
-				let unresolvedResource;
-				/** @type {{loader: string, options: string|undefined}[]} */
-				let elements;
-				let noPreAutoLoaders = false;
-				let noAutoLoaders = false;
-				let noPrePostAutoLoaders = false;
 
-				const contextScheme = getScheme(context);
-				/** @type {string | undefined} */
-				let scheme = getScheme(request);
 
-				if (!scheme) {
-					/** @type {string} */
-					let requestWithoutMatchResource = request;
-					const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);
-					if (matchResourceMatch) {
-						let matchResource = matchResourceMatch[1];
-						if (matchResource.charCodeAt(0) === 46) {
-							// 46 === ".", 47 === "/"
-							const secondChar = matchResource.charCodeAt(1);
-							if (
-								secondChar === 47 ||
-								(secondChar === 46 && matchResource.charCodeAt(2) === 47)
-							) {
-								// if matchResources startsWith ../ or ./
-								matchResource = join(this.fs, context, matchResource);
-							}
-						}
-						matchResourceData = {
-							resource: matchResource,
-							...cacheParseResource(matchResource)
-						};
-						requestWithoutMatchResource = request.substr(
-							matchResourceMatch[0].length
-						);
-					}
+const inspect = (__webpack_require__(73837).inspect.custom);
+const makeSerializable = __webpack_require__(33032);
 
-					scheme = getScheme(requestWithoutMatchResource);
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module")} Module */
 
-					if (!scheme && !contextScheme) {
-						const firstChar = requestWithoutMatchResource.charCodeAt(0);
-						const secondChar = requestWithoutMatchResource.charCodeAt(1);
-						noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!"
-						noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!"
-						noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!";
-						const rawElements = requestWithoutMatchResource
-							.slice(
-								noPreAutoLoaders || noPrePostAutoLoaders
-									? 2
-									: noAutoLoaders
-									? 1
-									: 0
-							)
-							.split(/!+/);
-						unresolvedResource = rawElements.pop();
-						elements = rawElements.map(identToLoaderRequest);
-						scheme = getScheme(unresolvedResource);
-					} else {
-						unresolvedResource = requestWithoutMatchResource;
-						elements = EMPTY_ELEMENTS;
-					}
-				} else {
-					unresolvedResource = request;
-					elements = EMPTY_ELEMENTS;
-				}
+class WebpackError extends Error {
+	/**
+	 * Creates an instance of WebpackError.
+	 * @param {string=} message error message
+	 */
+	constructor(message) {
+		super(message);
 
-				const resolveContext = {
-					fileDependencies,
-					missingDependencies,
-					contextDependencies
-				};
+		this.details = undefined;
+		/** @type {Module} */
+		this.module = undefined;
+		/** @type {DependencyLocation} */
+		this.loc = undefined;
+		/** @type {boolean} */
+		this.hideStack = undefined;
+		/** @type {Chunk} */
+		this.chunk = undefined;
+		/** @type {string} */
+		this.file = undefined;
+	}
 
-				/** @type {ResourceDataWithData} */
-				let resourceData;
+	[inspect]() {
+		return this.stack + (this.details ? `\n${this.details}` : "");
+	}
 
-				let loaders;
+	serialize({ write }) {
+		write(this.name);
+		write(this.message);
+		write(this.stack);
+		write(this.details);
+		write(this.loc);
+		write(this.hideStack);
+	}
 
-				const continueCallback = needCalls(2, err => {
-					if (err) return callback(err);
+	deserialize({ read }) {
+		this.name = read();
+		this.message = read();
+		this.stack = read();
+		this.details = read();
+		this.loc = read();
+		this.hideStack = read();
+	}
+}
 
-					// translate option idents
-					try {
-						for (const item of loaders) {
-							if (typeof item.options === "string" && item.options[0] === "?") {
-								const ident = item.options.substr(1);
-								if (ident === "[[missing ident]]") {
-									throw new Error(
-										"No ident is provided by referenced loader. " +
-											"When using a function for Rule.use in config you need to " +
-											"provide an 'ident' property for referenced loader options."
-									);
-								}
-								item.options = this.ruleSet.references.get(ident);
-								if (item.options === undefined) {
-									throw new Error(
-										"Invalid ident is provided by referenced loader"
-									);
-								}
-								item.ident = ident;
-							}
-						}
-					} catch (e) {
-						return callback(e);
-					}
+makeSerializable(WebpackError, "webpack/lib/WebpackError");
 
-					if (!resourceData) {
-						// ignored
-						return callback(null, dependencies[0].createIgnoredModule(context));
-					}
+module.exports = WebpackError;
 
-					const userRequest =
-						(matchResourceData !== undefined
-							? `${matchResourceData.resource}!=!`
-							: "") +
-						stringifyLoadersAndResource(loaders, resourceData.resource);
 
-					const settings = {};
-					const useLoadersPost = [];
-					const useLoaders = [];
-					const useLoadersPre = [];
+/***/ }),
 
-					// handle .webpack[] suffix
-					let resource;
-					let match;
-					if (
-						matchResourceData &&
-						typeof (resource = matchResourceData.resource) === "string" &&
-						(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
-					) {
-						settings.type = match[1];
-						matchResourceData.resource = matchResourceData.resource.slice(
-							0,
-							-settings.type.length - 10
-						);
-					} else {
-						settings.type = "javascript/auto";
-						const resourceDataForRules = matchResourceData || resourceData;
-						const result = this.ruleSet.exec({
-							resource: resourceDataForRules.path,
-							realResource: resourceData.path,
-							resourceQuery: resourceDataForRules.query,
-							resourceFragment: resourceDataForRules.fragment,
-							scheme,
-							assertions,
-							mimetype: matchResourceData
-								? ""
-								: resourceData.data.mimetype || "",
-							dependency: dependencyType,
-							descriptionData: matchResourceData
-								? undefined
-								: resourceData.data.descriptionFileData,
-							issuer: contextInfo.issuer,
-							compiler: contextInfo.compiler,
-							issuerLayer: contextInfo.issuerLayer || ""
-						});
-						for (const r of result) {
-							if (r.type === "use") {
-								if (!noAutoLoaders && !noPrePostAutoLoaders) {
-									useLoaders.push(r.value);
-								}
-							} else if (r.type === "use-post") {
-								if (!noPrePostAutoLoaders) {
-									useLoadersPost.push(r.value);
-								}
-							} else if (r.type === "use-pre") {
-								if (!noPreAutoLoaders && !noPrePostAutoLoaders) {
-									useLoadersPre.push(r.value);
-								}
-							} else if (
-								typeof r.value === "object" &&
-								r.value !== null &&
-								typeof settings[r.type] === "object" &&
-								settings[r.type] !== null
-							) {
-								settings[r.type] = cachedCleverMerge(settings[r.type], r.value);
-							} else {
-								settings[r.type] = r.value;
-							}
-						}
-					}
+/***/ 97017:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					let postLoaders, normalLoaders, preLoaders;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-					const continueCallback = needCalls(3, err => {
-						if (err) {
-							return callback(err);
-						}
-						const allLoaders = postLoaders;
-						if (matchResourceData === undefined) {
-							for (const loader of loaders) allLoaders.push(loader);
-							for (const loader of normalLoaders) allLoaders.push(loader);
-						} else {
-							for (const loader of normalLoaders) allLoaders.push(loader);
-							for (const loader of loaders) allLoaders.push(loader);
-						}
-						for (const loader of preLoaders) allLoaders.push(loader);
-						let type = settings.type;
-						const resolveOptions = settings.resolve;
-						const layer = settings.layer;
-						if (layer !== undefined && !layers) {
-							return callback(
-								new Error(
-									"'Rule.layer' is only allowed when 'experiments.layers' is enabled"
-								)
-							);
-						}
-						try {
-							Object.assign(data.createData, {
-								layer:
-									layer === undefined ? contextInfo.issuerLayer || null : layer,
-								request: stringifyLoadersAndResource(
-									allLoaders,
-									resourceData.resource
-								),
-								userRequest,
-								rawRequest: request,
-								loaders: allLoaders,
-								resource: resourceData.resource,
-								context:
-									resourceData.context || getContext(resourceData.resource),
-								matchResource: matchResourceData
-									? matchResourceData.resource
-									: undefined,
-								resourceResolveData: resourceData.data,
-								settings,
-								type,
-								parser: this.getParser(type, settings.parser),
-								parserOptions: settings.parser,
-								generator: this.getGenerator(type, settings.generator),
-								generatorOptions: settings.generator,
-								resolveOptions
-							});
-						} catch (e) {
-							return callback(e);
-						}
-						callback();
-					});
-					this.resolveRequestArray(
-						contextInfo,
-						this.context,
-						useLoadersPost,
-						loaderResolver,
-						resolveContext,
-						(err, result) => {
-							postLoaders = result;
-							continueCallback(err);
-						}
-					);
-					this.resolveRequestArray(
-						contextInfo,
-						this.context,
-						useLoaders,
-						loaderResolver,
-						resolveContext,
-						(err, result) => {
-							normalLoaders = result;
-							continueCallback(err);
-						}
-					);
-					this.resolveRequestArray(
-						contextInfo,
-						this.context,
-						useLoadersPre,
-						loaderResolver,
-						resolveContext,
-						(err, result) => {
-							preLoaders = result;
-							continueCallback(err);
-						}
-					);
-				});
 
-				this.resolveRequestArray(
-					contextInfo,
-					contextScheme ? this.context : context,
-					elements,
-					loaderResolver,
-					resolveContext,
-					(err, result) => {
-						if (err) return continueCallback(err);
-						loaders = result;
-						continueCallback();
-					}
+
+const IgnoreErrorModuleFactory = __webpack_require__(3);
+const WebpackIsIncludedDependency = __webpack_require__(26505);
+const {
+	toConstantDependency
+} = __webpack_require__(93998);
+
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class WebpackIsIncludedPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WebpackIsIncludedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebpackIsIncludedDependency,
+					new IgnoreErrorModuleFactory(normalModuleFactory)
+				);
+				compilation.dependencyTemplates.set(
+					WebpackIsIncludedDependency,
+					new WebpackIsIncludedDependency.Template()
 				);
 
-				const defaultResolve = context => {
-					if (/^($|\?)/.test(unresolvedResource)) {
-						resourceData = {
-							resource: unresolvedResource,
-							data: {},
-							...cacheParseResource(unresolvedResource)
-						};
-						continueCallback();
-					}
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call
+						.for("__webpack_is_included__")
+						.tap("WebpackIsIncludedPlugin", expr => {
+							if (
+								expr.type !== "CallExpression" ||
+								expr.arguments.length !== 1 ||
+								expr.arguments[0].type === "SpreadElement"
+							)
+								return;
 
-					// resource without scheme and with path
-					else {
-						const normalResolver = this.getResolver(
-							"normal",
-							dependencyType
-								? cachedSetProperty(
-										resolveOptions || EMPTY_RESOLVE_OPTIONS,
-										"dependencyType",
-										dependencyType
-								  )
-								: resolveOptions
-						);
-						this.resolveResource(
-							contextInfo,
-							context,
-							unresolvedResource,
-							normalResolver,
-							resolveContext,
-							(err, resolvedResource, resolvedResourceResolveData) => {
-								if (err) return continueCallback(err);
-								if (resolvedResource !== false) {
-									resourceData = {
-										resource: resolvedResource,
-										data: resolvedResourceResolveData,
-										...cacheParseResource(resolvedResource)
-									};
-								}
-								continueCallback();
-							}
-						);
-					}
-				};
+							const request = parser.evaluateExpression(expr.arguments[0]);
 
-				// resource with scheme
-				if (scheme) {
-					resourceData = {
-						resource: unresolvedResource,
-						data: {},
-						path: undefined,
-						query: undefined,
-						fragment: undefined,
-						context: undefined
-					};
-					this.hooks.resolveForScheme
-						.for(scheme)
-						.callAsync(resourceData, data, err => {
-							if (err) return continueCallback(err);
-							continueCallback();
-						});
-				}
+							if (!request.isString()) return;
 
-				// resource within scheme
-				else if (contextScheme) {
-					resourceData = {
-						resource: unresolvedResource,
-						data: {},
-						path: undefined,
-						query: undefined,
-						fragment: undefined,
-						context: undefined
-					};
-					this.hooks.resolveInScheme
-						.for(contextScheme)
-						.callAsync(resourceData, data, (err, handled) => {
-							if (err) return continueCallback(err);
-							if (!handled) return defaultResolve(this.context);
-							continueCallback();
+							const dep = new WebpackIsIncludedDependency(
+								request.string,
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
 						});
-				}
-
-				// resource without scheme and without path
-				else defaultResolve(context);
+					parser.hooks.typeof
+						.for("__webpack_is_included__")
+						.tap(
+							"WebpackIsIncludedPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("WebpackIsIncludedPlugin", handler);
 			}
 		);
 	}
+}
 
-	cleanupForCache() {
-		for (const module of this._restoredUnsafeCacheEntries) {
-			ChunkGraph.clearChunkGraphForModule(module);
-			ModuleGraph.clearModuleGraphForModule(module);
-			module.cleanupForCache();
-		}
-	}
+module.exports = WebpackIsIncludedPlugin;
 
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create(data, callback) {
-		const dependencies = /** @type {ModuleDependency[]} */ (data.dependencies);
-		const context = data.context || this.context;
-		const resolveOptions = data.resolveOptions || EMPTY_RESOLVE_OPTIONS;
-		const dependency = dependencies[0];
-		const request = dependency.request;
-		const assertions = dependency.assertions;
-		const contextInfo = data.contextInfo;
-		const fileDependencies = new LazySet();
-		const missingDependencies = new LazySet();
-		const contextDependencies = new LazySet();
-		const dependencyType =
-			(dependencies.length > 0 && dependencies[0].category) || "";
-		/** @type {ResolveData} */
-		const resolveData = {
-			contextInfo,
-			resolveOptions,
-			context,
-			request,
-			assertions,
-			dependencies,
-			dependencyType,
-			fileDependencies,
-			missingDependencies,
-			contextDependencies,
-			createData: {},
-			cacheable: true
-		};
-		this.hooks.beforeResolve.callAsync(resolveData, (err, result) => {
-			if (err) {
-				return callback(err, {
-					fileDependencies,
-					missingDependencies,
-					contextDependencies,
-					cacheable: false
-				});
-			}
 
-			// Ignored
-			if (result === false) {
-				return callback(null, {
-					fileDependencies,
-					missingDependencies,
-					contextDependencies,
-					cacheable: resolveData.cacheable
-				});
-			}
+/***/ }),
 
-			if (typeof result === "object")
-				throw new Error(
-					deprecationChangedHookMessage(
-						"beforeResolve",
-						this.hooks.beforeResolve
-					)
-				);
+/***/ 88422:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			this.hooks.factorize.callAsync(resolveData, (err, module) => {
-				if (err) {
-					return callback(err, {
-						fileDependencies,
-						missingDependencies,
-						contextDependencies,
-						cacheable: false
-					});
-				}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				const factoryResult = {
-					module,
-					fileDependencies,
-					missingDependencies,
-					contextDependencies,
-					cacheable: resolveData.cacheable
-				};
 
-				callback(null, factoryResult);
-			});
-		});
-	}
 
-	resolveResource(
-		contextInfo,
-		context,
-		unresolvedResource,
-		resolver,
-		resolveContext,
-		callback
-	) {
-		resolver.resolve(
-			contextInfo,
-			context,
-			unresolvedResource,
-			resolveContext,
-			(err, resolvedResource, resolvedResourceResolveData) => {
-				if (err) {
-					return this._resolveResourceErrorHints(
-						err,
-						contextInfo,
-						context,
-						unresolvedResource,
-						resolver,
-						resolveContext,
-						(err2, hints) => {
-							if (err2) {
-								err.message += `
-An fatal error happened during resolving additional hints for this error: ${err2.message}`;
-								err.stack += `
+const OptionsApply = __webpack_require__(81426);
 
-An fatal error happened during resolving additional hints for this error:
-${err2.stack}`;
-								return callback(err);
-							}
-							if (hints && hints.length > 0) {
-								err.message += `
-${hints.join("\n\n")}`;
-							}
-							callback(err);
-						}
-					);
-				}
-				callback(err, resolvedResource, resolvedResourceResolveData);
-			}
-		);
+const AssetModulesPlugin = __webpack_require__(16109);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const JsonModulesPlugin = __webpack_require__(86770);
+
+const ChunkPrefetchPreloadPlugin = __webpack_require__(33895);
+
+const EntryOptionPlugin = __webpack_require__(9909);
+const RecordIdsPlugin = __webpack_require__(11094);
+
+const RuntimePlugin = __webpack_require__(2307);
+
+const APIPlugin = __webpack_require__(74315);
+const CompatibilityPlugin = __webpack_require__(94258);
+const ConstPlugin = __webpack_require__(11146);
+const ExportsInfoApiPlugin = __webpack_require__(7145);
+const WebpackIsIncludedPlugin = __webpack_require__(97017);
+
+const TemplatedPathPlugin = __webpack_require__(80734);
+const UseStrictPlugin = __webpack_require__(36803);
+const WarnCaseSensitiveModulesPlugin = __webpack_require__(56504);
+
+const DataUriPlugin = __webpack_require__(64820);
+const FileUriPlugin = __webpack_require__(57637);
+
+const ResolverCachePlugin = __webpack_require__(97347);
+
+const CommonJsPlugin = __webpack_require__(32406);
+const HarmonyModulesPlugin = __webpack_require__(39029);
+const ImportMetaPlugin = __webpack_require__(17228);
+const ImportPlugin = __webpack_require__(41293);
+const LoaderPlugin = __webpack_require__(24721);
+const RequireContextPlugin = __webpack_require__(2928);
+const RequireEnsurePlugin = __webpack_require__(8434);
+const RequireIncludePlugin = __webpack_require__(37378);
+const SystemPlugin = __webpack_require__(97981);
+const URLPlugin = __webpack_require__(14412);
+const WorkerPlugin = __webpack_require__(82509);
+
+const InferAsyncModulesPlugin = __webpack_require__(59498);
+
+const JavascriptMetaInfoPlugin = __webpack_require__(52329);
+const DefaultStatsFactoryPlugin = __webpack_require__(71760);
+const DefaultStatsPresetPlugin = __webpack_require__(55442);
+const DefaultStatsPrinterPlugin = __webpack_require__(58692);
+
+const { cleverMerge } = __webpack_require__(60839);
+
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./Compiler")} Compiler */
+
+class WebpackOptionsApply extends OptionsApply {
+	constructor() {
+		super();
 	}
 
-	_resolveResourceErrorHints(
-		error,
-		contextInfo,
-		context,
-		unresolvedResource,
-		resolver,
-		resolveContext,
-		callback
-	) {
-		asyncLib.parallel(
-			[
-				callback => {
-					if (!resolver.options.fullySpecified) return callback();
-					resolver
-						.withOptions({
-							fullySpecified: false
-						})
-						.resolve(
-							contextInfo,
-							context,
-							unresolvedResource,
-							resolveContext,
-							(err, resolvedResource) => {
-								if (!err && resolvedResource) {
-									const resource = parseResource(resolvedResource).path.replace(
-										/^.*[\\/]/,
-										""
-									);
-									return callback(
-										null,
-										`Did you mean '${resource}'?
-BREAKING CHANGE: The request '${unresolvedResource}' failed to resolve only because it was resolved as fully specified
-(probably because the origin is strict EcmaScript Module, e. g. a module with javascript mimetype, a '*.mjs' file, or a '*.js' file where the package.json contains '"type": "module"').
-The extension in the request is mandatory for it to be fully specified.
-Add the extension to the request.`
-									);
-								}
-								callback();
-							}
-						);
-				},
-				callback => {
-					if (!resolver.options.enforceExtension) return callback();
-					resolver
-						.withOptions({
-							enforceExtension: false,
-							extensions: []
-						})
-						.resolve(
-							contextInfo,
-							context,
-							unresolvedResource,
-							resolveContext,
-							(err, resolvedResource) => {
-								if (!err && resolvedResource) {
-									let hint = "";
-									const match = /(\.[^.]+)(\?|$)/.exec(unresolvedResource);
-									if (match) {
-										const fixedRequest = unresolvedResource.replace(
-											/(\.[^.]+)(\?|$)/,
-											"$2"
-										);
-										if (resolver.options.extensions.has(match[1])) {
-											hint = `Did you mean '${fixedRequest}'?`;
-										} else {
-											hint = `Did you mean '${fixedRequest}'? Also note that '${match[1]}' is not in 'resolve.extensions' yet and need to be added for this to work?`;
-										}
-									} else {
-										hint = `Did you mean to omit the extension or to remove 'resolve.enforceExtension'?`;
-									}
-									return callback(
-										null,
-										`The request '${unresolvedResource}' failed to resolve only because 'resolve.enforceExtension' was specified.
-${hint}
-Including the extension in the request is no longer possible. Did you mean to enforce including the extension in requests with 'resolve.extensions: []' instead?`
-									);
-								}
-								callback();
-							}
-						);
-				},
-				callback => {
-					if (
-						/^\.\.?\//.test(unresolvedResource) ||
-						resolver.options.preferRelative
-					) {
-						return callback();
-					}
-					resolver.resolve(
-						contextInfo,
-						context,
-						`./${unresolvedResource}`,
-						resolveContext,
-						(err, resolvedResource) => {
-							if (err || !resolvedResource) return callback();
-							const moduleDirectories = resolver.options.modules
-								.map(m => (Array.isArray(m) ? m.join(", ") : m))
-								.join(", ");
-							callback(
-								null,
-								`Did you mean './${unresolvedResource}'?
-Requests that should resolve in the current directory need to start with './'.
-Requests that start with a name are treated as module requests and resolve within module directories (${moduleDirectories}).
-If changing the source code is not an option there is also a resolve options called 'preferRelative' which tries to resolve these kind of requests in the current directory too.`
-							);
-						}
-					);
-				}
-			],
-			(err, hints) => {
-				if (err) return callback(err);
-				callback(null, hints.filter(Boolean));
-			}
-		);
-	}
+	/**
+	 * @param {WebpackOptions} options options object
+	 * @param {Compiler} compiler compiler object
+	 * @returns {WebpackOptions} options object
+	 */
+	process(options, compiler) {
+		compiler.outputPath = options.output.path;
+		compiler.recordsInputPath = options.recordsInputPath || null;
+		compiler.recordsOutputPath = options.recordsOutputPath || null;
+		compiler.name = options.name;
 
-	resolveRequestArray(
-		contextInfo,
-		context,
-		array,
-		resolver,
-		resolveContext,
-		callback
-	) {
-		if (array.length === 0) return callback(null, array);
-		asyncLib.map(
-			array,
-			(item, callback) => {
-				resolver.resolve(
-					contextInfo,
-					context,
-					item.loader,
-					resolveContext,
-					(err, result) => {
-						if (
-							err &&
-							/^[^/]*$/.test(item.loader) &&
-							!/-loader$/.test(item.loader)
-						) {
-							return resolver.resolve(
-								contextInfo,
-								context,
-								item.loader + "-loader",
-								resolveContext,
-								err2 => {
-									if (!err2) {
-										err.message =
-											err.message +
-											"\n" +
-											"BREAKING CHANGE: It's no longer allowed to omit the '-loader' suffix when using loaders.\n" +
-											`                 You need to specify '${item.loader}-loader' instead of '${item.loader}',\n` +
-											"                 see https://webpack.js.org/migrate/3/#automatic-loader-module-name-extension-removed";
-									}
-									callback(err);
-								}
-							);
-						}
-						if (err) return callback(err);
+		if (options.externals) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin(options.externalsType, options.externals).apply(
+				compiler
+			);
+		}
 
-						const parsedResult = identToLoaderRequest(result);
-						const resolved = {
-							loader: parsedResult.loader,
-							options:
-								item.options === undefined
-									? parsedResult.options
-									: item.options,
-							ident: item.options === undefined ? undefined : item.ident
-						};
-						return callback(null, resolved);
-					}
-				);
-			},
-			callback
-		);
-	}
+		if (options.externalsPresets.node) {
+			const NodeTargetPlugin = __webpack_require__(17916);
+			new NodeTargetPlugin().apply(compiler);
+		}
+		if (options.externalsPresets.electronMain) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin("main").apply(compiler);
+		}
+		if (options.externalsPresets.electronPreload) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin("preload").apply(compiler);
+		}
+		if (options.externalsPresets.electronRenderer) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin("renderer").apply(compiler);
+		}
+		if (
+			options.externalsPresets.electron &&
+			!options.externalsPresets.electronMain &&
+			!options.externalsPresets.electronPreload &&
+			!options.externalsPresets.electronRenderer
+		) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ElectronTargetPlugin = __webpack_require__(32277);
+			new ElectronTargetPlugin().apply(compiler);
+		}
+		if (options.externalsPresets.nwjs) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
+		}
+		if (options.externalsPresets.webAsync) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin(
+				"import",
+				options.experiments.css
+					? ({ request, dependencyType }, callback) => {
+							if (dependencyType === "url") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `asset ${request}`);
+							} else if (dependencyType === "css-import") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `css-import ${request}`);
+							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+								if (/^\.css(\?|$)/.test(request))
+									return callback(null, `css-import ${request}`);
+								return callback(null, `import ${request}`);
+							}
+							callback();
+					  }
+					: /^(\/\/|https?:\/\/|std:)/
+			).apply(compiler);
+		} else if (options.externalsPresets.web) {
+			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+			const ExternalsPlugin = __webpack_require__(6652);
+			new ExternalsPlugin(
+				"module",
+				options.experiments.css
+					? ({ request, dependencyType }, callback) => {
+							if (dependencyType === "url") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `asset ${request}`);
+							} else if (dependencyType === "css-import") {
+								if (/^(\/\/|https?:\/\/)/.test(request))
+									return callback(null, `css-import ${request}`);
+							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
+								if (/^\.css(\?|$)/.test(request))
+									return callback(null, `css-import ${request}`);
+								return callback(null, `module ${request}`);
+							}
+							callback();
+					  }
+					: /^(\/\/|https?:\/\/|std:)/
+			).apply(compiler);
+		}
 
-	getParser(type, parserOptions = EMPTY_PARSER_OPTIONS) {
-		let cache = this.parserCache.get(type);
+		new ChunkPrefetchPreloadPlugin().apply(compiler);
 
-		if (cache === undefined) {
-			cache = new WeakMap();
-			this.parserCache.set(type, cache);
+		if (typeof options.output.chunkFormat === "string") {
+			switch (options.output.chunkFormat) {
+				case "array-push": {
+					const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
+					new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+					break;
+				}
+				case "commonjs": {
+					const CommonJsChunkFormatPlugin = __webpack_require__(84508);
+					new CommonJsChunkFormatPlugin().apply(compiler);
+					break;
+				}
+				case "module": {
+					const ModuleChunkFormatPlugin = __webpack_require__(68927);
+					new ModuleChunkFormatPlugin().apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(
+						"Unsupported chunk format '" + options.output.chunkFormat + "'."
+					);
+			}
 		}
 
-		let parser = cache.get(parserOptions);
+		if (options.output.enabledChunkLoadingTypes.length > 0) {
+			for (const type of options.output.enabledChunkLoadingTypes) {
+				const EnableChunkLoadingPlugin = __webpack_require__(61291);
+				new EnableChunkLoadingPlugin(type).apply(compiler);
+			}
+		}
 
-		if (parser === undefined) {
-			parser = this.createParser(type, parserOptions);
-			cache.set(parserOptions, parser);
+		if (options.output.enabledWasmLoadingTypes.length > 0) {
+			for (const type of options.output.enabledWasmLoadingTypes) {
+				const EnableWasmLoadingPlugin = __webpack_require__(78613);
+				new EnableWasmLoadingPlugin(type).apply(compiler);
+			}
 		}
 
-		return parser;
-	}
+		if (options.output.enabledLibraryTypes.length > 0) {
+			for (const type of options.output.enabledLibraryTypes) {
+				const EnableLibraryPlugin = __webpack_require__(91452);
+				new EnableLibraryPlugin(type).apply(compiler);
+			}
+		}
 
-	/**
-	 * @param {string} type type
-	 * @param {{[k: string]: any}} parserOptions parser options
-	 * @returns {Parser} parser
-	 */
-	createParser(type, parserOptions = {}) {
-		parserOptions = mergeGlobalOptions(
-			this._globalParserOptions,
-			type,
-			parserOptions
-		);
-		const parser = this.hooks.createParser.for(type).call(parserOptions);
-		if (!parser) {
-			throw new Error(`No parser registered for ${type}`);
+		if (options.output.pathinfo) {
+			const ModuleInfoHeaderPlugin = __webpack_require__(3454);
+			new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply(
+				compiler
+			);
 		}
-		this.hooks.parser.for(type).call(parser, parserOptions);
-		return parser;
-	}
 
-	getGenerator(type, generatorOptions = EMPTY_GENERATOR_OPTIONS) {
-		let cache = this.generatorCache.get(type);
+		if (options.output.clean) {
+			const CleanPlugin = __webpack_require__(31085);
+			new CleanPlugin(
+				options.output.clean === true ? {} : options.output.clean
+			).apply(compiler);
+		}
 
-		if (cache === undefined) {
-			cache = new WeakMap();
-			this.generatorCache.set(type, cache);
+		if (options.devtool) {
+			if (options.devtool.includes("source-map")) {
+				const hidden = options.devtool.includes("hidden");
+				const inline = options.devtool.includes("inline");
+				const evalWrapped = options.devtool.includes("eval");
+				const cheap = options.devtool.includes("cheap");
+				const moduleMaps = options.devtool.includes("module");
+				const noSources = options.devtool.includes("nosources");
+				const Plugin = evalWrapped
+					? __webpack_require__(14790)
+					: __webpack_require__(63872);
+				new Plugin({
+					filename: inline ? null : options.output.sourceMapFilename,
+					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
+					fallbackModuleFilenameTemplate:
+						options.output.devtoolFallbackModuleFilenameTemplate,
+					append: hidden ? false : undefined,
+					module: moduleMaps ? true : cheap ? false : true,
+					columns: cheap ? false : true,
+					noSources: noSources,
+					namespace: options.output.devtoolNamespace
+				}).apply(compiler);
+			} else if (options.devtool.includes("eval")) {
+				const EvalDevToolModulePlugin = __webpack_require__(65218);
+				new EvalDevToolModulePlugin({
+					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
+					namespace: options.output.devtoolNamespace
+				}).apply(compiler);
+			}
 		}
 
-		let generator = cache.get(generatorOptions);
+		new JavascriptModulesPlugin().apply(compiler);
+		new JsonModulesPlugin().apply(compiler);
+		new AssetModulesPlugin().apply(compiler);
 
-		if (generator === undefined) {
-			generator = this.createGenerator(type, generatorOptions);
-			cache.set(generatorOptions, generator);
+		if (!options.experiments.outputModule) {
+			if (options.output.module) {
+				throw new Error(
+					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
+			if (options.output.enabledLibraryTypes.includes("module")) {
+				throw new Error(
+					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
+			if (options.externalsType === "module") {
+				throw new Error(
+					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
 		}
 
-		return generator;
-	}
+		if (options.experiments.syncWebAssembly) {
+			const WebAssemblyModulesPlugin = __webpack_require__(53639);
+			new WebAssemblyModulesPlugin({
+				mangleImports: options.optimization.mangleWasmImports
+			}).apply(compiler);
+		}
 
-	createGenerator(type, generatorOptions = {}) {
-		generatorOptions = mergeGlobalOptions(
-			this._globalGeneratorOptions,
-			type,
-			generatorOptions
-		);
-		const generator = this.hooks.createGenerator
-			.for(type)
-			.call(generatorOptions);
-		if (!generator) {
-			throw new Error(`No generator registered for ${type}`);
+		if (options.experiments.asyncWebAssembly) {
+			const AsyncWebAssemblyModulesPlugin = __webpack_require__(7538);
+			new AsyncWebAssemblyModulesPlugin({
+				mangleImports: options.optimization.mangleWasmImports
+			}).apply(compiler);
 		}
-		this.hooks.generator.for(type).call(generator, generatorOptions);
-		return generator;
-	}
 
-	getResolver(type, resolveOptions) {
-		return this.resolverFactory.get(type, resolveOptions);
-	}
-}
+		if (options.experiments.css) {
+			const CssModulesPlugin = __webpack_require__(47283);
+			new CssModulesPlugin(options.experiments.css).apply(compiler);
+		}
 
-module.exports = NormalModuleFactory;
+		if (options.experiments.lazyCompilation) {
+			const LazyCompilationPlugin = __webpack_require__(79040);
+			const lazyOptions =
+				typeof options.experiments.lazyCompilation === "object"
+					? options.experiments.lazyCompilation
+					: null;
+			new LazyCompilationPlugin({
+				backend:
+					typeof lazyOptions.backend === "function"
+						? lazyOptions.backend
+						: __webpack_require__(17781)({
+								...lazyOptions.backend,
+								client:
+									(lazyOptions.backend && lazyOptions.backend.client) ||
+									options.externalsPresets.node ? __webpack_require__.ab + "lazy-compilation-node.js" : __webpack_require__.ab + "lazy-compilation-web.js"
+						  }),
+				entries: !lazyOptions || lazyOptions.entries !== false,
+				imports: !lazyOptions || lazyOptions.imports !== false,
+				test: (lazyOptions && lazyOptions.test) || undefined
+			}).apply(compiler);
+		}
 
+		if (options.experiments.buildHttp) {
+			const HttpUriPlugin = __webpack_require__(42110);
+			const httpOptions = options.experiments.buildHttp;
+			new HttpUriPlugin(httpOptions).apply(compiler);
+		}
 
-/***/ }),
+		new EntryOptionPlugin().apply(compiler);
+		compiler.hooks.entryOption.call(options.context, options.entry);
 
-/***/ 30633:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		new RuntimePlugin().apply(compiler);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		new InferAsyncModulesPlugin().apply(compiler);
 
+		new DataUriPlugin().apply(compiler);
+		new FileUriPlugin().apply(compiler);
 
+		new CompatibilityPlugin().apply(compiler);
+		new HarmonyModulesPlugin({
+			topLevelAwait: options.experiments.topLevelAwait
+		}).apply(compiler);
+		if (options.amd !== false) {
+			const AMDPlugin = __webpack_require__(50067);
+			const RequireJsStuffPlugin = __webpack_require__(88846);
+			new AMDPlugin(options.amd || {}).apply(compiler);
+			new RequireJsStuffPlugin().apply(compiler);
+		}
+		new CommonJsPlugin().apply(compiler);
+		new LoaderPlugin({}).apply(compiler);
+		if (options.node !== false) {
+			const NodeStuffPlugin = __webpack_require__(95287);
+			new NodeStuffPlugin(options.node).apply(compiler);
+		}
+		new APIPlugin().apply(compiler);
+		new ExportsInfoApiPlugin().apply(compiler);
+		new WebpackIsIncludedPlugin().apply(compiler);
+		new ConstPlugin().apply(compiler);
+		new UseStrictPlugin().apply(compiler);
+		new RequireIncludePlugin().apply(compiler);
+		new RequireEnsurePlugin().apply(compiler);
+		new RequireContextPlugin().apply(compiler);
+		new ImportPlugin().apply(compiler);
+		new SystemPlugin().apply(compiler);
+		new ImportMetaPlugin().apply(compiler);
+		new URLPlugin().apply(compiler);
+		new WorkerPlugin(
+			options.output.workerChunkLoading,
+			options.output.workerWasmLoading,
+			options.output.module
+		).apply(compiler);
 
-const { join, dirname } = __webpack_require__(17139);
+		new DefaultStatsFactoryPlugin().apply(compiler);
+		new DefaultStatsPresetPlugin().apply(compiler);
+		new DefaultStatsPrinterPlugin().apply(compiler);
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {function(TODO): void} ModuleReplacer */
+		new JavascriptMetaInfoPlugin().apply(compiler);
 
-class NormalModuleReplacementPlugin {
-	/**
-	 * Create an instance of the plugin
-	 * @param {RegExp} resourceRegExp the resource matcher
-	 * @param {string|ModuleReplacer} newResource the resource replacement
-	 */
-	constructor(resourceRegExp, newResource) {
-		this.resourceRegExp = resourceRegExp;
-		this.newResource = newResource;
-	}
+		if (typeof options.mode !== "string") {
+			const WarnNoModeSetPlugin = __webpack_require__(25295);
+			new WarnNoModeSetPlugin().apply(compiler);
+		}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const resourceRegExp = this.resourceRegExp;
-		const newResource = this.newResource;
-		compiler.hooks.normalModuleFactory.tap(
-			"NormalModuleReplacementPlugin",
-			nmf => {
-				nmf.hooks.beforeResolve.tap("NormalModuleReplacementPlugin", result => {
-					if (resourceRegExp.test(result.request)) {
-						if (typeof newResource === "function") {
-							newResource(result);
-						} else {
-							result.request = newResource;
-						}
-					}
-				});
-				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
-					const createData = result.createData;
-					if (resourceRegExp.test(createData.resource)) {
-						if (typeof newResource === "function") {
-							newResource(result);
-						} else {
-							const fs = compiler.inputFileSystem;
-							if (
-								newResource.startsWith("/") ||
-								(newResource.length > 1 && newResource[1] === ":")
-							) {
-								createData.resource = newResource;
-							} else {
-								createData.resource = join(
-									fs,
-									dirname(fs, createData.resource),
-									newResource
-								);
-							}
-						}
-					}
-				});
+		const EnsureChunkConditionsPlugin = __webpack_require__(96260);
+		new EnsureChunkConditionsPlugin().apply(compiler);
+		if (options.optimization.removeAvailableModules) {
+			const RemoveParentModulesPlugin = __webpack_require__(7081);
+			new RemoveParentModulesPlugin().apply(compiler);
+		}
+		if (options.optimization.removeEmptyChunks) {
+			const RemoveEmptyChunksPlugin = __webpack_require__(84760);
+			new RemoveEmptyChunksPlugin().apply(compiler);
+		}
+		if (options.optimization.mergeDuplicateChunks) {
+			const MergeDuplicateChunksPlugin = __webpack_require__(85067);
+			new MergeDuplicateChunksPlugin().apply(compiler);
+		}
+		if (options.optimization.flagIncludedChunks) {
+			const FlagIncludedChunksPlugin = __webpack_require__(50089);
+			new FlagIncludedChunksPlugin().apply(compiler);
+		}
+		if (options.optimization.sideEffects) {
+			const SideEffectsFlagPlugin = __webpack_require__(84800);
+			new SideEffectsFlagPlugin(
+				options.optimization.sideEffects === true
+			).apply(compiler);
+		}
+		if (options.optimization.providedExports) {
+			const FlagDependencyExportsPlugin = __webpack_require__(84506);
+			new FlagDependencyExportsPlugin().apply(compiler);
+		}
+		if (options.optimization.usedExports) {
+			const FlagDependencyUsagePlugin = __webpack_require__(58812);
+			new FlagDependencyUsagePlugin(
+				options.optimization.usedExports === "global"
+			).apply(compiler);
+		}
+		if (options.optimization.innerGraph) {
+			const InnerGraphPlugin = __webpack_require__(28758);
+			new InnerGraphPlugin().apply(compiler);
+		}
+		if (options.optimization.mangleExports) {
+			const MangleExportsPlugin = __webpack_require__(27868);
+			new MangleExportsPlugin(
+				options.optimization.mangleExports !== "size"
+			).apply(compiler);
+		}
+		if (options.optimization.concatenateModules) {
+			const ModuleConcatenationPlugin = __webpack_require__(74844);
+			new ModuleConcatenationPlugin().apply(compiler);
+		}
+		if (options.optimization.splitChunks) {
+			const SplitChunksPlugin = __webpack_require__(21478);
+			new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
+		}
+		if (options.optimization.runtimeChunk) {
+			const RuntimeChunkPlugin = __webpack_require__(2837);
+			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
+		}
+		if (!options.optimization.emitOnErrors) {
+			const NoEmitOnErrorsPlugin = __webpack_require__(50169);
+			new NoEmitOnErrorsPlugin().apply(compiler);
+		}
+		if (options.optimization.realContentHash) {
+			const RealContentHashPlugin = __webpack_require__(46043);
+			new RealContentHashPlugin({
+				hashFunction: options.output.hashFunction,
+				hashDigest: options.output.hashDigest
+			}).apply(compiler);
+		}
+		if (options.optimization.checkWasmTypes) {
+			const WasmFinalizeExportsPlugin = __webpack_require__(19810);
+			new WasmFinalizeExportsPlugin().apply(compiler);
+		}
+		const moduleIds = options.optimization.moduleIds;
+		if (moduleIds) {
+			switch (moduleIds) {
+				case "natural": {
+					const NaturalModuleIdsPlugin = __webpack_require__(83366);
+					new NaturalModuleIdsPlugin().apply(compiler);
+					break;
+				}
+				case "named": {
+					const NamedModuleIdsPlugin = __webpack_require__(24339);
+					new NamedModuleIdsPlugin().apply(compiler);
+					break;
+				}
+				case "hashed": {
+					const WarnDeprecatedOptionPlugin = __webpack_require__(76537);
+					const HashedModuleIdsPlugin = __webpack_require__(21825);
+					new WarnDeprecatedOptionPlugin(
+						"optimization.moduleIds",
+						"hashed",
+						"deterministic"
+					).apply(compiler);
+					new HashedModuleIdsPlugin({
+						hashFunction: options.output.hashFunction
+					}).apply(compiler);
+					break;
+				}
+				case "deterministic": {
+					const DeterministicModuleIdsPlugin = __webpack_require__(76692);
+					new DeterministicModuleIdsPlugin().apply(compiler);
+					break;
+				}
+				case "size": {
+					const OccurrenceModuleIdsPlugin = __webpack_require__(35371);
+					new OccurrenceModuleIdsPlugin({
+						prioritiseInitial: true
+					}).apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(
+						`webpack bug: moduleIds: ${moduleIds} is not implemented`
+					);
 			}
-		);
-	}
-}
+		}
+		const chunkIds = options.optimization.chunkIds;
+		if (chunkIds) {
+			switch (chunkIds) {
+				case "natural": {
+					const NaturalChunkIdsPlugin = __webpack_require__(86221);
+					new NaturalChunkIdsPlugin().apply(compiler);
+					break;
+				}
+				case "named": {
+					const NamedChunkIdsPlugin = __webpack_require__(6454);
+					new NamedChunkIdsPlugin().apply(compiler);
+					break;
+				}
+				case "deterministic": {
+					const DeterministicChunkIdsPlugin = __webpack_require__(8747);
+					new DeterministicChunkIdsPlugin().apply(compiler);
+					break;
+				}
+				case "size": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
+					new OccurrenceChunkIdsPlugin({
+						prioritiseInitial: true
+					}).apply(compiler);
+					break;
+				}
+				case "total-size": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
+					new OccurrenceChunkIdsPlugin({
+						prioritiseInitial: false
+					}).apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(
+						`webpack bug: chunkIds: ${chunkIds} is not implemented`
+					);
+			}
+		}
+		if (options.optimization.nodeEnv) {
+			const DefinePlugin = __webpack_require__(79065);
+			new DefinePlugin({
+				"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
+			}).apply(compiler);
+		}
+		if (options.optimization.minimize) {
+			for (const minimizer of options.optimization.minimizer) {
+				if (typeof minimizer === "function") {
+					minimizer.call(compiler, compiler);
+				} else if (minimizer !== "...") {
+					minimizer.apply(compiler);
+				}
+			}
+		}
 
-module.exports = NormalModuleReplacementPlugin;
+		if (options.performance) {
+			const SizeLimitsPlugin = __webpack_require__(32557);
+			new SizeLimitsPlugin(options.performance).apply(compiler);
+		}
 
+		new TemplatedPathPlugin().apply(compiler);
 
-/***/ }),
+		new RecordIdsPlugin({
+			portableIds: options.optimization.portableRecords
+		}).apply(compiler);
 
-/***/ 80057:
-/***/ (function(__unused_webpack_module, exports) {
+		new WarnCaseSensitiveModulesPlugin().apply(compiler);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
+		const AddManagedPathsPlugin = __webpack_require__(47942);
+		new AddManagedPathsPlugin(
+			options.snapshot.managedPaths,
+			options.snapshot.immutablePaths
+		).apply(compiler);
+
+		if (options.cache && typeof options.cache === "object") {
+			const cacheOptions = options.cache;
+			switch (cacheOptions.type) {
+				case "memory": {
+					if (isFinite(cacheOptions.maxGenerations)) {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryWithGcCachePlugin = __webpack_require__(99334);
+						new MemoryWithGcCachePlugin({
+							maxGenerations: cacheOptions.maxGenerations
+						}).apply(compiler);
+					} else {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryCachePlugin = __webpack_require__(52539);
+						new MemoryCachePlugin().apply(compiler);
+					}
+					if (cacheOptions.cacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new Map();
+					}
+					break;
+				}
+				case "filesystem": {
+					const AddBuildDependenciesPlugin = __webpack_require__(28034);
+					for (const key in cacheOptions.buildDependencies) {
+						const list = cacheOptions.buildDependencies[key];
+						new AddBuildDependenciesPlugin(list).apply(compiler);
+					}
+					if (!isFinite(cacheOptions.maxMemoryGenerations)) {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryCachePlugin = __webpack_require__(52539);
+						new MemoryCachePlugin().apply(compiler);
+					} else if (cacheOptions.maxMemoryGenerations !== 0) {
+						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+						const MemoryWithGcCachePlugin = __webpack_require__(99334);
+						new MemoryWithGcCachePlugin({
+							maxGenerations: cacheOptions.maxMemoryGenerations
+						}).apply(compiler);
+					}
+					if (cacheOptions.memoryCacheUnaffected) {
+						if (!options.experiments.cacheUnaffected) {
+							throw new Error(
+								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
+							);
+						}
+						compiler.moduleMemCaches = new Map();
+					}
+					switch (cacheOptions.store) {
+						case "pack": {
+							const IdleFileCachePlugin = __webpack_require__(71985);
+							const PackFileCacheStrategy = __webpack_require__(86180);
+							new IdleFileCachePlugin(
+								new PackFileCacheStrategy({
+									compiler,
+									fs: compiler.intermediateFileSystem,
+									context: options.context,
+									cacheLocation: cacheOptions.cacheLocation,
+									version: cacheOptions.version,
+									logger: compiler.getInfrastructureLogger(
+										"webpack.cache.PackFileCacheStrategy"
+									),
+									snapshot: options.snapshot,
+									maxAge: cacheOptions.maxAge,
+									profile: cacheOptions.profile,
+									allowCollectingMemory: cacheOptions.allowCollectingMemory,
+									compression: cacheOptions.compression
+								}),
+								cacheOptions.idleTimeout,
+								cacheOptions.idleTimeoutForInitialStore,
+								cacheOptions.idleTimeoutAfterLargeChanges
+							).apply(compiler);
+							break;
+						}
+						default:
+							throw new Error("Unhandled value for cache.store");
+					}
+					break;
+				}
+				default:
+					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+					throw new Error(`Unknown cache type ${cacheOptions.type}`);
+			}
+		}
+		new ResolverCachePlugin().apply(compiler);
 
+		if (options.ignoreWarnings && options.ignoreWarnings.length > 0) {
+			const IgnoreWarningsPlugin = __webpack_require__(7373);
+			new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler);
+		}
 
+		compiler.hooks.afterPlugins.call(compiler);
+		if (!compiler.inputFileSystem) {
+			throw new Error("No input filesystem provided");
+		}
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("normal")
+			.tap("WebpackOptionsApply", resolveOptions => {
+				resolveOptions = cleverMerge(options.resolve, resolveOptions);
+				resolveOptions.fileSystem = compiler.inputFileSystem;
+				return resolveOptions;
+			});
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("context")
+			.tap("WebpackOptionsApply", resolveOptions => {
+				resolveOptions = cleverMerge(options.resolve, resolveOptions);
+				resolveOptions.fileSystem = compiler.inputFileSystem;
+				resolveOptions.resolveToContext = true;
+				return resolveOptions;
+			});
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("loader")
+			.tap("WebpackOptionsApply", resolveOptions => {
+				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
+				resolveOptions.fileSystem = compiler.inputFileSystem;
+				return resolveOptions;
+			});
+		compiler.hooks.afterResolvers.call(compiler);
+		return options;
+	}
+}
 
-exports.STAGE_BASIC = -10;
-exports.STAGE_DEFAULT = 0;
-exports.STAGE_ADVANCED = 10;
+module.exports = WebpackOptionsApply;
 
 
 /***/ }),
 
-/***/ 81426:
-/***/ (function(module) {
+/***/ 14452:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -58290,828 +58084,819 @@ exports.STAGE_ADVANCED = 10;
 
 
 
-class OptionsApply {
-	process(options, compiler) {}
+const { applyWebpackOptionsDefaults } = __webpack_require__(92988);
+const { getNormalizedWebpackOptions } = __webpack_require__(26693);
+
+class WebpackOptionsDefaulter {
+	process(options) {
+		options = getNormalizedWebpackOptions(options);
+		applyWebpackOptionsDefaults(options);
+		return options;
+	}
 }
-module.exports = OptionsApply;
+
+module.exports = WebpackOptionsDefaulter;
 
 
 /***/ }),
 
-/***/ 11715:
+/***/ 98421:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./NormalModule")} NormalModule */
-
-/** @typedef {Record<string, any>} PreparsedAst */
+const mimeTypes = __webpack_require__(78585);
+const path = __webpack_require__(71017);
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
+const createHash = __webpack_require__(49835);
+const { makePathsRelative } = __webpack_require__(82186);
 
-/**
- * @typedef {Object} ParserStateBase
- * @property {string | Buffer} source
- * @property {NormalModule} current
- * @property {NormalModule} module
- * @property {Compilation} compilation
- * @property {{[k: string]: any}} options
- */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
+/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
+/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
 
-/** @typedef {Record<string, any> & ParserStateBase} ParserState */
+const mergeMaybeArrays = (a, b) => {
+	const set = new Set();
+	if (Array.isArray(a)) for (const item of a) set.add(item);
+	else set.add(a);
+	if (Array.isArray(b)) for (const item of b) set.add(item);
+	else set.add(b);
+	return Array.from(set);
+};
 
-class Parser {
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+const mergeAssetInfo = (a, b) => {
+	const result = { ...a, ...b };
+	for (const key of Object.keys(a)) {
+		if (key in b) {
+			if (a[key] === b[key]) continue;
+			switch (key) {
+				case "fullhash":
+				case "chunkhash":
+				case "modulehash":
+				case "contenthash":
+					result[key] = mergeMaybeArrays(a[key], b[key]);
+					break;
+				case "immutable":
+				case "development":
+				case "hotModuleReplacement":
+				case "javascriptModule":
+					result[key] = a[key] || b[key];
+					break;
+				case "related":
+					result[key] = mergeRelatedInfo(a[key], b[key]);
+					break;
+				default:
+					throw new Error(`Can't handle conflicting asset info for ${key}`);
+			}
+		}
 	}
-}
-
-module.exports = Parser;
+	return result;
+};
 
+const mergeRelatedInfo = (a, b) => {
+	const result = { ...a, ...b };
+	for (const key of Object.keys(a)) {
+		if (key in b) {
+			if (a[key] === b[key]) continue;
+			result[key] = mergeMaybeArrays(a[key], b[key]);
+		}
+	}
+	return result;
+};
 
-/***/ }),
+const encodeDataUri = (encoding, source) => {
+	let encodedContent;
 
-/***/ 73850:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	switch (encoding) {
+		case "base64": {
+			encodedContent = source.buffer().toString("base64");
+			break;
+		}
+		case false: {
+			const content = source.source();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			if (typeof content !== "string") {
+				encodedContent = content.toString("utf-8");
+			}
 
+			encodedContent = encodeURIComponent(encodedContent).replace(
+				/[!'()*]/g,
+				character => "%" + character.codePointAt(0).toString(16)
+			);
+			break;
+		}
+		default:
+			throw new Error(`Unsupported encoding '${encoding}'`);
+	}
 
+	return encodedContent;
+};
 
-const PrefetchDependency = __webpack_require__(31618);
+const decodeDataUriContent = (encoding, content) => {
+	const isBase64 = encoding === "base64";
+	return isBase64
+		? Buffer.from(content, "base64")
+		: Buffer.from(decodeURIComponent(content), "ascii");
+};
 
-/** @typedef {import("./Compiler")} Compiler */
+const JS_TYPES = new Set(["javascript"]);
+const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
 
-class PrefetchPlugin {
-	constructor(context, request) {
-		if (request) {
-			this.context = context;
-			this.request = request;
+class AssetGenerator extends Generator {
+	/**
+	 * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url
+	 * @param {string=} filename override for output.assetModuleFilename
+	 * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath
+	 * @param {AssetModuleOutputPath=} outputPath the output path for the emitted file which is not included in the runtime import
+	 * @param {boolean=} emit generate output asset
+	 */
+	constructor(dataUrlOptions, filename, publicPath, outputPath, emit) {
+		super();
+		this.dataUrlOptions = dataUrlOptions;
+		this.filename = filename;
+		this.publicPath = publicPath;
+		this.outputPath = outputPath;
+		this.emit = emit;
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(
+		module,
+		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
+	) {
+		switch (type) {
+			case "asset":
+				return module.originalSource();
+			default: {
+				runtimeRequirements.add(RuntimeGlobals.module);
+
+				const originalSource = module.originalSource();
+				if (module.buildInfo.dataUrl) {
+					let encodedSource;
+					if (typeof this.dataUrlOptions === "function") {
+						encodedSource = this.dataUrlOptions.call(
+							null,
+							originalSource.source(),
+							{
+								filename: module.matchResource || module.resource,
+								module
+							}
+						);
+					} else {
+						/** @type {string | false | undefined} */
+						let encoding = this.dataUrlOptions.encoding;
+						if (encoding === undefined) {
+							if (
+								module.resourceResolveData &&
+								module.resourceResolveData.encoding !== undefined
+							) {
+								encoding = module.resourceResolveData.encoding;
+							}
+						}
+						if (encoding === undefined) {
+							encoding = "base64";
+						}
+						let ext;
+						let mimeType = this.dataUrlOptions.mimetype;
+						if (mimeType === undefined) {
+							ext = path.extname(module.nameForCondition());
+							if (
+								module.resourceResolveData &&
+								module.resourceResolveData.mimetype !== undefined
+							) {
+								mimeType =
+									module.resourceResolveData.mimetype +
+									module.resourceResolveData.parameters;
+							} else if (ext) {
+								mimeType = mimeTypes.lookup(ext);
+							}
+						}
+						if (typeof mimeType !== "string") {
+							throw new Error(
+								"DataUrl can't be generated automatically, " +
+									`because there is no mimetype for "${ext}" in mimetype database. ` +
+									'Either pass a mimetype via "generator.mimetype" or ' +
+									'use type: "asset/resource" to create a resource file instead of a DataUrl'
+							);
+						}
+
+						let encodedContent;
+
+						if (
+							module.resourceResolveData &&
+							module.resourceResolveData.encoding === encoding &&
+							decodeDataUriContent(
+								module.resourceResolveData.encoding,
+								module.resourceResolveData.encodedContent
+							).equals(originalSource.buffer())
+						) {
+							encodedContent = module.resourceResolveData.encodedContent;
+						} else {
+							encodedContent = encodeDataUri(encoding, originalSource);
+						}
+
+						encodedSource = `data:${mimeType}${
+							encoding ? `;${encoding}` : ""
+						},${encodedContent}`;
+					}
+					const data = getData();
+					data.set("url", Buffer.from(encodedSource));
+					return new RawSource(
+						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
+							encodedSource
+						)};`
+					);
+				} else {
+					const assetModuleFilename =
+						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+					const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
+					if (runtimeTemplate.outputOptions.hashSalt) {
+						hash.update(runtimeTemplate.outputOptions.hashSalt);
+					}
+					hash.update(originalSource.buffer());
+					const fullHash = /** @type {string} */ (
+						hash.digest(runtimeTemplate.outputOptions.hashDigest)
+					);
+					const contentHash = fullHash.slice(
+						0,
+						runtimeTemplate.outputOptions.hashDigestLength
+					);
+					module.buildInfo.fullContentHash = fullHash;
+					const sourceFilename = makePathsRelative(
+						runtimeTemplate.compilation.compiler.context,
+						module.matchResource || module.resource,
+						runtimeTemplate.compilation.compiler.root
+					).replace(/^\.\//, "");
+					let { path: filename, info: assetInfo } =
+						runtimeTemplate.compilation.getAssetPathWithInfo(
+							assetModuleFilename,
+							{
+								module,
+								runtime,
+								filename: sourceFilename,
+								chunkGraph,
+								contentHash
+							}
+						);
+					let assetPath;
+					if (this.publicPath !== undefined) {
+						const { path, info } =
+							runtimeTemplate.compilation.getAssetPathWithInfo(
+								this.publicPath,
+								{
+									module,
+									runtime,
+									filename: sourceFilename,
+									chunkGraph,
+									contentHash
+								}
+							);
+						assetInfo = mergeAssetInfo(assetInfo, info);
+						assetPath = JSON.stringify(path + filename);
+					} else {
+						runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
+						assetPath = runtimeTemplate.concatenation(
+							{ expr: RuntimeGlobals.publicPath },
+							filename
+						);
+					}
+					assetInfo = {
+						sourceFilename,
+						...assetInfo
+					};
+					if (this.outputPath) {
+						const { path: outputPath, info } =
+							runtimeTemplate.compilation.getAssetPathWithInfo(
+								this.outputPath,
+								{
+									module,
+									runtime,
+									filename: sourceFilename,
+									chunkGraph,
+									contentHash
+								}
+							);
+						assetInfo = mergeAssetInfo(assetInfo, info);
+						filename = path.posix.join(outputPath, filename);
+					}
+					module.buildInfo.filename = filename;
+					module.buildInfo.assetInfo = assetInfo;
+					if (getData) {
+						// Due to code generation caching module.buildInfo.XXX can't used to store such information
+						// It need to be stored in the code generation results instead, where it's cached too
+						// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
+						const data = getData();
+						data.set("fullContentHash", fullHash);
+						data.set("filename", filename);
+						data.set("assetInfo", assetInfo);
+					}
+
+					return new RawSource(
+						`${RuntimeGlobals.module}.exports = ${assetPath};`
+					);
+				}
+			}
+		}
+	}
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) {
+			return JS_TYPES;
 		} else {
-			this.context = null;
-			this.request = context;
+			return JS_AND_ASSET_TYPES;
 		}
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"PrefetchPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					PrefetchDependency,
-					normalModuleFactory
-				);
+	getSize(module, type) {
+		switch (type) {
+			case "asset": {
+				const originalSource = module.originalSource();
+
+				if (!originalSource) {
+					return 0;
+				}
+
+				return originalSource.size();
 			}
-		);
-		compiler.hooks.make.tapAsync("PrefetchPlugin", (compilation, callback) => {
-			compilation.addModuleChain(
-				this.context || compiler.context,
-				new PrefetchDependency(this.request),
-				err => {
-					callback(err);
+			default:
+				if (module.buildInfo && module.buildInfo.dataUrl) {
+					const originalSource = module.originalSource();
+
+					if (!originalSource) {
+						return 0;
+					}
+
+					// roughly for data url
+					// Example: m.exports="data:image/png;base64,ag82/f+2=="
+					// 4/3 = base64 encoding
+					// 34 = ~ data url header + footer + rounding
+					return originalSource.size() * 1.34 + 36;
+				} else {
+					// it's only estimated so this number is probably fine
+					// Example: m.exports=r.p+"0123456789012345678901.ext"
+					return 42;
 				}
-			);
-		});
+		}
+	}
+
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {
+		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
 	}
 }
 
-module.exports = PrefetchPlugin;
+module.exports = AssetGenerator;
 
 
 /***/ }),
 
-/***/ 13216:
+/***/ 16109:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Yuta Hiroto @hiroppy
 */
 
 
 
-const Compiler = __webpack_require__(70845);
-const MultiCompiler = __webpack_require__(33370);
-const NormalModule = __webpack_require__(39);
+const { cleverMerge } = __webpack_require__(60839);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
 const createSchemaValidation = __webpack_require__(32540);
-const { contextify } = __webpack_require__(82186);
-
-/** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
-/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
-/** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
-
-const validate = createSchemaValidation(
-	__webpack_require__(57647),
-	() => __webpack_require__(75202),
-	{
-		name: "Progress Plugin",
-		baseDataPath: "options"
-	}
-);
-const median3 = (a, b, c) => {
-	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
-};
+const memoize = __webpack_require__(78676);
 
-const createDefaultHandler = (profile, logger) => {
-	/** @type {{ value: string, time: number }[]} */
-	const lastStateInfo = [];
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-	const defaultHandler = (percentage, msg, ...args) => {
-		if (profile) {
-			if (percentage === 0) {
-				lastStateInfo.length = 0;
-			}
-			const fullState = [msg, ...args];
-			const state = fullState.map(s => s.replace(/\d+\/\d+ /g, ""));
-			const now = Date.now();
-			const len = Math.max(state.length, lastStateInfo.length);
-			for (let i = len; i >= 0; i--) {
-				const stateItem = i < state.length ? state[i] : undefined;
-				const lastStateItem =
-					i < lastStateInfo.length ? lastStateInfo[i] : undefined;
-				if (lastStateItem) {
-					if (stateItem !== lastStateItem.value) {
-						const diff = now - lastStateItem.time;
-						if (lastStateItem.value) {
-							let reportState = lastStateItem.value;
-							if (i > 0) {
-								reportState = lastStateInfo[i - 1].value + " > " + reportState;
-							}
-							const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
-							const d = diff;
-							// This depends on timing so we ignore it for coverage
-							/* istanbul ignore next */
-							{
-								if (d > 10000) {
-									logger.error(stateMsg);
-								} else if (d > 1000) {
-									logger.warn(stateMsg);
-								} else if (d > 10) {
-									logger.info(stateMsg);
-								} else if (d > 5) {
-									logger.log(stateMsg);
-								} else {
-									logger.debug(stateMsg);
-								}
-							}
-						}
-						if (stateItem === undefined) {
-							lastStateInfo.length = i;
-						} else {
-							lastStateItem.value = stateItem;
-							lastStateItem.time = now;
-							lastStateInfo.length = i + 1;
-						}
-					}
-				} else {
-					lastStateInfo[i] = {
-						value: stateItem,
-						time: now
-					};
-				}
-			}
-		}
-		logger.status(`${Math.floor(percentage * 100)}%`, msg, ...args);
-		if (percentage === 1 || (!msg && args.length === 0)) logger.status();
+const getSchema = name => {
+	const { definitions } = __webpack_require__(73342);
+	return {
+		definitions,
+		oneOf: [{ $ref: `#/definitions/${name}` }]
 	};
-
-	return defaultHandler;
 };
 
-/**
- * @callback ReportProgress
- * @param {number} p
- * @param {...string[]} [args]
- * @returns {void}
- */
-
-/** @type {WeakMap<Compiler,ReportProgress>} */
-const progressReporters = new WeakMap();
+const generatorValidationOptions = {
+	name: "Asset Modules Plugin",
+	baseDataPath: "generator"
+};
+const validateGeneratorOptions = {
+	asset: createSchemaValidation(
+		__webpack_require__(55125),
+		() => getSchema("AssetGeneratorOptions"),
+		generatorValidationOptions
+	),
+	"asset/resource": createSchemaValidation(
+		__webpack_require__(4405),
+		() => getSchema("AssetResourceGeneratorOptions"),
+		generatorValidationOptions
+	),
+	"asset/inline": createSchemaValidation(
+		__webpack_require__(62368),
+		() => getSchema("AssetInlineGeneratorOptions"),
+		generatorValidationOptions
+	)
+};
 
-class ProgressPlugin {
-	/**
-	 * @param {Compiler} compiler the current compiler
-	 * @returns {ReportProgress} a progress reporter, if any
-	 */
-	static getReporter(compiler) {
-		return progressReporters.get(compiler);
+const validateParserOptions = createSchemaValidation(
+	__webpack_require__(45020),
+	() => getSchema("AssetParserOptions"),
+	{
+		name: "Asset Modules Plugin",
+		baseDataPath: "parser"
 	}
+);
 
-	/**
-	 * @param {ProgressPluginArgument} options options
-	 */
-	constructor(options = {}) {
-		if (typeof options === "function") {
-			options = {
-				handler: options
-			};
-		}
-
-		validate(options);
-		options = { ...ProgressPlugin.defaultOptions, ...options };
+const getAssetGenerator = memoize(() => __webpack_require__(98421));
+const getAssetParser = memoize(() => __webpack_require__(91112));
+const getAssetSourceParser = memoize(() => __webpack_require__(30953));
+const getAssetSourceGenerator = memoize(() =>
+	__webpack_require__(18749)
+);
 
-		this.profile = options.profile;
-		this.handler = options.handler;
-		this.modulesCount = options.modulesCount;
-		this.dependenciesCount = options.dependenciesCount;
-		this.showEntries = options.entries;
-		this.showModules = options.modules;
-		this.showDependencies = options.dependencies;
-		this.showActiveModules = options.activeModules;
-		this.percentBy = options.percentBy;
-	}
+const type = "asset";
+const plugin = "AssetModulesPlugin";
 
+class AssetModulesPlugin {
 	/**
-	 * @param {Compiler | MultiCompiler} compiler webpack compiler
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const handler =
-			this.handler ||
-			createDefaultHandler(
-				this.profile,
-				compiler.getInfrastructureLogger("webpack.Progress")
-			);
-		if (compiler instanceof MultiCompiler) {
-			this._applyOnMultiCompiler(compiler, handler);
-		} else if (compiler instanceof Compiler) {
-			this._applyOnCompiler(compiler, handler);
-		}
-	}
+		compiler.hooks.compilation.tap(
+			plugin,
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("asset")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						parserOptions = cleverMerge(
+							compiler.options.module.parser.asset,
+							parserOptions
+						);
 
-	/**
-	 * @param {MultiCompiler} compiler webpack multi-compiler
-	 * @param {HandlerFunction} handler function that executes for every progress step
-	 * @returns {void}
-	 */
-	_applyOnMultiCompiler(compiler, handler) {
-		const states = compiler.compilers.map(
-			() => /** @type {[number, ...string[]]} */ ([0])
-		);
-		compiler.compilers.forEach((compiler, idx) => {
-			new ProgressPlugin((p, msg, ...args) => {
-				states[idx] = [p, msg, ...args];
-				let sum = 0;
-				for (const [p] of states) sum += p;
-				handler(sum / states.length, `[${idx}] ${msg}`, ...args);
-			}).apply(compiler);
-		});
-	}
+						let dataUrlCondition = parserOptions.dataUrlCondition;
+						if (!dataUrlCondition || typeof dataUrlCondition === "object") {
+							dataUrlCondition = {
+								maxSize: 8096,
+								...dataUrlCondition
+							};
+						}
 
-	/**
-	 * @param {Compiler} compiler webpack compiler
-	 * @param {HandlerFunction} handler function that executes for every progress step
-	 * @returns {void}
-	 */
-	_applyOnCompiler(compiler, handler) {
-		const showEntries = this.showEntries;
-		const showModules = this.showModules;
-		const showDependencies = this.showDependencies;
-		const showActiveModules = this.showActiveModules;
-		let lastActiveModule = "";
-		let currentLoader = "";
-		let lastModulesCount = 0;
-		let lastDependenciesCount = 0;
-		let lastEntriesCount = 0;
-		let modulesCount = 0;
-		let dependenciesCount = 0;
-		let entriesCount = 1;
-		let doneModules = 0;
-		let doneDependencies = 0;
-		let doneEntries = 0;
-		const activeModules = new Set();
-		let lastUpdate = 0;
-
-		const updateThrottled = () => {
-			if (lastUpdate + 500 < Date.now()) update();
-		};
-
-		const update = () => {
-			/** @type {string[]} */
-			const items = [];
-			const percentByModules =
-				doneModules /
-				Math.max(lastModulesCount || this.modulesCount || 1, modulesCount);
-			const percentByEntries =
-				doneEntries /
-				Math.max(lastEntriesCount || this.dependenciesCount || 1, entriesCount);
-			const percentByDependencies =
-				doneDependencies /
-				Math.max(lastDependenciesCount || 1, dependenciesCount);
-			let percentageFactor;
+						const AssetParser = getAssetParser();
 
-			switch (this.percentBy) {
-				case "entries":
-					percentageFactor = percentByEntries;
-					break;
-				case "dependencies":
-					percentageFactor = percentByDependencies;
-					break;
-				case "modules":
-					percentageFactor = percentByModules;
-					break;
-				default:
-					percentageFactor = median3(
-						percentByModules,
-						percentByEntries,
-						percentByDependencies
-					);
-			}
+						return new AssetParser(dataUrlCondition);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/inline")
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
 
-			const percentage = 0.1 + percentageFactor * 0.55;
+						return new AssetParser(true);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/resource")
+					.tap(plugin, parserOptions => {
+						const AssetParser = getAssetParser();
 
-			if (currentLoader) {
-				items.push(
-					`import loader ${contextify(
-						compiler.context,
-						currentLoader,
-						compiler.root
-					)}`
-				);
-			} else {
-				const statItems = [];
-				if (showEntries) {
-					statItems.push(`${doneEntries}/${entriesCount} entries`);
-				}
-				if (showDependencies) {
-					statItems.push(
-						`${doneDependencies}/${dependenciesCount} dependencies`
-					);
-				}
-				if (showModules) {
-					statItems.push(`${doneModules}/${modulesCount} modules`);
-				}
-				if (showActiveModules) {
-					statItems.push(`${activeModules.size} active`);
-				}
-				if (statItems.length > 0) {
-					items.push(statItems.join(" "));
-				}
-				if (showActiveModules) {
-					items.push(lastActiveModule);
-				}
-			}
-			handler(percentage, "building", ...items);
-			lastUpdate = Date.now();
-		};
+						return new AssetParser(false);
+					});
+				normalModuleFactory.hooks.createParser
+					.for("asset/source")
+					.tap(plugin, parserOptions => {
+						const AssetSourceParser = getAssetSourceParser();
 
-		const factorizeAdd = () => {
-			dependenciesCount++;
-			if (dependenciesCount < 50 || dependenciesCount % 100 === 0)
-				updateThrottled();
-		};
+						return new AssetSourceParser();
+					});
 
-		const factorizeDone = () => {
-			doneDependencies++;
-			if (doneDependencies < 50 || doneDependencies % 100 === 0)
-				updateThrottled();
-		};
+				for (const type of ["asset", "asset/inline", "asset/resource"]) {
+					normalModuleFactory.hooks.createGenerator
+						.for(type)
+						.tap(plugin, generatorOptions => {
+							validateGeneratorOptions[type](generatorOptions);
 
-		const moduleAdd = () => {
-			modulesCount++;
-			if (modulesCount < 50 || modulesCount % 100 === 0) updateThrottled();
-		};
+							let dataUrl = undefined;
+							if (type !== "asset/resource") {
+								dataUrl = generatorOptions.dataUrl;
+								if (!dataUrl || typeof dataUrl === "object") {
+									dataUrl = {
+										encoding: undefined,
+										mimetype: undefined,
+										...dataUrl
+									};
+								}
+							}
 
-		// only used when showActiveModules is set
-		const moduleBuild = module => {
-			const ident = module.identifier();
-			if (ident) {
-				activeModules.add(ident);
-				lastActiveModule = ident;
-				update();
-			}
-		};
+							let filename = undefined;
+							let publicPath = undefined;
+							let outputPath = undefined;
+							if (type !== "asset/inline") {
+								filename = generatorOptions.filename;
+								publicPath = generatorOptions.publicPath;
+								outputPath = generatorOptions.outputPath;
+							}
 
-		const entryAdd = (entry, options) => {
-			entriesCount++;
-			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
-		};
+							const AssetGenerator = getAssetGenerator();
 
-		const moduleDone = module => {
-			doneModules++;
-			if (showActiveModules) {
-				const ident = module.identifier();
-				if (ident) {
-					activeModules.delete(ident);
-					if (lastActiveModule === ident) {
-						lastActiveModule = "";
-						for (const m of activeModules) {
-							lastActiveModule = m;
-						}
-						update();
-						return;
-					}
+							return new AssetGenerator(
+								dataUrl,
+								filename,
+								publicPath,
+								outputPath,
+								generatorOptions.emit !== false
+							);
+						});
 				}
-			}
-			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
-		};
-
-		const entryDone = (entry, options) => {
-			doneEntries++;
-			update();
-		};
+				normalModuleFactory.hooks.createGenerator
+					.for("asset/source")
+					.tap(plugin, () => {
+						const AssetSourceGenerator = getAssetSourceGenerator();
 
-		const cache = compiler
-			.getCache("ProgressPlugin")
-			.getItemCache("counts", null);
+						return new AssetSourceGenerator();
+					});
 
-		let cacheGetPromise;
+				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { chunk, codeGenerationResults } = options;
 
-		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
-			if (!cacheGetPromise) {
-				cacheGetPromise = cache.getPromise().then(
-					data => {
-						if (data) {
-							lastModulesCount = lastModulesCount || data.modulesCount;
-							lastDependenciesCount =
-								lastDependenciesCount || data.dependenciesCount;
+					const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+						chunk,
+						"asset",
+						compareModulesByIdentifier
+					);
+					if (modules) {
+						for (const module of modules) {
+							try {
+								const codeGenResult = codeGenerationResults.get(
+									module,
+									chunk.runtime
+								);
+								result.push({
+									render: () => codeGenResult.sources.get(type),
+									filename:
+										module.buildInfo.filename ||
+										codeGenResult.data.get("filename"),
+									info:
+										module.buildInfo.assetInfo ||
+										codeGenResult.data.get("assetInfo"),
+									auxiliary: true,
+									identifier: `assetModule${chunkGraph.getModuleId(module)}`,
+									hash:
+										module.buildInfo.fullContentHash ||
+										codeGenResult.data.get("fullContentHash")
+								});
+							} catch (e) {
+								e.message += `\nduring rendering of asset ${module.identifier()}`;
+								throw e;
+							}
 						}
-						return data;
-					},
-					err => {
-						// Ignore error
 					}
-				);
-			}
-		});
-
-		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
-			if (compilation.compiler.isChild()) return Promise.resolve();
-			return cacheGetPromise.then(async oldData => {
-				if (
-					!oldData ||
-					oldData.modulesCount !== modulesCount ||
-					oldData.dependenciesCount !== dependenciesCount
-				) {
-					await cache.storePromise({ modulesCount, dependenciesCount });
-				}
-			});
-		});
-
-		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
-			if (compilation.compiler.isChild()) return;
-			lastModulesCount = modulesCount;
-			lastEntriesCount = entriesCount;
-			lastDependenciesCount = dependenciesCount;
-			modulesCount = dependenciesCount = entriesCount = 0;
-			doneModules = doneDependencies = doneEntries = 0;
-
-			compilation.factorizeQueue.hooks.added.tap(
-				"ProgressPlugin",
-				factorizeAdd
-			);
-			compilation.factorizeQueue.hooks.result.tap(
-				"ProgressPlugin",
-				factorizeDone
-			);
 
-			compilation.addModuleQueue.hooks.added.tap("ProgressPlugin", moduleAdd);
-			compilation.processDependenciesQueue.hooks.result.tap(
-				"ProgressPlugin",
-				moduleDone
-			);
-
-			if (showActiveModules) {
-				compilation.hooks.buildModule.tap("ProgressPlugin", moduleBuild);
-			}
-
-			compilation.hooks.addEntry.tap("ProgressPlugin", entryAdd);
-			compilation.hooks.failedEntry.tap("ProgressPlugin", entryDone);
-			compilation.hooks.succeedEntry.tap("ProgressPlugin", entryDone);
-
-			// avoid dynamic require if bundled with webpack
-			// @ts-expect-error
-			if (false) {}
+					return result;
+				});
 
-			const hooks = {
-				finishModules: "finish module graph",
-				seal: "plugins",
-				optimizeDependencies: "dependencies optimization",
-				afterOptimizeDependencies: "after dependencies optimization",
-				beforeChunks: "chunk graph",
-				afterChunks: "after chunk graph",
-				optimize: "optimizing",
-				optimizeModules: "module optimization",
-				afterOptimizeModules: "after module optimization",
-				optimizeChunks: "chunk optimization",
-				afterOptimizeChunks: "after chunk optimization",
-				optimizeTree: "module and chunk tree optimization",
-				afterOptimizeTree: "after module and chunk tree optimization",
-				optimizeChunkModules: "chunk modules optimization",
-				afterOptimizeChunkModules: "after chunk modules optimization",
-				reviveModules: "module reviving",
-				beforeModuleIds: "before module ids",
-				moduleIds: "module ids",
-				optimizeModuleIds: "module id optimization",
-				afterOptimizeModuleIds: "module id optimization",
-				reviveChunks: "chunk reviving",
-				beforeChunkIds: "before chunk ids",
-				chunkIds: "chunk ids",
-				optimizeChunkIds: "chunk id optimization",
-				afterOptimizeChunkIds: "after chunk id optimization",
-				recordModules: "record modules",
-				recordChunks: "record chunks",
-				beforeModuleHash: "module hashing",
-				beforeCodeGeneration: "code generation",
-				beforeRuntimeRequirements: "runtime requirements",
-				beforeHash: "hashing",
-				afterHash: "after hashing",
-				recordHash: "record hash",
-				beforeModuleAssets: "module assets processing",
-				beforeChunkAssets: "chunk assets processing",
-				processAssets: "asset processing",
-				afterProcessAssets: "after asset optimization",
-				record: "recording",
-				afterSeal: "after seal"
-			};
-			const numberOfHooks = Object.keys(hooks).length;
-			Object.keys(hooks).forEach((name, idx) => {
-				const title = hooks[name];
-				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
-				compilation.hooks[name].intercept({
-					name: "ProgressPlugin",
-					call() {
-						handler(percentage, "sealing", title);
-					},
-					done() {
-						progressReporters.set(compiler, undefined);
-						handler(percentage, "sealing", title);
-					},
-					result() {
-						handler(percentage, "sealing", title);
-					},
-					error() {
-						handler(percentage, "sealing", title);
-					},
-					tap(tap) {
-						// p is percentage from 0 to 1
-						// args is any number of messages in a hierarchical matter
-						progressReporters.set(compilation.compiler, (p, ...args) => {
-							handler(percentage, "sealing", title, tap.name, ...args);
+				compilation.hooks.prepareModuleExecution.tap(
+					"AssetModulesPlugin",
+					(options, context) => {
+						const { codeGenerationResult } = options;
+						const source = codeGenerationResult.sources.get("asset");
+						if (source === undefined) return;
+						context.assets.set(codeGenerationResult.data.get("filename"), {
+							source,
+							info: codeGenerationResult.data.get("assetInfo")
 						});
-						handler(percentage, "sealing", title, tap.name);
 					}
-				});
-			});
-		});
-		compiler.hooks.make.intercept({
-			name: "ProgressPlugin",
-			call() {
-				handler(0.1, "building");
-			},
-			done() {
-				handler(0.65, "building");
-			}
-		});
-		const interceptHook = (hook, progress, category, name) => {
-			hook.intercept({
-				name: "ProgressPlugin",
-				call() {
-					handler(progress, category, name);
-				},
-				done() {
-					progressReporters.set(compiler, undefined);
-					handler(progress, category, name);
-				},
-				result() {
-					handler(progress, category, name);
-				},
-				error() {
-					handler(progress, category, name);
-				},
-				tap(tap) {
-					progressReporters.set(compiler, (p, ...args) => {
-						handler(progress, category, name, tap.name, ...args);
-					});
-					handler(progress, category, name, tap.name);
-				}
-			});
-		};
-		compiler.cache.hooks.endIdle.intercept({
-			name: "ProgressPlugin",
-			call() {
-				handler(0, "");
-			}
-		});
-		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
-		compiler.hooks.initialize.intercept({
-			name: "ProgressPlugin",
-			call() {
-				handler(0, "");
-			}
-		});
-		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
-		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
-		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
-		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
-		interceptHook(
-			compiler.hooks.normalModuleFactory,
-			0.04,
-			"setup",
-			"normal module factory"
-		);
-		interceptHook(
-			compiler.hooks.contextModuleFactory,
-			0.05,
-			"setup",
-			"context module factory"
-		);
-		interceptHook(
-			compiler.hooks.beforeCompile,
-			0.06,
-			"setup",
-			"before compile"
-		);
-		interceptHook(compiler.hooks.compile, 0.07, "setup", "compile");
-		interceptHook(compiler.hooks.thisCompilation, 0.08, "setup", "compilation");
-		interceptHook(compiler.hooks.compilation, 0.09, "setup", "compilation");
-		interceptHook(compiler.hooks.finishMake, 0.69, "building", "finish");
-		interceptHook(compiler.hooks.emit, 0.95, "emitting", "emit");
-		interceptHook(compiler.hooks.afterEmit, 0.98, "emitting", "after emit");
-		interceptHook(compiler.hooks.done, 0.99, "done", "plugins");
-		compiler.hooks.done.intercept({
-			name: "ProgressPlugin",
-			done() {
-				handler(0.99, "");
+				);
 			}
-		});
-		interceptHook(
-			compiler.cache.hooks.storeBuildDependencies,
-			0.99,
-			"cache",
-			"store build dependencies"
-		);
-		interceptHook(compiler.cache.hooks.shutdown, 0.99, "cache", "shutdown");
-		interceptHook(compiler.cache.hooks.beginIdle, 0.99, "cache", "begin idle");
-		interceptHook(
-			compiler.hooks.watchClose,
-			0.99,
-			"end",
-			"closing watch compilation"
 		);
-		compiler.cache.hooks.beginIdle.intercept({
-			name: "ProgressPlugin",
-			done() {
-				handler(1, "");
-			}
-		});
-		compiler.cache.hooks.shutdown.intercept({
-			name: "ProgressPlugin",
-			done() {
-				handler(1, "");
-			}
-		});
 	}
 }
 
-ProgressPlugin.defaultOptions = {
-	profile: false,
-	modulesCount: 5000,
-	dependenciesCount: 10000,
-	modules: true,
-	dependencies: true,
-	activeModules: false,
-	entries: true
-};
-
-module.exports = ProgressPlugin;
+module.exports = AssetModulesPlugin;
 
 
 /***/ }),
 
-/***/ 38309:
+/***/ 91112:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Yuta Hiroto @hiroppy
 */
 
 
 
-const ConstDependency = __webpack_require__(76911);
-const ProvidedDependency = __webpack_require__(95770);
-const { approve } = __webpack_require__(93998);
+const Parser = __webpack_require__(11715);
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-class ProvidePlugin {
+class AssetParser extends Parser {
 	/**
-	 * @param {Record<string, string | string[]>} definitions the provided identifiers
+	 * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl
 	 */
-	constructor(definitions) {
-		this.definitions = definitions;
+	constructor(dataUrlCondition) {
+		super();
+		this.dataUrlCondition = dataUrlCondition;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const definitions = this.definitions;
-		compiler.hooks.compilation.tap(
-			"ProvidePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					ProvidedDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ProvidedDependency,
-					new ProvidedDependency.Template()
-				);
-				const handler = (parser, parserOptions) => {
-					Object.keys(definitions).forEach(name => {
-						const request = [].concat(definitions[name]);
-						const splittedName = name.split(".");
-						if (splittedName.length > 0) {
-							splittedName.slice(1).forEach((_, i) => {
-								const name = splittedName.slice(0, i + 1).join(".");
-								parser.hooks.canRename.for(name).tap("ProvidePlugin", approve);
-							});
-						}
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetParser doesn't accept preparsed AST");
+		}
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "default";
 
-						parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
-							const nameIdentifier = name.includes(".")
-								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
-								: name;
-							const dep = new ProvidedDependency(
-								request[0],
-								nameIdentifier,
-								request.slice(1),
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-							return true;
-						});
+		if (typeof this.dataUrlCondition === "function") {
+			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
+				filename: state.module.matchResource || state.module.resource,
+				module: state.module
+			});
+		} else if (typeof this.dataUrlCondition === "boolean") {
+			state.module.buildInfo.dataUrl = this.dataUrlCondition;
+		} else if (
+			this.dataUrlCondition &&
+			typeof this.dataUrlCondition === "object"
+		) {
+			state.module.buildInfo.dataUrl =
+				Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
+		} else {
+			throw new Error("Unexpected dataUrlCondition type");
+		}
 
-						parser.hooks.call.for(name).tap("ProvidePlugin", expr => {
-							const nameIdentifier = name.includes(".")
-								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
-								: name;
-							const dep = new ProvidedDependency(
-								request[0],
-								nameIdentifier,
-								request.slice(1),
-								expr.callee.range
-							);
-							dep.loc = expr.callee.loc;
-							parser.state.module.addDependency(dep);
-							parser.walkExpressions(expr.arguments);
-							return true;
-						});
-					});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ProvidePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ProvidePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ProvidePlugin", handler);
-			}
+		return state;
+	}
+}
+
+module.exports = AssetParser;
+
+
+/***/ }),
+
+/***/ 18749:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+
+
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+const TYPES = new Set(["javascript"]);
+
+class AssetSourceGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.module);
+
+		const originalSource = module.originalSource();
+
+		if (!originalSource) {
+			return new RawSource("");
+		}
+
+		const content = originalSource.source();
+
+		let encodedSource;
+		if (typeof content === "string") {
+			encodedSource = content;
+		} else {
+			encodedSource = content.toString("utf-8");
+		}
+		return new RawSource(
+			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
 		);
 	}
+
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
+
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+
+		if (!originalSource) {
+			return 0;
+		}
+
+		// Example: m.exports="abcd"
+		return originalSource.size() + 12;
+	}
 }
 
-module.exports = ProvidePlugin;
+module.exports = AssetSourceGenerator;
 
 
 /***/ }),
 
-/***/ 84929:
+/***/ 30953:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Yuta Hiroto @hiroppy
+*/
+
+
+
+const Parser = __webpack_require__(11715);
+
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+
+class AssetSourceParser extends Parser {
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (typeof source === "object" && !Buffer.isBuffer(source)) {
+			throw new Error("AssetSourceParser doesn't accept preparsed AST");
+		}
+		const { module } = state;
+		module.buildInfo.strict = true;
+		module.buildMeta.exportsType = "default";
+
+		return state;
+	}
+}
+
+module.exports = AssetSourceParser;
+
+
+/***/ }),
+
+/***/ 19684:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -59122,41 +58907,37 @@ module.exports = ProvidePlugin;
 
 
 
-const { OriginalSource, RawSource } = __webpack_require__(51255);
+const { RawSource } = __webpack_require__(51255);
 const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 const TYPES = new Set(["javascript"]);
 
-class RawModule extends Module {
+class RawDataUrlModule extends Module {
 	/**
-	 * @param {string} source source code
+	 * @param {string} url raw url
 	 * @param {string} identifier unique identifier
 	 * @param {string=} readableIdentifier readable identifier
-	 * @param {ReadonlySet<string>=} runtimeRequirements runtime requirements needed for the source code
 	 */
-	constructor(source, identifier, readableIdentifier, runtimeRequirements) {
-		super("javascript/dynamic", null);
-		this.sourceStr = source;
-		this.identifierStr = identifier || this.sourceStr;
+	constructor(url, identifier, readableIdentifier) {
+		super("asset/raw-data-url", null);
+		this.url = url;
+		this.urlBuffer = url ? Buffer.from(url) : undefined;
+		this.identifierStr = identifier || this.url;
 		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
-		this.runtimeRequirements = runtimeRequirements || null;
 	}
 
 	/**
@@ -59178,7 +58959,8 @@ class RawModule extends Module {
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
 	size(type) {
-		return Math.max(1, this.sourceStr.length);
+		if (this.url === undefined) this.url = this.urlBuffer.toString();
+		return Math.max(1, this.url.length);
 	}
 
 	/**
@@ -59219,16 +59001,17 @@ class RawModule extends Module {
 	 * @returns {CodeGenerationResult} result
 	 */
 	codeGeneration(context) {
+		if (this.url === undefined) this.url = this.urlBuffer.toString();
 		const sources = new Map();
-		if (this.useSourceMap || this.useSimpleSourceMap) {
-			sources.set(
-				"javascript",
-				new OriginalSource(this.sourceStr, this.identifier())
-			);
-		} else {
-			sources.set("javascript", new RawSource(this.sourceStr));
-		}
-		return { sources, runtimeRequirements: this.runtimeRequirements };
+		sources.set(
+			"javascript",
+			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
+		);
+		const data = new Map();
+		data.set("url", this.urlBuffer);
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		return { sources, runtimeRequirements, data };
 	}
 
 	/**
@@ -59237,17 +59020,16 @@ class RawModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.sourceStr);
+		hash.update(this.urlBuffer);
 		super.updateHash(hash, context);
 	}
 
 	serialize(context) {
 		const { write } = context;
 
-		write(this.sourceStr);
+		write(this.urlBuffer);
 		write(this.identifierStr);
 		write(this.readableIdentifierStr);
-		write(this.runtimeRequirements);
 
 		super.serialize(context);
 	}
@@ -59255,23 +59037,22 @@ class RawModule extends Module {
 	deserialize(context) {
 		const { read } = context;
 
-		this.sourceStr = read();
+		this.urlBuffer = read();
 		this.identifierStr = read();
 		this.readableIdentifierStr = read();
-		this.runtimeRequirements = read();
 
 		super.deserialize(context);
 	}
 }
 
-makeSerializable(RawModule, "webpack/lib/RawModule");
+makeSerializable(RawDataUrlModule, "webpack/lib/asset/RawDataUrlModule");
 
-module.exports = RawModule;
+module.exports = RawDataUrlModule;
 
 
 /***/ }),
 
-/***/ 11094:
+/***/ 41153:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -59282,242 +59063,136 @@ module.exports = RawModule;
 
 
 
-const { compareNumbers } = __webpack_require__(29579);
-const identifierUtils = __webpack_require__(82186);
-
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
 
-/**
- * @typedef {Object} RecordsChunks
- * @property {Record<string, number>=} byName
- * @property {Record<string, number>=} bySource
- * @property {number[]=} usedIds
- */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
 /**
- * @typedef {Object} RecordsModules
- * @property {Record<string, number>=} byIdentifier
- * @property {Record<string, number>=} bySource
- * @property {number[]=} usedIds
+ * @typedef {GenerateContext} Context
  */
+class AwaitDependenciesInitFragment extends InitFragment {
+	/**
+	 * @param {Set<string>} promises the promises that should be awaited
+	 */
+	constructor(promises) {
+		super(
+			undefined,
+			InitFragment.STAGE_ASYNC_DEPENDENCIES,
+			0,
+			"await-dependencies"
+		);
+		this.promises = promises;
+	}
 
-/**
- * @typedef {Object} Records
- * @property {RecordsChunks=} chunks
- * @property {RecordsModules=} modules
- */
+	merge(other) {
+		const promises = new Set(other.promises);
+		for (const p of this.promises) {
+			promises.add(p);
+		}
+		return new AwaitDependenciesInitFragment(promises);
+	}
 
-class RecordIdsPlugin {
 	/**
-	 * @param {Object} options Options object
-	 * @param {boolean=} options.portableIds true, when ids need to be portable
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	constructor(options) {
-		this.options = options || {};
+	getContent({ runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.module);
+		const promises = this.promises;
+		if (promises.size === 0) {
+			return "";
+		}
+		if (promises.size === 1) {
+			for (const p of promises) {
+				return Template.asString([
+					`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
+					`${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
+					""
+				]);
+			}
+		}
+		const sepPromises = Array.from(promises).join(", ");
+		// TODO check if destructuring is supported
+		return Template.asString([
+			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
+			`([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
+			""
+		]);
 	}
+}
+
+module.exports = AwaitDependenciesInitFragment;
+
+
+/***/ }),
+
+/***/ 59498:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const HarmonyImportDependency = __webpack_require__(57154);
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
+class InferAsyncModulesPlugin {
 	/**
-	 * @param {Compiler} compiler the Compiler
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const portableIds = this.options.portableIds;
-
-		const makePathsRelative =
-			identifierUtils.makePathsRelative.bindContextCache(
-				compiler.context,
-				compiler.root
-			);
-
-		/**
-		 * @param {Module} module the module
-		 * @returns {string} the (portable) identifier
-		 */
-		const getModuleIdentifier = module => {
-			if (portableIds) {
-				return makePathsRelative(module.identifier());
-			}
-			return module.identifier();
-		};
-
-		compiler.hooks.compilation.tap("RecordIdsPlugin", compilation => {
-			compilation.hooks.recordModules.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Module[]} modules the modules array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(modules, records) => {
-					const chunkGraph = compilation.chunkGraph;
-					if (!records.modules) records.modules = {};
-					if (!records.modules.byIdentifier) records.modules.byIdentifier = {};
-					/** @type {Set<number>} */
-					const usedIds = new Set();
+		compiler.hooks.compilation.tap("InferAsyncModulesPlugin", compilation => {
+			const { moduleGraph } = compilation;
+			compilation.hooks.finishModules.tap(
+				"InferAsyncModulesPlugin",
+				modules => {
+					/** @type {Set<Module>} */
+					const queue = new Set();
 					for (const module of modules) {
-						const moduleId = chunkGraph.getModuleId(module);
-						if (typeof moduleId !== "number") continue;
-						const identifier = getModuleIdentifier(module);
-						records.modules.byIdentifier[identifier] = moduleId;
-						usedIds.add(moduleId);
-					}
-					records.modules.usedIds = Array.from(usedIds).sort(compareNumbers);
-				}
-			);
-			compilation.hooks.reviveModules.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Module[]} modules the modules array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(modules, records) => {
-					if (!records.modules) return;
-					if (records.modules.byIdentifier) {
-						const chunkGraph = compilation.chunkGraph;
-						/** @type {Set<number>} */
-						const usedIds = new Set();
-						for (const module of modules) {
-							const moduleId = chunkGraph.getModuleId(module);
-							if (moduleId !== null) continue;
-							const identifier = getModuleIdentifier(module);
-							const id = records.modules.byIdentifier[identifier];
-							if (id === undefined) continue;
-							if (usedIds.has(id)) continue;
-							usedIds.add(id);
-							chunkGraph.setModuleId(module, id);
+						if (module.buildMeta && module.buildMeta.async) {
+							queue.add(module);
 						}
 					}
-					if (Array.isArray(records.modules.usedIds)) {
-						compilation.usedModuleIds = new Set(records.modules.usedIds);
+					for (const module of queue) {
+						moduleGraph.setAsync(module);
+						for (const [
+							originModule,
+							connections
+						] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+							if (
+								connections.some(
+									c =>
+										c.dependency instanceof HarmonyImportDependency &&
+										c.isTargetActive(undefined)
+								)
+							) {
+								queue.add(originModule);
+							}
+						}
 					}
 				}
 			);
+		});
+	}
+}
 
-			/**
-			 * @param {Chunk} chunk the chunk
-			 * @returns {string[]} sources of the chunk
-			 */
-			const getChunkSources = chunk => {
-				/** @type {string[]} */
-				const sources = [];
-				for (const chunkGroup of chunk.groupsIterable) {
-					const index = chunkGroup.chunks.indexOf(chunk);
-					if (chunkGroup.name) {
-						sources.push(`${index} ${chunkGroup.name}`);
-					} else {
-						for (const origin of chunkGroup.origins) {
-							if (origin.module) {
-								if (origin.request) {
-									sources.push(
-										`${index} ${getModuleIdentifier(origin.module)} ${
-											origin.request
-										}`
-									);
-								} else if (typeof origin.loc === "string") {
-									sources.push(
-										`${index} ${getModuleIdentifier(origin.module)} ${
-											origin.loc
-										}`
-									);
-								} else if (
-									origin.loc &&
-									typeof origin.loc === "object" &&
-									"start" in origin.loc
-								) {
-									sources.push(
-										`${index} ${getModuleIdentifier(
-											origin.module
-										)} ${JSON.stringify(origin.loc.start)}`
-									);
-								}
-							}
-						}
-					}
-				}
-				return sources;
-			};
-
-			compilation.hooks.recordChunks.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Chunk[]} chunks the chunks array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(chunks, records) => {
-					if (!records.chunks) records.chunks = {};
-					if (!records.chunks.byName) records.chunks.byName = {};
-					if (!records.chunks.bySource) records.chunks.bySource = {};
-					/** @type {Set<number>} */
-					const usedIds = new Set();
-					for (const chunk of chunks) {
-						if (typeof chunk.id !== "number") continue;
-						const name = chunk.name;
-						if (name) records.chunks.byName[name] = chunk.id;
-						const sources = getChunkSources(chunk);
-						for (const source of sources) {
-							records.chunks.bySource[source] = chunk.id;
-						}
-						usedIds.add(chunk.id);
-					}
-					records.chunks.usedIds = Array.from(usedIds).sort(compareNumbers);
-				}
-			);
-			compilation.hooks.reviveChunks.tap(
-				"RecordIdsPlugin",
-				/**
-				 * @param {Chunk[]} chunks the chunks array
-				 * @param {Records} records the records object
-				 * @returns {void}
-				 */
-				(chunks, records) => {
-					if (!records.chunks) return;
-					/** @type {Set<number>} */
-					const usedIds = new Set();
-					if (records.chunks.byName) {
-						for (const chunk of chunks) {
-							if (chunk.id !== null) continue;
-							if (!chunk.name) continue;
-							const id = records.chunks.byName[chunk.name];
-							if (id === undefined) continue;
-							if (usedIds.has(id)) continue;
-							usedIds.add(id);
-							chunk.id = id;
-							chunk.ids = [id];
-						}
-					}
-					if (records.chunks.bySource) {
-						for (const chunk of chunks) {
-							if (chunk.id !== null) continue;
-							const sources = getChunkSources(chunk);
-							for (const source of sources) {
-								const id = records.chunks.bySource[source];
-								if (id === undefined) continue;
-								if (usedIds.has(id)) continue;
-								usedIds.add(id);
-								chunk.id = id;
-								chunk.ids = [id];
-								break;
-							}
-						}
-					}
-					if (Array.isArray(records.chunks.usedIds)) {
-						compilation.usedChunkIds = new Set(records.chunks.usedIds);
-					}
-				}
-			);
-		});
-	}
-}
-module.exports = RecordIdsPlugin;
+module.exports = InferAsyncModulesPlugin;
 
 
 /***/ }),
 
-/***/ 73406:
+/***/ 79233:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -59528,672 +59203,1406 @@ module.exports = RecordIdsPlugin;
 
 
 
-const { contextify } = __webpack_require__(82186);
+const AsyncDependencyToInitialChunkError = __webpack_require__(30111);
+const { connectChunkGroupParentAndChild } = __webpack_require__(37234);
+const ModuleGraphConnection = __webpack_require__(40639);
+const { getEntryRuntime, mergeRuntime } = __webpack_require__(17156);
 
-class RequestShortener {
-	/**
-	 * @param {string} dir the directory
-	 * @param {object=} associatedObjectForCache an object to which the cache will be attached
-	 */
-	constructor(dir, associatedObjectForCache) {
-		this.contextify = contextify.bindContextCache(
-			dir,
-			associatedObjectForCache
-		);
-	}
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
+/** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Entrypoint")} Entrypoint */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-	/**
-	 * @param {string | undefined | null} request the request to shorten
-	 * @returns {string | undefined | null} the shortened request
-	 */
-	shorten(request) {
-		if (!request) {
-			return request;
-		}
-		return this.contextify(request);
-	}
-}
+/**
+ * @typedef {Object} QueueItem
+ * @property {number} action
+ * @property {DependenciesBlock} block
+ * @property {Module} module
+ * @property {Chunk} chunk
+ * @property {ChunkGroup} chunkGroup
+ * @property {ChunkGroupInfo} chunkGroupInfo
+ */
 
-module.exports = RequestShortener;
+/** @typedef {Set<Module> & { plus: Set<Module> }} ModuleSetPlus */
 
+/**
+ * @typedef {Object} ChunkGroupInfo
+ * @property {ChunkGroup} chunkGroup the chunk group
+ * @property {RuntimeSpec} runtime the runtimes
+ * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
+ * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
+ * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
+ * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
+ * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
+ * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
+ * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
+ * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
+ * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
+ * @property {number} preOrderIndex next pre order index
+ * @property {number} postOrderIndex next post order index
+ * @property {boolean} chunkLoading has a chunk loading mechanism
+ * @property {boolean} asyncChunks create async chunks
+ */
 
-/***/ }),
+/**
+ * @typedef {Object} BlockChunkGroupConnection
+ * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group
+ * @property {ChunkGroup} chunkGroup referenced chunk group
+ */
 
-/***/ 88846:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const EMPTY_SET = /** @type {ModuleSetPlus} */ (new Set());
+EMPTY_SET.plus = EMPTY_SET;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {ModuleSetPlus} a first set
+ * @param {ModuleSetPlus} b second set
+ * @returns {number} cmp
+ */
+const bySetSize = (a, b) => {
+	return b.size + b.plus.size - a.size - a.plus.size;
+};
 
+const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	let blockCache;
+	let modules;
 
+	const arrays = [];
 
-const RuntimeGlobals = __webpack_require__(16475);
-const ConstDependency = __webpack_require__(76911);
-const {
-	toConstantDependency
-} = __webpack_require__(93998);
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = queue.pop();
+		const arr = [];
+		arrays.push(arr);
+		blockModulesMap.set(block, arr);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
+	}
 
-/** @typedef {import("./Compiler")} Compiler */
+	for (const connection of moduleGraph.getOutgoingConnections(module)) {
+		const d = connection.dependency;
+		// We skip connections without dependency
+		if (!d) continue;
+		const m = connection.module;
+		// We skip connections without Module pointer
+		if (!m) continue;
+		// We skip weak connections
+		if (connection.weak) continue;
+		const state = connection.getActiveState(runtime);
+		// We skip inactive connections
+		if (state === false) continue;
 
-module.exports = class RequireJsStuffPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireJsStuffPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					ConstDependency,
-					new ConstDependency.Template()
-				);
-				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.requireJs === undefined ||
-						!parserOptions.requireJs
-					) {
-						return;
-					}
+		const block = moduleGraph.getParentBlock(d);
+		let index = moduleGraph.getParentBlockIndex(d);
 
-					parser.hooks.call
-						.for("require.config")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(parser, "undefined")
-						);
-					parser.hooks.call
-						.for("requirejs.config")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(parser, "undefined")
-						);
+		// deprecated fallback
+		if (index < 0) {
+			index = block.dependencies.indexOf(d);
+		}
 
-					parser.hooks.expression
-						.for("require.version")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(parser, JSON.stringify("0.0.0"))
-						);
-					parser.hooks.expression
-						.for("requirejs.onError")
-						.tap(
-							"RequireJsStuffPlugin",
-							toConstantDependency(
-								parser,
-								RuntimeGlobals.uncaughtErrorHandler,
-								[RuntimeGlobals.uncaughtErrorHandler]
-							)
+		if (blockCache !== block) {
+			modules = blockModulesMap.get((blockCache = block));
+		}
+
+		const i = index << 2;
+		modules[i] = m;
+		modules[i + 1] = state;
+	}
+
+	for (const modules of arrays) {
+		if (modules.length === 0) continue;
+		let indexMap;
+		let length = 0;
+		outer: for (let j = 0; j < modules.length; j += 2) {
+			const m = modules[j];
+			if (m === undefined) continue;
+			const state = modules[j + 1];
+			if (indexMap === undefined) {
+				let i = 0;
+				for (; i < length; i += 2) {
+					if (modules[i] === m) {
+						const merged = modules[i + 1];
+						if (merged === true) continue outer;
+						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
+							merged,
+							state
 						);
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireJsStuffPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireJsStuffPlugin", handler);
+					}
+				}
+				modules[length] = m;
+				length++;
+				modules[length] = state;
+				length++;
+				if (length > 30) {
+					// To avoid worse case performance, we will use an index map for
+					// linear cost access, which allows to maintain O(n) complexity
+					// while keeping allocations down to a minimum
+					indexMap = new Map();
+					for (let i = 0; i < length; i += 2) {
+						indexMap.set(modules[i], i + 1);
+					}
+				}
+			} else {
+				const idx = indexMap.get(m);
+				if (idx !== undefined) {
+					const merged = modules[idx];
+					if (merged === true) continue outer;
+					modules[idx] = ModuleGraphConnection.addConnectionStates(
+						merged,
+						state
+					);
+				} else {
+					modules[length] = m;
+					length++;
+					modules[length] = state;
+					indexMap.set(m, length);
+					length++;
+				}
 			}
-		);
+		}
+		modules.length = length;
 	}
 };
 
+/**
+ *
+ * @param {Logger} logger a logger
+ * @param {Compilation} compilation the compilation
+ * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
+ * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
+ * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {Set<ChunkGroup>} allCreatedChunkGroups filled with all chunk groups that are created here
+ */
+const visitModules = (
+	logger,
+	compilation,
+	inputEntrypointsAndModules,
+	chunkGroupInfoMap,
+	blockConnections,
+	blocksWithNestedBlocks,
+	allCreatedChunkGroups
+) => {
+	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
-/***/ }),
-
-/***/ 30217:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	const blockModulesRuntimeMap = new Map();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/** @type {RuntimeSpec | false} */
+	let blockModulesMapRuntime = false;
+	let blockModulesMap;
 
+	/**
+	 *
+	 * @param {DependenciesBlock} block block
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 */
+	const getBlockModules = (block, runtime) => {
+		if (blockModulesMapRuntime !== runtime) {
+			blockModulesMap = blockModulesRuntimeMap.get(runtime);
+			if (blockModulesMap === undefined) {
+				blockModulesMap = new Map();
+				blockModulesRuntimeMap.set(runtime, blockModulesMap);
+			}
+		}
+		let blockModules = blockModulesMap.get(block);
+		if (blockModules !== undefined) return blockModules;
+		const module = /** @type {Module} */ (block.getRootBlock());
+		const memCache = moduleMemCaches && moduleMemCaches.get(module);
+		if (memCache !== undefined) {
+			const map = memCache.provide(
+				"bundleChunkGraph.blockModules",
+				runtime,
+				() => {
+					logger.time("visitModules: prepare");
+					const map = new Map();
+					extractBlockModules(module, moduleGraph, runtime, map);
+					logger.timeAggregate("visitModules: prepare");
+					return map;
+				}
+			);
+			for (const [block, blockModules] of map)
+				blockModulesMap.set(block, blockModules);
+			return map.get(block);
+		} else {
+			logger.time("visitModules: prepare");
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			blockModules = blockModulesMap.get(block);
+			logger.timeAggregate("visitModules: prepare");
+			return blockModules;
+		}
+	};
 
+	let statProcessedQueueItems = 0;
+	let statProcessedBlocks = 0;
+	let statConnectedChunkGroups = 0;
+	let statProcessedChunkGroupsForMerging = 0;
+	let statMergedAvailableModuleSets = 0;
+	let statForkedAvailableModules = 0;
+	let statForkedAvailableModulesCount = 0;
+	let statForkedAvailableModulesCountPlus = 0;
+	let statForkedMergedModulesCount = 0;
+	let statForkedMergedModulesCountPlus = 0;
+	let statForkedResultModulesCount = 0;
+	let statChunkGroupInfoUpdated = 0;
+	let statChildChunkGroupsReconnected = 0;
 
-const Factory = (__webpack_require__(30662).ResolverFactory);
-const { HookMap, SyncHook, SyncWaterfallHook } = __webpack_require__(41242);
-const {
-	cachedCleverMerge,
-	removeOperations,
-	resolveByProperty
-} = __webpack_require__(60839);
+	let nextChunkGroupIndex = 0;
+	let nextFreeModulePreOrderIndex = 0;
+	let nextFreeModulePostOrderIndex = 0;
 
-/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */
-/** @typedef {import("enhanced-resolve").Resolver} Resolver */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} WebpackResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
+	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
+	const blockChunkGroups = new Map();
 
-/** @typedef {WebpackResolveOptions & {dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
-/**
- * @typedef {Object} WithOptions
- * @property {function(Partial<ResolveOptionsWithDependencyType>): ResolverWithOptions} withOptions create a resolver with additional/different options
- */
+	/** @type {Map<string, ChunkGroupInfo>} */
+	const namedChunkGroups = new Map();
 
-/** @typedef {Resolver & WithOptions} ResolverWithOptions */
+	/** @type {Map<string, ChunkGroupInfo>} */
+	const namedAsyncEntrypoints = new Map();
 
-// need to be hoisted on module level for caching identity
-const EMPTY_RESOLVE_OPTIONS = {};
+	const ADD_AND_ENTER_ENTRY_MODULE = 0;
+	const ADD_AND_ENTER_MODULE = 1;
+	const ENTER_MODULE = 2;
+	const PROCESS_BLOCK = 3;
+	const PROCESS_ENTRY_BLOCK = 4;
+	const LEAVE_MODULE = 5;
 
-/**
- * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType enhanced options
- * @returns {ResolveOptions} merged options
- */
-const convertToResolveOptions = resolveOptionsWithDepType => {
-	const { dependencyType, plugins, ...remaining } = resolveOptionsWithDepType;
+	/** @type {QueueItem[]} */
+	let queue = [];
 
-	// check type compat
-	/** @type {Partial<ResolveOptions>} */
-	const partialOptions = {
-		...remaining,
-		plugins:
-			plugins &&
-			/** @type {ResolvePluginInstance[]} */ (
-				plugins.filter(item => item !== "...")
-			)
-	};
+	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
+	const queueConnect = new Map();
+	/** @type {Set<ChunkGroupInfo>} */
+	const chunkGroupsForCombining = new Set();
 
-	if (!partialOptions.fileSystem) {
-		throw new Error(
-			"fileSystem is missing in resolveOptions, but it's required for enhanced-resolve"
-		);
-	}
-	// These weird types validate that we checked all non-optional properties
-	const options =
-		/** @type {Partial<ResolveOptions> & Pick<ResolveOptions, "fileSystem">} */ (
-			partialOptions
+	// Fill queue with entrypoint modules
+	// Create ChunkGroupInfo for entrypoints
+	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
+		const runtime = getEntryRuntime(
+			compilation,
+			chunkGroup.name,
+			chunkGroup.options
 		);
-
-	return removeOperations(
-		resolveByProperty(options, "byDependency", dependencyType)
-	);
-};
-
-/**
- * @typedef {Object} ResolverCache
- * @property {WeakMap<Object, ResolverWithOptions>} direct
- * @property {Map<string, ResolverWithOptions>} stringified
- */
-
-module.exports = class ResolverFactory {
-	constructor() {
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncWaterfallHook<[ResolveOptionsWithDependencyType]>>} */
-			resolveOptions: new HookMap(
-				() => new SyncWaterfallHook(["resolveOptions"])
-			),
-			/** @type {HookMap<SyncHook<[Resolver, ResolveOptions, ResolveOptionsWithDependencyType]>>} */
-			resolver: new HookMap(
-				() => new SyncHook(["resolver", "resolveOptions", "userResolveOptions"])
-			)
-		});
-		/** @type {Map<string, ResolverCache>} */
-		this.cache = new Map();
-	}
-
-	/**
-	 * @param {string} type type of resolver
-	 * @param {ResolveOptionsWithDependencyType=} resolveOptions options
-	 * @returns {ResolverWithOptions} the resolver
-	 */
-	get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
-		let typedCaches = this.cache.get(type);
-		if (!typedCaches) {
-			typedCaches = {
-				direct: new WeakMap(),
-				stringified: new Map()
-			};
-			this.cache.set(type, typedCaches);
-		}
-		const cachedResolver = typedCaches.direct.get(resolveOptions);
-		if (cachedResolver) {
-			return cachedResolver;
+		/** @type {ChunkGroupInfo} */
+		const chunkGroupInfo = {
+			chunkGroup,
+			runtime,
+			minAvailableModules: undefined,
+			minAvailableModulesOwned: false,
+			availableModulesToBeMerged: [],
+			skippedItems: undefined,
+			resultingAvailableModules: undefined,
+			children: undefined,
+			availableSources: undefined,
+			availableChildren: undefined,
+			preOrderIndex: 0,
+			postOrderIndex: 0,
+			chunkLoading:
+				chunkGroup.options.chunkLoading !== undefined
+					? chunkGroup.options.chunkLoading !== false
+					: compilation.outputOptions.chunkLoading !== false,
+			asyncChunks:
+				chunkGroup.options.asyncChunks !== undefined
+					? chunkGroup.options.asyncChunks
+					: compilation.outputOptions.asyncChunks !== false
+		};
+		chunkGroup.index = nextChunkGroupIndex++;
+		if (chunkGroup.getNumberOfParents() > 0) {
+			// minAvailableModules for child entrypoints are unknown yet, set to undefined.
+			// This means no module is added until other sets are merged into
+			// this minAvailableModules (by the parent entrypoints)
+			const skippedItems = new Set();
+			for (const module of modules) {
+				skippedItems.add(module);
+			}
+			chunkGroupInfo.skippedItems = skippedItems;
+			chunkGroupsForCombining.add(chunkGroupInfo);
+		} else {
+			// The application may start here: We start with an empty list of available modules
+			chunkGroupInfo.minAvailableModules = EMPTY_SET;
+			const chunk = chunkGroup.getEntrypointChunk();
+			for (const module of modules) {
+				queue.push({
+					action: ADD_AND_ENTER_MODULE,
+					block: module,
+					module,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
+			}
 		}
-		const ident = JSON.stringify(resolveOptions);
-		const resolver = typedCaches.stringified.get(ident);
-		if (resolver) {
-			typedCaches.direct.set(resolveOptions, resolver);
-			return resolver;
+		chunkGroupInfoMap.set(chunkGroup, chunkGroupInfo);
+		if (chunkGroup.name) {
+			namedChunkGroups.set(chunkGroup.name, chunkGroupInfo);
 		}
-		const newResolver = this._create(type, resolveOptions);
-		typedCaches.direct.set(resolveOptions, newResolver);
-		typedCaches.stringified.set(ident, newResolver);
-		return newResolver;
 	}
-
-	/**
-	 * @param {string} type type of resolver
-	 * @param {ResolveOptionsWithDependencyType} resolveOptionsWithDepType options
-	 * @returns {ResolverWithOptions} the resolver
-	 */
-	_create(type, resolveOptionsWithDepType) {
-		/** @type {ResolveOptionsWithDependencyType} */
-		const originalResolveOptions = { ...resolveOptionsWithDepType };
-
-		const resolveOptions = convertToResolveOptions(
-			this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType)
-		);
-		const resolver = /** @type {ResolverWithOptions} */ (
-			Factory.createResolver(resolveOptions)
-		);
-		if (!resolver) {
-			throw new Error("No resolver created");
+	// Fill availableSources with parent-child dependencies between entrypoints
+	for (const chunkGroupInfo of chunkGroupsForCombining) {
+		const { chunkGroup } = chunkGroupInfo;
+		chunkGroupInfo.availableSources = new Set();
+		for (const parent of chunkGroup.parentsIterable) {
+			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
+			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
+			if (parentChunkGroupInfo.availableChildren === undefined) {
+				parentChunkGroupInfo.availableChildren = new Set();
+			}
+			parentChunkGroupInfo.availableChildren.add(chunkGroupInfo);
 		}
-		/** @type {WeakMap<Partial<ResolveOptionsWithDependencyType>, ResolverWithOptions>} */
-		const childCache = new WeakMap();
-		resolver.withOptions = options => {
-			const cacheEntry = childCache.get(options);
-			if (cacheEntry !== undefined) return cacheEntry;
-			const mergedOptions = cachedCleverMerge(originalResolveOptions, options);
-			const resolver = this.get(type, mergedOptions);
-			childCache.set(options, resolver);
-			return resolver;
-		};
-		this.hooks.resolver
-			.for(type)
-			.call(resolver, resolveOptions, originalResolveOptions);
-		return resolver;
 	}
-};
+	// pop() is used to read from the queue
+	// so it need to be reversed to be iterated in
+	// correct order
+	queue.reverse();
 
+	/** @type {Set<ChunkGroupInfo>} */
+	const outdatedChunkGroupInfo = new Set();
+	/** @type {Set<ChunkGroupInfo>} */
+	const chunkGroupsForMerging = new Set();
+	/** @type {QueueItem[]} */
+	let queueDelayed = [];
 
-/***/ }),
+	/** @type {[Module, ConnectionState][]} */
+	const skipConnectionBuffer = [];
+	/** @type {Module[]} */
+	const skipBuffer = [];
+	/** @type {QueueItem[]} */
+	const queueBuffer = [];
 
-/***/ 16475:
-/***/ (function(__unused_webpack_module, exports) {
+	/** @type {Module} */
+	let module;
+	/** @type {Chunk} */
+	let chunk;
+	/** @type {ChunkGroup} */
+	let chunkGroup;
+	/** @type {DependenciesBlock} */
+	let block;
+	/** @type {ChunkGroupInfo} */
+	let chunkGroupInfo;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	// For each async Block in graph
+	/**
+	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
+	 * @returns {void}
+	 */
+	const iteratorBlock = b => {
+		// 1. We create a chunk group with single chunk in it for this Block
+		// but only once (blockChunkGroups map)
+		let cgi = blockChunkGroups.get(b);
+		/** @type {ChunkGroup} */
+		let c;
+		/** @type {Entrypoint} */
+		let entrypoint;
+		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
+		if (cgi === undefined) {
+			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
+			if (entryOptions) {
+				cgi = namedAsyncEntrypoints.get(chunkName);
+				if (!cgi) {
+					entrypoint = compilation.addAsyncEntrypoint(
+						entryOptions,
+						module,
+						b.loc,
+						b.request
+					);
+					entrypoint.index = nextChunkGroupIndex++;
+					cgi = {
+						chunkGroup: entrypoint,
+						runtime: entrypoint.options.runtime || entrypoint.name,
+						minAvailableModules: EMPTY_SET,
+						minAvailableModulesOwned: false,
+						availableModulesToBeMerged: [],
+						skippedItems: undefined,
+						resultingAvailableModules: undefined,
+						children: undefined,
+						availableSources: undefined,
+						availableChildren: undefined,
+						preOrderIndex: 0,
+						postOrderIndex: 0,
+						chunkLoading:
+							entryOptions.chunkLoading !== undefined
+								? entryOptions.chunkLoading !== false
+								: chunkGroupInfo.chunkLoading,
+						asyncChunks:
+							entryOptions.asyncChunks !== undefined
+								? entryOptions.asyncChunks
+								: chunkGroupInfo.asyncChunks
+					};
+					chunkGroupInfoMap.set(entrypoint, cgi);
 
+					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
+					if (chunkName) {
+						namedAsyncEntrypoints.set(chunkName, cgi);
+					}
+				} else {
+					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
+					// TODO merge entryOptions
+					entrypoint.addOrigin(module, b.loc, b.request);
+					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
+				}
 
+				// 2. We enqueue the DependenciesBlock for traversal
+				queueDelayed.push({
+					action: PROCESS_ENTRY_BLOCK,
+					block: b,
+					module: module,
+					chunk: entrypoint.chunks[0],
+					chunkGroup: entrypoint,
+					chunkGroupInfo: cgi
+				});
+			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
+				// Just queue the block into the current chunk group
+				queue.push({
+					action: PROCESS_BLOCK,
+					block: b,
+					module: module,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
+			} else {
+				cgi = chunkName && namedChunkGroups.get(chunkName);
+				if (!cgi) {
+					c = compilation.addChunkInGroup(
+						b.groupOptions || b.chunkName,
+						module,
+						b.loc,
+						b.request
+					);
+					c.index = nextChunkGroupIndex++;
+					cgi = {
+						chunkGroup: c,
+						runtime: chunkGroupInfo.runtime,
+						minAvailableModules: undefined,
+						minAvailableModulesOwned: undefined,
+						availableModulesToBeMerged: [],
+						skippedItems: undefined,
+						resultingAvailableModules: undefined,
+						children: undefined,
+						availableSources: undefined,
+						availableChildren: undefined,
+						preOrderIndex: 0,
+						postOrderIndex: 0,
+						chunkLoading: chunkGroupInfo.chunkLoading,
+						asyncChunks: chunkGroupInfo.asyncChunks
+					};
+					allCreatedChunkGroups.add(c);
+					chunkGroupInfoMap.set(c, cgi);
+					if (chunkName) {
+						namedChunkGroups.set(chunkName, cgi);
+					}
+				} else {
+					c = cgi.chunkGroup;
+					if (c.isInitial()) {
+						compilation.errors.push(
+							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
+						);
+						c = chunkGroup;
+					}
+					c.addOptions(b.groupOptions);
+					c.addOrigin(module, b.loc, b.request);
+				}
+				blockConnections.set(b, []);
+			}
+			blockChunkGroups.set(b, cgi);
+		} else if (entryOptions) {
+			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
+		} else {
+			c = cgi.chunkGroup;
+		}
 
-/**
- * the internal require function
- */
-exports.require = "__webpack_require__";
+		if (c !== undefined) {
+			// 2. We store the connection for the block
+			// to connect it later if needed
+			blockConnections.get(b).push({
+				originChunkGroupInfo: chunkGroupInfo,
+				chunkGroup: c
+			});
 
-/**
- * access to properties of the internal require function/object
- */
-exports.requireScope = "__webpack_require__.*";
+			// 3. We enqueue the chunk group info creation/updating
+			let connectList = queueConnect.get(chunkGroupInfo);
+			if (connectList === undefined) {
+				connectList = new Set();
+				queueConnect.set(chunkGroupInfo, connectList);
+			}
+			connectList.add(cgi);
 
-/**
- * the internal exports object
- */
-exports.exports = "__webpack_exports__";
+			// TODO check if this really need to be done for each traversal
+			// or if it is enough when it's queued when created
+			// 4. We enqueue the DependenciesBlock for traversal
+			queueDelayed.push({
+				action: PROCESS_BLOCK,
+				block: b,
+				module: module,
+				chunk: c.chunks[0],
+				chunkGroup: c,
+				chunkGroupInfo: cgi
+			});
+		} else if (entrypoint !== undefined) {
+			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
+		}
+	};
 
-/**
- * top-level this need to be the exports object
- */
-exports.thisAsExports = "top-level-this-exports";
+	/**
+	 * @param {DependenciesBlock} block the block
+	 * @returns {void}
+	 */
+	const processBlock = block => {
+		statProcessedBlocks++;
+		// get prepared block info
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
-/**
- * runtime need to return the exports of the last entry module
- */
-exports.returnExportsFromRuntime = "return-exports-from-runtime";
+		if (blockModules !== undefined) {
+			const { minAvailableModules } = chunkGroupInfo;
+			// Buffer items because order need to be reversed to get indices correct
+			// Traverse all referenced modules
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
+					// skip early if already connected
+					continue;
+				}
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
+				if (activeState !== true) {
+					skipConnectionBuffer.push([refModule, activeState]);
+					if (activeState === false) continue;
+				}
+				if (
+					activeState === true &&
+					(minAvailableModules.has(refModule) ||
+						minAvailableModules.plus.has(refModule))
+				) {
+					// already in parent chunks, skip it for now
+					skipBuffer.push(refModule);
+					continue;
+				}
+				// enqueue, then add and enter to be in the correct order
+				// this is relevant with circular dependencies
+				queueBuffer.push({
+					action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
+					block: refModule,
+					module: refModule,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
+			}
+			// Add buffered items in reverse order
+			if (skipConnectionBuffer.length > 0) {
+				let { skippedModuleConnections } = chunkGroupInfo;
+				if (skippedModuleConnections === undefined) {
+					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections =
+						new Set();
+				}
+				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
+					skippedModuleConnections.add(skipConnectionBuffer[i]);
+				}
+				skipConnectionBuffer.length = 0;
+			}
+			if (skipBuffer.length > 0) {
+				let { skippedItems } = chunkGroupInfo;
+				if (skippedItems === undefined) {
+					chunkGroupInfo.skippedItems = skippedItems = new Set();
+				}
+				for (let i = skipBuffer.length - 1; i >= 0; i--) {
+					skippedItems.add(skipBuffer[i]);
+				}
+				skipBuffer.length = 0;
+			}
+			if (queueBuffer.length > 0) {
+				for (let i = queueBuffer.length - 1; i >= 0; i--) {
+					queue.push(queueBuffer[i]);
+				}
+				queueBuffer.length = 0;
+			}
+		}
 
-/**
- * the internal module object
- */
-exports.module = "module";
+		// Traverse all Blocks
+		for (const b of block.blocks) {
+			iteratorBlock(b);
+		}
 
-/**
- * the internal module object
- */
-exports.moduleId = "module.id";
+		if (block.blocks.length > 0 && module !== block) {
+			blocksWithNestedBlocks.add(block);
+		}
+	};
 
-/**
- * the internal module object
- */
-exports.moduleLoaded = "module.loaded";
+	/**
+	 * @param {DependenciesBlock} block the block
+	 * @returns {void}
+	 */
+	const processEntryBlock = block => {
+		statProcessedBlocks++;
+		// get prepared block info
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
-/**
- * the bundle public path
- */
-exports.publicPath = "__webpack_require__.p";
+		if (blockModules !== undefined) {
+			// Traverse all referenced modules
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
+				// enqueue, then add and enter to be in the correct order
+				// this is relevant with circular dependencies
+				queueBuffer.push({
+					action:
+						activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK,
+					block: refModule,
+					module: refModule,
+					chunk,
+					chunkGroup,
+					chunkGroupInfo
+				});
+			}
+			// Add buffered items in reverse order
+			if (queueBuffer.length > 0) {
+				for (let i = queueBuffer.length - 1; i >= 0; i--) {
+					queue.push(queueBuffer[i]);
+				}
+				queueBuffer.length = 0;
+			}
+		}
 
-/**
- * the module id of the entry point
- */
-exports.entryModuleId = "__webpack_require__.s";
+		// Traverse all Blocks
+		for (const b of block.blocks) {
+			iteratorBlock(b);
+		}
 
-/**
- * the module cache
- */
-exports.moduleCache = "__webpack_require__.c";
+		if (block.blocks.length > 0 && module !== block) {
+			blocksWithNestedBlocks.add(block);
+		}
+	};
 
-/**
- * the module functions
- */
-exports.moduleFactories = "__webpack_require__.m";
+	const processQueue = () => {
+		while (queue.length) {
+			statProcessedQueueItems++;
+			const queueItem = queue.pop();
+			module = queueItem.module;
+			block = queueItem.block;
+			chunk = queueItem.chunk;
+			chunkGroup = queueItem.chunkGroup;
+			chunkGroupInfo = queueItem.chunkGroupInfo;
 
-/**
- * the module functions, with only write access
- */
-exports.moduleFactoriesAddOnly = "__webpack_require__.m (add only)";
+			switch (queueItem.action) {
+				case ADD_AND_ENTER_ENTRY_MODULE:
+					chunkGraph.connectChunkAndEntryModule(
+						chunk,
+						module,
+						/** @type {Entrypoint} */ (chunkGroup)
+					);
+				// fallthrough
+				case ADD_AND_ENTER_MODULE: {
+					if (chunkGraph.isModuleInChunk(module, chunk)) {
+						// already connected, skip it
+						break;
+					}
+					// We connect Module and Chunk
+					chunkGraph.connectChunkAndModule(chunk, module);
+				}
+				// fallthrough
+				case ENTER_MODULE: {
+					const index = chunkGroup.getModulePreOrderIndex(module);
+					if (index === undefined) {
+						chunkGroup.setModulePreOrderIndex(
+							module,
+							chunkGroupInfo.preOrderIndex++
+						);
+					}
 
-/**
- * the chunk ensure function
- */
-exports.ensureChunk = "__webpack_require__.e";
+					if (
+						moduleGraph.setPreOrderIndexIfUnset(
+							module,
+							nextFreeModulePreOrderIndex
+						)
+					) {
+						nextFreeModulePreOrderIndex++;
+					}
 
-/**
- * an object with handlers to ensure a chunk
- */
-exports.ensureChunkHandlers = "__webpack_require__.f";
+					// reuse queueItem
+					queueItem.action = LEAVE_MODULE;
+					queue.push(queueItem);
+				}
+				// fallthrough
+				case PROCESS_BLOCK: {
+					processBlock(block);
+					break;
+				}
+				case PROCESS_ENTRY_BLOCK: {
+					processEntryBlock(block);
+					break;
+				}
+				case LEAVE_MODULE: {
+					const index = chunkGroup.getModulePostOrderIndex(module);
+					if (index === undefined) {
+						chunkGroup.setModulePostOrderIndex(
+							module,
+							chunkGroupInfo.postOrderIndex++
+						);
+					}
 
-/**
- * a runtime requirement if ensureChunkHandlers should include loading of chunk needed for entries
- */
-exports.ensureChunkIncludeEntries = "__webpack_require__.f (include entries)";
+					if (
+						moduleGraph.setPostOrderIndexIfUnset(
+							module,
+							nextFreeModulePostOrderIndex
+						)
+					) {
+						nextFreeModulePostOrderIndex++;
+					}
+					break;
+				}
+			}
+		}
+	};
 
-/**
- * the chunk prefetch function
- */
-exports.prefetchChunk = "__webpack_require__.E";
+	const calculateResultingAvailableModules = chunkGroupInfo => {
+		if (chunkGroupInfo.resultingAvailableModules)
+			return chunkGroupInfo.resultingAvailableModules;
 
-/**
- * an object with handlers to prefetch a chunk
- */
-exports.prefetchChunkHandlers = "__webpack_require__.F";
+		const minAvailableModules = chunkGroupInfo.minAvailableModules;
 
-/**
- * the chunk preload function
- */
-exports.preloadChunk = "__webpack_require__.G";
+		// Create a new Set of available modules at this point
+		// We want to be as lazy as possible. There are multiple ways doing this:
+		// Note that resultingAvailableModules is stored as "(a) + (b)" as it's a ModuleSetPlus
+		// - resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
+		// - resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
+		// We choose one depending on the size of minAvailableModules vs minAvailableModules.plus
 
-/**
- * an object with handlers to preload a chunk
- */
-exports.preloadChunkHandlers = "__webpack_require__.H";
+		let resultingAvailableModules;
+		if (minAvailableModules.size > minAvailableModules.plus.size) {
+			// resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
+			resultingAvailableModules =
+				/** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
+			for (const module of minAvailableModules.plus)
+				minAvailableModules.add(module);
+			minAvailableModules.plus = EMPTY_SET;
+			resultingAvailableModules.plus = minAvailableModules;
+			chunkGroupInfo.minAvailableModulesOwned = false;
+		} else {
+			// resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
+			resultingAvailableModules =
+				/** @type {Set<Module> & {plus: Set<Module>}} */ (
+					new Set(minAvailableModules)
+				);
+			resultingAvailableModules.plus = minAvailableModules.plus;
+		}
 
-/**
- * the exported property define getters function
- */
-exports.definePropertyGetters = "__webpack_require__.d";
+		// add the modules from the chunk group to the set
+		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
+			for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+				resultingAvailableModules.add(m);
+			}
+		}
+		return (chunkGroupInfo.resultingAvailableModules =
+			resultingAvailableModules);
+	};
 
-/**
- * define compatibility on export
- */
-exports.makeNamespaceObject = "__webpack_require__.r";
+	const processConnectQueue = () => {
+		// Figure out new parents for chunk groups
+		// to get new available modules for these children
+		for (const [chunkGroupInfo, targets] of queueConnect) {
+			// 1. Add new targets to the list of children
+			if (chunkGroupInfo.children === undefined) {
+				chunkGroupInfo.children = targets;
+			} else {
+				for (const target of targets) {
+					chunkGroupInfo.children.add(target);
+				}
+			}
 
-/**
- * create a fake namespace object
- */
-exports.createFakeNamespaceObject = "__webpack_require__.t";
+			// 2. Calculate resulting available modules
+			const resultingAvailableModules =
+				calculateResultingAvailableModules(chunkGroupInfo);
 
-/**
- * compatibility get default export
- */
-exports.compatGetDefaultExport = "__webpack_require__.n";
+			const runtime = chunkGroupInfo.runtime;
 
-/**
- * harmony module decorator
- */
-exports.harmonyModuleDecorator = "__webpack_require__.hmd";
+			// 3. Update chunk group info
+			for (const target of targets) {
+				target.availableModulesToBeMerged.push(resultingAvailableModules);
+				chunkGroupsForMerging.add(target);
+				const oldRuntime = target.runtime;
+				const newRuntime = mergeRuntime(oldRuntime, runtime);
+				if (oldRuntime !== newRuntime) {
+					target.runtime = newRuntime;
+					outdatedChunkGroupInfo.add(target);
+				}
+			}
 
-/**
- * node.js module decorator
- */
-exports.nodeModuleDecorator = "__webpack_require__.nmd";
+			statConnectedChunkGroups += targets.size;
+		}
+		queueConnect.clear();
+	};
 
-/**
- * the webpack hash
- */
-exports.getFullHash = "__webpack_require__.h";
+	const processChunkGroupsForMerging = () => {
+		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
-/**
- * an object containing all installed WebAssembly.Instance export objects keyed by module id
- */
-exports.wasmInstances = "__webpack_require__.w";
+		// Execute the merge
+		for (const info of chunkGroupsForMerging) {
+			const availableModulesToBeMerged = info.availableModulesToBeMerged;
+			let cachedMinAvailableModules = info.minAvailableModules;
 
-/**
- * instantiate a wasm instance from module exports object, id, hash and importsObject
- */
-exports.instantiateWasm = "__webpack_require__.v";
+			statMergedAvailableModuleSets += availableModulesToBeMerged.length;
 
-/**
- * the uncaught error handler for the webpack runtime
- */
-exports.uncaughtErrorHandler = "__webpack_require__.oe";
+			// 1. Get minimal available modules
+			// It doesn't make sense to traverse a chunk again with more available modules.
+			// This step calculates the minimal available modules and skips traversal when
+			// the list didn't shrink.
+			if (availableModulesToBeMerged.length > 1) {
+				availableModulesToBeMerged.sort(bySetSize);
+			}
+			let changed = false;
+			merge: for (const availableModules of availableModulesToBeMerged) {
+				if (cachedMinAvailableModules === undefined) {
+					cachedMinAvailableModules = availableModules;
+					info.minAvailableModules = cachedMinAvailableModules;
+					info.minAvailableModulesOwned = false;
+					changed = true;
+				} else {
+					if (info.minAvailableModulesOwned) {
+						// We own it and can modify it
+						if (cachedMinAvailableModules.plus === availableModules.plus) {
+							for (const m of cachedMinAvailableModules) {
+								if (!availableModules.has(m)) {
+									cachedMinAvailableModules.delete(m);
+									changed = true;
+								}
+							}
+						} else {
+							for (const m of cachedMinAvailableModules) {
+								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+									cachedMinAvailableModules.delete(m);
+									changed = true;
+								}
+							}
+							for (const m of cachedMinAvailableModules.plus) {
+								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+									// We can't remove modules from the plus part
+									// so we need to merge plus into the normal part to allow modifying it
+									const iterator =
+										cachedMinAvailableModules.plus[Symbol.iterator]();
+									// fast forward add all modules until m
+									/** @type {IteratorResult<Module>} */
+									let it;
+									while (!(it = iterator.next()).done) {
+										const module = it.value;
+										if (module === m) break;
+										cachedMinAvailableModules.add(module);
+									}
+									// check the remaining modules before adding
+									while (!(it = iterator.next()).done) {
+										const module = it.value;
+										if (
+											availableModules.has(module) ||
+											availableModules.plus.has(m)
+										) {
+											cachedMinAvailableModules.add(module);
+										}
+									}
+									cachedMinAvailableModules.plus = EMPTY_SET;
+									changed = true;
+									continue merge;
+								}
+							}
+						}
+					} else if (cachedMinAvailableModules.plus === availableModules.plus) {
+						// Common and fast case when the plus part is shared
+						// We only need to care about the normal part
+						if (availableModules.size < cachedMinAvailableModules.size) {
+							// the new availableModules is smaller so it's faster to
+							// fork from the new availableModules
+							statForkedAvailableModules++;
+							statForkedAvailableModulesCount += availableModules.size;
+							statForkedMergedModulesCount += cachedMinAvailableModules.size;
+							// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+							const newSet = /** @type {ModuleSetPlus} */ (new Set());
+							newSet.plus = availableModules.plus;
+							for (const m of availableModules) {
+								if (cachedMinAvailableModules.has(m)) {
+									newSet.add(m);
+								}
+							}
+							statForkedResultModulesCount += newSet.size;
+							cachedMinAvailableModules = newSet;
+							info.minAvailableModulesOwned = true;
+							info.minAvailableModules = newSet;
+							changed = true;
+							continue merge;
+						}
+						for (const m of cachedMinAvailableModules) {
+							if (!availableModules.has(m)) {
+								// cachedMinAvailableModules need to be modified
+								// but we don't own it
+								statForkedAvailableModules++;
+								statForkedAvailableModulesCount +=
+									cachedMinAvailableModules.size;
+								statForkedMergedModulesCount += availableModules.size;
+								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+								// as the plus part is equal we can just take over this one
+								const newSet = /** @type {ModuleSetPlus} */ (new Set());
+								newSet.plus = availableModules.plus;
+								const iterator = cachedMinAvailableModules[Symbol.iterator]();
+								// fast forward add all modules until m
+								/** @type {IteratorResult<Module>} */
+								let it;
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (module === m) break;
+									newSet.add(module);
+								}
+								// check the remaining modules before adding
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (availableModules.has(module)) {
+										newSet.add(module);
+									}
+								}
+								statForkedResultModulesCount += newSet.size;
+								cachedMinAvailableModules = newSet;
+								info.minAvailableModulesOwned = true;
+								info.minAvailableModules = newSet;
+								changed = true;
+								continue merge;
+							}
+						}
+					} else {
+						for (const m of cachedMinAvailableModules) {
+							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+								// cachedMinAvailableModules need to be modified
+								// but we don't own it
+								statForkedAvailableModules++;
+								statForkedAvailableModulesCount +=
+									cachedMinAvailableModules.size;
+								statForkedAvailableModulesCountPlus +=
+									cachedMinAvailableModules.plus.size;
+								statForkedMergedModulesCount += availableModules.size;
+								statForkedMergedModulesCountPlus += availableModules.plus.size;
+								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+								const newSet = /** @type {ModuleSetPlus} */ (new Set());
+								newSet.plus = EMPTY_SET;
+								const iterator = cachedMinAvailableModules[Symbol.iterator]();
+								// fast forward add all modules until m
+								/** @type {IteratorResult<Module>} */
+								let it;
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (module === m) break;
+									newSet.add(module);
+								}
+								// check the remaining modules before adding
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (
+										availableModules.has(module) ||
+										availableModules.plus.has(module)
+									) {
+										newSet.add(module);
+									}
+								}
+								// also check all modules in cachedMinAvailableModules.plus
+								for (const module of cachedMinAvailableModules.plus) {
+									if (
+										availableModules.has(module) ||
+										availableModules.plus.has(module)
+									) {
+										newSet.add(module);
+									}
+								}
+								statForkedResultModulesCount += newSet.size;
+								cachedMinAvailableModules = newSet;
+								info.minAvailableModulesOwned = true;
+								info.minAvailableModules = newSet;
+								changed = true;
+								continue merge;
+							}
+						}
+						for (const m of cachedMinAvailableModules.plus) {
+							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
+								// cachedMinAvailableModules need to be modified
+								// but we don't own it
+								statForkedAvailableModules++;
+								statForkedAvailableModulesCount +=
+									cachedMinAvailableModules.size;
+								statForkedAvailableModulesCountPlus +=
+									cachedMinAvailableModules.plus.size;
+								statForkedMergedModulesCount += availableModules.size;
+								statForkedMergedModulesCountPlus += availableModules.plus.size;
+								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
+								// we already know that all modules directly from cachedMinAvailableModules are in availableModules too
+								const newSet = /** @type {ModuleSetPlus} */ (
+									new Set(cachedMinAvailableModules)
+								);
+								newSet.plus = EMPTY_SET;
+								const iterator =
+									cachedMinAvailableModules.plus[Symbol.iterator]();
+								// fast forward add all modules until m
+								/** @type {IteratorResult<Module>} */
+								let it;
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (module === m) break;
+									newSet.add(module);
+								}
+								// check the remaining modules before adding
+								while (!(it = iterator.next()).done) {
+									const module = it.value;
+									if (
+										availableModules.has(module) ||
+										availableModules.plus.has(module)
+									) {
+										newSet.add(module);
+									}
+								}
+								statForkedResultModulesCount += newSet.size;
+								cachedMinAvailableModules = newSet;
+								info.minAvailableModulesOwned = true;
+								info.minAvailableModules = newSet;
+								changed = true;
+								continue merge;
+							}
+						}
+					}
+				}
+			}
+			availableModulesToBeMerged.length = 0;
+			if (changed) {
+				info.resultingAvailableModules = undefined;
+				outdatedChunkGroupInfo.add(info);
+			}
+		}
+		chunkGroupsForMerging.clear();
+	};
 
-/**
- * the script nonce
- */
-exports.scriptNonce = "__webpack_require__.nc";
+	const processChunkGroupsForCombining = () => {
+		for (const info of chunkGroupsForCombining) {
+			for (const source of info.availableSources) {
+				if (!source.minAvailableModules) {
+					chunkGroupsForCombining.delete(info);
+					break;
+				}
+			}
+		}
+		for (const info of chunkGroupsForCombining) {
+			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
+			availableModules.plus = EMPTY_SET;
+			const mergeSet = set => {
+				if (set.size > availableModules.plus.size) {
+					for (const item of availableModules.plus) availableModules.add(item);
+					availableModules.plus = set;
+				} else {
+					for (const item of set) availableModules.add(item);
+				}
+			};
+			// combine minAvailableModules from all resultingAvailableModules
+			for (const source of info.availableSources) {
+				const resultingAvailableModules =
+					calculateResultingAvailableModules(source);
+				mergeSet(resultingAvailableModules);
+				mergeSet(resultingAvailableModules.plus);
+			}
+			info.minAvailableModules = availableModules;
+			info.minAvailableModulesOwned = false;
+			info.resultingAvailableModules = undefined;
+			outdatedChunkGroupInfo.add(info);
+		}
+		chunkGroupsForCombining.clear();
+	};
 
-/**
- * function to load a script tag.
- * Arguments: (url: string, done: (event) => void), key?: string | number, chunkId?: string | number) => void
- * done function is called when loading has finished or timeout occurred.
- * It will attach to existing script tags with data-webpack == uniqueName + ":" + key or src == url.
- */
-exports.loadScript = "__webpack_require__.l";
+	const processOutdatedChunkGroupInfo = () => {
+		statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
+		// Revisit skipped elements
+		for (const info of outdatedChunkGroupInfo) {
+			// 1. Reconsider skipped items
+			if (info.skippedItems !== undefined) {
+				const { minAvailableModules } = info;
+				for (const module of info.skippedItems) {
+					if (
+						!minAvailableModules.has(module) &&
+						!minAvailableModules.plus.has(module)
+					) {
+						queue.push({
+							action: ADD_AND_ENTER_MODULE,
+							block: module,
+							module,
+							chunk: info.chunkGroup.chunks[0],
+							chunkGroup: info.chunkGroup,
+							chunkGroupInfo: info
+						});
+						info.skippedItems.delete(module);
+					}
+				}
+			}
 
-/**
- * function to promote a string to a TrustedScript using webpack's Trusted
- * Types policy
- * Arguments: (script: string) => TrustedScript
- */
-exports.createScript = "__webpack_require__.ts";
-
-/**
- * function to promote a string to a TrustedScriptURL using webpack's Trusted
- * Types policy
- * Arguments: (url: string) => TrustedScriptURL
- */
-exports.createScriptUrl = "__webpack_require__.tu";
-
-/**
- * function to return webpack's Trusted Types policy
- * Arguments: () => TrustedTypePolicy
- */
-exports.getTrustedTypesPolicy = "__webpack_require__.tt";
-
-/**
- * the chunk name of the chunk with the runtime
- */
-exports.chunkName = "__webpack_require__.cn";
-
-/**
- * the runtime id of the current runtime
- */
-exports.runtimeId = "__webpack_require__.j";
-
-/**
- * the filename of the script part of the chunk
- */
-exports.getChunkScriptFilename = "__webpack_require__.u";
+			// 2. Reconsider skipped connections
+			if (info.skippedModuleConnections !== undefined) {
+				const { minAvailableModules } = info;
+				for (const entry of info.skippedModuleConnections) {
+					const [module, activeState] = entry;
+					if (activeState === false) continue;
+					if (activeState === true) {
+						info.skippedModuleConnections.delete(entry);
+					}
+					if (
+						activeState === true &&
+						(minAvailableModules.has(module) ||
+							minAvailableModules.plus.has(module))
+					) {
+						info.skippedItems.add(module);
+						continue;
+					}
+					queue.push({
+						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
+						block: module,
+						module,
+						chunk: info.chunkGroup.chunks[0],
+						chunkGroup: info.chunkGroup,
+						chunkGroupInfo: info
+					});
+				}
+			}
 
-/**
- * the filename of the css part of the chunk
- */
-exports.getChunkCssFilename = "__webpack_require__.k";
+			// 2. Reconsider children chunk groups
+			if (info.children !== undefined) {
+				statChildChunkGroupsReconnected += info.children.size;
+				for (const cgi of info.children) {
+					let connectList = queueConnect.get(info);
+					if (connectList === undefined) {
+						connectList = new Set();
+						queueConnect.set(info, connectList);
+					}
+					connectList.add(cgi);
+				}
+			}
 
-/**
- * a flag when a module/chunk/tree has css modules
- */
-exports.hasCssModules = "has css modules";
+			// 3. Reconsider chunk groups for combining
+			if (info.availableChildren !== undefined) {
+				for (const cgi of info.availableChildren) {
+					chunkGroupsForCombining.add(cgi);
+				}
+			}
+		}
+		outdatedChunkGroupInfo.clear();
+	};
 
-/**
- * the filename of the script part of the hot update chunk
- */
-exports.getChunkUpdateScriptFilename = "__webpack_require__.hu";
+	// Iterative traversal of the Module graph
+	// Recursive would be simpler to write but could result in Stack Overflows
+	while (queue.length || queueConnect.size) {
+		logger.time("visitModules: visiting");
+		processQueue();
+		logger.timeAggregateEnd("visitModules: prepare");
+		logger.timeEnd("visitModules: visiting");
 
-/**
- * the filename of the css part of the hot update chunk
- */
-exports.getChunkUpdateCssFilename = "__webpack_require__.hk";
+		if (chunkGroupsForCombining.size > 0) {
+			logger.time("visitModules: combine available modules");
+			processChunkGroupsForCombining();
+			logger.timeEnd("visitModules: combine available modules");
+		}
 
-/**
- * startup signal from runtime
- * This will be called when the runtime chunk has been loaded.
- */
-exports.startup = "__webpack_require__.x";
+		if (queueConnect.size > 0) {
+			logger.time("visitModules: calculating available modules");
+			processConnectQueue();
+			logger.timeEnd("visitModules: calculating available modules");
 
-/**
- * @deprecated
- * creating a default startup function with the entry modules
- */
-exports.startupNoDefault = "__webpack_require__.x (no default handler)";
+			if (chunkGroupsForMerging.size > 0) {
+				logger.time("visitModules: merging available modules");
+				processChunkGroupsForMerging();
+				logger.timeEnd("visitModules: merging available modules");
+			}
+		}
 
-/**
- * startup signal from runtime but only used to add logic after the startup
- */
-exports.startupOnlyAfter = "__webpack_require__.x (only after)";
+		if (outdatedChunkGroupInfo.size > 0) {
+			logger.time("visitModules: check modules for revisit");
+			processOutdatedChunkGroupInfo();
+			logger.timeEnd("visitModules: check modules for revisit");
+		}
 
-/**
- * startup signal from runtime but only used to add sync logic before the startup
- */
-exports.startupOnlyBefore = "__webpack_require__.x (only before)";
+		// Run queueDelayed when all items of the queue are processed
+		// This is important to get the global indexing correct
+		// Async blocks should be processed after all sync blocks are processed
+		if (queue.length === 0) {
+			const tempQueue = queue;
+			queue = queueDelayed.reverse();
+			queueDelayed = tempQueue;
+		}
+	}
 
-/**
- * global callback functions for installing chunks
- */
-exports.chunkCallback = "webpackChunk";
+	logger.log(
+		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
+	);
+	logger.log(`${statConnectedChunkGroups} chunk groups connected`);
+	logger.log(
+		`${statProcessedChunkGroupsForMerging} chunk groups processed for merging (${statMergedAvailableModuleSets} module sets, ${statForkedAvailableModules} forked, ${statForkedAvailableModulesCount} + ${statForkedAvailableModulesCountPlus} modules forked, ${statForkedMergedModulesCount} + ${statForkedMergedModulesCountPlus} modules merged into fork, ${statForkedResultModulesCount} resulting modules)`
+	);
+	logger.log(
+		`${statChunkGroupInfoUpdated} chunk group info updated (${statChildChunkGroupsReconnected} already connected chunk groups reconnected)`
+	);
+};
 
 /**
- * method to startup an entrypoint with needed chunks.
- * Signature: (moduleId: Id, chunkIds: Id[]) => any.
- * Returns the exports of the module or a Promise
+ *
+ * @param {Compilation} compilation the compilation
+ * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
+ * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
  */
-exports.startupEntrypoint = "__webpack_require__.X";
+const connectChunkGroups = (
+	compilation,
+	blocksWithNestedBlocks,
+	blockConnections,
+	chunkGroupInfoMap
+) => {
+	const { chunkGraph } = compilation;
 
-/**
- * register deferred code, which will run when certain
- * chunks are loaded.
- * Signature: (chunkIds: Id[], fn: () => any, priority: int >= 0 = 0) => any
- * Returned value will be returned directly when all chunks are already loaded
- * When (priority & 1) it will wait for all other handlers with lower priority to
- * be executed before itself is executed
- */
-exports.onChunksLoaded = "__webpack_require__.O";
+	/**
+	 * Helper function to check if all modules of a chunk are available
+	 *
+	 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
+	 * @param {ModuleSetPlus} availableModules the comparator set
+	 * @returns {boolean} return true if all modules of a chunk are available
+	 */
+	const areModulesAvailable = (chunkGroup, availableModules) => {
+		for (const chunk of chunkGroup.chunks) {
+			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!availableModules.has(module) && !availableModules.plus.has(module))
+					return false;
+			}
+		}
+		return true;
+	};
 
-/**
- * method to install a chunk that was loaded somehow
- * Signature: ({ id, ids, modules, runtime }) => void
- */
-exports.externalInstallChunk = "__webpack_require__.C";
+	// For each edge in the basic chunk graph
+	for (const [block, connections] of blockConnections) {
+		// 1. Check if connection is needed
+		// When none of the dependencies need to be connected
+		// we can skip all of them
+		// It's not possible to filter each item so it doesn't create inconsistent
+		// connections and modules can only create one version
+		// TODO maybe decide this per runtime
+		if (
+			// TODO is this needed?
+			!blocksWithNestedBlocks.has(block) &&
+			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
+				areModulesAvailable(
+					chunkGroup,
+					originChunkGroupInfo.resultingAvailableModules
+				)
+			)
+		) {
+			continue;
+		}
 
-/**
- * interceptor for module executions
- */
-exports.interceptModuleExecution = "__webpack_require__.i";
+		// 2. Foreach edge
+		for (let i = 0; i < connections.length; i++) {
+			const { chunkGroup, originChunkGroupInfo } = connections[i];
 
-/**
- * the global object
- */
-exports.global = "__webpack_require__.g";
+			// 3. Connect block with chunk
+			chunkGraph.connectBlockAndChunkGroup(block, chunkGroup);
 
-/**
- * an object with all share scopes
- */
-exports.shareScopeMap = "__webpack_require__.S";
+			// 4. Connect chunk with parent
+			connectChunkGroupParentAndChild(
+				originChunkGroupInfo.chunkGroup,
+				chunkGroup
+			);
+		}
+	}
+};
 
 /**
- * The sharing init sequence function (only runs once per share scope).
- * Has one argument, the name of the share scope.
- * Creates a share scope if not existing
+ * Remove all unconnected chunk groups
+ * @param {Compilation} compilation the compilation
+ * @param {Iterable<ChunkGroup>} allCreatedChunkGroups all chunk groups that where created before
  */
-exports.initializeSharing = "__webpack_require__.I";
+const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
+	const { chunkGraph } = compilation;
 
-/**
- * The current scope when getting a module from a remote
- */
-exports.currentRemoteGetScope = "__webpack_require__.R";
+	for (const chunkGroup of allCreatedChunkGroups) {
+		if (chunkGroup.getNumberOfParents() === 0) {
+			for (const chunk of chunkGroup.chunks) {
+				compilation.chunks.delete(chunk);
+				chunkGraph.disconnectChunk(chunk);
+			}
+			chunkGraph.disconnectChunkGroup(chunkGroup);
+			chunkGroup.remove();
+		}
+	}
+};
 
 /**
- * the filename of the HMR manifest
+ * This method creates the Chunk graph from the Module graph
+ * @param {Compilation} compilation the compilation
+ * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @returns {void}
  */
-exports.getUpdateManifestFilename = "__webpack_require__.hmrF";
+const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
+	const logger = compilation.getLogger("webpack.buildChunkGraph");
 
-/**
- * function downloading the update manifest
- */
-exports.hmrDownloadManifest = "__webpack_require__.hmrM";
+	// SHARED STATE
 
-/**
- * array with handler functions to download chunk updates
- */
-exports.hmrDownloadUpdateHandlers = "__webpack_require__.hmrC";
+	/** @type {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} */
+	const blockConnections = new Map();
 
-/**
- * object with all hmr module data for all modules
- */
-exports.hmrModuleData = "__webpack_require__.hmrD";
+	/** @type {Set<ChunkGroup>} */
+	const allCreatedChunkGroups = new Set();
 
-/**
- * array with handler functions when a module should be invalidated
- */
-exports.hmrInvalidateModuleHandlers = "__webpack_require__.hmrI";
+	/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
+	const chunkGroupInfoMap = new Map();
 
-/**
- * the prefix for storing state of runtime modules when hmr is enabled
- */
-exports.hmrRuntimeStatePrefix = "__webpack_require__.hmrS";
+	/** @type {Set<DependenciesBlock>} */
+	const blocksWithNestedBlocks = new Set();
 
-/**
- * the AMD define function
- */
-exports.amdDefine = "__webpack_require__.amdD";
+	// PART ONE
 
-/**
- * the AMD options
- */
-exports.amdOptions = "__webpack_require__.amdO";
+	logger.time("visitModules");
+	visitModules(
+		logger,
+		compilation,
+		inputEntrypointsAndModules,
+		chunkGroupInfoMap,
+		blockConnections,
+		blocksWithNestedBlocks,
+		allCreatedChunkGroups
+	);
+	logger.timeEnd("visitModules");
 
-/**
- * the System polyfill object
- */
-exports.system = "__webpack_require__.System";
+	// PART TWO
 
-/**
- * the shorthand for Object.prototype.hasOwnProperty
- * using of it decreases the compiled bundle size
- */
-exports.hasOwnProperty = "__webpack_require__.o";
+	logger.time("connectChunkGroups");
+	connectChunkGroups(
+		compilation,
+		blocksWithNestedBlocks,
+		blockConnections,
+		chunkGroupInfoMap
+	);
+	logger.timeEnd("connectChunkGroups");
 
-/**
- * the System.register context object
- */
-exports.systemContext = "__webpack_require__.y";
+	for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
+		for (const chunk of chunkGroup.chunks)
+			chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
+	}
 
-/**
- * the baseURI of current document
- */
-exports.baseURI = "__webpack_require__.b";
+	// Cleanup work
 
-/**
- * a RelativeURL class when relative URLs are used
- */
-exports.relativeUrl = "__webpack_require__.U";
+	logger.time("cleanup");
+	cleanupUnconnectedGroups(compilation, allCreatedChunkGroups);
+	logger.timeEnd("cleanup");
+};
 
-/**
- * Creates an async module. The body function must be a async function.
- * "module.exports" will be decorated with an AsyncModulePromise.
- * The body function will be called.
- * To handle async dependencies correctly do this: "([a, b, c] = await handleDependencies([a, b, c]));".
- * If "hasAwaitAfterDependencies" is truthy, "handleDependencies()" must be called at the end of the body function.
- * Signature: function(
- * module: Module,
- * body: (handleDependencies: (deps: AsyncModulePromise[]) => Promise<any[]> & () => void,
- * hasAwaitAfterDependencies?: boolean
- * ) => void
- */
-exports.asyncModule = "__webpack_require__.a";
+module.exports = buildChunkGraph;
 
 
 /***/ }),
 
-/***/ 16963:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 28034:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -60203,217 +60612,315 @@ exports.asyncModule = "__webpack_require__.a";
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const OriginalSource = (__webpack_require__(51255).OriginalSource);
-const Module = __webpack_require__(73208);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["runtime"]);
+/** @typedef {import("../Compiler")} Compiler */
 
-class RuntimeModule extends Module {
+class AddBuildDependenciesPlugin {
 	/**
-	 * @param {string} name a readable name
-	 * @param {number=} stage an optional stage
+	 * @param {Iterable<string>} buildDependencies list of build dependencies
 	 */
-	constructor(name, stage = 0) {
-		super("runtime");
-		this.name = name;
-		this.stage = stage;
-		this.buildMeta = {};
-		this.buildInfo = {};
-		/** @type {Compilation} */
-		this.compilation = undefined;
-		/** @type {Chunk} */
-		this.chunk = undefined;
-		/** @type {ChunkGraph} */
-		this.chunkGraph = undefined;
-		this.fullHash = false;
-		this.dependentHash = false;
-		/** @type {string} */
-		this._cachedGeneratedCode = undefined;
+	constructor(buildDependencies) {
+		this.buildDependencies = new Set(buildDependencies);
 	}
 
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {Chunk} chunk the chunk
-	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	attach(compilation, chunk, chunkGraph = compilation.chunkGraph) {
-		this.compilation = compilation;
-		this.chunk = chunk;
-		this.chunkGraph = chunkGraph;
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"AddBuildDependenciesPlugin",
+			compilation => {
+				compilation.buildDependencies.addAll(this.buildDependencies);
+			}
+		);
 	}
+}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `webpack/runtime/${this.name}`;
-	}
+module.exports = AddBuildDependenciesPlugin;
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `webpack/runtime/${this.name}`;
-	}
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		return callback(null, false);
-	}
+/***/ }),
+
+/***/ 47942:
+/***/ (function(module) {
 
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class AddManagedPathsPlugin {
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
+	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		// do nothing
-		// should not be called as runtime modules are added later to the compilation
-		callback();
+	constructor(managedPaths, immutablePaths) {
+		this.managedPaths = new Set(managedPaths);
+		this.immutablePaths = new Set(immutablePaths);
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		hash.update(this.name);
-		hash.update(`${this.stage}`);
-		try {
-			if (this.fullHash || this.dependentHash) {
-				// Do not use getGeneratedCode here, because i. e. compilation hash might be not
-				// ready at this point. We will cache it later instead.
-				hash.update(this.generate());
-			} else {
-				hash.update(this.getGeneratedCode());
-			}
-		} catch (err) {
-			hash.update(err.message);
+	apply(compiler) {
+		for (const managedPath of this.managedPaths) {
+			compiler.managedPaths.add(managedPath);
+		}
+		for (const immutablePath of this.immutablePaths) {
+			compiler.immutablePaths.add(immutablePath);
 		}
-		super.updateHash(hash, context);
 	}
+}
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+module.exports = AddManagedPathsPlugin;
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration(context) {
-		const sources = new Map();
-		const generatedCode = this.getGeneratedCode();
-		if (generatedCode) {
-			sources.set(
-				"runtime",
-				this.useSourceMap || this.useSimpleSourceMap
-					? new OriginalSource(generatedCode, this.identifier())
-					: new RawSource(generatedCode)
-			);
-		}
-		return {
-			sources,
-			runtimeRequirements: null
-		};
-	}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		try {
-			const source = this.getGeneratedCode();
-			return source ? source.length : 0;
-		} catch (e) {
-			return 0;
-		}
-	}
+/***/ }),
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
-	}
+/***/ 71985:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Cache = __webpack_require__(7592);
+const ProgressPlugin = __webpack_require__(13216);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+const BUILD_DEPENDENCIES_KEY = Symbol();
 
+class IdleFileCachePlugin {
 	/**
-	 * @returns {string} runtime code
+	 * @param {TODO} strategy cache strategy
+	 * @param {number} idleTimeout timeout
+	 * @param {number} idleTimeoutForInitialStore initial timeout
+	 * @param {number} idleTimeoutAfterLargeChanges timeout after changes
 	 */
-	getGeneratedCode() {
-		if (this._cachedGeneratedCode) {
-			return this._cachedGeneratedCode;
-		}
-		return (this._cachedGeneratedCode = this.generate());
+	constructor(
+		strategy,
+		idleTimeout,
+		idleTimeoutForInitialStore,
+		idleTimeoutAfterLargeChanges
+	) {
+		this.strategy = strategy;
+		this.idleTimeout = idleTimeout;
+		this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
+		this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
 	}
 
 	/**
-	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	shouldIsolate() {
-		return true;
-	}
-}
+	apply(compiler) {
+		let strategy = this.strategy;
+		const idleTimeout = this.idleTimeout;
+		const idleTimeoutForInitialStore = Math.min(
+			idleTimeout,
+			this.idleTimeoutForInitialStore
+		);
+		const idleTimeoutAfterLargeChanges = this.idleTimeoutAfterLargeChanges;
+		const resolvedPromise = Promise.resolve();
 
-/**
- * Runtime modules without any dependencies to other runtime modules
- */
-RuntimeModule.STAGE_NORMAL = 0;
+		let timeSpendInBuild = 0;
+		let timeSpendInStore = 0;
+		let avgTimeSpendInStore = 0;
 
-/**
- * Runtime modules with simple dependencies on other runtime modules
- */
-RuntimeModule.STAGE_BASIC = 5;
+		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise>} */
+		const pendingIdleTasks = new Map();
 
-/**
- * Runtime modules which attach to handlers of other runtime modules
- */
-RuntimeModule.STAGE_ATTACH = 10;
+		compiler.cache.hooks.store.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			(identifier, etag, data) => {
+				pendingIdleTasks.set(identifier, () =>
+					strategy.store(identifier, etag, data)
+				);
+			}
+		);
 
-/**
- * Runtime modules which trigger actions on bootstrap
- */
-RuntimeModule.STAGE_TRIGGER = 20;
+		compiler.cache.hooks.get.tapPromise(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			(identifier, etag, gotHandlers) => {
+				const restore = () =>
+					strategy.restore(identifier, etag).then(cacheEntry => {
+						if (cacheEntry === undefined) {
+							gotHandlers.push((result, callback) => {
+								if (result !== undefined) {
+									pendingIdleTasks.set(identifier, () =>
+										strategy.store(identifier, etag, result)
+									);
+								}
+								callback();
+							});
+						} else {
+							return cacheEntry;
+						}
+					});
+				const pendingTask = pendingIdleTasks.get(identifier);
+				if (pendingTask !== undefined) {
+					pendingIdleTasks.delete(identifier);
+					return pendingTask().then(restore);
+				}
+				return restore();
+			}
+		);
 
-module.exports = RuntimeModule;
+		compiler.cache.hooks.storeBuildDependencies.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			dependencies => {
+				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
+					strategy.storeBuildDependencies(dependencies)
+				);
+			}
+		);
+
+		compiler.cache.hooks.shutdown.tapPromise(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			() => {
+				if (idleTimer) {
+					clearTimeout(idleTimer);
+					idleTimer = undefined;
+				}
+				isIdle = false;
+				const reportProgress = ProgressPlugin.getReporter(compiler);
+				const jobs = Array.from(pendingIdleTasks.values());
+				if (reportProgress) reportProgress(0, "process pending cache items");
+				const promises = jobs.map(fn => fn());
+				pendingIdleTasks.clear();
+				promises.push(currentIdlePromise);
+				const promise = Promise.all(promises);
+				currentIdlePromise = promise.then(() => strategy.afterAllStored());
+				if (reportProgress) {
+					currentIdlePromise = currentIdlePromise.then(() => {
+						reportProgress(1, `stored`);
+					});
+				}
+				return currentIdlePromise.then(() => {
+					// Reset strategy
+					if (strategy.clear) strategy.clear();
+				});
+			}
+		);
+
+		/** @type {Promise<any>} */
+		let currentIdlePromise = resolvedPromise;
+		let isIdle = false;
+		let isInitialStore = true;
+		const processIdleTasks = () => {
+			if (isIdle) {
+				const startTime = Date.now();
+				if (pendingIdleTasks.size > 0) {
+					const promises = [currentIdlePromise];
+					const maxTime = startTime + 100;
+					let maxCount = 100;
+					for (const [filename, factory] of pendingIdleTasks) {
+						pendingIdleTasks.delete(filename);
+						promises.push(factory());
+						if (maxCount-- <= 0 || Date.now() > maxTime) break;
+					}
+					currentIdlePromise = Promise.all(promises);
+					currentIdlePromise.then(() => {
+						timeSpendInStore += Date.now() - startTime;
+						// Allow to exit the process between
+						idleTimer = setTimeout(processIdleTasks, 0);
+						idleTimer.unref();
+					});
+					return;
+				}
+				currentIdlePromise = currentIdlePromise
+					.then(async () => {
+						await strategy.afterAllStored();
+						timeSpendInStore += Date.now() - startTime;
+						avgTimeSpendInStore =
+							Math.max(avgTimeSpendInStore, timeSpendInStore) * 0.9 +
+							timeSpendInStore * 0.1;
+						timeSpendInStore = 0;
+						timeSpendInBuild = 0;
+					})
+					.catch(err => {
+						const logger = compiler.getInfrastructureLogger(
+							"IdleFileCachePlugin"
+						);
+						logger.warn(`Background tasks during idle failed: ${err.message}`);
+						logger.debug(err.stack);
+					});
+				isInitialStore = false;
+			}
+		};
+		let idleTimer = undefined;
+		compiler.cache.hooks.beginIdle.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			() => {
+				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
+				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
+					compiler
+						.getInfrastructureLogger("IdleFileCachePlugin")
+						.log(
+							`Initial cache was generated and cache will be persisted in ${
+								idleTimeoutForInitialStore / 1000
+							}s.`
+						);
+				} else if (
+					isLargeChange &&
+					idleTimeoutAfterLargeChanges < idleTimeout
+				) {
+					compiler
+						.getInfrastructureLogger("IdleFileCachePlugin")
+						.log(
+							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
+								Math.round(avgTimeSpendInStore) / 1000
+							}s in average in cache store. This is considered as large change and cache will be persisted in ${
+								idleTimeoutAfterLargeChanges / 1000
+							}s.`
+						);
+				}
+				idleTimer = setTimeout(() => {
+					idleTimer = undefined;
+					isIdle = true;
+					resolvedPromise.then(processIdleTasks);
+				}, Math.min(isInitialStore ? idleTimeoutForInitialStore : Infinity, isLargeChange ? idleTimeoutAfterLargeChanges : Infinity, idleTimeout));
+				idleTimer.unref();
+			}
+		);
+		compiler.cache.hooks.endIdle.tap(
+			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
+			() => {
+				if (idleTimer) {
+					clearTimeout(idleTimer);
+					idleTimer = undefined;
+				}
+				isIdle = false;
+			}
+		);
+		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
+			// 10% build overhead is ignored, as it's not cacheable
+			timeSpendInBuild *= 0.9;
+			timeSpendInBuild += stats.endTime - stats.startTime;
+		});
+	}
+}
+
+module.exports = IdleFileCachePlugin;
 
 
 /***/ }),
 
-/***/ 2307:
+/***/ 52539:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -60424,448 +60931,198 @@ module.exports = RuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const { getChunkFilenameTemplate } = __webpack_require__(47283);
-const RuntimeRequirementsDependency = __webpack_require__(24187);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const AsyncModuleRuntimeModule = __webpack_require__(63672);
-const AutoPublicPathRuntimeModule = __webpack_require__(66532);
-const CompatGetDefaultExportRuntimeModule = __webpack_require__(44793);
-const CompatRuntimeModule = __webpack_require__(88234);
-const CreateFakeNamespaceObjectRuntimeModule = __webpack_require__(94669);
-const CreateScriptRuntimeModule = __webpack_require__(2759);
-const CreateScriptUrlRuntimeModule = __webpack_require__(21213);
-const DefinePropertyGettersRuntimeModule = __webpack_require__(75481);
-const EnsureChunkRuntimeModule = __webpack_require__(71519);
-const GetChunkFilenameRuntimeModule = __webpack_require__(34277);
-const GetMainFilenameRuntimeModule = __webpack_require__(10029);
-const GetTrustedTypesPolicyRuntimeModule = __webpack_require__(38713);
-const GlobalRuntimeModule = __webpack_require__(23255);
-const HasOwnPropertyRuntimeModule = __webpack_require__(8011);
-const LoadScriptRuntimeModule = __webpack_require__(19942);
-const MakeNamespaceObjectRuntimeModule = __webpack_require__(65714);
-const OnChunksLoadedRuntimeModule = __webpack_require__(44518);
-const PublicPathRuntimeModule = __webpack_require__(56030);
-const RelativeUrlRuntimeModule = __webpack_require__(4537);
-const RuntimeIdRuntimeModule = __webpack_require__(97115);
-const SystemContextRuntimeModule = __webpack_require__(80655);
-const ShareRuntimeModule = __webpack_require__(96066);
-const StringXor = __webpack_require__(40293);
+const Cache = __webpack_require__(7592);
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-const GLOBALS_ON_REQUIRE = [
-	RuntimeGlobals.chunkName,
-	RuntimeGlobals.runtimeId,
-	RuntimeGlobals.compatGetDefaultExport,
-	RuntimeGlobals.createFakeNamespaceObject,
-	RuntimeGlobals.createScript,
-	RuntimeGlobals.createScriptUrl,
-	RuntimeGlobals.getTrustedTypesPolicy,
-	RuntimeGlobals.definePropertyGetters,
-	RuntimeGlobals.ensureChunk,
-	RuntimeGlobals.entryModuleId,
-	RuntimeGlobals.getFullHash,
-	RuntimeGlobals.global,
-	RuntimeGlobals.makeNamespaceObject,
-	RuntimeGlobals.moduleCache,
-	RuntimeGlobals.moduleFactories,
-	RuntimeGlobals.moduleFactoriesAddOnly,
-	RuntimeGlobals.interceptModuleExecution,
-	RuntimeGlobals.publicPath,
-	RuntimeGlobals.baseURI,
-	RuntimeGlobals.relativeUrl,
-	RuntimeGlobals.scriptNonce,
-	RuntimeGlobals.uncaughtErrorHandler,
-	RuntimeGlobals.asyncModule,
-	RuntimeGlobals.wasmInstances,
-	RuntimeGlobals.instantiateWasm,
-	RuntimeGlobals.shareScopeMap,
-	RuntimeGlobals.initializeSharing,
-	RuntimeGlobals.loadScript,
-	RuntimeGlobals.systemContext,
-	RuntimeGlobals.onChunksLoaded
-];
+class MemoryCachePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		const cache = new Map();
+		compiler.cache.hooks.store.tap(
+			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, data) => {
+				cache.set(identifier, { etag, data });
+			}
+		);
+		compiler.cache.hooks.get.tap(
+			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, gotHandlers) => {
+				const cacheEntry = cache.get(identifier);
+				if (cacheEntry === null) {
+					return null;
+				} else if (cacheEntry !== undefined) {
+					return cacheEntry.etag === etag ? cacheEntry.data : null;
+				}
+				gotHandlers.push((result, callback) => {
+					if (result === undefined) {
+						cache.set(identifier, null);
+					} else {
+						cache.set(identifier, { etag, data: result });
+					}
+					return callback();
+				});
+			}
+		);
+		compiler.cache.hooks.shutdown.tap(
+			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
+			() => {
+				cache.clear();
+			}
+		);
+	}
+}
+module.exports = MemoryCachePlugin;
 
-const MODULE_DEPENDENCIES = {
-	[RuntimeGlobals.moduleLoaded]: [RuntimeGlobals.module],
-	[RuntimeGlobals.moduleId]: [RuntimeGlobals.module]
-};
 
-const TREE_DEPENDENCIES = {
-	[RuntimeGlobals.definePropertyGetters]: [RuntimeGlobals.hasOwnProperty],
-	[RuntimeGlobals.compatGetDefaultExport]: [
-		RuntimeGlobals.definePropertyGetters
-	],
-	[RuntimeGlobals.createFakeNamespaceObject]: [
-		RuntimeGlobals.definePropertyGetters,
-		RuntimeGlobals.makeNamespaceObject,
-		RuntimeGlobals.require
-	],
-	[RuntimeGlobals.initializeSharing]: [RuntimeGlobals.shareScopeMap],
-	[RuntimeGlobals.shareScopeMap]: [RuntimeGlobals.hasOwnProperty]
-};
+/***/ }),
 
-class RuntimePlugin {
+/***/ 99334:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Cache = __webpack_require__(7592);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+class MemoryWithGcCachePlugin {
+	constructor({ maxGenerations }) {
+		this._maxGenerations = maxGenerations;
+	}
 	/**
-	 * @param {Compiler} compiler the Compiler
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("RuntimePlugin", compilation => {
-			compilation.dependencyTemplates.set(
-				RuntimeRequirementsDependency,
-				new RuntimeRequirementsDependency.Template()
-			);
-			for (const req of GLOBALS_ON_REQUIRE) {
-				compilation.hooks.runtimeRequirementInModule
-					.for(req)
-					.tap("RuntimePlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(req)
-					.tap("RuntimePlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
+		const maxGenerations = this._maxGenerations;
+		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		const cache = new Map();
+		/** @type {Map<string, { entry: { etag: Etag | null, data: any }, until: number }>} */
+		const oldCache = new Map();
+		let generation = 0;
+		let cachePosition = 0;
+		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
+		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
+			generation++;
+			let clearedEntries = 0;
+			let lastClearedIdentifier;
+			for (const [identifier, entry] of oldCache) {
+				if (entry.until > generation) break;
+
+				oldCache.delete(identifier);
+				if (cache.get(identifier) === undefined) {
+					cache.delete(identifier);
+					clearedEntries++;
+					lastClearedIdentifier = identifier;
+				}
 			}
-			for (const req of Object.keys(TREE_DEPENDENCIES)) {
-				const deps = TREE_DEPENDENCIES[req];
-				compilation.hooks.runtimeRequirementInTree
-					.for(req)
-					.tap("RuntimePlugin", (chunk, set) => {
-						for (const dep of deps) set.add(dep);
-					});
+			if (clearedEntries > 0 || oldCache.size > 0) {
+				logger.log(
+					`${cache.size - oldCache.size} active entries, ${
+						oldCache.size
+					} recently unused cached entries${
+						clearedEntries > 0
+							? `, ${clearedEntries} old unused cache entries removed e. g. ${lastClearedIdentifier}`
+							: ""
+					}`
+				);
 			}
-			for (const req of Object.keys(MODULE_DEPENDENCIES)) {
-				const deps = MODULE_DEPENDENCIES[req];
-				compilation.hooks.runtimeRequirementInModule
-					.for(req)
-					.tap("RuntimePlugin", (chunk, set) => {
-						for (const dep of deps) set.add(dep);
+			let i = (cache.size / maxGenerations) | 0;
+			let j = cachePosition >= cache.size ? 0 : cachePosition;
+			cachePosition = j + i;
+			for (const [identifier, entry] of cache) {
+				if (j !== 0) {
+					j--;
+					continue;
+				}
+				if (entry !== undefined) {
+					// We don't delete the cache entry, but set it to undefined instead
+					// This reserves the location in the data table and avoids rehashing
+					// when constantly adding and removing entries.
+					// It will be deleted when removed from oldCache.
+					cache.set(identifier, undefined);
+					oldCache.delete(identifier);
+					oldCache.set(identifier, {
+						entry,
+						until: generation + maxGenerations
 					});
+					if (i-- === 0) break;
+				}
 			}
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.definePropertyGetters)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new DefinePropertyGettersRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.makeNamespaceObject)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new MakeNamespaceObjectRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.createFakeNamespaceObject)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new CreateFakeNamespaceObjectRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hasOwnProperty)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new HasOwnPropertyRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.compatGetDefaultExport)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(
-						chunk,
-						new CompatGetDefaultExportRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.runtimeId)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(chunk, new RuntimeIdRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.publicPath)
-				.tap("RuntimePlugin", (chunk, set) => {
-					const { outputOptions } = compilation;
-					const { publicPath: globalPublicPath, scriptType } = outputOptions;
-					const entryOptions = chunk.getEntryOptions();
-					const publicPath =
-						entryOptions && entryOptions.publicPath !== undefined
-							? entryOptions.publicPath
-							: globalPublicPath;
-
-					if (publicPath === "auto") {
-						const module = new AutoPublicPathRuntimeModule();
-						if (scriptType !== "module") set.add(RuntimeGlobals.global);
-						compilation.addRuntimeModule(chunk, module);
+		});
+		compiler.cache.hooks.store.tap(
+			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, data) => {
+				cache.set(identifier, { etag, data });
+			}
+		);
+		compiler.cache.hooks.get.tap(
+			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			(identifier, etag, gotHandlers) => {
+				const cacheEntry = cache.get(identifier);
+				if (cacheEntry === null) {
+					return null;
+				} else if (cacheEntry !== undefined) {
+					return cacheEntry.etag === etag ? cacheEntry.data : null;
+				}
+				const oldCacheEntry = oldCache.get(identifier);
+				if (oldCacheEntry !== undefined) {
+					const cacheEntry = oldCacheEntry.entry;
+					if (cacheEntry === null) {
+						oldCache.delete(identifier);
+						cache.set(identifier, cacheEntry);
+						return null;
 					} else {
-						const module = new PublicPathRuntimeModule(publicPath);
-
-						if (
-							typeof publicPath !== "string" ||
-							/\[(full)?hash\]/.test(publicPath)
-						) {
-							module.fullHash = true;
-						}
-
-						compilation.addRuntimeModule(chunk, module);
-					}
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.global)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(chunk, new GlobalRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.asyncModule)
-				.tap("RuntimePlugin", chunk => {
-					compilation.addRuntimeModule(chunk, new AsyncModuleRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.systemContext)
-				.tap("RuntimePlugin", chunk => {
-					const { outputOptions } = compilation;
-					const { library: globalLibrary } = outputOptions;
-					const entryOptions = chunk.getEntryOptions();
-					const libraryType =
-						entryOptions && entryOptions.library !== undefined
-							? entryOptions.library.type
-							: globalLibrary.type;
-
-					if (libraryType === "system") {
-						compilation.addRuntimeModule(
-							chunk,
-							new SystemContextRuntimeModule()
-						);
-					}
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getChunkScriptFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						typeof compilation.outputOptions.chunkFilename === "string" &&
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.chunkFilename
-						)
-					) {
-						set.add(RuntimeGlobals.getFullHash);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new GetChunkFilenameRuntimeModule(
-							"javascript",
-							"javascript",
-							RuntimeGlobals.getChunkScriptFilename,
-							chunk =>
-								chunk.filenameTemplate ||
-								(chunk.canBeInitial()
-									? compilation.outputOptions.filename
-									: compilation.outputOptions.chunkFilename),
-							false
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getChunkCssFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						typeof compilation.outputOptions.cssChunkFilename === "string" &&
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.cssChunkFilename
-						)
-					) {
-						set.add(RuntimeGlobals.getFullHash);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new GetChunkFilenameRuntimeModule(
-							"css",
-							"css",
-							RuntimeGlobals.getChunkCssFilename,
-							chunk =>
-								getChunkFilenameTemplate(chunk, compilation.outputOptions),
-							set.has(RuntimeGlobals.hmrDownloadUpdateHandlers)
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getChunkUpdateScriptFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.hotUpdateChunkFilename
-						)
-					)
-						set.add(RuntimeGlobals.getFullHash);
-					compilation.addRuntimeModule(
-						chunk,
-						new GetChunkFilenameRuntimeModule(
-							"javascript",
-							"javascript update",
-							RuntimeGlobals.getChunkUpdateScriptFilename,
-							c => compilation.outputOptions.hotUpdateChunkFilename,
-							true
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getUpdateManifestFilename)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (
-						/\[(full)?hash(:\d+)?\]/.test(
-							compilation.outputOptions.hotUpdateMainFilename
-						)
-					) {
-						set.add(RuntimeGlobals.getFullHash);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new GetMainFilenameRuntimeModule(
-							"update manifest",
-							RuntimeGlobals.getUpdateManifestFilename,
-							compilation.outputOptions.hotUpdateMainFilename
-						)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunk)
-				.tap("RuntimePlugin", (chunk, set) => {
-					const hasAsyncChunks = chunk.hasAsyncChunks();
-					if (hasAsyncChunks) {
-						set.add(RuntimeGlobals.ensureChunkHandlers);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new EnsureChunkRuntimeModule(set)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkIncludeEntries)
-				.tap("RuntimePlugin", (chunk, set) => {
-					set.add(RuntimeGlobals.ensureChunkHandlers);
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.shareScopeMap)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(chunk, new ShareRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.loadScript)
-				.tap("RuntimePlugin", (chunk, set) => {
-					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
-					if (withCreateScriptUrl) {
-						set.add(RuntimeGlobals.createScriptUrl);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new LoadScriptRuntimeModule(withCreateScriptUrl)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.createScript)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (compilation.outputOptions.trustedTypes) {
-						set.add(RuntimeGlobals.getTrustedTypesPolicy);
-					}
-					compilation.addRuntimeModule(chunk, new CreateScriptRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.createScriptUrl)
-				.tap("RuntimePlugin", (chunk, set) => {
-					if (compilation.outputOptions.trustedTypes) {
-						set.add(RuntimeGlobals.getTrustedTypesPolicy);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new CreateScriptUrlRuntimeModule()
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.getTrustedTypesPolicy)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(
-						chunk,
-						new GetTrustedTypesPolicyRuntimeModule(set)
-					);
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.relativeUrl)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(chunk, new RelativeUrlRuntimeModule());
-					return true;
-				});
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(
-						chunk,
-						new OnChunksLoadedRuntimeModule()
-					);
-					return true;
-				});
-			// TODO webpack 6: remove CompatRuntimeModule
-			compilation.hooks.additionalTreeRuntimeRequirements.tap(
-				"RuntimePlugin",
-				(chunk, set) => {
-					const { mainTemplate } = compilation;
-					if (
-						mainTemplate.hooks.bootstrap.isUsed() ||
-						mainTemplate.hooks.localVars.isUsed() ||
-						mainTemplate.hooks.requireEnsure.isUsed() ||
-						mainTemplate.hooks.requireExtensions.isUsed()
-					) {
-						compilation.addRuntimeModule(chunk, new CompatRuntimeModule());
+						if (cacheEntry.etag !== etag) return null;
+						oldCache.delete(identifier);
+						cache.set(identifier, cacheEntry);
+						return cacheEntry.data;
 					}
 				}
-			);
-			JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(
-				"RuntimePlugin",
-				(chunk, hash, { chunkGraph }) => {
-					const xor = new StringXor();
-					for (const m of chunkGraph.getChunkRuntimeModulesIterable(chunk)) {
-						xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+				gotHandlers.push((result, callback) => {
+					if (result === undefined) {
+						cache.set(identifier, null);
+					} else {
+						cache.set(identifier, { etag, data: result });
 					}
-					xor.updateHash(hash);
-				}
-			);
-		});
+					return callback();
+				});
+			}
+		);
+		compiler.cache.hooks.shutdown.tap(
+			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
+			() => {
+				cache.clear();
+				oldCache.clear();
+			}
+		);
 	}
 }
-module.exports = RuntimePlugin;
+module.exports = MemoryWithGcCachePlugin;
 
 
 /***/ }),
 
-/***/ 18777:
+/***/ 86180:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -60876,1758 +61133,1732 @@ module.exports = RuntimePlugin;
 
 
 
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const { equals } = __webpack_require__(84953);
-const compileBooleanMatcher = __webpack_require__(29404);
-const propertyAccess = __webpack_require__(54190);
-const { forEachRuntime, subtractRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
-/**
- * @param {Module} module the module
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @returns {string} error message
- */
-const noModuleIdErrorMessage = (module, chunkGraph) => {
-	return `Module ${module.identifier()} has no id assigned.
-This should not happen.
-It's in these chunks: ${
-		Array.from(
-			chunkGraph.getModuleChunksIterable(module),
-			c => c.name || c.id || c.debugId
-		).join(", ") || "none"
-	} (If module is in no chunk this indicates a bug in some chunk/module optimization logic)
-Module has these incoming connections: ${Array.from(
-		chunkGraph.moduleGraph.getIncomingConnections(module),
-		connection =>
-			`\n - ${
-				connection.originModule && connection.originModule.identifier()
-			} ${connection.dependency && connection.dependency.type} ${
-				(connection.explanations &&
-					Array.from(connection.explanations).join(", ")) ||
-				""
-			}`
-	).join("")}`;
-};
-
-/**
- * @param {string|undefined} definition global object definition
- * @returns {string} save to use global object
- */
-function getGlobalObject(definition) {
-	if (!definition) return definition;
-	const trimmed = definition.trim();
-
-	if (
-		// identifier, we do not need real identifier regarding ECMAScript/Unicode
-		trimmed.match(/^[_\p{L}][_0-9\p{L}]*$/iu) ||
-		// iife
-		// call expression
-		// expression in parentheses
-		trimmed.match(/^([_\p{L}][_0-9\p{L}]*)?\(.*\)$/iu)
-	)
-		return trimmed;
+const FileSystemInfo = __webpack_require__(79453);
+const ProgressPlugin = __webpack_require__(13216);
+const { formatSize } = __webpack_require__(71070);
+const SerializerMiddleware = __webpack_require__(83137);
+const LazySet = __webpack_require__(38938);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
+const {
+	createFileSerializer,
+	NOT_SERIALIZABLE
+} = __webpack_require__(8282);
 
-	return `Object(${trimmed})`;
-}
+/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../Cache").Etag} Etag */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+/** @typedef {import("../logging/Logger").Logger} Logger */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
-class RuntimeTemplate {
+class PackContainer {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {OutputOptions} outputOptions the compilation output options
-	 * @param {RequestShortener} requestShortener the request shortener
+	 * @param {Object} data stored data
+	 * @param {string} version version identifier
+	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
+	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
+	 * @param {Map<string, string | false>} resolveResults result of the resolved build dependencies
+	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
 	 */
-	constructor(compilation, outputOptions, requestShortener) {
-		this.compilation = compilation;
-		this.outputOptions = outputOptions || {};
-		this.requestShortener = requestShortener;
-		this.globalObject = getGlobalObject(outputOptions.globalObject);
-	}
-
-	isIIFE() {
-		return this.outputOptions.iife;
-	}
-
-	isModule() {
-		return this.outputOptions.module;
+	constructor(
+		data,
+		version,
+		buildSnapshot,
+		buildDependencies,
+		resolveResults,
+		resolveBuildDependenciesSnapshot
+	) {
+		this.data = data;
+		this.version = version;
+		this.buildSnapshot = buildSnapshot;
+		this.buildDependencies = buildDependencies;
+		this.resolveResults = resolveResults;
+		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
 	}
 
-	supportsConst() {
-		return this.outputOptions.environment.const;
-	}
-
-	supportsArrowFunction() {
-		return this.outputOptions.environment.arrowFunction;
-	}
-
-	supportsOptionalChaining() {
-		return this.outputOptions.environment.optionalChaining;
-	}
-
-	supportsForOf() {
-		return this.outputOptions.environment.forOf;
+	serialize({ write, writeLazy }) {
+		write(this.version);
+		write(this.buildSnapshot);
+		write(this.buildDependencies);
+		write(this.resolveResults);
+		write(this.resolveBuildDependenciesSnapshot);
+		writeLazy(this.data);
 	}
 
-	supportsDestructuring() {
-		return this.outputOptions.environment.destructuring;
+	deserialize({ read }) {
+		this.version = read();
+		this.buildSnapshot = read();
+		this.buildDependencies = read();
+		this.resolveResults = read();
+		this.resolveBuildDependenciesSnapshot = read();
+		this.data = read();
 	}
+}
 
-	supportsBigIntLiteral() {
-		return this.outputOptions.environment.bigIntLiteral;
-	}
+makeSerializable(
+	PackContainer,
+	"webpack/lib/cache/PackFileCacheStrategy",
+	"PackContainer"
+);
 
-	supportsDynamicImport() {
-		return this.outputOptions.environment.dynamicImport;
-	}
+const MIN_CONTENT_SIZE = 1024 * 1024; // 1 MB
+const CONTENT_COUNT_TO_MERGE = 10;
+const MIN_ITEMS_IN_FRESH_PACK = 100;
+const MAX_ITEMS_IN_FRESH_PACK = 50000;
+const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
 
-	supportsEcmaScriptModuleSyntax() {
-		return this.outputOptions.environment.module;
+class PackItemInfo {
+	/**
+	 * @param {string} identifier identifier of item
+	 * @param {string | null} etag etag of item
+	 * @param {any} value fresh value of item
+	 */
+	constructor(identifier, etag, value) {
+		this.identifier = identifier;
+		this.etag = etag;
+		this.location = -1;
+		this.lastAccess = Date.now();
+		this.freshValue = value;
 	}
+}
 
-	supportTemplateLiteral() {
-		return this.outputOptions.environment.templateLiteral;
+class Pack {
+	constructor(logger, maxAge) {
+		/** @type {Map<string, PackItemInfo>} */
+		this.itemInfo = new Map();
+		/** @type {string[]} */
+		this.requests = [];
+		this.requestsTimeout = undefined;
+		/** @type {Map<string, PackItemInfo>} */
+		this.freshContent = new Map();
+		/** @type {(undefined | PackContent)[]} */
+		this.content = [];
+		this.invalid = false;
+		this.logger = logger;
+		this.maxAge = maxAge;
 	}
 
-	returningFunction(returnValue, args = "") {
-		return this.supportsArrowFunction()
-			? `(${args}) => (${returnValue})`
-			: `function(${args}) { return ${returnValue}; }`;
+	_addRequest(identifier) {
+		this.requests.push(identifier);
+		if (this.requestsTimeout === undefined) {
+			this.requestsTimeout = setTimeout(() => {
+				this.requests.push(undefined);
+				this.requestsTimeout = undefined;
+			}, MAX_TIME_IN_FRESH_PACK);
+			if (this.requestsTimeout.unref) this.requestsTimeout.unref();
+		}
 	}
 
-	basicFunction(args, body) {
-		return this.supportsArrowFunction()
-			? `(${args}) => {\n${Template.indent(body)}\n}`
-			: `function(${args}) {\n${Template.indent(body)}\n}`;
+	stopCapturingRequests() {
+		if (this.requestsTimeout !== undefined) {
+			clearTimeout(this.requestsTimeout);
+			this.requestsTimeout = undefined;
+		}
 	}
 
 	/**
-	 * @param {Array<string|{expr: string}>} args args
-	 * @returns {string} result expression
+	 * @param {string} identifier unique name for the resource
+	 * @param {string | null} etag etag of the resource
+	 * @returns {any} cached content
 	 */
-	concatenation(...args) {
-		const len = args.length;
-
-		if (len === 2) return this._es5Concatenation(args);
-		if (len === 0) return '""';
-		if (len === 1) {
-			return typeof args[0] === "string"
-				? JSON.stringify(args[0])
-				: `"" + ${args[0].expr}`;
+	get(identifier, etag) {
+		const info = this.itemInfo.get(identifier);
+		this._addRequest(identifier);
+		if (info === undefined) {
+			return undefined;
 		}
-		if (!this.supportTemplateLiteral()) return this._es5Concatenation(args);
-
-		// cost comparison between template literal and concatenation:
-		// both need equal surroundings: `xxx` vs "xxx"
-		// template literal has constant cost of 3 chars for each expression
-		// es5 concatenation has cost of 3 + n chars for n expressions in row
-		// when a es5 concatenation ends with an expression it reduces cost by 3
-		// when a es5 concatenation starts with an single expression it reduces cost by 3
-		// e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
-		// e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
-
-		let templateCost = 0;
-		let concatenationCost = 0;
-
-		let lastWasExpr = false;
-		for (const arg of args) {
-			const isExpr = typeof arg !== "string";
-			if (isExpr) {
-				templateCost += 3;
-				concatenationCost += lastWasExpr ? 1 : 4;
+		if (info.etag !== etag) return null;
+		info.lastAccess = Date.now();
+		const loc = info.location;
+		if (loc === -1) {
+			return info.freshValue;
+		} else {
+			if (!this.content[loc]) {
+				return undefined;
 			}
-			lastWasExpr = isExpr;
+			return this.content[loc].get(identifier);
 		}
-		if (lastWasExpr) concatenationCost -= 3;
-		if (typeof args[0] !== "string" && typeof args[1] === "string")
-			concatenationCost -= 3;
-
-		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
-
-		return `\`${args
-			.map(arg => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
-			.join("")}\``;
-	}
-
-	/**
-	 * @param {Array<string|{expr: string}>} args args (len >= 2)
-	 * @returns {string} result expression
-	 * @private
-	 */
-	_es5Concatenation(args) {
-		const str = args
-			.map(arg => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
-			.join(" + ");
-
-		// when the first two args are expression, we need to prepend "" + to force string
-		// concatenation instead of number addition.
-		return typeof args[0] !== "string" && typeof args[1] !== "string"
-			? `"" + ${str}`
-			: str;
-	}
-
-	expressionFunction(expression, args = "") {
-		return this.supportsArrowFunction()
-			? `(${args}) => (${expression})`
-			: `function(${args}) { ${expression}; }`;
-	}
-
-	emptyFunction() {
-		return this.supportsArrowFunction() ? "x => {}" : "function() {}";
-	}
-
-	destructureArray(items, value) {
-		return this.supportsDestructuring()
-			? `var [${items.join(", ")}] = ${value};`
-			: Template.asString(
-					items.map((item, i) => `var ${item} = ${value}[${i}];`)
-			  );
-	}
-
-	destructureObject(items, value) {
-		return this.supportsDestructuring()
-			? `var {${items.join(", ")}} = ${value};`
-			: Template.asString(
-					items.map(item => `var ${item} = ${value}${propertyAccess([item])};`)
-			  );
-	}
-
-	iife(args, body) {
-		return `(${this.basicFunction(args, body)})()`;
-	}
-
-	forEach(variable, array, body) {
-		return this.supportsForOf()
-			? `for(const ${variable} of ${array}) {\n${Template.indent(body)}\n}`
-			: `${array}.forEach(function(${variable}) {\n${Template.indent(
-					body
-			  )}\n});`;
 	}
 
 	/**
-	 * Add a comment
-	 * @param {object} options Information content of the comment
-	 * @param {string=} options.request request string used originally
-	 * @param {string=} options.chunkName name of the chunk referenced
-	 * @param {string=} options.chunkReason reason information of the chunk
-	 * @param {string=} options.message additional message
-	 * @param {string=} options.exportName name of the export
-	 * @returns {string} comment
+	 * @param {string} identifier unique name for the resource
+	 * @param {string | null} etag etag of the resource
+	 * @param {any} data cached content
+	 * @returns {void}
 	 */
-	comment({ request, chunkName, chunkReason, message, exportName }) {
-		let content;
-		if (this.outputOptions.pathinfo) {
-			content = [message, request, chunkName, chunkReason]
-				.filter(Boolean)
-				.map(item => this.requestShortener.shorten(item))
-				.join(" | ");
-		} else {
-			content = [message, chunkName, chunkReason]
-				.filter(Boolean)
-				.map(item => this.requestShortener.shorten(item))
-				.join(" | ");
+	set(identifier, etag, data) {
+		if (!this.invalid) {
+			this.invalid = true;
+			this.logger.log(`Pack got invalid because of write to: ${identifier}`);
 		}
-		if (!content) return "";
-		if (this.outputOptions.pathinfo) {
-			return Template.toComment(content) + " ";
+		const info = this.itemInfo.get(identifier);
+		if (info === undefined) {
+			const newInfo = new PackItemInfo(identifier, etag, data);
+			this.itemInfo.set(identifier, newInfo);
+			this._addRequest(identifier);
+			this.freshContent.set(identifier, newInfo);
 		} else {
-			return Template.toNormalComment(content) + " ";
+			const loc = info.location;
+			if (loc >= 0) {
+				this._addRequest(identifier);
+				this.freshContent.set(identifier, info);
+				const content = this.content[loc];
+				content.delete(identifier);
+				if (content.items.size === 0) {
+					this.content[loc] = undefined;
+					this.logger.debug("Pack %d got empty and is removed", loc);
+				}
+			}
+			info.freshValue = data;
+			info.lastAccess = Date.now();
+			info.etag = etag;
+			info.location = -1;
 		}
 	}
 
-	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error block
-	 */
-	throwMissingModuleErrorBlock({ request }) {
-		const err = `Cannot find module '${request}'`;
-		return `var e = new Error(${JSON.stringify(
-			err
-		)}); e.code = 'MODULE_NOT_FOUND'; throw e;`;
-	}
-
-	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error function
-	 */
-	throwMissingModuleErrorFunction({ request }) {
-		return `function webpackMissingModule() { ${this.throwMissingModuleErrorBlock(
-			{ request }
-		)} }`;
-	}
-
-	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error IIFE
-	 */
-	missingModule({ request }) {
-		return `Object(${this.throwMissingModuleErrorFunction({ request })}())`;
-	}
-
-	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error statement
-	 */
-	missingModuleStatement({ request }) {
-		return `${this.missingModule({ request })};\n`;
+	getContentStats() {
+		let count = 0;
+		let size = 0;
+		for (const content of this.content) {
+			if (content !== undefined) {
+				count++;
+				const s = content.getSize();
+				if (s > 0) {
+					size += s;
+				}
+			}
+		}
+		return { count, size };
 	}
 
 	/**
-	 * @param {object} options generation options
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} generated error code
+	 * @returns {number} new location of data entries
 	 */
-	missingModulePromise({ request }) {
-		return `Promise.resolve().then(${this.throwMissingModuleErrorFunction({
-			request
-		})})`;
+	_findLocation() {
+		let i;
+		for (i = 0; i < this.content.length && this.content[i] !== undefined; i++);
+		return i;
 	}
 
-	/**
-	 * @param {Object} options options object
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Module} options.module the module
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {string=} options.idExpr expression to use as id expression
-	 * @param {"expression" | "promise" | "statements"} options.type which kind of code should be returned
-	 * @returns {string} the code
-	 */
-	weakError({ module, chunkGraph, request, idExpr, type }) {
-		const moduleId = chunkGraph.getModuleId(module);
-		const errorMessage =
-			moduleId === null
-				? JSON.stringify("Module is not available (weak dependency)")
-				: idExpr
-				? `"Module '" + ${idExpr} + "' is not available (weak dependency)"`
-				: JSON.stringify(
-						`Module '${moduleId}' is not available (weak dependency)`
-				  );
-		const comment = request ? Template.toNormalComment(request) + " " : "";
-		const errorStatements =
-			`var e = new Error(${errorMessage}); ` +
-			comment +
-			"e.code = 'MODULE_NOT_FOUND'; throw e;";
-		switch (type) {
-			case "statements":
-				return errorStatements;
-			case "promise":
-				return `Promise.resolve().then(${this.basicFunction(
-					"",
-					errorStatements
-				)})`;
-			case "expression":
-				return this.iife("", errorStatements);
+	_gcAndUpdateLocation(items, usedItems, newLoc) {
+		let count = 0;
+		let lastGC;
+		const now = Date.now();
+		for (const identifier of items) {
+			const info = this.itemInfo.get(identifier);
+			if (now - info.lastAccess > this.maxAge) {
+				this.itemInfo.delete(identifier);
+				items.delete(identifier);
+				usedItems.delete(identifier);
+				count++;
+				lastGC = identifier;
+			} else {
+				info.location = newLoc;
+			}
+		}
+		if (count > 0) {
+			this.logger.log(
+				"Garbage Collected %d old items at pack %d (%d items remaining) e. g. %s",
+				count,
+				newLoc,
+				items.size,
+				lastGC
+			);
 		}
 	}
 
-	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @returns {string} the expression
-	 */
-	moduleId({ module, chunkGraph, request, weak }) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId === null) {
-			if (weak) {
-				return "null /* weak dependency, without id */";
+	_persistFreshContent() {
+		const itemsCount = this.freshContent.size;
+		if (itemsCount > 0) {
+			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
+			const itemsPerPack = Math.ceil(itemsCount / packCount);
+			const packs = [];
+			let i = 0;
+			let ignoreNextTimeTick = false;
+			const createNextPack = () => {
+				const loc = this._findLocation();
+				this.content[loc] = null; // reserve
+				const pack = {
+					/** @type {Set<string>} */
+					items: new Set(),
+					/** @type {Map<string, any>} */
+					map: new Map(),
+					loc
+				};
+				packs.push(pack);
+				return pack;
+			};
+			let pack = createNextPack();
+			if (this.requestsTimeout !== undefined)
+				clearTimeout(this.requestsTimeout);
+			for (const identifier of this.requests) {
+				if (identifier === undefined) {
+					if (ignoreNextTimeTick) {
+						ignoreNextTimeTick = false;
+					} else if (pack.items.size >= MIN_ITEMS_IN_FRESH_PACK) {
+						i = 0;
+						pack = createNextPack();
+					}
+					continue;
+				}
+				const info = this.freshContent.get(identifier);
+				if (info === undefined) continue;
+				pack.items.add(identifier);
+				pack.map.set(identifier, info.freshValue);
+				info.location = pack.loc;
+				info.freshValue = undefined;
+				this.freshContent.delete(identifier);
+				if (++i > itemsPerPack) {
+					i = 0;
+					pack = createNextPack();
+					ignoreNextTimeTick = true;
+				}
 			}
-			throw new Error(
-				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
+			this.requests.length = 0;
+			for (const pack of packs) {
+				this.content[pack.loc] = new PackContent(
+					pack.items,
+					new Set(pack.items),
+					new PackContentItems(pack.map)
+				);
+			}
+			this.logger.log(
+				`${itemsCount} fresh items in cache put into pack ${
+					packs.length > 1
+						? packs
+								.map(pack => `${pack.loc} (${pack.items.size} items)`)
+								.join(", ")
+						: packs[0].loc
+				}`
 			);
 		}
-		return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the expression
+	 * Merges small content files to a single content file
 	 */
-	moduleRaw({ module, chunkGraph, request, weak, runtimeRequirements }) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
+	_optimizeSmallContent() {
+		// 1. Find all small content files
+		// Treat unused content files separately to avoid
+		// a merge-split cycle
+		/** @type {number[]} */
+		const smallUsedContents = [];
+		/** @type {number} */
+		let smallUsedContentSize = 0;
+		/** @type {number[]} */
+		const smallUnusedContents = [];
+		/** @type {number} */
+		let smallUnusedContentSize = 0;
+		for (let i = 0; i < this.content.length; i++) {
+			const content = this.content[i];
+			if (content === undefined) continue;
+			if (content.outdated) continue;
+			const size = content.getSize();
+			if (size < 0 || size > MIN_CONTENT_SIZE) continue;
+			if (content.used.size > 0) {
+				smallUsedContents.push(i);
+				smallUsedContentSize += size;
+			} else {
+				smallUnusedContents.push(i);
+				smallUnusedContentSize += size;
+			}
 		}
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return this.weakError({
-					module,
-					chunkGraph,
-					request,
-					type: "expression"
-				});
+
+		// 2. Check if minimum number is reached
+		let mergedIndices;
+		if (
+			smallUsedContents.length >= CONTENT_COUNT_TO_MERGE ||
+			smallUsedContentSize > MIN_CONTENT_SIZE
+		) {
+			mergedIndices = smallUsedContents;
+		} else if (
+			smallUnusedContents.length >= CONTENT_COUNT_TO_MERGE ||
+			smallUnusedContentSize > MIN_CONTENT_SIZE
+		) {
+			mergedIndices = smallUnusedContents;
+		} else return;
+
+		const mergedContent = [];
+
+		// 3. Remove old content entries
+		for (const i of mergedIndices) {
+			mergedContent.push(this.content[i]);
+			this.content[i] = undefined;
+		}
+
+		// 4. Determine merged items
+		/** @type {Set<string>} */
+		const mergedItems = new Set();
+		/** @type {Set<string>} */
+		const mergedUsedItems = new Set();
+		/** @type {(function(Map<string, any>): Promise)[]} */
+		const addToMergedMap = [];
+		for (const content of mergedContent) {
+			for (const identifier of content.items) {
+				mergedItems.add(identifier);
 			}
-			throw new Error(
-				`RuntimeTemplate.moduleId(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
+			for (const identifier of content.used) {
+				mergedUsedItems.add(identifier);
+			}
+			addToMergedMap.push(async map => {
+				// unpack existing content
+				// after that values are accessible in .content
+				await content.unpack(
+					"it should be merged with other small pack contents"
+				);
+				for (const [identifier, value] of content.content) {
+					map.set(identifier, value);
+				}
+			});
+		}
+
+		// 5. GC and update location of merged items
+		const newLoc = this._findLocation();
+		this._gcAndUpdateLocation(mergedItems, mergedUsedItems, newLoc);
+
+		// 6. If not empty, store content somewhere
+		if (mergedItems.size > 0) {
+			this.content[newLoc] = new PackContent(
+				mergedItems,
+				mergedUsedItems,
+				memoize(async () => {
+					/** @type {Map<string, any>} */
+					const map = new Map();
+					await Promise.all(addToMergedMap.map(fn => fn(map)));
+					return new PackContentItems(map);
+				})
+			);
+			this.logger.log(
+				"Merged %d small files with %d cache items into pack %d",
+				mergedContent.length,
+				mergedItems.size,
+				newLoc
 			);
 		}
-		runtimeRequirements.add(RuntimeGlobals.require);
-		return `__webpack_require__(${this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		})})`;
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the expression
+	 * Split large content files with used and unused items
+	 * into two parts to separate used from unused items
 	 */
-	moduleExports({ module, chunkGraph, request, weak, runtimeRequirements }) {
-		return this.moduleRaw({
-			module,
-			chunkGraph,
-			request,
-			weak,
-			runtimeRequirements
-		});
+	_optimizeUnusedContent() {
+		// 1. Find a large content file with used and unused items
+		for (let i = 0; i < this.content.length; i++) {
+			const content = this.content[i];
+			if (content === undefined) continue;
+			const size = content.getSize();
+			if (size < MIN_CONTENT_SIZE) continue;
+			const used = content.used.size;
+			const total = content.items.size;
+			if (used > 0 && used < total) {
+				// 2. Remove this content
+				this.content[i] = undefined;
+
+				// 3. Determine items for the used content file
+				const usedItems = new Set(content.used);
+				const newLoc = this._findLocation();
+				this._gcAndUpdateLocation(usedItems, usedItems, newLoc);
+
+				// 4. Create content file for used items
+				if (usedItems.size > 0) {
+					this.content[newLoc] = new PackContent(
+						usedItems,
+						new Set(usedItems),
+						async () => {
+							await content.unpack(
+								"it should be splitted into used and unused items"
+							);
+							const map = new Map();
+							for (const identifier of usedItems) {
+								map.set(identifier, content.content.get(identifier));
+							}
+							return new PackContentItems(map);
+						}
+					);
+				}
+
+				// 5. Determine items for the unused content file
+				const unusedItems = new Set(content.items);
+				const usedOfUnusedItems = new Set();
+				for (const identifier of usedItems) {
+					unusedItems.delete(identifier);
+				}
+				const newUnusedLoc = this._findLocation();
+				this._gcAndUpdateLocation(unusedItems, usedOfUnusedItems, newUnusedLoc);
+
+				// 6. Create content file for unused items
+				if (unusedItems.size > 0) {
+					this.content[newUnusedLoc] = new PackContent(
+						unusedItems,
+						usedOfUnusedItems,
+						async () => {
+							await content.unpack(
+								"it should be splitted into used and unused items"
+							);
+							const map = new Map();
+							for (const identifier of unusedItems) {
+								map.set(identifier, content.content.get(identifier));
+							}
+							return new PackContentItems(map);
+						}
+					);
+				}
+
+				this.logger.log(
+					"Split pack %d into pack %d with %d used items and pack %d with %d unused items",
+					i,
+					newLoc,
+					usedItems.size,
+					newUnusedLoc,
+					unusedItems.size
+				);
+
+				// optimizing only one of them is good enough and
+				// reduces the amount of serialization needed
+				return;
+			}
+		}
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {boolean=} options.strict if the current module is in strict esm mode
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the expression
+	 * Find the content with the oldest item and run GC on that.
+	 * Only runs for one content to avoid large invalidation.
 	 */
-	moduleNamespace({
-		module,
-		chunkGraph,
-		request,
-		strict,
-		weak,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		if (chunkGraph.getModuleId(module) === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return this.weakError({
-					module,
-					chunkGraph,
-					request,
-					type: "expression"
-				});
+	_gcOldestContent() {
+		/** @type {PackItemInfo} */
+		let oldest = undefined;
+		for (const info of this.itemInfo.values()) {
+			if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
+				oldest = info;
 			}
-			throw new Error(
-				`RuntimeTemplate.moduleNamespace(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
-			);
 		}
-		const moduleId = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
-		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		switch (exportsType) {
-			case "namespace":
-				return this.moduleRaw({
-					module,
-					chunkGraph,
-					request,
-					weak,
-					runtimeRequirements
-				});
-			case "default-with-named":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`;
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 1)`;
-			case "dynamic":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 7)`;
+		if (Date.now() - oldest.lastAccess > this.maxAge) {
+			const loc = oldest.location;
+			if (loc < 0) return;
+			const content = this.content[loc];
+			const items = new Set(content.items);
+			const usedItems = new Set(content.used);
+			this._gcAndUpdateLocation(items, usedItems, loc);
+
+			this.content[loc] =
+				items.size > 0
+					? new PackContent(items, usedItems, async () => {
+							await content.unpack(
+								"it contains old items that should be garbage collected"
+							);
+							const map = new Map();
+							for (const identifier of items) {
+								map.set(identifier, content.content.get(identifier));
+							}
+							return new PackContentItems(map);
+					  })
+					: undefined;
 		}
 	}
 
-	/**
-	 * @param {Object} options options object
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {AsyncDependenciesBlock=} options.block the current dependencies block
-	 * @param {Module} options.module the module
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {string} options.message a message for the comment
-	 * @param {boolean=} options.strict if the current module is in strict esm mode
-	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} the promise expression
-	 */
-	moduleNamespacePromise({
-		chunkGraph,
-		block,
-		module,
-		request,
-		message,
-		strict,
-		weak,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return this.missingModulePromise({
-				request
-			});
+	serialize({ write, writeSeparate }) {
+		this._persistFreshContent();
+		this._optimizeSmallContent();
+		this._optimizeUnusedContent();
+		this._gcOldestContent();
+		for (const identifier of this.itemInfo.keys()) {
+			write(identifier);
 		}
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return this.weakError({
-					module,
-					chunkGraph,
-					request,
-					type: "promise"
-				});
+		write(null); // null as marker of the end of keys
+		for (const info of this.itemInfo.values()) {
+			write(info.etag);
+		}
+		for (const info of this.itemInfo.values()) {
+			write(info.lastAccess);
+		}
+		for (let i = 0; i < this.content.length; i++) {
+			const content = this.content[i];
+			if (content !== undefined) {
+				write(content.items);
+				content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
+			} else {
+				write(undefined); // undefined marks an empty content slot
 			}
-			throw new Error(
-				`RuntimeTemplate.moduleNamespacePromise(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
-			);
 		}
-		const promise = this.blockPromise({
-			chunkGraph,
-			block,
-			message,
-			runtimeRequirements
-		});
+		write(null); // null as marker of the end of items
+	}
 
-		let appending;
-		let idExpr = JSON.stringify(chunkGraph.getModuleId(module));
-		const comment = this.comment({
-			request
-		});
-		let header = "";
-		if (weak) {
-			if (idExpr.length > 8) {
-				// 'var x="nnnnnn";x,"+x+",x' vs '"nnnnnn",nnnnnn,"nnnnnn"'
-				header += `var id = ${idExpr}; `;
-				idExpr = "id";
+	deserialize({ read, logger }) {
+		this.logger = logger;
+		{
+			const items = [];
+			let item = read();
+			while (item !== null) {
+				items.push(item);
+				item = read();
+			}
+			this.itemInfo.clear();
+			const infoItems = items.map(identifier => {
+				const info = new PackItemInfo(identifier, undefined, undefined);
+				this.itemInfo.set(identifier, info);
+				return info;
+			});
+			for (const info of infoItems) {
+				info.etag = read();
+			}
+			for (const info of infoItems) {
+				info.lastAccess = read();
 			}
-			runtimeRequirements.add(RuntimeGlobals.moduleFactories);
-			header += `if(!${
-				RuntimeGlobals.moduleFactories
-			}[${idExpr}]) { ${this.weakError({
-				module,
-				chunkGraph,
-				request,
-				idExpr,
-				type: "statements"
-			})} } `;
 		}
-		const moduleIdExpr = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
-		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
-		let fakeType = 16;
-		switch (exportsType) {
-			case "namespace":
-				if (header) {
-					const rawModule = this.moduleRaw({
-						module,
-						chunkGraph,
-						request,
-						weak,
-						runtimeRequirements
-					});
-					appending = `.then(${this.basicFunction(
-						"",
-						`${header}return ${rawModule};`
-					)})`;
-				} else {
-					runtimeRequirements.add(RuntimeGlobals.require);
-					appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
-				}
-				break;
-			case "dynamic":
-				fakeType |= 4;
-			/* fall through */
-			case "default-with-named":
-				fakeType |= 2;
-			/* fall through */
-			case "default-only":
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				if (chunkGraph.moduleGraph.isAsync(module)) {
-					if (header) {
-						const rawModule = this.moduleRaw({
-							module,
-							chunkGraph,
-							request,
-							weak,
-							runtimeRequirements
-						});
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${rawModule};`
-						)})`;
-					} else {
-						runtimeRequirements.add(RuntimeGlobals.require);
-						appending = `.then(__webpack_require__.bind(__webpack_require__, ${comment}${idExpr}))`;
-					}
-					appending += `.then(${this.returningFunction(
-						`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
-						"m"
-					)})`;
-				} else {
-					fakeType |= 1;
-					if (header) {
-						const returnExpression = `${RuntimeGlobals.createFakeNamespaceObject}(${moduleIdExpr}, ${fakeType})`;
-						appending = `.then(${this.basicFunction(
-							"",
-							`${header}return ${returnExpression};`
-						)})`;
-					} else {
-						appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(__webpack_require__, ${comment}${idExpr}, ${fakeType}))`;
-					}
+		this.content.length = 0;
+		let items = read();
+		while (items !== null) {
+			if (items === undefined) {
+				this.content.push(items);
+			} else {
+				const idx = this.content.length;
+				const lazy = read();
+				this.content.push(
+					new PackContent(
+						items,
+						new Set(),
+						lazy,
+						logger,
+						`${this.content.length}`
+					)
+				);
+				for (const identifier of items) {
+					this.itemInfo.get(identifier).location = idx;
 				}
-				break;
+			}
+			items = read();
 		}
-
-		return `${promise || "Promise.resolve()"}${appending}`;
 	}
+}
+
+makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
 
+class PackContentItems {
 	/**
-	 * @param {Object} options options object
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {RuntimeSpec=} options.runtime runtime for which this code will be generated
-	 * @param {RuntimeSpec | boolean=} options.runtimeCondition only execute the statement in some runtimes
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} expression
+	 * @param {Map<string, any>} map items
 	 */
-	runtimeConditionExpression({
-		chunkGraph,
-		runtimeCondition,
-		runtime,
-		runtimeRequirements
-	}) {
-		if (runtimeCondition === undefined) return "true";
-		if (typeof runtimeCondition === "boolean") return `${runtimeCondition}`;
-		/** @type {Set<string>} */
-		const positiveRuntimeIds = new Set();
-		forEachRuntime(runtimeCondition, runtime =>
-			positiveRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
-		);
-		/** @type {Set<string>} */
-		const negativeRuntimeIds = new Set();
-		forEachRuntime(subtractRuntime(runtime, runtimeCondition), runtime =>
-			negativeRuntimeIds.add(`${chunkGraph.getRuntimeId(runtime)}`)
-		);
-		runtimeRequirements.add(RuntimeGlobals.runtimeId);
-		return compileBooleanMatcher.fromLists(
-			Array.from(positiveRuntimeIds),
-			Array.from(negativeRuntimeIds)
-		)(RuntimeGlobals.runtimeId);
+	constructor(map) {
+		this.map = map;
 	}
 
-	/**
-	 *
-	 * @param {Object} options options object
-	 * @param {boolean=} options.update whether a new variable should be created or the existing one updated
-	 * @param {Module} options.module the module
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {string} options.request the request that should be printed as comment
-	 * @param {string} options.importVar name of the import variable
-	 * @param {Module} options.originModule module in which the statement is emitted
-	 * @param {boolean=} options.weak true, if this is a weak dependency
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {[string, string]} the import statement and the compat statement
-	 */
-	importStatement({
-		update,
-		module,
-		chunkGraph,
-		request,
-		importVar,
-		originModule,
-		weak,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return [
-				this.missingModuleStatement({
-					request
-				}),
-				""
-			];
-		}
-		if (chunkGraph.getModuleId(module) === null) {
-			if (weak) {
-				// only weak referenced modules don't get an id
-				// we can always emit an error emitting code here
-				return [
-					this.weakError({
-						module,
-						chunkGraph,
-						request,
-						type: "statements"
-					}),
-					""
-				];
+	serialize({ write, snapshot, rollback, logger, profile }) {
+		if (profile) {
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					const start = process.hrtime();
+					write(value);
+					const durationHr = process.hrtime(start);
+					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+					if (duration > 1) {
+						if (duration > 500)
+							logger.error(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 50)
+							logger.warn(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 10)
+							logger.info(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 5)
+							logger.log(`Serialization of '${key}': ${duration} ms`);
+						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+					}
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
 			}
-			throw new Error(
-				`RuntimeTemplate.importStatement(): ${noModuleIdErrorMessage(
-					module,
-					chunkGraph
-				)}`
-			);
-		}
-		const moduleId = this.moduleId({
-			module,
-			chunkGraph,
-			request,
-			weak
-		});
-		const optDeclaration = update ? "" : "var ";
-
-		const exportsType = module.getExportsType(
-			chunkGraph.moduleGraph,
-			originModule.buildMeta.strictHarmonyModule
-		);
-		runtimeRequirements.add(RuntimeGlobals.require);
-		const importContent = `/* harmony import */ ${optDeclaration}${importVar} = __webpack_require__(${moduleId});\n`;
-
-		if (exportsType === "dynamic") {
-			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
-			return [
-				importContent,
-				`/* harmony import */ ${optDeclaration}${importVar}_default = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${importVar});\n`
-			];
-		}
-		return [importContent, ""];
-	}
-
-	/**
-	 * @param {Object} options options
-	 * @param {ModuleGraph} options.moduleGraph the module graph
-	 * @param {Module} options.module the module
-	 * @param {string} options.request the request
-	 * @param {string | string[]} options.exportName the export name
-	 * @param {Module} options.originModule the origin module
-	 * @param {boolean|undefined} options.asiSafe true, if location is safe for ASI, a bracket can be emitted
-	 * @param {boolean} options.isCall true, if expression will be called
-	 * @param {boolean} options.callContext when false, call context will not be preserved
-	 * @param {boolean} options.defaultInterop when true and accessing the default exports, interop code will be generated
-	 * @param {string} options.importVar the identifier name of the import variable
-	 * @param {InitFragment[]} options.initFragments init fragments will be added here
-	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} expression
-	 */
-	exportFromImport({
-		moduleGraph,
-		module,
-		request,
-		exportName,
-		originModule,
-		asiSafe,
-		isCall,
-		callContext,
-		defaultInterop,
-		importVar,
-		initFragments,
-		runtime,
-		runtimeRequirements
-	}) {
-		if (!module) {
-			return this.missingModule({
-				request
-			});
-		}
-		if (!Array.isArray(exportName)) {
-			exportName = exportName ? [exportName] : [];
+			write(null);
+			return;
 		}
-		const exportsType = module.getExportsType(
-			moduleGraph,
-			originModule.buildMeta.strictHarmonyModule
-		);
+		// Try to serialize all at once
+		const s = snapshot();
+		try {
+			write(true);
+			write(this.map);
+		} catch (e) {
+			rollback(s);
 
-		if (defaultInterop) {
-			if (exportName.length > 0 && exportName[0] === "default") {
-				switch (exportsType) {
-					case "dynamic":
-						if (isCall) {
-							return `${importVar}_default()${propertyAccess(exportName, 1)}`;
-						} else {
-							return asiSafe
-								? `(${importVar}_default()${propertyAccess(exportName, 1)})`
-								: asiSafe === false
-								? `;(${importVar}_default()${propertyAccess(exportName, 1)})`
-								: `${importVar}_default.a${propertyAccess(exportName, 1)}`;
-						}
-					case "default-only":
-					case "default-with-named":
-						exportName = exportName.slice(1);
-						break;
-				}
-			} else if (exportName.length > 0) {
-				if (exportsType === "default-only") {
-					return (
-						"/* non-default import from non-esm module */undefined" +
-						propertyAccess(exportName, 1)
+			// Try to serialize each item on it's own
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					write(value);
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
 					);
-				} else if (
-					exportsType !== "namespace" &&
-					exportName[0] === "__esModule"
-				) {
-					return "/* __esModule */true";
+					logger.debug(e.stack);
 				}
-			} else if (
-				exportsType === "default-only" ||
-				exportsType === "default-with-named"
-			) {
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				initFragments.push(
-					new InitFragment(
-						`var ${importVar}_namespace_cache;\n`,
-						InitFragment.STAGE_CONSTANTS,
-						-1,
-						`${importVar}_namespace_cache`
-					)
-				);
-				return `/*#__PURE__*/ ${
-					asiSafe ? "" : asiSafe === false ? ";" : "Object"
-				}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${
-					RuntimeGlobals.createFakeNamespaceObject
-				}(${importVar}${exportsType === "default-only" ? "" : ", 2"})))`;
 			}
+			write(null);
 		}
+	}
 
-		if (exportName.length > 0) {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const used = exportsInfo.getUsedName(exportName, runtime);
-			if (!used) {
-				const comment = Template.toNormalComment(
-					`unused export ${propertyAccess(exportName)}`
-				);
-				return `${comment} undefined`;
-			}
-			const comment = equals(used, exportName)
-				? ""
-				: Template.toNormalComment(propertyAccess(exportName)) + " ";
-			const access = `${importVar}${comment}${propertyAccess(used)}`;
-			if (isCall && callContext === false) {
-				return asiSafe
-					? `(0,${access})`
-					: asiSafe === false
-					? `;(0,${access})`
-					: `/*#__PURE__*/Object(${access})`;
+	deserialize({ read, logger, profile }) {
+		if (read()) {
+			this.map = read();
+		} else if (profile) {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				const start = process.hrtime();
+				const value = read();
+				const durationHr = process.hrtime(start);
+				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+				if (duration > 1) {
+					if (duration > 100)
+						logger.error(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 20)
+						logger.warn(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 5)
+						logger.info(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 2)
+						logger.log(`Deserialization of '${key}': ${duration} ms`);
+					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+				}
+				map.set(key, value);
+				key = read();
 			}
-			return access;
+			this.map = map;
 		} else {
-			return importVar;
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				map.set(key, read());
+				key = read();
+			}
+			this.map = map;
 		}
 	}
+}
+
+makeSerializable(
+	PackContentItems,
+	"webpack/lib/cache/PackFileCacheStrategy",
+	"PackContentItems"
+);
+
+class PackContent {
+	/*
+		This class can be in these states:
+		   |   this.lazy    | this.content | this.outdated | state
+		A1 |   undefined    |     Map      |     false     | fresh content
+		A2 |   undefined    |     Map      |     true      | (will not happen)
+		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
+		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
+		C1 | lazy* () => {} |     Map      |     false     | deserialized
+		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
+
+		this.used is a subset of this.items.
+		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
+		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
+		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
+		When this.lazy and this.content is set, they contain the same data.
+		this.get must only be called with a valid item from this.items.
+		In state C this.lazy is unMemoized
+	*/
 
 	/**
-	 * @param {Object} options options
-	 * @param {AsyncDependenciesBlock} options.block the async block
-	 * @param {string} options.message the message
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} expression
+	 * @param {Set<string>} items keys
+	 * @param {Set<string>} usedItems used keys
+	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
+	 * @param {Logger=} logger logger for logging
+	 * @param {string=} lazyName name of dataOrFn for logging
 	 */
-	blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
-		if (!block) {
-			const comment = this.comment({
-				message
-			});
-			return `Promise.resolve(${comment.trim()})`;
+	constructor(items, usedItems, dataOrFn, logger, lazyName) {
+		this.items = items;
+		/** @type {function(): Promise<PackContentItems> | PackContentItems} */
+		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
+		/** @type {Map<string, any>} */
+		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
+		this.outdated = false;
+		this.used = usedItems;
+		this.logger = logger;
+		this.lazyName = lazyName;
+	}
+
+	get(identifier) {
+		this.used.add(identifier);
+		if (this.content) {
+			return this.content.get(identifier);
 		}
-		const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-		if (!chunkGroup || chunkGroup.chunks.length === 0) {
-			const comment = this.comment({
-				message
-			});
-			return `Promise.resolve(${comment.trim()})`;
+
+		// We are in state B
+		const { lazyName } = this;
+		let timeMessage;
+		if (lazyName) {
+			// only log once
+			this.lazyName = undefined;
+			timeMessage = `restore cache content ${lazyName} (${formatSize(
+				this.getSize()
+			)})`;
+			this.logger.log(
+				`starting to restore cache content ${lazyName} (${formatSize(
+					this.getSize()
+				)}) because of request to: ${identifier}`
+			);
+			this.logger.time(timeMessage);
 		}
-		const chunks = chunkGroup.chunks.filter(
-			chunk => !chunk.hasRuntime() && chunk.id !== null
-		);
-		const comment = this.comment({
-			message,
-			chunkName: block.chunkName
-		});
-		if (chunks.length === 1) {
-			const chunkId = JSON.stringify(chunks[0].id);
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId})`;
-		} else if (chunks.length > 0) {
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-			const requireChunkId = chunk =>
-				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`;
-			return `Promise.all(${comment.trim()}[${chunks
-				.map(requireChunkId)
-				.join(", ")}])`;
+		const value = this.lazy();
+		if ("then" in value) {
+			return value.then(data => {
+				const map = data.map;
+				if (timeMessage) {
+					this.logger.timeEnd(timeMessage);
+				}
+				// Move to state C
+				this.content = map;
+				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+				return map.get(identifier);
+			});
 		} else {
-			return `Promise.resolve(${comment.trim()})`;
+			const map = value.map;
+			if (timeMessage) {
+				this.logger.timeEnd(timeMessage);
+			}
+			// Move to state C
+			this.content = map;
+			this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+			return map.get(identifier);
 		}
 	}
 
 	/**
-	 * @param {Object} options options
-	 * @param {AsyncDependenciesBlock} options.block the async block
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} expression
+	 * @param {string} reason explanation why unpack is necessary
+	 * @returns {void | Promise} maybe a promise if lazy
 	 */
-	asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) {
-		const dep = block.dependencies[0];
-		const module = chunkGraph.moduleGraph.getModule(dep);
-		const ensureChunk = this.blockPromise({
-			block,
-			message: "",
-			chunkGraph,
-			runtimeRequirements
-		});
-		const factory = this.returningFunction(
-			this.moduleRaw({
-				module,
-				chunkGraph,
-				request,
-				runtimeRequirements
-			})
-		);
-		return this.returningFunction(
-			ensureChunk.startsWith("Promise.resolve(")
-				? `${factory}`
-				: `${ensureChunk}.then(${this.returningFunction(factory)})`
-		);
+	unpack(reason) {
+		if (this.content) return;
+
+		// Move from state B to C
+		if (this.lazy) {
+			const { lazyName } = this;
+			let timeMessage;
+			if (lazyName) {
+				// only log once
+				this.lazyName = undefined;
+				timeMessage = `unpack cache content ${lazyName} (${formatSize(
+					this.getSize()
+				)})`;
+				this.logger.log(
+					`starting to unpack cache content ${lazyName} (${formatSize(
+						this.getSize()
+					)}) because ${reason}`
+				);
+				this.logger.time(timeMessage);
+			}
+			const value = this.lazy();
+			if ("then" in value) {
+				return value.then(data => {
+					if (timeMessage) {
+						this.logger.timeEnd(timeMessage);
+					}
+					this.content = data.map;
+				});
+			} else {
+				if (timeMessage) {
+					this.logger.timeEnd(timeMessage);
+				}
+				this.content = value.map;
+			}
+		}
 	}
 
 	/**
-	 * @param {Object} options options
-	 * @param {Dependency} options.dependency the dependency
-	 * @param {ChunkGraph} options.chunkGraph the chunk graph
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {string=} options.request request string used originally
-	 * @returns {string} expression
+	 * @returns {number} size of the content or -1 if not known
 	 */
-	syncModuleFactory({ dependency, chunkGraph, runtimeRequirements, request }) {
-		const module = chunkGraph.moduleGraph.getModule(dependency);
-		const factory = this.returningFunction(
-			this.moduleRaw({
-				module,
-				chunkGraph,
-				request,
-				runtimeRequirements
-			})
-		);
-		return this.returningFunction(factory);
+	getSize() {
+		if (!this.lazy) return -1;
+		const options = /** @type {any} */ (this.lazy).options;
+		if (!options) return -1;
+		const size = options.size;
+		if (typeof size !== "number") return -1;
+		return size;
 	}
 
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.exportsArgument the name of the exports object
-	 * @param {Set<string>} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @returns {string} statement
-	 */
-	defineEsModuleFlagStatement({ exportsArgument, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
+	delete(identifier) {
+		this.items.delete(identifier);
+		this.used.delete(identifier);
+		this.outdated = true;
 	}
 
 	/**
-	 * @param {Object} options options object
-	 * @param {Module} options.module the module
-	 * @param {string} options.publicPath the public path
-	 * @param {RuntimeSpec=} options.runtime runtime
-	 * @param {CodeGenerationResults} options.codeGenerationResults the code generation results
-	 * @returns {string} the url of the asset
+	 * @template T
+	 * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
+	 * @returns {void}
 	 */
-	assetUrl({ publicPath, runtime, module, codeGenerationResults }) {
-		if (!module) {
-			return "data:,";
+	writeLazy(write) {
+		if (!this.outdated && this.lazy) {
+			// State B1 or C1
+			// this.lazy is still the valid deserialized version
+			write(this.lazy);
+			return;
 		}
-		const codeGen = codeGenerationResults.get(module, runtime);
-		const { data } = codeGen;
-		const url = data.get("url");
-		if (url) return url.toString();
-		const filename = data.get("filename");
-		return publicPath + filename;
-	}
-}
-
-module.exports = RuntimeTemplate;
-
-
-/***/ }),
-
-/***/ 63560:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-class SelfModuleFactory {
-	constructor(moduleGraph) {
-		this.moduleGraph = moduleGraph;
-	}
+		if (!this.outdated && this.content) {
+			// State A1
+			const map = new Map(this.content);
+			// Move to state C1
+			this.lazy = SerializerMiddleware.unMemoizeLazy(
+				write(() => new PackContentItems(map))
+			);
+			return;
+		}
+		if (this.content) {
+			// State A2 or C2
+			/** @type {Map<string, any>} */
+			const map = new Map();
+			for (const item of this.items) {
+				map.set(item, this.content.get(item));
+			}
+			// Move to state C1
+			this.outdated = false;
+			this.content = map;
+			this.lazy = SerializerMiddleware.unMemoizeLazy(
+				write(() => new PackContentItems(map))
+			);
+			return;
+		}
+		// State B2
+		const { lazyName } = this;
+		let timeMessage;
+		if (lazyName) {
+			// only log once
+			this.lazyName = undefined;
+			timeMessage = `unpack cache content ${lazyName} (${formatSize(
+				this.getSize()
+			)})`;
+			this.logger.log(
+				`starting to unpack cache content ${lazyName} (${formatSize(
+					this.getSize()
+				)}) because it's outdated and need to be serialized`
+			);
+			this.logger.time(timeMessage);
+		}
+		const value = this.lazy();
+		this.outdated = false;
+		if ("then" in value) {
+			// Move to state B1
+			this.lazy = write(() =>
+				value.then(data => {
+					if (timeMessage) {
+						this.logger.timeEnd(timeMessage);
+					}
+					const oldMap = data.map;
+					/** @type {Map<string, any>} */
+					const map = new Map();
+					for (const item of this.items) {
+						map.set(item, oldMap.get(item));
+					}
+					// Move to state C1 (or maybe C2)
+					this.content = map;
+					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 
-	create(data, callback) {
-		const module = this.moduleGraph.getParentModule(data.dependencies[0]);
-		callback(null, {
-			module
-		});
+					return new PackContentItems(map);
+				})
+			);
+		} else {
+			// Move to state C1
+			if (timeMessage) {
+				this.logger.timeEnd(timeMessage);
+			}
+			const oldMap = value.map;
+			/** @type {Map<string, any>} */
+			const map = new Map();
+			for (const item of this.items) {
+				map.set(item, oldMap.get(item));
+			}
+			this.content = map;
+			this.lazy = write(() => new PackContentItems(map));
+		}
 	}
 }
 
-module.exports = SelfModuleFactory;
-
-
-/***/ }),
-
-/***/ 48076:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-
-
-
-module.exports = __webpack_require__(96953);
-
-
-/***/ }),
-
-/***/ 71070:
-/***/ (function(__unused_webpack_module, exports) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
-
-
-
-/**
- * @param {number} size the size in bytes
- * @returns {string} the formatted size
- */
-exports.formatSize = size => {
-	if (typeof size !== "number" || Number.isNaN(size) === true) {
-		return "unknown size";
-	}
-
-	if (size <= 0) {
-		return "0 bytes";
+const allowCollectingMemory = buf => {
+	const wasted = buf.buffer.byteLength - buf.byteLength;
+	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
+		return Buffer.from(buf);
 	}
-
-	const abbreviations = ["bytes", "KiB", "MiB", "GiB"];
-	const index = Math.floor(Math.log(size) / Math.log(1024));
-
-	return `${+(size / Math.pow(1024, index)).toPrecision(3)} ${
-		abbreviations[index]
-	}`;
+	return buf;
 };
 
+class PackFileCacheStrategy {
+	/**
+	 * @param {Object} options options
+	 * @param {Compiler} options.compiler the compiler
+	 * @param {IntermediateFileSystem} options.fs the filesystem
+	 * @param {string} options.context the context directory
+	 * @param {string} options.cacheLocation the location of the cache data
+	 * @param {string} options.version version identifier
+	 * @param {Logger} options.logger a logger
+	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
+	 * @param {number} options.maxAge max age of cache items
+	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
+	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
+	 * @param {false | "gzip" | "brotli"} options.compression compression used
+	 */
+	constructor({
+		compiler,
+		fs,
+		context,
+		cacheLocation,
+		version,
+		logger,
+		snapshot,
+		maxAge,
+		profile,
+		allowCollectingMemory,
+		compression
+	}) {
+		this.fileSerializer = createFileSerializer(
+			fs,
+			compiler.options.output.hashFunction
+		);
+		this.fileSystemInfo = new FileSystemInfo(fs, {
+			managedPaths: snapshot.managedPaths,
+			immutablePaths: snapshot.immutablePaths,
+			logger: logger.getChildLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
+		});
+		this.compiler = compiler;
+		this.context = context;
+		this.cacheLocation = cacheLocation;
+		this.version = version;
+		this.logger = logger;
+		this.maxAge = maxAge;
+		this.profile = profile;
+		this.allowCollectingMemory = allowCollectingMemory;
+		this.compression = compression;
+		this._extension =
+			compression === "brotli"
+				? ".pack.br"
+				: compression === "gzip"
+				? ".pack.gz"
+				: ".pack";
+		this.snapshot = snapshot;
+		/** @type {Set<string>} */
+		this.buildDependencies = new Set();
+		/** @type {LazySet<string>} */
+		this.newBuildDependencies = new LazySet();
+		/** @type {Snapshot} */
+		this.resolveBuildDependenciesSnapshot = undefined;
+		/** @type {Map<string, string | false>} */
+		this.resolveResults = undefined;
+		/** @type {Snapshot} */
+		this.buildSnapshot = undefined;
+		/** @type {Promise<Pack>} */
+		this.packPromise = this._openPack();
+		this.storePromise = Promise.resolve();
+	}
 
-/***/ }),
-
-/***/ 97513:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const JavascriptModulesPlugin = __webpack_require__(89464);
-
-/** @typedef {import("./Compilation")} Compilation */
-
-class SourceMapDevToolModuleOptionsPlugin {
-	constructor(options) {
-		this.options = options;
+	_getPack() {
+		if (this.packPromise === undefined) {
+			this.packPromise = this.storePromise.then(() => this._openPack());
+		}
+		return this.packPromise;
 	}
 
 	/**
-	 * @param {Compilation} compilation the compiler instance
-	 * @returns {void}
+	 * @returns {Promise<Pack>} the pack
 	 */
-	apply(compilation) {
-		const options = this.options;
-		if (options.module !== false) {
-			compilation.hooks.buildModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSourceMap = true;
+	_openPack() {
+		const { logger, profile, cacheLocation, version } = this;
+		/** @type {Snapshot} */
+		let buildSnapshot;
+		/** @type {Set<string>} */
+		let buildDependencies;
+		/** @type {Set<string>} */
+		let newBuildDependencies;
+		/** @type {Snapshot} */
+		let resolveBuildDependenciesSnapshot;
+		/** @type {Map<string, string | false>} */
+		let resolveResults;
+		logger.time("restore cache container");
+		return this.fileSerializer
+			.deserialize(null, {
+				filename: `${cacheLocation}/index${this._extension}`,
+				extension: `${this._extension}`,
+				logger,
+				profile,
+				retainedBuffer: this.allowCollectingMemory
+					? allowCollectingMemory
+					: undefined
+			})
+			.catch(err => {
+				if (err.code !== "ENOENT") {
+					logger.warn(
+						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
+					);
+					logger.debug(err.stack);
+				} else {
+					logger.debug(
+						`No pack exists at ${cacheLocation}${this._extension}: ${err}`
+					);
 				}
-			);
-			compilation.hooks.runtimeModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSourceMap = true;
+				return undefined;
+			})
+			.then(packContainer => {
+				logger.timeEnd("restore cache container");
+				if (!packContainer) return undefined;
+				if (!(packContainer instanceof PackContainer)) {
+					logger.warn(
+						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
+						packContainer
+					);
+					return undefined;
 				}
-			);
-		} else {
-			compilation.hooks.buildModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSimpleSourceMap = true;
+				if (packContainer.version !== version) {
+					logger.log(
+						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
+					);
+					return undefined;
 				}
-			);
-			compilation.hooks.runtimeModule.tap(
-				"SourceMapDevToolModuleOptionsPlugin",
-				module => {
-					module.useSimpleSourceMap = true;
+				logger.time("check build dependencies");
+				return Promise.all([
+					new Promise((resolve, reject) => {
+						this.fileSystemInfo.checkSnapshotValid(
+							packContainer.buildSnapshot,
+							(err, valid) => {
+								if (err) {
+									logger.log(
+										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.`
+									);
+									logger.debug(err.stack);
+									return resolve(false);
+								}
+								if (!valid) {
+									logger.log(
+										`Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.`
+									);
+									return resolve(false);
+								}
+								buildSnapshot = packContainer.buildSnapshot;
+								return resolve(true);
+							}
+						);
+					}),
+					new Promise((resolve, reject) => {
+						this.fileSystemInfo.checkSnapshotValid(
+							packContainer.resolveBuildDependenciesSnapshot,
+							(err, valid) => {
+								if (err) {
+									logger.log(
+										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.`
+									);
+									logger.debug(err.stack);
+									return resolve(false);
+								}
+								if (valid) {
+									resolveBuildDependenciesSnapshot =
+										packContainer.resolveBuildDependenciesSnapshot;
+									buildDependencies = packContainer.buildDependencies;
+									resolveResults = packContainer.resolveResults;
+									return resolve(true);
+								}
+								logger.log(
+									"resolving of build dependencies is invalid, will re-resolve build dependencies"
+								);
+								this.fileSystemInfo.checkResolveResultsValid(
+									packContainer.resolveResults,
+									(err, valid) => {
+										if (err) {
+											logger.log(
+												`Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.`
+											);
+											logger.debug(err.stack);
+											return resolve(false);
+										}
+										if (valid) {
+											newBuildDependencies = packContainer.buildDependencies;
+											resolveResults = packContainer.resolveResults;
+											return resolve(true);
+										}
+										logger.log(
+											`Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.`
+										);
+										return resolve(false);
+									}
+								);
+							}
+						);
+					})
+				])
+					.catch(err => {
+						logger.timeEnd("check build dependencies");
+						throw err;
+					})
+					.then(([buildSnapshotValid, resolveValid]) => {
+						logger.timeEnd("check build dependencies");
+						if (buildSnapshotValid && resolveValid) {
+							logger.time("restore cache content metadata");
+							const d = packContainer.data();
+							logger.timeEnd("restore cache content metadata");
+							return d;
+						}
+						return undefined;
+					});
+			})
+			.then(pack => {
+				if (pack) {
+					pack.maxAge = this.maxAge;
+					this.buildSnapshot = buildSnapshot;
+					if (buildDependencies) this.buildDependencies = buildDependencies;
+					if (newBuildDependencies)
+						this.newBuildDependencies.addAll(newBuildDependencies);
+					this.resolveResults = resolveResults;
+					this.resolveBuildDependenciesSnapshot =
+						resolveBuildDependenciesSnapshot;
+					return pack;
 				}
-			);
-		}
-		JavascriptModulesPlugin.getCompilationHooks(compilation).useSourceMap.tap(
-			"SourceMapDevToolModuleOptionsPlugin",
-			() => true
-		);
+				return new Pack(logger, this.maxAge);
+			})
+			.catch(err => {
+				this.logger.warn(
+					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
+				);
+				this.logger.debug(err.stack);
+				return new Pack(logger, this.maxAge);
+			});
 	}
-}
-
-module.exports = SourceMapDevToolModuleOptionsPlugin;
-
-
-/***/ }),
-
-/***/ 63872:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+	/**
+	 * @param {string} identifier unique name for the resource
+	 * @param {Etag | null} etag etag of the resource
+	 * @param {any} data cached content
+	 * @returns {Promise<void>} promise
+	 */
+	store(identifier, etag, data) {
+		return this._getPack().then(pack => {
+			pack.set(identifier, etag === null ? null : etag.toString(), data);
+		});
+	}
 
+	/**
+	 * @param {string} identifier unique name for the resource
+	 * @param {Etag | null} etag etag of the resource
+	 * @returns {Promise<any>} promise to the cached content
+	 */
+	restore(identifier, etag) {
+		return this._getPack()
+			.then(pack =>
+				pack.get(identifier, etag === null ? null : etag.toString())
+			)
+			.catch(err => {
+				if (err && err.code !== "ENOENT") {
+					this.logger.warn(
+						`Restoring failed for ${identifier} from pack: ${err}`
+					);
+					this.logger.debug(err.stack);
+				}
+			});
+	}
 
-const asyncLib = __webpack_require__(78175);
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const ModuleFilenameHelpers = __webpack_require__(88821);
-const ProgressPlugin = __webpack_require__(13216);
-const SourceMapDevToolModuleOptionsPlugin = __webpack_require__(97513);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const { relative, dirname } = __webpack_require__(17139);
-const { makePathsAbsolute } = __webpack_require__(82186);
+	storeBuildDependencies(dependencies) {
+		this.newBuildDependencies.addAll(dependencies);
+	}
 
-/** @typedef {import("webpack-sources").MapOptions} MapOptions */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./NormalModule").SourceMap} SourceMap */
-/** @typedef {import("./util/Hash")} Hash */
+	afterAllStored() {
+		const packPromise = this.packPromise;
+		if (packPromise === undefined) return Promise.resolve();
+		const reportProgress = ProgressPlugin.getReporter(this.compiler);
+		return (this.storePromise = packPromise
+			.then(pack => {
+				pack.stopCapturingRequests();
+				if (!pack.invalid) return;
+				this.packPromise = undefined;
+				this.logger.log(`Storing pack...`);
+				let promise;
+				const newBuildDependencies = new Set();
+				for (const dep of this.newBuildDependencies) {
+					if (!this.buildDependencies.has(dep)) {
+						newBuildDependencies.add(dep);
+					}
+				}
+				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
+					if (reportProgress) reportProgress(0.5, "resolve build dependencies");
+					this.logger.debug(
+						`Capturing build dependencies... (${Array.from(
+							newBuildDependencies
+						).join(", ")})`
+					);
+					promise = new Promise((resolve, reject) => {
+						this.logger.time("resolve build dependencies");
+						this.fileSystemInfo.resolveBuildDependencies(
+							this.context,
+							newBuildDependencies,
+							(err, result) => {
+								this.logger.timeEnd("resolve build dependencies");
+								if (err) return reject(err);
 
-const validate = createSchemaValidation(
-	__webpack_require__(2885),
-	() => __webpack_require__(30501),
-	{
-		name: "SourceMap DevTool Plugin",
-		baseDataPath: "options"
-	}
-);
-/**
- * @typedef {object} SourceMapTask
- * @property {Source} asset
- * @property {AssetInfo} assetInfo
- * @property {(string | Module)[]} modules
- * @property {string} source
- * @property {string} file
- * @property {SourceMap} sourceMap
- * @property {ItemCacheFacade} cacheItem cache item
- */
+								this.logger.time("snapshot build dependencies");
+								const {
+									files,
+									directories,
+									missing,
+									resolveResults,
+									resolveDependencies
+								} = result;
+								if (this.resolveResults) {
+									for (const [key, value] of resolveResults) {
+										this.resolveResults.set(key, value);
+									}
+								} else {
+									this.resolveResults = resolveResults;
+								}
+								if (reportProgress) {
+									reportProgress(
+										0.6,
+										"snapshot build dependencies",
+										"resolving"
+									);
+								}
+								this.fileSystemInfo.createSnapshot(
+									undefined,
+									resolveDependencies.files,
+									resolveDependencies.directories,
+									resolveDependencies.missing,
+									this.snapshot.resolveBuildDependencies,
+									(err, snapshot) => {
+										if (err) {
+											this.logger.timeEnd("snapshot build dependencies");
+											return reject(err);
+										}
+										if (!snapshot) {
+											this.logger.timeEnd("snapshot build dependencies");
+											return reject(
+												new Error("Unable to snapshot resolve dependencies")
+											);
+										}
+										if (this.resolveBuildDependenciesSnapshot) {
+											this.resolveBuildDependenciesSnapshot =
+												this.fileSystemInfo.mergeSnapshots(
+													this.resolveBuildDependenciesSnapshot,
+													snapshot
+												);
+										} else {
+											this.resolveBuildDependenciesSnapshot = snapshot;
+										}
+										if (reportProgress) {
+											reportProgress(
+												0.7,
+												"snapshot build dependencies",
+												"modules"
+											);
+										}
+										this.fileSystemInfo.createSnapshot(
+											undefined,
+											files,
+											directories,
+											missing,
+											this.snapshot.buildDependencies,
+											(err, snapshot) => {
+												this.logger.timeEnd("snapshot build dependencies");
+												if (err) return reject(err);
+												if (!snapshot) {
+													return reject(
+														new Error("Unable to snapshot build dependencies")
+													);
+												}
+												this.logger.debug("Captured build dependencies");
 
-/**
- * Escapes regular expression metacharacters
- * @param {string} str String to quote
- * @returns {string} Escaped string
- */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+												if (this.buildSnapshot) {
+													this.buildSnapshot =
+														this.fileSystemInfo.mergeSnapshots(
+															this.buildSnapshot,
+															snapshot
+														);
+												} else {
+													this.buildSnapshot = snapshot;
+												}
 
-/**
- * Creating {@link SourceMapTask} for given file
- * @param {string} file current compiled file
- * @param {Source} asset the asset
- * @param {AssetInfo} assetInfo the asset info
- * @param {MapOptions} options source map options
- * @param {Compilation} compilation compilation instance
- * @param {ItemCacheFacade} cacheItem cache item
- * @returns {SourceMapTask | undefined} created task instance or `undefined`
- */
-const getTaskForFile = (
-	file,
-	asset,
-	assetInfo,
-	options,
-	compilation,
-	cacheItem
-) => {
-	let source;
-	/** @type {SourceMap} */
-	let sourceMap;
-	/**
-	 * Check if asset can build source map
-	 */
-	if (asset.sourceAndMap) {
-		const sourceAndMap = asset.sourceAndMap(options);
-		sourceMap = /** @type {SourceMap} */ (sourceAndMap.map);
-		source = sourceAndMap.source;
-	} else {
-		sourceMap = /** @type {SourceMap} */ (asset.map(options));
-		source = asset.source();
+												resolve();
+											}
+										);
+									}
+								);
+							}
+						);
+					});
+				} else {
+					promise = Promise.resolve();
+				}
+				return promise.then(() => {
+					if (reportProgress) reportProgress(0.8, "serialize pack");
+					this.logger.time(`store pack`);
+					const updatedBuildDependencies = new Set(this.buildDependencies);
+					for (const dep of newBuildDependencies) {
+						updatedBuildDependencies.add(dep);
+					}
+					const content = new PackContainer(
+						pack,
+						this.version,
+						this.buildSnapshot,
+						updatedBuildDependencies,
+						this.resolveResults,
+						this.resolveBuildDependenciesSnapshot
+					);
+					return this.fileSerializer
+						.serialize(content, {
+							filename: `${this.cacheLocation}/index${this._extension}`,
+							extension: `${this._extension}`,
+							logger: this.logger,
+							profile: this.profile
+						})
+						.then(() => {
+							for (const dep of newBuildDependencies) {
+								this.buildDependencies.add(dep);
+							}
+							this.newBuildDependencies.clear();
+							this.logger.timeEnd(`store pack`);
+							const stats = pack.getContentStats();
+							this.logger.log(
+								"Stored pack (%d items, %d files, %d MiB)",
+								pack.itemInfo.size,
+								stats.count,
+								Math.round(stats.size / 1024 / 1024)
+							);
+						})
+						.catch(err => {
+							this.logger.timeEnd(`store pack`);
+							this.logger.warn(`Caching failed for pack: ${err}`);
+							this.logger.debug(err.stack);
+						});
+				});
+			})
+			.catch(err => {
+				this.logger.warn(`Caching failed for pack: ${err}`);
+				this.logger.debug(err.stack);
+			}));
 	}
-	if (!sourceMap || typeof source !== "string") return;
-	const context = compilation.options.context;
-	const root = compilation.compiler.root;
-	const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root);
-	const modules = sourceMap.sources.map(source => {
-		if (!source.startsWith("webpack://")) return source;
-		source = cachedAbsolutify(source.slice(10));
-		const module = compilation.findModule(source);
-		return module || source;
-	});
-
-	return {
-		file,
-		asset,
-		source,
-		assetInfo,
-		sourceMap,
-		modules,
-		cacheItem
-	};
-};
-
-class SourceMapDevToolPlugin {
-	/**
-	 * @param {SourceMapDevToolPluginOptions} [options] options object
-	 * @throws {Error} throws error, if got more than 1 arguments
-	 */
-	constructor(options = {}) {
-		validate(options);
 
-		/** @type {string | false} */
-		this.sourceMapFilename = options.filename;
-		/** @type {string | false} */
-		this.sourceMappingURLComment =
-			options.append === false
-				? false
-				: options.append || "\n//# source" + "MappingURL=[url]";
-		/** @type {string | Function} */
-		this.moduleFilenameTemplate =
-			options.moduleFilenameTemplate || "webpack://[namespace]/[resourcePath]";
-		/** @type {string | Function} */
-		this.fallbackModuleFilenameTemplate =
-			options.fallbackModuleFilenameTemplate ||
-			"webpack://[namespace]/[resourcePath]?[hash]";
-		/** @type {string} */
-		this.namespace = options.namespace || "";
-		/** @type {SourceMapDevToolPluginOptions} */
-		this.options = options;
+	clear() {
+		this.fileSystemInfo.clear();
+		this.buildDependencies.clear();
+		this.newBuildDependencies.clear();
+		this.resolveBuildDependenciesSnapshot = undefined;
+		this.resolveResults = undefined;
+		this.buildSnapshot = undefined;
+		this.packPromise = undefined;
 	}
+}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const outputFs = compiler.outputFileSystem;
-		const sourceMapFilename = this.sourceMapFilename;
-		const sourceMappingURLComment = this.sourceMappingURLComment;
-		const moduleFilenameTemplate = this.moduleFilenameTemplate;
-		const namespace = this.namespace;
-		const fallbackModuleFilenameTemplate = this.fallbackModuleFilenameTemplate;
-		const requestShortener = compiler.requestShortener;
-		const options = this.options;
-		options.test = options.test || /\.((c|m)?js|css)($|\?)/i;
-
-		const matchObject = ModuleFilenameHelpers.matchObject.bind(
-			undefined,
-			options
-		);
+module.exports = PackFileCacheStrategy;
 
-		compiler.hooks.compilation.tap("SourceMapDevToolPlugin", compilation => {
-			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
 
-			compilation.hooks.processAssets.tapAsync(
-				{
-					name: "SourceMapDevToolPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
-					additionalAssets: true
-				},
-				(assets, callback) => {
-					const chunkGraph = compilation.chunkGraph;
-					const cache = compilation.getCache("SourceMapDevToolPlugin");
-					/** @type {Map<string | Module, string>} */
-					const moduleToSourceNameMapping = new Map();
-					/**
-					 * @type {Function}
-					 * @returns {void}
-					 */
-					const reportProgress =
-						ProgressPlugin.getReporter(compilation.compiler) || (() => {});
+/***/ }),
 
-					/** @type {Map<string, Chunk>} */
-					const fileToChunk = new Map();
-					for (const chunk of compilation.chunks) {
-						for (const file of chunk.files) {
-							fileToChunk.set(file, chunk);
-						}
-						for (const file of chunk.auxiliaryFiles) {
-							fileToChunk.set(file, chunk);
-						}
-					}
+/***/ 97347:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					/** @type {string[]} */
-					const files = [];
-					for (const file of Object.keys(assets)) {
-						if (matchObject(file)) {
-							files.push(file);
-						}
-					}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					reportProgress(0.0);
-					/** @type {SourceMapTask[]} */
-					const tasks = [];
-					let fileIndex = 0;
 
-					asyncLib.each(
-						files,
-						(file, callback) => {
-							const asset = compilation.getAsset(file);
-							if (asset.info.related && asset.info.related.sourceMap) {
-								fileIndex++;
-								return callback();
-							}
-							const cacheItem = cache.getItemCache(
-								file,
-								cache.mergeEtags(
-									cache.getLazyHashedEtag(asset.source),
-									namespace
-								)
-							);
 
-							cacheItem.get((err, cacheEntry) => {
-								if (err) {
-									return callback(err);
-								}
-								/**
-								 * If presented in cache, reassigns assets. Cache assets already have source maps.
-								 */
-								if (cacheEntry) {
-									const { assets, assetsInfo } = cacheEntry;
-									for (const cachedFile of Object.keys(assets)) {
-										if (cachedFile === file) {
-											compilation.updateAsset(
-												cachedFile,
-												assets[cachedFile],
-												assetsInfo[cachedFile]
-											);
-										} else {
-											compilation.emitAsset(
-												cachedFile,
-												assets[cachedFile],
-												assetsInfo[cachedFile]
-											);
-										}
-										/**
-										 * Add file to chunk, if not presented there
-										 */
-										if (cachedFile !== file) {
-											const chunk = fileToChunk.get(file);
-											if (chunk !== undefined)
-												chunk.auxiliaryFiles.add(cachedFile);
-										}
-									}
+const LazySet = __webpack_require__(38938);
+const makeSerializable = __webpack_require__(33032);
 
-									reportProgress(
-										(0.5 * ++fileIndex) / files.length,
-										file,
-										"restored cached SourceMap"
-									);
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
+/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
 
-									return callback();
-								}
+class CacheEntry {
+	constructor(result, snapshot) {
+		this.result = result;
+		this.snapshot = snapshot;
+	}
 
-								reportProgress(
-									(0.5 * fileIndex) / files.length,
-									file,
-									"generate SourceMap"
-								);
+	serialize({ write }) {
+		write(this.result);
+		write(this.snapshot);
+	}
 
-								/** @type {SourceMapTask | undefined} */
-								const task = getTaskForFile(
-									file,
-									asset.source,
-									asset.info,
-									{
-										module: options.module,
-										columns: options.columns
-									},
-									compilation,
-									cacheItem
-								);
+	deserialize({ read }) {
+		this.result = read();
+		this.snapshot = read();
+	}
+}
 
-								if (task) {
-									const modules = task.modules;
+makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin");
 
-									for (let idx = 0; idx < modules.length; idx++) {
-										const module = modules[idx];
-										if (!moduleToSourceNameMapping.get(module)) {
-											moduleToSourceNameMapping.set(
-												module,
-												ModuleFilenameHelpers.createFilename(
-													module,
-													{
-														moduleFilenameTemplate: moduleFilenameTemplate,
-														namespace: namespace
-													},
-													{
-														requestShortener,
-														chunkGraph,
-														hashFunction: compilation.outputOptions.hashFunction
-													}
-												)
-											);
-										}
-									}
+/**
+ * @template T
+ * @param {Set<T> | LazySet<T>} set set to add items to
+ * @param {Set<T> | LazySet<T>} otherSet set to add items from
+ * @returns {void}
+ */
+const addAllToSet = (set, otherSet) => {
+	if (set instanceof LazySet) {
+		set.addAll(otherSet);
+	} else {
+		for (const item of otherSet) {
+			set.add(item);
+		}
+	}
+};
 
-									tasks.push(task);
-								}
+/**
+ * @param {Object} object an object
+ * @param {boolean} excludeContext if true, context is not included in string
+ * @returns {string} stringified version
+ */
+const objectToString = (object, excludeContext) => {
+	let str = "";
+	for (const key in object) {
+		if (excludeContext && key === "context") continue;
+		const value = object[key];
+		if (typeof value === "object" && value !== null) {
+			str += `|${key}=[${objectToString(value, false)}|]`;
+		} else {
+			str += `|${key}=|${value}`;
+		}
+	}
+	return str;
+};
 
-								reportProgress(
-									(0.5 * ++fileIndex) / files.length,
-									file,
-									"generated SourceMap"
-								);
-
-								callback();
-							});
-						},
-						err => {
-							if (err) {
-								return callback(err);
+class ResolverCachePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const cache = compiler.getCache("ResolverCachePlugin");
+		/** @type {FileSystemInfo} */
+		let fileSystemInfo;
+		let snapshotOptions;
+		let realResolves = 0;
+		let cachedResolves = 0;
+		let cacheInvalidResolves = 0;
+		let concurrentResolves = 0;
+		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
+			snapshotOptions = compilation.options.snapshot.resolve;
+			fileSystemInfo = compilation.fileSystemInfo;
+			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
+				if (realResolves + cachedResolves > 0) {
+					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
+					logger.log(
+						`${Math.round(
+							(100 * realResolves) / (realResolves + cachedResolves)
+						)}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)`
+					);
+					realResolves = 0;
+					cachedResolves = 0;
+					cacheInvalidResolves = 0;
+					concurrentResolves = 0;
+				}
+			});
+		});
+		/**
+		 * @param {ItemCacheFacade} itemCache cache
+		 * @param {Resolver} resolver the resolver
+		 * @param {Object} resolveContext context for resolving meta info
+		 * @param {Object} request the request info object
+		 * @param {function((Error | null)=, Object=): void} callback callback function
+		 * @returns {void}
+		 */
+		const doRealResolve = (
+			itemCache,
+			resolver,
+			resolveContext,
+			request,
+			callback
+		) => {
+			realResolves++;
+			const newRequest = {
+				_ResolverCachePluginCacheMiss: true,
+				...request
+			};
+			const newResolveContext = {
+				...resolveContext,
+				stack: new Set(),
+				missingDependencies: new LazySet(),
+				fileDependencies: new LazySet(),
+				contextDependencies: new LazySet()
+			};
+			const propagate = key => {
+				if (resolveContext[key]) {
+					addAllToSet(resolveContext[key], newResolveContext[key]);
+				}
+			};
+			const resolveTime = Date.now();
+			resolver.doResolve(
+				resolver.hooks.resolve,
+				newRequest,
+				"Cache miss",
+				newResolveContext,
+				(err, result) => {
+					propagate("fileDependencies");
+					propagate("contextDependencies");
+					propagate("missingDependencies");
+					if (err) return callback(err);
+					const fileDependencies = newResolveContext.fileDependencies;
+					const contextDependencies = newResolveContext.contextDependencies;
+					const missingDependencies = newResolveContext.missingDependencies;
+					fileSystemInfo.createSnapshot(
+						resolveTime,
+						fileDependencies,
+						contextDependencies,
+						missingDependencies,
+						snapshotOptions,
+						(err, snapshot) => {
+							if (err) return callback(err);
+							if (!snapshot) {
+								if (result) return callback(null, result);
+								return callback();
 							}
-
-							reportProgress(0.5, "resolve sources");
-							/** @type {Set<string>} */
-							const usedNamesSet = new Set(moduleToSourceNameMapping.values());
-							/** @type {Set<string>} */
-							const conflictDetectionSet = new Set();
-
-							/**
-							 * all modules in defined order (longest identifier first)
-							 * @type {Array<string | Module>}
-							 */
-							const allModules = Array.from(
-								moduleToSourceNameMapping.keys()
-							).sort((a, b) => {
-								const ai = typeof a === "string" ? a : a.identifier();
-								const bi = typeof b === "string" ? b : b.identifier();
-								return ai.length - bi.length;
+							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
+								if (storeErr) return callback(storeErr);
+								if (result) return callback(null, result);
+								callback();
 							});
-
-							// find modules with conflicting source names
-							for (let idx = 0; idx < allModules.length; idx++) {
-								const module = allModules[idx];
-								let sourceName = moduleToSourceNameMapping.get(module);
-								let hasName = conflictDetectionSet.has(sourceName);
-								if (!hasName) {
-									conflictDetectionSet.add(sourceName);
-									continue;
-								}
-
-								// try the fallback name first
-								sourceName = ModuleFilenameHelpers.createFilename(
-									module,
-									{
-										moduleFilenameTemplate: fallbackModuleFilenameTemplate,
-										namespace: namespace
-									},
-									{
-										requestShortener,
-										chunkGraph,
-										hashFunction: compilation.outputOptions.hashFunction
-									}
-								);
-								hasName = usedNamesSet.has(sourceName);
-								if (!hasName) {
-									moduleToSourceNameMapping.set(module, sourceName);
-									usedNamesSet.add(sourceName);
-									continue;
+						}
+					);
+				}
+			);
+		};
+		compiler.resolverFactory.hooks.resolver.intercept({
+			factory(type, hook) {
+				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
+				const activeRequests = new Map();
+				hook.tap(
+					"ResolverCachePlugin",
+					/**
+					 * @param {Resolver} resolver the resolver
+					 * @param {Object} options resolve options
+					 * @param {Object} userOptions resolve options passed by the user
+					 * @returns {void}
+					 */
+					(resolver, options, userOptions) => {
+						if (options.cache !== true) return;
+						const optionsIdent = objectToString(userOptions, false);
+						const cacheWithContext =
+							options.cacheWithContext !== undefined
+								? options.cacheWithContext
+								: false;
+						resolver.hooks.resolve.tapAsync(
+							{
+								name: "ResolverCachePlugin",
+								stage: -100
+							},
+							(request, resolveContext, callback) => {
+								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
+									return callback();
 								}
-
-								// otherwise just append stars until we have a valid name
-								while (hasName) {
-									sourceName += "*";
-									hasName = usedNamesSet.has(sourceName);
+								const identifier = `${type}${optionsIdent}${objectToString(
+									request,
+									!cacheWithContext
+								)}`;
+								const activeRequest = activeRequests.get(identifier);
+								if (activeRequest) {
+									activeRequest.push(callback);
+									return;
 								}
-								moduleToSourceNameMapping.set(module, sourceName);
-								usedNamesSet.add(sourceName);
-							}
-
-							let taskIndex = 0;
-
-							asyncLib.each(
-								tasks,
-								(task, callback) => {
-									const assets = Object.create(null);
-									const assetsInfo = Object.create(null);
-									const file = task.file;
-									const chunk = fileToChunk.get(file);
-									const sourceMap = task.sourceMap;
-									const source = task.source;
-									const modules = task.modules;
-
-									reportProgress(
-										0.5 + (0.5 * taskIndex) / tasks.length,
-										file,
-										"attach SourceMap"
-									);
-
-									const moduleFilenames = modules.map(m =>
-										moduleToSourceNameMapping.get(m)
-									);
-									sourceMap.sources = moduleFilenames;
-									if (options.noSources) {
-										sourceMap.sourcesContent = undefined;
-									}
-									sourceMap.sourceRoot = options.sourceRoot || "";
-									sourceMap.file = file;
-									const usesContentHash =
-										sourceMapFilename &&
-										/\[contenthash(:\w+)?\]/.test(sourceMapFilename);
-
-									// If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file`
-									if (usesContentHash && task.assetInfo.contenthash) {
-										const contenthash = task.assetInfo.contenthash;
-										let pattern;
-										if (Array.isArray(contenthash)) {
-											pattern = contenthash.map(quoteMeta).join("|");
-										} else {
-											pattern = quoteMeta(contenthash);
+								const itemCache = cache.getItemCache(identifier, null);
+								let callbacks;
+								const done = (err, result) => {
+									if (callbacks === undefined) {
+										callback(err, result);
+										callbacks = false;
+									} else {
+										for (const callback of callbacks) {
+											callback(err, result);
 										}
-										sourceMap.file = sourceMap.file.replace(
-											new RegExp(pattern, "g"),
-											m => "x".repeat(m.length)
-										);
+										activeRequests.delete(identifier);
+										callbacks = false;
 									}
+								};
+								/**
+								 * @param {Error=} err error if any
+								 * @param {CacheEntry=} cacheEntry cache entry
+								 * @returns {void}
+								 */
+								const processCacheResult = (err, cacheEntry) => {
+									if (err) return done(err);
 
-									/** @type {string | false} */
-									let currentSourceMappingURLComment = sourceMappingURLComment;
-									if (
-										currentSourceMappingURLComment !== false &&
-										/\.css($|\?)/i.test(file)
-									) {
-										currentSourceMappingURLComment =
-											currentSourceMappingURLComment.replace(
-												/^\n\/\/(.*)$/,
-												"\n/*$1*/"
-											);
-									}
-									const sourceMapString = JSON.stringify(sourceMap);
-									if (sourceMapFilename) {
-										let filename = file;
-										const sourceMapContentHash =
-											usesContentHash &&
-											/** @type {string} */ (
-												createHash(compilation.outputOptions.hashFunction)
-													.update(sourceMapString)
-													.digest("hex")
-											);
-										const pathParams = {
-											chunk,
-											filename: options.fileContext
-												? relative(
-														outputFs,
-														`/${options.fileContext}`,
-														`/${filename}`
-												  )
-												: filename,
-											contentHash: sourceMapContentHash
-										};
-										const { path: sourceMapFile, info: sourceMapInfo } =
-											compilation.getPathWithInfo(
-												sourceMapFilename,
-												pathParams
-											);
-										const sourceMapUrl = options.publicPath
-											? options.publicPath + sourceMapFile
-											: relative(
-													outputFs,
-													dirname(outputFs, `/${file}`),
-													`/${sourceMapFile}`
-											  );
-										/** @type {Source} */
-										let asset = new RawSource(source);
-										if (currentSourceMappingURLComment !== false) {
-											// Add source map url to compilation asset, if currentSourceMappingURLComment is set
-											asset = new ConcatSource(
-												asset,
-												compilation.getPath(
-													currentSourceMappingURLComment,
-													Object.assign({ url: sourceMapUrl }, pathParams)
-												)
-											);
-										}
-										const assetInfo = {
-											related: { sourceMap: sourceMapFile }
-										};
-										assets[file] = asset;
-										assetsInfo[file] = assetInfo;
-										compilation.updateAsset(file, asset, assetInfo);
-										// Add source map file to compilation assets and chunk files
-										const sourceMapAsset = new RawSource(sourceMapString);
-										const sourceMapAssetInfo = {
-											...sourceMapInfo,
-											development: true
-										};
-										assets[sourceMapFile] = sourceMapAsset;
-										assetsInfo[sourceMapFile] = sourceMapAssetInfo;
-										compilation.emitAsset(
-											sourceMapFile,
-											sourceMapAsset,
-											sourceMapAssetInfo
+									if (cacheEntry) {
+										const { snapshot, result } = cacheEntry;
+										fileSystemInfo.checkSnapshotValid(
+											snapshot,
+											(err, valid) => {
+												if (err || !valid) {
+													cacheInvalidResolves++;
+													return doRealResolve(
+														itemCache,
+														resolver,
+														resolveContext,
+														request,
+														done
+													);
+												}
+												cachedResolves++;
+												if (resolveContext.missingDependencies) {
+													addAllToSet(
+														resolveContext.missingDependencies,
+														snapshot.getMissingIterable()
+													);
+												}
+												if (resolveContext.fileDependencies) {
+													addAllToSet(
+														resolveContext.fileDependencies,
+														snapshot.getFileIterable()
+													);
+												}
+												if (resolveContext.contextDependencies) {
+													addAllToSet(
+														resolveContext.contextDependencies,
+														snapshot.getContextIterable()
+													);
+												}
+												done(null, result);
+											}
 										);
-										if (chunk !== undefined)
-											chunk.auxiliaryFiles.add(sourceMapFile);
 									} else {
-										if (currentSourceMappingURLComment === false) {
-											throw new Error(
-												"SourceMapDevToolPlugin: append can't be false when no filename is provided"
-											);
-										}
-										/**
-										 * Add source map as data url to asset
-										 */
-										const asset = new ConcatSource(
-											new RawSource(source),
-											currentSourceMappingURLComment
-												.replace(/\[map\]/g, () => sourceMapString)
-												.replace(
-													/\[url\]/g,
-													() =>
-														`data:application/json;charset=utf-8;base64,${Buffer.from(
-															sourceMapString,
-															"utf-8"
-														).toString("base64")}`
-												)
+										doRealResolve(
+											itemCache,
+											resolver,
+											resolveContext,
+											request,
+											done
 										);
-										assets[file] = asset;
-										assetsInfo[file] = undefined;
-										compilation.updateAsset(file, asset);
 									}
-
-									task.cacheItem.store({ assets, assetsInfo }, err => {
-										reportProgress(
-											0.5 + (0.5 * ++taskIndex) / tasks.length,
-											task.file,
-											"attached SourceMap"
-										);
-
-										if (err) {
-											return callback(err);
-										}
-										callback();
-									});
-								},
-								err => {
-									reportProgress(1.0);
-									callback(err);
+								};
+								itemCache.get(processCacheResult);
+								if (callbacks === undefined) {
+									callbacks = [callback];
+									activeRequests.set(identifier, callbacks);
 								}
-							);
-						}
-					);
-				}
-			);
+							}
+						);
+					}
+				);
+				return hook;
+			}
 		});
 	}
 }
 
-module.exports = SourceMapDevToolPlugin;
+module.exports = ResolverCachePlugin;
 
 
 /***/ }),
 
-/***/ 31743:
-/***/ (function(module) {
+/***/ 94075:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -62637,89 +62868,168 @@ module.exports = SourceMapDevToolPlugin;
 
 
 
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-
-class Stats {
-	/**
-	 * @param {Compilation} compilation webpack compilation
-	 */
-	constructor(compilation) {
-		this.compilation = compilation;
-	}
-
-	get hash() {
-		return this.compilation.hash;
-	}
+const createHash = __webpack_require__(49835);
 
-	get startTime() {
-		return this.compilation.startTime;
-	}
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
 
-	get endTime() {
-		return this.compilation.endTime;
-	}
+/**
+ * @typedef {Object} HashableObject
+ * @property {function(Hash): void} updateHash
+ */
 
+class LazyHashedEtag {
 	/**
-	 * @returns {boolean} true if the compilation had a warning
+	 * @param {HashableObject} obj object with updateHash method
+	 * @param {string | HashConstructor} hashFunction the hash function to use
 	 */
-	hasWarnings() {
-		return (
-			this.compilation.warnings.length > 0 ||
-			this.compilation.children.some(child => child.getStats().hasWarnings())
-		);
+	constructor(obj, hashFunction = "md4") {
+		this._obj = obj;
+		this._hash = undefined;
+		this._hashFunction = hashFunction;
 	}
 
 	/**
-	 * @returns {boolean} true if the compilation encountered an error
+	 * @returns {string} hash of object
 	 */
-	hasErrors() {
-		return (
-			this.compilation.errors.length > 0 ||
-			this.compilation.children.some(child => child.getStats().hasErrors())
-		);
+	toString() {
+		if (this._hash === undefined) {
+			const hash = createHash(this._hashFunction);
+			this._obj.updateHash(hash);
+			this._hash = /** @type {string} */ (hash.digest("base64"));
+		}
+		return this._hash;
 	}
+}
 
-	/**
-	 * @param {(string|StatsOptions)=} options stats options
-	 * @returns {StatsCompilation} json output
-	 */
-	toJson(options) {
-		options = this.compilation.createStatsOptions(options, {
-			forToString: false
-		});
+/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapStrings = new Map();
 
-		const statsFactory = this.compilation.createStatsFactory(options);
+/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
+const mapObjects = new WeakMap();
 
-		return statsFactory.create("compilation", this.compilation, {
-			compilation: this.compilation
-		});
+/**
+ * @param {HashableObject} obj object with updateHash method
+ * @param {string | HashConstructor} hashFunction the hash function to use
+ * @returns {LazyHashedEtag} etag
+ */
+const getter = (obj, hashFunction = "md4") => {
+	let innerMap;
+	if (typeof hashFunction === "string") {
+		innerMap = mapStrings.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapStrings.set(hashFunction, innerMap);
+			return newHash;
+		}
+	} else {
+		innerMap = mapObjects.get(hashFunction);
+		if (innerMap === undefined) {
+			const newHash = new LazyHashedEtag(obj, hashFunction);
+			innerMap = new WeakMap();
+			innerMap.set(obj, newHash);
+			mapObjects.set(hashFunction, innerMap);
+			return newHash;
+		}
 	}
+	const hash = innerMap.get(obj);
+	if (hash !== undefined) return hash;
+	const newHash = new LazyHashedEtag(obj, hashFunction);
+	innerMap.set(obj, newHash);
+	return newHash;
+};
 
-	toString(options) {
-		options = this.compilation.createStatsOptions(options, {
-			forToString: true
-		});
+module.exports = getter;
 
-		const statsFactory = this.compilation.createStatsFactory(options);
-		const statsPrinter = this.compilation.createStatsPrinter(options);
 
-		const data = statsFactory.create("compilation", this.compilation, {
-			compilation: this.compilation
-		});
-		const result = statsPrinter.print("compilation", data);
-		return result === undefined ? "" : result;
+/***/ }),
+
+/***/ 54980:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Cache").Etag} Etag */
+
+class MergedEtag {
+	/**
+	 * @param {Etag} a first
+	 * @param {Etag} b second
+	 */
+	constructor(a, b) {
+		this.a = a;
+		this.b = b;
+	}
+
+	toString() {
+		return `${this.a.toString()}|${this.b.toString()}`;
 	}
 }
 
-module.exports = Stats;
+const dualObjectMap = new WeakMap();
+const objectStringMap = new WeakMap();
+
+/**
+ * @param {Etag} a first
+ * @param {Etag} b second
+ * @returns {Etag} result
+ */
+const mergeEtags = (a, b) => {
+	if (typeof a === "string") {
+		if (typeof b === "string") {
+			return `${a}|${b}`;
+		} else {
+			const temp = b;
+			b = a;
+			a = temp;
+		}
+	} else {
+		if (typeof b !== "string") {
+			// both a and b are objects
+			let map = dualObjectMap.get(a);
+			if (map === undefined) {
+				dualObjectMap.set(a, (map = new WeakMap()));
+			}
+			const mergedEtag = map.get(b);
+			if (mergedEtag === undefined) {
+				const newMergedEtag = new MergedEtag(a, b);
+				map.set(b, newMergedEtag);
+				return newMergedEtag;
+			} else {
+				return mergedEtag;
+			}
+		}
+	}
+	// a is object, b is string
+	let map = objectStringMap.get(a);
+	if (map === undefined) {
+		objectStringMap.set(a, (map = new Map()));
+	}
+	const mergedEtag = map.get(b);
+	if (mergedEtag === undefined) {
+		const newMergedEtag = new MergedEtag(a, b);
+		map.set(b, newMergedEtag);
+		return newMergedEtag;
+	} else {
+		return mergedEtag;
+	}
+};
+
+module.exports = mergeEtags;
 
 
 /***/ }),
 
-/***/ 39722:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 13462:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -62729,3373 +63039,4012 @@ module.exports = Stats;
 
 
 
-const { ConcatSource, PrefixSource } = __webpack_require__(51255);
+const path = __webpack_require__(71017);
+const webpackSchema = __webpack_require__(73342);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+// TODO add originPath to PathItem for better errors
+/**
+ * @typedef {Object} PathItem
+ * @property {any} schema the part of the schema
+ * @property {string} path the path in the config
+ */
 
-const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);
-const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0);
-const DELTA_A_TO_Z = "z".charCodeAt(0) - START_LOWERCASE_ALPHABET_CODE + 1;
-const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $
-const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
-	NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9
-const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g;
-const INDENT_MULTILINE_REGEX = /^\t/gm;
-const LINE_SEPARATOR_REGEX = /\r?\n/g;
-const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-zA-Z$_])/;
-const IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX = /[^a-zA-Z0-9$]+/g;
-const COMMENT_END_REGEX = /\*\//g;
-const PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
-const MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
+/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
 
 /**
- * @typedef {Object} RenderManifestOptions
- * @property {Chunk} chunk the chunk used to render
- * @property {string} hash
- * @property {string} fullHash
- * @property {OutputOptions} outputOptions
- * @property {CodeGenerationResults} codeGenerationResults
- * @property {{javascript: ModuleTemplate}} moduleTemplates
- * @property {DependencyTemplates} dependencyTemplates
- * @property {RuntimeTemplate} runtimeTemplate
- * @property {ModuleGraph} moduleGraph
- * @property {ChunkGraph} chunkGraph
+ * @typedef {Object} Problem
+ * @property {ProblemType} type
+ * @property {string} path
+ * @property {string} argument
+ * @property {any=} value
+ * @property {number=} index
+ * @property {string=} expected
  */
 
-/** @typedef {RenderManifestEntryTemplated | RenderManifestEntryStatic} RenderManifestEntry */
-
 /**
- * @typedef {Object} RenderManifestEntryTemplated
- * @property {function(): Source} render
- * @property {string | function(PathData, AssetInfo=): string} filenameTemplate
- * @property {PathData=} pathOptions
- * @property {AssetInfo=} info
- * @property {string} identifier
- * @property {string=} hash
- * @property {boolean=} auxiliary
+ * @typedef {Object} LocalProblem
+ * @property {ProblemType} type
+ * @property {string} path
+ * @property {string=} expected
  */
 
 /**
- * @typedef {Object} RenderManifestEntryStatic
- * @property {function(): Source} render
- * @property {string} filename
- * @property {AssetInfo} info
- * @property {string} identifier
- * @property {string=} hash
- * @property {boolean=} auxiliary
+ * @typedef {Object} ArgumentConfig
+ * @property {string} description
+ * @property {string} [negatedDescription]
+ * @property {string} path
+ * @property {boolean} multiple
+ * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
+ * @property {any[]=} values
  */
 
 /**
- * @typedef {Object} HasId
- * @property {number | string} id
+ * @typedef {Object} Argument
+ * @property {string} description
+ * @property {"string"|"number"|"boolean"} simpleType
+ * @property {boolean} multiple
+ * @property {ArgumentConfig[]} configs
  */
 
 /**
- * @typedef {function(Module, number): boolean} ModuleFilterPredicate
+ * @param {any=} schema a json schema to create arguments for (by default webpack schema is used)
+ * @returns {Record<string, Argument>} object of arguments
  */
+const getArguments = (schema = webpackSchema) => {
+	/** @type {Record<string, Argument>} */
+	const flags = {};
+
+	const pathToArgumentName = input => {
+		return input
+			.replace(/\./g, "-")
+			.replace(/\[\]/g, "")
+			.replace(
+				/(\p{Uppercase_Letter}+|\p{Lowercase_Letter}|\d)(\p{Uppercase_Letter}+)/gu,
+				"$1-$2"
+			)
+			.replace(/-?[^\p{Uppercase_Letter}\p{Lowercase_Letter}\d]+/gu, "-")
+			.toLowerCase();
+	};
+
+	const getSchemaPart = path => {
+		const newPath = path.split("/");
+
+		let schemaPart = schema;
+
+		for (let i = 1; i < newPath.length; i++) {
+			const inner = schemaPart[newPath[i]];
+
+			if (!inner) {
+				break;
+			}
+
+			schemaPart = inner;
+		}
+
+		return schemaPart;
+	};
 
-class Template {
 	/**
 	 *
-	 * @param {Function} fn a runtime function (.runtime.js) "template"
-	 * @returns {string} the updated and normalized function string
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {string | undefined} description
 	 */
-	static getFunctionContent(fn) {
-		return fn
-			.toString()
-			.replace(FUNCTION_CONTENT_REGEX, "")
-			.replace(INDENT_MULTILINE_REGEX, "")
-			.replace(LINE_SEPARATOR_REGEX, "\n");
-	}
+	const getDescription = path => {
+		for (const { schema } of path) {
+			if (schema.cli) {
+				if (schema.cli.helper) continue;
+				if (schema.cli.description) return schema.cli.description;
+			}
+			if (schema.description) return schema.description;
+		}
+	};
 
 	/**
-	 * @param {string} str the string converted to identifier
-	 * @returns {string} created identifier
+	 *
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {string | undefined} negative description
 	 */
-	static toIdentifier(str) {
-		if (typeof str !== "string") return "";
-		return str
-			.replace(IDENTIFIER_NAME_REPLACE_REGEX, "_$1")
-			.replace(IDENTIFIER_ALPHA_NUMERIC_NAME_REPLACE_REGEX, "_");
-	}
+	const getNegatedDescription = path => {
+		for (const { schema } of path) {
+			if (schema.cli) {
+				if (schema.cli.helper) continue;
+				if (schema.cli.negatedDescription) return schema.cli.negatedDescription;
+			}
+		}
+	};
+
 	/**
 	 *
-	 * @param {string} str string to be converted to commented in bundle code
-	 * @returns {string} returns a commented version of string
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {string | undefined} reset description
 	 */
-	static toComment(str) {
-		if (!str) return "";
-		return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`;
-	}
+	const getResetDescription = path => {
+		for (const { schema } of path) {
+			if (schema.cli) {
+				if (schema.cli.helper) continue;
+				if (schema.cli.resetDescription) return schema.cli.resetDescription;
+			}
+		}
+	};
 
 	/**
 	 *
-	 * @param {string} str string to be converted to "normal comment"
-	 * @returns {string} returns a commented version of string
+	 * @param {any} schemaPart schema
+	 * @returns {Pick<ArgumentConfig, "type"|"values">} partial argument config
 	 */
-	static toNormalComment(str) {
-		if (!str) return "";
-		return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`;
-	}
+	const schemaToArgumentConfig = schemaPart => {
+		if (schemaPart.enum) {
+			return {
+				type: "enum",
+				values: schemaPart.enum
+			};
+		}
+		switch (schemaPart.type) {
+			case "number":
+				return {
+					type: "number"
+				};
+			case "string":
+				return {
+					type: schemaPart.absolutePath ? "path" : "string"
+				};
+			case "boolean":
+				return {
+					type: "boolean"
+				};
+		}
+		if (schemaPart.instanceof === "RegExp") {
+			return {
+				type: "RegExp"
+			};
+		}
+		return undefined;
+	};
 
 	/**
-	 * @param {string} str string path to be normalized
-	 * @returns {string} normalized bundle-safe path
+	 * @param {PathItem[]} path path in the schema
+	 * @returns {void}
 	 */
-	static toPath(str) {
-		if (typeof str !== "string") return "";
-		return str
-			.replace(PATH_NAME_NORMALIZE_REPLACE_REGEX, "-")
-			.replace(MATCH_PADDED_HYPHENS_REPLACE_REGEX, "");
-	}
+	const addResetFlag = path => {
+		const schemaPath = path[0].path;
+		const name = pathToArgumentName(`${schemaPath}.reset`);
+		const description =
+			getResetDescription(path) ||
+			`Clear all items provided in '${schemaPath}' configuration. ${getDescription(
+				path
+			)}`;
+		flags[name] = {
+			configs: [
+				{
+					type: "reset",
+					multiple: false,
+					description,
+					path: schemaPath
+				}
+			],
+			description: undefined,
+			simpleType: undefined,
+			multiple: undefined
+		};
+	};
 
-	// map number to a single character a-z, A-Z or multiple characters if number is too big
 	/**
-	 * @param {number} n number to convert to ident
-	 * @returns {string} returns single character ident
+	 * @param {PathItem[]} path full path in schema
+	 * @param {boolean} multiple inside of an array
+	 * @returns {number} number of arguments added
 	 */
-	static numberToIdentifier(n) {
-		if (n >= NUMBER_OF_IDENTIFIER_START_CHARS) {
-			// use multiple letters
-			return (
-				Template.numberToIdentifier(n % NUMBER_OF_IDENTIFIER_START_CHARS) +
-				Template.numberToIdentifierContinuation(
-					Math.floor(n / NUMBER_OF_IDENTIFIER_START_CHARS)
-				)
-			);
-		}
+	const addFlag = (path, multiple) => {
+		const argConfigBase = schemaToArgumentConfig(path[0].schema);
+		if (!argConfigBase) return 0;
 
-		// lower case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
-		}
-		n -= DELTA_A_TO_Z;
+		const negatedDescription = getNegatedDescription(path);
+		const name = pathToArgumentName(path[0].path);
+		/** @type {ArgumentConfig} */
+		const argConfig = {
+			...argConfigBase,
+			multiple,
+			description: getDescription(path),
+			path: path[0].path
+		};
 
-		// upper case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+		if (negatedDescription) {
+			argConfig.negatedDescription = negatedDescription;
 		}
 
-		if (n === DELTA_A_TO_Z) return "_";
-		return "$";
-	}
-
-	/**
-	 * @param {number} n number to convert to ident
-	 * @returns {string} returns single character ident
-	 */
-	static numberToIdentifierContinuation(n) {
-		if (n >= NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS) {
-			// use multiple letters
-			return (
-				Template.numberToIdentifierContinuation(
-					n % NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
-				) +
-				Template.numberToIdentifierContinuation(
-					Math.floor(n / NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS)
-				)
-			);
+		if (!flags[name]) {
+			flags[name] = {
+				configs: [],
+				description: undefined,
+				simpleType: undefined,
+				multiple: undefined
+			};
 		}
 
-		// lower case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_LOWERCASE_ALPHABET_CODE + n);
+		if (
+			flags[name].configs.some(
+				item => JSON.stringify(item) === JSON.stringify(argConfig)
+			)
+		) {
+			return 0;
 		}
-		n -= DELTA_A_TO_Z;
 
-		// upper case
-		if (n < DELTA_A_TO_Z) {
-			return String.fromCharCode(START_UPPERCASE_ALPHABET_CODE + n);
+		if (
+			flags[name].configs.some(
+				item => item.type === argConfig.type && item.multiple !== multiple
+			)
+		) {
+			if (multiple) {
+				throw new Error(
+					`Conflicting schema for ${path[0].path} with ${argConfig.type} type (array type must be before single item type)`
+				);
+			}
+			return 0;
 		}
-		n -= DELTA_A_TO_Z;
 
-		// numbers
-		if (n < 10) {
-			return `${n}`;
-		}
+		flags[name].configs.push(argConfig);
 
-		if (n === 10) return "_";
-		return "$";
-	}
+		return 1;
+	};
 
+	// TODO support `not` and `if/then/else`
+	// TODO support `const`, but we don't use it on our schema
 	/**
 	 *
-	 * @param {string | string[]} s string to convert to identity
-	 * @returns {string} converted identity
+	 * @param {object} schemaPart the current schema
+	 * @param {string} schemaPath the current path in the schema
+	 * @param {{schema: object, path: string}[]} path all previous visited schemaParts
+	 * @param {string | null} inArray if inside of an array, the path to the array
+	 * @returns {number} added arguments
 	 */
-	static indent(s) {
-		if (Array.isArray(s)) {
-			return s.map(Template.indent).join("\n");
-		} else {
-			const str = s.trimRight();
-			if (!str) return "";
-			const ind = str[0] === "\n" ? "" : "\t";
-			return ind + str.replace(/\n([^\n])/g, "\n\t$1");
+	const traverse = (schemaPart, schemaPath = "", path = [], inArray = null) => {
+		while (schemaPart.$ref) {
+			schemaPart = getSchemaPart(schemaPart.$ref);
 		}
-	}
-
-	/**
-	 *
-	 * @param {string|string[]} s string to create prefix for
-	 * @param {string} prefix prefix to compose
-	 * @returns {string} returns new prefix string
-	 */
-	static prefix(s, prefix) {
-		const str = Template.asString(s).trim();
-		if (!str) return "";
-		const ind = str[0] === "\n" ? "" : prefix;
-		return ind + str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
-	}
 
-	/**
-	 *
-	 * @param {string|string[]} str string or string collection
-	 * @returns {string} returns a single string from array
-	 */
-	static asString(str) {
-		if (Array.isArray(str)) {
-			return str.join("\n");
+		const repetitions = path.filter(({ schema }) => schema === schemaPart);
+		if (
+			repetitions.length >= 2 ||
+			repetitions.some(({ path }) => path === schemaPath)
+		) {
+			return 0;
 		}
-		return str;
-	}
 
-	/**
-	 * @typedef {Object} WithId
-	 * @property {string|number} id
-	 */
+		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
 
-	/**
-	 * @param {WithId[]} modules a collection of modules to get array bounds for
-	 * @returns {[number, number] | false} returns the upper and lower array bounds
-	 * or false if not every module has a number based id
-	 */
-	static getModulesArrayBounds(modules) {
-		let maxId = -Infinity;
-		let minId = Infinity;
-		for (const module of modules) {
-			const moduleId = module.id;
-			if (typeof moduleId !== "number") return false;
-			if (maxId < moduleId) maxId = moduleId;
-			if (minId > moduleId) minId = moduleId;
-		}
-		if (minId < 16 + ("" + minId).length) {
-			// add minId x ',' instead of 'Array(minId).concat(…)'
-			minId = 0;
-		}
-		// start with -1 because the first module needs no comma
-		let objectOverhead = -1;
-		for (const module of modules) {
-			// module id + colon + comma
-			objectOverhead += `${module.id}`.length + 2;
-		}
-		// number of commas, or when starting non-zero the length of Array(minId).concat()
-		const arrayOverhead = minId === 0 ? maxId : 16 + `${minId}`.length + maxId;
-		return arrayOverhead < objectOverhead ? [minId, maxId] : false;
-	}
+		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
 
-	/**
-	 * @param {ChunkRenderContext} renderContext render context
-	 * @param {Module[]} modules modules to render (should be ordered by identifier)
-	 * @param {function(Module): Source} renderModule function to render a module
-	 * @param {string=} prefix applying prefix strings
-	 * @returns {Source} rendered chunk modules in a Source object
-	 */
-	static renderChunkModules(renderContext, modules, renderModule, prefix = "") {
-		const { chunkGraph } = renderContext;
-		var source = new ConcatSource();
-		if (modules.length === 0) {
-			return null;
-		}
-		/** @type {{id: string|number, source: Source|string}[]} */
-		const allModules = modules.map(module => {
-			return {
-				id: chunkGraph.getModuleId(module),
-				source: renderModule(module) || "false"
-			};
-		});
-		const bounds = Template.getModulesArrayBounds(allModules);
-		if (bounds) {
-			// Render a spare array
-			const minId = bounds[0];
-			const maxId = bounds[1];
-			if (minId !== 0) {
-				source.add(`Array(${minId}).concat(`);
-			}
-			source.add("[\n");
-			/** @type {Map<string|number, {id: string|number, source: Source|string}>} */
-			const modules = new Map();
-			for (const module of allModules) {
-				modules.set(module.id, module);
-			}
-			for (let idx = minId; idx <= maxId; idx++) {
-				const module = modules.get(idx);
-				if (idx !== minId) {
-					source.add(",\n");
-				}
-				source.add(`/* ${idx} */`);
-				if (module) {
-					source.add("\n");
-					source.add(module.source);
-				}
-			}
-			source.add("\n" + prefix + "]");
-			if (minId !== 0) {
-				source.add(")");
-			}
-		} else {
-			// Render an object
-			source.add("{\n");
-			for (let i = 0; i < allModules.length; i++) {
-				const module = allModules[i];
-				if (i !== 0) {
-					source.add(",\n");
+		let addedArguments = 0;
+
+		addedArguments += addFlag(fullPath, !!inArray);
+
+		if (schemaPart.type === "object") {
+			if (schemaPart.properties) {
+				for (const property of Object.keys(schemaPart.properties)) {
+					addedArguments += traverse(
+						schemaPart.properties[property],
+						schemaPath ? `${schemaPath}.${property}` : property,
+						fullPath,
+						inArray
+					);
 				}
-				source.add(`\n/***/ ${JSON.stringify(module.id)}:\n`);
-				source.add(module.source);
 			}
-			source.add(`\n\n${prefix}}`);
+
+			return addedArguments;
 		}
-		return source;
-	}
 
-	/**
-	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-	 * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
-	 * @returns {Source} rendered runtime modules in a Source object
-	 */
-	static renderRuntimeModules(runtimeModules, renderContext) {
-		const source = new ConcatSource();
-		for (const module of runtimeModules) {
-			const codeGenerationResults = renderContext.codeGenerationResults;
-			let runtimeSource;
-			if (codeGenerationResults) {
-				runtimeSource = codeGenerationResults.getSource(
-					module,
-					renderContext.chunk.runtime,
-					"runtime"
-				);
-			} else {
-				const codeGenResult = module.codeGeneration({
-					chunkGraph: renderContext.chunkGraph,
-					dependencyTemplates: renderContext.dependencyTemplates,
-					moduleGraph: renderContext.moduleGraph,
-					runtimeTemplate: renderContext.runtimeTemplate,
-					runtime: renderContext.chunk.runtime,
-					codeGenerationResults
-				});
-				if (!codeGenResult) continue;
-				runtimeSource = codeGenResult.sources.get("runtime");
+		if (schemaPart.type === "array") {
+			if (inArray) {
+				return 0;
 			}
-			if (runtimeSource) {
-				source.add(Template.toNormalComment(module.identifier()) + "\n");
-				if (!module.shouldIsolate()) {
-					source.add(runtimeSource);
-					source.add("\n\n");
-				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
-					source.add("(() => {\n");
-					source.add(new PrefixSource("\t", runtimeSource));
-					source.add("\n})();\n\n");
-				} else {
-					source.add("!function() {\n");
-					source.add(new PrefixSource("\t", runtimeSource));
-					source.add("\n}();\n\n");
+			if (Array.isArray(schemaPart.items)) {
+				let i = 0;
+				for (const item of schemaPart.items) {
+					addedArguments += traverse(
+						item,
+						`${schemaPath}.${i}`,
+						fullPath,
+						schemaPath
+					);
 				}
-			}
-		}
-		return source;
-	}
-
-	/**
-	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-	 * @param {RenderContext} renderContext render context
-	 * @returns {Source} rendered chunk runtime modules in a Source object
-	 */
-	static renderChunkRuntimeModules(runtimeModules, renderContext) {
-		return new PrefixSource(
-			"/******/ ",
-			new ConcatSource(
-				"function(__webpack_require__) { // webpackRuntimeModules\n",
-				this.renderRuntimeModules(runtimeModules, renderContext),
-				"}\n"
-			)
-		);
-	}
-}
-
-module.exports = Template;
-module.exports.NUMBER_OF_IDENTIFIER_START_CHARS =
-	NUMBER_OF_IDENTIFIER_START_CHARS;
-module.exports.NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
-	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS;
-
 
-/***/ }),
+				return addedArguments;
+			}
 
-/***/ 80734:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			addedArguments += traverse(
+				schemaPart.items,
+				`${schemaPath}[]`,
+				fullPath,
+				schemaPath
+			);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Jason Anderson @diurnalist
-*/
+			if (addedArguments > 0) {
+				addResetFlag(fullPath);
+				addedArguments++;
+			}
 
+			return addedArguments;
+		}
 
+		const maybeOf = schemaPart.oneOf || schemaPart.anyOf || schemaPart.allOf;
 
-const { basename, extname } = __webpack_require__(71017);
-const util = __webpack_require__(73837);
-const Chunk = __webpack_require__(39385);
-const Module = __webpack_require__(73208);
-const { parseResource } = __webpack_require__(82186);
+		if (maybeOf) {
+			const items = maybeOf;
 
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./Compilation").PathData} PathData */
-/** @typedef {import("./Compiler")} Compiler */
+			for (let i = 0; i < items.length; i++) {
+				addedArguments += traverse(items[i], schemaPath, fullPath, inArray);
+			}
 
-const REGEXP = /\[\\*([\w:]+)\\*\]/gi;
+			return addedArguments;
+		}
 
-const prepareId = id => {
-	if (typeof id !== "string") return id;
+		return addedArguments;
+	};
 
-	if (/^"\s\+*.*\+\s*"$/.test(id)) {
-		const match = /^"\s\+*\s*(.*)\s*\+\s*"$/.exec(id);
+	traverse(schema);
 
-		return `" + (${match[1]} + "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_") + "`;
+	// Summarize flags
+	for (const name of Object.keys(flags)) {
+		const argument = flags[name];
+		argument.description = argument.configs.reduce((desc, { description }) => {
+			if (!desc) return description;
+			if (!description) return desc;
+			if (desc.includes(description)) return desc;
+			return `${desc} ${description}`;
+		}, /** @type {string | undefined} */ (undefined));
+		argument.simpleType = argument.configs.reduce((t, argConfig) => {
+			/** @type {"string" | "number" | "boolean"} */
+			let type = "string";
+			switch (argConfig.type) {
+				case "number":
+					type = "number";
+					break;
+				case "reset":
+				case "boolean":
+					type = "boolean";
+					break;
+				case "enum":
+					if (argConfig.values.every(v => typeof v === "boolean"))
+						type = "boolean";
+					if (argConfig.values.every(v => typeof v === "number"))
+						type = "number";
+					break;
+			}
+			if (t === undefined) return type;
+			return t === type ? t : "string";
+		}, /** @type {"string" | "number" | "boolean" | undefined} */ (undefined));
+		argument.multiple = argument.configs.some(c => c.multiple);
 	}
 
-	return id.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+	return flags;
 };
 
-const hashLength = (replacer, handler, assetInfo, hashName) => {
-	const fn = (match, arg, input) => {
-		let result;
-		const length = arg && parseInt(arg, 10);
-
-		if (length && handler) {
-			result = handler(length);
-		} else {
-			const hash = replacer(match, arg, input);
+const cliAddedItems = new WeakMap();
 
-			result = length ? hash.slice(0, length) : hash;
-		}
-		if (assetInfo) {
-			assetInfo.immutable = true;
-			if (Array.isArray(assetInfo[hashName])) {
-				assetInfo[hashName] = [...assetInfo[hashName], result];
-			} else if (assetInfo[hashName]) {
-				assetInfo[hashName] = [assetInfo[hashName], result];
+/**
+ * @param {any} config configuration
+ * @param {string} schemaPath path in the config
+ * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
+ * @returns {{ problem?: LocalProblem, object?: any, property?: string | number, value?: any }} problem or object with property and value
+ */
+const getObjectAndProperty = (config, schemaPath, index = 0) => {
+	if (!schemaPath) return { value: config };
+	const parts = schemaPath.split(".");
+	let property = parts.pop();
+	let current = config;
+	let i = 0;
+	for (const part of parts) {
+		const isArray = part.endsWith("[]");
+		const name = isArray ? part.slice(0, -2) : part;
+		let value = current[name];
+		if (isArray) {
+			if (value === undefined) {
+				value = {};
+				current[name] = [...Array.from({ length: index }), value];
+				cliAddedItems.set(current[name], index + 1);
+			} else if (!Array.isArray(value)) {
+				return {
+					problem: {
+						type: "unexpected-non-array-in-path",
+						path: parts.slice(0, i).join(".")
+					}
+				};
 			} else {
-				assetInfo[hashName] = result;
+				let addedItems = cliAddedItems.get(value) || 0;
+				while (addedItems <= index) {
+					value.push(undefined);
+					addedItems++;
+				}
+				cliAddedItems.set(value, addedItems);
+				const x = value.length - addedItems + index;
+				if (value[x] === undefined) {
+					value[x] = {};
+				} else if (value[x] === null || typeof value[x] !== "object") {
+					return {
+						problem: {
+							type: "unexpected-non-object-in-path",
+							path: parts.slice(0, i).join(".")
+						}
+					};
+				}
+				value = value[x];
 			}
-		}
-		return result;
-	};
-
-	return fn;
-};
-
-const replacer = (value, allowEmpty) => {
-	const fn = (match, arg, input) => {
-		if (typeof value === "function") {
-			value = value();
-		}
-		if (value === null || value === undefined) {
-			if (!allowEmpty) {
-				throw new Error(
-					`Path variable ${match} not implemented in this context: ${input}`
-				);
+		} else {
+			if (value === undefined) {
+				value = current[name] = {};
+			} else if (value === null || typeof value !== "object") {
+				return {
+					problem: {
+						type: "unexpected-non-object-in-path",
+						path: parts.slice(0, i).join(".")
+					}
+				};
 			}
-
-			return "";
+		}
+		current = value;
+		i++;
+	}
+	let value = current[property];
+	if (property.endsWith("[]")) {
+		const name = property.slice(0, -2);
+		const value = current[name];
+		if (value === undefined) {
+			current[name] = [...Array.from({ length: index }), undefined];
+			cliAddedItems.set(current[name], index + 1);
+			return { object: current[name], property: index, value: undefined };
+		} else if (!Array.isArray(value)) {
+			current[name] = [value, ...Array.from({ length: index }), undefined];
+			cliAddedItems.set(current[name], index + 1);
+			return { object: current[name], property: index + 1, value: undefined };
 		} else {
-			return `${value}`;
+			let addedItems = cliAddedItems.get(value) || 0;
+			while (addedItems <= index) {
+				value.push(undefined);
+				addedItems++;
+			}
+			cliAddedItems.set(value, addedItems);
+			const x = value.length - addedItems + index;
+			if (value[x] === undefined) {
+				value[x] = {};
+			} else if (value[x] === null || typeof value[x] !== "object") {
+				return {
+					problem: {
+						type: "unexpected-non-object-in-path",
+						path: schemaPath
+					}
+				};
+			}
+			return {
+				object: value,
+				property: x,
+				value: value[x]
+			};
 		}
-	};
+	}
+	return { object: current, property, value };
+};
 
-	return fn;
+/**
+ * @param {any} config configuration
+ * @param {string} schemaPath path in the config
+ * @param {any} value parsed value
+ * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
+ * @returns {LocalProblem | null} problem or null for success
+ */
+const setValue = (config, schemaPath, value, index) => {
+	const { problem, object, property } = getObjectAndProperty(
+		config,
+		schemaPath,
+		index
+	);
+	if (problem) return problem;
+	object[property] = value;
+	return null;
 };
 
-const deprecationCache = new Map();
-const deprecatedFunction = (() => () => {})();
-const deprecated = (fn, message, code) => {
-	let d = deprecationCache.get(message);
-	if (d === undefined) {
-		d = util.deprecate(deprecatedFunction, message, code);
-		deprecationCache.set(message, d);
+/**
+ * @param {ArgumentConfig} argConfig processing instructions
+ * @param {any} config configuration
+ * @param {any} value the value
+ * @param {number | undefined} index the index if multiple values provided
+ * @returns {LocalProblem | null} a problem if any
+ */
+const processArgumentConfig = (argConfig, config, value, index) => {
+	if (index !== undefined && !argConfig.multiple) {
+		return {
+			type: "multiple-values-unexpected",
+			path: argConfig.path
+		};
 	}
-	return (...args) => {
-		d();
-		return fn(...args);
-	};
+	const parsed = parseValueForArgumentConfig(argConfig, value);
+	if (parsed === undefined) {
+		return {
+			type: "invalid-value",
+			path: argConfig.path,
+			expected: getExpectedValue(argConfig)
+		};
+	}
+	const problem = setValue(config, argConfig.path, parsed, index);
+	if (problem) return problem;
+	return null;
 };
 
 /**
- * @param {string | function(PathData, AssetInfo=): string} path the raw path
- * @param {PathData} data context data
- * @param {AssetInfo} assetInfo extra info about the asset (will be written to)
- * @returns {string} the interpolated path
+ * @param {ArgumentConfig} argConfig processing instructions
+ * @returns {string | undefined} expected message
  */
-const replacePathVariables = (path, data, assetInfo) => {
-	const chunkGraph = data.chunkGraph;
-
-	/** @type {Map<string, Function>} */
-	const replacements = new Map();
+const getExpectedValue = argConfig => {
+	switch (argConfig.type) {
+		default:
+			return argConfig.type;
+		case "boolean":
+			return "true | false";
+		case "RegExp":
+			return "regular expression (example: /ab?c*/)";
+		case "enum":
+			return argConfig.values.map(v => `${v}`).join(" | ");
+		case "reset":
+			return "true (will reset the previous value to an empty array)";
+	}
+};
 
-	// Filename context
-	//
-	// Placeholders
-	//
-	// for /some/path/file.js?query#fragment:
-	// [file] - /some/path/file.js
-	// [query] - ?query
-	// [fragment] - #fragment
-	// [base] - file.js
-	// [path] - /some/path/
-	// [name] - file
-	// [ext] - .js
-	if (typeof data.filename === "string") {
-		const { path: file, query, fragment } = parseResource(data.filename);
-
-		const ext = extname(file);
-		const base = basename(file);
-		const name = base.slice(0, base.length - ext.length);
-		const path = file.slice(0, file.length - base.length);
-
-		replacements.set("file", replacer(file));
-		replacements.set("query", replacer(query, true));
-		replacements.set("fragment", replacer(fragment, true));
-		replacements.set("path", replacer(path, true));
-		replacements.set("base", replacer(base));
-		replacements.set("name", replacer(name));
-		replacements.set("ext", replacer(ext, true));
-		// Legacy
-		replacements.set(
-			"filebase",
-			deprecated(
-				replacer(base),
-				"[filebase] is now [base]",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
-			)
-		);
-	}
-
-	// Compilation context
-	//
-	// Placeholders
-	//
-	// [fullhash] - data.hash (3a4b5c6e7f)
-	//
-	// Legacy Placeholders
-	//
-	// [hash] - data.hash (3a4b5c6e7f)
-	if (data.hash) {
-		const hashReplacer = hashLength(
-			replacer(data.hash),
-			data.hashWithLength,
-			assetInfo,
-			"fullhash"
-		);
-
-		replacements.set("fullhash", hashReplacer);
-
-		// Legacy
-		replacements.set(
-			"hash",
-			deprecated(
-				hashReplacer,
-				"[hash] is now [fullhash] (also consider using [chunkhash] or [contenthash], see documentation for details)",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_HASH"
-			)
-		);
-	}
-
-	// Chunk Context
-	//
-	// Placeholders
-	//
-	// [id] - chunk.id (0.js)
-	// [name] - chunk.name (app.js)
-	// [chunkhash] - chunk.hash (7823t4t4.js)
-	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
-	if (data.chunk) {
-		const chunk = data.chunk;
-
-		const contentHashType = data.contentHashType;
-
-		const idReplacer = replacer(chunk.id);
-		const nameReplacer = replacer(chunk.name || chunk.id);
-		const chunkhashReplacer = hashLength(
-			replacer(chunk instanceof Chunk ? chunk.renderedHash : chunk.hash),
-			"hashWithLength" in chunk ? chunk.hashWithLength : undefined,
-			assetInfo,
-			"chunkhash"
-		);
-		const contenthashReplacer = hashLength(
-			replacer(
-				data.contentHash ||
-					(contentHashType &&
-						chunk.contentHash &&
-						chunk.contentHash[contentHashType])
-			),
-			data.contentHashWithLength ||
-				("contentHashWithLength" in chunk && chunk.contentHashWithLength
-					? chunk.contentHashWithLength[contentHashType]
-					: undefined),
-			assetInfo,
-			"contenthash"
-		);
-
-		replacements.set("id", idReplacer);
-		replacements.set("name", nameReplacer);
-		replacements.set("chunkhash", chunkhashReplacer);
-		replacements.set("contenthash", contenthashReplacer);
-	}
-
-	// Module Context
-	//
-	// Placeholders
-	//
-	// [id] - module.id (2.png)
-	// [hash] - module.hash (6237543873.png)
-	//
-	// Legacy Placeholders
-	//
-	// [moduleid] - module.id (2.png)
-	// [modulehash] - module.hash (6237543873.png)
-	if (data.module) {
-		const module = data.module;
-
-		const idReplacer = replacer(() =>
-			prepareId(
-				module instanceof Module ? chunkGraph.getModuleId(module) : module.id
-			)
-		);
-		const moduleHashReplacer = hashLength(
-			replacer(() =>
-				module instanceof Module
-					? chunkGraph.getRenderedModuleHash(module, data.runtime)
-					: module.hash
-			),
-			"hashWithLength" in module ? module.hashWithLength : undefined,
-			assetInfo,
-			"modulehash"
-		);
-		const contentHashReplacer = hashLength(
-			replacer(data.contentHash),
-			undefined,
-			assetInfo,
-			"contenthash"
-		);
-
-		replacements.set("id", idReplacer);
-		replacements.set("modulehash", moduleHashReplacer);
-		replacements.set("contenthash", contentHashReplacer);
-		replacements.set(
-			"hash",
-			data.contentHash ? contentHashReplacer : moduleHashReplacer
-		);
-		// Legacy
-		replacements.set(
-			"moduleid",
-			deprecated(
-				idReplacer,
-				"[moduleid] is now [id]",
-				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_MODULE_ID"
-			)
-		);
-	}
-
-	// Other things
-	if (data.url) {
-		replacements.set("url", replacer(data.url));
-	}
-	if (typeof data.runtime === "string") {
-		replacements.set(
-			"runtime",
-			replacer(() => prepareId(data.runtime))
-		);
-	} else {
-		replacements.set("runtime", replacer("_"));
-	}
-
-	if (typeof path === "function") {
-		path = path(data, assetInfo);
+/**
+ * @param {ArgumentConfig} argConfig processing instructions
+ * @param {any} value the value
+ * @returns {any | undefined} parsed value
+ */
+const parseValueForArgumentConfig = (argConfig, value) => {
+	switch (argConfig.type) {
+		case "string":
+			if (typeof value === "string") {
+				return value;
+			}
+			break;
+		case "path":
+			if (typeof value === "string") {
+				return path.resolve(value);
+			}
+			break;
+		case "number":
+			if (typeof value === "number") return value;
+			if (typeof value === "string" && /^[+-]?\d*(\.\d*)[eE]\d+$/) {
+				const n = +value;
+				if (!isNaN(n)) return n;
+			}
+			break;
+		case "boolean":
+			if (typeof value === "boolean") return value;
+			if (value === "true") return true;
+			if (value === "false") return false;
+			break;
+		case "RegExp":
+			if (value instanceof RegExp) return value;
+			if (typeof value === "string") {
+				// cspell:word yugi
+				const match = /^\/(.*)\/([yugi]*)$/.exec(value);
+				if (match && !/[^\\]\//.test(match[1]))
+					return new RegExp(match[1], match[2]);
+			}
+			break;
+		case "enum":
+			if (argConfig.values.includes(value)) return value;
+			for (const item of argConfig.values) {
+				if (`${item}` === value) return item;
+			}
+			break;
+		case "reset":
+			if (value === true) return [];
+			break;
 	}
+};
 
-	path = path.replace(REGEXP, (match, content) => {
-		if (content.length + 2 === match.length) {
-			const contentMatch = /^(\w+)(?::(\w+))?$/.exec(content);
-			if (!contentMatch) return match;
-			const [, kind, arg] = contentMatch;
-			const replacer = replacements.get(kind);
-			if (replacer !== undefined) {
-				return replacer(match, arg, path);
+/**
+ * @param {Record<string, Argument>} args object of arguments
+ * @param {any} config configuration
+ * @param {Record<string, string | number | boolean | RegExp | (string | number | boolean | RegExp)[]>} values object with values
+ * @returns {Problem[] | null} problems or null for success
+ */
+const processArguments = (args, config, values) => {
+	/** @type {Problem[]} */
+	const problems = [];
+	for (const key of Object.keys(values)) {
+		const arg = args[key];
+		if (!arg) {
+			problems.push({
+				type: "unknown-argument",
+				path: "",
+				argument: key
+			});
+			continue;
+		}
+		const processValue = (value, i) => {
+			const currentProblems = [];
+			for (const argConfig of arg.configs) {
+				const problem = processArgumentConfig(argConfig, config, value, i);
+				if (!problem) {
+					return;
+				}
+				currentProblems.push({
+					...problem,
+					argument: key,
+					value: value,
+					index: i
+				});
 			}
-		} else if (match.startsWith("[\\") && match.endsWith("\\]")) {
-			return `[${match.slice(2, -2)}]`;
+			problems.push(...currentProblems);
+		};
+		let value = values[key];
+		if (Array.isArray(value)) {
+			for (let i = 0; i < value.length; i++) {
+				processValue(value[i], i);
+			}
+		} else {
+			processValue(value, undefined);
 		}
-		return match;
-	});
-
-	return path;
-};
-
-const plugin = "TemplatedPathPlugin";
-
-class TemplatedPathPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(plugin, compilation => {
-			compilation.hooks.assetPath.tap(plugin, replacePathVariables);
-		});
 	}
-}
+	if (problems.length === 0) return null;
+	return problems;
+};
 
-module.exports = TemplatedPathPlugin;
+exports.getArguments = getArguments;
+exports.processArguments = processArguments;
 
 
 /***/ }),
 
-/***/ 68099:
+/***/ 43950:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
-
-class UnhandledSchemeError extends WebpackError {
-	/**
-	 * @param {string} scheme scheme
-	 * @param {string} resource resource
-	 */
-	constructor(scheme, resource) {
-		super(
-			`Reading from "${resource}" is not handled by plugins (Unhandled scheme).` +
-				'\nWebpack supports "data:" and "file:" URIs by default.' +
-				`\nYou may need an additional plugin to handle "${scheme}:" URIs.`
-		);
-		this.file = resource;
-		this.name = "UnhandledSchemeError";
-	}
-}
-
-makeSerializable(
-	UnhandledSchemeError,
-	"webpack/lib/UnhandledSchemeError",
-	"UnhandledSchemeError"
-);
-
-module.exports = UnhandledSchemeError;
-
-
-/***/ }),
-
-/***/ 42495:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+const browserslist = __webpack_require__(14907);
+const path = __webpack_require__(71017);
 
-const WebpackError = __webpack_require__(53799);
-const makeSerializable = __webpack_require__(33032);
+/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
+/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
+/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+// [[C:]/path/to/config][:env]
+const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 
-class UnsupportedFeatureWarning extends WebpackError {
-	/**
-	 * @param {string} message description of warning
-	 * @param {DependencyLocation} loc location start and end positions of the module
-	 */
-	constructor(message, loc) {
-		super(message);
+/**
+ * @typedef {Object} BrowserslistHandlerConfig
+ * @property {string=} configPath
+ * @property {string=} env
+ * @property {string=} query
+ */
 
-		this.name = "UnsupportedFeatureWarning";
-		this.loc = loc;
-		this.hideStack = true;
+/**
+ * @param {string} input input string
+ * @param {string} context the context directory
+ * @returns {BrowserslistHandlerConfig} config
+ */
+const parse = (input, context) => {
+	if (!input) {
+		return {};
 	}
-}
-
-makeSerializable(
-	UnsupportedFeatureWarning,
-	"webpack/lib/UnsupportedFeatureWarning"
-);
-
-module.exports = UnsupportedFeatureWarning;
-
 
-/***/ }),
+	if (path.isAbsolute(input)) {
+		const [, configPath, env] = inputRx.exec(input) || [];
+		return { configPath, env };
+	}
 
-/***/ 36803:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	const config = browserslist.findConfig(context);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	if (config && Object.keys(config).includes(input)) {
+		return { env: input };
+	}
 
+	return { query: input };
+};
 
+/**
+ * @param {string} input input string
+ * @param {string} context the context directory
+ * @returns {string[] | undefined} selected browsers
+ */
+const load = (input, context) => {
+	const { configPath, env, query } = parse(input, context);
 
-const ConstDependency = __webpack_require__(76911);
+	// if a query is specified, then use it, else
+	// if a path to a config is specified then load it, else
+	// find a nearest config
+	const config = query
+		? query
+		: configPath
+		? browserslist.loadConfig({
+				config: configPath,
+				env
+		  })
+		: browserslist.loadConfig({ path: context, env });
 
-/** @typedef {import("./Compiler")} Compiler */
+	if (!config) return null;
+	return browserslist(config);
+};
 
-class UseStrictPlugin {
+/**
+ * @param {string[]} browsers supported browsers list
+ * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
+ */
+const resolve = browsers => {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * Checks all against a version number
+	 * @param {Record<string, number | [number, number]>} versions first supported version
+	 * @returns {boolean} true if supports
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"UseStrictPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const handler = parser => {
-					parser.hooks.program.tap("UseStrictPlugin", ast => {
-						const firstNode = ast.body[0];
-						if (
-							firstNode &&
-							firstNode.type === "ExpressionStatement" &&
-							firstNode.expression.type === "Literal" &&
-							firstNode.expression.value === "use strict"
-						) {
-							// Remove "use strict" expression. It will be added later by the renderer again.
-							// This is necessary in order to not break the strict mode when webpack prepends code.
-							// @see https://github.com/webpack/webpack/issues/1970
-							const dep = new ConstDependency("", firstNode.range);
-							dep.loc = firstNode.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							parser.state.module.buildInfo.strict = true;
-						}
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("UseStrictPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("UseStrictPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("UseStrictPlugin", handler);
+	const rawChecker = versions => {
+		return browsers.every(v => {
+			const [name, parsedVersion] = v.split(" ");
+			if (!name) return false;
+			const requiredVersion = versions[name];
+			if (!requiredVersion) return false;
+			const [parsedMajor, parserMinor] =
+				// safari TP supports all features for normal safari
+				parsedVersion === "TP"
+					? [Infinity, Infinity]
+					: parsedVersion.split(".");
+			if (typeof requiredVersion === "number") {
+				return +parsedMajor >= requiredVersion;
 			}
-		);
-	}
-}
-
-module.exports = UseStrictPlugin;
+			return requiredVersion[0] === +parsedMajor
+				? +parserMinor >= requiredVersion[1]
+				: +parsedMajor > requiredVersion[0];
+		});
+	};
+	const anyNode = browsers.some(b => /^node /.test(b));
+	const anyBrowser = browsers.some(b => /^(?!node)/.test(b));
+	const browserProperty = !anyBrowser ? false : anyNode ? null : true;
+	const nodeProperty = !anyNode ? false : anyBrowser ? null : true;
+	// Internet Explorer Mobile, Blackberry browser and Opera Mini are very old browsers, they do not support new features
+	const es6DynamicImport = rawChecker({
+		chrome: 63,
+		and_chr: 63,
+		edge: 79,
+		firefox: 67,
+		and_ff: 67,
+		// ie: Not supported
+		opera: 50,
+		op_mob: 46,
+		safari: [11, 1],
+		ios_saf: [11, 3],
+		samsung: [8, 2],
+		android: 63,
+		and_qq: [10, 4],
+		// baidu: Not supported
+		// and_uc: Not supported
+		// kaios: Not supported
+		// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
+		node: [13, 14]
+	});
 
+	return {
+		const: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 12,
+			// Prior to Firefox 13, <code>const</code> is implemented, but re-assignment is not failing.
+			// Prior to Firefox 46, a <code>TypeError</code> was thrown on redeclaration instead of a <code>SyntaxError</code>.
+			firefox: 36,
+			and_ff: 36,
+			// Not supported in for-in and for-of loops
+			// ie: Not supported
+			opera: 36,
+			op_mob: 36,
+			safari: [10, 0],
+			ios_saf: [10, 0],
+			// Before 5.0 supported correctly in strict mode, otherwise supported without block scope
+			samsung: [5, 0],
+			android: 37,
+			and_qq: [10, 4],
+			// Supported correctly in strict mode, otherwise supported without block scope
+			// baidu: Not supported
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		arrowFunction: rawChecker({
+			chrome: 45,
+			and_chr: 45,
+			edge: 12,
+			// The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of <code>'use strict';</code> is now required.
+			// Prior to Firefox 39, a line terminator (<code>\\n</code>) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like <code>() \\n => {}</code> will now throw a <code>SyntaxError</code> in this and later versions.
+			firefox: 39,
+			and_ff: 39,
+			// ie: Not supported,
+			opera: 32,
+			op_mob: 32,
+			safari: 10,
+			ios_saf: 10,
+			samsung: [5, 0],
+			android: 45,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: [6, 0]
+		}),
+		forOf: rawChecker({
+			chrome: 38,
+			and_chr: 38,
+			edge: 12,
+			// Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration").
+			firefox: 51,
+			and_ff: 51,
+			// ie: Not supported,
+			opera: 25,
+			op_mob: 25,
+			safari: 7,
+			ios_saf: 7,
+			samsung: [3, 0],
+			android: 38,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [0, 12]
+		}),
+		destructuring: rawChecker({
+			chrome: 49,
+			and_chr: 49,
+			edge: 14,
+			firefox: 41,
+			and_ff: 41,
+			// ie: Not supported,
+			opera: 36,
+			op_mob: 36,
+			safari: 8,
+			ios_saf: 8,
+			samsung: [5, 0],
+			android: 49,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [6, 0]
+		}),
+		bigIntLiteral: rawChecker({
+			chrome: 67,
+			and_chr: 67,
+			edge: 79,
+			firefox: 68,
+			and_ff: 68,
+			// ie: Not supported,
+			opera: 54,
+			op_mob: 48,
+			safari: 14,
+			ios_saf: 14,
+			samsung: [9, 2],
+			android: 67,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: [10, 4]
+		}),
+		// Support syntax `import` and `export` and no limitations and bugs on Node.js
+		// Not include `export * as namespace`
+		module: rawChecker({
+			chrome: 61,
+			and_chr: 61,
+			edge: 16,
+			firefox: 60,
+			and_ff: 60,
+			// ie: Not supported,
+			opera: 48,
+			op_mob: 45,
+			safari: [10, 1],
+			ios_saf: [10, 3],
+			samsung: [8, 0],
+			android: 61,
+			and_qq: [10, 4],
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
+			node: [13, 14]
+		}),
+		dynamicImport: es6DynamicImport,
+		dynamicImportInWorker: es6DynamicImport && !anyNode,
+		// browserslist does not have info about globalThis
+		// so this is based on mdn-browser-compat-data
+		globalThis: rawChecker({
+			chrome: 71,
+			and_chr: 71,
+			edge: 79,
+			firefox: 65,
+			and_ff: 65,
+			// ie: Not supported,
+			opera: 58,
+			op_mob: 50,
+			safari: [12, 1],
+			ios_saf: [12, 2],
+			samsung: [10, 1],
+			android: 71,
+			// and_qq: Unknown support
+			// baidu: Unknown support
+			// and_uc: Unknown support
+			// kaios: Unknown support
+			node: [12, 0]
+		}),
+		optionalChaining: rawChecker({
+			chrome: 80,
+			and_chr: 80,
+			edge: 80,
+			firefox: 74,
+			and_ff: 79,
+			// ie: Not supported,
+			opera: 67,
+			op_mob: 64,
+			safari: [13, 1],
+			ios_saf: [13, 4],
+			samsung: 13,
+			android: 80,
+			// and_qq: Not supported
+			// baidu: Not supported
+			// and_uc: Not supported
+			// kaios: Not supported
+			node: 14
+		}),
+		templateLiteral: rawChecker({
+			chrome: 41,
+			and_chr: 41,
+			edge: 13,
+			firefox: 34,
+			and_ff: 34,
+			// ie: Not supported,
+			opera: 29,
+			op_mob: 64,
+			safari: [9, 1],
+			ios_saf: 9,
+			samsung: 4,
+			android: 41,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: 4
+		}),
+		browser: browserProperty,
+		electron: false,
+		node: nodeProperty,
+		nwjs: false,
+		web: browserProperty,
+		webworker: false,
 
-/***/ }),
-
-/***/ 56504:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const CaseSensitiveModulesWarning = __webpack_require__(77975);
-
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
-
-class WarnCaseSensitiveModulesPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WarnCaseSensitiveModulesPlugin",
-			compilation => {
-				compilation.hooks.seal.tap("WarnCaseSensitiveModulesPlugin", () => {
-					/** @type {Map<string, Map<string, Module>>} */
-					const moduleWithoutCase = new Map();
-					for (const module of compilation.modules) {
-						const identifier = module.identifier();
-						const lowerIdentifier = identifier.toLowerCase();
-						let map = moduleWithoutCase.get(lowerIdentifier);
-						if (map === undefined) {
-							map = new Map();
-							moduleWithoutCase.set(lowerIdentifier, map);
-						}
-						map.set(identifier, module);
-					}
-					for (const pair of moduleWithoutCase) {
-						const map = pair[1];
-						if (map.size > 1) {
-							compilation.warnings.push(
-								new CaseSensitiveModulesWarning(
-									map.values(),
-									compilation.moduleGraph
-								)
-							);
-						}
-					}
-				});
-			}
-		);
-	}
-}
+		document: browserProperty,
+		fetchWasm: browserProperty,
+		global: nodeProperty,
+		importScripts: false,
+		importScriptsInWorker: true,
+		nodeBuiltins: nodeProperty,
+		require: nodeProperty
+	};
+};
 
-module.exports = WarnCaseSensitiveModulesPlugin;
+module.exports = {
+	resolve,
+	load
+};
 
 
 /***/ }),
 
-/***/ 76537:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 92988:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
+const fs = __webpack_require__(57147);
+const path = __webpack_require__(71017);
+const Template = __webpack_require__(1626);
+const { cleverMerge } = __webpack_require__(60839);
+const {
+	getTargetsProperties,
+	getTargetProperties,
+	getDefaultTarget
+} = __webpack_require__(52801);
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
+/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
+/** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
+/** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
+/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Library} Library */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
+/** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
+/** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
+/** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
+/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
+/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
+/** @typedef {import("../../declarations/WebpackOptions").Target} Target */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("./target").TargetProperties} TargetProperties */
 
-class WarnDeprecatedOptionPlugin {
-	/**
-	 * Create an instance of the plugin
-	 * @param {string} option the target option
-	 * @param {string | number} value the deprecated option value
-	 * @param {string} suggestion the suggestion replacement
-	 */
-	constructor(option, value, suggestion) {
-		this.option = option;
-		this.value = value;
-		this.suggestion = suggestion;
-	}
+const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"WarnDeprecatedOptionPlugin",
-			compilation => {
-				compilation.warnings.push(
-					new DeprecatedOptionWarning(this.option, this.value, this.suggestion)
-				);
-			}
-		);
+/**
+ * Sets a constant default value when undefined
+ * @template T
+ * @template {keyof T} P
+ * @param {T} obj an object
+ * @param {P} prop a property of this object
+ * @param {T[P]} value a default value of the property
+ * @returns {void}
+ */
+const D = (obj, prop, value) => {
+	if (obj[prop] === undefined) {
+		obj[prop] = value;
 	}
-}
-
-class DeprecatedOptionWarning extends WebpackError {
-	constructor(option, value, suggestion) {
-		super();
+};
 
-		this.name = "DeprecatedOptionWarning";
-		this.message =
-			"configuration\n" +
-			`The value '${value}' for option '${option}' is deprecated. ` +
-			`Use '${suggestion}' instead.`;
+/**
+ * Sets a dynamic default value when undefined, by calling the factory function
+ * @template T
+ * @template {keyof T} P
+ * @param {T} obj an object
+ * @param {P} prop a property of this object
+ * @param {function(): T[P]} factory a default value factory for the property
+ * @returns {void}
+ */
+const F = (obj, prop, factory) => {
+	if (obj[prop] === undefined) {
+		obj[prop] = factory();
 	}
-}
-
-module.exports = WarnDeprecatedOptionPlugin;
-
-
-/***/ }),
+};
 
-/***/ 25295:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * Sets a dynamic default value when undefined, by calling the factory function.
+ * factory must return an array or undefined
+ * When the current value is already an array an contains "..." it's replaced with
+ * the result of the factory function
+ * @template T
+ * @template {keyof T} P
+ * @param {T} obj an object
+ * @param {P} prop a property of this object
+ * @param {function(): T[P]} factory a default value factory for the property
+ * @returns {void}
+ */
+const A = (obj, prop, factory) => {
+	const value = obj[prop];
+	if (value === undefined) {
+		obj[prop] = factory();
+	} else if (Array.isArray(value)) {
+		/** @type {any[]} */
+		let newArray = undefined;
+		for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			if (item === "...") {
+				if (newArray === undefined) {
+					newArray = value.slice(0, i);
+					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
+				}
+				const items = /** @type {any[]} */ (/** @type {unknown} */ (factory()));
+				if (items !== undefined) {
+					for (const item of items) {
+						newArray.push(item);
+					}
+				}
+			} else if (newArray !== undefined) {
+				newArray.push(item);
+			}
+		}
+	}
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {WebpackOptions} options options to be modified
+ * @returns {void}
+ */
+const applyWebpackOptionsBaseDefaults = options => {
+	F(options, "context", () => process.cwd());
+	applyInfrastructureLoggingDefaults(options.infrastructureLogging);
+};
 
+/**
+ * @param {WebpackOptions} options options to be modified
+ * @returns {void}
+ */
+const applyWebpackOptionsDefaults = options => {
+	F(options, "context", () => process.cwd());
+	F(options, "target", () => {
+		return getDefaultTarget(options.context);
+	});
 
+	const { mode, name, target } = options;
 
-const NoModeWarning = __webpack_require__(80832);
+	let targetProperties =
+		target === false
+			? /** @type {false} */ (false)
+			: typeof target === "string"
+			? getTargetProperties(target, options.context)
+			: getTargetsProperties(target, options.context);
 
-/** @typedef {import("./Compiler")} Compiler */
+	const development = mode === "development";
+	const production = mode === "production" || !mode;
 
-class WarnNoModeSetPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("WarnNoModeSetPlugin", compilation => {
-			compilation.warnings.push(new NoModeWarning());
-		});
+	if (typeof options.entry !== "function") {
+		for (const key of Object.keys(options.entry)) {
+			F(
+				options.entry[key],
+				"import",
+				() => /** @type {[string]} */ (["./src"])
+			);
+		}
 	}
-}
-
-module.exports = WarnNoModeSetPlugin;
 
+	F(options, "devtool", () => (development ? "eval" : false));
+	D(options, "watch", false);
+	D(options, "profile", false);
+	D(options, "parallelism", 100);
+	D(options, "recordsInputPath", false);
+	D(options, "recordsOutputPath", false);
 
-/***/ }),
+	applyExperimentsDefaults(options.experiments, {
+		production,
+		development,
+		targetProperties
+	});
 
-/***/ 65193:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	const futureDefaults = options.experiments.futureDefaults;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	F(options, "cache", () =>
+		development ? { type: /** @type {"memory"} */ ("memory") } : false
+	);
+	applyCacheDefaults(options.cache, {
+		name: name || "default",
+		mode: mode || "production",
+		development,
+		cacheUnaffected: options.experiments.cacheUnaffected
+	});
+	const cache = !!options.cache;
 
+	applySnapshotDefaults(options.snapshot, {
+		production,
+		futureDefaults
+	});
 
+	applyModuleDefaults(options.module, {
+		cache,
+		syncWebAssembly: options.experiments.syncWebAssembly,
+		asyncWebAssembly: options.experiments.asyncWebAssembly,
+		css: options.experiments.css,
+		futureDefaults
+	});
 
-const { groupBy } = __webpack_require__(84953);
-const createSchemaValidation = __webpack_require__(32540);
+	applyOutputDefaults(options.output, {
+		context: options.context,
+		targetProperties,
+		isAffectedByBrowserslist:
+			target === undefined ||
+			(typeof target === "string" && target.startsWith("browserslist")) ||
+			(Array.isArray(target) &&
+				target.some(target => target.startsWith("browserslist"))),
+		outputModule: options.experiments.outputModule,
+		development,
+		entry: options.entry,
+		module: options.module,
+		futureDefaults
+	});
 
-/** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
+	applyExternalsPresetsDefaults(options.externalsPresets, {
+		targetProperties,
+		buildHttp: !!options.experiments.buildHttp
+	});
 
-const validate = createSchemaValidation(
-	__webpack_require__(16711),
-	() => __webpack_require__(44246),
-	{
-		name: "Watch Ignore Plugin",
-		baseDataPath: "options"
-	}
-);
+	applyLoaderDefaults(options.loader, { targetProperties });
 
-const IGNORE_TIME_ENTRY = "ignore";
+	F(options, "externalsType", () => {
+		const validExternalTypes = (__webpack_require__(73342).definitions.ExternalsType["enum"]);
+		return options.output.library &&
+			validExternalTypes.includes(options.output.library.type)
+			? /** @type {ExternalsType} */ (options.output.library.type)
+			: options.output.module
+			? "module"
+			: "var";
+	});
 
-class IgnoringWatchFileSystem {
-	/**
-	 * @param {WatchFileSystem} wfs original file system
-	 * @param {(string|RegExp)[]} paths ignored paths
-	 */
-	constructor(wfs, paths) {
-		this.wfs = wfs;
-		this.paths = paths;
-	}
+	applyNodeDefaults(options.node, {
+		futureDefaults: options.experiments.futureDefaults,
+		targetProperties
+	});
 
-	watch(files, dirs, missing, startTime, options, callback, callbackUndelayed) {
-		files = Array.from(files);
-		dirs = Array.from(dirs);
-		const ignored = path =>
-			this.paths.some(p =>
-				p instanceof RegExp ? p.test(path) : path.indexOf(p) === 0
-			);
+	F(options, "performance", () =>
+		production &&
+		targetProperties &&
+		(targetProperties.browser || targetProperties.browser === null)
+			? {}
+			: false
+	);
+	applyPerformanceDefaults(options.performance, {
+		production
+	});
 
-		const [ignoredFiles, notIgnoredFiles] = groupBy(files, ignored);
-		const [ignoredDirs, notIgnoredDirs] = groupBy(dirs, ignored);
+	applyOptimizationDefaults(options.optimization, {
+		development,
+		production,
+		css: options.experiments.css,
+		records: !!(options.recordsInputPath || options.recordsOutputPath)
+	});
 
-		const watcher = this.wfs.watch(
-			notIgnoredFiles,
-			notIgnoredDirs,
-			missing,
-			startTime,
-			options,
-			(err, fileTimestamps, dirTimestamps, changedFiles, removedFiles) => {
-				if (err) return callback(err);
-				for (const path of ignoredFiles) {
-					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
+	options.resolve = cleverMerge(
+		getResolveDefaults({
+			cache,
+			context: options.context,
+			targetProperties,
+			mode: options.mode
+		}),
+		options.resolve
+	);
 
-				for (const path of ignoredDirs) {
-					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
+	options.resolveLoader = cleverMerge(
+		getResolveLoaderDefaults({ cache }),
+		options.resolveLoader
+	);
+};
 
-				callback(
-					err,
-					fileTimestamps,
-					dirTimestamps,
-					changedFiles,
-					removedFiles
-				);
-			},
-			callbackUndelayed
-		);
+/**
+ * @param {ExperimentsNormalized} experiments options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @param {boolean} options.development is development mode
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @returns {void}
+ */
+const applyExperimentsDefaults = (
+	experiments,
+	{ production, development, targetProperties }
+) => {
+	D(experiments, "futureDefaults", false);
+	D(experiments, "backCompat", !experiments.futureDefaults);
+	D(experiments, "topLevelAwait", experiments.futureDefaults);
+	D(experiments, "syncWebAssembly", false);
+	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
+	D(experiments, "outputModule", false);
+	D(experiments, "layers", false);
+	D(experiments, "lazyCompilation", undefined);
+	D(experiments, "buildHttp", undefined);
+	D(experiments, "cacheUnaffected", experiments.futureDefaults);
+	F(experiments, "css", () => (experiments.futureDefaults ? {} : undefined));
 
-		return {
-			close: () => watcher.close(),
-			pause: () => watcher.pause(),
-			getContextTimeInfoEntries: () => {
-				const dirTimestamps = watcher.getContextTimeInfoEntries();
-				for (const path of ignoredDirs) {
-					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
-				return dirTimestamps;
-			},
-			getFileTimeInfoEntries: () => {
-				const fileTimestamps = watcher.getFileTimeInfoEntries();
-				for (const path of ignoredFiles) {
-					fileTimestamps.set(path, IGNORE_TIME_ENTRY);
-				}
-				return fileTimestamps;
-			},
-			getInfo:
-				watcher.getInfo &&
-				(() => {
-					const info = watcher.getInfo();
-					const { fileTimeInfoEntries, contextTimeInfoEntries } = info;
-					for (const path of ignoredFiles) {
-						fileTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
-					}
-					for (const path of ignoredDirs) {
-						contextTimeInfoEntries.set(path, IGNORE_TIME_ENTRY);
-					}
-					return info;
-				})
-		};
+	if (typeof experiments.buildHttp === "object") {
+		D(experiments.buildHttp, "frozen", production);
+		D(experiments.buildHttp, "upgrade", false);
 	}
-}
 
-class WatchIgnorePlugin {
-	/**
-	 * @param {WatchIgnorePluginOptions} options options
-	 */
-	constructor(options) {
-		validate(options);
-		this.paths = options.paths;
+	if (typeof experiments.css === "object") {
+		D(
+			experiments.css,
+			"exportsOnly",
+			!targetProperties || !targetProperties.document
+		);
 	}
+};
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.afterEnvironment.tap("WatchIgnorePlugin", () => {
-			compiler.watchFileSystem = new IgnoringWatchFileSystem(
-				compiler.watchFileSystem,
-				this.paths
+/**
+ * @param {CacheOptions} cache options
+ * @param {Object} options options
+ * @param {string} options.name name
+ * @param {string} options.mode mode
+ * @param {boolean} options.development is development mode
+ * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
+ * @returns {void}
+ */
+const applyCacheDefaults = (
+	cache,
+	{ name, mode, development, cacheUnaffected }
+) => {
+	if (cache === false) return;
+	switch (cache.type) {
+		case "filesystem":
+			F(cache, "name", () => name + "-" + mode);
+			D(cache, "version", "");
+			F(cache, "cacheDirectory", () => {
+				const cwd = process.cwd();
+				let dir = cwd;
+				for (;;) {
+					try {
+						if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
+						// eslint-disable-next-line no-empty
+					} catch (e) {}
+					const parent = path.dirname(dir);
+					if (dir === parent) {
+						dir = undefined;
+						break;
+					}
+					dir = parent;
+				}
+				if (!dir) {
+					return path.resolve(cwd, ".cache/webpack");
+				} else if (process.versions.pnp === "1") {
+					return path.resolve(dir, ".pnp/.cache/webpack");
+				} else if (process.versions.pnp === "3") {
+					return path.resolve(dir, ".yarn/.cache/webpack");
+				} else {
+					return path.resolve(dir, "node_modules/.cache/webpack");
+				}
+			});
+			F(cache, "cacheLocation", () =>
+				path.resolve(cache.cacheDirectory, cache.name)
 			);
-		});
+			D(cache, "hashAlgorithm", "md4");
+			D(cache, "store", "pack");
+			D(cache, "compression", false);
+			D(cache, "profile", false);
+			D(cache, "idleTimeout", 60000);
+			D(cache, "idleTimeoutForInitialStore", 5000);
+			D(cache, "idleTimeoutAfterLargeChanges", 1000);
+			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
+			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
+			D(cache, "allowCollectingMemory", development);
+			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
+			D(cache.buildDependencies, "defaultWebpack", [
+				path.resolve(__dirname, "..") + path.sep
+			]);
+			break;
+		case "memory":
+			D(cache, "maxGenerations", Infinity);
+			D(cache, "cacheUnaffected", development && cacheUnaffected);
+			break;
 	}
-}
-
-module.exports = WatchIgnorePlugin;
-
-
-/***/ }),
-
-/***/ 84275:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Stats = __webpack_require__(31743);
+};
 
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/**
+ * @param {SnapshotOptions} snapshot options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
+	if (futureDefaults) {
+		F(snapshot, "managedPaths", () =>
+			process.versions.pnp === "3"
+				? [
+						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
+				  ]
+				: [/^(.+?[\\/]node_modules[\\/])/]
+		);
+		F(snapshot, "immutablePaths", () =>
+			process.versions.pnp === "3"
+				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
+				: []
+		);
+	} else {
+		A(snapshot, "managedPaths", () => {
+			if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						/*require.resolve*/(36871)
+					);
+				if (match) {
+					return [path.resolve(match[1], "unplugged")];
+				}
+			} else {
+				const match = /^(.+?[\\/]node_modules[\\/])/.exec(
+					// eslint-disable-next-line node/no-extraneous-require
+					/*require.resolve*/(36871)
+				);
+				if (match) {
+					return [match[1]];
+				}
+			}
+			return [];
+		});
+		A(snapshot, "immutablePaths", () => {
+			if (process.versions.pnp === "1") {
+				const match =
+					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
+						/*require.resolve*/(36871)
+					);
+				if (match) {
+					return [match[1]];
+				}
+			} else if (process.versions.pnp === "3") {
+				const match =
+					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
+						/*require.resolve*/(36871)
+					);
+				if (match) {
+					return [match[1]];
+				}
+			}
+			return [];
+		});
+	}
+	F(snapshot, "resolveBuildDependencies", () => ({
+		timestamp: true,
+		hash: true
+	}));
+	F(snapshot, "buildDependencies", () => ({ timestamp: true, hash: true }));
+	F(snapshot, "module", () =>
+		production ? { timestamp: true, hash: true } : { timestamp: true }
+	);
+	F(snapshot, "resolve", () =>
+		production ? { timestamp: true, hash: true } : { timestamp: true }
+	);
+};
 
 /**
- * @template T
- * @callback Callback
- * @param {(Error | null)=} err
- * @param {T=} result
+ * @param {JavascriptParserOptions} parserOptions parser options
+ * @param {Object} options options
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
  */
+const applyJavascriptParserOptionsDefaults = (
+	parserOptions,
+	{ futureDefaults }
+) => {
+	D(parserOptions, "unknownContextRequest", ".");
+	D(parserOptions, "unknownContextRegExp", false);
+	D(parserOptions, "unknownContextRecursive", true);
+	D(parserOptions, "unknownContextCritical", true);
+	D(parserOptions, "exprContextRequest", ".");
+	D(parserOptions, "exprContextRegExp", false);
+	D(parserOptions, "exprContextRecursive", true);
+	D(parserOptions, "exprContextCritical", true);
+	D(parserOptions, "wrappedContextRegExp", /.*/);
+	D(parserOptions, "wrappedContextRecursive", true);
+	D(parserOptions, "wrappedContextCritical", false);
+	D(parserOptions, "strictThisContextOnImports", false);
+	D(parserOptions, "importMeta", true);
+	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
+};
 
-class Watching {
-	/**
-	 * @param {Compiler} compiler the compiler
-	 * @param {WatchOptions} watchOptions options
-	 * @param {Callback<Stats>} handler completion handler
-	 */
-	constructor(compiler, watchOptions, handler) {
-		this.startTime = null;
-		this.invalid = false;
-		this.handler = handler;
-		/** @type {Callback<void>[]} */
-		this.callbacks = [];
-		/** @type {Callback<void>[] | undefined} */
-		this._closeCallbacks = undefined;
-		this.closed = false;
-		this.suspended = false;
-		this.blocked = false;
-		this._isBlocked = () => false;
-		this._onChange = () => {};
-		this._onInvalid = () => {};
-		if (typeof watchOptions === "number") {
-			this.watchOptions = {
-				aggregateTimeout: watchOptions
-			};
-		} else if (watchOptions && typeof watchOptions === "object") {
-			this.watchOptions = { ...watchOptions };
-		} else {
-			this.watchOptions = {};
-		}
-		if (typeof this.watchOptions.aggregateTimeout !== "number") {
-			this.watchOptions.aggregateTimeout = 20;
-		}
-		this.compiler = compiler;
-		this.running = false;
-		this._initial = true;
-		this._invalidReported = true;
-		this._needRecords = true;
-		this.watcher = undefined;
-		this.pausedWatcher = undefined;
-		/** @type {Set<string>} */
-		this._collectedChangedFiles = undefined;
-		/** @type {Set<string>} */
-		this._collectedRemovedFiles = undefined;
-		this._done = this._done.bind(this);
-		process.nextTick(() => {
-			if (this._initial) this._invalidate();
+/**
+ * @param {ModuleOptions} module options
+ * @param {Object} options options
+ * @param {boolean} options.cache is caching enabled
+ * @param {boolean} options.syncWebAssembly is syncWebAssembly enabled
+ * @param {boolean} options.asyncWebAssembly is asyncWebAssembly enabled
+ * @param {CssExperimentOptions} options.css is css enabled
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applyModuleDefaults = (
+	module,
+	{ cache, syncWebAssembly, asyncWebAssembly, css, futureDefaults }
+) => {
+	if (cache) {
+		D(module, "unsafeCache", module => {
+			const name = module.nameForCondition();
+			return name && NODE_MODULES_REGEXP.test(name);
 		});
+	} else {
+		D(module, "unsafeCache", false);
 	}
 
-	/**
-	 * @param {ReadonlySet<string>} changedFiles changed files
-	 * @param {ReadonlySet<string>} removedFiles removed files
-	 */
-	_mergeWithCollected(changedFiles, removedFiles) {
-		if (!changedFiles) return;
-		if (!this._collectedChangedFiles) {
-			this._collectedChangedFiles = new Set(changedFiles);
-			this._collectedRemovedFiles = new Set(removedFiles);
-		} else {
-			for (const file of changedFiles) {
-				this._collectedChangedFiles.add(file);
-				this._collectedRemovedFiles.delete(file);
-			}
-			for (const file of removedFiles) {
-				this._collectedChangedFiles.delete(file);
-				this._collectedRemovedFiles.add(file);
-			}
-		}
+	F(module.parser, "asset", () => ({}));
+	F(module.parser.asset, "dataUrlCondition", () => ({}));
+	if (typeof module.parser.asset.dataUrlCondition === "object") {
+		D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
 	}
 
-	/**
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} fileTimeInfoEntries info for files
-	 * @param {ReadonlyMap<string, FileSystemInfoEntry | "ignore">=} contextTimeInfoEntries info for directories
-	 * @param {ReadonlySet<string>=} changedFiles changed files
-	 * @param {ReadonlySet<string>=} removedFiles removed files
-	 * @returns {void}
-	 */
-	_go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
-		this._initial = false;
-		if (this.startTime === null) this.startTime = Date.now();
-		this.running = true;
-		if (this.watcher) {
-			this.pausedWatcher = this.watcher;
-			this.lastWatcherStartTime = Date.now();
-			this.watcher.pause();
-			this.watcher = null;
-		} else if (!this.lastWatcherStartTime) {
-			this.lastWatcherStartTime = Date.now();
-		}
-		this.compiler.fsStartTime = Date.now();
-		if (
-			changedFiles &&
-			removedFiles &&
-			fileTimeInfoEntries &&
-			contextTimeInfoEntries
-		) {
-			this._mergeWithCollected(changedFiles, removedFiles);
-			this.compiler.fileTimestamps = fileTimeInfoEntries;
-			this.compiler.contextTimestamps = contextTimeInfoEntries;
-		} else if (this.pausedWatcher) {
-			if (this.pausedWatcher.getInfo) {
-				const {
-					changes,
-					removals,
-					fileTimeInfoEntries,
-					contextTimeInfoEntries
-				} = this.pausedWatcher.getInfo();
-				this._mergeWithCollected(changes, removals);
-				this.compiler.fileTimestamps = fileTimeInfoEntries;
-				this.compiler.contextTimestamps = contextTimeInfoEntries;
-			} else {
-				this._mergeWithCollected(
-					this.pausedWatcher.getAggregatedChanges &&
-						this.pausedWatcher.getAggregatedChanges(),
-					this.pausedWatcher.getAggregatedRemovals &&
-						this.pausedWatcher.getAggregatedRemovals()
-				);
-				this.compiler.fileTimestamps =
-					this.pausedWatcher.getFileTimeInfoEntries();
-				this.compiler.contextTimestamps =
-					this.pausedWatcher.getContextTimeInfoEntries();
-			}
-		}
-		this.compiler.modifiedFiles = this._collectedChangedFiles;
-		this._collectedChangedFiles = undefined;
-		this.compiler.removedFiles = this._collectedRemovedFiles;
-		this._collectedRemovedFiles = undefined;
+	F(module.parser, "javascript", () => ({}));
+	applyJavascriptParserOptionsDefaults(module.parser.javascript, {
+		futureDefaults
+	});
 
-		const run = () => {
-			if (this.compiler.idle) {
-				return this.compiler.cache.endIdle(err => {
-					if (err) return this._done(err);
-					this.compiler.idle = false;
-					run();
-				});
+	A(module, "defaultRules", () => {
+		const esm = {
+			type: "javascript/esm",
+			resolve: {
+				byDependency: {
+					esm: {
+						fullySpecified: true
+					}
+				}
 			}
-			if (this._needRecords) {
-				return this.compiler.readRecords(err => {
-					if (err) return this._done(err);
-
-					this._needRecords = false;
-					run();
-				});
+		};
+		const commonjs = {
+			type: "javascript/dynamic"
+		};
+		/** @type {RuleSetRules} */
+		const rules = [
+			{
+				mimetype: "application/node",
+				type: "javascript/auto"
+			},
+			{
+				test: /\.json$/i,
+				type: "json"
+			},
+			{
+				mimetype: "application/json",
+				type: "json"
+			},
+			{
+				test: /\.mjs$/i,
+				...esm
+			},
+			{
+				test: /\.js$/i,
+				descriptionData: {
+					type: "module"
+				},
+				...esm
+			},
+			{
+				test: /\.cjs$/i,
+				...commonjs
+			},
+			{
+				test: /\.js$/i,
+				descriptionData: {
+					type: "commonjs"
+				},
+				...commonjs
+			},
+			{
+				mimetype: {
+					or: ["text/javascript", "application/javascript"]
+				},
+				...esm
 			}
-			this.invalid = false;
-			this._invalidReported = false;
-			this.compiler.hooks.watchRun.callAsync(this.compiler, err => {
-				if (err) return this._done(err);
-				const onCompiled = (err, compilation) => {
-					if (err) return this._done(err, compilation);
-					if (this.invalid) return this._done(null, compilation);
-
-					if (this.compiler.hooks.shouldEmit.call(compilation) === false) {
-						return this._done(null, compilation);
+		];
+		if (asyncWebAssembly) {
+			const wasm = {
+				type: "webassembly/async",
+				rules: [
+					{
+						descriptionData: {
+							type: "module"
+						},
+						resolve: {
+							fullySpecified: true
+						}
 					}
-
-					process.nextTick(() => {
-						const logger = compilation.getLogger("webpack.Compiler");
-						logger.time("emitAssets");
-						this.compiler.emitAssets(compilation, err => {
-							logger.timeEnd("emitAssets");
-							if (err) return this._done(err, compilation);
-							if (this.invalid) return this._done(null, compilation);
-
-							logger.time("emitRecords");
-							this.compiler.emitRecords(err => {
-								logger.timeEnd("emitRecords");
-								if (err) return this._done(err, compilation);
-
-								if (compilation.hooks.needAdditionalPass.call()) {
-									compilation.needAdditionalPass = true;
-
-									compilation.startTime = this.startTime;
-									compilation.endTime = Date.now();
-									logger.time("done hook");
-									const stats = new Stats(compilation);
-									this.compiler.hooks.done.callAsync(stats, err => {
-										logger.timeEnd("done hook");
-										if (err) return this._done(err, compilation);
-
-										this.compiler.hooks.additionalPass.callAsync(err => {
-											if (err) return this._done(err, compilation);
-											this.compiler.compile(onCompiled);
-										});
-									});
-									return;
-								}
-								return this._done(null, compilation);
-							});
-						});
-					});
-				};
-				this.compiler.compile(onCompiled);
+				]
+			};
+			rules.push({
+				test: /\.wasm$/i,
+				...wasm
 			});
-		};
-
-		run();
-	}
-
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {Stats} the compilation stats
-	 */
-	_getStats(compilation) {
-		const stats = new Stats(compilation);
-		return stats;
-	}
-
-	/**
-	 * @param {Error=} err an optional error
-	 * @param {Compilation=} compilation the compilation
-	 * @returns {void}
-	 */
-	_done(err, compilation) {
-		this.running = false;
-
-		const logger = compilation && compilation.getLogger("webpack.Watching");
-
-		let stats = null;
-
-		const handleError = (err, cbs) => {
-			this.compiler.hooks.failed.call(err);
-			this.compiler.cache.beginIdle();
-			this.compiler.idle = true;
-			this.handler(err, stats);
-			if (!cbs) {
-				cbs = this.callbacks;
-				this.callbacks = [];
-			}
-			for (const cb of cbs) cb(err);
-		};
-
-		if (
-			this.invalid &&
-			!this.suspended &&
-			!this.blocked &&
-			!(this._isBlocked() && (this.blocked = true))
-		) {
-			if (compilation) {
-				logger.time("storeBuildDependencies");
-				this.compiler.cache.storeBuildDependencies(
-					compilation.buildDependencies,
-					err => {
-						logger.timeEnd("storeBuildDependencies");
-						if (err) return handleError(err);
-						this._go();
+			rules.push({
+				mimetype: "application/wasm",
+				...wasm
+			});
+		} else if (syncWebAssembly) {
+			const wasm = {
+				type: "webassembly/sync",
+				rules: [
+					{
+						descriptionData: {
+							type: "module"
+						},
+						resolve: {
+							fullySpecified: true
+						}
 					}
-				);
-			} else {
-				this._go();
-			}
-			return;
-		}
-
-		if (compilation) {
-			compilation.startTime = this.startTime;
-			compilation.endTime = Date.now();
-			stats = new Stats(compilation);
+				]
+			};
+			rules.push({
+				test: /\.wasm$/i,
+				...wasm
+			});
+			rules.push({
+				mimetype: "application/wasm",
+				...wasm
+			});
 		}
-		this.startTime = null;
-		if (err) return handleError(err);
-
-		const cbs = this.callbacks;
-		this.callbacks = [];
-		logger.time("done hook");
-		this.compiler.hooks.done.callAsync(stats, err => {
-			logger.timeEnd("done hook");
-			if (err) return handleError(err, cbs);
-			this.handler(null, stats);
-			logger.time("storeBuildDependencies");
-			this.compiler.cache.storeBuildDependencies(
-				compilation.buildDependencies,
-				err => {
-					logger.timeEnd("storeBuildDependencies");
-					if (err) return handleError(err, cbs);
-					logger.time("beginIdle");
-					this.compiler.cache.beginIdle();
-					this.compiler.idle = true;
-					logger.timeEnd("beginIdle");
-					process.nextTick(() => {
-						if (!this.closed) {
-							this.watch(
-								compilation.fileDependencies,
-								compilation.contextDependencies,
-								compilation.missingDependencies
-							);
-						}
-					});
-					for (const cb of cbs) cb(null);
-					this.compiler.hooks.afterDone.call(stats);
+		if (css) {
+			const cssRule = {
+				type: "css",
+				resolve: {
+					fullySpecified: true,
+					preferRelative: true
 				}
-			);
-		});
-	}
-
-	/**
-	 * @param {Iterable<string>} files watched files
-	 * @param {Iterable<string>} dirs watched directories
-	 * @param {Iterable<string>} missing watched existence entries
-	 * @returns {void}
-	 */
-	watch(files, dirs, missing) {
-		this.pausedWatcher = null;
-		this.watcher = this.compiler.watchFileSystem.watch(
-			files,
-			dirs,
-			missing,
-			this.lastWatcherStartTime,
-			this.watchOptions,
-			(
-				err,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changedFiles,
-				removedFiles
-			) => {
-				if (err) {
-					this.compiler.modifiedFiles = undefined;
-					this.compiler.removedFiles = undefined;
-					this.compiler.fileTimestamps = undefined;
-					this.compiler.contextTimestamps = undefined;
-					this.compiler.fsStartTime = undefined;
-					return this.handler(err);
+			};
+			const cssModulesRule = {
+				type: "css/module",
+				resolve: {
+					fullySpecified: true
 				}
-				this._invalidate(
-					fileTimeInfoEntries,
-					contextTimeInfoEntries,
-					changedFiles,
-					removedFiles
-				);
-				this._onChange();
+			};
+			rules.push({
+				test: /\.css$/i,
+				oneOf: [
+					{
+						test: /\.module\.css$/i,
+						...cssModulesRule
+					},
+					{
+						...cssRule
+					}
+				]
+			});
+			rules.push({
+				mimetype: "text/css+module",
+				...cssModulesRule
+			});
+			rules.push({
+				mimetype: "text/css",
+				...cssRule
+			});
+		}
+		rules.push(
+			{
+				dependency: "url",
+				oneOf: [
+					{
+						scheme: /^data$/,
+						type: "asset/inline"
+					},
+					{
+						type: "asset/resource"
+					}
+				]
 			},
-			(fileName, changeTime) => {
-				if (!this._invalidReported) {
-					this._invalidReported = true;
-					this.compiler.hooks.invalid.call(fileName, changeTime);
-				}
-				this._onInvalid();
+			{
+				assert: { type: "json" },
+				type: "json"
 			}
 		);
-	}
+		return rules;
+	});
+};
 
+/**
+ * @param {Output} output options
+ * @param {Object} options options
+ * @param {string} options.context context
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
+ * @param {boolean} options.outputModule is outputModule experiment enabled
+ * @param {boolean} options.development is development mode
+ * @param {Entry} options.entry entry option
+ * @param {ModuleOptions} options.module module option
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applyOutputDefaults = (
+	output,
+	{
+		context,
+		targetProperties: tp,
+		isAffectedByBrowserslist,
+		outputModule,
+		development,
+		entry,
+		module,
+		futureDefaults
+	}
+) => {
 	/**
-	 * @param {Callback<void>=} callback signals when the build has completed again
-	 * @returns {void}
+	 * @param {Library=} library the library option
+	 * @returns {string} a readable library name
 	 */
-	invalidate(callback) {
-		if (callback) {
-			this.callbacks.push(callback);
-		}
-		if (!this._invalidReported) {
-			this._invalidReported = true;
-			this.compiler.hooks.invalid.call(null, Date.now());
-		}
-		this._onChange();
-		this._invalidate();
-	}
-
-	_invalidate(
-		fileTimeInfoEntries,
-		contextTimeInfoEntries,
-		changedFiles,
-		removedFiles
-	) {
-		if (this.suspended || (this._isBlocked() && (this.blocked = true))) {
-			this._mergeWithCollected(changedFiles, removedFiles);
-			return;
+	const getLibraryName = library => {
+		const libraryName =
+			typeof library === "object" &&
+			library &&
+			!Array.isArray(library) &&
+			"type" in library
+				? library.name
+				: /** @type {LibraryName=} */ (library);
+		if (Array.isArray(libraryName)) {
+			return libraryName.join(".");
+		} else if (typeof libraryName === "object") {
+			return getLibraryName(libraryName.root);
+		} else if (typeof libraryName === "string") {
+			return libraryName;
 		}
+		return "";
+	};
 
-		if (this.running) {
-			this._mergeWithCollected(changedFiles, removedFiles);
-			this.invalid = true;
-		} else {
-			this._go(
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changedFiles,
-				removedFiles
-			);
+	F(output, "uniqueName", () => {
+		const libraryName = getLibraryName(output.library);
+		if (libraryName) return libraryName;
+		const pkgPath = path.resolve(context, "package.json");
+		try {
+			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+			return packageInfo.name || "";
+		} catch (e) {
+			if (e.code !== "ENOENT") {
+				e.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
+				throw e;
+			}
+			return "";
 		}
-	}
-
-	suspend() {
-		this.suspended = true;
-	}
+	});
 
-	resume() {
-		if (this.suspended) {
-			this.suspended = false;
-			this._invalidate();
+	F(output, "module", () => !!outputModule);
+	D(output, "filename", output.module ? "[name].mjs" : "[name].js");
+	F(output, "iife", () => !output.module);
+	D(output, "importFunctionName", "import");
+	D(output, "importMetaName", "import.meta");
+	F(output, "chunkFilename", () => {
+		const filename = output.filename;
+		if (typeof filename !== "function") {
+			const hasName = filename.includes("[name]");
+			const hasId = filename.includes("[id]");
+			const hasChunkHash = filename.includes("[chunkhash]");
+			const hasContentHash = filename.includes("[contenthash]");
+			// Anything changing depending on chunk is fine
+			if (hasChunkHash || hasContentHash || hasName || hasId) return filename;
+			// Otherwise prefix "[id]." in front of the basename to make it changing
+			return filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
 		}
-	}
-
-	/**
-	 * @param {Callback<void>} callback signals when the watcher is closed
-	 * @returns {void}
-	 */
-	close(callback) {
-		if (this._closeCallbacks) {
-			if (callback) {
-				this._closeCallbacks.push(callback);
-			}
-			return;
+		return output.module ? "[id].mjs" : "[id].js";
+	});
+	F(output, "cssFilename", () => {
+		const filename = output.filename;
+		if (typeof filename !== "function") {
+			return filename.replace(/\.[mc]?js(\?|$)/, ".css$1");
 		}
-		const finalCallback = (err, compilation) => {
-			this.running = false;
-			this.compiler.running = false;
-			this.compiler.watching = undefined;
-			this.compiler.watchMode = false;
-			this.compiler.modifiedFiles = undefined;
-			this.compiler.removedFiles = undefined;
-			this.compiler.fileTimestamps = undefined;
-			this.compiler.contextTimestamps = undefined;
-			this.compiler.fsStartTime = undefined;
-			const shutdown = err => {
-				this.compiler.hooks.watchClose.call();
-				const closeCallbacks = this._closeCallbacks;
-				this._closeCallbacks = undefined;
-				for (const cb of closeCallbacks) cb(err);
-			};
-			if (compilation) {
-				const logger = compilation.getLogger("webpack.Watching");
-				logger.time("storeBuildDependencies");
-				this.compiler.cache.storeBuildDependencies(
-					compilation.buildDependencies,
-					err2 => {
-						logger.timeEnd("storeBuildDependencies");
-						shutdown(err || err2);
-					}
+		return "[id].css";
+	});
+	F(output, "cssChunkFilename", () => {
+		const chunkFilename = output.chunkFilename;
+		if (typeof chunkFilename !== "function") {
+			return chunkFilename.replace(/\.[mc]?js(\?|$)/, ".css$1");
+		}
+		return "[id].css";
+	});
+	D(output, "assetModuleFilename", "[hash][ext][query]");
+	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
+	D(output, "compareBeforeEmit", true);
+	D(output, "charset", true);
+	F(output, "hotUpdateGlobal", () =>
+		Template.toIdentifier(
+			"webpackHotUpdate" + Template.toIdentifier(output.uniqueName)
+		)
+	);
+	F(output, "chunkLoadingGlobal", () =>
+		Template.toIdentifier(
+			"webpackChunk" + Template.toIdentifier(output.uniqueName)
+		)
+	);
+	F(output, "globalObject", () => {
+		if (tp) {
+			if (tp.global) return "global";
+			if (tp.globalThis) return "globalThis";
+		}
+		return "self";
+	});
+	F(output, "chunkFormat", () => {
+		if (tp) {
+			const helpMessage = isAffectedByBrowserslist
+				? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly."
+				: "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
+			if (output.module) {
+				if (tp.dynamicImport) return "module";
+				if (tp.document) return "array-push";
+				throw new Error(
+					"For the selected environment is no default ESM chunk format available:\n" +
+						"ESM exports can be chosen when 'import()' is available.\n" +
+						"JSONP Array push can be chosen when 'document' is available.\n" +
+						helpMessage
 				);
 			} else {
-				shutdown(err);
+				if (tp.document) return "array-push";
+				if (tp.require) return "commonjs";
+				if (tp.nodeBuiltins) return "commonjs";
+				if (tp.importScripts) return "array-push";
+				throw new Error(
+					"For the selected environment is no default script chunk format available:\n" +
+						"JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
+						"CommonJs exports can be chosen when 'require' or node builtins are available.\n" +
+						helpMessage
+				);
 			}
-		};
-
-		this.closed = true;
-		if (this.watcher) {
-			this.watcher.close();
-			this.watcher = null;
 		}
-		if (this.pausedWatcher) {
-			this.pausedWatcher.close();
-			this.pausedWatcher = null;
+		throw new Error(
+			"Chunk format can't be selected by default when no target is specified"
+		);
+	});
+	D(output, "asyncChunks", true);
+	F(output, "chunkLoading", () => {
+		if (tp) {
+			switch (output.chunkFormat) {
+				case "array-push":
+					if (tp.document) return "jsonp";
+					if (tp.importScripts) return "import-scripts";
+					break;
+				case "commonjs":
+					if (tp.require) return "require";
+					if (tp.nodeBuiltins) return "async-node";
+					break;
+				case "module":
+					if (tp.dynamicImport) return "import";
+					break;
+			}
+			if (
+				tp.require === null ||
+				tp.nodeBuiltins === null ||
+				tp.document === null ||
+				tp.importScripts === null
+			) {
+				return "universal";
+			}
 		}
-		this._closeCallbacks = [];
-		if (callback) {
-			this._closeCallbacks.push(callback);
+		return false;
+	});
+	F(output, "workerChunkLoading", () => {
+		if (tp) {
+			switch (output.chunkFormat) {
+				case "array-push":
+					if (tp.importScriptsInWorker) return "import-scripts";
+					break;
+				case "commonjs":
+					if (tp.require) return "require";
+					if (tp.nodeBuiltins) return "async-node";
+					break;
+				case "module":
+					if (tp.dynamicImportInWorker) return "import";
+					break;
+			}
+			if (
+				tp.require === null ||
+				tp.nodeBuiltins === null ||
+				tp.importScriptsInWorker === null
+			) {
+				return "universal";
+			}
 		}
-		if (this.running) {
-			this.invalid = true;
-			this._done = finalCallback;
-		} else {
-			finalCallback();
+		return false;
+	});
+	F(output, "wasmLoading", () => {
+		if (tp) {
+			if (tp.fetchWasm) return "fetch";
+			if (tp.nodeBuiltins)
+				return output.module ? "async-node-module" : "async-node";
+			if (tp.nodeBuiltins === null || tp.fetchWasm === null) {
+				return "universal";
+			}
 		}
+		return false;
+	});
+	F(output, "workerWasmLoading", () => output.wasmLoading);
+	F(output, "devtoolNamespace", () => output.uniqueName);
+	if (output.library) {
+		F(output.library, "type", () => (output.module ? "module" : "var"));
 	}
-}
-
-module.exports = Watching;
-
-
-/***/ }),
-
-/***/ 53799:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Jarid Margolin @jaridmargolin
-*/
-
-
-
-const inspect = (__webpack_require__(73837).inspect.custom);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module")} Module */
-
-class WebpackError extends Error {
-	/**
-	 * Creates an instance of WebpackError.
-	 * @param {string=} message error message
-	 */
-	constructor(message) {
-		super(message);
-
-		this.details = undefined;
-		/** @type {Module} */
-		this.module = undefined;
-		/** @type {DependencyLocation} */
-		this.loc = undefined;
-		/** @type {boolean} */
-		this.hideStack = undefined;
-		/** @type {Chunk} */
-		this.chunk = undefined;
-		/** @type {string} */
-		this.file = undefined;
-	}
-
-	[inspect]() {
-		return this.stack + (this.details ? `\n${this.details}` : "");
-	}
+	F(output, "path", () => path.join(process.cwd(), "dist"));
+	F(output, "pathinfo", () => development);
+	D(output, "sourceMapFilename", "[file].map[query]");
+	D(
+		output,
+		"hotUpdateChunkFilename",
+		`[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`
+	);
+	D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
+	D(output, "crossOriginLoading", false);
+	F(output, "scriptType", () => (output.module ? "module" : false));
+	D(
+		output,
+		"publicPath",
+		(tp && (tp.document || tp.importScripts)) || output.scriptType === "module"
+			? "auto"
+			: ""
+	);
+	D(output, "chunkLoadTimeout", 120000);
+	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
+	D(output, "hashDigest", "hex");
+	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
+	D(output, "strictModuleExceptionHandling", false);
 
-	serialize({ write }) {
-		write(this.name);
-		write(this.message);
-		write(this.stack);
-		write(this.details);
-		write(this.loc);
-		write(this.hideStack);
-	}
+	const optimistic = v => v || v === undefined;
+	F(
+		output.environment,
+		"arrowFunction",
+		() => tp && optimistic(tp.arrowFunction)
+	);
+	F(output.environment, "const", () => tp && optimistic(tp.const));
+	F(
+		output.environment,
+		"destructuring",
+		() => tp && optimistic(tp.destructuring)
+	);
+	F(output.environment, "forOf", () => tp && optimistic(tp.forOf));
+	F(output.environment, "bigIntLiteral", () => tp && tp.bigIntLiteral);
+	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
+	F(output.environment, "module", () => tp && tp.module);
 
-	deserialize({ read }) {
-		this.name = read();
-		this.message = read();
-		this.stack = read();
-		this.details = read();
-		this.loc = read();
-		this.hideStack = read();
+	const { trustedTypes } = output;
+	if (trustedTypes) {
+		F(
+			trustedTypes,
+			"policyName",
+			() =>
+				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
+		);
 	}
-}
-
-makeSerializable(WebpackError, "webpack/lib/WebpackError");
-
-module.exports = WebpackError;
-
-
-/***/ }),
-
-/***/ 97017:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const IgnoreErrorModuleFactory = __webpack_require__(3);
-const WebpackIsIncludedDependency = __webpack_require__(26505);
-const {
-	toConstantDependency
-} = __webpack_require__(93998);
-
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
-class WebpackIsIncludedPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {function(EntryDescription): void} fn iterator
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WebpackIsIncludedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WebpackIsIncludedDependency,
-					new IgnoreErrorModuleFactory(normalModuleFactory)
-				);
-				compilation.dependencyTemplates.set(
-					WebpackIsIncludedDependency,
-					new WebpackIsIncludedDependency.Template()
-				);
+	const forEachEntry = fn => {
+		for (const name of Object.keys(entry)) {
+			fn(entry[name]);
+		}
+	};
+	A(output, "enabledLibraryTypes", () => {
+		const enabledLibraryTypes = [];
+		if (output.library) {
+			enabledLibraryTypes.push(output.library.type);
+		}
+		forEachEntry(desc => {
+			if (desc.library) {
+				enabledLibraryTypes.push(desc.library.type);
+			}
+		});
+		return enabledLibraryTypes;
+	});
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @returns {void}
-				 */
-				const handler = parser => {
-					parser.hooks.call
-						.for("__webpack_is_included__")
-						.tap("WebpackIsIncludedPlugin", expr => {
-							if (
-								expr.type !== "CallExpression" ||
-								expr.arguments.length !== 1 ||
-								expr.arguments[0].type === "SpreadElement"
-							)
-								return;
+	A(output, "enabledChunkLoadingTypes", () => {
+		const enabledChunkLoadingTypes = new Set();
+		if (output.chunkLoading) {
+			enabledChunkLoadingTypes.add(output.chunkLoading);
+		}
+		if (output.workerChunkLoading) {
+			enabledChunkLoadingTypes.add(output.workerChunkLoading);
+		}
+		forEachEntry(desc => {
+			if (desc.chunkLoading) {
+				enabledChunkLoadingTypes.add(desc.chunkLoading);
+			}
+		});
+		return Array.from(enabledChunkLoadingTypes);
+	});
 
-							const request = parser.evaluateExpression(expr.arguments[0]);
+	A(output, "enabledWasmLoadingTypes", () => {
+		const enabledWasmLoadingTypes = new Set();
+		if (output.wasmLoading) {
+			enabledWasmLoadingTypes.add(output.wasmLoading);
+		}
+		if (output.workerWasmLoading) {
+			enabledWasmLoadingTypes.add(output.workerWasmLoading);
+		}
+		forEachEntry(desc => {
+			if (desc.wasmLoading) {
+				enabledWasmLoadingTypes.add(desc.wasmLoading);
+			}
+		});
+		return Array.from(enabledWasmLoadingTypes);
+	});
+};
 
-							if (!request.isString()) return;
+/**
+ * @param {ExternalsPresets} externalsPresets options
+ * @param {Object} options options
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.buildHttp buildHttp experiment enabled
+ * @returns {void}
+ */
+const applyExternalsPresetsDefaults = (
+	externalsPresets,
+	{ targetProperties, buildHttp }
+) => {
+	D(
+		externalsPresets,
+		"web",
+		!buildHttp && targetProperties && targetProperties.web
+	);
+	D(externalsPresets, "node", targetProperties && targetProperties.node);
+	D(externalsPresets, "nwjs", targetProperties && targetProperties.nwjs);
+	D(
+		externalsPresets,
+		"electron",
+		targetProperties && targetProperties.electron
+	);
+	D(
+		externalsPresets,
+		"electronMain",
+		targetProperties &&
+			targetProperties.electron &&
+			targetProperties.electronMain
+	);
+	D(
+		externalsPresets,
+		"electronPreload",
+		targetProperties &&
+			targetProperties.electron &&
+			targetProperties.electronPreload
+	);
+	D(
+		externalsPresets,
+		"electronRenderer",
+		targetProperties &&
+			targetProperties.electron &&
+			targetProperties.electronRenderer
+	);
+};
 
-							const dep = new WebpackIsIncludedDependency(
-								request.string,
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
-							return true;
-						});
-					parser.hooks.typeof
-						.for("__webpack_is_included__")
-						.tap(
-							"WebpackIsIncludedPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WebpackIsIncludedPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("WebpackIsIncludedPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WebpackIsIncludedPlugin", handler);
+/**
+ * @param {Loader} loader options
+ * @param {Object} options options
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @returns {void}
+ */
+const applyLoaderDefaults = (loader, { targetProperties }) => {
+	F(loader, "target", () => {
+		if (targetProperties) {
+			if (targetProperties.electron) {
+				if (targetProperties.electronMain) return "electron-main";
+				if (targetProperties.electronPreload) return "electron-preload";
+				if (targetProperties.electronRenderer) return "electron-renderer";
+				return "electron";
 			}
-		);
-	}
-}
+			if (targetProperties.nwjs) return "nwjs";
+			if (targetProperties.node) return "node";
+			if (targetProperties.web) return "web";
+		}
+	});
+};
 
-module.exports = WebpackIsIncludedPlugin;
+/**
+ * @param {WebpackNode} node options
+ * @param {Object} options options
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {boolean} options.futureDefaults is future defaults enabled
+ * @returns {void}
+ */
+const applyNodeDefaults = (node, { futureDefaults, targetProperties }) => {
+	if (node === false) return;
 
+	F(node, "global", () => {
+		if (targetProperties && targetProperties.global) return false;
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn" : true;
+	});
+	F(node, "__filename", () => {
+		if (targetProperties && targetProperties.node) return "eval-only";
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn-mock" : "mock";
+	});
+	F(node, "__dirname", () => {
+		if (targetProperties && targetProperties.node) return "eval-only";
+		// TODO webpack 6 should always default to false
+		return futureDefaults ? "warn-mock" : "mock";
+	});
+};
 
-/***/ }),
+/**
+ * @param {Performance} performance options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @returns {void}
+ */
+const applyPerformanceDefaults = (performance, { production }) => {
+	if (performance === false) return;
+	D(performance, "maxAssetSize", 250000);
+	D(performance, "maxEntrypointSize", 250000);
+	F(performance, "hints", () => (production ? "warning" : false));
+};
 
-/***/ 88422:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {Optimization} optimization options
+ * @param {Object} options options
+ * @param {boolean} options.production is production
+ * @param {boolean} options.development is development
+ * @param {CssExperimentOptions} options.css is css enabled
+ * @param {boolean} options.records using records
+ * @returns {void}
+ */
+const applyOptimizationDefaults = (
+	optimization,
+	{ production, development, css, records }
+) => {
+	D(optimization, "removeAvailableModules", false);
+	D(optimization, "removeEmptyChunks", true);
+	D(optimization, "mergeDuplicateChunks", true);
+	D(optimization, "flagIncludedChunks", production);
+	F(optimization, "moduleIds", () => {
+		if (production) return "deterministic";
+		if (development) return "named";
+		return "natural";
+	});
+	F(optimization, "chunkIds", () => {
+		if (production) return "deterministic";
+		if (development) return "named";
+		return "natural";
+	});
+	F(optimization, "sideEffects", () => (production ? true : "flag"));
+	D(optimization, "providedExports", true);
+	D(optimization, "usedExports", production);
+	D(optimization, "innerGraph", production);
+	D(optimization, "mangleExports", production);
+	D(optimization, "concatenateModules", production);
+	D(optimization, "runtimeChunk", false);
+	D(optimization, "emitOnErrors", !production);
+	D(optimization, "checkWasmTypes", production);
+	D(optimization, "mangleWasmImports", false);
+	D(optimization, "portableRecords", records);
+	D(optimization, "realContentHash", production);
+	D(optimization, "minimize", production);
+	A(optimization, "minimizer", () => [
+		{
+			apply: compiler => {
+				// Lazy load the Terser plugin
+				const TerserPlugin = __webpack_require__(55302);
+				new TerserPlugin({
+					terserOptions: {
+						compress: {
+							passes: 2
+						}
+					}
+				}).apply(compiler);
+			}
+		}
+	]);
+	F(optimization, "nodeEnv", () => {
+		if (production) return "production";
+		if (development) return "development";
+		return false;
+	});
+	const { splitChunks } = optimization;
+	if (splitChunks) {
+		A(splitChunks, "defaultSizeTypes", () =>
+			css ? ["javascript", "css", "unknown"] : ["javascript", "unknown"]
+		);
+		D(splitChunks, "hidePathInfo", production);
+		D(splitChunks, "chunks", "async");
+		D(splitChunks, "usedExports", optimization.usedExports === true);
+		D(splitChunks, "minChunks", 1);
+		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
+		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));
+		F(splitChunks, "enforceSizeThreshold", () => (production ? 50000 : 30000));
+		F(splitChunks, "maxAsyncRequests", () => (production ? 30 : Infinity));
+		F(splitChunks, "maxInitialRequests", () => (production ? 30 : Infinity));
+		D(splitChunks, "automaticNameDelimiter", "-");
+		const { cacheGroups } = splitChunks;
+		F(cacheGroups, "default", () => ({
+			idHint: "",
+			reuseExistingChunk: true,
+			minChunks: 2,
+			priority: -20
+		}));
+		F(cacheGroups, "defaultVendors", () => ({
+			idHint: "vendors",
+			reuseExistingChunk: true,
+			test: NODE_MODULES_REGEXP,
+			priority: -10
+		}));
+	}
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {Object} options options
+ * @param {boolean} options.cache is cache enable
+ * @param {string} options.context build context
+ * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {Mode} options.mode mode
+ * @returns {ResolveOptions} resolve options
+ */
+const getResolveDefaults = ({ cache, context, targetProperties, mode }) => {
+	/** @type {string[]} */
+	const conditions = ["webpack"];
 
+	conditions.push(mode === "development" ? "development" : "production");
 
+	if (targetProperties) {
+		if (targetProperties.webworker) conditions.push("worker");
+		if (targetProperties.node) conditions.push("node");
+		if (targetProperties.web) conditions.push("browser");
+		if (targetProperties.electron) conditions.push("electron");
+		if (targetProperties.nwjs) conditions.push("nwjs");
+	}
 
-const OptionsApply = __webpack_require__(81426);
+	const jsExtensions = [".js", ".json", ".wasm"];
 
-const AssetModulesPlugin = __webpack_require__(16109);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const JsonModulesPlugin = __webpack_require__(86770);
+	const tp = targetProperties;
+	const browserField =
+		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
 
-const ChunkPrefetchPreloadPlugin = __webpack_require__(33895);
+	/** @type {function(): ResolveOptions} */
+	const cjsDeps = () => ({
+		aliasFields: browserField ? ["browser"] : [],
+		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
+		conditionNames: ["require", "module", "..."],
+		extensions: [...jsExtensions]
+	});
+	/** @type {function(): ResolveOptions} */
+	const esmDeps = () => ({
+		aliasFields: browserField ? ["browser"] : [],
+		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
+		conditionNames: ["import", "module", "..."],
+		extensions: [...jsExtensions]
+	});
 
-const EntryOptionPlugin = __webpack_require__(9909);
-const RecordIdsPlugin = __webpack_require__(11094);
+	/** @type {ResolveOptions} */
+	const resolveOptions = {
+		cache,
+		modules: ["node_modules"],
+		conditionNames: conditions,
+		mainFiles: ["index"],
+		extensions: [],
+		aliasFields: [],
+		exportsFields: ["exports"],
+		roots: [context],
+		mainFields: ["main"],
+		byDependency: {
+			wasm: esmDeps(),
+			esm: esmDeps(),
+			loaderImport: esmDeps(),
+			url: {
+				preferRelative: true
+			},
+			worker: {
+				...esmDeps(),
+				preferRelative: true
+			},
+			commonjs: cjsDeps(),
+			amd: cjsDeps(),
+			// for backward-compat: loadModule
+			loader: cjsDeps(),
+			// for backward-compat: Custom Dependency
+			unknown: cjsDeps(),
+			// for backward-compat: getResolve without dependencyType
+			undefined: cjsDeps()
+		}
+	};
 
-const RuntimePlugin = __webpack_require__(2307);
+	return resolveOptions;
+};
 
-const APIPlugin = __webpack_require__(74315);
-const CompatibilityPlugin = __webpack_require__(94258);
-const ConstPlugin = __webpack_require__(11146);
-const ExportsInfoApiPlugin = __webpack_require__(7145);
-const WebpackIsIncludedPlugin = __webpack_require__(97017);
+/**
+ * @param {Object} options options
+ * @param {boolean} options.cache is cache enable
+ * @returns {ResolveOptions} resolve options
+ */
+const getResolveLoaderDefaults = ({ cache }) => {
+	/** @type {ResolveOptions} */
+	const resolveOptions = {
+		cache,
+		conditionNames: ["loader", "require", "node"],
+		exportsFields: ["exports"],
+		mainFields: ["loader", "main"],
+		extensions: [".js"],
+		mainFiles: ["index"]
+	};
 
-const TemplatedPathPlugin = __webpack_require__(80734);
-const UseStrictPlugin = __webpack_require__(36803);
-const WarnCaseSensitiveModulesPlugin = __webpack_require__(56504);
+	return resolveOptions;
+};
 
-const DataUriPlugin = __webpack_require__(64820);
-const FileUriPlugin = __webpack_require__(57637);
+/**
+ * @param {InfrastructureLogging} infrastructureLogging options
+ * @returns {void}
+ */
+const applyInfrastructureLoggingDefaults = infrastructureLogging => {
+	F(infrastructureLogging, "stream", () => process.stderr);
+	const tty =
+		/** @type {any} */ (infrastructureLogging.stream).isTTY &&
+		process.env.TERM !== "dumb";
+	D(infrastructureLogging, "level", "info");
+	D(infrastructureLogging, "debug", false);
+	D(infrastructureLogging, "colors", tty);
+	D(infrastructureLogging, "appendOnly", !tty);
+};
 
-const ResolverCachePlugin = __webpack_require__(97347);
+exports.applyWebpackOptionsBaseDefaults = applyWebpackOptionsBaseDefaults;
+exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
 
-const CommonJsPlugin = __webpack_require__(32406);
-const HarmonyModulesPlugin = __webpack_require__(39029);
-const ImportMetaPlugin = __webpack_require__(17228);
-const ImportPlugin = __webpack_require__(41293);
-const LoaderPlugin = __webpack_require__(24721);
-const RequireContextPlugin = __webpack_require__(2928);
-const RequireEnsurePlugin = __webpack_require__(8434);
-const RequireIncludePlugin = __webpack_require__(37378);
-const SystemPlugin = __webpack_require__(97981);
-const URLPlugin = __webpack_require__(14412);
-const WorkerPlugin = __webpack_require__(82509);
 
-const InferAsyncModulesPlugin = __webpack_require__(59498);
+/***/ }),
 
-const JavascriptMetaInfoPlugin = __webpack_require__(52329);
-const DefaultStatsFactoryPlugin = __webpack_require__(71760);
-const DefaultStatsPresetPlugin = __webpack_require__(55442);
-const DefaultStatsPrinterPlugin = __webpack_require__(58692);
+/***/ 26693:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-const { cleverMerge } = __webpack_require__(60839);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./Compiler")} Compiler */
 
-class WebpackOptionsApply extends OptionsApply {
-	constructor() {
-		super();
-	}
 
-	/**
-	 * @param {WebpackOptions} options options object
-	 * @param {Compiler} compiler compiler object
-	 * @returns {WebpackOptions} options object
-	 */
-	process(options, compiler) {
-		compiler.outputPath = options.output.path;
-		compiler.recordsInputPath = options.recordsInputPath || null;
-		compiler.recordsOutputPath = options.recordsOutputPath || null;
-		compiler.name = options.name;
+const util = __webpack_require__(73837);
 
-		if (options.externals) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin(options.externalsType, options.externals).apply(
-				compiler
+/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
+/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+
+const handledDeprecatedNoEmitOnErrors = util.deprecate(
+	(noEmitOnErrors, emitOnErrors) => {
+		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
+			throw new Error(
+				"Conflicting use of 'optimization.noEmitOnErrors' and 'optimization.emitOnErrors'. Remove deprecated 'optimization.noEmitOnErrors' from config."
 			);
 		}
+		return !noEmitOnErrors;
+	},
+	"optimization.noEmitOnErrors is deprecated in favor of optimization.emitOnErrors",
+	"DEP_WEBPACK_CONFIGURATION_OPTIMIZATION_NO_EMIT_ON_ERRORS"
+);
 
-		if (options.externalsPresets.node) {
-			const NodeTargetPlugin = __webpack_require__(17916);
-			new NodeTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.electronMain) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin("main").apply(compiler);
-		}
-		if (options.externalsPresets.electronPreload) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin("preload").apply(compiler);
-		}
-		if (options.externalsPresets.electronRenderer) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin("renderer").apply(compiler);
-		}
-		if (
-			options.externalsPresets.electron &&
-			!options.externalsPresets.electronMain &&
-			!options.externalsPresets.electronPreload &&
-			!options.externalsPresets.electronRenderer
-		) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ElectronTargetPlugin = __webpack_require__(32277);
-			new ElectronTargetPlugin().apply(compiler);
-		}
-		if (options.externalsPresets.nwjs) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
-		}
-		if (options.externalsPresets.webAsync) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin(
-				"import",
-				options.experiments.css
-					? ({ request, dependencyType }, callback) => {
-							if (dependencyType === "url") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `asset ${request}`);
-							} else if (dependencyType === "css-import") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `css-import ${request}`);
-							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-								if (/^\.css(\?|$)/.test(request))
-									return callback(null, `css-import ${request}`);
-								return callback(null, `import ${request}`);
-							}
-							callback();
-					  }
-					: /^(\/\/|https?:\/\/|std:)/
-			).apply(compiler);
-		} else if (options.externalsPresets.web) {
-			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-			const ExternalsPlugin = __webpack_require__(6652);
-			new ExternalsPlugin(
-				"module",
-				options.experiments.css
-					? ({ request, dependencyType }, callback) => {
-							if (dependencyType === "url") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `asset ${request}`);
-							} else if (dependencyType === "css-import") {
-								if (/^(\/\/|https?:\/\/)/.test(request))
-									return callback(null, `css-import ${request}`);
-							} else if (/^(\/\/|https?:\/\/|std:)/.test(request)) {
-								if (/^\.css(\?|$)/.test(request))
-									return callback(null, `css-import ${request}`);
-								return callback(null, `module ${request}`);
-							}
-							callback();
-					  }
-					: /^(\/\/|https?:\/\/|std:)/
-			).apply(compiler);
-		}
+/**
+ * @template T
+ * @template R
+ * @param {T|undefined} value value or not
+ * @param {function(T): R} fn nested handler
+ * @returns {R} result value
+ */
+const nestedConfig = (value, fn) =>
+	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
 
-		new ChunkPrefetchPreloadPlugin().apply(compiler);
+/**
+ * @template T
+ * @param {T|undefined} value value or not
+ * @returns {T} result value
+ */
+const cloneObject = value => {
+	return /** @type {T} */ ({ ...value });
+};
 
-		if (typeof options.output.chunkFormat === "string") {
-			switch (options.output.chunkFormat) {
-				case "array-push": {
-					const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
-					new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
-					break;
-				}
-				case "commonjs": {
-					const CommonJsChunkFormatPlugin = __webpack_require__(84508);
-					new CommonJsChunkFormatPlugin().apply(compiler);
-					break;
-				}
-				case "module": {
-					const ModuleChunkFormatPlugin = __webpack_require__(68927);
-					new ModuleChunkFormatPlugin().apply(compiler);
-					break;
-				}
-				default:
-					throw new Error(
-						"Unsupported chunk format '" + options.output.chunkFormat + "'."
-					);
-			}
-		}
+/**
+ * @template T
+ * @template R
+ * @param {T|undefined} value value or not
+ * @param {function(T): R} fn nested handler
+ * @returns {R|undefined} result value
+ */
+const optionalNestedConfig = (value, fn) =>
+	value === undefined ? undefined : fn(value);
 
-		if (options.output.enabledChunkLoadingTypes.length > 0) {
-			for (const type of options.output.enabledChunkLoadingTypes) {
-				const EnableChunkLoadingPlugin = __webpack_require__(61291);
-				new EnableChunkLoadingPlugin(type).apply(compiler);
-			}
-		}
+/**
+ * @template T
+ * @template R
+ * @param {T[]|undefined} value array or not
+ * @param {function(T[]): R[]} fn nested handler
+ * @returns {R[]|undefined} cloned value
+ */
+const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
 
-		if (options.output.enabledWasmLoadingTypes.length > 0) {
-			for (const type of options.output.enabledWasmLoadingTypes) {
-				const EnableWasmLoadingPlugin = __webpack_require__(78613);
-				new EnableWasmLoadingPlugin(type).apply(compiler);
-			}
-		}
+/**
+ * @template T
+ * @template R
+ * @param {T[]|undefined} value array or not
+ * @param {function(T[]): R[]} fn nested handler
+ * @returns {R[]|undefined} cloned value
+ */
+const optionalNestedArray = (value, fn) =>
+	Array.isArray(value) ? fn(value) : undefined;
 
-		if (options.output.enabledLibraryTypes.length > 0) {
-			for (const type of options.output.enabledLibraryTypes) {
-				const EnableLibraryPlugin = __webpack_require__(91452);
-				new EnableLibraryPlugin(type).apply(compiler);
+/**
+ * @template T
+ * @template R
+ * @param {Record<string, T>|undefined} value value or not
+ * @param {function(T): R} fn nested handler
+ * @param {Record<string, function(T): R>=} customKeys custom nested handler for some keys
+ * @returns {Record<string, R>} result value
+ */
+const keyedNestedConfig = (value, fn, customKeys) => {
+	const result =
+		value === undefined
+			? {}
+			: Object.keys(value).reduce(
+					(obj, key) => (
+						(obj[key] = (
+							customKeys && key in customKeys ? customKeys[key] : fn
+						)(value[key])),
+						obj
+					),
+					/** @type {Record<string, R>} */ ({})
+			  );
+	if (customKeys) {
+		for (const key of Object.keys(customKeys)) {
+			if (!(key in result)) {
+				result[key] = customKeys[key](/** @type {T} */ ({}));
 			}
 		}
+	}
+	return result;
+};
 
-		if (options.output.pathinfo) {
-			const ModuleInfoHeaderPlugin = __webpack_require__(3454);
-			new ModuleInfoHeaderPlugin(options.output.pathinfo !== true).apply(
-				compiler
-			);
-		}
-
-		if (options.output.clean) {
-			const CleanPlugin = __webpack_require__(31085);
-			new CleanPlugin(
-				options.output.clean === true ? {} : options.output.clean
-			).apply(compiler);
-		}
-
-		if (options.devtool) {
-			if (options.devtool.includes("source-map")) {
-				const hidden = options.devtool.includes("hidden");
-				const inline = options.devtool.includes("inline");
-				const evalWrapped = options.devtool.includes("eval");
-				const cheap = options.devtool.includes("cheap");
-				const moduleMaps = options.devtool.includes("module");
-				const noSources = options.devtool.includes("nosources");
-				const Plugin = evalWrapped
-					? __webpack_require__(14790)
-					: __webpack_require__(63872);
-				new Plugin({
-					filename: inline ? null : options.output.sourceMapFilename,
-					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
-					fallbackModuleFilenameTemplate:
-						options.output.devtoolFallbackModuleFilenameTemplate,
-					append: hidden ? false : undefined,
-					module: moduleMaps ? true : cheap ? false : true,
-					columns: cheap ? false : true,
-					noSources: noSources,
-					namespace: options.output.devtoolNamespace
-				}).apply(compiler);
-			} else if (options.devtool.includes("eval")) {
-				const EvalDevToolModulePlugin = __webpack_require__(65218);
-				new EvalDevToolModulePlugin({
-					moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
-					namespace: options.output.devtoolNamespace
-				}).apply(compiler);
+/**
+ * @param {WebpackOptions} config input config
+ * @returns {WebpackOptionsNormalized} normalized options
+ */
+const getNormalizedWebpackOptions = config => {
+	return {
+		amd: config.amd,
+		bail: config.bail,
+		cache: optionalNestedConfig(config.cache, cache => {
+			if (cache === false) return false;
+			if (cache === true) {
+				return {
+					type: "memory",
+					maxGenerations: undefined
+				};
 			}
-		}
-
-		new JavascriptModulesPlugin().apply(compiler);
-		new JsonModulesPlugin().apply(compiler);
-		new AssetModulesPlugin().apply(compiler);
-
-		if (!options.experiments.outputModule) {
-			if (options.output.module) {
-				throw new Error(
-					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
-				);
+			switch (cache.type) {
+				case "filesystem":
+					return {
+						type: "filesystem",
+						allowCollectingMemory: cache.allowCollectingMemory,
+						maxMemoryGenerations: cache.maxMemoryGenerations,
+						maxAge: cache.maxAge,
+						profile: cache.profile,
+						buildDependencies: cloneObject(cache.buildDependencies),
+						cacheDirectory: cache.cacheDirectory,
+						cacheLocation: cache.cacheLocation,
+						hashAlgorithm: cache.hashAlgorithm,
+						compression: cache.compression,
+						idleTimeout: cache.idleTimeout,
+						idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
+						idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
+						name: cache.name,
+						store: cache.store,
+						version: cache.version
+					};
+				case undefined:
+				case "memory":
+					return {
+						type: "memory",
+						maxGenerations: cache.maxGenerations
+					};
+				default:
+					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+					throw new Error(`Not implemented cache.type ${cache.type}`);
 			}
-			if (options.output.enabledLibraryTypes.includes("module")) {
-				throw new Error(
-					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
-				);
+		}),
+		context: config.context,
+		dependencies: config.dependencies,
+		devServer: optionalNestedConfig(config.devServer, devServer => ({
+			...devServer
+		})),
+		devtool: config.devtool,
+		entry:
+			config.entry === undefined
+				? { main: {} }
+				: typeof config.entry === "function"
+				? (
+						fn => () =>
+							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
+				  )(config.entry)
+				: getNormalizedEntryStatic(config.entry),
+		experiments: nestedConfig(config.experiments, experiments => ({
+			...experiments,
+			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
+				Array.isArray(options) ? { allowedUris: options } : options
+			),
+			lazyCompilation: optionalNestedConfig(
+				experiments.lazyCompilation,
+				options =>
+					options === true ? {} : options === false ? undefined : options
+			),
+			css: optionalNestedConfig(experiments.css, options =>
+				options === true ? {} : options === false ? undefined : options
+			)
+		})),
+		externals: config.externals,
+		externalsPresets: cloneObject(config.externalsPresets),
+		externalsType: config.externalsType,
+		ignoreWarnings: config.ignoreWarnings
+			? config.ignoreWarnings.map(ignore => {
+					if (typeof ignore === "function") return ignore;
+					const i = ignore instanceof RegExp ? { message: ignore } : ignore;
+					return (warning, { requestShortener }) => {
+						if (!i.message && !i.module && !i.file) return false;
+						if (i.message && !i.message.test(warning.message)) {
+							return false;
+						}
+						if (
+							i.module &&
+							(!warning.module ||
+								!i.module.test(
+									warning.module.readableIdentifier(requestShortener)
+								))
+						) {
+							return false;
+						}
+						if (i.file && (!warning.file || !i.file.test(warning.file))) {
+							return false;
+						}
+						return true;
+					};
+			  })
+			: undefined,
+		infrastructureLogging: cloneObject(config.infrastructureLogging),
+		loader: cloneObject(config.loader),
+		mode: config.mode,
+		module: nestedConfig(config.module, module => ({
+			noParse: module.noParse,
+			unsafeCache: module.unsafeCache,
+			parser: keyedNestedConfig(module.parser, cloneObject, {
+				javascript: parserOptions => ({
+					unknownContextRequest: module.unknownContextRequest,
+					unknownContextRegExp: module.unknownContextRegExp,
+					unknownContextRecursive: module.unknownContextRecursive,
+					unknownContextCritical: module.unknownContextCritical,
+					exprContextRequest: module.exprContextRequest,
+					exprContextRegExp: module.exprContextRegExp,
+					exprContextRecursive: module.exprContextRecursive,
+					exprContextCritical: module.exprContextCritical,
+					wrappedContextRegExp: module.wrappedContextRegExp,
+					wrappedContextRecursive: module.wrappedContextRecursive,
+					wrappedContextCritical: module.wrappedContextCritical,
+					// TODO webpack 6 remove
+					strictExportPresence: module.strictExportPresence,
+					strictThisContextOnImports: module.strictThisContextOnImports,
+					...parserOptions
+				})
+			}),
+			generator: cloneObject(module.generator),
+			defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
+			rules: nestedArray(module.rules, r => [...r])
+		})),
+		name: config.name,
+		node: nestedConfig(
+			config.node,
+			node =>
+				node && {
+					...node
+				}
+		),
+		optimization: nestedConfig(config.optimization, optimization => {
+			return {
+				...optimization,
+				runtimeChunk: getNormalizedOptimizationRuntimeChunk(
+					optimization.runtimeChunk
+				),
+				splitChunks: nestedConfig(
+					optimization.splitChunks,
+					splitChunks =>
+						splitChunks && {
+							...splitChunks,
+							defaultSizeTypes: splitChunks.defaultSizeTypes
+								? [...splitChunks.defaultSizeTypes]
+								: ["..."],
+							cacheGroups: cloneObject(splitChunks.cacheGroups)
+						}
+				),
+				emitOnErrors:
+					optimization.noEmitOnErrors !== undefined
+						? handledDeprecatedNoEmitOnErrors(
+								optimization.noEmitOnErrors,
+								optimization.emitOnErrors
+						  )
+						: optimization.emitOnErrors
+			};
+		}),
+		output: nestedConfig(config.output, output => {
+			const { library } = output;
+			const libraryAsName = /** @type {LibraryName} */ (library);
+			const libraryBase =
+				typeof library === "object" &&
+				library &&
+				!Array.isArray(library) &&
+				"type" in library
+					? library
+					: libraryAsName || output.libraryTarget
+					? /** @type {LibraryOptions} */ ({
+							name: libraryAsName
+					  })
+					: undefined;
+			/** @type {OutputNormalized} */
+			const result = {
+				assetModuleFilename: output.assetModuleFilename,
+				asyncChunks: output.asyncChunks,
+				charset: output.charset,
+				chunkFilename: output.chunkFilename,
+				chunkFormat: output.chunkFormat,
+				chunkLoading: output.chunkLoading,
+				chunkLoadingGlobal: output.chunkLoadingGlobal,
+				chunkLoadTimeout: output.chunkLoadTimeout,
+				cssFilename: output.cssFilename,
+				cssChunkFilename: output.cssChunkFilename,
+				clean: output.clean,
+				compareBeforeEmit: output.compareBeforeEmit,
+				crossOriginLoading: output.crossOriginLoading,
+				devtoolFallbackModuleFilenameTemplate:
+					output.devtoolFallbackModuleFilenameTemplate,
+				devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
+				devtoolNamespace: output.devtoolNamespace,
+				environment: cloneObject(output.environment),
+				enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
+					? [...output.enabledChunkLoadingTypes]
+					: ["..."],
+				enabledLibraryTypes: output.enabledLibraryTypes
+					? [...output.enabledLibraryTypes]
+					: ["..."],
+				enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
+					? [...output.enabledWasmLoadingTypes]
+					: ["..."],
+				filename: output.filename,
+				globalObject: output.globalObject,
+				hashDigest: output.hashDigest,
+				hashDigestLength: output.hashDigestLength,
+				hashFunction: output.hashFunction,
+				hashSalt: output.hashSalt,
+				hotUpdateChunkFilename: output.hotUpdateChunkFilename,
+				hotUpdateGlobal: output.hotUpdateGlobal,
+				hotUpdateMainFilename: output.hotUpdateMainFilename,
+				iife: output.iife,
+				importFunctionName: output.importFunctionName,
+				importMetaName: output.importMetaName,
+				scriptType: output.scriptType,
+				library: libraryBase && {
+					type:
+						output.libraryTarget !== undefined
+							? output.libraryTarget
+							: libraryBase.type,
+					auxiliaryComment:
+						output.auxiliaryComment !== undefined
+							? output.auxiliaryComment
+							: libraryBase.auxiliaryComment,
+					export:
+						output.libraryExport !== undefined
+							? output.libraryExport
+							: libraryBase.export,
+					name: libraryBase.name,
+					umdNamedDefine:
+						output.umdNamedDefine !== undefined
+							? output.umdNamedDefine
+							: libraryBase.umdNamedDefine
+				},
+				module: output.module,
+				path: output.path,
+				pathinfo: output.pathinfo,
+				publicPath: output.publicPath,
+				sourceMapFilename: output.sourceMapFilename,
+				sourcePrefix: output.sourcePrefix,
+				strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+				trustedTypes: optionalNestedConfig(
+					output.trustedTypes,
+					trustedTypes => {
+						if (trustedTypes === true) return {};
+						if (typeof trustedTypes === "string")
+							return { policyName: trustedTypes };
+						return { ...trustedTypes };
+					}
+				),
+				uniqueName: output.uniqueName,
+				wasmLoading: output.wasmLoading,
+				webassemblyModuleFilename: output.webassemblyModuleFilename,
+				workerChunkLoading: output.workerChunkLoading,
+				workerWasmLoading: output.workerWasmLoading
+			};
+			return result;
+		}),
+		parallelism: config.parallelism,
+		performance: optionalNestedConfig(config.performance, performance => {
+			if (performance === false) return false;
+			return {
+				...performance
+			};
+		}),
+		plugins: nestedArray(config.plugins, p => [...p]),
+		profile: config.profile,
+		recordsInputPath:
+			config.recordsInputPath !== undefined
+				? config.recordsInputPath
+				: config.recordsPath,
+		recordsOutputPath:
+			config.recordsOutputPath !== undefined
+				? config.recordsOutputPath
+				: config.recordsPath,
+		resolve: nestedConfig(config.resolve, resolve => ({
+			...resolve,
+			byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
+		})),
+		resolveLoader: cloneObject(config.resolveLoader),
+		snapshot: nestedConfig(config.snapshot, snapshot => ({
+			resolveBuildDependencies: optionalNestedConfig(
+				snapshot.resolveBuildDependencies,
+				resolveBuildDependencies => ({
+					timestamp: resolveBuildDependencies.timestamp,
+					hash: resolveBuildDependencies.hash
+				})
+			),
+			buildDependencies: optionalNestedConfig(
+				snapshot.buildDependencies,
+				buildDependencies => ({
+					timestamp: buildDependencies.timestamp,
+					hash: buildDependencies.hash
+				})
+			),
+			resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
+				timestamp: resolve.timestamp,
+				hash: resolve.hash
+			})),
+			module: optionalNestedConfig(snapshot.module, module => ({
+				timestamp: module.timestamp,
+				hash: module.hash
+			})),
+			immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
+			managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p])
+		})),
+		stats: nestedConfig(config.stats, stats => {
+			if (stats === false) {
+				return {
+					preset: "none"
+				};
 			}
-			if (options.externalsType === "module") {
-				throw new Error(
-					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
-				);
+			if (stats === true) {
+				return {
+					preset: "normal"
+				};
 			}
-		}
+			if (typeof stats === "string") {
+				return {
+					preset: stats
+				};
+			}
+			return {
+				...stats
+			};
+		}),
+		target: config.target,
+		watch: config.watch,
+		watchOptions: cloneObject(config.watchOptions)
+	};
+};
 
-		if (options.experiments.syncWebAssembly) {
-			const WebAssemblyModulesPlugin = __webpack_require__(53639);
-			new WebAssemblyModulesPlugin({
-				mangleImports: options.optimization.mangleWasmImports
-			}).apply(compiler);
+/**
+ * @param {EntryStatic} entry static entry options
+ * @returns {EntryStaticNormalized} normalized static entry options
+ */
+const getNormalizedEntryStatic = entry => {
+	if (typeof entry === "string") {
+		return {
+			main: {
+				import: [entry]
+			}
+		};
+	}
+	if (Array.isArray(entry)) {
+		return {
+			main: {
+				import: entry
+			}
+		};
+	}
+	/** @type {EntryStaticNormalized} */
+	const result = {};
+	for (const key of Object.keys(entry)) {
+		const value = entry[key];
+		if (typeof value === "string") {
+			result[key] = {
+				import: [value]
+			};
+		} else if (Array.isArray(value)) {
+			result[key] = {
+				import: value
+			};
+		} else {
+			result[key] = {
+				import:
+					value.import &&
+					(Array.isArray(value.import) ? value.import : [value.import]),
+				filename: value.filename,
+				layer: value.layer,
+				runtime: value.runtime,
+				publicPath: value.publicPath,
+				chunkLoading: value.chunkLoading,
+				asyncChunks: value.asyncChunks,
+				wasmLoading: value.wasmLoading,
+				dependOn:
+					value.dependOn &&
+					(Array.isArray(value.dependOn) ? value.dependOn : [value.dependOn]),
+				library: value.library
+			};
 		}
+	}
+	return result;
+};
 
-		if (options.experiments.asyncWebAssembly) {
-			const AsyncWebAssemblyModulesPlugin = __webpack_require__(7538);
-			new AsyncWebAssemblyModulesPlugin({
-				mangleImports: options.optimization.mangleWasmImports
-			}).apply(compiler);
-		}
+/**
+ * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
+ * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
+ */
+const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
+	if (runtimeChunk === undefined) return undefined;
+	if (runtimeChunk === false) return false;
+	if (runtimeChunk === "single") {
+		return {
+			name: () => "runtime"
+		};
+	}
+	if (runtimeChunk === true || runtimeChunk === "multiple") {
+		return {
+			name: entrypoint => `runtime~${entrypoint.name}`
+		};
+	}
+	const { name } = runtimeChunk;
+	return {
+		name: typeof name === "function" ? name : () => name
+	};
+};
 
-		if (options.experiments.css) {
-			const CssModulesPlugin = __webpack_require__(47283);
-			new CssModulesPlugin(options.experiments.css).apply(compiler);
-		}
+exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
 
-		if (options.experiments.lazyCompilation) {
-			const LazyCompilationPlugin = __webpack_require__(79040);
-			const lazyOptions =
-				typeof options.experiments.lazyCompilation === "object"
-					? options.experiments.lazyCompilation
-					: null;
-			new LazyCompilationPlugin({
-				backend:
-					typeof lazyOptions.backend === "function"
-						? lazyOptions.backend
-						: __webpack_require__(17781)({
-								...lazyOptions.backend,
-								client:
-									(lazyOptions.backend && lazyOptions.backend.client) ||
-									options.externalsPresets.node ? __webpack_require__.ab + "lazy-compilation-node.js" : __webpack_require__.ab + "lazy-compilation-web.js"
-						  }),
-				entries: !lazyOptions || lazyOptions.entries !== false,
-				imports: !lazyOptions || lazyOptions.imports !== false,
-				test: (lazyOptions && lazyOptions.test) || undefined
-			}).apply(compiler);
-		}
 
-		if (options.experiments.buildHttp) {
-			const HttpUriPlugin = __webpack_require__(42110);
-			const httpOptions = options.experiments.buildHttp;
-			new HttpUriPlugin(httpOptions).apply(compiler);
-		}
+/***/ }),
 
-		new EntryOptionPlugin().apply(compiler);
-		compiler.hooks.entryOption.call(options.context, options.entry);
+/***/ 52801:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-		new RuntimePlugin().apply(compiler);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		new InferAsyncModulesPlugin().apply(compiler);
 
-		new DataUriPlugin().apply(compiler);
-		new FileUriPlugin().apply(compiler);
 
-		new CompatibilityPlugin().apply(compiler);
-		new HarmonyModulesPlugin({
-			topLevelAwait: options.experiments.topLevelAwait
-		}).apply(compiler);
-		if (options.amd !== false) {
-			const AMDPlugin = __webpack_require__(50067);
-			const RequireJsStuffPlugin = __webpack_require__(88846);
-			new AMDPlugin(options.amd || {}).apply(compiler);
-			new RequireJsStuffPlugin().apply(compiler);
-		}
-		new CommonJsPlugin().apply(compiler);
-		new LoaderPlugin({}).apply(compiler);
-		if (options.node !== false) {
-			const NodeStuffPlugin = __webpack_require__(95287);
-			new NodeStuffPlugin(options.node).apply(compiler);
-		}
-		new APIPlugin().apply(compiler);
-		new ExportsInfoApiPlugin().apply(compiler);
-		new WebpackIsIncludedPlugin().apply(compiler);
-		new ConstPlugin().apply(compiler);
-		new UseStrictPlugin().apply(compiler);
-		new RequireIncludePlugin().apply(compiler);
-		new RequireEnsurePlugin().apply(compiler);
-		new RequireContextPlugin().apply(compiler);
-		new ImportPlugin().apply(compiler);
-		new SystemPlugin().apply(compiler);
-		new ImportMetaPlugin().apply(compiler);
-		new URLPlugin().apply(compiler);
-		new WorkerPlugin(
-			options.output.workerChunkLoading,
-			options.output.workerWasmLoading,
-			options.output.module
-		).apply(compiler);
+const memoize = __webpack_require__(78676);
 
-		new DefaultStatsFactoryPlugin().apply(compiler);
-		new DefaultStatsPresetPlugin().apply(compiler);
-		new DefaultStatsPrinterPlugin().apply(compiler);
+const getBrowserslistTargetHandler = memoize(() =>
+	__webpack_require__(43950)
+);
 
-		new JavascriptMetaInfoPlugin().apply(compiler);
+/**
+ * @param {string} context the context directory
+ * @returns {string} default target
+ */
+const getDefaultTarget = context => {
+	const browsers = getBrowserslistTargetHandler().load(null, context);
+	return browsers ? "browserslist" : "web";
+};
 
-		if (typeof options.mode !== "string") {
-			const WarnNoModeSetPlugin = __webpack_require__(25295);
-			new WarnNoModeSetPlugin().apply(compiler);
-		}
+/**
+ * @typedef {Object} PlatformTargetProperties
+ * @property {boolean | null} web web platform, importing of http(s) and std: is available
+ * @property {boolean | null} browser browser platform, running in a normal web browser
+ * @property {boolean | null} webworker (Web)Worker platform, running in a web/shared/service worker
+ * @property {boolean | null} node node platform, require of node built-in modules is available
+ * @property {boolean | null} nwjs nwjs platform, require of legacy nw.gui is available
+ * @property {boolean | null} electron electron platform, require of some electron built-in modules is available
+ */
 
-		const EnsureChunkConditionsPlugin = __webpack_require__(96260);
-		new EnsureChunkConditionsPlugin().apply(compiler);
-		if (options.optimization.removeAvailableModules) {
-			const RemoveParentModulesPlugin = __webpack_require__(7081);
-			new RemoveParentModulesPlugin().apply(compiler);
-		}
-		if (options.optimization.removeEmptyChunks) {
-			const RemoveEmptyChunksPlugin = __webpack_require__(84760);
-			new RemoveEmptyChunksPlugin().apply(compiler);
-		}
-		if (options.optimization.mergeDuplicateChunks) {
-			const MergeDuplicateChunksPlugin = __webpack_require__(85067);
-			new MergeDuplicateChunksPlugin().apply(compiler);
-		}
-		if (options.optimization.flagIncludedChunks) {
-			const FlagIncludedChunksPlugin = __webpack_require__(50089);
-			new FlagIncludedChunksPlugin().apply(compiler);
-		}
-		if (options.optimization.sideEffects) {
-			const SideEffectsFlagPlugin = __webpack_require__(84800);
-			new SideEffectsFlagPlugin(
-				options.optimization.sideEffects === true
-			).apply(compiler);
-		}
-		if (options.optimization.providedExports) {
-			const FlagDependencyExportsPlugin = __webpack_require__(84506);
-			new FlagDependencyExportsPlugin().apply(compiler);
-		}
-		if (options.optimization.usedExports) {
-			const FlagDependencyUsagePlugin = __webpack_require__(58812);
-			new FlagDependencyUsagePlugin(
-				options.optimization.usedExports === "global"
-			).apply(compiler);
-		}
-		if (options.optimization.innerGraph) {
-			const InnerGraphPlugin = __webpack_require__(28758);
-			new InnerGraphPlugin().apply(compiler);
+/**
+ * @typedef {Object} ElectronContextTargetProperties
+ * @property {boolean | null} electronMain in main context
+ * @property {boolean | null} electronPreload in preload context
+ * @property {boolean | null} electronRenderer in renderer context with node integration
+ */
+
+/**
+ * @typedef {Object} ApiTargetProperties
+ * @property {boolean | null} require has require function available
+ * @property {boolean | null} nodeBuiltins has node.js built-in modules available
+ * @property {boolean | null} document has document available (allows script tags)
+ * @property {boolean | null} importScripts has importScripts available
+ * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
+ * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
+ * @property {boolean | null} global has global variable available
+ */
+
+/**
+ * @typedef {Object} EcmaTargetProperties
+ * @property {boolean | null} globalThis has globalThis variable available
+ * @property {boolean | null} bigIntLiteral big int literal syntax is available
+ * @property {boolean | null} const const and let variable declarations are available
+ * @property {boolean | null} arrowFunction arrow functions are available
+ * @property {boolean | null} forOf for of iteration is available
+ * @property {boolean | null} destructuring destructuring is available
+ * @property {boolean | null} dynamicImport async import() is available
+ * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
+ * @property {boolean | null} module ESM syntax is available (when in module)
+ * @property {boolean | null} optionalChaining optional chaining is available
+ * @property {boolean | null} templateLiteral template literal is available
+ */
+
+///** @typedef {PlatformTargetProperties | ApiTargetProperties | EcmaTargetProperties | PlatformTargetProperties & ApiTargetProperties | PlatformTargetProperties & EcmaTargetProperties | ApiTargetProperties & EcmaTargetProperties} TargetProperties */
+/** @template T @typedef {{ [P in keyof T]?: never }} Never<T> */
+/** @template A @template B @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A,B> */
+/** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
+
+const versionDependent = (major, minor) => {
+	if (!major) return () => /** @type {undefined} */ (undefined);
+	major = +major;
+	minor = minor ? +minor : 0;
+	return (vMajor, vMinor = 0) => {
+		return major > vMajor || (major === vMajor && minor >= vMinor);
+	};
+};
+
+/** @type {[string, string, RegExp, (...args: string[]) => TargetProperties | false][]} */
+const TARGETS = [
+	[
+		"browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
+		"Resolve features from browserslist. Will resolve browserslist config automatically. Only browser or node queries are supported (electron is not supported). Examples: 'browserslist:modern' to use 'modern' environment from browserslist config",
+		/^browserslist(?::(.+))?$/,
+		(rest, context) => {
+			const browserslistTargetHandler = getBrowserslistTargetHandler();
+			const browsers = browserslistTargetHandler.load(
+				rest ? rest.trim() : null,
+				context
+			);
+			if (!browsers) {
+				throw new Error(`No browserslist config found to handle the 'browserslist' target.
+See https://github.com/browserslist/browserslist#queries for possible ways to provide a config.
+The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
+You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
+			}
+			return browserslistTargetHandler.resolve(browsers);
 		}
-		if (options.optimization.mangleExports) {
-			const MangleExportsPlugin = __webpack_require__(27868);
-			new MangleExportsPlugin(
-				options.optimization.mangleExports !== "size"
-			).apply(compiler);
+	],
+	[
+		"web",
+		"Web browser.",
+		/^web$/,
+		() => {
+			return {
+				web: true,
+				browser: true,
+				webworker: null,
+				node: false,
+				electron: false,
+				nwjs: false,
+
+				document: true,
+				importScriptsInWorker: true,
+				fetchWasm: true,
+				nodeBuiltins: false,
+				importScripts: false,
+				require: false,
+				global: false
+			};
 		}
-		if (options.optimization.concatenateModules) {
-			const ModuleConcatenationPlugin = __webpack_require__(74844);
-			new ModuleConcatenationPlugin().apply(compiler);
+	],
+	[
+		"webworker",
+		"Web Worker, SharedWorker or Service Worker.",
+		/^webworker$/,
+		() => {
+			return {
+				web: true,
+				browser: true,
+				webworker: true,
+				node: false,
+				electron: false,
+				nwjs: false,
+
+				importScripts: true,
+				importScriptsInWorker: true,
+				fetchWasm: true,
+				nodeBuiltins: false,
+				require: false,
+				document: false,
+				global: false
+			};
 		}
-		if (options.optimization.splitChunks) {
-			const SplitChunksPlugin = __webpack_require__(21478);
-			new SplitChunksPlugin(options.optimization.splitChunks).apply(compiler);
+	],
+	[
+		"[async-]node[X[.Y]]",
+		"Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
+		/^(async-)?node(\d+(?:\.(\d+))?)?$/,
+		(asyncFlag, major, minor) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/
+			return {
+				node: true,
+				electron: false,
+				nwjs: false,
+				web: false,
+				webworker: false,
+				browser: false,
+
+				require: !asyncFlag,
+				nodeBuiltins: true,
+				global: true,
+				document: false,
+				fetchWasm: false,
+				importScripts: false,
+				importScriptsInWorker: false,
+
+				globalThis: v(12),
+				const: v(6),
+				templateLiteral: v(4),
+				optionalChaining: v(14),
+				arrowFunction: v(6),
+				forOf: v(5),
+				destructuring: v(6),
+				bigIntLiteral: v(10, 4),
+				dynamicImport: v(12, 17),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(12, 17)
+			};
 		}
-		if (options.optimization.runtimeChunk) {
-			const RuntimeChunkPlugin = __webpack_require__(2837);
-			new RuntimeChunkPlugin(options.optimization.runtimeChunk).apply(compiler);
+	],
+	[
+		"electron[X[.Y]]-main/preload/renderer",
+		"Electron in version X.Y. Script is running in main, preload resp. renderer context.",
+		/^electron(\d+(?:\.(\d+))?)?-(main|preload|renderer)$/,
+		(major, minor, context) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/ + https://github.com/electron/releases
+			return {
+				node: true,
+				electron: true,
+				web: context !== "main",
+				webworker: false,
+				browser: false,
+				nwjs: false,
+
+				electronMain: context === "main",
+				electronPreload: context === "preload",
+				electronRenderer: context === "renderer",
+
+				global: true,
+				nodeBuiltins: true,
+				require: true,
+				document: context === "renderer",
+				fetchWasm: context === "renderer",
+				importScripts: false,
+				importScriptsInWorker: true,
+
+				globalThis: v(5),
+				const: v(1, 1),
+				templateLiteral: v(1, 1),
+				optionalChaining: v(8),
+				arrowFunction: v(1, 1),
+				forOf: v(0, 36),
+				destructuring: v(1, 1),
+				bigIntLiteral: v(4),
+				dynamicImport: v(11),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(11)
+			};
 		}
-		if (!options.optimization.emitOnErrors) {
-			const NoEmitOnErrorsPlugin = __webpack_require__(50169);
-			new NoEmitOnErrorsPlugin().apply(compiler);
+	],
+	[
+		"nwjs[X[.Y]] / node-webkit[X[.Y]]",
+		"NW.js in version X.Y.",
+		/^(?:nwjs|node-webkit)(\d+(?:\.(\d+))?)?$/,
+		(major, minor) => {
+			const v = versionDependent(major, minor);
+			// see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
+			return {
+				node: true,
+				web: true,
+				nwjs: true,
+				webworker: null,
+				browser: false,
+				electron: false,
+
+				global: true,
+				nodeBuiltins: true,
+				document: false,
+				importScriptsInWorker: false,
+				fetchWasm: false,
+				importScripts: false,
+				require: false,
+
+				globalThis: v(0, 43),
+				const: v(0, 15),
+				templateLiteral: v(0, 13),
+				optionalChaining: v(0, 44),
+				arrowFunction: v(0, 15),
+				forOf: v(0, 13),
+				destructuring: v(0, 15),
+				bigIntLiteral: v(0, 32),
+				dynamicImport: v(0, 43),
+				dynamicImportInWorker: major ? false : undefined,
+				module: v(0, 43)
+			};
 		}
-		if (options.optimization.realContentHash) {
-			const RealContentHashPlugin = __webpack_require__(46043);
-			new RealContentHashPlugin({
-				hashFunction: options.output.hashFunction,
-				hashDigest: options.output.hashDigest
-			}).apply(compiler);
+	],
+	[
+		"esX",
+		"EcmaScript in this version. Examples: es2020, es5.",
+		/^es(\d+)$/,
+		version => {
+			let v = +version;
+			if (v < 1000) v = v + 2009;
+			return {
+				const: v >= 2015,
+				templateLiteral: v >= 2015,
+				optionalChaining: v >= 2020,
+				arrowFunction: v >= 2015,
+				forOf: v >= 2015,
+				destructuring: v >= 2015,
+				module: v >= 2015,
+				globalThis: v >= 2020,
+				bigIntLiteral: v >= 2020,
+				dynamicImport: v >= 2020,
+				dynamicImportInWorker: v >= 2020
+			};
 		}
-		if (options.optimization.checkWasmTypes) {
-			const WasmFinalizeExportsPlugin = __webpack_require__(19810);
-			new WasmFinalizeExportsPlugin().apply(compiler);
+	]
+];
+
+/**
+ * @param {string} target the target
+ * @param {string} context the context directory
+ * @returns {TargetProperties} target properties
+ */
+const getTargetProperties = (target, context) => {
+	for (const [, , regExp, handler] of TARGETS) {
+		const match = regExp.exec(target);
+		if (match) {
+			const [, ...args] = match;
+			const result = handler(...args, context);
+			if (result) return result;
 		}
-		const moduleIds = options.optimization.moduleIds;
-		if (moduleIds) {
-			switch (moduleIds) {
-				case "natural": {
-					const NaturalModuleIdsPlugin = __webpack_require__(83366);
-					new NaturalModuleIdsPlugin().apply(compiler);
-					break;
-				}
-				case "named": {
-					const NamedModuleIdsPlugin = __webpack_require__(24339);
-					new NamedModuleIdsPlugin().apply(compiler);
-					break;
-				}
-				case "hashed": {
-					const WarnDeprecatedOptionPlugin = __webpack_require__(76537);
-					const HashedModuleIdsPlugin = __webpack_require__(21825);
-					new WarnDeprecatedOptionPlugin(
-						"optimization.moduleIds",
-						"hashed",
-						"deterministic"
-					).apply(compiler);
-					new HashedModuleIdsPlugin({
-						hashFunction: options.output.hashFunction
-					}).apply(compiler);
-					break;
-				}
-				case "deterministic": {
-					const DeterministicModuleIdsPlugin = __webpack_require__(76692);
-					new DeterministicModuleIdsPlugin().apply(compiler);
-					break;
-				}
-				case "size": {
-					const OccurrenceModuleIdsPlugin = __webpack_require__(35371);
-					new OccurrenceModuleIdsPlugin({
-						prioritiseInitial: true
-					}).apply(compiler);
-					break;
-				}
-				default:
-					throw new Error(
-						`webpack bug: moduleIds: ${moduleIds} is not implemented`
-					);
-			}
+	}
+	throw new Error(
+		`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(
+			([name, description]) => `* ${name}: ${description}`
+		).join("\n")}`
+	);
+};
+
+const mergeTargetProperties = targetProperties => {
+	const keys = new Set();
+	for (const tp of targetProperties) {
+		for (const key of Object.keys(tp)) {
+			keys.add(key);
 		}
-		const chunkIds = options.optimization.chunkIds;
-		if (chunkIds) {
-			switch (chunkIds) {
-				case "natural": {
-					const NaturalChunkIdsPlugin = __webpack_require__(86221);
-					new NaturalChunkIdsPlugin().apply(compiler);
-					break;
-				}
-				case "named": {
-					const NamedChunkIdsPlugin = __webpack_require__(6454);
-					new NamedChunkIdsPlugin().apply(compiler);
-					break;
-				}
-				case "deterministic": {
-					const DeterministicChunkIdsPlugin = __webpack_require__(8747);
-					new DeterministicChunkIdsPlugin().apply(compiler);
-					break;
-				}
-				case "size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
-					new OccurrenceChunkIdsPlugin({
-						prioritiseInitial: true
-					}).apply(compiler);
+	}
+	const result = {};
+	for (const key of keys) {
+		let hasTrue = false;
+		let hasFalse = false;
+		for (const tp of targetProperties) {
+			const value = tp[key];
+			switch (value) {
+				case true:
+					hasTrue = true;
 					break;
-				}
-				case "total-size": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const OccurrenceChunkIdsPlugin = __webpack_require__(51020);
-					new OccurrenceChunkIdsPlugin({
-						prioritiseInitial: false
-					}).apply(compiler);
+				case false:
+					hasFalse = true;
 					break;
-				}
-				default:
-					throw new Error(
-						`webpack bug: chunkIds: ${chunkIds} is not implemented`
-					);
-			}
-		}
-		if (options.optimization.nodeEnv) {
-			const DefinePlugin = __webpack_require__(79065);
-			new DefinePlugin({
-				"process.env.NODE_ENV": JSON.stringify(options.optimization.nodeEnv)
-			}).apply(compiler);
-		}
-		if (options.optimization.minimize) {
-			for (const minimizer of options.optimization.minimizer) {
-				if (typeof minimizer === "function") {
-					minimizer.call(compiler, compiler);
-				} else if (minimizer !== "...") {
-					minimizer.apply(compiler);
-				}
 			}
 		}
+		if (hasTrue || hasFalse)
+			result[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
+	}
+	return /** @type {TargetProperties} */ (result);
+};
 
-		if (options.performance) {
-			const SizeLimitsPlugin = __webpack_require__(32557);
-			new SizeLimitsPlugin(options.performance).apply(compiler);
-		}
+/**
+ * @param {string[]} targets the targets
+ * @param {string} context the context directory
+ * @returns {TargetProperties} target properties
+ */
+const getTargetsProperties = (targets, context) => {
+	return mergeTargetProperties(
+		targets.map(t => getTargetProperties(t, context))
+	);
+};
 
-		new TemplatedPathPlugin().apply(compiler);
+exports.getDefaultTarget = getDefaultTarget;
+exports.getTargetProperties = getTargetProperties;
+exports.getTargetsProperties = getTargetsProperties;
 
-		new RecordIdsPlugin({
-			portableIds: options.optimization.portableRecords
-		}).apply(compiler);
 
-		new WarnCaseSensitiveModulesPlugin().apply(compiler);
+/***/ }),
 
-		const AddManagedPathsPlugin = __webpack_require__(47942);
-		new AddManagedPathsPlugin(
-			options.snapshot.managedPaths,
-			options.snapshot.immutablePaths
-		).apply(compiler);
-
-		if (options.cache && typeof options.cache === "object") {
-			const cacheOptions = options.cache;
-			switch (cacheOptions.type) {
-				case "memory": {
-					if (isFinite(cacheOptions.maxGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryWithGcCachePlugin = __webpack_require__(99334);
-						new MemoryWithGcCachePlugin({
-							maxGenerations: cacheOptions.maxGenerations
-						}).apply(compiler);
-					} else {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryCachePlugin = __webpack_require__(52539);
-						new MemoryCachePlugin().apply(compiler);
-					}
-					if (cacheOptions.cacheUnaffected) {
-						if (!options.experiments.cacheUnaffected) {
-							throw new Error(
-								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
-							);
-						}
-						compiler.moduleMemCaches = new Map();
-					}
-					break;
-				}
-				case "filesystem": {
-					const AddBuildDependenciesPlugin = __webpack_require__(28034);
-					for (const key in cacheOptions.buildDependencies) {
-						const list = cacheOptions.buildDependencies[key];
-						new AddBuildDependenciesPlugin(list).apply(compiler);
-					}
-					if (!isFinite(cacheOptions.maxMemoryGenerations)) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryCachePlugin = __webpack_require__(52539);
-						new MemoryCachePlugin().apply(compiler);
-					} else if (cacheOptions.maxMemoryGenerations !== 0) {
-						//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-						const MemoryWithGcCachePlugin = __webpack_require__(99334);
-						new MemoryWithGcCachePlugin({
-							maxGenerations: cacheOptions.maxMemoryGenerations
-						}).apply(compiler);
-					}
-					if (cacheOptions.memoryCacheUnaffected) {
-						if (!options.experiments.cacheUnaffected) {
-							throw new Error(
-								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
-							);
-						}
-						compiler.moduleMemCaches = new Map();
-					}
-					switch (cacheOptions.store) {
-						case "pack": {
-							const IdleFileCachePlugin = __webpack_require__(71985);
-							const PackFileCacheStrategy = __webpack_require__(86180);
-							new IdleFileCachePlugin(
-								new PackFileCacheStrategy({
-									compiler,
-									fs: compiler.intermediateFileSystem,
-									context: options.context,
-									cacheLocation: cacheOptions.cacheLocation,
-									version: cacheOptions.version,
-									logger: compiler.getInfrastructureLogger(
-										"webpack.cache.PackFileCacheStrategy"
-									),
-									snapshot: options.snapshot,
-									maxAge: cacheOptions.maxAge,
-									profile: cacheOptions.profile,
-									allowCollectingMemory: cacheOptions.allowCollectingMemory,
-									compression: cacheOptions.compression
-								}),
-								cacheOptions.idleTimeout,
-								cacheOptions.idleTimeoutForInitialStore,
-								cacheOptions.idleTimeoutAfterLargeChanges
-							).apply(compiler);
-							break;
-						}
-						default:
-							throw new Error("Unhandled value for cache.store");
-					}
-					break;
-				}
-				default:
-					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
-					throw new Error(`Unknown cache type ${cacheOptions.type}`);
-			}
-		}
-		new ResolverCachePlugin().apply(compiler);
-
-		if (options.ignoreWarnings && options.ignoreWarnings.length > 0) {
-			const IgnoreWarningsPlugin = __webpack_require__(41606);
-			new IgnoreWarningsPlugin(options.ignoreWarnings).apply(compiler);
-		}
-
-		compiler.hooks.afterPlugins.call(compiler);
-		if (!compiler.inputFileSystem) {
-			throw new Error("No input filesystem provided");
-		}
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("normal")
-			.tap("WebpackOptionsApply", resolveOptions => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
-				return resolveOptions;
-			});
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("context")
-			.tap("WebpackOptionsApply", resolveOptions => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
-				resolveOptions.resolveToContext = true;
-				return resolveOptions;
-			});
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("loader")
-			.tap("WebpackOptionsApply", resolveOptions => {
-				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
-				resolveOptions.fileSystem = compiler.inputFileSystem;
-				return resolveOptions;
-			});
-		compiler.hooks.afterResolvers.call(compiler);
-		return options;
-	}
-}
-
-module.exports = WebpackOptionsApply;
-
-
-/***/ }),
-
-/***/ 14452:
+/***/ 64813:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const { applyWebpackOptionsDefaults } = __webpack_require__(92988);
-const { getNormalizedWebpackOptions } = __webpack_require__(26693);
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
 
-class WebpackOptionsDefaulter {
-	process(options) {
-		options = getNormalizedWebpackOptions(options);
-		applyWebpackOptionsDefaults(options);
-		return options;
+/** @typedef {import("./ContainerEntryModule").ExposeOptions} ExposeOptions */
+
+class ContainerEntryDependency extends Dependency {
+	/**
+	 * @param {string} name entry name
+	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
+	 * @param {string} shareScope name of the share scope
+	 */
+	constructor(name, exposes, shareScope) {
+		super();
+		this.name = name;
+		this.exposes = exposes;
+		this.shareScope = shareScope;
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `container-entry-${this.name}`;
+	}
+
+	get type() {
+		return "container entry";
+	}
+
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = WebpackOptionsDefaulter;
+makeSerializable(
+	ContainerEntryDependency,
+	"webpack/lib/container/ContainerEntryDependency"
+);
+
+module.exports = ContainerEntryDependency;
 
 
 /***/ }),
 
-/***/ 98421:
+/***/ 80580:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const mimeTypes = __webpack_require__(78585);
-const path = __webpack_require__(71017);
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
+const { OriginalSource, RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Module = __webpack_require__(73208);
 const RuntimeGlobals = __webpack_require__(16475);
-const createHash = __webpack_require__(49835);
-const { makePathsRelative } = __webpack_require__(82186);
+const Template = __webpack_require__(1626);
+const StaticExportsDependency = __webpack_require__(91418);
+const makeSerializable = __webpack_require__(33032);
+const ContainerExposedDependency = __webpack_require__(72374);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
-/** @typedef {import("../../declarations/WebpackOptions").AssetModuleOutputPath} AssetModuleOutputPath */
-/** @typedef {import("../../declarations/WebpackOptions").RawPublicPath} RawPublicPath */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
-const mergeMaybeArrays = (a, b) => {
-	const set = new Set();
-	if (Array.isArray(a)) for (const item of a) set.add(item);
-	else set.add(a);
-	if (Array.isArray(b)) for (const item of b) set.add(item);
-	else set.add(b);
-	return Array.from(set);
-};
+/**
+ * @typedef {Object} ExposeOptions
+ * @property {string[]} import requests to exposed modules (last one is exported)
+ * @property {string} name custom chunk name for the exposed module
+ */
 
-const mergeAssetInfo = (a, b) => {
-	const result = { ...a, ...b };
-	for (const key of Object.keys(a)) {
-		if (key in b) {
-			if (a[key] === b[key]) continue;
-			switch (key) {
-				case "fullhash":
-				case "chunkhash":
-				case "modulehash":
-				case "contenthash":
-					result[key] = mergeMaybeArrays(a[key], b[key]);
-					break;
-				case "immutable":
-				case "development":
-				case "hotModuleReplacement":
-				case "javascriptModule":
-					result[key] = a[key] || b[key];
-					break;
-				case "related":
-					result[key] = mergeRelatedInfo(a[key], b[key]);
-					break;
-				default:
-					throw new Error(`Can't handle conflicting asset info for ${key}`);
-			}
-		}
+const SOURCE_TYPES = new Set(["javascript"]);
+
+class ContainerEntryModule extends Module {
+	/**
+	 * @param {string} name container entry name
+	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
+	 * @param {string} shareScope name of the share scope
+	 */
+	constructor(name, exposes, shareScope) {
+		super("javascript/dynamic", null);
+		this._name = name;
+		this._exposes = exposes;
+		this._shareScope = shareScope;
 	}
-	return result;
-};
 
-const mergeRelatedInfo = (a, b) => {
-	const result = { ...a, ...b };
-	for (const key of Object.keys(a)) {
-		if (key in b) {
-			if (a[key] === b[key]) continue;
-			result[key] = mergeMaybeArrays(a[key], b[key]);
-		}
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return SOURCE_TYPES;
 	}
-	return result;
-};
 
-const encodeDataUri = (encoding, source) => {
-	let encodedContent;
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `container entry (${this._shareScope}) ${JSON.stringify(
+			this._exposes
+		)}`;
+	}
 
-	switch (encoding) {
-		case "base64": {
-			encodedContent = source.buffer().toString("base64");
-			break;
-		}
-		case false: {
-			const content = source.source();
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `container entry`;
+	}
 
-			if (typeof content !== "string") {
-				encodedContent = content.toString("utf-8");
-			}
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/entry/${
+			this._name
+		}`;
+	}
 
-			encodedContent = encodeURIComponent(encodedContent).replace(
-				/[!'()*]/g,
-				character => "%" + character.codePointAt(0).toString(16)
-			);
-			break;
-		}
-		default:
-			throw new Error(`Unsupported encoding '${encoding}'`);
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		return callback(null, !this.buildMeta);
 	}
 
-	return encodedContent;
-};
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true,
+			topLevelDeclarations: new Set(["moduleMap", "get", "init"])
+		};
+		this.buildMeta.exportsType = "namespace";
 
-const decodeDataUriContent = (encoding, content) => {
-	const isBase64 = encoding === "base64";
-	return isBase64
-		? Buffer.from(content, "base64")
-		: Buffer.from(decodeURIComponent(content), "ascii");
-};
+		this.clearDependenciesAndBlocks();
 
-const JS_TYPES = new Set(["javascript"]);
-const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
+		for (const [name, options] of this._exposes) {
+			const block = new AsyncDependenciesBlock(
+				{
+					name: options.name
+				},
+				{ name },
+				options.import[options.import.length - 1]
+			);
+			let idx = 0;
+			for (const request of options.import) {
+				const dep = new ContainerExposedDependency(name, request);
+				dep.loc = {
+					name,
+					index: idx++
+				};
 
-class AssetGenerator extends Generator {
-	/**
-	 * @param {AssetGeneratorOptions["dataUrl"]=} dataUrlOptions the options for the data url
-	 * @param {string=} filename override for output.assetModuleFilename
-	 * @param {RawPublicPath=} publicPath override for output.assetModulePublicPath
-	 * @param {AssetModuleOutputPath=} outputPath the output path for the emitted file which is not included in the runtime import
-	 * @param {boolean=} emit generate output asset
-	 */
-	constructor(dataUrlOptions, filename, publicPath, outputPath, emit) {
-		super();
-		this.dataUrlOptions = dataUrlOptions;
-		this.filename = filename;
-		this.publicPath = publicPath;
-		this.outputPath = outputPath;
-		this.emit = emit;
+				block.addDependency(dep);
+			}
+			this.addBlock(block);
+		}
+		this.addDependency(new StaticExportsDependency(["get", "init"], false));
+
+		callback();
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	generate(
-		module,
-		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
-	) {
-		switch (type) {
-			case "asset":
-				return module.originalSource();
-			default: {
-				runtimeRequirements.add(RuntimeGlobals.module);
+	codeGeneration({ moduleGraph, chunkGraph, runtimeTemplate }) {
+		const sources = new Map();
+		const runtimeRequirements = new Set([
+			RuntimeGlobals.definePropertyGetters,
+			RuntimeGlobals.hasOwnProperty,
+			RuntimeGlobals.exports
+		]);
+		const getters = [];
 
-				const originalSource = module.originalSource();
-				if (module.buildInfo.dataUrl) {
-					let encodedSource;
-					if (typeof this.dataUrlOptions === "function") {
-						encodedSource = this.dataUrlOptions.call(
-							null,
-							originalSource.source(),
-							{
-								filename: module.matchResource || module.resource,
-								module
-							}
-						);
-					} else {
-						/** @type {string | false | undefined} */
-						let encoding = this.dataUrlOptions.encoding;
-						if (encoding === undefined) {
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.encoding !== undefined
-							) {
-								encoding = module.resourceResolveData.encoding;
-							}
-						}
-						if (encoding === undefined) {
-							encoding = "base64";
-						}
-						let ext;
-						let mimeType = this.dataUrlOptions.mimetype;
-						if (mimeType === undefined) {
-							ext = path.extname(module.nameForCondition());
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.mimetype !== undefined
-							) {
-								mimeType =
-									module.resourceResolveData.mimetype +
-									module.resourceResolveData.parameters;
-							} else if (ext) {
-								mimeType = mimeTypes.lookup(ext);
-							}
-						}
-						if (typeof mimeType !== "string") {
-							throw new Error(
-								"DataUrl can't be generated automatically, " +
-									`because there is no mimetype for "${ext}" in mimetype database. ` +
-									'Either pass a mimetype via "generator.mimetype" or ' +
-									'use type: "asset/resource" to create a resource file instead of a DataUrl'
-							);
-						}
+		for (const block of this.blocks) {
+			const { dependencies } = block;
 
-						let encodedContent;
+			const modules = dependencies.map(dependency => {
+				const dep = /** @type {ContainerExposedDependency} */ (dependency);
+				return {
+					name: dep.exposedName,
+					module: moduleGraph.getModule(dep),
+					request: dep.userRequest
+				};
+			});
 
-						if (
-							module.resourceResolveData &&
-							module.resourceResolveData.encoding === encoding &&
-							decodeDataUriContent(
-								module.resourceResolveData.encoding,
-								module.resourceResolveData.encodedContent
-							).equals(originalSource.buffer())
-						) {
-							encodedContent = module.resourceResolveData.encodedContent;
-						} else {
-							encodedContent = encodeDataUri(encoding, originalSource);
-						}
+			let str;
 
-						encodedSource = `data:${mimeType}${
-							encoding ? `;${encoding}` : ""
-						},${encodedContent}`;
-					}
-					const data = getData();
-					data.set("url", Buffer.from(encodedSource));
-					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
-							encodedSource
-						)};`
-					);
-				} else {
-					const assetModuleFilename =
-						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
-					const hash = createHash(runtimeTemplate.outputOptions.hashFunction);
-					if (runtimeTemplate.outputOptions.hashSalt) {
-						hash.update(runtimeTemplate.outputOptions.hashSalt);
-					}
-					hash.update(originalSource.buffer());
-					const fullHash = /** @type {string} */ (
-						hash.digest(runtimeTemplate.outputOptions.hashDigest)
-					);
-					const contentHash = fullHash.slice(
-						0,
-						runtimeTemplate.outputOptions.hashDigestLength
-					);
-					module.buildInfo.fullContentHash = fullHash;
-					const sourceFilename = makePathsRelative(
-						runtimeTemplate.compilation.compiler.context,
-						module.matchResource || module.resource,
-						runtimeTemplate.compilation.compiler.root
-					).replace(/^\.\//, "");
-					let { path: filename, info: assetInfo } =
-						runtimeTemplate.compilation.getAssetPathWithInfo(
-							assetModuleFilename,
-							{
-								module,
-								runtime,
-								filename: sourceFilename,
-								chunkGraph,
-								contentHash
-							}
-						);
-					let assetPath;
-					if (this.publicPath !== undefined) {
-						const { path, info } =
-							runtimeTemplate.compilation.getAssetPathWithInfo(
-								this.publicPath,
-								{
-									module,
-									runtime,
-									filename: sourceFilename,
-									chunkGraph,
-									contentHash
-								}
-							);
-						assetInfo = mergeAssetInfo(assetInfo, info);
-						assetPath = JSON.stringify(path + filename);
-					} else {
-						runtimeRequirements.add(RuntimeGlobals.publicPath); // add __webpack_require__.p
-						assetPath = runtimeTemplate.concatenation(
-							{ expr: RuntimeGlobals.publicPath },
-							filename
-						);
-					}
-					assetInfo = {
-						sourceFilename,
-						...assetInfo
-					};
-					if (this.outputPath) {
-						const { path: outputPath, info } =
-							runtimeTemplate.compilation.getAssetPathWithInfo(
-								this.outputPath,
-								{
+			if (modules.some(m => !m.module)) {
+				str = runtimeTemplate.throwMissingModuleErrorBlock({
+					request: modules.map(m => m.request).join(", ")
+				});
+			} else {
+				str = `return ${runtimeTemplate.blockPromise({
+					block,
+					message: "",
+					chunkGraph,
+					runtimeRequirements
+				})}.then(${runtimeTemplate.returningFunction(
+					runtimeTemplate.returningFunction(
+						`(${modules
+							.map(({ module, request }) =>
+								runtimeTemplate.moduleRaw({
 									module,
-									runtime,
-									filename: sourceFilename,
 									chunkGraph,
-									contentHash
-								}
-							);
-						assetInfo = mergeAssetInfo(assetInfo, info);
-						filename = path.posix.join(outputPath, filename);
-					}
-					module.buildInfo.filename = filename;
-					module.buildInfo.assetInfo = assetInfo;
-					if (getData) {
-						// Due to code generation caching module.buildInfo.XXX can't used to store such information
-						// It need to be stored in the code generation results instead, where it's cached too
-						// TODO webpack 6 For back-compat reasons we also store in on module.buildInfo
-						const data = getData();
-						data.set("fullContentHash", fullHash);
-						data.set("filename", filename);
-						data.set("assetInfo", assetInfo);
-					}
-
-					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${assetPath};`
-					);
-				}
+									request,
+									weak: false,
+									runtimeRequirements
+								})
+							)
+							.join(", ")})`
+					)
+				)});`;
 			}
-		}
-	}
 
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		if ((module.buildInfo && module.buildInfo.dataUrl) || this.emit === false) {
-			return JS_TYPES;
-		} else {
-			return JS_AND_ASSET_TYPES;
+			getters.push(
+				`${JSON.stringify(modules[0].name)}: ${runtimeTemplate.basicFunction(
+					"",
+					str
+				)}`
+			);
 		}
-	}
-
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		switch (type) {
-			case "asset": {
-				const originalSource = module.originalSource();
-
-				if (!originalSource) {
-					return 0;
-				}
 
-				return originalSource.size();
-			}
-			default:
-				if (module.buildInfo && module.buildInfo.dataUrl) {
-					const originalSource = module.originalSource();
+		const source = Template.asString([
+			`var moduleMap = {`,
+			Template.indent(getters.join(",\n")),
+			"};",
+			`var get = ${runtimeTemplate.basicFunction("module, getScope", [
+				`${RuntimeGlobals.currentRemoteGetScope} = getScope;`,
+				// reusing the getScope variable to avoid creating a new var (and module is also used later)
+				"getScope = (",
+				Template.indent([
+					`${RuntimeGlobals.hasOwnProperty}(moduleMap, module)`,
+					Template.indent([
+						"? moduleMap[module]()",
+						`: Promise.resolve().then(${runtimeTemplate.basicFunction(
+							"",
+							"throw new Error('Module \"' + module + '\" does not exist in container.');"
+						)})`
+					])
+				]),
+				");",
+				`${RuntimeGlobals.currentRemoteGetScope} = undefined;`,
+				"return getScope;"
+			])};`,
+			`var init = ${runtimeTemplate.basicFunction("shareScope, initScope", [
+				`if (!${RuntimeGlobals.shareScopeMap}) return;`,
+				`var name = ${JSON.stringify(this._shareScope)}`,
+				`var oldScope = ${RuntimeGlobals.shareScopeMap}[name];`,
+				`if(oldScope && oldScope !== shareScope) throw new Error("Container initialization failed as it has already been initialized with a different share scope");`,
+				`${RuntimeGlobals.shareScopeMap}[name] = shareScope;`,
+				`return ${RuntimeGlobals.initializeSharing}(name, initScope);`
+			])};`,
+			"",
+			"// This exports getters to disallow modifications",
+			`${RuntimeGlobals.definePropertyGetters}(exports, {`,
+			Template.indent([
+				`get: ${runtimeTemplate.returningFunction("get")},`,
+				`init: ${runtimeTemplate.returningFunction("init")}`
+			]),
+			"});"
+		]);
 
-					if (!originalSource) {
-						return 0;
-					}
+		sources.set(
+			"javascript",
+			this.useSourceMap || this.useSimpleSourceMap
+				? new OriginalSource(source, "webpack/container-entry")
+				: new RawSource(source)
+		);
 
-					// roughly for data url
-					// Example: m.exports="data:image/png;base64,ag82/f+2=="
-					// 4/3 = base64 encoding
-					// 34 = ~ data url header + footer + rounding
-					return originalSource.size() * 1.34 + 36;
-				} else {
-					// it's only estimated so this number is probably fine
-					// Example: m.exports=r.p+"0123456789012345678901.ext"
-					return 42;
-				}
-		}
+		return {
+			sources,
+			runtimeRequirements
+		};
 	}
 
 	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	updateHash(hash, { module }) {
-		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	size(type) {
+		return 42;
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this._name);
+		write(this._exposes);
+		write(this._shareScope);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new ContainerEntryModule(read(), read(), read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-module.exports = AssetGenerator;
+makeSerializable(
+	ContainerEntryModule,
+	"webpack/lib/container/ContainerEntryModule"
+);
+
+module.exports = ContainerEntryModule;
 
 
 /***/ }),
 
-/***/ 16109:
+/***/ 76398:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Yuta Hiroto @hiroppy
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const { cleverMerge } = __webpack_require__(60839);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-
-const getSchema = name => {
-	const { definitions } = __webpack_require__(73342);
-	return {
-		definitions,
-		oneOf: [{ $ref: `#/definitions/${name}` }]
-	};
-};
-
-const generatorValidationOptions = {
-	name: "Asset Modules Plugin",
-	baseDataPath: "generator"
-};
-const validateGeneratorOptions = {
-	asset: createSchemaValidation(
-		__webpack_require__(55125),
-		() => getSchema("AssetGeneratorOptions"),
-		generatorValidationOptions
-	),
-	"asset/resource": createSchemaValidation(
-		__webpack_require__(4405),
-		() => getSchema("AssetResourceGeneratorOptions"),
-		generatorValidationOptions
-	),
-	"asset/inline": createSchemaValidation(
-		__webpack_require__(62368),
-		() => getSchema("AssetInlineGeneratorOptions"),
-		generatorValidationOptions
-	)
-};
-
-const validateParserOptions = createSchemaValidation(
-	__webpack_require__(45020),
-	() => getSchema("AssetParserOptions"),
-	{
-		name: "Asset Modules Plugin",
-		baseDataPath: "parser"
-	}
-);
-
-const getAssetGenerator = memoize(() => __webpack_require__(98421));
-const getAssetParser = memoize(() => __webpack_require__(91112));
-const getAssetSourceParser = memoize(() => __webpack_require__(30953));
-const getAssetSourceGenerator = memoize(() =>
-	__webpack_require__(18749)
-);
+const ModuleFactory = __webpack_require__(51010);
+const ContainerEntryModule = __webpack_require__(80580);
 
-const type = "asset";
-const plugin = "AssetModulesPlugin";
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
 
-class AssetModulesPlugin {
+module.exports = class ContainerEntryModuleFactory extends ModuleFactory {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			plugin,
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.createParser
-					.for("asset")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						parserOptions = cleverMerge(
-							compiler.options.module.parser.asset,
-							parserOptions
-						);
-
-						let dataUrlCondition = parserOptions.dataUrlCondition;
-						if (!dataUrlCondition || typeof dataUrlCondition === "object") {
-							dataUrlCondition = {
-								maxSize: 8096,
-								...dataUrlCondition
-							};
-						}
-
-						const AssetParser = getAssetParser();
-
-						return new AssetParser(dataUrlCondition);
-					});
-				normalModuleFactory.hooks.createParser
-					.for("asset/inline")
-					.tap(plugin, parserOptions => {
-						const AssetParser = getAssetParser();
+	create({ dependencies: [dependency] }, callback) {
+		const dep = /** @type {ContainerEntryDependency} */ (dependency);
+		callback(null, {
+			module: new ContainerEntryModule(dep.name, dep.exposes, dep.shareScope)
+		});
+	}
+};
 
-						return new AssetParser(true);
-					});
-				normalModuleFactory.hooks.createParser
-					.for("asset/resource")
-					.tap(plugin, parserOptions => {
-						const AssetParser = getAssetParser();
 
-						return new AssetParser(false);
-					});
-				normalModuleFactory.hooks.createParser
-					.for("asset/source")
-					.tap(plugin, parserOptions => {
-						const AssetSourceParser = getAssetSourceParser();
+/***/ }),
 
-						return new AssetSourceParser();
-					});
+/***/ 72374:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				for (const type of ["asset", "asset/inline", "asset/resource"]) {
-					normalModuleFactory.hooks.createGenerator
-						.for(type)
-						.tap(plugin, generatorOptions => {
-							validateGeneratorOptions[type](generatorOptions);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+*/
 
-							let dataUrl = undefined;
-							if (type !== "asset/resource") {
-								dataUrl = generatorOptions.dataUrl;
-								if (!dataUrl || typeof dataUrl === "object") {
-									dataUrl = {
-										encoding: undefined,
-										mimetype: undefined,
-										...dataUrl
-									};
-								}
-							}
 
-							let filename = undefined;
-							let publicPath = undefined;
-							let outputPath = undefined;
-							if (type !== "asset/inline") {
-								filename = generatorOptions.filename;
-								publicPath = generatorOptions.publicPath;
-								outputPath = generatorOptions.outputPath;
-							}
 
-							const AssetGenerator = getAssetGenerator();
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-							return new AssetGenerator(
-								dataUrl,
-								filename,
-								publicPath,
-								outputPath,
-								generatorOptions.emit !== false
-							);
-						});
-				}
-				normalModuleFactory.hooks.createGenerator
-					.for("asset/source")
-					.tap(plugin, () => {
-						const AssetSourceGenerator = getAssetSourceGenerator();
+class ContainerExposedDependency extends ModuleDependency {
+	/**
+	 * @param {string} exposedName public name
+	 * @param {string} request request to module
+	 */
+	constructor(exposedName, request) {
+		super(request);
+		this.exposedName = exposedName;
+	}
 
-						return new AssetSourceGenerator();
-					});
+	get type() {
+		return "container exposed";
+	}
 
-				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
-					const { chunkGraph } = compilation;
-					const { chunk, codeGenerationResults } = options;
+	get category() {
+		return "esm";
+	}
 
-					const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
-						chunk,
-						"asset",
-						compareModulesByIdentifier
-					);
-					if (modules) {
-						for (const module of modules) {
-							try {
-								const codeGenResult = codeGenerationResults.get(
-									module,
-									chunk.runtime
-								);
-								result.push({
-									render: () => codeGenResult.sources.get(type),
-									filename:
-										module.buildInfo.filename ||
-										codeGenResult.data.get("filename"),
-									info:
-										module.buildInfo.assetInfo ||
-										codeGenResult.data.get("assetInfo"),
-									auxiliary: true,
-									identifier: `assetModule${chunkGraph.getModuleId(module)}`,
-									hash:
-										module.buildInfo.fullContentHash ||
-										codeGenResult.data.get("fullContentHash")
-								});
-							} catch (e) {
-								e.message += `\nduring rendering of asset ${module.identifier()}`;
-								throw e;
-							}
-						}
-					}
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `exposed dependency ${this.exposedName}=${this.request}`;
+	}
 
-					return result;
-				});
+	serialize(context) {
+		context.write(this.exposedName);
+		super.serialize(context);
+	}
 
-				compilation.hooks.prepareModuleExecution.tap(
-					"AssetModulesPlugin",
-					(options, context) => {
-						const { codeGenerationResult } = options;
-						const source = codeGenerationResult.sources.get("asset");
-						if (source === undefined) return;
-						context.assets.set(codeGenerationResult.data.get("filename"), {
-							source,
-							info: codeGenerationResult.data.get("assetInfo")
-						});
-					}
-				);
-			}
-		);
+	deserialize(context) {
+		this.exposedName = context.read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = AssetModulesPlugin;
+makeSerializable(
+	ContainerExposedDependency,
+	"webpack/lib/container/ContainerExposedDependency"
+);
+
+module.exports = ContainerExposedDependency;
 
 
 /***/ }),
 
-/***/ 91112:
+/***/ 9244:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Yuta Hiroto @hiroppy
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const Parser = __webpack_require__(11715);
+const createSchemaValidation = __webpack_require__(32540);
+const ContainerEntryDependency = __webpack_require__(64813);
+const ContainerEntryModuleFactory = __webpack_require__(76398);
+const ContainerExposedDependency = __webpack_require__(72374);
+const { parseOptions } = __webpack_require__(3083);
 
-/** @typedef {import("../../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("../../declarations/plugins/container/ContainerPlugin").ContainerPluginOptions} ContainerPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
-class AssetParser extends Parser {
-	/**
-	 * @param {AssetParserOptions["dataUrlCondition"] | boolean} dataUrlCondition condition for inlining as DataUrl
-	 */
-	constructor(dataUrlCondition) {
-		super();
-		this.dataUrlCondition = dataUrlCondition;
+const validate = createSchemaValidation(
+	__webpack_require__(9504),
+	() => __webpack_require__(84899),
+	{
+		name: "Container Plugin",
+		baseDataPath: "options"
 	}
+);
+
+const PLUGIN_NAME = "ContainerPlugin";
 
+class ContainerPlugin {
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {ContainerPluginOptions} options options
 	 */
-	parse(source, state) {
-		if (typeof source === "object" && !Buffer.isBuffer(source)) {
-			throw new Error("AssetParser doesn't accept preparsed AST");
-		}
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
+	constructor(options) {
+		validate(options);
 
-		if (typeof this.dataUrlCondition === "function") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {
-				filename: state.module.matchResource || state.module.resource,
-				module: state.module
-			});
-		} else if (typeof this.dataUrlCondition === "boolean") {
-			state.module.buildInfo.dataUrl = this.dataUrlCondition;
-		} else if (
-			this.dataUrlCondition &&
-			typeof this.dataUrlCondition === "object"
-		) {
-			state.module.buildInfo.dataUrl =
-				Buffer.byteLength(source) <= this.dataUrlCondition.maxSize;
-		} else {
-			throw new Error("Unexpected dataUrlCondition type");
-		}
+		this._options = {
+			name: options.name,
+			shareScope: options.shareScope || "default",
+			library: options.library || {
+				type: "var",
+				name: options.name
+			},
+			runtime: options.runtime,
+			filename: options.filename || undefined,
+			exposes: parseOptions(
+				options.exposes,
+				item => ({
+					import: Array.isArray(item) ? item : [item],
+					name: undefined
+				}),
+				item => ({
+					import: Array.isArray(item.import) ? item.import : [item.import],
+					name: item.name || undefined
+				})
+			)
+		};
+	}
 
-		return state;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { name, exposes, shareScope, filename, library, runtime } =
+			this._options;
+
+		compiler.options.output.enabledLibraryTypes.push(library.type);
+
+		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
+			const dep = new ContainerEntryDependency(name, exposes, shareScope);
+			dep.loc = { name };
+			compilation.addEntry(
+				compilation.options.context,
+				dep,
+				{
+					name,
+					filename,
+					runtime,
+					library
+				},
+				error => {
+					if (error) return callback(error);
+					callback();
+				}
+			);
+		});
+
+		compiler.hooks.thisCompilation.tap(
+			PLUGIN_NAME,
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ContainerEntryDependency,
+					new ContainerEntryModuleFactory()
+				);
+
+				compilation.dependencyFactories.set(
+					ContainerExposedDependency,
+					normalModuleFactory
+				);
+			}
+		);
 	}
 }
 
-module.exports = AssetParser;
+module.exports = ContainerPlugin;
 
 
 /***/ }),
 
-/***/ 18749:
+/***/ 95757:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
+const ExternalsPlugin = __webpack_require__(6652);
 const RuntimeGlobals = __webpack_require__(16475);
+const createSchemaValidation = __webpack_require__(32540);
+const FallbackDependency = __webpack_require__(57764);
+const FallbackItemDependency = __webpack_require__(29593);
+const FallbackModuleFactory = __webpack_require__(4112);
+const RemoteModule = __webpack_require__(62916);
+const RemoteRuntimeModule = __webpack_require__(88288);
+const RemoteToExternalDependency = __webpack_require__(14389);
+const { parseOptions } = __webpack_require__(3083);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").ContainerReferencePluginOptions} ContainerReferencePluginOptions */
+/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").RemotesConfig} RemotesConfig */
+/** @typedef {import("../Compiler")} Compiler */
 
-const TYPES = new Set(["javascript"]);
+const validate = createSchemaValidation(
+	__webpack_require__(95122),
+	() =>
+		__webpack_require__(66681),
+	{
+		name: "Container Reference Plugin",
+		baseDataPath: "options"
+	}
+);
 
-class AssetSourceGenerator extends Generator {
+const slashCode = "/".charCodeAt(0);
+
+class ContainerReferencePlugin {
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {ContainerReferencePluginOptions} options options
 	 */
-	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
+	constructor(options) {
+		validate(options);
 
-		const originalSource = module.originalSource();
+		this._remoteType = options.remoteType;
+		this._remotes = parseOptions(
+			options.remotes,
+			item => ({
+				external: Array.isArray(item) ? item : [item],
+				shareScope: options.shareScope || "default"
+			}),
+			item => ({
+				external: Array.isArray(item.external)
+					? item.external
+					: [item.external],
+				shareScope: item.shareScope || options.shareScope || "default"
+			})
+		);
+	}
 
-		if (!originalSource) {
-			return new RawSource("");
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { _remotes: remotes, _remoteType: remoteType } = this;
+
+		/** @type {Record<string, string>} */
+		const remoteExternals = {};
+		for (const [key, config] of remotes) {
+			let i = 0;
+			for (const external of config.external) {
+				if (external.startsWith("internal ")) continue;
+				remoteExternals[
+					`webpack/container/reference/${key}${i ? `/fallback-${i}` : ""}`
+				] = external;
+				i++;
+			}
 		}
 
-		const content = originalSource.source();
+		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
 
-		let encodedSource;
-		if (typeof content === "string") {
-			encodedSource = content;
-		} else {
-			encodedSource = content.toString("utf-8");
-		}
-		return new RawSource(
-			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
+		compiler.hooks.compilation.tap(
+			"ContainerReferencePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RemoteToExternalDependency,
+					normalModuleFactory
+				);
+
+				compilation.dependencyFactories.set(
+					FallbackItemDependency,
+					normalModuleFactory
+				);
+
+				compilation.dependencyFactories.set(
+					FallbackDependency,
+					new FallbackModuleFactory()
+				);
+
+				normalModuleFactory.hooks.factorize.tap(
+					"ContainerReferencePlugin",
+					data => {
+						if (!data.request.includes("!")) {
+							for (const [key, config] of remotes) {
+								if (
+									data.request.startsWith(`${key}`) &&
+									(data.request.length === key.length ||
+										data.request.charCodeAt(key.length) === slashCode)
+								) {
+									return new RemoteModule(
+										data.request,
+										config.external.map((external, i) =>
+											external.startsWith("internal ")
+												? external.slice(9)
+												: `webpack/container/reference/${key}${
+														i ? `/fallback-${i}` : ""
+												  }`
+										),
+										`.${data.request.slice(key.length)}`,
+										config.shareScope
+									);
+								}
+							}
+						}
+					}
+				);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ContainerReferencePlugin", (chunk, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+						set.add(RuntimeGlobals.hasOwnProperty);
+						set.add(RuntimeGlobals.initializeSharing);
+						set.add(RuntimeGlobals.shareScopeMap);
+						compilation.addRuntimeModule(chunk, new RemoteRuntimeModule());
+					});
+			}
 		);
 	}
+}
 
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
+module.exports = ContainerReferencePlugin;
+
+
+/***/ }),
+
+/***/ 57764:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+
+class FallbackDependency extends Dependency {
+	constructor(requests) {
+		super();
+		this.requests = requests;
 	}
 
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
+	getResourceIdentifier() {
+		return `fallback ${this.requests.join(" ")}`;
+	}
 
-		if (!originalSource) {
-			return 0;
-		}
+	get type() {
+		return "fallback";
+	}
 
-		// Example: m.exports="abcd"
-		return originalSource.size() + 12;
+	get category() {
+		return "esm";
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.requests);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new FallbackDependency(read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-module.exports = AssetSourceGenerator;
+makeSerializable(
+	FallbackDependency,
+	"webpack/lib/container/FallbackDependency"
+);
+
+module.exports = FallbackDependency;
 
 
 /***/ }),
 
-/***/ 30953:
+/***/ 29593:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Yuta Hiroto @hiroppy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const Parser = __webpack_require__(11715);
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+class FallbackItemDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
 
-class AssetSourceParser extends Parser {
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (typeof source === "object" && !Buffer.isBuffer(source)) {
-			throw new Error("AssetSourceParser doesn't accept preparsed AST");
-		}
-		const { module } = state;
-		module.buildInfo.strict = true;
-		module.buildMeta.exportsType = "default";
+	get type() {
+		return "fallback item";
+	}
 
-		return state;
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = AssetSourceParser;
+makeSerializable(
+	FallbackItemDependency,
+	"webpack/lib/container/FallbackItemDependency"
+);
+
+module.exports = FallbackItemDependency;
 
 
 /***/ }),
 
-/***/ 19684:
+/***/ 82886:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
@@ -66103,13 +67052,18 @@ module.exports = AssetSourceParser;
 const { RawSource } = __webpack_require__(51255);
 const Module = __webpack_require__(73208);
 const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
 const makeSerializable = __webpack_require__(33032);
+const FallbackItemDependency = __webpack_require__(29593);
 
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
@@ -66118,50 +67072,50 @@ const makeSerializable = __webpack_require__(33032);
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 
-class RawDataUrlModule extends Module {
+class FallbackModule extends Module {
 	/**
-	 * @param {string} url raw url
-	 * @param {string} identifier unique identifier
-	 * @param {string=} readableIdentifier readable identifier
+	 * @param {string[]} requests list of requests to choose one
 	 */
-	constructor(url, identifier, readableIdentifier) {
-		super("asset/raw-data-url", null);
-		this.url = url;
-		this.urlBuffer = url ? Buffer.from(url) : undefined;
-		this.identifierStr = identifier || this.url;
-		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
+	constructor(requests) {
+		super("fallback-module");
+		this.requests = requests;
+		this._identifier = `fallback ${this.requests.join(" ")}`;
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {string} a unique identifier of the module
 	 */
-	getSourceTypes() {
-		return TYPES;
+	identifier() {
+		return this._identifier;
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	identifier() {
-		return this.identifierStr;
+	readableIdentifier(requestShortener) {
+		return this._identifier;
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	size(type) {
-		if (this.url === undefined) this.url = this.urlBuffer.toString();
-		return Math.max(1, this.url.length);
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/fallback/${
+			this.requests[0]
+		}/and ${this.requests.length - 1} more`;
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {Chunk} chunk the chunk which condition should be checked
+	 * @param {Compilation} compilation the compilation
+	 * @returns {boolean} true, if the chunk is ok for the module
 	 */
-	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.readableIdentifierStr);
+	chunkCondition(chunk, { chunkGraph }) {
+		return chunkGraph.getNumberOfEntryModules(chunk) > 0;
 	}
 
 	/**
@@ -66170,7 +67124,7 @@ class RawDataUrlModule extends Module {
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
+		callback(null, !this.buildInfo);
 	}
 
 	/**
@@ -66184,1618 +67138,1395 @@ class RawDataUrlModule extends Module {
 	build(options, compilation, resolver, fs, callback) {
 		this.buildMeta = {};
 		this.buildInfo = {
-			cacheable: true
+			strict: true
 		};
+
+		this.clearDependenciesAndBlocks();
+		for (const request of this.requests)
+			this.addDependency(new FallbackItemDependency(request));
+
 		callback();
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	codeGeneration(context) {
-		if (this.url === undefined) this.url = this.urlBuffer.toString();
-		const sources = new Map();
-		sources.set(
-			"javascript",
-			new RawSource(`module.exports = ${JSON.stringify(this.url)};`)
-		);
-		const data = new Map();
-		data.set("url", this.urlBuffer);
-		const runtimeRequirements = new Set();
-		runtimeRequirements.add(RuntimeGlobals.module);
-		return { sources, runtimeRequirements, data };
+	size(type) {
+		return this.requests.length * 5 + 42;
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	updateHash(hash, context) {
-		hash.update(this.urlBuffer);
-		super.updateHash(hash, context);
+	getSourceTypes() {
+		return TYPES;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const ids = this.dependencies.map(dep =>
+			chunkGraph.getModuleId(moduleGraph.getModule(dep))
+		);
+		const code = Template.asString([
+			`var ids = ${JSON.stringify(ids)};`,
+			"var error, result, i = 0;",
+			`var loop = ${runtimeTemplate.basicFunction("next", [
+				"while(i < ids.length) {",
+				Template.indent([
+					"try { next = __webpack_require__(ids[i++]); } catch(e) { return handleError(e); }",
+					"if(next) return next.then ? next.then(handleResult, handleError) : handleResult(next);"
+				]),
+				"}",
+				"if(error) throw error;"
+			])}`,
+			`var handleResult = ${runtimeTemplate.basicFunction("result", [
+				"if(result) return result;",
+				"return loop();"
+			])};`,
+			`var handleError = ${runtimeTemplate.basicFunction("e", [
+				"error = e;",
+				"return loop();"
+			])};`,
+			"module.exports = loop();"
+		]);
+		const sources = new Map();
+		sources.set("javascript", new RawSource(code));
+		return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS };
 	}
 
 	serialize(context) {
 		const { write } = context;
-
-		write(this.urlBuffer);
-		write(this.identifierStr);
-		write(this.readableIdentifierStr);
-
+		write(this.requests);
 		super.serialize(context);
 	}
 
-	deserialize(context) {
+	static deserialize(context) {
 		const { read } = context;
-
-		this.urlBuffer = read();
-		this.identifierStr = read();
-		this.readableIdentifierStr = read();
-
-		super.deserialize(context);
+		const obj = new FallbackModule(read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-makeSerializable(RawDataUrlModule, "webpack/lib/asset/RawDataUrlModule");
+makeSerializable(FallbackModule, "webpack/lib/container/FallbackModule");
 
-module.exports = RawDataUrlModule;
+module.exports = FallbackModule;
 
 
 /***/ }),
 
-/***/ 41153:
+/***/ 4112:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
 */
 
 
 
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-
-/**
- * @typedef {GenerateContext} Context
- */
-class AwaitDependenciesInitFragment extends InitFragment {
-	/**
-	 * @param {Set<string>} promises the promises that should be awaited
-	 */
-	constructor(promises) {
-		super(
-			undefined,
-			InitFragment.STAGE_ASYNC_DEPENDENCIES,
-			0,
-			"await-dependencies"
-		);
-		this.promises = promises;
-	}
+const ModuleFactory = __webpack_require__(51010);
+const FallbackModule = __webpack_require__(82886);
 
-	merge(other) {
-		const promises = new Set(other.promises);
-		for (const p of this.promises) {
-			promises.add(p);
-		}
-		return new AwaitDependenciesInitFragment(promises);
-	}
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./FallbackDependency")} FallbackDependency */
 
+module.exports = class FallbackModuleFactory extends ModuleFactory {
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
 	 */
-	getContent({ runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
-		const promises = this.promises;
-		if (promises.size === 0) {
-			return "";
-		}
-		if (promises.size === 1) {
-			for (const p of promises) {
-				return Template.asString([
-					`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${p}]);`,
-					`${p} = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];`,
-					""
-				]);
-			}
-		}
-		const sepPromises = Array.from(promises).join(", ");
-		// TODO check if destructuring is supported
-		return Template.asString([
-			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${sepPromises}]);`,
-			`([${sepPromises}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`,
-			""
-		]);
+	create({ dependencies: [dependency] }, callback) {
+		const dep = /** @type {FallbackDependency} */ (dependency);
+		callback(null, {
+			module: new FallbackModule(dep.requests)
+		});
 	}
-}
-
-module.exports = AwaitDependenciesInitFragment;
+};
 
 
 /***/ }),
 
-/***/ 59498:
+/***/ 30569:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const HarmonyImportDependency = __webpack_require__(57154);
+const isValidExternalsType = __webpack_require__(62142);
+const SharePlugin = __webpack_require__(26335);
+const createSchemaValidation = __webpack_require__(32540);
+const ContainerPlugin = __webpack_require__(9244);
+const ContainerReferencePlugin = __webpack_require__(95757);
 
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ExternalsType} ExternalsType */
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ModuleFederationPluginOptions} ModuleFederationPluginOptions */
+/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").Shared} Shared */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 
-class InferAsyncModulesPlugin {
+const validate = createSchemaValidation(
+	__webpack_require__(7467),
+	() => __webpack_require__(82601),
+	{
+		name: "Module Federation Plugin",
+		baseDataPath: "options"
+	}
+);
+class ModuleFederationPlugin {
+	/**
+	 * @param {ModuleFederationPluginOptions} options options
+	 */
+	constructor(options) {
+		validate(options);
+
+		this._options = options;
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("InferAsyncModulesPlugin", compilation => {
-			const { moduleGraph } = compilation;
-			compilation.hooks.finishModules.tap(
-				"InferAsyncModulesPlugin",
-				modules => {
-					/** @type {Set<Module>} */
-					const queue = new Set();
-					for (const module of modules) {
-						if (module.buildMeta && module.buildMeta.async) {
-							queue.add(module);
-						}
-					}
-					for (const module of queue) {
-						moduleGraph.setAsync(module);
-						for (const [
-							originModule,
-							connections
-						] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-							if (
-								connections.some(
-									c =>
-										c.dependency instanceof HarmonyImportDependency &&
-										c.isTargetActive(undefined)
-								)
-							) {
-								queue.add(originModule);
-							}
-						}
-					}
-				}
-			);
+		const { _options: options } = this;
+		const library = options.library || { type: "var", name: options.name };
+		const remoteType =
+			options.remoteType ||
+			(options.library && isValidExternalsType(options.library.type)
+				? /** @type {ExternalsType} */ (options.library.type)
+				: "script");
+		if (
+			library &&
+			!compiler.options.output.enabledLibraryTypes.includes(library.type)
+		) {
+			compiler.options.output.enabledLibraryTypes.push(library.type);
+		}
+		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
+			if (
+				options.exposes &&
+				(Array.isArray(options.exposes)
+					? options.exposes.length > 0
+					: Object.keys(options.exposes).length > 0)
+			) {
+				new ContainerPlugin({
+					name: options.name,
+					library,
+					filename: options.filename,
+					runtime: options.runtime,
+					exposes: options.exposes
+				}).apply(compiler);
+			}
+			if (
+				options.remotes &&
+				(Array.isArray(options.remotes)
+					? options.remotes.length > 0
+					: Object.keys(options.remotes).length > 0)
+			) {
+				new ContainerReferencePlugin({
+					remoteType,
+					remotes: options.remotes
+				}).apply(compiler);
+			}
+			if (options.shared) {
+				new SharePlugin({
+					shared: options.shared,
+					shareScope: options.shareScope
+				}).apply(compiler);
+			}
 		});
 	}
 }
 
-module.exports = InferAsyncModulesPlugin;
+module.exports = ModuleFederationPlugin;
 
 
 /***/ }),
 
-/***/ 79233:
+/***/ 62916:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const AsyncDependencyToInitialChunkError = __webpack_require__(30111);
-const { connectChunkGroupParentAndChild } = __webpack_require__(37234);
-const ModuleGraphConnection = __webpack_require__(40639);
-const { getEntryRuntime, mergeRuntime } = __webpack_require__(17156);
-
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Entrypoint")} Entrypoint */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+const { RawSource } = __webpack_require__(51255);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const FallbackDependency = __webpack_require__(57764);
+const RemoteToExternalDependency = __webpack_require__(14389);
 
-/**
- * @typedef {Object} QueueItem
- * @property {number} action
- * @property {DependenciesBlock} block
- * @property {Module} module
- * @property {Chunk} chunk
- * @property {ChunkGroup} chunkGroup
- * @property {ChunkGroupInfo} chunkGroupInfo
- */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-/** @typedef {Set<Module> & { plus: Set<Module> }} ModuleSetPlus */
+const TYPES = new Set(["remote", "share-init"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 
-/**
- * @typedef {Object} ChunkGroupInfo
- * @property {ChunkGroup} chunkGroup the chunk group
- * @property {RuntimeSpec} runtime the runtimes
- * @property {ModuleSetPlus} minAvailableModules current minimal set of modules available at this point
- * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
- * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
- * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
- * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
- * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
- * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
- * @property {Set<ChunkGroupInfo>} availableChildren set of chunk groups which depend on the this chunk group as availableSource
- * @property {number} preOrderIndex next pre order index
- * @property {number} postOrderIndex next post order index
- * @property {boolean} chunkLoading has a chunk loading mechanism
- * @property {boolean} asyncChunks create async chunks
- */
+class RemoteModule extends Module {
+	/**
+	 * @param {string} request request string
+	 * @param {string[]} externalRequests list of external requests to containers
+	 * @param {string} internalRequest name of exposed module in container
+	 * @param {string} shareScope the used share scope name
+	 */
+	constructor(request, externalRequests, internalRequest, shareScope) {
+		super("remote-module");
+		this.request = request;
+		this.externalRequests = externalRequests;
+		this.internalRequest = internalRequest;
+		this.shareScope = shareScope;
+		this._identifier = `remote (${shareScope}) ${this.externalRequests.join(
+			" "
+		)} ${this.internalRequest}`;
+	}
 
-/**
- * @typedef {Object} BlockChunkGroupConnection
- * @property {ChunkGroupInfo} originChunkGroupInfo origin chunk group
- * @property {ChunkGroup} chunkGroup referenced chunk group
- */
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return this._identifier;
+	}
 
-const EMPTY_SET = /** @type {ModuleSetPlus} */ (new Set());
-EMPTY_SET.plus = EMPTY_SET;
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `remote ${this.request}`;
+	}
 
-/**
- * @param {ModuleSetPlus} a first set
- * @param {ModuleSetPlus} b second set
- * @returns {number} cmp
- */
-const bySetSize = (a, b) => {
-	return b.size + b.plus.size - a.size - a.plus.size;
-};
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/remote/${
+			this.request
+		}`;
+	}
 
-const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
-	let blockCache;
-	let modules;
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
 
-	const arrays = [];
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true
+		};
 
-	const queue = [module];
-	while (queue.length > 0) {
-		const block = queue.pop();
-		const arr = [];
-		arrays.push(arr);
-		blockModulesMap.set(block, arr);
-		for (const b of block.blocks) {
-			queue.push(b);
+		this.clearDependenciesAndBlocks();
+		if (this.externalRequests.length === 1) {
+			this.addDependency(
+				new RemoteToExternalDependency(this.externalRequests[0])
+			);
+		} else {
+			this.addDependency(new FallbackDependency(this.externalRequests));
 		}
+
+		callback();
 	}
 
-	for (const connection of moduleGraph.getOutgoingConnections(module)) {
-		const d = connection.dependency;
-		// We skip connections without dependency
-		if (!d) continue;
-		const m = connection.module;
-		// We skip connections without Module pointer
-		if (!m) continue;
-		// We skip weak connections
-		if (connection.weak) continue;
-		const state = connection.getActiveState(runtime);
-		// We skip inactive connections
-		if (state === false) continue;
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 6;
+	}
 
-		const block = moduleGraph.getParentBlock(d);
-		let index = moduleGraph.getParentBlockIndex(d);
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
 
-		// deprecated fallback
-		if (index < 0) {
-			index = block.dependencies.indexOf(d);
-		}
+	/**
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 */
+	nameForCondition() {
+		return this.request;
+	}
 
-		if (blockCache !== block) {
-			modules = blockModulesMap.get((blockCache = block));
-		}
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const module = moduleGraph.getModule(this.dependencies[0]);
+		const id = module && chunkGraph.getModuleId(module);
+		const sources = new Map();
+		sources.set("remote", new RawSource(""));
+		const data = new Map();
+		data.set("share-init", [
+			{
+				shareScope: this.shareScope,
+				initStage: 20,
+				init: id === undefined ? "" : `initExternal(${JSON.stringify(id)});`
+			}
+		]);
+		return { sources, data, runtimeRequirements: RUNTIME_REQUIREMENTS };
+	}
 
-		const i = index << 2;
-		modules[i] = m;
-		modules[i + 1] = state;
+	serialize(context) {
+		const { write } = context;
+		write(this.request);
+		write(this.externalRequests);
+		write(this.internalRequest);
+		write(this.shareScope);
+		super.serialize(context);
 	}
 
-	for (const modules of arrays) {
-		if (modules.length === 0) continue;
-		let indexMap;
-		let length = 0;
-		outer: for (let j = 0; j < modules.length; j += 2) {
-			const m = modules[j];
-			if (m === undefined) continue;
-			const state = modules[j + 1];
-			if (indexMap === undefined) {
-				let i = 0;
-				for (; i < length; i += 2) {
-					if (modules[i] === m) {
-						const merged = modules[i + 1];
-						if (merged === true) continue outer;
-						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
-							merged,
-							state
-						);
-					}
-				}
-				modules[length] = m;
-				length++;
-				modules[length] = state;
-				length++;
-				if (length > 30) {
-					// To avoid worse case performance, we will use an index map for
-					// linear cost access, which allows to maintain O(n) complexity
-					// while keeping allocations down to a minimum
-					indexMap = new Map();
-					for (let i = 0; i < length; i += 2) {
-						indexMap.set(modules[i], i + 1);
-					}
-				}
-			} else {
-				const idx = indexMap.get(m);
-				if (idx !== undefined) {
-					const merged = modules[idx];
-					if (merged === true) continue outer;
-					modules[idx] = ModuleGraphConnection.addConnectionStates(
-						merged,
-						state
-					);
-				} else {
-					modules[length] = m;
-					length++;
-					modules[length] = state;
-					indexMap.set(m, length);
-					length++;
-				}
-			}
-		}
-		modules.length = length;
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new RemoteModule(read(), read(), read(), read());
+		obj.deserialize(context);
+		return obj;
 	}
-};
+}
 
-/**
- *
- * @param {Logger} logger a logger
- * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Set<ChunkGroup>} allCreatedChunkGroups filled with all chunk groups that are created here
- */
-const visitModules = (
-	logger,
-	compilation,
-	inputEntrypointsAndModules,
-	chunkGroupInfoMap,
-	blockConnections,
-	blocksWithNestedBlocks,
-	allCreatedChunkGroups
-) => {
-	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
+makeSerializable(RemoteModule, "webpack/lib/container/RemoteModule");
 
-	const blockModulesRuntimeMap = new Map();
+module.exports = RemoteModule;
 
-	/** @type {RuntimeSpec | false} */
-	let blockModulesMapRuntime = false;
-	let blockModulesMap;
 
-	/**
-	 *
-	 * @param {DependenciesBlock} block block
-	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+/***/ }),
+
+/***/ 88288:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+/** @typedef {import("./RemoteModule")} RemoteModule */
+
+class RemoteRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("remotes loading");
+	}
+
+	/**
+	 * @returns {string} runtime code
 	 */
-	const getBlockModules = (block, runtime) => {
-		if (blockModulesMapRuntime !== runtime) {
-			blockModulesMap = blockModulesRuntimeMap.get(runtime);
-			if (blockModulesMap === undefined) {
-				blockModulesMap = new Map();
-				blockModulesRuntimeMap.set(runtime, blockModulesMap);
-			}
-		}
-		let blockModules = blockModulesMap.get(block);
-		if (blockModules !== undefined) return blockModules;
-		const module = /** @type {Module} */ (block.getRootBlock());
-		const memCache = moduleMemCaches && moduleMemCaches.get(module);
-		if (memCache !== undefined) {
-			const map = memCache.provide(
-				"bundleChunkGraph.blockModules",
-				runtime,
-				() => {
-					logger.time("visitModules: prepare");
-					const map = new Map();
-					extractBlockModules(module, moduleGraph, runtime, map);
-					logger.timeAggregate("visitModules: prepare");
-					return map;
-				}
+	generate() {
+		const { compilation, chunkGraph } = this;
+		const { runtimeTemplate, moduleGraph } = compilation;
+		const chunkToRemotesMapping = {};
+		const idToExternalAndNameMapping = {};
+		for (const chunk of this.chunk.getAllAsyncChunks()) {
+			const modules = chunkGraph.getChunkModulesIterableBySourceType(
+				chunk,
+				"remote"
 			);
-			for (const [block, blockModules] of map)
-				blockModulesMap.set(block, blockModules);
-			return map.get(block);
-		} else {
-			logger.time("visitModules: prepare");
-			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
-			blockModules = blockModulesMap.get(block);
-			logger.timeAggregate("visitModules: prepare");
-			return blockModules;
+			if (!modules) continue;
+			const remotes = (chunkToRemotesMapping[chunk.id] = []);
+			for (const m of modules) {
+				const module = /** @type {RemoteModule} */ (m);
+				const name = module.internalRequest;
+				const id = chunkGraph.getModuleId(module);
+				const shareScope = module.shareScope;
+				const dep = module.dependencies[0];
+				const externalModule = moduleGraph.getModule(dep);
+				const externalModuleId =
+					externalModule && chunkGraph.getModuleId(externalModule);
+				remotes.push(id);
+				idToExternalAndNameMapping[id] = [shareScope, name, externalModuleId];
+			}
 		}
-	};
+		return Template.asString([
+			`var chunkMapping = ${JSON.stringify(
+				chunkToRemotesMapping,
+				null,
+				"\t"
+			)};`,
+			`var idToExternalAndNameMapping = ${JSON.stringify(
+				idToExternalAndNameMapping,
+				null,
+				"\t"
+			)};`,
+			`${
+				RuntimeGlobals.ensureChunkHandlers
+			}.remotes = ${runtimeTemplate.basicFunction("chunkId, promises", [
+				`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
+				Template.indent([
+					`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction("id", [
+						`var getScope = ${RuntimeGlobals.currentRemoteGetScope};`,
+						"if(!getScope) getScope = [];",
+						"var data = idToExternalAndNameMapping[id];",
+						"if(getScope.indexOf(data) >= 0) return;",
+						"getScope.push(data);",
+						`if(data.p) return promises.push(data.p);`,
+						`var onError = ${runtimeTemplate.basicFunction("error", [
+							'if(!error) error = new Error("Container missing");',
+							'if(typeof error.message === "string")',
+							Template.indent(
+								`error.message += '\\nwhile loading "' + data[1] + '" from ' + data[2];`
+							),
+							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction("", [
+								"throw error;"
+							])}`,
+							"data.p = 0;"
+						])};`,
+						`var handleFunction = ${runtimeTemplate.basicFunction(
+							"fn, arg1, arg2, d, next, first",
+							[
+								"try {",
+								Template.indent([
+									"var promise = fn(arg1, arg2);",
+									"if(promise && promise.then) {",
+									Template.indent([
+										`var p = promise.then(${runtimeTemplate.returningFunction(
+											"next(result, d)",
+											"result"
+										)}, onError);`,
+										`if(first) promises.push(data.p = p); else return p;`
+									]),
+									"} else {",
+									Template.indent(["return next(promise, d, first);"]),
+									"}"
+								]),
+								"} catch(error) {",
+								Template.indent(["onError(error);"]),
+								"}"
+							]
+						)}`,
+						`var onExternal = ${runtimeTemplate.returningFunction(
+							`external ? handleFunction(${RuntimeGlobals.initializeSharing}, data[0], 0, external, onInitialized, first) : onError()`,
+							"external, _, first"
+						)};`,
+						`var onInitialized = ${runtimeTemplate.returningFunction(
+							`handleFunction(external.get, data[1], getScope, 0, onFactory, first)`,
+							"_, external, first"
+						)};`,
+						`var onFactory = ${runtimeTemplate.basicFunction("factory", [
+							"data.p = 1;",
+							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction(
+								"module",
+								["module.exports = factory();"]
+							)}`
+						])};`,
+						"handleFunction(__webpack_require__, data[2], 0, 0, onExternal, 1);"
+					])});`
+				]),
+				"}"
+			])}`
+		]);
+	}
+}
 
-	let statProcessedQueueItems = 0;
-	let statProcessedBlocks = 0;
-	let statConnectedChunkGroups = 0;
-	let statProcessedChunkGroupsForMerging = 0;
-	let statMergedAvailableModuleSets = 0;
-	let statForkedAvailableModules = 0;
-	let statForkedAvailableModulesCount = 0;
-	let statForkedAvailableModulesCountPlus = 0;
-	let statForkedMergedModulesCount = 0;
-	let statForkedMergedModulesCountPlus = 0;
-	let statForkedResultModulesCount = 0;
-	let statChunkGroupInfoUpdated = 0;
-	let statChildChunkGroupsReconnected = 0;
+module.exports = RemoteRuntimeModule;
 
-	let nextChunkGroupIndex = 0;
-	let nextFreeModulePreOrderIndex = 0;
-	let nextFreeModulePostOrderIndex = 0;
 
-	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
-	const blockChunkGroups = new Map();
+/***/ }),
 
-	/** @type {Map<string, ChunkGroupInfo>} */
-	const namedChunkGroups = new Map();
+/***/ 14389:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/** @type {Map<string, ChunkGroupInfo>} */
-	const namedAsyncEntrypoints = new Map();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	const ADD_AND_ENTER_ENTRY_MODULE = 0;
-	const ADD_AND_ENTER_MODULE = 1;
-	const ENTER_MODULE = 2;
-	const PROCESS_BLOCK = 3;
-	const PROCESS_ENTRY_BLOCK = 4;
-	const LEAVE_MODULE = 5;
 
-	/** @type {QueueItem[]} */
-	let queue = [];
 
-	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
-	const queueConnect = new Map();
-	/** @type {Set<ChunkGroupInfo>} */
-	const chunkGroupsForCombining = new Set();
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-	// Fill queue with entrypoint modules
-	// Create ChunkGroupInfo for entrypoints
-	for (const [chunkGroup, modules] of inputEntrypointsAndModules) {
-		const runtime = getEntryRuntime(
-			compilation,
-			chunkGroup.name,
-			chunkGroup.options
-		);
-		/** @type {ChunkGroupInfo} */
-		const chunkGroupInfo = {
-			chunkGroup,
-			runtime,
-			minAvailableModules: undefined,
-			minAvailableModulesOwned: false,
-			availableModulesToBeMerged: [],
-			skippedItems: undefined,
-			resultingAvailableModules: undefined,
-			children: undefined,
-			availableSources: undefined,
-			availableChildren: undefined,
-			preOrderIndex: 0,
-			postOrderIndex: 0,
-			chunkLoading:
-				chunkGroup.options.chunkLoading !== undefined
-					? chunkGroup.options.chunkLoading !== false
-					: compilation.outputOptions.chunkLoading !== false,
-			asyncChunks:
-				chunkGroup.options.asyncChunks !== undefined
-					? chunkGroup.options.asyncChunks
-					: compilation.outputOptions.asyncChunks !== false
-		};
-		chunkGroup.index = nextChunkGroupIndex++;
-		if (chunkGroup.getNumberOfParents() > 0) {
-			// minAvailableModules for child entrypoints are unknown yet, set to undefined.
-			// This means no module is added until other sets are merged into
-			// this minAvailableModules (by the parent entrypoints)
-			const skippedItems = new Set();
-			for (const module of modules) {
-				skippedItems.add(module);
-			}
-			chunkGroupInfo.skippedItems = skippedItems;
-			chunkGroupsForCombining.add(chunkGroupInfo);
-		} else {
-			// The application may start here: We start with an empty list of available modules
-			chunkGroupInfo.minAvailableModules = EMPTY_SET;
-			const chunk = chunkGroup.getEntrypointChunk();
-			for (const module of modules) {
-				queue.push({
-					action: ADD_AND_ENTER_MODULE,
-					block: module,
-					module,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			}
-		}
-		chunkGroupInfoMap.set(chunkGroup, chunkGroupInfo);
-		if (chunkGroup.name) {
-			namedChunkGroups.set(chunkGroup.name, chunkGroupInfo);
-		}
+class RemoteToExternalDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
-	// Fill availableSources with parent-child dependencies between entrypoints
-	for (const chunkGroupInfo of chunkGroupsForCombining) {
-		const { chunkGroup } = chunkGroupInfo;
-		chunkGroupInfo.availableSources = new Set();
-		for (const parent of chunkGroup.parentsIterable) {
-			const parentChunkGroupInfo = chunkGroupInfoMap.get(parent);
-			chunkGroupInfo.availableSources.add(parentChunkGroupInfo);
-			if (parentChunkGroupInfo.availableChildren === undefined) {
-				parentChunkGroupInfo.availableChildren = new Set();
-			}
-			parentChunkGroupInfo.availableChildren.add(chunkGroupInfo);
-		}
+
+	get type() {
+		return "remote to external";
 	}
-	// pop() is used to read from the queue
-	// so it need to be reversed to be iterated in
-	// correct order
-	queue.reverse();
 
-	/** @type {Set<ChunkGroupInfo>} */
-	const outdatedChunkGroupInfo = new Set();
-	/** @type {Set<ChunkGroupInfo>} */
-	const chunkGroupsForMerging = new Set();
-	/** @type {QueueItem[]} */
-	let queueDelayed = [];
+	get category() {
+		return "esm";
+	}
+}
 
-	/** @type {[Module, ConnectionState][]} */
-	const skipConnectionBuffer = [];
-	/** @type {Module[]} */
-	const skipBuffer = [];
-	/** @type {QueueItem[]} */
-	const queueBuffer = [];
+makeSerializable(
+	RemoteToExternalDependency,
+	"webpack/lib/container/RemoteToExternalDependency"
+);
 
-	/** @type {Module} */
-	let module;
-	/** @type {Chunk} */
-	let chunk;
-	/** @type {ChunkGroup} */
-	let chunkGroup;
-	/** @type {DependenciesBlock} */
-	let block;
-	/** @type {ChunkGroupInfo} */
-	let chunkGroupInfo;
+module.exports = RemoteToExternalDependency;
 
-	// For each async Block in graph
-	/**
-	 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
-	 * @returns {void}
-	 */
-	const iteratorBlock = b => {
-		// 1. We create a chunk group with single chunk in it for this Block
-		// but only once (blockChunkGroups map)
-		let cgi = blockChunkGroups.get(b);
-		/** @type {ChunkGroup} */
-		let c;
-		/** @type {Entrypoint} */
-		let entrypoint;
-		const entryOptions = b.groupOptions && b.groupOptions.entryOptions;
-		if (cgi === undefined) {
-			const chunkName = (b.groupOptions && b.groupOptions.name) || b.chunkName;
-			if (entryOptions) {
-				cgi = namedAsyncEntrypoints.get(chunkName);
-				if (!cgi) {
-					entrypoint = compilation.addAsyncEntrypoint(
-						entryOptions,
-						module,
-						b.loc,
-						b.request
-					);
-					entrypoint.index = nextChunkGroupIndex++;
-					cgi = {
-						chunkGroup: entrypoint,
-						runtime: entrypoint.options.runtime || entrypoint.name,
-						minAvailableModules: EMPTY_SET,
-						minAvailableModulesOwned: false,
-						availableModulesToBeMerged: [],
-						skippedItems: undefined,
-						resultingAvailableModules: undefined,
-						children: undefined,
-						availableSources: undefined,
-						availableChildren: undefined,
-						preOrderIndex: 0,
-						postOrderIndex: 0,
-						chunkLoading:
-							entryOptions.chunkLoading !== undefined
-								? entryOptions.chunkLoading !== false
-								: chunkGroupInfo.chunkLoading,
-						asyncChunks:
-							entryOptions.asyncChunks !== undefined
-								? entryOptions.asyncChunks
-								: chunkGroupInfo.asyncChunks
-					};
-					chunkGroupInfoMap.set(entrypoint, cgi);
 
-					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
-					if (chunkName) {
-						namedAsyncEntrypoints.set(chunkName, cgi);
-					}
-				} else {
-					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// TODO merge entryOptions
-					entrypoint.addOrigin(module, b.loc, b.request);
-					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
-				}
+/***/ }),
 
-				// 2. We enqueue the DependenciesBlock for traversal
-				queueDelayed.push({
-					action: PROCESS_ENTRY_BLOCK,
-					block: b,
-					module: module,
-					chunk: entrypoint.chunks[0],
-					chunkGroup: entrypoint,
-					chunkGroupInfo: cgi
-				});
-			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
-				// Just queue the block into the current chunk group
-				queue.push({
-					action: PROCESS_BLOCK,
-					block: b,
-					module: module,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			} else {
-				cgi = chunkName && namedChunkGroups.get(chunkName);
-				if (!cgi) {
-					c = compilation.addChunkInGroup(
-						b.groupOptions || b.chunkName,
-						module,
-						b.loc,
-						b.request
-					);
-					c.index = nextChunkGroupIndex++;
-					cgi = {
-						chunkGroup: c,
-						runtime: chunkGroupInfo.runtime,
-						minAvailableModules: undefined,
-						minAvailableModulesOwned: undefined,
-						availableModulesToBeMerged: [],
-						skippedItems: undefined,
-						resultingAvailableModules: undefined,
-						children: undefined,
-						availableSources: undefined,
-						availableChildren: undefined,
-						preOrderIndex: 0,
-						postOrderIndex: 0,
-						chunkLoading: chunkGroupInfo.chunkLoading,
-						asyncChunks: chunkGroupInfo.asyncChunks
-					};
-					allCreatedChunkGroups.add(c);
-					chunkGroupInfoMap.set(c, cgi);
-					if (chunkName) {
-						namedChunkGroups.set(chunkName, cgi);
-					}
-				} else {
-					c = cgi.chunkGroup;
-					if (c.isInitial()) {
-						compilation.errors.push(
-							new AsyncDependencyToInitialChunkError(chunkName, module, b.loc)
-						);
-						c = chunkGroup;
-					}
-					c.addOptions(b.groupOptions);
-					c.addOrigin(module, b.loc, b.request);
-				}
-				blockConnections.set(b, []);
-			}
-			blockChunkGroups.set(b, cgi);
-		} else if (entryOptions) {
-			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-		} else {
-			c = cgi.chunkGroup;
-		}
+/***/ 3083:
+/***/ (function(__unused_webpack_module, exports) {
 
-		if (c !== undefined) {
-			// 2. We store the connection for the block
-			// to connect it later if needed
-			blockConnections.get(b).push({
-				originChunkGroupInfo: chunkGroupInfo,
-				chunkGroup: c
-			});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			// 3. We enqueue the chunk group info creation/updating
-			let connectList = queueConnect.get(chunkGroupInfo);
-			if (connectList === undefined) {
-				connectList = new Set();
-				queueConnect.set(chunkGroupInfo, connectList);
-			}
-			connectList.add(cgi);
 
-			// TODO check if this really need to be done for each traversal
-			// or if it is enough when it's queued when created
-			// 4. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module: module,
-				chunk: c.chunks[0],
-				chunkGroup: c,
-				chunkGroupInfo: cgi
-			});
-		} else if (entrypoint !== undefined) {
-			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
-		}
-	};
 
-	/**
-	 * @param {DependenciesBlock} block the block
-	 * @returns {void}
-	 */
-	const processBlock = block => {
-		statProcessedBlocks++;
-		// get prepared block info
-		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
+/** @template T @typedef {(string | Record<string, string | string[] | T>)[] | Record<string, string | string[] | T>} ContainerOptionsFormat */
 
-		if (blockModules !== undefined) {
-			const { minAvailableModules } = chunkGroupInfo;
-			// Buffer items because order need to be reversed to get indices correct
-			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
-					// skip early if already connected
-					continue;
-				}
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
-				);
-				if (activeState !== true) {
-					skipConnectionBuffer.push([refModule, activeState]);
-					if (activeState === false) continue;
-				}
-				if (
-					activeState === true &&
-					(minAvailableModules.has(refModule) ||
-						minAvailableModules.plus.has(refModule))
-				) {
-					// already in parent chunks, skip it for now
-					skipBuffer.push(refModule);
-					continue;
-				}
-				// enqueue, then add and enter to be in the correct order
-				// this is relevant with circular dependencies
-				queueBuffer.push({
-					action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
-					block: refModule,
-					module: refModule,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
-			}
-			// Add buffered items in reverse order
-			if (skipConnectionBuffer.length > 0) {
-				let { skippedModuleConnections } = chunkGroupInfo;
-				if (skippedModuleConnections === undefined) {
-					chunkGroupInfo.skippedModuleConnections = skippedModuleConnections =
-						new Set();
-				}
-				for (let i = skipConnectionBuffer.length - 1; i >= 0; i--) {
-					skippedModuleConnections.add(skipConnectionBuffer[i]);
-				}
-				skipConnectionBuffer.length = 0;
-			}
-			if (skipBuffer.length > 0) {
-				let { skippedItems } = chunkGroupInfo;
-				if (skippedItems === undefined) {
-					chunkGroupInfo.skippedItems = skippedItems = new Set();
-				}
-				for (let i = skipBuffer.length - 1; i >= 0; i--) {
-					skippedItems.add(skipBuffer[i]);
-				}
-				skipBuffer.length = 0;
+/**
+ * @template T
+ * @template N
+ * @param {ContainerOptionsFormat<T>} options options passed by the user
+ * @param {function(string | string[], string) : N} normalizeSimple normalize a simple item
+ * @param {function(T, string) : N} normalizeOptions normalize a complex item
+ * @param {function(string, N): void} fn processing function
+ * @returns {void}
+ */
+const process = (options, normalizeSimple, normalizeOptions, fn) => {
+	const array = items => {
+		for (const item of items) {
+			if (typeof item === "string") {
+				fn(item, normalizeSimple(item, item));
+			} else if (item && typeof item === "object") {
+				object(item);
+			} else {
+				throw new Error("Unexpected options format");
 			}
-			if (queueBuffer.length > 0) {
-				for (let i = queueBuffer.length - 1; i >= 0; i--) {
-					queue.push(queueBuffer[i]);
-				}
-				queueBuffer.length = 0;
+		}
+	};
+	const object = obj => {
+		for (const [key, value] of Object.entries(obj)) {
+			if (typeof value === "string" || Array.isArray(value)) {
+				fn(key, normalizeSimple(value, key));
+			} else {
+				fn(key, normalizeOptions(value, key));
 			}
 		}
+	};
+	if (!options) {
+		return;
+	} else if (Array.isArray(options)) {
+		array(options);
+	} else if (typeof options === "object") {
+		object(options);
+	} else {
+		throw new Error("Unexpected options format");
+	}
+};
 
-		// Traverse all Blocks
-		for (const b of block.blocks) {
-			iteratorBlock(b);
-		}
+/**
+ * @template T
+ * @template R
+ * @param {ContainerOptionsFormat<T>} options options passed by the user
+ * @param {function(string | string[], string) : R} normalizeSimple normalize a simple item
+ * @param {function(T, string) : R} normalizeOptions normalize a complex item
+ * @returns {[string, R][]} parsed options
+ */
+const parseOptions = (options, normalizeSimple, normalizeOptions) => {
+	/** @type {[string, R][]} */
+	const items = [];
+	process(options, normalizeSimple, normalizeOptions, (key, value) => {
+		items.push([key, value]);
+	});
+	return items;
+};
 
-		if (block.blocks.length > 0 && module !== block) {
-			blocksWithNestedBlocks.add(block);
+/**
+ * @template T
+ * @param {string} scope scope name
+ * @param {ContainerOptionsFormat<T>} options options passed by the user
+ * @returns {Record<string, string | string[] | T>} options to spread or pass
+ */
+const scope = (scope, options) => {
+	/** @type {Record<string, string | string[] | T>} */
+	const obj = {};
+	process(
+		options,
+		item => /** @type {string | string[] | T} */ (item),
+		item => /** @type {string | string[] | T} */ (item),
+		(key, value) => {
+			obj[
+				key.startsWith("./") ? `${scope}${key.slice(1)}` : `${scope}/${key}`
+			] = value;
 		}
-	};
+	);
+	return obj;
+};
+
+exports.parseOptions = parseOptions;
+exports.scope = scope;
+
+
+/***/ }),
+
+/***/ 91254:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+
+
+const { ReplaceSource, RawSource, ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/Hash")} Hash */
+
+const TYPES = new Set(["javascript"]);
+
+class CssExportsGenerator extends Generator {
+	constructor() {
+		super();
+	}
+
+	// TODO add getConcatenationBailoutReason to allow concatenation
+	// but how to make it have a module id
 
 	/**
-	 * @param {DependenciesBlock} block the block
-	 * @returns {void}
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	const processEntryBlock = block => {
-		statProcessedBlocks++;
-		// get prepared block info
-		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
+	generate(module, generateContext) {
+		const source = new ReplaceSource(new RawSource(""));
+		const initFragments = [];
+		const cssExports = new Map();
 
-		if (blockModules !== undefined) {
-			// Traverse all referenced modules
-			for (let i = 0; i < blockModules.length; i += 2) {
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
+		generateContext.runtimeRequirements.add(RuntimeGlobals.module);
+
+		const runtimeRequirements = new Set();
+
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
+			initFragments,
+			cssExports
+		};
+
+		const handleDependency = dependency => {
+			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
+				dependency.constructor
+			);
+			const template = generateContext.dependencyTemplates.get(constructor);
+			if (!template) {
+				throw new Error(
+					"No template for dependency: " + dependency.constructor.name
 				);
-				// enqueue, then add and enter to be in the correct order
-				// this is relevant with circular dependencies
-				queueBuffer.push({
-					action:
-						activeState === true ? ADD_AND_ENTER_ENTRY_MODULE : PROCESS_BLOCK,
-					block: refModule,
-					module: refModule,
-					chunk,
-					chunkGroup,
-					chunkGroupInfo
-				});
 			}
-			// Add buffered items in reverse order
-			if (queueBuffer.length > 0) {
-				for (let i = queueBuffer.length - 1; i >= 0; i--) {
-					queue.push(queueBuffer[i]);
+
+			template.apply(dependency, source, templateContext);
+		};
+		module.dependencies.forEach(handleDependency);
+
+		if (generateContext.concatenationScope) {
+			const source = new ConcatSource();
+			const usedIdentifiers = new Set();
+			for (const [k, v] of cssExports) {
+				let identifier = Template.toIdentifier(k);
+				let i = 0;
+				while (usedIdentifiers.has(identifier)) {
+					identifier = Template.toIdentifier(k + i);
 				}
-				queueBuffer.length = 0;
+				usedIdentifiers.add(identifier);
+				generateContext.concatenationScope.registerExport(k, identifier);
+				source.add(
+					`${
+						generateContext.runtimeTemplate.supportsConst ? "const" : "var"
+					} ${identifier} = ${JSON.stringify(v)};\n`
+				);
+			}
+			return source;
+		} else {
+			const otherUsed =
+				generateContext.moduleGraph
+					.getExportsInfo(module)
+					.otherExportsInfo.getUsed(generateContext.runtime) !==
+				UsageState.Unused;
+			if (otherUsed) {
+				generateContext.runtimeRequirements.add(
+					RuntimeGlobals.makeNamespaceObject
+				);
 			}
+			return new RawSource(
+				`${otherUsed ? `${RuntimeGlobals.makeNamespaceObject}(` : ""}${
+					module.moduleArgument
+				}.exports = {\n${Array.from(
+					cssExports,
+					([k, v]) => `\t${JSON.stringify(k)}: ${JSON.stringify(v)}`
+				).join(",\n")}\n}${otherUsed ? ")" : ""};`
+			);
 		}
+	}
 
-		// Traverse all Blocks
-		for (const b of block.blocks) {
-			iteratorBlock(b);
-		}
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
 
-		if (block.blocks.length > 0 && module !== block) {
-			blocksWithNestedBlocks.add(block);
-		}
-	};
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 42;
+	}
 
-	const processQueue = () => {
-		while (queue.length) {
-			statProcessedQueueItems++;
-			const queueItem = queue.pop();
-			module = queueItem.module;
-			block = queueItem.block;
-			chunk = queueItem.chunk;
-			chunkGroup = queueItem.chunkGroup;
-			chunkGroupInfo = queueItem.chunkGroupInfo;
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {}
+}
 
-			switch (queueItem.action) {
-				case ADD_AND_ENTER_ENTRY_MODULE:
-					chunkGraph.connectChunkAndEntryModule(
-						chunk,
-						module,
-						/** @type {Entrypoint} */ (chunkGroup)
-					);
-				// fallthrough
-				case ADD_AND_ENTER_MODULE: {
-					if (chunkGraph.isModuleInChunk(module, chunk)) {
-						// already connected, skip it
-						break;
-					}
-					// We connect Module and Chunk
-					chunkGraph.connectChunkAndModule(chunk, module);
-				}
-				// fallthrough
-				case ENTER_MODULE: {
-					const index = chunkGroup.getModulePreOrderIndex(module);
-					if (index === undefined) {
-						chunkGroup.setModulePreOrderIndex(
-							module,
-							chunkGroupInfo.preOrderIndex++
-						);
-					}
+module.exports = CssExportsGenerator;
 
-					if (
-						moduleGraph.setPreOrderIndexIfUnset(
-							module,
-							nextFreeModulePreOrderIndex
-						)
-					) {
-						nextFreeModulePreOrderIndex++;
-					}
 
-					// reuse queueItem
-					queueItem.action = LEAVE_MODULE;
-					queue.push(queueItem);
-				}
-				// fallthrough
-				case PROCESS_BLOCK: {
-					processBlock(block);
-					break;
-				}
-				case PROCESS_ENTRY_BLOCK: {
-					processEntryBlock(block);
-					break;
-				}
-				case LEAVE_MODULE: {
-					const index = chunkGroup.getModulePostOrderIndex(module);
-					if (index === undefined) {
-						chunkGroup.setModulePostOrderIndex(
-							module,
-							chunkGroupInfo.postOrderIndex++
-						);
-					}
+/***/ }),
 
-					if (
-						moduleGraph.setPostOrderIndexIfUnset(
-							module,
-							nextFreeModulePostOrderIndex
-						)
-					) {
-						nextFreeModulePostOrderIndex++;
-					}
-					break;
-				}
-			}
-		}
-	};
+/***/ 46061:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	const calculateResultingAvailableModules = chunkGroupInfo => {
-		if (chunkGroupInfo.resultingAvailableModules)
-			return chunkGroupInfo.resultingAvailableModules;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
 
-		const minAvailableModules = chunkGroupInfo.minAvailableModules;
 
-		// Create a new Set of available modules at this point
-		// We want to be as lazy as possible. There are multiple ways doing this:
-		// Note that resultingAvailableModules is stored as "(a) + (b)" as it's a ModuleSetPlus
-		// - resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-		// - resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-		// We choose one depending on the size of minAvailableModules vs minAvailableModules.plus
 
-		let resultingAvailableModules;
-		if (minAvailableModules.size > minAvailableModules.plus.size) {
-			// resultingAvailableModules = (modules of chunk) + (minAvailableModules + minAvailableModules.plus)
-			resultingAvailableModules =
-				/** @type {Set<Module> & {plus: Set<Module>}} */ (new Set());
-			for (const module of minAvailableModules.plus)
-				minAvailableModules.add(module);
-			minAvailableModules.plus = EMPTY_SET;
-			resultingAvailableModules.plus = minAvailableModules;
-			chunkGroupInfo.minAvailableModulesOwned = false;
-		} else {
-			// resultingAvailableModules = (minAvailableModules + modules of chunk) + (minAvailableModules.plus)
-			resultingAvailableModules =
-				/** @type {Set<Module> & {plus: Set<Module>}} */ (
-					new Set(minAvailableModules)
-				);
-			resultingAvailableModules.plus = minAvailableModules.plus;
-		}
+const { ReplaceSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
 
-		// add the modules from the chunk group to the set
-		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
-			for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-				resultingAvailableModules.add(m);
-			}
-		}
-		return (chunkGroupInfo.resultingAvailableModules =
-			resultingAvailableModules);
-	};
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/Hash")} Hash */
 
-	const processConnectQueue = () => {
-		// Figure out new parents for chunk groups
-		// to get new available modules for these children
-		for (const [chunkGroupInfo, targets] of queueConnect) {
-			// 1. Add new targets to the list of children
-			if (chunkGroupInfo.children === undefined) {
-				chunkGroupInfo.children = targets;
-			} else {
-				for (const target of targets) {
-					chunkGroupInfo.children.add(target);
-				}
-			}
+const TYPES = new Set(["css"]);
 
-			// 2. Calculate resulting available modules
-			const resultingAvailableModules =
-				calculateResultingAvailableModules(chunkGroupInfo);
+class CssGenerator extends Generator {
+	constructor() {
+		super();
+	}
 
-			const runtime = chunkGroupInfo.runtime;
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		const originalSource = module.originalSource();
+		const source = new ReplaceSource(originalSource);
+		const initFragments = [];
+		const cssExports = new Map();
 
-			// 3. Update chunk group info
-			for (const target of targets) {
-				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add(target);
-				const oldRuntime = target.runtime;
-				const newRuntime = mergeRuntime(oldRuntime, runtime);
-				if (oldRuntime !== newRuntime) {
-					target.runtime = newRuntime;
-					outdatedChunkGroupInfo.add(target);
-				}
+		generateContext.runtimeRequirements.add(RuntimeGlobals.hasCssModules);
+
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
+			initFragments,
+			cssExports
+		};
+
+		const handleDependency = dependency => {
+			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
+				dependency.constructor
+			);
+			const template = generateContext.dependencyTemplates.get(constructor);
+			if (!template) {
+				throw new Error(
+					"No template for dependency: " + dependency.constructor.name
+				);
 			}
 
-			statConnectedChunkGroups += targets.size;
+			template.apply(dependency, source, templateContext);
+		};
+		module.dependencies.forEach(handleDependency);
+		if (module.presentationalDependencies !== undefined)
+			module.presentationalDependencies.forEach(handleDependency);
+
+		if (cssExports.size > 0) {
+			const data = generateContext.getData();
+			data.set("css-exports", cssExports);
 		}
-		queueConnect.clear();
-	};
 
-	const processChunkGroupsForMerging = () => {
-		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
+		return InitFragment.addToSource(source, initFragments, generateContext);
+	}
 
-		// Execute the merge
-		for (const info of chunkGroupsForMerging) {
-			const availableModulesToBeMerged = info.availableModulesToBeMerged;
-			let cachedMinAvailableModules = info.minAvailableModules;
-
-			statMergedAvailableModuleSets += availableModulesToBeMerged.length;
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
 
-			// 1. Get minimal available modules
-			// It doesn't make sense to traverse a chunk again with more available modules.
-			// This step calculates the minimal available modules and skips traversal when
-			// the list didn't shrink.
-			if (availableModulesToBeMerged.length > 1) {
-				availableModulesToBeMerged.sort(bySetSize);
-			}
-			let changed = false;
-			merge: for (const availableModules of availableModulesToBeMerged) {
-				if (cachedMinAvailableModules === undefined) {
-					cachedMinAvailableModules = availableModules;
-					info.minAvailableModules = cachedMinAvailableModules;
-					info.minAvailableModulesOwned = false;
-					changed = true;
-				} else {
-					if (info.minAvailableModulesOwned) {
-						// We own it and can modify it
-						if (cachedMinAvailableModules.plus === availableModules.plus) {
-							for (const m of cachedMinAvailableModules) {
-								if (!availableModules.has(m)) {
-									cachedMinAvailableModules.delete(m);
-									changed = true;
-								}
-							}
-						} else {
-							for (const m of cachedMinAvailableModules) {
-								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-									cachedMinAvailableModules.delete(m);
-									changed = true;
-								}
-							}
-							for (const m of cachedMinAvailableModules.plus) {
-								if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-									// We can't remove modules from the plus part
-									// so we need to merge plus into the normal part to allow modifying it
-									const iterator =
-										cachedMinAvailableModules.plus[Symbol.iterator]();
-									// fast forward add all modules until m
-									/** @type {IteratorResult<Module>} */
-									let it;
-									while (!(it = iterator.next()).done) {
-										const module = it.value;
-										if (module === m) break;
-										cachedMinAvailableModules.add(module);
-									}
-									// check the remaining modules before adding
-									while (!(it = iterator.next()).done) {
-										const module = it.value;
-										if (
-											availableModules.has(module) ||
-											availableModules.plus.has(m)
-										) {
-											cachedMinAvailableModules.add(module);
-										}
-									}
-									cachedMinAvailableModules.plus = EMPTY_SET;
-									changed = true;
-									continue merge;
-								}
-							}
-						}
-					} else if (cachedMinAvailableModules.plus === availableModules.plus) {
-						// Common and fast case when the plus part is shared
-						// We only need to care about the normal part
-						if (availableModules.size < cachedMinAvailableModules.size) {
-							// the new availableModules is smaller so it's faster to
-							// fork from the new availableModules
-							statForkedAvailableModules++;
-							statForkedAvailableModulesCount += availableModules.size;
-							statForkedMergedModulesCount += cachedMinAvailableModules.size;
-							// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-							const newSet = /** @type {ModuleSetPlus} */ (new Set());
-							newSet.plus = availableModules.plus;
-							for (const m of availableModules) {
-								if (cachedMinAvailableModules.has(m)) {
-									newSet.add(m);
-								}
-							}
-							statForkedResultModulesCount += newSet.size;
-							cachedMinAvailableModules = newSet;
-							info.minAvailableModulesOwned = true;
-							info.minAvailableModules = newSet;
-							changed = true;
-							continue merge;
-						}
-						for (const m of cachedMinAvailableModules) {
-							if (!availableModules.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedMergedModulesCount += availableModules.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								// as the plus part is equal we can just take over this one
-								const newSet = /** @type {ModuleSetPlus} */ (new Set());
-								newSet.plus = availableModules.plus;
-								const iterator = cachedMinAvailableModules[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (availableModules.has(module)) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-					} else {
-						for (const m of cachedMinAvailableModules) {
-							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedAvailableModulesCountPlus +=
-									cachedMinAvailableModules.plus.size;
-								statForkedMergedModulesCount += availableModules.size;
-								statForkedMergedModulesCountPlus += availableModules.plus.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								const newSet = /** @type {ModuleSetPlus} */ (new Set());
-								newSet.plus = EMPTY_SET;
-								const iterator = cachedMinAvailableModules[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								// also check all modules in cachedMinAvailableModules.plus
-								for (const module of cachedMinAvailableModules.plus) {
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-						for (const m of cachedMinAvailableModules.plus) {
-							if (!availableModules.has(m) && !availableModules.plus.has(m)) {
-								// cachedMinAvailableModules need to be modified
-								// but we don't own it
-								statForkedAvailableModules++;
-								statForkedAvailableModulesCount +=
-									cachedMinAvailableModules.size;
-								statForkedAvailableModulesCountPlus +=
-									cachedMinAvailableModules.plus.size;
-								statForkedMergedModulesCount += availableModules.size;
-								statForkedMergedModulesCountPlus += availableModules.plus.size;
-								// construct a new Set as intersection of cachedMinAvailableModules and availableModules
-								// we already know that all modules directly from cachedMinAvailableModules are in availableModules too
-								const newSet = /** @type {ModuleSetPlus} */ (
-									new Set(cachedMinAvailableModules)
-								);
-								newSet.plus = EMPTY_SET;
-								const iterator =
-									cachedMinAvailableModules.plus[Symbol.iterator]();
-								// fast forward add all modules until m
-								/** @type {IteratorResult<Module>} */
-								let it;
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (module === m) break;
-									newSet.add(module);
-								}
-								// check the remaining modules before adding
-								while (!(it = iterator.next()).done) {
-									const module = it.value;
-									if (
-										availableModules.has(module) ||
-										availableModules.plus.has(module)
-									) {
-										newSet.add(module);
-									}
-								}
-								statForkedResultModulesCount += newSet.size;
-								cachedMinAvailableModules = newSet;
-								info.minAvailableModulesOwned = true;
-								info.minAvailableModules = newSet;
-								changed = true;
-								continue merge;
-							}
-						}
-					}
-				}
-			}
-			availableModulesToBeMerged.length = 0;
-			if (changed) {
-				info.resultingAvailableModules = undefined;
-				outdatedChunkGroupInfo.add(info);
-			}
-		}
-		chunkGroupsForMerging.clear();
-	};
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		const originalSource = module.originalSource();
 
-	const processChunkGroupsForCombining = () => {
-		for (const info of chunkGroupsForCombining) {
-			for (const source of info.availableSources) {
-				if (!source.minAvailableModules) {
-					chunkGroupsForCombining.delete(info);
-					break;
-				}
-			}
-		}
-		for (const info of chunkGroupsForCombining) {
-			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
-			availableModules.plus = EMPTY_SET;
-			const mergeSet = set => {
-				if (set.size > availableModules.plus.size) {
-					for (const item of availableModules.plus) availableModules.add(item);
-					availableModules.plus = set;
-				} else {
-					for (const item of set) availableModules.add(item);
-				}
-			};
-			// combine minAvailableModules from all resultingAvailableModules
-			for (const source of info.availableSources) {
-				const resultingAvailableModules =
-					calculateResultingAvailableModules(source);
-				mergeSet(resultingAvailableModules);
-				mergeSet(resultingAvailableModules.plus);
-			}
-			info.minAvailableModules = availableModules;
-			info.minAvailableModulesOwned = false;
-			info.resultingAvailableModules = undefined;
-			outdatedChunkGroupInfo.add(info);
+		if (!originalSource) {
+			return 0;
 		}
-		chunkGroupsForCombining.clear();
-	};
 
-	const processOutdatedChunkGroupInfo = () => {
-		statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
-		// Revisit skipped elements
-		for (const info of outdatedChunkGroupInfo) {
-			// 1. Reconsider skipped items
-			if (info.skippedItems !== undefined) {
-				const { minAvailableModules } = info;
-				for (const module of info.skippedItems) {
-					if (
-						!minAvailableModules.has(module) &&
-						!minAvailableModules.plus.has(module)
-					) {
-						queue.push({
-							action: ADD_AND_ENTER_MODULE,
-							block: module,
-							module,
-							chunk: info.chunkGroup.chunks[0],
-							chunkGroup: info.chunkGroup,
-							chunkGroupInfo: info
-						});
-						info.skippedItems.delete(module);
-					}
-				}
-			}
+		return originalSource.size();
+	}
 
-			// 2. Reconsider skipped connections
-			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules } = info;
-				for (const entry of info.skippedModuleConnections) {
-					const [module, activeState] = entry;
-					if (activeState === false) continue;
-					if (activeState === true) {
-						info.skippedModuleConnections.delete(entry);
-					}
-					if (
-						activeState === true &&
-						(minAvailableModules.has(module) ||
-							minAvailableModules.plus.has(module))
-					) {
-						info.skippedItems.add(module);
-						continue;
-					}
-					queue.push({
-						action: activeState === true ? ADD_AND_ENTER_MODULE : PROCESS_BLOCK,
-						block: module,
-						module,
-						chunk: info.chunkGroup.chunks[0],
-						chunkGroup: info.chunkGroup,
-						chunkGroupInfo: info
-					});
-				}
-			}
+	/**
+	 * @param {Hash} hash hash that will be modified
+	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 */
+	updateHash(hash, { module }) {}
+}
 
-			// 2. Reconsider children chunk groups
-			if (info.children !== undefined) {
-				statChildChunkGroupsReconnected += info.children.size;
-				for (const cgi of info.children) {
-					let connectList = queueConnect.get(info);
-					if (connectList === undefined) {
-						connectList = new Set();
-						queueConnect.set(info, connectList);
-					}
-					connectList.add(cgi);
-				}
-			}
+module.exports = CssGenerator;
 
-			// 3. Reconsider chunk groups for combining
-			if (info.availableChildren !== undefined) {
-				for (const cgi of info.availableChildren) {
-					chunkGroupsForCombining.add(cgi);
-				}
-			}
-		}
-		outdatedChunkGroupInfo.clear();
-	};
 
-	// Iterative traversal of the Module graph
-	// Recursive would be simpler to write but could result in Stack Overflows
-	while (queue.length || queueConnect.size) {
-		logger.time("visitModules: visiting");
-		processQueue();
-		logger.timeAggregateEnd("visitModules: prepare");
-		logger.timeEnd("visitModules: visiting");
+/***/ }),
 
-		if (chunkGroupsForCombining.size > 0) {
-			logger.time("visitModules: combine available modules");
-			processChunkGroupsForCombining();
-			logger.timeEnd("visitModules: combine available modules");
-		}
+/***/ 80806:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (queueConnect.size > 0) {
-			logger.time("visitModules: calculating available modules");
-			processConnectQueue();
-			logger.timeEnd("visitModules: calculating available modules");
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			if (chunkGroupsForMerging.size > 0) {
-				logger.time("visitModules: merging available modules");
-				processChunkGroupsForMerging();
-				logger.timeEnd("visitModules: merging available modules");
-			}
-		}
 
-		if (outdatedChunkGroupInfo.size > 0) {
-			logger.time("visitModules: check modules for revisit");
-			processOutdatedChunkGroupInfo();
-			logger.timeEnd("visitModules: check modules for revisit");
-		}
 
-		// Run queueDelayed when all items of the queue are processed
-		// This is important to get the global indexing correct
-		// Async blocks should be processed after all sync blocks are processed
-		if (queue.length === 0) {
-			const tempQueue = queue;
-			queue = queueDelayed.reverse();
-			queueDelayed = tempQueue;
-		}
-	}
+const { SyncWaterfallHook } = __webpack_require__(6967);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { chunkHasCss } = __webpack_require__(47283);
 
-	logger.log(
-		`${statProcessedQueueItems} queue items processed (${statProcessedBlocks} blocks)`
-	);
-	logger.log(`${statConnectedChunkGroups} chunk groups connected`);
-	logger.log(
-		`${statProcessedChunkGroupsForMerging} chunk groups processed for merging (${statMergedAvailableModuleSets} module sets, ${statForkedAvailableModules} forked, ${statForkedAvailableModulesCount} + ${statForkedAvailableModulesCountPlus} modules forked, ${statForkedMergedModulesCount} + ${statForkedMergedModulesCountPlus} modules merged into fork, ${statForkedResultModulesCount} resulting modules)`
-	);
-	logger.log(
-		`${statChunkGroupInfoUpdated} chunk group info updated (${statChildChunkGroupsReconnected} already connected chunk groups reconnected)`
-	);
-};
+/** @typedef {import("../Chunk")} Chunk */
 
 /**
- *
- * @param {Compilation} compilation the compilation
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
  */
-const connectChunkGroups = (
-	compilation,
-	blocksWithNestedBlocks,
-	blockConnections,
-	chunkGroupInfoMap
-) => {
-	const { chunkGraph } = compilation;
 
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
+class CssLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * Helper function to check if all modules of a chunk are available
-	 *
-	 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
-	 * @param {ModuleSetPlus} availableModules the comparator set
-	 * @returns {boolean} return true if all modules of a chunk are available
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
 	 */
-	const areModulesAvailable = (chunkGroup, availableModules) => {
-		for (const chunk of chunkGroup.chunks) {
-			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-				if (!availableModules.has(module) && !availableModules.plus.has(module))
-					return false;
-			}
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
 		}
-		return true;
-	};
-
-	// For each edge in the basic chunk graph
-	for (const [block, connections] of blockConnections) {
-		// 1. Check if connection is needed
-		// When none of the dependencies need to be connected
-		// we can skip all of them
-		// It's not possible to filter each item so it doesn't create inconsistent
-		// connections and modules can only create one version
-		// TODO maybe decide this per runtime
-		if (
-			// TODO is this needed?
-			!blocksWithNestedBlocks.has(block) &&
-			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
-				areModulesAvailable(
-					chunkGroup,
-					originChunkGroupInfo.resultingAvailableModules
-				)
-			)
-		) {
-			continue;
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				createStylesheet: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
 		}
+		return hooks;
+	}
 
-		// 2. Foreach edge
-		for (let i = 0; i < connections.length; i++) {
-			const { chunkGroup, originChunkGroupInfo } = connections[i];
-
-			// 3. Connect block with chunk
-			chunkGraph.connectBlockAndChunkGroup(block, chunkGroup);
+	constructor(runtimeRequirements, runtimeOptions) {
+		super("css loading", 10);
 
-			// 4. Connect chunk with parent
-			connectChunkGroupParentAndChild(
-				originChunkGroupInfo.chunkGroup,
-				chunkGroup
-			);
-		}
+		this._runtimeRequirements = runtimeRequirements;
+		this.runtimeOptions = runtimeOptions;
 	}
-};
 
-/**
- * Remove all unconnected chunk groups
- * @param {Compilation} compilation the compilation
- * @param {Iterable<ChunkGroup>} allCreatedChunkGroups all chunk groups that where created before
- */
-const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
-	const { chunkGraph } = compilation;
-
-	for (const chunkGroup of allCreatedChunkGroups) {
-		if (chunkGroup.getNumberOfParents() === 0) {
-			for (const chunk of chunkGroup.chunks) {
-				compilation.chunks.delete(chunk);
-				chunkGraph.disconnectChunk(chunk);
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunk, _runtimeRequirements } = this;
+		const {
+			chunkGraph,
+			runtimeTemplate,
+			outputOptions: {
+				crossOriginLoading,
+				uniqueName,
+				chunkLoadTimeout: loadTimeout
 			}
-			chunkGraph.disconnectChunkGroup(chunkGroup);
-			chunkGroup.remove();
-		}
-	}
-};
-
-/**
- * This method creates the Chunk graph from the Module graph
- * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
- * @returns {void}
- */
-const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
-	const logger = compilation.getLogger("webpack.buildChunkGraph");
-
-	// SHARED STATE
-
-	/** @type {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} */
-	const blockConnections = new Map();
-
-	/** @type {Set<ChunkGroup>} */
-	const allCreatedChunkGroups = new Set();
+		} = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const conditionMap = chunkGraph.getChunkConditionMap(
+			chunk,
+			(chunk, chunkGraph) =>
+				!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css")
+		);
+		const hasCssMatcher = compileBooleanMatcher(conditionMap);
 
-	/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
-	const chunkGroupInfoMap = new Map();
+		const withLoading =
+			_runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
+			hasCssMatcher !== false;
+		const withHmr = _runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const initialChunkIdsWithCss = new Set();
+		const initialChunkIdsWithoutCss = new Set();
+		for (const c of chunk.getAllInitialChunks()) {
+			(chunkHasCss(c, chunkGraph)
+				? initialChunkIdsWithCss
+				: initialChunkIdsWithoutCss
+			).add(c.id);
+		}
 
-	/** @type {Set<DependenciesBlock>} */
-	const blocksWithNestedBlocks = new Set();
+		if (!withLoading && !withHmr && initialChunkIdsWithCss.size === 0) {
+			return null;
+		}
 
-	// PART ONE
+		const { createStylesheet } =
+			CssLoadingRuntimeModule.getCompilationHooks(compilation);
 
-	logger.time("visitModules");
-	visitModules(
-		logger,
-		compilation,
-		inputEntrypointsAndModules,
-		chunkGroupInfoMap,
-		blockConnections,
-		blocksWithNestedBlocks,
-		allCreatedChunkGroups
-	);
-	logger.timeEnd("visitModules");
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_css`
+			: undefined;
 
-	// PART TWO
+		const code = Template.asString([
+			"link = document.createElement('link');",
+			uniqueName
+				? 'link.setAttribute("data-webpack", uniqueName + ":" + key);'
+				: "",
+			"link.setAttribute(loadingAttribute, 1);",
+			'link.rel = "stylesheet";',
+			"link.href = url;",
+			crossOriginLoading
+				? Template.asString([
+						"if (link.src.indexOf(window.location.origin + '/') !== 0) {",
+						Template.indent(
+							`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+						),
+						"}"
+				  ])
+				: ""
+		]);
 
-	logger.time("connectChunkGroups");
-	connectChunkGroups(
-		compilation,
-		blocksWithNestedBlocks,
-		blockConnections,
-		chunkGroupInfoMap
-	);
-	logger.timeEnd("connectChunkGroups");
+		const cc = str => str.charCodeAt(0);
 
-	for (const [chunkGroup, chunkGroupInfo] of chunkGroupInfoMap) {
-		for (const chunk of chunkGroup.chunks)
-			chunk.runtime = mergeRuntime(chunk.runtime, chunkGroupInfo.runtime);
+		return Template.asString([
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{${Array.from(
+				initialChunkIdsWithoutCss,
+				id => `${JSON.stringify(id)}:0`
+			).join(",")}};`,
+			"",
+			uniqueName
+				? `var uniqueName = ${JSON.stringify(
+						runtimeTemplate.outputOptions.uniqueName
+				  )};`
+				: "// data-webpack is not used as build has no uniqueName",
+			`var loadCssChunkData = ${runtimeTemplate.basicFunction(
+				"target, link, chunkId",
+				[
+					`var data, token = "", token2, exports = {}, exportsWithId = [], exportsWithDashes = [], ${
+						withHmr ? "moduleIds = [], " : ""
+					}i = 0, cc = 1;`,
+					"try { if(!link) link = loadStylesheet(chunkId); data = link.sheet.cssRules; data = data[data.length - 1].style; } catch(e) { data = getComputedStyle(document.head); }",
+					`data = data.getPropertyValue(${
+						uniqueName
+							? runtimeTemplate.concatenation(
+									"--webpack-",
+									{ expr: "uniqueName" },
+									"-",
+									{ expr: "chunkId" }
+							  )
+							: runtimeTemplate.concatenation("--webpack-", { expr: "chunkId" })
+					});`,
+					"if(!data) return [];",
+					"for(; cc; i++) {",
+					Template.indent([
+						"cc = data.charCodeAt(i);",
+						`if(cc == ${cc("(")}) { token2 = token; token = ""; }`,
+						`else if(cc == ${cc(
+							")"
+						)}) { exports[token2.replace(/^_/, "")] = token.replace(/^_/, ""); token = ""; }`,
+						`else if(cc == ${cc("/")} || cc == ${cc(
+							"%"
+						)}) { token = token.replace(/^_/, ""); exports[token] = token; exportsWithId.push(token); if(cc == ${cc(
+							"%"
+						)}) exportsWithDashes.push(token); token = ""; }`,
+						`else if(!cc || cc == ${cc(
+							","
+						)}) { token = token.replace(/^_/, ""); exportsWithId.forEach(${runtimeTemplate.expressionFunction(
+							`exports[x] = ${
+								uniqueName
+									? runtimeTemplate.concatenation(
+											{ expr: "uniqueName" },
+											"-",
+											{ expr: "token" },
+											"-",
+											{ expr: "exports[x]" }
+									  )
+									: runtimeTemplate.concatenation({ expr: "token" }, "-", {
+											expr: "exports[x]"
+									  })
+							}`,
+							"x"
+						)}); exportsWithDashes.forEach(${runtimeTemplate.expressionFunction(
+							`exports[x] = "--" + exports[x]`,
+							"x"
+						)}); ${
+							RuntimeGlobals.makeNamespaceObject
+						}(exports); target[token] = (${runtimeTemplate.basicFunction(
+							"exports, module",
+							`module.exports = exports;`
+						)}).bind(null, exports); ${
+							withHmr ? "moduleIds.push(token); " : ""
+						}token = ""; exports = {}; exportsWithId.length = 0; }`,
+						`else if(cc == ${cc("\\")}) { token += data[++i] }`,
+						`else { token += data[i]; }`
+					]),
+					"}",
+					`${
+						withHmr ? `if(target == ${RuntimeGlobals.moduleFactories}) ` : ""
+					}installedChunks[chunkId] = 0;`,
+					withHmr ? "return moduleIds;" : ""
+				]
+			)}`,
+			'var loadingAttribute = "data-webpack-loading";',
+			`var loadStylesheet = ${runtimeTemplate.basicFunction(
+				"chunkId, url, done" + (withHmr ? ", hmr" : ""),
+				[
+					'var link, needAttach, key = "chunk-" + chunkId;',
+					withHmr ? "if(!hmr) {" : "",
+					'var links = document.getElementsByTagName("link");',
+					"for(var i = 0; i < links.length; i++) {",
+					Template.indent([
+						"var l = links[i];",
+						`if(l.rel == "stylesheet" && (${
+							withHmr
+								? 'l.href.startsWith(url) || l.getAttribute("href").startsWith(url)'
+								: 'l.href == url || l.getAttribute("href") == url'
+						}${
+							uniqueName
+								? ' || l.getAttribute("data-webpack") == uniqueName + ":" + key'
+								: ""
+						})) { link = l; break; }`
+					]),
+					"}",
+					"if(!done) return link;",
+					withHmr ? "}" : "",
+					"if(!link) {",
+					Template.indent([
+						"needAttach = true;",
+						createStylesheet.call(code, this.chunk)
+					]),
+					"}",
+					`var onLinkComplete = ${runtimeTemplate.basicFunction(
+						"prev, event",
+						Template.asString([
+							"link.onerror = link.onload = null;",
+							"link.removeAttribute(loadingAttribute);",
+							"clearTimeout(timeout);",
+							'if(event && event.type != "load") link.parentNode.removeChild(link)',
+							"done(event);",
+							"if(prev) return prev(event);"
+						])
+					)};`,
+					"if(link.getAttribute(loadingAttribute)) {",
+					Template.indent([
+						`var timeout = setTimeout(onLinkComplete.bind(null, undefined, { type: 'timeout', target: link }), ${loadTimeout});`,
+						"link.onerror = onLinkComplete.bind(null, link.onerror);",
+						"link.onload = onLinkComplete.bind(null, link.onload);"
+					]),
+					"} else onLinkComplete(undefined, { type: 'load', target: link });", // We assume any existing stylesheet is render blocking
+					withHmr ? "hmr ? document.head.insertBefore(link, hmr) :" : "",
+					"needAttach && document.head.appendChild(link);",
+					"return link;"
+				]
+			)};`,
+			initialChunkIdsWithCss.size > 2
+				? `${JSON.stringify(
+						Array.from(initialChunkIdsWithCss)
+				  )}.forEach(loadCssChunkData.bind(null, ${
+						RuntimeGlobals.moduleFactories
+				  }, 0));`
+				: initialChunkIdsWithCss.size > 0
+				? `${Array.from(
+						initialChunkIdsWithCss,
+						id =>
+							`loadCssChunkData(${
+								RuntimeGlobals.moduleFactories
+							}, 0, ${JSON.stringify(id)});`
+				  ).join("")}`
+				: "// no initial css",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.css = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasCssMatcher !== false
+								? [
+										"// css chunk loading",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[2]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasCssMatcher === true
+													? "if(true) { // all chunks have CSS"
+													: `if(${hasCssMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
+														"resolve, reject"
+													)});`,
+													"promises.push(installedChunkData[2] = promise);",
+													"",
+													"// start chunk loading",
+													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
+													"// create error before stack unwound to get useful stacktrace later",
+													"var error = new Error();",
+													`var loadingEnded = ${runtimeTemplate.basicFunction(
+														"event",
+														[
+															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
+															Template.indent([
+																"installedChunkData = installedChunks[chunkId];",
+																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
+																"if(installedChunkData) {",
+																Template.indent([
+																	'if(event.type !== "load") {',
+																	Template.indent([
+																		"var errorType = event && event.type;",
+																		"var realSrc = event && event.target && event.target.src;",
+																		"error.message = 'Loading css chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+																		"error.name = 'ChunkLoadError';",
+																		"error.type = errorType;",
+																		"error.request = realSrc;",
+																		"installedChunkData[1](error);"
+																	]),
+																	"} else {",
+																	Template.indent([
+																		`loadCssChunkData(${RuntimeGlobals.moduleFactories}, link, chunkId);`,
+																		"installedChunkData[0]();"
+																	]),
+																	"}"
+																]),
+																"}"
+															]),
+															"}"
+														]
+													)};`,
+													"var link = loadStylesheet(chunkId, url, loadingEnded);"
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ]
+								: "installedChunks[chunkId] = 0;"
+						)};`
+				  ])
+				: "// no chunk loading",
+			"",
+			withHmr
+				? Template.asString([
+						"var oldTags = [];",
+						"var newTags = [];",
+						`var applyHandler = ${runtimeTemplate.basicFunction("options", [
+							`return { dispose: ${runtimeTemplate.basicFunction(
+								"",
+								[]
+							)}, apply: ${runtimeTemplate.basicFunction("", [
+								"var moduleIds = [];",
+								`newTags.forEach(${runtimeTemplate.expressionFunction(
+									"info[1].sheet.disabled = false",
+									"info"
+								)});`,
+								"while(oldTags.length) {",
+								Template.indent([
+									"var oldTag = oldTags.pop();",
+									"if(oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);"
+								]),
+								"}",
+								"while(newTags.length) {",
+								Template.indent([
+									`var info = newTags.pop();`,
+									`var chunkModuleIds = loadCssChunkData(${RuntimeGlobals.moduleFactories}, info[1], info[0]);`,
+									`chunkModuleIds.forEach(${runtimeTemplate.expressionFunction(
+										"moduleIds.push(id)",
+										"id"
+									)});`
+								]),
+								"}",
+								"return moduleIds;"
+							])} };`
+						])}`,
+						`var cssTextKey = ${runtimeTemplate.returningFunction(
+							`Array.from(link.sheet.cssRules, ${runtimeTemplate.returningFunction(
+								"r.cssText",
+								"r"
+							)}).join()`,
+							"link"
+						)}`,
+						`${
+							RuntimeGlobals.hmrDownloadUpdateHandlers
+						}.css = ${runtimeTemplate.basicFunction(
+							"chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList",
+							[
+								"applyHandlers.push(applyHandler);",
+								`chunkIds.forEach(${runtimeTemplate.basicFunction("chunkId", [
+									`var filename = ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
+									`var url = ${RuntimeGlobals.publicPath} + filename;`,
+									"var oldTag = loadStylesheet(chunkId, url);",
+									"if(!oldTag) return;",
+									`promises.push(new Promise(${runtimeTemplate.basicFunction(
+										"resolve, reject",
+										[
+											`var link = loadStylesheet(chunkId, url + (url.indexOf("?") < 0 ? "?" : "&") + "hmr=" + Date.now(), ${runtimeTemplate.basicFunction(
+												"event",
+												[
+													'if(event.type !== "load") {',
+													Template.indent([
+														"var errorType = event && event.type;",
+														"var realSrc = event && event.target && event.target.src;",
+														"error.message = 'Loading css hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+														"error.name = 'ChunkLoadError';",
+														"error.type = errorType;",
+														"error.request = realSrc;",
+														"reject(error);"
+													]),
+													"} else {",
+													Template.indent([
+														"try { if(cssTextKey(oldTag) == cssTextKey(link)) { if(link.parentNode) link.parentNode.removeChild(link); return resolve(); } } catch(e) {}",
+														"var factories = {};",
+														"loadCssChunkData(factories, link, chunkId);",
+														`Object.keys(factories).forEach(${runtimeTemplate.expressionFunction(
+															"updatedModulesList.push(id)",
+															"id"
+														)})`,
+														"link.sheet.disabled = true;",
+														"oldTags.push(oldTag);",
+														"newTags.push([chunkId, link]);",
+														"resolve();"
+													]),
+													"}"
+												]
+											)}, oldTag);`
+										]
+									)}));`
+								])});`
+							]
+						)}`
+				  ])
+				: "// no hmr"
+		]);
 	}
+}
 
-	// Cleanup work
-
-	logger.time("cleanup");
-	cleanupUnconnectedGroups(compilation, allCreatedChunkGroups);
-	logger.timeEnd("cleanup");
-};
-
-module.exports = buildChunkGraph;
+module.exports = CssLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 28034:
-/***/ (function(module) {
+/***/ 47283:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -67805,80 +68536,465 @@ module.exports = buildChunkGraph;
 
 
 
-/** @typedef {import("../Compiler")} Compiler */
-
-class AddBuildDependenciesPlugin {
-	/**
-	 * @param {Iterable<string>} buildDependencies list of build dependencies
-	 */
-	constructor(buildDependencies) {
-		this.buildDependencies = new Set(buildDependencies);
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AddBuildDependenciesPlugin",
-			compilation => {
-				compilation.buildDependencies.addAll(this.buildDependencies);
-			}
-		);
-	}
-}
+const { ConcatSource } = __webpack_require__(51255);
+const HotUpdateChunk = __webpack_require__(9597);
+const RuntimeGlobals = __webpack_require__(16475);
+const SelfModuleFactory = __webpack_require__(63560);
+const CssExportDependency = __webpack_require__(76760);
+const CssImportDependency = __webpack_require__(90542);
+const CssLocalIdentifierDependency = __webpack_require__(92328);
+const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
+const CssUrlDependency = __webpack_require__(70749);
+const StaticExportsDependency = __webpack_require__(91418);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const memoize = __webpack_require__(78676);
+const CssExportsGenerator = __webpack_require__(91254);
+const CssGenerator = __webpack_require__(46061);
+const CssParser = __webpack_require__(98305);
 
-module.exports = AddBuildDependenciesPlugin;
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
+const getCssLoadingRuntimeModule = memoize(() =>
+	__webpack_require__(80806)
+);
 
-/***/ }),
-
-/***/ 47942:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const getSchema = name => {
+	const { definitions } = __webpack_require__(73342);
+	return {
+		definitions,
+		oneOf: [{ $ref: `#/definitions/${name}` }]
+	};
+};
 
+const validateGeneratorOptions = createSchemaValidation(
+	__webpack_require__(59170),
+	() => getSchema("CssGeneratorOptions"),
+	{
+		name: "Css Modules Plugin",
+		baseDataPath: "parser"
+	}
+);
+const validateParserOptions = createSchemaValidation(
+	__webpack_require__(38542),
+	() => getSchema("CssParserOptions"),
+	{
+		name: "Css Modules Plugin",
+		baseDataPath: "parser"
+	}
+);
 
+const escapeCss = (str, omitOptionalUnderscore) => {
+	const escaped = `${str}`.replace(
+		// cspell:word uffff
+		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
+		s => `\\${s}`
+	);
+	return !omitOptionalUnderscore && /^(?!--)[0-9_-]/.test(escaped)
+		? `_${escaped}`
+		: escaped;
+};
 
-/** @typedef {import("../Compiler")} Compiler */
+const plugin = "CssModulesPlugin";
 
-class AddManagedPathsPlugin {
+class CssModulesPlugin {
 	/**
-	 * @param {Iterable<string | RegExp>} managedPaths list of managed paths
-	 * @param {Iterable<string | RegExp>} immutablePaths list of immutable paths
+	 * @param {CssExperimentOptions} options options
 	 */
-	constructor(managedPaths, immutablePaths) {
-		this.managedPaths = new Set(managedPaths);
-		this.immutablePaths = new Set(immutablePaths);
+	constructor({ exportsOnly = false }) {
+		this._exportsOnly = exportsOnly;
 	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		for (const managedPath of this.managedPaths) {
-			compiler.managedPaths.add(managedPath);
+		compiler.hooks.compilation.tap(
+			plugin,
+			(compilation, { normalModuleFactory }) => {
+				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
+				compilation.dependencyFactories.set(
+					CssUrlDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CssUrlDependency,
+					new CssUrlDependency.Template()
+				);
+				compilation.dependencyTemplates.set(
+					CssLocalIdentifierDependency,
+					new CssLocalIdentifierDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					CssSelfLocalIdentifierDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					CssSelfLocalIdentifierDependency,
+					new CssSelfLocalIdentifierDependency.Template()
+				);
+				compilation.dependencyTemplates.set(
+					CssExportDependency,
+					new CssExportDependency.Template()
+				);
+				compilation.dependencyFactories.set(
+					CssImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CssImportDependency,
+					new CssImportDependency.Template()
+				);
+				compilation.dependencyTemplates.set(
+					StaticExportsDependency,
+					new StaticExportsDependency.Template()
+				);
+				normalModuleFactory.hooks.createParser
+					.for("css")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						return new CssParser();
+					});
+				normalModuleFactory.hooks.createParser
+					.for("css/global")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						return new CssParser({
+							allowPseudoBlocks: false,
+							allowModeSwitch: false
+						});
+					});
+				normalModuleFactory.hooks.createParser
+					.for("css/module")
+					.tap(plugin, parserOptions => {
+						validateParserOptions(parserOptions);
+						return new CssParser({
+							defaultMode: "local"
+						});
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("css")
+					.tap(plugin, generatorOptions => {
+						validateGeneratorOptions(generatorOptions);
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("css/global")
+					.tap(plugin, generatorOptions => {
+						validateGeneratorOptions(generatorOptions);
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("css/module")
+					.tap(plugin, generatorOptions => {
+						validateGeneratorOptions(generatorOptions);
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
+					});
+				const orderedCssModulesPerChunk = new WeakMap();
+				compilation.hooks.afterCodeGeneration.tap("CssModulesPlugin", () => {
+					const { chunkGraph } = compilation;
+					for (const chunk of compilation.chunks) {
+						if (CssModulesPlugin.chunkHasCss(chunk, chunkGraph)) {
+							orderedCssModulesPerChunk.set(
+								chunk,
+								this.getOrderedChunkCssModules(chunk, chunkGraph, compilation)
+							);
+						}
+					}
+				});
+				compilation.hooks.contentHash.tap("CssModulesPlugin", chunk => {
+					const {
+						chunkGraph,
+						outputOptions: {
+							hashSalt,
+							hashDigest,
+							hashDigestLength,
+							hashFunction
+						}
+					} = compilation;
+					const modules = orderedCssModulesPerChunk.get(chunk);
+					if (modules === undefined) return;
+					const hash = createHash(hashFunction);
+					if (hashSalt) hash.update(hashSalt);
+					for (const module of modules) {
+						hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
+					}
+					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					chunk.contentHash.css = digest.substr(0, hashDigestLength);
+				});
+				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { hash, chunk, codeGenerationResults } = options;
+
+					if (chunk instanceof HotUpdateChunk) return result;
+
+					const modules = orderedCssModulesPerChunk.get(chunk);
+					if (modules !== undefined) {
+						result.push({
+							render: () =>
+								this.renderChunk({
+									chunk,
+									chunkGraph,
+									codeGenerationResults,
+									uniqueName: compilation.outputOptions.uniqueName,
+									modules
+								}),
+							filenameTemplate: CssModulesPlugin.getChunkFilenameTemplate(
+								chunk,
+								compilation.outputOptions
+							),
+							pathOptions: {
+								hash,
+								runtime: chunk.runtime,
+								chunk,
+								contentHashType: "css"
+							},
+							identifier: `css${chunk.id}`,
+							hash: chunk.contentHash.css
+						});
+					}
+					return result;
+				});
+				const enabledChunks = new WeakSet();
+				const handler = (chunk, set) => {
+					if (enabledChunks.has(chunk)) {
+						return;
+					}
+					enabledChunks.add(chunk);
+
+					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkCssFilename);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.makeNamespaceObject);
+
+					const CssLoadingRuntimeModule = getCssLoadingRuntimeModule();
+					compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hasCssModules)
+					.tap(plugin, handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap(plugin, handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap(plugin, handler);
+			}
+		);
+	}
+
+	getModulesInOrder(chunk, modules, compilation) {
+		if (!modules) return [];
+
+		const modulesList = [...modules];
+
+		// Get ordered list of modules per chunk group
+		// Lists are in reverse order to allow to use Array.pop()
+		const modulesByChunkGroup = Array.from(chunk.groupsIterable, chunkGroup => {
+			const sortedModules = modulesList
+				.map(module => {
+					return {
+						module,
+						index: chunkGroup.getModulePostOrderIndex(module)
+					};
+				})
+				.filter(item => item.index !== undefined)
+				.sort((a, b) => b.index - a.index)
+				.map(item => item.module);
+
+			return { list: sortedModules, set: new Set(sortedModules) };
+		});
+
+		if (modulesByChunkGroup.length === 1)
+			return modulesByChunkGroup[0].list.reverse();
+
+		const compareModuleLists = ({ list: a }, { list: b }) => {
+			if (a.length === 0) {
+				return b.length === 0 ? 0 : 1;
+			} else {
+				if (b.length === 0) return -1;
+				return compareModulesByIdentifier(a[a.length - 1], b[b.length - 1]);
+			}
+		};
+
+		modulesByChunkGroup.sort(compareModuleLists);
+
+		const finalModules = [];
+
+		for (;;) {
+			const failedModules = new Set();
+			const list = modulesByChunkGroup[0].list;
+			if (list.length === 0) {
+				// done, everything empty
+				break;
+			}
+			let selectedModule = list[list.length - 1];
+			let hasFailed = undefined;
+			outer: for (;;) {
+				for (const { list, set } of modulesByChunkGroup) {
+					if (list.length === 0) continue;
+					const lastModule = list[list.length - 1];
+					if (lastModule === selectedModule) continue;
+					if (!set.has(selectedModule)) continue;
+					failedModules.add(selectedModule);
+					if (failedModules.has(lastModule)) {
+						// There is a conflict, try other alternatives
+						hasFailed = lastModule;
+						continue;
+					}
+					selectedModule = lastModule;
+					hasFailed = false;
+					continue outer; // restart
+				}
+				break;
+			}
+			if (hasFailed) {
+				// There is a not resolve-able conflict with the selectedModule
+				if (compilation) {
+					// TODO print better warning
+					compilation.warnings.push(
+						new Error(
+							`chunk ${
+								chunk.name || chunk.id
+							}\nConflicting order between ${hasFailed.readableIdentifier(
+								compilation.requestShortener
+							)} and ${selectedModule.readableIdentifier(
+								compilation.requestShortener
+							)}`
+						)
+					);
+				}
+				selectedModule = hasFailed;
+			}
+			// Insert the selected module into the final modules list
+			finalModules.push(selectedModule);
+			// Remove the selected module from all lists
+			for (const { list, set } of modulesByChunkGroup) {
+				const lastModule = list[list.length - 1];
+				if (lastModule === selectedModule) list.pop();
+				else if (hasFailed && set.has(selectedModule)) {
+					const idx = list.indexOf(selectedModule);
+					if (idx >= 0) list.splice(idx, 1);
+				}
+			}
+			modulesByChunkGroup.sort(compareModuleLists);
 		}
-		for (const immutablePath of this.immutablePaths) {
-			compiler.immutablePaths.add(immutablePath);
+		return finalModules;
+	}
+
+	getOrderedChunkCssModules(chunk, chunkGraph, compilation) {
+		return [
+			...this.getModulesInOrder(
+				chunk,
+				chunkGraph.getOrderedChunkModulesIterableBySourceType(
+					chunk,
+					"css-import",
+					compareModulesByIdentifier
+				),
+				compilation
+			),
+			...this.getModulesInOrder(
+				chunk,
+				chunkGraph.getOrderedChunkModulesIterableBySourceType(
+					chunk,
+					"css",
+					compareModulesByIdentifier
+				),
+				compilation
+			)
+		];
+	}
+
+	renderChunk({
+		uniqueName,
+		chunk,
+		chunkGraph,
+		codeGenerationResults,
+		modules
+	}) {
+		const source = new ConcatSource();
+		const metaData = [];
+		for (const module of modules) {
+			try {
+				const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+
+				const s =
+					codeGenResult.sources.get("css") ||
+					codeGenResult.sources.get("css-import");
+				if (s) {
+					source.add(s);
+					source.add("\n");
+				}
+				const exports =
+					codeGenResult.data && codeGenResult.data.get("css-exports");
+				const moduleId = chunkGraph.getModuleId(module) + "";
+				metaData.push(
+					`${
+						exports
+							? Array.from(exports, ([n, v]) => {
+									const shortcutValue = `${
+										uniqueName ? uniqueName + "-" : ""
+									}${moduleId}-${n}`;
+									return v === shortcutValue
+										? `${escapeCss(n)}/`
+										: v === "--" + shortcutValue
+										? `${escapeCss(n)}%`
+										: `${escapeCss(n)}(${escapeCss(v)})`;
+							  }).join("")
+							: ""
+					}${escapeCss(moduleId)}`
+				);
+			} catch (e) {
+				e.message += `\nduring rendering of css ${module.identifier()}`;
+				throw e;
+			}
+		}
+		source.add(
+			`head{--webpack-${escapeCss(
+				(uniqueName ? uniqueName + "-" : "") + chunk.id,
+				true
+			)}:${metaData.join(",")};}`
+		);
+		return source;
+	}
+
+	static getChunkFilenameTemplate(chunk, outputOptions) {
+		if (chunk.cssFilenameTemplate) {
+			return chunk.cssFilenameTemplate;
+		} else if (chunk.canBeInitial()) {
+			return outputOptions.cssFilename;
+		} else {
+			return outputOptions.cssChunkFilename;
 		}
 	}
+
+	static chunkHasCss(chunk, chunkGraph) {
+		return (
+			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css") ||
+			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css-import")
+		);
+	}
 }
 
-module.exports = AddManagedPathsPlugin;
+module.exports = CssModulesPlugin;
 
 
 /***/ }),
 
-/***/ 71985:
+/***/ 98305:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -67889,1867 +69005,1752 @@ module.exports = AddManagedPathsPlugin;
 
 
 
-const Cache = __webpack_require__(7592);
-const ProgressPlugin = __webpack_require__(13216);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-const BUILD_DEPENDENCIES_KEY = Symbol();
-
-class IdleFileCachePlugin {
-	/**
-	 * @param {TODO} strategy cache strategy
-	 * @param {number} idleTimeout timeout
-	 * @param {number} idleTimeoutForInitialStore initial timeout
-	 * @param {number} idleTimeoutAfterLargeChanges timeout after changes
-	 */
-	constructor(
-		strategy,
-		idleTimeout,
-		idleTimeoutForInitialStore,
-		idleTimeoutAfterLargeChanges
-	) {
-		this.strategy = strategy;
-		this.idleTimeout = idleTimeout;
-		this.idleTimeoutForInitialStore = idleTimeoutForInitialStore;
-		this.idleTimeoutAfterLargeChanges = idleTimeoutAfterLargeChanges;
-	}
+const Parser = __webpack_require__(11715);
+const ConstDependency = __webpack_require__(76911);
+const CssExportDependency = __webpack_require__(76760);
+const CssImportDependency = __webpack_require__(90542);
+const CssLocalIdentifierDependency = __webpack_require__(92328);
+const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
+const CssUrlDependency = __webpack_require__(70749);
+const StaticExportsDependency = __webpack_require__(91418);
+const walkCssTokens = __webpack_require__(44124);
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		let strategy = this.strategy;
-		const idleTimeout = this.idleTimeout;
-		const idleTimeoutForInitialStore = Math.min(
-			idleTimeout,
-			this.idleTimeoutForInitialStore
-		);
-		const idleTimeoutAfterLargeChanges = this.idleTimeoutAfterLargeChanges;
-		const resolvedPromise = Promise.resolve();
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-		let timeSpendInBuild = 0;
-		let timeSpendInStore = 0;
-		let avgTimeSpendInStore = 0;
+const CC_LEFT_CURLY = "{".charCodeAt(0);
+const CC_RIGHT_CURLY = "}".charCodeAt(0);
+const CC_COLON = ":".charCodeAt(0);
+const CC_SLASH = "/".charCodeAt(0);
+const CC_SEMICOLON = ";".charCodeAt(0);
 
-		/** @type {Map<string | typeof BUILD_DEPENDENCIES_KEY, () => Promise>} */
-		const pendingIdleTasks = new Map();
+const cssUnescape = str => {
+	return str.replace(/\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g, match => {
+		if (match.length > 2) {
+			return String.fromCharCode(parseInt(match.slice(1).trim(), 16));
+		} else {
+			return match[1];
+		}
+	});
+};
 
-		compiler.cache.hooks.store.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			(identifier, etag, data) => {
-				pendingIdleTasks.set(identifier, () =>
-					strategy.store(identifier, etag, data)
-				);
-			}
-		);
+class LocConverter {
+	constructor(input) {
+		this._input = input;
+		this.line = 1;
+		this.column = 0;
+		this.pos = 0;
+	}
 
-		compiler.cache.hooks.get.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			(identifier, etag, gotHandlers) => {
-				const restore = () =>
-					strategy.restore(identifier, etag).then(cacheEntry => {
-						if (cacheEntry === undefined) {
-							gotHandlers.push((result, callback) => {
-								if (result !== undefined) {
-									pendingIdleTasks.set(identifier, () =>
-										strategy.store(identifier, etag, result)
-									);
-								}
-								callback();
-							});
-						} else {
-							return cacheEntry;
-						}
-					});
-				const pendingTask = pendingIdleTasks.get(identifier);
-				if (pendingTask !== undefined) {
-					pendingIdleTasks.delete(identifier);
-					return pendingTask().then(restore);
-				}
-				return restore();
-			}
-		);
-
-		compiler.cache.hooks.storeBuildDependencies.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			dependencies => {
-				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
-					strategy.storeBuildDependencies(dependencies)
-				);
-			}
-		);
-
-		compiler.cache.hooks.shutdown.tapPromise(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			() => {
-				if (idleTimer) {
-					clearTimeout(idleTimer);
-					idleTimer = undefined;
-				}
-				isIdle = false;
-				const reportProgress = ProgressPlugin.getReporter(compiler);
-				const jobs = Array.from(pendingIdleTasks.values());
-				if (reportProgress) reportProgress(0, "process pending cache items");
-				const promises = jobs.map(fn => fn());
-				pendingIdleTasks.clear();
-				promises.push(currentIdlePromise);
-				const promise = Promise.all(promises);
-				currentIdlePromise = promise.then(() => strategy.afterAllStored());
-				if (reportProgress) {
-					currentIdlePromise = currentIdlePromise.then(() => {
-						reportProgress(1, `stored`);
-					});
-				}
-				return currentIdlePromise.then(() => {
-					// Reset strategy
-					if (strategy.clear) strategy.clear();
-				});
-			}
-		);
-
-		/** @type {Promise<any>} */
-		let currentIdlePromise = resolvedPromise;
-		let isIdle = false;
-		let isInitialStore = true;
-		const processIdleTasks = () => {
-			if (isIdle) {
-				const startTime = Date.now();
-				if (pendingIdleTasks.size > 0) {
-					const promises = [currentIdlePromise];
-					const maxTime = startTime + 100;
-					let maxCount = 100;
-					for (const [filename, factory] of pendingIdleTasks) {
-						pendingIdleTasks.delete(filename);
-						promises.push(factory());
-						if (maxCount-- <= 0 || Date.now() > maxTime) break;
-					}
-					currentIdlePromise = Promise.all(promises);
-					currentIdlePromise.then(() => {
-						timeSpendInStore += Date.now() - startTime;
-						// Allow to exit the process between
-						idleTimer = setTimeout(processIdleTasks, 0);
-						idleTimer.unref();
-					});
-					return;
-				}
-				currentIdlePromise = currentIdlePromise
-					.then(async () => {
-						await strategy.afterAllStored();
-						timeSpendInStore += Date.now() - startTime;
-						avgTimeSpendInStore =
-							Math.max(avgTimeSpendInStore, timeSpendInStore) * 0.9 +
-							timeSpendInStore * 0.1;
-						timeSpendInStore = 0;
-						timeSpendInBuild = 0;
-					})
-					.catch(err => {
-						const logger = compiler.getInfrastructureLogger(
-							"IdleFileCachePlugin"
-						);
-						logger.warn(`Background tasks during idle failed: ${err.message}`);
-						logger.debug(err.stack);
-					});
-				isInitialStore = false;
-			}
-		};
-		let idleTimer = undefined;
-		compiler.cache.hooks.beginIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			() => {
-				const isLargeChange = timeSpendInBuild > avgTimeSpendInStore * 2;
-				if (isInitialStore && idleTimeoutForInitialStore < idleTimeout) {
-					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
-						.log(
-							`Initial cache was generated and cache will be persisted in ${
-								idleTimeoutForInitialStore / 1000
-							}s.`
-						);
-				} else if (
-					isLargeChange &&
-					idleTimeoutAfterLargeChanges < idleTimeout
-				) {
-					compiler
-						.getInfrastructureLogger("IdleFileCachePlugin")
-						.log(
-							`Spend ${Math.round(timeSpendInBuild) / 1000}s in build and ${
-								Math.round(avgTimeSpendInStore) / 1000
-							}s in average in cache store. This is considered as large change and cache will be persisted in ${
-								idleTimeoutAfterLargeChanges / 1000
-							}s.`
-						);
+	get(pos) {
+		if (this.pos !== pos) {
+			if (this.pos < pos) {
+				const str = this._input.slice(this.pos, pos);
+				let i = str.lastIndexOf("\n");
+				if (i === -1) {
+					this.column += str.length;
+				} else {
+					this.column = str.length - i - 1;
+					this.line++;
+					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1)
+						this.line++;
 				}
-				idleTimer = setTimeout(() => {
-					idleTimer = undefined;
-					isIdle = true;
-					resolvedPromise.then(processIdleTasks);
-				}, Math.min(isInitialStore ? idleTimeoutForInitialStore : Infinity, isLargeChange ? idleTimeoutAfterLargeChanges : Infinity, idleTimeout));
-				idleTimer.unref();
-			}
-		);
-		compiler.cache.hooks.endIdle.tap(
-			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
-			() => {
-				if (idleTimer) {
-					clearTimeout(idleTimer);
-					idleTimer = undefined;
+			} else {
+				let i = this._input.lastIndexOf("\n", this.pos);
+				while (i >= pos) {
+					this.line--;
+					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
 				}
-				isIdle = false;
+				this.column = pos - i;
 			}
-		);
-		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
-			// 10% build overhead is ignored, as it's not cacheable
-			timeSpendInBuild *= 0.9;
-			timeSpendInBuild += stats.endTime - stats.startTime;
-		});
+			this.pos = pos;
+		}
+		return this;
 	}
 }
 
-module.exports = IdleFileCachePlugin;
-
-
-/***/ }),
-
-/***/ 52539:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
+const CSS_MODE_TOP_LEVEL = 0;
+const CSS_MODE_IN_RULE = 1;
+const CSS_MODE_IN_LOCAL_RULE = 2;
+const CSS_MODE_AT_IMPORT_EXPECT_URL = 3;
+// TODO implement layer and supports for @import
+const CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS = 4;
+const CSS_MODE_AT_IMPORT_EXPECT_MEDIA = 5;
+const CSS_MODE_AT_OTHER = 6;
 
-const Cache = __webpack_require__(7592);
+const explainMode = mode => {
+	switch (mode) {
+		case CSS_MODE_TOP_LEVEL:
+			return "parsing top level css";
+		case CSS_MODE_IN_RULE:
+			return "parsing css rule content (global)";
+		case CSS_MODE_IN_LOCAL_RULE:
+			return "parsing css rule content (local)";
+		case CSS_MODE_AT_IMPORT_EXPECT_URL:
+			return "parsing @import (expecting url)";
+		case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
+			return "parsing @import (expecting optionally supports or media query)";
+		case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
+			return "parsing @import (expecting optionally media query)";
+		case CSS_MODE_AT_OTHER:
+			return "parsing at-rule";
+		default:
+			return mode;
+	}
+};
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+class CssParser extends Parser {
+	constructor({
+		allowPseudoBlocks = true,
+		allowModeSwitch = true,
+		defaultMode = "global"
+	} = {}) {
+		super();
+		this.allowPseudoBlocks = allowPseudoBlocks;
+		this.allowModeSwitch = allowModeSwitch;
+		this.defaultMode = defaultMode;
+	}
 
-class MemoryCachePlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
 	 */
-	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
-		const cache = new Map();
-		compiler.cache.hooks.store.tap(
-			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, data) => {
-				cache.set(identifier, { etag, data });
-			}
-		);
-		compiler.cache.hooks.get.tap(
-			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, gotHandlers) => {
-				const cacheEntry = cache.get(identifier);
-				if (cacheEntry === null) {
-					return null;
-				} else if (cacheEntry !== undefined) {
-					return cacheEntry.etag === etag ? cacheEntry.data : null;
-				}
-				gotHandlers.push((result, callback) => {
-					if (result === undefined) {
-						cache.set(identifier, null);
-					} else {
-						cache.set(identifier, { etag, data: result });
-					}
-					return callback();
-				});
-			}
-		);
-		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },
-			() => {
-				cache.clear();
-			}
-		);
-	}
-}
-module.exports = MemoryCachePlugin;
-
-
-/***/ }),
-
-/***/ 99334:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Cache = __webpack_require__(7592);
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		} else if (typeof source === "object") {
+			throw new Error("webpackAst is unexpected for the CssParser");
+		}
+		if (source[0] === "\ufeff") {
+			source = source.slice(1);
+		}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+		const module = state.module;
 
-class MemoryWithGcCachePlugin {
-	constructor({ maxGenerations }) {
-		this._maxGenerations = maxGenerations;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const maxGenerations = this._maxGenerations;
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
-		const cache = new Map();
-		/** @type {Map<string, { entry: { etag: Etag | null, data: any }, until: number }>} */
-		const oldCache = new Map();
-		let generation = 0;
-		let cachePosition = 0;
-		const logger = compiler.getInfrastructureLogger("MemoryWithGcCachePlugin");
-		compiler.hooks.afterDone.tap("MemoryWithGcCachePlugin", () => {
-			generation++;
-			let clearedEntries = 0;
-			let lastClearedIdentifier;
-			for (const [identifier, entry] of oldCache) {
-				if (entry.until > generation) break;
+		const declaredCssVariables = new Set();
 
-				oldCache.delete(identifier);
-				if (cache.get(identifier) === undefined) {
-					cache.delete(identifier);
-					clearedEntries++;
-					lastClearedIdentifier = identifier;
-				}
-			}
-			if (clearedEntries > 0 || oldCache.size > 0) {
-				logger.log(
-					`${cache.size - oldCache.size} active entries, ${
-						oldCache.size
-					} recently unused cached entries${
-						clearedEntries > 0
-							? `, ${clearedEntries} old unused cache entries removed e. g. ${lastClearedIdentifier}`
-							: ""
-					}`
-				);
-			}
-			let i = (cache.size / maxGenerations) | 0;
-			let j = cachePosition >= cache.size ? 0 : cachePosition;
-			cachePosition = j + i;
-			for (const [identifier, entry] of cache) {
-				if (j !== 0) {
-					j--;
+		const locConverter = new LocConverter(source);
+		let mode = CSS_MODE_TOP_LEVEL;
+		let modePos = 0;
+		let modeNestingLevel = 0;
+		let modeData = undefined;
+		let singleClassSelector = undefined;
+		let lastIdentifier = undefined;
+		const modeStack = [];
+		const isTopLevelLocal = () =>
+			modeData === "local" ||
+			(this.defaultMode === "local" && modeData === undefined);
+		const eatWhiteLine = (input, pos) => {
+			for (;;) {
+				const cc = input.charCodeAt(pos);
+				if (cc === 32 || cc === 9) {
+					pos++;
 					continue;
 				}
-				if (entry !== undefined) {
-					// We don't delete the cache entry, but set it to undefined instead
-					// This reserves the location in the data table and avoids rehashing
-					// when constantly adding and removing entries.
-					// It will be deleted when removed from oldCache.
-					cache.set(identifier, undefined);
-					oldCache.delete(identifier);
-					oldCache.set(identifier, {
-						entry,
-						until: generation + maxGenerations
-					});
-					if (i-- === 0) break;
-				}
-			}
-		});
-		compiler.cache.hooks.store.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, data) => {
-				cache.set(identifier, { etag, data });
+				if (cc === 10) pos++;
+				break;
 			}
-		);
-		compiler.cache.hooks.get.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
-			(identifier, etag, gotHandlers) => {
-				const cacheEntry = cache.get(identifier);
-				if (cacheEntry === null) {
-					return null;
-				} else if (cacheEntry !== undefined) {
-					return cacheEntry.etag === etag ? cacheEntry.data : null;
-				}
-				const oldCacheEntry = oldCache.get(identifier);
-				if (oldCacheEntry !== undefined) {
-					const cacheEntry = oldCacheEntry.entry;
-					if (cacheEntry === null) {
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return null;
-					} else {
-						if (cacheEntry.etag !== etag) return null;
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return cacheEntry.data;
+			return pos;
+		};
+		const eatUntil = chars => {
+			const charCodes = Array.from({ length: chars.length }, (_, i) =>
+				chars.charCodeAt(i)
+			);
+			const arr = Array.from(
+				{ length: charCodes.reduce((a, b) => Math.max(a, b), 0) + 1 },
+				() => false
+			);
+			charCodes.forEach(cc => (arr[cc] = true));
+			return (input, pos) => {
+				for (;;) {
+					const cc = input.charCodeAt(pos);
+					if (cc < arr.length && arr[cc]) {
+						return pos;
 					}
+					pos++;
+					if (pos === input.length) return pos;
 				}
-				gotHandlers.push((result, callback) => {
-					if (result === undefined) {
-						cache.set(identifier, null);
+			};
+		};
+		const eatText = (input, pos, eater) => {
+			let text = "";
+			for (;;) {
+				if (input.charCodeAt(pos) === CC_SLASH) {
+					const newPos = walkCssTokens.eatComments(input, pos);
+					if (pos !== newPos) {
+						pos = newPos;
+						if (pos === input.length) break;
 					} else {
-						cache.set(identifier, { etag, data: result });
+						text += "/";
+						pos++;
+						if (pos === input.length) break;
 					}
-					return callback();
-				});
-			}
-		);
-		compiler.cache.hooks.shutdown.tap(
-			{ name: "MemoryWithGcCachePlugin", stage: Cache.STAGE_MEMORY },
-			() => {
-				cache.clear();
-				oldCache.clear();
+				}
+				const newPos = eater(input, pos);
+				if (pos !== newPos) {
+					text += input.slice(pos, newPos);
+					pos = newPos;
+				} else {
+					break;
+				}
+				if (pos === input.length) break;
 			}
-		);
-	}
-}
-module.exports = MemoryWithGcCachePlugin;
-
-
-/***/ }),
-
-/***/ 86180:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const FileSystemInfo = __webpack_require__(79453);
-const ProgressPlugin = __webpack_require__(13216);
-const { formatSize } = __webpack_require__(71070);
-const SerializerMiddleware = __webpack_require__(83137);
-const LazySet = __webpack_require__(38938);
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-const {
-	createFileSerializer,
-	NOT_SERIALIZABLE
-} = __webpack_require__(8282);
-
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-
-class PackContainer {
-	/**
-	 * @param {Object} data stored data
-	 * @param {string} version version identifier
-	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
-	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
-	 * @param {Map<string, string | false>} resolveResults result of the resolved build dependencies
-	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
-	 */
-	constructor(
-		data,
-		version,
-		buildSnapshot,
-		buildDependencies,
-		resolveResults,
-		resolveBuildDependenciesSnapshot
-	) {
-		this.data = data;
-		this.version = version;
-		this.buildSnapshot = buildSnapshot;
-		this.buildDependencies = buildDependencies;
-		this.resolveResults = resolveResults;
-		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
-	}
-
-	serialize({ write, writeLazy }) {
-		write(this.version);
-		write(this.buildSnapshot);
-		write(this.buildDependencies);
-		write(this.resolveResults);
-		write(this.resolveBuildDependenciesSnapshot);
-		writeLazy(this.data);
-	}
+			return [pos, text.trimRight()];
+		};
+		const eatExportName = eatUntil(":};/");
+		const eatExportValue = eatUntil("};/");
+		const parseExports = (input, pos) => {
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			const cc = input.charCodeAt(pos);
+			if (cc !== CC_LEFT_CURLY)
+				throw new Error(
+					`Unexpected ${input[pos]} at ${pos} during parsing of ':export' (expected '{')`
+				);
+			pos++;
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			for (;;) {
+				if (input.charCodeAt(pos) === CC_RIGHT_CURLY) break;
+				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+				if (pos === input.length) return pos;
+				let start = pos;
+				let name;
+				[pos, name] = eatText(input, pos, eatExportName);
+				if (pos === input.length) return pos;
+				if (input.charCodeAt(pos) !== CC_COLON) {
+					throw new Error(
+						`Unexpected ${input[pos]} at ${pos} during parsing of export name in ':export' (expected ':')`
+					);
+				}
+				pos++;
+				if (pos === input.length) return pos;
+				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+				if (pos === input.length) return pos;
+				let value;
+				[pos, value] = eatText(input, pos, eatExportValue);
+				if (pos === input.length) return pos;
+				const cc = input.charCodeAt(pos);
+				if (cc === CC_SEMICOLON) {
+					pos++;
+					if (pos === input.length) return pos;
+					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+					if (pos === input.length) return pos;
+				} else if (cc !== CC_RIGHT_CURLY) {
+					throw new Error(
+						`Unexpected ${input[pos]} at ${pos} during parsing of export value in ':export' (expected ';' or '}')`
+					);
+				}
+				const dep = new CssExportDependency(name, value);
+				const { line: sl, column: sc } = locConverter.get(start);
+				const { line: el, column: ec } = locConverter.get(pos);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+			}
+			pos++;
+			if (pos === input.length) return pos;
+			pos = eatWhiteLine(input, pos);
+			return pos;
+		};
+		const eatPropertyName = eatUntil(":{};");
+		const processLocalDeclaration = (input, pos) => {
+			modeData = undefined;
+			const start = pos;
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			const propertyNameStart = pos;
+			const [propertyNameEnd, propertyName] = eatText(
+				input,
+				pos,
+				eatPropertyName
+			);
+			if (input.charCodeAt(propertyNameEnd) !== CC_COLON) return start;
+			pos = propertyNameEnd + 1;
+			if (propertyName.startsWith("--")) {
+				// CSS Variable
+				const { line: sl, column: sc } = locConverter.get(propertyNameStart);
+				const { line: el, column: ec } = locConverter.get(propertyNameEnd);
+				const name = propertyName.slice(2);
+				const dep = new CssLocalIdentifierDependency(
+					name,
+					[propertyNameStart, propertyNameEnd],
+					"--"
+				);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+				declaredCssVariables.add(name);
+			} else if (
+				propertyName === "animation-name" ||
+				propertyName === "animation"
+			) {
+				modeData = "animation";
+				lastIdentifier = undefined;
+			}
+			return pos;
+		};
+		const processDeclarationValueDone = (input, pos) => {
+			if (modeData === "animation" && lastIdentifier) {
+				const { line: sl, column: sc } = locConverter.get(lastIdentifier[0]);
+				const { line: el, column: ec } = locConverter.get(lastIdentifier[1]);
+				const name = input.slice(lastIdentifier[0], lastIdentifier[1]);
+				const dep = new CssSelfLocalIdentifierDependency(name, lastIdentifier);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+			}
+		};
+		const eatKeyframes = eatUntil("{};/");
+		const eatNameInVar = eatUntil(",)};/");
+		walkCssTokens(source, {
+			isSelector: () => {
+				return mode !== CSS_MODE_IN_RULE && mode !== CSS_MODE_IN_LOCAL_RULE;
+			},
+			url: (input, start, end, contentStart, contentEnd) => {
+				const value = cssUnescape(input.slice(contentStart, contentEnd));
+				switch (mode) {
+					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
+						modeData.url = value;
+						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
+						break;
+					}
+					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
+					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
+						throw new Error(
+							`Unexpected ${input.slice(
+								start,
+								end
+							)} at ${start} during ${explainMode(mode)}`
+						);
+					default: {
+						const dep = new CssUrlDependency(value, [start, end], "url");
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(end);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+						module.addCodeGenerationDependency(dep);
+						break;
+					}
+				}
+				return end;
+			},
+			string: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
+						modeData.url = cssUnescape(input.slice(start + 1, end - 1));
+						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
+						break;
+					}
+				}
+				return end;
+			},
+			atKeyword: (input, start, end) => {
+				const name = input.slice(start, end);
+				if (name === "@namespace") {
+					throw new Error("@namespace is not supported in bundled CSS");
+				}
+				if (name === "@import") {
+					if (mode !== CSS_MODE_TOP_LEVEL) {
+						throw new Error(
+							`Unexpected @import at ${start} during ${explainMode(mode)}`
+						);
+					}
+					mode = CSS_MODE_AT_IMPORT_EXPECT_URL;
+					modePos = end;
+					modeData = {
+						start: start,
+						url: undefined,
+						supports: undefined
+					};
+				}
+				if (name === "@keyframes") {
+					let pos = end;
+					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+					if (pos === input.length) return pos;
+					const [newPos, name] = eatText(input, pos, eatKeyframes);
+					const { line: sl, column: sc } = locConverter.get(pos);
+					const { line: el, column: ec } = locConverter.get(newPos);
+					const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
+					dep.setLoc(sl, sc, el, ec);
+					module.addDependency(dep);
+					pos = newPos;
+					if (pos === input.length) return pos;
+					if (input.charCodeAt(pos) !== CC_LEFT_CURLY) {
+						throw new Error(
+							`Unexpected ${input[pos]} at ${pos} during parsing of @keyframes (expected '{')`
+						);
+					}
+					mode = CSS_MODE_IN_LOCAL_RULE;
+					modeNestingLevel = 1;
+					return pos + 1;
+				}
+				return end;
+			},
+			semicolon: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_AT_IMPORT_EXPECT_URL:
+						throw new Error(`Expected URL for @import at ${start}`);
+					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
+					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS: {
+						const { line: sl, column: sc } = locConverter.get(modeData.start);
+						const { line: el, column: ec } = locConverter.get(end);
+						end = eatWhiteLine(input, end);
+						const media = input.slice(modePos, start).trim();
+						const dep = new CssImportDependency(
+							modeData.url,
+							[modeData.start, end],
+							modeData.supports,
+							media
+						);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+						break;
+					}
+					case CSS_MODE_IN_LOCAL_RULE: {
+						processDeclarationValueDone(input, start);
+						return processLocalDeclaration(input, end);
+					}
+					case CSS_MODE_IN_RULE: {
+						return end;
+					}
+				}
+				mode = CSS_MODE_TOP_LEVEL;
+				modeData = undefined;
+				singleClassSelector = undefined;
+				return end;
+			},
+			leftCurlyBracket: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL:
+						mode = isTopLevelLocal()
+							? CSS_MODE_IN_LOCAL_RULE
+							: CSS_MODE_IN_RULE;
+						modeNestingLevel = 1;
+						if (mode === CSS_MODE_IN_LOCAL_RULE)
+							return processLocalDeclaration(input, end);
+						break;
+					case CSS_MODE_IN_RULE:
+					case CSS_MODE_IN_LOCAL_RULE:
+						modeNestingLevel++;
+						break;
+				}
+				return end;
+			},
+			rightCurlyBracket: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_IN_LOCAL_RULE:
+						processDeclarationValueDone(input, start);
+					/* falls through */
+					case CSS_MODE_IN_RULE:
+						if (--modeNestingLevel === 0) {
+							mode = CSS_MODE_TOP_LEVEL;
+							modeData = undefined;
+							singleClassSelector = undefined;
+						}
+						break;
+				}
+				return end;
+			},
+			id: (input, start, end) => {
+				singleClassSelector = false;
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL:
+						if (isTopLevelLocal()) {
+							const name = input.slice(start + 1, end);
+							const dep = new CssLocalIdentifierDependency(name, [
+								start + 1,
+								end
+							]);
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+						}
+						break;
+				}
+				return end;
+			},
+			identifier: (input, start, end) => {
+				singleClassSelector = false;
+				switch (mode) {
+					case CSS_MODE_IN_LOCAL_RULE:
+						if (modeData === "animation") {
+							lastIdentifier = [start, end];
+						}
+						break;
+				}
+				return end;
+			},
+			class: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						if (isTopLevelLocal()) {
+							const name = input.slice(start + 1, end);
+							const dep = new CssLocalIdentifierDependency(name, [
+								start + 1,
+								end
+							]);
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+							if (singleClassSelector === undefined) singleClassSelector = name;
+						} else {
+							singleClassSelector = false;
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			leftParenthesis: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						modeStack.push(false);
+						break;
+					}
+				}
+				return end;
+			},
+			rightParenthesis: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						const newModeData = modeStack.pop();
+						if (newModeData !== false) {
+							modeData = newModeData;
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			pseudoClass: (input, start, end) => {
+				singleClassSelector = false;
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						const name = input.slice(start, end);
+						if (this.allowModeSwitch && name === ":global") {
+							modeData = "global";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else if (this.allowModeSwitch && name === ":local") {
+							modeData = "local";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else if (this.allowPseudoBlocks && name === ":export") {
+							const pos = parseExports(input, end);
+							const dep = new ConstDependency("", [start, pos]);
+							module.addPresentationalDependency(dep);
+							return pos;
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			pseudoFunction: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL: {
+						const name = input.slice(start, end - 1);
+						if (this.allowModeSwitch && name === ":global") {
+							modeStack.push(modeData);
+							modeData = "global";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else if (this.allowModeSwitch && name === ":local") {
+							modeStack.push(modeData);
+							modeData = "local";
+							const dep = new ConstDependency("", [start, end]);
+							module.addPresentationalDependency(dep);
+						} else {
+							modeStack.push(false);
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			function: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_IN_LOCAL_RULE: {
+						const name = input.slice(start, end - 1);
+						if (name === "var") {
+							let pos = walkCssTokens.eatWhitespaceAndComments(input, end);
+							if (pos === input.length) return pos;
+							const [newPos, name] = eatText(input, pos, eatNameInVar);
+							if (!name.startsWith("--")) return end;
+							const { line: sl, column: sc } = locConverter.get(pos);
+							const { line: el, column: ec } = locConverter.get(newPos);
+							const dep = new CssSelfLocalIdentifierDependency(
+								name.slice(2),
+								[pos, newPos],
+								"--",
+								declaredCssVariables
+							);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+							return newPos;
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			comma: (input, start, end) => {
+				switch (mode) {
+					case CSS_MODE_TOP_LEVEL:
+						modeData = undefined;
+						modeStack.length = 0;
+						break;
+					case CSS_MODE_IN_LOCAL_RULE:
+						processDeclarationValueDone(input, start);
+						break;
+				}
+				return end;
+			}
+		});
 
-	deserialize({ read }) {
-		this.version = read();
-		this.buildSnapshot = read();
-		this.buildDependencies = read();
-		this.resolveResults = read();
-		this.resolveBuildDependenciesSnapshot = read();
-		this.data = read();
+		module.buildInfo.strict = true;
+		module.buildMeta.exportsType = "namespace";
+		module.addDependency(new StaticExportsDependency([], true));
+		return state;
 	}
 }
 
-makeSerializable(
-	PackContainer,
-	"webpack/lib/cache/PackFileCacheStrategy",
-	"PackContainer"
-);
+module.exports = CssParser;
 
-const MIN_CONTENT_SIZE = 1024 * 1024; // 1 MB
-const CONTENT_COUNT_TO_MERGE = 10;
-const MIN_ITEMS_IN_FRESH_PACK = 100;
-const MAX_ITEMS_IN_FRESH_PACK = 50000;
-const MAX_TIME_IN_FRESH_PACK = 1 * 60 * 1000; // 1 min
 
-class PackItemInfo {
-	/**
-	 * @param {string} identifier identifier of item
-	 * @param {string | null} etag etag of item
-	 * @param {any} value fresh value of item
-	 */
-	constructor(identifier, etag, value) {
-		this.identifier = identifier;
-		this.etag = etag;
-		this.location = -1;
-		this.lastAccess = Date.now();
-		this.freshValue = value;
-	}
-}
+/***/ }),
 
-class Pack {
-	constructor(logger, maxAge) {
-		/** @type {Map<string, PackItemInfo>} */
-		this.itemInfo = new Map();
-		/** @type {string[]} */
-		this.requests = [];
-		this.requestsTimeout = undefined;
-		/** @type {Map<string, PackItemInfo>} */
-		this.freshContent = new Map();
-		/** @type {(undefined | PackContent)[]} */
-		this.content = [];
-		this.invalid = false;
-		this.logger = logger;
-		this.maxAge = maxAge;
-	}
+/***/ 44124:
+/***/ (function(module) {
 
-	_addRequest(identifier) {
-		this.requests.push(identifier);
-		if (this.requestsTimeout === undefined) {
-			this.requestsTimeout = setTimeout(() => {
-				this.requests.push(undefined);
-				this.requestsTimeout = undefined;
-			}, MAX_TIME_IN_FRESH_PACK);
-			if (this.requestsTimeout.unref) this.requestsTimeout.unref();
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	stopCapturingRequests() {
-		if (this.requestsTimeout !== undefined) {
-			clearTimeout(this.requestsTimeout);
-			this.requestsTimeout = undefined;
-		}
-	}
 
-	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {string | null} etag etag of the resource
-	 * @returns {any} cached content
-	 */
-	get(identifier, etag) {
-		const info = this.itemInfo.get(identifier);
-		this._addRequest(identifier);
-		if (info === undefined) {
-			return undefined;
-		}
-		if (info.etag !== etag) return null;
-		info.lastAccess = Date.now();
-		const loc = info.location;
-		if (loc === -1) {
-			return info.freshValue;
-		} else {
-			if (!this.content[loc]) {
-				return undefined;
-			}
-			return this.content[loc].get(identifier);
+
+/**
+ * @typedef {Object} CssTokenCallbacks
+ * @property {function(string, number): boolean} isSelector
+ * @property {function(string, number, number, number, number): number=} url
+ * @property {function(string, number, number): number=} string
+ * @property {function(string, number, number): number=} leftParenthesis
+ * @property {function(string, number, number): number=} rightParenthesis
+ * @property {function(string, number, number): number=} pseudoFunction
+ * @property {function(string, number, number): number=} function
+ * @property {function(string, number, number): number=} pseudoClass
+ * @property {function(string, number, number): number=} atKeyword
+ * @property {function(string, number, number): number=} class
+ * @property {function(string, number, number): number=} identifier
+ * @property {function(string, number, number): number=} id
+ * @property {function(string, number, number): number=} leftCurlyBracket
+ * @property {function(string, number, number): number=} rightCurlyBracket
+ * @property {function(string, number, number): number=} semicolon
+ * @property {function(string, number, number): number=} comma
+ */
+
+/** @typedef {function(string, number, CssTokenCallbacks): number} CharHandler */
+
+// spec: https://drafts.csswg.org/css-syntax/
+
+const CC_LINE_FEED = "\n".charCodeAt(0);
+const CC_CARRIAGE_RETURN = "\r".charCodeAt(0);
+const CC_FORM_FEED = "\f".charCodeAt(0);
+
+const CC_TAB = "\t".charCodeAt(0);
+const CC_SPACE = " ".charCodeAt(0);
+
+const CC_SLASH = "/".charCodeAt(0);
+const CC_BACK_SLASH = "\\".charCodeAt(0);
+const CC_ASTERISK = "*".charCodeAt(0);
+
+const CC_LEFT_PARENTHESIS = "(".charCodeAt(0);
+const CC_RIGHT_PARENTHESIS = ")".charCodeAt(0);
+const CC_LEFT_CURLY = "{".charCodeAt(0);
+const CC_RIGHT_CURLY = "}".charCodeAt(0);
+
+const CC_QUOTATION_MARK = '"'.charCodeAt(0);
+const CC_APOSTROPHE = "'".charCodeAt(0);
+
+const CC_FULL_STOP = ".".charCodeAt(0);
+const CC_COLON = ":".charCodeAt(0);
+const CC_SEMICOLON = ";".charCodeAt(0);
+const CC_COMMA = ",".charCodeAt(0);
+const CC_PERCENTAGE = "%".charCodeAt(0);
+const CC_AT_SIGN = "@".charCodeAt(0);
+
+const CC_LOW_LINE = "_".charCodeAt(0);
+const CC_LOWER_A = "a".charCodeAt(0);
+const CC_LOWER_U = "u".charCodeAt(0);
+const CC_LOWER_E = "e".charCodeAt(0);
+const CC_LOWER_Z = "z".charCodeAt(0);
+const CC_UPPER_A = "A".charCodeAt(0);
+const CC_UPPER_E = "E".charCodeAt(0);
+const CC_UPPER_Z = "Z".charCodeAt(0);
+const CC_0 = "0".charCodeAt(0);
+const CC_9 = "9".charCodeAt(0);
+
+const CC_NUMBER_SIGN = "#".charCodeAt(0);
+const CC_PLUS_SIGN = "+".charCodeAt(0);
+const CC_HYPHEN_MINUS = "-".charCodeAt(0);
+
+const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
+const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
+
+const _isNewLine = cc => {
+	return (
+		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
+	);
+};
+
+/** @type {CharHandler} */
+const consumeSpace = (input, pos, callbacks) => {
+	let cc;
+	do {
+		pos++;
+		cc = input.charCodeAt(pos);
+	} while (_isWhiteSpace(cc));
+	return pos;
+};
+
+const _isWhiteSpace = cc => {
+	return (
+		cc === CC_LINE_FEED ||
+		cc === CC_CARRIAGE_RETURN ||
+		cc === CC_FORM_FEED ||
+		cc === CC_TAB ||
+		cc === CC_SPACE
+	);
+};
+
+/** @type {CharHandler} */
+const consumeSingleCharToken = (input, pos, callbacks) => {
+	return pos + 1;
+};
+
+/** @type {CharHandler} */
+const consumePotentialComment = (input, pos, callbacks) => {
+	pos++;
+	if (pos === input.length) return pos;
+	let cc = input.charCodeAt(pos);
+	if (cc !== CC_ASTERISK) return pos;
+	for (;;) {
+		pos++;
+		if (pos === input.length) return pos;
+		cc = input.charCodeAt(pos);
+		while (cc === CC_ASTERISK) {
+			pos++;
+			if (pos === input.length) return pos;
+			cc = input.charCodeAt(pos);
+			if (cc === CC_SLASH) return pos + 1;
 		}
 	}
+};
 
-	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {string | null} etag etag of the resource
-	 * @param {any} data cached content
-	 * @returns {void}
-	 */
-	set(identifier, etag, data) {
-		if (!this.invalid) {
-			this.invalid = true;
-			this.logger.log(`Pack got invalid because of write to: ${identifier}`);
+/** @type {function(number): CharHandler} */
+const consumeString = end => (input, pos, callbacks) => {
+	const start = pos;
+	pos = _consumeString(input, pos, end);
+	if (callbacks.string !== undefined) {
+		pos = callbacks.string(input, start, pos);
+	}
+	return pos;
+};
+
+const _consumeString = (input, pos, end) => {
+	pos++;
+	for (;;) {
+		if (pos === input.length) return pos;
+		const cc = input.charCodeAt(pos);
+		if (cc === end) return pos + 1;
+		if (_isNewLine(cc)) {
+			// bad string
+			return pos;
 		}
-		const info = this.itemInfo.get(identifier);
-		if (info === undefined) {
-			const newInfo = new PackItemInfo(identifier, etag, data);
-			this.itemInfo.set(identifier, newInfo);
-			this._addRequest(identifier);
-			this.freshContent.set(identifier, newInfo);
+		if (cc === CC_BACK_SLASH) {
+			// we don't need to fully parse the escaped code point
+			// just skip over a potential new line
+			pos++;
+			if (pos === input.length) return pos;
+			pos++;
 		} else {
-			const loc = info.location;
-			if (loc >= 0) {
-				this._addRequest(identifier);
-				this.freshContent.set(identifier, info);
-				const content = this.content[loc];
-				content.delete(identifier);
-				if (content.items.size === 0) {
-					this.content[loc] = undefined;
-					this.logger.debug("Pack %d got empty and is removed", loc);
-				}
-			}
-			info.freshValue = data;
-			info.lastAccess = Date.now();
-			info.etag = etag;
-			info.location = -1;
+			pos++;
 		}
 	}
+};
 
-	getContentStats() {
-		let count = 0;
-		let size = 0;
-		for (const content of this.content) {
-			if (content !== undefined) {
-				count++;
-				const s = content.getSize();
-				if (s > 0) {
-					size += s;
-				}
-			}
-		}
-		return { count, size };
-	}
+const _isIdentifierStartCode = cc => {
+	return (
+		cc === CC_LOW_LINE ||
+		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
+		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
+		cc > 0x80
+	);
+};
 
-	/**
-	 * @returns {number} new location of data entries
-	 */
-	_findLocation() {
-		let i;
-		for (i = 0; i < this.content.length && this.content[i] !== undefined; i++);
-		return i;
-	}
+const _isDigit = cc => {
+	return cc >= CC_0 && cc <= CC_9;
+};
 
-	_gcAndUpdateLocation(items, usedItems, newLoc) {
-		let count = 0;
-		let lastGC;
-		const now = Date.now();
-		for (const identifier of items) {
-			const info = this.itemInfo.get(identifier);
-			if (now - info.lastAccess > this.maxAge) {
-				this.itemInfo.delete(identifier);
-				items.delete(identifier);
-				usedItems.delete(identifier);
-				count++;
-				lastGC = identifier;
-			} else {
-				info.location = newLoc;
-			}
-		}
-		if (count > 0) {
-			this.logger.log(
-				"Garbage Collected %d old items at pack %d (%d items remaining) e. g. %s",
-				count,
-				newLoc,
-				items.size,
-				lastGC
-			);
+const _startsIdentifier = (input, pos) => {
+	const cc = input.charCodeAt(pos);
+	if (cc === CC_HYPHEN_MINUS) {
+		if (pos === input.length) return false;
+		const cc = input.charCodeAt(pos + 1);
+		if (cc === CC_HYPHEN_MINUS) return true;
+		if (cc === CC_BACK_SLASH) {
+			const cc = input.charCodeAt(pos + 2);
+			return !_isNewLine(cc);
 		}
+		return _isIdentifierStartCode(cc);
+	}
+	if (cc === CC_BACK_SLASH) {
+		const cc = input.charCodeAt(pos + 1);
+		return !_isNewLine(cc);
 	}
+	return _isIdentifierStartCode(cc);
+};
 
-	_persistFreshContent() {
-		const itemsCount = this.freshContent.size;
-		if (itemsCount > 0) {
-			const packCount = Math.ceil(itemsCount / MAX_ITEMS_IN_FRESH_PACK);
-			const itemsPerPack = Math.ceil(itemsCount / packCount);
-			const packs = [];
-			let i = 0;
-			let ignoreNextTimeTick = false;
-			const createNextPack = () => {
-				const loc = this._findLocation();
-				this.content[loc] = null; // reserve
-				const pack = {
-					/** @type {Set<string>} */
-					items: new Set(),
-					/** @type {Map<string, any>} */
-					map: new Map(),
-					loc
-				};
-				packs.push(pack);
-				return pack;
-			};
-			let pack = createNextPack();
-			if (this.requestsTimeout !== undefined)
-				clearTimeout(this.requestsTimeout);
-			for (const identifier of this.requests) {
-				if (identifier === undefined) {
-					if (ignoreNextTimeTick) {
-						ignoreNextTimeTick = false;
-					} else if (pack.items.size >= MIN_ITEMS_IN_FRESH_PACK) {
-						i = 0;
-						pack = createNextPack();
-					}
-					continue;
-				}
-				const info = this.freshContent.get(identifier);
-				if (info === undefined) continue;
-				pack.items.add(identifier);
-				pack.map.set(identifier, info.freshValue);
-				info.location = pack.loc;
-				info.freshValue = undefined;
-				this.freshContent.delete(identifier);
-				if (++i > itemsPerPack) {
-					i = 0;
-					pack = createNextPack();
-					ignoreNextTimeTick = true;
-				}
-			}
-			this.requests.length = 0;
-			for (const pack of packs) {
-				this.content[pack.loc] = new PackContent(
-					pack.items,
-					new Set(pack.items),
-					new PackContentItems(pack.map)
-				);
-			}
-			this.logger.log(
-				`${itemsCount} fresh items in cache put into pack ${
-					packs.length > 1
-						? packs
-								.map(pack => `${pack.loc} (${pack.items.size} items)`)
-								.join(", ")
-						: packs[0].loc
-				}`
-			);
+/** @type {CharHandler} */
+const consumeNumberSign = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.id !== undefined) {
+			return callbacks.id(input, start, pos);
 		}
 	}
+	return pos;
+};
 
-	/**
-	 * Merges small content files to a single content file
-	 */
-	_optimizeSmallContent() {
-		// 1. Find all small content files
-		// Treat unused content files separately to avoid
-		// a merge-split cycle
-		/** @type {number[]} */
-		const smallUsedContents = [];
-		/** @type {number} */
-		let smallUsedContentSize = 0;
-		/** @type {number[]} */
-		const smallUnusedContents = [];
-		/** @type {number} */
-		let smallUnusedContentSize = 0;
-		for (let i = 0; i < this.content.length; i++) {
-			const content = this.content[i];
-			if (content === undefined) continue;
-			if (content.outdated) continue;
-			const size = content.getSize();
-			if (size < 0 || size > MIN_CONTENT_SIZE) continue;
-			if (content.used.size > 0) {
-				smallUsedContents.push(i);
-				smallUsedContentSize += size;
-			} else {
-				smallUnusedContents.push(i);
-				smallUnusedContentSize += size;
+/** @type {CharHandler} */
+const consumeMinus = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	const cc = input.charCodeAt(pos);
+	if (cc === CC_FULL_STOP || _isDigit(cc)) {
+		return consumeNumericToken(input, pos, callbacks);
+	} else if (cc === CC_HYPHEN_MINUS) {
+		pos++;
+		if (pos === input.length) return pos;
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_GREATER_THAN_SIGN) {
+			return pos + 1;
+		} else {
+			pos = _consumeIdentifier(input, pos);
+			if (callbacks.identifier !== undefined) {
+				return callbacks.identifier(input, start, pos);
 			}
 		}
-
-		// 2. Check if minimum number is reached
-		let mergedIndices;
-		if (
-			smallUsedContents.length >= CONTENT_COUNT_TO_MERGE ||
-			smallUsedContentSize > MIN_CONTENT_SIZE
-		) {
-			mergedIndices = smallUsedContents;
-		} else if (
-			smallUnusedContents.length >= CONTENT_COUNT_TO_MERGE ||
-			smallUnusedContentSize > MIN_CONTENT_SIZE
-		) {
-			mergedIndices = smallUnusedContents;
-		} else return;
-
-		const mergedContent = [];
-
-		// 3. Remove old content entries
-		for (const i of mergedIndices) {
-			mergedContent.push(this.content[i]);
-			this.content[i] = undefined;
+	} else if (cc === CC_BACK_SLASH) {
+		if (pos + 1 === input.length) return pos;
+		const cc = input.charCodeAt(pos + 1);
+		if (_isNewLine(cc)) return pos;
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
 		}
-
-		// 4. Determine merged items
-		/** @type {Set<string>} */
-		const mergedItems = new Set();
-		/** @type {Set<string>} */
-		const mergedUsedItems = new Set();
-		/** @type {(function(Map<string, any>): Promise)[]} */
-		const addToMergedMap = [];
-		for (const content of mergedContent) {
-			for (const identifier of content.items) {
-				mergedItems.add(identifier);
-			}
-			for (const identifier of content.used) {
-				mergedUsedItems.add(identifier);
-			}
-			addToMergedMap.push(async map => {
-				// unpack existing content
-				// after that values are accessible in .content
-				await content.unpack(
-					"it should be merged with other small pack contents"
-				);
-				for (const [identifier, value] of content.content) {
-					map.set(identifier, value);
-				}
-			});
+	} else if (_isIdentifierStartCode(cc)) {
+		pos++;
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
 		}
+	}
+	return pos;
+};
 
-		// 5. GC and update location of merged items
-		const newLoc = this._findLocation();
-		this._gcAndUpdateLocation(mergedItems, mergedUsedItems, newLoc);
+/** @type {CharHandler} */
+const consumeDot = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	const cc = input.charCodeAt(pos);
+	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
+	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
+		return pos;
+	pos = _consumeIdentifier(input, pos);
+	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
+	return pos;
+};
 
-		// 6. If not empty, store content somewhere
-		if (mergedItems.size > 0) {
-			this.content[newLoc] = new PackContent(
-				mergedItems,
-				mergedUsedItems,
-				memoize(async () => {
-					/** @type {Map<string, any>} */
-					const map = new Map();
-					await Promise.all(addToMergedMap.map(fn => fn(map)));
-					return new PackContentItems(map);
-				})
-			);
-			this.logger.log(
-				"Merged %d small files with %d cache items into pack %d",
-				mergedContent.length,
-				mergedItems.size,
-				newLoc
-			);
+/** @type {CharHandler} */
+const consumeNumericToken = (input, pos, callbacks) => {
+	pos = _consumeNumber(input, pos);
+	if (pos === input.length) return pos;
+	if (_startsIdentifier(input, pos)) return _consumeIdentifier(input, pos);
+	const cc = input.charCodeAt(pos);
+	if (cc === CC_PERCENTAGE) return pos + 1;
+	return pos;
+};
+
+/** @type {CharHandler} */
+const consumeOtherIdentifier = (input, pos, callbacks) => {
+	const start = pos;
+	pos = _consumeIdentifier(input, pos);
+	if (
+		pos !== input.length &&
+		!callbacks.isSelector(input, pos) &&
+		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
+	) {
+		pos++;
+		if (callbacks.function !== undefined) {
+			return callbacks.function(input, start, pos);
+		}
+	} else {
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
 		}
 	}
+	return pos;
+};
 
-	/**
-	 * Split large content files with used and unused items
-	 * into two parts to separate used from unused items
-	 */
-	_optimizeUnusedContent() {
-		// 1. Find a large content file with used and unused items
-		for (let i = 0; i < this.content.length; i++) {
-			const content = this.content[i];
-			if (content === undefined) continue;
-			const size = content.getSize();
-			if (size < MIN_CONTENT_SIZE) continue;
-			const used = content.used.size;
-			const total = content.items.size;
-			if (used > 0 && used < total) {
-				// 2. Remove this content
-				this.content[i] = undefined;
-
-				// 3. Determine items for the used content file
-				const usedItems = new Set(content.used);
-				const newLoc = this._findLocation();
-				this._gcAndUpdateLocation(usedItems, usedItems, newLoc);
-
-				// 4. Create content file for used items
-				if (usedItems.size > 0) {
-					this.content[newLoc] = new PackContent(
-						usedItems,
-						new Set(usedItems),
-						async () => {
-							await content.unpack(
-								"it should be splitted into used and unused items"
-							);
-							const map = new Map();
-							for (const identifier of usedItems) {
-								map.set(identifier, content.content.get(identifier));
-							}
-							return new PackContentItems(map);
-						}
-					);
-				}
-
-				// 5. Determine items for the unused content file
-				const unusedItems = new Set(content.items);
-				const usedOfUnusedItems = new Set();
-				for (const identifier of usedItems) {
-					unusedItems.delete(identifier);
-				}
-				const newUnusedLoc = this._findLocation();
-				this._gcAndUpdateLocation(unusedItems, usedOfUnusedItems, newUnusedLoc);
-
-				// 6. Create content file for unused items
-				if (unusedItems.size > 0) {
-					this.content[newUnusedLoc] = new PackContent(
-						unusedItems,
-						usedOfUnusedItems,
-						async () => {
-							await content.unpack(
-								"it should be splitted into used and unused items"
-							);
-							const map = new Map();
-							for (const identifier of unusedItems) {
-								map.set(identifier, content.content.get(identifier));
-							}
-							return new PackContentItems(map);
-						}
-					);
+/** @type {CharHandler} */
+const consumePotentialUrl = (input, pos, callbacks) => {
+	const start = pos;
+	pos = _consumeIdentifier(input, pos);
+	if (pos === start + 3 && input.slice(start, pos + 1) === "url(") {
+		pos++;
+		let cc = input.charCodeAt(pos);
+		while (_isWhiteSpace(cc)) {
+			pos++;
+			if (pos === input.length) return pos;
+			cc = input.charCodeAt(pos);
+		}
+		if (cc === CC_QUOTATION_MARK || cc === CC_APOSTROPHE) {
+			pos++;
+			const contentStart = pos;
+			pos = _consumeString(input, pos, cc);
+			const contentEnd = pos - 1;
+			cc = input.charCodeAt(pos);
+			while (_isWhiteSpace(cc)) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+			}
+			if (cc !== CC_RIGHT_PARENTHESIS) return pos;
+			pos++;
+			if (callbacks.url !== undefined)
+				return callbacks.url(input, start, pos, contentStart, contentEnd);
+			return pos;
+		} else {
+			const contentStart = pos;
+			let contentEnd;
+			for (;;) {
+				if (cc === CC_BACK_SLASH) {
+					pos++;
+					if (pos === input.length) return pos;
+					pos++;
+				} else if (_isWhiteSpace(cc)) {
+					contentEnd = pos;
+					do {
+						pos++;
+						if (pos === input.length) return pos;
+						cc = input.charCodeAt(pos);
+					} while (_isWhiteSpace(cc));
+					if (cc !== CC_RIGHT_PARENTHESIS) return pos;
+					pos++;
+					if (callbacks.url !== undefined) {
+						return callbacks.url(input, start, pos, contentStart, contentEnd);
+					}
+					return pos;
+				} else if (cc === CC_RIGHT_PARENTHESIS) {
+					contentEnd = pos;
+					pos++;
+					if (callbacks.url !== undefined) {
+						return callbacks.url(input, start, pos, contentStart, contentEnd);
+					}
+					return pos;
+				} else if (cc === CC_LEFT_PARENTHESIS) {
+					return pos;
+				} else {
+					pos++;
 				}
-
-				this.logger.log(
-					"Split pack %d into pack %d with %d used items and pack %d with %d unused items",
-					i,
-					newLoc,
-					usedItems.size,
-					newUnusedLoc,
-					unusedItems.size
-				);
-
-				// optimizing only one of them is good enough and
-				// reduces the amount of serialization needed
-				return;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
 			}
 		}
+	} else {
+		if (callbacks.identifier !== undefined) {
+			return callbacks.identifier(input, start, pos);
+		}
+		return pos;
 	}
+};
 
-	/**
-	 * Find the content with the oldest item and run GC on that.
-	 * Only runs for one content to avoid large invalidation.
-	 */
-	_gcOldestContent() {
-		/** @type {PackItemInfo} */
-		let oldest = undefined;
-		for (const info of this.itemInfo.values()) {
-			if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
-				oldest = info;
-			}
+/** @type {CharHandler} */
+const consumePotentialPseudo = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
+		return pos;
+	pos = _consumeIdentifier(input, pos);
+	let cc = input.charCodeAt(pos);
+	if (cc === CC_LEFT_PARENTHESIS) {
+		pos++;
+		if (callbacks.pseudoFunction !== undefined) {
+			return callbacks.pseudoFunction(input, start, pos);
 		}
-		if (Date.now() - oldest.lastAccess > this.maxAge) {
-			const loc = oldest.location;
-			if (loc < 0) return;
-			const content = this.content[loc];
-			const items = new Set(content.items);
-			const usedItems = new Set(content.used);
-			this._gcAndUpdateLocation(items, usedItems, loc);
+		return pos;
+	}
+	if (callbacks.pseudoClass !== undefined) {
+		return callbacks.pseudoClass(input, start, pos);
+	}
+	return pos;
+};
 
-			this.content[loc] =
-				items.size > 0
-					? new PackContent(items, usedItems, async () => {
-							await content.unpack(
-								"it contains old items that should be garbage collected"
-							);
-							const map = new Map();
-							for (const identifier of items) {
-								map.set(identifier, content.content.get(identifier));
-							}
-							return new PackContentItems(map);
-					  })
-					: undefined;
-		}
+/** @type {CharHandler} */
+const consumeLeftParenthesis = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.leftParenthesis !== undefined) {
+		return callbacks.leftParenthesis(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	serialize({ write, writeSeparate }) {
-		this._persistFreshContent();
-		this._optimizeSmallContent();
-		this._optimizeUnusedContent();
-		this._gcOldestContent();
-		for (const identifier of this.itemInfo.keys()) {
-			write(identifier);
-		}
-		write(null); // null as marker of the end of keys
-		for (const info of this.itemInfo.values()) {
-			write(info.etag);
-		}
-		for (const info of this.itemInfo.values()) {
-			write(info.lastAccess);
-		}
-		for (let i = 0; i < this.content.length; i++) {
-			const content = this.content[i];
-			if (content !== undefined) {
-				write(content.items);
-				content.writeLazy(lazy => writeSeparate(lazy, { name: `${i}` }));
-			} else {
-				write(undefined); // undefined marks an empty content slot
-			}
-		}
-		write(null); // null as marker of the end of items
+/** @type {CharHandler} */
+const consumeRightParenthesis = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.rightParenthesis !== undefined) {
+		return callbacks.rightParenthesis(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	deserialize({ read, logger }) {
-		this.logger = logger;
-		{
-			const items = [];
-			let item = read();
-			while (item !== null) {
-				items.push(item);
-				item = read();
-			}
-			this.itemInfo.clear();
-			const infoItems = items.map(identifier => {
-				const info = new PackItemInfo(identifier, undefined, undefined);
-				this.itemInfo.set(identifier, info);
-				return info;
-			});
-			for (const info of infoItems) {
-				info.etag = read();
-			}
-			for (const info of infoItems) {
-				info.lastAccess = read();
-			}
-		}
-		this.content.length = 0;
-		let items = read();
-		while (items !== null) {
-			if (items === undefined) {
-				this.content.push(items);
-			} else {
-				const idx = this.content.length;
-				const lazy = read();
-				this.content.push(
-					new PackContent(
-						items,
-						new Set(),
-						lazy,
-						logger,
-						`${this.content.length}`
-					)
-				);
-				for (const identifier of items) {
-					this.itemInfo.get(identifier).location = idx;
-				}
-			}
-			items = read();
-		}
+/** @type {CharHandler} */
+const consumeLeftCurlyBracket = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.leftCurlyBracket !== undefined) {
+		return callbacks.leftCurlyBracket(input, pos - 1, pos);
 	}
-}
+	return pos;
+};
 
-makeSerializable(Pack, "webpack/lib/cache/PackFileCacheStrategy", "Pack");
+/** @type {CharHandler} */
+const consumeRightCurlyBracket = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.rightCurlyBracket !== undefined) {
+		return callbacks.rightCurlyBracket(input, pos - 1, pos);
+	}
+	return pos;
+};
 
-class PackContentItems {
-	/**
-	 * @param {Map<string, any>} map items
-	 */
-	constructor(map) {
-		this.map = map;
+/** @type {CharHandler} */
+const consumeSemicolon = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.semicolon !== undefined) {
+		return callbacks.semicolon(input, pos - 1, pos);
 	}
+	return pos;
+};
 
-	serialize({ write, snapshot, rollback, logger, profile }) {
-		if (profile) {
-			write(false);
-			for (const [key, value] of this.map) {
-				const s = snapshot();
-				try {
-					write(key);
-					const start = process.hrtime();
-					write(value);
-					const durationHr = process.hrtime(start);
-					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
-					if (duration > 1) {
-						if (duration > 500)
-							logger.error(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 50)
-							logger.warn(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 10)
-							logger.info(`Serialization of '${key}': ${duration} ms`);
-						else if (duration > 5)
-							logger.log(`Serialization of '${key}': ${duration} ms`);
-						else logger.debug(`Serialization of '${key}': ${duration} ms`);
-					}
-				} catch (e) {
-					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
-				}
-			}
-			write(null);
-			return;
+/** @type {CharHandler} */
+const consumeComma = (input, pos, callbacks) => {
+	pos++;
+	if (callbacks.comma !== undefined) {
+		return callbacks.comma(input, pos - 1, pos);
+	}
+	return pos;
+};
+
+const _consumeIdentifier = (input, pos) => {
+	for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_BACK_SLASH) {
+			pos++;
+			if (pos === input.length) return pos;
+			pos++;
+		} else if (
+			_isIdentifierStartCode(cc) ||
+			_isDigit(cc) ||
+			cc === CC_HYPHEN_MINUS
+		) {
+			pos++;
+		} else {
+			return pos;
 		}
-		// Try to serialize all at once
-		const s = snapshot();
-		try {
-			write(true);
-			write(this.map);
-		} catch (e) {
-			rollback(s);
+	}
+};
 
-			// Try to serialize each item on it's own
-			write(false);
-			for (const [key, value] of this.map) {
-				const s = snapshot();
-				try {
-					write(key);
-					write(value);
-				} catch (e) {
-					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
-				}
+const _consumeNumber = (input, pos) => {
+	pos++;
+	if (pos === input.length) return pos;
+	let cc = input.charCodeAt(pos);
+	while (_isDigit(cc)) {
+		pos++;
+		if (pos === input.length) return pos;
+		cc = input.charCodeAt(pos);
+	}
+	if (cc === CC_FULL_STOP && pos + 1 !== input.length) {
+		const next = input.charCodeAt(pos + 1);
+		if (_isDigit(next)) {
+			pos += 2;
+			cc = input.charCodeAt(pos);
+			while (_isDigit(cc)) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
 			}
-			write(null);
 		}
 	}
-
-	deserialize({ read, logger, profile }) {
-		if (read()) {
-			this.map = read();
-		} else if (profile) {
-			const map = new Map();
-			let key = read();
-			while (key !== null) {
-				const start = process.hrtime();
-				const value = read();
-				const durationHr = process.hrtime(start);
-				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
-				if (duration > 1) {
-					if (duration > 100)
-						logger.error(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 20)
-						logger.warn(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 5)
-						logger.info(`Deserialization of '${key}': ${duration} ms`);
-					else if (duration > 2)
-						logger.log(`Deserialization of '${key}': ${duration} ms`);
-					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+	if (cc === CC_LOWER_E || cc === CC_UPPER_E) {
+		if (pos + 1 !== input.length) {
+			const next = input.charCodeAt(pos + 2);
+			if (_isDigit(next)) {
+				pos += 2;
+			} else if (
+				(next === CC_HYPHEN_MINUS || next === CC_PLUS_SIGN) &&
+				pos + 2 !== input.length
+			) {
+				const next = input.charCodeAt(pos + 2);
+				if (_isDigit(next)) {
+					pos += 3;
+				} else {
+					return pos;
 				}
-				map.set(key, value);
-				key = read();
-			}
-			this.map = map;
-		} else {
-			const map = new Map();
-			let key = read();
-			while (key !== null) {
-				map.set(key, read());
-				key = read();
+			} else {
+				return pos;
 			}
-			this.map = map;
 		}
+	} else {
+		return pos;
 	}
-}
+	cc = input.charCodeAt(pos);
+	while (_isDigit(cc)) {
+		pos++;
+		if (pos === input.length) return pos;
+		cc = input.charCodeAt(pos);
+	}
+	return pos;
+};
 
-makeSerializable(
-	PackContentItems,
-	"webpack/lib/cache/PackFileCacheStrategy",
-	"PackContentItems"
-);
+/** @type {CharHandler} */
+const consumeLessThan = (input, pos, callbacks) => {
+	if (input.slice(pos + 1, pos + 4) === "!--") return pos + 4;
+	return pos + 1;
+};
 
-class PackContent {
-	/*
-		This class can be in these states:
-		   |   this.lazy    | this.content | this.outdated | state
-		A1 |   undefined    |     Map      |     false     | fresh content
-		A2 |   undefined    |     Map      |     true      | (will not happen)
-		B1 | lazy () => {}  |  undefined   |     false     | not deserialized
-		B2 | lazy () => {}  |  undefined   |     true      | not deserialized, but some items has been removed
-		C1 | lazy* () => {} |     Map      |     false     | deserialized
-		C2 | lazy* () => {} |     Map      |     true      | deserialized, and some items has been removed
+/** @type {CharHandler} */
+const consumeAt = (input, pos, callbacks) => {
+	const start = pos;
+	pos++;
+	if (pos === input.length) return pos;
+	if (_startsIdentifier(input, pos)) {
+		pos = _consumeIdentifier(input, pos);
+		if (callbacks.atKeyword !== undefined) {
+			pos = callbacks.atKeyword(input, start, pos);
+		}
+	}
+	return pos;
+};
 
-		this.used is a subset of this.items.
-		this.items is a subset of this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === false, this.items === this.content.keys() resp. this.lazy().map.keys()
-		When this.outdated === true, this.items should be used to recreated this.lazy/this.content.
-		When this.lazy and this.content is set, they contain the same data.
-		this.get must only be called with a valid item from this.items.
-		In state C this.lazy is unMemoized
-	*/
-
-	/**
-	 * @param {Set<string>} items keys
-	 * @param {Set<string>} usedItems used keys
-	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
-	 * @param {Logger=} logger logger for logging
-	 * @param {string=} lazyName name of dataOrFn for logging
-	 */
-	constructor(items, usedItems, dataOrFn, logger, lazyName) {
-		this.items = items;
-		/** @type {function(): Promise<PackContentItems> | PackContentItems} */
-		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
-		/** @type {Map<string, any>} */
-		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
-		this.outdated = false;
-		this.used = usedItems;
-		this.logger = logger;
-		this.lazyName = lazyName;
+const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
+	// https://drafts.csswg.org/css-syntax/#consume-token
+	switch (cc) {
+		case CC_LINE_FEED:
+		case CC_CARRIAGE_RETURN:
+		case CC_FORM_FEED:
+		case CC_TAB:
+		case CC_SPACE:
+			return consumeSpace;
+		case CC_QUOTATION_MARK:
+		case CC_APOSTROPHE:
+			return consumeString(cc);
+		case CC_NUMBER_SIGN:
+			return consumeNumberSign;
+		case CC_SLASH:
+			return consumePotentialComment;
+		// case CC_LEFT_SQUARE:
+		// case CC_RIGHT_SQUARE:
+		// case CC_COMMA:
+		// case CC_COLON:
+		// 	return consumeSingleCharToken;
+		case CC_COMMA:
+			return consumeComma;
+		case CC_SEMICOLON:
+			return consumeSemicolon;
+		case CC_LEFT_PARENTHESIS:
+			return consumeLeftParenthesis;
+		case CC_RIGHT_PARENTHESIS:
+			return consumeRightParenthesis;
+		case CC_LEFT_CURLY:
+			return consumeLeftCurlyBracket;
+		case CC_RIGHT_CURLY:
+			return consumeRightCurlyBracket;
+		case CC_COLON:
+			return consumePotentialPseudo;
+		case CC_PLUS_SIGN:
+			return consumeNumericToken;
+		case CC_FULL_STOP:
+			return consumeDot;
+		case CC_HYPHEN_MINUS:
+			return consumeMinus;
+		case CC_LESS_THAN_SIGN:
+			return consumeLessThan;
+		case CC_AT_SIGN:
+			return consumeAt;
+		case CC_LOWER_U:
+			return consumePotentialUrl;
+		case CC_LOW_LINE:
+			return consumeOtherIdentifier;
+		default:
+			if (_isDigit(cc)) return consumeNumericToken;
+			if (
+				(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
+				(cc >= CC_UPPER_A && cc <= CC_UPPER_Z)
+			) {
+				return consumeOtherIdentifier;
+			}
+			return consumeSingleCharToken;
 	}
+});
 
-	get(identifier) {
-		this.used.add(identifier);
-		if (this.content) {
-			return this.content.get(identifier);
+/**
+ * @param {string} input input css
+ * @param {CssTokenCallbacks} callbacks callbacks
+ * @returns {void}
+ */
+module.exports = (input, callbacks) => {
+	let pos = 0;
+	while (pos < input.length) {
+		const cc = input.charCodeAt(pos);
+		if (cc < 0x80) {
+			pos = CHAR_MAP[cc](input, pos, callbacks);
+		} else {
+			pos++;
 		}
+	}
+};
 
-		// We are in state B
-		const { lazyName } = this;
-		let timeMessage;
-		if (lazyName) {
-			// only log once
-			this.lazyName = undefined;
-			timeMessage = `restore cache content ${lazyName} (${formatSize(
-				this.getSize()
-			)})`;
-			this.logger.log(
-				`starting to restore cache content ${lazyName} (${formatSize(
-					this.getSize()
-				)}) because of request to: ${identifier}`
-			);
-			this.logger.time(timeMessage);
-		}
-		const value = this.lazy();
-		if ("then" in value) {
-			return value.then(data => {
-				const map = data.map;
-				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
+module.exports.eatComments = (input, pos) => {
+	loop: for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_SLASH) {
+			if (pos === input.length) return pos;
+			let cc = input.charCodeAt(pos + 1);
+			if (cc !== CC_ASTERISK) return pos;
+			pos++;
+			for (;;) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+				while (cc === CC_ASTERISK) {
+					pos++;
+					if (pos === input.length) return pos;
+					cc = input.charCodeAt(pos);
+					if (cc === CC_SLASH) {
+						pos++;
+						continue loop;
+					}
 				}
-				// Move to state C
-				this.content = map;
-				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
-				return map.get(identifier);
-			});
-		} else {
-			const map = value.map;
-			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
 			}
-			// Move to state C
-			this.content = map;
-			this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
-			return map.get(identifier);
 		}
+		return pos;
 	}
+};
 
-	/**
-	 * @param {string} reason explanation why unpack is necessary
-	 * @returns {void | Promise} maybe a promise if lazy
-	 */
-	unpack(reason) {
-		if (this.content) return;
-
-		// Move from state B to C
-		if (this.lazy) {
-			const { lazyName } = this;
-			let timeMessage;
-			if (lazyName) {
-				// only log once
-				this.lazyName = undefined;
-				timeMessage = `unpack cache content ${lazyName} (${formatSize(
-					this.getSize()
-				)})`;
-				this.logger.log(
-					`starting to unpack cache content ${lazyName} (${formatSize(
-						this.getSize()
-					)}) because ${reason}`
-				);
-				this.logger.time(timeMessage);
-			}
-			const value = this.lazy();
-			if ("then" in value) {
-				return value.then(data => {
-					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
+module.exports.eatWhitespaceAndComments = (input, pos) => {
+	loop: for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (cc === CC_SLASH) {
+			if (pos === input.length) return pos;
+			let cc = input.charCodeAt(pos + 1);
+			if (cc !== CC_ASTERISK) return pos;
+			pos++;
+			for (;;) {
+				pos++;
+				if (pos === input.length) return pos;
+				cc = input.charCodeAt(pos);
+				while (cc === CC_ASTERISK) {
+					pos++;
+					if (pos === input.length) return pos;
+					cc = input.charCodeAt(pos);
+					if (cc === CC_SLASH) {
+						pos++;
+						continue loop;
 					}
-					this.content = data.map;
-				});
-			} else {
-				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
 				}
-				this.content = value.map;
 			}
+		} else if (_isWhiteSpace(cc)) {
+			pos++;
+			continue;
 		}
+		return pos;
 	}
+};
 
-	/**
-	 * @returns {number} size of the content or -1 if not known
-	 */
-	getSize() {
-		if (!this.lazy) return -1;
-		const options = /** @type {any} */ (this.lazy).options;
-		if (!options) return -1;
-		const size = options.size;
-		if (typeof size !== "number") return -1;
-		return size;
+
+/***/ }),
+
+/***/ 2757:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const { Tracer } = __webpack_require__(5787);
+const createSchemaValidation = __webpack_require__(32540);
+const { dirname, mkdirpSync } = __webpack_require__(17139);
+
+/** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+
+const validate = createSchemaValidation(
+	__webpack_require__(37134),
+	() => __webpack_require__(50686),
+	{
+		name: "Profiling Plugin",
+		baseDataPath: "options"
 	}
+);
+let inspector = undefined;
 
-	delete(identifier) {
-		this.items.delete(identifier);
-		this.used.delete(identifier);
-		this.outdated = true;
+try {
+	// eslint-disable-next-line node/no-unsupported-features/node-builtins
+	inspector = __webpack_require__(31405);
+} catch (e) {
+	console.log("Unable to CPU profile in < node 8.0");
+}
+
+class Profiler {
+	constructor(inspector) {
+		this.session = undefined;
+		this.inspector = inspector;
+		this._startTime = 0;
 	}
 
-	/**
-	 * @template T
-	 * @param {function(any): function(): Promise<PackContentItems> | PackContentItems} write write function
-	 * @returns {void}
-	 */
-	writeLazy(write) {
-		if (!this.outdated && this.lazy) {
-			// State B1 or C1
-			// this.lazy is still the valid deserialized version
-			write(this.lazy);
-			return;
-		}
-		if (!this.outdated && this.content) {
-			// State A1
-			const map = new Map(this.content);
-			// Move to state C1
-			this.lazy = SerializerMiddleware.unMemoizeLazy(
-				write(() => new PackContentItems(map))
-			);
-			return;
-		}
-		if (this.content) {
-			// State A2 or C2
-			/** @type {Map<string, any>} */
-			const map = new Map();
-			for (const item of this.items) {
-				map.set(item, this.content.get(item));
-			}
-			// Move to state C1
-			this.outdated = false;
-			this.content = map;
-			this.lazy = SerializerMiddleware.unMemoizeLazy(
-				write(() => new PackContentItems(map))
-			);
-			return;
+	hasSession() {
+		return this.session !== undefined;
+	}
+
+	startProfiling() {
+		if (this.inspector === undefined) {
+			return Promise.resolve();
 		}
-		// State B2
-		const { lazyName } = this;
-		let timeMessage;
-		if (lazyName) {
-			// only log once
-			this.lazyName = undefined;
-			timeMessage = `unpack cache content ${lazyName} (${formatSize(
-				this.getSize()
-			)})`;
-			this.logger.log(
-				`starting to unpack cache content ${lazyName} (${formatSize(
-					this.getSize()
-				)}) because it's outdated and need to be serialized`
-			);
-			this.logger.time(timeMessage);
+
+		try {
+			this.session = new inspector.Session();
+			this.session.connect();
+		} catch (_) {
+			this.session = undefined;
+			return Promise.resolve();
 		}
-		const value = this.lazy();
-		this.outdated = false;
-		if ("then" in value) {
-			// Move to state B1
-			this.lazy = write(() =>
-				value.then(data => {
-					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
-					}
-					const oldMap = data.map;
-					/** @type {Map<string, any>} */
-					const map = new Map();
-					for (const item of this.items) {
-						map.set(item, oldMap.get(item));
-					}
-					// Move to state C1 (or maybe C2)
-					this.content = map;
-					this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 
-					return new PackContentItems(map);
-				})
-			);
+		const hrtime = process.hrtime();
+		this._startTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+
+		return Promise.all([
+			this.sendCommand("Profiler.setSamplingInterval", {
+				interval: 100
+			}),
+			this.sendCommand("Profiler.enable"),
+			this.sendCommand("Profiler.start")
+		]);
+	}
+
+	sendCommand(method, params) {
+		if (this.hasSession()) {
+			return new Promise((res, rej) => {
+				return this.session.post(method, params, (err, params) => {
+					if (err !== null) {
+						rej(err);
+					} else {
+						res(params);
+					}
+				});
+			});
 		} else {
-			// Move to state C1
-			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
-			}
-			const oldMap = value.map;
-			/** @type {Map<string, any>} */
-			const map = new Map();
-			for (const item of this.items) {
-				map.set(item, oldMap.get(item));
-			}
-			this.content = map;
-			this.lazy = write(() => new PackContentItems(map));
+			return Promise.resolve();
 		}
 	}
-}
 
-const allowCollectingMemory = buf => {
-	const wasted = buf.buffer.byteLength - buf.byteLength;
-	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
-		return Buffer.from(buf);
+	destroy() {
+		if (this.hasSession()) {
+			this.session.disconnect();
+		}
+
+		return Promise.resolve();
 	}
-	return buf;
-};
 
-class PackFileCacheStrategy {
-	/**
-	 * @param {Object} options options
-	 * @param {Compiler} options.compiler the compiler
-	 * @param {IntermediateFileSystem} options.fs the filesystem
-	 * @param {string} options.context the context directory
-	 * @param {string} options.cacheLocation the location of the cache data
-	 * @param {string} options.version version identifier
-	 * @param {Logger} options.logger a logger
-	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
-	 * @param {number} options.maxAge max age of cache items
-	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
-	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
-	 * @param {false | "gzip" | "brotli"} options.compression compression used
-	 */
-	constructor({
-		compiler,
-		fs,
-		context,
-		cacheLocation,
-		version,
-		logger,
-		snapshot,
-		maxAge,
-		profile,
-		allowCollectingMemory,
-		compression
-	}) {
-		this.fileSerializer = createFileSerializer(
-			fs,
-			compiler.options.output.hashFunction
-		);
-		this.fileSystemInfo = new FileSystemInfo(fs, {
-			managedPaths: snapshot.managedPaths,
-			immutablePaths: snapshot.immutablePaths,
-			logger: logger.getChildLogger("webpack.FileSystemInfo"),
-			hashFunction: compiler.options.output.hashFunction
+	stopProfiling() {
+		return this.sendCommand("Profiler.stop").then(({ profile }) => {
+			const hrtime = process.hrtime();
+			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+			if (profile.startTime < this._startTime || profile.endTime > endTime) {
+				// In some cases timestamps mismatch and we need to adjust them
+				// Both process.hrtime and the inspector timestamps claim to be relative
+				// to a unknown point in time. But they do not guarantee that this is the
+				// same point in time.
+				const duration = profile.endTime - profile.startTime;
+				const ownDuration = endTime - this._startTime;
+				const untracked = Math.max(0, ownDuration - duration);
+				profile.startTime = this._startTime + untracked / 2;
+				profile.endTime = endTime - untracked / 2;
+			}
+			return { profile };
 		});
-		this.compiler = compiler;
-		this.context = context;
-		this.cacheLocation = cacheLocation;
-		this.version = version;
-		this.logger = logger;
-		this.maxAge = maxAge;
-		this.profile = profile;
-		this.allowCollectingMemory = allowCollectingMemory;
-		this.compression = compression;
-		this._extension =
-			compression === "brotli"
-				? ".pack.br"
-				: compression === "gzip"
-				? ".pack.gz"
-				: ".pack";
-		this.snapshot = snapshot;
-		/** @type {Set<string>} */
-		this.buildDependencies = new Set();
-		/** @type {LazySet<string>} */
-		this.newBuildDependencies = new LazySet();
-		/** @type {Snapshot} */
-		this.resolveBuildDependenciesSnapshot = undefined;
-		/** @type {Map<string, string | false>} */
-		this.resolveResults = undefined;
-		/** @type {Snapshot} */
-		this.buildSnapshot = undefined;
-		/** @type {Promise<Pack>} */
-		this.packPromise = this._openPack();
-		this.storePromise = Promise.resolve();
 	}
+}
 
-	_getPack() {
-		if (this.packPromise === undefined) {
-			this.packPromise = this.storePromise.then(() => this._openPack());
-		}
-		return this.packPromise;
+/**
+ * an object that wraps Tracer and Profiler with a counter
+ * @typedef {Object} Trace
+ * @property {Tracer} trace instance of Tracer
+ * @property {number} counter Counter
+ * @property {Profiler} profiler instance of Profiler
+ * @property {Function} end the end function
+ */
+
+/**
+ * @param {IntermediateFileSystem} fs filesystem used for output
+ * @param {string} outputPath The location where to write the log.
+ * @returns {Trace} The trace object
+ */
+const createTrace = (fs, outputPath) => {
+	const trace = new Tracer();
+	const profiler = new Profiler(inspector);
+	if (/\/|\\/.test(outputPath)) {
+		const dirPath = dirname(fs, outputPath);
+		mkdirpSync(fs, dirPath);
 	}
+	const fsStream = fs.createWriteStream(outputPath);
 
-	/**
-	 * @returns {Promise<Pack>} the pack
-	 */
-	_openPack() {
-		const { logger, profile, cacheLocation, version } = this;
-		/** @type {Snapshot} */
-		let buildSnapshot;
-		/** @type {Set<string>} */
-		let buildDependencies;
-		/** @type {Set<string>} */
-		let newBuildDependencies;
-		/** @type {Snapshot} */
-		let resolveBuildDependenciesSnapshot;
-		/** @type {Map<string, string | false>} */
-		let resolveResults;
-		logger.time("restore cache container");
-		return this.fileSerializer
-			.deserialize(null, {
-				filename: `${cacheLocation}/index${this._extension}`,
-				extension: `${this._extension}`,
-				logger,
-				profile,
-				retainedBuffer: this.allowCollectingMemory
-					? allowCollectingMemory
-					: undefined
-			})
-			.catch(err => {
-				if (err.code !== "ENOENT") {
-					logger.warn(
-						`Restoring pack failed from ${cacheLocation}${this._extension}: ${err}`
-					);
-					logger.debug(err.stack);
-				} else {
-					logger.debug(
-						`No pack exists at ${cacheLocation}${this._extension}: ${err}`
-					);
-				}
-				return undefined;
-			})
-			.then(packContainer => {
-				logger.timeEnd("restore cache container");
-				if (!packContainer) return undefined;
-				if (!(packContainer instanceof PackContainer)) {
-					logger.warn(
-						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
-						packContainer
-					);
-					return undefined;
-				}
-				if (packContainer.version !== version) {
-					logger.log(
-						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
-					);
-					return undefined;
-				}
-				logger.time("check build dependencies");
-				return Promise.all([
-					new Promise((resolve, reject) => {
-						this.fileSystemInfo.checkSnapshotValid(
-							packContainer.buildSnapshot,
-							(err, valid) => {
-								if (err) {
-									logger.log(
-										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of build dependencies errored: ${err}.`
-									);
-									logger.debug(err.stack);
-									return resolve(false);
-								}
-								if (!valid) {
-									logger.log(
-										`Restored pack from ${cacheLocation}${this._extension}, but build dependencies have changed.`
-									);
-									return resolve(false);
-								}
-								buildSnapshot = packContainer.buildSnapshot;
-								return resolve(true);
-							}
-						);
-					}),
-					new Promise((resolve, reject) => {
-						this.fileSystemInfo.checkSnapshotValid(
-							packContainer.resolveBuildDependenciesSnapshot,
-							(err, valid) => {
-								if (err) {
-									logger.log(
-										`Restored pack from ${cacheLocation}${this._extension}, but checking snapshot of resolving of build dependencies errored: ${err}.`
-									);
-									logger.debug(err.stack);
-									return resolve(false);
-								}
-								if (valid) {
-									resolveBuildDependenciesSnapshot =
-										packContainer.resolveBuildDependenciesSnapshot;
-									buildDependencies = packContainer.buildDependencies;
-									resolveResults = packContainer.resolveResults;
-									return resolve(true);
-								}
-								logger.log(
-									"resolving of build dependencies is invalid, will re-resolve build dependencies"
-								);
-								this.fileSystemInfo.checkResolveResultsValid(
-									packContainer.resolveResults,
-									(err, valid) => {
-										if (err) {
-											logger.log(
-												`Restored pack from ${cacheLocation}${this._extension}, but resolving of build dependencies errored: ${err}.`
-											);
-											logger.debug(err.stack);
-											return resolve(false);
-										}
-										if (valid) {
-											newBuildDependencies = packContainer.buildDependencies;
-											resolveResults = packContainer.resolveResults;
-											return resolve(true);
-										}
-										logger.log(
-											`Restored pack from ${cacheLocation}${this._extension}, but build dependencies resolve to different locations.`
-										);
-										return resolve(false);
-									}
-								);
-							}
-						);
-					})
-				])
-					.catch(err => {
-						logger.timeEnd("check build dependencies");
-						throw err;
-					})
-					.then(([buildSnapshotValid, resolveValid]) => {
-						logger.timeEnd("check build dependencies");
-						if (buildSnapshotValid && resolveValid) {
-							logger.time("restore cache content metadata");
-							const d = packContainer.data();
-							logger.timeEnd("restore cache content metadata");
-							return d;
-						}
-						return undefined;
-					});
-			})
-			.then(pack => {
-				if (pack) {
-					pack.maxAge = this.maxAge;
-					this.buildSnapshot = buildSnapshot;
-					if (buildDependencies) this.buildDependencies = buildDependencies;
-					if (newBuildDependencies)
-						this.newBuildDependencies.addAll(newBuildDependencies);
-					this.resolveResults = resolveResults;
-					this.resolveBuildDependenciesSnapshot =
-						resolveBuildDependenciesSnapshot;
-					return pack;
-				}
-				return new Pack(logger, this.maxAge);
-			})
-			.catch(err => {
-				this.logger.warn(
-					`Restoring pack from ${cacheLocation}${this._extension} failed: ${err}`
-				);
-				this.logger.debug(err.stack);
-				return new Pack(logger, this.maxAge);
+	let counter = 0;
+
+	trace.pipe(fsStream);
+	// These are critical events that need to be inserted so that tools like
+	// chrome dev tools can load the profile.
+	trace.instantEvent({
+		name: "TracingStartedInPage",
+		id: ++counter,
+		cat: ["disabled-by-default-devtools.timeline"],
+		args: {
+			data: {
+				sessionId: "-1",
+				page: "0xfff",
+				frames: [
+					{
+						frame: "0xfff",
+						url: "webpack",
+						name: ""
+					}
+				]
+			}
+		}
+	});
+
+	trace.instantEvent({
+		name: "TracingStartedInBrowser",
+		id: ++counter,
+		cat: ["disabled-by-default-devtools.timeline"],
+		args: {
+			data: {
+				sessionId: "-1"
+			}
+		}
+	});
+
+	return {
+		trace,
+		counter,
+		profiler,
+		end: callback => {
+			trace.push("]");
+			// Wait until the write stream finishes.
+			fsStream.on("close", () => {
+				callback();
 			});
-	}
+			// Tear down the readable trace stream.
+			trace.push(null);
+		}
+	};
+};
 
-	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {Etag | null} etag etag of the resource
-	 * @param {any} data cached content
-	 * @returns {Promise<void>} promise
-	 */
-	store(identifier, etag, data) {
-		return this._getPack().then(pack => {
-			pack.set(identifier, etag === null ? null : etag.toString(), data);
-		});
-	}
+const pluginName = "ProfilingPlugin";
 
+class ProfilingPlugin {
 	/**
-	 * @param {string} identifier unique name for the resource
-	 * @param {Etag | null} etag etag of the resource
-	 * @returns {Promise<any>} promise to the cached content
+	 * @param {ProfilingPluginOptions=} options options object
 	 */
-	restore(identifier, etag) {
-		return this._getPack()
-			.then(pack =>
-				pack.get(identifier, etag === null ? null : etag.toString())
-			)
-			.catch(err => {
-				if (err && err.code !== "ENOENT") {
-					this.logger.warn(
-						`Restoring failed for ${identifier} from pack: ${err}`
-					);
-					this.logger.debug(err.stack);
-				}
-			});
+	constructor(options = {}) {
+		validate(options);
+		this.outputPath = options.outputPath || "events.json";
 	}
 
-	storeBuildDependencies(dependencies) {
-		this.newBuildDependencies.addAll(dependencies);
-	}
+	apply(compiler) {
+		const tracer = createTrace(
+			compiler.intermediateFileSystem,
+			this.outputPath
+		);
+		tracer.profiler.startProfiling();
 
-	afterAllStored() {
-		const packPromise = this.packPromise;
-		if (packPromise === undefined) return Promise.resolve();
-		const reportProgress = ProgressPlugin.getReporter(this.compiler);
-		return (this.storePromise = packPromise
-			.then(pack => {
-				pack.stopCapturingRequests();
-				if (!pack.invalid) return;
-				this.packPromise = undefined;
-				this.logger.log(`Storing pack...`);
-				let promise;
-				const newBuildDependencies = new Set();
-				for (const dep of this.newBuildDependencies) {
-					if (!this.buildDependencies.has(dep)) {
-						newBuildDependencies.add(dep);
+		// Compiler Hooks
+		Object.keys(compiler.hooks).forEach(hookName => {
+			const hook = compiler.hooks[hookName];
+			if (hook) {
+				hook.intercept(makeInterceptorFor("Compiler", tracer)(hookName));
+			}
+		});
+
+		Object.keys(compiler.resolverFactory.hooks).forEach(hookName => {
+			const hook = compiler.resolverFactory.hooks[hookName];
+			if (hook) {
+				hook.intercept(makeInterceptorFor("Resolver", tracer)(hookName));
+			}
+		});
+
+		compiler.hooks.compilation.tap(
+			pluginName,
+			(compilation, { normalModuleFactory, contextModuleFactory }) => {
+				interceptAllHooksFor(compilation, tracer, "Compilation");
+				interceptAllHooksFor(
+					normalModuleFactory,
+					tracer,
+					"Normal Module Factory"
+				);
+				interceptAllHooksFor(
+					contextModuleFactory,
+					tracer,
+					"Context Module Factory"
+				);
+				interceptAllParserHooks(normalModuleFactory, tracer);
+				interceptAllJavascriptModulesPluginHooks(compilation, tracer);
+			}
+		);
+
+		// We need to write out the CPU profile when we are all done.
+		compiler.hooks.done.tapAsync(
+			{
+				name: pluginName,
+				stage: Infinity
+			},
+			(stats, callback) => {
+				if (compiler.watchMode) return callback();
+				tracer.profiler.stopProfiling().then(parsedResults => {
+					if (parsedResults === undefined) {
+						tracer.profiler.destroy();
+						tracer.end(callback);
+						return;
 					}
-				}
-				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
-					if (reportProgress) reportProgress(0.5, "resolve build dependencies");
-					this.logger.debug(
-						`Capturing build dependencies... (${Array.from(
-							newBuildDependencies
-						).join(", ")})`
-					);
-					promise = new Promise((resolve, reject) => {
-						this.logger.time("resolve build dependencies");
-						this.fileSystemInfo.resolveBuildDependencies(
-							this.context,
-							newBuildDependencies,
-							(err, result) => {
-								this.logger.timeEnd("resolve build dependencies");
-								if (err) return reject(err);
 
-								this.logger.time("snapshot build dependencies");
-								const {
-									files,
-									directories,
-									missing,
-									resolveResults,
-									resolveDependencies
-								} = result;
-								if (this.resolveResults) {
-									for (const [key, value] of resolveResults) {
-										this.resolveResults.set(key, value);
-									}
-								} else {
-									this.resolveResults = resolveResults;
-								}
-								if (reportProgress) {
-									reportProgress(
-										0.6,
-										"snapshot build dependencies",
-										"resolving"
-									);
-								}
-								this.fileSystemInfo.createSnapshot(
-									undefined,
-									resolveDependencies.files,
-									resolveDependencies.directories,
-									resolveDependencies.missing,
-									this.snapshot.resolveBuildDependencies,
-									(err, snapshot) => {
-										if (err) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(err);
-										}
-										if (!snapshot) {
-											this.logger.timeEnd("snapshot build dependencies");
-											return reject(
-												new Error("Unable to snapshot resolve dependencies")
-											);
-										}
-										if (this.resolveBuildDependenciesSnapshot) {
-											this.resolveBuildDependenciesSnapshot =
-												this.fileSystemInfo.mergeSnapshots(
-													this.resolveBuildDependenciesSnapshot,
-													snapshot
-												);
-										} else {
-											this.resolveBuildDependenciesSnapshot = snapshot;
-										}
-										if (reportProgress) {
-											reportProgress(
-												0.7,
-												"snapshot build dependencies",
-												"modules"
-											);
-										}
-										this.fileSystemInfo.createSnapshot(
-											undefined,
-											files,
-											directories,
-											missing,
-											this.snapshot.buildDependencies,
-											(err, snapshot) => {
-												this.logger.timeEnd("snapshot build dependencies");
-												if (err) return reject(err);
-												if (!snapshot) {
-													return reject(
-														new Error("Unable to snapshot build dependencies")
-													);
-												}
-												this.logger.debug("Captured build dependencies");
+					const cpuStartTime = parsedResults.profile.startTime;
+					const cpuEndTime = parsedResults.profile.endTime;
 
-												if (this.buildSnapshot) {
-													this.buildSnapshot =
-														this.fileSystemInfo.mergeSnapshots(
-															this.buildSnapshot,
-															snapshot
-														);
-												} else {
-													this.buildSnapshot = snapshot;
-												}
+					tracer.trace.completeEvent({
+						name: "TaskQueueManager::ProcessTaskFromWorkQueue",
+						id: ++tracer.counter,
+						cat: ["toplevel"],
+						ts: cpuStartTime,
+						args: {
+							src_file: "../../ipc/ipc_moji_bootstrap.cc",
+							src_func: "Accept"
+						}
+					});
 
-												resolve();
-											}
-										);
-									}
-								);
+					tracer.trace.completeEvent({
+						name: "EvaluateScript",
+						id: ++tracer.counter,
+						cat: ["devtools.timeline"],
+						ts: cpuStartTime,
+						dur: cpuEndTime - cpuStartTime,
+						args: {
+							data: {
+								url: "webpack",
+								lineNumber: 1,
+								columnNumber: 1,
+								frame: "0xFFF"
 							}
-						);
+						}
 					});
-				} else {
-					promise = Promise.resolve();
-				}
-				return promise.then(() => {
-					if (reportProgress) reportProgress(0.8, "serialize pack");
-					this.logger.time(`store pack`);
-					const updatedBuildDependencies = new Set(this.buildDependencies);
-					for (const dep of newBuildDependencies) {
-						updatedBuildDependencies.add(dep);
-					}
-					const content = new PackContainer(
-						pack,
-						this.version,
-						this.buildSnapshot,
-						updatedBuildDependencies,
-						this.resolveResults,
-						this.resolveBuildDependenciesSnapshot
-					);
-					return this.fileSerializer
-						.serialize(content, {
-							filename: `${this.cacheLocation}/index${this._extension}`,
-							extension: `${this._extension}`,
-							logger: this.logger,
-							profile: this.profile
-						})
-						.then(() => {
-							for (const dep of newBuildDependencies) {
-								this.buildDependencies.add(dep);
+
+					tracer.trace.instantEvent({
+						name: "CpuProfile",
+						id: ++tracer.counter,
+						cat: ["disabled-by-default-devtools.timeline"],
+						ts: cpuEndTime,
+						args: {
+							data: {
+								cpuProfile: parsedResults.profile
 							}
-							this.newBuildDependencies.clear();
-							this.logger.timeEnd(`store pack`);
-							const stats = pack.getContentStats();
-							this.logger.log(
-								"Stored pack (%d items, %d files, %d MiB)",
-								pack.itemInfo.size,
-								stats.count,
-								Math.round(stats.size / 1024 / 1024)
-							);
-						})
-						.catch(err => {
-							this.logger.timeEnd(`store pack`);
-							this.logger.warn(`Caching failed for pack: ${err}`);
-							this.logger.debug(err.stack);
-						});
-				});
-			})
-			.catch(err => {
-				this.logger.warn(`Caching failed for pack: ${err}`);
-				this.logger.debug(err.stack);
-			}));
-	}
+						}
+					});
 
-	clear() {
-		this.fileSystemInfo.clear();
-		this.buildDependencies.clear();
-		this.newBuildDependencies.clear();
-		this.resolveBuildDependenciesSnapshot = undefined;
-		this.resolveResults = undefined;
-		this.buildSnapshot = undefined;
-		this.packPromise = undefined;
+					tracer.profiler.destroy();
+					tracer.end(callback);
+				});
+			}
+		);
 	}
 }
 
-module.exports = PackFileCacheStrategy;
+const interceptAllHooksFor = (instance, tracer, logLabel) => {
+	if (Reflect.has(instance, "hooks")) {
+		Object.keys(instance.hooks).forEach(hookName => {
+			const hook = instance.hooks[hookName];
+			if (hook && !hook._fakeHook) {
+				hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
+			}
+		});
+	}
+};
+
+const interceptAllParserHooks = (moduleFactory, tracer) => {
+	const moduleTypes = [
+		"javascript/auto",
+		"javascript/dynamic",
+		"javascript/esm",
+		"json",
+		"webassembly/async",
+		"webassembly/sync"
+	];
+
+	moduleTypes.forEach(moduleType => {
+		moduleFactory.hooks.parser
+			.for(moduleType)
+			.tap("ProfilingPlugin", (parser, parserOpts) => {
+				interceptAllHooksFor(parser, tracer, "Parser");
+			});
+	});
+};
+
+const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
+	interceptAllHooksFor(
+		{
+			hooks:
+				(__webpack_require__(89464).getCompilationHooks)(
+					compilation
+				)
+		},
+		tracer,
+		"JavascriptModulesPlugin"
+	);
+};
+
+const makeInterceptorFor = (instance, tracer) => hookName => ({
+	register: ({ name, type, context, fn }) => {
+		const newFn =
+			// Don't tap our own hooks to ensure stream can close cleanly
+			name === pluginName
+				? fn
+				: makeNewProfiledTapFn(hookName, tracer, {
+						name,
+						type,
+						fn
+				  });
+		return {
+			name,
+			type,
+			context,
+			fn: newFn
+		};
+	}
+});
+
+// TODO improve typing
+/** @typedef {(...args: TODO[]) => void | Promise<TODO>} PluginFunction */
+
+/**
+ * @param {string} hookName Name of the hook to profile.
+ * @param {Trace} tracer The trace object.
+ * @param {object} options Options for the profiled fn.
+ * @param {string} options.name Plugin name
+ * @param {string} options.type Plugin type (sync | async | promise)
+ * @param {PluginFunction} options.fn Plugin function
+ * @returns {PluginFunction} Chainable hooked function.
+ */
+const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
+	const defaultCategory = ["blink.user_timing"];
+
+	switch (type) {
+		case "promise":
+			return (...args) => {
+				const id = ++tracer.counter;
+				tracer.trace.begin({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				const promise = /** @type {Promise<*>} */ (fn(...args));
+				return promise.then(r => {
+					tracer.trace.end({
+						name,
+						id,
+						cat: defaultCategory
+					});
+					return r;
+				});
+			};
+		case "async":
+			return (...args) => {
+				const id = ++tracer.counter;
+				tracer.trace.begin({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				const callback = args.pop();
+				fn(...args, (...r) => {
+					tracer.trace.end({
+						name,
+						id,
+						cat: defaultCategory
+					});
+					callback(...r);
+				});
+			};
+		case "sync":
+			return (...args) => {
+				const id = ++tracer.counter;
+				// Do not instrument ourself due to the CPU
+				// profile needing to be the last event in the trace.
+				if (name === pluginName) {
+					return fn(...args);
+				}
+
+				tracer.trace.begin({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				let r;
+				try {
+					r = fn(...args);
+				} catch (error) {
+					tracer.trace.end({
+						name,
+						id,
+						cat: defaultCategory
+					});
+					throw error;
+				}
+				tracer.trace.end({
+					name,
+					id,
+					cat: defaultCategory
+				});
+				return r;
+			};
+		default:
+			break;
+	}
+};
+
+module.exports = ProfilingPlugin;
+module.exports.Profiler = Profiler;
 
 
 /***/ }),
 
-/***/ 97347:
+/***/ 96816:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -69760,297 +70761,587 @@ module.exports = PackFileCacheStrategy;
 
 
 
-const LazySet = __webpack_require__(38938);
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
-/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class CacheEntry {
-	constructor(result, snapshot) {
-		this.result = result;
-		this.snapshot = snapshot;
+/** @type {Record<string, { definition: string, content: string, requests: string[] }>} */
+const DEFINITIONS = {
+	f: {
+		definition: "var __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_RESULT__ = (#).call(exports, __webpack_require__, exports, module),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [
+			RuntimeGlobals.require,
+			RuntimeGlobals.exports,
+			RuntimeGlobals.module
+		]
+	},
+	o: {
+		definition: "",
+		content: "!(module.exports = #)",
+		requests: [RuntimeGlobals.module]
+	},
+	of: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
+		__WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [
+			RuntimeGlobals.require,
+			RuntimeGlobals.exports,
+			RuntimeGlobals.module
+		]
+	},
+	af: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_RESULT__ = (#).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
+	},
+	ao: {
+		definition: "",
+		content: "!(#, module.exports = #)",
+		requests: [RuntimeGlobals.module]
+	},
+	aof: {
+		definition:
+			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
+		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#),
+		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
+		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
+		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
+	},
+	lf: {
+		definition: "var XXX, XXXmodule;",
+		content:
+			"!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = (#).call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))",
+		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
+	},
+	lo: {
+		definition: "var XXX;",
+		content: "!(XXX = #)",
+		requests: []
+	},
+	lof: {
+		definition: "var XXX, XXXfactory, XXXmodule;",
+		content:
+			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))",
+		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
+	},
+	laf: {
+		definition: "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX, XXXexports;",
+		content:
+			"!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#).apply(XXXexports = {}, __WEBPACK_AMD_DEFINE_ARRAY__), XXX === undefined && (XXX = XXXexports))",
+		requests: []
+	},
+	lao: {
+		definition: "var XXX;",
+		content: "!(#, XXX = #)",
+		requests: []
+	},
+	laof: {
+		definition: "var XXXarray, XXXfactory, XXXexports, XXX;",
+		content: `!(XXXarray = #, XXXfactory = (#),
+		(typeof XXXfactory === 'function' ?
+			((XXX = XXXfactory.apply(XXXexports = {}, XXXarray)), XXX === undefined && (XXX = XXXexports)) :
+			(XXX = XXXfactory)
+		))`,
+		requests: []
 	}
+};
 
-	serialize({ write }) {
-		write(this.result);
-		write(this.snapshot);
+class AMDDefineDependency extends NullDependency {
+	constructor(range, arrayRange, functionRange, objectRange, namedModule) {
+		super();
+		this.range = range;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.objectRange = objectRange;
+		this.namedModule = namedModule;
+		this.localModule = null;
 	}
 
-	deserialize({ read }) {
-		this.result = read();
-		this.snapshot = read();
+	get type() {
+		return "amd define";
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.objectRange);
+		write(this.namedModule);
+		write(this.localModule);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.objectRange = read();
+		this.namedModule = read();
+		this.localModule = read();
+		super.deserialize(context);
 	}
 }
 
-makeSerializable(CacheEntry, "webpack/lib/cache/ResolverCachePlugin");
+makeSerializable(
+	AMDDefineDependency,
+	"webpack/lib/dependencies/AMDDefineDependency"
+);
 
-/**
- * @template T
- * @param {Set<T> | LazySet<T>} set set to add items to
- * @param {Set<T> | LazySet<T>} otherSet set to add items from
- * @returns {void}
- */
-const addAllToSet = (set, otherSet) => {
-	if (set instanceof LazySet) {
-		set.addAll(otherSet);
-	} else {
-		for (const item of otherSet) {
-			set.add(item);
+AMDDefineDependency.Template = class AMDDefineDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {AMDDefineDependency} */ (dependency);
+		const branch = this.branch(dep);
+		const { definition, content, requests } = DEFINITIONS[branch];
+		for (const req of requests) {
+			runtimeRequirements.add(req);
 		}
+		this.replace(dep, source, definition, content);
 	}
-};
 
-/**
- * @param {Object} object an object
- * @param {boolean} excludeContext if true, context is not included in string
- * @returns {string} stringified version
- */
-const objectToString = (object, excludeContext) => {
-	let str = "";
-	for (const key in object) {
-		if (excludeContext && key === "context") continue;
-		const value = object[key];
-		if (typeof value === "object" && value !== null) {
-			str += `|${key}=[${objectToString(value, false)}|]`;
-		} else {
-			str += `|${key}=|${value}`;
+	localModuleVar(dependency) {
+		return (
+			dependency.localModule &&
+			dependency.localModule.used &&
+			dependency.localModule.variableName()
+		);
+	}
+
+	branch(dependency) {
+		const localModuleVar = this.localModuleVar(dependency) ? "l" : "";
+		const arrayRange = dependency.arrayRange ? "a" : "";
+		const objectRange = dependency.objectRange ? "o" : "";
+		const functionRange = dependency.functionRange ? "f" : "";
+		return localModuleVar + arrayRange + objectRange + functionRange;
+	}
+
+	replace(dependency, source, definition, text) {
+		const localModuleVar = this.localModuleVar(dependency);
+		if (localModuleVar) {
+			text = text.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$"));
+			definition = definition.replace(
+				/XXX/g,
+				localModuleVar.replace(/\$/g, "$$$$")
+			);
+		}
+
+		if (dependency.namedModule) {
+			text = text.replace(/YYY/g, JSON.stringify(dependency.namedModule));
+		}
+
+		const texts = text.split("#");
+
+		if (definition) source.insert(0, definition);
+
+		let current = dependency.range[0];
+		if (dependency.arrayRange) {
+			source.replace(current, dependency.arrayRange[0] - 1, texts.shift());
+			current = dependency.arrayRange[1];
+		}
+
+		if (dependency.objectRange) {
+			source.replace(current, dependency.objectRange[0] - 1, texts.shift());
+			current = dependency.objectRange[1];
+		} else if (dependency.functionRange) {
+			source.replace(current, dependency.functionRange[0] - 1, texts.shift());
+			current = dependency.functionRange[1];
 		}
+		source.replace(current, dependency.range[1] - 1, texts.shift());
+		if (texts.length > 0) throw new Error("Implementation error");
 	}
-	return str;
 };
 
-class ResolverCachePlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const cache = compiler.getCache("ResolverCachePlugin");
-		/** @type {FileSystemInfo} */
-		let fileSystemInfo;
-		let snapshotOptions;
-		let realResolves = 0;
-		let cachedResolves = 0;
-		let cacheInvalidResolves = 0;
-		let concurrentResolves = 0;
-		compiler.hooks.thisCompilation.tap("ResolverCachePlugin", compilation => {
-			snapshotOptions = compilation.options.snapshot.resolve;
-			fileSystemInfo = compilation.fileSystemInfo;
-			compilation.hooks.finishModules.tap("ResolverCachePlugin", () => {
-				if (realResolves + cachedResolves > 0) {
-					const logger = compilation.getLogger("webpack.ResolverCachePlugin");
-					logger.log(
-						`${Math.round(
-							(100 * realResolves) / (realResolves + cachedResolves)
-						)}% really resolved (${realResolves} real resolves with ${cacheInvalidResolves} cached but invalid, ${cachedResolves} cached valid, ${concurrentResolves} concurrent)`
-					);
-					realResolves = 0;
-					cachedResolves = 0;
-					cacheInvalidResolves = 0;
-					concurrentResolves = 0;
+module.exports = AMDDefineDependency;
+
+
+/***/ }),
+
+/***/ 48519:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const AMDDefineDependency = __webpack_require__(96816);
+const AMDRequireArrayDependency = __webpack_require__(33516);
+const AMDRequireContextDependency = __webpack_require__(96123);
+const AMDRequireItemDependency = __webpack_require__(71806);
+const ConstDependency = __webpack_require__(76911);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const DynamicExports = __webpack_require__(32006);
+const LocalModuleDependency = __webpack_require__(52805);
+const { addLocalModule, getLocalModule } = __webpack_require__(75827);
+
+const isBoundFunctionExpression = expr => {
+	if (expr.type !== "CallExpression") return false;
+	if (expr.callee.type !== "MemberExpression") return false;
+	if (expr.callee.computed) return false;
+	if (expr.callee.object.type !== "FunctionExpression") return false;
+	if (expr.callee.property.type !== "Identifier") return false;
+	if (expr.callee.property.name !== "bind") return false;
+	return true;
+};
+
+const isUnboundFunctionExpression = expr => {
+	if (expr.type === "FunctionExpression") return true;
+	if (expr.type === "ArrowFunctionExpression") return true;
+	return false;
+};
+
+const isCallable = expr => {
+	if (isUnboundFunctionExpression(expr)) return true;
+	if (isBoundFunctionExpression(expr)) return true;
+	return false;
+};
+
+class AMDDefineDependencyParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	apply(parser) {
+		parser.hooks.call
+			.for("define")
+			.tap(
+				"AMDDefineDependencyParserPlugin",
+				this.processCallDefine.bind(this, parser)
+			);
+	}
+
+	processArray(parser, expr, param, identifiers, namedModule) {
+		if (param.isArray()) {
+			param.items.forEach((param, idx) => {
+				if (
+					param.isString() &&
+					["require", "module", "exports"].includes(param.string)
+				)
+					identifiers[idx] = param.string;
+				const result = this.processItem(parser, expr, param, namedModule);
+				if (result === undefined) {
+					this.processContext(parser, expr, param);
 				}
 			});
-		});
-		/**
-		 * @param {ItemCacheFacade} itemCache cache
-		 * @param {Resolver} resolver the resolver
-		 * @param {Object} resolveContext context for resolving meta info
-		 * @param {Object} request the request info object
-		 * @param {function((Error | null)=, Object=): void} callback callback function
-		 * @returns {void}
-		 */
-		const doRealResolve = (
-			itemCache,
-			resolver,
-			resolveContext,
-			request,
-			callback
-		) => {
-			realResolves++;
-			const newRequest = {
-				_ResolverCachePluginCacheMiss: true,
-				...request
-			};
-			const newResolveContext = {
-				...resolveContext,
-				stack: new Set(),
-				missingDependencies: new LazySet(),
-				fileDependencies: new LazySet(),
-				contextDependencies: new LazySet()
-			};
-			const propagate = key => {
-				if (resolveContext[key]) {
-					addAllToSet(resolveContext[key], newResolveContext[key]);
+			return true;
+		} else if (param.isConstArray()) {
+			const deps = [];
+			param.array.forEach((request, idx) => {
+				let dep;
+				let localModule;
+				if (request === "require") {
+					identifiers[idx] = request;
+					dep = "__webpack_require__";
+				} else if (["exports", "module"].includes(request)) {
+					identifiers[idx] = request;
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = expr.loc;
+					dep.optional = !!parser.scope.inTry;
+					parser.state.current.addDependency(dep);
 				}
-			};
-			const resolveTime = Date.now();
-			resolver.doResolve(
-				resolver.hooks.resolve,
-				newRequest,
-				"Cache miss",
-				newResolveContext,
-				(err, result) => {
-					propagate("fileDependencies");
-					propagate("contextDependencies");
-					propagate("missingDependencies");
-					if (err) return callback(err);
-					const fileDependencies = newResolveContext.fileDependencies;
-					const contextDependencies = newResolveContext.contextDependencies;
-					const missingDependencies = newResolveContext.missingDependencies;
-					fileSystemInfo.createSnapshot(
-						resolveTime,
-						fileDependencies,
-						contextDependencies,
-						missingDependencies,
-						snapshotOptions,
-						(err, snapshot) => {
-							if (err) return callback(err);
-							if (!snapshot) {
-								if (result) return callback(null, result);
-								return callback();
-							}
-							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
-								if (storeErr) return callback(storeErr);
-								if (result) return callback(null, result);
-								callback();
-							});
-						}
-					);
+				deps.push(dep);
+			});
+			const dep = this.newRequireArrayDependency(deps, param.range);
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processItem(parser, expr, param, namedModule) {
+		if (param.isConditional()) {
+			param.options.forEach(param => {
+				const result = this.processItem(parser, expr, param);
+				if (result === undefined) {
+					this.processContext(parser, expr, param);
 				}
-			);
-		};
-		compiler.resolverFactory.hooks.resolver.intercept({
-			factory(type, hook) {
-				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
-				const activeRequests = new Map();
-				hook.tap(
-					"ResolverCachePlugin",
-					/**
-					 * @param {Resolver} resolver the resolver
-					 * @param {Object} options resolve options
-					 * @param {Object} userOptions resolve options passed by the user
-					 * @returns {void}
-					 */
-					(resolver, options, userOptions) => {
-						if (options.cache !== true) return;
-						const optionsIdent = objectToString(userOptions, false);
-						const cacheWithContext =
-							options.cacheWithContext !== undefined
-								? options.cacheWithContext
-								: false;
-						resolver.hooks.resolve.tapAsync(
-							{
-								name: "ResolverCachePlugin",
-								stage: -100
-							},
-							(request, resolveContext, callback) => {
-								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
-									return callback();
-								}
-								const identifier = `${type}${optionsIdent}${objectToString(
-									request,
-									!cacheWithContext
-								)}`;
-								const activeRequest = activeRequests.get(identifier);
-								if (activeRequest) {
-									activeRequest.push(callback);
-									return;
-								}
-								const itemCache = cache.getItemCache(identifier, null);
-								let callbacks;
-								const done = (err, result) => {
-									if (callbacks === undefined) {
-										callback(err, result);
-										callbacks = false;
-									} else {
-										for (const callback of callbacks) {
-											callback(err, result);
-										}
-										activeRequests.delete(identifier);
-										callbacks = false;
-									}
-								};
-								/**
-								 * @param {Error=} err error if any
-								 * @param {CacheEntry=} cacheEntry cache entry
-								 * @returns {void}
-								 */
-								const processCacheResult = (err, cacheEntry) => {
-									if (err) return done(err);
+			});
+			return true;
+		} else if (param.isString()) {
+			let dep, localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency("__webpack_require__", param.range, [
+					RuntimeGlobals.require
+				]);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency("exports", param.range, [
+					RuntimeGlobals.exports
+				]);
+			} else if (param.string === "module") {
+				dep = new ConstDependency("module", param.range, [
+					RuntimeGlobals.module
+				]);
+			} else if (
+				(localModule = getLocalModule(parser.state, param.string, namedModule))
+			) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(param.string, param.range);
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			param.range,
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
+		);
+		if (!dep) return;
+		dep.loc = expr.loc;
+		dep.optional = !!parser.scope.inTry;
+		parser.state.current.addDependency(dep);
+		return true;
+	}
 
-									if (cacheEntry) {
-										const { snapshot, result } = cacheEntry;
-										fileSystemInfo.checkSnapshotValid(
-											snapshot,
-											(err, valid) => {
-												if (err || !valid) {
-													cacheInvalidResolves++;
-													return doRealResolve(
-														itemCache,
-														resolver,
-														resolveContext,
-														request,
-														done
-													);
-												}
-												cachedResolves++;
-												if (resolveContext.missingDependencies) {
-													addAllToSet(
-														resolveContext.missingDependencies,
-														snapshot.getMissingIterable()
-													);
-												}
-												if (resolveContext.fileDependencies) {
-													addAllToSet(
-														resolveContext.fileDependencies,
-														snapshot.getFileIterable()
-													);
-												}
-												if (resolveContext.contextDependencies) {
-													addAllToSet(
-														resolveContext.contextDependencies,
-														snapshot.getContextIterable()
-													);
-												}
-												done(null, result);
-											}
-										);
-									} else {
-										doRealResolve(
-											itemCache,
-											resolver,
-											resolveContext,
-											request,
-											done
-										);
-									}
-								};
-								itemCache.get(processCacheResult);
-								if (callbacks === undefined) {
-									callbacks = [callback];
-									activeRequests.set(identifier, callbacks);
-								}
-							}
-						);
+	processCallDefine(parser, expr) {
+		let array, fn, obj, namedModule;
+		switch (expr.arguments.length) {
+			case 1:
+				if (isCallable(expr.arguments[0])) {
+					// define(f() {…})
+					fn = expr.arguments[0];
+				} else if (expr.arguments[0].type === "ObjectExpression") {
+					// define({…})
+					obj = expr.arguments[0];
+				} else {
+					// define(expr)
+					// unclear if function or object
+					obj = fn = expr.arguments[0];
+				}
+				break;
+			case 2:
+				if (expr.arguments[0].type === "Literal") {
+					namedModule = expr.arguments[0].value;
+					// define("…", …)
+					if (isCallable(expr.arguments[1])) {
+						// define("…", f() {…})
+						fn = expr.arguments[1];
+					} else if (expr.arguments[1].type === "ObjectExpression") {
+						// define("…", {…})
+						obj = expr.arguments[1];
+					} else {
+						// define("…", expr)
+						// unclear if function or object
+						obj = fn = expr.arguments[1];
 					}
-				);
-				return hook;
+				} else {
+					array = expr.arguments[0];
+					if (isCallable(expr.arguments[1])) {
+						// define([…], f() {})
+						fn = expr.arguments[1];
+					} else if (expr.arguments[1].type === "ObjectExpression") {
+						// define([…], {…})
+						obj = expr.arguments[1];
+					} else {
+						// define([…], expr)
+						// unclear if function or object
+						obj = fn = expr.arguments[1];
+					}
+				}
+				break;
+			case 3:
+				// define("…", […], f() {…})
+				namedModule = expr.arguments[0].value;
+				array = expr.arguments[1];
+				if (isCallable(expr.arguments[2])) {
+					// define("…", […], f() {})
+					fn = expr.arguments[2];
+				} else if (expr.arguments[2].type === "ObjectExpression") {
+					// define("…", […], {…})
+					obj = expr.arguments[2];
+				} else {
+					// define("…", […], expr)
+					// unclear if function or object
+					obj = fn = expr.arguments[2];
+				}
+				break;
+			default:
+				return;
+		}
+		DynamicExports.bailout(parser.state);
+		let fnParams = null;
+		let fnParamsOffset = 0;
+		if (fn) {
+			if (isUnboundFunctionExpression(fn)) {
+				fnParams = fn.params;
+			} else if (isBoundFunctionExpression(fn)) {
+				fnParams = fn.callee.object.params;
+				fnParamsOffset = fn.arguments.length - 1;
+				if (fnParamsOffset < 0) {
+					fnParamsOffset = 0;
+				}
 			}
-		});
+		}
+		let fnRenames = new Map();
+		if (array) {
+			const identifiers = {};
+			const param = parser.evaluateExpression(array);
+			const result = this.processArray(
+				parser,
+				expr,
+				param,
+				identifiers,
+				namedModule
+			);
+			if (!result) return;
+			if (fnParams) {
+				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+					if (identifiers[idx]) {
+						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
+						return false;
+					}
+					return true;
+				});
+			}
+		} else {
+			const identifiers = ["require", "exports", "module"];
+			if (fnParams) {
+				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
+					if (identifiers[idx]) {
+						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
+						return false;
+					}
+					return true;
+				});
+			}
+		}
+		let inTry;
+		if (fn && isUnboundFunctionExpression(fn)) {
+			inTry = parser.scope.inTry;
+			parser.inScope(fnParams, () => {
+				for (const [name, varInfo] of fnRenames) {
+					parser.setVariable(name, varInfo);
+				}
+				parser.scope.inTry = inTry;
+				if (fn.body.type === "BlockStatement") {
+					parser.detectMode(fn.body.body);
+					const prev = parser.prevStatement;
+					parser.preWalkStatement(fn.body);
+					parser.prevStatement = prev;
+					parser.walkStatement(fn.body);
+				} else {
+					parser.walkExpression(fn.body);
+				}
+			});
+		} else if (fn && isBoundFunctionExpression(fn)) {
+			inTry = parser.scope.inTry;
+			parser.inScope(
+				fn.callee.object.params.filter(
+					i => !["require", "module", "exports"].includes(i.name)
+				),
+				() => {
+					for (const [name, varInfo] of fnRenames) {
+						parser.setVariable(name, varInfo);
+					}
+					parser.scope.inTry = inTry;
+					if (fn.callee.object.body.type === "BlockStatement") {
+						parser.detectMode(fn.callee.object.body.body);
+						const prev = parser.prevStatement;
+						parser.preWalkStatement(fn.callee.object.body);
+						parser.prevStatement = prev;
+						parser.walkStatement(fn.callee.object.body);
+					} else {
+						parser.walkExpression(fn.callee.object.body);
+					}
+				}
+			);
+			if (fn.arguments) {
+				parser.walkExpressions(fn.arguments);
+			}
+		} else if (fn || obj) {
+			parser.walkExpression(fn || obj);
+		}
+
+		const dep = this.newDefineDependency(
+			expr.range,
+			array ? array.range : null,
+			fn ? fn.range : null,
+			obj ? obj.range : null,
+			namedModule ? namedModule : null
+		);
+		dep.loc = expr.loc;
+		if (namedModule) {
+			dep.localModule = addLocalModule(parser.state, namedModule);
+		}
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
 	}
-}
 
-module.exports = ResolverCachePlugin;
+	newDefineDependency(
+		range,
+		arrayRange,
+		functionRange,
+		objectRange,
+		namedModule
+	) {
+		return new AMDDefineDependency(
+			range,
+			arrayRange,
+			functionRange,
+			objectRange,
+			namedModule
+		);
+	}
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+}
+module.exports = AMDDefineDependencyParserPlugin;
 
 
 /***/ }),
 
-/***/ 94075:
+/***/ 50067:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -70061,86 +71352,221 @@ module.exports = ResolverCachePlugin;
 
 
 
-const createHash = __webpack_require__(49835);
+const RuntimeGlobals = __webpack_require__(16475);
+const {
+	approve,
+	evaluateToIdentifier,
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
 
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {typeof import("../util/Hash")} HashConstructor */
+const AMDDefineDependency = __webpack_require__(96816);
+const AMDDefineDependencyParserPlugin = __webpack_require__(48519);
+const AMDRequireArrayDependency = __webpack_require__(33516);
+const AMDRequireContextDependency = __webpack_require__(96123);
+const AMDRequireDependenciesBlockParserPlugin = __webpack_require__(66866);
+const AMDRequireDependency = __webpack_require__(43911);
+const AMDRequireItemDependency = __webpack_require__(71806);
+const {
+	AMDDefineRuntimeModule,
+	AMDOptionsRuntimeModule
+} = __webpack_require__(45242);
+const ConstDependency = __webpack_require__(76911);
+const LocalModuleDependency = __webpack_require__(52805);
+const UnsupportedDependency = __webpack_require__(51669);
 
-/**
- * @typedef {Object} HashableObject
- * @property {function(Hash): void} updateHash
- */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
-class LazyHashedEtag {
+class AMDPlugin {
 	/**
-	 * @param {HashableObject} obj object with updateHash method
-	 * @param {string | HashConstructor} hashFunction the hash function to use
+	 * @param {Record<string, any>} amdOptions the AMD options
 	 */
-	constructor(obj, hashFunction = "md4") {
-		this._obj = obj;
-		this._hash = undefined;
-		this._hashFunction = hashFunction;
+	constructor(amdOptions) {
+		this.amdOptions = amdOptions;
 	}
 
 	/**
-	 * @returns {string} hash of object
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	toString() {
-		if (this._hash === undefined) {
-			const hash = createHash(this._hashFunction);
-			this._obj.updateHash(hash);
-			this._hash = /** @type {string} */ (hash.digest("base64"));
-		}
-		return this._hash;
-	}
-}
-
-/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
-const mapStrings = new Map();
-
-/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
-const mapObjects = new WeakMap();
+	apply(compiler) {
+		const amdOptions = this.amdOptions;
+		compiler.hooks.compilation.tap(
+			"AMDPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					AMDRequireDependency,
+					new AMDRequireDependency.Template()
+				);
 
-/**
- * @param {HashableObject} obj object with updateHash method
- * @param {string | HashConstructor} hashFunction the hash function to use
- * @returns {LazyHashedEtag} etag
- */
-const getter = (obj, hashFunction = "md4") => {
-	let innerMap;
-	if (typeof hashFunction === "string") {
-		innerMap = mapStrings.get(hashFunction);
-		if (innerMap === undefined) {
-			const newHash = new LazyHashedEtag(obj, hashFunction);
-			innerMap = new WeakMap();
-			innerMap.set(obj, newHash);
-			mapStrings.set(hashFunction, innerMap);
-			return newHash;
-		}
-	} else {
-		innerMap = mapObjects.get(hashFunction);
-		if (innerMap === undefined) {
-			const newHash = new LazyHashedEtag(obj, hashFunction);
-			innerMap = new WeakMap();
-			innerMap.set(obj, newHash);
-			mapObjects.set(hashFunction, innerMap);
-			return newHash;
-		}
+				compilation.dependencyFactories.set(
+					AMDRequireItemDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					AMDRequireItemDependency,
+					new AMDRequireItemDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					AMDRequireArrayDependency,
+					new AMDRequireArrayDependency.Template()
+				);
+
+				compilation.dependencyFactories.set(
+					AMDRequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					AMDRequireContextDependency,
+					new AMDRequireContextDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					AMDDefineDependency,
+					new AMDDefineDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					UnsupportedDependency,
+					new UnsupportedDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					LocalModuleDependency,
+					new LocalModuleDependency.Template()
+				);
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.amdDefine)
+					.tap("AMDPlugin", (module, set) => {
+						set.add(RuntimeGlobals.require);
+					});
+
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.amdOptions)
+					.tap("AMDPlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.amdDefine)
+					.tap("AMDPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
+					});
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.amdOptions)
+					.tap("AMDPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new AMDOptionsRuntimeModule(amdOptions)
+						);
+					});
+
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.amd !== undefined && !parserOptions.amd) return;
+
+					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
+						parser.hooks.expression
+							.for(optionExpr)
+							.tap(
+								"AMDPlugin",
+								toConstantDependency(parser, RuntimeGlobals.amdOptions, [
+									RuntimeGlobals.amdOptions
+								])
+							);
+						parser.hooks.evaluateIdentifier
+							.for(optionExpr)
+							.tap(
+								"AMDPlugin",
+								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
+							);
+						parser.hooks.evaluateTypeof
+							.for(optionExpr)
+							.tap("AMDPlugin", evaluateToString("object"));
+						parser.hooks.typeof
+							.for(optionExpr)
+							.tap(
+								"AMDPlugin",
+								toConstantDependency(parser, JSON.stringify("object"))
+							);
+					};
+
+					new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
+						parser
+					);
+					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
+
+					tapOptionsHooks("define.amd", "define", () => "amd");
+					tapOptionsHooks("require.amd", "require", () => ["amd"]);
+					tapOptionsHooks(
+						"__webpack_amd_options__",
+						"__webpack_amd_options__",
+						() => []
+					);
+
+					parser.hooks.expression.for("define").tap("AMDPlugin", expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.amdDefine,
+							expr.range,
+							[RuntimeGlobals.amdDefine]
+						);
+						dep.loc = expr.loc;
+						parser.state.module.addPresentationalDependency(dep);
+						return true;
+					});
+					parser.hooks.typeof
+						.for("define")
+						.tap(
+							"AMDPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("define")
+						.tap("AMDPlugin", evaluateToString("function"));
+					parser.hooks.canRename.for("define").tap("AMDPlugin", approve);
+					parser.hooks.rename.for("define").tap("AMDPlugin", expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.amdDefine,
+							expr.range,
+							[RuntimeGlobals.amdDefine]
+						);
+						dep.loc = expr.loc;
+						parser.state.module.addPresentationalDependency(dep);
+						return false;
+					});
+					parser.hooks.typeof
+						.for("require")
+						.tap(
+							"AMDPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("require")
+						.tap("AMDPlugin", evaluateToString("function"));
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("AMDPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("AMDPlugin", handler);
+			}
+		);
 	}
-	const hash = innerMap.get(obj);
-	if (hash !== undefined) return hash;
-	const newHash = new LazyHashedEtag(obj, hashFunction);
-	innerMap.set(obj, newHash);
-	return newHash;
-};
+}
 
-module.exports = getter;
+module.exports = AMDPlugin;
 
 
 /***/ }),
 
-/***/ 54980:
-/***/ (function(module) {
+/***/ 33516:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -70150,79 +71576,104 @@ module.exports = getter;
 
 
 
-/** @typedef {import("../Cache").Etag} Etag */
+const DependencyTemplate = __webpack_require__(5160);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-class MergedEtag {
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class AMDRequireArrayDependency extends NullDependency {
+	constructor(depsArray, range) {
+		super();
+
+		this.depsArray = depsArray;
+		this.range = range;
+	}
+
+	get type() {
+		return "amd require array";
+	}
+
+	get category() {
+		return "amd";
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.depsArray);
+		write(this.range);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.depsArray = read();
+		this.range = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	AMDRequireArrayDependency,
+	"webpack/lib/dependencies/AMDRequireArrayDependency"
+);
+
+AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate extends (
+	DependencyTemplate
+) {
 	/**
-	 * @param {Etag} a first
-	 * @param {Etag} b second
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	constructor(a, b) {
-		this.a = a;
-		this.b = b;
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {AMDRequireArrayDependency} */ (dependency);
+		const content = this.getContent(dep, templateContext);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 
-	toString() {
-		return `${this.a.toString()}|${this.b.toString()}`;
+	getContent(dep, templateContext) {
+		const requires = dep.depsArray.map(dependency => {
+			return this.contentForDependency(dependency, templateContext);
+		});
+		return `[${requires.join(", ")}]`;
 	}
-}
 
-const dualObjectMap = new WeakMap();
-const objectStringMap = new WeakMap();
+	contentForDependency(
+		dep,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		if (typeof dep === "string") {
+			return dep;
+		}
 
-/**
- * @param {Etag} a first
- * @param {Etag} b second
- * @returns {Etag} result
- */
-const mergeEtags = (a, b) => {
-	if (typeof a === "string") {
-		if (typeof b === "string") {
-			return `${a}|${b}`;
+		if (dep.localModule) {
+			return dep.localModule.variableName();
 		} else {
-			const temp = b;
-			b = a;
-			a = temp;
-		}
-	} else {
-		if (typeof b !== "string") {
-			// both a and b are objects
-			let map = dualObjectMap.get(a);
-			if (map === undefined) {
-				dualObjectMap.set(a, (map = new WeakMap()));
-			}
-			const mergedEtag = map.get(b);
-			if (mergedEtag === undefined) {
-				const newMergedEtag = new MergedEtag(a, b);
-				map.set(b, newMergedEtag);
-				return newMergedEtag;
-			} else {
-				return mergedEtag;
-			}
+			return runtimeTemplate.moduleExports({
+				module: moduleGraph.getModule(dep),
+				chunkGraph,
+				request: dep.request,
+				runtimeRequirements
+			});
 		}
 	}
-	// a is object, b is string
-	let map = objectStringMap.get(a);
-	if (map === undefined) {
-		objectStringMap.set(a, (map = new Map()));
-	}
-	const mergedEtag = map.get(b);
-	if (mergedEtag === undefined) {
-		const newMergedEtag = new MergedEtag(a, b);
-		map.set(b, newMergedEtag);
-		return newMergedEtag;
-	} else {
-		return mergedEtag;
-	}
 };
 
-module.exports = mergeEtags;
+module.exports = AMDRequireArrayDependency;
 
 
 /***/ }),
 
-/***/ 13462:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 96123:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -70232,2314 +71683,1209 @@ module.exports = mergeEtags;
 
 
 
-const path = __webpack_require__(71017);
-const webpackSchema = __webpack_require__(73342);
+const makeSerializable = __webpack_require__(33032);
+const ContextDependency = __webpack_require__(88101);
 
-// TODO add originPath to PathItem for better errors
-/**
- * @typedef {Object} PathItem
- * @property {any} schema the part of the schema
- * @property {string} path the path in the config
- */
+class AMDRequireContextDependency extends ContextDependency {
+	constructor(options, range, valueRange) {
+		super(options);
 
-/** @typedef {"unknown-argument" | "unexpected-non-array-in-path" | "unexpected-non-object-in-path" | "multiple-values-unexpected" | "invalid-value"} ProblemType */
+		this.range = range;
+		this.valueRange = valueRange;
+	}
 
-/**
- * @typedef {Object} Problem
- * @property {ProblemType} type
- * @property {string} path
- * @property {string} argument
- * @property {any=} value
- * @property {number=} index
- * @property {string=} expected
- */
+	get type() {
+		return "amd require context";
+	}
 
-/**
- * @typedef {Object} LocalProblem
- * @property {ProblemType} type
- * @property {string} path
- * @property {string=} expected
- */
+	get category() {
+		return "amd";
+	}
 
-/**
- * @typedef {Object} ArgumentConfig
- * @property {string} description
- * @property {string} [negatedDescription]
- * @property {string} path
- * @property {boolean} multiple
- * @property {"enum"|"string"|"path"|"number"|"boolean"|"RegExp"|"reset"} type
- * @property {any[]=} values
- */
+	serialize(context) {
+		const { write } = context;
 
-/**
- * @typedef {Object} Argument
- * @property {string} description
- * @property {"string"|"number"|"boolean"} simpleType
- * @property {boolean} multiple
- * @property {ArgumentConfig[]} configs
- */
+		write(this.range);
+		write(this.valueRange);
 
-/**
- * @param {any=} schema a json schema to create arguments for (by default webpack schema is used)
- * @returns {Record<string, Argument>} object of arguments
- */
-const getArguments = (schema = webpackSchema) => {
-	/** @type {Record<string, Argument>} */
-	const flags = {};
+		super.serialize(context);
+	}
 
-	const pathToArgumentName = input => {
-		return input
-			.replace(/\./g, "-")
-			.replace(/\[\]/g, "")
-			.replace(
-				/(\p{Uppercase_Letter}+|\p{Lowercase_Letter}|\d)(\p{Uppercase_Letter}+)/gu,
-				"$1-$2"
-			)
-			.replace(/-?[^\p{Uppercase_Letter}\p{Lowercase_Letter}\d]+/gu, "-")
-			.toLowerCase();
-	};
+	deserialize(context) {
+		const { read } = context;
 
-	const getSchemaPart = path => {
-		const newPath = path.split("/");
+		this.range = read();
+		this.valueRange = read();
 
-		let schemaPart = schema;
+		super.deserialize(context);
+	}
+}
 
-		for (let i = 1; i < newPath.length; i++) {
-			const inner = schemaPart[newPath[i]];
+makeSerializable(
+	AMDRequireContextDependency,
+	"webpack/lib/dependencies/AMDRequireContextDependency"
+);
 
-			if (!inner) {
-				break;
-			}
+AMDRequireContextDependency.Template = __webpack_require__(75815);
 
-			schemaPart = inner;
-		}
+module.exports = AMDRequireContextDependency;
 
-		return schemaPart;
-	};
 
-	/**
-	 *
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {string | undefined} description
-	 */
-	const getDescription = path => {
-		for (const { schema } of path) {
-			if (schema.cli) {
-				if (schema.cli.helper) continue;
-				if (schema.cli.description) return schema.cli.description;
-			}
-			if (schema.description) return schema.description;
-		}
-	};
+/***/ }),
 
-	/**
-	 *
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {string | undefined} negative description
-	 */
-	const getNegatedDescription = path => {
-		for (const { schema } of path) {
-			if (schema.cli) {
-				if (schema.cli.helper) continue;
-				if (schema.cli.negatedDescription) return schema.cli.negatedDescription;
-			}
-		}
-	};
+/***/ 76932:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 *
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {string | undefined} reset description
-	 */
-	const getResetDescription = path => {
-		for (const { schema } of path) {
-			if (schema.cli) {
-				if (schema.cli.helper) continue;
-				if (schema.cli.resetDescription) return schema.cli.resetDescription;
-			}
-		}
-	};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 *
-	 * @param {any} schemaPart schema
-	 * @returns {Pick<ArgumentConfig, "type"|"values">} partial argument config
-	 */
-	const schemaToArgumentConfig = schemaPart => {
-		if (schemaPart.enum) {
-			return {
-				type: "enum",
-				values: schemaPart.enum
-			};
-		}
-		switch (schemaPart.type) {
-			case "number":
-				return {
-					type: "number"
-				};
-			case "string":
-				return {
-					type: schemaPart.absolutePath ? "path" : "string"
-				};
-			case "boolean":
-				return {
-					type: "boolean"
-				};
-		}
-		if (schemaPart.instanceof === "RegExp") {
-			return {
-				type: "RegExp"
-			};
-		}
-		return undefined;
-	};
 
-	/**
-	 * @param {PathItem[]} path path in the schema
-	 * @returns {void}
-	 */
-	const addResetFlag = path => {
-		const schemaPath = path[0].path;
-		const name = pathToArgumentName(`${schemaPath}.reset`);
-		const description =
-			getResetDescription(path) ||
-			`Clear all items provided in '${schemaPath}' configuration. ${getDescription(
-				path
-			)}`;
-		flags[name] = {
-			configs: [
-				{
-					type: "reset",
-					multiple: false,
-					description,
-					path: schemaPath
-				}
-			],
-			description: undefined,
-			simpleType: undefined,
-			multiple: undefined
-		};
-	};
 
-	/**
-	 * @param {PathItem[]} path full path in schema
-	 * @param {boolean} multiple inside of an array
-	 * @returns {number} number of arguments added
-	 */
-	const addFlag = (path, multiple) => {
-		const argConfigBase = schemaToArgumentConfig(path[0].schema);
-		if (!argConfigBase) return 0;
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const makeSerializable = __webpack_require__(33032);
 
-		const negatedDescription = getNegatedDescription(path);
-		const name = pathToArgumentName(path[0].path);
-		/** @type {ArgumentConfig} */
-		const argConfig = {
-			...argConfigBase,
-			multiple,
-			description: getDescription(path),
-			path: path[0].path
-		};
+class AMDRequireDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(loc, request) {
+		super(null, loc, request);
+	}
+}
 
-		if (negatedDescription) {
-			argConfig.negatedDescription = negatedDescription;
-		}
+makeSerializable(
+	AMDRequireDependenciesBlock,
+	"webpack/lib/dependencies/AMDRequireDependenciesBlock"
+);
 
-		if (!flags[name]) {
-			flags[name] = {
-				configs: [],
-				description: undefined,
-				simpleType: undefined,
-				multiple: undefined
-			};
-		}
+module.exports = AMDRequireDependenciesBlock;
 
-		if (
-			flags[name].configs.some(
-				item => JSON.stringify(item) === JSON.stringify(argConfig)
-			)
-		) {
-			return 0;
-		}
 
-		if (
-			flags[name].configs.some(
-				item => item.type === argConfig.type && item.multiple !== multiple
-			)
-		) {
-			if (multiple) {
-				throw new Error(
-					`Conflicting schema for ${path[0].path} with ${argConfig.type} type (array type must be before single item type)`
-				);
+/***/ }),
+
+/***/ 66866:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const AMDRequireArrayDependency = __webpack_require__(33516);
+const AMDRequireContextDependency = __webpack_require__(96123);
+const AMDRequireDependenciesBlock = __webpack_require__(76932);
+const AMDRequireDependency = __webpack_require__(43911);
+const AMDRequireItemDependency = __webpack_require__(71806);
+const ConstDependency = __webpack_require__(76911);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const LocalModuleDependency = __webpack_require__(52805);
+const { getLocalModule } = __webpack_require__(75827);
+const UnsupportedDependency = __webpack_require__(51669);
+const getFunctionExpression = __webpack_require__(50396);
+
+class AMDRequireDependenciesBlockParserPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
+	processFunctionArgument(parser, expression) {
+		let bindThis = true;
+		const fnData = getFunctionExpression(expression);
+		if (fnData) {
+			parser.inScope(
+				fnData.fn.params.filter(i => {
+					return !["require", "module", "exports"].includes(i.name);
+				}),
+				() => {
+					if (fnData.fn.body.type === "BlockStatement") {
+						parser.walkStatement(fnData.fn.body);
+					} else {
+						parser.walkExpression(fnData.fn.body);
+					}
+				}
+			);
+			parser.walkExpressions(fnData.expressions);
+			if (fnData.needThis === false) {
+				bindThis = false;
 			}
-			return 0;
+		} else {
+			parser.walkExpression(expression);
 		}
+		return bindThis;
+	}
 
-		flags[name].configs.push(argConfig);
+	apply(parser) {
+		parser.hooks.call
+			.for("require")
+			.tap(
+				"AMDRequireDependenciesBlockParserPlugin",
+				this.processCallRequire.bind(this, parser)
+			);
+	}
 
-		return 1;
-	};
+	processArray(parser, expr, param) {
+		if (param.isArray()) {
+			for (const p of param.items) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isConstArray()) {
+			const deps = [];
+			for (const request of param.array) {
+				let dep, localModule;
+				if (request === "require") {
+					dep = "__webpack_require__";
+				} else if (["exports", "module"].includes(request)) {
+					dep = request;
+				} else if ((localModule = getLocalModule(parser.state, request))) {
+					localModule.flagUsed();
+					dep = new LocalModuleDependency(localModule, undefined, false);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				} else {
+					dep = this.newRequireItemDependency(request);
+					dep.loc = expr.loc;
+					dep.optional = !!parser.scope.inTry;
+					parser.state.current.addDependency(dep);
+				}
+				deps.push(dep);
+			}
+			const dep = this.newRequireArrayDependency(deps, param.range);
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processItem(parser, expr, param) {
+		if (param.isConditional()) {
+			for (const p of param.options) {
+				const result = this.processItem(parser, expr, p);
+				if (result === undefined) {
+					this.processContext(parser, expr, p);
+				}
+			}
+			return true;
+		} else if (param.isString()) {
+			let dep, localModule;
+			if (param.string === "require") {
+				dep = new ConstDependency("__webpack_require__", param.string, [
+					RuntimeGlobals.require
+				]);
+			} else if (param.string === "module") {
+				dep = new ConstDependency(
+					parser.state.module.buildInfo.moduleArgument,
+					param.range,
+					[RuntimeGlobals.module]
+				);
+			} else if (param.string === "exports") {
+				dep = new ConstDependency(
+					parser.state.module.buildInfo.exportsArgument,
+					param.range,
+					[RuntimeGlobals.exports]
+				);
+			} else if ((localModule = getLocalModule(parser.state, param.string))) {
+				localModule.flagUsed();
+				dep = new LocalModuleDependency(localModule, param.range, false);
+			} else {
+				dep = this.newRequireItemDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		}
+	}
+	processContext(parser, expr, param) {
+		const dep = ContextDependencyHelpers.create(
+			AMDRequireContextDependency,
+			param.range,
+			param,
+			expr,
+			this.options,
+			{
+				category: "amd"
+			},
+			parser
+		);
+		if (!dep) return;
+		dep.loc = expr.loc;
+		dep.optional = !!parser.scope.inTry;
+		parser.state.current.addDependency(dep);
+		return true;
+	}
 
-	// TODO support `not` and `if/then/else`
-	// TODO support `const`, but we don't use it on our schema
-	/**
-	 *
-	 * @param {object} schemaPart the current schema
-	 * @param {string} schemaPath the current path in the schema
-	 * @param {{schema: object, path: string}[]} path all previous visited schemaParts
-	 * @param {string | null} inArray if inside of an array, the path to the array
-	 * @returns {number} added arguments
-	 */
-	const traverse = (schemaPart, schemaPath = "", path = [], inArray = null) => {
-		while (schemaPart.$ref) {
-			schemaPart = getSchemaPart(schemaPart.$ref);
+	processArrayForRequestString(param) {
+		if (param.isArray()) {
+			const result = param.items.map(item =>
+				this.processItemForRequestString(item)
+			);
+			if (result.every(Boolean)) return result.join(" ");
+		} else if (param.isConstArray()) {
+			return param.array.join(" ");
 		}
+	}
 
-		const repetitions = path.filter(({ schema }) => schema === schemaPart);
-		if (
-			repetitions.length >= 2 ||
-			repetitions.some(({ path }) => path === schemaPath)
-		) {
-			return 0;
+	processItemForRequestString(param) {
+		if (param.isConditional()) {
+			const result = param.options.map(item =>
+				this.processItemForRequestString(item)
+			);
+			if (result.every(Boolean)) return result.join("|");
+		} else if (param.isString()) {
+			return param.string;
 		}
+	}
 
-		if (schemaPart.cli && schemaPart.cli.exclude) return 0;
+	processCallRequire(parser, expr) {
+		let param;
+		let depBlock;
+		let dep;
+		let result;
 
-		const fullPath = [{ schema: schemaPart, path: schemaPath }, ...path];
+		const old = parser.state.current;
 
-		let addedArguments = 0;
+		if (expr.arguments.length >= 1) {
+			param = parser.evaluateExpression(expr.arguments[0]);
+			depBlock = this.newRequireDependenciesBlock(
+				expr.loc,
+				this.processArrayForRequestString(param)
+			);
+			dep = this.newRequireDependency(
+				expr.range,
+				param.range,
+				expr.arguments.length > 1 ? expr.arguments[1].range : null,
+				expr.arguments.length > 2 ? expr.arguments[2].range : null
+			);
+			dep.loc = expr.loc;
+			depBlock.addDependency(dep);
 
-		addedArguments += addFlag(fullPath, !!inArray);
+			parser.state.current = depBlock;
+		}
 
-		if (schemaPart.type === "object") {
-			if (schemaPart.properties) {
-				for (const property of Object.keys(schemaPart.properties)) {
-					addedArguments += traverse(
-						schemaPart.properties[property],
-						schemaPath ? `${schemaPath}.${property}` : property,
-						fullPath,
-						inArray
+		if (expr.arguments.length === 1) {
+			parser.inScope([], () => {
+				result = this.processArray(parser, expr, param);
+			});
+			parser.state.current = old;
+			if (!result) return;
+			parser.state.current.addBlock(depBlock);
+			return true;
+		}
+
+		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
+			try {
+				parser.inScope([], () => {
+					result = this.processArray(parser, expr, param);
+				});
+				if (!result) {
+					const dep = new UnsupportedDependency("unsupported", expr.range);
+					old.addPresentationalDependency(dep);
+					if (parser.state.module) {
+						parser.state.module.addError(
+							new UnsupportedFeatureWarning(
+								"Cannot statically analyse 'require(…, …)' in line " +
+									expr.loc.start.line,
+								expr.loc
+							)
+						);
+					}
+					depBlock = null;
+					return true;
+				}
+				dep.functionBindThis = this.processFunctionArgument(
+					parser,
+					expr.arguments[1]
+				);
+				if (expr.arguments.length === 3) {
+					dep.errorCallbackBindThis = this.processFunctionArgument(
+						parser,
+						expr.arguments[2]
 					);
 				}
+			} finally {
+				parser.state.current = old;
+				if (depBlock) parser.state.current.addBlock(depBlock);
 			}
-
-			return addedArguments;
+			return true;
 		}
+	}
 
-		if (schemaPart.type === "array") {
-			if (inArray) {
-				return 0;
-			}
-			if (Array.isArray(schemaPart.items)) {
-				let i = 0;
-				for (const item of schemaPart.items) {
-					addedArguments += traverse(
-						item,
-						`${schemaPath}.${i}`,
-						fullPath,
-						schemaPath
-					);
-				}
+	newRequireDependenciesBlock(loc, request) {
+		return new AMDRequireDependenciesBlock(loc, request);
+	}
+	newRequireDependency(
+		outerRange,
+		arrayRange,
+		functionRange,
+		errorCallbackRange
+	) {
+		return new AMDRequireDependency(
+			outerRange,
+			arrayRange,
+			functionRange,
+			errorCallbackRange
+		);
+	}
+	newRequireItemDependency(request, range) {
+		return new AMDRequireItemDependency(request, range);
+	}
+	newRequireArrayDependency(depsArray, range) {
+		return new AMDRequireArrayDependency(depsArray, range);
+	}
+}
+module.exports = AMDRequireDependenciesBlockParserPlugin;
 
-				return addedArguments;
-			}
 
-			addedArguments += traverse(
-				schemaPart.items,
-				`${schemaPath}[]`,
-				fullPath,
-				schemaPath
-			);
+/***/ }),
 
-			if (addedArguments > 0) {
-				addResetFlag(fullPath);
-				addedArguments++;
-			}
+/***/ 43911:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			return addedArguments;
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const maybeOf = schemaPart.oneOf || schemaPart.anyOf || schemaPart.allOf;
 
-		if (maybeOf) {
-			const items = maybeOf;
 
-			for (let i = 0; i < items.length; i++) {
-				addedArguments += traverse(items[i], schemaPath, fullPath, inArray);
-			}
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-			return addedArguments;
-		}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-		return addedArguments;
-	};
+class AMDRequireDependency extends NullDependency {
+	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
+		super();
 
-	traverse(schema);
+		this.outerRange = outerRange;
+		this.arrayRange = arrayRange;
+		this.functionRange = functionRange;
+		this.errorCallbackRange = errorCallbackRange;
+		this.functionBindThis = false;
+		this.errorCallbackBindThis = false;
+	}
 
-	// Summarize flags
-	for (const name of Object.keys(flags)) {
-		const argument = flags[name];
-		argument.description = argument.configs.reduce((desc, { description }) => {
-			if (!desc) return description;
-			if (!description) return desc;
-			if (desc.includes(description)) return desc;
-			return `${desc} ${description}`;
-		}, /** @type {string | undefined} */ (undefined));
-		argument.simpleType = argument.configs.reduce((t, argConfig) => {
-			/** @type {"string" | "number" | "boolean"} */
-			let type = "string";
-			switch (argConfig.type) {
-				case "number":
-					type = "number";
-					break;
-				case "reset":
-				case "boolean":
-					type = "boolean";
-					break;
-				case "enum":
-					if (argConfig.values.every(v => typeof v === "boolean"))
-						type = "boolean";
-					if (argConfig.values.every(v => typeof v === "number"))
-						type = "number";
-					break;
-			}
-			if (t === undefined) return type;
-			return t === type ? t : "string";
-		}, /** @type {"string" | "number" | "boolean" | undefined} */ (undefined));
-		argument.multiple = argument.configs.some(c => c.multiple);
+	get category() {
+		return "amd";
 	}
 
-	return flags;
-};
+	serialize(context) {
+		const { write } = context;
 
-const cliAddedItems = new WeakMap();
+		write(this.outerRange);
+		write(this.arrayRange);
+		write(this.functionRange);
+		write(this.errorCallbackRange);
+		write(this.functionBindThis);
+		write(this.errorCallbackBindThis);
 
-/**
- * @param {any} config configuration
- * @param {string} schemaPath path in the config
- * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {{ problem?: LocalProblem, object?: any, property?: string | number, value?: any }} problem or object with property and value
- */
-const getObjectAndProperty = (config, schemaPath, index = 0) => {
-	if (!schemaPath) return { value: config };
-	const parts = schemaPath.split(".");
-	let property = parts.pop();
-	let current = config;
-	let i = 0;
-	for (const part of parts) {
-		const isArray = part.endsWith("[]");
-		const name = isArray ? part.slice(0, -2) : part;
-		let value = current[name];
-		if (isArray) {
-			if (value === undefined) {
-				value = {};
-				current[name] = [...Array.from({ length: index }), value];
-				cliAddedItems.set(current[name], index + 1);
-			} else if (!Array.isArray(value)) {
-				return {
-					problem: {
-						type: "unexpected-non-array-in-path",
-						path: parts.slice(0, i).join(".")
-					}
-				};
-			} else {
-				let addedItems = cliAddedItems.get(value) || 0;
-				while (addedItems <= index) {
-					value.push(undefined);
-					addedItems++;
-				}
-				cliAddedItems.set(value, addedItems);
-				const x = value.length - addedItems + index;
-				if (value[x] === undefined) {
-					value[x] = {};
-				} else if (value[x] === null || typeof value[x] !== "object") {
-					return {
-						problem: {
-							type: "unexpected-non-object-in-path",
-							path: parts.slice(0, i).join(".")
-						}
-					};
-				}
-				value = value[x];
-			}
-		} else {
-			if (value === undefined) {
-				value = current[name] = {};
-			} else if (value === null || typeof value !== "object") {
-				return {
-					problem: {
-						type: "unexpected-non-object-in-path",
-						path: parts.slice(0, i).join(".")
-					}
-				};
-			}
-		}
-		current = value;
-		i++;
-	}
-	let value = current[property];
-	if (property.endsWith("[]")) {
-		const name = property.slice(0, -2);
-		const value = current[name];
-		if (value === undefined) {
-			current[name] = [...Array.from({ length: index }), undefined];
-			cliAddedItems.set(current[name], index + 1);
-			return { object: current[name], property: index, value: undefined };
-		} else if (!Array.isArray(value)) {
-			current[name] = [value, ...Array.from({ length: index }), undefined];
-			cliAddedItems.set(current[name], index + 1);
-			return { object: current[name], property: index + 1, value: undefined };
-		} else {
-			let addedItems = cliAddedItems.get(value) || 0;
-			while (addedItems <= index) {
-				value.push(undefined);
-				addedItems++;
-			}
-			cliAddedItems.set(value, addedItems);
-			const x = value.length - addedItems + index;
-			if (value[x] === undefined) {
-				value[x] = {};
-			} else if (value[x] === null || typeof value[x] !== "object") {
-				return {
-					problem: {
-						type: "unexpected-non-object-in-path",
-						path: schemaPath
-					}
-				};
-			}
-			return {
-				object: value,
-				property: x,
-				value: value[x]
-			};
-		}
+		super.serialize(context);
 	}
-	return { object: current, property, value };
-};
 
-/**
- * @param {any} config configuration
- * @param {string} schemaPath path in the config
- * @param {any} value parsed value
- * @param {number | undefined} index index of value when multiple values are provided, otherwise undefined
- * @returns {LocalProblem | null} problem or null for success
- */
-const setValue = (config, schemaPath, value, index) => {
-	const { problem, object, property } = getObjectAndProperty(
-		config,
-		schemaPath,
-		index
-	);
-	if (problem) return problem;
-	object[property] = value;
-	return null;
-};
+	deserialize(context) {
+		const { read } = context;
 
-/**
- * @param {ArgumentConfig} argConfig processing instructions
- * @param {any} config configuration
- * @param {any} value the value
- * @param {number | undefined} index the index if multiple values provided
- * @returns {LocalProblem | null} a problem if any
- */
-const processArgumentConfig = (argConfig, config, value, index) => {
-	if (index !== undefined && !argConfig.multiple) {
-		return {
-			type: "multiple-values-unexpected",
-			path: argConfig.path
-		};
-	}
-	const parsed = parseValueForArgumentConfig(argConfig, value);
-	if (parsed === undefined) {
-		return {
-			type: "invalid-value",
-			path: argConfig.path,
-			expected: getExpectedValue(argConfig)
-		};
-	}
-	const problem = setValue(config, argConfig.path, parsed, index);
-	if (problem) return problem;
-	return null;
-};
+		this.outerRange = read();
+		this.arrayRange = read();
+		this.functionRange = read();
+		this.errorCallbackRange = read();
+		this.functionBindThis = read();
+		this.errorCallbackBindThis = read();
 
-/**
- * @param {ArgumentConfig} argConfig processing instructions
- * @returns {string | undefined} expected message
- */
-const getExpectedValue = argConfig => {
-	switch (argConfig.type) {
-		default:
-			return argConfig.type;
-		case "boolean":
-			return "true | false";
-		case "RegExp":
-			return "regular expression (example: /ab?c*/)";
-		case "enum":
-			return argConfig.values.map(v => `${v}`).join(" | ");
-		case "reset":
-			return "true (will reset the previous value to an empty array)";
+		super.deserialize(context);
 	}
-};
+}
 
-/**
- * @param {ArgumentConfig} argConfig processing instructions
- * @param {any} value the value
- * @returns {any | undefined} parsed value
- */
-const parseValueForArgumentConfig = (argConfig, value) => {
-	switch (argConfig.type) {
-		case "string":
-			if (typeof value === "string") {
-				return value;
-			}
-			break;
-		case "path":
-			if (typeof value === "string") {
-				return path.resolve(value);
-			}
-			break;
-		case "number":
-			if (typeof value === "number") return value;
-			if (typeof value === "string" && /^[+-]?\d*(\.\d*)[eE]\d+$/) {
-				const n = +value;
-				if (!isNaN(n)) return n;
-			}
-			break;
-		case "boolean":
-			if (typeof value === "boolean") return value;
-			if (value === "true") return true;
-			if (value === "false") return false;
-			break;
-		case "RegExp":
-			if (value instanceof RegExp) return value;
-			if (typeof value === "string") {
-				// cspell:word yugi
-				const match = /^\/(.*)\/([yugi]*)$/.exec(value);
-				if (match && !/[^\\]\//.test(match[1]))
-					return new RegExp(match[1], match[2]);
-			}
-			break;
-		case "enum":
-			if (argConfig.values.includes(value)) return value;
-			for (const item of argConfig.values) {
-				if (`${item}` === value) return item;
-			}
-			break;
-		case "reset":
-			if (value === true) return [];
-			break;
-	}
-};
+makeSerializable(
+	AMDRequireDependency,
+	"webpack/lib/dependencies/AMDRequireDependency"
+);
 
-/**
- * @param {Record<string, Argument>} args object of arguments
- * @param {any} config configuration
- * @param {Record<string, string | number | boolean | RegExp | (string | number | boolean | RegExp)[]>} values object with values
- * @returns {Problem[] | null} problems or null for success
- */
-const processArguments = (args, config, values) => {
-	/** @type {Problem[]} */
-	const problems = [];
-	for (const key of Object.keys(values)) {
-		const arg = args[key];
-		if (!arg) {
-			problems.push({
-				type: "unknown-argument",
-				path: "",
-				argument: key
-			});
-			continue;
+AMDRequireDependency.Template = class AMDRequireDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {AMDRequireDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block: depBlock,
+			message: "AMD require",
+			runtimeRequirements
+		});
+
+		// has array range but no function range
+		if (dep.arrayRange && !dep.functionRange) {
+			const startBlock = `${promise}.then(function() {`;
+			const endBlock = `;})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.replace(dep.arrayRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
 		}
-		const processValue = (value, i) => {
-			const currentProblems = [];
-			for (const argConfig of arg.configs) {
-				const problem = processArgumentConfig(argConfig, config, value, i);
-				if (!problem) {
-					return;
-				}
-				currentProblems.push({
-					...problem,
-					argument: key,
-					value: value,
-					index: i
-				});
-			}
-			problems.push(...currentProblems);
-		};
-		let value = values[key];
-		if (Array.isArray(value)) {
-			for (let i = 0; i < value.length; i++) {
-				processValue(value[i], i);
-			}
-		} else {
-			processValue(value, undefined);
+
+		// has function range but no array range
+		if (dep.functionRange && !dep.arrayRange) {
+			const startBlock = `${promise}.then((`;
+			const endBlock = `).bind(exports, __webpack_require__, exports, module))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.functionRange[0] - 1, startBlock);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+
+			return;
+		}
+
+		// has array range, function range, and errorCallbackRange
+		if (dep.arrayRange && dep.functionRange && dep.errorCallbackRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const errorRangeBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](`;
+			const endBlock = `${dep.errorCallbackBindThis ? ".bind(this)" : ""})`;
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(
+				dep.functionRange[1],
+				dep.errorCallbackRange[0] - 1,
+				errorRangeBlock
+			);
+
+			source.replace(
+				dep.errorCallbackRange[1],
+				dep.outerRange[1] - 1,
+				endBlock
+			);
+
+			return;
+		}
+
+		// has array range, function range, but no errorCallbackRange
+		if (dep.arrayRange && dep.functionRange) {
+			const startBlock = `${promise}.then(function() { `;
+			const endBlock = `}${
+				dep.functionBindThis ? ".bind(this)" : ""
+			})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
+			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
+
+			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
+
+			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
+
+			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
+
+			source.insert(
+				dep.functionRange[1],
+				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
+			);
+
+			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
 		}
 	}
-	if (problems.length === 0) return null;
-	return problems;
 };
 
-exports.getArguments = getArguments;
-exports.processArguments = processArguments;
+module.exports = AMDRequireDependency;
 
 
 /***/ }),
 
-/***/ 43950:
+/***/ 71806:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra
 */
 
 
 
-const browserslist = __webpack_require__(14907);
-const path = __webpack_require__(71017);
-
-/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
-/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
-/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
 
-// [[C:]/path/to/config][:env]
-const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
+class AMDRequireItemDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
 
-/**
- * @typedef {Object} BrowserslistHandlerConfig
- * @property {string=} configPath
- * @property {string=} env
- * @property {string=} query
- */
+		this.range = range;
+	}
 
-/**
- * @param {string} input input string
- * @param {string} context the context directory
- * @returns {BrowserslistHandlerConfig} config
- */
-const parse = (input, context) => {
-	if (!input) {
-		return {};
+	get type() {
+		return "amd require";
 	}
 
-	if (path.isAbsolute(input)) {
-		const [, configPath, env] = inputRx.exec(input) || [];
-		return { configPath, env };
+	get category() {
+		return "amd";
 	}
+}
 
-	const config = browserslist.findConfig(context);
+makeSerializable(
+	AMDRequireItemDependency,
+	"webpack/lib/dependencies/AMDRequireItemDependency"
+);
 
-	if (config && Object.keys(config).includes(input)) {
-		return { env: input };
-	}
+AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
 
-	return { query: input };
-};
+module.exports = AMDRequireItemDependency;
 
-/**
- * @param {string} input input string
- * @param {string} context the context directory
- * @returns {string[] | undefined} selected browsers
- */
-const load = (input, context) => {
-	const { configPath, env, query } = parse(input, context);
 
-	// if a query is specified, then use it, else
-	// if a path to a config is specified then load it, else
-	// find a nearest config
-	const config = query
-		? query
-		: configPath
-		? browserslist.loadConfig({
-				config: configPath,
-				env
-		  })
-		: browserslist.loadConfig({ path: context, env });
+/***/ }),
 
-	if (!config) return null;
-	return browserslist(config);
-};
+/***/ 45242:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+class AMDDefineRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("amd define");
+	}
 
-/**
- * @param {string[]} browsers supported browsers list
- * @returns {EcmaTargetProperties & PlatformTargetProperties & ApiTargetProperties} target properties
- */
-const resolve = browsers => {
 	/**
-	 * Checks all against a version number
-	 * @param {Record<string, number | [number, number]>} versions first supported version
-	 * @returns {boolean} true if supports
+	 * @returns {string} runtime code
 	 */
-	const rawChecker = versions => {
-		return browsers.every(v => {
-			const [name, parsedVersion] = v.split(" ");
-			if (!name) return false;
-			const requiredVersion = versions[name];
-			if (!requiredVersion) return false;
-			const [parsedMajor, parserMinor] =
-				// safari TP supports all features for normal safari
-				parsedVersion === "TP"
-					? [Infinity, Infinity]
-					: parsedVersion.split(".");
-			if (typeof requiredVersion === "number") {
-				return +parsedMajor >= requiredVersion;
-			}
-			return requiredVersion[0] === +parsedMajor
-				? +parserMinor >= requiredVersion[1]
-				: +parsedMajor > requiredVersion[0];
-		});
-	};
-	const anyNode = browsers.some(b => /^node /.test(b));
-	const anyBrowser = browsers.some(b => /^(?!node)/.test(b));
-	const browserProperty = !anyBrowser ? false : anyNode ? null : true;
-	const nodeProperty = !anyNode ? false : anyBrowser ? null : true;
-	// Internet Explorer Mobile, Blackberry browser and Opera Mini are very old browsers, they do not support new features
-	const es6DynamicImport = rawChecker({
-		chrome: 63,
-		and_chr: 63,
-		edge: 79,
-		firefox: 67,
-		and_ff: 67,
-		// ie: Not supported
-		opera: 50,
-		op_mob: 46,
-		safari: [11, 1],
-		ios_saf: [11, 3],
-		samsung: [8, 2],
-		android: 63,
-		and_qq: [10, 4],
-		// baidu: Not supported
-		// and_uc: Not supported
-		// kaios: Not supported
-		// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
-		node: [13, 14]
-	});
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdDefine} = function () {`,
+			Template.indent("throw new Error('define cannot be used indirect');"),
+			"};"
+		]);
+	}
+}
 
-	return {
-		const: rawChecker({
-			chrome: 49,
-			and_chr: 49,
-			edge: 12,
-			// Prior to Firefox 13, <code>const</code> is implemented, but re-assignment is not failing.
-			// Prior to Firefox 46, a <code>TypeError</code> was thrown on redeclaration instead of a <code>SyntaxError</code>.
-			firefox: 36,
-			and_ff: 36,
-			// Not supported in for-in and for-of loops
-			// ie: Not supported
-			opera: 36,
-			op_mob: 36,
-			safari: [10, 0],
-			ios_saf: [10, 0],
-			// Before 5.0 supported correctly in strict mode, otherwise supported without block scope
-			samsung: [5, 0],
-			android: 37,
-			and_qq: [10, 4],
-			// Supported correctly in strict mode, otherwise supported without block scope
-			// baidu: Not supported
-			and_uc: [12, 12],
-			kaios: [2, 5],
-			node: [6, 0]
-		}),
-		arrowFunction: rawChecker({
-			chrome: 45,
-			and_chr: 45,
-			edge: 12,
-			// The initial implementation of arrow functions in Firefox made them automatically strict. This has been changed as of Firefox 24. The use of <code>'use strict';</code> is now required.
-			// Prior to Firefox 39, a line terminator (<code>\\n</code>) was incorrectly allowed after arrow function arguments. This has been fixed to conform to the ES2015 specification and code like <code>() \\n => {}</code> will now throw a <code>SyntaxError</code> in this and later versions.
-			firefox: 39,
-			and_ff: 39,
-			// ie: Not supported,
-			opera: 32,
-			op_mob: 32,
-			safari: 10,
-			ios_saf: 10,
-			samsung: [5, 0],
-			android: 45,
-			and_qq: [10, 4],
-			baidu: [7, 12],
-			and_uc: [12, 12],
-			kaios: [2, 5],
-			node: [6, 0]
-		}),
-		forOf: rawChecker({
-			chrome: 38,
-			and_chr: 38,
-			edge: 12,
-			// Prior to Firefox 51, using the for...of loop construct with the const keyword threw a SyntaxError ("missing = in const declaration").
-			firefox: 51,
-			and_ff: 51,
-			// ie: Not supported,
-			opera: 25,
-			op_mob: 25,
-			safari: 7,
-			ios_saf: 7,
-			samsung: [3, 0],
-			android: 38,
-			// and_qq: Unknown support
-			// baidu: Unknown support
-			// and_uc: Unknown support
-			// kaios: Unknown support
-			node: [0, 12]
-		}),
-		destructuring: rawChecker({
-			chrome: 49,
-			and_chr: 49,
-			edge: 14,
-			firefox: 41,
-			and_ff: 41,
-			// ie: Not supported,
-			opera: 36,
-			op_mob: 36,
-			safari: 8,
-			ios_saf: 8,
-			samsung: [5, 0],
-			android: 49,
-			// and_qq: Unknown support
-			// baidu: Unknown support
-			// and_uc: Unknown support
-			// kaios: Unknown support
-			node: [6, 0]
-		}),
-		bigIntLiteral: rawChecker({
-			chrome: 67,
-			and_chr: 67,
-			edge: 79,
-			firefox: 68,
-			and_ff: 68,
-			// ie: Not supported,
-			opera: 54,
-			op_mob: 48,
-			safari: 14,
-			ios_saf: 14,
-			samsung: [9, 2],
-			android: 67,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
-			node: [10, 4]
-		}),
-		// Support syntax `import` and `export` and no limitations and bugs on Node.js
-		// Not include `export * as namespace`
-		module: rawChecker({
-			chrome: 61,
-			and_chr: 61,
-			edge: 16,
-			firefox: 60,
-			and_ff: 60,
-			// ie: Not supported,
-			opera: 48,
-			op_mob: 45,
-			safari: [10, 1],
-			ios_saf: [10, 3],
-			samsung: [8, 0],
-			android: 61,
-			and_qq: [10, 4],
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
-			// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
-			node: [13, 14]
-		}),
-		dynamicImport: es6DynamicImport,
-		dynamicImportInWorker: es6DynamicImport && !anyNode,
-		// browserslist does not have info about globalThis
-		// so this is based on mdn-browser-compat-data
-		globalThis: rawChecker({
-			chrome: 71,
-			and_chr: 71,
-			edge: 79,
-			firefox: 65,
-			and_ff: 65,
-			// ie: Not supported,
-			opera: 58,
-			op_mob: 50,
-			safari: [12, 1],
-			ios_saf: [12, 2],
-			samsung: [10, 1],
-			android: 71,
-			// and_qq: Unknown support
-			// baidu: Unknown support
-			// and_uc: Unknown support
-			// kaios: Unknown support
-			node: [12, 0]
-		}),
-		optionalChaining: rawChecker({
-			chrome: 80,
-			and_chr: 80,
-			edge: 80,
-			firefox: 74,
-			and_ff: 79,
-			// ie: Not supported,
-			opera: 67,
-			op_mob: 64,
-			safari: [13, 1],
-			ios_saf: [13, 4],
-			samsung: 13,
-			android: 80,
-			// and_qq: Not supported
-			// baidu: Not supported
-			// and_uc: Not supported
-			// kaios: Not supported
-			node: 14
-		}),
-		templateLiteral: rawChecker({
-			chrome: 41,
-			and_chr: 41,
-			edge: 13,
-			firefox: 34,
-			and_ff: 34,
-			// ie: Not supported,
-			opera: 29,
-			op_mob: 64,
-			safari: [9, 1],
-			ios_saf: 9,
-			samsung: 4,
-			android: 41,
-			and_qq: [10, 4],
-			baidu: [7, 12],
-			and_uc: [12, 12],
-			kaios: [2, 5],
-			node: 4
-		}),
-		browser: browserProperty,
-		electron: false,
-		node: nodeProperty,
-		nwjs: false,
-		web: browserProperty,
-		webworker: false,
+class AMDOptionsRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Record<string, boolean | number | string>} options the AMD options
+	 */
+	constructor(options) {
+		super("amd options");
+		this.options = options;
+	}
 
-		document: browserProperty,
-		fetchWasm: browserProperty,
-		global: nodeProperty,
-		importScripts: false,
-		importScriptsInWorker: true,
-		nodeBuiltins: nodeProperty,
-		require: nodeProperty
-	};
-};
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.amdOptions} = ${JSON.stringify(this.options)};`
+		]);
+	}
+}
 
-module.exports = {
-	resolve,
-	load
-};
+exports.AMDDefineRuntimeModule = AMDDefineRuntimeModule;
+exports.AMDOptionsRuntimeModule = AMDOptionsRuntimeModule;
 
 
 /***/ }),
 
-/***/ 92988:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 57403:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const fs = __webpack_require__(57147);
-const path = __webpack_require__(71017);
-const Template = __webpack_require__(39722);
-const { cleverMerge } = __webpack_require__(60839);
-const {
-	getTargetsProperties,
-	getTargetProperties,
-	getDefaultTarget
-} = __webpack_require__(52801);
+const DependencyTemplate = __webpack_require__(5160);
+const InitFragment = __webpack_require__(55870);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
-/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescription} EntryDescription */
-/** @typedef {import("../../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("../../declarations/WebpackOptions").Experiments} Experiments */
-/** @typedef {import("../../declarations/WebpackOptions").ExperimentsNormalized} ExperimentsNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsPresets} ExternalsPresets */
-/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Library} Library */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
-/** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
-/** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
-/** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
-/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../../declarations/WebpackOptions").Target} Target */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("./target").TargetProperties} TargetProperties */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
 
-const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
+class CachedConstDependency extends NullDependency {
+	constructor(expression, range, identifier) {
+		super();
 
-/**
- * Sets a constant default value when undefined
- * @template T
- * @template {keyof T} P
- * @param {T} obj an object
- * @param {P} prop a property of this object
- * @param {T[P]} value a default value of the property
- * @returns {void}
- */
-const D = (obj, prop, value) => {
-	if (obj[prop] === undefined) {
-		obj[prop] = value;
+		this.expression = expression;
+		this.range = range;
+		this.identifier = identifier;
+		this._hashUpdate = undefined;
 	}
-};
 
-/**
- * Sets a dynamic default value when undefined, by calling the factory function
- * @template T
- * @template {keyof T} P
- * @param {T} obj an object
- * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
- * @returns {void}
- */
-const F = (obj, prop, factory) => {
-	if (obj[prop] === undefined) {
-		obj[prop] = factory();
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined)
+			this._hashUpdate = "" + this.identifier + this.range + this.expression;
+		hash.update(this._hashUpdate);
 	}
-};
 
-/**
- * Sets a dynamic default value when undefined, by calling the factory function.
- * factory must return an array or undefined
- * When the current value is already an array an contains "..." it's replaced with
- * the result of the factory function
- * @template T
- * @template {keyof T} P
- * @param {T} obj an object
- * @param {P} prop a property of this object
- * @param {function(): T[P]} factory a default value factory for the property
- * @returns {void}
- */
-const A = (obj, prop, factory) => {
-	const value = obj[prop];
-	if (value === undefined) {
-		obj[prop] = factory();
-	} else if (Array.isArray(value)) {
-		/** @type {any[]} */
-		let newArray = undefined;
-		for (let i = 0; i < value.length; i++) {
-			const item = value[i];
-			if (item === "...") {
-				if (newArray === undefined) {
-					newArray = value.slice(0, i);
-					obj[prop] = /** @type {T[P]} */ (/** @type {unknown} */ (newArray));
-				}
-				const items = /** @type {any[]} */ (/** @type {unknown} */ (factory()));
-				if (items !== undefined) {
-					for (const item of items) {
-						newArray.push(item);
-					}
-				}
-			} else if (newArray !== undefined) {
-				newArray.push(item);
-			}
-		}
+	serialize(context) {
+		const { write } = context;
+
+		write(this.expression);
+		write(this.range);
+		write(this.identifier);
+
+		super.serialize(context);
 	}
-};
 
-/**
- * @param {WebpackOptions} options options to be modified
- * @returns {void}
- */
-const applyWebpackOptionsBaseDefaults = options => {
-	F(options, "context", () => process.cwd());
-	applyInfrastructureLoggingDefaults(options.infrastructureLogging);
-};
+	deserialize(context) {
+		const { read } = context;
 
-/**
- * @param {WebpackOptions} options options to be modified
- * @returns {void}
- */
-const applyWebpackOptionsDefaults = options => {
-	F(options, "context", () => process.cwd());
-	F(options, "target", () => {
-		return getDefaultTarget(options.context);
-	});
+		this.expression = read();
+		this.range = read();
+		this.identifier = read();
 
-	const { mode, name, target } = options;
+		super.deserialize(context);
+	}
+}
 
-	let targetProperties =
-		target === false
-			? /** @type {false} */ (false)
-			: typeof target === "string"
-			? getTargetProperties(target, options.context)
-			: getTargetsProperties(target, options.context);
+makeSerializable(
+	CachedConstDependency,
+	"webpack/lib/dependencies/CachedConstDependency"
+);
 
-	const development = mode === "development";
-	const production = mode === "production" || !mode;
+CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, dependencyTemplates, initFragments }
+	) {
+		const dep = /** @type {CachedConstDependency} */ (dependency);
 
-	if (typeof options.entry !== "function") {
-		for (const key of Object.keys(options.entry)) {
-			F(
-				options.entry[key],
-				"import",
-				() => /** @type {[string]} */ (["./src"])
-			);
+		initFragments.push(
+			new InitFragment(
+				`var ${dep.identifier} = ${dep.expression};\n`,
+				InitFragment.STAGE_CONSTANTS,
+				0,
+				`const ${dep.identifier}`
+			)
+		);
+
+		if (typeof dep.range === "number") {
+			source.insert(dep.range, dep.identifier);
+
+			return;
 		}
+
+		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
+};
 
-	F(options, "devtool", () => (development ? "eval" : false));
-	D(options, "watch", false);
-	D(options, "profile", false);
-	D(options, "parallelism", 100);
-	D(options, "recordsInputPath", false);
-	D(options, "recordsOutputPath", false);
+module.exports = CachedConstDependency;
 
-	applyExperimentsDefaults(options.experiments, {
-		production,
-		development,
-		targetProperties
-	});
 
-	const futureDefaults = options.experiments.futureDefaults;
+/***/ }),
 
-	F(options, "cache", () =>
-		development ? { type: /** @type {"memory"} */ ("memory") } : false
-	);
-	applyCacheDefaults(options.cache, {
-		name: name || "default",
-		mode: mode || "production",
-		development,
-		cacheUnaffected: options.experiments.cacheUnaffected
-	});
-	const cache = !!options.cache;
+/***/ 59643:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-	applySnapshotDefaults(options.snapshot, {
-		production,
-		futureDefaults
-	});
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	applyModuleDefaults(options.module, {
-		cache,
-		syncWebAssembly: options.experiments.syncWebAssembly,
-		asyncWebAssembly: options.experiments.asyncWebAssembly,
-		css: options.experiments.css,
-		futureDefaults
-	});
 
-	applyOutputDefaults(options.output, {
-		context: options.context,
-		targetProperties,
-		isAffectedByBrowserslist:
-			target === undefined ||
-			(typeof target === "string" && target.startsWith("browserslist")) ||
-			(Array.isArray(target) &&
-				target.some(target => target.startsWith("browserslist"))),
-		outputModule: options.experiments.outputModule,
-		development,
-		entry: options.entry,
-		module: options.module,
-		futureDefaults
-	});
 
-	applyExternalsPresetsDefaults(options.externalsPresets, {
-		targetProperties,
-		buildHttp: !!options.experiments.buildHttp
-	});
+const RuntimeGlobals = __webpack_require__(16475);
 
-	applyLoaderDefaults(options.loader, { targetProperties });
+exports.handleDependencyBase = (depBase, module, runtimeRequirements) => {
+	let base = undefined;
+	let type;
+	switch (depBase) {
+		case "exports":
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			base = module.exportsArgument;
+			type = "expression";
+			break;
+		case "module.exports":
+			runtimeRequirements.add(RuntimeGlobals.module);
+			base = `${module.moduleArgument}.exports`;
+			type = "expression";
+			break;
+		case "this":
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+			base = "this";
+			type = "expression";
+			break;
+		case "Object.defineProperty(exports)":
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			base = module.exportsArgument;
+			type = "Object.defineProperty";
+			break;
+		case "Object.defineProperty(module.exports)":
+			runtimeRequirements.add(RuntimeGlobals.module);
+			base = `${module.moduleArgument}.exports`;
+			type = "Object.defineProperty";
+			break;
+		case "Object.defineProperty(this)":
+			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+			base = "this";
+			type = "Object.defineProperty";
+			break;
+		default:
+			throw new Error(`Unsupported base ${depBase}`);
+	}
 
-	F(options, "externalsType", () => {
-		const validExternalTypes = (__webpack_require__(73342).definitions.ExternalsType["enum"]);
-		return options.output.library &&
-			validExternalTypes.includes(options.output.library.type)
-			? /** @type {ExternalsType} */ (options.output.library.type)
-			: options.output.module
-			? "module"
-			: "var";
-	});
+	return [type, base];
+};
 
-	applyNodeDefaults(options.node, {
-		futureDefaults: options.experiments.futureDefaults,
-		targetProperties
-	});
 
-	F(options, "performance", () =>
-		production &&
-		targetProperties &&
-		(targetProperties.browser || targetProperties.browser === null)
-			? {}
-			: false
-	);
-	applyPerformanceDefaults(options.performance, {
-		production
-	});
+/***/ }),
 
-	applyOptimizationDefaults(options.optimization, {
-		development,
-		production,
-		css: options.experiments.css,
-		records: !!(options.recordsInputPath || options.recordsOutputPath)
-	});
+/***/ 62892:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	options.resolve = cleverMerge(
-		getResolveDefaults({
-			cache,
-			context: options.context,
-			targetProperties,
-			mode: options.mode
-		}),
-		options.resolve
-	);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	options.resolveLoader = cleverMerge(
-		getResolveLoaderDefaults({ cache }),
-		options.resolveLoader
-	);
-};
 
-/**
- * @param {ExperimentsNormalized} experiments options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @param {boolean} options.development is development mode
- * @param {TargetProperties | false} options.targetProperties target properties
- * @returns {void}
- */
-const applyExperimentsDefaults = (
-	experiments,
-	{ production, development, targetProperties }
-) => {
-	D(experiments, "futureDefaults", false);
-	D(experiments, "backCompat", !experiments.futureDefaults);
-	D(experiments, "topLevelAwait", experiments.futureDefaults);
-	D(experiments, "syncWebAssembly", false);
-	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
-	D(experiments, "outputModule", false);
-	D(experiments, "layers", false);
-	D(experiments, "lazyCompilation", undefined);
-	D(experiments, "buildHttp", undefined);
-	D(experiments, "cacheUnaffected", experiments.futureDefaults);
-	F(experiments, "css", () => (experiments.futureDefaults ? {} : undefined));
 
-	if (typeof experiments.buildHttp === "object") {
-		D(experiments.buildHttp, "frozen", production);
-		D(experiments.buildHttp, "upgrade", false);
-	}
+const Dependency = __webpack_require__(54912);
+const { UsageState } = __webpack_require__(63686);
+const Template = __webpack_require__(1626);
+const { equals } = __webpack_require__(84953);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { handleDependencyBase } = __webpack_require__(59643);
+const ModuleDependency = __webpack_require__(80321);
+const processExportInfo = __webpack_require__(55207);
 
-	if (typeof experiments.css === "object") {
-		D(
-			experiments.css,
-			"exportsOnly",
-			!targetProperties || !targetProperties.document
-		);
-	}
-};
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @param {CacheOptions} cache options
- * @param {Object} options options
- * @param {string} options.name name
- * @param {string} options.mode mode
- * @param {boolean} options.development is development mode
- * @param {boolean} options.cacheUnaffected the cacheUnaffected experiment is enabled
- * @returns {void}
- */
-const applyCacheDefaults = (
-	cache,
-	{ name, mode, development, cacheUnaffected }
-) => {
-	if (cache === false) return;
-	switch (cache.type) {
-		case "filesystem":
-			F(cache, "name", () => name + "-" + mode);
-			D(cache, "version", "");
-			F(cache, "cacheDirectory", () => {
-				const cwd = process.cwd();
-				let dir = cwd;
-				for (;;) {
-					try {
-						if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
-						// eslint-disable-next-line no-empty
-					} catch (e) {}
-					const parent = path.dirname(dir);
-					if (dir === parent) {
-						dir = undefined;
-						break;
-					}
-					dir = parent;
-				}
-				if (!dir) {
-					return path.resolve(cwd, ".cache/webpack");
-				} else if (process.versions.pnp === "1") {
-					return path.resolve(dir, ".pnp/.cache/webpack");
-				} else if (process.versions.pnp === "3") {
-					return path.resolve(dir, ".yarn/.cache/webpack");
-				} else {
-					return path.resolve(dir, "node_modules/.cache/webpack");
-				}
-			});
-			F(cache, "cacheLocation", () =>
-				path.resolve(cache.cacheDirectory, cache.name)
-			);
-			D(cache, "hashAlgorithm", "md4");
-			D(cache, "store", "pack");
-			D(cache, "compression", false);
-			D(cache, "profile", false);
-			D(cache, "idleTimeout", 60000);
-			D(cache, "idleTimeoutForInitialStore", 5000);
-			D(cache, "idleTimeoutAfterLargeChanges", 1000);
-			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
-			D(cache, "maxAge", 1000 * 60 * 60 * 24 * 60); // 1 month
-			D(cache, "allowCollectingMemory", development);
-			D(cache, "memoryCacheUnaffected", development && cacheUnaffected);
-			D(cache.buildDependencies, "defaultWebpack", [
-				path.resolve(__dirname, "..") + path.sep
-			]);
-			break;
-		case "memory":
-			D(cache, "maxGenerations", Infinity);
-			D(cache, "cacheUnaffected", development && cacheUnaffected);
-			break;
-	}
-};
+const idsSymbol = Symbol("CommonJsExportRequireDependency.ids");
 
-/**
- * @param {SnapshotOptions} snapshot options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
- */
-const applySnapshotDefaults = (snapshot, { production, futureDefaults }) => {
-	if (futureDefaults) {
-		F(snapshot, "managedPaths", () =>
-			process.versions.pnp === "3"
-				? [
-						/^(.+?(?:[\\/]\.yarn[\\/]unplugged[\\/][^\\/]+)?[\\/]node_modules[\\/])/
-				  ]
-				: [/^(.+?[\\/]node_modules[\\/])/]
-		);
-		F(snapshot, "immutablePaths", () =>
-			process.versions.pnp === "3"
-				? [/^(.+?[\\/]cache[\\/][^\\/]+\.zip[\\/]node_modules[\\/])/]
-				: []
-		);
-	} else {
-		A(snapshot, "managedPaths", () => {
-			if (process.versions.pnp === "3") {
-				const match =
-					/^(.+?)[\\/]cache[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-						/*require.resolve*/(36871)
-					);
-				if (match) {
-					return [path.resolve(match[1], "unplugged")];
-				}
-			} else {
-				const match = /^(.+?[\\/]node_modules[\\/])/.exec(
-					// eslint-disable-next-line node/no-extraneous-require
-					/*require.resolve*/(36871)
-				);
-				if (match) {
-					return [match[1]];
-				}
-			}
-			return [];
-		});
-		A(snapshot, "immutablePaths", () => {
-			if (process.versions.pnp === "1") {
-				const match =
-					/^(.+?[\\/]v4)[\\/]npm-watchpack-[^\\/]+-[\da-f]{40}[\\/]node_modules[\\/]/.exec(
-						/*require.resolve*/(36871)
-					);
-				if (match) {
-					return [match[1]];
-				}
-			} else if (process.versions.pnp === "3") {
-				const match =
-					/^(.+?)[\\/]watchpack-npm-[^\\/]+\.zip[\\/]node_modules[\\/]/.exec(
-						/*require.resolve*/(36871)
-					);
-				if (match) {
-					return [match[1]];
-				}
-			}
-			return [];
-		});
+const EMPTY_OBJECT = {};
+
+class CommonJsExportRequireDependency extends ModuleDependency {
+	constructor(range, valueRange, base, names, request, ids, resultUsed) {
+		super(request);
+		this.range = range;
+		this.valueRange = valueRange;
+		this.base = base;
+		this.names = names;
+		this.ids = ids;
+		this.resultUsed = resultUsed;
+		this.asiSafe = undefined;
 	}
-	F(snapshot, "resolveBuildDependencies", () => ({
-		timestamp: true,
-		hash: true
-	}));
-	F(snapshot, "buildDependencies", () => ({ timestamp: true, hash: true }));
-	F(snapshot, "module", () =>
-		production ? { timestamp: true, hash: true } : { timestamp: true }
-	);
-	F(snapshot, "resolve", () =>
-		production ? { timestamp: true, hash: true } : { timestamp: true }
-	);
-};
 
-/**
- * @param {JavascriptParserOptions} parserOptions parser options
- * @param {Object} options options
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
- */
-const applyJavascriptParserOptionsDefaults = (
-	parserOptions,
-	{ futureDefaults }
-) => {
-	D(parserOptions, "unknownContextRequest", ".");
-	D(parserOptions, "unknownContextRegExp", false);
-	D(parserOptions, "unknownContextRecursive", true);
-	D(parserOptions, "unknownContextCritical", true);
-	D(parserOptions, "exprContextRequest", ".");
-	D(parserOptions, "exprContextRegExp", false);
-	D(parserOptions, "exprContextRecursive", true);
-	D(parserOptions, "exprContextCritical", true);
-	D(parserOptions, "wrappedContextRegExp", /.*/);
-	D(parserOptions, "wrappedContextRecursive", true);
-	D(parserOptions, "wrappedContextCritical", false);
-	D(parserOptions, "strictThisContextOnImports", false);
-	D(parserOptions, "importMeta", true);
-	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
-};
+	get type() {
+		return "cjs export require";
+	}
 
-/**
- * @param {ModuleOptions} module options
- * @param {Object} options options
- * @param {boolean} options.cache is caching enabled
- * @param {boolean} options.syncWebAssembly is syncWebAssembly enabled
- * @param {boolean} options.asyncWebAssembly is asyncWebAssembly enabled
- * @param {CssExperimentOptions} options.css is css enabled
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
- */
-const applyModuleDefaults = (
-	module,
-	{ cache, syncWebAssembly, asyncWebAssembly, css, futureDefaults }
-) => {
-	if (cache) {
-		D(module, "unsafeCache", module => {
-			const name = module.nameForCondition();
-			return name && NODE_MODULES_REGEXP.test(name);
-		});
-	} else {
-		D(module, "unsafeCache", false);
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
 	}
 
-	F(module.parser, "asset", () => ({}));
-	F(module.parser.asset, "dataUrlCondition", () => ({}));
-	if (typeof module.parser.asset.dataUrlCondition === "object") {
-		D(module.parser.asset.dataUrlCondition, "maxSize", 8096);
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported id
+	 */
+	getIds(moduleGraph) {
+		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
 	}
 
-	F(module.parser, "javascript", () => ({}));
-	applyJavascriptParserOptionsDefaults(module.parser.javascript, {
-		futureDefaults
-	});
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	}
 
-	A(module, "defaultRules", () => {
-		const esm = {
-			type: "javascript/esm",
-			resolve: {
-				byDependency: {
-					esm: {
-						fullySpecified: true
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		const ids = this.getIds(moduleGraph);
+		const getFullResult = () => {
+			if (ids.length === 0) {
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
+			} else {
+				return [
+					{
+						name: ids,
+						canMangle: false
 					}
-				}
+				];
 			}
 		};
-		const commonjs = {
-			type: "javascript/dynamic"
-		};
-		/** @type {RuleSetRules} */
-		const rules = [
-			{
-				mimetype: "application/node",
-				type: "javascript/auto"
-			},
-			{
-				test: /\.json$/i,
-				type: "json"
-			},
-			{
-				mimetype: "application/json",
-				type: "json"
-			},
-			{
-				test: /\.mjs$/i,
-				...esm
-			},
-			{
-				test: /\.js$/i,
-				descriptionData: {
-					type: "module"
-				},
-				...esm
-			},
-			{
-				test: /\.cjs$/i,
-				...commonjs
-			},
-			{
-				test: /\.js$/i,
-				descriptionData: {
-					type: "commonjs"
-				},
-				...commonjs
-			},
-			{
-				mimetype: {
-					or: ["text/javascript", "application/javascript"]
-				},
-				...esm
-			}
-		];
-		if (asyncWebAssembly) {
-			const wasm = {
-				type: "webassembly/async",
-				rules: [
+		if (this.resultUsed) return getFullResult();
+		let exportsInfo = moduleGraph.getExportsInfo(
+			moduleGraph.getParentModule(this)
+		);
+		for (const name of this.names) {
+			const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+			const used = exportInfo.getUsed(runtime);
+			if (used === UsageState.Unused) return Dependency.NO_EXPORTS_REFERENCED;
+			if (used !== UsageState.OnlyPropertiesUsed) return getFullResult();
+			exportsInfo = exportInfo.exportsInfo;
+			if (!exportsInfo) return getFullResult();
+		}
+		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+			return getFullResult();
+		}
+		/** @type {string[][]} */
+		const referencedExports = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			processExportInfo(
+				runtime,
+				referencedExports,
+				ids.concat(exportInfo.name),
+				exportInfo,
+				false
+			);
+		}
+		return referencedExports.map(name => ({
+			name,
+			canMangle: false
+		}));
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		if (this.names.length === 1) {
+			const name = this.names[0];
+			const from = moduleGraph.getConnection(this);
+			if (!from) return;
+			return {
+				exports: [
 					{
-						descriptionData: {
-							type: "module"
-						},
-						resolve: {
-							fullySpecified: true
-						}
+						name,
+						from,
+						export: ids.length === 0 ? null : ids,
+						// we can't mangle names that are in an empty object
+						// because one could access the prototype property
+						// when export isn't set yet
+						canMangle: !(name in EMPTY_OBJECT) && false
 					}
-				]
-			};
-			rules.push({
-				test: /\.wasm$/i,
-				...wasm
-			});
-			rules.push({
-				mimetype: "application/wasm",
-				...wasm
-			});
-		} else if (syncWebAssembly) {
-			const wasm = {
-				type: "webassembly/sync",
-				rules: [
-					{
-						descriptionData: {
-							type: "module"
-						},
-						resolve: {
-							fullySpecified: true
-						}
-					}
-				]
-			};
-			rules.push({
-				test: /\.wasm$/i,
-				...wasm
-			});
-			rules.push({
-				mimetype: "application/wasm",
-				...wasm
-			});
-		}
-		if (css) {
-			const cssRule = {
-				type: "css",
-				resolve: {
-					fullySpecified: true,
-					preferRelative: true
-				}
-			};
-			const cssModulesRule = {
-				type: "css/module",
-				resolve: {
-					fullySpecified: true
-				}
+				],
+				dependencies: [from.module]
 			};
-			rules.push({
-				test: /\.css$/i,
-				oneOf: [
-					{
-						test: /\.module\.css$/i,
-						...cssModulesRule
-					},
-					{
-						...cssRule
-					}
-				]
-			});
-			rules.push({
-				mimetype: "text/css+module",
-				...cssModulesRule
-			});
-			rules.push({
-				mimetype: "text/css",
-				...cssRule
-			});
-		}
-		rules.push(
-			{
-				dependency: "url",
-				oneOf: [
-					{
-						scheme: /^data$/,
-						type: "asset/inline"
-					},
+		} else if (this.names.length > 0) {
+			const name = this.names[0];
+			return {
+				exports: [
 					{
-						type: "asset/resource"
+						name,
+						// we can't mangle names that are in an empty object
+						// because one could access the prototype property
+						// when export isn't set yet
+						canMangle: !(name in EMPTY_OBJECT) && false
 					}
-				]
-			},
-			{
-				assert: { type: "json" },
-				type: "json"
+				],
+				dependencies: undefined
+			};
+		} else {
+			const from = moduleGraph.getConnection(this);
+			if (!from) return;
+			const reexportInfo = this.getStarReexports(
+				moduleGraph,
+				undefined,
+				from.module
+			);
+			if (reexportInfo) {
+				return {
+					exports: Array.from(reexportInfo.exports, name => {
+						return {
+							name,
+							from,
+							export: ids.concat(name),
+							canMangle: !(name in EMPTY_OBJECT) && false
+						};
+					}),
+					// TODO handle deep reexports
+					dependencies: [from.module]
+				};
+			} else {
+				return {
+					exports: true,
+					from: ids.length === 0 ? from : undefined,
+					canMangle: false,
+					dependencies: [from.module]
+				};
 			}
-		);
-		return rules;
-	});
-};
-
-/**
- * @param {Output} output options
- * @param {Object} options options
- * @param {string} options.context context
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {boolean} options.isAffectedByBrowserslist is affected by browserslist
- * @param {boolean} options.outputModule is outputModule experiment enabled
- * @param {boolean} options.development is development mode
- * @param {Entry} options.entry entry option
- * @param {ModuleOptions} options.module module option
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
- */
-const applyOutputDefaults = (
-	output,
-	{
-		context,
-		targetProperties: tp,
-		isAffectedByBrowserslist,
-		outputModule,
-		development,
-		entry,
-		module,
-		futureDefaults
+		}
 	}
-) => {
+
 	/**
-	 * @param {Library=} library the library option
-	 * @returns {string} a readable library name
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Module} importedModule the imported module (optional)
+	 * @returns {{exports?: Set<string>, checked?: Set<string>}} information
 	 */
-	const getLibraryName = library => {
-		const libraryName =
-			typeof library === "object" &&
-			library &&
-			!Array.isArray(library) &&
-			"type" in library
-				? library.name
-				: /** @type {LibraryName=} */ (library);
-		if (Array.isArray(libraryName)) {
-			return libraryName.join(".");
-		} else if (typeof libraryName === "object") {
-			return getLibraryName(libraryName.root);
-		} else if (typeof libraryName === "string") {
-			return libraryName;
-		}
-		return "";
-	};
+	getStarReexports(
+		moduleGraph,
+		runtime,
+		importedModule = moduleGraph.getModule(this)
+	) {
+		let importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+		const ids = this.getIds(moduleGraph);
+		if (ids.length > 0)
+			importedExportsInfo = importedExportsInfo.getNestedExportsInfo(ids);
+		let exportsInfo = moduleGraph.getExportsInfo(
+			moduleGraph.getParentModule(this)
+		);
+		if (this.names.length > 0)
+			exportsInfo = exportsInfo.getNestedExportsInfo(this.names);
 
-	F(output, "uniqueName", () => {
-		const libraryName = getLibraryName(output.library);
-		if (libraryName) return libraryName;
-		const pkgPath = path.resolve(context, "package.json");
-		try {
-			const packageInfo = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-			return packageInfo.name || "";
-		} catch (e) {
-			if (e.code !== "ENOENT") {
-				e.message += `\nwhile determining default 'output.uniqueName' from 'name' in ${pkgPath}`;
-				throw e;
-			}
-			return "";
-		}
-	});
+		const noExtraExports =
+			importedExportsInfo &&
+			importedExportsInfo.otherExportsInfo.provided === false;
+		const noExtraImports =
+			exportsInfo &&
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
 
-	F(output, "module", () => !!outputModule);
-	D(output, "filename", output.module ? "[name].mjs" : "[name].js");
-	F(output, "iife", () => !output.module);
-	D(output, "importFunctionName", "import");
-	D(output, "importMetaName", "import.meta");
-	F(output, "chunkFilename", () => {
-		const filename = output.filename;
-		if (typeof filename !== "function") {
-			const hasName = filename.includes("[name]");
-			const hasId = filename.includes("[id]");
-			const hasChunkHash = filename.includes("[chunkhash]");
-			const hasContentHash = filename.includes("[contenthash]");
-			// Anything changing depending on chunk is fine
-			if (hasChunkHash || hasContentHash || hasName || hasId) return filename;
-			// Otherwise prefix "[id]." in front of the basename to make it changing
-			return filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
-		}
-		return output.module ? "[id].mjs" : "[id].js";
-	});
-	F(output, "cssFilename", () => {
-		const filename = output.filename;
-		if (typeof filename !== "function") {
-			return filename.replace(/\.[mc]?js(\?|$)/, ".css$1");
-		}
-		return "[id].css";
-	});
-	F(output, "cssChunkFilename", () => {
-		const chunkFilename = output.chunkFilename;
-		if (typeof chunkFilename !== "function") {
-			return chunkFilename.replace(/\.[mc]?js(\?|$)/, ".css$1");
-		}
-		return "[id].css";
-	});
-	D(output, "assetModuleFilename", "[hash][ext][query]");
-	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
-	D(output, "compareBeforeEmit", true);
-	D(output, "charset", true);
-	F(output, "hotUpdateGlobal", () =>
-		Template.toIdentifier(
-			"webpackHotUpdate" + Template.toIdentifier(output.uniqueName)
-		)
-	);
-	F(output, "chunkLoadingGlobal", () =>
-		Template.toIdentifier(
-			"webpackChunk" + Template.toIdentifier(output.uniqueName)
-		)
-	);
-	F(output, "globalObject", () => {
-		if (tp) {
-			if (tp.global) return "global";
-			if (tp.globalThis) return "globalThis";
-		}
-		return "self";
-	});
-	F(output, "chunkFormat", () => {
-		if (tp) {
-			const helpMessage = isAffectedByBrowserslist
-				? "Make sure that your 'browserslist' includes only platforms that support these features or select an appropriate 'target' to allow selecting a chunk format by default. Alternatively specify the 'output.chunkFormat' directly."
-				: "Select an appropriate 'target' to allow selecting one by default, or specify the 'output.chunkFormat' directly.";
-			if (output.module) {
-				if (tp.dynamicImport) return "module";
-				if (tp.document) return "array-push";
-				throw new Error(
-					"For the selected environment is no default ESM chunk format available:\n" +
-						"ESM exports can be chosen when 'import()' is available.\n" +
-						"JSONP Array push can be chosen when 'document' is available.\n" +
-						helpMessage
-				);
-			} else {
-				if (tp.document) return "array-push";
-				if (tp.require) return "commonjs";
-				if (tp.nodeBuiltins) return "commonjs";
-				if (tp.importScripts) return "array-push";
-				throw new Error(
-					"For the selected environment is no default script chunk format available:\n" +
-						"JSONP Array push can be chosen when 'document' or 'importScripts' is available.\n" +
-						"CommonJs exports can be chosen when 'require' or node builtins are available.\n" +
-						helpMessage
-				);
-			}
-		}
-		throw new Error(
-			"Chunk format can't be selected by default when no target is specified"
-		);
-	});
-	D(output, "asyncChunks", true);
-	F(output, "chunkLoading", () => {
-		if (tp) {
-			switch (output.chunkFormat) {
-				case "array-push":
-					if (tp.document) return "jsonp";
-					if (tp.importScripts) return "import-scripts";
-					break;
-				case "commonjs":
-					if (tp.require) return "require";
-					if (tp.nodeBuiltins) return "async-node";
-					break;
-				case "module":
-					if (tp.dynamicImport) return "import";
-					break;
-			}
-			if (
-				tp.require === null ||
-				tp.nodeBuiltins === null ||
-				tp.document === null ||
-				tp.importScripts === null
-			) {
-				return "universal";
-			}
+		if (!noExtraExports && !noExtraImports) {
+			return;
 		}
-		return false;
-	});
-	F(output, "workerChunkLoading", () => {
-		if (tp) {
-			switch (output.chunkFormat) {
-				case "array-push":
-					if (tp.importScriptsInWorker) return "import-scripts";
-					break;
-				case "commonjs":
-					if (tp.require) return "require";
-					if (tp.nodeBuiltins) return "async-node";
-					break;
-				case "module":
-					if (tp.dynamicImportInWorker) return "import";
-					break;
+
+		const isNamespaceImport =
+			importedModule.getExportsType(moduleGraph, false) === "namespace";
+
+		/** @type {Set<string>} */
+		const exports = new Set();
+		/** @type {Set<string>} */
+		const checked = new Set();
+
+		if (noExtraImports) {
+			for (const exportInfo of exportsInfo.orderedExports) {
+				const name = exportInfo.name;
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				if (name === "__esModule" && isNamespaceImport) {
+					exports.add(name);
+				} else if (importedExportsInfo) {
+					const importedExportInfo =
+						importedExportsInfo.getReadOnlyExportInfo(name);
+					if (importedExportInfo.provided === false) continue;
+					exports.add(name);
+					if (importedExportInfo.provided === true) continue;
+					checked.add(name);
+				} else {
+					exports.add(name);
+					checked.add(name);
+				}
 			}
-			if (
-				tp.require === null ||
-				tp.nodeBuiltins === null ||
-				tp.importScriptsInWorker === null
-			) {
-				return "universal";
+		} else if (noExtraExports) {
+			for (const importedExportInfo of importedExportsInfo.orderedExports) {
+				const name = importedExportInfo.name;
+				if (importedExportInfo.provided === false) continue;
+				if (exportsInfo) {
+					const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+					if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
 			}
-		}
-		return false;
-	});
-	F(output, "wasmLoading", () => {
-		if (tp) {
-			if (tp.fetchWasm) return "fetch";
-			if (tp.nodeBuiltins)
-				return output.module ? "async-node-module" : "async-node";
-			if (tp.nodeBuiltins === null || tp.fetchWasm === null) {
-				return "universal";
+			if (isNamespaceImport) {
+				exports.add("__esModule");
+				checked.delete("__esModule");
 			}
 		}
-		return false;
-	});
-	F(output, "workerWasmLoading", () => output.wasmLoading);
-	F(output, "devtoolNamespace", () => output.uniqueName);
-	if (output.library) {
-		F(output.library, "type", () => (output.module ? "module" : "var"));
+
+		return { exports, checked };
 	}
-	F(output, "path", () => path.join(process.cwd(), "dist"));
-	F(output, "pathinfo", () => development);
-	D(output, "sourceMapFilename", "[file].map[query]");
-	D(
-		output,
-		"hotUpdateChunkFilename",
-		`[id].[fullhash].hot-update.${output.module ? "mjs" : "js"}`
-	);
-	D(output, "hotUpdateMainFilename", "[runtime].[fullhash].hot-update.json");
-	D(output, "crossOriginLoading", false);
-	F(output, "scriptType", () => (output.module ? "module" : false));
-	D(
-		output,
-		"publicPath",
-		(tp && (tp.document || tp.importScripts)) || output.scriptType === "module"
-			? "auto"
-			: ""
-	);
-	D(output, "chunkLoadTimeout", 120000);
-	D(output, "hashFunction", futureDefaults ? "xxhash64" : "md4");
-	D(output, "hashDigest", "hex");
-	D(output, "hashDigestLength", futureDefaults ? 16 : 20);
-	D(output, "strictModuleExceptionHandling", false);
 
-	const optimistic = v => v || v === undefined;
-	F(
-		output.environment,
-		"arrowFunction",
-		() => tp && optimistic(tp.arrowFunction)
-	);
-	F(output.environment, "const", () => tp && optimistic(tp.const));
-	F(
-		output.environment,
-		"destructuring",
-		() => tp && optimistic(tp.destructuring)
-	);
-	F(output.environment, "forOf", () => tp && optimistic(tp.forOf));
-	F(output.environment, "bigIntLiteral", () => tp && tp.bigIntLiteral);
-	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
-	F(output.environment, "module", () => tp && tp.module);
+	serialize(context) {
+		const { write } = context;
+		write(this.asiSafe);
+		write(this.range);
+		write(this.valueRange);
+		write(this.base);
+		write(this.names);
+		write(this.ids);
+		write(this.resultUsed);
+		super.serialize(context);
+	}
 
-	const { trustedTypes } = output;
-	if (trustedTypes) {
-		F(
-			trustedTypes,
-			"policyName",
-			() =>
-				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
-		);
+	deserialize(context) {
+		const { read } = context;
+		this.asiSafe = read();
+		this.range = read();
+		this.valueRange = read();
+		this.base = read();
+		this.names = read();
+		this.ids = read();
+		this.resultUsed = read();
+		super.deserialize(context);
 	}
+}
+
+makeSerializable(
+	CommonJsExportRequireDependency,
+	"webpack/lib/dependencies/CommonJsExportRequireDependency"
+);
 
+CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @param {function(EntryDescription): void} fn iterator
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	const forEachEntry = fn => {
-		for (const name of Object.keys(entry)) {
-			fn(entry[name]);
-		}
-	};
-	A(output, "enabledLibraryTypes", () => {
-		const enabledLibraryTypes = [];
-		if (output.library) {
-			enabledLibraryTypes.push(output.library.type);
+	apply(
+		dependency,
+		source,
+		{
+			module,
+			runtimeTemplate,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtime
 		}
-		forEachEntry(desc => {
-			if (desc.library) {
-				enabledLibraryTypes.push(desc.library.type);
-			}
-		});
-		return enabledLibraryTypes;
-	});
-
-	A(output, "enabledChunkLoadingTypes", () => {
-		const enabledChunkLoadingTypes = new Set();
-		if (output.chunkLoading) {
-			enabledChunkLoadingTypes.add(output.chunkLoading);
-		}
-		if (output.workerChunkLoading) {
-			enabledChunkLoadingTypes.add(output.workerChunkLoading);
-		}
-		forEachEntry(desc => {
-			if (desc.chunkLoading) {
-				enabledChunkLoadingTypes.add(desc.chunkLoading);
-			}
-		});
-		return Array.from(enabledChunkLoadingTypes);
-	});
-
-	A(output, "enabledWasmLoadingTypes", () => {
-		const enabledWasmLoadingTypes = new Set();
-		if (output.wasmLoading) {
-			enabledWasmLoadingTypes.add(output.wasmLoading);
-		}
-		if (output.workerWasmLoading) {
-			enabledWasmLoadingTypes.add(output.workerWasmLoading);
-		}
-		forEachEntry(desc => {
-			if (desc.wasmLoading) {
-				enabledWasmLoadingTypes.add(desc.wasmLoading);
-			}
-		});
-		return Array.from(enabledWasmLoadingTypes);
-	});
-};
+	) {
+		const dep = /** @type {CommonJsExportRequireDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.names, runtime);
 
-/**
- * @param {ExternalsPresets} externalsPresets options
- * @param {Object} options options
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {boolean} options.buildHttp buildHttp experiment enabled
- * @returns {void}
- */
-const applyExternalsPresetsDefaults = (
-	externalsPresets,
-	{ targetProperties, buildHttp }
-) => {
-	D(
-		externalsPresets,
-		"web",
-		!buildHttp && targetProperties && targetProperties.web
-	);
-	D(externalsPresets, "node", targetProperties && targetProperties.node);
-	D(externalsPresets, "nwjs", targetProperties && targetProperties.nwjs);
-	D(
-		externalsPresets,
-		"electron",
-		targetProperties && targetProperties.electron
-	);
-	D(
-		externalsPresets,
-		"electronMain",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronMain
-	);
-	D(
-		externalsPresets,
-		"electronPreload",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronPreload
-	);
-	D(
-		externalsPresets,
-		"electronRenderer",
-		targetProperties &&
-			targetProperties.electron &&
-			targetProperties.electronRenderer
-	);
-};
+		const [type, base] = handleDependencyBase(
+			dep.base,
+			module,
+			runtimeRequirements
+		);
 
-/**
- * @param {Loader} loader options
- * @param {Object} options options
- * @param {TargetProperties | false} options.targetProperties target properties
- * @returns {void}
- */
-const applyLoaderDefaults = (loader, { targetProperties }) => {
-	F(loader, "target", () => {
-		if (targetProperties) {
-			if (targetProperties.electron) {
-				if (targetProperties.electronMain) return "electron-main";
-				if (targetProperties.electronPreload) return "electron-preload";
-				if (targetProperties.electronRenderer) return "electron-renderer";
-				return "electron";
+		const importedModule = moduleGraph.getModule(dep);
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+		if (importedModule) {
+			const ids = dep.getIds(moduleGraph);
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				requireExpr += `${comment}${propertyAccess(usedImported)}`;
 			}
-			if (targetProperties.nwjs) return "nwjs";
-			if (targetProperties.node) return "node";
-			if (targetProperties.web) return "web";
 		}
-	});
-};
-
-/**
- * @param {WebpackNode} node options
- * @param {Object} options options
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {boolean} options.futureDefaults is future defaults enabled
- * @returns {void}
- */
-const applyNodeDefaults = (node, { futureDefaults, targetProperties }) => {
-	if (node === false) return;
-
-	F(node, "global", () => {
-		if (targetProperties && targetProperties.global) return false;
-		// TODO webpack 6 should always default to false
-		return futureDefaults ? "warn" : true;
-	});
-	F(node, "__filename", () => {
-		if (targetProperties && targetProperties.node) return "eval-only";
-		// TODO webpack 6 should always default to false
-		return futureDefaults ? "warn-mock" : "mock";
-	});
-	F(node, "__dirname", () => {
-		if (targetProperties && targetProperties.node) return "eval-only";
-		// TODO webpack 6 should always default to false
-		return futureDefaults ? "warn-mock" : "mock";
-	});
-};
-
-/**
- * @param {Performance} performance options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @returns {void}
- */
-const applyPerformanceDefaults = (performance, { production }) => {
-	if (performance === false) return;
-	D(performance, "maxAssetSize", 250000);
-	D(performance, "maxEntrypointSize", 250000);
-	F(performance, "hints", () => (production ? "warning" : false));
-};
 
-/**
- * @param {Optimization} optimization options
- * @param {Object} options options
- * @param {boolean} options.production is production
- * @param {boolean} options.development is development
- * @param {CssExperimentOptions} options.css is css enabled
- * @param {boolean} options.records using records
- * @returns {void}
- */
-const applyOptimizationDefaults = (
-	optimization,
-	{ production, development, css, records }
-) => {
-	D(optimization, "removeAvailableModules", false);
-	D(optimization, "removeEmptyChunks", true);
-	D(optimization, "mergeDuplicateChunks", true);
-	D(optimization, "flagIncludedChunks", production);
-	F(optimization, "moduleIds", () => {
-		if (production) return "deterministic";
-		if (development) return "named";
-		return "natural";
-	});
-	F(optimization, "chunkIds", () => {
-		if (production) return "deterministic";
-		if (development) return "named";
-		return "natural";
-	});
-	F(optimization, "sideEffects", () => (production ? true : "flag"));
-	D(optimization, "providedExports", true);
-	D(optimization, "usedExports", production);
-	D(optimization, "innerGraph", production);
-	D(optimization, "mangleExports", production);
-	D(optimization, "concatenateModules", production);
-	D(optimization, "runtimeChunk", false);
-	D(optimization, "emitOnErrors", !production);
-	D(optimization, "checkWasmTypes", production);
-	D(optimization, "mangleWasmImports", false);
-	D(optimization, "portableRecords", records);
-	D(optimization, "realContentHash", production);
-	D(optimization, "minimize", production);
-	A(optimization, "minimizer", () => [
-		{
-			apply: compiler => {
-				// Lazy load the Terser plugin
-				const TerserPlugin = __webpack_require__(55302);
-				new TerserPlugin({
-					terserOptions: {
-						compress: {
-							passes: 2
-						}
-					}
-				}).apply(compiler);
-			}
+		switch (type) {
+			case "expression":
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					used
+						? `${base}${propertyAccess(used)} = ${requireExpr}`
+						: `/* unused reexport */ ${requireExpr}`
+				);
+				return;
+			case "Object.defineProperty":
+				throw new Error("TODO");
+			default:
+				throw new Error("Unexpected type");
 		}
-	]);
-	F(optimization, "nodeEnv", () => {
-		if (production) return "production";
-		if (development) return "development";
-		return false;
-	});
-	const { splitChunks } = optimization;
-	if (splitChunks) {
-		A(splitChunks, "defaultSizeTypes", () =>
-			css ? ["javascript", "css", "unknown"] : ["javascript", "unknown"]
-		);
-		D(splitChunks, "hidePathInfo", production);
-		D(splitChunks, "chunks", "async");
-		D(splitChunks, "usedExports", optimization.usedExports === true);
-		D(splitChunks, "minChunks", 1);
-		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
-		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));
-		F(splitChunks, "enforceSizeThreshold", () => (production ? 50000 : 30000));
-		F(splitChunks, "maxAsyncRequests", () => (production ? 30 : Infinity));
-		F(splitChunks, "maxInitialRequests", () => (production ? 30 : Infinity));
-		D(splitChunks, "automaticNameDelimiter", "-");
-		const { cacheGroups } = splitChunks;
-		F(cacheGroups, "default", () => ({
-			idHint: "",
-			reuseExistingChunk: true,
-			minChunks: 2,
-			priority: -20
-		}));
-		F(cacheGroups, "defaultVendors", () => ({
-			idHint: "vendors",
-			reuseExistingChunk: true,
-			test: NODE_MODULES_REGEXP,
-			priority: -10
-		}));
-	}
-};
-
-/**
- * @param {Object} options options
- * @param {boolean} options.cache is cache enable
- * @param {string} options.context build context
- * @param {TargetProperties | false} options.targetProperties target properties
- * @param {Mode} options.mode mode
- * @returns {ResolveOptions} resolve options
- */
-const getResolveDefaults = ({ cache, context, targetProperties, mode }) => {
-	/** @type {string[]} */
-	const conditions = ["webpack"];
-
-	conditions.push(mode === "development" ? "development" : "production");
-
-	if (targetProperties) {
-		if (targetProperties.webworker) conditions.push("worker");
-		if (targetProperties.node) conditions.push("node");
-		if (targetProperties.web) conditions.push("browser");
-		if (targetProperties.electron) conditions.push("electron");
-		if (targetProperties.nwjs) conditions.push("nwjs");
 	}
-
-	const jsExtensions = [".js", ".json", ".wasm"];
-
-	const tp = targetProperties;
-	const browserField =
-		tp && tp.web && (!tp.node || (tp.electron && tp.electronRenderer));
-
-	/** @type {function(): ResolveOptions} */
-	const cjsDeps = () => ({
-		aliasFields: browserField ? ["browser"] : [],
-		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
-		conditionNames: ["require", "module", "..."],
-		extensions: [...jsExtensions]
-	});
-	/** @type {function(): ResolveOptions} */
-	const esmDeps = () => ({
-		aliasFields: browserField ? ["browser"] : [],
-		mainFields: browserField ? ["browser", "module", "..."] : ["module", "..."],
-		conditionNames: ["import", "module", "..."],
-		extensions: [...jsExtensions]
-	});
-
-	/** @type {ResolveOptions} */
-	const resolveOptions = {
-		cache,
-		modules: ["node_modules"],
-		conditionNames: conditions,
-		mainFiles: ["index"],
-		extensions: [],
-		aliasFields: [],
-		exportsFields: ["exports"],
-		roots: [context],
-		mainFields: ["main"],
-		byDependency: {
-			wasm: esmDeps(),
-			esm: esmDeps(),
-			loaderImport: esmDeps(),
-			url: {
-				preferRelative: true
-			},
-			worker: {
-				...esmDeps(),
-				preferRelative: true
-			},
-			commonjs: cjsDeps(),
-			amd: cjsDeps(),
-			// for backward-compat: loadModule
-			loader: cjsDeps(),
-			// for backward-compat: Custom Dependency
-			unknown: cjsDeps(),
-			// for backward-compat: getResolve without dependencyType
-			undefined: cjsDeps()
-		}
-	};
-
-	return resolveOptions;
-};
-
-/**
- * @param {Object} options options
- * @param {boolean} options.cache is cache enable
- * @returns {ResolveOptions} resolve options
- */
-const getResolveLoaderDefaults = ({ cache }) => {
-	/** @type {ResolveOptions} */
-	const resolveOptions = {
-		cache,
-		conditionNames: ["loader", "require", "node"],
-		exportsFields: ["exports"],
-		mainFields: ["loader", "main"],
-		extensions: [".js"],
-		mainFiles: ["index"]
-	};
-
-	return resolveOptions;
-};
-
-/**
- * @param {InfrastructureLogging} infrastructureLogging options
- * @returns {void}
- */
-const applyInfrastructureLoggingDefaults = infrastructureLogging => {
-	F(infrastructureLogging, "stream", () => process.stderr);
-	const tty =
-		/** @type {any} */ (infrastructureLogging.stream).isTTY &&
-		process.env.TERM !== "dumb";
-	D(infrastructureLogging, "level", "info");
-	D(infrastructureLogging, "debug", false);
-	D(infrastructureLogging, "colors", tty);
-	D(infrastructureLogging, "appendOnly", !tty);
 };
 
-exports.applyWebpackOptionsBaseDefaults = applyWebpackOptionsBaseDefaults;
-exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
+module.exports = CommonJsExportRequireDependency;
 
 
 /***/ }),
 
-/***/ 26693:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 45598:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -72549,533 +72895,509 @@ exports.applyWebpackOptionsDefaults = applyWebpackOptionsDefaults;
 
 
 
-const util = __webpack_require__(73837);
+const InitFragment = __webpack_require__(55870);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { handleDependencyBase } = __webpack_require__(59643);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
-/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-const handledDeprecatedNoEmitOnErrors = util.deprecate(
-	(noEmitOnErrors, emitOnErrors) => {
-		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
-			throw new Error(
-				"Conflicting use of 'optimization.noEmitOnErrors' and 'optimization.emitOnErrors'. Remove deprecated 'optimization.noEmitOnErrors' from config."
-			);
-		}
-		return !noEmitOnErrors;
-	},
-	"optimization.noEmitOnErrors is deprecated in favor of optimization.emitOnErrors",
-	"DEP_WEBPACK_CONFIGURATION_OPTIMIZATION_NO_EMIT_ON_ERRORS"
-);
+const EMPTY_OBJECT = {};
 
-/**
- * @template T
- * @template R
- * @param {T|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @returns {R} result value
- */
-const nestedConfig = (value, fn) =>
-	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
+class CommonJsExportsDependency extends NullDependency {
+	constructor(range, valueRange, base, names) {
+		super();
+		this.range = range;
+		this.valueRange = valueRange;
+		this.base = base;
+		this.names = names;
+	}
 
-/**
- * @template T
- * @param {T|undefined} value value or not
- * @returns {T} result value
- */
-const cloneObject = value => {
-	return /** @type {T} */ ({ ...value });
-};
+	get type() {
+		return "cjs exports";
+	}
 
-/**
- * @template T
- * @template R
- * @param {T|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @returns {R|undefined} result value
- */
-const optionalNestedConfig = (value, fn) =>
-	value === undefined ? undefined : fn(value);
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.names[0];
+		return {
+			exports: [
+				{
+					name,
+					// we can't mangle names that are in an empty object
+					// because one could access the prototype property
+					// when export isn't set yet
+					canMangle: !(name in EMPTY_OBJECT)
+				}
+			],
+			dependencies: undefined
+		};
+	}
 
-/**
- * @template T
- * @template R
- * @param {T[]|undefined} value array or not
- * @param {function(T[]): R[]} fn nested handler
- * @returns {R[]|undefined} cloned value
- */
-const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.valueRange);
+		write(this.base);
+		write(this.names);
+		super.serialize(context);
+	}
 
-/**
- * @template T
- * @template R
- * @param {T[]|undefined} value array or not
- * @param {function(T[]): R[]} fn nested handler
- * @returns {R[]|undefined} cloned value
- */
-const optionalNestedArray = (value, fn) =>
-	Array.isArray(value) ? fn(value) : undefined;
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.valueRange = read();
+		this.base = read();
+		this.names = read();
+		super.deserialize(context);
+	}
+}
 
-/**
- * @template T
- * @template R
- * @param {Record<string, T>|undefined} value value or not
- * @param {function(T): R} fn nested handler
- * @param {Record<string, function(T): R>=} customKeys custom nested handler for some keys
- * @returns {Record<string, R>} result value
- */
-const keyedNestedConfig = (value, fn, customKeys) => {
-	const result =
-		value === undefined
-			? {}
-			: Object.keys(value).reduce(
-					(obj, key) => (
-						(obj[key] = (
-							customKeys && key in customKeys ? customKeys[key] : fn
-						)(value[key])),
-						obj
-					),
-					/** @type {Record<string, R>} */ ({})
-			  );
-	if (customKeys) {
-		for (const key of Object.keys(customKeys)) {
-			if (!(key in result)) {
-				result[key] = customKeys[key](/** @type {T} */ ({}));
-			}
+makeSerializable(
+	CommonJsExportsDependency,
+	"webpack/lib/dependencies/CommonJsExportsDependency"
+);
+
+CommonJsExportsDependency.Template = class CommonJsExportsDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, initFragments, runtimeRequirements, runtime }
+	) {
+		const dep = /** @type {CommonJsExportsDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.names, runtime);
+
+		const [type, base] = handleDependencyBase(
+			dep.base,
+			module,
+			runtimeRequirements
+		);
+
+		switch (type) {
+			case "expression":
+				if (!used) {
+					initFragments.push(
+						new InitFragment(
+							"var __webpack_unused_export__;\n",
+							InitFragment.STAGE_CONSTANTS,
+							0,
+							"__webpack_unused_export__"
+						)
+					);
+					source.replace(
+						dep.range[0],
+						dep.range[1] - 1,
+						"__webpack_unused_export__"
+					);
+					return;
+				}
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					`${base}${propertyAccess(used)}`
+				);
+				return;
+			case "Object.defineProperty":
+				if (!used) {
+					initFragments.push(
+						new InitFragment(
+							"var __webpack_unused_export__;\n",
+							InitFragment.STAGE_CONSTANTS,
+							0,
+							"__webpack_unused_export__"
+						)
+					);
+					source.replace(
+						dep.range[0],
+						dep.valueRange[0] - 1,
+						"__webpack_unused_export__ = ("
+					);
+					source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+					return;
+				}
+				source.replace(
+					dep.range[0],
+					dep.valueRange[0] - 1,
+					`Object.defineProperty(${base}${propertyAccess(
+						used.slice(0, -1)
+					)}, ${JSON.stringify(used[used.length - 1])}, (`
+				);
+				source.replace(dep.valueRange[1], dep.range[1] - 1, "))");
+				return;
 		}
 	}
-	return result;
+};
+
+module.exports = CommonJsExportsDependency;
+
+
+/***/ }),
+
+/***/ 97107:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const formatLocation = __webpack_require__(16734);
+const { evaluateToString } = __webpack_require__(93998);
+const propertyAccess = __webpack_require__(54190);
+const CommonJsExportRequireDependency = __webpack_require__(62892);
+const CommonJsExportsDependency = __webpack_require__(45598);
+const CommonJsSelfReferenceDependency = __webpack_require__(52225);
+const DynamicExports = __webpack_require__(32006);
+const HarmonyExports = __webpack_require__(39211);
+const ModuleDecoratorDependency = __webpack_require__(88488);
+
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
+const getValueOfPropertyDescription = expr => {
+	if (expr.type !== "ObjectExpression") return;
+	for (const property of expr.properties) {
+		if (property.computed) continue;
+		const key = property.key;
+		if (key.type !== "Identifier" || key.name !== "value") continue;
+		return property.value;
+	}
+};
+
+const isTruthyLiteral = expr => {
+	switch (expr.type) {
+		case "Literal":
+			return !!expr.value;
+		case "UnaryExpression":
+			if (expr.operator === "!") return isFalsyLiteral(expr.argument);
+	}
+	return false;
+};
+
+const isFalsyLiteral = expr => {
+	switch (expr.type) {
+		case "Literal":
+			return !expr.value;
+		case "UnaryExpression":
+			if (expr.operator === "!") return isTruthyLiteral(expr.argument);
+	}
+	return false;
 };
 
 /**
- * @param {WebpackOptions} config input config
- * @returns {WebpackOptionsNormalized} normalized options
+ * @param {JavascriptParser} parser the parser
+ * @param {ExpressionNode} expr expression
+ * @returns {{ argument: BasicEvaluatedExpression, ids: string[] } | undefined} parsed call
  */
-const getNormalizedWebpackOptions = config => {
-	return {
-		amd: config.amd,
-		bail: config.bail,
-		cache: optionalNestedConfig(config.cache, cache => {
-			if (cache === false) return false;
-			if (cache === true) {
-				return {
-					type: "memory",
-					maxGenerations: undefined
-				};
+const parseRequireCall = (parser, expr) => {
+	const ids = [];
+	while (expr.type === "MemberExpression") {
+		if (expr.object.type === "Super") return;
+		if (!expr.property) return;
+		const prop = expr.property;
+		if (expr.computed) {
+			if (prop.type !== "Literal") return;
+			ids.push(`${prop.value}`);
+		} else {
+			if (prop.type !== "Identifier") return;
+			ids.push(prop.name);
+		}
+		expr = expr.object;
+	}
+	if (expr.type !== "CallExpression" || expr.arguments.length !== 1) return;
+	const callee = expr.callee;
+	if (
+		callee.type !== "Identifier" ||
+		parser.getVariableInfo(callee.name) !== "require"
+	) {
+		return;
+	}
+	const arg = expr.arguments[0];
+	if (arg.type === "SpreadElement") return;
+	const argValue = parser.evaluateExpression(arg);
+	return { argument: argValue, ids: ids.reverse() };
+};
+
+class CommonJsExportsParserPlugin {
+	constructor(moduleGraph) {
+		this.moduleGraph = moduleGraph;
+	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 */
+	apply(parser) {
+		const enableStructuredExports = () => {
+			DynamicExports.enable(parser.state);
+		};
+		const checkNamespace = (topLevel, members, valueExpr) => {
+			if (!DynamicExports.isEnabled(parser.state)) return;
+			if (members.length > 0 && members[0] === "__esModule") {
+				if (valueExpr && isTruthyLiteral(valueExpr) && topLevel) {
+					DynamicExports.setFlagged(parser.state);
+				} else {
+					DynamicExports.setDynamic(parser.state);
+				}
 			}
-			switch (cache.type) {
-				case "filesystem":
-					return {
-						type: "filesystem",
-						allowCollectingMemory: cache.allowCollectingMemory,
-						maxMemoryGenerations: cache.maxMemoryGenerations,
-						maxAge: cache.maxAge,
-						profile: cache.profile,
-						buildDependencies: cloneObject(cache.buildDependencies),
-						cacheDirectory: cache.cacheDirectory,
-						cacheLocation: cache.cacheLocation,
-						hashAlgorithm: cache.hashAlgorithm,
-						compression: cache.compression,
-						idleTimeout: cache.idleTimeout,
-						idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
-						idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
-						name: cache.name,
-						store: cache.store,
-						version: cache.version
-					};
-				case undefined:
-				case "memory":
-					return {
-						type: "memory",
-						maxGenerations: cache.maxGenerations
-					};
-				default:
-					// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
-					throw new Error(`Not implemented cache.type ${cache.type}`);
+		};
+		const bailout = reason => {
+			DynamicExports.bailout(parser.state);
+			if (reason) bailoutHint(reason);
+		};
+		const bailoutHint = reason => {
+			this.moduleGraph
+				.getOptimizationBailout(parser.state.module)
+				.push(`CommonJS bailout: ${reason}`);
+		};
+
+		// metadata //
+		parser.hooks.evaluateTypeof
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", evaluateToString("object"));
+		parser.hooks.evaluateTypeof
+			.for("exports")
+			.tap("CommonJsPlugin", evaluateToString("object"));
+
+		// exporting //
+		const handleAssignExport = (expr, base, members) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			// Handle reexporting
+			const requireCall = parseRequireCall(parser, expr.right);
+			if (
+				requireCall &&
+				requireCall.argument.isString() &&
+				(members.length === 0 || members[0] !== "__esModule")
+			) {
+				enableStructuredExports();
+				// It's possible to reexport __esModule, so we must convert to a dynamic module
+				if (members.length === 0) DynamicExports.setDynamic(parser.state);
+				const dep = new CommonJsExportRequireDependency(
+					expr.range,
+					null,
+					base,
+					members,
+					requireCall.argument.string,
+					requireCall.ids,
+					!parser.isStatementLevelExpression(expr)
+				);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.module.addDependency(dep);
+				return true;
 			}
-		}),
-		context: config.context,
-		dependencies: config.dependencies,
-		devServer: optionalNestedConfig(config.devServer, devServer => ({
-			...devServer
-		})),
-		devtool: config.devtool,
-		entry:
-			config.entry === undefined
-				? { main: {} }
-				: typeof config.entry === "function"
-				? (
-						fn => () =>
-							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
-				  )(config.entry)
-				: getNormalizedEntryStatic(config.entry),
-		experiments: nestedConfig(config.experiments, experiments => ({
-			...experiments,
-			buildHttp: optionalNestedConfig(experiments.buildHttp, options =>
-				Array.isArray(options) ? { allowedUris: options } : options
-			),
-			lazyCompilation: optionalNestedConfig(
-				experiments.lazyCompilation,
-				options =>
-					options === true ? {} : options === false ? undefined : options
-			),
-			css: optionalNestedConfig(experiments.css, options =>
-				options === true ? {} : options === false ? undefined : options
-			)
-		})),
-		externals: config.externals,
-		externalsPresets: cloneObject(config.externalsPresets),
-		externalsType: config.externalsType,
-		ignoreWarnings: config.ignoreWarnings
-			? config.ignoreWarnings.map(ignore => {
-					if (typeof ignore === "function") return ignore;
-					const i = ignore instanceof RegExp ? { message: ignore } : ignore;
-					return (warning, { requestShortener }) => {
-						if (!i.message && !i.module && !i.file) return false;
-						if (i.message && !i.message.test(warning.message)) {
-							return false;
-						}
-						if (
-							i.module &&
-							(!warning.module ||
-								!i.module.test(
-									warning.module.readableIdentifier(requestShortener)
-								))
-						) {
-							return false;
-						}
-						if (i.file && (!warning.file || !i.file.test(warning.file))) {
-							return false;
-						}
-						return true;
-					};
-			  })
-			: undefined,
-		infrastructureLogging: cloneObject(config.infrastructureLogging),
-		loader: cloneObject(config.loader),
-		mode: config.mode,
-		module: nestedConfig(config.module, module => ({
-			noParse: module.noParse,
-			unsafeCache: module.unsafeCache,
-			parser: keyedNestedConfig(module.parser, cloneObject, {
-				javascript: parserOptions => ({
-					unknownContextRequest: module.unknownContextRequest,
-					unknownContextRegExp: module.unknownContextRegExp,
-					unknownContextRecursive: module.unknownContextRecursive,
-					unknownContextCritical: module.unknownContextCritical,
-					exprContextRequest: module.exprContextRequest,
-					exprContextRegExp: module.exprContextRegExp,
-					exprContextRecursive: module.exprContextRecursive,
-					exprContextCritical: module.exprContextCritical,
-					wrappedContextRegExp: module.wrappedContextRegExp,
-					wrappedContextRecursive: module.wrappedContextRecursive,
-					wrappedContextCritical: module.wrappedContextCritical,
-					// TODO webpack 6 remove
-					strictExportPresence: module.strictExportPresence,
-					strictThisContextOnImports: module.strictThisContextOnImports,
-					...parserOptions
-				})
-			}),
-			generator: cloneObject(module.generator),
-			defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
-			rules: nestedArray(module.rules, r => [...r])
-		})),
-		name: config.name,
-		node: nestedConfig(
-			config.node,
-			node =>
-				node && {
-					...node
+			if (members.length === 0) return;
+			enableStructuredExports();
+			const remainingMembers = members;
+			checkNamespace(
+				parser.statementPath.length === 1 &&
+					parser.isStatementLevelExpression(expr),
+				remainingMembers,
+				expr.right
+			);
+			const dep = new CommonJsExportsDependency(
+				expr.left.range,
+				null,
+				base,
+				remainingMembers
+			);
+			dep.loc = expr.loc;
+			parser.state.module.addDependency(dep);
+			parser.walkExpression(expr.right);
+			return true;
+		};
+		parser.hooks.assignMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				return handleAssignExport(expr, "exports", members);
+			});
+		parser.hooks.assignMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAssignExport(expr, "this", members);
+			});
+		parser.hooks.assignMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAssignExport(expr, "module.exports", members.slice(1));
+			});
+		parser.hooks.call
+			.for("Object.defineProperty")
+			.tap("CommonJsExportsParserPlugin", expression => {
+				const expr = /** @type {import("estree").CallExpression} */ (
+					expression
+				);
+				if (!parser.isStatementLevelExpression(expr)) return;
+				if (expr.arguments.length !== 3) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				if (expr.arguments[1].type === "SpreadElement") return;
+				if (expr.arguments[2].type === "SpreadElement") return;
+				const exportsArg = parser.evaluateExpression(expr.arguments[0]);
+				if (!exportsArg || !exportsArg.isIdentifier()) return;
+				if (
+					exportsArg.identifier !== "exports" &&
+					exportsArg.identifier !== "module.exports" &&
+					(exportsArg.identifier !== "this" || !parser.scope.topLevelScope)
+				) {
+					return;
 				}
-		),
-		optimization: nestedConfig(config.optimization, optimization => {
-			return {
-				...optimization,
-				runtimeChunk: getNormalizedOptimizationRuntimeChunk(
-					optimization.runtimeChunk
-				),
-				splitChunks: nestedConfig(
-					optimization.splitChunks,
-					splitChunks =>
-						splitChunks && {
-							...splitChunks,
-							defaultSizeTypes: splitChunks.defaultSizeTypes
-								? [...splitChunks.defaultSizeTypes]
-								: ["..."],
-							cacheGroups: cloneObject(splitChunks.cacheGroups)
-						}
-				),
-				emitOnErrors:
-					optimization.noEmitOnErrors !== undefined
-						? handledDeprecatedNoEmitOnErrors(
-								optimization.noEmitOnErrors,
-								optimization.emitOnErrors
-						  )
-						: optimization.emitOnErrors
-			};
-		}),
-		output: nestedConfig(config.output, output => {
-			const { library } = output;
-			const libraryAsName = /** @type {LibraryName} */ (library);
-			const libraryBase =
-				typeof library === "object" &&
-				library &&
-				!Array.isArray(library) &&
-				"type" in library
-					? library
-					: libraryAsName || output.libraryTarget
-					? /** @type {LibraryOptions} */ ({
-							name: libraryAsName
-					  })
-					: undefined;
-			/** @type {OutputNormalized} */
-			const result = {
-				assetModuleFilename: output.assetModuleFilename,
-				asyncChunks: output.asyncChunks,
-				charset: output.charset,
-				chunkFilename: output.chunkFilename,
-				chunkFormat: output.chunkFormat,
-				chunkLoading: output.chunkLoading,
-				chunkLoadingGlobal: output.chunkLoadingGlobal,
-				chunkLoadTimeout: output.chunkLoadTimeout,
-				cssFilename: output.cssFilename,
-				cssChunkFilename: output.cssChunkFilename,
-				clean: output.clean,
-				compareBeforeEmit: output.compareBeforeEmit,
-				crossOriginLoading: output.crossOriginLoading,
-				devtoolFallbackModuleFilenameTemplate:
-					output.devtoolFallbackModuleFilenameTemplate,
-				devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
-				devtoolNamespace: output.devtoolNamespace,
-				environment: cloneObject(output.environment),
-				enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
-					? [...output.enabledChunkLoadingTypes]
-					: ["..."],
-				enabledLibraryTypes: output.enabledLibraryTypes
-					? [...output.enabledLibraryTypes]
-					: ["..."],
-				enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
-					? [...output.enabledWasmLoadingTypes]
-					: ["..."],
-				filename: output.filename,
-				globalObject: output.globalObject,
-				hashDigest: output.hashDigest,
-				hashDigestLength: output.hashDigestLength,
-				hashFunction: output.hashFunction,
-				hashSalt: output.hashSalt,
-				hotUpdateChunkFilename: output.hotUpdateChunkFilename,
-				hotUpdateGlobal: output.hotUpdateGlobal,
-				hotUpdateMainFilename: output.hotUpdateMainFilename,
-				iife: output.iife,
-				importFunctionName: output.importFunctionName,
-				importMetaName: output.importMetaName,
-				scriptType: output.scriptType,
-				library: libraryBase && {
-					type:
-						output.libraryTarget !== undefined
-							? output.libraryTarget
-							: libraryBase.type,
-					auxiliaryComment:
-						output.auxiliaryComment !== undefined
-							? output.auxiliaryComment
-							: libraryBase.auxiliaryComment,
-					export:
-						output.libraryExport !== undefined
-							? output.libraryExport
-							: libraryBase.export,
-					name: libraryBase.name,
-					umdNamedDefine:
-						output.umdNamedDefine !== undefined
-							? output.umdNamedDefine
-							: libraryBase.umdNamedDefine
-				},
-				module: output.module,
-				path: output.path,
-				pathinfo: output.pathinfo,
-				publicPath: output.publicPath,
-				sourceMapFilename: output.sourceMapFilename,
-				sourcePrefix: output.sourcePrefix,
-				strictModuleExceptionHandling: output.strictModuleExceptionHandling,
-				trustedTypes: optionalNestedConfig(
-					output.trustedTypes,
-					trustedTypes => {
-						if (trustedTypes === true) return {};
-						if (typeof trustedTypes === "string")
-							return { policyName: trustedTypes };
-						return { ...trustedTypes };
-					}
-				),
-				uniqueName: output.uniqueName,
-				wasmLoading: output.wasmLoading,
-				webassemblyModuleFilename: output.webassemblyModuleFilename,
-				workerChunkLoading: output.workerChunkLoading,
-				workerWasmLoading: output.workerWasmLoading
-			};
-			return result;
-		}),
-		parallelism: config.parallelism,
-		performance: optionalNestedConfig(config.performance, performance => {
-			if (performance === false) return false;
-			return {
-				...performance
-			};
-		}),
-		plugins: nestedArray(config.plugins, p => [...p]),
-		profile: config.profile,
-		recordsInputPath:
-			config.recordsInputPath !== undefined
-				? config.recordsInputPath
-				: config.recordsPath,
-		recordsOutputPath:
-			config.recordsOutputPath !== undefined
-				? config.recordsOutputPath
-				: config.recordsPath,
-		resolve: nestedConfig(config.resolve, resolve => ({
-			...resolve,
-			byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
-		})),
-		resolveLoader: cloneObject(config.resolveLoader),
-		snapshot: nestedConfig(config.snapshot, snapshot => ({
-			resolveBuildDependencies: optionalNestedConfig(
-				snapshot.resolveBuildDependencies,
-				resolveBuildDependencies => ({
-					timestamp: resolveBuildDependencies.timestamp,
-					hash: resolveBuildDependencies.hash
-				})
-			),
-			buildDependencies: optionalNestedConfig(
-				snapshot.buildDependencies,
-				buildDependencies => ({
-					timestamp: buildDependencies.timestamp,
-					hash: buildDependencies.hash
-				})
-			),
-			resolve: optionalNestedConfig(snapshot.resolve, resolve => ({
-				timestamp: resolve.timestamp,
-				hash: resolve.hash
-			})),
-			module: optionalNestedConfig(snapshot.module, module => ({
-				timestamp: module.timestamp,
-				hash: module.hash
-			})),
-			immutablePaths: optionalNestedArray(snapshot.immutablePaths, p => [...p]),
-			managedPaths: optionalNestedArray(snapshot.managedPaths, p => [...p])
-		})),
-		stats: nestedConfig(config.stats, stats => {
-			if (stats === false) {
-				return {
-					preset: "none"
-				};
-			}
-			if (stats === true) {
-				return {
-					preset: "normal"
-				};
-			}
-			if (typeof stats === "string") {
-				return {
-					preset: stats
-				};
-			}
-			return {
-				...stats
-			};
-		}),
-		target: config.target,
-		watch: config.watch,
-		watchOptions: cloneObject(config.watchOptions)
-	};
-};
+				const propertyArg = parser.evaluateExpression(expr.arguments[1]);
+				if (!propertyArg) return;
+				const property = propertyArg.asString();
+				if (typeof property !== "string") return;
+				enableStructuredExports();
+				const descArg = expr.arguments[2];
+				checkNamespace(
+					parser.statementPath.length === 1,
+					[property],
+					getValueOfPropertyDescription(descArg)
+				);
+				const dep = new CommonJsExportsDependency(
+					expr.range,
+					expr.arguments[2].range,
+					`Object.defineProperty(${exportsArg.identifier})`,
+					[property]
+				);
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
 
-/**
- * @param {EntryStatic} entry static entry options
- * @returns {EntryStaticNormalized} normalized static entry options
- */
-const getNormalizedEntryStatic = entry => {
-	if (typeof entry === "string") {
-		return {
-			main: {
-				import: [entry]
+				parser.walkExpression(expr.arguments[2]);
+				return true;
+			});
+
+		// Self reference //
+		const handleAccessExport = (expr, base, members, call = undefined) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			if (members.length === 0) {
+				bailout(`${base} is used directly at ${formatLocation(expr.loc)}`);
 			}
-		};
-	}
-	if (Array.isArray(entry)) {
-		return {
-			main: {
-				import: entry
+			if (call && members.length === 1) {
+				bailoutHint(
+					`${base}${propertyAccess(
+						members
+					)}(...) prevents optimization as ${base} is passed as call context at ${formatLocation(
+						expr.loc
+					)}`
+				);
+			}
+			const dep = new CommonJsSelfReferenceDependency(
+				expr.range,
+				base,
+				members,
+				!!call
+			);
+			dep.loc = expr.loc;
+			parser.state.module.addDependency(dep);
+			if (call) {
+				parser.walkExpressions(call.arguments);
 			}
+			return true;
 		};
-	}
-	/** @type {EntryStaticNormalized} */
-	const result = {};
-	for (const key of Object.keys(entry)) {
-		const value = entry[key];
-		if (typeof value === "string") {
-			result[key] = {
-				import: [value]
-			};
-		} else if (Array.isArray(value)) {
-			result[key] = {
-				import: value
-			};
-		} else {
-			result[key] = {
-				import:
-					value.import &&
-					(Array.isArray(value.import) ? value.import : [value.import]),
-				filename: value.filename,
-				layer: value.layer,
-				runtime: value.runtime,
-				publicPath: value.publicPath,
-				chunkLoading: value.chunkLoading,
-				asyncChunks: value.asyncChunks,
-				wasmLoading: value.wasmLoading,
-				dependOn:
-					value.dependOn &&
-					(Array.isArray(value.dependOn) ? value.dependOn : [value.dependOn]),
-				library: value.library
-			};
-		}
-	}
-	return result;
-};
+		parser.hooks.callMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				return handleAccessExport(expr.callee, "exports", members, expr);
+			});
+		parser.hooks.expressionMemberChain
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				return handleAccessExport(expr, "exports", members);
+			});
+		parser.hooks.expression
+			.for("exports")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				return handleAccessExport(expr, "exports", []);
+			});
+		parser.hooks.callMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAccessExport(
+					expr.callee,
+					"module.exports",
+					members.slice(1),
+					expr
+				);
+			});
+		parser.hooks.expressionMemberChain
+			.for("module")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (members[0] !== "exports") return;
+				return handleAccessExport(expr, "module.exports", members.slice(1));
+			});
+		parser.hooks.expression
+			.for("module.exports")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				return handleAccessExport(expr, "module.exports", []);
+			});
+		parser.hooks.callMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr.callee, "this", members, expr);
+			});
+		parser.hooks.expressionMemberChain
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", (expr, members) => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr, "this", members);
+			});
+		parser.hooks.expression
+			.for("this")
+			.tap("CommonJsExportsParserPlugin", expr => {
+				if (!parser.scope.topLevelScope) return;
+				return handleAccessExport(expr, "this", []);
+			});
 
-/**
- * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
- * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
- */
-const getNormalizedOptimizationRuntimeChunk = runtimeChunk => {
-	if (runtimeChunk === undefined) return undefined;
-	if (runtimeChunk === false) return false;
-	if (runtimeChunk === "single") {
-		return {
-			name: () => "runtime"
-		};
-	}
-	if (runtimeChunk === true || runtimeChunk === "multiple") {
-		return {
-			name: entrypoint => `runtime~${entrypoint.name}`
-		};
+		// Bailouts //
+		parser.hooks.expression.for("module").tap("CommonJsPlugin", expr => {
+			bailout();
+			const isHarmony = HarmonyExports.isEnabled(parser.state);
+			const dep = new ModuleDecoratorDependency(
+				isHarmony
+					? RuntimeGlobals.harmonyModuleDecorator
+					: RuntimeGlobals.nodeModuleDecorator,
+				!isHarmony
+			);
+			dep.loc = expr.loc;
+			parser.state.module.addDependency(dep);
+			return true;
+		});
 	}
-	const { name } = runtimeChunk;
-	return {
-		name: typeof name === "function" ? name : () => name
-	};
-};
-
-exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
+}
+module.exports = CommonJsExportsParserPlugin;
 
 
 /***/ }),
 
-/***/ 52801:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 59440:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -73085,1056 +73407,887 @@ exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;
 
 
 
-const memoize = __webpack_require__(78676);
+const Template = __webpack_require__(1626);
+const { equals } = __webpack_require__(84953);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const ModuleDependency = __webpack_require__(80321);
 
-const getBrowserslistTargetHandler = memoize(() =>
-	__webpack_require__(43950)
-);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @param {string} context the context directory
- * @returns {string} default target
- */
-const getDefaultTarget = context => {
-	const browsers = getBrowserslistTargetHandler().load(null, context);
-	return browsers ? "browserslist" : "web";
-};
+class CommonJsFullRequireDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {[number, number]} range location in source code
+	 * @param {string[]} names accessed properties on module
+	 */
+	constructor(request, range, names) {
+		super(request);
+		this.range = range;
+		this.names = names;
+		this.call = false;
+		this.asiSafe = undefined;
+	}
 
-/**
- * @typedef {Object} PlatformTargetProperties
- * @property {boolean | null} web web platform, importing of http(s) and std: is available
- * @property {boolean | null} browser browser platform, running in a normal web browser
- * @property {boolean | null} webworker (Web)Worker platform, running in a web/shared/service worker
- * @property {boolean | null} node node platform, require of node built-in modules is available
- * @property {boolean | null} nwjs nwjs platform, require of legacy nw.gui is available
- * @property {boolean | null} electron electron platform, require of some electron built-in modules is available
- */
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (this.call) {
+			const importedModule = moduleGraph.getModule(this);
+			if (
+				!importedModule ||
+				importedModule.getExportsType(moduleGraph, false) !== "namespace"
+			) {
+				return [this.names.slice(0, -1)];
+			}
+		}
+		return [this.names];
+	}
 
-/**
- * @typedef {Object} ElectronContextTargetProperties
- * @property {boolean | null} electronMain in main context
- * @property {boolean | null} electronPreload in preload context
- * @property {boolean | null} electronRenderer in renderer context with node integration
- */
+	serialize(context) {
+		const { write } = context;
+		write(this.names);
+		write(this.call);
+		write(this.asiSafe);
+		super.serialize(context);
+	}
 
-/**
- * @typedef {Object} ApiTargetProperties
- * @property {boolean | null} require has require function available
- * @property {boolean | null} nodeBuiltins has node.js built-in modules available
- * @property {boolean | null} document has document available (allows script tags)
- * @property {boolean | null} importScripts has importScripts available
- * @property {boolean | null} importScriptsInWorker has importScripts available when creating a worker
- * @property {boolean | null} fetchWasm has fetch function available for WebAssembly
- * @property {boolean | null} global has global variable available
- */
+	deserialize(context) {
+		const { read } = context;
+		this.names = read();
+		this.call = read();
+		this.asiSafe = read();
+		super.deserialize(context);
+	}
 
-/**
- * @typedef {Object} EcmaTargetProperties
- * @property {boolean | null} globalThis has globalThis variable available
- * @property {boolean | null} bigIntLiteral big int literal syntax is available
- * @property {boolean | null} const const and let variable declarations are available
- * @property {boolean | null} arrowFunction arrow functions are available
- * @property {boolean | null} forOf for of iteration is available
- * @property {boolean | null} destructuring destructuring is available
- * @property {boolean | null} dynamicImport async import() is available
- * @property {boolean | null} dynamicImportInWorker async import() is available when creating a worker
- * @property {boolean | null} module ESM syntax is available (when in module)
- * @property {boolean | null} optionalChaining optional chaining is available
- * @property {boolean | null} templateLiteral template literal is available
- */
+	get type() {
+		return "cjs full require";
+	}
 
-///** @typedef {PlatformTargetProperties | ApiTargetProperties | EcmaTargetProperties | PlatformTargetProperties & ApiTargetProperties | PlatformTargetProperties & EcmaTargetProperties | ApiTargetProperties & EcmaTargetProperties} TargetProperties */
-/** @template T @typedef {{ [P in keyof T]?: never }} Never<T> */
-/** @template A @template B @typedef {(A & Never<B>) | (Never<A> & B) | (A & B)} Mix<A,B> */
-/** @typedef {Mix<Mix<PlatformTargetProperties, ElectronContextTargetProperties>, Mix<ApiTargetProperties, EcmaTargetProperties>>} TargetProperties */
+	get category() {
+		return "commonjs";
+	}
+}
 
-const versionDependent = (major, minor) => {
-	if (!major) return () => /** @type {undefined} */ (undefined);
-	major = +major;
-	minor = minor ? +minor : 0;
-	return (vMajor, vMinor = 0) => {
-		return major > vMajor || (major === vMajor && minor >= vMinor);
-	};
+CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{
+			module,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime,
+			initFragments
+		}
+	) {
+		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
+		if (!dep.range) return;
+		const importedModule = moduleGraph.getModule(dep);
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+		if (importedModule) {
+			const ids = dep.names;
+			const usedImported = moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(ids, runtime);
+			if (usedImported) {
+				const comment = equals(usedImported, ids)
+					? ""
+					: Template.toNormalComment(propertyAccess(ids)) + " ";
+				const access = `${comment}${propertyAccess(usedImported)}`;
+				requireExpr =
+					dep.asiSafe === true
+						? `(${requireExpr}${access})`
+						: `${requireExpr}${access}`;
+			}
+		}
+		source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
+	}
 };
 
-/** @type {[string, string, RegExp, (...args: string[]) => TargetProperties | false][]} */
-const TARGETS = [
-	[
-		"browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
-		"Resolve features from browserslist. Will resolve browserslist config automatically. Only browser or node queries are supported (electron is not supported). Examples: 'browserslist:modern' to use 'modern' environment from browserslist config",
-		/^browserslist(?::(.+))?$/,
-		(rest, context) => {
-			const browserslistTargetHandler = getBrowserslistTargetHandler();
-			const browsers = browserslistTargetHandler.load(
-				rest ? rest.trim() : null,
-				context
-			);
-			if (!browsers) {
-				throw new Error(`No browserslist config found to handle the 'browserslist' target.
-See https://github.com/browserslist/browserslist#queries for possible ways to provide a config.
-The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
-You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
-			}
-			return browserslistTargetHandler.resolve(browsers);
-		}
-	],
-	[
-		"web",
-		"Web browser.",
-		/^web$/,
-		() => {
-			return {
-				web: true,
-				browser: true,
-				webworker: null,
-				node: false,
-				electron: false,
-				nwjs: false,
-
-				document: true,
-				importScriptsInWorker: true,
-				fetchWasm: true,
-				nodeBuiltins: false,
-				importScripts: false,
-				require: false,
-				global: false
-			};
-		}
-	],
-	[
-		"webworker",
-		"Web Worker, SharedWorker or Service Worker.",
-		/^webworker$/,
-		() => {
-			return {
-				web: true,
-				browser: true,
-				webworker: true,
-				node: false,
-				electron: false,
-				nwjs: false,
-
-				importScripts: true,
-				importScriptsInWorker: true,
-				fetchWasm: true,
-				nodeBuiltins: false,
-				require: false,
-				document: false,
-				global: false
-			};
-		}
-	],
-	[
-		"[async-]node[X[.Y]]",
-		"Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
-		/^(async-)?node(\d+(?:\.(\d+))?)?$/,
-		(asyncFlag, major, minor) => {
-			const v = versionDependent(major, minor);
-			// see https://node.green/
-			return {
-				node: true,
-				electron: false,
-				nwjs: false,
-				web: false,
-				webworker: false,
-				browser: false,
-
-				require: !asyncFlag,
-				nodeBuiltins: true,
-				global: true,
-				document: false,
-				fetchWasm: false,
-				importScripts: false,
-				importScriptsInWorker: false,
-
-				globalThis: v(12),
-				const: v(6),
-				templateLiteral: v(4),
-				optionalChaining: v(14),
-				arrowFunction: v(6),
-				forOf: v(5),
-				destructuring: v(6),
-				bigIntLiteral: v(10, 4),
-				dynamicImport: v(12, 17),
-				dynamicImportInWorker: major ? false : undefined,
-				module: v(12, 17)
-			};
-		}
-	],
-	[
-		"electron[X[.Y]]-main/preload/renderer",
-		"Electron in version X.Y. Script is running in main, preload resp. renderer context.",
-		/^electron(\d+(?:\.(\d+))?)?-(main|preload|renderer)$/,
-		(major, minor, context) => {
-			const v = versionDependent(major, minor);
-			// see https://node.green/ + https://github.com/electron/releases
-			return {
-				node: true,
-				electron: true,
-				web: context !== "main",
-				webworker: false,
-				browser: false,
-				nwjs: false,
-
-				electronMain: context === "main",
-				electronPreload: context === "preload",
-				electronRenderer: context === "renderer",
-
-				global: true,
-				nodeBuiltins: true,
-				require: true,
-				document: context === "renderer",
-				fetchWasm: context === "renderer",
-				importScripts: false,
-				importScriptsInWorker: true,
-
-				globalThis: v(5),
-				const: v(1, 1),
-				templateLiteral: v(1, 1),
-				optionalChaining: v(8),
-				arrowFunction: v(1, 1),
-				forOf: v(0, 36),
-				destructuring: v(1, 1),
-				bigIntLiteral: v(4),
-				dynamicImport: v(11),
-				dynamicImportInWorker: major ? false : undefined,
-				module: v(11)
-			};
-		}
-	],
-	[
-		"nwjs[X[.Y]] / node-webkit[X[.Y]]",
-		"NW.js in version X.Y.",
-		/^(?:nwjs|node-webkit)(\d+(?:\.(\d+))?)?$/,
-		(major, minor) => {
-			const v = versionDependent(major, minor);
-			// see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
-			return {
-				node: true,
-				web: true,
-				nwjs: true,
-				webworker: null,
-				browser: false,
-				electron: false,
-
-				global: true,
-				nodeBuiltins: true,
-				document: false,
-				importScriptsInWorker: false,
-				fetchWasm: false,
-				importScripts: false,
-				require: false,
-
-				globalThis: v(0, 43),
-				const: v(0, 15),
-				templateLiteral: v(0, 13),
-				optionalChaining: v(0, 44),
-				arrowFunction: v(0, 15),
-				forOf: v(0, 13),
-				destructuring: v(0, 15),
-				bigIntLiteral: v(0, 32),
-				dynamicImport: v(0, 43),
-				dynamicImportInWorker: major ? false : undefined,
-				module: v(0, 43)
-			};
-		}
-	],
-	[
-		"esX",
-		"EcmaScript in this version. Examples: es2020, es5.",
-		/^es(\d+)$/,
-		version => {
-			let v = +version;
-			if (v < 1000) v = v + 2009;
-			return {
-				const: v >= 2015,
-				templateLiteral: v >= 2015,
-				optionalChaining: v >= 2020,
-				arrowFunction: v >= 2015,
-				forOf: v >= 2015,
-				destructuring: v >= 2015,
-				module: v >= 2015,
-				globalThis: v >= 2020,
-				bigIntLiteral: v >= 2020,
-				dynamicImport: v >= 2020,
-				dynamicImportInWorker: v >= 2020
-			};
-		}
-	]
-];
-
-/**
- * @param {string} target the target
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
- */
-const getTargetProperties = (target, context) => {
-	for (const [, , regExp, handler] of TARGETS) {
-		const match = regExp.exec(target);
-		if (match) {
-			const [, ...args] = match;
-			const result = handler(...args, context);
-			if (result) return result;
-		}
-	}
-	throw new Error(
-		`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(
-			([name, description]) => `* ${name}: ${description}`
-		).join("\n")}`
-	);
-};
-
-const mergeTargetProperties = targetProperties => {
-	const keys = new Set();
-	for (const tp of targetProperties) {
-		for (const key of Object.keys(tp)) {
-			keys.add(key);
-		}
-	}
-	const result = {};
-	for (const key of keys) {
-		let hasTrue = false;
-		let hasFalse = false;
-		for (const tp of targetProperties) {
-			const value = tp[key];
-			switch (value) {
-				case true:
-					hasTrue = true;
-					break;
-				case false:
-					hasFalse = true;
-					break;
-			}
-		}
-		if (hasTrue || hasFalse)
-			result[key] = hasFalse && hasTrue ? null : hasTrue ? true : false;
-	}
-	return /** @type {TargetProperties} */ (result);
-};
-
-/**
- * @param {string[]} targets the targets
- * @param {string} context the context directory
- * @returns {TargetProperties} target properties
- */
-const getTargetsProperties = (targets, context) => {
-	return mergeTargetProperties(
-		targets.map(t => getTargetProperties(t, context))
-	);
-};
+makeSerializable(
+	CommonJsFullRequireDependency,
+	"webpack/lib/dependencies/CommonJsFullRequireDependency"
+);
 
-exports.getDefaultTarget = getDefaultTarget;
-exports.getTargetProperties = getTargetProperties;
-exports.getTargetsProperties = getTargetsProperties;
+module.exports = CommonJsFullRequireDependency;
 
 
 /***/ }),
 
-/***/ 64813:
+/***/ 36013:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+	Author Tobias Koppers @sokra
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-
-/** @typedef {import("./ContainerEntryModule").ExposeOptions} ExposeOptions */
+const CommentCompilationWarning = __webpack_require__(98427);
+const RuntimeGlobals = __webpack_require__(16475);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const {
+	evaluateToIdentifier,
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = __webpack_require__(93998);
+const CommonJsFullRequireDependency = __webpack_require__(59440);
+const CommonJsRequireContextDependency = __webpack_require__(23962);
+const CommonJsRequireDependency = __webpack_require__(21264);
+const ConstDependency = __webpack_require__(76911);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const LocalModuleDependency = __webpack_require__(52805);
+const { getLocalModule } = __webpack_require__(75827);
+const RequireHeaderDependency = __webpack_require__(89183);
+const RequireResolveContextDependency = __webpack_require__(55627);
+const RequireResolveDependency = __webpack_require__(68582);
+const RequireResolveHeaderDependency = __webpack_require__(9880);
 
-class ContainerEntryDependency extends Dependency {
-	/**
-	 * @param {string} name entry name
-	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
-	 * @param {string} shareScope name of the share scope
-	 */
-	constructor(name, exposes, shareScope) {
-		super();
-		this.name = name;
-		this.exposes = exposes;
-		this.shareScope = shareScope;
-	}
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 
+class CommonJsImportsParserPlugin {
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * @param {JavascriptParserOptions} options parser options
 	 */
-	getResourceIdentifier() {
-		return `container-entry-${this.name}`;
-	}
-
-	get type() {
-		return "container entry";
+	constructor(options) {
+		this.options = options;
 	}
 
-	get category() {
-		return "esm";
-	}
-}
+	apply(parser) {
+		const options = this.options;
 
-makeSerializable(
-	ContainerEntryDependency,
-	"webpack/lib/container/ContainerEntryDependency"
-);
+		// metadata //
+		const tapRequireExpression = (expression, getMembers) => {
+			parser.hooks.typeof
+				.for(expression)
+				.tap(
+					"CommonJsPlugin",
+					toConstantDependency(parser, JSON.stringify("function"))
+				);
+			parser.hooks.evaluateTypeof
+				.for(expression)
+				.tap("CommonJsPlugin", evaluateToString("function"));
+			parser.hooks.evaluateIdentifier
+				.for(expression)
+				.tap(
+					"CommonJsPlugin",
+					evaluateToIdentifier(expression, "require", getMembers, true)
+				);
+		};
+		tapRequireExpression("require", () => []);
+		tapRequireExpression("require.resolve", () => ["resolve"]);
+		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
 
-module.exports = ContainerEntryDependency;
+		// Weird stuff //
+		parser.hooks.assign.for("require").tap("CommonJsPlugin", expr => {
+			// to not leak to global "require", we need to define a local require here.
+			const dep = new ConstDependency("var require;", 0);
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return true;
+		});
 
+		// Unsupported //
+		parser.hooks.expression
+			.for("require.main.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"require.main.require is not supported by webpack."
+				)
+			);
+		parser.hooks.call
+			.for("require.main.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"require.main.require is not supported by webpack."
+				)
+			);
+		parser.hooks.expression
+			.for("module.parent.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"module.parent.require is not supported by webpack."
+				)
+			);
+		parser.hooks.call
+			.for("module.parent.require")
+			.tap(
+				"CommonJsPlugin",
+				expressionIsUnsupported(
+					parser,
+					"module.parent.require is not supported by webpack."
+				)
+			);
 
-/***/ }),
+		// renaming //
+		parser.hooks.canRename.for("require").tap("CommonJsPlugin", () => true);
+		parser.hooks.rename.for("require").tap("CommonJsPlugin", expr => {
+			// To avoid "not defined" error, replace the value with undefined
+			const dep = new ConstDependency("undefined", expr.range);
+			dep.loc = expr.loc;
+			parser.state.module.addPresentationalDependency(dep);
+			return false;
+		});
 
-/***/ 80580:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// inspection //
+		parser.hooks.expression
+			.for("require.cache")
+			.tap(
+				"CommonJsImportsParserPlugin",
+				toConstantDependency(parser, RuntimeGlobals.moduleCache, [
+					RuntimeGlobals.moduleCache,
+					RuntimeGlobals.moduleId,
+					RuntimeGlobals.moduleLoaded
+				])
+			);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
+		// require as expression //
+		parser.hooks.expression
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", expr => {
+				const dep = new CommonJsRequireContextDependency(
+					{
+						request: options.unknownContextRequest,
+						recursive: options.unknownContextRecursive,
+						regExp: options.unknownContextRegExp,
+						mode: "sync"
+					},
+					expr.range,
+					undefined,
+					parser.scope.inShorthand
+				);
+				dep.critical =
+					options.unknownContextCritical &&
+					"require function is used in a way in which dependencies cannot be statically extracted";
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			});
 
+		// require //
+		const processRequireItem = (expr, param) => {
+			if (param.isString()) {
+				const dep = new CommonJsRequireDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		const processRequireContext = (expr, param) => {
+			const dep = ContextDependencyHelpers.create(
+				CommonJsRequireContextDependency,
+				expr.range,
+				param,
+				expr,
+				options,
+				{
+					category: "commonjs"
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
+			return true;
+		};
+		const createRequireHandler = callNew => expr => {
+			if (options.commonjsMagicComments) {
+				const { options: requireOptions, errors: commentErrors } =
+					parser.parseCommentOptions(expr.range);
 
+				if (commentErrors) {
+					for (const e of commentErrors) {
+						const { comment } = e;
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								comment.loc
+							)
+						);
+					}
+				}
+				if (requireOptions) {
+					if (requireOptions.webpackIgnore !== undefined) {
+						if (typeof requireOptions.webpackIgnore !== "boolean") {
+							parser.state.module.addWarning(
+								new UnsupportedFeatureWarning(
+									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+									expr.loc
+								)
+							);
+						} else {
+							// Do not instrument `require()` if `webpackIgnore` is `true`
+							if (requireOptions.webpackIgnore) {
+								return true;
+							}
+						}
+					}
+				}
+			}
 
-const { OriginalSource, RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const StaticExportsDependency = __webpack_require__(91418);
-const makeSerializable = __webpack_require__(33032);
-const ContainerExposedDependency = __webpack_require__(72374);
-
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
-
-/**
- * @typedef {Object} ExposeOptions
- * @property {string[]} import requests to exposed modules (last one is exported)
- * @property {string} name custom chunk name for the exposed module
- */
-
-const SOURCE_TYPES = new Set(["javascript"]);
-
-class ContainerEntryModule extends Module {
-	/**
-	 * @param {string} name container entry name
-	 * @param {[string, ExposeOptions][]} exposes list of exposed modules
-	 * @param {string} shareScope name of the share scope
-	 */
-	constructor(name, exposes, shareScope) {
-		super("javascript/dynamic", null);
-		this._name = name;
-		this._exposes = exposes;
-		this._shareScope = shareScope;
-	}
-
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return SOURCE_TYPES;
-	}
-
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `container entry (${this._shareScope}) ${JSON.stringify(
-			this._exposes
-		)}`;
-	}
-
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `container entry`;
-	}
-
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/entry/${
-			this._name
-		}`;
-	}
-
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		return callback(null, !this.buildMeta);
-	}
-
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true,
-			topLevelDeclarations: new Set(["moduleMap", "get", "init"])
+			if (expr.arguments.length !== 1) return;
+			let localModule;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (param.isConditional()) {
+				let isExpression = false;
+				for (const p of param.options) {
+					const result = processRequireItem(expr, p);
+					if (result === undefined) {
+						isExpression = true;
+					}
+				}
+				if (!isExpression) {
+					const dep = new RequireHeaderDependency(expr.callee.range);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+					return true;
+				}
+			}
+			if (
+				param.isString() &&
+				(localModule = getLocalModule(parser.state, param.string))
+			) {
+				localModule.flagUsed();
+				const dep = new LocalModuleDependency(localModule, expr.range, callNew);
+				dep.loc = expr.loc;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			} else {
+				const result = processRequireItem(expr, param);
+				if (result === undefined) {
+					processRequireContext(expr, param);
+				} else {
+					const dep = new RequireHeaderDependency(expr.callee.range);
+					dep.loc = expr.loc;
+					parser.state.module.addPresentationalDependency(dep);
+				}
+				return true;
+			}
 		};
-		this.buildMeta.exportsType = "namespace";
-
-		this.clearDependenciesAndBlocks();
-
-		for (const [name, options] of this._exposes) {
-			const block = new AsyncDependenciesBlock(
-				{
-					name: options.name
-				},
-				{ name },
-				options.import[options.import.length - 1]
-			);
-			let idx = 0;
-			for (const request of options.import) {
-				const dep = new ContainerExposedDependency(name, request);
-				dep.loc = {
-					name,
-					index: idx++
-				};
+		parser.hooks.call
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		parser.hooks.new
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
+		parser.hooks.call
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
+		parser.hooks.new
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
 
-				block.addDependency(dep);
+		// require with property access //
+		const chainHandler = (expr, calleeMembers, callExpr, members) => {
+			if (callExpr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(callExpr.arguments[0]);
+			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+				const dep = new CommonJsFullRequireDependency(
+					param.string,
+					expr.range,
+					members
+				);
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.optional = !!parser.scope.inTry;
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
 			}
-			this.addBlock(block);
-		}
-		this.addDependency(new StaticExportsDependency(["get", "init"], false));
-
-		callback();
-	}
-
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ moduleGraph, chunkGraph, runtimeTemplate }) {
-		const sources = new Map();
-		const runtimeRequirements = new Set([
-			RuntimeGlobals.definePropertyGetters,
-			RuntimeGlobals.hasOwnProperty,
-			RuntimeGlobals.exports
-		]);
-		const getters = [];
-
-		for (const block of this.blocks) {
-			const { dependencies } = block;
-
-			const modules = dependencies.map(dependency => {
-				const dep = /** @type {ContainerExposedDependency} */ (dependency);
-				return {
-					name: dep.exposedName,
-					module: moduleGraph.getModule(dep),
-					request: dep.userRequest
-				};
-			});
-
-			let str;
+		};
+		const callChainHandler = (expr, calleeMembers, callExpr, members) => {
+			if (callExpr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(callExpr.arguments[0]);
+			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+				const dep = new CommonJsFullRequireDependency(
+					param.string,
+					expr.callee.range,
+					members
+				);
+				dep.call = true;
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.optional = !!parser.scope.inTry;
+				dep.loc = expr.callee.loc;
+				parser.state.current.addDependency(dep);
+				parser.walkExpressions(expr.arguments);
+				return true;
+			}
+		};
+		parser.hooks.memberChainOfCallMemberChain
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", chainHandler);
+		parser.hooks.memberChainOfCallMemberChain
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", chainHandler);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for("require")
+			.tap("CommonJsImportsParserPlugin", callChainHandler);
+		parser.hooks.callMemberChainOfCallMemberChain
+			.for("module.require")
+			.tap("CommonJsImportsParserPlugin", callChainHandler);
 
-			if (modules.some(m => !m.module)) {
-				str = runtimeTemplate.throwMissingModuleErrorBlock({
-					request: modules.map(m => m.request).join(", ")
-				});
+		// require.resolve //
+		const processResolve = (expr, weak) => {
+			if (expr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (param.isConditional()) {
+				for (const option of param.options) {
+					const result = processResolveItem(expr, option, weak);
+					if (result === undefined) {
+						processResolveContext(expr, option, weak);
+					}
+				}
+				const dep = new RequireResolveHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
 			} else {
-				str = `return ${runtimeTemplate.blockPromise({
-					block,
-					message: "",
-					chunkGraph,
-					runtimeRequirements
-				})}.then(${runtimeTemplate.returningFunction(
-					runtimeTemplate.returningFunction(
-						`(${modules
-							.map(({ module, request }) =>
-								runtimeTemplate.moduleRaw({
-									module,
-									chunkGraph,
-									request,
-									weak: false,
-									runtimeRequirements
-								})
-							)
-							.join(", ")})`
-					)
-				)});`;
+				const result = processResolveItem(expr, param, weak);
+				if (result === undefined) {
+					processResolveContext(expr, param, weak);
+				}
+				const dep = new RequireResolveHeaderDependency(expr.callee.range);
+				dep.loc = expr.loc;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
 			}
-
-			getters.push(
-				`${JSON.stringify(modules[0].name)}: ${runtimeTemplate.basicFunction(
-					"",
-					str
-				)}`
+		};
+		const processResolveItem = (expr, param, weak) => {
+			if (param.isString()) {
+				const dep = new RequireResolveDependency(param.string, param.range);
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				dep.weak = weak;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		};
+		const processResolveContext = (expr, param, weak) => {
+			const dep = ContextDependencyHelpers.create(
+				RequireResolveContextDependency,
+				param.range,
+				param,
+				expr,
+				options,
+				{
+					category: "commonjs",
+					mode: weak ? "weak" : "sync"
+				},
+				parser
 			);
-		}
-
-		const source = Template.asString([
-			`var moduleMap = {`,
-			Template.indent(getters.join(",\n")),
-			"};",
-			`var get = ${runtimeTemplate.basicFunction("module, getScope", [
-				`${RuntimeGlobals.currentRemoteGetScope} = getScope;`,
-				// reusing the getScope variable to avoid creating a new var (and module is also used later)
-				"getScope = (",
-				Template.indent([
-					`${RuntimeGlobals.hasOwnProperty}(moduleMap, module)`,
-					Template.indent([
-						"? moduleMap[module]()",
-						`: Promise.resolve().then(${runtimeTemplate.basicFunction(
-							"",
-							"throw new Error('Module \"' + module + '\" does not exist in container.');"
-						)})`
-					])
-				]),
-				");",
-				`${RuntimeGlobals.currentRemoteGetScope} = undefined;`,
-				"return getScope;"
-			])};`,
-			`var init = ${runtimeTemplate.basicFunction("shareScope, initScope", [
-				`if (!${RuntimeGlobals.shareScopeMap}) return;`,
-				`var name = ${JSON.stringify(this._shareScope)}`,
-				`var oldScope = ${RuntimeGlobals.shareScopeMap}[name];`,
-				`if(oldScope && oldScope !== shareScope) throw new Error("Container initialization failed as it has already been initialized with a different share scope");`,
-				`${RuntimeGlobals.shareScopeMap}[name] = shareScope;`,
-				`return ${RuntimeGlobals.initializeSharing}(name, initScope);`
-			])};`,
-			"",
-			"// This exports getters to disallow modifications",
-			`${RuntimeGlobals.definePropertyGetters}(exports, {`,
-			Template.indent([
-				`get: ${runtimeTemplate.returningFunction("get")},`,
-				`init: ${runtimeTemplate.returningFunction("init")}`
-			]),
-			"});"
-		]);
-
-		sources.set(
-			"javascript",
-			this.useSourceMap || this.useSimpleSourceMap
-				? new OriginalSource(source, "webpack/container-entry")
-				: new RawSource(source)
-		);
-
-		return {
-			sources,
-			runtimeRequirements
+			if (!dep) return;
+			dep.loc = expr.loc;
+			dep.optional = !!parser.scope.inTry;
+			parser.state.current.addDependency(dep);
+			return true;
 		};
-	}
-
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 42;
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this._name);
-		write(this._exposes);
-		write(this._shareScope);
-		super.serialize(context);
-	}
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new ContainerEntryModule(read(), read(), read());
-		obj.deserialize(context);
-		return obj;
+		parser.hooks.call
+			.for("require.resolve")
+			.tap("RequireResolveDependencyParserPlugin", expr => {
+				return processResolve(expr, false);
+			});
+		parser.hooks.call
+			.for("require.resolveWeak")
+			.tap("RequireResolveDependencyParserPlugin", expr => {
+				return processResolve(expr, true);
+			});
 	}
 }
-
-makeSerializable(
-	ContainerEntryModule,
-	"webpack/lib/container/ContainerEntryModule"
-);
-
-module.exports = ContainerEntryModule;
+module.exports = CommonJsImportsParserPlugin;
 
 
 /***/ }),
 
-/***/ 76398:
+/***/ 32406:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+	Author Tobias Koppers @sokra
 */
 
 
 
-const ModuleFactory = __webpack_require__(51010);
-const ContainerEntryModule = __webpack_require__(80580);
-
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./ContainerEntryDependency")} ContainerEntryDependency */
-
-module.exports = class ContainerEntryModuleFactory extends ModuleFactory {
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create({ dependencies: [dependency] }, callback) {
-		const dep = /** @type {ContainerEntryDependency} */ (dependency);
-		callback(null, {
-			module: new ContainerEntryModule(dep.name, dep.exposes, dep.shareScope)
-		});
-	}
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const SelfModuleFactory = __webpack_require__(63560);
+const Template = __webpack_require__(1626);
+const CommonJsExportsDependency = __webpack_require__(45598);
+const CommonJsFullRequireDependency = __webpack_require__(59440);
+const CommonJsRequireContextDependency = __webpack_require__(23962);
+const CommonJsRequireDependency = __webpack_require__(21264);
+const CommonJsSelfReferenceDependency = __webpack_require__(52225);
+const ModuleDecoratorDependency = __webpack_require__(88488);
+const RequireHeaderDependency = __webpack_require__(89183);
+const RequireResolveContextDependency = __webpack_require__(55627);
+const RequireResolveDependency = __webpack_require__(68582);
+const RequireResolveHeaderDependency = __webpack_require__(9880);
+const RuntimeRequirementsDependency = __webpack_require__(24187);
 
+const CommonJsExportsParserPlugin = __webpack_require__(97107);
+const CommonJsImportsParserPlugin = __webpack_require__(36013);
 
-/***/ }),
+const {
+	evaluateToIdentifier,
+	toConstantDependency
+} = __webpack_require__(93998);
+const CommonJsExportRequireDependency = __webpack_require__(62892);
 
-/***/ 72374:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+class CommonJsPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"CommonJsPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					CommonJsRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsRequireDependency,
+					new CommonJsRequireDependency.Template()
+				);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
+				compilation.dependencyFactories.set(
+					CommonJsFullRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsFullRequireDependency,
+					new CommonJsFullRequireDependency.Template()
+				);
 
+				compilation.dependencyFactories.set(
+					CommonJsRequireContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsRequireContextDependency,
+					new CommonJsRequireContextDependency.Template()
+				);
 
+				compilation.dependencyFactories.set(
+					RequireResolveDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireResolveDependency,
+					new RequireResolveDependency.Template()
+				);
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
+				compilation.dependencyFactories.set(
+					RequireResolveContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireResolveContextDependency,
+					new RequireResolveContextDependency.Template()
+				);
 
-class ContainerExposedDependency extends ModuleDependency {
-	/**
-	 * @param {string} exposedName public name
-	 * @param {string} request request to module
-	 */
-	constructor(exposedName, request) {
-		super(request);
-		this.exposedName = exposedName;
-	}
+				compilation.dependencyTemplates.set(
+					RequireResolveHeaderDependency,
+					new RequireResolveHeaderDependency.Template()
+				);
 
-	get type() {
-		return "container exposed";
-	}
+				compilation.dependencyTemplates.set(
+					RequireHeaderDependency,
+					new RequireHeaderDependency.Template()
+				);
 
-	get category() {
-		return "esm";
-	}
+				compilation.dependencyTemplates.set(
+					CommonJsExportsDependency,
+					new CommonJsExportsDependency.Template()
+				);
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `exposed dependency ${this.exposedName}=${this.request}`;
-	}
+				compilation.dependencyFactories.set(
+					CommonJsExportRequireDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsExportRequireDependency,
+					new CommonJsExportRequireDependency.Template()
+				);
 
-	serialize(context) {
-		context.write(this.exposedName);
-		super.serialize(context);
-	}
+				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
 
-	deserialize(context) {
-		this.exposedName = context.read();
-		super.deserialize(context);
-	}
-}
+				compilation.dependencyFactories.set(
+					CommonJsSelfReferenceDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					CommonJsSelfReferenceDependency,
+					new CommonJsSelfReferenceDependency.Template()
+				);
 
-makeSerializable(
-	ContainerExposedDependency,
-	"webpack/lib/container/ContainerExposedDependency"
-);
+				compilation.dependencyFactories.set(
+					ModuleDecoratorDependency,
+					selfFactory
+				);
+				compilation.dependencyTemplates.set(
+					ModuleDecoratorDependency,
+					new ModuleDecoratorDependency.Template()
+				);
 
-module.exports = ContainerExposedDependency;
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap("CommonJsPlugin", (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
 
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap("CommonJsPlugin", (module, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.requireScope);
+					});
 
-/***/ }),
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.harmonyModuleDecorator)
+					.tap("CommonJsPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new HarmonyModuleDecoratorRuntimeModule()
+						);
+					});
 
-/***/ 9244:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.nodeModuleDecorator)
+					.tap("CommonJsPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new NodeModuleDecoratorRuntimeModule()
+						);
+					});
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
-*/
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.commonjs !== undefined && !parserOptions.commonjs)
+						return;
+					parser.hooks.typeof
+						.for("module")
+						.tap(
+							"CommonJsPlugin",
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
 
+					parser.hooks.expression
+						.for("require.main")
+						.tap(
+							"CommonJsPlugin",
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`,
+								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
+							)
+						);
+					parser.hooks.expression
+						.for("module.loaded")
+						.tap("CommonJsPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"module.loaded";
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleLoaded
+							]);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
+					parser.hooks.expression
+						.for("module.id")
+						.tap("CommonJsPlugin", expr => {
+							parser.state.module.buildInfo.moduleConcatenationBailout =
+								"module.id";
+							const dep = new RuntimeRequirementsDependency([
+								RuntimeGlobals.moduleId
+							]);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
 
-const createSchemaValidation = __webpack_require__(32540);
-const ContainerEntryDependency = __webpack_require__(64813);
-const ContainerEntryModuleFactory = __webpack_require__(76398);
-const ContainerExposedDependency = __webpack_require__(72374);
-const { parseOptions } = __webpack_require__(3083);
+					parser.hooks.evaluateIdentifier.for("module.hot").tap(
+						"CommonJsPlugin",
+						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
+					);
 
-/** @typedef {import("../../declarations/plugins/container/ContainerPlugin").ContainerPluginOptions} ContainerPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
+					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
+					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
+						parser
+					);
+				};
 
-const validate = createSchemaValidation(
-	__webpack_require__(9504),
-	() => __webpack_require__(84899),
-	{
-		name: "Container Plugin",
-		baseDataPath: "options"
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("CommonJsPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("CommonJsPlugin", handler);
+			}
+		);
 	}
-);
+}
 
-const PLUGIN_NAME = "ContainerPlugin";
+class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("harmony module decorator");
+	}
 
-class ContainerPlugin {
 	/**
-	 * @param {ContainerPluginOptions} options options
+	 * @returns {string} runtime code
 	 */
-	constructor(options) {
-		validate(options);
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${
+				RuntimeGlobals.harmonyModuleDecorator
+			} = ${runtimeTemplate.basicFunction("module", [
+				"module = Object.create(module);",
+				"if (!module.children) module.children = [];",
+				"Object.defineProperty(module, 'exports', {",
+				Template.indent([
+					"enumerable: true,",
+					`set: ${runtimeTemplate.basicFunction("", [
+						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
+					])}`
+				]),
+				"});",
+				"return module;"
+			])};`
+		]);
+	}
+}
 
-		this._options = {
-			name: options.name,
-			shareScope: options.shareScope || "default",
-			library: options.library || {
-				type: "var",
-				name: options.name
-			},
-			runtime: options.runtime,
-			filename: options.filename || undefined,
-			exposes: parseOptions(
-				options.exposes,
-				item => ({
-					import: Array.isArray(item) ? item : [item],
-					name: undefined
-				}),
-				item => ({
-					import: Array.isArray(item.import) ? item.import : [item.import],
-					name: item.name || undefined
-				})
-			)
-		};
+class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("node module decorator");
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		const { name, exposes, shareScope, filename, library, runtime } =
-			this._options;
-
-		compiler.options.output.enabledLibraryTypes.push(library.type);
-
-		compiler.hooks.make.tapAsync(PLUGIN_NAME, (compilation, callback) => {
-			const dep = new ContainerEntryDependency(name, exposes, shareScope);
-			dep.loc = { name };
-			compilation.addEntry(
-				compilation.options.context,
-				dep,
-				{
-					name,
-					filename,
-					runtime,
-					library
-				},
-				error => {
-					if (error) return callback(error);
-					callback();
-				}
-			);
-		});
-
-		compiler.hooks.thisCompilation.tap(
-			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ContainerEntryDependency,
-					new ContainerEntryModuleFactory()
-				);
-
-				compilation.dependencyFactories.set(
-					ContainerExposedDependency,
-					normalModuleFactory
-				);
-			}
-		);
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
+				"module",
+				[
+					"module.paths = [];",
+					"if (!module.children) module.children = [];",
+					"return module;"
+				]
+			)};`
+		]);
 	}
 }
 
-module.exports = ContainerPlugin;
+module.exports = CommonJsPlugin;
 
 
 /***/ }),
 
-/***/ 95757:
+/***/ 23962:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const ExternalsPlugin = __webpack_require__(6652);
-const RuntimeGlobals = __webpack_require__(16475);
-const createSchemaValidation = __webpack_require__(32540);
-const FallbackDependency = __webpack_require__(57764);
-const FallbackItemDependency = __webpack_require__(29593);
-const FallbackModuleFactory = __webpack_require__(4112);
-const RemoteModule = __webpack_require__(62916);
-const RemoteRuntimeModule = __webpack_require__(88288);
-const RemoteToExternalDependency = __webpack_require__(14389);
-const { parseOptions } = __webpack_require__(3083);
+const makeSerializable = __webpack_require__(33032);
+const ContextDependency = __webpack_require__(88101);
+const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
 
-/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").ContainerReferencePluginOptions} ContainerReferencePluginOptions */
-/** @typedef {import("../../declarations/plugins/container/ContainerReferencePlugin").RemotesConfig} RemotesConfig */
-/** @typedef {import("../Compiler")} Compiler */
+class CommonJsRequireContextDependency extends ContextDependency {
+	constructor(options, range, valueRange, inShorthand) {
+		super(options);
 
-const validate = createSchemaValidation(
-	__webpack_require__(95122),
-	() =>
-		__webpack_require__(66681),
-	{
-		name: "Container Reference Plugin",
-		baseDataPath: "options"
+		this.range = range;
+		this.valueRange = valueRange;
+		// inShorthand must be serialized by subclasses that use it
+		this.inShorthand = inShorthand;
 	}
-);
-
-const slashCode = "/".charCodeAt(0);
-
-class ContainerReferencePlugin {
-	/**
-	 * @param {ContainerReferencePluginOptions} options options
-	 */
-	constructor(options) {
-		validate(options);
 
-		this._remoteType = options.remoteType;
-		this._remotes = parseOptions(
-			options.remotes,
-			item => ({
-				external: Array.isArray(item) ? item : [item],
-				shareScope: options.shareScope || "default"
-			}),
-			item => ({
-				external: Array.isArray(item.external)
-					? item.external
-					: [item.external],
-				shareScope: item.shareScope || options.shareScope || "default"
-			})
-		);
+	get type() {
+		return "cjs require context";
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { _remotes: remotes, _remoteType: remoteType } = this;
-
-		/** @type {Record<string, string>} */
-		const remoteExternals = {};
-		for (const [key, config] of remotes) {
-			let i = 0;
-			for (const external of config.external) {
-				if (external.startsWith("internal ")) continue;
-				remoteExternals[
-					`webpack/container/reference/${key}${i ? `/fallback-${i}` : ""}`
-				] = external;
-				i++;
-			}
-		}
-
-		new ExternalsPlugin(remoteType, remoteExternals).apply(compiler);
+	serialize(context) {
+		const { write } = context;
 
-		compiler.hooks.compilation.tap(
-			"ContainerReferencePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RemoteToExternalDependency,
-					normalModuleFactory
-				);
+		write(this.range);
+		write(this.valueRange);
+		write(this.inShorthand);
 
-				compilation.dependencyFactories.set(
-					FallbackItemDependency,
-					normalModuleFactory
-				);
+		super.serialize(context);
+	}
 
-				compilation.dependencyFactories.set(
-					FallbackDependency,
-					new FallbackModuleFactory()
-				);
+	deserialize(context) {
+		const { read } = context;
 
-				normalModuleFactory.hooks.factorize.tap(
-					"ContainerReferencePlugin",
-					data => {
-						if (!data.request.includes("!")) {
-							for (const [key, config] of remotes) {
-								if (
-									data.request.startsWith(`${key}`) &&
-									(data.request.length === key.length ||
-										data.request.charCodeAt(key.length) === slashCode)
-								) {
-									return new RemoteModule(
-										data.request,
-										config.external.map((external, i) =>
-											external.startsWith("internal ")
-												? external.slice(9)
-												: `webpack/container/reference/${key}${
-														i ? `/fallback-${i}` : ""
-												  }`
-										),
-										`.${data.request.slice(key.length)}`,
-										config.shareScope
-									);
-								}
-							}
-						}
-					}
-				);
+		this.range = read();
+		this.valueRange = read();
+		this.inShorthand = read();
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ContainerReferencePlugin", (chunk, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-						set.add(RuntimeGlobals.hasOwnProperty);
-						set.add(RuntimeGlobals.initializeSharing);
-						set.add(RuntimeGlobals.shareScopeMap);
-						compilation.addRuntimeModule(chunk, new RemoteRuntimeModule());
-					});
-			}
-		);
+		super.deserialize(context);
 	}
 }
 
-module.exports = ContainerReferencePlugin;
+makeSerializable(
+	CommonJsRequireContextDependency,
+	"webpack/lib/dependencies/CommonJsRequireContextDependency"
+);
+
+CommonJsRequireContextDependency.Template =
+	ContextDependencyTemplateAsRequireCall;
+
+module.exports = CommonJsRequireContextDependency;
 
 
 /***/ }),
 
-/***/ 57764:
+/***/ 21264:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -74145,55 +74298,38 @@ module.exports = ContainerReferencePlugin;
 
 
 
-const Dependency = __webpack_require__(54912);
 const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-class FallbackDependency extends Dependency {
-	constructor(requests) {
-		super();
-		this.requests = requests;
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `fallback ${this.requests.join(" ")}`;
+class CommonJsRequireDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
 	}
 
 	get type() {
-		return "fallback";
+		return "cjs require";
 	}
 
 	get category() {
-		return "esm";
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.requests);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new FallbackDependency(read());
-		obj.deserialize(context);
-		return obj;
+		return "commonjs";
 	}
 }
 
+CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+
 makeSerializable(
-	FallbackDependency,
-	"webpack/lib/container/FallbackDependency"
+	CommonJsRequireDependency,
+	"webpack/lib/dependencies/CommonJsRequireDependency"
 );
 
-module.exports = FallbackDependency;
+module.exports = CommonJsRequireDependency;
 
 
 /***/ }),
 
-/***/ 29593:
+/***/ 52225:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -74204,529 +74340,792 @@ module.exports = FallbackDependency;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
+const RuntimeGlobals = __webpack_require__(16475);
+const { equals } = __webpack_require__(84953);
 const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const NullDependency = __webpack_require__(31830);
 
-class FallbackItemDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class CommonJsSelfReferenceDependency extends NullDependency {
+	constructor(range, base, names, call) {
+		super();
+		this.range = range;
+		this.base = base;
+		this.names = names;
+		this.call = call;
 	}
 
 	get type() {
-		return "fallback item";
+		return "cjs self exports reference";
 	}
 
 	get category() {
-		return "esm";
+		return "self";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `self`;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [this.call ? this.names.slice(0, -1) : this.names];
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.base);
+		write(this.names);
+		write(this.call);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.base = read();
+		this.names = read();
+		this.call = read();
+		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	FallbackItemDependency,
-	"webpack/lib/container/FallbackItemDependency"
+	CommonJsSelfReferenceDependency,
+	"webpack/lib/dependencies/CommonJsSelfReferenceDependency"
 );
 
-module.exports = FallbackItemDependency;
+CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, runtime, runtimeRequirements }
+	) {
+		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
+		let used;
+		if (dep.names.length === 0) {
+			used = dep.names;
+		} else {
+			used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
+		}
+		if (!used) {
+			throw new Error(
+				"Self-reference dependency has unused export name: This should not happen"
+			);
+		}
+
+		let base = undefined;
+		switch (dep.base) {
+			case "exports":
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				base = module.exportsArgument;
+				break;
+			case "module.exports":
+				runtimeRequirements.add(RuntimeGlobals.module);
+				base = `${module.moduleArgument}.exports`;
+				break;
+			case "this":
+				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+				base = "this";
+				break;
+			default:
+				throw new Error(`Unsupported base ${dep.base}`);
+		}
+
+		if (base === dep.base && equals(used, dep.names)) {
+			// Nothing has to be changed
+			// We don't use a replacement for compat reasons
+			// for plugins that update `module._source` which they
+			// shouldn't do!
+			return;
+		}
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${base}${propertyAccess(used)}`
+		);
+	}
+};
+
+module.exports = CommonJsSelfReferenceDependency;
 
 
 /***/ }),
 
-/***/ 82886:
+/***/ 76911:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
 const makeSerializable = __webpack_require__(33032);
-const FallbackItemDependency = __webpack_require__(29593);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 
-class FallbackModule extends Module {
+class ConstDependency extends NullDependency {
 	/**
-	 * @param {string[]} requests list of requests to choose one
+	 * @param {string} expression the expression
+	 * @param {number|[number, number]} range the source range
+	 * @param {string[]=} runtimeRequirements runtime requirements
 	 */
-	constructor(requests) {
-		super("fallback-module");
-		this.requests = requests;
-		this._identifier = `fallback ${this.requests.join(" ")}`;
+	constructor(expression, range, runtimeRequirements) {
+		super();
+		this.expression = expression;
+		this.range = range;
+		this.runtimeRequirements = runtimeRequirements
+			? new Set(runtimeRequirements)
+			: null;
+		this._hashUpdate = undefined;
 	}
 
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
 	 */
-	identifier() {
-		return this._identifier;
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = "" + this.range + "|" + this.expression;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
 	 */
-	readableIdentifier(requestShortener) {
-		return this._identifier;
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/fallback/${
-			this.requests[0]
-		}/and ${this.requests.length - 1} more`;
+	serialize(context) {
+		const { write } = context;
+		write(this.expression);
+		write(this.range);
+		write(this.runtimeRequirements);
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {Chunk} chunk the chunk which condition should be checked
-	 * @param {Compilation} compilation the compilation
-	 * @returns {boolean} true, if the chunk is ok for the module
-	 */
-	chunkCondition(chunk, { chunkGraph }) {
-		return chunkGraph.getNumberOfEntryModules(chunk) > 0;
+	deserialize(context) {
+		const { read } = context;
+		this.expression = read();
+		this.range = read();
+		this.runtimeRequirements = read();
+		super.deserialize(context);
 	}
+}
+
+makeSerializable(ConstDependency, "webpack/lib/dependencies/ConstDependency");
 
+ConstDependency.Template = class ConstDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {ConstDependency} */ (dependency);
+		if (dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		if (typeof dep.range === "number") {
+			source.insert(dep.range, dep.expression);
+			return;
+		}
+
+		source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
 	}
+};
+
+module.exports = ConstDependency;
+
+
+/***/ }),
+
+/***/ 88101:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const DependencyTemplate = __webpack_require__(5160);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../WebpackError")} WebpackError */
+
+const getCriticalDependencyWarning = memoize(() =>
+	__webpack_require__(15427)
+);
+
+/** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
+
+const regExpToString = r => (r ? r + "" : "");
 
+class ContextDependency extends Dependency {
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {ContextDependencyOptions} options options for the context module
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true
-		};
+	constructor(options) {
+		super();
 
-		this.clearDependenciesAndBlocks();
-		for (const request of this.requests)
-			this.addDependency(new FallbackItemDependency(request));
+		this.options = options;
+		this.userRequest = this.options && this.options.request;
+		/** @type {false | string} */
+		this.critical = false;
+		this.hadGlobalOrStickyRegExp = false;
 
-		callback();
+		if (
+			this.options &&
+			(this.options.regExp.global || this.options.regExp.sticky)
+		) {
+			this.options = { ...this.options, regExp: null };
+			this.hadGlobalOrStickyRegExp = true;
+		}
+
+		this.request = undefined;
+		this.range = undefined;
+		this.valueRange = undefined;
+		this.inShorthand = undefined;
+		// TODO refactor this
+		this.replaces = undefined;
+	}
+
+	get category() {
+		return "commonjs";
 	}
 
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
 	 */
-	size(type) {
-		return this.requests.length * 5 + 42;
+	couldAffectReferencingModule() {
+		return true;
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	getSourceTypes() {
-		return TYPES;
+	getResourceIdentifier() {
+		return (
+			`context${this.options.request} ${this.options.recursive} ` +
+			`${regExpToString(this.options.regExp)} ${regExpToString(
+				this.options.include
+			)} ${regExpToString(this.options.exclude)} ` +
+			`${this.options.mode} ${this.options.chunkName} ` +
+			`${JSON.stringify(this.options.groupOptions)}`
+		);
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
 	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const ids = this.dependencies.map(dep =>
-			chunkGraph.getModuleId(moduleGraph.getModule(dep))
-		);
-		const code = Template.asString([
-			`var ids = ${JSON.stringify(ids)};`,
-			"var error, result, i = 0;",
-			`var loop = ${runtimeTemplate.basicFunction("next", [
-				"while(i < ids.length) {",
-				Template.indent([
-					"try { next = __webpack_require__(ids[i++]); } catch(e) { return handleError(e); }",
-					"if(next) return next.then ? next.then(handleResult, handleError) : handleResult(next);"
-				]),
-				"}",
-				"if(error) throw error;"
-			])}`,
-			`var handleResult = ${runtimeTemplate.basicFunction("result", [
-				"if(result) return result;",
-				"return loop();"
-			])};`,
-			`var handleError = ${runtimeTemplate.basicFunction("e", [
-				"error = e;",
-				"return loop();"
-			])};`,
-			"module.exports = loop();"
-		]);
-		const sources = new Map();
-		sources.set("javascript", new RawSource(code));
-		return { sources, runtimeRequirements: RUNTIME_REQUIREMENTS };
+	getWarnings(moduleGraph) {
+		let warnings = super.getWarnings(moduleGraph);
+
+		if (this.critical) {
+			if (!warnings) warnings = [];
+			const CriticalDependencyWarning = getCriticalDependencyWarning();
+			warnings.push(new CriticalDependencyWarning(this.critical));
+		}
+
+		if (this.hadGlobalOrStickyRegExp) {
+			if (!warnings) warnings = [];
+			const CriticalDependencyWarning = getCriticalDependencyWarning();
+			warnings.push(
+				new CriticalDependencyWarning(
+					"Contexts can't use RegExps with the 'g' or 'y' flags."
+				)
+			);
+		}
+
+		return warnings;
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.requests);
+
+		write(this.options);
+		write(this.userRequest);
+		write(this.critical);
+		write(this.hadGlobalOrStickyRegExp);
+		write(this.request);
+		write(this.range);
+		write(this.valueRange);
+		write(this.prepend);
+		write(this.replaces);
+
 		super.serialize(context);
 	}
 
-	static deserialize(context) {
+	deserialize(context) {
 		const { read } = context;
-		const obj = new FallbackModule(read());
-		obj.deserialize(context);
-		return obj;
+
+		this.options = read();
+		this.userRequest = read();
+		this.critical = read();
+		this.hadGlobalOrStickyRegExp = read();
+		this.request = read();
+		this.range = read();
+		this.valueRange = read();
+		this.prepend = read();
+		this.replaces = read();
+
+		super.deserialize(context);
 	}
 }
 
-makeSerializable(FallbackModule, "webpack/lib/container/FallbackModule");
+makeSerializable(
+	ContextDependency,
+	"webpack/lib/dependencies/ContextDependency"
+);
 
-module.exports = FallbackModule;
+ContextDependency.Template = DependencyTemplate;
+
+module.exports = ContextDependency;
 
 
 /***/ }),
 
-/***/ 4112:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 99630:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra, Zackary Jackson @ScriptedAlchemy, Marais Rossouw @maraisr
+	Author Tobias Koppers @sokra
 */
 
 
 
-const ModuleFactory = __webpack_require__(51010);
-const FallbackModule = __webpack_require__(82886);
+const { parseResource } = __webpack_require__(82186);
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./FallbackDependency")} FallbackDependency */
+/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./ContextDependency")} ContextDependency */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
-module.exports = class FallbackModuleFactory extends ModuleFactory {
-	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
-	 */
-	create({ dependencies: [dependency] }, callback) {
-		const dep = /** @type {FallbackDependency} */ (dependency);
-		callback(null, {
-			module: new FallbackModule(dep.requests)
-		});
-	}
+/**
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
+ */
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 };
 
+const splitContextFromPrefix = prefix => {
+	const idx = prefix.lastIndexOf("/");
+	let context = ".";
+	if (idx >= 0) {
+		context = prefix.substr(0, idx);
+		prefix = `.${prefix.substr(idx)}`;
+	}
+	return {
+		context,
+		prefix
+	};
+};
 
-/***/ }),
-
-/***/ 30569:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
-*/
-
-
+/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
 
-const isValidExternalsType = __webpack_require__(62142);
-const SharePlugin = __webpack_require__(26335);
-const createSchemaValidation = __webpack_require__(32540);
-const ContainerPlugin = __webpack_require__(9244);
-const ContainerReferencePlugin = __webpack_require__(95757);
+/** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
 
-/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ExternalsType} ExternalsType */
-/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").ModuleFederationPluginOptions} ModuleFederationPluginOptions */
-/** @typedef {import("../../declarations/plugins/container/ModuleFederationPlugin").Shared} Shared */
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @param {ContextDependencyConstructor} Dep the Dependency class
+ * @param {[number, number]} range source range
+ * @param {BasicEvaluatedExpression} param context param
+ * @param {EsTreeNode} expr expr
+ * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
+ * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
+ * @param {JavascriptParser} parser the parser
+ * @returns {ContextDependency} the created Dependency
+ */
+exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
+	if (param.isTemplateString()) {
+		let prefixRaw = param.quasis[0].string;
+		let postfixRaw =
+			param.quasis.length > 1
+				? param.quasis[param.quasis.length - 1].string
+				: "";
 
-const validate = createSchemaValidation(
-	__webpack_require__(7467),
-	() => __webpack_require__(82601),
-	{
-		name: "Module Federation Plugin",
-		baseDataPath: "options"
-	}
-);
-class ModuleFederationPlugin {
-	/**
-	 * @param {ModuleFederationPluginOptions} options options
-	 */
-	constructor(options) {
-		validate(options);
+		const valueRange = param.range;
+		const { context, prefix } = splitContextFromPrefix(prefixRaw);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
 
-		this._options = options;
-	}
+		// When there are more than two quasis, the generated RegExp can be more precise
+		// We join the quasis with the expression regexp
+		const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
+		const innerRegExp =
+			options.wrappedContextRegExp.source +
+			innerQuasis
+				.map(q => quoteMeta(q.string) + options.wrappedContextRegExp.source)
+				.join("");
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { _options: options } = this;
-		const library = options.library || { type: "var", name: options.name };
-		const remoteType =
-			options.remoteType ||
-			(options.library && isValidExternalsType(options.library.type)
-				? /** @type {ExternalsType} */ (options.library.type)
-				: "script");
-		if (
-			library &&
-			!compiler.options.output.enabledLibraryTypes.includes(library.type)
-		) {
-			compiler.options.output.enabledLibraryTypes.push(library.type);
-		}
-		compiler.hooks.afterPlugins.tap("ModuleFederationPlugin", () => {
-			if (
-				options.exposes &&
-				(Array.isArray(options.exposes)
-					? options.exposes.length > 0
-					: Object.keys(options.exposes).length > 0)
-			) {
-				new ContainerPlugin({
-					name: options.name,
-					library,
-					filename: options.filename,
-					runtime: options.runtime,
-					exposes: options.exposes
-				}).apply(compiler);
-			}
-			if (
-				options.remotes &&
-				(Array.isArray(options.remotes)
-					? options.remotes.length > 0
-					: Object.keys(options.remotes).length > 0)
-			) {
-				new ContainerReferencePlugin({
-					remoteType,
-					remotes: options.remotes
-				}).apply(compiler);
-			}
-			if (options.shared) {
-				new SharePlugin({
-					shared: options.shared,
-					shareScope: options.shareScope
-				}).apply(compiler);
+		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
+		// context: "./context"
+		// prefix: "./pre"
+		// innerQuasis: [BEE("inner"), BEE("inner2")]
+		// (BEE = BasicEvaluatedExpression)
+		// postfix: "post"
+		// query: "?query"
+		// fragment: "#frag"
+		// regExp: /^\.\/pre.*inner.*inner2.*post$/
+		const regExp = new RegExp(
+			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
+		);
+		const dep = new Dep(
+			{
+				request: context + query + fragment,
+				recursive: options.wrappedContextRecursive,
+				regExp,
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			valueRange
+		);
+		dep.loc = expr.loc;
+		const replaces = [];
+
+		param.parts.forEach((part, i) => {
+			if (i % 2 === 0) {
+				// Quasis or merged quasi
+				let range = part.range;
+				let value = part.string;
+				if (param.templateStringKind === "cooked") {
+					value = JSON.stringify(value);
+					value = value.slice(1, value.length - 1);
+				}
+				if (i === 0) {
+					// prefix
+					value = prefix;
+					range = [param.range[0], part.range[1]];
+					value =
+						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
+						value;
+				} else if (i === param.parts.length - 1) {
+					// postfix
+					value = postfix;
+					range = [part.range[0], param.range[1]];
+					value = value + "`";
+				} else if (
+					part.expression &&
+					part.expression.type === "TemplateElement" &&
+					part.expression.value.raw === value
+				) {
+					// Shortcut when it's a single quasi and doesn't need to be replaced
+					return;
+				}
+				replaces.push({
+					range,
+					value
+				});
+			} else {
+				// Expression
+				parser.walkExpression(part.expression);
 			}
 		});
-	}
-}
 
-module.exports = ModuleFederationPlugin;
+		dep.replaces = replaces;
+		dep.critical =
+			options.wrappedContextCritical &&
+			"a part of the request of a dependency is an expression";
+		return dep;
+	} else if (
+		param.isWrapped() &&
+		((param.prefix && param.prefix.isString()) ||
+			(param.postfix && param.postfix.isString()))
+	) {
+		let prefixRaw =
+			param.prefix && param.prefix.isString() ? param.prefix.string : "";
+		let postfixRaw =
+			param.postfix && param.postfix.isString() ? param.postfix.string : "";
+		const prefixRange =
+			param.prefix && param.prefix.isString() ? param.prefix.range : null;
+		const postfixRange =
+			param.postfix && param.postfix.isString() ? param.postfix.range : null;
+		const valueRange = param.range;
+		const { context, prefix } = splitContextFromPrefix(prefixRaw);
+		const {
+			path: postfix,
+			query,
+			fragment
+		} = parseResource(postfixRaw, parser);
+		const regExp = new RegExp(
+			`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(
+				postfix
+			)}$`
+		);
+		const dep = new Dep(
+			{
+				request: context + query + fragment,
+				recursive: options.wrappedContextRecursive,
+				regExp,
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			valueRange
+		);
+		dep.loc = expr.loc;
+		const replaces = [];
+		if (prefixRange) {
+			replaces.push({
+				range: prefixRange,
+				value: JSON.stringify(prefix)
+			});
+		}
+		if (postfixRange) {
+			replaces.push({
+				range: postfixRange,
+				value: JSON.stringify(postfix)
+			});
+		}
+		dep.replaces = replaces;
+		dep.critical =
+			options.wrappedContextCritical &&
+			"a part of the request of a dependency is an expression";
+
+		if (parser && param.wrappedInnerExpressions) {
+			for (const part of param.wrappedInnerExpressions) {
+				if (part.expression) parser.walkExpression(part.expression);
+			}
+		}
+
+		return dep;
+	} else {
+		const dep = new Dep(
+			{
+				request: options.exprContextRequest,
+				recursive: options.exprContextRecursive,
+				regExp: /** @type {RegExp} */ (options.exprContextRegExp),
+				mode: "sync",
+				...contextOptions
+			},
+			range,
+			param.range
+		);
+		dep.loc = expr.loc;
+		dep.critical =
+			options.exprContextCritical &&
+			"the request of a dependency is an expression";
+
+		parser.walkExpression(param.expression);
+
+		return dep;
+	}
+};
 
 
 /***/ }),
 
-/***/ 62916:
+/***/ 76081:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const FallbackDependency = __webpack_require__(57764);
-const RemoteToExternalDependency = __webpack_require__(14389);
-
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+const ContextDependency = __webpack_require__(88101);
 
-const TYPES = new Set(["remote", "share-init"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class RemoteModule extends Module {
+class ContextDependencyTemplateAsId extends ContextDependency.Template {
 	/**
-	 * @param {string} request request string
-	 * @param {string[]} externalRequests list of external requests to containers
-	 * @param {string} internalRequest name of exposed module in container
-	 * @param {string} shareScope the used share scope name
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	constructor(request, externalRequests, internalRequest, shareScope) {
-		super("remote-module");
-		this.request = request;
-		this.externalRequests = externalRequests;
-		this.internalRequest = internalRequest;
-		this.shareScope = shareScope;
-		this._identifier = `remote (${shareScope}) ${this.externalRequests.join(
-			" "
-		)} ${this.internalRequest}`;
-	}
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ContextDependency} */ (dependency);
+		const moduleExports = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return this._identifier;
+		if (moduleGraph.getModule(dep)) {
+			if (dep.valueRange) {
+				if (Array.isArray(dep.replaces)) {
+					for (let i = 0; i < dep.replaces.length; i++) {
+						const rep = dep.replaces[i];
+						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+					}
+				}
+				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+				source.replace(
+					dep.range[0],
+					dep.valueRange[0] - 1,
+					`${moduleExports}.resolve(`
+				);
+			} else {
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					`${moduleExports}.resolve`
+				);
+			}
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+		}
 	}
+}
+module.exports = ContextDependencyTemplateAsId;
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `remote ${this.request}`;
-	}
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/container/remote/${
-			this.request
-		}`;
-	}
+/***/ }),
 
-	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
-	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
-	}
+/***/ 75815:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		this.clearDependenciesAndBlocks();
-		if (this.externalRequests.length === 1) {
-			this.addDependency(
-				new RemoteToExternalDependency(this.externalRequests[0])
-			);
-		} else {
-			this.addDependency(new FallbackDependency(this.externalRequests));
-		}
 
-		callback();
-	}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 6;
-	}
+const ContextDependency = __webpack_require__(88101);
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
+class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template {
 	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	nameForCondition() {
-		return this.request;
-	}
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ContextDependency} */ (dependency);
+		let moduleExports = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			runtimeRequirements
+		});
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const module = moduleGraph.getModule(this.dependencies[0]);
-		const id = module && chunkGraph.getModuleId(module);
-		const sources = new Map();
-		sources.set("remote", new RawSource(""));
-		const data = new Map();
-		data.set("share-init", [
-			{
-				shareScope: this.shareScope,
-				initStage: 20,
-				init: id === undefined ? "" : `initExternal(${JSON.stringify(id)});`
+		if (dep.inShorthand) {
+			moduleExports = `${dep.inShorthand}: ${moduleExports}`;
+		}
+		if (moduleGraph.getModule(dep)) {
+			if (dep.valueRange) {
+				if (Array.isArray(dep.replaces)) {
+					for (let i = 0; i < dep.replaces.length; i++) {
+						const rep = dep.replaces[i];
+						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
+					}
+				}
+				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+				source.replace(
+					dep.range[0],
+					dep.valueRange[0] - 1,
+					`${moduleExports}(`
+				);
+			} else {
+				source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
 			}
-		]);
-		return { sources, data, runtimeRequirements: RUNTIME_REQUIREMENTS };
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.request);
-		write(this.externalRequests);
-		write(this.internalRequest);
-		write(this.shareScope);
-		super.serialize(context);
-	}
-
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new RemoteModule(read(), read(), read(), read());
-		obj.deserialize(context);
-		return obj;
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
+		}
 	}
 }
-
-makeSerializable(RemoteModule, "webpack/lib/container/RemoteModule");
-
-module.exports = RemoteModule;
+module.exports = ContextDependencyTemplateAsRequireCall;
 
 
 /***/ }),
 
-/***/ 88288:
+/***/ 58477:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -74737,132 +75136,75 @@ module.exports = RemoteModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-
-/** @typedef {import("./RemoteModule")} RemoteModule */
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-class RemoteRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("remotes loading");
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ContextElementDependency extends ModuleDependency {
+	constructor(request, userRequest, typePrefix, category, referencedExports) {
+		super(request);
+		this.referencedExports = referencedExports;
+		this._typePrefix = typePrefix;
+		this._category = category;
+
+		if (userRequest) {
+			this.userRequest = userRequest;
+		}
+	}
+
+	get type() {
+		if (this._typePrefix) {
+			return `${this._typePrefix} context element`;
+		}
+
+		return "context element";
+	}
+
+	get category() {
+		return this._category;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	generate() {
-		const { compilation, chunkGraph } = this;
-		const { runtimeTemplate, moduleGraph } = compilation;
-		const chunkToRemotesMapping = {};
-		const idToExternalAndNameMapping = {};
-		for (const chunk of this.chunk.getAllAsyncChunks()) {
-			const modules = chunkGraph.getChunkModulesIterableBySourceType(
-				chunk,
-				"remote"
-			);
-			if (!modules) continue;
-			const remotes = (chunkToRemotesMapping[chunk.id] = []);
-			for (const m of modules) {
-				const module = /** @type {RemoteModule} */ (m);
-				const name = module.internalRequest;
-				const id = chunkGraph.getModuleId(module);
-				const shareScope = module.shareScope;
-				const dep = module.dependencies[0];
-				const externalModule = moduleGraph.getModule(dep);
-				const externalModuleId =
-					externalModule && chunkGraph.getModuleId(externalModule);
-				remotes.push(id);
-				idToExternalAndNameMapping[id] = [shareScope, name, externalModuleId];
-			}
-		}
-		return Template.asString([
-			`var chunkMapping = ${JSON.stringify(
-				chunkToRemotesMapping,
-				null,
-				"\t"
-			)};`,
-			`var idToExternalAndNameMapping = ${JSON.stringify(
-				idToExternalAndNameMapping,
-				null,
-				"\t"
-			)};`,
-			`${
-				RuntimeGlobals.ensureChunkHandlers
-			}.remotes = ${runtimeTemplate.basicFunction("chunkId, promises", [
-				`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
-				Template.indent([
-					`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction("id", [
-						`var getScope = ${RuntimeGlobals.currentRemoteGetScope};`,
-						"if(!getScope) getScope = [];",
-						"var data = idToExternalAndNameMapping[id];",
-						"if(getScope.indexOf(data) >= 0) return;",
-						"getScope.push(data);",
-						`if(data.p) return promises.push(data.p);`,
-						`var onError = ${runtimeTemplate.basicFunction("error", [
-							'if(!error) error = new Error("Container missing");',
-							'if(typeof error.message === "string")',
-							Template.indent(
-								`error.message += '\\nwhile loading "' + data[1] + '" from ' + data[2];`
-							),
-							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction("", [
-								"throw error;"
-							])}`,
-							"data.p = 0;"
-						])};`,
-						`var handleFunction = ${runtimeTemplate.basicFunction(
-							"fn, arg1, arg2, d, next, first",
-							[
-								"try {",
-								Template.indent([
-									"var promise = fn(arg1, arg2);",
-									"if(promise && promise.then) {",
-									Template.indent([
-										`var p = promise.then(${runtimeTemplate.returningFunction(
-											"next(result, d)",
-											"result"
-										)}, onError);`,
-										`if(first) promises.push(data.p = p); else return p;`
-									]),
-									"} else {",
-									Template.indent(["return next(promise, d, first);"]),
-									"}"
-								]),
-								"} catch(error) {",
-								Template.indent(["onError(error);"]),
-								"}"
-							]
-						)}`,
-						`var onExternal = ${runtimeTemplate.returningFunction(
-							`external ? handleFunction(${RuntimeGlobals.initializeSharing}, data[0], 0, external, onInitialized, first) : onError()`,
-							"external, _, first"
-						)};`,
-						`var onInitialized = ${runtimeTemplate.returningFunction(
-							`handleFunction(external.get, data[1], getScope, 0, onFactory, first)`,
-							"_, external, first"
-						)};`,
-						`var onFactory = ${runtimeTemplate.basicFunction("factory", [
-							"data.p = 1;",
-							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction(
-								"module",
-								["module.exports = factory();"]
-							)}`
-						])};`,
-						"handleFunction(__webpack_require__, data[2], 0, 0, onExternal, 1);"
-					])});`
-				]),
-				"}"
-			])}`
-		]);
+	getReferencedExports(moduleGraph, runtime) {
+		return this.referencedExports
+			? this.referencedExports.map(e => ({
+					name: e,
+					canMangle: false
+			  }))
+			: Dependency.EXPORTS_OBJECT_REFERENCED;
+	}
+
+	serialize(context) {
+		context.write(this.referencedExports);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		this.referencedExports = context.read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = RemoteRuntimeModule;
+makeSerializable(
+	ContextElementDependency,
+	"webpack/lib/dependencies/ContextElementDependency"
+);
+
+module.exports = ContextElementDependency;
 
 
 /***/ }),
 
-/***/ 14389:
+/***/ 79062:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -74873,35 +75215,71 @@ module.exports = RemoteRuntimeModule;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-class RemoteToExternalDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class CreateScriptUrlDependency extends NullDependency {
+	/**
+	 * @param {[number, number]} range range
+	 */
+	constructor(range) {
+		super();
+		this.range = range;
 	}
 
 	get type() {
-		return "remote to external";
+		return "create script url";
 	}
 
-	get category() {
-		return "esm";
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		super.deserialize(context);
 	}
 }
 
+CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {CreateScriptUrlDependency} */ (dependency);
+
+		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+
+		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
+		source.insert(dep.range[1], ")");
+	}
+};
+
 makeSerializable(
-	RemoteToExternalDependency,
-	"webpack/lib/container/RemoteToExternalDependency"
+	CreateScriptUrlDependency,
+	"webpack/lib/dependencies/CreateScriptUrlDependency"
 );
 
-module.exports = RemoteToExternalDependency;
+module.exports = CreateScriptUrlDependency;
 
 
 /***/ }),
 
-/***/ 3083:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 15427:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -74911,814 +75289,619 @@ module.exports = RemoteToExternalDependency;
 
 
 
-/** @template T @typedef {(string | Record<string, string | string[] | T>)[] | Record<string, string | string[] | T>} ContainerOptionsFormat */
+const WebpackError = __webpack_require__(53799);
+const makeSerializable = __webpack_require__(33032);
 
-/**
- * @template T
- * @template N
- * @param {ContainerOptionsFormat<T>} options options passed by the user
- * @param {function(string | string[], string) : N} normalizeSimple normalize a simple item
- * @param {function(T, string) : N} normalizeOptions normalize a complex item
- * @param {function(string, N): void} fn processing function
- * @returns {void}
- */
-const process = (options, normalizeSimple, normalizeOptions, fn) => {
-	const array = items => {
-		for (const item of items) {
-			if (typeof item === "string") {
-				fn(item, normalizeSimple(item, item));
-			} else if (item && typeof item === "object") {
-				object(item);
-			} else {
-				throw new Error("Unexpected options format");
-			}
-		}
-	};
-	const object = obj => {
-		for (const [key, value] of Object.entries(obj)) {
-			if (typeof value === "string" || Array.isArray(value)) {
-				fn(key, normalizeSimple(value, key));
-			} else {
-				fn(key, normalizeOptions(value, key));
-			}
-		}
-	};
-	if (!options) {
-		return;
-	} else if (Array.isArray(options)) {
-		array(options);
-	} else if (typeof options === "object") {
-		object(options);
-	} else {
-		throw new Error("Unexpected options format");
-	}
-};
+class CriticalDependencyWarning extends WebpackError {
+	constructor(message) {
+		super();
 
-/**
- * @template T
- * @template R
- * @param {ContainerOptionsFormat<T>} options options passed by the user
- * @param {function(string | string[], string) : R} normalizeSimple normalize a simple item
- * @param {function(T, string) : R} normalizeOptions normalize a complex item
- * @returns {[string, R][]} parsed options
- */
-const parseOptions = (options, normalizeSimple, normalizeOptions) => {
-	/** @type {[string, R][]} */
-	const items = [];
-	process(options, normalizeSimple, normalizeOptions, (key, value) => {
-		items.push([key, value]);
-	});
-	return items;
-};
+		this.name = "CriticalDependencyWarning";
+		this.message = "Critical dependency: " + message;
+	}
+}
 
-/**
- * @template T
- * @param {string} scope scope name
- * @param {ContainerOptionsFormat<T>} options options passed by the user
- * @returns {Record<string, string | string[] | T>} options to spread or pass
- */
-const scope = (scope, options) => {
-	/** @type {Record<string, string | string[] | T>} */
-	const obj = {};
-	process(
-		options,
-		item => /** @type {string | string[] | T} */ (item),
-		item => /** @type {string | string[] | T} */ (item),
-		(key, value) => {
-			obj[
-				key.startsWith("./") ? `${scope}${key.slice(1)}` : `${scope}/${key}`
-			] = value;
-		}
-	);
-	return obj;
-};
+makeSerializable(
+	CriticalDependencyWarning,
+	"webpack/lib/dependencies/CriticalDependencyWarning"
+);
 
-exports.parseOptions = parseOptions;
-exports.scope = scope;
+module.exports = CriticalDependencyWarning;
 
 
 /***/ }),
 
-/***/ 91254:
+/***/ 76760:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { ReplaceSource, RawSource, ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Generator = __webpack_require__(93401);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../util/Hash")} Hash */
-
-const TYPES = new Set(["javascript"]);
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-class CssExportsGenerator extends Generator {
-	constructor() {
+class CssExportDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {string} value value
+	 */
+	constructor(name, value) {
 		super();
+		this.name = name;
+		this.value = value;
 	}
 
-	// TODO add getConcatenationBailoutReason to allow concatenation
-	// but how to make it have a module id
+	get type() {
+		return "css :export";
+	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
 	 */
-	generate(module, generateContext) {
-		const source = new ReplaceSource(new RawSource(""));
-		const initFragments = [];
-		const cssExports = new Map();
-
-		generateContext.runtimeRequirements.add(RuntimeGlobals.module);
-
-		const runtimeRequirements = new Set();
-
-		const templateContext = {
-			runtimeTemplate: generateContext.runtimeTemplate,
-			dependencyTemplates: generateContext.dependencyTemplates,
-			moduleGraph: generateContext.moduleGraph,
-			chunkGraph: generateContext.chunkGraph,
-			module,
-			runtime: generateContext.runtime,
-			runtimeRequirements: runtimeRequirements,
-			concatenationScope: generateContext.concatenationScope,
-			codeGenerationResults: generateContext.codeGenerationResults,
-			initFragments,
-			cssExports
-		};
-
-		const handleDependency = dependency => {
-			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-				dependency.constructor
-			);
-			const template = generateContext.dependencyTemplates.get(constructor);
-			if (!template) {
-				throw new Error(
-					"No template for dependency: " + dependency.constructor.name
-				);
-			}
-
-			template.apply(dependency, source, templateContext);
+	getExports(moduleGraph) {
+		const name = this.name;
+		return {
+			exports: [
+				{
+					name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
 		};
-		module.dependencies.forEach(handleDependency);
+	}
 
-		if (generateContext.concatenationScope) {
-			const source = new ConcatSource();
-			const usedIdentifiers = new Set();
-			for (const [k, v] of cssExports) {
-				let identifier = Template.toIdentifier(k);
-				let i = 0;
-				while (usedIdentifiers.has(identifier)) {
-					identifier = Template.toIdentifier(k + i);
-				}
-				usedIdentifiers.add(identifier);
-				generateContext.concatenationScope.registerExport(k, identifier);
-				source.add(
-					`${
-						generateContext.runtimeTemplate.supportsConst ? "const" : "var"
-					} ${identifier} = ${JSON.stringify(v)};\n`
-				);
-			}
-			return source;
-		} else {
-			const otherUsed =
-				generateContext.moduleGraph
-					.getExportsInfo(module)
-					.otherExportsInfo.getUsed(generateContext.runtime) !==
-				UsageState.Unused;
-			if (otherUsed) {
-				generateContext.runtimeRequirements.add(
-					RuntimeGlobals.makeNamespaceObject
-				);
-			}
-			return new RawSource(
-				`${otherUsed ? `${RuntimeGlobals.makeNamespaceObject}(` : ""}${
-					module.moduleArgument
-				}.exports = {\n${Array.from(
-					cssExports,
-					([k, v]) => `\t${JSON.stringify(k)}: ${JSON.stringify(v)}`
-				).join(",\n")}\n}${otherUsed ? ")" : ""};`
-			);
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.value);
+		super.serialize(context);
 	}
 
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.value = read();
+		super.deserialize(context);
 	}
+}
 
+CssExportDependency.Template = class CssExportDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	getSize(module, type) {
-		return 42;
+	apply(dependency, source, { cssExports }) {
+		const dep = /** @type {CssExportDependency} */ (dependency);
+		cssExports.set(dep.name, dep.value);
 	}
+};
 
-	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
-	 */
-	updateHash(hash, { module }) {}
-}
+makeSerializable(
+	CssExportDependency,
+	"webpack/lib/dependencies/CssExportDependency"
+);
 
-module.exports = CssExportsGenerator;
+module.exports = CssExportDependency;
 
 
 /***/ }),
 
-/***/ 46061:
+/***/ 90542:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { ReplaceSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const TYPES = new Set(["css"]);
+class CssImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the argument
+	 * @param {string | undefined} supports list of supports conditions
+	 * @param {string | undefined} media list of media conditions
+	 */
+	constructor(request, range, supports, media) {
+		super(request);
+		this.range = range;
+		this.supports = supports;
+		this.media = media;
+	}
 
-class CssGenerator extends Generator {
-	constructor() {
-		super();
+	get type() {
+		return "css @import";
+	}
+
+	get category() {
+		return "css-import";
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {string} context context directory
+	 * @returns {Module} a module
 	 */
-	generate(module, generateContext) {
-		const originalSource = module.originalSource();
-		const source = new ReplaceSource(originalSource);
-		const initFragments = [];
-		const cssExports = new Map();
+	createIgnoredModule(context) {
+		return null;
+	}
+}
 
-		generateContext.runtimeRequirements.add(RuntimeGlobals.hasCssModules);
+CssImportDependency.Template = class CssImportDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {CssImportDependency} */ (dependency);
 
-		const templateContext = {
-			runtimeTemplate: generateContext.runtimeTemplate,
-			dependencyTemplates: generateContext.dependencyTemplates,
-			moduleGraph: generateContext.moduleGraph,
-			chunkGraph: generateContext.chunkGraph,
-			module,
-			runtime: generateContext.runtime,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			concatenationScope: generateContext.concatenationScope,
-			codeGenerationResults: generateContext.codeGenerationResults,
-			initFragments,
-			cssExports
-		};
+		source.replace(dep.range[0], dep.range[1] - 1, "");
+	}
+};
 
-		const handleDependency = dependency => {
-			const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-				dependency.constructor
-			);
-			const template = generateContext.dependencyTemplates.get(constructor);
-			if (!template) {
-				throw new Error(
-					"No template for dependency: " + dependency.constructor.name
-				);
-			}
+makeSerializable(
+	CssImportDependency,
+	"webpack/lib/dependencies/CssImportDependency"
+);
 
-			template.apply(dependency, source, templateContext);
+module.exports = CssImportDependency;
+
+
+/***/ }),
+
+/***/ 92328:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+
+class CssLocalIdentifierDependency extends NullDependency {
+	/**
+	 * @param {string} name name
+	 * @param {[number, number]} range range
+	 * @param {string=} prefix prefix
+	 */
+	constructor(name, range, prefix = "") {
+		super();
+		this.name = name;
+		this.range = range;
+		this.prefix = prefix;
+	}
+
+	get type() {
+		return "css local identifier";
+	}
+
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const name = this.name;
+		return {
+			exports: [
+				{
+					name,
+					canMangle: true
+				}
+			],
+			dependencies: undefined
 		};
-		module.dependencies.forEach(handleDependency);
-		if (module.presentationalDependencies !== undefined)
-			module.presentationalDependencies.forEach(handleDependency);
+	}
 
-		if (cssExports.size > 0) {
-			const data = generateContext.getData();
-			data.set("css-exports", cssExports);
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.name);
+		write(this.range);
+		write(this.prefix);
+		super.serialize(context);
+	}
 
-		return InitFragment.addToSource(source, initFragments, generateContext);
+	deserialize(context) {
+		const { read } = context;
+		this.name = read();
+		this.range = read();
+		this.prefix = read();
+		super.deserialize(context);
 	}
+}
+
+const escapeCssIdentifier = (str, omitUnderscore) => {
+	const escaped = `${str}`.replace(
+		// cspell:word uffff
+		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
+		s => `\\${s}`
+	);
+	return !omitUnderscore && /^(?!--)[0-9-]/.test(escaped)
+		? `_${escaped}`
+		: escaped;
+};
 
+CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	getTypes(module) {
-		return TYPES;
+	apply(
+		dependency,
+		source,
+		{ module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }
+	) {
+		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
+		const used = moduleGraph
+			.getExportInfo(module, dep.name)
+			.getUsedName(dep.name, runtime);
+		const moduleId = chunkGraph.getModuleId(module);
+		const identifier =
+			dep.prefix +
+			(runtimeTemplate.outputOptions.uniqueName
+				? runtimeTemplate.outputOptions.uniqueName + "-"
+				: "") +
+			(used ? moduleId + "-" + used : "-");
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			escapeCssIdentifier(identifier, dep.prefix)
+		);
+		if (used) cssExports.set(used, identifier);
 	}
+};
+
+makeSerializable(
+	CssLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssLocalIdentifierDependency"
+);
+
+module.exports = CssLocalIdentifierDependency;
+
+
+/***/ }),
+
+/***/ 29094:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const CssLocalIdentifierDependency = __webpack_require__(92328);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {string} name name
+	 * @param {[number, number]} range range
+	 * @param {string=} prefix prefix
+	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
 	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
+	constructor(name, range, prefix = "", declaredSet = undefined) {
+		super(name, range, prefix);
+		this.declaredSet = declaredSet;
+	}
 
-		if (!originalSource) {
-			return 0;
-		}
+	get type() {
+		return "css self local identifier";
+	}
 
-		return originalSource.size();
+	get category() {
+		return "self";
 	}
 
 	/**
-	 * @param {Hash} hash hash that will be modified
-	 * @param {UpdateHashContext} updateHashContext context for updating hash
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	updateHash(hash, { module }) {}
+	getResourceIdentifier() {
+		return `self`;
+	}
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
+		return super.getExports(moduleGraph);
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		if (this.declaredSet && !this.declaredSet.has(this.name))
+			return Dependency.NO_EXPORTS_REFERENCED;
+		return [[this.name]];
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.declaredSet);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.declaredSet = read();
+		super.deserialize(context);
+	}
 }
 
-module.exports = CssGenerator;
+CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
+	CssLocalIdentifierDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {CssSelfLocalIdentifierDependency} */ (dependency);
+		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
+		super.apply(dependency, source, templateContext);
+	}
+};
+
+makeSerializable(
+	CssSelfLocalIdentifierDependency,
+	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
+);
+
+module.exports = CssSelfLocalIdentifierDependency;
 
 
 /***/ }),
 
-/***/ 80806:
+/***/ 70749:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(41242);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { chunkHasCss } = __webpack_require__(47283);
+const makeSerializable = __webpack_require__(33032);
+const memoize = __webpack_require__(78676);
+const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @typedef {Object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
- */
+const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
+class CssUrlDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the argument
+	 * @param {string} cssFunctionKind kind of css function, e. g. url(), image()
+	 */
+	constructor(request, range, cssFunctionKind) {
+		super(request);
+		this.range = range;
+		this.cssFunctionKind = cssFunctionKind;
+	}
+
+	get type() {
+		return "css url()";
+	}
+
+	get category() {
+		return "url";
+	}
 
-class CssLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
+	 * @param {string} context context directory
+	 * @returns {Module} a module
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				createStylesheet: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
+	createIgnoredModule(context) {
+		const RawDataUrlModule = getRawDataUrlModule();
+		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
 	}
 
-	constructor(runtimeRequirements, runtimeOptions) {
-		super("css loading", 10);
+	serialize(context) {
+		const { write } = context;
+		write(this.cssFunctionKind);
+		super.serialize(context);
+	}
 
-		this._runtimeRequirements = runtimeRequirements;
-		this.runtimeOptions = runtimeOptions;
+	deserialize(context) {
+		const { read } = context;
+		this.cssFunctionKind = read();
+		super.deserialize(context);
+	}
+}
+
+const cssEscapeString = str => {
+	let countWhiteOrBracket = 0;
+	let countQuotation = 0;
+	let countApostrophe = 0;
+	for (let i = 0; i < str.length; i++) {
+		const cc = str.charCodeAt(i);
+		switch (cc) {
+			case 9: // tab
+			case 10: // nl
+			case 32: // space
+			case 40: // (
+			case 41: // )
+				countWhiteOrBracket++;
+				break;
+			case 34:
+				countQuotation++;
+				break;
+			case 39:
+				countApostrophe++;
+				break;
+		}
+	}
+	if (countWhiteOrBracket < 2) {
+		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
+	} else if (countQuotation <= countApostrophe) {
+		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
+	} else {
+		return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
 	}
+};
 
+CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @returns {string} runtime code
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation, chunk, _runtimeRequirements } = this;
-		const {
-			chunkGraph,
-			runtimeTemplate,
-			outputOptions: {
-				crossOriginLoading,
-				uniqueName,
-				chunkLoadTimeout: loadTimeout
-			}
-		} = compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const conditionMap = chunkGraph.getChunkConditionMap(
-			chunk,
-			(chunk, chunkGraph) =>
-				!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css")
-		);
-		const hasCssMatcher = compileBooleanMatcher(conditionMap);
+	apply(
+		dependency,
+		source,
+		{ runtime, moduleGraph, runtimeTemplate, codeGenerationResults }
+	) {
+		const dep = /** @type {CssUrlDependency} */ (dependency);
 
-		const withLoading =
-			_runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
-			hasCssMatcher !== false;
-		const withHmr = _runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${dep.cssFunctionKind}(${cssEscapeString(
+				runtimeTemplate.assetUrl({
+					publicPath: "",
+					runtime,
+					module: moduleGraph.getModule(dep),
+					codeGenerationResults
+				})
+			)})`
 		);
-		const initialChunkIdsWithCss = new Set();
-		const initialChunkIdsWithoutCss = new Set();
-		for (const c of chunk.getAllInitialChunks()) {
-			(chunkHasCss(c, chunkGraph)
-				? initialChunkIdsWithCss
-				: initialChunkIdsWithoutCss
-			).add(c.id);
-		}
+	}
+};
 
-		if (!withLoading && !withHmr && initialChunkIdsWithCss.size === 0) {
-			return null;
-		}
+makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
 
-		const { createStylesheet } =
-			CssLoadingRuntimeModule.getCompilationHooks(compilation);
+module.exports = CssUrlDependency;
 
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_css`
-			: undefined;
 
-		const code = Template.asString([
-			"link = document.createElement('link');",
-			uniqueName
-				? 'link.setAttribute("data-webpack", uniqueName + ":" + key);'
-				: "",
-			"link.setAttribute(loadingAttribute, 1);",
-			'link.rel = "stylesheet";',
-			"link.href = url;",
-			crossOriginLoading
-				? Template.asString([
-						"if (link.src.indexOf(window.location.origin + '/') !== 0) {",
-						Template.indent(
-							`link.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
-						),
-						"}"
-				  ])
-				: ""
-		]);
+/***/ }),
 
-		const cc = str => str.charCodeAt(0);
+/***/ 22914:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		return Template.asString([
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{${Array.from(
-				initialChunkIdsWithoutCss,
-				id => `${JSON.stringify(id)}:0`
-			).join(",")}};`,
-			"",
-			uniqueName
-				? `var uniqueName = ${JSON.stringify(
-						runtimeTemplate.outputOptions.uniqueName
-				  )};`
-				: "// data-webpack is not used as build has no uniqueName",
-			`var loadCssChunkData = ${runtimeTemplate.basicFunction(
-				"target, link, chunkId",
-				[
-					`var data, token = "", token2, exports = {}, exportsWithId = [], exportsWithDashes = [], ${
-						withHmr ? "moduleIds = [], " : ""
-					}i = 0, cc = 1;`,
-					"try { if(!link) link = loadStylesheet(chunkId); data = link.sheet.cssRules; data = data[data.length - 1].style; } catch(e) { data = getComputedStyle(document.head); }",
-					`data = data.getPropertyValue(${
-						uniqueName
-							? runtimeTemplate.concatenation(
-									"--webpack-",
-									{ expr: "uniqueName" },
-									"-",
-									{ expr: "chunkId" }
-							  )
-							: runtimeTemplate.concatenation("--webpack-", { expr: "chunkId" })
-					});`,
-					"if(!data) return [];",
-					"for(; cc; i++) {",
-					Template.indent([
-						"cc = data.charCodeAt(i);",
-						`if(cc == ${cc("(")}) { token2 = token; token = ""; }`,
-						`else if(cc == ${cc(
-							")"
-						)}) { exports[token2.replace(/^_/, "")] = token.replace(/^_/, ""); token = ""; }`,
-						`else if(cc == ${cc("/")} || cc == ${cc(
-							"%"
-						)}) { token = token.replace(/^_/, ""); exports[token] = token; exportsWithId.push(token); if(cc == ${cc(
-							"%"
-						)}) exportsWithDashes.push(token); token = ""; }`,
-						`else if(!cc || cc == ${cc(
-							","
-						)}) { token = token.replace(/^_/, ""); exportsWithId.forEach(${runtimeTemplate.expressionFunction(
-							`exports[x] = ${
-								uniqueName
-									? runtimeTemplate.concatenation(
-											{ expr: "uniqueName" },
-											"-",
-											{ expr: "token" },
-											"-",
-											{ expr: "exports[x]" }
-									  )
-									: runtimeTemplate.concatenation({ expr: "token" }, "-", {
-											expr: "exports[x]"
-									  })
-							}`,
-							"x"
-						)}); exportsWithDashes.forEach(${runtimeTemplate.expressionFunction(
-							`exports[x] = "--" + exports[x]`,
-							"x"
-						)}); ${
-							RuntimeGlobals.makeNamespaceObject
-						}(exports); target[token] = (${runtimeTemplate.basicFunction(
-							"exports, module",
-							`module.exports = exports;`
-						)}).bind(null, exports); ${
-							withHmr ? "moduleIds.push(token); " : ""
-						}token = ""; exports = {}; exportsWithId.length = 0; }`,
-						`else if(cc == ${cc("\\")}) { token += data[++i] }`,
-						`else { token += data[i]; }`
-					]),
-					"}",
-					`${
-						withHmr ? `if(target == ${RuntimeGlobals.moduleFactories}) ` : ""
-					}installedChunks[chunkId] = 0;`,
-					withHmr ? "return moduleIds;" : ""
-				]
-			)}`,
-			'var loadingAttribute = "data-webpack-loading";',
-			`var loadStylesheet = ${runtimeTemplate.basicFunction(
-				"chunkId, url, done" + (withHmr ? ", hmr" : ""),
-				[
-					'var link, needAttach, key = "chunk-" + chunkId;',
-					withHmr ? "if(!hmr) {" : "",
-					'var links = document.getElementsByTagName("link");',
-					"for(var i = 0; i < links.length; i++) {",
-					Template.indent([
-						"var l = links[i];",
-						`if(l.rel == "stylesheet" && (${
-							withHmr
-								? 'l.href.startsWith(url) || l.getAttribute("href").startsWith(url)'
-								: 'l.href == url || l.getAttribute("href") == url'
-						}${
-							uniqueName
-								? ' || l.getAttribute("data-webpack") == uniqueName + ":" + key'
-								: ""
-						})) { link = l; break; }`
-					]),
-					"}",
-					"if(!done) return link;",
-					withHmr ? "}" : "",
-					"if(!link) {",
-					Template.indent([
-						"needAttach = true;",
-						createStylesheet.call(code, this.chunk)
-					]),
-					"}",
-					`var onLinkComplete = ${runtimeTemplate.basicFunction(
-						"prev, event",
-						Template.asString([
-							"link.onerror = link.onload = null;",
-							"link.removeAttribute(loadingAttribute);",
-							"clearTimeout(timeout);",
-							'if(event && event.type != "load") link.parentNode.removeChild(link)',
-							"done(event);",
-							"if(prev) return prev(event);"
-						])
-					)};`,
-					"if(link.getAttribute(loadingAttribute)) {",
-					Template.indent([
-						`var timeout = setTimeout(onLinkComplete.bind(null, undefined, { type: 'timeout', target: link }), ${loadTimeout});`,
-						"link.onerror = onLinkComplete.bind(null, link.onerror);",
-						"link.onload = onLinkComplete.bind(null, link.onload);"
-					]),
-					"} else onLinkComplete(undefined, { type: 'load', target: link });", // We assume any existing stylesheet is render blocking
-					withHmr ? "hmr ? document.head.insertBefore(link, hmr) :" : "",
-					"needAttach && document.head.appendChild(link);",
-					"return link;"
-				]
-			)};`,
-			initialChunkIdsWithCss.size > 2
-				? `${JSON.stringify(
-						Array.from(initialChunkIdsWithCss)
-				  )}.forEach(loadCssChunkData.bind(null, ${
-						RuntimeGlobals.moduleFactories
-				  }, 0));`
-				: initialChunkIdsWithCss.size > 0
-				? `${Array.from(
-						initialChunkIdsWithCss,
-						id =>
-							`loadCssChunkData(${
-								RuntimeGlobals.moduleFactories
-							}, 0, ${JSON.stringify(id)});`
-				  ).join("")}`
-				: "// no initial css",
-			"",
-			withLoading
-				? Template.asString([
-						`${fn}.css = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasCssMatcher !== false
-								? [
-										"// css chunk loading",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[2]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasCssMatcher === true
-													? "if(true) { // all chunks have CSS"
-													: `if(${hasCssMatcher("chunkId")}) {`,
-												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
-														"resolve, reject"
-													)});`,
-													"promises.push(installedChunkData[2] = promise);",
-													"",
-													"// start chunk loading",
-													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
-													"// create error before stack unwound to get useful stacktrace later",
-													"var error = new Error();",
-													`var loadingEnded = ${runtimeTemplate.basicFunction(
-														"event",
-														[
-															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
-															Template.indent([
-																"installedChunkData = installedChunks[chunkId];",
-																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
-																"if(installedChunkData) {",
-																Template.indent([
-																	'if(event.type !== "load") {',
-																	Template.indent([
-																		"var errorType = event && event.type;",
-																		"var realSrc = event && event.target && event.target.src;",
-																		"error.message = 'Loading css chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-																		"error.name = 'ChunkLoadError';",
-																		"error.type = errorType;",
-																		"error.request = realSrc;",
-																		"installedChunkData[1](error);"
-																	]),
-																	"} else {",
-																	Template.indent([
-																		`loadCssChunkData(${RuntimeGlobals.moduleFactories}, link, chunkId);`,
-																		"installedChunkData[0]();"
-																	]),
-																	"}"
-																]),
-																"}"
-															]),
-															"}"
-														]
-													)};`,
-													"var link = loadStylesheet(chunkId, url, loadingEnded);"
-												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 0;"
-						)};`
-				  ])
-				: "// no chunk loading",
-			"",
-			withHmr
-				? Template.asString([
-						"var oldTags = [];",
-						"var newTags = [];",
-						`var applyHandler = ${runtimeTemplate.basicFunction("options", [
-							`return { dispose: ${runtimeTemplate.basicFunction(
-								"",
-								[]
-							)}, apply: ${runtimeTemplate.basicFunction("", [
-								"var moduleIds = [];",
-								`newTags.forEach(${runtimeTemplate.expressionFunction(
-									"info[1].sheet.disabled = false",
-									"info"
-								)});`,
-								"while(oldTags.length) {",
-								Template.indent([
-									"var oldTag = oldTags.pop();",
-									"if(oldTag.parentNode) oldTag.parentNode.removeChild(oldTag);"
-								]),
-								"}",
-								"while(newTags.length) {",
-								Template.indent([
-									`var info = newTags.pop();`,
-									`var chunkModuleIds = loadCssChunkData(${RuntimeGlobals.moduleFactories}, info[1], info[0]);`,
-									`chunkModuleIds.forEach(${runtimeTemplate.expressionFunction(
-										"moduleIds.push(id)",
-										"id"
-									)});`
-								]),
-								"}",
-								"return moduleIds;"
-							])} };`
-						])}`,
-						`var cssTextKey = ${runtimeTemplate.returningFunction(
-							`Array.from(link.sheet.cssRules, ${runtimeTemplate.returningFunction(
-								"r.cssText",
-								"r"
-							)}).join()`,
-							"link"
-						)}`,
-						`${
-							RuntimeGlobals.hmrDownloadUpdateHandlers
-						}.css = ${runtimeTemplate.basicFunction(
-							"chunkIds, removedChunks, removedModules, promises, applyHandlers, updatedModulesList",
-							[
-								"applyHandlers.push(applyHandler);",
-								`chunkIds.forEach(${runtimeTemplate.basicFunction("chunkId", [
-									`var filename = ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
-									`var url = ${RuntimeGlobals.publicPath} + filename;`,
-									"var oldTag = loadStylesheet(chunkId, url);",
-									"if(!oldTag) return;",
-									`promises.push(new Promise(${runtimeTemplate.basicFunction(
-										"resolve, reject",
-										[
-											`var link = loadStylesheet(chunkId, url + (url.indexOf("?") < 0 ? "?" : "&") + "hmr=" + Date.now(), ${runtimeTemplate.basicFunction(
-												"event",
-												[
-													'if(event.type !== "load") {',
-													Template.indent([
-														"var errorType = event && event.type;",
-														"var realSrc = event && event.target && event.target.src;",
-														"error.message = 'Loading css hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-														"error.name = 'ChunkLoadError';",
-														"error.type = errorType;",
-														"error.request = realSrc;",
-														"reject(error);"
-													]),
-													"} else {",
-													Template.indent([
-														"try { if(cssTextKey(oldTag) == cssTextKey(link)) { if(link.parentNode) link.parentNode.removeChild(link); return resolve(); } } catch(e) {}",
-														"var factories = {};",
-														"loadCssChunkData(factories, link, chunkId);",
-														`Object.keys(factories).forEach(${runtimeTemplate.expressionFunction(
-															"updatedModulesList.push(id)",
-															"id"
-														)})`,
-														"link.sheet.disabled = true;",
-														"oldTags.push(oldTag);",
-														"newTags.push([chunkId, link]);",
-														"resolve();"
-													]),
-													"}"
-												]
-											)}, oldTag);`
-										]
-									)}));`
-								])});`
-							]
-						)}`
-				  ])
-				: "// no hmr"
-		]);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+
+class DelegatedSourceDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "delegated source";
+	}
+
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = CssLoadingRuntimeModule;
+makeSerializable(
+	DelegatedSourceDependency,
+	"webpack/lib/dependencies/DelegatedSourceDependency"
+);
+
+module.exports = DelegatedSourceDependency;
 
 
 /***/ }),
 
-/***/ 47283:
+/***/ 95666:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -75729,465 +75912,166 @@ module.exports = CssLoadingRuntimeModule;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const HotUpdateChunk = __webpack_require__(9597);
-const RuntimeGlobals = __webpack_require__(16475);
-const SelfModuleFactory = __webpack_require__(63560);
-const CssExportDependency = __webpack_require__(76760);
-const CssImportDependency = __webpack_require__(90542);
-const CssLocalIdentifierDependency = __webpack_require__(92328);
-const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
-const CssUrlDependency = __webpack_require__(70749);
-const StaticExportsDependency = __webpack_require__(91418);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const memoize = __webpack_require__(78676);
-const CssExportsGenerator = __webpack_require__(91254);
-const CssGenerator = __webpack_require__(46061);
-const CssParser = __webpack_require__(98305);
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+class DllEntryDependency extends Dependency {
+	constructor(dependencies, name) {
+		super();
 
-const getCssLoadingRuntimeModule = memoize(() =>
-	__webpack_require__(80806)
-);
+		this.dependencies = dependencies;
+		this.name = name;
+	}
 
-const getSchema = name => {
-	const { definitions } = __webpack_require__(73342);
-	return {
-		definitions,
-		oneOf: [{ $ref: `#/definitions/${name}` }]
-	};
-};
+	get type() {
+		return "dll entry";
+	}
 
-const validateGeneratorOptions = createSchemaValidation(
-	__webpack_require__(59170),
-	() => getSchema("CssGeneratorOptions"),
-	{
-		name: "Css Modules Plugin",
-		baseDataPath: "parser"
+	serialize(context) {
+		const { write } = context;
+
+		write(this.dependencies);
+		write(this.name);
+
+		super.serialize(context);
 	}
-);
-const validateParserOptions = createSchemaValidation(
-	__webpack_require__(38542),
-	() => getSchema("CssParserOptions"),
-	{
-		name: "Css Modules Plugin",
-		baseDataPath: "parser"
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.dependencies = read();
+		this.name = read();
+
+		super.deserialize(context);
 	}
+}
+
+makeSerializable(
+	DllEntryDependency,
+	"webpack/lib/dependencies/DllEntryDependency"
 );
 
-const escapeCss = (str, omitOptionalUnderscore) => {
-	const escaped = `${str}`.replace(
-		// cspell:word uffff
-		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
-		s => `\\${s}`
-	);
-	return !omitOptionalUnderscore && /^(?!--)[0-9_-]/.test(escaped)
-		? `_${escaped}`
-		: escaped;
-};
+module.exports = DllEntryDependency;
 
-const plugin = "CssModulesPlugin";
 
-class CssModulesPlugin {
-	/**
-	 * @param {CssExperimentOptions} options options
-	 */
-	constructor({ exportsOnly = false }) {
-		this._exportsOnly = exportsOnly;
+/***/ }),
+
+/***/ 32006:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Parser").ParserState} ParserState */
+
+/** @type {WeakMap<ParserState, boolean>} */
+const parserStateExportsState = new WeakMap();
+
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.bailout = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	parserStateExportsState.set(parserState, false);
+	if (value === true) {
+		parserState.module.buildMeta.exportsType = undefined;
+		parserState.module.buildMeta.defaultObject = false;
 	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			plugin,
-			(compilation, { normalModuleFactory }) => {
-				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
-				compilation.dependencyFactories.set(
-					CssUrlDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CssUrlDependency,
-					new CssUrlDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					CssLocalIdentifierDependency,
-					new CssLocalIdentifierDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					CssSelfLocalIdentifierDependency,
-					selfFactory
-				);
-				compilation.dependencyTemplates.set(
-					CssSelfLocalIdentifierDependency,
-					new CssSelfLocalIdentifierDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					CssExportDependency,
-					new CssExportDependency.Template()
-				);
-				compilation.dependencyFactories.set(
-					CssImportDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CssImportDependency,
-					new CssImportDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					StaticExportsDependency,
-					new StaticExportsDependency.Template()
-				);
-				normalModuleFactory.hooks.createParser
-					.for("css")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						return new CssParser();
-					});
-				normalModuleFactory.hooks.createParser
-					.for("css/global")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						return new CssParser({
-							allowPseudoBlocks: false,
-							allowModeSwitch: false
-						});
-					});
-				normalModuleFactory.hooks.createParser
-					.for("css/module")
-					.tap(plugin, parserOptions => {
-						validateParserOptions(parserOptions);
-						return new CssParser({
-							defaultMode: "local"
-						});
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("css")
-					.tap(plugin, generatorOptions => {
-						validateGeneratorOptions(generatorOptions);
-						return this._exportsOnly
-							? new CssExportsGenerator()
-							: new CssGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("css/global")
-					.tap(plugin, generatorOptions => {
-						validateGeneratorOptions(generatorOptions);
-						return this._exportsOnly
-							? new CssExportsGenerator()
-							: new CssGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("css/module")
-					.tap(plugin, generatorOptions => {
-						validateGeneratorOptions(generatorOptions);
-						return this._exportsOnly
-							? new CssExportsGenerator()
-							: new CssGenerator();
-					});
-				const orderedCssModulesPerChunk = new WeakMap();
-				compilation.hooks.afterCodeGeneration.tap("CssModulesPlugin", () => {
-					const { chunkGraph } = compilation;
-					for (const chunk of compilation.chunks) {
-						if (CssModulesPlugin.chunkHasCss(chunk, chunkGraph)) {
-							orderedCssModulesPerChunk.set(
-								chunk,
-								this.getOrderedChunkCssModules(chunk, chunkGraph, compilation)
-							);
-						}
-					}
-				});
-				compilation.hooks.contentHash.tap("CssModulesPlugin", chunk => {
-					const {
-						chunkGraph,
-						outputOptions: {
-							hashSalt,
-							hashDigest,
-							hashDigestLength,
-							hashFunction
-						}
-					} = compilation;
-					const modules = orderedCssModulesPerChunk.get(chunk);
-					if (modules === undefined) return;
-					const hash = createHash(hashFunction);
-					if (hashSalt) hash.update(hashSalt);
-					for (const module of modules) {
-						hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
-					}
-					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.css = digest.substr(0, hashDigestLength);
-				});
-				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
-					const { chunkGraph } = compilation;
-					const { hash, chunk, codeGenerationResults } = options;
-
-					if (chunk instanceof HotUpdateChunk) return result;
-
-					const modules = orderedCssModulesPerChunk.get(chunk);
-					if (modules !== undefined) {
-						result.push({
-							render: () =>
-								this.renderChunk({
-									chunk,
-									chunkGraph,
-									codeGenerationResults,
-									uniqueName: compilation.outputOptions.uniqueName,
-									modules
-								}),
-							filenameTemplate: CssModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								compilation.outputOptions
-							),
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "css"
-							},
-							identifier: `css${chunk.id}`,
-							hash: chunk.contentHash.css
-						});
-					}
-					return result;
-				});
-				const enabledChunks = new WeakSet();
-				const handler = (chunk, set) => {
-					if (enabledChunks.has(chunk)) {
-						return;
-					}
-					enabledChunks.add(chunk);
-
-					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.getChunkCssFilename);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.makeNamespaceObject);
+};
 
-					const CssLoadingRuntimeModule = getCssLoadingRuntimeModule();
-					compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hasCssModules)
-					.tap(plugin, handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap(plugin, handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap(plugin, handler);
-			}
-		);
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.enable = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value === false) return;
+	parserStateExportsState.set(parserState, true);
+	if (value !== true) {
+		parserState.module.buildMeta.exportsType = "default";
+		parserState.module.buildMeta.defaultObject = "redirect";
 	}
+};
 
-	getModulesInOrder(chunk, modules, compilation) {
-		if (!modules) return [];
-
-		const modulesList = [...modules];
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.setFlagged = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value !== true) return;
+	const buildMeta = parserState.module.buildMeta;
+	if (buildMeta.exportsType === "dynamic") return;
+	buildMeta.exportsType = "flagged";
+};
 
-		// Get ordered list of modules per chunk group
-		// Lists are in reverse order to allow to use Array.pop()
-		const modulesByChunkGroup = Array.from(chunk.groupsIterable, chunkGroup => {
-			const sortedModules = modulesList
-				.map(module => {
-					return {
-						module,
-						index: chunkGroup.getModulePostOrderIndex(module)
-					};
-				})
-				.filter(item => item.index !== undefined)
-				.sort((a, b) => b.index - a.index)
-				.map(item => item.module);
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.setDynamic = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	if (value !== true) return;
+	parserState.module.buildMeta.exportsType = "dynamic";
+};
 
-			return { list: sortedModules, set: new Set(sortedModules) };
-		});
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+exports.isEnabled = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	return value === true;
+};
 
-		if (modulesByChunkGroup.length === 1)
-			return modulesByChunkGroup[0].list.reverse();
 
-		const compareModuleLists = ({ list: a }, { list: b }) => {
-			if (a.length === 0) {
-				return b.length === 0 ? 0 : 1;
-			} else {
-				if (b.length === 0) return -1;
-				return compareModulesByIdentifier(a[a.length - 1], b[b.length - 1]);
-			}
-		};
+/***/ }),
 
-		modulesByChunkGroup.sort(compareModuleLists);
+/***/ 3979:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const finalModules = [];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		for (;;) {
-			const failedModules = new Set();
-			const list = modulesByChunkGroup[0].list;
-			if (list.length === 0) {
-				// done, everything empty
-				break;
-			}
-			let selectedModule = list[list.length - 1];
-			let hasFailed = undefined;
-			outer: for (;;) {
-				for (const { list, set } of modulesByChunkGroup) {
-					if (list.length === 0) continue;
-					const lastModule = list[list.length - 1];
-					if (lastModule === selectedModule) continue;
-					if (!set.has(selectedModule)) continue;
-					failedModules.add(selectedModule);
-					if (failedModules.has(lastModule)) {
-						// There is a conflict, try other alternatives
-						hasFailed = lastModule;
-						continue;
-					}
-					selectedModule = lastModule;
-					hasFailed = false;
-					continue outer; // restart
-				}
-				break;
-			}
-			if (hasFailed) {
-				// There is a not resolve-able conflict with the selectedModule
-				if (compilation) {
-					// TODO print better warning
-					compilation.warnings.push(
-						new Error(
-							`chunk ${
-								chunk.name || chunk.id
-							}\nConflicting order between ${hasFailed.readableIdentifier(
-								compilation.requestShortener
-							)} and ${selectedModule.readableIdentifier(
-								compilation.requestShortener
-							)}`
-						)
-					);
-				}
-				selectedModule = hasFailed;
-			}
-			// Insert the selected module into the final modules list
-			finalModules.push(selectedModule);
-			// Remove the selected module from all lists
-			for (const { list, set } of modulesByChunkGroup) {
-				const lastModule = list[list.length - 1];
-				if (lastModule === selectedModule) list.pop();
-				else if (hasFailed && set.has(selectedModule)) {
-					const idx = list.indexOf(selectedModule);
-					if (idx >= 0) list.splice(idx, 1);
-				}
-			}
-			modulesByChunkGroup.sort(compareModuleLists);
-		}
-		return finalModules;
-	}
 
-	getOrderedChunkCssModules(chunk, chunkGraph, compilation) {
-		return [
-			...this.getModulesInOrder(
-				chunk,
-				chunkGraph.getOrderedChunkModulesIterableBySourceType(
-					chunk,
-					"css-import",
-					compareModulesByIdentifier
-				),
-				compilation
-			),
-			...this.getModulesInOrder(
-				chunk,
-				chunkGraph.getOrderedChunkModulesIterableBySourceType(
-					chunk,
-					"css",
-					compareModulesByIdentifier
-				),
-				compilation
-			)
-		];
-	}
 
-	renderChunk({
-		uniqueName,
-		chunk,
-		chunkGraph,
-		codeGenerationResults,
-		modules
-	}) {
-		const source = new ConcatSource();
-		const metaData = [];
-		for (const module of modules) {
-			try {
-				const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-				const s =
-					codeGenResult.sources.get("css") ||
-					codeGenResult.sources.get("css-import");
-				if (s) {
-					source.add(s);
-					source.add("\n");
-				}
-				const exports =
-					codeGenResult.data && codeGenResult.data.get("css-exports");
-				const moduleId = chunkGraph.getModuleId(module) + "";
-				metaData.push(
-					`${
-						exports
-							? Array.from(exports, ([n, v]) => {
-									const shortcutValue = `${
-										uniqueName ? uniqueName + "-" : ""
-									}${moduleId}-${n}`;
-									return v === shortcutValue
-										? `${escapeCss(n)}/`
-										: v === "--" + shortcutValue
-										? `${escapeCss(n)}%`
-										: `${escapeCss(n)}(${escapeCss(v)})`;
-							  }).join("")
-							: ""
-					}${escapeCss(moduleId)}`
-				);
-			} catch (e) {
-				e.message += `\nduring rendering of css ${module.identifier()}`;
-				throw e;
-			}
-		}
-		source.add(
-			`head{--webpack-${escapeCss(
-				(uniqueName ? uniqueName + "-" : "") + chunk.id,
-				true
-			)}:${metaData.join(",")};}`
-		);
-		return source;
+class EntryDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request path for entry
+	 */
+	constructor(request) {
+		super(request);
 	}
 
-	static getChunkFilenameTemplate(chunk, outputOptions) {
-		if (chunk.cssFilenameTemplate) {
-			return chunk.cssFilenameTemplate;
-		} else if (chunk.canBeInitial()) {
-			return outputOptions.cssFilename;
-		} else {
-			return outputOptions.cssChunkFilename;
-		}
+	get type() {
+		return "entry";
 	}
 
-	static chunkHasCss(chunk, chunkGraph) {
-		return (
-			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css") ||
-			!!chunkGraph.getChunkModulesIterableBySourceType(chunk, "css-import")
-		);
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = CssModulesPlugin;
+makeSerializable(EntryDependency, "webpack/lib/dependencies/EntryDependency");
+
+module.exports = EntryDependency;
 
 
 /***/ }),
 
-/***/ 98305:
+/***/ 78988:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -76198,623 +76082,531 @@ module.exports = CssModulesPlugin;
 
 
 
-const Parser = __webpack_require__(11715);
-const ConstDependency = __webpack_require__(76911);
-const CssExportDependency = __webpack_require__(76760);
-const CssImportDependency = __webpack_require__(90542);
-const CssLocalIdentifierDependency = __webpack_require__(92328);
-const CssSelfLocalIdentifierDependency = __webpack_require__(29094);
-const CssUrlDependency = __webpack_require__(70749);
-const StaticExportsDependency = __webpack_require__(91418);
-const walkCssTokens = __webpack_require__(44124);
-
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+const { UsageState } = __webpack_require__(63686);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-const CC_LEFT_CURLY = "{".charCodeAt(0);
-const CC_RIGHT_CURLY = "}".charCodeAt(0);
-const CC_COLON = ":".charCodeAt(0);
-const CC_SLASH = "/".charCodeAt(0);
-const CC_SEMICOLON = ";".charCodeAt(0);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const cssUnescape = str => {
-	return str.replace(/\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g, match => {
-		if (match.length > 2) {
-			return String.fromCharCode(parseInt(match.slice(1).trim(), 16));
-		} else {
-			return match[1];
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the module
+ * @param {string | null} exportName name of the export if any
+ * @param {string | null} property name of the requested property
+ * @param {RuntimeSpec} runtime for which runtime
+ * @returns {any} value of the property
+ */
+const getProperty = (moduleGraph, module, exportName, property, runtime) => {
+	if (!exportName) {
+		switch (property) {
+			case "usedExports": {
+				const usedExports = moduleGraph
+					.getExportsInfo(module)
+					.getUsedExports(runtime);
+				if (
+					typeof usedExports === "boolean" ||
+					usedExports === undefined ||
+					usedExports === null
+				) {
+					return usedExports;
+				}
+				return Array.from(usedExports).sort();
+			}
 		}
-	});
+	}
+	switch (property) {
+		case "used":
+			return (
+				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
+				UsageState.Unused
+			);
+		case "useInfo": {
+			const state = moduleGraph
+				.getExportsInfo(module)
+				.getUsed(exportName, runtime);
+			switch (state) {
+				case UsageState.Used:
+				case UsageState.OnlyPropertiesUsed:
+					return true;
+				case UsageState.Unused:
+					return false;
+				case UsageState.NoInfo:
+					return undefined;
+				case UsageState.Unknown:
+					return null;
+				default:
+					throw new Error(`Unexpected UsageState ${state}`);
+			}
+		}
+		case "provideInfo":
+			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
+	}
+	return undefined;
 };
 
-class LocConverter {
-	constructor(input) {
-		this._input = input;
-		this.line = 1;
-		this.column = 0;
-		this.pos = 0;
+class ExportsInfoDependency extends NullDependency {
+	constructor(range, exportName, property) {
+		super();
+		this.range = range;
+		this.exportName = exportName;
+		this.property = property;
 	}
 
-	get(pos) {
-		if (this.pos !== pos) {
-			if (this.pos < pos) {
-				const str = this._input.slice(this.pos, pos);
-				let i = str.lastIndexOf("\n");
-				if (i === -1) {
-					this.column += str.length;
-				} else {
-					this.column = str.length - i - 1;
-					this.line++;
-					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1)
-						this.line++;
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.exportName);
+		write(this.property);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const obj = new ExportsInfoDependency(
+			context.read(),
+			context.read(),
+			context.read()
+		);
+		obj.deserialize(context);
+		return obj;
+	}
+}
+
+makeSerializable(
+	ExportsInfoDependency,
+	"webpack/lib/dependencies/ExportsInfoDependency"
+);
+
+ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { module, moduleGraph, runtime }) {
+		const dep = /** @type {ExportsInfoDependency} */ (dependency);
+
+		const value = getProperty(
+			moduleGraph,
+			module,
+			dep.exportName,
+			dep.property,
+			runtime
+		);
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			value === undefined ? "undefined" : JSON.stringify(value)
+		);
+	}
+};
+
+module.exports = ExportsInfoDependency;
+
+
+/***/ }),
+
+/***/ 23624:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Template = __webpack_require__(1626);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyImportDependency = __webpack_require__(57154);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+
+class HarmonyAcceptDependency extends NullDependency {
+	/**
+	 * @param {[number, number]} range expression range
+	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
+	 * @param {boolean} hasCallback true, if the range wraps an existing callback
+	 */
+	constructor(range, dependencies, hasCallback) {
+		super();
+		this.range = range;
+		this.dependencies = dependencies;
+		this.hasCallback = hasCallback;
+	}
+
+	get type() {
+		return "accepted harmony modules";
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.dependencies);
+		write(this.hasCallback);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.dependencies = read();
+		this.hasCallback = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	HarmonyAcceptDependency,
+	"webpack/lib/dependencies/HarmonyAcceptDependency"
+);
+
+HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
+		const {
+			module,
+			runtime,
+			runtimeRequirements,
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph
+		} = templateContext;
+		const content = dep.dependencies
+			.map(dependency => {
+				const referencedModule = moduleGraph.getModule(dependency);
+				return {
+					dependency,
+					runtimeCondition: referencedModule
+						? HarmonyImportDependency.Template.getImportEmittedRuntime(
+								module,
+								referencedModule
+						  )
+						: false
+				};
+			})
+			.filter(({ runtimeCondition }) => runtimeCondition !== false)
+			.map(({ dependency, runtimeCondition }) => {
+				const condition = runtimeTemplate.runtimeConditionExpression({
+					chunkGraph,
+					runtime,
+					runtimeCondition,
+					runtimeRequirements
+				});
+				const s = dependency.getImportStatement(true, templateContext);
+				const code = s[0] + s[1];
+				if (condition !== "true") {
+					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
 				}
+				return code;
+			})
+			.join("");
+
+		if (dep.hasCallback) {
+			if (runtimeTemplate.supportsArrowFunction()) {
+				source.insert(
+					dep.range[0],
+					`__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`
+				);
+				source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
 			} else {
-				let i = this._input.lastIndexOf("\n", this.pos);
-				while (i >= pos) {
-					this.line--;
-					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
-				}
-				this.column = pos - i;
+				source.insert(
+					dep.range[0],
+					`function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`
+				);
+				source.insert(
+					dep.range[1],
+					")(__WEBPACK_OUTDATED_DEPENDENCIES__); }.bind(this)"
+				);
 			}
-			this.pos = pos;
+			return;
 		}
-		return this;
+
+		const arrow = runtimeTemplate.supportsArrowFunction();
+		source.insert(
+			dep.range[1] - 0.5,
+			`, ${arrow ? "() =>" : "function()"} { ${content} }`
+		);
 	}
-}
+};
 
-const CSS_MODE_TOP_LEVEL = 0;
-const CSS_MODE_IN_RULE = 1;
-const CSS_MODE_IN_LOCAL_RULE = 2;
-const CSS_MODE_AT_IMPORT_EXPECT_URL = 3;
-// TODO implement layer and supports for @import
-const CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS = 4;
-const CSS_MODE_AT_IMPORT_EXPECT_MEDIA = 5;
-const CSS_MODE_AT_OTHER = 6;
+module.exports = HarmonyAcceptDependency;
 
-const explainMode = mode => {
-	switch (mode) {
-		case CSS_MODE_TOP_LEVEL:
-			return "parsing top level css";
-		case CSS_MODE_IN_RULE:
-			return "parsing css rule content (global)";
-		case CSS_MODE_IN_LOCAL_RULE:
-			return "parsing css rule content (local)";
-		case CSS_MODE_AT_IMPORT_EXPECT_URL:
-			return "parsing @import (expecting url)";
-		case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
-			return "parsing @import (expecting optionally supports or media query)";
-		case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
-			return "parsing @import (expecting optionally media query)";
-		case CSS_MODE_AT_OTHER:
-			return "parsing at-rule";
-		default:
-			return mode;
+
+/***/ }),
+
+/***/ 99843:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const HarmonyImportDependency = __webpack_require__(57154);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class HarmonyAcceptImportDependency extends HarmonyImportDependency {
+	constructor(request) {
+		super(request, NaN);
+		this.weak = true;
 	}
-};
 
-class CssParser extends Parser {
-	constructor({
-		allowPseudoBlocks = true,
-		allowModeSwitch = true,
-		defaultMode = "global"
-	} = {}) {
-		super();
-		this.allowPseudoBlocks = allowPseudoBlocks;
-		this.allowModeSwitch = allowModeSwitch;
-		this.defaultMode = defaultMode;
+	get type() {
+		return "harmony accept";
+	}
+}
+
+makeSerializable(
+	HarmonyAcceptImportDependency,
+	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
+);
+
+HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {};
+
+module.exports = HarmonyAcceptImportDependency;
+
+
+/***/ }),
+
+/***/ 72906:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { UsageState } = __webpack_require__(63686);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
+
+class HarmonyCompatibilityDependency extends NullDependency {
+	get type() {
+		return "harmony export header";
 	}
+}
 
+makeSerializable(
+	HarmonyCompatibilityDependency,
+	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
+);
+
+HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	parse(source, state) {
-		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
-		} else if (typeof source === "object") {
-			throw new Error("webpackAst is unexpected for the CssParser");
+	apply(
+		dependency,
+		source,
+		{
+			module,
+			runtimeTemplate,
+			moduleGraph,
+			initFragments,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
 		}
-		if (source[0] === "\ufeff") {
-			source = source.slice(1);
+	) {
+		if (concatenationScope) return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		if (
+			exportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
+			UsageState.Unused
+		) {
+			const content = runtimeTemplate.defineEsModuleFlagStatement({
+				exportsArgument: module.exportsArgument,
+				runtimeRequirements
+			});
+			initFragments.push(
+				new InitFragment(
+					content,
+					InitFragment.STAGE_HARMONY_EXPORTS,
+					0,
+					"harmony compatibility"
+				)
+			);
+		}
+		if (moduleGraph.isAsync(module)) {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+			initFragments.push(
+				new InitFragment(
+					runtimeTemplate.supportsArrowFunction()
+						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+					InitFragment.STAGE_ASYNC_BOUNDARY,
+					0,
+					undefined,
+					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
+						module.buildMeta.async ? ", 1" : ""
+					});`
+				)
+			);
 		}
+	}
+};
 
-		const module = state.module;
+module.exports = HarmonyCompatibilityDependency;
 
-		const declaredCssVariables = new Set();
 
-		const locConverter = new LocConverter(source);
-		let mode = CSS_MODE_TOP_LEVEL;
-		let modePos = 0;
-		let modeNestingLevel = 0;
-		let modeData = undefined;
-		let singleClassSelector = undefined;
-		let lastIdentifier = undefined;
-		const modeStack = [];
-		const isTopLevelLocal = () =>
-			modeData === "local" ||
-			(this.defaultMode === "local" && modeData === undefined);
-		const eatWhiteLine = (input, pos) => {
-			for (;;) {
-				const cc = input.charCodeAt(pos);
-				if (cc === 32 || cc === 9) {
-					pos++;
-					continue;
-				}
-				if (cc === 10) pos++;
-				break;
+/***/ }),
+
+/***/ 17223:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const DynamicExports = __webpack_require__(32006);
+const HarmonyCompatibilityDependency = __webpack_require__(72906);
+const HarmonyExports = __webpack_require__(39211);
+
+module.exports = class HarmonyDetectionParserPlugin {
+	constructor(options) {
+		const { topLevelAwait = false } = options || {};
+		this.topLevelAwait = topLevelAwait;
+	}
+
+	apply(parser) {
+		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
+			const isStrictHarmony = parser.state.module.type === "javascript/esm";
+			const isHarmony =
+				isStrictHarmony ||
+				ast.body.some(
+					statement =>
+						statement.type === "ImportDeclaration" ||
+						statement.type === "ExportDefaultDeclaration" ||
+						statement.type === "ExportNamedDeclaration" ||
+						statement.type === "ExportAllDeclaration"
+				);
+			if (isHarmony) {
+				const module = parser.state.module;
+				const compatDep = new HarmonyCompatibilityDependency();
+				compatDep.loc = {
+					start: {
+						line: -1,
+						column: 0
+					},
+					end: {
+						line: -1,
+						column: 0
+					},
+					index: -3
+				};
+				module.addPresentationalDependency(compatDep);
+				DynamicExports.bailout(parser.state);
+				HarmonyExports.enable(parser.state, isStrictHarmony);
+				parser.scope.isStrict = true;
+			}
+		});
+
+		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
+			const module = parser.state.module;
+			if (!this.topLevelAwait) {
+				throw new Error(
+					"The top-level-await experiment is not enabled (set experiments.topLevelAwait: true to enabled it)"
+				);
+			}
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				throw new Error(
+					"Top-level-await is only supported in EcmaScript Modules"
+				);
+			}
+			module.buildMeta.async = true;
+		});
+
+		const skipInHarmony = () => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				return true;
 			}
-			return pos;
 		};
-		const eatUntil = chars => {
-			const charCodes = Array.from({ length: chars.length }, (_, i) =>
-				chars.charCodeAt(i)
-			);
-			const arr = Array.from(
-				{ length: charCodes.reduce((a, b) => Math.max(a, b), 0) + 1 },
-				() => false
-			);
-			charCodes.forEach(cc => (arr[cc] = true));
-			return (input, pos) => {
-				for (;;) {
-					const cc = input.charCodeAt(pos);
-					if (cc < arr.length && arr[cc]) {
-						return pos;
-					}
-					pos++;
-					if (pos === input.length) return pos;
-				}
-			};
+
+		const nullInHarmony = () => {
+			if (HarmonyExports.isEnabled(parser.state)) {
+				return null;
+			}
 		};
-		const eatText = (input, pos, eater) => {
-			let text = "";
-			for (;;) {
-				if (input.charCodeAt(pos) === CC_SLASH) {
-					const newPos = walkCssTokens.eatComments(input, pos);
-					if (pos !== newPos) {
-						pos = newPos;
-						if (pos === input.length) break;
-					} else {
-						text += "/";
-						pos++;
-						if (pos === input.length) break;
-					}
-				}
-				const newPos = eater(input, pos);
-				if (pos !== newPos) {
-					text += input.slice(pos, newPos);
-					pos = newPos;
-				} else {
-					break;
-				}
-				if (pos === input.length) break;
-			}
-			return [pos, text.trimRight()];
-		};
-		const eatExportName = eatUntil(":};/");
-		const eatExportValue = eatUntil("};/");
-		const parseExports = (input, pos) => {
-			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-			const cc = input.charCodeAt(pos);
-			if (cc !== CC_LEFT_CURLY)
-				throw new Error(
-					`Unexpected ${input[pos]} at ${pos} during parsing of ':export' (expected '{')`
-				);
-			pos++;
-			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-			for (;;) {
-				if (input.charCodeAt(pos) === CC_RIGHT_CURLY) break;
-				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-				if (pos === input.length) return pos;
-				let start = pos;
-				let name;
-				[pos, name] = eatText(input, pos, eatExportName);
-				if (pos === input.length) return pos;
-				if (input.charCodeAt(pos) !== CC_COLON) {
-					throw new Error(
-						`Unexpected ${input[pos]} at ${pos} during parsing of export name in ':export' (expected ':')`
-					);
-				}
-				pos++;
-				if (pos === input.length) return pos;
-				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-				if (pos === input.length) return pos;
-				let value;
-				[pos, value] = eatText(input, pos, eatExportValue);
-				if (pos === input.length) return pos;
-				const cc = input.charCodeAt(pos);
-				if (cc === CC_SEMICOLON) {
-					pos++;
-					if (pos === input.length) return pos;
-					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-					if (pos === input.length) return pos;
-				} else if (cc !== CC_RIGHT_CURLY) {
-					throw new Error(
-						`Unexpected ${input[pos]} at ${pos} during parsing of export value in ':export' (expected ';' or '}')`
-					);
-				}
-				const dep = new CssExportDependency(name, value);
-				const { line: sl, column: sc } = locConverter.get(start);
-				const { line: el, column: ec } = locConverter.get(pos);
-				dep.setLoc(sl, sc, el, ec);
-				module.addDependency(dep);
-			}
-			pos++;
-			if (pos === input.length) return pos;
-			pos = eatWhiteLine(input, pos);
-			return pos;
-		};
-		const eatPropertyName = eatUntil(":{};");
-		const processLocalDeclaration = (input, pos) => {
-			modeData = undefined;
-			const start = pos;
-			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-			const propertyNameStart = pos;
-			const [propertyNameEnd, propertyName] = eatText(
-				input,
-				pos,
-				eatPropertyName
-			);
-			if (input.charCodeAt(propertyNameEnd) !== CC_COLON) return start;
-			pos = propertyNameEnd + 1;
-			if (propertyName.startsWith("--")) {
-				// CSS Variable
-				const { line: sl, column: sc } = locConverter.get(propertyNameStart);
-				const { line: el, column: ec } = locConverter.get(propertyNameEnd);
-				const name = propertyName.slice(2);
-				const dep = new CssLocalIdentifierDependency(
-					name,
-					[propertyNameStart, propertyNameEnd],
-					"--"
-				);
-				dep.setLoc(sl, sc, el, ec);
-				module.addDependency(dep);
-				declaredCssVariables.add(name);
-			} else if (
-				propertyName === "animation-name" ||
-				propertyName === "animation"
-			) {
-				modeData = "animation";
-				lastIdentifier = undefined;
-			}
-			return pos;
-		};
-		const processDeclarationValueDone = (input, pos) => {
-			if (modeData === "animation" && lastIdentifier) {
-				const { line: sl, column: sc } = locConverter.get(lastIdentifier[0]);
-				const { line: el, column: ec } = locConverter.get(lastIdentifier[1]);
-				const name = input.slice(lastIdentifier[0], lastIdentifier[1]);
-				const dep = new CssSelfLocalIdentifierDependency(name, lastIdentifier);
-				dep.setLoc(sl, sc, el, ec);
-				module.addDependency(dep);
-			}
-		};
-		const eatKeyframes = eatUntil("{};/");
-		const eatNameInVar = eatUntil(",)};/");
-		walkCssTokens(source, {
-			isSelector: () => {
-				return mode !== CSS_MODE_IN_RULE && mode !== CSS_MODE_IN_LOCAL_RULE;
-			},
-			url: (input, start, end, contentStart, contentEnd) => {
-				const value = cssUnescape(input.slice(contentStart, contentEnd));
-				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
-						modeData.url = value;
-						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
-						break;
-					}
-					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS:
-					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
-						throw new Error(
-							`Unexpected ${input.slice(
-								start,
-								end
-							)} at ${start} during ${explainMode(mode)}`
-						);
-					default: {
-						const dep = new CssUrlDependency(value, [start, end], "url");
-						const { line: sl, column: sc } = locConverter.get(start);
-						const { line: el, column: ec } = locConverter.get(end);
-						dep.setLoc(sl, sc, el, ec);
-						module.addDependency(dep);
-						module.addCodeGenerationDependency(dep);
-						break;
-					}
-				}
-				return end;
-			},
-			string: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL: {
-						modeData.url = cssUnescape(input.slice(start + 1, end - 1));
-						mode = CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS;
-						break;
-					}
-				}
-				return end;
-			},
-			atKeyword: (input, start, end) => {
-				const name = input.slice(start, end);
-				if (name === "@namespace") {
-					throw new Error("@namespace is not supported in bundled CSS");
-				}
-				if (name === "@import") {
-					if (mode !== CSS_MODE_TOP_LEVEL) {
-						throw new Error(
-							`Unexpected @import at ${start} during ${explainMode(mode)}`
-						);
-					}
-					mode = CSS_MODE_AT_IMPORT_EXPECT_URL;
-					modePos = end;
-					modeData = {
-						start: start,
-						url: undefined,
-						supports: undefined
-					};
-				}
-				if (name === "@keyframes") {
-					let pos = end;
-					pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
-					if (pos === input.length) return pos;
-					const [newPos, name] = eatText(input, pos, eatKeyframes);
-					const { line: sl, column: sc } = locConverter.get(pos);
-					const { line: el, column: ec } = locConverter.get(newPos);
-					const dep = new CssLocalIdentifierDependency(name, [pos, newPos]);
-					dep.setLoc(sl, sc, el, ec);
-					module.addDependency(dep);
-					pos = newPos;
-					if (pos === input.length) return pos;
-					if (input.charCodeAt(pos) !== CC_LEFT_CURLY) {
-						throw new Error(
-							`Unexpected ${input[pos]} at ${pos} during parsing of @keyframes (expected '{')`
-						);
-					}
-					mode = CSS_MODE_IN_LOCAL_RULE;
-					modeNestingLevel = 1;
-					return pos + 1;
-				}
-				return end;
-			},
-			semicolon: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_AT_IMPORT_EXPECT_URL:
-						throw new Error(`Expected URL for @import at ${start}`);
-					case CSS_MODE_AT_IMPORT_EXPECT_MEDIA:
-					case CSS_MODE_AT_IMPORT_EXPECT_SUPPORTS: {
-						const { line: sl, column: sc } = locConverter.get(modeData.start);
-						const { line: el, column: ec } = locConverter.get(end);
-						end = eatWhiteLine(input, end);
-						const media = input.slice(modePos, start).trim();
-						const dep = new CssImportDependency(
-							modeData.url,
-							[modeData.start, end],
-							modeData.supports,
-							media
-						);
-						dep.setLoc(sl, sc, el, ec);
-						module.addDependency(dep);
-						break;
-					}
-					case CSS_MODE_IN_LOCAL_RULE: {
-						processDeclarationValueDone(input, start);
-						return processLocalDeclaration(input, end);
-					}
-					case CSS_MODE_IN_RULE: {
-						return end;
-					}
-				}
-				mode = CSS_MODE_TOP_LEVEL;
-				modeData = undefined;
-				singleClassSelector = undefined;
-				return end;
-			},
-			leftCurlyBracket: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL:
-						mode = isTopLevelLocal()
-							? CSS_MODE_IN_LOCAL_RULE
-							: CSS_MODE_IN_RULE;
-						modeNestingLevel = 1;
-						if (mode === CSS_MODE_IN_LOCAL_RULE)
-							return processLocalDeclaration(input, end);
-						break;
-					case CSS_MODE_IN_RULE:
-					case CSS_MODE_IN_LOCAL_RULE:
-						modeNestingLevel++;
-						break;
-				}
-				return end;
-			},
-			rightCurlyBracket: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_IN_LOCAL_RULE:
-						processDeclarationValueDone(input, start);
-					/* falls through */
-					case CSS_MODE_IN_RULE:
-						if (--modeNestingLevel === 0) {
-							mode = CSS_MODE_TOP_LEVEL;
-							modeData = undefined;
-							singleClassSelector = undefined;
-						}
-						break;
-				}
-				return end;
-			},
-			id: (input, start, end) => {
-				singleClassSelector = false;
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL:
-						if (isTopLevelLocal()) {
-							const name = input.slice(start + 1, end);
-							const dep = new CssLocalIdentifierDependency(name, [
-								start + 1,
-								end
-							]);
-							const { line: sl, column: sc } = locConverter.get(start);
-							const { line: el, column: ec } = locConverter.get(end);
-							dep.setLoc(sl, sc, el, ec);
-							module.addDependency(dep);
-						}
-						break;
-				}
-				return end;
-			},
-			identifier: (input, start, end) => {
-				singleClassSelector = false;
-				switch (mode) {
-					case CSS_MODE_IN_LOCAL_RULE:
-						if (modeData === "animation") {
-							lastIdentifier = [start, end];
-						}
-						break;
-				}
-				return end;
-			},
-			class: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						if (isTopLevelLocal()) {
-							const name = input.slice(start + 1, end);
-							const dep = new CssLocalIdentifierDependency(name, [
-								start + 1,
-								end
-							]);
-							const { line: sl, column: sc } = locConverter.get(start);
-							const { line: el, column: ec } = locConverter.get(end);
-							dep.setLoc(sl, sc, el, ec);
-							module.addDependency(dep);
-							if (singleClassSelector === undefined) singleClassSelector = name;
-						} else {
-							singleClassSelector = false;
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			leftParenthesis: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						modeStack.push(false);
-						break;
-					}
-				}
-				return end;
-			},
-			rightParenthesis: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						const newModeData = modeStack.pop();
-						if (newModeData !== false) {
-							modeData = newModeData;
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			pseudoClass: (input, start, end) => {
-				singleClassSelector = false;
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						const name = input.slice(start, end);
-						if (this.allowModeSwitch && name === ":global") {
-							modeData = "global";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else if (this.allowModeSwitch && name === ":local") {
-							modeData = "local";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else if (this.allowPseudoBlocks && name === ":export") {
-							const pos = parseExports(input, end);
-							const dep = new ConstDependency("", [start, pos]);
-							module.addPresentationalDependency(dep);
-							return pos;
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			pseudoFunction: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL: {
-						const name = input.slice(start, end - 1);
-						if (this.allowModeSwitch && name === ":global") {
-							modeStack.push(modeData);
-							modeData = "global";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else if (this.allowModeSwitch && name === ":local") {
-							modeStack.push(modeData);
-							modeData = "local";
-							const dep = new ConstDependency("", [start, end]);
-							module.addPresentationalDependency(dep);
-						} else {
-							modeStack.push(false);
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			function: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_IN_LOCAL_RULE: {
-						const name = input.slice(start, end - 1);
-						if (name === "var") {
-							let pos = walkCssTokens.eatWhitespaceAndComments(input, end);
-							if (pos === input.length) return pos;
-							const [newPos, name] = eatText(input, pos, eatNameInVar);
-							if (!name.startsWith("--")) return end;
-							const { line: sl, column: sc } = locConverter.get(pos);
-							const { line: el, column: ec } = locConverter.get(newPos);
-							const dep = new CssSelfLocalIdentifierDependency(
-								name.slice(2),
-								[pos, newPos],
-								"--",
-								declaredCssVariables
-							);
-							dep.setLoc(sl, sc, el, ec);
-							module.addDependency(dep);
-							return newPos;
-						}
-						break;
-					}
-				}
-				return end;
-			},
-			comma: (input, start, end) => {
-				switch (mode) {
-					case CSS_MODE_TOP_LEVEL:
-						modeData = undefined;
-						modeStack.length = 0;
-						break;
-					case CSS_MODE_IN_LOCAL_RULE:
-						processDeclarationValueDone(input, start);
-						break;
-				}
-				return end;
-			}
-		});
 
-		module.buildInfo.strict = true;
-		module.buildMeta.exportsType = "namespace";
-		module.addDependency(new StaticExportsDependency([], true));
-		return state;
+		const nonHarmonyIdentifiers = ["define", "exports"];
+		for (const identifier of nonHarmonyIdentifiers) {
+			parser.hooks.evaluateTypeof
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
+			parser.hooks.typeof
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+			parser.hooks.evaluate
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
+			parser.hooks.expression
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+			parser.hooks.call
+				.for(identifier)
+				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+		}
 	}
-}
-
-module.exports = CssParser;
+};
 
 
 /***/ }),
 
-/***/ 44124:
-/***/ (function(module) {
+/***/ 93466:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -76824,2001 +76616,1359 @@ module.exports = CssParser;
 
 
 
-/**
- * @typedef {Object} CssTokenCallbacks
- * @property {function(string, number): boolean} isSelector
- * @property {function(string, number, number, number, number): number=} url
- * @property {function(string, number, number): number=} string
- * @property {function(string, number, number): number=} leftParenthesis
- * @property {function(string, number, number): number=} rightParenthesis
- * @property {function(string, number, number): number=} pseudoFunction
- * @property {function(string, number, number): number=} function
- * @property {function(string, number, number): number=} pseudoClass
- * @property {function(string, number, number): number=} atKeyword
- * @property {function(string, number, number): number=} class
- * @property {function(string, number, number): number=} identifier
- * @property {function(string, number, number): number=} id
- * @property {function(string, number, number): number=} leftCurlyBracket
- * @property {function(string, number, number): number=} rightCurlyBracket
- * @property {function(string, number, number): number=} semicolon
- * @property {function(string, number, number): number=} comma
- */
-
-/** @typedef {function(string, number, CssTokenCallbacks): number} CharHandler */
-
-// spec: https://drafts.csswg.org/css-syntax/
+const InnerGraph = __webpack_require__(38988);
+const ConstDependency = __webpack_require__(76911);
+const HarmonyExportExpressionDependency = __webpack_require__(51340);
+const HarmonyExportHeaderDependency = __webpack_require__(38873);
+const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
+const HarmonyExportSpecifierDependency = __webpack_require__(48567);
+const { ExportPresenceModes } = __webpack_require__(57154);
+const {
+	harmonySpecifierTag,
+	getAssertions
+} = __webpack_require__(20862);
+const HarmonyImportSideEffectDependency = __webpack_require__(73132);
 
-const CC_LINE_FEED = "\n".charCodeAt(0);
-const CC_CARRIAGE_RETURN = "\r".charCodeAt(0);
-const CC_FORM_FEED = "\f".charCodeAt(0);
+const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
 
-const CC_TAB = "\t".charCodeAt(0);
-const CC_SPACE = " ".charCodeAt(0);
+module.exports = class HarmonyExportDependencyParserPlugin {
+	constructor(options) {
+		this.exportPresenceMode =
+			options.reexportExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
+	}
 
-const CC_SLASH = "/".charCodeAt(0);
-const CC_BACK_SLASH = "\\".charCodeAt(0);
-const CC_ASTERISK = "*".charCodeAt(0);
+	apply(parser) {
+		const { exportPresenceMode } = this;
+		parser.hooks.export.tap(
+			"HarmonyExportDependencyParserPlugin",
+			statement => {
+				const dep = new HarmonyExportHeaderDependency(
+					statement.declaration && statement.declaration.range,
+					statement.range
+				);
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = -1;
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		);
+		parser.hooks.exportImport.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency("", statement.range);
+				clearDep.loc = Object.create(statement.loc);
+				clearDep.loc.index = -1;
+				parser.state.module.addPresentationalDependency(clearDep);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					source,
+					parser.state.lastHarmonyImportOrder,
+					getAssertions(statement)
+				);
+				sideEffectDep.loc = Object.create(statement.loc);
+				sideEffectDep.loc.index = -1;
+				parser.state.current.addDependency(sideEffectDep);
+				return true;
+			}
+		);
+		parser.hooks.exportExpression.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, expr) => {
+				const isFunctionDeclaration = expr.type === "FunctionDeclaration";
+				const comments = parser.getComments([
+					statement.range[0],
+					expr.range[0]
+				]);
+				const dep = new HarmonyExportExpressionDependency(
+					expr.range,
+					statement.range,
+					comments
+						.map(c => {
+							switch (c.type) {
+								case "Block":
+									return `/*${c.value}*/`;
+								case "Line":
+									return `//${c.value}\n`;
+							}
+							return "";
+						})
+						.join(""),
+					expr.type.endsWith("Declaration") && expr.id
+						? expr.id.name
+						: isFunctionDeclaration
+						? {
+								id: expr.id ? expr.id.name : undefined,
+								range: [
+									expr.range[0],
+									expr.params.length > 0
+										? expr.params[0].range[0]
+										: expr.body.range[0]
+								],
+								prefix: `${expr.async ? "async " : ""}function${
+									expr.generator ? "*" : ""
+								} `,
+								suffix: `(${expr.params.length > 0 ? "" : ") "}`
+						  }
+						: undefined
+				);
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = -1;
+				parser.state.current.addDependency(dep);
+				InnerGraph.addVariableUsage(
+					parser,
+					expr.type.endsWith("Declaration") && expr.id
+						? expr.id.name
+						: "*default*",
+					"default"
+				);
+				return true;
+			}
+		);
+		parser.hooks.exportSpecifier.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, id, name, idx) => {
+				const settings = parser.getTagData(id, harmonySpecifierTag);
+				let dep;
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				harmonyNamedExports.add(name);
+				InnerGraph.addVariableUsage(parser, id, name);
+				if (settings) {
+					dep = new HarmonyExportImportedSpecifierDependency(
+						settings.source,
+						settings.sourceOrder,
+						settings.ids,
+						name,
+						harmonyNamedExports,
+						null,
+						exportPresenceMode,
+						null,
+						settings.assertions
+					);
+				} else {
+					dep = new HarmonyExportSpecifierDependency(id, name);
+				}
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = idx;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		);
+		parser.hooks.exportImportSpecifier.tap(
+			"HarmonyExportDependencyParserPlugin",
+			(statement, source, id, name, idx) => {
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				let harmonyStarExports = null;
+				if (name) {
+					harmonyNamedExports.add(name);
+				} else {
+					harmonyStarExports = parser.state.harmonyStarExports =
+						parser.state.harmonyStarExports || new HarmonyStarExportsList();
+				}
+				const dep = new HarmonyExportImportedSpecifierDependency(
+					source,
+					parser.state.lastHarmonyImportOrder,
+					id ? [id] : [],
+					name,
+					harmonyNamedExports,
+					harmonyStarExports && harmonyStarExports.slice(),
+					exportPresenceMode,
+					harmonyStarExports
+				);
+				if (harmonyStarExports) {
+					harmonyStarExports.push(dep);
+				}
+				dep.loc = Object.create(statement.loc);
+				dep.loc.index = idx;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		);
+	}
+};
 
-const CC_LEFT_PARENTHESIS = "(".charCodeAt(0);
-const CC_RIGHT_PARENTHESIS = ")".charCodeAt(0);
-const CC_LEFT_CURLY = "{".charCodeAt(0);
-const CC_RIGHT_CURLY = "}".charCodeAt(0);
 
-const CC_QUOTATION_MARK = '"'.charCodeAt(0);
-const CC_APOSTROPHE = "'".charCodeAt(0);
+/***/ }),
 
-const CC_FULL_STOP = ".".charCodeAt(0);
-const CC_COLON = ":".charCodeAt(0);
-const CC_SEMICOLON = ";".charCodeAt(0);
-const CC_COMMA = ",".charCodeAt(0);
-const CC_PERCENTAGE = "%".charCodeAt(0);
-const CC_AT_SIGN = "@".charCodeAt(0);
+/***/ 51340:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const CC_LOW_LINE = "_".charCodeAt(0);
-const CC_LOWER_A = "a".charCodeAt(0);
-const CC_LOWER_U = "u".charCodeAt(0);
-const CC_LOWER_E = "e".charCodeAt(0);
-const CC_LOWER_Z = "z".charCodeAt(0);
-const CC_UPPER_A = "A".charCodeAt(0);
-const CC_UPPER_E = "E".charCodeAt(0);
-const CC_UPPER_Z = "Z".charCodeAt(0);
-const CC_0 = "0".charCodeAt(0);
-const CC_9 = "9".charCodeAt(0);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-const CC_NUMBER_SIGN = "#".charCodeAt(0);
-const CC_PLUS_SIGN = "+".charCodeAt(0);
-const CC_HYPHEN_MINUS = "-".charCodeAt(0);
 
-const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
-const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
 
-const _isNewLine = cc => {
-	return (
-		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
-	);
-};
+const ConcatenationScope = __webpack_require__(98229);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyExportInitFragment = __webpack_require__(89500);
+const NullDependency = __webpack_require__(31830);
 
-/** @type {CharHandler} */
-const consumeSpace = (input, pos, callbacks) => {
-	let cc;
-	do {
-		pos++;
-		cc = input.charCodeAt(pos);
-	} while (_isWhiteSpace(cc));
-	return pos;
-};
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 
-const _isWhiteSpace = cc => {
-	return (
-		cc === CC_LINE_FEED ||
-		cc === CC_CARRIAGE_RETURN ||
-		cc === CC_FORM_FEED ||
-		cc === CC_TAB ||
-		cc === CC_SPACE
-	);
-};
+class HarmonyExportExpressionDependency extends NullDependency {
+	constructor(range, rangeStatement, prefix, declarationId) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
+		this.prefix = prefix;
+		this.declarationId = declarationId;
+	}
 
-/** @type {CharHandler} */
-const consumeSingleCharToken = (input, pos, callbacks) => {
-	return pos + 1;
-};
+	get type() {
+		return "harmony export expression";
+	}
 
-/** @type {CharHandler} */
-const consumePotentialComment = (input, pos, callbacks) => {
-	pos++;
-	if (pos === input.length) return pos;
-	let cc = input.charCodeAt(pos);
-	if (cc !== CC_ASTERISK) return pos;
-	for (;;) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
-		while (cc === CC_ASTERISK) {
-			pos++;
-			if (pos === input.length) return pos;
-			cc = input.charCodeAt(pos);
-			if (cc === CC_SLASH) return pos + 1;
-		}
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: ["default"],
+			priority: 1,
+			terminalBinding: true,
+			dependencies: undefined
+		};
 	}
-};
 
-/** @type {function(number): CharHandler} */
-const consumeString = end => (input, pos, callbacks) => {
-	const start = pos;
-	pos = _consumeString(input, pos, end);
-	if (callbacks.string !== undefined) {
-		pos = callbacks.string(input, start, pos);
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		// The expression/declaration is already covered by SideEffectsFlagPlugin
+		return false;
 	}
-	return pos;
-};
 
-const _consumeString = (input, pos, end) => {
-	pos++;
-	for (;;) {
-		if (pos === input.length) return pos;
-		const cc = input.charCodeAt(pos);
-		if (cc === end) return pos + 1;
-		if (_isNewLine(cc)) {
-			// bad string
-			return pos;
-		}
-		if (cc === CC_BACK_SLASH) {
-			// we don't need to fully parse the escaped code point
-			// just skip over a potential new line
-			pos++;
-			if (pos === input.length) return pos;
-			pos++;
-		} else {
-			pos++;
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.rangeStatement);
+		write(this.prefix);
+		write(this.declarationId);
+		super.serialize(context);
 	}
-};
 
-const _isIdentifierStartCode = cc => {
-	return (
-		cc === CC_LOW_LINE ||
-		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
-		cc > 0x80
-	);
-};
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.rangeStatement = read();
+		this.prefix = read();
+		this.declarationId = read();
+		super.deserialize(context);
+	}
+}
 
-const _isDigit = cc => {
-	return cc >= CC_0 && cc <= CC_9;
-};
+makeSerializable(
+	HarmonyExportExpressionDependency,
+	"webpack/lib/dependencies/HarmonyExportExpressionDependency"
+);
 
-const _startsIdentifier = (input, pos) => {
-	const cc = input.charCodeAt(pos);
-	if (cc === CC_HYPHEN_MINUS) {
-		if (pos === input.length) return false;
-		const cc = input.charCodeAt(pos + 1);
-		if (cc === CC_HYPHEN_MINUS) return true;
-		if (cc === CC_BACK_SLASH) {
-			const cc = input.charCodeAt(pos + 2);
-			return !_isNewLine(cc);
+HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{
+			module,
+			moduleGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			initFragments,
+			runtime,
+			concatenationScope
 		}
-		return _isIdentifierStartCode(cc);
-	}
-	if (cc === CC_BACK_SLASH) {
-		const cc = input.charCodeAt(pos + 1);
-		return !_isNewLine(cc);
-	}
-	return _isIdentifierStartCode(cc);
-};
+	) {
+		const dep = /** @type {HarmonyExportExpressionDependency} */ (dependency);
+		const { declarationId } = dep;
+		const exportsName = module.exportsArgument;
+		if (declarationId) {
+			let name;
+			if (typeof declarationId === "string") {
+				name = declarationId;
+			} else {
+				name = ConcatenationScope.DEFAULT_EXPORT;
+				source.replace(
+					declarationId.range[0],
+					declarationId.range[1] - 1,
+					`${declarationId.prefix}${name}${declarationId.suffix}`
+				);
+			}
 
-/** @type {CharHandler} */
-const consumeNumberSign = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.id !== undefined) {
-			return callbacks.id(input, start, pos);
-		}
-	}
-	return pos;
-};
+			if (concatenationScope) {
+				concatenationScope.registerExport("default", name);
+			} else {
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName("default", runtime);
+				if (used) {
+					const map = new Map();
+					map.set(used, `/* export default binding */ ${name}`);
+					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+				}
+			}
 
-/** @type {CharHandler} */
-const consumeMinus = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	const cc = input.charCodeAt(pos);
-	if (cc === CC_FULL_STOP || _isDigit(cc)) {
-		return consumeNumericToken(input, pos, callbacks);
-	} else if (cc === CC_HYPHEN_MINUS) {
-		pos++;
-		if (pos === input.length) return pos;
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_GREATER_THAN_SIGN) {
-			return pos + 1;
+			source.replace(
+				dep.rangeStatement[0],
+				dep.range[0] - 1,
+				`/* harmony default export */ ${dep.prefix}`
+			);
 		} else {
-			pos = _consumeIdentifier(input, pos);
-			if (callbacks.identifier !== undefined) {
-				return callbacks.identifier(input, start, pos);
+			let content;
+			const name = ConcatenationScope.DEFAULT_EXPORT;
+			if (runtimeTemplate.supportsConst()) {
+				content = `/* harmony default export */ const ${name} = `;
+				if (concatenationScope) {
+					concatenationScope.registerExport("default", name);
+				} else {
+					const used = moduleGraph
+						.getExportsInfo(module)
+						.getUsedName("default", runtime);
+					if (used) {
+						runtimeRequirements.add(RuntimeGlobals.exports);
+						const map = new Map();
+						map.set(used, name);
+						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+					} else {
+						content = `/* unused harmony default export */ var ${name} = `;
+					}
+				}
+			} else if (concatenationScope) {
+				content = `/* harmony default export */ var ${name} = `;
+				concatenationScope.registerExport("default", name);
+			} else {
+				const used = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName("default", runtime);
+				if (used) {
+					runtimeRequirements.add(RuntimeGlobals.exports);
+					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
+					content = `/* harmony default export */ ${exportsName}[${JSON.stringify(
+						used
+					)}] = `;
+				} else {
+					content = `/* unused harmony default export */ var ${name} = `;
+				}
 			}
-		}
-	} else if (cc === CC_BACK_SLASH) {
-		if (pos + 1 === input.length) return pos;
-		const cc = input.charCodeAt(pos + 1);
-		if (_isNewLine(cc)) return pos;
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
-	} else if (_isIdentifierStartCode(cc)) {
-		pos++;
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
+
+			if (dep.range) {
+				source.replace(
+					dep.rangeStatement[0],
+					dep.range[0] - 1,
+					content + "(" + dep.prefix
+				);
+				source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
+				return;
+			}
+
+			source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
 		}
 	}
-	return pos;
 };
 
-/** @type {CharHandler} */
-const consumeDot = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	const cc = input.charCodeAt(pos);
-	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
-	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
-		return pos;
-	pos = _consumeIdentifier(input, pos);
-	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
-	return pos;
-};
+module.exports = HarmonyExportExpressionDependency;
 
-/** @type {CharHandler} */
-const consumeNumericToken = (input, pos, callbacks) => {
-	pos = _consumeNumber(input, pos);
-	if (pos === input.length) return pos;
-	if (_startsIdentifier(input, pos)) return _consumeIdentifier(input, pos);
-	const cc = input.charCodeAt(pos);
-	if (cc === CC_PERCENTAGE) return pos + 1;
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeOtherIdentifier = (input, pos, callbacks) => {
-	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (
-		pos !== input.length &&
-		!callbacks.isSelector(input, pos) &&
-		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
-	) {
-		pos++;
-		if (callbacks.function !== undefined) {
-			return callbacks.function(input, start, pos);
-		}
-	} else {
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
-	}
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumePotentialUrl = (input, pos, callbacks) => {
-	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (pos === start + 3 && input.slice(start, pos + 1) === "url(") {
-		pos++;
-		let cc = input.charCodeAt(pos);
-		while (_isWhiteSpace(cc)) {
-			pos++;
-			if (pos === input.length) return pos;
-			cc = input.charCodeAt(pos);
-		}
-		if (cc === CC_QUOTATION_MARK || cc === CC_APOSTROPHE) {
-			pos++;
-			const contentStart = pos;
-			pos = _consumeString(input, pos, cc);
-			const contentEnd = pos - 1;
-			cc = input.charCodeAt(pos);
-			while (_isWhiteSpace(cc)) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-			}
-			if (cc !== CC_RIGHT_PARENTHESIS) return pos;
-			pos++;
-			if (callbacks.url !== undefined)
-				return callbacks.url(input, start, pos, contentStart, contentEnd);
-			return pos;
-		} else {
-			const contentStart = pos;
-			let contentEnd;
-			for (;;) {
-				if (cc === CC_BACK_SLASH) {
-					pos++;
-					if (pos === input.length) return pos;
-					pos++;
-				} else if (_isWhiteSpace(cc)) {
-					contentEnd = pos;
-					do {
-						pos++;
-						if (pos === input.length) return pos;
-						cc = input.charCodeAt(pos);
-					} while (_isWhiteSpace(cc));
-					if (cc !== CC_RIGHT_PARENTHESIS) return pos;
-					pos++;
-					if (callbacks.url !== undefined) {
-						return callbacks.url(input, start, pos, contentStart, contentEnd);
-					}
-					return pos;
-				} else if (cc === CC_RIGHT_PARENTHESIS) {
-					contentEnd = pos;
-					pos++;
-					if (callbacks.url !== undefined) {
-						return callbacks.url(input, start, pos, contentStart, contentEnd);
-					}
-					return pos;
-				} else if (cc === CC_LEFT_PARENTHESIS) {
-					return pos;
-				} else {
-					pos++;
-				}
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-			}
-		}
-	} else {
-		if (callbacks.identifier !== undefined) {
-			return callbacks.identifier(input, start, pos);
-		}
-		return pos;
-	}
-};
 
-/** @type {CharHandler} */
-const consumePotentialPseudo = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
-		return pos;
-	pos = _consumeIdentifier(input, pos);
-	let cc = input.charCodeAt(pos);
-	if (cc === CC_LEFT_PARENTHESIS) {
-		pos++;
-		if (callbacks.pseudoFunction !== undefined) {
-			return callbacks.pseudoFunction(input, start, pos);
-		}
-		return pos;
-	}
-	if (callbacks.pseudoClass !== undefined) {
-		return callbacks.pseudoClass(input, start, pos);
-	}
-	return pos;
-};
+/***/ }),
 
-/** @type {CharHandler} */
-const consumeLeftParenthesis = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.leftParenthesis !== undefined) {
-		return callbacks.leftParenthesis(input, pos - 1, pos);
-	}
-	return pos;
-};
+/***/ 38873:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/** @type {CharHandler} */
-const consumeRightParenthesis = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.rightParenthesis !== undefined) {
-		return callbacks.rightParenthesis(input, pos - 1, pos);
-	}
-	return pos;
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/** @type {CharHandler} */
-const consumeLeftCurlyBracket = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.leftCurlyBracket !== undefined) {
-		return callbacks.leftCurlyBracket(input, pos - 1, pos);
-	}
-	return pos;
-};
 
-/** @type {CharHandler} */
-const consumeRightCurlyBracket = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.rightCurlyBracket !== undefined) {
-		return callbacks.rightCurlyBracket(input, pos - 1, pos);
-	}
-	return pos;
-};
 
-/** @type {CharHandler} */
-const consumeSemicolon = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.semicolon !== undefined) {
-		return callbacks.semicolon(input, pos - 1, pos);
-	}
-	return pos;
-};
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-/** @type {CharHandler} */
-const consumeComma = (input, pos, callbacks) => {
-	pos++;
-	if (callbacks.comma !== undefined) {
-		return callbacks.comma(input, pos - 1, pos);
-	}
-	return pos;
-};
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-const _consumeIdentifier = (input, pos) => {
-	for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_BACK_SLASH) {
-			pos++;
-			if (pos === input.length) return pos;
-			pos++;
-		} else if (
-			_isIdentifierStartCode(cc) ||
-			_isDigit(cc) ||
-			cc === CC_HYPHEN_MINUS
-		) {
-			pos++;
-		} else {
-			return pos;
-		}
+class HarmonyExportHeaderDependency extends NullDependency {
+	constructor(range, rangeStatement) {
+		super();
+		this.range = range;
+		this.rangeStatement = rangeStatement;
 	}
-};
 
-const _consumeNumber = (input, pos) => {
-	pos++;
-	if (pos === input.length) return pos;
-	let cc = input.charCodeAt(pos);
-	while (_isDigit(cc)) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
-	}
-	if (cc === CC_FULL_STOP && pos + 1 !== input.length) {
-		const next = input.charCodeAt(pos + 1);
-		if (_isDigit(next)) {
-			pos += 2;
-			cc = input.charCodeAt(pos);
-			while (_isDigit(cc)) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-			}
-		}
-	}
-	if (cc === CC_LOWER_E || cc === CC_UPPER_E) {
-		if (pos + 1 !== input.length) {
-			const next = input.charCodeAt(pos + 2);
-			if (_isDigit(next)) {
-				pos += 2;
-			} else if (
-				(next === CC_HYPHEN_MINUS || next === CC_PLUS_SIGN) &&
-				pos + 2 !== input.length
-			) {
-				const next = input.charCodeAt(pos + 2);
-				if (_isDigit(next)) {
-					pos += 3;
-				} else {
-					return pos;
-				}
-			} else {
-				return pos;
-			}
-		}
-	} else {
-		return pos;
-	}
-	cc = input.charCodeAt(pos);
-	while (_isDigit(cc)) {
-		pos++;
-		if (pos === input.length) return pos;
-		cc = input.charCodeAt(pos);
+	get type() {
+		return "harmony export header";
 	}
-	return pos;
-};
-
-/** @type {CharHandler} */
-const consumeLessThan = (input, pos, callbacks) => {
-	if (input.slice(pos + 1, pos + 4) === "!--") return pos + 4;
-	return pos + 1;
-};
 
-/** @type {CharHandler} */
-const consumeAt = (input, pos, callbacks) => {
-	const start = pos;
-	pos++;
-	if (pos === input.length) return pos;
-	if (_startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
-		if (callbacks.atKeyword !== undefined) {
-			pos = callbacks.atKeyword(input, start, pos);
-		}
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		write(this.rangeStatement);
+		super.serialize(context);
 	}
-	return pos;
-};
 
-const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
-	// https://drafts.csswg.org/css-syntax/#consume-token
-	switch (cc) {
-		case CC_LINE_FEED:
-		case CC_CARRIAGE_RETURN:
-		case CC_FORM_FEED:
-		case CC_TAB:
-		case CC_SPACE:
-			return consumeSpace;
-		case CC_QUOTATION_MARK:
-		case CC_APOSTROPHE:
-			return consumeString(cc);
-		case CC_NUMBER_SIGN:
-			return consumeNumberSign;
-		case CC_SLASH:
-			return consumePotentialComment;
-		// case CC_LEFT_SQUARE:
-		// case CC_RIGHT_SQUARE:
-		// case CC_COMMA:
-		// case CC_COLON:
-		// 	return consumeSingleCharToken;
-		case CC_COMMA:
-			return consumeComma;
-		case CC_SEMICOLON:
-			return consumeSemicolon;
-		case CC_LEFT_PARENTHESIS:
-			return consumeLeftParenthesis;
-		case CC_RIGHT_PARENTHESIS:
-			return consumeRightParenthesis;
-		case CC_LEFT_CURLY:
-			return consumeLeftCurlyBracket;
-		case CC_RIGHT_CURLY:
-			return consumeRightCurlyBracket;
-		case CC_COLON:
-			return consumePotentialPseudo;
-		case CC_PLUS_SIGN:
-			return consumeNumericToken;
-		case CC_FULL_STOP:
-			return consumeDot;
-		case CC_HYPHEN_MINUS:
-			return consumeMinus;
-		case CC_LESS_THAN_SIGN:
-			return consumeLessThan;
-		case CC_AT_SIGN:
-			return consumeAt;
-		case CC_LOWER_U:
-			return consumePotentialUrl;
-		case CC_LOW_LINE:
-			return consumeOtherIdentifier;
-		default:
-			if (_isDigit(cc)) return consumeNumericToken;
-			if (
-				(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
-				(cc >= CC_UPPER_A && cc <= CC_UPPER_Z)
-			) {
-				return consumeOtherIdentifier;
-			}
-			return consumeSingleCharToken;
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		this.rangeStatement = read();
+		super.deserialize(context);
 	}
-});
+}
 
-/**
- * @param {string} input input css
- * @param {CssTokenCallbacks} callbacks callbacks
- * @returns {void}
- */
-module.exports = (input, callbacks) => {
-	let pos = 0;
-	while (pos < input.length) {
-		const cc = input.charCodeAt(pos);
-		if (cc < 0x80) {
-			pos = CHAR_MAP[cc](input, pos, callbacks);
-		} else {
-			pos++;
-		}
-	}
-};
+makeSerializable(
+	HarmonyExportHeaderDependency,
+	"webpack/lib/dependencies/HarmonyExportHeaderDependency"
+);
 
-module.exports.eatComments = (input, pos) => {
-	loop: for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
-			if (pos === input.length) return pos;
-			let cc = input.charCodeAt(pos + 1);
-			if (cc !== CC_ASTERISK) return pos;
-			pos++;
-			for (;;) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-				while (cc === CC_ASTERISK) {
-					pos++;
-					if (pos === input.length) return pos;
-					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
-						pos++;
-						continue loop;
-					}
-				}
-			}
-		}
-		return pos;
+HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyExportHeaderDependency} */ (dependency);
+		const content = "";
+		const replaceUntil = dep.range
+			? dep.range[0] - 1
+			: dep.rangeStatement[1] - 1;
+		source.replace(dep.rangeStatement[0], replaceUntil, content);
 	}
 };
 
-module.exports.eatWhitespaceAndComments = (input, pos) => {
-	loop: for (;;) {
-		const cc = input.charCodeAt(pos);
-		if (cc === CC_SLASH) {
-			if (pos === input.length) return pos;
-			let cc = input.charCodeAt(pos + 1);
-			if (cc !== CC_ASTERISK) return pos;
-			pos++;
-			for (;;) {
-				pos++;
-				if (pos === input.length) return pos;
-				cc = input.charCodeAt(pos);
-				while (cc === CC_ASTERISK) {
-					pos++;
-					if (pos === input.length) return pos;
-					cc = input.charCodeAt(pos);
-					if (cc === CC_SLASH) {
-						pos++;
-						continue loop;
-					}
-				}
-			}
-		} else if (_isWhiteSpace(cc)) {
-			pos++;
-			continue;
-		}
-		return pos;
-	}
-};
+module.exports = HarmonyExportHeaderDependency;
 
 
 /***/ }),
 
-/***/ 2757:
+/***/ 67157:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { Tracer } = __webpack_require__(5787);
-const createSchemaValidation = __webpack_require__(32540);
-const { dirname, mkdirpSync } = __webpack_require__(17139);
+const Dependency = __webpack_require__(54912);
+const { UsageState } = __webpack_require__(63686);
+const HarmonyLinkingError = __webpack_require__(97511);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const { countIterable } = __webpack_require__(39104);
+const { first, combine } = __webpack_require__(93347);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const { getRuntimeKey, keyToRuntime } = __webpack_require__(17156);
+const HarmonyExportInitFragment = __webpack_require__(89500);
+const HarmonyImportDependency = __webpack_require__(57154);
+const processExportInfo = __webpack_require__(55207);
 
-/** @typedef {import("../../declarations/plugins/debug/ProfilingPlugin").ProfilingPluginOptions} ProfilingPluginOptions */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const validate = createSchemaValidation(
-	__webpack_require__(37134),
-	() => __webpack_require__(50686),
-	{
-		name: "Profiling Plugin",
-		baseDataPath: "options"
-	}
-);
-let inspector = undefined;
+/** @typedef {"missing"|"unused"|"empty-star"|"reexport-dynamic-default"|"reexport-named-default"|"reexport-namespace-object"|"reexport-fake-namespace-object"|"reexport-undefined"|"normal-reexport"|"dynamic-reexport"} ExportModeType */
 
-try {
-	// eslint-disable-next-line node/no-unsupported-features/node-builtins
-	inspector = __webpack_require__(31405);
-} catch (e) {
-	console.log("Unable to CPU profile in < node 8.0");
-}
+const { ExportPresenceModes } = HarmonyImportDependency;
 
-class Profiler {
-	constructor(inspector) {
-		this.session = undefined;
-		this.inspector = inspector;
-		this._startTime = 0;
-	}
+const idsSymbol = Symbol("HarmonyExportImportedSpecifierDependency.ids");
 
-	hasSession() {
-		return this.session !== undefined;
+class NormalReexportItem {
+	/**
+	 * @param {string} name export name
+	 * @param {string[]} ids reexported ids from other module
+	 * @param {ExportInfo} exportInfo export info from other module
+	 * @param {boolean} checked true, if it should be checked at runtime if this export exists
+	 * @param {boolean} hidden true, if it is hidden behind another active export in the same module
+	 */
+	constructor(name, ids, exportInfo, checked, hidden) {
+		this.name = name;
+		this.ids = ids;
+		this.exportInfo = exportInfo;
+		this.checked = checked;
+		this.hidden = hidden;
 	}
+}
 
-	startProfiling() {
-		if (this.inspector === undefined) {
-			return Promise.resolve();
-		}
-
-		try {
-			this.session = new inspector.Session();
-			this.session.connect();
-		} catch (_) {
-			this.session = undefined;
-			return Promise.resolve();
-		}
+class ExportMode {
+	/**
+	 * @param {ExportModeType} type type of the mode
+	 */
+	constructor(type) {
+		/** @type {ExportModeType} */
+		this.type = type;
 
-		const hrtime = process.hrtime();
-		this._startTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+		// for "normal-reexport":
+		/** @type {NormalReexportItem[] | null} */
+		this.items = null;
 
-		return Promise.all([
-			this.sendCommand("Profiler.setSamplingInterval", {
-				interval: 100
-			}),
-			this.sendCommand("Profiler.enable"),
-			this.sendCommand("Profiler.start")
-		]);
-	}
+		// for "reexport-named-default" | "reexport-fake-namespace-object" | "reexport-namespace-object"
+		/** @type {string|null} */
+		this.name = null;
+		/** @type {ExportInfo | null} */
+		this.partialNamespaceExportInfo = null;
 
-	sendCommand(method, params) {
-		if (this.hasSession()) {
-			return new Promise((res, rej) => {
-				return this.session.post(method, params, (err, params) => {
-					if (err !== null) {
-						rej(err);
-					} else {
-						res(params);
-					}
-				});
-			});
-		} else {
-			return Promise.resolve();
-		}
-	}
+		// for "dynamic-reexport":
+		/** @type {Set<string> | null} */
+		this.ignored = null;
 
-	destroy() {
-		if (this.hasSession()) {
-			this.session.disconnect();
-		}
+		// for "dynamic-reexport" | "empty-star":
+		/** @type {Set<string> | null} */
+		this.hidden = null;
 
-		return Promise.resolve();
-	}
+		// for "missing":
+		/** @type {string | null} */
+		this.userRequest = null;
 
-	stopProfiling() {
-		return this.sendCommand("Profiler.stop").then(({ profile }) => {
-			const hrtime = process.hrtime();
-			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
-			if (profile.startTime < this._startTime || profile.endTime > endTime) {
-				// In some cases timestamps mismatch and we need to adjust them
-				// Both process.hrtime and the inspector timestamps claim to be relative
-				// to a unknown point in time. But they do not guarantee that this is the
-				// same point in time.
-				const duration = profile.endTime - profile.startTime;
-				const ownDuration = endTime - this._startTime;
-				const untracked = Math.max(0, ownDuration - duration);
-				profile.startTime = this._startTime + untracked / 2;
-				profile.endTime = endTime - untracked / 2;
-			}
-			return { profile };
-		});
+		// for "reexport-fake-namespace-object":
+		/** @type {number} */
+		this.fakeType = 0;
 	}
 }
 
-/**
- * an object that wraps Tracer and Profiler with a counter
- * @typedef {Object} Trace
- * @property {Tracer} trace instance of Tracer
- * @property {number} counter Counter
- * @property {Profiler} profiler instance of Profiler
- * @property {Function} end the end function
- */
+const determineExportAssignments = (
+	moduleGraph,
+	dependencies,
+	additionalDependency
+) => {
+	const names = new Set();
+	const dependencyIndices = [];
 
-/**
- * @param {IntermediateFileSystem} fs filesystem used for output
- * @param {string} outputPath The location where to write the log.
- * @returns {Trace} The trace object
- */
-const createTrace = (fs, outputPath) => {
-	const trace = new Tracer();
-	const profiler = new Profiler(inspector);
-	if (/\/|\\/.test(outputPath)) {
-		const dirPath = dirname(fs, outputPath);
-		mkdirpSync(fs, dirPath);
+	if (additionalDependency) {
+		dependencies = dependencies.concat(additionalDependency);
 	}
-	const fsStream = fs.createWriteStream(outputPath);
-
-	let counter = 0;
 
-	trace.pipe(fsStream);
-	// These are critical events that need to be inserted so that tools like
-	// chrome dev tools can load the profile.
-	trace.instantEvent({
-		name: "TracingStartedInPage",
-		id: ++counter,
-		cat: ["disabled-by-default-devtools.timeline"],
-		args: {
-			data: {
-				sessionId: "-1",
-				page: "0xfff",
-				frames: [
-					{
-						frame: "0xfff",
-						url: "webpack",
-						name: ""
-					}
-				]
+	for (const dep of dependencies) {
+		const i = dependencyIndices.length;
+		dependencyIndices[i] = names.size;
+		const otherImportedModule = moduleGraph.getModule(dep);
+		if (otherImportedModule) {
+			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
+			for (const exportInfo of exportsInfo.exports) {
+				if (
+					exportInfo.provided === true &&
+					exportInfo.name !== "default" &&
+					!names.has(exportInfo.name)
+				) {
+					names.add(exportInfo.name);
+					dependencyIndices[i] = names.size;
+				}
 			}
 		}
-	});
+	}
+	dependencyIndices.push(names.size);
 
-	trace.instantEvent({
-		name: "TracingStartedInBrowser",
-		id: ++counter,
-		cat: ["disabled-by-default-devtools.timeline"],
-		args: {
-			data: {
-				sessionId: "-1"
-			}
-		}
-	});
+	return { names: Array.from(names), dependencyIndices };
+};
 
-	return {
-		trace,
-		counter,
-		profiler,
-		end: callback => {
-			trace.push("]");
-			// Wait until the write stream finishes.
-			fsStream.on("close", () => {
-				callback();
-			});
-			// Tear down the readable trace stream.
-			trace.push(null);
+const findDependencyForName = (
+	{ names, dependencyIndices },
+	name,
+	dependencies
+) => {
+	const dependenciesIt = dependencies[Symbol.iterator]();
+	const dependencyIndicesIt = dependencyIndices[Symbol.iterator]();
+	let dependenciesItResult = dependenciesIt.next();
+	let dependencyIndicesItResult = dependencyIndicesIt.next();
+	if (dependencyIndicesItResult.done) return;
+	for (let i = 0; i < names.length; i++) {
+		while (i >= dependencyIndicesItResult.value) {
+			dependenciesItResult = dependenciesIt.next();
+			dependencyIndicesItResult = dependencyIndicesIt.next();
+			if (dependencyIndicesItResult.done) return;
 		}
-	};
+		if (names[i] === name) return dependenciesItResult.value;
+	}
+	return undefined;
 };
 
-const pluginName = "ProfilingPlugin";
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {HarmonyExportImportedSpecifierDependency} dep the dependency
+ * @param {string} runtimeKey the runtime key
+ * @returns {ExportMode} the export mode
+ */
+const getMode = (moduleGraph, dep, runtimeKey) => {
+	const importedModule = moduleGraph.getModule(dep);
 
-class ProfilingPlugin {
-	/**
-	 * @param {ProfilingPluginOptions=} options options object
-	 */
-	constructor(options = {}) {
-		validate(options);
-		this.outputPath = options.outputPath || "events.json";
+	if (!importedModule) {
+		const mode = new ExportMode("missing");
+
+		mode.userRequest = dep.userRequest;
+
+		return mode;
 	}
 
-	apply(compiler) {
-		const tracer = createTrace(
-			compiler.intermediateFileSystem,
-			this.outputPath
-		);
-		tracer.profiler.startProfiling();
+	const name = dep.name;
+	const runtime = keyToRuntime(runtimeKey);
+	const parentModule = moduleGraph.getParentModule(dep);
+	const exportsInfo = moduleGraph.getExportsInfo(parentModule);
 
-		// Compiler Hooks
-		Object.keys(compiler.hooks).forEach(hookName => {
-			const hook = compiler.hooks[hookName];
-			if (hook) {
-				hook.intercept(makeInterceptorFor("Compiler", tracer)(hookName));
-			}
-		});
+	if (
+		name
+			? exportsInfo.getUsed(name, runtime) === UsageState.Unused
+			: exportsInfo.isUsed(runtime) === false
+	) {
+		const mode = new ExportMode("unused");
 
-		Object.keys(compiler.resolverFactory.hooks).forEach(hookName => {
-			const hook = compiler.resolverFactory.hooks[hookName];
-			if (hook) {
-				hook.intercept(makeInterceptorFor("Resolver", tracer)(hookName));
-			}
-		});
+		mode.name = name || "*";
 
-		compiler.hooks.compilation.tap(
-			pluginName,
-			(compilation, { normalModuleFactory, contextModuleFactory }) => {
-				interceptAllHooksFor(compilation, tracer, "Compilation");
-				interceptAllHooksFor(
-					normalModuleFactory,
-					tracer,
-					"Normal Module Factory"
-				);
-				interceptAllHooksFor(
-					contextModuleFactory,
-					tracer,
-					"Context Module Factory"
-				);
-				interceptAllParserHooks(normalModuleFactory, tracer);
-				interceptAllJavascriptModulesPluginHooks(compilation, tracer);
-			}
-		);
+		return mode;
+	}
 
-		// We need to write out the CPU profile when we are all done.
-		compiler.hooks.done.tapAsync(
-			{
-				name: pluginName,
-				stage: Infinity
-			},
-			(stats, callback) => {
-				if (compiler.watchMode) return callback();
-				tracer.profiler.stopProfiling().then(parsedResults => {
-					if (parsedResults === undefined) {
-						tracer.profiler.destroy();
-						tracer.end(callback);
-						return;
-					}
+	const importedExportsType = importedModule.getExportsType(
+		moduleGraph,
+		parentModule.buildMeta.strictHarmonyModule
+	);
 
-					const cpuStartTime = parsedResults.profile.startTime;
-					const cpuEndTime = parsedResults.profile.endTime;
+	const ids = dep.getIds(moduleGraph);
 
-					tracer.trace.completeEvent({
-						name: "TaskQueueManager::ProcessTaskFromWorkQueue",
-						id: ++tracer.counter,
-						cat: ["toplevel"],
-						ts: cpuStartTime,
-						args: {
-							src_file: "../../ipc/ipc_moji_bootstrap.cc",
-							src_func: "Accept"
-						}
-					});
+	// Special handling for reexporting the default export
+	// from non-namespace modules
+	if (name && ids.length > 0 && ids[0] === "default") {
+		switch (importedExportsType) {
+			case "dynamic": {
+				const mode = new ExportMode("reexport-dynamic-default");
 
-					tracer.trace.completeEvent({
-						name: "EvaluateScript",
-						id: ++tracer.counter,
-						cat: ["devtools.timeline"],
-						ts: cpuStartTime,
-						dur: cpuEndTime - cpuStartTime,
-						args: {
-							data: {
-								url: "webpack",
-								lineNumber: 1,
-								columnNumber: 1,
-								frame: "0xFFF"
-							}
-						}
-					});
+				mode.name = name;
 
-					tracer.trace.instantEvent({
-						name: "CpuProfile",
-						id: ++tracer.counter,
-						cat: ["disabled-by-default-devtools.timeline"],
-						ts: cpuEndTime,
-						args: {
-							data: {
-								cpuProfile: parsedResults.profile
-							}
-						}
-					});
+				return mode;
+			}
+			case "default-only":
+			case "default-with-named": {
+				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+				const mode = new ExportMode("reexport-named-default");
 
-					tracer.profiler.destroy();
-					tracer.end(callback);
-				});
+				mode.name = name;
+				mode.partialNamespaceExportInfo = exportInfo;
+
+				return mode;
 			}
-		);
+		}
 	}
-}
 
-const interceptAllHooksFor = (instance, tracer, logLabel) => {
-	if (Reflect.has(instance, "hooks")) {
-		Object.keys(instance.hooks).forEach(hookName => {
-			const hook = instance.hooks[hookName];
-			if (hook && !hook._fakeHook) {
-				hook.intercept(makeInterceptorFor(logLabel, tracer)(hookName));
+	// reexporting with a fixed name
+	if (name) {
+		let mode;
+		const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+
+		if (ids.length > 0) {
+			// export { name as name }
+			switch (importedExportsType) {
+				case "default-only":
+					mode = new ExportMode("reexport-undefined");
+					mode.name = name;
+					break;
+				default:
+					mode = new ExportMode("normal-reexport");
+					mode.items = [
+						new NormalReexportItem(name, ids, exportInfo, false, false)
+					];
+					break;
 			}
-		});
-	}
-};
+		} else {
+			// export * as name
+			switch (importedExportsType) {
+				case "default-only":
+					mode = new ExportMode("reexport-fake-namespace-object");
+					mode.name = name;
+					mode.partialNamespaceExportInfo = exportInfo;
+					mode.fakeType = 0;
+					break;
+				case "default-with-named":
+					mode = new ExportMode("reexport-fake-namespace-object");
+					mode.name = name;
+					mode.partialNamespaceExportInfo = exportInfo;
+					mode.fakeType = 2;
+					break;
+				case "dynamic":
+				default:
+					mode = new ExportMode("reexport-namespace-object");
+					mode.name = name;
+					mode.partialNamespaceExportInfo = exportInfo;
+			}
+		}
 
-const interceptAllParserHooks = (moduleFactory, tracer) => {
-	const moduleTypes = [
-		"javascript/auto",
-		"javascript/dynamic",
-		"javascript/esm",
-		"json",
-		"webassembly/async",
-		"webassembly/sync"
-	];
+		return mode;
+	}
 
-	moduleTypes.forEach(moduleType => {
-		moduleFactory.hooks.parser
-			.for(moduleType)
-			.tap("ProfilingPlugin", (parser, parserOpts) => {
-				interceptAllHooksFor(parser, tracer, "Parser");
-			});
-	});
-};
+	// Star reexporting
 
-const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
-	interceptAllHooksFor(
-		{
-			hooks:
-				(__webpack_require__(89464).getCompilationHooks)(
-					compilation
-				)
-		},
-		tracer,
-		"JavascriptModulesPlugin"
+	const { ignoredExports, exports, checked, hidden } = dep.getStarReexports(
+		moduleGraph,
+		runtime,
+		exportsInfo,
+		importedModule
 	);
-};
+	if (!exports) {
+		// We have too few info about the modules
+		// Delegate the logic to the runtime code
 
-const makeInterceptorFor = (instance, tracer) => hookName => ({
-	register: ({ name, type, context, fn }) => {
-		const newFn =
-			// Don't tap our own hooks to ensure stream can close cleanly
-			name === pluginName
-				? fn
-				: makeNewProfiledTapFn(hookName, tracer, {
-						name,
-						type,
-						fn
-				  });
-		return {
-			name,
-			type,
-			context,
-			fn: newFn
-		};
+		const mode = new ExportMode("dynamic-reexport");
+		mode.ignored = ignoredExports;
+		mode.hidden = hidden;
+
+		return mode;
 	}
-});
 
-// TODO improve typing
-/** @typedef {(...args: TODO[]) => void | Promise<TODO>} PluginFunction */
+	if (exports.size === 0) {
+		const mode = new ExportMode("empty-star");
+		mode.hidden = hidden;
 
-/**
- * @param {string} hookName Name of the hook to profile.
- * @param {Trace} tracer The trace object.
- * @param {object} options Options for the profiled fn.
- * @param {string} options.name Plugin name
- * @param {string} options.type Plugin type (sync | async | promise)
- * @param {PluginFunction} options.fn Plugin function
- * @returns {PluginFunction} Chainable hooked function.
- */
-const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
-	const defaultCategory = ["blink.user_timing"];
+		return mode;
+	}
 
-	switch (type) {
-		case "promise":
-			return (...args) => {
-				const id = ++tracer.counter;
-				tracer.trace.begin({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				const promise = /** @type {Promise<*>} */ (fn(...args));
-				return promise.then(r => {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					return r;
-				});
-			};
-		case "async":
-			return (...args) => {
-				const id = ++tracer.counter;
-				tracer.trace.begin({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				const callback = args.pop();
-				fn(...args, (...r) => {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					callback(...r);
-				});
-			};
-		case "sync":
-			return (...args) => {
-				const id = ++tracer.counter;
-				// Do not instrument ourself due to the CPU
-				// profile needing to be the last event in the trace.
-				if (name === pluginName) {
-					return fn(...args);
-				}
+	const mode = new ExportMode("normal-reexport");
 
-				tracer.trace.begin({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				let r;
-				try {
-					r = fn(...args);
-				} catch (error) {
-					tracer.trace.end({
-						name,
-						id,
-						cat: defaultCategory
-					});
-					throw error;
-				}
-				tracer.trace.end({
-					name,
-					id,
-					cat: defaultCategory
-				});
-				return r;
-			};
-		default:
-			break;
+	mode.items = Array.from(
+		exports,
+		exportName =>
+			new NormalReexportItem(
+				exportName,
+				[exportName],
+				exportsInfo.getReadOnlyExportInfo(exportName),
+				checked.has(exportName),
+				false
+			)
+	);
+	if (hidden !== undefined) {
+		for (const exportName of hidden) {
+			mode.items.push(
+				new NormalReexportItem(
+					exportName,
+					[exportName],
+					exportsInfo.getReadOnlyExportInfo(exportName),
+					false,
+					true
+				)
+			);
+		}
 	}
-};
-
-module.exports = ProfilingPlugin;
-module.exports.Profiler = Profiler;
-
-
-/***/ }),
-
-/***/ 96816:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	return mode;
+};
 
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {number} sourceOrder the order in the original source file
+	 * @param {string[]} ids the requested export name of the imported module
+	 * @param {string | null} name the export name of for this module
+	 * @param {Set<string>} activeExports other named exports in the module
+	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module before this import
+	 * @param {number} exportPresenceMode mode of checking export names
+	 * @param {HarmonyStarExportsList} allStarExports all star exports in the module
+	 * @param {Record<string, any>=} assertions import assertions
+	 */
+	constructor(
+		request,
+		sourceOrder,
+		ids,
+		name,
+		activeExports,
+		otherStarExports,
+		exportPresenceMode,
+		allStarExports,
+		assertions
+	) {
+		super(request, sourceOrder, assertions);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+		this.ids = ids;
+		this.name = name;
+		this.activeExports = activeExports;
+		this.otherStarExports = otherStarExports;
+		this.exportPresenceMode = exportPresenceMode;
+		this.allStarExports = allStarExports;
+	}
 
-/** @type {Record<string, { definition: string, content: string, requests: string[] }>} */
-const DEFINITIONS = {
-	f: {
-		definition: "var __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_RESULT__ = (#).call(exports, __webpack_require__, exports, module),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [
-			RuntimeGlobals.require,
-			RuntimeGlobals.exports,
-			RuntimeGlobals.module
-		]
-	},
-	o: {
-		definition: "",
-		content: "!(module.exports = #)",
-		requests: [RuntimeGlobals.module]
-	},
-	of: {
-		definition:
-			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_FACTORY__ = (#),
-		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-		(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
-		__WEBPACK_AMD_DEFINE_FACTORY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [
-			RuntimeGlobals.require,
-			RuntimeGlobals.exports,
-			RuntimeGlobals.module
-		]
-	},
-	af: {
-		definition:
-			"var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_RESULT__ = (#).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
-	},
-	ao: {
-		definition: "",
-		content: "!(#, module.exports = #)",
-		requests: [RuntimeGlobals.module]
-	},
-	aof: {
-		definition:
-			"var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;",
-		content: `!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, __WEBPACK_AMD_DEFINE_FACTORY__ = (#),
-		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
-		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))`,
-		requests: [RuntimeGlobals.exports, RuntimeGlobals.module]
-	},
-	lf: {
-		definition: "var XXX, XXXmodule;",
-		content:
-			"!(XXXmodule = { id: YYY, exports: {}, loaded: false }, XXX = (#).call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule), XXXmodule.loaded = true, XXX === undefined && (XXX = XXXmodule.exports))",
-		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
-	},
-	lo: {
-		definition: "var XXX;",
-		content: "!(XXX = #)",
-		requests: []
-	},
-	lof: {
-		definition: "var XXX, XXXfactory, XXXmodule;",
-		content:
-			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))",
-		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
-	},
-	laf: {
-		definition: "var __WEBPACK_AMD_DEFINE_ARRAY__, XXX, XXXexports;",
-		content:
-			"!(__WEBPACK_AMD_DEFINE_ARRAY__ = #, XXX = (#).apply(XXXexports = {}, __WEBPACK_AMD_DEFINE_ARRAY__), XXX === undefined && (XXX = XXXexports))",
-		requests: []
-	},
-	lao: {
-		definition: "var XXX;",
-		content: "!(#, XXX = #)",
-		requests: []
-	},
-	laof: {
-		definition: "var XXXarray, XXXfactory, XXXexports, XXX;",
-		content: `!(XXXarray = #, XXXfactory = (#),
-		(typeof XXXfactory === 'function' ?
-			((XXX = XXXfactory.apply(XXXexports = {}, XXXarray)), XXX === undefined && (XXX = XXXexports)) :
-			(XXX = XXXfactory)
-		))`,
-		requests: []
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
 	}
-};
 
-class AMDDefineDependency extends NullDependency {
-	constructor(range, arrayRange, functionRange, objectRange, namedModule) {
-		super();
-		this.range = range;
-		this.arrayRange = arrayRange;
-		this.functionRange = functionRange;
-		this.objectRange = objectRange;
-		this.namedModule = namedModule;
-		this.localModule = null;
+	// TODO webpack 6 remove
+	get id() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	get type() {
-		return "amd define";
+	// TODO webpack 6 remove
+	getId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.arrayRange);
-		write(this.functionRange);
-		write(this.objectRange);
-		write(this.namedModule);
-		write(this.localModule);
-		super.serialize(context);
+	// TODO webpack 6 remove
+	setId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.arrayRange = read();
-		this.functionRange = read();
-		this.objectRange = read();
-		this.namedModule = read();
-		this.localModule = read();
-		super.deserialize(context);
+	get type() {
+		return "harmony export imported specifier";
 	}
-}
 
-makeSerializable(
-	AMDDefineDependency,
-	"webpack/lib/dependencies/AMDDefineDependency"
-);
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported id
+	 */
+	getIds(moduleGraph) {
+		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	}
 
-AMDDefineDependency.Template = class AMDDefineDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
 	 * @returns {void}
 	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {AMDDefineDependency} */ (dependency);
-		const branch = this.branch(dep);
-		const { definition, content, requests } = DEFINITIONS[branch];
-		for (const req of requests) {
-			runtimeRequirements.add(req);
-		}
-		this.replace(dep, source, definition, content);
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
 	}
 
-	localModuleVar(dependency) {
-		return (
-			dependency.localModule &&
-			dependency.localModule.used &&
-			dependency.localModule.variableName()
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {ExportMode} the export mode
+	 */
+	getMode(moduleGraph, runtime) {
+		return moduleGraph.dependencyCacheProvide(
+			this,
+			getRuntimeKey(runtime),
+			getMode
 		);
 	}
 
-	branch(dependency) {
-		const localModuleVar = this.localModuleVar(dependency) ? "l" : "";
-		const arrayRange = dependency.arrayRange ? "a" : "";
-		const objectRange = dependency.objectRange ? "o" : "";
-		const functionRange = dependency.functionRange ? "f" : "";
-		return localModuleVar + arrayRange + objectRange + functionRange;
-	}
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {ExportsInfo} exportsInfo exports info about the current module (optional)
+	 * @param {Module} importedModule the imported module (optional)
+	 * @returns {{exports?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden?: Set<string>}} information
+	 */
+	getStarReexports(
+		moduleGraph,
+		runtime,
+		exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this)),
+		importedModule = moduleGraph.getModule(this)
+	) {
+		const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
 
-	replace(dependency, source, definition, text) {
-		const localModuleVar = this.localModuleVar(dependency);
-		if (localModuleVar) {
-			text = text.replace(/XXX/g, localModuleVar.replace(/\$/g, "$$$$"));
-			definition = definition.replace(
-				/XXX/g,
-				localModuleVar.replace(/\$/g, "$$$$")
-			);
-		}
+		const noExtraExports =
+			importedExportsInfo.otherExportsInfo.provided === false;
+		const noExtraImports =
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
 
-		if (dependency.namedModule) {
-			text = text.replace(/YYY/g, JSON.stringify(dependency.namedModule));
+		const ignoredExports = new Set(["default", ...this.activeExports]);
+
+		let hiddenExports = undefined;
+		const otherStarExports =
+			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
+		if (otherStarExports !== undefined) {
+			hiddenExports = new Set();
+			for (let i = 0; i < otherStarExports.namesSlice; i++) {
+				hiddenExports.add(otherStarExports.names[i]);
+			}
+			for (const e of ignoredExports) hiddenExports.delete(e);
 		}
 
-		const texts = text.split("#");
+		if (!noExtraExports && !noExtraImports) {
+			return {
+				ignoredExports,
+				hidden: hiddenExports
+			};
+		}
 
-		if (definition) source.insert(0, definition);
+		/** @type {Set<string>} */
+		const exports = new Set();
+		/** @type {Set<string>} */
+		const checked = new Set();
+		/** @type {Set<string>} */
+		const hidden = hiddenExports !== undefined ? new Set() : undefined;
 
-		let current = dependency.range[0];
-		if (dependency.arrayRange) {
-			source.replace(current, dependency.arrayRange[0] - 1, texts.shift());
-			current = dependency.arrayRange[1];
+		if (noExtraImports) {
+			for (const exportInfo of exportsInfo.orderedExports) {
+				const name = exportInfo.name;
+				if (ignoredExports.has(name)) continue;
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				const importedExportInfo =
+					importedExportsInfo.getReadOnlyExportInfo(name);
+				if (importedExportInfo.provided === false) continue;
+				if (hiddenExports !== undefined && hiddenExports.has(name)) {
+					hidden.add(name);
+					continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
+			}
+		} else if (noExtraExports) {
+			for (const importedExportInfo of importedExportsInfo.orderedExports) {
+				const name = importedExportInfo.name;
+				if (ignoredExports.has(name)) continue;
+				if (importedExportInfo.provided === false) continue;
+				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
+				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+				if (hiddenExports !== undefined && hiddenExports.has(name)) {
+					hidden.add(name);
+					continue;
+				}
+				exports.add(name);
+				if (importedExportInfo.provided === true) continue;
+				checked.add(name);
+			}
 		}
 
-		if (dependency.objectRange) {
-			source.replace(current, dependency.objectRange[0] - 1, texts.shift());
-			current = dependency.objectRange[1];
-		} else if (dependency.functionRange) {
-			source.replace(current, dependency.functionRange[0] - 1, texts.shift());
-			current = dependency.functionRange[1];
-		}
-		source.replace(current, dependency.range[1] - 1, texts.shift());
-		if (texts.length > 0) throw new Error("Implementation error");
+		return { ignoredExports, exports, checked, hidden };
 	}
-};
 
-module.exports = AMDDefineDependency;
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return (connection, runtime) => {
+			const mode = this.getMode(moduleGraph, runtime);
+			return mode.type !== "unused" && mode.type !== "empty-star";
+		};
+	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
+	}
 
-/***/ }),
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		const mode = this.getMode(moduleGraph, runtime);
 
-/***/ 48519:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		switch (mode.type) {
+			case "missing":
+			case "unused":
+			case "empty-star":
+			case "reexport-undefined":
+				return Dependency.NO_EXPORTS_REFERENCED;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			case "reexport-dynamic-default":
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
 
+			case "reexport-named-default": {
+				if (!mode.partialNamespaceExportInfo)
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				/** @type {string[][]} */
+				const referencedExports = [];
+				processExportInfo(
+					runtime,
+					referencedExports,
+					[],
+					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo)
+				);
+				return referencedExports;
+			}
 
+			case "reexport-namespace-object":
+			case "reexport-fake-namespace-object": {
+				if (!mode.partialNamespaceExportInfo)
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				/** @type {string[][]} */
+				const referencedExports = [];
+				processExportInfo(
+					runtime,
+					referencedExports,
+					[],
+					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo),
+					mode.type === "reexport-fake-namespace-object"
+				);
+				return referencedExports;
+			}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const AMDDefineDependency = __webpack_require__(96816);
-const AMDRequireArrayDependency = __webpack_require__(33516);
-const AMDRequireContextDependency = __webpack_require__(96123);
-const AMDRequireItemDependency = __webpack_require__(71806);
-const ConstDependency = __webpack_require__(76911);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const DynamicExports = __webpack_require__(32006);
-const LocalModuleDependency = __webpack_require__(52805);
-const { addLocalModule, getLocalModule } = __webpack_require__(75827);
+			case "dynamic-reexport":
+				return Dependency.EXPORTS_OBJECT_REFERENCED;
 
-const isBoundFunctionExpression = expr => {
-	if (expr.type !== "CallExpression") return false;
-	if (expr.callee.type !== "MemberExpression") return false;
-	if (expr.callee.computed) return false;
-	if (expr.callee.object.type !== "FunctionExpression") return false;
-	if (expr.callee.property.type !== "Identifier") return false;
-	if (expr.callee.property.name !== "bind") return false;
-	return true;
-};
+			case "normal-reexport": {
+				const referencedExports = [];
+				for (const { ids, exportInfo, hidden } of mode.items) {
+					if (hidden) continue;
+					processExportInfo(runtime, referencedExports, ids, exportInfo, false);
+				}
+				return referencedExports;
+			}
 
-const isUnboundFunctionExpression = expr => {
-	if (expr.type === "FunctionExpression") return true;
-	if (expr.type === "ArrowFunctionExpression") return true;
-	return false;
-};
+			default:
+				throw new Error(`Unknown mode ${mode.type}`);
+		}
+	}
 
-const isCallable = expr => {
-	if (isUnboundFunctionExpression(expr)) return true;
-	if (isBoundFunctionExpression(expr)) return true;
-	return false;
-};
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {{ names: string[], namesSlice: number, dependencyIndices: number[], dependencyIndex: number } | undefined} exported names and their origin dependency
+	 */
+	_discoverActiveExportsFromOtherStarExports(moduleGraph) {
+		if (!this.otherStarExports) return undefined;
 
-class AMDDefineDependencyParserPlugin {
-	constructor(options) {
-		this.options = options;
-	}
+		const i =
+			"length" in this.otherStarExports
+				? this.otherStarExports.length
+				: countIterable(this.otherStarExports);
+		if (i === 0) return undefined;
 
-	apply(parser) {
-		parser.hooks.call
-			.for("define")
-			.tap(
-				"AMDDefineDependencyParserPlugin",
-				this.processCallDefine.bind(this, parser)
+		if (this.allStarExports) {
+			const { names, dependencyIndices } = moduleGraph.cached(
+				determineExportAssignments,
+				this.allStarExports.dependencies
 			);
-	}
 
-	processArray(parser, expr, param, identifiers, namedModule) {
-		if (param.isArray()) {
-			param.items.forEach((param, idx) => {
-				if (
-					param.isString() &&
-					["require", "module", "exports"].includes(param.string)
-				)
-					identifiers[idx] = param.string;
-				const result = this.processItem(parser, expr, param, namedModule);
-				if (result === undefined) {
-					this.processContext(parser, expr, param);
-				}
-			});
-			return true;
-		} else if (param.isConstArray()) {
-			const deps = [];
-			param.array.forEach((request, idx) => {
-				let dep;
-				let localModule;
-				if (request === "require") {
-					identifiers[idx] = request;
-					dep = "__webpack_require__";
-				} else if (["exports", "module"].includes(request)) {
-					identifiers[idx] = request;
-					dep = request;
-				} else if ((localModule = getLocalModule(parser.state, request))) {
-					localModule.flagUsed();
-					dep = new LocalModuleDependency(localModule, undefined, false);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-				} else {
-					dep = this.newRequireItemDependency(request);
-					dep.loc = expr.loc;
-					dep.optional = !!parser.scope.inTry;
-					parser.state.current.addDependency(dep);
-				}
-				deps.push(dep);
-			});
-			const dep = this.newRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		}
-	}
-	processItem(parser, expr, param, namedModule) {
-		if (param.isConditional()) {
-			param.options.forEach(param => {
-				const result = this.processItem(parser, expr, param);
-				if (result === undefined) {
-					this.processContext(parser, expr, param);
-				}
-			});
-			return true;
-		} else if (param.isString()) {
-			let dep, localModule;
-			if (param.string === "require") {
-				dep = new ConstDependency("__webpack_require__", param.range, [
-					RuntimeGlobals.require
-				]);
-			} else if (param.string === "exports") {
-				dep = new ConstDependency("exports", param.range, [
-					RuntimeGlobals.exports
-				]);
-			} else if (param.string === "module") {
-				dep = new ConstDependency("module", param.range, [
-					RuntimeGlobals.module
-				]);
-			} else if (
-				(localModule = getLocalModule(parser.state, param.string, namedModule))
-			) {
-				localModule.flagUsed();
-				dep = new LocalModuleDependency(localModule, param.range, false);
-			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
+			return {
+				names,
+				namesSlice: dependencyIndices[i - 1],
+				dependencyIndices,
+				dependencyIndex: i
+			};
 		}
-	}
-	processContext(parser, expr, param) {
-		const dep = ContextDependencyHelpers.create(
-			AMDRequireContextDependency,
-			param.range,
-			param,
-			expr,
-			this.options,
-			{
-				category: "amd"
-			},
-			parser
+
+		const { names, dependencyIndices } = moduleGraph.cached(
+			determineExportAssignments,
+			this.otherStarExports,
+			this
 		);
-		if (!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!parser.scope.inTry;
-		parser.state.current.addDependency(dep);
-		return true;
+
+		return {
+			names,
+			namesSlice: dependencyIndices[i - 1],
+			dependencyIndices,
+			dependencyIndex: i
+		};
 	}
 
-	processCallDefine(parser, expr) {
-		let array, fn, obj, namedModule;
-		switch (expr.arguments.length) {
-			case 1:
-				if (isCallable(expr.arguments[0])) {
-					// define(f() {…})
-					fn = expr.arguments[0];
-				} else if (expr.arguments[0].type === "ObjectExpression") {
-					// define({…})
-					obj = expr.arguments[0];
-				} else {
-					// define(expr)
-					// unclear if function or object
-					obj = fn = expr.arguments[0];
-				}
-				break;
-			case 2:
-				if (expr.arguments[0].type === "Literal") {
-					namedModule = expr.arguments[0].value;
-					// define("…", …)
-					if (isCallable(expr.arguments[1])) {
-						// define("…", f() {…})
-						fn = expr.arguments[1];
-					} else if (expr.arguments[1].type === "ObjectExpression") {
-						// define("…", {…})
-						obj = expr.arguments[1];
-					} else {
-						// define("…", expr)
-						// unclear if function or object
-						obj = fn = expr.arguments[1];
-					}
-				} else {
-					array = expr.arguments[0];
-					if (isCallable(expr.arguments[1])) {
-						// define([…], f() {})
-						fn = expr.arguments[1];
-					} else if (expr.arguments[1].type === "ObjectExpression") {
-						// define([…], {…})
-						obj = expr.arguments[1];
-					} else {
-						// define([…], expr)
-						// unclear if function or object
-						obj = fn = expr.arguments[1];
-					}
-				}
-				break;
-			case 3:
-				// define("…", […], f() {…})
-				namedModule = expr.arguments[0].value;
-				array = expr.arguments[1];
-				if (isCallable(expr.arguments[2])) {
-					// define("…", […], f() {})
-					fn = expr.arguments[2];
-				} else if (expr.arguments[2].type === "ObjectExpression") {
-					// define("…", […], {…})
-					obj = expr.arguments[2];
-				} else {
-					// define("…", […], expr)
-					// unclear if function or object
-					obj = fn = expr.arguments[2];
-				}
-				break;
-			default:
-				return;
-		}
-		DynamicExports.bailout(parser.state);
-		let fnParams = null;
-		let fnParamsOffset = 0;
-		if (fn) {
-			if (isUnboundFunctionExpression(fn)) {
-				fnParams = fn.params;
-			} else if (isBoundFunctionExpression(fn)) {
-				fnParams = fn.callee.object.params;
-				fnParamsOffset = fn.arguments.length - 1;
-				if (fnParamsOffset < 0) {
-					fnParamsOffset = 0;
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		const mode = this.getMode(moduleGraph, undefined);
+
+		switch (mode.type) {
+			case "missing":
+				return undefined;
+			case "dynamic-reexport": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: true,
+					from,
+					canMangle: false,
+					excludeExports: mode.hidden
+						? combine(mode.ignored, mode.hidden)
+						: mode.ignored,
+					hideExports: mode.hidden,
+					dependencies: [from.module]
+				};
+			}
+			case "empty-star":
+				return {
+					exports: [],
+					hideExports: mode.hidden,
+					dependencies: [moduleGraph.getModule(this)]
+				};
+			// falls through
+			case "normal-reexport": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: Array.from(mode.items, item => ({
+						name: item.name,
+						from,
+						export: item.ids,
+						hidden: item.hidden
+					})),
+					priority: 1,
+					dependencies: [from.module]
+				};
+			}
+			case "reexport-dynamic-default": {
+				{
+					const from = moduleGraph.getConnection(this);
+					return {
+						exports: [
+							{
+								name: mode.name,
+								from,
+								export: ["default"]
+							}
+						],
+						priority: 1,
+						dependencies: [from.module]
+					};
 				}
 			}
-		}
-		let fnRenames = new Map();
-		if (array) {
-			const identifiers = {};
-			const param = parser.evaluateExpression(array);
-			const result = this.processArray(
-				parser,
-				expr,
-				param,
-				identifiers,
-				namedModule
-			);
-			if (!result) return;
-			if (fnParams) {
-				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
-					if (identifiers[idx]) {
-						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
-						return false;
-					}
-					return true;
-				});
+			case "reexport-undefined":
+				return {
+					exports: [mode.name],
+					dependencies: [moduleGraph.getModule(this)]
+				};
+			case "reexport-fake-namespace-object": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: [
+						{
+							name: mode.name,
+							from,
+							export: null,
+							exports: [
+								{
+									name: "default",
+									canMangle: false,
+									from,
+									export: null
+								}
+							]
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
 			}
-		} else {
-			const identifiers = ["require", "exports", "module"];
-			if (fnParams) {
-				fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
-					if (identifiers[idx]) {
-						fnRenames.set(param.name, parser.getVariableInfo(identifiers[idx]));
-						return false;
-					}
-					return true;
-				});
+			case "reexport-namespace-object": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: [
+						{
+							name: mode.name,
+							from,
+							export: null
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
 			}
-		}
-		let inTry;
-		if (fn && isUnboundFunctionExpression(fn)) {
-			inTry = parser.scope.inTry;
-			parser.inScope(fnParams, () => {
-				for (const [name, varInfo] of fnRenames) {
-					parser.setVariable(name, varInfo);
-				}
-				parser.scope.inTry = inTry;
-				if (fn.body.type === "BlockStatement") {
-					parser.detectMode(fn.body.body);
-					const prev = parser.prevStatement;
-					parser.preWalkStatement(fn.body);
-					parser.prevStatement = prev;
-					parser.walkStatement(fn.body);
-				} else {
-					parser.walkExpression(fn.body);
-				}
-			});
-		} else if (fn && isBoundFunctionExpression(fn)) {
-			inTry = parser.scope.inTry;
-			parser.inScope(
-				fn.callee.object.params.filter(
-					i => !["require", "module", "exports"].includes(i.name)
-				),
-				() => {
-					for (const [name, varInfo] of fnRenames) {
-						parser.setVariable(name, varInfo);
-					}
-					parser.scope.inTry = inTry;
-					if (fn.callee.object.body.type === "BlockStatement") {
-						parser.detectMode(fn.callee.object.body.body);
-						const prev = parser.prevStatement;
-						parser.preWalkStatement(fn.callee.object.body);
-						parser.prevStatement = prev;
-						parser.walkStatement(fn.callee.object.body);
-					} else {
-						parser.walkExpression(fn.callee.object.body);
-					}
-				}
-			);
-			if (fn.arguments) {
-				parser.walkExpressions(fn.arguments);
+			case "reexport-named-default": {
+				const from = moduleGraph.getConnection(this);
+				return {
+					exports: [
+						{
+							name: mode.name,
+							from,
+							export: ["default"]
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
 			}
-		} else if (fn || obj) {
-			parser.walkExpression(fn || obj);
-		}
-
-		const dep = this.newDefineDependency(
-			expr.range,
-			array ? array.range : null,
-			fn ? fn.range : null,
-			obj ? obj.range : null,
-			namedModule ? namedModule : null
-		);
-		dep.loc = expr.loc;
-		if (namedModule) {
-			dep.localModule = addLocalModule(parser.state, namedModule);
+			default:
+				throw new Error(`Unknown mode ${mode.type}`);
 		}
-		parser.state.module.addPresentationalDependency(dep);
-		return true;
 	}
 
-	newDefineDependency(
-		range,
-		arrayRange,
-		functionRange,
-		objectRange,
-		namedModule
-	) {
-		return new AMDDefineDependency(
-			range,
-			arrayRange,
-			functionRange,
-			objectRange,
-			namedModule
-		);
-	}
-	newRequireArrayDependency(depsArray, range) {
-		return new AMDRequireArrayDependency(depsArray, range);
-	}
-	newRequireItemDependency(request, range) {
-		return new AMDRequireItemDependency(request, range);
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {number} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
 	}
-}
-module.exports = AMDDefineDependencyParserPlugin;
-
-
-/***/ }),
-
-/***/ 50067:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const {
-	approve,
-	evaluateToIdentifier,
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
-
-const AMDDefineDependency = __webpack_require__(96816);
-const AMDDefineDependencyParserPlugin = __webpack_require__(48519);
-const AMDRequireArrayDependency = __webpack_require__(33516);
-const AMDRequireContextDependency = __webpack_require__(96123);
-const AMDRequireDependenciesBlockParserPlugin = __webpack_require__(66866);
-const AMDRequireDependency = __webpack_require__(43911);
-const AMDRequireItemDependency = __webpack_require__(71806);
-const {
-	AMDDefineRuntimeModule,
-	AMDOptionsRuntimeModule
-} = __webpack_require__(45242);
-const ConstDependency = __webpack_require__(76911);
-const LocalModuleDependency = __webpack_require__(52805);
-const UnsupportedDependency = __webpack_require__(51669);
-
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../Compiler")} Compiler */
 
-class AMDPlugin {
 	/**
-	 * @param {Record<string, any>} amdOptions the AMD options
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
 	 */
-	constructor(amdOptions) {
-		this.amdOptions = amdOptions;
+	getWarnings(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
 	 */
-	apply(compiler) {
-		const amdOptions = this.amdOptions;
-		compiler.hooks.compilation.tap(
-			"AMDPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					AMDRequireDependency,
-					new AMDRequireDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					AMDRequireItemDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					AMDRequireItemDependency,
-					new AMDRequireItemDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					AMDRequireArrayDependency,
-					new AMDRequireArrayDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					AMDRequireContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					AMDRequireContextDependency,
-					new AMDRequireContextDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					AMDDefineDependency,
-					new AMDDefineDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					UnsupportedDependency,
-					new UnsupportedDependency.Template()
-				);
+	getErrors(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
+			return this._getErrors(moduleGraph);
+		}
+		return null;
+	}
 
-				compilation.dependencyTemplates.set(
-					LocalModuleDependency,
-					new LocalModuleDependency.Template()
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		let errors = this.getLinkingErrors(
+			moduleGraph,
+			ids,
+			`(reexported as '${this.name}')`
+		);
+		if (ids.length === 0 && this.name === null) {
+			const potentialConflicts =
+				this._discoverActiveExportsFromOtherStarExports(moduleGraph);
+			if (potentialConflicts && potentialConflicts.namesSlice > 0) {
+				const ownNames = new Set(
+					potentialConflicts.names.slice(
+						potentialConflicts.namesSlice,
+						potentialConflicts.dependencyIndices[
+							potentialConflicts.dependencyIndex
+						]
+					)
 				);
-
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.amdDefine)
-					.tap("AMDPlugin", (module, set) => {
-						set.add(RuntimeGlobals.require);
-					});
-
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.amdOptions)
-					.tap("AMDPlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.amdDefine)
-					.tap("AMDPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(chunk, new AMDDefineRuntimeModule());
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.amdOptions)
-					.tap("AMDPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new AMDOptionsRuntimeModule(amdOptions)
-						);
-					});
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.amd !== undefined && !parserOptions.amd) return;
-
-					const tapOptionsHooks = (optionExpr, rootName, getMembers) => {
-						parser.hooks.expression
-							.for(optionExpr)
-							.tap(
-								"AMDPlugin",
-								toConstantDependency(parser, RuntimeGlobals.amdOptions, [
-									RuntimeGlobals.amdOptions
-								])
-							);
-						parser.hooks.evaluateIdentifier
-							.for(optionExpr)
-							.tap(
-								"AMDPlugin",
-								evaluateToIdentifier(optionExpr, rootName, getMembers, true)
-							);
-						parser.hooks.evaluateTypeof
-							.for(optionExpr)
-							.tap("AMDPlugin", evaluateToString("object"));
-						parser.hooks.typeof
-							.for(optionExpr)
-							.tap(
-								"AMDPlugin",
-								toConstantDependency(parser, JSON.stringify("object"))
-							);
-					};
-
-					new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
-						parser
-					);
-					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
-
-					tapOptionsHooks("define.amd", "define", () => "amd");
-					tapOptionsHooks("require.amd", "require", () => ["amd"]);
-					tapOptionsHooks(
-						"__webpack_amd_options__",
-						"__webpack_amd_options__",
-						() => []
-					);
-
-					parser.hooks.expression.for("define").tap("AMDPlugin", expr => {
-						const dep = new ConstDependency(
-							RuntimeGlobals.amdDefine,
-							expr.range,
-							[RuntimeGlobals.amdDefine]
+				const importedModule = moduleGraph.getModule(this);
+				if (importedModule) {
+					const exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					const conflicts = new Map();
+					for (const exportInfo of exportsInfo.orderedExports) {
+						if (exportInfo.provided !== true) continue;
+						if (exportInfo.name === "default") continue;
+						if (this.activeExports.has(exportInfo.name)) continue;
+						if (ownNames.has(exportInfo.name)) continue;
+						const conflictingDependency = findDependencyForName(
+							potentialConflicts,
+							exportInfo.name,
+							this.allStarExports
+								? this.allStarExports.dependencies
+								: [...this.otherStarExports, this]
 						);
-						dep.loc = expr.loc;
-						parser.state.module.addPresentationalDependency(dep);
-						return true;
-					});
-					parser.hooks.typeof
-						.for("define")
-						.tap(
-							"AMDPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
+						if (!conflictingDependency) continue;
+						const target = exportInfo.getTerminalBinding(moduleGraph);
+						if (!target) continue;
+						const conflictingModule = moduleGraph.getModule(
+							conflictingDependency
 						);
-					parser.hooks.evaluateTypeof
-						.for("define")
-						.tap("AMDPlugin", evaluateToString("function"));
-					parser.hooks.canRename.for("define").tap("AMDPlugin", approve);
-					parser.hooks.rename.for("define").tap("AMDPlugin", expr => {
-						const dep = new ConstDependency(
-							RuntimeGlobals.amdDefine,
-							expr.range,
-							[RuntimeGlobals.amdDefine]
+						if (conflictingModule === importedModule) continue;
+						const conflictingExportInfo = moduleGraph.getExportInfo(
+							conflictingModule,
+							exportInfo.name
 						);
-						dep.loc = expr.loc;
-						parser.state.module.addPresentationalDependency(dep);
-						return false;
-					});
-					parser.hooks.typeof
-						.for("require")
-						.tap(
-							"AMDPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
+						const conflictingTarget =
+							conflictingExportInfo.getTerminalBinding(moduleGraph);
+						if (!conflictingTarget) continue;
+						if (target === conflictingTarget) continue;
+						const list = conflicts.get(conflictingDependency.request);
+						if (list === undefined) {
+							conflicts.set(conflictingDependency.request, [exportInfo.name]);
+						} else {
+							list.push(exportInfo.name);
+						}
+					}
+					for (const [request, exports] of conflicts) {
+						if (!errors) errors = [];
+						errors.push(
+							new HarmonyLinkingError(
+								`The requested module '${
+									this.request
+								}' contains conflicting star exports for the ${
+									exports.length > 1 ? "names" : "name"
+								} ${exports
+									.map(e => `'${e}'`)
+									.join(", ")} with the previous requested module '${request}'`
+							)
 						);
-					parser.hooks.evaluateTypeof
-						.for("require")
-						.tap("AMDPlugin", evaluateToString("function"));
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("AMDPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("AMDPlugin", handler);
+					}
+				}
 			}
-		);
-	}
-}
-
-module.exports = AMDPlugin;
-
-
-/***/ }),
-
-/***/ 33516:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const DependencyTemplate = __webpack_require__(5160);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-
-class AMDRequireArrayDependency extends NullDependency {
-	constructor(depsArray, range) {
-		super();
-
-		this.depsArray = depsArray;
-		this.range = range;
-	}
-
-	get type() {
-		return "amd require array";
-	}
-
-	get category() {
-		return "amd";
+		}
+		return errors;
 	}
 
 	serialize(context) {
-		const { write } = context;
+		const { write, setCircularReference } = context;
 
-		write(this.depsArray);
-		write(this.range);
+		setCircularReference(this);
+		write(this.ids);
+		write(this.name);
+		write(this.activeExports);
+		write(this.otherStarExports);
+		write(this.exportPresenceMode);
+		write(this.allStarExports);
 
 		super.serialize(context);
 	}
 
 	deserialize(context) {
-		const { read } = context;
+		const { read, setCircularReference } = context;
 
-		this.depsArray = read();
-		this.range = read();
+		setCircularReference(this);
+		this.ids = read();
+		this.name = read();
+		this.activeExports = read();
+		this.otherStarExports = read();
+		this.exportPresenceMode = read();
+		this.allStarExports = read();
 
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	AMDRequireArrayDependency,
-	"webpack/lib/dependencies/AMDRequireArrayDependency"
+	HarmonyExportImportedSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency"
 );
 
-AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate extends (
-	DependencyTemplate
+module.exports = HarmonyExportImportedSpecifierDependency;
+
+HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate extends (
+	HarmonyImportDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -78827,423 +77977,378 @@ AMDRequireArrayDependency.Template = class AMDRequireArrayDependencyTemplate ext
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const dep = /** @type {AMDRequireArrayDependency} */ (dependency);
-		const content = this.getContent(dep, templateContext);
-		source.replace(dep.range[0], dep.range[1] - 1, content);
-	}
+		const { moduleGraph, runtime, concatenationScope } = templateContext;
 
-	getContent(dep, templateContext) {
-		const requires = dep.depsArray.map(dependency => {
-			return this.contentForDependency(dependency, templateContext);
-		});
-		return `[${requires.join(", ")}]`;
-	}
+		const dep = /** @type {HarmonyExportImportedSpecifierDependency} */ (
+			dependency
+		);
 
-	contentForDependency(
-		dep,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		if (typeof dep === "string") {
-			return dep;
-		}
+		const mode = dep.getMode(moduleGraph, runtime);
 
-		if (dep.localModule) {
-			return dep.localModule.variableName();
-		} else {
-			return runtimeTemplate.moduleExports({
-				module: moduleGraph.getModule(dep),
-				chunkGraph,
-				request: dep.request,
-				runtimeRequirements
-			});
+		if (concatenationScope) {
+			switch (mode.type) {
+				case "reexport-undefined":
+					concatenationScope.registerRawExport(
+						mode.name,
+						"/* reexport non-default export from non-harmony */ undefined"
+					);
+			}
+			return;
 		}
-	}
-};
-
-module.exports = AMDRequireArrayDependency;
-
-
-/***/ }),
-
-/***/ 96123:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+		if (mode.type !== "unused" && mode.type !== "empty-star") {
+			super.apply(dependency, source, templateContext);
 
-
-const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-
-class AMDRequireContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
-
-		this.range = range;
-		this.valueRange = valueRange;
-	}
-
-	get type() {
-		return "amd require context";
-	}
-
-	get category() {
-		return "amd";
+			this._addExportFragments(
+				templateContext.initFragments,
+				dep,
+				mode,
+				templateContext.module,
+				moduleGraph,
+				runtime,
+				templateContext.runtimeTemplate,
+				templateContext.runtimeRequirements
+			);
+		}
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-		write(this.valueRange);
-
-		super.serialize(context);
-	}
+	/**
+	 * @param {InitFragment[]} initFragments target array for init fragments
+	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
+	 * @param {ExportMode} mode the export mode
+	 * @param {Module} module the current module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 * @returns {void}
+	 */
+	_addExportFragments(
+		initFragments,
+		dep,
+		mode,
+		module,
+		moduleGraph,
+		runtime,
+		runtimeTemplate,
+		runtimeRequirements
+	) {
+		const importedModule = moduleGraph.getModule(dep);
+		const importVar = dep.getImportVar(moduleGraph);
 
-	deserialize(context) {
-		const { read } = context;
+		switch (mode.type) {
+			case "missing":
+			case "empty-star":
+				initFragments.push(
+					new InitFragment(
+						"/* empty/unused harmony star reexport */\n",
+						InitFragment.STAGE_HARMONY_EXPORTS,
+						1
+					)
+				);
+				break;
 
-		this.range = read();
-		this.valueRange = read();
+			case "unused":
+				initFragments.push(
+					new InitFragment(
+						`${Template.toNormalComment(
+							`unused harmony reexport ${mode.name}`
+						)}\n`,
+						InitFragment.STAGE_HARMONY_EXPORTS,
+						1
+					)
+				);
+				break;
 
-		super.deserialize(context);
-	}
-}
+			case "reexport-dynamic-default":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport default from dynamic",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						null,
+						runtimeRequirements
+					)
+				);
+				break;
 
-makeSerializable(
-	AMDRequireContextDependency,
-	"webpack/lib/dependencies/AMDRequireContextDependency"
-);
+			case "reexport-fake-namespace-object":
+				initFragments.push(
+					...this.getReexportFakeNamespaceObjectFragments(
+						module,
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						mode.fakeType,
+						runtimeRequirements
+					)
+				);
+				break;
 
-AMDRequireContextDependency.Template = __webpack_require__(75815);
+			case "reexport-undefined":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport non-default export from non-harmony",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						"undefined",
+						"",
+						runtimeRequirements
+					)
+				);
+				break;
 
-module.exports = AMDRequireContextDependency;
+			case "reexport-named-default":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport default export from named module",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						"",
+						runtimeRequirements
+					)
+				);
+				break;
 
+			case "reexport-namespace-object":
+				initFragments.push(
+					this.getReexportFragment(
+						module,
+						"reexport module object",
+						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
+						importVar,
+						"",
+						runtimeRequirements
+					)
+				);
+				break;
 
-/***/ }),
+			case "normal-reexport":
+				for (const { name, ids, checked, hidden } of mode.items) {
+					if (hidden) continue;
+					if (checked) {
+						initFragments.push(
+							new InitFragment(
+								"/* harmony reexport (checked) */ " +
+									this.getConditionalReexportStatement(
+										module,
+										name,
+										importVar,
+										ids,
+										runtimeRequirements
+									),
+								moduleGraph.isAsync(importedModule)
+									? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
+									: InitFragment.STAGE_HARMONY_IMPORTS,
+								dep.sourceOrder
+							)
+						);
+					} else {
+						initFragments.push(
+							this.getReexportFragment(
+								module,
+								"reexport safe",
+								moduleGraph.getExportsInfo(module).getUsedName(name, runtime),
+								importVar,
+								moduleGraph
+									.getExportsInfo(importedModule)
+									.getUsedName(ids, runtime),
+								runtimeRequirements
+							)
+						);
+					}
+				}
+				break;
 
-/***/ 76932:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			case "dynamic-reexport": {
+				const ignored = mode.hidden
+					? combine(mode.ignored, mode.hidden)
+					: mode.ignored;
+				const modern =
+					runtimeTemplate.supportsConst() &&
+					runtimeTemplate.supportsArrowFunction();
+				let content =
+					"/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};\n" +
+					`/* harmony reexport (unknown) */ for(${
+						modern ? "const" : "var"
+					} __WEBPACK_IMPORT_KEY__ in ${importVar}) `;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				// Filter out exports which are defined by other exports
+				// and filter out default export because it cannot be reexported with *
+				if (ignored.size > 1) {
+					content +=
+						"if(" +
+						JSON.stringify(Array.from(ignored)) +
+						".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
+				} else if (ignored.size === 1) {
+					content += `if(__WEBPACK_IMPORT_KEY__ !== ${JSON.stringify(
+						first(ignored)
+					)}) `;
+				}
 
+				content += `__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = `;
+				if (modern) {
+					content += `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`;
+				} else {
+					content += `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
+				}
 
+				runtimeRequirements.add(RuntimeGlobals.exports);
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const makeSerializable = __webpack_require__(33032);
+				const exportsName = module.exportsArgument;
+				initFragments.push(
+					new InitFragment(
+						`${content}\n/* harmony reexport (unknown) */ ${RuntimeGlobals.definePropertyGetters}(${exportsName}, __WEBPACK_REEXPORT_OBJECT__);\n`,
+						moduleGraph.isAsync(importedModule)
+							? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
+							: InitFragment.STAGE_HARMONY_IMPORTS,
+						dep.sourceOrder
+					)
+				);
+				break;
+			}
 
-class AMDRequireDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(loc, request) {
-		super(null, loc, request);
+			default:
+				throw new Error(`Unknown mode ${mode.type}`);
+		}
 	}
-}
-
-makeSerializable(
-	AMDRequireDependenciesBlock,
-	"webpack/lib/dependencies/AMDRequireDependenciesBlock"
-);
-
-module.exports = AMDRequireDependenciesBlock;
-
-
-/***/ }),
-
-/***/ 66866:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	getReexportFragment(
+		module,
+		comment,
+		key,
+		name,
+		valueKey,
+		runtimeRequirements
+	) {
+		const returnValue = this.getReturnValue(name, valueKey);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const AMDRequireArrayDependency = __webpack_require__(33516);
-const AMDRequireContextDependency = __webpack_require__(96123);
-const AMDRequireDependenciesBlock = __webpack_require__(76932);
-const AMDRequireDependency = __webpack_require__(43911);
-const AMDRequireItemDependency = __webpack_require__(71806);
-const ConstDependency = __webpack_require__(76911);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const LocalModuleDependency = __webpack_require__(52805);
-const { getLocalModule } = __webpack_require__(75827);
-const UnsupportedDependency = __webpack_require__(51669);
-const getFunctionExpression = __webpack_require__(50396);
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-class AMDRequireDependenciesBlockParserPlugin {
-	constructor(options) {
-		this.options = options;
-	}
+		const map = new Map();
+		map.set(key, `/* ${comment} */ ${returnValue}`);
 
-	processFunctionArgument(parser, expression) {
-		let bindThis = true;
-		const fnData = getFunctionExpression(expression);
-		if (fnData) {
-			parser.inScope(
-				fnData.fn.params.filter(i => {
-					return !["require", "module", "exports"].includes(i.name);
-				}),
-				() => {
-					if (fnData.fn.body.type === "BlockStatement") {
-						parser.walkStatement(fnData.fn.body);
-					} else {
-						parser.walkExpression(fnData.fn.body);
-					}
-				}
-			);
-			parser.walkExpressions(fnData.expressions);
-			if (fnData.needThis === false) {
-				bindThis = false;
-			}
-		} else {
-			parser.walkExpression(expression);
-		}
-		return bindThis;
+		return new HarmonyExportInitFragment(module.exportsArgument, map);
 	}
 
-	apply(parser) {
-		parser.hooks.call
-			.for("require")
-			.tap(
-				"AMDRequireDependenciesBlockParserPlugin",
-				this.processCallRequire.bind(this, parser)
-			);
-	}
+	getReexportFakeNamespaceObjectFragments(
+		module,
+		key,
+		name,
+		fakeType,
+		runtimeRequirements
+	) {
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 
-	processArray(parser, expr, param) {
-		if (param.isArray()) {
-			for (const p of param.items) {
-				const result = this.processItem(parser, expr, p);
-				if (result === undefined) {
-					this.processContext(parser, expr, p);
-				}
-			}
-			return true;
-		} else if (param.isConstArray()) {
-			const deps = [];
-			for (const request of param.array) {
-				let dep, localModule;
-				if (request === "require") {
-					dep = "__webpack_require__";
-				} else if (["exports", "module"].includes(request)) {
-					dep = request;
-				} else if ((localModule = getLocalModule(parser.state, request))) {
-					localModule.flagUsed();
-					dep = new LocalModuleDependency(localModule, undefined, false);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-				} else {
-					dep = this.newRequireItemDependency(request);
-					dep.loc = expr.loc;
-					dep.optional = !!parser.scope.inTry;
-					parser.state.current.addDependency(dep);
-				}
-				deps.push(dep);
-			}
-			const dep = this.newRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		}
-	}
-	processItem(parser, expr, param) {
-		if (param.isConditional()) {
-			for (const p of param.options) {
-				const result = this.processItem(parser, expr, p);
-				if (result === undefined) {
-					this.processContext(parser, expr, p);
-				}
-			}
-			return true;
-		} else if (param.isString()) {
-			let dep, localModule;
-			if (param.string === "require") {
-				dep = new ConstDependency("__webpack_require__", param.string, [
-					RuntimeGlobals.require
-				]);
-			} else if (param.string === "module") {
-				dep = new ConstDependency(
-					parser.state.module.buildInfo.moduleArgument,
-					param.range,
-					[RuntimeGlobals.module]
-				);
-			} else if (param.string === "exports") {
-				dep = new ConstDependency(
-					parser.state.module.buildInfo.exportsArgument,
-					param.range,
-					[RuntimeGlobals.exports]
-				);
-			} else if ((localModule = getLocalModule(parser.state, param.string))) {
-				localModule.flagUsed();
-				dep = new LocalModuleDependency(localModule, param.range, false);
-			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		}
-	}
-	processContext(parser, expr, param) {
-		const dep = ContextDependencyHelpers.create(
-			AMDRequireContextDependency,
-			param.range,
-			param,
-			expr,
-			this.options,
-			{
-				category: "amd"
-			},
-			parser
+		const map = new Map();
+		map.set(
+			key,
+			`/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
+				RuntimeGlobals.createFakeNamespaceObject
+			}(${name}${fakeType ? `, ${fakeType}` : ""}))`
 		);
-		if (!dep) return;
-		dep.loc = expr.loc;
-		dep.optional = !!parser.scope.inTry;
-		parser.state.current.addDependency(dep);
-		return true;
-	}
 
-	processArrayForRequestString(param) {
-		if (param.isArray()) {
-			const result = param.items.map(item =>
-				this.processItemForRequestString(item)
-			);
-			if (result.every(Boolean)) return result.join(" ");
-		} else if (param.isConstArray()) {
-			return param.array.join(" ");
-		}
+		return [
+			new InitFragment(
+				`var ${name}_namespace_cache;\n`,
+				InitFragment.STAGE_CONSTANTS,
+				-1,
+				`${name}_namespace_cache`
+			),
+			new HarmonyExportInitFragment(module.exportsArgument, map)
+		];
 	}
 
-	processItemForRequestString(param) {
-		if (param.isConditional()) {
-			const result = param.options.map(item =>
-				this.processItemForRequestString(item)
-			);
-			if (result.every(Boolean)) return result.join("|");
-		} else if (param.isString()) {
-			return param.string;
+	getConditionalReexportStatement(
+		module,
+		key,
+		name,
+		valueKey,
+		runtimeRequirements
+	) {
+		if (valueKey === false) {
+			return "/* unused export */\n";
 		}
-	}
 
-	processCallRequire(parser, expr) {
-		let param;
-		let depBlock;
-		let dep;
-		let result;
+		const exportsName = module.exportsArgument;
+		const returnValue = this.getReturnValue(name, valueKey);
 
-		const old = parser.state.current;
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		runtimeRequirements.add(RuntimeGlobals.hasOwnProperty);
 
-		if (expr.arguments.length >= 1) {
-			param = parser.evaluateExpression(expr.arguments[0]);
-			depBlock = this.newRequireDependenciesBlock(
-				expr.loc,
-				this.processArrayForRequestString(param)
-			);
-			dep = this.newRequireDependency(
-				expr.range,
-				param.range,
-				expr.arguments.length > 1 ? expr.arguments[1].range : null,
-				expr.arguments.length > 2 ? expr.arguments[2].range : null
-			);
-			dep.loc = expr.loc;
-			depBlock.addDependency(dep);
+		return `if(${RuntimeGlobals.hasOwnProperty}(${name}, ${JSON.stringify(
+			valueKey[0]
+		)})) ${
+			RuntimeGlobals.definePropertyGetters
+		}(${exportsName}, { ${JSON.stringify(
+			key
+		)}: function() { return ${returnValue}; } });\n`;
+	}
 
-			parser.state.current = depBlock;
+	getReturnValue(name, valueKey) {
+		if (valueKey === null) {
+			return `${name}_default.a`;
 		}
 
-		if (expr.arguments.length === 1) {
-			parser.inScope([], () => {
-				result = this.processArray(parser, expr, param);
-			});
-			parser.state.current = old;
-			if (!result) return;
-			parser.state.current.addBlock(depBlock);
-			return true;
+		if (valueKey === "") {
+			return name;
 		}
 
-		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
-			try {
-				parser.inScope([], () => {
-					result = this.processArray(parser, expr, param);
-				});
-				if (!result) {
-					const dep = new UnsupportedDependency("unsupported", expr.range);
-					old.addPresentationalDependency(dep);
-					if (parser.state.module) {
-						parser.state.module.addError(
-							new UnsupportedFeatureWarning(
-								"Cannot statically analyse 'require(…, …)' in line " +
-									expr.loc.start.line,
-								expr.loc
-							)
-						);
-					}
-					depBlock = null;
-					return true;
-				}
-				dep.functionBindThis = this.processFunctionArgument(
-					parser,
-					expr.arguments[1]
-				);
-				if (expr.arguments.length === 3) {
-					dep.errorCallbackBindThis = this.processFunctionArgument(
-						parser,
-						expr.arguments[2]
-					);
-				}
-			} finally {
-				parser.state.current = old;
-				if (depBlock) parser.state.current.addBlock(depBlock);
-			}
-			return true;
+		if (valueKey === false) {
+			return "/* unused export */ undefined";
 		}
+
+		return `${name}${propertyAccess(valueKey)}`;
 	}
+};
 
-	newRequireDependenciesBlock(loc, request) {
-		return new AMDRequireDependenciesBlock(loc, request);
+class HarmonyStarExportsList {
+	constructor() {
+		/** @type {HarmonyExportImportedSpecifierDependency[]} */
+		this.dependencies = [];
 	}
-	newRequireDependency(
-		outerRange,
-		arrayRange,
-		functionRange,
-		errorCallbackRange
-	) {
-		return new AMDRequireDependency(
-			outerRange,
-			arrayRange,
-			functionRange,
-			errorCallbackRange
-		);
+
+	/**
+	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
+	 * @returns {void}
+	 */
+	push(dep) {
+		this.dependencies.push(dep);
 	}
-	newRequireItemDependency(request, range) {
-		return new AMDRequireItemDependency(request, range);
+
+	slice() {
+		return this.dependencies.slice();
 	}
-	newRequireArrayDependency(depsArray, range) {
-		return new AMDRequireArrayDependency(depsArray, range);
+
+	serialize({ write, setCircularReference }) {
+		setCircularReference(this);
+		write(this.dependencies);
+	}
+
+	deserialize({ read, setCircularReference }) {
+		setCircularReference(this);
+		this.dependencies = read();
 	}
 }
-module.exports = AMDRequireDependenciesBlockParserPlugin;
+
+makeSerializable(
+	HarmonyStarExportsList,
+	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency",
+	"HarmonyStarExportsList"
+);
+
+module.exports.HarmonyStarExportsList = HarmonyStarExportsList;
 
 
 /***/ }),
 
-/***/ 43911:
+/***/ 89500:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -79254,352 +78359,245 @@ module.exports = AMDRequireDependenciesBlockParserPlugin;
 
 
 
+const InitFragment = __webpack_require__(55870);
 const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+const { first } = __webpack_require__(93347);
 
-class AMDRequireDependency extends NullDependency {
-	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
-		super();
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
-		this.outerRange = outerRange;
-		this.arrayRange = arrayRange;
-		this.functionRange = functionRange;
-		this.errorCallbackRange = errorCallbackRange;
-		this.functionBindThis = false;
-		this.errorCallbackBindThis = false;
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
 	}
+	return str;
+};
 
-	get category() {
-		return "amd";
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.outerRange);
-		write(this.arrayRange);
-		write(this.functionRange);
-		write(this.errorCallbackRange);
-		write(this.functionBindThis);
-		write(this.errorCallbackBindThis);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.outerRange = read();
-		this.arrayRange = read();
-		this.functionRange = read();
-		this.errorCallbackRange = read();
-		this.functionBindThis = read();
-		this.errorCallbackBindThis = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	AMDRequireDependency,
-	"webpack/lib/dependencies/AMDRequireDependency"
-);
+const EMPTY_MAP = new Map();
+const EMPTY_SET = new Set();
 
-AMDRequireDependency.Template = class AMDRequireDependencyTemplate extends (
-	NullDependency.Template
-) {
+/**
+ * @typedef {GenerateContext} Context
+ */
+class HarmonyExportInitFragment extends InitFragment {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {string} exportsArgument the exports identifier
+	 * @param {Map<string, string>} exportMap mapping from used name to exposed variable name
+	 * @param {Set<string>} unusedExports list of unused export names
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	constructor(
+		exportsArgument,
+		exportMap = EMPTY_MAP,
+		unusedExports = EMPTY_SET
 	) {
-		const dep = /** @type {AMDRequireDependency} */ (dependency);
-		const depBlock = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dep)
-		);
-		const promise = runtimeTemplate.blockPromise({
-			chunkGraph,
-			block: depBlock,
-			message: "AMD require",
-			runtimeRequirements
-		});
-
-		// has array range but no function range
-		if (dep.arrayRange && !dep.functionRange) {
-			const startBlock = `${promise}.then(function() {`;
-			const endBlock = `;})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
-			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
-
-			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
-
-			source.replace(dep.arrayRange[1], dep.outerRange[1] - 1, endBlock);
-
-			return;
-		}
-
-		// has function range but no array range
-		if (dep.functionRange && !dep.arrayRange) {
-			const startBlock = `${promise}.then((`;
-			const endBlock = `).bind(exports, __webpack_require__, exports, module))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
-			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
-
-			source.replace(dep.outerRange[0], dep.functionRange[0] - 1, startBlock);
+		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
+		this.exportsArgument = exportsArgument;
+		this.exportMap = exportMap;
+		this.unusedExports = unusedExports;
+	}
 
-			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+	/**
+	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
+	 * @returns {HarmonyExportInitFragment} merged fragment
+	 */
+	mergeAll(fragments) {
+		let exportMap;
+		let exportMapOwned = false;
+		let unusedExports;
+		let unusedExportsOwned = false;
 
-			return;
+		for (const fragment of fragments) {
+			if (fragment.exportMap.size !== 0) {
+				if (exportMap === undefined) {
+					exportMap = fragment.exportMap;
+					exportMapOwned = false;
+				} else {
+					if (!exportMapOwned) {
+						exportMap = new Map(exportMap);
+						exportMapOwned = true;
+					}
+					for (const [key, value] of fragment.exportMap) {
+						if (!exportMap.has(key)) exportMap.set(key, value);
+					}
+				}
+			}
+			if (fragment.unusedExports.size !== 0) {
+				if (unusedExports === undefined) {
+					unusedExports = fragment.unusedExports;
+					unusedExportsOwned = false;
+				} else {
+					if (!unusedExportsOwned) {
+						unusedExports = new Set(unusedExports);
+						unusedExportsOwned = true;
+					}
+					for (const value of fragment.unusedExports) {
+						unusedExports.add(value);
+					}
+				}
+			}
 		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
 
-		// has array range, function range, and errorCallbackRange
-		if (dep.arrayRange && dep.functionRange && dep.errorCallbackRange) {
-			const startBlock = `${promise}.then(function() { `;
-			const errorRangeBlock = `}${
-				dep.functionBindThis ? ".bind(this)" : ""
-			})['catch'](`;
-			const endBlock = `${dep.errorCallbackBindThis ? ".bind(this)" : ""})`;
-
-			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
-
-			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
-
-			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
-
-			source.insert(
-				dep.functionRange[1],
-				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
-			);
-
-			source.replace(
-				dep.functionRange[1],
-				dep.errorCallbackRange[0] - 1,
-				errorRangeBlock
-			);
-
-			source.replace(
-				dep.errorCallbackRange[1],
-				dep.outerRange[1] - 1,
-				endBlock
-			);
-
-			return;
+	merge(other) {
+		let exportMap;
+		if (this.exportMap.size === 0) {
+			exportMap = other.exportMap;
+		} else if (other.exportMap.size === 0) {
+			exportMap = this.exportMap;
+		} else {
+			exportMap = new Map(other.exportMap);
+			for (const [key, value] of this.exportMap) {
+				if (!exportMap.has(key)) exportMap.set(key, value);
+			}
 		}
-
-		// has array range, function range, but no errorCallbackRange
-		if (dep.arrayRange && dep.functionRange) {
-			const startBlock = `${promise}.then(function() { `;
-			const endBlock = `}${
-				dep.functionBindThis ? ".bind(this)" : ""
-			})['catch'](${RuntimeGlobals.uncaughtErrorHandler})`;
-			runtimeRequirements.add(RuntimeGlobals.uncaughtErrorHandler);
-
-			source.replace(dep.outerRange[0], dep.arrayRange[0] - 1, startBlock);
-
-			source.insert(dep.arrayRange[0], "var __WEBPACK_AMD_REQUIRE_ARRAY__ = ");
-
-			source.replace(dep.arrayRange[1], dep.functionRange[0] - 1, "; (");
-
-			source.insert(
-				dep.functionRange[1],
-				").apply(null, __WEBPACK_AMD_REQUIRE_ARRAY__);"
-			);
-
-			source.replace(dep.functionRange[1], dep.outerRange[1] - 1, endBlock);
+		let unusedExports;
+		if (this.unusedExports.size === 0) {
+			unusedExports = other.unusedExports;
+		} else if (other.unusedExports.size === 0) {
+			unusedExports = this.unusedExports;
+		} else {
+			unusedExports = new Set(other.unusedExports);
+			for (const value of this.unusedExports) {
+				unusedExports.add(value);
+			}
 		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
 	}
-};
-
-module.exports = AMDRequireDependency;
-
-
-/***/ }),
-
-/***/ 71806:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
-
-class AMDRequireItemDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-
-		this.range = range;
-	}
-
-	get type() {
-		return "amd require";
-	}
-
-	get category() {
-		return "amd";
-	}
-}
-
-makeSerializable(
-	AMDRequireItemDependency,
-	"webpack/lib/dependencies/AMDRequireItemDependency"
-);
-
-AMDRequireItemDependency.Template = ModuleDependencyTemplateAsRequireId;
-
-module.exports = AMDRequireItemDependency;
-
-
-/***/ }),
-
-/***/ 45242:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-
-class AMDDefineRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("amd define");
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.amdDefine} = function () {`,
-			Template.indent("throw new Error('define cannot be used indirect');"),
-			"};"
-		]);
-	}
-}
 
-class AMDOptionsRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Record<string, boolean | number | string>} options the AMD options
+	 * @param {Context} context context
+	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	constructor(options) {
-		super("amd options");
-		this.options = options;
-	}
+	getContent({ runtimeTemplate, runtimeRequirements }) {
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.amdOptions} = ${JSON.stringify(this.options)};`
-		]);
+		const unusedPart =
+			this.unusedExports.size > 1
+				? `/* unused harmony exports ${joinIterableWithComma(
+						this.unusedExports
+				  )} */\n`
+				: this.unusedExports.size > 0
+				? `/* unused harmony export ${first(this.unusedExports)} */\n`
+				: "";
+		const definitions = [];
+		for (const [key, value] of this.exportMap) {
+			definitions.push(
+				`\n/* harmony export */   ${JSON.stringify(
+					key
+				)}: ${runtimeTemplate.returningFunction(value)}`
+			);
+		}
+		const definePart =
+			this.exportMap.size > 0
+				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
+						this.exportsArgument
+				  }, {${definitions.join(",")}\n/* harmony export */ });\n`
+				: "";
+		return `${definePart}${unusedPart}`;
 	}
 }
 
-exports.AMDDefineRuntimeModule = AMDDefineRuntimeModule;
-exports.AMDOptionsRuntimeModule = AMDOptionsRuntimeModule;
+module.exports = HarmonyExportInitFragment;
 
 
 /***/ }),
 
-/***/ 57403:
+/***/ 48567:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const DependencyTemplate = __webpack_require__(5160);
-const InitFragment = __webpack_require__(55870);
 const makeSerializable = __webpack_require__(33032);
+const HarmonyExportInitFragment = __webpack_require__(89500);
 const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 
-class CachedConstDependency extends NullDependency {
-	constructor(expression, range, identifier) {
+class HarmonyExportSpecifierDependency extends NullDependency {
+	constructor(id, name) {
 		super();
+		this.id = id;
+		this.name = name;
+	}
 
-		this.expression = expression;
-		this.range = range;
-		this.identifier = identifier;
-		this._hashUpdate = undefined;
+	get type() {
+		return "harmony export specifier";
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined)
-			this._hashUpdate = "" + this.identifier + this.range + this.expression;
-		hash.update(this._hashUpdate);
+	getExports(moduleGraph) {
+		return {
+			exports: [this.name],
+			priority: 1,
+			terminalBinding: true,
+			dependencies: undefined
+		};
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
 	serialize(context) {
 		const { write } = context;
-
-		write(this.expression);
-		write(this.range);
-		write(this.identifier);
-
+		write(this.id);
+		write(this.name);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-
-		this.expression = read();
-		this.range = read();
-		this.identifier = read();
-
+		this.id = read();
+		this.name = read();
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	CachedConstDependency,
-	"webpack/lib/dependencies/CachedConstDependency"
+	HarmonyExportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyExportSpecifierDependency"
 );
 
-CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
-	DependencyTemplate
+HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate extends (
+	NullDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -79610,36 +78608,88 @@ CachedConstDependency.Template = class CachedConstDependencyTemplate extends (
 	apply(
 		dependency,
 		source,
-		{ runtimeTemplate, dependencyTemplates, initFragments }
+		{ module, moduleGraph, initFragments, runtime, concatenationScope }
 	) {
-		const dep = /** @type {CachedConstDependency} */ (dependency);
+		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
+		if (concatenationScope) {
+			concatenationScope.registerExport(dep.name, dep.id);
+			return;
+		}
+		const used = moduleGraph
+			.getExportsInfo(module)
+			.getUsedName(dep.name, runtime);
+		if (!used) {
+			const set = new Set();
+			set.add(dep.name || "namespace");
+			initFragments.push(
+				new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
+			);
+			return;
+		}
 
+		const map = new Map();
+		map.set(used, `/* binding */ ${dep.id}`);
 		initFragments.push(
-			new InitFragment(
-				`var ${dep.identifier} = ${dep.expression};\n`,
-				InitFragment.STAGE_CONSTANTS,
-				0,
-				`const ${dep.identifier}`
-			)
+			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
 		);
+	}
+};
 
-		if (typeof dep.range === "number") {
-			source.insert(dep.range, dep.identifier);
+module.exports = HarmonyExportSpecifierDependency;
 
-			return;
-		}
 
-		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
+/***/ }),
+
+/***/ 39211:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Parser").ParserState} ParserState */
+
+/** @type {WeakMap<ParserState, boolean>} */
+const parserStateExportsState = new WeakMap();
+
+/**
+ * @param {ParserState} parserState parser state
+ * @param {boolean} isStrictHarmony strict harmony mode should be enabled
+ * @returns {void}
+ */
+exports.enable = (parserState, isStrictHarmony) => {
+	const value = parserStateExportsState.get(parserState);
+	if (value === false) return;
+	parserStateExportsState.set(parserState, true);
+	if (value !== true) {
+		parserState.module.buildMeta.exportsType = "namespace";
+		parserState.module.buildInfo.strict = true;
+		parserState.module.buildInfo.exportsArgument = "__webpack_exports__";
+		if (isStrictHarmony) {
+			parserState.module.buildMeta.strictHarmonyModule = true;
+			parserState.module.buildInfo.moduleArgument = "__webpack_module__";
+		}
 	}
 };
 
-module.exports = CachedConstDependency;
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+exports.isEnabled = parserState => {
+	const value = parserStateExportsState.get(parserState);
+	return value === true;
+};
 
 
 /***/ }),
 
-/***/ 59643:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 57154:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -79649,124 +78699,64 @@ module.exports = CachedConstDependency;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-
-exports.handleDependencyBase = (depBase, module, runtimeRequirements) => {
-	let base = undefined;
-	let type;
-	switch (depBase) {
-		case "exports":
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			base = module.exportsArgument;
-			type = "expression";
-			break;
-		case "module.exports":
-			runtimeRequirements.add(RuntimeGlobals.module);
-			base = `${module.moduleArgument}.exports`;
-			type = "expression";
-			break;
-		case "this":
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-			base = "this";
-			type = "expression";
-			break;
-		case "Object.defineProperty(exports)":
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			base = module.exportsArgument;
-			type = "Object.defineProperty";
-			break;
-		case "Object.defineProperty(module.exports)":
-			runtimeRequirements.add(RuntimeGlobals.module);
-			base = `${module.moduleArgument}.exports`;
-			type = "Object.defineProperty";
-			break;
-		case "Object.defineProperty(this)":
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-			base = "this";
-			type = "Object.defineProperty";
-			break;
-		default:
-			throw new Error(`Unsupported base ${depBase}`);
-	}
-
-	return [type, base];
-};
-
-
-/***/ }),
-
-/***/ 62892:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Dependency = __webpack_require__(54912);
-const { UsageState } = __webpack_require__(63686);
-const Template = __webpack_require__(39722);
-const { equals } = __webpack_require__(84953);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { handleDependencyBase } = __webpack_require__(59643);
-const ModuleDependency = __webpack_require__(80321);
-const processExportInfo = __webpack_require__(55207);
+const ConditionalInitFragment = __webpack_require__(61333);
+const Dependency = __webpack_require__(54912);
+const HarmonyLinkingError = __webpack_require__(97511);
+const InitFragment = __webpack_require__(55870);
+const Template = __webpack_require__(1626);
+const AwaitDependenciesInitFragment = __webpack_require__(41153);
+const { filterRuntime, mergeRuntime } = __webpack_require__(17156);
+const ModuleDependency = __webpack_require__(80321);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const idsSymbol = Symbol("CommonJsExportRequireDependency.ids");
-
-const EMPTY_OBJECT = {};
-
-class CommonJsExportRequireDependency extends ModuleDependency {
-	constructor(range, valueRange, base, names, request, ids, resultUsed) {
-		super(request);
-		this.range = range;
-		this.valueRange = valueRange;
-		this.base = base;
-		this.names = names;
-		this.ids = ids;
-		this.resultUsed = resultUsed;
-		this.asiSafe = undefined;
-	}
-
-	get type() {
-		return "cjs export require";
-	}
-
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return Dependency.TRANSITIVE;
+const ExportPresenceModes = {
+	NONE: /** @type {0} */ (0),
+	WARN: /** @type {1} */ (1),
+	AUTO: /** @type {2} */ (2),
+	ERROR: /** @type {3} */ (3),
+	fromUserOption(str) {
+		switch (str) {
+			case "error":
+				return ExportPresenceModes.ERROR;
+			case "warn":
+				return ExportPresenceModes.WARN;
+			case "auto":
+				return ExportPresenceModes.AUTO;
+			case false:
+				return ExportPresenceModes.NONE;
+			default:
+				throw new Error(`Invalid export presence value ${str}`);
+		}
 	}
+};
 
+class HarmonyImportDependency extends ModuleDependency {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported id
+	 *
+	 * @param {string} request request string
+	 * @param {number} sourceOrder source order
+	 * @param {Record<string, any>=} assertions import assertions
 	 */
-	getIds(moduleGraph) {
-		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	constructor(request, sourceOrder, assertions) {
+		super(request);
+		this.sourceOrder = sourceOrder;
+		this.assertions = assertions;
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
-	 * @returns {void}
-	 */
-	setIds(moduleGraph, ids) {
-		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	get category() {
+		return "esm";
 	}
 
 	/**
@@ -79776,232 +78766,176 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		const ids = this.getIds(moduleGraph);
-		const getFullResult = () => {
-			if (ids.length === 0) {
-				return Dependency.EXPORTS_OBJECT_REFERENCED;
-			} else {
-				return [
-					{
-						name: ids,
-						canMangle: false
-					}
-				];
-			}
-		};
-		if (this.resultUsed) return getFullResult();
-		let exportsInfo = moduleGraph.getExportsInfo(
-			moduleGraph.getParentModule(this)
-		);
-		for (const name of this.names) {
-			const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-			const used = exportInfo.getUsed(runtime);
-			if (used === UsageState.Unused) return Dependency.NO_EXPORTS_REFERENCED;
-			if (used !== UsageState.OnlyPropertiesUsed) return getFullResult();
-			exportsInfo = exportInfo.exportsInfo;
-			if (!exportsInfo) return getFullResult();
-		}
-		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
-			return getFullResult();
-		}
-		/** @type {string[][]} */
-		const referencedExports = [];
-		for (const exportInfo of exportsInfo.orderedExports) {
-			processExportInfo(
-				runtime,
-				referencedExports,
-				ids.concat(exportInfo.name),
-				exportInfo,
-				false
-			);
-		}
-		return referencedExports.map(name => ({
-			name,
-			canMangle: false
-		}));
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string} name of the variable for the import
 	 */
-	getExports(moduleGraph) {
-		const ids = this.getIds(moduleGraph);
-		if (this.names.length === 1) {
-			const name = this.names[0];
-			const from = moduleGraph.getConnection(this);
-			if (!from) return;
-			return {
-				exports: [
-					{
-						name,
-						from,
-						export: ids.length === 0 ? null : ids,
-						// we can't mangle names that are in an empty object
-						// because one could access the prototype property
-						// when export isn't set yet
-						canMangle: !(name in EMPTY_OBJECT) && false
-					}
-				],
-				dependencies: [from.module]
-			};
-		} else if (this.names.length > 0) {
-			const name = this.names[0];
-			return {
-				exports: [
-					{
-						name,
-						// we can't mangle names that are in an empty object
-						// because one could access the prototype property
-						// when export isn't set yet
-						canMangle: !(name in EMPTY_OBJECT) && false
-					}
-				],
-				dependencies: undefined
-			};
-		} else {
-			const from = moduleGraph.getConnection(this);
-			if (!from) return;
-			const reexportInfo = this.getStarReexports(
-				moduleGraph,
-				undefined,
-				from.module
-			);
-			if (reexportInfo) {
-				return {
-					exports: Array.from(reexportInfo.exports, name => {
-						return {
-							name,
-							from,
-							export: ids.concat(name),
-							canMangle: !(name in EMPTY_OBJECT) && false
-						};
-					}),
-					// TODO handle deep reexports
-					dependencies: [from.module]
-				};
-			} else {
-				return {
-					exports: true,
-					from: ids.length === 0 ? from : undefined,
-					canMangle: false,
-					dependencies: [from.module]
-				};
-			}
-		}
+	getImportVar(moduleGraph) {
+		const module = moduleGraph.getParentModule(this);
+		const meta = moduleGraph.getMeta(module);
+		let importVarMap = meta.importVarMap;
+		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
+		let importVar = importVarMap.get(moduleGraph.getModule(this));
+		if (importVar) return importVar;
+		importVar = `${Template.toIdentifier(
+			`${this.userRequest}`
+		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
+		importVarMap.set(moduleGraph.getModule(this), importVar);
+		return importVar;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Module} importedModule the imported module (optional)
-	 * @returns {{exports?: Set<string>, checked?: Set<string>}} information
+	 * @param {boolean} update create new variables or update existing one
+	 * @param {DependencyTemplateContext} templateContext the template context
+	 * @returns {[string, string]} the import statement and the compat statement
 	 */
-	getStarReexports(
-		moduleGraph,
-		runtime,
-		importedModule = moduleGraph.getModule(this)
+	getImportStatement(
+		update,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
-		let importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
-		const ids = this.getIds(moduleGraph);
-		if (ids.length > 0)
-			importedExportsInfo = importedExportsInfo.getNestedExportsInfo(ids);
-		let exportsInfo = moduleGraph.getExportsInfo(
-			moduleGraph.getParentModule(this)
-		);
-		if (this.names.length > 0)
-			exportsInfo = exportsInfo.getNestedExportsInfo(this.names);
-
-		const noExtraExports =
-			importedExportsInfo &&
-			importedExportsInfo.otherExportsInfo.provided === false;
-		const noExtraImports =
-			exportsInfo &&
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
+		return runtimeTemplate.importStatement({
+			update,
+			module: moduleGraph.getModule(this),
+			chunkGraph,
+			importVar: this.getImportVar(moduleGraph),
+			request: this.request,
+			originModule: module,
+			runtimeRequirements
+		});
+	}
 
-		if (!noExtraExports && !noExtraImports) {
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {string[]} ids imported ids
+	 * @param {string} additionalMessage extra info included in the error message
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	getLinkingErrors(moduleGraph, ids, additionalMessage) {
+		const importedModule = moduleGraph.getModule(this);
+		// ignore errors for missing or failed modules
+		if (!importedModule || importedModule.getNumberOfErrors() > 0) {
 			return;
 		}
 
-		const isNamespaceImport =
-			importedModule.getExportsType(moduleGraph, false) === "namespace";
+		const parentModule = moduleGraph.getParentModule(this);
+		const exportsType = importedModule.getExportsType(
+			moduleGraph,
+			parentModule.buildMeta.strictHarmonyModule
+		);
+		if (exportsType === "namespace" || exportsType === "default-with-named") {
+			if (ids.length === 0) {
+				return;
+			}
 
-		/** @type {Set<string>} */
-		const exports = new Set();
-		/** @type {Set<string>} */
-		const checked = new Set();
+			if (
+				(exportsType !== "default-with-named" || ids[0] !== "default") &&
+				moduleGraph.isExportProvided(importedModule, ids) === false
+			) {
+				// We are sure that it's not provided
 
-		if (noExtraImports) {
-			for (const exportInfo of exportsInfo.orderedExports) {
-				const name = exportInfo.name;
-				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				if (name === "__esModule" && isNamespaceImport) {
-					exports.add(name);
-				} else if (importedExportsInfo) {
-					const importedExportInfo =
-						importedExportsInfo.getReadOnlyExportInfo(name);
-					if (importedExportInfo.provided === false) continue;
-					exports.add(name);
-					if (importedExportInfo.provided === true) continue;
-					checked.add(name);
-				} else {
-					exports.add(name);
-					checked.add(name);
+				// Try to provide detailed info in the error message
+				let pos = 0;
+				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+				while (pos < ids.length && exportsInfo) {
+					const id = ids[pos++];
+					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+					if (exportInfo.provided === false) {
+						// We are sure that it's not provided
+						const providedExports = exportsInfo.getProvidedExports();
+						const moreInfo = !Array.isArray(providedExports)
+							? " (possible exports unknown)"
+							: providedExports.length === 0
+							? " (module has no exports)"
+							: ` (possible exports: ${providedExports.join(", ")})`;
+						return [
+							new HarmonyLinkingError(
+								`export ${ids
+									.slice(0, pos)
+									.map(id => `'${id}'`)
+									.join(".")} ${additionalMessage} was not found in '${
+									this.userRequest
+								}'${moreInfo}`
+							)
+						];
+					}
+					exportsInfo = exportInfo.getNestedExportsInfo();
 				}
+
+				// General error message
+				return [
+					new HarmonyLinkingError(
+						`export ${ids
+							.map(id => `'${id}'`)
+							.join(".")} ${additionalMessage} was not found in '${
+							this.userRequest
+						}'`
+					)
+				];
 			}
-		} else if (noExtraExports) {
-			for (const importedExportInfo of importedExportsInfo.orderedExports) {
-				const name = importedExportInfo.name;
-				if (importedExportInfo.provided === false) continue;
-				if (exportsInfo) {
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-					if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
+		}
+		switch (exportsType) {
+			case "default-only":
+				// It's has only a default export
+				if (ids.length > 0 && ids[0] !== "default") {
+					// In strict harmony modules we only support the default export
+					return [
+						new HarmonyLinkingError(
+							`Can't import the named export ${ids
+								.map(id => `'${id}'`)
+								.join(
+									"."
+								)} ${additionalMessage} from default-exporting module (only default export is available)`
+						)
+					];
 				}
-				exports.add(name);
-				if (importedExportInfo.provided === true) continue;
-				checked.add(name);
-			}
-			if (isNamespaceImport) {
-				exports.add("__esModule");
-				checked.delete("__esModule");
-			}
+				break;
+			case "default-with-named":
+				// It has a default export and named properties redirect
+				// In some cases we still want to warn here
+				if (
+					ids.length > 0 &&
+					ids[0] !== "default" &&
+					importedModule.buildMeta.defaultObject === "redirect-warn"
+				) {
+					// For these modules only the default export is supported
+					return [
+						new HarmonyLinkingError(
+							`Should not import the named export ${ids
+								.map(id => `'${id}'`)
+								.join(
+									"."
+								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
+						)
+					];
+				}
+				break;
 		}
-
-		return { exports, checked };
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.asiSafe);
-		write(this.range);
-		write(this.valueRange);
-		write(this.base);
-		write(this.names);
-		write(this.ids);
-		write(this.resultUsed);
+		write(this.sourceOrder);
+		write(this.assertions);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.asiSafe = read();
-		this.range = read();
-		this.valueRange = read();
-		this.base = read();
-		this.names = read();
-		this.ids = read();
-		this.resultUsed = read();
+		this.sourceOrder = read();
+		this.assertions = read();
 		super.deserialize(context);
 	}
 }
 
-makeSerializable(
-	CommonJsExportRequireDependency,
-	"webpack/lib/dependencies/CommonJsExportRequireDependency"
-);
+module.exports = HarmonyImportDependency;
 
-CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependencyTemplate extends (
+/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
+const importEmittedMap = new WeakMap();
+
+HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends (
 	ModuleDependency.Template
 ) {
 	/**
@@ -80010,74 +78944,118 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			runtimeTemplate,
-			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
-			runtime
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyImportDependency} */ (dependency);
+		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
+
+		const connection = moduleGraph.getConnection(dep);
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const referencedModule = connection && connection.module;
+
+		if (
+			connection &&
+			connection.weak &&
+			referencedModule &&
+			chunkGraph.getModuleId(referencedModule) === null
+		) {
+			// in weak references, module might not be in any chunk
+			// but that's ok, we don't need that logic in this case
+			return;
 		}
-	) {
-		const dep = /** @type {CommonJsExportRequireDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportsInfo(module)
-			.getUsedName(dep.names, runtime);
 
-		const [type, base] = handleDependencyBase(
-			dep.base,
-			module,
-			runtimeRequirements
-		);
+		const moduleKey = referencedModule
+			? referencedModule.identifier()
+			: dep.request;
+		const key = `harmony import ${moduleKey}`;
 
-		const importedModule = moduleGraph.getModule(dep);
-		let requireExpr = runtimeTemplate.moduleExports({
-			module: importedModule,
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-		if (importedModule) {
-			const ids = dep.getIds(moduleGraph);
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(ids, runtime);
-			if (usedImported) {
-				const comment = equals(usedImported, ids)
-					? ""
-					: Template.toNormalComment(propertyAccess(ids)) + " ";
-				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+		const runtimeCondition = dep.weak
+			? false
+			: connection
+			? filterRuntime(runtime, r => connection.isTargetActive(r))
+			: true;
+
+		if (module && referencedModule) {
+			let emittedModules = importEmittedMap.get(module);
+			if (emittedModules === undefined) {
+				emittedModules = new WeakMap();
+				importEmittedMap.set(module, emittedModules);
+			}
+			let mergedRuntimeCondition = runtimeCondition;
+			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
+			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
+				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
+					mergedRuntimeCondition = oldRuntimeCondition;
+				} else {
+					mergedRuntimeCondition = mergeRuntime(
+						oldRuntimeCondition,
+						mergedRuntimeCondition
+					);
+				}
 			}
+			emittedModules.set(referencedModule, mergedRuntimeCondition);
 		}
 
-		switch (type) {
-			case "expression":
-				source.replace(
-					dep.range[0],
-					dep.range[1] - 1,
-					used
-						? `${base}${propertyAccess(used)} = ${requireExpr}`
-						: `/* unused reexport */ ${requireExpr}`
-				);
-				return;
-			case "Object.defineProperty":
-				throw new Error("TODO");
-			default:
-				throw new Error("Unexpected type");
+		const importStatement = dep.getImportStatement(false, templateContext);
+		if (
+			referencedModule &&
+			templateContext.moduleGraph.isAsync(referencedModule)
+		) {
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[0],
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key,
+					runtimeCondition
+				)
+			);
+			templateContext.initFragments.push(
+				new AwaitDependenciesInitFragment(
+					new Set([dep.getImportVar(templateContext.moduleGraph)])
+				)
+			);
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[1],
+					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key + " compat",
+					runtimeCondition
+				)
+			);
+		} else {
+			templateContext.initFragments.push(
+				new ConditionalInitFragment(
+					importStatement[0] + importStatement[1],
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					dep.sourceOrder,
+					key,
+					runtimeCondition
+				)
+			);
 		}
 	}
+
+	/**
+	 *
+	 * @param {Module} module the module
+	 * @param {Module} referencedModule the referenced module
+	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
+	 */
+	static getImportEmittedRuntime(module, referencedModule) {
+		const emittedModules = importEmittedMap.get(module);
+		if (emittedModules === undefined) return false;
+		return emittedModules.get(referencedModule) || false;
+	}
 };
 
-module.exports = CommonJsExportRequireDependency;
+module.exports.ExportPresenceModes = ExportPresenceModes;
 
 
 /***/ }),
 
-/***/ 45598:
+/***/ 20862:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -80088,164 +79066,260 @@ module.exports = CommonJsExportRequireDependency;
 
 
 
-const InitFragment = __webpack_require__(55870);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { handleDependencyBase } = __webpack_require__(59643);
-const NullDependency = __webpack_require__(31830);
+const HotModuleReplacementPlugin = __webpack_require__(6404);
+const InnerGraph = __webpack_require__(38988);
+const ConstDependency = __webpack_require__(76911);
+const HarmonyAcceptDependency = __webpack_require__(23624);
+const HarmonyAcceptImportDependency = __webpack_require__(99843);
+const HarmonyExports = __webpack_require__(39211);
+const { ExportPresenceModes } = __webpack_require__(57154);
+const HarmonyImportSideEffectDependency = __webpack_require__(73132);
+const HarmonyImportSpecifierDependency = __webpack_require__(14077);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ImportExpression} ImportExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
+/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
+/** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
 
-const EMPTY_OBJECT = {};
+const harmonySpecifierTag = Symbol("harmony import");
 
-class CommonJsExportsDependency extends NullDependency {
-	constructor(range, valueRange, base, names) {
-		super();
-		this.range = range;
-		this.valueRange = valueRange;
-		this.base = base;
-		this.names = names;
-	}
+/**
+ * @typedef {Object} HarmonySettings
+ * @property {string[]} ids
+ * @property {string} source
+ * @property {number} sourceOrder
+ * @property {string} name
+ * @property {boolean} await
+ * @property {Record<string, any> | undefined} assertions
+ */
 
-	get type() {
-		return "cjs exports";
+/**
+ * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
+ * @returns {Record<string, any> | undefined} assertions
+ */
+function getAssertions(node) {
+	// TODO remove cast when @types/estree has been updated to import assertions
+	const assertions = /** @type {{ assertions?: ImportAttributeNode[] }} */ (
+		node
+	).assertions;
+	if (assertions === undefined) {
+		return undefined;
+	}
+	const result = {};
+	for (const assertion of assertions) {
+		const key =
+			assertion.key.type === "Identifier"
+				? assertion.key.name
+				: assertion.key.value;
+		result[key] = assertion.value.value;
 	}
+	return result;
+}
 
+module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @param {JavascriptParserOptions} options options
 	 */
-	getExports(moduleGraph) {
-		const name = this.names[0];
-		return {
-			exports: [
-				{
-					name,
-					// we can't mangle names that are in an empty object
-					// because one could access the prototype property
-					// when export isn't set yet
-					canMangle: !(name in EMPTY_OBJECT)
-				}
-			],
-			dependencies: undefined
-		};
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.valueRange);
-		write(this.base);
-		write(this.names);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.valueRange = read();
-		this.base = read();
-		this.names = read();
-		super.deserialize(context);
+	constructor(options) {
+		this.exportPresenceMode =
+			options.importExportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
+				: options.exportsPresence !== undefined
+				? ExportPresenceModes.fromUserOption(options.exportsPresence)
+				: options.strictExportPresence
+				? ExportPresenceModes.ERROR
+				: ExportPresenceModes.AUTO;
+		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
-}
-
-makeSerializable(
-	CommonJsExportsDependency,
-	"webpack/lib/dependencies/CommonJsExportsDependency"
-);
 
-CommonJsExportsDependency.Template = class CommonJsExportsDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, initFragments, runtimeRequirements, runtime }
-	) {
-		const dep = /** @type {CommonJsExportsDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportsInfo(module)
-			.getUsedName(dep.names, runtime);
-
-		const [type, base] = handleDependencyBase(
-			dep.base,
-			module,
-			runtimeRequirements
+	apply(parser) {
+		const { exportPresenceMode } = this;
+		parser.hooks.isPure
+			.for("Identifier")
+			.tap("HarmonyImportDependencyParserPlugin", expression => {
+				const expr = /** @type {Identifier} */ (expression);
+				if (
+					parser.isVariableDefined(expr.name) ||
+					parser.getTagData(expr.name, harmonySpecifierTag)
+				) {
+					return true;
+				}
+			});
+		parser.hooks.import.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source) => {
+				parser.state.lastHarmonyImportOrder =
+					(parser.state.lastHarmonyImportOrder || 0) + 1;
+				const clearDep = new ConstDependency(
+					parser.isAsiPosition(statement.range[0]) ? ";" : "",
+					statement.range
+				);
+				clearDep.loc = statement.loc;
+				parser.state.module.addPresentationalDependency(clearDep);
+				parser.unsetAsiPosition(statement.range[1]);
+				const assertions = getAssertions(statement);
+				const sideEffectDep = new HarmonyImportSideEffectDependency(
+					source,
+					parser.state.lastHarmonyImportOrder,
+					assertions
+				);
+				sideEffectDep.loc = statement.loc;
+				parser.state.module.addDependency(sideEffectDep);
+				return true;
+			}
 		);
-
-		switch (type) {
-			case "expression":
-				if (!used) {
-					initFragments.push(
-						new InitFragment(
-							"var __webpack_unused_export__;\n",
-							InitFragment.STAGE_CONSTANTS,
-							0,
-							"__webpack_unused_export__"
-						)
-					);
-					source.replace(
-						dep.range[0],
-						dep.range[1] - 1,
-						"__webpack_unused_export__"
-					);
+		parser.hooks.importSpecifier.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(statement, source, id, name) => {
+				const ids = id === null ? [] : [id];
+				parser.tagVariable(name, harmonySpecifierTag, {
+					name,
+					source,
+					ids,
+					sourceOrder: parser.state.lastHarmonyImportOrder,
+					assertions: getAssertions(statement)
+				});
+				return true;
+			}
+		);
+		parser.hooks.expression
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", expr => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					settings.ids,
+					settings.name,
+					expr.range,
+					exportPresenceMode,
+					settings.assertions
+				);
+				dep.shorthand = parser.scope.inShorthand;
+				dep.directImport = true;
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		parser.hooks.expressionMemberChain
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const ids = settings.ids.concat(members);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					ids,
+					settings.name,
+					expr.range,
+					exportPresenceMode,
+					settings.assertions
+				);
+				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.loc = expr.loc;
+				parser.state.module.addDependency(dep);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		parser.hooks.callMemberChain
+			.for(harmonySpecifierTag)
+			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
+				const { arguments: args, callee } = expr;
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				const ids = settings.ids.concat(members);
+				const dep = new HarmonyImportSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					ids,
+					settings.name,
+					callee.range,
+					exportPresenceMode,
+					settings.assertions
+				);
+				dep.directImport = members.length === 0;
+				dep.call = true;
+				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
+				// only in case when we strictly follow the spec we need a special case here
+				dep.namespaceObjectAsContext =
+					members.length > 0 && this.strictThisContextOnImports;
+				dep.loc = callee.loc;
+				parser.state.module.addDependency(dep);
+				if (args) parser.walkExpressions(args);
+				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				return true;
+			});
+		const { hotAcceptCallback, hotAcceptWithoutCallback } =
+			HotModuleReplacementPlugin.getParserHooks(parser);
+		hotAcceptCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				if (!HarmonyExports.isEnabled(parser.state)) {
+					// This is not a harmony module, skip it
 					return;
 				}
-				source.replace(
-					dep.range[0],
-					dep.range[1] - 1,
-					`${base}${propertyAccess(used)}`
-				);
-				return;
-			case "Object.defineProperty":
-				if (!used) {
-					initFragments.push(
-						new InitFragment(
-							"var __webpack_unused_export__;\n",
-							InitFragment.STAGE_CONSTANTS,
-							0,
-							"__webpack_unused_export__"
-						)
-					);
-					source.replace(
-						dep.range[0],
-						dep.valueRange[0] - 1,
-						"__webpack_unused_export__ = ("
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(request);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						expr.range,
+						dependencies,
+						true
 					);
-					source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
+		hotAcceptWithoutCallback.tap(
+			"HarmonyImportDependencyParserPlugin",
+			(expr, requests) => {
+				if (!HarmonyExports.isEnabled(parser.state)) {
+					// This is not a harmony module, skip it
 					return;
 				}
-				source.replace(
-					dep.range[0],
-					dep.valueRange[0] - 1,
-					`Object.defineProperty(${base}${propertyAccess(
-						used.slice(0, -1)
-					)}, ${JSON.stringify(used[used.length - 1])}, (`
-				);
-				source.replace(dep.valueRange[1], dep.range[1] - 1, "))");
-				return;
-		}
+				const dependencies = requests.map(request => {
+					const dep = new HarmonyAcceptImportDependency(request);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+					return dep;
+				});
+				if (dependencies.length > 0) {
+					const dep = new HarmonyAcceptDependency(
+						expr.range,
+						dependencies,
+						false
+					);
+					dep.loc = expr.loc;
+					parser.state.module.addDependency(dep);
+				}
+			}
+		);
 	}
 };
 
-module.exports = CommonJsExportsDependency;
+module.exports.harmonySpecifierTag = harmonySpecifierTag;
+module.exports.getAssertions = getAssertions;
 
 
 /***/ }),
 
-/***/ 97107:
+/***/ 73132:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -80256,340 +79330,84 @@ module.exports = CommonJsExportsDependency;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const formatLocation = __webpack_require__(16734);
-const { evaluateToString } = __webpack_require__(93998);
-const propertyAccess = __webpack_require__(54190);
-const CommonJsExportRequireDependency = __webpack_require__(62892);
-const CommonJsExportsDependency = __webpack_require__(45598);
-const CommonJsSelfReferenceDependency = __webpack_require__(52225);
-const DynamicExports = __webpack_require__(32006);
-const HarmonyExports = __webpack_require__(39211);
-const ModuleDecoratorDependency = __webpack_require__(88488);
+const makeSerializable = __webpack_require__(33032);
+const HarmonyImportDependency = __webpack_require__(57154);
 
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../InitFragment")} InitFragment */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const getValueOfPropertyDescription = expr => {
-	if (expr.type !== "ObjectExpression") return;
-	for (const property of expr.properties) {
-		if (property.computed) continue;
-		const key = property.key;
-		if (key.type !== "Identifier" || key.name !== "value") continue;
-		return property.value;
+class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
+	constructor(request, sourceOrder, assertions) {
+		super(request, sourceOrder, assertions);
 	}
-};
 
-const isTruthyLiteral = expr => {
-	switch (expr.type) {
-		case "Literal":
-			return !!expr.value;
-		case "UnaryExpression":
-			if (expr.operator === "!") return isFalsyLiteral(expr.argument);
+	get type() {
+		return "harmony side effect evaluation";
 	}
-	return false;
-};
 
-const isFalsyLiteral = expr => {
-	switch (expr.type) {
-		case "Literal":
-			return !expr.value;
-		case "UnaryExpression":
-			if (expr.operator === "!") return isTruthyLiteral(expr.argument);
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return connection => {
+			const refModule = connection.resolvedModule;
+			if (!refModule) return true;
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
 	}
-	return false;
-};
 
-/**
- * @param {JavascriptParser} parser the parser
- * @param {ExpressionNode} expr expression
- * @returns {{ argument: BasicEvaluatedExpression, ids: string[] } | undefined} parsed call
- */
-const parseRequireCall = (parser, expr) => {
-	const ids = [];
-	while (expr.type === "MemberExpression") {
-		if (expr.object.type === "Super") return;
-		if (!expr.property) return;
-		const prop = expr.property;
-		if (expr.computed) {
-			if (prop.type !== "Literal") return;
-			ids.push(`${prop.value}`);
-		} else {
-			if (prop.type !== "Identifier") return;
-			ids.push(prop.name);
-		}
-		expr = expr.object;
-	}
-	if (expr.type !== "CallExpression" || expr.arguments.length !== 1) return;
-	const callee = expr.callee;
-	if (
-		callee.type !== "Identifier" ||
-		parser.getVariableInfo(callee.name) !== "require"
-	) {
-		return;
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		const refModule = moduleGraph.getModule(this);
+		if (!refModule) return true;
+		return refModule.getSideEffectsConnectionState(moduleGraph);
 	}
-	const arg = expr.arguments[0];
-	if (arg.type === "SpreadElement") return;
-	const argValue = parser.evaluateExpression(arg);
-	return { argument: argValue, ids: ids.reverse() };
-};
+}
 
-class CommonJsExportsParserPlugin {
-	constructor(moduleGraph) {
-		this.moduleGraph = moduleGraph;
-	}
+makeSerializable(
+	HarmonyImportSideEffectDependency,
+	"webpack/lib/dependencies/HarmonyImportSideEffectDependency"
+);
 
+HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {
 	/**
-	 * @param {JavascriptParser} parser the parser
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	apply(parser) {
-		const enableStructuredExports = () => {
-			DynamicExports.enable(parser.state);
-		};
-		const checkNamespace = (topLevel, members, valueExpr) => {
-			if (!DynamicExports.isEnabled(parser.state)) return;
-			if (members.length > 0 && members[0] === "__esModule") {
-				if (valueExpr && isTruthyLiteral(valueExpr) && topLevel) {
-					DynamicExports.setFlagged(parser.state);
-				} else {
-					DynamicExports.setDynamic(parser.state);
-				}
-			}
-		};
-		const bailout = reason => {
-			DynamicExports.bailout(parser.state);
-			if (reason) bailoutHint(reason);
-		};
-		const bailoutHint = reason => {
-			this.moduleGraph
-				.getOptimizationBailout(parser.state.module)
-				.push(`CommonJS bailout: ${reason}`);
-		};
-
-		// metadata //
-		parser.hooks.evaluateTypeof
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", evaluateToString("object"));
-		parser.hooks.evaluateTypeof
-			.for("exports")
-			.tap("CommonJsPlugin", evaluateToString("object"));
-
-		// exporting //
-		const handleAssignExport = (expr, base, members) => {
-			if (HarmonyExports.isEnabled(parser.state)) return;
-			// Handle reexporting
-			const requireCall = parseRequireCall(parser, expr.right);
-			if (
-				requireCall &&
-				requireCall.argument.isString() &&
-				(members.length === 0 || members[0] !== "__esModule")
-			) {
-				enableStructuredExports();
-				// It's possible to reexport __esModule, so we must convert to a dynamic module
-				if (members.length === 0) DynamicExports.setDynamic(parser.state);
-				const dep = new CommonJsExportRequireDependency(
-					expr.range,
-					null,
-					base,
-					members,
-					requireCall.argument.string,
-					requireCall.ids,
-					!parser.isStatementLevelExpression(expr)
-				);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.module.addDependency(dep);
-				return true;
-			}
-			if (members.length === 0) return;
-			enableStructuredExports();
-			const remainingMembers = members;
-			checkNamespace(
-				parser.statementPath.length === 1 &&
-					parser.isStatementLevelExpression(expr),
-				remainingMembers,
-				expr.right
-			);
-			const dep = new CommonJsExportsDependency(
-				expr.left.range,
-				null,
-				base,
-				remainingMembers
-			);
-			dep.loc = expr.loc;
-			parser.state.module.addDependency(dep);
-			parser.walkExpression(expr.right);
-			return true;
-		};
-		parser.hooks.assignMemberChain
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				return handleAssignExport(expr, "exports", members);
-			});
-		parser.hooks.assignMemberChain
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAssignExport(expr, "this", members);
-			});
-		parser.hooks.assignMemberChain
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (members[0] !== "exports") return;
-				return handleAssignExport(expr, "module.exports", members.slice(1));
-			});
-		parser.hooks.call
-			.for("Object.defineProperty")
-			.tap("CommonJsExportsParserPlugin", expression => {
-				const expr = /** @type {import("estree").CallExpression} */ (
-					expression
-				);
-				if (!parser.isStatementLevelExpression(expr)) return;
-				if (expr.arguments.length !== 3) return;
-				if (expr.arguments[0].type === "SpreadElement") return;
-				if (expr.arguments[1].type === "SpreadElement") return;
-				if (expr.arguments[2].type === "SpreadElement") return;
-				const exportsArg = parser.evaluateExpression(expr.arguments[0]);
-				if (!exportsArg || !exportsArg.isIdentifier()) return;
-				if (
-					exportsArg.identifier !== "exports" &&
-					exportsArg.identifier !== "module.exports" &&
-					(exportsArg.identifier !== "this" || !parser.scope.topLevelScope)
-				) {
-					return;
-				}
-				const propertyArg = parser.evaluateExpression(expr.arguments[1]);
-				if (!propertyArg) return;
-				const property = propertyArg.asString();
-				if (typeof property !== "string") return;
-				enableStructuredExports();
-				const descArg = expr.arguments[2];
-				checkNamespace(
-					parser.statementPath.length === 1,
-					[property],
-					getValueOfPropertyDescription(descArg)
-				);
-				const dep = new CommonJsExportsDependency(
-					expr.range,
-					expr.arguments[2].range,
-					`Object.defineProperty(${exportsArg.identifier})`,
-					[property]
-				);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
-
-				parser.walkExpression(expr.arguments[2]);
-				return true;
-			});
-
-		// Self reference //
-		const handleAccessExport = (expr, base, members, call = undefined) => {
-			if (HarmonyExports.isEnabled(parser.state)) return;
-			if (members.length === 0) {
-				bailout(`${base} is used directly at ${formatLocation(expr.loc)}`);
-			}
-			if (call && members.length === 1) {
-				bailoutHint(
-					`${base}${propertyAccess(
-						members
-					)}(...) prevents optimization as ${base} is passed as call context at ${formatLocation(
-						expr.loc
-					)}`
-				);
-			}
-			const dep = new CommonJsSelfReferenceDependency(
-				expr.range,
-				base,
-				members,
-				!!call
-			);
-			dep.loc = expr.loc;
-			parser.state.module.addDependency(dep);
-			if (call) {
-				parser.walkExpressions(call.arguments);
+	apply(dependency, source, templateContext) {
+		const { moduleGraph, concatenationScope } = templateContext;
+		if (concatenationScope) {
+			const module = moduleGraph.getModule(dependency);
+			if (concatenationScope.isModuleInScope(module)) {
+				return;
 			}
-			return true;
-		};
-		parser.hooks.callMemberChain
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				return handleAccessExport(expr.callee, "exports", members, expr);
-			});
-		parser.hooks.expressionMemberChain
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				return handleAccessExport(expr, "exports", members);
-			});
-		parser.hooks.expression
-			.for("exports")
-			.tap("CommonJsExportsParserPlugin", expr => {
-				return handleAccessExport(expr, "exports", []);
-			});
-		parser.hooks.callMemberChain
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (members[0] !== "exports") return;
-				return handleAccessExport(
-					expr.callee,
-					"module.exports",
-					members.slice(1),
-					expr
-				);
-			});
-		parser.hooks.expressionMemberChain
-			.for("module")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (members[0] !== "exports") return;
-				return handleAccessExport(expr, "module.exports", members.slice(1));
-			});
-		parser.hooks.expression
-			.for("module.exports")
-			.tap("CommonJsExportsParserPlugin", expr => {
-				return handleAccessExport(expr, "module.exports", []);
-			});
-		parser.hooks.callMemberChain
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr.callee, "this", members, expr);
-			});
-		parser.hooks.expressionMemberChain
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr, "this", members);
-			});
-		parser.hooks.expression
-			.for("this")
-			.tap("CommonJsExportsParserPlugin", expr => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr, "this", []);
-			});
-
-		// Bailouts //
-		parser.hooks.expression.for("module").tap("CommonJsPlugin", expr => {
-			bailout();
-			const isHarmony = HarmonyExports.isEnabled(parser.state);
-			const dep = new ModuleDecoratorDependency(
-				isHarmony
-					? RuntimeGlobals.harmonyModuleDecorator
-					: RuntimeGlobals.nodeModuleDecorator,
-				!isHarmony
-			);
-			dep.loc = expr.loc;
-			parser.state.module.addDependency(dep);
-			return true;
-		});
+		}
+		super.apply(dependency, source, templateContext);
 	}
-}
-module.exports = CommonJsExportsParserPlugin;
+};
+
+module.exports = HarmonyImportSideEffectDependency;
 
 
 /***/ }),
 
-/***/ 59440:
+/***/ 14077:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -80600,31 +79418,112 @@ module.exports = CommonJsExportsParserPlugin;
 
 
 
-const Template = __webpack_require__(39722);
-const { equals } = __webpack_require__(84953);
+const Dependency = __webpack_require__(54912);
+const {
+	getDependencyUsedByExportsCondition
+} = __webpack_require__(38988);
 const makeSerializable = __webpack_require__(33032);
 const propertyAccess = __webpack_require__(54190);
-const ModuleDependency = __webpack_require__(80321);
+const HarmonyImportDependency = __webpack_require__(57154);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class CommonJsFullRequireDependency extends ModuleDependency {
-	/**
-	 * @param {string} request the request string
-	 * @param {[number, number]} range location in source code
-	 * @param {string[]} names accessed properties on module
-	 */
-	constructor(request, range, names) {
-		super(request);
+const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
+
+const { ExportPresenceModes } = HarmonyImportDependency;
+
+class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
+	constructor(
+		request,
+		sourceOrder,
+		ids,
+		name,
+		range,
+		exportPresenceMode,
+		assertions
+	) {
+		super(request, sourceOrder, assertions);
+		this.ids = ids;
+		this.name = name;
 		this.range = range;
-		this.names = names;
-		this.call = false;
+		this.exportPresenceMode = exportPresenceMode;
+		this.namespaceObjectAsContext = false;
+		this.call = undefined;
+		this.directImport = undefined;
+		this.shorthand = undefined;
 		this.asiSafe = undefined;
+		/** @type {Set<string> | boolean} */
+		this.usedByExports = undefined;
+	}
+
+	// TODO webpack 6 remove
+	get id() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
+
+	// TODO webpack 6 remove
+	getId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
+
+	// TODO webpack 6 remove
+	setId() {
+		throw new Error("id was renamed to ids and type changed to string[]");
+	}
+
+	get type() {
+		return "harmony import specifier";
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string[]} the imported ids
+	 */
+	getIds(moduleGraph) {
+		const meta = moduleGraph.getMetaIfExisting(this);
+		if (meta === undefined) return this.ids;
+		const ids = meta[idsSymbol];
+		return ids !== undefined ? ids : this.ids;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string[]} ids the imported ids
+	 * @returns {void}
+	 */
+	setIds(moduleGraph, ids) {
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
 	/**
@@ -80634,106 +79533,220 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		if (this.call) {
+		let ids = this.getIds(moduleGraph);
+		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		let namespaceObjectAsContext = this.namespaceObjectAsContext;
+		if (ids[0] === "default") {
+			const selfModule = moduleGraph.getParentModule(this);
 			const importedModule = moduleGraph.getModule(this);
-			if (
-				!importedModule ||
-				importedModule.getExportsType(moduleGraph, false) !== "namespace"
+			switch (
+				importedModule.getExportsType(
+					moduleGraph,
+					selfModule.buildMeta.strictHarmonyModule
+				)
 			) {
-				return [this.names.slice(0, -1)];
+				case "default-only":
+				case "default-with-named":
+					if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
+					ids = ids.slice(1);
+					namespaceObjectAsContext = true;
+					break;
+				case "dynamic":
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
 			}
 		}
-		return [this.names];
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.names);
-		write(this.call);
-		write(this.asiSafe);
-		super.serialize(context);
-	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.names = read();
-		this.call = read();
-		this.asiSafe = read();
-		super.deserialize(context);
-	}
+		if (
+			this.call &&
+			!this.directImport &&
+			(namespaceObjectAsContext || ids.length > 1)
+		) {
+			if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
+			ids = ids.slice(0, -1);
+		}
 
-	get type() {
-		return "cjs full require";
+		return [ids];
 	}
 
-	get category() {
-		return "commonjs";
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {number} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+			return this.exportPresenceMode;
+		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
 	}
-}
 
-CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemplate extends (
-	ModuleDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} warnings
 	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph,
-			runtimeRequirements,
-			runtime,
-			initFragments
+	getWarnings(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.WARN) {
+			return this._getErrors(moduleGraph);
 		}
-	) {
-		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
-		if (!dep.range) return;
-		const importedModule = moduleGraph.getModule(dep);
-		let requireExpr = runtimeTemplate.moduleExports({
-			module: importedModule,
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-		if (importedModule) {
-			const ids = dep.names;
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(ids, runtime);
-			if (usedImported) {
-				const comment = equals(usedImported, ids)
-					? ""
-					: Template.toNormalComment(propertyAccess(ids)) + " ";
-				const access = `${comment}${propertyAccess(usedImported)}`;
-				requireExpr =
-					dep.asiSafe === true
-						? `(${requireExpr}${access})`
-						: `${requireExpr}${access}`;
-			}
+		return null;
+	}
+
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
+	 */
+	getErrors(moduleGraph) {
+		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
+		if (exportsPresence === ExportPresenceModes.ERROR) {
+			return this._getErrors(moduleGraph);
 		}
-		source.replace(dep.range[0], dep.range[1] - 1, requireExpr);
+		return null;
 	}
-};
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getErrors(moduleGraph) {
+		const ids = this.getIds(moduleGraph);
+		return this.getLinkingErrors(
+			moduleGraph,
+			ids,
+			`(imported as '${this.name}')`
+		);
+	}
+
+	/**
+	 * implement this method to allow the occurrence order plugin to count correctly
+	 * @returns {number} count how often the id is used in this dependency
+	 */
+	getNumberOfIdOccurrences() {
+		return 0;
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.ids);
+		write(this.name);
+		write(this.range);
+		write(this.exportPresenceMode);
+		write(this.namespaceObjectAsContext);
+		write(this.call);
+		write(this.directImport);
+		write(this.shorthand);
+		write(this.asiSafe);
+		write(this.usedByExports);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.ids = read();
+		this.name = read();
+		this.range = read();
+		this.exportPresenceMode = read();
+		this.namespaceObjectAsContext = read();
+		this.call = read();
+		this.directImport = read();
+		this.shorthand = read();
+		this.asiSafe = read();
+		this.usedByExports = read();
+		super.deserialize(context);
+	}
+}
 
 makeSerializable(
-	CommonJsFullRequireDependency,
-	"webpack/lib/dependencies/CommonJsFullRequireDependency"
+	HarmonyImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
 );
 
-module.exports = CommonJsFullRequireDependency;
+HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
+	HarmonyImportDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
+		const { moduleGraph, module, runtime, concatenationScope } =
+			templateContext;
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) return;
+
+		const ids = dep.getIds(moduleGraph);
+
+		let exportExpr;
+		if (
+			connection &&
+			concatenationScope &&
+			concatenationScope.isModuleInScope(connection.module)
+		) {
+			if (ids.length === 0) {
+				exportExpr = concatenationScope.createModuleReference(
+					connection.module,
+					{
+						asiSafe: dep.asiSafe
+					}
+				);
+			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
+				exportExpr =
+					concatenationScope.createModuleReference(connection.module, {
+						asiSafe: dep.asiSafe
+					}) + propertyAccess(ids);
+			} else {
+				exportExpr = concatenationScope.createModuleReference(
+					connection.module,
+					{
+						ids,
+						call: dep.call,
+						directImport: dep.directImport,
+						asiSafe: dep.asiSafe
+					}
+				);
+			}
+		} else {
+			super.apply(dependency, source, templateContext);
+
+			const { runtimeTemplate, initFragments, runtimeRequirements } =
+				templateContext;
+
+			exportExpr = runtimeTemplate.exportFromImport({
+				moduleGraph,
+				module: moduleGraph.getModule(dep),
+				request: dep.request,
+				exportName: ids,
+				originModule: module,
+				asiSafe: dep.shorthand ? true : dep.asiSafe,
+				isCall: dep.call,
+				callContext: !dep.directImport,
+				defaultInterop: true,
+				importVar: dep.getImportVar(moduleGraph),
+				initFragments,
+				runtime,
+				runtimeRequirements
+			});
+		}
+		if (dep.shorthand) {
+			source.insert(dep.range[1], `: ${exportExpr}`);
+		} else {
+			source.replace(dep.range[0], dep.range[1] - 1, exportExpr);
+		}
+	}
+};
+
+module.exports = HarmonyImportSpecifierDependency;
 
 
 /***/ }),
 
-/***/ 36013:
+/***/ 39029:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -80744,680 +79757,160 @@ module.exports = CommonJsFullRequireDependency;
 
 
 
-const CommentCompilationWarning = __webpack_require__(98427);
-const RuntimeGlobals = __webpack_require__(16475);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const {
-	evaluateToIdentifier,
-	evaluateToString,
-	expressionIsUnsupported,
-	toConstantDependency
-} = __webpack_require__(93998);
-const CommonJsFullRequireDependency = __webpack_require__(59440);
-const CommonJsRequireContextDependency = __webpack_require__(23962);
-const CommonJsRequireDependency = __webpack_require__(21264);
-const ConstDependency = __webpack_require__(76911);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const LocalModuleDependency = __webpack_require__(52805);
-const { getLocalModule } = __webpack_require__(75827);
-const RequireHeaderDependency = __webpack_require__(89183);
-const RequireResolveContextDependency = __webpack_require__(55627);
-const RequireResolveDependency = __webpack_require__(68582);
-const RequireResolveHeaderDependency = __webpack_require__(9880);
+const HarmonyAcceptDependency = __webpack_require__(23624);
+const HarmonyAcceptImportDependency = __webpack_require__(99843);
+const HarmonyCompatibilityDependency = __webpack_require__(72906);
+const HarmonyExportExpressionDependency = __webpack_require__(51340);
+const HarmonyExportHeaderDependency = __webpack_require__(38873);
+const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
+const HarmonyExportSpecifierDependency = __webpack_require__(48567);
+const HarmonyImportSideEffectDependency = __webpack_require__(73132);
+const HarmonyImportSpecifierDependency = __webpack_require__(14077);
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+const HarmonyDetectionParserPlugin = __webpack_require__(17223);
+const HarmonyExportDependencyParserPlugin = __webpack_require__(93466);
+const HarmonyImportDependencyParserPlugin = __webpack_require__(20862);
+const HarmonyTopLevelThisParserPlugin = __webpack_require__(63232);
 
-class CommonJsImportsParserPlugin {
-	/**
-	 * @param {JavascriptParserOptions} options parser options
-	 */
+/** @typedef {import("../Compiler")} Compiler */
+
+class HarmonyModulesPlugin {
 	constructor(options) {
 		this.options = options;
 	}
 
-	apply(parser) {
-		const options = this.options;
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"HarmonyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyTemplates.set(
+					HarmonyCompatibilityDependency,
+					new HarmonyCompatibilityDependency.Template()
+				);
 
-		// metadata //
-		const tapRequireExpression = (expression, getMembers) => {
-			parser.hooks.typeof
-				.for(expression)
-				.tap(
-					"CommonJsPlugin",
-					toConstantDependency(parser, JSON.stringify("function"))
+				compilation.dependencyFactories.set(
+					HarmonyImportSideEffectDependency,
+					normalModuleFactory
 				);
-			parser.hooks.evaluateTypeof
-				.for(expression)
-				.tap("CommonJsPlugin", evaluateToString("function"));
-			parser.hooks.evaluateIdentifier
-				.for(expression)
-				.tap(
-					"CommonJsPlugin",
-					evaluateToIdentifier(expression, "require", getMembers, true)
+				compilation.dependencyTemplates.set(
+					HarmonyImportSideEffectDependency,
+					new HarmonyImportSideEffectDependency.Template()
 				);
-		};
-		tapRequireExpression("require", () => []);
-		tapRequireExpression("require.resolve", () => ["resolve"]);
-		tapRequireExpression("require.resolveWeak", () => ["resolveWeak"]);
 
-		// Weird stuff //
-		parser.hooks.assign.for("require").tap("CommonJsPlugin", expr => {
-			// to not leak to global "require", we need to define a local require here.
-			const dep = new ConstDependency("var require;", 0);
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return true;
-		});
+				compilation.dependencyFactories.set(
+					HarmonyImportSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportSpecifierDependency,
+					new HarmonyImportSpecifierDependency.Template()
+				);
 
-		// Unsupported //
-		parser.hooks.expression
-			.for("require.main.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"require.main.require is not supported by webpack."
-				)
-			);
-		parser.hooks.call
-			.for("require.main.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"require.main.require is not supported by webpack."
-				)
-			);
-		parser.hooks.expression
-			.for("module.parent.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"module.parent.require is not supported by webpack."
-				)
-			);
-		parser.hooks.call
-			.for("module.parent.require")
-			.tap(
-				"CommonJsPlugin",
-				expressionIsUnsupported(
-					parser,
-					"module.parent.require is not supported by webpack."
-				)
-			);
+				compilation.dependencyTemplates.set(
+					HarmonyExportHeaderDependency,
+					new HarmonyExportHeaderDependency.Template()
+				);
 
-		// renaming //
-		parser.hooks.canRename.for("require").tap("CommonJsPlugin", () => true);
-		parser.hooks.rename.for("require").tap("CommonJsPlugin", expr => {
-			// To avoid "not defined" error, replace the value with undefined
-			const dep = new ConstDependency("undefined", expr.range);
-			dep.loc = expr.loc;
-			parser.state.module.addPresentationalDependency(dep);
-			return false;
-		});
+				compilation.dependencyTemplates.set(
+					HarmonyExportExpressionDependency,
+					new HarmonyExportExpressionDependency.Template()
+				);
 
-		// inspection //
-		parser.hooks.expression
-			.for("require.cache")
-			.tap(
-				"CommonJsImportsParserPlugin",
-				toConstantDependency(parser, RuntimeGlobals.moduleCache, [
-					RuntimeGlobals.moduleCache,
-					RuntimeGlobals.moduleId,
-					RuntimeGlobals.moduleLoaded
-				])
-			);
+				compilation.dependencyTemplates.set(
+					HarmonyExportSpecifierDependency,
+					new HarmonyExportSpecifierDependency.Template()
+				);
 
-		// require as expression //
-		parser.hooks.expression
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", expr => {
-				const dep = new CommonJsRequireContextDependency(
-					{
-						request: options.unknownContextRequest,
-						recursive: options.unknownContextRecursive,
-						regExp: options.unknownContextRegExp,
-						mode: "sync"
-					},
-					expr.range,
-					undefined,
-					parser.scope.inShorthand
+				compilation.dependencyFactories.set(
+					HarmonyExportImportedSpecifierDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyExportImportedSpecifierDependency,
+					new HarmonyExportImportedSpecifierDependency.Template()
 				);
-				dep.critical =
-					options.unknownContextCritical &&
-					"require function is used in a way in which dependencies cannot be statically extracted";
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			});
 
-		// require //
-		const processRequireItem = (expr, param) => {
-			if (param.isString()) {
-				const dep = new CommonJsRequireDependency(param.string, param.range);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		const processRequireContext = (expr, param) => {
-			const dep = ContextDependencyHelpers.create(
-				CommonJsRequireContextDependency,
-				expr.range,
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs"
-				},
-				parser
-			);
-			if (!dep) return;
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.current.addDependency(dep);
-			return true;
-		};
-		const createRequireHandler = callNew => expr => {
-			if (options.commonjsMagicComments) {
-				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(expr.range);
+				compilation.dependencyTemplates.set(
+					HarmonyAcceptDependency,
+					new HarmonyAcceptDependency.Template()
+				);
 
-				if (commentErrors) {
-					for (const e of commentErrors) {
-						const { comment } = e;
-						parser.state.module.addWarning(
-							new CommentCompilationWarning(
-								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-								comment.loc
-							)
-						);
-					}
-				}
-				if (requireOptions) {
-					if (requireOptions.webpackIgnore !== undefined) {
-						if (typeof requireOptions.webpackIgnore !== "boolean") {
-							parser.state.module.addWarning(
-								new UnsupportedFeatureWarning(
-									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-									expr.loc
-								)
-							);
-						} else {
-							// Do not instrument `require()` if `webpackIgnore` is `true`
-							if (requireOptions.webpackIgnore) {
-								return true;
-							}
-						}
-					}
-				}
-			}
+				compilation.dependencyFactories.set(
+					HarmonyAcceptImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyAcceptImportDependency,
+					new HarmonyAcceptImportDependency.Template()
+				);
 
-			if (expr.arguments.length !== 1) return;
-			let localModule;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				let isExpression = false;
-				for (const p of param.options) {
-					const result = processRequireItem(expr, p);
-					if (result === undefined) {
-						isExpression = true;
-					}
-				}
-				if (!isExpression) {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
+				const handler = (parser, parserOptions) => {
+					// TODO webpack 6: rename harmony to esm or module
+					if (parserOptions.harmony !== undefined && !parserOptions.harmony)
+						return;
+
+					new HarmonyDetectionParserPlugin(this.options).apply(parser);
+					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyTopLevelThisParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("HarmonyModulesPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("HarmonyModulesPlugin", handler);
 			}
-			if (
-				param.isString() &&
-				(localModule = getLocalModule(parser.state, param.string))
-			) {
-				localModule.flagUsed();
-				const dep = new LocalModuleDependency(localModule, expr.range, callNew);
-				dep.loc = expr.loc;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			} else {
-				const result = processRequireItem(expr, param);
-				if (result === undefined) {
-					processRequireContext(expr, param);
-				} else {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
-					parser.state.module.addPresentationalDependency(dep);
-				}
-				return true;
-			}
-		};
-		parser.hooks.call
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
-		parser.hooks.new
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
-		parser.hooks.call
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
-		parser.hooks.new
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", createRequireHandler(true));
-
-		// require with property access //
-		const chainHandler = (expr, calleeMembers, callExpr, members) => {
-			if (callExpr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
-				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.range,
-					members
-				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.loc;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		const callChainHandler = (expr, calleeMembers, callExpr, members) => {
-			if (callExpr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
-				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.callee.range,
-					members
-				);
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.callee.loc;
-				parser.state.current.addDependency(dep);
-				parser.walkExpressions(expr.arguments);
-				return true;
-			}
-		};
-		parser.hooks.memberChainOfCallMemberChain
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", chainHandler);
-		parser.hooks.memberChainOfCallMemberChain
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", chainHandler);
-		parser.hooks.callMemberChainOfCallMemberChain
-			.for("require")
-			.tap("CommonJsImportsParserPlugin", callChainHandler);
-		parser.hooks.callMemberChainOfCallMemberChain
-			.for("module.require")
-			.tap("CommonJsImportsParserPlugin", callChainHandler);
-
-		// require.resolve //
-		const processResolve = (expr, weak) => {
-			if (expr.arguments.length !== 1) return;
-			const param = parser.evaluateExpression(expr.arguments[0]);
-			if (param.isConditional()) {
-				for (const option of param.options) {
-					const result = processResolveItem(expr, option, weak);
-					if (result === undefined) {
-						processResolveContext(expr, option, weak);
-					}
-				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			} else {
-				const result = processResolveItem(expr, param, weak);
-				if (result === undefined) {
-					processResolveContext(expr, param, weak);
-				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			}
-		};
-		const processResolveItem = (expr, param, weak) => {
-			if (param.isString()) {
-				const dep = new RequireResolveDependency(param.string, param.range);
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				dep.weak = weak;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		};
-		const processResolveContext = (expr, param, weak) => {
-			const dep = ContextDependencyHelpers.create(
-				RequireResolveContextDependency,
-				param.range,
-				param,
-				expr,
-				options,
-				{
-					category: "commonjs",
-					mode: weak ? "weak" : "sync"
-				},
-				parser
-			);
-			if (!dep) return;
-			dep.loc = expr.loc;
-			dep.optional = !!parser.scope.inTry;
-			parser.state.current.addDependency(dep);
-			return true;
-		};
-
-		parser.hooks.call
-			.for("require.resolve")
-			.tap("RequireResolveDependencyParserPlugin", expr => {
-				return processResolve(expr, false);
-			});
-		parser.hooks.call
-			.for("require.resolveWeak")
-			.tap("RequireResolveDependencyParserPlugin", expr => {
-				return processResolve(expr, true);
-			});
+		);
 	}
 }
-module.exports = CommonJsImportsParserPlugin;
+module.exports = HarmonyModulesPlugin;
 
 
 /***/ }),
 
-/***/ 32406:
+/***/ 63232:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const SelfModuleFactory = __webpack_require__(63560);
-const Template = __webpack_require__(39722);
-const CommonJsExportsDependency = __webpack_require__(45598);
-const CommonJsFullRequireDependency = __webpack_require__(59440);
-const CommonJsRequireContextDependency = __webpack_require__(23962);
-const CommonJsRequireDependency = __webpack_require__(21264);
-const CommonJsSelfReferenceDependency = __webpack_require__(52225);
-const ModuleDecoratorDependency = __webpack_require__(88488);
-const RequireHeaderDependency = __webpack_require__(89183);
-const RequireResolveContextDependency = __webpack_require__(55627);
-const RequireResolveDependency = __webpack_require__(68582);
-const RequireResolveHeaderDependency = __webpack_require__(9880);
-const RuntimeRequirementsDependency = __webpack_require__(24187);
-
-const CommonJsExportsParserPlugin = __webpack_require__(97107);
-const CommonJsImportsParserPlugin = __webpack_require__(36013);
-
-const {
-	evaluateToIdentifier,
-	toConstantDependency
-} = __webpack_require__(93998);
-const CommonJsExportRequireDependency = __webpack_require__(62892);
-
-class CommonJsPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"CommonJsPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					CommonJsRequireDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsRequireDependency,
-					new CommonJsRequireDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					CommonJsFullRequireDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsFullRequireDependency,
-					new CommonJsFullRequireDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					CommonJsRequireContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsRequireContextDependency,
-					new CommonJsRequireContextDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					RequireResolveDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireResolveDependency,
-					new RequireResolveDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					RequireResolveContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireResolveContextDependency,
-					new RequireResolveContextDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					RequireResolveHeaderDependency,
-					new RequireResolveHeaderDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					RequireHeaderDependency,
-					new RequireHeaderDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					CommonJsExportsDependency,
-					new CommonJsExportsDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					CommonJsExportRequireDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsExportRequireDependency,
-					new CommonJsExportRequireDependency.Template()
-				);
-
-				const selfFactory = new SelfModuleFactory(compilation.moduleGraph);
-
-				compilation.dependencyFactories.set(
-					CommonJsSelfReferenceDependency,
-					selfFactory
-				);
-				compilation.dependencyTemplates.set(
-					CommonJsSelfReferenceDependency,
-					new CommonJsSelfReferenceDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					ModuleDecoratorDependency,
-					selfFactory
-				);
-				compilation.dependencyTemplates.set(
-					ModuleDecoratorDependency,
-					new ModuleDecoratorDependency.Template()
-				);
-
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.harmonyModuleDecorator)
-					.tap("CommonJsPlugin", (module, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.nodeModuleDecorator)
-					.tap("CommonJsPlugin", (module, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.harmonyModuleDecorator)
-					.tap("CommonJsPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new HarmonyModuleDecoratorRuntimeModule()
-						);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.nodeModuleDecorator)
-					.tap("CommonJsPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new NodeModuleDecoratorRuntimeModule()
-						);
-					});
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.commonjs !== undefined && !parserOptions.commonjs)
-						return;
-					parser.hooks.typeof
-						.for("module")
-						.tap(
-							"CommonJsPlugin",
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-
-					parser.hooks.expression
-						.for("require.main")
-						.tap(
-							"CommonJsPlugin",
-							toConstantDependency(
-								parser,
-								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}]`,
-								[RuntimeGlobals.moduleCache, RuntimeGlobals.entryModuleId]
-							)
-						);
-					parser.hooks.expression
-						.for("module.loaded")
-						.tap("CommonJsPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"module.loaded";
-							const dep = new RuntimeRequirementsDependency([
-								RuntimeGlobals.moduleLoaded
-							]);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-
-					parser.hooks.expression
-						.for("module.id")
-						.tap("CommonJsPlugin", expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
-								"module.id";
-							const dep = new RuntimeRequirementsDependency([
-								RuntimeGlobals.moduleId
-							]);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-
-					parser.hooks.evaluateIdentifier.for("module.hot").tap(
-						"CommonJsPlugin",
-						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
-					);
-
-					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
-					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
-						parser
-					);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("CommonJsPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("CommonJsPlugin", handler);
-			}
-		);
-	}
-}
-
-class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("harmony module decorator");
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${
-				RuntimeGlobals.harmonyModuleDecorator
-			} = ${runtimeTemplate.basicFunction("module", [
-				"module = Object.create(module);",
-				"if (!module.children) module.children = [];",
-				"Object.defineProperty(module, 'exports', {",
-				Template.indent([
-					"enumerable: true,",
-					`set: ${runtimeTemplate.basicFunction("", [
-						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
-					])}`
-				]),
-				"});",
-				"return module;"
-			])};`
-		]);
-	}
-}
-
-class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("node module decorator");
-	}
+const ConstDependency = __webpack_require__(76911);
+const HarmonyExports = __webpack_require__(39211);
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
-				"module",
-				[
-					"module.paths = [];",
-					"if (!module.children) module.children = [];",
-					"return module;"
-				]
-			)};`
-		]);
+class HarmonyTopLevelThisParserPlugin {
+	apply(parser) {
+		parser.hooks.expression
+			.for("this")
+			.tap("HarmonyTopLevelThisParserPlugin", node => {
+				if (!parser.scope.topLevelScope) return;
+				if (HarmonyExports.isEnabled(parser.state)) {
+					const dep = new ConstDependency("undefined", node.range, null);
+					dep.loc = node.loc;
+					parser.state.module.addPresentationalDependency(dep);
+					return this;
+				}
+			});
 	}
 }
 
-module.exports = CommonJsPlugin;
+module.exports = HarmonyTopLevelThisParserPlugin;
 
 
 /***/ }),
 
-/***/ 23962:
+/***/ 1902:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81432,18 +79925,20 @@ const makeSerializable = __webpack_require__(33032);
 const ContextDependency = __webpack_require__(88101);
 const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
 
-class CommonJsRequireContextDependency extends ContextDependency {
-	constructor(options, range, valueRange, inShorthand) {
+class ImportContextDependency extends ContextDependency {
+	constructor(options, range, valueRange) {
 		super(options);
 
 		this.range = range;
 		this.valueRange = valueRange;
-		// inShorthand must be serialized by subclasses that use it
-		this.inShorthand = inShorthand;
 	}
 
 	get type() {
-		return "cjs require context";
+		return `import() context ${this.options.mode}`;
+	}
+
+	get category() {
+		return "esm";
 	}
 
 	serialize(context) {
@@ -81451,7 +79946,6 @@ class CommonJsRequireContextDependency extends ContextDependency {
 
 		write(this.range);
 		write(this.valueRange);
-		write(this.inShorthand);
 
 		super.serialize(context);
 	}
@@ -81461,26 +79955,24 @@ class CommonJsRequireContextDependency extends ContextDependency {
 
 		this.range = read();
 		this.valueRange = read();
-		this.inShorthand = read();
 
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	CommonJsRequireContextDependency,
-	"webpack/lib/dependencies/CommonJsRequireContextDependency"
+	ImportContextDependency,
+	"webpack/lib/dependencies/ImportContextDependency"
 );
 
-CommonJsRequireContextDependency.Template =
-	ContextDependencyTemplateAsRequireCall;
+ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
 
-module.exports = CommonJsRequireContextDependency;
+module.exports = ImportContextDependency;
 
 
 /***/ }),
 
-/***/ 21264:
+/***/ 89376:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81491,122 +79983,69 @@ module.exports = CommonJsRequireContextDependency;
 
 
 
+const Dependency = __webpack_require__(54912);
 const makeSerializable = __webpack_require__(33032);
 const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-class CommonJsRequireDependency extends ModuleDependency {
-	constructor(request, range) {
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {[number, number]} range expression range
+	 * @param {string[][]=} referencedExports list of referenced exports
+	 */
+	constructor(request, range, referencedExports) {
 		super(request);
 		this.range = range;
+		this.referencedExports = referencedExports;
 	}
 
 	get type() {
-		return "cjs require";
+		return "import()";
 	}
 
 	get category() {
-		return "commonjs";
+		return "esm";
 	}
-}
-
-CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
-
-makeSerializable(
-	CommonJsRequireDependency,
-	"webpack/lib/dependencies/CommonJsRequireDependency"
-);
 
-module.exports = CommonJsRequireDependency;
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return this.referencedExports
+			? this.referencedExports.map(e => ({
+					name: e,
+					canMangle: false
+			  }))
+			: Dependency.EXPORTS_OBJECT_REFERENCED;
+	}
 
+	serialize(context) {
+		context.write(this.range);
+		context.write(this.referencedExports);
+		super.serialize(context);
+	}
 
-/***/ }),
+	deserialize(context) {
+		this.range = context.read();
+		this.referencedExports = context.read();
+		super.deserialize(context);
+	}
+}
 
-/***/ 52225:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+makeSerializable(ImportDependency, "webpack/lib/dependencies/ImportDependency");
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const { equals } = __webpack_require__(84953);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class CommonJsSelfReferenceDependency extends NullDependency {
-	constructor(range, base, names, call) {
-		super();
-		this.range = range;
-		this.base = base;
-		this.names = names;
-		this.call = call;
-	}
-
-	get type() {
-		return "cjs self exports reference";
-	}
-
-	get category() {
-		return "self";
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `self`;
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return [this.call ? this.names.slice(0, -1) : this.names];
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.base);
-		write(this.names);
-		write(this.call);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.base = read();
-		this.names = read();
-		this.call = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	CommonJsSelfReferenceDependency,
-	"webpack/lib/dependencies/CommonJsSelfReferenceDependency"
-);
-
-CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependencyTemplate extends (
-	NullDependency.Template
+ImportDependency.Template = class ImportDependencyTemplate extends (
+	ModuleDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -81617,61 +80056,32 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 	apply(
 		dependency,
 		source,
-		{ module, moduleGraph, runtime, runtimeRequirements }
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
-		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
-		let used;
-		if (dep.names.length === 0) {
-			used = dep.names;
-		} else {
-			used = moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime);
-		}
-		if (!used) {
-			throw new Error(
-				"Self-reference dependency has unused export name: This should not happen"
-			);
-		}
-
-		let base = undefined;
-		switch (dep.base) {
-			case "exports":
-				runtimeRequirements.add(RuntimeGlobals.exports);
-				base = module.exportsArgument;
-				break;
-			case "module.exports":
-				runtimeRequirements.add(RuntimeGlobals.module);
-				base = `${module.moduleArgument}.exports`;
-				break;
-			case "this":
-				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-				base = "this";
-				break;
-			default:
-				throw new Error(`Unsupported base ${dep.base}`);
-		}
-
-		if (base === dep.base && equals(used, dep.names)) {
-			// Nothing has to be changed
-			// We don't use a replacement for compat reasons
-			// for plugins that update `module._source` which they
-			// shouldn't do!
-			return;
-		}
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`${base}${propertyAccess(used)}`
+		const dep = /** @type {ImportDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
 		);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			block: block,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			strict: module.buildMeta.strictHarmonyModule,
+			message: "import()",
+			runtimeRequirements
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 };
 
-module.exports = CommonJsSelfReferenceDependency;
+module.exports = ImportDependency;
 
 
 /***/ }),
 
-/***/ 76911:
+/***/ 50718:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -81683,82 +80093,40 @@ module.exports = CommonJsSelfReferenceDependency;
 
 
 const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const ImportDependency = __webpack_require__(89376);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-
-class ConstDependency extends NullDependency {
-	/**
-	 * @param {string} expression the expression
-	 * @param {number|[number, number]} range the source range
-	 * @param {string[]=} runtimeRequirements runtime requirements
-	 */
-	constructor(expression, range, runtimeRequirements) {
-		super();
-		this.expression = expression;
-		this.range = range;
-		this.runtimeRequirements = runtimeRequirements
-			? new Set(runtimeRequirements)
-			: null;
-		this._hashUpdate = undefined;
-	}
-
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			let hashUpdate = "" + this.range + "|" + this.expression;
-			if (this.runtimeRequirements) {
-				for (const item of this.runtimeRequirements) {
-					hashUpdate += "|";
-					hashUpdate += item;
-				}
-			}
-			this._hashUpdate = hashUpdate;
-		}
-		hash.update(this._hashUpdate);
-	}
 
+class ImportEagerDependency extends ImportDependency {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @param {string} request the request
+	 * @param {[number, number]} range expression range
+	 * @param {string[][]=} referencedExports list of referenced exports
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
+	constructor(request, range, referencedExports) {
+		super(request, range, referencedExports);
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.expression);
-		write(this.range);
-		write(this.runtimeRequirements);
-		super.serialize(context);
+	get type() {
+		return "import() eager";
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.expression = read();
-		this.range = read();
-		this.runtimeRequirements = read();
-		super.deserialize(context);
+	get category() {
+		return "esm";
 	}
 }
 
-makeSerializable(ConstDependency, "webpack/lib/dependencies/ConstDependency");
+makeSerializable(
+	ImportEagerDependency,
+	"webpack/lib/dependencies/ImportEagerDependency"
+);
 
-ConstDependency.Template = class ConstDependencyTemplate extends (
-	NullDependency.Template
+ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
+	ImportDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -81766,423 +80134,329 @@ ConstDependency.Template = class ConstDependencyTemplate extends (
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {ConstDependency} */ (dependency);
-		if (dep.runtimeRequirements) {
-			for (const req of dep.runtimeRequirements) {
-				templateContext.runtimeRequirements.add(req);
-			}
-		}
-		if (typeof dep.range === "number") {
-			source.insert(dep.range, dep.expression);
-			return;
-		}
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportEagerDependency} */ (dependency);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			strict: module.buildMeta.strictHarmonyModule,
+			message: "import() eager",
+			runtimeRequirements
+		});
 
-		source.replace(dep.range[0], dep.range[1] - 1, dep.expression);
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 };
 
-module.exports = ConstDependency;
+module.exports = ImportEagerDependency;
 
 
 /***/ }),
 
-/***/ 88101:
+/***/ 51274:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const DependencyTemplate = __webpack_require__(5160);
 const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
+class ImportMetaHotAcceptDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
 
-const getCriticalDependencyWarning = memoize(() =>
-	__webpack_require__(15427)
-);
+	get type() {
+		return "import.meta.webpackHot.accept";
+	}
 
-/** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
+	get category() {
+		return "esm";
+	}
+}
 
-const regExpToString = r => (r ? r + "" : "");
+makeSerializable(
+	ImportMetaHotAcceptDependency,
+	"webpack/lib/dependencies/ImportMetaHotAcceptDependency"
+);
 
-class ContextDependency extends Dependency {
-	/**
-	 * @param {ContextDependencyOptions} options options for the context module
-	 */
-	constructor(options) {
-		super();
+ImportMetaHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
 
-		this.options = options;
-		this.userRequest = this.options && this.options.request;
-		/** @type {false | string} */
-		this.critical = false;
-		this.hadGlobalOrStickyRegExp = false;
+module.exports = ImportMetaHotAcceptDependency;
 
-		if (
-			this.options &&
-			(this.options.regExp.global || this.options.regExp.sticky)
-		) {
-			this.options = { ...this.options, regExp: null };
-			this.hadGlobalOrStickyRegExp = true;
-		}
 
-		this.request = undefined;
-		this.range = undefined;
-		this.valueRange = undefined;
-		this.inShorthand = undefined;
-		// TODO refactor this
-		this.replaces = undefined;
-	}
+/***/ }),
 
-	get category() {
-		return "commonjs";
-	}
+/***/ 53141:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return true;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return (
-			`context${this.options.request} ${this.options.recursive} ` +
-			`${regExpToString(this.options.regExp)} ${regExpToString(
-				this.options.include
-			)} ${regExpToString(this.options.exclude)} ` +
-			`${this.options.mode} ${this.options.chunkName} ` +
-			`${JSON.stringify(this.options.groupOptions)}`
-		);
-	}
 
-	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
-	 */
-	getWarnings(moduleGraph) {
-		let warnings = super.getWarnings(moduleGraph);
 
-		if (this.critical) {
-			if (!warnings) warnings = [];
-			const CriticalDependencyWarning = getCriticalDependencyWarning();
-			warnings.push(new CriticalDependencyWarning(this.critical));
-		}
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-		if (this.hadGlobalOrStickyRegExp) {
-			if (!warnings) warnings = [];
-			const CriticalDependencyWarning = getCriticalDependencyWarning();
-			warnings.push(
-				new CriticalDependencyWarning(
-					"Contexts can't use RegExps with the 'g' or 'y' flags."
-				)
-			);
-		}
+class ImportMetaHotDeclineDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
 
-		return warnings;
+		this.range = range;
+		this.weak = true;
 	}
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.options);
-		write(this.userRequest);
-		write(this.critical);
-		write(this.hadGlobalOrStickyRegExp);
-		write(this.request);
-		write(this.range);
-		write(this.valueRange);
-		write(this.prepend);
-		write(this.replaces);
-
-		super.serialize(context);
+	get type() {
+		return "import.meta.webpackHot.decline";
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.options = read();
-		this.userRequest = read();
-		this.critical = read();
-		this.hadGlobalOrStickyRegExp = read();
-		this.request = read();
-		this.range = read();
-		this.valueRange = read();
-		this.prepend = read();
-		this.replaces = read();
-
-		super.deserialize(context);
+	get category() {
+		return "esm";
 	}
 }
 
 makeSerializable(
-	ContextDependency,
-	"webpack/lib/dependencies/ContextDependency"
+	ImportMetaHotDeclineDependency,
+	"webpack/lib/dependencies/ImportMetaHotDeclineDependency"
 );
 
-ContextDependency.Template = DependencyTemplate;
+ImportMetaHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
 
-module.exports = ContextDependency;
+module.exports = ImportMetaHotDeclineDependency;
 
 
 /***/ }),
 
-/***/ 99630:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 17228:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { parseResource } = __webpack_require__(82186);
+const { pathToFileURL } = __webpack_require__(57310);
+const ModuleDependencyWarning = __webpack_require__(29656);
+const Template = __webpack_require__(1626);
+const BasicEvaluatedExpression = __webpack_require__(950);
+const {
+	evaluateToIdentifier,
+	toConstantDependency,
+	evaluateToString,
+	evaluateToNumber
+} = __webpack_require__(93998);
+const memoize = __webpack_require__(78676);
+const propertyAccess = __webpack_require__(54190);
+const ConstDependency = __webpack_require__(76911);
 
-/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./ContextDependency")} ContextDependency */
-/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
-
-/**
- * Escapes regular expression metacharacters
- * @param {string} str String to quote
- * @returns {string} Escaped string
- */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
 
-const splitContextFromPrefix = prefix => {
-	const idx = prefix.lastIndexOf("/");
-	let context = ".";
-	if (idx >= 0) {
-		context = prefix.substr(0, idx);
-		prefix = `.${prefix.substr(idx)}`;
-	}
-	return {
-		context,
-		prefix
-	};
-};
+const getCriticalDependencyWarning = memoize(() =>
+	__webpack_require__(15427)
+);
 
-/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
+class ImportMetaPlugin {
+	/**
+	 * @param {Compiler} compiler compiler
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ImportMetaPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/**
+				 * @param {NormalModule} module module
+				 * @returns {string} file url
+				 */
+				const getUrl = module => {
+					return pathToFileURL(module.resource).toString();
+				};
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
+				const parserHandler = (parser, { importMeta }) => {
+					if (importMeta === false) {
+						const { importMetaName } = compilation.outputOptions;
+						if (importMetaName === "import.meta") return;
 
-/** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
+						parser.hooks.expression
+							.for("import.meta")
+							.tap("ImportMetaPlugin", metaProperty => {
+								const dep = new ConstDependency(
+									importMetaName,
+									metaProperty.range
+								);
+								dep.loc = metaProperty.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+						return;
+					}
 
-/**
- * @param {ContextDependencyConstructor} Dep the Dependency class
- * @param {[number, number]} range source range
- * @param {BasicEvaluatedExpression} param context param
- * @param {EsTreeNode} expr expr
- * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
- * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
- * @param {JavascriptParser} parser the parser
- * @returns {ContextDependency} the created Dependency
- */
-exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
-	if (param.isTemplateString()) {
-		let prefixRaw = param.quasis[0].string;
-		let postfixRaw =
-			param.quasis.length > 1
-				? param.quasis[param.quasis.length - 1].string
-				: "";
-
-		const valueRange = param.range;
-		const { context, prefix } = splitContextFromPrefix(prefixRaw);
-		const {
-			path: postfix,
-			query,
-			fragment
-		} = parseResource(postfixRaw, parser);
-
-		// When there are more than two quasis, the generated RegExp can be more precise
-		// We join the quasis with the expression regexp
-		const innerQuasis = param.quasis.slice(1, param.quasis.length - 1);
-		const innerRegExp =
-			options.wrappedContextRegExp.source +
-			innerQuasis
-				.map(q => quoteMeta(q.string) + options.wrappedContextRegExp.source)
-				.join("");
+					/// import.meta direct ///
+					parser.hooks.typeof
+						.for("import.meta")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.expression
+						.for("import.meta")
+						.tap("ImportMetaPlugin", metaProperty => {
+							const CriticalDependencyWarning = getCriticalDependencyWarning();
+							parser.state.module.addWarning(
+								new ModuleDependencyWarning(
+									parser.state.module,
+									new CriticalDependencyWarning(
+										"Accessing import.meta directly is unsupported (only property access is supported)"
+									),
+									metaProperty.loc
+								)
+							);
+							const dep = new ConstDependency(
+								`${parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""}({})`,
+								metaProperty.range
+							);
+							dep.loc = metaProperty.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta")
+						.tap("ImportMetaPlugin", evaluateToString("object"));
+					parser.hooks.evaluateIdentifier.for("import.meta").tap(
+						"ImportMetaPlugin",
+						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
+					);
 
-		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
-		// context: "./context"
-		// prefix: "./pre"
-		// innerQuasis: [BEE("inner"), BEE("inner2")]
-		// (BEE = BasicEvaluatedExpression)
-		// postfix: "post"
-		// query: "?query"
-		// fragment: "#frag"
-		// regExp: /^\.\/pre.*inner.*inner2.*post$/
-		const regExp = new RegExp(
-			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
-		);
-		const dep = new Dep(
-			{
-				request: context + query + fragment,
-				recursive: options.wrappedContextRecursive,
-				regExp,
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			valueRange
-		);
-		dep.loc = expr.loc;
-		const replaces = [];
+					/// import.meta.url ///
+					parser.hooks.typeof
+						.for("import.meta.url")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify("string"))
+						);
+					parser.hooks.expression
+						.for("import.meta.url")
+						.tap("ImportMetaPlugin", expr => {
+							const dep = new ConstDependency(
+								JSON.stringify(getUrl(parser.state.module)),
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta.url")
+						.tap("ImportMetaPlugin", evaluateToString("string"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.url")
+						.tap("ImportMetaPlugin", expr => {
+							return new BasicEvaluatedExpression()
+								.setString(getUrl(parser.state.module))
+								.setRange(expr.range);
+						});
 
-		param.parts.forEach((part, i) => {
-			if (i % 2 === 0) {
-				// Quasis or merged quasi
-				let range = part.range;
-				let value = part.string;
-				if (param.templateStringKind === "cooked") {
-					value = JSON.stringify(value);
-					value = value.slice(1, value.length - 1);
-				}
-				if (i === 0) {
-					// prefix
-					value = prefix;
-					range = [param.range[0], part.range[1]];
-					value =
-						(param.templateStringKind === "cooked" ? "`" : "String.raw`") +
-						value;
-				} else if (i === param.parts.length - 1) {
-					// postfix
-					value = postfix;
-					range = [part.range[0], param.range[1]];
-					value = value + "`";
-				} else if (
-					part.expression &&
-					part.expression.type === "TemplateElement" &&
-					part.expression.value.raw === value
-				) {
-					// Shortcut when it's a single quasi and doesn't need to be replaced
-					return;
-				}
-				replaces.push({
-					range,
-					value
-				});
-			} else {
-				// Expression
-				parser.walkExpression(part.expression);
-			}
-		});
+					/// import.meta.webpack ///
+					const webpackVersion = parseInt(
+						(__webpack_require__(32702)/* .version */ .i8),
+						10
+					);
+					parser.hooks.typeof
+						.for("import.meta.webpack")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify("number"))
+						);
+					parser.hooks.expression
+						.for("import.meta.webpack")
+						.tap(
+							"ImportMetaPlugin",
+							toConstantDependency(parser, JSON.stringify(webpackVersion))
+						);
+					parser.hooks.evaluateTypeof
+						.for("import.meta.webpack")
+						.tap("ImportMetaPlugin", evaluateToString("number"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.webpack")
+						.tap("ImportMetaPlugin", evaluateToNumber(webpackVersion));
 
-		dep.replaces = replaces;
-		dep.critical =
-			options.wrappedContextCritical &&
-			"a part of the request of a dependency is an expression";
-		return dep;
-	} else if (
-		param.isWrapped() &&
-		((param.prefix && param.prefix.isString()) ||
-			(param.postfix && param.postfix.isString()))
-	) {
-		let prefixRaw =
-			param.prefix && param.prefix.isString() ? param.prefix.string : "";
-		let postfixRaw =
-			param.postfix && param.postfix.isString() ? param.postfix.string : "";
-		const prefixRange =
-			param.prefix && param.prefix.isString() ? param.prefix.range : null;
-		const postfixRange =
-			param.postfix && param.postfix.isString() ? param.postfix.range : null;
-		const valueRange = param.range;
-		const { context, prefix } = splitContextFromPrefix(prefixRaw);
-		const {
-			path: postfix,
-			query,
-			fragment
-		} = parseResource(postfixRaw, parser);
-		const regExp = new RegExp(
-			`^${quoteMeta(prefix)}${options.wrappedContextRegExp.source}${quoteMeta(
-				postfix
-			)}$`
-		);
-		const dep = new Dep(
-			{
-				request: context + query + fragment,
-				recursive: options.wrappedContextRecursive,
-				regExp,
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			valueRange
-		);
-		dep.loc = expr.loc;
-		const replaces = [];
-		if (prefixRange) {
-			replaces.push({
-				range: prefixRange,
-				value: JSON.stringify(prefix)
-			});
-		}
-		if (postfixRange) {
-			replaces.push({
-				range: postfixRange,
-				value: JSON.stringify(postfix)
-			});
-		}
-		dep.replaces = replaces;
-		dep.critical =
-			options.wrappedContextCritical &&
-			"a part of the request of a dependency is an expression";
+					/// Unknown properties ///
+					parser.hooks.unhandledExpressionMemberChain
+						.for("import.meta")
+						.tap("ImportMetaPlugin", (expr, members) => {
+							const dep = new ConstDependency(
+								`${Template.toNormalComment(
+									"unsupported import.meta." + members.join(".")
+								)} undefined${propertyAccess(members, 1)}`,
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluate
+						.for("MemberExpression")
+						.tap("ImportMetaPlugin", expression => {
+							const expr = /** @type {MemberExpression} */ (expression);
+							if (
+								expr.object.type === "MetaProperty" &&
+								expr.object.meta.name === "import" &&
+								expr.object.property.name === "meta" &&
+								expr.property.type ===
+									(expr.computed ? "Literal" : "Identifier")
+							) {
+								return new BasicEvaluatedExpression()
+									.setUndefined()
+									.setRange(expr.range);
+							}
+						});
+				};
 
-		if (parser && param.wrappedInnerExpressions) {
-			for (const part of param.wrappedInnerExpressions) {
-				if (part.expression) parser.walkExpression(part.expression);
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ImportMetaPlugin", parserHandler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ImportMetaPlugin", parserHandler);
 			}
-		}
-
-		return dep;
-	} else {
-		const dep = new Dep(
-			{
-				request: options.exprContextRequest,
-				recursive: options.exprContextRecursive,
-				regExp: /** @type {RegExp} */ (options.exprContextRegExp),
-				mode: "sync",
-				...contextOptions
-			},
-			range,
-			param.range
 		);
-		dep.loc = expr.loc;
-		dep.critical =
-			options.exprContextCritical &&
-			"the request of a dependency is an expression";
-
-		parser.walkExpression(param.expression);
-
-		return dep;
 	}
-};
+}
+
+module.exports = ImportMetaPlugin;
 
 
 /***/ }),
 
-/***/ 76081:
+/***/ 88130:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82193,211 +80467,271 @@ exports.create = (Dep, range, param, expr, options, contextOptions, parser) => {
 
 
 
-const ContextDependency = __webpack_require__(88101);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const CommentCompilationWarning = __webpack_require__(98427);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const ContextDependencyHelpers = __webpack_require__(99630);
+const ImportContextDependency = __webpack_require__(1902);
+const ImportDependency = __webpack_require__(89376);
+const ImportEagerDependency = __webpack_require__(50718);
+const ImportWeakDependency = __webpack_require__(82483);
 
-class ContextDependencyTemplateAsId extends ContextDependency.Template {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ContextDependency} */ (dependency);
-		const moduleExports = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
+/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
 
-		if (moduleGraph.getModule(dep)) {
-			if (dep.valueRange) {
-				if (Array.isArray(dep.replaces)) {
-					for (let i = 0; i < dep.replaces.length; i++) {
-						const rep = dep.replaces[i];
-						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
-					}
-				}
-				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-				source.replace(
-					dep.range[0],
-					dep.valueRange[0] - 1,
-					`${moduleExports}.resolve(`
-				);
-			} else {
-				source.replace(
-					dep.range[0],
-					dep.range[1] - 1,
-					`${moduleExports}.resolve`
-				);
-			}
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
-		}
+class ImportParserPlugin {
+	constructor(options) {
+		this.options = options;
 	}
-}
-module.exports = ContextDependencyTemplateAsId;
 
+	apply(parser) {
+		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
+			const param = parser.evaluateExpression(expr.source);
 
-/***/ }),
-
-/***/ 75815:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ContextDependency = __webpack_require__(88101);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+			let chunkName = null;
+			/** @type {ContextMode} */
+			let mode = "lazy";
+			let include = null;
+			let exclude = null;
+			/** @type {string[][] | null} */
+			let exports = null;
+			/** @type {RawChunkGroupOptions} */
+			const groupOptions = {};
 
-class ContextDependencyTemplateAsRequireCall extends ContextDependency.Template {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ContextDependency} */ (dependency);
-		let moduleExports = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			runtimeRequirements
-		});
+			const { options: importOptions, errors: commentErrors } =
+				parser.parseCommentOptions(expr.range);
 
-		if (dep.inShorthand) {
-			moduleExports = `${dep.inShorthand}: ${moduleExports}`;
-		}
-		if (moduleGraph.getModule(dep)) {
-			if (dep.valueRange) {
-				if (Array.isArray(dep.replaces)) {
-					for (let i = 0; i < dep.replaces.length; i++) {
-						const rep = dep.replaces[i];
-						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
-					}
+			if (commentErrors) {
+				for (const e of commentErrors) {
+					const { comment } = e;
+					parser.state.module.addWarning(
+						new CommentCompilationWarning(
+							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+							comment.loc
+						)
+					);
 				}
-				source.replace(dep.valueRange[1], dep.range[1] - 1, ")");
-				source.replace(
-					dep.range[0],
-					dep.valueRange[0] - 1,
-					`${moduleExports}(`
-				);
-			} else {
-				source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
 			}
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, moduleExports);
-		}
-	}
-}
-module.exports = ContextDependencyTemplateAsRequireCall;
-
-
-/***/ }),
-
-/***/ 58477:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class ContextElementDependency extends ModuleDependency {
-	constructor(request, userRequest, typePrefix, category, referencedExports) {
-		super(request);
-		this.referencedExports = referencedExports;
-		this._typePrefix = typePrefix;
-		this._category = category;
-
-		if (userRequest) {
-			this.userRequest = userRequest;
-		}
-	}
-
-	get type() {
-		if (this._typePrefix) {
-			return `${this._typePrefix} context element`;
-		}
-
-		return "context element";
-	}
-
-	get category() {
-		return this._category;
-	}
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return this.referencedExports
-			? this.referencedExports.map(e => ({
-					name: e,
-					canMangle: false
-			  }))
-			: Dependency.EXPORTS_OBJECT_REFERENCED;
-	}
+			if (importOptions) {
+				if (importOptions.webpackIgnore !== undefined) {
+					if (typeof importOptions.webpackIgnore !== "boolean") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+								expr.loc
+							)
+						);
+					} else {
+						// Do not instrument `import()` if `webpackIgnore` is `true`
+						if (importOptions.webpackIgnore) {
+							return false;
+						}
+					}
+				}
+				if (importOptions.webpackChunkName !== undefined) {
+					if (typeof importOptions.webpackChunkName !== "string") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
+								expr.loc
+							)
+						);
+					} else {
+						chunkName = importOptions.webpackChunkName;
+					}
+				}
+				if (importOptions.webpackMode !== undefined) {
+					if (typeof importOptions.webpackMode !== "string") {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
+								expr.loc
+							)
+						);
+					} else {
+						mode = importOptions.webpackMode;
+					}
+				}
+				if (importOptions.webpackPrefetch !== undefined) {
+					if (importOptions.webpackPrefetch === true) {
+						groupOptions.prefetchOrder = 0;
+					} else if (typeof importOptions.webpackPrefetch === "number") {
+						groupOptions.prefetchOrder = importOptions.webpackPrefetch;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
+								expr.loc
+							)
+						);
+					}
+				}
+				if (importOptions.webpackPreload !== undefined) {
+					if (importOptions.webpackPreload === true) {
+						groupOptions.preloadOrder = 0;
+					} else if (typeof importOptions.webpackPreload === "number") {
+						groupOptions.preloadOrder = importOptions.webpackPreload;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
+								expr.loc
+							)
+						);
+					}
+				}
+				if (importOptions.webpackInclude !== undefined) {
+					if (
+						!importOptions.webpackInclude ||
+						importOptions.webpackInclude.constructor.name !== "RegExp"
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
+								expr.loc
+							)
+						);
+					} else {
+						include = new RegExp(importOptions.webpackInclude);
+					}
+				}
+				if (importOptions.webpackExclude !== undefined) {
+					if (
+						!importOptions.webpackExclude ||
+						importOptions.webpackExclude.constructor.name !== "RegExp"
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
+								expr.loc
+							)
+						);
+					} else {
+						exclude = new RegExp(importOptions.webpackExclude);
+					}
+				}
+				if (importOptions.webpackExports !== undefined) {
+					if (
+						!(
+							typeof importOptions.webpackExports === "string" ||
+							(Array.isArray(importOptions.webpackExports) &&
+								importOptions.webpackExports.every(
+									item => typeof item === "string"
+								))
+						)
+					) {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
+								expr.loc
+							)
+						);
+					} else {
+						if (typeof importOptions.webpackExports === "string") {
+							exports = [[importOptions.webpackExports]];
+						} else {
+							exports = Array.from(importOptions.webpackExports, e => [e]);
+						}
+					}
+				}
+			}
 
-	serialize(context) {
-		context.write(this.referencedExports);
-		super.serialize(context);
-	}
+			if (param.isString()) {
+				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
+							expr.loc
+						)
+					);
+				}
 
-	deserialize(context) {
-		this.referencedExports = context.read();
-		super.deserialize(context);
+				if (mode === "eager") {
+					const dep = new ImportEagerDependency(
+						param.string,
+						expr.range,
+						exports
+					);
+					parser.state.current.addDependency(dep);
+				} else if (mode === "weak") {
+					const dep = new ImportWeakDependency(
+						param.string,
+						expr.range,
+						exports
+					);
+					parser.state.current.addDependency(dep);
+				} else {
+					const depBlock = new AsyncDependenciesBlock(
+						{
+							...groupOptions,
+							name: chunkName
+						},
+						expr.loc,
+						param.string
+					);
+					const dep = new ImportDependency(param.string, expr.range, exports);
+					dep.loc = expr.loc;
+					depBlock.addDependency(dep);
+					parser.state.current.addBlock(depBlock);
+				}
+				return true;
+			} else {
+				if (
+					mode !== "lazy" &&
+					mode !== "lazy-once" &&
+					mode !== "eager" &&
+					mode !== "weak"
+				) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+							expr.loc
+						)
+					);
+					mode = "lazy";
+				}
+
+				if (mode === "weak") {
+					mode = "async-weak";
+				}
+				const dep = ContextDependencyHelpers.create(
+					ImportContextDependency,
+					expr.range,
+					param,
+					expr,
+					this.options,
+					{
+						chunkName,
+						groupOptions,
+						include,
+						exclude,
+						mode,
+						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
+							? "strict"
+							: true,
+						typePrefix: "import()",
+						category: "esm",
+						referencedExports: exports
+					},
+					parser
+				);
+				if (!dep) return;
+				dep.loc = expr.loc;
+				dep.optional = !!parser.scope.inTry;
+				parser.state.current.addDependency(dep);
+				return true;
+			}
+		});
 	}
 }
 
-makeSerializable(
-	ContextElementDependency,
-	"webpack/lib/dependencies/ContextElementDependency"
-);
-
-module.exports = ContextElementDependency;
+module.exports = ImportParserPlugin;
 
 
 /***/ }),
 
-/***/ 79062:
+/***/ 41293:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82408,70 +80742,86 @@ module.exports = ContextElementDependency;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const ImportContextDependency = __webpack_require__(1902);
+const ImportDependency = __webpack_require__(89376);
+const ImportEagerDependency = __webpack_require__(50718);
+const ImportParserPlugin = __webpack_require__(88130);
+const ImportWeakDependency = __webpack_require__(82483);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Compiler")} Compiler */
 
-class CreateScriptUrlDependency extends NullDependency {
+class ImportPlugin {
 	/**
-	 * @param {[number, number]} range range
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(range) {
-		super();
-		this.range = range;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ImportPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ImportDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportDependency,
+					new ImportDependency.Template()
+				);
 
-	get type() {
-		return "create script url";
-	}
+				compilation.dependencyFactories.set(
+					ImportEagerDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportEagerDependency,
+					new ImportEagerDependency.Template()
+				);
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		super.serialize(context);
-	}
+				compilation.dependencyFactories.set(
+					ImportWeakDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportWeakDependency,
+					new ImportWeakDependency.Template()
+				);
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		super.deserialize(context);
-	}
-}
+				compilation.dependencyFactories.set(
+					ImportContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportContextDependency,
+					new ImportContextDependency.Template()
+				);
 
-CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {CreateScriptUrlDependency} */ (dependency);
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.import !== undefined && !parserOptions.import)
+						return;
 
-		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+					new ImportParserPlugin(parserOptions).apply(parser);
+				};
 
-		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
-		source.insert(dep.range[1], ")");
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("ImportPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("ImportPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("ImportPlugin", handler);
+			}
+		);
 	}
-};
-
-makeSerializable(
-	CreateScriptUrlDependency,
-	"webpack/lib/dependencies/CreateScriptUrlDependency"
-);
-
-module.exports = CreateScriptUrlDependency;
+}
+module.exports = ImportPlugin;
 
 
 /***/ }),
 
-/***/ 15427:
+/***/ 82483:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -82482,35 +80832,77 @@ module.exports = CreateScriptUrlDependency;
 
 
 
-const WebpackError = __webpack_require__(53799);
 const makeSerializable = __webpack_require__(33032);
+const ImportDependency = __webpack_require__(89376);
 
-class CriticalDependencyWarning extends WebpackError {
-	constructor(message) {
-		super();
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-		this.name = "CriticalDependencyWarning";
-		this.message = "Critical dependency: " + message;
+class ImportWeakDependency extends ImportDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {[number, number]} range expression range
+	 * @param {string[][]=} referencedExports list of referenced exports
+	 */
+	constructor(request, range, referencedExports) {
+		super(request, range, referencedExports);
+		this.weak = true;
+	}
+
+	get type() {
+		return "import() weak";
 	}
 }
 
 makeSerializable(
-	CriticalDependencyWarning,
-	"webpack/lib/dependencies/CriticalDependencyWarning"
+	ImportWeakDependency,
+	"webpack/lib/dependencies/ImportWeakDependency"
 );
 
-module.exports = CriticalDependencyWarning;
+ImportWeakDependency.Template = class ImportDependencyTemplate extends (
+	ImportDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ImportWeakDependency} */ (dependency);
+		const content = runtimeTemplate.moduleNamespacePromise({
+			chunkGraph,
+			module: moduleGraph.getModule(dep),
+			request: dep.request,
+			strict: module.buildMeta.strictHarmonyModule,
+			message: "import() weak",
+			weak: true,
+			runtimeRequirements
+		});
+
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+	}
+};
+
+module.exports = ImportWeakDependency;
 
 
 /***/ }),
 
-/***/ 76760:
+/***/ 750:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
@@ -82518,25 +80910,50 @@ module.exports = CriticalDependencyWarning;
 const makeSerializable = __webpack_require__(33032);
 const NullDependency = __webpack_require__(31830);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
 
-class CssExportDependency extends NullDependency {
+const getExportsFromData = data => {
+	if (data && typeof data === "object") {
+		if (Array.isArray(data)) {
+			return data.map((item, idx) => {
+				return {
+					name: `${idx}`,
+					canMangle: true,
+					exports: getExportsFromData(item)
+				};
+			});
+		} else {
+			const exports = [];
+			for (const key of Object.keys(data)) {
+				exports.push({
+					name: key,
+					canMangle: true,
+					exports: getExportsFromData(data[key])
+				});
+			}
+			return exports;
+		}
+	}
+	return undefined;
+};
+
+class JsonExportsDependency extends NullDependency {
 	/**
-	 * @param {string} name name
-	 * @param {string} value value
+	 * @param {(string | ExportSpec)[]} exports json exports
 	 */
-	constructor(name, value) {
+	constructor(exports) {
 		super();
-		this.name = name;
-		this.value = value;
+		this.exports = exports;
+		this._hashUpdate = undefined;
 	}
 
 	get type() {
-		return "css :export";
+		return "json exports";
 	}
 
 	/**
@@ -82545,148 +80962,448 @@ class CssExportDependency extends NullDependency {
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
-		const name = this.name;
 		return {
-			exports: [
-				{
-					name,
-					canMangle: true
-				}
-			],
+			exports: this.exports,
 			dependencies: undefined
 		};
 	}
 
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.exports
+				? JSON.stringify(this.exports)
+				: "undefined";
+		}
+		hash.update(this._hashUpdate);
+	}
+
 	serialize(context) {
 		const { write } = context;
-		write(this.name);
-		write(this.value);
+		write(this.exports);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.name = read();
-		this.value = read();
+		this.exports = read();
 		super.deserialize(context);
 	}
 }
 
-CssExportDependency.Template = class CssExportDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { cssExports }) {
-		const dep = /** @type {CssExportDependency} */ (dependency);
-		cssExports.set(dep.name, dep.value);
-	}
-};
-
 makeSerializable(
-	CssExportDependency,
-	"webpack/lib/dependencies/CssExportDependency"
+	JsonExportsDependency,
+	"webpack/lib/dependencies/JsonExportsDependency"
 );
 
-module.exports = CssExportDependency;
+module.exports = JsonExportsDependency;
+module.exports.getExportsFromData = getExportsFromData;
 
 
 /***/ }),
 
-/***/ 90542:
+/***/ 71693:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
 const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class CssImportDependency extends ModuleDependency {
+class LoaderDependency extends ModuleDependency {
 	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range of the argument
-	 * @param {string | undefined} supports list of supports conditions
-	 * @param {string | undefined} media list of media conditions
+	 * @param {string} request request string
 	 */
-	constructor(request, range, supports, media) {
+	constructor(request) {
 		super(request);
-		this.range = range;
-		this.supports = supports;
-		this.media = media;
 	}
 
 	get type() {
-		return "css @import";
+		return "loader";
 	}
 
 	get category() {
-		return "css-import";
+		return "loader";
 	}
+}
+
+module.exports = LoaderDependency;
+
+
+/***/ }),
+
+/***/ 223:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
 
+const ModuleDependency = __webpack_require__(80321);
+
+class LoaderImportDependency extends ModuleDependency {
 	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @param {string} request request string
 	 */
-	createIgnoredModule(context) {
-		return null;
+	constructor(request) {
+		super(request);
+		this.weak = true;
+	}
+
+	get type() {
+		return "loader import";
+	}
+
+	get category() {
+		return "loaderImport";
 	}
 }
 
-CssImportDependency.Template = class CssImportDependencyTemplate extends (
-	ModuleDependency.Template
-) {
+module.exports = LoaderImportDependency;
+
+
+/***/ }),
+
+/***/ 24721:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const NormalModule = __webpack_require__(39);
+const LazySet = __webpack_require__(38938);
+const LoaderDependency = __webpack_require__(71693);
+const LoaderImportDependency = __webpack_require__(223);
+
+/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+/**
+ * @callback LoadModuleCallback
+ * @param {(Error | null)=} err error object
+ * @param {string | Buffer=} source source code
+ * @param {object=} map source map
+ * @param {Module=} module loaded module if successful
+ */
+
+/**
+ * @callback ImportModuleCallback
+ * @param {(Error | null)=} err error object
+ * @param {any=} exports exports of the evaluated module
+ */
+
+/**
+ * @typedef {Object} ImportModuleOptions
+ * @property {string=} layer the target layer
+ * @property {string=} publicPath the target public path
+ */
+
+class LoaderPlugin {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @param {Object} options options
+	 */
+	constructor(options = {}) {}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {CssImportDependency} */ (dependency);
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"LoaderPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					LoaderDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyFactories.set(
+					LoaderImportDependency,
+					normalModuleFactory
+				);
+			}
+		);
 
-		source.replace(dep.range[0], dep.range[1] - 1, "");
+		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			NormalModule.getCompilationHooks(compilation).loader.tap(
+				"LoaderPlugin",
+				loaderContext => {
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
+					 * @returns {void}
+					 */
+					loaderContext.loadModule = (request, callback) => {
+						const dep = new LoaderDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule: loaderContext._module,
+								context: loaderContext.context,
+								recursive: false
+							},
+							err => {
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								if (referencedModule.getNumberOfErrors() > 0) {
+									return callback(
+										new Error("The loaded module contains errors")
+									);
+								}
+								const moduleSource = referencedModule.originalSource();
+								if (!moduleSource) {
+									return callback(
+										new Error(
+											"The module created for a LoaderDependency must have an original source"
+										)
+									);
+								}
+								let source, map;
+								if (moduleSource.sourceAndMap) {
+									const sourceAndMap = moduleSource.sourceAndMap();
+									map = sourceAndMap.map;
+									source = sourceAndMap.source;
+								} else {
+									map = moduleSource.map();
+									source = moduleSource.source();
+								}
+								const fileDependencies = new LazySet();
+								const contextDependencies = new LazySet();
+								const missingDependencies = new LazySet();
+								const buildDependencies = new LazySet();
+								referencedModule.addCacheDependencies(
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								);
+
+								for (const d of fileDependencies) {
+									loaderContext.addDependency(d);
+								}
+								for (const d of contextDependencies) {
+									loaderContext.addContextDependency(d);
+								}
+								for (const d of missingDependencies) {
+									loaderContext.addMissingDependency(d);
+								}
+								for (const d of buildDependencies) {
+									loaderContext.addBuildDependency(d);
+								}
+								return callback(null, source, map, referencedModule);
+							}
+						);
+					};
+
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions=} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {void}
+					 */
+					const importModule = (request, options, callback) => {
+						const dep = new LoaderImportDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
+							);
+						}
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule: loaderContext._module,
+								contextInfo: {
+									issuerLayer: options.layer
+								},
+								context: loaderContext.context,
+								connectOrigin: false
+							},
+							err => {
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								compilation.executeModule(
+									referencedModule,
+									{
+										entryOptions: {
+											publicPath: options.publicPath
+										}
+									},
+									(err, result) => {
+										if (err) return callback(err);
+										for (const d of result.fileDependencies) {
+											loaderContext.addDependency(d);
+										}
+										for (const d of result.contextDependencies) {
+											loaderContext.addContextDependency(d);
+										}
+										for (const d of result.missingDependencies) {
+											loaderContext.addMissingDependency(d);
+										}
+										for (const d of result.buildDependencies) {
+											loaderContext.addBuildDependency(d);
+										}
+										if (result.cacheable === false)
+											loaderContext.cacheable(false);
+										for (const [name, { source, info }] of result.assets) {
+											const { buildInfo } = loaderContext._module;
+											if (!buildInfo.assets) {
+												buildInfo.assets = Object.create(null);
+												buildInfo.assetsInfo = new Map();
+											}
+											buildInfo.assets[name] = source;
+											buildInfo.assetsInfo.set(name, info);
+										}
+										callback(null, result.exports);
+									}
+								);
+							}
+						);
+					};
+
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {Promise<any> | void} exports
+					 */
+					loaderContext.importModule = (request, options, callback) => {
+						if (!callback) {
+							return new Promise((resolve, reject) => {
+								importModule(request, options || {}, (err, result) => {
+									if (err) reject(err);
+									else resolve(result);
+								});
+							});
+						}
+						return importModule(request, options || {}, callback);
+					};
+				}
+			);
+		});
 	}
-};
+}
+module.exports = LoaderPlugin;
 
-makeSerializable(
-	CssImportDependency,
-	"webpack/lib/dependencies/CssImportDependency"
-);
 
-module.exports = CssImportDependency;
+/***/ }),
+
+/***/ 5826:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+
+class LocalModule {
+	constructor(name, idx) {
+		this.name = name;
+		this.idx = idx;
+		this.used = false;
+	}
+
+	flagUsed() {
+		this.used = true;
+	}
+
+	variableName() {
+		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.name);
+		write(this.idx);
+		write(this.used);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.name = read();
+		this.idx = read();
+		this.used = read();
+	}
+}
+
+makeSerializable(LocalModule, "webpack/lib/dependencies/LocalModule");
+
+module.exports = LocalModule;
 
 
 /***/ }),
 
-/***/ 92328:
+/***/ 52805:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
@@ -82696,74 +81413,44 @@ const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class CssLocalIdentifierDependency extends NullDependency {
-	/**
-	 * @param {string} name name
-	 * @param {[number, number]} range range
-	 * @param {string=} prefix prefix
-	 */
-	constructor(name, range, prefix = "") {
+class LocalModuleDependency extends NullDependency {
+	constructor(localModule, range, callNew) {
 		super();
-		this.name = name;
-		this.range = range;
-		this.prefix = prefix;
-	}
-
-	get type() {
-		return "css local identifier";
-	}
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		const name = this.name;
-		return {
-			exports: [
-				{
-					name,
-					canMangle: true
-				}
-			],
-			dependencies: undefined
-		};
+		this.localModule = localModule;
+		this.range = range;
+		this.callNew = callNew;
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.name);
+
+		write(this.localModule);
 		write(this.range);
-		write(this.prefix);
+		write(this.callNew);
+
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.name = read();
+
+		this.localModule = read();
 		this.range = read();
-		this.prefix = read();
+		this.callNew = read();
+
 		super.deserialize(context);
 	}
 }
 
-const escapeCssIdentifier = (str, omitUnderscore) => {
-	const escaped = `${str}`.replace(
-		// cspell:word uffff
-		/[^a-zA-Z0-9_\u0081-\uffff-]/g,
-		s => `\\${s}`
-	);
-	return !omitUnderscore && /^(?!--)[0-9-]/.test(escaped)
-		? `_${escaped}`
-		: escaped;
-};
+makeSerializable(
+	LocalModuleDependency,
+	"webpack/lib/dependencies/LocalModuleDependency"
+);
 
-CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTemplate extends (
+LocalModuleDependency.Template = class LocalModuleDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -82772,77 +81459,123 @@ CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTempla
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, chunkGraph, runtime, runtimeTemplate, cssExports }
-	) {
-		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportInfo(module, dep.name)
-			.getUsedName(dep.name, runtime);
-		const moduleId = chunkGraph.getModuleId(module);
-		const identifier =
-			dep.prefix +
-			(runtimeTemplate.outputOptions.uniqueName
-				? runtimeTemplate.outputOptions.uniqueName + "-"
-				: "") +
-			(used ? moduleId + "-" + used : "-");
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			escapeCssIdentifier(identifier, dep.prefix)
-		);
-		if (used) cssExports.set(used, identifier);
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {LocalModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const moduleInstance = dep.callNew
+			? `new (function () { return ${dep.localModule.variableName()}; })()`
+			: dep.localModule.variableName();
+		source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
 	}
 };
 
-makeSerializable(
-	CssLocalIdentifierDependency,
-	"webpack/lib/dependencies/CssLocalIdentifierDependency"
-);
-
-module.exports = CssLocalIdentifierDependency;
+module.exports = LocalModuleDependency;
 
 
 /***/ }),
 
-/***/ 29094:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 75827:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const CssLocalIdentifierDependency = __webpack_require__(92328);
+const LocalModule = __webpack_require__(5826);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+const lookup = (parent, mod) => {
+	if (mod.charAt(0) !== ".") return mod;
 
-class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
-	/**
-	 * @param {string} name name
-	 * @param {[number, number]} range range
-	 * @param {string=} prefix prefix
-	 * @param {Set<string>=} declaredSet set of declared names (will only be active when in declared set)
+	var path = parent.split("/");
+	var segments = mod.split("/");
+	path.pop();
+
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (seg === "..") {
+			path.pop();
+		} else if (seg !== ".") {
+			path.push(seg);
+		}
+	}
+
+	return path.join("/");
+};
+
+exports.addLocalModule = (state, name) => {
+	if (!state.localModules) {
+		state.localModules = [];
+	}
+	const m = new LocalModule(name, state.localModules.length);
+	state.localModules.push(m);
+	return m;
+};
+
+exports.getLocalModule = (state, name, namedModule) => {
+	if (!state.localModules) return null;
+	if (namedModule) {
+		// resolve dependency name relative to the defining named module
+		name = lookup(namedModule, name);
+	}
+	for (let i = 0; i < state.localModules.length; i++) {
+		if (state.localModules[i].name === name) {
+			return state.localModules[i];
+		}
+	}
+	return null;
+};
+
+
+/***/ }),
+
+/***/ 88488:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class ModuleDecoratorDependency extends NullDependency {
+	/**
+	 * @param {string} decorator the decorator requirement
+	 * @param {boolean} allowExportsAccess allow to access exports from module
 	 */
-	constructor(name, range, prefix = "", declaredSet = undefined) {
-		super(name, range, prefix);
-		this.declaredSet = declaredSet;
+	constructor(decorator, allowExportsAccess) {
+		super();
+		this.decorator = decorator;
+		this.allowExportsAccess = allowExportsAccess;
+		this._hashUpdate = undefined;
 	}
 
+	/**
+	 * @returns {string} a display name for the type of dependency
+	 */
 	get type() {
-		return "css self local identifier";
+		return "module decorator";
 	}
 
 	get category() {
@@ -82855,15 +81588,6 @@ class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	getResourceIdentifier() {
 		return `self`;
 	}
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		if (this.declaredSet && !this.declaredSet.has(this.name)) return;
-		return super.getExports(moduleGraph);
-	}
 
 	/**
 	 * Returns list of exports referenced by this dependency
@@ -82872,26 +81596,46 @@ class CssSelfLocalIdentifierDependency extends CssLocalIdentifierDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		if (this.declaredSet && !this.declaredSet.has(this.name))
-			return Dependency.NO_EXPORTS_REFERENCED;
-		return [[this.name]];
+		return this.allowExportsAccess
+			? Dependency.EXPORTS_OBJECT_REFERENCED
+			: Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.declaredSet);
+		write(this.decorator);
+		write(this.allowExportsAccess);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.declaredSet = read();
+		this.decorator = read();
+		this.allowExportsAccess = read();
 		super.deserialize(context);
 	}
 }
 
-CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependencyTemplate extends (
-	CssLocalIdentifierDependency.Template
+makeSerializable(
+	ModuleDecoratorDependency,
+	"webpack/lib/dependencies/ModuleDecoratorDependency"
+);
+
+ModuleDecoratorDependency.Template = class ModuleDecoratorDependencyTemplate extends (
+	NullDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -82899,70 +81643,82 @@ CssSelfLocalIdentifierDependency.Template = class CssSelfLocalIdentifierDependen
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {CssSelfLocalIdentifierDependency} */ (dependency);
-		if (dep.declaredSet && !dep.declaredSet.has(dep.name)) return;
-		super.apply(dependency, source, templateContext);
+	apply(
+		dependency,
+		source,
+		{ module, chunkGraph, initFragments, runtimeRequirements }
+	) {
+		const dep = /** @type {ModuleDecoratorDependency} */ (dependency);
+		runtimeRequirements.add(RuntimeGlobals.moduleLoaded);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(dep.decorator);
+		initFragments.push(
+			new InitFragment(
+				`/* module decorator */ ${module.moduleArgument} = ${dep.decorator}(${module.moduleArgument});\n`,
+				InitFragment.STAGE_PROVIDES,
+				0,
+				`module decorator ${chunkGraph.getModuleId(module)}`
+			)
+		);
 	}
 };
 
-makeSerializable(
-	CssSelfLocalIdentifierDependency,
-	"webpack/lib/dependencies/CssSelfLocalIdentifierDependency"
-);
-
-module.exports = CssSelfLocalIdentifierDependency;
+module.exports = ModuleDecoratorDependency;
 
 
 /***/ }),
 
-/***/ 70749:
+/***/ 80321:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
+const Dependency = __webpack_require__(54912);
+const DependencyTemplate = __webpack_require__(5160);
 const memoize = __webpack_require__(78676);
-const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
+const getRawModule = memoize(() => __webpack_require__(84929));
 
-class CssUrlDependency extends ModuleDependency {
+class ModuleDependency extends Dependency {
 	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range of the argument
-	 * @param {string} cssFunctionKind kind of css function, e. g. url(), image()
+	 * @param {string} request request path which needs resolving
 	 */
-	constructor(request, range, cssFunctionKind) {
-		super(request);
-		this.range = range;
-		this.cssFunctionKind = cssFunctionKind;
+	constructor(request) {
+		super();
+		this.request = request;
+		this.userRequest = request;
+		this.range = undefined;
+		// assertions must be serialized by subclasses that use it
+		/** @type {Record<string, any> | undefined} */
+		this.assertions = undefined;
 	}
 
-	get type() {
-		return "css url()";
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = `module${this.request}`;
+		if (this.assertions !== undefined) {
+			str += JSON.stringify(this.assertions);
+		}
+		return str;
 	}
 
-	get category() {
-		return "url";
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return true;
 	}
 
 	/**
@@ -82970,93 +81726,39 @@ class CssUrlDependency extends ModuleDependency {
 	 * @returns {Module} a module
 	 */
 	createIgnoredModule(context) {
-		const RawDataUrlModule = getRawDataUrlModule();
-		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
+		const RawModule = getRawModule();
+		return new RawModule(
+			"/* (ignored) */",
+			`ignored|${context}|${this.request}`,
+			`${this.request} (ignored)`
+		);
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.cssFunctionKind);
+		write(this.request);
+		write(this.userRequest);
+		write(this.range);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.cssFunctionKind = read();
+		this.request = read();
+		this.userRequest = read();
+		this.range = read();
 		super.deserialize(context);
 	}
 }
 
-const cssEscapeString = str => {
-	let countWhiteOrBracket = 0;
-	let countQuotation = 0;
-	let countApostrophe = 0;
-	for (let i = 0; i < str.length; i++) {
-		const cc = str.charCodeAt(i);
-		switch (cc) {
-			case 9: // tab
-			case 10: // nl
-			case 32: // space
-			case 40: // (
-			case 41: // )
-				countWhiteOrBracket++;
-				break;
-			case 34:
-				countQuotation++;
-				break;
-			case 39:
-				countApostrophe++;
-				break;
-		}
-	}
-	if (countWhiteOrBracket < 2) {
-		return str.replace(/[\n\t ()'"\\]/g, m => `\\${m}`);
-	} else if (countQuotation <= countApostrophe) {
-		return `"${str.replace(/[\n"\\]/g, m => `\\${m}`)}"`;
-	} else {
-		return `'${str.replace(/[\n'\\]/g, m => `\\${m}`)}'`;
-	}
-};
-
-CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtime, moduleGraph, runtimeTemplate, codeGenerationResults }
-	) {
-		const dep = /** @type {CssUrlDependency} */ (dependency);
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`${dep.cssFunctionKind}(${cssEscapeString(
-				runtimeTemplate.assetUrl({
-					publicPath: "",
-					runtime,
-					module: moduleGraph.getModule(dep),
-					codeGenerationResults
-				})
-			)})`
-		);
-	}
-};
-
-makeSerializable(CssUrlDependency, "webpack/lib/dependencies/CssUrlDependency");
+ModuleDependency.Template = DependencyTemplate;
 
-module.exports = CssUrlDependency;
+module.exports = ModuleDependency;
 
 
 /***/ }),
 
-/***/ 22914:
+/***/ 80825:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83067,34 +81769,38 @@ module.exports = CssUrlDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
 const ModuleDependency = __webpack_require__(80321);
 
-class DelegatedSourceDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
-
-	get type() {
-		return "delegated source";
-	}
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-	get category() {
-		return "esm";
+class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph }) {
+		const dep = /** @type {ModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const content = runtimeTemplate.moduleId({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 }
 
-makeSerializable(
-	DelegatedSourceDependency,
-	"webpack/lib/dependencies/DelegatedSourceDependency"
-);
-
-module.exports = DelegatedSourceDependency;
+module.exports = ModuleDependencyTemplateAsId;
 
 
 /***/ }),
 
-/***/ 95666:
+/***/ 36873:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83105,52 +81811,43 @@ module.exports = DelegatedSourceDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-
-class DllEntryDependency extends Dependency {
-	constructor(dependencies, name) {
-		super();
-
-		this.dependencies = dependencies;
-		this.name = name;
-	}
-
-	get type() {
-		return "dll entry";
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.dependencies);
-		write(this.name);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
+const ModuleDependency = __webpack_require__(80321);
 
-		this.dependencies = read();
-		this.name = read();
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-		super.deserialize(context);
+class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
+	) {
+		const dep = /** @type {ModuleDependency} */ (dependency);
+		if (!dep.range) return;
+		const content = runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(dep),
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 }
-
-makeSerializable(
-	DllEntryDependency,
-	"webpack/lib/dependencies/DllEntryDependency"
-);
-
-module.exports = DllEntryDependency;
+module.exports = ModuleDependencyTemplateAsRequireId;
 
 
 /***/ }),
 
-/***/ 32006:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 47511:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -83160,73 +81857,39 @@ module.exports = DllEntryDependency;
 
 
 
-/** @typedef {import("../Parser").ParserState} ParserState */
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-/** @type {WeakMap<ParserState, boolean>} */
-const parserStateExportsState = new WeakMap();
+class ModuleHotAcceptDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+		this.range = range;
+		this.weak = true;
+	}
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.bailout = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	parserStateExportsState.set(parserState, false);
-	if (value === true) {
-		parserState.module.buildMeta.exportsType = undefined;
-		parserState.module.buildMeta.defaultObject = false;
+	get type() {
+		return "module.hot.accept";
 	}
-};
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.enable = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	if (value === false) return;
-	parserStateExportsState.set(parserState, true);
-	if (value !== true) {
-		parserState.module.buildMeta.exportsType = "default";
-		parserState.module.buildMeta.defaultObject = "redirect";
+	get category() {
+		return "commonjs";
 	}
-};
+}
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.setFlagged = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	if (value !== true) return;
-	const buildMeta = parserState.module.buildMeta;
-	if (buildMeta.exportsType === "dynamic") return;
-	buildMeta.exportsType = "flagged";
-};
+makeSerializable(
+	ModuleHotAcceptDependency,
+	"webpack/lib/dependencies/ModuleHotAcceptDependency"
+);
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {void}
- */
-exports.setDynamic = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	if (value !== true) return;
-	parserState.module.buildMeta.exportsType = "dynamic";
-};
+ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-exports.isEnabled = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	return value === true;
-};
+module.exports = ModuleHotAcceptDependency;
 
 
 /***/ }),
 
-/***/ 3979:
+/***/ 86301:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83239,32 +81902,38 @@ exports.isEnabled = parserState => {
 
 const makeSerializable = __webpack_require__(33032);
 const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyTemplateAsId = __webpack_require__(80825);
 
-class EntryDependency extends ModuleDependency {
-	/**
-	 * @param {string} request request path for entry
-	 */
-	constructor(request) {
+class ModuleHotDeclineDependency extends ModuleDependency {
+	constructor(request, range) {
 		super(request);
+
+		this.range = range;
+		this.weak = true;
 	}
 
 	get type() {
-		return "entry";
+		return "module.hot.decline";
 	}
 
 	get category() {
-		return "esm";
+		return "commonjs";
 	}
 }
 
-makeSerializable(EntryDependency, "webpack/lib/dependencies/EntryDependency");
+makeSerializable(
+	ModuleHotDeclineDependency,
+	"webpack/lib/dependencies/ModuleHotDeclineDependency"
+);
 
-module.exports = EntryDependency;
+ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
+
+module.exports = ModuleHotDeclineDependency;
 
 
 /***/ }),
 
-/***/ 78988:
+/***/ 31830:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83275,141 +81944,206 @@ module.exports = EntryDependency;
 
 
 
-const { UsageState } = __webpack_require__(63686);
+const Dependency = __webpack_require__(54912);
+const DependencyTemplate = __webpack_require__(5160);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class NullDependency extends Dependency {
+	get type() {
+		return "null";
+	}
+
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return false;
+	}
+}
+
+NullDependency.Template = class NullDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {}
+};
+
+module.exports = NullDependency;
+
+
+/***/ }),
+
+/***/ 31618:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleDependency = __webpack_require__(80321);
+
+class PrefetchDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "prefetch";
+	}
+
+	get category() {
+		return "esm";
+	}
+}
+
+module.exports = PrefetchDependency;
+
+
+/***/ }),
+
+/***/ 95770:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Florent Cailhol @ooflorent
+*/
+
+
+
+const InitFragment = __webpack_require__(55870);
 const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const ModuleDependency = __webpack_require__(80321);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} module the module
- * @param {string | null} exportName name of the export if any
- * @param {string | null} property name of the requested property
- * @param {RuntimeSpec} runtime for which runtime
- * @returns {any} value of the property
+ * @param {string[]|null} path the property path array
+ * @returns {string} the converted path
  */
-const getProperty = (moduleGraph, module, exportName, property, runtime) => {
-	if (!exportName) {
-		switch (property) {
-			case "usedExports": {
-				const usedExports = moduleGraph
-					.getExportsInfo(module)
-					.getUsedExports(runtime);
-				if (
-					typeof usedExports === "boolean" ||
-					usedExports === undefined ||
-					usedExports === null
-				) {
-					return usedExports;
-				}
-				return Array.from(usedExports).sort();
-			}
-		}
+const pathToString = path =>
+	path !== null && path.length > 0
+		? path.map(part => `[${JSON.stringify(part)}]`).join("")
+		: "";
+
+class ProvidedDependency extends ModuleDependency {
+	constructor(request, identifier, path, range) {
+		super(request);
+		this.identifier = identifier;
+		this.path = path;
+		this.range = range;
+		this._hashUpdate = undefined;
 	}
-	switch (property) {
-		case "used":
-			return (
-				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
-				UsageState.Unused
-			);
-		case "useInfo": {
-			const state = moduleGraph
-				.getExportsInfo(module)
-				.getUsed(exportName, runtime);
-			switch (state) {
-				case UsageState.Used:
-				case UsageState.OnlyPropertiesUsed:
-					return true;
-				case UsageState.Unused:
-					return false;
-				case UsageState.NoInfo:
-					return undefined;
-				case UsageState.Unknown:
-					return null;
-				default:
-					throw new Error(`Unexpected UsageState ${state}`);
-			}
-		}
-		case "provideInfo":
-			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
+
+	get type() {
+		return "provided";
 	}
-	return undefined;
-};
 
-class ExportsInfoDependency extends NullDependency {
-	constructor(range, exportName, property) {
-		super();
-		this.range = range;
-		this.exportName = exportName;
-		this.property = property;
+	get category() {
+		return "esm";
+	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate =
+				this.identifier + (this.path ? this.path.join(",") : "null");
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.range);
-		write(this.exportName);
-		write(this.property);
+		write(this.identifier);
+		write(this.path);
 		super.serialize(context);
 	}
 
-	static deserialize(context) {
-		const obj = new ExportsInfoDependency(
-			context.read(),
-			context.read(),
-			context.read()
-		);
-		obj.deserialize(context);
-		return obj;
+	deserialize(context) {
+		const { read } = context;
+		this.identifier = read();
+		this.path = read();
+		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	ExportsInfoDependency,
-	"webpack/lib/dependencies/ExportsInfoDependency"
+	ProvidedDependency,
+	"webpack/lib/dependencies/ProvidedDependency"
 );
 
-ExportsInfoDependency.Template = class ExportsInfoDependencyTemplate extends (
-	NullDependency.Template
-) {
+class ProvidedDependencyTemplate extends ModuleDependency.Template {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { module, moduleGraph, runtime }) {
-		const dep = /** @type {ExportsInfoDependency} */ (dependency);
-
-		const value = getProperty(
+	apply(
+		dependency,
+		source,
+		{
+			runtimeTemplate,
 			moduleGraph,
-			module,
-			dep.exportName,
-			dep.property,
-			runtime
-		);
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			value === undefined ? "undefined" : JSON.stringify(value)
+			chunkGraph,
+			initFragments,
+			runtimeRequirements
+		}
+	) {
+		const dep = /** @type {ProvidedDependency} */ (dependency);
+		initFragments.push(
+			new InitFragment(
+				`/* provided dependency */ var ${
+					dep.identifier
+				} = ${runtimeTemplate.moduleExports({
+					module: moduleGraph.getModule(dep),
+					chunkGraph,
+					request: dep.request,
+					runtimeRequirements
+				})}${pathToString(dep.path)};\n`,
+				InitFragment.STAGE_PROVIDES,
+				1,
+				`provided ${dep.identifier}`
+			)
 		);
+		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
 	}
-};
+}
 
-module.exports = ExportsInfoDependency;
+ProvidedDependency.Template = ProvidedDependencyTemplate;
+
+module.exports = ProvidedDependency;
 
 
 /***/ }),
 
-/***/ 23624:
+/***/ 55799:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83420,56 +82154,74 @@ module.exports = ExportsInfoDependency;
 
 
 
-const Template = __webpack_require__(39722);
+const { UsageState } = __webpack_require__(63686);
 const makeSerializable = __webpack_require__(33032);
-const HarmonyImportDependency = __webpack_require__(57154);
+const { filterRuntime } = __webpack_require__(17156);
 const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
 
-class HarmonyAcceptDependency extends NullDependency {
+class PureExpressionDependency extends NullDependency {
 	/**
-	 * @param {[number, number]} range expression range
-	 * @param {HarmonyAcceptImportDependency[]} dependencies import dependencies
-	 * @param {boolean} hasCallback true, if the range wraps an existing callback
+	 * @param {[number, number]} range the source range
 	 */
-	constructor(range, dependencies, hasCallback) {
+	constructor(range) {
 		super();
 		this.range = range;
-		this.dependencies = dependencies;
-		this.hasCallback = hasCallback;
+		/** @type {Set<string> | false} */
+		this.usedByExports = false;
+		this._hashUpdate = undefined;
 	}
 
-	get type() {
-		return "accepted harmony modules";
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.range + "";
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 */
+	getModuleEvaluationSideEffectsState(moduleGraph) {
+		return false;
 	}
 
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
-		write(this.dependencies);
-		write(this.hasCallback);
+		write(this.usedByExports);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
 		this.range = read();
-		this.dependencies = read();
-		this.hasCallback = read();
+		this.usedByExports = read();
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	HarmonyAcceptDependency,
-	"webpack/lib/dependencies/HarmonyAcceptDependency"
+	PureExpressionDependency,
+	"webpack/lib/dependencies/PureExpressionDependency"
 );
 
-HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends (
+PureExpressionDependency.Template = class PureExpressionDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -83478,80 +82230,56 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyAcceptDependency} */ (dependency);
-		const {
-			module,
-			runtime,
-			runtimeRequirements,
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph
-		} = templateContext;
-		const content = dep.dependencies
-			.map(dependency => {
-				const referencedModule = moduleGraph.getModule(dependency);
-				return {
-					dependency,
-					runtimeCondition: referencedModule
-						? HarmonyImportDependency.Template.getImportEmittedRuntime(
-								module,
-								referencedModule
-						  )
-						: false
-				};
-			})
-			.filter(({ runtimeCondition }) => runtimeCondition !== false)
-			.map(({ dependency, runtimeCondition }) => {
+	apply(
+		dependency,
+		source,
+		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
+	) {
+		const dep = /** @type {PureExpressionDependency} */ (dependency);
+
+		const usedByExports = dep.usedByExports;
+		if (usedByExports !== false) {
+			const selfModule = moduleGraph.getParentModule(dep);
+			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+			const runtimeCondition = filterRuntime(runtime, runtime => {
+				for (const exportName of usedByExports) {
+					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
+						return true;
+					}
+				}
+				return false;
+			});
+			if (runtimeCondition === true) return;
+			if (runtimeCondition !== false) {
 				const condition = runtimeTemplate.runtimeConditionExpression({
 					chunkGraph,
 					runtime,
 					runtimeCondition,
 					runtimeRequirements
 				});
-				const s = dependency.getImportStatement(true, templateContext);
-				const code = s[0] + s[1];
-				if (condition !== "true") {
-					return `if (${condition}) {\n${Template.indent(code)}\n}\n`;
-				}
-				return code;
-			})
-			.join("");
-
-		if (dep.hasCallback) {
-			if (runtimeTemplate.supportsArrowFunction()) {
-				source.insert(
-					dep.range[0],
-					`__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`
-				);
-				source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
-			} else {
 				source.insert(
 					dep.range[0],
-					`function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`
-				);
-				source.insert(
-					dep.range[1],
-					")(__WEBPACK_OUTDATED_DEPENDENCIES__); }.bind(this)"
+					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
 				);
+				source.insert(dep.range[1], ") : null)");
+				return;
 			}
-			return;
 		}
 
-		const arrow = runtimeTemplate.supportsArrowFunction();
 		source.insert(
-			dep.range[1] - 0.5,
-			`, ${arrow ? "() =>" : "function()"} { ${content} }`
+			dep.range[0],
+			`(/* unused pure expression or super */ null && (`
 		);
+		source.insert(dep.range[1], "))");
 	}
 };
 
-module.exports = HarmonyAcceptDependency;
+module.exports = PureExpressionDependency;
 
 
 /***/ }),
 
-/***/ 99843:
+/***/ 46917:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83563,38 +82291,50 @@ module.exports = HarmonyAcceptDependency;
 
 
 const makeSerializable = __webpack_require__(33032);
-const HarmonyImportDependency = __webpack_require__(57154);
+const ContextDependency = __webpack_require__(88101);
+const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+class RequireContextDependency extends ContextDependency {
+	constructor(options, range) {
+		super(options);
 
-class HarmonyAcceptImportDependency extends HarmonyImportDependency {
-	constructor(request) {
-		super(request, NaN);
-		this.weak = true;
+		this.range = range;
 	}
 
 	get type() {
-		return "harmony accept";
+		return "require.context";
+	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.range);
+
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.range = read();
+
+		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	HarmonyAcceptImportDependency,
-	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
+	RequireContextDependency,
+	"webpack/lib/dependencies/RequireContextDependency"
 );
 
-HarmonyAcceptImportDependency.Template = class HarmonyAcceptImportDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {};
+RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
 
-module.exports = HarmonyAcceptImportDependency;
+module.exports = RequireContextDependency;
 
 
 /***/ }),
 
-/***/ 72906:
+/***/ 18851:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83605,95 +82345,62 @@ module.exports = HarmonyAcceptImportDependency;
 
 
 
-const { UsageState } = __webpack_require__(63686);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
+const RequireContextDependency = __webpack_require__(46917);
 
-class HarmonyCompatibilityDependency extends NullDependency {
-	get type() {
-		return "harmony export header";
+module.exports = class RequireContextDependencyParserPlugin {
+	apply(parser) {
+		parser.hooks.call
+			.for("require.context")
+			.tap("RequireContextDependencyParserPlugin", expr => {
+				let regExp = /^\.\/.*$/;
+				let recursive = true;
+				let mode = "sync";
+				switch (expr.arguments.length) {
+					case 4: {
+						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+						if (!modeExpr.isString()) return;
+						mode = modeExpr.string;
+					}
+					// falls through
+					case 3: {
+						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+						if (!regExpExpr.isRegExp()) return;
+						regExp = regExpExpr.regExp;
+					}
+					// falls through
+					case 2: {
+						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+						if (!recursiveExpr.isBoolean()) return;
+						recursive = recursiveExpr.bool;
+					}
+					// falls through
+					case 1: {
+						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+						if (!requestExpr.isString()) return;
+						const dep = new RequireContextDependency(
+							{
+								request: requestExpr.string,
+								recursive,
+								regExp,
+								mode,
+								category: "commonjs"
+							},
+							expr.range
+						);
+						dep.loc = expr.loc;
+						dep.optional = !!parser.scope.inTry;
+						parser.state.current.addDependency(dep);
+						return true;
+					}
+				}
+			});
 	}
-}
-
-makeSerializable(
-	HarmonyCompatibilityDependency,
-	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
-);
-
-HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{
-			module,
-			runtimeTemplate,
-			moduleGraph,
-			initFragments,
-			runtimeRequirements,
-			runtime,
-			concatenationScope
-		}
-	) {
-		if (concatenationScope) return;
-		const exportsInfo = moduleGraph.getExportsInfo(module);
-		if (
-			exportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
-			UsageState.Unused
-		) {
-			const content = runtimeTemplate.defineEsModuleFlagStatement({
-				exportsArgument: module.exportsArgument,
-				runtimeRequirements
-			});
-			initFragments.push(
-				new InitFragment(
-					content,
-					InitFragment.STAGE_HARMONY_EXPORTS,
-					0,
-					"harmony compatibility"
-				)
-			);
-		}
-		if (moduleGraph.isAsync(module)) {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			runtimeRequirements.add(RuntimeGlobals.asyncModule);
-			initFragments.push(
-				new InitFragment(
-					runtimeTemplate.supportsArrowFunction()
-						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
-						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
-					InitFragment.STAGE_ASYNC_BOUNDARY,
-					0,
-					undefined,
-					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
-						module.buildMeta.async ? ", 1" : ""
-					});`
-				)
-			);
-		}
-	}
-};
-
-module.exports = HarmonyCompatibilityDependency;
+};
 
 
 /***/ }),
 
-/***/ 17223:
+/***/ 2928:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83704,101 +82411,154 @@ module.exports = HarmonyCompatibilityDependency;
 
 
 
-const DynamicExports = __webpack_require__(32006);
-const HarmonyCompatibilityDependency = __webpack_require__(72906);
-const HarmonyExports = __webpack_require__(39211);
+const { cachedSetProperty } = __webpack_require__(60839);
+const ContextElementDependency = __webpack_require__(58477);
+const RequireContextDependency = __webpack_require__(46917);
+const RequireContextDependencyParserPlugin = __webpack_require__(18851);
 
-module.exports = class HarmonyDetectionParserPlugin {
-	constructor(options) {
-		const { topLevelAwait = false } = options || {};
-		this.topLevelAwait = topLevelAwait;
-	}
+/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
-	apply(parser) {
-		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
-			const isStrictHarmony = parser.state.module.type === "javascript/esm";
-			const isHarmony =
-				isStrictHarmony ||
-				ast.body.some(
-					statement =>
-						statement.type === "ImportDeclaration" ||
-						statement.type === "ExportDefaultDeclaration" ||
-						statement.type === "ExportNamedDeclaration" ||
-						statement.type === "ExportAllDeclaration"
-				);
-			if (isHarmony) {
-				const module = parser.state.module;
-				const compatDep = new HarmonyCompatibilityDependency();
-				compatDep.loc = {
-					start: {
-						line: -1,
-						column: 0
-					},
-					end: {
-						line: -1,
-						column: 0
-					},
-					index: -3
-				};
-				module.addPresentationalDependency(compatDep);
-				DynamicExports.bailout(parser.state);
-				HarmonyExports.enable(parser.state, isStrictHarmony);
-				parser.scope.isStrict = true;
-			}
-		});
+/** @type {ResolveOptions} */
+const EMPTY_RESOLVE_OPTIONS = {};
 
-		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
-			const module = parser.state.module;
-			if (!this.topLevelAwait) {
-				throw new Error(
-					"The top-level-await experiment is not enabled (set experiments.topLevelAwait: true to enabled it)"
+class RequireContextPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireContextPlugin",
+			(compilation, { contextModuleFactory, normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireContextDependency,
+					contextModuleFactory
 				);
-			}
-			if (!HarmonyExports.isEnabled(parser.state)) {
-				throw new Error(
-					"Top-level-await is only supported in EcmaScript Modules"
+				compilation.dependencyTemplates.set(
+					RequireContextDependency,
+					new RequireContextDependency.Template()
 				);
-			}
-			module.buildMeta.async = true;
-		});
 
-		const skipInHarmony = () => {
-			if (HarmonyExports.isEnabled(parser.state)) {
-				return true;
-			}
-		};
+				compilation.dependencyFactories.set(
+					ContextElementDependency,
+					normalModuleFactory
+				);
 
-		const nullInHarmony = () => {
-			if (HarmonyExports.isEnabled(parser.state)) {
-				return null;
-			}
-		};
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireContext !== undefined &&
+						!parserOptions.requireContext
+					)
+						return;
 
-		const nonHarmonyIdentifiers = ["define", "exports"];
-		for (const identifier of nonHarmonyIdentifiers) {
-			parser.hooks.evaluateTypeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.typeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.evaluate
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.expression
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.call
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-		}
+					new RequireContextDependencyParserPlugin().apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireContextPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireContextPlugin", handler);
+
+				contextModuleFactory.hooks.alternativeRequests.tap(
+					"RequireContextPlugin",
+					(items, options) => {
+						if (items.length === 0) return items;
+
+						const finalResolveOptions = compiler.resolverFactory.get(
+							"normal",
+							cachedSetProperty(
+								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
+								"dependencyType",
+								options.category
+							)
+						).options;
+
+						let newItems;
+						if (!finalResolveOptions.fullySpecified) {
+							newItems = [];
+							for (const item of items) {
+								const { request, context } = item;
+								for (const ext of finalResolveOptions.extensions) {
+									if (request.endsWith(ext)) {
+										newItems.push({
+											context,
+											request: request.slice(0, -ext.length)
+										});
+									}
+								}
+								if (!finalResolveOptions.enforceExtension) {
+									newItems.push(item);
+								}
+							}
+							items = newItems;
+
+							newItems = [];
+							for (const obj of items) {
+								const { request, context } = obj;
+								for (const mainFile of finalResolveOptions.mainFiles) {
+									if (request.endsWith(`/${mainFile}`)) {
+										newItems.push({
+											context,
+											request: request.slice(0, -mainFile.length)
+										});
+										newItems.push({
+											context,
+											request: request.slice(0, -mainFile.length - 1)
+										});
+									}
+								}
+								newItems.push(obj);
+							}
+							items = newItems;
+						}
+
+						newItems = [];
+						for (const item of items) {
+							let hideOriginal = false;
+							for (const modulesItems of finalResolveOptions.modules) {
+								if (Array.isArray(modulesItems)) {
+									for (const dir of modulesItems) {
+										if (item.request.startsWith(`./${dir}/`)) {
+											newItems.push({
+												context: item.context,
+												request: item.request.slice(dir.length + 3)
+											});
+											hideOriginal = true;
+										}
+									}
+								} else {
+									const dir = modulesItems.replace(/\\/g, "/");
+									const fullPath =
+										item.context.replace(/\\/g, "/") + item.request.slice(1);
+									if (fullPath.startsWith(dir)) {
+										newItems.push({
+											context: item.context,
+											request: fullPath.slice(dir.length + 1)
+										});
+									}
+								}
+							}
+							if (!hideOriginal) {
+								newItems.push(item);
+							}
+						}
+						return newItems;
+					}
+				);
+			}
+		);
 	}
-};
+}
+module.exports = RequireContextPlugin;
 
 
 /***/ }),
 
-/***/ 93466:
+/***/ 27153:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -83809,189 +82569,26 @@ module.exports = class HarmonyDetectionParserPlugin {
 
 
 
-const InnerGraph = __webpack_require__(38988);
-const ConstDependency = __webpack_require__(76911);
-const HarmonyExportExpressionDependency = __webpack_require__(51340);
-const HarmonyExportHeaderDependency = __webpack_require__(38873);
-const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
-const HarmonyExportSpecifierDependency = __webpack_require__(48567);
-const { ExportPresenceModes } = __webpack_require__(57154);
-const {
-	harmonySpecifierTag,
-	getAssertions
-} = __webpack_require__(20862);
-const HarmonyImportSideEffectDependency = __webpack_require__(73132);
-
-const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const makeSerializable = __webpack_require__(33032);
 
-module.exports = class HarmonyExportDependencyParserPlugin {
-	constructor(options) {
-		this.exportPresenceMode =
-			options.reexportExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
-				: options.exportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.exportsPresence)
-				: options.strictExportPresence
-				? ExportPresenceModes.ERROR
-				: ExportPresenceModes.AUTO;
+class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
+	constructor(chunkName, loc) {
+		super(chunkName, loc, null);
 	}
+}
 
-	apply(parser) {
-		const { exportPresenceMode } = this;
-		parser.hooks.export.tap(
-			"HarmonyExportDependencyParserPlugin",
-			statement => {
-				const dep = new HarmonyExportHeaderDependency(
-					statement.declaration && statement.declaration.range,
-					statement.range
-				);
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = -1;
-				parser.state.module.addPresentationalDependency(dep);
-				return true;
-			}
-		);
-		parser.hooks.exportImport.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, source) => {
-				parser.state.lastHarmonyImportOrder =
-					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency("", statement.range);
-				clearDep.loc = Object.create(statement.loc);
-				clearDep.loc.index = -1;
-				parser.state.module.addPresentationalDependency(clearDep);
-				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					source,
-					parser.state.lastHarmonyImportOrder,
-					getAssertions(statement)
-				);
-				sideEffectDep.loc = Object.create(statement.loc);
-				sideEffectDep.loc.index = -1;
-				parser.state.current.addDependency(sideEffectDep);
-				return true;
-			}
-		);
-		parser.hooks.exportExpression.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, expr) => {
-				const isFunctionDeclaration = expr.type === "FunctionDeclaration";
-				const comments = parser.getComments([
-					statement.range[0],
-					expr.range[0]
-				]);
-				const dep = new HarmonyExportExpressionDependency(
-					expr.range,
-					statement.range,
-					comments
-						.map(c => {
-							switch (c.type) {
-								case "Block":
-									return `/*${c.value}*/`;
-								case "Line":
-									return `//${c.value}\n`;
-							}
-							return "";
-						})
-						.join(""),
-					expr.type.endsWith("Declaration") && expr.id
-						? expr.id.name
-						: isFunctionDeclaration
-						? {
-								id: expr.id ? expr.id.name : undefined,
-								range: [
-									expr.range[0],
-									expr.params.length > 0
-										? expr.params[0].range[0]
-										: expr.body.range[0]
-								],
-								prefix: `${expr.async ? "async " : ""}function${
-									expr.generator ? "*" : ""
-								} `,
-								suffix: `(${expr.params.length > 0 ? "" : ") "}`
-						  }
-						: undefined
-				);
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = -1;
-				parser.state.current.addDependency(dep);
-				InnerGraph.addVariableUsage(
-					parser,
-					expr.type.endsWith("Declaration") && expr.id
-						? expr.id.name
-						: "*default*",
-					"default"
-				);
-				return true;
-			}
-		);
-		parser.hooks.exportSpecifier.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, id, name, idx) => {
-				const settings = parser.getTagData(id, harmonySpecifierTag);
-				let dep;
-				const harmonyNamedExports = (parser.state.harmonyNamedExports =
-					parser.state.harmonyNamedExports || new Set());
-				harmonyNamedExports.add(name);
-				InnerGraph.addVariableUsage(parser, id, name);
-				if (settings) {
-					dep = new HarmonyExportImportedSpecifierDependency(
-						settings.source,
-						settings.sourceOrder,
-						settings.ids,
-						name,
-						harmonyNamedExports,
-						null,
-						exportPresenceMode,
-						null,
-						settings.assertions
-					);
-				} else {
-					dep = new HarmonyExportSpecifierDependency(id, name);
-				}
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = idx;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		);
-		parser.hooks.exportImportSpecifier.tap(
-			"HarmonyExportDependencyParserPlugin",
-			(statement, source, id, name, idx) => {
-				const harmonyNamedExports = (parser.state.harmonyNamedExports =
-					parser.state.harmonyNamedExports || new Set());
-				let harmonyStarExports = null;
-				if (name) {
-					harmonyNamedExports.add(name);
-				} else {
-					harmonyStarExports = parser.state.harmonyStarExports =
-						parser.state.harmonyStarExports || new HarmonyStarExportsList();
-				}
-				const dep = new HarmonyExportImportedSpecifierDependency(
-					source,
-					parser.state.lastHarmonyImportOrder,
-					id ? [id] : [],
-					name,
-					harmonyNamedExports,
-					harmonyStarExports && harmonyStarExports.slice(),
-					exportPresenceMode,
-					harmonyStarExports
-				);
-				if (harmonyStarExports) {
-					harmonyStarExports.push(dep);
-				}
-				dep.loc = Object.create(statement.loc);
-				dep.loc.index = idx;
-				parser.state.current.addDependency(dep);
-				return true;
-			}
-		);
-	}
-};
+makeSerializable(
+	RequireEnsureDependenciesBlock,
+	"webpack/lib/dependencies/RequireEnsureDependenciesBlock"
+);
+
+module.exports = RequireEnsureDependenciesBlock;
 
 
 /***/ }),
 
-/***/ 51340:
+/***/ 7235:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -84002,80 +82599,184 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 
 
 
-const ConcatenationScope = __webpack_require__(98229);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const HarmonyExportInitFragment = __webpack_require__(89500);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-
-class HarmonyExportExpressionDependency extends NullDependency {
-	constructor(range, rangeStatement, prefix, declarationId) {
-		super();
-		this.range = range;
-		this.rangeStatement = rangeStatement;
-		this.prefix = prefix;
-		this.declarationId = declarationId;
-	}
+const RequireEnsureDependenciesBlock = __webpack_require__(27153);
+const RequireEnsureDependency = __webpack_require__(27223);
+const RequireEnsureItemDependency = __webpack_require__(50329);
+const getFunctionExpression = __webpack_require__(50396);
 
-	get type() {
-		return "harmony export expression";
-	}
+module.exports = class RequireEnsureDependenciesBlockParserPlugin {
+	apply(parser) {
+		parser.hooks.call
+			.for("require.ensure")
+			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
+				let chunkName = null;
+				let errorExpressionArg = null;
+				let errorExpression = null;
+				switch (expr.arguments.length) {
+					case 4: {
+						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+						if (!chunkNameExpr.isString()) return;
+						chunkName = chunkNameExpr.string;
+					}
+					// falls through
+					case 3: {
+						errorExpressionArg = expr.arguments[2];
+						errorExpression = getFunctionExpression(errorExpressionArg);
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: ["default"],
-			priority: 1,
-			terminalBinding: true,
-			dependencies: undefined
-		};
+						if (!errorExpression && !chunkName) {
+							const chunkNameExpr = parser.evaluateExpression(
+								expr.arguments[2]
+							);
+							if (!chunkNameExpr.isString()) return;
+							chunkName = chunkNameExpr.string;
+						}
+					}
+					// falls through
+					case 2: {
+						const dependenciesExpr = parser.evaluateExpression(
+							expr.arguments[0]
+						);
+						const dependenciesItems = dependenciesExpr.isArray()
+							? dependenciesExpr.items
+							: [dependenciesExpr];
+						const successExpressionArg = expr.arguments[1];
+						const successExpression =
+							getFunctionExpression(successExpressionArg);
+
+						if (successExpression) {
+							parser.walkExpressions(successExpression.expressions);
+						}
+						if (errorExpression) {
+							parser.walkExpressions(errorExpression.expressions);
+						}
+
+						const depBlock = new RequireEnsureDependenciesBlock(
+							chunkName,
+							expr.loc
+						);
+						const errorCallbackExists =
+							expr.arguments.length === 4 ||
+							(!chunkName && expr.arguments.length === 3);
+						const dep = new RequireEnsureDependency(
+							expr.range,
+							expr.arguments[1].range,
+							errorCallbackExists && expr.arguments[2].range
+						);
+						dep.loc = expr.loc;
+						depBlock.addDependency(dep);
+						const old = parser.state.current;
+						parser.state.current = depBlock;
+						try {
+							let failed = false;
+							parser.inScope([], () => {
+								for (const ee of dependenciesItems) {
+									if (ee.isString()) {
+										const ensureDependency = new RequireEnsureItemDependency(
+											ee.string
+										);
+										ensureDependency.loc = ee.loc || expr.loc;
+										depBlock.addDependency(ensureDependency);
+									} else {
+										failed = true;
+									}
+								}
+							});
+							if (failed) {
+								return;
+							}
+							if (successExpression) {
+								if (successExpression.fn.body.type === "BlockStatement") {
+									parser.walkStatement(successExpression.fn.body);
+								} else {
+									parser.walkExpression(successExpression.fn.body);
+								}
+							}
+							old.addBlock(depBlock);
+						} finally {
+							parser.state.current = old;
+						}
+						if (!successExpression) {
+							parser.walkExpression(successExpressionArg);
+						}
+						if (errorExpression) {
+							if (errorExpression.fn.body.type === "BlockStatement") {
+								parser.walkStatement(errorExpression.fn.body);
+							} else {
+								parser.walkExpression(errorExpression.fn.body);
+							}
+						} else if (errorExpressionArg) {
+							parser.walkExpression(errorExpressionArg);
+						}
+						return true;
+					}
+				}
+			});
 	}
+};
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		// The expression/declaration is already covered by SideEffectsFlagPlugin
-		return false;
+
+/***/ }),
+
+/***/ 27223:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class RequireEnsureDependency extends NullDependency {
+	constructor(range, contentRange, errorHandlerRange) {
+		super();
+
+		this.range = range;
+		this.contentRange = contentRange;
+		this.errorHandlerRange = errorHandlerRange;
+	}
+
+	get type() {
+		return "require.ensure";
 	}
 
 	serialize(context) {
 		const { write } = context;
+
 		write(this.range);
-		write(this.rangeStatement);
-		write(this.prefix);
-		write(this.declarationId);
+		write(this.contentRange);
+		write(this.errorHandlerRange);
+
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
+
 		this.range = read();
-		this.rangeStatement = read();
-		this.prefix = read();
-		this.declarationId = read();
+		this.contentRange = read();
+		this.errorHandlerRange = read();
+
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	HarmonyExportExpressionDependency,
-	"webpack/lib/dependencies/HarmonyExportExpressionDependency"
+	RequireEnsureDependency,
+	"webpack/lib/dependencies/RequireEnsureDependency"
 );
 
-HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTemplate extends (
+RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -84087,109 +82788,160 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 	apply(
 		dependency,
 		source,
-		{
-			module,
-			moduleGraph,
-			runtimeTemplate,
-			runtimeRequirements,
-			initFragments,
-			runtime,
-			concatenationScope
-		}
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
 	) {
-		const dep = /** @type {HarmonyExportExpressionDependency} */ (dependency);
-		const { declarationId } = dep;
-		const exportsName = module.exportsArgument;
-		if (declarationId) {
-			let name;
-			if (typeof declarationId === "string") {
-				name = declarationId;
-			} else {
-				name = ConcatenationScope.DEFAULT_EXPORT;
-				source.replace(
-					declarationId.range[0],
-					declarationId.range[1] - 1,
-					`${declarationId.prefix}${name}${declarationId.suffix}`
-				);
-			}
-
-			if (concatenationScope) {
-				concatenationScope.registerExport("default", name);
-			} else {
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName("default", runtime);
-				if (used) {
-					const map = new Map();
-					map.set(used, `/* export default binding */ ${name}`);
-					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
-				}
-			}
-
+		const dep = /** @type {RequireEnsureDependency} */ (dependency);
+		const depBlock = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dep)
+		);
+		const promise = runtimeTemplate.blockPromise({
+			chunkGraph,
+			block: depBlock,
+			message: "require.ensure",
+			runtimeRequirements
+		});
+		const range = dep.range;
+		const contentRange = dep.contentRange;
+		const errorHandlerRange = dep.errorHandlerRange;
+		source.replace(range[0], contentRange[0] - 1, `${promise}.then((`);
+		if (errorHandlerRange) {
 			source.replace(
-				dep.rangeStatement[0],
-				dep.range[0] - 1,
-				`/* harmony default export */ ${dep.prefix}`
+				contentRange[1],
+				errorHandlerRange[0] - 1,
+				").bind(null, __webpack_require__))['catch']("
 			);
+			source.replace(errorHandlerRange[1], range[1] - 1, ")");
 		} else {
-			let content;
-			const name = ConcatenationScope.DEFAULT_EXPORT;
-			if (runtimeTemplate.supportsConst()) {
-				content = `/* harmony default export */ const ${name} = `;
-				if (concatenationScope) {
-					concatenationScope.registerExport("default", name);
-				} else {
-					const used = moduleGraph
-						.getExportsInfo(module)
-						.getUsedName("default", runtime);
-					if (used) {
-						runtimeRequirements.add(RuntimeGlobals.exports);
-						const map = new Map();
-						map.set(used, name);
-						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
-					} else {
-						content = `/* unused harmony default export */ var ${name} = `;
-					}
-				}
-			} else if (concatenationScope) {
-				content = `/* harmony default export */ var ${name} = `;
-				concatenationScope.registerExport("default", name);
-			} else {
-				const used = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName("default", runtime);
-				if (used) {
-					runtimeRequirements.add(RuntimeGlobals.exports);
-					// This is a little bit incorrect as TDZ is not correct, but we can't use const.
-					content = `/* harmony default export */ ${exportsName}[${JSON.stringify(
-						used
-					)}] = `;
-				} else {
-					content = `/* unused harmony default export */ var ${name} = `;
-				}
-			}
-
-			if (dep.range) {
-				source.replace(
-					dep.rangeStatement[0],
-					dep.range[0] - 1,
-					content + "(" + dep.prefix
-				);
-				source.replace(dep.range[1], dep.rangeStatement[1] - 0.5, ");");
-				return;
-			}
-
-			source.replace(dep.rangeStatement[0], dep.rangeStatement[1] - 1, content);
+			source.replace(
+				contentRange[1],
+				range[1] - 1,
+				`).bind(null, __webpack_require__))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`
+			);
 		}
 	}
 };
 
-module.exports = HarmonyExportExpressionDependency;
+module.exports = RequireEnsureDependency;
 
 
 /***/ }),
 
-/***/ 38873:
+/***/ 50329:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const NullDependency = __webpack_require__(31830);
+
+class RequireEnsureItemDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
+	}
+
+	get type() {
+		return "require.ensure item";
+	}
+
+	get category() {
+		return "commonjs";
+	}
+}
+
+makeSerializable(
+	RequireEnsureItemDependency,
+	"webpack/lib/dependencies/RequireEnsureItemDependency"
+);
+
+RequireEnsureItemDependency.Template = NullDependency.Template;
+
+module.exports = RequireEnsureItemDependency;
+
+
+/***/ }),
+
+/***/ 8434:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RequireEnsureDependency = __webpack_require__(27223);
+const RequireEnsureItemDependency = __webpack_require__(50329);
+
+const RequireEnsureDependenciesBlockParserPlugin = __webpack_require__(7235);
+
+const {
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
+
+class RequireEnsurePlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireEnsurePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireEnsureItemDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireEnsureItemDependency,
+					new RequireEnsureItemDependency.Template()
+				);
+
+				compilation.dependencyTemplates.set(
+					RequireEnsureDependency,
+					new RequireEnsureDependency.Template()
+				);
+
+				const handler = (parser, parserOptions) => {
+					if (
+						parserOptions.requireEnsure !== undefined &&
+						!parserOptions.requireEnsure
+					)
+						return;
+
+					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);
+					parser.hooks.evaluateTypeof
+						.for("require.ensure")
+						.tap("RequireEnsurePlugin", evaluateToString("function"));
+					parser.hooks.typeof
+						.for("require.ensure")
+						.tap(
+							"RequireEnsurePlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireEnsurePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireEnsurePlugin", handler);
+			}
+		);
+	}
+}
+module.exports = RequireEnsurePlugin;
+
+
+/***/ }),
+
+/***/ 89183:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -84200,6 +82952,7 @@ module.exports = HarmonyExportExpressionDependency;
 
 
 
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
 const NullDependency = __webpack_require__(31830);
 
@@ -84207,38 +82960,32 @@ const NullDependency = __webpack_require__(31830);
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-class HarmonyExportHeaderDependency extends NullDependency {
-	constructor(range, rangeStatement) {
+class RequireHeaderDependency extends NullDependency {
+	constructor(range) {
 		super();
+		if (!Array.isArray(range)) throw new Error("range must be valid");
 		this.range = range;
-		this.rangeStatement = rangeStatement;
-	}
-
-	get type() {
-		return "harmony export header";
 	}
 
 	serialize(context) {
 		const { write } = context;
 		write(this.range);
-		write(this.rangeStatement);
 		super.serialize(context);
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.rangeStatement = read();
-		super.deserialize(context);
+	static deserialize(context) {
+		const obj = new RequireHeaderDependency(context.read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
 makeSerializable(
-	HarmonyExportHeaderDependency,
-	"webpack/lib/dependencies/HarmonyExportHeaderDependency"
+	RequireHeaderDependency,
+	"webpack/lib/dependencies/RequireHeaderDependency"
 );
 
-HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate extends (
+RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -84247,22 +82994,19 @@ HarmonyExportHeaderDependency.Template = class HarmonyExportDependencyTemplate e
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyExportHeaderDependency} */ (dependency);
-		const content = "";
-		const replaceUntil = dep.range
-			? dep.range[0] - 1
-			: dep.rangeStatement[1] - 1;
-		source.replace(dep.rangeStatement[0], replaceUntil, content);
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {RequireHeaderDependency} */ (dependency);
+		runtimeRequirements.add(RuntimeGlobals.require);
+		source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__");
 	}
 };
 
-module.exports = HarmonyExportHeaderDependency;
+module.exports = RequireHeaderDependency;
 
 
 /***/ }),
 
-/***/ 67157:
+/***/ 71284:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -84274,894 +83018,464 @@ module.exports = HarmonyExportHeaderDependency;
 
 
 const Dependency = __webpack_require__(54912);
-const { UsageState } = __webpack_require__(63686);
-const HarmonyLinkingError = __webpack_require__(97511);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const { countIterable } = __webpack_require__(39104);
-const { first, combine } = __webpack_require__(93347);
+const Template = __webpack_require__(1626);
 const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const { getRuntimeKey, keyToRuntime } = __webpack_require__(17156);
-const HarmonyExportInitFragment = __webpack_require__(89500);
-const HarmonyImportDependency = __webpack_require__(57154);
-const processExportInfo = __webpack_require__(55207);
+const ModuleDependency = __webpack_require__(80321);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {"missing"|"unused"|"empty-star"|"reexport-dynamic-default"|"reexport-named-default"|"reexport-namespace-object"|"reexport-fake-namespace-object"|"reexport-undefined"|"normal-reexport"|"dynamic-reexport"} ExportModeType */
-
-const { ExportPresenceModes } = HarmonyImportDependency;
-
-const idsSymbol = Symbol("HarmonyExportImportedSpecifierDependency.ids");
+class RequireIncludeDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
 
-class NormalReexportItem {
-	/**
-	 * @param {string} name export name
-	 * @param {string[]} ids reexported ids from other module
-	 * @param {ExportInfo} exportInfo export info from other module
-	 * @param {boolean} checked true, if it should be checked at runtime if this export exists
-	 * @param {boolean} hidden true, if it is hidden behind another active export in the same module
-	 */
-	constructor(name, ids, exportInfo, checked, hidden) {
-		this.name = name;
-		this.ids = ids;
-		this.exportInfo = exportInfo;
-		this.checked = checked;
-		this.hidden = hidden;
+		this.range = range;
 	}
-}
 
-class ExportMode {
 	/**
-	 * @param {ExportModeType} type type of the mode
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	constructor(type) {
-		/** @type {ExportModeType} */
-		this.type = type;
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
 
-		// for "normal-reexport":
-		/** @type {NormalReexportItem[] | null} */
-		this.items = null;
+	get type() {
+		return "require.include";
+	}
 
-		// for "reexport-named-default" | "reexport-fake-namespace-object" | "reexport-namespace-object"
-		/** @type {string|null} */
-		this.name = null;
-		/** @type {ExportInfo | null} */
-		this.partialNamespaceExportInfo = null;
+	get category() {
+		return "commonjs";
+	}
+}
 
-		// for "dynamic-reexport":
-		/** @type {Set<string> | null} */
-		this.ignored = null;
+makeSerializable(
+	RequireIncludeDependency,
+	"webpack/lib/dependencies/RequireIncludeDependency"
+);
 
-		// for "dynamic-reexport" | "empty-star":
-		/** @type {Set<string> | null} */
-		this.hidden = null;
-
-		// for "missing":
-		/** @type {string | null} */
-		this.userRequest = null;
+RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, { runtimeTemplate }) {
+		const dep = /** @type {RequireIncludeDependency} */ (dependency);
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`require.include ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
+			  )
+			: "";
 
-		// for "reexport-fake-namespace-object":
-		/** @type {number} */
-		this.fakeType = 0;
+		source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`);
 	}
-}
+};
 
-const determineExportAssignments = (
-	moduleGraph,
-	dependencies,
-	additionalDependency
-) => {
-	const names = new Set();
-	const dependencyIndices = [];
+module.exports = RequireIncludeDependency;
 
-	if (additionalDependency) {
-		dependencies = dependencies.concat(additionalDependency);
-	}
 
-	for (const dep of dependencies) {
-		const i = dependencyIndices.length;
-		dependencyIndices[i] = names.size;
-		const otherImportedModule = moduleGraph.getModule(dep);
-		if (otherImportedModule) {
-			const exportsInfo = moduleGraph.getExportsInfo(otherImportedModule);
-			for (const exportInfo of exportsInfo.exports) {
-				if (
-					exportInfo.provided === true &&
-					exportInfo.name !== "default" &&
-					!names.has(exportInfo.name)
-				) {
-					names.add(exportInfo.name);
-					dependencyIndices[i] = names.size;
-				}
-			}
-		}
+/***/ }),
+
+/***/ 35768:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+const {
+	evaluateToString,
+	toConstantDependency
+} = __webpack_require__(93998);
+const makeSerializable = __webpack_require__(33032);
+const RequireIncludeDependency = __webpack_require__(71284);
+
+module.exports = class RequireIncludeDependencyParserPlugin {
+	constructor(warn) {
+		this.warn = warn;
 	}
-	dependencyIndices.push(names.size);
+	apply(parser) {
+		const { warn } = this;
+		parser.hooks.call
+			.for("require.include")
+			.tap("RequireIncludeDependencyParserPlugin", expr => {
+				if (expr.arguments.length !== 1) return;
+				const param = parser.evaluateExpression(expr.arguments[0]);
+				if (!param.isString()) return;
 
-	return { names: Array.from(names), dependencyIndices };
-};
+				if (warn) {
+					parser.state.module.addWarning(
+						new RequireIncludeDeprecationWarning(expr.loc)
+					);
+				}
 
-const findDependencyForName = (
-	{ names, dependencyIndices },
-	name,
-	dependencies
-) => {
-	const dependenciesIt = dependencies[Symbol.iterator]();
-	const dependencyIndicesIt = dependencyIndices[Symbol.iterator]();
-	let dependenciesItResult = dependenciesIt.next();
-	let dependencyIndicesItResult = dependencyIndicesIt.next();
-	if (dependencyIndicesItResult.done) return;
-	for (let i = 0; i < names.length; i++) {
-		while (i >= dependencyIndicesItResult.value) {
-			dependenciesItResult = dependenciesIt.next();
-			dependencyIndicesItResult = dependencyIndicesIt.next();
-			if (dependencyIndicesItResult.done) return;
-		}
-		if (names[i] === name) return dependenciesItResult.value;
+				const dep = new RequireIncludeDependency(param.string, expr.range);
+				dep.loc = expr.loc;
+				parser.state.current.addDependency(dep);
+				return true;
+			});
+		parser.hooks.evaluateTypeof
+			.for("require.include")
+			.tap("RequireIncludePlugin", expr => {
+				if (warn) {
+					parser.state.module.addWarning(
+						new RequireIncludeDeprecationWarning(expr.loc)
+					);
+				}
+				return evaluateToString("function")(expr);
+			});
+		parser.hooks.typeof
+			.for("require.include")
+			.tap("RequireIncludePlugin", expr => {
+				if (warn) {
+					parser.state.module.addWarning(
+						new RequireIncludeDeprecationWarning(expr.loc)
+					);
+				}
+				return toConstantDependency(parser, JSON.stringify("function"))(expr);
+			});
 	}
-	return undefined;
 };
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {HarmonyExportImportedSpecifierDependency} dep the dependency
- * @param {string} runtimeKey the runtime key
- * @returns {ExportMode} the export mode
- */
-const getMode = (moduleGraph, dep, runtimeKey) => {
-	const importedModule = moduleGraph.getModule(dep);
-
-	if (!importedModule) {
-		const mode = new ExportMode("missing");
+class RequireIncludeDeprecationWarning extends WebpackError {
+	constructor(loc) {
+		super("require.include() is deprecated and will be removed soon.");
 
-		mode.userRequest = dep.userRequest;
+		this.name = "RequireIncludeDeprecationWarning";
 
-		return mode;
+		this.loc = loc;
 	}
+}
 
-	const name = dep.name;
-	const runtime = keyToRuntime(runtimeKey);
-	const parentModule = moduleGraph.getParentModule(dep);
-	const exportsInfo = moduleGraph.getExportsInfo(parentModule);
+makeSerializable(
+	RequireIncludeDeprecationWarning,
+	"webpack/lib/dependencies/RequireIncludeDependencyParserPlugin",
+	"RequireIncludeDeprecationWarning"
+);
 
-	if (
-		name
-			? exportsInfo.getUsed(name, runtime) === UsageState.Unused
-			: exportsInfo.isUsed(runtime) === false
-	) {
-		const mode = new ExportMode("unused");
 
-		mode.name = name || "*";
+/***/ }),
 
-		return mode;
-	}
+/***/ 37378:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	const importedExportsType = importedModule.getExportsType(
-		moduleGraph,
-		parentModule.buildMeta.strictHarmonyModule
-	);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	const ids = dep.getIds(moduleGraph);
 
-	// Special handling for reexporting the default export
-	// from non-namespace modules
-	if (name && ids.length > 0 && ids[0] === "default") {
-		switch (importedExportsType) {
-			case "dynamic": {
-				const mode = new ExportMode("reexport-dynamic-default");
 
-				mode.name = name;
+const RequireIncludeDependency = __webpack_require__(71284);
+const RequireIncludeDependencyParserPlugin = __webpack_require__(35768);
 
-				return mode;
-			}
-			case "default-only":
-			case "default-with-named": {
-				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-				const mode = new ExportMode("reexport-named-default");
+class RequireIncludePlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"RequireIncludePlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					RequireIncludeDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					RequireIncludeDependency,
+					new RequireIncludeDependency.Template()
+				);
 
-				mode.name = name;
-				mode.partialNamespaceExportInfo = exportInfo;
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.requireInclude === false) return;
+					const warn = parserOptions.requireInclude === undefined;
 
-				return mode;
+					new RequireIncludeDependencyParserPlugin(warn).apply(parser);
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("RequireIncludePlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("RequireIncludePlugin", handler);
 			}
-		}
+		);
 	}
+}
+module.exports = RequireIncludePlugin;
 
-	// reexporting with a fixed name
-	if (name) {
-		let mode;
-		const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
 
-		if (ids.length > 0) {
-			// export { name as name }
-			switch (importedExportsType) {
-				case "default-only":
-					mode = new ExportMode("reexport-undefined");
-					mode.name = name;
-					break;
-				default:
-					mode = new ExportMode("normal-reexport");
-					mode.items = [
-						new NormalReexportItem(name, ids, exportInfo, false, false)
-					];
-					break;
-			}
-		} else {
-			// export * as name
-			switch (importedExportsType) {
-				case "default-only":
-					mode = new ExportMode("reexport-fake-namespace-object");
-					mode.name = name;
-					mode.partialNamespaceExportInfo = exportInfo;
-					mode.fakeType = 0;
-					break;
-				case "default-with-named":
-					mode = new ExportMode("reexport-fake-namespace-object");
-					mode.name = name;
-					mode.partialNamespaceExportInfo = exportInfo;
-					mode.fakeType = 2;
-					break;
-				case "dynamic":
-				default:
-					mode = new ExportMode("reexport-namespace-object");
-					mode.name = name;
-					mode.partialNamespaceExportInfo = exportInfo;
-			}
-		}
+/***/ }),
 
-		return mode;
-	}
+/***/ 55627:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	// Star reexporting
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	const { ignoredExports, exports, checked, hidden } = dep.getStarReexports(
-		moduleGraph,
-		runtime,
-		exportsInfo,
-		importedModule
-	);
-	if (!exports) {
-		// We have too few info about the modules
-		// Delegate the logic to the runtime code
 
-		const mode = new ExportMode("dynamic-reexport");
-		mode.ignored = ignoredExports;
-		mode.hidden = hidden;
 
-		return mode;
-	}
+const makeSerializable = __webpack_require__(33032);
+const ContextDependency = __webpack_require__(88101);
+const ContextDependencyTemplateAsId = __webpack_require__(76081);
 
-	if (exports.size === 0) {
-		const mode = new ExportMode("empty-star");
-		mode.hidden = hidden;
+class RequireResolveContextDependency extends ContextDependency {
+	constructor(options, range, valueRange) {
+		super(options);
 
-		return mode;
+		this.range = range;
+		this.valueRange = valueRange;
 	}
 
-	const mode = new ExportMode("normal-reexport");
-
-	mode.items = Array.from(
-		exports,
-		exportName =>
-			new NormalReexportItem(
-				exportName,
-				[exportName],
-				exportsInfo.getReadOnlyExportInfo(exportName),
-				checked.has(exportName),
-				false
-			)
-	);
-	if (hidden !== undefined) {
-		for (const exportName of hidden) {
-			mode.items.push(
-				new NormalReexportItem(
-					exportName,
-					[exportName],
-					exportsInfo.getReadOnlyExportInfo(exportName),
-					false,
-					true
-				)
-			);
-		}
+	get type() {
+		return "amd require context";
 	}
 
-	return mode;
-};
+	serialize(context) {
+		const { write } = context;
 
-class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
-	/**
-	 * @param {string} request the request string
-	 * @param {number} sourceOrder the order in the original source file
-	 * @param {string[]} ids the requested export name of the imported module
-	 * @param {string | null} name the export name of for this module
-	 * @param {Set<string>} activeExports other named exports in the module
-	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency>} otherStarExports other star exports in the module before this import
-	 * @param {number} exportPresenceMode mode of checking export names
-	 * @param {HarmonyStarExportsList} allStarExports all star exports in the module
-	 * @param {Record<string, any>=} assertions import assertions
-	 */
-	constructor(
-		request,
-		sourceOrder,
-		ids,
-		name,
-		activeExports,
-		otherStarExports,
-		exportPresenceMode,
-		allStarExports,
-		assertions
-	) {
-		super(request, sourceOrder, assertions);
+		write(this.range);
+		write(this.valueRange);
 
-		this.ids = ids;
-		this.name = name;
-		this.activeExports = activeExports;
-		this.otherStarExports = otherStarExports;
-		this.exportPresenceMode = exportPresenceMode;
-		this.allStarExports = allStarExports;
+		super.serialize(context);
 	}
 
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return Dependency.TRANSITIVE;
-	}
+	deserialize(context) {
+		const { read } = context;
 
-	// TODO webpack 6 remove
-	get id() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
+		this.range = read();
+		this.valueRange = read();
 
-	// TODO webpack 6 remove
-	getId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
+		super.deserialize(context);
 	}
+}
 
-	// TODO webpack 6 remove
-	setId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
+makeSerializable(
+	RequireResolveContextDependency,
+	"webpack/lib/dependencies/RequireResolveContextDependency"
+);
+
+RequireResolveContextDependency.Template = ContextDependencyTemplateAsId;
+
+module.exports = RequireResolveContextDependency;
+
+
+/***/ }),
+
+/***/ 68582:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+const ModuleDependencyAsId = __webpack_require__(80825);
+
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class RequireResolveDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+
+		this.range = range;
 	}
 
 	get type() {
-		return "harmony export imported specifier";
+		return "require.resolve";
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported id
-	 */
-	getIds(moduleGraph) {
-		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
+	get category() {
+		return "commonjs";
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
-	 * @returns {void}
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	setIds(moduleGraph, ids) {
-		moduleGraph.getMeta(this)[idsSymbol] = ids;
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {ExportMode} the export mode
-	 */
-	getMode(moduleGraph, runtime) {
-		return moduleGraph.dependencyCacheProvide(
-			this,
-			getRuntimeKey(runtime),
-			getMode
-		);
-	}
+makeSerializable(
+	RequireResolveDependency,
+	"webpack/lib/dependencies/RequireResolveDependency"
+);
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {ExportsInfo} exportsInfo exports info about the current module (optional)
-	 * @param {Module} importedModule the imported module (optional)
-	 * @returns {{exports?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden?: Set<string>}} information
-	 */
-	getStarReexports(
-		moduleGraph,
-		runtime,
-		exportsInfo = moduleGraph.getExportsInfo(moduleGraph.getParentModule(this)),
-		importedModule = moduleGraph.getModule(this)
-	) {
-		const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+RequireResolveDependency.Template = ModuleDependencyAsId;
 
-		const noExtraExports =
-			importedExportsInfo.otherExportsInfo.provided === false;
-		const noExtraImports =
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
+module.exports = RequireResolveDependency;
 
-		const ignoredExports = new Set(["default", ...this.activeExports]);
 
-		let hiddenExports = undefined;
-		const otherStarExports =
-			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
-		if (otherStarExports !== undefined) {
-			hiddenExports = new Set();
-			for (let i = 0; i < otherStarExports.namesSlice; i++) {
-				hiddenExports.add(otherStarExports.names[i]);
-			}
-			for (const e of ignoredExports) hiddenExports.delete(e);
-		}
+/***/ }),
 
-		if (!noExtraExports && !noExtraImports) {
-			return {
-				ignoredExports,
-				hidden: hiddenExports
-			};
-		}
-
-		/** @type {Set<string>} */
-		const exports = new Set();
-		/** @type {Set<string>} */
-		const checked = new Set();
-		/** @type {Set<string>} */
-		const hidden = hiddenExports !== undefined ? new Set() : undefined;
+/***/ 9880:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (noExtraImports) {
-			for (const exportInfo of exportsInfo.orderedExports) {
-				const name = exportInfo.name;
-				if (ignoredExports.has(name)) continue;
-				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				const importedExportInfo =
-					importedExportsInfo.getReadOnlyExportInfo(name);
-				if (importedExportInfo.provided === false) continue;
-				if (hiddenExports !== undefined && hiddenExports.has(name)) {
-					hidden.add(name);
-					continue;
-				}
-				exports.add(name);
-				if (importedExportInfo.provided === true) continue;
-				checked.add(name);
-			}
-		} else if (noExtraExports) {
-			for (const importedExportInfo of importedExportsInfo.orderedExports) {
-				const name = importedExportInfo.name;
-				if (ignoredExports.has(name)) continue;
-				if (importedExportInfo.provided === false) continue;
-				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
-				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
-				if (hiddenExports !== undefined && hiddenExports.has(name)) {
-					hidden.add(name);
-					continue;
-				}
-				exports.add(name);
-				if (importedExportInfo.provided === true) continue;
-				checked.add(name);
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		return { ignoredExports, exports, checked, hidden };
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
-	 */
-	getCondition(moduleGraph) {
-		return (connection, runtime) => {
-			const mode = this.getMode(moduleGraph, runtime);
-			return mode.type !== "unused" && mode.type !== "empty-star";
-		};
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
-	}
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		const mode = this.getMode(moduleGraph, runtime);
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 
-		switch (mode.type) {
-			case "missing":
-			case "unused":
-			case "empty-star":
-			case "reexport-undefined":
-				return Dependency.NO_EXPORTS_REFERENCED;
+class RequireResolveHeaderDependency extends NullDependency {
+	constructor(range) {
+		super();
 
-			case "reexport-dynamic-default":
-				return Dependency.EXPORTS_OBJECT_REFERENCED;
+		if (!Array.isArray(range)) throw new Error("range must be valid");
 
-			case "reexport-named-default": {
-				if (!mode.partialNamespaceExportInfo)
-					return Dependency.EXPORTS_OBJECT_REFERENCED;
-				/** @type {string[][]} */
-				const referencedExports = [];
-				processExportInfo(
-					runtime,
-					referencedExports,
-					[],
-					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo)
-				);
-				return referencedExports;
-			}
+		this.range = range;
+	}
 
-			case "reexport-namespace-object":
-			case "reexport-fake-namespace-object": {
-				if (!mode.partialNamespaceExportInfo)
-					return Dependency.EXPORTS_OBJECT_REFERENCED;
-				/** @type {string[][]} */
-				const referencedExports = [];
-				processExportInfo(
-					runtime,
-					referencedExports,
-					[],
-					/** @type {ExportInfo} */ (mode.partialNamespaceExportInfo),
-					mode.type === "reexport-fake-namespace-object"
-				);
-				return referencedExports;
-			}
+	serialize(context) {
+		const { write } = context;
 
-			case "dynamic-reexport":
-				return Dependency.EXPORTS_OBJECT_REFERENCED;
+		write(this.range);
 
-			case "normal-reexport": {
-				const referencedExports = [];
-				for (const { ids, exportInfo, hidden } of mode.items) {
-					if (hidden) continue;
-					processExportInfo(runtime, referencedExports, ids, exportInfo, false);
-				}
-				return referencedExports;
-			}
+		super.serialize(context);
+	}
 
-			default:
-				throw new Error(`Unknown mode ${mode.type}`);
-		}
+	static deserialize(context) {
+		const obj = new RequireResolveHeaderDependency(context.read());
+		obj.deserialize(context);
+		return obj;
 	}
+}
+
+makeSerializable(
+	RequireResolveHeaderDependency,
+	"webpack/lib/dependencies/RequireResolveHeaderDependency"
+);
 
+RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {{ names: string[], namesSlice: number, dependencyIndices: number[], dependencyIndex: number } | undefined} exported names and their origin dependency
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	_discoverActiveExportsFromOtherStarExports(moduleGraph) {
-		if (!this.otherStarExports) return undefined;
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {RequireResolveHeaderDependency} */ (dependency);
+		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	}
 
-		const i =
-			"length" in this.otherStarExports
-				? this.otherStarExports.length
-				: countIterable(this.otherStarExports);
-		if (i === 0) return undefined;
+	applyAsTemplateArgument(name, dep, source) {
+		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	}
+};
 
-		if (this.allStarExports) {
-			const { names, dependencyIndices } = moduleGraph.cached(
-				determineExportAssignments,
-				this.allStarExports.dependencies
-			);
+module.exports = RequireResolveHeaderDependency;
 
-			return {
-				names,
-				namesSlice: dependencyIndices[i - 1],
-				dependencyIndices,
-				dependencyIndex: i
-			};
-		}
 
-		const { names, dependencyIndices } = moduleGraph.cached(
-			determineExportAssignments,
-			this.otherStarExports,
-			this
-		);
+/***/ }),
 
-		return {
-			names,
-			namesSlice: dependencyIndices[i - 1],
-			dependencyIndices,
-			dependencyIndex: i
-		};
-	}
+/***/ 24187:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		const mode = this.getMode(moduleGraph, undefined);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		switch (mode.type) {
-			case "missing":
-				return undefined;
-			case "dynamic-reexport": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: true,
-					from,
-					canMangle: false,
-					excludeExports: mode.hidden
-						? combine(mode.ignored, mode.hidden)
-						: mode.ignored,
-					hideExports: mode.hidden,
-					dependencies: [from.module]
-				};
-			}
-			case "empty-star":
-				return {
-					exports: [],
-					hideExports: mode.hidden,
-					dependencies: [moduleGraph.getModule(this)]
-				};
-			// falls through
-			case "normal-reexport": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: Array.from(mode.items, item => ({
-						name: item.name,
-						from,
-						export: item.ids,
-						hidden: item.hidden
-					})),
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			case "reexport-dynamic-default": {
-				{
-					const from = moduleGraph.getConnection(this);
-					return {
-						exports: [
-							{
-								name: mode.name,
-								from,
-								export: ["default"]
-							}
-						],
-						priority: 1,
-						dependencies: [from.module]
-					};
-				}
-			}
-			case "reexport-undefined":
-				return {
-					exports: [mode.name],
-					dependencies: [moduleGraph.getModule(this)]
-				};
-			case "reexport-fake-namespace-object": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: [
-						{
-							name: mode.name,
-							from,
-							export: null,
-							exports: [
-								{
-									name: "default",
-									canMangle: false,
-									from,
-									export: null
-								}
-							]
-						}
-					],
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			case "reexport-namespace-object": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: [
-						{
-							name: mode.name,
-							from,
-							export: null
-						}
-					],
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			case "reexport-named-default": {
-				const from = moduleGraph.getConnection(this);
-				return {
-					exports: [
-						{
-							name: mode.name,
-							from,
-							export: ["default"]
-						}
-					],
-					priority: 1,
-					dependencies: [from.module]
-				};
-			}
-			default:
-				throw new Error(`Unknown mode ${mode.type}`);
-		}
-	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {number} effective mode
-	 */
-	_getEffectiveExportPresenceLevel(moduleGraph) {
-		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
-			return this.exportPresenceMode;
-		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-			? ExportPresenceModes.ERROR
-			: ExportPresenceModes.WARN;
-	}
 
-	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
-	 */
-	getWarnings(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.WARN) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
-	}
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
+
+class RuntimeRequirementsDependency extends NullDependency {
 	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
+	 * @param {string[]} runtimeRequirements runtime requirements
 	 */
-	getErrors(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
+	constructor(runtimeRequirements) {
+		super();
+		this.runtimeRequirements = new Set(runtimeRequirements);
+		this._hashUpdate = undefined;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[] | undefined} errors
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
 	 */
-	_getErrors(moduleGraph) {
-		const ids = this.getIds(moduleGraph);
-		let errors = this.getLinkingErrors(
-			moduleGraph,
-			ids,
-			`(reexported as '${this.name}')`
-		);
-		if (ids.length === 0 && this.name === null) {
-			const potentialConflicts =
-				this._discoverActiveExportsFromOtherStarExports(moduleGraph);
-			if (potentialConflicts && potentialConflicts.namesSlice > 0) {
-				const ownNames = new Set(
-					potentialConflicts.names.slice(
-						potentialConflicts.namesSlice,
-						potentialConflicts.dependencyIndices[
-							potentialConflicts.dependencyIndex
-						]
-					)
-				);
-				const importedModule = moduleGraph.getModule(this);
-				if (importedModule) {
-					const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-					const conflicts = new Map();
-					for (const exportInfo of exportsInfo.orderedExports) {
-						if (exportInfo.provided !== true) continue;
-						if (exportInfo.name === "default") continue;
-						if (this.activeExports.has(exportInfo.name)) continue;
-						if (ownNames.has(exportInfo.name)) continue;
-						const conflictingDependency = findDependencyForName(
-							potentialConflicts,
-							exportInfo.name,
-							this.allStarExports
-								? this.allStarExports.dependencies
-								: [...this.otherStarExports, this]
-						);
-						if (!conflictingDependency) continue;
-						const target = exportInfo.getTerminalBinding(moduleGraph);
-						if (!target) continue;
-						const conflictingModule = moduleGraph.getModule(
-							conflictingDependency
-						);
-						if (conflictingModule === importedModule) continue;
-						const conflictingExportInfo = moduleGraph.getExportInfo(
-							conflictingModule,
-							exportInfo.name
-						);
-						const conflictingTarget =
-							conflictingExportInfo.getTerminalBinding(moduleGraph);
-						if (!conflictingTarget) continue;
-						if (target === conflictingTarget) continue;
-						const list = conflicts.get(conflictingDependency.request);
-						if (list === undefined) {
-							conflicts.set(conflictingDependency.request, [exportInfo.name]);
-						} else {
-							list.push(exportInfo.name);
-						}
-					}
-					for (const [request, exports] of conflicts) {
-						if (!errors) errors = [];
-						errors.push(
-							new HarmonyLinkingError(
-								`The requested module '${
-									this.request
-								}' contains conflicting star exports for the ${
-									exports.length > 1 ? "names" : "name"
-								} ${exports
-									.map(e => `'${e}'`)
-									.join(", ")} with the previous requested module '${request}'`
-							)
-						);
-					}
-				}
-			}
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
 		}
-		return errors;
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {
-		const { write, setCircularReference } = context;
-
-		setCircularReference(this);
-		write(this.ids);
-		write(this.name);
-		write(this.activeExports);
-		write(this.otherStarExports);
-		write(this.exportPresenceMode);
-		write(this.allStarExports);
-
+		const { write } = context;
+		write(this.runtimeRequirements);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
-		const { read, setCircularReference } = context;
-
-		setCircularReference(this);
-		this.ids = read();
-		this.name = read();
-		this.activeExports = read();
-		this.otherStarExports = read();
-		this.exportPresenceMode = read();
-		this.allStarExports = read();
-
+		const { read } = context;
+		this.runtimeRequirements = read();
 		super.deserialize(context);
 	}
 }
 
 makeSerializable(
-	HarmonyExportImportedSpecifierDependency,
-	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency"
+	RuntimeRequirementsDependency,
+	"webpack/lib/dependencies/RuntimeRequirementsDependency"
 );
 
-module.exports = HarmonyExportImportedSpecifierDependency;
-
-HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedSpecifierDependencyTemplate extends (
-	HarmonyImportDependency.Template
+RuntimeRequirementsDependency.Template = class RuntimeRequirementsDependencyTemplate extends (
+	NullDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -85169,628 +83483,381 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const { moduleGraph, runtime, concatenationScope } = templateContext;
+	apply(dependency, source, { runtimeRequirements }) {
+		const dep = /** @type {RuntimeRequirementsDependency} */ (dependency);
+		for (const req of dep.runtimeRequirements) {
+			runtimeRequirements.add(req);
+		}
+	}
+};
 
-		const dep = /** @type {HarmonyExportImportedSpecifierDependency} */ (
-			dependency
-		);
+module.exports = RuntimeRequirementsDependency;
 
-		const mode = dep.getMode(moduleGraph, runtime);
 
-		if (concatenationScope) {
-			switch (mode.type) {
-				case "reexport-undefined":
-					concatenationScope.registerRawExport(
-						mode.name,
-						"/* reexport non-default export from non-harmony */ undefined"
-					);
-			}
-			return;
-		}
-
-		if (mode.type !== "unused" && mode.type !== "empty-star") {
-			super.apply(dependency, source, templateContext);
-
-			this._addExportFragments(
-				templateContext.initFragments,
-				dep,
-				mode,
-				templateContext.module,
-				moduleGraph,
-				runtime,
-				templateContext.runtimeTemplate,
-				templateContext.runtimeRequirements
-			);
-		}
-	}
-
-	/**
-	 * @param {InitFragment[]} initFragments target array for init fragments
-	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
-	 * @param {ExportMode} mode the export mode
-	 * @param {Module} module the current module
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
-	 * @param {Set<string>} runtimeRequirements runtime requirements
-	 * @returns {void}
-	 */
-	_addExportFragments(
-		initFragments,
-		dep,
-		mode,
-		module,
-		moduleGraph,
-		runtime,
-		runtimeTemplate,
-		runtimeRequirements
-	) {
-		const importedModule = moduleGraph.getModule(dep);
-		const importVar = dep.getImportVar(moduleGraph);
+/***/ }),
 
-		switch (mode.type) {
-			case "missing":
-			case "empty-star":
-				initFragments.push(
-					new InitFragment(
-						"/* empty/unused harmony star reexport */\n",
-						InitFragment.STAGE_HARMONY_EXPORTS,
-						1
-					)
-				);
-				break;
+/***/ 91418:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			case "unused":
-				initFragments.push(
-					new InitFragment(
-						`${Template.toNormalComment(
-							`unused harmony reexport ${mode.name}`
-						)}\n`,
-						InitFragment.STAGE_HARMONY_EXPORTS,
-						1
-					)
-				);
-				break;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			case "reexport-dynamic-default":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport default from dynamic",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						null,
-						runtimeRequirements
-					)
-				);
-				break;
 
-			case "reexport-fake-namespace-object":
-				initFragments.push(
-					...this.getReexportFakeNamespaceObjectFragments(
-						module,
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						mode.fakeType,
-						runtimeRequirements
-					)
-				);
-				break;
 
-			case "reexport-undefined":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport non-default export from non-harmony",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						"undefined",
-						"",
-						runtimeRequirements
-					)
-				);
-				break;
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
-			case "reexport-named-default":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport default export from named module",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						"",
-						runtimeRequirements
-					)
-				);
-				break;
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
+/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/Hash")} Hash */
 
-			case "reexport-namespace-object":
-				initFragments.push(
-					this.getReexportFragment(
-						module,
-						"reexport module object",
-						moduleGraph.getExportsInfo(module).getUsedName(mode.name, runtime),
-						importVar,
-						"",
-						runtimeRequirements
-					)
-				);
-				break;
+class StaticExportsDependency extends NullDependency {
+	/**
+	 * @param {string[] | true} exports export names
+	 * @param {boolean} canMangle true, if mangling exports names is allowed
+	 */
+	constructor(exports, canMangle) {
+		super();
+		this.exports = exports;
+		this.canMangle = canMangle;
+	}
 
-			case "normal-reexport":
-				for (const { name, ids, checked, hidden } of mode.items) {
-					if (hidden) continue;
-					if (checked) {
-						initFragments.push(
-							new InitFragment(
-								"/* harmony reexport (checked) */ " +
-									this.getConditionalReexportStatement(
-										module,
-										name,
-										importVar,
-										ids,
-										runtimeRequirements
-									),
-								moduleGraph.isAsync(importedModule)
-									? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
-									: InitFragment.STAGE_HARMONY_IMPORTS,
-								dep.sourceOrder
-							)
-						);
-					} else {
-						initFragments.push(
-							this.getReexportFragment(
-								module,
-								"reexport safe",
-								moduleGraph.getExportsInfo(module).getUsedName(name, runtime),
-								importVar,
-								moduleGraph
-									.getExportsInfo(importedModule)
-									.getUsedName(ids, runtime),
-								runtimeRequirements
-							)
-						);
-					}
-				}
-				break;
+	get type() {
+		return "static exports";
+	}
 
-			case "dynamic-reexport": {
-				const ignored = mode.hidden
-					? combine(mode.ignored, mode.hidden)
-					: mode.ignored;
-				const modern =
-					runtimeTemplate.supportsConst() &&
-					runtimeTemplate.supportsArrowFunction();
-				let content =
-					"/* harmony reexport (unknown) */ var __WEBPACK_REEXPORT_OBJECT__ = {};\n" +
-					`/* harmony reexport (unknown) */ for(${
-						modern ? "const" : "var"
-					} __WEBPACK_IMPORT_KEY__ in ${importVar}) `;
+	/**
+	 * Returns the exported names
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportsSpec | undefined} export names
+	 */
+	getExports(moduleGraph) {
+		return {
+			exports: this.exports,
+			canMangle: this.canMangle,
+			dependencies: undefined
+		};
+	}
 
-				// Filter out exports which are defined by other exports
-				// and filter out default export because it cannot be reexported with *
-				if (ignored.size > 1) {
-					content +=
-						"if(" +
-						JSON.stringify(Array.from(ignored)) +
-						".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
-				} else if (ignored.size === 1) {
-					content += `if(__WEBPACK_IMPORT_KEY__ !== ${JSON.stringify(
-						first(ignored)
-					)}) `;
-				}
+	serialize(context) {
+		const { write } = context;
+		write(this.exports);
+		write(this.canMangle);
+		super.serialize(context);
+	}
 
-				content += `__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = `;
-				if (modern) {
-					content += `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`;
-				} else {
-					content += `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
-				}
+	deserialize(context) {
+		const { read } = context;
+		this.exports = read();
+		this.canMangle = read();
+		super.deserialize(context);
+	}
+}
 
-				runtimeRequirements.add(RuntimeGlobals.exports);
-				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+makeSerializable(
+	StaticExportsDependency,
+	"webpack/lib/dependencies/StaticExportsDependency"
+);
 
-				const exportsName = module.exportsArgument;
-				initFragments.push(
-					new InitFragment(
-						`${content}\n/* harmony reexport (unknown) */ ${RuntimeGlobals.definePropertyGetters}(${exportsName}, __WEBPACK_REEXPORT_OBJECT__);\n`,
-						moduleGraph.isAsync(importedModule)
-							? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
-							: InitFragment.STAGE_HARMONY_IMPORTS,
-						dep.sourceOrder
-					)
-				);
-				break;
-			}
+module.exports = StaticExportsDependency;
 
-			default:
-				throw new Error(`Unknown mode ${mode.type}`);
-		}
-	}
 
-	getReexportFragment(
-		module,
-		comment,
-		key,
-		name,
-		valueKey,
-		runtimeRequirements
-	) {
-		const returnValue = this.getReturnValue(name, valueKey);
+/***/ }),
 
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+/***/ 97981:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const map = new Map();
-		map.set(key, `/* ${comment} */ ${returnValue}`);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		return new HarmonyExportInitFragment(module.exportsArgument, map);
-	}
 
-	getReexportFakeNamespaceObjectFragments(
-		module,
-		key,
-		name,
-		fakeType,
-		runtimeRequirements
-	) {
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-		runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 
-		const map = new Map();
-		map.set(
-			key,
-			`/* reexport fake namespace object from non-harmony */ ${name}_namespace_cache || (${name}_namespace_cache = ${
-				RuntimeGlobals.createFakeNamespaceObject
-			}(${name}${fakeType ? `, ${fakeType}` : ""}))`
-		);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const {
+	evaluateToString,
+	expressionIsUnsupported,
+	toConstantDependency
+} = __webpack_require__(93998);
+const makeSerializable = __webpack_require__(33032);
+const ConstDependency = __webpack_require__(76911);
+const SystemRuntimeModule = __webpack_require__(85439);
 
-		return [
-			new InitFragment(
-				`var ${name}_namespace_cache;\n`,
-				InitFragment.STAGE_CONSTANTS,
-				-1,
-				`${name}_namespace_cache`
-			),
-			new HarmonyExportInitFragment(module.exportsArgument, map)
-		];
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
-	getConditionalReexportStatement(
-		module,
-		key,
-		name,
-		valueKey,
-		runtimeRequirements
-	) {
-		if (valueKey === false) {
-			return "/* unused export */\n";
-		}
+class SystemPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"SystemPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.hooks.runtimeRequirementInModule
+					.for(RuntimeGlobals.system)
+					.tap("SystemPlugin", (module, set) => {
+						set.add(RuntimeGlobals.requireScope);
+					});
 
-		const exportsName = module.exportsArgument;
-		const returnValue = this.getReturnValue(name, valueKey);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.system)
+					.tap("SystemPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
+					});
 
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-		runtimeRequirements.add(RuntimeGlobals.hasOwnProperty);
+				const handler = (parser, parserOptions) => {
+					if (parserOptions.system === undefined || !parserOptions.system) {
+						return;
+					}
 
-		return `if(${RuntimeGlobals.hasOwnProperty}(${name}, ${JSON.stringify(
-			valueKey[0]
-		)})) ${
-			RuntimeGlobals.definePropertyGetters
-		}(${exportsName}, { ${JSON.stringify(
-			key
-		)}: function() { return ${returnValue}; } });\n`;
-	}
+					const setNotSupported = name => {
+						parser.hooks.evaluateTypeof
+							.for(name)
+							.tap("SystemPlugin", evaluateToString("undefined"));
+						parser.hooks.expression
+							.for(name)
+							.tap(
+								"SystemPlugin",
+								expressionIsUnsupported(
+									parser,
+									name + " is not supported by webpack."
+								)
+							);
+					};
 
-	getReturnValue(name, valueKey) {
-		if (valueKey === null) {
-			return `${name}_default.a`;
-		}
+					parser.hooks.typeof
+						.for("System.import")
+						.tap(
+							"SystemPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("System.import")
+						.tap("SystemPlugin", evaluateToString("function"));
+					parser.hooks.typeof
+						.for("System")
+						.tap(
+							"SystemPlugin",
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("System")
+						.tap("SystemPlugin", evaluateToString("object"));
 
-		if (valueKey === "") {
-			return name;
-		}
+					setNotSupported("System.set");
+					setNotSupported("System.get");
+					setNotSupported("System.register");
 
-		if (valueKey === false) {
-			return "/* unused export */ undefined";
-		}
+					parser.hooks.expression.for("System").tap("SystemPlugin", expr => {
+						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
+							RuntimeGlobals.system
+						]);
+						dep.loc = expr.loc;
+						parser.state.module.addPresentationalDependency(dep);
+						return true;
+					});
 
-		return `${name}${propertyAccess(valueKey)}`;
-	}
-};
+					parser.hooks.call.for("System.import").tap("SystemPlugin", expr => {
+						parser.state.module.addWarning(
+							new SystemImportDeprecationWarning(expr.loc)
+						);
 
-class HarmonyStarExportsList {
-	constructor() {
-		/** @type {HarmonyExportImportedSpecifierDependency[]} */
-		this.dependencies = [];
-	}
+						return parser.hooks.importCall.call({
+							type: "ImportExpression",
+							source: expr.arguments[0],
+							loc: expr.loc,
+							range: expr.range
+						});
+					});
+				};
 
-	/**
-	 * @param {HarmonyExportImportedSpecifierDependency} dep dependency
-	 * @returns {void}
-	 */
-	push(dep) {
-		this.dependencies.push(dep);
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("SystemPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("SystemPlugin", handler);
+			}
+		);
 	}
+}
 
-	slice() {
-		return this.dependencies.slice();
-	}
+class SystemImportDeprecationWarning extends WebpackError {
+	constructor(loc) {
+		super(
+			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +
+				"For more info visit https://webpack.js.org/guides/code-splitting/"
+		);
 
-	serialize({ write, setCircularReference }) {
-		setCircularReference(this);
-		write(this.dependencies);
-	}
+		this.name = "SystemImportDeprecationWarning";
 
-	deserialize({ read, setCircularReference }) {
-		setCircularReference(this);
-		this.dependencies = read();
+		this.loc = loc;
 	}
 }
 
 makeSerializable(
-	HarmonyStarExportsList,
-	"webpack/lib/dependencies/HarmonyExportImportedSpecifierDependency",
-	"HarmonyStarExportsList"
+	SystemImportDeprecationWarning,
+	"webpack/lib/dependencies/SystemPlugin",
+	"SystemImportDeprecationWarning"
 );
 
-module.exports.HarmonyStarExportsList = HarmonyStarExportsList;
+module.exports = SystemPlugin;
+module.exports.SystemImportDeprecationWarning = SystemImportDeprecationWarning;
 
 
 /***/ }),
 
-/***/ 89500:
+/***/ 85439:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const InitFragment = __webpack_require__(55870);
 const RuntimeGlobals = __webpack_require__(16475);
-const { first } = __webpack_require__(93347);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-
-const joinIterableWithComma = iterable => {
-	// This is more performant than Array.from().join(", ")
-	// as it doesn't create an array
-	let str = "";
-	let first = true;
-	for (const item of iterable) {
-		if (first) {
-			first = false;
-		} else {
-			str += ", ";
-		}
-		str += item;
-	}
-	return str;
-};
-
-const EMPTY_MAP = new Map();
-const EMPTY_SET = new Set();
-
-/**
- * @typedef {GenerateContext} Context
- */
-class HarmonyExportInitFragment extends InitFragment {
-	/**
-	 * @param {string} exportsArgument the exports identifier
-	 * @param {Map<string, string>} exportMap mapping from used name to exposed variable name
-	 * @param {Set<string>} unusedExports list of unused export names
-	 */
-	constructor(
-		exportsArgument,
-		exportMap = EMPTY_MAP,
-		unusedExports = EMPTY_SET
-	) {
-		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
-		this.exportsArgument = exportsArgument;
-		this.exportMap = exportMap;
-		this.unusedExports = unusedExports;
-	}
-
-	/**
-	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
-	 * @returns {HarmonyExportInitFragment} merged fragment
-	 */
-	mergeAll(fragments) {
-		let exportMap;
-		let exportMapOwned = false;
-		let unusedExports;
-		let unusedExportsOwned = false;
-
-		for (const fragment of fragments) {
-			if (fragment.exportMap.size !== 0) {
-				if (exportMap === undefined) {
-					exportMap = fragment.exportMap;
-					exportMapOwned = false;
-				} else {
-					if (!exportMapOwned) {
-						exportMap = new Map(exportMap);
-						exportMapOwned = true;
-					}
-					for (const [key, value] of fragment.exportMap) {
-						if (!exportMap.has(key)) exportMap.set(key, value);
-					}
-				}
-			}
-			if (fragment.unusedExports.size !== 0) {
-				if (unusedExports === undefined) {
-					unusedExports = fragment.unusedExports;
-					unusedExportsOwned = false;
-				} else {
-					if (!unusedExportsOwned) {
-						unusedExports = new Set(unusedExports);
-						unusedExportsOwned = true;
-					}
-					for (const value of fragment.unusedExports) {
-						unusedExports.add(value);
-					}
-				}
-			}
-		}
-		return new HarmonyExportInitFragment(
-			this.exportsArgument,
-			exportMap,
-			unusedExports
-		);
-	}
-
-	merge(other) {
-		let exportMap;
-		if (this.exportMap.size === 0) {
-			exportMap = other.exportMap;
-		} else if (other.exportMap.size === 0) {
-			exportMap = this.exportMap;
-		} else {
-			exportMap = new Map(other.exportMap);
-			for (const [key, value] of this.exportMap) {
-				if (!exportMap.has(key)) exportMap.set(key, value);
-			}
-		}
-		let unusedExports;
-		if (this.unusedExports.size === 0) {
-			unusedExports = other.unusedExports;
-		} else if (other.unusedExports.size === 0) {
-			unusedExports = this.unusedExports;
-		} else {
-			unusedExports = new Set(other.unusedExports);
-			for (const value of this.unusedExports) {
-				unusedExports.add(value);
-			}
-		}
-		return new HarmonyExportInitFragment(
-			this.exportsArgument,
-			exportMap,
-			unusedExports
-		);
-	}
+class SystemRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("system");
+	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @returns {string} runtime code
 	 */
-	getContent({ runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-
-		const unusedPart =
-			this.unusedExports.size > 1
-				? `/* unused harmony exports ${joinIterableWithComma(
-						this.unusedExports
-				  )} */\n`
-				: this.unusedExports.size > 0
-				? `/* unused harmony export ${first(this.unusedExports)} */\n`
-				: "";
-		const definitions = [];
-		for (const [key, value] of this.exportMap) {
-			definitions.push(
-				`\n/* harmony export */   ${JSON.stringify(
-					key
-				)}: ${runtimeTemplate.returningFunction(value)}`
-			);
-		}
-		const definePart =
-			this.exportMap.size > 0
-				? `/* harmony export */ ${RuntimeGlobals.definePropertyGetters}(${
-						this.exportsArgument
-				  }, {${definitions.join(",")}\n/* harmony export */ });\n`
-				: "";
-		return `${definePart}${unusedPart}`;
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.system} = {`,
+			Template.indent([
+				"import: function () {",
+				Template.indent(
+					"throw new Error('System.import cannot be used indirectly');"
+				),
+				"}"
+			]),
+			"};"
+		]);
 	}
 }
 
-module.exports = HarmonyExportInitFragment;
+module.exports = SystemRuntimeModule;
 
 
 /***/ }),
 
-/***/ 48567:
+/***/ 58612:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
+const RuntimeGlobals = __webpack_require__(16475);
+const {
+	getDependencyUsedByExportsCondition
+} = __webpack_require__(38988);
 const makeSerializable = __webpack_require__(33032);
-const HarmonyExportInitFragment = __webpack_require__(89500);
-const NullDependency = __webpack_require__(31830);
+const memoize = __webpack_require__(78676);
+const ModuleDependency = __webpack_require__(80321);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class HarmonyExportSpecifierDependency extends NullDependency {
-	constructor(id, name) {
-		super();
-		this.id = id;
-		this.name = name;
+const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
+
+class URLDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
+	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
+	 * @param {boolean=} relative use relative urls instead of absolute with base uri
+	 */
+	constructor(request, range, outerRange, relative) {
+		super(request);
+		this.range = range;
+		this.outerRange = outerRange;
+		this.relative = relative || false;
+		/** @type {Set<string> | boolean} */
+		this.usedByExports = undefined;
 	}
 
 	get type() {
-		return "harmony export specifier";
+		return "new URL()";
+	}
+
+	get category() {
+		return "url";
 	}
 
 	/**
-	 * Returns the exported names
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
 	 */
-	getExports(moduleGraph) {
-		return {
-			exports: [this.name],
-			priority: 1,
-			terminalBinding: true,
-			dependencies: undefined
-		};
+	getCondition(moduleGraph) {
+		return getDependencyUsedByExportsCondition(
+			this,
+			this.usedByExports,
+			moduleGraph
+		);
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * @param {string} context context directory
+	 * @returns {Module} a module
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
+	createIgnoredModule(context) {
+		const RawDataUrlModule = getRawDataUrlModule();
+		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.id);
-		write(this.name);
+		write(this.outerRange);
+		write(this.relative);
+		write(this.usedByExports);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.id = read();
-		this.name = read();
+		this.outerRange = read();
+		this.relative = read();
+		this.usedByExports = read();
 		super.deserialize(context);
 	}
 }
 
-makeSerializable(
-	HarmonyExportSpecifierDependency,
-	"webpack/lib/dependencies/HarmonyExportSpecifierDependency"
-);
-
-HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependencyTemplate extends (
-	NullDependency.Template
+URLDependency.Template = class URLDependencyTemplate extends (
+	ModuleDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -85798,90 +83865,191 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ module, moduleGraph, initFragments, runtime, concatenationScope }
-	) {
-		const dep = /** @type {HarmonyExportSpecifierDependency} */ (dependency);
-		if (concatenationScope) {
-			concatenationScope.registerExport(dep.name, dep.id);
-			return;
-		}
-		const used = moduleGraph
-			.getExportsInfo(module)
-			.getUsedName(dep.name, runtime);
-		if (!used) {
-			const set = new Set();
-			set.add(dep.name || "namespace");
-			initFragments.push(
-				new HarmonyExportInitFragment(module.exportsArgument, undefined, set)
+	apply(dependency, source, templateContext) {
+		const {
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtimeTemplate,
+			runtime
+		} = templateContext;
+		const dep = /** @type {URLDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				"/* unused asset import */ undefined"
 			);
 			return;
 		}
 
-		const map = new Map();
-		map.set(used, `/* binding */ ${dep.id}`);
-		initFragments.push(
-			new HarmonyExportInitFragment(module.exportsArgument, map, undefined)
-		);
+		runtimeRequirements.add(RuntimeGlobals.require);
+
+		if (dep.relative) {
+			runtimeRequirements.add(RuntimeGlobals.relativeUrl);
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				`/* asset import */ new ${
+					RuntimeGlobals.relativeUrl
+				}(${runtimeTemplate.moduleRaw({
+					chunkGraph,
+					module: moduleGraph.getModule(dep),
+					request: dep.request,
+					runtimeRequirements,
+					weak: false
+				})})`
+			);
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.baseURI);
+
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				`/* asset import */ ${runtimeTemplate.moduleRaw({
+					chunkGraph,
+					module: moduleGraph.getModule(dep),
+					request: dep.request,
+					runtimeRequirements,
+					weak: false
+				})}, ${RuntimeGlobals.baseURI}`
+			);
+		}
 	}
 };
 
-module.exports = HarmonyExportSpecifierDependency;
+makeSerializable(URLDependency, "webpack/lib/dependencies/URLDependency");
+
+module.exports = URLDependency;
 
 
 /***/ }),
 
-/***/ 39211:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 14412:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-/** @typedef {import("../Parser").ParserState} ParserState */
+const { approve } = __webpack_require__(93998);
+const InnerGraph = __webpack_require__(38988);
+const URLDependency = __webpack_require__(58612);
 
-/** @type {WeakMap<ParserState, boolean>} */
-const parserStateExportsState = new WeakMap();
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
-/**
- * @param {ParserState} parserState parser state
- * @param {boolean} isStrictHarmony strict harmony mode should be enabled
- * @returns {void}
- */
-exports.enable = (parserState, isStrictHarmony) => {
-	const value = parserStateExportsState.get(parserState);
-	if (value === false) return;
-	parserStateExportsState.set(parserState, true);
-	if (value !== true) {
-		parserState.module.buildMeta.exportsType = "namespace";
-		parserState.module.buildInfo.strict = true;
-		parserState.module.buildInfo.exportsArgument = "__webpack_exports__";
-		if (isStrictHarmony) {
-			parserState.module.buildMeta.strictHarmonyModule = true;
-			parserState.module.buildInfo.moduleArgument = "__webpack_module__";
-		}
+class URLPlugin {
+	/**
+	 * @param {Compiler} compiler compiler
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"URLPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
+				compilation.dependencyTemplates.set(
+					URLDependency,
+					new URLDependency.Template()
+				);
+
+				/**
+				 * @param {JavascriptParser} parser parser
+				 * @param {object} parserOptions options
+				 */
+				const parserCallback = (parser, parserOptions) => {
+					if (parserOptions.url === false) return;
+					const relative = parserOptions.url === "relative";
+
+					/**
+					 * @param {NewExpressionNode} expr expression
+					 * @returns {undefined | string} request
+					 */
+					const getUrlRequest = expr => {
+						if (expr.arguments.length !== 2) return;
+
+						const [arg1, arg2] = expr.arguments;
+
+						if (
+							arg2.type !== "MemberExpression" ||
+							arg1.type === "SpreadElement"
+						)
+							return;
+
+						const chain = parser.extractMemberExpressionChain(arg2);
+
+						if (
+							chain.members.length !== 1 ||
+							chain.object.type !== "MetaProperty" ||
+							chain.object.meta.name !== "import" ||
+							chain.object.property.name !== "meta" ||
+							chain.members[0] !== "url"
+						)
+							return;
+
+						const request = parser.evaluateExpression(arg1).asString();
+
+						return request;
+					};
+
+					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+
+						const request = getUrlRequest(expr);
+
+						if (!request) return;
+
+						const [arg1, arg2] = expr.arguments;
+						const dep = new URLDependency(
+							request,
+							[arg1.range[0], arg2.range[1]],
+							expr.range,
+							relative
+						);
+						dep.loc = expr.loc;
+						parser.state.current.addDependency(dep);
+						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+						return true;
+					});
+					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+						const { callee } = expr;
+						if (callee.type !== "Identifier") return;
+						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+						if (!calleeInfo || calleeInfo.name !== "URL") return;
+
+						const request = getUrlRequest(expr);
+
+						if (request) return true;
+					});
+				};
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("URLPlugin", parserCallback);
+
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("URLPlugin", parserCallback);
+			}
+		);
 	}
-};
+}
 
-/**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
- */
-exports.isEnabled = parserState => {
-	const value = parserStateExportsState.get(parserState);
-	return value === true;
-};
+module.exports = URLPlugin;
 
 
 /***/ }),
 
-/***/ 57154:
+/***/ 51669:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -85892,690 +84060,413 @@ exports.isEnabled = parserState => {
 
 
 
-const ConditionalInitFragment = __webpack_require__(61333);
-const Dependency = __webpack_require__(54912);
-const HarmonyLinkingError = __webpack_require__(97511);
-const InitFragment = __webpack_require__(55870);
-const Template = __webpack_require__(39722);
-const AwaitDependenciesInitFragment = __webpack_require__(41153);
-const { filterRuntime, mergeRuntime } = __webpack_require__(17156);
-const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
+const NullDependency = __webpack_require__(31830);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const ExportPresenceModes = {
-	NONE: /** @type {0} */ (0),
-	WARN: /** @type {1} */ (1),
-	AUTO: /** @type {2} */ (2),
-	ERROR: /** @type {3} */ (3),
-	fromUserOption(str) {
-		switch (str) {
-			case "error":
-				return ExportPresenceModes.ERROR;
-			case "warn":
-				return ExportPresenceModes.WARN;
-			case "auto":
-				return ExportPresenceModes.AUTO;
-			case false:
-				return ExportPresenceModes.NONE;
-			default:
-				throw new Error(`Invalid export presence value ${str}`);
-		}
+class UnsupportedDependency extends NullDependency {
+	constructor(request, range) {
+		super();
+
+		this.request = request;
+		this.range = range;
 	}
-};
 
-class HarmonyImportDependency extends ModuleDependency {
-	/**
-	 *
-	 * @param {string} request request string
-	 * @param {number} sourceOrder source order
-	 * @param {Record<string, any>=} assertions import assertions
-	 */
-	constructor(request, sourceOrder, assertions) {
-		super(request);
-		this.sourceOrder = sourceOrder;
-		this.assertions = assertions;
+	serialize(context) {
+		const { write } = context;
+
+		write(this.request);
+		write(this.range);
+
+		super.serialize(context);
 	}
 
-	get category() {
-		return "esm";
+	deserialize(context) {
+		const { read } = context;
+
+		this.request = read();
+		this.range = read();
+
+		super.deserialize(context);
 	}
+}
+
+makeSerializable(
+	UnsupportedDependency,
+	"webpack/lib/dependencies/UnsupportedDependency"
+);
 
+UnsupportedDependency.Template = class UnsupportedDependencyTemplate extends (
+	NullDependency.Template
+) {
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return Dependency.NO_EXPORTS_REFERENCED;
+	apply(dependency, source, { runtimeTemplate }) {
+		const dep = /** @type {UnsupportedDependency} */ (dependency);
+
+		source.replace(
+			dep.range[0],
+			dep.range[1],
+			runtimeTemplate.missingModule({
+				request: dep.request
+			})
+		);
 	}
+};
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string} name of the variable for the import
-	 */
-	getImportVar(moduleGraph) {
-		const module = moduleGraph.getParentModule(this);
-		const meta = moduleGraph.getMeta(module);
-		let importVarMap = meta.importVarMap;
-		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
-		let importVar = importVarMap.get(moduleGraph.getModule(this));
-		if (importVar) return importVar;
-		importVar = `${Template.toIdentifier(
-			`${this.userRequest}`
-		)}__WEBPACK_IMPORTED_MODULE_${importVarMap.size}__`;
-		importVarMap.set(moduleGraph.getModule(this), importVar);
-		return importVar;
+module.exports = UnsupportedDependency;
+
+
+/***/ }),
+
+/***/ 52204:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebAssemblyExportImportedDependency extends ModuleDependency {
+	constructor(exportName, request, name, valueType) {
+		super(request);
+		/** @type {string} */
+		this.exportName = exportName;
+		/** @type {string} */
+		this.name = name;
+		/** @type {string} */
+		this.valueType = valueType;
 	}
 
 	/**
-	 * @param {boolean} update create new variables or update existing one
-	 * @param {DependencyTemplateContext} templateContext the template context
-	 * @returns {[string, string]} the import statement and the compat statement
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
 	 */
-	getImportStatement(
-		update,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		return runtimeTemplate.importStatement({
-			update,
-			module: moduleGraph.getModule(this),
-			chunkGraph,
-			importVar: this.getImportVar(moduleGraph),
-			request: this.request,
-			originModule: module,
-			runtimeRequirements
-		});
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
 	}
 
 	/**
+	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {string[]} ids imported ids
-	 * @param {string} additionalMessage extra info included in the error message
-	 * @returns {WebpackError[] | undefined} errors
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	getLinkingErrors(moduleGraph, ids, additionalMessage) {
-		const importedModule = moduleGraph.getModule(this);
-		// ignore errors for missing or failed modules
-		if (!importedModule || importedModule.getNumberOfErrors() > 0) {
-			return;
-		}
-
-		const parentModule = moduleGraph.getParentModule(this);
-		const exportsType = importedModule.getExportsType(
-			moduleGraph,
-			parentModule.buildMeta.strictHarmonyModule
-		);
-		if (exportsType === "namespace" || exportsType === "default-with-named") {
-			if (ids.length === 0) {
-				return;
-			}
-
-			if (
-				(exportsType !== "default-with-named" || ids[0] !== "default") &&
-				moduleGraph.isExportProvided(importedModule, ids) === false
-			) {
-				// We are sure that it's not provided
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
 
-				// Try to provide detailed info in the error message
-				let pos = 0;
-				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
-				while (pos < ids.length && exportsInfo) {
-					const id = ids[pos++];
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
-					if (exportInfo.provided === false) {
-						// We are sure that it's not provided
-						const providedExports = exportsInfo.getProvidedExports();
-						const moreInfo = !Array.isArray(providedExports)
-							? " (possible exports unknown)"
-							: providedExports.length === 0
-							? " (module has no exports)"
-							: ` (possible exports: ${providedExports.join(", ")})`;
-						return [
-							new HarmonyLinkingError(
-								`export ${ids
-									.slice(0, pos)
-									.map(id => `'${id}'`)
-									.join(".")} ${additionalMessage} was not found in '${
-									this.userRequest
-								}'${moreInfo}`
-							)
-						];
-					}
-					exportsInfo = exportInfo.getNestedExportsInfo();
-				}
+	get type() {
+		return "wasm export import";
+	}
 
-				// General error message
-				return [
-					new HarmonyLinkingError(
-						`export ${ids
-							.map(id => `'${id}'`)
-							.join(".")} ${additionalMessage} was not found in '${
-							this.userRequest
-						}'`
-					)
-				];
-			}
-		}
-		switch (exportsType) {
-			case "default-only":
-				// It's has only a default export
-				if (ids.length > 0 && ids[0] !== "default") {
-					// In strict harmony modules we only support the default export
-					return [
-						new HarmonyLinkingError(
-							`Can't import the named export ${ids
-								.map(id => `'${id}'`)
-								.join(
-									"."
-								)} ${additionalMessage} from default-exporting module (only default export is available)`
-						)
-					];
-				}
-				break;
-			case "default-with-named":
-				// It has a default export and named properties redirect
-				// In some cases we still want to warn here
-				if (
-					ids.length > 0 &&
-					ids[0] !== "default" &&
-					importedModule.buildMeta.defaultObject === "redirect-warn"
-				) {
-					// For these modules only the default export is supported
-					return [
-						new HarmonyLinkingError(
-							`Should not import the named export ${ids
-								.map(id => `'${id}'`)
-								.join(
-									"."
-								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
-						)
-					];
-				}
-				break;
-		}
+	get category() {
+		return "wasm";
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.sourceOrder);
-		write(this.assertions);
+
+		write(this.exportName);
+		write(this.name);
+		write(this.valueType);
+
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.sourceOrder = read();
-		this.assertions = read();
+
+		this.exportName = read();
+		this.name = read();
+		this.valueType = read();
+
 		super.deserialize(context);
 	}
 }
 
-module.exports = HarmonyImportDependency;
+makeSerializable(
+	WebAssemblyExportImportedDependency,
+	"webpack/lib/dependencies/WebAssemblyExportImportedDependency"
+);
 
-/** @type {WeakMap<Module, WeakMap<Module, RuntimeSpec | boolean>>} */
-const importEmittedMap = new WeakMap();
+module.exports = WebAssemblyExportImportedDependency;
 
-HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyImportDependency} */ (dependency);
-		const { module, chunkGraph, moduleGraph, runtime } = templateContext;
 
-		const connection = moduleGraph.getConnection(dep);
-		if (connection && !connection.isTargetActive(runtime)) return;
+/***/ }),
 
-		const referencedModule = connection && connection.module;
+/***/ 5239:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		if (
-			connection &&
-			connection.weak &&
-			referencedModule &&
-			chunkGraph.getModuleId(referencedModule) === null
-		) {
-			// in weak references, module might not be in any chunk
-			// but that's ok, we don't need that logic in this case
-			return;
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		const moduleKey = referencedModule
-			? referencedModule.identifier()
-			: dep.request;
-		const key = `harmony import ${moduleKey}`;
 
-		const runtimeCondition = dep.weak
-			? false
-			: connection
-			? filterRuntime(runtime, r => connection.isTargetActive(r))
-			: true;
 
-		if (module && referencedModule) {
-			let emittedModules = importEmittedMap.get(module);
-			if (emittedModules === undefined) {
-				emittedModules = new WeakMap();
-				importEmittedMap.set(module, emittedModules);
-			}
-			let mergedRuntimeCondition = runtimeCondition;
-			const oldRuntimeCondition = emittedModules.get(referencedModule) || false;
-			if (oldRuntimeCondition !== false && mergedRuntimeCondition !== true) {
-				if (mergedRuntimeCondition === false || oldRuntimeCondition === true) {
-					mergedRuntimeCondition = oldRuntimeCondition;
-				} else {
-					mergedRuntimeCondition = mergeRuntime(
-						oldRuntimeCondition,
-						mergedRuntimeCondition
-					);
-				}
-			}
-			emittedModules.set(referencedModule, mergedRuntimeCondition);
-		}
+const makeSerializable = __webpack_require__(33032);
+const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
+const ModuleDependency = __webpack_require__(80321);
+
+/** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebAssemblyImportDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request
+	 * @param {string} name the imported name
+	 * @param {ModuleImportDescription} description the WASM ast node
+	 * @param {false | string} onlyDirectImport if only direct imports are allowed
+	 */
+	constructor(request, name, description, onlyDirectImport) {
+		super(request);
+		/** @type {string} */
+		this.name = name;
+		/** @type {ModuleImportDescription} */
+		this.description = description;
+		/** @type {false | string} */
+		this.onlyDirectImport = onlyDirectImport;
+	}
+
+	get type() {
+		return "wasm import";
+	}
+
+	get category() {
+		return "wasm";
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [[this.name]];
+	}
+
+	/**
+	 * Returns errors
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[]} errors
+	 */
+	getErrors(moduleGraph) {
+		const module = moduleGraph.getModule(this);
 
-		const importStatement = dep.getImportStatement(false, templateContext);
 		if (
-			referencedModule &&
-			templateContext.moduleGraph.isAsync(referencedModule)
+			this.onlyDirectImport &&
+			module &&
+			!module.type.startsWith("webassembly")
 		) {
-			templateContext.initFragments.push(
-				new ConditionalInitFragment(
-					importStatement[0],
-					InitFragment.STAGE_HARMONY_IMPORTS,
-					dep.sourceOrder,
-					key,
-					runtimeCondition
-				)
-			);
-			templateContext.initFragments.push(
-				new AwaitDependenciesInitFragment(
-					new Set([dep.getImportVar(templateContext.moduleGraph)])
-				)
-			);
-			templateContext.initFragments.push(
-				new ConditionalInitFragment(
-					importStatement[1],
-					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
-					dep.sourceOrder,
-					key + " compat",
-					runtimeCondition
-				)
-			);
-		} else {
-			templateContext.initFragments.push(
-				new ConditionalInitFragment(
-					importStatement[0] + importStatement[1],
-					InitFragment.STAGE_HARMONY_IMPORTS,
-					dep.sourceOrder,
-					key,
-					runtimeCondition
+			return [
+				new UnsupportedWebAssemblyFeatureError(
+					`Import "${this.name}" from "${this.request}" with ${this.onlyDirectImport} can only be used for direct wasm to wasm dependencies`
 				)
-			);
+			];
 		}
 	}
 
-	/**
-	 *
-	 * @param {Module} module the module
-	 * @param {Module} referencedModule the referenced module
-	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted
-	 */
-	static getImportEmittedRuntime(module, referencedModule) {
-		const emittedModules = importEmittedMap.get(module);
-		if (emittedModules === undefined) return false;
-		return emittedModules.get(referencedModule) || false;
+	serialize(context) {
+		const { write } = context;
+
+		write(this.name);
+		write(this.description);
+		write(this.onlyDirectImport);
+
+		super.serialize(context);
 	}
-};
 
-module.exports.ExportPresenceModes = ExportPresenceModes;
+	deserialize(context) {
+		const { read } = context;
+
+		this.name = read();
+		this.description = read();
+		this.onlyDirectImport = read();
+
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	WebAssemblyImportDependency,
+	"webpack/lib/dependencies/WebAssemblyImportDependency"
+);
+
+module.exports = WebAssemblyImportDependency;
 
 
 /***/ }),
 
-/***/ 20862:
+/***/ 26505:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const HotModuleReplacementPlugin = __webpack_require__(6404);
-const InnerGraph = __webpack_require__(38988);
-const ConstDependency = __webpack_require__(76911);
-const HarmonyAcceptDependency = __webpack_require__(23624);
-const HarmonyAcceptImportDependency = __webpack_require__(99843);
-const HarmonyExports = __webpack_require__(39211);
-const { ExportPresenceModes } = __webpack_require__(57154);
-const HarmonyImportSideEffectDependency = __webpack_require__(73132);
-const HarmonyImportSpecifierDependency = __webpack_require__(14077);
+const Dependency = __webpack_require__(54912);
+const Template = __webpack_require__(1626);
+const makeSerializable = __webpack_require__(33032);
+const ModuleDependency = __webpack_require__(80321);
 
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("estree").ImportExpression} ImportExpression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../optimize/InnerGraph").InnerGraph} InnerGraph */
-/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
-/** @typedef {import("./HarmonyImportDependency")} HarmonyImportDependency */
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const harmonySpecifierTag = Symbol("harmony import");
+class WebpackIsIncludedDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
 
-/**
- * @typedef {Object} HarmonySettings
- * @property {string[]} ids
- * @property {string} source
- * @property {number} sourceOrder
- * @property {string} name
- * @property {boolean} await
- * @property {Record<string, any> | undefined} assertions
- */
+		this.weak = true;
+		this.range = range;
+	}
 
-/**
- * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
- * @returns {Record<string, any> | undefined} assertions
- */
-function getAssertions(node) {
-	// TODO remove cast when @types/estree has been updated to import assertions
-	const assertions = /** @type {{ assertions?: ImportAttributeNode[] }} */ (
-		node
-	).assertions;
-	if (assertions === undefined) {
-		return undefined;
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
-	const result = {};
-	for (const assertion of assertions) {
-		const key =
-			assertion.key.type === "Identifier"
-				? assertion.key.name
-				: assertion.key.value;
-		result[key] = assertion.value.value;
+
+	get type() {
+		return "__webpack_is_included__";
 	}
-	return result;
 }
 
-module.exports = class HarmonyImportDependencyParserPlugin {
-	/**
-	 * @param {JavascriptParserOptions} options options
-	 */
-	constructor(options) {
-		this.exportPresenceMode =
-			options.importExportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
-				: options.exportsPresence !== undefined
-				? ExportPresenceModes.fromUserOption(options.exportsPresence)
-				: options.strictExportPresence
-				? ExportPresenceModes.ERROR
-				: ExportPresenceModes.AUTO;
-		this.strictThisContextOnImports = options.strictThisContextOnImports;
-	}
+makeSerializable(
+	WebpackIsIncludedDependency,
+	"webpack/lib/dependencies/WebpackIsIncludedDependency"
+);
 
+WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate extends (
+	ModuleDependency.Template
+) {
 	/**
-	 * @param {JavascriptParser} parser the parser
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(parser) {
-		const { exportPresenceMode } = this;
-		parser.hooks.isPure
-			.for("Identifier")
-			.tap("HarmonyImportDependencyParserPlugin", expression => {
-				const expr = /** @type {Identifier} */ (expression);
-				if (
-					parser.isVariableDefined(expr.name) ||
-					parser.getTagData(expr.name, harmonySpecifierTag)
-				) {
-					return true;
-				}
-			});
-		parser.hooks.import.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(statement, source) => {
-				parser.state.lastHarmonyImportOrder =
-					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency(
-					parser.isAsiPosition(statement.range[0]) ? ";" : "",
-					statement.range
-				);
-				clearDep.loc = statement.loc;
-				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(statement.range[1]);
-				const assertions = getAssertions(statement);
-				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					source,
-					parser.state.lastHarmonyImportOrder,
-					assertions
-				);
-				sideEffectDep.loc = statement.loc;
-				parser.state.module.addDependency(sideEffectDep);
-				return true;
-			}
-		);
-		parser.hooks.importSpecifier.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(statement, source, id, name) => {
-				const ids = id === null ? [] : [id];
-				parser.tagVariable(name, harmonySpecifierTag, {
-					name,
-					source,
-					ids,
-					sourceOrder: parser.state.lastHarmonyImportOrder,
-					assertions: getAssertions(statement)
-				});
-				return true;
-			}
-		);
-		parser.hooks.expression
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					settings.ids,
-					settings.name,
-					expr.range,
-					exportPresenceMode,
-					settings.assertions
-				);
-				dep.shorthand = parser.scope.inShorthand;
-				dep.directImport = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
-		parser.hooks.expressionMemberChain
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					expr.range,
-					exportPresenceMode,
-					settings.assertions
-				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
-				dep.loc = expr.loc;
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
-		parser.hooks.callMemberChain
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", (expr, members) => {
-				const { arguments: args, callee } = expr;
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const ids = settings.ids.concat(members);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					ids,
-					settings.name,
-					callee.range,
-					exportPresenceMode,
-					settings.assertions
-				);
-				dep.directImport = members.length === 0;
-				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(callee.range[0]);
-				// only in case when we strictly follow the spec we need a special case here
-				dep.namespaceObjectAsContext =
-					members.length > 0 && this.strictThisContextOnImports;
-				dep.loc = callee.loc;
-				parser.state.module.addDependency(dep);
-				if (args) parser.walkExpressions(args);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
-		const { hotAcceptCallback, hotAcceptWithoutCallback } =
-			HotModuleReplacementPlugin.getParserHooks(parser);
-		hotAcceptCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						expr.range,
-						dependencies,
-						true
-					);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-				}
-			}
-		);
-		hotAcceptWithoutCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						expr.range,
-						dependencies,
-						false
-					);
-					dep.loc = expr.loc;
-					parser.state.module.addDependency(dep);
-				}
-			}
+	apply(dependency, source, { runtimeTemplate, chunkGraph, moduleGraph }) {
+		const dep = /** @type {WebpackIsIncludedDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		const included = connection
+			? chunkGraph.getNumberOfModuleChunks(connection.module) > 0
+			: false;
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
+			  )
+			: "";
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${comment}${JSON.stringify(included)}`
 		);
 	}
 };
 
-module.exports.harmonySpecifierTag = harmonySpecifierTag;
-module.exports.getAssertions = getAssertions;
+module.exports = WebpackIsIncludedDependency;
 
 
 /***/ }),
 
-/***/ 73132:
+/***/ 1466:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
+const Dependency = __webpack_require__(54912);
+const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
-const HarmonyImportDependency = __webpack_require__(57154);
+const ModuleDependency = __webpack_require__(80321);
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../InitFragment")} InitFragment */
-/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
-	constructor(request, sourceOrder, assertions) {
-		super(request, sourceOrder, assertions);
-	}
-
-	get type() {
-		return "harmony side effect evaluation";
+class WorkerDependency extends ModuleDependency {
+	/**
+	 * @param {string} request request
+	 * @param {[number, number]} range range
+	 */
+	constructor(request, range) {
+		super(request);
+		this.range = range;
 	}
 
 	/**
+	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
-	getCondition(moduleGraph) {
-		return connection => {
-			const refModule = connection.resolvedModule;
-			if (!refModule) return true;
-			return refModule.getSideEffectsConnectionState(moduleGraph);
-		};
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
 	}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		const refModule = moduleGraph.getModule(this);
-		if (!refModule) return true;
-		return refModule.getSideEffectsConnectionState(moduleGraph);
+	get type() {
+		return "new Worker()";
 	}
-}
 
-makeSerializable(
-	HarmonyImportSideEffectDependency,
-	"webpack/lib/dependencies/HarmonyImportSideEffectDependency"
-);
+	get category() {
+		return "worker";
+	}
+}
 
-HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDependencyTemplate extends (
-	HarmonyImportDependency.Template
+WorkerDependency.Template = class WorkerDependencyTemplate extends (
+	ModuleDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -86584,23 +84475,38 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
-		const { moduleGraph, concatenationScope } = templateContext;
-		if (concatenationScope) {
-			const module = moduleGraph.getModule(dependency);
-			if (concatenationScope.isModuleInScope(module)) {
-				return;
-			}
-		}
-		super.apply(dependency, source, templateContext);
+		const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
+		const dep = /** @type {WorkerDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dependency)
+		);
+		const entrypoint = /** @type {Entrypoint} */ (
+			chunkGraph.getBlockChunkGroup(block)
+		);
+		const chunk = entrypoint.getEntrypointChunk();
+
+		runtimeRequirements.add(RuntimeGlobals.publicPath);
+		runtimeRequirements.add(RuntimeGlobals.baseURI);
+		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`/* worker import */ ${RuntimeGlobals.publicPath} + ${
+				RuntimeGlobals.getChunkScriptFilename
+			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
+		);
 	}
 };
 
-module.exports = HarmonyImportSideEffectDependency;
+makeSerializable(WorkerDependency, "webpack/lib/dependencies/WorkerDependency");
+
+module.exports = WorkerDependency;
 
 
 /***/ }),
 
-/***/ 14077:
+/***/ 82509:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -86611,336 +84517,421 @@ module.exports = HarmonyImportSideEffectDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
+const { pathToFileURL } = __webpack_require__(57310);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const CommentCompilationWarning = __webpack_require__(98427);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const { equals } = __webpack_require__(84953);
+const createHash = __webpack_require__(49835);
+const { contextify } = __webpack_require__(82186);
+const EnableWasmLoadingPlugin = __webpack_require__(78613);
+const ConstDependency = __webpack_require__(76911);
+const CreateScriptUrlDependency = __webpack_require__(79062);
 const {
-	getDependencyUsedByExportsCondition
-} = __webpack_require__(38988);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const HarmonyImportDependency = __webpack_require__(57154);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
-
-const { ExportPresenceModes } = HarmonyImportDependency;
-
-class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
-	constructor(
-		request,
-		sourceOrder,
-		ids,
-		name,
-		range,
-		exportPresenceMode,
-		assertions
-	) {
-		super(request, sourceOrder, assertions);
-		this.ids = ids;
-		this.name = name;
-		this.range = range;
-		this.exportPresenceMode = exportPresenceMode;
-		this.namespaceObjectAsContext = false;
-		this.call = undefined;
-		this.directImport = undefined;
-		this.shorthand = undefined;
-		this.asiSafe = undefined;
-		/** @type {Set<string> | boolean} */
-		this.usedByExports = undefined;
-	}
+	harmonySpecifierTag
+} = __webpack_require__(20862);
+const WorkerDependency = __webpack_require__(1466);
 
-	// TODO webpack 6 remove
-	get id() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").ObjectExpression} ObjectExpression */
+/** @typedef {import("estree").Pattern} Pattern */
+/** @typedef {import("estree").Property} Property */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
-	// TODO webpack 6 remove
-	getId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
+const getUrl = module => {
+	return pathToFileURL(module.resource).toString();
+};
 
-	// TODO webpack 6 remove
-	setId() {
-		throw new Error("id was renamed to ids and type changed to string[]");
-	}
+const DEFAULT_SYNTAX = [
+	"Worker",
+	"SharedWorker",
+	"navigator.serviceWorker.register()",
+	"Worker from worker_threads"
+];
 
-	get type() {
-		return "harmony import specifier";
-	}
+/** @type {WeakMap<ParserState, number>} */
+const workerIndexMap = new WeakMap();
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported ids
-	 */
-	getIds(moduleGraph) {
-		const meta = moduleGraph.getMetaIfExisting(this);
-		if (meta === undefined) return this.ids;
-		const ids = meta[idsSymbol];
-		return ids !== undefined ? ids : this.ids;
+class WorkerPlugin {
+	constructor(chunkLoading, wasmLoading, module) {
+		this._chunkLoading = chunkLoading;
+		this._wasmLoading = wasmLoading;
+		this._module = module;
 	}
-
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	setIds(moduleGraph, ids) {
-		moduleGraph.getMeta(this)[idsSymbol] = ids;
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
-	 */
-	getCondition(moduleGraph) {
-		return getDependencyUsedByExportsCondition(
-			this,
-			this.usedByExports,
-			moduleGraph
-		);
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
-	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		let ids = this.getIds(moduleGraph);
-		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
-		let namespaceObjectAsContext = this.namespaceObjectAsContext;
-		if (ids[0] === "default") {
-			const selfModule = moduleGraph.getParentModule(this);
-			const importedModule = moduleGraph.getModule(this);
-			switch (
-				importedModule.getExportsType(
-					moduleGraph,
-					selfModule.buildMeta.strictHarmonyModule
-				)
-			) {
-				case "default-only":
-				case "default-with-named":
-					if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
-					ids = ids.slice(1);
-					namespaceObjectAsContext = true;
-					break;
-				case "dynamic":
-					return Dependency.EXPORTS_OBJECT_REFERENCED;
-			}
+	apply(compiler) {
+		if (this._chunkLoading) {
+			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
 		}
-
-		if (
-			this.call &&
-			!this.directImport &&
-			(namespaceObjectAsContext || ids.length > 1)
-		) {
-			if (ids.length === 1) return Dependency.EXPORTS_OBJECT_REFERENCED;
-			ids = ids.slice(0, -1);
+		if (this._wasmLoading) {
+			new EnableWasmLoadingPlugin(this._wasmLoading).apply(compiler);
 		}
+		const cachedContextify = contextify.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
+		compiler.hooks.thisCompilation.tap(
+			"WorkerPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WorkerDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					WorkerDependency,
+					new WorkerDependency.Template()
+				);
+				compilation.dependencyTemplates.set(
+					CreateScriptUrlDependency,
+					new CreateScriptUrlDependency.Template()
+				);
 
-		return [ids];
-	}
-
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {number} effective mode
-	 */
-	_getEffectiveExportPresenceLevel(moduleGraph) {
-		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
-			return this.exportPresenceMode;
-		return moduleGraph.getParentModule(this).buildMeta.strictHarmonyModule
-			? ExportPresenceModes.ERROR
-			: ExportPresenceModes.WARN;
-	}
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {Expression} expr expression
+				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
+				 */
+				const parseModuleUrl = (parser, expr) => {
+					if (
+						expr.type !== "NewExpression" ||
+						expr.callee.type === "Super" ||
+						expr.arguments.length !== 2
+					)
+						return;
+					const [arg1, arg2] = expr.arguments;
+					if (arg1.type === "SpreadElement") return;
+					if (arg2.type === "SpreadElement") return;
+					const callee = parser.evaluateExpression(expr.callee);
+					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
+					const arg2Value = parser.evaluateExpression(arg2);
+					if (
+						!arg2Value.isString() ||
+						!arg2Value.string.startsWith("file://") ||
+						arg2Value.string !== getUrl(parser.state.module)
+					) {
+						return;
+					}
+					const arg1Value = parser.evaluateExpression(arg1);
+					return [arg1Value, [arg1.range[0], arg2.range[1]]];
+				};
 
-	/**
-	 * Returns warnings
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
-	 */
-	getWarnings(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.WARN) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
-	}
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {ObjectExpression} expr expression
+				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
+				 */
+				const parseObjectExpression = (parser, expr) => {
+					/** @type {Record<string, any>} */
+					const values = {};
+					/** @type {Record<string, Expression | Pattern>} */
+					const expressions = {};
+					/** @type {(Property | SpreadElement)[]} */
+					const otherElements = [];
+					let spread = false;
+					for (const prop of expr.properties) {
+						if (prop.type === "SpreadElement") {
+							spread = true;
+						} else if (
+							prop.type === "Property" &&
+							!prop.method &&
+							!prop.computed &&
+							prop.key.type === "Identifier"
+						) {
+							expressions[prop.key.name] = prop.value;
+							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
+								const value = parser.evaluateExpression(
+									/** @type {Expression} */ (prop.value)
+								);
+								if (value.isCompileTimeValue())
+									values[prop.key.name] = value.asCompileTimeValue();
+							}
+						} else {
+							otherElements.push(prop);
+						}
+					}
+					const insertType = expr.properties.length > 0 ? "comma" : "single";
+					const insertLocation =
+						expr.properties[expr.properties.length - 1].range[1];
+					return {
+						expressions,
+						otherElements,
+						values,
+						spread,
+						insertType,
+						insertLocation
+					};
+				};
 
-	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
-	 */
-	getErrors(moduleGraph) {
-		const exportsPresence = this._getEffectiveExportPresenceLevel(moduleGraph);
-		if (exportsPresence === ExportPresenceModes.ERROR) {
-			return this._getErrors(moduleGraph);
-		}
-		return null;
-	}
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {object} parserOptions options
+				 */
+				const parserPlugin = (parser, parserOptions) => {
+					if (parserOptions.worker === false) return;
+					const options = !Array.isArray(parserOptions.worker)
+						? ["..."]
+						: parserOptions.worker;
+					const handleNewWorker = expr => {
+						if (expr.arguments.length === 0 || expr.arguments.length > 2)
+							return;
+						const [arg1, arg2] = expr.arguments;
+						if (arg1.type === "SpreadElement") return;
+						if (arg2 && arg2.type === "SpreadElement") return;
+						const parsedUrl = parseModuleUrl(parser, arg1);
+						if (!parsedUrl) return;
+						const [url, range] = parsedUrl;
+						if (!url.isString()) return;
+						const {
+							expressions,
+							otherElements,
+							values: options,
+							spread: hasSpreadInOptions,
+							insertType,
+							insertLocation
+						} = arg2 && arg2.type === "ObjectExpression"
+							? parseObjectExpression(parser, arg2)
+							: {
+									expressions: {},
+									otherElements: [],
+									values: {},
+									spread: false,
+									insertType: arg2 ? "spread" : "argument",
+									insertLocation: arg2 ? arg2.range : arg1.range[1]
+							  };
+						const { options: importOptions, errors: commentErrors } =
+							parser.parseCommentOptions(expr.range);
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[] | undefined} errors
-	 */
-	_getErrors(moduleGraph) {
-		const ids = this.getIds(moduleGraph);
-		return this.getLinkingErrors(
-			moduleGraph,
-			ids,
-			`(imported as '${this.name}')`
-		);
-	}
+						if (commentErrors) {
+							for (const e of commentErrors) {
+								const { comment } = e;
+								parser.state.module.addWarning(
+									new CommentCompilationWarning(
+										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+										comment.loc
+									)
+								);
+							}
+						}
 
-	/**
-	 * implement this method to allow the occurrence order plugin to count correctly
-	 * @returns {number} count how often the id is used in this dependency
-	 */
-	getNumberOfIdOccurrences() {
-		return 0;
-	}
+						/** @type {EntryOptions} */
+						let entryOptions = {};
 
-	serialize(context) {
-		const { write } = context;
-		write(this.ids);
-		write(this.name);
-		write(this.range);
-		write(this.exportPresenceMode);
-		write(this.namespaceObjectAsContext);
-		write(this.call);
-		write(this.directImport);
-		write(this.shorthand);
-		write(this.asiSafe);
-		write(this.usedByExports);
-		super.serialize(context);
-	}
+						if (importOptions) {
+							if (importOptions.webpackIgnore !== undefined) {
+								if (typeof importOptions.webpackIgnore !== "boolean") {
+									parser.state.module.addWarning(
+										new UnsupportedFeatureWarning(
+											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+											expr.loc
+										)
+									);
+								} else {
+									if (importOptions.webpackIgnore) {
+										return false;
+									}
+								}
+							}
+							if (importOptions.webpackEntryOptions !== undefined) {
+								if (
+									typeof importOptions.webpackEntryOptions !== "object" ||
+									importOptions.webpackEntryOptions === null
+								) {
+									parser.state.module.addWarning(
+										new UnsupportedFeatureWarning(
+											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
+											expr.loc
+										)
+									);
+								} else {
+									Object.assign(
+										entryOptions,
+										importOptions.webpackEntryOptions
+									);
+								}
+							}
+							if (importOptions.webpackChunkName !== undefined) {
+								if (typeof importOptions.webpackChunkName !== "string") {
+									parser.state.module.addWarning(
+										new UnsupportedFeatureWarning(
+											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
+											expr.loc
+										)
+									);
+								} else {
+									entryOptions.name = importOptions.webpackChunkName;
+								}
+							}
+						}
 
-	deserialize(context) {
-		const { read } = context;
-		this.ids = read();
-		this.name = read();
-		this.range = read();
-		this.exportPresenceMode = read();
-		this.namespaceObjectAsContext = read();
-		this.call = read();
-		this.directImport = read();
-		this.shorthand = read();
-		this.asiSafe = read();
-		this.usedByExports = read();
-		super.deserialize(context);
-	}
-}
+						if (
+							!Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
+							options &&
+							typeof options.name === "string"
+						) {
+							entryOptions.name = options.name;
+						}
 
-makeSerializable(
-	HarmonyImportSpecifierDependency,
-	"webpack/lib/dependencies/HarmonyImportSpecifierDependency"
-);
+						if (entryOptions.runtime === undefined) {
+							let i = workerIndexMap.get(parser.state) || 0;
+							workerIndexMap.set(parser.state, i + 1);
+							let name = `${cachedContextify(
+								parser.state.module.identifier()
+							)}|${i}`;
+							const hash = createHash(compilation.outputOptions.hashFunction);
+							hash.update(name);
+							const digest = /** @type {string} */ (
+								hash.digest(compilation.outputOptions.hashDigest)
+							);
+							entryOptions.runtime = digest.slice(
+								0,
+								compilation.outputOptions.hashDigestLength
+							);
+						}
 
-HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependencyTemplate extends (
-	HarmonyImportDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
-		const { moduleGraph, module, runtime, concatenationScope } =
-			templateContext;
-		const connection = moduleGraph.getConnection(dep);
-		// Skip rendering depending when dependency is conditional
-		if (connection && !connection.isTargetActive(runtime)) return;
+						const block = new AsyncDependenciesBlock({
+							name: entryOptions.name,
+							entryOptions: {
+								chunkLoading: this._chunkLoading,
+								wasmLoading: this._wasmLoading,
+								...entryOptions
+							}
+						});
+						block.loc = expr.loc;
+						const dep = new WorkerDependency(url.string, range);
+						dep.loc = expr.loc;
+						block.addDependency(dep);
+						parser.state.module.addBlock(block);
 
-		const ids = dep.getIds(moduleGraph);
+						if (compilation.outputOptions.trustedTypes) {
+							const dep = new CreateScriptUrlDependency(
+								expr.arguments[0].range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+						}
 
-		let exportExpr;
-		if (
-			connection &&
-			concatenationScope &&
-			concatenationScope.isModuleInScope(connection.module)
-		) {
-			if (ids.length === 0) {
-				exportExpr = concatenationScope.createModuleReference(
-					connection.module,
-					{
-						asiSafe: dep.asiSafe
-					}
-				);
-			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
-				exportExpr =
-					concatenationScope.createModuleReference(connection.module, {
-						asiSafe: dep.asiSafe
-					}) + propertyAccess(ids);
-			} else {
-				exportExpr = concatenationScope.createModuleReference(
-					connection.module,
-					{
-						ids,
-						call: dep.call,
-						directImport: dep.directImport,
-						asiSafe: dep.asiSafe
-					}
-				);
-			}
-		} else {
-			super.apply(dependency, source, templateContext);
+						if (expressions.type) {
+							const expr = expressions.type;
+							if (options.type !== false) {
+								const dep = new ConstDependency(
+									this._module ? '"module"' : "undefined",
+									expr.range
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								expressions.type = undefined;
+							}
+						} else if (insertType === "comma") {
+							if (this._module || hasSpreadInOptions) {
+								const dep = new ConstDependency(
+									`, type: ${this._module ? '"module"' : "undefined"}`,
+									insertLocation
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
+						} else if (insertType === "spread") {
+							const dep1 = new ConstDependency(
+								"Object.assign({}, ",
+								insertLocation[0]
+							);
+							const dep2 = new ConstDependency(
+								`, { type: ${this._module ? '"module"' : "undefined"} })`,
+								insertLocation[1]
+							);
+							dep1.loc = expr.loc;
+							dep2.loc = expr.loc;
+							parser.state.module.addPresentationalDependency(dep1);
+							parser.state.module.addPresentationalDependency(dep2);
+						} else if (insertType === "argument") {
+							if (this._module) {
+								const dep = new ConstDependency(
+									', { type: "module" }',
+									insertLocation
+								);
+								dep.loc = expr.loc;
+								parser.state.module.addPresentationalDependency(dep);
+							}
+						}
 
-			const { runtimeTemplate, initFragments, runtimeRequirements } =
-				templateContext;
+						parser.walkExpression(expr.callee);
+						for (const key of Object.keys(expressions)) {
+							if (expressions[key]) parser.walkExpression(expressions[key]);
+						}
+						for (const prop of otherElements) {
+							parser.walkProperty(prop);
+						}
+						if (insertType === "spread") {
+							parser.walkExpression(arg2);
+						}
 
-			exportExpr = runtimeTemplate.exportFromImport({
-				moduleGraph,
-				module: moduleGraph.getModule(dep),
-				request: dep.request,
-				exportName: ids,
-				originModule: module,
-				asiSafe: dep.shorthand ? true : dep.asiSafe,
-				isCall: dep.call,
-				callContext: !dep.directImport,
-				defaultInterop: true,
-				importVar: dep.getImportVar(moduleGraph),
-				initFragments,
-				runtime,
-				runtimeRequirements
-			});
-		}
-		if (dep.shorthand) {
-			source.insert(dep.range[1], `: ${exportExpr}`);
-		} else {
-			source.replace(dep.range[0], dep.range[1] - 1, exportExpr);
-		}
+						return true;
+					};
+					const processItem = item => {
+						if (item.endsWith("()")) {
+							parser.hooks.call
+								.for(item.slice(0, -2))
+								.tap("WorkerPlugin", handleNewWorker);
+						} else {
+							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
+							if (match) {
+								const ids = match[1].split(".");
+								const call = match[2];
+								const source = match[3];
+								(call ? parser.hooks.call : parser.hooks.new)
+									.for(harmonySpecifierTag)
+									.tap("WorkerPlugin", expr => {
+										const settings = /** @type {HarmonySettings} */ (
+											parser.currentTagData
+										);
+										if (
+											!settings ||
+											settings.source !== source ||
+											!equals(settings.ids, ids)
+										) {
+											return;
+										}
+										return handleNewWorker(expr);
+									});
+							} else {
+								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
+							}
+						}
+					};
+					for (const item of options) {
+						if (item === "...") {
+							DEFAULT_SYNTAX.forEach(processItem);
+						} else processItem(item);
+					}
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("WorkerPlugin", parserPlugin);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("WorkerPlugin", parserPlugin);
+			}
+		);
 	}
-};
-
-module.exports = HarmonyImportSpecifierDependency;
+}
+module.exports = WorkerPlugin;
 
 
 /***/ }),
 
-/***/ 39029:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 50396:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -86950,160 +84941,132 @@ module.exports = HarmonyImportSpecifierDependency;
 
 
 
-const HarmonyAcceptDependency = __webpack_require__(23624);
-const HarmonyAcceptImportDependency = __webpack_require__(99843);
-const HarmonyCompatibilityDependency = __webpack_require__(72906);
-const HarmonyExportExpressionDependency = __webpack_require__(51340);
-const HarmonyExportHeaderDependency = __webpack_require__(38873);
-const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
-const HarmonyExportSpecifierDependency = __webpack_require__(48567);
-const HarmonyImportSideEffectDependency = __webpack_require__(73132);
-const HarmonyImportSpecifierDependency = __webpack_require__(14077);
-
-const HarmonyDetectionParserPlugin = __webpack_require__(17223);
-const HarmonyExportDependencyParserPlugin = __webpack_require__(93466);
-const HarmonyImportDependencyParserPlugin = __webpack_require__(20862);
-const HarmonyTopLevelThisParserPlugin = __webpack_require__(63232);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-class HarmonyModulesPlugin {
-	constructor(options) {
-		this.options = options;
+module.exports = expr => {
+	// <FunctionExpression>
+	if (
+		expr.type === "FunctionExpression" ||
+		expr.type === "ArrowFunctionExpression"
+	) {
+		return {
+			fn: expr,
+			expressions: [],
+			needThis: false
+		};
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"HarmonyModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					HarmonyCompatibilityDependency,
-					new HarmonyCompatibilityDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyImportSideEffectDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyImportSideEffectDependency,
-					new HarmonyImportSideEffectDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyImportSpecifierDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyImportSpecifierDependency,
-					new HarmonyImportSpecifierDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyExportHeaderDependency,
-					new HarmonyExportHeaderDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyExportExpressionDependency,
-					new HarmonyExportExpressionDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyExportSpecifierDependency,
-					new HarmonyExportSpecifierDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyExportImportedSpecifierDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyExportImportedSpecifierDependency,
-					new HarmonyExportImportedSpecifierDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyAcceptDependency,
-					new HarmonyAcceptDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyAcceptImportDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyAcceptImportDependency,
-					new HarmonyAcceptImportDependency.Template()
-				);
-
-				const handler = (parser, parserOptions) => {
-					// TODO webpack 6: rename harmony to esm or module
-					if (parserOptions.harmony !== undefined && !parserOptions.harmony)
-						return;
-
-					new HarmonyDetectionParserPlugin(this.options).apply(parser);
-					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
-					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
-					new HarmonyTopLevelThisParserPlugin().apply(parser);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("HarmonyModulesPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("HarmonyModulesPlugin", handler);
-			}
-		);
+	// <FunctionExpression>.bind(<Expression>)
+	if (
+		expr.type === "CallExpression" &&
+		expr.callee.type === "MemberExpression" &&
+		expr.callee.object.type === "FunctionExpression" &&
+		expr.callee.property.type === "Identifier" &&
+		expr.callee.property.name === "bind" &&
+		expr.arguments.length === 1
+	) {
+		return {
+			fn: expr.callee.object,
+			expressions: [expr.arguments[0]],
+			needThis: undefined
+		};
 	}
-}
-module.exports = HarmonyModulesPlugin;
+	// (function(_this) {return <FunctionExpression>})(this) (Coffeescript)
+	if (
+		expr.type === "CallExpression" &&
+		expr.callee.type === "FunctionExpression" &&
+		expr.callee.body.type === "BlockStatement" &&
+		expr.arguments.length === 1 &&
+		expr.arguments[0].type === "ThisExpression" &&
+		expr.callee.body.body &&
+		expr.callee.body.body.length === 1 &&
+		expr.callee.body.body[0].type === "ReturnStatement" &&
+		expr.callee.body.body[0].argument &&
+		expr.callee.body.body[0].argument.type === "FunctionExpression"
+	) {
+		return {
+			fn: expr.callee.body.body[0].argument,
+			expressions: [],
+			needThis: true
+		};
+	}
+};
 
 
 /***/ }),
 
-/***/ 63232:
+/***/ 55207:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const ConstDependency = __webpack_require__(76911);
-const HarmonyExports = __webpack_require__(39211);
+const { UsageState } = __webpack_require__(63686);
 
-class HarmonyTopLevelThisParserPlugin {
-	apply(parser) {
-		parser.hooks.expression
-			.for("this")
-			.tap("HarmonyTopLevelThisParserPlugin", node => {
-				if (!parser.scope.topLevelScope) return;
-				if (HarmonyExports.isEnabled(parser.state)) {
-					const dep = new ConstDependency("undefined", node.range, null);
-					dep.loc = node.loc;
-					parser.state.module.addPresentationalDependency(dep);
-					return this;
-				}
-			});
-	}
-}
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-module.exports = HarmonyTopLevelThisParserPlugin;
+/**
+ * @param {RuntimeSpec} runtime the runtime
+ * @param {string[][]} referencedExports list of referenced exports, will be added to
+ * @param {string[]} prefix export prefix
+ * @param {ExportInfo=} exportInfo the export info
+ * @param {boolean} defaultPointsToSelf when true, using default will reference itself
+ * @param {Set<ExportInfo>} alreadyVisited already visited export info (to handle circular reexports)
+ */
+const processExportInfo = (
+	runtime,
+	referencedExports,
+	prefix,
+	exportInfo,
+	defaultPointsToSelf = false,
+	alreadyVisited = new Set()
+) => {
+	if (!exportInfo) {
+		referencedExports.push(prefix);
+		return;
+	}
+	const used = exportInfo.getUsed(runtime);
+	if (used === UsageState.Unused) return;
+	if (alreadyVisited.has(exportInfo)) {
+		referencedExports.push(prefix);
+		return;
+	}
+	alreadyVisited.add(exportInfo);
+	if (
+		used !== UsageState.OnlyPropertiesUsed ||
+		!exportInfo.exportsInfo ||
+		exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !==
+			UsageState.Unused
+	) {
+		alreadyVisited.delete(exportInfo);
+		referencedExports.push(prefix);
+		return;
+	}
+	const exportsInfo = exportInfo.exportsInfo;
+	for (const exportInfo of exportsInfo.orderedExports) {
+		processExportInfo(
+			runtime,
+			referencedExports,
+			defaultPointsToSelf && exportInfo.name === "default"
+				? prefix
+				: prefix.concat(exportInfo.name),
+			exportInfo,
+			false,
+			alreadyVisited
+		);
+	}
+	alreadyVisited.delete(exportInfo);
+};
+module.exports = processExportInfo;
 
 
 /***/ }),
 
-/***/ 1902:
+/***/ 32277:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -87114,58 +85077,72 @@ module.exports = HarmonyTopLevelThisParserPlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-const ContextDependencyTemplateAsRequireCall = __webpack_require__(75815);
-
-class ImportContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
-
-		this.range = range;
-		this.valueRange = valueRange;
-	}
-
-	get type() {
-		return `import() context ${this.options.mode}`;
-	}
-
-	get category() {
-		return "esm";
-	}
-
-	serialize(context) {
-		const { write } = context;
+const ExternalsPlugin = __webpack_require__(6652);
 
-		write(this.range);
-		write(this.valueRange);
+/** @typedef {import("../Compiler")} Compiler */
 
-		super.serialize(context);
+class ElectronTargetPlugin {
+	/**
+	 * @param {"main" | "preload" | "renderer"=} context in main, preload or renderer context?
+	 */
+	constructor(context) {
+		this._context = context;
 	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.range = read();
-		this.valueRange = read();
-
-		super.deserialize(context);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ExternalsPlugin("node-commonjs", [
+			"clipboard",
+			"crash-reporter",
+			"electron",
+			"ipc",
+			"native-image",
+			"original-fs",
+			"screen",
+			"shell"
+		]).apply(compiler);
+		switch (this._context) {
+			case "main":
+				new ExternalsPlugin("node-commonjs", [
+					"app",
+					"auto-updater",
+					"browser-window",
+					"content-tracing",
+					"dialog",
+					"global-shortcut",
+					"ipc-main",
+					"menu",
+					"menu-item",
+					"power-monitor",
+					"power-save-blocker",
+					"protocol",
+					"session",
+					"tray",
+					"web-contents"
+				]).apply(compiler);
+				break;
+			case "preload":
+			case "renderer":
+				new ExternalsPlugin("node-commonjs", [
+					"desktop-capturer",
+					"ipc-renderer",
+					"remote",
+					"web-frame"
+				]).apply(compiler);
+				break;
+		}
 	}
 }
 
-makeSerializable(
-	ImportContextDependency,
-	"webpack/lib/dependencies/ImportContextDependency"
-);
-
-ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
-
-module.exports = ImportContextDependency;
+module.exports = ElectronTargetPlugin;
 
 
 /***/ }),
 
-/***/ 89376:
+/***/ 22273:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -87176,756 +85153,597 @@ module.exports = ImportContextDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class ImportDependency extends ModuleDependency {
-	/**
-	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
-	 */
-	constructor(request, range, referencedExports) {
-		super(request);
-		this.range = range;
-		this.referencedExports = referencedExports;
-	}
-
-	get type() {
-		return "import()";
-	}
-
-	get category() {
-		return "esm";
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return this.referencedExports
-			? this.referencedExports.map(e => ({
-					name: e,
-					canMangle: false
-			  }))
-			: Dependency.EXPORTS_OBJECT_REFERENCED;
-	}
-
-	serialize(context) {
-		context.write(this.range);
-		context.write(this.referencedExports);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		this.range = context.read();
-		this.referencedExports = context.read();
-		super.deserialize(context);
-	}
-}
+const WebpackError = __webpack_require__(53799);
 
-makeSerializable(ImportDependency, "webpack/lib/dependencies/ImportDependency");
+/** @typedef {import("../Module")} Module */
 
-ImportDependency.Template = class ImportDependencyTemplate extends (
-	ModuleDependency.Template
-) {
+class BuildCycleError extends WebpackError {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * Creates an instance of ModuleDependencyError.
+	 * @param {Module} module the module starting the cycle
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ImportDependency} */ (dependency);
-		const block = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dep)
+	constructor(module) {
+		super(
+			"There is a circular build dependency, which makes it impossible to create this module"
 		);
-		const content = runtimeTemplate.moduleNamespacePromise({
-			chunkGraph,
-			block: block,
-			module: moduleGraph.getModule(dep),
-			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
-			message: "import()",
-			runtimeRequirements
-		});
 
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+		this.name = "BuildCycleError";
+		this.module = module;
 	}
-};
+}
 
-module.exports = ImportDependency;
+module.exports = BuildCycleError;
 
 
 /***/ }),
 
-/***/ 50718:
+/***/ 5294:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ImportDependency = __webpack_require__(89376);
+const RuntimeModule = __webpack_require__(16963);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+class ExportWebpackRequireRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("export webpack runtime", RuntimeModule.STAGE_ATTACH);
+	}
 
-class ImportEagerDependency extends ImportDependency {
 	/**
-	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
+	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
-	constructor(request, range, referencedExports) {
-		super(request, range, referencedExports);
-	}
-
-	get type() {
-		return "import() eager";
-	}
-
-	get category() {
-		return "esm";
+	shouldIsolate() {
+		return false;
 	}
-}
-
-makeSerializable(
-	ImportEagerDependency,
-	"webpack/lib/dependencies/ImportEagerDependency"
-);
 
-ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
-	ImportDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ImportEagerDependency} */ (dependency);
-		const content = runtimeTemplate.moduleNamespacePromise({
-			chunkGraph,
-			module: moduleGraph.getModule(dep),
-			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
-			message: "import() eager",
-			runtimeRequirements
-		});
-
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+	generate() {
+		return "export default __webpack_require__;";
 	}
-};
+}
 
-module.exports = ImportEagerDependency;
+module.exports = ExportWebpackRequireRuntimeModule;
 
 
 /***/ }),
 
-/***/ 51274:
+/***/ 68927:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+const { ConcatSource } = __webpack_require__(51255);
+const { RuntimeGlobals } = __webpack_require__(91919);
+const HotUpdateChunk = __webpack_require__(9597);
+const Template = __webpack_require__(1626);
+const { getAllChunks } = __webpack_require__(91145);
+const {
+	getCompilationHooks,
+	getChunkFilenameTemplate
+} = __webpack_require__(89464);
+const { updateHashForEntryStartup } = __webpack_require__(98124);
 
-class ImportMetaHotAcceptDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-		this.range = range;
-		this.weak = true;
-	}
+/** @typedef {import("../Compiler")} Compiler */
 
-	get type() {
-		return "import.meta.webpackHot.accept";
-	}
-
-	get category() {
-		return "esm";
-	}
-}
-
-makeSerializable(
-	ImportMetaHotAcceptDependency,
-	"webpack/lib/dependencies/ImportMetaHotAcceptDependency"
-);
-
-ImportMetaHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
-
-module.exports = ImportMetaHotAcceptDependency;
-
-
-/***/ }),
-
-/***/ 53141:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+class ModuleChunkFormatPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ModuleChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ModuleChunkFormatPlugin",
+					(chunk, set) => {
+						if (chunk.hasRuntime()) return;
+						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.require);
+							set.add(RuntimeGlobals.startupEntrypoint);
+							set.add(RuntimeGlobals.externalInstallChunk);
+						}
+					}
+				);
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"ModuleChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
+						const source = new ConcatSource();
+						if (hotUpdateChunk) {
+							throw new Error(
+								"HMR is not implemented for module chunk format yet"
+							);
+						} else {
+							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
+							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
+							source.add(`export const modules = `);
+							source.add(modules);
+							source.add(`;\n`);
+							const runtimeModules =
+								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+							if (runtimeModules.length > 0) {
+								source.add("export const runtime =\n");
+								source.add(
+									Template.renderChunkRuntimeModules(
+										runtimeModules,
+										renderContext
+									)
+								);
+							}
+							const entries = Array.from(
+								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+							);
+							if (entries.length > 0) {
+								const runtimeChunk = entries[0][1].getRuntimeChunk();
+								const currentOutputName = compilation
+									.getPath(
+										getChunkFilenameTemplate(chunk, compilation.outputOptions),
+										{
+											chunk,
+											contentHashType: "javascript"
+										}
+									)
+									.split("/");
 
+								// remove filename, we only need the directory
+								currentOutputName.pop();
 
+								const getRelativePath = chunk => {
+									const baseOutputName = currentOutputName.slice();
+									const chunkOutputName = compilation
+										.getPath(
+											getChunkFilenameTemplate(
+												chunk,
+												compilation.outputOptions
+											),
+											{
+												chunk: chunk,
+												contentHashType: "javascript"
+											}
+										)
+										.split("/");
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+									// remove common parts
+									while (
+										baseOutputName.length > 0 &&
+										chunkOutputName.length > 0 &&
+										baseOutputName[0] === chunkOutputName[0]
+									) {
+										baseOutputName.shift();
+										chunkOutputName.shift();
+									}
+									// create final path
+									return (
+										(baseOutputName.length > 0
+											? "../".repeat(baseOutputName.length)
+											: "./") + chunkOutputName.join("/")
+									);
+								};
 
-class ImportMetaHotDeclineDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+								const entrySource = new ConcatSource();
+								entrySource.add(source);
+								entrySource.add(";\n\n// load runtime\n");
+								entrySource.add(
+									`import __webpack_require__ from ${JSON.stringify(
+										getRelativePath(runtimeChunk)
+									)};\n`
+								);
 
-		this.range = range;
-		this.weak = true;
-	}
+								const startupSource = new ConcatSource();
+								startupSource.add(
+									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+										`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+										"moduleId"
+									)}\n`
+								);
 
-	get type() {
-		return "import.meta.webpackHot.decline";
-	}
+								const loadedChunks = new Set();
+								let index = 0;
+								for (let i = 0; i < entries.length; i++) {
+									const [module, entrypoint] = entries[i];
+									const final = i + 1 === entries.length;
+									const moduleId = chunkGraph.getModuleId(module);
+									const chunks = getAllChunks(
+										entrypoint,
+										runtimeChunk,
+										undefined
+									);
+									for (const chunk of chunks) {
+										if (loadedChunks.has(chunk)) continue;
+										loadedChunks.add(chunk);
+										startupSource.add(
+											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
+												getRelativePath(chunk)
+											)};\n`
+										);
+										startupSource.add(
+											`${RuntimeGlobals.externalInstallChunk}(__webpack_chunk_${index}__);\n`
+										);
+										index++;
+									}
+									startupSource.add(
+										`${
+											final ? "var __webpack_exports__ = " : ""
+										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
+									);
+								}
 
-	get category() {
-		return "esm";
+								entrySource.add(
+									hooks.renderStartup.call(
+										startupSource,
+										entries[entries.length - 1][0],
+										{
+											...renderContext,
+											inlined: false
+										}
+									)
+								);
+								return entrySource;
+							}
+						}
+						return source;
+					}
+				);
+				hooks.chunkHash.tap(
+					"ModuleChunkFormatPlugin",
+					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update("ModuleChunkFormatPlugin");
+						hash.update("1");
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
+			}
+		);
 	}
 }
 
-makeSerializable(
-	ImportMetaHotDeclineDependency,
-	"webpack/lib/dependencies/ImportMetaHotDeclineDependency"
-);
-
-ImportMetaHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
-
-module.exports = ImportMetaHotDeclineDependency;
+module.exports = ModuleChunkFormatPlugin;
 
 
 /***/ }),
 
-/***/ 17228:
+/***/ 89831:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { pathToFileURL } = __webpack_require__(57310);
-const ModuleDependencyWarning = __webpack_require__(29656);
-const Template = __webpack_require__(39722);
-const BasicEvaluatedExpression = __webpack_require__(950);
-const {
-	evaluateToIdentifier,
-	toConstantDependency,
-	evaluateToString,
-	evaluateToNumber
-} = __webpack_require__(93998);
-const memoize = __webpack_require__(78676);
-const propertyAccess = __webpack_require__(54190);
-const ConstDependency = __webpack_require__(76911);
+const RuntimeGlobals = __webpack_require__(16475);
+const ExportWebpackRequireRuntimeModule = __webpack_require__(5294);
+const ModuleChunkLoadingRuntimeModule = __webpack_require__(64747);
 
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
-
-const getCriticalDependencyWarning = memoize(() =>
-	__webpack_require__(15427)
-);
 
-class ImportMetaPlugin {
+class ModuleChunkLoadingPlugin {
 	/**
-	 * @param {Compiler} compiler compiler
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ImportMetaPlugin",
-			(compilation, { normalModuleFactory }) => {
-				/**
-				 * @param {NormalModule} module module
-				 * @returns {string} file url
-				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource).toString();
+		compiler.hooks.thisCompilation.tap(
+			"ModuleChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						(options && options.chunkLoading) || globalChunkLoading;
+					return chunkLoading === "import";
 				};
-				/**
-				 * @param {Parser} parser parser parser
-				 * @param {JavascriptParserOptions} parserOptions parserOptions
-				 * @returns {void}
-				 */
-				const parserHandler = (parser, { importMeta }) => {
-					if (importMeta === false) {
-						const { importMetaName } = compilation.outputOptions;
-						if (importMetaName === "import.meta") return;
-
-						parser.hooks.expression
-							.for("import.meta")
-							.tap("ImportMetaPlugin", metaProperty => {
-								const dep = new ConstDependency(
-									importMetaName,
-									metaProperty.range
-								);
-								dep.loc = metaProperty.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								return true;
-							});
-						return;
-					}
-
-					/// import.meta direct ///
-					parser.hooks.typeof
-						.for("import.meta")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-					parser.hooks.expression
-						.for("import.meta")
-						.tap("ImportMetaPlugin", metaProperty => {
-							const CriticalDependencyWarning = getCriticalDependencyWarning();
-							parser.state.module.addWarning(
-								new ModuleDependencyWarning(
-									parser.state.module,
-									new CriticalDependencyWarning(
-										"Accessing import.meta directly is unsupported (only property access is supported)"
-									),
-									metaProperty.loc
-								)
-							);
-							const dep = new ConstDependency(
-								`${parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""}({})`,
-								metaProperty.range
-							);
-							dep.loc = metaProperty.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for("import.meta")
-						.tap("ImportMetaPlugin", evaluateToString("object"));
-					parser.hooks.evaluateIdentifier.for("import.meta").tap(
-						"ImportMetaPlugin",
-						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
-					);
-
-					/// import.meta.url ///
-					parser.hooks.typeof
-						.for("import.meta.url")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify("string"))
-						);
-					parser.hooks.expression
-						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
-							const dep = new ConstDependency(
-								JSON.stringify(getUrl(parser.state.module)),
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluateTypeof
-						.for("import.meta.url")
-						.tap("ImportMetaPlugin", evaluateToString("string"));
-					parser.hooks.evaluateIdentifier
-						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
-							return new BasicEvaluatedExpression()
-								.setString(getUrl(parser.state.module))
-								.setRange(expr.range);
-						});
-
-					/// import.meta.webpack ///
-					const webpackVersion = parseInt(
-						(__webpack_require__(32702)/* .version */ .i8),
-						10
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
+						chunk,
+						new ModuleChunkLoadingRuntimeModule(set)
 					);
-					parser.hooks.typeof
-						.for("import.meta.webpack")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify("number"))
-						);
-					parser.hooks.expression
-						.for("import.meta.webpack")
-						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify(webpackVersion))
-						);
-					parser.hooks.evaluateTypeof
-						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToString("number"));
-					parser.hooks.evaluateIdentifier
-						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToNumber(webpackVersion));
-
-					/// Unknown properties ///
-					parser.hooks.unhandledExpressionMemberChain
-						.for("import.meta")
-						.tap("ImportMetaPlugin", (expr, members) => {
-							const dep = new ConstDependency(
-								`${Template.toNormalComment(
-									"unsupported import.meta." + members.join(".")
-								)} undefined${propertyAccess(members, 1)}`,
-								expr.range
-							);
-							dep.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep);
-							return true;
-						});
-					parser.hooks.evaluate
-						.for("MemberExpression")
-						.tap("ImportMetaPlugin", expression => {
-							const expr = /** @type {MemberExpression} */ (expression);
-							if (
-								expr.object.type === "MetaProperty" &&
-								expr.object.meta.name === "import" &&
-								expr.object.property.name === "meta" &&
-								expr.property.type ===
-									(expr.computed ? "Literal" : "Identifier")
-							) {
-								return new BasicEvaluatedExpression()
-									.setUndefined()
-									.setRange(expr.range);
-							}
-						});
 				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("ModuleChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						compilation.addRuntimeModule(
+							chunk,
+							new ExportWebpackRequireRuntimeModule()
+						);
+					});
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportMetaPlugin", parserHandler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportMetaPlugin", parserHandler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
 			}
 		);
 	}
 }
 
-module.exports = ImportMetaPlugin;
+module.exports = ModuleChunkLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 88130:
+/***/ 64747:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const CommentCompilationWarning = __webpack_require__(98427);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const ContextDependencyHelpers = __webpack_require__(99630);
-const ImportContextDependency = __webpack_require__(1902);
-const ImportDependency = __webpack_require__(89376);
-const ImportEagerDependency = __webpack_require__(50718);
-const ImportWeakDependency = __webpack_require__(82483);
-
-/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
-/** @typedef {import("../ContextModule").ContextMode} ContextMode */
-
-class ImportParserPlugin {
-	constructor(options) {
-		this.options = options;
-	}
+const { SyncWaterfallHook } = __webpack_require__(6967);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const {
+	getChunkFilenameTemplate,
+	chunkHasJs
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
 
-	apply(parser) {
-		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
-			const param = parser.evaluateExpression(expr.source);
+/** @typedef {import("../Chunk")} Chunk */
 
-			let chunkName = null;
-			/** @type {ContextMode} */
-			let mode = "lazy";
-			let include = null;
-			let exclude = null;
-			/** @type {string[][] | null} */
-			let exports = null;
-			/** @type {RawChunkGroupOptions} */
-			const groupOptions = {};
+/**
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ */
 
-			const { options: importOptions, errors: commentErrors } =
-				parser.parseCommentOptions(expr.range);
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
 
-			if (commentErrors) {
-				for (const e of commentErrors) {
-					const { comment } = e;
-					parser.state.module.addWarning(
-						new CommentCompilationWarning(
-							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-							comment.loc
-						)
-					);
-				}
-			}
-
-			if (importOptions) {
-				if (importOptions.webpackIgnore !== undefined) {
-					if (typeof importOptions.webpackIgnore !== "boolean") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								expr.loc
-							)
-						);
-					} else {
-						// Do not instrument `import()` if `webpackIgnore` is `true`
-						if (importOptions.webpackIgnore) {
-							return false;
-						}
-					}
-				}
-				if (importOptions.webpackChunkName !== undefined) {
-					if (typeof importOptions.webpackChunkName !== "string") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								expr.loc
-							)
-						);
-					} else {
-						chunkName = importOptions.webpackChunkName;
-					}
-				}
-				if (importOptions.webpackMode !== undefined) {
-					if (typeof importOptions.webpackMode !== "string") {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								expr.loc
-							)
-						);
-					} else {
-						mode = importOptions.webpackMode;
-					}
-				}
-				if (importOptions.webpackPrefetch !== undefined) {
-					if (importOptions.webpackPrefetch === true) {
-						groupOptions.prefetchOrder = 0;
-					} else if (typeof importOptions.webpackPrefetch === "number") {
-						groupOptions.prefetchOrder = importOptions.webpackPrefetch;
-					} else {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								expr.loc
-							)
-						);
-					}
-				}
-				if (importOptions.webpackPreload !== undefined) {
-					if (importOptions.webpackPreload === true) {
-						groupOptions.preloadOrder = 0;
-					} else if (typeof importOptions.webpackPreload === "number") {
-						groupOptions.preloadOrder = importOptions.webpackPreload;
-					} else {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								expr.loc
-							)
-						);
-					}
-				}
-				if (importOptions.webpackInclude !== undefined) {
-					if (
-						!importOptions.webpackInclude ||
-						importOptions.webpackInclude.constructor.name !== "RegExp"
-					) {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								expr.loc
-							)
-						);
-					} else {
-						include = new RegExp(importOptions.webpackInclude);
-					}
-				}
-				if (importOptions.webpackExclude !== undefined) {
-					if (
-						!importOptions.webpackExclude ||
-						importOptions.webpackExclude.constructor.name !== "RegExp"
-					) {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								expr.loc
-							)
-						);
-					} else {
-						exclude = new RegExp(importOptions.webpackExclude);
-					}
-				}
-				if (importOptions.webpackExports !== undefined) {
-					if (
-						!(
-							typeof importOptions.webpackExports === "string" ||
-							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
-									item => typeof item === "string"
-								))
-						)
-					) {
-						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
-								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								expr.loc
-							)
-						);
-					} else {
-						if (typeof importOptions.webpackExports === "string") {
-							exports = [[importOptions.webpackExports]];
-						} else {
-							exports = Array.from(importOptions.webpackExports, e => [e]);
-						}
-					}
-				}
-			}
+class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
 
-			if (param.isString()) {
-				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-				}
+	constructor(runtimeRequirements) {
+		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
+	}
 
-				if (mode === "eager") {
-					const dep = new ImportEagerDependency(
-						param.string,
-						expr.range,
-						exports
-					);
-					parser.state.current.addDependency(dep);
-				} else if (mode === "weak") {
-					const dep = new ImportWeakDependency(
-						param.string,
-						expr.range,
-						exports
-					);
-					parser.state.current.addDependency(dep);
-				} else {
-					const depBlock = new AsyncDependenciesBlock(
-						{
-							...groupOptions,
-							name: chunkName
-						},
-						expr.loc,
-						param.string
-					);
-					const dep = new ImportDependency(param.string, expr.range, exports);
-					dep.loc = expr.loc;
-					depBlock.addDependency(dep);
-					parser.state.current.addBlock(depBlock);
-				}
-				return true;
-			} else {
-				if (
-					mode !== "lazy" &&
-					mode !== "lazy-once" &&
-					mode !== "eager" &&
-					mode !== "weak"
-				) {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-					mode = "lazy";
-				}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunk } = this;
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			outputOptions: { importFunctionName, importMetaName }
+		} = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this._runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
+		const withLoading = this._runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withOnChunkLoad = this._runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withHmr = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-				if (mode === "weak") {
-					mode = "async-weak";
-				}
-				const dep = ContextDependencyHelpers.create(
-					ImportContextDependency,
-					expr.range,
-					param,
-					expr,
-					this.options,
-					{
-						chunkName,
-						groupOptions,
-						include,
-						exclude,
-						mode,
-						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
-							? "strict"
-							: true,
-						typePrefix: "import()",
-						category: "esm",
-						referencedExports: exports
-					},
-					parser
-				);
-				if (!dep) return;
-				dep.loc = expr.loc;
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
 			}
-		});
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			true
+		);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_module`
+			: undefined;
+
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
+							rootOutputDir
+						)}, ${importMetaName}.url);`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
+						runtimeTemplate.destructureObject(
+							["ids", "modules", "runtime"],
+							"data"
+						),
+						'// add "modules" to the modules object,',
+						'// then flag all "ids" as loaded and fire callback',
+						"var moduleId, chunkId, i = 0;",
+						"for(moduleId in modules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
+							Template.indent(
+								`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
+							),
+							"}"
+						]),
+						"}",
+						"if(runtime) runtime(__webpack_require__);",
+						"for(;i < ids.length; i++) {",
+						Template.indent([
+							"chunkId = ids[i];",
+							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+							Template.indent("installedChunks[chunkId][0]();"),
+							"}",
+							"installedChunks[ids[i]] = 0;"
+						]),
+						"}",
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])}`
+				: "// no install chunk",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.j = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? Template.indent([
+										"// import() chunk loading for javascript",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[1]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasJsMatcher === true
+													? "if(true) { // all chunks have JS"
+													: `if(${hasJsMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = ${importFunctionName}(${JSON.stringify(
+														rootOutputDir
+													)} + ${
+														RuntimeGlobals.getChunkScriptFilename
+													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
+														"e",
+														[
+															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+															"throw e;"
+														]
+													)});`,
+													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve]`,
+														"resolve"
+													)})])`,
+													`promises.push(installedChunkData[1] = promise);`
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ])
+								: Template.indent(["installedChunks[chunkId] = 0;"])
+						)};`
+				  ])
+				: "// no chunk on demand loading",
+			"",
+			withExternalInstallChunk
+				? Template.asString([
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.j = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded"
+		]);
 	}
 }
 
-module.exports = ImportParserPlugin;
+module.exports = ModuleChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 41293:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 16734:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -87935,86 +85753,72 @@ module.exports = ImportParserPlugin;
 
 
 
-const ImportContextDependency = __webpack_require__(1902);
-const ImportDependency = __webpack_require__(89376);
-const ImportEagerDependency = __webpack_require__(50718);
-const ImportParserPlugin = __webpack_require__(88130);
-const ImportWeakDependency = __webpack_require__(82483);
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
 
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @param {SourcePosition} pos position
+ * @returns {string} formatted position
+ */
+const formatPosition = pos => {
+	if (pos && typeof pos === "object") {
+		if ("line" in pos && "column" in pos) {
+			return `${pos.line}:${pos.column}`;
+		} else if ("line" in pos) {
+			return `${pos.line}:?`;
+		}
+	}
+	return "";
+};
 
-class ImportPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ImportPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ImportDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportDependency,
-					new ImportDependency.Template()
-				);
+/**
+ * @param {DependencyLocation} loc location
+ * @returns {string} formatted location
+ */
+const formatLocation = loc => {
+	if (loc && typeof loc === "object") {
+		if ("start" in loc && loc.start && "end" in loc && loc.end) {
+			if (
+				typeof loc.start === "object" &&
+				typeof loc.start.line === "number" &&
+				typeof loc.end === "object" &&
+				typeof loc.end.line === "number" &&
+				typeof loc.end.column === "number" &&
+				loc.start.line === loc.end.line
+			) {
+				return `${formatPosition(loc.start)}-${loc.end.column}`;
+			} else if (
+				typeof loc.start === "object" &&
+				typeof loc.start.line === "number" &&
+				typeof loc.start.column !== "number" &&
+				typeof loc.end === "object" &&
+				typeof loc.end.line === "number" &&
+				typeof loc.end.column !== "number"
+			) {
+				return `${loc.start.line}-${loc.end.line}`;
+			} else {
+				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
+			}
+		}
+		if ("start" in loc && loc.start) {
+			return formatPosition(loc.start);
+		}
+		if ("name" in loc && "index" in loc) {
+			return `${loc.name}[${loc.index}]`;
+		}
+		if ("name" in loc) {
+			return loc.name;
+		}
+	}
+	return "";
+};
 
-				compilation.dependencyFactories.set(
-					ImportEagerDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportEagerDependency,
-					new ImportEagerDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					ImportWeakDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportWeakDependency,
-					new ImportWeakDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					ImportContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					ImportContextDependency,
-					new ImportContextDependency.Template()
-				);
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.import !== undefined && !parserOptions.import)
-						return;
-
-					new ImportParserPlugin(parserOptions).apply(parser);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ImportPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportPlugin", handler);
-			}
-		);
-	}
-}
-module.exports = ImportPlugin;
+module.exports = formatLocation;
 
 
 /***/ }),
 
-/***/ 82483:
+/***/ 27899:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -88025,71 +85829,46 @@ module.exports = ImportPlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ImportDependency = __webpack_require__(89376);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-
-class ImportWeakDependency extends ImportDependency {
-	/**
-	 * @param {string} request the request
-	 * @param {[number, number]} range expression range
-	 * @param {string[][]=} referencedExports list of referenced exports
-	 */
-	constructor(request, range, referencedExports) {
-		super(request, range, referencedExports);
-		this.weak = true;
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-	get type() {
-		return "import() weak";
+class HotModuleReplacementRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
-}
-
-makeSerializable(
-	ImportWeakDependency,
-	"webpack/lib/dependencies/ImportWeakDependency"
-);
-
-ImportWeakDependency.Template = class ImportDependencyTemplate extends (
-	ImportDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ImportWeakDependency} */ (dependency);
-		const content = runtimeTemplate.moduleNamespacePromise({
-			chunkGraph,
-			module: moduleGraph.getModule(dep),
-			request: dep.request,
-			strict: module.buildMeta.strictHarmonyModule,
-			message: "import() weak",
-			weak: true,
-			runtimeRequirements
-		});
-
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+	generate() {
+		return Template.getFunctionContent(
+			require('./HotModuleReplacement.runtime.js')
+		)
+			.replace(/\$getFullHash\$/g, RuntimeGlobals.getFullHash)
+			.replace(
+				/\$interceptModuleExecution\$/g,
+				RuntimeGlobals.interceptModuleExecution
+			)
+			.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+			.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+			.replace(/\$hmrDownloadManifest\$/g, RuntimeGlobals.hmrDownloadManifest)
+			.replace(
+				/\$hmrInvalidateModuleHandlers\$/g,
+				RuntimeGlobals.hmrInvalidateModuleHandlers
+			)
+			.replace(
+				/\$hmrDownloadUpdateHandlers\$/g,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			);
 	}
-};
+}
 
-module.exports = ImportWeakDependency;
+module.exports = HotModuleReplacementRuntimeModule;
 
 
 /***/ }),
 
-/***/ 750:
+/***/ 79040:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -88100,445 +85879,422 @@ module.exports = ImportWeakDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const { RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Dependency = __webpack_require__(54912);
+const Module = __webpack_require__(73208);
+const ModuleFactory = __webpack_require__(51010);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const CommonJsRequireDependency = __webpack_require__(21264);
+const { registerNotSerializable } = __webpack_require__(8282);
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
-const getExportsFromData = data => {
-	if (data && typeof data === "object") {
-		if (Array.isArray(data)) {
-			return data.map((item, idx) => {
-				return {
-					name: `${idx}`,
-					canMangle: true,
-					exports: getExportsFromData(item)
-				};
-			});
-		} else {
-			const exports = [];
-			for (const key of Object.keys(data)) {
-				exports.push({
-					name: key,
-					canMangle: true,
-					exports: getExportsFromData(data[key])
-				});
-			}
-			return exports;
-		}
+/**
+ * @typedef {Object} BackendApi
+ * @property {function(Error=): void} dispose
+ * @property {function(Module): { client: string, data: string, active: boolean }} module
+ */
+
+const HMR_DEPENDENCY_TYPES = new Set([
+	"import.meta.webpackHot.accept",
+	"import.meta.webpackHot.decline",
+	"module.hot.accept",
+	"module.hot.decline"
+]);
+
+/**
+ * @param {undefined|string|RegExp|Function} test test option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkTest = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module);
 	}
-	return undefined;
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name && name.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name && test.test(name);
+	}
+	return false;
 };
 
-class JsonExportsDependency extends NullDependency {
-	/**
-	 * @param {(string | ExportSpec)[]} exports json exports
-	 */
-	constructor(exports) {
+const TYPES = new Set(["javascript"]);
+
+class LazyCompilationDependency extends Dependency {
+	constructor(proxyModule) {
 		super();
-		this.exports = exports;
-		this._hashUpdate = undefined;
+		this.proxyModule = proxyModule;
+	}
+
+	get category() {
+		return "esm";
 	}
 
 	get type() {
-		return "json exports";
+		return "lazy import()";
 	}
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @returns {string | null} an identifier to merge equal requests
 	 */
-	getExports(moduleGraph) {
-		return {
-			exports: this.exports,
-			dependencies: undefined
-		};
+	getResourceIdentifier() {
+		return this.proxyModule.originalModule.identifier();
+	}
+}
+
+registerNotSerializable(LazyCompilationDependency);
+
+class LazyCompilationProxyModule extends Module {
+	constructor(context, originalModule, request, client, data, active) {
+		super("lazy-compilation-proxy", context, originalModule.layer);
+		this.originalModule = originalModule;
+		this.request = request;
+		this.client = client;
+		this.data = data;
+		this.active = active;
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @returns {string} a unique identifier of the module
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = this.exports
-				? JSON.stringify(this.exports)
-				: "undefined";
-		}
-		hash.update(this._hashUpdate);
+	identifier() {
+		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.exports);
-		super.serialize(context);
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
+			requestShortener
+		)}`;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.exports = read();
-		super.deserialize(context);
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {LazyCompilationProxyModule} */ (module);
+		this.originalModule = m.originalModule;
+		this.request = m.request;
+		this.client = m.client;
+		this.data = m.data;
+		this.active = m.active;
 	}
-}
-
-makeSerializable(
-	JsonExportsDependency,
-	"webpack/lib/dependencies/JsonExportsDependency"
-);
-
-module.exports = JsonExportsDependency;
-module.exports.getExportsFromData = getExportsFromData;
-
-
-/***/ }),
-
-/***/ 71693:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
 
-const ModuleDependency = __webpack_require__(80321);
-
-class LoaderDependency extends ModuleDependency {
 	/**
-	 * @param {string} request request string
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	constructor(request) {
-		super(request);
+	libIdent(options) {
+		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
 	}
 
-	get type() {
-		return "loader";
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo || this.buildInfo.active !== this.active);
 	}
 
-	get category() {
-		return "loader";
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildInfo = {
+			active: this.active
+		};
+		/** @type {BuildMeta} */
+		this.buildMeta = {};
+		this.clearDependenciesAndBlocks();
+		const dep = new CommonJsRequireDependency(this.client);
+		this.addDependency(dep);
+		if (this.active) {
+			const dep = new LazyCompilationDependency(this);
+			const block = new AsyncDependenciesBlock({});
+			block.addDependency(dep);
+			this.addBlock(block);
+		}
+		callback();
 	}
-}
-
-module.exports = LoaderDependency;
-
-
-/***/ }),
-
-/***/ 223:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
 
-
-const ModuleDependency = __webpack_require__(80321);
-
-class LoaderImportDependency extends ModuleDependency {
 	/**
-	 * @param {string} request request string
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	constructor(request) {
-		super(request);
-		this.weak = true;
+	size(type) {
+		return 200;
 	}
 
-	get type() {
-		return "loader import";
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
+		const sources = new Map();
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		const clientDep = /** @type {CommonJsRequireDependency} */ (
+			this.dependencies[0]
+		);
+		const clientModule = moduleGraph.getModule(clientDep);
+		const block = this.blocks[0];
+		const client = Template.asString([
+			`var client = ${runtimeTemplate.moduleExports({
+				module: clientModule,
+				chunkGraph,
+				request: clientDep.userRequest,
+				runtimeRequirements
+			})}`,
+			`var data = ${JSON.stringify(this.data)};`
+		]);
+		const keepActive = Template.asString([
+			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
+				!!block
+			)}, module: module, onError: onError });`
+		]);
+		let source;
+		if (block) {
+			const dep = block.dependencies[0];
+			const module = moduleGraph.getModule(dep);
+			source = Template.asString([
+				client,
+				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
+					chunkGraph,
+					block,
+					module,
+					request: this.request,
+					strict: false, // TODO this should be inherited from the original module
+					message: "import()",
+					runtimeRequirements
+				})};`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					`module.hot.accept(${JSON.stringify(
+						chunkGraph.getModuleId(module)
+					)}, function() { module.hot.invalidate(); });`,
+					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
+				]),
+				"}",
+				"function onError() { /* ignore */ }",
+				keepActive
+			]);
+		} else {
+			source = Template.asString([
+				client,
+				"var resolveSelf, onError;",
+				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
+					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
+				]),
+				"}",
+				keepActive
+			]);
+		}
+		sources.set("javascript", new RawSource(source));
+		return {
+			sources,
+			runtimeRequirements
+		};
 	}
 
-	get category() {
-		return "loaderImport";
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.active ? "active" : "");
+		hash.update(JSON.stringify(this.data));
 	}
 }
 
-module.exports = LoaderImportDependency;
-
-
-/***/ }),
-
-/***/ 24721:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+registerNotSerializable(LazyCompilationProxyModule);
 
+class LazyCompilationDependencyFactory extends ModuleFactory {
+	constructor(factory) {
+		super();
+		this._factory = factory;
+	}
 
-const NormalModule = __webpack_require__(39);
-const LazySet = __webpack_require__(38938);
-const LoaderDependency = __webpack_require__(71693);
-const LoaderImportDependency = __webpack_require__(223);
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dependency = /** @type {LazyCompilationDependency} */ (
+			data.dependencies[0]
+		);
+		callback(null, {
+			module: dependency.proxyModule.originalModule
+		});
+	}
+}
 
-/** @typedef {import("../Compilation").DepConstructor} DepConstructor */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-
-/**
- * @callback LoadModuleCallback
- * @param {(Error | null)=} err error object
- * @param {string | Buffer=} source source code
- * @param {object=} map source map
- * @param {Module=} module loaded module if successful
- */
-
-/**
- * @callback ImportModuleCallback
- * @param {(Error | null)=} err error object
- * @param {any=} exports exports of the evaluated module
- */
-
-/**
- * @typedef {Object} ImportModuleOptions
- * @property {string=} layer the target layer
- * @property {string=} publicPath the target public path
- */
-
-class LoaderPlugin {
+class LazyCompilationPlugin {
 	/**
 	 * @param {Object} options options
+	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
+	 * @param {boolean} options.entries true, when entries are lazy compiled
+	 * @param {boolean} options.imports true, when import() modules are lazy compiled
+	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
 	 */
-	constructor(options = {}) {}
-
+	constructor({ backend, entries, imports, test }) {
+		this.backend = backend;
+		this.entries = entries;
+		this.imports = imports;
+		this.test = test;
+	}
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"LoaderPlugin",
+		let backend;
+		compiler.hooks.beforeCompile.tapAsync(
+			"LazyCompilationPlugin",
+			(params, callback) => {
+				if (backend !== undefined) return callback();
+				const promise = this.backend(compiler, (err, result) => {
+					if (err) return callback(err);
+					backend = result;
+					callback();
+				});
+				if (promise && promise.then) {
+					promise.then(b => {
+						backend = b;
+						callback();
+					}, callback);
+				}
+			}
+		);
+		compiler.hooks.thisCompilation.tap(
+			"LazyCompilationPlugin",
 			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					LoaderDependency,
-					normalModuleFactory
+				normalModuleFactory.hooks.module.tap(
+					"LazyCompilationPlugin",
+					(originalModule, createData, resolveData) => {
+						if (
+							resolveData.dependencies.every(dep =>
+								HMR_DEPENDENCY_TYPES.has(dep.type)
+							)
+						) {
+							// for HMR only resolving, try to determine if the HMR accept/decline refers to
+							// an import() or not
+							const hmrDep = resolveData.dependencies[0];
+							const originModule =
+								compilation.moduleGraph.getParentModule(hmrDep);
+							const isReferringToDynamicImport = originModule.blocks.some(
+								block =>
+									block.dependencies.some(
+										dep =>
+											dep.type === "import()" &&
+											/** @type {HarmonyImportDependency} */ (dep).request ===
+												hmrDep.request
+									)
+							);
+							if (!isReferringToDynamicImport) return;
+						} else if (
+							!resolveData.dependencies.every(
+								dep =>
+									HMR_DEPENDENCY_TYPES.has(dep.type) ||
+									(this.imports &&
+										(dep.type === "import()" ||
+											dep.type === "import() context element")) ||
+									(this.entries && dep.type === "entry")
+							)
+						)
+							return;
+						if (
+							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
+								resolveData.request
+							) ||
+							!checkTest(this.test, originalModule)
+						)
+							return;
+						const moduleInfo = backend.module(originalModule);
+						if (!moduleInfo) return;
+						const { client, data, active } = moduleInfo;
+
+						return new LazyCompilationProxyModule(
+							compiler.context,
+							originalModule,
+							resolveData.request,
+							client,
+							data,
+							active
+						);
+					}
 				);
 				compilation.dependencyFactories.set(
-					LoaderImportDependency,
-					normalModuleFactory
+					LazyCompilationDependency,
+					new LazyCompilationDependencyFactory()
 				);
 			}
 		);
-
-		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderPlugin",
-				loaderContext => {
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
-					 * @returns {void}
-					 */
-					loaderContext.loadModule = (request, callback) => {
-						const dep = new LoaderDependency(request);
-						dep.loc = {
-							name: request
-						};
-						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
-						);
-						if (factory === undefined) {
-							return callback(
-								new Error(
-									`No module factory available for dependency type: ${dep.constructor.name}`
-								)
-							);
-						}
-						compilation.buildQueue.increaseParallelism();
-						compilation.handleModuleCreation(
-							{
-								factory,
-								dependencies: [dep],
-								originModule: loaderContext._module,
-								context: loaderContext.context,
-								recursive: false
-							},
-							err => {
-								compilation.buildQueue.decreaseParallelism();
-								if (err) {
-									return callback(err);
-								}
-								const referencedModule = moduleGraph.getModule(dep);
-								if (!referencedModule) {
-									return callback(new Error("Cannot load the module"));
-								}
-								if (referencedModule.getNumberOfErrors() > 0) {
-									return callback(
-										new Error("The loaded module contains errors")
-									);
-								}
-								const moduleSource = referencedModule.originalSource();
-								if (!moduleSource) {
-									return callback(
-										new Error(
-											"The module created for a LoaderDependency must have an original source"
-										)
-									);
-								}
-								let source, map;
-								if (moduleSource.sourceAndMap) {
-									const sourceAndMap = moduleSource.sourceAndMap();
-									map = sourceAndMap.map;
-									source = sourceAndMap.source;
-								} else {
-									map = moduleSource.map();
-									source = moduleSource.source();
-								}
-								const fileDependencies = new LazySet();
-								const contextDependencies = new LazySet();
-								const missingDependencies = new LazySet();
-								const buildDependencies = new LazySet();
-								referencedModule.addCacheDependencies(
-									fileDependencies,
-									contextDependencies,
-									missingDependencies,
-									buildDependencies
-								);
-
-								for (const d of fileDependencies) {
-									loaderContext.addDependency(d);
-								}
-								for (const d of contextDependencies) {
-									loaderContext.addContextDependency(d);
-								}
-								for (const d of missingDependencies) {
-									loaderContext.addMissingDependency(d);
-								}
-								for (const d of buildDependencies) {
-									loaderContext.addBuildDependency(d);
-								}
-								return callback(null, source, map, referencedModule);
-							}
-						);
-					};
-
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions=} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {void}
-					 */
-					const importModule = (request, options, callback) => {
-						const dep = new LoaderImportDependency(request);
-						dep.loc = {
-							name: request
-						};
-						const factory = compilation.dependencyFactories.get(
-							/** @type {DepConstructor} */ (dep.constructor)
-						);
-						if (factory === undefined) {
-							return callback(
-								new Error(
-									`No module factory available for dependency type: ${dep.constructor.name}`
-								)
-							);
-						}
-						compilation.buildQueue.increaseParallelism();
-						compilation.handleModuleCreation(
-							{
-								factory,
-								dependencies: [dep],
-								originModule: loaderContext._module,
-								contextInfo: {
-									issuerLayer: options.layer
-								},
-								context: loaderContext.context,
-								connectOrigin: false
-							},
-							err => {
-								compilation.buildQueue.decreaseParallelism();
-								if (err) {
-									return callback(err);
-								}
-								const referencedModule = moduleGraph.getModule(dep);
-								if (!referencedModule) {
-									return callback(new Error("Cannot load the module"));
-								}
-								compilation.executeModule(
-									referencedModule,
-									{
-										entryOptions: {
-											publicPath: options.publicPath
-										}
-									},
-									(err, result) => {
-										if (err) return callback(err);
-										for (const d of result.fileDependencies) {
-											loaderContext.addDependency(d);
-										}
-										for (const d of result.contextDependencies) {
-											loaderContext.addContextDependency(d);
-										}
-										for (const d of result.missingDependencies) {
-											loaderContext.addMissingDependency(d);
-										}
-										for (const d of result.buildDependencies) {
-											loaderContext.addBuildDependency(d);
-										}
-										if (result.cacheable === false)
-											loaderContext.cacheable(false);
-										for (const [name, { source, info }] of result.assets) {
-											const { buildInfo } = loaderContext._module;
-											if (!buildInfo.assets) {
-												buildInfo.assets = Object.create(null);
-												buildInfo.assetsInfo = new Map();
-											}
-											buildInfo.assets[name] = source;
-											buildInfo.assetsInfo.set(name, info);
-										}
-										callback(null, result.exports);
-									}
-								);
-							}
-						);
-					};
-
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {Promise<any> | void} exports
-					 */
-					loaderContext.importModule = (request, options, callback) => {
-						if (!callback) {
-							return new Promise((resolve, reject) => {
-								importModule(request, options || {}, (err, result) => {
-									if (err) reject(err);
-									else resolve(result);
-								});
-							});
-						}
-						return importModule(request, options || {}, callback);
-					};
-				}
-			);
+		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
+			backend.dispose(callback);
 		});
 	}
 }
-module.exports = LoaderPlugin;
+
+module.exports = LazyCompilationPlugin;
 
 
 /***/ }),
 
-/***/ 5826:
+/***/ 17781:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -88549,48 +86305,147 @@ module.exports = LoaderPlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-
-class LocalModule {
-	constructor(name, idx) {
-		this.name = name;
-		this.idx = idx;
-		this.used = false;
-	}
+/** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
-	flagUsed() {
-		this.used = true;
-	}
+/**
+ * @callback BackendHandler
+ * @param {Compiler} compiler compiler
+ * @param {function((Error | null)=, any=): void} callback callback
+ * @returns {void}
+ */
 
-	variableName() {
-		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
-	}
+/**
+ * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
+ * @returns {BackendHandler} backend
+ */
+module.exports = options => (compiler, callback) => {
+	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+	const activeModules = new Map();
+	const prefix = "/lazy-compilation-using-";
 
-	serialize(context) {
-		const { write } = context;
+	const isHttps =
+		options.protocol === "https" ||
+		(typeof options.server === "object" &&
+			("key" in options.server || "pfx" in options.server));
 
-		write(this.name);
-		write(this.idx);
-		write(this.used);
-	}
+	const createServer =
+		typeof options.server === "function"
+			? options.server
+			: (() => {
+					const http = isHttps ? __webpack_require__(95687) : __webpack_require__(13685);
+					return http.createServer.bind(http, options.server);
+			  })();
+	const listen =
+		typeof options.listen === "function"
+			? options.listen
+			: server => {
+					let listen = options.listen;
+					if (typeof listen === "object" && !("port" in listen))
+						listen = { ...listen, port: undefined };
+					server.listen(listen);
+			  };
 
-	deserialize(context) {
-		const { read } = context;
+	const protocol = options.protocol || (isHttps ? "https" : "http");
 
-		this.name = read();
-		this.idx = read();
-		this.used = read();
-	}
-}
+	const requestListener = (req, res) => {
+		const keys = req.url.slice(prefix.length).split("@");
+		req.socket.on("close", () => {
+			setTimeout(() => {
+				for (const key of keys) {
+					const oldValue = activeModules.get(key) || 0;
+					activeModules.set(key, oldValue - 1);
+					if (oldValue === 1) {
+						logger.log(
+							`${key} is no longer in use. Next compilation will skip this module.`
+						);
+					}
+				}
+			}, 120000);
+		});
+		req.socket.setNoDelay(true);
+		res.writeHead(200, {
+			"content-type": "text/event-stream",
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "*",
+			"Access-Control-Allow-Headers": "*"
+		});
+		res.write("\n");
+		let moduleActivated = false;
+		for (const key of keys) {
+			const oldValue = activeModules.get(key) || 0;
+			activeModules.set(key, oldValue + 1);
+			if (oldValue === 0) {
+				logger.log(`${key} is now in use and will be compiled.`);
+				moduleActivated = true;
+			}
+		}
+		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
+	};
 
-makeSerializable(LocalModule, "webpack/lib/dependencies/LocalModule");
+	const server = /** @type {import("net").Server} */ (createServer());
+	server.on("request", requestListener);
 
-module.exports = LocalModule;
+	let isClosing = false;
+	/** @type {Set<import("net").Socket>} */
+	const sockets = new Set();
+	server.on("connection", socket => {
+		sockets.add(socket);
+		socket.on("close", () => {
+			sockets.delete(socket);
+		});
+		if (isClosing) socket.destroy();
+	});
+	server.on("clientError", e => {
+		if (e.message !== "Server is disposing") logger.warn(e);
+	});
+	server.on("listening", err => {
+		if (err) return callback(err);
+		const addr = server.address();
+		if (typeof addr === "string") throw new Error("addr must not be a string");
+		const urlBase =
+			addr.address === "::" || addr.address === "0.0.0.0"
+				? `${protocol}://localhost:${addr.port}`
+				: addr.family === "IPv6"
+				? `${protocol}://[${addr.address}]:${addr.port}`
+				: `${protocol}://${addr.address}:${addr.port}`;
+		logger.log(
+			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+		);
+		callback(null, {
+			dispose(callback) {
+				isClosing = true;
+				// Removing the listener is a workaround for a memory leak in node.js
+				server.off("request", requestListener);
+				server.close(err => {
+					callback(err);
+				});
+				for (const socket of sockets) {
+					socket.destroy(new Error("Server is disposing"));
+				}
+			},
+			module(originalModule) {
+				const key = `${encodeURIComponent(
+					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
+				const active = activeModules.get(key) > 0;
+				return {
+					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+					data: key,
+					active
+				};
+			}
+		});
+	});
+	listen(server);
+};
 
 
 /***/ }),
 
-/***/ 52805:
+/***/ 64618:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -88601,268 +86456,263 @@ module.exports = LocalModule;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-
-class LocalModuleDependency extends NullDependency {
-	constructor(localModule, range, callNew) {
-		super();
-
-		this.localModule = localModule;
-		this.range = range;
-		this.callNew = callNew;
-	}
-
-	serialize(context) {
-		const { write } = context;
+const { find } = __webpack_require__(93347);
+const {
+	compareModulesByPreOrderIndexOrIdentifier,
+	compareModulesByPostOrderIndexOrIdentifier
+} = __webpack_require__(29579);
 
-		write(this.localModule);
-		write(this.range);
-		write(this.callNew);
+/** @typedef {import("../Compiler")} Compiler */
 
-		super.serialize(context);
+class ChunkModuleIdRangePlugin {
+	constructor(options) {
+		this.options = options;
 	}
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.localModule = read();
-		this.range = read();
-		this.callNew = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	LocalModuleDependency,
-	"webpack/lib/dependencies/LocalModuleDependency"
-);
-
-LocalModuleDependency.Template = class LocalModuleDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {LocalModuleDependency} */ (dependency);
-		if (!dep.range) return;
-		const moduleInstance = dep.callNew
-			? `new (function () { return ${dep.localModule.variableName()}; })()`
-			: dep.localModule.variableName();
-		source.replace(dep.range[0], dep.range[1] - 1, moduleInstance);
-	}
-};
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("ChunkModuleIdRangePlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			compilation.hooks.moduleIds.tap("ChunkModuleIdRangePlugin", modules => {
+				const chunkGraph = compilation.chunkGraph;
+				const chunk = find(
+					compilation.chunks,
+					chunk => chunk.name === options.name
+				);
+				if (!chunk) {
+					throw new Error(
+						`ChunkModuleIdRangePlugin: Chunk with name '${options.name}"' was not found`
+					);
+				}
 
-module.exports = LocalModuleDependency;
+				let chunkModules;
+				if (options.order) {
+					let cmpFn;
+					switch (options.order) {
+						case "index":
+						case "preOrderIndex":
+							cmpFn = compareModulesByPreOrderIndexOrIdentifier(moduleGraph);
+							break;
+						case "index2":
+						case "postOrderIndex":
+							cmpFn = compareModulesByPostOrderIndexOrIdentifier(moduleGraph);
+							break;
+						default:
+							throw new Error(
+								"ChunkModuleIdRangePlugin: unexpected value of order"
+							);
+					}
+					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
+				} else {
+					chunkModules = Array.from(modules)
+						.filter(m => {
+							return chunkGraph.isModuleInChunk(m, chunk);
+						})
+						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
+				}
+
+				let currentId = options.start || 0;
+				for (let i = 0; i < chunkModules.length; i++) {
+					const m = chunkModules[i];
+					if (m.needId && chunkGraph.getModuleId(m) === null) {
+						chunkGraph.setModuleId(m, currentId++);
+					}
+					if (options.end && currentId > options.end) break;
+				}
+			});
+		});
+	}
+}
+module.exports = ChunkModuleIdRangePlugin;
 
 
 /***/ }),
 
-/***/ 75827:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 8747:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const LocalModule = __webpack_require__(5826);
-
-const lookup = (parent, mod) => {
-	if (mod.charAt(0) !== ".") return mod;
+const { compareChunksNatural } = __webpack_require__(29579);
+const {
+	getFullChunkName,
+	getUsedChunkIds,
+	assignDeterministicIds
+} = __webpack_require__(63290);
 
-	var path = parent.split("/");
-	var segments = mod.split("/");
-	path.pop();
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-	for (let i = 0; i < segments.length; i++) {
-		const seg = segments[i];
-		if (seg === "..") {
-			path.pop();
-		} else if (seg !== ".") {
-			path.push(seg);
-		}
+class DeterministicChunkIdsPlugin {
+	constructor(options) {
+		this.options = options || {};
 	}
 
-	return path.join("/");
-};
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DeterministicChunkIdsPlugin",
+			compilation => {
+				compilation.hooks.chunkIds.tap(
+					"DeterministicChunkIdsPlugin",
+					chunks => {
+						const chunkGraph = compilation.chunkGraph;
+						const context = this.options.context
+							? this.options.context
+							: compiler.context;
+						const maxLength = this.options.maxLength || 3;
 
-exports.addLocalModule = (state, name) => {
-	if (!state.localModules) {
-		state.localModules = [];
-	}
-	const m = new LocalModule(name, state.localModules.length);
-	state.localModules.push(m);
-	return m;
-};
+						const compareNatural = compareChunksNatural(chunkGraph);
 
-exports.getLocalModule = (state, name, namedModule) => {
-	if (!state.localModules) return null;
-	if (namedModule) {
-		// resolve dependency name relative to the defining named module
-		name = lookup(namedModule, name);
-	}
-	for (let i = 0; i < state.localModules.length; i++) {
-		if (state.localModules[i].name === name) {
-			return state.localModules[i];
-		}
+						const usedIds = getUsedChunkIds(compilation);
+						assignDeterministicIds(
+							Array.from(chunks).filter(chunk => {
+								return chunk.id === null;
+							}),
+							chunk =>
+								getFullChunkName(chunk, chunkGraph, context, compiler.root),
+							compareNatural,
+							(chunk, id) => {
+								const size = usedIds.size;
+								usedIds.add(`${id}`);
+								if (size === usedIds.size) return false;
+								chunk.id = id;
+								chunk.ids = [id];
+								return true;
+							},
+							[Math.pow(10, maxLength)],
+							10,
+							usedIds.size
+						);
+					}
+				);
+			}
+		);
 	}
-	return null;
-};
+}
+
+module.exports = DeterministicChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 88488:
+/***/ 76692:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Florent Cailhol @ooflorent
 */
 
 
 
-const Dependency = __webpack_require__(54912);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class ModuleDecoratorDependency extends NullDependency {
-	/**
-	 * @param {string} decorator the decorator requirement
-	 * @param {boolean} allowExportsAccess allow to access exports from module
-	 */
-	constructor(decorator, allowExportsAccess) {
-		super();
-		this.decorator = decorator;
-		this.allowExportsAccess = allowExportsAccess;
-		this._hashUpdate = undefined;
-	}
-
-	/**
-	 * @returns {string} a display name for the type of dependency
-	 */
-	get type() {
-		return "module decorator";
-	}
-
-	get category() {
-		return "self";
-	}
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName,
+	assignDeterministicIds
+} = __webpack_require__(63290);
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `self`;
-	}
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
+class DeterministicModuleIdsPlugin {
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @param {Object} options options
+	 * @param {string=} options.context context relative to which module identifiers are computed
+	 * @param {function(Module): boolean=} options.test selector function for modules
+	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
+	 * @param {number=} options.salt hash salt for ids
+	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
+	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return this.allowExportsAccess
-			? Dependency.EXPORTS_OBJECT_REFERENCED
-			: Dependency.NO_EXPORTS_REFERENCED;
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
-		}
-		hash.update(this._hashUpdate);
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.decorator);
-		write(this.allowExportsAccess);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.decorator = read();
-		this.allowExportsAccess = read();
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	ModuleDecoratorDependency,
-	"webpack/lib/dependencies/ModuleDecoratorDependency"
-);
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DeterministicModuleIdsPlugin",
+			compilation => {
+				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
+					const chunkGraph = compilation.chunkGraph;
+					const context = this.options.context
+						? this.options.context
+						: compiler.context;
+					const maxLength = this.options.maxLength || 3;
+					const failOnConflict = this.options.failOnConflict || false;
+					const fixedLength = this.options.fixedLength || false;
+					const salt = this.options.salt || 0;
+					let conflicts = 0;
 
-ModuleDecoratorDependency.Template = class ModuleDecoratorDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ module, chunkGraph, initFragments, runtimeRequirements }
-	) {
-		const dep = /** @type {ModuleDecoratorDependency} */ (dependency);
-		runtimeRequirements.add(RuntimeGlobals.moduleLoaded);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(dep.decorator);
-		initFragments.push(
-			new InitFragment(
-				`/* module decorator */ ${module.moduleArgument} = ${dep.decorator}(${module.moduleArgument});\n`,
-				InitFragment.STAGE_PROVIDES,
-				0,
-				`module decorator ${chunkGraph.getModuleId(module)}`
-			)
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this.options.test
+					);
+					assignDeterministicIds(
+						modules,
+						module => getFullModuleName(module, context, compiler.root),
+						failOnConflict
+							? () => 0
+							: compareModulesByPreOrderIndexOrIdentifier(
+									compilation.moduleGraph
+							  ),
+						(module, id) => {
+							const size = usedIds.size;
+							usedIds.add(`${id}`);
+							if (size === usedIds.size) {
+								conflicts++;
+								return false;
+							}
+							chunkGraph.setModuleId(module, id);
+							return true;
+						},
+						[Math.pow(10, maxLength)],
+						fixedLength ? 0 : 10,
+						usedIds.size,
+						salt
+					);
+					if (failOnConflict && conflicts)
+						throw new Error(
+							`Assigning deterministic module ids has lead to ${conflicts} conflict${
+								conflicts > 1 ? "s" : ""
+							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
+						);
+				});
+			}
 		);
 	}
-};
+}
 
-module.exports = ModuleDecoratorDependency;
+module.exports = DeterministicModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 80321:
+/***/ 21825:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -88873,86 +86723,82 @@ module.exports = ModuleDecoratorDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const DependencyTemplate = __webpack_require__(5160);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../Module")} Module */
-
-const getRawModule = memoize(() => __webpack_require__(84929));
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName
+} = __webpack_require__(63290);
 
-class ModuleDependency extends Dependency {
-	/**
-	 * @param {string} request request path which needs resolving
-	 */
-	constructor(request) {
-		super();
-		this.request = request;
-		this.userRequest = request;
-		this.range = undefined;
-		// assertions must be serialized by subclasses that use it
-		/** @type {Record<string, any> | undefined} */
-		this.assertions = undefined;
-	}
+/** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		let str = `module${this.request}`;
-		if (this.assertions !== undefined) {
-			str += JSON.stringify(this.assertions);
-		}
-		return str;
+const validate = createSchemaValidation(
+	__webpack_require__(52210),
+	() => __webpack_require__(59106),
+	{
+		name: "Hashed Module Ids Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class HashedModuleIdsPlugin {
 	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 * @param {HashedModuleIdsPluginOptions=} options options object
 	 */
-	couldAffectReferencingModule() {
-		return true;
-	}
+	constructor(options = {}) {
+		validate(options);
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
-	 */
-	createIgnoredModule(context) {
-		const RawModule = getRawModule();
-		return new RawModule(
-			"/* (ignored) */",
-			`ignored|${context}|${this.request}`,
-			`${this.request} (ignored)`
-		);
+		/** @type {HashedModuleIdsPluginOptions} */
+		this.options = {
+			context: null,
+			hashFunction: "md4",
+			hashDigest: "base64",
+			hashDigestLength: 4,
+			...options
+		};
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.request);
-		write(this.userRequest);
-		write(this.range);
-		super.serialize(context);
-	}
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
+			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
 
-	deserialize(context) {
-		const { read } = context;
-		this.request = read();
-		this.userRequest = read();
-		this.range = read();
-		super.deserialize(context);
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const modulesInNaturalOrder = modules.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				for (const module of modulesInNaturalOrder) {
+					const ident = getFullModuleName(module, context, compiler.root);
+					const hash = createHash(options.hashFunction);
+					hash.update(ident || "");
+					const hashId = /** @type {string} */ (
+						hash.digest(options.hashDigest)
+					);
+					let len = options.hashDigestLength;
+					while (usedIds.has(hashId.substr(0, len))) len++;
+					const moduleId = hashId.substr(0, len);
+					chunkGraph.setModuleId(module, moduleId);
+					usedIds.add(moduleId);
+				}
+			});
+		});
 	}
 }
 
-ModuleDependency.Template = DependencyTemplate;
-
-module.exports = ModuleDependency;
+module.exports = HashedModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 80825:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 63290:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -88962,127 +86808,481 @@ module.exports = ModuleDependency;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
+const createHash = __webpack_require__(49835);
+const { makePathsRelative } = __webpack_require__(82186);
+const numberHash = __webpack_require__(70002);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {typeof import("../util/Hash")} Hash */
 
-class ModuleDependencyTemplateAsId extends ModuleDependency.Template {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeTemplate, moduleGraph, chunkGraph }) {
-		const dep = /** @type {ModuleDependency} */ (dependency);
-		if (!dep.range) return;
-		const content = runtimeTemplate.moduleId({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak
-		});
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+/**
+ * @param {string} str string to hash
+ * @param {number} len max length of the hash
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const getHash = (str, len, hashFunction) => {
+	const hash = createHash(hashFunction);
+	hash.update(str);
+	const digest = /** @type {string} */ (hash.digest("hex"));
+	return digest.substr(0, len);
+};
+
+/**
+ * @param {string} str the string
+ * @returns {string} string prefixed by an underscore if it is a number
+ */
+const avoidNumber = str => {
+	// max length of a number is 21 chars, bigger numbers a written as "...e+xx"
+	if (str.length > 21) return str;
+	const firstChar = str.charCodeAt(0);
+	// skip everything that doesn't look like a number
+	// charCodes: "-": 45, "1": 49, "9": 57
+	if (firstChar < 49) {
+		if (firstChar !== 45) return str;
+	} else if (firstChar > 57) {
+		return str;
 	}
-}
+	if (str === +str + "") {
+		return `_${str}`;
+	}
+	return str;
+};
 
-module.exports = ModuleDependencyTemplateAsId;
+/**
+ * @param {string} request the request
+ * @returns {string} id representation
+ */
+const requestToId = request => {
+	return request
+		.replace(/^(\.\.?\/)+/, "")
+		.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+};
+exports.requestToId = requestToId;
 
+/**
+ * @param {string} string the string
+ * @param {string} delimiter separator for string and hash
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} string with limited max length to 100 chars
+ */
+const shortenLongString = (string, delimiter, hashFunction) => {
+	if (string.length < 100) return string;
+	return (
+		string.slice(0, 100 - 6 - delimiter.length) +
+		delimiter +
+		getHash(string, 6, hashFunction)
+	);
+};
 
-/***/ }),
+/**
+ * @param {Module} module the module
+ * @param {string} context context directory
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} short module name
+ */
+const getShortModuleName = (module, context, associatedObjectForCache) => {
+	const libIdent = module.libIdent({ context, associatedObjectForCache });
+	if (libIdent) return avoidNumber(libIdent);
+	const nameForCondition = module.nameForCondition();
+	if (nameForCondition)
+		return avoidNumber(
+			makePathsRelative(context, nameForCondition, associatedObjectForCache)
+		);
+	return "";
+};
+exports.getShortModuleName = getShortModuleName;
 
-/***/ 36873:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {string} shortName the short name
+ * @param {Module} module the module
+ * @param {string} context context directory
+ * @param {string | Hash} hashFunction hash function to use
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} long module name
+ */
+const getLongModuleName = (
+	shortName,
+	module,
+	context,
+	hashFunction,
+	associatedObjectForCache
+) => {
+	const fullName = getFullModuleName(module, context, associatedObjectForCache);
+	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
+};
+exports.getLongModuleName = getLongModuleName;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @param {Module} module the module
+ * @param {string} context context directory
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} full module name
+ */
+const getFullModuleName = (module, context, associatedObjectForCache) => {
+	return makePathsRelative(
+		context,
+		module.identifier(),
+		associatedObjectForCache
+	);
+};
+exports.getFullModuleName = getFullModuleName;
 
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {string} context context directory
+ * @param {string} delimiter delimiter for names
+ * @param {string | Hash} hashFunction hash function to use
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} short chunk name
+ */
+const getShortChunkName = (
+	chunk,
+	chunkGraph,
+	context,
+	delimiter,
+	hashFunction,
+	associatedObjectForCache
+) => {
+	const modules = chunkGraph.getChunkRootModules(chunk);
+	const shortModuleNames = modules.map(m =>
+		requestToId(getShortModuleName(m, context, associatedObjectForCache))
+	);
+	chunk.idNameHints.sort();
+	const chunkName = Array.from(chunk.idNameHints)
+		.concat(shortModuleNames)
+		.filter(Boolean)
+		.join(delimiter);
+	return shortenLongString(chunkName, delimiter, hashFunction);
+};
+exports.getShortChunkName = getShortChunkName;
 
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {string} context context directory
+ * @param {string} delimiter delimiter for names
+ * @param {string | Hash} hashFunction hash function to use
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} short chunk name
+ */
+const getLongChunkName = (
+	chunk,
+	chunkGraph,
+	context,
+	delimiter,
+	hashFunction,
+	associatedObjectForCache
+) => {
+	const modules = chunkGraph.getChunkRootModules(chunk);
+	const shortModuleNames = modules.map(m =>
+		requestToId(getShortModuleName(m, context, associatedObjectForCache))
+	);
+	const longModuleNames = modules.map(m =>
+		requestToId(
+			getLongModuleName("", m, context, hashFunction, associatedObjectForCache)
+		)
+	);
+	chunk.idNameHints.sort();
+	const chunkName = Array.from(chunk.idNameHints)
+		.concat(shortModuleNames, longModuleNames)
+		.filter(Boolean)
+		.join(delimiter);
+	return shortenLongString(chunkName, delimiter, hashFunction);
+};
+exports.getLongChunkName = getLongChunkName;
 
-const ModuleDependency = __webpack_require__(80321);
+/**
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {string} context context directory
+ * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @returns {string} full chunk name
+ */
+const getFullChunkName = (
+	chunk,
+	chunkGraph,
+	context,
+	associatedObjectForCache
+) => {
+	if (chunk.name) return chunk.name;
+	const modules = chunkGraph.getChunkRootModules(chunk);
+	const fullModuleNames = modules.map(m =>
+		makePathsRelative(context, m.identifier(), associatedObjectForCache)
+	);
+	return fullModuleNames.join();
+};
+exports.getFullChunkName = getFullChunkName;
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/**
+ * @template K
+ * @template V
+ * @param {Map<K, V[]>} map a map from key to values
+ * @param {K} key key
+ * @param {V} value value
+ * @returns {void}
+ */
+const addToMapOfItems = (map, key, value) => {
+	let array = map.get(key);
+	if (array === undefined) {
+		array = [];
+		map.set(key, array);
+	}
+	array.push(value);
+};
 
-class ModuleDependencyTemplateAsRequireId extends ModuleDependency.Template {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {ModuleDependency} */ (dependency);
-		if (!dep.range) return;
-		const content = runtimeTemplate.moduleExports({
-			module: moduleGraph.getModule(dep),
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-		source.replace(dep.range[0], dep.range[1] - 1, content);
+/**
+ * @param {Compilation} compilation the compilation
+ * @param {function(Module): boolean=} filter filter modules
+ * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
+ */
+const getUsedModuleIdsAndModules = (compilation, filter) => {
+	const chunkGraph = compilation.chunkGraph;
+
+	const modules = [];
+
+	/** @type {Set<string>} */
+	const usedIds = new Set();
+	if (compilation.usedModuleIds) {
+		for (const id of compilation.usedModuleIds) {
+			usedIds.add(id + "");
+		}
 	}
-}
-module.exports = ModuleDependencyTemplateAsRequireId;
 
+	for (const module of compilation.modules) {
+		if (!module.needId) continue;
+		const moduleId = chunkGraph.getModuleId(module);
+		if (moduleId !== null) {
+			usedIds.add(moduleId + "");
+		} else {
+			if (
+				(!filter || filter(module)) &&
+				chunkGraph.getNumberOfModuleChunks(module) !== 0
+			) {
+				modules.push(module);
+			}
+		}
+	}
 
-/***/ }),
+	return [usedIds, modules];
+};
+exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
 
-/***/ 47511:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {Compilation} compilation the compilation
+ * @returns {Set<string>} used chunk ids as strings
+ */
+const getUsedChunkIds = compilation => {
+	/** @type {Set<string>} */
+	const usedIds = new Set();
+	if (compilation.usedChunkIds) {
+		for (const id of compilation.usedChunkIds) {
+			usedIds.add(id + "");
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	for (const chunk of compilation.chunks) {
+		const chunkId = chunk.id;
+		if (chunkId !== null) {
+			usedIds.add(chunkId + "");
+		}
+	}
+
+	return usedIds;
+};
+exports.getUsedChunkIds = getUsedChunkIds;
 
+/**
+ * @template T
+ * @param {Iterable<T>} items list of items to be named
+ * @param {function(T): string} getShortName get a short name for an item
+ * @param {function(T, string): string} getLongName get a long name for an item
+ * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {Set<string>} usedIds already used ids, will not be assigned
+ * @param {function(T, string): void} assignName assign a name to an item
+ * @returns {T[]} list of items without a name
+ */
+const assignNames = (
+	items,
+	getShortName,
+	getLongName,
+	comparator,
+	usedIds,
+	assignName
+) => {
+	/** @type {Map<string, T[]>} */
+	const nameToItems = new Map();
 
+	for (const item of items) {
+		const name = getShortName(item);
+		addToMapOfItems(nameToItems, name, item);
+	}
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+	/** @type {Map<string, T[]>} */
+	const nameToItems2 = new Map();
 
-class ModuleHotAcceptDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
-		this.range = range;
-		this.weak = true;
+	for (const [name, items] of nameToItems) {
+		if (items.length > 1 || !name) {
+			for (const item of items) {
+				const longName = getLongName(item, name);
+				addToMapOfItems(nameToItems2, longName, item);
+			}
+		} else {
+			addToMapOfItems(nameToItems2, name, items[0]);
+		}
 	}
 
-	get type() {
-		return "module.hot.accept";
+	/** @type {T[]} */
+	const unnamedItems = [];
+
+	for (const [name, items] of nameToItems2) {
+		if (!name) {
+			for (const item of items) {
+				unnamedItems.push(item);
+			}
+		} else if (items.length === 1 && !usedIds.has(name)) {
+			assignName(items[0], name);
+			usedIds.add(name);
+		} else {
+			items.sort(comparator);
+			let i = 0;
+			for (const item of items) {
+				while (nameToItems2.has(name + i) && usedIds.has(name + i)) i++;
+				assignName(item, name + i);
+				usedIds.add(name + i);
+				i++;
+			}
+		}
 	}
 
-	get category() {
-		return "commonjs";
+	unnamedItems.sort(comparator);
+	return unnamedItems;
+};
+exports.assignNames = assignNames;
+
+/**
+ * @template T
+ * @param {T[]} items list of items to be named
+ * @param {function(T): string} getName get a name for an item
+ * @param {function(T, T): -1|0|1} comparator order of items
+ * @param {function(T, number): boolean} assignId assign an id to an item
+ * @param {number[]} ranges usable ranges for ids
+ * @param {number} expandFactor factor to create more ranges
+ * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
+ * @param {number} salt salting number to initialize hashing
+ * @returns {void}
+ */
+const assignDeterministicIds = (
+	items,
+	getName,
+	comparator,
+	assignId,
+	ranges = [10],
+	expandFactor = 10,
+	extraSpace = 0,
+	salt = 0
+) => {
+	items.sort(comparator);
+
+	// max 5% fill rate
+	const optimalRange = Math.min(
+		Math.ceil(items.length * 20) + extraSpace,
+		Number.MAX_SAFE_INTEGER
+	);
+
+	let i = 0;
+	let range = ranges[i];
+	while (range < optimalRange) {
+		i++;
+		if (i < ranges.length) {
+			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
+		} else if (expandFactor) {
+			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+		} else {
+			break;
+		}
 	}
-}
 
-makeSerializable(
-	ModuleHotAcceptDependency,
-	"webpack/lib/dependencies/ModuleHotAcceptDependency"
-);
+	for (const item of items) {
+		const ident = getName(item);
+		let id;
+		let i = salt;
+		do {
+			id = numberHash(ident + i++, range);
+		} while (!assignId(item, id));
+	}
+};
+exports.assignDeterministicIds = assignDeterministicIds;
 
-ModuleHotAcceptDependency.Template = ModuleDependencyTemplateAsId;
+/**
+ * @param {Set<string>} usedIds used ids
+ * @param {Iterable<Module>} modules the modules
+ * @param {Compilation} compilation the compilation
+ * @returns {void}
+ */
+const assignAscendingModuleIds = (usedIds, modules, compilation) => {
+	const chunkGraph = compilation.chunkGraph;
 
-module.exports = ModuleHotAcceptDependency;
+	let nextId = 0;
+	let assignId;
+	if (usedIds.size > 0) {
+		assignId = module => {
+			if (chunkGraph.getModuleId(module) === null) {
+				while (usedIds.has(nextId + "")) nextId++;
+				chunkGraph.setModuleId(module, nextId++);
+			}
+		};
+	} else {
+		assignId = module => {
+			if (chunkGraph.getModuleId(module) === null) {
+				chunkGraph.setModuleId(module, nextId++);
+			}
+		};
+	}
+	for (const module of modules) {
+		assignId(module);
+	}
+};
+exports.assignAscendingModuleIds = assignAscendingModuleIds;
+
+/**
+ * @param {Iterable<Chunk>} chunks the chunks
+ * @param {Compilation} compilation the compilation
+ * @returns {void}
+ */
+const assignAscendingChunkIds = (chunks, compilation) => {
+	const usedIds = getUsedChunkIds(compilation);
+
+	let nextId = 0;
+	if (usedIds.size > 0) {
+		for (const chunk of chunks) {
+			if (chunk.id === null) {
+				while (usedIds.has(nextId + "")) nextId++;
+				chunk.id = nextId;
+				chunk.ids = [nextId];
+				nextId++;
+			}
+		}
+	} else {
+		for (const chunk of chunks) {
+			if (chunk.id === null) {
+				chunk.id = nextId;
+				chunk.ids = [nextId];
+				nextId++;
+			}
+		}
+	}
+};
+exports.assignAscendingChunkIds = assignAscendingChunkIds;
 
 
 /***/ }),
 
-/***/ 86301:
+/***/ 6454:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89093,40 +87293,85 @@ module.exports = ModuleHotAcceptDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyTemplateAsId = __webpack_require__(80825);
+const { compareChunksNatural } = __webpack_require__(29579);
+const {
+	getShortChunkName,
+	getLongChunkName,
+	assignNames,
+	getUsedChunkIds,
+	assignAscendingChunkIds
+} = __webpack_require__(63290);
 
-class ModuleHotDeclineDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-		this.range = range;
-		this.weak = true;
+class NamedChunkIdsPlugin {
+	constructor(options) {
+		this.delimiter = (options && options.delimiter) || "-";
+		this.context = options && options.context;
 	}
 
-	get type() {
-		return "module.hot.decline";
-	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
+			const { hashFunction } = compilation.outputOptions;
+			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.context ? this.context : compiler.context;
+				const delimiter = this.delimiter;
 
-	get category() {
-		return "commonjs";
+				const unnamedChunks = assignNames(
+					Array.from(chunks).filter(chunk => {
+						if (chunk.name) {
+							chunk.id = chunk.name;
+							chunk.ids = [chunk.name];
+						}
+						return chunk.id === null;
+					}),
+					chunk =>
+						getShortChunkName(
+							chunk,
+							chunkGraph,
+							context,
+							delimiter,
+							hashFunction,
+							compiler.root
+						),
+					chunk =>
+						getLongChunkName(
+							chunk,
+							chunkGraph,
+							context,
+							delimiter,
+							hashFunction,
+							compiler.root
+						),
+					compareChunksNatural(chunkGraph),
+					getUsedChunkIds(compilation),
+					(chunk, name) => {
+						chunk.id = name;
+						chunk.ids = [name];
+					}
+				);
+				if (unnamedChunks.length > 0) {
+					assignAscendingChunkIds(unnamedChunks, compilation);
+				}
+			});
+		});
 	}
 }
 
-makeSerializable(
-	ModuleHotDeclineDependency,
-	"webpack/lib/dependencies/ModuleHotDeclineDependency"
-);
-
-ModuleHotDeclineDependency.Template = ModuleDependencyTemplateAsId;
-
-module.exports = ModuleHotDeclineDependency;
+module.exports = NamedChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 31830:
+/***/ 24339:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89137,44 +87382,62 @@ module.exports = ModuleHotDeclineDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const DependencyTemplate = __webpack_require__(5160);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const {
+	getShortModuleName,
+	getLongModuleName,
+	assignNames,
+	getUsedModuleIdsAndModules,
+	assignAscendingModuleIds
+} = __webpack_require__(63290);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-class NullDependency extends Dependency {
-	get type() {
-		return "null";
+class NamedModuleIdsPlugin {
+	constructor(options) {
+		this.options = options || {};
 	}
 
 	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	couldAffectReferencingModule() {
-		return false;
+	apply(compiler) {
+		const { root } = compiler;
+		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
+			const { hashFunction } = compilation.outputOptions;
+			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
+				const chunkGraph = compilation.chunkGraph;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
+
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const unnamedModules = assignNames(
+					modules,
+					m => getShortModuleName(m, context, root),
+					(m, shortName) =>
+						getLongModuleName(shortName, m, context, hashFunction, root),
+					compareModulesByIdentifier,
+					usedIds,
+					(m, name) => chunkGraph.setModuleId(m, name)
+				);
+				if (unnamedModules.length > 0) {
+					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
+				}
+			});
+		});
 	}
 }
 
-NullDependency.Template = class NullDependencyTemplate extends (
-	DependencyTemplate
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {}
-};
-
-module.exports = NullDependency;
+module.exports = NamedModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 31618:
+/***/ 86221:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89185,28 +87448,37 @@ module.exports = NullDependency;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
-
-class PrefetchDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
+const { compareChunksNatural } = __webpack_require__(29579);
+const { assignAscendingChunkIds } = __webpack_require__(63290);
 
-	get type() {
-		return "prefetch";
-	}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-	get category() {
-		return "esm";
+class NaturalChunkIdsPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NaturalChunkIdsPlugin", compilation => {
+			compilation.hooks.chunkIds.tap("NaturalChunkIdsPlugin", chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				const compareNatural = compareChunksNatural(chunkGraph);
+				const chunksInNaturalOrder = Array.from(chunks).sort(compareNatural);
+				assignAscendingChunkIds(chunksInNaturalOrder, compilation);
+			});
+		});
 	}
 }
 
-module.exports = PrefetchDependency;
+module.exports = NaturalChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 95770:
+/***/ 83366:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89217,126 +87489,43 @@ module.exports = PrefetchDependency;
 
 
 
-const InitFragment = __webpack_require__(55870);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
-
-/**
- * @param {string[]|null} path the property path array
- * @returns {string} the converted path
- */
-const pathToString = path =>
-	path !== null && path.length > 0
-		? path.map(part => `[${JSON.stringify(part)}]`).join("")
-		: "";
-
-class ProvidedDependency extends ModuleDependency {
-	constructor(request, identifier, path, range) {
-		super(request);
-		this.identifier = identifier;
-		this.path = path;
-		this.range = range;
-		this._hashUpdate = undefined;
-	}
-
-	get type() {
-		return "provided";
-	}
-
-	get category() {
-		return "esm";
-	}
-
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate =
-				this.identifier + (this.path ? this.path.join(",") : "null");
-		}
-		hash.update(this._hashUpdate);
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.identifier);
-		write(this.path);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.identifier = read();
-		this.path = read();
-		super.deserialize(context);
-	}
-}
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = __webpack_require__(63290);
 
-makeSerializable(
-	ProvidedDependency,
-	"webpack/lib/dependencies/ProvidedDependency"
-);
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-class ProvidedDependencyTemplate extends ModuleDependency.Template {
+class NaturalModuleIdsPlugin {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph,
-			initFragments,
-			runtimeRequirements
-		}
-	) {
-		const dep = /** @type {ProvidedDependency} */ (dependency);
-		initFragments.push(
-			new InitFragment(
-				`/* provided dependency */ var ${
-					dep.identifier
-				} = ${runtimeTemplate.moduleExports({
-					module: moduleGraph.getModule(dep),
-					chunkGraph,
-					request: dep.request,
-					runtimeRequirements
-				})}${pathToString(dep.path)};\n`,
-				InitFragment.STAGE_PROVIDES,
-				1,
-				`provided ${dep.identifier}`
-			)
-		);
-		source.replace(dep.range[0], dep.range[1] - 1, dep.identifier);
+	apply(compiler) {
+		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
+			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
+				const [usedIds, modulesInNaturalOrder] =
+					getUsedModuleIdsAndModules(compilation);
+				modulesInNaturalOrder.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
+			});
+		});
 	}
 }
 
-ProvidedDependency.Template = ProvidedDependencyTemplate;
-
-module.exports = ProvidedDependency;
+module.exports = NaturalModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 55799:
+/***/ 51020:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89347,132 +87536,84 @@ module.exports = ProvidedDependency;
 
 
 
-const { UsageState } = __webpack_require__(63686);
-const makeSerializable = __webpack_require__(33032);
-const { filterRuntime } = __webpack_require__(17156);
-const NullDependency = __webpack_require__(31830);
+const { compareChunksNatural } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const { assignAscendingChunkIds } = __webpack_require__(63290);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../../declarations/plugins/ids/OccurrenceChunkIdsPlugin").OccurrenceChunkIdsPluginOptions} OccurrenceChunkIdsPluginOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-class PureExpressionDependency extends NullDependency {
-	/**
-	 * @param {[number, number]} range the source range
-	 */
-	constructor(range) {
-		super();
-		this.range = range;
-		/** @type {Set<string> | false} */
-		this.usedByExports = false;
-		this._hashUpdate = undefined;
+const validate = createSchemaValidation(
+	__webpack_require__(24344),
+	() => __webpack_require__(53576),
+	{
+		name: "Occurrence Order Chunk Ids Plugin",
+		baseDataPath: "options"
 	}
+);
 
+class OccurrenceChunkIdsPlugin {
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @param {OccurrenceChunkIdsPluginOptions=} options options object
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = this.range + "";
-		}
-		hash.update(this._hashUpdate);
+	constructor(options = {}) {
+		validate(options);
+		this.options = options;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this dependency connects the module to referencing modules
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	getModuleEvaluationSideEffectsState(moduleGraph) {
-		return false;
-	}
-
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.usedByExports);
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.usedByExports = read();
-		super.deserialize(context);
-	}
-}
+	apply(compiler) {
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap("OccurrenceChunkIdsPlugin", compilation => {
+			compilation.hooks.chunkIds.tap("OccurrenceChunkIdsPlugin", chunks => {
+				const chunkGraph = compilation.chunkGraph;
 
-makeSerializable(
-	PureExpressionDependency,
-	"webpack/lib/dependencies/PureExpressionDependency"
-);
+				/** @type {Map<Chunk, number>} */
+				const occursInInitialChunksMap = new Map();
 
-PureExpressionDependency.Template = class PureExpressionDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ chunkGraph, moduleGraph, runtime, runtimeTemplate, runtimeRequirements }
-	) {
-		const dep = /** @type {PureExpressionDependency} */ (dependency);
+				const compareNatural = compareChunksNatural(chunkGraph);
 
-		const usedByExports = dep.usedByExports;
-		if (usedByExports !== false) {
-			const selfModule = moduleGraph.getParentModule(dep);
-			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			const runtimeCondition = filterRuntime(runtime, runtime => {
-				for (const exportName of usedByExports) {
-					if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused) {
-						return true;
+				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);
 				}
-				return false;
-			});
-			if (runtimeCondition === true) return;
-			if (runtimeCondition !== false) {
-				const condition = runtimeTemplate.runtimeConditionExpression({
-					chunkGraph,
-					runtime,
-					runtimeCondition,
-					runtimeRequirements
-				});
-				source.insert(
-					dep.range[0],
-					`(/* runtime-dependent pure expression or super */ ${condition} ? (`
-				);
-				source.insert(dep.range[1], ") : null)");
-				return;
-			}
-		}
 
-		source.insert(
-			dep.range[0],
-			`(/* unused pure expression or super */ null && (`
-		);
-		source.insert(dep.range[1], "))");
+				const chunksInOccurrenceOrder = Array.from(chunks).sort((a, b) => {
+					if (prioritiseInitial) {
+						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;
+					return compareNatural(a, b);
+				});
+				assignAscendingChunkIds(chunksInOccurrenceOrder, compilation);
+			});
+		});
 	}
-};
+}
 
-module.exports = PureExpressionDependency;
+module.exports = OccurrenceChunkIdsPlugin;
 
 
 /***/ }),
 
-/***/ 46917:
+/***/ 35371:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89483,117 +87624,163 @@ module.exports = PureExpressionDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-const ModuleDependencyTemplateAsRequireId = __webpack_require__(36873);
+const {
+	compareModulesByPreOrderIndexOrIdentifier
+} = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = __webpack_require__(63290);
 
-class RequireContextDependency extends ContextDependency {
-	constructor(options, range) {
-		super(options);
+/** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 
-		this.range = range;
+const validate = createSchemaValidation(
+	__webpack_require__(14916),
+	() => __webpack_require__(19330),
+	{
+		name: "Occurrence Order Module Ids Plugin",
+		baseDataPath: "options"
 	}
+);
 
-	get type() {
-		return "require.context";
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.range = read();
-
-		super.deserialize(context);
+class OccurrenceModuleIdsPlugin {
+	/**
+	 * @param {OccurrenceModuleIdsPluginOptions=} options options object
+	 */
+	constructor(options = {}) {
+		validate(options);
+		this.options = options;
 	}
-}
 
-makeSerializable(
-	RequireContextDependency,
-	"webpack/lib/dependencies/RequireContextDependency"
-);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const prioritiseInitial = this.options.prioritiseInitial;
+		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
 
-RequireContextDependency.Template = ModuleDependencyTemplateAsRequireId;
+			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
+				const chunkGraph = compilation.chunkGraph;
 
-module.exports = RequireContextDependency;
+				const [usedIds, modulesInOccurrenceOrder] =
+					getUsedModuleIdsAndModules(compilation);
 
+				const occursInInitialChunksMap = new Map();
+				const occursInAllChunksMap = new Map();
 
-/***/ }),
+				const initialChunkChunkMap = new Map();
+				const entryCountMap = new Map();
+				for (const m of modulesInOccurrenceOrder) {
+					let initial = 0;
+					let entry = 0;
+					for (const c of chunkGraph.getModuleChunksIterable(m)) {
+						if (c.canBeInitial()) initial++;
+						if (chunkGraph.isEntryModuleInChunk(m, c)) entry++;
+					}
+					initialChunkChunkMap.set(m, initial);
+					entryCountMap.set(m, entry);
+				}
 
-/***/ 18851:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				/**
+				 * @param {Module} module module
+				 * @returns {number} count of occurs
+				 */
+				const countOccursInEntry = module => {
+					let sum = 0;
+					for (const [
+						originModule,
+						connections
+					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+						if (!originModule) continue;
+						if (!connections.some(c => c.isTargetActive(undefined))) continue;
+						sum += initialChunkChunkMap.get(originModule);
+					}
+					return sum;
+				};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				/**
+				 * @param {Module} module module
+				 * @returns {number} count of occurs
+				 */
+				const countOccurs = module => {
+					let sum = 0;
+					for (const [
+						originModule,
+						connections
+					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+						if (!originModule) continue;
+						const chunkModules =
+							chunkGraph.getNumberOfModuleChunks(originModule);
+						for (const c of connections) {
+							if (!c.isTargetActive(undefined)) continue;
+							if (!c.dependency) continue;
+							const factor = c.dependency.getNumberOfIdOccurrences();
+							if (factor === 0) continue;
+							sum += factor * chunkModules;
+						}
+					}
+					return sum;
+				};
 
+				if (prioritiseInitial) {
+					for (const m of modulesInOccurrenceOrder) {
+						const result =
+							countOccursInEntry(m) +
+							initialChunkChunkMap.get(m) +
+							entryCountMap.get(m);
+						occursInInitialChunksMap.set(m, result);
+					}
+				}
 
+				for (const m of modulesInOccurrenceOrder) {
+					const result =
+						countOccurs(m) +
+						chunkGraph.getNumberOfModuleChunks(m) +
+						entryCountMap.get(m);
+					occursInAllChunksMap.set(m, result);
+				}
 
-const RequireContextDependency = __webpack_require__(46917);
+				const naturalCompare = compareModulesByPreOrderIndexOrIdentifier(
+					compilation.moduleGraph
+				);
 
-module.exports = class RequireContextDependencyParserPlugin {
-	apply(parser) {
-		parser.hooks.call
-			.for("require.context")
-			.tap("RequireContextDependencyParserPlugin", expr => {
-				let regExp = /^\.\/.*$/;
-				let recursive = true;
-				let mode = "sync";
-				switch (expr.arguments.length) {
-					case 4: {
-						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!modeExpr.isString()) return;
-						mode = modeExpr.string;
-					}
-					// falls through
-					case 3: {
-						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
-						if (!regExpExpr.isRegExp()) return;
-						regExp = regExpExpr.regExp;
-					}
-					// falls through
-					case 2: {
-						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
-						if (!recursiveExpr.isBoolean()) return;
-						recursive = recursiveExpr.bool;
-					}
-					// falls through
-					case 1: {
-						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
-						if (!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(
-							{
-								request: requestExpr.string,
-								recursive,
-								regExp,
-								mode,
-								category: "commonjs"
-							},
-							expr.range
-						);
-						dep.loc = expr.loc;
-						dep.optional = !!parser.scope.inTry;
-						parser.state.current.addDependency(dep);
-						return true;
+				modulesInOccurrenceOrder.sort((a, b) => {
+					if (prioritiseInitial) {
+						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;
+					return naturalCompare(a, b);
+				});
+
+				assignAscendingModuleIds(
+					usedIds,
+					modulesInOccurrenceOrder,
+					compilation
+				);
 			});
+		});
 	}
-};
+}
+
+module.exports = OccurrenceModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 2928:
+/***/ 8635:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89604,154 +87791,144 @@ module.exports = class RequireContextDependencyParserPlugin {
 
 
 
-const { cachedSetProperty } = __webpack_require__(60839);
-const ContextElementDependency = __webpack_require__(58477);
-const RequireContextDependency = __webpack_require__(46917);
-const RequireContextDependencyParserPlugin = __webpack_require__(18851);
+const { WebpackError } = __webpack_require__(91919);
+const { getUsedModuleIdsAndModules } = __webpack_require__(63290);
 
-/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-/** @type {ResolveOptions} */
-const EMPTY_RESOLVE_OPTIONS = {};
+const plugin = "SyncModuleIdsPlugin";
+
+class SyncModuleIdsPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.path path to file
+	 * @param {string=} options.context context for module names
+	 * @param {function(Module): boolean} options.test selector for modules
+	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 */
+	constructor({ path, context, test, mode }) {
+		this._path = path;
+		this._context = context;
+		this._test = test || (() => true);
+		const readAndWrite = !mode || mode === "merge" || mode === "update";
+		this._read = readAndWrite || mode === "read";
+		this._write = readAndWrite || mode === "create";
+		this._prune = mode === "update";
+	}
 
-class RequireContextPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireContextPlugin",
-			(compilation, { contextModuleFactory, normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RequireContextDependency,
-					contextModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireContextDependency,
-					new RequireContextDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					ContextElementDependency,
-					normalModuleFactory
-				);
-
-				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.requireContext !== undefined &&
-						!parserOptions.requireContext
-					)
-						return;
-
-					new RequireContextDependencyParserPlugin().apply(parser);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireContextPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireContextPlugin", handler);
-
-				contextModuleFactory.hooks.alternativeRequests.tap(
-					"RequireContextPlugin",
-					(items, options) => {
-						if (items.length === 0) return items;
-
-						const finalResolveOptions = compiler.resolverFactory.get(
-							"normal",
-							cachedSetProperty(
-								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
-								"dependencyType",
-								options.category
-							)
-						).options;
-
-						let newItems;
-						if (!finalResolveOptions.fullySpecified) {
-							newItems = [];
-							for (const item of items) {
-								const { request, context } = item;
-								for (const ext of finalResolveOptions.extensions) {
-									if (request.endsWith(ext)) {
-										newItems.push({
-											context,
-											request: request.slice(0, -ext.length)
-										});
-									}
-								}
-								if (!finalResolveOptions.enforceExtension) {
-									newItems.push(item);
-								}
-							}
-							items = newItems;
-
-							newItems = [];
-							for (const obj of items) {
-								const { request, context } = obj;
-								for (const mainFile of finalResolveOptions.mainFiles) {
-									if (request.endsWith(`/${mainFile}`)) {
-										newItems.push({
-											context,
-											request: request.slice(0, -mainFile.length)
-										});
-										newItems.push({
-											context,
-											request: request.slice(0, -mainFile.length - 1)
-										});
-									}
-								}
-								newItems.push(obj);
-							}
-							items = newItems;
+		/** @type {Map<string, string | number>} */
+		let data;
+		let dataChanged = false;
+		if (this._read) {
+			compiler.hooks.readRecords.tapAsync(plugin, callback => {
+				const fs = compiler.intermediateFileSystem;
+				fs.readFile(this._path, (err, buffer) => {
+					if (err) {
+						if (err.code !== "ENOENT") {
+							return callback(err);
 						}
-
-						newItems = [];
-						for (const item of items) {
-							let hideOriginal = false;
-							for (const modulesItems of finalResolveOptions.modules) {
-								if (Array.isArray(modulesItems)) {
-									for (const dir of modulesItems) {
-										if (item.request.startsWith(`./${dir}/`)) {
-											newItems.push({
-												context: item.context,
-												request: item.request.slice(dir.length + 3)
-											});
-											hideOriginal = true;
-										}
-									}
-								} else {
-									const dir = modulesItems.replace(/\\/g, "/");
-									const fullPath =
-										item.context.replace(/\\/g, "/") + item.request.slice(1);
-									if (fullPath.startsWith(dir)) {
-										newItems.push({
-											context: item.context,
-											request: fullPath.slice(dir.length + 1)
-										});
-									}
-								}
-							}
-							if (!hideOriginal) {
-								newItems.push(item);
+						return callback();
+					}
+					const json = JSON.parse(buffer.toString());
+					data = new Map();
+					for (const key of Object.keys(json)) {
+						data.set(key, json[key]);
+					}
+					dataChanged = false;
+					return callback();
+				});
+			});
+		}
+		if (this._write) {
+			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
+				if (!data || !dataChanged) return callback();
+				const json = {};
+				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
+				for (const [key, value] of sorted) {
+					json[key] = value;
+				}
+				const fs = compiler.intermediateFileSystem;
+				fs.writeFile(this._path, JSON.stringify(json), callback);
+			});
+		}
+		compiler.hooks.thisCompilation.tap(plugin, compilation => {
+			const associatedObjectForCache = compiler.root;
+			const context = this._context || compiler.context;
+			if (this._read) {
+				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
+					if (!data) return;
+					const { chunkGraph } = compilation;
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this._test
+					);
+					for (const module of modules) {
+						const name = module.libIdent({
+							context,
+							associatedObjectForCache
+						});
+						if (!name) continue;
+						const id = data.get(name);
+						const idAsString = `${id}`;
+						if (usedIds.has(idAsString)) {
+							const err = new WebpackError(
+								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
+							);
+							err.module = module;
+							compilation.errors.push(err);
+						}
+						chunkGraph.setModuleId(module, id);
+						usedIds.add(idAsString);
+					}
+				});
+			}
+			if (this._write) {
+				compilation.hooks.recordModules.tap(plugin, modules => {
+					const { chunkGraph } = compilation;
+					let oldData = data;
+					if (!oldData) {
+						oldData = data = new Map();
+					} else if (this._prune) {
+						data = new Map();
+					}
+					for (const module of modules) {
+						if (this._test(module)) {
+							const name = module.libIdent({
+								context,
+								associatedObjectForCache
+							});
+							if (!name) continue;
+							const id = chunkGraph.getModuleId(module);
+							if (id === null) continue;
+							const oldId = oldData.get(name);
+							if (oldId !== id) {
+								dataChanged = true;
+							} else if (data === oldData) {
+								continue;
 							}
+							data.set(name, id);
 						}
-						return newItems;
 					}
-				);
+					if (data.size !== oldData.size) dataChanged = true;
+				});
 			}
-		);
+		});
 	}
 }
-module.exports = RequireContextPlugin;
+
+module.exports = SyncModuleIdsPlugin;
 
 
 /***/ }),
 
-/***/ 27153:
+/***/ 91919:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -89762,305 +87939,578 @@ module.exports = RequireContextPlugin;
 
 
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const makeSerializable = __webpack_require__(33032);
-
-class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
-	constructor(chunkName, loc) {
-		super(chunkName, loc, null);
-	}
-}
-
-makeSerializable(
-	RequireEnsureDependenciesBlock,
-	"webpack/lib/dependencies/RequireEnsureDependenciesBlock"
-);
-
-module.exports = RequireEnsureDependenciesBlock;
-
+const util = __webpack_require__(73837);
+const memoize = __webpack_require__(78676);
 
-/***/ }),
+/** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
+/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
+/** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
+/** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetCondition} RuleSetCondition */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
+/** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./Compilation").Asset} Asset */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./Parser").ParserState} ParserState */
+/** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
+/** @typedef {import("./ResolverFactory").Resolver} Resolver */
+/** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLogging} StatsLogging */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLoggingEntry} StatsLoggingEntry */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
+/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
 
-/***/ 7235:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @template {Function} T
+ * @param {function(): T} factory factory function
+ * @returns {T} function
+ */
+const lazyFunction = factory => {
+	const fac = memoize(factory);
+	const f = /** @type {any} */ (
+		(...args) => {
+			return fac()(...args);
+		}
+	);
+	return /** @type {T} */ (f);
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RequireEnsureDependenciesBlock = __webpack_require__(27153);
-const RequireEnsureDependency = __webpack_require__(27223);
-const RequireEnsureItemDependency = __webpack_require__(50329);
-const getFunctionExpression = __webpack_require__(50396);
-
-module.exports = class RequireEnsureDependenciesBlockParserPlugin {
-	apply(parser) {
-		parser.hooks.call
-			.for("require.ensure")
-			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
-				let chunkName = null;
-				let errorExpressionArg = null;
-				let errorExpression = null;
-				switch (expr.arguments.length) {
-					case 4: {
-						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!chunkNameExpr.isString()) return;
-						chunkName = chunkNameExpr.string;
-					}
-					// falls through
-					case 3: {
-						errorExpressionArg = expr.arguments[2];
-						errorExpression = getFunctionExpression(errorExpressionArg);
-
-						if (!errorExpression && !chunkName) {
-							const chunkNameExpr = parser.evaluateExpression(
-								expr.arguments[2]
-							);
-							if (!chunkNameExpr.isString()) return;
-							chunkName = chunkNameExpr.string;
-						}
-					}
-					// falls through
-					case 2: {
-						const dependenciesExpr = parser.evaluateExpression(
-							expr.arguments[0]
-						);
-						const dependenciesItems = dependenciesExpr.isArray()
-							? dependenciesExpr.items
-							: [dependenciesExpr];
-						const successExpressionArg = expr.arguments[1];
-						const successExpression =
-							getFunctionExpression(successExpressionArg);
-
-						if (successExpression) {
-							parser.walkExpressions(successExpression.expressions);
-						}
-						if (errorExpression) {
-							parser.walkExpressions(errorExpression.expressions);
-						}
-
-						const depBlock = new RequireEnsureDependenciesBlock(
-							chunkName,
-							expr.loc
-						);
-						const errorCallbackExists =
-							expr.arguments.length === 4 ||
-							(!chunkName && expr.arguments.length === 3);
-						const dep = new RequireEnsureDependency(
-							expr.range,
-							expr.arguments[1].range,
-							errorCallbackExists && expr.arguments[2].range
-						);
-						dep.loc = expr.loc;
-						depBlock.addDependency(dep);
-						const old = parser.state.current;
-						parser.state.current = depBlock;
-						try {
-							let failed = false;
-							parser.inScope([], () => {
-								for (const ee of dependenciesItems) {
-									if (ee.isString()) {
-										const ensureDependency = new RequireEnsureItemDependency(
-											ee.string
-										);
-										ensureDependency.loc = ee.loc || expr.loc;
-										depBlock.addDependency(ensureDependency);
-									} else {
-										failed = true;
-									}
-								}
-							});
-							if (failed) {
-								return;
-							}
-							if (successExpression) {
-								if (successExpression.fn.body.type === "BlockStatement") {
-									parser.walkStatement(successExpression.fn.body);
-								} else {
-									parser.walkExpression(successExpression.fn.body);
-								}
-							}
-							old.addBlock(depBlock);
-						} finally {
-							parser.state.current = old;
-						}
-						if (!successExpression) {
-							parser.walkExpression(successExpressionArg);
-						}
-						if (errorExpression) {
-							if (errorExpression.fn.body.type === "BlockStatement") {
-								parser.walkStatement(errorExpression.fn.body);
-							} else {
-								parser.walkExpression(errorExpression.fn.body);
-							}
-						} else if (errorExpressionArg) {
-							parser.walkExpression(errorExpressionArg);
-						}
-						return true;
-					}
-				}
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	for (const name of Object.keys(descriptors)) {
+		const descriptor = descriptors[name];
+		if (descriptor.get) {
+			const fn = descriptor.get;
+			Object.defineProperty(obj, name, {
+				configurable: false,
+				enumerable: true,
+				get: memoize(fn)
+			});
+		} else if (typeof descriptor.value === "object") {
+			Object.defineProperty(obj, name, {
+				configurable: false,
+				enumerable: true,
+				writable: false,
+				value: mergeExports({}, descriptor.value)
 			});
+		} else {
+			throw new Error(
+				"Exposed values must be either a getter or an nested object"
+			);
+		}
 	}
+	return /** @type {A & B} */ (Object.freeze(obj));
 };
 
+const fn = lazyFunction(() => __webpack_require__(36243));
+module.exports = mergeExports(fn, {
+	get webpack() {
+		return __webpack_require__(36243);
+	},
+	get validate() {
+		const webpackOptionsSchemaCheck = __webpack_require__(10382);
+		const getRealValidate = memoize(() => {
+			const validateSchema = __webpack_require__(12047);
+			const webpackOptionsSchema = __webpack_require__(73342);
+			return options => validateSchema(webpackOptionsSchema, options);
+		});
+		return options => {
+			if (!webpackOptionsSchemaCheck(options)) getRealValidate()(options);
+		};
+	},
+	get validateSchema() {
+		const validateSchema = __webpack_require__(12047);
+		return validateSchema;
+	},
+	get version() {
+		return /** @type {string} */ ((__webpack_require__(32702)/* .version */ .i8));
+	},
 
-/***/ }),
-
-/***/ 27223:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	get cli() {
+		return __webpack_require__(13462);
+	},
+	get AutomaticPrefetchPlugin() {
+		return __webpack_require__(17714);
+	},
+	get AsyncDependenciesBlock() {
+		return __webpack_require__(47736);
+	},
+	get BannerPlugin() {
+		return __webpack_require__(21242);
+	},
+	get Cache() {
+		return __webpack_require__(7592);
+	},
+	get Chunk() {
+		return __webpack_require__(39385);
+	},
+	get ChunkGraph() {
+		return __webpack_require__(64971);
+	},
+	get CleanPlugin() {
+		return __webpack_require__(31085);
+	},
+	get Compilation() {
+		return __webpack_require__(85720);
+	},
+	get Compiler() {
+		return __webpack_require__(70845);
+	},
+	get ConcatenationScope() {
+		return __webpack_require__(98229);
+	},
+	get ContextExclusionPlugin() {
+		return __webpack_require__(21411);
+	},
+	get ContextReplacementPlugin() {
+		return __webpack_require__(12206);
+	},
+	get DefinePlugin() {
+		return __webpack_require__(79065);
+	},
+	get DelegatedPlugin() {
+		return __webpack_require__(80632);
+	},
+	get Dependency() {
+		return __webpack_require__(54912);
+	},
+	get DllPlugin() {
+		return __webpack_require__(40038);
+	},
+	get DllReferencePlugin() {
+		return __webpack_require__(90999);
+	},
+	get DynamicEntryPlugin() {
+		return __webpack_require__(96475);
+	},
+	get EntryOptionPlugin() {
+		return __webpack_require__(9909);
+	},
+	get EntryPlugin() {
+		return __webpack_require__(96953);
+	},
+	get EnvironmentPlugin() {
+		return __webpack_require__(22070);
+	},
+	get EvalDevToolModulePlugin() {
+		return __webpack_require__(65218);
+	},
+	get EvalSourceMapDevToolPlugin() {
+		return __webpack_require__(14790);
+	},
+	get ExternalModule() {
+		return __webpack_require__(73071);
+	},
+	get ExternalsPlugin() {
+		return __webpack_require__(6652);
+	},
+	get Generator() {
+		return __webpack_require__(93401);
+	},
+	get HotUpdateChunk() {
+		return __webpack_require__(9597);
+	},
+	get HotModuleReplacementPlugin() {
+		return __webpack_require__(6404);
+	},
+	get IgnorePlugin() {
+		return __webpack_require__(84808);
+	},
+	get JavascriptModulesPlugin() {
+		return util.deprecate(
+			() => __webpack_require__(89464),
+			"webpack.JavascriptModulesPlugin has moved to webpack.javascript.JavascriptModulesPlugin",
+			"DEP_WEBPACK_JAVASCRIPT_MODULES_PLUGIN"
+		)();
+	},
+	get LibManifestPlugin() {
+		return __webpack_require__(93837);
+	},
+	get LibraryTemplatePlugin() {
+		return util.deprecate(
+			() => __webpack_require__(14157),
+			"webpack.LibraryTemplatePlugin is deprecated and has been replaced by compilation.outputOptions.library or compilation.addEntry + passing a library option",
+			"DEP_WEBPACK_LIBRARY_TEMPLATE_PLUGIN"
+		)();
+	},
+	get LoaderOptionsPlugin() {
+		return __webpack_require__(22078);
+	},
+	get LoaderTargetPlugin() {
+		return __webpack_require__(86738);
+	},
+	get Module() {
+		return __webpack_require__(73208);
+	},
+	get ModuleFilenameHelpers() {
+		return __webpack_require__(88821);
+	},
+	get ModuleGraph() {
+		return __webpack_require__(99988);
+	},
+	get ModuleGraphConnection() {
+		return __webpack_require__(40639);
+	},
+	get NoEmitOnErrorsPlugin() {
+		return __webpack_require__(50169);
+	},
+	get NormalModule() {
+		return __webpack_require__(39);
+	},
+	get NormalModuleReplacementPlugin() {
+		return __webpack_require__(30633);
+	},
+	get MultiCompiler() {
+		return __webpack_require__(33370);
+	},
+	get Parser() {
+		return __webpack_require__(11715);
+	},
+	get PrefetchPlugin() {
+		return __webpack_require__(73850);
+	},
+	get ProgressPlugin() {
+		return __webpack_require__(13216);
+	},
+	get ProvidePlugin() {
+		return __webpack_require__(38309);
+	},
+	get RuntimeGlobals() {
+		return __webpack_require__(16475);
+	},
+	get RuntimeModule() {
+		return __webpack_require__(16963);
+	},
+	get SingleEntryPlugin() {
+		return util.deprecate(
+			() => __webpack_require__(96953),
+			"SingleEntryPlugin was renamed to EntryPlugin",
+			"DEP_WEBPACK_SINGLE_ENTRY_PLUGIN"
+		)();
+	},
+	get SourceMapDevToolPlugin() {
+		return __webpack_require__(63872);
+	},
+	get Stats() {
+		return __webpack_require__(31743);
+	},
+	get Template() {
+		return __webpack_require__(1626);
+	},
+	get UsageState() {
+		return (__webpack_require__(63686).UsageState);
+	},
+	get WatchIgnorePlugin() {
+		return __webpack_require__(65193);
+	},
+	get WebpackError() {
+		return __webpack_require__(53799);
+	},
+	get WebpackOptionsApply() {
+		return __webpack_require__(88422);
+	},
+	get WebpackOptionsDefaulter() {
+		return util.deprecate(
+			() => __webpack_require__(14452),
+			"webpack.WebpackOptionsDefaulter is deprecated and has been replaced by webpack.config.getNormalizedWebpackOptions and webpack.config.applyWebpackOptionsDefaults",
+			"DEP_WEBPACK_OPTIONS_DEFAULTER"
+		)();
+	},
+	// TODO webpack 6 deprecate
+	get WebpackOptionsValidationError() {
+		return (__webpack_require__(38476).ValidationError);
+	},
+	get ValidationError() {
+		return (__webpack_require__(38476).ValidationError);
+	},
 
+	cache: {
+		get MemoryCachePlugin() {
+			return __webpack_require__(52539);
+		}
+	},
 
+	config: {
+		get getNormalizedWebpackOptions() {
+			return (__webpack_require__(26693).getNormalizedWebpackOptions);
+		},
+		get applyWebpackOptionsDefaults() {
+			return (__webpack_require__(92988).applyWebpackOptionsDefaults);
+		}
+	},
 
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+	dependencies: {
+		get ModuleDependency() {
+			return __webpack_require__(80321);
+		},
+		get ConstDependency() {
+			return __webpack_require__(76911);
+		},
+		get NullDependency() {
+			return __webpack_require__(31830);
+		}
+	},
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+	ids: {
+		get ChunkModuleIdRangePlugin() {
+			return __webpack_require__(64618);
+		},
+		get NaturalModuleIdsPlugin() {
+			return __webpack_require__(83366);
+		},
+		get OccurrenceModuleIdsPlugin() {
+			return __webpack_require__(35371);
+		},
+		get NamedModuleIdsPlugin() {
+			return __webpack_require__(24339);
+		},
+		get DeterministicChunkIdsPlugin() {
+			return __webpack_require__(8747);
+		},
+		get DeterministicModuleIdsPlugin() {
+			return __webpack_require__(76692);
+		},
+		get NamedChunkIdsPlugin() {
+			return __webpack_require__(6454);
+		},
+		get OccurrenceChunkIdsPlugin() {
+			return __webpack_require__(51020);
+		},
+		get HashedModuleIdsPlugin() {
+			return __webpack_require__(21825);
+		}
+	},
 
-class RequireEnsureDependency extends NullDependency {
-	constructor(range, contentRange, errorHandlerRange) {
-		super();
+	javascript: {
+		get EnableChunkLoadingPlugin() {
+			return __webpack_require__(61291);
+		},
+		get JavascriptModulesPlugin() {
+			return __webpack_require__(89464);
+		},
+		get JavascriptParser() {
+			return __webpack_require__(29050);
+		}
+	},
 
-		this.range = range;
-		this.contentRange = contentRange;
-		this.errorHandlerRange = errorHandlerRange;
-	}
+	optimize: {
+		get AggressiveMergingPlugin() {
+			return __webpack_require__(64395);
+		},
+		get AggressiveSplittingPlugin() {
+			return util.deprecate(
+				() => __webpack_require__(15543),
+				"AggressiveSplittingPlugin is deprecated in favor of SplitChunksPlugin",
+				"DEP_WEBPACK_AGGRESSIVE_SPLITTING_PLUGIN"
+			)();
+		},
+		get InnerGraph() {
+			return __webpack_require__(38988);
+		},
+		get LimitChunkCountPlugin() {
+			return __webpack_require__(83608);
+		},
+		get MinChunkSizePlugin() {
+			return __webpack_require__(53912);
+		},
+		get ModuleConcatenationPlugin() {
+			return __webpack_require__(74844);
+		},
+		get RealContentHashPlugin() {
+			return __webpack_require__(46043);
+		},
+		get RuntimeChunkPlugin() {
+			return __webpack_require__(2837);
+		},
+		get SideEffectsFlagPlugin() {
+			return __webpack_require__(84800);
+		},
+		get SplitChunksPlugin() {
+			return __webpack_require__(21478);
+		}
+	},
 
-	get type() {
-		return "require.ensure";
-	}
+	runtime: {
+		get GetChunkFilenameRuntimeModule() {
+			return __webpack_require__(34277);
+		},
+		get LoadScriptRuntimeModule() {
+			return __webpack_require__(19942);
+		}
+	},
 
-	serialize(context) {
-		const { write } = context;
+	prefetch: {
+		get ChunkPrefetchPreloadPlugin() {
+			return __webpack_require__(33895);
+		}
+	},
 
-		write(this.range);
-		write(this.contentRange);
-		write(this.errorHandlerRange);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.range = read();
-		this.contentRange = read();
-		this.errorHandlerRange = read();
-
-		super.deserialize(context);
-	}
-}
-
-makeSerializable(
-	RequireEnsureDependency,
-	"webpack/lib/dependencies/RequireEnsureDependency"
-);
-
-RequireEnsureDependency.Template = class RequireEnsureDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
-		const dep = /** @type {RequireEnsureDependency} */ (dependency);
-		const depBlock = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dep)
-		);
-		const promise = runtimeTemplate.blockPromise({
-			chunkGraph,
-			block: depBlock,
-			message: "require.ensure",
-			runtimeRequirements
-		});
-		const range = dep.range;
-		const contentRange = dep.contentRange;
-		const errorHandlerRange = dep.errorHandlerRange;
-		source.replace(range[0], contentRange[0] - 1, `${promise}.then((`);
-		if (errorHandlerRange) {
-			source.replace(
-				contentRange[1],
-				errorHandlerRange[0] - 1,
-				").bind(null, __webpack_require__))['catch']("
-			);
-			source.replace(errorHandlerRange[1], range[1] - 1, ")");
-		} else {
-			source.replace(
-				contentRange[1],
-				range[1] - 1,
-				`).bind(null, __webpack_require__))['catch'](${RuntimeGlobals.uncaughtErrorHandler})`
-			);
+	web: {
+		get FetchCompileAsyncWasmPlugin() {
+			return __webpack_require__(8437);
+		},
+		get FetchCompileWasmPlugin() {
+			return __webpack_require__(35537);
+		},
+		get JsonpChunkLoadingRuntimeModule() {
+			return __webpack_require__(84154);
+		},
+		get JsonpTemplatePlugin() {
+			return __webpack_require__(4607);
 		}
-	}
-};
+	},
 
-module.exports = RequireEnsureDependency;
+	webworker: {
+		get WebWorkerTemplatePlugin() {
+			return __webpack_require__(68693);
+		}
+	},
 
+	node: {
+		get NodeEnvironmentPlugin() {
+			return __webpack_require__(7553);
+		},
+		get NodeSourcePlugin() {
+			return __webpack_require__(7103);
+		},
+		get NodeTargetPlugin() {
+			return __webpack_require__(17916);
+		},
+		get NodeTemplatePlugin() {
+			return __webpack_require__(61052);
+		},
+		get ReadFileCompileWasmPlugin() {
+			return __webpack_require__(98939);
+		}
+	},
 
-/***/ }),
+	electron: {
+		get ElectronTargetPlugin() {
+			return __webpack_require__(32277);
+		}
+	},
 
-/***/ 50329:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	wasm: {
+		get AsyncWebAssemblyModulesPlugin() {
+			return __webpack_require__(7538);
+		}
+	},
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	library: {
+		get AbstractLibraryPlugin() {
+			return __webpack_require__(26030);
+		},
+		get EnableLibraryPlugin() {
+			return __webpack_require__(91452);
+		}
+	},
 
+	container: {
+		get ContainerPlugin() {
+			return __webpack_require__(9244);
+		},
+		get ContainerReferencePlugin() {
+			return __webpack_require__(95757);
+		},
+		get ModuleFederationPlugin() {
+			return __webpack_require__(30569);
+		},
+		get scope() {
+			return (__webpack_require__(3083).scope);
+		}
+	},
 
+	sharing: {
+		get ConsumeSharedPlugin() {
+			return __webpack_require__(15046);
+		},
+		get ProvideSharedPlugin() {
+			return __webpack_require__(31225);
+		},
+		get SharePlugin() {
+			return __webpack_require__(26335);
+		},
+		get scope() {
+			return (__webpack_require__(3083).scope);
+		}
+	},
 
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const NullDependency = __webpack_require__(31830);
+	debug: {
+		get ProfilingPlugin() {
+			return __webpack_require__(2757);
+		}
+	},
 
-class RequireEnsureItemDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
-	}
+	util: {
+		get createHash() {
+			return __webpack_require__(49835);
+		},
+		get comparators() {
+			return __webpack_require__(29579);
+		},
+		get runtime() {
+			return __webpack_require__(17156);
+		},
+		get serialization() {
+			return __webpack_require__(8282);
+		},
+		get cleverMerge() {
+			return (__webpack_require__(60839).cachedCleverMerge);
+		},
+		get LazySet() {
+			return __webpack_require__(38938);
+		}
+	},
 
-	get type() {
-		return "require.ensure item";
-	}
+	get sources() {
+		return __webpack_require__(51255);
+	},
 
-	get category() {
-		return "commonjs";
+	experiments: {
+		schemes: {
+			get HttpUriPlugin() {
+				return __webpack_require__(42110);
+			}
+		},
+		ids: {
+			get SyncModuleIdsPlugin() {
+				return __webpack_require__(8635);
+			}
+		}
 	}
-}
-
-makeSerializable(
-	RequireEnsureItemDependency,
-	"webpack/lib/dependencies/RequireEnsureItemDependency"
-);
-
-RequireEnsureItemDependency.Template = NullDependency.Template;
-
-module.exports = RequireEnsureItemDependency;
+});
 
 
 /***/ }),
 
-/***/ 8434:
+/***/ 18535:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -90071,71 +88521,159 @@ module.exports = RequireEnsureItemDependency;
 
 
 
-const RequireEnsureDependency = __webpack_require__(27223);
-const RequireEnsureItemDependency = __webpack_require__(50329);
-
-const RequireEnsureDependenciesBlockParserPlugin = __webpack_require__(7235);
-
+const { ConcatSource, PrefixSource, RawSource } = __webpack_require__(51255);
+const { RuntimeGlobals } = __webpack_require__(91919);
+const HotUpdateChunk = __webpack_require__(9597);
+const Template = __webpack_require__(1626);
+const { getCompilationHooks } = __webpack_require__(89464);
 const {
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
+	generateEntryStartup,
+	updateHashForEntryStartup
+} = __webpack_require__(98124);
 
-class RequireEnsurePlugin {
+/** @typedef {import("../Compiler")} Compiler */
+
+class ArrayPushCallbackChunkFormatPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireEnsurePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RequireEnsureItemDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireEnsureItemDependency,
-					new RequireEnsureItemDependency.Template()
+		compiler.hooks.thisCompilation.tap(
+			"ArrayPushCallbackChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ArrayPushCallbackChunkFormatPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (chunk.hasRuntime()) return;
+						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.require);
+						}
+						set.add(RuntimeGlobals.chunkCallback);
+					}
 				);
-
-				compilation.dependencyTemplates.set(
-					RequireEnsureDependency,
-					new RequireEnsureDependency.Template()
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"ArrayPushCallbackChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
+						const globalObject = runtimeTemplate.globalObject;
+						const source = new ConcatSource();
+						const runtimeModules =
+							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+						if (hotUpdateChunk) {
+							const hotUpdateGlobal =
+								runtimeTemplate.outputOptions.hotUpdateGlobal;
+							source.add(
+								`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`
+							);
+							source.add(`${JSON.stringify(chunk.id)},`);
+							source.add(modules);
+							if (runtimeModules.length > 0) {
+								source.add(",\n");
+								const runtimePart = Template.renderChunkRuntimeModules(
+									runtimeModules,
+									renderContext
+								);
+								source.add(runtimePart);
+							}
+							source.add(")");
+						} else {
+							const chunkLoadingGlobal =
+								runtimeTemplate.outputOptions.chunkLoadingGlobal;
+							source.add(
+								`(${globalObject}[${JSON.stringify(
+									chunkLoadingGlobal
+								)}] = ${globalObject}[${JSON.stringify(
+									chunkLoadingGlobal
+								)}] || []).push([`
+							);
+							source.add(`${JSON.stringify(chunk.ids)},`);
+							source.add(modules);
+							const entries = Array.from(
+								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+							);
+							if (runtimeModules.length > 0 || entries.length > 0) {
+								const runtime = new ConcatSource(
+									(runtimeTemplate.supportsArrowFunction()
+										? "__webpack_require__ =>"
+										: "function(__webpack_require__)") +
+										" { // webpackRuntimeModules\n"
+								);
+								if (runtimeModules.length > 0) {
+									runtime.add(
+										Template.renderRuntimeModules(runtimeModules, {
+											...renderContext,
+											codeGenerationResults: compilation.codeGenerationResults
+										})
+									);
+								}
+								if (entries.length > 0) {
+									const startupSource = new RawSource(
+										generateEntryStartup(
+											chunkGraph,
+											runtimeTemplate,
+											entries,
+											chunk,
+											true
+										)
+									);
+									runtime.add(
+										hooks.renderStartup.call(
+											startupSource,
+											entries[entries.length - 1][0],
+											{
+												...renderContext,
+												inlined: false
+											}
+										)
+									);
+									if (
+										chunkGraph
+											.getChunkRuntimeRequirements(chunk)
+											.has(RuntimeGlobals.returnExportsFromRuntime)
+									) {
+										runtime.add("return __webpack_exports__;\n");
+									}
+								}
+								runtime.add("}\n");
+								source.add(",\n");
+								source.add(new PrefixSource("/******/ ", runtime));
+							}
+							source.add("])");
+						}
+						return source;
+					}
 				);
-
-				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.requireEnsure !== undefined &&
-						!parserOptions.requireEnsure
-					)
-						return;
-
-					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);
-					parser.hooks.evaluateTypeof
-						.for("require.ensure")
-						.tap("RequireEnsurePlugin", evaluateToString("function"));
-					parser.hooks.typeof
-						.for("require.ensure")
-						.tap(
-							"RequireEnsurePlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
+				hooks.chunkHash.tap(
+					"ArrayPushCallbackChunkFormatPlugin",
+					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update(
+							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
 						);
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireEnsurePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireEnsurePlugin", handler);
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
 			}
 		);
 	}
 }
-module.exports = RequireEnsurePlugin;
+
+module.exports = ArrayPushCallbackChunkFormatPlugin;
 
 
 /***/ }),
 
-/***/ 89183:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 950:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -90145,279 +88683,485 @@ module.exports = RequireEnsurePlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+const TypeUnknown = 0;
+const TypeUndefined = 1;
+const TypeNull = 2;
+const TypeString = 3;
+const TypeNumber = 4;
+const TypeBoolean = 5;
+const TypeRegExp = 6;
+const TypeConditional = 7;
+const TypeArray = 8;
+const TypeConstArray = 9;
+const TypeIdentifier = 10;
+const TypeWrapped = 11;
+const TypeTemplateString = 12;
+const TypeBigInt = 13;
 
-class RequireHeaderDependency extends NullDependency {
-	constructor(range) {
-		super();
-		if (!Array.isArray(range)) throw new Error("range must be valid");
-		this.range = range;
+class BasicEvaluatedExpression {
+	constructor() {
+		this.type = TypeUnknown;
+		/** @type {[number, number]} */
+		this.range = undefined;
+		/** @type {boolean} */
+		this.falsy = false;
+		/** @type {boolean} */
+		this.truthy = false;
+		/** @type {boolean | undefined} */
+		this.nullish = undefined;
+		/** @type {boolean} */
+		this.sideEffects = true;
+		/** @type {boolean | undefined} */
+		this.bool = undefined;
+		/** @type {number | undefined} */
+		this.number = undefined;
+		/** @type {bigint | undefined} */
+		this.bigint = undefined;
+		/** @type {RegExp | undefined} */
+		this.regExp = undefined;
+		/** @type {string | undefined} */
+		this.string = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.quasis = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.parts = undefined;
+		/** @type {any[] | undefined} */
+		this.array = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.items = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
+		this.options = undefined;
+		/** @type {BasicEvaluatedExpression | undefined} */
+		this.prefix = undefined;
+		/** @type {BasicEvaluatedExpression | undefined} */
+		this.postfix = undefined;
+		this.wrappedInnerExpressions = undefined;
+		/** @type {string | undefined} */
+		this.identifier = undefined;
+		/** @type {VariableInfoInterface} */
+		this.rootInfo = undefined;
+		/** @type {() => string[]} */
+		this.getMembers = undefined;
+		/** @type {EsTreeNode} */
+		this.expression = undefined;
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		super.serialize(context);
+	isUnknown() {
+		return this.type === TypeUnknown;
 	}
 
-	static deserialize(context) {
-		const obj = new RequireHeaderDependency(context.read());
-		obj.deserialize(context);
-		return obj;
+	isNull() {
+		return this.type === TypeNull;
 	}
-}
-
-makeSerializable(
-	RequireHeaderDependency,
-	"webpack/lib/dependencies/RequireHeaderDependency"
-);
 
-RequireHeaderDependency.Template = class RequireHeaderDependencyTemplate extends (
-	NullDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {RequireHeaderDependency} */ (dependency);
-		runtimeRequirements.add(RuntimeGlobals.require);
-		source.replace(dep.range[0], dep.range[1] - 1, "__webpack_require__");
+	isUndefined() {
+		return this.type === TypeUndefined;
 	}
-};
 
-module.exports = RequireHeaderDependency;
+	isString() {
+		return this.type === TypeString;
+	}
 
+	isNumber() {
+		return this.type === TypeNumber;
+	}
 
-/***/ }),
+	isBigInt() {
+		return this.type === TypeBigInt;
+	}
 
-/***/ 71284:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	isBoolean() {
+		return this.type === TypeBoolean;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	isRegExp() {
+		return this.type === TypeRegExp;
+	}
 
+	isConditional() {
+		return this.type === TypeConditional;
+	}
 
+	isArray() {
+		return this.type === TypeArray;
+	}
 
-const Dependency = __webpack_require__(54912);
-const Template = __webpack_require__(39722);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+	isConstArray() {
+		return this.type === TypeConstArray;
+	}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+	isIdentifier() {
+		return this.type === TypeIdentifier;
+	}
 
-class RequireIncludeDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+	isWrapped() {
+		return this.type === TypeWrapped;
+	}
 
-		this.range = range;
+	isTemplateString() {
+		return this.type === TypeTemplateString;
 	}
 
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * Is expression a primitive or an object type value?
+	 * @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		// This doesn't use any export
-		return Dependency.NO_EXPORTS_REFERENCED;
+	isPrimitiveType() {
+		switch (this.type) {
+			case TypeUndefined:
+			case TypeNull:
+			case TypeString:
+			case TypeNumber:
+			case TypeBoolean:
+			case TypeBigInt:
+			case TypeWrapped:
+			case TypeTemplateString:
+				return true;
+			case TypeRegExp:
+			case TypeArray:
+			case TypeConstArray:
+				return false;
+			default:
+				return undefined;
+		}
 	}
 
-	get type() {
-		return "require.include";
+	/**
+	 * Is expression a runtime or compile-time value?
+	 * @returns {boolean} true: compile time value, false: runtime value
+	 */
+	isCompileTimeValue() {
+		switch (this.type) {
+			case TypeUndefined:
+			case TypeNull:
+			case TypeString:
+			case TypeNumber:
+			case TypeBoolean:
+			case TypeRegExp:
+			case TypeConstArray:
+			case TypeBigInt:
+				return true;
+			default:
+				return false;
+		}
 	}
 
-	get category() {
-		return "commonjs";
+	/**
+	 * Gets the compile-time value of the expression
+	 * @returns {any} the javascript value
+	 */
+	asCompileTimeValue() {
+		switch (this.type) {
+			case TypeUndefined:
+				return undefined;
+			case TypeNull:
+				return null;
+			case TypeString:
+				return this.string;
+			case TypeNumber:
+				return this.number;
+			case TypeBoolean:
+				return this.bool;
+			case TypeRegExp:
+				return this.regExp;
+			case TypeConstArray:
+				return this.array;
+			case TypeBigInt:
+				return this.bigint;
+			default:
+				throw new Error(
+					"asCompileTimeValue must only be called for compile-time values"
+				);
+		}
 	}
-}
 
-makeSerializable(
-	RequireIncludeDependency,
-	"webpack/lib/dependencies/RequireIncludeDependency"
-);
+	isTruthy() {
+		return this.truthy;
+	}
+
+	isFalsy() {
+		return this.falsy;
+	}
+
+	isNullish() {
+		return this.nullish;
+	}
 
-RequireIncludeDependency.Template = class RequireIncludeDependencyTemplate extends (
-	ModuleDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * Can this expression have side effects?
+	 * @returns {boolean} false: never has side effects
 	 */
-	apply(dependency, source, { runtimeTemplate }) {
-		const dep = /** @type {RequireIncludeDependency} */ (dependency);
-		const comment = runtimeTemplate.outputOptions.pathinfo
-			? Template.toComment(
-					`require.include ${runtimeTemplate.requestShortener.shorten(
-						dep.request
-					)}`
-			  )
-			: "";
+	couldHaveSideEffects() {
+		return this.sideEffects;
+	}
 
-		source.replace(dep.range[0], dep.range[1] - 1, `undefined${comment}`);
+	asBool() {
+		if (this.truthy) return true;
+		if (this.falsy || this.nullish) return false;
+		if (this.isBoolean()) return this.bool;
+		if (this.isNull()) return false;
+		if (this.isUndefined()) return false;
+		if (this.isString()) return this.string !== "";
+		if (this.isNumber()) return this.number !== 0;
+		if (this.isBigInt()) return this.bigint !== BigInt(0);
+		if (this.isRegExp()) return true;
+		if (this.isArray()) return true;
+		if (this.isConstArray()) return true;
+		if (this.isWrapped()) {
+			return (this.prefix && this.prefix.asBool()) ||
+				(this.postfix && this.postfix.asBool())
+				? true
+				: undefined;
+		}
+		if (this.isTemplateString()) {
+			const str = this.asString();
+			if (typeof str === "string") return str !== "";
+		}
+		return undefined;
 	}
-};
 
-module.exports = RequireIncludeDependency;
+	asNullish() {
+		const nullish = this.isNullish();
 
+		if (nullish === true || this.isNull() || this.isUndefined()) return true;
 
-/***/ }),
+		if (nullish === false) return false;
+		if (this.isTruthy()) return false;
+		if (this.isBoolean()) return false;
+		if (this.isString()) return false;
+		if (this.isNumber()) return false;
+		if (this.isBigInt()) return false;
+		if (this.isRegExp()) return false;
+		if (this.isArray()) return false;
+		if (this.isConstArray()) return false;
+		if (this.isTemplateString()) return false;
+		if (this.isRegExp()) return false;
 
-/***/ 35768:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		return undefined;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	asString() {
+		if (this.isBoolean()) return `${this.bool}`;
+		if (this.isNull()) return "null";
+		if (this.isUndefined()) return "undefined";
+		if (this.isString()) return this.string;
+		if (this.isNumber()) return `${this.number}`;
+		if (this.isBigInt()) return `${this.bigint}`;
+		if (this.isRegExp()) return `${this.regExp}`;
+		if (this.isArray()) {
+			let array = [];
+			for (const item of this.items) {
+				const itemStr = item.asString();
+				if (itemStr === undefined) return undefined;
+				array.push(itemStr);
+			}
+			return `${array}`;
+		}
+		if (this.isConstArray()) return `${this.array}`;
+		if (this.isTemplateString()) {
+			let str = "";
+			for (const part of this.parts) {
+				const partStr = part.asString();
+				if (partStr === undefined) return undefined;
+				str += partStr;
+			}
+			return str;
+		}
+		return undefined;
+	}
+
+	setString(string) {
+		this.type = TypeString;
+		this.string = string;
+		this.sideEffects = false;
+		return this;
+	}
 
+	setUndefined() {
+		this.type = TypeUndefined;
+		this.sideEffects = false;
+		return this;
+	}
 
+	setNull() {
+		this.type = TypeNull;
+		this.sideEffects = false;
+		return this;
+	}
 
-const WebpackError = __webpack_require__(53799);
-const {
-	evaluateToString,
-	toConstantDependency
-} = __webpack_require__(93998);
-const makeSerializable = __webpack_require__(33032);
-const RequireIncludeDependency = __webpack_require__(71284);
+	setNumber(number) {
+		this.type = TypeNumber;
+		this.number = number;
+		this.sideEffects = false;
+		return this;
+	}
 
-module.exports = class RequireIncludeDependencyParserPlugin {
-	constructor(warn) {
-		this.warn = warn;
+	setBigInt(bigint) {
+		this.type = TypeBigInt;
+		this.bigint = bigint;
+		this.sideEffects = false;
+		return this;
 	}
-	apply(parser) {
-		const { warn } = this;
-		parser.hooks.call
-			.for("require.include")
-			.tap("RequireIncludeDependencyParserPlugin", expr => {
-				if (expr.arguments.length !== 1) return;
-				const param = parser.evaluateExpression(expr.arguments[0]);
-				if (!param.isString()) return;
 
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
-					);
-				}
+	setBoolean(bool) {
+		this.type = TypeBoolean;
+		this.bool = bool;
+		this.sideEffects = false;
+		return this;
+	}
 
-				const dep = new RequireIncludeDependency(param.string, expr.range);
-				dep.loc = expr.loc;
-				parser.state.current.addDependency(dep);
-				return true;
-			});
-		parser.hooks.evaluateTypeof
-			.for("require.include")
-			.tap("RequireIncludePlugin", expr => {
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
-					);
-				}
-				return evaluateToString("function")(expr);
-			});
-		parser.hooks.typeof
-			.for("require.include")
-			.tap("RequireIncludePlugin", expr => {
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(expr.loc)
-					);
-				}
-				return toConstantDependency(parser, JSON.stringify("function"))(expr);
-			});
+	setRegExp(regExp) {
+		this.type = TypeRegExp;
+		this.regExp = regExp;
+		this.sideEffects = false;
+		return this;
 	}
-};
 
-class RequireIncludeDeprecationWarning extends WebpackError {
-	constructor(loc) {
-		super("require.include() is deprecated and will be removed soon.");
+	setIdentifier(identifier, rootInfo, getMembers) {
+		this.type = TypeIdentifier;
+		this.identifier = identifier;
+		this.rootInfo = rootInfo;
+		this.getMembers = getMembers;
+		this.sideEffects = true;
+		return this;
+	}
 
-		this.name = "RequireIncludeDeprecationWarning";
+	setWrapped(prefix, postfix, innerExpressions) {
+		this.type = TypeWrapped;
+		this.prefix = prefix;
+		this.postfix = postfix;
+		this.wrappedInnerExpressions = innerExpressions;
+		this.sideEffects = true;
+		return this;
+	}
 
-		this.loc = loc;
+	setOptions(options) {
+		this.type = TypeConditional;
+		this.options = options;
+		this.sideEffects = true;
+		return this;
 	}
-}
 
-makeSerializable(
-	RequireIncludeDeprecationWarning,
-	"webpack/lib/dependencies/RequireIncludeDependencyParserPlugin",
-	"RequireIncludeDeprecationWarning"
-);
+	addOptions(options) {
+		if (!this.options) {
+			this.type = TypeConditional;
+			this.options = [];
+			this.sideEffects = true;
+		}
+		for (const item of options) {
+			this.options.push(item);
+		}
+		return this;
+	}
 
+	setItems(items) {
+		this.type = TypeArray;
+		this.items = items;
+		this.sideEffects = items.some(i => i.couldHaveSideEffects());
+		return this;
+	}
 
-/***/ }),
+	setArray(array) {
+		this.type = TypeConstArray;
+		this.array = array;
+		this.sideEffects = false;
+		return this;
+	}
 
-/***/ 37378:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	setTemplateString(quasis, parts, kind) {
+		this.type = TypeTemplateString;
+		this.quasis = quasis;
+		this.parts = parts;
+		this.templateStringKind = kind;
+		this.sideEffects = parts.some(p => p.sideEffects);
+		return this;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	setTruthy() {
+		this.falsy = false;
+		this.truthy = true;
+		this.nullish = false;
+		return this;
+	}
 
+	setFalsy() {
+		this.falsy = true;
+		this.truthy = false;
+		return this;
+	}
 
+	setNullish(value) {
+		this.nullish = value;
 
-const RequireIncludeDependency = __webpack_require__(71284);
-const RequireIncludeDependencyParserPlugin = __webpack_require__(35768);
+		if (value) return this.setFalsy();
 
-class RequireIncludePlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"RequireIncludePlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					RequireIncludeDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					RequireIncludeDependency,
-					new RequireIncludeDependency.Template()
-				);
+		return this;
+	}
 
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.requireInclude === false) return;
-					const warn = parserOptions.requireInclude === undefined;
+	setRange(range) {
+		this.range = range;
+		return this;
+	}
 
-					new RequireIncludeDependencyParserPlugin(warn).apply(parser);
-				};
+	setSideEffects(sideEffects = true) {
+		this.sideEffects = sideEffects;
+		return this;
+	}
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("RequireIncludePlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("RequireIncludePlugin", handler);
-			}
-		);
+	setExpression(expression) {
+		this.expression = expression;
+		return this;
 	}
 }
-module.exports = RequireIncludePlugin;
+
+/**
+ * @param {string} flags regexp flags
+ * @returns {boolean} is valid flags
+ */
+BasicEvaluatedExpression.isValidRegExpFlags = flags => {
+	const len = flags.length;
+
+	if (len === 0) return true;
+	if (len > 4) return false;
+
+	// cspell:word gimy
+	let remaining = 0b0000; // bit per RegExp flag: gimy
+
+	for (let i = 0; i < len; i++)
+		switch (flags.charCodeAt(i)) {
+			case 103 /* g */:
+				if (remaining & 0b1000) return false;
+				remaining |= 0b1000;
+				break;
+			case 105 /* i */:
+				if (remaining & 0b0100) return false;
+				remaining |= 0b0100;
+				break;
+			case 109 /* m */:
+				if (remaining & 0b0010) return false;
+				remaining |= 0b0010;
+				break;
+			case 121 /* y */:
+				if (remaining & 0b0001) return false;
+				remaining |= 0b0001;
+				break;
+			default:
+				return false;
+		}
+
+	return true;
+};
+
+module.exports = BasicEvaluatedExpression;
 
 
 /***/ }),
 
-/***/ 55627:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 91145:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -90427,54 +89171,37 @@ module.exports = RequireIncludePlugin;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const ContextDependency = __webpack_require__(88101);
-const ContextDependencyTemplateAsId = __webpack_require__(76081);
+const Entrypoint = __webpack_require__(13795);
 
-class RequireResolveContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
-
-		this.range = range;
-		this.valueRange = valueRange;
-	}
-
-	get type() {
-		return "amd require context";
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-		write(this.valueRange);
-
-		super.serialize(context);
-	}
-
-	deserialize(context) {
-		const { read } = context;
-
-		this.range = read();
-		this.valueRange = read();
+/** @typedef {import("../Chunk")} Chunk */
 
-		super.deserialize(context);
+/**
+ * @param {Entrypoint} entrypoint a chunk group
+ * @param {Chunk} excludedChunk1 current chunk which is excluded
+ * @param {Chunk} excludedChunk2 runtime chunk which is excluded
+ * @returns {Set<Chunk>} chunks
+ */
+const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
+	const queue = new Set([entrypoint]);
+	const chunks = new Set();
+	for (const entrypoint of queue) {
+		for (const chunk of entrypoint.chunks) {
+			if (chunk === excludedChunk1) continue;
+			if (chunk === excludedChunk2) continue;
+			chunks.add(chunk);
+		}
+		for (const parent of entrypoint.parentsIterable) {
+			if (parent instanceof Entrypoint) queue.add(parent);
+		}
 	}
-}
-
-makeSerializable(
-	RequireResolveContextDependency,
-	"webpack/lib/dependencies/RequireResolveContextDependency"
-);
-
-RequireResolveContextDependency.Template = ContextDependencyTemplateAsId;
-
-module.exports = RequireResolveContextDependency;
+	return chunks;
+};
+exports.getAllChunks = getAllChunks;
 
 
 /***/ }),
 
-/***/ 68582:
+/***/ 84508:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -90485,55 +89212,176 @@ module.exports = RequireResolveContextDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-const ModuleDependencyAsId = __webpack_require__(80825);
+const { ConcatSource, RawSource } = __webpack_require__(51255);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const {
+	getChunkFilenameTemplate,
+	getCompilationHooks
+} = __webpack_require__(89464);
+const {
+	generateEntryStartup,
+	updateHashForEntryStartup
+} = __webpack_require__(98124);
 
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../Compiler")} Compiler */
 
-class RequireResolveDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+class CommonJsChunkFormatPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"CommonJsChunkFormatPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"CommonJsChunkLoadingPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (chunk.hasRuntime()) return;
+						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+							set.add(RuntimeGlobals.require);
+							set.add(RuntimeGlobals.startupEntrypoint);
+							set.add(RuntimeGlobals.externalInstallChunk);
+						}
+					}
+				);
+				const hooks = getCompilationHooks(compilation);
+				hooks.renderChunk.tap(
+					"CommonJsChunkFormatPlugin",
+					(modules, renderContext) => {
+						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+						const source = new ConcatSource();
+						source.add(`exports.id = ${JSON.stringify(chunk.id)};\n`);
+						source.add(`exports.ids = ${JSON.stringify(chunk.ids)};\n`);
+						source.add(`exports.modules = `);
+						source.add(modules);
+						source.add(";\n");
+						const runtimeModules =
+							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+						if (runtimeModules.length > 0) {
+							source.add("exports.runtime =\n");
+							source.add(
+								Template.renderChunkRuntimeModules(
+									runtimeModules,
+									renderContext
+								)
+							);
+						}
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						if (entries.length > 0) {
+							const runtimeChunk = entries[0][1].getRuntimeChunk();
+							const currentOutputName = compilation
+								.getPath(
+									getChunkFilenameTemplate(chunk, compilation.outputOptions),
+									{
+										chunk,
+										contentHashType: "javascript"
+									}
+								)
+								.split("/");
+							const runtimeOutputName = compilation
+								.getPath(
+									getChunkFilenameTemplate(
+										runtimeChunk,
+										compilation.outputOptions
+									),
+									{
+										chunk: runtimeChunk,
+										contentHashType: "javascript"
+									}
+								)
+								.split("/");
 
-		this.range = range;
-	}
+							// remove filename, we only need the directory
+							currentOutputName.pop();
 
-	get type() {
-		return "require.resolve";
-	}
+							// remove common parts
+							while (
+								currentOutputName.length > 0 &&
+								runtimeOutputName.length > 0 &&
+								currentOutputName[0] === runtimeOutputName[0]
+							) {
+								currentOutputName.shift();
+								runtimeOutputName.shift();
+							}
 
-	get category() {
-		return "commonjs";
-	}
+							// create final path
+							const runtimePath =
+								(currentOutputName.length > 0
+									? "../".repeat(currentOutputName.length)
+									: "./") + runtimeOutputName.join("/");
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		// This doesn't use any export
-		return Dependency.NO_EXPORTS_REFERENCED;
+							const entrySource = new ConcatSource();
+							entrySource.add(
+								`(${
+									runtimeTemplate.supportsArrowFunction()
+										? "() => "
+										: "function() "
+								}{\n`
+							);
+							entrySource.add("var exports = {};\n");
+							entrySource.add(source);
+							entrySource.add(";\n\n// load runtime\n");
+							entrySource.add(
+								`var __webpack_require__ = require(${JSON.stringify(
+									runtimePath
+								)});\n`
+							);
+							entrySource.add(
+								`${RuntimeGlobals.externalInstallChunk}(exports);\n`
+							);
+							const startupSource = new RawSource(
+								generateEntryStartup(
+									chunkGraph,
+									runtimeTemplate,
+									entries,
+									chunk,
+									false
+								)
+							);
+							entrySource.add(
+								hooks.renderStartup.call(
+									startupSource,
+									entries[entries.length - 1][0],
+									{
+										...renderContext,
+										inlined: false
+									}
+								)
+							);
+							entrySource.add("\n})()");
+							return entrySource;
+						}
+						return source;
+					}
+				);
+				hooks.chunkHash.tap(
+					"CommonJsChunkFormatPlugin",
+					(chunk, hash, { chunkGraph }) => {
+						if (chunk.hasRuntime()) return;
+						hash.update("CommonJsChunkFormatPlugin");
+						hash.update("1");
+						const entries = Array.from(
+							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
+						);
+						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					}
+				);
+			}
+		);
 	}
 }
 
-makeSerializable(
-	RequireResolveDependency,
-	"webpack/lib/dependencies/RequireResolveDependency"
-);
-
-RequireResolveDependency.Template = ModuleDependencyAsId;
-
-module.exports = RequireResolveDependency;
+module.exports = CommonJsChunkFormatPlugin;
 
 
 /***/ }),
 
-/***/ 9880:
+/***/ 61291:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -90544,67 +89392,122 @@ module.exports = RequireResolveDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-
-class RequireResolveHeaderDependency extends NullDependency {
-	constructor(range) {
-		super();
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
+/** @typedef {import("../Compiler")} Compiler */
 
-		if (!Array.isArray(range)) throw new Error("range must be valid");
+/** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
+const enabledTypes = new WeakMap();
 
-		this.range = range;
+const getEnabledTypes = compiler => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
 	}
+	return set;
+};
 
-	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-
-		super.serialize(context);
+class EnableChunkLoadingPlugin {
+	/**
+	 * @param {ChunkLoadingType} type library type that should be available
+	 */
+	constructor(type) {
+		this.type = type;
 	}
 
-	static deserialize(context) {
-		const obj = new RequireResolveHeaderDependency(context.read());
-		obj.deserialize(context);
-		return obj;
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {ChunkLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
 	}
-}
-
-makeSerializable(
-	RequireResolveHeaderDependency,
-	"webpack/lib/dependencies/RequireResolveHeaderDependency"
-);
 
-RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {ChunkLoadingType} type type of library
 	 * @returns {void}
 	 */
-	apply(dependency, source, templateContext) {
-		const dep = /** @type {RequireResolveHeaderDependency} */ (dependency);
-		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Chunk loading type "${type}" is not enabled. ` +
+					"EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. " +
+					'This usually happens through the "output.enabledChunkLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". ' +
+					"These types are enabled: " +
+					Array.from(getEnabledTypes(compiler)).join(", ")
+			);
+		}
 	}
 
-	applyAsTemplateArgument(name, dep, source) {
-		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { type } = this;
+
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
+
+		if (typeof type === "string") {
+			switch (type) {
+				case "jsonp": {
+					const JsonpChunkLoadingPlugin = __webpack_require__(83121);
+					new JsonpChunkLoadingPlugin().apply(compiler);
+					break;
+				}
+				case "import-scripts": {
+					const ImportScriptsChunkLoadingPlugin = __webpack_require__(54182);
+					new ImportScriptsChunkLoadingPlugin().apply(compiler);
+					break;
+				}
+				case "require": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
+					new CommonJsChunkLoadingPlugin({
+						asyncChunkLoading: false
+					}).apply(compiler);
+					break;
+				}
+				case "async-node": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
+					new CommonJsChunkLoadingPlugin({
+						asyncChunkLoading: true
+					}).apply(compiler);
+					break;
+				}
+				case "import": {
+					const ModuleChunkLoadingPlugin = __webpack_require__(89831);
+					new ModuleChunkLoadingPlugin().apply(compiler);
+					break;
+				}
+				case "universal":
+					// TODO implement universal chunk loading
+					throw new Error("Universal Chunk Loading is not implemented yet");
+				default:
+					throw new Error(`Unsupported chunk loading type ${type}.
+Plugins which provide custom chunk loading types must call EnableChunkLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
+			}
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
+		}
 	}
-};
+}
 
-module.exports = RequireResolveHeaderDependency;
+module.exports = EnableChunkLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 24187:
+/***/ 77106:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -90615,155 +89518,229 @@ module.exports = RequireResolveHeaderDependency;
 
 
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+const util = __webpack_require__(73837);
+const { RawSource, ReplaceSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const HarmonyCompatibilityDependency = __webpack_require__(72906);
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
-class RuntimeRequirementsDependency extends NullDependency {
+// TODO: clean up this file
+// replace with newer constructs
+
+const deprecatedGetInitFragments = util.deprecate(
+	(template, dependency, templateContext) =>
+		template.getInitFragments(dependency, templateContext),
+	"DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)",
+	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
+);
+
+const TYPES = new Set(["javascript"]);
+
+class JavascriptGenerator extends Generator {
 	/**
-	 * @param {string[]} runtimeRequirements runtime requirements
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	constructor(runtimeRequirements) {
-		super();
-		this.runtimeRequirements = new Set(runtimeRequirements);
-		this._hashUpdate = undefined;
+	getTypes(module) {
+		return TYPES;
 	}
 
 	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 39;
 		}
-		hash.update(this._hashUpdate);
+		return originalSource.size();
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.runtimeRequirements);
-		super.serialize(context);
-	}
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		// Only harmony modules are valid for optimization
+		if (
+			!module.buildMeta ||
+			module.buildMeta.exportsType !== "namespace" ||
+			module.presentationalDependencies === undefined ||
+			!module.presentationalDependencies.some(
+				d => d instanceof HarmonyCompatibilityDependency
+			)
+		) {
+			return "Module is not an ECMAScript module";
+		}
 
-	deserialize(context) {
-		const { read } = context;
-		this.runtimeRequirements = read();
-		super.deserialize(context);
+		// 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.buildInfo && module.buildInfo.moduleConcatenationBailout) {
+			return `Module uses ${module.buildInfo.moduleConcatenationBailout}`;
+		}
 	}
-}
-
-makeSerializable(
-	RuntimeRequirementsDependency,
-	"webpack/lib/dependencies/RuntimeRequirementsDependency"
-);
 
-RuntimeRequirementsDependency.Template = class RuntimeRequirementsDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	apply(dependency, source, { runtimeRequirements }) {
-		const dep = /** @type {RuntimeRequirementsDependency} */ (dependency);
-		for (const req of dep.runtimeRequirements) {
-			runtimeRequirements.add(req);
+	generate(module, generateContext) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return new RawSource("throw new Error('No source available');");
 		}
-	}
-};
 
-module.exports = RuntimeRequirementsDependency;
+		const source = new ReplaceSource(originalSource);
+		const initFragments = [];
 
+		this.sourceModule(module, initFragments, source, generateContext);
 
-/***/ }),
-
-/***/ 91418:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+		return InitFragment.addToSource(source, initFragments, generateContext);
+	}
 
+	/**
+	 * @param {Module} module the module to generate
+	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {GenerateContext} generateContext the generateContext
+	 * @returns {void}
+	 */
+	sourceModule(module, initFragments, source, generateContext) {
+		for (const dependency of module.dependencies) {
+			this.sourceDependency(
+				module,
+				dependency,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+		if (module.presentationalDependencies !== undefined) {
+			for (const dependency of module.presentationalDependencies) {
+				this.sourceDependency(
+					module,
+					dependency,
+					initFragments,
+					source,
+					generateContext
+				);
+			}
+		}
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
+		for (const childBlock of module.blocks) {
+			this.sourceBlock(
+				module,
+				childBlock,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
+	}
 
-class StaticExportsDependency extends NullDependency {
 	/**
-	 * @param {string[] | true} exports export names
-	 * @param {boolean} canMangle true, if mangling exports names is allowed
+	 * @param {Module} module the module to generate
+	 * @param {DependenciesBlock} block the dependencies block which will be processed
+	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {GenerateContext} generateContext the generateContext
+	 * @returns {void}
 	 */
-	constructor(exports, canMangle) {
-		super();
-		this.exports = exports;
-		this.canMangle = canMangle;
-	}
+	sourceBlock(module, block, initFragments, source, generateContext) {
+		for (const dependency of block.dependencies) {
+			this.sourceDependency(
+				module,
+				dependency,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
 
-	get type() {
-		return "static exports";
+		for (const childBlock of block.blocks) {
+			this.sourceBlock(
+				module,
+				childBlock,
+				initFragments,
+				source,
+				generateContext
+			);
+		}
 	}
 
 	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
+	 * @param {Module} module the current module
+	 * @param {Dependency} dependency the dependency to generate
+	 * @param {InitFragment[]} initFragments mutable list of init fragments
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {GenerateContext} generateContext the render context
+	 * @returns {void}
 	 */
-	getExports(moduleGraph) {
-		return {
-			exports: this.exports,
-			canMangle: this.canMangle,
-			dependencies: undefined
+	sourceDependency(module, dependency, initFragments, source, generateContext) {
+		const constructor = /** @type {new (...args: any[]) => Dependency} */ (
+			dependency.constructor
+		);
+		const template = generateContext.dependencyTemplates.get(constructor);
+		if (!template) {
+			throw new Error(
+				"No template for dependency: " + dependency.constructor.name
+			);
+		}
+
+		const templateContext = {
+			runtimeTemplate: generateContext.runtimeTemplate,
+			dependencyTemplates: generateContext.dependencyTemplates,
+			moduleGraph: generateContext.moduleGraph,
+			chunkGraph: generateContext.chunkGraph,
+			module,
+			runtime: generateContext.runtime,
+			runtimeRequirements: generateContext.runtimeRequirements,
+			concatenationScope: generateContext.concatenationScope,
+			codeGenerationResults: generateContext.codeGenerationResults,
+			initFragments
 		};
-	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.exports);
-		write(this.canMangle);
-		super.serialize(context);
-	}
+		template.apply(dependency, source, templateContext);
 
-	deserialize(context) {
-		const { read } = context;
-		this.exports = read();
-		this.canMangle = read();
-		super.deserialize(context);
+		// TODO remove in webpack 6
+		if ("getInitFragments" in template) {
+			const fragments = deprecatedGetInitFragments(
+				template,
+				dependency,
+				templateContext
+			);
+
+			if (fragments) {
+				for (const fragment of fragments) {
+					initFragments.push(fragment);
+				}
+			}
+		}
 	}
 }
 
-makeSerializable(
-	StaticExportsDependency,
-	"webpack/lib/dependencies/StaticExportsDependency"
-);
-
-module.exports = StaticExportsDependency;
+module.exports = JavascriptGenerator;
 
 
 /***/ }),
 
-/***/ 97981:
+/***/ 89464:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -90774,552 +89751,1349 @@ module.exports = StaticExportsDependency;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
+const { SyncWaterfallHook, SyncHook, SyncBailHook } = __webpack_require__(6967);
+const vm = __webpack_require__(26144);
 const {
-	evaluateToString,
-	expressionIsUnsupported,
-	toConstantDependency
-} = __webpack_require__(93998);
-const makeSerializable = __webpack_require__(33032);
-const ConstDependency = __webpack_require__(76911);
-const SystemRuntimeModule = __webpack_require__(85439);
+	ConcatSource,
+	OriginalSource,
+	PrefixSource,
+	RawSource,
+	CachedSource
+} = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const { tryRunOrWebpackError } = __webpack_require__(11351);
+const HotUpdateChunk = __webpack_require__(9597);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const { last, someInIterable } = __webpack_require__(39104);
+const StringXor = __webpack_require__(40293);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const { intersectRuntime } = __webpack_require__(17156);
+const JavascriptGenerator = __webpack_require__(77106);
+const JavascriptParser = __webpack_require__(29050);
 
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/Hash")} Hash */
 
-class SystemPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"SystemPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.hooks.runtimeRequirementInModule
-					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (module, set) => {
-						set.add(RuntimeGlobals.requireScope);
-					});
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
-					});
-
-				const handler = (parser, parserOptions) => {
-					if (parserOptions.system === undefined || !parserOptions.system) {
-						return;
-					}
+/**
+ * @param {Chunk} chunk a chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true, when a JS file is needed for this chunk
+ */
+const chunkHasJs = (chunk, chunkGraph) => {
+	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
 
-					const setNotSupported = name => {
-						parser.hooks.evaluateTypeof
-							.for(name)
-							.tap("SystemPlugin", evaluateToString("undefined"));
-						parser.hooks.expression
-							.for(name)
-							.tap(
-								"SystemPlugin",
-								expressionIsUnsupported(
-									parser,
-									name + " is not supported by webpack."
-								)
-							);
-					};
+	return chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
+		? true
+		: false;
+};
 
-					parser.hooks.typeof
-						.for("System.import")
-						.tap(
-							"SystemPlugin",
-							toConstantDependency(parser, JSON.stringify("function"))
-						);
-					parser.hooks.evaluateTypeof
-						.for("System.import")
-						.tap("SystemPlugin", evaluateToString("function"));
-					parser.hooks.typeof
-						.for("System")
-						.tap(
-							"SystemPlugin",
-							toConstantDependency(parser, JSON.stringify("object"))
-						);
-					parser.hooks.evaluateTypeof
-						.for("System")
-						.tap("SystemPlugin", evaluateToString("object"));
+const printGeneratedCodeForStack = (module, code) => {
+	const lines = code.split("\n");
+	const n = `${lines.length}`.length;
+	return `\n\nGenerated code for ${module.identifier()}\n${lines
+		.map((line, i, lines) => {
+			const iStr = `${i + 1}`;
+			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
+		})
+		.join("\n")}`;
+};
 
-					setNotSupported("System.set");
-					setNotSupported("System.get");
-					setNotSupported("System.register");
+/**
+ * @typedef {Object} RenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {boolean} strictMode rendering in strict context
+ */
 
-					parser.hooks.expression.for("System").tap("SystemPlugin", expr => {
-						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
-							RuntimeGlobals.system
-						]);
-						dep.loc = expr.loc;
-						parser.state.module.addPresentationalDependency(dep);
-						return true;
-					});
+/**
+ * @typedef {Object} MainRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {string} hash hash to be used for render call
+ * @property {boolean} strictMode rendering in strict context
+ */
 
-					parser.hooks.call.for("System.import").tap("SystemPlugin", expr => {
-						parser.state.module.addWarning(
-							new SystemImportDeprecationWarning(expr.loc)
-						);
+/**
+ * @typedef {Object} ChunkRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
+ * @property {boolean} strictMode rendering in strict context
+ */
 
-						return parser.hooks.importCall.call({
-							type: "ImportExpression",
-							source: expr.arguments[0],
-							loc: expr.loc,
-							range: expr.range
-						});
-					});
-				};
+/**
+ * @typedef {Object} RenderBootstrapContext
+ * @property {Chunk} chunk the chunk
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {string} hash hash to be used for render call
+ */
 
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("SystemPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("SystemPlugin", handler);
-			}
-		);
-	}
-}
+/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
 
-class SystemImportDeprecationWarning extends WebpackError {
-	constructor(loc) {
-		super(
-			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +
-				"For more info visit https://webpack.js.org/guides/code-splitting/"
-		);
+/**
+ * @typedef {Object} CompilationHooks
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} render
+ * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
+ * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
+ * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
+ * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
+ * @property {SyncBailHook<[RenderContext], string>} strictRuntimeBailout
+ * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
+ * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
+ */
 
-		this.name = "SystemImportDeprecationWarning";
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-		this.loc = loc;
+class JavascriptModulesPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				renderModuleContent: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				]),
+				renderModuleContainer: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				]),
+				renderModulePackage: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				]),
+				render: new SyncWaterfallHook(["source", "renderContext"]),
+				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
+				renderStartup: new SyncWaterfallHook([
+					"source",
+					"module",
+					"startupRenderContext"
+				]),
+				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
+				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
+				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
+				inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+				embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+				strictRuntimeBailout: new SyncBailHook(["renderContext"]),
+				chunkHash: new SyncHook(["chunk", "hash", "context"]),
+				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
 	}
-}
-
-makeSerializable(
-	SystemImportDeprecationWarning,
-	"webpack/lib/dependencies/SystemPlugin",
-	"SystemImportDeprecationWarning"
-);
-
-module.exports = SystemPlugin;
-module.exports.SystemImportDeprecationWarning = SystemImportDeprecationWarning;
-
-
-/***/ }),
-
-/***/ 85439:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
 
-class SystemRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("system");
+	constructor(options = {}) {
+		this.options = options;
+		/** @type {WeakMap<Source, TODO>} */
+		this._moduleFactoryCache = new WeakMap();
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.system} = {`,
-			Template.indent([
-				"import: function () {",
-				Template.indent(
-					"throw new Error('System.import cannot be used indirectly');"
-				),
-				"}"
-			]),
-			"};"
-		]);
-	}
-}
-
-module.exports = SystemRuntimeModule;
-
-
-/***/ }),
-
-/***/ 58612:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const {
-	getDependencyUsedByExportsCondition
-} = __webpack_require__(38988);
-const makeSerializable = __webpack_require__(33032);
-const memoize = __webpack_require__(78676);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"JavascriptModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+				normalModuleFactory.hooks.createParser
+					.for("javascript/auto")
+					.tap("JavascriptModulesPlugin", options => {
+						return new JavascriptParser("auto");
+					});
+				normalModuleFactory.hooks.createParser
+					.for("javascript/dynamic")
+					.tap("JavascriptModulesPlugin", options => {
+						return new JavascriptParser("script");
+					});
+				normalModuleFactory.hooks.createParser
+					.for("javascript/esm")
+					.tap("JavascriptModulesPlugin", options => {
+						return new JavascriptParser("module");
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/auto")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/dynamic")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("javascript/esm")
+					.tap("JavascriptModulesPlugin", () => {
+						return new JavascriptGenerator();
+					});
+				compilation.hooks.renderManifest.tap(
+					"JavascriptModulesPlugin",
+					(result, options) => {
+						const {
+							hash,
+							chunk,
+							chunkGraph,
+							moduleGraph,
+							runtimeTemplate,
+							dependencyTemplates,
+							outputOptions,
+							codeGenerationResults
+						} = options;
 
-const getRawDataUrlModule = memoize(() => __webpack_require__(19684));
+						const hotUpdateChunk =
+							chunk instanceof HotUpdateChunk ? chunk : null;
 
-class URLDependency extends ModuleDependency {
-	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
-	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
-	 * @param {boolean=} relative use relative urls instead of absolute with base uri
-	 */
-	constructor(request, range, outerRange, relative) {
-		super(request);
-		this.range = range;
-		this.outerRange = outerRange;
-		this.relative = relative || false;
-		/** @type {Set<string> | boolean} */
-		this.usedByExports = undefined;
-	}
+						let render;
+						const filenameTemplate =
+							JavascriptModulesPlugin.getChunkFilenameTemplate(
+								chunk,
+								outputOptions
+							);
+						if (hotUpdateChunk) {
+							render = () =>
+								this.renderChunk(
+									{
+										chunk,
+										dependencyTemplates,
+										runtimeTemplate,
+										moduleGraph,
+										chunkGraph,
+										codeGenerationResults,
+										strictMode: runtimeTemplate.isModule()
+									},
+									hooks
+								);
+						} else if (chunk.hasRuntime()) {
+							render = () =>
+								this.renderMain(
+									{
+										hash,
+										chunk,
+										dependencyTemplates,
+										runtimeTemplate,
+										moduleGraph,
+										chunkGraph,
+										codeGenerationResults,
+										strictMode: runtimeTemplate.isModule()
+									},
+									hooks,
+									compilation
+								);
+						} else {
+							if (!chunkHasJs(chunk, chunkGraph)) {
+								return result;
+							}
 
-	get type() {
-		return "new URL()";
-	}
+							render = () =>
+								this.renderChunk(
+									{
+										chunk,
+										dependencyTemplates,
+										runtimeTemplate,
+										moduleGraph,
+										chunkGraph,
+										codeGenerationResults,
+										strictMode: runtimeTemplate.isModule()
+									},
+									hooks
+								);
+						}
 
-	get category() {
-		return "url";
-	}
+						result.push({
+							render,
+							filenameTemplate,
+							pathOptions: {
+								hash,
+								runtime: chunk.runtime,
+								chunk,
+								contentHashType: "javascript"
+							},
+							info: {
+								javascriptModule: compilation.runtimeTemplate.isModule()
+							},
+							identifier: hotUpdateChunk
+								? `hotupdatechunk${chunk.id}`
+								: `chunk${chunk.id}`,
+							hash: chunk.contentHash.javascript
+						});
 
-	/**
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
-	 */
-	getCondition(moduleGraph) {
-		return getDependencyUsedByExportsCondition(
-			this,
-			this.usedByExports,
-			moduleGraph
-		);
-	}
+						return result;
+					}
+				);
+				compilation.hooks.chunkHash.tap(
+					"JavascriptModulesPlugin",
+					(chunk, hash, context) => {
+						hooks.chunkHash.call(chunk, hash, context);
+						if (chunk.hasRuntime()) {
+							this.updateHashWithBootstrap(
+								hash,
+								{
+									hash: "0000",
+									chunk,
+									chunkGraph: context.chunkGraph,
+									moduleGraph: context.moduleGraph,
+									runtimeTemplate: context.runtimeTemplate
+								},
+								hooks
+							);
+						}
+					}
+				);
+				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+					const {
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						outputOptions: {
+							hashSalt,
+							hashDigest,
+							hashDigestLength,
+							hashFunction
+						}
+					} = compilation;
+					const hash = createHash(hashFunction);
+					if (hashSalt) hash.update(hashSalt);
+					if (chunk.hasRuntime()) {
+						this.updateHashWithBootstrap(
+							hash,
+							{
+								hash: "0000",
+								chunk,
+								chunkGraph: compilation.chunkGraph,
+								moduleGraph: compilation.moduleGraph,
+								runtimeTemplate: compilation.runtimeTemplate
+							},
+							hooks
+						);
+					} else {
+						hash.update(`${chunk.id} `);
+						hash.update(chunk.ids ? chunk.ids.join(",") : "");
+					}
+					hooks.chunkHash.call(chunk, hash, {
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate
+					});
+					const modules = chunkGraph.getChunkModulesIterableBySourceType(
+						chunk,
+						"javascript"
+					);
+					if (modules) {
+						const xor = new StringXor();
+						for (const m of modules) {
+							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+						}
+						xor.updateHash(hash);
+					}
+					const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(
+						chunk,
+						"runtime"
+					);
+					if (runtimeModules) {
+						const xor = new StringXor();
+						for (const m of runtimeModules) {
+							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
+						}
+						xor.updateHash(hash);
+					}
+					const digest = /** @type {string} */ (hash.digest(hashDigest));
+					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
+				});
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"JavascriptModulesPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (
+							!set.has(RuntimeGlobals.startupNoDefault) &&
+							chunkGraph.hasChunkEntryDependentChunks(chunk)
+						) {
+							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.require);
+						}
+					}
+				);
+				compilation.hooks.executeModule.tap(
+					"JavascriptModulesPlugin",
+					(options, context) => {
+						const source =
+							options.codeGenerationResult.sources.get("javascript");
+						if (source === undefined) return;
+						const { module, moduleObject } = options;
+						const code = source.source();
 
-	/**
-	 * @param {string} context context directory
-	 * @returns {Module} a module
-	 */
-	createIgnoredModule(context) {
-		const RawDataUrlModule = getRawDataUrlModule();
-		return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
-	}
+						const fn = vm.runInThisContext(
+							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
+							{
+								filename: module.identifier(),
+								lineOffset: -1
+							}
+						);
+						try {
+							fn.call(
+								moduleObject.exports,
+								moduleObject,
+								moduleObject.exports,
+								context.__webpack_require__
+							);
+						} catch (e) {
+							e.stack += printGeneratedCodeForStack(options.module, code);
+							throw e;
+						}
+					}
+				);
+				compilation.hooks.executeModule.tap(
+					"JavascriptModulesPlugin",
+					(options, context) => {
+						const source = options.codeGenerationResult.sources.get("runtime");
+						if (source === undefined) return;
+						let code = source.source();
+						if (typeof code !== "string") code = code.toString();
 
-	serialize(context) {
-		const { write } = context;
-		write(this.outerRange);
-		write(this.relative);
-		write(this.usedByExports);
-		super.serialize(context);
+						const fn = vm.runInThisContext(
+							`(function(__webpack_require__) {\n${code}\n/**/})`,
+							{
+								filename: options.module.identifier(),
+								lineOffset: -1
+							}
+						);
+						try {
+							fn.call(null, context.__webpack_require__);
+						} catch (e) {
+							e.stack += printGeneratedCodeForStack(options.module, code);
+							throw e;
+						}
+					}
+				);
+			}
+		);
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.outerRange = read();
-		this.relative = read();
-		this.usedByExports = read();
-		super.deserialize(context);
+	static getChunkFilenameTemplate(chunk, outputOptions) {
+		if (chunk.filenameTemplate) {
+			return chunk.filenameTemplate;
+		} else if (chunk instanceof HotUpdateChunk) {
+			return outputOptions.hotUpdateChunkFilename;
+		} else if (chunk.canBeInitial()) {
+			return outputOptions.filename;
+		} else {
+			return outputOptions.chunkFilename;
+		}
 	}
-}
 
-URLDependency.Template = class URLDependencyTemplate extends (
-	ModuleDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {Module} module the rendered module
+	 * @param {ChunkRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @param {boolean} factory true: renders as factory method, false: pure module content
+	 * @returns {Source} the newly generated source from rendering
 	 */
-	apply(dependency, source, templateContext) {
+	renderModule(module, renderContext, hooks, factory) {
 		const {
+			chunk,
 			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
 			runtimeTemplate,
-			runtime
-		} = templateContext;
-		const dep = /** @type {URLDependency} */ (dependency);
-		const connection = moduleGraph.getConnection(dep);
-		// Skip rendering depending when dependency is conditional
-		if (connection && !connection.isTargetActive(runtime)) {
-			source.replace(
-				dep.outerRange[0],
-				dep.outerRange[1] - 1,
-				"/* unused asset import */ undefined"
-			);
-			return;
-		}
-
-		runtimeRequirements.add(RuntimeGlobals.require);
-
-		if (dep.relative) {
-			runtimeRequirements.add(RuntimeGlobals.relativeUrl);
-			source.replace(
-				dep.outerRange[0],
-				dep.outerRange[1] - 1,
-				`/* asset import */ new ${
-					RuntimeGlobals.relativeUrl
-				}(${runtimeTemplate.moduleRaw({
-					chunkGraph,
-					module: moduleGraph.getModule(dep),
-					request: dep.request,
-					runtimeRequirements,
-					weak: false
-				})})`
+			codeGenerationResults,
+			strictMode
+		} = renderContext;
+		try {
+			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+			const moduleSource = codeGenResult.sources.get("javascript");
+			if (!moduleSource) return null;
+			if (codeGenResult.data !== undefined) {
+				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
+				if (chunkInitFragments) {
+					for (const i of chunkInitFragments)
+						renderContext.chunkInitFragments.push(i);
+				}
+			}
+			const moduleSourcePostContent = tryRunOrWebpackError(
+				() =>
+					hooks.renderModuleContent.call(moduleSource, module, renderContext),
+				"JavascriptModulesPlugin.getCompilationHooks().renderModuleContent"
 			);
-		} else {
-			runtimeRequirements.add(RuntimeGlobals.baseURI);
-
-			source.replace(
-				dep.range[0],
-				dep.range[1] - 1,
-				`/* asset import */ ${runtimeTemplate.moduleRaw({
-					chunkGraph,
-					module: moduleGraph.getModule(dep),
-					request: dep.request,
-					runtimeRequirements,
-					weak: false
-				})}, ${RuntimeGlobals.baseURI}`
+			let moduleSourcePostContainer;
+			if (factory) {
+				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+					module,
+					chunk.runtime
+				);
+				const needModule = runtimeRequirements.has(RuntimeGlobals.module);
+				const needExports = runtimeRequirements.has(RuntimeGlobals.exports);
+				const needRequire =
+					runtimeRequirements.has(RuntimeGlobals.require) ||
+					runtimeRequirements.has(RuntimeGlobals.requireScope);
+				const needThisAsExports = runtimeRequirements.has(
+					RuntimeGlobals.thisAsExports
+				);
+				const needStrict = module.buildInfo.strict && !strictMode;
+				const cacheEntry = this._moduleFactoryCache.get(
+					moduleSourcePostContent
+				);
+				let source;
+				if (
+					cacheEntry &&
+					cacheEntry.needModule === needModule &&
+					cacheEntry.needExports === needExports &&
+					cacheEntry.needRequire === needRequire &&
+					cacheEntry.needThisAsExports === needThisAsExports &&
+					cacheEntry.needStrict === needStrict
+				) {
+					source = cacheEntry.source;
+				} else {
+					const factorySource = new ConcatSource();
+					const args = [];
+					if (needExports || needRequire || needModule)
+						args.push(
+							needModule
+								? module.moduleArgument
+								: "__unused_webpack_" + module.moduleArgument
+						);
+					if (needExports || needRequire)
+						args.push(
+							needExports
+								? module.exportsArgument
+								: "__unused_webpack_" + module.exportsArgument
+						);
+					if (needRequire) args.push("__webpack_require__");
+					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
+						factorySource.add("/***/ ((" + args.join(", ") + ") => {\n\n");
+					} else {
+						factorySource.add("/***/ (function(" + args.join(", ") + ") {\n\n");
+					}
+					if (needStrict) {
+						factorySource.add('"use strict";\n');
+					}
+					factorySource.add(moduleSourcePostContent);
+					factorySource.add("\n\n/***/ })");
+					source = new CachedSource(factorySource);
+					this._moduleFactoryCache.set(moduleSourcePostContent, {
+						source,
+						needModule,
+						needExports,
+						needRequire,
+						needThisAsExports,
+						needStrict
+					});
+				}
+				moduleSourcePostContainer = tryRunOrWebpackError(
+					() => hooks.renderModuleContainer.call(source, module, renderContext),
+					"JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer"
+				);
+			} else {
+				moduleSourcePostContainer = moduleSourcePostContent;
+			}
+			return tryRunOrWebpackError(
+				() =>
+					hooks.renderModulePackage.call(
+						moduleSourcePostContainer,
+						module,
+						renderContext
+					),
+				"JavascriptModulesPlugin.getCompilationHooks().renderModulePackage"
 			);
+		} catch (e) {
+			e.module = module;
+			throw e;
 		}
 	}
-};
-
-makeSerializable(URLDependency, "webpack/lib/dependencies/URLDependency");
-
-module.exports = URLDependency;
-
 
-/***/ }),
-
-/***/ 14412:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const { approve } = __webpack_require__(93998);
-const InnerGraph = __webpack_require__(38988);
-const URLDependency = __webpack_require__(58612);
-
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-
-class URLPlugin {
 	/**
-	 * @param {Compiler} compiler compiler
+	 * @param {RenderContext} renderContext the render context
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {Source} the rendered source
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"URLPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
-				compilation.dependencyTemplates.set(
-					URLDependency,
-					new URLDependency.Template()
-				);
-
-				/**
-				 * @param {JavascriptParser} parser parser
-				 * @param {object} parserOptions options
-				 */
-				const parserCallback = (parser, parserOptions) => {
-					if (parserOptions.url === false) return;
-					const relative = parserOptions.url === "relative";
+	renderChunk(renderContext, hooks) {
+		const { chunk, chunkGraph } = renderContext;
+		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+			chunk,
+			"javascript",
+			compareModulesByIdentifier
+		);
+		const allModules = modules ? Array.from(modules) : [];
+		let strictHeader;
+		let allStrict = renderContext.strictMode;
+		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+			strictHeader = strictBailout
+				? `// runtime can't be in strict mode because ${strictBailout}.\n`
+				: '"use strict";\n';
+			if (!strictBailout) allStrict = true;
+		}
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: [],
+			strictMode: allStrict
+		};
+		const moduleSources =
+			Template.renderChunkModules(chunkRenderContext, allModules, module =>
+				this.renderModule(module, chunkRenderContext, hooks, true)
+			) || new RawSource("{}");
+		let source = tryRunOrWebpackError(
+			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderChunk"
+		);
+		source = tryRunOrWebpackError(
+			() => hooks.renderContent.call(source, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		source = InitFragment.addToSource(
+			source,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
+		source = tryRunOrWebpackError(
+			() => hooks.render.call(source, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().render"
+		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
+			);
+		}
+		chunk.rendered = true;
+		return strictHeader
+			? new ConcatSource(strictHeader, source, ";")
+			: renderContext.runtimeTemplate.isModule()
+			? source
+			: new ConcatSource(source, ";");
+	}
 
-					/**
-					 * @param {NewExpressionNode} expr expression
-					 * @returns {undefined | string} request
-					 */
-					const getUrlRequest = expr => {
-						if (expr.arguments.length !== 2) return;
+	/**
+	 * @param {MainRenderContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Source} the newly generated source from rendering
+	 */
+	renderMain(renderContext, hooks, compilation) {
+		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 
-						const [arg1, arg2] = expr.arguments;
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+		const iife = runtimeTemplate.isIIFE();
 
-						if (
-							arg2.type !== "MemberExpression" ||
-							arg1.type === "SpreadElement"
-						)
-							return;
+		const bootstrap = this.renderBootstrap(renderContext, hooks);
+		const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
 
-						const chain = parser.extractMemberExpressionChain(arg2);
+		const allModules = Array.from(
+			chunkGraph.getOrderedChunkModulesIterableBySourceType(
+				chunk,
+				"javascript",
+				compareModulesByIdentifier
+			) || []
+		);
 
-						if (
-							chain.members.length !== 1 ||
-							chain.object.type !== "MetaProperty" ||
-							chain.object.meta.name !== "import" ||
-							chain.object.property.name !== "meta" ||
-							chain.members[0] !== "url"
-						)
-							return;
+		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
+		let inlinedModules;
+		if (bootstrap.allowInlineStartup && hasEntryModules) {
+			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
+		}
 
-						const request = parser.evaluateExpression(arg1).asString();
+		let source = new ConcatSource();
+		let prefix;
+		if (iife) {
+			if (runtimeTemplate.supportsArrowFunction()) {
+				source.add("/******/ (() => { // webpackBootstrap\n");
+			} else {
+				source.add("/******/ (function() { // webpackBootstrap\n");
+			}
+			prefix = "/******/ \t";
+		} else {
+			prefix = "/******/ ";
+		}
+		let allStrict = renderContext.strictMode;
+		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
+			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+			if (strictBailout) {
+				source.add(
+					prefix +
+						`// runtime can't be in strict mode because ${strictBailout}.\n`
+				);
+			} else {
+				allStrict = true;
+				source.add(prefix + '"use strict";\n');
+			}
+		}
 
-						return request;
-					};
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: [],
+			strictMode: allStrict
+		};
 
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
+		const chunkModules = Template.renderChunkModules(
+			chunkRenderContext,
+			inlinedModules
+				? allModules.filter(m => !inlinedModules.has(m))
+				: allModules,
+			module => this.renderModule(module, chunkRenderContext, hooks, true),
+			prefix
+		);
+		if (
+			chunkModules ||
+			runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
+			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
+			runtimeRequirements.has(RuntimeGlobals.require)
+		) {
+			source.add(prefix + "var __webpack_modules__ = (");
+			source.add(chunkModules || "{}");
+			source.add(");\n");
+			source.add(
+				"/************************************************************************/\n"
+			);
+		}
 
-						const request = getUrlRequest(expr);
+		if (bootstrap.header.length > 0) {
+			const header = Template.asString(bootstrap.header) + "\n";
+			source.add(
+				new PrefixSource(
+					prefix,
+					useSourceMap
+						? new OriginalSource(header, "webpack/bootstrap")
+						: new RawSource(header)
+				)
+			);
+			source.add(
+				"/************************************************************************/\n"
+			);
+		}
 
-						if (!request) return;
+		const runtimeModules =
+			renderContext.chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 
-						const [arg1, arg2] = expr.arguments;
-						const dep = new URLDependency(
-							request,
-							[arg1.range[0], arg2.range[1]],
-							expr.range,
-							relative
+		if (runtimeModules.length > 0) {
+			source.add(
+				new PrefixSource(
+					prefix,
+					Template.renderRuntimeModules(runtimeModules, chunkRenderContext)
+				)
+			);
+			source.add(
+				"/************************************************************************/\n"
+			);
+			// runtimeRuntimeModules calls codeGeneration
+			for (const module of runtimeModules) {
+				compilation.codeGeneratedModules.add(module);
+			}
+		}
+		if (inlinedModules) {
+			if (bootstrap.beforeStartup.length > 0) {
+				const beforeStartup = Template.asString(bootstrap.beforeStartup) + "\n";
+				source.add(
+					new PrefixSource(
+						prefix,
+						useSourceMap
+							? new OriginalSource(beforeStartup, "webpack/before-startup")
+							: new RawSource(beforeStartup)
+					)
+				);
+			}
+			const lastInlinedModule = last(inlinedModules);
+			const startupSource = new ConcatSource();
+			startupSource.add(`var __webpack_exports__ = {};\n`);
+			for (const m of inlinedModules) {
+				const renderedModule = this.renderModule(
+					m,
+					chunkRenderContext,
+					hooks,
+					false
+				);
+				if (renderedModule) {
+					const innerStrict = !allStrict && m.buildInfo.strict;
+					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+						m,
+						chunk.runtime
+					);
+					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
+					const webpackExports =
+						exports && m.exportsArgument === "__webpack_exports__";
+					let iife = innerStrict
+						? "it need to be in strict mode."
+						: inlinedModules.size > 1
+						? // TODO check globals and top-level declarations of other entries and chunk modules
+						  // to make a better decision
+						  "it need to be isolated against other entry modules."
+						: chunkModules
+						? "it need to be isolated against other modules in the chunk."
+						: exports && !webpackExports
+						? `it uses a non-standard name for the exports (${m.exportsArgument}).`
+						: hooks.embedInRuntimeBailout.call(m, renderContext);
+					let footer;
+					if (iife !== undefined) {
+						startupSource.add(
+							`// This entry need to be wrapped in an IIFE because ${iife}\n`
 						);
-						dep.loc = expr.loc;
-						parser.state.current.addDependency(dep);
-						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-						return true;
-					});
-					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
-						const { callee } = expr;
-						if (callee.type !== "Identifier") return;
-						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
-						if (!calleeInfo || calleeInfo.name !== "URL") return;
-
-						const request = getUrlRequest(expr);
-
-						if (request) return true;
-					});
-				};
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("URLPlugin", parserCallback);
-
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("URLPlugin", parserCallback);
+						const arrow = runtimeTemplate.supportsArrowFunction();
+						if (arrow) {
+							startupSource.add("(() => {\n");
+							footer = "\n})();\n\n";
+						} else {
+							startupSource.add("!function() {\n");
+							footer = "\n}();\n";
+						}
+						if (innerStrict) startupSource.add('"use strict";\n');
+					} else {
+						footer = "\n";
+					}
+					if (exports) {
+						if (m !== lastInlinedModule)
+							startupSource.add(`var ${m.exportsArgument} = {};\n`);
+						else if (m.exportsArgument !== "__webpack_exports__")
+							startupSource.add(
+								`var ${m.exportsArgument} = __webpack_exports__;\n`
+							);
+					}
+					startupSource.add(renderedModule);
+					startupSource.add(footer);
+				}
+			}
+			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+				startupSource.add(
+					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
+				);
+			}
+			source.add(
+				hooks.renderStartup.call(startupSource, lastInlinedModule, {
+					...renderContext,
+					inlined: true
+				})
+			);
+			if (bootstrap.afterStartup.length > 0) {
+				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
+				source.add(
+					new PrefixSource(
+						prefix,
+						useSourceMap
+							? new OriginalSource(afterStartup, "webpack/after-startup")
+							: new RawSource(afterStartup)
+					)
+				);
 			}
+		} else {
+			const lastEntryModule = last(
+				chunkGraph.getChunkEntryModulesIterable(chunk)
+			);
+			const toSource = useSourceMap
+				? (content, name) =>
+						new OriginalSource(Template.asString(content), name)
+				: content => new RawSource(Template.asString(content));
+			source.add(
+				new PrefixSource(
+					prefix,
+					new ConcatSource(
+						toSource(bootstrap.beforeStartup, "webpack/before-startup"),
+						"\n",
+						hooks.renderStartup.call(
+							toSource(bootstrap.startup.concat(""), "webpack/startup"),
+							lastEntryModule,
+							{
+								...renderContext,
+								inlined: false
+							}
+						),
+						toSource(bootstrap.afterStartup, "webpack/after-startup"),
+						"\n"
+					)
+				)
+			);
+		}
+		if (
+			hasEntryModules &&
+			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
+		) {
+			source.add(`${prefix}return __webpack_exports__;\n`);
+		}
+		if (iife) {
+			source.add("/******/ })()\n");
+		}
+
+		/** @type {Source} */
+		let finalSource = tryRunOrWebpackError(
+			() => hooks.renderMain.call(source, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderMain"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something"
+			);
+		}
+		finalSource = tryRunOrWebpackError(
+			() => hooks.renderContent.call(finalSource, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		finalSource = InitFragment.addToSource(
+			finalSource,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
+		finalSource = tryRunOrWebpackError(
+			() => hooks.render.call(finalSource, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().render"
 		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
+			);
+		}
+		chunk.rendered = true;
+		return iife ? new ConcatSource(finalSource, ";") : finalSource;
 	}
-}
 
-module.exports = URLPlugin;
+	/**
+	 * @param {Hash} hash the hash to be updated
+	 * @param {RenderBootstrapContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 */
+	updateHashWithBootstrap(hash, renderContext, hooks) {
+		const bootstrap = this.renderBootstrap(renderContext, hooks);
+		for (const key of Object.keys(bootstrap)) {
+			hash.update(key);
+			if (Array.isArray(bootstrap[key])) {
+				for (const line of bootstrap[key]) {
+					hash.update(line);
+				}
+			} else {
+				hash.update(JSON.stringify(bootstrap[key]));
+			}
+		}
+	}
 
+	/**
+	 * @param {RenderBootstrapContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
+	 */
+	renderBootstrap(renderContext, hooks) {
+		const { chunkGraph, moduleGraph, chunk, runtimeTemplate } = renderContext;
 
-/***/ }),
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
-/***/ 51669:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const requireFunction = runtimeRequirements.has(RuntimeGlobals.require);
+		const moduleCache = runtimeRequirements.has(RuntimeGlobals.moduleCache);
+		const moduleFactories = runtimeRequirements.has(
+			RuntimeGlobals.moduleFactories
+		);
+		const moduleUsed = runtimeRequirements.has(RuntimeGlobals.module);
+		const requireScopeUsed = runtimeRequirements.has(
+			RuntimeGlobals.requireScope
+		);
+		const interceptModuleExecution = runtimeRequirements.has(
+			RuntimeGlobals.interceptModuleExecution
+		);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const useRequire =
+			requireFunction || interceptModuleExecution || moduleUsed;
 
+		const result = {
+			header: [],
+			beforeStartup: [],
+			startup: [],
+			afterStartup: [],
+			allowInlineStartup: true
+		};
 
+		let { header: buf, startup, beforeStartup, afterStartup } = result;
 
-const makeSerializable = __webpack_require__(33032);
-const NullDependency = __webpack_require__(31830);
+		if (result.allowInlineStartup && moduleFactories) {
+			startup.push(
+				"// module factories are used so entry inlining is disabled"
+			);
+			result.allowInlineStartup = false;
+		}
+		if (result.allowInlineStartup && moduleCache) {
+			startup.push("// module cache are used so entry inlining is disabled");
+			result.allowInlineStartup = false;
+		}
+		if (result.allowInlineStartup && interceptModuleExecution) {
+			startup.push(
+				"// module execution is intercepted so entry inlining is disabled"
+			);
+			result.allowInlineStartup = false;
+		}
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+		if (useRequire || moduleCache) {
+			buf.push("// The module cache");
+			buf.push("var __webpack_module_cache__ = {};");
+			buf.push("");
+		}
 
-class UnsupportedDependency extends NullDependency {
-	constructor(request, range) {
-		super();
-
-		this.request = request;
-		this.range = range;
-	}
-
-	serialize(context) {
-		const { write } = context;
-
-		write(this.request);
-		write(this.range);
+		if (useRequire) {
+			buf.push("// The require function");
+			buf.push(`function __webpack_require__(moduleId) {`);
+			buf.push(Template.indent(this.renderRequire(renderContext, hooks)));
+			buf.push("}");
+			buf.push("");
+		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
+			buf.push("// The require scope");
+			buf.push("var __webpack_require__ = {};");
+			buf.push("");
+		}
 
-		super.serialize(context);
-	}
+		if (
+			moduleFactories ||
+			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)
+		) {
+			buf.push("// expose the modules object (__webpack_modules__)");
+			buf.push(`${RuntimeGlobals.moduleFactories} = __webpack_modules__;`);
+			buf.push("");
+		}
 
-	deserialize(context) {
-		const { read } = context;
+		if (moduleCache) {
+			buf.push("// expose the module cache");
+			buf.push(`${RuntimeGlobals.moduleCache} = __webpack_module_cache__;`);
+			buf.push("");
+		}
 
-		this.request = read();
-		this.range = read();
+		if (interceptModuleExecution) {
+			buf.push("// expose the module execution interceptor");
+			buf.push(`${RuntimeGlobals.interceptModuleExecution} = [];`);
+			buf.push("");
+		}
 
-		super.deserialize(context);
+		if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
+			if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+				/** @type {string[]} */
+				const buf2 = [];
+				const runtimeRequirements =
+					chunkGraph.getTreeRuntimeRequirements(chunk);
+				buf2.push("// Load entry module and return exports");
+				let i = chunkGraph.getNumberOfEntryModules(chunk);
+				for (const [
+					entryModule,
+					entrypoint
+				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+					const chunks = entrypoint.chunks.filter(c => c !== chunk);
+					if (result.allowInlineStartup && chunks.length > 0) {
+						buf2.push(
+							"// This entry module depends on other loaded chunks and execution need to be delayed"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (
+						result.allowInlineStartup &&
+						someInIterable(
+							moduleGraph.getIncomingConnectionsByOriginModule(entryModule),
+							([originModule, connections]) =>
+								originModule &&
+								connections.some(c => c.isTargetActive(chunk.runtime)) &&
+								someInIterable(
+									chunkGraph.getModuleRuntimes(originModule),
+									runtime =>
+										intersectRuntime(runtime, chunk.runtime) !== undefined
+								)
+						)
+					) {
+						buf2.push(
+							"// This entry module is referenced by other modules so it can't be inlined"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (
+						result.allowInlineStartup &&
+						(!entryModule.buildInfo ||
+							!entryModule.buildInfo.topLevelDeclarations)
+					) {
+						buf2.push(
+							"// This entry module doesn't tell about it's top-level declarations so it can't be inlined"
+						);
+						result.allowInlineStartup = false;
+					}
+					if (result.allowInlineStartup) {
+						const bailout = hooks.inlineInRuntimeBailout.call(
+							entryModule,
+							renderContext
+						);
+						if (bailout !== undefined) {
+							buf2.push(
+								`// This entry module can't be inlined because ${bailout}`
+							);
+							result.allowInlineStartup = false;
+						}
+					}
+					i--;
+					const moduleId = chunkGraph.getModuleId(entryModule);
+					const entryRuntimeRequirements =
+						chunkGraph.getModuleRuntimeRequirements(entryModule, chunk.runtime);
+					let moduleIdExpr = JSON.stringify(moduleId);
+					if (runtimeRequirements.has(RuntimeGlobals.entryModuleId)) {
+						moduleIdExpr = `${RuntimeGlobals.entryModuleId} = ${moduleIdExpr}`;
+					}
+					if (
+						result.allowInlineStartup &&
+						entryRuntimeRequirements.has(RuntimeGlobals.module)
+					) {
+						result.allowInlineStartup = false;
+						buf2.push(
+							"// This entry module used 'module' so it can't be inlined"
+						);
+					}
+					if (chunks.length > 0) {
+						buf2.push(
+							`${i === 0 ? "var __webpack_exports__ = " : ""}${
+								RuntimeGlobals.onChunksLoaded
+							}(undefined, ${JSON.stringify(
+								chunks.map(c => c.id)
+							)}, ${runtimeTemplate.returningFunction(
+								`__webpack_require__(${moduleIdExpr})`
+							)})`
+						);
+					} else if (useRequire) {
+						buf2.push(
+							`${
+								i === 0 ? "var __webpack_exports__ = " : ""
+							}__webpack_require__(${moduleIdExpr});`
+						);
+					} else {
+						if (i === 0) buf2.push("var __webpack_exports__ = {};");
+						if (requireScopeUsed) {
+							buf2.push(
+								`__webpack_modules__[${moduleIdExpr}](0, ${
+									i === 0 ? "__webpack_exports__" : "{}"
+								}, __webpack_require__);`
+							);
+						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
+							buf2.push(
+								`__webpack_modules__[${moduleIdExpr}](0, ${
+									i === 0 ? "__webpack_exports__" : "{}"
+								});`
+							);
+						} else {
+							buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
+						}
+					}
+				}
+				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+					buf2.push(
+						`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);`
+					);
+				}
+				if (
+					runtimeRequirements.has(RuntimeGlobals.startup) ||
+					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
+						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))
+				) {
+					result.allowInlineStartup = false;
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
+							...buf2,
+							"return __webpack_exports__;"
+						])};`
+					);
+					buf.push("");
+					startup.push("// run startup");
+					startup.push(
+						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
+					);
+				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+					);
+					beforeStartup.push("// run runtime startup");
+					beforeStartup.push(`${RuntimeGlobals.startup}();`);
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+					);
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+					afterStartup.push("// run runtime startup");
+					afterStartup.push(`${RuntimeGlobals.startup}();`);
+				} else {
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+				}
+			} else if (
+				runtimeRequirements.has(RuntimeGlobals.startup) ||
+				runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+				runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+			) {
+				buf.push(
+					"// the startup function",
+					"// It's empty as no entry modules are in this chunk",
+					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`,
+					""
+				);
+			}
+		} else if (
+			runtimeRequirements.has(RuntimeGlobals.startup) ||
+			runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+			runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+		) {
+			result.allowInlineStartup = false;
+			buf.push(
+				"// the startup function",
+				"// It's empty as some runtime module handles the default behavior",
+				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+			);
+			startup.push("// run startup");
+			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
+		}
+		return result;
 	}
-}
 
-makeSerializable(
-	UnsupportedDependency,
-	"webpack/lib/dependencies/UnsupportedDependency"
-);
-
-UnsupportedDependency.Template = class UnsupportedDependencyTemplate extends (
-	NullDependency.Template
-) {
 	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
+	 * @param {RenderBootstrapContext} renderContext options object
+	 * @param {CompilationHooks} hooks hooks
+	 * @returns {string} the generated source of the require function
 	 */
-	apply(dependency, source, { runtimeTemplate }) {
-		const dep = /** @type {UnsupportedDependency} */ (dependency);
-
-		source.replace(
-			dep.range[0],
-			dep.range[1],
-			runtimeTemplate.missingModule({
-				request: dep.request
-			})
+	renderRequire(renderContext, hooks) {
+		const {
+			chunk,
+			chunkGraph,
+			runtimeTemplate: { outputOptions }
+		} = renderContext;
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+		const moduleExecution = runtimeRequirements.has(
+			RuntimeGlobals.interceptModuleExecution
+		)
+			? Template.asString([
+					"var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };",
+					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
+					"module = execOptions.module;",
+					"execOptions.factory.call(module.exports, module, module.exports, execOptions.require);"
+			  ])
+			: runtimeRequirements.has(RuntimeGlobals.thisAsExports)
+			? Template.asString([
+					"__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);"
+			  ])
+			: Template.asString([
+					"__webpack_modules__[moduleId](module, module.exports, __webpack_require__);"
+			  ]);
+		const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
+		const needModuleLoaded = runtimeRequirements.has(
+			RuntimeGlobals.moduleLoaded
+		);
+		const content = Template.asString([
+			"// Check if module is in cache",
+			"var cachedModule = __webpack_module_cache__[moduleId];",
+			"if (cachedModule !== undefined) {",
+			outputOptions.strictModuleErrorHandling
+				? Template.indent([
+						"if (cachedModule.error !== undefined) throw cachedModule.error;",
+						"return cachedModule.exports;"
+				  ])
+				: Template.indent("return cachedModule.exports;"),
+			"}",
+			"// Create a new module (and put it into the cache)",
+			"var module = __webpack_module_cache__[moduleId] = {",
+			Template.indent([
+				needModuleId ? "id: moduleId," : "// no module.id needed",
+				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
+				"exports: {}"
+			]),
+			"};",
+			"",
+			outputOptions.strictModuleExceptionHandling
+				? Template.asString([
+						"// Execute the module function",
+						"var threw = true;",
+						"try {",
+						Template.indent([moduleExecution, "threw = false;"]),
+						"} finally {",
+						Template.indent([
+							"if(threw) delete __webpack_module_cache__[moduleId];"
+						]),
+						"}"
+				  ])
+				: outputOptions.strictModuleErrorHandling
+				? Template.asString([
+						"// Execute the module function",
+						"try {",
+						Template.indent(moduleExecution),
+						"} catch(e) {",
+						Template.indent(["module.error = e;", "throw e;"]),
+						"}"
+				  ])
+				: Template.asString([
+						"// Execute the module function",
+						moduleExecution
+				  ]),
+			needModuleLoaded
+				? Template.asString([
+						"",
+						"// Flag the module as loaded",
+						"module.loaded = true;",
+						""
+				  ])
+				: "",
+			"// Return the exports of the module",
+			"return module.exports;"
+		]);
+		return tryRunOrWebpackError(
+			() => hooks.renderRequire.call(content, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderRequire"
 		);
 	}
-};
+}
 
-module.exports = UnsupportedDependency;
+module.exports = JavascriptModulesPlugin;
+module.exports.chunkHasJs = chunkHasJs;
 
 
 /***/ }),
 
-/***/ 52204:
+/***/ 29050:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -91330,2667 +91104,3780 @@ module.exports = UnsupportedDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+const { Parser: AcornParser } = __webpack_require__(31988);
+const { importAssertions } = __webpack_require__(72617);
+const { SyncBailHook, HookMap } = __webpack_require__(6967);
+const vm = __webpack_require__(26144);
+const Parser = __webpack_require__(11715);
+const StackedMap = __webpack_require__(58845);
+const binarySearchBounds = __webpack_require__(92229);
+const memoize = __webpack_require__(78676);
+const BasicEvaluatedExpression = __webpack_require__(950);
 
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("acorn").Options} AcornOptions */
+/** @typedef {import("estree").ArrayExpression} ArrayExpressionNode */
+/** @typedef {import("estree").BinaryExpression} BinaryExpressionNode */
+/** @typedef {import("estree").BlockStatement} BlockStatementNode */
+/** @typedef {import("estree").SequenceExpression} SequenceExpressionNode */
+/** @typedef {import("estree").CallExpression} CallExpressionNode */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
+/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
+/** @typedef {import("estree").Comment} CommentNode */
+/** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
+/** @typedef {import("estree").Declaration} DeclarationNode */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Identifier} IdentifierNode */
+/** @typedef {import("estree").IfStatement} IfStatementNode */
+/** @typedef {import("estree").LabeledStatement} LabeledStatementNode */
+/** @typedef {import("estree").Literal} LiteralNode */
+/** @typedef {import("estree").LogicalExpression} LogicalExpressionNode */
+/** @typedef {import("estree").ChainExpression} ChainExpressionNode */
+/** @typedef {import("estree").MemberExpression} MemberExpressionNode */
+/** @typedef {import("estree").MetaProperty} MetaPropertyNode */
+/** @typedef {import("estree").MethodDefinition} MethodDefinitionNode */
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclarationNode */
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("estree").Program} ProgramNode */
+/** @typedef {import("estree").Statement} StatementNode */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
+/** @typedef {import("estree").Super} SuperNode */
+/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
+/** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
+/** @typedef {import("estree").ThisExpression} ThisExpressionNode */
+/** @typedef {import("estree").UnaryExpression} UnaryExpressionNode */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[] }} GetInfoResult */
 
-class WebAssemblyExportImportedDependency extends ModuleDependency {
-	constructor(exportName, request, name, valueType) {
-		super(request);
-		/** @type {string} */
-		this.exportName = exportName;
-		/** @type {string} */
-		this.name = name;
-		/** @type {string} */
-		this.valueType = valueType;
-	}
+const EMPTY_ARRAY = [];
+const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
+const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
+const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
-	/**
-	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
-	 */
-	couldAffectReferencingModule() {
-		return Dependency.TRANSITIVE;
-	}
+// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
 
+const parser = AcornParser.extend(importAssertions);
+
+class VariableInfo {
 	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
+	 * @param {string | true} freeName which free name the variable aliases, or true when none
+	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
+	constructor(declaredScope, freeName, tagInfo) {
+		this.declaredScope = declaredScope;
+		this.freeName = freeName;
+		this.tagInfo = tagInfo;
 	}
+}
 
-	get type() {
-		return "wasm export import";
-	}
+/** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
+/** @typedef {LiteralNode | string | null | undefined} ImportSource */
+/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
 
-	get category() {
-		return "wasm";
-	}
+/**
+ * @typedef {Object} TagInfo
+ * @property {any} tag
+ * @property {any} data
+ * @property {TagInfo | undefined} next
+ */
 
-	serialize(context) {
-		const { write } = context;
+/**
+ * @typedef {Object} ScopeInfo
+ * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
+ * @property {boolean | "arrow"} topLevelScope
+ * @property {boolean} inShorthand
+ * @property {boolean} isStrict
+ * @property {boolean} isAsmJs
+ * @property {boolean} inTry
+ */
 
-		write(this.exportName);
-		write(this.name);
-		write(this.valueType);
+const joinRanges = (startRange, endRange) => {
+	if (!endRange) return startRange;
+	if (!startRange) return endRange;
+	return [startRange[0], endRange[1]];
+};
 
-		super.serialize(context);
+const objectAndMembersToName = (object, membersReversed) => {
+	let name = object;
+	for (let i = membersReversed.length - 1; i >= 0; i--) {
+		name = name + "." + membersReversed[i];
 	}
+	return name;
+};
 
-	deserialize(context) {
-		const { read } = context;
-
-		this.exportName = read();
-		this.name = read();
-		this.valueType = read();
-
-		super.deserialize(context);
+const getRootName = expression => {
+	switch (expression.type) {
+		case "Identifier":
+			return expression.name;
+		case "ThisExpression":
+			return "this";
+		case "MetaProperty":
+			return `${expression.meta.name}.${expression.property.name}`;
+		default:
+			return undefined;
 	}
-}
-
-makeSerializable(
-	WebAssemblyExportImportedDependency,
-	"webpack/lib/dependencies/WebAssemblyExportImportedDependency"
-);
-
-module.exports = WebAssemblyExportImportedDependency;
-
-
-/***/ }),
-
-/***/ 5239:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+};
 
+/** @type {AcornOptions} */
+const defaultParserOptions = {
+	ranges: true,
+	locations: true,
+	ecmaVersion: "latest",
+	sourceType: "module",
+	// https://github.com/tc39/proposal-hashbang
+	allowHashBang: true,
+	onComment: null
+};
 
-const makeSerializable = __webpack_require__(33032);
-const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
-const ModuleDependency = __webpack_require__(80321);
+// regexp to match at least one "magic comment"
+const webpackCommentRegExp = new RegExp(/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/);
 
-/** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+const EMPTY_COMMENT_OPTIONS = {
+	options: null,
+	errors: null
+};
 
-class WebAssemblyImportDependency extends ModuleDependency {
+class JavascriptParser extends Parser {
 	/**
-	 * @param {string} request the request
-	 * @param {string} name the imported name
-	 * @param {ModuleImportDescription} description the WASM ast node
-	 * @param {false | string} onlyDirectImport if only direct imports are allowed
+	 * @param {"module" | "script" | "auto"} sourceType default source type
 	 */
-	constructor(request, name, description, onlyDirectImport) {
-		super(request);
-		/** @type {string} */
-		this.name = name;
-		/** @type {ModuleImportDescription} */
-		this.description = description;
-		/** @type {false | string} */
-		this.onlyDirectImport = onlyDirectImport;
-	}
+	constructor(sourceType = "auto") {
+		super();
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[UnaryExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode | MetaPropertyNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateDefinedIdentifier: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateCallExpressionMember: new HookMap(
+				() => new SyncBailHook(["expression", "param"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
+			isPure: new HookMap(
+				() => new SyncBailHook(["expression", "commentsStartPosition"])
+			),
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			preStatement: new SyncBailHook(["statement"]),
 
-	get type() {
-		return "wasm import";
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			blockPreStatement: new SyncBailHook(["declaration"]),
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			statement: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
+			statementIf: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classExtendsExpression: new SyncBailHook([
+				"expression",
+				"classDefinition"
+			]),
+			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
+			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyValue: new SyncBailHook([
+				"expression",
+				"element",
+				"classDefinition"
+			]),
+			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
+			label: new HookMap(() => new SyncBailHook(["statement"])),
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
+			import: new SyncBailHook(["statement", "source"]),
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
+			importSpecifier: new SyncBailHook([
+				"statement",
+				"source",
+				"exportName",
+				"identifierName"
+			]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
+			export: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
+			exportImport: new SyncBailHook(["statement", "source"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
+			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
+			exportExpression: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
+			exportSpecifier: new SyncBailHook([
+				"statement",
+				"identifierName",
+				"exportName",
+				"index"
+			]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
+			exportImportSpecifier: new SyncBailHook([
+				"statement",
+				"source",
+				"identifierName",
+				"exportName",
+				"index"
+			]),
+			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			preDeclarator: new SyncBailHook(["declarator", "statement"]),
+			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			declarator: new SyncBailHook(["declarator", "statement"]),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
+			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
+			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression], boolean | void>>} */
+			assign: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression, string[]], boolean | void>>} */
+			assignMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			typeof: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			importCall: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			topLevelAwait: new SyncBailHook(["expression"]),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			call: new HookMap(() => new SyncBailHook(["expression"])),
+			/** Something like "a.b()" */
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode, string[]], boolean | void>>} */
+			callMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** Something like "a.b().c.d" */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			memberChainOfCallMemberChain: new HookMap(
+				() =>
+					new SyncBailHook([
+						"expression",
+						"calleeMembers",
+						"callExpression",
+						"members"
+					])
+			),
+			/** Something like "a.b().c.d()"" */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			callMemberChainOfCallMemberChain: new HookMap(
+				() =>
+					new SyncBailHook([
+						"expression",
+						"calleeMembers",
+						"innerCallExpression",
+						"members"
+					])
+			),
+			/** @type {SyncBailHook<[ChainExpressionNode], boolean | void>} */
+			optionalChaining: new SyncBailHook(["optionalChaining"]),
+			/** @type {HookMap<SyncBailHook<[NewExpressionNode], boolean | void>>} */
+			new: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			expression: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			expressionMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			unhandledExpressionMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			expressionConditionalOperator: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			expressionLogicalOperator: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			program: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			finish: new SyncBailHook(["ast", "comments"])
+		});
+		this.sourceType = sourceType;
+		/** @type {ScopeInfo} */
+		this.scope = undefined;
+		/** @type {ParserState} */
+		this.state = undefined;
+		this.comments = undefined;
+		this.semicolons = undefined;
+		/** @type {(StatementNode|ExpressionNode)[]} */
+		this.statementPath = undefined;
+		this.prevStatement = undefined;
+		this.currentTagData = undefined;
+		this._initializeEvaluating();
 	}
 
-	get category() {
-		return "wasm";
-	}
+	_initializeEvaluating() {
+		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
+			const expr = /** @type {LiteralNode} */ (_expr);
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
-	}
+			switch (typeof expr.value) {
+				case "number":
+					return new BasicEvaluatedExpression()
+						.setNumber(expr.value)
+						.setRange(expr.range);
+				case "bigint":
+					return new BasicEvaluatedExpression()
+						.setBigInt(expr.value)
+						.setRange(expr.range);
+				case "string":
+					return new BasicEvaluatedExpression()
+						.setString(expr.value)
+						.setRange(expr.range);
+				case "boolean":
+					return new BasicEvaluatedExpression()
+						.setBoolean(expr.value)
+						.setRange(expr.range);
+			}
+			if (expr.value === null) {
+				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
+			}
+			if (expr.value instanceof RegExp) {
+				return new BasicEvaluatedExpression()
+					.setRegExp(expr.value)
+					.setRange(expr.range);
+			}
+		});
+		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const callee = expr.callee;
+			if (
+				callee.type !== "Identifier" ||
+				callee.name !== "RegExp" ||
+				expr.arguments.length > 2 ||
+				this.getVariableInfo("RegExp") !== "RegExp"
+			)
+				return;
 
-	/**
-	 * Returns errors
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
-	 */
-	getErrors(moduleGraph) {
-		const module = moduleGraph.getModule(this);
+			let regExp, flags;
+			const arg1 = expr.arguments[0];
 
-		if (
-			this.onlyDirectImport &&
-			module &&
-			!module.type.startsWith("webassembly")
-		) {
-			return [
-				new UnsupportedWebAssemblyFeatureError(
-					`Import "${this.name}" from "${this.request}" with ${this.onlyDirectImport} can only be used for direct wasm to wasm dependencies`
-				)
-			];
-		}
-	}
+			if (arg1) {
+				if (arg1.type === "SpreadElement") return;
 
-	serialize(context) {
-		const { write } = context;
+				const evaluatedRegExp = this.evaluateExpression(arg1);
 
-		write(this.name);
-		write(this.description);
-		write(this.onlyDirectImport);
+				if (!evaluatedRegExp) return;
 
-		super.serialize(context);
-	}
+				regExp = evaluatedRegExp.asString();
 
-	deserialize(context) {
-		const { read } = context;
+				if (!regExp) return;
+			} else {
+				return new BasicEvaluatedExpression()
+					.setRegExp(new RegExp(""))
+					.setRange(expr.range);
+			}
 
-		this.name = read();
-		this.description = read();
-		this.onlyDirectImport = read();
+			const arg2 = expr.arguments[1];
 
-		super.deserialize(context);
-	}
-}
+			if (arg2) {
+				if (arg2.type === "SpreadElement") return;
 
-makeSerializable(
-	WebAssemblyImportDependency,
-	"webpack/lib/dependencies/WebAssemblyImportDependency"
-);
+				const evaluatedFlags = this.evaluateExpression(arg2);
 
-module.exports = WebAssemblyImportDependency;
+				if (!evaluatedFlags) return;
 
+				if (!evaluatedFlags.isUndefined()) {
+					flags = evaluatedFlags.asString();
 
-/***/ }),
+					if (
+						flags === undefined ||
+						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
+					)
+						return;
+				}
+			}
 
-/***/ 26505:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			return new BasicEvaluatedExpression()
+				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
+				.setRange(expr.range);
+		});
+		this.hooks.evaluate
+			.for("LogicalExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {LogicalExpressionNode} */ (_expr);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+				const left = this.evaluateExpression(expr.left);
+				if (!left) return;
+				let returnRight = false;
+				/** @type {boolean|undefined} */
+				let allowedRight;
+				if (expr.operator === "&&") {
+					const leftAsBool = left.asBool();
+					if (leftAsBool === false) return left.setRange(expr.range);
+					returnRight = leftAsBool === true;
+					allowedRight = false;
+				} else if (expr.operator === "||") {
+					const leftAsBool = left.asBool();
+					if (leftAsBool === true) return left.setRange(expr.range);
+					returnRight = leftAsBool === false;
+					allowedRight = true;
+				} else if (expr.operator === "??") {
+					const leftAsNullish = left.asNullish();
+					if (leftAsNullish === false) return left.setRange(expr.range);
+					if (leftAsNullish !== true) return;
+					returnRight = true;
+				} else return;
+				const right = this.evaluateExpression(expr.right);
+				if (!right) return;
+				if (returnRight) {
+					if (left.couldHaveSideEffects()) right.setSideEffects();
+					return right.setRange(expr.range);
+				}
 
+				const asBool = right.asBool();
 
+				if (allowedRight === true && asBool === true) {
+					return new BasicEvaluatedExpression()
+						.setRange(expr.range)
+						.setTruthy();
+				} else if (allowedRight === false && asBool === false) {
+					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
+				}
+			});
 
-const Dependency = __webpack_require__(54912);
-const Template = __webpack_require__(39722);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
+		const valueAsExpression = (value, expr, sideEffects) => {
+			switch (typeof value) {
+				case "boolean":
+					return new BasicEvaluatedExpression()
+						.setBoolean(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "number":
+					return new BasicEvaluatedExpression()
+						.setNumber(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "bigint":
+					return new BasicEvaluatedExpression()
+						.setBigInt(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "string":
+					return new BasicEvaluatedExpression()
+						.setString(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+			}
+		};
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+		this.hooks.evaluate
+			.for("BinaryExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {BinaryExpressionNode} */ (_expr);
 
-class WebpackIsIncludedDependency extends ModuleDependency {
-	constructor(request, range) {
-		super(request);
+				const handleConstOperation = fn => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left || !left.isCompileTimeValue()) return;
 
-		this.weak = true;
-		this.range = range;
-	}
+					const right = this.evaluateExpression(expr.right);
+					if (!right || !right.isCompileTimeValue()) return;
 
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		// This doesn't use any export
-		return Dependency.NO_EXPORTS_REFERENCED;
-	}
+					const result = fn(
+						left.asCompileTimeValue(),
+						right.asCompileTimeValue()
+					);
+					return valueAsExpression(
+						result,
+						expr,
+						left.couldHaveSideEffects() || right.couldHaveSideEffects()
+					);
+				};
 
-	get type() {
-		return "__webpack_is_included__";
-	}
-}
+				const isAlwaysDifferent = (a, b) =>
+					(a === true && b === false) || (a === false && b === true);
 
-makeSerializable(
-	WebpackIsIncludedDependency,
-	"webpack/lib/dependencies/WebpackIsIncludedDependency"
-);
+				const handleTemplateStringCompare = (left, right, res, eql) => {
+					const getPrefix = parts => {
+						let value = "";
+						for (const p of parts) {
+							const v = p.asString();
+							if (v !== undefined) value += v;
+							else break;
+						}
+						return value;
+					};
+					const getSuffix = parts => {
+						let value = "";
+						for (let i = parts.length - 1; i >= 0; i--) {
+							const v = parts[i].asString();
+							if (v !== undefined) value = v + value;
+							else break;
+						}
+						return value;
+					};
+					const leftPrefix = getPrefix(left.parts);
+					const rightPrefix = getPrefix(right.parts);
+					const leftSuffix = getSuffix(left.parts);
+					const rightSuffix = getSuffix(right.parts);
+					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
+					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
+					if (
+						leftPrefix.slice(0, lenPrefix) !==
+							rightPrefix.slice(0, lenPrefix) ||
+						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
+					) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+				};
 
-WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, { runtimeTemplate, chunkGraph, moduleGraph }) {
-		const dep = /** @type {WebpackIsIncludedDependency} */ (dependency);
-		const connection = moduleGraph.getConnection(dep);
-		const included = connection
-			? chunkGraph.getNumberOfModuleChunks(connection.module) > 0
-			: false;
-		const comment = runtimeTemplate.outputOptions.pathinfo
-			? Template.toComment(
-					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
-						dep.request
-					)}`
-			  )
-			: "";
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`${comment}${JSON.stringify(included)}`
-		);
-	}
-};
-
-module.exports = WebpackIsIncludedDependency;
-
-
-/***/ }),
-
-/***/ 1466:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
-
-
-
-const Dependency = __webpack_require__(54912);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const ModuleDependency = __webpack_require__(80321);
-
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-class WorkerDependency extends ModuleDependency {
-	/**
-	 * @param {string} request request
-	 * @param {[number, number]} range range
-	 */
-	constructor(request, range) {
-		super(request);
-		this.range = range;
-	}
-
-	/**
-	 * Returns list of exports referenced by this dependency
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
-	 */
-	getReferencedExports(moduleGraph, runtime) {
-		return Dependency.NO_EXPORTS_REFERENCED;
-	}
-
-	get type() {
-		return "new Worker()";
-	}
-
-	get category() {
-		return "worker";
-	}
-}
-
-WorkerDependency.Template = class WorkerDependencyTemplate extends (
-	ModuleDependency.Template
-) {
-	/**
-	 * @param {Dependency} dependency the dependency for which the template should be applied
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {DependencyTemplateContext} templateContext the context object
-	 * @returns {void}
-	 */
-	apply(dependency, source, templateContext) {
-		const { chunkGraph, moduleGraph, runtimeRequirements } = templateContext;
-		const dep = /** @type {WorkerDependency} */ (dependency);
-		const block = /** @type {AsyncDependenciesBlock} */ (
-			moduleGraph.getParentBlock(dependency)
-		);
-		const entrypoint = /** @type {Entrypoint} */ (
-			chunkGraph.getBlockChunkGroup(block)
-		);
-		const chunk = entrypoint.getEntrypointChunk();
-
-		runtimeRequirements.add(RuntimeGlobals.publicPath);
-		runtimeRequirements.add(RuntimeGlobals.baseURI);
-		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			`/* worker import */ ${RuntimeGlobals.publicPath} + ${
-				RuntimeGlobals.getChunkScriptFilename
-			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
-		);
-	}
-};
-
-makeSerializable(WorkerDependency, "webpack/lib/dependencies/WorkerDependency");
-
-module.exports = WorkerDependency;
-
-
-/***/ }),
-
-/***/ 82509:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				const handleStrictEqualityComparison = eql => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					res.setRange(expr.range);
 
+					const leftConst = left.isCompileTimeValue();
+					const rightConst = right.isCompileTimeValue();
 
+					if (leftConst && rightConst) {
+						return res
+							.setBoolean(
+								eql ===
+									(left.asCompileTimeValue() === right.asCompileTimeValue())
+							)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
 
-const { pathToFileURL } = __webpack_require__(57310);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const CommentCompilationWarning = __webpack_require__(98427);
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
-const { equals } = __webpack_require__(84953);
-const createHash = __webpack_require__(49835);
-const { contextify } = __webpack_require__(82186);
-const EnableWasmLoadingPlugin = __webpack_require__(78613);
-const ConstDependency = __webpack_require__(76911);
-const CreateScriptUrlDependency = __webpack_require__(79062);
-const {
-	harmonySpecifierTag
-} = __webpack_require__(20862);
-const WorkerDependency = __webpack_require__(1466);
+					if (left.isArray() && right.isArray()) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+					if (left.isTemplateString() && right.isTemplateString()) {
+						return handleTemplateStringCompare(left, right, res, eql);
+					}
 
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").Pattern} Pattern */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
+					const leftPrimitive = left.isPrimitiveType();
+					const rightPrimitive = right.isPrimitiveType();
 
-const getUrl = module => {
-	return pathToFileURL(module.resource).toString();
-};
+					if (
+						// Primitive !== Object or
+						// compile-time object types are never equal to something at runtime
+						(leftPrimitive === false &&
+							(leftConst || rightPrimitive === true)) ||
+						(rightPrimitive === false &&
+							(rightConst || leftPrimitive === true)) ||
+						// Different nullish or boolish status also means not equal
+						isAlwaysDifferent(left.asBool(), right.asBool()) ||
+						isAlwaysDifferent(left.asNullish(), right.asNullish())
+					) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+				};
 
-const DEFAULT_SYNTAX = [
-	"Worker",
-	"SharedWorker",
-	"navigator.serviceWorker.register()",
-	"Worker from worker_threads"
-];
+				const handleAbstractEqualityComparison = eql => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					res.setRange(expr.range);
 
-/** @type {WeakMap<ParserState, number>} */
-const workerIndexMap = new WeakMap();
+					const leftConst = left.isCompileTimeValue();
+					const rightConst = right.isCompileTimeValue();
 
-class WorkerPlugin {
-	constructor(chunkLoading, wasmLoading, module) {
-		this._chunkLoading = chunkLoading;
-		this._wasmLoading = wasmLoading;
-		this._module = module;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		if (this._chunkLoading) {
-			new EnableChunkLoadingPlugin(this._chunkLoading).apply(compiler);
-		}
-		if (this._wasmLoading) {
-			new EnableWasmLoadingPlugin(this._wasmLoading).apply(compiler);
-		}
-		const cachedContextify = contextify.bindContextCache(
-			compiler.context,
-			compiler.root
-		);
-		compiler.hooks.thisCompilation.tap(
-			"WorkerPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WorkerDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					WorkerDependency,
-					new WorkerDependency.Template()
-				);
-				compilation.dependencyTemplates.set(
-					CreateScriptUrlDependency,
-					new CreateScriptUrlDependency.Template()
-				);
+					if (leftConst && rightConst) {
+						return res
+							.setBoolean(
+								eql ===
+									// eslint-disable-next-line eqeqeq
+									(left.asCompileTimeValue() == right.asCompileTimeValue())
+							)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
-				 */
-				const parseModuleUrl = (parser, expr) => {
-					if (
-						expr.type !== "NewExpression" ||
-						expr.callee.type === "Super" ||
-						expr.arguments.length !== 2
-					)
-						return;
-					const [arg1, arg2] = expr.arguments;
-					if (arg1.type === "SpreadElement") return;
-					if (arg2.type === "SpreadElement") return;
-					const callee = parser.evaluateExpression(expr.callee);
-					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
-					const arg2Value = parser.evaluateExpression(arg2);
-					if (
-						!arg2Value.isString() ||
-						!arg2Value.string.startsWith("file://") ||
-						arg2Value.string !== getUrl(parser.state.module)
-					) {
-						return;
+					if (left.isArray() && right.isArray()) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+					if (left.isTemplateString() && right.isTemplateString()) {
+						return handleTemplateStringCompare(left, right, res, eql);
 					}
-					const arg1Value = parser.evaluateExpression(arg1);
-					return [arg1Value, [arg1.range[0], arg2.range[1]]];
 				};
 
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {ObjectExpression} expr expression
-				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
-				 */
-				const parseObjectExpression = (parser, expr) => {
-					/** @type {Record<string, any>} */
-					const values = {};
-					/** @type {Record<string, Expression | Pattern>} */
-					const expressions = {};
-					/** @type {(Property | SpreadElement)[]} */
-					const otherElements = [];
-					let spread = false;
-					for (const prop of expr.properties) {
-						if (prop.type === "SpreadElement") {
-							spread = true;
+				if (expr.operator === "+") {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					if (left.isString()) {
+						if (right.isString()) {
+							res.setString(left.string + right.string);
+						} else if (right.isNumber()) {
+							res.setString(left.string + right.number);
 						} else if (
-							prop.type === "Property" &&
-							!prop.method &&
-							!prop.computed &&
-							prop.key.type === "Identifier"
+							right.isWrapped() &&
+							right.prefix &&
+							right.prefix.isString()
 						) {
-							expressions[prop.key.name] = prop.value;
-							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
-								const value = parser.evaluateExpression(
-									/** @type {Expression} */ (prop.value)
-								);
-								if (value.isCompileTimeValue())
-									values[prop.key.name] = value.asCompileTimeValue();
-							}
+							// "left" + ("prefix" + inner + "postfix")
+							// => ("leftPrefix" + inner + "postfix")
+							res.setWrapped(
+								new BasicEvaluatedExpression()
+									.setString(left.string + right.prefix.string)
+									.setRange(joinRanges(left.range, right.prefix.range)),
+								right.postfix,
+								right.wrappedInnerExpressions
+							);
+						} else if (right.isWrapped()) {
+							// "left" + ([null] + inner + "postfix")
+							// => ("left" + inner + "postfix")
+							res.setWrapped(
+								left,
+								right.postfix,
+								right.wrappedInnerExpressions
+							);
 						} else {
-							otherElements.push(prop);
+							// "left" + expr
+							// => ("left" + expr + "")
+							res.setWrapped(left, null, [right]);
 						}
-					}
-					const insertType = expr.properties.length > 0 ? "comma" : "single";
-					const insertLocation =
-						expr.properties[expr.properties.length - 1].range[1];
-					return {
-						expressions,
-						otherElements,
-						values,
-						spread,
-						insertType,
-						insertLocation
-					};
-				};
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {object} parserOptions options
-				 */
-				const parserPlugin = (parser, parserOptions) => {
-					if (parserOptions.worker === false) return;
-					const options = !Array.isArray(parserOptions.worker)
-						? ["..."]
-						: parserOptions.worker;
-					const handleNewWorker = expr => {
-						if (expr.arguments.length === 0 || expr.arguments.length > 2)
+					} else if (left.isNumber()) {
+						if (right.isString()) {
+							res.setString(left.number + right.string);
+						} else if (right.isNumber()) {
+							res.setNumber(left.number + right.number);
+						} else {
 							return;
-						const [arg1, arg2] = expr.arguments;
-						if (arg1.type === "SpreadElement") return;
-						if (arg2 && arg2.type === "SpreadElement") return;
-						const parsedUrl = parseModuleUrl(parser, arg1);
-						if (!parsedUrl) return;
-						const [url, range] = parsedUrl;
-						if (!url.isString()) return;
-						const {
-							expressions,
-							otherElements,
-							values: options,
-							spread: hasSpreadInOptions,
-							insertType,
-							insertLocation
-						} = arg2 && arg2.type === "ObjectExpression"
-							? parseObjectExpression(parser, arg2)
-							: {
-									expressions: {},
-									otherElements: [],
-									values: {},
-									spread: false,
-									insertType: arg2 ? "spread" : "argument",
-									insertLocation: arg2 ? arg2.range : arg1.range[1]
-							  };
-						const { options: importOptions, errors: commentErrors } =
-							parser.parseCommentOptions(expr.range);
-
-						if (commentErrors) {
-							for (const e of commentErrors) {
-								const { comment } = e;
-								parser.state.module.addWarning(
-									new CommentCompilationWarning(
-										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-										comment.loc
-									)
-								);
-							}
-						}
-
-						/** @type {EntryOptions} */
-						let entryOptions = {};
-
-						if (importOptions) {
-							if (importOptions.webpackIgnore !== undefined) {
-								if (typeof importOptions.webpackIgnore !== "boolean") {
-									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
-											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-											expr.loc
-										)
-									);
-								} else {
-									if (importOptions.webpackIgnore) {
-										return false;
-									}
-								}
-							}
-							if (importOptions.webpackEntryOptions !== undefined) {
-								if (
-									typeof importOptions.webpackEntryOptions !== "object" ||
-									importOptions.webpackEntryOptions === null
-								) {
-									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
-											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
-											expr.loc
-										)
-									);
-								} else {
-									Object.assign(
-										entryOptions,
-										importOptions.webpackEntryOptions
-									);
-								}
-							}
-							if (importOptions.webpackChunkName !== undefined) {
-								if (typeof importOptions.webpackChunkName !== "string") {
-									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
-											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-											expr.loc
-										)
-									);
-								} else {
-									entryOptions.name = importOptions.webpackChunkName;
-								}
-							}
 						}
-
-						if (
-							!Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
-							options &&
-							typeof options.name === "string"
-						) {
-							entryOptions.name = options.name;
+					} else if (left.isBigInt()) {
+						if (right.isBigInt()) {
+							res.setBigInt(left.bigint + right.bigint);
 						}
-
-						if (entryOptions.runtime === undefined) {
-							let i = workerIndexMap.get(parser.state) || 0;
-							workerIndexMap.set(parser.state, i + 1);
-							let name = `${cachedContextify(
-								parser.state.module.identifier()
-							)}|${i}`;
-							const hash = createHash(compilation.outputOptions.hashFunction);
-							hash.update(name);
-							const digest = /** @type {string} */ (
-								hash.digest(compilation.outputOptions.hashDigest)
+					} else if (left.isWrapped()) {
+						if (left.postfix && left.postfix.isString() && right.isString()) {
+							// ("prefix" + inner + "postfix") + "right"
+							// => ("prefix" + inner + "postfixRight")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(left.postfix.string + right.string)
+									.setRange(joinRanges(left.postfix.range, right.range)),
+								left.wrappedInnerExpressions
 							);
-							entryOptions.runtime = digest.slice(
-								0,
-								compilation.outputOptions.hashDigestLength
+						} else if (
+							left.postfix &&
+							left.postfix.isString() &&
+							right.isNumber()
+						) {
+							// ("prefix" + inner + "postfix") + 123
+							// => ("prefix" + inner + "postfix123")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(left.postfix.string + right.number)
+									.setRange(joinRanges(left.postfix.range, right.range)),
+								left.wrappedInnerExpressions
+							);
+						} else if (right.isString()) {
+							// ("prefix" + inner + [null]) + "right"
+							// => ("prefix" + inner + "right")
+							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
+						} else if (right.isNumber()) {
+							// ("prefix" + inner + [null]) + 123
+							// => ("prefix" + inner + "123")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(right.number + "")
+									.setRange(right.range),
+								left.wrappedInnerExpressions
+							);
+						} else if (right.isWrapped()) {
+							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
+							res.setWrapped(
+								left.prefix,
+								right.postfix,
+								left.wrappedInnerExpressions &&
+									right.wrappedInnerExpressions &&
+									left.wrappedInnerExpressions
+										.concat(left.postfix ? [left.postfix] : [])
+										.concat(right.prefix ? [right.prefix] : [])
+										.concat(right.wrappedInnerExpressions)
+							);
+						} else {
+							// ("prefix" + inner + postfix) + expr
+							// => ("prefix" + inner + postfix + expr + [null])
+							res.setWrapped(
+								left.prefix,
+								null,
+								left.wrappedInnerExpressions &&
+									left.wrappedInnerExpressions.concat(
+										left.postfix ? [left.postfix, right] : [right]
+									)
 							);
 						}
-
-						const block = new AsyncDependenciesBlock({
-							name: entryOptions.name,
-							entryOptions: {
-								chunkLoading: this._chunkLoading,
-								wasmLoading: this._wasmLoading,
-								...entryOptions
-							}
-						});
-						block.loc = expr.loc;
-						const dep = new WorkerDependency(url.string, range);
-						dep.loc = expr.loc;
-						block.addDependency(dep);
-						parser.state.module.addBlock(block);
-
-						if (compilation.outputOptions.trustedTypes) {
-							const dep = new CreateScriptUrlDependency(
-								expr.arguments[0].range
+					} else {
+						if (right.isString()) {
+							// left + "right"
+							// => ([null] + left + "right")
+							res.setWrapped(null, right, [left]);
+						} else if (right.isWrapped()) {
+							// left + (prefix + inner + "postfix")
+							// => ([null] + left + prefix + inner + "postfix")
+							res.setWrapped(
+								null,
+								right.postfix,
+								right.wrappedInnerExpressions &&
+									(right.prefix ? [left, right.prefix] : [left]).concat(
+										right.wrappedInnerExpressions
+									)
 							);
-							dep.loc = expr.loc;
-							parser.state.module.addDependency(dep);
+						} else {
+							return;
 						}
+					}
+					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
+						res.setSideEffects();
+					res.setRange(expr.range);
+					return res;
+				} else if (expr.operator === "-") {
+					return handleConstOperation((l, r) => l - r);
+				} else if (expr.operator === "*") {
+					return handleConstOperation((l, r) => l * r);
+				} else if (expr.operator === "/") {
+					return handleConstOperation((l, r) => l / r);
+				} else if (expr.operator === "**") {
+					return handleConstOperation((l, r) => l ** r);
+				} else if (expr.operator === "===") {
+					return handleStrictEqualityComparison(true);
+				} else if (expr.operator === "==") {
+					return handleAbstractEqualityComparison(true);
+				} else if (expr.operator === "!==") {
+					return handleStrictEqualityComparison(false);
+				} else if (expr.operator === "!=") {
+					return handleAbstractEqualityComparison(false);
+				} else if (expr.operator === "&") {
+					return handleConstOperation((l, r) => l & r);
+				} else if (expr.operator === "|") {
+					return handleConstOperation((l, r) => l | r);
+				} else if (expr.operator === "^") {
+					return handleConstOperation((l, r) => l ^ r);
+				} else if (expr.operator === ">>>") {
+					return handleConstOperation((l, r) => l >>> r);
+				} else if (expr.operator === ">>") {
+					return handleConstOperation((l, r) => l >> r);
+				} else if (expr.operator === "<<") {
+					return handleConstOperation((l, r) => l << r);
+				} else if (expr.operator === "<") {
+					return handleConstOperation((l, r) => l < r);
+				} else if (expr.operator === ">") {
+					return handleConstOperation((l, r) => l > r);
+				} else if (expr.operator === "<=") {
+					return handleConstOperation((l, r) => l <= r);
+				} else if (expr.operator === ">=") {
+					return handleConstOperation((l, r) => l >= r);
+				}
+			});
+		this.hooks.evaluate
+			.for("UnaryExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {UnaryExpressionNode} */ (_expr);
 
-						if (expressions.type) {
-							const expr = expressions.type;
-							if (options.type !== false) {
-								const dep = new ConstDependency(
-									this._module ? '"module"' : "undefined",
-									expr.range
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-								expressions.type = undefined;
-							}
-						} else if (insertType === "comma") {
-							if (this._module || hasSpreadInOptions) {
-								const dep = new ConstDependency(
-									`, type: ${this._module ? '"module"' : "undefined"}`,
-									insertLocation
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
-						} else if (insertType === "spread") {
-							const dep1 = new ConstDependency(
-								"Object.assign({}, ",
-								insertLocation[0]
+				const handleConstOperation = fn => {
+					const argument = this.evaluateExpression(expr.argument);
+					if (!argument || !argument.isCompileTimeValue()) return;
+					const result = fn(argument.asCompileTimeValue());
+					return valueAsExpression(
+						result,
+						expr,
+						argument.couldHaveSideEffects()
+					);
+				};
+
+				if (expr.operator === "typeof") {
+					switch (expr.argument.type) {
+						case "Identifier": {
+							const res = this.callHooksForName(
+								this.hooks.evaluateTypeof,
+								expr.argument.name,
+								expr
 							);
-							const dep2 = new ConstDependency(
-								`, { type: ${this._module ? '"module"' : "undefined"} })`,
-								insertLocation[1]
+							if (res !== undefined) return res;
+							break;
+						}
+						case "MetaProperty": {
+							const res = this.callHooksForName(
+								this.hooks.evaluateTypeof,
+								getRootName(expr.argument),
+								expr
 							);
-							dep1.loc = expr.loc;
-							dep2.loc = expr.loc;
-							parser.state.module.addPresentationalDependency(dep1);
-							parser.state.module.addPresentationalDependency(dep2);
-						} else if (insertType === "argument") {
-							if (this._module) {
-								const dep = new ConstDependency(
-									', { type: "module" }',
-									insertLocation
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
+							if (res !== undefined) return res;
+							break;
 						}
-
-						parser.walkExpression(expr.callee);
-						for (const key of Object.keys(expressions)) {
-							if (expressions[key]) parser.walkExpression(expressions[key]);
+						case "MemberExpression": {
+							const res = this.callHooksForExpression(
+								this.hooks.evaluateTypeof,
+								expr.argument,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
 						}
-						for (const prop of otherElements) {
-							parser.walkProperty(prop);
+						case "ChainExpression": {
+							const res = this.callHooksForExpression(
+								this.hooks.evaluateTypeof,
+								expr.argument.expression,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
 						}
-						if (insertType === "spread") {
-							parser.walkExpression(arg2);
+						case "FunctionExpression": {
+							return new BasicEvaluatedExpression()
+								.setString("function")
+								.setRange(expr.range);
 						}
+					}
+					const arg = this.evaluateExpression(expr.argument);
+					if (arg.isUnknown()) return;
+					if (arg.isString()) {
+						return new BasicEvaluatedExpression()
+							.setString("string")
+							.setRange(expr.range);
+					}
+					if (arg.isWrapped()) {
+						return new BasicEvaluatedExpression()
+							.setString("string")
+							.setSideEffects()
+							.setRange(expr.range);
+					}
+					if (arg.isUndefined()) {
+						return new BasicEvaluatedExpression()
+							.setString("undefined")
+							.setRange(expr.range);
+					}
+					if (arg.isNumber()) {
+						return new BasicEvaluatedExpression()
+							.setString("number")
+							.setRange(expr.range);
+					}
+					if (arg.isBigInt()) {
+						return new BasicEvaluatedExpression()
+							.setString("bigint")
+							.setRange(expr.range);
+					}
+					if (arg.isBoolean()) {
+						return new BasicEvaluatedExpression()
+							.setString("boolean")
+							.setRange(expr.range);
+					}
+					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
+						return new BasicEvaluatedExpression()
+							.setString("object")
+							.setRange(expr.range);
+					}
+					if (arg.isArray()) {
+						return new BasicEvaluatedExpression()
+							.setString("object")
+							.setSideEffects(arg.couldHaveSideEffects())
+							.setRange(expr.range);
+					}
+				} else if (expr.operator === "!") {
+					const argument = this.evaluateExpression(expr.argument);
+					if (!argument) return;
+					const bool = argument.asBool();
+					if (typeof bool !== "boolean") return;
+					return new BasicEvaluatedExpression()
+						.setBoolean(!bool)
+						.setSideEffects(argument.couldHaveSideEffects())
+						.setRange(expr.range);
+				} else if (expr.operator === "~") {
+					return handleConstOperation(v => ~v);
+				} else if (expr.operator === "+") {
+					return handleConstOperation(v => +v);
+				} else if (expr.operator === "-") {
+					return handleConstOperation(v => -v);
+				}
+			});
+		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
+			return new BasicEvaluatedExpression()
+				.setString("undefined")
+				.setRange(expr.range);
+		});
+		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
+				return new BasicEvaluatedExpression()
+					.setUndefined()
+					.setRange(expr.range);
+			}
+		});
+		/**
+		 * @param {string} exprType expression type name
+		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
+		 * @returns {void}
+		 */
+		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
+			/** @type {ExpressionNode | undefined} */
+			let cachedExpression = undefined;
+			/** @type {GetInfoResult | undefined} */
+			let cachedInfo = undefined;
+			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
+				const expression = /** @type {MemberExpressionNode} */ (expr);
 
-						return true;
-					};
-					const processItem = item => {
-						if (item.endsWith("()")) {
-							parser.hooks.call
-								.for(item.slice(0, -2))
-								.tap("WorkerPlugin", handleNewWorker);
-						} else {
-							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
-							if (match) {
-								const ids = match[1].split(".");
-								const call = match[2];
-								const source = match[3];
-								(call ? parser.hooks.call : parser.hooks.new)
-									.for(harmonySpecifierTag)
-									.tap("WorkerPlugin", expr => {
-										const settings = /** @type {HarmonySettings} */ (
-											parser.currentTagData
-										);
-										if (
-											!settings ||
-											settings.source !== source ||
-											!equals(settings.ids, ids)
-										) {
-											return;
-										}
-										return handleNewWorker(expr);
-									});
-							} else {
-								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
+				const info = getInfo(expr);
+				if (info !== undefined) {
+					return this.callHooksForInfoWithFallback(
+						this.hooks.evaluateIdentifier,
+						info.name,
+						name => {
+							cachedExpression = expression;
+							cachedInfo = info;
+						},
+						name => {
+							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
+							if (hook !== undefined) {
+								return hook.call(expression);
 							}
-						}
-					};
-					for (const item of options) {
-						if (item === "...") {
-							DEFAULT_SYNTAX.forEach(processItem);
-						} else processItem(item);
+						},
+						expression
+					);
+				}
+			});
+			this.hooks.evaluate
+				.for(exprType)
+				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
+					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
+					if (info !== undefined) {
+						return new BasicEvaluatedExpression()
+							.setIdentifier(info.name, info.rootInfo, info.getMembers)
+							.setRange(expr.range);
 					}
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WorkerPlugin", parserPlugin);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WorkerPlugin", parserPlugin);
+				});
+			this.hooks.finish.tap("JavascriptParser", () => {
+				// Cleanup for GC
+				cachedExpression = cachedInfo = undefined;
+			});
+		};
+		tapEvaluateWithVariableInfo("Identifier", expr => {
+			const info = this.getVariableInfo(
+				/** @type {IdentifierNode} */ (expr).name
+			);
+			if (
+				typeof info === "string" ||
+				(info instanceof VariableInfo && typeof info.freeName === "string")
+			) {
+				return { name: info, rootInfo: info, getMembers: () => [] };
 			}
-		);
-	}
-}
-module.exports = WorkerPlugin;
-
-
-/***/ }),
-
-/***/ 50396:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		});
+		tapEvaluateWithVariableInfo("ThisExpression", expr => {
+			const info = this.getVariableInfo("this");
+			if (
+				typeof info === "string" ||
+				(info instanceof VariableInfo && typeof info.freeName === "string")
+			) {
+				return { name: info, rootInfo: info, getMembers: () => [] };
+			}
+		});
+		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
+			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
 
+			return this.callHooksForName(
+				this.hooks.evaluateIdentifier,
+				getRootName(expr),
+				metaProperty
+			);
+		});
+		tapEvaluateWithVariableInfo("MemberExpression", expr =>
+			this.getMemberExpressionInfo(
+				/** @type {MemberExpressionNode} */ (expr),
+				ALLOWED_MEMBER_TYPES_EXPRESSION
+			)
+		);
 
+		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
+			const expr = /** @type {CallExpressionNode} */ (_expr);
+			if (
+				expr.callee.type !== "MemberExpression" ||
+				expr.callee.property.type !==
+					(expr.callee.computed ? "Literal" : "Identifier")
+			) {
+				return;
+			}
 
-module.exports = expr => {
-	// <FunctionExpression>
-	if (
-		expr.type === "FunctionExpression" ||
-		expr.type === "ArrowFunctionExpression"
-	) {
-		return {
-			fn: expr,
-			expressions: [],
-			needThis: false
-		};
-	}
+			// type Super also possible here
+			const param = this.evaluateExpression(
+				/** @type {ExpressionNode} */ (expr.callee.object)
+			);
+			if (!param) return;
+			const property =
+				expr.callee.property.type === "Literal"
+					? `${expr.callee.property.value}`
+					: expr.callee.property.name;
+			const hook = this.hooks.evaluateCallExpressionMember.get(property);
+			if (hook !== undefined) {
+				return hook.call(expr, param);
+			}
+		});
+		this.hooks.evaluateCallExpressionMember
+			.for("indexOf")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length === 0) return;
+				const [arg1, arg2] = expr.arguments;
+				if (arg1.type === "SpreadElement") return;
+				const arg1Eval = this.evaluateExpression(arg1);
+				if (!arg1Eval.isString()) return;
+				const arg1Value = arg1Eval.string;
 
-	// <FunctionExpression>.bind(<Expression>)
-	if (
-		expr.type === "CallExpression" &&
-		expr.callee.type === "MemberExpression" &&
-		expr.callee.object.type === "FunctionExpression" &&
-		expr.callee.property.type === "Identifier" &&
-		expr.callee.property.name === "bind" &&
-		expr.arguments.length === 1
-	) {
-		return {
-			fn: expr.callee.object,
-			expressions: [expr.arguments[0]],
-			needThis: undefined
-		};
-	}
-	// (function(_this) {return <FunctionExpression>})(this) (Coffeescript)
-	if (
-		expr.type === "CallExpression" &&
-		expr.callee.type === "FunctionExpression" &&
-		expr.callee.body.type === "BlockStatement" &&
-		expr.arguments.length === 1 &&
-		expr.arguments[0].type === "ThisExpression" &&
-		expr.callee.body.body &&
-		expr.callee.body.body.length === 1 &&
-		expr.callee.body.body[0].type === "ReturnStatement" &&
-		expr.callee.body.body[0].argument &&
-		expr.callee.body.body[0].argument.type === "FunctionExpression"
-	) {
-		return {
-			fn: expr.callee.body.body[0].argument,
-			expressions: [],
-			needThis: true
-		};
-	}
-};
+				let result;
+				if (arg2) {
+					if (arg2.type === "SpreadElement") return;
+					const arg2Eval = this.evaluateExpression(arg2);
+					if (!arg2Eval.isNumber()) return;
+					result = param.string.indexOf(arg1Value, arg2Eval.number);
+				} else {
+					result = param.string.indexOf(arg1Value);
+				}
+				return new BasicEvaluatedExpression()
+					.setNumber(result)
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		this.hooks.evaluateCallExpressionMember
+			.for("replace")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length !== 2) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				if (expr.arguments[1].type === "SpreadElement") return;
+				let arg1 = this.evaluateExpression(expr.arguments[0]);
+				let arg2 = this.evaluateExpression(expr.arguments[1]);
+				if (!arg1.isString() && !arg1.isRegExp()) return;
+				const arg1Value = arg1.regExp || arg1.string;
+				if (!arg2.isString()) return;
+				const arg2Value = arg2.string;
+				return new BasicEvaluatedExpression()
+					.setString(param.string.replace(arg1Value, arg2Value))
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		["substr", "substring", "slice"].forEach(fn => {
+			this.hooks.evaluateCallExpressionMember
+				.for(fn)
+				.tap("JavascriptParser", (expr, param) => {
+					if (!param.isString()) return;
+					let arg1;
+					let result,
+						str = param.string;
+					switch (expr.arguments.length) {
+						case 1:
+							if (expr.arguments[0].type === "SpreadElement") return;
+							arg1 = this.evaluateExpression(expr.arguments[0]);
+							if (!arg1.isNumber()) return;
+							result = str[fn](arg1.number);
+							break;
+						case 2: {
+							if (expr.arguments[0].type === "SpreadElement") return;
+							if (expr.arguments[1].type === "SpreadElement") return;
+							arg1 = this.evaluateExpression(expr.arguments[0]);
+							const arg2 = this.evaluateExpression(expr.arguments[1]);
+							if (!arg1.isNumber()) return;
+							if (!arg2.isNumber()) return;
+							result = str[fn](arg1.number, arg2.number);
+							break;
+						}
+						default:
+							return;
+					}
+					return new BasicEvaluatedExpression()
+						.setString(result)
+						.setSideEffects(param.couldHaveSideEffects())
+						.setRange(expr.range);
+				});
+		});
 
+		/**
+		 * @param {"cooked" | "raw"} kind kind of values to get
+		 * @param {TemplateLiteralNode} templateLiteralExpr TemplateLiteral expr
+		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
+		 */
+		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
+			/** @type {BasicEvaluatedExpression[]} */
+			const quasis = [];
+			/** @type {BasicEvaluatedExpression[]} */
+			const parts = [];
 
-/***/ }),
+			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
+				const quasiExpr = templateLiteralExpr.quasis[i];
+				const quasi = quasiExpr.value[kind];
 
-/***/ 55207:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+				if (i > 0) {
+					const prevExpr = parts[parts.length - 1];
+					const expr = this.evaluateExpression(
+						templateLiteralExpr.expressions[i - 1]
+					);
+					const exprAsString = expr.asString();
+					if (
+						typeof exprAsString === "string" &&
+						!expr.couldHaveSideEffects()
+					) {
+						// We can merge quasi + expr + quasi when expr
+						// is a const string
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+						prevExpr.setString(prevExpr.string + exprAsString + quasi);
+						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						// We unset the expression as it doesn't match to a single expression
+						prevExpr.setExpression(undefined);
+						continue;
+					}
+					parts.push(expr);
+				}
 
+				const part = new BasicEvaluatedExpression()
+					.setString(quasi)
+					.setRange(quasiExpr.range)
+					.setExpression(quasiExpr);
+				quasis.push(part);
+				parts.push(part);
+			}
+			return {
+				quasis,
+				parts
+			};
+		};
 
+		this.hooks.evaluate
+			.for("TemplateLiteral")
+			.tap("JavascriptParser", _node => {
+				const node = /** @type {TemplateLiteralNode} */ (_node);
 
-const { UsageState } = __webpack_require__(63686);
+				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
+				if (parts.length === 1) {
+					return parts[0].setRange(node.range);
+				}
+				return new BasicEvaluatedExpression()
+					.setTemplateString(quasis, parts, "cooked")
+					.setRange(node.range);
+			});
+		this.hooks.evaluate
+			.for("TaggedTemplateExpression")
+			.tap("JavascriptParser", _node => {
+				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
+				const tag = this.evaluateExpression(node.tag);
 
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+				if (tag.isIdentifier() && tag.identifier === "String.raw") {
+					const { quasis, parts } = getSimplifiedTemplateResult(
+						"raw",
+						node.quasi
+					);
+					return new BasicEvaluatedExpression()
+						.setTemplateString(quasis, parts, "raw")
+						.setRange(node.range);
+				}
+			});
 
-/**
- * @param {RuntimeSpec} runtime the runtime
- * @param {string[][]} referencedExports list of referenced exports, will be added to
- * @param {string[]} prefix export prefix
- * @param {ExportInfo=} exportInfo the export info
- * @param {boolean} defaultPointsToSelf when true, using default will reference itself
- * @param {Set<ExportInfo>} alreadyVisited already visited export info (to handle circular reexports)
- */
-const processExportInfo = (
-	runtime,
-	referencedExports,
-	prefix,
-	exportInfo,
-	defaultPointsToSelf = false,
-	alreadyVisited = new Set()
-) => {
-	if (!exportInfo) {
-		referencedExports.push(prefix);
-		return;
-	}
-	const used = exportInfo.getUsed(runtime);
-	if (used === UsageState.Unused) return;
-	if (alreadyVisited.has(exportInfo)) {
-		referencedExports.push(prefix);
-		return;
-	}
-	alreadyVisited.add(exportInfo);
-	if (
-		used !== UsageState.OnlyPropertiesUsed ||
-		!exportInfo.exportsInfo ||
-		exportInfo.exportsInfo.otherExportsInfo.getUsed(runtime) !==
-			UsageState.Unused
-	) {
-		alreadyVisited.delete(exportInfo);
-		referencedExports.push(prefix);
-		return;
-	}
-	const exportsInfo = exportInfo.exportsInfo;
-	for (const exportInfo of exportsInfo.orderedExports) {
-		processExportInfo(
-			runtime,
-			referencedExports,
-			defaultPointsToSelf && exportInfo.name === "default"
-				? prefix
-				: prefix.concat(exportInfo.name),
-			exportInfo,
-			false,
-			alreadyVisited
-		);
-	}
-	alreadyVisited.delete(exportInfo);
-};
-module.exports = processExportInfo;
+		this.hooks.evaluateCallExpressionMember
+			.for("concat")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString() && !param.isWrapped()) return;
 
+				let stringSuffix = null;
+				let hasUnknownParams = false;
+				const innerExpressions = [];
+				for (let i = expr.arguments.length - 1; i >= 0; i--) {
+					const arg = expr.arguments[i];
+					if (arg.type === "SpreadElement") return;
+					const argExpr = this.evaluateExpression(arg);
+					if (
+						hasUnknownParams ||
+						(!argExpr.isString() && !argExpr.isNumber())
+					) {
+						hasUnknownParams = true;
+						innerExpressions.push(argExpr);
+						continue;
+					}
 
-/***/ }),
+					const value = argExpr.isString()
+						? argExpr.string
+						: "" + argExpr.number;
 
-/***/ 32277:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					const newString = value + (stringSuffix ? stringSuffix.string : "");
+					const newRange = [
+						argExpr.range[0],
+						(stringSuffix || argExpr).range[1]
+					];
+					stringSuffix = new BasicEvaluatedExpression()
+						.setString(newString)
+						.setSideEffects(
+							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+								argExpr.couldHaveSideEffects()
+						)
+						.setRange(newRange);
+				}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				if (hasUnknownParams) {
+					const prefix = param.isString() ? param : param.prefix;
+					const inner =
+						param.isWrapped() && param.wrappedInnerExpressions
+							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+							: innerExpressions.reverse();
+					return new BasicEvaluatedExpression()
+						.setWrapped(prefix, stringSuffix, inner)
+						.setRange(expr.range);
+				} else if (param.isWrapped()) {
+					const postfix = stringSuffix || param.postfix;
+					const inner = param.wrappedInnerExpressions
+						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+						: innerExpressions.reverse();
+					return new BasicEvaluatedExpression()
+						.setWrapped(param.prefix, postfix, inner)
+						.setRange(expr.range);
+				} else {
+					const newString =
+						param.string + (stringSuffix ? stringSuffix.string : "");
+					return new BasicEvaluatedExpression()
+						.setString(newString)
+						.setSideEffects(
+							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+								param.couldHaveSideEffects()
+						)
+						.setRange(expr.range);
+				}
+			});
+		this.hooks.evaluateCallExpressionMember
+			.for("split")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length !== 1) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				let result;
+				const arg = this.evaluateExpression(expr.arguments[0]);
+				if (arg.isString()) {
+					result = param.string.split(arg.string);
+				} else if (arg.isRegExp()) {
+					result = param.string.split(arg.regExp);
+				} else {
+					return;
+				}
+				return new BasicEvaluatedExpression()
+					.setArray(result)
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		this.hooks.evaluate
+			.for("ConditionalExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ConditionalExpressionNode} */ (_expr);
 
+				const condition = this.evaluateExpression(expr.test);
+				const conditionValue = condition.asBool();
+				let res;
+				if (conditionValue === undefined) {
+					const consequent = this.evaluateExpression(expr.consequent);
+					const alternate = this.evaluateExpression(expr.alternate);
+					if (!consequent || !alternate) return;
+					res = new BasicEvaluatedExpression();
+					if (consequent.isConditional()) {
+						res.setOptions(consequent.options);
+					} else {
+						res.setOptions([consequent]);
+					}
+					if (alternate.isConditional()) {
+						res.addOptions(alternate.options);
+					} else {
+						res.addOptions([alternate]);
+					}
+				} else {
+					res = this.evaluateExpression(
+						conditionValue ? expr.consequent : expr.alternate
+					);
+					if (condition.couldHaveSideEffects()) res.setSideEffects();
+				}
+				res.setRange(expr.range);
+				return res;
+			});
+		this.hooks.evaluate
+			.for("ArrayExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ArrayExpressionNode} */ (_expr);
 
+				const items = expr.elements.map(element => {
+					return (
+						element !== null &&
+						element.type !== "SpreadElement" &&
+						this.evaluateExpression(element)
+					);
+				});
+				if (!items.every(Boolean)) return;
+				return new BasicEvaluatedExpression()
+					.setItems(items)
+					.setRange(expr.range);
+			});
+		this.hooks.evaluate
+			.for("ChainExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ChainExpressionNode} */ (_expr);
+				/** @type {ExpressionNode[]} */
+				const optionalExpressionsStack = [];
+				/** @type {ExpressionNode|SuperNode} */
+				let next = expr.expression;
 
-const ExternalsPlugin = __webpack_require__(6652);
+				while (
+					next.type === "MemberExpression" ||
+					next.type === "CallExpression"
+				) {
+					if (next.type === "MemberExpression") {
+						if (next.optional) {
+							// SuperNode can not be optional
+							optionalExpressionsStack.push(
+								/** @type {ExpressionNode} */ (next.object)
+							);
+						}
+						next = next.object;
+					} else {
+						if (next.optional) {
+							// SuperNode can not be optional
+							optionalExpressionsStack.push(
+								/** @type {ExpressionNode} */ (next.callee)
+							);
+						}
+						next = next.callee;
+					}
+				}
 
-/** @typedef {import("../Compiler")} Compiler */
+				while (optionalExpressionsStack.length > 0) {
+					const expression = optionalExpressionsStack.pop();
+					const evaluated = this.evaluateExpression(expression);
 
-class ElectronTargetPlugin {
-	/**
-	 * @param {"main" | "preload" | "renderer"=} context in main, preload or renderer context?
-	 */
-	constructor(context) {
-		this._context = context;
+					if (evaluated && evaluated.asNullish()) {
+						return evaluated.setRange(_expr.range);
+					}
+				}
+				return this.evaluateExpression(expr.expression);
+			});
+	}
+
+	getRenameIdentifier(expr) {
+		const result = this.evaluateExpression(expr);
+		if (result && result.isIdentifier()) {
+			return result.identifier;
+		}
 	}
+
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", [
-			"clipboard",
-			"crash-reporter",
-			"electron",
-			"ipc",
-			"native-image",
-			"original-fs",
-			"screen",
-			"shell"
-		]).apply(compiler);
-		switch (this._context) {
-			case "main":
-				new ExternalsPlugin("node-commonjs", [
-					"app",
-					"auto-updater",
-					"browser-window",
-					"content-tracing",
-					"dialog",
-					"global-shortcut",
-					"ipc-main",
-					"menu",
-					"menu-item",
-					"power-monitor",
-					"power-save-blocker",
-					"protocol",
-					"session",
-					"tray",
-					"web-contents"
-				]).apply(compiler);
-				break;
-			case "preload":
-			case "renderer":
-				new ExternalsPlugin("node-commonjs", [
-					"desktop-capturer",
-					"ipc-renderer",
-					"remote",
-					"web-frame"
-				]).apply(compiler);
-				break;
+	walkClass(classy) {
+		if (classy.superClass) {
+			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
+				this.walkExpression(classy.superClass);
+			}
+		}
+		if (classy.body && classy.body.type === "ClassBody") {
+			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
+				if (!this.hooks.classBodyElement.call(classElement, classy)) {
+					if (classElement.computed && classElement.key) {
+						this.walkExpression(classElement.key);
+					}
+					if (classElement.value) {
+						if (
+							!this.hooks.classBodyValue.call(
+								classElement.value,
+								classElement,
+								classy
+							)
+						) {
+							const wasTopLevel = this.scope.topLevelScope;
+							this.scope.topLevelScope = false;
+							this.walkExpression(classElement.value);
+							this.scope.topLevelScope = wasTopLevel;
+						}
+					}
+				}
+			}
 		}
 	}
-}
-
-module.exports = ElectronTargetPlugin;
 
+	// Pre walking iterates the scope for variable declarations
+	preWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.preWalkStatement(statement);
+		}
+	}
 
-/***/ }),
-
-/***/ 22273:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	// Block pre walking iterates the scope for block variable declarations
+	blockPreWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.blockPreWalkStatement(statement);
+		}
+	}
 
+	// Walking iterates the statements and expressions and processes them
+	walkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.walkStatement(statement);
+		}
+	}
 
+	preWalkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.preStatement.call(statement)) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "BlockStatement":
+				this.preWalkBlockStatement(statement);
+				break;
+			case "DoWhileStatement":
+				this.preWalkDoWhileStatement(statement);
+				break;
+			case "ForInStatement":
+				this.preWalkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.preWalkForOfStatement(statement);
+				break;
+			case "ForStatement":
+				this.preWalkForStatement(statement);
+				break;
+			case "FunctionDeclaration":
+				this.preWalkFunctionDeclaration(statement);
+				break;
+			case "IfStatement":
+				this.preWalkIfStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.preWalkLabeledStatement(statement);
+				break;
+			case "SwitchStatement":
+				this.preWalkSwitchStatement(statement);
+				break;
+			case "TryStatement":
+				this.preWalkTryStatement(statement);
+				break;
+			case "VariableDeclaration":
+				this.preWalkVariableDeclaration(statement);
+				break;
+			case "WhileStatement":
+				this.preWalkWhileStatement(statement);
+				break;
+			case "WithStatement":
+				this.preWalkWithStatement(statement);
+				break;
+		}
+		this.prevStatement = this.statementPath.pop();
+	}
 
-const WebpackError = __webpack_require__(53799);
+	blockPreWalkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.blockPreStatement.call(statement)) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "ImportDeclaration":
+				this.blockPreWalkImportDeclaration(statement);
+				break;
+			case "ExportAllDeclaration":
+				this.blockPreWalkExportAllDeclaration(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.blockPreWalkExportDefaultDeclaration(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.blockPreWalkExportNamedDeclaration(statement);
+				break;
+			case "VariableDeclaration":
+				this.blockPreWalkVariableDeclaration(statement);
+				break;
+			case "ClassDeclaration":
+				this.blockPreWalkClassDeclaration(statement);
+				break;
+		}
+		this.prevStatement = this.statementPath.pop();
+	}
 
-/** @typedef {import("../Module")} Module */
+	walkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.statement.call(statement) !== undefined) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "BlockStatement":
+				this.walkBlockStatement(statement);
+				break;
+			case "ClassDeclaration":
+				this.walkClassDeclaration(statement);
+				break;
+			case "DoWhileStatement":
+				this.walkDoWhileStatement(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.walkExportDefaultDeclaration(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.walkExportNamedDeclaration(statement);
+				break;
+			case "ExpressionStatement":
+				this.walkExpressionStatement(statement);
+				break;
+			case "ForInStatement":
+				this.walkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.walkForOfStatement(statement);
+				break;
+			case "ForStatement":
+				this.walkForStatement(statement);
+				break;
+			case "FunctionDeclaration":
+				this.walkFunctionDeclaration(statement);
+				break;
+			case "IfStatement":
+				this.walkIfStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.walkLabeledStatement(statement);
+				break;
+			case "ReturnStatement":
+				this.walkReturnStatement(statement);
+				break;
+			case "SwitchStatement":
+				this.walkSwitchStatement(statement);
+				break;
+			case "ThrowStatement":
+				this.walkThrowStatement(statement);
+				break;
+			case "TryStatement":
+				this.walkTryStatement(statement);
+				break;
+			case "VariableDeclaration":
+				this.walkVariableDeclaration(statement);
+				break;
+			case "WhileStatement":
+				this.walkWhileStatement(statement);
+				break;
+			case "WithStatement":
+				this.walkWithStatement(statement);
+				break;
+		}
+		this.prevStatement = this.statementPath.pop();
+	}
 
-class BuildCycleError extends WebpackError {
 	/**
-	 * Creates an instance of ModuleDependencyError.
-	 * @param {Module} module the module starting the cycle
+	 * Walks a statements that is nested within a parent statement
+	 * and can potentially be a non-block statement.
+	 * This enforces the nested statement to never be in ASI position.
+	 * @param {StatementNode} statement the nested statement
+	 * @returns {void}
 	 */
-	constructor(module) {
-		super(
-			"There is a circular build dependency, which makes it impossible to create this module"
-		);
-
-		this.name = "BuildCycleError";
-		this.module = module;
+	walkNestedStatement(statement) {
+		this.prevStatement = undefined;
+		this.walkStatement(statement);
 	}
-}
-
-module.exports = BuildCycleError;
 
+	// Real Statements
+	preWalkBlockStatement(statement) {
+		this.preWalkStatements(statement.body);
+	}
 
-/***/ }),
+	walkBlockStatement(statement) {
+		this.inBlockScope(() => {
+			const body = statement.body;
+			const prev = this.prevStatement;
+			this.blockPreWalkStatements(body);
+			this.prevStatement = prev;
+			this.walkStatements(body);
+		});
+	}
 
-/***/ 5294:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	walkExpressionStatement(statement) {
+		this.walkExpression(statement.expression);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	preWalkIfStatement(statement) {
+		this.preWalkStatement(statement.consequent);
+		if (statement.alternate) {
+			this.preWalkStatement(statement.alternate);
+		}
+	}
 
+	walkIfStatement(statement) {
+		const result = this.hooks.statementIf.call(statement);
+		if (result === undefined) {
+			this.walkExpression(statement.test);
+			this.walkNestedStatement(statement.consequent);
+			if (statement.alternate) {
+				this.walkNestedStatement(statement.alternate);
+			}
+		} else {
+			if (result) {
+				this.walkNestedStatement(statement.consequent);
+			} else if (statement.alternate) {
+				this.walkNestedStatement(statement.alternate);
+			}
+		}
+	}
 
+	preWalkLabeledStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
 
-const RuntimeModule = __webpack_require__(16963);
+	walkLabeledStatement(statement) {
+		const hook = this.hooks.label.get(statement.label.name);
+		if (hook !== undefined) {
+			const result = hook.call(statement);
+			if (result === true) return;
+		}
+		this.walkNestedStatement(statement.body);
+	}
 
-class ExportWebpackRequireRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("export webpack runtime", RuntimeModule.STAGE_ATTACH);
+	preWalkWithStatement(statement) {
+		this.preWalkStatement(statement.body);
 	}
 
-	/**
-	 * @returns {boolean} true, if the runtime module should get it's own scope
-	 */
-	shouldIsolate() {
-		return false;
+	walkWithStatement(statement) {
+		this.walkExpression(statement.object);
+		this.walkNestedStatement(statement.body);
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return "export default __webpack_require__;";
+	preWalkSwitchStatement(statement) {
+		this.preWalkSwitchCases(statement.cases);
 	}
-}
 
-module.exports = ExportWebpackRequireRuntimeModule;
+	walkSwitchStatement(statement) {
+		this.walkExpression(statement.discriminant);
+		this.walkSwitchCases(statement.cases);
+	}
 
+	walkTerminatingStatement(statement) {
+		if (statement.argument) this.walkExpression(statement.argument);
+	}
 
-/***/ }),
+	walkReturnStatement(statement) {
+		this.walkTerminatingStatement(statement);
+	}
 
-/***/ 68927:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	walkThrowStatement(statement) {
+		this.walkTerminatingStatement(statement);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	preWalkTryStatement(statement) {
+		this.preWalkStatement(statement.block);
+		if (statement.handler) this.preWalkCatchClause(statement.handler);
+		if (statement.finializer) this.preWalkStatement(statement.finializer);
+	}
 
+	walkTryStatement(statement) {
+		if (this.scope.inTry) {
+			this.walkStatement(statement.block);
+		} else {
+			this.scope.inTry = true;
+			this.walkStatement(statement.block);
+			this.scope.inTry = false;
+		}
+		if (statement.handler) this.walkCatchClause(statement.handler);
+		if (statement.finalizer) this.walkStatement(statement.finalizer);
+	}
 
+	preWalkWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
 
-const { ConcatSource } = __webpack_require__(51255);
-const { RuntimeGlobals } = __webpack_require__(91919);
-const HotUpdateChunk = __webpack_require__(9597);
-const Template = __webpack_require__(39722);
-const { getAllChunks } = __webpack_require__(91145);
-const {
-	getCompilationHooks,
-	getChunkFilenameTemplate
-} = __webpack_require__(89464);
-const { updateHashForEntryStartup } = __webpack_require__(98124);
+	walkWhileStatement(statement) {
+		this.walkExpression(statement.test);
+		this.walkNestedStatement(statement.body);
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	preWalkDoWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
 
-class ModuleChunkFormatPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ModuleChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ModuleChunkFormatPlugin",
-					(chunk, set) => {
-						if (chunk.hasRuntime()) return;
-						if (compilation.chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.require);
-							set.add(RuntimeGlobals.startupEntrypoint);
-							set.add(RuntimeGlobals.externalInstallChunk);
-						}
-					}
-				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"ModuleChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
-						const source = new ConcatSource();
-						if (hotUpdateChunk) {
-							throw new Error(
-								"HMR is not implemented for module chunk format yet"
-							);
-						} else {
-							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
-							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
-							source.add(`export const modules = `);
-							source.add(modules);
-							source.add(`;\n`);
-							const runtimeModules =
-								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-							if (runtimeModules.length > 0) {
-								source.add("export const runtime =\n");
-								source.add(
-									Template.renderChunkRuntimeModules(
-										runtimeModules,
-										renderContext
-									)
-								);
-							}
-							const entries = Array.from(
-								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-							);
-							if (entries.length > 0) {
-								const runtimeChunk = entries[0][1].getRuntimeChunk();
-								const currentOutputName = compilation
-									.getPath(
-										getChunkFilenameTemplate(chunk, compilation.outputOptions),
-										{
-											chunk,
-											contentHashType: "javascript"
-										}
-									)
-									.split("/");
+	walkDoWhileStatement(statement) {
+		this.walkNestedStatement(statement.body);
+		this.walkExpression(statement.test);
+	}
 
-								// remove filename, we only need the directory
-								currentOutputName.pop();
+	preWalkForStatement(statement) {
+		if (statement.init) {
+			if (statement.init.type === "VariableDeclaration") {
+				this.preWalkStatement(statement.init);
+			}
+		}
+		this.preWalkStatement(statement.body);
+	}
 
-								const getRelativePath = chunk => {
-									const baseOutputName = currentOutputName.slice();
-									const chunkOutputName = compilation
-										.getPath(
-											getChunkFilenameTemplate(
-												chunk,
-												compilation.outputOptions
-											),
-											{
-												chunk: chunk,
-												contentHashType: "javascript"
-											}
-										)
-										.split("/");
+	walkForStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.init) {
+				if (statement.init.type === "VariableDeclaration") {
+					this.blockPreWalkVariableDeclaration(statement.init);
+					this.prevStatement = undefined;
+					this.walkStatement(statement.init);
+				} else {
+					this.walkExpression(statement.init);
+				}
+			}
+			if (statement.test) {
+				this.walkExpression(statement.test);
+			}
+			if (statement.update) {
+				this.walkExpression(statement.update);
+			}
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
+	}
 
-									// remove common parts
-									while (
-										baseOutputName.length > 0 &&
-										chunkOutputName.length > 0 &&
-										baseOutputName[0] === chunkOutputName[0]
-									) {
-										baseOutputName.shift();
-										chunkOutputName.shift();
-									}
-									// create final path
-									return (
-										(baseOutputName.length > 0
-											? "../".repeat(baseOutputName.length)
-											: "./") + chunkOutputName.join("/")
-									);
-								};
+	preWalkForInStatement(statement) {
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkVariableDeclaration(statement.left);
+		}
+		this.preWalkStatement(statement.body);
+	}
 
-								const entrySource = new ConcatSource();
-								entrySource.add(source);
-								entrySource.add(";\n\n// load runtime\n");
-								entrySource.add(
-									`import __webpack_require__ from ${JSON.stringify(
-										getRelativePath(runtimeChunk)
-									)};\n`
-								);
+	walkForInStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.left.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.left);
+				this.walkVariableDeclaration(statement.left);
+			} else {
+				this.walkPattern(statement.left);
+			}
+			this.walkExpression(statement.right);
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
+	}
 
-								const startupSource = new ConcatSource();
-								startupSource.add(
-									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-										`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
-										"moduleId"
-									)}\n`
-								);
+	preWalkForOfStatement(statement) {
+		if (statement.await && this.scope.topLevelScope === true) {
+			this.hooks.topLevelAwait.call(statement);
+		}
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkVariableDeclaration(statement.left);
+		}
+		this.preWalkStatement(statement.body);
+	}
 
-								const loadedChunks = new Set();
-								let index = 0;
-								for (let i = 0; i < entries.length; i++) {
-									const [module, entrypoint] = entries[i];
-									const final = i + 1 === entries.length;
-									const moduleId = chunkGraph.getModuleId(module);
-									const chunks = getAllChunks(
-										entrypoint,
-										runtimeChunk,
-										undefined
-									);
-									for (const chunk of chunks) {
-										if (loadedChunks.has(chunk)) continue;
-										loadedChunks.add(chunk);
-										startupSource.add(
-											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
-												getRelativePath(chunk)
-											)};\n`
-										);
-										startupSource.add(
-											`${RuntimeGlobals.externalInstallChunk}(__webpack_chunk_${index}__);\n`
-										);
-										index++;
-									}
-									startupSource.add(
-										`${
-											final ? "var __webpack_exports__ = " : ""
-										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
-									);
-								}
+	walkForOfStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.left.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.left);
+				this.walkVariableDeclaration(statement.left);
+			} else {
+				this.walkPattern(statement.left);
+			}
+			this.walkExpression(statement.right);
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
+	}
 
-								entrySource.add(
-									hooks.renderStartup.call(
-										startupSource,
-										entries[entries.length - 1][0],
-										{
-											...renderContext,
-											inlined: false
-										}
-									)
-								);
-								return entrySource;
-							}
-						}
-						return source;
+	// Declarations
+	preWalkFunctionDeclaration(statement) {
+		if (statement.id) {
+			this.defineVariable(statement.id.name);
+		}
+	}
+
+	walkFunctionDeclaration(statement) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = false;
+		this.inFunctionScope(true, statement.params, () => {
+			for (const param of statement.params) {
+				this.walkPattern(param);
+			}
+			if (statement.body.type === "BlockStatement") {
+				this.detectMode(statement.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(statement.body);
+				this.prevStatement = prev;
+				this.walkStatement(statement.body);
+			} else {
+				this.walkExpression(statement.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
+
+	blockPreWalkImportDeclaration(statement) {
+		const source = statement.source.value;
+		this.hooks.import.call(statement, source);
+		for (const specifier of statement.specifiers) {
+			const name = specifier.local.name;
+			switch (specifier.type) {
+				case "ImportDefaultSpecifier":
+					if (
+						!this.hooks.importSpecifier.call(statement, source, "default", name)
+					) {
+						this.defineVariable(name);
 					}
-				);
-				hooks.chunkHash.tap(
-					"ModuleChunkFormatPlugin",
-					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update("ModuleChunkFormatPlugin");
-						hash.update("1");
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
+					break;
+				case "ImportSpecifier":
+					if (
+						!this.hooks.importSpecifier.call(
+							statement,
+							source,
+							specifier.imported.name,
+							name
+						)
+					) {
+						this.defineVariable(name);
 					}
-				);
+					break;
+				case "ImportNamespaceSpecifier":
+					if (!this.hooks.importSpecifier.call(statement, source, null, name)) {
+						this.defineVariable(name);
+					}
+					break;
+				default:
+					this.defineVariable(name);
 			}
-		);
+		}
 	}
-}
-
-module.exports = ModuleChunkFormatPlugin;
-
 
-/***/ }),
+	enterDeclaration(declaration, onIdent) {
+		switch (declaration.type) {
+			case "VariableDeclaration":
+				for (const declarator of declaration.declarations) {
+					switch (declarator.type) {
+						case "VariableDeclarator": {
+							this.enterPattern(declarator.id, onIdent);
+							break;
+						}
+					}
+				}
+				break;
+			case "FunctionDeclaration":
+				this.enterPattern(declaration.id, onIdent);
+				break;
+			case "ClassDeclaration":
+				this.enterPattern(declaration.id, onIdent);
+				break;
+		}
+	}
 
-/***/ 89831:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	blockPreWalkExportNamedDeclaration(statement) {
+		let source;
+		if (statement.source) {
+			source = statement.source.value;
+			this.hooks.exportImport.call(statement, source);
+		} else {
+			this.hooks.export.call(statement);
+		}
+		if (statement.declaration) {
+			if (
+				!this.hooks.exportDeclaration.call(statement, statement.declaration)
+			) {
+				const prev = this.prevStatement;
+				this.preWalkStatement(statement.declaration);
+				this.prevStatement = prev;
+				this.blockPreWalkStatement(statement.declaration);
+				let index = 0;
+				this.enterDeclaration(statement.declaration, def => {
+					this.hooks.exportSpecifier.call(statement, def, def, index++);
+				});
+			}
+		}
+		if (statement.specifiers) {
+			for (
+				let specifierIndex = 0;
+				specifierIndex < statement.specifiers.length;
+				specifierIndex++
+			) {
+				const specifier = statement.specifiers[specifierIndex];
+				switch (specifier.type) {
+					case "ExportSpecifier": {
+						const name = specifier.exported.name;
+						if (source) {
+							this.hooks.exportImportSpecifier.call(
+								statement,
+								source,
+								specifier.local.name,
+								name,
+								specifierIndex
+							);
+						} else {
+							this.hooks.exportSpecifier.call(
+								statement,
+								specifier.local.name,
+								name,
+								specifierIndex
+							);
+						}
+						break;
+					}
+				}
+			}
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	walkExportNamedDeclaration(statement) {
+		if (statement.declaration) {
+			this.walkStatement(statement.declaration);
+		}
+	}
 
+	blockPreWalkExportDefaultDeclaration(statement) {
+		const prev = this.prevStatement;
+		this.preWalkStatement(statement.declaration);
+		this.prevStatement = prev;
+		this.blockPreWalkStatement(statement.declaration);
+		if (
+			statement.declaration.id &&
+			statement.declaration.type !== "FunctionExpression" &&
+			statement.declaration.type !== "ClassExpression"
+		) {
+			this.hooks.exportSpecifier.call(
+				statement,
+				statement.declaration.id.name,
+				"default",
+				undefined
+			);
+		}
+	}
 
+	walkExportDefaultDeclaration(statement) {
+		this.hooks.export.call(statement);
+		if (
+			statement.declaration.id &&
+			statement.declaration.type !== "FunctionExpression" &&
+			statement.declaration.type !== "ClassExpression"
+		) {
+			if (
+				!this.hooks.exportDeclaration.call(statement, statement.declaration)
+			) {
+				this.walkStatement(statement.declaration);
+			}
+		} else {
+			// Acorn parses `export default function() {}` as `FunctionDeclaration` and
+			// `export default class {}` as `ClassDeclaration`, both with `id = null`.
+			// These nodes must be treated as expressions.
+			if (
+				statement.declaration.type === "FunctionDeclaration" ||
+				statement.declaration.type === "ClassDeclaration"
+			) {
+				this.walkStatement(statement.declaration);
+			} else {
+				this.walkExpression(statement.declaration);
+			}
+			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
+				this.hooks.exportSpecifier.call(
+					statement,
+					statement.declaration,
+					"default",
+					undefined
+				);
+			}
+		}
+	}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const ExportWebpackRequireRuntimeModule = __webpack_require__(5294);
-const ModuleChunkLoadingRuntimeModule = __webpack_require__(64747);
+	blockPreWalkExportAllDeclaration(statement) {
+		const source = statement.source.value;
+		const name = statement.exported ? statement.exported.name : null;
+		this.hooks.exportImport.call(statement, source);
+		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	preWalkVariableDeclaration(statement) {
+		if (statement.kind !== "var") return;
+		this._preWalkVariableDeclaration(statement, this.hooks.varDeclarationVar);
+	}
 
-class ModuleChunkLoadingPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ModuleChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						(options && options.chunkLoading) || globalChunkLoading;
-					return chunkLoading === "import";
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new ModuleChunkLoadingRuntimeModule(set)
-					);
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						compilation.addRuntimeModule(
-							chunk,
-							new ExportWebpackRequireRuntimeModule()
-						);
-					});
+	blockPreWalkVariableDeclaration(statement) {
+		if (statement.kind === "var") return;
+		const hookMap =
+			statement.kind === "const"
+				? this.hooks.varDeclarationConst
+				: this.hooks.varDeclarationLet;
+		this._preWalkVariableDeclaration(statement, hookMap);
+	}
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
+	_preWalkVariableDeclaration(statement, hookMap) {
+		for (const declarator of statement.declarations) {
+			switch (declarator.type) {
+				case "VariableDeclarator": {
+					if (!this.hooks.preDeclarator.call(declarator, statement)) {
+						this.enterPattern(declarator.id, (name, decl) => {
+							let hook = hookMap.get(name);
+							if (hook === undefined || !hook.call(decl)) {
+								hook = this.hooks.varDeclaration.get(name);
+								if (hook === undefined || !hook.call(decl)) {
+									this.defineVariable(name);
+								}
+							}
+						});
+					}
+					break;
+				}
 			}
-		);
+		}
 	}
-}
-
-module.exports = ModuleChunkLoadingPlugin;
-
 
-/***/ }),
+	walkVariableDeclaration(statement) {
+		for (const declarator of statement.declarations) {
+			switch (declarator.type) {
+				case "VariableDeclarator": {
+					const renameIdentifier =
+						declarator.init && this.getRenameIdentifier(declarator.init);
+					if (renameIdentifier && declarator.id.type === "Identifier") {
+						const hook = this.hooks.canRename.get(renameIdentifier);
+						if (hook !== undefined && hook.call(declarator.init)) {
+							// renaming with "var a = b;"
+							const hook = this.hooks.rename.get(renameIdentifier);
+							if (hook === undefined || !hook.call(declarator.init)) {
+								this.setVariable(declarator.id.name, renameIdentifier);
+							}
+							break;
+						}
+					}
+					if (!this.hooks.declarator.call(declarator, statement)) {
+						this.walkPattern(declarator.id);
+						if (declarator.init) this.walkExpression(declarator.init);
+					}
+					break;
+				}
+			}
+		}
+	}
 
-/***/ 64747:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	blockPreWalkClassDeclaration(statement) {
+		if (statement.id) {
+			this.defineVariable(statement.id.name);
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	walkClassDeclaration(statement) {
+		this.walkClass(statement);
+	}
 
+	preWalkSwitchCases(switchCases) {
+		for (let index = 0, len = switchCases.length; index < len; index++) {
+			const switchCase = switchCases[index];
+			this.preWalkStatements(switchCase.consequent);
+		}
+	}
 
+	walkSwitchCases(switchCases) {
+		this.inBlockScope(() => {
+			const len = switchCases.length;
 
-const { SyncWaterfallHook } = __webpack_require__(41242);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const {
-	getChunkFilenameTemplate,
-	chunkHasJs
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
+			// we need to pre walk all statements first since we can have invalid code
+			// import A from "module";
+			// switch(1) {
+			//    case 1:
+			//      console.log(A); // should fail at runtime
+			//    case 2:
+			//      const A = 1;
+			// }
+			for (let index = 0; index < len; index++) {
+				const switchCase = switchCases[index];
 
-/** @typedef {import("../Chunk")} Chunk */
+				if (switchCase.consequent.length > 0) {
+					const prev = this.prevStatement;
+					this.blockPreWalkStatements(switchCase.consequent);
+					this.prevStatement = prev;
+				}
+			}
 
-/**
- * @typedef {Object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
- */
+			for (let index = 0; index < len; index++) {
+				const switchCase = switchCases[index];
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
+				if (switchCase.test) {
+					this.walkExpression(switchCase.test);
+				}
+				if (switchCase.consequent.length > 0) {
+					this.walkStatements(switchCase.consequent);
+				}
+			}
+		});
+	}
 
-class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
+	preWalkCatchClause(catchClause) {
+		this.preWalkStatement(catchClause.body);
 	}
 
-	constructor(runtimeRequirements) {
-		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
-		this._runtimeRequirements = runtimeRequirements;
+	walkCatchClause(catchClause) {
+		this.inBlockScope(() => {
+			// Error binding is optional in catch clause since ECMAScript 2019
+			if (catchClause.param !== null) {
+				this.enterPattern(catchClause.param, ident => {
+					this.defineVariable(ident);
+				});
+				this.walkPattern(catchClause.param);
+			}
+			const prev = this.prevStatement;
+			this.blockPreWalkStatement(catchClause.body);
+			this.prevStatement = prev;
+			this.walkStatement(catchClause.body);
+		});
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, chunk } = this;
-		const {
-			runtimeTemplate,
-			chunkGraph,
-			outputOptions: { importFunctionName, importMetaName }
-		} = compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withExternalInstallChunk = this._runtimeRequirements.has(
-			RuntimeGlobals.externalInstallChunk
-		);
-		const withLoading = this._runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withOnChunkLoad = this._runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withHmr = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
-
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			true
-		);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_module`
-			: undefined;
-
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
-							rootOutputDir
-						)}, ${importMetaName}.url);`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
-						runtimeTemplate.destructureObject(
-							["ids", "modules", "runtime"],
-							"data"
-						),
-						'// add "modules" to the modules object,',
-						'// then flag all "ids" as loaded and fire callback',
-						"var moduleId, chunkId, i = 0;",
-						"for(moduleId in modules) {",
-						Template.indent([
-							`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
-							Template.indent(
-								`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
-							),
-							"}"
-						]),
-						"}",
-						"if(runtime) runtime(__webpack_require__);",
-						"for(;i < ids.length; i++) {",
-						Template.indent([
-							"chunkId = ids[i];",
-							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
-							Template.indent("installedChunks[chunkId][0]();"),
-							"}",
-							"installedChunks[ids[i]] = 0;"
-						]),
-						"}",
-						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
-				  ])}`
-				: "// no install chunk",
-			"",
-			withLoading
-				? Template.asString([
-						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? Template.indent([
-										"// import() chunk loading for javascript",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[1]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasJsMatcher === true
-													? "if(true) { // all chunks have JS"
-													: `if(${hasJsMatcher("chunkId")}) {`,
-												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = ${importFunctionName}(${JSON.stringify(
-														rootOutputDir
-													)} + ${
-														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
-														"e",
-														[
-															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
-															"throw e;"
-														]
-													)});`,
-													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve]`,
-														"resolve"
-													)})])`,
-													`promises.push(installedChunkData[1] = promise);`
-												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ])
-								: Template.indent(["installedChunks[chunkId] = 0;"])
-						)};`
-				  ])
-				: "// no chunk on demand loading",
-			"",
-			withExternalInstallChunk
-				? Template.asString([
-						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
-				  ])
-				: "// no external install chunk",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.j = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId] === 0",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded"
-		]);
+	walkPattern(pattern) {
+		switch (pattern.type) {
+			case "ArrayPattern":
+				this.walkArrayPattern(pattern);
+				break;
+			case "AssignmentPattern":
+				this.walkAssignmentPattern(pattern);
+				break;
+			case "MemberExpression":
+				this.walkMemberExpression(pattern);
+				break;
+			case "ObjectPattern":
+				this.walkObjectPattern(pattern);
+				break;
+			case "RestElement":
+				this.walkRestElement(pattern);
+				break;
+		}
 	}
-}
 
-module.exports = ModuleChunkLoadingRuntimeModule;
+	walkAssignmentPattern(pattern) {
+		this.walkExpression(pattern.right);
+		this.walkPattern(pattern.left);
+	}
 
+	walkObjectPattern(pattern) {
+		for (let i = 0, len = pattern.properties.length; i < len; i++) {
+			const prop = pattern.properties[i];
+			if (prop) {
+				if (prop.computed) this.walkExpression(prop.key);
+				if (prop.value) this.walkPattern(prop.value);
+			}
+		}
+	}
 
-/***/ }),
+	walkArrayPattern(pattern) {
+		for (let i = 0, len = pattern.elements.length; i < len; i++) {
+			const element = pattern.elements[i];
+			if (element) this.walkPattern(element);
+		}
+	}
 
-/***/ 16734:
-/***/ (function(module) {
+	walkRestElement(pattern) {
+		this.walkPattern(pattern.argument);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	walkExpressions(expressions) {
+		for (const expression of expressions) {
+			if (expression) {
+				this.walkExpression(expression);
+			}
+		}
+	}
 
+	walkExpression(expression) {
+		switch (expression.type) {
+			case "ArrayExpression":
+				this.walkArrayExpression(expression);
+				break;
+			case "ArrowFunctionExpression":
+				this.walkArrowFunctionExpression(expression);
+				break;
+			case "AssignmentExpression":
+				this.walkAssignmentExpression(expression);
+				break;
+			case "AwaitExpression":
+				this.walkAwaitExpression(expression);
+				break;
+			case "BinaryExpression":
+				this.walkBinaryExpression(expression);
+				break;
+			case "CallExpression":
+				this.walkCallExpression(expression);
+				break;
+			case "ChainExpression":
+				this.walkChainExpression(expression);
+				break;
+			case "ClassExpression":
+				this.walkClassExpression(expression);
+				break;
+			case "ConditionalExpression":
+				this.walkConditionalExpression(expression);
+				break;
+			case "FunctionExpression":
+				this.walkFunctionExpression(expression);
+				break;
+			case "Identifier":
+				this.walkIdentifier(expression);
+				break;
+			case "ImportExpression":
+				this.walkImportExpression(expression);
+				break;
+			case "LogicalExpression":
+				this.walkLogicalExpression(expression);
+				break;
+			case "MetaProperty":
+				this.walkMetaProperty(expression);
+				break;
+			case "MemberExpression":
+				this.walkMemberExpression(expression);
+				break;
+			case "NewExpression":
+				this.walkNewExpression(expression);
+				break;
+			case "ObjectExpression":
+				this.walkObjectExpression(expression);
+				break;
+			case "SequenceExpression":
+				this.walkSequenceExpression(expression);
+				break;
+			case "SpreadElement":
+				this.walkSpreadElement(expression);
+				break;
+			case "TaggedTemplateExpression":
+				this.walkTaggedTemplateExpression(expression);
+				break;
+			case "TemplateLiteral":
+				this.walkTemplateLiteral(expression);
+				break;
+			case "ThisExpression":
+				this.walkThisExpression(expression);
+				break;
+			case "UnaryExpression":
+				this.walkUnaryExpression(expression);
+				break;
+			case "UpdateExpression":
+				this.walkUpdateExpression(expression);
+				break;
+			case "YieldExpression":
+				this.walkYieldExpression(expression);
+				break;
+		}
+	}
 
+	walkAwaitExpression(expression) {
+		if (this.scope.topLevelScope === true)
+			this.hooks.topLevelAwait.call(expression);
+		this.walkExpression(expression.argument);
+	}
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
+	walkArrayExpression(expression) {
+		if (expression.elements) {
+			this.walkExpressions(expression.elements);
+		}
+	}
 
-/**
- * @param {SourcePosition} pos position
- * @returns {string} formatted position
- */
-const formatPosition = pos => {
-	if (pos && typeof pos === "object") {
-		if ("line" in pos && "column" in pos) {
-			return `${pos.line}:${pos.column}`;
-		} else if ("line" in pos) {
-			return `${pos.line}:?`;
+	walkSpreadElement(expression) {
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
 		}
 	}
-	return "";
-};
 
-/**
- * @param {DependencyLocation} loc location
- * @returns {string} formatted location
- */
-const formatLocation = loc => {
-	if (loc && typeof loc === "object") {
-		if ("start" in loc && loc.start && "end" in loc && loc.end) {
-			if (
-				typeof loc.start === "object" &&
-				typeof loc.start.line === "number" &&
-				typeof loc.end === "object" &&
-				typeof loc.end.line === "number" &&
-				typeof loc.end.column === "number" &&
-				loc.start.line === loc.end.line
-			) {
-				return `${formatPosition(loc.start)}-${loc.end.column}`;
-			} else if (
-				typeof loc.start === "object" &&
-				typeof loc.start.line === "number" &&
-				typeof loc.start.column !== "number" &&
-				typeof loc.end === "object" &&
-				typeof loc.end.line === "number" &&
-				typeof loc.end.column !== "number"
-			) {
-				return `${loc.start.line}-${loc.end.line}`;
-			} else {
-				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
-			}
+	walkObjectExpression(expression) {
+		for (
+			let propIndex = 0, len = expression.properties.length;
+			propIndex < len;
+			propIndex++
+		) {
+			const prop = expression.properties[propIndex];
+			this.walkProperty(prop);
 		}
-		if ("start" in loc && loc.start) {
-			return formatPosition(loc.start);
+	}
+
+	walkProperty(prop) {
+		if (prop.type === "SpreadElement") {
+			this.walkExpression(prop.argument);
+			return;
 		}
-		if ("name" in loc && "index" in loc) {
-			return `${loc.name}[${loc.index}]`;
+		if (prop.computed) {
+			this.walkExpression(prop.key);
 		}
-		if ("name" in loc) {
-			return loc.name;
+		if (prop.shorthand && prop.value && prop.value.type === "Identifier") {
+			this.scope.inShorthand = prop.value.name;
+			this.walkIdentifier(prop.value);
+			this.scope.inShorthand = false;
+		} else {
+			this.walkExpression(prop.value);
 		}
 	}
-	return "";
-};
-
-module.exports = formatLocation;
-
-
-/***/ }),
-
-/***/ 27899:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
+	walkFunctionExpression(expression) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = false;
+		const scopeParams = expression.params;
 
+		// Add function name in scope for recursive calls
+		if (expression.id) {
+			scopeParams.push(expression.id.name);
+		}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+		this.inFunctionScope(true, scopeParams, () => {
+			for (const param of expression.params) {
+				this.walkPattern(param);
+			}
+			if (expression.body.type === "BlockStatement") {
+				this.detectMode(expression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(expression.body);
+				this.prevStatement = prev;
+				this.walkStatement(expression.body);
+			} else {
+				this.walkExpression(expression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
 
-class HotModuleReplacementRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("hot module replacement", RuntimeModule.STAGE_BASIC);
+	walkArrowFunctionExpression(expression) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
+		this.inFunctionScope(false, expression.params, () => {
+			for (const param of expression.params) {
+				this.walkPattern(param);
+			}
+			if (expression.body.type === "BlockStatement") {
+				this.detectMode(expression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(expression.body);
+				this.prevStatement = prev;
+				this.walkStatement(expression.body);
+			} else {
+				this.walkExpression(expression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
 	}
+
 	/**
-	 * @returns {string} runtime code
+	 * @param {SequenceExpressionNode} expression the sequence
 	 */
-	generate() {
-		return Template.getFunctionContent(
-			require('./HotModuleReplacement.runtime.js')
-		)
-			.replace(/\$getFullHash\$/g, RuntimeGlobals.getFullHash)
-			.replace(
-				/\$interceptModuleExecution\$/g,
-				RuntimeGlobals.interceptModuleExecution
-			)
-			.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-			.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-			.replace(/\$hmrDownloadManifest\$/g, RuntimeGlobals.hmrDownloadManifest)
-			.replace(
-				/\$hmrInvalidateModuleHandlers\$/g,
-				RuntimeGlobals.hmrInvalidateModuleHandlers
-			)
-			.replace(
-				/\$hmrDownloadUpdateHandlers\$/g,
-				RuntimeGlobals.hmrDownloadUpdateHandlers
-			);
+	walkSequenceExpression(expression) {
+		if (!expression.expressions) return;
+		// We treat sequence expressions like statements when they are one statement level
+		// This has some benefits for optimizations that only work on statement level
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		if (
+			currentStatement === expression ||
+			(currentStatement.type === "ExpressionStatement" &&
+				currentStatement.expression === expression)
+		) {
+			const old = this.statementPath.pop();
+			for (const expr of expression.expressions) {
+				this.statementPath.push(expr);
+				this.walkExpression(expr);
+				this.statementPath.pop();
+			}
+			this.statementPath.push(old);
+		} else {
+			this.walkExpressions(expression.expressions);
+		}
 	}
-}
-
-module.exports = HotModuleReplacementRuntimeModule;
-
-
-/***/ }),
-
-/***/ 79040:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	walkUpdateExpression(expression) {
+		this.walkExpression(expression.argument);
+	}
 
-const { RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Dependency = __webpack_require__(54912);
-const Module = __webpack_require__(73208);
-const ModuleFactory = __webpack_require__(51010);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const CommonJsRequireDependency = __webpack_require__(21264);
-const { registerNotSerializable } = __webpack_require__(8282);
-
-/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-
-/**
- * @typedef {Object} BackendApi
- * @property {function(Error=): void} dispose
- * @property {function(Module): { client: string, data: string, active: boolean }} module
- */
-
-const HMR_DEPENDENCY_TYPES = new Set([
-	"import.meta.webpackHot.accept",
-	"import.meta.webpackHot.decline",
-	"module.hot.accept",
-	"module.hot.decline"
-]);
-
-/**
- * @param {undefined|string|RegExp|Function} test test option
- * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
- */
-const checkTest = (test, module) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module);
-	}
-	if (typeof test === "string") {
-		const name = module.nameForCondition();
-		return name && name.startsWith(test);
-	}
-	if (test instanceof RegExp) {
-		const name = module.nameForCondition();
-		return name && test.test(name);
+	walkUnaryExpression(expression) {
+		if (expression.operator === "typeof") {
+			const result = this.callHooksForExpression(
+				this.hooks.typeof,
+				expression.argument,
+				expression
+			);
+			if (result === true) return;
+			if (expression.argument.type === "ChainExpression") {
+				const result = this.callHooksForExpression(
+					this.hooks.typeof,
+					expression.argument.expression,
+					expression
+				);
+				if (result === true) return;
+			}
+		}
+		this.walkExpression(expression.argument);
 	}
-	return false;
-};
-
-const TYPES = new Set(["javascript"]);
 
-class LazyCompilationDependency extends Dependency {
-	constructor(proxyModule) {
-		super();
-		this.proxyModule = proxyModule;
+	walkLeftRightExpression(expression) {
+		this.walkExpression(expression.left);
+		this.walkExpression(expression.right);
 	}
 
-	get category() {
-		return "esm";
+	walkBinaryExpression(expression) {
+		this.walkLeftRightExpression(expression);
 	}
 
-	get type() {
-		return "lazy import()";
+	walkLogicalExpression(expression) {
+		const result = this.hooks.expressionLogicalOperator.call(expression);
+		if (result === undefined) {
+			this.walkLeftRightExpression(expression);
+		} else {
+			if (result) {
+				this.walkExpression(expression.right);
+			}
+		}
 	}
 
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return this.proxyModule.originalModule.identifier();
+	walkAssignmentExpression(expression) {
+		if (expression.left.type === "Identifier") {
+			const renameIdentifier = this.getRenameIdentifier(expression.right);
+			if (renameIdentifier) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.canRename,
+						renameIdentifier,
+						expression.right
+					)
+				) {
+					// renaming "a = b;"
+					if (
+						!this.callHooksForInfo(
+							this.hooks.rename,
+							renameIdentifier,
+							expression.right
+						)
+					) {
+						this.setVariable(
+							expression.left.name,
+							this.getVariableInfo(renameIdentifier)
+						);
+					}
+					return;
+				}
+			}
+			this.walkExpression(expression.right);
+			this.enterPattern(expression.left, (name, decl) => {
+				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+					this.walkExpression(expression.left);
+				}
+			});
+			return;
+		}
+		if (expression.left.type.endsWith("Pattern")) {
+			this.walkExpression(expression.right);
+			this.enterPattern(expression.left, (name, decl) => {
+				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+					this.defineVariable(name);
+				}
+			});
+			this.walkPattern(expression.left);
+		} else if (expression.left.type === "MemberExpression") {
+			const exprName = this.getMemberExpressionInfo(
+				expression.left,
+				ALLOWED_MEMBER_TYPES_EXPRESSION
+			);
+			if (exprName) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.assignMemberChain,
+						exprName.rootInfo,
+						expression,
+						exprName.getMembers()
+					)
+				) {
+					return;
+				}
+			}
+			this.walkExpression(expression.right);
+			this.walkExpression(expression.left);
+		} else {
+			this.walkExpression(expression.right);
+			this.walkExpression(expression.left);
+		}
 	}
-}
 
-registerNotSerializable(LazyCompilationDependency);
+	walkConditionalExpression(expression) {
+		const result = this.hooks.expressionConditionalOperator.call(expression);
+		if (result === undefined) {
+			this.walkExpression(expression.test);
+			this.walkExpression(expression.consequent);
+			if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
+		} else {
+			if (result) {
+				this.walkExpression(expression.consequent);
+			} else if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
+		}
+	}
 
-class LazyCompilationProxyModule extends Module {
-	constructor(context, originalModule, request, client, data, active) {
-		super("lazy-compilation-proxy", context, originalModule.layer);
-		this.originalModule = originalModule;
-		this.request = request;
-		this.client = client;
-		this.data = data;
-		this.active = active;
+	walkNewExpression(expression) {
+		const result = this.callHooksForExpression(
+			this.hooks.new,
+			expression.callee,
+			expression
+		);
+		if (result === true) return;
+		this.walkExpression(expression.callee);
+		if (expression.arguments) {
+			this.walkExpressions(expression.arguments);
+		}
 	}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
+	walkYieldExpression(expression) {
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
 	}
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
-			requestShortener
-		)}`;
+	walkTemplateLiteral(expression) {
+		if (expression.expressions) {
+			this.walkExpressions(expression.expressions);
+		}
 	}
 
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		super.updateCacheModule(module);
-		const m = /** @type {LazyCompilationProxyModule} */ (module);
-		this.originalModule = m.originalModule;
-		this.request = m.request;
-		this.client = m.client;
-		this.data = m.data;
-		this.active = m.active;
+	walkTaggedTemplateExpression(expression) {
+		if (expression.tag) {
+			this.walkExpression(expression.tag);
+		}
+		if (expression.quasi && expression.quasi.expressions) {
+			this.walkExpressions(expression.quasi.expressions);
+		}
 	}
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
+	walkClassExpression(expression) {
+		this.walkClass(expression);
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {ChainExpressionNode} expression expression
 	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo || this.buildInfo.active !== this.active);
+	walkChainExpression(expression) {
+		const result = this.hooks.optionalChaining.call(expression);
+
+		if (result === undefined) {
+			if (expression.expression.type === "CallExpression") {
+				this.walkCallExpression(expression.expression);
+			} else {
+				this.walkMemberExpression(expression.expression);
+			}
+		}
 	}
 
-	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
-	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildInfo = {
-			active: this.active
+	_walkIIFE(functionExpression, options, currentThis) {
+		const getVarInfo = argOrThis => {
+			const renameIdentifier = this.getRenameIdentifier(argOrThis);
+			if (renameIdentifier) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.canRename,
+						renameIdentifier,
+						argOrThis
+					)
+				) {
+					if (
+						!this.callHooksForInfo(
+							this.hooks.rename,
+							renameIdentifier,
+							argOrThis
+						)
+					) {
+						return this.getVariableInfo(renameIdentifier);
+					}
+				}
+			}
+			this.walkExpression(argOrThis);
 		};
-		/** @type {BuildMeta} */
-		this.buildMeta = {};
-		this.clearDependenciesAndBlocks();
-		const dep = new CommonJsRequireDependency(this.client);
-		this.addDependency(dep);
-		if (this.active) {
-			const dep = new LazyCompilationDependency(this);
-			const block = new AsyncDependenciesBlock({});
-			block.addDependency(dep);
-			this.addBlock(block);
+		const { params, type } = functionExpression;
+		const arrow = type === "ArrowFunctionExpression";
+		const renameThis = currentThis ? getVarInfo(currentThis) : null;
+		const varInfoForArgs = options.map(getVarInfo);
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = wasTopLevel && arrow ? "arrow" : false;
+		const scopeParams = params.filter(
+			(identifier, idx) => !varInfoForArgs[idx]
+		);
+
+		// Add function name in scope for recursive calls
+		if (functionExpression.id) {
+			scopeParams.push(functionExpression.id.name);
 		}
-		callback();
-	}
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
+		this.inFunctionScope(true, scopeParams, () => {
+			if (renameThis && !arrow) {
+				this.setVariable("this", renameThis);
+			}
+			for (let i = 0; i < varInfoForArgs.length; i++) {
+				const varInfo = varInfoForArgs[i];
+				if (!varInfo) continue;
+				if (!params[i] || params[i].type !== "Identifier") continue;
+				this.setVariable(params[i].name, varInfo);
+			}
+			if (functionExpression.body.type === "BlockStatement") {
+				this.detectMode(functionExpression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(functionExpression.body);
+				this.prevStatement = prev;
+				this.walkStatement(functionExpression.body);
+			} else {
+				this.walkExpression(functionExpression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
 	}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 200;
+	walkImportExpression(expression) {
+		let result = this.hooks.importCall.call(expression);
+		if (result === true) return;
+
+		this.walkExpression(expression.source);
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
-		const sources = new Map();
-		const runtimeRequirements = new Set();
-		runtimeRequirements.add(RuntimeGlobals.module);
-		const clientDep = /** @type {CommonJsRequireDependency} */ (
-			this.dependencies[0]
-		);
-		const clientModule = moduleGraph.getModule(clientDep);
-		const block = this.blocks[0];
-		const client = Template.asString([
-			`var client = ${runtimeTemplate.moduleExports({
-				module: clientModule,
-				chunkGraph,
-				request: clientDep.userRequest,
-				runtimeRequirements
-			})}`,
-			`var data = ${JSON.stringify(this.data)};`
-		]);
-		const keepActive = Template.asString([
-			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
-				!!block
-			)}, module: module, onError: onError });`
-		]);
-		let source;
-		if (block) {
-			const dep = block.dependencies[0];
-			const module = moduleGraph.getModule(dep);
-			source = Template.asString([
-				client,
-				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
-					chunkGraph,
-					block,
-					module,
-					request: this.request,
-					strict: false, // TODO this should be inherited from the original module
-					message: "import()",
-					runtimeRequirements
-				})};`,
-				"if (module.hot) {",
-				Template.indent([
-					"module.hot.accept();",
-					`module.hot.accept(${JSON.stringify(
-						chunkGraph.getModuleId(module)
-					)}, function() { module.hot.invalidate(); });`,
-					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
-				]),
-				"}",
-				"function onError() { /* ignore */ }",
-				keepActive
-			]);
+	walkCallExpression(expression) {
+		const isSimpleFunction = fn => {
+			return fn.params.every(p => p.type === "Identifier");
+		};
+		if (
+			expression.callee.type === "MemberExpression" &&
+			expression.callee.object.type.endsWith("FunctionExpression") &&
+			!expression.callee.computed &&
+			(expression.callee.property.name === "call" ||
+				expression.callee.property.name === "bind") &&
+			expression.arguments.length > 0 &&
+			isSimpleFunction(expression.callee.object)
+		) {
+			// (function(…) { }.call/bind(?, …))
+			this._walkIIFE(
+				expression.callee.object,
+				expression.arguments.slice(1),
+				expression.arguments[0]
+			);
+		} else if (
+			expression.callee.type.endsWith("FunctionExpression") &&
+			isSimpleFunction(expression.callee)
+		) {
+			// (function(…) { }(…))
+			this._walkIIFE(expression.callee, expression.arguments, null);
 		} else {
-			source = Template.asString([
-				client,
-				"var resolveSelf, onError;",
-				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
-				"if (module.hot) {",
-				Template.indent([
-					"module.hot.accept();",
-					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
-					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
-				]),
-				"}",
-				keepActive
-			]);
+			if (expression.callee.type === "MemberExpression") {
+				const exprInfo = this.getMemberExpressionInfo(
+					expression.callee,
+					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
+				);
+				if (exprInfo && exprInfo.type === "call") {
+					const result = this.callHooksForInfo(
+						this.hooks.callMemberChainOfCallMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						exprInfo.getCalleeMembers(),
+						exprInfo.call,
+						exprInfo.getMembers()
+					);
+					if (result === true) return;
+				}
+			}
+			const callee = this.evaluateExpression(expression.callee);
+			if (callee.isIdentifier()) {
+				const result1 = this.callHooksForInfo(
+					this.hooks.callMemberChain,
+					callee.rootInfo,
+					expression,
+					callee.getMembers()
+				);
+				if (result1 === true) return;
+				const result2 = this.callHooksForInfo(
+					this.hooks.call,
+					callee.identifier,
+					expression
+				);
+				if (result2 === true) return;
+			}
+
+			if (expression.callee) {
+				if (expression.callee.type === "MemberExpression") {
+					// because of call context we need to walk the call context as expression
+					this.walkExpression(expression.callee.object);
+					if (expression.callee.computed === true)
+						this.walkExpression(expression.callee.property);
+				} else {
+					this.walkExpression(expression.callee);
+				}
+			}
+			if (expression.arguments) this.walkExpressions(expression.arguments);
 		}
-		sources.set("javascript", new RawSource(source));
-		return {
-			sources,
-			runtimeRequirements
-		};
+	}
+
+	walkMemberExpression(expression) {
+		const exprInfo = this.getMemberExpressionInfo(
+			expression,
+			ALLOWED_MEMBER_TYPES_ALL
+		);
+		if (exprInfo) {
+			switch (exprInfo.type) {
+				case "expression": {
+					const result1 = this.callHooksForInfo(
+						this.hooks.expression,
+						exprInfo.name,
+						expression
+					);
+					if (result1 === true) return;
+					const members = exprInfo.getMembers();
+					const result2 = this.callHooksForInfo(
+						this.hooks.expressionMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						members
+					);
+					if (result2 === true) return;
+					this.walkMemberExpressionWithExpressionName(
+						expression,
+						exprInfo.name,
+						exprInfo.rootInfo,
+						members.slice(),
+						() =>
+							this.callHooksForInfo(
+								this.hooks.unhandledExpressionMemberChain,
+								exprInfo.rootInfo,
+								expression,
+								members
+							)
+					);
+					return;
+				}
+				case "call": {
+					const result = this.callHooksForInfo(
+						this.hooks.memberChainOfCallMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						exprInfo.getCalleeMembers(),
+						exprInfo.call,
+						exprInfo.getMembers()
+					);
+					if (result === true) return;
+					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
+					// and call computed property are literals anyway
+					this.walkExpression(exprInfo.call);
+					return;
+				}
+			}
+		}
+		this.walkExpression(expression.object);
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
+
+	walkMemberExpressionWithExpressionName(
+		expression,
+		name,
+		rootInfo,
+		members,
+		onUnhandled
+	) {
+		if (expression.object.type === "MemberExpression") {
+			// optimize the case where expression.object is a MemberExpression too.
+			// we can keep info here when calling walkMemberExpression directly
+			const property =
+				expression.property.name || `${expression.property.value}`;
+			name = name.slice(0, -property.length - 1);
+			members.pop();
+			const result = this.callHooksForInfo(
+				this.hooks.expression,
+				name,
+				expression.object
+			);
+			if (result === true) return;
+			this.walkMemberExpressionWithExpressionName(
+				expression.object,
+				name,
+				rootInfo,
+				members,
+				onUnhandled
+			);
+		} else if (!onUnhandled || !onUnhandled()) {
+			this.walkExpression(expression.object);
+		}
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
+
+	walkThisExpression(expression) {
+		this.callHooksForName(this.hooks.expression, "this", expression);
+	}
+
+	walkIdentifier(expression) {
+		this.callHooksForName(this.hooks.expression, expression.name, expression);
 	}
 
 	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
+	 * @param {MetaPropertyNode} metaProperty meta property
 	 */
-	updateHash(hash, context) {
-		super.updateHash(hash, context);
-		hash.update(this.active ? "active" : "");
-		hash.update(JSON.stringify(this.data));
+	walkMetaProperty(metaProperty) {
+		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
 	}
-}
 
-registerNotSerializable(LazyCompilationProxyModule);
+	callHooksForExpression(hookMap, expr, ...args) {
+		return this.callHooksForExpressionWithFallback(
+			hookMap,
+			expr,
+			undefined,
+			undefined,
+			...args
+		);
+	}
 
-class LazyCompilationDependencyFactory extends ModuleFactory {
-	constructor(factory) {
-		super();
-		this._factory = factory;
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {MemberExpressionNode} expr expression info
+	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
+	 * @param {function(string): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForExpressionWithFallback(
+		hookMap,
+		expr,
+		fallback,
+		defined,
+		...args
+	) {
+		const exprName = this.getMemberExpressionInfo(
+			expr,
+			ALLOWED_MEMBER_TYPES_EXPRESSION
+		);
+		if (exprName !== undefined) {
+			const members = exprName.getMembers();
+			return this.callHooksForInfoWithFallback(
+				hookMap,
+				members.length === 0 ? exprName.rootInfo : exprName.name,
+				fallback &&
+					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
+				defined && (() => defined(exprName.name)),
+				...args
+			);
+		}
 	}
 
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
-	 * @returns {void}
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {string} name key in map
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
 	 */
-	create(data, callback) {
-		const dependency = /** @type {LazyCompilationDependency} */ (
-			data.dependencies[0]
+	callHooksForName(hookMap, name, ...args) {
+		return this.callHooksForNameWithFallback(
+			hookMap,
+			name,
+			undefined,
+			undefined,
+			...args
 		);
-		callback(null, {
-			module: dependency.proxyModule.originalModule
-		});
 	}
-}
 
-class LazyCompilationPlugin {
 	/**
-	 * @param {Object} options options
-	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
-	 * @param {boolean} options.entries true, when entries are lazy compiled
-	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param  {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
 	 */
-	constructor({ backend, entries, imports, test }) {
-		this.backend = backend;
-		this.entries = entries;
-		this.imports = imports;
-		this.test = test;
+	callHooksForInfo(hookMap, info, ...args) {
+		return this.callHooksForInfoWithFallback(
+			hookMap,
+			info,
+			undefined,
+			undefined,
+			...args
+		);
 	}
+
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param {function(string): any} fallback callback when variable in not handled by hooks
+	 * @param {function(): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
 	 */
-	apply(compiler) {
-		let backend;
-		compiler.hooks.beforeCompile.tapAsync(
-			"LazyCompilationPlugin",
-			(params, callback) => {
-				if (backend !== undefined) return callback();
-				const promise = this.backend(compiler, (err, result) => {
-					if (err) return callback(err);
-					backend = result;
-					callback();
-				});
-				if (promise && promise.then) {
-					promise.then(b => {
-						backend = b;
-						callback();
-					}, callback);
+	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
+		let name;
+		if (typeof info === "string") {
+			name = info;
+		} else {
+			if (!(info instanceof VariableInfo)) {
+				if (defined !== undefined) {
+					return defined();
 				}
+				return;
 			}
-		);
-		compiler.hooks.thisCompilation.tap(
-			"LazyCompilationPlugin",
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.module.tap(
-					"LazyCompilationPlugin",
-					(originalModule, createData, resolveData) => {
-						if (
-							resolveData.dependencies.every(dep =>
-								HMR_DEPENDENCY_TYPES.has(dep.type)
-							)
-						) {
-							// for HMR only resolving, try to determine if the HMR accept/decline refers to
-							// an import() or not
-							const hmrDep = resolveData.dependencies[0];
-							const originModule =
-								compilation.moduleGraph.getParentModule(hmrDep);
-							const isReferringToDynamicImport = originModule.blocks.some(
-								block =>
-									block.dependencies.some(
-										dep =>
-											dep.type === "import()" &&
-											/** @type {HarmonyImportDependency} */ (dep).request ===
-												hmrDep.request
-									)
-							);
-							if (!isReferringToDynamicImport) return;
-						} else if (
-							!resolveData.dependencies.every(
-								dep =>
-									HMR_DEPENDENCY_TYPES.has(dep.type) ||
-									(this.imports &&
-										(dep.type === "import()" ||
-											dep.type === "import() context element")) ||
-									(this.entries && dep.type === "entry")
-							)
-						)
-							return;
-						if (
-							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
-								resolveData.request
-							) ||
-							!checkTest(this.test, originalModule)
-						)
-							return;
-						const moduleInfo = backend.module(originalModule);
-						if (!moduleInfo) return;
-						const { client, data, active } = moduleInfo;
-
-						return new LazyCompilationProxyModule(
-							compiler.context,
-							originalModule,
-							resolveData.request,
-							client,
-							data,
-							active
-						);
-					}
-				);
-				compilation.dependencyFactories.set(
-					LazyCompilationDependency,
-					new LazyCompilationDependencyFactory()
-				);
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				const hook = hookMap.get(tagInfo.tag);
+				if (hook !== undefined) {
+					this.currentTagData = tagInfo.data;
+					const result = hook.call(...args);
+					this.currentTagData = undefined;
+					if (result !== undefined) return result;
+				}
+				tagInfo = tagInfo.next;
+			}
+			if (info.freeName === true) {
+				if (defined !== undefined) {
+					return defined();
+				}
+				return;
 			}
+			name = info.freeName;
+		}
+		const hook = hookMap.get(name);
+		if (hook !== undefined) {
+			const result = hook.call(...args);
+			if (result !== undefined) return result;
+		}
+		if (fallback !== undefined) {
+			return fallback(name);
+		}
+	}
+
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {string} name key in map
+	 * @param {function(string): any} fallback callback when variable in not handled by hooks
+	 * @param {function(): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
+		return this.callHooksForInfoWithFallback(
+			hookMap,
+			this.getVariableInfo(name),
+			fallback,
+			defined,
+			...args
 		);
-		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
-			backend.dispose(callback);
-		});
 	}
-}
 
-module.exports = LazyCompilationPlugin;
+	/**
+	 * @deprecated
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
+	inScope(params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
 
+		this.undefineVariable("this");
 
-/***/ }),
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
 
-/***/ 17781:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		fn();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		this.scope = oldScope;
+	}
 
+	inFunctionScope(hasThis, params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
 
+		if (hasThis) {
+			this.undefineVariable("this");
+		}
 
-/** @typedef {import("http").ServerOptions} HttpServerOptions */
-/** @typedef {import("https").ServerOptions} HttpsServerOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
-/** @typedef {import("../Compiler")} Compiler */
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
 
-/**
- * @callback BackendHandler
- * @param {Compiler} compiler compiler
- * @param {function((Error | null)=, any=): void} callback callback
- * @returns {void}
- */
+		fn();
 
-/**
- * @param {Omit<LazyCompilationDefaultBackendOptions, "client"> & { client: NonNullable<LazyCompilationDefaultBackendOptions["client"]>}} options additional options for the backend
- * @returns {BackendHandler} backend
- */
-module.exports = options => (compiler, callback) => {
-	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
-	const activeModules = new Map();
-	const prefix = "/lazy-compilation-using-";
+		this.scope = oldScope;
+	}
 
-	const isHttps =
-		options.protocol === "https" ||
-		(typeof options.server === "object" &&
-			("key" in options.server || "pfx" in options.server));
+	inBlockScope(fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: oldScope.inTry,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
 
-	const createServer =
-		typeof options.server === "function"
-			? options.server
-			: (() => {
-					const http = isHttps ? __webpack_require__(95687) : __webpack_require__(13685);
-					return http.createServer.bind(http, options.server);
-			  })();
-	const listen =
-		typeof options.listen === "function"
-			? options.listen
-			: server => {
-					let listen = options.listen;
-					if (typeof listen === "object" && !("port" in listen))
-						listen = { ...listen, port: undefined };
-					server.listen(listen);
-			  };
+		fn();
 
-	const protocol = options.protocol || (isHttps ? "https" : "http");
+		this.scope = oldScope;
+	}
 
-	const requestListener = (req, res) => {
-		const keys = req.url.slice(prefix.length).split("@");
-		req.socket.on("close", () => {
-			setTimeout(() => {
-				for (const key of keys) {
-					const oldValue = activeModules.get(key) || 0;
-					activeModules.set(key, oldValue - 1);
-					if (oldValue === 1) {
-						logger.log(
-							`${key} is no longer in use. Next compilation will skip this module.`
-						);
-					}
-				}
-			}, 120000);
-		});
-		req.socket.setNoDelay(true);
-		res.writeHead(200, {
-			"content-type": "text/event-stream",
-			"Access-Control-Allow-Origin": "*",
-			"Access-Control-Allow-Methods": "*",
-			"Access-Control-Allow-Headers": "*"
-		});
-		res.write("\n");
-		let moduleActivated = false;
-		for (const key of keys) {
-			const oldValue = activeModules.get(key) || 0;
-			activeModules.set(key, oldValue + 1);
-			if (oldValue === 0) {
-				logger.log(`${key} is now in use and will be compiled.`);
-				moduleActivated = true;
-			}
+	detectMode(statements) {
+		const isLiteral =
+			statements.length >= 1 &&
+			statements[0].type === "ExpressionStatement" &&
+			statements[0].expression.type === "Literal";
+		if (isLiteral && statements[0].expression.value === "use strict") {
+			this.scope.isStrict = true;
 		}
-		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
-	};
+		if (isLiteral && statements[0].expression.value === "use asm") {
+			this.scope.isAsmJs = true;
+		}
+	}
 
-	const server = /** @type {import("net").Server} */ (createServer());
-	server.on("request", requestListener);
+	enterPatterns(patterns, onIdent) {
+		for (const pattern of patterns) {
+			if (typeof pattern !== "string") {
+				this.enterPattern(pattern, onIdent);
+			} else if (pattern) {
+				onIdent(pattern);
+			}
+		}
+	}
 
-	let isClosing = false;
-	/** @type {Set<import("net").Socket>} */
-	const sockets = new Set();
-	server.on("connection", socket => {
-		sockets.add(socket);
-		socket.on("close", () => {
-			sockets.delete(socket);
-		});
-		if (isClosing) socket.destroy();
-	});
-	server.on("clientError", e => {
-		if (e.message !== "Server is disposing") logger.warn(e);
-	});
-	server.on("listening", err => {
-		if (err) return callback(err);
-		const addr = server.address();
-		if (typeof addr === "string") throw new Error("addr must not be a string");
-		const urlBase =
-			addr.address === "::" || addr.address === "0.0.0.0"
-				? `${protocol}://localhost:${addr.port}`
-				: addr.family === "IPv6"
-				? `${protocol}://[${addr.address}]:${addr.port}`
-				: `${protocol}://${addr.address}:${addr.port}`;
-		logger.log(
-			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
-		);
-		callback(null, {
-			dispose(callback) {
-				isClosing = true;
-				// Removing the listener is a workaround for a memory leak in node.js
-				server.off("request", requestListener);
-				server.close(err => {
-					callback(err);
-				});
-				for (const socket of sockets) {
-					socket.destroy(new Error("Server is disposing"));
+	enterPattern(pattern, onIdent) {
+		if (!pattern) return;
+		switch (pattern.type) {
+			case "ArrayPattern":
+				this.enterArrayPattern(pattern, onIdent);
+				break;
+			case "AssignmentPattern":
+				this.enterAssignmentPattern(pattern, onIdent);
+				break;
+			case "Identifier":
+				this.enterIdentifier(pattern, onIdent);
+				break;
+			case "ObjectPattern":
+				this.enterObjectPattern(pattern, onIdent);
+				break;
+			case "RestElement":
+				this.enterRestElement(pattern, onIdent);
+				break;
+			case "Property":
+				if (pattern.shorthand && pattern.value.type === "Identifier") {
+					this.scope.inShorthand = pattern.value.name;
+					this.enterIdentifier(pattern.value, onIdent);
+					this.scope.inShorthand = false;
+				} else {
+					this.enterPattern(pattern.value, onIdent);
 				}
-			},
-			module(originalModule) {
-				const key = `${encodeURIComponent(
-					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
-				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
-				const active = activeModules.get(key) > 0;
-				return {
-					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
-					data: key,
-					active
-				};
-			}
-		});
-	});
-	listen(server);
-};
-
-
-/***/ }),
-
-/***/ 64618:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				break;
+		}
+	}
 
+	enterIdentifier(pattern, onIdent) {
+		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
+			onIdent(pattern.name, pattern);
+		}
+	}
 
+	enterObjectPattern(pattern, onIdent) {
+		for (
+			let propIndex = 0, len = pattern.properties.length;
+			propIndex < len;
+			propIndex++
+		) {
+			const prop = pattern.properties[propIndex];
+			this.enterPattern(prop, onIdent);
+		}
+	}
 
-const { find } = __webpack_require__(93347);
-const {
-	compareModulesByPreOrderIndexOrIdentifier,
-	compareModulesByPostOrderIndexOrIdentifier
-} = __webpack_require__(29579);
+	enterArrayPattern(pattern, onIdent) {
+		for (
+			let elementIndex = 0, len = pattern.elements.length;
+			elementIndex < len;
+			elementIndex++
+		) {
+			const element = pattern.elements[elementIndex];
+			this.enterPattern(element, onIdent);
+		}
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	enterRestElement(pattern, onIdent) {
+		this.enterPattern(pattern.argument, onIdent);
+	}
 
-class ChunkModuleIdRangePlugin {
-	constructor(options) {
-		this.options = options;
+	enterAssignmentPattern(pattern, onIdent) {
+		this.enterPattern(pattern.left, onIdent);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {ExpressionNode} expression expression node
+	 * @returns {BasicEvaluatedExpression | undefined} evaluation result
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("ChunkModuleIdRangePlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.moduleIds.tap("ChunkModuleIdRangePlugin", modules => {
-				const chunkGraph = compilation.chunkGraph;
-				const chunk = find(
-					compilation.chunks,
-					chunk => chunk.name === options.name
-				);
-				if (!chunk) {
-					throw new Error(
-						`ChunkModuleIdRangePlugin: Chunk with name '${options.name}"' was not found`
+	evaluateExpression(expression) {
+		try {
+			const hook = this.hooks.evaluate.get(expression.type);
+			if (hook !== undefined) {
+				const result = hook.call(expression);
+				if (result !== undefined) {
+					if (result) {
+						result.setExpression(expression);
+					}
+					return result;
+				}
+			}
+		} catch (e) {
+			console.warn(e);
+			// ignore error
+		}
+		return new BasicEvaluatedExpression()
+			.setRange(expression.range)
+			.setExpression(expression);
+	}
+
+	parseString(expression) {
+		switch (expression.type) {
+			case "BinaryExpression":
+				if (expression.operator === "+") {
+					return (
+						this.parseString(expression.left) +
+						this.parseString(expression.right)
 					);
 				}
+				break;
+			case "Literal":
+				return expression.value + "";
+		}
+		throw new Error(
+			expression.type + " is not supported as parameter for require"
+		);
+	}
 
-				let chunkModules;
-				if (options.order) {
-					let cmpFn;
-					switch (options.order) {
-						case "index":
-						case "preOrderIndex":
-							cmpFn = compareModulesByPreOrderIndexOrIdentifier(moduleGraph);
-							break;
-						case "index2":
-						case "postOrderIndex":
-							cmpFn = compareModulesByPostOrderIndexOrIdentifier(moduleGraph);
-							break;
-						default:
-							throw new Error(
-								"ChunkModuleIdRangePlugin: unexpected value of order"
-							);
+	parseCalculatedString(expression) {
+		switch (expression.type) {
+			case "BinaryExpression":
+				if (expression.operator === "+") {
+					const left = this.parseCalculatedString(expression.left);
+					const right = this.parseCalculatedString(expression.right);
+					if (left.code) {
+						return {
+							range: left.range,
+							value: left.value,
+							code: true,
+							conditional: false
+						};
+					} else if (right.code) {
+						return {
+							range: [
+								left.range[0],
+								right.range ? right.range[1] : left.range[1]
+							],
+							value: left.value + right.value,
+							code: true,
+							conditional: false
+						};
+					} else {
+						return {
+							range: [left.range[0], right.range[1]],
+							value: left.value + right.value,
+							code: false,
+							conditional: false
+						};
 					}
-					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
+				}
+				break;
+			case "ConditionalExpression": {
+				const consequent = this.parseCalculatedString(expression.consequent);
+				const alternate = this.parseCalculatedString(expression.alternate);
+				const items = [];
+				if (consequent.conditional) {
+					items.push(...consequent.conditional);
+				} else if (!consequent.code) {
+					items.push(consequent);
 				} else {
-					chunkModules = Array.from(modules)
-						.filter(m => {
-							return chunkGraph.isModuleInChunk(m, chunk);
-						})
-						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
+					break;
 				}
-
-				let currentId = options.start || 0;
-				for (let i = 0; i < chunkModules.length; i++) {
-					const m = chunkModules[i];
-					if (m.needId && chunkGraph.getModuleId(m) === null) {
-						chunkGraph.setModuleId(m, currentId++);
-					}
-					if (options.end && currentId > options.end) break;
+				if (alternate.conditional) {
+					items.push(...alternate.conditional);
+				} else if (!alternate.code) {
+					items.push(alternate);
+				} else {
+					break;
 				}
+				return {
+					range: undefined,
+					value: "",
+					code: true,
+					conditional: items
+				};
+			}
+			case "Literal":
+				return {
+					range: expression.range,
+					value: expression.value + "",
+					code: false,
+					conditional: false
+				};
+		}
+		return {
+			range: undefined,
+			value: "",
+			code: true,
+			conditional: false
+		};
+	}
+
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		let ast;
+		let comments;
+		const semicolons = new Set();
+		if (source === null) {
+			throw new Error("source must not be null");
+		}
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		}
+		if (typeof source === "object") {
+			ast = /** @type {ProgramNode} */ (source);
+			comments = source.comments;
+		} else {
+			comments = [];
+			ast = JavascriptParser._parse(source, {
+				sourceType: this.sourceType,
+				onComment: comments,
+				onInsertedSemicolon: pos => semicolons.add(pos)
 			});
+		}
+
+		const oldScope = this.scope;
+		const oldState = this.state;
+		const oldComments = this.comments;
+		const oldSemicolons = this.semicolons;
+		const oldStatementPath = this.statementPath;
+		const oldPrevStatement = this.prevStatement;
+		this.scope = {
+			topLevelScope: true,
+			inTry: false,
+			inShorthand: false,
+			isStrict: false,
+			isAsmJs: false,
+			definitions: new StackedMap()
+		};
+		/** @type {ParserState} */
+		this.state = state;
+		this.comments = comments;
+		this.semicolons = semicolons;
+		this.statementPath = [];
+		this.prevStatement = undefined;
+		if (this.hooks.program.call(ast, comments) === undefined) {
+			this.detectMode(ast.body);
+			this.preWalkStatements(ast.body);
+			this.prevStatement = undefined;
+			this.blockPreWalkStatements(ast.body);
+			this.prevStatement = undefined;
+			this.walkStatements(ast.body);
+		}
+		this.hooks.finish.call(ast, comments);
+		this.scope = oldScope;
+		/** @type {ParserState} */
+		this.state = oldState;
+		this.comments = oldComments;
+		this.semicolons = oldSemicolons;
+		this.statementPath = oldStatementPath;
+		this.prevStatement = oldPrevStatement;
+		return state;
+	}
+
+	evaluate(source) {
+		const ast = JavascriptParser._parse("(" + source + ")", {
+			sourceType: this.sourceType,
+			locations: false
 		});
+		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
+			throw new Error("evaluate: Source is not a expression");
+		}
+		return this.evaluateExpression(ast.body[0].expression);
 	}
-}
-module.exports = ChunkModuleIdRangePlugin;
 
+	/**
+	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
+	 * @param {number} commentsStartPos source position from which annotation comments are checked
+	 * @returns {boolean} true, when the expression is pure
+	 */
+	isPure(expr, commentsStartPos) {
+		if (!expr) return true;
+		const result = this.hooks.isPure
+			.for(expr.type)
+			.call(expr, commentsStartPos);
+		if (typeof result === "boolean") return result;
+		switch (expr.type) {
+			case "ClassDeclaration":
+			case "ClassExpression": {
+				if (expr.body.type !== "ClassBody") return false;
+				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
+					return false;
+				}
+				const items =
+					/** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (
+						expr.body.body
+					);
+				return items.every(
+					item =>
+						(!item.computed ||
+							!item.key ||
+							this.isPure(item.key, item.range[0])) &&
+						(!item.static ||
+							!item.value ||
+							this.isPure(
+								item.value,
+								item.key ? item.key.range[1] : item.range[0]
+							))
+				);
+			}
 
-/***/ }),
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+			case "Literal":
+			case "PrivateIdentifier":
+				return true;
 
-/***/ 8747:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+			case "VariableDeclaration":
+				return expr.declarations.every(decl =>
+					this.isPure(decl.init, decl.range[0])
+				);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
+			case "ConditionalExpression":
+				return (
+					this.isPure(expr.test, commentsStartPos) &&
+					this.isPure(expr.consequent, expr.test.range[1]) &&
+					this.isPure(expr.alternate, expr.consequent.range[1])
+				);
 
+			case "SequenceExpression":
+				return expr.expressions.every(expr => {
+					const pureFlag = this.isPure(expr, commentsStartPos);
+					commentsStartPos = expr.range[1];
+					return pureFlag;
+				});
 
+			case "CallExpression": {
+				const pureFlag =
+					expr.range[0] - commentsStartPos > 12 &&
+					this.getComments([commentsStartPos, expr.range[0]]).some(
+						comment =>
+							comment.type === "Block" &&
+							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = expr.callee.range[1];
+				return expr.arguments.every(arg => {
+					if (arg.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(arg, commentsStartPos);
+					commentsStartPos = arg.range[1];
+					return pureFlag;
+				});
+			}
+		}
+		const evaluated = this.evaluateExpression(expr);
+		return !evaluated.couldHaveSideEffects();
+	}
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const {
-	getFullChunkName,
-	getUsedChunkIds,
-	assignDeterministicIds
-} = __webpack_require__(63290);
+	getComments(range) {
+		const [rangeStart, rangeEnd] = range;
+		const compare = (comment, needle) => comment.range[0] - needle;
+		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
+		let commentsInRange = [];
+		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
+			commentsInRange.push(this.comments[idx]);
+			idx++;
+		}
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+		return commentsInRange;
+	}
 
-class DeterministicChunkIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {number} pos source code position
+	 * @returns {boolean} true when a semicolon has been inserted before this position, false if not
+	 */
+	isAsiPosition(pos) {
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		if (currentStatement === undefined) throw new Error("Not in statement");
+		return (
+			// Either asking directly for the end position of the current statement
+			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
+			// Or asking for the start position of the current statement,
+			// here we have to check multiple things
+			(currentStatement.range[0] === pos &&
+				// is there a previous statement which might be relevant?
+				this.prevStatement !== undefined &&
+				// is the end position of the previous statement an ASI position?
+				this.semicolons.has(this.prevStatement.range[1]))
+		);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {number} pos source code position
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DeterministicChunkIdsPlugin",
-			compilation => {
-				compilation.hooks.chunkIds.tap(
-					"DeterministicChunkIdsPlugin",
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						const context = this.options.context
-							? this.options.context
-							: compiler.context;
-						const maxLength = this.options.maxLength || 3;
+	unsetAsiPosition(pos) {
+		this.semicolons.delete(pos);
+	}
 
-						const compareNatural = compareChunksNatural(chunkGraph);
+	isStatementLevelExpression(expr) {
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		return (
+			expr === currentStatement ||
+			(currentStatement.type === "ExpressionStatement" &&
+				currentStatement.expression === expr)
+		);
+	}
 
-						const usedIds = getUsedChunkIds(compilation);
-						assignDeterministicIds(
-							Array.from(chunks).filter(chunk => {
-								return chunk.id === null;
-							}),
-							chunk =>
-								getFullChunkName(chunk, chunkGraph, context, compiler.root),
-							compareNatural,
-							(chunk, id) => {
-								const size = usedIds.size;
-								usedIds.add(`${id}`);
-								if (size === usedIds.size) return false;
-								chunk.id = id;
-								chunk.ids = [id];
-								return true;
-							},
-							[Math.pow(10, maxLength)],
-							10,
-							usedIds.size
-						);
-					}
-				);
+	getTagData(name, tag) {
+		const info = this.scope.definitions.get(name);
+		if (info instanceof VariableInfo) {
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				if (tagInfo.tag === tag) return tagInfo.data;
+				tagInfo = tagInfo.next;
 			}
-		);
+		}
 	}
-}
-
-module.exports = DeterministicChunkIdsPlugin;
-
-
-/***/ }),
-
-/***/ 76692:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
-*/
 
+	tagVariable(name, tag, data) {
+		const oldInfo = this.scope.definitions.get(name);
+		/** @type {VariableInfo} */
+		let newInfo;
+		if (oldInfo === undefined) {
+			newInfo = new VariableInfo(this.scope, name, {
+				tag,
+				data,
+				next: undefined
+			});
+		} else if (oldInfo instanceof VariableInfo) {
+			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
+				tag,
+				data,
+				next: oldInfo.tagInfo
+			});
+		} else {
+			newInfo = new VariableInfo(oldInfo, true, {
+				tag,
+				data,
+				next: undefined
+			});
+		}
+		this.scope.definitions.set(name, newInfo);
+	}
 
+	defineVariable(name) {
+		const oldInfo = this.scope.definitions.get(name);
+		// Don't redefine variable in same scope to keep existing tags
+		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
+			return;
+		this.scope.definitions.set(name, this.scope);
+	}
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const {
-	getUsedModuleIdsAndModules,
-	getFullModuleName,
-	assignDeterministicIds
-} = __webpack_require__(63290);
+	undefineVariable(name) {
+		this.scope.definitions.delete(name);
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+	isVariableDefined(name) {
+		const info = this.scope.definitions.get(name);
+		if (info === undefined) return false;
+		if (info instanceof VariableInfo) {
+			return info.freeName === true;
+		}
+		return true;
+	}
 
-class DeterministicModuleIdsPlugin {
 	/**
-	 * @param {Object} options options
-	 * @param {string=} options.context context relative to which module identifiers are computed
-	 * @param {function(Module): boolean=} options.test selector function for modules
-	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
-	 * @param {number=} options.salt hash salt for ids
-	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
-	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
+	 * @param {string} name variable name
+	 * @returns {ExportedVariableInfo} info for this variable
 	 */
-	constructor(options = {}) {
-		this.options = options;
+	getVariableInfo(name) {
+		const value = this.scope.definitions.get(name);
+		if (value === undefined) {
+			return name;
+		} else {
+			return value;
+		}
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {string} name variable name
+	 * @param {ExportedVariableInfo} variableInfo new info for this variable
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DeterministicModuleIdsPlugin",
-			compilation => {
-				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
-					const chunkGraph = compilation.chunkGraph;
-					const context = this.options.context
-						? this.options.context
-						: compiler.context;
-					const maxLength = this.options.maxLength || 3;
-					const failOnConflict = this.options.failOnConflict || false;
-					const fixedLength = this.options.fixedLength || false;
-					const salt = this.options.salt || 0;
-					let conflicts = 0;
-
-					const [usedIds, modules] = getUsedModuleIdsAndModules(
-						compilation,
-						this.options.test
-					);
-					assignDeterministicIds(
-						modules,
-						module => getFullModuleName(module, context, compiler.root),
-						failOnConflict
-							? () => 0
-							: compareModulesByPreOrderIndexOrIdentifier(
-									compilation.moduleGraph
-							  ),
-						(module, id) => {
-							const size = usedIds.size;
-							usedIds.add(`${id}`);
-							if (size === usedIds.size) {
-								conflicts++;
-								return false;
-							}
-							chunkGraph.setModuleId(module, id);
-							return true;
-						},
-						[Math.pow(10, maxLength)],
-						fixedLength ? 0 : 10,
-						usedIds.size,
-						salt
-					);
-					if (failOnConflict && conflicts)
-						throw new Error(
-							`Assigning deterministic module ids has lead to ${conflicts} conflict${
-								conflicts > 1 ? "s" : ""
-							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
-						);
-				});
+	setVariable(name, variableInfo) {
+		if (typeof variableInfo === "string") {
+			if (variableInfo === name) {
+				this.scope.definitions.delete(name);
+			} else {
+				this.scope.definitions.set(
+					name,
+					new VariableInfo(this.scope, variableInfo, undefined)
+				);
 			}
-		);
+		} else {
+			this.scope.definitions.set(name, variableInfo);
+		}
 	}
-}
-
-module.exports = DeterministicModuleIdsPlugin;
-
-
-/***/ }),
-
-/***/ 21825:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	parseCommentOptions(range) {
+		const comments = this.getComments(range);
+		if (comments.length === 0) {
+			return EMPTY_COMMENT_OPTIONS;
+		}
+		let options = {};
+		let errors = [];
+		for (const comment of comments) {
+			const { value } = comment;
+			if (value && webpackCommentRegExp.test(value)) {
+				// try compile only if webpack options comment is present
+				try {
+					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
+					Object.assign(options, val);
+				} catch (e) {
+					e.comment = comment;
+					errors.push(e);
+				}
+			}
+		}
+		return { options, errors };
+	}
 
+	/**
+	 * @param {MemberExpressionNode} expression a member expression
+	 * @returns {{ members: string[], object: ExpressionNode | SuperNode }} member names (reverse order) and remaining object
+	 */
+	extractMemberExpressionChain(expression) {
+		/** @type {AnyNode} */
+		let expr = expression;
+		const members = [];
+		while (expr.type === "MemberExpression") {
+			if (expr.computed) {
+				if (expr.property.type !== "Literal") break;
+				members.push(`${expr.property.value}`);
+			} else {
+				if (expr.property.type !== "Identifier") break;
+				members.push(expr.property.name);
+			}
+			expr = expr.object;
+		}
+		return {
+			members,
+			object: expr
+		};
+	}
 
+	/**
+	 * @param {string} varName variable name
+	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 */
+	getFreeInfoFromVariable(varName) {
+		const info = this.getVariableInfo(varName);
+		let name;
+		if (info instanceof VariableInfo) {
+			name = info.freeName;
+			if (typeof name !== "string") return undefined;
+		} else if (typeof info !== "string") {
+			return undefined;
+		} else {
+			name = info;
+		}
+		return { info, name };
+	}
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const {
-	getUsedModuleIdsAndModules,
-	getFullModuleName
-} = __webpack_require__(63290);
+	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[]}} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[]}} ExpressionExpressionInfo */
 
-/** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+	/**
+	 * @param {MemberExpressionNode} expression a member expression
+	 * @param {number} allowedTypes which types should be returned, presented in bit mask
+	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 */
+	getMemberExpressionInfo(expression, allowedTypes) {
+		const { object, members } = this.extractMemberExpressionChain(expression);
+		switch (object.type) {
+			case "CallExpression": {
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
+					return undefined;
+				let callee = object.callee;
+				let rootMembers = EMPTY_ARRAY;
+				if (callee.type === "MemberExpression") {
+					({ object: callee, members: rootMembers } =
+						this.extractMemberExpressionChain(callee));
+				}
+				const rootName = getRootName(callee);
+				if (!rootName) return undefined;
+				const result = this.getFreeInfoFromVariable(rootName);
+				if (!result) return undefined;
+				const { info: rootInfo, name: resolvedRoot } = result;
+				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
+				return {
+					type: "call",
+					call: object,
+					calleeName,
+					rootInfo,
+					getCalleeMembers: memoize(() => rootMembers.reverse()),
+					name: objectAndMembersToName(`${calleeName}()`, members),
+					getMembers: memoize(() => members.reverse())
+				};
+			}
+			case "Identifier":
+			case "MetaProperty":
+			case "ThisExpression": {
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
+					return undefined;
+				const rootName = getRootName(object);
+				if (!rootName) return undefined;
 
-const validate = createSchemaValidation(
-	__webpack_require__(52210),
-	() => __webpack_require__(59106),
-	{
-		name: "Hashed Module Ids Plugin",
-		baseDataPath: "options"
+				const result = this.getFreeInfoFromVariable(rootName);
+				if (!result) return undefined;
+				const { info: rootInfo, name: resolvedRoot } = result;
+				return {
+					type: "expression",
+					name: objectAndMembersToName(resolvedRoot, members),
+					rootInfo,
+					getMembers: memoize(() => members.reverse())
+				};
+			}
+		}
 	}
-);
 
-class HashedModuleIdsPlugin {
 	/**
-	 * @param {HashedModuleIdsPluginOptions=} options options object
+	 * @param {MemberExpressionNode} expression an expression
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
 	 */
-	constructor(options = {}) {
-		validate(options);
+	getNameForExpression(expression) {
+		return this.getMemberExpressionInfo(
+			expression,
+			ALLOWED_MEMBER_TYPES_EXPRESSION
+		);
+	}
 
-		/** @type {HashedModuleIdsPluginOptions} */
-		this.options = {
-			context: null,
-			hashFunction: "md4",
-			hashDigest: "base64",
-			hashDigestLength: 4,
-			...options
+	/**
+	 * @param {string} code source code
+	 * @param {ParseOptions} options parsing options
+	 * @returns {ProgramNode} parsed ast
+	 */
+	static _parse(code, options) {
+		const type = options ? options.sourceType : "module";
+		/** @type {AcornOptions} */
+		const parserOptions = {
+			...defaultParserOptions,
+			allowReturnOutsideFunction: type === "script",
+			...options,
+			sourceType: type === "auto" ? "module" : type
 		};
-	}
 
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
-				const chunkGraph = compilation.chunkGraph;
-				const context = this.options.context
-					? this.options.context
-					: compiler.context;
+		/** @type {AnyNode} */
+		let ast;
+		let error;
+		let threw = false;
+		try {
+			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+		} catch (e) {
+			error = e;
+			threw = true;
+		}
 
-				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
-				const modulesInNaturalOrder = modules.sort(
-					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-				);
-				for (const module of modulesInNaturalOrder) {
-					const ident = getFullModuleName(module, context, compiler.root);
-					const hash = createHash(options.hashFunction);
-					hash.update(ident || "");
-					const hashId = /** @type {string} */ (
-						hash.digest(options.hashDigest)
-					);
-					let len = options.hashDigestLength;
-					while (usedIds.has(hashId.substr(0, len))) len++;
-					const moduleId = hashId.substr(0, len);
-					chunkGraph.setModuleId(module, moduleId);
-					usedIds.add(moduleId);
-				}
-			});
-		});
+		if (threw && type === "auto") {
+			parserOptions.sourceType = "script";
+			if (!("allowReturnOutsideFunction" in options)) {
+				parserOptions.allowReturnOutsideFunction = true;
+			}
+			if (Array.isArray(parserOptions.onComment)) {
+				parserOptions.onComment.length = 0;
+			}
+			try {
+				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+				threw = false;
+			} catch (e) {
+				// we use the error from first parse try
+				// so nothing to do here
+			}
+		}
+
+		if (threw) {
+			throw error;
+		}
+
+		return /** @type {ProgramNode} */ (ast);
 	}
 }
 
-module.exports = HashedModuleIdsPlugin;
+module.exports = JavascriptParser;
+module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
+module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_EXPRESSION;
+module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
 
 
 /***/ }),
 
-/***/ 63290:
+/***/ 93998:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -94001,481 +94888,250 @@ module.exports = HashedModuleIdsPlugin;
 
 
 
-const createHash = __webpack_require__(49835);
-const { makePathsRelative } = __webpack_require__(82186);
-const numberHash = __webpack_require__(70002);
+const UnsupportedFeatureWarning = __webpack_require__(42495);
+const ConstDependency = __webpack_require__(76911);
+const BasicEvaluatedExpression = __webpack_require__(950);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("./JavascriptParser")} JavascriptParser */
 
 /**
- * @param {string} str string to hash
- * @param {number} len max length of the hash
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
+ * @param {JavascriptParser} parser the parser
+ * @param {string} value the const value
+ * @param {string[]=} runtimeRequirements runtime requirements
+ * @returns {function(ExpressionNode): true} plugin function
  */
-const getHash = (str, len, hashFunction) => {
-	const hash = createHash(hashFunction);
-	hash.update(str);
-	const digest = /** @type {string} */ (hash.digest("hex"));
-	return digest.substr(0, len);
+exports.toConstantDependency = (parser, value, runtimeRequirements) => {
+	return function constDependency(expr) {
+		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
+		dep.loc = expr.loc;
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	};
 };
 
 /**
- * @param {string} str the string
- * @returns {string} string prefixed by an underscore if it is a number
+ * @param {string} value the string value
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
  */
-const avoidNumber = str => {
-	// max length of a number is 21 chars, bigger numbers a written as "...e+xx"
-	if (str.length > 21) return str;
-	const firstChar = str.charCodeAt(0);
-	// skip everything that doesn't look like a number
-	// charCodes: "-": 45, "1": 49, "9": 57
-	if (firstChar < 49) {
-		if (firstChar !== 45) return str;
-	} else if (firstChar > 57) {
-		return str;
-	}
-	if (str === +str + "") {
-		return `_${str}`;
-	}
-	return str;
+exports.evaluateToString = value => {
+	return function stringExpression(expr) {
+		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+	};
 };
 
 /**
- * @param {string} request the request
- * @returns {string} id representation
+ * @param {number} value the number value
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
  */
-const requestToId = request => {
-	return request
-		.replace(/^(\.\.?\/)+/, "")
-		.replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+exports.evaluateToNumber = value => {
+	return function stringExpression(expr) {
+		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
+	};
 };
-exports.requestToId = requestToId;
 
 /**
- * @param {string} string the string
- * @param {string} delimiter separator for string and hash
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} string with limited max length to 100 chars
+ * @param {boolean} value the boolean value
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
  */
-const shortenLongString = (string, delimiter, hashFunction) => {
-	if (string.length < 100) return string;
-	return (
-		string.slice(0, 100 - 6 - delimiter.length) +
-		delimiter +
-		getHash(string, 6, hashFunction)
-	);
-};
-
-/**
- * @param {Module} module the module
- * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} short module name
- */
-const getShortModuleName = (module, context, associatedObjectForCache) => {
-	const libIdent = module.libIdent({ context, associatedObjectForCache });
-	if (libIdent) return avoidNumber(libIdent);
-	const nameForCondition = module.nameForCondition();
-	if (nameForCondition)
-		return avoidNumber(
-			makePathsRelative(context, nameForCondition, associatedObjectForCache)
-		);
-	return "";
+exports.evaluateToBoolean = value => {
+	return function booleanExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setBoolean(value)
+			.setRange(expr.range);
+	};
 };
-exports.getShortModuleName = getShortModuleName;
 
 /**
- * @param {string} shortName the short name
- * @param {Module} module the module
- * @param {string} context context directory
- * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} long module name
+ * @param {string} identifier identifier
+ * @param {string} rootInfo rootInfo
+ * @param {function(): string[]} getMembers getMembers
+ * @param {boolean|null=} truthy is truthy, null if nullish
+ * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
  */
-const getLongModuleName = (
-	shortName,
-	module,
-	context,
-	hashFunction,
-	associatedObjectForCache
-) => {
-	const fullName = getFullModuleName(module, context, associatedObjectForCache);
-	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
-};
-exports.getLongModuleName = getLongModuleName;
+exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
+	return function identifierExpression(expr) {
+		let evaluatedExpression = new BasicEvaluatedExpression()
+			.setIdentifier(identifier, rootInfo, getMembers)
+			.setSideEffects(false)
+			.setRange(expr.range);
+		switch (truthy) {
+			case true:
+				evaluatedExpression.setTruthy();
+				break;
+			case null:
+				evaluatedExpression.setNullish(true);
+				break;
+			case false:
+				evaluatedExpression.setFalsy();
+				break;
+		}
 
-/**
- * @param {Module} module the module
- * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} full module name
- */
-const getFullModuleName = (module, context, associatedObjectForCache) => {
-	return makePathsRelative(
-		context,
-		module.identifier(),
-		associatedObjectForCache
-	);
+		return evaluatedExpression;
+	};
 };
-exports.getFullModuleName = getFullModuleName;
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {string} context context directory
- * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} short chunk name
- */
-const getShortChunkName = (
-	chunk,
-	chunkGraph,
-	context,
-	delimiter,
-	hashFunction,
-	associatedObjectForCache
-) => {
-	const modules = chunkGraph.getChunkRootModules(chunk);
-	const shortModuleNames = modules.map(m =>
-		requestToId(getShortModuleName(m, context, associatedObjectForCache))
-	);
-	chunk.idNameHints.sort();
-	const chunkName = Array.from(chunk.idNameHints)
-		.concat(shortModuleNames)
-		.filter(Boolean)
-		.join(delimiter);
-	return shortenLongString(chunkName, delimiter, hashFunction);
+exports.expressionIsUnsupported = (parser, message) => {
+	return function unsupportedExpression(expr) {
+		const dep = new ConstDependency("(void 0)", expr.range, null);
+		dep.loc = expr.loc;
+		parser.state.module.addPresentationalDependency(dep);
+		if (!parser.state.module) return;
+		parser.state.module.addWarning(
+			new UnsupportedFeatureWarning(message, expr.loc)
+		);
+		return true;
+	};
 };
-exports.getShortChunkName = getShortChunkName;
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {string} context context directory
- * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} short chunk name
- */
-const getLongChunkName = (
-	chunk,
-	chunkGraph,
-	context,
-	delimiter,
-	hashFunction,
-	associatedObjectForCache
-) => {
-	const modules = chunkGraph.getChunkRootModules(chunk);
-	const shortModuleNames = modules.map(m =>
-		requestToId(getShortModuleName(m, context, associatedObjectForCache))
-	);
-	const longModuleNames = modules.map(m =>
-		requestToId(
-			getLongModuleName("", m, context, hashFunction, associatedObjectForCache)
-		)
-	);
-	chunk.idNameHints.sort();
-	const chunkName = Array.from(chunk.idNameHints)
-		.concat(shortModuleNames, longModuleNames)
-		.filter(Boolean)
-		.join(delimiter);
-	return shortenLongString(chunkName, delimiter, hashFunction);
-};
-exports.getLongChunkName = getLongChunkName;
+exports.skipTraversal = () => true;
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {string} context context directory
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} full chunk name
- */
-const getFullChunkName = (
-	chunk,
-	chunkGraph,
-	context,
-	associatedObjectForCache
-) => {
-	if (chunk.name) return chunk.name;
-	const modules = chunkGraph.getChunkRootModules(chunk);
-	const fullModuleNames = modules.map(m =>
-		makePathsRelative(context, m.identifier(), associatedObjectForCache)
-	);
-	return fullModuleNames.join();
-};
-exports.getFullChunkName = getFullChunkName;
+exports.approve = () => true;
 
-/**
- * @template K
- * @template V
- * @param {Map<K, V[]>} map a map from key to values
- * @param {K} key key
- * @param {V} value value
- * @returns {void}
- */
-const addToMapOfItems = (map, key, value) => {
-	let array = map.get(key);
-	if (array === undefined) {
-		array = [];
-		map.set(key, array);
-	}
-	array.push(value);
-};
 
-/**
- * @param {Compilation} compilation the compilation
- * @param {function(Module): boolean=} filter filter modules
- * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
- */
-const getUsedModuleIdsAndModules = (compilation, filter) => {
-	const chunkGraph = compilation.chunkGraph;
+/***/ }),
 
-	const modules = [];
+/***/ 98124:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-	/** @type {Set<string>} */
-	const usedIds = new Set();
-	if (compilation.usedModuleIds) {
-		for (const id of compilation.usedModuleIds) {
-			usedIds.add(id + "");
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	for (const module of compilation.modules) {
-		if (!module.needId) continue;
-		const moduleId = chunkGraph.getModuleId(module);
-		if (moduleId !== null) {
-			usedIds.add(moduleId + "");
-		} else {
-			if (
-				(!filter || filter(module)) &&
-				chunkGraph.getNumberOfModuleChunks(module) !== 0
-			) {
-				modules.push(module);
-			}
-		}
-	}
 
-	return [usedIds, modules];
-};
-exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
 
-/**
- * @param {Compilation} compilation the compilation
- * @returns {Set<string>} used chunk ids as strings
- */
-const getUsedChunkIds = compilation => {
-	/** @type {Set<string>} */
-	const usedIds = new Set();
-	if (compilation.usedChunkIds) {
-		for (const id of compilation.usedChunkIds) {
-			usedIds.add(id + "");
-		}
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const { isSubset } = __webpack_require__(93347);
+const { getAllChunks } = __webpack_require__(91145);
 
-	for (const chunk of compilation.chunks) {
-		const chunkId = chunk.id;
-		if (chunkId !== null) {
-			usedIds.add(chunkId + "");
-		}
-	}
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {(string|number)[]} EntryItem */
 
-	return usedIds;
-};
-exports.getUsedChunkIds = getUsedChunkIds;
+const EXPORT_PREFIX = "var __webpack_exports__ = ";
 
 /**
- * @template T
- * @param {Iterable<T>} items list of items to be named
- * @param {function(T): string} getShortName get a short name for an item
- * @param {function(T, string): string} getLongName get a long name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {Set<string>} usedIds already used ids, will not be assigned
- * @param {function(T, string): void} assignName assign a name to an item
- * @returns {T[]} list of items without a name
+ * @param {ChunkGraph} chunkGraph chunkGraph
+ * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+ * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
+ * @param {Chunk} chunk chunk
+ * @param {boolean} passive true: passive startup with on chunks loaded
+ * @returns {string} runtime code
  */
-const assignNames = (
-	items,
-	getShortName,
-	getLongName,
-	comparator,
-	usedIds,
-	assignName
+exports.generateEntryStartup = (
+	chunkGraph,
+	runtimeTemplate,
+	entries,
+	chunk,
+	passive
 ) => {
-	/** @type {Map<string, T[]>} */
-	const nameToItems = new Map();
-
-	for (const item of items) {
-		const name = getShortName(item);
-		addToMapOfItems(nameToItems, name, item);
-	}
-
-	/** @type {Map<string, T[]>} */
-	const nameToItems2 = new Map();
-
-	for (const [name, items] of nameToItems) {
-		if (items.length > 1 || !name) {
-			for (const item of items) {
-				const longName = getLongName(item, name);
-				addToMapOfItems(nameToItems2, longName, item);
-			}
-		} else {
-			addToMapOfItems(nameToItems2, name, items[0]);
-		}
-	}
-
-	/** @type {T[]} */
-	const unnamedItems = [];
+	/** @type {string[]} */
+	const runtime = [
+		`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+			`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+			"moduleId"
+		)}`
+	];
 
-	for (const [name, items] of nameToItems2) {
-		if (!name) {
-			for (const item of items) {
-				unnamedItems.push(item);
-			}
-		} else if (items.length === 1 && !usedIds.has(name)) {
-			assignName(items[0], name);
-			usedIds.add(name);
+	const runModule = id => {
+		return `__webpack_exec__(${JSON.stringify(id)})`;
+	};
+	const outputCombination = (chunks, moduleIds, final) => {
+		if (chunks.size === 0) {
+			runtime.push(
+				`${final ? EXPORT_PREFIX : ""}(${moduleIds.map(runModule).join(", ")});`
+			);
 		} else {
-			items.sort(comparator);
-			let i = 0;
-			for (const item of items) {
-				while (nameToItems2.has(name + i) && usedIds.has(name + i)) i++;
-				assignName(item, name + i);
-				usedIds.add(name + i);
-				i++;
+			const fn = runtimeTemplate.returningFunction(
+				moduleIds.map(runModule).join(", ")
+			);
+			runtime.push(
+				`${final && !passive ? EXPORT_PREFIX : ""}${
+					passive
+						? RuntimeGlobals.onChunksLoaded
+						: RuntimeGlobals.startupEntrypoint
+				}(0, ${JSON.stringify(Array.from(chunks, c => c.id))}, ${fn});`
+			);
+			if (final && passive) {
+				runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);
 			}
 		}
-	}
-
-	unnamedItems.sort(comparator);
-	return unnamedItems;
-};
-exports.assignNames = assignNames;
-
-/**
- * @template T
- * @param {T[]} items list of items to be named
- * @param {function(T): string} getName get a name for an item
- * @param {function(T, T): -1|0|1} comparator order of items
- * @param {function(T, number): boolean} assignId assign an id to an item
- * @param {number[]} ranges usable ranges for ids
- * @param {number} expandFactor factor to create more ranges
- * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
- * @param {number} salt salting number to initialize hashing
- * @returns {void}
- */
-const assignDeterministicIds = (
-	items,
-	getName,
-	comparator,
-	assignId,
-	ranges = [10],
-	expandFactor = 10,
-	extraSpace = 0,
-	salt = 0
-) => {
-	items.sort(comparator);
+	};
 
-	// max 5% fill rate
-	const optimalRange = Math.min(
-		Math.ceil(items.length * 20) + extraSpace,
-		Number.MAX_SAFE_INTEGER
-	);
+	let currentChunks = undefined;
+	let currentModuleIds = undefined;
 
-	let i = 0;
-	let range = ranges[i];
-	while (range < optimalRange) {
-		i++;
-		if (i < ranges.length) {
-			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
-		} else if (expandFactor) {
-			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+	for (const [module, entrypoint] of entries) {
+		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const moduleId = chunkGraph.getModuleId(module);
+		const chunks = getAllChunks(entrypoint, chunk, runtimeChunk);
+		if (
+			currentChunks &&
+			currentChunks.size === chunks.size &&
+			isSubset(currentChunks, chunks)
+		) {
+			currentModuleIds.push(moduleId);
 		} else {
-			break;
+			if (currentChunks) {
+				outputCombination(currentChunks, currentModuleIds);
+			}
+			currentChunks = chunks;
+			currentModuleIds = [moduleId];
 		}
 	}
 
-	for (const item of items) {
-		const ident = getName(item);
-		let id;
-		let i = salt;
-		do {
-			id = numberHash(ident + i++, range);
-		} while (!assignId(item, id));
+	// output current modules with export prefix
+	if (currentChunks) {
+		outputCombination(currentChunks, currentModuleIds, true);
 	}
+	runtime.push("");
+	return Template.asString(runtime);
 };
-exports.assignDeterministicIds = assignDeterministicIds;
 
 /**
- * @param {Set<string>} usedIds used ids
- * @param {Iterable<Module>} modules the modules
- * @param {Compilation} compilation the compilation
+ * @param {Hash} hash the hash to update
+ * @param {ChunkGraph} chunkGraph chunkGraph
+ * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
+ * @param {Chunk} chunk chunk
  * @returns {void}
  */
-const assignAscendingModuleIds = (usedIds, modules, compilation) => {
-	const chunkGraph = compilation.chunkGraph;
-
-	let nextId = 0;
-	let assignId;
-	if (usedIds.size > 0) {
-		assignId = module => {
-			if (chunkGraph.getModuleId(module) === null) {
-				while (usedIds.has(nextId + "")) nextId++;
-				chunkGraph.setModuleId(module, nextId++);
-			}
-		};
-	} else {
-		assignId = module => {
-			if (chunkGraph.getModuleId(module) === null) {
-				chunkGraph.setModuleId(module, nextId++);
-			}
-		};
-	}
-	for (const module of modules) {
-		assignId(module);
+exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
+	for (const [module, entrypoint] of entries) {
+		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const moduleId = chunkGraph.getModuleId(module);
+		hash.update(`${moduleId}`);
+		for (const c of getAllChunks(entrypoint, chunk, runtimeChunk))
+			hash.update(`${c.id}`);
 	}
 };
-exports.assignAscendingModuleIds = assignAscendingModuleIds;
 
 /**
- * @param {Iterable<Chunk>} chunks the chunks
- * @param {Compilation} compilation the compilation
- * @returns {void}
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
+ * @returns {Set<number | string>} initially fulfilled chunk ids
  */
-const assignAscendingChunkIds = (chunks, compilation) => {
-	const usedIds = getUsedChunkIds(compilation);
-
-	let nextId = 0;
-	if (usedIds.size > 0) {
-		for (const chunk of chunks) {
-			if (chunk.id === null) {
-				while (usedIds.has(nextId + "")) nextId++;
-				chunk.id = nextId;
-				chunk.ids = [nextId];
-				nextId++;
-			}
-		}
-	} else {
-		for (const chunk of chunks) {
-			if (chunk.id === null) {
-				chunk.id = nextId;
-				chunk.ids = [nextId];
-				nextId++;
-			}
-		}
+exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
+	const initialChunkIds = new Set(chunk.ids);
+	for (const c of chunk.getAllInitialChunks()) {
+		if (c === chunk || filterFn(c, chunkGraph)) continue;
+		for (const id of c.ids) initialChunkIds.add(id);
 	}
+	return initialChunkIds;
 };
-exports.assignAscendingChunkIds = assignAscendingChunkIds;
 
 
 /***/ }),
 
-/***/ 6454:
+/***/ 90490:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -94486,85 +95142,45 @@ exports.assignAscendingChunkIds = assignAscendingChunkIds;
 
 
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const {
-	getShortChunkName,
-	getLongChunkName,
-	assignNames,
-	getUsedChunkIds,
-	assignAscendingChunkIds
-} = __webpack_require__(63290);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+const { register } = __webpack_require__(8282);
 
-class NamedChunkIdsPlugin {
-	constructor(options) {
-		this.delimiter = (options && options.delimiter) || "-";
-		this.context = options && options.context;
+class JsonData {
+	constructor(data) {
+		this._buffer = undefined;
+		this._data = undefined;
+		if (Buffer.isBuffer(data)) {
+			this._buffer = data;
+		} else {
+			this._data = data;
+		}
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
-				const chunkGraph = compilation.chunkGraph;
-				const context = this.context ? this.context : compiler.context;
-				const delimiter = this.delimiter;
-
-				const unnamedChunks = assignNames(
-					Array.from(chunks).filter(chunk => {
-						if (chunk.name) {
-							chunk.id = chunk.name;
-							chunk.ids = [chunk.name];
-						}
-						return chunk.id === null;
-					}),
-					chunk =>
-						getShortChunkName(
-							chunk,
-							chunkGraph,
-							context,
-							delimiter,
-							hashFunction,
-							compiler.root
-						),
-					chunk =>
-						getLongChunkName(
-							chunk,
-							chunkGraph,
-							context,
-							delimiter,
-							hashFunction,
-							compiler.root
-						),
-					compareChunksNatural(chunkGraph),
-					getUsedChunkIds(compilation),
-					(chunk, name) => {
-						chunk.id = name;
-						chunk.ids = [name];
-					}
-				);
-				if (unnamedChunks.length > 0) {
-					assignAscendingChunkIds(unnamedChunks, compilation);
-				}
-			});
-		});
+	get() {
+		if (this._data === undefined && this._buffer !== undefined) {
+			this._data = JSON.parse(this._buffer.toString());
+		}
+		return this._data;
 	}
 }
 
-module.exports = NamedChunkIdsPlugin;
+register(JsonData, "webpack/lib/json/JsonData", null, {
+	serialize(obj, { write }) {
+		if (obj._buffer === undefined && obj._data !== undefined) {
+			obj._buffer = Buffer.from(JSON.stringify(obj._data));
+		}
+		write(obj._buffer);
+	},
+	deserialize({ read }) {
+		return new JsonData(read());
+	}
+});
+
+module.exports = JsonData;
 
 
 /***/ }),
 
-/***/ 24339:
+/***/ 70393:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -94575,150 +95191,253 @@ module.exports = NamedChunkIdsPlugin;
 
 
 
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const {
-	getShortModuleName,
-	getLongModuleName,
-	assignNames,
-	getUsedModuleIdsAndModules,
-	assignAscendingModuleIds
-} = __webpack_require__(63290);
-
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-
-class NamedModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
-	}
+const { RawSource } = __webpack_require__(51255);
+const ConcatenationScope = __webpack_require__(98229);
+const { UsageState } = __webpack_require__(63686);
+const Generator = __webpack_require__(93401);
+const RuntimeGlobals = __webpack_require__(16475);
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { root } = compiler;
-		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
-				const chunkGraph = compilation.chunkGraph;
-				const context = this.options.context
-					? this.options.context
-					: compiler.context;
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
-				const unnamedModules = assignNames(
-					modules,
-					m => getShortModuleName(m, context, root),
-					(m, shortName) =>
-						getLongModuleName(shortName, m, context, hashFunction, root),
-					compareModulesByIdentifier,
-					usedIds,
-					(m, name) => chunkGraph.setModuleId(m, name)
-				);
-				if (unnamedModules.length > 0) {
-					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
-				}
-			});
-		});
+const stringifySafe = data => {
+	const stringified = JSON.stringify(data);
+	if (!stringified) {
+		return undefined; // Invalid JSON
 	}
-}
-
-module.exports = NamedModuleIdsPlugin;
 
+	return stringified.replace(/\u2028|\u2029/g, str =>
+		str === "\u2029" ? "\\u2029" : "\\u2028"
+	); // invalid in JavaScript but valid JSON
+};
 
-/***/ }),
+/**
+ * @param {Object} data data (always an object or array)
+ * @param {ExportsInfo} exportsInfo exports info
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {Object} reduced data
+ */
+const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
+		return data;
+	const isArray = Array.isArray(data);
+	const reducedData = isArray ? [] : {};
+	for (const key of Object.keys(data)) {
+		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
+		const used = exportInfo.getUsed(runtime);
+		if (used === UsageState.Unused) continue;
 
-/***/ 86221:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		let value;
+		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
+			value = createObjectForExportsInfo(
+				data[key],
+				exportInfo.exportsInfo,
+				runtime
+			);
+		} else {
+			value = data[key];
+		}
+		const name = exportInfo.getUsedName(key, runtime);
+		reducedData[name] = value;
+	}
+	if (isArray) {
+		let arrayLengthWhenUsed =
+			exportsInfo.getReadOnlyExportInfo("length").getUsed(runtime) !==
+			UsageState.Unused
+				? data.length
+				: undefined;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		let sizeObjectMinusArray = 0;
+		for (let i = 0; i < reducedData.length; i++) {
+			if (reducedData[i] === undefined) {
+				sizeObjectMinusArray -= 2;
+			} else {
+				sizeObjectMinusArray += `${i}`.length + 3;
+			}
+		}
+		if (arrayLengthWhenUsed !== undefined) {
+			sizeObjectMinusArray +=
+				`${arrayLengthWhenUsed}`.length +
+				8 -
+				(arrayLengthWhenUsed - reducedData.length) * 2;
+		}
+		if (sizeObjectMinusArray < 0)
+			return Object.assign(
+				arrayLengthWhenUsed === undefined
+					? {}
+					: { length: arrayLengthWhenUsed },
+				reducedData
+			);
+		const generatedLength =
+			arrayLengthWhenUsed !== undefined
+				? Math.max(arrayLengthWhenUsed, reducedData.length)
+				: reducedData.length;
+		for (let i = 0; i < generatedLength; i++) {
+			if (reducedData[i] === undefined) {
+				reducedData[i] = 0;
+			}
+		}
+	}
+	return reducedData;
+};
 
+const TYPES = new Set(["javascript"]);
 
+class JsonGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
+	}
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const { assignAscendingChunkIds } = __webpack_require__(63290);
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		let data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
+		if (!data) return 0;
+		return stringifySafe(data).length + 10;
+	}
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
+	}
 
-class NaturalChunkIdsPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("NaturalChunkIdsPlugin", compilation => {
-			compilation.hooks.chunkIds.tap("NaturalChunkIdsPlugin", chunks => {
-				const chunkGraph = compilation.chunkGraph;
-				const compareNatural = compareChunksNatural(chunkGraph);
-				const chunksInNaturalOrder = Array.from(chunks).sort(compareNatural);
-				assignAscendingChunkIds(chunksInNaturalOrder, compilation);
-			});
-		});
+	generate(
+		module,
+		{
+			moduleGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
+		}
+	) {
+		const data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
+		if (data === undefined) {
+			return new RawSource(
+				runtimeTemplate.missingModuleStatement({
+					request: module.rawRequest
+				})
+			);
+		}
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		let finalJson =
+			typeof data === "object" &&
+			data &&
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused
+				? createObjectForExportsInfo(data, exportsInfo, runtime)
+				: data;
+		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
+		const jsonStr = stringifySafe(finalJson);
+		const jsonExpr =
+			jsonStr.length > 20 && typeof finalJson === "object"
+				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
+				: jsonStr;
+		let content;
+		if (concatenationScope) {
+			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			} = ${jsonExpr};`;
+			concatenationScope.registerNamespaceExport(
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			);
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			content = `${module.moduleArgument}.exports = ${jsonExpr};`;
+		}
+		return new RawSource(content);
 	}
 }
 
-module.exports = NaturalChunkIdsPlugin;
+module.exports = JsonGenerator;
 
 
 /***/ }),
 
-/***/ 83366:
+/***/ 86770:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Florent Cailhol @ooflorent
+	Author Tobias Koppers @sokra
 */
 
 
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const {
-	assignAscendingModuleIds,
-	getUsedModuleIdsAndModules
-} = __webpack_require__(63290);
+const createSchemaValidation = __webpack_require__(32540);
+const JsonGenerator = __webpack_require__(70393);
+const JsonParser = __webpack_require__(41090);
 
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 
-class NaturalModuleIdsPlugin {
+const validate = createSchemaValidation(
+	__webpack_require__(54094),
+	() => __webpack_require__(50166),
+	{
+		name: "Json Modules Plugin",
+		baseDataPath: "parser"
+	}
+);
+
+class JsonModulesPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
-				const [usedIds, modulesInNaturalOrder] =
-					getUsedModuleIdsAndModules(compilation);
-				modulesInNaturalOrder.sort(
-					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-				);
-				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
-			});
-		});
+		compiler.hooks.compilation.tap(
+			"JsonModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.createParser
+					.for("json")
+					.tap("JsonModulesPlugin", parserOptions => {
+						validate(parserOptions);
+
+						return new JsonParser(parserOptions);
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("json")
+					.tap("JsonModulesPlugin", () => {
+						return new JsonGenerator();
+					});
+			}
+		);
 	}
 }
 
-module.exports = NaturalModuleIdsPlugin;
+module.exports = JsonModulesPlugin;
 
 
 /***/ }),
 
-/***/ 51020:
+/***/ 41090:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -94729,84 +95448,61 @@ module.exports = NaturalModuleIdsPlugin;
 
 
 
-const { compareChunksNatural } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const { assignAscendingChunkIds } = __webpack_require__(63290);
-
-/** @typedef {import("../../declarations/plugins/ids/OccurrenceChunkIdsPlugin").OccurrenceChunkIdsPluginOptions} OccurrenceChunkIdsPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+const parseJson = __webpack_require__(15235);
+const Parser = __webpack_require__(11715);
+const JsonExportsDependency = __webpack_require__(750);
+const JsonData = __webpack_require__(90490);
 
-const validate = createSchemaValidation(
-	__webpack_require__(24344),
-	() => __webpack_require__(53576),
-	{
-		name: "Occurrence Order Chunk Ids Plugin",
-		baseDataPath: "options"
-	}
-);
+/** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-class OccurrenceChunkIdsPlugin {
+class JsonParser extends Parser {
 	/**
-	 * @param {OccurrenceChunkIdsPluginOptions=} options options object
+	 * @param {JsonModulesPluginParserOptions} options parser options
 	 */
-	constructor(options = {}) {
-		validate(options);
-		this.options = options;
+	constructor(options) {
+		super();
+		this.options = options || {};
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
 	 */
-	apply(compiler) {
-		const prioritiseInitial = this.options.prioritiseInitial;
-		compiler.hooks.compilation.tap("OccurrenceChunkIdsPlugin", compilation => {
-			compilation.hooks.chunkIds.tap("OccurrenceChunkIdsPlugin", chunks => {
-				const chunkGraph = compilation.chunkGraph;
-
-				/** @type {Map<Chunk, number>} */
-				const occursInInitialChunksMap = new Map();
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		}
 
-				const compareNatural = compareChunksNatural(chunkGraph);
+		/** @type {JsonModulesPluginParserOptions["parse"]} */
+		const parseFn =
+			typeof this.options.parse === "function" ? this.options.parse : parseJson;
 
-				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);
-				}
+		const data =
+			typeof source === "object"
+				? source
+				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
 
-				const chunksInOccurrenceOrder = Array.from(chunks).sort((a, b) => {
-					if (prioritiseInitial) {
-						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;
-					return compareNatural(a, b);
-				});
-				assignAscendingChunkIds(chunksInOccurrenceOrder, compilation);
-			});
-		});
+		state.module.buildInfo.jsonData = new JsonData(data);
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "default";
+		state.module.buildMeta.defaultObject =
+			typeof data === "object" ? "redirect-warn" : false;
+		state.module.addDependency(
+			new JsonExportsDependency(JsonExportsDependency.getExportsFromData(data))
+		);
+		return state;
 	}
 }
 
-module.exports = OccurrenceChunkIdsPlugin;
+module.exports = JsonParser;
 
 
 /***/ }),
 
-/***/ 35371:
+/***/ 26030:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -94817,36 +95513,46 @@ module.exports = OccurrenceChunkIdsPlugin;
 
 
 
-const {
-	compareModulesByPreOrderIndexOrIdentifier
-} = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const {
-	assignAscendingModuleIds,
-	getUsedModuleIdsAndModules
-} = __webpack_require__(63290);
+const RuntimeGlobals = __webpack_require__(16475);
+const JavascriptModulesPlugin = __webpack_require__(89464);
 
-/** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
 
-const validate = createSchemaValidation(
-	__webpack_require__(14916),
-	() => __webpack_require__(19330),
-	{
-		name: "Occurrence Order Module Ids Plugin",
-		baseDataPath: "options"
-	}
-);
+const COMMON_LIBRARY_NAME_MESSAGE =
+	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
 
-class OccurrenceModuleIdsPlugin {
+/**
+ * @template T
+ * @typedef {Object} LibraryContext
+ * @property {Compilation} compilation
+ * @property {ChunkGraph} chunkGraph
+ * @property {T} options
+ */
+
+/**
+ * @template T
+ */
+class AbstractLibraryPlugin {
 	/**
-	 * @param {OccurrenceModuleIdsPluginOptions=} options options object
+	 * @param {Object} options options
+	 * @param {string} options.pluginName name of the plugin
+	 * @param {LibraryType} options.type used library type
 	 */
-	constructor(options = {}) {
-		validate(options);
-		this.options = options;
+	constructor({ pluginName, type }) {
+		this._pluginName = pluginName;
+		this._type = type;
+		this._parseCache = new WeakMap();
 	}
 
 	/**
@@ -94855,273 +95561,253 @@ class OccurrenceModuleIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const prioritiseInitial = this.options.prioritiseInitial;
-		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-
-			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
-				const chunkGraph = compilation.chunkGraph;
-
-				const [usedIds, modulesInOccurrenceOrder] =
-					getUsedModuleIdsAndModules(compilation);
-
-				const occursInInitialChunksMap = new Map();
-				const occursInAllChunksMap = new Map();
-
-				const initialChunkChunkMap = new Map();
-				const entryCountMap = new Map();
-				for (const m of modulesInOccurrenceOrder) {
-					let initial = 0;
-					let entry = 0;
-					for (const c of chunkGraph.getModuleChunksIterable(m)) {
-						if (c.canBeInitial()) initial++;
-						if (chunkGraph.isEntryModuleInChunk(m, c)) entry++;
+		const { _pluginName } = this;
+		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
+			compilation.hooks.finishModules.tap(
+				{ name: _pluginName, stage: 10 },
+				() => {
+					for (const [
+						name,
+						{
+							dependencies: deps,
+							options: { library }
+						}
+					] of compilation.entries) {
+						const options = this._parseOptionsCached(
+							library !== undefined
+								? library
+								: compilation.outputOptions.library
+						);
+						if (options !== false) {
+							const dep = deps[deps.length - 1];
+							if (dep) {
+								const module = compilation.moduleGraph.getModule(dep);
+								if (module) {
+									this.finishEntryModule(module, name, {
+										options,
+										compilation,
+										chunkGraph: compilation.chunkGraph
+									});
+								}
+							}
+						}
 					}
-					initialChunkChunkMap.set(m, initial);
-					entryCountMap.set(m, entry);
 				}
+			);
 
-				/**
-				 * @param {Module} module module
-				 * @returns {number} count of occurs
-				 */
-				const countOccursInEntry = module => {
-					let sum = 0;
-					for (const [
-						originModule,
-						connections
-					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-						if (!originModule) continue;
-						if (!connections.some(c => c.isTargetActive(undefined))) continue;
-						sum += initialChunkChunkMap.get(originModule);
-					}
-					return sum;
-				};
+			const getOptionsForChunk = chunk => {
+				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
+					return false;
+				const options = chunk.getEntryOptions();
+				const library = options && options.library;
+				return this._parseOptionsCached(
+					library !== undefined ? library : compilation.outputOptions.library
+				);
+			};
 
-				/**
-				 * @param {Module} module module
-				 * @returns {number} count of occurs
-				 */
-				const countOccurs = module => {
-					let sum = 0;
-					for (const [
-						originModule,
-						connections
-					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
-						if (!originModule) continue;
-						const chunkModules =
-							chunkGraph.getNumberOfModuleChunks(originModule);
-						for (const c of connections) {
-							if (!c.isTargetActive(undefined)) continue;
-							if (!c.dependency) continue;
-							const factor = c.dependency.getNumberOfIdOccurrences();
-							if (factor === 0) continue;
-							sum += factor * chunkModules;
+			if (
+				this.render !== AbstractLibraryPlugin.prototype.render ||
+				this.runtimeRequirements !==
+					AbstractLibraryPlugin.prototype.runtimeRequirements
+			) {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					_pluginName,
+					(chunk, set, { chunkGraph }) => {
+						const options = getOptionsForChunk(chunk);
+						if (options !== false) {
+							this.runtimeRequirements(chunk, set, {
+								options,
+								compilation,
+								chunkGraph
+							});
 						}
 					}
-					return sum;
-				};
+				);
+			}
 
-				if (prioritiseInitial) {
-					for (const m of modulesInOccurrenceOrder) {
-						const result =
-							countOccursInEntry(m) +
-							initialChunkChunkMap.get(m) +
-							entryCountMap.get(m);
-						occursInInitialChunksMap.set(m, result);
-					}
-				}
+			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
 
-				for (const m of modulesInOccurrenceOrder) {
-					const result =
-						countOccurs(m) +
-						chunkGraph.getNumberOfModuleChunks(m) +
-						entryCountMap.get(m);
-					occursInAllChunksMap.set(m, result);
-				}
+			if (this.render !== AbstractLibraryPlugin.prototype.render) {
+				hooks.render.tap(_pluginName, (source, renderContext) => {
+					const options = getOptionsForChunk(renderContext.chunk);
+					if (options === false) return source;
+					return this.render(source, renderContext, {
+						options,
+						compilation,
+						chunkGraph: compilation.chunkGraph
+					});
+				});
+			}
 
-				const naturalCompare = compareModulesByPreOrderIndexOrIdentifier(
-					compilation.moduleGraph
+			if (
+				this.embedInRuntimeBailout !==
+				AbstractLibraryPlugin.prototype.embedInRuntimeBailout
+			) {
+				hooks.embedInRuntimeBailout.tap(
+					_pluginName,
+					(module, renderContext) => {
+						const options = getOptionsForChunk(renderContext.chunk);
+						if (options === false) return;
+						return this.embedInRuntimeBailout(module, renderContext, {
+							options,
+							compilation,
+							chunkGraph: compilation.chunkGraph
+						});
+					}
 				);
+			}
 
-				modulesInOccurrenceOrder.sort((a, b) => {
-					if (prioritiseInitial) {
-						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;
-					return naturalCompare(a, b);
+			if (
+				this.strictRuntimeBailout !==
+				AbstractLibraryPlugin.prototype.strictRuntimeBailout
+			) {
+				hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
+					const options = getOptionsForChunk(renderContext.chunk);
+					if (options === false) return;
+					return this.strictRuntimeBailout(renderContext, {
+						options,
+						compilation,
+						chunkGraph: compilation.chunkGraph
+					});
 				});
+			}
 
-				assignAscendingModuleIds(
-					usedIds,
-					modulesInOccurrenceOrder,
-					compilation
+			if (
+				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
+			) {
+				hooks.renderStartup.tap(
+					_pluginName,
+					(source, module, renderContext) => {
+						const options = getOptionsForChunk(renderContext.chunk);
+						if (options === false) return source;
+						return this.renderStartup(source, module, renderContext, {
+							options,
+							compilation,
+							chunkGraph: compilation.chunkGraph
+						});
+					}
 				);
+			}
+
+			hooks.chunkHash.tap(_pluginName, (chunk, hash, context) => {
+				const options = getOptionsForChunk(chunk);
+				if (options === false) return;
+				this.chunkHash(chunk, hash, context, {
+					options,
+					compilation,
+					chunkGraph: compilation.chunkGraph
+				});
 			});
 		});
 	}
-}
 
-module.exports = OccurrenceModuleIdsPlugin;
-
-
-/***/ }),
-
-/***/ 8635:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {LibraryOptions=} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	_parseOptionsCached(library) {
+		if (!library) return false;
+		if (library.type !== this._type) return false;
+		const cacheEntry = this._parseCache.get(library);
+		if (cacheEntry !== undefined) return cacheEntry;
+		const result = this.parseOptions(library);
+		this._parseCache.set(library, result);
+		return result;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/* istanbul ignore next */
+	/**
+	 * @abstract
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
 
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	finishEntryModule(module, entryName, libraryContext) {}
 
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	embedInRuntimeBailout(module, renderContext, libraryContext) {
+		return undefined;
+	}
 
-const { WebpackError } = __webpack_require__(91919);
-const { getUsedModuleIdsAndModules } = __webpack_require__(63290);
+	/**
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	strictRuntimeBailout(renderContext, libraryContext) {
+		return undefined;
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	runtimeRequirements(chunk, set, libraryContext) {
+		if (this.render !== AbstractLibraryPlugin.prototype.render)
+			set.add(RuntimeGlobals.returnExportsFromRuntime);
+	}
 
-const plugin = "SyncModuleIdsPlugin";
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, renderContext, libraryContext) {
+		return source;
+	}
 
-class SyncModuleIdsPlugin {
 	/**
-	 * @param {Object} options options
-	 * @param {string} options.path path to file
-	 * @param {string=} options.context context for module names
-	 * @param {function(Module): boolean} options.test selector for modules
-	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
 	 */
-	constructor({ path, context, test, mode }) {
-		this._path = path;
-		this._context = context;
-		this._test = test || (() => true);
-		const readAndWrite = !mode || mode === "merge" || mode === "update";
-		this._read = readAndWrite || mode === "read";
-		this._write = readAndWrite || mode === "create";
-		this._prune = mode === "update";
+	renderStartup(source, module, renderContext, libraryContext) {
+		return source;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		/** @type {Map<string, string | number>} */
-		let data;
-		let dataChanged = false;
-		if (this._read) {
-			compiler.hooks.readRecords.tapAsync(plugin, callback => {
-				const fs = compiler.intermediateFileSystem;
-				fs.readFile(this._path, (err, buffer) => {
-					if (err) {
-						if (err.code !== "ENOENT") {
-							return callback(err);
-						}
-						return callback();
-					}
-					const json = JSON.parse(buffer.toString());
-					data = new Map();
-					for (const key of Object.keys(json)) {
-						data.set(key, json[key]);
-					}
-					dataChanged = false;
-					return callback();
-				});
-			});
-		}
-		if (this._write) {
-			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
-				if (!data || !dataChanged) return callback();
-				const json = {};
-				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
-				for (const [key, value] of sorted) {
-					json[key] = value;
-				}
-				const fs = compiler.intermediateFileSystem;
-				fs.writeFile(this._path, JSON.stringify(json), callback);
-			});
-		}
-		compiler.hooks.thisCompilation.tap(plugin, compilation => {
-			const associatedObjectForCache = compiler.root;
-			const context = this._context || compiler.context;
-			if (this._read) {
-				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
-					if (!data) return;
-					const { chunkGraph } = compilation;
-					const [usedIds, modules] = getUsedModuleIdsAndModules(
-						compilation,
-						this._test
-					);
-					for (const module of modules) {
-						const name = module.libIdent({
-							context,
-							associatedObjectForCache
-						});
-						if (!name) continue;
-						const id = data.get(name);
-						const idAsString = `${id}`;
-						if (usedIds.has(idAsString)) {
-							const err = new WebpackError(
-								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
-							);
-							err.module = module;
-							compilation.errors.push(err);
-						}
-						chunkGraph.setModuleId(module, id);
-						usedIds.add(idAsString);
-					}
-				});
-			}
-			if (this._write) {
-				compilation.hooks.recordModules.tap(plugin, modules => {
-					const { chunkGraph } = compilation;
-					let oldData = data;
-					if (!oldData) {
-						oldData = data = new Map();
-					} else if (this._prune) {
-						data = new Map();
-					}
-					for (const module of modules) {
-						if (this._test(module)) {
-							const name = module.libIdent({
-								context,
-								associatedObjectForCache
-							});
-							if (!name) continue;
-							const id = chunkGraph.getModuleId(module);
-							if (id === null) continue;
-							const oldId = oldData.get(name);
-							if (oldId !== id) {
-								dataChanged = true;
-							} else if (data === oldData) {
-								continue;
-							}
-							data.set(name, id);
-						}
-					}
-					if (data.size !== oldData.size) dataChanged = true;
-				});
-			}
-		});
+	chunkHash(chunk, hash, chunkHashContext, libraryContext) {
+		const options = this._parseOptionsCached(
+			libraryContext.compilation.outputOptions.library
+		);
+		hash.update(this._pluginName);
+		hash.update(JSON.stringify(options));
 	}
 }
 
-module.exports = SyncModuleIdsPlugin;
+AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
+module.exports = AbstractLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 91919:
+/***/ 67416:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -95132,578 +95818,543 @@ module.exports = SyncModuleIdsPlugin;
 
 
 
-const util = __webpack_require__(73837);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
-/** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
-/** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetCondition} RuleSetCondition */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
-/** @typedef {import("./Compilation").Asset} Asset */
-/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("./MultiStats")} MultiStats */
-/** @typedef {import("./Parser").ParserState} ParserState */
-/** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
-/** @typedef {import("./ResolverFactory").Resolver} Resolver */
-/** @typedef {import("./Watching")} Watching */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkOrigin} StatsChunkOrigin */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLogging} StatsLogging */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsLoggingEntry} StatsLoggingEntry */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleIssuer} StatsModuleIssuer */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceDependency} StatsModuleTraceDependency */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModuleTraceItem} StatsModuleTraceItem */
-/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsProfile} StatsProfile */
+const { ConcatSource } = __webpack_require__(51255);
+const ExternalModule = __webpack_require__(73071);
+const Template = __webpack_require__(1626);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-/**
- * @template {Function} T
- * @param {function(): T} factory factory function
- * @returns {T} function
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @typedef {Object} AmdLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {boolean=} requireAsWrapper
  */
-const lazyFunction = factory => {
-	const fac = memoize(factory);
-	const f = /** @type {any} */ (
-		(...args) => {
-			return fac()(...args);
-		}
-	);
-	return /** @type {T} */ (f);
-};
 
 /**
- * @template A
- * @template B
- * @param {A} obj input a
- * @param {B} exports input b
- * @returns {A & B} merged
+ * @typedef {Object} AmdLibraryPluginParsed
+ * @property {string} name
  */
-const mergeExports = (obj, exports) => {
-	const descriptors = Object.getOwnPropertyDescriptors(exports);
-	for (const name of Object.keys(descriptors)) {
-		const descriptor = descriptors[name];
-		if (descriptor.get) {
-			const fn = descriptor.get;
-			Object.defineProperty(obj, name, {
-				configurable: false,
-				enumerable: true,
-				get: memoize(fn)
-			});
-		} else if (typeof descriptor.value === "object") {
-			Object.defineProperty(obj, name, {
-				configurable: false,
-				enumerable: true,
-				writable: false,
-				value: mergeExports({}, descriptor.value)
-			});
+
+/**
+ * @typedef {AmdLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<AmdLibraryPluginParsed>}
+ */
+class AmdLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {AmdLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "AmdLibraryPlugin",
+			type: options.type
+		});
+		this.requireAsWrapper = options.requireAsWrapper;
+	}
+
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (this.requireAsWrapper) {
+			if (name) {
+				throw new Error(
+					`AMD library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
 		} else {
-			throw new Error(
-				"Exposed values must be either a getter or an nested object"
-			);
+			if (name && typeof name !== "string") {
+				throw new Error(
+					`AMD library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
 		}
+		return {
+			name: /** @type {string=} */ (name)
+		};
 	}
-	return /** @type {A & B} */ (Object.freeze(obj));
-};
 
-const fn = lazyFunction(() => __webpack_require__(36243));
-module.exports = mergeExports(fn, {
-	get webpack() {
-		return __webpack_require__(36243);
-	},
-	get validate() {
-		const webpackOptionsSchemaCheck = __webpack_require__(10382);
-		const getRealValidate = memoize(() => {
-			const validateSchema = __webpack_require__(12047);
-			const webpackOptionsSchema = __webpack_require__(73342);
-			return options => validateSchema(webpackOptionsSchema, options);
-		});
-		return options => {
-			if (!webpackOptionsSchemaCheck(options)) getRealValidate()(options);
-		};
-	},
-	get validateSchema() {
-		const validateSchema = __webpack_require__(12047);
-		return validateSchema;
-	},
-	get version() {
-		return /** @type {string} */ ((__webpack_require__(32702)/* .version */ .i8));
-	},
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(
+		source,
+		{ chunkGraph, chunk, runtimeTemplate },
+		{ options, compilation }
+	) {
+		const modern = runtimeTemplate.supportsArrowFunction();
+		const modules = chunkGraph
+			.getChunkModules(chunk)
+			.filter(m => m instanceof ExternalModule);
+		const externals = /** @type {ExternalModule[]} */ (modules);
+		const externalsDepsArray = JSON.stringify(
+			externals.map(m =>
+				typeof m.request === "object" && !Array.isArray(m.request)
+					? m.request.amd
+					: m.request
+			)
+		);
+		const externalsArguments = externals
+			.map(
+				m =>
+					`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+						`${chunkGraph.getModuleId(m)}`
+					)}__`
+			)
+			.join(", ");
 
-	get cli() {
-		return __webpack_require__(13462);
-	},
-	get AutomaticPrefetchPlugin() {
-		return __webpack_require__(17714);
-	},
-	get AsyncDependenciesBlock() {
-		return __webpack_require__(47736);
-	},
-	get BannerPlugin() {
-		return __webpack_require__(21242);
-	},
-	get Cache() {
-		return __webpack_require__(7592);
-	},
-	get Chunk() {
-		return __webpack_require__(39385);
-	},
-	get ChunkGraph() {
-		return __webpack_require__(64971);
-	},
-	get CleanPlugin() {
-		return __webpack_require__(31085);
-	},
-	get Compilation() {
-		return __webpack_require__(85720);
-	},
-	get Compiler() {
-		return __webpack_require__(70845);
-	},
-	get ConcatenationScope() {
-		return __webpack_require__(98229);
-	},
-	get ContextExclusionPlugin() {
-		return __webpack_require__(21411);
-	},
-	get ContextReplacementPlugin() {
-		return __webpack_require__(12206);
-	},
-	get DefinePlugin() {
-		return __webpack_require__(79065);
-	},
-	get DelegatedPlugin() {
-		return __webpack_require__(80632);
-	},
-	get Dependency() {
-		return __webpack_require__(54912);
-	},
-	get DllPlugin() {
-		return __webpack_require__(40038);
-	},
-	get DllReferencePlugin() {
-		return __webpack_require__(90999);
-	},
-	get DynamicEntryPlugin() {
-		return __webpack_require__(96475);
-	},
-	get EntryOptionPlugin() {
-		return __webpack_require__(9909);
-	},
-	get EntryPlugin() {
-		return __webpack_require__(96953);
-	},
-	get EnvironmentPlugin() {
-		return __webpack_require__(22070);
-	},
-	get EvalDevToolModulePlugin() {
-		return __webpack_require__(65218);
-	},
-	get EvalSourceMapDevToolPlugin() {
-		return __webpack_require__(14790);
-	},
-	get ExternalModule() {
-		return __webpack_require__(73071);
-	},
-	get ExternalsPlugin() {
-		return __webpack_require__(6652);
-	},
-	get Generator() {
-		return __webpack_require__(93401);
-	},
-	get HotUpdateChunk() {
-		return __webpack_require__(9597);
-	},
-	get HotModuleReplacementPlugin() {
-		return __webpack_require__(6404);
-	},
-	get IgnorePlugin() {
-		return __webpack_require__(84808);
-	},
-	get JavascriptModulesPlugin() {
-		return util.deprecate(
-			() => __webpack_require__(89464),
-			"webpack.JavascriptModulesPlugin has moved to webpack.javascript.JavascriptModulesPlugin",
-			"DEP_WEBPACK_JAVASCRIPT_MODULES_PLUGIN"
-		)();
-	},
-	get LibManifestPlugin() {
-		return __webpack_require__(93837);
-	},
-	get LibraryTemplatePlugin() {
-		return util.deprecate(
-			() => __webpack_require__(14157),
-			"webpack.LibraryTemplatePlugin is deprecated and has been replaced by compilation.outputOptions.library or compilation.addEntry + passing a library option",
-			"DEP_WEBPACK_LIBRARY_TEMPLATE_PLUGIN"
-		)();
-	},
-	get LoaderOptionsPlugin() {
-		return __webpack_require__(22078);
-	},
-	get LoaderTargetPlugin() {
-		return __webpack_require__(86738);
-	},
-	get Module() {
-		return __webpack_require__(73208);
-	},
-	get ModuleFilenameHelpers() {
-		return __webpack_require__(88821);
-	},
-	get ModuleGraph() {
-		return __webpack_require__(99988);
-	},
-	get ModuleGraphConnection() {
-		return __webpack_require__(40639);
-	},
-	get NoEmitOnErrorsPlugin() {
-		return __webpack_require__(50169);
-	},
-	get NormalModule() {
-		return __webpack_require__(39);
-	},
-	get NormalModuleReplacementPlugin() {
-		return __webpack_require__(30633);
-	},
-	get MultiCompiler() {
-		return __webpack_require__(33370);
-	},
-	get Parser() {
-		return __webpack_require__(11715);
-	},
-	get PrefetchPlugin() {
-		return __webpack_require__(73850);
-	},
-	get ProgressPlugin() {
-		return __webpack_require__(13216);
-	},
-	get ProvidePlugin() {
-		return __webpack_require__(38309);
-	},
-	get RuntimeGlobals() {
-		return __webpack_require__(16475);
-	},
-	get RuntimeModule() {
-		return __webpack_require__(16963);
-	},
-	get SingleEntryPlugin() {
-		return util.deprecate(
-			() => __webpack_require__(96953),
-			"SingleEntryPlugin was renamed to EntryPlugin",
-			"DEP_WEBPACK_SINGLE_ENTRY_PLUGIN"
-		)();
-	},
-	get SourceMapDevToolPlugin() {
-		return __webpack_require__(63872);
-	},
-	get Stats() {
-		return __webpack_require__(31743);
-	},
-	get Template() {
-		return __webpack_require__(39722);
-	},
-	get UsageState() {
-		return (__webpack_require__(63686).UsageState);
-	},
-	get WatchIgnorePlugin() {
-		return __webpack_require__(65193);
-	},
-	get WebpackError() {
-		return __webpack_require__(53799);
-	},
-	get WebpackOptionsApply() {
-		return __webpack_require__(88422);
-	},
-	get WebpackOptionsDefaulter() {
-		return util.deprecate(
-			() => __webpack_require__(14452),
-			"webpack.WebpackOptionsDefaulter is deprecated and has been replaced by webpack.config.getNormalizedWebpackOptions and webpack.config.applyWebpackOptionsDefaults",
-			"DEP_WEBPACK_OPTIONS_DEFAULTER"
-		)();
-	},
-	// TODO webpack 6 deprecate
-	get WebpackOptionsValidationError() {
-		return (__webpack_require__(38476).ValidationError);
-	},
-	get ValidationError() {
-		return (__webpack_require__(38476).ValidationError);
-	},
+		const iife = runtimeTemplate.isIIFE();
+		const fnStart =
+			(modern
+				? `(${externalsArguments}) => {`
+				: `function(${externalsArguments}) {`) +
+			(iife || !chunk.hasRuntime() ? " return " : "\n");
+		const fnEnd = iife ? ";\n}" : "\n}";
 
-	cache: {
-		get MemoryCachePlugin() {
-			return __webpack_require__(52539);
-		}
-	},
+		if (this.requireAsWrapper) {
+			return new ConcatSource(
+				`require(${externalsDepsArray}, ${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
+		} else if (options.name) {
+			const name = compilation.getPath(options.name, {
+				chunk
+			});
 
-	config: {
-		get getNormalizedWebpackOptions() {
-			return (__webpack_require__(26693).getNormalizedWebpackOptions);
-		},
-		get applyWebpackOptionsDefaults() {
-			return (__webpack_require__(92988).applyWebpackOptionsDefaults);
+			return new ConcatSource(
+				`define(${JSON.stringify(name)}, ${externalsDepsArray}, ${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
+		} else if (externalsArguments) {
+			return new ConcatSource(
+				`define(${externalsDepsArray}, ${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
+		} else {
+			return new ConcatSource(`define(${fnStart}`, source, `${fnEnd});`);
 		}
-	},
+	}
 
-	dependencies: {
-		get ModuleDependency() {
-			return __webpack_require__(80321);
-		},
-		get ConstDependency() {
-			return __webpack_require__(76911);
-		},
-		get NullDependency() {
-			return __webpack_require__(31830);
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("AmdLibraryPlugin");
+		if (this.requireAsWrapper) {
+			hash.update("requireAsWrapper");
+		} else if (options.name) {
+			hash.update("named");
+			const name = compilation.getPath(options.name, {
+				chunk
+			});
+			hash.update(name);
 		}
-	},
+	}
+}
 
-	ids: {
-		get ChunkModuleIdRangePlugin() {
-			return __webpack_require__(64618);
-		},
-		get NaturalModuleIdsPlugin() {
-			return __webpack_require__(83366);
-		},
-		get OccurrenceModuleIdsPlugin() {
-			return __webpack_require__(35371);
-		},
-		get NamedModuleIdsPlugin() {
-			return __webpack_require__(24339);
-		},
-		get DeterministicChunkIdsPlugin() {
-			return __webpack_require__(8747);
-		},
-		get DeterministicModuleIdsPlugin() {
-			return __webpack_require__(76692);
-		},
-		get NamedChunkIdsPlugin() {
-			return __webpack_require__(6454);
-		},
-		get OccurrenceChunkIdsPlugin() {
-			return __webpack_require__(51020);
-		},
-		get HashedModuleIdsPlugin() {
-			return __webpack_require__(21825);
-		}
-	},
+module.exports = AmdLibraryPlugin;
 
-	javascript: {
-		get EnableChunkLoadingPlugin() {
-			return __webpack_require__(61291);
-		},
-		get JavascriptModulesPlugin() {
-			return __webpack_require__(89464);
-		},
-		get JavascriptParser() {
-			return __webpack_require__(29050);
-		}
-	},
 
-	optimize: {
-		get AggressiveMergingPlugin() {
-			return __webpack_require__(64395);
-		},
-		get AggressiveSplittingPlugin() {
-			return util.deprecate(
-				() => __webpack_require__(15543),
-				"AggressiveSplittingPlugin is deprecated in favor of SplitChunksPlugin",
-				"DEP_WEBPACK_AGGRESSIVE_SPLITTING_PLUGIN"
-			)();
-		},
-		get InnerGraph() {
-			return __webpack_require__(38988);
-		},
-		get LimitChunkCountPlugin() {
-			return __webpack_require__(83608);
-		},
-		get MinChunkSizePlugin() {
-			return __webpack_require__(53912);
-		},
-		get ModuleConcatenationPlugin() {
-			return __webpack_require__(74844);
-		},
-		get RealContentHashPlugin() {
-			return __webpack_require__(46043);
-		},
-		get RuntimeChunkPlugin() {
-			return __webpack_require__(2837);
-		},
-		get SideEffectsFlagPlugin() {
-			return __webpack_require__(84800);
-		},
-		get SplitChunksPlugin() {
-			return __webpack_require__(21478);
-		}
-	},
+/***/ }),
 
-	runtime: {
-		get GetChunkFilenameRuntimeModule() {
-			return __webpack_require__(34277);
-		},
-		get LoadScriptRuntimeModule() {
-			return __webpack_require__(19942);
-		}
-	},
+/***/ 40080:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	prefetch: {
-		get ChunkPrefetchPreloadPlugin() {
-			return __webpack_require__(33895);
-		}
-	},
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	web: {
-		get FetchCompileAsyncWasmPlugin() {
-			return __webpack_require__(8437);
-		},
-		get FetchCompileWasmPlugin() {
-			return __webpack_require__(35537);
-		},
-		get JsonpChunkLoadingRuntimeModule() {
-			return __webpack_require__(84154);
-		},
-		get JsonpTemplatePlugin() {
-			return __webpack_require__(4607);
-		}
-	},
 
-	webworker: {
-		get WebWorkerTemplatePlugin() {
-			return __webpack_require__(68693);
-		}
-	},
 
-	node: {
-		get NodeEnvironmentPlugin() {
-			return __webpack_require__(7553);
-		},
-		get NodeSourcePlugin() {
-			return __webpack_require__(7103);
-		},
-		get NodeTargetPlugin() {
-			return __webpack_require__(17916);
-		},
-		get NodeTemplatePlugin() {
-			return __webpack_require__(61052);
-		},
-		get ReadFileCompileWasmPlugin() {
-			return __webpack_require__(98939);
-		}
-	},
+const { ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Template = __webpack_require__(1626);
+const propertyAccess = __webpack_require__(54190);
+const { getEntryRuntime } = __webpack_require__(17156);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-	electron: {
-		get ElectronTargetPlugin() {
-			return __webpack_require__(32277);
-		}
-	},
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-	wasm: {
-		get AsyncWebAssemblyModulesPlugin() {
-			return __webpack_require__(7538);
-		}
-	},
+const KEYWORD_REGEX =
+	/^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
+const IDENTIFIER_REGEX =
+	/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
 
-	library: {
-		get AbstractLibraryPlugin() {
-			return __webpack_require__(26030);
-		},
-		get EnableLibraryPlugin() {
-			return __webpack_require__(91452);
-		}
-	},
+/**
+ * Validates the library name by checking for keywords and valid characters
+ * @param {string} name name to be validated
+ * @returns {boolean} true, when valid
+ */
+const isNameValid = name => {
+	return !KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
+};
 
-	container: {
-		get ContainerPlugin() {
-			return __webpack_require__(9244);
-		},
-		get ContainerReferencePlugin() {
-			return __webpack_require__(95757);
-		},
-		get ModuleFederationPlugin() {
-			return __webpack_require__(30569);
-		},
-		get scope() {
-			return (__webpack_require__(3083).scope);
-		}
-	},
+/**
+ * @param {string[]} accessor variable plus properties
+ * @param {number} existingLength items of accessor that are existing already
+ * @param {boolean=} initLast if the last property should also be initialized to an object
+ * @returns {string} code to access the accessor while initializing
+ */
+const accessWithInit = (accessor, existingLength, initLast = false) => {
+	// This generates for [a, b, c, d]:
+	// (((a = typeof a === "undefined" ? {} : a).b = a.b || {}).c = a.b.c || {}).d
+	const base = accessor[0];
+	if (accessor.length === 1 && !initLast) return base;
+	let current =
+		existingLength > 0
+			? base
+			: `(${base} = typeof ${base} === "undefined" ? {} : ${base})`;
 
-	sharing: {
-		get ConsumeSharedPlugin() {
-			return __webpack_require__(15046);
-		},
-		get ProvideSharedPlugin() {
-			return __webpack_require__(31225);
-		},
-		get SharePlugin() {
-			return __webpack_require__(26335);
-		},
-		get scope() {
-			return (__webpack_require__(3083).scope);
+	// i is the current position in accessor that has been printed
+	let i = 1;
+
+	// all properties printed so far (excluding base)
+	let propsSoFar;
+
+	// if there is existingLength, print all properties until this position as property access
+	if (existingLength > i) {
+		propsSoFar = accessor.slice(1, existingLength);
+		i = existingLength;
+		current += propertyAccess(propsSoFar);
+	} else {
+		propsSoFar = [];
+	}
+
+	// all remaining properties (except the last one when initLast is not set)
+	// should be printed as initializer
+	const initUntil = initLast ? accessor.length : accessor.length - 1;
+	for (; i < initUntil; i++) {
+		const prop = accessor[i];
+		propsSoFar.push(prop);
+		current = `(${current}${propertyAccess([prop])} = ${base}${propertyAccess(
+			propsSoFar
+		)} || {})`;
+	}
+
+	// print the last property as property access if not yet printed
+	if (i < accessor.length)
+		current = `${current}${propertyAccess([accessor[accessor.length - 1]])}`;
+
+	return current;
+};
+
+/**
+ * @typedef {Object} AssignLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {string[] | "global"} prefix name prefix
+ * @property {string | false} declare declare name as variable
+ * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
+ * @property {"copy"|"assign"=} named behavior for named library name
+ */
+
+/**
+ * @typedef {Object} AssignLibraryPluginParsed
+ * @property {string | string[]} name
+ * @property {string | string[] | undefined} export
+ */
+
+/**
+ * @typedef {AssignLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
+ */
+class AssignLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {AssignLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "AssignLibraryPlugin",
+			type: options.type
+		});
+		this.prefix = options.prefix;
+		this.declare = options.declare;
+		this.unnamed = options.unnamed;
+		this.named = options.named || "assign";
+	}
+
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (this.unnamed === "error") {
+			if (typeof name !== "string" && !Array.isArray(name)) {
+				throw new Error(
+					`Library name must be a string or string array. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
+		} else {
+			if (name && typeof name !== "string" && !Array.isArray(name)) {
+				throw new Error(
+					`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				);
+			}
 		}
-	},
+		return {
+			name: /** @type {string|string[]=} */ (name),
+			export: library.export
+		};
+	}
 
-	debug: {
-		get ProfilingPlugin() {
-			return __webpack_require__(2757);
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	finishEntryModule(
+		module,
+		entryName,
+		{ options, compilation, compilation: { moduleGraph } }
+	) {
+		const runtime = getEntryRuntime(compilation, entryName);
+		if (options.export) {
+			const exportsInfo = moduleGraph.getExportInfo(
+				module,
+				Array.isArray(options.export) ? options.export[0] : options.export
+			);
+			exportsInfo.setUsed(UsageState.Used, runtime);
+			exportsInfo.canMangleUse = false;
+		} else {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			exportsInfo.setUsedInUnknownWay(runtime);
 		}
-	},
+		moduleGraph.addExtraReason(module, "used as library export");
+	}
 
-	util: {
-		get createHash() {
-			return __webpack_require__(49835);
-		},
-		get comparators() {
-			return __webpack_require__(29579);
-		},
-		get runtime() {
-			return __webpack_require__(17156);
-		},
-		get serialization() {
-			return __webpack_require__(8282);
-		},
-		get cleverMerge() {
-			return (__webpack_require__(60839).cachedCleverMerge);
-		},
-		get LazySet() {
-			return __webpack_require__(38938);
+	_getPrefix(compilation) {
+		return this.prefix === "global"
+			? [compilation.runtimeTemplate.globalObject]
+			: this.prefix;
+	}
+
+	_getResolvedFullName(options, chunk, compilation) {
+		const prefix = this._getPrefix(compilation);
+		const fullName = options.name ? prefix.concat(options.name) : prefix;
+		return fullName.map(n =>
+			compilation.getPath(n, {
+				chunk
+			})
+		);
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, { chunk }, { options, compilation }) {
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		if (this.declare) {
+			const base = fullNameResolved[0];
+			if (!isNameValid(base)) {
+				throw new Error(
+					`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
+						base
+					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${
+						AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE
+					}`
+				);
+			}
+			source = new ConcatSource(`${this.declare} ${base};\n`, source);
 		}
-	},
+		return source;
+	}
 
-	get sources() {
-		return __webpack_require__(51255);
-	},
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
+		const topLevelDeclarations =
+			module.buildInfo && module.buildInfo.topLevelDeclarations;
+		if (!topLevelDeclarations)
+			return "it doesn't tell about top level declarations.";
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		const base = fullNameResolved[0];
+		if (topLevelDeclarations.has(base))
+			return `it declares '${base}' on top-level, which conflicts with the current library output.`;
+	}
 
-	experiments: {
-		schemes: {
-			get HttpUriPlugin() {
-				return __webpack_require__(42110);
+	/**
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {string | undefined} bailout reason
+	 */
+	strictRuntimeBailout({ chunk }, { options, compilation }) {
+		if (
+			this.declare ||
+			this.prefix === "global" ||
+			this.prefix.length > 0 ||
+			!options.name
+		) {
+			return;
+		}
+		return "a global variable is assign and maybe created";
+	}
+
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		const staticExports = this.unnamed === "static";
+		const exportAccess = options.export
+			? propertyAccess(
+					Array.isArray(options.export) ? options.export : [options.export]
+			  )
+			: "";
+		const result = new ConcatSource(source);
+		if (staticExports) {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportTarget = accessWithInit(
+				fullNameResolved,
+				this._getPrefix(compilation).length,
+				true
+			);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (!exportInfo.provided) continue;
+				const nameAccess = propertyAccess([exportInfo.name]);
+				result.add(
+					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
+				);
 			}
-		},
-		ids: {
-			get SyncModuleIdsPlugin() {
-				return __webpack_require__(8635);
+			result.add(
+				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
+			);
+		} else if (options.name ? this.named === "copy" : this.unnamed === "copy") {
+			result.add(
+				`var __webpack_export_target__ = ${accessWithInit(
+					fullNameResolved,
+					this._getPrefix(compilation).length,
+					true
+				)};\n`
+			);
+			let exports = "__webpack_exports__";
+			if (exportAccess) {
+				result.add(
+					`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
+				);
+				exports = "__webpack_exports_export__";
 			}
+			result.add(
+				`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`
+			);
+			result.add(
+				`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`
+			);
+		} else {
+			result.add(
+				`${accessWithInit(
+					fullNameResolved,
+					this._getPrefix(compilation).length,
+					false
+				)} = __webpack_exports__${exportAccess};\n`
+			);
 		}
+		return result;
 	}
-});
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	runtimeRequirements(chunk, set, libraryContext) {
+		// we don't need to return exports from runtime
+	}
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("AssignLibraryPlugin");
+		const fullNameResolved = this._getResolvedFullName(
+			options,
+			chunk,
+			compilation
+		);
+		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
+			hash.update("copy");
+		}
+		if (this.declare) {
+			hash.update(this.declare);
+		}
+		hash.update(fullNameResolved.join("."));
+		if (options.export) {
+			hash.update(`${options.export}`);
+		}
+	}
+}
+
+module.exports = AssignLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 18535:
+/***/ 91452:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -95714,159 +96365,253 @@ module.exports = mergeExports(fn, {
 
 
 
-const { ConcatSource, PrefixSource, RawSource } = __webpack_require__(51255);
-const { RuntimeGlobals } = __webpack_require__(91919);
-const HotUpdateChunk = __webpack_require__(9597);
-const Template = __webpack_require__(39722);
-const { getCompilationHooks } = __webpack_require__(89464);
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = __webpack_require__(98124);
-
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Compiler")} Compiler */
 
-class ArrayPushCallbackChunkFormatPlugin {
+/** @type {WeakMap<Compiler, Set<LibraryType>>} */
+const enabledTypes = new WeakMap();
+
+const getEnabledTypes = compiler => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
+	}
+	return set;
+};
+
+class EnableLibraryPlugin {
+	/**
+	 * @param {LibraryType} type library type that should be available
+	 */
+	constructor(type) {
+		this.type = type;
+	}
+
 	/**
-	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
+	 * @param {LibraryType} type type of library
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ArrayPushCallbackChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.require);
-						}
-						set.add(RuntimeGlobals.chunkCallback);
-					}
-				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
-						const globalObject = runtimeTemplate.globalObject;
-						const source = new ConcatSource();
-						const runtimeModules =
-							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-						if (hotUpdateChunk) {
-							const hotUpdateGlobal =
-								runtimeTemplate.outputOptions.hotUpdateGlobal;
-							source.add(
-								`${globalObject}[${JSON.stringify(hotUpdateGlobal)}](`
-							);
-							source.add(`${JSON.stringify(chunk.id)},`);
-							source.add(modules);
-							if (runtimeModules.length > 0) {
-								source.add(",\n");
-								const runtimePart = Template.renderChunkRuntimeModules(
-									runtimeModules,
-									renderContext
-								);
-								source.add(runtimePart);
-							}
-							source.add(")");
-						} else {
-							const chunkLoadingGlobal =
-								runtimeTemplate.outputOptions.chunkLoadingGlobal;
-							source.add(
-								`(${globalObject}[${JSON.stringify(
-									chunkLoadingGlobal
-								)}] = ${globalObject}[${JSON.stringify(
-									chunkLoadingGlobal
-								)}] || []).push([`
-							);
-							source.add(`${JSON.stringify(chunk.ids)},`);
-							source.add(modules);
-							const entries = Array.from(
-								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-							);
-							if (runtimeModules.length > 0 || entries.length > 0) {
-								const runtime = new ConcatSource(
-									(runtimeTemplate.supportsArrowFunction()
-										? "__webpack_require__ =>"
-										: "function(__webpack_require__)") +
-										" { // webpackRuntimeModules\n"
-								);
-								if (runtimeModules.length > 0) {
-									runtime.add(
-										Template.renderRuntimeModules(runtimeModules, {
-											...renderContext,
-											codeGenerationResults: compilation.codeGenerationResults
-										})
-									);
-								}
-								if (entries.length > 0) {
-									const startupSource = new RawSource(
-										generateEntryStartup(
-											chunkGraph,
-											runtimeTemplate,
-											entries,
-											chunk,
-											true
-										)
-									);
-									runtime.add(
-										hooks.renderStartup.call(
-											startupSource,
-											entries[entries.length - 1][0],
-											{
-												...renderContext,
-												inlined: false
-											}
-										)
-									);
-									if (
-										chunkGraph
-											.getChunkRuntimeRequirements(chunk)
-											.has(RuntimeGlobals.returnExportsFromRuntime)
-									) {
-										runtime.add("return __webpack_exports__;\n");
-									}
-								}
-								runtime.add("}\n");
-								source.add(",\n");
-								source.add(new PrefixSource("/******/ ", runtime));
-							}
-							source.add("])");
-						}
-						return source;
-					}
-				);
-				hooks.chunkHash.tap(
-					"ArrayPushCallbackChunkFormatPlugin",
-					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update(
-							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.globalObject}`
-						);
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-					}
-				);
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
+	}
+
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {LibraryType} type type of library
+	 * @returns {void}
+	 */
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Library type "${type}" is not enabled. ` +
+					"EnableLibraryPlugin need to be used to enable this type of library. " +
+					'This usually happens through the "output.enabledLibraryTypes" option. ' +
+					'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
+					"These types are enabled: " +
+					Array.from(getEnabledTypes(compiler)).join(", ")
+			);
+		}
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { type } = this;
+
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
+
+		if (typeof type === "string") {
+			const enableExportProperty = () => {
+				const ExportPropertyTemplatePlugin = __webpack_require__(5487);
+				new ExportPropertyTemplatePlugin({
+					type,
+					nsObjectUsed: type !== "module"
+				}).apply(compiler);
+			};
+			switch (type) {
+				case "var": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: "var",
+						unnamed: "error"
+					}).apply(compiler);
+					break;
+				}
+				case "assign-properties": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: false,
+						unnamed: "error",
+						named: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "assign": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: false,
+						unnamed: "error"
+					}).apply(compiler);
+					break;
+				}
+				case "this": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["this"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "window": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["window"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "self": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["self"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "global": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: "global",
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "commonjs": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["exports"],
+						declare: false,
+						unnamed: "copy"
+					}).apply(compiler);
+					break;
+				}
+				case "commonjs-static": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["exports"],
+						declare: false,
+						unnamed: "static"
+					}).apply(compiler);
+					break;
+				}
+				case "commonjs2":
+				case "commonjs-module": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = __webpack_require__(40080);
+					new AssignLibraryPlugin({
+						type,
+						prefix: ["module", "exports"],
+						declare: false,
+						unnamed: "assign"
+					}).apply(compiler);
+					break;
+				}
+				case "amd":
+				case "amd-require": {
+					enableExportProperty();
+					const AmdLibraryPlugin = __webpack_require__(67416);
+					new AmdLibraryPlugin({
+						type,
+						requireAsWrapper: type === "amd-require"
+					}).apply(compiler);
+					break;
+				}
+				case "umd":
+				case "umd2": {
+					enableExportProperty();
+					const UmdLibraryPlugin = __webpack_require__(54442);
+					new UmdLibraryPlugin({
+						type,
+						optionalAmdExternalAsGlobal: type === "umd2"
+					}).apply(compiler);
+					break;
+				}
+				case "system": {
+					enableExportProperty();
+					const SystemLibraryPlugin = __webpack_require__(11707);
+					new SystemLibraryPlugin({
+						type
+					}).apply(compiler);
+					break;
+				}
+				case "jsonp": {
+					enableExportProperty();
+					const JsonpLibraryPlugin = __webpack_require__(84415);
+					new JsonpLibraryPlugin({
+						type
+					}).apply(compiler);
+					break;
+				}
+				case "module": {
+					enableExportProperty();
+					const ModuleLibraryPlugin = __webpack_require__(59780);
+					new ModuleLibraryPlugin({
+						type
+					}).apply(compiler);
+					break;
+				}
+				default:
+					throw new Error(`Unsupported library type ${type}.
+Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);
 			}
-		);
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
+		}
 	}
 }
 
-module.exports = ArrayPushCallbackChunkFormatPlugin;
+module.exports = EnableLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 950:
-/***/ (function(module) {
+/***/ 5487:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -95876,705 +96621,566 @@ module.exports = ArrayPushCallbackChunkFormatPlugin;
 
 
 
-/** @typedef {import("estree").Node} EsTreeNode */
-/** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
-
-const TypeUnknown = 0;
-const TypeUndefined = 1;
-const TypeNull = 2;
-const TypeString = 3;
-const TypeNumber = 4;
-const TypeBoolean = 5;
-const TypeRegExp = 6;
-const TypeConditional = 7;
-const TypeArray = 8;
-const TypeConstArray = 9;
-const TypeIdentifier = 10;
-const TypeWrapped = 11;
-const TypeTemplateString = 12;
-const TypeBigInt = 13;
+const { ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const propertyAccess = __webpack_require__(54190);
+const { getEntryRuntime } = __webpack_require__(17156);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-class BasicEvaluatedExpression {
-	constructor() {
-		this.type = TypeUnknown;
-		/** @type {[number, number]} */
-		this.range = undefined;
-		/** @type {boolean} */
-		this.falsy = false;
-		/** @type {boolean} */
-		this.truthy = false;
-		/** @type {boolean | undefined} */
-		this.nullish = undefined;
-		/** @type {boolean} */
-		this.sideEffects = true;
-		/** @type {boolean | undefined} */
-		this.bool = undefined;
-		/** @type {number | undefined} */
-		this.number = undefined;
-		/** @type {bigint | undefined} */
-		this.bigint = undefined;
-		/** @type {RegExp | undefined} */
-		this.regExp = undefined;
-		/** @type {string | undefined} */
-		this.string = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.quasis = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.parts = undefined;
-		/** @type {any[] | undefined} */
-		this.array = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.items = undefined;
-		/** @type {BasicEvaluatedExpression[] | undefined} */
-		this.options = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
-		this.prefix = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
-		this.postfix = undefined;
-		this.wrappedInnerExpressions = undefined;
-		/** @type {string | undefined} */
-		this.identifier = undefined;
-		/** @type {VariableInfoInterface} */
-		this.rootInfo = undefined;
-		/** @type {() => string[]} */
-		this.getMembers = undefined;
-		/** @type {EsTreeNode} */
-		this.expression = undefined;
-	}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-	isUnknown() {
-		return this.type === TypeUnknown;
-	}
+/**
+ * @typedef {Object} ExportPropertyLibraryPluginParsed
+ * @property {string | string[]} export
+ */
 
-	isNull() {
-		return this.type === TypeNull;
+/**
+ * @typedef {Object} ExportPropertyLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {boolean} nsObjectUsed the namespace object is used
+ */
+/**
+ * @typedef {ExportPropertyLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<ExportPropertyLibraryPluginParsed>}
+ */
+class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {ExportPropertyLibraryPluginOptions} options options
+	 */
+	constructor({ type, nsObjectUsed }) {
+		super({
+			pluginName: "ExportPropertyLibraryPlugin",
+			type
+		});
+		this.nsObjectUsed = nsObjectUsed;
 	}
 
-	isUndefined() {
-		return this.type === TypeUndefined;
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		return {
+			export: library.export
+		};
 	}
 
-	isString() {
-		return this.type === TypeString;
+	/**
+	 * @param {Module} module the exporting entry module
+	 * @param {string} entryName the name of the entrypoint
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	finishEntryModule(
+		module,
+		entryName,
+		{ options, compilation, compilation: { moduleGraph } }
+	) {
+		const runtime = getEntryRuntime(compilation, entryName);
+		if (options.export) {
+			const exportsInfo = moduleGraph.getExportInfo(
+				module,
+				Array.isArray(options.export) ? options.export[0] : options.export
+			);
+			exportsInfo.setUsed(UsageState.Used, runtime);
+			exportsInfo.canMangleUse = false;
+		} else {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			if (this.nsObjectUsed) {
+				exportsInfo.setUsedInUnknownWay(runtime);
+			} else {
+				exportsInfo.setAllKnownExportsUsed(runtime);
+			}
+		}
+		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
-	isNumber() {
-		return this.type === TypeNumber;
-	}
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Set<string>} set runtime requirements
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	runtimeRequirements(chunk, set, libraryContext) {}
 
-	isBigInt() {
-		return this.type === TypeBigInt;
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(source, module, renderContext, { options }) {
+		if (!options.export) return source;
+		const postfix = `__webpack_exports__ = __webpack_exports__${propertyAccess(
+			Array.isArray(options.export) ? options.export : [options.export]
+		)};\n`;
+		return new ConcatSource(source, postfix);
 	}
+}
 
-	isBoolean() {
-		return this.type === TypeBoolean;
-	}
+module.exports = ExportPropertyLibraryPlugin;
 
-	isRegExp() {
-		return this.type === TypeRegExp;
-	}
 
-	isConditional() {
-		return this.type === TypeConditional;
-	}
+/***/ }),
 
-	isArray() {
-		return this.type === TypeArray;
-	}
+/***/ 84415:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	isConstArray() {
-		return this.type === TypeConstArray;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	isIdentifier() {
-		return this.type === TypeIdentifier;
-	}
 
-	isWrapped() {
-		return this.type === TypeWrapped;
-	}
 
-	isTemplateString() {
-		return this.type === TypeTemplateString;
-	}
+const { ConcatSource } = __webpack_require__(51255);
+const AbstractLibraryPlugin = __webpack_require__(26030);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+
+/**
+ * @typedef {Object} JsonpLibraryPluginOptions
+ * @property {LibraryType} type
+ */
+
+/**
+ * @typedef {Object} JsonpLibraryPluginParsed
+ * @property {string} name
+ */
 
+/**
+ * @typedef {JsonpLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<JsonpLibraryPluginParsed>}
+ */
+class JsonpLibraryPlugin extends AbstractLibraryPlugin {
 	/**
-	 * Is expression a primitive or an object type value?
-	 * @returns {boolean | undefined} true: primitive type, false: object type, undefined: unknown/runtime-defined
+	 * @param {JsonpLibraryPluginOptions} options the plugin options
 	 */
-	isPrimitiveType() {
-		switch (this.type) {
-			case TypeUndefined:
-			case TypeNull:
-			case TypeString:
-			case TypeNumber:
-			case TypeBoolean:
-			case TypeBigInt:
-			case TypeWrapped:
-			case TypeTemplateString:
-				return true;
-			case TypeRegExp:
-			case TypeArray:
-			case TypeConstArray:
-				return false;
-			default:
-				return undefined;
-		}
+	constructor(options) {
+		super({
+			pluginName: "JsonpLibraryPlugin",
+			type: options.type
+		});
 	}
 
 	/**
-	 * Is expression a runtime or compile-time value?
-	 * @returns {boolean} true: compile time value, false: runtime value
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
 	 */
-	isCompileTimeValue() {
-		switch (this.type) {
-			case TypeUndefined:
-			case TypeNull:
-			case TypeString:
-			case TypeNumber:
-			case TypeBoolean:
-			case TypeRegExp:
-			case TypeConstArray:
-			case TypeBigInt:
-				return true;
-			default:
-				return false;
+	parseOptions(library) {
+		const { name } = library;
+		if (typeof name !== "string") {
+			throw new Error(
+				`Jsonp library name must be a simple string. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
 		}
+		return {
+			name: /** @type {string} */ (name)
+		};
 	}
 
 	/**
-	 * Gets the compile-time value of the expression
-	 * @returns {any} the javascript value
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
 	 */
-	asCompileTimeValue() {
-		switch (this.type) {
-			case TypeUndefined:
-				return undefined;
-			case TypeNull:
-				return null;
-			case TypeString:
-				return this.string;
-			case TypeNumber:
-				return this.number;
-			case TypeBoolean:
-				return this.bool;
-			case TypeRegExp:
-				return this.regExp;
-			case TypeConstArray:
-				return this.array;
-			case TypeBigInt:
-				return this.bigint;
-			default:
-				throw new Error(
-					"asCompileTimeValue must only be called for compile-time values"
-				);
-		}
-	}
-
-	isTruthy() {
-		return this.truthy;
-	}
-
-	isFalsy() {
-		return this.falsy;
-	}
-
-	isNullish() {
-		return this.nullish;
+	render(source, { chunk }, { options, compilation }) {
+		const name = compilation.getPath(options.name, {
+			chunk
+		});
+		return new ConcatSource(`${name}(`, source, ")");
 	}
 
 	/**
-	 * Can this expression have side effects?
-	 * @returns {boolean} false: never has side effects
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
 	 */
-	couldHaveSideEffects() {
-		return this.sideEffects;
-	}
-
-	asBool() {
-		if (this.truthy) return true;
-		if (this.falsy || this.nullish) return false;
-		if (this.isBoolean()) return this.bool;
-		if (this.isNull()) return false;
-		if (this.isUndefined()) return false;
-		if (this.isString()) return this.string !== "";
-		if (this.isNumber()) return this.number !== 0;
-		if (this.isBigInt()) return this.bigint !== BigInt(0);
-		if (this.isRegExp()) return true;
-		if (this.isArray()) return true;
-		if (this.isConstArray()) return true;
-		if (this.isWrapped()) {
-			return (this.prefix && this.prefix.asBool()) ||
-				(this.postfix && this.postfix.asBool())
-				? true
-				: undefined;
-		}
-		if (this.isTemplateString()) {
-			const str = this.asString();
-			if (typeof str === "string") return str !== "";
-		}
-		return undefined;
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("JsonpLibraryPlugin");
+		hash.update(compilation.getPath(options.name, { chunk }));
 	}
+}
 
-	asNullish() {
-		const nullish = this.isNullish();
-
-		if (nullish === true || this.isNull() || this.isUndefined()) return true;
-
-		if (nullish === false) return false;
-		if (this.isTruthy()) return false;
-		if (this.isBoolean()) return false;
-		if (this.isString()) return false;
-		if (this.isNumber()) return false;
-		if (this.isBigInt()) return false;
-		if (this.isRegExp()) return false;
-		if (this.isArray()) return false;
-		if (this.isConstArray()) return false;
-		if (this.isTemplateString()) return false;
-		if (this.isRegExp()) return false;
+module.exports = JsonpLibraryPlugin;
 
-		return undefined;
-	}
 
-	asString() {
-		if (this.isBoolean()) return `${this.bool}`;
-		if (this.isNull()) return "null";
-		if (this.isUndefined()) return "undefined";
-		if (this.isString()) return this.string;
-		if (this.isNumber()) return `${this.number}`;
-		if (this.isBigInt()) return `${this.bigint}`;
-		if (this.isRegExp()) return `${this.regExp}`;
-		if (this.isArray()) {
-			let array = [];
-			for (const item of this.items) {
-				const itemStr = item.asString();
-				if (itemStr === undefined) return undefined;
-				array.push(itemStr);
-			}
-			return `${array}`;
-		}
-		if (this.isConstArray()) return `${this.array}`;
-		if (this.isTemplateString()) {
-			let str = "";
-			for (const part of this.parts) {
-				const partStr = part.asString();
-				if (partStr === undefined) return undefined;
-				str += partStr;
-			}
-			return str;
-		}
-		return undefined;
-	}
+/***/ }),
 
-	setString(string) {
-		this.type = TypeString;
-		this.string = string;
-		this.sideEffects = false;
-		return this;
-	}
+/***/ 59780:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	setUndefined() {
-		this.type = TypeUndefined;
-		this.sideEffects = false;
-		return this;
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	setNull() {
-		this.type = TypeNull;
-		this.sideEffects = false;
-		return this;
-	}
 
-	setNumber(number) {
-		this.type = TypeNumber;
-		this.number = number;
-		this.sideEffects = false;
-		return this;
-	}
 
-	setBigInt(bigint) {
-		this.type = TypeBigInt;
-		this.bigint = bigint;
-		this.sideEffects = false;
-		return this;
-	}
+const { ConcatSource } = __webpack_require__(51255);
+const Template = __webpack_require__(1626);
+const propertyAccess = __webpack_require__(54190);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
-	setBoolean(bool) {
-		this.type = TypeBoolean;
-		this.bool = bool;
-		this.sideEffects = false;
-		return this;
-	}
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-	setRegExp(regExp) {
-		this.type = TypeRegExp;
-		this.regExp = regExp;
-		this.sideEffects = false;
-		return this;
-	}
+/**
+ * @typedef {Object} ModuleLibraryPluginOptions
+ * @property {LibraryType} type
+ */
 
-	setIdentifier(identifier, rootInfo, getMembers) {
-		this.type = TypeIdentifier;
-		this.identifier = identifier;
-		this.rootInfo = rootInfo;
-		this.getMembers = getMembers;
-		this.sideEffects = true;
-		return this;
-	}
+/**
+ * @typedef {Object} ModuleLibraryPluginParsed
+ * @property {string} name
+ */
 
-	setWrapped(prefix, postfix, innerExpressions) {
-		this.type = TypeWrapped;
-		this.prefix = prefix;
-		this.postfix = postfix;
-		this.wrappedInnerExpressions = innerExpressions;
-		this.sideEffects = true;
-		return this;
+/**
+ * @typedef {ModuleLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
+ */
+class ModuleLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {ModuleLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "ModuleLibraryPlugin",
+			type: options.type
+		});
 	}
 
-	setOptions(options) {
-		this.type = TypeConditional;
-		this.options = options;
-		this.sideEffects = true;
-		return this;
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (name) {
+			throw new Error(
+				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
+		}
+		return {
+			name: /** @type {string} */ (name)
+		};
 	}
 
-	addOptions(options) {
-		if (!this.options) {
-			this.type = TypeConditional;
-			this.options = [];
-			this.sideEffects = true;
+	/**
+	 * @param {Source} source source
+	 * @param {Module} module module
+	 * @param {StartupRenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	renderStartup(
+		source,
+		module,
+		{ moduleGraph, chunk },
+		{ options, compilation }
+	) {
+		const result = new ConcatSource(source);
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		const exports = [];
+		const isAsync = moduleGraph.isAsync(module);
+		if (isAsync) {
+			result.add(`__webpack_exports__ = await __webpack_exports__;\n`);
 		}
-		for (const item of options) {
-			this.options.push(item);
+		for (const exportInfo of exportsInfo.orderedExports) {
+			if (!exportInfo.provided) continue;
+			const varName = `__webpack_exports__${Template.toIdentifier(
+				exportInfo.name
+			)}`;
+			result.add(
+				`var ${varName} = __webpack_exports__${propertyAccess([
+					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
+				])};\n`
+			);
+			exports.push(`${varName} as ${exportInfo.name}`);
 		}
-		return this;
-	}
-
-	setItems(items) {
-		this.type = TypeArray;
-		this.items = items;
-		this.sideEffects = items.some(i => i.couldHaveSideEffects());
-		return this;
-	}
-
-	setArray(array) {
-		this.type = TypeConstArray;
-		this.array = array;
-		this.sideEffects = false;
-		return this;
-	}
-
-	setTemplateString(quasis, parts, kind) {
-		this.type = TypeTemplateString;
-		this.quasis = quasis;
-		this.parts = parts;
-		this.templateStringKind = kind;
-		this.sideEffects = parts.some(p => p.sideEffects);
-		return this;
-	}
-
-	setTruthy() {
-		this.falsy = false;
-		this.truthy = true;
-		this.nullish = false;
-		return this;
-	}
-
-	setFalsy() {
-		this.falsy = true;
-		this.truthy = false;
-		return this;
-	}
-
-	setNullish(value) {
-		this.nullish = value;
-
-		if (value) return this.setFalsy();
-
-		return this;
-	}
-
-	setRange(range) {
-		this.range = range;
-		return this;
-	}
-
-	setSideEffects(sideEffects = true) {
-		this.sideEffects = sideEffects;
-		return this;
-	}
-
-	setExpression(expression) {
-		this.expression = expression;
-		return this;
+		if (exports.length > 0) {
+			result.add(`export { ${exports.join(", ")} };\n`);
+		}
+		return result;
 	}
 }
 
-/**
- * @param {string} flags regexp flags
- * @returns {boolean} is valid flags
- */
-BasicEvaluatedExpression.isValidRegExpFlags = flags => {
-	const len = flags.length;
-
-	if (len === 0) return true;
-	if (len > 4) return false;
-
-	// cspell:word gimy
-	let remaining = 0b0000; // bit per RegExp flag: gimy
-
-	for (let i = 0; i < len; i++)
-		switch (flags.charCodeAt(i)) {
-			case 103 /* g */:
-				if (remaining & 0b1000) return false;
-				remaining |= 0b1000;
-				break;
-			case 105 /* i */:
-				if (remaining & 0b0100) return false;
-				remaining |= 0b0100;
-				break;
-			case 109 /* m */:
-				if (remaining & 0b0010) return false;
-				remaining |= 0b0010;
-				break;
-			case 121 /* y */:
-				if (remaining & 0b0001) return false;
-				remaining |= 0b0001;
-				break;
-			default:
-				return false;
-		}
-
-	return true;
-};
-
-module.exports = BasicEvaluatedExpression;
+module.exports = ModuleLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 91145:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 11707:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Joel Denning @joeldenning
 */
 
 
 
-const Entrypoint = __webpack_require__(13795);
+const { ConcatSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const ExternalModule = __webpack_require__(73071);
+const Template = __webpack_require__(1626);
+const propertyAccess = __webpack_require__(54190);
+const AbstractLibraryPlugin = __webpack_require__(26030);
 
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
 /**
- * @param {Entrypoint} entrypoint a chunk group
- * @param {Chunk} excludedChunk1 current chunk which is excluded
- * @param {Chunk} excludedChunk2 runtime chunk which is excluded
- * @returns {Set<Chunk>} chunks
+ * @typedef {Object} SystemLibraryPluginOptions
+ * @property {LibraryType} type
  */
-const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {
-	const queue = new Set([entrypoint]);
-	const chunks = new Set();
-	for (const entrypoint of queue) {
-		for (const chunk of entrypoint.chunks) {
-			if (chunk === excludedChunk1) continue;
-			if (chunk === excludedChunk2) continue;
-			chunks.add(chunk);
-		}
-		for (const parent of entrypoint.parentsIterable) {
-			if (parent instanceof Entrypoint) queue.add(parent);
-		}
+
+/**
+ * @typedef {Object} SystemLibraryPluginParsed
+ * @property {string} name
+ */
+
+/**
+ * @typedef {SystemLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<SystemLibraryPluginParsed>}
+ */
+class SystemLibraryPlugin extends AbstractLibraryPlugin {
+	/**
+	 * @param {SystemLibraryPluginOptions} options the plugin options
+	 */
+	constructor(options) {
+		super({
+			pluginName: "SystemLibraryPlugin",
+			type: options.type
+		});
 	}
-	return chunks;
-};
-exports.getAllChunks = getAllChunks;
 
+	/**
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
+	 */
+	parseOptions(library) {
+		const { name } = library;
+		if (name && typeof name !== "string") {
+			throw new Error(
+				`System.js library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+			);
+		}
+		return {
+			name: /** @type {string=} */ (name)
+		};
+	}
 
-/***/ }),
+	/**
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
+	 */
+	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
+		const modules = chunkGraph
+			.getChunkModules(chunk)
+			.filter(m => m instanceof ExternalModule && m.externalType === "system");
+		const externals = /** @type {ExternalModule[]} */ (modules);
 
-/***/ 84508:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// The name this bundle should be registered as with System
+		const name = options.name
+			? `${JSON.stringify(compilation.getPath(options.name, { chunk }))}, `
+			: "";
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		// The array of dependencies that are external to webpack and will be provided by System
+		const systemDependencies = JSON.stringify(
+			externals.map(m =>
+				typeof m.request === "object" && !Array.isArray(m.request)
+					? m.request.amd
+					: m.request
+			)
+		);
 
+		// The name of the variable provided by System for exporting
+		const dynamicExport = "__WEBPACK_DYNAMIC_EXPORT__";
 
+		// An array of the internal variable names for the webpack externals
+		const externalWebpackNames = externals.map(
+			m =>
+				`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+					`${chunkGraph.getModuleId(m)}`
+				)}__`
+		);
 
-const { ConcatSource, RawSource } = __webpack_require__(51255);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const {
-	getChunkFilenameTemplate,
-	getCompilationHooks
-} = __webpack_require__(89464);
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = __webpack_require__(98124);
+		// Declaring variables for the internal variable names for the webpack externals
+		const externalVarDeclarations = externalWebpackNames
+			.map(name => `var ${name} = {};`)
+			.join("\n");
 
-/** @typedef {import("../Compiler")} Compiler */
+		// Define __esModule flag on all internal variables and helpers
+		const externalVarInitialization = [];
 
-class CommonJsChunkFormatPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"CommonJsChunkFormatPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"CommonJsChunkLoadingPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-							set.add(RuntimeGlobals.require);
-							set.add(RuntimeGlobals.startupEntrypoint);
-							set.add(RuntimeGlobals.externalInstallChunk);
-						}
-					}
-				);
-				const hooks = getCompilationHooks(compilation);
-				hooks.renderChunk.tap(
-					"CommonJsChunkFormatPlugin",
-					(modules, renderContext) => {
-						const { chunk, chunkGraph, runtimeTemplate } = renderContext;
-						const source = new ConcatSource();
-						source.add(`exports.id = ${JSON.stringify(chunk.id)};\n`);
-						source.add(`exports.ids = ${JSON.stringify(chunk.ids)};\n`);
-						source.add(`exports.modules = `);
-						source.add(modules);
-						source.add(";\n");
-						const runtimeModules =
-							chunkGraph.getChunkRuntimeModulesInOrder(chunk);
-						if (runtimeModules.length > 0) {
-							source.add("exports.runtime =\n");
-							source.add(
-								Template.renderChunkRuntimeModules(
-									runtimeModules,
-									renderContext
-								)
-							);
-						}
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						if (entries.length > 0) {
-							const runtimeChunk = entries[0][1].getRuntimeChunk();
-							const currentOutputName = compilation
-								.getPath(
-									getChunkFilenameTemplate(chunk, compilation.outputOptions),
-									{
-										chunk,
-										contentHashType: "javascript"
+		// The system.register format requires an array of setter functions for externals.
+		const setters =
+			externalWebpackNames.length === 0
+				? ""
+				: Template.asString([
+						"setters: [",
+						Template.indent(
+							externals
+								.map((module, i) => {
+									const external = externalWebpackNames[i];
+									const exportsInfo = moduleGraph.getExportsInfo(module);
+									const otherUnused =
+										exportsInfo.otherExportsInfo.getUsed(chunk.runtime) ===
+										UsageState.Unused;
+									const instructions = [];
+									const handledNames = [];
+									for (const exportInfo of exportsInfo.orderedExports) {
+										const used = exportInfo.getUsedName(
+											undefined,
+											chunk.runtime
+										);
+										if (used) {
+											if (otherUnused || used !== exportInfo.name) {
+												instructions.push(
+													`${external}${propertyAccess([
+														used
+													])} = module${propertyAccess([exportInfo.name])};`
+												);
+												handledNames.push(exportInfo.name);
+											}
+										} else {
+											handledNames.push(exportInfo.name);
+										}
 									}
-								)
-								.split("/");
-							const runtimeOutputName = compilation
-								.getPath(
-									getChunkFilenameTemplate(
-										runtimeChunk,
-										compilation.outputOptions
-									),
-									{
-										chunk: runtimeChunk,
-										contentHashType: "javascript"
+									if (!otherUnused) {
+										if (
+											!Array.isArray(module.request) ||
+											module.request.length === 1
+										) {
+											externalVarInitialization.push(
+												`Object.defineProperty(${external}, "__esModule", { value: true });`
+											);
+										}
+										if (handledNames.length > 0) {
+											const name = `${external}handledNames`;
+											externalVarInitialization.push(
+												`var ${name} = ${JSON.stringify(handledNames)};`
+											);
+											instructions.push(
+												Template.asString([
+													"Object.keys(module).forEach(function(key) {",
+													Template.indent([
+														`if(${name}.indexOf(key) >= 0)`,
+														Template.indent(`${external}[key] = module[key];`)
+													]),
+													"});"
+												])
+											);
+										} else {
+											instructions.push(
+												Template.asString([
+													"Object.keys(module).forEach(function(key) {",
+													Template.indent([`${external}[key] = module[key];`]),
+													"});"
+												])
+											);
+										}
 									}
-								)
-								.split("/");
-
-							// remove filename, we only need the directory
-							currentOutputName.pop();
-
-							// remove common parts
-							while (
-								currentOutputName.length > 0 &&
-								runtimeOutputName.length > 0 &&
-								currentOutputName[0] === runtimeOutputName[0]
-							) {
-								currentOutputName.shift();
-								runtimeOutputName.shift();
-							}
-
-							// create final path
-							const runtimePath =
-								(currentOutputName.length > 0
-									? "../".repeat(currentOutputName.length)
-									: "./") + runtimeOutputName.join("/");
+									if (instructions.length === 0) return "function() {}";
+									return Template.asString([
+										"function(module) {",
+										Template.indent(instructions),
+										"}"
+									]);
+								})
+								.join(",\n")
+						),
+						"],"
+				  ]);
 
-							const entrySource = new ConcatSource();
-							entrySource.add(
-								`(${
-									runtimeTemplate.supportsArrowFunction()
-										? "() => "
-										: "function() "
-								}{\n`
-							);
-							entrySource.add("var exports = {};\n");
-							entrySource.add(source);
-							entrySource.add(";\n\n// load runtime\n");
-							entrySource.add(
-								`var __webpack_require__ = require(${JSON.stringify(
-									runtimePath
-								)});\n`
-							);
-							entrySource.add(
-								`${RuntimeGlobals.externalInstallChunk}(exports);\n`
-							);
-							const startupSource = new RawSource(
-								generateEntryStartup(
-									chunkGraph,
-									runtimeTemplate,
-									entries,
-									chunk,
-									false
-								)
-							);
-							entrySource.add(
-								hooks.renderStartup.call(
-									startupSource,
-									entries[entries.length - 1][0],
-									{
-										...renderContext,
-										inlined: false
-									}
-								)
-							);
-							entrySource.add("\n})()");
-							return entrySource;
-						}
-						return source;
-					}
-				);
-				hooks.chunkHash.tap(
-					"CommonJsChunkFormatPlugin",
-					(chunk, hash, { chunkGraph }) => {
-						if (chunk.hasRuntime()) return;
-						hash.update("CommonJsChunkFormatPlugin");
-						hash.update("1");
-						const entries = Array.from(
-							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-						);
-						updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-					}
-				);
-			}
+		return new ConcatSource(
+			Template.asString([
+				`System.register(${name}${systemDependencies}, function(${dynamicExport}, __system_context__) {`,
+				Template.indent([
+					externalVarDeclarations,
+					Template.asString(externalVarInitialization),
+					"return {",
+					Template.indent([
+						setters,
+						"execute: function() {",
+						Template.indent(`${dynamicExport}(`)
+					])
+				]),
+				""
+			]),
+			source,
+			Template.asString([
+				"",
+				Template.indent([
+					Template.indent([Template.indent([");"]), "}"]),
+					"};"
+				]),
+				"})"
+			])
 		);
 	}
+
+	/**
+	 * @param {Chunk} chunk the chunk
+	 * @param {Hash} hash hash
+	 * @param {ChunkHashContext} chunkHashContext chunk hash context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {void}
+	 */
+	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+		hash.update("SystemLibraryPlugin");
+		if (options.name) {
+			hash.update(compilation.getPath(options.name, { chunk }));
+		}
+	}
 }
 
-module.exports = CommonJsChunkFormatPlugin;
+module.exports = SystemLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 61291:
+/***/ 54442:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -96585,123 +97191,329 @@ module.exports = CommonJsChunkFormatPlugin;
 
 
 
-/** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
+const { ConcatSource, OriginalSource } = __webpack_require__(51255);
+const ExternalModule = __webpack_require__(73071);
+const Template = __webpack_require__(1626);
+const AbstractLibraryPlugin = __webpack_require__(26030);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdCommentObject} LibraryCustomUmdCommentObject */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdObject} LibraryCustomUmdObject */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
 
-/** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
-const enabledTypes = new WeakMap();
+/**
+ * @param {string[]} accessor the accessor to convert to path
+ * @returns {string} the path
+ */
+const accessorToObjectAccess = accessor => {
+	return accessor.map(a => `[${JSON.stringify(a)}]`).join("");
+};
 
-const getEnabledTypes = compiler => {
-	let set = enabledTypes.get(compiler);
-	if (set === undefined) {
-		set = new Set();
-		enabledTypes.set(compiler, set);
-	}
-	return set;
+/**
+ * @param {string|undefined} base the path prefix
+ * @param {string|string[]} accessor the accessor
+ * @param {string=} joinWith the element separator
+ * @returns {string} the path
+ */
+const accessorAccess = (base, accessor, joinWith = ", ") => {
+	const accessors = Array.isArray(accessor) ? accessor : [accessor];
+	return accessors
+		.map((_, idx) => {
+			const a = base
+				? base + accessorToObjectAccess(accessors.slice(0, idx + 1))
+				: accessors[0] + accessorToObjectAccess(accessors.slice(1, idx + 1));
+			if (idx === accessors.length - 1) return a;
+			if (idx === 0 && base === undefined)
+				return `${a} = typeof ${a} === "object" ? ${a} : {}`;
+			return `${a} = ${a} || {}`;
+		})
+		.join(joinWith);
 };
 
-class EnableChunkLoadingPlugin {
-	/**
-	 * @param {ChunkLoadingType} type library type that should be available
-	 */
-	constructor(type) {
-		this.type = type;
-	}
+/** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
+
+/**
+ * @typedef {Object} UmdLibraryPluginOptions
+ * @property {LibraryType} type
+ * @property {boolean=} optionalAmdExternalAsGlobal
+ */
+
+/**
+ * @typedef {Object} UmdLibraryPluginParsed
+ * @property {string | string[]} name
+ * @property {LibraryCustomUmdObject} names
+ * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
+ * @property {boolean} namedDefine
+ */
 
+/**
+ * @typedef {UmdLibraryPluginParsed} T
+ * @extends {AbstractLibraryPlugin<UmdLibraryPluginParsed>}
+ */
+class UmdLibraryPlugin extends AbstractLibraryPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {ChunkLoadingType} type type of library
-	 * @returns {void}
+	 * @param {UmdLibraryPluginOptions} options the plugin option
 	 */
-	static setEnabled(compiler, type) {
-		getEnabledTypes(compiler).add(type);
+	constructor(options) {
+		super({
+			pluginName: "UmdLibraryPlugin",
+			type: options.type
+		});
+
+		this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal;
 	}
 
 	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {ChunkLoadingType} type type of library
-	 * @returns {void}
+	 * @param {LibraryOptions} library normalized library option
+	 * @returns {T | false} preprocess as needed by overriding
 	 */
-	static checkEnabled(compiler, type) {
-		if (!getEnabledTypes(compiler).has(type)) {
-			throw new Error(
-				`Chunk loading type "${type}" is not enabled. ` +
-					"EnableChunkLoadingPlugin need to be used to enable this type of chunk loading. " +
-					'This usually happens through the "output.enabledChunkLoadingTypes" option. ' +
-					'If you are using a function as entry which sets "chunkLoading", you need to add all potential chunk loading types to "output.enabledChunkLoadingTypes". ' +
-					"These types are enabled: " +
-					Array.from(getEnabledTypes(compiler)).join(", ")
-			);
+	parseOptions(library) {
+		/** @type {LibraryName} */
+		let name;
+		/** @type {LibraryCustomUmdObject} */
+		let names;
+		if (typeof library.name === "object" && !Array.isArray(library.name)) {
+			name = library.name.root || library.name.amd || library.name.commonjs;
+			names = library.name;
+		} else {
+			name = library.name;
+			const singleName = Array.isArray(name) ? name[0] : name;
+			names = {
+				commonjs: singleName,
+				root: library.name,
+				amd: singleName
+			};
 		}
+		return {
+			name,
+			names,
+			auxiliaryComment: library.auxiliaryComment,
+			namedDefine: library.umdNamedDefine
+		};
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {Source} source source
+	 * @param {RenderContext} renderContext render context
+	 * @param {LibraryContext<T>} libraryContext context
+	 * @returns {Source} source with library export
 	 */
-	apply(compiler) {
-		const { type } = this;
-
-		// Only enable once
-		const enabled = getEnabledTypes(compiler);
-		if (enabled.has(type)) return;
-		enabled.add(type);
-
-		if (typeof type === "string") {
-			switch (type) {
-				case "jsonp": {
-					const JsonpChunkLoadingPlugin = __webpack_require__(83121);
-					new JsonpChunkLoadingPlugin().apply(compiler);
-					break;
-				}
-				case "import-scripts": {
-					const ImportScriptsChunkLoadingPlugin = __webpack_require__(54182);
-					new ImportScriptsChunkLoadingPlugin().apply(compiler);
-					break;
-				}
-				case "require": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
-					new CommonJsChunkLoadingPlugin({
-						asyncChunkLoading: false
-					}).apply(compiler);
-					break;
-				}
-				case "async-node": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const CommonJsChunkLoadingPlugin = __webpack_require__(1313);
-					new CommonJsChunkLoadingPlugin({
-						asyncChunkLoading: true
-					}).apply(compiler);
-					break;
-				}
-				case "import": {
-					const ModuleChunkLoadingPlugin = __webpack_require__(89831);
-					new ModuleChunkLoadingPlugin().apply(compiler);
-					break;
+	render(
+		source,
+		{ chunkGraph, runtimeTemplate, chunk, moduleGraph },
+		{ options, compilation }
+	) {
+		const modules = chunkGraph
+			.getChunkModules(chunk)
+			.filter(
+				m =>
+					m instanceof ExternalModule &&
+					(m.externalType === "umd" || m.externalType === "umd2")
+			);
+		let externals = /** @type {ExternalModule[]} */ (modules);
+		/** @type {ExternalModule[]} */
+		const optionalExternals = [];
+		/** @type {ExternalModule[]} */
+		let requiredExternals = [];
+		if (this.optionalAmdExternalAsGlobal) {
+			for (const m of externals) {
+				if (m.isOptional(moduleGraph)) {
+					optionalExternals.push(m);
+				} else {
+					requiredExternals.push(m);
 				}
-				case "universal":
-					// TODO implement universal chunk loading
-					throw new Error("Universal Chunk Loading is not implemented yet");
-				default:
-					throw new Error(`Unsupported chunk loading type ${type}.
-Plugins which provide custom chunk loading types must call EnableChunkLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
 			}
+			externals = requiredExternals.concat(optionalExternals);
 		} else {
-			// TODO support plugin instances here
-			// apply them to the compiler
+			requiredExternals = externals;
+		}
+
+		const replaceKeys = str => {
+			return compilation.getPath(str, {
+				chunk
+			});
+		};
+
+		const externalsDepsArray = modules => {
+			return `[${replaceKeys(
+				modules
+					.map(m =>
+						JSON.stringify(
+							typeof m.request === "object" ? m.request.amd : m.request
+						)
+					)
+					.join(", ")
+			)}]`;
+		};
+
+		const externalsRootArray = modules => {
+			return replaceKeys(
+				modules
+					.map(m => {
+						let request = m.request;
+						if (typeof request === "object") request = request.root;
+						return `root${accessorToObjectAccess([].concat(request))}`;
+					})
+					.join(", ")
+			);
+		};
+
+		const externalsRequireArray = type => {
+			return replaceKeys(
+				externals
+					.map(m => {
+						let expr;
+						let request = m.request;
+						if (typeof request === "object") {
+							request = request[type];
+						}
+						if (request === undefined) {
+							throw new Error(
+								"Missing external configuration for type:" + type
+							);
+						}
+						if (Array.isArray(request)) {
+							expr = `require(${JSON.stringify(
+								request[0]
+							)})${accessorToObjectAccess(request.slice(1))}`;
+						} else {
+							expr = `require(${JSON.stringify(request)})`;
+						}
+						if (m.isOptional(moduleGraph)) {
+							expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
+						}
+						return expr;
+					})
+					.join(", ")
+			);
+		};
+
+		const externalsArguments = modules => {
+			return modules
+				.map(
+					m =>
+						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+							`${chunkGraph.getModuleId(m)}`
+						)}__`
+				)
+				.join(", ");
+		};
+
+		const libraryName = library => {
+			return JSON.stringify(replaceKeys([].concat(library).pop()));
+		};
+
+		let amdFactory;
+		if (optionalExternals.length > 0) {
+			const wrapperArguments = externalsArguments(requiredExternals);
+			const factoryArguments =
+				requiredExternals.length > 0
+					? externalsArguments(requiredExternals) +
+					  ", " +
+					  externalsRootArray(optionalExternals)
+					: externalsRootArray(optionalExternals);
+			amdFactory =
+				`function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` +
+				`			return factory(${factoryArguments});\n` +
+				"		}";
+		} else {
+			amdFactory = "factory";
 		}
+
+		const { auxiliaryComment, namedDefine, names } = options;
+
+		const getAuxiliaryComment = type => {
+			if (auxiliaryComment) {
+				if (typeof auxiliaryComment === "string")
+					return "\t//" + auxiliaryComment + "\n";
+				if (auxiliaryComment[type])
+					return "\t//" + auxiliaryComment[type] + "\n";
+			}
+			return "";
+		};
+
+		return new ConcatSource(
+			new OriginalSource(
+				"(function webpackUniversalModuleDefinition(root, factory) {\n" +
+					getAuxiliaryComment("commonjs2") +
+					"	if(typeof exports === 'object' && typeof module === 'object')\n" +
+					"		module.exports = factory(" +
+					externalsRequireArray("commonjs2") +
+					");\n" +
+					getAuxiliaryComment("amd") +
+					"	else if(typeof define === 'function' && define.amd)\n" +
+					(requiredExternals.length > 0
+						? names.amd && namedDefine === true
+							? "		define(" +
+							  libraryName(names.amd) +
+							  ", " +
+							  externalsDepsArray(requiredExternals) +
+							  ", " +
+							  amdFactory +
+							  ");\n"
+							: "		define(" +
+							  externalsDepsArray(requiredExternals) +
+							  ", " +
+							  amdFactory +
+							  ");\n"
+						: names.amd && namedDefine === true
+						? "		define(" +
+						  libraryName(names.amd) +
+						  ", [], " +
+						  amdFactory +
+						  ");\n"
+						: "		define([], " + amdFactory + ");\n") +
+					(names.root || names.commonjs
+						? getAuxiliaryComment("commonjs") +
+						  "	else if(typeof exports === 'object')\n" +
+						  "		exports[" +
+						  libraryName(names.commonjs || names.root) +
+						  "] = factory(" +
+						  externalsRequireArray("commonjs") +
+						  ");\n" +
+						  getAuxiliaryComment("root") +
+						  "	else\n" +
+						  "		" +
+						  replaceKeys(
+								accessorAccess("root", names.root || names.commonjs)
+						  ) +
+						  " = factory(" +
+						  externalsRootArray(externals) +
+						  ");\n"
+						: "	else {\n" +
+						  (externals.length > 0
+								? "		var a = typeof exports === 'object' ? factory(" +
+								  externalsRequireArray("commonjs") +
+								  ") : factory(" +
+								  externalsRootArray(externals) +
+								  ");\n"
+								: "		var a = factory();\n") +
+						  "		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" +
+						  "	}\n") +
+					`})(${
+						runtimeTemplate.outputOptions.globalObject
+					}, function(${externalsArguments(externals)}) {\nreturn `,
+				"webpack/universalModuleDefinition"
+			),
+			source,
+			";\n})"
+		);
 	}
 }
 
-module.exports = EnableChunkLoadingPlugin;
+module.exports = UmdLibraryPlugin;
 
 
 /***/ }),
 
-/***/ 77106:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 32597:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -96711,1582 +97523,830 @@ module.exports = EnableChunkLoadingPlugin;
 
 
 
-const util = __webpack_require__(73837);
-const { RawSource, ReplaceSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const HarmonyCompatibilityDependency = __webpack_require__(72906);
+const LogType = Object.freeze({
+	error: /** @type {"error"} */ ("error"), // message, c style arguments
+	warn: /** @type {"warn"} */ ("warn"), // message, c style arguments
+	info: /** @type {"info"} */ ("info"), // message, c style arguments
+	log: /** @type {"log"} */ ("log"), // message, c style arguments
+	debug: /** @type {"debug"} */ ("debug"), // message, c style arguments
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+	trace: /** @type {"trace"} */ ("trace"), // no arguments
 
-// TODO: clean up this file
-// replace with newer constructs
+	group: /** @type {"group"} */ ("group"), // [label]
+	groupCollapsed: /** @type {"groupCollapsed"} */ ("groupCollapsed"), // [label]
+	groupEnd: /** @type {"groupEnd"} */ ("groupEnd"), // [label]
 
-const deprecatedGetInitFragments = util.deprecate(
-	(template, dependency, templateContext) =>
-		template.getInitFragments(dependency, templateContext),
-	"DependencyTemplate.getInitFragment is deprecated (use apply(dep, source, { initFragments }) instead)",
-	"DEP_WEBPACK_JAVASCRIPT_GENERATOR_GET_INIT_FRAGMENTS"
-);
+	profile: /** @type {"profile"} */ ("profile"), // [profileName]
+	profileEnd: /** @type {"profileEnd"} */ ("profileEnd"), // [profileName]
 
-const TYPES = new Set(["javascript"]);
+	time: /** @type {"time"} */ ("time"), // name, time as [seconds, nanoseconds]
 
-class JavascriptGenerator extends Generator {
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
+	clear: /** @type {"clear"} */ ("clear"), // no arguments
+	status: /** @type {"status"} */ ("status") // message, arguments
+});
 
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 39;
-		}
-		return originalSource.size();
-	}
+exports.LogType = LogType;
 
-	/**
-	 * @param {NormalModule} module module for which the bailout reason should be determined
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(module, context) {
-		// Only harmony modules are valid for optimization
-		if (
-			!module.buildMeta ||
-			module.buildMeta.exportsType !== "namespace" ||
-			module.presentationalDependencies === undefined ||
-			!module.presentationalDependencies.some(
-				d => d instanceof HarmonyCompatibilityDependency
-			)
-		) {
-			return "Module is not an ECMAScript module";
-		}
+/** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
 
-		// 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.buildInfo && module.buildInfo.moduleConcatenationBailout) {
-			return `Module uses ${module.buildInfo.moduleConcatenationBailout}`;
-		}
-	}
+const LOG_SYMBOL = Symbol("webpack logger raw log method");
+const TIMERS_SYMBOL = Symbol("webpack logger times");
+const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
 
+class WebpackLogger {
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {function(LogTypeEnum, any[]=): void} log log function
+	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
 	 */
-	generate(module, generateContext) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return new RawSource("throw new Error('No source available');");
-		}
-
-		const source = new ReplaceSource(originalSource);
-		const initFragments = [];
-
-		this.sourceModule(module, initFragments, source, generateContext);
+	constructor(log, getChildLogger) {
+		this[LOG_SYMBOL] = log;
+		this.getChildLogger = getChildLogger;
+	}
 
-		return InitFragment.addToSource(source, initFragments, generateContext);
+	error(...args) {
+		this[LOG_SYMBOL](LogType.error, args);
 	}
 
-	/**
-	 * @param {Module} module the module to generate
-	 * @param {InitFragment[]} initFragments mutable list of init fragments
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {GenerateContext} generateContext the generateContext
-	 * @returns {void}
-	 */
-	sourceModule(module, initFragments, source, generateContext) {
-		for (const dependency of module.dependencies) {
-			this.sourceDependency(
-				module,
-				dependency,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
+	warn(...args) {
+		this[LOG_SYMBOL](LogType.warn, args);
+	}
 
-		if (module.presentationalDependencies !== undefined) {
-			for (const dependency of module.presentationalDependencies) {
-				this.sourceDependency(
-					module,
-					dependency,
-					initFragments,
-					source,
-					generateContext
-				);
-			}
-		}
+	info(...args) {
+		this[LOG_SYMBOL](LogType.info, args);
+	}
 
-		for (const childBlock of module.blocks) {
-			this.sourceBlock(
-				module,
-				childBlock,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
+	log(...args) {
+		this[LOG_SYMBOL](LogType.log, args);
 	}
 
-	/**
-	 * @param {Module} module the module to generate
-	 * @param {DependenciesBlock} block the dependencies block which will be processed
-	 * @param {InitFragment[]} initFragments mutable list of init fragments
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {GenerateContext} generateContext the generateContext
-	 * @returns {void}
-	 */
-	sourceBlock(module, block, initFragments, source, generateContext) {
-		for (const dependency of block.dependencies) {
-			this.sourceDependency(
-				module,
-				dependency,
-				initFragments,
-				source,
-				generateContext
-			);
-		}
+	debug(...args) {
+		this[LOG_SYMBOL](LogType.debug, args);
+	}
 
-		for (const childBlock of block.blocks) {
-			this.sourceBlock(
-				module,
-				childBlock,
-				initFragments,
-				source,
-				generateContext
-			);
+	assert(assertion, ...args) {
+		if (!assertion) {
+			this[LOG_SYMBOL](LogType.error, args);
 		}
 	}
 
-	/**
-	 * @param {Module} module the current module
-	 * @param {Dependency} dependency the dependency to generate
-	 * @param {InitFragment[]} initFragments mutable list of init fragments
-	 * @param {ReplaceSource} source the current replace source which can be modified
-	 * @param {GenerateContext} generateContext the render context
-	 * @returns {void}
-	 */
-	sourceDependency(module, dependency, initFragments, source, generateContext) {
-		const constructor = /** @type {new (...args: any[]) => Dependency} */ (
-			dependency.constructor
-		);
-		const template = generateContext.dependencyTemplates.get(constructor);
-		if (!template) {
-			throw new Error(
-				"No template for dependency: " + dependency.constructor.name
-			);
-		}
+	trace() {
+		this[LOG_SYMBOL](LogType.trace, ["Trace"]);
+	}
 
-		const templateContext = {
-			runtimeTemplate: generateContext.runtimeTemplate,
-			dependencyTemplates: generateContext.dependencyTemplates,
-			moduleGraph: generateContext.moduleGraph,
-			chunkGraph: generateContext.chunkGraph,
-			module,
-			runtime: generateContext.runtime,
-			runtimeRequirements: generateContext.runtimeRequirements,
-			concatenationScope: generateContext.concatenationScope,
-			codeGenerationResults: generateContext.codeGenerationResults,
-			initFragments
-		};
+	clear() {
+		this[LOG_SYMBOL](LogType.clear);
+	}
 
-		template.apply(dependency, source, templateContext);
+	status(...args) {
+		this[LOG_SYMBOL](LogType.status, args);
+	}
 
-		// TODO remove in webpack 6
-		if ("getInitFragments" in template) {
-			const fragments = deprecatedGetInitFragments(
-				template,
-				dependency,
-				templateContext
-			);
+	group(...args) {
+		this[LOG_SYMBOL](LogType.group, args);
+	}
 
-			if (fragments) {
-				for (const fragment of fragments) {
-					initFragments.push(fragment);
-				}
-			}
-		}
+	groupCollapsed(...args) {
+		this[LOG_SYMBOL](LogType.groupCollapsed, args);
 	}
-}
 
-module.exports = JavascriptGenerator;
+	groupEnd(...args) {
+		this[LOG_SYMBOL](LogType.groupEnd, args);
+	}
 
+	profile(label) {
+		this[LOG_SYMBOL](LogType.profile, [label]);
+	}
 
-/***/ }),
+	profileEnd(label) {
+		this[LOG_SYMBOL](LogType.profileEnd, [label]);
+	}
 
-/***/ 89464:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	time(label) {
+		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
+		this[TIMERS_SYMBOL].set(label, process.hrtime());
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	timeLog(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+		}
+		const time = process.hrtime(prev);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
 
+	timeEnd(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+		}
+		const time = process.hrtime(prev);
+		this[TIMERS_SYMBOL].delete(label);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
 
+	timeAggregate(label) {
+		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+		if (!prev) {
+			throw new Error(
+				`No such label '${label}' for WebpackLogger.timeAggregate()`
+			);
+		}
+		const time = process.hrtime(prev);
+		this[TIMERS_SYMBOL].delete(label);
+		this[TIMERS_AGGREGATES_SYMBOL] =
+			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
+		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+		if (current !== undefined) {
+			if (time[1] + current[1] > 1e9) {
+				time[0] += current[0] + 1;
+				time[1] = time[1] - 1e9 + current[1];
+			} else {
+				time[0] += current[0];
+				time[1] += current[1];
+			}
+		}
+		this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
+	}
 
-const { SyncWaterfallHook, SyncHook, SyncBailHook } = __webpack_require__(41242);
-const vm = __webpack_require__(26144);
-const {
-	ConcatSource,
-	OriginalSource,
-	PrefixSource,
-	RawSource,
-	CachedSource
-} = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const { tryRunOrWebpackError } = __webpack_require__(11351);
-const HotUpdateChunk = __webpack_require__(9597);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const { last, someInIterable } = __webpack_require__(39104);
-const StringXor = __webpack_require__(40293);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const { intersectRuntime } = __webpack_require__(17156);
-const JavascriptGenerator = __webpack_require__(77106);
-const JavascriptParser = __webpack_require__(29050);
+	timeAggregateEnd(label) {
+		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
+		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+		if (time === undefined) return;
+		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
+		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	}
+}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/Hash")} Hash */
+exports.Logger = WebpackLogger;
 
-/**
- * @param {Chunk} chunk a chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @returns {boolean} true, when a JS file is needed for this chunk
- */
-const chunkHasJs = (chunk, chunkGraph) => {
-	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return true;
 
-	return chunkGraph.getChunkModulesIterableBySourceType(chunk, "javascript")
-		? true
-		: false;
-};
+/***/ }),
 
-const printGeneratedCodeForStack = (module, code) => {
-	const lines = code.split("\n");
-	const n = `${lines.length}`.length;
-	return `\n\nGenerated code for ${module.identifier()}\n${lines
-		.map((line, i, lines) => {
-			const iStr = `${i + 1}`;
-			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
-		})
-		.join("\n")}`;
-};
+/***/ 54963:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { LogType } = __webpack_require__(32597);
+
+/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
+/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
+/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
+
+/** @typedef {function(string): boolean} FilterFunction */
 
 /**
- * @typedef {Object} RenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {boolean} strictMode rendering in strict context
+ * @typedef {Object} LoggerConsole
+ * @property {function(): void} clear
+ * @property {function(): void} trace
+ * @property {(...args: any[]) => void} info
+ * @property {(...args: any[]) => void} log
+ * @property {(...args: any[]) => void} warn
+ * @property {(...args: any[]) => void} error
+ * @property {(...args: any[]) => void=} debug
+ * @property {(...args: any[]) => void=} group
+ * @property {(...args: any[]) => void=} groupCollapsed
+ * @property {(...args: any[]) => void=} groupEnd
+ * @property {(...args: any[]) => void=} status
+ * @property {(...args: any[]) => void=} profile
+ * @property {(...args: any[]) => void=} profileEnd
+ * @property {(...args: any[]) => void=} logTime
  */
 
 /**
- * @typedef {Object} MainRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {string} hash hash to be used for render call
- * @property {boolean} strictMode rendering in strict context
+ * @typedef {Object} LoggerOptions
+ * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
+ * @property {FilterTypes|boolean} debug filter for debug logging
+ * @property {LoggerConsole} console the console to log to
  */
 
 /**
- * @typedef {Object} ChunkRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
- * @property {boolean} strictMode rendering in strict context
+ * @param {FilterItemTypes} item an input item
+ * @returns {FilterFunction} filter function
  */
+const filterToFunction = item => {
+	if (typeof item === "string") {
+		const regExp = new RegExp(
+			`[\\\\/]${item.replace(
+				// eslint-disable-next-line no-useless-escape
+				/[-[\]{}()*+?.\\^$|]/g,
+				"\\$&"
+			)}([\\\\/]|$|!|\\?)`
+		);
+		return ident => regExp.test(ident);
+	}
+	if (item && typeof item === "object" && typeof item.test === "function") {
+		return ident => item.test(ident);
+	}
+	if (typeof item === "function") {
+		return item;
+	}
+	if (typeof item === "boolean") {
+		return () => item;
+	}
+};
 
 /**
- * @typedef {Object} RenderBootstrapContext
- * @property {Chunk} chunk the chunk
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {string} hash hash to be used for render call
+ * @enum {number}
  */
-
-/** @typedef {RenderContext & { inlined: boolean }} StartupRenderContext */
+const LogLevel = {
+	none: 6,
+	false: 6,
+	error: 5,
+	warn: 4,
+	info: 3,
+	log: 2,
+	true: 2,
+	verbose: 1
+};
 
 /**
- * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
- * @property {SyncWaterfallHook<[Source, RenderContext]>} render
- * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
- * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
- * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
- * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
- * @property {SyncBailHook<[RenderContext], string>} strictRuntimeBailout
- * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
+ * @param {LoggerOptions} options options object
+ * @returns {function(string, LogTypeEnum, any[]): void} logging function
  */
+module.exports = ({ level = "info", debug = false, console }) => {
+	const debugFilters =
+		typeof debug === "boolean"
+			? [() => debug]
+			: /** @type {FilterItemTypes[]} */ ([])
+					.concat(debug)
+					.map(filterToFunction);
+	/** @type {number} */
+	const loglevel = LogLevel[`${level}`] || 0;
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
-class JavascriptModulesPlugin {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
+	 * @param {string} name name of the logger
+	 * @param {LogTypeEnum} type type of the log entry
+	 * @param {any[]} args arguments of the log entry
+	 * @returns {void}
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
+	const logger = (name, type, args) => {
+		const labeledArgs = () => {
+			if (Array.isArray(args)) {
+				if (args.length > 0 && typeof args[0] === "string") {
+					return [`[${name}] ${args[0]}`, ...args.slice(1)];
+				} else {
+					return [`[${name}]`, ...args];
+				}
+			} else {
+				return [];
+			}
+		};
+		const debug = debugFilters.some(f => f(name));
+		switch (type) {
+			case LogType.debug:
+				if (!debug) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.debug === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.debug(...labeledArgs());
+				} else {
+					console.log(...labeledArgs());
+				}
+				break;
+			case LogType.log:
+				if (!debug && loglevel > LogLevel.log) return;
+				console.log(...labeledArgs());
+				break;
+			case LogType.info:
+				if (!debug && loglevel > LogLevel.info) return;
+				console.info(...labeledArgs());
+				break;
+			case LogType.warn:
+				if (!debug && loglevel > LogLevel.warn) return;
+				console.warn(...labeledArgs());
+				break;
+			case LogType.error:
+				if (!debug && loglevel > LogLevel.error) return;
+				console.error(...labeledArgs());
+				break;
+			case LogType.trace:
+				if (!debug) return;
+				console.trace();
+				break;
+			case LogType.groupCollapsed:
+				if (!debug && loglevel > LogLevel.log) return;
+				if (!debug && loglevel > LogLevel.verbose) {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					if (typeof console.groupCollapsed === "function") {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						console.groupCollapsed(...labeledArgs());
+					} else {
+						console.log(...labeledArgs());
+					}
+					break;
+				}
+			// falls through
+			case LogType.group:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.group === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.group(...labeledArgs());
+				} else {
+					console.log(...labeledArgs());
+				}
+				break;
+			case LogType.groupEnd:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.groupEnd === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.groupEnd();
+				}
+				break;
+			case LogType.time: {
+				if (!debug && loglevel > LogLevel.log) return;
+				const ms = args[1] * 1000 + args[2] / 1000000;
+				const msg = `[${name}] ${args[0]}: ${ms} ms`;
+				if (typeof console.logTime === "function") {
+					console.logTime(msg);
+				} else {
+					console.log(msg);
+				}
+				break;
+			}
+			case LogType.profile:
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.profile === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.profile(...labeledArgs());
+				}
+				break;
+			case LogType.profileEnd:
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.profileEnd === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.profileEnd(...labeledArgs());
+				}
+				break;
+			case LogType.clear:
+				if (!debug && loglevel > LogLevel.log) return;
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				if (typeof console.clear === "function") {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					console.clear();
+				}
+				break;
+			case LogType.status:
+				if (!debug && loglevel > LogLevel.info) return;
+				if (typeof console.status === "function") {
+					if (args.length === 0) {
+						console.status();
+					} else {
+						console.status(...labeledArgs());
+					}
+				} else {
+					if (args.length !== 0) {
+						console.info(...labeledArgs());
+					}
+				}
+				break;
+			default:
+				throw new Error(`Unexpected LogType ${type}`);
 		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				]),
-				renderModuleContainer: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				]),
-				renderModulePackage: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				]),
-				render: new SyncWaterfallHook(["source", "renderContext"]),
-				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
-				renderStartup: new SyncWaterfallHook([
-					"source",
-					"module",
-					"startupRenderContext"
-				]),
-				renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
-				renderMain: new SyncWaterfallHook(["source", "renderContext"]),
-				renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
-				inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-				embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-				strictRuntimeBailout: new SyncBailHook(["renderContext"]),
-				chunkHash: new SyncHook(["chunk", "hash", "context"]),
-				useSourceMap: new SyncBailHook(["chunk", "renderContext"])
-			};
-			compilationHooksMap.set(compilation, hooks);
+	};
+	return logger;
+};
+
+
+/***/ }),
+
+/***/ 62090:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const arraySum = array => {
+	let sum = 0;
+	for (const item of array) sum += item;
+	return sum;
+};
+
+/**
+ * @param {any[]} args items to be truncated
+ * @param {number} maxLength maximum length of args including spaces between
+ * @returns {string[]} truncated args
+ */
+const truncateArgs = (args, maxLength) => {
+	const lengths = args.map(a => `${a}`.length);
+	const availableLength = maxLength - lengths.length + 1;
+
+	if (availableLength > 0 && args.length === 1) {
+		if (availableLength >= args[0].length) {
+			return args;
+		} else if (availableLength > 3) {
+			return ["..." + args[0].slice(-availableLength + 3)];
+		} else {
+			return [args[0].slice(-availableLength)];
 		}
-		return hooks;
 	}
 
-	constructor(options = {}) {
-		this.options = options;
-		/** @type {WeakMap<Source, TODO>} */
-		this._moduleFactoryCache = new WeakMap();
+	// Check if there is space for at least 4 chars per arg
+	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
+		// remove args
+		if (args.length > 1)
+			return truncateArgs(args.slice(0, args.length - 1), maxLength);
+		return [];
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"JavascriptModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
-				normalModuleFactory.hooks.createParser
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("auto");
-					});
-				normalModuleFactory.hooks.createParser
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("script");
-					});
-				normalModuleFactory.hooks.createParser
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", options => {
-						return new JavascriptParser("module");
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", () => {
-						return new JavascriptGenerator();
-					});
-				compilation.hooks.renderManifest.tap(
-					"JavascriptModulesPlugin",
-					(result, options) => {
-						const {
-							hash,
-							chunk,
-							chunkGraph,
-							moduleGraph,
-							runtimeTemplate,
-							dependencyTemplates,
-							outputOptions,
-							codeGenerationResults
-						} = options;
+	let currentLength = arraySum(lengths);
 
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
+	// Check if all fits into maxLength
+	if (currentLength <= availableLength) return args;
 
-						let render;
-						const filenameTemplate =
-							JavascriptModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								outputOptions
-							);
-						if (hotUpdateChunk) {
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						} else if (chunk.hasRuntime()) {
-							render = () =>
-								this.renderMain(
-									{
-										hash,
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks,
-									compilation
-								);
-						} else {
-							if (!chunkHasJs(chunk, chunkGraph)) {
-								return result;
-							}
+	// Try to remove chars from the longest items until it fits
+	while (currentLength > availableLength) {
+		const maxLength = Math.max(...lengths);
+		const shorterItems = lengths.filter(l => l !== maxLength);
+		const nextToMaxLength =
+			shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
+		const maxReduce = maxLength - nextToMaxLength;
+		let maxItems = lengths.length - shorterItems.length;
+		let overrun = currentLength - availableLength;
+		for (let i = 0; i < lengths.length; i++) {
+			if (lengths[i] === maxLength) {
+				const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
+				lengths[i] -= reduce;
+				currentLength -= reduce;
+				overrun -= reduce;
+				maxItems--;
+			}
+		}
+	}
 
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						}
+	// Return args reduced to length in lengths
+	return args.map((a, i) => {
+		const str = `${a}`;
+		const length = lengths[i];
+		if (str.length === length) {
+			return str;
+		} else if (length > 5) {
+			return "..." + str.slice(-length + 3);
+		} else if (length > 0) {
+			return str.slice(-length);
+		} else {
+			return "";
+		}
+	});
+};
 
-						result.push({
-							render,
-							filenameTemplate,
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "javascript"
-							},
-							info: {
-								javascriptModule: compilation.runtimeTemplate.isModule()
-							},
-							identifier: hotUpdateChunk
-								? `hotupdatechunk${chunk.id}`
-								: `chunk${chunk.id}`,
-							hash: chunk.contentHash.javascript
-						});
+module.exports = truncateArgs;
 
-						return result;
-					}
-				);
-				compilation.hooks.chunkHash.tap(
-					"JavascriptModulesPlugin",
-					(chunk, hash, context) => {
-						hooks.chunkHash.call(chunk, hash, context);
-						if (chunk.hasRuntime()) {
-							this.updateHashWithBootstrap(
-								hash,
-								{
-									hash: "0000",
-									chunk,
-									chunkGraph: context.chunkGraph,
-									moduleGraph: context.moduleGraph,
-									runtimeTemplate: context.runtimeTemplate
-								},
-								hooks
-							);
-						}
-					}
-				);
-				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
-					const {
-						chunkGraph,
-						moduleGraph,
-						runtimeTemplate,
-						outputOptions: {
-							hashSalt,
-							hashDigest,
-							hashDigestLength,
-							hashFunction
-						}
-					} = compilation;
-					const hash = createHash(hashFunction);
-					if (hashSalt) hash.update(hashSalt);
-					if (chunk.hasRuntime()) {
-						this.updateHashWithBootstrap(
-							hash,
-							{
-								hash: "0000",
-								chunk,
-								chunkGraph: compilation.chunkGraph,
-								moduleGraph: compilation.moduleGraph,
-								runtimeTemplate: compilation.runtimeTemplate
-							},
-							hooks
-						);
-					} else {
-						hash.update(`${chunk.id} `);
-						hash.update(chunk.ids ? chunk.ids.join(",") : "");
-					}
-					hooks.chunkHash.call(chunk, hash, {
-						chunkGraph,
-						moduleGraph,
-						runtimeTemplate
-					});
-					const modules = chunkGraph.getChunkModulesIterableBySourceType(
-						chunk,
-						"javascript"
-					);
-					if (modules) {
-						const xor = new StringXor();
-						for (const m of modules) {
-							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
-						}
-						xor.updateHash(hash);
-					}
-					const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(
+
+/***/ }),
+
+/***/ 1313:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const StartupChunkDependenciesPlugin = __webpack_require__(22339);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class CommonJsChunkLoadingPlugin {
+	constructor(options) {
+		options = options || {};
+		this._asyncChunkLoading = options.asyncChunkLoading;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const ChunkLoadingRuntimeModule = this._asyncChunkLoading
+			? __webpack_require__(73369)
+			: __webpack_require__(94172);
+		const chunkLoadingValue = this._asyncChunkLoading
+			? "async-node"
+			: "require";
+		new StartupChunkDependenciesPlugin({
+			chunkLoading: chunkLoadingValue,
+			asyncChunkLoading: this._asyncChunkLoading
+		}).apply(compiler);
+		compiler.hooks.thisCompilation.tap(
+			"CommonJsChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === chunkLoadingValue;
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
 						chunk,
-						"runtime"
+						new ChunkLoadingRuntimeModule(set)
 					);
-					if (runtimeModules) {
-						const xor = new StringXor();
-						for (const m of runtimeModules) {
-							xor.add(chunkGraph.getModuleHash(m, chunk.runtime));
-						}
-						xor.updateHash(hash);
-					}
-					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
-				});
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"JavascriptModulesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (
-							!set.has(RuntimeGlobals.startupNoDefault) &&
-							chunkGraph.hasChunkEntryDependentChunks(chunk)
-						) {
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.require);
-						}
-					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source =
-							options.codeGenerationResult.sources.get("javascript");
-						if (source === undefined) return;
-						const { module, moduleObject } = options;
-						const code = source.source();
+				};
 
-						const fn = vm.runInThisContext(
-							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(
-								moduleObject.exports,
-								moduleObject,
-								moduleObject.exports,
-								context.__webpack_require__
-							);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
-						}
-					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source = options.codeGenerationResult.sources.get("runtime");
-						if (source === undefined) return;
-						let code = source.source();
-						if (typeof code !== "string") code = code.toString();
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.externalInstallChunk)
+					.tap("CommonJsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("CommonJsChunkLoadingPlugin", handler);
 
-						const fn = vm.runInThisContext(
-							`(function(__webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: options.module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(null, context.__webpack_require__);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
-						}
-					}
-				);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.hmrModuleData);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.getUpdateManifestFilename);
+					});
 			}
 		);
 	}
+}
 
-	static getChunkFilenameTemplate(chunk, outputOptions) {
-		if (chunk.filenameTemplate) {
-			return chunk.filenameTemplate;
-		} else if (chunk instanceof HotUpdateChunk) {
-			return outputOptions.hotUpdateChunkFilename;
-		} else if (chunk.canBeInitial()) {
-			return outputOptions.filename;
-		} else {
-			return outputOptions.chunkFilename;
-		}
-	}
+module.exports = CommonJsChunkLoadingPlugin;
+
+
+/***/ }),
+
+/***/ 7553:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const CachedInputFileSystem = __webpack_require__(52788);
+const fs = __webpack_require__(90552);
+const createConsoleLogger = __webpack_require__(54963);
+const NodeWatchFileSystem = __webpack_require__(98810);
+const nodeConsole = __webpack_require__(91786);
+
+/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
+/** @typedef {import("../Compiler")} Compiler */
 
+class NodeEnvironmentPlugin {
 	/**
-	 * @param {Module} module the rendered module
-	 * @param {ChunkRenderContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @param {boolean} factory true: renders as factory method, false: pure module content
-	 * @returns {Source} the newly generated source from rendering
+	 * @param {Object} options options
+	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
 	 */
-	renderModule(module, renderContext, hooks, factory) {
-		const {
-			chunk,
-			chunkGraph,
-			runtimeTemplate,
-			codeGenerationResults,
-			strictMode
-		} = renderContext;
-		try {
-			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
-			const moduleSource = codeGenResult.sources.get("javascript");
-			if (!moduleSource) return null;
-			if (codeGenResult.data !== undefined) {
-				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
-				if (chunkInitFragments) {
-					for (const i of chunkInitFragments)
-						renderContext.chunkInitFragments.push(i);
-				}
-			}
-			const moduleSourcePostContent = tryRunOrWebpackError(
-				() =>
-					hooks.renderModuleContent.call(moduleSource, module, renderContext),
-				"JavascriptModulesPlugin.getCompilationHooks().renderModuleContent"
-			);
-			let moduleSourcePostContainer;
-			if (factory) {
-				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-					module,
-					chunk.runtime
-				);
-				const needModule = runtimeRequirements.has(RuntimeGlobals.module);
-				const needExports = runtimeRequirements.has(RuntimeGlobals.exports);
-				const needRequire =
-					runtimeRequirements.has(RuntimeGlobals.require) ||
-					runtimeRequirements.has(RuntimeGlobals.requireScope);
-				const needThisAsExports = runtimeRequirements.has(
-					RuntimeGlobals.thisAsExports
-				);
-				const needStrict = module.buildInfo.strict && !strictMode;
-				const cacheEntry = this._moduleFactoryCache.get(
-					moduleSourcePostContent
-				);
-				let source;
-				if (
-					cacheEntry &&
-					cacheEntry.needModule === needModule &&
-					cacheEntry.needExports === needExports &&
-					cacheEntry.needRequire === needRequire &&
-					cacheEntry.needThisAsExports === needThisAsExports &&
-					cacheEntry.needStrict === needStrict
-				) {
-					source = cacheEntry.source;
-				} else {
-					const factorySource = new ConcatSource();
-					const args = [];
-					if (needExports || needRequire || needModule)
-						args.push(
-							needModule
-								? module.moduleArgument
-								: "__unused_webpack_" + module.moduleArgument
-						);
-					if (needExports || needRequire)
-						args.push(
-							needExports
-								? module.exportsArgument
-								: "__unused_webpack_" + module.exportsArgument
-						);
-					if (needRequire) args.push("__webpack_require__");
-					if (!needThisAsExports && runtimeTemplate.supportsArrowFunction()) {
-						factorySource.add("/***/ ((" + args.join(", ") + ") => {\n\n");
-					} else {
-						factorySource.add("/***/ (function(" + args.join(", ") + ") {\n\n");
-					}
-					if (needStrict) {
-						factorySource.add('"use strict";\n');
-					}
-					factorySource.add(moduleSourcePostContent);
-					factorySource.add("\n\n/***/ })");
-					source = new CachedSource(factorySource);
-					this._moduleFactoryCache.set(moduleSourcePostContent, {
-						source,
-						needModule,
-						needExports,
-						needRequire,
-						needThisAsExports,
-						needStrict
-					});
-				}
-				moduleSourcePostContainer = tryRunOrWebpackError(
-					() => hooks.renderModuleContainer.call(source, module, renderContext),
-					"JavascriptModulesPlugin.getCompilationHooks().renderModuleContainer"
-				);
-			} else {
-				moduleSourcePostContainer = moduleSourcePostContent;
-			}
-			return tryRunOrWebpackError(
-				() =>
-					hooks.renderModulePackage.call(
-						moduleSourcePostContainer,
-						module,
-						renderContext
-					),
-				"JavascriptModulesPlugin.getCompilationHooks().renderModulePackage"
-			);
-		} catch (e) {
-			e.module = module;
-			throw e;
-		}
+	constructor(options) {
+		this.options = options;
 	}
 
 	/**
-	 * @param {RenderContext} renderContext the render context
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {Source} the rendered source
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	renderChunk(renderContext, hooks) {
-		const { chunk, chunkGraph } = renderContext;
-		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
-			chunk,
-			"javascript",
-			compareModulesByIdentifier
-		);
-		const allModules = modules ? Array.from(modules) : [];
-		let strictHeader;
-		let allStrict = renderContext.strictMode;
-		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
-			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
-			strictHeader = strictBailout
-				? `// runtime can't be in strict mode because ${strictBailout}.\n`
-				: '"use strict";\n';
-			if (!strictBailout) allStrict = true;
-		}
-		/** @type {ChunkRenderContext} */
-		const chunkRenderContext = {
-			...renderContext,
-			chunkInitFragments: [],
-			strictMode: allStrict
-		};
-		const moduleSources =
-			Template.renderChunkModules(chunkRenderContext, allModules, module =>
-				this.renderModule(module, chunkRenderContext, hooks, true)
-			) || new RawSource("{}");
-		let source = tryRunOrWebpackError(
-			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderChunk"
-		);
-		source = tryRunOrWebpackError(
-			() => hooks.renderContent.call(source, chunkRenderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
-		);
-		if (!source) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
-			);
-		}
-		source = InitFragment.addToSource(
-			source,
-			chunkRenderContext.chunkInitFragments,
-			chunkRenderContext
-		);
-		source = tryRunOrWebpackError(
-			() => hooks.render.call(source, chunkRenderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().render"
+	apply(compiler) {
+		const { infrastructureLogging } = this.options;
+		compiler.infrastructureLogger = createConsoleLogger({
+			level: infrastructureLogging.level || "info",
+			debug: infrastructureLogging.debug || false,
+			console:
+				infrastructureLogging.console ||
+				nodeConsole({
+					colors: infrastructureLogging.colors,
+					appendOnly: infrastructureLogging.appendOnly,
+					stream: infrastructureLogging.stream
+				})
+		});
+		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
+		const inputFileSystem = compiler.inputFileSystem;
+		compiler.outputFileSystem = fs;
+		compiler.intermediateFileSystem = fs;
+		compiler.watchFileSystem = new NodeWatchFileSystem(
+			compiler.inputFileSystem
 		);
-		if (!source) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
-			);
-		}
-		chunk.rendered = true;
-		return strictHeader
-			? new ConcatSource(strictHeader, source, ";")
-			: renderContext.runtimeTemplate.isModule()
-			? source
-			: new ConcatSource(source, ";");
+		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
+			if (compiler.inputFileSystem === inputFileSystem) {
+				compiler.fsStartTime = Date.now();
+				inputFileSystem.purge();
+			}
+		});
 	}
+}
+
+module.exports = NodeEnvironmentPlugin;
+
+
+/***/ }),
+
+/***/ 7103:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Compiler")} Compiler */
 
+class NodeSourcePlugin {
 	/**
-	 * @param {MainRenderContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @param {Compilation} compilation the compilation
-	 * @returns {Source} the newly generated source from rendering
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	renderMain(renderContext, hooks, compilation) {
-		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
+	apply(compiler) {}
+}
 
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
-		const iife = runtimeTemplate.isIIFE();
+module.exports = NodeSourcePlugin;
 
-		const bootstrap = this.renderBootstrap(renderContext, hooks);
-		const useSourceMap = hooks.useSourceMap.call(chunk, renderContext);
 
-		const allModules = Array.from(
-			chunkGraph.getOrderedChunkModulesIterableBySourceType(
-				chunk,
-				"javascript",
-				compareModulesByIdentifier
-			) || []
-		);
+/***/ }),
 
-		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
-		let inlinedModules;
-		if (bootstrap.allowInlineStartup && hasEntryModules) {
-			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
-		}
+/***/ 17916:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		let source = new ConcatSource();
-		let prefix;
-		if (iife) {
-			if (runtimeTemplate.supportsArrowFunction()) {
-				source.add("/******/ (() => { // webpackBootstrap\n");
-			} else {
-				source.add("/******/ (function() { // webpackBootstrap\n");
-			}
-			prefix = "/******/ \t";
-		} else {
-			prefix = "/******/ ";
-		}
-		let allStrict = renderContext.strictMode;
-		if (!allStrict && allModules.every(m => m.buildInfo.strict)) {
-			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
-			if (strictBailout) {
-				source.add(
-					prefix +
-						`// runtime can't be in strict mode because ${strictBailout}.\n`
-				);
-			} else {
-				allStrict = true;
-				source.add(prefix + '"use strict";\n');
-			}
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		/** @type {ChunkRenderContext} */
-		const chunkRenderContext = {
-			...renderContext,
-			chunkInitFragments: [],
-			strictMode: allStrict
-		};
 
-		const chunkModules = Template.renderChunkModules(
-			chunkRenderContext,
-			inlinedModules
-				? allModules.filter(m => !inlinedModules.has(m))
-				: allModules,
-			module => this.renderModule(module, chunkRenderContext, hooks, true),
-			prefix
-		);
-		if (
-			chunkModules ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
-			runtimeRequirements.has(RuntimeGlobals.require)
-		) {
-			source.add(prefix + "var __webpack_modules__ = (");
-			source.add(chunkModules || "{}");
-			source.add(");\n");
-			source.add(
-				"/************************************************************************/\n"
-			);
-		}
 
-		if (bootstrap.header.length > 0) {
-			const header = Template.asString(bootstrap.header) + "\n";
-			source.add(
-				new PrefixSource(
-					prefix,
-					useSourceMap
-						? new OriginalSource(header, "webpack/bootstrap")
-						: new RawSource(header)
-				)
-			);
-			source.add(
-				"/************************************************************************/\n"
-			);
-		}
+const ExternalsPlugin = __webpack_require__(6652);
 
-		const runtimeModules =
-			renderContext.chunkGraph.getChunkRuntimeModulesInOrder(chunk);
+/** @typedef {import("../Compiler")} Compiler */
 
-		if (runtimeModules.length > 0) {
-			source.add(
-				new PrefixSource(
-					prefix,
-					Template.renderRuntimeModules(runtimeModules, chunkRenderContext)
-				)
-			);
-			source.add(
-				"/************************************************************************/\n"
-			);
-			// runtimeRuntimeModules calls codeGeneration
-			for (const module of runtimeModules) {
-				compilation.codeGeneratedModules.add(module);
-			}
-		}
-		if (inlinedModules) {
-			if (bootstrap.beforeStartup.length > 0) {
-				const beforeStartup = Template.asString(bootstrap.beforeStartup) + "\n";
-				source.add(
-					new PrefixSource(
-						prefix,
-						useSourceMap
-							? new OriginalSource(beforeStartup, "webpack/before-startup")
-							: new RawSource(beforeStartup)
-					)
-				);
-			}
-			const lastInlinedModule = last(inlinedModules);
-			const startupSource = new ConcatSource();
-			startupSource.add(`var __webpack_exports__ = {};\n`);
-			for (const m of inlinedModules) {
-				const renderedModule = this.renderModule(
-					m,
-					chunkRenderContext,
-					hooks,
-					false
-				);
-				if (renderedModule) {
-					const innerStrict = !allStrict && m.buildInfo.strict;
-					const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
-						m,
-						chunk.runtime
-					);
-					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
-					const webpackExports =
-						exports && m.exportsArgument === "__webpack_exports__";
-					let iife = innerStrict
-						? "it need to be in strict mode."
-						: inlinedModules.size > 1
-						? // TODO check globals and top-level declarations of other entries and chunk modules
-						  // to make a better decision
-						  "it need to be isolated against other entry modules."
-						: chunkModules
-						? "it need to be isolated against other modules in the chunk."
-						: exports && !webpackExports
-						? `it uses a non-standard name for the exports (${m.exportsArgument}).`
-						: hooks.embedInRuntimeBailout.call(m, renderContext);
-					let footer;
-					if (iife !== undefined) {
-						startupSource.add(
-							`// This entry need to be wrapped in an IIFE because ${iife}\n`
-						);
-						const arrow = runtimeTemplate.supportsArrowFunction();
-						if (arrow) {
-							startupSource.add("(() => {\n");
-							footer = "\n})();\n\n";
-						} else {
-							startupSource.add("!function() {\n");
-							footer = "\n}();\n";
-						}
-						if (innerStrict) startupSource.add('"use strict";\n');
-					} else {
-						footer = "\n";
-					}
-					if (exports) {
-						if (m !== lastInlinedModule)
-							startupSource.add(`var ${m.exportsArgument} = {};\n`);
-						else if (m.exportsArgument !== "__webpack_exports__")
-							startupSource.add(
-								`var ${m.exportsArgument} = __webpack_exports__;\n`
-							);
-					}
-					startupSource.add(renderedModule);
-					startupSource.add(footer);
-				}
-			}
-			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
-				startupSource.add(
-					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
-				);
-			}
-			source.add(
-				hooks.renderStartup.call(startupSource, lastInlinedModule, {
-					...renderContext,
-					inlined: true
-				})
-			);
-			if (bootstrap.afterStartup.length > 0) {
-				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
-				source.add(
-					new PrefixSource(
-						prefix,
-						useSourceMap
-							? new OriginalSource(afterStartup, "webpack/after-startup")
-							: new RawSource(afterStartup)
-					)
-				);
-			}
-		} else {
-			const lastEntryModule = last(
-				chunkGraph.getChunkEntryModulesIterable(chunk)
-			);
-			const toSource = useSourceMap
-				? (content, name) =>
-						new OriginalSource(Template.asString(content), name)
-				: content => new RawSource(Template.asString(content));
-			source.add(
-				new PrefixSource(
-					prefix,
-					new ConcatSource(
-						toSource(bootstrap.beforeStartup, "webpack/before-startup"),
-						"\n",
-						hooks.renderStartup.call(
-							toSource(bootstrap.startup.concat(""), "webpack/startup"),
-							lastEntryModule,
-							{
-								...renderContext,
-								inlined: false
-							}
-						),
-						toSource(bootstrap.afterStartup, "webpack/after-startup"),
-						"\n"
-					)
-				)
-			);
-		}
-		if (
-			hasEntryModules &&
-			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
-		) {
-			source.add(`${prefix}return __webpack_exports__;\n`);
-		}
-		if (iife) {
-			source.add("/******/ })()\n");
-		}
+const builtins = [
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"dns/promises",
+	"domain",
+	"events",
+	"fs",
+	"fs/promises",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"path/posix",
+	"path/win32",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"sys",
+	"timers",
+	"timers/promises",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib",
+	/^node:/,
 
-		/** @type {Source} */
-		let finalSource = tryRunOrWebpackError(
-			() => hooks.renderMain.call(source, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderMain"
-		);
-		if (!finalSource) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something"
-			);
-		}
-		finalSource = tryRunOrWebpackError(
-			() => hooks.renderContent.call(finalSource, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
-		);
-		if (!finalSource) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
-			);
-		}
-		finalSource = InitFragment.addToSource(
-			finalSource,
-			chunkRenderContext.chunkInitFragments,
-			chunkRenderContext
-		);
-		finalSource = tryRunOrWebpackError(
-			() => hooks.render.call(finalSource, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().render"
-		);
-		if (!finalSource) {
-			throw new Error(
-				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
-			);
-		}
-		chunk.rendered = true;
-		return iife ? new ConcatSource(finalSource, ";") : finalSource;
-	}
+	// cspell:word pnpapi
+	// Yarn PnP adds pnpapi as "builtin"
+	"pnpapi"
+];
 
+class NodeTargetPlugin {
 	/**
-	 * @param {Hash} hash the hash to be updated
-	 * @param {RenderBootstrapContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	updateHashWithBootstrap(hash, renderContext, hooks) {
-		const bootstrap = this.renderBootstrap(renderContext, hooks);
-		for (const key of Object.keys(bootstrap)) {
-			hash.update(key);
-			if (Array.isArray(bootstrap[key])) {
-				for (const line of bootstrap[key]) {
-					hash.update(line);
-				}
-			} else {
-				hash.update(JSON.stringify(bootstrap[key]));
-			}
-		}
+	apply(compiler) {
+		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
 	}
+}
 
-	/**
-	 * @param {RenderBootstrapContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
-	 */
-	renderBootstrap(renderContext, hooks) {
-		const { chunkGraph, moduleGraph, chunk, runtimeTemplate } = renderContext;
+module.exports = NodeTargetPlugin;
 
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
-		const requireFunction = runtimeRequirements.has(RuntimeGlobals.require);
-		const moduleCache = runtimeRequirements.has(RuntimeGlobals.moduleCache);
-		const moduleFactories = runtimeRequirements.has(
-			RuntimeGlobals.moduleFactories
-		);
-		const moduleUsed = runtimeRequirements.has(RuntimeGlobals.module);
-		const requireScopeUsed = runtimeRequirements.has(
-			RuntimeGlobals.requireScope
-		);
-		const interceptModuleExecution = runtimeRequirements.has(
-			RuntimeGlobals.interceptModuleExecution
-		);
+/***/ }),
 
-		const useRequire =
-			requireFunction || interceptModuleExecution || moduleUsed;
+/***/ 61052:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const result = {
-			header: [],
-			beforeStartup: [],
-			startup: [],
-			afterStartup: [],
-			allowInlineStartup: true
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		let { header: buf, startup, beforeStartup, afterStartup } = result;
 
-		if (result.allowInlineStartup && moduleFactories) {
-			startup.push(
-				"// module factories are used so entry inlining is disabled"
-			);
-			result.allowInlineStartup = false;
-		}
-		if (result.allowInlineStartup && moduleCache) {
-			startup.push("// module cache are used so entry inlining is disabled");
-			result.allowInlineStartup = false;
-		}
-		if (result.allowInlineStartup && interceptModuleExecution) {
-			startup.push(
-				"// module execution is intercepted so entry inlining is disabled"
-			);
-			result.allowInlineStartup = false;
-		}
-
-		if (useRequire || moduleCache) {
-			buf.push("// The module cache");
-			buf.push("var __webpack_module_cache__ = {};");
-			buf.push("");
-		}
-
-		if (useRequire) {
-			buf.push("// The require function");
-			buf.push(`function __webpack_require__(moduleId) {`);
-			buf.push(Template.indent(this.renderRequire(renderContext, hooks)));
-			buf.push("}");
-			buf.push("");
-		} else if (runtimeRequirements.has(RuntimeGlobals.requireScope)) {
-			buf.push("// The require scope");
-			buf.push("var __webpack_require__ = {};");
-			buf.push("");
-		}
-
-		if (
-			moduleFactories ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)
-		) {
-			buf.push("// expose the modules object (__webpack_modules__)");
-			buf.push(`${RuntimeGlobals.moduleFactories} = __webpack_modules__;`);
-			buf.push("");
-		}
 
-		if (moduleCache) {
-			buf.push("// expose the module cache");
-			buf.push(`${RuntimeGlobals.moduleCache} = __webpack_module_cache__;`);
-			buf.push("");
-		}
+const CommonJsChunkFormatPlugin = __webpack_require__(84508);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
 
-		if (interceptModuleExecution) {
-			buf.push("// expose the module execution interceptor");
-			buf.push(`${RuntimeGlobals.interceptModuleExecution} = [];`);
-			buf.push("");
-		}
+/** @typedef {import("../Compiler")} Compiler */
 
-		if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
-			if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
-				/** @type {string[]} */
-				const buf2 = [];
-				const runtimeRequirements =
-					chunkGraph.getTreeRuntimeRequirements(chunk);
-				buf2.push("// Load entry module and return exports");
-				let i = chunkGraph.getNumberOfEntryModules(chunk);
-				for (const [
-					entryModule,
-					entrypoint
-				] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-					const chunks = entrypoint.chunks.filter(c => c !== chunk);
-					if (result.allowInlineStartup && chunks.length > 0) {
-						buf2.push(
-							"// This entry module depends on other loaded chunks and execution need to be delayed"
-						);
-						result.allowInlineStartup = false;
-					}
-					if (
-						result.allowInlineStartup &&
-						someInIterable(
-							moduleGraph.getIncomingConnectionsByOriginModule(entryModule),
-							([originModule, connections]) =>
-								originModule &&
-								connections.some(c => c.isTargetActive(chunk.runtime)) &&
-								someInIterable(
-									chunkGraph.getModuleRuntimes(originModule),
-									runtime =>
-										intersectRuntime(runtime, chunk.runtime) !== undefined
-								)
-						)
-					) {
-						buf2.push(
-							"// This entry module is referenced by other modules so it can't be inlined"
-						);
-						result.allowInlineStartup = false;
-					}
-					if (
-						result.allowInlineStartup &&
-						(!entryModule.buildInfo ||
-							!entryModule.buildInfo.topLevelDeclarations)
-					) {
-						buf2.push(
-							"// This entry module doesn't tell about it's top-level declarations so it can't be inlined"
-						);
-						result.allowInlineStartup = false;
-					}
-					if (result.allowInlineStartup) {
-						const bailout = hooks.inlineInRuntimeBailout.call(
-							entryModule,
-							renderContext
-						);
-						if (bailout !== undefined) {
-							buf2.push(
-								`// This entry module can't be inlined because ${bailout}`
-							);
-							result.allowInlineStartup = false;
-						}
-					}
-					i--;
-					const moduleId = chunkGraph.getModuleId(entryModule);
-					const entryRuntimeRequirements =
-						chunkGraph.getModuleRuntimeRequirements(entryModule, chunk.runtime);
-					let moduleIdExpr = JSON.stringify(moduleId);
-					if (runtimeRequirements.has(RuntimeGlobals.entryModuleId)) {
-						moduleIdExpr = `${RuntimeGlobals.entryModuleId} = ${moduleIdExpr}`;
-					}
-					if (
-						result.allowInlineStartup &&
-						entryRuntimeRequirements.has(RuntimeGlobals.module)
-					) {
-						result.allowInlineStartup = false;
-						buf2.push(
-							"// This entry module used 'module' so it can't be inlined"
-						);
-					}
-					if (chunks.length > 0) {
-						buf2.push(
-							`${i === 0 ? "var __webpack_exports__ = " : ""}${
-								RuntimeGlobals.onChunksLoaded
-							}(undefined, ${JSON.stringify(
-								chunks.map(c => c.id)
-							)}, ${runtimeTemplate.returningFunction(
-								`__webpack_require__(${moduleIdExpr})`
-							)})`
-						);
-					} else if (useRequire) {
-						buf2.push(
-							`${
-								i === 0 ? "var __webpack_exports__ = " : ""
-							}__webpack_require__(${moduleIdExpr});`
-						);
-					} else {
-						if (i === 0) buf2.push("var __webpack_exports__ = {};");
-						if (requireScopeUsed) {
-							buf2.push(
-								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
-								}, __webpack_require__);`
-							);
-						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
-							buf2.push(
-								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
-								});`
-							);
-						} else {
-							buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
-						}
-					}
-				}
-				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
-					buf2.push(
-						`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);`
-					);
-				}
-				if (
-					runtimeRequirements.has(RuntimeGlobals.startup) ||
-					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
-						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))
-				) {
-					result.allowInlineStartup = false;
-					buf.push("// the startup function");
-					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
-							...buf2,
-							"return __webpack_exports__;"
-						])};`
-					);
-					buf.push("");
-					startup.push("// run startup");
-					startup.push(
-						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
-					);
-				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
-					buf.push("// the startup function");
-					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
-					);
-					beforeStartup.push("// run runtime startup");
-					beforeStartup.push(`${RuntimeGlobals.startup}();`);
-					startup.push("// startup");
-					startup.push(Template.asString(buf2));
-				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
-					buf.push("// the startup function");
-					buf.push(
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
-					);
-					startup.push("// startup");
-					startup.push(Template.asString(buf2));
-					afterStartup.push("// run runtime startup");
-					afterStartup.push(`${RuntimeGlobals.startup}();`);
-				} else {
-					startup.push("// startup");
-					startup.push(Template.asString(buf2));
-				}
-			} else if (
-				runtimeRequirements.has(RuntimeGlobals.startup) ||
-				runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
-				runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
-			) {
-				buf.push(
-					"// the startup function",
-					"// It's empty as no entry modules are in this chunk",
-					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`,
-					""
-				);
-			}
-		} else if (
-			runtimeRequirements.has(RuntimeGlobals.startup) ||
-			runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
-			runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
-		) {
-			result.allowInlineStartup = false;
-			buf.push(
-				"// the startup function",
-				"// It's empty as some runtime module handles the default behavior",
-				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
-			);
-			startup.push("// run startup");
-			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
-		}
-		return result;
+class NodeTemplatePlugin {
+	constructor(options) {
+		this._options = options || {};
 	}
 
 	/**
-	 * @param {RenderBootstrapContext} renderContext options object
-	 * @param {CompilationHooks} hooks hooks
-	 * @returns {string} the generated source of the require function
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	renderRequire(renderContext, hooks) {
-		const {
-			chunk,
-			chunkGraph,
-			runtimeTemplate: { outputOptions }
-		} = renderContext;
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
-		const moduleExecution = runtimeRequirements.has(
-			RuntimeGlobals.interceptModuleExecution
-		)
-			? Template.asString([
-					"var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };",
-					`${RuntimeGlobals.interceptModuleExecution}.forEach(function(handler) { handler(execOptions); });`,
-					"module = execOptions.module;",
-					"execOptions.factory.call(module.exports, module, module.exports, execOptions.require);"
-			  ])
-			: runtimeRequirements.has(RuntimeGlobals.thisAsExports)
-			? Template.asString([
-					"__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);"
-			  ])
-			: Template.asString([
-					"__webpack_modules__[moduleId](module, module.exports, __webpack_require__);"
-			  ]);
-		const needModuleId = runtimeRequirements.has(RuntimeGlobals.moduleId);
-		const needModuleLoaded = runtimeRequirements.has(
-			RuntimeGlobals.moduleLoaded
-		);
-		const content = Template.asString([
-			"// Check if module is in cache",
-			"var cachedModule = __webpack_module_cache__[moduleId];",
-			"if (cachedModule !== undefined) {",
-			outputOptions.strictModuleErrorHandling
-				? Template.indent([
-						"if (cachedModule.error !== undefined) throw cachedModule.error;",
-						"return cachedModule.exports;"
-				  ])
-				: Template.indent("return cachedModule.exports;"),
-			"}",
-			"// Create a new module (and put it into the cache)",
-			"var module = __webpack_module_cache__[moduleId] = {",
-			Template.indent([
-				needModuleId ? "id: moduleId," : "// no module.id needed",
-				needModuleLoaded ? "loaded: false," : "// no module.loaded needed",
-				"exports: {}"
-			]),
-			"};",
-			"",
-			outputOptions.strictModuleExceptionHandling
-				? Template.asString([
-						"// Execute the module function",
-						"var threw = true;",
-						"try {",
-						Template.indent([moduleExecution, "threw = false;"]),
-						"} finally {",
-						Template.indent([
-							"if(threw) delete __webpack_module_cache__[moduleId];"
-						]),
-						"}"
-				  ])
-				: outputOptions.strictModuleErrorHandling
-				? Template.asString([
-						"// Execute the module function",
-						"try {",
-						Template.indent(moduleExecution),
-						"} catch(e) {",
-						Template.indent(["module.error = e;", "throw e;"]),
-						"}"
-				  ])
-				: Template.asString([
-						"// Execute the module function",
-						moduleExecution
-				  ]),
-			needModuleLoaded
-				? Template.asString([
-						"",
-						"// Flag the module as loaded",
-						"module.loaded = true;",
-						""
-				  ])
-				: "",
-			"// Return the exports of the module",
-			"return module.exports;"
-		]);
-		return tryRunOrWebpackError(
-			() => hooks.renderRequire.call(content, renderContext),
-			"JavascriptModulesPlugin.getCompilationHooks().renderRequire"
-		);
+	apply(compiler) {
+		const chunkLoading = this._options.asyncChunkLoading
+			? "async-node"
+			: "require";
+		compiler.options.output.chunkLoading = chunkLoading;
+		new CommonJsChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin(chunkLoading).apply(compiler);
 	}
 }
 
-module.exports = JavascriptModulesPlugin;
-module.exports.chunkHasJs = chunkHasJs;
+module.exports = NodeTemplatePlugin;
 
 
 /***/ }),
 
-/***/ 29050:
+/***/ 98810:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -98297,4083 +98357,3398 @@ module.exports.chunkHasJs = chunkHasJs;
 
 
 
-const { Parser: AcornParser } = __webpack_require__(31988);
-const { importAssertions } = __webpack_require__(72617);
-const { SyncBailHook, HookMap } = __webpack_require__(41242);
-const vm = __webpack_require__(26144);
-const Parser = __webpack_require__(11715);
-const StackedMap = __webpack_require__(58845);
-const binarySearchBounds = __webpack_require__(92229);
-const memoize = __webpack_require__(78676);
-const BasicEvaluatedExpression = __webpack_require__(950);
-
-/** @typedef {import("acorn").Options} AcornOptions */
-/** @typedef {import("estree").ArrayExpression} ArrayExpressionNode */
-/** @typedef {import("estree").BinaryExpression} BinaryExpressionNode */
-/** @typedef {import("estree").BlockStatement} BlockStatementNode */
-/** @typedef {import("estree").SequenceExpression} SequenceExpressionNode */
-/** @typedef {import("estree").CallExpression} CallExpressionNode */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
-/** @typedef {import("estree").Comment} CommentNode */
-/** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
-/** @typedef {import("estree").Declaration} DeclarationNode */
-/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
-/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Identifier} IdentifierNode */
-/** @typedef {import("estree").IfStatement} IfStatementNode */
-/** @typedef {import("estree").LabeledStatement} LabeledStatementNode */
-/** @typedef {import("estree").Literal} LiteralNode */
-/** @typedef {import("estree").LogicalExpression} LogicalExpressionNode */
-/** @typedef {import("estree").ChainExpression} ChainExpressionNode */
-/** @typedef {import("estree").MemberExpression} MemberExpressionNode */
-/** @typedef {import("estree").MetaProperty} MetaPropertyNode */
-/** @typedef {import("estree").MethodDefinition} MethodDefinitionNode */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclarationNode */
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
-/** @typedef {import("estree").Node} AnyNode */
-/** @typedef {import("estree").Program} ProgramNode */
-/** @typedef {import("estree").Statement} StatementNode */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
-/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
-/** @typedef {import("estree").Super} SuperNode */
-/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
-/** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
-/** @typedef {import("estree").ThisExpression} ThisExpressionNode */
-/** @typedef {import("estree").UnaryExpression} UnaryExpressionNode */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
-/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[] }} GetInfoResult */
-
-const EMPTY_ARRAY = [];
-const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
-const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
-const ALLOWED_MEMBER_TYPES_ALL = 0b11;
+const util = __webpack_require__(73837);
+const Watchpack = __webpack_require__(36871);
 
-// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
+/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
+/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
+/** @typedef {import("../util/fs").Watcher} Watcher */
 
-const parser = AcornParser.extend(importAssertions);
+class NodeWatchFileSystem {
+	constructor(inputFileSystem) {
+		this.inputFileSystem = inputFileSystem;
+		this.watcherOptions = {
+			aggregateTimeout: 0
+		};
+		this.watcher = new Watchpack(this.watcherOptions);
+	}
 
-class VariableInfo {
 	/**
-	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true} freeName which free name the variable aliases, or true when none
-	 * @param {TagInfo | undefined} tagInfo info about tags
+	 * @param {Iterable<string>} files watched files
+	 * @param {Iterable<string>} directories watched directories
+	 * @param {Iterable<string>} missing watched exitance entries
+	 * @param {number} startTime timestamp of start time
+	 * @param {WatchOptions} options options object
+	 * @param {function(Error=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
+	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
+	 * @returns {Watcher} a watcher
 	 */
-	constructor(declaredScope, freeName, tagInfo) {
-		this.declaredScope = declaredScope;
-		this.freeName = freeName;
-		this.tagInfo = tagInfo;
-	}
-}
-
-/** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
-/** @typedef {LiteralNode | string | null | undefined} ImportSource */
-/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
-
-/**
- * @typedef {Object} TagInfo
- * @property {any} tag
- * @property {any} data
- * @property {TagInfo | undefined} next
- */
-
-/**
- * @typedef {Object} ScopeInfo
- * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
- * @property {boolean | "arrow"} topLevelScope
- * @property {boolean} inShorthand
- * @property {boolean} isStrict
- * @property {boolean} isAsmJs
- * @property {boolean} inTry
- */
+	watch(
+		files,
+		directories,
+		missing,
+		startTime,
+		options,
+		callback,
+		callbackUndelayed
+	) {
+		if (!files || typeof files[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'files'");
+		}
+		if (!directories || typeof directories[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'directories'");
+		}
+		if (!missing || typeof missing[Symbol.iterator] !== "function") {
+			throw new Error("Invalid arguments: 'missing'");
+		}
+		if (typeof callback !== "function") {
+			throw new Error("Invalid arguments: 'callback'");
+		}
+		if (typeof startTime !== "number" && startTime) {
+			throw new Error("Invalid arguments: 'startTime'");
+		}
+		if (typeof options !== "object") {
+			throw new Error("Invalid arguments: 'options'");
+		}
+		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
+			throw new Error("Invalid arguments: 'callbackUndelayed'");
+		}
+		const oldWatcher = this.watcher;
+		this.watcher = new Watchpack(options);
 
-const joinRanges = (startRange, endRange) => {
-	if (!endRange) return startRange;
-	if (!startRange) return endRange;
-	return [startRange[0], endRange[1]];
-};
+		if (callbackUndelayed) {
+			this.watcher.once("change", callbackUndelayed);
+		}
 
-const objectAndMembersToName = (object, membersReversed) => {
-	let name = object;
-	for (let i = membersReversed.length - 1; i >= 0; i--) {
-		name = name + "." + membersReversed[i];
-	}
-	return name;
-};
+		const fetchTimeInfo = () => {
+			const fileTimeInfoEntries = new Map();
+			const contextTimeInfoEntries = new Map();
+			if (this.watcher) {
+				this.watcher.collectTimeInfoEntries(
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				);
+			}
+			return { fileTimeInfoEntries, contextTimeInfoEntries };
+		};
+		this.watcher.once("aggregated", (changes, removals) => {
+			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
+			this.watcher.pause();
 
-const getRootName = expression => {
-	switch (expression.type) {
-		case "Identifier":
-			return expression.name;
-		case "ThisExpression":
-			return "this";
-		case "MetaProperty":
-			return `${expression.meta.name}.${expression.property.name}`;
-		default:
-			return undefined;
-	}
-};
-
-/** @type {AcornOptions} */
-const defaultParserOptions = {
-	ranges: true,
-	locations: true,
-	ecmaVersion: "latest",
-	sourceType: "module",
-	// https://github.com/tc39/proposal-hashbang
-	allowHashBang: true,
-	onComment: null
-};
-
-// regexp to match at least one "magic comment"
-const webpackCommentRegExp = new RegExp(/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/);
-
-const EMPTY_COMMENT_OPTIONS = {
-	options: null,
-	errors: null
-};
+			if (this.inputFileSystem && this.inputFileSystem.purge) {
+				const fs = this.inputFileSystem;
+				for (const item of changes) {
+					fs.purge(item);
+				}
+				for (const item of removals) {
+					fs.purge(item);
+				}
+			}
+			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+			callback(
+				null,
+				fileTimeInfoEntries,
+				contextTimeInfoEntries,
+				changes,
+				removals
+			);
+		});
 
-class JavascriptParser extends Parser {
-	/**
-	 * @param {"module" | "script" | "auto"} sourceType default source type
-	 */
-	constructor(sourceType = "auto") {
-		super();
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[UnaryExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode | MetaPropertyNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateDefinedIdentifier: new HookMap(
-				() => new SyncBailHook(["expression"])
-			),
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
-			evaluateCallExpressionMember: new HookMap(
-				() => new SyncBailHook(["expression", "param"])
-			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
-			isPure: new HookMap(
-				() => new SyncBailHook(["expression", "commentsStartPosition"])
-			),
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
-			preStatement: new SyncBailHook(["statement"]),
+		this.watcher.watch({ files, directories, missing, startTime });
 
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
-			blockPreStatement: new SyncBailHook(["declaration"]),
-			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
-			statement: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
-			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classExtendsExpression: new SyncBailHook([
-				"expression",
-				"classDefinition"
-			]),
-			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classBodyValue: new SyncBailHook([
-				"expression",
-				"element",
-				"classDefinition"
-			]),
-			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
-			label: new HookMap(() => new SyncBailHook(["statement"])),
-			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
-			import: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
-			importSpecifier: new SyncBailHook([
-				"statement",
-				"source",
-				"exportName",
-				"identifierName"
-			]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
-			export: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
-			exportImport: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
-			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
-			exportExpression: new SyncBailHook(["statement", "declaration"]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
-			exportSpecifier: new SyncBailHook([
-				"statement",
-				"identifierName",
-				"exportName",
-				"index"
-			]),
-			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
-			exportImportSpecifier: new SyncBailHook([
-				"statement",
-				"source",
-				"identifierName",
-				"exportName",
-				"index"
-			]),
-			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
-			preDeclarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
-			declarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
-			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
-			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
-			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression], boolean | void>>} */
-			assign: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression, string[]], boolean | void>>} */
-			assignMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
-			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			typeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			importCall: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			topLevelAwait: new SyncBailHook(["expression"]),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			call: new HookMap(() => new SyncBailHook(["expression"])),
-			/** Something like "a.b()" */
-			/** @type {HookMap<SyncBailHook<[CallExpressionNode, string[]], boolean | void>>} */
-			callMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
-			),
-			/** Something like "a.b().c.d" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
-			memberChainOfCallMemberChain: new HookMap(
-				() =>
-					new SyncBailHook([
-						"expression",
-						"calleeMembers",
-						"callExpression",
-						"members"
-					])
+		if (oldWatcher) {
+			oldWatcher.close();
+		}
+		return {
+			close: () => {
+				if (this.watcher) {
+					this.watcher.close();
+					this.watcher = null;
+				}
+			},
+			pause: () => {
+				if (this.watcher) {
+					this.watcher.pause();
+				}
+			},
+			getAggregatedRemovals: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedRemovals;
+					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+						const fs = this.inputFileSystem;
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
 			),
-			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
-			callMemberChainOfCallMemberChain: new HookMap(
-				() =>
-					new SyncBailHook([
-						"expression",
-						"calleeMembers",
-						"innerCallExpression",
-						"members"
-					])
+			getAggregatedChanges: util.deprecate(
+				() => {
+					const items = this.watcher && this.watcher.aggregatedChanges;
+					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+						const fs = this.inputFileSystem;
+						for (const item of items) {
+							fs.purge(item);
+						}
+					}
+					return items;
+				},
+				"Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
 			),
-			/** @type {SyncBailHook<[ChainExpressionNode], boolean | void>} */
-			optionalChaining: new SyncBailHook(["optionalChaining"]),
-			/** @type {HookMap<SyncBailHook<[NewExpressionNode], boolean | void>>} */
-			new: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
-			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
-			expressionMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
+			getFileTimeInfoEntries: util.deprecate(
+				() => {
+					return fetchTimeInfo().fileTimeInfoEntries;
+				},
+				"Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
 			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
-			unhandledExpressionMemberChain: new HookMap(
-				() => new SyncBailHook(["expression", "members"])
+			getContextTimeInfoEntries: util.deprecate(
+				() => {
+					return fetchTimeInfo().contextTimeInfoEntries;
+				},
+				"Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
+				"DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"
 			),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			expressionConditionalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
-			expressionLogicalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
-			program: new SyncBailHook(["ast", "comments"]),
-			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
-			finish: new SyncBailHook(["ast", "comments"])
-		});
-		this.sourceType = sourceType;
-		/** @type {ScopeInfo} */
-		this.scope = undefined;
-		/** @type {ParserState} */
-		this.state = undefined;
-		this.comments = undefined;
-		this.semicolons = undefined;
-		/** @type {(StatementNode|ExpressionNode)[]} */
-		this.statementPath = undefined;
-		this.prevStatement = undefined;
-		this.currentTagData = undefined;
-		this._initializeEvaluating();
-	}
-
-	_initializeEvaluating() {
-		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
-			const expr = /** @type {LiteralNode} */ (_expr);
-
-			switch (typeof expr.value) {
-				case "number":
-					return new BasicEvaluatedExpression()
-						.setNumber(expr.value)
-						.setRange(expr.range);
-				case "bigint":
-					return new BasicEvaluatedExpression()
-						.setBigInt(expr.value)
-						.setRange(expr.range);
-				case "string":
-					return new BasicEvaluatedExpression()
-						.setString(expr.value)
-						.setRange(expr.range);
-				case "boolean":
-					return new BasicEvaluatedExpression()
-						.setBoolean(expr.value)
-						.setRange(expr.range);
-			}
-			if (expr.value === null) {
-				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
-			}
-			if (expr.value instanceof RegExp) {
-				return new BasicEvaluatedExpression()
-					.setRegExp(expr.value)
-					.setRange(expr.range);
-			}
-		});
-		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
-			const expr = /** @type {NewExpressionNode} */ (_expr);
-			const callee = expr.callee;
-			if (
-				callee.type !== "Identifier" ||
-				callee.name !== "RegExp" ||
-				expr.arguments.length > 2 ||
-				this.getVariableInfo("RegExp") !== "RegExp"
-			)
-				return;
-
-			let regExp, flags;
-			const arg1 = expr.arguments[0];
-
-			if (arg1) {
-				if (arg1.type === "SpreadElement") return;
-
-				const evaluatedRegExp = this.evaluateExpression(arg1);
-
-				if (!evaluatedRegExp) return;
-
-				regExp = evaluatedRegExp.asString();
-
-				if (!regExp) return;
-			} else {
-				return new BasicEvaluatedExpression()
-					.setRegExp(new RegExp(""))
-					.setRange(expr.range);
+			getInfo: () => {
+				const removals = this.watcher && this.watcher.aggregatedRemovals;
+				const changes = this.watcher && this.watcher.aggregatedChanges;
+				if (this.inputFileSystem && this.inputFileSystem.purge) {
+					const fs = this.inputFileSystem;
+					if (removals) {
+						for (const item of removals) {
+							fs.purge(item);
+						}
+					}
+					if (changes) {
+						for (const item of changes) {
+							fs.purge(item);
+						}
+					}
+				}
+				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+				return {
+					changes,
+					removals,
+					fileTimeInfoEntries,
+					contextTimeInfoEntries
+				};
 			}
+		};
+	}
+}
 
-			const arg2 = expr.arguments[1];
+module.exports = NodeWatchFileSystem;
 
-			if (arg2) {
-				if (arg2.type === "SpreadElement") return;
 
-				const evaluatedFlags = this.evaluateExpression(arg2);
+/***/ }),
 
-				if (!evaluatedFlags) return;
+/***/ 73369:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				if (!evaluatedFlags.isUndefined()) {
-					flags = evaluatedFlags.asString();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-					if (
-						flags === undefined ||
-						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
-					)
-						return;
-				}
-			}
 
-			return new BasicEvaluatedExpression()
-				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
-				.setRange(expr.range);
-		});
-		this.hooks.evaluate
-			.for("LogicalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {LogicalExpressionNode} */ (_expr);
 
-				const left = this.evaluateExpression(expr.left);
-				if (!left) return;
-				let returnRight = false;
-				/** @type {boolean|undefined} */
-				let allowedRight;
-				if (expr.operator === "&&") {
-					const leftAsBool = left.asBool();
-					if (leftAsBool === false) return left.setRange(expr.range);
-					returnRight = leftAsBool === true;
-					allowedRight = false;
-				} else if (expr.operator === "||") {
-					const leftAsBool = left.asBool();
-					if (leftAsBool === true) return left.setRange(expr.range);
-					returnRight = leftAsBool === false;
-					allowedRight = true;
-				} else if (expr.operator === "??") {
-					const leftAsNullish = left.asNullish();
-					if (leftAsNullish === false) return left.setRange(expr.range);
-					if (leftAsNullish !== true) return;
-					returnRight = true;
-				} else return;
-				const right = this.evaluateExpression(expr.right);
-				if (!right) return;
-				if (returnRight) {
-					if (left.couldHaveSideEffects()) right.setSideEffects();
-					return right.setRange(expr.range);
-				}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const {
+	chunkHasJs,
+	getChunkFilenameTemplate
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
 
-				const asBool = right.asBool();
+class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
+	}
 
-				if (allowedRight === true && asBool === true) {
-					return new BasicEvaluatedExpression()
-						.setRange(expr.range)
-						.setTruthy();
-				} else if (allowedRight === false && asBool === false) {
-					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
-				}
-			});
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, chunk } = this;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this.runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
+		const withOnChunkLoad = this.runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const valueAsExpression = (value, expr, sideEffects) => {
-			switch (typeof value) {
-				case "boolean":
-					return new BasicEvaluatedExpression()
-						.setBoolean(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
-				case "number":
-					return new BasicEvaluatedExpression()
-						.setNumber(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
-				case "bigint":
-					return new BasicEvaluatedExpression()
-						.setBigInt(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
-				case "string":
-					return new BasicEvaluatedExpression()
-						.setString(value)
-						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
 			}
-		};
-
-		this.hooks.evaluate
-			.for("BinaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {BinaryExpressionNode} */ (_expr);
-
-				const handleConstOperation = fn => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left || !left.isCompileTimeValue()) return;
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			false
+		);
 
-					const right = this.evaluateExpression(expr.right);
-					if (!right || !right.isCompileTimeValue()) return;
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
+			: undefined;
 
-					const result = fn(
-						left.asCompileTimeValue(),
-						right.asCompileTimeValue()
-					);
-					return valueAsExpression(
-						result,
-						expr,
-						left.couldHaveSideEffects() || right.couldHaveSideEffects()
-					);
-				};
-
-				const isAlwaysDifferent = (a, b) =>
-					(a === true && b === false) || (a === false && b === true);
-
-				const handleTemplateStringCompare = (left, right, res, eql) => {
-					const getPrefix = parts => {
-						let value = "";
-						for (const p of parts) {
-							const v = p.asString();
-							if (v !== undefined) value += v;
-							else break;
-						}
-						return value;
-					};
-					const getSuffix = parts => {
-						let value = "";
-						for (let i = parts.length - 1; i >= 0; i--) {
-							const v = parts[i].asString();
-							if (v !== undefined) value = v + value;
-							else break;
-						}
-						return value;
-					};
-					const leftPrefix = getPrefix(left.parts);
-					const rightPrefix = getPrefix(right.parts);
-					const leftSuffix = getSuffix(left.parts);
-					const rightSuffix = getSuffix(right.parts);
-					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
-					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
-					if (
-						leftPrefix.slice(0, lenPrefix) !==
-							rightPrefix.slice(0, lenPrefix) ||
-						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
-					) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-				};
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
+							rootOutputDir
+								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
+								: "__filename"
+						});`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "0" means "already loaded", Promise means loading',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.readFileVm = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded",
+			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
+						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
+						"for(var moduleId in moreModules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+							Template.indent([
+								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+							]),
+							"}"
+						]),
+						"}",
+						`if(runtime) runtime(__webpack_require__);`,
+						"for(var i = 0; i < chunkIds.length; i++) {",
+						Template.indent([
+							"if(installedChunks[chunkIds[i]]) {",
+							Template.indent(["installedChunks[chunkIds[i]][0]();"]),
+							"}",
+							"installedChunks[chunkIds[i]] = 0;"
+						]),
+						"}",
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])};`
+				: "// no chunk install function needed",
+			"",
+			withLoading
+				? Template.asString([
+						"// ReadFile + VM.run chunk loading for javascript",
+						`${fn}.readFileVm = function(chunkId, promises) {`,
+						hasJsMatcher !== false
+							? Template.indent([
+									"",
+									"var installedChunkData = installedChunks[chunkId];",
+									'if(installedChunkData !== 0) { // 0 means "already installed".',
+									Template.indent([
+										'// array of [resolve, reject, promise] means "currently loading"',
+										"if(installedChunkData) {",
+										Template.indent(["promises.push(installedChunkData[2]);"]),
+										"} else {",
+										Template.indent([
+											hasJsMatcher === true
+												? "if(true) { // all chunks have JS"
+												: `if(${hasJsMatcher("chunkId")}) {`,
+											Template.indent([
+												"// load the chunk and return promise to it",
+												"var promise = new Promise(function(resolve, reject) {",
+												Template.indent([
+													"installedChunkData = installedChunks[chunkId] = [resolve, reject];",
+													`var filename = require('path').join(__dirname, ${JSON.stringify(
+														rootOutputDir
+													)} + ${
+														RuntimeGlobals.getChunkScriptFilename
+													}(chunkId));`,
+													"require('fs').readFile(filename, 'utf-8', function(err, content) {",
+													Template.indent([
+														"if(err) return reject(err);",
+														"var chunk = {};",
+														"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+															"(chunk, require, require('path').dirname(filename), filename);",
+														"installChunk(chunk);"
+													]),
+													"});"
+												]),
+												"});",
+												"promises.push(installedChunkData[2] = promise);"
+											]),
+											"} else installedChunks[chunkId] = 0;"
+										]),
+										"}"
+									]),
+									"}"
+							  ])
+							: Template.indent(["installedChunks[chunkId] = 0;"]),
+						"};"
+				  ])
+				: "// no chunk loading",
+			"",
+			withExternalInstallChunk
+				? Template.asString([
+						"module.exports = __webpack_require__;",
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							"return new Promise(function(resolve, reject) {",
+							Template.indent([
+								`var filename = require('path').join(__dirname, ${JSON.stringify(
+									rootOutputDir
+								)} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId));`,
+								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
+								Template.indent([
+									"if(err) return reject(err);",
+									"var update = {};",
+									"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
+										"(update, require, require('path').dirname(filename), filename);",
+									"var updatedModules = update.modules;",
+									"var runtime = update.runtime;",
+									"for(var moduleId in updatedModules) {",
+									Template.indent([
+										`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
+										Template.indent([
+											`currentUpdate[moduleId] = updatedModules[moduleId];`,
+											"if(updatedModulesList) updatedModulesList.push(moduleId);"
+										]),
+										"}"
+									]),
+									"}",
+									"if(runtime) currentUpdateRuntime.push(runtime);",
+									"resolve();"
+								]),
+								"});"
+							]),
+							"});"
+						]),
+						"}",
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "readFileVm")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
+						Template.indent([
+							"return new Promise(function(resolve, reject) {",
+							Template.indent([
+								`var filename = require('path').join(__dirname, ${JSON.stringify(
+									rootOutputDir
+								)} + ${RuntimeGlobals.getUpdateManifestFilename}());`,
+								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
+								Template.indent([
+									"if(err) {",
+									Template.indent([
+										'if(err.code === "ENOENT") return resolve();',
+										"return reject(err);"
+									]),
+									"}",
+									"try { resolve(JSON.parse(content)); }",
+									"catch(e) { reject(e); }"
+								]),
+								"});"
+							]),
+							"});"
+						]),
+						"}"
+				  ])
+				: "// no HMR manifest"
+		]);
+	}
+}
 
-				const handleStrictEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
-					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
-					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+module.exports = ReadFileChunkLoadingRuntimeModule;
 
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
 
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									(left.asCompileTimeValue() === right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
+/***/ }),
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
+/***/ 73163:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					const leftPrimitive = left.isPrimitiveType();
-					const rightPrimitive = right.isPrimitiveType();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					if (
-						// Primitive !== Object or
-						// compile-time object types are never equal to something at runtime
-						(leftPrimitive === false &&
-							(leftConst || rightPrimitive === true)) ||
-						(rightPrimitive === false &&
-							(rightConst || leftPrimitive === true)) ||
-						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(left.asBool(), right.asBool()) ||
-						isAlwaysDifferent(left.asNullish(), right.asNullish())
-					) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-				};
 
-				const handleAbstractEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
-					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
-					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
 
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
 
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									// eslint-disable-next-line eqeqeq
-									(left.asCompileTimeValue() == right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
+/** @typedef {import("../Compiler")} Compiler */
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
+class ReadFileCompileAsyncWasmPlugin {
+	constructor({ type = "async-node", import: useImport = false } = {}) {
+		this._type = type;
+		this._import = useImport;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ReadFileCompileAsyncWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === this._type;
 				};
+				const generateLoadBinaryCode = this._import
+					? path =>
+							Template.asString([
+								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
+								Template.indent([
+									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
+									Template.indent([
+										"if (err) return reject(err);",
+										"",
+										"// Fake fetch response",
+										"resolve({",
+										Template.indent(["arrayBuffer() { return buffer; }"]),
+										"});"
+									]),
+									"});"
+								]),
+								"}))"
+							])
+					: path =>
+							Template.asString([
+								"new Promise(function (resolve, reject) {",
+								Template.indent([
+									"try {",
+									Template.indent([
+										"var { readFile } = require('fs');",
+										"var { join } = require('path');",
+										"",
+										`readFile(join(__dirname, ${path}), function(err, buffer){`,
+										Template.indent([
+											"if (err) return reject(err);",
+											"",
+											"// Fake fetch response",
+											"resolve({",
+											Template.indent(["arrayBuffer() { return buffer; }"]),
+											"});"
+										]),
+										"});"
+									]),
+									"} catch (err) { reject(err); }"
+								]),
+								"})"
+							]);
 
-				if (expr.operator === "+") {
-					const left = this.evaluateExpression(expr.left);
-					if (!left) return;
-					const right = this.evaluateExpression(expr.right);
-					if (!right) return;
-					const res = new BasicEvaluatedExpression();
-					if (left.isString()) {
-						if (right.isString()) {
-							res.setString(left.string + right.string);
-						} else if (right.isNumber()) {
-							res.setString(left.string + right.number);
-						} else if (
-							right.isWrapped() &&
-							right.prefix &&
-							right.prefix.isString()
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.instantiateWasm)
+					.tap("ReadFileCompileAsyncWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/async"
+							)
 						) {
-							// "left" + ("prefix" + inner + "postfix")
-							// => ("leftPrefix" + inner + "postfix")
-							res.setWrapped(
-								new BasicEvaluatedExpression()
-									.setString(left.string + right.prefix.string)
-									.setRange(joinRanges(left.range, right.prefix.range)),
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// "left" + ([null] + inner + "postfix")
-							// => ("left" + inner + "postfix")
-							res.setWrapped(
-								left,
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else {
-							// "left" + expr
-							// => ("left" + expr + "")
-							res.setWrapped(left, null, [right]);
-						}
-					} else if (left.isNumber()) {
-						if (right.isString()) {
-							res.setString(left.number + right.string);
-						} else if (right.isNumber()) {
-							res.setNumber(left.number + right.number);
-						} else {
 							return;
 						}
-					} else if (left.isBigInt()) {
-						if (right.isBigInt()) {
-							res.setBigInt(left.bigint + right.bigint);
-						}
-					} else if (left.isWrapped()) {
-						if (left.postfix && left.postfix.isString() && right.isString()) {
-							// ("prefix" + inner + "postfix") + "right"
-							// => ("prefix" + inner + "postfixRight")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.string)
-									.setRange(joinRanges(left.postfix.range, right.range)),
-								left.wrappedInnerExpressions
-							);
-						} else if (
-							left.postfix &&
-							left.postfix.isString() &&
-							right.isNumber()
-						) {
-							// ("prefix" + inner + "postfix") + 123
-							// => ("prefix" + inner + "postfix123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.number)
-									.setRange(joinRanges(left.postfix.range, right.range)),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isString()) {
-							// ("prefix" + inner + [null]) + "right"
-							// => ("prefix" + inner + "right")
-							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
-						} else if (right.isNumber()) {
-							// ("prefix" + inner + [null]) + 123
-							// => ("prefix" + inner + "123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(right.number + "")
-									.setRange(right.range),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
-							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
-							res.setWrapped(
-								left.prefix,
-								right.postfix,
-								left.wrappedInnerExpressions &&
-									right.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions
-										.concat(left.postfix ? [left.postfix] : [])
-										.concat(right.prefix ? [right.prefix] : [])
-										.concat(right.wrappedInnerExpressions)
-							);
-						} else {
-							// ("prefix" + inner + postfix) + expr
-							// => ("prefix" + inner + postfix + expr + [null])
-							res.setWrapped(
-								left.prefix,
-								null,
-								left.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions.concat(
-										left.postfix ? [left.postfix, right] : [right]
-									)
-							);
-						}
-					} else {
-						if (right.isString()) {
-							// left + "right"
-							// => ([null] + left + "right")
-							res.setWrapped(null, right, [left]);
-						} else if (right.isWrapped()) {
-							// left + (prefix + inner + "postfix")
-							// => ([null] + left + prefix + inner + "postfix")
-							res.setWrapped(
-								null,
-								right.postfix,
-								right.wrappedInnerExpressions &&
-									(right.prefix ? [left, right.prefix] : [left]).concat(
-										right.wrappedInnerExpressions
-									)
-							);
-						} else {
-							return;
-						}
-					}
-					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
-						res.setSideEffects();
-					res.setRange(expr.range);
-					return res;
-				} else if (expr.operator === "-") {
-					return handleConstOperation((l, r) => l - r);
-				} else if (expr.operator === "*") {
-					return handleConstOperation((l, r) => l * r);
-				} else if (expr.operator === "/") {
-					return handleConstOperation((l, r) => l / r);
-				} else if (expr.operator === "**") {
-					return handleConstOperation((l, r) => l ** r);
-				} else if (expr.operator === "===") {
-					return handleStrictEqualityComparison(true);
-				} else if (expr.operator === "==") {
-					return handleAbstractEqualityComparison(true);
-				} else if (expr.operator === "!==") {
-					return handleStrictEqualityComparison(false);
-				} else if (expr.operator === "!=") {
-					return handleAbstractEqualityComparison(false);
-				} else if (expr.operator === "&") {
-					return handleConstOperation((l, r) => l & r);
-				} else if (expr.operator === "|") {
-					return handleConstOperation((l, r) => l | r);
-				} else if (expr.operator === "^") {
-					return handleConstOperation((l, r) => l ^ r);
-				} else if (expr.operator === ">>>") {
-					return handleConstOperation((l, r) => l >>> r);
-				} else if (expr.operator === ">>") {
-					return handleConstOperation((l, r) => l >> r);
-				} else if (expr.operator === "<<") {
-					return handleConstOperation((l, r) => l << r);
-				} else if (expr.operator === "<") {
-					return handleConstOperation((l, r) => l < r);
-				} else if (expr.operator === ">") {
-					return handleConstOperation((l, r) => l > r);
-				} else if (expr.operator === "<=") {
-					return handleConstOperation((l, r) => l <= r);
-				} else if (expr.operator === ">=") {
-					return handleConstOperation((l, r) => l >= r);
-				}
-			});
-		this.hooks.evaluate
-			.for("UnaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {UnaryExpressionNode} */ (_expr);
-
-				const handleConstOperation = fn => {
-					const argument = this.evaluateExpression(expr.argument);
-					if (!argument || !argument.isCompileTimeValue()) return;
-					const result = fn(argument.asCompileTimeValue());
-					return valueAsExpression(
-						result,
-						expr,
-						argument.couldHaveSideEffects()
-					);
-				};
-
-				if (expr.operator === "typeof") {
-					switch (expr.argument.type) {
-						case "Identifier": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								expr.argument.name,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MetaProperty": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								getRootName(expr.argument),
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MemberExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "ChainExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument.expression,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "FunctionExpression": {
-							return new BasicEvaluatedExpression()
-								.setString("function")
-								.setRange(expr.range);
-						}
-					}
-					const arg = this.evaluateExpression(expr.argument);
-					if (arg.isUnknown()) return;
-					if (arg.isString()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setRange(expr.range);
-					}
-					if (arg.isWrapped()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setSideEffects()
-							.setRange(expr.range);
-					}
-					if (arg.isUndefined()) {
-						return new BasicEvaluatedExpression()
-							.setString("undefined")
-							.setRange(expr.range);
-					}
-					if (arg.isNumber()) {
-						return new BasicEvaluatedExpression()
-							.setString("number")
-							.setRange(expr.range);
-					}
-					if (arg.isBigInt()) {
-						return new BasicEvaluatedExpression()
-							.setString("bigint")
-							.setRange(expr.range);
-					}
-					if (arg.isBoolean()) {
-						return new BasicEvaluatedExpression()
-							.setString("boolean")
-							.setRange(expr.range);
-					}
-					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
-						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setRange(expr.range);
-					}
-					if (arg.isArray()) {
-						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setSideEffects(arg.couldHaveSideEffects())
-							.setRange(expr.range);
-					}
-				} else if (expr.operator === "!") {
-					const argument = this.evaluateExpression(expr.argument);
-					if (!argument) return;
-					const bool = argument.asBool();
-					if (typeof bool !== "boolean") return;
-					return new BasicEvaluatedExpression()
-						.setBoolean(!bool)
-						.setSideEffects(argument.couldHaveSideEffects())
-						.setRange(expr.range);
-				} else if (expr.operator === "~") {
-					return handleConstOperation(v => ~v);
-				} else if (expr.operator === "+") {
-					return handleConstOperation(v => +v);
-				} else if (expr.operator === "-") {
-					return handleConstOperation(v => -v);
-				}
-			});
-		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
-			return new BasicEvaluatedExpression()
-				.setString("undefined")
-				.setRange(expr.range);
-		});
-		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
-			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
-				return new BasicEvaluatedExpression()
-					.setUndefined()
-					.setRange(expr.range);
-			}
-		});
-		/**
-		 * @param {string} exprType expression type name
-		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
-		 * @returns {void}
-		 */
-		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
-			/** @type {ExpressionNode | undefined} */
-			let cachedExpression = undefined;
-			/** @type {GetInfoResult | undefined} */
-			let cachedInfo = undefined;
-			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
-				const expression = /** @type {MemberExpressionNode} */ (expr);
-
-				const info = getInfo(expr);
-				if (info !== undefined) {
-					return this.callHooksForInfoWithFallback(
-						this.hooks.evaluateIdentifier,
-						info.name,
-						name => {
-							cachedExpression = expression;
-							cachedInfo = info;
-						},
-						name => {
-							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
-							if (hook !== undefined) {
-								return hook.call(expression);
-							}
-						},
-						expression
-					);
-				}
-			});
-			this.hooks.evaluate
-				.for(exprType)
-				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
-					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
-					if (info !== undefined) {
-						return new BasicEvaluatedExpression()
-							.setIdentifier(info.name, info.rootInfo, info.getMembers)
-							.setRange(expr.range);
-					}
-				});
-			this.hooks.finish.tap("JavascriptParser", () => {
-				// Cleanup for GC
-				cachedExpression = cachedInfo = undefined;
-			});
-		};
-		tapEvaluateWithVariableInfo("Identifier", expr => {
-			const info = this.getVariableInfo(
-				/** @type {IdentifierNode} */ (expr).name
-			);
-			if (
-				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
-			) {
-				return { name: info, rootInfo: info, getMembers: () => [] };
-			}
-		});
-		tapEvaluateWithVariableInfo("ThisExpression", expr => {
-			const info = this.getVariableInfo("this");
-			if (
-				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
-			) {
-				return { name: info, rootInfo: info, getMembers: () => [] };
+						set.add(RuntimeGlobals.publicPath);
+						compilation.addRuntimeModule(
+							chunk,
+							new AsyncWasmLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: false
+							})
+						);
+					});
 			}
-		});
-		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
-			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
-
-			return this.callHooksForName(
-				this.hooks.evaluateIdentifier,
-				getRootName(expr),
-				metaProperty
-			);
-		});
-		tapEvaluateWithVariableInfo("MemberExpression", expr =>
-			this.getMemberExpressionInfo(
-				/** @type {MemberExpressionNode} */ (expr),
-				ALLOWED_MEMBER_TYPES_EXPRESSION
-			)
 		);
+	}
+}
 
-		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
-			const expr = /** @type {CallExpressionNode} */ (_expr);
-			if (
-				expr.callee.type !== "MemberExpression" ||
-				expr.callee.property.type !==
-					(expr.callee.computed ? "Literal" : "Identifier")
-			) {
-				return;
-			}
-
-			// type Super also possible here
-			const param = this.evaluateExpression(
-				/** @type {ExpressionNode} */ (expr.callee.object)
-			);
-			if (!param) return;
-			const property =
-				expr.callee.property.type === "Literal"
-					? `${expr.callee.property.value}`
-					: expr.callee.property.name;
-			const hook = this.hooks.evaluateCallExpressionMember.get(property);
-			if (hook !== undefined) {
-				return hook.call(expr, param);
-			}
-		});
-		this.hooks.evaluateCallExpressionMember
-			.for("indexOf")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString()) return;
-				if (expr.arguments.length === 0) return;
-				const [arg1, arg2] = expr.arguments;
-				if (arg1.type === "SpreadElement") return;
-				const arg1Eval = this.evaluateExpression(arg1);
-				if (!arg1Eval.isString()) return;
-				const arg1Value = arg1Eval.string;
+module.exports = ReadFileCompileAsyncWasmPlugin;
 
-				let result;
-				if (arg2) {
-					if (arg2.type === "SpreadElement") return;
-					const arg2Eval = this.evaluateExpression(arg2);
-					if (!arg2Eval.isNumber()) return;
-					result = param.string.indexOf(arg1Value, arg2Eval.number);
-				} else {
-					result = param.string.indexOf(arg1Value);
-				}
-				return new BasicEvaluatedExpression()
-					.setNumber(result)
-					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
-			});
-		this.hooks.evaluateCallExpressionMember
-			.for("replace")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString()) return;
-				if (expr.arguments.length !== 2) return;
-				if (expr.arguments[0].type === "SpreadElement") return;
-				if (expr.arguments[1].type === "SpreadElement") return;
-				let arg1 = this.evaluateExpression(expr.arguments[0]);
-				let arg2 = this.evaluateExpression(expr.arguments[1]);
-				if (!arg1.isString() && !arg1.isRegExp()) return;
-				const arg1Value = arg1.regExp || arg1.string;
-				if (!arg2.isString()) return;
-				const arg2Value = arg2.string;
-				return new BasicEvaluatedExpression()
-					.setString(param.string.replace(arg1Value, arg2Value))
-					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
-			});
-		["substr", "substring", "slice"].forEach(fn => {
-			this.hooks.evaluateCallExpressionMember
-				.for(fn)
-				.tap("JavascriptParser", (expr, param) => {
-					if (!param.isString()) return;
-					let arg1;
-					let result,
-						str = param.string;
-					switch (expr.arguments.length) {
-						case 1:
-							if (expr.arguments[0].type === "SpreadElement") return;
-							arg1 = this.evaluateExpression(expr.arguments[0]);
-							if (!arg1.isNumber()) return;
-							result = str[fn](arg1.number);
-							break;
-						case 2: {
-							if (expr.arguments[0].type === "SpreadElement") return;
-							if (expr.arguments[1].type === "SpreadElement") return;
-							arg1 = this.evaluateExpression(expr.arguments[0]);
-							const arg2 = this.evaluateExpression(expr.arguments[1]);
-							if (!arg1.isNumber()) return;
-							if (!arg2.isNumber()) return;
-							result = str[fn](arg1.number, arg2.number);
-							break;
-						}
-						default:
-							return;
-					}
-					return new BasicEvaluatedExpression()
-						.setString(result)
-						.setSideEffects(param.couldHaveSideEffects())
-						.setRange(expr.range);
-				});
-		});
 
-		/**
-		 * @param {"cooked" | "raw"} kind kind of values to get
-		 * @param {TemplateLiteralNode} templateLiteralExpr TemplateLiteral expr
-		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
-		 */
-		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
-			/** @type {BasicEvaluatedExpression[]} */
-			const quasis = [];
-			/** @type {BasicEvaluatedExpression[]} */
-			const parts = [];
+/***/ }),
 
-			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
-				const quasiExpr = templateLiteralExpr.quasis[i];
-				const quasi = quasiExpr.value[kind];
+/***/ 98939:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				if (i > 0) {
-					const prevExpr = parts[parts.length - 1];
-					const expr = this.evaluateExpression(
-						templateLiteralExpr.expressions[i - 1]
-					);
-					const exprAsString = expr.asString();
-					if (
-						typeof exprAsString === "string" &&
-						!expr.couldHaveSideEffects()
-					) {
-						// We can merge quasi + expr + quasi when expr
-						// is a const string
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						prevExpr.setString(prevExpr.string + exprAsString + quasi);
-						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
-						// We unset the expression as it doesn't match to a single expression
-						prevExpr.setExpression(undefined);
-						continue;
-					}
-					parts.push(expr);
-				}
 
-				const part = new BasicEvaluatedExpression()
-					.setString(quasi)
-					.setRange(quasiExpr.range)
-					.setExpression(quasiExpr);
-				quasis.push(part);
-				parts.push(part);
-			}
-			return {
-				quasis,
-				parts
-			};
-		};
 
-		this.hooks.evaluate
-			.for("TemplateLiteral")
-			.tap("JavascriptParser", _node => {
-				const node = /** @type {TemplateLiteralNode} */ (_node);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
 
-				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
-				if (parts.length === 1) {
-					return parts[0].setRange(node.range);
-				}
-				return new BasicEvaluatedExpression()
-					.setTemplateString(quasis, parts, "cooked")
-					.setRange(node.range);
-			});
-		this.hooks.evaluate
-			.for("TaggedTemplateExpression")
-			.tap("JavascriptParser", _node => {
-				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
-				const tag = this.evaluateExpression(node.tag);
+/** @typedef {import("../Compiler")} Compiler */
 
-				if (tag.isIdentifier() && tag.identifier === "String.raw") {
-					const { quasis, parts } = getSimplifiedTemplateResult(
-						"raw",
-						node.quasi
-					);
-					return new BasicEvaluatedExpression()
-						.setTemplateString(quasis, parts, "raw")
-						.setRange(node.range);
-				}
-			});
+// TODO webpack 6 remove
 
-		this.hooks.evaluateCallExpressionMember
-			.for("concat")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString() && !param.isWrapped()) return;
-
-				let stringSuffix = null;
-				let hasUnknownParams = false;
-				const innerExpressions = [];
-				for (let i = expr.arguments.length - 1; i >= 0; i--) {
-					const arg = expr.arguments[i];
-					if (arg.type === "SpreadElement") return;
-					const argExpr = this.evaluateExpression(arg);
-					if (
-						hasUnknownParams ||
-						(!argExpr.isString() && !argExpr.isNumber())
-					) {
-						hasUnknownParams = true;
-						innerExpressions.push(argExpr);
-						continue;
-					}
-
-					const value = argExpr.isString()
-						? argExpr.string
-						: "" + argExpr.number;
-
-					const newString = value + (stringSuffix ? stringSuffix.string : "");
-					const newRange = [
-						argExpr.range[0],
-						(stringSuffix || argExpr).range[1]
-					];
-					stringSuffix = new BasicEvaluatedExpression()
-						.setString(newString)
-						.setSideEffects(
-							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
-								argExpr.couldHaveSideEffects()
-						)
-						.setRange(newRange);
-				}
-
-				if (hasUnknownParams) {
-					const prefix = param.isString() ? param : param.prefix;
-					const inner =
-						param.isWrapped() && param.wrappedInnerExpressions
-							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
-							: innerExpressions.reverse();
-					return new BasicEvaluatedExpression()
-						.setWrapped(prefix, stringSuffix, inner)
-						.setRange(expr.range);
-				} else if (param.isWrapped()) {
-					const postfix = stringSuffix || param.postfix;
-					const inner = param.wrappedInnerExpressions
-						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
-						: innerExpressions.reverse();
-					return new BasicEvaluatedExpression()
-						.setWrapped(param.prefix, postfix, inner)
-						.setRange(expr.range);
-				} else {
-					const newString =
-						param.string + (stringSuffix ? stringSuffix.string : "");
-					return new BasicEvaluatedExpression()
-						.setString(newString)
-						.setSideEffects(
-							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
-								param.couldHaveSideEffects()
-						)
-						.setRange(expr.range);
-				}
-			});
-		this.hooks.evaluateCallExpressionMember
-			.for("split")
-			.tap("JavascriptParser", (expr, param) => {
-				if (!param.isString()) return;
-				if (expr.arguments.length !== 1) return;
-				if (expr.arguments[0].type === "SpreadElement") return;
-				let result;
-				const arg = this.evaluateExpression(expr.arguments[0]);
-				if (arg.isString()) {
-					result = param.string.split(arg.string);
-				} else if (arg.isRegExp()) {
-					result = param.string.split(arg.regExp);
-				} else {
-					return;
-				}
-				return new BasicEvaluatedExpression()
-					.setArray(result)
-					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
-			});
-		this.hooks.evaluate
-			.for("ConditionalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ConditionalExpressionNode} */ (_expr);
-
-				const condition = this.evaluateExpression(expr.test);
-				const conditionValue = condition.asBool();
-				let res;
-				if (conditionValue === undefined) {
-					const consequent = this.evaluateExpression(expr.consequent);
-					const alternate = this.evaluateExpression(expr.alternate);
-					if (!consequent || !alternate) return;
-					res = new BasicEvaluatedExpression();
-					if (consequent.isConditional()) {
-						res.setOptions(consequent.options);
-					} else {
-						res.setOptions([consequent]);
-					}
-					if (alternate.isConditional()) {
-						res.addOptions(alternate.options);
-					} else {
-						res.addOptions([alternate]);
-					}
-				} else {
-					res = this.evaluateExpression(
-						conditionValue ? expr.consequent : expr.alternate
-					);
-					if (condition.couldHaveSideEffects()) res.setSideEffects();
-				}
-				res.setRange(expr.range);
-				return res;
-			});
-		this.hooks.evaluate
-			.for("ArrayExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ArrayExpressionNode} */ (_expr);
-
-				const items = expr.elements.map(element => {
-					return (
-						element !== null &&
-						element.type !== "SpreadElement" &&
-						this.evaluateExpression(element)
-					);
-				});
-				if (!items.every(Boolean)) return;
-				return new BasicEvaluatedExpression()
-					.setItems(items)
-					.setRange(expr.range);
-			});
-		this.hooks.evaluate
-			.for("ChainExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ChainExpressionNode} */ (_expr);
-				/** @type {ExpressionNode[]} */
-				const optionalExpressionsStack = [];
-				/** @type {ExpressionNode|SuperNode} */
-				let next = expr.expression;
-
-				while (
-					next.type === "MemberExpression" ||
-					next.type === "CallExpression"
-				) {
-					if (next.type === "MemberExpression") {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {ExpressionNode} */ (next.object)
-							);
-						}
-						next = next.object;
-					} else {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {ExpressionNode} */ (next.callee)
-							);
-						}
-						next = next.callee;
-					}
-				}
-
-				while (optionalExpressionsStack.length > 0) {
-					const expression = optionalExpressionsStack.pop();
-					const evaluated = this.evaluateExpression(expression);
-
-					if (evaluated && evaluated.asNullish()) {
-						return evaluated.setRange(_expr.range);
-					}
-				}
-				return this.evaluateExpression(expr.expression);
-			});
-	}
-
-	getRenameIdentifier(expr) {
-		const result = this.evaluateExpression(expr);
-		if (result && result.isIdentifier()) {
-			return result.identifier;
-		}
-	}
+class ReadFileCompileWasmPlugin {
+	constructor(options) {
+		this.options = options || {};
+	}
 
 	/**
-	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	walkClass(classy) {
-		if (classy.superClass) {
-			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
-				this.walkExpression(classy.superClass);
-			}
-		}
-		if (classy.body && classy.body.type === "ClassBody") {
-			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
-				if (!this.hooks.classBodyElement.call(classElement, classy)) {
-					if (classElement.computed && classElement.key) {
-						this.walkExpression(classElement.key);
-					}
-					if (classElement.value) {
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"ReadFileCompileWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === "async-node";
+				};
+				const generateLoadBinaryCode = path =>
+					Template.asString([
+						"new Promise(function (resolve, reject) {",
+						Template.indent([
+							"var { readFile } = require('fs');",
+							"var { join } = require('path');",
+							"",
+							"try {",
+							Template.indent([
+								`readFile(join(__dirname, ${path}), function(err, buffer){`,
+								Template.indent([
+									"if (err) return reject(err);",
+									"",
+									"// Fake fetch response",
+									"resolve({",
+									Template.indent(["arrayBuffer() { return buffer; }"]),
+									"});"
+								]),
+								"});"
+							]),
+							"} catch (err) { reject(err); }"
+						]),
+						"})"
+					]);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ReadFileCompileWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
 						if (
-							!this.hooks.classBodyValue.call(
-								classElement.value,
-								classElement,
-								classy
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/sync"
 							)
 						) {
-							const wasTopLevel = this.scope.topLevelScope;
-							this.scope.topLevelScope = false;
-							this.walkExpression(classElement.value);
-							this.scope.topLevelScope = wasTopLevel;
+							return;
 						}
-					}
-				}
+						set.add(RuntimeGlobals.moduleCache);
+						compilation.addRuntimeModule(
+							chunk,
+							new WasmChunkLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: false,
+								mangleImports: this.options.mangleImports,
+								runtimeRequirements: set
+							})
+						);
+					});
 			}
-		}
+		);
 	}
+}
 
-	// Pre walking iterates the scope for variable declarations
-	preWalkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
-			this.preWalkStatement(statement);
-		}
-	}
+module.exports = ReadFileCompileWasmPlugin;
 
-	// Block pre walking iterates the scope for block variable declarations
-	blockPreWalkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
-			this.blockPreWalkStatement(statement);
-		}
-	}
 
-	// Walking iterates the statements and expressions and processes them
-	walkStatements(statements) {
-		for (let index = 0, len = statements.length; index < len; index++) {
-			const statement = statements[index];
-			this.walkStatement(statement);
-		}
-	}
+/***/ }),
 
-	preWalkStatement(statement) {
-		this.statementPath.push(statement);
-		if (this.hooks.preStatement.call(statement)) {
-			this.prevStatement = this.statementPath.pop();
-			return;
-		}
-		switch (statement.type) {
-			case "BlockStatement":
-				this.preWalkBlockStatement(statement);
-				break;
-			case "DoWhileStatement":
-				this.preWalkDoWhileStatement(statement);
-				break;
-			case "ForInStatement":
-				this.preWalkForInStatement(statement);
-				break;
-			case "ForOfStatement":
-				this.preWalkForOfStatement(statement);
-				break;
-			case "ForStatement":
-				this.preWalkForStatement(statement);
-				break;
-			case "FunctionDeclaration":
-				this.preWalkFunctionDeclaration(statement);
-				break;
-			case "IfStatement":
-				this.preWalkIfStatement(statement);
-				break;
-			case "LabeledStatement":
-				this.preWalkLabeledStatement(statement);
-				break;
-			case "SwitchStatement":
-				this.preWalkSwitchStatement(statement);
-				break;
-			case "TryStatement":
-				this.preWalkTryStatement(statement);
-				break;
-			case "VariableDeclaration":
-				this.preWalkVariableDeclaration(statement);
-				break;
-			case "WhileStatement":
-				this.preWalkWhileStatement(statement);
-				break;
-			case "WithStatement":
-				this.preWalkWithStatement(statement);
-				break;
-		}
-		this.prevStatement = this.statementPath.pop();
-	}
+/***/ 94172:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	blockPreWalkStatement(statement) {
-		this.statementPath.push(statement);
-		if (this.hooks.blockPreStatement.call(statement)) {
-			this.prevStatement = this.statementPath.pop();
-			return;
-		}
-		switch (statement.type) {
-			case "ImportDeclaration":
-				this.blockPreWalkImportDeclaration(statement);
-				break;
-			case "ExportAllDeclaration":
-				this.blockPreWalkExportAllDeclaration(statement);
-				break;
-			case "ExportDefaultDeclaration":
-				this.blockPreWalkExportDefaultDeclaration(statement);
-				break;
-			case "ExportNamedDeclaration":
-				this.blockPreWalkExportNamedDeclaration(statement);
-				break;
-			case "VariableDeclaration":
-				this.blockPreWalkVariableDeclaration(statement);
-				break;
-			case "ClassDeclaration":
-				this.blockPreWalkClassDeclaration(statement);
-				break;
-		}
-		this.prevStatement = this.statementPath.pop();
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-	walkStatement(statement) {
-		this.statementPath.push(statement);
-		if (this.hooks.statement.call(statement) !== undefined) {
-			this.prevStatement = this.statementPath.pop();
-			return;
-		}
-		switch (statement.type) {
-			case "BlockStatement":
-				this.walkBlockStatement(statement);
-				break;
-			case "ClassDeclaration":
-				this.walkClassDeclaration(statement);
-				break;
-			case "DoWhileStatement":
-				this.walkDoWhileStatement(statement);
-				break;
-			case "ExportDefaultDeclaration":
-				this.walkExportDefaultDeclaration(statement);
-				break;
-			case "ExportNamedDeclaration":
-				this.walkExportNamedDeclaration(statement);
-				break;
-			case "ExpressionStatement":
-				this.walkExpressionStatement(statement);
-				break;
-			case "ForInStatement":
-				this.walkForInStatement(statement);
-				break;
-			case "ForOfStatement":
-				this.walkForOfStatement(statement);
-				break;
-			case "ForStatement":
-				this.walkForStatement(statement);
-				break;
-			case "FunctionDeclaration":
-				this.walkFunctionDeclaration(statement);
-				break;
-			case "IfStatement":
-				this.walkIfStatement(statement);
-				break;
-			case "LabeledStatement":
-				this.walkLabeledStatement(statement);
-				break;
-			case "ReturnStatement":
-				this.walkReturnStatement(statement);
-				break;
-			case "SwitchStatement":
-				this.walkSwitchStatement(statement);
-				break;
-			case "ThrowStatement":
-				this.walkThrowStatement(statement);
-				break;
-			case "TryStatement":
-				this.walkTryStatement(statement);
-				break;
-			case "VariableDeclaration":
-				this.walkVariableDeclaration(statement);
-				break;
-			case "WhileStatement":
-				this.walkWhileStatement(statement);
-				break;
-			case "WithStatement":
-				this.walkWithStatement(statement);
-				break;
-		}
-		this.prevStatement = this.statementPath.pop();
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const {
+	chunkHasJs,
+	getChunkFilenameTemplate
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
+
+class RequireChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("require chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * Walks a statements that is nested within a parent statement
-	 * and can potentially be a non-block statement.
-	 * This enforces the nested statement to never be in ASI position.
-	 * @param {StatementNode} statement the nested statement
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	walkNestedStatement(statement) {
-		this.prevStatement = undefined;
-		this.walkStatement(statement);
-	}
-
-	// Real Statements
-	preWalkBlockStatement(statement) {
-		this.preWalkStatements(statement.body);
-	}
+	generate() {
+		const { chunkGraph, chunk } = this;
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this.runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
+		const withOnChunkLoad = this.runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-	walkBlockStatement(statement) {
-		this.inBlockScope(() => {
-			const body = statement.body;
-			const prev = this.prevStatement;
-			this.blockPreWalkStatements(body);
-			this.prevStatement = prev;
-			this.walkStatements(body);
-		});
-	}
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			true
+		);
 
-	walkExpressionStatement(statement) {
-		this.walkExpression(statement.expression);
-	}
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_require`
+			: undefined;
 
-	preWalkIfStatement(statement) {
-		this.preWalkStatement(statement.consequent);
-		if (statement.alternate) {
-			this.preWalkStatement(statement.alternate);
-		}
-	}
-
-	walkIfStatement(statement) {
-		const result = this.hooks.statementIf.call(statement);
-		if (result === undefined) {
-			this.walkExpression(statement.test);
-			this.walkNestedStatement(statement.consequent);
-			if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
-		} else {
-			if (result) {
-				this.walkNestedStatement(statement.consequent);
-			} else if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
-		}
-	}
-
-	preWalkLabeledStatement(statement) {
-		this.preWalkStatement(statement.body);
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
+							rootOutputDir !== "./"
+								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
+								: "__filename"
+						});`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "1" means "loaded", otherwise not loaded yet',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.require = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId]",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded",
+			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
+						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
+						"for(var moduleId in moreModules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+							Template.indent([
+								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+							]),
+							"}"
+						]),
+						"}",
+						`if(runtime) runtime(__webpack_require__);`,
+						"for(var i = 0; i < chunkIds.length; i++)",
+						Template.indent("installedChunks[chunkIds[i]] = 1;"),
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])};`
+				: "// no chunk install function needed",
+			"",
+			withLoading
+				? Template.asString([
+						"// require() chunk loading for javascript",
+						`${fn}.require = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? [
+										'// "1" is the signal for "already loaded"',
+										"if(!installedChunks[chunkId]) {",
+										Template.indent([
+											hasJsMatcher === true
+												? "if(true) { // all chunks have JS"
+												: `if(${hasJsMatcher("chunkId")}) {`,
+											Template.indent([
+												`installChunk(require(${JSON.stringify(
+													rootOutputDir
+												)} + ${
+													RuntimeGlobals.getChunkScriptFilename
+												}(chunkId)));`
+											]),
+											"} else installedChunks[chunkId] = 1;",
+											""
+										]),
+										"}"
+								  ]
+								: "installedChunks[chunkId] = 1;"
+						)};`
+				  ])
+				: "// no chunk loading",
+			"",
+			withExternalInstallChunk
+				? Template.asString([
+						"module.exports = __webpack_require__;",
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							`var update = require(${JSON.stringify(rootOutputDir)} + ${
+								RuntimeGlobals.getChunkUpdateScriptFilename
+							}(chunkId));`,
+							"var updatedModules = update.modules;",
+							"var runtime = update.runtime;",
+							"for(var moduleId in updatedModules) {",
+							Template.indent([
+								`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
+								Template.indent([
+									`currentUpdate[moduleId] = updatedModules[moduleId];`,
+									"if(updatedModulesList) updatedModulesList.push(moduleId);"
+								]),
+								"}"
+							]),
+							"}",
+							"if(runtime) currentUpdateRuntime.push(runtime);"
+						]),
+						"}",
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "require")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
+						Template.indent([
+							"return Promise.resolve().then(function() {",
+							Template.indent([
+								`return require(${JSON.stringify(rootOutputDir)} + ${
+									RuntimeGlobals.getUpdateManifestFilename
+								}());`
+							]),
+							"})['catch'](function(err) { if(err.code !== 'MODULE_NOT_FOUND') throw err; });"
+						]),
+						"}"
+				  ])
+				: "// no HMR manifest"
+		]);
 	}
+}
 
-	walkLabeledStatement(statement) {
-		const hook = this.hooks.label.get(statement.label.name);
-		if (hook !== undefined) {
-			const result = hook.call(statement);
-			if (result === true) return;
-		}
-		this.walkNestedStatement(statement.body);
-	}
+module.exports = RequireChunkLoadingRuntimeModule;
 
-	preWalkWithStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
 
-	walkWithStatement(statement) {
-		this.walkExpression(statement.object);
-		this.walkNestedStatement(statement.body);
-	}
+/***/ }),
 
-	preWalkSwitchStatement(statement) {
-		this.preWalkSwitchCases(statement.cases);
-	}
+/***/ 91786:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkSwitchStatement(statement) {
-		this.walkExpression(statement.discriminant);
-		this.walkSwitchCases(statement.cases);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	walkTerminatingStatement(statement) {
-		if (statement.argument) this.walkExpression(statement.argument);
-	}
 
-	walkReturnStatement(statement) {
-		this.walkTerminatingStatement(statement);
-	}
 
-	walkThrowStatement(statement) {
-		this.walkTerminatingStatement(statement);
-	}
+const util = __webpack_require__(73837);
+const truncateArgs = __webpack_require__(62090);
 
-	preWalkTryStatement(statement) {
-		this.preWalkStatement(statement.block);
-		if (statement.handler) this.preWalkCatchClause(statement.handler);
-		if (statement.finializer) this.preWalkStatement(statement.finializer);
-	}
+module.exports = ({ colors, appendOnly, stream }) => {
+	let currentStatusMessage = undefined;
+	let hasStatusMessage = false;
+	let currentIndent = "";
+	let currentCollapsed = 0;
 
-	walkTryStatement(statement) {
-		if (this.scope.inTry) {
-			this.walkStatement(statement.block);
+	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+		if (str === "") return str;
+		prefix = currentIndent + prefix;
+		if (colors) {
+			return (
+				prefix +
+				colorPrefix +
+				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
+				colorSuffix
+			);
 		} else {
-			this.scope.inTry = true;
-			this.walkStatement(statement.block);
-			this.scope.inTry = false;
+			return prefix + str.replace(/\n/g, "\n" + prefix);
 		}
-		if (statement.handler) this.walkCatchClause(statement.handler);
-		if (statement.finalizer) this.walkStatement(statement.finalizer);
-	}
+	};
 
-	preWalkWhileStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
+	const clearStatusMessage = () => {
+		if (hasStatusMessage) {
+			stream.write("\x1b[2K\r");
+			hasStatusMessage = false;
+		}
+	};
 
-	walkWhileStatement(statement) {
-		this.walkExpression(statement.test);
-		this.walkNestedStatement(statement.body);
-	}
+	const writeStatusMessage = () => {
+		if (!currentStatusMessage) return;
+		const l = stream.columns;
+		const args = l
+			? truncateArgs(currentStatusMessage, l - 1)
+			: currentStatusMessage;
+		const str = args.join(" ");
+		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
+		stream.write(`\x1b[2K\r${coloredStr}`);
+		hasStatusMessage = true;
+	};
 
-	preWalkDoWhileStatement(statement) {
-		this.preWalkStatement(statement.body);
-	}
+	const writeColored = (prefix, colorPrefix, colorSuffix) => {
+		return (...args) => {
+			if (currentCollapsed > 0) return;
+			clearStatusMessage();
+			const str = indent(
+				util.format(...args),
+				prefix,
+				colorPrefix,
+				colorSuffix
+			);
+			stream.write(str + "\n");
+			writeStatusMessage();
+		};
+	};
 
-	walkDoWhileStatement(statement) {
-		this.walkNestedStatement(statement.body);
-		this.walkExpression(statement.test);
-	}
+	const writeGroupMessage = writeColored(
+		"<-> ",
+		"\u001b[1m\u001b[36m",
+		"\u001b[39m\u001b[22m"
+	);
 
-	preWalkForStatement(statement) {
-		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration") {
-				this.preWalkStatement(statement.init);
-			}
-		}
-		this.preWalkStatement(statement.body);
-	}
+	const writeGroupCollapsedMessage = writeColored(
+		"<+> ",
+		"\u001b[1m\u001b[36m",
+		"\u001b[39m\u001b[22m"
+	);
 
-	walkForStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.init) {
-				if (statement.init.type === "VariableDeclaration") {
-					this.blockPreWalkVariableDeclaration(statement.init);
-					this.prevStatement = undefined;
-					this.walkStatement(statement.init);
-				} else {
-					this.walkExpression(statement.init);
-				}
-			}
-			if (statement.test) {
-				this.walkExpression(statement.test);
-			}
-			if (statement.update) {
-				this.walkExpression(statement.update);
-			}
-			const body = statement.body;
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
+	return {
+		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
+		debug: writeColored("    ", "", ""),
+		trace: writeColored("    ", "", ""),
+		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
+		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
+		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
+		logTime: writeColored(
+			"<t> ",
+			"\u001b[1m\u001b[35m",
+			"\u001b[39m\u001b[22m"
+		),
+		group: (...args) => {
+			writeGroupMessage(...args);
+			if (currentCollapsed > 0) {
+				currentCollapsed++;
 			} else {
-				this.walkNestedStatement(body);
+				currentIndent += "  ";
 			}
-		});
-	}
+		},
+		groupCollapsed: (...args) => {
+			writeGroupCollapsedMessage(...args);
+			currentCollapsed++;
+		},
+		groupEnd: () => {
+			if (currentCollapsed > 0) currentCollapsed--;
+			else if (currentIndent.length >= 2)
+				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
+		},
+		// eslint-disable-next-line node/no-unsupported-features/node-builtins
+		profile: console.profile && (name => console.profile(name)),
+		// eslint-disable-next-line node/no-unsupported-features/node-builtins
+		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
+		clear:
+			!appendOnly &&
+			// eslint-disable-next-line node/no-unsupported-features/node-builtins
+			console.clear &&
+			(() => {
+				clearStatusMessage();
+				// eslint-disable-next-line node/no-unsupported-features/node-builtins
+				console.clear();
+				writeStatusMessage();
+			}),
+		status: appendOnly
+			? writeColored("<s> ", "", "")
+			: (name, ...args) => {
+					args = args.filter(Boolean);
+					if (name === undefined && args.length === 0) {
+						clearStatusMessage();
+						currentStatusMessage = undefined;
+					} else if (
+						typeof name === "string" &&
+						name.startsWith("[webpack.Progress] ")
+					) {
+						currentStatusMessage = [name.slice(19), ...args];
+						writeStatusMessage();
+					} else if (name === "[webpack.Progress]") {
+						currentStatusMessage = [...args];
+						writeStatusMessage();
+					} else {
+						currentStatusMessage = [name, ...args];
+						writeStatusMessage();
+					}
+			  }
+	};
+};
 
-	preWalkForInStatement(statement) {
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
-		}
-		this.preWalkStatement(statement.body);
-	}
 
-	walkForInStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.left.type === "VariableDeclaration") {
-				this.blockPreWalkVariableDeclaration(statement.left);
-				this.walkVariableDeclaration(statement.left);
-			} else {
-				this.walkPattern(statement.left);
-			}
-			this.walkExpression(statement.right);
-			const body = statement.body;
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
-	}
+/***/ }),
 
-	preWalkForOfStatement(statement) {
-		if (statement.await && this.scope.topLevelScope === true) {
-			this.hooks.topLevelAwait.call(statement);
-		}
-		if (statement.left.type === "VariableDeclaration") {
-			this.preWalkVariableDeclaration(statement.left);
-		}
-		this.preWalkStatement(statement.body);
-	}
+/***/ 64395:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkForOfStatement(statement) {
-		this.inBlockScope(() => {
-			if (statement.left.type === "VariableDeclaration") {
-				this.blockPreWalkVariableDeclaration(statement.left);
-				this.walkVariableDeclaration(statement.left);
-			} else {
-				this.walkPattern(statement.left);
-			}
-			this.walkExpression(statement.right);
-			const body = statement.body;
-			if (body.type === "BlockStatement") {
-				// no need to add additional scope
-				const prev = this.prevStatement;
-				this.blockPreWalkStatements(body.body);
-				this.prevStatement = prev;
-				this.walkStatements(body.body);
-			} else {
-				this.walkNestedStatement(body);
-			}
-		});
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	// Declarations
-	preWalkFunctionDeclaration(statement) {
-		if (statement.id) {
-			this.defineVariable(statement.id.name);
-		}
-	}
 
-	walkFunctionDeclaration(statement) {
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = false;
-		this.inFunctionScope(true, statement.params, () => {
-			for (const param of statement.params) {
-				this.walkPattern(param);
-			}
-			if (statement.body.type === "BlockStatement") {
-				this.detectMode(statement.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.body);
-				this.prevStatement = prev;
-				this.walkStatement(statement.body);
-			} else {
-				this.walkExpression(statement.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
+
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
+
+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 || {};
 	}
 
-	blockPreWalkImportDeclaration(statement) {
-		const source = statement.source.value;
-		this.hooks.import.call(statement, source);
-		for (const specifier of statement.specifiers) {
-			const name = specifier.local.name;
-			switch (specifier.type) {
-				case "ImportDefaultSpecifier":
-					if (
-						!this.hooks.importSpecifier.call(statement, source, "default", name)
-					) {
-						this.defineVariable(name);
-					}
-					break;
-				case "ImportSpecifier":
-					if (
-						!this.hooks.importSpecifier.call(
-							statement,
-							source,
-							specifier.imported.name,
-							name
-						)
-					) {
-						this.defineVariable(name);
-					}
-					break;
-				case "ImportNamespaceSpecifier":
-					if (!this.hooks.importSpecifier.call(statement, source, null, name)) {
-						this.defineVariable(name);
-					}
-					break;
-				default:
-					this.defineVariable(name);
-			}
-		}
-	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const options = this.options;
+		const minSizeReduce = options.minSizeReduce || 1.5;
 
-	enterDeclaration(declaration, onIdent) {
-		switch (declaration.type) {
-			case "VariableDeclaration":
-				for (const declarator of declaration.declarations) {
-					switch (declarator.type) {
-						case "VariableDeclarator": {
-							this.enterPattern(declarator.id, onIdent);
-							break;
+		compiler.hooks.thisCompilation.tap(
+			"AggressiveMergingPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "AggressiveMergingPlugin",
+						stage: STAGE_ADVANCED
+					},
+					chunks => {
+						const chunkGraph = compilation.chunkGraph;
+						/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
+						let combinations = [];
+						for (const a of chunks) {
+							if (a.canBeInitial()) continue;
+							for (const b of chunks) {
+								if (b.canBeInitial()) continue;
+								if (b === a) break;
+								if (!chunkGraph.canChunksBeIntegrated(a, b)) {
+									continue;
+								}
+								const aSize = chunkGraph.getChunkSize(b, {
+									chunkOverhead: 0
+								});
+								const bSize = chunkGraph.getChunkSize(a, {
+									chunkOverhead: 0
+								});
+								const abSize = chunkGraph.getIntegratedChunksSize(b, a, {
+									chunkOverhead: 0
+								});
+								const improvement = (aSize + bSize) / abSize;
+								combinations.push({
+									a,
+									b,
+									improvement
+								});
+							}
 						}
-					}
-				}
-				break;
-			case "FunctionDeclaration":
-				this.enterPattern(declaration.id, onIdent);
-				break;
-			case "ClassDeclaration":
-				this.enterPattern(declaration.id, onIdent);
-				break;
-		}
-	}
 
-	blockPreWalkExportNamedDeclaration(statement) {
-		let source;
-		if (statement.source) {
-			source = statement.source.value;
-			this.hooks.exportImport.call(statement, source);
-		} else {
-			this.hooks.export.call(statement);
-		}
-		if (statement.declaration) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.declaration);
-				this.prevStatement = prev;
-				this.blockPreWalkStatement(statement.declaration);
-				let index = 0;
-				this.enterDeclaration(statement.declaration, def => {
-					this.hooks.exportSpecifier.call(statement, def, def, index++);
-				});
-			}
-		}
-		if (statement.specifiers) {
-			for (
-				let specifierIndex = 0;
-				specifierIndex < statement.specifiers.length;
-				specifierIndex++
-			) {
-				const specifier = statement.specifiers[specifierIndex];
-				switch (specifier.type) {
-					case "ExportSpecifier": {
-						const name = specifier.exported.name;
-						if (source) {
-							this.hooks.exportImportSpecifier.call(
-								statement,
-								source,
-								specifier.local.name,
-								name,
-								specifierIndex
-							);
-						} else {
-							this.hooks.exportSpecifier.call(
-								statement,
-								specifier.local.name,
-								name,
-								specifierIndex
-							);
-						}
-						break;
-					}
-				}
-			}
-		}
-	}
+						combinations.sort((a, b) => {
+							return b.improvement - a.improvement;
+						});
 
-	walkExportNamedDeclaration(statement) {
-		if (statement.declaration) {
-			this.walkStatement(statement.declaration);
-		}
-	}
+						const pair = combinations[0];
 
-	blockPreWalkExportDefaultDeclaration(statement) {
-		const prev = this.prevStatement;
-		this.preWalkStatement(statement.declaration);
-		this.prevStatement = prev;
-		this.blockPreWalkStatement(statement.declaration);
-		if (
-			statement.declaration.id &&
-			statement.declaration.type !== "FunctionExpression" &&
-			statement.declaration.type !== "ClassExpression"
-		) {
-			this.hooks.exportSpecifier.call(
-				statement,
-				statement.declaration.id.name,
-				"default",
-				undefined
-			);
-		}
-	}
+						if (!pair) return;
+						if (pair.improvement < minSizeReduce) return;
 
-	walkExportDefaultDeclaration(statement) {
-		this.hooks.export.call(statement);
-		if (
-			statement.declaration.id &&
-			statement.declaration.type !== "FunctionExpression" &&
-			statement.declaration.type !== "ClassExpression"
-		) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				this.walkStatement(statement.declaration);
-			}
-		} else {
-			// Acorn parses `export default function() {}` as `FunctionDeclaration` and
-			// `export default class {}` as `ClassDeclaration`, both with `id = null`.
-			// These nodes must be treated as expressions.
-			if (
-				statement.declaration.type === "FunctionDeclaration" ||
-				statement.declaration.type === "ClassDeclaration"
-			) {
-				this.walkStatement(statement.declaration);
-			} else {
-				this.walkExpression(statement.declaration);
-			}
-			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
-				this.hooks.exportSpecifier.call(
-					statement,
-					statement.declaration,
-					"default",
-					undefined
+						chunkGraph.integrateChunks(pair.b, pair.a);
+						compilation.chunks.delete(pair.a);
+						return true;
+					}
 				);
 			}
-		}
+		);
 	}
+}
 
-	blockPreWalkExportAllDeclaration(statement) {
-		const source = statement.source.value;
-		const name = statement.exported ? statement.exported.name : null;
-		this.hooks.exportImport.call(statement, source);
-		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
-	}
+module.exports = AggressiveMergingPlugin;
 
-	preWalkVariableDeclaration(statement) {
-		if (statement.kind !== "var") return;
-		this._preWalkVariableDeclaration(statement, this.hooks.varDeclarationVar);
-	}
 
-	blockPreWalkVariableDeclaration(statement) {
-		if (statement.kind === "var") return;
-		const hookMap =
-			statement.kind === "const"
-				? this.hooks.varDeclarationConst
-				: this.hooks.varDeclarationLet;
-		this._preWalkVariableDeclaration(statement, hookMap);
-	}
+/***/ }),
 
-	_preWalkVariableDeclaration(statement, hookMap) {
-		for (const declarator of statement.declarations) {
-			switch (declarator.type) {
-				case "VariableDeclarator": {
-					if (!this.hooks.preDeclarator.call(declarator, statement)) {
-						this.enterPattern(declarator.id, (name, decl) => {
-							let hook = hookMap.get(name);
-							if (hook === undefined || !hook.call(decl)) {
-								hook = this.hooks.varDeclaration.get(name);
-								if (hook === undefined || !hook.call(decl)) {
-									this.defineVariable(name);
-								}
-							}
-						});
-					}
-					break;
-				}
-			}
-		}
-	}
+/***/ 15543:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkVariableDeclaration(statement) {
-		for (const declarator of statement.declarations) {
-			switch (declarator.type) {
-				case "VariableDeclarator": {
-					const renameIdentifier =
-						declarator.init && this.getRenameIdentifier(declarator.init);
-					if (renameIdentifier && declarator.id.type === "Identifier") {
-						const hook = this.hooks.canRename.get(renameIdentifier);
-						if (hook !== undefined && hook.call(declarator.init)) {
-							// renaming with "var a = b;"
-							const hook = this.hooks.rename.get(renameIdentifier);
-							if (hook === undefined || !hook.call(declarator.init)) {
-								this.setVariable(declarator.id.name, renameIdentifier);
-							}
-							break;
-						}
-					}
-					if (!this.hooks.declarator.call(declarator, statement)) {
-						this.walkPattern(declarator.id);
-						if (declarator.init) this.walkExpression(declarator.init);
-					}
-					break;
-				}
-			}
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	blockPreWalkClassDeclaration(statement) {
-		if (statement.id) {
-			this.defineVariable(statement.id.name);
-		}
-	}
 
-	walkClassDeclaration(statement) {
-		this.walkClass(statement);
-	}
 
-	preWalkSwitchCases(switchCases) {
-		for (let index = 0, len = switchCases.length; index < len; index++) {
-			const switchCase = switchCases[index];
-			this.preWalkStatements(switchCase.consequent);
-		}
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const { intersect } = __webpack_require__(93347);
+const {
+	compareModulesByIdentifier,
+	compareChunks
+} = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
+const identifierUtils = __webpack_require__(82186);
+
+/** @typedef {import("../../declarations/plugins/optimize/AggressiveSplittingPlugin").AggressiveSplittingPluginOptions} AggressiveSplittingPluginOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const validate = createSchemaValidation(
+	__webpack_require__(32697),
+	() =>
+		__webpack_require__(47995),
+	{
+		name: "Aggressive Splitting Plugin",
+		baseDataPath: "options"
 	}
+);
 
-	walkSwitchCases(switchCases) {
-		this.inBlockScope(() => {
-			const len = switchCases.length;
+const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
+	return module => {
+		chunkGraph.disconnectChunkAndModule(oldChunk, module);
+		chunkGraph.connectChunkAndModule(newChunk, module);
+	};
+};
 
-			// we need to pre walk all statements first since we can have invalid code
-			// import A from "module";
-			// switch(1) {
-			//    case 1:
-			//      console.log(A); // should fail at runtime
-			//    case 2:
-			//      const A = 1;
-			// }
-			for (let index = 0; index < len; index++) {
-				const switchCase = switchCases[index];
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} chunk the chunk
+ * @returns {function(Module): boolean} filter for entry module
+ */
+const isNotAEntryModule = (chunkGraph, chunk) => {
+	return module => {
+		return !chunkGraph.isEntryModuleInChunk(module, chunk);
+	};
+};
 
-				if (switchCase.consequent.length > 0) {
-					const prev = this.prevStatement;
-					this.blockPreWalkStatements(switchCase.consequent);
-					this.prevStatement = prev;
-				}
-			}
+/** @type {WeakSet<Chunk>} */
+const recordedChunks = new WeakSet();
 
-			for (let index = 0; index < len; index++) {
-				const switchCase = switchCases[index];
+class AggressiveSplittingPlugin {
+	/**
+	 * @param {AggressiveSplittingPluginOptions=} options options object
+	 */
+	constructor(options = {}) {
+		validate(options);
 
-				if (switchCase.test) {
-					this.walkExpression(switchCase.test);
-				}
-				if (switchCase.consequent.length > 0) {
-					this.walkStatements(switchCase.consequent);
-				}
-			}
-		});
+		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;
+		}
 	}
 
-	preWalkCatchClause(catchClause) {
-		this.preWalkStatement(catchClause.body);
+	/**
+	 * @param {Chunk} chunk the chunk to test
+	 * @returns {boolean} true if the chunk was recorded
+	 */
+	static wasChunkRecorded(chunk) {
+		return recordedChunks.has(chunk);
 	}
 
-	walkCatchClause(catchClause) {
-		this.inBlockScope(() => {
-			// Error binding is optional in catch clause since ECMAScript 2019
-			if (catchClause.param !== null) {
-				this.enterPattern(catchClause.param, ident => {
-					this.defineVariable(ident);
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	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();
 				});
-				this.walkPattern(catchClause.param);
-			}
-			const prev = this.prevStatement;
-			this.blockPreWalkStatement(catchClause.body);
-			this.prevStatement = prev;
-			this.walkStatement(catchClause.body);
-		});
-	}
-
-	walkPattern(pattern) {
-		switch (pattern.type) {
-			case "ArrayPattern":
-				this.walkArrayPattern(pattern);
-				break;
-			case "AssignmentPattern":
-				this.walkAssignmentPattern(pattern);
-				break;
-			case "MemberExpression":
-				this.walkMemberExpression(pattern);
-				break;
-			case "ObjectPattern":
-				this.walkObjectPattern(pattern);
-				break;
-			case "RestElement":
-				this.walkRestElement(pattern);
-				break;
-		}
-	}
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "AggressiveSplittingPlugin",
+						stage: STAGE_ADVANCED
+					},
+					chunks => {
+						const chunkGraph = compilation.chunkGraph;
+						// Precompute stuff
+						const nameToModuleMap = new Map();
+						const moduleToNameMap = new Map();
+						const makePathsRelative =
+							identifierUtils.makePathsRelative.bindContextCache(
+								compiler.context,
+								compiler.root
+							);
+						for (const m of compilation.modules) {
+							const name = makePathsRelative(m.identifier());
+							nameToModuleMap.set(name, m);
+							moduleToNameMap.set(m, name);
+						}
 
-	walkAssignmentPattern(pattern) {
-		this.walkExpression(pattern.right);
-		this.walkPattern(pattern.left);
-	}
+						// Check used chunk ids
+						const usedIds = new Set();
+						for (const chunk of chunks) {
+							usedIds.add(chunk.id);
+						}
 
-	walkObjectPattern(pattern) {
-		for (let i = 0, len = pattern.properties.length; i < len; i++) {
-			const prop = pattern.properties[i];
-			if (prop) {
-				if (prop.computed) this.walkExpression(prop.key);
-				if (prop.value) this.walkPattern(prop.value);
-			}
-		}
-	}
+						const recordedSplits =
+							(compilation.records && compilation.records.aggressiveSplits) ||
+							[];
+						const usedSplits = newSplits
+							? recordedSplits.concat(newSplits)
+							: recordedSplits;
 
-	walkArrayPattern(pattern) {
-		for (let i = 0, len = pattern.elements.length; i < len; i++) {
-			const element = pattern.elements[i];
-			if (element) this.walkPattern(element);
-		}
-	}
+						const minSize = this.options.minSize;
+						const maxSize = this.options.maxSize;
 
-	walkRestElement(pattern) {
-		this.walkPattern(pattern.argument);
-	}
+						const applySplit = splitData => {
+							// Cannot split if id is already taken
+							if (splitData.id !== undefined && usedIds.has(splitData.id)) {
+								return false;
+							}
 
-	walkExpressions(expressions) {
-		for (const expression of expressions) {
-			if (expression) {
-				this.walkExpression(expression);
-			}
-		}
-	}
-
-	walkExpression(expression) {
-		switch (expression.type) {
-			case "ArrayExpression":
-				this.walkArrayExpression(expression);
-				break;
-			case "ArrowFunctionExpression":
-				this.walkArrowFunctionExpression(expression);
-				break;
-			case "AssignmentExpression":
-				this.walkAssignmentExpression(expression);
-				break;
-			case "AwaitExpression":
-				this.walkAwaitExpression(expression);
-				break;
-			case "BinaryExpression":
-				this.walkBinaryExpression(expression);
-				break;
-			case "CallExpression":
-				this.walkCallExpression(expression);
-				break;
-			case "ChainExpression":
-				this.walkChainExpression(expression);
-				break;
-			case "ClassExpression":
-				this.walkClassExpression(expression);
-				break;
-			case "ConditionalExpression":
-				this.walkConditionalExpression(expression);
-				break;
-			case "FunctionExpression":
-				this.walkFunctionExpression(expression);
-				break;
-			case "Identifier":
-				this.walkIdentifier(expression);
-				break;
-			case "ImportExpression":
-				this.walkImportExpression(expression);
-				break;
-			case "LogicalExpression":
-				this.walkLogicalExpression(expression);
-				break;
-			case "MetaProperty":
-				this.walkMetaProperty(expression);
-				break;
-			case "MemberExpression":
-				this.walkMemberExpression(expression);
-				break;
-			case "NewExpression":
-				this.walkNewExpression(expression);
-				break;
-			case "ObjectExpression":
-				this.walkObjectExpression(expression);
-				break;
-			case "SequenceExpression":
-				this.walkSequenceExpression(expression);
-				break;
-			case "SpreadElement":
-				this.walkSpreadElement(expression);
-				break;
-			case "TaggedTemplateExpression":
-				this.walkTaggedTemplateExpression(expression);
-				break;
-			case "TemplateLiteral":
-				this.walkTemplateLiteral(expression);
-				break;
-			case "ThisExpression":
-				this.walkThisExpression(expression);
-				break;
-			case "UnaryExpression":
-				this.walkUnaryExpression(expression);
-				break;
-			case "UpdateExpression":
-				this.walkUpdateExpression(expression);
-				break;
-			case "YieldExpression":
-				this.walkYieldExpression(expression);
-				break;
-		}
-	}
-
-	walkAwaitExpression(expression) {
-		if (this.scope.topLevelScope === true)
-			this.hooks.topLevelAwait.call(expression);
-		this.walkExpression(expression.argument);
-	}
-
-	walkArrayExpression(expression) {
-		if (expression.elements) {
-			this.walkExpressions(expression.elements);
-		}
-	}
+							// Get module objects from names
+							const selectedModules = splitData.modules.map(name =>
+								nameToModuleMap.get(name)
+							);
 
-	walkSpreadElement(expression) {
-		if (expression.argument) {
-			this.walkExpression(expression.argument);
-		}
-	}
+							// Does the modules exist at all?
+							if (!selectedModules.every(Boolean)) return false;
 
-	walkObjectExpression(expression) {
-		for (
-			let propIndex = 0, len = expression.properties.length;
-			propIndex < len;
-			propIndex++
-		) {
-			const prop = expression.properties[propIndex];
-			this.walkProperty(prop);
-		}
-	}
+							// Check if size matches (faster than waiting for hash)
+							let size = 0;
+							for (const m of selectedModules) size += m.size();
+							if (size !== splitData.size) return false;
 
-	walkProperty(prop) {
-		if (prop.type === "SpreadElement") {
-			this.walkExpression(prop.argument);
-			return;
-		}
-		if (prop.computed) {
-			this.walkExpression(prop.key);
-		}
-		if (prop.shorthand && prop.value && prop.value.type === "Identifier") {
-			this.scope.inShorthand = prop.value.name;
-			this.walkIdentifier(prop.value);
-			this.scope.inShorthand = false;
-		} else {
-			this.walkExpression(prop.value);
-		}
-	}
+							// get chunks with all modules
+							const selectedChunks = intersect(
+								selectedModules.map(
+									m => new Set(chunkGraph.getModuleChunksIterable(m))
+								)
+							);
 
-	walkFunctionExpression(expression) {
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = false;
-		const scopeParams = expression.params;
+							// No relevant chunks found
+							if (selectedChunks.size === 0) return false;
 
-		// Add function name in scope for recursive calls
-		if (expression.id) {
-			scopeParams.push(expression.id.name);
-		}
+							// The found chunk is already the split or similar
+							if (
+								selectedChunks.size === 1 &&
+								chunkGraph.getNumberOfChunkModules(
+									Array.from(selectedChunks)[0]
+								) === selectedModules.length
+							) {
+								const chunk = Array.from(selectedChunks)[0];
+								if (fromAggressiveSplittingSet.has(chunk)) return false;
+								fromAggressiveSplittingSet.add(chunk);
+								chunkSplitDataMap.set(chunk, splitData);
+								return true;
+							}
 
-		this.inFunctionScope(true, scopeParams, () => {
-			for (const param of expression.params) {
-				this.walkPattern(param);
-			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
-	}
+							// split the chunk into two parts
+							const newChunk = compilation.addChunk();
+							newChunk.chunkReason = "aggressive splitted";
+							for (const chunk of selectedChunks) {
+								selectedModules.forEach(
+									moveModuleBetween(chunkGraph, chunk, newChunk)
+								);
+								chunk.split(newChunk);
+								chunk.name = null;
+							}
+							fromAggressiveSplittingSet.add(newChunk);
+							chunkSplitDataMap.set(newChunk, splitData);
 
-	walkArrowFunctionExpression(expression) {
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
-		this.inFunctionScope(false, expression.params, () => {
-			for (const param of expression.params) {
-				this.walkPattern(param);
-			}
-			if (expression.body.type === "BlockStatement") {
-				this.detectMode(expression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(expression.body);
-				this.prevStatement = prev;
-				this.walkStatement(expression.body);
-			} else {
-				this.walkExpression(expression.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
-	}
+							if (splitData.id !== null && splitData.id !== undefined) {
+								newChunk.id = splitData.id;
+								newChunk.ids = [splitData.id];
+							}
+							return true;
+						};
 
-	/**
-	 * @param {SequenceExpressionNode} expression the sequence
-	 */
-	walkSequenceExpression(expression) {
-		if (!expression.expressions) return;
-		// We treat sequence expressions like statements when they are one statement level
-		// This has some benefits for optimizations that only work on statement level
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
-		if (
-			currentStatement === expression ||
-			(currentStatement.type === "ExpressionStatement" &&
-				currentStatement.expression === expression)
-		) {
-			const old = this.statementPath.pop();
-			for (const expr of expression.expressions) {
-				this.statementPath.push(expr);
-				this.walkExpression(expr);
-				this.statementPath.pop();
-			}
-			this.statementPath.push(old);
-		} else {
-			this.walkExpressions(expression.expressions);
-		}
-	}
+						// 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;
+						}
 
-	walkUpdateExpression(expression) {
-		this.walkExpression(expression.argument);
-	}
+						// for any chunk which isn't splitted yet, split it and create a new entry
+						// start with the biggest chunk
+						const cmpFn = compareChunks(chunkGraph);
+						const sortedChunks = Array.from(chunks).sort((a, b) => {
+							const diff1 =
+								chunkGraph.getChunkModulesSize(b) -
+								chunkGraph.getChunkModulesSize(a);
+							if (diff1) return diff1;
+							const diff2 =
+								chunkGraph.getNumberOfChunkModules(a) -
+								chunkGraph.getNumberOfChunkModules(b);
+							if (diff2) return diff2;
+							return cmpFn(a, b);
+						});
+						for (const chunk of sortedChunks) {
+							if (fromAggressiveSplittingSet.has(chunk)) continue;
+							const size = chunkGraph.getChunkModulesSize(chunk);
+							if (
+								size > maxSize &&
+								chunkGraph.getNumberOfChunkModules(chunk) > 1
+							) {
+								const modules = chunkGraph
+									.getOrderedChunkModules(chunk, compareModulesByIdentifier)
+									.filter(isNotAEntryModule(chunkGraph, chunk));
+								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
+								};
 
-	walkUnaryExpression(expression) {
-		if (expression.operator === "typeof") {
-			const result = this.callHooksForExpression(
-				this.hooks.typeof,
-				expression.argument,
-				expression
-			);
-			if (result === true) return;
-			if (expression.argument.type === "ChainExpression") {
-				const result = this.callHooksForExpression(
-					this.hooks.typeof,
-					expression.argument.expression,
-					expression
+								if (applySplit(splitData)) {
+									newSplits = (newSplits || []).concat(splitData);
+									changed = true;
+								}
+							}
+						}
+						if (changed) return true;
+					}
 				);
-				if (result === true) return;
-			}
-		}
-		this.walkExpression(expression.argument);
-	}
+				compilation.hooks.recordHash.tap(
+					"AggressiveSplittingPlugin",
+					records => {
+						// 4. save made splittings to records
+						const allSplits = new Set();
+						const invalidSplits = new Set();
 
-	walkLeftRightExpression(expression) {
-		this.walkExpression(expression.left);
-		this.walkExpression(expression.right);
-	}
+						// 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);
+								}
+							}
+						}
 
-	walkBinaryExpression(expression) {
-		this.walkLeftRightExpression(expression);
-	}
+						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
+									recordedChunks.add(chunk);
+								}
+							}
 
-	walkLogicalExpression(expression) {
-		const result = this.hooks.expressionLogicalOperator.call(expression);
-		if (result === undefined) {
-			this.walkLeftRightExpression(expression);
-		} else {
-			if (result) {
-				this.walkExpression(expression.right);
-			}
-		}
-	}
+							// Also add all unused historical 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);
+								}
+							}
 
-	walkAssignmentExpression(expression) {
-		if (expression.left.type === "Identifier") {
-			const renameIdentifier = this.getRenameIdentifier(expression.right);
-			if (renameIdentifier) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
-						renameIdentifier,
-						expression.right
-					)
-				) {
-					// renaming "a = b;"
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							expression.right
-						)
-					) {
-						this.setVariable(
-							expression.left.name,
-							this.getVariableInfo(renameIdentifier)
-						);
+							// record all splits
+							records.aggressiveSplits = Array.from(allSplits);
+
+							needAdditionalSeal = false;
+						}
 					}
-					return;
-				}
-			}
-			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
-				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.walkExpression(expression.left);
-				}
-			});
-			return;
-		}
-		if (expression.left.type.endsWith("Pattern")) {
-			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
-				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
-					this.defineVariable(name);
-				}
-			});
-			this.walkPattern(expression.left);
-		} else if (expression.left.type === "MemberExpression") {
-			const exprName = this.getMemberExpressionInfo(
-				expression.left,
-				ALLOWED_MEMBER_TYPES_EXPRESSION
-			);
-			if (exprName) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.assignMemberChain,
-						exprName.rootInfo,
-						expression,
-						exprName.getMembers()
-					)
-				) {
-					return;
-				}
+				);
+				compilation.hooks.needAdditionalSeal.tap(
+					"AggressiveSplittingPlugin",
+					() => {
+						if (needAdditionalSeal) {
+							needAdditionalSeal = false;
+							return true;
+						}
+					}
+				);
 			}
-			this.walkExpression(expression.right);
-			this.walkExpression(expression.left);
-		} else {
-			this.walkExpression(expression.right);
-			this.walkExpression(expression.left);
-		}
+		);
 	}
+}
+module.exports = AggressiveSplittingPlugin;
 
-	walkConditionalExpression(expression) {
-		const result = this.hooks.expressionConditionalOperator.call(expression);
-		if (result === undefined) {
-			this.walkExpression(expression.test);
-			this.walkExpression(expression.consequent);
-			if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
-		} else {
-			if (result) {
-				this.walkExpression(expression.consequent);
-			} else if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
-		}
-	}
 
-	walkNewExpression(expression) {
-		const result = this.callHooksForExpression(
-			this.hooks.new,
-			expression.callee,
-			expression
-		);
-		if (result === true) return;
-		this.walkExpression(expression.callee);
-		if (expression.arguments) {
-			this.walkExpressions(expression.arguments);
-		}
-	}
+/***/ }),
 
-	walkYieldExpression(expression) {
-		if (expression.argument) {
-			this.walkExpression(expression.argument);
-		}
-	}
+/***/ 97198:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	walkTemplateLiteral(expression) {
-		if (expression.expressions) {
-			this.walkExpressions(expression.expressions);
-		}
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	walkTaggedTemplateExpression(expression) {
-		if (expression.tag) {
-			this.walkExpression(expression.tag);
-		}
-		if (expression.quasi && expression.quasi.expressions) {
-			this.walkExpressions(expression.quasi.expressions);
-		}
-	}
 
-	walkClassExpression(expression) {
-		this.walkClass(expression);
-	}
 
-	/**
-	 * @param {ChainExpressionNode} expression expression
-	 */
-	walkChainExpression(expression) {
-		const result = this.hooks.optionalChaining.call(expression);
+const eslintScope = __webpack_require__(36007);
+const Referencer = __webpack_require__(44585);
+const {
+	CachedSource,
+	ConcatSource,
+	ReplaceSource
+} = __webpack_require__(51255);
+const ConcatenationScope = __webpack_require__(98229);
+const { UsageState } = __webpack_require__(63686);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HarmonyImportDependency = __webpack_require__(57154);
+const JavascriptParser = __webpack_require__(29050);
+const { equals } = __webpack_require__(84953);
+const LazySet = __webpack_require__(38938);
+const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const { makePathsRelative } = __webpack_require__(82186);
+const makeSerializable = __webpack_require__(33032);
+const propertyAccess = __webpack_require__(54190);
+const {
+	filterRuntime,
+	intersectRuntime,
+	mergeRuntimeCondition,
+	mergeRuntimeConditionNonFalse,
+	runtimeConditionToString,
+	subtractRuntimeCondition
+} = __webpack_require__(17156);
 
-		if (result === undefined) {
-			if (expression.expression.type === "CallExpression") {
-				this.walkCallExpression(expression.expression);
-			} else {
-				this.walkMemberExpression(expression.expression);
-			}
-		}
-	}
+/** @typedef {import("eslint-scope").Scope} Scope */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-	_walkIIFE(functionExpression, options, currentThis) {
-		const getVarInfo = argOrThis => {
-			const renameIdentifier = this.getRenameIdentifier(argOrThis);
-			if (renameIdentifier) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
-						renameIdentifier,
-						argOrThis
-					)
-				) {
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							argOrThis
-						)
-					) {
-						return this.getVariableInfo(renameIdentifier);
-					}
-				}
-			}
-			this.walkExpression(argOrThis);
-		};
-		const { params, type } = functionExpression;
-		const arrow = type === "ArrowFunctionExpression";
-		const renameThis = currentThis ? getVarInfo(currentThis) : null;
-		const varInfoForArgs = options.map(getVarInfo);
-		const wasTopLevel = this.scope.topLevelScope;
-		this.scope.topLevelScope = wasTopLevel && arrow ? "arrow" : false;
-		const scopeParams = params.filter(
-			(identifier, idx) => !varInfoForArgs[idx]
-		);
+// fix eslint-scope to support class properties correctly
+// cspell:word Referencer
+const ReferencerClass = Referencer;
+if (!ReferencerClass.prototype.PropertyDefinition) {
+	ReferencerClass.prototype.PropertyDefinition =
+		ReferencerClass.prototype.Property;
+}
 
-		// Add function name in scope for recursive calls
-		if (functionExpression.id) {
-			scopeParams.push(functionExpression.id.name);
-		}
+/**
+ * @typedef {Object} ReexportInfo
+ * @property {Module} module
+ * @property {string[]} export
+ */
 
-		this.inFunctionScope(true, scopeParams, () => {
-			if (renameThis && !arrow) {
-				this.setVariable("this", renameThis);
-			}
-			for (let i = 0; i < varInfoForArgs.length; i++) {
-				const varInfo = varInfoForArgs[i];
-				if (!varInfo) continue;
-				if (!params[i] || params[i].type !== "Identifier") continue;
-				this.setVariable(params[i].name, varInfo);
-			}
-			if (functionExpression.body.type === "BlockStatement") {
-				this.detectMode(functionExpression.body.body);
-				const prev = this.prevStatement;
-				this.preWalkStatement(functionExpression.body);
-				this.prevStatement = prev;
-				this.walkStatement(functionExpression.body);
-			} else {
-				this.walkExpression(functionExpression.body);
-			}
-		});
-		this.scope.topLevelScope = wasTopLevel;
-	}
+/** @typedef {RawBinding | SymbolBinding} Binding */
 
-	walkImportExpression(expression) {
-		let result = this.hooks.importCall.call(expression);
-		if (result === true) return;
+/**
+ * @typedef {Object} RawBinding
+ * @property {ModuleInfo} info
+ * @property {string} rawName
+ * @property {string=} comment
+ * @property {string[]} ids
+ * @property {string[]} exportName
+ */
 
-		this.walkExpression(expression.source);
-	}
+/**
+ * @typedef {Object} SymbolBinding
+ * @property {ConcatenatedModuleInfo} info
+ * @property {string} name
+ * @property {string=} comment
+ * @property {string[]} ids
+ * @property {string[]} exportName
+ */
 
-	walkCallExpression(expression) {
-		const isSimpleFunction = fn => {
-			return fn.params.every(p => p.type === "Identifier");
-		};
-		if (
-			expression.callee.type === "MemberExpression" &&
-			expression.callee.object.type.endsWith("FunctionExpression") &&
-			!expression.callee.computed &&
-			(expression.callee.property.name === "call" ||
-				expression.callee.property.name === "bind") &&
-			expression.arguments.length > 0 &&
-			isSimpleFunction(expression.callee.object)
-		) {
-			// (function(…) { }.call/bind(?, …))
-			this._walkIIFE(
-				expression.callee.object,
-				expression.arguments.slice(1),
-				expression.arguments[0]
-			);
-		} else if (
-			expression.callee.type.endsWith("FunctionExpression") &&
-			isSimpleFunction(expression.callee)
-		) {
-			// (function(…) { }(…))
-			this._walkIIFE(expression.callee, expression.arguments, null);
-		} else {
-			if (expression.callee.type === "MemberExpression") {
-				const exprInfo = this.getMemberExpressionInfo(
-					expression.callee,
-					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
-				);
-				if (exprInfo && exprInfo.type === "call") {
-					const result = this.callHooksForInfo(
-						this.hooks.callMemberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers()
-					);
-					if (result === true) return;
-				}
-			}
-			const callee = this.evaluateExpression(expression.callee);
-			if (callee.isIdentifier()) {
-				const result1 = this.callHooksForInfo(
-					this.hooks.callMemberChain,
-					callee.rootInfo,
-					expression,
-					callee.getMembers()
-				);
-				if (result1 === true) return;
-				const result2 = this.callHooksForInfo(
-					this.hooks.call,
-					callee.identifier,
-					expression
-				);
-				if (result2 === true) return;
-			}
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo } ModuleInfo */
+/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
 
-			if (expression.callee) {
-				if (expression.callee.type === "MemberExpression") {
-					// because of call context we need to walk the call context as expression
-					this.walkExpression(expression.callee.object);
-					if (expression.callee.computed === true)
-						this.walkExpression(expression.callee.property);
-				} else {
-					this.walkExpression(expression.callee);
-				}
-			}
-			if (expression.arguments) this.walkExpressions(expression.arguments);
-		}
-	}
+/**
+ * @typedef {Object} ConcatenatedModuleInfo
+ * @property {"concatenated"} type
+ * @property {Module} module
+ * @property {number} index
+ * @property {Object} ast
+ * @property {Source} internalSource
+ * @property {ReplaceSource} source
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {Iterable<string>} runtimeRequirements
+ * @property {Scope} globalScope
+ * @property {Scope} moduleScope
+ * @property {Map<string, string>} internalNames
+ * @property {Map<string, string>} exportMap
+ * @property {Map<string, string>} rawExportMap
+ * @property {string=} namespaceExportSymbol
+ * @property {string} namespaceObjectName
+ * @property {boolean} interopNamespaceObjectUsed
+ * @property {string} interopNamespaceObjectName
+ * @property {boolean} interopNamespaceObject2Used
+ * @property {string} interopNamespaceObject2Name
+ * @property {boolean} interopDefaultAccessUsed
+ * @property {string} interopDefaultAccessName
+ */
 
-	walkMemberExpression(expression) {
-		const exprInfo = this.getMemberExpressionInfo(
-			expression,
-			ALLOWED_MEMBER_TYPES_ALL
-		);
-		if (exprInfo) {
-			switch (exprInfo.type) {
-				case "expression": {
-					const result1 = this.callHooksForInfo(
-						this.hooks.expression,
-						exprInfo.name,
-						expression
-					);
-					if (result1 === true) return;
-					const members = exprInfo.getMembers();
-					const result2 = this.callHooksForInfo(
-						this.hooks.expressionMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						members
-					);
-					if (result2 === true) return;
-					this.walkMemberExpressionWithExpressionName(
-						expression,
-						exprInfo.name,
-						exprInfo.rootInfo,
-						members.slice(),
-						() =>
-							this.callHooksForInfo(
-								this.hooks.unhandledExpressionMemberChain,
-								exprInfo.rootInfo,
-								expression,
-								members
-							)
-					);
-					return;
-				}
-				case "call": {
-					const result = this.callHooksForInfo(
-						this.hooks.memberChainOfCallMemberChain,
-						exprInfo.rootInfo,
-						expression,
-						exprInfo.getCalleeMembers(),
-						exprInfo.call,
-						exprInfo.getMembers()
-					);
-					if (result === true) return;
-					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
-					// and call computed property are literals anyway
-					this.walkExpression(exprInfo.call);
-					return;
-				}
-			}
-		}
-		this.walkExpression(expression.object);
-		if (expression.computed === true) this.walkExpression(expression.property);
-	}
+/**
+ * @typedef {Object} ExternalModuleInfo
+ * @property {"external"} type
+ * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {number} index
+ * @property {string} name
+ * @property {boolean} interopNamespaceObjectUsed
+ * @property {string} interopNamespaceObjectName
+ * @property {boolean} interopNamespaceObject2Used
+ * @property {string} interopNamespaceObject2Name
+ * @property {boolean} interopDefaultAccessUsed
+ * @property {string} interopDefaultAccessName
+ */
 
-	walkMemberExpressionWithExpressionName(
-		expression,
-		name,
-		rootInfo,
-		members,
-		onUnhandled
-	) {
-		if (expression.object.type === "MemberExpression") {
-			// optimize the case where expression.object is a MemberExpression too.
-			// we can keep info here when calling walkMemberExpression directly
-			const property =
-				expression.property.name || `${expression.property.value}`;
-			name = name.slice(0, -property.length - 1);
-			members.pop();
-			const result = this.callHooksForInfo(
-				this.hooks.expression,
-				name,
-				expression.object
-			);
-			if (result === true) return;
-			this.walkMemberExpressionWithExpressionName(
-				expression.object,
-				name,
-				rootInfo,
-				members,
-				onUnhandled
-			);
-		} else if (!onUnhandled || !onUnhandled()) {
-			this.walkExpression(expression.object);
-		}
-		if (expression.computed === true) this.walkExpression(expression.property);
-	}
+/**
+ * @typedef {Object} ReferenceToModuleInfo
+ * @property {"reference"} type
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
+ */
 
-	walkThisExpression(expression) {
-		this.callHooksForName(this.hooks.expression, "this", expression);
-	}
+const RESERVED_NAMES = new Set(
+	[
+		// internal names (should always be renamed)
+		ConcatenationScope.DEFAULT_EXPORT,
+		ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
 
-	walkIdentifier(expression) {
-		this.callHooksForName(this.hooks.expression, expression.name, expression);
-	}
+		// keywords
+		"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",
 
-	/**
-	 * @param {MetaPropertyNode} metaProperty meta property
-	 */
-	walkMetaProperty(metaProperty) {
-		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
-	}
+		// commonjs/amd
+		"module,__dirname,__filename,exports,require,define",
 
-	callHooksForExpression(hookMap, expr, ...args) {
-		return this.callHooksForExpressionWithFallback(
-			hookMap,
-			expr,
-			undefined,
-			undefined,
-			...args
-		);
-	}
+		// js globals
+		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
+		"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {MemberExpressionNode} expr expression info
-	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
-	 * @param {function(string): any} defined callback when variable is defined
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForExpressionWithFallback(
-		hookMap,
-		expr,
-		fallback,
-		defined,
-		...args
-	) {
-		const exprName = this.getMemberExpressionInfo(
-			expr,
-			ALLOWED_MEMBER_TYPES_EXPRESSION
-		);
-		if (exprName !== undefined) {
-			const members = exprName.getMembers();
-			return this.callHooksForInfoWithFallback(
-				hookMap,
-				members.length === 0 ? exprName.rootInfo : exprName.name,
-				fallback &&
-					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
-				defined && (() => defined(exprName.name)),
-				...args
-			);
+		// browser globals
+		"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",
+
+		// window events
+		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
+	]
+		.join(",")
+		.split(",")
+);
+
+const bySourceOrder = (a, b) => {
+	const aOrder = a.sourceOrder;
+	const bOrder = b.sourceOrder;
+	if (isNaN(aOrder)) {
+		if (!isNaN(bOrder)) {
+			return 1;
+		}
+	} else {
+		if (isNaN(bOrder)) {
+			return -1;
+		}
+		if (aOrder !== bOrder) {
+			return aOrder < bOrder ? -1 : 1;
 		}
 	}
+	return 0;
+};
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {string} name key in map
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForName(hookMap, name, ...args) {
-		return this.callHooksForNameWithFallback(
-			hookMap,
-			name,
-			undefined,
-			undefined,
-			...args
-		);
+const joinIterableWithComma = iterable => {
+	// This is more performant than Array.from().join(", ")
+	// as it doesn't create an array
+	let str = "";
+	let first = true;
+	for (const item of iterable) {
+		if (first) {
+			first = false;
+		} else {
+			str += ", ";
+		}
+		str += item;
 	}
+	return str;
+};
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
-	 * @param {ExportedVariableInfo} info variable info
-	 * @param  {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForInfo(hookMap, info, ...args) {
-		return this.callHooksForInfoWithFallback(
-			hookMap,
-			info,
-			undefined,
-			undefined,
-			...args
-		);
-	}
+/**
+ * @typedef {Object} ConcatenationEntry
+ * @property {"concatenated" | "external"} type
+ * @property {Module} module
+ * @property {RuntimeSpec | boolean} runtimeCondition
+ */
 
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {ExportedVariableInfo} info variable info
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
-		let name;
-		if (typeof info === "string") {
-			name = info;
-		} else {
-			if (!(info instanceof VariableInfo)) {
-				if (defined !== undefined) {
-					return defined();
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ModuleInfo} info module info
+ * @param {string[]} exportName exportName
+ * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
+ * @param {RuntimeSpec} runtime for which runtime
+ * @param {RequestShortener} requestShortener the request shortener
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
+ * @param {boolean} asCall asCall
+ * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
+ * @returns {Binding} the final variable
+ */
+const getFinalBinding = (
+	moduleGraph,
+	info,
+	exportName,
+	moduleToInfoMap,
+	runtime,
+	requestShortener,
+	runtimeTemplate,
+	neededNamespaceObjects,
+	asCall,
+	strictHarmonyModule,
+	asiSafe,
+	alreadyVisited = new Set()
+) => {
+	const exportsType = info.module.getExportsType(
+		moduleGraph,
+		strictHarmonyModule
+	);
+	if (exportName.length === 0) {
+		switch (exportsType) {
+			case "default-only":
+				info.interopNamespaceObject2Used = true;
+				return {
+					info,
+					rawName: info.interopNamespaceObject2Name,
+					ids: exportName,
+					exportName
+				};
+			case "default-with-named":
+				info.interopNamespaceObjectUsed = true;
+				return {
+					info,
+					rawName: info.interopNamespaceObjectName,
+					ids: exportName,
+					exportName
+				};
+			case "namespace":
+			case "dynamic":
+				break;
+			default:
+				throw new Error(`Unexpected exportsType ${exportsType}`);
+		}
+	} else {
+		switch (exportsType) {
+			case "namespace":
+				break;
+			case "default-with-named":
+				switch (exportName[0]) {
+					case "default":
+						exportName = exportName.slice(1);
+						break;
+					case "__esModule":
+						return {
+							info,
+							rawName: "/* __esModule */true",
+							ids: exportName.slice(1),
+							exportName
+						};
 				}
-				return;
-			}
-			let tagInfo = info.tagInfo;
-			while (tagInfo !== undefined) {
-				const hook = hookMap.get(tagInfo.tag);
-				if (hook !== undefined) {
-					this.currentTagData = tagInfo.data;
-					const result = hook.call(...args);
-					this.currentTagData = undefined;
-					if (result !== undefined) return result;
+				break;
+			case "default-only": {
+				const exportId = exportName[0];
+				if (exportId === "__esModule") {
+					return {
+						info,
+						rawName: "/* __esModule */true",
+						ids: exportName.slice(1),
+						exportName
+					};
 				}
-				tagInfo = tagInfo.next;
-			}
-			if (info.freeName === true) {
-				if (defined !== undefined) {
-					return defined();
+				exportName = exportName.slice(1);
+				if (exportId !== "default") {
+					return {
+						info,
+						rawName:
+							"/* non-default import from default-exporting module */undefined",
+						ids: exportName,
+						exportName
+					};
 				}
-				return;
+				break;
 			}
-			name = info.freeName;
-		}
-		const hook = hookMap.get(name);
-		if (hook !== undefined) {
-			const result = hook.call(...args);
-			if (result !== undefined) return result;
-		}
-		if (fallback !== undefined) {
-			return fallback(name);
+			case "dynamic":
+				switch (exportName[0]) {
+					case "default": {
+						exportName = exportName.slice(1);
+						info.interopDefaultAccessUsed = true;
+						const defaultExport = asCall
+							? `${info.interopDefaultAccessName}()`
+							: asiSafe
+							? `(${info.interopDefaultAccessName}())`
+							: asiSafe === false
+							? `;(${info.interopDefaultAccessName}())`
+							: `${info.interopDefaultAccessName}.a`;
+						return {
+							info,
+							rawName: defaultExport,
+							ids: exportName,
+							exportName
+						};
+					}
+					case "__esModule":
+						return {
+							info,
+							rawName: "/* __esModule */true",
+							ids: exportName.slice(1),
+							exportName
+						};
+				}
+				break;
+			default:
+				throw new Error(`Unexpected exportsType ${exportsType}`);
 		}
 	}
-
-	/**
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {string} name key in map
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
-	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
-	 */
-	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
-		return this.callHooksForInfoWithFallback(
-			hookMap,
-			this.getVariableInfo(name),
-			fallback,
-			defined,
-			...args
-		);
+	if (exportName.length === 0) {
+		switch (info.type) {
+			case "concatenated":
+				neededNamespaceObjects.add(info);
+				return {
+					info,
+					rawName: info.namespaceObjectName,
+					ids: exportName,
+					exportName
+				};
+			case "external":
+				return { info, rawName: info.name, ids: exportName, exportName };
+		}
 	}
-
-	/**
-	 * @deprecated
-	 * @param {any} params scope params
-	 * @param {function(): void} fn inner function
-	 * @returns {void}
-	 */
-	inScope(params, fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: false,
-			inShorthand: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			definitions: oldScope.definitions.createChild()
+	const exportsInfo = moduleGraph.getExportsInfo(info.module);
+	const exportInfo = exportsInfo.getExportInfo(exportName[0]);
+	if (alreadyVisited.has(exportInfo)) {
+		return {
+			info,
+			rawName: "/* circular reexport */ Object(function x() { x() }())",
+			ids: [],
+			exportName
 		};
-
-		this.undefineVariable("this");
-
-		this.enterPatterns(params, (ident, pattern) => {
-			this.defineVariable(ident);
-		});
-
-		fn();
-
-		this.scope = oldScope;
 	}
-
-	inFunctionScope(hasThis, params, fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: false,
-			inShorthand: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			definitions: oldScope.definitions.createChild()
-		};
-
-		if (hasThis) {
-			this.undefineVariable("this");
+	alreadyVisited.add(exportInfo);
+	switch (info.type) {
+		case "concatenated": {
+			const exportId = exportName[0];
+			if (exportInfo.provided === false) {
+				// It's not provided, but it could be on the prototype
+				neededNamespaceObjects.add(info);
+				return {
+					info,
+					rawName: info.namespaceObjectName,
+					ids: exportName,
+					exportName
+				};
+			}
+			const directExport = info.exportMap && info.exportMap.get(exportId);
+			if (directExport) {
+				const usedName = /** @type {string[]} */ (
+					exportsInfo.getUsedName(exportName, runtime)
+				);
+				if (!usedName) {
+					return {
+						info,
+						rawName: "/* unused export */ undefined",
+						ids: exportName.slice(1),
+						exportName
+					};
+				}
+				return {
+					info,
+					name: directExport,
+					ids: usedName.slice(1),
+					exportName
+				};
+			}
+			const rawExport = info.rawExportMap && info.rawExportMap.get(exportId);
+			if (rawExport) {
+				return {
+					info,
+					rawName: rawExport,
+					ids: exportName.slice(1),
+					exportName
+				};
+			}
+			const reexport = exportInfo.findTarget(moduleGraph, module =>
+				moduleToInfoMap.has(module)
+			);
+			if (reexport === false) {
+				throw new Error(
+					`Target module of reexport from '${info.module.readableIdentifier(
+						requestShortener
+					)}' is not part of the concatenation (export '${exportId}')\nModules in the concatenation:\n${Array.from(
+						moduleToInfoMap,
+						([m, info]) =>
+							` * ${info.type} ${m.readableIdentifier(requestShortener)}`
+					).join("\n")}`
+				);
+			}
+			if (reexport) {
+				const refInfo = moduleToInfoMap.get(reexport.module);
+				return getFinalBinding(
+					moduleGraph,
+					refInfo,
+					reexport.export
+						? [...reexport.export, ...exportName.slice(1)]
+						: exportName.slice(1),
+					moduleToInfoMap,
+					runtime,
+					requestShortener,
+					runtimeTemplate,
+					neededNamespaceObjects,
+					asCall,
+					info.module.buildMeta.strictHarmonyModule,
+					asiSafe,
+					alreadyVisited
+				);
+			}
+			if (info.namespaceExportSymbol) {
+				const usedName = /** @type {string[]} */ (
+					exportsInfo.getUsedName(exportName, runtime)
+				);
+				return {
+					info,
+					rawName: info.namespaceObjectName,
+					ids: usedName,
+					exportName
+				};
+			}
+			throw new Error(
+				`Cannot get final name for export '${exportName.join(
+					"."
+				)}' of ${info.module.readableIdentifier(requestShortener)}`
+			);
 		}
 
-		this.enterPatterns(params, (ident, pattern) => {
-			this.defineVariable(ident);
-		});
-
-		fn();
-
-		this.scope = oldScope;
+		case "external": {
+			const used = /** @type {string[]} */ (
+				exportsInfo.getUsedName(exportName, runtime)
+			);
+			if (!used) {
+				return {
+					info,
+					rawName: "/* unused export */ undefined",
+					ids: exportName.slice(1),
+					exportName
+				};
+			}
+			const comment = equals(used, exportName)
+				? ""
+				: Template.toNormalComment(`${exportName.join(".")}`);
+			return { info, rawName: info.name + comment, ids: used, exportName };
+		}
 	}
+};
 
-	inBlockScope(fn) {
-		const oldScope = this.scope;
-		this.scope = {
-			topLevelScope: oldScope.topLevelScope,
-			inTry: oldScope.inTry,
-			inShorthand: false,
-			isStrict: oldScope.isStrict,
-			isAsmJs: oldScope.isAsmJs,
-			definitions: oldScope.definitions.createChild()
-		};
-
-		fn();
-
-		this.scope = oldScope;
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ModuleInfo} info module info
+ * @param {string[]} exportName exportName
+ * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
+ * @param {RuntimeSpec} runtime for which runtime
+ * @param {RequestShortener} requestShortener the request shortener
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
+ * @param {boolean} asCall asCall
+ * @param {boolean} callContext callContext
+ * @param {boolean} strictHarmonyModule strictHarmonyModule
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @returns {string} the final name
+ */
+const getFinalName = (
+	moduleGraph,
+	info,
+	exportName,
+	moduleToInfoMap,
+	runtime,
+	requestShortener,
+	runtimeTemplate,
+	neededNamespaceObjects,
+	asCall,
+	callContext,
+	strictHarmonyModule,
+	asiSafe
+) => {
+	const binding = getFinalBinding(
+		moduleGraph,
+		info,
+		exportName,
+		moduleToInfoMap,
+		runtime,
+		requestShortener,
+		runtimeTemplate,
+		neededNamespaceObjects,
+		asCall,
+		strictHarmonyModule,
+		asiSafe
+	);
+	{
+		const { ids, comment } = binding;
+		let reference;
+		let isPropertyAccess;
+		if ("rawName" in binding) {
+			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
+			isPropertyAccess = ids.length > 0;
+		} else {
+			const { info, name: exportId } = binding;
+			const name = info.internalNames.get(exportId);
+			if (!name) {
+				throw new Error(
+					`The export "${exportId}" in "${info.module.readableIdentifier(
+						requestShortener
+					)}" has no internal name (existing names: ${
+						Array.from(
+							info.internalNames,
+							([name, symbol]) => `${name}: ${symbol}`
+						).join(", ") || "none"
+					})`
+				);
+			}
+			reference = `${name}${comment || ""}${propertyAccess(ids)}`;
+			isPropertyAccess = ids.length > 1;
+		}
+		if (isPropertyAccess && asCall && callContext === false) {
+			return asiSafe
+				? `(0,${reference})`
+				: asiSafe === false
+				? `;(0,${reference})`
+				: `/*#__PURE__*/Object(${reference})`;
+		}
+		return reference;
 	}
+};
 
-	detectMode(statements) {
-		const isLiteral =
-			statements.length >= 1 &&
-			statements[0].type === "ExpressionStatement" &&
-			statements[0].expression.type === "Literal";
-		if (isLiteral && statements[0].expression.value === "use strict") {
-			this.scope.isStrict = true;
-		}
-		if (isLiteral && statements[0].expression.value === "use asm") {
-			this.scope.isAsmJs = true;
+const addScopeSymbols = (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;
 	}
+};
 
-	enterPatterns(patterns, onIdent) {
-		for (const pattern of patterns) {
-			if (typeof pattern !== "string") {
-				this.enterPattern(pattern, onIdent);
-			} else if (pattern) {
-				onIdent(pattern);
+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;
+};
 
-	enterPattern(pattern, onIdent) {
-		if (!pattern) return;
-		switch (pattern.type) {
-			case "ArrayPattern":
-				this.enterArrayPattern(pattern, onIdent);
-				break;
-			case "AssignmentPattern":
-				this.enterAssignmentPattern(pattern, onIdent);
-				break;
-			case "Identifier":
-				this.enterIdentifier(pattern, onIdent);
-				break;
-			case "ObjectPattern":
-				this.enterObjectPattern(pattern, onIdent);
-				break;
-			case "RestElement":
-				this.enterRestElement(pattern, onIdent);
-				break;
-			case "Property":
-				if (pattern.shorthand && pattern.value.type === "Identifier") {
-					this.scope.inShorthand = pattern.value.name;
-					this.enterIdentifier(pattern.value, onIdent);
-					this.scope.inShorthand = false;
-				} else {
-					this.enterPattern(pattern.value, onIdent);
-				}
-				break;
-		}
+const getPathInAst = (ast, node) => {
+	if (ast === node) {
+		return [];
 	}
 
-	enterIdentifier(pattern, onIdent) {
-		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
-			onIdent(pattern.name, pattern);
-		}
-	}
+	const nr = node.range;
 
-	enterObjectPattern(pattern, onIdent) {
-		for (
-			let propIndex = 0, len = pattern.properties.length;
-			propIndex < len;
-			propIndex++
-		) {
-			const prop = pattern.properties[propIndex];
-			this.enterPattern(prop, onIdent);
+	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;
+	};
 
-	enterArrayPattern(pattern, onIdent) {
-		for (
-			let elementIndex = 0, len = pattern.elements.length;
-			elementIndex < len;
-			elementIndex++
-		) {
-			const element = pattern.elements[elementIndex];
-			this.enterPattern(element, onIdent);
+	if (Array.isArray(ast)) {
+		for (let 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 (let 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;
+			}
 		}
 	}
+};
 
-	enterRestElement(pattern, onIdent) {
-		this.enterPattern(pattern.argument, onIdent);
-	}
-
-	enterAssignmentPattern(pattern, onIdent) {
-		this.enterPattern(pattern.left, onIdent);
-	}
+const TYPES = new Set(["javascript"]);
 
+class ConcatenatedModule extends Module {
 	/**
-	 * @param {ExpressionNode} expression expression node
-	 * @returns {BasicEvaluatedExpression | undefined} evaluation result
+	 * @param {Module} rootModule the root module of the concatenation
+	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @returns {ConcatenatedModule} the module
 	 */
-	evaluateExpression(expression) {
-		try {
-			const hook = this.hooks.evaluate.get(expression.type);
-			if (hook !== undefined) {
-				const result = hook.call(expression);
-				if (result !== undefined) {
-					if (result) {
-						result.setExpression(expression);
-					}
-					return result;
-				}
-			}
-		} catch (e) {
-			console.warn(e);
-			// ignore error
-		}
-		return new BasicEvaluatedExpression()
-			.setRange(expression.range)
-			.setExpression(expression);
-	}
-
-	parseString(expression) {
-		switch (expression.type) {
-			case "BinaryExpression":
-				if (expression.operator === "+") {
-					return (
-						this.parseString(expression.left) +
-						this.parseString(expression.right)
-					);
-				}
-				break;
-			case "Literal":
-				return expression.value + "";
-		}
-		throw new Error(
-			expression.type + " is not supported as parameter for require"
+	static create(
+		rootModule,
+		modules,
+		runtime,
+		associatedObjectForCache,
+		hashFunction = "md4"
+	) {
+		const identifier = ConcatenatedModule._createIdentifier(
+			rootModule,
+			modules,
+			associatedObjectForCache,
+			hashFunction
 		);
-	}
-
-	parseCalculatedString(expression) {
-		switch (expression.type) {
-			case "BinaryExpression":
-				if (expression.operator === "+") {
-					const left = this.parseCalculatedString(expression.left);
-					const right = this.parseCalculatedString(expression.right);
-					if (left.code) {
-						return {
-							range: left.range,
-							value: left.value,
-							code: true,
-							conditional: false
-						};
-					} else if (right.code) {
-						return {
-							range: [
-								left.range[0],
-								right.range ? right.range[1] : left.range[1]
-							],
-							value: left.value + right.value,
-							code: true,
-							conditional: false
-						};
-					} else {
-						return {
-							range: [left.range[0], right.range[1]],
-							value: left.value + right.value,
-							code: false,
-							conditional: false
-						};
-					}
-				}
-				break;
-			case "ConditionalExpression": {
-				const consequent = this.parseCalculatedString(expression.consequent);
-				const alternate = this.parseCalculatedString(expression.alternate);
-				const items = [];
-				if (consequent.conditional) {
-					items.push(...consequent.conditional);
-				} else if (!consequent.code) {
-					items.push(consequent);
-				} else {
-					break;
-				}
-				if (alternate.conditional) {
-					items.push(...alternate.conditional);
-				} else if (!alternate.code) {
-					items.push(alternate);
-				} else {
-					break;
-				}
-				return {
-					range: undefined,
-					value: "",
-					code: true,
-					conditional: items
-				};
-			}
-			case "Literal":
-				return {
-					range: expression.range,
-					value: expression.value + "",
-					code: false,
-					conditional: false
-				};
-		}
-		return {
-			range: undefined,
-			value: "",
-			code: true,
-			conditional: false
-		};
+		return new ConcatenatedModule({
+			identifier,
+			rootModule,
+			modules,
+			runtime
+		});
 	}
 
 	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
+	 * @param {Object} options options
+	 * @param {string} options.identifier the identifier of the module
+	 * @param {Module=} options.rootModule the root module of the concatenation
+	 * @param {RuntimeSpec} options.runtime the selected runtime
+	 * @param {Set<Module>=} options.modules all concatenated modules
 	 */
-	parse(source, state) {
-		let ast;
-		let comments;
-		const semicolons = new Set();
-		if (source === null) {
-			throw new Error("source must not be null");
-		}
-		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
-		}
-		if (typeof source === "object") {
-			ast = /** @type {ProgramNode} */ (source);
-			comments = source.comments;
-		} else {
-			comments = [];
-			ast = JavascriptParser._parse(source, {
-				sourceType: this.sourceType,
-				onComment: comments,
-				onInsertedSemicolon: pos => semicolons.add(pos)
-			});
-		}
+	constructor({ identifier, rootModule, modules, runtime }) {
+		super("javascript/esm", null, rootModule && rootModule.layer);
 
-		const oldScope = this.scope;
-		const oldState = this.state;
-		const oldComments = this.comments;
-		const oldSemicolons = this.semicolons;
-		const oldStatementPath = this.statementPath;
-		const oldPrevStatement = this.prevStatement;
-		this.scope = {
-			topLevelScope: true,
-			inTry: false,
-			inShorthand: false,
-			isStrict: false,
-			isAsmJs: false,
-			definitions: new StackedMap()
-		};
-		/** @type {ParserState} */
-		this.state = state;
-		this.comments = comments;
-		this.semicolons = semicolons;
-		this.statementPath = [];
-		this.prevStatement = undefined;
-		if (this.hooks.program.call(ast, comments) === undefined) {
-			this.detectMode(ast.body);
-			this.preWalkStatements(ast.body);
-			this.prevStatement = undefined;
-			this.blockPreWalkStatements(ast.body);
-			this.prevStatement = undefined;
-			this.walkStatements(ast.body);
-		}
-		this.hooks.finish.call(ast, comments);
-		this.scope = oldScope;
-		/** @type {ParserState} */
-		this.state = oldState;
-		this.comments = oldComments;
-		this.semicolons = oldSemicolons;
-		this.statementPath = oldStatementPath;
-		this.prevStatement = oldPrevStatement;
-		return state;
+		// Info from Factory
+		/** @type {string} */
+		this._identifier = identifier;
+		/** @type {Module} */
+		this.rootModule = rootModule;
+		/** @type {Set<Module>} */
+		this._modules = modules;
+		this._runtime = runtime;
+		this.factoryMeta = rootModule && rootModule.factoryMeta;
 	}
 
-	evaluate(source) {
-		const ast = JavascriptParser._parse("(" + source + ")", {
-			sourceType: this.sourceType,
-			locations: false
-		});
-		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
-			throw new Error("evaluate: Source is not a expression");
-		}
-		return this.evaluateExpression(ast.body[0].expression);
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		throw new Error("Must not be called");
 	}
 
 	/**
-	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
-	 * @param {number} commentsStartPos source position from which annotation comments are checked
-	 * @returns {boolean} true, when the expression is pure
+	 * @returns {Set<string>} types available (do not mutate)
 	 */
-	isPure(expr, commentsStartPos) {
-		if (!expr) return true;
-		const result = this.hooks.isPure
-			.for(expr.type)
-			.call(expr, commentsStartPos);
-		if (typeof result === "boolean") return result;
-		switch (expr.type) {
-			case "ClassDeclaration":
-			case "ClassExpression": {
-				if (expr.body.type !== "ClassBody") return false;
-				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
-					return false;
-				}
-				const items =
-					/** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (
-						expr.body.body
-					);
-				return items.every(
-					item =>
-						(!item.computed ||
-							!item.key ||
-							this.isPure(item.key, item.range[0])) &&
-						(!item.static ||
-							!item.value ||
-							this.isPure(
-								item.value,
-								item.key ? item.key.range[1] : item.range[0]
-							))
-				);
-			}
-
-			case "FunctionDeclaration":
-			case "FunctionExpression":
-			case "ArrowFunctionExpression":
-			case "Literal":
-			case "PrivateIdentifier":
-				return true;
-
-			case "VariableDeclaration":
-				return expr.declarations.every(decl =>
-					this.isPure(decl.init, decl.range[0])
-				);
-
-			case "ConditionalExpression":
-				return (
-					this.isPure(expr.test, commentsStartPos) &&
-					this.isPure(expr.consequent, expr.test.range[1]) &&
-					this.isPure(expr.alternate, expr.consequent.range[1])
-				);
-
-			case "SequenceExpression":
-				return expr.expressions.every(expr => {
-					const pureFlag = this.isPure(expr, commentsStartPos);
-					commentsStartPos = expr.range[1];
-					return pureFlag;
-				});
-
-			case "CallExpression": {
-				const pureFlag =
-					expr.range[0] - commentsStartPos > 12 &&
-					this.getComments([commentsStartPos, expr.range[0]]).some(
-						comment =>
-							comment.type === "Block" &&
-							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
-					);
-				if (!pureFlag) return false;
-				commentsStartPos = expr.callee.range[1];
-				return expr.arguments.every(arg => {
-					if (arg.type === "SpreadElement") return false;
-					const pureFlag = this.isPure(arg, commentsStartPos);
-					commentsStartPos = arg.range[1];
-					return pureFlag;
-				});
-			}
-		}
-		const evaluated = this.evaluateExpression(expr);
-		return !evaluated.couldHaveSideEffects();
+	getSourceTypes() {
+		return TYPES;
 	}
 
-	getComments(range) {
-		const [rangeStart, rangeEnd] = range;
-		const compare = (comment, needle) => comment.range[0] - needle;
-		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
-		let commentsInRange = [];
-		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
-			commentsInRange.push(this.comments[idx]);
-			idx++;
-		}
-
-		return commentsInRange;
+	get modules() {
+		return Array.from(this._modules);
 	}
 
 	/**
-	 * @param {number} pos source code position
-	 * @returns {boolean} true when a semicolon has been inserted before this position, false if not
+	 * @returns {string} a unique identifier of the module
 	 */
-	isAsiPosition(pos) {
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
-		if (currentStatement === undefined) throw new Error("Not in statement");
-		return (
-			// Either asking directly for the end position of the current statement
-			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
-			// Or asking for the start position of the current statement,
-			// here we have to check multiple things
-			(currentStatement.range[0] === pos &&
-				// is there a previous statement which might be relevant?
-				this.prevStatement !== undefined &&
-				// is the end position of the previous statement an ASI position?
-				this.semicolons.has(this.prevStatement.range[1]))
-		);
+	identifier() {
+		return this._identifier;
 	}
 
 	/**
-	 * @param {number} pos source code position
-	 * @returns {void}
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
 	 */
-	unsetAsiPosition(pos) {
-		this.semicolons.delete(pos);
-	}
-
-	isStatementLevelExpression(expr) {
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
+	readableIdentifier(requestShortener) {
 		return (
-			expr === currentStatement ||
-			(currentStatement.type === "ExpressionStatement" &&
-				currentStatement.expression === expr)
+			this.rootModule.readableIdentifier(requestShortener) +
+			` + ${this._modules.size - 1} modules`
 		);
 	}
 
-	getTagData(name, tag) {
-		const info = this.scope.definitions.get(name);
-		if (info instanceof VariableInfo) {
-			let tagInfo = info.tagInfo;
-			while (tagInfo !== undefined) {
-				if (tagInfo.tag === tag) return tagInfo.data;
-				tagInfo = tagInfo.next;
-			}
-		}
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return this.rootModule.libIdent(options);
 	}
 
-	tagVariable(name, tag, data) {
-		const oldInfo = this.scope.definitions.get(name);
-		/** @type {VariableInfo} */
-		let newInfo;
-		if (oldInfo === undefined) {
-			newInfo = new VariableInfo(this.scope, name, {
-				tag,
-				data,
-				next: undefined
-			});
-		} else if (oldInfo instanceof VariableInfo) {
-			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
-				tag,
-				data,
-				next: oldInfo.tagInfo
-			});
-		} else {
-			newInfo = new VariableInfo(oldInfo, true, {
-				tag,
-				data,
-				next: undefined
-			});
-		}
-		this.scope.definitions.set(name, newInfo);
+	/**
+	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 */
+	nameForCondition() {
+		return this.rootModule.nameForCondition();
 	}
 
-	defineVariable(name) {
-		const oldInfo = this.scope.definitions.get(name);
-		// Don't redefine variable in same scope to keep existing tags
-		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
-			return;
-		this.scope.definitions.set(name, this.scope);
-	}
-
-	undefineVariable(name) {
-		this.scope.definitions.delete(name);
-	}
-
-	isVariableDefined(name) {
-		const info = this.scope.definitions.get(name);
-		if (info === undefined) return false;
-		if (info instanceof VariableInfo) {
-			return info.freeName === true;
-		}
-		return true;
-	}
-
-	/**
-	 * @param {string} name variable name
-	 * @returns {ExportedVariableInfo} info for this variable
-	 */
-	getVariableInfo(name) {
-		const value = this.scope.definitions.get(name);
-		if (value === undefined) {
-			return name;
-		} else {
-			return value;
-		}
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 */
+	getSideEffectsConnectionState(moduleGraph) {
+		return this.rootModule.getSideEffectsConnectionState(moduleGraph);
 	}
 
 	/**
-	 * @param {string} name variable name
-	 * @param {ExportedVariableInfo} variableInfo new info for this variable
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	setVariable(name, variableInfo) {
-		if (typeof variableInfo === "string") {
-			if (variableInfo === name) {
-				this.scope.definitions.delete(name);
-			} else {
-				this.scope.definitions.set(
-					name,
-					new VariableInfo(this.scope, variableInfo, undefined)
-				);
+	build(options, compilation, resolver, fs, callback) {
+		const { rootModule } = this;
+		this.buildInfo = {
+			strict: true,
+			cacheable: true,
+			moduleArgument: rootModule.buildInfo.moduleArgument,
+			exportsArgument: rootModule.buildInfo.exportsArgument,
+			fileDependencies: new LazySet(),
+			contextDependencies: new LazySet(),
+			missingDependencies: new LazySet(),
+			topLevelDeclarations: new Set(),
+			assets: undefined
+		};
+		this.buildMeta = rootModule.buildMeta;
+		this.clearDependenciesAndBlocks();
+		this.clearWarningsAndErrors();
+
+		for (const m of this._modules) {
+			// populate cacheable
+			if (!m.buildInfo.cacheable) {
+				this.buildInfo.cacheable = false;
 			}
-		} else {
-			this.scope.definitions.set(name, variableInfo);
-		}
-	}
 
-	parseCommentOptions(range) {
-		const comments = this.getComments(range);
-		if (comments.length === 0) {
-			return EMPTY_COMMENT_OPTIONS;
-		}
-		let options = {};
-		let errors = [];
-		for (const comment of comments) {
-			const { value } = comment;
-			if (value && webpackCommentRegExp.test(value)) {
-				// try compile only if webpack options comment is present
-				try {
-					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
-					Object.assign(options, val);
-				} catch (e) {
-					e.comment = comment;
-					errors.push(e);
+			// populate dependencies
+			for (const d of m.dependencies.filter(
+				dep =>
+					!(dep instanceof HarmonyImportDependency) ||
+					!this._modules.has(compilation.moduleGraph.getModule(dep))
+			)) {
+				this.dependencies.push(d);
+			}
+			// populate blocks
+			for (const d of m.blocks) {
+				this.blocks.push(d);
+			}
+
+			// populate warnings
+			const warnings = m.getWarnings();
+			if (warnings !== undefined) {
+				for (const warning of warnings) {
+					this.addWarning(warning);
 				}
 			}
-		}
-		return { options, errors };
-	}
 
-	/**
-	 * @param {MemberExpressionNode} expression a member expression
-	 * @returns {{ members: string[], object: ExpressionNode | SuperNode }} member names (reverse order) and remaining object
-	 */
-	extractMemberExpressionChain(expression) {
-		/** @type {AnyNode} */
-		let expr = expression;
-		const members = [];
-		while (expr.type === "MemberExpression") {
-			if (expr.computed) {
-				if (expr.property.type !== "Literal") break;
-				members.push(`${expr.property.value}`);
+			// populate errors
+			const errors = m.getErrors();
+			if (errors !== undefined) {
+				for (const error of errors) {
+					this.addError(error);
+				}
+			}
+
+			// populate topLevelDeclarations
+			if (m.buildInfo.topLevelDeclarations) {
+				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
+				if (topLevelDeclarations !== undefined) {
+					for (const decl of m.buildInfo.topLevelDeclarations) {
+						// reserved names will always be renamed
+						if (RESERVED_NAMES.has(decl)) continue;
+						// TODO actually this is incorrect since with renaming there could be more
+						// We should do the renaming during build
+						topLevelDeclarations.add(decl);
+					}
+				}
 			} else {
-				if (expr.property.type !== "Identifier") break;
-				members.push(expr.property.name);
+				this.buildInfo.topLevelDeclarations = undefined;
+			}
+
+			// populate assets
+			if (m.buildInfo.assets) {
+				if (this.buildInfo.assets === undefined) {
+					this.buildInfo.assets = Object.create(null);
+				}
+				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
+			}
+			if (m.buildInfo.assetsInfo) {
+				if (this.buildInfo.assetsInfo === undefined) {
+					this.buildInfo.assetsInfo = new Map();
+				}
+				for (const [key, value] of m.buildInfo.assetsInfo) {
+					this.buildInfo.assetsInfo.set(key, value);
+				}
 			}
-			expr = expr.object;
 		}
-		return {
-			members,
-			object: expr
-		};
+		callback();
 	}
 
 	/**
-	 * @param {string} varName variable name
-	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	getFreeInfoFromVariable(varName) {
-		const info = this.getVariableInfo(varName);
-		let name;
-		if (info instanceof VariableInfo) {
-			name = info.freeName;
-			if (typeof name !== "string") return undefined;
-		} else if (typeof info !== "string") {
-			return undefined;
-		} else {
-			name = info;
+	size(type) {
+		// Guess size from embedded modules
+		let size = 0;
+		for (const module of this._modules) {
+			size += module.size(type);
 		}
-		return { info, name };
+		return size;
 	}
 
-	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[]}} CallExpressionInfo */
-	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[]}} ExpressionExpressionInfo */
-
 	/**
-	 * @param {MemberExpressionNode} expression a member expression
-	 * @param {number} allowedTypes which types should be returned, presented in bit mask
-	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 * @private
+	 * @param {Module} rootModule the root of the concatenation
+	 * @param {Set<Module>} modulesSet a set of modules which should be concatenated
+	 * @param {RuntimeSpec} runtime for this runtime
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {ConcatenationEntry[]} concatenation list
 	 */
-	getMemberExpressionInfo(expression, allowedTypes) {
-		const { object, members } = this.extractMemberExpressionChain(expression);
-		switch (object.type) {
-			case "CallExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
-					return undefined;
-				let callee = object.callee;
-				let rootMembers = EMPTY_ARRAY;
-				if (callee.type === "MemberExpression") {
-					({ object: callee, members: rootMembers } =
-						this.extractMemberExpressionChain(callee));
+	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
+		/** @type {ConcatenationEntry[]} */
+		const list = [];
+		/** @type {Map<Module, RuntimeSpec | true>} */
+		const existingEntries = new Map();
+
+		/**
+		 * @param {Module} module a module
+		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
+		 */
+		const getConcatenatedImports = module => {
+			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
+			if (module === rootModule) {
+				for (const c of moduleGraph.getOutgoingConnections(this))
+					connections.push(c);
+			}
+			const references = connections
+				.filter(connection => {
+					if (!(connection.dependency instanceof HarmonyImportDependency))
+						return false;
+					return (
+						connection &&
+						connection.resolvedOriginModule === module &&
+						connection.module &&
+						connection.isTargetActive(runtime)
+					);
+				})
+				.map(connection => ({
+					connection,
+					sourceOrder: /** @type {HarmonyImportDependency} */ (
+						connection.dependency
+					).sourceOrder
+				}));
+			references.sort(
+				concatComparators(bySourceOrder, keepOriginalOrder(references))
+			);
+			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
+			const referencesMap = new Map();
+			for (const { connection } of references) {
+				const runtimeCondition = filterRuntime(runtime, r =>
+					connection.isTargetActive(r)
+				);
+				if (runtimeCondition === false) continue;
+				const module = connection.module;
+				const entry = referencesMap.get(module);
+				if (entry === undefined) {
+					referencesMap.set(module, { connection, runtimeCondition });
+					continue;
 				}
-				const rootName = getRootName(callee);
-				if (!rootName) return undefined;
-				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
-				const { info: rootInfo, name: resolvedRoot } = result;
-				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
-				return {
-					type: "call",
-					call: object,
-					calleeName,
-					rootInfo,
-					getCalleeMembers: memoize(() => rootMembers.reverse()),
-					name: objectAndMembersToName(`${calleeName}()`, members),
-					getMembers: memoize(() => members.reverse())
-				};
+				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
+					entry.runtimeCondition,
+					runtimeCondition,
+					runtime
+				);
 			}
-			case "Identifier":
-			case "MetaProperty":
-			case "ThisExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
-					return undefined;
-				const rootName = getRootName(object);
-				if (!rootName) return undefined;
+			return referencesMap.values();
+		};
 
-				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
-				const { info: rootInfo, name: resolvedRoot } = result;
-				return {
-					type: "expression",
-					name: objectAndMembersToName(resolvedRoot, members),
-					rootInfo,
-					getMembers: memoize(() => members.reverse())
-				};
+		/**
+		 * @param {ModuleGraphConnection} connection graph connection
+		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
+		 * @returns {void}
+		 */
+		const enterModule = (connection, runtimeCondition) => {
+			const module = connection.module;
+			if (!module) return;
+			const existingEntry = existingEntries.get(module);
+			if (existingEntry === true) {
+				return;
 			}
-		}
+			if (modulesSet.has(module)) {
+				existingEntries.set(module, true);
+				if (runtimeCondition !== true) {
+					throw new Error(
+						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
+							runtimeCondition
+						)}). This should not happen.`
+					);
+				}
+				const imports = getConcatenatedImports(module);
+				for (const { connection, runtimeCondition } of imports)
+					enterModule(connection, runtimeCondition);
+				list.push({
+					type: "concatenated",
+					module: connection.module,
+					runtimeCondition
+				});
+			} else {
+				if (existingEntry !== undefined) {
+					const reducedRuntimeCondition = subtractRuntimeCondition(
+						runtimeCondition,
+						existingEntry,
+						runtime
+					);
+					if (reducedRuntimeCondition === false) return;
+					runtimeCondition = reducedRuntimeCondition;
+					existingEntries.set(
+						connection.module,
+						mergeRuntimeConditionNonFalse(
+							existingEntry,
+							runtimeCondition,
+							runtime
+						)
+					);
+				} else {
+					existingEntries.set(connection.module, runtimeCondition);
+				}
+				if (list.length > 0) {
+					const lastItem = list[list.length - 1];
+					if (
+						lastItem.type === "external" &&
+						lastItem.module === connection.module
+					) {
+						lastItem.runtimeCondition = mergeRuntimeCondition(
+							lastItem.runtimeCondition,
+							runtimeCondition,
+							runtime
+						);
+						return;
+					}
+				}
+				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 connection.module;
+					},
+					runtimeCondition
+				});
+			}
+		};
+
+		existingEntries.set(rootModule, true);
+		const imports = getConcatenatedImports(rootModule);
+		for (const { connection, runtimeCondition } of imports)
+			enterModule(connection, runtimeCondition);
+		list.push({
+			type: "concatenated",
+			module: rootModule,
+			runtimeCondition: true
+		});
+
+		return list;
 	}
 
 	/**
-	 * @param {MemberExpressionNode} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 * @param {Module} rootModule the root module of the concatenation
+	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @returns {string} the identifier
 	 */
-	getNameForExpression(expression) {
-		return this.getMemberExpressionInfo(
-			expression,
-			ALLOWED_MEMBER_TYPES_EXPRESSION
+	static _createIdentifier(
+		rootModule,
+		modules,
+		associatedObjectForCache,
+		hashFunction = "md4"
+	) {
+		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
+			rootModule.context,
+			associatedObjectForCache
 		);
+		let identifiers = [];
+		for (const module of modules) {
+			identifiers.push(cachedMakePathsRelative(module.identifier()));
+		}
+		identifiers.sort();
+		const hash = createHash(hashFunction);
+		hash.update(identifiers.join(" "));
+		return rootModule.identifier() + "|" + hash.digest("hex");
 	}
 
 	/**
-	 * @param {string} code source code
-	 * @param {ParseOptions} options parsing options
-	 * @returns {ProgramNode} parsed ast
+	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
+	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
+	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
+	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
 	 */
-	static _parse(code, options) {
-		const type = options ? options.sourceType : "module";
-		/** @type {AcornOptions} */
-		const parserOptions = {
-			...defaultParserOptions,
-			allowReturnOutsideFunction: type === "script",
-			...options,
-			sourceType: type === "auto" ? "module" : type
-		};
-
-		/** @type {AnyNode} */
-		let ast;
-		let error;
-		let threw = false;
-		try {
-			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
-		} catch (e) {
-			error = e;
-			threw = true;
-		}
-
-		if (threw && type === "auto") {
-			parserOptions.sourceType = "script";
-			if (!("allowReturnOutsideFunction" in options)) {
-				parserOptions.allowReturnOutsideFunction = true;
-			}
-			if (Array.isArray(parserOptions.onComment)) {
-				parserOptions.onComment.length = 0;
-			}
-			try {
-				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
-				threw = false;
-			} catch (e) {
-				// we use the error from first parse try
-				// so nothing to do here
-			}
-		}
-
-		if (threw) {
-			throw error;
+	addCacheDependencies(
+		fileDependencies,
+		contextDependencies,
+		missingDependencies,
+		buildDependencies
+	) {
+		for (const module of this._modules) {
+			module.addCacheDependencies(
+				fileDependencies,
+				contextDependencies,
+				missingDependencies,
+				buildDependencies
+			);
 		}
-
-		return /** @type {ProgramNode} */ (ast);
 	}
-}
-
-module.exports = JavascriptParser;
-module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
-module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
-	ALLOWED_MEMBER_TYPES_EXPRESSION;
-module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
-	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
-
-
-/***/ }),
-
-/***/ 93998:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({
+		dependencyTemplates,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime: generationRuntime,
+		codeGenerationResults
+	}) {
+		/** @type {Set<string>} */
+		const runtimeRequirements = new Set();
+		const runtime = intersectRuntime(generationRuntime, this._runtime);
 
+		const requestShortener = runtimeTemplate.requestShortener;
+		// Meta info for each module
+		const [modulesWithInfo, moduleToInfoMap] = this._getModulesWithInfo(
+			moduleGraph,
+			runtime
+		);
 
+		// Set with modules that need a generated namespace object
+		/** @type {Set<ConcatenatedModuleInfo>} */
+		const neededNamespaceObjects = new Set();
 
-const UnsupportedFeatureWarning = __webpack_require__(42495);
-const ConstDependency = __webpack_require__(76911);
-const BasicEvaluatedExpression = __webpack_require__(950);
-
-/** @typedef {import("estree").Expression} ExpressionNode */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("./JavascriptParser")} JavascriptParser */
-
-/**
- * @param {JavascriptParser} parser the parser
- * @param {string} value the const value
- * @param {string[]=} runtimeRequirements runtime requirements
- * @returns {function(ExpressionNode): true} plugin function
- */
-exports.toConstantDependency = (parser, value, runtimeRequirements) => {
-	return function constDependency(expr) {
-		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
-		dep.loc = expr.loc;
-		parser.state.module.addPresentationalDependency(dep);
-		return true;
-	};
-};
-
-/**
- * @param {string} value the string value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
- */
-exports.evaluateToString = value => {
-	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
-	};
-};
-
-/**
- * @param {number} value the number value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
- */
-exports.evaluateToNumber = value => {
-	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
-	};
-};
-
-/**
- * @param {boolean} value the boolean value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
- */
-exports.evaluateToBoolean = value => {
-	return function booleanExpression(expr) {
-		return new BasicEvaluatedExpression()
-			.setBoolean(value)
-			.setRange(expr.range);
-	};
-};
-
-/**
- * @param {string} identifier identifier
- * @param {string} rootInfo rootInfo
- * @param {function(): string[]} getMembers getMembers
- * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
- */
-exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
-	return function identifierExpression(expr) {
-		let evaluatedExpression = new BasicEvaluatedExpression()
-			.setIdentifier(identifier, rootInfo, getMembers)
-			.setSideEffects(false)
-			.setRange(expr.range);
-		switch (truthy) {
-			case true:
-				evaluatedExpression.setTruthy();
-				break;
-			case null:
-				evaluatedExpression.setNullish(true);
-				break;
-			case false:
-				evaluatedExpression.setFalsy();
-				break;
+		// Generate source code and analyse scopes
+		// Prepare a ReplaceSource for the final source
+		for (const info of moduleToInfoMap.values()) {
+			this._analyseModule(
+				moduleToInfoMap,
+				info,
+				dependencyTemplates,
+				runtimeTemplate,
+				moduleGraph,
+				chunkGraph,
+				runtime,
+				codeGenerationResults
+			);
 		}
 
-		return evaluatedExpression;
-	};
-};
-
-exports.expressionIsUnsupported = (parser, message) => {
-	return function unsupportedExpression(expr) {
-		const dep = new ConstDependency("(void 0)", expr.range, null);
-		dep.loc = expr.loc;
-		parser.state.module.addPresentationalDependency(dep);
-		if (!parser.state.module) return;
-		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, expr.loc)
-		);
-		return true;
-	};
-};
-
-exports.skipTraversal = () => true;
-
-exports.approve = () => true;
-
+		// List of all used names to avoid conflicts
+		const allUsedNames = new Set(RESERVED_NAMES);
 
-/***/ }),
+		// List of additional names in scope for module references
+		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
+		const usedNamesInScopeInfo = new Map();
+		/**
+		 * @param {string} module module identifier
+		 * @param {string} id export id
+		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
+		 */
+		const getUsedNamesInScopeInfo = (module, id) => {
+			const key = `${module}-${id}`;
+			let info = usedNamesInScopeInfo.get(key);
+			if (info === undefined) {
+				info = {
+					usedNames: new Set(),
+					alreadyCheckedScopes: new Set()
+				};
+				usedNamesInScopeInfo.set(key, info);
+			}
+			return info;
+		};
 
-/***/ 98124:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+		// Set of already checked scopes
+		const ignoredScopes = new Set();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		// get all global names
+		for (const info of modulesWithInfo) {
+			if (info.type === "concatenated") {
+				// ignore symbols from moduleScope
+				if (info.moduleScope) {
+					ignoredScopes.add(info.moduleScope);
+				}
 
+				// The super class expression in class scopes behaves weird
+				// We get ranges of all super class expressions to make
+				// renaming to work correctly
+				const superClassCache = new WeakMap();
+				const getSuperClassExpressions = scope => {
+					const cacheEntry = superClassCache.get(scope);
+					if (cacheEntry !== undefined) return cacheEntry;
+					const superClassExpressions = [];
+					for (const childScope of scope.childScopes) {
+						if (childScope.type !== "class") continue;
+						const block = childScope.block;
+						if (
+							(block.type === "ClassDeclaration" ||
+								block.type === "ClassExpression") &&
+							block.superClass
+						) {
+							superClassExpressions.push({
+								range: block.superClass.range,
+								variables: childScope.variables
+							});
+						}
+					}
+					superClassCache.set(scope, superClassExpressions);
+					return superClassExpressions;
+				};
 
+				// add global symbols
+				if (info.globalScope) {
+					for (const reference of info.globalScope.through) {
+						const name = reference.identifier.name;
+						if (ConcatenationScope.isModuleReference(name)) {
+							const match = ConcatenationScope.matchModuleReference(name);
+							if (!match) continue;
+							const referencedInfo = modulesWithInfo[match.index];
+							if (referencedInfo.type === "reference")
+								throw new Error("Module reference can't point to a reference");
+							const binding = getFinalBinding(
+								moduleGraph,
+								referencedInfo,
+								match.ids,
+								moduleToInfoMap,
+								runtime,
+								requestShortener,
+								runtimeTemplate,
+								neededNamespaceObjects,
+								false,
+								info.module.buildMeta.strictHarmonyModule,
+								true
+							);
+							if (!binding.ids) continue;
+							const { usedNames, alreadyCheckedScopes } =
+								getUsedNamesInScopeInfo(
+									binding.info.module.identifier(),
+									"name" in binding ? binding.name : ""
+								);
+							for (const expr of getSuperClassExpressions(reference.from)) {
+								if (
+									expr.range[0] <= reference.identifier.range[0] &&
+									expr.range[1] >= reference.identifier.range[1]
+								) {
+									for (const variable of expr.variables) {
+										usedNames.add(variable.name);
+									}
+								}
+							}
+							addScopeSymbols(
+								reference.from,
+								usedNames,
+								alreadyCheckedScopes,
+								ignoredScopes
+							);
+						} else {
+							allUsedNames.add(name);
+						}
+					}
+				}
+			}
+		}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const { isSubset } = __webpack_require__(93347);
-const { getAllChunks } = __webpack_require__(91145);
+		// generate names for symbols
+		for (const info of moduleToInfoMap.values()) {
+			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
+				info.module.identifier(),
+				""
+			);
+			switch (info.type) {
+				case "concatenated": {
+					for (const variable of info.moduleScope.variables) {
+						const name = variable.name;
+						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
+							info.module.identifier(),
+							name
+						);
+						if (allUsedNames.has(name) || usedNames.has(name)) {
+							const references = getAllReferences(variable);
+							for (const ref of references) {
+								addScopeSymbols(
+									ref.from,
+									usedNames,
+									alreadyCheckedScopes,
+									ignoredScopes
+								);
+							}
+							const newName = this.findNewName(
+								name,
+								allUsedNames,
+								usedNames,
+								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) {
+									const maybeProperty =
+										path[1].type === "AssignmentPattern" &&
+										path[1].left === path[0]
+											? path[2]
+											: path[1];
+									if (
+										maybeProperty.type === "Property" &&
+										maybeProperty.shorthand
+									) {
+										source.insert(r[1], `: ${newName}`);
+										continue;
+									}
+								}
+								source.replace(r[0], r[1] - 1, newName);
+							}
+						} else {
+							allUsedNames.add(name);
+							info.internalNames.set(name, name);
+						}
+					}
+					let namespaceObjectName;
+					if (info.namespaceExportSymbol) {
+						namespaceObjectName = info.internalNames.get(
+							info.namespaceExportSymbol
+						);
+					} else {
+						namespaceObjectName = this.findNewName(
+							"namespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(namespaceObjectName);
+					}
+					info.namespaceObjectName = namespaceObjectName;
+					break;
+				}
+				case "external": {
+					const externalName = this.findNewName(
+						"",
+						allUsedNames,
+						namespaceObjectUsedNames,
+						info.module.readableIdentifier(requestShortener)
+					);
+					allUsedNames.add(externalName);
+					info.name = externalName;
+					break;
+				}
+			}
+			if (info.module.buildMeta.exportsType !== "namespace") {
+				const externalNameInterop = this.findNewName(
+					"namespaceObject",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopNamespaceObjectName = externalNameInterop;
+			}
+			if (
+				info.module.buildMeta.exportsType === "default" &&
+				info.module.buildMeta.defaultObject !== "redirect"
+			) {
+				const externalNameInterop = this.findNewName(
+					"namespaceObject2",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopNamespaceObject2Name = externalNameInterop;
+			}
+			if (
+				info.module.buildMeta.exportsType === "dynamic" ||
+				!info.module.buildMeta.exportsType
+			) {
+				const externalNameInterop = this.findNewName(
+					"default",
+					allUsedNames,
+					namespaceObjectUsedNames,
+					info.module.readableIdentifier(requestShortener)
+				);
+				allUsedNames.add(externalNameInterop);
+				info.interopDefaultAccessName = externalNameInterop;
+			}
+		}
 
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {(string|number)[]} EntryItem */
+		// Find and replace references to modules
+		for (const info of moduleToInfoMap.values()) {
+			if (info.type === "concatenated") {
+				for (const reference of info.globalScope.through) {
+					const name = reference.identifier.name;
+					const match = ConcatenationScope.matchModuleReference(name);
+					if (match) {
+						const referencedInfo = modulesWithInfo[match.index];
+						if (referencedInfo.type === "reference")
+							throw new Error("Module reference can't point to a reference");
+						const finalName = getFinalName(
+							moduleGraph,
+							referencedInfo,
+							match.ids,
+							moduleToInfoMap,
+							runtime,
+							requestShortener,
+							runtimeTemplate,
+							neededNamespaceObjects,
+							match.call,
+							!match.directImport,
+							info.module.buildMeta.strictHarmonyModule,
+							match.asiSafe
+						);
+						const r = reference.identifier.range;
+						const source = info.source;
+						// range is extended by 2 chars to cover the appended "._"
+						source.replace(r[0], r[1] + 1, finalName);
+					}
+				}
+			}
+		}
 
-const EXPORT_PREFIX = "var __webpack_exports__ = ";
+		// Map with all root exposed used exports
+		/** @type {Map<string, function(RequestShortener): string>} */
+		const exportsMap = new Map();
 
-/**
- * @param {ChunkGraph} chunkGraph chunkGraph
- * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
- * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
- * @param {Chunk} chunk chunk
- * @param {boolean} passive true: passive startup with on chunks loaded
- * @returns {string} runtime code
- */
-exports.generateEntryStartup = (
-	chunkGraph,
-	runtimeTemplate,
-	entries,
-	chunk,
-	passive
-) => {
-	/** @type {string[]} */
-	const runtime = [
-		`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-			`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
-			"moduleId"
-		)}`
-	];
+		// Set with all root exposed unused exports
+		/** @type {Set<string>} */
+		const unusedExports = new Set();
 
-	const runModule = id => {
-		return `__webpack_exec__(${JSON.stringify(id)})`;
-	};
-	const outputCombination = (chunks, moduleIds, final) => {
-		if (chunks.size === 0) {
-			runtime.push(
-				`${final ? EXPORT_PREFIX : ""}(${moduleIds.map(runModule).join(", ")});`
-			);
-		} else {
-			const fn = runtimeTemplate.returningFunction(
-				moduleIds.map(runModule).join(", ")
-			);
-			runtime.push(
-				`${final && !passive ? EXPORT_PREFIX : ""}${
-					passive
-						? RuntimeGlobals.onChunksLoaded
-						: RuntimeGlobals.startupEntrypoint
-				}(0, ${JSON.stringify(Array.from(chunks, c => c.id))}, ${fn});`
-			);
-			if (final && passive) {
-				runtime.push(`${EXPORT_PREFIX}${RuntimeGlobals.onChunksLoaded}();`);
+		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
+			moduleToInfoMap.get(this.rootModule)
+		);
+		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
+		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const name = exportInfo.name;
+			if (exportInfo.provided === false) continue;
+			const used = exportInfo.getUsedName(undefined, runtime);
+			if (!used) {
+				unusedExports.add(name);
+				continue;
 			}
+			exportsMap.set(used, requestShortener => {
+				try {
+					const finalName = getFinalName(
+						moduleGraph,
+						rootInfo,
+						[name],
+						moduleToInfoMap,
+						runtime,
+						requestShortener,
+						runtimeTemplate,
+						neededNamespaceObjects,
+						false,
+						false,
+						strictHarmonyModule,
+						true
+					);
+					return `/* ${
+						exportInfo.isReexport() ? "reexport" : "binding"
+					} */ ${finalName}`;
+				} catch (e) {
+					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
+					throw e;
+				}
+			});
 		}
-	};
 
-	let currentChunks = undefined;
-	let currentModuleIds = undefined;
+		const result = new ConcatSource();
 
-	for (const [module, entrypoint] of entries) {
-		const runtimeChunk = entrypoint.getRuntimeChunk();
-		const moduleId = chunkGraph.getModuleId(module);
-		const chunks = getAllChunks(entrypoint, chunk, runtimeChunk);
+		// add harmony compatibility flag (must be first because of possible circular dependencies)
 		if (
-			currentChunks &&
-			currentChunks.size === chunks.size &&
-			isSubset(currentChunks, chunks)
+			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
+			UsageState.Unused
 		) {
-			currentModuleIds.push(moduleId);
-		} else {
-			if (currentChunks) {
-				outputCombination(currentChunks, currentModuleIds);
-			}
-			currentChunks = chunks;
-			currentModuleIds = [moduleId];
+			result.add(`// ESM COMPAT FLAG\n`);
+			result.add(
+				runtimeTemplate.defineEsModuleFlagStatement({
+					exportsArgument: this.exportsArgument,
+					runtimeRequirements
+				})
+			);
 		}
-	}
 
-	// output current modules with export prefix
-	if (currentChunks) {
-		outputCombination(currentChunks, currentModuleIds, true);
-	}
-	runtime.push("");
-	return Template.asString(runtime);
-};
+		// define exports
+		if (exportsMap.size > 0) {
+			runtimeRequirements.add(RuntimeGlobals.exports);
+			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			const definitions = [];
+			for (const [key, value] of exportsMap) {
+				definitions.push(
+					`\n  ${JSON.stringify(key)}: ${runtimeTemplate.returningFunction(
+						value(requestShortener)
+					)}`
+				);
+			}
+			result.add(`\n// EXPORTS\n`);
+			result.add(
+				`${RuntimeGlobals.definePropertyGetters}(${
+					this.exportsArgument
+				}, {${definitions.join(",")}\n});\n`
+			);
+		}
 
-/**
- * @param {Hash} hash the hash to update
- * @param {ChunkGraph} chunkGraph chunkGraph
- * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
- * @param {Chunk} chunk chunk
- * @returns {void}
- */
-exports.updateHashForEntryStartup = (hash, chunkGraph, entries, chunk) => {
-	for (const [module, entrypoint] of entries) {
-		const runtimeChunk = entrypoint.getRuntimeChunk();
-		const moduleId = chunkGraph.getModuleId(module);
-		hash.update(`${moduleId}`);
-		for (const c of getAllChunks(entrypoint, chunk, runtimeChunk))
-			hash.update(`${c.id}`);
-	}
-};
+		// list unused exports
+		if (unusedExports.size > 0) {
+			result.add(
+				`\n// UNUSED EXPORTS: ${joinIterableWithComma(unusedExports)}\n`
+			);
+		}
 
-/**
- * @param {Chunk} chunk the chunk
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
- * @returns {Set<number | string>} initially fulfilled chunk ids
- */
-exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
-	const initialChunkIds = new Set(chunk.ids);
-	for (const c of chunk.getAllInitialChunks()) {
-		if (c === chunk || filterFn(c, chunkGraph)) continue;
-		for (const id of c.ids) initialChunkIds.add(id);
-	}
-	return initialChunkIds;
-};
+		// generate namespace objects
+		const namespaceObjectSources = new Map();
+		for (const info of neededNamespaceObjects) {
+			if (info.namespaceExportSymbol) continue;
+			const nsObj = [];
+			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			for (const exportInfo of exportsInfo.orderedExports) {
+				if (exportInfo.provided === false) continue;
+				const usedName = exportInfo.getUsedName(undefined, runtime);
+				if (usedName) {
+					const finalName = getFinalName(
+						moduleGraph,
+						info,
+						[exportInfo.name],
+						moduleToInfoMap,
+						runtime,
+						requestShortener,
+						runtimeTemplate,
+						neededNamespaceObjects,
+						false,
+						undefined,
+						info.module.buildMeta.strictHarmonyModule,
+						true
+					);
+					nsObj.push(
+						`\n  ${JSON.stringify(
+							usedName
+						)}: ${runtimeTemplate.returningFunction(finalName)}`
+					);
+				}
+			}
+			const name = info.namespaceObjectName;
+			const defineGetters =
+				nsObj.length > 0
+					? `${RuntimeGlobals.definePropertyGetters}(${name}, {${nsObj.join(
+							","
+					  )}\n});\n`
+					: "";
+			if (nsObj.length > 0)
+				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			namespaceObjectSources.set(
+				info,
+				`
+// NAMESPACE OBJECT: ${info.module.readableIdentifier(requestShortener)}
+var ${name} = {};
+${RuntimeGlobals.makeNamespaceObject}(${name});
+${defineGetters}`
+			);
+			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		}
 
+		// define required namespace objects (must be before evaluation modules)
+		for (const info of modulesWithInfo) {
+			if (info.type === "concatenated") {
+				const source = namespaceObjectSources.get(info);
+				if (!source) continue;
+				result.add(source);
+			}
+		}
 
-/***/ }),
+		const chunkInitFragments = [];
 
-/***/ 90490:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		// evaluate modules in order
+		for (const rawInfo of modulesWithInfo) {
+			let name;
+			let isConditional = false;
+			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
+			switch (info.type) {
+				case "concatenated": {
+					result.add(
+						`\n;// CONCATENATED MODULE: ${info.module.readableIdentifier(
+							requestShortener
+						)}\n`
+					);
+					result.add(info.source);
+					if (info.chunkInitFragments) {
+						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
+					}
+					if (info.runtimeRequirements) {
+						for (const r of info.runtimeRequirements) {
+							runtimeRequirements.add(r);
+						}
+					}
+					name = info.namespaceObjectName;
+					break;
+				}
+				case "external": {
+					result.add(
+						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
+							requestShortener
+						)}\n`
+					);
+					runtimeRequirements.add(RuntimeGlobals.require);
+					const { runtimeCondition } =
+						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
+					const condition = runtimeTemplate.runtimeConditionExpression({
+						chunkGraph,
+						runtimeCondition,
+						runtime,
+						runtimeRequirements
+					});
+					if (condition !== "true") {
+						isConditional = true;
+						result.add(`if (${condition}) {\n`);
+					}
+					result.add(
+						`var ${info.name} = __webpack_require__(${JSON.stringify(
+							chunkGraph.getModuleId(info.module)
+						)});`
+					);
+					name = info.name;
+					break;
+				}
+				default:
+					// @ts-expect-error never is expected here
+					throw new Error(`Unsupported concatenation entry type ${info.type}`);
+			}
+			if (info.interopNamespaceObjectUsed) {
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				result.add(
+					`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
+				);
+			}
+			if (info.interopNamespaceObject2Used) {
+				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
+				result.add(
+					`\nvar ${info.interopNamespaceObject2Name} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
+				);
+			}
+			if (info.interopDefaultAccessUsed) {
+				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+				result.add(
+					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
+				);
+			}
+			if (isConditional) {
+				result.add("\n}");
+			}
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		const data = new Map();
+		if (chunkInitFragments.length > 0)
+			data.set("chunkInitFragments", chunkInitFragments);
 
+		/** @type {CodeGenerationResult} */
+		const resultEntry = {
+			sources: new Map([["javascript", new CachedSource(result)]]),
+			data,
+			runtimeRequirements
+		};
 
+		return resultEntry;
+	}
 
-const { register } = __webpack_require__(8282);
+	/**
+	 * @param {Map<Module, ModuleInfo>} modulesMap modulesMap
+	 * @param {ModuleInfo} info info
+	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
+	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+	 * @param {ModuleGraph} moduleGraph moduleGraph
+	 * @param {ChunkGraph} chunkGraph chunkGraph
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
+	 */
+	_analyseModule(
+		modulesMap,
+		info,
+		dependencyTemplates,
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtime,
+		codeGenerationResults
+	) {
+		if (info.type === "concatenated") {
+			const m = info.module;
+			try {
+				// Create a concatenation scope to track and capture information
+				const concatenationScope = new ConcatenationScope(modulesMap, info);
 
-class JsonData {
-	constructor(data) {
-		this._buffer = undefined;
-		this._data = undefined;
-		if (Buffer.isBuffer(data)) {
-			this._buffer = data;
-		} else {
-			this._data = data;
+				// TODO cache codeGeneration results
+				const codeGenResult = m.codeGeneration({
+					dependencyTemplates,
+					runtimeTemplate,
+					moduleGraph,
+					chunkGraph,
+					runtime,
+					concatenationScope,
+					codeGenerationResults
+				});
+				const source = codeGenResult.sources.get("javascript");
+				const data = codeGenResult.data;
+				const chunkInitFragments = data && data.get("chunkInitFragments");
+				const code = source.source().toString();
+				let ast;
+				try {
+					ast = JavascriptParser._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.runtimeRequirements = codeGenResult.runtimeRequirements;
+				info.ast = ast;
+				info.internalSource = source;
+				info.source = resultSource;
+				info.chunkInitFragments = chunkInitFragments;
+				info.globalScope = globalScope;
+				info.moduleScope = moduleScope;
+			} catch (err) {
+				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
+				throw err;
+			}
 		}
 	}
 
-	get() {
-		if (this._data === undefined && this._buffer !== undefined) {
-			this._data = JSON.parse(this._buffer.toString());
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {[ModuleInfoOrReference[], Map<Module, ModuleInfo>]} module info items
+	 */
+	_getModulesWithInfo(moduleGraph, runtime) {
+		const orderedConcatenationList = this._createConcatenationList(
+			this.rootModule,
+			this._modules,
+			runtime,
+			moduleGraph
+		);
+		/** @type {Map<Module, ModuleInfo>} */
+		const map = new Map();
+		const list = orderedConcatenationList.map((info, index) => {
+			let item = map.get(info.module);
+			if (item === undefined) {
+				switch (info.type) {
+					case "concatenated":
+						item = {
+							type: "concatenated",
+							module: info.module,
+							index,
+							ast: undefined,
+							internalSource: undefined,
+							runtimeRequirements: undefined,
+							source: undefined,
+							globalScope: undefined,
+							moduleScope: undefined,
+							internalNames: new Map(),
+							exportMap: undefined,
+							rawExportMap: undefined,
+							namespaceExportSymbol: undefined,
+							namespaceObjectName: undefined,
+							interopNamespaceObjectUsed: false,
+							interopNamespaceObjectName: undefined,
+							interopNamespaceObject2Used: false,
+							interopNamespaceObject2Name: undefined,
+							interopDefaultAccessUsed: false,
+							interopDefaultAccessName: undefined
+						};
+						break;
+					case "external":
+						item = {
+							type: "external",
+							module: info.module,
+							runtimeCondition: info.runtimeCondition,
+							index,
+							name: undefined,
+							interopNamespaceObjectUsed: false,
+							interopNamespaceObjectName: undefined,
+							interopNamespaceObject2Used: false,
+							interopNamespaceObject2Name: undefined,
+							interopDefaultAccessUsed: false,
+							interopDefaultAccessName: undefined
+						};
+						break;
+					default:
+						throw new Error(
+							`Unsupported concatenation entry type ${info.type}`
+						);
+				}
+				map.set(item.module, item);
+				return item;
+			} else {
+				/** @type {ReferenceToModuleInfo} */
+				const ref = {
+					type: "reference",
+					runtimeCondition: info.runtimeCondition,
+					target: item
+				};
+				return ref;
+			}
+		});
+		return [list, map];
+	}
+
+	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
+		let name = oldName;
+
+		if (name === ConcatenationScope.DEFAULT_EXPORT) {
+			name = "";
 		}
-		return this._data;
+		if (name === ConcatenationScope.NAMESPACE_OBJECT_EXPORT) {
+			name = "namespaceObject";
+		}
+
+		// 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;
 	}
-}
 
-register(JsonData, "webpack/lib/json/JsonData", null, {
-	serialize(obj, { write }) {
-		if (obj._buffer === undefined && obj._data !== undefined) {
-			obj._buffer = Buffer.from(JSON.stringify(obj._data));
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		for (const info of this._createConcatenationList(
+			this.rootModule,
+			this._modules,
+			intersectRuntime(runtime, this._runtime),
+			chunkGraph.moduleGraph
+		)) {
+			switch (info.type) {
+				case "concatenated":
+					info.module.updateHash(hash, context);
+					break;
+				case "external":
+					hash.update(`${chunkGraph.getModuleId(info.module)}`);
+					// TODO runtimeCondition
+					break;
+			}
 		}
-		write(obj._buffer);
-	},
-	deserialize({ read }) {
-		return new JsonData(read());
+		super.updateHash(hash, context);
 	}
-});
 
-module.exports = JsonData;
+	static deserialize(context) {
+		const obj = new ConcatenatedModule({
+			identifier: undefined,
+			rootModule: undefined,
+			modules: undefined,
+			runtime: undefined
+		});
+		obj.deserialize(context);
+		return obj;
+	}
+}
+
+makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
+
+module.exports = ConcatenatedModule;
 
 
 /***/ }),
 
-/***/ 70393:
+/***/ 96260:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -102384,196 +101759,90 @@ module.exports = JsonData;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const ConcatenationScope = __webpack_require__(98229);
-const { UsageState } = __webpack_require__(63686);
-const Generator = __webpack_require__(93401);
-const RuntimeGlobals = __webpack_require__(16475);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-const stringifySafe = data => {
-	const stringified = JSON.stringify(data);
-	if (!stringified) {
-		return undefined; // Invalid JSON
-	}
+const { STAGE_BASIC } = __webpack_require__(80057);
 
-	return stringified.replace(/\u2028|\u2029/g, str =>
-		str === "\u2029" ? "\\u2029" : "\\u2028"
-	); // invalid in JavaScript but valid JSON
-};
-
-/**
- * @param {Object} data data (always an object or array)
- * @param {ExportsInfo} exportsInfo exports info
- * @param {RuntimeSpec} runtime the runtime
- * @returns {Object} reduced data
- */
-const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
-	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
-		return data;
-	const isArray = Array.isArray(data);
-	const reducedData = isArray ? [] : {};
-	for (const key of Object.keys(data)) {
-		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
-		const used = exportInfo.getUsed(runtime);
-		if (used === UsageState.Unused) continue;
-
-		let value;
-		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
-			value = createObjectForExportsInfo(
-				data[key],
-				exportInfo.exportsInfo,
-				runtime
-			);
-		} else {
-			value = data[key];
-		}
-		const name = exportInfo.getUsedName(key, runtime);
-		reducedData[name] = value;
-	}
-	if (isArray) {
-		let arrayLengthWhenUsed =
-			exportsInfo.getReadOnlyExportInfo("length").getUsed(runtime) !==
-			UsageState.Unused
-				? data.length
-				: undefined;
-
-		let sizeObjectMinusArray = 0;
-		for (let i = 0; i < reducedData.length; i++) {
-			if (reducedData[i] === undefined) {
-				sizeObjectMinusArray -= 2;
-			} else {
-				sizeObjectMinusArray += `${i}`.length + 3;
-			}
-		}
-		if (arrayLengthWhenUsed !== undefined) {
-			sizeObjectMinusArray +=
-				`${arrayLengthWhenUsed}`.length +
-				8 -
-				(arrayLengthWhenUsed - reducedData.length) * 2;
-		}
-		if (sizeObjectMinusArray < 0)
-			return Object.assign(
-				arrayLengthWhenUsed === undefined
-					? {}
-					: { length: arrayLengthWhenUsed },
-				reducedData
-			);
-		const generatedLength =
-			arrayLengthWhenUsed !== undefined
-				? Math.max(arrayLengthWhenUsed, reducedData.length)
-				: reducedData.length;
-		for (let i = 0; i < generatedLength; i++) {
-			if (reducedData[i] === undefined) {
-				reducedData[i] = 0;
-			}
-		}
-	}
-	return reducedData;
-};
-
-const TYPES = new Set(["javascript"]);
-
-class JsonGenerator extends Generator {
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
-
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		let data =
-			module.buildInfo &&
-			module.buildInfo.jsonData &&
-			module.buildInfo.jsonData.get();
-		if (!data) return 0;
-		return stringifySafe(data).length + 10;
-	}
-
-	/**
-	 * @param {NormalModule} module module for which the bailout reason should be determined
-	 * @param {ConcatenationBailoutReasonContext} context context
-	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
-	 */
-	getConcatenationBailoutReason(module, context) {
-		return undefined;
-	}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compiler")} Compiler */
 
+class EnsureChunkConditionsPlugin {
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate(
-		module,
-		{
-			moduleGraph,
-			runtimeTemplate,
-			runtimeRequirements,
-			runtime,
-			concatenationScope
-		}
-	) {
-		const data =
-			module.buildInfo &&
-			module.buildInfo.jsonData &&
-			module.buildInfo.jsonData.get();
-		if (data === undefined) {
-			return new RawSource(
-				runtimeTemplate.missingModuleStatement({
-					request: module.rawRequest
-				})
-			);
-		}
-		const exportsInfo = moduleGraph.getExportsInfo(module);
-		let finalJson =
-			typeof data === "object" &&
-			data &&
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused
-				? createObjectForExportsInfo(data, exportsInfo, runtime)
-				: data;
-		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
-		const jsonStr = stringifySafe(finalJson);
-		const jsonExpr =
-			jsonStr.length > 20 && typeof finalJson === "object"
-				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
-				: jsonStr;
-		let content;
-		if (concatenationScope) {
-			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
-				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-			} = ${jsonExpr};`;
-			concatenationScope.registerNamespaceExport(
-				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
-			);
-		} else {
-			runtimeRequirements.add(RuntimeGlobals.module);
-			content = `${module.moduleArgument}.exports = ${jsonExpr};`;
-		}
-		return new RawSource(content);
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"EnsureChunkConditionsPlugin",
+			compilation => {
+				const handler = chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					// These sets are hoisted here to save memory
+					// They are cleared at the end of every loop
+					/** @type {Set<Chunk>} */
+					const sourceChunks = new Set();
+					/** @type {Set<ChunkGroup>} */
+					const chunkGroups = new Set();
+					for (const module of compilation.modules) {
+						if (!module.hasChunkCondition()) continue;
+						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+							if (!module.chunkCondition(chunk, compilation)) {
+								sourceChunks.add(chunk);
+								for (const group of chunk.groupsIterable) {
+									chunkGroups.add(group);
+								}
+							}
+						}
+						if (sourceChunks.size === 0) continue;
+						/** @type {Set<Chunk>} */
+						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, compilation)) {
+									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) {
+							chunkGraph.disconnectChunkAndModule(sourceChunk, module);
+						}
+						for (const targetChunk of targetChunks) {
+							chunkGraph.connectChunkAndModule(targetChunk, module);
+						}
+						sourceChunks.clear();
+						chunkGroups.clear();
+					}
+				};
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "EnsureChunkConditionsPlugin",
+						stage: STAGE_BASIC
+					},
+					handler
+				);
+			}
+		);
 	}
 }
-
-module.exports = JsonGenerator;
+module.exports = EnsureChunkConditionsPlugin;
 
 
 /***/ }),
 
-/***/ 86770:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 50089:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -102583,424 +101852,476 @@ module.exports = JsonGenerator;
 
 
 
-const createSchemaValidation = __webpack_require__(32540);
-const JsonGenerator = __webpack_require__(70393);
-const JsonParser = __webpack_require__(41090);
-
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
 
-const validate = createSchemaValidation(
-	__webpack_require__(54094),
-	() => __webpack_require__(50166),
-	{
-		name: "Json Modules Plugin",
-		baseDataPath: "parser"
-	}
-);
-
-class JsonModulesPlugin {
+class FlagIncludedChunksPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"JsonModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.createParser
-					.for("json")
-					.tap("JsonModulesPlugin", parserOptions => {
-						validate(parserOptions);
-
-						return new JsonParser(parserOptions);
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("json")
-					.tap("JsonModulesPlugin", () => {
-						return new JsonGenerator();
-					});
-			}
-		);
-	}
-}
-
-module.exports = JsonModulesPlugin;
-
-
-/***/ }),
+		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
+			compilation.hooks.optimizeChunkIds.tap(
+				"FlagIncludedChunksPlugin",
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
 
-/***/ 41090:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					// 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)
+					/** @type {WeakMap<Module, number>} */
+					const moduleBits = new WeakMap();
+					const modulesCount = compilation.modules.size;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					// 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++;
+					}
 
+					// iterate all chunks to generate bitmaps
+					/** @type {WeakMap<Chunk, number>} */
+					const chunkModulesHash = new WeakMap();
+					for (const chunk of chunks) {
+						let hash = 0;
+						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+							hash |= moduleBits.get(module);
+						}
+						chunkModulesHash.set(chunk, hash);
+					}
 
-const parseJson = __webpack_require__(15235);
-const Parser = __webpack_require__(11715);
-const JsonExportsDependency = __webpack_require__(750);
-const JsonData = __webpack_require__(90490);
+					for (const chunkA of chunks) {
+						const chunkAHash = chunkModulesHash.get(chunkA);
+						const chunkAModulesCount =
+							chunkGraph.getNumberOfChunkModules(chunkA);
+						if (chunkAModulesCount === 0) continue;
+						let bestModule = undefined;
+						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
+							if (
+								bestModule === undefined ||
+								chunkGraph.getNumberOfModuleChunks(bestModule) >
+									chunkGraph.getNumberOfModuleChunks(module)
+							)
+								bestModule = module;
+						}
+						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
+							bestModule
+						)) {
+							// as we iterate the same iterables twice
+							// skip if we find ourselves
+							if (chunkA === chunkB) continue;
 
-/** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+							const chunkBModulesCount =
+								chunkGraph.getNumberOfChunkModules(chunkB);
 
-class JsonParser extends Parser {
-	/**
-	 * @param {JsonModulesPluginParserOptions} options parser options
-	 */
-	constructor(options) {
-		super();
-		this.options = options || {};
-	}
+							// ids for empty chunks are not included
+							if (chunkBModulesCount === 0) continue;
 
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
-		}
+							// 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;
 
-		/** @type {JsonModulesPluginParserOptions["parse"]} */
-		const parseFn =
-			typeof this.options.parse === "function" ? this.options.parse : parseJson;
+							// is chunkA in chunkB?
 
-		const data =
-			typeof source === "object"
-				? source
-				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
+							// we do a cheap check for the hash value
+							const chunkBHash = chunkModulesHash.get(chunkB);
+							if ((chunkBHash & chunkAHash) !== chunkAHash) continue;
 
-		state.module.buildInfo.jsonData = new JsonData(data);
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject =
-			typeof data === "object" ? "redirect-warn" : false;
-		state.module.addDependency(
-			new JsonExportsDependency(JsonExportsDependency.getExportsFromData(data))
-		);
-		return state;
+							// compare all modules
+							for (const m of chunkGraph.getChunkModulesIterable(chunkA)) {
+								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
+							}
+							chunkB.ids.push(chunkA.id);
+						}
+					}
+				}
+			);
+		});
 	}
 }
-
-module.exports = JsonParser;
+module.exports = FlagIncludedChunksPlugin;
 
 
 /***/ }),
 
-/***/ 26030:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 38988:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Sergey Melyukov @smelukov
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const JavascriptModulesPlugin = __webpack_require__(89464);
+const { UsageState } = __webpack_require__(63686);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const COMMON_LIBRARY_NAME_MESSAGE =
-	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
 
 /**
- * @template T
- * @typedef {Object} LibraryContext
- * @property {Compilation} compilation
- * @property {ChunkGraph} chunkGraph
- * @property {T} options
+ * @typedef {Object} StateObject
+ * @property {InnerGraph} innerGraph
+ * @property {TopLevelSymbol=} currentTopLevelSymbol
+ * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
  */
 
+/** @typedef {false|StateObject} State */
+
+/** @type {WeakMap<ParserState, State>} */
+const parserStateMap = new WeakMap();
+const topLevelSymbolTag = Symbol("top level symbol");
+
 /**
- * @template T
+ * @param {ParserState} parserState parser state
+ * @returns {State} state
  */
-class AbstractLibraryPlugin {
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.pluginName name of the plugin
-	 * @param {LibraryType} options.type used library type
-	 */
-	constructor({ pluginName, type }) {
-		this._pluginName = pluginName;
-		this._type = type;
-		this._parseCache = new WeakMap();
-	}
-
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { _pluginName } = this;
-		compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
-			compilation.hooks.finishModules.tap(
-				{ name: _pluginName, stage: 10 },
-				() => {
-					for (const [
-						name,
-						{
-							dependencies: deps,
-							options: { library }
-						}
-					] of compilation.entries) {
-						const options = this._parseOptionsCached(
-							library !== undefined
-								? library
-								: compilation.outputOptions.library
-						);
-						if (options !== false) {
-							const dep = deps[deps.length - 1];
-							if (dep) {
-								const module = compilation.moduleGraph.getModule(dep);
-								if (module) {
-									this.finishEntryModule(module, name, {
-										options,
-										compilation,
-										chunkGraph: compilation.chunkGraph
-									});
-								}
-							}
-						}
-					}
-				}
-			);
+function getState(parserState) {
+	return parserStateMap.get(parserState);
+}
 
-			const getOptionsForChunk = chunk => {
-				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
-					return false;
-				const options = chunk.getEntryOptions();
-				const library = options && options.library;
-				return this._parseOptionsCached(
-					library !== undefined ? library : compilation.outputOptions.library
-				);
-			};
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.bailout = parserState => {
+	parserStateMap.set(parserState, false);
+};
 
-			if (
-				this.render !== AbstractLibraryPlugin.prototype.render ||
-				this.runtimeRequirements !==
-					AbstractLibraryPlugin.prototype.runtimeRequirements
-			) {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					_pluginName,
-					(chunk, set, { chunkGraph }) => {
-						const options = getOptionsForChunk(chunk);
-						if (options !== false) {
-							this.runtimeRequirements(chunk, set, {
-								options,
-								compilation,
-								chunkGraph
-							});
-						}
-					}
-				);
-			}
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {void}
+ */
+exports.enable = parserState => {
+	const state = parserStateMap.get(parserState);
+	if (state === false) {
+		return;
+	}
+	parserStateMap.set(parserState, {
+		innerGraph: new Map(),
+		currentTopLevelSymbol: undefined,
+		usageCallbackMap: new Map()
+	});
+};
 
-			const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+/**
+ * @param {ParserState} parserState parser state
+ * @returns {boolean} true, when enabled
+ */
+exports.isEnabled = parserState => {
+	const state = parserStateMap.get(parserState);
+	return !!state;
+};
 
-			if (this.render !== AbstractLibraryPlugin.prototype.render) {
-				hooks.render.tap(_pluginName, (source, renderContext) => {
-					const options = getOptionsForChunk(renderContext.chunk);
-					if (options === false) return source;
-					return this.render(source, renderContext, {
-						options,
-						compilation,
-						chunkGraph: compilation.chunkGraph
-					});
-				});
-			}
+/**
+ * @param {ParserState} state parser state
+ * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
+ * @param {string | TopLevelSymbol | true} usage usage data
+ * @returns {void}
+ */
+exports.addUsage = (state, symbol, usage) => {
+	const innerGraphState = getState(state);
 
-			if (
-				this.embedInRuntimeBailout !==
-				AbstractLibraryPlugin.prototype.embedInRuntimeBailout
-			) {
-				hooks.embedInRuntimeBailout.tap(
-					_pluginName,
-					(module, renderContext) => {
-						const options = getOptionsForChunk(renderContext.chunk);
-						if (options === false) return;
-						return this.embedInRuntimeBailout(module, renderContext, {
-							options,
-							compilation,
-							chunkGraph: compilation.chunkGraph
-						});
-					}
-				);
-			}
+	if (innerGraphState) {
+		const { innerGraph } = innerGraphState;
+		const info = innerGraph.get(symbol);
+		if (usage === true) {
+			innerGraph.set(symbol, true);
+		} else if (info === undefined) {
+			innerGraph.set(symbol, new Set([usage]));
+		} else if (info !== true) {
+			info.add(usage);
+		}
+	}
+};
 
-			if (
-				this.strictRuntimeBailout !==
-				AbstractLibraryPlugin.prototype.strictRuntimeBailout
-			) {
-				hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
-					const options = getOptionsForChunk(renderContext.chunk);
-					if (options === false) return;
-					return this.strictRuntimeBailout(renderContext, {
-						options,
-						compilation,
-						chunkGraph: compilation.chunkGraph
-					});
-				});
-			}
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} name name of variable
+ * @param {string | TopLevelSymbol | true} usage usage data
+ * @returns {void}
+ */
+exports.addVariableUsage = (parser, name, usage) => {
+	const symbol =
+		/** @type {TopLevelSymbol} */ (
+			parser.getTagData(name, topLevelSymbolTag)
+		) || exports.tagTopLevelSymbol(parser, name);
+	if (symbol) {
+		exports.addUsage(parser.state, symbol, usage);
+	}
+};
 
-			if (
-				this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup
-			) {
-				hooks.renderStartup.tap(
-					_pluginName,
-					(source, module, renderContext) => {
-						const options = getOptionsForChunk(renderContext.chunk);
-						if (options === false) return source;
-						return this.renderStartup(source, module, renderContext, {
-							options,
-							compilation,
-							chunkGraph: compilation.chunkGraph
-						});
+/**
+ * @param {ParserState} state parser state
+ * @returns {void}
+ */
+exports.inferDependencyUsage = state => {
+	const innerGraphState = getState(state);
+
+	if (!innerGraphState) {
+		return;
+	}
+
+	const { innerGraph, usageCallbackMap } = innerGraphState;
+	const processed = new Map();
+	// flatten graph to terminal nodes (string, undefined or true)
+	const nonTerminal = new Set(innerGraph.keys());
+	while (nonTerminal.size > 0) {
+		for (const key of nonTerminal) {
+			/** @type {Set<string|TopLevelSymbol> | true} */
+			let newSet = new Set();
+			let isTerminal = true;
+			const value = innerGraph.get(key);
+			let alreadyProcessed = processed.get(key);
+			if (alreadyProcessed === undefined) {
+				alreadyProcessed = new Set();
+				processed.set(key, alreadyProcessed);
+			}
+			if (value !== true && value !== undefined) {
+				for (const item of value) {
+					alreadyProcessed.add(item);
+				}
+				for (const item of value) {
+					if (typeof item === "string") {
+						newSet.add(item);
+					} else {
+						const itemValue = innerGraph.get(item);
+						if (itemValue === true) {
+							newSet = true;
+							break;
+						}
+						if (itemValue !== undefined) {
+							for (const i of itemValue) {
+								if (i === key) continue;
+								if (alreadyProcessed.has(i)) continue;
+								newSet.add(i);
+								if (typeof i !== "string") {
+									isTerminal = false;
+								}
+							}
+						}
 					}
-				);
+				}
+				if (newSet === true) {
+					innerGraph.set(key, true);
+				} else if (newSet.size === 0) {
+					innerGraph.set(key, undefined);
+				} else {
+					innerGraph.set(key, newSet);
+				}
 			}
+			if (isTerminal) {
+				nonTerminal.delete(key);
 
-			hooks.chunkHash.tap(_pluginName, (chunk, hash, context) => {
-				const options = getOptionsForChunk(chunk);
-				if (options === false) return;
-				this.chunkHash(chunk, hash, context, {
-					options,
-					compilation,
-					chunkGraph: compilation.chunkGraph
-				});
-			});
-		});
+				// For the global key, merge with all other keys
+				if (key === null) {
+					const globalValue = innerGraph.get(null);
+					if (globalValue) {
+						for (const [key, value] of innerGraph) {
+							if (key !== null && value !== true) {
+								if (globalValue === true) {
+									innerGraph.set(key, true);
+								} else {
+									const newSet = new Set(value);
+									for (const item of globalValue) {
+										newSet.add(item);
+									}
+									innerGraph.set(key, newSet);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
 	}
 
-	/**
-	 * @param {LibraryOptions=} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	_parseOptionsCached(library) {
-		if (!library) return false;
-		if (library.type !== this._type) return false;
-		const cacheEntry = this._parseCache.get(library);
-		if (cacheEntry !== undefined) return cacheEntry;
-		const result = this.parseOptions(library);
-		this._parseCache.set(library, result);
-		return result;
+	/** @type {Map<Dependency, true | Set<string>>} */
+	for (const [symbol, callbacks] of usageCallbackMap) {
+		const usage = /** @type {true | Set<string> | undefined} */ (
+			innerGraph.get(symbol)
+		);
+		for (const callback of callbacks) {
+			callback(usage === undefined ? false : usage);
+		}
 	}
+};
 
-	/* istanbul ignore next */
-	/**
-	 * @abstract
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+/**
+ * @param {ParserState} state parser state
+ * @param {UsageCallback} onUsageCallback on usage callback
+ */
+exports.onUsage = (state, onUsageCallback) => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		const { usageCallbackMap, currentTopLevelSymbol } = innerGraphState;
+		if (currentTopLevelSymbol) {
+			let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
+
+			if (callbacks === undefined) {
+				callbacks = new Set();
+				usageCallbackMap.set(currentTopLevelSymbol, callbacks);
+			}
+
+			callbacks.add(onUsageCallback);
+		} else {
+			onUsageCallback(true);
+		}
+	} else {
+		onUsageCallback(undefined);
 	}
+};
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {string} entryName the name of the entrypoint
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	finishEntryModule(module, entryName, libraryContext) {}
+/**
+ * @param {ParserState} state parser state
+ * @param {TopLevelSymbol} symbol the symbol
+ */
+exports.setTopLevelSymbol = (state, symbol) => {
+	const innerGraphState = getState(state);
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	embedInRuntimeBailout(module, renderContext, libraryContext) {
-		return undefined;
+	if (innerGraphState) {
+		innerGraphState.currentTopLevelSymbol = symbol;
 	}
+};
 
-	/**
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	strictRuntimeBailout(renderContext, libraryContext) {
-		return undefined;
+/**
+ * @param {ParserState} state parser state
+ * @returns {TopLevelSymbol|void} usage data
+ */
+exports.getTopLevelSymbol = state => {
+	const innerGraphState = getState(state);
+
+	if (innerGraphState) {
+		return innerGraphState.currentTopLevelSymbol;
 	}
+};
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	runtimeRequirements(chunk, set, libraryContext) {
-		if (this.render !== AbstractLibraryPlugin.prototype.render)
-			set.add(RuntimeGlobals.returnExportsFromRuntime);
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {string} name name of variable
+ * @returns {TopLevelSymbol} symbol
+ */
+exports.tagTopLevelSymbol = (parser, name) => {
+	const innerGraphState = getState(parser.state);
+	if (!innerGraphState) return;
+
+	parser.defineVariable(name);
+
+	const existingTag = /** @type {TopLevelSymbol} */ (
+		parser.getTagData(name, topLevelSymbolTag)
+	);
+	if (existingTag) {
+		return existingTag;
 	}
 
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(source, renderContext, libraryContext) {
-		return source;
+	const fn = new TopLevelSymbol(name);
+	parser.tagVariable(name, topLevelSymbolTag, fn);
+	return fn;
+};
+
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} false, when unused. Otherwise true
+ */
+exports.isDependencyUsedByExports = (
+	dependency,
+	usedByExports,
+	moduleGraph,
+	runtime
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		let used = false;
+		for (const exportName of usedByExports) {
+			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+				used = true;
+		}
+		if (!used) return false;
 	}
+	return true;
+};
 
-	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	renderStartup(source, module, renderContext, libraryContext) {
-		return source;
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+ */
+exports.getDependencyUsedByExportsCondition = (
+	dependency,
+	usedByExports,
+	moduleGraph
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		return (connections, runtime) => {
+			for (const exportName of usedByExports) {
+				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+					return true;
+			}
+			return false;
+		};
 	}
+	return null;
+};
 
+class TopLevelSymbol {
 	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
+	 * @param {string} name name of the variable
 	 */
-	chunkHash(chunk, hash, chunkHashContext, libraryContext) {
-		const options = this._parseOptionsCached(
-			libraryContext.compilation.outputOptions.library
-		);
-		hash.update(this._pluginName);
-		hash.update(JSON.stringify(options));
+	constructor(name) {
+		this.name = name;
 	}
 }
 
-AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
-module.exports = AbstractLibraryPlugin;
+exports.TopLevelSymbol = TopLevelSymbol;
+exports.topLevelSymbolTag = topLevelSymbolTag;
 
 
 /***/ }),
 
-/***/ 67416:
+/***/ 28758:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -103011,166 +102332,372 @@ module.exports = AbstractLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const ExternalModule = __webpack_require__(73071);
-const Template = __webpack_require__(39722);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const PureExpressionDependency = __webpack_require__(55799);
+const InnerGraph = __webpack_require__(38988);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
+/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} AmdLibraryPluginOptions
- * @property {LibraryType} type
- * @property {boolean=} requireAsWrapper
- */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
+/** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
-/**
- * @typedef {Object} AmdLibraryPluginParsed
- * @property {string} name
- */
+const { topLevelSymbolTag } = InnerGraph;
 
-/**
- * @typedef {AmdLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<AmdLibraryPluginParsed>}
- */
-class AmdLibraryPlugin extends AbstractLibraryPlugin {
+class InnerGraphPlugin {
 	/**
-	 * @param {AmdLibraryPluginOptions} options the plugin options
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	constructor(options) {
-		super({
-			pluginName: "AmdLibraryPlugin",
-			type: options.type
-		});
-		this.requireAsWrapper = options.requireAsWrapper;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"InnerGraphPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
 
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (this.requireAsWrapper) {
-			if (name) {
-				throw new Error(
-					`AMD library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		} else {
-			if (name && typeof name !== "string") {
-				throw new Error(
-					`AMD library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
+				compilation.dependencyTemplates.set(
+					PureExpressionDependency,
+					new PureExpressionDependency.Template()
 				);
-			}
-		}
-		return {
-			name: /** @type {string=} */ (name)
-		};
-	}
 
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(
-		source,
-		{ chunkGraph, chunk, runtimeTemplate },
-		{ options, compilation }
-	) {
-		const modern = runtimeTemplate.supportsArrowFunction();
-		const modules = chunkGraph
-			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule);
-		const externals = /** @type {ExternalModule[]} */ (modules);
-		const externalsDepsArray = JSON.stringify(
-			externals.map(m =>
-				typeof m.request === "object" && !Array.isArray(m.request)
-					? m.request.amd
-					: m.request
-			)
-		);
-		const externalsArguments = externals
-			.map(
-				m =>
-					`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-						`${chunkGraph.getModuleId(m)}`
-					)}__`
-			)
-			.join(", ");
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {Object} parserOptions options
+				 * @returns {void}
+				 */
+				const handler = (parser, parserOptions) => {
+					const onUsageSuper = sup => {
+						InnerGraph.onUsage(parser.state, usedByExports => {
+							switch (usedByExports) {
+								case undefined:
+								case true:
+									return;
+								default: {
+									const dep = new PureExpressionDependency(sup.range);
+									dep.loc = sup.loc;
+									dep.usedByExports = usedByExports;
+									parser.state.module.addDependency(dep);
+									break;
+								}
+							}
+						});
+					};
 
-		const iife = runtimeTemplate.isIIFE();
-		const fnStart =
-			(modern
-				? `(${externalsArguments}) => {`
-				: `function(${externalsArguments}) {`) +
-			(iife || !chunk.hasRuntime() ? " return " : "\n");
-		const fnEnd = iife ? ";\n}" : "\n}";
+					parser.hooks.program.tap("InnerGraphPlugin", () => {
+						InnerGraph.enable(parser.state);
+					});
 
-		if (this.requireAsWrapper) {
-			return new ConcatSource(
-				`require(${externalsDepsArray}, ${fnStart}`,
-				source,
-				`${fnEnd});`
-			);
-		} else if (options.name) {
-			const name = compilation.getPath(options.name, {
-				chunk
-			});
+					parser.hooks.finish.tap("InnerGraphPlugin", () => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
 
-			return new ConcatSource(
-				`define(${JSON.stringify(name)}, ${externalsDepsArray}, ${fnStart}`,
-				source,
-				`${fnEnd});`
-			);
-		} else if (externalsArguments) {
-			return new ConcatSource(
-				`define(${externalsDepsArray}, ${fnStart}`,
-				source,
-				`${fnEnd});`
-			);
-		} else {
-			return new ConcatSource(`define(${fnStart}`, source, `${fnEnd});`);
-		}
-	}
+						logger.time("infer dependency usage");
+						InnerGraph.inferDependencyUsage(parser.state);
+						logger.timeAggregate("infer dependency usage");
+					});
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("AmdLibraryPlugin");
-		if (this.requireAsWrapper) {
-			hash.update("requireAsWrapper");
-		} else if (options.name) {
-			hash.update("named");
-			const name = compilation.getPath(options.name, {
-				chunk
-			});
-			hash.update(name);
-		}
+					// During prewalking the following datastructures are filled with
+					// nodes that have a TopLevelSymbol assigned and
+					// variables are tagged with the assigned TopLevelSymbol
+
+					// We differ 3 types of nodes:
+					// 1. full statements (export default, function declaration)
+					// 2. classes (class declaration, class expression)
+					// 3. variable declarators (const x = ...)
+
+					/** @type {WeakMap<Node, TopLevelSymbol>} */
+					const statementWithTopLevelSymbol = new WeakMap();
+					/** @type {WeakMap<Node, Node>} */
+					const statementPurePart = new WeakMap();
+
+					/** @type {WeakMap<ClassExpressionNode | ClassDeclarationNode, TopLevelSymbol>} */
+					const classWithTopLevelSymbol = new WeakMap();
+
+					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
+					const declWithTopLevelSymbol = new WeakMap();
+					/** @type {WeakSet<VariableDeclaratorNode>} */
+					const pureDeclarators = new WeakSet();
+
+					// The following hooks are used during prewalking:
+
+					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+
+						if (parser.scope.topLevelScope === true) {
+							if (statement.type === "FunctionDeclaration") {
+								const name = statement.id ? statement.id.name : "*default*";
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								statementWithTopLevelSymbol.set(statement, fn);
+								return true;
+							}
+						}
+					});
+
+					parser.hooks.blockPreStatement.tap("InnerGraphPlugin", statement => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+
+						if (parser.scope.topLevelScope === true) {
+							if (statement.type === "ClassDeclaration") {
+								const name = statement.id ? statement.id.name : "*default*";
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								classWithTopLevelSymbol.set(statement, fn);
+								return true;
+							}
+							if (statement.type === "ExportDefaultDeclaration") {
+								const name = "*default*";
+								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+								const decl = statement.declaration;
+								if (
+									decl.type === "ClassExpression" ||
+									decl.type === "ClassDeclaration"
+								) {
+									classWithTopLevelSymbol.set(decl, fn);
+								} else if (parser.isPure(decl, statement.range[0])) {
+									statementWithTopLevelSymbol.set(statement, fn);
+									if (
+										!decl.type.endsWith("FunctionExpression") &&
+										!decl.type.endsWith("Declaration") &&
+										decl.type !== "Literal"
+									) {
+										statementPurePart.set(statement, decl);
+									}
+								}
+							}
+						}
+					});
+
+					parser.hooks.preDeclarator.tap(
+						"InnerGraphPlugin",
+						(decl, statement) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (
+								parser.scope.topLevelScope === true &&
+								decl.init &&
+								decl.id.type === "Identifier"
+							) {
+								const name = decl.id.name;
+								if (decl.init.type === "ClassExpression") {
+									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+									classWithTopLevelSymbol.set(decl.init, fn);
+								} else if (parser.isPure(decl.init, decl.id.range[1])) {
+									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
+									declWithTopLevelSymbol.set(decl, fn);
+									if (
+										!decl.init.type.endsWith("FunctionExpression") &&
+										decl.init.type !== "Literal"
+									) {
+										pureDeclarators.add(decl);
+									}
+									return true;
+								}
+							}
+						}
+					);
+
+					// During real walking we set the TopLevelSymbol state to the assigned
+					// TopLevelSymbol by using the fill datastructures.
+
+					// In addition to tracking TopLevelSymbols, we sometimes need to
+					// add a PureExpressionDependency. This is needed to skip execution
+					// of pure expressions, even when they are not dropped due to
+					// minimizing. Otherwise symbols used there might not exist anymore
+					// as they are removed as unused by this optimization
+
+					// When we find a reference to a TopLevelSymbol, we register a
+					// TopLevelSymbol dependency from TopLevelSymbol in state to the
+					// referenced TopLevelSymbol. This way we get a graph of all
+					// TopLevelSymbols.
+
+					// The following hooks are called during walking:
+
+					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (parser.scope.topLevelScope === true) {
+							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+
+							const fn = statementWithTopLevelSymbol.get(statement);
+							if (fn) {
+								InnerGraph.setTopLevelSymbol(parser.state, fn);
+								const purePart = statementPurePart.get(statement);
+								if (purePart) {
+									InnerGraph.onUsage(parser.state, usedByExports => {
+										switch (usedByExports) {
+											case undefined:
+											case true:
+												return;
+											default: {
+												const dep = new PureExpressionDependency(
+													purePart.range
+												);
+												dep.loc = statement.loc;
+												dep.usedByExports = usedByExports;
+												parser.state.module.addDependency(dep);
+												break;
+											}
+										}
+									});
+								}
+							}
+						}
+					});
+
+					parser.hooks.classExtendsExpression.tap(
+						"InnerGraphPlugin",
+						(expr, statement) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(statement);
+								if (
+									fn &&
+									parser.isPure(
+										expr,
+										statement.id ? statement.id.range[1] : statement.range[0]
+									)
+								) {
+									InnerGraph.setTopLevelSymbol(parser.state, fn);
+									onUsageSuper(expr);
+								}
+							}
+						}
+					);
+
+					parser.hooks.classBodyElement.tap(
+						"InnerGraphPlugin",
+						(element, classDefinition) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(classDefinition);
+								if (fn) {
+									InnerGraph.setTopLevelSymbol(parser.state, undefined);
+								}
+							}
+						}
+					);
+
+					parser.hooks.classBodyValue.tap(
+						"InnerGraphPlugin",
+						(expression, element, classDefinition) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(classDefinition);
+								if (fn) {
+									if (
+										!element.static ||
+										parser.isPure(
+											expression,
+											element.key ? element.key.range[1] : element.range[0]
+										)
+									) {
+										InnerGraph.setTopLevelSymbol(parser.state, fn);
+										if (element.type !== "MethodDefinition" && element.static) {
+											InnerGraph.onUsage(parser.state, usedByExports => {
+												switch (usedByExports) {
+													case undefined:
+													case true:
+														return;
+													default: {
+														const dep = new PureExpressionDependency(
+															expression.range
+														);
+														dep.loc = expression.loc;
+														dep.usedByExports = usedByExports;
+														parser.state.module.addDependency(dep);
+														break;
+													}
+												}
+											});
+										}
+									} else {
+										InnerGraph.setTopLevelSymbol(parser.state, undefined);
+									}
+								}
+							}
+						}
+					);
+
+					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
+						if (!InnerGraph.isEnabled(parser.state)) return;
+						const fn = declWithTopLevelSymbol.get(decl);
+
+						if (fn) {
+							InnerGraph.setTopLevelSymbol(parser.state, fn);
+							if (pureDeclarators.has(decl)) {
+								if (decl.init.type === "ClassExpression") {
+									if (decl.init.superClass) {
+										onUsageSuper(decl.init.superClass);
+									}
+								} else {
+									InnerGraph.onUsage(parser.state, usedByExports => {
+										switch (usedByExports) {
+											case undefined:
+											case true:
+												return;
+											default: {
+												const dep = new PureExpressionDependency(
+													decl.init.range
+												);
+												dep.loc = decl.loc;
+												dep.usedByExports = usedByExports;
+												parser.state.module.addDependency(dep);
+												break;
+											}
+										}
+									});
+								}
+							}
+							parser.walkExpression(decl.init);
+							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							return true;
+						}
+					});
+
+					parser.hooks.expression
+						.for(topLevelSymbolTag)
+						.tap("InnerGraphPlugin", () => {
+							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
+								parser.currentTagData
+							);
+							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
+								parser.state
+							);
+							InnerGraph.addUsage(
+								parser.state,
+								topLevelSymbol,
+								currentTopLevelSymbol || true
+							);
+						});
+					parser.hooks.assign
+						.for(topLevelSymbolTag)
+						.tap("InnerGraphPlugin", expr => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (expr.operator === "=") return true;
+						});
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("InnerGraphPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("InnerGraphPlugin", handler);
+
+				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
+					logger.timeAggregateEnd("infer dependency usage");
+				});
+			}
+		);
 	}
 }
 
-module.exports = AmdLibraryPlugin;
+module.exports = InnerGraphPlugin;
 
 
 /***/ }),
 
-/***/ 40080:
+/***/ 83608:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -103181,373 +102708,260 @@ module.exports = AmdLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Template = __webpack_require__(39722);
-const propertyAccess = __webpack_require__(54190);
-const { getEntryRuntime } = __webpack_require__(17156);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const LazyBucketSortedSet = __webpack_require__(48424);
+const { compareChunks } = __webpack_require__(29579);
+const createSchemaValidation = __webpack_require__(32540);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
 /** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-const KEYWORD_REGEX =
-	/^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
-const IDENTIFIER_REGEX =
-	/^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
 
-/**
- * Validates the library name by checking for keywords and valid characters
- * @param {string} name name to be validated
- * @returns {boolean} true, when valid
- */
-const isNameValid = name => {
-	return !KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
-};
+const validate = createSchemaValidation(
+	__webpack_require__(36557),
+	() => __webpack_require__(30837),
+	{
+		name: "Limit Chunk Count Plugin",
+		baseDataPath: "options"
+	}
+);
 
 /**
- * @param {string[]} accessor variable plus properties
- * @param {number} existingLength items of accessor that are existing already
- * @param {boolean=} initLast if the last property should also be initialized to an object
- * @returns {string} code to access the accessor while initializing
+ * @typedef {Object} ChunkCombination
+ * @property {boolean} deleted this is set to true when combination was removed
+ * @property {number} sizeDiff
+ * @property {number} integratedSize
+ * @property {Chunk} a
+ * @property {Chunk} b
+ * @property {number} aIdx
+ * @property {number} bIdx
+ * @property {number} aSize
+ * @property {number} bSize
  */
-const accessWithInit = (accessor, existingLength, initLast = false) => {
-	// This generates for [a, b, c, d]:
-	// (((a = typeof a === "undefined" ? {} : a).b = a.b || {}).c = a.b.c || {}).d
-	const base = accessor[0];
-	if (accessor.length === 1 && !initLast) return base;
-	let current =
-		existingLength > 0
-			? base
-			: `(${base} = typeof ${base} === "undefined" ? {} : ${base})`;
 
-	// i is the current position in accessor that has been printed
-	let i = 1;
-
-	// all properties printed so far (excluding base)
-	let propsSoFar;
-
-	// if there is existingLength, print all properties until this position as property access
-	if (existingLength > i) {
-		propsSoFar = accessor.slice(1, existingLength);
-		i = existingLength;
-		current += propertyAccess(propsSoFar);
+const addToSetMap = (map, key, value) => {
+	const set = map.get(key);
+	if (set === undefined) {
+		map.set(key, new Set([value]));
 	} else {
-		propsSoFar = [];
+		set.add(value);
 	}
+};
 
-	// all remaining properties (except the last one when initLast is not set)
-	// should be printed as initializer
-	const initUntil = initLast ? accessor.length : accessor.length - 1;
-	for (; i < initUntil; i++) {
-		const prop = accessor[i];
-		propsSoFar.push(prop);
-		current = `(${current}${propertyAccess([prop])} = ${base}${propertyAccess(
-			propsSoFar
-		)} || {})`;
+class LimitChunkCountPlugin {
+	/**
+	 * @param {LimitChunkCountPluginOptions=} options options object
+	 */
+	constructor(options) {
+		validate(options);
+		this.options = options;
 	}
 
-	// print the last property as property access if not yet printed
-	if (i < accessor.length)
-		current = `${current}${propertyAccess([accessor[accessor.length - 1]])}`;
-
-	return current;
-};
+	/**
+	 * @param {Compiler} compiler the webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const options = this.options;
+		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "LimitChunkCountPlugin",
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					const maxChunks = options.maxChunks;
+					if (!maxChunks) return;
+					if (maxChunks < 1) return;
+					if (compilation.chunks.size <= maxChunks) return;
 
-/**
- * @typedef {Object} AssignLibraryPluginOptions
- * @property {LibraryType} type
- * @property {string[] | "global"} prefix name prefix
- * @property {string | false} declare declare name as variable
- * @property {"error"|"static"|"copy"|"assign"} unnamed behavior for unnamed library name
- * @property {"copy"|"assign"=} named behavior for named library name
- */
+					let remainingChunksToMerge = compilation.chunks.size - maxChunks;
 
-/**
- * @typedef {Object} AssignLibraryPluginParsed
- * @property {string | string[]} name
- * @property {string | string[] | undefined} export
- */
+					// order chunks in a deterministic way
+					const compareChunksWithGraph = compareChunks(chunkGraph);
+					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
 
-/**
- * @typedef {AssignLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
- */
-class AssignLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {AssignLibraryPluginOptions} options the plugin options
-	 */
-	constructor(options) {
-		super({
-			pluginName: "AssignLibraryPlugin",
-			type: options.type
-		});
-		this.prefix = options.prefix;
-		this.declare = options.declare;
-		this.unnamed = options.unnamed;
-		this.named = options.named || "assign";
-	}
+					// create a lazy sorted data structure to keep all combinations
+					// this is large. Size = chunks * (chunks - 1) / 2
+					// It uses a multi layer bucket sort plus normal sort in the last layer
+					// It's also lazy so only accessed buckets are sorted
+					const combinations = new LazyBucketSortedSet(
+						// Layer 1: ordered by largest size benefit
+						c => c.sizeDiff,
+						(a, b) => b - a,
+						// Layer 2: ordered by smallest combined size
+						c => c.integratedSize,
+						(a, b) => a - b,
+						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
+						c => c.bIdx - c.aIdx,
+						(a, b) => a - b,
+						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
+						(a, b) => a.bIdx - b.bIdx
+					);
 
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (this.unnamed === "error") {
-			if (typeof name !== "string" && !Array.isArray(name)) {
-				throw new Error(
-					`Library name must be a string or string array. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		} else {
-			if (name && typeof name !== "string" && !Array.isArray(name)) {
-				throw new Error(
-					`Library name must be a string, string array or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-				);
-			}
-		}
-		return {
-			name: /** @type {string|string[]=} */ (name),
-			export: library.export
-		};
-	}
+					// we keep a mapping from chunk to all combinations
+					// but this mapping is not kept up-to-date with deletions
+					// so `deleted` flag need to be considered when iterating this
+					/** @type {Map<Chunk, Set<ChunkCombination>>} */
+					const combinationsByChunk = new Map();
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {string} entryName the name of the entrypoint
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	finishEntryModule(
-		module,
-		entryName,
-		{ options, compilation, compilation: { moduleGraph } }
-	) {
-		const runtime = getEntryRuntime(compilation, entryName);
-		if (options.export) {
-			const exportsInfo = moduleGraph.getExportInfo(
-				module,
-				Array.isArray(options.export) ? options.export[0] : options.export
-			);
-			exportsInfo.setUsed(UsageState.Used, runtime);
-			exportsInfo.canMangleUse = false;
-		} else {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			exportsInfo.setUsedInUnknownWay(runtime);
-		}
-		moduleGraph.addExtraReason(module, "used as library export");
-	}
+					orderedChunks.forEach((b, bIdx) => {
+						// create combination pairs with size and integrated size
+						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
+							const a = orderedChunks[aIdx];
+							// filter pairs that can not be integrated!
+							if (!chunkGraph.canChunksBeIntegrated(a, b)) continue;
 
-	_getPrefix(compilation) {
-		return this.prefix === "global"
-			? [compilation.runtimeTemplate.globalObject]
-			: this.prefix;
-	}
+							const integratedSize = chunkGraph.getIntegratedChunksSize(
+								a,
+								b,
+								options
+							);
 
-	_getResolvedFullName(options, chunk, compilation) {
-		const prefix = this._getPrefix(compilation);
-		const fullName = options.name ? prefix.concat(options.name) : prefix;
-		return fullName.map(n =>
-			compilation.getPath(n, {
-				chunk
-			})
-		);
-	}
+							const aSize = chunkGraph.getChunkSize(a, options);
+							const bSize = chunkGraph.getChunkSize(b, options);
+							const c = {
+								deleted: false,
+								sizeDiff: aSize + bSize - integratedSize,
+								integratedSize,
+								a,
+								b,
+								aIdx,
+								bIdx,
+								aSize,
+								bSize
+							};
+							combinations.add(c);
+							addToSetMap(combinationsByChunk, a, c);
+							addToSetMap(combinationsByChunk, b, c);
+						}
+						return combinations;
+					});
 
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(source, { chunk }, { options, compilation }) {
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		if (this.declare) {
-			const base = fullNameResolved[0];
-			if (!isNameValid(base)) {
-				throw new Error(
-					`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
-						base
-					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${
-						AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE
-					}`
-				);
-			}
-			source = new ConcatSource(`${this.declare} ${base};\n`, source);
-		}
-		return source;
-	}
+					// list of modified chunks during this run
+					// combinations affected by this change are skipped to allow
+					// further optimizations
+					/** @type {Set<Chunk>} */
+					const modifiedChunks = new Set();
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
-		const topLevelDeclarations =
-			module.buildInfo && module.buildInfo.topLevelDeclarations;
-		if (!topLevelDeclarations)
-			return "it doesn't tell about top level declarations.";
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		const base = fullNameResolved[0];
-		if (topLevelDeclarations.has(base))
-			return `it declares '${base}' on top-level, which conflicts with the current library output.`;
-	}
+					let changed = false;
+					// eslint-disable-next-line no-constant-condition
+					loop: while (true) {
+						const combination = combinations.popFirst();
+						if (combination === undefined) break;
 
-	/**
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {string | undefined} bailout reason
-	 */
-	strictRuntimeBailout({ chunk }, { options, compilation }) {
-		if (
-			this.declare ||
-			this.prefix === "global" ||
-			this.prefix.length > 0 ||
-			!options.name
-		) {
-			return;
-		}
-		return "a global variable is assign and maybe created";
-	}
+						combination.deleted = true;
+						const { a, b, integratedSize } = combination;
 
-	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	renderStartup(
-		source,
-		module,
-		{ moduleGraph, chunk },
-		{ options, compilation }
-	) {
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		const staticExports = this.unnamed === "static";
-		const exportAccess = options.export
-			? propertyAccess(
-					Array.isArray(options.export) ? options.export : [options.export]
-			  )
-			: "";
-		const result = new ConcatSource(source);
-		if (staticExports) {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const exportTarget = accessWithInit(
-				fullNameResolved,
-				this._getPrefix(compilation).length,
-				true
-			);
-			for (const exportInfo of exportsInfo.orderedExports) {
-				if (!exportInfo.provided) continue;
-				const nameAccess = propertyAccess([exportInfo.name]);
-				result.add(
-					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
-				);
-			}
-			result.add(
-				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
-			);
-		} else if (options.name ? this.named === "copy" : this.unnamed === "copy") {
-			result.add(
-				`var __webpack_export_target__ = ${accessWithInit(
-					fullNameResolved,
-					this._getPrefix(compilation).length,
-					true
-				)};\n`
-			);
-			let exports = "__webpack_exports__";
-			if (exportAccess) {
-				result.add(
-					`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
-				);
-				exports = "__webpack_exports_export__";
-			}
-			result.add(
-				`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`
-			);
-			result.add(
-				`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`
-			);
-		} else {
-			result.add(
-				`${accessWithInit(
-					fullNameResolved,
-					this._getPrefix(compilation).length,
-					false
-				)} = __webpack_exports__${exportAccess};\n`
-			);
-		}
-		return result;
-	}
+						// skip over pair when
+						// one of the already merged chunks is a parent of one of the chunks
+						if (modifiedChunks.size > 0) {
+							const queue = new Set(a.groupsIterable);
+							for (const group of b.groupsIterable) {
+								queue.add(group);
+							}
+							for (const group of queue) {
+								for (const mChunk of modifiedChunks) {
+									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
+										// This is a potential pair which needs recalculation
+										// We can't do that now, but it merge before following pairs
+										// so we leave space for it, and consider chunks as modified
+										// just for the worse case
+										remainingChunksToMerge--;
+										if (remainingChunksToMerge <= 0) break loop;
+										modifiedChunks.add(a);
+										modifiedChunks.add(b);
+										continue loop;
+									}
+								}
+								for (const parent of group.parentsIterable) {
+									queue.add(parent);
+								}
+							}
+						}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	runtimeRequirements(chunk, set, libraryContext) {
-		// we don't need to return exports from runtime
-	}
+						// merge the chunks
+						if (chunkGraph.canChunksBeIntegrated(a, b)) {
+							chunkGraph.integrateChunks(a, b);
+							compilation.chunks.delete(b);
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("AssignLibraryPlugin");
-		const fullNameResolved = this._getResolvedFullName(
-			options,
-			chunk,
-			compilation
-		);
-		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
-			hash.update("copy");
-		}
-		if (this.declare) {
-			hash.update(this.declare);
-		}
-		hash.update(fullNameResolved.join("."));
-		if (options.export) {
-			hash.update(`${options.export}`);
-		}
+							// flag chunk a as modified as further optimization are possible for all children here
+							modifiedChunks.add(a);
+
+							changed = true;
+							remainingChunksToMerge--;
+							if (remainingChunksToMerge <= 0) break;
+
+							// Update all affected combinations
+							// delete all combination with the removed chunk
+							// we will use combinations with the kept chunk instead
+							for (const combination of combinationsByChunk.get(a)) {
+								if (combination.deleted) continue;
+								combination.deleted = true;
+								combinations.delete(combination);
+							}
+
+							// Update combinations with the kept chunk with new sizes
+							for (const combination of combinationsByChunk.get(b)) {
+								if (combination.deleted) continue;
+								if (combination.a === b) {
+									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
+										combination.deleted = true;
+										combinations.delete(combination);
+										continue;
+									}
+									// Update size
+									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
+										a,
+										combination.b,
+										options
+									);
+									const finishUpdate = combinations.startUpdate(combination);
+									combination.a = a;
+									combination.integratedSize = newIntegratedSize;
+									combination.aSize = integratedSize;
+									combination.sizeDiff =
+										combination.bSize + integratedSize - newIntegratedSize;
+									finishUpdate();
+								} else if (combination.b === b) {
+									if (!chunkGraph.canChunksBeIntegrated(combination.a, a)) {
+										combination.deleted = true;
+										combinations.delete(combination);
+										continue;
+									}
+									// Update size
+									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
+										combination.a,
+										a,
+										options
+									);
+
+									const finishUpdate = combinations.startUpdate(combination);
+									combination.b = a;
+									combination.integratedSize = newIntegratedSize;
+									combination.bSize = integratedSize;
+									combination.sizeDiff =
+										integratedSize + combination.aSize - newIntegratedSize;
+									finishUpdate();
+								}
+							}
+							combinationsByChunk.set(a, combinationsByChunk.get(b));
+							combinationsByChunk.delete(b);
+						}
+					}
+					if (changed) return true;
+				}
+			);
+		});
 	}
 }
-
-module.exports = AssignLibraryPlugin;
+module.exports = LimitChunkCountPlugin;
 
 
 /***/ }),
 
-/***/ 91452:
+/***/ 27868:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -103558,252 +102972,181 @@ module.exports = AssignLibraryPlugin;
 
 
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Compiler")} Compiler */
+const { UsageState } = __webpack_require__(63686);
+const {
+	numberToIdentifier,
+	NUMBER_OF_IDENTIFIER_START_CHARS,
+	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+} = __webpack_require__(1626);
+const { assignDeterministicIds } = __webpack_require__(63290);
+const { compareSelect, compareStringsNumeric } = __webpack_require__(29579);
 
-/** @type {WeakMap<Compiler, Set<LibraryType>>} */
-const enabledTypes = new WeakMap();
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ExportsInfo")} ExportsInfo */
+/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
 
-const getEnabledTypes = compiler => {
-	let set = enabledTypes.get(compiler);
-	if (set === undefined) {
-		set = new Set();
-		enabledTypes.set(compiler, set);
+/**
+ * @param {ExportsInfo} exportsInfo exports info
+ * @returns {boolean} mangle is possible
+ */
+const canMangle = exportsInfo => {
+	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused)
+		return false;
+	let hasSomethingToMangle = false;
+	for (const exportInfo of exportsInfo.exports) {
+		if (exportInfo.canMangle === true) {
+			hasSomethingToMangle = true;
+		}
 	}
-	return set;
+	return hasSomethingToMangle;
 };
 
-class EnableLibraryPlugin {
-	/**
-	 * @param {LibraryType} type library type that should be available
-	 */
-	constructor(type) {
-		this.type = type;
-	}
+// Sort by name
+const comparator = compareSelect(e => e.name, compareStringsNumeric);
+/**
+ * @param {boolean} deterministic use deterministic names
+ * @param {ExportsInfo} exportsInfo exports info
+ * @param {boolean} isNamespace is namespace object
+ * @returns {void}
+ */
+const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
+	if (!canMangle(exportsInfo)) return;
+	const usedNames = new Set();
+	/** @type {ExportInfo[]} */
+	const mangleableExports = [];
 
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {LibraryType} type type of library
-	 * @returns {void}
-	 */
-	static setEnabled(compiler, type) {
-		getEnabledTypes(compiler).add(type);
+	// Avoid to renamed exports that are not provided when
+	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
+	// 2. there are other provided exports and deterministic mode is chosen:
+	//    non-provided exports would break the determinism
+	let avoidMangleNonProvided = !isNamespace;
+	if (!avoidMangleNonProvided && deterministic) {
+		for (const exportInfo of exportsInfo.ownedExports) {
+			if (exportInfo.provided !== false) {
+				avoidMangleNonProvided = true;
+				break;
+			}
+		}
+	}
+	for (const exportInfo of exportsInfo.ownedExports) {
+		const name = exportInfo.name;
+		if (!exportInfo.hasUsedName()) {
+			if (
+				// Can the export be mangled?
+				exportInfo.canMangle !== true ||
+				// Never rename 1 char exports
+				(name.length === 1 && /^[a-zA-Z0-9_$]/.test(name)) ||
+				// Don't rename 2 char exports in deterministic mode
+				(deterministic &&
+					name.length === 2 &&
+					/^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
+				// Don't rename exports that are not provided
+				(avoidMangleNonProvided && exportInfo.provided !== true)
+			) {
+				exportInfo.setUsedName(name);
+				usedNames.add(name);
+			} else {
+				mangleableExports.push(exportInfo);
+			}
+		}
+		if (exportInfo.exportsInfoOwned) {
+			const used = exportInfo.getUsed(undefined);
+			if (
+				used === UsageState.OnlyPropertiesUsed ||
+				used === UsageState.Unused
+			) {
+				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
+			}
+		}
+	}
+	if (deterministic) {
+		assignDeterministicIds(
+			mangleableExports,
+			e => e.name,
+			comparator,
+			(e, id) => {
+				const name = numberToIdentifier(id);
+				const size = usedNames.size;
+				usedNames.add(name);
+				if (size === usedNames.size) return false;
+				e.setUsedName(name);
+				return true;
+			},
+			[
+				NUMBER_OF_IDENTIFIER_START_CHARS,
+				NUMBER_OF_IDENTIFIER_START_CHARS *
+					NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
+			],
+			NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
+			usedNames.size
+		);
+	} else {
+		const usedExports = [];
+		const unusedExports = [];
+		for (const exportInfo of mangleableExports) {
+			if (exportInfo.getUsed(undefined) === UsageState.Unused) {
+				unusedExports.push(exportInfo);
+			} else {
+				usedExports.push(exportInfo);
+			}
+		}
+		usedExports.sort(comparator);
+		unusedExports.sort(comparator);
+		let i = 0;
+		for (const list of [usedExports, unusedExports]) {
+			for (const exportInfo of list) {
+				let name;
+				do {
+					name = numberToIdentifier(i++);
+				} while (usedNames.has(name));
+				exportInfo.setUsedName(name);
+			}
+		}
 	}
+};
 
+class MangleExportsPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {LibraryType} type type of library
-	 * @returns {void}
+	 * @param {boolean} deterministic use deterministic names
 	 */
-	static checkEnabled(compiler, type) {
-		if (!getEnabledTypes(compiler).has(type)) {
-			throw new Error(
-				`Library type "${type}" is not enabled. ` +
-					"EnableLibraryPlugin need to be used to enable this type of library. " +
-					'This usually happens through the "output.enabledLibraryTypes" option. ' +
-					'If you are using a function as entry which sets "library", you need to add all potential library types to "output.enabledLibraryTypes". ' +
-					"These types are enabled: " +
-					Array.from(getEnabledTypes(compiler)).join(", ")
-			);
-		}
+	constructor(deterministic) {
+		this._deterministic = deterministic;
 	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { type } = this;
-
-		// Only enable once
-		const enabled = getEnabledTypes(compiler);
-		if (enabled.has(type)) return;
-		enabled.add(type);
-
-		if (typeof type === "string") {
-			const enableExportProperty = () => {
-				const ExportPropertyTemplatePlugin = __webpack_require__(5487);
-				new ExportPropertyTemplatePlugin({
-					type,
-					nsObjectUsed: type !== "module"
-				}).apply(compiler);
-			};
-			switch (type) {
-				case "var": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: [],
-						declare: "var",
-						unnamed: "error"
-					}).apply(compiler);
-					break;
-				}
-				case "assign-properties": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: [],
-						declare: false,
-						unnamed: "error",
-						named: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "assign": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: [],
-						declare: false,
-						unnamed: "error"
-					}).apply(compiler);
-					break;
-				}
-				case "this": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["this"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "window": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["window"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "self": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["self"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "global": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: "global",
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "commonjs": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["exports"],
-						declare: false,
-						unnamed: "copy"
-					}).apply(compiler);
-					break;
-				}
-				case "commonjs-static": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["exports"],
-						declare: false,
-						unnamed: "static"
-					}).apply(compiler);
-					break;
-				}
-				case "commonjs2":
-				case "commonjs-module": {
-					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
-					const AssignLibraryPlugin = __webpack_require__(40080);
-					new AssignLibraryPlugin({
-						type,
-						prefix: ["module", "exports"],
-						declare: false,
-						unnamed: "assign"
-					}).apply(compiler);
-					break;
-				}
-				case "amd":
-				case "amd-require": {
-					enableExportProperty();
-					const AmdLibraryPlugin = __webpack_require__(67416);
-					new AmdLibraryPlugin({
-						type,
-						requireAsWrapper: type === "amd-require"
-					}).apply(compiler);
-					break;
-				}
-				case "umd":
-				case "umd2": {
-					enableExportProperty();
-					const UmdLibraryPlugin = __webpack_require__(54442);
-					new UmdLibraryPlugin({
-						type,
-						optionalAmdExternalAsGlobal: type === "umd2"
-					}).apply(compiler);
-					break;
-				}
-				case "system": {
-					enableExportProperty();
-					const SystemLibraryPlugin = __webpack_require__(11707);
-					new SystemLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
-				case "jsonp": {
-					enableExportProperty();
-					const JsonpLibraryPlugin = __webpack_require__(84415);
-					new JsonpLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
-				case "module": {
-					enableExportProperty();
-					const ModuleLibraryPlugin = __webpack_require__(59780);
-					new ModuleLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
+		const { _deterministic: deterministic } = this;
+		compiler.hooks.compilation.tap("MangleExportsPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			compilation.hooks.optimizeCodeGeneration.tap(
+				"MangleExportsPlugin",
+				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
+						);
+					}
+					for (const module of modules) {
+						const isNamespace =
+							module.buildMeta && module.buildMeta.exportsType === "namespace";
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
+					}
 				}
-				default:
-					throw new Error(`Unsupported library type ${type}.
-Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);
-			}
-		} else {
-			// TODO support plugin instances here
-			// apply them to the compiler
-		}
+			);
+		});
 	}
 }
 
-module.exports = EnableLibraryPlugin;
+module.exports = MangleExportsPlugin;
 
 
 /***/ }),
 
-/***/ 5487:
+/***/ 85067:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -103814,117 +103157,119 @@ module.exports = EnableLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const propertyAccess = __webpack_require__(54190);
-const { getEntryRuntime } = __webpack_require__(17156);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const { STAGE_BASIC } = __webpack_require__(80057);
+const { runtimeEqual } = __webpack_require__(17156);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} ExportPropertyLibraryPluginParsed
- * @property {string | string[]} export
- */
 
-/**
- * @typedef {Object} ExportPropertyLibraryPluginOptions
- * @property {LibraryType} type
- * @property {boolean} nsObjectUsed the namespace object is used
- */
-/**
- * @typedef {ExportPropertyLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<ExportPropertyLibraryPluginParsed>}
- */
-class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
+class MergeDuplicateChunksPlugin {
 	/**
-	 * @param {ExportPropertyLibraryPluginOptions} options options
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
 	 */
-	constructor({ type, nsObjectUsed }) {
-		super({
-			pluginName: "ExportPropertyLibraryPlugin",
-			type
-		});
-		this.nsObjectUsed = nsObjectUsed;
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"MergeDuplicateChunksPlugin",
+			compilation => {
+				compilation.hooks.optimizeChunks.tap(
+					{
+						name: "MergeDuplicateChunksPlugin",
+						stage: STAGE_BASIC
+					},
+					chunks => {
+						const { chunkGraph, moduleGraph } = compilation;
 
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		return {
-			export: library.export
-		};
-	}
+						// remember already tested chunks for performance
+						const notDuplicates = new Set();
 
-	/**
-	 * @param {Module} module the exporting entry module
-	 * @param {string} entryName the name of the entrypoint
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	finishEntryModule(
-		module,
-		entryName,
-		{ options, compilation, compilation: { moduleGraph } }
-	) {
-		const runtime = getEntryRuntime(compilation, entryName);
-		if (options.export) {
-			const exportsInfo = moduleGraph.getExportInfo(
-				module,
-				Array.isArray(options.export) ? options.export[0] : options.export
-			);
-			exportsInfo.setUsed(UsageState.Used, runtime);
-			exportsInfo.canMangleUse = false;
-		} else {
-			const exportsInfo = moduleGraph.getExportsInfo(module);
-			if (this.nsObjectUsed) {
-				exportsInfo.setUsedInUnknownWay(runtime);
-			} else {
-				exportsInfo.setAllKnownExportsUsed(runtime);
-			}
-		}
-		moduleGraph.addExtraReason(module, "used as library export");
-	}
+						// for each chunk
+						for (const chunk of chunks) {
+							// track a Set of all chunk that could be duplicates
+							let possibleDuplicates;
+							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+								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 chunkGraph.getModuleChunksIterable(
+										module
+									)) {
+										if (
+											dup !== chunk &&
+											chunkGraph.getNumberOfChunkModules(chunk) ===
+												chunkGraph.getNumberOfChunkModules(dup) &&
+											!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 (!chunkGraph.isModuleInChunk(module, dup)) {
+											possibleDuplicates.delete(dup);
+										}
+									}
+									// when all chunks has been removed we can break here
+									if (possibleDuplicates.size === 0) break;
+								}
+							}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Set<string>} set runtime requirements
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	runtimeRequirements(chunk, set, libraryContext) {}
+							// when we found duplicates
+							if (
+								possibleDuplicates !== undefined &&
+								possibleDuplicates.size > 0
+							) {
+								outer: for (const otherChunk of possibleDuplicates) {
+									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
+									if (chunkGraph.getNumberOfEntryModules(chunk) > 0) continue;
+									if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0)
+										continue;
+									if (!runtimeEqual(chunk.runtime, otherChunk.runtime)) {
+										for (const module of chunkGraph.getChunkModulesIterable(
+											chunk
+										)) {
+											const exportsInfo = moduleGraph.getExportsInfo(module);
+											if (
+												!exportsInfo.isEquallyUsed(
+													chunk.runtime,
+													otherChunk.runtime
+												)
+											) {
+												continue outer;
+											}
+										}
+									}
+									// merge them
+									if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
+										chunkGraph.integrateChunks(chunk, otherChunk);
+										compilation.chunks.delete(otherChunk);
+									}
+								}
+							}
 
-	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	renderStartup(source, module, renderContext, { options }) {
-		if (!options.export) return source;
-		const postfix = `__webpack_exports__ = __webpack_exports__${propertyAccess(
-			Array.isArray(options.export) ? options.export : [options.export]
-		)};\n`;
-		return new ConcatSource(source, postfix);
+							// don't check already processed chunks twice
+							notDuplicates.add(chunk);
+						}
+					}
+				);
+			}
+		);
 	}
 }
-
-module.exports = ExportPropertyLibraryPlugin;
+module.exports = MergeDuplicateChunksPlugin;
 
 
 /***/ }),
 
-/***/ 84415:
+/***/ 53912:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -103935,92 +103280,117 @@ module.exports = ExportPropertyLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const createSchemaValidation = __webpack_require__(32540);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
+/** @typedef {import("../../declarations/plugins/optimize/MinChunkSizePlugin").MinChunkSizePluginOptions} MinChunkSizePluginOptions */
 /** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} JsonpLibraryPluginOptions
- * @property {LibraryType} type
- */
 
-/**
- * @typedef {Object} JsonpLibraryPluginParsed
- * @property {string} name
- */
+const validate = createSchemaValidation(
+	__webpack_require__(60135),
+	() => __webpack_require__(53850),
+	{
+		name: "Min Chunk Size Plugin",
+		baseDataPath: "options"
+	}
+);
 
-/**
- * @typedef {JsonpLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<JsonpLibraryPluginParsed>}
- */
-class JsonpLibraryPlugin extends AbstractLibraryPlugin {
+class MinChunkSizePlugin {
 	/**
-	 * @param {JsonpLibraryPluginOptions} options the plugin options
+	 * @param {MinChunkSizePluginOptions} options options object
 	 */
 	constructor(options) {
-		super({
-			pluginName: "JsonpLibraryPlugin",
-			type: options.type
-		});
+		validate(options);
+		this.options = options;
 	}
 
 	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (typeof name !== "string") {
-			throw new Error(
-				`Jsonp library name must be a simple string. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-			);
-		}
-		return {
-			name: /** @type {string} */ (name)
-		};
-	}
+	apply(compiler) {
+		const options = this.options;
+		const minChunkSize = options.minChunkSize;
+		compiler.hooks.compilation.tap("MinChunkSizePlugin", compilation => {
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "MinChunkSizePlugin",
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					const chunkGraph = compilation.chunkGraph;
+					const equalOptions = {
+						chunkOverhead: 1,
+						entryChunkMultiplicator: 1
+					};
 
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(source, { chunk }, { options, compilation }) {
-		const name = compilation.getPath(options.name, {
-			chunk
-		});
-		return new ConcatSource(`${name}(`, source, ")");
-	}
+					const chunkSizesMap = new Map();
+					/** @type {[Chunk, Chunk][]} */
+					const combinations = [];
+					/** @type {Chunk[]} */
+					const smallChunks = [];
+					const visitedChunks = [];
+					for (const a of chunks) {
+						// check if one of the chunks sizes is smaller than the minChunkSize
+						// and filter pairs that can NOT be integrated!
+						if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
+							smallChunks.push(a);
+							for (const b of visitedChunks) {
+								if (chunkGraph.canChunksBeIntegrated(b, a))
+									combinations.push([b, a]);
+							}
+						} else {
+							for (const b of smallChunks) {
+								if (chunkGraph.canChunksBeIntegrated(b, a))
+									combinations.push([b, a]);
+							}
+						}
+						chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
+						visitedChunks.push(a);
+					}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("JsonpLibraryPlugin");
-		hash.update(compilation.getPath(options.name, { chunk }));
+					const sortedSizeFilteredExtendedPairCombinations = combinations
+						.map(pair => {
+							// extend combination pairs with size and integrated size
+							const a = chunkSizesMap.get(pair[0]);
+							const b = chunkSizesMap.get(pair[1]);
+							const ab = chunkGraph.getIntegratedChunksSize(
+								pair[0],
+								pair[1],
+								options
+							);
+							/** @type {[number, number, Chunk, Chunk]} */
+							const extendedPair = [a + b - ab, ab, pair[0], pair[1]];
+							return extendedPair;
+						})
+						.sort((a, b) => {
+							// sadly javascript does an in place 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];
+
+					chunkGraph.integrateChunks(pair[2], pair[3]);
+					compilation.chunks.delete(pair[3]);
+					return true;
+				}
+			);
+		});
 	}
 }
-
-module.exports = JsonpLibraryPlugin;
+module.exports = MinChunkSizePlugin;
 
 
 /***/ }),
 
-/***/ 59780:
+/***/ 85305:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -104031,852 +103401,908 @@ module.exports = JsonpLibraryPlugin;
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const Template = __webpack_require__(39722);
-const propertyAccess = __webpack_require__(54190);
-const AbstractLibraryPlugin = __webpack_require__(26030);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
-
-/**
- * @typedef {Object} ModuleLibraryPluginOptions
- * @property {LibraryType} type
- */
-
-/**
- * @typedef {Object} ModuleLibraryPluginParsed
- * @property {string} name
- */
-
-/**
- * @typedef {ModuleLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<ModuleLibraryPluginParsed>}
- */
-class ModuleLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {ModuleLibraryPluginOptions} options the plugin options
-	 */
-	constructor(options) {
-		super({
-			pluginName: "ModuleLibraryPlugin",
-			type: options.type
-		});
-	}
-
-	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
-	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (name) {
-			throw new Error(
-				`Library name must be unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-			);
-		}
-		return {
-			name: /** @type {string} */ (name)
-		};
-	}
+const SizeFormatHelpers = __webpack_require__(71070);
+const WebpackError = __webpack_require__(53799);
 
-	/**
-	 * @param {Source} source source
-	 * @param {Module} module module
-	 * @param {StartupRenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	renderStartup(
-		source,
-		module,
-		{ moduleGraph, chunk },
-		{ options, compilation }
-	) {
-		const result = new ConcatSource(source);
-		const exportsInfo = moduleGraph.getExportsInfo(module);
-		const exports = [];
-		const isAsync = moduleGraph.isAsync(module);
-		if (isAsync) {
-			result.add(`__webpack_exports__ = await __webpack_exports__;\n`);
-		}
-		for (const exportInfo of exportsInfo.orderedExports) {
-			if (!exportInfo.provided) continue;
-			const varName = `__webpack_exports__${Template.toIdentifier(
-				exportInfo.name
-			)}`;
-			result.add(
-				`var ${varName} = __webpack_exports__${propertyAccess([
-					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
-				])};\n`
-			);
-			exports.push(`${varName} as ${exportInfo.name}`);
-		}
-		if (exports.length > 0) {
-			result.add(`export { ${exports.join(", ")} };\n`);
+class MinMaxSizeWarning extends WebpackError {
+	constructor(keys, minSize, maxSize) {
+		let keysMessage = "Fallback cache group";
+		if (keys) {
+			keysMessage =
+				keys.length > 1
+					? `Cache groups ${keys.sort().join(", ")}`
+					: `Cache group ${keys[0]}`;
 		}
-		return result;
+		super(
+			`SplitChunksPlugin\n` +
+				`${keysMessage}\n` +
+				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
+				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
+				"This seem to be a invalid optimization.splitChunks configuration."
+		);
 	}
 }
 
-module.exports = ModuleLibraryPlugin;
+module.exports = MinMaxSizeWarning;
 
 
 /***/ }),
 
-/***/ 11707:
+/***/ 74844:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Joel Denning @joeldenning
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { ConcatSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const ExternalModule = __webpack_require__(73071);
-const Template = __webpack_require__(39722);
-const propertyAccess = __webpack_require__(54190);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+const asyncLib = __webpack_require__(78175);
+const ChunkGraph = __webpack_require__(64971);
+const ModuleGraph = __webpack_require__(99988);
+const { STAGE_DEFAULT } = __webpack_require__(80057);
+const HarmonyImportDependency = __webpack_require__(57154);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const {
+	intersectRuntime,
+	mergeRuntimeOwned,
+	filterRuntime,
+	runtimeToString,
+	mergeRuntime
+} = __webpack_require__(17156);
+const ConcatenatedModule = __webpack_require__(97198);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
- * @typedef {Object} SystemLibraryPluginOptions
- * @property {LibraryType} type
+ * @typedef {Object} Statistics
+ * @property {number} cached
+ * @property {number} alreadyInConfig
+ * @property {number} invalidModule
+ * @property {number} incorrectChunks
+ * @property {number} incorrectDependency
+ * @property {number} incorrectModuleDependency
+ * @property {number} incorrectChunksOfImporter
+ * @property {number} incorrectRuntimeCondition
+ * @property {number} importerFailed
+ * @property {number} added
  */
 
-/**
- * @typedef {Object} SystemLibraryPluginParsed
- * @property {string} name
- */
+const formatBailoutReason = msg => {
+	return "ModuleConcatenation bailout: " + msg;
+};
 
-/**
- * @typedef {SystemLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<SystemLibraryPluginParsed>}
- */
-class SystemLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {SystemLibraryPluginOptions} options the plugin options
-	 */
+class ModuleConcatenationPlugin {
 	constructor(options) {
-		super({
-			pluginName: "SystemLibraryPlugin",
-			type: options.type
-		});
+		if (typeof options !== "object") options = {};
+		this.options = options;
 	}
 
 	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	parseOptions(library) {
-		const { name } = library;
-		if (name && typeof name !== "string") {
-			throw new Error(
-				`System.js library name must be a simple string or unset. ${AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE}`
-			);
-		}
-		return {
-			name: /** @type {string=} */ (name)
-		};
-	}
+	apply(compiler) {
+		const { _backCompat: backCompat } = compiler;
+		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
+			const moduleGraph = compilation.moduleGraph;
+			const bailoutReasonMap = new Map();
 
-	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
-		const modules = chunkGraph
-			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule && m.externalType === "system");
-		const externals = /** @type {ExternalModule[]} */ (modules);
+			const setBailoutReason = (module, reason) => {
+				setInnerBailoutReason(module, reason);
+				moduleGraph
+					.getOptimizationBailout(module)
+					.push(
+						typeof reason === "function"
+							? rs => formatBailoutReason(reason(rs))
+							: formatBailoutReason(reason)
+					);
+			};
 
-		// The name this bundle should be registered as with System
-		const name = options.name
-			? `${JSON.stringify(compilation.getPath(options.name, { chunk }))}, `
-			: "";
+			const setInnerBailoutReason = (module, reason) => {
+				bailoutReasonMap.set(module, reason);
+			};
 
-		// The array of dependencies that are external to webpack and will be provided by System
-		const systemDependencies = JSON.stringify(
-			externals.map(m =>
-				typeof m.request === "object" && !Array.isArray(m.request)
-					? m.request.amd
-					: m.request
-			)
-		);
+			const getInnerBailoutReason = (module, requestShortener) => {
+				const reason = bailoutReasonMap.get(module);
+				if (typeof reason === "function") return reason(requestShortener);
+				return reason;
+			};
 
-		// The name of the variable provided by System for exporting
-		const dynamicExport = "__WEBPACK_DYNAMIC_EXPORT__";
+			const formatBailoutWarning = (module, problem) => requestShortener => {
+				if (typeof problem === "function") {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)}: ${problem(requestShortener)}`
+					);
+				}
+				const reason = getInnerBailoutReason(module, requestShortener);
+				const reasonWithPrefix = reason ? `: ${reason}` : "";
+				if (module === problem) {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)}${reasonWithPrefix}`
+					);
+				} else {
+					return formatBailoutReason(
+						`Cannot concat with ${module.readableIdentifier(
+							requestShortener
+						)} because of ${problem.readableIdentifier(
+							requestShortener
+						)}${reasonWithPrefix}`
+					);
+				}
+			};
 
-		// An array of the internal variable names for the webpack externals
-		const externalWebpackNames = externals.map(
-			m =>
-				`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-					`${chunkGraph.getModuleId(m)}`
-				)}__`
-		);
+			compilation.hooks.optimizeChunkModules.tapAsync(
+				{
+					name: "ModuleConcatenationPlugin",
+					stage: STAGE_DEFAULT
+				},
+				(allChunks, modules, callback) => {
+					const logger = compilation.getLogger(
+						"webpack.ModuleConcatenationPlugin"
+					);
+					const { chunkGraph, moduleGraph } = compilation;
+					const relevantModules = [];
+					const possibleInners = new Set();
+					const context = {
+						chunkGraph,
+						moduleGraph
+					};
+					logger.time("select relevant modules");
+					for (const module of modules) {
+						let canBeRoot = true;
+						let canBeInner = true;
 
-		// Declaring variables for the internal variable names for the webpack externals
-		const externalVarDeclarations = externalWebpackNames
-			.map(name => `var ${name} = {};`)
-			.join("\n");
+						const bailoutReason = module.getConcatenationBailoutReason(context);
+						if (bailoutReason) {
+							setBailoutReason(module, bailoutReason);
+							continue;
+						}
 
-		// Define __esModule flag on all internal variables and helpers
-		const externalVarInitialization = [];
+						// Must not be an async module
+						if (moduleGraph.isAsync(module)) {
+							setBailoutReason(module, `Module is async`);
+							continue;
+						}
 
-		// The system.register format requires an array of setter functions for externals.
-		const setters =
-			externalWebpackNames.length === 0
-				? ""
-				: Template.asString([
-						"setters: [",
-						Template.indent(
-							externals
-								.map((module, i) => {
-									const external = externalWebpackNames[i];
-									const exportsInfo = moduleGraph.getExportsInfo(module);
-									const otherUnused =
-										exportsInfo.otherExportsInfo.getUsed(chunk.runtime) ===
-										UsageState.Unused;
-									const instructions = [];
-									const handledNames = [];
-									for (const exportInfo of exportsInfo.orderedExports) {
-										const used = exportInfo.getUsedName(
-											undefined,
-											chunk.runtime
-										);
-										if (used) {
-											if (otherUnused || used !== exportInfo.name) {
-												instructions.push(
-													`${external}${propertyAccess([
-														used
-													])} = module${propertyAccess([exportInfo.name])};`
-												);
-												handledNames.push(exportInfo.name);
-											}
-										} else {
-											handledNames.push(exportInfo.name);
-										}
-									}
-									if (!otherUnused) {
-										if (
-											!Array.isArray(module.request) ||
-											module.request.length === 1
-										) {
-											externalVarInitialization.push(
-												`Object.defineProperty(${external}, "__esModule", { value: true });`
-											);
-										}
-										if (handledNames.length > 0) {
-											const name = `${external}handledNames`;
-											externalVarInitialization.push(
-												`var ${name} = ${JSON.stringify(handledNames)};`
-											);
-											instructions.push(
-												Template.asString([
-													"Object.keys(module).forEach(function(key) {",
-													Template.indent([
-														`if(${name}.indexOf(key) >= 0)`,
-														Template.indent(`${external}[key] = module[key];`)
-													]),
-													"});"
-												])
-											);
-										} else {
-											instructions.push(
-												Template.asString([
-													"Object.keys(module).forEach(function(key) {",
-													Template.indent([`${external}[key] = module[key];`]),
-													"});"
-												])
-											);
-										}
-									}
-									if (instructions.length === 0) return "function() {}";
-									return Template.asString([
-										"function(module) {",
-										Template.indent(instructions),
-										"}"
-									]);
-								})
-								.join(",\n")
-						),
-						"],"
-				  ]);
+						// Must be in strict mode
+						if (!module.buildInfo.strict) {
+							setBailoutReason(module, `Module is not in strict mode`);
+							continue;
+						}
 
-		return new ConcatSource(
-			Template.asString([
-				`System.register(${name}${systemDependencies}, function(${dynamicExport}, __system_context__) {`,
-				Template.indent([
-					externalVarDeclarations,
-					Template.asString(externalVarInitialization),
-					"return {",
-					Template.indent([
-						setters,
-						"execute: function() {",
-						Template.indent(`${dynamicExport}(`)
-					])
-				]),
-				""
-			]),
-			source,
-			Template.asString([
-				"",
-				Template.indent([
-					Template.indent([Template.indent([");"]), "}"]),
-					"};"
-				]),
-				"})"
-			])
-		);
-	}
+						// Module must be in any chunk (we don't want to do useless work)
+						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
+							setBailoutReason(module, "Module is not in any chunk");
+							continue;
+						}
 
-	/**
-	 * @param {Chunk} chunk the chunk
-	 * @param {Hash} hash hash
-	 * @param {ChunkHashContext} chunkHashContext chunk hash context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {void}
-	 */
-	chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
-		hash.update("SystemLibraryPlugin");
-		if (options.name) {
-			hash.update(compilation.getPath(options.name, { chunk }));
-		}
-	}
-}
+						// Exports must be known (and not dynamic)
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						const relevantExports = exportsInfo.getRelevantExports(undefined);
+						const unknownReexports = relevantExports.filter(exportInfo => {
+							return (
+								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
+							);
+						});
+						if (unknownReexports.length > 0) {
+							setBailoutReason(
+								module,
+								`Reexports in this module do not have a static target (${Array.from(
+									unknownReexports,
+									exportInfo =>
+										`${
+											exportInfo.name || "other exports"
+										}: ${exportInfo.getUsedInfo()}`
+								).join(", ")})`
+							);
+							continue;
+						}
 
-module.exports = SystemLibraryPlugin;
+						// Root modules must have a static list of exports
+						const unknownProvidedExports = relevantExports.filter(
+							exportInfo => {
+								return exportInfo.provided !== true;
+							}
+						);
+						if (unknownProvidedExports.length > 0) {
+							setBailoutReason(
+								module,
+								`List of module exports is dynamic (${Array.from(
+									unknownProvidedExports,
+									exportInfo =>
+										`${
+											exportInfo.name || "other exports"
+										}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
+								).join(", ")})`
+							);
+							canBeRoot = false;
+						}
 
+						// Module must not be an entry point
+						if (chunkGraph.isEntryModule(module)) {
+							setInnerBailoutReason(module, "Module is an entry point");
+							canBeInner = false;
+						}
 
-/***/ }),
+						if (canBeRoot) relevantModules.push(module);
+						if (canBeInner) possibleInners.add(module);
+					}
+					logger.timeEnd("select relevant modules");
+					logger.debug(
+						`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
+					);
+					// sort by depth
+					// modules with lower depth are more likely suited as roots
+					// this improves performance, because modules already selected as inner are skipped
+					logger.time("sort relevant modules");
+					relevantModules.sort((a, b) => {
+						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
+					});
+					logger.timeEnd("sort relevant modules");
 
-/***/ 54442:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					/** @type {Statistics} */
+					const stats = {
+						cached: 0,
+						alreadyInConfig: 0,
+						invalidModule: 0,
+						incorrectChunks: 0,
+						incorrectDependency: 0,
+						incorrectModuleDependency: 0,
+						incorrectChunksOfImporter: 0,
+						incorrectRuntimeCondition: 0,
+						importerFailed: 0,
+						added: 0
+					};
+					let statsCandidates = 0;
+					let statsSizeSum = 0;
+					let statsEmptyConfigurations = 0;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					logger.time("find modules to concatenate");
+					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
+						// TODO reconsider that when it's only used in a different runtime
+						if (usedAsInner.has(currentRoot)) continue;
 
+						let chunkRuntime = undefined;
+						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
+							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
+						}
+						const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
+						const filteredRuntime = filterRuntime(chunkRuntime, r =>
+							exportsInfo.isModuleUsed(r)
+						);
+						const activeRuntime =
+							filteredRuntime === true
+								? chunkRuntime
+								: filteredRuntime === false
+								? undefined
+								: filteredRuntime;
 
+						// create a configuration with the root
+						const currentConfiguration = new ConcatConfiguration(
+							currentRoot,
+							activeRuntime
+						);
 
-const { ConcatSource, OriginalSource } = __webpack_require__(51255);
-const ExternalModule = __webpack_require__(73071);
-const Template = __webpack_require__(39722);
-const AbstractLibraryPlugin = __webpack_require__(26030);
+						// cache failures to add modules
+						const failureCache = new Map();
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdCommentObject} LibraryCustomUmdCommentObject */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryCustomUmdObject} LibraryCustomUmdObject */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @template T @typedef {import("./AbstractLibraryPlugin").LibraryContext<T>} LibraryContext<T> */
+						// potential optional import candidates
+						/** @type {Set<Module>} */
+						const candidates = new Set();
 
-/**
- * @param {string[]} accessor the accessor to convert to path
- * @returns {string} the path
- */
-const accessorToObjectAccess = accessor => {
-	return accessor.map(a => `[${JSON.stringify(a)}]`).join("");
-};
+						// try to add all imports
+						for (const imp of this._getImports(
+							compilation,
+							currentRoot,
+							activeRuntime
+						)) {
+							candidates.add(imp);
+						}
 
-/**
- * @param {string|undefined} base the path prefix
- * @param {string|string[]} accessor the accessor
- * @param {string=} joinWith the element separator
- * @returns {string} the path
- */
-const accessorAccess = (base, accessor, joinWith = ", ") => {
-	const accessors = Array.isArray(accessor) ? accessor : [accessor];
-	return accessors
-		.map((_, idx) => {
-			const a = base
-				? base + accessorToObjectAccess(accessors.slice(0, idx + 1))
-				: accessors[0] + accessorToObjectAccess(accessors.slice(1, idx + 1));
-			if (idx === accessors.length - 1) return a;
-			if (idx === 0 && base === undefined)
-				return `${a} = typeof ${a} === "object" ? ${a} : {}`;
-			return `${a} = ${a} || {}`;
-		})
-		.join(joinWith);
-};
+						for (const imp of candidates) {
+							const impCandidates = new Set();
+							const problem = this._tryToAdd(
+								compilation,
+								currentConfiguration,
+								imp,
+								chunkRuntime,
+								activeRuntime,
+								possibleInners,
+								impCandidates,
+								failureCache,
+								chunkGraph,
+								true,
+								stats
+							);
+							if (problem) {
+								failureCache.set(imp, problem);
+								currentConfiguration.addWarning(imp, problem);
+							} else {
+								for (const c of impCandidates) {
+									candidates.add(c);
+								}
+							}
+						}
+						statsCandidates += candidates.size;
+						if (!currentConfiguration.isEmpty()) {
+							const modules = currentConfiguration.getModules();
+							statsSizeSum += modules.size;
+							concatConfigurations.push(currentConfiguration);
+							for (const module of modules) {
+								if (module !== currentConfiguration.rootModule) {
+									usedAsInner.add(module);
+								}
+							}
+						} else {
+							statsEmptyConfigurations++;
+							const optimizationBailouts =
+								moduleGraph.getOptimizationBailout(currentRoot);
+							for (const warning of currentConfiguration.getWarningsSorted()) {
+								optimizationBailouts.push(
+									formatBailoutWarning(warning[0], warning[1])
+								);
+							}
+						}
+					}
+					logger.timeEnd("find modules to concatenate");
+					logger.debug(
+						`${
+							concatConfigurations.length
+						} successful concat configurations (avg size: ${
+							statsSizeSum / concatConfigurations.length
+						}), ${statsEmptyConfigurations} bailed out completely`
+					);
+					logger.debug(
+						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
+					);
+					// HACK: Sort configurations by length and start with the longest one
+					// to get the biggest 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)
+					logger.time(`sort concat configurations`);
+					concatConfigurations.sort((a, b) => {
+						return b.modules.size - a.modules.size;
+					});
+					logger.timeEnd(`sort concat configurations`);
+					const usedModules = new Set();
 
-/** @typedef {string | string[] | LibraryCustomUmdObject} UmdLibraryPluginName */
+					logger.time("create concatenated modules");
+					asyncLib.each(
+						concatConfigurations,
+						(concatConfiguration, callback) => {
+							const rootModule = concatConfiguration.rootModule;
 
-/**
- * @typedef {Object} UmdLibraryPluginOptions
- * @property {LibraryType} type
- * @property {boolean=} optionalAmdExternalAsGlobal
- */
+							// Avoid overlapping configurations
+							// TODO: remove this when todo above is fixed
+							if (usedModules.has(rootModule)) return callback();
+							const modules = concatConfiguration.getModules();
+							for (const m of modules) {
+								usedModules.add(m);
+							}
 
-/**
- * @typedef {Object} UmdLibraryPluginParsed
- * @property {string | string[]} name
- * @property {LibraryCustomUmdObject} names
- * @property {string | LibraryCustomUmdCommentObject} auxiliaryComment
- * @property {boolean} namedDefine
- */
+							// Create a new ConcatenatedModule
+							let newModule = ConcatenatedModule.create(
+								rootModule,
+								modules,
+								concatConfiguration.runtime,
+								compiler.root,
+								compilation.outputOptions.hashFunction
+							);
 
-/**
- * @typedef {UmdLibraryPluginParsed} T
- * @extends {AbstractLibraryPlugin<UmdLibraryPluginParsed>}
- */
-class UmdLibraryPlugin extends AbstractLibraryPlugin {
-	/**
-	 * @param {UmdLibraryPluginOptions} options the plugin option
-	 */
-	constructor(options) {
-		super({
-			pluginName: "UmdLibraryPlugin",
-			type: options.type
-		});
+							const build = () => {
+								newModule.build(
+									compiler.options,
+									compilation,
+									null,
+									null,
+									err => {
+										if (err) {
+											if (!err.module) {
+												err.module = newModule;
+											}
+											return callback(err);
+										}
+										integrate();
+									}
+								);
+							};
 
-		this.optionalAmdExternalAsGlobal = options.optionalAmdExternalAsGlobal;
+							const integrate = () => {
+								if (backCompat) {
+									ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
+									ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
+								}
+
+								for (const warning of concatConfiguration.getWarningsSorted()) {
+									moduleGraph
+										.getOptimizationBailout(newModule)
+										.push(formatBailoutWarning(warning[0], warning[1]));
+								}
+								moduleGraph.cloneModuleAttributes(rootModule, newModule);
+								for (const m of modules) {
+									// add to builtModules when one of the included modules was built
+									if (compilation.builtModules.has(m)) {
+										compilation.builtModules.add(newModule);
+									}
+									if (m !== rootModule) {
+										// attach external references to the concatenated module too
+										moduleGraph.copyOutgoingModuleConnections(
+											m,
+											newModule,
+											c => {
+												return (
+													c.originModule === m &&
+													!(
+														c.dependency instanceof HarmonyImportDependency &&
+														modules.has(c.module)
+													)
+												);
+											}
+										);
+										// remove module from chunk
+										for (const chunk of chunkGraph.getModuleChunksIterable(
+											rootModule
+										)) {
+											chunkGraph.disconnectChunkAndModule(chunk, m);
+										}
+									}
+								}
+								compilation.modules.delete(rootModule);
+								ChunkGraph.clearChunkGraphForModule(rootModule);
+								ModuleGraph.clearModuleGraphForModule(rootModule);
+
+								// remove module from chunk
+								chunkGraph.replaceModule(rootModule, newModule);
+								// replace module references with the concatenated module
+								moduleGraph.moveModuleConnections(rootModule, newModule, c => {
+									const otherModule =
+										c.module === rootModule ? c.originModule : c.module;
+									const innerConnection =
+										c.dependency instanceof HarmonyImportDependency &&
+										modules.has(otherModule);
+									return !innerConnection;
+								});
+								// add concatenated module to the compilation
+								compilation.modules.add(newModule);
+
+								callback();
+							};
+
+							build();
+						},
+						err => {
+							logger.timeEnd("create concatenated modules");
+							process.nextTick(callback.bind(null, err));
+						}
+					);
+				}
+			);
+		});
 	}
 
 	/**
-	 * @param {LibraryOptions} library normalized library option
-	 * @returns {T | false} preprocess as needed by overriding
+	 * @param {Compilation} compilation the compilation
+	 * @param {Module} module the module to be added
+	 * @param {RuntimeSpec} runtime the runtime scope
+	 * @returns {Set<Module>} the imported modules
 	 */
-	parseOptions(library) {
-		/** @type {LibraryName} */
-		let name;
-		/** @type {LibraryCustomUmdObject} */
-		let names;
-		if (typeof library.name === "object" && !Array.isArray(library.name)) {
-			name = library.name.root || library.name.amd || library.name.commonjs;
-			names = library.name;
-		} else {
-			name = library.name;
-			const singleName = Array.isArray(name) ? name[0] : name;
-			names = {
-				commonjs: singleName,
-				root: library.name,
-				amd: singleName
-			};
+	_getImports(compilation, module, runtime) {
+		const moduleGraph = compilation.moduleGraph;
+		const set = new Set();
+		for (const dep of module.dependencies) {
+			// Get reference info only for harmony Dependencies
+			if (!(dep instanceof HarmonyImportDependency)) continue;
+
+			const connection = moduleGraph.getConnection(dep);
+			// Reference is valid and has a module
+			if (
+				!connection ||
+				!connection.module ||
+				!connection.isTargetActive(runtime)
+			) {
+				continue;
+			}
+
+			const importedNames = compilation.getDependencyReferencedExports(
+				dep,
+				undefined
+			);
+
+			if (
+				importedNames.every(i =>
+					Array.isArray(i) ? i.length > 0 : i.name.length > 0
+				) ||
+				Array.isArray(moduleGraph.getProvidedExports(module))
+			) {
+				set.add(connection.module);
+			}
 		}
-		return {
-			name,
-			names,
-			auxiliaryComment: library.auxiliaryComment,
-			namedDefine: library.umdNamedDefine
-		};
+		return set;
 	}
 
 	/**
-	 * @param {Source} source source
-	 * @param {RenderContext} renderContext render context
-	 * @param {LibraryContext<T>} libraryContext context
-	 * @returns {Source} source with library export
-	 */
-	render(
-		source,
-		{ chunkGraph, runtimeTemplate, chunk, moduleGraph },
-		{ options, compilation }
+	 * @param {Compilation} compilation webpack compilation
+	 * @param {ConcatConfiguration} config concat configuration (will be modified when added)
+	 * @param {Module} module the module to be added
+	 * @param {RuntimeSpec} runtime the runtime scope of the generated code
+	 * @param {RuntimeSpec} activeRuntime the runtime scope of the root module
+	 * @param {Set<Module>} possibleModules modules that are candidates
+	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
+	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
+	 * @param {Statistics} statistics gathering metrics
+	 * @returns {Module | function(RequestShortener): string} the problematic module
+	 */
+	_tryToAdd(
+		compilation,
+		config,
+		module,
+		runtime,
+		activeRuntime,
+		possibleModules,
+		candidates,
+		failureCache,
+		chunkGraph,
+		avoidMutateOnFailure,
+		statistics
 	) {
-		const modules = chunkGraph
-			.getChunkModules(chunk)
-			.filter(
-				m =>
-					m instanceof ExternalModule &&
-					(m.externalType === "umd" || m.externalType === "umd2")
-			);
-		let externals = /** @type {ExternalModule[]} */ (modules);
-		/** @type {ExternalModule[]} */
-		const optionalExternals = [];
-		/** @type {ExternalModule[]} */
-		let requiredExternals = [];
-		if (this.optionalAmdExternalAsGlobal) {
-			for (const m of externals) {
-				if (m.isOptional(moduleGraph)) {
-					optionalExternals.push(m);
-				} else {
-					requiredExternals.push(m);
-				}
-			}
-			externals = requiredExternals.concat(optionalExternals);
-		} else {
-			requiredExternals = externals;
+		const cacheEntry = failureCache.get(module);
+		if (cacheEntry) {
+			statistics.cached++;
+			return cacheEntry;
 		}
 
-		const replaceKeys = str => {
-			return compilation.getPath(str, {
-				chunk
-			});
-		};
+		// Already added?
+		if (config.has(module)) {
+			statistics.alreadyInConfig++;
+			return null;
+		}
 
-		const externalsDepsArray = modules => {
-			return `[${replaceKeys(
-				modules
-					.map(m =>
-						JSON.stringify(
-							typeof m.request === "object" ? m.request.amd : m.request
+		// Not possible to add?
+		if (!possibleModules.has(module)) {
+			statistics.invalidModule++;
+			failureCache.set(module, module); // cache failures for performance
+			return module;
+		}
+
+		// Module must be in the correct chunks
+		const missingChunks = Array.from(
+			chunkGraph.getModuleChunksIterable(config.rootModule)
+		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
+		if (missingChunks.length > 0) {
+			const problem = requestShortener => {
+				const missingChunksList = Array.from(
+					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
+				).sort();
+				const chunks = Array.from(
+					new Set(
+						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
+							chunk => chunk.name || "unnamed chunk(s)"
 						)
 					)
-					.join(", ")
-			)}]`;
-		};
-
-		const externalsRootArray = modules => {
-			return replaceKeys(
-				modules
-					.map(m => {
-						let request = m.request;
-						if (typeof request === "object") request = request.root;
-						return `root${accessorToObjectAccess([].concat(request))}`;
-					})
-					.join(", ")
-			);
-		};
-
-		const externalsRequireArray = type => {
-			return replaceKeys(
-				externals
-					.map(m => {
-						let expr;
-						let request = m.request;
-						if (typeof request === "object") {
-							request = request[type];
-						}
-						if (request === undefined) {
-							throw new Error(
-								"Missing external configuration for type:" + type
-							);
-						}
-						if (Array.isArray(request)) {
-							expr = `require(${JSON.stringify(
-								request[0]
-							)})${accessorToObjectAccess(request.slice(1))}`;
-						} else {
-							expr = `require(${JSON.stringify(request)})`;
-						}
-						if (m.isOptional(moduleGraph)) {
-							expr = `(function webpackLoadOptionalExternalModule() { try { return ${expr}; } catch(e) {} }())`;
-						}
-						return expr;
-					})
-					.join(", ")
-			);
-		};
+				).sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
+					", "
+				)}, module is in chunk(s) ${chunks.join(", ")})`;
+			};
+			statistics.incorrectChunks++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
+		}
 
-		const externalsArguments = modules => {
-			return modules
-				.map(
-					m =>
-						`__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-							`${chunkGraph.getModuleId(m)}`
-						)}__`
-				)
-				.join(", ");
-		};
+		const moduleGraph = compilation.moduleGraph;
 
-		const libraryName = library => {
-			return JSON.stringify(replaceKeys([].concat(library).pop()));
-		};
+		const incomingConnections =
+			moduleGraph.getIncomingConnectionsByOriginModule(module);
 
-		let amdFactory;
-		if (optionalExternals.length > 0) {
-			const wrapperArguments = externalsArguments(requiredExternals);
-			const factoryArguments =
-				requiredExternals.length > 0
-					? externalsArguments(requiredExternals) +
-					  ", " +
-					  externalsRootArray(optionalExternals)
-					: externalsRootArray(optionalExternals);
-			amdFactory =
-				`function webpackLoadOptionalExternalModuleAmd(${wrapperArguments}) {\n` +
-				`			return factory(${factoryArguments});\n` +
-				"		}";
-		} else {
-			amdFactory = "factory";
+		const incomingConnectionsFromNonModules =
+			incomingConnections.get(null) || incomingConnections.get(undefined);
+		if (incomingConnectionsFromNonModules) {
+			const activeNonModulesConnections =
+				incomingConnectionsFromNonModules.filter(connection => {
+					// We are not interested in inactive connections
+					// or connections without dependency
+					return connection.isActive(runtime) || connection.dependency;
+				});
+			if (activeNonModulesConnections.length > 0) {
+				const problem = requestShortener => {
+					const importingExplanations = new Set(
+						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
+					);
+					const explanations = Array.from(importingExplanations).sort();
+					return `Module ${module.readableIdentifier(
+						requestShortener
+					)} is referenced ${
+						explanations.length > 0
+							? `by: ${explanations.join(", ")}`
+							: "in an unsupported way"
+					}`;
+				};
+				statistics.incorrectDependency++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
 		}
 
-		const { auxiliaryComment, namedDefine, names } = options;
+		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
+		const incomingConnectionsFromModules = new Map();
+		for (const [originModule, connections] of incomingConnections) {
+			if (originModule) {
+				// Ignore connection from orphan modules
+				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
 
-		const getAuxiliaryComment = type => {
-			if (auxiliaryComment) {
-				if (typeof auxiliaryComment === "string")
-					return "\t//" + auxiliaryComment + "\n";
-				if (auxiliaryComment[type])
-					return "\t//" + auxiliaryComment[type] + "\n";
-			}
-			return "";
-		};
+				// We don't care for connections from other runtimes
+				let originRuntime = undefined;
+				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
+					originRuntime = mergeRuntimeOwned(originRuntime, r);
+				}
 
-		return new ConcatSource(
-			new OriginalSource(
-				"(function webpackUniversalModuleDefinition(root, factory) {\n" +
-					getAuxiliaryComment("commonjs2") +
-					"	if(typeof exports === 'object' && typeof module === 'object')\n" +
-					"		module.exports = factory(" +
-					externalsRequireArray("commonjs2") +
-					");\n" +
-					getAuxiliaryComment("amd") +
-					"	else if(typeof define === 'function' && define.amd)\n" +
-					(requiredExternals.length > 0
-						? names.amd && namedDefine === true
-							? "		define(" +
-							  libraryName(names.amd) +
-							  ", " +
-							  externalsDepsArray(requiredExternals) +
-							  ", " +
-							  amdFactory +
-							  ");\n"
-							: "		define(" +
-							  externalsDepsArray(requiredExternals) +
-							  ", " +
-							  amdFactory +
-							  ");\n"
-						: names.amd && namedDefine === true
-						? "		define(" +
-						  libraryName(names.amd) +
-						  ", [], " +
-						  amdFactory +
-						  ");\n"
-						: "		define([], " + amdFactory + ");\n") +
-					(names.root || names.commonjs
-						? getAuxiliaryComment("commonjs") +
-						  "	else if(typeof exports === 'object')\n" +
-						  "		exports[" +
-						  libraryName(names.commonjs || names.root) +
-						  "] = factory(" +
-						  externalsRequireArray("commonjs") +
-						  ");\n" +
-						  getAuxiliaryComment("root") +
-						  "	else\n" +
-						  "		" +
-						  replaceKeys(
-								accessorAccess("root", names.root || names.commonjs)
-						  ) +
-						  " = factory(" +
-						  externalsRootArray(externals) +
-						  ");\n"
-						: "	else {\n" +
-						  (externals.length > 0
-								? "		var a = typeof exports === 'object' ? factory(" +
-								  externalsRequireArray("commonjs") +
-								  ") : factory(" +
-								  externalsRootArray(externals) +
-								  ");\n"
-								: "		var a = factory();\n") +
-						  "		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" +
-						  "	}\n") +
-					`})(${
-						runtimeTemplate.outputOptions.globalObject
-					}, function(${externalsArguments(externals)}) {\nreturn `,
-				"webpack/universalModuleDefinition"
-			),
-			source,
-			";\n})"
-		);
-	}
-}
+				if (!intersectRuntime(runtime, originRuntime)) continue;
 
-module.exports = UmdLibraryPlugin;
+				// We are not interested in inactive connections
+				const activeConnections = connections.filter(connection =>
+					connection.isActive(runtime)
+				);
+				if (activeConnections.length > 0)
+					incomingConnectionsFromModules.set(originModule, activeConnections);
+			}
+		}
 
+		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
 
-/***/ }),
+		// Module must be in the same chunks like the referencing module
+		const otherChunkModules = incomingModules.filter(originModule => {
+			for (const chunk of chunkGraph.getModuleChunksIterable(
+				config.rootModule
+			)) {
+				if (!chunkGraph.isModuleInChunk(originModule, chunk)) {
+					return true;
+				}
+			}
+			return false;
+		});
+		if (otherChunkModules.length > 0) {
+			const problem = requestShortener => {
+				const names = otherChunkModules
+					.map(m => m.readableIdentifier(requestShortener))
+					.sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is referenced from different chunks by these modules: ${names.join(
+					", "
+				)}`;
+			};
+			statistics.incorrectChunksOfImporter++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
+		}
 
-/***/ 32597:
-/***/ (function(__unused_webpack_module, exports) {
+		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
+		const nonHarmonyConnections = new Map();
+		for (const [originModule, connections] of incomingConnectionsFromModules) {
+			const selected = connections.filter(
+				connection =>
+					!connection.dependency ||
+					!(connection.dependency instanceof HarmonyImportDependency)
+			);
+			if (selected.length > 0)
+				nonHarmonyConnections.set(originModule, connections);
+		}
+		if (nonHarmonyConnections.size > 0) {
+			const problem = requestShortener => {
+				const names = Array.from(nonHarmonyConnections)
+					.map(([originModule, connections]) => {
+						return `${originModule.readableIdentifier(
+							requestShortener
+						)} (referenced with ${Array.from(
+							new Set(
+								connections
+									.map(c => c.dependency && c.dependency.type)
+									.filter(Boolean)
+							)
+						)
+							.sort()
+							.join(", ")})`;
+					})
+					.sort();
+				return `Module ${module.readableIdentifier(
+					requestShortener
+				)} is referenced from these modules with unsupported syntax: ${names.join(
+					", "
+				)}`;
+			};
+			statistics.incorrectModuleDependency++;
+			failureCache.set(module, problem); // cache failures for performance
+			return problem;
+		}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		if (runtime !== undefined && typeof runtime !== "string") {
+			// Module must be consistently referenced in the same runtimes
+			/** @type {{ originModule: Module, runtimeCondition: RuntimeSpec }[]} */
+			const otherRuntimeConnections = [];
+			outer: for (const [
+				originModule,
+				connections
+			] of incomingConnectionsFromModules) {
+				/** @type {false | RuntimeSpec} */
+				let currentRuntimeCondition = false;
+				for (const connection of connections) {
+					const runtimeCondition = filterRuntime(runtime, runtime => {
+						return connection.isTargetActive(runtime);
+					});
+					if (runtimeCondition === false) continue;
+					if (runtimeCondition === true) continue outer;
+					if (currentRuntimeCondition !== false) {
+						currentRuntimeCondition = mergeRuntime(
+							currentRuntimeCondition,
+							runtimeCondition
+						);
+					} else {
+						currentRuntimeCondition = runtimeCondition;
+					}
+				}
+				if (currentRuntimeCondition !== false) {
+					otherRuntimeConnections.push({
+						originModule,
+						runtimeCondition: currentRuntimeCondition
+					});
+				}
+			}
+			if (otherRuntimeConnections.length > 0) {
+				const problem = requestShortener => {
+					return `Module ${module.readableIdentifier(
+						requestShortener
+					)} is runtime-dependent referenced by these modules: ${Array.from(
+						otherRuntimeConnections,
+						({ originModule, runtimeCondition }) =>
+							`${originModule.readableIdentifier(
+								requestShortener
+							)} (expected runtime ${runtimeToString(
+								runtime
+							)}, module is only referenced in ${runtimeToString(
+								/** @type {RuntimeSpec} */ (runtimeCondition)
+							)})`
+					).join(", ")}`;
+				};
+				statistics.incorrectRuntimeCondition++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
+		}
 
+		let backup;
+		if (avoidMutateOnFailure) {
+			backup = config.snapshot();
+		}
 
+		// Add the module
+		config.add(module);
 
-const LogType = Object.freeze({
-	error: /** @type {"error"} */ ("error"), // message, c style arguments
-	warn: /** @type {"warn"} */ ("warn"), // message, c style arguments
-	info: /** @type {"info"} */ ("info"), // message, c style arguments
-	log: /** @type {"log"} */ ("log"), // message, c style arguments
-	debug: /** @type {"debug"} */ ("debug"), // message, c style arguments
+		incomingModules.sort(compareModulesByIdentifier);
 
-	trace: /** @type {"trace"} */ ("trace"), // no arguments
+		// Every module which depends on the added module must be in the configuration too.
+		for (const originModule of incomingModules) {
+			const problem = this._tryToAdd(
+				compilation,
+				config,
+				originModule,
+				runtime,
+				activeRuntime,
+				possibleModules,
+				candidates,
+				failureCache,
+				chunkGraph,
+				false,
+				statistics
+			);
+			if (problem) {
+				if (backup !== undefined) config.rollback(backup);
+				statistics.importerFailed++;
+				failureCache.set(module, problem); // cache failures for performance
+				return problem;
+			}
+		}
 
-	group: /** @type {"group"} */ ("group"), // [label]
-	groupCollapsed: /** @type {"groupCollapsed"} */ ("groupCollapsed"), // [label]
-	groupEnd: /** @type {"groupEnd"} */ ("groupEnd"), // [label]
+		// Add imports to possible candidates list
+		for (const imp of this._getImports(compilation, module, runtime)) {
+			candidates.add(imp);
+		}
+		statistics.added++;
+		return null;
+	}
+}
 
-	profile: /** @type {"profile"} */ ("profile"), // [profileName]
-	profileEnd: /** @type {"profileEnd"} */ ("profileEnd"), // [profileName]
+class ConcatConfiguration {
+	/**
+	 * @param {Module} rootModule the root module
+	 * @param {RuntimeSpec} runtime the runtime
+	 */
+	constructor(rootModule, runtime) {
+		this.rootModule = rootModule;
+		this.runtime = runtime;
+		/** @type {Set<Module>} */
+		this.modules = new Set();
+		this.modules.add(rootModule);
+		/** @type {Map<Module, Module | function(RequestShortener): string>} */
+		this.warnings = new Map();
+	}
 
-	time: /** @type {"time"} */ ("time"), // name, time as [seconds, nanoseconds]
+	add(module) {
+		this.modules.add(module);
+	}
 
-	clear: /** @type {"clear"} */ ("clear"), // no arguments
-	status: /** @type {"status"} */ ("status") // message, arguments
-});
+	has(module) {
+		return this.modules.has(module);
+	}
 
-exports.LogType = LogType;
+	isEmpty() {
+		return this.modules.size === 1;
+	}
 
-/** @typedef {typeof LogType[keyof typeof LogType]} LogTypeEnum */
+	addWarning(module, problem) {
+		this.warnings.set(module, problem);
+	}
 
-const LOG_SYMBOL = Symbol("webpack logger raw log method");
-const TIMERS_SYMBOL = Symbol("webpack logger times");
-const TIMERS_AGGREGATES_SYMBOL = Symbol("webpack logger aggregated times");
+	getWarningsSorted() {
+		return new Map(
+			Array.from(this.warnings).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;
+			})
+		);
+	}
 
-class WebpackLogger {
 	/**
-	 * @param {function(LogTypeEnum, any[]=): void} log log function
-	 * @param {function(string | function(): string): WebpackLogger} getChildLogger function to create child logger
+	 * @returns {Set<Module>} modules as set
 	 */
-	constructor(log, getChildLogger) {
-		this[LOG_SYMBOL] = log;
-		this.getChildLogger = getChildLogger;
-	}
-
-	error(...args) {
-		this[LOG_SYMBOL](LogType.error, args);
-	}
-
-	warn(...args) {
-		this[LOG_SYMBOL](LogType.warn, args);
-	}
-
-	info(...args) {
-		this[LOG_SYMBOL](LogType.info, args);
-	}
-
-	log(...args) {
-		this[LOG_SYMBOL](LogType.log, args);
-	}
-
-	debug(...args) {
-		this[LOG_SYMBOL](LogType.debug, args);
-	}
-
-	assert(assertion, ...args) {
-		if (!assertion) {
-			this[LOG_SYMBOL](LogType.error, args);
-		}
-	}
-
-	trace() {
-		this[LOG_SYMBOL](LogType.trace, ["Trace"]);
-	}
-
-	clear() {
-		this[LOG_SYMBOL](LogType.clear);
-	}
-
-	status(...args) {
-		this[LOG_SYMBOL](LogType.status, args);
-	}
-
-	group(...args) {
-		this[LOG_SYMBOL](LogType.group, args);
-	}
-
-	groupCollapsed(...args) {
-		this[LOG_SYMBOL](LogType.groupCollapsed, args);
-	}
-
-	groupEnd(...args) {
-		this[LOG_SYMBOL](LogType.groupEnd, args);
-	}
-
-	profile(label) {
-		this[LOG_SYMBOL](LogType.profile, [label]);
-	}
-
-	profileEnd(label) {
-		this[LOG_SYMBOL](LogType.profileEnd, [label]);
-	}
-
-	time(label) {
-		this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
-		this[TIMERS_SYMBOL].set(label, process.hrtime());
-	}
-
-	timeLog(label) {
-		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
-		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
-		}
-		const time = process.hrtime(prev);
-		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	getModules() {
+		return this.modules;
 	}
 
-	timeEnd(label) {
-		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
-		if (!prev) {
-			throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
-		}
-		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
-		this[LOG_SYMBOL](LogType.time, [label, ...time]);
+	snapshot() {
+		return this.modules.size;
 	}
 
-	timeAggregate(label) {
-		const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
-		if (!prev) {
-			throw new Error(
-				`No such label '${label}' for WebpackLogger.timeAggregate()`
-			);
-		}
-		const time = process.hrtime(prev);
-		this[TIMERS_SYMBOL].delete(label);
-		this[TIMERS_AGGREGATES_SYMBOL] =
-			this[TIMERS_AGGREGATES_SYMBOL] || new Map();
-		const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
-		if (current !== undefined) {
-			if (time[1] + current[1] > 1e9) {
-				time[0] += current[0] + 1;
-				time[1] = time[1] - 1e9 + current[1];
+	rollback(snapshot) {
+		const modules = this.modules;
+		for (const m of modules) {
+			if (snapshot === 0) {
+				modules.delete(m);
 			} else {
-				time[0] += current[0];
-				time[1] += current[1];
+				snapshot--;
 			}
 		}
-		this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
-	}
-
-	timeAggregateEnd(label) {
-		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
-		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
-		if (time === undefined) return;
-		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
-		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 }
 
-exports.Logger = WebpackLogger;
+module.exports = ModuleConcatenationPlugin;
 
 
 /***/ }),
 
-/***/ 54963:
+/***/ 46043:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -104887,342 +104313,120 @@ exports.Logger = WebpackLogger;
 
 
 
-const { LogType } = __webpack_require__(32597);
-
-/** @typedef {import("../../declarations/WebpackOptions").FilterItemTypes} FilterItemTypes */
-/** @typedef {import("../../declarations/WebpackOptions").FilterTypes} FilterTypes */
-/** @typedef {import("./Logger").LogTypeEnum} LogTypeEnum */
-
-/** @typedef {function(string): boolean} FilterFunction */
+const { SyncBailHook } = __webpack_require__(6967);
+const { RawSource, CachedSource, CompatSource } = __webpack_require__(51255);
+const Compilation = __webpack_require__(85720);
+const WebpackError = __webpack_require__(53799);
+const { compareSelect, compareStrings } = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
 
-/**
- * @typedef {Object} LoggerConsole
- * @property {function(): void} clear
- * @property {function(): void} trace
- * @property {(...args: any[]) => void} info
- * @property {(...args: any[]) => void} log
- * @property {(...args: any[]) => void} warn
- * @property {(...args: any[]) => void} error
- * @property {(...args: any[]) => void=} debug
- * @property {(...args: any[]) => void=} group
- * @property {(...args: any[]) => void=} groupCollapsed
- * @property {(...args: any[]) => void=} groupEnd
- * @property {(...args: any[]) => void=} status
- * @property {(...args: any[]) => void=} profile
- * @property {(...args: any[]) => void=} profileEnd
- * @property {(...args: any[]) => void=} logTime
- */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compiler")} Compiler */
 
-/**
- * @typedef {Object} LoggerOptions
- * @property {false|true|"none"|"error"|"warn"|"info"|"log"|"verbose"} level loglevel
- * @property {FilterTypes|boolean} debug filter for debug logging
- * @property {LoggerConsole} console the console to log to
- */
+const EMPTY_SET = new Set();
 
-/**
- * @param {FilterItemTypes} item an input item
- * @returns {FilterFunction} filter function
- */
-const filterToFunction = item => {
-	if (typeof item === "string") {
-		const regExp = new RegExp(
-			`[\\\\/]${item.replace(
-				// eslint-disable-next-line no-useless-escape
-				/[-[\]{}()*+?.\\^$|]/g,
-				"\\$&"
-			)}([\\\\/]|$|!|\\?)`
-		);
-		return ident => regExp.test(ident);
-	}
-	if (item && typeof item === "object" && typeof item.test === "function") {
-		return ident => item.test(ident);
-	}
-	if (typeof item === "function") {
-		return item;
-	}
-	if (typeof item === "boolean") {
-		return () => item;
+const addToList = (itemOrItems, list) => {
+	if (Array.isArray(itemOrItems)) {
+		for (const item of itemOrItems) {
+			list.add(item);
+		}
+	} else if (itemOrItems) {
+		list.add(itemOrItems);
 	}
 };
 
 /**
- * @enum {number}
+ * @template T
+ * @param {T[]} input list
+ * @param {function(T): Buffer} fn map function
+ * @returns {Buffer[]} buffers without duplicates
  */
-const LogLevel = {
-	none: 6,
-	false: 6,
-	error: 5,
-	warn: 4,
-	info: 3,
-	log: 2,
-	true: 2,
-	verbose: 1
+const mapAndDeduplicateBuffers = (input, fn) => {
+	// Buffer.equals compares size first so this should be efficient enough
+	// If it becomes a performance problem we can use a map and group by size
+	// instead of looping over all assets.
+	const result = [];
+	outer: for (const value of input) {
+		const buf = fn(value);
+		for (const other of result) {
+			if (buf.equals(other)) continue outer;
+		}
+		result.push(buf);
+	}
+	return result;
 };
 
 /**
- * @param {LoggerOptions} options options object
- * @returns {function(string, LogTypeEnum, any[]): void} logging function
+ * Escapes regular expression metacharacters
+ * @param {string} str String to quote
+ * @returns {string} Escaped string
  */
-module.exports = ({ level = "info", debug = false, console }) => {
-	const debugFilters =
-		typeof debug === "boolean"
-			? [() => debug]
-			: /** @type {FilterItemTypes[]} */ ([])
-					.concat(debug)
-					.map(filterToFunction);
-	/** @type {number} */
-	const loglevel = LogLevel[`${level}`] || 0;
-
-	/**
-	 * @param {string} name name of the logger
-	 * @param {LogTypeEnum} type type of the log entry
-	 * @param {any[]} args arguments of the log entry
-	 * @returns {void}
-	 */
-	const logger = (name, type, args) => {
-		const labeledArgs = () => {
-			if (Array.isArray(args)) {
-				if (args.length > 0 && typeof args[0] === "string") {
-					return [`[${name}] ${args[0]}`, ...args.slice(1)];
-				} else {
-					return [`[${name}]`, ...args];
-				}
-			} else {
-				return [];
-			}
-		};
-		const debug = debugFilters.some(f => f(name));
-		switch (type) {
-			case LogType.debug:
-				if (!debug) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.debug === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.debug(...labeledArgs());
-				} else {
-					console.log(...labeledArgs());
-				}
-				break;
-			case LogType.log:
-				if (!debug && loglevel > LogLevel.log) return;
-				console.log(...labeledArgs());
-				break;
-			case LogType.info:
-				if (!debug && loglevel > LogLevel.info) return;
-				console.info(...labeledArgs());
-				break;
-			case LogType.warn:
-				if (!debug && loglevel > LogLevel.warn) return;
-				console.warn(...labeledArgs());
-				break;
-			case LogType.error:
-				if (!debug && loglevel > LogLevel.error) return;
-				console.error(...labeledArgs());
-				break;
-			case LogType.trace:
-				if (!debug) return;
-				console.trace();
-				break;
-			case LogType.groupCollapsed:
-				if (!debug && loglevel > LogLevel.log) return;
-				if (!debug && loglevel > LogLevel.verbose) {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					if (typeof console.groupCollapsed === "function") {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						console.groupCollapsed(...labeledArgs());
-					} else {
-						console.log(...labeledArgs());
-					}
-					break;
-				}
-			// falls through
-			case LogType.group:
-				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.group === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.group(...labeledArgs());
-				} else {
-					console.log(...labeledArgs());
-				}
-				break;
-			case LogType.groupEnd:
-				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.groupEnd === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.groupEnd();
-				}
-				break;
-			case LogType.time: {
-				if (!debug && loglevel > LogLevel.log) return;
-				const ms = args[1] * 1000 + args[2] / 1000000;
-				const msg = `[${name}] ${args[0]}: ${ms} ms`;
-				if (typeof console.logTime === "function") {
-					console.logTime(msg);
-				} else {
-					console.log(msg);
-				}
-				break;
-			}
-			case LogType.profile:
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.profile === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.profile(...labeledArgs());
-				}
-				break;
-			case LogType.profileEnd:
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.profileEnd === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.profileEnd(...labeledArgs());
-				}
-				break;
-			case LogType.clear:
-				if (!debug && loglevel > LogLevel.log) return;
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				if (typeof console.clear === "function") {
-					// eslint-disable-next-line node/no-unsupported-features/node-builtins
-					console.clear();
-				}
-				break;
-			case LogType.status:
-				if (!debug && loglevel > LogLevel.info) return;
-				if (typeof console.status === "function") {
-					if (args.length === 0) {
-						console.status();
-					} else {
-						console.status(...labeledArgs());
-					}
-				} else {
-					if (args.length !== 0) {
-						console.info(...labeledArgs());
-					}
-				}
-				break;
-			default:
-				throw new Error(`Unexpected LogType ${type}`);
-		}
-	};
-	return logger;
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 };
 
+const cachedSourceMap = new WeakMap();
 
-/***/ }),
-
-/***/ 62090:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const arraySum = array => {
-	let sum = 0;
-	for (const item of array) sum += item;
-	return sum;
+const toCachedSource = source => {
+	if (source instanceof CachedSource) {
+		return source;
+	}
+	const entry = cachedSourceMap.get(source);
+	if (entry !== undefined) return entry;
+	const newSource = new CachedSource(CompatSource.from(source));
+	cachedSourceMap.set(source, newSource);
+	return newSource;
 };
 
 /**
- * @param {any[]} args items to be truncated
- * @param {number} maxLength maximum length of args including spaces between
- * @returns {string[]} truncated args
+ * @typedef {Object} AssetInfoForRealContentHash
+ * @property {string} name
+ * @property {AssetInfo} info
+ * @property {Source} source
+ * @property {RawSource | undefined} newSource
+ * @property {RawSource | undefined} newSourceWithoutOwn
+ * @property {string} content
+ * @property {Set<string>} ownHashes
+ * @property {Promise} contentComputePromise
+ * @property {Promise} contentComputeWithoutOwnPromise
+ * @property {Set<string>} referencedHashes
+ * @property {Set<string>} hashes
  */
-const truncateArgs = (args, maxLength) => {
-	const lengths = args.map(a => `${a}`.length);
-	const availableLength = maxLength - lengths.length + 1;
-
-	if (availableLength > 0 && args.length === 1) {
-		if (availableLength >= args[0].length) {
-			return args;
-		} else if (availableLength > 3) {
-			return ["..." + args[0].slice(-availableLength + 3)];
-		} else {
-			return [args[0].slice(-availableLength)];
-		}
-	}
-
-	// Check if there is space for at least 4 chars per arg
-	if (availableLength < arraySum(lengths.map(i => Math.min(i, 6)))) {
-		// remove args
-		if (args.length > 1)
-			return truncateArgs(args.slice(0, args.length - 1), maxLength);
-		return [];
-	}
 
-	let currentLength = arraySum(lengths);
+/**
+ * @typedef {Object} CompilationHooks
+ * @property {SyncBailHook<[Buffer[], string], string>} updateHash
+ */
 
-	// Check if all fits into maxLength
-	if (currentLength <= availableLength) return args;
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
-	// Try to remove chars from the longest items until it fits
-	while (currentLength > availableLength) {
-		const maxLength = Math.max(...lengths);
-		const shorterItems = lengths.filter(l => l !== maxLength);
-		const nextToMaxLength =
-			shorterItems.length > 0 ? Math.max(...shorterItems) : 0;
-		const maxReduce = maxLength - nextToMaxLength;
-		let maxItems = lengths.length - shorterItems.length;
-		let overrun = currentLength - availableLength;
-		for (let i = 0; i < lengths.length; i++) {
-			if (lengths[i] === maxLength) {
-				const reduce = Math.min(Math.floor(overrun / maxItems), maxReduce);
-				lengths[i] -= reduce;
-				currentLength -= reduce;
-				overrun -= reduce;
-				maxItems--;
-			}
+class RealContentHashPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				updateHash: new SyncBailHook(["content", "oldHash"])
+			};
+			compilationHooksMap.set(compilation, hooks);
 		}
+		return hooks;
 	}
 
-	// Return args reduced to length in lengths
-	return args.map((a, i) => {
-		const str = `${a}`;
-		const length = lengths[i];
-		if (str.length === length) {
-			return str;
-		} else if (length > 5) {
-			return "..." + str.slice(-length + 3);
-		} else if (length > 0) {
-			return str.slice(-length);
-		} else {
-			return "";
-		}
-	});
-};
-
-module.exports = truncateArgs;
-
-
-/***/ }),
-
-/***/ 1313:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const StartupChunkDependenciesPlugin = __webpack_require__(22339);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-class CommonJsChunkLoadingPlugin {
-	constructor(options) {
-		options = options || {};
-		this._asyncChunkLoading = options.asyncChunkLoading;
-	}
+	constructor({ hashFunction, hashDigest }) {
+		this._hashFunction = hashFunction;
+		this._hashDigest = hashDigest;
+	}
 
 	/**
 	 * Apply the plugin
@@ -105230,92 +104434,291 @@ class CommonJsChunkLoadingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const ChunkLoadingRuntimeModule = this._asyncChunkLoading
-			? __webpack_require__(73369)
-			: __webpack_require__(94172);
-		const chunkLoadingValue = this._asyncChunkLoading
-			? "async-node"
-			: "require";
-		new StartupChunkDependenciesPlugin({
-			chunkLoading: chunkLoadingValue,
-			asyncChunkLoading: this._asyncChunkLoading
-		}).apply(compiler);
-		compiler.hooks.thisCompilation.tap(
-			"CommonJsChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === chunkLoadingValue;
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new ChunkLoadingRuntimeModule(set)
+		compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
+			const cacheAnalyse = compilation.getCache(
+				"RealContentHashPlugin|analyse"
+			);
+			const cacheGenerate = compilation.getCache(
+				"RealContentHashPlugin|generate"
+			);
+			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
+			compilation.hooks.processAssets.tapPromise(
+				{
+					name: "RealContentHashPlugin",
+					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
+				},
+				async () => {
+					const assets = compilation.getAssets();
+					/** @type {AssetInfoForRealContentHash[]} */
+					const assetsWithInfo = [];
+					const hashToAssets = new Map();
+					for (const { source, info, name } of assets) {
+						const cachedSource = toCachedSource(source);
+						const content = cachedSource.source();
+						/** @type {Set<string>} */
+						const hashes = new Set();
+						addToList(info.contenthash, hashes);
+						const data = {
+							name,
+							info,
+							source: cachedSource,
+							/** @type {RawSource | undefined} */
+							newSource: undefined,
+							/** @type {RawSource | undefined} */
+							newSourceWithoutOwn: undefined,
+							content,
+							/** @type {Set<string>} */
+							ownHashes: undefined,
+							contentComputePromise: undefined,
+							contentComputeWithoutOwnPromise: undefined,
+							/** @type {Set<string>} */
+							referencedHashes: undefined,
+							hashes
+						};
+						assetsWithInfo.push(data);
+						for (const hash of hashes) {
+							const list = hashToAssets.get(hash);
+							if (list === undefined) {
+								hashToAssets.set(hash, [data]);
+							} else {
+								list.push(data);
+							}
+						}
+					}
+					if (hashToAssets.size === 0) return;
+					const hashRegExp = new RegExp(
+						Array.from(hashToAssets.keys(), quoteMeta).join("|"),
+						"g"
 					);
-				};
+					await Promise.all(
+						assetsWithInfo.map(async asset => {
+							const { name, source, content, hashes } = asset;
+							if (Buffer.isBuffer(content)) {
+								asset.referencedHashes = EMPTY_SET;
+								asset.ownHashes = EMPTY_SET;
+								return;
+							}
+							const etag = cacheAnalyse.mergeEtags(
+								cacheAnalyse.getLazyHashedEtag(source),
+								Array.from(hashes).join("|")
+							);
+							[asset.referencedHashes, asset.ownHashes] =
+								await cacheAnalyse.providePromise(name, etag, () => {
+									const referencedHashes = new Set();
+									let ownHashes = new Set();
+									const inContent = content.match(hashRegExp);
+									if (inContent) {
+										for (const hash of inContent) {
+											if (hashes.has(hash)) {
+												ownHashes.add(hash);
+												continue;
+											}
+											referencedHashes.add(hash);
+										}
+									}
+									return [referencedHashes, ownHashes];
+								});
+						})
+					);
+					const getDependencies = hash => {
+						const assets = hashToAssets.get(hash);
+						if (!assets) {
+							const referencingAssets = assetsWithInfo.filter(asset =>
+								asset.referencedHashes.has(hash)
+							);
+							const err = new WebpackError(`RealContentHashPlugin
+Some kind of unexpected caching problem occurred.
+An asset was cached with a reference to another asset (${hash}) that's not in the compilation anymore.
+Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
+Referenced by:
+${referencingAssets
+	.map(a => {
+		const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(
+			a.content
+		);
+		return ` - ${a.name}: ...${match ? match[0] : "???"}...`;
+	})
+	.join("\n")}`);
+							compilation.errors.push(err);
+							return undefined;
+						}
+						const hashes = new Set();
+						for (const { referencedHashes, ownHashes } of assets) {
+							if (!ownHashes.has(hash)) {
+								for (const hash of ownHashes) {
+									hashes.add(hash);
+								}
+							}
+							for (const hash of referencedHashes) {
+								hashes.add(hash);
+							}
+						}
+						return hashes;
+					};
+					const hashInfo = hash => {
+						const assets = hashToAssets.get(hash);
+						return `${hash} (${Array.from(assets, a => a.name)})`;
+					};
+					const hashesInOrder = new Set();
+					for (const hash of hashToAssets.keys()) {
+						const add = (hash, stack) => {
+							const deps = getDependencies(hash);
+							if (!deps) return;
+							stack.add(hash);
+							for (const dep of deps) {
+								if (hashesInOrder.has(dep)) continue;
+								if (stack.has(dep)) {
+									throw new Error(
+										`Circular hash dependency ${Array.from(
+											stack,
+											hashInfo
+										).join(" -> ")} -> ${hashInfo(dep)}`
+									);
+								}
+								add(dep, stack);
+							}
+							hashesInOrder.add(hash);
+							stack.delete(hash);
+						};
+						if (hashesInOrder.has(hash)) continue;
+						add(hash, new Set());
+					}
+					const hashToNewHash = new Map();
+					const getEtag = asset =>
+						cacheGenerate.mergeEtags(
+							cacheGenerate.getLazyHashedEtag(asset.source),
+							Array.from(asset.referencedHashes, hash =>
+								hashToNewHash.get(hash)
+							).join("|")
+						);
+					const computeNewContent = asset => {
+						if (asset.contentComputePromise) return asset.contentComputePromise;
+						return (asset.contentComputePromise = (async () => {
+							if (
+								asset.ownHashes.size > 0 ||
+								Array.from(asset.referencedHashes).some(
+									hash => hashToNewHash.get(hash) !== hash
+								)
+							) {
+								const identifier = asset.name;
+								const etag = getEtag(asset);
+								asset.newSource = await cacheGenerate.providePromise(
+									identifier,
+									etag,
+									() => {
+										const newContent = asset.content.replace(hashRegExp, hash =>
+											hashToNewHash.get(hash)
+										);
+										return new RawSource(newContent);
+									}
+								);
+							}
+						})());
+					};
+					const computeNewContentWithoutOwn = asset => {
+						if (asset.contentComputeWithoutOwnPromise)
+							return asset.contentComputeWithoutOwnPromise;
+						return (asset.contentComputeWithoutOwnPromise = (async () => {
+							if (
+								asset.ownHashes.size > 0 ||
+								Array.from(asset.referencedHashes).some(
+									hash => hashToNewHash.get(hash) !== hash
+								)
+							) {
+								const identifier = asset.name + "|without-own";
+								const etag = getEtag(asset);
+								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
+									identifier,
+									etag,
+									() => {
+										const newContent = asset.content.replace(
+											hashRegExp,
+											hash => {
+												if (asset.ownHashes.has(hash)) {
+													return "";
+												}
+												return hashToNewHash.get(hash);
+											}
+										);
+										return new RawSource(newContent);
+									}
+								);
+							}
+						})());
+					};
+					const comparator = compareSelect(a => a.name, compareStrings);
+					for (const oldHash of hashesInOrder) {
+						const assets = hashToAssets.get(oldHash);
+						assets.sort(comparator);
+						const hash = createHash(this._hashFunction);
+						await Promise.all(
+							assets.map(asset =>
+								asset.ownHashes.has(oldHash)
+									? computeNewContentWithoutOwn(asset)
+									: computeNewContent(asset)
+							)
+						);
+						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
+							if (asset.ownHashes.has(oldHash)) {
+								return asset.newSourceWithoutOwn
+									? asset.newSourceWithoutOwn.buffer()
+									: asset.source.buffer();
+							} else {
+								return asset.newSource
+									? asset.newSource.buffer()
+									: asset.source.buffer();
+							}
+						});
+						let newHash = hooks.updateHash.call(assetsContent, oldHash);
+						if (!newHash) {
+							for (const content of assetsContent) {
+								hash.update(content);
+							}
+							const digest = hash.digest(this._hashDigest);
+							newHash = /** @type {string} */ (digest.slice(0, oldHash.length));
+						}
+						hashToNewHash.set(oldHash, newHash);
+					}
+					await Promise.all(
+						assetsWithInfo.map(async asset => {
+							await computeNewContent(asset);
+							const newName = asset.name.replace(hashRegExp, hash =>
+								hashToNewHash.get(hash)
+							);
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("CommonJsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("CommonJsChunkLoadingPlugin", handler);
+							const infoUpdate = {};
+							const hash = asset.info.contenthash;
+							infoUpdate.contenthash = Array.isArray(hash)
+								? hash.map(hash => hashToNewHash.get(hash))
+								: hashToNewHash.get(hash);
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("CommonJsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
-			}
-		);
+							if (asset.newSource !== undefined) {
+								compilation.updateAsset(
+									asset.name,
+									asset.newSource,
+									infoUpdate
+								);
+							} else {
+								compilation.updateAsset(asset.name, asset.source, infoUpdate);
+							}
+
+							if (asset.name !== newName) {
+								compilation.renameAsset(asset.name, newName);
+							}
+						})
+					);
+				}
+			);
+		});
 	}
 }
 
-module.exports = CommonJsChunkLoadingPlugin;
+module.exports = RealContentHashPlugin;
 
 
 /***/ }),
 
-/***/ 7553:
+/***/ 84760:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -105326,65 +104729,62 @@ module.exports = CommonJsChunkLoadingPlugin;
 
 
 
-const CachedInputFileSystem = __webpack_require__(89429);
-const fs = __webpack_require__(90552);
-const createConsoleLogger = __webpack_require__(54963);
-const NodeWatchFileSystem = __webpack_require__(98810);
-const nodeConsole = __webpack_require__(91786);
+const { STAGE_BASIC, STAGE_ADVANCED } = __webpack_require__(80057);
 
-/** @typedef {import("../../declarations/WebpackOptions").InfrastructureLogging} InfrastructureLogging */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
-class NodeEnvironmentPlugin {
-	/**
-	 * @param {Object} options options
-	 * @param {InfrastructureLogging} options.infrastructureLogging infrastructure logging options
-	 */
-	constructor(options) {
-		this.options = options;
-	}
-
+class RemoveEmptyChunksPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const { infrastructureLogging } = this.options;
-		compiler.infrastructureLogger = createConsoleLogger({
-			level: infrastructureLogging.level || "info",
-			debug: infrastructureLogging.debug || false,
-			console:
-				infrastructureLogging.console ||
-				nodeConsole({
-					colors: infrastructureLogging.colors,
-					appendOnly: infrastructureLogging.appendOnly,
-					stream: infrastructureLogging.stream
-				})
-		});
-		compiler.inputFileSystem = new CachedInputFileSystem(fs, 60000);
-		const inputFileSystem = compiler.inputFileSystem;
-		compiler.outputFileSystem = fs;
-		compiler.intermediateFileSystem = fs;
-		compiler.watchFileSystem = new NodeWatchFileSystem(
-			compiler.inputFileSystem
-		);
-		compiler.hooks.beforeRun.tap("NodeEnvironmentPlugin", compiler => {
-			if (compiler.inputFileSystem === inputFileSystem) {
-				compiler.fsStartTime = Date.now();
-				inputFileSystem.purge();
-			}
+		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
+			/**
+			 * @param {Iterable<Chunk>} chunks the chunks array
+			 * @returns {void}
+			 */
+			const handler = chunks => {
+				const chunkGraph = compilation.chunkGraph;
+				for (const chunk of chunks) {
+					if (
+						chunkGraph.getNumberOfChunkModules(chunk) === 0 &&
+						!chunk.hasRuntime() &&
+						chunkGraph.getNumberOfEntryModules(chunk) === 0
+					) {
+						compilation.chunkGraph.disconnectChunk(chunk);
+						compilation.chunks.delete(chunk);
+					}
+				}
+			};
+
+			// TODO do it once
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "RemoveEmptyChunksPlugin",
+					stage: STAGE_BASIC
+				},
+				handler
+			);
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "RemoveEmptyChunksPlugin",
+					stage: STAGE_ADVANCED
+				},
+				handler
+			);
 		});
 	}
 }
-
-module.exports = NodeEnvironmentPlugin;
+module.exports = RemoveEmptyChunksPlugin;
 
 
 /***/ }),
 
-/***/ 7103:
-/***/ (function(module) {
+/***/ 7081:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -105394,112 +104794,126 @@ module.exports = NodeEnvironmentPlugin;
 
 
 
+const { STAGE_BASIC } = __webpack_require__(80057);
+const Queue = __webpack_require__(65930);
+const { intersect } = __webpack_require__(93347);
+
 /** @typedef {import("../Compiler")} Compiler */
 
-class NodeSourcePlugin {
+class RemoveParentModulesPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
-	apply(compiler) {}
-}
-
-module.exports = NodeSourcePlugin;
-
-
-/***/ }),
-
-/***/ 17916:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const ExternalsPlugin = __webpack_require__(6652);
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
+			const handler = (chunks, chunkGroups) => {
+				const chunkGraph = compilation.chunkGraph;
+				const queue = new Queue();
+				const availableModulesMap = new WeakMap();
 
-/** @typedef {import("../Compiler")} Compiler */
+				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);
+					}
+				}
+				for (const chunkGroup of compilation.asyncEntrypoints) {
+					// initialize available modules for chunks without parents
+					availableModulesMap.set(chunkGroup, new Set());
+					for (const child of chunkGroup.childrenIterable) {
+						queue.enqueue(child);
+					}
+				}
 
-const builtins = [
-	"assert",
-	"async_hooks",
-	"buffer",
-	"child_process",
-	"cluster",
-	"console",
-	"constants",
-	"crypto",
-	"dgram",
-	"diagnostics_channel",
-	"dns",
-	"dns/promises",
-	"domain",
-	"events",
-	"fs",
-	"fs/promises",
-	"http",
-	"http2",
-	"https",
-	"inspector",
-	"module",
-	"net",
-	"os",
-	"path",
-	"path/posix",
-	"path/win32",
-	"perf_hooks",
-	"process",
-	"punycode",
-	"querystring",
-	"readline",
-	"repl",
-	"stream",
-	"stream/promises",
-	"stream/web",
-	"string_decoder",
-	"sys",
-	"timers",
-	"timers/promises",
-	"tls",
-	"trace_events",
-	"tty",
-	"url",
-	"util",
-	"v8",
-	"vm",
-	"wasi",
-	"worker_threads",
-	"zlib",
-	/^node:/,
-
-	// cspell:word pnpapi
-	// Yarn PnP adds pnpapi as "builtin"
-	"pnpapi"
-];
+				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 chunkGraph.getChunkModulesIterable(chunk)) {
+										availableModules.add(m);
+									}
+								}
+								availableModulesMap.set(chunkGroup, availableModules);
+								changed = true;
+							} else {
+								for (const m of availableModules) {
+									if (
+										!chunkGraph.isModuleInChunkGroup(m, parent) &&
+										!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);
+						}
+					}
+				}
 
-class NodeTargetPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
+				// 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 = chunkGraph.getNumberOfChunkModules(chunk);
+					const toRemove = new Set();
+					if (numberOfModules < availableModules.size) {
+						for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+							if (availableModules.has(m)) {
+								toRemove.add(m);
+							}
+						}
+					} else {
+						for (const m of availableModules) {
+							if (chunkGraph.isModuleInChunk(m, chunk)) {
+								toRemove.add(m);
+							}
+						}
+					}
+					for (const module of toRemove) {
+						chunkGraph.disconnectChunkAndModule(chunk, module);
+					}
+				}
+			};
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "RemoveParentModulesPlugin",
+					stage: STAGE_BASIC
+				},
+				handler
+			);
+		});
 	}
 }
-
-module.exports = NodeTargetPlugin;
+module.exports = RemoveParentModulesPlugin;
 
 
 /***/ }),
 
-/***/ 61052:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 2837:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -105509,14 +104923,14 @@ module.exports = NodeTargetPlugin;
 
 
 
-const CommonJsChunkFormatPlugin = __webpack_require__(84508);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
-
 /** @typedef {import("../Compiler")} Compiler */
 
-class NodeTemplatePlugin {
+class RuntimeChunkPlugin {
 	constructor(options) {
-		this._options = options || {};
+		this.options = {
+			name: entrypoint => `runtime~${entrypoint.name}`,
+			...options
+		};
 	}
 
 	/**
@@ -105525,21 +104939,32 @@ class NodeTemplatePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const chunkLoading = this._options.asyncChunkLoading
-			? "async-node"
-			: "require";
-		compiler.options.output.chunkLoading = chunkLoading;
-		new CommonJsChunkFormatPlugin().apply(compiler);
-		new EnableChunkLoadingPlugin(chunkLoading).apply(compiler);
+		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
+			compilation.hooks.addEntry.tap(
+				"RuntimeChunkPlugin",
+				(_, { name: entryName }) => {
+					if (entryName === undefined) return;
+					const data = compilation.entries.get(entryName);
+					if (data.options.runtime === undefined && !data.options.dependOn) {
+						// Determine runtime chunk name
+						let name = this.options.name;
+						if (typeof name === "function") {
+							name = name({ name: entryName });
+						}
+						data.options.runtime = name;
+					}
+				}
+			);
+		});
 	}
 }
 
-module.exports = NodeTemplatePlugin;
+module.exports = RuntimeChunkPlugin;
 
 
 /***/ }),
 
-/***/ 98810:
+/***/ 84800:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -105550,482 +104975,341 @@ module.exports = NodeTemplatePlugin;
 
 
 
-const util = __webpack_require__(73837);
-const Watchpack = __webpack_require__(36871);
-
-/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
-/** @typedef {import("../util/fs").WatchFileSystem} WatchFileSystem */
-/** @typedef {import("../util/fs").WatchMethod} WatchMethod */
-/** @typedef {import("../util/fs").Watcher} Watcher */
-
-class NodeWatchFileSystem {
-	constructor(inputFileSystem) {
-		this.inputFileSystem = inputFileSystem;
-		this.watcherOptions = {
-			aggregateTimeout: 0
-		};
-		this.watcher = new Watchpack(this.watcherOptions);
-	}
-
-	/**
-	 * @param {Iterable<string>} files watched files
-	 * @param {Iterable<string>} directories watched directories
-	 * @param {Iterable<string>} missing watched exitance entries
-	 * @param {number} startTime timestamp of start time
-	 * @param {WatchOptions} options options object
-	 * @param {function(Error=, Map<string, FileSystemInfoEntry>, Map<string, FileSystemInfoEntry>, Set<string>, Set<string>): void} callback aggregated callback
-	 * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
-	 * @returns {Watcher} a watcher
-	 */
-	watch(
-		files,
-		directories,
-		missing,
-		startTime,
-		options,
-		callback,
-		callbackUndelayed
-	) {
-		if (!files || typeof files[Symbol.iterator] !== "function") {
-			throw new Error("Invalid arguments: 'files'");
-		}
-		if (!directories || typeof directories[Symbol.iterator] !== "function") {
-			throw new Error("Invalid arguments: 'directories'");
-		}
-		if (!missing || typeof missing[Symbol.iterator] !== "function") {
-			throw new Error("Invalid arguments: 'missing'");
-		}
-		if (typeof callback !== "function") {
-			throw new Error("Invalid arguments: 'callback'");
-		}
-		if (typeof startTime !== "number" && startTime) {
-			throw new Error("Invalid arguments: 'startTime'");
-		}
-		if (typeof options !== "object") {
-			throw new Error("Invalid arguments: 'options'");
-		}
-		if (typeof callbackUndelayed !== "function" && callbackUndelayed) {
-			throw new Error("Invalid arguments: 'callbackUndelayed'");
-		}
-		const oldWatcher = this.watcher;
-		this.watcher = new Watchpack(options);
+const glob2regexp = __webpack_require__(86140);
+const { STAGE_DEFAULT } = __webpack_require__(80057);
+const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
+const HarmonyImportSpecifierDependency = __webpack_require__(14077);
+const formatLocation = __webpack_require__(16734);
 
-		if (callbackUndelayed) {
-			this.watcher.once("change", callbackUndelayed);
-		}
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
-		const fetchTimeInfo = () => {
-			const fileTimeInfoEntries = new Map();
-			const contextTimeInfoEntries = new Map();
-			if (this.watcher) {
-				this.watcher.collectTimeInfoEntries(
-					fileTimeInfoEntries,
-					contextTimeInfoEntries
-				);
-			}
-			return { fileTimeInfoEntries, contextTimeInfoEntries };
-		};
-		this.watcher.once("aggregated", (changes, removals) => {
-			// pause emitting events (avoids clearing aggregated changes and removals on timeout)
-			this.watcher.pause();
+/**
+ * @typedef {Object} ExportInModule
+ * @property {Module} module the module
+ * @property {string} exportName the name of the export
+ * @property {boolean} checked if the export is conditional
+ */
 
-			if (this.inputFileSystem && this.inputFileSystem.purge) {
-				const fs = this.inputFileSystem;
-				for (const item of changes) {
-					fs.purge(item);
-				}
-				for (const item of removals) {
-					fs.purge(item);
-				}
-			}
-			const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
-			callback(
-				null,
-				fileTimeInfoEntries,
-				contextTimeInfoEntries,
-				changes,
-				removals
-			);
-		});
+/**
+ * @typedef {Object} ReexportInfo
+ * @property {Map<string, ExportInModule[]>} static
+ * @property {Map<Module, Set<string>>} dynamic
+ */
 
-		this.watcher.watch({ files, directories, missing, startTime });
+/** @type {WeakMap<any, Map<string, RegExp>>} */
+const globToRegexpCache = new WeakMap();
 
-		if (oldWatcher) {
-			oldWatcher.close();
-		}
-		return {
-			close: () => {
-				if (this.watcher) {
-					this.watcher.close();
-					this.watcher = null;
-				}
-			},
-			pause: () => {
-				if (this.watcher) {
-					this.watcher.pause();
-				}
-			},
-			getAggregatedRemovals: util.deprecate(
-				() => {
-					const items = this.watcher && this.watcher.aggregatedRemovals;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
-						for (const item of items) {
-							fs.purge(item);
-						}
-					}
-					return items;
-				},
-				"Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS"
-			),
-			getAggregatedChanges: util.deprecate(
-				() => {
-					const items = this.watcher && this.watcher.aggregatedChanges;
-					if (items && this.inputFileSystem && this.inputFileSystem.purge) {
-						const fs = this.inputFileSystem;
-						for (const item of items) {
-							fs.purge(item);
-						}
-					}
-					return items;
-				},
-				"Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES"
-			),
-			getFileTimeInfoEntries: util.deprecate(
-				() => {
-					return fetchTimeInfo().fileTimeInfoEntries;
-				},
-				"Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES"
-			),
-			getContextTimeInfoEntries: util.deprecate(
-				() => {
-					return fetchTimeInfo().contextTimeInfoEntries;
-				},
-				"Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.",
-				"DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES"
-			),
-			getInfo: () => {
-				const removals = this.watcher && this.watcher.aggregatedRemovals;
-				const changes = this.watcher && this.watcher.aggregatedChanges;
-				if (this.inputFileSystem && this.inputFileSystem.purge) {
-					const fs = this.inputFileSystem;
-					if (removals) {
-						for (const item of removals) {
-							fs.purge(item);
-						}
-					}
-					if (changes) {
-						for (const item of changes) {
-							fs.purge(item);
-						}
-					}
-				}
-				const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
-				return {
-					changes,
-					removals,
-					fileTimeInfoEntries,
-					contextTimeInfoEntries
-				};
-			}
-		};
+/**
+ * @param {string} glob the pattern
+ * @param {Map<string, RegExp>} cache the glob to RegExp cache
+ * @returns {RegExp} a regular expression
+ */
+const globToRegexp = (glob, cache) => {
+	const cacheEntry = cache.get(glob);
+	if (cacheEntry !== undefined) return cacheEntry;
+	if (!glob.includes("/")) {
+		glob = `**/${glob}`;
 	}
-}
-
-module.exports = NodeWatchFileSystem;
-
-
-/***/ }),
-
-/***/ 73369:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
+	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
+	const regexpSource = baseRegexp.source;
+	const regexp = new RegExp("^(\\./)?" + regexpSource.slice(1));
+	cache.set(glob, regexp);
+	return regexp;
+};
 
-class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.runtimeRequirements = runtimeRequirements;
+class SideEffectsFlagPlugin {
+	/**
+	 * @param {boolean} analyseSource analyse source code for side effects
+	 */
+	constructor(analyseSource = true) {
+		this._analyseSource = analyseSource;
 	}
-
 	/**
-	 * @returns {string} runtime code
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withExternalInstallChunk = this.runtimeRequirements.has(
-			RuntimeGlobals.externalInstallChunk
-		);
-		const withOnChunkLoad = this.runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withLoading = this.runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withHmr = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
-
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			false
-		);
-
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_readFileVm`
-			: undefined;
+	apply(compiler) {
+		let cache = globToRegexpCache.get(compiler.root);
+		if (cache === undefined) {
+			cache = new Map();
+			globToRegexpCache.set(compiler.root, cache);
+		}
+		compiler.hooks.compilation.tap(
+			"SideEffectsFlagPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const moduleGraph = compilation.moduleGraph;
+				normalModuleFactory.hooks.module.tap(
+					"SideEffectsFlagPlugin",
+					(module, data) => {
+						const resolveData = data.resourceResolveData;
+						if (
+							resolveData &&
+							resolveData.descriptionFileData &&
+							resolveData.relativePath
+						) {
+							const sideEffects = resolveData.descriptionFileData.sideEffects;
+							if (sideEffects !== undefined) {
+								if (module.factoryMeta === undefined) {
+									module.factoryMeta = {};
+								}
+								const hasSideEffects =
+									SideEffectsFlagPlugin.moduleHasSideEffects(
+										resolveData.relativePath,
+										sideEffects,
+										cache
+									);
+								module.factoryMeta.sideEffectFree = !hasSideEffects;
+							}
+						}
 
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
-							rootOutputDir
-								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
-								: "__filename"
-						});`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded chunks",
-			'// "0" means "already loaded", Promise means loading',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.readFileVm = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId] === 0",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded",
-			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
-						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
-						"for(var moduleId in moreModules) {",
-						Template.indent([
-							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-							Template.indent([
-								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-							]),
-							"}"
-						]),
-						"}",
-						`if(runtime) runtime(__webpack_require__);`,
-						"for(var i = 0; i < chunkIds.length; i++) {",
-						Template.indent([
-							"if(installedChunks[chunkIds[i]]) {",
-							Template.indent(["installedChunks[chunkIds[i]][0]();"]),
-							"}",
-							"installedChunks[chunkIds[i]] = 0;"
-						]),
-						"}",
-						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
-				  ])};`
-				: "// no chunk install function needed",
-			"",
-			withLoading
-				? Template.asString([
-						"// ReadFile + VM.run chunk loading for javascript",
-						`${fn}.readFileVm = function(chunkId, promises) {`,
-						hasJsMatcher !== false
-							? Template.indent([
-									"",
-									"var installedChunkData = installedChunks[chunkId];",
-									'if(installedChunkData !== 0) { // 0 means "already installed".',
-									Template.indent([
-										'// array of [resolve, reject, promise] means "currently loading"',
-										"if(installedChunkData) {",
-										Template.indent(["promises.push(installedChunkData[2]);"]),
-										"} else {",
-										Template.indent([
-											hasJsMatcher === true
-												? "if(true) { // all chunks have JS"
-												: `if(${hasJsMatcher("chunkId")}) {`,
-											Template.indent([
-												"// load the chunk and return promise to it",
-												"var promise = new Promise(function(resolve, reject) {",
-												Template.indent([
-													"installedChunkData = installedChunks[chunkId] = [resolve, reject];",
-													`var filename = require('path').join(__dirname, ${JSON.stringify(
-														rootOutputDir
-													)} + ${
-														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId));`,
-													"require('fs').readFile(filename, 'utf-8', function(err, content) {",
-													Template.indent([
-														"if(err) return reject(err);",
-														"var chunk = {};",
-														"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
-															"(chunk, require, require('path').dirname(filename), filename);",
-														"installChunk(chunk);"
-													]),
-													"});"
-												]),
-												"});",
-												"promises.push(installedChunkData[2] = promise);"
-											]),
-											"} else installedChunks[chunkId] = 0;"
-										]),
-										"}"
-									]),
-									"}"
-							  ])
-							: Template.indent(["installedChunks[chunkId] = 0;"]),
-						"};"
-				  ])
-				: "// no chunk loading",
-			"",
-			withExternalInstallChunk
-				? Template.asString([
-						"module.exports = __webpack_require__;",
-						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
-				  ])
-				: "// no external install chunk",
-			"",
-			withHmr
-				? Template.asString([
-						"function loadUpdateChunk(chunkId, updatedModulesList) {",
-						Template.indent([
-							"return new Promise(function(resolve, reject) {",
-							Template.indent([
-								`var filename = require('path').join(__dirname, ${JSON.stringify(
-									rootOutputDir
-								)} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId));`,
-								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
-								Template.indent([
-									"if(err) return reject(err);",
-									"var update = {};",
-									"require('vm').runInThisContext('(function(exports, require, __dirname, __filename) {' + content + '\\n})', filename)" +
-										"(update, require, require('path').dirname(filename), filename);",
-									"var updatedModules = update.modules;",
-									"var runtime = update.runtime;",
-									"for(var moduleId in updatedModules) {",
-									Template.indent([
-										`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
-										Template.indent([
-											`currentUpdate[moduleId] = updatedModules[moduleId];`,
-											"if(updatedModulesList) updatedModulesList.push(moduleId);"
-										]),
-										"}"
-									]),
-									"}",
-									"if(runtime) currentUpdateRuntime.push(runtime);",
-									"resolve();"
-								]),
-								"});"
-							]),
-							"});"
-						]),
-						"}",
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "readFileVm")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
-						Template.indent([
-							"return new Promise(function(resolve, reject) {",
-							Template.indent([
-								`var filename = require('path').join(__dirname, ${JSON.stringify(
-									rootOutputDir
-								)} + ${RuntimeGlobals.getUpdateManifestFilename}());`,
-								"require('fs').readFile(filename, 'utf-8', function(err, content) {",
-								Template.indent([
-									"if(err) {",
-									Template.indent([
-										'if(err.code === "ENOENT") return resolve();',
-										"return reject(err);"
-									]),
-									"}",
-									"try { resolve(JSON.parse(content)); }",
-									"catch(e) { reject(e); }"
-								]),
-								"});"
-							]),
-							"});"
-						]),
-						"}"
-				  ])
-				: "// no HMR manifest"
-		]);
+						return module;
+					}
+				);
+				normalModuleFactory.hooks.module.tap(
+					"SideEffectsFlagPlugin",
+					(module, data) => {
+						if (typeof data.settings.sideEffects === "boolean") {
+							if (module.factoryMeta === undefined) {
+								module.factoryMeta = {};
+							}
+							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+						}
+						return module;
+					}
+				);
+				if (this._analyseSource) {
+					/**
+					 * @param {JavascriptParser} parser the parser
+					 * @returns {void}
+					 */
+					const parserHandler = parser => {
+						let sideEffectsStatement;
+						parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
+							sideEffectsStatement = undefined;
+						});
+						parser.hooks.statement.tap(
+							{ name: "SideEffectsFlagPlugin", stage: -100 },
+							statement => {
+								if (sideEffectsStatement) return;
+								if (parser.scope.topLevelScope !== true) return;
+								switch (statement.type) {
+									case "ExpressionStatement":
+										if (
+											!parser.isPure(statement.expression, statement.range[0])
+										) {
+											sideEffectsStatement = statement;
+										}
+										break;
+									case "IfStatement":
+									case "WhileStatement":
+									case "DoWhileStatement":
+										if (!parser.isPure(statement.test, statement.range[0])) {
+											sideEffectsStatement = statement;
+										}
+										// statement hook will be called for child statements too
+										break;
+									case "ForStatement":
+										if (
+											!parser.isPure(statement.init, statement.range[0]) ||
+											!parser.isPure(
+												statement.test,
+												statement.init
+													? statement.init.range[1]
+													: statement.range[0]
+											) ||
+											!parser.isPure(
+												statement.update,
+												statement.test
+													? statement.test.range[1]
+													: statement.init
+													? statement.init.range[1]
+													: statement.range[0]
+											)
+										) {
+											sideEffectsStatement = statement;
+										}
+										// statement hook will be called for child statements too
+										break;
+									case "SwitchStatement":
+										if (
+											!parser.isPure(statement.discriminant, statement.range[0])
+										) {
+											sideEffectsStatement = statement;
+										}
+										// statement hook will be called for child statements too
+										break;
+									case "VariableDeclaration":
+									case "ClassDeclaration":
+									case "FunctionDeclaration":
+										if (!parser.isPure(statement, statement.range[0])) {
+											sideEffectsStatement = statement;
+										}
+										break;
+									case "ExportNamedDeclaration":
+									case "ExportDefaultDeclaration":
+										if (
+											!parser.isPure(statement.declaration, statement.range[0])
+										) {
+											sideEffectsStatement = statement;
+										}
+										break;
+									case "LabeledStatement":
+									case "BlockStatement":
+										// statement hook will be called for child statements too
+										break;
+									case "EmptyStatement":
+										break;
+									case "ExportAllDeclaration":
+									case "ImportDeclaration":
+										// imports will be handled by the dependencies
+										break;
+									default:
+										sideEffectsStatement = statement;
+										break;
+								}
+							}
+						);
+						parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
+							if (sideEffectsStatement === undefined) {
+								parser.state.module.buildMeta.sideEffectFree = true;
+							} else {
+								const { loc, type } = sideEffectsStatement;
+								moduleGraph
+									.getOptimizationBailout(parser.state.module)
+									.push(
+										() =>
+											`Statement (${type}) with side effects in source code at ${formatLocation(
+												loc
+											)}`
+									);
+							}
+						});
+					};
+					for (const key of [
+						"javascript/auto",
+						"javascript/esm",
+						"javascript/dynamic"
+					]) {
+						normalModuleFactory.hooks.parser
+							.for(key)
+							.tap("SideEffectsFlagPlugin", parserHandler);
+					}
+				}
+				compilation.hooks.optimizeDependencies.tap(
+					{
+						name: "SideEffectsFlagPlugin",
+						stage: STAGE_DEFAULT
+					},
+					modules => {
+						const logger = compilation.getLogger(
+							"webpack.SideEffectsFlagPlugin"
+						);
+
+						logger.time("update dependencies");
+						for (const module of modules) {
+							if (module.getSideEffectsConnectionState(moduleGraph) === false) {
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								for (const connection of moduleGraph.getIncomingConnections(
+									module
+								)) {
+									const dep = connection.dependency;
+									let isReexport;
+									if (
+										(isReexport =
+											dep instanceof
+											HarmonyExportImportedSpecifierDependency) ||
+										(dep instanceof HarmonyImportSpecifierDependency &&
+											!dep.namespaceObjectAsContext)
+									) {
+										// TODO improve for export *
+										if (isReexport && dep.name) {
+											const exportInfo = moduleGraph.getExportInfo(
+												connection.originModule,
+												dep.name
+											);
+											exportInfo.moveTarget(
+												moduleGraph,
+												({ module }) =>
+													module.getSideEffectsConnectionState(moduleGraph) ===
+													false,
+												({ module: newModule, export: exportName }) => {
+													moduleGraph.updateModule(dep, newModule);
+													moduleGraph.addExplanation(
+														dep,
+														"(skipped side-effect-free modules)"
+													);
+													const ids = dep.getIds(moduleGraph);
+													dep.setIds(
+														moduleGraph,
+														exportName
+															? [...exportName, ...ids.slice(1)]
+															: ids.slice(1)
+													);
+													return moduleGraph.getConnection(dep);
+												}
+											);
+											continue;
+										}
+										// TODO improve for nested imports
+										const ids = dep.getIds(moduleGraph);
+										if (ids.length > 0) {
+											const exportInfo = exportsInfo.getExportInfo(ids[0]);
+											const target = exportInfo.getTarget(
+												moduleGraph,
+												({ module }) =>
+													module.getSideEffectsConnectionState(moduleGraph) ===
+													false
+											);
+											if (!target) continue;
+
+											moduleGraph.updateModule(dep, target.module);
+											moduleGraph.addExplanation(
+												dep,
+												"(skipped side-effect-free modules)"
+											);
+											dep.setIds(
+												moduleGraph,
+												target.export
+													? [...target.export, ...ids.slice(1)]
+													: ids.slice(1)
+											);
+										}
+									}
+								}
+							}
+						}
+						logger.timeEnd("update dependencies");
+					}
+				);
+			}
+		);
 	}
-}
 
-module.exports = ReadFileChunkLoadingRuntimeModule;
+	static moduleHasSideEffects(moduleName, flagValue, cache) {
+		switch (typeof flagValue) {
+			case "undefined":
+				return true;
+			case "boolean":
+				return flagValue;
+			case "string":
+				return globToRegexp(flagValue, cache).test(moduleName);
+			case "object":
+				return flagValue.some(glob =>
+					SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob, cache)
+				);
+		}
+	}
+}
+module.exports = SideEffectsFlagPlugin;
 
 
 /***/ }),
 
-/***/ 73163:
+/***/ 21478:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -106036,620 +105320,778 @@ module.exports = ReadFileChunkLoadingRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
+const Chunk = __webpack_require__(39385);
+const { STAGE_ADVANCED } = __webpack_require__(80057);
+const WebpackError = __webpack_require__(53799);
+const { requestToId } = __webpack_require__(63290);
+const { isSubset } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
+const {
+	compareModulesByIdentifier,
+	compareIterables
+} = __webpack_require__(29579);
+const createHash = __webpack_require__(49835);
+const deterministicGrouping = __webpack_require__(59836);
+const { makePathsRelative } = __webpack_require__(82186);
+const memoize = __webpack_require__(78676);
+const MinMaxSizeWarning = __webpack_require__(85305);
 
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
+/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").PathData} PathData */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
+/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 
-class ReadFileCompileAsyncWasmPlugin {
-	constructor({ type = "async-node", import: useImport = false } = {}) {
-		this._type = type;
-		this._import = useImport;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ReadFileCompileAsyncWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === this._type;
-				};
-				const generateLoadBinaryCode = this._import
-					? path =>
-							Template.asString([
-								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
-								Template.indent([
-									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
-									Template.indent([
-										"if (err) return reject(err);",
-										"",
-										"// Fake fetch response",
-										"resolve({",
-										Template.indent(["arrayBuffer() { return buffer; }"]),
-										"});"
-									]),
-									"});"
-								]),
-								"}))"
-							])
-					: path =>
-							Template.asString([
-								"new Promise(function (resolve, reject) {",
-								Template.indent([
-									"try {",
-									Template.indent([
-										"var { readFile } = require('fs');",
-										"var { join } = require('path');",
-										"",
-										`readFile(join(__dirname, ${path}), function(err, buffer){`,
-										Template.indent([
-											"if (err) return reject(err);",
-											"",
-											"// Fake fetch response",
-											"resolve({",
-											Template.indent(["arrayBuffer() { return buffer; }"]),
-											"});"
-										]),
-										"});"
-									]),
-									"} catch (err) { reject(err); }"
-								]),
-								"})"
-							]);
+/** @typedef {Record<string, number>} SplitChunksSizes */
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.instantiateWasm)
-					.tap("ReadFileCompileAsyncWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/async"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
-							chunk,
-							new AsyncWasmLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: false
-							})
-						);
-					});
-			}
-		);
-	}
-}
+/**
+ * @callback ChunkFilterFunction
+ * @param {Chunk} chunk
+ * @returns {boolean}
+ */
 
-module.exports = ReadFileCompileAsyncWasmPlugin;
+/**
+ * @callback CombineSizeFunction
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
 
+/**
+ * @typedef {Object} CacheGroupSource
+ * @property {string=} key
+ * @property {number=} priority
+ * @property {GetName=} getName
+ * @property {ChunkFilterFunction=} chunksFilter
+ * @property {boolean=} enforce
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
+ * @property {SplitChunksSizes} minRemainingSize
+ * @property {SplitChunksSizes} enforceSizeThreshold
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {number=} minChunks
+ * @property {number=} maxAsyncRequests
+ * @property {number=} maxInitialRequests
+ * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {string=} idHint
+ * @property {string} automaticNameDelimiter
+ * @property {boolean=} reuseExistingChunk
+ * @property {boolean=} usedExports
+ */
 
-/***/ }),
+/**
+ * @typedef {Object} CacheGroup
+ * @property {string} key
+ * @property {number=} priority
+ * @property {GetName=} getName
+ * @property {ChunkFilterFunction=} chunksFilter
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
+ * @property {SplitChunksSizes} minRemainingSize
+ * @property {SplitChunksSizes} enforceSizeThreshold
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {number=} minChunks
+ * @property {number=} maxAsyncRequests
+ * @property {number=} maxInitialRequests
+ * @property {(string | function(PathData, AssetInfo=): string)=} filename
+ * @property {string=} idHint
+ * @property {string} automaticNameDelimiter
+ * @property {boolean} reuseExistingChunk
+ * @property {boolean} usedExports
+ * @property {boolean} _validateSize
+ * @property {boolean} _validateRemainingSize
+ * @property {SplitChunksSizes} _minSizeForMaxSize
+ * @property {boolean} _conditionalEnforce
+ */
 
-/***/ 98939:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @typedef {Object} FallbackCacheGroup
+ * @property {ChunkFilterFunction} chunksFilter
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {string} automaticNameDelimiter
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * @typedef {Object} CacheGroupsContext
+ * @property {ModuleGraph} moduleGraph
+ * @property {ChunkGraph} chunkGraph
+ */
 
+/**
+ * @callback GetCacheGroups
+ * @param {Module} module
+ * @param {CacheGroupsContext} context
+ * @returns {CacheGroupSource[]}
+ */
 
+/**
+ * @callback GetName
+ * @param {Module=} module
+ * @param {Chunk[]=} chunks
+ * @param {string=} key
+ * @returns {string=}
+ */
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
+/**
+ * @typedef {Object} SplitChunksOptions
+ * @property {ChunkFilterFunction} chunksFilter
+ * @property {string[]} defaultSizeTypes
+ * @property {SplitChunksSizes} minSize
+ * @property {SplitChunksSizes} minSizeReduction
+ * @property {SplitChunksSizes} minRemainingSize
+ * @property {SplitChunksSizes} enforceSizeThreshold
+ * @property {SplitChunksSizes} maxInitialSize
+ * @property {SplitChunksSizes} maxAsyncSize
+ * @property {number} minChunks
+ * @property {number} maxAsyncRequests
+ * @property {number} maxInitialRequests
+ * @property {boolean} hidePathInfo
+ * @property {string | function(PathData, AssetInfo=): string} filename
+ * @property {string} automaticNameDelimiter
+ * @property {GetCacheGroups} getCacheGroups
+ * @property {GetName} getName
+ * @property {boolean} usedExports
+ * @property {FallbackCacheGroup} fallbackCacheGroup
+ */
 
-/** @typedef {import("../Compiler")} Compiler */
+/**
+ * @typedef {Object} ChunksInfoItem
+ * @property {SortableSet<Module>} modules
+ * @property {CacheGroup} cacheGroup
+ * @property {number} cacheGroupIndex
+ * @property {string} name
+ * @property {Record<string, number>} sizes
+ * @property {Set<Chunk>} chunks
+ * @property {Set<Chunk>} reuseableChunks
+ * @property {Set<bigint | Chunk>} chunksKeys
+ */
 
-// TODO webpack 6 remove
+const defaultGetName = /** @type {GetName} */ (() => {});
 
-class ReadFileCompileWasmPlugin {
-	constructor(options) {
-		this.options = options || {};
-	}
+const deterministicGroupingForModules =
+	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
+		deterministicGrouping
+	);
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ReadFileCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "async-node";
-				};
-				const generateLoadBinaryCode = path =>
-					Template.asString([
-						"new Promise(function (resolve, reject) {",
-						Template.indent([
-							"var { readFile } = require('fs');",
-							"var { join } = require('path');",
-							"",
-							"try {",
-							Template.indent([
-								`readFile(join(__dirname, ${path}), function(err, buffer){`,
-								Template.indent([
-									"if (err) return reject(err);",
-									"",
-									"// Fake fetch response",
-									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
-									"});"
-								]),
-								"});"
-							]),
-							"} catch (err) { reject(err); }"
-						]),
-						"})"
-					]);
+/** @type {WeakMap<Module, string>} */
+const getKeyCache = new WeakMap();
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ReadFileCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						compilation.addRuntimeModule(
-							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: false,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
+/**
+ * @param {string} name a filename to hash
+ * @param {OutputOptions} outputOptions hash function used
+ * @returns {string} hashed filename
+ */
+const hashFilename = (name, outputOptions) => {
+	const digest = /** @type {string} */ (
+		createHash(outputOptions.hashFunction)
+			.update(name)
+			.digest(outputOptions.hashDigest)
+	);
+	return digest.slice(0, 8);
+};
+
+/**
+ * @param {Chunk} chunk the chunk
+ * @returns {number} the number of requests
+ */
+const getRequests = chunk => {
+	let requests = 0;
+	for (const chunkGroup of chunk.groupsIterable) {
+		requests = Math.max(requests, chunkGroup.chunks.length);
 	}
-}
+	return requests;
+};
 
-module.exports = ReadFileCompileWasmPlugin;
+const mapObject = (obj, fn) => {
+	const newObj = Object.create(null);
+	for (const key of Object.keys(obj)) {
+		newObj[key] = fn(obj[key], key);
+	}
+	return newObj;
+};
 
+/**
+ * @template T
+ * @param {Set<T>} a set
+ * @param {Set<T>} b other set
+ * @returns {boolean} true if at least one item of a is in b
+ */
+const isOverlap = (a, b) => {
+	for (const item of a) {
+		if (b.has(item)) return true;
+	}
+	return false;
+};
 
-/***/ }),
+const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
-/***/ 94172:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * @param {ChunksInfoItem} a item
+ * @param {ChunksInfoItem} b item
+ * @returns {number} compare result
+ */
+const compareEntries = (a, b) => {
+	// 1. by priority
+	const diffPriority = a.cacheGroup.priority - b.cacheGroup.priority;
+	if (diffPriority) return diffPriority;
+	// 2. by number of chunks
+	const diffCount = a.chunks.size - b.chunks.size;
+	if (diffCount) return diffCount;
+	// 3. by size reduction
+	const aSizeReduce = totalSize(a.sizes) * (a.chunks.size - 1);
+	const bSizeReduce = totalSize(b.sizes) * (b.chunks.size - 1);
+	const diffSizeReduce = aSizeReduce - bSizeReduce;
+	if (diffSizeReduce) return diffSizeReduce;
+	// 4. by cache group index
+	const indexDiff = b.cacheGroupIndex - a.cacheGroupIndex;
+	if (indexDiff) return indexDiff;
+	// 5. by number of modules (to be able to compare by identifier)
+	const modulesA = a.modules;
+	const modulesB = b.modules;
+	const diff = modulesA.size - modulesB.size;
+	if (diff) return diff;
+	// 6. by module identifiers
+	modulesA.sort();
+	modulesB.sort();
+	return compareModuleIterables(modulesA, modulesB);
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
+const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
+const ALL_CHUNK_FILTER = chunk => true;
 
+/**
+ * @param {OptimizationSplitChunksSizes} value the sizes
+ * @param {string[]} defaultSizeTypes the default size types
+ * @returns {SplitChunksSizes} normalized representation
+ */
+const normalizeSizes = (value, defaultSizeTypes) => {
+	if (typeof value === "number") {
+		/** @type {Record<string, number>} */
+		const o = {};
+		for (const sizeType of defaultSizeTypes) o[sizeType] = value;
+		return o;
+	} else if (typeof value === "object" && value !== null) {
+		return { ...value };
+	} else {
+		return {};
+	}
+};
 
+/**
+ * @param {...SplitChunksSizes} sizes the sizes
+ * @returns {SplitChunksSizes} the merged sizes
+ */
+const mergeSizes = (...sizes) => {
+	/** @type {SplitChunksSizes} */
+	let merged = {};
+	for (let i = sizes.length - 1; i >= 0; i--) {
+		merged = Object.assign(merged, sizes[i]);
+	}
+	return merged;
+};
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @returns {boolean} true, if there are sizes > 0
+ */
+const hasNonZeroSizes = sizes => {
+	for (const key of Object.keys(sizes)) {
+		if (sizes[key] > 0) return true;
+	}
+	return false;
+};
 
-class RequireChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("require chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.runtimeRequirements = runtimeRequirements;
+/**
+ * @param {SplitChunksSizes} a first sizes
+ * @param {SplitChunksSizes} b second sizes
+ * @param {CombineSizeFunction} combine a function to combine sizes
+ * @returns {SplitChunksSizes} the combine sizes
+ */
+const combineSizes = (a, b, combine) => {
+	const aKeys = new Set(Object.keys(a));
+	const bKeys = new Set(Object.keys(b));
+	/** @type {SplitChunksSizes} */
+	const result = {};
+	for (const key of aKeys) {
+		if (bKeys.has(key)) {
+			result[key] = combine(a[key], b[key]);
+		} else {
+			result[key] = a[key];
+		}
+	}
+	for (const key of bKeys) {
+		if (!aKeys.has(key)) {
+			result[key] = b[key];
+		}
 	}
+	return result;
+};
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withExternalInstallChunk = this.runtimeRequirements.has(
-			RuntimeGlobals.externalInstallChunk
-		);
-		const withOnChunkLoad = this.runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withLoading = this.runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withHmr = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSize the min sizes
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
+ */
+const checkMinSize = (sizes, minSize) => {
+	for (const key of Object.keys(minSize)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size < minSize[key]) return false;
+	}
+	return true;
+};
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			true
-		);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSizeReduction the min sizes
+ * @param {number} chunkCount number of chunks
+ * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
+ */
+const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
+	for (const key of Object.keys(minSizeReduction)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size * chunkCount < minSizeReduction[key]) return false;
+	}
+	return true;
+};
 
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_require`
-			: undefined;
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @param {SplitChunksSizes} minSize the min sizes
+ * @returns {undefined | string[]} list of size types that are below min size
+ */
+const getViolatingMinSizes = (sizes, minSize) => {
+	let list;
+	for (const key of Object.keys(minSize)) {
+		const size = sizes[key];
+		if (size === undefined || size === 0) continue;
+		if (size < minSize[key]) {
+			if (list === undefined) list = [key];
+			else list.push(key);
+		}
+	}
+	return list;
+};
 
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = require("url").pathToFileURL(${
-							rootOutputDir !== "./"
-								? `__dirname + ${JSON.stringify("/" + rootOutputDir)}`
-								: "__filename"
-						});`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded chunks",
-			'// "1" means "loaded", otherwise not loaded yet',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.require = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId]",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded",
-			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
-						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
-						"for(var moduleId in moreModules) {",
-						Template.indent([
-							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-							Template.indent([
-								`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-							]),
-							"}"
-						]),
-						"}",
-						`if(runtime) runtime(__webpack_require__);`,
-						"for(var i = 0; i < chunkIds.length; i++)",
-						Template.indent("installedChunks[chunkIds[i]] = 1;"),
-						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
-				  ])};`
-				: "// no chunk install function needed",
-			"",
-			withLoading
-				? Template.asString([
-						"// require() chunk loading for javascript",
-						`${fn}.require = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? [
-										'// "1" is the signal for "already loaded"',
-										"if(!installedChunks[chunkId]) {",
-										Template.indent([
-											hasJsMatcher === true
-												? "if(true) { // all chunks have JS"
-												: `if(${hasJsMatcher("chunkId")}) {`,
-											Template.indent([
-												`installChunk(require(${JSON.stringify(
-													rootOutputDir
-												)} + ${
-													RuntimeGlobals.getChunkScriptFilename
-												}(chunkId)));`
-											]),
-											"} else installedChunks[chunkId] = 1;",
-											""
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 1;"
-						)};`
-				  ])
-				: "// no chunk loading",
-			"",
-			withExternalInstallChunk
-				? Template.asString([
-						"module.exports = __webpack_require__;",
-						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
-				  ])
-				: "// no external install chunk",
-			"",
-			withHmr
-				? Template.asString([
-						"function loadUpdateChunk(chunkId, updatedModulesList) {",
-						Template.indent([
-							`var update = require(${JSON.stringify(rootOutputDir)} + ${
-								RuntimeGlobals.getChunkUpdateScriptFilename
-							}(chunkId));`,
-							"var updatedModules = update.modules;",
-							"var runtime = update.runtime;",
-							"for(var moduleId in updatedModules) {",
-							Template.indent([
-								`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
-								Template.indent([
-									`currentUpdate[moduleId] = updatedModules[moduleId];`,
-									"if(updatedModulesList) updatedModulesList.push(moduleId);"
-								]),
-								"}"
-							]),
-							"}",
-							"if(runtime) currentUpdateRuntime.push(runtime);"
-						]),
-						"}",
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "require")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${RuntimeGlobals.hmrDownloadManifest} = function() {`,
-						Template.indent([
-							"return Promise.resolve().then(function() {",
-							Template.indent([
-								`return require(${JSON.stringify(rootOutputDir)} + ${
-									RuntimeGlobals.getUpdateManifestFilename
-								}());`
-							]),
-							"})['catch'](function(err) { if(err.code !== 'MODULE_NOT_FOUND') throw err; });"
-						]),
-						"}"
-				  ])
-				: "// no HMR manifest"
-		]);
+/**
+ * @param {SplitChunksSizes} sizes the sizes
+ * @returns {number} the total size
+ */
+const totalSize = sizes => {
+	let size = 0;
+	for (const key of Object.keys(sizes)) {
+		size += sizes[key];
 	}
-}
-
-module.exports = RequireChunkLoadingRuntimeModule;
-
-
-/***/ }),
-
-/***/ 91786:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const util = __webpack_require__(73837);
-const truncateArgs = __webpack_require__(62090);
+	return size;
+};
 
-module.exports = ({ colors, appendOnly, stream }) => {
-	let currentStatusMessage = undefined;
-	let hasStatusMessage = false;
-	let currentIndent = "";
-	let currentCollapsed = 0;
+/**
+ * @param {false|string|Function} name the chunk name
+ * @returns {GetName} a function to get the name of the chunk
+ */
+const normalizeName = name => {
+	if (typeof name === "string") {
+		return () => name;
+	}
+	if (typeof name === "function") {
+		return /** @type {GetName} */ (name);
+	}
+};
 
-	const indent = (str, prefix, colorPrefix, colorSuffix) => {
-		if (str === "") return str;
-		prefix = currentIndent + prefix;
-		if (colors) {
-			return (
-				prefix +
-				colorPrefix +
-				str.replace(/\n/g, colorSuffix + "\n" + prefix + colorPrefix) +
-				colorSuffix
-			);
-		} else {
-			return prefix + str.replace(/\n/g, "\n" + prefix);
-		}
-	};
+/**
+ * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
+ * @returns {ChunkFilterFunction} the chunk filter function
+ */
+const normalizeChunksFilter = chunks => {
+	if (chunks === "initial") {
+		return INITIAL_CHUNK_FILTER;
+	}
+	if (chunks === "async") {
+		return ASYNC_CHUNK_FILTER;
+	}
+	if (chunks === "all") {
+		return ALL_CHUNK_FILTER;
+	}
+	if (typeof chunks === "function") {
+		return chunks;
+	}
+};
 
-	const clearStatusMessage = () => {
-		if (hasStatusMessage) {
-			stream.write("\x1b[2K\r");
-			hasStatusMessage = false;
+/**
+ * @param {GetCacheGroups | Record<string, false|string|RegExp|OptimizationSplitChunksGetCacheGroups|OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
+ * @param {string[]} defaultSizeTypes the default size types
+ * @returns {GetCacheGroups} a function to get the cache groups
+ */
+const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
+	if (typeof cacheGroups === "function") {
+		return cacheGroups;
+	}
+	if (typeof cacheGroups === "object" && cacheGroups !== null) {
+		/** @type {(function(Module, CacheGroupsContext, CacheGroupSource[]): void)[]} */
+		const handlers = [];
+		for (const key of Object.keys(cacheGroups)) {
+			const option = cacheGroups[key];
+			if (option === false) {
+				continue;
+			}
+			if (typeof option === "string" || option instanceof RegExp) {
+				const source = createCacheGroupSource({}, key, defaultSizeTypes);
+				handlers.push((module, context, results) => {
+					if (checkTest(option, module, context)) {
+						results.push(source);
+					}
+				});
+			} else if (typeof option === "function") {
+				const cache = new WeakMap();
+				handlers.push((module, context, results) => {
+					const result = option(module);
+					if (result) {
+						const groups = Array.isArray(result) ? result : [result];
+						for (const group of groups) {
+							const cachedSource = cache.get(group);
+							if (cachedSource !== undefined) {
+								results.push(cachedSource);
+							} else {
+								const source = createCacheGroupSource(
+									group,
+									key,
+									defaultSizeTypes
+								);
+								cache.set(group, source);
+								results.push(source);
+							}
+						}
+					}
+				});
+			} else {
+				const source = createCacheGroupSource(option, key, defaultSizeTypes);
+				handlers.push((module, context, results) => {
+					if (
+						checkTest(option.test, module, context) &&
+						checkModuleType(option.type, module) &&
+						checkModuleLayer(option.layer, module)
+					) {
+						results.push(source);
+					}
+				});
+			}
 		}
-	};
+		/**
+		 * @param {Module} module the current module
+		 * @param {CacheGroupsContext} context the current context
+		 * @returns {CacheGroupSource[]} the matching cache groups
+		 */
+		const fn = (module, context) => {
+			/** @type {CacheGroupSource[]} */
+			let results = [];
+			for (const fn of handlers) {
+				fn(module, context, results);
+			}
+			return results;
+		};
+		return fn;
+	}
+	return () => null;
+};
 
-	const writeStatusMessage = () => {
-		if (!currentStatusMessage) return;
-		const l = stream.columns;
-		const args = l
-			? truncateArgs(currentStatusMessage, l - 1)
-			: currentStatusMessage;
-		const str = args.join(" ");
-		const coloredStr = `\u001b[1m${str}\u001b[39m\u001b[22m`;
-		stream.write(`\x1b[2K\r${coloredStr}`);
-		hasStatusMessage = true;
-	};
+/**
+ * @param {undefined|boolean|string|RegExp|Function} test test option
+ * @param {Module} module the module
+ * @param {CacheGroupsContext} context context object
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkTest = (test, module, context) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module, context);
+	}
+	if (typeof test === "boolean") return test;
+	if (typeof test === "string") {
+		const name = module.nameForCondition();
+		return name && name.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const name = module.nameForCondition();
+		return name && test.test(name);
+	}
+	return false;
+};
 
-	const writeColored = (prefix, colorPrefix, colorSuffix) => {
-		return (...args) => {
-			if (currentCollapsed > 0) return;
-			clearStatusMessage();
-			const str = indent(
-				util.format(...args),
-				prefix,
-				colorPrefix,
-				colorSuffix
-			);
-			stream.write(str + "\n");
-			writeStatusMessage();
-		};
-	};
+/**
+ * @param {undefined|string|RegExp|Function} test type option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkModuleType = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module.type);
+	}
+	if (typeof test === "string") {
+		const type = module.type;
+		return test === type;
+	}
+	if (test instanceof RegExp) {
+		const type = module.type;
+		return test.test(type);
+	}
+	return false;
+};
 
-	const writeGroupMessage = writeColored(
-		"<-> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
-	);
+/**
+ * @param {undefined|string|RegExp|Function} test type option
+ * @param {Module} module the module
+ * @returns {boolean} true, if the module should be selected
+ */
+const checkModuleLayer = (test, module) => {
+	if (test === undefined) return true;
+	if (typeof test === "function") {
+		return test(module.layer);
+	}
+	if (typeof test === "string") {
+		const layer = module.layer;
+		return test === "" ? !layer : layer && layer.startsWith(test);
+	}
+	if (test instanceof RegExp) {
+		const layer = module.layer;
+		return test.test(layer);
+	}
+	return false;
+};
 
-	const writeGroupCollapsedMessage = writeColored(
-		"<+> ",
-		"\u001b[1m\u001b[36m",
-		"\u001b[39m\u001b[22m"
+/**
+ * @param {OptimizationSplitChunksCacheGroup} options the group options
+ * @param {string} key key of cache group
+ * @param {string[]} defaultSizeTypes the default size types
+ * @returns {CacheGroupSource} the normalized cached group
+ */
+const createCacheGroupSource = (options, key, defaultSizeTypes) => {
+	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+	const minSizeReduction = normalizeSizes(
+		options.minSizeReduction,
+		defaultSizeTypes
 	);
-
+	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 	return {
-		log: writeColored("    ", "\u001b[1m", "\u001b[22m"),
-		debug: writeColored("    ", "", ""),
-		trace: writeColored("    ", "", ""),
-		info: writeColored("<i> ", "\u001b[1m\u001b[32m", "\u001b[39m\u001b[22m"),
-		warn: writeColored("<w> ", "\u001b[1m\u001b[33m", "\u001b[39m\u001b[22m"),
-		error: writeColored("<e> ", "\u001b[1m\u001b[31m", "\u001b[39m\u001b[22m"),
-		logTime: writeColored(
-			"<t> ",
-			"\u001b[1m\u001b[35m",
-			"\u001b[39m\u001b[22m"
+		key,
+		priority: options.priority,
+		getName: normalizeName(options.name),
+		chunksFilter: normalizeChunksFilter(options.chunks),
+		enforce: options.enforce,
+		minSize,
+		minSizeReduction,
+		minRemainingSize: mergeSizes(
+			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
+			minSize
 		),
-		group: (...args) => {
-			writeGroupMessage(...args);
-			if (currentCollapsed > 0) {
-				currentCollapsed++;
-			} else {
-				currentIndent += "  ";
-			}
-		},
-		groupCollapsed: (...args) => {
-			writeGroupCollapsedMessage(...args);
-			currentCollapsed++;
-		},
-		groupEnd: () => {
-			if (currentCollapsed > 0) currentCollapsed--;
-			else if (currentIndent.length >= 2)
-				currentIndent = currentIndent.slice(0, currentIndent.length - 2);
-		},
-		// eslint-disable-next-line node/no-unsupported-features/node-builtins
-		profile: console.profile && (name => console.profile(name)),
-		// eslint-disable-next-line node/no-unsupported-features/node-builtins
-		profileEnd: console.profileEnd && (name => console.profileEnd(name)),
-		clear:
-			!appendOnly &&
-			// eslint-disable-next-line node/no-unsupported-features/node-builtins
-			console.clear &&
-			(() => {
-				clearStatusMessage();
-				// eslint-disable-next-line node/no-unsupported-features/node-builtins
-				console.clear();
-				writeStatusMessage();
-			}),
-		status: appendOnly
-			? writeColored("<s> ", "", "")
-			: (name, ...args) => {
-					args = args.filter(Boolean);
-					if (name === undefined && args.length === 0) {
-						clearStatusMessage();
-						currentStatusMessage = undefined;
-					} else if (
-						typeof name === "string" &&
-						name.startsWith("[webpack.Progress] ")
-					) {
-						currentStatusMessage = [name.slice(19), ...args];
-						writeStatusMessage();
-					} else if (name === "[webpack.Progress]") {
-						currentStatusMessage = [...args];
-						writeStatusMessage();
-					} else {
-						currentStatusMessage = [name, ...args];
-						writeStatusMessage();
-					}
-			  }
+		enforceSizeThreshold: normalizeSizes(
+			options.enforceSizeThreshold,
+			defaultSizeTypes
+		),
+		maxAsyncSize: mergeSizes(
+			normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
+			maxSize
+		),
+		maxInitialSize: mergeSizes(
+			normalizeSizes(options.maxInitialSize, defaultSizeTypes),
+			maxSize
+		),
+		minChunks: options.minChunks,
+		maxAsyncRequests: options.maxAsyncRequests,
+		maxInitialRequests: options.maxInitialRequests,
+		filename: options.filename,
+		idHint: options.idHint,
+		automaticNameDelimiter: options.automaticNameDelimiter,
+		reuseExistingChunk: options.reuseExistingChunk,
+		usedExports: options.usedExports
 	};
 };
 
+module.exports = class SplitChunksPlugin {
+	/**
+	 * @param {OptimizationSplitChunksOptions=} options plugin options
+	 */
+	constructor(options = {}) {
+		const defaultSizeTypes = options.defaultSizeTypes || [
+			"javascript",
+			"unknown"
+		];
+		const fallbackCacheGroup = options.fallbackCacheGroup || {};
+		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
+		const minSizeReduction = normalizeSizes(
+			options.minSizeReduction,
+			defaultSizeTypes
+		);
+		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
 
-/***/ }),
-
-/***/ 64395:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { STAGE_ADVANCED } = __webpack_require__(80057);
+		/** @type {SplitChunksOptions} */
+		this.options = {
+			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
+			defaultSizeTypes,
+			minSize,
+			minSizeReduction,
+			minRemainingSize: mergeSizes(
+				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
+				minSize
+			),
+			enforceSizeThreshold: normalizeSizes(
+				options.enforceSizeThreshold,
+				defaultSizeTypes
+			),
+			maxAsyncSize: mergeSizes(
+				normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
+				maxSize
+			),
+			maxInitialSize: mergeSizes(
+				normalizeSizes(options.maxInitialSize, defaultSizeTypes),
+				maxSize
+			),
+			minChunks: options.minChunks || 1,
+			maxAsyncRequests: options.maxAsyncRequests || 1,
+			maxInitialRequests: options.maxInitialRequests || 1,
+			hidePathInfo: options.hidePathInfo || false,
+			filename: options.filename || undefined,
+			getCacheGroups: normalizeCacheGroups(
+				options.cacheGroups,
+				defaultSizeTypes
+			),
+			getName: options.name ? normalizeName(options.name) : defaultGetName,
+			automaticNameDelimiter: options.automaticNameDelimiter,
+			usedExports: options.usedExports,
+			fallbackCacheGroup: {
+				chunksFilter: normalizeChunksFilter(
+					fallbackCacheGroup.chunks || options.chunks || "all"
+				),
+				minSize: mergeSizes(
+					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
+					minSize
+				),
+				maxAsyncSize: mergeSizes(
+					normalizeSizes(fallbackCacheGroup.maxAsyncSize, defaultSizeTypes),
+					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
+					normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
+					normalizeSizes(options.maxSize, defaultSizeTypes)
+				),
+				maxInitialSize: mergeSizes(
+					normalizeSizes(fallbackCacheGroup.maxInitialSize, defaultSizeTypes),
+					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
+					normalizeSizes(options.maxInitialSize, defaultSizeTypes),
+					normalizeSizes(options.maxSize, defaultSizeTypes)
+				),
+				automaticNameDelimiter:
+					fallbackCacheGroup.automaticNameDelimiter ||
+					options.automaticNameDelimiter ||
+					"~"
+			}
+		};
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+		/** @type {WeakMap<CacheGroupSource, CacheGroup>} */
+		this._cacheGroupCache = new WeakMap();
+	}
 
-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 || {};
+	/**
+	 * @param {CacheGroupSource} cacheGroupSource source
+	 * @returns {CacheGroup} the cache group (cached)
+	 */
+	_getCacheGroup(cacheGroupSource) {
+		const cacheEntry = this._cacheGroupCache.get(cacheGroupSource);
+		if (cacheEntry !== undefined) return cacheEntry;
+		const minSize = mergeSizes(
+			cacheGroupSource.minSize,
+			cacheGroupSource.enforce ? undefined : this.options.minSize
+		);
+		const minSizeReduction = mergeSizes(
+			cacheGroupSource.minSizeReduction,
+			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
+		);
+		const minRemainingSize = mergeSizes(
+			cacheGroupSource.minRemainingSize,
+			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
+		);
+		const enforceSizeThreshold = mergeSizes(
+			cacheGroupSource.enforceSizeThreshold,
+			cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold
+		);
+		const cacheGroup = {
+			key: cacheGroupSource.key,
+			priority: cacheGroupSource.priority || 0,
+			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
+			minSize,
+			minSizeReduction,
+			minRemainingSize,
+			enforceSizeThreshold,
+			maxAsyncSize: mergeSizes(
+				cacheGroupSource.maxAsyncSize,
+				cacheGroupSource.enforce ? undefined : this.options.maxAsyncSize
+			),
+			maxInitialSize: mergeSizes(
+				cacheGroupSource.maxInitialSize,
+				cacheGroupSource.enforce ? undefined : this.options.maxInitialSize
+			),
+			minChunks:
+				cacheGroupSource.minChunks !== undefined
+					? cacheGroupSource.minChunks
+					: cacheGroupSource.enforce
+					? 1
+					: this.options.minChunks,
+			maxAsyncRequests:
+				cacheGroupSource.maxAsyncRequests !== undefined
+					? cacheGroupSource.maxAsyncRequests
+					: cacheGroupSource.enforce
+					? Infinity
+					: this.options.maxAsyncRequests,
+			maxInitialRequests:
+				cacheGroupSource.maxInitialRequests !== undefined
+					? cacheGroupSource.maxInitialRequests
+					: cacheGroupSource.enforce
+					? Infinity
+					: this.options.maxInitialRequests,
+			getName:
+				cacheGroupSource.getName !== undefined
+					? cacheGroupSource.getName
+					: this.options.getName,
+			usedExports:
+				cacheGroupSource.usedExports !== undefined
+					? cacheGroupSource.usedExports
+					: this.options.usedExports,
+			filename:
+				cacheGroupSource.filename !== undefined
+					? cacheGroupSource.filename
+					: this.options.filename,
+			automaticNameDelimiter:
+				cacheGroupSource.automaticNameDelimiter !== undefined
+					? cacheGroupSource.automaticNameDelimiter
+					: this.options.automaticNameDelimiter,
+			idHint:
+				cacheGroupSource.idHint !== undefined
+					? cacheGroupSource.idHint
+					: cacheGroupSource.key,
+			reuseExistingChunk: cacheGroupSource.reuseExistingChunk || false,
+			_validateSize: hasNonZeroSizes(minSize),
+			_validateRemainingSize: hasNonZeroSizes(minRemainingSize),
+			_minSizeForMaxSize: mergeSizes(
+				cacheGroupSource.minSize,
+				this.options.minSize
+			),
+			_conditionalEnforce: hasNonZeroSizes(enforceSizeThreshold)
+		};
+		this._cacheGroupCache.set(cacheGroupSource, cacheGroup);
+		return cacheGroup;
 	}
 
 	/**
@@ -106658,2291 +106100,1657 @@ class AggressiveMergingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const options = this.options;
-		const minSizeReduce = options.minSizeReduce || 1.5;
+		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
+			compiler.context,
+			compiler.root
+		);
+		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
+			const logger = compilation.getLogger("webpack.SplitChunksPlugin");
+			let alreadyOptimized = false;
+			compilation.hooks.unseal.tap("SplitChunksPlugin", () => {
+				alreadyOptimized = false;
+			});
+			compilation.hooks.optimizeChunks.tap(
+				{
+					name: "SplitChunksPlugin",
+					stage: STAGE_ADVANCED
+				},
+				chunks => {
+					if (alreadyOptimized) return;
+					alreadyOptimized = true;
+					logger.time("prepare");
+					const chunkGraph = compilation.chunkGraph;
+					const moduleGraph = compilation.moduleGraph;
+					// Give each selected chunk an index (to create strings from chunks)
+					/** @type {Map<Chunk, bigint>} */
+					const chunkIndexMap = new Map();
+					const ZERO = BigInt("0");
+					const ONE = BigInt("1");
+					const START = ONE << BigInt("31");
+					let index = START;
+					for (const chunk of chunks) {
+						chunkIndexMap.set(
+							chunk,
+							index | BigInt((Math.random() * 0x7fffffff) | 0)
+						);
+						index = index << ONE;
+					}
+					/**
+					 * @param {Iterable<Chunk>} chunks list of chunks
+					 * @returns {bigint | Chunk} key of the chunks
+					 */
+					const getKey = chunks => {
+						const iterator = chunks[Symbol.iterator]();
+						let result = iterator.next();
+						if (result.done) return ZERO;
+						const first = result.value;
+						result = iterator.next();
+						if (result.done) return first;
+						let key =
+							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
+						while (!(result = iterator.next()).done) {
+							const raw = chunkIndexMap.get(result.value);
+							key = key ^ raw;
+						}
+						return key;
+					};
+					const keyToString = key => {
+						if (typeof key === "bigint") return key.toString(16);
+						return chunkIndexMap.get(key).toString(16);
+					};
 
-		compiler.hooks.thisCompilation.tap(
-			"AggressiveMergingPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "AggressiveMergingPlugin",
-						stage: STAGE_ADVANCED
-					},
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						/** @type {{a: Chunk, b: Chunk, improvement: number}[]} */
-						let combinations = [];
-						for (const a of chunks) {
-							if (a.canBeInitial()) continue;
-							for (const b of chunks) {
-								if (b.canBeInitial()) continue;
-								if (b === a) break;
-								if (!chunkGraph.canChunksBeIntegrated(a, b)) {
-									continue;
+					const getChunkSetsInGraph = memoize(() => {
+						/** @type {Map<bigint, Set<Chunk>>} */
+						const chunkSetsInGraph = new Map();
+						/** @type {Set<Chunk>} */
+						const singleChunkSets = new Set();
+						for (const module of compilation.modules) {
+							const chunks = chunkGraph.getModuleChunksIterable(module);
+							const chunksKey = getKey(chunks);
+							if (typeof chunksKey === "bigint") {
+								if (!chunkSetsInGraph.has(chunksKey)) {
+									chunkSetsInGraph.set(chunksKey, new Set(chunks));
 								}
-								const aSize = chunkGraph.getChunkSize(b, {
-									chunkOverhead: 0
-								});
-								const bSize = chunkGraph.getChunkSize(a, {
-									chunkOverhead: 0
-								});
-								const abSize = chunkGraph.getIntegratedChunksSize(b, a, {
-									chunkOverhead: 0
-								});
-								const improvement = (aSize + bSize) / abSize;
-								combinations.push({
-									a,
-									b,
-									improvement
-								});
+							} else {
+								singleChunkSets.add(chunksKey);
 							}
 						}
+						return { chunkSetsInGraph, singleChunkSets };
+					});
 
-						combinations.sort((a, b) => {
-							return b.improvement - a.improvement;
-						});
-
-						const pair = combinations[0];
+					/**
+					 * @param {Module} module the module
+					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
+					 */
+					const groupChunksByExports = module => {
+						const exportsInfo = moduleGraph.getExportsInfo(module);
+						const groupedByUsedExports = new Map();
+						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+							const key = exportsInfo.getUsageKey(chunk.runtime);
+							const list = groupedByUsedExports.get(key);
+							if (list !== undefined) {
+								list.push(chunk);
+							} else {
+								groupedByUsedExports.set(key, [chunk]);
+							}
+						}
+						return groupedByUsedExports.values();
+					};
 
-						if (!pair) return;
-						if (pair.improvement < minSizeReduce) return;
+					/** @type {Map<Module, Iterable<Chunk[]>>} */
+					const groupedByExportsMap = new Map();
 
-						chunkGraph.integrateChunks(pair.b, pair.a);
-						compilation.chunks.delete(pair.a);
-						return true;
-					}
-				);
-			}
-		);
-	}
-}
+					const getExportsChunkSetsInGraph = memoize(() => {
+						/** @type {Map<bigint, Set<Chunk>>} */
+						const chunkSetsInGraph = new Map();
+						/** @type {Set<Chunk>} */
+						const singleChunkSets = new Set();
+						for (const module of compilation.modules) {
+							const groupedChunks = Array.from(groupChunksByExports(module));
+							groupedByExportsMap.set(module, groupedChunks);
+							for (const chunks of groupedChunks) {
+								if (chunks.length === 1) {
+									singleChunkSets.add(chunks[0]);
+								} else {
+									const chunksKey = /** @type {bigint} */ (getKey(chunks));
+									if (!chunkSetsInGraph.has(chunksKey)) {
+										chunkSetsInGraph.set(chunksKey, new Set(chunks));
+									}
+								}
+							}
+						}
+						return { chunkSetsInGraph, singleChunkSets };
+					});
 
-module.exports = AggressiveMergingPlugin;
+					// group these set of chunks by count
+					// to allow to check less sets via isSubset
+					// (only smaller sets can be subset)
+					const groupChunkSetsByCount = chunkSets => {
+						/** @type {Map<number, Array<Set<Chunk>>>} */
+						const chunkSetsByCount = new Map();
+						for (const chunksSet of chunkSets) {
+							const count = chunksSet.size;
+							let array = chunkSetsByCount.get(count);
+							if (array === undefined) {
+								array = [];
+								chunkSetsByCount.set(count, array);
+							}
+							array.push(chunksSet);
+						}
+						return chunkSetsByCount;
+					};
+					const getChunkSetsByCount = memoize(() =>
+						groupChunkSetsByCount(
+							getChunkSetsInGraph().chunkSetsInGraph.values()
+						)
+					);
+					const getExportsChunkSetsByCount = memoize(() =>
+						groupChunkSetsByCount(
+							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
+						)
+					);
 
+					// Create a list of possible combinations
+					const createGetCombinations = (
+						chunkSets,
+						singleChunkSets,
+						chunkSetsByCount
+					) => {
+						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
+						const combinationsCache = new Map();
 
-/***/ }),
+						return key => {
+							const cacheEntry = combinationsCache.get(key);
+							if (cacheEntry !== undefined) return cacheEntry;
+							if (key instanceof Chunk) {
+								const result = [key];
+								combinationsCache.set(key, result);
+								return result;
+							}
+							const chunksSet = chunkSets.get(key);
+							/** @type {(Set<Chunk> | Chunk)[]} */
+							const array = [chunksSet];
+							for (const [count, setArray] of chunkSetsByCount) {
+								// "equal" is not needed because they would have been merge in the first step
+								if (count < chunksSet.size) {
+									for (const set of setArray) {
+										if (isSubset(chunksSet, set)) {
+											array.push(set);
+										}
+									}
+								}
+							}
+							for (const chunk of singleChunkSets) {
+								if (chunksSet.has(chunk)) {
+									array.push(chunk);
+								}
+							}
+							combinationsCache.set(key, array);
+							return array;
+						};
+					};
 
-/***/ 15543:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					const getCombinationsFactory = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
+						return createGetCombinations(
+							chunkSetsInGraph,
+							singleChunkSets,
+							getChunkSetsByCount()
+						);
+					});
+					const getCombinations = key => getCombinationsFactory()(key);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					const getExportsCombinationsFactory = memoize(() => {
+						const { chunkSetsInGraph, singleChunkSets } =
+							getExportsChunkSetsInGraph();
+						return createGetCombinations(
+							chunkSetsInGraph,
+							singleChunkSets,
+							getExportsChunkSetsByCount()
+						);
+					});
+					const getExportsCombinations = key =>
+						getExportsCombinationsFactory()(key);
 
+					/**
+					 * @typedef {Object} SelectedChunksResult
+					 * @property {Chunk[]} chunks the list of chunks
+					 * @property {bigint | Chunk} key a key of the list
+					 */
 
+					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
+					const selectedChunksCacheByChunksSet = new WeakMap();
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const { intersect } = __webpack_require__(93347);
-const {
-	compareModulesByIdentifier,
-	compareChunks
-} = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-const identifierUtils = __webpack_require__(82186);
+					/**
+					 * get list and key by applying the filter function to the list
+					 * It is cached for performance reasons
+					 * @param {Set<Chunk> | Chunk} chunks list of chunks
+					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
+					 * @returns {SelectedChunksResult} list and key
+					 */
+					const getSelectedChunks = (chunks, chunkFilter) => {
+						let entry = selectedChunksCacheByChunksSet.get(chunks);
+						if (entry === undefined) {
+							entry = new WeakMap();
+							selectedChunksCacheByChunksSet.set(chunks, entry);
+						}
+						/** @type {SelectedChunksResult} */
+						let entry2 = entry.get(chunkFilter);
+						if (entry2 === undefined) {
+							/** @type {Chunk[]} */
+							const selectedChunks = [];
+							if (chunks instanceof Chunk) {
+								if (chunkFilter(chunks)) selectedChunks.push(chunks);
+							} else {
+								for (const chunk of chunks) {
+									if (chunkFilter(chunk)) selectedChunks.push(chunk);
+								}
+							}
+							entry2 = {
+								chunks: selectedChunks,
+								key: getKey(selectedChunks)
+							};
+							entry.set(chunkFilter, entry2);
+						}
+						return entry2;
+					};
 
-/** @typedef {import("../../declarations/plugins/optimize/AggressiveSplittingPlugin").AggressiveSplittingPluginOptions} AggressiveSplittingPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
+					/** @type {Map<string, boolean>} */
+					const alreadyValidatedParents = new Map();
+					/** @type {Set<string>} */
+					const alreadyReportedErrors = new Set();
 
-const validate = createSchemaValidation(
-	__webpack_require__(32697),
-	() =>
-		__webpack_require__(47995),
-	{
-		name: "Aggressive Splitting Plugin",
-		baseDataPath: "options"
-	}
-);
-
-const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => {
-	return module => {
-		chunkGraph.disconnectChunkAndModule(oldChunk, module);
-		chunkGraph.connectChunkAndModule(newChunk, module);
-	};
-};
-
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Chunk} chunk the chunk
- * @returns {function(Module): boolean} filter for entry module
- */
-const isNotAEntryModule = (chunkGraph, chunk) => {
-	return module => {
-		return !chunkGraph.isEntryModuleInChunk(module, chunk);
-	};
-};
-
-/** @type {WeakSet<Chunk>} */
-const recordedChunks = new WeakSet();
-
-class AggressiveSplittingPlugin {
-	/**
-	 * @param {AggressiveSplittingPluginOptions=} options options object
-	 */
-	constructor(options = {}) {
-		validate(options);
-
-		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;
-		}
-	}
-
-	/**
-	 * @param {Chunk} chunk the chunk to test
-	 * @returns {boolean} true if the chunk was recorded
-	 */
-	static wasChunkRecorded(chunk) {
-		return recordedChunks.has(chunk);
-	}
+					// Map a list of chunks to a list of modules
+					// For the key the chunk "index" is used, the value is a SortableSet of modules
+					/** @type {Map<string, ChunksInfoItem>} */
+					const chunksInfoMap = new Map();
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	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.optimizeChunks.tap(
-					{
-						name: "AggressiveSplittingPlugin",
-						stage: STAGE_ADVANCED
-					},
-					chunks => {
-						const chunkGraph = compilation.chunkGraph;
-						// Precompute stuff
-						const nameToModuleMap = new Map();
-						const moduleToNameMap = new Map();
-						const makePathsRelative =
-							identifierUtils.makePathsRelative.bindContextCache(
-								compiler.context,
-								compiler.root
+					/**
+					 * @param {CacheGroup} cacheGroup the current cache group
+					 * @param {number} cacheGroupIndex the index of the cache group of ordering
+					 * @param {Chunk[]} selectedChunks chunks selected for this module
+					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
+					 * @param {Module} module the current module
+					 * @returns {void}
+					 */
+					const addModuleToChunksInfoMap = (
+						cacheGroup,
+						cacheGroupIndex,
+						selectedChunks,
+						selectedChunksKey,
+						module
+					) => {
+						// Break if minimum number of chunks is not reached
+						if (selectedChunks.length < cacheGroup.minChunks) return;
+						// Determine name for split chunk
+						const name = cacheGroup.getName(
+							module,
+							selectedChunks,
+							cacheGroup.key
+						);
+						// Check if the name is ok
+						const existingChunk = compilation.namedChunks.get(name);
+						if (existingChunk) {
+							const parentValidationKey = `${name}|${
+								typeof selectedChunksKey === "bigint"
+									? selectedChunksKey
+									: selectedChunksKey.debugId
+							}`;
+							const valid = alreadyValidatedParents.get(parentValidationKey);
+							if (valid === false) return;
+							if (valid === undefined) {
+								// Module can only be moved into the existing chunk if the existing chunk
+								// is a parent of all selected chunks
+								let isInAllParents = true;
+								/** @type {Set<ChunkGroup>} */
+								const queue = new Set();
+								for (const chunk of selectedChunks) {
+									for (const group of chunk.groupsIterable) {
+										queue.add(group);
+									}
+								}
+								for (const group of queue) {
+									if (existingChunk.isInGroup(group)) continue;
+									let hasParent = false;
+									for (const parent of group.parentsIterable) {
+										hasParent = true;
+										queue.add(parent);
+									}
+									if (!hasParent) {
+										isInAllParents = false;
+									}
+								}
+								const valid = isInAllParents;
+								alreadyValidatedParents.set(parentValidationKey, valid);
+								if (!valid) {
+									if (!alreadyReportedErrors.has(name)) {
+										alreadyReportedErrors.add(name);
+										compilation.errors.push(
+											new WebpackError(
+												"SplitChunksPlugin\n" +
+													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
+													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
+													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +
+													'HINT: You can omit "name" to automatically create a name.\n' +
+													"BREAKING CHANGE: webpack < 5 used to allow to use an entrypoint as splitChunk. " +
+													"This is no longer allowed when the entrypoint is not a parent of the selected modules.\n" +
+													"Remove this entrypoint and add modules to cache group's 'test' instead. " +
+													"If you need modules to be evaluated on startup, add them to the existing entrypoints (make them arrays). " +
+													"See migration guide of more info."
+											)
+										);
+									}
+									return;
+								}
+							}
+						}
+						// Create key for maps
+						// When it has a name we use the name as key
+						// Otherwise we create the key from chunks and cache group key
+						// This automatically merges equal names
+						const key =
+							cacheGroup.key +
+							(name
+								? ` name:${name}`
+								: ` chunks:${keyToString(selectedChunksKey)}`);
+						// Add module to maps
+						let info = chunksInfoMap.get(key);
+						if (info === undefined) {
+							chunksInfoMap.set(
+								key,
+								(info = {
+									modules: new SortableSet(
+										undefined,
+										compareModulesByIdentifier
+									),
+									cacheGroup,
+									cacheGroupIndex,
+									name,
+									sizes: {},
+									chunks: new Set(),
+									reuseableChunks: new Set(),
+									chunksKeys: new Set()
+								})
 							);
-						for (const m of compilation.modules) {
-							const name = makePathsRelative(m.identifier());
-							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 oldSize = info.modules.size;
+						info.modules.add(module);
+						if (info.modules.size !== oldSize) {
+							for (const type of module.getSourceTypes()) {
+								info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
+							}
 						}
-
-						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;
+						const oldChunksKeysSize = info.chunksKeys.size;
+						info.chunksKeys.add(selectedChunksKey);
+						if (oldChunksKeysSize !== info.chunksKeys.size) {
+							for (const chunk of selectedChunks) {
+								info.chunks.add(chunk);
 							}
+						}
+					};
 
-							// 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)
-							let size = 0;
-							for (const m of selectedModules) size += m.size();
-							if (size !== splitData.size) return false;
+					const context = {
+						moduleGraph,
+						chunkGraph
+					};
 
-							// get chunks with all modules
-							const selectedChunks = intersect(
-								selectedModules.map(
-									m => new Set(chunkGraph.getModuleChunksIterable(m))
-								)
-							);
+					logger.timeEnd("prepare");
 
-							// No relevant chunks found
-							if (selectedChunks.size === 0) return false;
+					logger.time("modules");
 
-							// The found chunk is already the split or similar
-							if (
-								selectedChunks.size === 1 &&
-								chunkGraph.getNumberOfChunkModules(
-									Array.from(selectedChunks)[0]
-								) === selectedModules.length
-							) {
-								const chunk = Array.from(selectedChunks)[0];
-								if (fromAggressiveSplittingSet.has(chunk)) return false;
-								fromAggressiveSplittingSet.add(chunk);
-								chunkSplitDataMap.set(chunk, splitData);
-								return true;
-							}
+					// Walk through all modules
+					for (const module of compilation.modules) {
+						// Get cache group
+						let cacheGroups = this.options.getCacheGroups(module, context);
+						if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
+							continue;
+						}
 
-							// split the chunk into two parts
-							const newChunk = compilation.addChunk();
-							newChunk.chunkReason = "aggressive splitted";
-							for (const chunk of selectedChunks) {
-								selectedModules.forEach(
-									moveModuleBetween(chunkGraph, chunk, newChunk)
-								);
-								chunk.split(newChunk);
-								chunk.name = null;
-							}
-							fromAggressiveSplittingSet.add(newChunk);
-							chunkSplitDataMap.set(newChunk, splitData);
+						// Prepare some values (usedExports = false)
+						const getCombs = memoize(() => {
+							const chunks = chunkGraph.getModuleChunksIterable(module);
+							const chunksKey = getKey(chunks);
+							return getCombinations(chunksKey);
+						});
 
-							if (splitData.id !== null && splitData.id !== undefined) {
-								newChunk.id = splitData.id;
-								newChunk.ids = [splitData.id];
+						// Prepare some values (usedExports = true)
+						const getCombsByUsedExports = memoize(() => {
+							// fill the groupedByExportsMap
+							getExportsChunkSetsInGraph();
+							/** @type {Set<Set<Chunk> | Chunk>} */
+							const set = new Set();
+							const groupedByUsedExports = groupedByExportsMap.get(module);
+							for (const chunks of groupedByUsedExports) {
+								const chunksKey = getKey(chunks);
+								for (const comb of getExportsCombinations(chunksKey))
+									set.add(comb);
 							}
-							return true;
-						};
+							return set;
+						});
 
-						// 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;
-						}
+						let cacheGroupIndex = 0;
+						for (const cacheGroupSource of cacheGroups) {
+							const cacheGroup = this._getCacheGroup(cacheGroupSource);
 
-						// for any chunk which isn't splitted yet, split it and create a new entry
-						// start with the biggest chunk
-						const cmpFn = compareChunks(chunkGraph);
-						const sortedChunks = Array.from(chunks).sort((a, b) => {
-							const diff1 =
-								chunkGraph.getChunkModulesSize(b) -
-								chunkGraph.getChunkModulesSize(a);
-							if (diff1) return diff1;
-							const diff2 =
-								chunkGraph.getNumberOfChunkModules(a) -
-								chunkGraph.getNumberOfChunkModules(b);
-							if (diff2) return diff2;
-							return cmpFn(a, b);
-						});
-						for (const chunk of sortedChunks) {
-							if (fromAggressiveSplittingSet.has(chunk)) continue;
-							const size = chunkGraph.getChunkModulesSize(chunk);
-							if (
-								size > maxSize &&
-								chunkGraph.getNumberOfChunkModules(chunk) > 1
-							) {
-								const modules = chunkGraph
-									.getOrderedChunkModules(chunk, compareModulesByIdentifier)
-									.filter(isNotAEntryModule(chunkGraph, chunk));
-								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
-								};
+							const combs = cacheGroup.usedExports
+								? getCombsByUsedExports()
+								: getCombs();
+							// For all combination of chunk selection
+							for (const chunkCombination of combs) {
+								// Break if minimum number of chunks is not reached
+								const count =
+									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
+								if (count < cacheGroup.minChunks) continue;
+								// Select chunks by configuration
+								const { chunks: selectedChunks, key: selectedChunksKey } =
+									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
 
-								if (applySplit(splitData)) {
-									newSplits = (newSplits || []).concat(splitData);
-									changed = true;
-								}
+								addModuleToChunksInfoMap(
+									cacheGroup,
+									cacheGroupIndex,
+									selectedChunks,
+									selectedChunksKey,
+									module
+								);
 							}
+							cacheGroupIndex++;
 						}
-						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);
-								}
-							}
-						}
+					logger.timeEnd("modules");
 
-						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
-									recordedChunks.add(chunk);
-								}
-							}
+					logger.time("queue");
 
-							// Also add all unused historical 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);
+					/**
+					 * @param {ChunksInfoItem} info entry
+					 * @param {string[]} sourceTypes source types to be removed
+					 */
+					const removeModulesWithSourceType = (info, sourceTypes) => {
+						for (const module of info.modules) {
+							const types = module.getSourceTypes();
+							if (sourceTypes.some(type => types.has(type))) {
+								info.modules.delete(module);
+								for (const type of types) {
+									info.sizes[type] -= module.size(type);
 								}
 							}
+						}
+					};
 
-							// record all splits
-							records.aggressiveSplits = Array.from(allSplits);
+					/**
+					 * @param {ChunksInfoItem} info entry
+					 * @returns {boolean} true, if entry become empty
+					 */
+					const removeMinSizeViolatingModules = info => {
+						if (!info.cacheGroup._validateSize) return false;
+						const violatingSizes = getViolatingMinSizes(
+							info.sizes,
+							info.cacheGroup.minSize
+						);
+						if (violatingSizes === undefined) return false;
+						removeModulesWithSourceType(info, violatingSizes);
+						return info.modules.size === 0;
+					};
 
-							needAdditionalSeal = false;
-						}
-					}
-				);
-				compilation.hooks.needAdditionalSeal.tap(
-					"AggressiveSplittingPlugin",
-					() => {
-						if (needAdditionalSeal) {
-							needAdditionalSeal = false;
-							return true;
+					// Filter items were size < minSize
+					for (const [key, info] of chunksInfoMap) {
+						if (removeMinSizeViolatingModules(info)) {
+							chunksInfoMap.delete(key);
+						} else if (
+							!checkMinSizeReduction(
+								info.sizes,
+								info.cacheGroup.minSizeReduction,
+								info.chunks.size
+							)
+						) {
+							chunksInfoMap.delete(key);
 						}
 					}
-				);
-			}
-		);
-	}
-}
-module.exports = AggressiveSplittingPlugin;
-
 
-/***/ }),
+					/**
+					 * @typedef {Object} MaxSizeQueueItem
+					 * @property {SplitChunksSizes} minSize
+					 * @property {SplitChunksSizes} maxAsyncSize
+					 * @property {SplitChunksSizes} maxInitialSize
+					 * @property {string} automaticNameDelimiter
+					 * @property {string[]} keys
+					 */
 
-/***/ 97198:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+					/** @type {Map<Chunk, MaxSizeQueueItem>} */
+					const maxSizeQueueMap = new Map();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const eslintScope = __webpack_require__(36007);
-const Referencer = __webpack_require__(44585);
-const {
-	CachedSource,
-	ConcatSource,
-	ReplaceSource
-} = __webpack_require__(51255);
-const ConcatenationScope = __webpack_require__(98229);
-const { UsageState } = __webpack_require__(63686);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HarmonyImportDependency = __webpack_require__(57154);
-const JavascriptParser = __webpack_require__(29050);
-const { equals } = __webpack_require__(84953);
-const LazySet = __webpack_require__(38938);
-const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const { makePathsRelative } = __webpack_require__(82186);
-const makeSerializable = __webpack_require__(33032);
-const propertyAccess = __webpack_require__(54190);
-const {
-	filterRuntime,
-	intersectRuntime,
-	mergeRuntimeCondition,
-	mergeRuntimeConditionNonFalse,
-	runtimeConditionToString,
-	subtractRuntimeCondition
-} = __webpack_require__(17156);
-
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {typeof import("../util/Hash")} HashConstructor */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-// fix eslint-scope to support class properties correctly
-// cspell:word Referencer
-const ReferencerClass = Referencer;
-if (!ReferencerClass.prototype.PropertyDefinition) {
-	ReferencerClass.prototype.PropertyDefinition =
-		ReferencerClass.prototype.Property;
-}
-
-/**
- * @typedef {Object} ReexportInfo
- * @property {Module} module
- * @property {string[]} export
- */
+					while (chunksInfoMap.size > 0) {
+						// Find best matching entry
+						let bestEntryKey;
+						let bestEntry;
+						for (const pair of chunksInfoMap) {
+							const key = pair[0];
+							const info = pair[1];
+							if (
+								bestEntry === undefined ||
+								compareEntries(bestEntry, info) < 0
+							) {
+								bestEntry = info;
+								bestEntryKey = key;
+							}
+						}
 
-/** @typedef {RawBinding | SymbolBinding} Binding */
+						const item = bestEntry;
+						chunksInfoMap.delete(bestEntryKey);
 
-/**
- * @typedef {Object} RawBinding
- * @property {ModuleInfo} info
- * @property {string} rawName
- * @property {string=} comment
- * @property {string[]} ids
- * @property {string[]} exportName
- */
+						let chunkName = item.name;
+						// Variable for the new chunk (lazy created)
+						/** @type {Chunk} */
+						let newChunk;
+						// When no chunk name, check if we can reuse a chunk instead of creating a new one
+						let isExistingChunk = false;
+						let isReusedWithAllModules = false;
+						if (chunkName) {
+							const chunkByName = compilation.namedChunks.get(chunkName);
+							if (chunkByName !== undefined) {
+								newChunk = chunkByName;
+								const oldSize = item.chunks.size;
+								item.chunks.delete(newChunk);
+								isExistingChunk = item.chunks.size !== oldSize;
+							}
+						} else if (item.cacheGroup.reuseExistingChunk) {
+							outer: for (const chunk of item.chunks) {
+								if (
+									chunkGraph.getNumberOfChunkModules(chunk) !==
+									item.modules.size
+								) {
+									continue;
+								}
+								if (
+									item.chunks.size > 1 &&
+									chunkGraph.getNumberOfEntryModules(chunk) > 0
+								) {
+									continue;
+								}
+								for (const module of item.modules) {
+									if (!chunkGraph.isModuleInChunk(module, chunk)) {
+										continue outer;
+									}
+								}
+								if (!newChunk || !newChunk.name) {
+									newChunk = chunk;
+								} else if (
+									chunk.name &&
+									chunk.name.length < newChunk.name.length
+								) {
+									newChunk = chunk;
+								} else if (
+									chunk.name &&
+									chunk.name.length === newChunk.name.length &&
+									chunk.name < newChunk.name
+								) {
+									newChunk = chunk;
+								}
+							}
+							if (newChunk) {
+								item.chunks.delete(newChunk);
+								chunkName = undefined;
+								isExistingChunk = true;
+								isReusedWithAllModules = true;
+							}
+						}
 
-/**
- * @typedef {Object} SymbolBinding
- * @property {ConcatenatedModuleInfo} info
- * @property {string} name
- * @property {string=} comment
- * @property {string[]} ids
- * @property {string[]} exportName
- */
+						const enforced =
+							item.cacheGroup._conditionalEnforce &&
+							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
 
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo } ModuleInfo */
-/** @typedef {ConcatenatedModuleInfo | ExternalModuleInfo | ReferenceToModuleInfo } ModuleInfoOrReference */
+						const usedChunks = new Set(item.chunks);
 
-/**
- * @typedef {Object} ConcatenatedModuleInfo
- * @property {"concatenated"} type
- * @property {Module} module
- * @property {number} index
- * @property {Object} ast
- * @property {Source} internalSource
- * @property {ReplaceSource} source
- * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
- * @property {Iterable<string>} runtimeRequirements
- * @property {Scope} globalScope
- * @property {Scope} moduleScope
- * @property {Map<string, string>} internalNames
- * @property {Map<string, string>} exportMap
- * @property {Map<string, string>} rawExportMap
- * @property {string=} namespaceExportSymbol
- * @property {string} namespaceObjectName
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
- */
+						// Check if maxRequests condition can be fulfilled
+						if (
+							!enforced &&
+							(Number.isFinite(item.cacheGroup.maxInitialRequests) ||
+								Number.isFinite(item.cacheGroup.maxAsyncRequests))
+						) {
+							for (const chunk of usedChunks) {
+								// respect max requests
+								const maxRequests = chunk.isOnlyInitial()
+									? item.cacheGroup.maxInitialRequests
+									: chunk.canBeInitial()
+									? Math.min(
+											item.cacheGroup.maxInitialRequests,
+											item.cacheGroup.maxAsyncRequests
+									  )
+									: item.cacheGroup.maxAsyncRequests;
+								if (
+									isFinite(maxRequests) &&
+									getRequests(chunk) >= maxRequests
+								) {
+									usedChunks.delete(chunk);
+								}
+							}
+						}
 
-/**
- * @typedef {Object} ExternalModuleInfo
- * @property {"external"} type
- * @property {Module} module
- * @property {RuntimeSpec | boolean} runtimeCondition
- * @property {number} index
- * @property {string} name
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string} interopDefaultAccessName
- */
+						outer: for (const chunk of usedChunks) {
+							for (const module of item.modules) {
+								if (chunkGraph.isModuleInChunk(module, chunk)) continue outer;
+							}
+							usedChunks.delete(chunk);
+						}
 
-/**
- * @typedef {Object} ReferenceToModuleInfo
- * @property {"reference"} type
- * @property {RuntimeSpec | boolean} runtimeCondition
- * @property {ConcatenatedModuleInfo | ExternalModuleInfo} target
- */
+						// Were some (invalid) chunks removed from usedChunks?
+						// => readd all modules to the queue, as things could have been changed
+						if (usedChunks.size < item.chunks.size) {
+							if (isExistingChunk) usedChunks.add(newChunk);
+							if (usedChunks.size >= item.cacheGroup.minChunks) {
+								const chunksArr = Array.from(usedChunks);
+								for (const module of item.modules) {
+									addModuleToChunksInfoMap(
+										item.cacheGroup,
+										item.cacheGroupIndex,
+										chunksArr,
+										getKey(usedChunks),
+										module
+									);
+								}
+							}
+							continue;
+						}
 
-const RESERVED_NAMES = new Set(
-	[
-		// internal names (should always be renamed)
-		ConcatenationScope.DEFAULT_EXPORT,
-		ConcatenationScope.NAMESPACE_OBJECT_EXPORT,
+						// Validate minRemainingSize constraint when a single chunk is left over
+						if (
+							!enforced &&
+							item.cacheGroup._validateRemainingSize &&
+							usedChunks.size === 1
+						) {
+							const [chunk] = usedChunks;
+							let chunkSizes = Object.create(null);
+							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+								if (!item.modules.has(module)) {
+									for (const type of module.getSourceTypes()) {
+										chunkSizes[type] =
+											(chunkSizes[type] || 0) + module.size(type);
+									}
+								}
+							}
+							const violatingSizes = getViolatingMinSizes(
+								chunkSizes,
+								item.cacheGroup.minRemainingSize
+							);
+							if (violatingSizes !== undefined) {
+								const oldModulesSize = item.modules.size;
+								removeModulesWithSourceType(item, violatingSizes);
+								if (
+									item.modules.size > 0 &&
+									item.modules.size !== oldModulesSize
+								) {
+									// queue this item again to be processed again
+									// without violating modules
+									chunksInfoMap.set(bestEntryKey, item);
+								}
+								continue;
+							}
+						}
 
-		// keywords
-		"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",
+						// Create the new chunk if not reusing one
+						if (newChunk === undefined) {
+							newChunk = compilation.addChunk(chunkName);
+						}
+						// Walk through all chunks
+						for (const chunk of usedChunks) {
+							// Add graph connections for splitted chunk
+							chunk.split(newChunk);
+						}
 
-		// commonjs/amd
-		"module,__dirname,__filename,exports,require,define",
+						// Add a note to the chunk
+						newChunk.chunkReason =
+							(newChunk.chunkReason ? newChunk.chunkReason + ", " : "") +
+							(isReusedWithAllModules
+								? "reused as split chunk"
+								: "split chunk");
+						if (item.cacheGroup.key) {
+							newChunk.chunkReason += ` (cache group: ${item.cacheGroup.key})`;
+						}
+						if (chunkName) {
+							newChunk.chunkReason += ` (name: ${chunkName})`;
+						}
+						if (item.cacheGroup.filename) {
+							newChunk.filenameTemplate = item.cacheGroup.filename;
+						}
+						if (item.cacheGroup.idHint) {
+							newChunk.idNameHints.add(item.cacheGroup.idHint);
+						}
+						if (!isReusedWithAllModules) {
+							// Add all modules to the new chunk
+							for (const module of item.modules) {
+								if (!module.chunkCondition(newChunk, compilation)) continue;
+								// Add module to new chunk
+								chunkGraph.connectChunkAndModule(newChunk, module);
+								// Remove module from used chunks
+								for (const chunk of usedChunks) {
+									chunkGraph.disconnectChunkAndModule(chunk, module);
+								}
+							}
+						} else {
+							// Remove all modules from used chunks
+							for (const module of item.modules) {
+								for (const chunk of usedChunks) {
+									chunkGraph.disconnectChunkAndModule(chunk, module);
+								}
+							}
+						}
 
-		// js globals
-		"Array,Date,eval,function,hasOwnProperty,Infinity,isFinite,isNaN,isPrototypeOf,length,Math",
-		"NaN,name,Number,Object,prototype,String,toString,undefined,valueOf",
+						if (
+							Object.keys(item.cacheGroup.maxAsyncSize).length > 0 ||
+							Object.keys(item.cacheGroup.maxInitialSize).length > 0
+						) {
+							const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
+							maxSizeQueueMap.set(newChunk, {
+								minSize: oldMaxSizeSettings
+									? combineSizes(
+											oldMaxSizeSettings.minSize,
+											item.cacheGroup._minSizeForMaxSize,
+											Math.max
+									  )
+									: item.cacheGroup.minSize,
+								maxAsyncSize: oldMaxSizeSettings
+									? combineSizes(
+											oldMaxSizeSettings.maxAsyncSize,
+											item.cacheGroup.maxAsyncSize,
+											Math.min
+									  )
+									: item.cacheGroup.maxAsyncSize,
+								maxInitialSize: oldMaxSizeSettings
+									? combineSizes(
+											oldMaxSizeSettings.maxInitialSize,
+											item.cacheGroup.maxInitialSize,
+											Math.min
+									  )
+									: item.cacheGroup.maxInitialSize,
+								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
+								keys: oldMaxSizeSettings
+									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+									: [item.cacheGroup.key]
+							});
+						}
 
-		// browser globals
-		"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",
+						// remove all modules from other entries and update size
+						for (const [key, info] of chunksInfoMap) {
+							if (isOverlap(info.chunks, usedChunks)) {
+								// update modules and total size
+								// may remove it from the map when < minSize
+								let updated = false;
+								for (const module of item.modules) {
+									if (info.modules.has(module)) {
+										// remove module
+										info.modules.delete(module);
+										// update size
+										for (const key of module.getSourceTypes()) {
+											info.sizes[key] -= module.size(key);
+										}
+										updated = true;
+									}
+								}
+								if (updated) {
+									if (info.modules.size === 0) {
+										chunksInfoMap.delete(key);
+										continue;
+									}
+									if (
+										removeMinSizeViolatingModules(info) ||
+										!checkMinSizeReduction(
+											info.sizes,
+											info.cacheGroup.minSizeReduction,
+											info.chunks.size
+										)
+									) {
+										chunksInfoMap.delete(key);
+										continue;
+									}
+								}
+							}
+						}
+					}
 
-		// window events
-		"onblur,onclick,onerror,onfocus,onkeydown,onkeypress,onkeyup,onmouseover,onload,onmouseup,onmousedown,onsubmit"
-	]
-		.join(",")
-		.split(",")
-);
+					logger.timeEnd("queue");
 
-const bySourceOrder = (a, b) => {
-	const aOrder = a.sourceOrder;
-	const bOrder = b.sourceOrder;
-	if (isNaN(aOrder)) {
-		if (!isNaN(bOrder)) {
-			return 1;
-		}
-	} else {
-		if (isNaN(bOrder)) {
-			return -1;
-		}
-		if (aOrder !== bOrder) {
-			return aOrder < bOrder ? -1 : 1;
-		}
-	}
-	return 0;
-};
+					logger.time("maxSize");
 
-const joinIterableWithComma = iterable => {
-	// This is more performant than Array.from().join(", ")
-	// as it doesn't create an array
-	let str = "";
-	let first = true;
-	for (const item of iterable) {
-		if (first) {
-			first = false;
-		} else {
-			str += ", ";
-		}
-		str += item;
-	}
-	return str;
-};
+					/** @type {Set<string>} */
+					const incorrectMinMaxSizeSet = new Set();
 
-/**
- * @typedef {Object} ConcatenationEntry
- * @property {"concatenated" | "external"} type
- * @property {Module} module
- * @property {RuntimeSpec | boolean} runtimeCondition
- */
+					const { outputOptions } = compilation;
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {ModuleInfo} info module info
- * @param {string[]} exportName exportName
- * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
- * @param {RuntimeSpec} runtime for which runtime
- * @param {RequestShortener} requestShortener the request shortener
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
- * @param {boolean} asCall asCall
- * @param {boolean} strictHarmonyModule strictHarmonyModule
- * @param {boolean | undefined} asiSafe asiSafe
- * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
- * @returns {Binding} the final variable
- */
-const getFinalBinding = (
-	moduleGraph,
-	info,
-	exportName,
-	moduleToInfoMap,
-	runtime,
-	requestShortener,
-	runtimeTemplate,
-	neededNamespaceObjects,
-	asCall,
-	strictHarmonyModule,
-	asiSafe,
-	alreadyVisited = new Set()
-) => {
-	const exportsType = info.module.getExportsType(
-		moduleGraph,
-		strictHarmonyModule
-	);
-	if (exportName.length === 0) {
-		switch (exportsType) {
-			case "default-only":
-				info.interopNamespaceObject2Used = true;
-				return {
-					info,
-					rawName: info.interopNamespaceObject2Name,
-					ids: exportName,
-					exportName
-				};
-			case "default-with-named":
-				info.interopNamespaceObjectUsed = true;
-				return {
-					info,
-					rawName: info.interopNamespaceObjectName,
-					ids: exportName,
-					exportName
-				};
-			case "namespace":
-			case "dynamic":
-				break;
-			default:
-				throw new Error(`Unexpected exportsType ${exportsType}`);
-		}
-	} else {
-		switch (exportsType) {
-			case "namespace":
-				break;
-			case "default-with-named":
-				switch (exportName[0]) {
-					case "default":
-						exportName = exportName.slice(1);
-						break;
-					case "__esModule":
-						return {
-							info,
-							rawName: "/* __esModule */true",
-							ids: exportName.slice(1),
-							exportName
-						};
-				}
-				break;
-			case "default-only": {
-				const exportId = exportName[0];
-				if (exportId === "__esModule") {
-					return {
-						info,
-						rawName: "/* __esModule */true",
-						ids: exportName.slice(1),
-						exportName
-					};
-				}
-				exportName = exportName.slice(1);
-				if (exportId !== "default") {
-					return {
-						info,
-						rawName:
-							"/* non-default import from default-exporting module */undefined",
-						ids: exportName,
-						exportName
-					};
-				}
-				break;
-			}
-			case "dynamic":
-				switch (exportName[0]) {
-					case "default": {
-						exportName = exportName.slice(1);
-						info.interopDefaultAccessUsed = true;
-						const defaultExport = asCall
-							? `${info.interopDefaultAccessName}()`
-							: asiSafe
-							? `(${info.interopDefaultAccessName}())`
-							: asiSafe === false
-							? `;(${info.interopDefaultAccessName}())`
-							: `${info.interopDefaultAccessName}.a`;
-						return {
-							info,
-							rawName: defaultExport,
-							ids: exportName,
-							exportName
-						};
+					// Make sure that maxSize is fulfilled
+					const { fallbackCacheGroup } = this.options;
+					for (const chunk of Array.from(compilation.chunks)) {
+						const chunkConfig = maxSizeQueueMap.get(chunk);
+						const {
+							minSize,
+							maxAsyncSize,
+							maxInitialSize,
+							automaticNameDelimiter
+						} = chunkConfig || fallbackCacheGroup;
+						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+							continue;
+						/** @type {SplitChunksSizes} */
+						let maxSize;
+						if (chunk.isOnlyInitial()) {
+							maxSize = maxInitialSize;
+						} else if (chunk.canBeInitial()) {
+							maxSize = combineSizes(maxAsyncSize, maxInitialSize, Math.min);
+						} else {
+							maxSize = maxAsyncSize;
+						}
+						if (Object.keys(maxSize).length === 0) {
+							continue;
+						}
+						for (const key of Object.keys(maxSize)) {
+							const maxSizeValue = maxSize[key];
+							const minSizeValue = minSize[key];
+							if (
+								typeof minSizeValue === "number" &&
+								minSizeValue > maxSizeValue
+							) {
+								const keys = chunkConfig && chunkConfig.keys;
+								const warningKey = `${
+									keys && keys.join()
+								} ${minSizeValue} ${maxSizeValue}`;
+								if (!incorrectMinMaxSizeSet.has(warningKey)) {
+									incorrectMinMaxSizeSet.add(warningKey);
+									compilation.warnings.push(
+										new MinMaxSizeWarning(keys, minSizeValue, maxSizeValue)
+									);
+								}
+							}
+						}
+						const results = deterministicGroupingForModules({
+							minSize,
+							maxSize: mapObject(maxSize, (value, key) => {
+								const minSizeValue = minSize[key];
+								return typeof minSizeValue === "number"
+									? Math.max(value, minSizeValue)
+									: value;
+							}),
+							items: chunkGraph.getChunkModulesIterable(chunk),
+							getKey(module) {
+								const cache = getKeyCache.get(module);
+								if (cache !== undefined) return cache;
+								const ident = cachedMakePathsRelative(module.identifier());
+								const nameForCondition =
+									module.nameForCondition && module.nameForCondition();
+								const name = nameForCondition
+									? cachedMakePathsRelative(nameForCondition)
+									: ident.replace(/^.*!|\?[^?!]*$/g, "");
+								const fullKey =
+									name +
+									automaticNameDelimiter +
+									hashFilename(ident, outputOptions);
+								const key = requestToId(fullKey);
+								getKeyCache.set(module, key);
+								return key;
+							},
+							getSize(module) {
+								const size = Object.create(null);
+								for (const key of module.getSourceTypes()) {
+									size[key] = module.size(key);
+								}
+								return size;
+							}
+						});
+						if (results.length <= 1) {
+							continue;
+						}
+						for (let i = 0; i < results.length; i++) {
+							const group = results[i];
+							const key = this.options.hidePathInfo
+								? hashFilename(group.key, outputOptions)
+								: group.key;
+							let name = chunk.name
+								? chunk.name + automaticNameDelimiter + key
+								: null;
+							if (name && name.length > 100) {
+								name =
+									name.slice(0, 100) +
+									automaticNameDelimiter +
+									hashFilename(name, outputOptions);
+							}
+							if (i !== results.length - 1) {
+								const newPart = compilation.addChunk(name);
+								chunk.split(newPart);
+								newPart.chunkReason = chunk.chunkReason;
+								// Add all modules to the new chunk
+								for (const module of group.items) {
+									if (!module.chunkCondition(newPart, compilation)) {
+										continue;
+									}
+									// Add module to new chunk
+									chunkGraph.connectChunkAndModule(newPart, module);
+									// Remove module from used chunks
+									chunkGraph.disconnectChunkAndModule(chunk, module);
+								}
+							} else {
+								// change the chunk to be a part
+								chunk.name = name;
+							}
+						}
 					}
-					case "__esModule":
-						return {
-							info,
-							rawName: "/* __esModule */true",
-							ids: exportName.slice(1),
-							exportName
-						};
-				}
-				break;
-			default:
-				throw new Error(`Unexpected exportsType ${exportsType}`);
-		}
-	}
-	if (exportName.length === 0) {
-		switch (info.type) {
-			case "concatenated":
-				neededNamespaceObjects.add(info);
-				return {
-					info,
-					rawName: info.namespaceObjectName,
-					ids: exportName,
-					exportName
-				};
-			case "external":
-				return { info, rawName: info.name, ids: exportName, exportName };
-		}
-	}
-	const exportsInfo = moduleGraph.getExportsInfo(info.module);
-	const exportInfo = exportsInfo.getExportInfo(exportName[0]);
-	if (alreadyVisited.has(exportInfo)) {
-		return {
-			info,
-			rawName: "/* circular reexport */ Object(function x() { x() }())",
-			ids: [],
-			exportName
-		};
-	}
-	alreadyVisited.add(exportInfo);
-	switch (info.type) {
-		case "concatenated": {
-			const exportId = exportName[0];
-			if (exportInfo.provided === false) {
-				// It's not provided, but it could be on the prototype
-				neededNamespaceObjects.add(info);
-				return {
-					info,
-					rawName: info.namespaceObjectName,
-					ids: exportName,
-					exportName
-				};
-			}
-			const directExport = info.exportMap && info.exportMap.get(exportId);
-			if (directExport) {
-				const usedName = /** @type {string[]} */ (
-					exportsInfo.getUsedName(exportName, runtime)
-				);
-				if (!usedName) {
-					return {
-						info,
-						rawName: "/* unused export */ undefined",
-						ids: exportName.slice(1),
-						exportName
-					};
+					logger.timeEnd("maxSize");
 				}
-				return {
-					info,
-					name: directExport,
-					ids: usedName.slice(1),
-					exportName
-				};
-			}
-			const rawExport = info.rawExportMap && info.rawExportMap.get(exportId);
-			if (rawExport) {
-				return {
-					info,
-					rawName: rawExport,
-					ids: exportName.slice(1),
-					exportName
-				};
-			}
-			const reexport = exportInfo.findTarget(moduleGraph, module =>
-				moduleToInfoMap.has(module)
-			);
-			if (reexport === false) {
-				throw new Error(
-					`Target module of reexport from '${info.module.readableIdentifier(
-						requestShortener
-					)}' is not part of the concatenation (export '${exportId}')\nModules in the concatenation:\n${Array.from(
-						moduleToInfoMap,
-						([m, info]) =>
-							` * ${info.type} ${m.readableIdentifier(requestShortener)}`
-					).join("\n")}`
-				);
-			}
-			if (reexport) {
-				const refInfo = moduleToInfoMap.get(reexport.module);
-				return getFinalBinding(
-					moduleGraph,
-					refInfo,
-					reexport.export
-						? [...reexport.export, ...exportName.slice(1)]
-						: exportName.slice(1),
-					moduleToInfoMap,
-					runtime,
-					requestShortener,
-					runtimeTemplate,
-					neededNamespaceObjects,
-					asCall,
-					info.module.buildMeta.strictHarmonyModule,
-					asiSafe,
-					alreadyVisited
-				);
-			}
-			if (info.namespaceExportSymbol) {
-				const usedName = /** @type {string[]} */ (
-					exportsInfo.getUsedName(exportName, runtime)
-				);
-				return {
-					info,
-					rawName: info.namespaceObjectName,
-					ids: usedName,
-					exportName
-				};
-			}
-			throw new Error(
-				`Cannot get final name for export '${exportName.join(
-					"."
-				)}' of ${info.module.readableIdentifier(requestShortener)}`
-			);
-		}
-
-		case "external": {
-			const used = /** @type {string[]} */ (
-				exportsInfo.getUsedName(exportName, runtime)
 			);
-			if (!used) {
-				return {
-					info,
-					rawName: "/* unused export */ undefined",
-					ids: exportName.slice(1),
-					exportName
-				};
-			}
-			const comment = equals(used, exportName)
-				? ""
-				: Template.toNormalComment(`${exportName.join(".")}`);
-			return { info, rawName: info.name + comment, ids: used, exportName };
-		}
+		});
 	}
 };
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {ModuleInfo} info module info
- * @param {string[]} exportName exportName
- * @param {Map<Module, ModuleInfo>} moduleToInfoMap moduleToInfoMap
- * @param {RuntimeSpec} runtime for which runtime
- * @param {RequestShortener} requestShortener the request shortener
- * @param {RuntimeTemplate} runtimeTemplate the runtime template
- * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
- * @param {boolean} asCall asCall
- * @param {boolean} callContext callContext
- * @param {boolean} strictHarmonyModule strictHarmonyModule
- * @param {boolean | undefined} asiSafe asiSafe
- * @returns {string} the final name
- */
-const getFinalName = (
-	moduleGraph,
-	info,
-	exportName,
-	moduleToInfoMap,
-	runtime,
-	requestShortener,
-	runtimeTemplate,
-	neededNamespaceObjects,
-	asCall,
-	callContext,
-	strictHarmonyModule,
-	asiSafe
-) => {
-	const binding = getFinalBinding(
-		moduleGraph,
-		info,
-		exportName,
-		moduleToInfoMap,
-		runtime,
-		requestShortener,
-		runtimeTemplate,
-		neededNamespaceObjects,
-		asCall,
-		strictHarmonyModule,
-		asiSafe
-	);
-	{
-		const { ids, comment } = binding;
-		let reference;
-		let isPropertyAccess;
-		if ("rawName" in binding) {
-			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
-			isPropertyAccess = ids.length > 0;
-		} else {
-			const { info, name: exportId } = binding;
-			const name = info.internalNames.get(exportId);
-			if (!name) {
-				throw new Error(
-					`The export "${exportId}" in "${info.module.readableIdentifier(
-						requestShortener
-					)}" has no internal name (existing names: ${
-						Array.from(
-							info.internalNames,
-							([name, symbol]) => `${name}: ${symbol}`
-						).join(", ") || "none"
-					})`
-				);
-			}
-			reference = `${name}${comment || ""}${propertyAccess(ids)}`;
-			isPropertyAccess = ids.length > 1;
-		}
-		if (isPropertyAccess && asCall && callContext === false) {
-			return asiSafe
-				? `(0,${reference})`
-				: asiSafe === false
-				? `;(0,${reference})`
-				: `/*#__PURE__*/Object(${reference})`;
-		}
-		return reference;
-	}
-};
 
-const addScopeSymbols = (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;
-};
+/***/ 52149:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
 
-	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;
-	};
 
-	if (Array.isArray(ast)) {
-		for (let 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 (let 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;
-			}
-		}
-	}
-};
+const { formatSize } = __webpack_require__(71070);
+const WebpackError = __webpack_require__(53799);
 
-const TYPES = new Set(["javascript"]);
+/** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
 
-class ConcatenatedModule extends Module {
+module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
 	/**
-	 * @param {Module} rootModule the root module of the concatenation
-	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @param {string | HashConstructor=} hashFunction hash function to use
-	 * @returns {ConcatenatedModule} the module
+	 * @param {AssetDetails[]} assetsOverSizeLimit the assets
+	 * @param {number} assetLimit the size limit
 	 */
-	static create(
-		rootModule,
-		modules,
-		runtime,
-		associatedObjectForCache,
-		hashFunction = "md4"
-	) {
-		const identifier = ConcatenatedModule._createIdentifier(
-			rootModule,
-			modules,
-			associatedObjectForCache,
-			hashFunction
-		);
-		return new ConcatenatedModule({
-			identifier,
-			rootModule,
-			modules,
-			runtime
-		});
-	}
+	constructor(assetsOverSizeLimit, assetLimit) {
+		const assetLists = assetsOverSizeLimit
+			.map(asset => `\n  ${asset.name} (${formatSize(asset.size)})`)
+			.join("");
 
-	/**
-	 * @param {Object} options options
-	 * @param {string} options.identifier the identifier of the module
-	 * @param {Module=} options.rootModule the root module of the concatenation
-	 * @param {RuntimeSpec} options.runtime the selected runtime
-	 * @param {Set<Module>=} options.modules all concatenated modules
-	 */
-	constructor({ identifier, rootModule, modules, runtime }) {
-		super("javascript/esm", null, rootModule && rootModule.layer);
+		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(
+			assetLimit
+		)}).
+This can impact web performance.
+Assets: ${assetLists}`);
 
-		// Info from Factory
-		/** @type {string} */
-		this._identifier = identifier;
-		/** @type {Module} */
-		this.rootModule = rootModule;
-		/** @type {Set<Module>} */
-		this._modules = modules;
-		this._runtime = runtime;
-		this.factoryMeta = rootModule && rootModule.factoryMeta;
+		this.name = "AssetsOverSizeLimitWarning";
+		this.assets = assetsOverSizeLimit;
 	}
+};
 
-	/**
-	 * Assuming this module is in the cache. Update the (cached) module with
-	 * the fresh module from the factory. Usually updates internal references
-	 * and properties.
-	 * @param {Module} module fresh module
-	 * @returns {void}
-	 */
-	updateCacheModule(module) {
-		throw new Error("Must not be called");
-	}
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
-	}
+/***/ }),
 
-	get modules() {
-		return Array.from(this._modules);
-	}
+/***/ 84229:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+
+
+
+const { formatSize } = __webpack_require__(71070);
+const WebpackError = __webpack_require__(53799);
 
+/** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
+
+module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {EntrypointDetails[]} entrypoints the entrypoints
+	 * @param {number} entrypointLimit the size limit
 	 */
-	identifier() {
-		return this._identifier;
+	constructor(entrypoints, entrypointLimit) {
+		const entrypointList = entrypoints
+			.map(
+				entrypoint =>
+					`\n  ${entrypoint.name} (${formatSize(
+						entrypoint.size
+					)})\n${entrypoint.files.map(asset => `      ${asset}`).join("\n")}`
+			)
+			.join("");
+		super(`entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${formatSize(
+			entrypointLimit
+		)}). This can impact web performance.
+Entrypoints:${entrypointList}\n`);
+
+		this.name = "EntrypointsOverSizeLimitWarning";
+		this.entrypoints = entrypoints;
 	}
+};
 
-	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
-	 */
-	readableIdentifier(requestShortener) {
-		return (
-			this.rootModule.readableIdentifier(requestShortener) +
-			` + ${this._modules.size - 1} modules`
+
+/***/ }),
+
+/***/ 17791:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+
+
+
+const WebpackError = __webpack_require__(53799);
+
+module.exports = class NoAsyncChunksWarning extends WebpackError {
+	constructor() {
+		super(
+			"webpack performance recommendations: \n" +
+				"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
+				"For more info visit https://webpack.js.org/guides/code-splitting/"
 		);
-	}
 
-	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
-	 */
-	libIdent(options) {
-		return this.rootModule.libIdent(options);
+		this.name = "NoAsyncChunksWarning";
 	}
+};
+
+
+/***/ }),
+
+/***/ 32557:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sean Larkin @thelarkinn
+*/
+
+
+
+const { find } = __webpack_require__(93347);
+const AssetsOverSizeLimitWarning = __webpack_require__(52149);
+const EntrypointsOverSizeLimitWarning = __webpack_require__(84229);
+const NoAsyncChunksWarning = __webpack_require__(17791);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../WebpackError")} WebpackError */
+
+/**
+ * @typedef {Object} AssetDetails
+ * @property {string} name
+ * @property {number} size
+ */
+
+/**
+ * @typedef {Object} EntrypointDetails
+ * @property {string} name
+ * @property {number} size
+ * @property {string[]} files
+ */
+
+const isOverSizeLimitSet = new WeakSet();
+
+const excludeSourceMap = (name, source, info) => !info.development;
 
+module.exports = class SizeLimitsPlugin {
 	/**
-	 * @returns {string | null} absolute path which should be used for condition matching (usually the resource path)
+	 * @param {PerformanceOptions} options the plugin options
 	 */
-	nameForCondition() {
-		return this.rootModule.nameForCondition();
+	constructor(options) {
+		this.hints = options.hints;
+		this.maxAssetSize = options.maxAssetSize;
+		this.maxEntrypointSize = options.maxEntrypointSize;
+		this.assetFilter = options.assetFilter;
 	}
 
 	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
+	 * @param {ChunkGroup | Source} thing the resource to test
+	 * @returns {boolean} true if over the limit
 	 */
-	getSideEffectsConnectionState(moduleGraph) {
-		return this.rootModule.getSideEffectsConnectionState(moduleGraph);
+	static isOverSizeLimit(thing) {
+		return isOverSizeLimitSet.has(thing);
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		const { rootModule } = this;
-		this.buildInfo = {
-			strict: true,
-			cacheable: true,
-			moduleArgument: rootModule.buildInfo.moduleArgument,
-			exportsArgument: rootModule.buildInfo.exportsArgument,
-			fileDependencies: new LazySet(),
-			contextDependencies: new LazySet(),
-			missingDependencies: new LazySet(),
-			topLevelDeclarations: new Set(),
-			assets: undefined
-		};
-		this.buildMeta = rootModule.buildMeta;
-		this.clearDependenciesAndBlocks();
-		this.clearWarningsAndErrors();
+	apply(compiler) {
+		const entrypointSizeLimit = this.maxEntrypointSize;
+		const assetSizeLimit = this.maxAssetSize;
+		const hints = this.hints;
+		const assetFilter = this.assetFilter || excludeSourceMap;
 
-		for (const m of this._modules) {
-			// populate cacheable
-			if (!m.buildInfo.cacheable) {
-				this.buildInfo.cacheable = false;
-			}
+		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
+			/** @type {WebpackError[]} */
+			const warnings = [];
 
-			// populate dependencies
-			for (const d of m.dependencies.filter(
-				dep =>
-					!(dep instanceof HarmonyImportDependency) ||
-					!this._modules.has(compilation.moduleGraph.getModule(dep))
-			)) {
-				this.dependencies.push(d);
-			}
-			// populate blocks
-			for (const d of m.blocks) {
-				this.blocks.push(d);
-			}
+			/**
+			 * @param {Entrypoint} entrypoint an entrypoint
+			 * @returns {number} the size of the entrypoint
+			 */
+			const getEntrypointSize = entrypoint => {
+				let size = 0;
+				for (const file of entrypoint.getFiles()) {
+					const asset = compilation.getAsset(file);
+					if (
+						asset &&
+						assetFilter(asset.name, asset.source, asset.info) &&
+						asset.source
+					) {
+						size += asset.info.size || asset.source.size();
+					}
+				}
+				return size;
+			};
 
-			// populate warnings
-			const warnings = m.getWarnings();
-			if (warnings !== undefined) {
-				for (const warning of warnings) {
-					this.addWarning(warning);
+			/** @type {AssetDetails[]} */
+			const assetsOverSizeLimit = [];
+			for (const { name, source, info } of compilation.getAssets()) {
+				if (!assetFilter(name, source, info) || !source) {
+					continue;
 				}
-			}
 
-			// populate errors
-			const errors = m.getErrors();
-			if (errors !== undefined) {
-				for (const error of errors) {
-					this.addError(error);
+				const size = info.size || source.size();
+				if (size > assetSizeLimit) {
+					assetsOverSizeLimit.push({
+						name,
+						size
+					});
+					isOverSizeLimitSet.add(source);
 				}
 			}
 
-			// populate topLevelDeclarations
-			if (m.buildInfo.topLevelDeclarations) {
-				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
-				if (topLevelDeclarations !== undefined) {
-					for (const decl of m.buildInfo.topLevelDeclarations) {
-						// reserved names will always be renamed
-						if (RESERVED_NAMES.has(decl)) continue;
-						// TODO actually this is incorrect since with renaming there could be more
-						// We should do the renaming during build
-						topLevelDeclarations.add(decl);
-					}
+			const fileFilter = name => {
+				const asset = compilation.getAsset(name);
+				return asset && assetFilter(asset.name, asset.source, asset.info);
+			};
+
+			/** @type {EntrypointDetails[]} */
+			const entrypointsOverLimit = [];
+			for (const [name, entry] of compilation.entrypoints) {
+				const size = getEntrypointSize(entry);
+
+				if (size > entrypointSizeLimit) {
+					entrypointsOverLimit.push({
+						name: name,
+						size: size,
+						files: entry.getFiles().filter(fileFilter)
+					});
+					isOverSizeLimitSet.add(entry);
 				}
-			} else {
-				this.buildInfo.topLevelDeclarations = undefined;
 			}
 
-			// populate assets
-			if (m.buildInfo.assets) {
-				if (this.buildInfo.assets === undefined) {
-					this.buildInfo.assets = Object.create(null);
+			if (hints) {
+				// 1. Individual Chunk: Size < 250kb
+				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
+				// 3. No Async Chunks
+				// if !1, then 2, if !2 return
+				if (assetsOverSizeLimit.length > 0) {
+					warnings.push(
+						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
+					);
 				}
-				Object.assign(this.buildInfo.assets, m.buildInfo.assets);
-			}
-			if (m.buildInfo.assetsInfo) {
-				if (this.buildInfo.assetsInfo === undefined) {
-					this.buildInfo.assetsInfo = new Map();
+				if (entrypointsOverLimit.length > 0) {
+					warnings.push(
+						new EntrypointsOverSizeLimitWarning(
+							entrypointsOverLimit,
+							entrypointSizeLimit
+						)
+					);
 				}
-				for (const [key, value] of m.buildInfo.assetsInfo) {
-					this.buildInfo.assetsInfo.set(key, value);
+
+				if (warnings.length > 0) {
+					const someAsyncChunk = find(
+						compilation.chunks,
+						chunk => !chunk.canBeInitial()
+					);
+
+					if (!someAsyncChunk) {
+						warnings.push(new NoAsyncChunksWarning());
+					}
+
+					if (hints === "error") {
+						compilation.errors.push(...warnings);
+					} else {
+						compilation.warnings.push(...warnings);
+					}
 				}
 			}
-		}
-		callback();
+		});
 	}
+};
+
+
+/***/ }),
+
+/***/ 95175:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
 
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
+	 * @param {string} childType TODO
+	 * @param {string} runtimeFunction TODO
+	 * @param {string} runtimeHandlers TODO
 	 */
-	size(type) {
-		// Guess size from embedded modules
-		let size = 0;
-		for (const module of this._modules) {
-			size += module.size(type);
-		}
-		return size;
+	constructor(childType, runtimeFunction, runtimeHandlers) {
+		super(`chunk ${childType} function`);
+		this.childType = childType;
+		this.runtimeFunction = runtimeFunction;
+		this.runtimeHandlers = runtimeHandlers;
 	}
 
 	/**
-	 * @private
-	 * @param {Module} rootModule the root of the concatenation
-	 * @param {Set<Module>} modulesSet a set of modules which should be concatenated
-	 * @param {RuntimeSpec} runtime for this runtime
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {ConcatenationEntry[]} concatenation list
+	 * @returns {string} runtime code
 	 */
-	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
-		/** @type {ConcatenationEntry[]} */
-		const list = [];
-		/** @type {Map<Module, RuntimeSpec | true>} */
-		const existingEntries = new Map();
+	generate() {
+		const { runtimeFunction, runtimeHandlers } = this;
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${runtimeHandlers} = {};`,
+			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
+				// map is shorter than forEach
+				`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
+					"key",
+					`${runtimeHandlers}[key](chunkId);`
+				)});`
+			])}`
+		]);
+	}
+}
 
-		/**
-		 * @param {Module} module a module
-		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
-		 */
-		const getConcatenatedImports = module => {
-			let connections = Array.from(moduleGraph.getOutgoingConnections(module));
-			if (module === rootModule) {
-				for (const c of moduleGraph.getOutgoingConnections(this))
-					connections.push(c);
-			}
-			const references = connections
-				.filter(connection => {
-					if (!(connection.dependency instanceof HarmonyImportDependency))
-						return false;
-					return (
-						connection &&
-						connection.resolvedOriginModule === module &&
-						connection.module &&
-						connection.isTargetActive(runtime)
-					);
-				})
-				.map(connection => ({
-					connection,
-					sourceOrder: /** @type {HarmonyImportDependency} */ (
-						connection.dependency
-					).sourceOrder
-				}));
-			references.sort(
-				concatComparators(bySourceOrder, keepOriginalOrder(references))
-			);
-			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
-			const referencesMap = new Map();
-			for (const { connection } of references) {
-				const runtimeCondition = filterRuntime(runtime, r =>
-					connection.isTargetActive(r)
-				);
-				if (runtimeCondition === false) continue;
-				const module = connection.module;
-				const entry = referencesMap.get(module);
-				if (entry === undefined) {
-					referencesMap.set(module, { connection, runtimeCondition });
-					continue;
-				}
-				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
-					entry.runtimeCondition,
-					runtimeCondition,
-					runtime
-				);
-			}
-			return referencesMap.values();
-		};
+module.exports = ChunkPrefetchFunctionRuntimeModule;
 
-		/**
-		 * @param {ModuleGraphConnection} connection graph connection
-		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
-		 * @returns {void}
-		 */
-		const enterModule = (connection, runtimeCondition) => {
-			const module = connection.module;
-			if (!module) return;
-			const existingEntry = existingEntries.get(module);
-			if (existingEntry === true) {
-				return;
-			}
-			if (modulesSet.has(module)) {
-				existingEntries.set(module, true);
-				if (runtimeCondition !== true) {
-					throw new Error(
-						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
-							runtimeCondition
-						)}). This should not happen.`
-					);
-				}
-				const imports = getConcatenatedImports(module);
-				for (const { connection, runtimeCondition } of imports)
-					enterModule(connection, runtimeCondition);
-				list.push({
-					type: "concatenated",
-					module: connection.module,
-					runtimeCondition
-				});
-			} else {
-				if (existingEntry !== undefined) {
-					const reducedRuntimeCondition = subtractRuntimeCondition(
-						runtimeCondition,
-						existingEntry,
-						runtime
-					);
-					if (reducedRuntimeCondition === false) return;
-					runtimeCondition = reducedRuntimeCondition;
-					existingEntries.set(
-						connection.module,
-						mergeRuntimeConditionNonFalse(
-							existingEntry,
-							runtimeCondition,
-							runtime
-						)
-					);
-				} else {
-					existingEntries.set(connection.module, runtimeCondition);
-				}
-				if (list.length > 0) {
-					const lastItem = list[list.length - 1];
-					if (
-						lastItem.type === "external" &&
-						lastItem.module === connection.module
-					) {
-						lastItem.runtimeCondition = mergeRuntimeCondition(
-							lastItem.runtimeCondition,
-							runtimeCondition,
-							runtime
+
+/***/ }),
+
+/***/ 33895:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const ChunkPrefetchFunctionRuntimeModule = __webpack_require__(95175);
+const ChunkPrefetchStartupRuntimeModule = __webpack_require__(15294);
+const ChunkPrefetchTriggerRuntimeModule = __webpack_require__(98441);
+const ChunkPreloadTriggerRuntimeModule = __webpack_require__(56236);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ChunkPrefetchPreloadPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"ChunkPrefetchPreloadPlugin",
+			compilation => {
+				compilation.hooks.additionalChunkRuntimeRequirements.tap(
+					"ChunkPrefetchPreloadPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
+						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
+							chunkGraph,
+							"prefetchOrder"
 						);
-						return;
+						if (startupChildChunks) {
+							set.add(RuntimeGlobals.prefetchChunk);
+							set.add(RuntimeGlobals.onChunksLoaded);
+							compilation.addRuntimeModule(
+								chunk,
+								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
+							);
+						}
 					}
-				}
-				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 connection.module;
-					},
-					runtimeCondition
-				});
+				);
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"ChunkPrefetchPreloadPlugin",
+					(chunk, set, { chunkGraph }) => {
+						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph, false);
+
+						if (chunkMap.prefetch) {
+							set.add(RuntimeGlobals.prefetchChunk);
+							compilation.addRuntimeModule(
+								chunk,
+								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
+							);
+						}
+						if (chunkMap.preload) {
+							set.add(RuntimeGlobals.preloadChunk);
+							compilation.addRuntimeModule(
+								chunk,
+								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
+							);
+						}
+					}
+				);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.prefetchChunk)
+					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchFunctionRuntimeModule(
+								"prefetch",
+								RuntimeGlobals.prefetchChunk,
+								RuntimeGlobals.prefetchChunkHandlers
+							)
+						);
+						set.add(RuntimeGlobals.prefetchChunkHandlers);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.preloadChunk)
+					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchFunctionRuntimeModule(
+								"preload",
+								RuntimeGlobals.preloadChunk,
+								RuntimeGlobals.preloadChunkHandlers
+							)
+						);
+						set.add(RuntimeGlobals.preloadChunkHandlers);
+					});
 			}
-		};
+		);
+	}
+}
 
-		existingEntries.set(rootModule, true);
-		const imports = getConcatenatedImports(rootModule);
-		for (const { connection, runtimeCondition } of imports)
-			enterModule(connection, runtimeCondition);
-		list.push({
-			type: "concatenated",
-			module: rootModule,
-			runtimeCondition: true
-		});
+module.exports = ChunkPrefetchPreloadPlugin;
 
-		return list;
+
+/***/ }),
+
+/***/ 15294:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} startupChunks chunk ids to trigger when chunks are loaded
+	 */
+	constructor(startupChunks) {
+		super("startup prefetch", RuntimeModule.STAGE_TRIGGER);
+		this.startupChunks = startupChunks;
 	}
 
 	/**
-	 * @param {Module} rootModule the root module of the concatenation
-	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
-	 * @param {Object=} associatedObjectForCache object for caching
-	 * @param {string | HashConstructor=} hashFunction hash function to use
-	 * @returns {string} the identifier
+	 * @returns {string} runtime code
 	 */
-	static _createIdentifier(
-		rootModule,
-		modules,
-		associatedObjectForCache,
-		hashFunction = "md4"
-	) {
-		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			rootModule.context,
-			associatedObjectForCache
+	generate() {
+		const { startupChunks, chunk } = this;
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString(
+			startupChunks.map(
+				({ onChunks, chunks }) =>
+					`${RuntimeGlobals.onChunksLoaded}(0, ${JSON.stringify(
+						// This need to include itself to delay execution after this chunk has been fully loaded
+						onChunks.filter(c => c === chunk).map(c => c.id)
+					)}, ${runtimeTemplate.basicFunction(
+						"",
+						chunks.size < 3
+							? Array.from(
+									chunks,
+									c =>
+										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
+							  )
+							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
+									RuntimeGlobals.prefetchChunk
+							  });`
+					)}, 5);`
+			)
 		);
-		let identifiers = [];
-		for (const module of modules) {
-			identifiers.push(cachedMakePathsRelative(module.identifier()));
-		}
-		identifiers.sort();
-		const hash = createHash(hashFunction);
-		hash.update(identifiers.join(" "));
-		return rootModule.identifier() + "|" + hash.digest("hex");
 	}
+}
+
+module.exports = ChunkPrefetchStartupRuntimeModule;
+
+
+/***/ }),
+
+/***/ 98441:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
 
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {LazySet<string>} fileDependencies set where file dependencies are added to
-	 * @param {LazySet<string>} contextDependencies set where context dependencies are added to
-	 * @param {LazySet<string>} missingDependencies set where missing dependencies are added to
-	 * @param {LazySet<string>} buildDependencies set where build dependencies are added to
+	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
 	 */
-	addCacheDependencies(
-		fileDependencies,
-		contextDependencies,
-		missingDependencies,
-		buildDependencies
-	) {
-		for (const module of this._modules) {
-			module.addCacheDependencies(
-				fileDependencies,
-				contextDependencies,
-				missingDependencies,
-				buildDependencies
-			);
-		}
+	constructor(chunkMap) {
+		super(`chunk prefetch trigger`, RuntimeModule.STAGE_TRIGGER);
+		this.chunkMap = chunkMap;
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @returns {string} runtime code
 	 */
-	codeGeneration({
-		dependencyTemplates,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime: generationRuntime,
-		codeGenerationResults
-	}) {
-		/** @type {Set<string>} */
-		const runtimeRequirements = new Set();
-		const runtime = intersectRuntime(generationRuntime, this._runtime);
+	generate() {
+		const { chunkMap } = this;
+		const { runtimeTemplate } = this.compilation;
+		const body = [
+			"var chunks = chunkToChildrenMap[chunkId];",
+			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`
+		];
+		return Template.asString([
+			Template.asString([
+				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
+				`${
+					RuntimeGlobals.ensureChunkHandlers
+				}.prefetch = ${runtimeTemplate.expressionFunction(
+					`Promise.all(promises).then(${runtimeTemplate.basicFunction(
+						"",
+						body
+					)})`,
+					"chunkId, promises"
+				)};`
+			])
+		]);
+	}
+}
 
-		const requestShortener = runtimeTemplate.requestShortener;
-		// Meta info for each module
-		const [modulesWithInfo, moduleToInfoMap] = this._getModulesWithInfo(
-			moduleGraph,
-			runtime
-		);
+module.exports = ChunkPrefetchTriggerRuntimeModule;
 
-		// Set with modules that need a generated namespace object
-		/** @type {Set<ConcatenatedModuleInfo>} */
-		const neededNamespaceObjects = new Set();
 
-		// Generate source code and analyse scopes
-		// Prepare a ReplaceSource for the final source
-		for (const info of moduleToInfoMap.values()) {
-			this._analyseModule(
-				moduleToInfoMap,
-				info,
-				dependencyTemplates,
-				runtimeTemplate,
-				moduleGraph,
-				chunkGraph,
-				runtime,
-				codeGenerationResults
-			);
-		}
+/***/ }),
 
-		// List of all used names to avoid conflicts
-		const allUsedNames = new Set(RESERVED_NAMES);
+/***/ 56236:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// List of additional names in scope for module references
-		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
-		const usedNamesInScopeInfo = new Map();
-		/**
-		 * @param {string} module module identifier
-		 * @param {string} id export id
-		 * @returns {{ usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }} info
-		 */
-		const getUsedNamesInScopeInfo = (module, id) => {
-			const key = `${module}-${id}`;
-			let info = usedNamesInScopeInfo.get(key);
-			if (info === undefined) {
-				info = {
-					usedNames: new Set(),
-					alreadyCheckedScopes: new Set()
-				};
-				usedNamesInScopeInfo.set(key, info);
-			}
-			return info;
-		};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-		// Set of already checked scopes
-		const ignoredScopes = new Set();
 
-		// get all global names
-		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
-				// ignore symbols from moduleScope
-				if (info.moduleScope) {
-					ignoredScopes.add(info.moduleScope);
-				}
 
-				// The super class expression in class scopes behaves weird
-				// We get ranges of all super class expressions to make
-				// renaming to work correctly
-				const superClassCache = new WeakMap();
-				const getSuperClassExpressions = scope => {
-					const cacheEntry = superClassCache.get(scope);
-					if (cacheEntry !== undefined) return cacheEntry;
-					const superClassExpressions = [];
-					for (const childScope of scope.childScopes) {
-						if (childScope.type !== "class") continue;
-						const block = childScope.block;
-						if (
-							(block.type === "ClassDeclaration" ||
-								block.type === "ClassExpression") &&
-							block.superClass
-						) {
-							superClassExpressions.push({
-								range: block.superClass.range,
-								variables: childScope.variables
-							});
-						}
-					}
-					superClassCache.set(scope, superClassExpressions);
-					return superClassExpressions;
-				};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-				// add global symbols
-				if (info.globalScope) {
-					for (const reference of info.globalScope.through) {
-						const name = reference.identifier.name;
-						if (ConcatenationScope.isModuleReference(name)) {
-							const match = ConcatenationScope.matchModuleReference(name);
-							if (!match) continue;
-							const referencedInfo = modulesWithInfo[match.index];
-							if (referencedInfo.type === "reference")
-								throw new Error("Module reference can't point to a reference");
-							const binding = getFinalBinding(
-								moduleGraph,
-								referencedInfo,
-								match.ids,
-								moduleToInfoMap,
-								runtime,
-								requestShortener,
-								runtimeTemplate,
-								neededNamespaceObjects,
-								false,
-								info.module.buildMeta.strictHarmonyModule,
-								true
-							);
-							if (!binding.ids) continue;
-							const { usedNames, alreadyCheckedScopes } =
-								getUsedNamesInScopeInfo(
-									binding.info.module.identifier(),
-									"name" in binding ? binding.name : ""
-								);
-							for (const expr of getSuperClassExpressions(reference.from)) {
-								if (
-									expr.range[0] <= reference.identifier.range[0] &&
-									expr.range[1] >= reference.identifier.range[1]
-								) {
-									for (const variable of expr.variables) {
-										usedNames.add(variable.name);
-									}
-								}
-							}
-							addScopeSymbols(
-								reference.from,
-								usedNames,
-								alreadyCheckedScopes,
-								ignoredScopes
-							);
-						} else {
-							allUsedNames.add(name);
-						}
-					}
-				}
-			}
-		}
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
-		// generate names for symbols
-		for (const info of moduleToInfoMap.values()) {
-			const { usedNames: namespaceObjectUsedNames } = getUsedNamesInScopeInfo(
-				info.module.identifier(),
-				""
-			);
-			switch (info.type) {
-				case "concatenated": {
-					for (const variable of info.moduleScope.variables) {
-						const name = variable.name;
-						const { usedNames, alreadyCheckedScopes } = getUsedNamesInScopeInfo(
-							info.module.identifier(),
-							name
-						);
-						if (allUsedNames.has(name) || usedNames.has(name)) {
-							const references = getAllReferences(variable);
-							for (const ref of references) {
-								addScopeSymbols(
-									ref.from,
-									usedNames,
-									alreadyCheckedScopes,
-									ignoredScopes
-								);
-							}
-							const newName = this.findNewName(
-								name,
-								allUsedNames,
-								usedNames,
-								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) {
-									const maybeProperty =
-										path[1].type === "AssignmentPattern" &&
-										path[1].left === path[0]
-											? path[2]
-											: path[1];
-									if (
-										maybeProperty.type === "Property" &&
-										maybeProperty.shorthand
-									) {
-										source.insert(r[1], `: ${newName}`);
-										continue;
-									}
-								}
-								source.replace(r[0], r[1] - 1, newName);
-							}
-						} else {
-							allUsedNames.add(name);
-							info.internalNames.set(name, name);
-						}
-					}
-					let namespaceObjectName;
-					if (info.namespaceExportSymbol) {
-						namespaceObjectName = info.internalNames.get(
-							info.namespaceExportSymbol
-						);
-					} else {
-						namespaceObjectName = this.findNewName(
-							"namespaceObject",
-							allUsedNames,
-							namespaceObjectUsedNames,
-							info.module.readableIdentifier(requestShortener)
-						);
-						allUsedNames.add(namespaceObjectName);
-					}
-					info.namespaceObjectName = namespaceObjectName;
-					break;
-				}
-				case "external": {
-					const externalName = this.findNewName(
-						"",
-						allUsedNames,
-						namespaceObjectUsedNames,
-						info.module.readableIdentifier(requestShortener)
-					);
-					allUsedNames.add(externalName);
-					info.name = externalName;
-					break;
-				}
-			}
-			if (info.module.buildMeta.exportsType !== "namespace") {
-				const externalNameInterop = this.findNewName(
-					"namespaceObject",
-					allUsedNames,
-					namespaceObjectUsedNames,
-					info.module.readableIdentifier(requestShortener)
-				);
-				allUsedNames.add(externalNameInterop);
-				info.interopNamespaceObjectName = externalNameInterop;
-			}
-			if (
-				info.module.buildMeta.exportsType === "default" &&
-				info.module.buildMeta.defaultObject !== "redirect"
-			) {
-				const externalNameInterop = this.findNewName(
-					"namespaceObject2",
-					allUsedNames,
-					namespaceObjectUsedNames,
-					info.module.readableIdentifier(requestShortener)
-				);
-				allUsedNames.add(externalNameInterop);
-				info.interopNamespaceObject2Name = externalNameInterop;
-			}
-			if (
-				info.module.buildMeta.exportsType === "dynamic" ||
-				!info.module.buildMeta.exportsType
-			) {
-				const externalNameInterop = this.findNewName(
-					"default",
-					allUsedNames,
-					namespaceObjectUsedNames,
-					info.module.readableIdentifier(requestShortener)
-				);
-				allUsedNames.add(externalNameInterop);
-				info.interopDefaultAccessName = externalNameInterop;
-			}
-		}
+class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
+	 */
+	constructor(chunkMap) {
+		super(`chunk preload trigger`, RuntimeModule.STAGE_TRIGGER);
+		this.chunkMap = chunkMap;
+	}
 
-		// Find and replace references to modules
-		for (const info of moduleToInfoMap.values()) {
-			if (info.type === "concatenated") {
-				for (const reference of info.globalScope.through) {
-					const name = reference.identifier.name;
-					const match = ConcatenationScope.matchModuleReference(name);
-					if (match) {
-						const referencedInfo = modulesWithInfo[match.index];
-						if (referencedInfo.type === "reference")
-							throw new Error("Module reference can't point to a reference");
-						const finalName = getFinalName(
-							moduleGraph,
-							referencedInfo,
-							match.ids,
-							moduleToInfoMap,
-							runtime,
-							requestShortener,
-							runtimeTemplate,
-							neededNamespaceObjects,
-							match.call,
-							!match.directImport,
-							info.module.buildMeta.strictHarmonyModule,
-							match.asiSafe
-						);
-						const r = reference.identifier.range;
-						const source = info.source;
-						// range is extended by 2 chars to cover the appended "._"
-						source.replace(r[0], r[1] + 1, finalName);
-					}
-				}
-			}
-		}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkMap } = this;
+		const { runtimeTemplate } = this.compilation;
+		const body = [
+			"var chunks = chunkToChildrenMap[chunkId];",
+			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`
+		];
+		return Template.asString([
+			Template.asString([
+				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
+				`${
+					RuntimeGlobals.ensureChunkHandlers
+				}.preload = ${runtimeTemplate.basicFunction("chunkId", body)};`
+			])
+		]);
+	}
+}
 
-		// Map with all root exposed used exports
-		/** @type {Map<string, function(RequestShortener): string>} */
-		const exportsMap = new Map();
+module.exports = ChunkPreloadTriggerRuntimeModule;
 
-		// Set with all root exposed unused exports
-		/** @type {Set<string>} */
-		const unusedExports = new Set();
 
-		const rootInfo = /** @type {ConcatenatedModuleInfo} */ (
-			moduleToInfoMap.get(this.rootModule)
-		);
-		const strictHarmonyModule = rootInfo.module.buildMeta.strictHarmonyModule;
-		const exportsInfo = moduleGraph.getExportsInfo(rootInfo.module);
-		for (const exportInfo of exportsInfo.orderedExports) {
-			const name = exportInfo.name;
-			if (exportInfo.provided === false) continue;
-			const used = exportInfo.getUsedName(undefined, runtime);
-			if (!used) {
-				unusedExports.add(name);
-				continue;
-			}
-			exportsMap.set(used, requestShortener => {
-				try {
-					const finalName = getFinalName(
-						moduleGraph,
-						rootInfo,
-						[name],
-						moduleToInfoMap,
-						runtime,
-						requestShortener,
-						runtimeTemplate,
-						neededNamespaceObjects,
-						false,
-						false,
-						strictHarmonyModule,
-						true
-					);
-					return `/* ${
-						exportInfo.isReexport() ? "reexport" : "binding"
-					} */ ${finalName}`;
-				} catch (e) {
-					e.message += `\nwhile generating the root export '${name}' (used name: '${used}')`;
-					throw e;
-				}
-			});
-		}
+/***/ }),
 
-		const result = new ConcatSource();
+/***/ 30318:
+/***/ (function(module) {
 
-		// add harmony compatibility flag (must be first because of possible circular dependencies)
-		if (
-			moduleGraph.getExportsInfo(this).otherExportsInfo.getUsed(runtime) !==
-			UsageState.Unused
-		) {
-			result.add(`// ESM COMPAT FLAG\n`);
-			result.add(
-				runtimeTemplate.defineEsModuleFlagStatement({
-					exportsArgument: this.exportsArgument,
-					runtimeRequirements
-				})
-			);
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		// define exports
-		if (exportsMap.size > 0) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
-			runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-			const definitions = [];
-			for (const [key, value] of exportsMap) {
-				definitions.push(
-					`\n  ${JSON.stringify(key)}: ${runtimeTemplate.returningFunction(
-						value(requestShortener)
-					)}`
-				);
-			}
-			result.add(`\n// EXPORTS\n`);
-			result.add(
-				`${RuntimeGlobals.definePropertyGetters}(${
-					this.exportsArgument
-				}, {${definitions.join(",")}\n});\n`
-			);
-		}
 
-		// list unused exports
-		if (unusedExports.size > 0) {
-			result.add(
-				`\n// UNUSED EXPORTS: ${joinIterableWithComma(unusedExports)}\n`
-			);
-		}
 
-		// generate namespace objects
-		const namespaceObjectSources = new Map();
-		for (const info of neededNamespaceObjects) {
-			if (info.namespaceExportSymbol) continue;
-			const nsObj = [];
-			const exportsInfo = moduleGraph.getExportsInfo(info.module);
-			for (const exportInfo of exportsInfo.orderedExports) {
-				if (exportInfo.provided === false) continue;
-				const usedName = exportInfo.getUsedName(undefined, runtime);
-				if (usedName) {
-					const finalName = getFinalName(
-						moduleGraph,
-						info,
-						[exportInfo.name],
-						moduleToInfoMap,
-						runtime,
-						requestShortener,
-						runtimeTemplate,
-						neededNamespaceObjects,
-						false,
-						undefined,
-						info.module.buildMeta.strictHarmonyModule,
-						true
-					);
-					nsObj.push(
-						`\n  ${JSON.stringify(
-							usedName
-						)}: ${runtimeTemplate.returningFunction(finalName)}`
-					);
-				}
-			}
-			const name = info.namespaceObjectName;
-			const defineGetters =
-				nsObj.length > 0
-					? `${RuntimeGlobals.definePropertyGetters}(${name}, {${nsObj.join(
-							","
-					  )}\n});\n`
-					: "";
-			if (nsObj.length > 0)
-				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
-			namespaceObjectSources.set(
-				info,
-				`
-// NAMESPACE OBJECT: ${info.module.readableIdentifier(requestShortener)}
-var ${name} = {};
-${RuntimeGlobals.makeNamespaceObject}(${name});
-${defineGetters}`
-			);
-			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
-		}
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 
-		// define required namespace objects (must be before evaluation modules)
-		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
-				const source = namespaceObjectSources.get(info);
-				if (!source) continue;
-				result.add(source);
-			}
-		}
+class BasicEffectRulePlugin {
+	constructor(ruleProperty, effectType) {
+		this.ruleProperty = ruleProperty;
+		this.effectType = effectType || ruleProperty;
+	}
 
-		const chunkInitFragments = [];
+	/**
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"BasicEffectRulePlugin",
+			(path, rule, unhandledProperties, result, references) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
 
-		// evaluate modules in order
-		for (const rawInfo of modulesWithInfo) {
-			let name;
-			let isConditional = false;
-			const info = rawInfo.type === "reference" ? rawInfo.target : rawInfo;
-			switch (info.type) {
-				case "concatenated": {
-					result.add(
-						`\n;// CONCATENATED MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					result.add(info.source);
-					if (info.chunkInitFragments) {
-						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
-					}
-					if (info.runtimeRequirements) {
-						for (const r of info.runtimeRequirements) {
-							runtimeRequirements.add(r);
-						}
-					}
-					name = info.namespaceObjectName;
-					break;
-				}
-				case "external": {
-					result.add(
-						`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
-							requestShortener
-						)}\n`
-					);
-					runtimeRequirements.add(RuntimeGlobals.require);
-					const { runtimeCondition } =
-						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */ (rawInfo);
-					const condition = runtimeTemplate.runtimeConditionExpression({
-						chunkGraph,
-						runtimeCondition,
-						runtime,
-						runtimeRequirements
+					const value = rule[this.ruleProperty];
+
+					result.effects.push({
+						type: this.effectType,
+						value
 					});
-					if (condition !== "true") {
-						isConditional = true;
-						result.add(`if (${condition}) {\n`);
-					}
-					result.add(
-						`var ${info.name} = __webpack_require__(${JSON.stringify(
-							chunkGraph.getModuleId(info.module)
-						)});`
-					);
-					name = info.name;
-					break;
 				}
-				default:
-					// @ts-expect-error never is expected here
-					throw new Error(`Unsupported concatenation entry type ${info.type}`);
-			}
-			if (info.interopNamespaceObjectUsed) {
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				result.add(
-					`\nvar ${info.interopNamespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name}, 2);`
-				);
-			}
-			if (info.interopNamespaceObject2Used) {
-				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
-				result.add(
-					`\nvar ${info.interopNamespaceObject2Name} = /*#__PURE__*/${RuntimeGlobals.createFakeNamespaceObject}(${name});`
-				);
-			}
-			if (info.interopDefaultAccessUsed) {
-				runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
-				result.add(
-					`\nvar ${info.interopDefaultAccessName} = /*#__PURE__*/${RuntimeGlobals.compatGetDefaultExport}(${name});`
-				);
-			}
-			if (isConditional) {
-				result.add("\n}");
 			}
-		}
+		);
+	}
+}
 
-		const data = new Map();
-		if (chunkInitFragments.length > 0)
-			data.set("chunkInitFragments", chunkInitFragments);
+module.exports = BasicEffectRulePlugin;
 
-		/** @type {CodeGenerationResult} */
-		const resultEntry = {
-			sources: new Map([["javascript", new CachedSource(result)]]),
-			data,
-			runtimeRequirements
-		};
 
-		return resultEntry;
+/***/ }),
+
+/***/ 94215:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
+
+class BasicMatcherRulePlugin {
+	constructor(ruleProperty, dataProperty, invert) {
+		this.ruleProperty = ruleProperty;
+		this.dataProperty = dataProperty || ruleProperty;
+		this.invert = invert || false;
 	}
 
 	/**
-	 * @param {Map<Module, ModuleInfo>} modulesMap modulesMap
-	 * @param {ModuleInfo} info info
-	 * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
-	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
-	 * @param {ModuleGraph} moduleGraph moduleGraph
-	 * @param {ChunkGraph} chunkGraph chunkGraph
-	 * @param {RuntimeSpec} runtime runtime
-	 * @param {CodeGenerationResults} codeGenerationResults codeGenerationResults
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
 	 */
-	_analyseModule(
-		modulesMap,
-		info,
-		dependencyTemplates,
-		runtimeTemplate,
-		moduleGraph,
-		chunkGraph,
-		runtime,
-		codeGenerationResults
-	) {
-		if (info.type === "concatenated") {
-			const m = info.module;
-			try {
-				// Create a concatenation scope to track and capture information
-				const concatenationScope = new ConcatenationScope(modulesMap, info);
-
-				// TODO cache codeGeneration results
-				const codeGenResult = m.codeGeneration({
-					dependencyTemplates,
-					runtimeTemplate,
-					moduleGraph,
-					chunkGraph,
-					runtime,
-					concatenationScope,
-					codeGenerationResults
-				});
-				const source = codeGenResult.sources.get("javascript");
-				const data = codeGenResult.data;
-				const chunkInitFragments = data && data.get("chunkInitFragments");
-				const code = source.source().toString();
-				let ast;
-				try {
-					ast = JavascriptParser._parse(code, {
-						sourceType: "module"
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"BasicMatcherRulePlugin",
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+					const value = rule[this.ruleProperty];
+					const condition = ruleSetCompiler.compileCondition(
+						`${path}.${this.ruleProperty}`,
+						value
+					);
+					const fn = condition.fn;
+					result.conditions.push({
+						property: this.dataProperty,
+						matchWhenEmpty: this.invert
+							? !condition.matchWhenEmpty
+							: condition.matchWhenEmpty,
+						fn: this.invert ? v => !fn(v) : fn
 					});
-				} 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.runtimeRequirements = codeGenResult.runtimeRequirements;
-				info.ast = ast;
-				info.internalSource = source;
-				info.source = resultSource;
-				info.chunkInitFragments = chunkInitFragments;
-				info.globalScope = globalScope;
-				info.moduleScope = moduleScope;
-			} catch (err) {
-				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
-				throw err;
 			}
-		}
+		);
 	}
+}
 
-	/**
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {[ModuleInfoOrReference[], Map<Module, ModuleInfo>]} module info items
-	 */
-	_getModulesWithInfo(moduleGraph, runtime) {
-		const orderedConcatenationList = this._createConcatenationList(
-			this.rootModule,
-			this._modules,
-			runtime,
-			moduleGraph
-		);
-		/** @type {Map<Module, ModuleInfo>} */
-		const map = new Map();
-		const list = orderedConcatenationList.map((info, index) => {
-			let item = map.get(info.module);
-			if (item === undefined) {
-				switch (info.type) {
-					case "concatenated":
-						item = {
-							type: "concatenated",
-							module: info.module,
-							index,
-							ast: undefined,
-							internalSource: undefined,
-							runtimeRequirements: undefined,
-							source: undefined,
-							globalScope: undefined,
-							moduleScope: undefined,
-							internalNames: new Map(),
-							exportMap: undefined,
-							rawExportMap: undefined,
-							namespaceExportSymbol: undefined,
-							namespaceObjectName: undefined,
-							interopNamespaceObjectUsed: false,
-							interopNamespaceObjectName: undefined,
-							interopNamespaceObject2Used: false,
-							interopNamespaceObject2Name: undefined,
-							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
-						};
-						break;
-					case "external":
-						item = {
-							type: "external",
-							module: info.module,
-							runtimeCondition: info.runtimeCondition,
-							index,
-							name: undefined,
-							interopNamespaceObjectUsed: false,
-							interopNamespaceObjectName: undefined,
-							interopNamespaceObject2Used: false,
-							interopNamespaceObject2Name: undefined,
-							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
-						};
-						break;
-					default:
-						throw new Error(
-							`Unsupported concatenation entry type ${info.type}`
-						);
-				}
-				map.set(item.module, item);
-				return item;
-			} else {
-				/** @type {ReferenceToModuleInfo} */
-				const ref = {
-					type: "reference",
-					runtimeCondition: info.runtimeCondition,
-					target: item
-				};
-				return ref;
-			}
-		});
-		return [list, map];
-	}
-
-	findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
-		let name = oldName;
-
-		if (name === ConcatenationScope.DEFAULT_EXPORT) {
-			name = "";
-		}
-		if (name === ConcatenationScope.NAMESPACE_OBJECT_EXPORT) {
-			name = "namespaceObject";
-		}
-
-		// 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
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		for (const info of this._createConcatenationList(
-			this.rootModule,
-			this._modules,
-			intersectRuntime(runtime, this._runtime),
-			chunkGraph.moduleGraph
-		)) {
-			switch (info.type) {
-				case "concatenated":
-					info.module.updateHash(hash, context);
-					break;
-				case "external":
-					hash.update(`${chunkGraph.getModuleId(info.module)}`);
-					// TODO runtimeCondition
-					break;
-			}
-		}
-		super.updateHash(hash, context);
-	}
-
-	static deserialize(context) {
-		const obj = new ConcatenatedModule({
-			identifier: undefined,
-			rootModule: undefined,
-			modules: undefined,
-			runtime: undefined
-		});
-		obj.deserialize(context);
-		return obj;
-	}
-}
-
-makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
-
-module.exports = ConcatenatedModule;
+module.exports = BasicMatcherRulePlugin;
 
 
 /***/ }),
 
-/***/ 96260:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 72021:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -108952,569 +107760,438 @@ module.exports = ConcatenatedModule;
 
 
 
-const { STAGE_BASIC } = __webpack_require__(80057);
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
+class ObjectMatcherRulePlugin {
+	constructor(ruleProperty, dataProperty) {
+		this.ruleProperty = ruleProperty;
+		this.dataProperty = dataProperty || ruleProperty;
+	}
 
-class EnsureChunkConditionsPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"EnsureChunkConditionsPlugin",
-			compilation => {
-				const handler = chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					// These sets are hoisted here to save memory
-					// They are cleared at the end of every loop
-					/** @type {Set<Chunk>} */
-					const sourceChunks = new Set();
-					/** @type {Set<ChunkGroup>} */
-					const chunkGroups = new Set();
-					for (const module of compilation.modules) {
-						if (!module.hasChunkCondition()) continue;
-						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-							if (!module.chunkCondition(chunk, compilation)) {
-								sourceChunks.add(chunk);
-								for (const group of chunk.groupsIterable) {
-									chunkGroups.add(group);
-								}
-							}
-						}
-						if (sourceChunks.size === 0) continue;
-						/** @type {Set<Chunk>} */
-						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, compilation)) {
-									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) {
-							chunkGraph.disconnectChunkAndModule(sourceChunk, module);
-						}
-						for (const targetChunk of targetChunks) {
-							chunkGraph.connectChunkAndModule(targetChunk, module);
-						}
-						sourceChunks.clear();
-						chunkGroups.clear();
+	apply(ruleSetCompiler) {
+		const { ruleProperty, dataProperty } = this;
+		ruleSetCompiler.hooks.rule.tap(
+			"ObjectMatcherRulePlugin",
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(ruleProperty)) {
+					unhandledProperties.delete(ruleProperty);
+					const value = rule[ruleProperty];
+					for (const property of Object.keys(value)) {
+						const nestedDataProperties = property.split(".");
+						const condition = ruleSetCompiler.compileCondition(
+							`${path}.${ruleProperty}.${property}`,
+							value[property]
+						);
+						result.conditions.push({
+							property: [dataProperty, ...nestedDataProperties],
+							matchWhenEmpty: condition.matchWhenEmpty,
+							fn: condition.fn
+						});
 					}
-				};
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "EnsureChunkConditionsPlugin",
-						stage: STAGE_BASIC
-					},
-					handler
-				);
+				}
 			}
 		);
 	}
 }
-module.exports = EnsureChunkConditionsPlugin;
 
-
-/***/ }),
-
-/***/ 50089:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-
-class FlagIncludedChunksPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("FlagIncludedChunksPlugin", compilation => {
-			compilation.hooks.optimizeChunkIds.tap(
-				"FlagIncludedChunksPlugin",
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-
-					// 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)
-					/** @type {WeakMap<Module, number>} */
-					const moduleBits = new WeakMap();
-					const modulesCount = compilation.modules.size;
-
-					// 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++;
-					}
-
-					// iterate all chunks to generate bitmaps
-					/** @type {WeakMap<Chunk, number>} */
-					const chunkModulesHash = new WeakMap();
-					for (const chunk of chunks) {
-						let hash = 0;
-						for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-							hash |= moduleBits.get(module);
-						}
-						chunkModulesHash.set(chunk, hash);
-					}
-
-					for (const chunkA of chunks) {
-						const chunkAHash = chunkModulesHash.get(chunkA);
-						const chunkAModulesCount =
-							chunkGraph.getNumberOfChunkModules(chunkA);
-						if (chunkAModulesCount === 0) continue;
-						let bestModule = undefined;
-						for (const module of chunkGraph.getChunkModulesIterable(chunkA)) {
-							if (
-								bestModule === undefined ||
-								chunkGraph.getNumberOfModuleChunks(bestModule) >
-									chunkGraph.getNumberOfModuleChunks(module)
-							)
-								bestModule = module;
-						}
-						loopB: for (const chunkB of chunkGraph.getModuleChunksIterable(
-							bestModule
-						)) {
-							// as we iterate the same iterables twice
-							// skip if we find ourselves
-							if (chunkA === chunkB) continue;
-
-							const chunkBModulesCount =
-								chunkGraph.getNumberOfChunkModules(chunkB);
-
-							// 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 chunkGraph.getChunkModulesIterable(chunkA)) {
-								if (!chunkGraph.isModuleInChunk(m, chunkB)) continue loopB;
-							}
-							chunkB.ids.push(chunkA.id);
-						}
-					}
-				}
-			);
-		});
-	}
-}
-module.exports = FlagIncludedChunksPlugin;
+module.exports = ObjectMatcherRulePlugin;
 
 
 /***/ }),
 
-/***/ 38988:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 83349:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { UsageState } = __webpack_require__(63686);
-
-/** @typedef {import("estree").Node} AnyNode */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
-/** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
-
-/**
- * @typedef {Object} StateObject
- * @property {InnerGraph} innerGraph
- * @property {TopLevelSymbol=} currentTopLevelSymbol
- * @property {Map<TopLevelSymbol, Set<UsageCallback>>} usageCallbackMap
- */
-
-/** @typedef {false|StateObject} State */
-
-/** @type {WeakMap<ParserState, State>} */
-const parserStateMap = new WeakMap();
-const topLevelSymbolTag = Symbol("top level symbol");
+const { SyncHook } = __webpack_require__(6967);
 
 /**
- * @param {ParserState} parserState parser state
- * @returns {State} state
+ * @typedef {Object} RuleCondition
+ * @property {string | string[]} property
+ * @property {boolean} matchWhenEmpty
+ * @property {function(string): boolean} fn
  */
-function getState(parserState) {
-	return parserStateMap.get(parserState);
-}
 
 /**
- * @param {ParserState} parserState parser state
- * @returns {void}
+ * @typedef {Object} Condition
+ * @property {boolean} matchWhenEmpty
+ * @property {function(string): boolean} fn
  */
-exports.bailout = parserState => {
-	parserStateMap.set(parserState, false);
-};
 
 /**
- * @param {ParserState} parserState parser state
- * @returns {void}
+ * @typedef {Object} CompiledRule
+ * @property {RuleCondition[]} conditions
+ * @property {(Effect|function(object): Effect[])[]} effects
+ * @property {CompiledRule[]=} rules
+ * @property {CompiledRule[]=} oneOf
  */
-exports.enable = parserState => {
-	const state = parserStateMap.get(parserState);
-	if (state === false) {
-		return;
-	}
-	parserStateMap.set(parserState, {
-		innerGraph: new Map(),
-		currentTopLevelSymbol: undefined,
-		usageCallbackMap: new Map()
-	});
-};
 
 /**
- * @param {ParserState} parserState parser state
- * @returns {boolean} true, when enabled
+ * @typedef {Object} Effect
+ * @property {string} type
+ * @property {any} value
  */
-exports.isEnabled = parserState => {
-	const state = parserStateMap.get(parserState);
-	return !!state;
-};
 
 /**
- * @param {ParserState} state parser state
- * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
- * @param {string | TopLevelSymbol | true} usage usage data
- * @returns {void}
+ * @typedef {Object} RuleSet
+ * @property {Map<string, any>} references map of references in the rule set (may grow over time)
+ * @property {function(object): Effect[]} exec execute the rule set
  */
-exports.addUsage = (state, symbol, usage) => {
-	const innerGraphState = getState(state);
 
-	if (innerGraphState) {
-		const { innerGraph } = innerGraphState;
-		const info = innerGraph.get(symbol);
-		if (usage === true) {
-			innerGraph.set(symbol, true);
-		} else if (info === undefined) {
-			innerGraph.set(symbol, new Set([usage]));
-		} else if (info !== true) {
-			info.add(usage);
+class RuleSetCompiler {
+	constructor(plugins) {
+		this.hooks = Object.freeze({
+			/** @type {SyncHook<[string, object, Set<string>, CompiledRule, Map<string, any>]>} */
+			rule: new SyncHook([
+				"path",
+				"rule",
+				"unhandledProperties",
+				"compiledRule",
+				"references"
+			])
+		});
+		if (plugins) {
+			for (const plugin of plugins) {
+				plugin.apply(this);
+			}
 		}
 	}
-};
-
-/**
- * @param {JavascriptParser} parser the parser
- * @param {string} name name of variable
- * @param {string | TopLevelSymbol | true} usage usage data
- * @returns {void}
- */
-exports.addVariableUsage = (parser, name, usage) => {
-	const symbol =
-		/** @type {TopLevelSymbol} */ (
-			parser.getTagData(name, topLevelSymbolTag)
-		) || exports.tagTopLevelSymbol(parser, name);
-	if (symbol) {
-		exports.addUsage(parser.state, symbol, usage);
-	}
-};
 
-/**
- * @param {ParserState} state parser state
- * @returns {void}
- */
-exports.inferDependencyUsage = state => {
-	const innerGraphState = getState(state);
-
-	if (!innerGraphState) {
-		return;
-	}
+	/**
+	 * @param {object[]} ruleSet raw user provided rules
+	 * @returns {RuleSet} compiled RuleSet
+	 */
+	compile(ruleSet) {
+		const refs = new Map();
+		const rules = this.compileRules("ruleSet", ruleSet, refs);
 
-	const { innerGraph, usageCallbackMap } = innerGraphState;
-	const processed = new Map();
-	// flatten graph to terminal nodes (string, undefined or true)
-	const nonTerminal = new Set(innerGraph.keys());
-	while (nonTerminal.size > 0) {
-		for (const key of nonTerminal) {
-			/** @type {Set<string|TopLevelSymbol> | true} */
-			let newSet = new Set();
-			let isTerminal = true;
-			const value = innerGraph.get(key);
-			let alreadyProcessed = processed.get(key);
-			if (alreadyProcessed === undefined) {
-				alreadyProcessed = new Set();
-				processed.set(key, alreadyProcessed);
-			}
-			if (value !== true && value !== undefined) {
-				for (const item of value) {
-					alreadyProcessed.add(item);
-				}
-				for (const item of value) {
-					if (typeof item === "string") {
-						newSet.add(item);
-					} else {
-						const itemValue = innerGraph.get(item);
-						if (itemValue === true) {
-							newSet = true;
+		/**
+		 * @param {object} data data passed in
+		 * @param {CompiledRule} rule the compiled rule
+		 * @param {Effect[]} effects an array where effects are pushed to
+		 * @returns {boolean} true, if the rule has matched
+		 */
+		const execRule = (data, rule, effects) => {
+			for (const condition of rule.conditions) {
+				const p = condition.property;
+				if (Array.isArray(p)) {
+					let current = data;
+					for (const subProperty of p) {
+						if (
+							current &&
+							typeof current === "object" &&
+							Object.prototype.hasOwnProperty.call(current, subProperty)
+						) {
+							current = current[subProperty];
+						} else {
+							current = undefined;
 							break;
 						}
-						if (itemValue !== undefined) {
-							for (const i of itemValue) {
-								if (i === key) continue;
-								if (alreadyProcessed.has(i)) continue;
-								newSet.add(i);
-								if (typeof i !== "string") {
-									isTerminal = false;
-								}
-							}
-						}
+					}
+					if (current !== undefined) {
+						if (!condition.fn(current)) return false;
+						continue;
+					}
+				} else if (p in data) {
+					const value = data[p];
+					if (value !== undefined) {
+						if (!condition.fn(value)) return false;
+						continue;
 					}
 				}
-				if (newSet === true) {
-					innerGraph.set(key, true);
-				} else if (newSet.size === 0) {
-					innerGraph.set(key, undefined);
+				if (!condition.matchWhenEmpty) {
+					return false;
+				}
+			}
+			for (const effect of rule.effects) {
+				if (typeof effect === "function") {
+					const returnedEffects = effect(data);
+					for (const effect of returnedEffects) {
+						effects.push(effect);
+					}
 				} else {
-					innerGraph.set(key, newSet);
+					effects.push(effect);
 				}
 			}
-			if (isTerminal) {
-				nonTerminal.delete(key);
-
-				// For the global key, merge with all other keys
-				if (key === null) {
-					const globalValue = innerGraph.get(null);
-					if (globalValue) {
-						for (const [key, value] of innerGraph) {
-							if (key !== null && value !== true) {
-								if (globalValue === true) {
-									innerGraph.set(key, true);
-								} else {
-									const newSet = new Set(value);
-									for (const item of globalValue) {
-										newSet.add(item);
-									}
-									innerGraph.set(key, newSet);
-								}
-							}
-						}
+			if (rule.rules) {
+				for (const childRule of rule.rules) {
+					execRule(data, childRule, effects);
+				}
+			}
+			if (rule.oneOf) {
+				for (const childRule of rule.oneOf) {
+					if (execRule(data, childRule, effects)) {
+						break;
 					}
 				}
 			}
-		}
+			return true;
+		};
+
+		return {
+			references: refs,
+			exec: data => {
+				/** @type {Effect[]} */
+				const effects = [];
+				for (const rule of rules) {
+					execRule(data, rule, effects);
+				}
+				return effects;
+			}
+		};
 	}
 
-	/** @type {Map<Dependency, true | Set<string>>} */
-	for (const [symbol, callbacks] of usageCallbackMap) {
-		const usage = /** @type {true | Set<string> | undefined} */ (
-			innerGraph.get(symbol)
+	/**
+	 * @param {string} path current path
+	 * @param {object[]} rules the raw rules provided by user
+	 * @param {Map<string, any>} refs references
+	 * @returns {CompiledRule[]} rules
+	 */
+	compileRules(path, rules, refs) {
+		return rules.map((rule, i) =>
+			this.compileRule(`${path}[${i}]`, rule, refs)
 		);
-		for (const callback of callbacks) {
-			callback(usage === undefined ? false : usage);
-		}
 	}
-};
 
-/**
- * @param {ParserState} state parser state
- * @param {UsageCallback} onUsageCallback on usage callback
- */
-exports.onUsage = (state, onUsageCallback) => {
-	const innerGraphState = getState(state);
+	/**
+	 * @param {string} path current path
+	 * @param {object} rule the raw rule provided by user
+	 * @param {Map<string, any>} refs references
+	 * @returns {CompiledRule} normalized and compiled rule for processing
+	 */
+	compileRule(path, rule, refs) {
+		const unhandledProperties = new Set(
+			Object.keys(rule).filter(key => rule[key] !== undefined)
+		);
 
-	if (innerGraphState) {
-		const { usageCallbackMap, currentTopLevelSymbol } = innerGraphState;
-		if (currentTopLevelSymbol) {
-			let callbacks = usageCallbackMap.get(currentTopLevelSymbol);
+		/** @type {CompiledRule} */
+		const compiledRule = {
+			conditions: [],
+			effects: [],
+			rules: undefined,
+			oneOf: undefined
+		};
 
-			if (callbacks === undefined) {
-				callbacks = new Set();
-				usageCallbackMap.set(currentTopLevelSymbol, callbacks);
-			}
+		this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs);
 
-			callbacks.add(onUsageCallback);
-		} else {
-			onUsageCallback(true);
+		if (unhandledProperties.has("rules")) {
+			unhandledProperties.delete("rules");
+			const rules = rule.rules;
+			if (!Array.isArray(rules))
+				throw this.error(path, rules, "Rule.rules must be an array of rules");
+			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
 		}
-	} else {
-		onUsageCallback(undefined);
-	}
-};
-
-/**
- * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
- */
-exports.setTopLevelSymbol = (state, symbol) => {
-	const innerGraphState = getState(state);
 
-	if (innerGraphState) {
-		innerGraphState.currentTopLevelSymbol = symbol;
-	}
-};
+		if (unhandledProperties.has("oneOf")) {
+			unhandledProperties.delete("oneOf");
+			const oneOf = rule.oneOf;
+			if (!Array.isArray(oneOf))
+				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
+			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
+		}
 
-/**
- * @param {ParserState} state parser state
- * @returns {TopLevelSymbol|void} usage data
- */
-exports.getTopLevelSymbol = state => {
-	const innerGraphState = getState(state);
+		if (unhandledProperties.size > 0) {
+			throw this.error(
+				path,
+				rule,
+				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
+			);
+		}
 
-	if (innerGraphState) {
-		return innerGraphState.currentTopLevelSymbol;
+		return compiledRule;
 	}
-};
 
-/**
- * @param {JavascriptParser} parser parser
- * @param {string} name name of variable
- * @returns {TopLevelSymbol} symbol
- */
-exports.tagTopLevelSymbol = (parser, name) => {
-	const innerGraphState = getState(parser.state);
-	if (!innerGraphState) return;
+	/**
+	 * @param {string} path current path
+	 * @param {any} condition user provided condition value
+	 * @returns {Condition} compiled condition
+	 */
+	compileCondition(path, condition) {
+		if (condition === "") {
+			return {
+				matchWhenEmpty: true,
+				fn: str => str === ""
+			};
+		}
+		if (!condition) {
+			throw this.error(
+				path,
+				condition,
+				"Expected condition but got falsy value"
+			);
+		}
+		if (typeof condition === "string") {
+			return {
+				matchWhenEmpty: condition.length === 0,
+				fn: str => typeof str === "string" && str.startsWith(condition)
+			};
+		}
+		if (typeof condition === "function") {
+			try {
+				return {
+					matchWhenEmpty: condition(""),
+					fn: condition
+				};
+			} catch (err) {
+				throw this.error(
+					path,
+					condition,
+					"Evaluation of condition function threw error"
+				);
+			}
+		}
+		if (condition instanceof RegExp) {
+			return {
+				matchWhenEmpty: condition.test(""),
+				fn: v => typeof v === "string" && condition.test(v)
+			};
+		}
+		if (Array.isArray(condition)) {
+			const items = condition.map((c, i) =>
+				this.compileCondition(`${path}[${i}]`, c)
+			);
+			return this.combineConditionsOr(items);
+		}
 
-	parser.defineVariable(name);
+		if (typeof condition !== "object") {
+			throw this.error(
+				path,
+				condition,
+				`Unexpected ${typeof condition} when condition was expected`
+			);
+		}
 
-	const existingTag = /** @type {TopLevelSymbol} */ (
-		parser.getTagData(name, topLevelSymbolTag)
-	);
-	if (existingTag) {
-		return existingTag;
+		const conditions = [];
+		for (const key of Object.keys(condition)) {
+			const value = condition[key];
+			switch (key) {
+				case "or":
+					if (value) {
+						if (!Array.isArray(value)) {
+							throw this.error(
+								`${path}.or`,
+								condition.and,
+								"Expected array of conditions"
+							);
+						}
+						conditions.push(this.compileCondition(`${path}.or`, value));
+					}
+					break;
+				case "and":
+					if (value) {
+						if (!Array.isArray(value)) {
+							throw this.error(
+								`${path}.and`,
+								condition.and,
+								"Expected array of conditions"
+							);
+						}
+						let i = 0;
+						for (const item of value) {
+							conditions.push(this.compileCondition(`${path}.and[${i}]`, item));
+							i++;
+						}
+					}
+					break;
+				case "not":
+					if (value) {
+						const matcher = this.compileCondition(`${path}.not`, value);
+						const fn = matcher.fn;
+						conditions.push({
+							matchWhenEmpty: !matcher.matchWhenEmpty,
+							fn: v => !fn(v)
+						});
+					}
+					break;
+				default:
+					throw this.error(
+						`${path}.${key}`,
+						condition[key],
+						`Unexpected property ${key} in condition`
+					);
+			}
+		}
+		if (conditions.length === 0) {
+			throw this.error(
+				path,
+				condition,
+				"Expected condition, but got empty thing"
+			);
+		}
+		return this.combineConditionsAnd(conditions);
 	}
 
-	const fn = new TopLevelSymbol(name);
-	parser.tagVariable(name, topLevelSymbolTag, fn);
-	return fn;
-};
-
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @param {RuntimeSpec} runtime runtime
- * @returns {boolean} false, when unused. Otherwise true
- */
-exports.isDependencyUsedByExports = (
-	dependency,
-	usedByExports,
-	moduleGraph,
-	runtime
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		let used = false;
-		for (const exportName of usedByExports) {
-			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-				used = true;
+	/**
+	 * @param {Condition[]} conditions some conditions
+	 * @returns {Condition} merged condition
+	 */
+	combineConditionsOr(conditions) {
+		if (conditions.length === 0) {
+			return {
+				matchWhenEmpty: false,
+				fn: () => false
+			};
+		} else if (conditions.length === 1) {
+			return conditions[0];
+		} else {
+			return {
+				matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
+				fn: v => conditions.some(c => c.fn(v))
+			};
 		}
-		if (!used) return false;
 	}
-	return true;
-};
 
-/**
- * @param {Dependency} dependency the dependency
- * @param {Set<string> | boolean} usedByExports usedByExports info
- * @param {ModuleGraph} moduleGraph moduleGraph
- * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
- */
-exports.getDependencyUsedByExportsCondition = (
-	dependency,
-	usedByExports,
-	moduleGraph
-) => {
-	if (usedByExports === false) return false;
-	if (usedByExports !== true && usedByExports !== undefined) {
-		const selfModule = moduleGraph.getParentModule(dependency);
-		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-		return (connections, runtime) => {
-			for (const exportName of usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-					return true;
-			}
-			return false;
-		};
+	/**
+	 * @param {Condition[]} conditions some conditions
+	 * @returns {Condition} merged condition
+	 */
+	combineConditionsAnd(conditions) {
+		if (conditions.length === 0) {
+			return {
+				matchWhenEmpty: false,
+				fn: () => false
+			};
+		} else if (conditions.length === 1) {
+			return conditions[0];
+		} else {
+			return {
+				matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
+				fn: v => conditions.every(c => c.fn(v))
+			};
+		}
 	}
-	return null;
-};
 
-class TopLevelSymbol {
 	/**
-	 * @param {string} name name of the variable
+	 * @param {string} path current path
+	 * @param {any} value value at the error location
+	 * @param {string} message message explaining the problem
+	 * @returns {Error} an error object
 	 */
-	constructor(name) {
-		this.name = name;
+	error(path, value, message) {
+		return new Error(
+			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
+		);
 	}
 }
 
-exports.TopLevelSymbol = TopLevelSymbol;
-exports.topLevelSymbolTag = topLevelSymbolTag;
+module.exports = RuleSetCompiler;
 
 
 /***/ }),
 
-/***/ 28758:
+/***/ 84977:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -109525,2080 +108202,1490 @@ exports.topLevelSymbolTag = topLevelSymbolTag;
 
 
 
-const PureExpressionDependency = __webpack_require__(55799);
-const InnerGraph = __webpack_require__(38988);
-
-/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
-/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./InnerGraph").InnerGraph} InnerGraph */
-/** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
+const util = __webpack_require__(73837);
 
-const { topLevelSymbolTag } = InnerGraph;
+/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @typedef {import("./RuleSetCompiler").Effect} Effect */
 
-class InnerGraphPlugin {
+class UseEffectRulePlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"InnerGraphPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			"UseEffectRulePlugin",
+			(path, rule, unhandledProperties, result, references) => {
+				const conflictWith = (property, correctProperty) => {
+					if (unhandledProperties.has(property)) {
+						throw ruleSetCompiler.error(
+							`${path}.${property}`,
+							rule[property],
+							`A Rule must not have a '${property}' property when it has a '${correctProperty}' property`
+						);
+					}
+				};
 
-				compilation.dependencyTemplates.set(
-					PureExpressionDependency,
-					new PureExpressionDependency.Template()
-				);
-
-				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {Object} parserOptions options
-				 * @returns {void}
-				 */
-				const handler = (parser, parserOptions) => {
-					const onUsageSuper = sup => {
-						InnerGraph.onUsage(parser.state, usedByExports => {
-							switch (usedByExports) {
-								case undefined:
-								case true:
-									return;
-								default: {
-									const dep = new PureExpressionDependency(sup.range);
-									dep.loc = sup.loc;
-									dep.usedByExports = usedByExports;
-									parser.state.module.addDependency(dep);
-									break;
-								}
-							}
-						});
-					};
-
-					parser.hooks.program.tap("InnerGraphPlugin", () => {
-						InnerGraph.enable(parser.state);
-					});
-
-					parser.hooks.finish.tap("InnerGraphPlugin", () => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						logger.time("infer dependency usage");
-						InnerGraph.inferDependencyUsage(parser.state);
-						logger.timeAggregate("infer dependency usage");
-					});
-
-					// During prewalking the following datastructures are filled with
-					// nodes that have a TopLevelSymbol assigned and
-					// variables are tagged with the assigned TopLevelSymbol
-
-					// We differ 3 types of nodes:
-					// 1. full statements (export default, function declaration)
-					// 2. classes (class declaration, class expression)
-					// 3. variable declarators (const x = ...)
-
-					/** @type {WeakMap<Node, TopLevelSymbol>} */
-					const statementWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakMap<Node, Node>} */
-					const statementPurePart = new WeakMap();
-
-					/** @type {WeakMap<ClassExpressionNode | ClassDeclarationNode, TopLevelSymbol>} */
-					const classWithTopLevelSymbol = new WeakMap();
+				if (unhandledProperties.has("use")) {
+					unhandledProperties.delete("use");
+					unhandledProperties.delete("enforce");
 
-					/** @type {WeakMap<VariableDeclaratorNode, TopLevelSymbol>} */
-					const declWithTopLevelSymbol = new WeakMap();
-					/** @type {WeakSet<VariableDeclaratorNode>} */
-					const pureDeclarators = new WeakSet();
+					conflictWith("loader", "use");
+					conflictWith("options", "use");
 
-					// The following hooks are used during prewalking:
+					const use = rule.use;
+					const enforce = rule.enforce;
 
-					parser.hooks.preStatement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+					const type = enforce ? `use-${enforce}` : "use";
 
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "FunctionDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								statementWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
+					/**
+					 *
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {object} item user provided use value
+					 * @returns {Effect|function(any): Effect[]} effect
+					 */
+					const useToEffect = (path, defaultIdent, item) => {
+						if (typeof item === "function") {
+							return data => useToEffectsWithoutIdent(path, item(data));
+						} else {
+							return useToEffectRaw(path, defaultIdent, item);
 						}
-					});
-
-					parser.hooks.blockPreStatement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+					};
 
-						if (parser.scope.topLevelScope === true) {
-							if (statement.type === "ClassDeclaration") {
-								const name = statement.id ? statement.id.name : "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								classWithTopLevelSymbol.set(statement, fn);
-								return true;
-							}
-							if (statement.type === "ExportDefaultDeclaration") {
-								const name = "*default*";
-								const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-								const decl = statement.declaration;
-								if (
-									decl.type === "ClassExpression" ||
-									decl.type === "ClassDeclaration"
-								) {
-									classWithTopLevelSymbol.set(decl, fn);
-								} else if (parser.isPure(decl, statement.range[0])) {
-									statementWithTopLevelSymbol.set(statement, fn);
-									if (
-										!decl.type.endsWith("FunctionExpression") &&
-										!decl.type.endsWith("Declaration") &&
-										decl.type !== "Literal"
-									) {
-										statementPurePart.set(statement, decl);
-									}
+					/**
+					 *
+					 * @param {string} path options path
+					 * @param {string} defaultIdent default ident when none is provided
+					 * @param {object} item user provided use value
+					 * @returns {Effect} effect
+					 */
+					const useToEffectRaw = (path, defaultIdent, item) => {
+						if (typeof item === "string") {
+							return {
+								type,
+								value: {
+									loader: item,
+									options: undefined,
+									ident: undefined
 								}
+							};
+						} else {
+							const loader = item.loader;
+							const options = item.options;
+							let ident = item.ident;
+							if (options && typeof options === "object") {
+								if (!ident) ident = defaultIdent;
+								references.set(ident, options);
 							}
-						}
-					});
-
-					parser.hooks.preDeclarator.tap(
-						"InnerGraphPlugin",
-						(decl, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (
-								parser.scope.topLevelScope === true &&
-								decl.init &&
-								decl.id.type === "Identifier"
-							) {
-								const name = decl.id.name;
-								if (decl.init.type === "ClassExpression") {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									classWithTopLevelSymbol.set(decl.init, fn);
-								} else if (parser.isPure(decl.init, decl.id.range[1])) {
-									const fn = InnerGraph.tagTopLevelSymbol(parser, name);
-									declWithTopLevelSymbol.set(decl, fn);
-									if (
-										!decl.init.type.endsWith("FunctionExpression") &&
-										decl.init.type !== "Literal"
-									) {
-										pureDeclarators.add(decl);
-									}
-									return true;
-								}
+							if (typeof options === "string") {
+								util.deprecate(
+									() => {},
+									`Using a string as loader options is deprecated (${path}.options)`,
+									"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+								)();
 							}
-						}
-					);
-
-					// During real walking we set the TopLevelSymbol state to the assigned
-					// TopLevelSymbol by using the fill datastructures.
-
-					// In addition to tracking TopLevelSymbols, we sometimes need to
-					// add a PureExpressionDependency. This is needed to skip execution
-					// of pure expressions, even when they are not dropped due to
-					// minimizing. Otherwise symbols used there might not exist anymore
-					// as they are removed as unused by this optimization
-
-					// When we find a reference to a TopLevelSymbol, we register a
-					// TopLevelSymbol dependency from TopLevelSymbol in state to the
-					// referenced TopLevelSymbol. This way we get a graph of all
-					// TopLevelSymbols.
-
-					// The following hooks are called during walking:
-
-					parser.hooks.statement.tap("InnerGraphPlugin", statement => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						if (parser.scope.topLevelScope === true) {
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
-
-							const fn = statementWithTopLevelSymbol.get(statement);
-							if (fn) {
-								InnerGraph.setTopLevelSymbol(parser.state, fn);
-								const purePart = statementPurePart.get(statement);
-								if (purePart) {
-									InnerGraph.onUsage(parser.state, usedByExports => {
-										switch (usedByExports) {
-											case undefined:
-											case true:
-												return;
-											default: {
-												const dep = new PureExpressionDependency(
-													purePart.range
-												);
-												dep.loc = statement.loc;
-												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
-												break;
-											}
-										}
-									});
+							return {
+								type: enforce ? `use-${enforce}` : "use",
+								value: {
+									loader,
+									options,
+									ident
 								}
-							}
+							};
 						}
-					});
+					};
 
-					parser.hooks.classExtendsExpression.tap(
-						"InnerGraphPlugin",
-						(expr, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(statement);
-								if (
-									fn &&
-									parser.isPure(
-										expr,
-										statement.id ? statement.id.range[1] : statement.range[0]
-									)
-								) {
-									InnerGraph.setTopLevelSymbol(parser.state, fn);
-									onUsageSuper(expr);
-								}
-							}
+					/**
+					 * @param {string} path options path
+					 * @param {any} items user provided use value
+					 * @returns {Effect[]} effects
+					 */
+					const useToEffectsWithoutIdent = (path, items) => {
+						if (Array.isArray(items)) {
+							return items.map((item, idx) =>
+								useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
+							);
 						}
-					);
+						return [useToEffectRaw(path, "[[missing ident]]", items)];
+					};
 
-					parser.hooks.classBodyElement.tap(
-						"InnerGraphPlugin",
-						(element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(classDefinition);
-								if (fn) {
-									InnerGraph.setTopLevelSymbol(parser.state, undefined);
-								}
-							}
+					/**
+					 * @param {string} path current path
+					 * @param {any} items user provided use value
+					 * @returns {(Effect|function(any): Effect[])[]} effects
+					 */
+					const useToEffects = (path, items) => {
+						if (Array.isArray(items)) {
+							return items.map((item, idx) => {
+								const subPath = `${path}[${idx}]`;
+								return useToEffect(subPath, subPath, item);
+							});
 						}
-					);
+						return [useToEffect(path, path, items)];
+					};
 
-					parser.hooks.classBodyValue.tap(
-						"InnerGraphPlugin",
-						(expression, element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(classDefinition);
-								if (fn) {
-									if (
-										!element.static ||
-										parser.isPure(
-											expression,
-											element.key ? element.key.range[1] : element.range[0]
-										)
-									) {
-										InnerGraph.setTopLevelSymbol(parser.state, fn);
-										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, usedByExports => {
-												switch (usedByExports) {
-													case undefined:
-													case true:
-														return;
-													default: {
-														const dep = new PureExpressionDependency(
-															expression.range
-														);
-														dep.loc = expression.loc;
-														dep.usedByExports = usedByExports;
-														parser.state.module.addDependency(dep);
-														break;
-													}
-												}
-											});
-										}
-									} else {
-										InnerGraph.setTopLevelSymbol(parser.state, undefined);
-									}
-								}
-							}
+					if (typeof use === "function") {
+						result.effects.push(data =>
+							useToEffectsWithoutIdent(`${path}.use`, use(data))
+						);
+					} else {
+						for (const effect of useToEffects(`${path}.use`, use)) {
+							result.effects.push(effect);
 						}
-					);
+					}
+				}
 
-					parser.hooks.declarator.tap("InnerGraphPlugin", (decl, statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-						const fn = declWithTopLevelSymbol.get(decl);
+				if (unhandledProperties.has("loader")) {
+					unhandledProperties.delete("loader");
+					unhandledProperties.delete("options");
+					unhandledProperties.delete("enforce");
 
-						if (fn) {
-							InnerGraph.setTopLevelSymbol(parser.state, fn);
-							if (pureDeclarators.has(decl)) {
-								if (decl.init.type === "ClassExpression") {
-									if (decl.init.superClass) {
-										onUsageSuper(decl.init.superClass);
-									}
-								} else {
-									InnerGraph.onUsage(parser.state, usedByExports => {
-										switch (usedByExports) {
-											case undefined:
-											case true:
-												return;
-											default: {
-												const dep = new PureExpressionDependency(
-													decl.init.range
-												);
-												dep.loc = decl.loc;
-												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
-												break;
-											}
-										}
-									});
-								}
-							}
-							parser.walkExpression(decl.init);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
-							return true;
-						}
-					});
+					const loader = rule.loader;
+					const options = rule.options;
+					const enforce = rule.enforce;
 
-					parser.hooks.expression
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", () => {
-							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
-								parser.currentTagData
-							);
-							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
-								parser.state
-							);
-							InnerGraph.addUsage(
-								parser.state,
-								topLevelSymbol,
-								currentTopLevelSymbol || true
-							);
-						});
-					parser.hooks.assign
-						.for(topLevelSymbolTag)
-						.tap("InnerGraphPlugin", expr => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
-							if (expr.operator === "=") return true;
-						});
-				};
-				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("InnerGraphPlugin", handler);
-				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("InnerGraphPlugin", handler);
+					if (loader.includes("!")) {
+						throw ruleSetCompiler.error(
+							`${path}.loader`,
+							loader,
+							"Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays"
+						);
+					}
 
-				compilation.hooks.finishModules.tap("InnerGraphPlugin", () => {
-					logger.timeAggregateEnd("infer dependency usage");
-				});
+					if (loader.includes("?")) {
+						throw ruleSetCompiler.error(
+							`${path}.loader`,
+							loader,
+							"Query arguments on 'loader' has been removed in favor of the 'options' property"
+						);
+					}
+
+					if (typeof options === "string") {
+						util.deprecate(
+							() => {},
+							`Using a string as loader options is deprecated (${path}.options)`,
+							"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+						)();
+					}
+
+					const ident =
+						options && typeof options === "object" ? path : undefined;
+					references.set(ident, options);
+					result.effects.push({
+						type: enforce ? `use-${enforce}` : "use",
+						value: {
+							loader,
+							options,
+							ident
+						}
+					});
+				}
 			}
 		);
 	}
+
+	useItemToEffects(path, item) {}
 }
 
-module.exports = InnerGraphPlugin;
+module.exports = UseEffectRulePlugin;
 
 
 /***/ }),
 
-/***/ 83608:
+/***/ 63672:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const LazyBucketSortedSet = __webpack_require__(48424);
-const { compareChunks } = __webpack_require__(29579);
-const createSchemaValidation = __webpack_require__(32540);
-
-/** @typedef {import("../../declarations/plugins/optimize/LimitChunkCountPlugin").LimitChunkCountPluginOptions} LimitChunkCountPluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-
-const validate = createSchemaValidation(
-	__webpack_require__(36557),
-	() => __webpack_require__(30837),
-	{
-		name: "Limit Chunk Count Plugin",
-		baseDataPath: "options"
-	}
-);
-
-/**
- * @typedef {Object} ChunkCombination
- * @property {boolean} deleted this is set to true when combination was removed
- * @property {number} sizeDiff
- * @property {number} integratedSize
- * @property {Chunk} a
- * @property {Chunk} b
- * @property {number} aIdx
- * @property {number} bIdx
- * @property {number} aSize
- * @property {number} bSize
- */
-
-const addToSetMap = (map, key, value) => {
-	const set = map.get(key);
-	if (set === undefined) {
-		map.set(key, new Set([value]));
-	} else {
-		set.add(value);
-	}
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-class LimitChunkCountPlugin {
-	/**
-	 * @param {LimitChunkCountPluginOptions=} options options object
-	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
+class AsyncModuleRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("async module");
 	}
 
 	/**
-	 * @param {Compiler} compiler the webpack compiler
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		const options = this.options;
-		compiler.hooks.compilation.tap("LimitChunkCountPlugin", compilation => {
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "LimitChunkCountPlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					const maxChunks = options.maxChunks;
-					if (!maxChunks) return;
-					if (maxChunks < 1) return;
-					if (compilation.chunks.size <= maxChunks) return;
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.asyncModule;
+		return Template.asString([
+			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
+			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
+			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
+				"if(queue) {",
+				Template.indent([
+					`queue.forEach(${runtimeTemplate.expressionFunction(
+						"fn.r--",
+						"fn"
+					)});`,
+					`queue.forEach(${runtimeTemplate.expressionFunction(
+						"fn.r-- ? fn.r++ : fn()",
+						"fn"
+					)});`
+				]),
+				"}"
+			])}`,
+			`var completeFunction = ${runtimeTemplate.expressionFunction(
+				"!--fn.r && fn()",
+				"fn"
+			)};`,
+			`var queueFunction = ${runtimeTemplate.expressionFunction(
+				"queue ? queue.push(fn) : completeFunction(fn)",
+				"queue, fn"
+			)};`,
+			`var wrapDeps = ${runtimeTemplate.returningFunction(
+				`deps.map(${runtimeTemplate.basicFunction("dep", [
+					'if(dep !== null && typeof dep === "object") {',
+					Template.indent([
+						"if(dep[webpackThen]) return dep;",
+						"if(dep.then) {",
+						Template.indent([
+							"var queue = [];",
+							`dep.then(${runtimeTemplate.basicFunction("r", [
+								"obj[webpackExports] = r;",
+								"completeQueue(queue);",
+								"queue = 0;"
+							])}, ${runtimeTemplate.basicFunction("e", [
+								"obj[webpackError] = e;",
+								"completeQueue(queue);",
+								"queue = 0;"
+							])});`,
+							"var obj = {};",
+							`obj[webpackThen] = ${runtimeTemplate.expressionFunction(
+								"queueFunction(queue, fn), dep['catch'](reject)",
+								"fn, reject"
+							)};`,
+							"return obj;"
+						]),
+						"}"
+					]),
+					"}",
+					"var ret = {};",
+					`ret[webpackThen] = ${runtimeTemplate.expressionFunction(
+						"completeFunction(fn)",
+						"fn"
+					)};`,
+					"ret[webpackExports] = dep;",
+					"return ret;"
+				])})`,
+				"deps"
+			)};`,
+			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
+				"var queue = hasAwait && [];",
+				"var exports = module.exports;",
+				"var currentDeps;",
+				"var outerResolve;",
+				"var reject;",
+				"var isEvaluating = true;",
+				"var nested = false;",
+				`var whenAll = ${runtimeTemplate.basicFunction(
+					"deps, onResolve, onReject",
+					[
+						"if (nested) return;",
+						"nested = true;",
+						"onResolve.r += deps.length;",
+						`deps.map(${runtimeTemplate.expressionFunction(
+							"dep[webpackThen](onResolve, onReject)",
+							"dep, i"
+						)});`,
+						"nested = false;"
+					]
+				)};`,
+				`var promise = new Promise(${runtimeTemplate.basicFunction(
+					"resolve, rej",
+					[
+						"reject = rej;",
+						`outerResolve = ${runtimeTemplate.expressionFunction(
+							"resolve(exports), completeQueue(queue), queue = 0"
+						)};`
+					]
+				)});`,
+				"promise[webpackExports] = exports;",
+				`promise[webpackThen] = ${runtimeTemplate.basicFunction(
+					"fn, rejectFn",
+					[
+						"if (isEvaluating) { return completeFunction(fn); }",
+						"if (currentDeps) whenAll(currentDeps, fn, rejectFn);",
+						"queueFunction(queue, fn);",
+						"promise['catch'](rejectFn);"
+					]
+				)};`,
+				"module.exports = promise;",
+				`body(${runtimeTemplate.basicFunction("deps", [
+					"currentDeps = wrapDeps(deps);",
+					"var fn;",
+					`var getResult = ${runtimeTemplate.returningFunction(
+						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							"if(d[webpackError]) throw d[webpackError];",
+							"return d[webpackExports];"
+						])})`
+					)}`,
+					`var promise = new Promise(${runtimeTemplate.basicFunction(
+						"resolve, reject",
+						[
+							`fn = ${runtimeTemplate.expressionFunction(
+								"resolve(getResult)"
+							)};`,
+							"fn.r = 0;",
+							"whenAll(currentDeps, fn, reject);"
+						]
+					)});`,
+					"return fn.r ? promise : getResult();"
+				])}, ${runtimeTemplate.expressionFunction(
+					"err && reject(promise[webpackError] = err), outerResolve()",
+					"err"
+				)});`,
+				"isEvaluating = false;"
+			])};`
+		]);
+	}
+}
 
-					let remainingChunksToMerge = compilation.chunks.size - maxChunks;
+module.exports = AsyncModuleRuntimeModule;
 
-					// order chunks in a deterministic way
-					const compareChunksWithGraph = compareChunks(chunkGraph);
-					const orderedChunks = Array.from(chunks).sort(compareChunksWithGraph);
 
-					// create a lazy sorted data structure to keep all combinations
-					// this is large. Size = chunks * (chunks - 1) / 2
-					// It uses a multi layer bucket sort plus normal sort in the last layer
-					// It's also lazy so only accessed buckets are sorted
-					const combinations = new LazyBucketSortedSet(
-						// Layer 1: ordered by largest size benefit
-						c => c.sizeDiff,
-						(a, b) => b - a,
-						// Layer 2: ordered by smallest combined size
-						c => c.integratedSize,
-						(a, b) => a - b,
-						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
-						c => c.bIdx - c.aIdx,
-						(a, b) => a - b,
-						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
-						(a, b) => a.bIdx - b.bIdx
-					);
+/***/ }),
 
-					// we keep a mapping from chunk to all combinations
-					// but this mapping is not kept up-to-date with deletions
-					// so `deleted` flag need to be considered when iterating this
-					/** @type {Map<Chunk, Set<ChunkCombination>>} */
-					const combinationsByChunk = new Map();
+/***/ 66532:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					orderedChunks.forEach((b, bIdx) => {
-						// create combination pairs with size and integrated size
-						for (let aIdx = 0; aIdx < bIdx; aIdx++) {
-							const a = orderedChunks[aIdx];
-							// filter pairs that can not be integrated!
-							if (!chunkGraph.canChunksBeIntegrated(a, b)) continue;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-							const integratedSize = chunkGraph.getIntegratedChunksSize(
-								a,
-								b,
-								options
-							);
 
-							const aSize = chunkGraph.getChunkSize(a, options);
-							const bSize = chunkGraph.getChunkSize(b, options);
-							const c = {
-								deleted: false,
-								sizeDiff: aSize + bSize - integratedSize,
-								integratedSize,
-								a,
-								b,
-								aIdx,
-								bIdx,
-								aSize,
-								bSize
-							};
-							combinations.add(c);
-							addToSetMap(combinationsByChunk, a, c);
-							addToSetMap(combinationsByChunk, b, c);
-						}
-						return combinations;
-					});
 
-					// list of modified chunks during this run
-					// combinations affected by this change are skipped to allow
-					// further optimizations
-					/** @type {Set<Chunk>} */
-					const modifiedChunks = new Set();
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const JavascriptModulesPlugin = __webpack_require__(89464);
+const { getUndoPath } = __webpack_require__(82186);
 
-					let changed = false;
-					// eslint-disable-next-line no-constant-condition
-					loop: while (true) {
-						const combination = combinations.popFirst();
-						if (combination === undefined) break;
+class AutoPublicPathRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("publicPath", RuntimeModule.STAGE_BASIC);
+	}
 
-						combination.deleted = true;
-						const { a, b, integratedSize } = combination;
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { scriptType, importMetaName, path } = compilation.outputOptions;
+		const chunkName = compilation.getPath(
+			JavascriptModulesPlugin.getChunkFilenameTemplate(
+				this.chunk,
+				compilation.outputOptions
+			),
+			{
+				chunk: this.chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const undoPath = getUndoPath(chunkName, path, false);
 
-						// skip over pair when
-						// one of the already merged chunks is a parent of one of the chunks
-						if (modifiedChunks.size > 0) {
-							const queue = new Set(a.groupsIterable);
-							for (const group of b.groupsIterable) {
-								queue.add(group);
-							}
-							for (const group of queue) {
-								for (const mChunk of modifiedChunks) {
-									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
-										// This is a potential pair which needs recalculation
-										// We can't do that now, but it merge before following pairs
-										// so we leave space for it, and consider chunks as modified
-										// just for the worse case
-										remainingChunksToMerge--;
-										if (remainingChunksToMerge <= 0) break loop;
-										modifiedChunks.add(a);
-										modifiedChunks.add(b);
-										continue loop;
-									}
-								}
-								for (const parent of group.parentsIterable) {
-									queue.add(parent);
-								}
-							}
-						}
+		return Template.asString([
+			"var scriptUrl;",
+			scriptType === "module"
+				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
+				: Template.asString([
+						`if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
+						`var document = ${RuntimeGlobals.global}.document;`,
+						"if (!scriptUrl && document) {",
+						Template.indent([
+							`if (document.currentScript)`,
+							Template.indent(`scriptUrl = document.currentScript.src`),
+							"if (!scriptUrl) {",
+							Template.indent([
+								'var scripts = document.getElementsByTagName("script");',
+								"if(scripts.length) scriptUrl = scripts[scripts.length - 1].src"
+							]),
+							"}"
+						]),
+						"}"
+				  ]),
+			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
+			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
+			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
+			'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+			!undoPath
+				? `${RuntimeGlobals.publicPath} = scriptUrl;`
+				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(
+						undoPath
+				  )};`
+		]);
+	}
+}
 
-						// merge the chunks
-						if (chunkGraph.canChunksBeIntegrated(a, b)) {
-							chunkGraph.integrateChunks(a, b);
-							compilation.chunks.delete(b);
+module.exports = AutoPublicPathRuntimeModule;
 
-							// flag chunk a as modified as further optimization are possible for all children here
-							modifiedChunks.add(a);
 
-							changed = true;
-							remainingChunksToMerge--;
-							if (remainingChunksToMerge <= 0) break;
+/***/ }),
 
-							// Update all affected combinations
-							// delete all combination with the removed chunk
-							// we will use combinations with the kept chunk instead
-							for (const combination of combinationsByChunk.get(a)) {
-								if (combination.deleted) continue;
-								combination.deleted = true;
-								combinations.delete(combination);
-							}
+/***/ 84519:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-							// Update combinations with the kept chunk with new sizes
-							for (const combination of combinationsByChunk.get(b)) {
-								if (combination.deleted) continue;
-								if (combination.a === b) {
-									if (!chunkGraph.canChunksBeIntegrated(a, combination.b)) {
-										combination.deleted = true;
-										combinations.delete(combination);
-										continue;
-									}
-									// Update size
-									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
-										a,
-										combination.b,
-										options
-									);
-									const finishUpdate = combinations.startUpdate(combination);
-									combination.a = a;
-									combination.integratedSize = newIntegratedSize;
-									combination.aSize = integratedSize;
-									combination.sizeDiff =
-										combination.bSize + integratedSize - newIntegratedSize;
-									finishUpdate();
-								} else if (combination.b === b) {
-									if (!chunkGraph.canChunksBeIntegrated(combination.a, a)) {
-										combination.deleted = true;
-										combinations.delete(combination);
-										continue;
-									}
-									// Update size
-									const newIntegratedSize = chunkGraph.getIntegratedChunksSize(
-										combination.a,
-										a,
-										options
-									);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-									const finishUpdate = combinations.startUpdate(combination);
-									combination.b = a;
-									combination.integratedSize = newIntegratedSize;
-									combination.bSize = integratedSize;
-									combination.sizeDiff =
-										integratedSize + combination.aSize - newIntegratedSize;
-									finishUpdate();
-								}
-							}
-							combinationsByChunk.set(a, combinationsByChunk.get(b));
-							combinationsByChunk.delete(b);
-						}
-					}
-					if (changed) return true;
-				}
-			);
-		});
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+class ChunkNameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} chunkName the chunk's name
+	 */
+	constructor(chunkName) {
+		super("chunkName");
+		this.chunkName = chunkName;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;
 	}
 }
-module.exports = LimitChunkCountPlugin;
+
+module.exports = ChunkNameRuntimeModule;
 
 
 /***/ }),
 
-/***/ 27868:
+/***/ 44793:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { UsageState } = __webpack_require__(63686);
-const {
-	numberToIdentifier,
-	NUMBER_OF_IDENTIFIER_START_CHARS,
-	NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
-} = __webpack_require__(39722);
-const { assignDeterministicIds } = __webpack_require__(63290);
-const { compareSelect, compareStringsNumeric } = __webpack_require__(29579);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("compat get default export");
+	}
 
-/**
- * @param {ExportsInfo} exportsInfo exports info
- * @returns {boolean} mangle is possible
- */
-const canMangle = exportsInfo => {
-	if (exportsInfo.otherExportsInfo.getUsed(undefined) !== UsageState.Unused)
-		return false;
-	let hasSomethingToMangle = false;
-	for (const exportInfo of exportsInfo.exports) {
-		if (exportInfo.canMangle === true) {
-			hasSomethingToMangle = true;
-		}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.compatGetDefaultExport;
+		return Template.asString([
+			"// getDefaultExport function for compatibility with non-harmony modules",
+			`${fn} = ${runtimeTemplate.basicFunction("module", [
+				"var getter = module && module.__esModule ?",
+				Template.indent([
+					`${runtimeTemplate.returningFunction("module['default']")} :`,
+					`${runtimeTemplate.returningFunction("module")};`
+				]),
+				`${RuntimeGlobals.definePropertyGetters}(getter, { a: getter });`,
+				"return getter;"
+			])};`
+		]);
 	}
-	return hasSomethingToMangle;
-};
+}
 
-// Sort by name
-const comparator = compareSelect(e => e.name, compareStringsNumeric);
-/**
- * @param {boolean} deterministic use deterministic names
- * @param {ExportsInfo} exportsInfo exports info
- * @param {boolean} isNamespace is namespace object
- * @returns {void}
- */
-const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
-	if (!canMangle(exportsInfo)) return;
-	const usedNames = new Set();
-	/** @type {ExportInfo[]} */
-	const mangleableExports = [];
+module.exports = CompatGetDefaultExportRuntimeModule;
 
-	// Avoid to renamed exports that are not provided when
-	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
-	// 2. there are other provided exports and deterministic mode is chosen:
-	//    non-provided exports would break the determinism
-	let avoidMangleNonProvided = !isNamespace;
-	if (!avoidMangleNonProvided && deterministic) {
-		for (const exportInfo of exportsInfo.ownedExports) {
-			if (exportInfo.provided !== false) {
-				avoidMangleNonProvided = true;
-				break;
-			}
-		}
+
+/***/ }),
+
+/***/ 88234:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+/** @typedef {import("../MainTemplate")} MainTemplate */
+
+class CompatRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("compat", RuntimeModule.STAGE_ATTACH);
+		this.fullHash = true;
 	}
-	for (const exportInfo of exportsInfo.ownedExports) {
-		const name = exportInfo.name;
-		if (!exportInfo.hasUsedName()) {
-			if (
-				// Can the export be mangled?
-				exportInfo.canMangle !== true ||
-				// Never rename 1 char exports
-				(name.length === 1 && /^[a-zA-Z0-9_$]/.test(name)) ||
-				// Don't rename 2 char exports in deterministic mode
-				(deterministic &&
-					name.length === 2 &&
-					/^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
-				// Don't rename exports that are not provided
-				(avoidMangleNonProvided && exportInfo.provided !== true)
-			) {
-				exportInfo.setUsedName(name);
-				usedNames.add(name);
-			} else {
-				mangleableExports.push(exportInfo);
-			}
-		}
-		if (exportInfo.exportsInfoOwned) {
-			const used = exportInfo.getUsed(undefined);
-			if (
-				used === UsageState.OnlyPropertiesUsed ||
-				used === UsageState.Unused
-			) {
-				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
-			}
-		}
-	}
-	if (deterministic) {
-		assignDeterministicIds(
-			mangleableExports,
-			e => e.name,
-			comparator,
-			(e, id) => {
-				const name = numberToIdentifier(id);
-				const size = usedNames.size;
-				usedNames.add(name);
-				if (size === usedNames.size) return false;
-				e.setUsedName(name);
-				return true;
-			},
-			[
-				NUMBER_OF_IDENTIFIER_START_CHARS,
-				NUMBER_OF_IDENTIFIER_START_CHARS *
-					NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS
-			],
-			NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS,
-			usedNames.size
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, chunk, compilation } = this;
+		const {
+			runtimeTemplate,
+			mainTemplate,
+			moduleTemplates,
+			dependencyTemplates
+		} = compilation;
+		const bootstrap = mainTemplate.hooks.bootstrap.call(
+			"",
+			chunk,
+			compilation.hash || "XXXX",
+			moduleTemplates.javascript,
+			dependencyTemplates
 		);
-	} else {
-		const usedExports = [];
-		const unusedExports = [];
-		for (const exportInfo of mangleableExports) {
-			if (exportInfo.getUsed(undefined) === UsageState.Unused) {
-				unusedExports.push(exportInfo);
-			} else {
-				usedExports.push(exportInfo);
-			}
-		}
-		usedExports.sort(comparator);
-		unusedExports.sort(comparator);
-		let i = 0;
-		for (const list of [usedExports, unusedExports]) {
-			for (const exportInfo of list) {
-				let name;
-				do {
-					name = numberToIdentifier(i++);
-				} while (usedNames.has(name));
-				exportInfo.setUsedName(name);
+		const localVars = mainTemplate.hooks.localVars.call(
+			"",
+			chunk,
+			compilation.hash || "XXXX"
+		);
+		const requireExtensions = mainTemplate.hooks.requireExtensions.call(
+			"",
+			chunk,
+			compilation.hash || "XXXX"
+		);
+		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
+		let requireEnsure = "";
+		if (runtimeRequirements.has(RuntimeGlobals.ensureChunk)) {
+			const requireEnsureHandler = mainTemplate.hooks.requireEnsure.call(
+				"",
+				chunk,
+				compilation.hash || "XXXX",
+				"chunkId"
+			);
+			if (requireEnsureHandler) {
+				requireEnsure = `${
+					RuntimeGlobals.ensureChunkHandlers
+				}.compat = ${runtimeTemplate.basicFunction(
+					"chunkId, promises",
+					requireEnsureHandler
+				)};`;
 			}
 		}
+		return [bootstrap, localVars, requireEnsure, requireExtensions]
+			.filter(Boolean)
+			.join("\n");
 	}
-};
 
-class MangleExportsPlugin {
 	/**
-	 * @param {boolean} deterministic use deterministic names
-	 */
-	constructor(deterministic) {
-		this._deterministic = deterministic;
-	}
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
-	apply(compiler) {
-		const { _deterministic: deterministic } = this;
-		compiler.hooks.compilation.tap("MangleExportsPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			compilation.hooks.optimizeCodeGeneration.tap(
-				"MangleExportsPlugin",
-				modules => {
-					if (compilation.moduleMemCaches) {
-						throw new Error(
-							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
-						);
-					}
-					for (const module of modules) {
-						const isNamespace =
-							module.buildMeta && module.buildMeta.exportsType === "namespace";
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
-					}
-				}
-			);
-		});
+	shouldIsolate() {
+		// We avoid isolating this to have better backward-compat
+		return false;
 	}
 }
 
-module.exports = MangleExportsPlugin;
+module.exports = CompatRuntimeModule;
 
 
 /***/ }),
 
-/***/ 85067:
+/***/ 94669:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { STAGE_BASIC } = __webpack_require__(80057);
-const { runtimeEqual } = __webpack_require__(17156);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-/** @typedef {import("../Compiler")} Compiler */
+class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("create fake namespace object");
+	}
 
-class MergeDuplicateChunksPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"MergeDuplicateChunksPlugin",
-			compilation => {
-				compilation.hooks.optimizeChunks.tap(
-					{
-						name: "MergeDuplicateChunksPlugin",
-						stage: STAGE_BASIC
-					},
-					chunks => {
-						const { chunkGraph, moduleGraph } = compilation;
-
-						// 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 chunkGraph.getChunkModulesIterable(chunk)) {
-								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 chunkGraph.getModuleChunksIterable(
-										module
-									)) {
-										if (
-											dup !== chunk &&
-											chunkGraph.getNumberOfChunkModules(chunk) ===
-												chunkGraph.getNumberOfChunkModules(dup) &&
-											!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 (!chunkGraph.isModuleInChunk(module, dup)) {
-											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
-							) {
-								outer: for (const otherChunk of possibleDuplicates) {
-									if (otherChunk.hasRuntime() !== chunk.hasRuntime()) continue;
-									if (chunkGraph.getNumberOfEntryModules(chunk) > 0) continue;
-									if (chunkGraph.getNumberOfEntryModules(otherChunk) > 0)
-										continue;
-									if (!runtimeEqual(chunk.runtime, otherChunk.runtime)) {
-										for (const module of chunkGraph.getChunkModulesIterable(
-											chunk
-										)) {
-											const exportsInfo = moduleGraph.getExportsInfo(module);
-											if (
-												!exportsInfo.isEquallyUsed(
-													chunk.runtime,
-													otherChunk.runtime
-												)
-											) {
-												continue outer;
-											}
-										}
-									}
-									// merge them
-									if (chunkGraph.canChunksBeIntegrated(chunk, otherChunk)) {
-										chunkGraph.integrateChunks(chunk, otherChunk);
-										compilation.chunks.delete(otherChunk);
-									}
-								}
-							}
-
-							// don't check already processed chunks twice
-							notDuplicates.add(chunk);
-						}
-					}
-				);
-			}
-		);
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.createFakeNamespaceObject;
+		return Template.asString([
+			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
+				"Object.getPrototypeOf(obj)",
+				"obj"
+			)} : ${runtimeTemplate.returningFunction("obj.__proto__", "obj")};`,
+			"var leafPrototypes;",
+			"// create a fake namespace object",
+			"// mode & 1: value is a module id, require it",
+			"// mode & 2: merge all properties of value into the ns",
+			"// mode & 4: return value when already ns object",
+			"// mode & 16: return value when it's Promise-like",
+			"// mode & 8|1: behave like require",
+			// Note: must be a function (not arrow), because this is used in body!
+			`${fn} = function(value, mode) {`,
+			Template.indent([
+				`if(mode & 1) value = this(value);`,
+				`if(mode & 8) return value;`,
+				"if(typeof value === 'object' && value) {",
+				Template.indent([
+					"if((mode & 4) && value.__esModule) return value;",
+					"if((mode & 16) && typeof value.then === 'function') return value;"
+				]),
+				"}",
+				"var ns = Object.create(null);",
+				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
+				"var def = {};",
+				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
+				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
+				Template.indent([
+					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
+						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,
+						"key"
+					)});`
+				]),
+				"}",
+				`def['default'] = ${runtimeTemplate.returningFunction("value", "")};`,
+				`${RuntimeGlobals.definePropertyGetters}(ns, def);`,
+				"return ns;"
+			]),
+			"};"
+		]);
 	}
 }
-module.exports = MergeDuplicateChunksPlugin;
+
+module.exports = CreateFakeNamespaceObjectRuntimeModule;
 
 
 /***/ }),
 
-/***/ 53912:
+/***/ 2759:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const createSchemaValidation = __webpack_require__(32540);
-
-/** @typedef {import("../../declarations/plugins/optimize/MinChunkSizePlugin").MinChunkSizePluginOptions} MinChunkSizePluginOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-const validate = createSchemaValidation(
-	__webpack_require__(60135),
-	() => __webpack_require__(53850),
-	{
-		name: "Min Chunk Size Plugin",
-		baseDataPath: "options"
+class CreateScriptRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("trusted types script");
 	}
-);
 
-class MinChunkSizePlugin {
 	/**
-	 * @param {MinChunkSizePluginOptions} options options object
+	 * @returns {string} runtime code
 	 */
-	constructor(options) {
-		validate(options);
-		this.options = options;
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.createScript;
+
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)`
+					: "script",
+				"script"
+			)};`
+		);
 	}
+}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const options = this.options;
-		const minChunkSize = options.minChunkSize;
-		compiler.hooks.compilation.tap("MinChunkSizePlugin", compilation => {
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "MinChunkSizePlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					const chunkGraph = compilation.chunkGraph;
-					const equalOptions = {
-						chunkOverhead: 1,
-						entryChunkMultiplicator: 1
-					};
+module.exports = CreateScriptRuntimeModule;
 
-					const chunkSizesMap = new Map();
-					/** @type {[Chunk, Chunk][]} */
-					const combinations = [];
-					/** @type {Chunk[]} */
-					const smallChunks = [];
-					const visitedChunks = [];
-					for (const a of chunks) {
-						// check if one of the chunks sizes is smaller than the minChunkSize
-						// and filter pairs that can NOT be integrated!
-						if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
-							smallChunks.push(a);
-							for (const b of visitedChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
-									combinations.push([b, a]);
-							}
-						} else {
-							for (const b of smallChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
-									combinations.push([b, a]);
-							}
-						}
-						chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
-						visitedChunks.push(a);
-					}
 
-					const sortedSizeFilteredExtendedPairCombinations = combinations
-						.map(pair => {
-							// extend combination pairs with size and integrated size
-							const a = chunkSizesMap.get(pair[0]);
-							const b = chunkSizesMap.get(pair[1]);
-							const ab = chunkGraph.getIntegratedChunksSize(
-								pair[0],
-								pair[1],
-								options
-							);
-							/** @type {[number, number, Chunk, Chunk]} */
-							const extendedPair = [a + b - ab, ab, pair[0], pair[1]];
-							return extendedPair;
-						})
-						.sort((a, b) => {
-							// sadly javascript does an in place 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;
+/***/ 21213:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					const pair = sortedSizeFilteredExtendedPairCombinations[0];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-					chunkGraph.integrateChunks(pair[2], pair[3]);
-					compilation.chunks.delete(pair[3]);
-					return true;
-				}
-			);
-		});
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("trusted types script url");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.createScriptUrl;
+
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScriptURL(url)`
+					: "url",
+				"url"
+			)};`
+		);
 	}
 }
-module.exports = MinChunkSizePlugin;
+
+module.exports = CreateScriptUrlRuntimeModule;
 
 
 /***/ }),
 
-/***/ 85305:
+/***/ 75481:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const SizeFormatHelpers = __webpack_require__(71070);
-const WebpackError = __webpack_require__(53799);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-class MinMaxSizeWarning extends WebpackError {
-	constructor(keys, minSize, maxSize) {
-		let keysMessage = "Fallback cache group";
-		if (keys) {
-			keysMessage =
-				keys.length > 1
-					? `Cache groups ${keys.sort().join(", ")}`
-					: `Cache group ${keys[0]}`;
-		}
-		super(
-			`SplitChunksPlugin\n` +
-				`${keysMessage}\n` +
-				`Configured minSize (${SizeFormatHelpers.formatSize(minSize)}) is ` +
-				`bigger than maxSize (${SizeFormatHelpers.formatSize(maxSize)}).\n` +
-				"This seem to be a invalid optimization.splitChunks configuration."
-		);
+class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("define property getters");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.definePropertyGetters;
+		return Template.asString([
+			"// define getter functions for harmony exports",
+			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
+				`for(var key in definition) {`,
+				Template.indent([
+					`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+					Template.indent([
+						"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
+					]),
+					"}"
+				]),
+				"}"
+			])};`
+		]);
 	}
 }
 
-module.exports = MinMaxSizeWarning;
+module.exports = DefinePropertyGettersRuntimeModule;
 
 
 /***/ }),
 
-/***/ 74844:
+/***/ 71519:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const asyncLib = __webpack_require__(78175);
-const ChunkGraph = __webpack_require__(64971);
-const ModuleGraph = __webpack_require__(99988);
-const { STAGE_DEFAULT } = __webpack_require__(80057);
-const HarmonyImportDependency = __webpack_require__(57154);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const {
-	intersectRuntime,
-	mergeRuntimeOwned,
-	filterRuntime,
-	runtimeToString,
-	mergeRuntime
-} = __webpack_require__(17156);
-const ConcatenatedModule = __webpack_require__(97198);
-
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-/**
- * @typedef {Object} Statistics
- * @property {number} cached
- * @property {number} alreadyInConfig
- * @property {number} invalidModule
- * @property {number} incorrectChunks
- * @property {number} incorrectDependency
- * @property {number} incorrectModuleDependency
- * @property {number} incorrectChunksOfImporter
- * @property {number} incorrectRuntimeCondition
- * @property {number} importerFailed
- * @property {number} added
- */
-
-const formatBailoutReason = msg => {
-	return "ModuleConcatenation bailout: " + msg;
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-class ModuleConcatenationPlugin {
-	constructor(options) {
-		if (typeof options !== "object") options = {};
-		this.options = options;
+class EnsureChunkRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("ensure chunk");
+		this.runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		const { _backCompat: backCompat } = compiler;
-		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
-			const moduleGraph = compilation.moduleGraph;
-			const bailoutReasonMap = new Map();
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		// Check if there are non initial chunks which need to be imported using require-ensure
+		if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			const handlers = RuntimeGlobals.ensureChunkHandlers;
+			return Template.asString([
+				`${handlers} = {};`,
+				"// This file contains only the entry chunk.",
+				"// The chunk loading function for additional chunks",
+				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
+					"chunkId",
+					[
+						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
+							"promises, key",
+							[`${handlers}[key](chunkId, promises);`, "return promises;"]
+						)}, []));`
+					]
+				)};`
+			]);
+		} else {
+			// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
+			// function. This can happen with multiple entrypoints.
+			return Template.asString([
+				"// The chunk loading function for additional chunks",
+				"// Since all referenced chunks are already included",
+				"// in this file, this function is empty here.",
+				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
+					"Promise.resolve()"
+				)};`
+			]);
+		}
+	}
+}
 
-			const setBailoutReason = (module, reason) => {
-				setInnerBailoutReason(module, reason);
-				moduleGraph
-					.getOptimizationBailout(module)
-					.push(
-						typeof reason === "function"
-							? rs => formatBailoutReason(reason(rs))
-							: formatBailoutReason(reason)
-					);
-			};
+module.exports = EnsureChunkRuntimeModule;
 
-			const setInnerBailoutReason = (module, reason) => {
-				bailoutReasonMap.set(module, reason);
-			};
 
-			const getInnerBailoutReason = (module, requestShortener) => {
-				const reason = bailoutReasonMap.get(module);
-				if (typeof reason === "function") return reason(requestShortener);
-				return reason;
-			};
+/***/ }),
 
-			const formatBailoutWarning = (module, problem) => requestShortener => {
-				if (typeof problem === "function") {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)}: ${problem(requestShortener)}`
-					);
-				}
-				const reason = getInnerBailoutReason(module, requestShortener);
-				const reasonWithPrefix = reason ? `: ${reason}` : "";
-				if (module === problem) {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)}${reasonWithPrefix}`
-					);
-				} else {
-					return formatBailoutReason(
-						`Cannot concat with ${module.readableIdentifier(
-							requestShortener
-						)} because of ${problem.readableIdentifier(
-							requestShortener
-						)}${reasonWithPrefix}`
-					);
-				}
-			};
+/***/ 34277:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			compilation.hooks.optimizeChunkModules.tapAsync(
-				{
-					name: "ModuleConcatenationPlugin",
-					stage: STAGE_DEFAULT
-				},
-				(allChunks, modules, callback) => {
-					const logger = compilation.getLogger(
-						"webpack.ModuleConcatenationPlugin"
-					);
-					const { chunkGraph, moduleGraph } = compilation;
-					const relevantModules = [];
-					const possibleInners = new Set();
-					const context = {
-						chunkGraph,
-						moduleGraph
-					};
-					logger.time("select relevant modules");
-					for (const module of modules) {
-						let canBeRoot = true;
-						let canBeInner = true;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-						const bailoutReason = module.getConcatenationBailoutReason(context);
-						if (bailoutReason) {
-							setBailoutReason(module, bailoutReason);
-							continue;
-						}
 
-						// Must not be an async module
-						if (moduleGraph.isAsync(module)) {
-							setBailoutReason(module, `Module is async`);
-							continue;
-						}
 
-						// Must be in strict mode
-						if (!module.buildInfo.strict) {
-							setBailoutReason(module, `Module is not in strict mode`);
-							continue;
-						}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const { first } = __webpack_require__(93347);
 
-						// Module must be in any chunk (we don't want to do useless work)
-						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
-							setBailoutReason(module, "Module is not in any chunk");
-							continue;
-						}
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").PathData} PathData */
 
-						// Exports must be known (and not dynamic)
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						const relevantExports = exportsInfo.getRelevantExports(undefined);
-						const unknownReexports = relevantExports.filter(exportInfo => {
-							return (
-								exportInfo.isReexport() && !exportInfo.getTarget(moduleGraph)
-							);
-						});
-						if (unknownReexports.length > 0) {
-							setBailoutReason(
-								module,
-								`Reexports in this module do not have a static target (${Array.from(
-									unknownReexports,
-									exportInfo =>
-										`${
-											exportInfo.name || "other exports"
-										}: ${exportInfo.getUsedInfo()}`
-								).join(", ")})`
-							);
-							continue;
-						}
+/** @typedef {function(PathData, AssetInfo=): string} FilenameFunction */
 
-						// Root modules must have a static list of exports
-						const unknownProvidedExports = relevantExports.filter(
-							exportInfo => {
-								return exportInfo.provided !== true;
-							}
-						);
-						if (unknownProvidedExports.length > 0) {
-							setBailoutReason(
-								module,
-								`List of module exports is dynamic (${Array.from(
-									unknownProvidedExports,
-									exportInfo =>
-										`${
-											exportInfo.name || "other exports"
-										}: ${exportInfo.getProvidedInfo()} and ${exportInfo.getUsedInfo()}`
-								).join(", ")})`
-							);
-							canBeRoot = false;
-						}
+class GetChunkFilenameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} contentType the contentType to use the content hash for
+	 * @param {string} name kind of filename
+	 * @param {string} global function name to be assigned
+	 * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
+	 * @param {boolean} allChunks when false, only async chunks are included
+	 */
+	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
+		super(`get ${name} chunk filename`);
+		this.contentType = contentType;
+		this.global = global;
+		this.getFilenameForChunk = getFilenameForChunk;
+		this.allChunks = allChunks;
+		this.dependentHash = true;
+	}
 
-						// Module must not be an entry point
-						if (chunkGraph.isEntryModule(module)) {
-							setInnerBailoutReason(module, "Module is an entry point");
-							canBeInner = false;
-						}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const {
+			global,
+			chunk,
+			chunkGraph,
+			contentType,
+			getFilenameForChunk,
+			allChunks,
+			compilation
+		} = this;
+		const { runtimeTemplate } = compilation;
 
-						if (canBeRoot) relevantModules.push(module);
-						if (canBeInner) possibleInners.add(module);
+		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
+		const chunkFilenames = new Map();
+		let maxChunks = 0;
+		/** @type {string} */
+		let dynamicFilename;
+
+		/**
+		 * @param {Chunk} c the chunk
+		 * @returns {void}
+		 */
+		const addChunk = c => {
+			const chunkFilename = getFilenameForChunk(c);
+			if (chunkFilename) {
+				let set = chunkFilenames.get(chunkFilename);
+				if (set === undefined) {
+					chunkFilenames.set(chunkFilename, (set = new Set()));
+				}
+				set.add(c);
+				if (typeof chunkFilename === "string") {
+					if (set.size < maxChunks) return;
+					if (set.size === maxChunks) {
+						if (chunkFilename.length < dynamicFilename.length) return;
+						if (chunkFilename.length === dynamicFilename.length) {
+							if (chunkFilename < dynamicFilename) return;
+						}
 					}
-					logger.timeEnd("select relevant modules");
-					logger.debug(
-						`${relevantModules.length} potential root modules, ${possibleInners.size} potential inner modules`
-					);
-					// sort by depth
-					// modules with lower depth are more likely suited as roots
-					// this improves performance, because modules already selected as inner are skipped
-					logger.time("sort relevant modules");
-					relevantModules.sort((a, b) => {
-						return moduleGraph.getDepth(a) - moduleGraph.getDepth(b);
-					});
-					logger.timeEnd("sort relevant modules");
+					maxChunks = set.size;
+					dynamicFilename = chunkFilename;
+				}
+			}
+		};
 
-					/** @type {Statistics} */
-					const stats = {
-						cached: 0,
-						alreadyInConfig: 0,
-						invalidModule: 0,
-						incorrectChunks: 0,
-						incorrectDependency: 0,
-						incorrectModuleDependency: 0,
-						incorrectChunksOfImporter: 0,
-						incorrectRuntimeCondition: 0,
-						importerFailed: 0,
-						added: 0
-					};
-					let statsCandidates = 0;
-					let statsSizeSum = 0;
-					let statsEmptyConfigurations = 0;
+		/** @type {string[]} */
+		const includedChunksMessages = [];
+		if (allChunks) {
+			includedChunksMessages.push("all chunks");
+			for (const c of chunk.getAllReferencedChunks()) {
+				addChunk(c);
+			}
+		} else {
+			includedChunksMessages.push("async chunks");
+			for (const c of chunk.getAllAsyncChunks()) {
+				addChunk(c);
+			}
+			const includeEntries = chunkGraph
+				.getTreeRuntimeRequirements(chunk)
+				.has(RuntimeGlobals.ensureChunkIncludeEntries);
+			if (includeEntries) {
+				includedChunksMessages.push("sibling chunks for the entrypoint");
+				for (const c of chunkGraph.getChunkEntryDependentChunksIterable(
+					chunk
+				)) {
+					addChunk(c);
+				}
+			}
+		}
+		for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {
+			addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
+		}
 
-					logger.time("find modules to concatenate");
-					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
-						// TODO reconsider that when it's only used in a different runtime
-						if (usedAsInner.has(currentRoot)) continue;
+		/** @type {Map<string, Set<string | number>>} */
+		const staticUrls = new Map();
+		/** @type {Set<Chunk>} */
+		const dynamicUrlChunks = new Set();
 
-						let chunkRuntime = undefined;
-						for (const r of chunkGraph.getModuleRuntimes(currentRoot)) {
-							chunkRuntime = mergeRuntimeOwned(chunkRuntime, r);
-						}
-						const exportsInfo = moduleGraph.getExportsInfo(currentRoot);
-						const filteredRuntime = filterRuntime(chunkRuntime, r =>
-							exportsInfo.isModuleUsed(r)
-						);
-						const activeRuntime =
-							filteredRuntime === true
-								? chunkRuntime
-								: filteredRuntime === false
-								? undefined
-								: filteredRuntime;
+		/**
+		 * @param {Chunk} c the chunk
+		 * @param {string | FilenameFunction} chunkFilename the filename template for the chunk
+		 * @returns {void}
+		 */
+		const addStaticUrl = (c, chunkFilename) => {
+			/**
+			 * @param {string | number} value a value
+			 * @returns {string} string to put in quotes
+			 */
+			const unquotedStringify = value => {
+				const str = `${value}`;
+				if (str.length >= 5 && str === `${c.id}`) {
+					// This is shorter and generates the same result
+					return '" + chunkId + "';
+				}
+				const s = JSON.stringify(str);
+				return s.slice(1, s.length - 1);
+			};
+			const unquotedStringifyWithLength = value => length =>
+				unquotedStringify(`${value}`.slice(0, length));
+			const chunkFilenameValue =
+				typeof chunkFilename === "function"
+					? JSON.stringify(
+							chunkFilename({
+								chunk: c,
+								contentHashType: contentType
+							})
+					  )
+					: JSON.stringify(chunkFilename);
+			const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				chunk: {
+					id: unquotedStringify(c.id),
+					hash: unquotedStringify(c.renderedHash),
+					hashWithLength: unquotedStringifyWithLength(c.renderedHash),
+					name: unquotedStringify(c.name || c.id),
+					contentHash: {
+						[contentType]: unquotedStringify(c.contentHash[contentType])
+					},
+					contentHashWithLength: {
+						[contentType]: unquotedStringifyWithLength(
+							c.contentHash[contentType]
+						)
+					}
+				},
+				contentHashType: contentType
+			});
+			let set = staticUrls.get(staticChunkFilename);
+			if (set === undefined) {
+				staticUrls.set(staticChunkFilename, (set = new Set()));
+			}
+			set.add(c.id);
+		};
 
-						// create a configuration with the root
-						const currentConfiguration = new ConcatConfiguration(
-							currentRoot,
-							activeRuntime
-						);
+		for (const [filename, chunks] of chunkFilenames) {
+			if (filename !== dynamicFilename) {
+				for (const c of chunks) addStaticUrl(c, filename);
+			} else {
+				for (const c of chunks) dynamicUrlChunks.add(c);
+			}
+		}
 
-						// cache failures to add modules
-						const failureCache = new Map();
+		/**
+		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @returns {string} code with static mapping of results of fn
+		 */
+		const createMap = fn => {
+			const obj = {};
+			let useId = false;
+			let lastKey;
+			let entries = 0;
+			for (const c of dynamicUrlChunks) {
+				const value = fn(c);
+				if (value === c.id) {
+					useId = true;
+				} else {
+					obj[c.id] = value;
+					lastKey = c.id;
+					entries++;
+				}
+			}
+			if (entries === 0) return "chunkId";
+			if (entries === 1) {
+				return useId
+					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
+							obj[lastKey]
+					  )} : chunkId)`
+					: JSON.stringify(obj[lastKey]);
+			}
+			return useId
+				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
+				: `${JSON.stringify(obj)}[chunkId]`;
+		};
 
-						// potential optional import candidates
-						/** @type {Set<Module>} */
-						const candidates = new Set();
+		/**
+		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @returns {string} code with static mapping of results of fn for including in quoted string
+		 */
+		const mapExpr = fn => {
+			return `" + ${createMap(fn)} + "`;
+		};
 
-						// try to add all imports
-						for (const imp of this._getImports(
-							compilation,
-							currentRoot,
-							activeRuntime
-						)) {
-							candidates.add(imp);
-						}
+		/**
+		 * @param {function(Chunk): string | number} fn function from chunk to value
+		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
+		 */
+		const mapExprWithLength = fn => length => {
+			return `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
+		};
 
-						for (const imp of candidates) {
-							const impCandidates = new Set();
-							const problem = this._tryToAdd(
-								compilation,
-								currentConfiguration,
-								imp,
-								chunkRuntime,
-								activeRuntime,
-								possibleInners,
-								impCandidates,
-								failureCache,
-								chunkGraph,
-								true,
-								stats
-							);
-							if (problem) {
-								failureCache.set(imp, problem);
-								currentConfiguration.addWarning(imp, problem);
-							} else {
-								for (const c of impCandidates) {
-									candidates.add(c);
-								}
-							}
-						}
-						statsCandidates += candidates.size;
-						if (!currentConfiguration.isEmpty()) {
-							const modules = currentConfiguration.getModules();
-							statsSizeSum += modules.size;
-							concatConfigurations.push(currentConfiguration);
-							for (const module of modules) {
-								if (module !== currentConfiguration.rootModule) {
-									usedAsInner.add(module);
-								}
-							}
-						} else {
-							statsEmptyConfigurations++;
-							const optimizationBailouts =
-								moduleGraph.getOptimizationBailout(currentRoot);
-							for (const warning of currentConfiguration.getWarningsSorted()) {
-								optimizationBailouts.push(
-									formatBailoutWarning(warning[0], warning[1])
-								);
-							}
-						}
+		const url =
+			dynamicFilename &&
+			compilation.getPath(JSON.stringify(dynamicFilename), {
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+				chunk: {
+					id: `" + chunkId + "`,
+					hash: mapExpr(c => c.renderedHash),
+					hashWithLength: mapExprWithLength(c => c.renderedHash),
+					name: mapExpr(c => c.name || c.id),
+					contentHash: {
+						[contentType]: mapExpr(c => c.contentHash[contentType])
+					},
+					contentHashWithLength: {
+						[contentType]: mapExprWithLength(c => c.contentHash[contentType])
 					}
-					logger.timeEnd("find modules to concatenate");
-					logger.debug(
-						`${
-							concatConfigurations.length
-						} successful concat configurations (avg size: ${
-							statsSizeSum / concatConfigurations.length
-						}), ${statsEmptyConfigurations} bailed out completely`
-					);
-					logger.debug(
-						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
-					);
-					// HACK: Sort configurations by length and start with the longest one
-					// to get the biggest 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)
-					logger.time(`sort concat configurations`);
-					concatConfigurations.sort((a, b) => {
-						return b.modules.size - a.modules.size;
-					});
-					logger.timeEnd(`sort concat configurations`);
-					const usedModules = new Set();
+				},
+				contentHashType: contentType
+			});
 
-					logger.time("create concatenated modules");
-					asyncLib.each(
-						concatConfigurations,
-						(concatConfiguration, callback) => {
-							const rootModule = concatConfiguration.rootModule;
+		return Template.asString([
+			`// This function allow to reference ${includedChunksMessages.join(
+				" and "
+			)}`,
+			`${global} = ${runtimeTemplate.basicFunction(
+				"chunkId",
 
-							// Avoid overlapping configurations
-							// TODO: remove this when todo above is fixed
-							if (usedModules.has(rootModule)) return callback();
-							const modules = concatConfiguration.getModules();
-							for (const m of modules) {
-								usedModules.add(m);
-							}
+				staticUrls.size > 0
+					? [
+							"// return url for filenames not based on template",
+							// it minimizes to `x===1?"...":x===2?"...":"..."`
+							Template.asString(
+								Array.from(staticUrls, ([url, ids]) => {
+									const condition =
+										ids.size === 1
+											? `chunkId === ${JSON.stringify(first(ids))}`
+											: `{${Array.from(
+													ids,
+													id => `${JSON.stringify(id)}:1`
+											  ).join(",")}}[chunkId]`;
+									return `if (${condition}) return ${url};`;
+								})
+							),
+							"// return url for filenames based on template",
+							`return ${url};`
+					  ]
+					: ["// return url for filenames based on template", `return ${url};`]
+			)};`
+		]);
+	}
+}
 
-							// Create a new ConcatenatedModule
-							let newModule = ConcatenatedModule.create(
-								rootModule,
-								modules,
-								concatConfiguration.runtime,
-								compiler.root,
-								compilation.outputOptions.hashFunction
-							);
+module.exports = GetChunkFilenameRuntimeModule;
 
-							const build = () => {
-								newModule.build(
-									compiler.options,
-									compilation,
-									null,
-									null,
-									err => {
-										if (err) {
-											if (!err.module) {
-												err.module = newModule;
-											}
-											return callback(err);
-										}
-										integrate();
-									}
-								);
-							};
 
-							const integrate = () => {
-								if (backCompat) {
-									ChunkGraph.setChunkGraphForModule(newModule, chunkGraph);
-									ModuleGraph.setModuleGraphForModule(newModule, moduleGraph);
-								}
+/***/ }),
 
-								for (const warning of concatConfiguration.getWarningsSorted()) {
-									moduleGraph
-										.getOptimizationBailout(newModule)
-										.push(formatBailoutWarning(warning[0], warning[1]));
-								}
-								moduleGraph.cloneModuleAttributes(rootModule, newModule);
-								for (const m of modules) {
-									// add to builtModules when one of the included modules was built
-									if (compilation.builtModules.has(m)) {
-										compilation.builtModules.add(newModule);
-									}
-									if (m !== rootModule) {
-										// attach external references to the concatenated module too
-										moduleGraph.copyOutgoingModuleConnections(
-											m,
-											newModule,
-											c => {
-												return (
-													c.originModule === m &&
-													!(
-														c.dependency instanceof HarmonyImportDependency &&
-														modules.has(c.module)
-													)
-												);
-											}
-										);
-										// remove module from chunk
-										for (const chunk of chunkGraph.getModuleChunksIterable(
-											rootModule
-										)) {
-											chunkGraph.disconnectChunkAndModule(chunk, m);
-										}
-									}
-								}
-								compilation.modules.delete(rootModule);
-								ChunkGraph.clearChunkGraphForModule(rootModule);
-								ModuleGraph.clearModuleGraphForModule(rootModule);
+/***/ 88732:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-								// remove module from chunk
-								chunkGraph.replaceModule(rootModule, newModule);
-								// replace module references with the concatenated module
-								moduleGraph.moveModuleConnections(rootModule, newModule, c => {
-									const otherModule =
-										c.module === rootModule ? c.originModule : c.module;
-									const innerConnection =
-										c.dependency instanceof HarmonyImportDependency &&
-										modules.has(otherModule);
-									return !innerConnection;
-								});
-								// add concatenated module to the compilation
-								compilation.modules.add(newModule);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-								callback();
-							};
 
-							build();
-						},
-						err => {
-							logger.timeEnd("create concatenated modules");
-							process.nextTick(callback.bind(null, err));
-						}
-					);
-				}
-			);
-		});
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class GetFullHashRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("getFullHash");
+		this.fullHash = true;
 	}
 
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @param {Module} module the module to be added
-	 * @param {RuntimeSpec} runtime the runtime scope
-	 * @returns {Set<Module>} the imported modules
+	 * @returns {string} runtime code
 	 */
-	_getImports(compilation, module, runtime) {
-		const moduleGraph = compilation.moduleGraph;
-		const set = new Set();
-		for (const dep of module.dependencies) {
-			// Get reference info only for harmony Dependencies
-			if (!(dep instanceof HarmonyImportDependency)) continue;
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(
+			JSON.stringify(this.compilation.hash || "XXXX")
+		)}`;
+	}
+}
 
-			const connection = moduleGraph.getConnection(dep);
-			// Reference is valid and has a module
-			if (
-				!connection ||
-				!connection.module ||
-				!connection.isTargetActive(runtime)
-			) {
-				continue;
-			}
+module.exports = GetFullHashRuntimeModule;
 
-			const importedNames = compilation.getDependencyReferencedExports(
-				dep,
-				undefined
-			);
 
-			if (
-				importedNames.every(i =>
-					Array.isArray(i) ? i.length > 0 : i.name.length > 0
-				) ||
-				Array.isArray(moduleGraph.getProvidedExports(module))
-			) {
-				set.add(connection.module);
-			}
-		}
-		return set;
+/***/ }),
+
+/***/ 10029:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class GetMainFilenameRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} name readable name
+	 * @param {string} global global object binding
+	 * @param {string} filename main file name
+	 */
+	constructor(name, global, filename) {
+		super(`get ${name} filename`);
+		this.global = global;
+		this.filename = filename;
 	}
 
 	/**
-	 * @param {Compilation} compilation webpack compilation
-	 * @param {ConcatConfiguration} config concat configuration (will be modified when added)
-	 * @param {Module} module the module to be added
-	 * @param {RuntimeSpec} runtime the runtime scope of the generated code
-	 * @param {RuntimeSpec} activeRuntime the runtime scope of the root module
-	 * @param {Set<Module>} possibleModules modules that are candidates
-	 * @param {Set<Module>} candidates list of potential candidates (will be added to)
-	 * @param {Map<Module, Module | function(RequestShortener): string>} failureCache cache for problematic modules to be more performant
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {boolean} avoidMutateOnFailure avoid mutating the config when adding fails
-	 * @param {Statistics} statistics gathering metrics
-	 * @returns {Module | function(RequestShortener): string} the problematic module
+	 * @returns {string} runtime code
 	 */
-	_tryToAdd(
-		compilation,
-		config,
-		module,
-		runtime,
-		activeRuntime,
-		possibleModules,
-		candidates,
-		failureCache,
-		chunkGraph,
-		avoidMutateOnFailure,
-		statistics
-	) {
-		const cacheEntry = failureCache.get(module);
-		if (cacheEntry) {
-			statistics.cached++;
-			return cacheEntry;
-		}
+	generate() {
+		const { global, filename, compilation, chunk } = this;
+		const { runtimeTemplate } = compilation;
+		const url = compilation.getPath(JSON.stringify(filename), {
+			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+			hashWithLength: length =>
+				`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+			chunk,
+			runtime: chunk.runtime
+		});
+		return Template.asString([
+			`${global} = ${runtimeTemplate.returningFunction(url)};`
+		]);
+	}
+}
 
-		// Already added?
-		if (config.has(module)) {
-			statistics.alreadyInConfig++;
-			return null;
-		}
+module.exports = GetMainFilenameRuntimeModule;
 
-		// Not possible to add?
-		if (!possibleModules.has(module)) {
-			statistics.invalidModule++;
-			failureCache.set(module, module); // cache failures for performance
-			return module;
-		}
 
-		// Module must be in the correct chunks
-		const missingChunks = Array.from(
-			chunkGraph.getModuleChunksIterable(config.rootModule)
-		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
-		if (missingChunks.length > 0) {
-			const problem = requestShortener => {
-				const missingChunksList = Array.from(
-					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
-				).sort();
-				const chunks = Array.from(
-					new Set(
-						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
-							chunk => chunk.name || "unnamed chunk(s)"
-						)
-					)
-				).sort();
-				return `Module ${module.readableIdentifier(
-					requestShortener
-				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
-					", "
-				)}, module is in chunk(s) ${chunks.join(", ")})`;
-			};
-			statistics.incorrectChunks++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
-		}
+/***/ }),
 
-		const moduleGraph = compilation.moduleGraph;
+/***/ 38713:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		const incomingConnections =
-			moduleGraph.getIncomingConnectionsByOriginModule(module);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-		const incomingConnectionsFromNonModules =
-			incomingConnections.get(null) || incomingConnections.get(undefined);
-		if (incomingConnectionsFromNonModules) {
-			const activeNonModulesConnections =
-				incomingConnectionsFromNonModules.filter(connection => {
-					// We are not interested in inactive connections
-					// or connections without dependency
-					return connection.isActive(runtime) || connection.dependency;
-				});
-			if (activeNonModulesConnections.length > 0) {
-				const problem = requestShortener => {
-					const importingExplanations = new Set(
-						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
-					);
-					const explanations = Array.from(importingExplanations).sort();
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is referenced ${
-						explanations.length > 0
-							? `by: ${explanations.join(", ")}`
-							: "in an unsupported way"
-					}`;
-				};
-				statistics.incorrectDependency++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
-			}
-		}
 
-		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
-		const incomingConnectionsFromModules = new Map();
-		for (const [originModule, connections] of incomingConnections) {
-			if (originModule) {
-				// Ignore connection from orphan modules
-				if (chunkGraph.getNumberOfModuleChunks(originModule) === 0) continue;
 
-				// We don't care for connections from other runtimes
-				let originRuntime = undefined;
-				for (const r of chunkGraph.getModuleRuntimes(originModule)) {
-					originRuntime = mergeRuntimeOwned(originRuntime, r);
-				}
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-				if (!intersectRuntime(runtime, originRuntime)) continue;
+class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
+	/**
+	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
+		super("trusted types policy");
+		this.runtimeRequirements = runtimeRequirements;
+	}
 
-				// We are not interested in inactive connections
-				const activeConnections = connections.filter(connection =>
-					connection.isActive(runtime)
-				);
-				if (activeConnections.length > 0)
-					incomingConnectionsFromModules.set(originModule, activeConnections);
-			}
-		}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.getTrustedTypesPolicy;
 
-		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
+		return Template.asString([
+			"var policy;",
+			`${fn} = ${runtimeTemplate.basicFunction("", [
+				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
+				"if (policy === undefined) {",
+				Template.indent([
+					"policy = {",
+					Template.indent(
+						[
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
+								? [
+										`createScript: ${runtimeTemplate.returningFunction(
+											"script",
+											"script"
+										)}`
+								  ]
+								: []),
+							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
+								? [
+										`createScriptURL: ${runtimeTemplate.returningFunction(
+											"url",
+											"url"
+										)}`
+								  ]
+								: [])
+						].join(",\n")
+					),
+					"};",
+					...(trustedTypes
+						? [
+								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
+								Template.indent([
+									`policy = trustedTypes.createPolicy(${JSON.stringify(
+										trustedTypes.policyName
+									)}, policy);`
+								]),
+								"}"
+						  ]
+						: [])
+				]),
+				"}",
+				"return policy;"
+			])};`
+		]);
+	}
+}
 
-		// Module must be in the same chunks like the referencing module
-		const otherChunkModules = incomingModules.filter(originModule => {
-			for (const chunk of chunkGraph.getModuleChunksIterable(
-				config.rootModule
-			)) {
-				if (!chunkGraph.isModuleInChunk(originModule, chunk)) {
-					return true;
-				}
-			}
-			return false;
-		});
-		if (otherChunkModules.length > 0) {
-			const problem = requestShortener => {
-				const names = otherChunkModules
-					.map(m => m.readableIdentifier(requestShortener))
-					.sort();
-				return `Module ${module.readableIdentifier(
-					requestShortener
-				)} is referenced from different chunks by these modules: ${names.join(
-					", "
-				)}`;
-			};
-			statistics.incorrectChunksOfImporter++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
-		}
+module.exports = GetTrustedTypesPolicyRuntimeModule;
 
-		/** @type {Map<Module, readonly ModuleGraph.ModuleGraphConnection[]>} */
-		const nonHarmonyConnections = new Map();
-		for (const [originModule, connections] of incomingConnectionsFromModules) {
-			const selected = connections.filter(
-				connection =>
-					!connection.dependency ||
-					!(connection.dependency instanceof HarmonyImportDependency)
-			);
-			if (selected.length > 0)
-				nonHarmonyConnections.set(originModule, connections);
-		}
-		if (nonHarmonyConnections.size > 0) {
-			const problem = requestShortener => {
-				const names = Array.from(nonHarmonyConnections)
-					.map(([originModule, connections]) => {
-						return `${originModule.readableIdentifier(
-							requestShortener
-						)} (referenced with ${Array.from(
-							new Set(
-								connections
-									.map(c => c.dependency && c.dependency.type)
-									.filter(Boolean)
-							)
-						)
-							.sort()
-							.join(", ")})`;
-					})
-					.sort();
-				return `Module ${module.readableIdentifier(
-					requestShortener
-				)} is referenced from these modules with unsupported syntax: ${names.join(
-					", "
-				)}`;
-			};
-			statistics.incorrectModuleDependency++;
-			failureCache.set(module, problem); // cache failures for performance
-			return problem;
-		}
 
-		if (runtime !== undefined && typeof runtime !== "string") {
-			// Module must be consistently referenced in the same runtimes
-			/** @type {{ originModule: Module, runtimeCondition: RuntimeSpec }[]} */
-			const otherRuntimeConnections = [];
-			outer: for (const [
-				originModule,
-				connections
-			] of incomingConnectionsFromModules) {
-				/** @type {false | RuntimeSpec} */
-				let currentRuntimeCondition = false;
-				for (const connection of connections) {
-					const runtimeCondition = filterRuntime(runtime, runtime => {
-						return connection.isTargetActive(runtime);
-					});
-					if (runtimeCondition === false) continue;
-					if (runtimeCondition === true) continue outer;
-					if (currentRuntimeCondition !== false) {
-						currentRuntimeCondition = mergeRuntime(
-							currentRuntimeCondition,
-							runtimeCondition
-						);
-					} else {
-						currentRuntimeCondition = runtimeCondition;
-					}
-				}
-				if (currentRuntimeCondition !== false) {
-					otherRuntimeConnections.push({
-						originModule,
-						runtimeCondition: currentRuntimeCondition
-					});
-				}
-			}
-			if (otherRuntimeConnections.length > 0) {
-				const problem = requestShortener => {
-					return `Module ${module.readableIdentifier(
-						requestShortener
-					)} is runtime-dependent referenced by these modules: ${Array.from(
-						otherRuntimeConnections,
-						({ originModule, runtimeCondition }) =>
-							`${originModule.readableIdentifier(
-								requestShortener
-							)} (expected runtime ${runtimeToString(
-								runtime
-							)}, module is only referenced in ${runtimeToString(
-								/** @type {RuntimeSpec} */ (runtimeCondition)
-							)})`
-					).join(", ")}`;
-				};
-				statistics.incorrectRuntimeCondition++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
-			}
-		}
+/***/ }),
 
-		let backup;
-		if (avoidMutateOnFailure) {
-			backup = config.snapshot();
-		}
+/***/ 23255:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		// Add the module
-		config.add(module);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-		incomingModules.sort(compareModulesByIdentifier);
 
-		// Every module which depends on the added module must be in the configuration too.
-		for (const originModule of incomingModules) {
-			const problem = this._tryToAdd(
-				compilation,
-				config,
-				originModule,
-				runtime,
-				activeRuntime,
-				possibleModules,
-				candidates,
-				failureCache,
-				chunkGraph,
-				false,
-				statistics
-			);
-			if (problem) {
-				if (backup !== undefined) config.rollback(backup);
-				statistics.importerFailed++;
-				failureCache.set(module, problem); // cache failures for performance
-				return problem;
-			}
-		}
 
-		// Add imports to possible candidates list
-		for (const imp of this._getImports(compilation, module, runtime)) {
-			candidates.add(imp);
-		}
-		statistics.added++;
-		return null;
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+class GlobalRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("global");
 	}
-}
 
-class ConcatConfiguration {
 	/**
-	 * @param {Module} rootModule the root module
-	 * @param {RuntimeSpec} runtime the runtime
+	 * @returns {string} runtime code
 	 */
-	constructor(rootModule, runtime) {
-		this.rootModule = rootModule;
-		this.runtime = runtime;
-		/** @type {Set<Module>} */
-		this.modules = new Set();
-		this.modules.add(rootModule);
-		/** @type {Map<Module, Module | function(RequestShortener): string>} */
-		this.warnings = new Map();
+	generate() {
+		return Template.asString([
+			`${RuntimeGlobals.global} = (function() {`,
+			Template.indent([
+				"if (typeof globalThis === 'object') return globalThis;",
+				"try {",
+				Template.indent(
+					// This works in non-strict mode
+					// or
+					// This works if eval is allowed (see CSP)
+					"return this || new Function('return this')();"
+				),
+				"} catch (e) {",
+				Template.indent(
+					// This works if the window reference is available
+					"if (typeof window === 'object') return window;"
+				),
+				"}"
+				// It can still be `undefined`, but nothing to do about it...
+				// We return `undefined`, instead of nothing here, so it's
+				// easier to handle this case:
+				//   if (!global) { … }
+			]),
+			"})();"
+		]);
 	}
+}
 
-	add(module) {
-		this.modules.add(module);
-	}
+module.exports = GlobalRuntimeModule;
 
-	has(module) {
-		return this.modules.has(module);
-	}
 
-	isEmpty() {
-		return this.modules.size === 1;
-	}
+/***/ }),
 
-	addWarning(module, problem) {
-		this.warnings.set(module, problem);
-	}
+/***/ 8011:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	getWarningsSorted() {
-		return new Map(
-			Array.from(this.warnings).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;
-			})
-		);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sergey Melyukov @smelukov
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+
+class HasOwnPropertyRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("hasOwnProperty shorthand");
 	}
 
 	/**
-	 * @returns {Set<Module>} modules as set
+	 * @returns {string} runtime code
 	 */
-	getModules() {
-		return this.modules;
-	}
-
-	snapshot() {
-		return this.modules.size;
-	}
+	generate() {
+		const { runtimeTemplate } = this.compilation;
 
-	rollback(snapshot) {
-		const modules = this.modules;
-		for (const m of modules) {
-			if (snapshot === 0) {
-				modules.delete(m);
-			} else {
-				snapshot--;
-			}
-		}
+		return Template.asString([
+			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(
+				"Object.prototype.hasOwnProperty.call(obj, prop)",
+				"obj, prop"
+			)}`
+		]);
 	}
 }
 
-module.exports = ModuleConcatenationPlugin;
+module.exports = HasOwnPropertyRuntimeModule;
 
 
 /***/ }),
 
-/***/ 46043:
+/***/ 82444:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { SyncBailHook } = __webpack_require__(41242);
-const { RawSource, CachedSource, CompatSource } = __webpack_require__(51255);
-const Compilation = __webpack_require__(85720);
-const WebpackError = __webpack_require__(53799);
-const { compareSelect, compareStrings } = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
+const RuntimeModule = __webpack_require__(16963);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compiler")} Compiler */
+class HelperRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {string} name a readable name
+	 */
+	constructor(name) {
+		super(name);
+	}
+}
 
-const EMPTY_SET = new Set();
+module.exports = HelperRuntimeModule;
 
-const addToList = (itemOrItems, list) => {
-	if (Array.isArray(itemOrItems)) {
-		for (const item of itemOrItems) {
-			list.add(item);
-		}
-	} else if (itemOrItems) {
-		list.add(itemOrItems);
-	}
-};
 
-/**
- * @template T
- * @param {T[]} input list
- * @param {function(T): Buffer} fn map function
- * @returns {Buffer[]} buffers without duplicates
- */
-const mapAndDeduplicateBuffers = (input, fn) => {
-	// Buffer.equals compares size first so this should be efficient enough
-	// If it becomes a performance problem we can use a map and group by size
-	// instead of looping over all assets.
-	const result = [];
-	outer: for (const value of input) {
-		const buf = fn(value);
-		for (const other of result) {
-			if (buf.equals(other)) continue outer;
-		}
-		result.push(buf);
-	}
-	return result;
-};
+/***/ }),
 
-/**
- * Escapes regular expression metacharacters
- * @param {string} str String to quote
- * @returns {string} Escaped string
- */
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+/***/ 19942:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const cachedSourceMap = new WeakMap();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-const toCachedSource = source => {
-	if (source instanceof CachedSource) {
-		return source;
-	}
-	const entry = cachedSourceMap.get(source);
-	if (entry !== undefined) return entry;
-	const newSource = new CachedSource(CompatSource.from(source));
-	cachedSourceMap.set(source, newSource);
-	return newSource;
-};
 
-/**
- * @typedef {Object} AssetInfoForRealContentHash
- * @property {string} name
- * @property {AssetInfo} info
- * @property {Source} source
- * @property {RawSource | undefined} newSource
- * @property {RawSource | undefined} newSourceWithoutOwn
- * @property {string} content
- * @property {Set<string>} ownHashes
- * @property {Promise} contentComputePromise
- * @property {Promise} contentComputeWithoutOwnPromise
- * @property {Set<string>} referencedHashes
- * @property {Set<string>} hashes
- */
+
+const { SyncWaterfallHook } = __webpack_require__(6967);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compiler")} Compiler */
 
 /**
- * @typedef {Object} CompilationHooks
- * @property {SyncBailHook<[Buffer[], string], string>} updateHash
+ * @typedef {Object} LoadScriptCompilationHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} createScript
  */
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
+/** @type {WeakMap<Compilation, LoadScriptCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
-class RealContentHashPlugin {
+class LoadScriptRuntimeModule extends HelperRuntimeModule {
 	/**
 	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
+	 * @returns {LoadScriptCompilationHooks} hooks
 	 */
 	static getCompilationHooks(compilation) {
 		if (!(compilation instanceof Compilation)) {
@@ -111609,900 +109696,465 @@ class RealContentHashPlugin {
 		let hooks = compilationHooksMap.get(compilation);
 		if (hooks === undefined) {
 			hooks = {
-				updateHash: new SyncBailHook(["content", "oldHash"])
+				createScript: new SyncWaterfallHook(["source", "chunk"])
 			};
 			compilationHooksMap.set(compilation, hooks);
 		}
 		return hooks;
 	}
 
-	constructor({ hashFunction, hashDigest }) {
-		this._hashFunction = hashFunction;
-		this._hashDigest = hashDigest;
+	/**
+	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
+	 */
+	constructor(withCreateScriptUrl) {
+		super("load script");
+		this._withCreateScriptUrl = withCreateScriptUrl;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RealContentHashPlugin", compilation => {
-			const cacheAnalyse = compilation.getCache(
-				"RealContentHashPlugin|analyse"
-			);
-			const cacheGenerate = compilation.getCache(
-				"RealContentHashPlugin|generate"
-			);
-			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
-			compilation.hooks.processAssets.tapPromise(
-				{
-					name: "RealContentHashPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
-				},
-				async () => {
-					const assets = compilation.getAssets();
-					/** @type {AssetInfoForRealContentHash[]} */
-					const assetsWithInfo = [];
-					const hashToAssets = new Map();
-					for (const { source, info, name } of assets) {
-						const cachedSource = toCachedSource(source);
-						const content = cachedSource.source();
-						/** @type {Set<string>} */
-						const hashes = new Set();
-						addToList(info.contenthash, hashes);
-						const data = {
-							name,
-							info,
-							source: cachedSource,
-							/** @type {RawSource | undefined} */
-							newSource: undefined,
-							/** @type {RawSource | undefined} */
-							newSourceWithoutOwn: undefined,
-							content,
-							/** @type {Set<string>} */
-							ownHashes: undefined,
-							contentComputePromise: undefined,
-							contentComputeWithoutOwnPromise: undefined,
-							/** @type {Set<string>} */
-							referencedHashes: undefined,
-							hashes
-						};
-						assetsWithInfo.push(data);
-						for (const hash of hashes) {
-							const list = hashToAssets.get(hash);
-							if (list === undefined) {
-								hashToAssets.set(hash, [data]);
-							} else {
-								list.push(data);
-							}
-						}
-					}
-					if (hashToAssets.size === 0) return;
-					const hashRegExp = new RegExp(
-						Array.from(hashToAssets.keys(), quoteMeta).join("|"),
-						"g"
-					);
-					await Promise.all(
-						assetsWithInfo.map(async asset => {
-							const { name, source, content, hashes } = asset;
-							if (Buffer.isBuffer(content)) {
-								asset.referencedHashes = EMPTY_SET;
-								asset.ownHashes = EMPTY_SET;
-								return;
-							}
-							const etag = cacheAnalyse.mergeEtags(
-								cacheAnalyse.getLazyHashedEtag(source),
-								Array.from(hashes).join("|")
-							);
-							[asset.referencedHashes, asset.ownHashes] =
-								await cacheAnalyse.providePromise(name, etag, () => {
-									const referencedHashes = new Set();
-									let ownHashes = new Set();
-									const inContent = content.match(hashRegExp);
-									if (inContent) {
-										for (const hash of inContent) {
-											if (hashes.has(hash)) {
-												ownHashes.add(hash);
-												continue;
-											}
-											referencedHashes.add(hash);
-										}
-									}
-									return [referencedHashes, ownHashes];
-								});
-						})
-					);
-					const getDependencies = hash => {
-						const assets = hashToAssets.get(hash);
-						if (!assets) {
-							const referencingAssets = assetsWithInfo.filter(asset =>
-								asset.referencedHashes.has(hash)
-							);
-							const err = new WebpackError(`RealContentHashPlugin
-Some kind of unexpected caching problem occurred.
-An asset was cached with a reference to another asset (${hash}) that's not in the compilation anymore.
-Either the asset was incorrectly cached, or the referenced asset should also be restored from cache.
-Referenced by:
-${referencingAssets
-	.map(a => {
-		const match = new RegExp(`.{0,20}${quoteMeta(hash)}.{0,20}`).exec(
-			a.content
-		);
-		return ` - ${a.name}: ...${match ? match[0] : "???"}...`;
-	})
-	.join("\n")}`);
-							compilation.errors.push(err);
-							return undefined;
-						}
-						const hashes = new Set();
-						for (const { referencedHashes, ownHashes } of assets) {
-							if (!ownHashes.has(hash)) {
-								for (const hash of ownHashes) {
-									hashes.add(hash);
-								}
-							}
-							for (const hash of referencedHashes) {
-								hashes.add(hash);
-							}
-						}
-						return hashes;
-					};
-					const hashInfo = hash => {
-						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(assets, a => a.name)})`;
-					};
-					const hashesInOrder = new Set();
-					for (const hash of hashToAssets.keys()) {
-						const add = (hash, stack) => {
-							const deps = getDependencies(hash);
-							if (!deps) return;
-							stack.add(hash);
-							for (const dep of deps) {
-								if (hashesInOrder.has(dep)) continue;
-								if (stack.has(dep)) {
-									throw new Error(
-										`Circular hash dependency ${Array.from(
-											stack,
-											hashInfo
-										).join(" -> ")} -> ${hashInfo(dep)}`
-									);
-								}
-								add(dep, stack);
-							}
-							hashesInOrder.add(hash);
-							stack.delete(hash);
-						};
-						if (hashesInOrder.has(hash)) continue;
-						add(hash, new Set());
-					}
-					const hashToNewHash = new Map();
-					const getEtag = asset =>
-						cacheGenerate.mergeEtags(
-							cacheGenerate.getLazyHashedEtag(asset.source),
-							Array.from(asset.referencedHashes, hash =>
-								hashToNewHash.get(hash)
-							).join("|")
-						);
-					const computeNewContent = asset => {
-						if (asset.contentComputePromise) return asset.contentComputePromise;
-						return (asset.contentComputePromise = (async () => {
-							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
-							) {
-								const identifier = asset.name;
-								const etag = getEtag(asset);
-								asset.newSource = await cacheGenerate.providePromise(
-									identifier,
-									etag,
-									() => {
-										const newContent = asset.content.replace(hashRegExp, hash =>
-											hashToNewHash.get(hash)
-										);
-										return new RawSource(newContent);
-									}
-								);
-							}
-						})());
-					};
-					const computeNewContentWithoutOwn = asset => {
-						if (asset.contentComputeWithoutOwnPromise)
-							return asset.contentComputeWithoutOwnPromise;
-						return (asset.contentComputeWithoutOwnPromise = (async () => {
-							if (
-								asset.ownHashes.size > 0 ||
-								Array.from(asset.referencedHashes).some(
-									hash => hashToNewHash.get(hash) !== hash
-								)
-							) {
-								const identifier = asset.name + "|without-own";
-								const etag = getEtag(asset);
-								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
-									identifier,
-									etag,
-									() => {
-										const newContent = asset.content.replace(
-											hashRegExp,
-											hash => {
-												if (asset.ownHashes.has(hash)) {
-													return "";
-												}
-												return hashToNewHash.get(hash);
-											}
-										);
-										return new RawSource(newContent);
-									}
-								);
-							}
-						})());
-					};
-					const comparator = compareSelect(a => a.name, compareStrings);
-					for (const oldHash of hashesInOrder) {
-						const assets = hashToAssets.get(oldHash);
-						assets.sort(comparator);
-						const hash = createHash(this._hashFunction);
-						await Promise.all(
-							assets.map(asset =>
-								asset.ownHashes.has(oldHash)
-									? computeNewContentWithoutOwn(asset)
-									: computeNewContent(asset)
-							)
-						);
-						const assetsContent = mapAndDeduplicateBuffers(assets, asset => {
-							if (asset.ownHashes.has(oldHash)) {
-								return asset.newSourceWithoutOwn
-									? asset.newSourceWithoutOwn.buffer()
-									: asset.source.buffer();
-							} else {
-								return asset.newSource
-									? asset.newSource.buffer()
-									: asset.source.buffer();
-							}
-						});
-						let newHash = hooks.updateHash.call(assetsContent, oldHash);
-						if (!newHash) {
-							for (const content of assetsContent) {
-								hash.update(content);
-							}
-							const digest = hash.digest(this._hashDigest);
-							newHash = /** @type {string} */ (digest.slice(0, oldHash.length));
-						}
-						hashToNewHash.set(oldHash, newHash);
-					}
-					await Promise.all(
-						assetsWithInfo.map(async asset => {
-							await computeNewContent(asset);
-							const newName = asset.name.replace(hashRegExp, hash =>
-								hashToNewHash.get(hash)
-							);
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const {
+			scriptType,
+			chunkLoadTimeout: loadTimeout,
+			crossOriginLoading,
+			uniqueName,
+			charset
+		} = outputOptions;
+		const fn = RuntimeGlobals.loadScript;
 
-							const infoUpdate = {};
-							const hash = asset.info.contenthash;
-							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(hash => hashToNewHash.get(hash))
-								: hashToNewHash.get(hash);
+		const { createScript } =
+			LoadScriptRuntimeModule.getCompilationHooks(compilation);
 
-							if (asset.newSource !== undefined) {
-								compilation.updateAsset(
-									asset.name,
-									asset.newSource,
-									infoUpdate
-								);
-							} else {
-								compilation.updateAsset(asset.name, asset.source, infoUpdate);
-							}
+		const code = Template.asString([
+			"script = document.createElement('script');",
+			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
+			charset ? "script.charset = 'utf-8';" : "",
+			`script.timeout = ${loadTimeout / 1000};`,
+			`if (${RuntimeGlobals.scriptNonce}) {`,
+			Template.indent(
+				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+			),
+			"}",
+			uniqueName
+				? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);'
+				: "",
+			`script.src = ${
+				this._withCreateScriptUrl
+					? `${RuntimeGlobals.createScriptUrl}(url)`
+					: "url"
+			};`,
+			crossOriginLoading
+				? Template.asString([
+						"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
+						Template.indent(
+							`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
+						),
+						"}"
+				  ])
+				: ""
+		]);
 
-							if (asset.name !== newName) {
-								compilation.renameAsset(asset.name, newName);
-							}
-						})
-					);
-				}
-			);
-		});
+		return Template.asString([
+			"var inProgress = {};",
+			uniqueName
+				? `var dataWebpackPrefix = ${JSON.stringify(uniqueName + ":")};`
+				: "// data-webpack is not used as build has no uniqueName",
+			"// loadScript function to load a script via script tag",
+			`${fn} = ${runtimeTemplate.basicFunction("url, done, key, chunkId", [
+				"if(inProgress[url]) { inProgress[url].push(done); return; }",
+				"var script, needAttach;",
+				"if(key !== undefined) {",
+				Template.indent([
+					'var scripts = document.getElementsByTagName("script");',
+					"for(var i = 0; i < scripts.length; i++) {",
+					Template.indent([
+						"var s = scripts[i];",
+						`if(s.getAttribute("src") == url${
+							uniqueName
+								? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
+								: ""
+						}) { script = s; break; }`
+					]),
+					"}"
+				]),
+				"}",
+				"if(!script) {",
+				Template.indent([
+					"needAttach = true;",
+					createScript.call(code, this.chunk)
+				]),
+				"}",
+				"inProgress[url] = [done];",
+				"var onScriptComplete = " +
+					runtimeTemplate.basicFunction(
+						"prev, event",
+						Template.asString([
+							"// avoid mem leaks in IE.",
+							"script.onerror = script.onload = null;",
+							"clearTimeout(timeout);",
+							"var doneFns = inProgress[url];",
+							"delete inProgress[url];",
+							"script.parentNode && script.parentNode.removeChild(script);",
+							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
+								"fn(event)",
+								"fn"
+							)});`,
+							"if(prev) return prev(event);"
+						])
+					),
+				";",
+				`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
+				"script.onerror = onScriptComplete.bind(null, script.onerror);",
+				"script.onload = onScriptComplete.bind(null, script.onload);",
+				"needAttach && document.head.appendChild(script);"
+			])};`
+		]);
 	}
 }
 
-module.exports = RealContentHashPlugin;
+module.exports = LoadScriptRuntimeModule;
 
 
 /***/ }),
 
-/***/ 84760:
+/***/ 65714:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { STAGE_BASIC, STAGE_ADVANCED } = __webpack_require__(80057);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
+class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("make namespace object");
+	}
 
-class RemoveEmptyChunksPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveEmptyChunksPlugin", compilation => {
-			/**
-			 * @param {Iterable<Chunk>} chunks the chunks array
-			 * @returns {void}
-			 */
-			const handler = chunks => {
-				const chunkGraph = compilation.chunkGraph;
-				for (const chunk of chunks) {
-					if (
-						chunkGraph.getNumberOfChunkModules(chunk) === 0 &&
-						!chunk.hasRuntime() &&
-						chunkGraph.getNumberOfEntryModules(chunk) === 0
-					) {
-						compilation.chunkGraph.disconnectChunk(chunk);
-						compilation.chunks.delete(chunk);
-					}
-				}
-			};
-
-			// TODO do it once
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "RemoveEmptyChunksPlugin",
-					stage: STAGE_BASIC
-				},
-				handler
-			);
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "RemoveEmptyChunksPlugin",
-					stage: STAGE_ADVANCED
-				},
-				handler
-			);
-		});
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		const fn = RuntimeGlobals.makeNamespaceObject;
+		return Template.asString([
+			"// define __esModule on exports",
+			`${fn} = ${runtimeTemplate.basicFunction("exports", [
+				"if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {",
+				Template.indent([
+					"Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });"
+				]),
+				"}",
+				"Object.defineProperty(exports, '__esModule', { value: true });"
+			])};`
+		]);
 	}
 }
-module.exports = RemoveEmptyChunksPlugin;
+
+module.exports = MakeNamespaceObjectRuntimeModule;
 
 
 /***/ }),
 
-/***/ 7081:
+/***/ 44518:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { STAGE_BASIC } = __webpack_require__(80057);
-const Queue = __webpack_require__(65930);
-const { intersect } = __webpack_require__(93347);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-/** @typedef {import("../Compiler")} Compiler */
+class OnChunksLoadedRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("chunk loaded");
+	}
 
-class RemoveParentModulesPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("RemoveParentModulesPlugin", compilation => {
-			const handler = (chunks, chunkGroups) => {
-				const chunkGraph = compilation.chunkGraph;
-				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);
-					}
-				}
-				for (const chunkGroup of compilation.asyncEntrypoints) {
-					// 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 chunkGraph.getChunkModulesIterable(chunk)) {
-										availableModules.add(m);
-									}
-								}
-								availableModulesMap.set(chunkGroup, availableModules);
-								changed = true;
-							} else {
-								for (const m of availableModules) {
-									if (
-										!chunkGraph.isModuleInChunkGroup(m, parent) &&
-										!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 = chunkGraph.getNumberOfChunkModules(chunk);
-					const toRemove = new Set();
-					if (numberOfModules < availableModules.size) {
-						for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
-							if (availableModules.has(m)) {
-								toRemove.add(m);
-							}
-						}
-					} else {
-						for (const m of availableModules) {
-							if (chunkGraph.isModuleInChunk(m, chunk)) {
-								toRemove.add(m);
-							}
-						}
-					}
-					for (const module of toRemove) {
-						chunkGraph.disconnectChunkAndModule(chunk, module);
-					}
-				}
-			};
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "RemoveParentModulesPlugin",
-					stage: STAGE_BASIC
-				},
-				handler
-			);
-		});
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate } = compilation;
+		return Template.asString([
+			"var deferred = [];",
+			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
+				"result, chunkIds, fn, priority",
+				[
+					"if(chunkIds) {",
+					Template.indent([
+						"priority = priority || 0;",
+						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
+						"deferred[i] = [chunkIds, fn, priority];",
+						"return;"
+					]),
+					"}",
+					"var notFulfilled = Infinity;",
+					"for (var i = 0; i < deferred.length; i++) {",
+					Template.indent([
+						runtimeTemplate.destructureArray(
+							["chunkIds", "fn", "priority"],
+							"deferred[i]"
+						),
+						"var fulfilled = true;",
+						"for (var j = 0; j < chunkIds.length; j++) {",
+						Template.indent([
+							`if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${
+								RuntimeGlobals.onChunksLoaded
+							}).every(${runtimeTemplate.returningFunction(
+								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
+								"key"
+							)})) {`,
+							Template.indent(["chunkIds.splice(j--, 1);"]),
+							"} else {",
+							Template.indent([
+								"fulfilled = false;",
+								"if(priority < notFulfilled) notFulfilled = priority;"
+							]),
+							"}"
+						]),
+						"}",
+						"if(fulfilled) {",
+						Template.indent([
+							"deferred.splice(i--, 1)",
+							"var r = fn();",
+							"if (r !== undefined) result = r;"
+						]),
+						"}"
+					]),
+					"}",
+					"return result;"
+				]
+			)};`
+		]);
 	}
 }
-module.exports = RemoveParentModulesPlugin;
+
+module.exports = OnChunksLoadedRuntimeModule;
 
 
 /***/ }),
 
-/***/ 2837:
-/***/ (function(module) {
+/***/ 56030:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-/** @typedef {import("../Compiler")} Compiler */
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-class RuntimeChunkPlugin {
-	constructor(options) {
-		this.options = {
-			name: entrypoint => `runtime~${entrypoint.name}`,
-			...options
-		};
+class PublicPathRuntimeModule extends RuntimeModule {
+	constructor(publicPath) {
+		super("publicPath", RuntimeModule.STAGE_BASIC);
+		this.publicPath = publicPath;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {string} runtime code
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap("RuntimeChunkPlugin", compilation => {
-			compilation.hooks.addEntry.tap(
-				"RuntimeChunkPlugin",
-				(_, { name: entryName }) => {
-					if (entryName === undefined) return;
-					const data = compilation.entries.get(entryName);
-					if (data.options.runtime === undefined && !data.options.dependOn) {
-						// Determine runtime chunk name
-						let name = this.options.name;
-						if (typeof name === "function") {
-							name = name({ name: entryName });
-						}
-						data.options.runtime = name;
-					}
-				}
-			);
-		});
+	generate() {
+		const { compilation, publicPath } = this;
+
+		return `${RuntimeGlobals.publicPath} = ${JSON.stringify(
+			compilation.getPath(publicPath || "", {
+				hash: compilation.hash || "XXXX"
+			})
+		)};`;
 	}
 }
 
-module.exports = RuntimeChunkPlugin;
+module.exports = PublicPathRuntimeModule;
 
 
 /***/ }),
 
-/***/ 84800:
+/***/ 4537:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const glob2regexp = __webpack_require__(86140);
-const { STAGE_DEFAULT } = __webpack_require__(80057);
-const HarmonyExportImportedSpecifierDependency = __webpack_require__(67157);
-const HarmonyImportSpecifierDependency = __webpack_require__(14077);
-const formatLocation = __webpack_require__(16734);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const HelperRuntimeModule = __webpack_require__(82444);
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+class RelativeUrlRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("relative url");
+	}
 
-/**
- * @typedef {Object} ExportInModule
- * @property {Module} module the module
- * @property {string} exportName the name of the export
- * @property {boolean} checked if the export is conditional
- */
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { runtimeTemplate } = this.compilation;
+		return Template.asString([
+			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
+			Template.indent([
+				'var realUrl = new URL(url, "x:/");',
+				"var values = {};",
+				"for (var key in realUrl) values[key] = realUrl[key];",
+				"values.href = url;",
+				'values.pathname = url.replace(/[?#].*/, "");',
+				'values.origin = values.protocol = "";',
+				`values.toString = values.toJSON = ${runtimeTemplate.returningFunction(
+					"url"
+				)};`,
+				"for (var key in values) Object.defineProperty(this, key, { enumerable: true, configurable: true, value: values[key] });"
+			]),
+			"};",
+			`${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`
+		]);
+	}
+}
 
-/**
- * @typedef {Object} ReexportInfo
- * @property {Map<string, ExportInModule[]>} static
- * @property {Map<Module, Set<string>>} dynamic
- */
+module.exports = RelativeUrlRuntimeModule;
 
-/** @type {WeakMap<any, Map<string, RegExp>>} */
-const globToRegexpCache = new WeakMap();
 
-/**
- * @param {string} glob the pattern
- * @param {Map<string, RegExp>} cache the glob to RegExp cache
- * @returns {RegExp} a regular expression
- */
-const globToRegexp = (glob, cache) => {
-	const cacheEntry = cache.get(glob);
-	if (cacheEntry !== undefined) return cacheEntry;
-	if (!glob.includes("/")) {
-		glob = `**/${glob}`;
+/***/ }),
+
+/***/ 97115:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+
+class RuntimeIdRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("runtimeId");
 	}
-	const baseRegexp = glob2regexp(glob, { globstar: true, extended: true });
-	const regexpSource = baseRegexp.source;
-	const regexp = new RegExp("^(\\./)?" + regexpSource.slice(1));
-	cache.set(glob, regexp);
-	return regexp;
-};
 
-class SideEffectsFlagPlugin {
 	/**
-	 * @param {boolean} analyseSource analyse source code for side effects
+	 * @returns {string} runtime code
 	 */
-	constructor(analyseSource = true) {
-		this._analyseSource = analyseSource;
+	generate() {
+		const { chunkGraph, chunk } = this;
+		const runtime = chunk.runtime;
+		if (typeof runtime !== "string")
+			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
+		const id = chunkGraph.getRuntimeId(runtime);
+		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
+	}
+}
+
+module.exports = RuntimeIdRuntimeModule;
+
+
+/***/ }),
+
+/***/ 22339:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const StartupChunkDependenciesRuntimeModule = __webpack_require__(38157);
+const StartupEntrypointRuntimeModule = __webpack_require__(97672);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class StartupChunkDependenciesPlugin {
+	constructor(options) {
+		this.chunkLoading = options.chunkLoading;
+		this.asyncChunkLoading =
+			typeof options.asyncChunkLoading === "boolean"
+				? options.asyncChunkLoading
+				: true;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		let cache = globToRegexpCache.get(compiler.root);
-		if (cache === undefined) {
-			cache = new Map();
-			globToRegexpCache.set(compiler.root, cache);
-		}
-		compiler.hooks.compilation.tap(
-			"SideEffectsFlagPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const moduleGraph = compilation.moduleGraph;
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						const resolveData = data.resourceResolveData;
-						if (
-							resolveData &&
-							resolveData.descriptionFileData &&
-							resolveData.relativePath
-						) {
-							const sideEffects = resolveData.descriptionFileData.sideEffects;
-							if (sideEffects !== undefined) {
-								if (module.factoryMeta === undefined) {
-									module.factoryMeta = {};
-								}
-								const hasSideEffects =
-									SideEffectsFlagPlugin.moduleHasSideEffects(
-										resolveData.relativePath,
-										sideEffects,
-										cache
-									);
-								module.factoryMeta.sideEffectFree = !hasSideEffects;
-							}
-						}
-
-						return module;
-					}
-				);
-				normalModuleFactory.hooks.module.tap(
-					"SideEffectsFlagPlugin",
-					(module, data) => {
-						if (typeof data.settings.sideEffects === "boolean") {
-							if (module.factoryMeta === undefined) {
-								module.factoryMeta = {};
-							}
-							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
+		compiler.hooks.thisCompilation.tap(
+			"StartupChunkDependenciesPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === this.chunkLoading;
+				};
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					"StartupChunkDependenciesPlugin",
+					(chunk, set, { chunkGraph }) => {
+						if (!isEnabledForChunk(chunk)) return;
+						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+							set.add(RuntimeGlobals.startup);
+							set.add(RuntimeGlobals.ensureChunk);
+							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+							compilation.addRuntimeModule(
+								chunk,
+								new StartupChunkDependenciesRuntimeModule(
+									this.asyncChunkLoading
+								)
+							);
 						}
-						return module;
 					}
 				);
-				if (this._analyseSource) {
-					/**
-					 * @param {JavascriptParser} parser the parser
-					 * @returns {void}
-					 */
-					const parserHandler = parser => {
-						let sideEffectsStatement;
-						parser.hooks.program.tap("SideEffectsFlagPlugin", () => {
-							sideEffectsStatement = undefined;
-						});
-						parser.hooks.statement.tap(
-							{ name: "SideEffectsFlagPlugin", stage: -100 },
-							statement => {
-								if (sideEffectsStatement) return;
-								if (parser.scope.topLevelScope !== true) return;
-								switch (statement.type) {
-									case "ExpressionStatement":
-										if (
-											!parser.isPure(statement.expression, statement.range[0])
-										) {
-											sideEffectsStatement = statement;
-										}
-										break;
-									case "IfStatement":
-									case "WhileStatement":
-									case "DoWhileStatement":
-										if (!parser.isPure(statement.test, statement.range[0])) {
-											sideEffectsStatement = statement;
-										}
-										// statement hook will be called for child statements too
-										break;
-									case "ForStatement":
-										if (
-											!parser.isPure(statement.init, statement.range[0]) ||
-											!parser.isPure(
-												statement.test,
-												statement.init
-													? statement.init.range[1]
-													: statement.range[0]
-											) ||
-											!parser.isPure(
-												statement.update,
-												statement.test
-													? statement.test.range[1]
-													: statement.init
-													? statement.init.range[1]
-													: statement.range[0]
-											)
-										) {
-											sideEffectsStatement = statement;
-										}
-										// statement hook will be called for child statements too
-										break;
-									case "SwitchStatement":
-										if (
-											!parser.isPure(statement.discriminant, statement.range[0])
-										) {
-											sideEffectsStatement = statement;
-										}
-										// statement hook will be called for child statements too
-										break;
-									case "VariableDeclaration":
-									case "ClassDeclaration":
-									case "FunctionDeclaration":
-										if (!parser.isPure(statement, statement.range[0])) {
-											sideEffectsStatement = statement;
-										}
-										break;
-									case "ExportNamedDeclaration":
-									case "ExportDefaultDeclaration":
-										if (
-											!parser.isPure(statement.declaration, statement.range[0])
-										) {
-											sideEffectsStatement = statement;
-										}
-										break;
-									case "LabeledStatement":
-									case "BlockStatement":
-										// statement hook will be called for child statements too
-										break;
-									case "EmptyStatement":
-										break;
-									case "ExportAllDeclaration":
-									case "ImportDeclaration":
-										// imports will be handled by the dependencies
-										break;
-									default:
-										sideEffectsStatement = statement;
-										break;
-								}
-							}
-						);
-						parser.hooks.finish.tap("SideEffectsFlagPlugin", () => {
-							if (sideEffectsStatement === undefined) {
-								parser.state.module.buildMeta.sideEffectFree = true;
-							} else {
-								const { loc, type } = sideEffectsStatement;
-								moduleGraph
-									.getOptimizationBailout(parser.state.module)
-									.push(
-										() =>
-											`Statement (${type}) with side effects in source code at ${formatLocation(
-												loc
-											)}`
-									);
-							}
-						});
-					};
-					for (const key of [
-						"javascript/auto",
-						"javascript/esm",
-						"javascript/dynamic"
-					]) {
-						normalModuleFactory.hooks.parser
-							.for(key)
-							.tap("SideEffectsFlagPlugin", parserHandler);
-					}
-				}
-				compilation.hooks.optimizeDependencies.tap(
-					{
-						name: "SideEffectsFlagPlugin",
-						stage: STAGE_DEFAULT
-					},
-					modules => {
-						const logger = compilation.getLogger(
-							"webpack.SideEffectsFlagPlugin"
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.startupEntrypoint)
+					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.require);
+						set.add(RuntimeGlobals.ensureChunk);
+						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+						compilation.addRuntimeModule(
+							chunk,
+							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
 						);
-
-						logger.time("update dependencies");
-						for (const module of modules) {
-							if (module.getSideEffectsConnectionState(moduleGraph) === false) {
-								const exportsInfo = moduleGraph.getExportsInfo(module);
-								for (const connection of moduleGraph.getIncomingConnections(
-									module
-								)) {
-									const dep = connection.dependency;
-									let isReexport;
-									if (
-										(isReexport =
-											dep instanceof
-											HarmonyExportImportedSpecifierDependency) ||
-										(dep instanceof HarmonyImportSpecifierDependency &&
-											!dep.namespaceObjectAsContext)
-									) {
-										// TODO improve for export *
-										if (isReexport && dep.name) {
-											const exportInfo = moduleGraph.getExportInfo(
-												connection.originModule,
-												dep.name
-											);
-											exportInfo.moveTarget(
-												moduleGraph,
-												({ module }) =>
-													module.getSideEffectsConnectionState(moduleGraph) ===
-													false,
-												({ module: newModule, export: exportName }) => {
-													moduleGraph.updateModule(dep, newModule);
-													moduleGraph.addExplanation(
-														dep,
-														"(skipped side-effect-free modules)"
-													);
-													const ids = dep.getIds(moduleGraph);
-													dep.setIds(
-														moduleGraph,
-														exportName
-															? [...exportName, ...ids.slice(1)]
-															: ids.slice(1)
-													);
-													return moduleGraph.getConnection(dep);
-												}
-											);
-											continue;
-										}
-										// TODO improve for nested imports
-										const ids = dep.getIds(moduleGraph);
-										if (ids.length > 0) {
-											const exportInfo = exportsInfo.getExportInfo(ids[0]);
-											const target = exportInfo.getTarget(
-												moduleGraph,
-												({ module }) =>
-													module.getSideEffectsConnectionState(moduleGraph) ===
-													false
-											);
-											if (!target) continue;
-
-											moduleGraph.updateModule(dep, target.module);
-											moduleGraph.addExplanation(
-												dep,
-												"(skipped side-effect-free modules)"
-											);
-											dep.setIds(
-												moduleGraph,
-												target.export
-													? [...target.export, ...ids.slice(1)]
-													: ids.slice(1)
-											);
-										}
-									}
-								}
-							}
-						}
-						logger.timeEnd("update dependencies");
-					}
-				);
+					});
 			}
 		);
 	}
-
-	static moduleHasSideEffects(moduleName, flagValue, cache) {
-		switch (typeof flagValue) {
-			case "undefined":
-				return true;
-			case "boolean":
-				return flagValue;
-			case "string":
-				return globToRegexp(flagValue, cache).test(moduleName);
-			case "object":
-				return flagValue.some(glob =>
-					SideEffectsFlagPlugin.moduleHasSideEffects(moduleName, glob, cache)
-				);
-		}
-	}
 }
-module.exports = SideEffectsFlagPlugin;
+
+module.exports = StartupChunkDependenciesPlugin;
 
 
 /***/ }),
 
-/***/ 21478:
+/***/ 38157:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -112513,779 +110165,563 @@ module.exports = SideEffectsFlagPlugin;
 
 
 
-const Chunk = __webpack_require__(39385);
-const { STAGE_ADVANCED } = __webpack_require__(80057);
-const WebpackError = __webpack_require__(53799);
-const { requestToId } = __webpack_require__(63290);
-const { isSubset } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-const {
-	compareModulesByIdentifier,
-	compareIterables
-} = __webpack_require__(29579);
-const createHash = __webpack_require__(49835);
-const deterministicGrouping = __webpack_require__(59836);
-const { makePathsRelative } = __webpack_require__(82186);
-const memoize = __webpack_require__(78676);
-const MinMaxSizeWarning = __webpack_require__(85305);
-
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksGetCacheGroups} OptimizationSplitChunksGetCacheGroups */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
-/** @typedef {import("../../declarations/WebpackOptions").Output} OutputOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
-/** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
-
-/** @typedef {Record<string, number>} SplitChunksSizes */
-
-/**
- * @callback ChunkFilterFunction
- * @param {Chunk} chunk
- * @returns {boolean}
- */
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-/**
- * @callback CombineSizeFunction
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
+class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
+	constructor(asyncChunkLoading) {
+		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
+		this.asyncChunkLoading = asyncChunkLoading;
+	}
 
-/**
- * @typedef {Object} CacheGroupSource
- * @property {string=} key
- * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
- * @property {boolean=} enforce
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} minSizeReduction
- * @property {SplitChunksSizes} minRemainingSize
- * @property {SplitChunksSizes} enforceSizeThreshold
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
- * @property {string=} idHint
- * @property {string} automaticNameDelimiter
- * @property {boolean=} reuseExistingChunk
- * @property {boolean=} usedExports
- */
-
-/**
- * @typedef {Object} CacheGroup
- * @property {string} key
- * @property {number=} priority
- * @property {GetName=} getName
- * @property {ChunkFilterFunction=} chunksFilter
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} minSizeReduction
- * @property {SplitChunksSizes} minRemainingSize
- * @property {SplitChunksSizes} enforceSizeThreshold
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {SplitChunksSizes} maxInitialSize
- * @property {number=} minChunks
- * @property {number=} maxAsyncRequests
- * @property {number=} maxInitialRequests
- * @property {(string | function(PathData, AssetInfo=): string)=} filename
- * @property {string=} idHint
- * @property {string} automaticNameDelimiter
- * @property {boolean} reuseExistingChunk
- * @property {boolean} usedExports
- * @property {boolean} _validateSize
- * @property {boolean} _validateRemainingSize
- * @property {SplitChunksSizes} _minSizeForMaxSize
- * @property {boolean} _conditionalEnforce
- */
-
-/**
- * @typedef {Object} FallbackCacheGroup
- * @property {ChunkFilterFunction} chunksFilter
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {SplitChunksSizes} maxInitialSize
- * @property {string} automaticNameDelimiter
- */
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, chunk, compilation } = this;
+		const { runtimeTemplate } = compilation;
+		const chunkIds = Array.from(
+			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
+		).map(chunk => {
+			return chunk.id;
+		});
+		return Template.asString([
+			`var next = ${RuntimeGlobals.startup};`,
+			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
+				"",
+				!this.asyncChunkLoading
+					? chunkIds
+							.map(
+								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
+							)
+							.concat("return next();")
+					: chunkIds.length === 1
+					? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
+							chunkIds[0]
+					  )}).then(next);`
+					: chunkIds.length > 2
+					? [
+							// using map is shorter for 3 or more chunks
+							`return Promise.all(${JSON.stringify(chunkIds)}.map(${
+								RuntimeGlobals.ensureChunk
+							}, __webpack_require__)).then(next);`
+					  ]
+					: [
+							// calling ensureChunk directly is shorter for 0 - 2 chunks
+							"return Promise.all([",
+							Template.indent(
+								chunkIds
+									.map(
+										id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)})`
+									)
+									.join(",\n")
+							),
+							"]).then(next);"
+					  ]
+			)};`
+		]);
+	}
+}
 
-/**
- * @typedef {Object} CacheGroupsContext
- * @property {ModuleGraph} moduleGraph
- * @property {ChunkGraph} chunkGraph
- */
+module.exports = StartupChunkDependenciesRuntimeModule;
 
-/**
- * @callback GetCacheGroups
- * @param {Module} module
- * @param {CacheGroupsContext} context
- * @returns {CacheGroupSource[]}
- */
 
-/**
- * @callback GetName
- * @param {Module=} module
- * @param {Chunk[]=} chunks
- * @param {string=} key
- * @returns {string=}
- */
+/***/ }),
 
-/**
- * @typedef {Object} SplitChunksOptions
- * @property {ChunkFilterFunction} chunksFilter
- * @property {string[]} defaultSizeTypes
- * @property {SplitChunksSizes} minSize
- * @property {SplitChunksSizes} minSizeReduction
- * @property {SplitChunksSizes} minRemainingSize
- * @property {SplitChunksSizes} enforceSizeThreshold
- * @property {SplitChunksSizes} maxInitialSize
- * @property {SplitChunksSizes} maxAsyncSize
- * @property {number} minChunks
- * @property {number} maxAsyncRequests
- * @property {number} maxInitialRequests
- * @property {boolean} hidePathInfo
- * @property {string | function(PathData, AssetInfo=): string} filename
- * @property {string} automaticNameDelimiter
- * @property {GetCacheGroups} getCacheGroups
- * @property {GetName} getName
- * @property {boolean} usedExports
- * @property {FallbackCacheGroup} fallbackCacheGroup
- */
+/***/ 97672:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * @typedef {Object} ChunksInfoItem
- * @property {SortableSet<Module>} modules
- * @property {CacheGroup} cacheGroup
- * @property {number} cacheGroupIndex
- * @property {string} name
- * @property {Record<string, number>} sizes
- * @property {Set<Chunk>} chunks
- * @property {Set<Chunk>} reuseableChunks
- * @property {Set<bigint | Chunk>} chunksKeys
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-const defaultGetName = /** @type {GetName} */ (() => {});
 
-const deterministicGroupingForModules =
-	/** @type {function(DeterministicGroupingOptionsForModule): DeterministicGroupingGroupedItemsForModule[]} */ (
-		deterministicGrouping
-	);
 
-/** @type {WeakMap<Module, string>} */
-const getKeyCache = new WeakMap();
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-/**
- * @param {string} name a filename to hash
- * @param {OutputOptions} outputOptions hash function used
- * @returns {string} hashed filename
- */
-const hashFilename = (name, outputOptions) => {
-	const digest = /** @type {string} */ (
-		createHash(outputOptions.hashFunction)
-			.update(name)
-			.digest(outputOptions.hashDigest)
-	);
-	return digest.slice(0, 8);
-};
+/** @typedef {import("../MainTemplate")} MainTemplate */
 
-/**
- * @param {Chunk} chunk the chunk
- * @returns {number} the number of requests
- */
-const getRequests = chunk => {
-	let requests = 0;
-	for (const chunkGroup of chunk.groupsIterable) {
-		requests = Math.max(requests, chunkGroup.chunks.length);
+class StartupEntrypointRuntimeModule extends RuntimeModule {
+	constructor(asyncChunkLoading) {
+		super("startup entrypoint");
+		this.asyncChunkLoading = asyncChunkLoading;
 	}
-	return requests;
-};
 
-const mapObject = (obj, fn) => {
-	const newObj = Object.create(null);
-	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], key);
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate } = compilation;
+		return `${
+			RuntimeGlobals.startupEntrypoint
+		} = ${runtimeTemplate.basicFunction("result, chunkIds, fn", [
+			"// arguments: chunkIds, moduleId are deprecated",
+			"var moduleId = chunkIds;",
+			`if(!fn) chunkIds = result, fn = ${runtimeTemplate.returningFunction(
+				`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`
+			)};`,
+			...(this.asyncChunkLoading
+				? [
+						`return Promise.all(chunkIds.map(${
+							RuntimeGlobals.ensureChunk
+						}, __webpack_require__)).then(${runtimeTemplate.basicFunction("", [
+							"var r = fn();",
+							"return r === undefined ? result : r;"
+						])})`
+				  ]
+				: [
+						`chunkIds.map(${RuntimeGlobals.ensureChunk}, __webpack_require__)`,
+						"var r = fn();",
+						"return r === undefined ? result : r;"
+				  ])
+		])}`;
 	}
-	return newObj;
-};
+}
 
-/**
- * @template T
- * @param {Set<T>} a set
- * @param {Set<T>} b other set
- * @returns {boolean} true if at least one item of a is in b
- */
-const isOverlap = (a, b) => {
-	for (const item of a) {
-		if (b.has(item)) return true;
-	}
-	return false;
-};
+module.exports = StartupEntrypointRuntimeModule;
 
-const compareModuleIterables = compareIterables(compareModulesByIdentifier);
 
-/**
- * @param {ChunksInfoItem} a item
- * @param {ChunksInfoItem} b item
- * @returns {number} compare result
- */
-const compareEntries = (a, b) => {
-	// 1. by priority
-	const diffPriority = a.cacheGroup.priority - b.cacheGroup.priority;
-	if (diffPriority) return diffPriority;
-	// 2. by number of chunks
-	const diffCount = a.chunks.size - b.chunks.size;
-	if (diffCount) return diffCount;
-	// 3. by size reduction
-	const aSizeReduce = totalSize(a.sizes) * (a.chunks.size - 1);
-	const bSizeReduce = totalSize(b.sizes) * (b.chunks.size - 1);
-	const diffSizeReduce = aSizeReduce - bSizeReduce;
-	if (diffSizeReduce) return diffSizeReduce;
-	// 4. by cache group index
-	const indexDiff = b.cacheGroupIndex - a.cacheGroupIndex;
-	if (indexDiff) return indexDiff;
-	// 5. by number of modules (to be able to compare by identifier)
-	const modulesA = a.modules;
-	const modulesB = b.modules;
-	const diff = modulesA.size - modulesB.size;
-	if (diff) return diff;
-	// 6. by module identifiers
-	modulesA.sort();
-	modulesB.sort();
-	return compareModuleIterables(modulesA, modulesB);
-};
+/***/ }),
 
-const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
-const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
-const ALL_CHUNK_FILTER = chunk => true;
+/***/ 80655:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/**
- * @param {OptimizationSplitChunksSizes} value the sizes
- * @param {string[]} defaultSizeTypes the default size types
- * @returns {SplitChunksSizes} normalized representation
- */
-const normalizeSizes = (value, defaultSizeTypes) => {
-	if (typeof value === "number") {
-		/** @type {Record<string, number>} */
-		const o = {};
-		for (const sizeType of defaultSizeTypes) o[sizeType] = value;
-		return o;
-	} else if (typeof value === "object" && value !== null) {
-		return { ...value };
-	} else {
-		return {};
-	}
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-/**
- * @param {...SplitChunksSizes} sizes the sizes
- * @returns {SplitChunksSizes} the merged sizes
- */
-const mergeSizes = (...sizes) => {
-	/** @type {SplitChunksSizes} */
-	let merged = {};
-	for (let i = sizes.length - 1; i >= 0; i--) {
-		merged = Object.assign(merged, sizes[i]);
-	}
-	return merged;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @returns {boolean} true, if there are sizes > 0
- */
-const hasNonZeroSizes = sizes => {
-	for (const key of Object.keys(sizes)) {
-		if (sizes[key] > 0) return true;
-	}
-	return false;
-};
 
-/**
- * @param {SplitChunksSizes} a first sizes
- * @param {SplitChunksSizes} b second sizes
- * @param {CombineSizeFunction} combine a function to combine sizes
- * @returns {SplitChunksSizes} the combine sizes
- */
-const combineSizes = (a, b, combine) => {
-	const aKeys = new Set(Object.keys(a));
-	const bKeys = new Set(Object.keys(b));
-	/** @type {SplitChunksSizes} */
-	const result = {};
-	for (const key of aKeys) {
-		if (bKeys.has(key)) {
-			result[key] = combine(a[key], b[key]);
-		} else {
-			result[key] = a[key];
-		}
-	}
-	for (const key of bKeys) {
-		if (!aKeys.has(key)) {
-			result[key] = b[key];
-		}
-	}
-	return result;
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @param {SplitChunksSizes} minSize the min sizes
- * @returns {boolean} true if there are sizes and all existing sizes are at least `minSize`
- */
-const checkMinSize = (sizes, minSize) => {
-	for (const key of Object.keys(minSize)) {
-		const size = sizes[key];
-		if (size === undefined || size === 0) continue;
-		if (size < minSize[key]) return false;
-	}
-	return true;
-};
+/** @typedef {import("../Compilation")} Compilation */
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @param {SplitChunksSizes} minSizeReduction the min sizes
- * @param {number} chunkCount number of chunks
- * @returns {boolean} true if there are sizes and all existing sizes are at least `minSizeReduction`
- */
-const checkMinSizeReduction = (sizes, minSizeReduction, chunkCount) => {
-	for (const key of Object.keys(minSizeReduction)) {
-		const size = sizes[key];
-		if (size === undefined || size === 0) continue;
-		if (size * chunkCount < minSizeReduction[key]) return false;
+class SystemContextRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("__system_context__");
 	}
-	return true;
-};
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @param {SplitChunksSizes} minSize the min sizes
- * @returns {undefined | string[]} list of size types that are below min size
- */
-const getViolatingMinSizes = (sizes, minSize) => {
-	let list;
-	for (const key of Object.keys(minSize)) {
-		const size = sizes[key];
-		if (size === undefined || size === 0) continue;
-		if (size < minSize[key]) {
-			if (list === undefined) list = [key];
-			else list.push(key);
-		}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		return `${RuntimeGlobals.systemContext} = __system_context__;`;
 	}
-	return list;
-};
+}
 
-/**
- * @param {SplitChunksSizes} sizes the sizes
- * @returns {number} the total size
- */
-const totalSize = sizes => {
-	let size = 0;
-	for (const key of Object.keys(sizes)) {
-		size += sizes[key];
-	}
-	return size;
-};
+module.exports = SystemContextRuntimeModule;
 
-/**
- * @param {false|string|Function} name the chunk name
- * @returns {GetName} a function to get the name of the chunk
- */
-const normalizeName = name => {
-	if (typeof name === "string") {
-		return () => name;
-	}
-	if (typeof name === "function") {
-		return /** @type {GetName} */ (name);
-	}
+
+/***/ }),
+
+/***/ 64820:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const NormalModule = __webpack_require__(39);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
+// http://www.ietf.org/rfc/rfc2397.txt
+const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
+
+const decodeDataURI = uri => {
+	const match = URIRegEx.exec(uri);
+	if (!match) return null;
+
+	const isBase64 = match[3];
+	const body = match[4];
+	return isBase64
+		? Buffer.from(body, "base64")
+		: Buffer.from(decodeURIComponent(body), "ascii");
 };
 
-/**
- * @param {OptimizationSplitChunksCacheGroup["chunks"]} chunks the chunk filter option
- * @returns {ChunkFilterFunction} the chunk filter function
- */
-const normalizeChunksFilter = chunks => {
-	if (chunks === "initial") {
-		return INITIAL_CHUNK_FILTER;
-	}
-	if (chunks === "async") {
-		return ASYNC_CHUNK_FILTER;
-	}
-	if (chunks === "all") {
-		return ALL_CHUNK_FILTER;
-	}
-	if (typeof chunks === "function") {
-		return chunks;
+class DataUriPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"DataUriPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.resolveForScheme
+					.for("data")
+					.tap("DataUriPlugin", resourceData => {
+						const match = URIRegEx.exec(resourceData.resource);
+						if (match) {
+							resourceData.data.mimetype = match[1] || "";
+							resourceData.data.parameters = match[2] || "";
+							resourceData.data.encoding = match[3] || false;
+							resourceData.data.encodedContent = match[4] || "";
+						}
+					});
+				NormalModule.getCompilationHooks(compilation)
+					.readResourceForScheme.for("data")
+					.tap("DataUriPlugin", resource => decodeDataURI(resource));
+			}
+		);
 	}
-};
+}
 
-/**
- * @param {GetCacheGroups | Record<string, false|string|RegExp|OptimizationSplitChunksGetCacheGroups|OptimizationSplitChunksCacheGroup>} cacheGroups the cache group options
- * @param {string[]} defaultSizeTypes the default size types
- * @returns {GetCacheGroups} a function to get the cache groups
- */
-const normalizeCacheGroups = (cacheGroups, defaultSizeTypes) => {
-	if (typeof cacheGroups === "function") {
-		return cacheGroups;
-	}
-	if (typeof cacheGroups === "object" && cacheGroups !== null) {
-		/** @type {(function(Module, CacheGroupsContext, CacheGroupSource[]): void)[]} */
-		const handlers = [];
-		for (const key of Object.keys(cacheGroups)) {
-			const option = cacheGroups[key];
-			if (option === false) {
-				continue;
-			}
-			if (typeof option === "string" || option instanceof RegExp) {
-				const source = createCacheGroupSource({}, key, defaultSizeTypes);
-				handlers.push((module, context, results) => {
-					if (checkTest(option, module, context)) {
-						results.push(source);
-					}
-				});
-			} else if (typeof option === "function") {
-				const cache = new WeakMap();
-				handlers.push((module, context, results) => {
-					const result = option(module);
-					if (result) {
-						const groups = Array.isArray(result) ? result : [result];
-						for (const group of groups) {
-							const cachedSource = cache.get(group);
-							if (cachedSource !== undefined) {
-								results.push(cachedSource);
-							} else {
-								const source = createCacheGroupSource(
-									group,
-									key,
-									defaultSizeTypes
-								);
-								cache.set(group, source);
-								results.push(source);
-							}
-						}
-					}
-				});
-			} else {
-				const source = createCacheGroupSource(option, key, defaultSizeTypes);
-				handlers.push((module, context, results) => {
-					if (
-						checkTest(option.test, module, context) &&
-						checkModuleType(option.type, module) &&
-						checkModuleLayer(option.layer, module)
-					) {
-						results.push(source);
-					}
-				});
-			}
-		}
-		/**
-		 * @param {Module} module the current module
-		 * @param {CacheGroupsContext} context the current context
-		 * @returns {CacheGroupSource[]} the matching cache groups
-		 */
-		const fn = (module, context) => {
-			/** @type {CacheGroupSource[]} */
-			let results = [];
-			for (const fn of handlers) {
-				fn(module, context, results);
+module.exports = DataUriPlugin;
+
+
+/***/ }),
+
+/***/ 57637:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { URL, fileURLToPath } = __webpack_require__(57310);
+const { NormalModule } = __webpack_require__(91919);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class FileUriPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"FileUriPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.resolveForScheme
+					.for("file")
+					.tap("FileUriPlugin", resourceData => {
+						const url = new URL(resourceData.resource);
+						const path = fileURLToPath(url);
+						const query = url.search;
+						const fragment = url.hash;
+						resourceData.path = path;
+						resourceData.query = query;
+						resourceData.fragment = fragment;
+						resourceData.resource = path + query + fragment;
+						return true;
+					});
+				const hooks = NormalModule.getCompilationHooks(compilation);
+				hooks.readResource
+					.for(undefined)
+					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+						const { resourcePath } = loaderContext;
+						loaderContext.addDependency(resourcePath);
+						loaderContext.fs.readFile(resourcePath, callback);
+					});
 			}
-			return results;
-		};
-		return fn;
+		);
 	}
-	return () => null;
+}
+
+module.exports = FileUriPlugin;
+
+
+/***/ }),
+
+/***/ 42110:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { extname, basename } = __webpack_require__(71017);
+const { URL } = __webpack_require__(57310);
+const { createGunzip, createBrotliDecompress, createInflate } = __webpack_require__(59796);
+const NormalModule = __webpack_require__(39);
+const createSchemaValidation = __webpack_require__(32540);
+const createHash = __webpack_require__(49835);
+const { mkdirp, dirname, join } = __webpack_require__(17139);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
+
+const getHttp = memoize(() => __webpack_require__(13685));
+const getHttps = memoize(() => __webpack_require__(95687));
+
+/** @type {(() => void)[] | undefined} */
+let inProgressWrite = undefined;
+
+const validate = createSchemaValidation(
+	__webpack_require__(67263),
+	() => __webpack_require__(27256),
+	{
+		name: "Http Uri Plugin",
+		baseDataPath: "options"
+	}
+);
+
+const toSafePath = str =>
+	str
+		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
+		.replace(/[^a-zA-Z0-9._-]+/g, "_");
+
+const computeIntegrity = content => {
+	const hash = createHash("sha512");
+	hash.update(content);
+	const integrity = "sha512-" + hash.digest("base64");
+	return integrity;
+};
+
+const verifyIntegrity = (content, integrity) => {
+	if (integrity === "ignore") return true;
+	return computeIntegrity(content) === integrity;
 };
 
 /**
- * @param {undefined|boolean|string|RegExp|Function} test test option
- * @param {Module} module the module
- * @param {CacheGroupsContext} context context object
- * @returns {boolean} true, if the module should be selected
+ * @param {string} str input
+ * @returns {Record<string, string>} parsed
  */
-const checkTest = (test, module, context) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module, context);
-	}
-	if (typeof test === "boolean") return test;
-	if (typeof test === "string") {
-		const name = module.nameForCondition();
-		return name && name.startsWith(test);
+const parseKeyValuePairs = str => {
+	/** @type {Record<string, string>} */
+	const result = {};
+	for (const item of str.split(",")) {
+		const i = item.indexOf("=");
+		if (i >= 0) {
+			const key = item.slice(0, i).trim();
+			const value = item.slice(i + 1).trim();
+			result[key] = value;
+		} else {
+			const key = item.trim();
+			if (!key) continue;
+			result[key] = key;
+		}
 	}
-	if (test instanceof RegExp) {
-		const name = module.nameForCondition();
-		return name && test.test(name);
+	return result;
+};
+
+const parseCacheControl = (cacheControl, requestTime) => {
+	// When false resource is not stored in cache
+	let storeCache = true;
+	// When false resource is not stored in lockfile cache
+	let storeLock = true;
+	// Resource is only revalidated, after that timestamp and when upgrade is chosen
+	let validUntil = 0;
+	if (cacheControl) {
+		const parsed = parseKeyValuePairs(cacheControl);
+		if (parsed["no-cache"]) storeCache = storeLock = false;
+		if (parsed["max-age"] && !isNaN(+parsed["max-age"])) {
+			validUntil = requestTime + +parsed["max-age"] * 1000;
+		}
+		if (parsed["must-revalidate"]) validUntil = 0;
 	}
-	return false;
+	return {
+		storeLock,
+		storeCache,
+		validUntil
+	};
 };
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
- * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @typedef {Object} LockfileEntry
+ * @property {string} resolved
+ * @property {string} integrity
+ * @property {string} contentType
  */
-const checkModuleType = (test, module) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module.type);
+
+const areLockfileEntriesEqual = (a, b) => {
+	return (
+		a.resolved === b.resolved &&
+		a.integrity === b.integrity &&
+		a.contentType === b.contentType
+	);
+};
+
+const entryToString = entry => {
+	return `resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
+};
+
+class Lockfile {
+	constructor() {
+		this.version = 1;
+		/** @type {Map<string, LockfileEntry | "ignore" | "no-cache">} */
+		this.entries = new Map();
 	}
-	if (typeof test === "string") {
-		const type = module.type;
-		return test === type;
+
+	static parse(content) {
+		// TODO handle merge conflicts
+		const data = JSON.parse(content);
+		if (data.version !== 1)
+			throw new Error(`Unsupported lockfile version ${data.version}`);
+		const lockfile = new Lockfile();
+		for (const key of Object.keys(data)) {
+			if (key === "version") continue;
+			const entry = data[key];
+			lockfile.entries.set(
+				key,
+				typeof entry === "string"
+					? entry
+					: {
+							resolved: key,
+							...entry
+					  }
+			);
+		}
+		return lockfile;
 	}
-	if (test instanceof RegExp) {
-		const type = module.type;
-		return test.test(type);
+
+	toString() {
+		let str = "{\n";
+		const entries = Array.from(this.entries).sort(([a], [b]) =>
+			a < b ? -1 : 1
+		);
+		for (const [key, entry] of entries) {
+			if (typeof entry === "string") {
+				str += `  ${JSON.stringify(key)}: ${JSON.stringify(entry)},\n`;
+			} else {
+				str += `  ${JSON.stringify(key)}: { `;
+				if (entry.resolved !== key)
+					str += `"resolved": ${JSON.stringify(entry.resolved)}, `;
+				str += `"integrity": ${JSON.stringify(
+					entry.integrity
+				)}, "contentType": ${JSON.stringify(entry.contentType)} },\n`;
+			}
+		}
+		str += `  "version": ${this.version}\n}\n`;
+		return str;
 	}
-	return false;
-};
+}
 
 /**
- * @param {undefined|string|RegExp|Function} test type option
- * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @template R
+ * @param {function(function(Error=, R=): void): void} fn function
+ * @returns {function(function((Error | null)=, R=): void): void} cached function
  */
-const checkModuleLayer = (test, module) => {
-	if (test === undefined) return true;
-	if (typeof test === "function") {
-		return test(module.layer);
-	}
-	if (typeof test === "string") {
-		const layer = module.layer;
-		return test === "" ? !layer : layer && layer.startsWith(test);
-	}
-	if (test instanceof RegExp) {
-		const layer = module.layer;
-		return test.test(layer);
-	}
-	return false;
+const cachedWithoutKey = fn => {
+	let inFlight = false;
+	/** @type {Error | undefined} */
+	let cachedError = undefined;
+	/** @type {R | undefined} */
+	let cachedResult = undefined;
+	/** @type {(function(Error=, R=): void)[] | undefined} */
+	let cachedCallbacks = undefined;
+	return callback => {
+		if (inFlight) {
+			if (cachedResult !== undefined) return callback(null, cachedResult);
+			if (cachedError !== undefined) return callback(cachedError);
+			if (cachedCallbacks === undefined) cachedCallbacks = [callback];
+			else cachedCallbacks.push(callback);
+			return;
+		}
+		inFlight = true;
+		fn((err, result) => {
+			if (err) cachedError = err;
+			else cachedResult = result;
+			const callbacks = cachedCallbacks;
+			cachedCallbacks = undefined;
+			callback(err, result);
+			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+		});
+	};
 };
 
 /**
- * @param {OptimizationSplitChunksCacheGroup} options the group options
- * @param {string} key key of cache group
- * @param {string[]} defaultSizeTypes the default size types
- * @returns {CacheGroupSource} the normalized cached group
+ * @template T
+ * @template R
+ * @param {function(T, function(Error=, R=): void): void} fn function
+ * @param {function(T, function(Error=, R=): void): void=} forceFn function for the second try
+ * @returns {(function(T, function((Error | null)=, R=): void): void) & { force: function(T, function((Error | null)=, R=): void): void }} cached function
  */
-const createCacheGroupSource = (options, key, defaultSizeTypes) => {
-	const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
-	const minSizeReduction = normalizeSizes(
-		options.minSizeReduction,
-		defaultSizeTypes
-	);
-	const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
-	return {
-		key,
-		priority: options.priority,
-		getName: normalizeName(options.name),
-		chunksFilter: normalizeChunksFilter(options.chunks),
-		enforce: options.enforce,
-		minSize,
-		minSizeReduction,
-		minRemainingSize: mergeSizes(
-			normalizeSizes(options.minRemainingSize, defaultSizeTypes),
-			minSize
-		),
-		enforceSizeThreshold: normalizeSizes(
-			options.enforceSizeThreshold,
-			defaultSizeTypes
-		),
-		maxAsyncSize: mergeSizes(
-			normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
-			maxSize
-		),
-		maxInitialSize: mergeSizes(
-			normalizeSizes(options.maxInitialSize, defaultSizeTypes),
-			maxSize
-		),
-		minChunks: options.minChunks,
-		maxAsyncRequests: options.maxAsyncRequests,
-		maxInitialRequests: options.maxInitialRequests,
-		filename: options.filename,
-		idHint: options.idHint,
-		automaticNameDelimiter: options.automaticNameDelimiter,
-		reuseExistingChunk: options.reuseExistingChunk,
-		usedExports: options.usedExports
+const cachedWithKey = (fn, forceFn = fn) => {
+	/** @typedef {{ result?: R, error?: Error, callbacks?: (function((Error | null)=, R=): void)[], force?: true }} CacheEntry */
+	/** @type {Map<T, CacheEntry>} */
+	const cache = new Map();
+	const resultFn = (arg, callback) => {
+		const cacheEntry = cache.get(arg);
+		if (cacheEntry !== undefined) {
+			if (cacheEntry.result !== undefined)
+				return callback(null, cacheEntry.result);
+			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
+			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
+			else cacheEntry.callbacks.push(callback);
+			return;
+		}
+		/** @type {CacheEntry} */
+		const newCacheEntry = {
+			result: undefined,
+			error: undefined,
+			callbacks: undefined
+		};
+		cache.set(arg, newCacheEntry);
+		fn(arg, (err, result) => {
+			if (err) newCacheEntry.error = err;
+			else newCacheEntry.result = result;
+			const callbacks = newCacheEntry.callbacks;
+			newCacheEntry.callbacks = undefined;
+			callback(err, result);
+			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+		});
+	};
+	resultFn.force = (arg, callback) => {
+		const cacheEntry = cache.get(arg);
+		if (cacheEntry !== undefined && cacheEntry.force) {
+			if (cacheEntry.result !== undefined)
+				return callback(null, cacheEntry.result);
+			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
+			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
+			else cacheEntry.callbacks.push(callback);
+			return;
+		}
+		/** @type {CacheEntry} */
+		const newCacheEntry = {
+			result: undefined,
+			error: undefined,
+			callbacks: undefined,
+			force: true
+		};
+		cache.set(arg, newCacheEntry);
+		forceFn(arg, (err, result) => {
+			if (err) newCacheEntry.error = err;
+			else newCacheEntry.result = result;
+			const callbacks = newCacheEntry.callbacks;
+			newCacheEntry.callbacks = undefined;
+			callback(err, result);
+			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
+		});
 	};
+	return resultFn;
 };
 
-module.exports = class SplitChunksPlugin {
+class HttpUriPlugin {
 	/**
-	 * @param {OptimizationSplitChunksOptions=} options plugin options
+	 * @param {HttpUriPluginOptions} options options
 	 */
-	constructor(options = {}) {
-		const defaultSizeTypes = options.defaultSizeTypes || [
-			"javascript",
-			"unknown"
-		];
-		const fallbackCacheGroup = options.fallbackCacheGroup || {};
-		const minSize = normalizeSizes(options.minSize, defaultSizeTypes);
-		const minSizeReduction = normalizeSizes(
-			options.minSizeReduction,
-			defaultSizeTypes
-		);
-		const maxSize = normalizeSizes(options.maxSize, defaultSizeTypes);
-
-		/** @type {SplitChunksOptions} */
-		this.options = {
-			chunksFilter: normalizeChunksFilter(options.chunks || "all"),
-			defaultSizeTypes,
-			minSize,
-			minSizeReduction,
-			minRemainingSize: mergeSizes(
-				normalizeSizes(options.minRemainingSize, defaultSizeTypes),
-				minSize
-			),
-			enforceSizeThreshold: normalizeSizes(
-				options.enforceSizeThreshold,
-				defaultSizeTypes
-			),
-			maxAsyncSize: mergeSizes(
-				normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
-				maxSize
-			),
-			maxInitialSize: mergeSizes(
-				normalizeSizes(options.maxInitialSize, defaultSizeTypes),
-				maxSize
-			),
-			minChunks: options.minChunks || 1,
-			maxAsyncRequests: options.maxAsyncRequests || 1,
-			maxInitialRequests: options.maxInitialRequests || 1,
-			hidePathInfo: options.hidePathInfo || false,
-			filename: options.filename || undefined,
-			getCacheGroups: normalizeCacheGroups(
-				options.cacheGroups,
-				defaultSizeTypes
-			),
-			getName: options.name ? normalizeName(options.name) : defaultGetName,
-			automaticNameDelimiter: options.automaticNameDelimiter,
-			usedExports: options.usedExports,
-			fallbackCacheGroup: {
-				chunksFilter: normalizeChunksFilter(
-					fallbackCacheGroup.chunks || options.chunks || "all"
-				),
-				minSize: mergeSizes(
-					normalizeSizes(fallbackCacheGroup.minSize, defaultSizeTypes),
-					minSize
-				),
-				maxAsyncSize: mergeSizes(
-					normalizeSizes(fallbackCacheGroup.maxAsyncSize, defaultSizeTypes),
-					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
-					normalizeSizes(options.maxAsyncSize, defaultSizeTypes),
-					normalizeSizes(options.maxSize, defaultSizeTypes)
-				),
-				maxInitialSize: mergeSizes(
-					normalizeSizes(fallbackCacheGroup.maxInitialSize, defaultSizeTypes),
-					normalizeSizes(fallbackCacheGroup.maxSize, defaultSizeTypes),
-					normalizeSizes(options.maxInitialSize, defaultSizeTypes),
-					normalizeSizes(options.maxSize, defaultSizeTypes)
-				),
-				automaticNameDelimiter:
-					fallbackCacheGroup.automaticNameDelimiter ||
-					options.automaticNameDelimiter ||
-					"~"
-			}
-		};
-
-		/** @type {WeakMap<CacheGroupSource, CacheGroup>} */
-		this._cacheGroupCache = new WeakMap();
-	}
-
-	/**
-	 * @param {CacheGroupSource} cacheGroupSource source
-	 * @returns {CacheGroup} the cache group (cached)
-	 */
-	_getCacheGroup(cacheGroupSource) {
-		const cacheEntry = this._cacheGroupCache.get(cacheGroupSource);
-		if (cacheEntry !== undefined) return cacheEntry;
-		const minSize = mergeSizes(
-			cacheGroupSource.minSize,
-			cacheGroupSource.enforce ? undefined : this.options.minSize
-		);
-		const minSizeReduction = mergeSizes(
-			cacheGroupSource.minSizeReduction,
-			cacheGroupSource.enforce ? undefined : this.options.minSizeReduction
-		);
-		const minRemainingSize = mergeSizes(
-			cacheGroupSource.minRemainingSize,
-			cacheGroupSource.enforce ? undefined : this.options.minRemainingSize
-		);
-		const enforceSizeThreshold = mergeSizes(
-			cacheGroupSource.enforceSizeThreshold,
-			cacheGroupSource.enforce ? undefined : this.options.enforceSizeThreshold
-		);
-		const cacheGroup = {
-			key: cacheGroupSource.key,
-			priority: cacheGroupSource.priority || 0,
-			chunksFilter: cacheGroupSource.chunksFilter || this.options.chunksFilter,
-			minSize,
-			minSizeReduction,
-			minRemainingSize,
-			enforceSizeThreshold,
-			maxAsyncSize: mergeSizes(
-				cacheGroupSource.maxAsyncSize,
-				cacheGroupSource.enforce ? undefined : this.options.maxAsyncSize
-			),
-			maxInitialSize: mergeSizes(
-				cacheGroupSource.maxInitialSize,
-				cacheGroupSource.enforce ? undefined : this.options.maxInitialSize
-			),
-			minChunks:
-				cacheGroupSource.minChunks !== undefined
-					? cacheGroupSource.minChunks
-					: cacheGroupSource.enforce
-					? 1
-					: this.options.minChunks,
-			maxAsyncRequests:
-				cacheGroupSource.maxAsyncRequests !== undefined
-					? cacheGroupSource.maxAsyncRequests
-					: cacheGroupSource.enforce
-					? Infinity
-					: this.options.maxAsyncRequests,
-			maxInitialRequests:
-				cacheGroupSource.maxInitialRequests !== undefined
-					? cacheGroupSource.maxInitialRequests
-					: cacheGroupSource.enforce
-					? Infinity
-					: this.options.maxInitialRequests,
-			getName:
-				cacheGroupSource.getName !== undefined
-					? cacheGroupSource.getName
-					: this.options.getName,
-			usedExports:
-				cacheGroupSource.usedExports !== undefined
-					? cacheGroupSource.usedExports
-					: this.options.usedExports,
-			filename:
-				cacheGroupSource.filename !== undefined
-					? cacheGroupSource.filename
-					: this.options.filename,
-			automaticNameDelimiter:
-				cacheGroupSource.automaticNameDelimiter !== undefined
-					? cacheGroupSource.automaticNameDelimiter
-					: this.options.automaticNameDelimiter,
-			idHint:
-				cacheGroupSource.idHint !== undefined
-					? cacheGroupSource.idHint
-					: cacheGroupSource.key,
-			reuseExistingChunk: cacheGroupSource.reuseExistingChunk || false,
-			_validateSize: hasNonZeroSizes(minSize),
-			_validateRemainingSize: hasNonZeroSizes(minRemainingSize),
-			_minSizeForMaxSize: mergeSizes(
-				cacheGroupSource.minSize,
-				this.options.minSize
-			),
-			_conditionalEnforce: hasNonZeroSizes(enforceSizeThreshold)
-		};
-		this._cacheGroupCache.set(cacheGroupSource, cacheGroup);
-		return cacheGroup;
-	}
+	constructor(options) {
+		validate(options);
+		this._lockfileLocation = options.lockfileLocation;
+		this._cacheLocation = options.cacheLocation;
+		this._upgrade = options.upgrade;
+		this._frozen = options.frozen;
+		this._allowedUris = options.allowedUris;
+	}
 
 	/**
 	 * Apply the plugin
@@ -113293,1387 +110729,1772 @@ module.exports = class SplitChunksPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-			compiler.context,
-			compiler.root
-		);
-		compiler.hooks.thisCompilation.tap("SplitChunksPlugin", compilation => {
-			const logger = compilation.getLogger("webpack.SplitChunksPlugin");
-			let alreadyOptimized = false;
-			compilation.hooks.unseal.tap("SplitChunksPlugin", () => {
-				alreadyOptimized = false;
-			});
-			compilation.hooks.optimizeChunks.tap(
-				{
-					name: "SplitChunksPlugin",
-					stage: STAGE_ADVANCED
-				},
-				chunks => {
-					if (alreadyOptimized) return;
-					alreadyOptimized = true;
-					logger.time("prepare");
-					const chunkGraph = compilation.chunkGraph;
-					const moduleGraph = compilation.moduleGraph;
-					// Give each selected chunk an index (to create strings from chunks)
-					/** @type {Map<Chunk, bigint>} */
-					const chunkIndexMap = new Map();
-					const ZERO = BigInt("0");
-					const ONE = BigInt("1");
-					const START = ONE << BigInt("31");
-					let index = START;
-					for (const chunk of chunks) {
-						chunkIndexMap.set(
-							chunk,
-							index | BigInt((Math.random() * 0x7fffffff) | 0)
-						);
-						index = index << ONE;
-					}
-					/**
-					 * @param {Iterable<Chunk>} chunks list of chunks
-					 * @returns {bigint | Chunk} key of the chunks
-					 */
-					const getKey = chunks => {
-						const iterator = chunks[Symbol.iterator]();
-						let result = iterator.next();
-						if (result.done) return ZERO;
-						const first = result.value;
-						result = iterator.next();
-						if (result.done) return first;
-						let key =
-							chunkIndexMap.get(first) | chunkIndexMap.get(result.value);
-						while (!(result = iterator.next()).done) {
-							const raw = chunkIndexMap.get(result.value);
-							key = key ^ raw;
-						}
-						return key;
-					};
-					const keyToString = key => {
-						if (typeof key === "bigint") return key.toString(16);
-						return chunkIndexMap.get(key).toString(16);
-					};
+		const schemes = [
+			{
+				scheme: "http",
+				fetch: (url, options, callback) => getHttp().get(url, options, callback)
+			},
+			{
+				scheme: "https",
+				fetch: (url, options, callback) =>
+					getHttps().get(url, options, callback)
+			}
+		];
+		let lockfileCache;
+		compiler.hooks.compilation.tap(
+			"HttpUriPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const intermediateFs = compiler.intermediateFileSystem;
+				const fs = compilation.inputFileSystem;
+				const cache = compilation.getCache("webpack.HttpUriPlugin");
+				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				const lockfileLocation =
+					this._lockfileLocation ||
+					join(
+						intermediateFs,
+						compiler.context,
+						compiler.name
+							? `${toSafePath(compiler.name)}.webpack.lock`
+							: "webpack.lock"
+					);
+				const cacheLocation =
+					this._cacheLocation !== undefined
+						? this._cacheLocation
+						: lockfileLocation + ".data";
+				const upgrade = this._upgrade || false;
+				const frozen = this._frozen || false;
+				const hashFunction = "sha512";
+				const hashDigest = "hex";
+				const hashDigestLength = 20;
+				const allowedUris = this._allowedUris;
 
-					const getChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
-						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
-						const singleChunkSets = new Set();
-						for (const module of compilation.modules) {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							if (typeof chunksKey === "bigint") {
-								if (!chunkSetsInGraph.has(chunksKey)) {
-									chunkSetsInGraph.set(chunksKey, new Set(chunks));
-								}
-							} else {
-								singleChunkSets.add(chunksKey);
-							}
-						}
-						return { chunkSetsInGraph, singleChunkSets };
-					});
+				let warnedAboutEol = false;
 
-					/**
-					 * @param {Module} module the module
-					 * @returns {Iterable<Chunk[]>} groups of chunks with equal exports
-					 */
-					const groupChunksByExports = module => {
-						const exportsInfo = moduleGraph.getExportsInfo(module);
-						const groupedByUsedExports = new Map();
-						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-							const key = exportsInfo.getUsageKey(chunk.runtime);
-							const list = groupedByUsedExports.get(key);
-							if (list !== undefined) {
-								list.push(chunk);
-							} else {
-								groupedByUsedExports.set(key, [chunk]);
-							}
-						}
-						return groupedByUsedExports.values();
-					};
+				const cacheKeyCache = new Map();
+				/**
+				 * @param {string} url the url
+				 * @returns {string} the key
+				 */
+				const getCacheKey = url => {
+					const cachedResult = cacheKeyCache.get(url);
+					if (cachedResult !== undefined) return cachedResult;
+					const result = _getCacheKey(url);
+					cacheKeyCache.set(url, result);
+					return result;
+				};
 
-					/** @type {Map<Module, Iterable<Chunk[]>>} */
-					const groupedByExportsMap = new Map();
+				/**
+				 * @param {string} url the url
+				 * @returns {string} the key
+				 */
+				const _getCacheKey = url => {
+					const parsedUrl = new URL(url);
+					const folder = toSafePath(parsedUrl.origin);
+					const name = toSafePath(parsedUrl.pathname);
+					const query = toSafePath(parsedUrl.search);
+					let ext = extname(name);
+					if (ext.length > 20) ext = "";
+					const basename = ext ? name.slice(0, -ext.length) : name;
+					const hash = createHash(hashFunction);
+					hash.update(url);
+					const digest = hash.digest(hashDigest).slice(0, hashDigestLength);
+					return `${folder.slice(-50)}/${`${basename}${
+						query ? `_${query}` : ""
+					}`.slice(0, 150)}_${digest}${ext}`;
+				};
 
-					const getExportsChunkSetsInGraph = memoize(() => {
-						/** @type {Map<bigint, Set<Chunk>>} */
-						const chunkSetsInGraph = new Map();
-						/** @type {Set<Chunk>} */
-						const singleChunkSets = new Set();
-						for (const module of compilation.modules) {
-							const groupedChunks = Array.from(groupChunksByExports(module));
-							groupedByExportsMap.set(module, groupedChunks);
-							for (const chunks of groupedChunks) {
-								if (chunks.length === 1) {
-									singleChunkSets.add(chunks[0]);
-								} else {
-									const chunksKey = /** @type {bigint} */ (getKey(chunks));
-									if (!chunkSetsInGraph.has(chunksKey)) {
-										chunkSetsInGraph.set(chunksKey, new Set(chunks));
+				const getLockfile = cachedWithoutKey(
+					/**
+					 * @param {function((Error | null)=, Lockfile=): void} callback callback
+					 * @returns {void}
+					 */
+					callback => {
+						const readLockfile = () => {
+							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
+								if (err && err.code !== "ENOENT") {
+									compilation.missingDependencies.add(lockfileLocation);
+									return callback(err);
+								}
+								compilation.fileDependencies.add(lockfileLocation);
+								compilation.fileSystemInfo.createSnapshot(
+									compiler.fsStartTime,
+									buffer ? [lockfileLocation] : [],
+									[],
+									buffer ? [] : [lockfileLocation],
+									{ timestamp: true },
+									(err, snapshot) => {
+										if (err) return callback(err);
+										const lockfile = buffer
+											? Lockfile.parse(buffer.toString("utf-8"))
+											: new Lockfile();
+										lockfileCache = {
+											lockfile,
+											snapshot
+										};
+										callback(null, lockfile);
 									}
+								);
+							});
+						};
+						if (lockfileCache) {
+							compilation.fileSystemInfo.checkSnapshotValid(
+								lockfileCache.snapshot,
+								(err, valid) => {
+									if (err) return callback(err);
+									if (!valid) return readLockfile();
+									callback(null, lockfileCache.lockfile);
 								}
-							}
+							);
+						} else {
+							readLockfile();
 						}
-						return { chunkSetsInGraph, singleChunkSets };
-					});
+					}
+				);
 
-					// group these set of chunks by count
-					// to allow to check less sets via isSubset
-					// (only smaller sets can be subset)
-					const groupChunkSetsByCount = chunkSets => {
-						/** @type {Map<number, Array<Set<Chunk>>>} */
-						const chunkSetsByCount = new Map();
-						for (const chunksSet of chunkSets) {
-							const count = chunksSet.size;
-							let array = chunkSetsByCount.get(count);
-							if (array === undefined) {
-								array = [];
-								chunkSetsByCount.set(count, array);
-							}
-							array.push(chunksSet);
+				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
+				let lockfileUpdates = undefined;
+				const storeLockEntry = (lockfile, url, entry) => {
+					const oldEntry = lockfile.entries.get(url);
+					if (lockfileUpdates === undefined) lockfileUpdates = new Map();
+					lockfileUpdates.set(url, entry);
+					lockfile.entries.set(url, entry);
+					if (!oldEntry) {
+						logger.log(`${url} added to lockfile`);
+					} else if (typeof oldEntry === "string") {
+						if (typeof entry === "string") {
+							logger.log(`${url} updated in lockfile: ${oldEntry} -> ${entry}`);
+						} else {
+							logger.log(
+								`${url} updated in lockfile: ${oldEntry} -> ${entry.resolved}`
+							);
 						}
-						return chunkSetsByCount;
-					};
-					const getChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getChunkSetsInGraph().chunkSetsInGraph.values()
-						)
-					);
-					const getExportsChunkSetsByCount = memoize(() =>
-						groupChunkSetsByCount(
-							getExportsChunkSetsInGraph().chunkSetsInGraph.values()
-						)
-					);
+					} else if (typeof entry === "string") {
+						logger.log(
+							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry}`
+						);
+					} else if (oldEntry.resolved !== entry.resolved) {
+						logger.log(
+							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry.resolved}`
+						);
+					} else if (oldEntry.integrity !== entry.integrity) {
+						logger.log(`${url} updated in lockfile: content changed`);
+					} else if (oldEntry.contentType !== entry.contentType) {
+						logger.log(
+							`${url} updated in lockfile: ${oldEntry.contentType} -> ${entry.contentType}`
+						);
+					} else {
+						logger.log(`${url} updated in lockfile`);
+					}
+				};
 
-					// Create a list of possible combinations
-					const createGetCombinations = (
-						chunkSets,
-						singleChunkSets,
-						chunkSetsByCount
-					) => {
-						/** @type {Map<bigint | Chunk, (Set<Chunk> | Chunk)[]>} */
-						const combinationsCache = new Map();
+				const storeResult = (lockfile, url, result, callback) => {
+					if (result.storeLock) {
+						storeLockEntry(lockfile, url, result.entry);
+						if (!cacheLocation || !result.content)
+							return callback(null, result);
+						const key = getCacheKey(result.entry.resolved);
+						const filePath = join(intermediateFs, cacheLocation, key);
+						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
+							if (err) return callback(err);
+							intermediateFs.writeFile(filePath, result.content, err => {
+								if (err) return callback(err);
+								callback(null, result);
+							});
+						});
+					} else {
+						storeLockEntry(lockfile, url, "no-cache");
+						callback(null, result);
+					}
+				};
 
-						return key => {
-							const cacheEntry = combinationsCache.get(key);
-							if (cacheEntry !== undefined) return cacheEntry;
-							if (key instanceof Chunk) {
-								const result = [key];
-								combinationsCache.set(key, result);
-								return result;
-							}
-							const chunksSet = chunkSets.get(key);
-							/** @type {(Set<Chunk> | Chunk)[]} */
-							const array = [chunksSet];
-							for (const [count, setArray] of chunkSetsByCount) {
-								// "equal" is not needed because they would have been merge in the first step
-								if (count < chunksSet.size) {
-									for (const set of setArray) {
-										if (isSubset(chunksSet, set)) {
-											array.push(set);
-										}
+				for (const { scheme, fetch } of schemes) {
+					/**
+					 *
+					 * @param {string} url URL
+					 * @param {string} integrity integrity
+					 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
+					 */
+					const resolveContent = (url, integrity, callback) => {
+						const handleResult = (err, result) => {
+							if (err) return callback(err);
+							if ("location" in result) {
+								return resolveContent(
+									result.location,
+									integrity,
+									(err, innerResult) => {
+										if (err) return callback(err);
+										callback(null, {
+											entry: innerResult.entry,
+											content: innerResult.content,
+											storeLock: innerResult.storeLock && result.storeLock
+										});
 									}
+								);
+							} else {
+								if (
+									!result.fresh &&
+									integrity &&
+									result.entry.integrity !== integrity &&
+									!verifyIntegrity(result.content, integrity)
+								) {
+									return fetchContent.force(url, handleResult);
 								}
+								return callback(null, {
+									entry: result.entry,
+									content: result.content,
+									storeLock: result.storeLock
+								});
 							}
-							for (const chunk of singleChunkSets) {
-								if (chunksSet.has(chunk)) {
-									array.push(chunk);
-								}
-							}
-							combinationsCache.set(key, array);
-							return array;
 						};
+						fetchContent(url, handleResult);
 					};
 
-					const getCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } = getChunkSetsInGraph();
-						return createGetCombinations(
-							chunkSetsInGraph,
-							singleChunkSets,
-							getChunkSetsByCount()
-						);
-					});
-					const getCombinations = key => getCombinationsFactory()(key);
-
-					const getExportsCombinationsFactory = memoize(() => {
-						const { chunkSetsInGraph, singleChunkSets } =
-							getExportsChunkSetsInGraph();
-						return createGetCombinations(
-							chunkSetsInGraph,
-							singleChunkSets,
-							getExportsChunkSetsByCount()
-						);
-					});
-					const getExportsCombinations = key =>
-						getExportsCombinationsFactory()(key);
-
-					/**
-					 * @typedef {Object} SelectedChunksResult
-					 * @property {Chunk[]} chunks the list of chunks
-					 * @property {bigint | Chunk} key a key of the list
-					 */
-
-					/** @type {WeakMap<Set<Chunk> | Chunk, WeakMap<ChunkFilterFunction, SelectedChunksResult>>} */
-					const selectedChunksCacheByChunksSet = new WeakMap();
-
-					/**
-					 * get list and key by applying the filter function to the list
-					 * It is cached for performance reasons
-					 * @param {Set<Chunk> | Chunk} chunks list of chunks
-					 * @param {ChunkFilterFunction} chunkFilter filter function for chunks
-					 * @returns {SelectedChunksResult} list and key
-					 */
-					const getSelectedChunks = (chunks, chunkFilter) => {
-						let entry = selectedChunksCacheByChunksSet.get(chunks);
-						if (entry === undefined) {
-							entry = new WeakMap();
-							selectedChunksCacheByChunksSet.set(chunks, entry);
-						}
-						/** @type {SelectedChunksResult} */
-						let entry2 = entry.get(chunkFilter);
-						if (entry2 === undefined) {
-							/** @type {Chunk[]} */
-							const selectedChunks = [];
-							if (chunks instanceof Chunk) {
-								if (chunkFilter(chunks)) selectedChunks.push(chunks);
-							} else {
-								for (const chunk of chunks) {
-									if (chunkFilter(chunk)) selectedChunks.push(chunk);
-								}
-							}
-							entry2 = {
-								chunks: selectedChunks,
-								key: getKey(selectedChunks)
-							};
-							entry.set(chunkFilter, entry2);
-						}
-						return entry2;
-					};
-
-					/** @type {Map<string, boolean>} */
-					const alreadyValidatedParents = new Map();
-					/** @type {Set<string>} */
-					const alreadyReportedErrors = new Set();
-
-					// Map a list of chunks to a list of modules
-					// For the key the chunk "index" is used, the value is a SortableSet of modules
-					/** @type {Map<string, ChunksInfoItem>} */
-					const chunksInfoMap = new Map();
+					/** @typedef {{ storeCache: boolean, storeLock: boolean, validUntil: number, etag: string | undefined, fresh: boolean }} FetchResultMeta */
+					/** @typedef {FetchResultMeta & { location: string }} RedirectFetchResult */
+					/** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
+					/** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
 
 					/**
-					 * @param {CacheGroup} cacheGroup the current cache group
-					 * @param {number} cacheGroupIndex the index of the cache group of ordering
-					 * @param {Chunk[]} selectedChunks chunks selected for this module
-					 * @param {bigint | Chunk} selectedChunksKey a key of selectedChunks
-					 * @param {Module} module the current module
+					 * @param {string} url URL
+					 * @param {FetchResult} cachedResult result from cache
+					 * @param {function((Error | null)=, FetchResult=): void} callback callback
 					 * @returns {void}
 					 */
-					const addModuleToChunksInfoMap = (
-						cacheGroup,
-						cacheGroupIndex,
-						selectedChunks,
-						selectedChunksKey,
-						module
-					) => {
-						// Break if minimum number of chunks is not reached
-						if (selectedChunks.length < cacheGroup.minChunks) return;
-						// Determine name for split chunk
-						const name = cacheGroup.getName(
-							module,
-							selectedChunks,
-							cacheGroup.key
-						);
-						// Check if the name is ok
-						const existingChunk = compilation.namedChunks.get(name);
-						if (existingChunk) {
-							const parentValidationKey = `${name}|${
-								typeof selectedChunksKey === "bigint"
-									? selectedChunksKey
-									: selectedChunksKey.debugId
-							}`;
-							const valid = alreadyValidatedParents.get(parentValidationKey);
-							if (valid === false) return;
-							if (valid === undefined) {
-								// Module can only be moved into the existing chunk if the existing chunk
-								// is a parent of all selected chunks
-								let isInAllParents = true;
-								/** @type {Set<ChunkGroup>} */
-								const queue = new Set();
-								for (const chunk of selectedChunks) {
-									for (const group of chunk.groupsIterable) {
-										queue.add(group);
-									}
+					const fetchContentRaw = (url, cachedResult, callback) => {
+						const requestTime = Date.now();
+						fetch(
+							new URL(url),
+							{
+								headers: {
+									"accept-encoding": "gzip, deflate, br",
+									"user-agent": "webpack",
+									"if-none-match": cachedResult
+										? cachedResult.etag || null
+										: null
 								}
-								for (const group of queue) {
-									if (existingChunk.isInGroup(group)) continue;
-									let hasParent = false;
-									for (const parent of group.parentsIterable) {
-										hasParent = true;
-										queue.add(parent);
-									}
-									if (!hasParent) {
-										isInAllParents = false;
+							},
+							res => {
+								const etag = res.headers["etag"];
+								const location = res.headers["location"];
+								const cacheControl = res.headers["cache-control"];
+								const { storeLock, storeCache, validUntil } = parseCacheControl(
+									cacheControl,
+									requestTime
+								);
+								/**
+								 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
+								 * @returns {void}
+								 */
+								const finishWith = partialResult => {
+									if ("location" in partialResult) {
+										logger.debug(
+											`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
+										);
+									} else {
+										logger.debug(
+											`GET ${url} [${res.statusCode}] ${Math.ceil(
+												partialResult.content.length / 1024
+											)} kB${!storeLock ? " no-cache" : ""}`
+										);
 									}
-								}
-								const valid = isInAllParents;
-								alreadyValidatedParents.set(parentValidationKey, valid);
-								if (!valid) {
-									if (!alreadyReportedErrors.has(name)) {
-										alreadyReportedErrors.add(name);
-										compilation.errors.push(
-											new WebpackError(
-												"SplitChunksPlugin\n" +
-													`Cache group "${cacheGroup.key}" conflicts with existing chunk.\n` +
-													`Both have the same name "${name}" and existing chunk is not a parent of the selected modules.\n` +
-													"Use a different name for the cache group or make sure that the existing chunk is a parent (e. g. via dependOn).\n" +
-													'HINT: You can omit "name" to automatically create a name.\n' +
-													"BREAKING CHANGE: webpack < 5 used to allow to use an entrypoint as splitChunk. " +
-													"This is no longer allowed when the entrypoint is not a parent of the selected modules.\n" +
-													"Remove this entrypoint and add modules to cache group's 'test' instead. " +
-													"If you need modules to be evaluated on startup, add them to the existing entrypoints (make them arrays). " +
-													"See migration guide of more info."
-											)
+									const result = {
+										...partialResult,
+										fresh: true,
+										storeLock,
+										storeCache,
+										validUntil,
+										etag
+									};
+									if (!storeCache) {
+										logger.log(
+											`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
 										);
+										return callback(null, result);
+									}
+									cache.store(
+										url,
+										null,
+										{
+											...result,
+											fresh: false
+										},
+										err => {
+											if (err) {
+												logger.warn(
+													`${url} can't be stored in cache: ${err.message}`
+												);
+												logger.debug(err.stack);
+											}
+											callback(null, result);
+										}
+									);
+								};
+								if (res.statusCode === 304) {
+									if (
+										cachedResult.validUntil < validUntil ||
+										cachedResult.storeLock !== storeLock ||
+										cachedResult.storeCache !== storeCache ||
+										cachedResult.etag !== etag
+									) {
+										return finishWith(cachedResult);
+									} else {
+										logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
+										return callback(null, {
+											...cachedResult,
+											fresh: true
+										});
 									}
-									return;
 								}
-							}
-						}
-						// Create key for maps
-						// When it has a name we use the name as key
-						// Otherwise we create the key from chunks and cache group key
-						// This automatically merges equal names
-						const key =
-							cacheGroup.key +
-							(name
-								? ` name:${name}`
-								: ` chunks:${keyToString(selectedChunksKey)}`);
-						// Add module to maps
-						let info = chunksInfoMap.get(key);
-						if (info === undefined) {
-							chunksInfoMap.set(
-								key,
-								(info = {
-									modules: new SortableSet(
-										undefined,
-										compareModulesByIdentifier
-									),
-									cacheGroup,
-									cacheGroupIndex,
-									name,
-									sizes: {},
-									chunks: new Set(),
-									reuseableChunks: new Set(),
-									chunksKeys: new Set()
-								})
-							);
-						}
-						const oldSize = info.modules.size;
-						info.modules.add(module);
-						if (info.modules.size !== oldSize) {
-							for (const type of module.getSourceTypes()) {
-								info.sizes[type] = (info.sizes[type] || 0) + module.size(type);
-							}
-						}
-						const oldChunksKeysSize = info.chunksKeys.size;
-						info.chunksKeys.add(selectedChunksKey);
-						if (oldChunksKeysSize !== info.chunksKeys.size) {
-							for (const chunk of selectedChunks) {
-								info.chunks.add(chunk);
-							}
-						}
-					};
-
-					const context = {
-						moduleGraph,
-						chunkGraph
-					};
-
-					logger.timeEnd("prepare");
+								if (
+									location &&
+									res.statusCode >= 301 &&
+									res.statusCode <= 308
+								) {
+									return finishWith({
+										location: new URL(location, url).href
+									});
+								}
+								const contentType = res.headers["content-type"] || "";
+								const bufferArr = [];
 
-					logger.time("modules");
+								const contentEncoding = res.headers["content-encoding"];
+								let stream = res;
+								if (contentEncoding === "gzip") {
+									stream = stream.pipe(createGunzip());
+								} else if (contentEncoding === "br") {
+									stream = stream.pipe(createBrotliDecompress());
+								} else if (contentEncoding === "deflate") {
+									stream = stream.pipe(createInflate());
+								}
 
-					// Walk through all modules
-					for (const module of compilation.modules) {
-						// Get cache group
-						let cacheGroups = this.options.getCacheGroups(module, context);
-						if (!Array.isArray(cacheGroups) || cacheGroups.length === 0) {
-							continue;
-						}
+								stream.on("data", chunk => {
+									bufferArr.push(chunk);
+								});
 
-						// Prepare some values (usedExports = false)
-						const getCombs = memoize(() => {
-							const chunks = chunkGraph.getModuleChunksIterable(module);
-							const chunksKey = getKey(chunks);
-							return getCombinations(chunksKey);
-						});
+								stream.on("end", () => {
+									if (!res.complete) {
+										logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
+										return callback(new Error(`${url} request was terminated`));
+									}
 
-						// Prepare some values (usedExports = true)
-						const getCombsByUsedExports = memoize(() => {
-							// fill the groupedByExportsMap
-							getExportsChunkSetsInGraph();
-							/** @type {Set<Set<Chunk> | Chunk>} */
-							const set = new Set();
-							const groupedByUsedExports = groupedByExportsMap.get(module);
-							for (const chunks of groupedByUsedExports) {
-								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey))
-									set.add(comb);
-							}
-							return set;
-						});
+									const content = Buffer.concat(bufferArr);
 
-						let cacheGroupIndex = 0;
-						for (const cacheGroupSource of cacheGroups) {
-							const cacheGroup = this._getCacheGroup(cacheGroupSource);
+									if (res.statusCode !== 200) {
+										logger.log(`GET ${url} [${res.statusCode}]`);
+										return callback(
+											new Error(
+												`${url} request status code = ${
+													res.statusCode
+												}\n${content.toString("utf-8")}`
+											)
+										);
+									}
 
-							const combs = cacheGroup.usedExports
-								? getCombsByUsedExports()
-								: getCombs();
-							// For all combination of chunk selection
-							for (const chunkCombination of combs) {
-								// Break if minimum number of chunks is not reached
-								const count =
-									chunkCombination instanceof Chunk ? 1 : chunkCombination.size;
-								if (count < cacheGroup.minChunks) continue;
-								// Select chunks by configuration
-								const { chunks: selectedChunks, key: selectedChunksKey } =
-									getSelectedChunks(chunkCombination, cacheGroup.chunksFilter);
+									const integrity = computeIntegrity(content);
+									const entry = { resolved: url, integrity, contentType };
 
-								addModuleToChunksInfoMap(
-									cacheGroup,
-									cacheGroupIndex,
-									selectedChunks,
-									selectedChunksKey,
-									module
-								);
+									finishWith({
+										entry,
+										content
+									});
+								});
 							}
-							cacheGroupIndex++;
-						}
-					}
-
-					logger.timeEnd("modules");
-
-					logger.time("queue");
+						).on("error", err => {
+							logger.log(`GET ${url} (error)`);
+							err.message += `\nwhile fetching ${url}`;
+							callback(err);
+						});
+					};
 
-					/**
-					 * @param {ChunksInfoItem} info entry
-					 * @param {string[]} sourceTypes source types to be removed
-					 */
-					const removeModulesWithSourceType = (info, sourceTypes) => {
-						for (const module of info.modules) {
-							const types = module.getSourceTypes();
-							if (sourceTypes.some(type => types.has(type))) {
-								info.modules.delete(module);
-								for (const type of types) {
-									info.sizes[type] -= module.size(type);
+					const fetchContent = cachedWithKey(
+						/**
+						 * @param {string} url URL
+						 * @param {function((Error | null)=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
+						 * @returns {void}
+						 */ (url, callback) => {
+							cache.get(url, null, (err, cachedResult) => {
+								if (err) return callback(err);
+								if (cachedResult) {
+									const isValid = cachedResult.validUntil >= Date.now();
+									if (isValid) return callback(null, cachedResult);
 								}
+								fetchContentRaw(url, cachedResult, callback);
+							});
+						},
+						(url, callback) => fetchContentRaw(url, undefined, callback)
+					);
+
+					const isAllowed = uri => {
+						for (const allowed of allowedUris) {
+							if (typeof allowed === "string") {
+								if (uri.startsWith(allowed)) return true;
+							} else if (typeof allowed === "function") {
+								if (allowed(uri)) return true;
+							} else {
+								if (allowed.test(uri)) return true;
 							}
 						}
+						return false;
 					};
 
-					/**
-					 * @param {ChunksInfoItem} info entry
-					 * @returns {boolean} true, if entry become empty
-					 */
-					const removeMinSizeViolatingModules = info => {
-						if (!info.cacheGroup._validateSize) return false;
-						const violatingSizes = getViolatingMinSizes(
-							info.sizes,
-							info.cacheGroup.minSize
-						);
-						if (violatingSizes === undefined) return false;
-						removeModulesWithSourceType(info, violatingSizes);
-						return info.modules.size === 0;
-					};
-
-					// Filter items were size < minSize
-					for (const [key, info] of chunksInfoMap) {
-						if (removeMinSizeViolatingModules(info)) {
-							chunksInfoMap.delete(key);
-						} else if (
-							!checkMinSizeReduction(
-								info.sizes,
-								info.cacheGroup.minSizeReduction,
-								info.chunks.size
-							)
-						) {
-							chunksInfoMap.delete(key);
-						}
-					}
-
-					/**
-					 * @typedef {Object} MaxSizeQueueItem
-					 * @property {SplitChunksSizes} minSize
-					 * @property {SplitChunksSizes} maxAsyncSize
-					 * @property {SplitChunksSizes} maxInitialSize
-					 * @property {string} automaticNameDelimiter
-					 * @property {string[]} keys
-					 */
-
-					/** @type {Map<Chunk, MaxSizeQueueItem>} */
-					const maxSizeQueueMap = new Map();
-
-					while (chunksInfoMap.size > 0) {
-						// Find best matching entry
-						let bestEntryKey;
-						let bestEntry;
-						for (const pair of chunksInfoMap) {
-							const key = pair[0];
-							const info = pair[1];
-							if (
-								bestEntry === undefined ||
-								compareEntries(bestEntry, info) < 0
-							) {
-								bestEntry = info;
-								bestEntryKey = key;
+					const getInfo = cachedWithKey(
+						/**
+						 * @param {string} url the url
+						 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
+						 * @returns {void}
+						 */
+						(url, callback) => {
+							if (!isAllowed(url)) {
+								return callback(
+									new Error(
+										`${url} doesn't match the allowedUris policy. These URIs are allowed:\n${allowedUris
+											.map(uri => ` - ${uri}`)
+											.join("\n")}`
+									)
+								);
 							}
-						}
-
-						const item = bestEntry;
-						chunksInfoMap.delete(bestEntryKey);
-
-						let chunkName = item.name;
-						// Variable for the new chunk (lazy created)
-						/** @type {Chunk} */
-						let newChunk;
-						// When no chunk name, check if we can reuse a chunk instead of creating a new one
-						let isExistingChunk = false;
-						let isReusedWithAllModules = false;
-						if (chunkName) {
-							const chunkByName = compilation.namedChunks.get(chunkName);
-							if (chunkByName !== undefined) {
-								newChunk = chunkByName;
-								const oldSize = item.chunks.size;
-								item.chunks.delete(newChunk);
-								isExistingChunk = item.chunks.size !== oldSize;
-							}
-						} else if (item.cacheGroup.reuseExistingChunk) {
-							outer: for (const chunk of item.chunks) {
-								if (
-									chunkGraph.getNumberOfChunkModules(chunk) !==
-									item.modules.size
-								) {
-									continue;
-								}
-								if (
-									item.chunks.size > 1 &&
-									chunkGraph.getNumberOfEntryModules(chunk) > 0
-								) {
-									continue;
-								}
-								for (const module of item.modules) {
-									if (!chunkGraph.isModuleInChunk(module, chunk)) {
-										continue outer;
+							getLockfile((err, lockfile) => {
+								if (err) return callback(err);
+								const entryOrString = lockfile.entries.get(url);
+								if (!entryOrString) {
+									if (frozen) {
+										return callback(
+											new Error(
+												`${url} has no lockfile entry and lockfile is frozen`
+											)
+										);
 									}
+									resolveContent(url, null, (err, result) => {
+										if (err) return callback(err);
+										storeResult(lockfile, url, result, callback);
+									});
+									return;
 								}
-								if (!newChunk || !newChunk.name) {
-									newChunk = chunk;
-								} else if (
-									chunk.name &&
-									chunk.name.length < newChunk.name.length
-								) {
-									newChunk = chunk;
-								} else if (
-									chunk.name &&
-									chunk.name.length === newChunk.name.length &&
-									chunk.name < newChunk.name
-								) {
-									newChunk = chunk;
+								if (typeof entryOrString === "string") {
+									const entryTag = entryOrString;
+									resolveContent(url, null, (err, result) => {
+										if (err) return callback(err);
+										if (!result.storeLock || entryTag === "ignore")
+											return callback(null, result);
+										if (frozen) {
+											return callback(
+												new Error(
+													`${url} used to have ${entryTag} lockfile entry and has content now, but lockfile is frozen`
+												)
+											);
+										}
+										if (!upgrade) {
+											return callback(
+												new Error(
+													`${url} used to have ${entryTag} lockfile entry and has content now.
+This should be reflected in the lockfile, so this lockfile entry must be upgraded, but upgrading is not enabled.
+Remove this line from the lockfile to force upgrading.`
+												)
+											);
+										}
+										storeResult(lockfile, url, result, callback);
+									});
+									return;
 								}
-							}
-							if (newChunk) {
-								item.chunks.delete(newChunk);
-								chunkName = undefined;
-								isExistingChunk = true;
-								isReusedWithAllModules = true;
-							}
-						}
-
-						const enforced =
-							item.cacheGroup._conditionalEnforce &&
-							checkMinSize(item.sizes, item.cacheGroup.enforceSizeThreshold);
-
-						const usedChunks = new Set(item.chunks);
-
-						// Check if maxRequests condition can be fulfilled
-						if (
-							!enforced &&
-							(Number.isFinite(item.cacheGroup.maxInitialRequests) ||
-								Number.isFinite(item.cacheGroup.maxAsyncRequests))
-						) {
-							for (const chunk of usedChunks) {
-								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-									? Math.min(
-											item.cacheGroup.maxInitialRequests,
-											item.cacheGroup.maxAsyncRequests
-									  )
-									: item.cacheGroup.maxAsyncRequests;
-								if (
-									isFinite(maxRequests) &&
-									getRequests(chunk) >= maxRequests
-								) {
-									usedChunks.delete(chunk);
+								let entry = entryOrString;
+								const doFetch = lockedContent => {
+									resolveContent(url, entry.integrity, (err, result) => {
+										if (err) {
+											if (lockedContent) {
+												logger.warn(
+													`Upgrade request to ${url} failed: ${err.message}`
+												);
+												logger.debug(err.stack);
+												return callback(null, {
+													entry,
+													content: lockedContent
+												});
+											}
+											return callback(err);
+										}
+										if (!result.storeLock) {
+											// When the lockfile entry should be no-cache
+											// we need to update the lockfile
+											if (frozen) {
+												return callback(
+													new Error(
+														`${url} has a lockfile entry and is no-cache now, but lockfile is frozen\nLockfile: ${entryToString(
+															entry
+														)}`
+													)
+												);
+											}
+											storeResult(lockfile, url, result, callback);
+											return;
+										}
+										if (!areLockfileEntriesEqual(result.entry, entry)) {
+											// When the lockfile entry is outdated
+											// we need to update the lockfile
+											if (frozen) {
+												return callback(
+													new Error(
+														`${url} has an outdated lockfile entry, but lockfile is frozen\nLockfile: ${entryToString(
+															entry
+														)}\nExpected: ${entryToString(result.entry)}`
+													)
+												);
+											}
+											storeResult(lockfile, url, result, callback);
+											return;
+										}
+										if (!lockedContent && cacheLocation) {
+											// When the lockfile cache content is missing
+											// we need to update the lockfile
+											if (frozen) {
+												return callback(
+													new Error(
+														`${url} is missing content in the lockfile cache, but lockfile is frozen\nLockfile: ${entryToString(
+															entry
+														)}`
+													)
+												);
+											}
+											storeResult(lockfile, url, result, callback);
+											return;
+										}
+										return callback(null, result);
+									});
+								};
+								if (cacheLocation) {
+									// When there is a lockfile cache
+									// we read the content from there
+									const key = getCacheKey(entry.resolved);
+									const filePath = join(intermediateFs, cacheLocation, key);
+									fs.readFile(filePath, (err, result) => {
+										const content = /** @type {Buffer} */ (result);
+										if (err) {
+											if (err.code === "ENOENT") return doFetch();
+											return callback(err);
+										}
+										const continueWithCachedContent = result => {
+											if (!upgrade) {
+												// When not in upgrade mode, we accept the result from the lockfile cache
+												return callback(null, { entry, content });
+											}
+											return doFetch(content);
+										};
+										if (!verifyIntegrity(content, entry.integrity)) {
+											let contentWithChangedEol;
+											let isEolChanged = false;
+											try {
+												contentWithChangedEol = Buffer.from(
+													content.toString("utf-8").replace(/\r\n/g, "\n")
+												);
+												isEolChanged = verifyIntegrity(
+													contentWithChangedEol,
+													entry.integrity
+												);
+											} catch (e) {
+												// ignore
+											}
+											if (isEolChanged) {
+												if (!warnedAboutEol) {
+													const explainer = `Incorrect end of line sequence was detected in the lockfile cache.
+The lockfile cache is protected by integrity checks, so any external modification will lead to a corrupted lockfile cache.
+When using git make sure to configure .gitattributes correctly for the lockfile cache:
+  **/*webpack.lock.data/** -text
+This will avoid that the end of line sequence is changed by git on Windows.`;
+													if (frozen) {
+														logger.error(explainer);
+													} else {
+														logger.warn(explainer);
+														logger.info(
+															"Lockfile cache will be automatically fixed now, but when lockfile is frozen this would result in an error."
+														);
+													}
+													warnedAboutEol = true;
+												}
+												if (!frozen) {
+													// "fix" the end of line sequence of the lockfile content
+													logger.log(
+														`${filePath} fixed end of line sequence (\\r\\n instead of \\n).`
+													);
+													intermediateFs.writeFile(
+														filePath,
+														contentWithChangedEol,
+														err => {
+															if (err) return callback(err);
+															continueWithCachedContent(contentWithChangedEol);
+														}
+													);
+													return;
+												}
+											}
+											if (frozen) {
+												return callback(
+													new Error(
+														`${
+															entry.resolved
+														} integrity mismatch, expected content with integrity ${
+															entry.integrity
+														} but got ${computeIntegrity(content)}.
+Lockfile corrupted (${
+															isEolChanged
+																? "end of line sequence was unexpectedly changed"
+																: "incorrectly merged? changed by other tools?"
+														}).
+Run build with un-frozen lockfile to automatically fix lockfile.`
+													)
+												);
+											} else {
+												// "fix" the lockfile entry to the correct integrity
+												// the content has priority over the integrity value
+												entry = {
+													...entry,
+													integrity: computeIntegrity(content)
+												};
+												storeLockEntry(lockfile, url, entry);
+											}
+										}
+										continueWithCachedContent(result);
+									});
+								} else {
+									doFetch();
 								}
-							}
-						}
-
-						outer: for (const chunk of usedChunks) {
-							for (const module of item.modules) {
-								if (chunkGraph.isModuleInChunk(module, chunk)) continue outer;
-							}
-							usedChunks.delete(chunk);
+							});
 						}
+					);
 
-						// Were some (invalid) chunks removed from usedChunks?
-						// => readd all modules to the queue, as things could have been changed
-						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk) usedChunks.add(newChunk);
-							if (usedChunks.size >= item.cacheGroup.minChunks) {
-								const chunksArr = Array.from(usedChunks);
-								for (const module of item.modules) {
-									addModuleToChunksInfoMap(
-										item.cacheGroup,
-										item.cacheGroupIndex,
-										chunksArr,
-										getKey(usedChunks),
-										module
-									);
-								}
+					const respondWithUrlModule = (url, resourceData, callback) => {
+						getInfo(url.href, (err, result) => {
+							if (err) return callback(err);
+							resourceData.resource = url.href;
+							resourceData.path = url.origin + url.pathname;
+							resourceData.query = url.search;
+							resourceData.fragment = url.hash;
+							resourceData.context = new URL(
+								".",
+								result.entry.resolved
+							).href.slice(0, -1);
+							resourceData.data.mimetype = result.entry.contentType;
+							callback(null, true);
+						});
+					};
+					normalModuleFactory.hooks.resolveForScheme
+						.for(scheme)
+						.tapAsync(
+							"HttpUriPlugin",
+							(resourceData, resolveData, callback) => {
+								respondWithUrlModule(
+									new URL(resourceData.resource),
+									resourceData,
+									callback
+								);
 							}
-							continue;
-						}
-
-						// Validate minRemainingSize constraint when a single chunk is left over
-						if (
-							!enforced &&
-							item.cacheGroup._validateRemainingSize &&
-							usedChunks.size === 1
-						) {
-							const [chunk] = usedChunks;
-							let chunkSizes = Object.create(null);
-							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								if (!item.modules.has(module)) {
-									for (const type of module.getSourceTypes()) {
-										chunkSizes[type] =
-											(chunkSizes[type] || 0) + module.size(type);
-									}
-								}
+						);
+					normalModuleFactory.hooks.resolveInScheme
+						.for(scheme)
+						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
+							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
+							if (
+								data.dependencyType !== "url" &&
+								!/^\.{0,2}\//.test(resourceData.resource)
+							) {
+								return callback();
 							}
-							const violatingSizes = getViolatingMinSizes(
-								chunkSizes,
-								item.cacheGroup.minRemainingSize
+							respondWithUrlModule(
+								new URL(resourceData.resource, data.context + "/"),
+								resourceData,
+								callback
 							);
-							if (violatingSizes !== undefined) {
-								const oldModulesSize = item.modules.size;
-								removeModulesWithSourceType(item, violatingSizes);
-								if (
-									item.modules.size > 0 &&
-									item.modules.size !== oldModulesSize
-								) {
-									// queue this item again to be processed again
-									// without violating modules
-									chunksInfoMap.set(bestEntryKey, item);
-								}
-								continue;
+						});
+					const hooks = NormalModule.getCompilationHooks(compilation);
+					hooks.readResourceForScheme
+						.for(scheme)
+						.tapAsync("HttpUriPlugin", (resource, module, callback) => {
+							return getInfo(resource, (err, result) => {
+								if (err) return callback(err);
+								module.buildInfo.resourceIntegrity = result.entry.integrity;
+								callback(null, result.content);
+							});
+						});
+					hooks.needBuild.tapAsync(
+						"HttpUriPlugin",
+						(module, context, callback) => {
+							if (
+								module.resource &&
+								module.resource.startsWith(`${scheme}://`)
+							) {
+								getInfo(module.resource, (err, result) => {
+									if (err) return callback(err);
+									if (
+										result.entry.integrity !==
+										module.buildInfo.resourceIntegrity
+									) {
+										return callback(null, true);
+									}
+									callback();
+								});
+							} else {
+								return callback();
 							}
 						}
+					);
+				}
+				compilation.hooks.finishModules.tapAsync(
+					"HttpUriPlugin",
+					(modules, callback) => {
+						if (!lockfileUpdates) return callback();
+						const ext = extname(lockfileLocation);
+						const tempFile = join(
+							intermediateFs,
+							dirname(intermediateFs, lockfileLocation),
+							`.${basename(lockfileLocation, ext)}.${
+								(Math.random() * 10000) | 0
+							}${ext}`
+						);
 
-						// Create the new chunk if not reusing one
-						if (newChunk === undefined) {
-							newChunk = compilation.addChunk(chunkName);
-						}
-						// Walk through all chunks
-						for (const chunk of usedChunks) {
-							// Add graph connections for splitted chunk
-							chunk.split(newChunk);
-						}
-
-						// Add a note to the chunk
-						newChunk.chunkReason =
-							(newChunk.chunkReason ? newChunk.chunkReason + ", " : "") +
-							(isReusedWithAllModules
-								? "reused as split chunk"
-								: "split chunk");
-						if (item.cacheGroup.key) {
-							newChunk.chunkReason += ` (cache group: ${item.cacheGroup.key})`;
-						}
-						if (chunkName) {
-							newChunk.chunkReason += ` (name: ${chunkName})`;
-						}
-						if (item.cacheGroup.filename) {
-							newChunk.filenameTemplate = item.cacheGroup.filename;
-						}
-						if (item.cacheGroup.idHint) {
-							newChunk.idNameHints.add(item.cacheGroup.idHint);
-						}
-						if (!isReusedWithAllModules) {
-							// Add all modules to the new chunk
-							for (const module of item.modules) {
-								if (!module.chunkCondition(newChunk, compilation)) continue;
-								// Add module to new chunk
-								chunkGraph.connectChunkAndModule(newChunk, module);
-								// Remove module from used chunks
-								for (const chunk of usedChunks) {
-									chunkGraph.disconnectChunkAndModule(chunk, module);
-								}
+						const writeDone = () => {
+							const nextOperation = inProgressWrite.shift();
+							if (nextOperation) {
+								nextOperation();
+							} else {
+								inProgressWrite = undefined;
 							}
-						} else {
-							// Remove all modules from used chunks
-							for (const module of item.modules) {
-								for (const chunk of usedChunks) {
-									chunkGraph.disconnectChunkAndModule(chunk, module);
+						};
+						const runWrite = () => {
+							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
+								if (err && err.code !== "ENOENT") {
+									writeDone();
+									return callback(err);
 								}
-							}
+								const lockfile = buffer
+									? Lockfile.parse(buffer.toString("utf-8"))
+									: new Lockfile();
+								for (const [key, value] of lockfileUpdates) {
+									lockfile.entries.set(key, value);
+								}
+								intermediateFs.writeFile(tempFile, lockfile.toString(), err => {
+									if (err) {
+										writeDone();
+										return intermediateFs.unlink(tempFile, () => callback(err));
+									}
+									intermediateFs.rename(tempFile, lockfileLocation, err => {
+										if (err) {
+											writeDone();
+											return intermediateFs.unlink(tempFile, () =>
+												callback(err)
+											);
+										}
+										writeDone();
+										callback();
+									});
+								});
+							});
+						};
+						if (inProgressWrite) {
+							inProgressWrite.push(runWrite);
+						} else {
+							inProgressWrite = [];
+							runWrite();
 						}
+					}
+				);
+			}
+		);
+	}
+}
 
-						if (
-							Object.keys(item.cacheGroup.maxAsyncSize).length > 0 ||
-							Object.keys(item.cacheGroup.maxInitialSize).length > 0
-						) {
-							const oldMaxSizeSettings = maxSizeQueueMap.get(newChunk);
-							maxSizeQueueMap.set(newChunk, {
-								minSize: oldMaxSizeSettings
-									? combineSizes(
-											oldMaxSizeSettings.minSize,
-											item.cacheGroup._minSizeForMaxSize,
-											Math.max
-									  )
-									: item.cacheGroup.minSize,
-								maxAsyncSize: oldMaxSizeSettings
-									? combineSizes(
-											oldMaxSizeSettings.maxAsyncSize,
-											item.cacheGroup.maxAsyncSize,
-											Math.min
-									  )
-									: item.cacheGroup.maxAsyncSize,
-								maxInitialSize: oldMaxSizeSettings
-									? combineSizes(
-											oldMaxSizeSettings.maxInitialSize,
-											item.cacheGroup.maxInitialSize,
-											Math.min
-									  )
-									: item.cacheGroup.maxInitialSize,
-								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
-								keys: oldMaxSizeSettings
-									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
-									: [item.cacheGroup.key]
-							});
-						}
-
-						// remove all modules from other entries and update size
-						for (const [key, info] of chunksInfoMap) {
-							if (isOverlap(info.chunks, usedChunks)) {
-								// update modules and total size
-								// may remove it from the map when < minSize
-								let updated = false;
-								for (const module of item.modules) {
-									if (info.modules.has(module)) {
-										// remove module
-										info.modules.delete(module);
-										// update size
-										for (const key of module.getSourceTypes()) {
-											info.sizes[key] -= module.size(key);
-										}
-										updated = true;
-									}
-								}
-								if (updated) {
-									if (info.modules.size === 0) {
-										chunksInfoMap.delete(key);
-										continue;
-									}
-									if (
-										removeMinSizeViolatingModules(info) ||
-										!checkMinSizeReduction(
-											info.sizes,
-											info.cacheGroup.minSizeReduction,
-											info.chunks.size
-										)
-									) {
-										chunksInfoMap.delete(key);
-										continue;
-									}
-								}
-							}
-						}
-					}
-
-					logger.timeEnd("queue");
-
-					logger.time("maxSize");
-
-					/** @type {Set<string>} */
-					const incorrectMinMaxSizeSet = new Set();
-
-					const { outputOptions } = compilation;
-
-					// Make sure that maxSize is fulfilled
-					const { fallbackCacheGroup } = this.options;
-					for (const chunk of Array.from(compilation.chunks)) {
-						const chunkConfig = maxSizeQueueMap.get(chunk);
-						const {
-							minSize,
-							maxAsyncSize,
-							maxInitialSize,
-							automaticNameDelimiter
-						} = chunkConfig || fallbackCacheGroup;
-						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
-							continue;
-						/** @type {SplitChunksSizes} */
-						let maxSize;
-						if (chunk.isOnlyInitial()) {
-							maxSize = maxInitialSize;
-						} else if (chunk.canBeInitial()) {
-							maxSize = combineSizes(maxAsyncSize, maxInitialSize, Math.min);
-						} else {
-							maxSize = maxAsyncSize;
-						}
-						if (Object.keys(maxSize).length === 0) {
-							continue;
-						}
-						for (const key of Object.keys(maxSize)) {
-							const maxSizeValue = maxSize[key];
-							const minSizeValue = minSize[key];
-							if (
-								typeof minSizeValue === "number" &&
-								minSizeValue > maxSizeValue
-							) {
-								const keys = chunkConfig && chunkConfig.keys;
-								const warningKey = `${
-									keys && keys.join()
-								} ${minSizeValue} ${maxSizeValue}`;
-								if (!incorrectMinMaxSizeSet.has(warningKey)) {
-									incorrectMinMaxSizeSet.add(warningKey);
-									compilation.warnings.push(
-										new MinMaxSizeWarning(keys, minSizeValue, maxSizeValue)
-									);
-								}
-							}
-						}
-						const results = deterministicGroupingForModules({
-							minSize,
-							maxSize: mapObject(maxSize, (value, key) => {
-								const minSizeValue = minSize[key];
-								return typeof minSizeValue === "number"
-									? Math.max(value, minSizeValue)
-									: value;
-							}),
-							items: chunkGraph.getChunkModulesIterable(chunk),
-							getKey(module) {
-								const cache = getKeyCache.get(module);
-								if (cache !== undefined) return cache;
-								const ident = cachedMakePathsRelative(module.identifier());
-								const nameForCondition =
-									module.nameForCondition && module.nameForCondition();
-								const name = nameForCondition
-									? cachedMakePathsRelative(nameForCondition)
-									: ident.replace(/^.*!|\?[^?!]*$/g, "");
-								const fullKey =
-									name +
-									automaticNameDelimiter +
-									hashFilename(ident, outputOptions);
-								const key = requestToId(fullKey);
-								getKeyCache.set(module, key);
-								return key;
-							},
-							getSize(module) {
-								const size = Object.create(null);
-								for (const key of module.getSourceTypes()) {
-									size[key] = module.size(key);
-								}
-								return size;
-							}
-						});
-						if (results.length <= 1) {
-							continue;
-						}
-						for (let i = 0; i < results.length; i++) {
-							const group = results[i];
-							const key = this.options.hidePathInfo
-								? hashFilename(group.key, outputOptions)
-								: group.key;
-							let name = chunk.name
-								? chunk.name + automaticNameDelimiter + key
-								: null;
-							if (name && name.length > 100) {
-								name =
-									name.slice(0, 100) +
-									automaticNameDelimiter +
-									hashFilename(name, outputOptions);
-							}
-							if (i !== results.length - 1) {
-								const newPart = compilation.addChunk(name);
-								chunk.split(newPart);
-								newPart.chunkReason = chunk.chunkReason;
-								// Add all modules to the new chunk
-								for (const module of group.items) {
-									if (!module.chunkCondition(newPart, compilation)) {
-										continue;
-									}
-									// Add module to new chunk
-									chunkGraph.connectChunkAndModule(newPart, module);
-									// Remove module from used chunks
-									chunkGraph.disconnectChunkAndModule(chunk, module);
-								}
-							} else {
-								// change the chunk to be a part
-								chunk.name = name;
-							}
-						}
-					}
-					logger.timeEnd("maxSize");
-				}
-			);
-		});
-	}
-};
+module.exports = HttpUriPlugin;
 
 
 /***/ }),
 
-/***/ 52149:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 41721:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
 */
 
 
 
-const { formatSize } = __webpack_require__(71070);
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
-
-module.exports = class AssetsOverSizeLimitWarning extends WebpackError {
-	/**
-	 * @param {AssetDetails[]} assetsOverSizeLimit the assets
-	 * @param {number} assetLimit the size limit
-	 */
-	constructor(assetsOverSizeLimit, assetLimit) {
-		const assetLists = assetsOverSizeLimit
-			.map(asset => `\n  ${asset.name} (${formatSize(asset.size)})`)
-			.join("");
-
-		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(
-			assetLimit
-		)}).
-This can impact web performance.
-Assets: ${assetLists}`);
-
-		this.name = "AssetsOverSizeLimitWarning";
-		this.assets = assetsOverSizeLimit;
+class ArraySerializer {
+	serialize(array, { write }) {
+		write(array.length);
+		for (const item of array) write(item);
 	}
-};
+	deserialize({ read }) {
+		const length = read();
+		const array = [];
+		for (let i = 0; i < length; i++) {
+			array.push(read());
+		}
+		return array;
+	}
+}
+
+module.exports = ArraySerializer;
 
 
 /***/ }),
 
-/***/ 84229:
+/***/ 97059:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
 */
 
 
 
-const { formatSize } = __webpack_require__(71070);
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
-
-module.exports = class EntrypointsOverSizeLimitWarning extends WebpackError {
-	/**
-	 * @param {EntrypointDetails[]} entrypoints the entrypoints
-	 * @param {number} entrypointLimit the size limit
-	 */
-	constructor(entrypoints, entrypointLimit) {
-		const entrypointList = entrypoints
-			.map(
-				entrypoint =>
-					`\n  ${entrypoint.name} (${formatSize(
-						entrypoint.size
-					)})\n${entrypoint.files.map(asset => `      ${asset}`).join("\n")}`
-			)
-			.join("");
-		super(`entrypoint size limit: The following entrypoint(s) combined asset size exceeds the recommended limit (${formatSize(
-			entrypointLimit
-		)}). This can impact web performance.
-Entrypoints:${entrypointList}\n`);
-
-		this.name = "EntrypointsOverSizeLimitWarning";
-		this.entrypoints = entrypoints;
-	}
-};
+const memoize = __webpack_require__(78676);
+const SerializerMiddleware = __webpack_require__(83137);
 
+/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/***/ }),
+/*
+Format:
 
-/***/ 17791:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+File -> Section*
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
-*/
+Section -> NullsSection |
+					 BooleansSection |
+					 F64NumbersSection |
+					 I32NumbersSection |
+					 I8NumbersSection |
+					 ShortStringSection |
+					 StringSection |
+					 BufferSection |
+					 NopSection
 
 
 
-const WebpackError = __webpack_require__(53799);
+NullsSection ->
+	NullHeaderByte | Null2HeaderByte | Null3HeaderByte |
+	Nulls8HeaderByte 0xnn (n:count - 4) |
+	Nulls32HeaderByte n:ui32 (n:count - 260) |
+BooleansSection -> TrueHeaderByte | FalseHeaderByte | BooleansSectionHeaderByte BooleansCountAndBitsByte
+F64NumbersSection -> F64NumbersSectionHeaderByte f64*
+I32NumbersSection -> I32NumbersSectionHeaderByte i32*
+I8NumbersSection -> I8NumbersSectionHeaderByte i8*
+ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
+StringSection -> StringSectionHeaderByte i32:length utf8-byte*
+BufferSection -> BufferSectionHeaderByte i32:length byte*
+NopSection --> NopSectionHeaderByte
 
-module.exports = class NoAsyncChunksWarning extends WebpackError {
-	constructor() {
-		super(
-			"webpack performance recommendations: \n" +
-				"You can limit the size of your bundles by using import() or require.ensure to lazy load some parts of your application.\n" +
-				"For more info visit https://webpack.js.org/guides/code-splitting/"
-		);
+ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
 
-		this.name = "NoAsyncChunksWarning";
-	}
-};
+F64NumbersSectionHeaderByte -> 0b001n_nnnn (n:count - 1)
+I32NumbersSectionHeaderByte -> 0b010n_nnnn (n:count - 1)
+I8NumbersSectionHeaderByte -> 0b011n_nnnn (n:count - 1)
 
+NullsSectionHeaderByte -> 0b0001_nnnn (n:count - 1)
+BooleansCountAndBitsByte ->
+	0b0000_1xxx (count = 3) |
+	0b0001_xxxx (count = 4) |
+	0b001x_xxxx (count = 5) |
+	0b01xx_xxxx (count = 6) |
+	0b1nnn_nnnn (n:count - 7, 7 <= count <= 133)
+	0xff n:ui32 (n:count, 134 <= count < 2^32)
 
-/***/ }),
+StringSectionHeaderByte -> 0b0000_1110
+BufferSectionHeaderByte -> 0b0000_1111
+NopSectionHeaderByte -> 0b0000_1011
+FalseHeaderByte -> 0b0000_1100
+TrueHeaderByte -> 0b0000_1101
 
-/***/ 32557:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+RawNumber -> n (n <= 10)
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sean Larkin @thelarkinn
 */
 
+const LAZY_HEADER = 0x0b;
+const TRUE_HEADER = 0x0c;
+const FALSE_HEADER = 0x0d;
+const BOOLEANS_HEADER = 0x0e;
+const NULL_HEADER = 0x10;
+const NULL2_HEADER = 0x11;
+const NULL3_HEADER = 0x12;
+const NULLS8_HEADER = 0x13;
+const NULLS32_HEADER = 0x14;
+const NULL_AND_I8_HEADER = 0x15;
+const NULL_AND_I32_HEADER = 0x16;
+const NULL_AND_TRUE_HEADER = 0x17;
+const NULL_AND_FALSE_HEADER = 0x18;
+const STRING_HEADER = 0x1e;
+const BUFFER_HEADER = 0x1f;
+const I8_HEADER = 0x60;
+const I32_HEADER = 0x40;
+const F64_HEADER = 0x20;
+const SHORT_STRING_HEADER = 0x80;
+
+/** Uplift high-order bits */
+const NUMBERS_HEADER_MASK = 0xe0;
+const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
+const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
 
+const HEADER_SIZE = 1;
+const I8_SIZE = 1;
+const I32_SIZE = 4;
+const F64_SIZE = 8;
 
-const { find } = __webpack_require__(93347);
-const AssetsOverSizeLimitWarning = __webpack_require__(52149);
-const EntrypointsOverSizeLimitWarning = __webpack_require__(84229);
-const NoAsyncChunksWarning = __webpack_require__(17791);
+const MEASURE_START_OPERATION = Symbol("MEASURE_START_OPERATION");
+const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
+/** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
 
-/**
- * @typedef {Object} AssetDetails
- * @property {string} name
- * @property {number} size
- */
+const identifyNumber = n => {
+	if (n === (n | 0)) {
+		if (n <= 127 && n >= -128) return 0;
+		if (n <= 2147483647 && n >= -2147483648) return 1;
+	}
+	return 2;
+};
 
 /**
- * @typedef {Object} EntrypointDetails
- * @property {string} name
- * @property {number} size
- * @property {string[]} files
+ * @typedef {PrimitiveSerializableType[]} DeserializedType
+ * @typedef {BufferSerializableType[]} SerializedType
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
-
-const isOverSizeLimitSet = new WeakSet();
-
-const excludeSourceMap = (name, source, info) => !info.development;
-
-module.exports = class SizeLimitsPlugin {
+class BinaryMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {PerformanceOptions} options the plugin options
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
 	 */
-	constructor(options) {
-		this.hints = options.hints;
-		this.maxAssetSize = options.maxAssetSize;
-		this.maxEntrypointSize = options.maxEntrypointSize;
-		this.assetFilter = options.assetFilter;
+	serialize(data, context) {
+		return this._serialize(data, context);
 	}
 
-	/**
-	 * @param {ChunkGroup | Source} thing the resource to test
-	 * @returns {boolean} true if over the limit
-	 */
-	static isOverSizeLimit(thing) {
-		return isOverSizeLimitSet.has(thing);
+	_serializeLazy(fn, context) {
+		return SerializerMiddleware.serializeLazy(fn, data =>
+			this._serialize(data, context)
+		);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
+	 * @returns {SerializedType} serialized data
 	 */
-	apply(compiler) {
-		const entrypointSizeLimit = this.maxEntrypointSize;
-		const assetSizeLimit = this.maxAssetSize;
-		const hints = this.hints;
-		const assetFilter = this.assetFilter || excludeSourceMap;
-
-		compiler.hooks.afterEmit.tap("SizeLimitsPlugin", compilation => {
-			/** @type {WebpackError[]} */
-			const warnings = [];
-
-			/**
-			 * @param {Entrypoint} entrypoint an entrypoint
-			 * @returns {number} the size of the entrypoint
-			 */
-			const getEntrypointSize = entrypoint => {
-				let size = 0;
-				for (const file of entrypoint.getFiles()) {
-					const asset = compilation.getAsset(file);
-					if (
-						asset &&
-						assetFilter(asset.name, asset.source, asset.info) &&
-						asset.source
-					) {
-						size += asset.info.size || asset.source.size();
-					}
-				}
-				return size;
-			};
-
-			/** @type {AssetDetails[]} */
-			const assetsOverSizeLimit = [];
-			for (const { name, source, info } of compilation.getAssets()) {
-				if (!assetFilter(name, source, info) || !source) {
-					continue;
-				}
-
-				const size = info.size || source.size();
-				if (size > assetSizeLimit) {
-					assetsOverSizeLimit.push({
-						name,
-						size
-					});
-					isOverSizeLimitSet.add(source);
-				}
+	_serialize(
+		data,
+		context,
+		allocationScope = {
+			allocationSize: 1024,
+			increaseCounter: 0,
+			leftOverBuffer: null
+		}
+	) {
+		/** @type {Buffer} */
+		let leftOverBuffer = null;
+		/** @type {BufferSerializableType[]} */
+		let buffers = [];
+		/** @type {Buffer} */
+		let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
+		allocationScope.leftOverBuffer = null;
+		let currentPosition = 0;
+		if (currentBuffer === null) {
+			currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
+		}
+		const allocate = bytesNeeded => {
+			if (currentBuffer !== null) {
+				if (currentBuffer.length - currentPosition >= bytesNeeded) return;
+				flush();
 			}
-
-			const fileFilter = name => {
-				const asset = compilation.getAsset(name);
-				return asset && assetFilter(asset.name, asset.source, asset.info);
-			};
-
-			/** @type {EntrypointDetails[]} */
-			const entrypointsOverLimit = [];
-			for (const [name, entry] of compilation.entrypoints) {
-				const size = getEntrypointSize(entry);
-
-				if (size > entrypointSizeLimit) {
-					entrypointsOverLimit.push({
-						name: name,
-						size: size,
-						files: entry.getFiles().filter(fileFilter)
-					});
-					isOverSizeLimitSet.add(entry);
+			if (leftOverBuffer && leftOverBuffer.length >= bytesNeeded) {
+				currentBuffer = leftOverBuffer;
+				leftOverBuffer = null;
+			} else {
+				currentBuffer = Buffer.allocUnsafe(
+					Math.max(bytesNeeded, allocationScope.allocationSize)
+				);
+				if (
+					!(allocationScope.increaseCounter =
+						(allocationScope.increaseCounter + 1) % 4) &&
+					allocationScope.allocationSize < 16777216
+				) {
+					allocationScope.allocationSize = allocationScope.allocationSize << 1;
 				}
 			}
-
-			if (hints) {
-				// 1. Individual Chunk: Size < 250kb
-				// 2. Collective Initial Chunks [entrypoint] (Each Set?): Size < 250kb
-				// 3. No Async Chunks
-				// if !1, then 2, if !2 return
-				if (assetsOverSizeLimit.length > 0) {
-					warnings.push(
-						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
+		};
+		const flush = () => {
+			if (currentBuffer !== null) {
+				if (currentPosition > 0) {
+					buffers.push(
+						Buffer.from(
+							currentBuffer.buffer,
+							currentBuffer.byteOffset,
+							currentPosition
+						)
 					);
 				}
-				if (entrypointsOverLimit.length > 0) {
-					warnings.push(
-						new EntrypointsOverSizeLimitWarning(
-							entrypointsOverLimit,
-							entrypointSizeLimit
-						)
+				if (
+					!leftOverBuffer ||
+					leftOverBuffer.length < currentBuffer.length - currentPosition
+				) {
+					leftOverBuffer = Buffer.from(
+						currentBuffer.buffer,
+						currentBuffer.byteOffset + currentPosition,
+						currentBuffer.byteLength - currentPosition
 					);
 				}
 
-				if (warnings.length > 0) {
-					const someAsyncChunk = find(
-						compilation.chunks,
-						chunk => !chunk.canBeInitial()
-					);
+				currentBuffer = null;
+				currentPosition = 0;
+			}
+		};
+		const writeU8 = byte => {
+			currentBuffer.writeUInt8(byte, currentPosition++);
+		};
+		const writeU32 = ui32 => {
+			currentBuffer.writeUInt32LE(ui32, currentPosition);
+			currentPosition += 4;
+		};
+		const measureStack = [];
+		const measureStart = () => {
+			measureStack.push(buffers.length, currentPosition);
+		};
+		const measureEnd = () => {
+			const oldPos = measureStack.pop();
+			const buffersIndex = measureStack.pop();
+			let size = currentPosition - oldPos;
+			for (let i = buffersIndex; i < buffers.length; i++) {
+				size += buffers[i].length;
+			}
+			return size;
+		};
+		for (let i = 0; i < data.length; i++) {
+			const thing = data[i];
+			switch (typeof thing) {
+				case "function": {
+					if (!SerializerMiddleware.isLazy(thing))
+						throw new Error("Unexpected function " + thing);
+					/** @type {SerializedType | (() => SerializedType)} */
+					let serializedData =
+						SerializerMiddleware.getLazySerializedValue(thing);
+					if (serializedData === undefined) {
+						if (SerializerMiddleware.isLazy(thing, this)) {
+							flush();
+							allocationScope.leftOverBuffer = leftOverBuffer;
+							const result =
+								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
+									thing()
+								);
+							const data = this._serialize(result, context, allocationScope);
+							leftOverBuffer = allocationScope.leftOverBuffer;
+							allocationScope.leftOverBuffer = null;
+							SerializerMiddleware.setLazySerializedValue(thing, data);
+							serializedData = data;
+						} else {
+							serializedData = this._serializeLazy(thing, context);
+							flush();
+							buffers.push(serializedData);
+							break;
+						}
+					} else {
+						if (typeof serializedData === "function") {
+							flush();
+							buffers.push(serializedData);
+							break;
+						}
+					}
+					const lengths = [];
+					for (const item of serializedData) {
+						let last;
+						if (typeof item === "function") {
+							lengths.push(0);
+						} else if (item.length === 0) {
+							// ignore
+						} else if (
+							lengths.length > 0 &&
+							(last = lengths[lengths.length - 1]) !== 0
+						) {
+							const remaining = 0xffffffff - last;
+							if (remaining >= item.length) {
+								lengths[lengths.length - 1] += item.length;
+							} else {
+								lengths.push(item.length - remaining);
+								lengths[lengths.length - 2] = 0xffffffff;
+							}
+						} else {
+							lengths.push(item.length);
+						}
+					}
+					allocate(5 + lengths.length * 4);
+					writeU8(LAZY_HEADER);
+					writeU32(lengths.length);
+					for (const l of lengths) {
+						writeU32(l);
+					}
+					flush();
+					for (const item of serializedData) {
+						buffers.push(item);
+					}
+					break;
+				}
+				case "string": {
+					const len = Buffer.byteLength(thing);
+					if (len >= 128 || len !== thing.length) {
+						allocate(len + HEADER_SIZE + I32_SIZE);
+						writeU8(STRING_HEADER);
+						writeU32(len);
+						currentBuffer.write(thing, currentPosition);
+						currentPosition += len;
+					} else if (len >= 70) {
+						allocate(len + HEADER_SIZE);
+						writeU8(SHORT_STRING_HEADER | len);
 
-					if (!someAsyncChunk) {
-						warnings.push(new NoAsyncChunksWarning());
+						currentBuffer.write(thing, currentPosition, "latin1");
+						currentPosition += len;
+					} else {
+						allocate(len + HEADER_SIZE);
+						writeU8(SHORT_STRING_HEADER | len);
+
+						for (let i = 0; i < len; i++) {
+							currentBuffer[currentPosition++] = thing.charCodeAt(i);
+						}
+					}
+					break;
+				}
+				case "number": {
+					const type = identifyNumber(thing);
+					if (type === 0 && thing >= 0 && thing <= 10) {
+						// shortcut for very small numbers
+						allocate(I8_SIZE);
+						writeU8(thing);
+						break;
+					}
+					/**
+					 * amount of numbers to write
+					 * @type {number}
+					 */
+					let n = 1;
+					for (; n < 32 && i + n < data.length; n++) {
+						const item = data[i + n];
+						if (typeof item !== "number") break;
+						if (identifyNumber(item) !== type) break;
+					}
+					switch (type) {
+						case 0:
+							allocate(HEADER_SIZE + I8_SIZE * n);
+							writeU8(I8_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt8(
+									/** @type {number} */ (data[i]),
+									currentPosition
+								);
+								currentPosition += I8_SIZE;
+								n--;
+								i++;
+							}
+							break;
+						case 1:
+							allocate(HEADER_SIZE + I32_SIZE * n);
+							writeU8(I32_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeInt32LE(
+									/** @type {number} */ (data[i]),
+									currentPosition
+								);
+								currentPosition += I32_SIZE;
+								n--;
+								i++;
+							}
+							break;
+						case 2:
+							allocate(HEADER_SIZE + F64_SIZE * n);
+							writeU8(F64_HEADER | (n - 1));
+							while (n > 0) {
+								currentBuffer.writeDoubleLE(
+									/** @type {number} */ (data[i]),
+									currentPosition
+								);
+								currentPosition += F64_SIZE;
+								n--;
+								i++;
+							}
+							break;
 					}
 
-					if (hints === "error") {
-						compilation.errors.push(...warnings);
+					i--;
+					break;
+				}
+				case "boolean": {
+					let lastByte = thing === true ? 1 : 0;
+					const bytes = [];
+					let count = 1;
+					let n;
+					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
+						const item = data[i + n];
+						if (typeof item !== "boolean") break;
+						const pos = count & 0x7;
+						if (pos === 0) {
+							bytes.push(lastByte);
+							lastByte = item === true ? 1 : 0;
+						} else if (item === true) {
+							lastByte |= 1 << pos;
+						}
+						count++;
+					}
+					i += count - 1;
+					if (count === 1) {
+						allocate(HEADER_SIZE);
+						writeU8(lastByte === 1 ? TRUE_HEADER : FALSE_HEADER);
+					} else if (count === 2) {
+						allocate(HEADER_SIZE * 2);
+						writeU8(lastByte & 1 ? TRUE_HEADER : FALSE_HEADER);
+						writeU8(lastByte & 2 ? TRUE_HEADER : FALSE_HEADER);
+					} else if (count <= 6) {
+						allocate(HEADER_SIZE + I8_SIZE);
+						writeU8(BOOLEANS_HEADER);
+						writeU8((1 << count) | lastByte);
+					} else if (count <= 133) {
+						allocate(HEADER_SIZE + I8_SIZE + I8_SIZE * bytes.length + I8_SIZE);
+						writeU8(BOOLEANS_HEADER);
+						writeU8(0x80 | (count - 7));
+						for (const byte of bytes) writeU8(byte);
+						writeU8(lastByte);
 					} else {
-						compilation.warnings.push(...warnings);
+						allocate(
+							HEADER_SIZE +
+								I8_SIZE +
+								I32_SIZE +
+								I8_SIZE * bytes.length +
+								I8_SIZE
+						);
+						writeU8(BOOLEANS_HEADER);
+						writeU8(0xff);
+						writeU32(count);
+						for (const byte of bytes) writeU8(byte);
+						writeU8(lastByte);
+					}
+					break;
+				}
+				case "object": {
+					if (thing === null) {
+						let n;
+						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
+							const item = data[i + n];
+							if (item !== null) break;
+						}
+						i += n - 1;
+						if (n === 1) {
+							if (i + 1 < data.length) {
+								const next = data[i + 1];
+								if (next === true) {
+									allocate(HEADER_SIZE);
+									writeU8(NULL_AND_TRUE_HEADER);
+									i++;
+								} else if (next === false) {
+									allocate(HEADER_SIZE);
+									writeU8(NULL_AND_FALSE_HEADER);
+									i++;
+								} else if (typeof next === "number") {
+									const type = identifyNumber(next);
+									if (type === 0) {
+										allocate(HEADER_SIZE + I8_SIZE);
+										writeU8(NULL_AND_I8_HEADER);
+										currentBuffer.writeInt8(next, currentPosition);
+										currentPosition += I8_SIZE;
+										i++;
+									} else if (type === 1) {
+										allocate(HEADER_SIZE + I32_SIZE);
+										writeU8(NULL_AND_I32_HEADER);
+										currentBuffer.writeInt32LE(next, currentPosition);
+										currentPosition += I32_SIZE;
+										i++;
+									} else {
+										allocate(HEADER_SIZE);
+										writeU8(NULL_HEADER);
+									}
+								} else {
+									allocate(HEADER_SIZE);
+									writeU8(NULL_HEADER);
+								}
+							} else {
+								allocate(HEADER_SIZE);
+								writeU8(NULL_HEADER);
+							}
+						} else if (n === 2) {
+							allocate(HEADER_SIZE);
+							writeU8(NULL2_HEADER);
+						} else if (n === 3) {
+							allocate(HEADER_SIZE);
+							writeU8(NULL3_HEADER);
+						} else if (n < 260) {
+							allocate(HEADER_SIZE + I8_SIZE);
+							writeU8(NULLS8_HEADER);
+							writeU8(n - 4);
+						} else {
+							allocate(HEADER_SIZE + I32_SIZE);
+							writeU8(NULLS32_HEADER);
+							writeU32(n - 260);
+						}
+					} else if (Buffer.isBuffer(thing)) {
+						if (thing.length < 8192) {
+							allocate(HEADER_SIZE + I32_SIZE + thing.length);
+							writeU8(BUFFER_HEADER);
+							writeU32(thing.length);
+							thing.copy(currentBuffer, currentPosition);
+							currentPosition += thing.length;
+						} else {
+							allocate(HEADER_SIZE + I32_SIZE);
+							writeU8(BUFFER_HEADER);
+							writeU32(thing.length);
+							flush();
+							buffers.push(thing);
+						}
+					}
+					break;
+				}
+				case "symbol": {
+					if (thing === MEASURE_START_OPERATION) {
+						measureStart();
+					} else if (thing === MEASURE_END_OPERATION) {
+						const size = measureEnd();
+						allocate(HEADER_SIZE + I32_SIZE);
+						writeU8(I32_HEADER);
+						currentBuffer.writeInt32LE(size, currentPosition);
+						currentPosition += I32_SIZE;
 					}
+					break;
 				}
 			}
-		});
-	}
-};
-
-
-/***/ }),
-
-/***/ 95175:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+		}
+		flush();
 
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+		allocationScope.leftOverBuffer = leftOverBuffer;
 
-class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} childType TODO
-	 * @param {string} runtimeFunction TODO
-	 * @param {string} runtimeHandlers TODO
-	 */
-	constructor(childType, runtimeFunction, runtimeHandlers) {
-		super(`chunk ${childType} function`);
-		this.childType = childType;
-		this.runtimeFunction = runtimeFunction;
-		this.runtimeHandlers = runtimeHandlers;
+		// avoid leaking memory
+		currentBuffer = null;
+		leftOverBuffer = null;
+		allocationScope = undefined;
+		const _buffers = buffers;
+		buffers = undefined;
+		return _buffers;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	generate() {
-		const { runtimeFunction, runtimeHandlers } = this;
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${runtimeHandlers} = {};`,
-			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [
-				// map is shorter than forEach
-				`Object.keys(${runtimeHandlers}).map(${runtimeTemplate.basicFunction(
-					"key",
-					`${runtimeHandlers}[key](chunkId);`
-				)});`
-			])}`
-		]);
+	deserialize(data, context) {
+		return this._deserialize(data, context);
 	}
-}
-
-module.exports = ChunkPrefetchFunctionRuntimeModule;
-
-
-/***/ }),
-
-/***/ 33895:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
 
+	_createLazyDeserialized(content, context) {
+		return SerializerMiddleware.createLazy(
+			memoize(() => this._deserialize(content, context)),
+			this,
+			undefined,
+			content
+		);
+	}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const ChunkPrefetchFunctionRuntimeModule = __webpack_require__(95175);
-const ChunkPrefetchStartupRuntimeModule = __webpack_require__(15294);
-const ChunkPrefetchTriggerRuntimeModule = __webpack_require__(98441);
-const ChunkPreloadTriggerRuntimeModule = __webpack_require__(56236);
-
-/** @typedef {import("../Compiler")} Compiler */
+	_deserializeLazy(fn, context) {
+		return SerializerMiddleware.deserializeLazy(fn, data =>
+			this._deserialize(data, context)
+		);
+	}
 
-class ChunkPrefetchPreloadPlugin {
 	/**
-	 * @param {Compiler} compiler the compiler
-	 * @returns {void}
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType} deserialized data
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ChunkPrefetchPreloadPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
-						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
-							chunkGraph,
-							"prefetchOrder"
-						);
-						if (startupChildChunks) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							set.add(RuntimeGlobals.onChunksLoaded);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
-							);
-						}
-					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph, false);
+	_deserialize(data, context) {
+		let currentDataItem = 0;
+		let currentBuffer = data[0];
+		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
+		let currentPosition = 0;
 
-						if (chunkMap.prefetch) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
+		const retainedBuffer = context.retainedBuffer || (x => x);
+
+		const checkOverflow = () => {
+			if (currentPosition >= currentBuffer.length) {
+				currentPosition = 0;
+				currentDataItem++;
+				currentBuffer =
+					currentDataItem < data.length ? data[currentDataItem] : null;
+				currentIsBuffer = Buffer.isBuffer(currentBuffer);
+			}
+		};
+		const isInCurrentBuffer = n => {
+			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
+		};
+		const ensureBuffer = () => {
+			if (!currentIsBuffer) {
+				throw new Error(
+					currentBuffer === null
+						? "Unexpected end of stream"
+						: "Unexpected lazy element in stream"
+				);
+			}
+		};
+		/**
+		 * Reads n bytes
+		 * @param {number} n amount of bytes to read
+		 * @returns {Buffer} buffer with bytes
+		 */
+		const read = n => {
+			ensureBuffer();
+			const rem = currentBuffer.length - currentPosition;
+			if (rem < n) {
+				const buffers = [read(rem)];
+				n -= rem;
+				ensureBuffer();
+				while (currentBuffer.length < n) {
+					const b = /** @type {Buffer} */ (currentBuffer);
+					buffers.push(b);
+					n -= b.length;
+					currentDataItem++;
+					currentBuffer =
+						currentDataItem < data.length ? data[currentDataItem] : null;
+					currentIsBuffer = Buffer.isBuffer(currentBuffer);
+					ensureBuffer();
+				}
+				buffers.push(read(n));
+				return Buffer.concat(buffers);
+			}
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
+			currentPosition += n;
+			checkOverflow();
+			return res;
+		};
+		/**
+		 * Reads up to n bytes
+		 * @param {number} n amount of bytes to read
+		 * @returns {Buffer} buffer with bytes
+		 */
+		const readUpTo = n => {
+			ensureBuffer();
+			const rem = currentBuffer.length - currentPosition;
+			if (rem < n) {
+				n = rem;
+			}
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
+			currentPosition += n;
+			checkOverflow();
+			return res;
+		};
+		const readU8 = () => {
+			ensureBuffer();
+			/**
+			 * There is no need to check remaining buffer size here
+			 * since {@link checkOverflow} guarantees at least one byte remaining
+			 */
+			const byte = /** @type {Buffer} */ (currentBuffer).readUInt8(
+				currentPosition
+			);
+			currentPosition += I8_SIZE;
+			checkOverflow();
+			return byte;
+		};
+		const readU32 = () => {
+			return read(I32_SIZE).readUInt32LE(0);
+		};
+		const readBits = (data, n) => {
+			let mask = 1;
+			while (n !== 0) {
+				result.push((data & mask) !== 0);
+				mask = mask << 1;
+				n--;
+			}
+		};
+		const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
+			switch (header) {
+				case LAZY_HEADER:
+					return () => {
+						const count = readU32();
+						const lengths = Array.from({ length: count }).map(() => readU32());
+						const content = [];
+						for (let l of lengths) {
+							if (l === 0) {
+								if (typeof currentBuffer !== "function") {
+									throw new Error("Unexpected non-lazy element in stream");
+								}
+								content.push(currentBuffer);
+								currentDataItem++;
+								currentBuffer =
+									currentDataItem < data.length ? data[currentDataItem] : null;
+								currentIsBuffer = Buffer.isBuffer(currentBuffer);
+							} else {
+								do {
+									const buf = readUpTo(l);
+									l -= buf.length;
+									content.push(retainedBuffer(buf));
+								} while (l > 0);
+							}
+						}
+						result.push(this._createLazyDeserialized(content, context));
+					};
+				case BUFFER_HEADER:
+					return () => {
+						const len = readU32();
+						result.push(retainedBuffer(read(len)));
+					};
+				case TRUE_HEADER:
+					return () => result.push(true);
+				case FALSE_HEADER:
+					return () => result.push(false);
+				case NULL3_HEADER:
+					return () => result.push(null, null, null);
+				case NULL2_HEADER:
+					return () => result.push(null, null);
+				case NULL_HEADER:
+					return () => result.push(null);
+				case NULL_AND_TRUE_HEADER:
+					return () => result.push(null, true);
+				case NULL_AND_FALSE_HEADER:
+					return () => result.push(null, false);
+				case NULL_AND_I8_HEADER:
+					return () => {
+						if (currentIsBuffer) {
+							result.push(
+								null,
+								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
 							);
+							currentPosition += I8_SIZE;
+							checkOverflow();
+						} else {
+							result.push(null, read(I8_SIZE).readInt8(0));
 						}
-						if (chunkMap.preload) {
-							set.add(RuntimeGlobals.preloadChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
+					};
+				case NULL_AND_I32_HEADER:
+					return () => {
+						result.push(null);
+						if (isInCurrentBuffer(I32_SIZE)) {
+							result.push(
+								/** @type {Buffer} */ (currentBuffer).readInt32LE(
+									currentPosition
+								)
+							);
+							currentPosition += I32_SIZE;
+							checkOverflow();
+						} else {
+							result.push(read(I32_SIZE).readInt32LE(0));
+						}
+					};
+				case NULLS8_HEADER:
+					return () => {
+						const len = readU8() + 4;
+						for (let i = 0; i < len; i++) {
+							result.push(null);
+						}
+					};
+				case NULLS32_HEADER:
+					return () => {
+						const len = readU32() + 260;
+						for (let i = 0; i < len; i++) {
+							result.push(null);
+						}
+					};
+				case BOOLEANS_HEADER:
+					return () => {
+						const innerHeader = readU8();
+						if ((innerHeader & 0xf0) === 0) {
+							readBits(innerHeader, 3);
+						} else if ((innerHeader & 0xe0) === 0) {
+							readBits(innerHeader, 4);
+						} else if ((innerHeader & 0xc0) === 0) {
+							readBits(innerHeader, 5);
+						} else if ((innerHeader & 0x80) === 0) {
+							readBits(innerHeader, 6);
+						} else if (innerHeader !== 0xff) {
+							let count = (innerHeader & 0x7f) + 7;
+							while (count > 8) {
+								readBits(readU8(), 8);
+								count -= 8;
+							}
+							readBits(readU8(), count);
+						} else {
+							let count = readU32();
+							while (count > 8) {
+								readBits(readU8(), 8);
+								count -= 8;
+							}
+							readBits(readU8(), count);
+						}
+					};
+				case STRING_HEADER:
+					return () => {
+						const len = readU32();
+						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
+							result.push(
+								currentBuffer.toString(
+									undefined,
+									currentPosition,
+									currentPosition + len
+								)
+							);
+							currentPosition += len;
+							checkOverflow();
+						} else {
+							result.push(read(len).toString());
+						}
+					};
+				case SHORT_STRING_HEADER:
+					return () => result.push("");
+				case SHORT_STRING_HEADER | 1:
+					return () => {
+						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
+							result.push(
+								currentBuffer.toString(
+									"latin1",
+									currentPosition,
+									currentPosition + 1
+								)
+							);
+							currentPosition++;
+							checkOverflow();
+						} else {
+							result.push(read(1).toString("latin1"));
+						}
+					};
+				case I8_HEADER:
+					return () => {
+						if (currentIsBuffer) {
+							result.push(
+								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
 							);
+							currentPosition++;
+							checkOverflow();
+						} else {
+							result.push(read(1).readInt8(0));
 						}
+					};
+				default:
+					if (header <= 10) {
+						return () => result.push(header);
+					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
+						const len = header & SHORT_STRING_LENGTH_MASK;
+						return () => {
+							if (
+								isInCurrentBuffer(len) &&
+								currentPosition + len < 0x7fffffff
+							) {
+								result.push(
+									currentBuffer.toString(
+										"latin1",
+										currentPosition,
+										currentPosition + len
+									)
+								);
+								currentPosition += len;
+								checkOverflow();
+							} else {
+								result.push(read(len).toString("latin1"));
+							}
+						};
+					} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
+						const len = (header & NUMBERS_COUNT_MASK) + 1;
+						return () => {
+							const need = F64_SIZE * len;
+							if (isInCurrentBuffer(need)) {
+								for (let i = 0; i < len; i++) {
+									result.push(
+										/** @type {Buffer} */ (currentBuffer).readDoubleLE(
+											currentPosition
+										)
+									);
+									currentPosition += F64_SIZE;
+								}
+								checkOverflow();
+							} else {
+								const buf = read(need);
+								for (let i = 0; i < len; i++) {
+									result.push(buf.readDoubleLE(i * F64_SIZE));
+								}
+							}
+						};
+					} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
+						const len = (header & NUMBERS_COUNT_MASK) + 1;
+						return () => {
+							const need = I32_SIZE * len;
+							if (isInCurrentBuffer(need)) {
+								for (let i = 0; i < len; i++) {
+									result.push(
+										/** @type {Buffer} */ (currentBuffer).readInt32LE(
+											currentPosition
+										)
+									);
+									currentPosition += I32_SIZE;
+								}
+								checkOverflow();
+							} else {
+								const buf = read(need);
+								for (let i = 0; i < len; i++) {
+									result.push(buf.readInt32LE(i * I32_SIZE));
+								}
+							}
+						};
+					} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
+						const len = (header & NUMBERS_COUNT_MASK) + 1;
+						return () => {
+							const need = I8_SIZE * len;
+							if (isInCurrentBuffer(need)) {
+								for (let i = 0; i < len; i++) {
+									result.push(
+										/** @type {Buffer} */ (currentBuffer).readInt8(
+											currentPosition
+										)
+									);
+									currentPosition += I8_SIZE;
+								}
+								checkOverflow();
+							} else {
+								const buf = read(need);
+								for (let i = 0; i < len; i++) {
+									result.push(buf.readInt8(i * I8_SIZE));
+								}
+							}
+						};
+					} else {
+						return () => {
+							throw new Error(
+								`Unexpected header byte 0x${header.toString(16)}`
+							);
+						};
 					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.prefetchChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"prefetch",
-								RuntimeGlobals.prefetchChunk,
-								RuntimeGlobals.prefetchChunkHandlers
-							)
-						);
-						set.add(RuntimeGlobals.prefetchChunkHandlers);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.preloadChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
-						compilation.addRuntimeModule(
-							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"preload",
-								RuntimeGlobals.preloadChunk,
-								RuntimeGlobals.preloadChunkHandlers
-							)
-						);
-						set.add(RuntimeGlobals.preloadChunkHandlers);
-					});
 			}
-		);
+		});
+
+		/** @type {DeserializedType} */
+		let result = [];
+		while (currentBuffer !== null) {
+			if (typeof currentBuffer === "function") {
+				result.push(this._deserializeLazy(currentBuffer, context));
+				currentDataItem++;
+				currentBuffer =
+					currentDataItem < data.length ? data[currentDataItem] : null;
+				currentIsBuffer = Buffer.isBuffer(currentBuffer);
+			} else {
+				const header = readU8();
+				dispatchTable[header]();
+			}
+		}
+
+		// avoid leaking memory in context
+		let _result = result;
+		result = undefined;
+		return _result;
 	}
 }
 
-module.exports = ChunkPrefetchPreloadPlugin;
+module.exports = BinaryMiddleware;
+
+module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
+module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
 
 
 /***/ }),
 
-/***/ 15294:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 93475:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -114682,58 +112503,22 @@ module.exports = ChunkPrefetchPreloadPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {{ onChunks: Chunk[], chunks: Set<Chunk> }[]} startupChunks chunk ids to trigger when chunks are loaded
-	 */
-	constructor(startupChunks) {
-		super("startup prefetch", RuntimeModule.STAGE_TRIGGER);
-		this.startupChunks = startupChunks;
+class DateObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.getTime());
 	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { startupChunks, chunk } = this;
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString(
-			startupChunks.map(
-				({ onChunks, chunks }) =>
-					`${RuntimeGlobals.onChunksLoaded}(0, ${JSON.stringify(
-						// This need to include itself to delay execution after this chunk has been fully loaded
-						onChunks.filter(c => c === chunk).map(c => c.id)
-					)}, ${runtimeTemplate.basicFunction(
-						"",
-						chunks.size < 3
-							? Array.from(
-									chunks,
-									c =>
-										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
-							  )
-							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
-									RuntimeGlobals.prefetchChunk
-							  });`
-					)}, 5);`
-			)
-		);
+	deserialize({ read }) {
+		return new Date(read());
 	}
 }
 
-module.exports = ChunkPrefetchStartupRuntimeModule;
+module.exports = DateObjectSerializer;
 
 
 /***/ }),
 
-/***/ 98441:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 79479:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -114742,54 +112527,32 @@ module.exports = ChunkPrefetchStartupRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+class ErrorObjectSerializer {
+	constructor(Type) {
+		this.Type = Type;
+	}
 
-class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to
-	 */
-	constructor(chunkMap) {
-		super(`chunk prefetch trigger`, RuntimeModule.STAGE_TRIGGER);
-		this.chunkMap = chunkMap;
+	serialize(obj, { write }) {
+		write(obj.message);
+		write(obj.stack);
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
-		const body = [
-			"var chunks = chunkToChildrenMap[chunkId];",
-			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.prefetchChunk});`
-		];
-		return Template.asString([
-			Template.asString([
-				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
-				`${
-					RuntimeGlobals.ensureChunkHandlers
-				}.prefetch = ${runtimeTemplate.expressionFunction(
-					`Promise.all(promises).then(${runtimeTemplate.basicFunction(
-						"",
-						body
-					)})`,
-					"chunkId, promises"
-				)};`
-			])
-		]);
+	deserialize({ read }) {
+		const err = new this.Type();
+
+		err.message = read();
+		err.stack = read();
+
+		return err;
 	}
 }
 
-module.exports = ChunkPrefetchTriggerRuntimeModule;
+module.exports = ErrorObjectSerializer;
 
 
 /***/ }),
 
-/***/ 56236:
+/***/ 65321:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -114799,795 +112562,636 @@ module.exports = ChunkPrefetchTriggerRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Record<string|number, (string|number)[]>} chunkMap map from chunk to chunks
-	 */
-	constructor(chunkMap) {
-		super(`chunk preload trigger`, RuntimeModule.STAGE_TRIGGER);
-		this.chunkMap = chunkMap;
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkMap } = this;
-		const { runtimeTemplate } = this.compilation;
-		const body = [
-			"var chunks = chunkToChildrenMap[chunkId];",
-			`Array.isArray(chunks) && chunks.map(${RuntimeGlobals.preloadChunk});`
-		];
-		return Template.asString([
-			Template.asString([
-				`var chunkToChildrenMap = ${JSON.stringify(chunkMap, null, "\t")};`,
-				`${
-					RuntimeGlobals.ensureChunkHandlers
-				}.preload = ${runtimeTemplate.basicFunction("chunkId", body)};`
-			])
-		]);
-	}
-}
-
-module.exports = ChunkPreloadTriggerRuntimeModule;
-
-
-/***/ }),
-
-/***/ 30318:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-
-class BasicEffectRulePlugin {
-	constructor(ruleProperty, effectType) {
-		this.ruleProperty = ruleProperty;
-		this.effectType = effectType || ruleProperty;
-	}
-
-	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
-	 * @returns {void}
-	 */
-	apply(ruleSetCompiler) {
-		ruleSetCompiler.hooks.rule.tap(
-			"BasicEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
-				if (unhandledProperties.has(this.ruleProperty)) {
-					unhandledProperties.delete(this.ruleProperty);
-
-					const value = rule[this.ruleProperty];
-
-					result.effects.push({
-						type: this.effectType,
-						value
-					});
-				}
-			}
-		);
-	}
-}
-
-module.exports = BasicEffectRulePlugin;
-
-
-/***/ }),
-
-/***/ 94215:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
-
-class BasicMatcherRulePlugin {
-	constructor(ruleProperty, dataProperty, invert) {
-		this.ruleProperty = ruleProperty;
-		this.dataProperty = dataProperty || ruleProperty;
-		this.invert = invert || false;
-	}
-
-	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
-	 * @returns {void}
-	 */
-	apply(ruleSetCompiler) {
-		ruleSetCompiler.hooks.rule.tap(
-			"BasicMatcherRulePlugin",
-			(path, rule, unhandledProperties, result) => {
-				if (unhandledProperties.has(this.ruleProperty)) {
-					unhandledProperties.delete(this.ruleProperty);
-					const value = rule[this.ruleProperty];
-					const condition = ruleSetCompiler.compileCondition(
-						`${path}.${this.ruleProperty}`,
-						value
-					);
-					const fn = condition.fn;
-					result.conditions.push({
-						property: this.dataProperty,
-						matchWhenEmpty: this.invert
-							? !condition.matchWhenEmpty
-							: condition.matchWhenEmpty,
-						fn: this.invert ? v => !fn(v) : fn
-					});
-				}
-			}
-		);
-	}
-}
-
-module.exports = BasicMatcherRulePlugin;
-
-
-/***/ }),
+const { constants } = __webpack_require__(14300);
+const { pipeline } = __webpack_require__(12781);
+const {
+	createBrotliCompress,
+	createBrotliDecompress,
+	createGzip,
+	createGunzip,
+	constants: zConstants
+} = __webpack_require__(59796);
+const createHash = __webpack_require__(49835);
+const { dirname, join, mkdirp } = __webpack_require__(17139);
+const memoize = __webpack_require__(78676);
+const SerializerMiddleware = __webpack_require__(83137);
 
-/***/ 72021:
-/***/ (function(module) {
+/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 
-"use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
-
-class ObjectMatcherRulePlugin {
-	constructor(ruleProperty, dataProperty) {
-		this.ruleProperty = ruleProperty;
-		this.dataProperty = dataProperty || ruleProperty;
-	}
-
-	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
-	 * @returns {void}
-	 */
-	apply(ruleSetCompiler) {
-		const { ruleProperty, dataProperty } = this;
-		ruleSetCompiler.hooks.rule.tap(
-			"ObjectMatcherRulePlugin",
-			(path, rule, unhandledProperties, result) => {
-				if (unhandledProperties.has(ruleProperty)) {
-					unhandledProperties.delete(ruleProperty);
-					const value = rule[ruleProperty];
-					for (const property of Object.keys(value)) {
-						const nestedDataProperties = property.split(".");
-						const condition = ruleSetCompiler.compileCondition(
-							`${path}.${ruleProperty}.${property}`,
-							value[property]
-						);
-						result.conditions.push({
-							property: [dataProperty, ...nestedDataProperties],
-							matchWhenEmpty: condition.matchWhenEmpty,
-							fn: condition.fn
-						});
-					}
-				}
-			}
-		);
-	}
-}
+Format:
 
-module.exports = ObjectMatcherRulePlugin;
+File -> Header Section*
 
+Version -> u32
+AmountOfSections -> u32
+SectionSize -> i32 (if less than zero represents lazy value)
 
-/***/ }),
+Header -> Version AmountOfSections SectionSize*
 
-/***/ 83349:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+Buffer -> n bytes
+Section -> Buffer
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
-
-
-const { SyncHook } = __webpack_require__(41242);
+// "wpc" + 1 in little-endian
+const VERSION = 0x01637077;
 
 /**
- * @typedef {Object} RuleCondition
- * @property {string | string[]} property
- * @property {boolean} matchWhenEmpty
- * @property {function(string): boolean} fn
+ * @param {Buffer[]} buffers buffers
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
  */
+const hashForName = (buffers, hashFunction) => {
+	const hash = createHash(hashFunction);
+	for (const buf of buffers) hash.update(buf);
+	return /** @type {string} */ (hash.digest("hex"));
+};
 
-/**
- * @typedef {Object} Condition
- * @property {boolean} matchWhenEmpty
- * @property {function(string): boolean} fn
- */
+const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
+const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 
-/**
- * @typedef {Object} CompiledRule
- * @property {RuleCondition[]} conditions
- * @property {(Effect|function(object): Effect[])[]} effects
- * @property {CompiledRule[]=} rules
- * @property {CompiledRule[]=} oneOf
- */
+const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
+	? (buf, value, offset) => {
+			buf.writeBigUInt64LE(BigInt(value), offset);
+	  }
+	: (buf, value, offset) => {
+			const low = value % 0x100000000;
+			const high = (value - low) / 0x100000000;
+			buf.writeUInt32LE(low, offset);
+			buf.writeUInt32LE(high, offset + 4);
+	  };
+
+const readUInt64LE = Buffer.prototype.readBigUInt64LE
+	? (buf, offset) => {
+			return Number(buf.readBigUInt64LE(offset));
+	  }
+	: (buf, offset) => {
+			const low = buf.readUInt32LE(offset);
+			const high = buf.readUInt32LE(offset + 4);
+			return high * 0x100000000 + low;
+	  };
 
 /**
- * @typedef {Object} Effect
- * @property {string} type
- * @property {any} value
+ * @typedef {Object} SerializeResult
+ * @property {string | false} name
+ * @property {number} size
+ * @property {Promise=} backgroundJob
  */
 
 /**
- * @typedef {Object} RuleSet
- * @property {Map<string, any>} references map of references in the rule set (may grow over time)
- * @property {function(object): Effect[]} exec execute the rule set
+ * @param {FileMiddleware} middleware this
+ * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
+ * @param {string | boolean} name file base name
+ * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
-
-class RuleSetCompiler {
-	constructor(plugins) {
-		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, object, Set<string>, CompiledRule, Map<string, any>]>} */
-			rule: new SyncHook([
-				"path",
-				"rule",
-				"unhandledProperties",
-				"compiledRule",
-				"references"
-			])
-		});
-		if (plugins) {
-			for (const plugin of plugins) {
-				plugin.apply(this);
-			}
-		}
-	}
-
-	/**
-	 * @param {object[]} ruleSet raw user provided rules
-	 * @returns {RuleSet} compiled RuleSet
-	 */
-	compile(ruleSet) {
-		const refs = new Map();
-		const rules = this.compileRules("ruleSet", ruleSet, refs);
-
-		/**
-		 * @param {object} data data passed in
-		 * @param {CompiledRule} rule the compiled rule
-		 * @param {Effect[]} effects an array where effects are pushed to
-		 * @returns {boolean} true, if the rule has matched
-		 */
-		const execRule = (data, rule, effects) => {
-			for (const condition of rule.conditions) {
-				const p = condition.property;
-				if (Array.isArray(p)) {
-					let current = data;
-					for (const subProperty of p) {
-						if (
-							current &&
-							typeof current === "object" &&
-							Object.prototype.hasOwnProperty.call(current, subProperty)
-						) {
-							current = current[subProperty];
-						} else {
-							current = undefined;
-							break;
-						}
-					}
-					if (current !== undefined) {
-						if (!condition.fn(current)) return false;
-						continue;
-					}
-				} else if (p in data) {
-					const value = data[p];
-					if (value !== undefined) {
-						if (!condition.fn(value)) return false;
-						continue;
-					}
-				}
-				if (!condition.matchWhenEmpty) {
-					return false;
-				}
+const serialize = async (
+	middleware,
+	data,
+	name,
+	writeFile,
+	hashFunction = "md4"
+) => {
+	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
+	const processedData = [];
+	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
+	const resultToLazy = new WeakMap();
+	/** @type {Buffer[]} */
+	let lastBuffers = undefined;
+	for (const item of await data) {
+		if (typeof item === "function") {
+			if (!SerializerMiddleware.isLazy(item))
+				throw new Error("Unexpected function");
+			if (!SerializerMiddleware.isLazy(item, middleware)) {
+				throw new Error(
+					"Unexpected lazy value with non-this target (can't pass through lazy values)"
+				);
 			}
-			for (const effect of rule.effects) {
-				if (typeof effect === "function") {
-					const returnedEffects = effect(data);
-					for (const effect of returnedEffects) {
-						effects.push(effect);
-					}
+			lastBuffers = undefined;
+			const serializedInfo = SerializerMiddleware.getLazySerializedValue(item);
+			if (serializedInfo) {
+				if (typeof serializedInfo === "function") {
+					throw new Error(
+						"Unexpected lazy value with non-this target (can't pass through lazy values)"
+					);
 				} else {
-					effects.push(effect);
+					processedData.push(serializedInfo);
 				}
-			}
-			if (rule.rules) {
-				for (const childRule of rule.rules) {
-					execRule(data, childRule, effects);
+			} else {
+				const content = item();
+				if (content) {
+					const options = SerializerMiddleware.getLazyOptions(item);
+					processedData.push(
+						serialize(
+							middleware,
+							content,
+							(options && options.name) || true,
+							writeFile,
+							hashFunction
+						).then(result => {
+							/** @type {any} */ (item).options.size = result.size;
+							resultToLazy.set(result, item);
+							return result;
+						})
+					);
+				} else {
+					throw new Error(
+						"Unexpected falsy value returned by lazy value function"
+					);
 				}
 			}
-			if (rule.oneOf) {
-				for (const childRule of rule.oneOf) {
-					if (execRule(data, childRule, effects)) {
-						break;
-					}
-				}
+		} else if (item) {
+			if (lastBuffers) {
+				lastBuffers.push(item);
+			} else {
+				lastBuffers = [item];
+				processedData.push(lastBuffers);
 			}
-			return true;
-		};
+		} else {
+			throw new Error("Unexpected falsy value in items array");
+		}
+	}
+	/** @type {Promise<any>[]} */
+	const backgroundJobs = [];
+	const resolvedData = (
+		await Promise.all(
+			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (
+				processedData
+			)
+		)
+	).map(item => {
+		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
 
-		return {
-			references: refs,
-			exec: data => {
-				/** @type {Effect[]} */
-				const effects = [];
-				for (const rule of rules) {
-					execRule(data, rule, effects);
-				}
-				return effects;
+		backgroundJobs.push(item.backgroundJob);
+		// create pointer buffer from size and name
+		const name = /** @type {string} */ (item.name);
+		const nameBuffer = Buffer.from(name);
+		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
+		writeUInt64LE(buf, item.size, 0);
+		nameBuffer.copy(buf, 8, 0);
+		const lazy = resultToLazy.get(item);
+		SerializerMiddleware.setLazySerializedValue(lazy, buf);
+		return buf;
+	});
+	const lengths = [];
+	for (const item of resolvedData) {
+		if (Array.isArray(item)) {
+			let l = 0;
+			for (const b of item) l += b.length;
+			while (l > 0x7fffffff) {
+				lengths.push(0x7fffffff);
+				l -= 0x7fffffff;
 			}
-		};
+			lengths.push(l);
+		} else if (item) {
+			lengths.push(-item.length);
+		} else {
+			throw new Error("Unexpected falsy value in resolved data " + item);
+		}
 	}
-
-	/**
-	 * @param {string} path current path
-	 * @param {object[]} rules the raw rules provided by user
-	 * @param {Map<string, any>} refs references
-	 * @returns {CompiledRule[]} rules
-	 */
-	compileRules(path, rules, refs) {
-		return rules.map((rule, i) =>
-			this.compileRule(`${path}[${i}]`, rule, refs)
-		);
+	const header = Buffer.allocUnsafe(8 + lengths.length * 4);
+	header.writeUInt32LE(VERSION, 0);
+	header.writeUInt32LE(lengths.length, 4);
+	for (let i = 0; i < lengths.length; i++) {
+		header.writeInt32LE(lengths[i], 8 + i * 4);
 	}
-
-	/**
-	 * @param {string} path current path
-	 * @param {object} rule the raw rule provided by user
-	 * @param {Map<string, any>} refs references
-	 * @returns {CompiledRule} normalized and compiled rule for processing
-	 */
-	compileRule(path, rule, refs) {
-		const unhandledProperties = new Set(
-			Object.keys(rule).filter(key => rule[key] !== undefined)
-		);
-
-		/** @type {CompiledRule} */
-		const compiledRule = {
-			conditions: [],
-			effects: [],
-			rules: undefined,
-			oneOf: undefined
-		};
-
-		this.hooks.rule.call(path, rule, unhandledProperties, compiledRule, refs);
-
-		if (unhandledProperties.has("rules")) {
-			unhandledProperties.delete("rules");
-			const rules = rule.rules;
-			if (!Array.isArray(rules))
-				throw this.error(path, rules, "Rule.rules must be an array of rules");
-			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
-		}
-
-		if (unhandledProperties.has("oneOf")) {
-			unhandledProperties.delete("oneOf");
-			const oneOf = rule.oneOf;
-			if (!Array.isArray(oneOf))
-				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
-			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
-		}
-
-		if (unhandledProperties.size > 0) {
-			throw this.error(
-				path,
-				rule,
-				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
-			);
+	const buf = [header];
+	for (const item of resolvedData) {
+		if (Array.isArray(item)) {
+			for (const b of item) buf.push(b);
+		} else if (item) {
+			buf.push(item);
 		}
-
-		return compiledRule;
 	}
+	if (name === true) {
+		name = hashForName(buf, hashFunction);
+	}
+	backgroundJobs.push(writeFile(name, buf));
+	let size = 0;
+	for (const b of buf) size += b.length;
+	return {
+		size,
+		name,
+		backgroundJob:
+			backgroundJobs.length === 1
+				? backgroundJobs[0]
+				: Promise.all(backgroundJobs)
+	};
+};
 
-	/**
-	 * @param {string} path current path
-	 * @param {any} condition user provided condition value
-	 * @returns {Condition} compiled condition
-	 */
-	compileCondition(path, condition) {
-		if (condition === "") {
-			return {
-				matchWhenEmpty: true,
-				fn: str => str === ""
-			};
-		}
-		if (!condition) {
-			throw this.error(
-				path,
-				condition,
-				"Expected condition but got falsy value"
-			);
-		}
-		if (typeof condition === "string") {
-			return {
-				matchWhenEmpty: condition.length === 0,
-				fn: str => typeof str === "string" && str.startsWith(condition)
-			};
-		}
-		if (typeof condition === "function") {
-			try {
-				return {
-					matchWhenEmpty: condition(""),
-					fn: condition
-				};
-			} catch (err) {
-				throw this.error(
-					path,
-					condition,
-					"Evaluation of condition function threw error"
-				);
-			}
-		}
-		if (condition instanceof RegExp) {
-			return {
-				matchWhenEmpty: condition.test(""),
-				fn: v => typeof v === "string" && condition.test(v)
-			};
-		}
-		if (Array.isArray(condition)) {
-			const items = condition.map((c, i) =>
-				this.compileCondition(`${path}[${i}]`, c)
-			);
-			return this.combineConditionsOr(items);
-		}
-
-		if (typeof condition !== "object") {
-			throw this.error(
-				path,
-				condition,
-				`Unexpected ${typeof condition} when condition was expected`
-			);
+/**
+ * @param {FileMiddleware} middleware this
+ * @param {string | false} name filename
+ * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
+ * @returns {Promise<BufferSerializableType[]>} deserialized data
+ */
+const deserialize = async (middleware, name, readFile) => {
+	const contents = await readFile(name);
+	if (contents.length === 0) throw new Error("Empty file " + name);
+	let contentsIndex = 0;
+	let contentItem = contents[0];
+	let contentItemLength = contentItem.length;
+	let contentPosition = 0;
+	if (contentItemLength === 0) throw new Error("Empty file " + name);
+	const nextContent = () => {
+		contentsIndex++;
+		contentItem = contents[contentsIndex];
+		contentItemLength = contentItem.length;
+		contentPosition = 0;
+	};
+	const ensureData = n => {
+		if (contentPosition === contentItemLength) {
+			nextContent();
 		}
-
-		const conditions = [];
-		for (const key of Object.keys(condition)) {
-			const value = condition[key];
-			switch (key) {
-				case "or":
-					if (value) {
-						if (!Array.isArray(value)) {
-							throw this.error(
-								`${path}.or`,
-								condition.and,
-								"Expected array of conditions"
-							);
-						}
-						conditions.push(this.compileCondition(`${path}.or`, value));
-					}
-					break;
-				case "and":
-					if (value) {
-						if (!Array.isArray(value)) {
-							throw this.error(
-								`${path}.and`,
-								condition.and,
-								"Expected array of conditions"
-							);
-						}
-						let i = 0;
-						for (const item of value) {
-							conditions.push(this.compileCondition(`${path}.and[${i}]`, item));
-							i++;
-						}
-					}
-					break;
-				case "not":
-					if (value) {
-						const matcher = this.compileCondition(`${path}.not`, value);
-						const fn = matcher.fn;
-						conditions.push({
-							matchWhenEmpty: !matcher.matchWhenEmpty,
-							fn: v => !fn(v)
-						});
-					}
+		while (contentItemLength - contentPosition < n) {
+			const remaining = contentItem.slice(contentPosition);
+			let lengthFromNext = n - remaining.length;
+			const buffers = [remaining];
+			for (let i = contentsIndex + 1; i < contents.length; i++) {
+				const l = contents[i].length;
+				if (l > lengthFromNext) {
+					buffers.push(contents[i].slice(0, lengthFromNext));
+					contents[i] = contents[i].slice(lengthFromNext);
+					lengthFromNext = 0;
 					break;
-				default:
-					throw this.error(
-						`${path}.${key}`,
-						condition[key],
-						`Unexpected property ${key} in condition`
-					);
+				} else {
+					buffers.push(contents[i]);
+					contentsIndex = i;
+					lengthFromNext -= l;
+				}
 			}
+			if (lengthFromNext > 0) throw new Error("Unexpected end of data");
+			contentItem = Buffer.concat(buffers, n);
+			contentItemLength = n;
+			contentPosition = 0;
 		}
-		if (conditions.length === 0) {
-			throw this.error(
-				path,
-				condition,
-				"Expected condition, but got empty thing"
-			);
+	};
+	const readUInt32LE = () => {
+		ensureData(4);
+		const value = contentItem.readUInt32LE(contentPosition);
+		contentPosition += 4;
+		return value;
+	};
+	const readInt32LE = () => {
+		ensureData(4);
+		const value = contentItem.readInt32LE(contentPosition);
+		contentPosition += 4;
+		return value;
+	};
+	const readSlice = l => {
+		ensureData(l);
+		if (contentPosition === 0 && contentItemLength === l) {
+			const result = contentItem;
+			if (contentsIndex + 1 < contents.length) {
+				nextContent();
+			} else {
+				contentPosition = l;
+			}
+			return result;
 		}
-		return this.combineConditionsAnd(conditions);
+		const result = contentItem.slice(contentPosition, contentPosition + l);
+		contentPosition += l;
+		// we clone the buffer here to allow the original content to be garbage collected
+		return l * 2 < contentItem.buffer.byteLength ? Buffer.from(result) : result;
+	};
+	const version = readUInt32LE();
+	if (version !== VERSION) {
+		throw new Error("Invalid file version");
 	}
-
-	/**
-	 * @param {Condition[]} conditions some conditions
-	 * @returns {Condition} merged condition
-	 */
-	combineConditionsOr(conditions) {
-		if (conditions.length === 0) {
-			return {
-				matchWhenEmpty: false,
-				fn: () => false
-			};
-		} else if (conditions.length === 1) {
-			return conditions[0];
+	const sectionCount = readUInt32LE();
+	const lengths = [];
+	let lastLengthPositive = false;
+	for (let i = 0; i < sectionCount; i++) {
+		const value = readInt32LE();
+		const valuePositive = value >= 0;
+		if (lastLengthPositive && valuePositive) {
+			lengths[lengths.length - 1] += value;
 		} else {
-			return {
-				matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
-				fn: v => conditions.some(c => c.fn(v))
-			};
+			lengths.push(value);
+			lastLengthPositive = valuePositive;
 		}
 	}
-
-	/**
-	 * @param {Condition[]} conditions some conditions
-	 * @returns {Condition} merged condition
-	 */
-	combineConditionsAnd(conditions) {
-		if (conditions.length === 0) {
-			return {
-				matchWhenEmpty: false,
-				fn: () => false
-			};
-		} else if (conditions.length === 1) {
-			return conditions[0];
+	const result = [];
+	for (let length of lengths) {
+		if (length < 0) {
+			const slice = readSlice(-length);
+			const size = Number(readUInt64LE(slice, 0));
+			const nameBuffer = slice.slice(8);
+			const name = nameBuffer.toString();
+			result.push(
+				SerializerMiddleware.createLazy(
+					memoize(() => deserialize(middleware, name, readFile)),
+					middleware,
+					{
+						name,
+						size
+					},
+					slice
+				)
+			);
 		} else {
-			return {
-				matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
-				fn: v => conditions.every(c => c.fn(v))
-			};
+			if (contentPosition === contentItemLength) {
+				nextContent();
+			} else if (contentPosition !== 0) {
+				if (length <= contentItemLength - contentPosition) {
+					result.push(
+						Buffer.from(
+							contentItem.buffer,
+							contentItem.byteOffset + contentPosition,
+							length
+						)
+					);
+					contentPosition += length;
+					length = 0;
+				} else {
+					const l = contentItemLength - contentPosition;
+					result.push(
+						Buffer.from(
+							contentItem.buffer,
+							contentItem.byteOffset + contentPosition,
+							l
+						)
+					);
+					length -= l;
+					contentPosition = contentItemLength;
+				}
+			} else {
+				if (length >= contentItemLength) {
+					result.push(contentItem);
+					length -= contentItemLength;
+					contentPosition = contentItemLength;
+				} else {
+					result.push(
+						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+					);
+					contentPosition += length;
+					length = 0;
+				}
+			}
+			while (length > 0) {
+				nextContent();
+				if (length >= contentItemLength) {
+					result.push(contentItem);
+					length -= contentItemLength;
+					contentPosition = contentItemLength;
+				} else {
+					result.push(
+						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
+					);
+					contentPosition += length;
+					length = 0;
+				}
+			}
 		}
 	}
+	return result;
+};
 
+/**
+ * @typedef {BufferSerializableType[]} DeserializedType
+ * @typedef {true} SerializedType
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ */
+class FileMiddleware extends SerializerMiddleware {
 	/**
-	 * @param {string} path current path
-	 * @param {any} value value at the error location
-	 * @param {string} message message explaining the problem
-	 * @returns {Error} an error object
+	 * @param {IntermediateFileSystem} fs filesystem
+	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	error(path, value, message) {
-		return new Error(
-			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
-		);
+	constructor(fs, hashFunction = "md4") {
+		super();
+		this.fs = fs;
+		this._hashFunction = hashFunction;
 	}
-}
-
-module.exports = RuleSetCompiler;
-
-
-/***/ }),
-
-/***/ 84977:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	/**
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 */
+	serialize(data, context) {
+		const { filename, extension = "" } = context;
+		return new Promise((resolve, reject) => {
+			mkdirp(this.fs, dirname(this.fs, filename), err => {
+				if (err) return reject(err);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+				// It's important that we don't touch existing files during serialization
+				// because serialize may read existing files (when deserializing)
+				const allWrittenFiles = new Set();
+				const writeFile = async (name, content) => {
+					const file = name
+						? join(this.fs, filename, `../${name}${extension}`)
+						: filename;
+					await new Promise((resolve, reject) => {
+						let stream = this.fs.createWriteStream(file + "_");
+						let compression;
+						if (file.endsWith(".gz")) {
+							compression = createGzip({
+								chunkSize: COMPRESSION_CHUNK_SIZE,
+								level: zConstants.Z_BEST_SPEED
+							});
+						} else if (file.endsWith(".br")) {
+							compression = createBrotliCompress({
+								chunkSize: COMPRESSION_CHUNK_SIZE,
+								params: {
+									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
+									[zConstants.BROTLI_PARAM_QUALITY]: 2,
+									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
+									[zConstants.BROTLI_PARAM_SIZE_HINT]: content.reduce(
+										(size, b) => size + b.length,
+										0
+									)
+								}
+							});
+						}
+						if (compression) {
+							pipeline(compression, stream, reject);
+							stream = compression;
+							stream.on("finish", () => resolve());
+						} else {
+							stream.on("error", err => reject(err));
+							stream.on("finish", () => resolve());
+						}
+						for (const b of content) stream.write(b);
+						stream.end();
+					});
+					if (name) allWrittenFiles.add(file);
+				};
 
+				resolve(
+					serialize(this, data, false, writeFile, this._hashFunction).then(
+						async ({ backgroundJob }) => {
+							await backgroundJob;
 
+							// Rename the index file to disallow access during inconsistent file state
+							await new Promise(resolve =>
+								this.fs.rename(filename, filename + ".old", err => {
+									resolve();
+								})
+							);
 
-const util = __webpack_require__(73837);
+							// update all written files
+							await Promise.all(
+								Array.from(
+									allWrittenFiles,
+									file =>
+										new Promise((resolve, reject) => {
+											this.fs.rename(file + "_", file, err => {
+												if (err) return reject(err);
+												resolve();
+											});
+										})
+								)
+							);
 
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").Effect} Effect */
+							// As final step automatically update the index file to have a consistent pack again
+							await new Promise(resolve => {
+								this.fs.rename(filename + "_", filename, err => {
+									if (err) return reject(err);
+									resolve();
+								});
+							});
+							return /** @type {true} */ (true);
+						}
+					)
+				);
+			});
+		});
+	}
 
-class UseEffectRulePlugin {
 	/**
-	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
-	 * @returns {void}
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	apply(ruleSetCompiler) {
-		ruleSetCompiler.hooks.rule.tap(
-			"UseEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
-				const conflictWith = (property, correctProperty) => {
-					if (unhandledProperties.has(property)) {
-						throw ruleSetCompiler.error(
-							`${path}.${property}`,
-							rule[property],
-							`A Rule must not have a '${property}' property when it has a '${correctProperty}' property`
-						);
+	deserialize(data, context) {
+		const { filename, extension = "" } = context;
+		const readFile = name =>
+			new Promise((resolve, reject) => {
+				const file = name
+					? join(this.fs, filename, `../${name}${extension}`)
+					: filename;
+				this.fs.stat(file, (err, stats) => {
+					if (err) {
+						reject(err);
+						return;
 					}
-				};
-
-				if (unhandledProperties.has("use")) {
-					unhandledProperties.delete("use");
-					unhandledProperties.delete("enforce");
-
-					conflictWith("loader", "use");
-					conflictWith("options", "use");
-
-					const use = rule.use;
-					const enforce = rule.enforce;
-
-					const type = enforce ? `use-${enforce}` : "use";
-
-					/**
-					 *
-					 * @param {string} path options path
-					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
-					 * @returns {Effect|function(any): Effect[]} effect
-					 */
-					const useToEffect = (path, defaultIdent, item) => {
-						if (typeof item === "function") {
-							return data => useToEffectsWithoutIdent(path, item(data));
-						} else {
-							return useToEffectRaw(path, defaultIdent, item);
+					let remaining = /** @type {number} */ (stats.size);
+					let currentBuffer;
+					let currentBufferUsed;
+					const buf = [];
+					let decompression;
+					if (file.endsWith(".gz")) {
+						decompression = createGunzip({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
+					} else if (file.endsWith(".br")) {
+						decompression = createBrotliDecompress({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
+					}
+					if (decompression) {
+						let newResolve, newReject;
+						resolve(
+							Promise.all([
+								new Promise((rs, rj) => {
+									newResolve = rs;
+									newReject = rj;
+								}),
+								new Promise((resolve, reject) => {
+									decompression.on("data", chunk => buf.push(chunk));
+									decompression.on("end", () => resolve());
+									decompression.on("error", err => reject(err));
+								})
+							]).then(() => buf)
+						);
+						resolve = newResolve;
+						reject = newReject;
+					}
+					this.fs.open(file, "r", (err, fd) => {
+						if (err) {
+							reject(err);
+							return;
 						}
-					};
-
-					/**
-					 *
-					 * @param {string} path options path
-					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
-					 * @returns {Effect} effect
-					 */
-					const useToEffectRaw = (path, defaultIdent, item) => {
-						if (typeof item === "string") {
-							return {
-								type,
-								value: {
-									loader: item,
-									options: undefined,
-									ident: undefined
-								}
-							};
-						} else {
-							const loader = item.loader;
-							const options = item.options;
-							let ident = item.ident;
-							if (options && typeof options === "object") {
-								if (!ident) ident = defaultIdent;
-								references.set(ident, options);
+						const read = () => {
+							if (currentBuffer === undefined) {
+								currentBuffer = Buffer.allocUnsafeSlow(
+									Math.min(
+										constants.MAX_LENGTH,
+										remaining,
+										decompression ? DECOMPRESSION_CHUNK_SIZE : Infinity
+									)
+								);
+								currentBufferUsed = 0;
 							}
-							if (typeof options === "string") {
-								util.deprecate(
-									() => {},
-									`Using a string as loader options is deprecated (${path}.options)`,
-									"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
-								)();
+							let readBuffer = currentBuffer;
+							let readOffset = currentBufferUsed;
+							let readLength = currentBuffer.length - currentBufferUsed;
+							// values passed to fs.read must be valid int32 values
+							if (readOffset > 0x7fffffff) {
+								readBuffer = currentBuffer.slice(readOffset);
+								readOffset = 0;
 							}
-							return {
-								type: enforce ? `use-${enforce}` : "use",
-								value: {
-									loader,
-									options,
-									ident
+							if (readLength > 0x7fffffff) {
+								readLength = 0x7fffffff;
+							}
+							this.fs.read(
+								fd,
+								readBuffer,
+								readOffset,
+								readLength,
+								null,
+								(err, bytesRead) => {
+									if (err) {
+										this.fs.close(fd, () => {
+											reject(err);
+										});
+										return;
+									}
+									currentBufferUsed += bytesRead;
+									remaining -= bytesRead;
+									if (currentBufferUsed === currentBuffer.length) {
+										if (decompression) {
+											decompression.write(currentBuffer);
+										} else {
+											buf.push(currentBuffer);
+										}
+										currentBuffer = undefined;
+										if (remaining === 0) {
+											if (decompression) {
+												decompression.end();
+											}
+											this.fs.close(fd, err => {
+												if (err) {
+													reject(err);
+													return;
+												}
+												resolve(buf);
+											});
+											return;
+										}
+									}
+									read();
 								}
-							};
-						}
-					};
-
-					/**
-					 * @param {string} path options path
-					 * @param {any} items user provided use value
-					 * @returns {Effect[]} effects
-					 */
-					const useToEffectsWithoutIdent = (path, items) => {
-						if (Array.isArray(items)) {
-							return items.map((item, idx) =>
-								useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
 							);
-						}
-						return [useToEffectRaw(path, "[[missing ident]]", items)];
-					};
-
-					/**
-					 * @param {string} path current path
-					 * @param {any} items user provided use value
-					 * @returns {(Effect|function(any): Effect[])[]} effects
-					 */
-					const useToEffects = (path, items) => {
-						if (Array.isArray(items)) {
-							return items.map((item, idx) => {
-								const subPath = `${path}[${idx}]`;
-								return useToEffect(subPath, subPath, item);
-							});
-						}
-						return [useToEffect(path, path, items)];
-					};
-
-					if (typeof use === "function") {
-						result.effects.push(data =>
-							useToEffectsWithoutIdent(`${path}.use`, use(data))
-						);
-					} else {
-						for (const effect of useToEffects(`${path}.use`, use)) {
-							result.effects.push(effect);
-						}
-					}
-				}
-
-				if (unhandledProperties.has("loader")) {
-					unhandledProperties.delete("loader");
-					unhandledProperties.delete("options");
-					unhandledProperties.delete("enforce");
-
-					const loader = rule.loader;
-					const options = rule.options;
-					const enforce = rule.enforce;
-
-					if (loader.includes("!")) {
-						throw ruleSetCompiler.error(
-							`${path}.loader`,
-							loader,
-							"Exclamation mark separated loader lists has been removed in favor of the 'use' property with arrays"
-						);
-					}
-
-					if (loader.includes("?")) {
-						throw ruleSetCompiler.error(
-							`${path}.loader`,
-							loader,
-							"Query arguments on 'loader' has been removed in favor of the 'options' property"
-						);
-					}
-
-					if (typeof options === "string") {
-						util.deprecate(
-							() => {},
-							`Using a string as loader options is deprecated (${path}.options)`,
-							"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
-						)();
-					}
-
-					const ident =
-						options && typeof options === "object" ? path : undefined;
-					references.set(ident, options);
-					result.effects.push({
-						type: enforce ? `use-${enforce}` : "use",
-						value: {
-							loader,
-							options,
-							ident
-						}
+						};
+						read();
 					});
-				}
-			}
-		);
+				});
+			});
+		return deserialize(this, false, readFile);
 	}
-
-	useItemToEffects(path, item) {}
 }
 
-module.exports = UseEffectRulePlugin;
+module.exports = FileMiddleware;
 
 
 /***/ }),
 
-/***/ 63672:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 86791:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -115596,162 +113200,37 @@ module.exports = UseEffectRulePlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-class AsyncModuleRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("async module");
+class MapObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.size);
+		for (const key of obj.keys()) {
+			write(key);
+		}
+		for (const value of obj.values()) {
+			write(value);
+		}
 	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.asyncModule;
-		return Template.asString([
-			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
-			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
-			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
-			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
-				"if(queue) {",
-				Template.indent([
-					`queue.forEach(${runtimeTemplate.expressionFunction(
-						"fn.r--",
-						"fn"
-					)});`,
-					`queue.forEach(${runtimeTemplate.expressionFunction(
-						"fn.r-- ? fn.r++ : fn()",
-						"fn"
-					)});`
-				]),
-				"}"
-			])}`,
-			`var completeFunction = ${runtimeTemplate.expressionFunction(
-				"!--fn.r && fn()",
-				"fn"
-			)};`,
-			`var queueFunction = ${runtimeTemplate.expressionFunction(
-				"queue ? queue.push(fn) : completeFunction(fn)",
-				"queue, fn"
-			)};`,
-			`var wrapDeps = ${runtimeTemplate.returningFunction(
-				`deps.map(${runtimeTemplate.basicFunction("dep", [
-					'if(dep !== null && typeof dep === "object") {',
-					Template.indent([
-						"if(dep[webpackThen]) return dep;",
-						"if(dep.then) {",
-						Template.indent([
-							"var queue = [];",
-							`dep.then(${runtimeTemplate.basicFunction("r", [
-								"obj[webpackExports] = r;",
-								"completeQueue(queue);",
-								"queue = 0;"
-							])}, ${runtimeTemplate.basicFunction("e", [
-								"obj[webpackError] = e;",
-								"completeQueue(queue);",
-								"queue = 0;"
-							])});`,
-							"var obj = {};",
-							`obj[webpackThen] = ${runtimeTemplate.expressionFunction(
-								"queueFunction(queue, fn), dep['catch'](reject)",
-								"fn, reject"
-							)};`,
-							"return obj;"
-						]),
-						"}"
-					]),
-					"}",
-					"var ret = {};",
-					`ret[webpackThen] = ${runtimeTemplate.expressionFunction(
-						"completeFunction(fn)",
-						"fn"
-					)};`,
-					"ret[webpackExports] = dep;",
-					"return ret;"
-				])})`,
-				"deps"
-			)};`,
-			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
-				"var queue = hasAwait && [];",
-				"var exports = module.exports;",
-				"var currentDeps;",
-				"var outerResolve;",
-				"var reject;",
-				"var isEvaluating = true;",
-				"var nested = false;",
-				`var whenAll = ${runtimeTemplate.basicFunction(
-					"deps, onResolve, onReject",
-					[
-						"if (nested) return;",
-						"nested = true;",
-						"onResolve.r += deps.length;",
-						`deps.map(${runtimeTemplate.expressionFunction(
-							"dep[webpackThen](onResolve, onReject)",
-							"dep, i"
-						)});`,
-						"nested = false;"
-					]
-				)};`,
-				`var promise = new Promise(${runtimeTemplate.basicFunction(
-					"resolve, rej",
-					[
-						"reject = rej;",
-						`outerResolve = ${runtimeTemplate.expressionFunction(
-							"resolve(exports), completeQueue(queue), queue = 0"
-						)};`
-					]
-				)});`,
-				"promise[webpackExports] = exports;",
-				`promise[webpackThen] = ${runtimeTemplate.basicFunction(
-					"fn, rejectFn",
-					[
-						"if (isEvaluating) { return completeFunction(fn); }",
-						"if (currentDeps) whenAll(currentDeps, fn, rejectFn);",
-						"queueFunction(queue, fn);",
-						"promise['catch'](rejectFn);"
-					]
-				)};`,
-				"module.exports = promise;",
-				`body(${runtimeTemplate.basicFunction("deps", [
-					"currentDeps = wrapDeps(deps);",
-					"var fn;",
-					`var getResult = ${runtimeTemplate.returningFunction(
-						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
-							"if(d[webpackError]) throw d[webpackError];",
-							"return d[webpackExports];"
-						])})`
-					)}`,
-					`var promise = new Promise(${runtimeTemplate.basicFunction(
-						"resolve, reject",
-						[
-							`fn = ${runtimeTemplate.expressionFunction(
-								"resolve(getResult)"
-							)};`,
-							"fn.r = 0;",
-							"whenAll(currentDeps, fn, reject);"
-						]
-					)});`,
-					"return fn.r ? promise : getResult();"
-				])}, ${runtimeTemplate.expressionFunction(
-					"err && reject(promise[webpackError] = err), outerResolve()",
-					"err"
-				)});`,
-				"isEvaluating = false;"
-			])};`
-		]);
+	deserialize({ read }) {
+		let size = read();
+		const map = new Map();
+		const keys = [];
+		for (let i = 0; i < size; i++) {
+			keys.push(read());
+		}
+		for (let i = 0; i < size; i++) {
+			map.set(keys[i], read());
+		}
+		return map;
 	}
 }
 
-module.exports = AsyncModuleRuntimeModule;
+module.exports = MapObjectSerializer;
 
 
 /***/ }),
 
-/***/ 66532:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 21048:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -115760,75 +113239,39 @@ module.exports = AsyncModuleRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const JavascriptModulesPlugin = __webpack_require__(89464);
-const { getUndoPath } = __webpack_require__(82186);
-
-class AutoPublicPathRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("publicPath", RuntimeModule.STAGE_BASIC);
+class NullPrototypeObjectSerializer {
+	serialize(obj, { write }) {
+		const keys = Object.keys(obj);
+		for (const key of keys) {
+			write(key);
+		}
+		write(null);
+		for (const key of keys) {
+			write(obj[key]);
+		}
 	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation } = this;
-		const { scriptType, importMetaName, path } = compilation.outputOptions;
-		const chunkName = compilation.getPath(
-			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				this.chunk,
-				compilation.outputOptions
-			),
-			{
-				chunk: this.chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const undoPath = getUndoPath(chunkName, path, false);
-
-		return Template.asString([
-			"var scriptUrl;",
-			scriptType === "module"
-				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
-				: Template.asString([
-						`if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
-						`var document = ${RuntimeGlobals.global}.document;`,
-						"if (!scriptUrl && document) {",
-						Template.indent([
-							`if (document.currentScript)`,
-							Template.indent(`scriptUrl = document.currentScript.src`),
-							"if (!scriptUrl) {",
-							Template.indent([
-								'var scripts = document.getElementsByTagName("script");',
-								"if(scripts.length) scriptUrl = scripts[scripts.length - 1].src"
-							]),
-							"}"
-						]),
-						"}"
-				  ]),
-			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
-			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
-			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
-			'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
-			!undoPath
-				? `${RuntimeGlobals.publicPath} = scriptUrl;`
-				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(
-						undoPath
-				  )};`
-		]);
+	deserialize({ read }) {
+		const obj = Object.create(null);
+		const keys = [];
+		let key = read();
+		while (key !== null) {
+			keys.push(key);
+			key = read();
+		}
+		for (const key of keys) {
+			obj[key] = read();
+		}
+		return obj;
 	}
 }
 
-module.exports = AutoPublicPathRuntimeModule;
+module.exports = NullPrototypeObjectSerializer;
 
 
 /***/ }),
 
-/***/ 84519:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 34795:
+/***/ (function(module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -115837,762 +113280,740 @@ module.exports = AutoPublicPathRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-class ChunkNameRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} chunkName the chunk's name
-	 */
-	constructor(chunkName) {
-		super("chunkName");
-		this.chunkName = chunkName;
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;
-	}
-}
-
-module.exports = ChunkNameRuntimeModule;
-
+const createHash = __webpack_require__(49835);
+const ArraySerializer = __webpack_require__(41721);
+const DateObjectSerializer = __webpack_require__(93475);
+const ErrorObjectSerializer = __webpack_require__(79479);
+const MapObjectSerializer = __webpack_require__(86791);
+const NullPrototypeObjectSerializer = __webpack_require__(21048);
+const PlainObjectSerializer = __webpack_require__(33040);
+const RegExpObjectSerializer = __webpack_require__(57328);
+const SerializerMiddleware = __webpack_require__(83137);
+const SetObjectSerializer = __webpack_require__(79240);
 
-/***/ }),
+/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/***/ 44793:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/** @typedef {new (...params: any[]) => any} Constructor */
 
-"use strict";
 /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("compat get default export");
-	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.compatGetDefaultExport;
-		return Template.asString([
-			"// getDefaultExport function for compatibility with non-harmony modules",
-			`${fn} = ${runtimeTemplate.basicFunction("module", [
-				"var getter = module && module.__esModule ?",
-				Template.indent([
-					`${runtimeTemplate.returningFunction("module['default']")} :`,
-					`${runtimeTemplate.returningFunction("module")};`
-				]),
-				`${RuntimeGlobals.definePropertyGetters}(getter, { a: getter });`,
-				"return getter;"
-			])};`
-		]);
-	}
-}
 
-module.exports = CompatGetDefaultExportRuntimeModule;
+Format:
 
+File -> Section*
+Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
 
-/***/ }),
+ObjectSection -> ESCAPE (
+	number:relativeOffset (number > 0) |
+	string:request (string|null):export
+) Section:value* ESCAPE ESCAPE_END_OBJECT
+ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
+EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
+EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
+OtherSection -> any (except ESCAPE)
 
-/***/ 88234:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+Why using null as escape value?
+Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
+Technically any value can be used.
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
+/**
+ * @typedef {Object} ObjectSerializerContext
+ * @property {function(any): void} write
+ */
 
+/**
+ * @typedef {Object} ObjectDeserializerContext
+ * @property {function(): any} read
+ */
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-/** @typedef {import("../MainTemplate")} MainTemplate */
-
-class CompatRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("compat", RuntimeModule.STAGE_ATTACH);
-		this.fullHash = true;
-	}
+/**
+ * @typedef {Object} ObjectSerializer
+ * @property {function(any, ObjectSerializerContext): void} serialize
+ * @property {function(ObjectDeserializerContext): any} deserialize
+ */
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, chunk, compilation } = this;
-		const {
-			runtimeTemplate,
-			mainTemplate,
-			moduleTemplates,
-			dependencyTemplates
-		} = compilation;
-		const bootstrap = mainTemplate.hooks.bootstrap.call(
-			"",
-			chunk,
-			compilation.hash || "XXXX",
-			moduleTemplates.javascript,
-			dependencyTemplates
-		);
-		const localVars = mainTemplate.hooks.localVars.call(
-			"",
-			chunk,
-			compilation.hash || "XXXX"
-		);
-		const requireExtensions = mainTemplate.hooks.requireExtensions.call(
-			"",
-			chunk,
-			compilation.hash || "XXXX"
-		);
-		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
-		let requireEnsure = "";
-		if (runtimeRequirements.has(RuntimeGlobals.ensureChunk)) {
-			const requireEnsureHandler = mainTemplate.hooks.requireEnsure.call(
-				"",
-				chunk,
-				compilation.hash || "XXXX",
-				"chunkId"
-			);
-			if (requireEnsureHandler) {
-				requireEnsure = `${
-					RuntimeGlobals.ensureChunkHandlers
-				}.compat = ${runtimeTemplate.basicFunction(
-					"chunkId, promises",
-					requireEnsureHandler
-				)};`;
-			}
+const setSetSize = (set, size) => {
+	let i = 0;
+	for (const item of set) {
+		if (i++ >= size) {
+			set.delete(item);
 		}
-		return [bootstrap, localVars, requireEnsure, requireExtensions]
-			.filter(Boolean)
-			.join("\n");
 	}
+};
 
-	/**
-	 * @returns {boolean} true, if the runtime module should get it's own scope
-	 */
-	shouldIsolate() {
-		// We avoid isolating this to have better backward-compat
-		return false;
+const setMapSize = (map, size) => {
+	let i = 0;
+	for (const item of map.keys()) {
+		if (i++ >= size) {
+			map.delete(item);
+		}
 	}
-}
-
-module.exports = CompatRuntimeModule;
+};
 
+/**
+ * @param {Buffer} buffer buffer
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const toHash = (buffer, hashFunction) => {
+	const hash = createHash(hashFunction);
+	hash.update(buffer);
+	return /** @type {string} */ (hash.digest("latin1"));
+};
 
-/***/ }),
+const ESCAPE = null;
+const ESCAPE_ESCAPE_VALUE = null;
+const ESCAPE_END_OBJECT = true;
+const ESCAPE_UNDEFINED = false;
 
-/***/ 94669:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+const CURRENT_VERSION = 2;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+const serializers = new Map();
+const serializerInversed = new Map();
 
+const loadedRequests = new Set();
 
+const NOT_SERIALIZABLE = {};
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
+const jsTypes = new Map();
+jsTypes.set(Object, new PlainObjectSerializer());
+jsTypes.set(Array, new ArraySerializer());
+jsTypes.set(null, new NullPrototypeObjectSerializer());
+jsTypes.set(Map, new MapObjectSerializer());
+jsTypes.set(Set, new SetObjectSerializer());
+jsTypes.set(Date, new DateObjectSerializer());
+jsTypes.set(RegExp, new RegExpObjectSerializer());
+jsTypes.set(Error, new ErrorObjectSerializer(Error));
+jsTypes.set(EvalError, new ErrorObjectSerializer(EvalError));
+jsTypes.set(RangeError, new ErrorObjectSerializer(RangeError));
+jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
+jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
+jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
 
-class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("create fake namespace object");
+// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
+// real Object and Array types to. These types may occur in the wild too, e. g. when
+// using Structured Clone in postMessage.
+if (exports.constructor !== Object) {
+	const Obj = /** @type {typeof Object} */ (exports.constructor);
+	const Fn = /** @type {typeof Function} */ (Obj.constructor);
+	for (const [type, config] of Array.from(jsTypes)) {
+		if (type) {
+			const Type = new Fn(`return ${type.name};`)();
+			jsTypes.set(Type, config);
+		}
 	}
+}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.createFakeNamespaceObject;
-		return Template.asString([
-			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
-				"Object.getPrototypeOf(obj)",
-				"obj"
-			)} : ${runtimeTemplate.returningFunction("obj.__proto__", "obj")};`,
-			"var leafPrototypes;",
-			"// create a fake namespace object",
-			"// mode & 1: value is a module id, require it",
-			"// mode & 2: merge all properties of value into the ns",
-			"// mode & 4: return value when already ns object",
-			"// mode & 16: return value when it's Promise-like",
-			"// mode & 8|1: behave like require",
-			// Note: must be a function (not arrow), because this is used in body!
-			`${fn} = function(value, mode) {`,
-			Template.indent([
-				`if(mode & 1) value = this(value);`,
-				`if(mode & 8) return value;`,
-				"if(typeof value === 'object' && value) {",
-				Template.indent([
-					"if((mode & 4) && value.__esModule) return value;",
-					"if((mode & 16) && typeof value.then === 'function') return value;"
-				]),
-				"}",
-				"var ns = Object.create(null);",
-				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
-				"var def = {};",
-				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
-				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
-				Template.indent([
-					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
-						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,
-						"key"
-					)});`
-				]),
-				"}",
-				`def['default'] = ${runtimeTemplate.returningFunction("value", "")};`,
-				`${RuntimeGlobals.definePropertyGetters}(ns, def);`,
-				"return ns;"
-			]),
-			"};"
-		]);
+{
+	let i = 1;
+	for (const [type, serializer] of jsTypes) {
+		serializers.set(type, {
+			request: "",
+			name: i++,
+			serializer
+		});
 	}
 }
 
-module.exports = CreateFakeNamespaceObjectRuntimeModule;
-
-
-/***/ }),
-
-/***/ 2759:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
+for (const { request, name, serializer } of serializers.values()) {
+	serializerInversed.set(`${request}/${name}`, serializer);
+}
 
-class CreateScriptRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("trusted types script");
-	}
+/** @type {Map<RegExp, (request: string) => boolean>} */
+const loaders = new Map();
 
+/**
+ * @typedef {ComplexSerializableType[]} DeserializedType
+ * @typedef {PrimitiveSerializableType[]} SerializedType
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ */
+class ObjectMiddleware extends SerializerMiddleware {
 	/**
-	 * @returns {string} runtime code
+	 * @param {function(any): void} extendContext context extensions
+	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const { trustedTypes } = outputOptions;
-		const fn = RuntimeGlobals.createScript;
-
-		return Template.asString(
-			`${fn} = ${runtimeTemplate.returningFunction(
-				trustedTypes
-					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)`
-					: "script",
-				"script"
-			)};`
-		);
-	}
-}
-
-module.exports = CreateScriptRuntimeModule;
-
-
-/***/ }),
-
-/***/ 21213:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("trusted types script url");
+	constructor(extendContext, hashFunction = "md4") {
+		super();
+		this.extendContext = extendContext;
+		this._hashFunction = hashFunction;
 	}
-
 	/**
-	 * @returns {string} runtime code
+	 * @param {RegExp} regExp RegExp for which the request is tested
+	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const { trustedTypes } = outputOptions;
-		const fn = RuntimeGlobals.createScriptUrl;
-
-		return Template.asString(
-			`${fn} = ${runtimeTemplate.returningFunction(
-				trustedTypes
-					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScriptURL(url)`
-					: "url",
-				"url"
-			)};`
-		);
+	static registerLoader(regExp, loader) {
+		loaders.set(regExp, loader);
 	}
-}
-
-module.exports = CreateScriptUrlRuntimeModule;
-
-
-/***/ }),
-
-/***/ 75481:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+	/**
+	 * @param {Constructor} Constructor the constructor
+	 * @param {string} request the request which will be required when deserializing
+	 * @param {string} name the name to make multiple serializer unique when sharing a request
+	 * @param {ObjectSerializer} serializer the serializer
+	 * @returns {void}
+	 */
+	static register(Constructor, request, name, serializer) {
+		const key = request + "/" + name;
 
+		if (serializers.has(Constructor)) {
+			throw new Error(
+				`ObjectMiddleware.register: serializer for ${Constructor.name} is already registered`
+			);
+		}
 
+		if (serializerInversed.has(key)) {
+			throw new Error(
+				`ObjectMiddleware.register: serializer for ${key} is already registered`
+			);
+		}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
+		serializers.set(Constructor, {
+			request,
+			name,
+			serializer
+		});
 
-class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("define property getters");
+		serializerInversed.set(key, serializer);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {Constructor} Constructor the constructor
+	 * @returns {void}
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.definePropertyGetters;
-		return Template.asString([
-			"// define getter functions for harmony exports",
-			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
-				`for(var key in definition) {`,
-				Template.indent([
-					`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
-					Template.indent([
-						"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
-					]),
-					"}"
-				]),
-				"}"
-			])};`
-		]);
-	}
-}
-
-module.exports = DefinePropertyGettersRuntimeModule;
+	static registerNotSerializable(Constructor) {
+		if (serializers.has(Constructor)) {
+			throw new Error(
+				`ObjectMiddleware.registerNotSerializable: serializer for ${Constructor.name} is already registered`
+			);
+		}
 
+		serializers.set(Constructor, NOT_SERIALIZABLE);
+	}
 
-/***/ }),
+	static getSerializerFor(object) {
+		const proto = Object.getPrototypeOf(object);
+		let c;
+		if (proto === null) {
+			// Object created with Object.create(null)
+			c = null;
+		} else {
+			c = proto.constructor;
+			if (!c) {
+				throw new Error(
+					"Serialization of objects with prototype without valid constructor property not possible"
+				);
+			}
+		}
+		const config = serializers.get(c);
 
-/***/ 71519:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		if (!config) throw new Error(`No serializer registered for ${c.name}`);
+		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+		return config;
+	}
 
+	static getDeserializerFor(request, name) {
+		const key = request + "/" + name;
+		const serializer = serializerInversed.get(key);
 
+		if (serializer === undefined) {
+			throw new Error(`No deserializer registered for ${key}`);
+		}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+		return serializer;
+	}
 
-class EnsureChunkRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("ensure chunk");
-		this.runtimeRequirements = runtimeRequirements;
+	static _getDeserializerForWithoutError(request, name) {
+		const key = request + "/" + name;
+		const serializer = serializerInversed.get(key);
+		return serializer;
 	}
 
 	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		// Check if there are non initial chunks which need to be imported using require-ensure
-		if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
-			const handlers = RuntimeGlobals.ensureChunkHandlers;
-			return Template.asString([
-				`${handlers} = {};`,
-				"// This file contains only the entry chunk.",
-				"// The chunk loading function for additional chunks",
-				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
-					"chunkId",
-					[
-						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
-							"promises, key",
-							[`${handlers}[key](chunkId, promises);`, "return promises;"]
-						)}, []));`
-					]
-				)};`
-			]);
-		} else {
-			// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
-			// function. This can happen with multiple entrypoints.
-			return Template.asString([
-				"// The chunk loading function for additional chunks",
-				"// Since all referenced chunks are already included",
-				"// in this file, this function is empty here.",
-				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
-					"Promise.resolve()"
-				)};`
-			]);
-		}
-	}
-}
-
-module.exports = EnsureChunkRuntimeModule;
-
-
-/***/ }),
-
-/***/ 34277:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 */
+	serialize(data, context) {
+		/** @type {any[]} */
+		let result = [CURRENT_VERSION];
+		let currentPos = 0;
+		let referenceable = new Map();
+		const addReferenceable = item => {
+			referenceable.set(item, currentPos++);
+		};
+		let bufferDedupeMap = new Map();
+		const dedupeBuffer = buf => {
+			const len = buf.length;
+			const entry = bufferDedupeMap.get(len);
+			if (entry === undefined) {
+				bufferDedupeMap.set(len, buf);
+				return buf;
+			}
+			if (Buffer.isBuffer(entry)) {
+				if (len < 32) {
+					if (buf.equals(entry)) {
+						return entry;
+					}
+					bufferDedupeMap.set(len, [entry, buf]);
+					return buf;
+				} else {
+					const hash = toHash(entry, this._hashFunction);
+					const newMap = new Map();
+					newMap.set(hash, entry);
+					bufferDedupeMap.set(len, newMap);
+					const hashBuf = toHash(buf, this._hashFunction);
+					if (hash === hashBuf) {
+						return entry;
+					}
+					return buf;
+				}
+			} else if (Array.isArray(entry)) {
+				if (entry.length < 16) {
+					for (const item of entry) {
+						if (buf.equals(item)) {
+							return item;
+						}
+					}
+					entry.push(buf);
+					return buf;
+				} else {
+					const newMap = new Map();
+					const hash = toHash(buf, this._hashFunction);
+					let found;
+					for (const item of entry) {
+						const itemHash = toHash(item, this._hashFunction);
+						newMap.set(itemHash, item);
+						if (found === undefined && itemHash === hash) found = item;
+					}
+					bufferDedupeMap.set(len, newMap);
+					if (found === undefined) {
+						newMap.set(hash, buf);
+						return buf;
+					} else {
+						return found;
+					}
+				}
+			} else {
+				const hash = toHash(buf, this._hashFunction);
+				const item = entry.get(hash);
+				if (item !== undefined) {
+					return item;
+				}
+				entry.set(hash, buf);
+				return buf;
+			}
+		};
+		let currentPosTypeLookup = 0;
+		let objectTypeLookup = new Map();
+		const cycleStack = new Set();
+		const stackToString = item => {
+			const arr = Array.from(cycleStack);
+			arr.push(item);
+			return arr
+				.map(item => {
+					if (typeof item === "string") {
+						if (item.length > 100) {
+							return `String ${JSON.stringify(item.slice(0, 100)).slice(
+								0,
+								-1
+							)}..."`;
+						}
+						return `String ${JSON.stringify(item)}`;
+					}
+					try {
+						const { request, name } = ObjectMiddleware.getSerializerFor(item);
+						if (request) {
+							return `${request}${name ? `.${name}` : ""}`;
+						}
+					} catch (e) {
+						// ignore -> fallback
+					}
+					if (typeof item === "object" && item !== null) {
+						if (item.constructor) {
+							if (item.constructor === Object)
+								return `Object { ${Object.keys(item).join(", ")} }`;
+							if (item.constructor === Map) return `Map { ${item.size} items }`;
+							if (item.constructor === Array)
+								return `Array { ${item.length} items }`;
+							if (item.constructor === Set) return `Set { ${item.size} items }`;
+							if (item.constructor === RegExp) return item.toString();
+							return `${item.constructor.name}`;
+						}
+						return `Object [null prototype] { ${Object.keys(item).join(
+							", "
+						)} }`;
+					}
+					try {
+						return `${item}`;
+					} catch (e) {
+						return `(${e.message})`;
+					}
+				})
+				.join(" -> ");
+		};
+		let hasDebugInfoAttached;
+		let ctx = {
+			write(value, key) {
+				try {
+					process(value);
+				} catch (e) {
+					if (e !== NOT_SERIALIZABLE) {
+						if (hasDebugInfoAttached === undefined)
+							hasDebugInfoAttached = new WeakSet();
+						if (!hasDebugInfoAttached.has(e)) {
+							e.message += `\nwhile serializing ${stackToString(value)}`;
+							hasDebugInfoAttached.add(e);
+						}
+					}
+					throw e;
+				}
+			},
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			snapshot() {
+				return {
+					length: result.length,
+					cycleStackSize: cycleStack.size,
+					referenceableSize: referenceable.size,
+					currentPos,
+					objectTypeLookupSize: objectTypeLookup.size,
+					currentPosTypeLookup
+				};
+			},
+			rollback(snapshot) {
+				result.length = snapshot.length;
+				setSetSize(cycleStack, snapshot.cycleStackSize);
+				setMapSize(referenceable, snapshot.referenceableSize);
+				currentPos = snapshot.currentPos;
+				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
+				currentPosTypeLookup = snapshot.currentPosTypeLookup;
+			},
+			...context
+		};
+		this.extendContext(ctx);
+		const process = item => {
+			if (Buffer.isBuffer(item)) {
+				// check if we can emit a reference
+				const ref = referenceable.get(item);
+				if (ref !== undefined) {
+					result.push(ESCAPE, ref - currentPos);
+					return;
+				}
+				const alreadyUsedBuffer = dedupeBuffer(item);
+				if (alreadyUsedBuffer !== item) {
+					const ref = referenceable.get(alreadyUsedBuffer);
+					if (ref !== undefined) {
+						referenceable.set(item, ref);
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
+					item = alreadyUsedBuffer;
+				}
+				addReferenceable(item);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+				result.push(item);
+			} else if (item === ESCAPE) {
+				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+			} else if (
+				typeof item === "object"
+				// We don't have to check for null as ESCAPE is null and this has been checked before
+			) {
+				// check if we can emit a reference
+				const ref = referenceable.get(item);
+				if (ref !== undefined) {
+					result.push(ESCAPE, ref - currentPos);
+					return;
+				}
 
+				if (cycleStack.has(item)) {
+					throw new Error(
+						`This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize.`
+					);
+				}
 
+				const { request, name, serializer } =
+					ObjectMiddleware.getSerializerFor(item);
+				const key = `${request}/${name}`;
+				const lastIndex = objectTypeLookup.get(key);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const { first } = __webpack_require__(93347);
+				if (lastIndex === undefined) {
+					objectTypeLookup.set(key, currentPosTypeLookup++);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
+					result.push(ESCAPE, request, name);
+				} else {
+					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
+				}
 
-/** @typedef {function(PathData, AssetInfo=): string} FilenameFunction */
+				cycleStack.add(item);
 
-class GetChunkFilenameRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} contentType the contentType to use the content hash for
-	 * @param {string} name kind of filename
-	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
-	 * @param {boolean} allChunks when false, only async chunks are included
-	 */
-	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
-		super(`get ${name} chunk filename`);
-		this.contentType = contentType;
-		this.global = global;
-		this.getFilenameForChunk = getFilenameForChunk;
-		this.allChunks = allChunks;
-		this.dependentHash = true;
-	}
+				try {
+					serializer.serialize(item, ctx);
+				} finally {
+					cycleStack.delete(item);
+				}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const {
-			global,
-			chunk,
-			chunkGraph,
-			contentType,
-			getFilenameForChunk,
-			allChunks,
-			compilation
-		} = this;
-		const { runtimeTemplate } = compilation;
+				result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
-		const chunkFilenames = new Map();
-		let maxChunks = 0;
-		/** @type {string} */
-		let dynamicFilename;
+				addReferenceable(item);
+			} else if (typeof item === "string") {
+				if (item.length > 1) {
+					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+					// check if we can emit a reference
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
+					addReferenceable(item);
+				}
 
-		/**
-		 * @param {Chunk} c the chunk
-		 * @returns {void}
-		 */
-		const addChunk = c => {
-			const chunkFilename = getFilenameForChunk(c);
-			if (chunkFilename) {
-				let set = chunkFilenames.get(chunkFilename);
-				if (set === undefined) {
-					chunkFilenames.set(chunkFilename, (set = new Set()));
+				if (item.length > 102400 && context.logger) {
+					context.logger.warn(
+						`Serializing big strings (${Math.round(
+							item.length / 1024
+						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
+					);
 				}
-				set.add(c);
-				if (typeof chunkFilename === "string") {
-					if (set.size < maxChunks) return;
-					if (set.size === maxChunks) {
-						if (chunkFilename.length < dynamicFilename.length) return;
-						if (chunkFilename.length === dynamicFilename.length) {
-							if (chunkFilename < dynamicFilename) return;
-						}
+
+				result.push(item);
+			} else if (typeof item === "function") {
+				if (!SerializerMiddleware.isLazy(item))
+					throw new Error("Unexpected function " + item);
+				/** @type {SerializedType} */
+				const serializedData =
+					SerializerMiddleware.getLazySerializedValue(item);
+				if (serializedData !== undefined) {
+					if (typeof serializedData === "function") {
+						result.push(serializedData);
+					} else {
+						throw new Error("Not implemented");
 					}
-					maxChunks = set.size;
-					dynamicFilename = chunkFilename;
+				} else if (SerializerMiddleware.isLazy(item, this)) {
+					throw new Error("Not implemented");
+				} else {
+					const data = SerializerMiddleware.serializeLazy(item, data =>
+						this.serialize([data], context)
+					);
+					SerializerMiddleware.setLazySerializedValue(item, data);
+					result.push(data);
 				}
+			} else if (item === undefined) {
+				result.push(ESCAPE, ESCAPE_UNDEFINED);
+			} else {
+				result.push(item);
 			}
 		};
 
-		/** @type {string[]} */
-		const includedChunksMessages = [];
-		if (allChunks) {
-			includedChunksMessages.push("all chunks");
-			for (const c of chunk.getAllReferencedChunks()) {
-				addChunk(c);
-			}
-		} else {
-			includedChunksMessages.push("async chunks");
-			for (const c of chunk.getAllAsyncChunks()) {
-				addChunk(c);
-			}
-			const includeEntries = chunkGraph
-				.getTreeRuntimeRequirements(chunk)
-				.has(RuntimeGlobals.ensureChunkIncludeEntries);
-			if (includeEntries) {
-				includedChunksMessages.push("sibling chunks for the entrypoint");
-				for (const c of chunkGraph.getChunkEntryDependentChunksIterable(
-					chunk
-				)) {
-					addChunk(c);
-				}
+		try {
+			for (const item of data) {
+				process(item);
 			}
+			return result;
+		} catch (e) {
+			if (e === NOT_SERIALIZABLE) return null;
+
+			throw e;
+		} finally {
+			// Get rid of these references to avoid leaking memory
+			// This happens because the optimized code v8 generates
+			// is optimized for our "ctx.write" method so it will reference
+			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
+			data =
+				result =
+				referenceable =
+				bufferDedupeMap =
+				objectTypeLookup =
+				ctx =
+					undefined;
 		}
-		for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {
-			addChunk(entrypoint.chunks[entrypoint.chunks.length - 1]);
-		}
+	}
 
-		/** @type {Map<string, Set<string | number>>} */
-		const staticUrls = new Map();
-		/** @type {Set<Chunk>} */
-		const dynamicUrlChunks = new Set();
+	/**
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 */
+	deserialize(data, context) {
+		let currentDataPos = 0;
+		const read = () => {
+			if (currentDataPos >= data.length)
+				throw new Error("Unexpected end of stream");
 
-		/**
-		 * @param {Chunk} c the chunk
-		 * @param {string | FilenameFunction} chunkFilename the filename template for the chunk
-		 * @returns {void}
-		 */
-		const addStaticUrl = (c, chunkFilename) => {
-			/**
-			 * @param {string | number} value a value
-			 * @returns {string} string to put in quotes
-			 */
-			const unquotedStringify = value => {
-				const str = `${value}`;
-				if (str.length >= 5 && str === `${c.id}`) {
-					// This is shorter and generates the same result
-					return '" + chunkId + "';
-				}
-				const s = JSON.stringify(str);
-				return s.slice(1, s.length - 1);
-			};
-			const unquotedStringifyWithLength = value => length =>
-				unquotedStringify(`${value}`.slice(0, length));
-			const chunkFilenameValue =
-				typeof chunkFilename === "function"
-					? JSON.stringify(
-							chunkFilename({
-								chunk: c,
-								contentHashType: contentType
-							})
-					  )
-					: JSON.stringify(chunkFilename);
-			const staticChunkFilename = compilation.getPath(chunkFilenameValue, {
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				chunk: {
-					id: unquotedStringify(c.id),
-					hash: unquotedStringify(c.renderedHash),
-					hashWithLength: unquotedStringifyWithLength(c.renderedHash),
-					name: unquotedStringify(c.name || c.id),
-					contentHash: {
-						[contentType]: unquotedStringify(c.contentHash[contentType])
-					},
-					contentHashWithLength: {
-						[contentType]: unquotedStringifyWithLength(
-							c.contentHash[contentType]
-						)
-					}
-				},
-				contentHashType: contentType
-			});
-			let set = staticUrls.get(staticChunkFilename);
-			if (set === undefined) {
-				staticUrls.set(staticChunkFilename, (set = new Set()));
-			}
-			set.add(c.id);
+			return data[currentDataPos++];
 		};
 
-		for (const [filename, chunks] of chunkFilenames) {
-			if (filename !== dynamicFilename) {
-				for (const c of chunks) addStaticUrl(c, filename);
-			} else {
-				for (const c of chunks) dynamicUrlChunks.add(c);
-			}
-		}
+		if (read() !== CURRENT_VERSION)
+			throw new Error("Version mismatch, serializer changed");
 
-		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {string} code with static mapping of results of fn
-		 */
-		const createMap = fn => {
-			const obj = {};
-			let useId = false;
-			let lastKey;
-			let entries = 0;
-			for (const c of dynamicUrlChunks) {
-				const value = fn(c);
-				if (value === c.id) {
-					useId = true;
-				} else {
-					obj[c.id] = value;
-					lastKey = c.id;
-					entries++;
-				}
-			}
-			if (entries === 0) return "chunkId";
-			if (entries === 1) {
-				return useId
-					? `(chunkId === ${JSON.stringify(lastKey)} ? ${JSON.stringify(
-							obj[lastKey]
-					  )} : chunkId)`
-					: JSON.stringify(obj[lastKey]);
-			}
-			return useId
-				? `(${JSON.stringify(obj)}[chunkId] || chunkId)`
-				: `${JSON.stringify(obj)}[chunkId]`;
+		let currentPos = 0;
+		let referenceable = [];
+		const addReferenceable = item => {
+			referenceable.push(item);
+			currentPos++;
 		};
-
-		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {string} code with static mapping of results of fn for including in quoted string
-		 */
-		const mapExpr = fn => {
-			return `" + ${createMap(fn)} + "`;
+		let currentPosTypeLookup = 0;
+		let objectTypeLookup = [];
+		let result = [];
+		let ctx = {
+			read() {
+				return decodeValue();
+			},
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			...context
 		};
+		this.extendContext(ctx);
+		const decodeValue = () => {
+			const item = read();
 
-		/**
-		 * @param {function(Chunk): string | number} fn function from chunk to value
-		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
-		 */
-		const mapExprWithLength = fn => length => {
-			return `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
-		};
+			if (item === ESCAPE) {
+				const nextItem = read();
 
-		const url =
-			dynamicFilename &&
-			compilation.getPath(JSON.stringify(dynamicFilename), {
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				chunk: {
-					id: `" + chunkId + "`,
-					hash: mapExpr(c => c.renderedHash),
-					hashWithLength: mapExprWithLength(c => c.renderedHash),
-					name: mapExpr(c => c.name || c.id),
-					contentHash: {
-						[contentType]: mapExpr(c => c.contentHash[contentType])
-					},
-					contentHashWithLength: {
-						[contentType]: mapExprWithLength(c => c.contentHash[contentType])
-					}
-				},
-				contentHashType: contentType
-			});
+				if (nextItem === ESCAPE_ESCAPE_VALUE) {
+					return ESCAPE;
+				} else if (nextItem === ESCAPE_UNDEFINED) {
+					return undefined;
+				} else if (nextItem === ESCAPE_END_OBJECT) {
+					throw new Error(
+						`Unexpected end of object at position ${currentDataPos - 1}`
+					);
+				} else {
+					const request = nextItem;
+					let serializer;
 
-		return Template.asString([
-			`// This function allow to reference ${includedChunksMessages.join(
-				" and "
-			)}`,
-			`${global} = ${runtimeTemplate.basicFunction(
-				"chunkId",
+					if (typeof request === "number") {
+						if (request < 0) {
+							// relative reference
+							return referenceable[currentPos + request];
+						}
+						serializer = objectTypeLookup[currentPosTypeLookup - request];
+					} else {
+						if (typeof request !== "string") {
+							throw new Error(
+								`Unexpected type (${typeof request}) of request ` +
+									`at position ${currentDataPos - 1}`
+							);
+						}
+						const name = read();
 
-				staticUrls.size > 0
-					? [
-							"// return url for filenames not based on template",
-							// it minimizes to `x===1?"...":x===2?"...":"..."`
-							Template.asString(
-								Array.from(staticUrls, ([url, ids]) => {
-									const condition =
-										ids.size === 1
-											? `chunkId === ${JSON.stringify(first(ids))}`
-											: `{${Array.from(
-													ids,
-													id => `${JSON.stringify(id)}:1`
-											  ).join(",")}}[chunkId]`;
-									return `if (${condition}) return ${url};`;
-								})
-							),
-							"// return url for filenames based on template",
-							`return ${url};`
-					  ]
-					: ["// return url for filenames based on template", `return ${url};`]
-			)};`
-		]);
-	}
-}
+						serializer = ObjectMiddleware._getDeserializerForWithoutError(
+							request,
+							name
+						);
 
-module.exports = GetChunkFilenameRuntimeModule;
+						if (serializer === undefined) {
+							if (request && !loadedRequests.has(request)) {
+								let loaded = false;
+								for (const [regExp, loader] of loaders) {
+									if (regExp.test(request)) {
+										if (loader(request)) {
+											loaded = true;
+											break;
+										}
+									}
+								}
+								if (!loaded) {
+									require(request);
+								}
 
+								loadedRequests.add(request);
+							}
 
-/***/ }),
+							serializer = ObjectMiddleware.getDeserializerFor(request, name);
+						}
 
-/***/ 88732:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+						objectTypeLookup.push(serializer);
+						currentPosTypeLookup++;
+					}
+					try {
+						const item = serializer.deserialize(ctx);
+						const end1 = read();
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+						if (end1 !== ESCAPE) {
+							throw new Error("Expected end of object");
+						}
 
+						const end2 = read();
 
+						if (end2 !== ESCAPE_END_OBJECT) {
+							throw new Error("Expected end of object");
+						}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
+						addReferenceable(item);
 
-/** @typedef {import("../Compilation")} Compilation */
+						return item;
+					} catch (err) {
+						// As this is only for error handling, we omit creating a Map for
+						// faster access to this information, as this would affect performance
+						// in the good case
+						let serializerEntry;
+						for (const entry of serializers) {
+							if (entry[1].serializer === serializer) {
+								serializerEntry = entry;
+								break;
+							}
+						}
+						const name = !serializerEntry
+							? "unknown"
+							: !serializerEntry[1].request
+							? serializerEntry[0].name
+							: serializerEntry[1].name
+							? `${serializerEntry[1].request} ${serializerEntry[1].name}`
+							: serializerEntry[1].request;
+						err.message += `\n(during deserialization of ${name})`;
+						throw err;
+					}
+				}
+			} else if (typeof item === "string") {
+				if (item.length > 1) {
+					addReferenceable(item);
+				}
 
-class GetFullHashRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("getFullHash");
-		this.fullHash = true;
-	}
+				return item;
+			} else if (Buffer.isBuffer(item)) {
+				addReferenceable(item);
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(
-			JSON.stringify(this.compilation.hash || "XXXX")
-		)}`;
+				return item;
+			} else if (typeof item === "function") {
+				return SerializerMiddleware.deserializeLazy(
+					item,
+					data => this.deserialize(data, context)[0]
+				);
+			} else {
+				return item;
+			}
+		};
+
+		try {
+			while (currentDataPos < data.length) {
+				result.push(decodeValue());
+			}
+			return result;
+		} finally {
+			// Get rid of these references to avoid leaking memory
+			// This happens because the optimized code v8 generates
+			// is optimized for our "ctx.read" method so it will reference
+			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
+			result = referenceable = data = objectTypeLookup = ctx = undefined;
+		}
 	}
 }
 
-module.exports = GetFullHashRuntimeModule;
+module.exports = ObjectMiddleware;
+module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
 
 
 /***/ }),
 
-/***/ 10029:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 33040:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -116601,50 +114022,86 @@ module.exports = GetFullHashRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+const cache = new WeakMap();
 
-/** @typedef {import("../Compilation")} Compilation */
+class ObjectStructure {
+	constructor() {
+		this.keys = undefined;
+		this.children = undefined;
+	}
 
-class GetMainFilenameRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {string} name readable name
-	 * @param {string} global global object binding
-	 * @param {string} filename main file name
-	 */
-	constructor(name, global, filename) {
-		super(`get ${name} filename`);
-		this.global = global;
-		this.filename = filename;
+	getKeys(keys) {
+		if (this.keys === undefined) this.keys = keys;
+		return this.keys;
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { global, filename, compilation, chunk } = this;
-		const { runtimeTemplate } = compilation;
-		const url = compilation.getPath(JSON.stringify(filename), {
-			hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-			hashWithLength: length =>
-				`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-			chunk,
-			runtime: chunk.runtime
-		});
-		return Template.asString([
-			`${global} = ${runtimeTemplate.returningFunction(url)};`
-		]);
+	key(key) {
+		if (this.children === undefined) this.children = new Map();
+		const child = this.children.get(key);
+		if (child !== undefined) return child;
+		const newChild = new ObjectStructure();
+		this.children.set(key, newChild);
+		return newChild;
 	}
 }
 
-module.exports = GetMainFilenameRuntimeModule;
+const getCachedKeys = (keys, cacheAssoc) => {
+	let root = cache.get(cacheAssoc);
+	if (root === undefined) {
+		root = new ObjectStructure();
+		cache.set(cacheAssoc, root);
+	}
+	let current = root;
+	for (const key of keys) {
+		current = current.key(key);
+	}
+	return current.getKeys(keys);
+};
+
+class PlainObjectSerializer {
+	serialize(obj, { write }) {
+		const keys = Object.keys(obj);
+		if (keys.length > 128) {
+			// Objects with so many keys are unlikely to share structure
+			// with other objects
+			write(keys);
+			for (const key of keys) {
+				write(obj[key]);
+			}
+		} else if (keys.length > 1) {
+			write(getCachedKeys(keys, write));
+			for (const key of keys) {
+				write(obj[key]);
+			}
+		} else if (keys.length === 1) {
+			const key = keys[0];
+			write(key);
+			write(obj[key]);
+		} else {
+			write(null);
+		}
+	}
+	deserialize({ read }) {
+		const keys = read();
+		const obj = {};
+		if (Array.isArray(keys)) {
+			for (const key of keys) {
+				obj[key] = read();
+			}
+		} else if (keys !== null) {
+			obj[keys] = read();
+		}
+		return obj;
+	}
+}
+
+module.exports = PlainObjectSerializer;
 
 
 /***/ }),
 
-/***/ 38713:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 57328:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -116653,82 +114110,23 @@ module.exports = GetMainFilenameRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
-	/**
-	 * @param {Set<string>} runtimeRequirements runtime requirements
-	 */
-	constructor(runtimeRequirements) {
-		super("trusted types policy");
-		this.runtimeRequirements = runtimeRequirements;
+class RegExpObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.source);
+		write(obj.flags);
 	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const { trustedTypes } = outputOptions;
-		const fn = RuntimeGlobals.getTrustedTypesPolicy;
-
-		return Template.asString([
-			"var policy;",
-			`${fn} = ${runtimeTemplate.basicFunction("", [
-				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
-				"if (policy === undefined) {",
-				Template.indent([
-					"policy = {",
-					Template.indent(
-						[
-							...(this.runtimeRequirements.has(RuntimeGlobals.createScript)
-								? [
-										`createScript: ${runtimeTemplate.returningFunction(
-											"script",
-											"script"
-										)}`
-								  ]
-								: []),
-							...(this.runtimeRequirements.has(RuntimeGlobals.createScriptUrl)
-								? [
-										`createScriptURL: ${runtimeTemplate.returningFunction(
-											"url",
-											"url"
-										)}`
-								  ]
-								: [])
-						].join(",\n")
-					),
-					"};",
-					...(trustedTypes
-						? [
-								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
-								Template.indent([
-									`policy = trustedTypes.createPolicy(${JSON.stringify(
-										trustedTypes.policyName
-									)}, policy);`
-								]),
-								"}"
-						  ]
-						: [])
-				]),
-				"}",
-				"return policy;"
-			])};`
-		]);
+	deserialize({ read }) {
+		return new RegExp(read(), read());
 	}
 }
 
-module.exports = GetTrustedTypesPolicyRuntimeModule;
+module.exports = RegExpObjectSerializer;
 
 
 /***/ }),
 
-/***/ 23255:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 53080:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -116737,285 +114135,213 @@ module.exports = GetTrustedTypesPolicyRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+class Serializer {
+	constructor(middlewares, context) {
+		this.serializeMiddlewares = middlewares.slice();
+		this.deserializeMiddlewares = middlewares.slice().reverse();
+		this.context = context;
+	}
 
-class GlobalRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("global");
+	serialize(obj, context) {
+		const ctx = { ...context, ...this.context };
+		let current = obj;
+		for (const middleware of this.serializeMiddlewares) {
+			if (current && typeof current.then === "function") {
+				current = current.then(data => data && middleware.serialize(data, ctx));
+			} else if (current) {
+				try {
+					current = middleware.serialize(current, ctx);
+				} catch (err) {
+					current = Promise.reject(err);
+				}
+			} else break;
+		}
+		return current;
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return Template.asString([
-			`${RuntimeGlobals.global} = (function() {`,
-			Template.indent([
-				"if (typeof globalThis === 'object') return globalThis;",
-				"try {",
-				Template.indent(
-					// This works in non-strict mode
-					// or
-					// This works if eval is allowed (see CSP)
-					"return this || new Function('return this')();"
-				),
-				"} catch (e) {",
-				Template.indent(
-					// This works if the window reference is available
-					"if (typeof window === 'object') return window;"
-				),
-				"}"
-				// It can still be `undefined`, but nothing to do about it...
-				// We return `undefined`, instead of nothing here, so it's
-				// easier to handle this case:
-				//   if (!global) { … }
-			]),
-			"})();"
-		]);
+	deserialize(value, context) {
+		const ctx = { ...context, ...this.context };
+		/** @type {any} */
+		let current = value;
+		for (const middleware of this.deserializeMiddlewares) {
+			if (current && typeof current.then === "function") {
+				current = current.then(data => middleware.deserialize(data, ctx));
+			} else {
+				current = middleware.deserialize(current, ctx);
+			}
+		}
+		return current;
 	}
 }
 
-module.exports = GlobalRuntimeModule;
+module.exports = Serializer;
 
 
 /***/ }),
 
-/***/ 8011:
+/***/ 83137:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sergey Melyukov @smelukov
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+const memoize = __webpack_require__(78676);
 
-class HasOwnPropertyRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("hasOwnProperty shorthand");
-	}
+const LAZY_TARGET = Symbol("lazy serialization target");
+const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
+/**
+ * @template DeserializedType
+ * @template SerializedType
+ */
+class SerializerMiddleware {
+	/* istanbul ignore next */
 	/**
-	 * @returns {string} runtime code
+	 * @abstract
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-
-		return Template.asString([
-			`${RuntimeGlobals.hasOwnProperty} = ${runtimeTemplate.returningFunction(
-				"Object.prototype.hasOwnProperty.call(obj, prop)",
-				"obj, prop"
-			)}`
-		]);
+	serialize(data, context) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
-}
-
-module.exports = HasOwnPropertyRuntimeModule;
-
-
-/***/ }),
-
-/***/ 82444:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
 
-
-const RuntimeModule = __webpack_require__(16963);
-
-class HelperRuntimeModule extends RuntimeModule {
+	/* istanbul ignore next */
 	/**
-	 * @param {string} name a readable name
+	 * @abstract
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	constructor(name) {
-		super(name);
+	deserialize(data, context) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
-}
-
-module.exports = HelperRuntimeModule;
-
-
-/***/ }),
-
-/***/ 19942:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const { SyncWaterfallHook } = __webpack_require__(41242);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-
-/**
- * @typedef {Object} LoadScriptCompilationHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} createScript
- */
+	/**
+	 * @param {any | function(): Promise<any> | any} value contained value or function to value
+	 * @param {SerializerMiddleware<any, any>} target target middleware
+	 * @param {object=} options lazy options
+	 * @param {any=} serializedValue serialized value
+	 * @returns {function(): Promise<any> | any} lazy function
+	 */
+	static createLazy(value, target, options = {}, serializedValue) {
+		if (SerializerMiddleware.isLazy(value, target)) return value;
+		const fn = typeof value === "function" ? value : () => value;
+		fn[LAZY_TARGET] = target;
+		/** @type {any} */ (fn).options = options;
+		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
+		return fn;
+	}
 
-/** @type {WeakMap<Compilation, LoadScriptCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+	/**
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @param {SerializerMiddleware<any, any>=} target target middleware
+	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
+	 */
+	static isLazy(fn, target) {
+		if (typeof fn !== "function") return false;
+		const t = fn[LAZY_TARGET];
+		return target ? t === target : !!t;
+	}
 
-class LoadScriptRuntimeModule extends HelperRuntimeModule {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {LoadScriptCompilationHooks} hooks
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @returns {object} options
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				createScript: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
+	static getLazyOptions(fn) {
+		if (typeof fn !== "function") return undefined;
+		return /** @type {any} */ (fn).options;
 	}
 
 	/**
-	 * @param {boolean=} withCreateScriptUrl use create script url for trusted types
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @returns {any} serialized value
 	 */
-	constructor(withCreateScriptUrl) {
-		super("load script");
-		this._withCreateScriptUrl = withCreateScriptUrl;
+	static getLazySerializedValue(fn) {
+		if (typeof fn !== "function") return undefined;
+		return fn[LAZY_SERIALIZED_VALUE];
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {function(): Promise<any> | any} fn lazy function
+	 * @param {any} value serialized value
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate, outputOptions } = compilation;
-		const {
-			scriptType,
-			chunkLoadTimeout: loadTimeout,
-			crossOriginLoading,
-			uniqueName,
-			charset
-		} = outputOptions;
-		const fn = RuntimeGlobals.loadScript;
+	static setLazySerializedValue(fn, value) {
+		fn[LAZY_SERIALIZED_VALUE] = value;
+	}
 
-		const { createScript } =
-			LoadScriptRuntimeModule.getCompilationHooks(compilation);
+	/**
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @param {function(any): Promise<any> | any} serialize serialize function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	static serializeLazy(lazy, serialize) {
+		const fn = memoize(() => {
+			const r = lazy();
+			if (r && typeof r.then === "function") {
+				return r.then(data => data && serialize(data));
+			}
+			return serialize(r);
+		});
+		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		lazy[LAZY_SERIALIZED_VALUE] = fn;
+		return fn;
+	}
 
-		const code = Template.asString([
-			"script = document.createElement('script');",
-			scriptType ? `script.type = ${JSON.stringify(scriptType)};` : "",
-			charset ? "script.charset = 'utf-8';" : "",
-			`script.timeout = ${loadTimeout / 1000};`,
-			`if (${RuntimeGlobals.scriptNonce}) {`,
-			Template.indent(
-				`script.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
-			),
-			"}",
-			uniqueName
-				? 'script.setAttribute("data-webpack", dataWebpackPrefix + key);'
-				: "",
-			`script.src = ${
-				this._withCreateScriptUrl
-					? `${RuntimeGlobals.createScriptUrl}(url)`
-					: "url"
-			};`,
-			crossOriginLoading
-				? Template.asString([
-						"if (script.src.indexOf(window.location.origin + '/') !== 0) {",
-						Template.indent(
-							`script.crossOrigin = ${JSON.stringify(crossOriginLoading)};`
-						),
-						"}"
-				  ])
-				: ""
-		]);
+	/**
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @param {function(any): Promise<any> | any} deserialize deserialize function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	static deserializeLazy(lazy, deserialize) {
+		const fn = memoize(() => {
+			const r = lazy();
+			if (r && typeof r.then === "function") {
+				return r.then(data => deserialize(data));
+			}
+			return deserialize(r);
+		});
+		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
+		fn[LAZY_SERIALIZED_VALUE] = lazy;
+		return fn;
+	}
 
-		return Template.asString([
-			"var inProgress = {};",
-			uniqueName
-				? `var dataWebpackPrefix = ${JSON.stringify(uniqueName + ":")};`
-				: "// data-webpack is not used as build has no uniqueName",
-			"// loadScript function to load a script via script tag",
-			`${fn} = ${runtimeTemplate.basicFunction("url, done, key, chunkId", [
-				"if(inProgress[url]) { inProgress[url].push(done); return; }",
-				"var script, needAttach;",
-				"if(key !== undefined) {",
-				Template.indent([
-					'var scripts = document.getElementsByTagName("script");',
-					"for(var i = 0; i < scripts.length; i++) {",
-					Template.indent([
-						"var s = scripts[i];",
-						`if(s.getAttribute("src") == url${
-							uniqueName
-								? ' || s.getAttribute("data-webpack") == dataWebpackPrefix + key'
-								: ""
-						}) { script = s; break; }`
-					]),
-					"}"
-				]),
-				"}",
-				"if(!script) {",
-				Template.indent([
-					"needAttach = true;",
-					createScript.call(code, this.chunk)
-				]),
-				"}",
-				"inProgress[url] = [done];",
-				"var onScriptComplete = " +
-					runtimeTemplate.basicFunction(
-						"prev, event",
-						Template.asString([
-							"// avoid mem leaks in IE.",
-							"script.onerror = script.onload = null;",
-							"clearTimeout(timeout);",
-							"var doneFns = inProgress[url];",
-							"delete inProgress[url];",
-							"script.parentNode && script.parentNode.removeChild(script);",
-							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
-								"fn(event)",
-								"fn"
-							)});`,
-							"if(prev) return prev(event);"
-						])
-					),
-				";",
-				`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
-				"script.onerror = onScriptComplete.bind(null, script.onerror);",
-				"script.onload = onScriptComplete.bind(null, script.onload);",
-				"needAttach && document.head.appendChild(script);"
-			])};`
-		]);
+	/**
+	 * @param {function(): Promise<any> | any} lazy lazy function
+	 * @returns {function(): Promise<any> | any} new lazy
+	 */
+	static unMemoizeLazy(lazy) {
+		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
+		const fn = () => {
+			throw new Error(
+				"A lazy value that has been unmemorized can't be called again"
+			);
+		};
+		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
+			lazy[LAZY_SERIALIZED_VALUE]
+		);
+		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
+		fn.options = /** @type {any} */ (lazy).options;
+		return fn;
 	}
 }
 
-module.exports = LoadScriptRuntimeModule;
+module.exports = SerializerMiddleware;
 
 
 /***/ }),
 
-/***/ 65714:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 79240:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -117024,41 +114350,29 @@ module.exports = LoadScriptRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
-
-class MakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("make namespace object");
+class SetObjectSerializer {
+	serialize(obj, { write }) {
+		write(obj.size);
+		for (const value of obj) {
+			write(value);
+		}
 	}
-
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		const fn = RuntimeGlobals.makeNamespaceObject;
-		return Template.asString([
-			"// define __esModule on exports",
-			`${fn} = ${runtimeTemplate.basicFunction("exports", [
-				"if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {",
-				Template.indent([
-					"Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });"
-				]),
-				"}",
-				"Object.defineProperty(exports, '__esModule', { value: true });"
-			])};`
-		]);
+	deserialize({ read }) {
+		let size = read();
+		const set = new Set();
+		for (let i = 0; i < size; i++) {
+			set.add(read());
+		}
+		return set;
 	}
 }
 
-module.exports = MakeNamespaceObjectRuntimeModule;
+module.exports = SetObjectSerializer;
 
 
 /***/ }),
 
-/***/ 44518:
+/***/ 65112:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -117068,452 +114382,336 @@ module.exports = MakeNamespaceObjectRuntimeModule;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+const SerializerMiddleware = __webpack_require__(83137);
 
-class OnChunksLoadedRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("chunk loaded");
+/**
+ * @typedef {any} DeserializedType
+ * @typedef {any[]} SerializedType
+ * @extends {SerializerMiddleware<any, any[]>}
+ */
+class SingleItemMiddleware extends SerializerMiddleware {
+	/**
+	 * @param {DeserializedType} data data
+	 * @param {Object} context context object
+	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 */
+	serialize(data, context) {
+		return [data];
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {SerializedType} data data
+	 * @param {Object} context context object
+	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate } = compilation;
-		return Template.asString([
-			"var deferred = [];",
-			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
-				"result, chunkIds, fn, priority",
-				[
-					"if(chunkIds) {",
-					Template.indent([
-						"priority = priority || 0;",
-						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
-						"deferred[i] = [chunkIds, fn, priority];",
-						"return;"
-					]),
-					"}",
-					"var notFulfilled = Infinity;",
-					"for (var i = 0; i < deferred.length; i++) {",
-					Template.indent([
-						runtimeTemplate.destructureArray(
-							["chunkIds", "fn", "priority"],
-							"deferred[i]"
-						),
-						"var fulfilled = true;",
-						"for (var j = 0; j < chunkIds.length; j++) {",
-						Template.indent([
-							`if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(${
-								RuntimeGlobals.onChunksLoaded
-							}).every(${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
-								"key"
-							)})) {`,
-							Template.indent(["chunkIds.splice(j--, 1);"]),
-							"} else {",
-							Template.indent([
-								"fulfilled = false;",
-								"if(priority < notFulfilled) notFulfilled = priority;"
-							]),
-							"}"
-						]),
-						"}",
-						"if(fulfilled) {",
-						Template.indent([
-							"deferred.splice(i--, 1)",
-							"var r = fn();",
-							"if (r !== undefined) result = r;"
-						]),
-						"}"
-					]),
-					"}",
-					"return result;"
-				]
-			)};`
-		]);
+	deserialize(data, context) {
+		return data[0];
 	}
 }
 
-module.exports = OnChunksLoadedRuntimeModule;
+module.exports = SingleItemMiddleware;
 
 
 /***/ }),
 
-/***/ 56030:
+/***/ 58831:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
 
-class PublicPathRuntimeModule extends RuntimeModule {
-	constructor(publicPath) {
-		super("publicPath", RuntimeModule.STAGE_BASIC);
-		this.publicPath = publicPath;
+class ConsumeSharedFallbackDependency extends ModuleDependency {
+	constructor(request) {
+		super(request);
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, publicPath } = this;
+	get type() {
+		return "consume shared fallback";
+	}
 
-		return `${RuntimeGlobals.publicPath} = ${JSON.stringify(
-			compilation.getPath(publicPath || "", {
-				hash: compilation.hash || "XXXX"
-			})
-		)};`;
+	get category() {
+		return "esm";
 	}
 }
 
-module.exports = PublicPathRuntimeModule;
+makeSerializable(
+	ConsumeSharedFallbackDependency,
+	"webpack/lib/sharing/ConsumeSharedFallbackDependency"
+);
+
+module.exports = ConsumeSharedFallbackDependency;
 
 
 /***/ }),
 
-/***/ 4537:
+/***/ 62286:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
+const { RawSource } = __webpack_require__(51255);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Module = __webpack_require__(73208);
 const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const HelperRuntimeModule = __webpack_require__(82444);
+const makeSerializable = __webpack_require__(33032);
+const { rangeToString, stringifyHoley } = __webpack_require__(19702);
+const ConsumeSharedFallbackDependency = __webpack_require__(58831);
 
-class RelativeUrlRuntimeModule extends HelperRuntimeModule {
-	constructor() {
-		super("relative url");
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+
+/**
+ * @typedef {Object} ConsumeOptions
+ * @property {string=} import fallback request
+ * @property {string=} importResolved resolved fallback request
+ * @property {string} shareKey global share key
+ * @property {string} shareScope share scope
+ * @property {SemVerRange | false | undefined} requiredVersion version requirement
+ * @property {string} packageName package name to determine required version automatically
+ * @property {boolean} strictVersion don't use shared version even if version isn't valid
+ * @property {boolean} singleton use single global version
+ * @property {boolean} eager include the fallback module in a sync way
+ */
+
+const TYPES = new Set(["consume-shared"]);
+
+class ConsumeSharedModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {ConsumeOptions} options consume options
+	 */
+	constructor(context, options) {
+		super("consume-shared-module", context);
+		this.options = options;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string} a unique identifier of the module
 	 */
-	generate() {
-		const { runtimeTemplate } = this.compilation;
-		return Template.asString([
-			`${RuntimeGlobals.relativeUrl} = function RelativeURL(url) {`,
-			Template.indent([
-				'var realUrl = new URL(url, "x:/");',
-				"var values = {};",
-				"for (var key in realUrl) values[key] = realUrl[key];",
-				"values.href = url;",
-				'values.pathname = url.replace(/[?#].*/, "");',
-				'values.origin = values.protocol = "";',
-				`values.toString = values.toJSON = ${runtimeTemplate.returningFunction(
-					"url"
-				)};`,
-				"for (var key in values) Object.defineProperty(this, key, { enumerable: true, configurable: true, value: values[key] });"
-			]),
-			"};",
-			`${RuntimeGlobals.relativeUrl}.prototype = URL.prototype;`
-		]);
+	identifier() {
+		const {
+			shareKey,
+			shareScope,
+			importResolved,
+			requiredVersion,
+			strictVersion,
+			singleton,
+			eager
+		} = this.options;
+		return `consume-shared-module|${shareScope}|${shareKey}|${
+			requiredVersion && rangeToString(requiredVersion)
+		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
 	}
-}
-
-module.exports = RelativeUrlRuntimeModule;
-
-
-/***/ }),
-
-/***/ 97115:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
 
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-class RuntimeIdRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("runtimeId");
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		const {
+			shareKey,
+			shareScope,
+			importResolved,
+			requiredVersion,
+			strictVersion,
+			singleton,
+			eager
+		} = this.options;
+		return `consume shared module (${shareScope}) ${shareKey}@${
+			requiredVersion ? rangeToString(requiredVersion) : "*"
+		}${strictVersion ? " (strict)" : ""}${singleton ? " (singleton)" : ""}${
+			importResolved
+				? ` (fallback: ${requestShortener.shorten(importResolved)})`
+				: ""
+		}${eager ? " (eager)" : ""}`;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
 	 */
-	generate() {
-		const { chunkGraph, chunk } = this;
-		const runtime = chunk.runtime;
-		if (typeof runtime !== "string")
-			throw new Error("RuntimeIdRuntimeModule must be in a single runtime");
-		const id = chunkGraph.getRuntimeId(runtime);
-		return `${RuntimeGlobals.runtimeId} = ${JSON.stringify(id)};`;
+	libIdent(options) {
+		const { shareKey, shareScope, import: request } = this.options;
+		return `${
+			this.layer ? `(${this.layer})/` : ""
+		}webpack/sharing/consume/${shareScope}/${shareKey}${
+			request ? `/${request}` : ""
+		}`;
 	}
-}
-
-module.exports = RuntimeIdRuntimeModule;
-
-
-/***/ }),
-
-/***/ 22339:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const StartupChunkDependenciesRuntimeModule = __webpack_require__(38157);
-const StartupEntrypointRuntimeModule = __webpack_require__(97672);
-
-/** @typedef {import("../Compiler")} Compiler */
 
-class StartupChunkDependenciesPlugin {
-	constructor(options) {
-		this.chunkLoading = options.chunkLoading;
-		this.asyncChunkLoading =
-			typeof options.asyncChunkLoading === "boolean"
-				? options.asyncChunkLoading
-				: true;
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"StartupChunkDependenciesPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === this.chunkLoading;
-				};
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"StartupChunkDependenciesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
-							set.add(RuntimeGlobals.startup);
-							set.add(RuntimeGlobals.ensureChunk);
-							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-							compilation.addRuntimeModule(
-								chunk,
-								new StartupChunkDependenciesRuntimeModule(
-									this.asyncChunkLoading
-								)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.startupEntrypoint)
-					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.require);
-						set.add(RuntimeGlobals.ensureChunk);
-						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-						compilation.addRuntimeModule(
-							chunk,
-							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
-						);
-					});
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {};
+		if (this.options.import) {
+			const dep = new ConsumeSharedFallbackDependency(this.options.import);
+			if (this.options.eager) {
+				this.addDependency(dep);
+			} else {
+				const block = new AsyncDependenciesBlock({});
+				block.addDependency(dep);
+				this.addBlock(block);
 			}
-		);
+		}
+		callback();
 	}
-}
-
-module.exports = StartupChunkDependenciesPlugin;
-
-
-/***/ }),
-
-/***/ 38157:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
 
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-
-class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
-	constructor(asyncChunkLoading) {
-		super("startup chunk dependencies", RuntimeModule.STAGE_TRIGGER);
-		this.asyncChunkLoading = asyncChunkLoading;
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
-	generate() {
-		const { chunkGraph, chunk, compilation } = this;
-		const { runtimeTemplate } = compilation;
-		const chunkIds = Array.from(
-			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-		).map(chunk => {
-			return chunk.id;
-		});
-		return Template.asString([
-			`var next = ${RuntimeGlobals.startup};`,
-			`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
-				"",
-				!this.asyncChunkLoading
-					? chunkIds
-							.map(
-								id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)});`
-							)
-							.concat("return next();")
-					: chunkIds.length === 1
-					? `return ${RuntimeGlobals.ensureChunk}(${JSON.stringify(
-							chunkIds[0]
-					  )}).then(next);`
-					: chunkIds.length > 2
-					? [
-							// using map is shorter for 3 or more chunks
-							`return Promise.all(${JSON.stringify(chunkIds)}.map(${
-								RuntimeGlobals.ensureChunk
-							}, __webpack_require__)).then(next);`
-					  ]
-					: [
-							// calling ensureChunk directly is shorter for 0 - 2 chunks
-							"return Promise.all([",
-							Template.indent(
-								chunkIds
-									.map(
-										id => `${RuntimeGlobals.ensureChunk}(${JSON.stringify(id)})`
-									)
-									.join(",\n")
-							),
-							"]).then(next);"
-					  ]
-			)};`
-		]);
+	size(type) {
+		return 42;
 	}
-}
-
-module.exports = StartupChunkDependenciesRuntimeModule;
-
-
-/***/ }),
-
-/***/ 97672:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-/** @typedef {import("../MainTemplate")} MainTemplate */
 
-class StartupEntrypointRuntimeModule extends RuntimeModule {
-	constructor(asyncChunkLoading) {
-		super("startup entrypoint");
-		this.asyncChunkLoading = asyncChunkLoading;
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		hash.update(JSON.stringify(this.options));
+		super.updateHash(hash, context);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
 	 */
-	generate() {
-		const { compilation } = this;
-		const { runtimeTemplate } = compilation;
-		return `${
-			RuntimeGlobals.startupEntrypoint
-		} = ${runtimeTemplate.basicFunction("result, chunkIds, fn", [
-			"// arguments: chunkIds, moduleId are deprecated",
-			"var moduleId = chunkIds;",
-			`if(!fn) chunkIds = result, fn = ${runtimeTemplate.returningFunction(
-				`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`
-			)};`,
-			...(this.asyncChunkLoading
-				? [
-						`return Promise.all(chunkIds.map(${
-							RuntimeGlobals.ensureChunk
-						}, __webpack_require__)).then(${runtimeTemplate.basicFunction("", [
-							"var r = fn();",
-							"return r === undefined ? result : r;"
-						])})`
-				  ]
-				: [
-						`chunkIds.map(${RuntimeGlobals.ensureChunk}, __webpack_require__)`,
-						"var r = fn();",
-						"return r === undefined ? result : r;"
-				  ])
-		])}`;
+	codeGeneration({ chunkGraph, moduleGraph, runtimeTemplate }) {
+		const runtimeRequirements = new Set([RuntimeGlobals.shareScopeMap]);
+		const {
+			shareScope,
+			shareKey,
+			strictVersion,
+			requiredVersion,
+			import: request,
+			singleton,
+			eager
+		} = this.options;
+		let fallbackCode;
+		if (request) {
+			if (eager) {
+				const dep = this.dependencies[0];
+				fallbackCode = runtimeTemplate.syncModuleFactory({
+					dependency: dep,
+					chunkGraph,
+					runtimeRequirements,
+					request: this.options.import
+				});
+			} else {
+				const block = this.blocks[0];
+				fallbackCode = runtimeTemplate.asyncModuleFactory({
+					block,
+					chunkGraph,
+					runtimeRequirements,
+					request: this.options.import
+				});
+			}
+		}
+		let fn = "load";
+		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
+		if (requiredVersion) {
+			if (strictVersion) {
+				fn += "Strict";
+			}
+			if (singleton) {
+				fn += "Singleton";
+			}
+			args.push(stringifyHoley(requiredVersion));
+			fn += "VersionCheck";
+		} else {
+			if (singleton) {
+				fn += "Singleton";
+			}
+		}
+		if (fallbackCode) {
+			fn += "Fallback";
+			args.push(fallbackCode);
+		}
+		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
+		const sources = new Map();
+		sources.set("consume-shared", new RawSource(code));
+		return {
+			runtimeRequirements,
+			sources
+		};
 	}
-}
-
-module.exports = StartupEntrypointRuntimeModule;
-
-
-/***/ }),
-
-/***/ 80655:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-
-/** @typedef {import("../Compilation")} Compilation */
 
-class SystemContextRuntimeModule extends RuntimeModule {
-	constructor() {
-		super("__system_context__");
+	serialize(context) {
+		const { write } = context;
+		write(this.options);
+		super.serialize(context);
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		return `${RuntimeGlobals.systemContext} = __system_context__;`;
+	deserialize(context) {
+		const { read } = context;
+		this.options = read();
+		super.deserialize(context);
 	}
 }
 
-module.exports = SystemContextRuntimeModule;
+makeSerializable(
+	ConsumeSharedModule,
+	"webpack/lib/sharing/ConsumeSharedModule"
+);
+
+module.exports = ConsumeSharedModule;
 
 
 /***/ }),
 
-/***/ 64820:
+/***/ 15046:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -117524,117 +114722,323 @@ module.exports = SystemContextRuntimeModule;
 
 
 
-const NormalModule = __webpack_require__(39);
+const ModuleNotFoundError = __webpack_require__(32882);
+const RuntimeGlobals = __webpack_require__(16475);
+const WebpackError = __webpack_require__(53799);
+const { parseOptions } = __webpack_require__(3083);
+const LazySet = __webpack_require__(38938);
+const createSchemaValidation = __webpack_require__(32540);
+const { parseRange } = __webpack_require__(19702);
+const ConsumeSharedFallbackDependency = __webpack_require__(58831);
+const ConsumeSharedModule = __webpack_require__(62286);
+const ConsumeSharedRuntimeModule = __webpack_require__(10394);
+const ProvideForSharedDependency = __webpack_require__(40017);
+const { resolveMatchedConfigs } = __webpack_require__(3591);
+const {
+	isRequiredVersion,
+	getDescriptionFile,
+	getRequiredVersionFromDescriptionFile
+} = __webpack_require__(84379);
 
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
+/** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
 
-// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
-// http://www.ietf.org/rfc/rfc2397.txt
-const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
-
-const decodeDataURI = uri => {
-	const match = URIRegEx.exec(uri);
-	if (!match) return null;
+const validate = createSchemaValidation(
+	__webpack_require__(6464),
+	() => __webpack_require__(16116),
+	{
+		name: "Consume Shared Plugin",
+		baseDataPath: "options"
+	}
+);
 
-	const isBase64 = match[3];
-	const body = match[4];
-	return isBase64
-		? Buffer.from(body, "base64")
-		: Buffer.from(decodeURIComponent(body), "ascii");
-};
+/** @type {ResolveOptionsWithDependencyType} */
+const RESOLVE_OPTIONS = { dependencyType: "esm" };
+const PLUGIN_NAME = "ConsumeSharedPlugin";
 
-class DataUriPlugin {
+class ConsumeSharedPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {ConsumeSharedPluginOptions} options options
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"DataUriPlugin",
-			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.resolveForScheme
-					.for("data")
-					.tap("DataUriPlugin", resourceData => {
-						const match = URIRegEx.exec(resourceData.resource);
-						if (match) {
-							resourceData.data.mimetype = match[1] || "";
-							resourceData.data.parameters = match[2] || "";
-							resourceData.data.encoding = match[3] || false;
-							resourceData.data.encodedContent = match[4] || "";
-						}
-					});
-				NormalModule.getCompilationHooks(compilation)
-					.readResourceForScheme.for("data")
-					.tap("DataUriPlugin", resource => decodeDataURI(resource));
-			}
-		);
-	}
-}
-
-module.exports = DataUriPlugin;
-
-
-/***/ }),
-
-/***/ 57637:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	constructor(options) {
+		if (typeof options !== "string") {
+			validate(options);
+		}
 
+		/** @type {[string, ConsumeOptions][]} */
+		this._consumes = parseOptions(
+			options.consumes,
+			(item, key) => {
+				if (Array.isArray(item)) throw new Error("Unexpected array in options");
+				/** @type {ConsumeOptions} */
+				let result =
+					item === key || !isRequiredVersion(item)
+						? // item is a request/key
+						  {
+								import: key,
+								shareScope: options.shareScope || "default",
+								shareKey: key,
+								requiredVersion: undefined,
+								packageName: undefined,
+								strictVersion: false,
+								singleton: false,
+								eager: false
+						  }
+						: // key is a request/key
+						  // item is a version
+						  {
+								import: key,
+								shareScope: options.shareScope || "default",
+								shareKey: key,
+								requiredVersion: parseRange(item),
+								strictVersion: true,
+								packageName: undefined,
+								singleton: false,
+								eager: false
+						  };
+				return result;
+			},
+			(item, key) => ({
+				import: item.import === false ? undefined : item.import || key,
+				shareScope: item.shareScope || options.shareScope || "default",
+				shareKey: item.shareKey || key,
+				requiredVersion:
+					typeof item.requiredVersion === "string"
+						? parseRange(item.requiredVersion)
+						: item.requiredVersion,
+				strictVersion:
+					typeof item.strictVersion === "boolean"
+						? item.strictVersion
+						: item.import !== false && !item.singleton,
+				packageName: item.packageName,
+				singleton: !!item.singleton,
+				eager: !!item.eager
+			})
+		);
+	}
 
-
-const { URL, fileURLToPath } = __webpack_require__(57310);
-const { NormalModule } = __webpack_require__(91919);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-class FileUriPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"FileUriPlugin",
+		compiler.hooks.thisCompilation.tap(
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
-				normalModuleFactory.hooks.resolveForScheme
-					.for("file")
-					.tap("FileUriPlugin", resourceData => {
-						const url = new URL(resourceData.resource);
-						const path = fileURLToPath(url);
-						const query = url.search;
-						const fragment = url.hash;
-						resourceData.path = path;
-						resourceData.query = query;
-						resourceData.fragment = fragment;
-						resourceData.resource = path + query + fragment;
-						return true;
-					});
-				const hooks = NormalModule.getCompilationHooks(compilation);
-				hooks.readResource
-					.for(undefined)
-					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
-						const { resourcePath } = loaderContext;
-						loaderContext.addDependency(resourcePath);
-						loaderContext.fs.readFile(resourcePath, callback);
+				compilation.dependencyFactories.set(
+					ConsumeSharedFallbackDependency,
+					normalModuleFactory
+				);
+
+				let unresolvedConsumes, resolvedConsumes, prefixedConsumes;
+				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
+					({ resolved, unresolved, prefixed }) => {
+						resolvedConsumes = resolved;
+						unresolvedConsumes = unresolved;
+						prefixedConsumes = prefixed;
+					}
+				);
+
+				const resolver = compilation.resolverFactory.get(
+					"normal",
+					RESOLVE_OPTIONS
+				);
+
+				/**
+				 * @param {string} context issuer directory
+				 * @param {string} request request
+				 * @param {ConsumeOptions} config options
+				 * @returns {Promise<ConsumeSharedModule>} create module
+				 */
+				const createConsumeSharedModule = (context, request, config) => {
+					const requiredVersionWarning = details => {
+						const error = new WebpackError(
+							`No required version specified and unable to automatically determine one. ${details}`
+						);
+						error.file = `shared module ${request}`;
+						compilation.warnings.push(error);
+					};
+					const directFallback =
+						config.import &&
+						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
+					return Promise.all([
+						new Promise(resolve => {
+							if (!config.import) return resolve();
+							const resolveContext = {
+								/** @type {LazySet<string>} */
+								fileDependencies: new LazySet(),
+								/** @type {LazySet<string>} */
+								contextDependencies: new LazySet(),
+								/** @type {LazySet<string>} */
+								missingDependencies: new LazySet()
+							};
+							resolver.resolve(
+								{},
+								directFallback ? compiler.context : context,
+								config.import,
+								resolveContext,
+								(err, result) => {
+									compilation.contextDependencies.addAll(
+										resolveContext.contextDependencies
+									);
+									compilation.fileDependencies.addAll(
+										resolveContext.fileDependencies
+									);
+									compilation.missingDependencies.addAll(
+										resolveContext.missingDependencies
+									);
+									if (err) {
+										compilation.errors.push(
+											new ModuleNotFoundError(null, err, {
+												name: `resolving fallback for shared module ${request}`
+											})
+										);
+										return resolve();
+									}
+									resolve(result);
+								}
+							);
+						}),
+						new Promise(resolve => {
+							if (config.requiredVersion !== undefined)
+								return resolve(config.requiredVersion);
+							let packageName = config.packageName;
+							if (packageName === undefined) {
+								if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
+									// For relative or absolute requests we don't automatically use a packageName.
+									// If wished one can specify one with the packageName option.
+									return resolve();
+								}
+								const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
+								if (!match) {
+									requiredVersionWarning(
+										"Unable to extract the package name from request."
+									);
+									return resolve();
+								}
+								packageName = match[0];
+							}
+
+							getDescriptionFile(
+								compilation.inputFileSystem,
+								context,
+								["package.json"],
+								(err, result) => {
+									if (err) {
+										requiredVersionWarning(
+											`Unable to read description file: ${err}`
+										);
+										return resolve();
+									}
+									const { data, path: descriptionPath } = result;
+									if (!data) {
+										requiredVersionWarning(
+											`Unable to find description file in ${context}.`
+										);
+										return resolve();
+									}
+									const requiredVersion = getRequiredVersionFromDescriptionFile(
+										data,
+										packageName
+									);
+									if (typeof requiredVersion !== "string") {
+										requiredVersionWarning(
+											`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
+										);
+										return resolve();
+									}
+									resolve(parseRange(requiredVersion));
+								}
+							);
+						})
+					]).then(([importResolved, requiredVersion]) => {
+						return new ConsumeSharedModule(
+							directFallback ? compiler.context : context,
+							{
+								...config,
+								importResolved,
+								import: importResolved ? config.import : undefined,
+								requiredVersion
+							}
+						);
 					});
+				};
+
+				normalModuleFactory.hooks.factorize.tapPromise(
+					PLUGIN_NAME,
+					({ context, request, dependencies }) =>
+						// wait for resolving to be complete
+						promise.then(() => {
+							if (
+								dependencies[0] instanceof ConsumeSharedFallbackDependency ||
+								dependencies[0] instanceof ProvideForSharedDependency
+							) {
+								return;
+							}
+							const match = unresolvedConsumes.get(request);
+							if (match !== undefined) {
+								return createConsumeSharedModule(context, request, match);
+							}
+							for (const [prefix, options] of prefixedConsumes) {
+								if (request.startsWith(prefix)) {
+									const remainder = request.slice(prefix.length);
+									return createConsumeSharedModule(context, request, {
+										...options,
+										import: options.import
+											? options.import + remainder
+											: undefined,
+										shareKey: options.shareKey + remainder
+									});
+								}
+							}
+						})
+				);
+				normalModuleFactory.hooks.createModule.tapPromise(
+					PLUGIN_NAME,
+					({ resource }, { context, dependencies }) => {
+						if (
+							dependencies[0] instanceof ConsumeSharedFallbackDependency ||
+							dependencies[0] instanceof ProvideForSharedDependency
+						) {
+							return Promise.resolve();
+						}
+						const options = resolvedConsumes.get(resource);
+						if (options !== undefined) {
+							return createConsumeSharedModule(context, resource, options);
+						}
+						return Promise.resolve();
+					}
+				);
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					PLUGIN_NAME,
+					(chunk, set) => {
+						set.add(RuntimeGlobals.module);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+						set.add(RuntimeGlobals.shareScopeMap);
+						set.add(RuntimeGlobals.initializeSharing);
+						set.add(RuntimeGlobals.hasOwnProperty);
+						compilation.addRuntimeModule(
+							chunk,
+							new ConsumeSharedRuntimeModule(set)
+						);
+					}
+				);
 			}
 		);
 	}
 }
 
-module.exports = FileUriPlugin;
+module.exports = ConsumeSharedPlugin;
 
 
 /***/ }),
 
-/***/ 42110:
+/***/ 10394:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -117645,4007 +115049,6981 @@ module.exports = FileUriPlugin;
 
 
 
-const { extname, basename } = __webpack_require__(71017);
-const { URL } = __webpack_require__(57310);
-const { createGunzip, createBrotliDecompress, createInflate } = __webpack_require__(59796);
-const NormalModule = __webpack_require__(39);
-const createSchemaValidation = __webpack_require__(32540);
-const createHash = __webpack_require__(49835);
-const { mkdirp, dirname, join } = __webpack_require__(17139);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-
-const getHttp = memoize(() => __webpack_require__(13685));
-const getHttps = memoize(() => __webpack_require__(95687));
-
-/** @type {(() => void)[] | undefined} */
-let inProgressWrite = undefined;
-
-const validate = createSchemaValidation(
-	__webpack_require__(67263),
-	() => __webpack_require__(27256),
-	{
-		name: "Http Uri Plugin",
-		baseDataPath: "options"
-	}
-);
-
-const toSafePath = str =>
-	str
-		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
-		.replace(/[^a-zA-Z0-9._-]+/g, "_");
-
-const computeIntegrity = content => {
-	const hash = createHash("sha512");
-	hash.update(content);
-	const integrity = "sha512-" + hash.digest("base64");
-	return integrity;
-};
-
-const verifyIntegrity = (content, integrity) => {
-	if (integrity === "ignore") return true;
-	return computeIntegrity(content) === integrity;
-};
-
-/**
- * @param {string} str input
- * @returns {Record<string, string>} parsed
- */
-const parseKeyValuePairs = str => {
-	/** @type {Record<string, string>} */
-	const result = {};
-	for (const item of str.split(",")) {
-		const i = item.indexOf("=");
-		if (i >= 0) {
-			const key = item.slice(0, i).trim();
-			const value = item.slice(i + 1).trim();
-			result[key] = value;
-		} else {
-			const key = item.trim();
-			if (!key) continue;
-			result[key] = key;
-		}
-	}
-	return result;
-};
-
-const parseCacheControl = (cacheControl, requestTime) => {
-	// When false resource is not stored in cache
-	let storeCache = true;
-	// When false resource is not stored in lockfile cache
-	let storeLock = true;
-	// Resource is only revalidated, after that timestamp and when upgrade is chosen
-	let validUntil = 0;
-	if (cacheControl) {
-		const parsed = parseKeyValuePairs(cacheControl);
-		if (parsed["no-cache"]) storeCache = storeLock = false;
-		if (parsed["max-age"] && !isNaN(+parsed["max-age"])) {
-			validUntil = requestTime + +parsed["max-age"] * 1000;
-		}
-		if (parsed["must-revalidate"]) validUntil = 0;
-	}
-	return {
-		storeLock,
-		storeCache,
-		validUntil
-	};
-};
-
-/**
- * @typedef {Object} LockfileEntry
- * @property {string} resolved
- * @property {string} integrity
- * @property {string} contentType
- */
-
-const areLockfileEntriesEqual = (a, b) => {
-	return (
-		a.resolved === b.resolved &&
-		a.integrity === b.integrity &&
-		a.contentType === b.contentType
-	);
-};
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const {
+	parseVersionRuntimeCode,
+	versionLtRuntimeCode,
+	rangeToStringRuntimeCode,
+	satisfyRuntimeCode
+} = __webpack_require__(19702);
 
-const entryToString = entry => {
-	return `resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
-};
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
 
-class Lockfile {
-	constructor() {
-		this.version = 1;
-		/** @type {Map<string, LockfileEntry | "ignore" | "no-cache">} */
-		this.entries = new Map();
+class ConsumeSharedRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements) {
+		super("consumes", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
 	}
 
-	static parse(content) {
-		// TODO handle merge conflicts
-		const data = JSON.parse(content);
-		if (data.version !== 1)
-			throw new Error(`Unsupported lockfile version ${data.version}`);
-		const lockfile = new Lockfile();
-		for (const key of Object.keys(data)) {
-			if (key === "version") continue;
-			const entry = data[key];
-			lockfile.entries.set(
-				key,
-				typeof entry === "string"
-					? entry
-					: {
-							resolved: key,
-							...entry
-					  }
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunkGraph } = this;
+		const { runtimeTemplate, codeGenerationResults } = compilation;
+		const chunkToModuleMapping = {};
+		/** @type {Map<string | number, Source>} */
+		const moduleIdToSourceMapping = new Map();
+		const initialConsumes = [];
+		/**
+		 *
+		 * @param {Iterable<Module>} modules modules
+		 * @param {Chunk} chunk the chunk
+		 * @param {(string | number)[]} list list of ids
+		 */
+		const addModules = (modules, chunk, list) => {
+			for (const m of modules) {
+				const module = /** @type {ConsumeSharedModule} */ (m);
+				const id = chunkGraph.getModuleId(module);
+				list.push(id);
+				moduleIdToSourceMapping.set(
+					id,
+					codeGenerationResults.getSource(
+						module,
+						chunk.runtime,
+						"consume-shared"
+					)
+				);
+			}
+		};
+		for (const chunk of this.chunk.getAllAsyncChunks()) {
+			const modules = chunkGraph.getChunkModulesIterableBySourceType(
+				chunk,
+				"consume-shared"
 			);
+			if (!modules) continue;
+			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
 		}
-		return lockfile;
-	}
-
-	toString() {
-		let str = "{\n";
-		const entries = Array.from(this.entries).sort(([a], [b]) =>
-			a < b ? -1 : 1
-		);
-		for (const [key, entry] of entries) {
-			if (typeof entry === "string") {
-				str += `  ${JSON.stringify(key)}: ${JSON.stringify(entry)},\n`;
-			} else {
-				str += `  ${JSON.stringify(key)}: { `;
-				if (entry.resolved !== key)
-					str += `"resolved": ${JSON.stringify(entry.resolved)}, `;
-				str += `"integrity": ${JSON.stringify(
-					entry.integrity
-				)}, "contentType": ${JSON.stringify(entry.contentType)} },\n`;
-			}
+		for (const chunk of this.chunk.getAllInitialChunks()) {
+			const modules = chunkGraph.getChunkModulesIterableBySourceType(
+				chunk,
+				"consume-shared"
+			);
+			if (!modules) continue;
+			addModules(modules, chunk, initialConsumes);
 		}
-		str += `  "version": ${this.version}\n}\n`;
-		return str;
-	}
-}
-
-/**
- * @template R
- * @param {function(function(Error=, R=): void): void} fn function
- * @returns {function(function((Error | null)=, R=): void): void} cached function
- */
-const cachedWithoutKey = fn => {
-	let inFlight = false;
-	/** @type {Error | undefined} */
-	let cachedError = undefined;
-	/** @type {R | undefined} */
-	let cachedResult = undefined;
-	/** @type {(function(Error=, R=): void)[] | undefined} */
-	let cachedCallbacks = undefined;
-	return callback => {
-		if (inFlight) {
-			if (cachedResult !== undefined) return callback(null, cachedResult);
-			if (cachedError !== undefined) return callback(cachedError);
-			if (cachedCallbacks === undefined) cachedCallbacks = [callback];
-			else cachedCallbacks.push(callback);
-			return;
-		}
-		inFlight = true;
-		fn((err, result) => {
-			if (err) cachedError = err;
-			else cachedResult = result;
-			const callbacks = cachedCallbacks;
-			cachedCallbacks = undefined;
-			callback(err, result);
-			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
-		});
-	};
-};
+		if (moduleIdToSourceMapping.size === 0) return null;
+		return Template.asString([
+			parseVersionRuntimeCode(runtimeTemplate),
+			versionLtRuntimeCode(runtimeTemplate),
+			rangeToStringRuntimeCode(runtimeTemplate),
+			satisfyRuntimeCode(runtimeTemplate),
+			`var ensureExistence = ${runtimeTemplate.basicFunction("scopeName, key", [
+				`var scope = ${RuntimeGlobals.shareScopeMap}[scopeName];`,
+				`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) throw new Error("Shared module " + key + " doesn't exist in shared scope " + scopeName);`,
+				"return scope;"
+			])};`,
+			`var findVersion = ${runtimeTemplate.basicFunction("scope, key", [
+				"var versions = scope[key];",
+				`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+					"a, b",
+					["return !a || versionLt(a, b) ? b : a;"]
+				)}, 0);`,
+				"return key && versions[key]"
+			])};`,
+			`var findSingletonVersionKey = ${runtimeTemplate.basicFunction(
+				"scope, key",
+				[
+					"var versions = scope[key];",
+					`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+						"a, b",
+						["return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;"]
+					)}, 0);`
+				]
+			)};`,
+			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
+				"scope, key, version, requiredVersion",
+				[
+					`return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
+				]
+			)};`,
+			`var getSingleton = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"return get(scope[key][version]);"
+				]
+			)};`,
+			`var getSingletonVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"if (!satisfy(requiredVersion, version)) " +
+						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));',
+					"return get(scope[key][version]);"
+				]
+			)};`,
+			`var getStrictSingletonVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var version = findSingletonVersionKey(scope, key);",
+					"if (!satisfy(requiredVersion, version)) " +
+						"throw new Error(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));",
+					"return get(scope[key][version]);"
+				]
+			)};`,
+			`var findValidVersion = ${runtimeTemplate.basicFunction(
+				"scope, key, requiredVersion",
+				[
+					"var versions = scope[key];",
+					`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+						"a, b",
+						[
+							"if (!satisfy(requiredVersion, b)) return a;",
+							"return !a || versionLt(a, b) ? b : a;"
+						]
+					)}, 0);`,
+					"return key && versions[key]"
+				]
+			)};`,
+			`var getInvalidVersionMessage = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var versions = scope[key];",
+					'return "No satisfying version (" + rangeToString(requiredVersion) + ") of shared module " + key + " found in shared scope " + scopeName + ".\\n" +',
+					`\t"Available versions: " + Object.keys(versions).map(${runtimeTemplate.basicFunction(
+						"key",
+						['return key + " from " + versions[key].from;']
+					)}).join(", ");`
+				]
+			)};`,
+			`var getValidVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					"var entry = findValidVersion(scope, key, requiredVersion);",
+					"if(entry) return get(entry);",
+					"throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
+				]
+			)};`,
+			`var warnInvalidVersion = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion",
+				[
+					'typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));'
+				]
+			)};`,
+			`var get = ${runtimeTemplate.basicFunction("entry", [
+				"entry.loaded = 1;",
+				"return entry.get()"
+			])};`,
+			`var init = ${runtimeTemplate.returningFunction(
+				Template.asString([
+					"function(scopeName, a, b, c) {",
+					Template.indent([
+						`var promise = ${RuntimeGlobals.initializeSharing}(scopeName);`,
+						`if (promise && promise.then) return promise.then(fn.bind(fn, scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c));`,
+						`return fn(scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c);`
+					]),
+					"}"
+				]),
+				"fn"
+			)};`,
+			"",
+			`var load = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key",
+				[
+					"ensureExistence(scopeName, key);",
+					"return get(findVersion(scope, key));"
+				]
+			)});`,
+			`var loadFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, fallback",
+				[
+					`return scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) ? get(findVersion(scope, key)) : fallback();`
+				]
+			)});`,
+			`var loadVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
+				]
+			)});`,
+			`var loadSingleton = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getSingleton(scope, scopeName, key);"
+				]
+			)});`,
+			`var loadSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadStrictVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getValidVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadStrictSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version",
+				[
+					"ensureExistence(scopeName, key);",
+					"return getStrictSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
+				]
+			)});`,
+			`var loadSingletonFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getSingleton(scope, scopeName, key);"
+				]
+			)});`,
+			`var loadSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			`var loadStrictVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`var entry = scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) && findValidVersion(scope, key, version);`,
+					`return entry ? get(entry) : fallback();`
+				]
+			)});`,
+			`var loadStrictSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, version, fallback",
+				[
+					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
+					"return getStrictSingletonVersion(scope, scopeName, key, version);"
+				]
+			)});`,
+			"var installedModules = {};",
+			"var moduleToHandlerMapping = {",
+			Template.indent(
+				Array.from(
+					moduleIdToSourceMapping,
+					([key, source]) => `${JSON.stringify(key)}: ${source.source()}`
+				).join(",\n")
+			),
+			"};",
 
-/**
- * @template T
- * @template R
- * @param {function(T, function(Error=, R=): void): void} fn function
- * @param {function(T, function(Error=, R=): void): void=} forceFn function for the second try
- * @returns {(function(T, function((Error | null)=, R=): void): void) & { force: function(T, function((Error | null)=, R=): void): void }} cached function
- */
-const cachedWithKey = (fn, forceFn = fn) => {
-	/** @typedef {{ result?: R, error?: Error, callbacks?: (function((Error | null)=, R=): void)[], force?: true }} CacheEntry */
-	/** @type {Map<T, CacheEntry>} */
-	const cache = new Map();
-	const resultFn = (arg, callback) => {
-		const cacheEntry = cache.get(arg);
-		if (cacheEntry !== undefined) {
-			if (cacheEntry.result !== undefined)
-				return callback(null, cacheEntry.result);
-			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
-			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
-			else cacheEntry.callbacks.push(callback);
-			return;
-		}
-		/** @type {CacheEntry} */
-		const newCacheEntry = {
-			result: undefined,
-			error: undefined,
-			callbacks: undefined
-		};
-		cache.set(arg, newCacheEntry);
-		fn(arg, (err, result) => {
-			if (err) newCacheEntry.error = err;
-			else newCacheEntry.result = result;
-			const callbacks = newCacheEntry.callbacks;
-			newCacheEntry.callbacks = undefined;
-			callback(err, result);
-			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
-		});
-	};
-	resultFn.force = (arg, callback) => {
-		const cacheEntry = cache.get(arg);
-		if (cacheEntry !== undefined && cacheEntry.force) {
-			if (cacheEntry.result !== undefined)
-				return callback(null, cacheEntry.result);
-			if (cacheEntry.error !== undefined) return callback(cacheEntry.error);
-			if (cacheEntry.callbacks === undefined) cacheEntry.callbacks = [callback];
-			else cacheEntry.callbacks.push(callback);
-			return;
-		}
-		/** @type {CacheEntry} */
-		const newCacheEntry = {
-			result: undefined,
-			error: undefined,
-			callbacks: undefined,
-			force: true
-		};
-		cache.set(arg, newCacheEntry);
-		forceFn(arg, (err, result) => {
-			if (err) newCacheEntry.error = err;
-			else newCacheEntry.result = result;
-			const callbacks = newCacheEntry.callbacks;
-			newCacheEntry.callbacks = undefined;
-			callback(err, result);
-			if (callbacks !== undefined) for (const cb of callbacks) cb(err, result);
-		});
-	};
-	return resultFn;
-};
+			initialConsumes.length > 0
+				? Template.asString([
+						`var initialConsumes = ${JSON.stringify(initialConsumes)};`,
+						`initialConsumes.forEach(${runtimeTemplate.basicFunction("id", [
+							`${
+								RuntimeGlobals.moduleFactories
+							}[id] = ${runtimeTemplate.basicFunction("module", [
+								"// Handle case when module is used sync",
+								"installedModules[id] = 0;",
+								`delete ${RuntimeGlobals.moduleCache}[id];`,
+								"var factory = moduleToHandlerMapping[id]();",
+								'if(typeof factory !== "function") throw new Error("Shared module is not available for eager consumption: " + id);',
+								`module.exports = factory();`
+							])}`
+						])});`
+				  ])
+				: "// no consumes in initial chunks",
+			this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+				? Template.asString([
+						`var chunkMapping = ${JSON.stringify(
+							chunkToModuleMapping,
+							null,
+							"\t"
+						)};`,
+						`${
+							RuntimeGlobals.ensureChunkHandlers
+						}.consumes = ${runtimeTemplate.basicFunction("chunkId, promises", [
+							`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
+							Template.indent([
+								`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction(
+									"id",
+									[
+										`if(${RuntimeGlobals.hasOwnProperty}(installedModules, id)) return promises.push(installedModules[id]);`,
+										`var onFactory = ${runtimeTemplate.basicFunction(
+											"factory",
+											[
+												"installedModules[id] = 0;",
+												`${
+													RuntimeGlobals.moduleFactories
+												}[id] = ${runtimeTemplate.basicFunction("module", [
+													`delete ${RuntimeGlobals.moduleCache}[id];`,
+													"module.exports = factory();"
+												])}`
+											]
+										)};`,
+										`var onError = ${runtimeTemplate.basicFunction("error", [
+											"delete installedModules[id];",
+											`${
+												RuntimeGlobals.moduleFactories
+											}[id] = ${runtimeTemplate.basicFunction("module", [
+												`delete ${RuntimeGlobals.moduleCache}[id];`,
+												"throw error;"
+											])}`
+										])};`,
+										"try {",
+										Template.indent([
+											"var promise = moduleToHandlerMapping[id]();",
+											"if(promise.then) {",
+											Template.indent(
+												"promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));"
+											),
+											"} else onFactory(promise);"
+										]),
+										"} catch(e) { onError(e); }"
+									]
+								)});`
+							]),
+							"}"
+						])}`
+				  ])
+				: "// no chunk loading of consumes"
+		]);
+	}
+}
 
-class HttpUriPlugin {
+module.exports = ConsumeSharedRuntimeModule;
+
+
+/***/ }),
+
+/***/ 40017:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const ModuleDependency = __webpack_require__(80321);
+const makeSerializable = __webpack_require__(33032);
+
+class ProvideForSharedDependency extends ModuleDependency {
 	/**
-	 * @param {HttpUriPluginOptions} options options
+	 *
+	 * @param {string} request request string
 	 */
-	constructor(options) {
-		validate(options);
-		this._lockfileLocation = options.lockfileLocation;
-		this._cacheLocation = options.cacheLocation;
-		this._upgrade = options.upgrade;
-		this._frozen = options.frozen;
-		this._allowedUris = options.allowedUris;
+	constructor(request) {
+		super(request);
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const schemes = [
-			{
-				scheme: "http",
-				fetch: (url, options, callback) => getHttp().get(url, options, callback)
-			},
-			{
-				scheme: "https",
-				fetch: (url, options, callback) =>
-					getHttps().get(url, options, callback)
-			}
-		];
-		let lockfileCache;
-		compiler.hooks.compilation.tap(
-			"HttpUriPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const intermediateFs = compiler.intermediateFileSystem;
-				const fs = compilation.inputFileSystem;
-				const cache = compilation.getCache("webpack.HttpUriPlugin");
-				const logger = compilation.getLogger("webpack.HttpUriPlugin");
-				const lockfileLocation =
-					this._lockfileLocation ||
-					join(
-						intermediateFs,
-						compiler.context,
-						compiler.name
-							? `${toSafePath(compiler.name)}.webpack.lock`
-							: "webpack.lock"
-					);
-				const cacheLocation =
-					this._cacheLocation !== undefined
-						? this._cacheLocation
-						: lockfileLocation + ".data";
-				const upgrade = this._upgrade || false;
-				const frozen = this._frozen || false;
-				const hashFunction = "sha512";
-				const hashDigest = "hex";
-				const hashDigestLength = 20;
-				const allowedUris = this._allowedUris;
+	get type() {
+		return "provide module for shared";
+	}
 
-				let warnedAboutEol = false;
+	get category() {
+		return "esm";
+	}
+}
 
-				const cacheKeyCache = new Map();
-				/**
-				 * @param {string} url the url
-				 * @returns {string} the key
-				 */
-				const getCacheKey = url => {
-					const cachedResult = cacheKeyCache.get(url);
-					if (cachedResult !== undefined) return cachedResult;
-					const result = _getCacheKey(url);
-					cacheKeyCache.set(url, result);
-					return result;
-				};
+makeSerializable(
+	ProvideForSharedDependency,
+	"webpack/lib/sharing/ProvideForSharedDependency"
+);
 
-				/**
-				 * @param {string} url the url
-				 * @returns {string} the key
-				 */
-				const _getCacheKey = url => {
-					const parsedUrl = new URL(url);
-					const folder = toSafePath(parsedUrl.origin);
-					const name = toSafePath(parsedUrl.pathname);
-					const query = toSafePath(parsedUrl.search);
-					let ext = extname(name);
-					if (ext.length > 20) ext = "";
-					const basename = ext ? name.slice(0, -ext.length) : name;
-					const hash = createHash(hashFunction);
-					hash.update(url);
-					const digest = hash.digest(hashDigest).slice(0, hashDigestLength);
-					return `${folder.slice(-50)}/${`${basename}${
-						query ? `_${query}` : ""
-					}`.slice(0, 150)}_${digest}${ext}`;
-				};
+module.exports = ProvideForSharedDependency;
 
-				const getLockfile = cachedWithoutKey(
-					/**
-					 * @param {function((Error | null)=, Lockfile=): void} callback callback
-					 * @returns {void}
-					 */
-					callback => {
-						const readLockfile = () => {
-							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
-								if (err && err.code !== "ENOENT") {
-									compilation.missingDependencies.add(lockfileLocation);
-									return callback(err);
-								}
-								compilation.fileDependencies.add(lockfileLocation);
-								compilation.fileSystemInfo.createSnapshot(
-									compiler.fsStartTime,
-									buffer ? [lockfileLocation] : [],
-									[],
-									buffer ? [] : [lockfileLocation],
-									{ timestamp: true },
-									(err, snapshot) => {
-										if (err) return callback(err);
-										const lockfile = buffer
-											? Lockfile.parse(buffer.toString("utf-8"))
-											: new Lockfile();
-										lockfileCache = {
-											lockfile,
-											snapshot
-										};
-										callback(null, lockfile);
-									}
-								);
-							});
-						};
-						if (lockfileCache) {
-							compilation.fileSystemInfo.checkSnapshotValid(
-								lockfileCache.snapshot,
-								(err, valid) => {
-									if (err) return callback(err);
-									if (!valid) return readLockfile();
-									callback(null, lockfileCache.lockfile);
-								}
-							);
-						} else {
-							readLockfile();
-						}
-					}
-				);
 
-				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
-				let lockfileUpdates = undefined;
-				const storeLockEntry = (lockfile, url, entry) => {
-					const oldEntry = lockfile.entries.get(url);
-					if (lockfileUpdates === undefined) lockfileUpdates = new Map();
-					lockfileUpdates.set(url, entry);
-					lockfile.entries.set(url, entry);
-					if (!oldEntry) {
-						logger.log(`${url} added to lockfile`);
-					} else if (typeof oldEntry === "string") {
-						if (typeof entry === "string") {
-							logger.log(`${url} updated in lockfile: ${oldEntry} -> ${entry}`);
-						} else {
-							logger.log(
-								`${url} updated in lockfile: ${oldEntry} -> ${entry.resolved}`
-							);
-						}
-					} else if (typeof entry === "string") {
-						logger.log(
-							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry}`
-						);
-					} else if (oldEntry.resolved !== entry.resolved) {
-						logger.log(
-							`${url} updated in lockfile: ${oldEntry.resolved} -> ${entry.resolved}`
-						);
-					} else if (oldEntry.integrity !== entry.integrity) {
-						logger.log(`${url} updated in lockfile: content changed`);
-					} else if (oldEntry.contentType !== entry.contentType) {
-						logger.log(
-							`${url} updated in lockfile: ${oldEntry.contentType} -> ${entry.contentType}`
-						);
-					} else {
-						logger.log(`${url} updated in lockfile`);
-					}
-				};
+/***/ }),
 
-				const storeResult = (lockfile, url, result, callback) => {
-					if (result.storeLock) {
-						storeLockEntry(lockfile, url, result.entry);
-						if (!cacheLocation || !result.content)
-							return callback(null, result);
-						const key = getCacheKey(result.entry.resolved);
-						const filePath = join(intermediateFs, cacheLocation, key);
-						mkdirp(intermediateFs, dirname(intermediateFs, filePath), err => {
-							if (err) return callback(err);
-							intermediateFs.writeFile(filePath, result.content, err => {
-								if (err) return callback(err);
-								callback(null, result);
-							});
-						});
-					} else {
-						storeLockEntry(lockfile, url, "no-cache");
-						callback(null, result);
-					}
-				};
+/***/ 1798:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				for (const { scheme, fetch } of schemes) {
-					/**
-					 *
-					 * @param {string} url URL
-					 * @param {string} integrity integrity
-					 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer, storeLock: boolean }=): void} callback callback
-					 */
-					const resolveContent = (url, integrity, callback) => {
-						const handleResult = (err, result) => {
-							if (err) return callback(err);
-							if ("location" in result) {
-								return resolveContent(
-									result.location,
-									integrity,
-									(err, innerResult) => {
-										if (err) return callback(err);
-										callback(null, {
-											entry: innerResult.entry,
-											content: innerResult.content,
-											storeLock: innerResult.storeLock && result.storeLock
-										});
-									}
-								);
-							} else {
-								if (
-									!result.fresh &&
-									integrity &&
-									result.entry.integrity !== integrity &&
-									!verifyIntegrity(result.content, integrity)
-								) {
-									return fetchContent.force(url, handleResult);
-								}
-								return callback(null, {
-									entry: result.entry,
-									content: result.content,
-									storeLock: result.storeLock
-								});
-							}
-						};
-						fetchContent(url, handleResult);
-					};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-					/** @typedef {{ storeCache: boolean, storeLock: boolean, validUntil: number, etag: string | undefined, fresh: boolean }} FetchResultMeta */
-					/** @typedef {FetchResultMeta & { location: string }} RedirectFetchResult */
-					/** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
-					/** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
 
-					/**
-					 * @param {string} url URL
-					 * @param {FetchResult} cachedResult result from cache
-					 * @param {function((Error | null)=, FetchResult=): void} callback callback
-					 * @returns {void}
-					 */
-					const fetchContentRaw = (url, cachedResult, callback) => {
-						const requestTime = Date.now();
-						fetch(
-							new URL(url),
-							{
-								headers: {
-									"accept-encoding": "gzip, deflate, br",
-									"user-agent": "webpack",
-									"if-none-match": cachedResult
-										? cachedResult.etag || null
-										: null
-								}
-							},
-							res => {
-								const etag = res.headers["etag"];
-								const location = res.headers["location"];
-								const cacheControl = res.headers["cache-control"];
-								const { storeLock, storeCache, validUntil } = parseCacheControl(
-									cacheControl,
-									requestTime
-								);
-								/**
-								 * @param {Partial<Pick<FetchResultMeta, "fresh">> & (Pick<RedirectFetchResult, "location"> | Pick<ContentFetchResult, "content" | "entry">)} partialResult result
-								 * @returns {void}
-								 */
-								const finishWith = partialResult => {
-									if ("location" in partialResult) {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] -> ${partialResult.location}`
-										);
-									} else {
-										logger.debug(
-											`GET ${url} [${res.statusCode}] ${Math.ceil(
-												partialResult.content.length / 1024
-											)} kB${!storeLock ? " no-cache" : ""}`
-										);
-									}
-									const result = {
-										...partialResult,
-										fresh: true,
-										storeLock,
-										storeCache,
-										validUntil,
-										etag
-									};
-									if (!storeCache) {
-										logger.log(
-											`${url} can't be stored in cache, due to Cache-Control header: ${cacheControl}`
-										);
-										return callback(null, result);
-									}
-									cache.store(
-										url,
-										null,
-										{
-											...result,
-											fresh: false
-										},
-										err => {
-											if (err) {
-												logger.warn(
-													`${url} can't be stored in cache: ${err.message}`
-												);
-												logger.debug(err.stack);
-											}
-											callback(null, result);
-										}
-									);
-								};
-								if (res.statusCode === 304) {
-									if (
-										cachedResult.validUntil < validUntil ||
-										cachedResult.storeLock !== storeLock ||
-										cachedResult.storeCache !== storeCache ||
-										cachedResult.etag !== etag
-									) {
-										return finishWith(cachedResult);
-									} else {
-										logger.debug(`GET ${url} [${res.statusCode}] (unchanged)`);
-										return callback(null, {
-											...cachedResult,
-											fresh: true
-										});
-									}
-								}
-								if (
-									location &&
-									res.statusCode >= 301 &&
-									res.statusCode <= 308
-								) {
-									return finishWith({
-										location: new URL(location, url).href
-									});
-								}
-								const contentType = res.headers["content-type"] || "";
-								const bufferArr = [];
 
-								const contentEncoding = res.headers["content-encoding"];
-								let stream = res;
-								if (contentEncoding === "gzip") {
-									stream = stream.pipe(createGunzip());
-								} else if (contentEncoding === "br") {
-									stream = stream.pipe(createBrotliDecompress());
-								} else if (contentEncoding === "deflate") {
-									stream = stream.pipe(createInflate());
-								}
+const Dependency = __webpack_require__(54912);
+const makeSerializable = __webpack_require__(33032);
 
-								stream.on("data", chunk => {
-									bufferArr.push(chunk);
-								});
+class ProvideSharedDependency extends Dependency {
+	constructor(shareScope, name, version, request, eager) {
+		super();
+		this.shareScope = shareScope;
+		this.name = name;
+		this.version = version;
+		this.request = request;
+		this.eager = eager;
+	}
 
-								stream.on("end", () => {
-									if (!res.complete) {
-										logger.log(`GET ${url} [${res.statusCode}] (terminated)`);
-										return callback(new Error(`${url} request was terminated`));
-									}
+	get type() {
+		return "provide shared module";
+	}
 
-									const content = Buffer.concat(bufferArr);
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `provide module (${this.shareScope}) ${this.request} as ${
+			this.name
+		} @ ${this.version}${this.eager ? " (eager)" : ""}`;
+	}
 
-									if (res.statusCode !== 200) {
-										logger.log(`GET ${url} [${res.statusCode}]`);
-										return callback(
-											new Error(
-												`${url} request status code = ${
-													res.statusCode
-												}\n${content.toString("utf-8")}`
-											)
-										);
-									}
+	serialize(context) {
+		context.write(this.shareScope);
+		context.write(this.name);
+		context.write(this.request);
+		context.write(this.version);
+		context.write(this.eager);
+		super.serialize(context);
+	}
 
-									const integrity = computeIntegrity(content);
-									const entry = { resolved: url, integrity, contentType };
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new ProvideSharedDependency(
+			read(),
+			read(),
+			read(),
+			read(),
+			read()
+		);
+		this.shareScope = context.read();
+		obj.deserialize(context);
+		return obj;
+	}
+}
 
-									finishWith({
-										entry,
-										content
-									});
-								});
-							}
-						).on("error", err => {
-							logger.log(`GET ${url} (error)`);
-							err.message += `\nwhile fetching ${url}`;
-							callback(err);
-						});
-					};
+makeSerializable(
+	ProvideSharedDependency,
+	"webpack/lib/sharing/ProvideSharedDependency"
+);
 
-					const fetchContent = cachedWithKey(
-						/**
-						 * @param {string} url URL
-						 * @param {function((Error | null)=, { validUntil: number, etag?: string, entry: LockfileEntry, content: Buffer, fresh: boolean } | { validUntil: number, etag?: string, location: string, fresh: boolean }=): void} callback callback
-						 * @returns {void}
-						 */ (url, callback) => {
-							cache.get(url, null, (err, cachedResult) => {
-								if (err) return callback(err);
-								if (cachedResult) {
-									const isValid = cachedResult.validUntil >= Date.now();
-									if (isValid) return callback(null, cachedResult);
-								}
-								fetchContentRaw(url, cachedResult, callback);
-							});
-						},
-						(url, callback) => fetchContentRaw(url, undefined, callback)
-					);
-
-					const isAllowed = uri => {
-						for (const allowed of allowedUris) {
-							if (typeof allowed === "string") {
-								if (uri.startsWith(allowed)) return true;
-							} else if (typeof allowed === "function") {
-								if (allowed(uri)) return true;
-							} else {
-								if (allowed.test(uri)) return true;
-							}
-						}
-						return false;
-					};
-
-					const getInfo = cachedWithKey(
-						/**
-						 * @param {string} url the url
-						 * @param {function((Error | null)=, { entry: LockfileEntry, content: Buffer }=): void} callback callback
-						 * @returns {void}
-						 */
-						(url, callback) => {
-							if (!isAllowed(url)) {
-								return callback(
-									new Error(
-										`${url} doesn't match the allowedUris policy. These URIs are allowed:\n${allowedUris
-											.map(uri => ` - ${uri}`)
-											.join("\n")}`
-									)
-								);
-							}
-							getLockfile((err, lockfile) => {
-								if (err) return callback(err);
-								const entryOrString = lockfile.entries.get(url);
-								if (!entryOrString) {
-									if (frozen) {
-										return callback(
-											new Error(
-												`${url} has no lockfile entry and lockfile is frozen`
-											)
-										);
-									}
-									resolveContent(url, null, (err, result) => {
-										if (err) return callback(err);
-										storeResult(lockfile, url, result, callback);
-									});
-									return;
-								}
-								if (typeof entryOrString === "string") {
-									const entryTag = entryOrString;
-									resolveContent(url, null, (err, result) => {
-										if (err) return callback(err);
-										if (!result.storeLock || entryTag === "ignore")
-											return callback(null, result);
-										if (frozen) {
-											return callback(
-												new Error(
-													`${url} used to have ${entryTag} lockfile entry and has content now, but lockfile is frozen`
-												)
-											);
-										}
-										if (!upgrade) {
-											return callback(
-												new Error(
-													`${url} used to have ${entryTag} lockfile entry and has content now.
-This should be reflected in the lockfile, so this lockfile entry must be upgraded, but upgrading is not enabled.
-Remove this line from the lockfile to force upgrading.`
-												)
-											);
-										}
-										storeResult(lockfile, url, result, callback);
-									});
-									return;
-								}
-								let entry = entryOrString;
-								const doFetch = lockedContent => {
-									resolveContent(url, entry.integrity, (err, result) => {
-										if (err) {
-											if (lockedContent) {
-												logger.warn(
-													`Upgrade request to ${url} failed: ${err.message}`
-												);
-												logger.debug(err.stack);
-												return callback(null, {
-													entry,
-													content: lockedContent
-												});
-											}
-											return callback(err);
-										}
-										if (!result.storeLock) {
-											// When the lockfile entry should be no-cache
-											// we need to update the lockfile
-											if (frozen) {
-												return callback(
-													new Error(
-														`${url} has a lockfile entry and is no-cache now, but lockfile is frozen\nLockfile: ${entryToString(
-															entry
-														)}`
-													)
-												);
-											}
-											storeResult(lockfile, url, result, callback);
-											return;
-										}
-										if (!areLockfileEntriesEqual(result.entry, entry)) {
-											// When the lockfile entry is outdated
-											// we need to update the lockfile
-											if (frozen) {
-												return callback(
-													new Error(
-														`${url} has an outdated lockfile entry, but lockfile is frozen\nLockfile: ${entryToString(
-															entry
-														)}\nExpected: ${entryToString(result.entry)}`
-													)
-												);
-											}
-											storeResult(lockfile, url, result, callback);
-											return;
-										}
-										if (!lockedContent && cacheLocation) {
-											// When the lockfile cache content is missing
-											// we need to update the lockfile
-											if (frozen) {
-												return callback(
-													new Error(
-														`${url} is missing content in the lockfile cache, but lockfile is frozen\nLockfile: ${entryToString(
-															entry
-														)}`
-													)
-												);
-											}
-											storeResult(lockfile, url, result, callback);
-											return;
-										}
-										return callback(null, result);
-									});
-								};
-								if (cacheLocation) {
-									// When there is a lockfile cache
-									// we read the content from there
-									const key = getCacheKey(entry.resolved);
-									const filePath = join(intermediateFs, cacheLocation, key);
-									fs.readFile(filePath, (err, result) => {
-										const content = /** @type {Buffer} */ (result);
-										if (err) {
-											if (err.code === "ENOENT") return doFetch();
-											return callback(err);
-										}
-										const continueWithCachedContent = result => {
-											if (!upgrade) {
-												// When not in upgrade mode, we accept the result from the lockfile cache
-												return callback(null, { entry, content });
-											}
-											return doFetch(content);
-										};
-										if (!verifyIntegrity(content, entry.integrity)) {
-											let contentWithChangedEol;
-											let isEolChanged = false;
-											try {
-												contentWithChangedEol = Buffer.from(
-													content.toString("utf-8").replace(/\r\n/g, "\n")
-												);
-												isEolChanged = verifyIntegrity(
-													contentWithChangedEol,
-													entry.integrity
-												);
-											} catch (e) {
-												// ignore
-											}
-											if (isEolChanged) {
-												if (!warnedAboutEol) {
-													const explainer = `Incorrect end of line sequence was detected in the lockfile cache.
-The lockfile cache is protected by integrity checks, so any external modification will lead to a corrupted lockfile cache.
-When using git make sure to configure .gitattributes correctly for the lockfile cache:
-  **/*webpack.lock.data/** -text
-This will avoid that the end of line sequence is changed by git on Windows.`;
-													if (frozen) {
-														logger.error(explainer);
-													} else {
-														logger.warn(explainer);
-														logger.info(
-															"Lockfile cache will be automatically fixed now, but when lockfile is frozen this would result in an error."
-														);
-													}
-													warnedAboutEol = true;
-												}
-												if (!frozen) {
-													// "fix" the end of line sequence of the lockfile content
-													logger.log(
-														`${filePath} fixed end of line sequence (\\r\\n instead of \\n).`
-													);
-													intermediateFs.writeFile(
-														filePath,
-														contentWithChangedEol,
-														err => {
-															if (err) return callback(err);
-															continueWithCachedContent(contentWithChangedEol);
-														}
-													);
-													return;
-												}
-											}
-											if (frozen) {
-												return callback(
-													new Error(
-														`${
-															entry.resolved
-														} integrity mismatch, expected content with integrity ${
-															entry.integrity
-														} but got ${computeIntegrity(content)}.
-Lockfile corrupted (${
-															isEolChanged
-																? "end of line sequence was unexpectedly changed"
-																: "incorrectly merged? changed by other tools?"
-														}).
-Run build with un-frozen lockfile to automatically fix lockfile.`
-													)
-												);
-											} else {
-												// "fix" the lockfile entry to the correct integrity
-												// the content has priority over the integrity value
-												entry = {
-													...entry,
-													integrity: computeIntegrity(content)
-												};
-												storeLockEntry(lockfile, url, entry);
-											}
-										}
-										continueWithCachedContent(result);
-									});
-								} else {
-									doFetch();
-								}
-							});
-						}
-					);
-
-					const respondWithUrlModule = (url, resourceData, callback) => {
-						getInfo(url.href, (err, result) => {
-							if (err) return callback(err);
-							resourceData.resource = url.href;
-							resourceData.path = url.origin + url.pathname;
-							resourceData.query = url.search;
-							resourceData.fragment = url.hash;
-							resourceData.context = new URL(
-								".",
-								result.entry.resolved
-							).href.slice(0, -1);
-							resourceData.data.mimetype = result.entry.contentType;
-							callback(null, true);
-						});
-					};
-					normalModuleFactory.hooks.resolveForScheme
-						.for(scheme)
-						.tapAsync(
-							"HttpUriPlugin",
-							(resourceData, resolveData, callback) => {
-								respondWithUrlModule(
-									new URL(resourceData.resource),
-									resourceData,
-									callback
-								);
-							}
-						);
-					normalModuleFactory.hooks.resolveInScheme
-						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
-							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
-							if (
-								data.dependencyType !== "url" &&
-								!/^\.{0,2}\//.test(resourceData.resource)
-							) {
-								return callback();
-							}
-							respondWithUrlModule(
-								new URL(resourceData.resource, data.context + "/"),
-								resourceData,
-								callback
-							);
-						});
-					const hooks = NormalModule.getCompilationHooks(compilation);
-					hooks.readResourceForScheme
-						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resource, module, callback) => {
-							return getInfo(resource, (err, result) => {
-								if (err) return callback(err);
-								module.buildInfo.resourceIntegrity = result.entry.integrity;
-								callback(null, result.content);
-							});
-						});
-					hooks.needBuild.tapAsync(
-						"HttpUriPlugin",
-						(module, context, callback) => {
-							if (
-								module.resource &&
-								module.resource.startsWith(`${scheme}://`)
-							) {
-								getInfo(module.resource, (err, result) => {
-									if (err) return callback(err);
-									if (
-										result.entry.integrity !==
-										module.buildInfo.resourceIntegrity
-									) {
-										return callback(null, true);
-									}
-									callback();
-								});
-							} else {
-								return callback();
-							}
-						}
-					);
-				}
-				compilation.hooks.finishModules.tapAsync(
-					"HttpUriPlugin",
-					(modules, callback) => {
-						if (!lockfileUpdates) return callback();
-						const ext = extname(lockfileLocation);
-						const tempFile = join(
-							intermediateFs,
-							dirname(intermediateFs, lockfileLocation),
-							`.${basename(lockfileLocation, ext)}.${
-								(Math.random() * 10000) | 0
-							}${ext}`
-						);
-
-						const writeDone = () => {
-							const nextOperation = inProgressWrite.shift();
-							if (nextOperation) {
-								nextOperation();
-							} else {
-								inProgressWrite = undefined;
-							}
-						};
-						const runWrite = () => {
-							intermediateFs.readFile(lockfileLocation, (err, buffer) => {
-								if (err && err.code !== "ENOENT") {
-									writeDone();
-									return callback(err);
-								}
-								const lockfile = buffer
-									? Lockfile.parse(buffer.toString("utf-8"))
-									: new Lockfile();
-								for (const [key, value] of lockfileUpdates) {
-									lockfile.entries.set(key, value);
-								}
-								intermediateFs.writeFile(tempFile, lockfile.toString(), err => {
-									if (err) {
-										writeDone();
-										return intermediateFs.unlink(tempFile, () => callback(err));
-									}
-									intermediateFs.rename(tempFile, lockfileLocation, err => {
-										if (err) {
-											writeDone();
-											return intermediateFs.unlink(tempFile, () =>
-												callback(err)
-											);
-										}
-										writeDone();
-										callback();
-									});
-								});
-							});
-						};
-						if (inProgressWrite) {
-							inProgressWrite.push(runWrite);
-						} else {
-							inProgressWrite = [];
-							runWrite();
-						}
-					}
-				);
-			}
-		);
-	}
-}
-
-module.exports = HttpUriPlugin;
+module.exports = ProvideSharedDependency;
 
 
 /***/ }),
 
-/***/ 41721:
-/***/ (function(module) {
+/***/ 50821:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-class ArraySerializer {
-	serialize(array, { write }) {
-		write(array.length);
-		for (const item of array) write(item);
+const AsyncDependenciesBlock = __webpack_require__(47736);
+const Module = __webpack_require__(73208);
+const RuntimeGlobals = __webpack_require__(16475);
+const makeSerializable = __webpack_require__(33032);
+const ProvideForSharedDependency = __webpack_require__(40017);
+
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["share-init"]);
+
+class ProvideSharedModule extends Module {
+	/**
+	 * @param {string} shareScope shared scope name
+	 * @param {string} name shared key
+	 * @param {string | false} version version
+	 * @param {string} request request to the provided module
+	 * @param {boolean} eager include the module in sync way
+	 */
+	constructor(shareScope, name, version, request, eager) {
+		super("provide-module");
+		this._shareScope = shareScope;
+		this._name = name;
+		this._version = version;
+		this._request = request;
+		this._eager = eager;
 	}
-	deserialize({ read }) {
-		const length = read();
-		const array = [];
-		for (let i = 0; i < length; i++) {
-			array.push(read());
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `provide module (${this._shareScope}) ${this._name}@${this._version} = ${this._request}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `provide shared module (${this._shareScope}) ${this._name}@${
+			this._version
+		} = ${requestShortener.shorten(this._request)}`;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
+			this._shareScope
+		}/${this._name}`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildMeta = {};
+		this.buildInfo = {
+			strict: true
+		};
+
+		this.clearDependenciesAndBlocks();
+		const dep = new ProvideForSharedDependency(this._request);
+		if (this._eager) {
+			this.addDependency(dep);
+		} else {
+			const block = new AsyncDependenciesBlock({});
+			block.addDependency(dep);
+			this.addBlock(block);
 		}
-		return array;
+
+		callback();
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 42;
+	}
+
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
+		const runtimeRequirements = new Set([RuntimeGlobals.initializeSharing]);
+		const code = `register(${JSON.stringify(this._name)}, ${JSON.stringify(
+			this._version || "0"
+		)}, ${
+			this._eager
+				? runtimeTemplate.syncModuleFactory({
+						dependency: this.dependencies[0],
+						chunkGraph,
+						request: this._request,
+						runtimeRequirements
+				  })
+				: runtimeTemplate.asyncModuleFactory({
+						block: this.blocks[0],
+						chunkGraph,
+						request: this._request,
+						runtimeRequirements
+				  })
+		}${this._eager ? ", 1" : ""});`;
+		const sources = new Map();
+		const data = new Map();
+		data.set("share-init", [
+			{
+				shareScope: this._shareScope,
+				initStage: 10,
+				init: code
+			}
+		]);
+		return { sources, data, runtimeRequirements };
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this._shareScope);
+		write(this._name);
+		write(this._version);
+		write(this._request);
+		write(this._eager);
+		super.serialize(context);
+	}
+
+	static deserialize(context) {
+		const { read } = context;
+		const obj = new ProvideSharedModule(read(), read(), read(), read(), read());
+		obj.deserialize(context);
+		return obj;
 	}
 }
 
-module.exports = ArraySerializer;
+makeSerializable(
+	ProvideSharedModule,
+	"webpack/lib/sharing/ProvideSharedModule"
+);
+
+module.exports = ProvideSharedModule;
 
 
 /***/ }),
 
-/***/ 97059:
+/***/ 39344:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-const memoize = __webpack_require__(78676);
-const SerializerMiddleware = __webpack_require__(83137);
+const ModuleFactory = __webpack_require__(51010);
+const ProvideSharedModule = __webpack_require__(50821);
 
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
 
-/*
-Format:
+class ProvideSharedModuleFactory extends ModuleFactory {
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dep = /** @type {ProvideSharedDependency} */ (data.dependencies[0]);
+		callback(null, {
+			module: new ProvideSharedModule(
+				dep.shareScope,
+				dep.name,
+				dep.version,
+				dep.request,
+				dep.eager
+			)
+		});
+	}
+}
 
-File -> Section*
+module.exports = ProvideSharedModuleFactory;
 
-Section -> NullsSection |
-					 BooleansSection |
-					 F64NumbersSection |
-					 I32NumbersSection |
-					 I8NumbersSection |
-					 ShortStringSection |
-					 StringSection |
-					 BufferSection |
-					 NopSection
 
+/***/ }),
 
+/***/ 31225:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-NullsSection ->
-	NullHeaderByte | Null2HeaderByte | Null3HeaderByte |
-	Nulls8HeaderByte 0xnn (n:count - 4) |
-	Nulls32HeaderByte n:ui32 (n:count - 260) |
-BooleansSection -> TrueHeaderByte | FalseHeaderByte | BooleansSectionHeaderByte BooleansCountAndBitsByte
-F64NumbersSection -> F64NumbersSectionHeaderByte f64*
-I32NumbersSection -> I32NumbersSectionHeaderByte i32*
-I8NumbersSection -> I8NumbersSectionHeaderByte i8*
-ShortStringSection -> ShortStringSectionHeaderByte ascii-byte*
-StringSection -> StringSectionHeaderByte i32:length utf8-byte*
-BufferSection -> BufferSectionHeaderByte i32:length byte*
-NopSection --> NopSectionHeaderByte
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+*/
 
-ShortStringSectionHeaderByte -> 0b1nnn_nnnn (n:length)
 
-F64NumbersSectionHeaderByte -> 0b001n_nnnn (n:count - 1)
-I32NumbersSectionHeaderByte -> 0b010n_nnnn (n:count - 1)
-I8NumbersSectionHeaderByte -> 0b011n_nnnn (n:count - 1)
 
-NullsSectionHeaderByte -> 0b0001_nnnn (n:count - 1)
-BooleansCountAndBitsByte ->
-	0b0000_1xxx (count = 3) |
-	0b0001_xxxx (count = 4) |
-	0b001x_xxxx (count = 5) |
-	0b01xx_xxxx (count = 6) |
-	0b1nnn_nnnn (n:count - 7, 7 <= count <= 133)
-	0xff n:ui32 (n:count, 134 <= count < 2^32)
+const WebpackError = __webpack_require__(53799);
+const { parseOptions } = __webpack_require__(3083);
+const createSchemaValidation = __webpack_require__(32540);
+const ProvideForSharedDependency = __webpack_require__(40017);
+const ProvideSharedDependency = __webpack_require__(1798);
+const ProvideSharedModuleFactory = __webpack_require__(39344);
 
-StringSectionHeaderByte -> 0b0000_1110
-BufferSectionHeaderByte -> 0b0000_1111
-NopSectionHeaderByte -> 0b0000_1011
-FalseHeaderByte -> 0b0000_1100
-TrueHeaderByte -> 0b0000_1101
+/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
 
-RawNumber -> n (n <= 10)
+const validate = createSchemaValidation(
+	__webpack_require__(91924),
+	() => __webpack_require__(438),
+	{
+		name: "Provide Shared Plugin",
+		baseDataPath: "options"
+	}
+);
 
-*/
+/**
+ * @typedef {Object} ProvideOptions
+ * @property {string} shareKey
+ * @property {string} shareScope
+ * @property {string | undefined | false} version
+ * @property {boolean} eager
+ */
 
-const LAZY_HEADER = 0x0b;
-const TRUE_HEADER = 0x0c;
-const FALSE_HEADER = 0x0d;
-const BOOLEANS_HEADER = 0x0e;
-const NULL_HEADER = 0x10;
-const NULL2_HEADER = 0x11;
-const NULL3_HEADER = 0x12;
-const NULLS8_HEADER = 0x13;
-const NULLS32_HEADER = 0x14;
-const NULL_AND_I8_HEADER = 0x15;
-const NULL_AND_I32_HEADER = 0x16;
-const NULL_AND_TRUE_HEADER = 0x17;
-const NULL_AND_FALSE_HEADER = 0x18;
-const STRING_HEADER = 0x1e;
-const BUFFER_HEADER = 0x1f;
-const I8_HEADER = 0x60;
-const I32_HEADER = 0x40;
-const F64_HEADER = 0x20;
-const SHORT_STRING_HEADER = 0x80;
-
-/** Uplift high-order bits */
-const NUMBERS_HEADER_MASK = 0xe0;
-const NUMBERS_COUNT_MASK = 0x1f; // 0b0001_1111
-const SHORT_STRING_LENGTH_MASK = 0x7f; // 0b0111_1111
-
-const HEADER_SIZE = 1;
-const I8_SIZE = 1;
-const I32_SIZE = 4;
-const F64_SIZE = 8;
-
-const MEASURE_START_OPERATION = Symbol("MEASURE_START_OPERATION");
-const MEASURE_END_OPERATION = Symbol("MEASURE_END_OPERATION");
-
-/** @typedef {typeof MEASURE_START_OPERATION} MEASURE_START_OPERATION_TYPE */
-/** @typedef {typeof MEASURE_END_OPERATION} MEASURE_END_OPERATION_TYPE */
-
-const identifyNumber = n => {
-	if (n === (n | 0)) {
-		if (n <= 127 && n >= -128) return 0;
-		if (n <= 2147483647 && n >= -2147483648) return 1;
-	}
-	return 2;
-};
+/** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
 
-/**
- * @typedef {PrimitiveSerializableType[]} DeserializedType
- * @typedef {BufferSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class BinaryMiddleware extends SerializerMiddleware {
+class ProvideSharedPlugin {
 	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {ProvideSharedPluginOptions} options options
 	 */
-	serialize(data, context) {
-		return this._serialize(data, context);
-	}
+	constructor(options) {
+		validate(options);
 
-	_serializeLazy(fn, context) {
-		return SerializerMiddleware.serializeLazy(fn, data =>
-			this._serialize(data, context)
+		/** @type {[string, ProvideOptions][]} */
+		this._provides = parseOptions(
+			options.provides,
+			item => {
+				if (Array.isArray(item))
+					throw new Error("Unexpected array of provides");
+				/** @type {ProvideOptions} */
+				const result = {
+					shareKey: item,
+					version: undefined,
+					shareScope: options.shareScope || "default",
+					eager: false
+				};
+				return result;
+			},
+			item => ({
+				shareKey: item.shareKey,
+				version: item.version,
+				shareScope: item.shareScope || options.shareScope || "default",
+				eager: !!item.eager
+			})
 		);
+		this._provides.sort(([a], [b]) => {
+			if (a < b) return -1;
+			if (b < a) return 1;
+			return 0;
+		});
 	}
 
 	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @param {{ leftOverBuffer: Buffer | null, allocationSize: number, increaseCounter: number }} allocationScope allocation scope
-	 * @returns {SerializedType} serialized data
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	_serialize(
-		data,
-		context,
-		allocationScope = {
-			allocationSize: 1024,
-			increaseCounter: 0,
-			leftOverBuffer: null
-		}
-	) {
-		/** @type {Buffer} */
-		let leftOverBuffer = null;
-		/** @type {BufferSerializableType[]} */
-		let buffers = [];
-		/** @type {Buffer} */
-		let currentBuffer = allocationScope ? allocationScope.leftOverBuffer : null;
-		allocationScope.leftOverBuffer = null;
-		let currentPosition = 0;
-		if (currentBuffer === null) {
-			currentBuffer = Buffer.allocUnsafe(allocationScope.allocationSize);
-		}
-		const allocate = bytesNeeded => {
-			if (currentBuffer !== null) {
-				if (currentBuffer.length - currentPosition >= bytesNeeded) return;
-				flush();
-			}
-			if (leftOverBuffer && leftOverBuffer.length >= bytesNeeded) {
-				currentBuffer = leftOverBuffer;
-				leftOverBuffer = null;
-			} else {
-				currentBuffer = Buffer.allocUnsafe(
-					Math.max(bytesNeeded, allocationScope.allocationSize)
-				);
-				if (
-					!(allocationScope.increaseCounter =
-						(allocationScope.increaseCounter + 1) % 4) &&
-					allocationScope.allocationSize < 16777216
-				) {
-					allocationScope.allocationSize = allocationScope.allocationSize << 1;
-				}
-			}
-		};
-		const flush = () => {
-			if (currentBuffer !== null) {
-				if (currentPosition > 0) {
-					buffers.push(
-						Buffer.from(
-							currentBuffer.buffer,
-							currentBuffer.byteOffset,
-							currentPosition
-						)
-					);
-				}
-				if (
-					!leftOverBuffer ||
-					leftOverBuffer.length < currentBuffer.length - currentPosition
-				) {
-					leftOverBuffer = Buffer.from(
-						currentBuffer.buffer,
-						currentBuffer.byteOffset + currentPosition,
-						currentBuffer.byteLength - currentPosition
-					);
-				}
+	apply(compiler) {
+		/** @type {WeakMap<Compilation, ResolvedProvideMap>} */
+		const compilationData = new WeakMap();
 
-				currentBuffer = null;
-				currentPosition = 0;
-			}
-		};
-		const writeU8 = byte => {
-			currentBuffer.writeUInt8(byte, currentPosition++);
-		};
-		const writeU32 = ui32 => {
-			currentBuffer.writeUInt32LE(ui32, currentPosition);
-			currentPosition += 4;
-		};
-		const measureStack = [];
-		const measureStart = () => {
-			measureStack.push(buffers.length, currentPosition);
-		};
-		const measureEnd = () => {
-			const oldPos = measureStack.pop();
-			const buffersIndex = measureStack.pop();
-			let size = currentPosition - oldPos;
-			for (let i = buffersIndex; i < buffers.length; i++) {
-				size += buffers[i].length;
-			}
-			return size;
-		};
-		for (let i = 0; i < data.length; i++) {
-			const thing = data[i];
-			switch (typeof thing) {
-				case "function": {
-					if (!SerializerMiddleware.isLazy(thing))
-						throw new Error("Unexpected function " + thing);
-					/** @type {SerializedType | (() => SerializedType)} */
-					let serializedData =
-						SerializerMiddleware.getLazySerializedValue(thing);
-					if (serializedData === undefined) {
-						if (SerializerMiddleware.isLazy(thing, this)) {
-							flush();
-							allocationScope.leftOverBuffer = leftOverBuffer;
-							const result =
-								/** @type {(Exclude<PrimitiveSerializableType, Promise<PrimitiveSerializableType>>)[]} */ (
-									thing()
-								);
-							const data = this._serialize(result, context, allocationScope);
-							leftOverBuffer = allocationScope.leftOverBuffer;
-							allocationScope.leftOverBuffer = null;
-							SerializerMiddleware.setLazySerializedValue(thing, data);
-							serializedData = data;
-						} else {
-							serializedData = this._serializeLazy(thing, context);
-							flush();
-							buffers.push(serializedData);
-							break;
-						}
+		compiler.hooks.compilation.tap(
+			"ProvideSharedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				/** @type {ResolvedProvideMap} */
+				const resolvedProvideMap = new Map();
+				/** @type {Map<string, ProvideOptions>} */
+				const matchProvides = new Map();
+				/** @type {Map<string, ProvideOptions>} */
+				const prefixMatchProvides = new Map();
+				for (const [request, config] of this._provides) {
+					if (/^(\/|[A-Za-z]:\\|\\\\|\.\.?(\/|$))/.test(request)) {
+						// relative request
+						resolvedProvideMap.set(request, {
+							config,
+							version: config.version
+						});
+					} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+						// absolute path
+						resolvedProvideMap.set(request, {
+							config,
+							version: config.version
+						});
+					} else if (request.endsWith("/")) {
+						// module request prefix
+						prefixMatchProvides.set(request, config);
 					} else {
-						if (typeof serializedData === "function") {
-							flush();
-							buffers.push(serializedData);
-							break;
-						}
+						// module request
+						matchProvides.set(request, config);
 					}
-					const lengths = [];
-					for (const item of serializedData) {
-						let last;
-						if (typeof item === "function") {
-							lengths.push(0);
-						} else if (item.length === 0) {
-							// ignore
-						} else if (
-							lengths.length > 0 &&
-							(last = lengths[lengths.length - 1]) !== 0
-						) {
-							const remaining = 0xffffffff - last;
-							if (remaining >= item.length) {
-								lengths[lengths.length - 1] += item.length;
+				}
+				compilationData.set(compilation, resolvedProvideMap);
+				const provideSharedModule = (
+					key,
+					config,
+					resource,
+					resourceResolveData
+				) => {
+					let version = config.version;
+					if (version === undefined) {
+						let details = "";
+						if (!resourceResolveData) {
+							details = `No resolve data provided from resolver.`;
+						} else {
+							const descriptionFileData =
+								resourceResolveData.descriptionFileData;
+							if (!descriptionFileData) {
+								details =
+									"No description file (usually package.json) found. Add description file with name and version, or manually specify version in shared config.";
+							} else if (!descriptionFileData.version) {
+								details =
+									"No version in description file (usually package.json). Add version to description file, or manually specify version in shared config.";
 							} else {
-								lengths.push(item.length - remaining);
-								lengths[lengths.length - 2] = 0xffffffff;
+								version = descriptionFileData.version;
 							}
-						} else {
-							lengths.push(item.length);
 						}
-					}
-					allocate(5 + lengths.length * 4);
-					writeU8(LAZY_HEADER);
-					writeU32(lengths.length);
-					for (const l of lengths) {
-						writeU32(l);
-					}
-					flush();
-					for (const item of serializedData) {
-						buffers.push(item);
-					}
-					break;
-				}
-				case "string": {
-					const len = Buffer.byteLength(thing);
-					if (len >= 128 || len !== thing.length) {
-						allocate(len + HEADER_SIZE + I32_SIZE);
-						writeU8(STRING_HEADER);
-						writeU32(len);
-						currentBuffer.write(thing, currentPosition);
-						currentPosition += len;
-					} else if (len >= 70) {
-						allocate(len + HEADER_SIZE);
-						writeU8(SHORT_STRING_HEADER | len);
-
-						currentBuffer.write(thing, currentPosition, "latin1");
-						currentPosition += len;
-					} else {
-						allocate(len + HEADER_SIZE);
-						writeU8(SHORT_STRING_HEADER | len);
-
-						for (let i = 0; i < len; i++) {
-							currentBuffer[currentPosition++] = thing.charCodeAt(i);
+						if (!version) {
+							const error = new WebpackError(
+								`No version specified and unable to automatically determine one. ${details}`
+							);
+							error.file = `shared module ${key} -> ${resource}`;
+							compilation.warnings.push(error);
 						}
 					}
-					break;
-				}
-				case "number": {
-					const type = identifyNumber(thing);
-					if (type === 0 && thing >= 0 && thing <= 10) {
-						// shortcut for very small numbers
-						allocate(I8_SIZE);
-						writeU8(thing);
-						break;
-					}
-					/**
-					 * amount of numbers to write
-					 * @type {number}
-					 */
-					let n = 1;
-					for (; n < 32 && i + n < data.length; n++) {
-						const item = data[i + n];
-						if (typeof item !== "number") break;
-						if (identifyNumber(item) !== type) break;
-					}
-					switch (type) {
-						case 0:
-							allocate(HEADER_SIZE + I8_SIZE * n);
-							writeU8(I8_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt8(
-									/** @type {number} */ (data[i]),
-									currentPosition
-								);
-								currentPosition += I8_SIZE;
-								n--;
-								i++;
-							}
-							break;
-						case 1:
-							allocate(HEADER_SIZE + I32_SIZE * n);
-							writeU8(I32_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeInt32LE(
-									/** @type {number} */ (data[i]),
-									currentPosition
+					resolvedProvideMap.set(resource, {
+						config,
+						version
+					});
+				};
+				normalModuleFactory.hooks.module.tap(
+					"ProvideSharedPlugin",
+					(module, { resource, resourceResolveData }, resolveData) => {
+						if (resolvedProvideMap.has(resource)) {
+							return module;
+						}
+						const { request } = resolveData;
+						{
+							const config = matchProvides.get(request);
+							if (config !== undefined) {
+								provideSharedModule(
+									request,
+									config,
+									resource,
+									resourceResolveData
 								);
-								currentPosition += I32_SIZE;
-								n--;
-								i++;
+								resolveData.cacheable = false;
 							}
-							break;
-						case 2:
-							allocate(HEADER_SIZE + F64_SIZE * n);
-							writeU8(F64_HEADER | (n - 1));
-							while (n > 0) {
-								currentBuffer.writeDoubleLE(
-									/** @type {number} */ (data[i]),
-									currentPosition
+						}
+						for (const [prefix, config] of prefixMatchProvides) {
+							if (request.startsWith(prefix)) {
+								const remainder = request.slice(prefix.length);
+								provideSharedModule(
+									resource,
+									{
+										...config,
+										shareKey: config.shareKey + remainder
+									},
+									resource,
+									resourceResolveData
 								);
-								currentPosition += F64_SIZE;
-								n--;
-								i++;
+								resolveData.cacheable = false;
 							}
-							break;
-					}
-
-					i--;
-					break;
-				}
-				case "boolean": {
-					let lastByte = thing === true ? 1 : 0;
-					const bytes = [];
-					let count = 1;
-					let n;
-					for (n = 1; n < 0xffffffff && i + n < data.length; n++) {
-						const item = data[i + n];
-						if (typeof item !== "boolean") break;
-						const pos = count & 0x7;
-						if (pos === 0) {
-							bytes.push(lastByte);
-							lastByte = item === true ? 1 : 0;
-						} else if (item === true) {
-							lastByte |= 1 << pos;
 						}
-						count++;
-					}
-					i += count - 1;
-					if (count === 1) {
-						allocate(HEADER_SIZE);
-						writeU8(lastByte === 1 ? TRUE_HEADER : FALSE_HEADER);
-					} else if (count === 2) {
-						allocate(HEADER_SIZE * 2);
-						writeU8(lastByte & 1 ? TRUE_HEADER : FALSE_HEADER);
-						writeU8(lastByte & 2 ? TRUE_HEADER : FALSE_HEADER);
-					} else if (count <= 6) {
-						allocate(HEADER_SIZE + I8_SIZE);
-						writeU8(BOOLEANS_HEADER);
-						writeU8((1 << count) | lastByte);
-					} else if (count <= 133) {
-						allocate(HEADER_SIZE + I8_SIZE + I8_SIZE * bytes.length + I8_SIZE);
-						writeU8(BOOLEANS_HEADER);
-						writeU8(0x80 | (count - 7));
-						for (const byte of bytes) writeU8(byte);
-						writeU8(lastByte);
-					} else {
-						allocate(
-							HEADER_SIZE +
-								I8_SIZE +
-								I32_SIZE +
-								I8_SIZE * bytes.length +
-								I8_SIZE
-						);
-						writeU8(BOOLEANS_HEADER);
-						writeU8(0xff);
-						writeU32(count);
-						for (const byte of bytes) writeU8(byte);
-						writeU8(lastByte);
+						return module;
 					}
-					break;
-				}
-				case "object": {
-					if (thing === null) {
-						let n;
-						for (n = 1; n < 0x100000104 && i + n < data.length; n++) {
-							const item = data[i + n];
-							if (item !== null) break;
-						}
-						i += n - 1;
-						if (n === 1) {
-							if (i + 1 < data.length) {
-								const next = data[i + 1];
-								if (next === true) {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_AND_TRUE_HEADER);
-									i++;
-								} else if (next === false) {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_AND_FALSE_HEADER);
-									i++;
-								} else if (typeof next === "number") {
-									const type = identifyNumber(next);
-									if (type === 0) {
-										allocate(HEADER_SIZE + I8_SIZE);
-										writeU8(NULL_AND_I8_HEADER);
-										currentBuffer.writeInt8(next, currentPosition);
-										currentPosition += I8_SIZE;
-										i++;
-									} else if (type === 1) {
-										allocate(HEADER_SIZE + I32_SIZE);
-										writeU8(NULL_AND_I32_HEADER);
-										currentBuffer.writeInt32LE(next, currentPosition);
-										currentPosition += I32_SIZE;
-										i++;
-									} else {
-										allocate(HEADER_SIZE);
-										writeU8(NULL_HEADER);
-									}
-								} else {
-									allocate(HEADER_SIZE);
-									writeU8(NULL_HEADER);
-								}
-							} else {
-								allocate(HEADER_SIZE);
-								writeU8(NULL_HEADER);
-							}
-						} else if (n === 2) {
-							allocate(HEADER_SIZE);
-							writeU8(NULL2_HEADER);
-						} else if (n === 3) {
-							allocate(HEADER_SIZE);
-							writeU8(NULL3_HEADER);
-						} else if (n < 260) {
-							allocate(HEADER_SIZE + I8_SIZE);
-							writeU8(NULLS8_HEADER);
-							writeU8(n - 4);
-						} else {
-							allocate(HEADER_SIZE + I32_SIZE);
-							writeU8(NULLS32_HEADER);
-							writeU32(n - 260);
-						}
-					} else if (Buffer.isBuffer(thing)) {
-						if (thing.length < 8192) {
-							allocate(HEADER_SIZE + I32_SIZE + thing.length);
-							writeU8(BUFFER_HEADER);
-							writeU32(thing.length);
-							thing.copy(currentBuffer, currentPosition);
-							currentPosition += thing.length;
-						} else {
-							allocate(HEADER_SIZE + I32_SIZE);
-							writeU8(BUFFER_HEADER);
-							writeU32(thing.length);
-							flush();
-							buffers.push(thing);
-						}
-					}
-					break;
-				}
-				case "symbol": {
-					if (thing === MEASURE_START_OPERATION) {
-						measureStart();
-					} else if (thing === MEASURE_END_OPERATION) {
-						const size = measureEnd();
-						allocate(HEADER_SIZE + I32_SIZE);
-						writeU8(I32_HEADER);
-						currentBuffer.writeInt32LE(size, currentPosition);
-						currentPosition += I32_SIZE;
-					}
-					break;
-				}
-			}
-		}
-		flush();
-
-		allocationScope.leftOverBuffer = leftOverBuffer;
-
-		// avoid leaking memory
-		currentBuffer = null;
-		leftOverBuffer = null;
-		allocationScope = undefined;
-		const _buffers = buffers;
-		buffers = undefined;
-		return _buffers;
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		return this._deserialize(data, context);
-	}
-
-	_createLazyDeserialized(content, context) {
-		return SerializerMiddleware.createLazy(
-			memoize(() => this._deserialize(content, context)),
-			this,
-			undefined,
-			content
-		);
-	}
-
-	_deserializeLazy(fn, context) {
-		return SerializerMiddleware.deserializeLazy(fn, data =>
-			this._deserialize(data, context)
-		);
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType} deserialized data
-	 */
-	_deserialize(data, context) {
-		let currentDataItem = 0;
-		let currentBuffer = data[0];
-		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
-		let currentPosition = 0;
-
-		const retainedBuffer = context.retainedBuffer || (x => x);
-
-		const checkOverflow = () => {
-			if (currentPosition >= currentBuffer.length) {
-				currentPosition = 0;
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			}
-		};
-		const isInCurrentBuffer = n => {
-			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
-		};
-		const ensureBuffer = () => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
 				);
 			}
-		};
-		/**
-		 * Reads n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const read = n => {
-			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
-			if (rem < n) {
-				const buffers = [read(rem)];
-				n -= rem;
-				ensureBuffer();
-				while (currentBuffer.length < n) {
-					const b = /** @type {Buffer} */ (currentBuffer);
-					buffers.push(b);
-					n -= b.length;
-					currentDataItem++;
-					currentBuffer =
-						currentDataItem < data.length ? data[currentDataItem] : null;
-					currentIsBuffer = Buffer.isBuffer(currentBuffer);
-					ensureBuffer();
-				}
-				buffers.push(read(n));
-				return Buffer.concat(buffers);
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		/**
-		 * Reads up to n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const readUpTo = n => {
-			ensureBuffer();
-			const rem = currentBuffer.length - currentPosition;
-			if (rem < n) {
-				n = rem;
-			}
-			const b = /** @type {Buffer} */ (currentBuffer);
-			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
-			currentPosition += n;
-			checkOverflow();
-			return res;
-		};
-		const readU8 = () => {
-			ensureBuffer();
-			/**
-			 * There is no need to check remaining buffer size here
-			 * since {@link checkOverflow} guarantees at least one byte remaining
-			 */
-			const byte = /** @type {Buffer} */ (currentBuffer).readUInt8(
-				currentPosition
-			);
-			currentPosition += I8_SIZE;
-			checkOverflow();
-			return byte;
-		};
-		const readU32 = () => {
-			return read(I32_SIZE).readUInt32LE(0);
-		};
-		const readBits = (data, n) => {
-			let mask = 1;
-			while (n !== 0) {
-				result.push((data & mask) !== 0);
-				mask = mask << 1;
-				n--;
-			}
-		};
-		const dispatchTable = Array.from({ length: 256 }).map((_, header) => {
-			switch (header) {
-				case LAZY_HEADER:
-					return () => {
-						const count = readU32();
-						const lengths = Array.from({ length: count }).map(() => readU32());
-						const content = [];
-						for (let l of lengths) {
-							if (l === 0) {
-								if (typeof currentBuffer !== "function") {
-									throw new Error("Unexpected non-lazy element in stream");
-								}
-								content.push(currentBuffer);
-								currentDataItem++;
-								currentBuffer =
-									currentDataItem < data.length ? data[currentDataItem] : null;
-								currentIsBuffer = Buffer.isBuffer(currentBuffer);
-							} else {
-								do {
-									const buf = readUpTo(l);
-									l -= buf.length;
-									content.push(retainedBuffer(buf));
-								} while (l > 0);
-							}
-						}
-						result.push(this._createLazyDeserialized(content, context));
-					};
-				case BUFFER_HEADER:
-					return () => {
-						const len = readU32();
-						result.push(retainedBuffer(read(len)));
-					};
-				case TRUE_HEADER:
-					return () => result.push(true);
-				case FALSE_HEADER:
-					return () => result.push(false);
-				case NULL3_HEADER:
-					return () => result.push(null, null, null);
-				case NULL2_HEADER:
-					return () => result.push(null, null);
-				case NULL_HEADER:
-					return () => result.push(null);
-				case NULL_AND_TRUE_HEADER:
-					return () => result.push(null, true);
-				case NULL_AND_FALSE_HEADER:
-					return () => result.push(null, false);
-				case NULL_AND_I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								null,
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition += I8_SIZE;
-							checkOverflow();
-						} else {
-							result.push(null, read(I8_SIZE).readInt8(0));
-						}
-					};
-				case NULL_AND_I32_HEADER:
-					return () => {
-						result.push(null);
-						if (isInCurrentBuffer(I32_SIZE)) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt32LE(
-									currentPosition
-								)
-							);
-							currentPosition += I32_SIZE;
-							checkOverflow();
-						} else {
-							result.push(read(I32_SIZE).readInt32LE(0));
-						}
-					};
-				case NULLS8_HEADER:
-					return () => {
-						const len = readU8() + 4;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case NULLS32_HEADER:
-					return () => {
-						const len = readU32() + 260;
-						for (let i = 0; i < len; i++) {
-							result.push(null);
-						}
-					};
-				case BOOLEANS_HEADER:
-					return () => {
-						const innerHeader = readU8();
-						if ((innerHeader & 0xf0) === 0) {
-							readBits(innerHeader, 3);
-						} else if ((innerHeader & 0xe0) === 0) {
-							readBits(innerHeader, 4);
-						} else if ((innerHeader & 0xc0) === 0) {
-							readBits(innerHeader, 5);
-						} else if ((innerHeader & 0x80) === 0) {
-							readBits(innerHeader, 6);
-						} else if (innerHeader !== 0xff) {
-							let count = (innerHeader & 0x7f) + 7;
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						} else {
-							let count = readU32();
-							while (count > 8) {
-								readBits(readU8(), 8);
-								count -= 8;
-							}
-							readBits(readU8(), count);
-						}
-					};
-				case STRING_HEADER:
-					return () => {
-						const len = readU32();
-						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
-							result.push(
-								currentBuffer.toString(
-									undefined,
-									currentPosition,
-									currentPosition + len
-								)
-							);
-							currentPosition += len;
-							checkOverflow();
-						} else {
-							result.push(read(len).toString());
-						}
-					};
-				case SHORT_STRING_HEADER:
-					return () => result.push("");
-				case SHORT_STRING_HEADER | 1:
-					return () => {
-						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
-							result.push(
-								currentBuffer.toString(
-									"latin1",
-									currentPosition,
-									currentPosition + 1
-								)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).toString("latin1"));
-						}
-					};
-				case I8_HEADER:
-					return () => {
-						if (currentIsBuffer) {
-							result.push(
-								/** @type {Buffer} */ (currentBuffer).readInt8(currentPosition)
-							);
-							currentPosition++;
-							checkOverflow();
-						} else {
-							result.push(read(1).readInt8(0));
-						}
-					};
-				default:
-					if (header <= 10) {
-						return () => result.push(header);
-					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
-						const len = header & SHORT_STRING_LENGTH_MASK;
-						return () => {
-							if (
-								isInCurrentBuffer(len) &&
-								currentPosition + len < 0x7fffffff
-							) {
-								result.push(
-									currentBuffer.toString(
-										"latin1",
-										currentPosition,
-										currentPosition + len
-									)
-								);
-								currentPosition += len;
-								checkOverflow();
-							} else {
-								result.push(read(len).toString("latin1"));
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === F64_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = F64_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readDoubleLE(
-											currentPosition
-										)
-									);
-									currentPosition += F64_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readDoubleLE(i * F64_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I32_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I32_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt32LE(
-											currentPosition
-										)
-									);
-									currentPosition += I32_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt32LE(i * I32_SIZE));
-								}
-							}
-						};
-					} else if ((header & NUMBERS_HEADER_MASK) === I8_HEADER) {
-						const len = (header & NUMBERS_COUNT_MASK) + 1;
-						return () => {
-							const need = I8_SIZE * len;
-							if (isInCurrentBuffer(need)) {
-								for (let i = 0; i < len; i++) {
-									result.push(
-										/** @type {Buffer} */ (currentBuffer).readInt8(
-											currentPosition
-										)
-									);
-									currentPosition += I8_SIZE;
-								}
-								checkOverflow();
-							} else {
-								const buf = read(need);
-								for (let i = 0; i < len; i++) {
-									result.push(buf.readInt8(i * I8_SIZE));
+		);
+		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
+			const resolvedProvideMap = compilationData.get(compilation);
+			if (!resolvedProvideMap) return Promise.resolve();
+			return Promise.all(
+				Array.from(
+					resolvedProvideMap,
+					([resource, { config, version }]) =>
+						new Promise((resolve, reject) => {
+							compilation.addInclude(
+								compiler.context,
+								new ProvideSharedDependency(
+									config.shareScope,
+									config.shareKey,
+									version || false,
+									resource,
+									config.eager
+								),
+								{
+									name: undefined
+								},
+								err => {
+									if (err) return reject(err);
+									resolve();
 								}
-							}
-						};
-					} else {
-						return () => {
-							throw new Error(
-								`Unexpected header byte 0x${header.toString(16)}`
 							);
-						};
-					}
-			}
+						})
+				)
+			).then(() => {});
 		});
 
-		/** @type {DeserializedType} */
-		let result = [];
-		while (currentBuffer !== null) {
-			if (typeof currentBuffer === "function") {
-				result.push(this._deserializeLazy(currentBuffer, context));
-				currentDataItem++;
-				currentBuffer =
-					currentDataItem < data.length ? data[currentDataItem] : null;
-				currentIsBuffer = Buffer.isBuffer(currentBuffer);
-			} else {
-				const header = readU8();
-				dispatchTable[header]();
-			}
-		}
+		compiler.hooks.compilation.tap(
+			"ProvideSharedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					ProvideForSharedDependency,
+					normalModuleFactory
+				);
 
-		// avoid leaking memory in context
-		let _result = result;
-		result = undefined;
-		return _result;
+				compilation.dependencyFactories.set(
+					ProvideSharedDependency,
+					new ProvideSharedModuleFactory()
+				);
+			}
+		);
 	}
 }
 
-module.exports = BinaryMiddleware;
-
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
-module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+module.exports = ProvideSharedPlugin;
 
 
 /***/ }),
 
-/***/ 93475:
-/***/ (function(module) {
+/***/ 26335:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
 */
 
 
 
-class DateObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.getTime());
-	}
-	deserialize({ read }) {
-		return new Date(read());
-	}
-}
-
-module.exports = DateObjectSerializer;
-
+const { parseOptions } = __webpack_require__(3083);
+const ConsumeSharedPlugin = __webpack_require__(15046);
+const ProvideSharedPlugin = __webpack_require__(31225);
+const { isRequiredVersion } = __webpack_require__(84379);
+
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
+/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvidesConfig} ProvidesConfig */
+/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharePluginOptions} SharePluginOptions */
+/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharedConfig} SharedConfig */
+/** @typedef {import("../Compiler")} Compiler */
+
+class SharePlugin {
+	/**
+	 * @param {SharePluginOptions} options options
+	 */
+	constructor(options) {
+		/** @type {[string, SharedConfig][]} */
+		const sharedOptions = parseOptions(
+			options.shared,
+			(item, key) => {
+				if (typeof item !== "string")
+					throw new Error("Unexpected array in shared");
+				/** @type {SharedConfig} */
+				const config =
+					item === key || !isRequiredVersion(item)
+						? {
+								import: item
+						  }
+						: {
+								import: key,
+								requiredVersion: item
+						  };
+				return config;
+			},
+			item => item
+		);
+		/** @type {Record<string, ConsumesConfig>[]} */
+		const consumes = sharedOptions.map(([key, options]) => ({
+			[key]: {
+				import: options.import,
+				shareKey: options.shareKey || key,
+				shareScope: options.shareScope,
+				requiredVersion: options.requiredVersion,
+				strictVersion: options.strictVersion,
+				singleton: options.singleton,
+				packageName: options.packageName,
+				eager: options.eager
+			}
+		}));
+		/** @type {Record<string, ProvidesConfig>[]} */
+		const provides = sharedOptions
+			.filter(([, options]) => options.import !== false)
+			.map(([key, options]) => ({
+				[options.import || key]: {
+					shareKey: options.shareKey || key,
+					shareScope: options.shareScope,
+					version: options.version,
+					eager: options.eager
+				}
+			}));
+		this._shareScope = options.shareScope;
+		this._consumes = consumes;
+		this._provides = provides;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new ConsumeSharedPlugin({
+			shareScope: this._shareScope,
+			consumes: this._consumes
+		}).apply(compiler);
+		new ProvideSharedPlugin({
+			shareScope: this._shareScope,
+			provides: this._provides
+		}).apply(compiler);
+	}
+}
+
+module.exports = SharePlugin;
+
 
 /***/ }),
 
-/***/ 79479:
-/***/ (function(module) {
+/***/ 96066:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-class ErrorObjectSerializer {
-	constructor(Type) {
-		this.Type = Type;
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const {
+	compareModulesByIdentifier,
+	compareStrings
+} = __webpack_require__(29579);
 
-	serialize(obj, { write }) {
-		write(obj.message);
-		write(obj.stack);
+class ShareRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("sharing");
 	}
 
-	deserialize({ read }) {
-		const err = new this.Type();
-
-		err.message = read();
-		err.stack = read();
-
-		return err;
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunkGraph } = this;
+		const {
+			runtimeTemplate,
+			codeGenerationResults,
+			outputOptions: { uniqueName }
+		} = compilation;
+		/** @type {Map<string, Map<number, Set<string>>>} */
+		const initCodePerScope = new Map();
+		for (const chunk of this.chunk.getAllReferencedChunks()) {
+			const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
+				chunk,
+				"share-init",
+				compareModulesByIdentifier
+			);
+			if (!modules) continue;
+			for (const m of modules) {
+				const data = codeGenerationResults.getData(
+					m,
+					chunk.runtime,
+					"share-init"
+				);
+				if (!data) continue;
+				for (const item of data) {
+					const { shareScope, initStage, init } = item;
+					let stages = initCodePerScope.get(shareScope);
+					if (stages === undefined) {
+						initCodePerScope.set(shareScope, (stages = new Map()));
+					}
+					let list = stages.get(initStage || 0);
+					if (list === undefined) {
+						stages.set(initStage || 0, (list = new Set()));
+					}
+					list.add(init);
+				}
+			}
+		}
+		return Template.asString([
+			`${RuntimeGlobals.shareScopeMap} = {};`,
+			"var initPromises = {};",
+			"var initTokens = {};",
+			`${RuntimeGlobals.initializeSharing} = ${runtimeTemplate.basicFunction(
+				"name, initScope",
+				[
+					"if(!initScope) initScope = [];",
+					"// handling circular init calls",
+					"var initToken = initTokens[name];",
+					"if(!initToken) initToken = initTokens[name] = {};",
+					"if(initScope.indexOf(initToken) >= 0) return;",
+					"initScope.push(initToken);",
+					"// only runs once",
+					"if(initPromises[name]) return initPromises[name];",
+					"// creates a new share scope if needed",
+					`if(!${RuntimeGlobals.hasOwnProperty}(${RuntimeGlobals.shareScopeMap}, name)) ${RuntimeGlobals.shareScopeMap}[name] = {};`,
+					"// runs all init snippets from all modules reachable",
+					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
+					`var warn = ${runtimeTemplate.returningFunction(
+						'typeof console !== "undefined" && console.warn && console.warn(msg)',
+						"msg"
+					)};`,
+					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
+					`var register = ${runtimeTemplate.basicFunction(
+						"name, version, factory, eager",
+						[
+							"var versions = scope[name] = scope[name] || {};",
+							"var activeVersion = versions[version];",
+							"if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };"
+						]
+					)};`,
+					`var initExternal = ${runtimeTemplate.basicFunction("id", [
+						`var handleError = ${runtimeTemplate.expressionFunction(
+							'warn("Initialization of sharing external failed: " + err)',
+							"err"
+						)};`,
+						"try {",
+						Template.indent([
+							"var module = __webpack_require__(id);",
+							"if(!module) return;",
+							`var initFn = ${runtimeTemplate.returningFunction(
+								`module && module.init && module.init(${RuntimeGlobals.shareScopeMap}[name], initScope)`,
+								"module"
+							)}`,
+							"if(module.then) return promises.push(module.then(initFn, handleError));",
+							"var initResult = initFn(module);",
+							"if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));"
+						]),
+						"} catch(err) { handleError(err); }"
+					])}`,
+					"var promises = [];",
+					"switch(name) {",
+					...Array.from(initCodePerScope)
+						.sort(([a], [b]) => compareStrings(a, b))
+						.map(([name, stages]) =>
+							Template.indent([
+								`case ${JSON.stringify(name)}: {`,
+								Template.indent(
+									Array.from(stages)
+										.sort(([a], [b]) => a - b)
+										.map(([, initCode]) =>
+											Template.asString(Array.from(initCode))
+										)
+								),
+								"}",
+								"break;"
+							])
+						),
+					"}",
+					"if(!promises.length) return initPromises[name] = 1;",
+					`return initPromises[name] = Promise.all(promises).then(${runtimeTemplate.returningFunction(
+						"initPromises[name] = 1"
+					)});`
+				]
+			)};`
+		]);
 	}
 }
 
-module.exports = ErrorObjectSerializer;
+module.exports = ShareRuntimeModule;
 
 
 /***/ }),
 
-/***/ 65321:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 3591:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { constants } = __webpack_require__(14300);
-const { pipeline } = __webpack_require__(12781);
-const {
-	createBrotliCompress,
-	createBrotliDecompress,
-	createGzip,
-	createGunzip,
-	constants: zConstants
-} = __webpack_require__(59796);
-const createHash = __webpack_require__(49835);
-const { dirname, join, mkdirp } = __webpack_require__(17139);
-const memoize = __webpack_require__(78676);
-const SerializerMiddleware = __webpack_require__(83137);
+const ModuleNotFoundError = __webpack_require__(32882);
+const LazySet = __webpack_require__(38938);
 
-/** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 
-/*
-Format:
+/**
+ * @template T
+ * @typedef {Object} MatchedConfigs
+ * @property {Map<string, T>} resolved
+ * @property {Map<string, T>} unresolved
+ * @property {Map<string, T>} prefixed
+ */
 
-File -> Header Section*
+/** @type {ResolveOptionsWithDependencyType} */
+const RESOLVE_OPTIONS = { dependencyType: "esm" };
 
-Version -> u32
-AmountOfSections -> u32
-SectionSize -> i32 (if less than zero represents lazy value)
+/**
+ * @template T
+ * @param {Compilation} compilation the compilation
+ * @param {[string, T][]} configs to be processed configs
+ * @returns {Promise<MatchedConfigs<T>>} resolved matchers
+ */
+exports.resolveMatchedConfigs = (compilation, configs) => {
+	/** @type {Map<string, T>} */
+	const resolved = new Map();
+	/** @type {Map<string, T>} */
+	const unresolved = new Map();
+	/** @type {Map<string, T>} */
+	const prefixed = new Map();
+	const resolveContext = {
+		/** @type {LazySet<string>} */
+		fileDependencies: new LazySet(),
+		/** @type {LazySet<string>} */
+		contextDependencies: new LazySet(),
+		/** @type {LazySet<string>} */
+		missingDependencies: new LazySet()
+	};
+	const resolver = compilation.resolverFactory.get("normal", RESOLVE_OPTIONS);
+	const context = compilation.compiler.context;
 
-Header -> Version AmountOfSections SectionSize*
+	return Promise.all(
+		configs.map(([request, config]) => {
+			if (/^\.\.?(\/|$)/.test(request)) {
+				// relative request
+				return new Promise(resolve => {
+					resolver.resolve(
+						{},
+						context,
+						request,
+						resolveContext,
+						(err, result) => {
+							if (err || result === false) {
+								err = err || new Error(`Can't resolve ${request}`);
+								compilation.errors.push(
+									new ModuleNotFoundError(null, err, {
+										name: `shared module ${request}`
+									})
+								);
+								return resolve();
+							}
+							resolved.set(result, config);
+							resolve();
+						}
+					);
+				});
+			} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+				// absolute path
+				resolved.set(request, config);
+			} else if (request.endsWith("/")) {
+				// module request prefix
+				prefixed.set(request, config);
+			} else {
+				// module request
+				unresolved.set(request, config);
+			}
+		})
+	).then(() => {
+		compilation.contextDependencies.addAll(resolveContext.contextDependencies);
+		compilation.fileDependencies.addAll(resolveContext.fileDependencies);
+		compilation.missingDependencies.addAll(resolveContext.missingDependencies);
+		return { resolved, unresolved, prefixed };
+	});
+};
 
-Buffer -> n bytes
-Section -> Buffer
 
-*/
+/***/ }),
 
-// "wpc" + 1 in little-endian
-const VERSION = 0x01637077;
+/***/ 84379:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-/**
- * @param {Buffer[]} buffers buffers
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const hashForName = (buffers, hashFunction) => {
-	const hash = createHash(hashFunction);
-	for (const buf of buffers) hash.update(buf);
-	return /** @type {string} */ (hash.digest("hex"));
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-const COMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
-const DECOMPRESSION_CHUNK_SIZE = 100 * 1024 * 1024;
 
-const writeUInt64LE = Buffer.prototype.writeBigUInt64LE
-	? (buf, value, offset) => {
-			buf.writeBigUInt64LE(BigInt(value), offset);
-	  }
-	: (buf, value, offset) => {
-			const low = value % 0x100000000;
-			const high = (value - low) / 0x100000000;
-			buf.writeUInt32LE(low, offset);
-			buf.writeUInt32LE(high, offset + 4);
-	  };
 
-const readUInt64LE = Buffer.prototype.readBigUInt64LE
-	? (buf, offset) => {
-			return Number(buf.readBigUInt64LE(offset));
-	  }
-	: (buf, offset) => {
-			const low = buf.readUInt32LE(offset);
-			const high = buf.readUInt32LE(offset + 4);
-			return high * 0x100000000 + low;
-	  };
+const { join, dirname, readJson } = __webpack_require__(17139);
+
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 /**
- * @typedef {Object} SerializeResult
- * @property {string | false} name
- * @property {number} size
- * @property {Promise=} backgroundJob
+ * @param {string} str maybe required version
+ * @returns {boolean} true, if it looks like a version
  */
+exports.isRequiredVersion = str => {
+	return /^([\d^=v<>~]|[*xX]$)/.test(str);
+};
 
 /**
- * @param {FileMiddleware} middleware this
- * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
- * @param {string | boolean} name file base name
- * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
- * @param {string | Hash} hashFunction hash function to use
- * @returns {Promise<SerializeResult>} resulting file pointer and promise
+ *
+ * @param {InputFileSystem} fs file system
+ * @param {string} directory directory to start looking into
+ * @param {string[]} descriptionFiles possible description filenames
+ * @param {function((Error | null)=, {data: object, path: string}=): void} callback callback
  */
-const serialize = async (
-	middleware,
-	data,
-	name,
-	writeFile,
-	hashFunction = "md4"
-) => {
-	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
-	const processedData = [];
-	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
-	const resultToLazy = new WeakMap();
-	/** @type {Buffer[]} */
-	let lastBuffers = undefined;
-	for (const item of await data) {
-		if (typeof item === "function") {
-			if (!SerializerMiddleware.isLazy(item))
-				throw new Error("Unexpected function");
-			if (!SerializerMiddleware.isLazy(item, middleware)) {
-				throw new Error(
-					"Unexpected lazy value with non-this target (can't pass through lazy values)"
-				);
-			}
-			lastBuffers = undefined;
-			const serializedInfo = SerializerMiddleware.getLazySerializedValue(item);
-			if (serializedInfo) {
-				if (typeof serializedInfo === "function") {
-					throw new Error(
-						"Unexpected lazy value with non-this target (can't pass through lazy values)"
-					);
-				} else {
-					processedData.push(serializedInfo);
-				}
-			} else {
-				const content = item();
-				if (content) {
-					const options = SerializerMiddleware.getLazyOptions(item);
-					processedData.push(
-						serialize(
-							middleware,
-							content,
-							(options && options.name) || true,
-							writeFile,
-							hashFunction
-						).then(result => {
-							/** @type {any} */ (item).options.size = result.size;
-							resultToLazy.set(result, item);
-							return result;
-						})
-					);
-				} else {
-					throw new Error(
-						"Unexpected falsy value returned by lazy value function"
-					);
+const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
+	let i = 0;
+	const tryLoadCurrent = () => {
+		if (i >= descriptionFiles.length) {
+			const parentDirectory = dirname(fs, directory);
+			if (!parentDirectory || parentDirectory === directory) return callback();
+			return getDescriptionFile(
+				fs,
+				parentDirectory,
+				descriptionFiles,
+				callback
+			);
+		}
+		const filePath = join(fs, directory, descriptionFiles[i]);
+		readJson(fs, filePath, (err, data) => {
+			if (err) {
+				if ("code" in err && err.code === "ENOENT") {
+					i++;
+					return tryLoadCurrent();
 				}
+				return callback(err);
 			}
-		} else if (item) {
-			if (lastBuffers) {
-				lastBuffers.push(item);
-			} else {
-				lastBuffers = [item];
-				processedData.push(lastBuffers);
+			if (!data || typeof data !== "object" || Array.isArray(data)) {
+				return callback(
+					new Error(`Description file ${filePath} is not an object`)
+				);
 			}
-		} else {
-			throw new Error("Unexpected falsy value in items array");
-		}
-	}
-	/** @type {Promise<any>[]} */
-	const backgroundJobs = [];
-	const resolvedData = (
-		await Promise.all(
-			/** @type {Promise<Buffer[] | Buffer | SerializeResult>[]} */ (
-				processedData
-			)
-		)
-	).map(item => {
-		if (Array.isArray(item) || Buffer.isBuffer(item)) return item;
+			callback(null, { data, path: filePath });
+		});
+	};
+	tryLoadCurrent();
+};
+exports.getDescriptionFile = getDescriptionFile;
 
-		backgroundJobs.push(item.backgroundJob);
-		// create pointer buffer from size and name
-		const name = /** @type {string} */ (item.name);
-		const nameBuffer = Buffer.from(name);
-		const buf = Buffer.allocUnsafe(8 + nameBuffer.length);
-		writeUInt64LE(buf, item.size, 0);
-		nameBuffer.copy(buf, 8, 0);
-		const lazy = resultToLazy.get(item);
-		SerializerMiddleware.setLazySerializedValue(lazy, buf);
-		return buf;
-	});
-	const lengths = [];
-	for (const item of resolvedData) {
-		if (Array.isArray(item)) {
-			let l = 0;
-			for (const b of item) l += b.length;
-			while (l > 0x7fffffff) {
-				lengths.push(0x7fffffff);
-				l -= 0x7fffffff;
-			}
-			lengths.push(l);
-		} else if (item) {
-			lengths.push(-item.length);
-		} else {
-			throw new Error("Unexpected falsy value in resolved data " + item);
-		}
+exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
+	if (
+		data.optionalDependencies &&
+		typeof data.optionalDependencies === "object" &&
+		packageName in data.optionalDependencies
+	) {
+		return data.optionalDependencies[packageName];
 	}
-	const header = Buffer.allocUnsafe(8 + lengths.length * 4);
-	header.writeUInt32LE(VERSION, 0);
-	header.writeUInt32LE(lengths.length, 4);
-	for (let i = 0; i < lengths.length; i++) {
-		header.writeInt32LE(lengths[i], 8 + i * 4);
+	if (
+		data.dependencies &&
+		typeof data.dependencies === "object" &&
+		packageName in data.dependencies
+	) {
+		return data.dependencies[packageName];
 	}
-	const buf = [header];
-	for (const item of resolvedData) {
-		if (Array.isArray(item)) {
-			for (const b of item) buf.push(b);
-		} else if (item) {
-			buf.push(item);
-		}
+	if (
+		data.peerDependencies &&
+		typeof data.peerDependencies === "object" &&
+		packageName in data.peerDependencies
+	) {
+		return data.peerDependencies[packageName];
 	}
-	if (name === true) {
-		name = hashForName(buf, hashFunction);
+	if (
+		data.devDependencies &&
+		typeof data.devDependencies === "object" &&
+		packageName in data.devDependencies
+	) {
+		return data.devDependencies[packageName];
 	}
-	backgroundJobs.push(writeFile(name, buf));
-	let size = 0;
-	for (const b of buf) size += b.length;
-	return {
-		size,
-		name,
-		backgroundJob:
-			backgroundJobs.length === 1
-				? backgroundJobs[0]
-				: Promise.all(backgroundJobs)
-	};
 };
 
+
+/***/ }),
+
+/***/ 71760:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const util = __webpack_require__(73837);
+const ModuleDependency = __webpack_require__(80321);
+const formatLocation = __webpack_require__(16734);
+const { LogType } = __webpack_require__(32597);
+const AggressiveSplittingPlugin = __webpack_require__(15543);
+const SizeLimitsPlugin = __webpack_require__(32557);
+const { countIterable } = __webpack_require__(39104);
+const {
+	compareLocations,
+	compareChunksById,
+	compareNumbers,
+	compareIds,
+	concatComparators,
+	compareSelect,
+	compareModulesByIdentifier
+} = __webpack_require__(29579);
+const { makePathsRelative, parseResource } = __webpack_require__(82186);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").Asset} Asset */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleProfile")} ModuleProfile */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @template T @typedef {import("../util/comparators").Comparator<T>} Comparator<T> */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
+/** @typedef {import("./StatsFactory")} StatsFactory */
+/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
+
+/** @typedef {KnownStatsCompilation & Record<string, any>} StatsCompilation */
 /**
- * @param {FileMiddleware} middleware this
- * @param {string | false} name filename
- * @param {function(string | false): Promise<Buffer[]>} readFile read content of a file
- * @returns {Promise<BufferSerializableType[]>} deserialized data
+ * @typedef {Object} KnownStatsCompilation
+ * @property {any=} env
+ * @property {string=} name
+ * @property {string=} hash
+ * @property {string=} version
+ * @property {number=} time
+ * @property {number=} builtAt
+ * @property {boolean=} needAdditionalPass
+ * @property {string=} publicPath
+ * @property {string=} outputPath
+ * @property {Record<string, string[]>=} assetsByChunkName
+ * @property {StatsAsset[]=} assets
+ * @property {number=} filteredAssets
+ * @property {StatsChunk[]=} chunks
+ * @property {StatsModule[]=} modules
+ * @property {number=} filteredModules
+ * @property {Record<string, StatsChunkGroup>=} entrypoints
+ * @property {Record<string, StatsChunkGroup>=} namedChunkGroups
+ * @property {StatsError[]=} errors
+ * @property {number=} errorsCount
+ * @property {StatsError[]=} warnings
+ * @property {number=} warningsCount
+ * @property {StatsCompilation[]=} children
+ * @property {Record<string, StatsLogging>=} logging
  */
-const deserialize = async (middleware, name, readFile) => {
-	const contents = await readFile(name);
-	if (contents.length === 0) throw new Error("Empty file " + name);
-	let contentsIndex = 0;
-	let contentItem = contents[0];
-	let contentItemLength = contentItem.length;
-	let contentPosition = 0;
-	if (contentItemLength === 0) throw new Error("Empty file " + name);
-	const nextContent = () => {
-		contentsIndex++;
-		contentItem = contents[contentsIndex];
-		contentItemLength = contentItem.length;
-		contentPosition = 0;
-	};
-	const ensureData = n => {
-		if (contentPosition === contentItemLength) {
-			nextContent();
-		}
-		while (contentItemLength - contentPosition < n) {
-			const remaining = contentItem.slice(contentPosition);
-			let lengthFromNext = n - remaining.length;
-			const buffers = [remaining];
-			for (let i = contentsIndex + 1; i < contents.length; i++) {
-				const l = contents[i].length;
-				if (l > lengthFromNext) {
-					buffers.push(contents[i].slice(0, lengthFromNext));
-					contents[i] = contents[i].slice(lengthFromNext);
-					lengthFromNext = 0;
-					break;
-				} else {
-					buffers.push(contents[i]);
-					contentsIndex = i;
-					lengthFromNext -= l;
-				}
-			}
-			if (lengthFromNext > 0) throw new Error("Unexpected end of data");
-			contentItem = Buffer.concat(buffers, n);
-			contentItemLength = n;
-			contentPosition = 0;
-		}
-	};
-	const readUInt32LE = () => {
-		ensureData(4);
-		const value = contentItem.readUInt32LE(contentPosition);
-		contentPosition += 4;
-		return value;
-	};
-	const readInt32LE = () => {
-		ensureData(4);
-		const value = contentItem.readInt32LE(contentPosition);
-		contentPosition += 4;
-		return value;
-	};
-	const readSlice = l => {
-		ensureData(l);
-		if (contentPosition === 0 && contentItemLength === l) {
-			const result = contentItem;
-			if (contentsIndex + 1 < contents.length) {
-				nextContent();
-			} else {
-				contentPosition = l;
-			}
-			return result;
-		}
-		const result = contentItem.slice(contentPosition, contentPosition + l);
-		contentPosition += l;
-		// we clone the buffer here to allow the original content to be garbage collected
-		return l * 2 < contentItem.buffer.byteLength ? Buffer.from(result) : result;
-	};
-	const version = readUInt32LE();
-	if (version !== VERSION) {
-		throw new Error("Invalid file version");
-	}
-	const sectionCount = readUInt32LE();
-	const lengths = [];
-	let lastLengthPositive = false;
-	for (let i = 0; i < sectionCount; i++) {
-		const value = readInt32LE();
-		const valuePositive = value >= 0;
-		if (lastLengthPositive && valuePositive) {
-			lengths[lengths.length - 1] += value;
-		} else {
-			lengths.push(value);
-			lastLengthPositive = valuePositive;
+
+/** @typedef {KnownStatsLogging & Record<string, any>} StatsLogging */
+/**
+ * @typedef {Object} KnownStatsLogging
+ * @property {StatsLoggingEntry[]} entries
+ * @property {number} filteredEntries
+ * @property {boolean} debug
+ */
+
+/** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
+/**
+ * @typedef {Object} KnownStatsLoggingEntry
+ * @property {string} type
+ * @property {string} message
+ * @property {string[]=} trace
+ * @property {StatsLoggingEntry[]=} children
+ * @property {any[]=} args
+ * @property {number=} time
+ */
+
+/** @typedef {KnownStatsAsset & Record<string, any>} StatsAsset */
+/**
+ * @typedef {Object} KnownStatsAsset
+ * @property {string} type
+ * @property {string} name
+ * @property {AssetInfo} info
+ * @property {number} size
+ * @property {boolean} emitted
+ * @property {boolean} comparedForEmit
+ * @property {boolean} cached
+ * @property {StatsAsset[]=} related
+ * @property {(string|number)[]=} chunkNames
+ * @property {(string|number)[]=} chunkIdHints
+ * @property {(string|number)[]=} chunks
+ * @property {(string|number)[]=} auxiliaryChunkNames
+ * @property {(string|number)[]=} auxiliaryChunks
+ * @property {(string|number)[]=} auxiliaryChunkIdHints
+ * @property {number=} filteredRelated
+ * @property {boolean=} isOverSizeLimit
+ */
+
+/** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
+/**
+ * @typedef {Object} KnownStatsChunkGroup
+ * @property {string=} name
+ * @property {(string|number)[]=} chunks
+ * @property {({ name: string, size?: number })[]=} assets
+ * @property {number=} filteredAssets
+ * @property {number=} assetsSize
+ * @property {({ name: string, size?: number })[]=} auxiliaryAssets
+ * @property {number=} filteredAuxiliaryAssets
+ * @property {number=} auxiliaryAssetsSize
+ * @property {{ [x: string]: StatsChunkGroup[] }=} children
+ * @property {{ [x: string]: string[] }=} childAssets
+ * @property {boolean=} isOverSizeLimit
+ */
+
+/** @typedef {KnownStatsModule & Record<string, any>} StatsModule */
+/**
+ * @typedef {Object} KnownStatsModule
+ * @property {string=} type
+ * @property {string=} moduleType
+ * @property {string=} layer
+ * @property {string=} identifier
+ * @property {string=} name
+ * @property {string=} nameForCondition
+ * @property {number=} index
+ * @property {number=} preOrderIndex
+ * @property {number=} index2
+ * @property {number=} postOrderIndex
+ * @property {number=} size
+ * @property {{[x: string]: number}=} sizes
+ * @property {boolean=} cacheable
+ * @property {boolean=} built
+ * @property {boolean=} codeGenerated
+ * @property {boolean=} buildTimeExecuted
+ * @property {boolean=} cached
+ * @property {boolean=} optional
+ * @property {boolean=} orphan
+ * @property {string|number=} id
+ * @property {string|number=} issuerId
+ * @property {(string|number)[]=} chunks
+ * @property {(string|number)[]=} assets
+ * @property {boolean=} dependent
+ * @property {string=} issuer
+ * @property {string=} issuerName
+ * @property {StatsModuleIssuer[]=} issuerPath
+ * @property {boolean=} failed
+ * @property {number=} errors
+ * @property {number=} warnings
+ * @property {StatsProfile=} profile
+ * @property {StatsModuleReason[]=} reasons
+ * @property {(boolean | string[])=} usedExports
+ * @property {string[]=} providedExports
+ * @property {string[]=} optimizationBailout
+ * @property {number=} depth
+ * @property {StatsModule[]=} modules
+ * @property {number=} filteredModules
+ * @property {ReturnType<Source["source"]>=} source
+ */
+
+/** @typedef {KnownStatsProfile & Record<string, any>} StatsProfile */
+/**
+ * @typedef {Object} KnownStatsProfile
+ * @property {number} total
+ * @property {number} resolving
+ * @property {number} restoring
+ * @property {number} building
+ * @property {number} integration
+ * @property {number} storing
+ * @property {number} additionalResolving
+ * @property {number} additionalIntegration
+ * @property {number} factory
+ * @property {number} dependencies
+ */
+
+/** @typedef {KnownStatsModuleIssuer & Record<string, any>} StatsModuleIssuer */
+/**
+ * @typedef {Object} KnownStatsModuleIssuer
+ * @property {string=} identifier
+ * @property {string=} name
+ * @property {(string|number)=} id
+ * @property {StatsProfile=} profile
+ */
+
+/** @typedef {KnownStatsModuleReason & Record<string, any>} StatsModuleReason */
+/**
+ * @typedef {Object} KnownStatsModuleReason
+ * @property {string=} moduleIdentifier
+ * @property {string=} module
+ * @property {string=} moduleName
+ * @property {string=} resolvedModuleIdentifier
+ * @property {string=} resolvedModule
+ * @property {string=} type
+ * @property {boolean} active
+ * @property {string=} explanation
+ * @property {string=} userRequest
+ * @property {string=} loc
+ * @property {(string|number)=} moduleId
+ * @property {(string|number)=} resolvedModuleId
+ */
+
+/** @typedef {KnownStatsChunk & Record<string, any>} StatsChunk */
+/**
+ * @typedef {Object} KnownStatsChunk
+ * @property {boolean} rendered
+ * @property {boolean} initial
+ * @property {boolean} entry
+ * @property {boolean} recorded
+ * @property {string=} reason
+ * @property {number} size
+ * @property {Record<string, number>=} sizes
+ * @property {string[]=} names
+ * @property {string[]=} idHints
+ * @property {string[]=} runtime
+ * @property {string[]=} files
+ * @property {string[]=} auxiliaryFiles
+ * @property {string} hash
+ * @property {Record<string, (string|number)[]>=} childrenByOrder
+ * @property {(string|number)=} id
+ * @property {(string|number)[]=} siblings
+ * @property {(string|number)[]=} parents
+ * @property {(string|number)[]=} children
+ * @property {StatsModule[]=} modules
+ * @property {number=} filteredModules
+ * @property {StatsChunkOrigin[]=} origins
+ */
+
+/** @typedef {KnownStatsChunkOrigin & Record<string, any>} StatsChunkOrigin */
+/**
+ * @typedef {Object} KnownStatsChunkOrigin
+ * @property {string=} module
+ * @property {string=} moduleIdentifier
+ * @property {string=} moduleName
+ * @property {string=} loc
+ * @property {string=} request
+ * @property {(string|number)=} moduleId
+ */
+
+/** @typedef {KnownStatsModuleTraceItem & Record<string, any>} StatsModuleTraceItem */
+/**
+ * @typedef {Object} KnownStatsModuleTraceItem
+ * @property {string=} originIdentifier
+ * @property {string=} originName
+ * @property {string=} moduleIdentifier
+ * @property {string=} moduleName
+ * @property {StatsModuleTraceDependency[]=} dependencies
+ * @property {(string|number)=} originId
+ * @property {(string|number)=} moduleId
+ */
+
+/** @typedef {KnownStatsModuleTraceDependency & Record<string, any>} StatsModuleTraceDependency */
+/**
+ * @typedef {Object} KnownStatsModuleTraceDependency
+ * @property {string=} loc
+ */
+
+/** @typedef {KnownStatsError & Record<string, any>} StatsError */
+/**
+ * @typedef {Object} KnownStatsError
+ * @property {string} message
+ * @property {string=} chunkName
+ * @property {boolean=} chunkEntry
+ * @property {boolean=} chunkInitial
+ * @property {string=} file
+ * @property {string=} moduleIdentifier
+ * @property {string=} moduleName
+ * @property {string=} loc
+ * @property {string|number=} chunkId
+ * @property {string|number=} moduleId
+ * @property {StatsModuleTraceItem[]=} moduleTrace
+ * @property {any=} details
+ * @property {string=} stack
+ */
+
+/** @typedef {Asset & { type: string, related: PreprocessedAsset[] }} PreprocessedAsset */
+
+/**
+ * @template T
+ * @template O
+ * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
+ */
+
+/**
+ * @typedef {Object} SimpleExtractors
+ * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
+ * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
+ * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
+ * @property {ExtractorsByOption<{ name: string, chunkGroup: ChunkGroup }, StatsChunkGroup>} chunkGroup
+ * @property {ExtractorsByOption<Module, StatsModule>} module
+ * @property {ExtractorsByOption<Module, StatsModule>} module$visible
+ * @property {ExtractorsByOption<Module, StatsModuleIssuer>} moduleIssuer
+ * @property {ExtractorsByOption<ModuleProfile, StatsProfile>} profile
+ * @property {ExtractorsByOption<ModuleGraphConnection, StatsModuleReason>} moduleReason
+ * @property {ExtractorsByOption<Chunk, StatsChunk>} chunk
+ * @property {ExtractorsByOption<OriginRecord, StatsChunkOrigin>} chunkOrigin
+ * @property {ExtractorsByOption<WebpackError, StatsError>} error
+ * @property {ExtractorsByOption<WebpackError, StatsError>} warning
+ * @property {ExtractorsByOption<{ origin: Module, module: Module }, StatsModuleTraceItem>} moduleTraceItem
+ * @property {ExtractorsByOption<Dependency, StatsModuleTraceDependency>} moduleTraceDependency
+ */
+
+/**
+ * @template T
+ * @template I
+ * @param {Iterable<T>} items items to select from
+ * @param {function(T): Iterable<I>} selector selector function to select values from item
+ * @returns {I[]} array of values
+ */
+const uniqueArray = (items, selector) => {
+	/** @type {Set<I>} */
+	const set = new Set();
+	for (const item of items) {
+		for (const i of selector(item)) {
+			set.add(i);
 		}
 	}
-	const result = [];
-	for (let length of lengths) {
-		if (length < 0) {
-			const slice = readSlice(-length);
-			const size = Number(readUInt64LE(slice, 0));
-			const nameBuffer = slice.slice(8);
-			const name = nameBuffer.toString();
-			result.push(
-				SerializerMiddleware.createLazy(
-					memoize(() => deserialize(middleware, name, readFile)),
-					middleware,
-					{
-						name,
-						size
-					},
-					slice
-				)
-			);
-		} else {
-			if (contentPosition === contentItemLength) {
-				nextContent();
-			} else if (contentPosition !== 0) {
-				if (length <= contentItemLength - contentPosition) {
-					result.push(
-						Buffer.from(
-							contentItem.buffer,
-							contentItem.byteOffset + contentPosition,
-							length
+	return Array.from(set);
+};
+
+/**
+ * @template T
+ * @template I
+ * @param {Iterable<T>} items items to select from
+ * @param {function(T): Iterable<I>} selector selector function to select values from item
+ * @param {Comparator<I>} comparator comparator function
+ * @returns {I[]} array of values
+ */
+const uniqueOrderedArray = (items, selector, comparator) => {
+	return uniqueArray(items, selector).sort(comparator);
+};
+
+/** @template T @template R @typedef {{ [P in keyof T]: R }} MappedValues<T, R> */
+
+/**
+ * @template T
+ * @template R
+ * @param {T} obj object to be mapped
+ * @param {function(T[keyof T], keyof T): R} fn mapping function
+ * @returns {MappedValues<T, R>} mapped object
+ */
+const mapObject = (obj, fn) => {
+	const newObj = Object.create(null);
+	for (const key of Object.keys(obj)) {
+		newObj[key] = fn(obj[key], /** @type {keyof T} */ (key));
+	}
+	return newObj;
+};
+
+/**
+ * @param {Compilation} compilation the compilation
+ * @param {function(Compilation, string): any[]} getItems get items
+ * @returns {number} total number
+ */
+const countWithChildren = (compilation, getItems) => {
+	let count = getItems(compilation, "").length;
+	for (const child of compilation.children) {
+		count += countWithChildren(child, (c, type) =>
+			getItems(c, `.children[].compilation${type}`)
+		);
+	}
+	return count;
+};
+
+/** @type {ExtractorsByOption<WebpackError | string, StatsError>} */
+const EXTRACT_ERROR = {
+	_: (object, error, context, { requestShortener }) => {
+		// TODO webpack 6 disallow strings in the errors/warnings list
+		if (typeof error === "string") {
+			object.message = error;
+		} else {
+			if (error.chunk) {
+				object.chunkName = error.chunk.name;
+				object.chunkEntry = error.chunk.hasRuntime();
+				object.chunkInitial = error.chunk.canBeInitial();
+			}
+			if (error.file) {
+				object.file = error.file;
+			}
+			if (error.module) {
+				object.moduleIdentifier = error.module.identifier();
+				object.moduleName = error.module.readableIdentifier(requestShortener);
+			}
+			if (error.loc) {
+				object.loc = formatLocation(error.loc);
+			}
+			object.message = error.message;
+		}
+	},
+	ids: (object, error, { compilation: { chunkGraph } }) => {
+		if (typeof error !== "string") {
+			if (error.chunk) {
+				object.chunkId = error.chunk.id;
+			}
+			if (error.module) {
+				object.moduleId = chunkGraph.getModuleId(error.module);
+			}
+		}
+	},
+	moduleTrace: (object, error, context, options, factory) => {
+		if (typeof error !== "string" && error.module) {
+			const {
+				type,
+				compilation: { moduleGraph }
+			} = context;
+			/** @type {Set<Module>} */
+			const visitedModules = new Set();
+			const moduleTrace = [];
+			let current = error.module;
+			while (current) {
+				if (visitedModules.has(current)) break; // circular (technically impossible, but how knows)
+				visitedModules.add(current);
+				const origin = moduleGraph.getIssuer(current);
+				if (!origin) break;
+				moduleTrace.push({ origin, module: current });
+				current = origin;
+			}
+			object.moduleTrace = factory.create(
+				`${type}.moduleTrace`,
+				moduleTrace,
+				context
+			);
+		}
+	},
+	errorDetails: (
+		object,
+		error,
+		{ type, compilation, cachedGetErrors, cachedGetWarnings },
+		{ errorDetails }
+	) => {
+		if (
+			typeof error !== "string" &&
+			(errorDetails === true ||
+				(type.endsWith(".error") && cachedGetErrors(compilation).length < 3))
+		) {
+			object.details = error.details;
+		}
+	},
+	errorStack: (object, error) => {
+		if (typeof error !== "string") {
+			object.stack = error.stack;
+		}
+	}
+};
+
+/** @type {SimpleExtractors} */
+const SIMPLE_EXTRACTORS = {
+	compilation: {
+		_: (object, compilation, context, options) => {
+			if (!context.makePathsRelative) {
+				context.makePathsRelative = makePathsRelative.bindContextCache(
+					compilation.compiler.context,
+					compilation.compiler.root
+				);
+			}
+			if (!context.cachedGetErrors) {
+				const map = new WeakMap();
+				context.cachedGetErrors = compilation => {
+					return (
+						map.get(compilation) ||
+						(errors => (map.set(compilation, errors), errors))(
+							compilation.getErrors()
 						)
 					);
-					contentPosition += length;
-					length = 0;
-				} else {
-					const l = contentItemLength - contentPosition;
-					result.push(
-						Buffer.from(
-							contentItem.buffer,
-							contentItem.byteOffset + contentPosition,
-							l
+				};
+			}
+			if (!context.cachedGetWarnings) {
+				const map = new WeakMap();
+				context.cachedGetWarnings = compilation => {
+					return (
+						map.get(compilation) ||
+						(warnings => (map.set(compilation, warnings), warnings))(
+							compilation.getWarnings()
 						)
 					);
-					length -= l;
-					contentPosition = contentItemLength;
+				};
+			}
+			if (compilation.name) {
+				object.name = compilation.name;
+			}
+			if (compilation.needAdditionalPass) {
+				object.needAdditionalPass = true;
+			}
+
+			const { logging, loggingDebug, loggingTrace } = options;
+			if (logging || (loggingDebug && loggingDebug.length > 0)) {
+				const util = __webpack_require__(73837);
+				object.logging = {};
+				let acceptedTypes;
+				let collapsedGroups = false;
+				switch (logging) {
+					default:
+						acceptedTypes = new Set();
+						break;
+					case "error":
+						acceptedTypes = new Set([LogType.error]);
+						break;
+					case "warn":
+						acceptedTypes = new Set([LogType.error, LogType.warn]);
+						break;
+					case "info":
+						acceptedTypes = new Set([
+							LogType.error,
+							LogType.warn,
+							LogType.info
+						]);
+						break;
+					case "log":
+						acceptedTypes = new Set([
+							LogType.error,
+							LogType.warn,
+							LogType.info,
+							LogType.log,
+							LogType.group,
+							LogType.groupEnd,
+							LogType.groupCollapsed,
+							LogType.clear
+						]);
+						break;
+					case "verbose":
+						acceptedTypes = new Set([
+							LogType.error,
+							LogType.warn,
+							LogType.info,
+							LogType.log,
+							LogType.group,
+							LogType.groupEnd,
+							LogType.groupCollapsed,
+							LogType.profile,
+							LogType.profileEnd,
+							LogType.time,
+							LogType.status,
+							LogType.clear
+						]);
+						collapsedGroups = true;
+						break;
 				}
-			} else {
-				if (length >= contentItemLength) {
-					result.push(contentItem);
-					length -= contentItemLength;
-					contentPosition = contentItemLength;
-				} else {
-					result.push(
-						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
-					);
-					contentPosition += length;
-					length = 0;
+				const cachedMakePathsRelative = makePathsRelative.bindContextCache(
+					options.context,
+					compilation.compiler.root
+				);
+				let depthInCollapsedGroup = 0;
+				for (const [origin, logEntries] of compilation.logging) {
+					const debugMode = loggingDebug.some(fn => fn(origin));
+					if (logging === false && !debugMode) continue;
+					/** @type {KnownStatsLoggingEntry[]} */
+					const groupStack = [];
+					/** @type {KnownStatsLoggingEntry[]} */
+					const rootList = [];
+					let currentList = rootList;
+					let processedLogEntries = 0;
+					for (const entry of logEntries) {
+						let type = entry.type;
+						if (!debugMode && !acceptedTypes.has(type)) continue;
+
+						// Expand groups in verbose and debug modes
+						if (
+							type === LogType.groupCollapsed &&
+							(debugMode || collapsedGroups)
+						)
+							type = LogType.group;
+
+						if (depthInCollapsedGroup === 0) {
+							processedLogEntries++;
+						}
+
+						if (type === LogType.groupEnd) {
+							groupStack.pop();
+							if (groupStack.length > 0) {
+								currentList = groupStack[groupStack.length - 1].children;
+							} else {
+								currentList = rootList;
+							}
+							if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
+							continue;
+						}
+						let message = undefined;
+						if (entry.type === LogType.time) {
+							message = `${entry.args[0]}: ${
+								entry.args[1] * 1000 + entry.args[2] / 1000000
+							} ms`;
+						} else if (entry.args && entry.args.length > 0) {
+							message = util.format(entry.args[0], ...entry.args.slice(1));
+						}
+						/** @type {KnownStatsLoggingEntry} */
+						const newEntry = {
+							...entry,
+							type,
+							message,
+							trace: loggingTrace ? entry.trace : undefined,
+							children:
+								type === LogType.group || type === LogType.groupCollapsed
+									? []
+									: undefined
+						};
+						currentList.push(newEntry);
+						if (newEntry.children) {
+							groupStack.push(newEntry);
+							currentList = newEntry.children;
+							if (depthInCollapsedGroup > 0) {
+								depthInCollapsedGroup++;
+							} else if (type === LogType.groupCollapsed) {
+								depthInCollapsedGroup = 1;
+							}
+						}
+					}
+					let name = cachedMakePathsRelative(origin).replace(/\|/g, " ");
+					if (name in object.logging) {
+						let i = 1;
+						while (`${name}#${i}` in object.logging) {
+							i++;
+						}
+						name = `${name}#${i}`;
+					}
+					object.logging[name] = {
+						entries: rootList,
+						filteredEntries: logEntries.length - processedLogEntries,
+						debug: debugMode
+					};
 				}
 			}
-			while (length > 0) {
-				nextContent();
-				if (length >= contentItemLength) {
-					result.push(contentItem);
-					length -= contentItemLength;
-					contentPosition = contentItemLength;
-				} else {
-					result.push(
-						Buffer.from(contentItem.buffer, contentItem.byteOffset, length)
-					);
-					contentPosition += length;
-					length = 0;
+		},
+		hash: (object, compilation) => {
+			object.hash = compilation.hash;
+		},
+		version: object => {
+			object.version = (__webpack_require__(32702)/* .version */ .i8);
+		},
+		env: (object, compilation, context, { _env }) => {
+			object.env = _env;
+		},
+		timings: (object, compilation) => {
+			object.time = compilation.endTime - compilation.startTime;
+		},
+		builtAt: (object, compilation) => {
+			object.builtAt = compilation.endTime;
+		},
+		publicPath: (object, compilation) => {
+			object.publicPath = compilation.getPath(
+				compilation.outputOptions.publicPath
+			);
+		},
+		outputPath: (object, compilation) => {
+			object.outputPath = compilation.outputOptions.path;
+		},
+		assets: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			/** @type {Map<string, Chunk[]>} */
+			const compilationFileToChunks = new Map();
+			/** @type {Map<string, Chunk[]>} */
+			const compilationAuxiliaryFileToChunks = new Map();
+			for (const chunk of compilation.chunks) {
+				for (const file of chunk.files) {
+					let array = compilationFileToChunks.get(file);
+					if (array === undefined) {
+						array = [];
+						compilationFileToChunks.set(file, array);
+					}
+					array.push(chunk);
+				}
+				for (const file of chunk.auxiliaryFiles) {
+					let array = compilationAuxiliaryFileToChunks.get(file);
+					if (array === undefined) {
+						array = [];
+						compilationAuxiliaryFileToChunks.set(file, array);
+					}
+					array.push(chunk);
+				}
+			}
+			/** @type {Map<string, PreprocessedAsset>} */
+			const assetMap = new Map();
+			/** @type {Set<PreprocessedAsset>} */
+			const assets = new Set();
+			for (const asset of compilation.getAssets()) {
+				/** @type {PreprocessedAsset} */
+				const item = {
+					...asset,
+					type: "asset",
+					related: undefined
+				};
+				assets.add(item);
+				assetMap.set(asset.name, item);
+			}
+			for (const item of assetMap.values()) {
+				const related = item.info.related;
+				if (!related) continue;
+				for (const type of Object.keys(related)) {
+					const relatedEntry = related[type];
+					const deps = Array.isArray(relatedEntry)
+						? relatedEntry
+						: [relatedEntry];
+					for (const dep of deps) {
+						const depItem = assetMap.get(dep);
+						if (!depItem) continue;
+						assets.delete(depItem);
+						depItem.type = type;
+						item.related = item.related || [];
+						item.related.push(depItem);
+					}
+				}
+			}
+
+			object.assetsByChunkName = {};
+			for (const [file, chunks] of compilationFileToChunks) {
+				for (const chunk of chunks) {
+					const name = chunk.name;
+					if (!name) continue;
+					if (
+						!Object.prototype.hasOwnProperty.call(
+							object.assetsByChunkName,
+							name
+						)
+					) {
+						object.assetsByChunkName[name] = [];
+					}
+					object.assetsByChunkName[name].push(file);
+				}
+			}
+
+			const groupedAssets = factory.create(
+				`${type}.assets`,
+				Array.from(assets),
+				{
+					...context,
+					compilationFileToChunks,
+					compilationAuxiliaryFileToChunks
+				}
+			);
+			const limited = spaceLimited(groupedAssets, options.assetsSpace);
+			object.assets = limited.children;
+			object.filteredAssets = limited.filteredChildren;
+		},
+		chunks: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			object.chunks = factory.create(
+				`${type}.chunks`,
+				Array.from(compilation.chunks),
+				context
+			);
+		},
+		modules: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			const array = Array.from(compilation.modules);
+			const groupedModules = factory.create(`${type}.modules`, array, context);
+			const limited = spaceLimited(groupedModules, options.modulesSpace);
+			object.modules = limited.children;
+			object.filteredModules = limited.filteredChildren;
+		},
+		entrypoints: (
+			object,
+			compilation,
+			context,
+			{ entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren },
+			factory
+		) => {
+			const { type } = context;
+			const array = Array.from(compilation.entrypoints, ([key, value]) => ({
+				name: key,
+				chunkGroup: value
+			}));
+			if (entrypoints === "auto" && !chunkGroups) {
+				if (array.length > 5) return;
+				if (
+					!chunkGroupChildren &&
+					array.every(({ chunkGroup }) => {
+						if (chunkGroup.chunks.length !== 1) return false;
+						const chunk = chunkGroup.chunks[0];
+						return (
+							chunk.files.size === 1 &&
+							(!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0)
+						);
+					})
+				) {
+					return;
 				}
 			}
+			object.entrypoints = factory.create(
+				`${type}.entrypoints`,
+				array,
+				context
+			);
+		},
+		chunkGroups: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			const array = Array.from(
+				compilation.namedChunkGroups,
+				([key, value]) => ({
+					name: key,
+					chunkGroup: value
+				})
+			);
+			object.namedChunkGroups = factory.create(
+				`${type}.namedChunkGroups`,
+				array,
+				context
+			);
+		},
+		errors: (object, compilation, context, options, factory) => {
+			const { type, cachedGetErrors } = context;
+			object.errors = factory.create(
+				`${type}.errors`,
+				cachedGetErrors(compilation),
+				context
+			);
+		},
+		errorsCount: (object, compilation, { cachedGetErrors }) => {
+			object.errorsCount = countWithChildren(compilation, c =>
+				cachedGetErrors(c)
+			);
+		},
+		warnings: (object, compilation, context, options, factory) => {
+			const { type, cachedGetWarnings } = context;
+			object.warnings = factory.create(
+				`${type}.warnings`,
+				cachedGetWarnings(compilation),
+				context
+			);
+		},
+		warningsCount: (
+			object,
+			compilation,
+			context,
+			{ warningsFilter },
+			factory
+		) => {
+			const { type, cachedGetWarnings } = context;
+			object.warningsCount = countWithChildren(compilation, (c, childType) => {
+				if (!warningsFilter && warningsFilter.length === 0)
+					return cachedGetWarnings(c);
+				return factory
+					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
+					.filter(warning => {
+						const warningString = Object.keys(warning)
+							.map(key => `${warning[key]}`)
+							.join("\n");
+						return !warningsFilter.some(filter =>
+							filter(warning, warningString)
+						);
+					});
+			});
+		},
+		errorDetails: (
+			object,
+			compilation,
+			{ cachedGetErrors, cachedGetWarnings },
+			{ errorDetails, errors, warnings }
+		) => {
+			if (errorDetails === "auto") {
+				if (warnings) {
+					const warnings = cachedGetWarnings(compilation);
+					object.filteredWarningDetailsCount = warnings
+						.map(e => typeof e !== "string" && e.details)
+						.filter(Boolean).length;
+				}
+				if (errors) {
+					const errors = cachedGetErrors(compilation);
+					if (errors.length >= 3) {
+						object.filteredErrorDetailsCount = errors
+							.map(e => typeof e !== "string" && e.details)
+							.filter(Boolean).length;
+					}
+				}
+			}
+		},
+		children: (object, compilation, context, options, factory) => {
+			const { type } = context;
+			object.children = factory.create(
+				`${type}.children`,
+				compilation.children,
+				context
+			);
+		}
+	},
+	asset: {
+		_: (object, asset, context, options, factory) => {
+			const { compilation } = context;
+			object.type = asset.type;
+			object.name = asset.name;
+			object.size = asset.source.size();
+			object.emitted = compilation.emittedAssets.has(asset.name);
+			object.comparedForEmit = compilation.comparedForEmitAssets.has(
+				asset.name
+			);
+			const cached = !object.emitted && !object.comparedForEmit;
+			object.cached = cached;
+			object.info = asset.info;
+			if (!cached || options.cachedAssets) {
+				Object.assign(
+					object,
+					factory.create(`${context.type}$visible`, asset, context)
+				);
+			}
+		}
+	},
+	asset$visible: {
+		_: (
+			object,
+			asset,
+			{ compilation, compilationFileToChunks, compilationAuxiliaryFileToChunks }
+		) => {
+			const chunks = compilationFileToChunks.get(asset.name) || [];
+			const auxiliaryChunks =
+				compilationAuxiliaryFileToChunks.get(asset.name) || [];
+			object.chunkNames = uniqueOrderedArray(
+				chunks,
+				c => (c.name ? [c.name] : []),
+				compareIds
+			);
+			object.chunkIdHints = uniqueOrderedArray(
+				chunks,
+				c => Array.from(c.idNameHints),
+				compareIds
+			);
+			object.auxiliaryChunkNames = uniqueOrderedArray(
+				auxiliaryChunks,
+				c => (c.name ? [c.name] : []),
+				compareIds
+			);
+			object.auxiliaryChunkIdHints = uniqueOrderedArray(
+				auxiliaryChunks,
+				c => Array.from(c.idNameHints),
+				compareIds
+			);
+			object.filteredRelated = asset.related ? asset.related.length : undefined;
+		},
+		relatedAssets: (object, asset, context, options, factory) => {
+			const { type } = context;
+			object.related = factory.create(
+				`${type.slice(0, -8)}.related`,
+				asset.related,
+				context
+			);
+			object.filteredRelated = asset.related
+				? asset.related.length - object.related.length
+				: undefined;
+		},
+		ids: (
+			object,
+			asset,
+			{ compilationFileToChunks, compilationAuxiliaryFileToChunks }
+		) => {
+			const chunks = compilationFileToChunks.get(asset.name) || [];
+			const auxiliaryChunks =
+				compilationAuxiliaryFileToChunks.get(asset.name) || [];
+			object.chunks = uniqueOrderedArray(chunks, c => c.ids, compareIds);
+			object.auxiliaryChunks = uniqueOrderedArray(
+				auxiliaryChunks,
+				c => c.ids,
+				compareIds
+			);
+		},
+		performance: (object, asset) => {
+			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(asset.source);
+		}
+	},
+	chunkGroup: {
+		_: (
+			object,
+			{ name, chunkGroup },
+			{ compilation, compilation: { moduleGraph, chunkGraph } },
+			{ ids, chunkGroupAuxiliary, chunkGroupChildren, chunkGroupMaxAssets }
+		) => {
+			const children =
+				chunkGroupChildren &&
+				chunkGroup.getChildrenByOrders(moduleGraph, chunkGraph);
+			/**
+			 * @param {string} name Name
+			 * @returns {{ name: string, size: number }} Asset object
+			 */
+			const toAsset = name => {
+				const asset = compilation.getAsset(name);
+				return {
+					name,
+					size: asset ? asset.info.size : -1
+				};
+			};
+			/** @type {(total: number, asset: { size: number }) => number} */
+			const sizeReducer = (total, { size }) => total + size;
+			const assets = uniqueArray(chunkGroup.chunks, c => c.files).map(toAsset);
+			const auxiliaryAssets = uniqueOrderedArray(
+				chunkGroup.chunks,
+				c => c.auxiliaryFiles,
+				compareIds
+			).map(toAsset);
+			const assetsSize = assets.reduce(sizeReducer, 0);
+			const auxiliaryAssetsSize = auxiliaryAssets.reduce(sizeReducer, 0);
+			/** @type {KnownStatsChunkGroup} */
+			const statsChunkGroup = {
+				name,
+				chunks: ids ? chunkGroup.chunks.map(c => c.id) : undefined,
+				assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
+				filteredAssets:
+					assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
+				assetsSize,
+				auxiliaryAssets:
+					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+						? auxiliaryAssets
+						: undefined,
+				filteredAuxiliaryAssets:
+					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
+						? 0
+						: auxiliaryAssets.length,
+				auxiliaryAssetsSize,
+				children: children
+					? mapObject(children, groups =>
+							groups.map(group => {
+								const assets = uniqueArray(group.chunks, c => c.files).map(
+									toAsset
+								);
+								const auxiliaryAssets = uniqueOrderedArray(
+									group.chunks,
+									c => c.auxiliaryFiles,
+									compareIds
+								).map(toAsset);
+
+								/** @type {KnownStatsChunkGroup} */
+								const childStatsChunkGroup = {
+									name: group.name,
+									chunks: ids ? group.chunks.map(c => c.id) : undefined,
+									assets:
+										assets.length <= chunkGroupMaxAssets ? assets : undefined,
+									filteredAssets:
+										assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
+									auxiliaryAssets:
+										chunkGroupAuxiliary &&
+										auxiliaryAssets.length <= chunkGroupMaxAssets
+											? auxiliaryAssets
+											: undefined,
+									filteredAuxiliaryAssets:
+										chunkGroupAuxiliary &&
+										auxiliaryAssets.length <= chunkGroupMaxAssets
+											? 0
+											: auxiliaryAssets.length
+								};
+
+								return childStatsChunkGroup;
+							})
+					  )
+					: undefined,
+				childAssets: children
+					? mapObject(children, groups => {
+							/** @type {Set<string>} */
+							const set = new Set();
+							for (const group of groups) {
+								for (const chunk of group.chunks) {
+									for (const asset of chunk.files) {
+										set.add(asset);
+									}
+								}
+							}
+							return Array.from(set);
+					  })
+					: undefined
+			};
+			Object.assign(object, statsChunkGroup);
+		},
+		performance: (object, { chunkGroup }) => {
+			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(chunkGroup);
+		}
+	},
+	module: {
+		_: (object, module, context, options, factory) => {
+			const { compilation, type } = context;
+			const built = compilation.builtModules.has(module);
+			const codeGenerated = compilation.codeGeneratedModules.has(module);
+			const buildTimeExecuted =
+				compilation.buildTimeExecutedModules.has(module);
+			/** @type {{[x: string]: number}} */
+			const sizes = {};
+			for (const sourceType of module.getSourceTypes()) {
+				sizes[sourceType] = module.size(sourceType);
+			}
+			/** @type {KnownStatsModule} */
+			const statsModule = {
+				type: "module",
+				moduleType: module.type,
+				layer: module.layer,
+				size: module.size(),
+				sizes,
+				built,
+				codeGenerated,
+				buildTimeExecuted,
+				cached: !built && !codeGenerated
+			};
+			Object.assign(object, statsModule);
+
+			if (built || codeGenerated || options.cachedModules) {
+				Object.assign(
+					object,
+					factory.create(`${type}$visible`, module, context)
+				);
+			}
+		}
+	},
+	module$visible: {
+		_: (object, module, context, { requestShortener }, factory) => {
+			const { compilation, type, rootModules } = context;
+			const { moduleGraph } = compilation;
+			/** @type {Module[]} */
+			const path = [];
+			const issuer = moduleGraph.getIssuer(module);
+			let current = issuer;
+			while (current) {
+				path.push(current);
+				current = moduleGraph.getIssuer(current);
+			}
+			path.reverse();
+			const profile = moduleGraph.getProfile(module);
+			const errors = module.getErrors();
+			const errorsCount = errors !== undefined ? countIterable(errors) : 0;
+			const warnings = module.getWarnings();
+			const warningsCount =
+				warnings !== undefined ? countIterable(warnings) : 0;
+			/** @type {{[x: string]: number}} */
+			const sizes = {};
+			for (const sourceType of module.getSourceTypes()) {
+				sizes[sourceType] = module.size(sourceType);
+			}
+			/** @type {KnownStatsModule} */
+			const statsModule = {
+				identifier: module.identifier(),
+				name: module.readableIdentifier(requestShortener),
+				nameForCondition: module.nameForCondition(),
+				index: moduleGraph.getPreOrderIndex(module),
+				preOrderIndex: moduleGraph.getPreOrderIndex(module),
+				index2: moduleGraph.getPostOrderIndex(module),
+				postOrderIndex: moduleGraph.getPostOrderIndex(module),
+				cacheable: module.buildInfo.cacheable,
+				optional: module.isOptional(moduleGraph),
+				orphan:
+					!type.endsWith("module.modules[].module$visible") &&
+					compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
+				dependent: rootModules ? !rootModules.has(module) : undefined,
+				issuer: issuer && issuer.identifier(),
+				issuerName: issuer && issuer.readableIdentifier(requestShortener),
+				issuerPath:
+					issuer &&
+					factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
+				failed: errorsCount > 0,
+				errors: errorsCount,
+				warnings: warningsCount
+			};
+			Object.assign(object, statsModule);
+			if (profile) {
+				object.profile = factory.create(
+					`${type.slice(0, -8)}.profile`,
+					profile,
+					context
+				);
+			}
+		},
+		ids: (object, module, { compilation: { chunkGraph, moduleGraph } }) => {
+			object.id = chunkGraph.getModuleId(module);
+			const issuer = moduleGraph.getIssuer(module);
+			object.issuerId = issuer && chunkGraph.getModuleId(issuer);
+			object.chunks = Array.from(
+				chunkGraph.getOrderedModuleChunksIterable(module, compareChunksById),
+				chunk => chunk.id
+			);
+		},
+		moduleAssets: (object, module) => {
+			object.assets = module.buildInfo.assets
+				? Object.keys(module.buildInfo.assets)
+				: [];
+		},
+		reasons: (object, module, context, options, factory) => {
+			const {
+				type,
+				compilation: { moduleGraph }
+			} = context;
+			const groupsReasons = factory.create(
+				`${type.slice(0, -8)}.reasons`,
+				Array.from(moduleGraph.getIncomingConnections(module)),
+				context
+			);
+			const limited = spaceLimited(groupsReasons, options.reasonsSpace);
+			object.reasons = limited.children;
+			object.filteredReasons = limited.filteredChildren;
+		},
+		usedExports: (
+			object,
+			module,
+			{ runtime, compilation: { moduleGraph } }
+		) => {
+			const usedExports = moduleGraph.getUsedExports(module, runtime);
+			if (usedExports === null) {
+				object.usedExports = null;
+			} else if (typeof usedExports === "boolean") {
+				object.usedExports = usedExports;
+			} else {
+				object.usedExports = Array.from(usedExports);
+			}
+		},
+		providedExports: (object, module, { compilation: { moduleGraph } }) => {
+			const providedExports = moduleGraph.getProvidedExports(module);
+			object.providedExports = Array.isArray(providedExports)
+				? providedExports
+				: null;
+		},
+		optimizationBailout: (
+			object,
+			module,
+			{ compilation: { moduleGraph } },
+			{ requestShortener }
+		) => {
+			object.optimizationBailout = moduleGraph
+				.getOptimizationBailout(module)
+				.map(item => {
+					if (typeof item === "function") return item(requestShortener);
+					return item;
+				});
+		},
+		depth: (object, module, { compilation: { moduleGraph } }) => {
+			object.depth = moduleGraph.getDepth(module);
+		},
+		nestedModules: (object, module, context, options, factory) => {
+			const { type } = context;
+			const innerModules = /** @type {Module & { modules?: Module[] }} */ (
+				module
+			).modules;
+			if (Array.isArray(innerModules)) {
+				const groupedModules = factory.create(
+					`${type.slice(0, -8)}.modules`,
+					innerModules,
+					context
+				);
+				const limited = spaceLimited(
+					groupedModules,
+					options.nestedModulesSpace
+				);
+				object.modules = limited.children;
+				object.filteredModules = limited.filteredChildren;
+			}
+		},
+		source: (object, module) => {
+			const originalSource = module.originalSource();
+			if (originalSource) {
+				object.source = originalSource.source();
+			}
+		}
+	},
+	profile: {
+		_: (object, profile) => {
+			/** @type {KnownStatsProfile} */
+			const statsProfile = {
+				total:
+					profile.factory +
+					profile.restoring +
+					profile.integration +
+					profile.building +
+					profile.storing,
+				resolving: profile.factory,
+				restoring: profile.restoring,
+				building: profile.building,
+				integration: profile.integration,
+				storing: profile.storing,
+				additionalResolving: profile.additionalFactories,
+				additionalIntegration: profile.additionalIntegration,
+				// TODO remove this in webpack 6
+				factory: profile.factory,
+				// TODO remove this in webpack 6
+				dependencies: profile.additionalFactories
+			};
+			Object.assign(object, statsProfile);
+		}
+	},
+	moduleIssuer: {
+		_: (object, module, context, { requestShortener }, factory) => {
+			const { compilation, type } = context;
+			const { moduleGraph } = compilation;
+			const profile = moduleGraph.getProfile(module);
+			/** @type {KnownStatsModuleIssuer} */
+			const statsModuleIssuer = {
+				identifier: module.identifier(),
+				name: module.readableIdentifier(requestShortener)
+			};
+			Object.assign(object, statsModuleIssuer);
+			if (profile) {
+				object.profile = factory.create(`${type}.profile`, profile, context);
+			}
+		},
+		ids: (object, module, { compilation: { chunkGraph } }) => {
+			object.id = chunkGraph.getModuleId(module);
+		}
+	},
+	moduleReason: {
+		_: (object, reason, { runtime }, { requestShortener }) => {
+			const dep = reason.dependency;
+			const moduleDep =
+				dep && dep instanceof ModuleDependency ? dep : undefined;
+			/** @type {KnownStatsModuleReason} */
+			const statsModuleReason = {
+				moduleIdentifier: reason.originModule
+					? reason.originModule.identifier()
+					: null,
+				module: reason.originModule
+					? reason.originModule.readableIdentifier(requestShortener)
+					: null,
+				moduleName: reason.originModule
+					? reason.originModule.readableIdentifier(requestShortener)
+					: null,
+				resolvedModuleIdentifier: reason.resolvedOriginModule
+					? reason.resolvedOriginModule.identifier()
+					: null,
+				resolvedModule: reason.resolvedOriginModule
+					? reason.resolvedOriginModule.readableIdentifier(requestShortener)
+					: null,
+				type: reason.dependency ? reason.dependency.type : null,
+				active: reason.isActive(runtime),
+				explanation: reason.explanation,
+				userRequest: (moduleDep && moduleDep.userRequest) || null
+			};
+			Object.assign(object, statsModuleReason);
+			if (reason.dependency) {
+				const locInfo = formatLocation(reason.dependency.loc);
+				if (locInfo) {
+					object.loc = locInfo;
+				}
+			}
+		},
+		ids: (object, reason, { compilation: { chunkGraph } }) => {
+			object.moduleId = reason.originModule
+				? chunkGraph.getModuleId(reason.originModule)
+				: null;
+			object.resolvedModuleId = reason.resolvedOriginModule
+				? chunkGraph.getModuleId(reason.resolvedOriginModule)
+				: null;
+		}
+	},
+	chunk: {
+		_: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
+			const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
+
+			/** @type {KnownStatsChunk} */
+			const statsChunk = {
+				rendered: chunk.rendered,
+				initial: chunk.canBeInitial(),
+				entry: chunk.hasRuntime(),
+				recorded: AggressiveSplittingPlugin.wasChunkRecorded(chunk),
+				reason: chunk.chunkReason,
+				size: chunkGraph.getChunkModulesSize(chunk),
+				sizes: chunkGraph.getChunkModulesSizes(chunk),
+				names: chunk.name ? [chunk.name] : [],
+				idHints: Array.from(chunk.idNameHints),
+				runtime:
+					chunk.runtime === undefined
+						? undefined
+						: typeof chunk.runtime === "string"
+						? [makePathsRelative(chunk.runtime)]
+						: Array.from(chunk.runtime.sort(), makePathsRelative),
+				files: Array.from(chunk.files),
+				auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(compareIds),
+				hash: chunk.renderedHash,
+				childrenByOrder: childIdByOrder
+			};
+			Object.assign(object, statsChunk);
+		},
+		ids: (object, chunk) => {
+			object.id = chunk.id;
+		},
+		chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
+			/** @type {Set<string|number>} */
+			const parents = new Set();
+			/** @type {Set<string|number>} */
+			const children = new Set();
+			/** @type {Set<string|number>} */
+			const siblings = new Set();
+
+			for (const chunkGroup of chunk.groupsIterable) {
+				for (const parentGroup of chunkGroup.parentsIterable) {
+					for (const chunk of parentGroup.chunks) {
+						parents.add(chunk.id);
+					}
+				}
+				for (const childGroup of chunkGroup.childrenIterable) {
+					for (const chunk of childGroup.chunks) {
+						children.add(chunk.id);
+					}
+				}
+				for (const sibling of chunkGroup.chunks) {
+					if (sibling !== chunk) siblings.add(sibling.id);
+				}
+			}
+			object.siblings = Array.from(siblings).sort(compareIds);
+			object.parents = Array.from(parents).sort(compareIds);
+			object.children = Array.from(children).sort(compareIds);
+		},
+		chunkModules: (object, chunk, context, options, factory) => {
+			const {
+				type,
+				compilation: { chunkGraph }
+			} = context;
+			const array = chunkGraph.getChunkModules(chunk);
+			const groupedModules = factory.create(`${type}.modules`, array, {
+				...context,
+				runtime: chunk.runtime,
+				rootModules: new Set(chunkGraph.getChunkRootModules(chunk))
+			});
+			const limited = spaceLimited(groupedModules, options.chunkModulesSpace);
+			object.modules = limited.children;
+			object.filteredModules = limited.filteredChildren;
+		},
+		chunkOrigins: (object, chunk, context, options, factory) => {
+			const {
+				type,
+				compilation: { chunkGraph }
+			} = context;
+			/** @type {Set<string>} */
+			const originsKeySet = new Set();
+			const origins = [];
+			for (const g of chunk.groupsIterable) {
+				origins.push(...g.origins);
+			}
+			const array = origins.filter(origin => {
+				const key = [
+					origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
+					formatLocation(origin.loc),
+					origin.request
+				].join();
+				if (originsKeySet.has(key)) return false;
+				originsKeySet.add(key);
+				return true;
+			});
+			object.origins = factory.create(`${type}.origins`, array, context);
+		}
+	},
+	chunkOrigin: {
+		_: (object, origin, context, { requestShortener }) => {
+			/** @type {KnownStatsChunkOrigin} */
+			const statsChunkOrigin = {
+				module: origin.module ? origin.module.identifier() : "",
+				moduleIdentifier: origin.module ? origin.module.identifier() : "",
+				moduleName: origin.module
+					? origin.module.readableIdentifier(requestShortener)
+					: "",
+				loc: formatLocation(origin.loc),
+				request: origin.request
+			};
+			Object.assign(object, statsChunkOrigin);
+		},
+		ids: (object, origin, { compilation: { chunkGraph } }) => {
+			object.moduleId = origin.module
+				? chunkGraph.getModuleId(origin.module)
+				: undefined;
+		}
+	},
+	error: EXTRACT_ERROR,
+	warning: EXTRACT_ERROR,
+	moduleTraceItem: {
+		_: (object, { origin, module }, context, { requestShortener }, factory) => {
+			const {
+				type,
+				compilation: { moduleGraph }
+			} = context;
+			object.originIdentifier = origin.identifier();
+			object.originName = origin.readableIdentifier(requestShortener);
+			object.moduleIdentifier = module.identifier();
+			object.moduleName = module.readableIdentifier(requestShortener);
+			const dependencies = Array.from(
+				moduleGraph.getIncomingConnections(module)
+			)
+				.filter(c => c.resolvedOriginModule === origin && c.dependency)
+				.map(c => c.dependency);
+			object.dependencies = factory.create(
+				`${type}.dependencies`,
+				Array.from(new Set(dependencies)),
+				context
+			);
+		},
+		ids: (object, { origin, module }, { compilation: { chunkGraph } }) => {
+			object.originId = chunkGraph.getModuleId(origin);
+			object.moduleId = chunkGraph.getModuleId(module);
+		}
+	},
+	moduleTraceDependency: {
+		_: (object, dependency) => {
+			object.loc = formatLocation(dependency.loc);
+		}
+	}
+};
+
+/** @type {Record<string, Record<string, (thing: any, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+const FILTER = {
+	"module.reasons": {
+		"!orphanModules": (reason, { compilation: { chunkGraph } }) => {
+			if (
+				reason.originModule &&
+				chunkGraph.getNumberOfModuleChunks(reason.originModule) === 0
+			) {
+				return false;
+			}
+		}
+	}
+};
+
+/** @type {Record<string, Record<string, (thing: Object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
+const FILTER_RESULTS = {
+	"compilation.warnings": {
+		warningsFilter: util.deprecate(
+			(warning, context, { warningsFilter }) => {
+				const warningString = Object.keys(warning)
+					.map(key => `${warning[key]}`)
+					.join("\n");
+				return !warningsFilter.some(filter => filter(warning, warningString));
+			},
+			"config.stats.warningsFilter is deprecated in favor of config.ignoreWarnings",
+			"DEP_WEBPACK_STATS_WARNINGS_FILTER"
+		)
+	}
+};
+
+/** @type {Record<string, (comparators: Function[], context: StatsFactoryContext) => void>} */
+const MODULES_SORTER = {
+	_: (comparators, { compilation: { moduleGraph } }) => {
+		comparators.push(
+			compareSelect(
+				/**
+				 * @param {Module} m module
+				 * @returns {number} depth
+				 */
+				m => moduleGraph.getDepth(m),
+				compareNumbers
+			),
+			compareSelect(
+				/**
+				 * @param {Module} m module
+				 * @returns {number} index
+				 */
+				m => moduleGraph.getPreOrderIndex(m),
+				compareNumbers
+			),
+			compareSelect(
+				/**
+				 * @param {Module} m module
+				 * @returns {string} identifier
+				 */
+				m => m.identifier(),
+				compareIds
+			)
+		);
+	}
+};
+
+/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext) => void>>} */
+const SORTERS = {
+	"compilation.chunks": {
+		_: comparators => {
+			comparators.push(compareSelect(c => c.id, compareIds));
+		}
+	},
+	"compilation.modules": MODULES_SORTER,
+	"chunk.rootModules": MODULES_SORTER,
+	"chunk.modules": MODULES_SORTER,
+	"module.modules": MODULES_SORTER,
+	"module.reasons": {
+		_: (comparators, { compilation: { chunkGraph } }) => {
+			comparators.push(
+				compareSelect(x => x.originModule, compareModulesByIdentifier)
+			);
+			comparators.push(
+				compareSelect(x => x.resolvedOriginModule, compareModulesByIdentifier)
+			);
+			comparators.push(
+				compareSelect(
+					x => x.dependency,
+					concatComparators(
+						compareSelect(
+							/**
+							 * @param {Dependency} x dependency
+							 * @returns {DependencyLocation} location
+							 */
+							x => x.loc,
+							compareLocations
+						),
+						compareSelect(x => x.type, compareIds)
+					)
+				)
+			);
+		}
+	},
+	"chunk.origins": {
+		_: (comparators, { compilation: { chunkGraph } }) => {
+			comparators.push(
+				compareSelect(
+					origin =>
+						origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
+					compareIds
+				),
+				compareSelect(origin => formatLocation(origin.loc), compareIds),
+				compareSelect(origin => origin.request, compareIds)
+			);
+		}
+	}
+};
+
+const getItemSize = item => {
+	// Each item takes 1 line
+	// + the size of the children
+	// + 1 extra line when it has children and filteredChildren
+	return !item.children
+		? 1
+		: item.filteredChildren
+		? 2 + getTotalSize(item.children)
+		: 1 + getTotalSize(item.children);
+};
+
+const getTotalSize = children => {
+	let size = 0;
+	for (const child of children) {
+		size += getItemSize(child);
+	}
+	return size;
+};
+
+const getTotalItems = children => {
+	let count = 0;
+	for (const child of children) {
+		if (!child.children && !child.filteredChildren) {
+			count++;
+		} else {
+			if (child.children) count += getTotalItems(child.children);
+			if (child.filteredChildren) count += child.filteredChildren;
+		}
+	}
+	return count;
+};
+
+const collapse = children => {
+	// After collapse each child must take exactly one line
+	const newChildren = [];
+	for (const child of children) {
+		if (child.children) {
+			let filteredChildren = child.filteredChildren || 0;
+			filteredChildren += getTotalItems(child.children);
+			newChildren.push({
+				...child,
+				children: undefined,
+				filteredChildren
+			});
+		} else {
+			newChildren.push(child);
+		}
+	}
+	return newChildren;
+};
+
+const spaceLimited = (
+	itemsAndGroups,
+	max,
+	filteredChildrenLineReserved = false
+) => {
+	if (max < 1) {
+		return {
+			children: undefined,
+			filteredChildren: getTotalItems(itemsAndGroups)
+		};
+	}
+	/** @type {any[] | undefined} */
+	let children = undefined;
+	/** @type {number | undefined} */
+	let filteredChildren = undefined;
+	// This are the groups, which take 1+ lines each
+	const groups = [];
+	// The sizes of the groups are stored in groupSizes
+	const groupSizes = [];
+	// This are the items, which take 1 line each
+	const items = [];
+	// The total of group sizes
+	let groupsSize = 0;
+
+	for (const itemOrGroup of itemsAndGroups) {
+		// is item
+		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
+			items.push(itemOrGroup);
+		} else {
+			groups.push(itemOrGroup);
+			const size = getItemSize(itemOrGroup);
+			groupSizes.push(size);
+			groupsSize += size;
+		}
+	}
+
+	if (groupsSize + items.length <= max) {
+		// The total size in the current state fits into the max
+		// keep all
+		children = groups.length > 0 ? groups.concat(items) : items;
+	} else if (groups.length === 0) {
+		// slice items to max
+		// inner space marks that lines for filteredChildren already reserved
+		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
+		filteredChildren = items.length - limit;
+		items.length = limit;
+		children = items;
+	} else {
+		// limit is the size when all groups are collapsed
+		const limit =
+			groups.length +
+			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
+		if (limit < max) {
+			// calculate how much we are over the size limit
+			// this allows to approach the limit faster
+			let oversize;
+			// If each group would take 1 line the total would be below the maximum
+			// collapse some groups, keep items
+			while (
+				(oversize =
+					groupsSize +
+					items.length +
+					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
+					max) > 0
+			) {
+				// Find the maximum group and process only this one
+				const maxGroupSize = Math.max(...groupSizes);
+				if (maxGroupSize < items.length) {
+					filteredChildren = items.length;
+					items.length = 0;
+					continue;
+				}
+				for (let i = 0; i < groups.length; i++) {
+					if (groupSizes[i] === maxGroupSize) {
+						const group = groups[i];
+						// run this algorithm recursively and limit the size of the children to
+						// current size - oversize / number of groups
+						// So it should always end up being smaller
+						const headerSize = group.filteredChildren ? 2 : 1;
+						const limited = spaceLimited(
+							group.children,
+							maxGroupSize -
+								// we should use ceil to always feet in max
+								Math.ceil(oversize / groups.length) -
+								// we substitute size of group head
+								headerSize,
+							headerSize === 2
+						);
+						groups[i] = {
+							...group,
+							children: limited.children,
+							filteredChildren: limited.filteredChildren
+								? (group.filteredChildren || 0) + limited.filteredChildren
+								: group.filteredChildren
+						};
+						const newSize = getItemSize(groups[i]);
+						groupsSize -= maxGroupSize - newSize;
+						groupSizes[i] = newSize;
+						break;
+					}
+				}
+			}
+			children = groups.concat(items);
+		} else if (limit === max) {
+			// If we have only enough space to show one line per group and one line for the filtered items
+			// collapse all groups and items
+			children = collapse(groups);
+			filteredChildren = items.length;
+		} else {
+			// If we have no space
+			// collapse complete group
+			filteredChildren = getTotalItems(itemsAndGroups);
+		}
+	}
+
+	return {
+		children,
+		filteredChildren
+	};
+};
+
+const assetGroup = (children, assets) => {
+	let size = 0;
+	for (const asset of children) {
+		size += asset.size;
+	}
+	return {
+		size
+	};
+};
+
+const moduleGroup = (children, modules) => {
+	let size = 0;
+	const sizes = {};
+	for (const module of children) {
+		size += module.size;
+		for (const key of Object.keys(module.sizes)) {
+			sizes[key] = (sizes[key] || 0) + module.sizes[key];
+		}
+	}
+	return {
+		size,
+		sizes
+	};
+};
+
+const reasonGroup = (children, reasons) => {
+	let active = false;
+	for (const reason of children) {
+		active = active || reason.active;
+	}
+	return {
+		active
+	};
+};
+
+const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
+const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+
+/** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+const ASSETS_GROUPERS = {
+	_: (groupConfigs, context, options) => {
+		const groupByFlag = (name, exclude) => {
+			groupConfigs.push({
+				getKeys: asset => {
+					return asset[name] ? ["1"] : undefined;
+				},
+				getOptions: () => {
+					return {
+						groupChildren: !exclude,
+						force: exclude
+					};
+				},
+				createGroup: (key, children, assets) => {
+					return exclude
+						? {
+								type: "assets by status",
+								[name]: !!key,
+								filteredChildren: assets.length,
+								...assetGroup(children, assets)
+						  }
+						: {
+								type: "assets by status",
+								[name]: !!key,
+								children,
+								...assetGroup(children, assets)
+						  };
+				}
+			});
+		};
+		const {
+			groupAssetsByEmitStatus,
+			groupAssetsByPath,
+			groupAssetsByExtension
+		} = options;
+		if (groupAssetsByEmitStatus) {
+			groupByFlag("emitted");
+			groupByFlag("comparedForEmit");
+			groupByFlag("isOverSizeLimit");
+		}
+		if (groupAssetsByEmitStatus || !options.cachedAssets) {
+			groupByFlag("cached", !options.cachedAssets);
+		}
+		if (groupAssetsByPath || groupAssetsByExtension) {
+			groupConfigs.push({
+				getKeys: asset => {
+					const extensionMatch =
+						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
+					const extension = extensionMatch ? extensionMatch[1] : "";
+					const pathMatch =
+						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
+					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					const keys = [];
+					if (groupAssetsByPath) {
+						keys.push(".");
+						if (extension)
+							keys.push(
+								path.length
+									? `${path.join("/")}/*${extension}`
+									: `*${extension}`
+							);
+						while (path.length > 0) {
+							keys.push(path.join("/") + "/");
+							path.pop();
+						}
+					} else {
+						if (extension) keys.push(`*${extension}`);
+					}
+					return keys;
+				},
+				createGroup: (key, children, assets) => {
+					return {
+						type: groupAssetsByPath ? "assets by path" : "assets by extension",
+						name: key,
+						children,
+						...assetGroup(children, assets)
+					};
+				}
+			});
+		}
+	},
+	groupAssetsByInfo: (groupConfigs, context, options) => {
+		const groupByAssetInfoFlag = name => {
+			groupConfigs.push({
+				getKeys: asset => {
+					return asset.info && asset.info[name] ? ["1"] : undefined;
+				},
+				createGroup: (key, children, assets) => {
+					return {
+						type: "assets by info",
+						info: {
+							[name]: !!key
+						},
+						children,
+						...assetGroup(children, assets)
+					};
+				}
+			});
+		};
+		groupByAssetInfoFlag("immutable");
+		groupByAssetInfoFlag("development");
+		groupByAssetInfoFlag("hotModuleReplacement");
+	},
+	groupAssetsByChunk: (groupConfigs, context, options) => {
+		const groupByNames = name => {
+			groupConfigs.push({
+				getKeys: asset => {
+					return asset[name];
+				},
+				createGroup: (key, children, assets) => {
+					return {
+						type: "assets by chunk",
+						[name]: [key],
+						children,
+						...assetGroup(children, assets)
+					};
+				}
+			});
+		};
+		groupByNames("chunkNames");
+		groupByNames("auxiliaryChunkNames");
+		groupByNames("chunkIdHints");
+		groupByNames("auxiliaryChunkIdHints");
+	},
+	excludeAssets: (groupConfigs, context, { excludeAssets }) => {
+		groupConfigs.push({
+			getKeys: asset => {
+				const ident = asset.name;
+				const excluded = excludeAssets.some(fn => fn(ident, asset));
+				if (excluded) return ["excluded"];
+			},
+			getOptions: () => ({
+				groupChildren: false,
+				force: true
+			}),
+			createGroup: (key, children, assets) => ({
+				type: "hidden assets",
+				filteredChildren: assets.length,
+				...assetGroup(children, assets)
+			})
+		});
+	}
+};
+
+/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
+const MODULES_GROUPERS = type => ({
+	_: (groupConfigs, context, options) => {
+		const groupByFlag = (name, type, exclude) => {
+			groupConfigs.push({
+				getKeys: module => {
+					return module[name] ? ["1"] : undefined;
+				},
+				getOptions: () => {
+					return {
+						groupChildren: !exclude,
+						force: exclude
+					};
+				},
+				createGroup: (key, children, modules) => {
+					return {
+						type,
+						[name]: !!key,
+						...(exclude ? { filteredChildren: modules.length } : { children }),
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		};
+		const {
+			groupModulesByCacheStatus,
+			groupModulesByLayer,
+			groupModulesByAttributes,
+			groupModulesByType,
+			groupModulesByPath,
+			groupModulesByExtension
+		} = options;
+		if (groupModulesByAttributes) {
+			groupByFlag("errors", "modules with errors");
+			groupByFlag("warnings", "modules with warnings");
+			groupByFlag("assets", "modules with assets");
+			groupByFlag("optional", "optional modules");
+		}
+		if (groupModulesByCacheStatus) {
+			groupByFlag("cacheable", "cacheable modules");
+			groupByFlag("built", "built modules");
+			groupByFlag("codeGenerated", "code generated modules");
+		}
+		if (groupModulesByCacheStatus || !options.cachedModules) {
+			groupByFlag("cached", "cached modules", !options.cachedModules);
+		}
+		if (groupModulesByAttributes || !options.orphanModules) {
+			groupByFlag("orphan", "orphan modules", !options.orphanModules);
+		}
+		if (groupModulesByAttributes || !options.dependentModules) {
+			groupByFlag("dependent", "dependent modules", !options.dependentModules);
+		}
+		if (groupModulesByType || !options.runtimeModules) {
+			groupConfigs.push({
+				getKeys: module => {
+					if (!module.moduleType) return;
+					if (groupModulesByType) {
+						return [module.moduleType.split("/", 1)[0]];
+					} else if (module.moduleType === "runtime") {
+						return ["runtime"];
+					}
+				},
+				getOptions: key => {
+					const exclude = key === "runtime" && !options.runtimeModules;
+					return {
+						groupChildren: !exclude,
+						force: exclude
+					};
+				},
+				createGroup: (key, children, modules) => {
+					const exclude = key === "runtime" && !options.runtimeModules;
+					return {
+						type: `${key} modules`,
+						moduleType: key,
+						...(exclude ? { filteredChildren: modules.length } : { children }),
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		}
+		if (groupModulesByLayer) {
+			groupConfigs.push({
+				getKeys: module => {
+					return [module.layer];
+				},
+				createGroup: (key, children, modules) => {
+					return {
+						type: "modules by layer",
+						layer: key,
+						children,
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		}
+		if (groupModulesByPath || groupModulesByExtension) {
+			groupConfigs.push({
+				getKeys: module => {
+					if (!module.name) return;
+					const resource = parseResource(module.name.split("!").pop()).path;
+					const dataUrl = /^data:[^,;]+/.exec(resource);
+					if (dataUrl) return [dataUrl[0]];
+					const extensionMatch =
+						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
+					const extension = extensionMatch ? extensionMatch[1] : "";
+					const pathMatch =
+						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
+					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					const keys = [];
+					if (groupModulesByPath) {
+						if (extension)
+							keys.push(
+								path.length
+									? `${path.join("/")}/*${extension}`
+									: `*${extension}`
+							);
+						while (path.length > 0) {
+							keys.push(path.join("/") + "/");
+							path.pop();
+						}
+					} else {
+						if (extension) keys.push(`*${extension}`);
+					}
+					return keys;
+				},
+				createGroup: (key, children, modules) => {
+					const isDataUrl = key.startsWith("data:");
+					return {
+						type: isDataUrl
+							? "modules by mime type"
+							: groupModulesByPath
+							? "modules by path"
+							: "modules by extension",
+						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
+						children,
+						...moduleGroup(children, modules)
+					};
+				}
+			});
+		}
+	},
+	excludeModules: (groupConfigs, context, { excludeModules }) => {
+		groupConfigs.push({
+			getKeys: module => {
+				const name = module.name;
+				if (name) {
+					const excluded = excludeModules.some(fn => fn(name, module, type));
+					if (excluded) return ["1"];
+				}
+			},
+			getOptions: () => ({
+				groupChildren: false,
+				force: true
+			}),
+			createGroup: (key, children, modules) => ({
+				type: "hidden modules",
+				filteredChildren: children.length,
+				...moduleGroup(children, modules)
+			})
+		});
+	}
+});
+
+/** @type {Record<string, Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+const RESULT_GROUPERS = {
+	"compilation.assets": ASSETS_GROUPERS,
+	"asset.related": ASSETS_GROUPERS,
+	"compilation.modules": MODULES_GROUPERS("module"),
+	"chunk.modules": MODULES_GROUPERS("chunk"),
+	"chunk.rootModules": MODULES_GROUPERS("root-of-chunk"),
+	"module.modules": MODULES_GROUPERS("nested"),
+	"module.reasons": {
+		groupReasonsByOrigin: groupConfigs => {
+			groupConfigs.push({
+				getKeys: reason => {
+					return [reason.module];
+				},
+				createGroup: (key, children, reasons) => {
+					return {
+						type: "from origin",
+						module: key,
+						children,
+						...reasonGroup(children, reasons)
+					};
+				}
+			});
+		}
+	}
+};
+
+// remove a prefixed "!" that can be specified to reverse sort order
+const normalizeFieldKey = field => {
+	if (field[0] === "!") {
+		return field.substr(1);
+	}
+	return field;
+};
+
+// if a field is prefixed by a "!" reverse sort order
+const sortOrderRegular = field => {
+	if (field[0] === "!") {
+		return false;
+	}
+	return true;
+};
+
+/**
+ * @param {string} field field name
+ * @returns {function(Object, Object): number} comparators
+ */
+const sortByField = field => {
+	if (!field) {
+		/**
+		 * @param {any} a first
+		 * @param {any} b second
+		 * @returns {-1|0|1} zero
+		 */
+		const noSort = (a, b) => 0;
+		return noSort;
+	}
+
+	const fieldKey = normalizeFieldKey(field);
+
+	let sortFn = compareSelect(m => m[fieldKey], compareIds);
+
+	// if a field is prefixed with a "!" the sort is reversed!
+	const sortIsRegular = sortOrderRegular(field);
+
+	if (!sortIsRegular) {
+		const oldSortFn = sortFn;
+		sortFn = (a, b) => oldSortFn(b, a);
+	}
+
+	return sortFn;
+};
+
+const ASSET_SORTERS = {
+	/** @type {(comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void} */
+	assetsSort: (comparators, context, { assetsSort }) => {
+		comparators.push(sortByField(assetsSort));
+	},
+	_: comparators => {
+		comparators.push(compareSelect(a => a.name, compareIds));
+	}
+};
+
+/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
+const RESULT_SORTERS = {
+	"compilation.chunks": {
+		chunksSort: (comparators, context, { chunksSort }) => {
+			comparators.push(sortByField(chunksSort));
+		}
+	},
+	"compilation.modules": {
+		modulesSort: (comparators, context, { modulesSort }) => {
+			comparators.push(sortByField(modulesSort));
+		}
+	},
+	"chunk.modules": {
+		chunkModulesSort: (comparators, context, { chunkModulesSort }) => {
+			comparators.push(sortByField(chunkModulesSort));
+		}
+	},
+	"module.modules": {
+		nestedModulesSort: (comparators, context, { nestedModulesSort }) => {
+			comparators.push(sortByField(nestedModulesSort));
+		}
+	},
+	"compilation.assets": ASSET_SORTERS,
+	"asset.related": ASSET_SORTERS
+};
+
+/**
+ * @param {Record<string, Record<string, Function>>} config the config see above
+ * @param {NormalizedStatsOptions} options stats options
+ * @param {function(string, Function): void} fn handler function called for every active line in config
+ * @returns {void}
+ */
+const iterateConfig = (config, options, fn) => {
+	for (const hookFor of Object.keys(config)) {
+		const subConfig = config[hookFor];
+		for (const option of Object.keys(subConfig)) {
+			if (option !== "_") {
+				if (option.startsWith("!")) {
+					if (options[option.slice(1)]) continue;
+				} else {
+					const value = options[option];
+					if (
+						value === false ||
+						value === undefined ||
+						(Array.isArray(value) && value.length === 0)
+					)
+						continue;
+				}
+			}
+			fn(hookFor, subConfig[option]);
+		}
+	}
+};
+
+/** @type {Record<string, string>} */
+const ITEM_NAMES = {
+	"compilation.children[]": "compilation",
+	"compilation.modules[]": "module",
+	"compilation.entrypoints[]": "chunkGroup",
+	"compilation.namedChunkGroups[]": "chunkGroup",
+	"compilation.errors[]": "error",
+	"compilation.warnings[]": "warning",
+	"chunk.modules[]": "module",
+	"chunk.rootModules[]": "module",
+	"chunk.origins[]": "chunkOrigin",
+	"compilation.chunks[]": "chunk",
+	"compilation.assets[]": "asset",
+	"asset.related[]": "asset",
+	"module.issuerPath[]": "moduleIssuer",
+	"module.reasons[]": "moduleReason",
+	"module.modules[]": "module",
+	"module.children[]": "module",
+	"moduleTrace[]": "moduleTraceItem",
+	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
+};
+
+/**
+ * @param {Object[]} items items to be merged
+ * @returns {Object} an object
+ */
+const mergeToObject = items => {
+	const obj = Object.create(null);
+	for (const item of items) {
+		obj[item.name] = item;
+	}
+	return obj;
+};
+
+/** @type {Record<string, (items: Object[]) => any>} */
+const MERGER = {
+	"compilation.entrypoints": mergeToObject,
+	"compilation.namedChunkGroups": mergeToObject
+};
+
+class DefaultStatsFactoryPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
+			compilation.hooks.statsFactory.tap(
+				"DefaultStatsFactoryPlugin",
+				(stats, options, context) => {
+					iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
+						stats.hooks.extract
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (obj, data, ctx) =>
+								fn(obj, data, ctx, options, stats)
+							);
+					});
+					iterateConfig(FILTER, options, (hookFor, fn) => {
+						stats.hooks.filter
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+								fn(item, ctx, options, idx, i)
+							);
+					});
+					iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
+						stats.hooks.filterResults
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
+								fn(item, ctx, options, idx, i)
+							);
+					});
+					iterateConfig(SORTERS, options, (hookFor, fn) => {
+						stats.hooks.sort
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+								fn(comparators, ctx, options)
+							);
+					});
+					iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
+						stats.hooks.sortResults
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
+								fn(comparators, ctx, options)
+							);
+					});
+					iterateConfig(RESULT_GROUPERS, options, (hookFor, fn) => {
+						stats.hooks.groupResults
+							.for(hookFor)
+							.tap("DefaultStatsFactoryPlugin", (groupConfigs, ctx) =>
+								fn(groupConfigs, ctx, options)
+							);
+					});
+					for (const key of Object.keys(ITEM_NAMES)) {
+						const itemName = ITEM_NAMES[key];
+						stats.hooks.getItemName
+							.for(key)
+							.tap("DefaultStatsFactoryPlugin", () => itemName);
+					}
+					for (const key of Object.keys(MERGER)) {
+						const merger = MERGER[key];
+						stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
+					}
+					if (options.children) {
+						if (Array.isArray(options.children)) {
+							stats.hooks.getItemFactory
+								.for("compilation.children[].compilation")
+								.tap("DefaultStatsFactoryPlugin", (comp, { _index: idx }) => {
+									if (idx < options.children.length) {
+										return compilation.createStatsFactory(
+											compilation.createStatsOptions(
+												options.children[idx],
+												context
+											)
+										);
+									}
+								});
+						} else if (options.children !== true) {
+							const childFactory = compilation.createStatsFactory(
+								compilation.createStatsOptions(options.children, context)
+							);
+							stats.hooks.getItemFactory
+								.for("compilation.children[].compilation")
+								.tap("DefaultStatsFactoryPlugin", () => {
+									return childFactory;
+								});
+						}
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = DefaultStatsFactoryPlugin;
+
+
+/***/ }),
+
+/***/ 55442:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RequestShortener = __webpack_require__(73406);
+
+/** @typedef {import("../../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
+/** @typedef {import("../Compiler")} Compiler */
+
+const applyDefaults = (options, defaults) => {
+	for (const key of Object.keys(defaults)) {
+		if (typeof options[key] === "undefined") {
+			options[key] = defaults[key];
+		}
+	}
+};
+
+const NAMED_PRESETS = {
+	verbose: {
+		hash: true,
+		builtAt: true,
+		relatedAssets: true,
+		entrypoints: true,
+		chunkGroups: true,
+		ids: true,
+		modules: false,
+		chunks: true,
+		chunkRelations: true,
+		chunkModules: true,
+		dependentModules: true,
+		chunkOrigins: true,
+		depth: true,
+		env: true,
+		reasons: true,
+		usedExports: true,
+		providedExports: true,
+		optimizationBailout: true,
+		errorDetails: true,
+		errorStack: true,
+		publicPath: true,
+		logging: "verbose",
+		orphanModules: true,
+		runtimeModules: true,
+		exclude: false,
+		modulesSpace: Infinity,
+		chunkModulesSpace: Infinity,
+		assetsSpace: Infinity,
+		reasonsSpace: Infinity,
+		children: true
+	},
+	detailed: {
+		hash: true,
+		builtAt: true,
+		relatedAssets: true,
+		entrypoints: true,
+		chunkGroups: true,
+		ids: true,
+		chunks: true,
+		chunkRelations: true,
+		chunkModules: false,
+		chunkOrigins: true,
+		depth: true,
+		usedExports: true,
+		providedExports: true,
+		optimizationBailout: true,
+		errorDetails: true,
+		publicPath: true,
+		logging: true,
+		runtimeModules: true,
+		exclude: false,
+		modulesSpace: 1000,
+		assetsSpace: 1000,
+		reasonsSpace: 1000
+	},
+	minimal: {
+		all: false,
+		version: true,
+		timings: true,
+		modules: true,
+		modulesSpace: 0,
+		assets: true,
+		assetsSpace: 0,
+		errors: true,
+		errorsCount: true,
+		warnings: true,
+		warningsCount: true,
+		logging: "warn"
+	},
+	"errors-only": {
+		all: false,
+		errors: true,
+		errorsCount: true,
+		moduleTrace: true,
+		logging: "error"
+	},
+	"errors-warnings": {
+		all: false,
+		errors: true,
+		errorsCount: true,
+		warnings: true,
+		warningsCount: true,
+		logging: "warn"
+	},
+	summary: {
+		all: false,
+		version: true,
+		errorsCount: true,
+		warningsCount: true
+	},
+	none: {
+		all: false
+	}
+};
+
+const NORMAL_ON = ({ all }) => all !== false;
+const NORMAL_OFF = ({ all }) => all === true;
+const ON_FOR_TO_STRING = ({ all }, { forToString }) =>
+	forToString ? all !== false : all === true;
+const OFF_FOR_TO_STRING = ({ all }, { forToString }) =>
+	forToString ? all === true : all !== false;
+const AUTO_FOR_TO_STRING = ({ all }, { forToString }) => {
+	if (all === false) return false;
+	if (all === true) return true;
+	if (forToString) return "auto";
+	return true;
+};
+
+/** @type {Record<string, (options: StatsOptions, context: CreateStatsOptionsContext, compilation: Compilation) => any>} */
+const DEFAULTS = {
+	context: (options, context, compilation) => compilation.compiler.context,
+	requestShortener: (options, context, compilation) =>
+		compilation.compiler.context === options.context
+			? compilation.requestShortener
+			: new RequestShortener(options.context, compilation.compiler.root),
+	performance: NORMAL_ON,
+	hash: OFF_FOR_TO_STRING,
+	env: NORMAL_OFF,
+	version: NORMAL_ON,
+	timings: NORMAL_ON,
+	builtAt: OFF_FOR_TO_STRING,
+	assets: NORMAL_ON,
+	entrypoints: AUTO_FOR_TO_STRING,
+	chunkGroups: OFF_FOR_TO_STRING,
+	chunkGroupAuxiliary: OFF_FOR_TO_STRING,
+	chunkGroupChildren: OFF_FOR_TO_STRING,
+	chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
+	chunks: OFF_FOR_TO_STRING,
+	chunkRelations: OFF_FOR_TO_STRING,
+	chunkModules: ({ all, modules }) => {
+		if (all === false) return false;
+		if (all === true) return true;
+		if (modules) return false;
+		return true;
+	},
+	dependentModules: OFF_FOR_TO_STRING,
+	chunkOrigins: OFF_FOR_TO_STRING,
+	ids: OFF_FOR_TO_STRING,
+	modules: ({ all, chunks, chunkModules }, { forToString }) => {
+		if (all === false) return false;
+		if (all === true) return true;
+		if (forToString && chunks && chunkModules) return false;
+		return true;
+	},
+	nestedModules: OFF_FOR_TO_STRING,
+	groupModulesByType: ON_FOR_TO_STRING,
+	groupModulesByCacheStatus: ON_FOR_TO_STRING,
+	groupModulesByLayer: ON_FOR_TO_STRING,
+	groupModulesByAttributes: ON_FOR_TO_STRING,
+	groupModulesByPath: ON_FOR_TO_STRING,
+	groupModulesByExtension: ON_FOR_TO_STRING,
+	modulesSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+	chunkModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
+	nestedModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
+	relatedAssets: OFF_FOR_TO_STRING,
+	groupAssetsByEmitStatus: ON_FOR_TO_STRING,
+	groupAssetsByInfo: ON_FOR_TO_STRING,
+	groupAssetsByPath: ON_FOR_TO_STRING,
+	groupAssetsByExtension: ON_FOR_TO_STRING,
+	groupAssetsByChunk: ON_FOR_TO_STRING,
+	assetsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+	orphanModules: OFF_FOR_TO_STRING,
+	runtimeModules: ({ all, runtime }, { forToString }) =>
+		runtime !== undefined
+			? runtime
+			: forToString
+			? all === true
+			: all !== false,
+	cachedModules: ({ all, cached }, { forToString }) =>
+		cached !== undefined ? cached : forToString ? all === true : all !== false,
+	moduleAssets: OFF_FOR_TO_STRING,
+	depth: OFF_FOR_TO_STRING,
+	cachedAssets: OFF_FOR_TO_STRING,
+	reasons: OFF_FOR_TO_STRING,
+	reasonsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
+	groupReasonsByOrigin: ON_FOR_TO_STRING,
+	usedExports: OFF_FOR_TO_STRING,
+	providedExports: OFF_FOR_TO_STRING,
+	optimizationBailout: OFF_FOR_TO_STRING,
+	children: OFF_FOR_TO_STRING,
+	source: NORMAL_OFF,
+	moduleTrace: NORMAL_ON,
+	errors: NORMAL_ON,
+	errorsCount: NORMAL_ON,
+	errorDetails: AUTO_FOR_TO_STRING,
+	errorStack: OFF_FOR_TO_STRING,
+	warnings: NORMAL_ON,
+	warningsCount: NORMAL_ON,
+	publicPath: OFF_FOR_TO_STRING,
+	logging: ({ all }, { forToString }) =>
+		forToString && all !== false ? "info" : false,
+	loggingDebug: () => [],
+	loggingTrace: OFF_FOR_TO_STRING,
+	excludeModules: () => [],
+	excludeAssets: () => [],
+	modulesSort: () => "depth",
+	chunkModulesSort: () => "name",
+	nestedModulesSort: () => false,
+	chunksSort: () => false,
+	assetsSort: () => "!size",
+	outputPath: OFF_FOR_TO_STRING,
+	colors: () => false
+};
+
+const normalizeFilter = item => {
+	if (typeof item === "string") {
+		const regExp = new RegExp(
+			`[\\\\/]${item.replace(
+				// eslint-disable-next-line no-useless-escape
+				/[-[\]{}()*+?.\\^$|]/g,
+				"\\$&"
+			)}([\\\\/]|$|!|\\?)`
+		);
+		return ident => regExp.test(ident);
+	}
+	if (item && typeof item === "object" && typeof item.test === "function") {
+		return ident => item.test(ident);
+	}
+	if (typeof item === "function") {
+		return item;
+	}
+	if (typeof item === "boolean") {
+		return () => item;
+	}
+};
+
+const NORMALIZER = {
+	excludeModules: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(normalizeFilter);
+	},
+	excludeAssets: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(normalizeFilter);
+	},
+	warningsFilter: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(filter => {
+			if (typeof filter === "string") {
+				return (warning, warningString) => warningString.includes(filter);
+			}
+			if (filter instanceof RegExp) {
+				return (warning, warningString) => filter.test(warningString);
+			}
+			if (typeof filter === "function") {
+				return filter;
+			}
+			throw new Error(
+				`Can only filter warnings with Strings or RegExps. (Given: ${filter})`
+			);
+		});
+	},
+	logging: value => {
+		if (value === true) value = "log";
+		return value;
+	},
+	loggingDebug: value => {
+		if (!Array.isArray(value)) {
+			value = value ? [value] : [];
+		}
+		return value.map(normalizeFilter);
+	}
+};
+
+class DefaultStatsPresetPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("DefaultStatsPresetPlugin", compilation => {
+			for (const key of Object.keys(NAMED_PRESETS)) {
+				const defaults = NAMED_PRESETS[key];
+				compilation.hooks.statsPreset
+					.for(key)
+					.tap("DefaultStatsPresetPlugin", (options, context) => {
+						applyDefaults(options, defaults);
+					});
+			}
+			compilation.hooks.statsNormalize.tap(
+				"DefaultStatsPresetPlugin",
+				(options, context) => {
+					for (const key of Object.keys(DEFAULTS)) {
+						if (options[key] === undefined)
+							options[key] = DEFAULTS[key](options, context, compilation);
+					}
+					for (const key of Object.keys(NORMALIZER)) {
+						options[key] = NORMALIZER[key](options[key]);
+					}
+				}
+			);
+		});
+	}
+}
+module.exports = DefaultStatsPresetPlugin;
+
+
+/***/ }),
+
+/***/ 58692:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./StatsPrinter")} StatsPrinter */
+/** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
+
+const DATA_URI_CONTENT_LENGTH = 16;
+
+const plural = (n, singular, plural) => (n === 1 ? singular : plural);
+
+/**
+ * @param {Record<string, number>} sizes sizes by source type
+ * @param {Object} options options
+ * @param {(number) => string=} options.formatSize size formatter
+ * @returns {string} text
+ */
+const printSizes = (sizes, { formatSize = n => `${n}` }) => {
+	const keys = Object.keys(sizes);
+	if (keys.length > 1) {
+		return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
+	} else if (keys.length === 1) {
+		return formatSize(sizes[keys[0]]);
+	}
+};
+
+const getResourceName = resource => {
+	const dataUrl = /^data:[^,]+,/.exec(resource);
+	if (!dataUrl) return resource;
+
+	const len = dataUrl[0].length + DATA_URI_CONTENT_LENGTH;
+	if (resource.length < len) return resource;
+	return `${resource.slice(
+		0,
+		Math.min(resource.length - /* '..'.length */ 2, len)
+	)}..`;
+};
+
+const getModuleName = name => {
+	const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
+	return [prefix, getResourceName(resource)];
+};
+
+const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
+
+/**
+ * @param {number} n a number
+ * @returns {string} number as two digit string, leading 0
+ */
+const twoDigit = n => (n >= 10 ? `${n}` : `0${n}`);
+
+const isValidId = id => {
+	return typeof id === "number" || id;
+};
+
+const moreCount = (list, count) => {
+	return list && list.length > 0 ? `+ ${count}` : `${count}`;
+};
+
+/** @type {Record<string, (thing: any, context: StatsPrinterContext, printer: StatsPrinter) => string | void>} */
+const SIMPLE_PRINTERS = {
+	"compilation.summary!": (
+		_,
+		{
+			type,
+			bold,
+			green,
+			red,
+			yellow,
+			formatDateTime,
+			formatTime,
+			compilation: {
+				name,
+				hash,
+				version,
+				time,
+				builtAt,
+				errorsCount,
+				warningsCount
+			}
+		}
+	) => {
+		const root = type === "compilation.summary!";
+		const warningsMessage =
+			warningsCount > 0
+				? yellow(
+						`${warningsCount} ${plural(warningsCount, "warning", "warnings")}`
+				  )
+				: "";
+		const errorsMessage =
+			errorsCount > 0
+				? red(`${errorsCount} ${plural(errorsCount, "error", "errors")}`)
+				: "";
+		const timeMessage = root && time ? ` in ${formatTime(time)}` : "";
+		const hashMessage = hash ? ` (${hash})` : "";
+		const builtAtMessage =
+			root && builtAt ? `${formatDateTime(builtAt)}: ` : "";
+		const versionMessage = root && version ? `webpack ${version}` : "";
+		const nameMessage =
+			root && name
+				? bold(name)
+				: name
+				? `Child ${bold(name)}`
+				: root
+				? ""
+				: "Child";
+		const subjectMessage =
+			nameMessage && versionMessage
+				? `${nameMessage} (${versionMessage})`
+				: versionMessage || nameMessage || "webpack";
+		let statusMessage;
+		if (errorsMessage && warningsMessage) {
+			statusMessage = `compiled with ${errorsMessage} and ${warningsMessage}`;
+		} else if (errorsMessage) {
+			statusMessage = `compiled with ${errorsMessage}`;
+		} else if (warningsMessage) {
+			statusMessage = `compiled with ${warningsMessage}`;
+		} else if (errorsCount === 0 && warningsCount === 0) {
+			statusMessage = `compiled ${green("successfully")}`;
+		} else {
+			statusMessage = `compiled`;
+		}
+		if (
+			builtAtMessage ||
+			versionMessage ||
+			errorsMessage ||
+			warningsMessage ||
+			(errorsCount === 0 && warningsCount === 0) ||
+			timeMessage ||
+			hashMessage
+		)
+			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
+	},
+	"compilation.filteredWarningDetailsCount": count =>
+		count
+			? `${count} ${plural(
+					count,
+					"warning has",
+					"warnings have"
+			  )} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+			: undefined,
+	"compilation.filteredErrorDetailsCount": (count, { yellow }) =>
+		count
+			? yellow(
+					`${count} ${plural(
+						count,
+						"error has",
+						"errors have"
+					)} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
+			  )
+			: undefined,
+	"compilation.env": (env, { bold }) =>
+		env
+			? `Environment (--env): ${bold(JSON.stringify(env, null, 2))}`
+			: undefined,
+	"compilation.publicPath": (publicPath, { bold }) =>
+		`PublicPath: ${bold(publicPath || "(none)")}`,
+	"compilation.entrypoints": (entrypoints, context, printer) =>
+		Array.isArray(entrypoints)
+			? undefined
+			: printer.print(context.type, Object.values(entrypoints), {
+					...context,
+					chunkGroupKind: "Entrypoint"
+			  }),
+	"compilation.namedChunkGroups": (namedChunkGroups, context, printer) => {
+		if (!Array.isArray(namedChunkGroups)) {
+			const {
+				compilation: { entrypoints }
+			} = context;
+			let chunkGroups = Object.values(namedChunkGroups);
+			if (entrypoints) {
+				chunkGroups = chunkGroups.filter(
+					group =>
+						!Object.prototype.hasOwnProperty.call(entrypoints, group.name)
+				);
+			}
+			return printer.print(context.type, chunkGroups, {
+				...context,
+				chunkGroupKind: "Chunk Group"
+			});
+		}
+	},
+	"compilation.assetsByChunkName": () => "",
+
+	"compilation.filteredModules": (
+		filteredModules,
+		{ compilation: { modules } }
+	) =>
+		filteredModules > 0
+			? `${moreCount(modules, filteredModules)} ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"compilation.filteredAssets": (filteredAssets, { compilation: { assets } }) =>
+		filteredAssets > 0
+			? `${moreCount(assets, filteredAssets)} ${plural(
+					filteredAssets,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+	"compilation.logging": (logging, context, printer) =>
+		Array.isArray(logging)
+			? undefined
+			: printer.print(
+					context.type,
+					Object.entries(logging).map(([name, value]) => ({ ...value, name })),
+					context
+			  ),
+	"compilation.warningsInChildren!": (_, { yellow, compilation }) => {
+		if (
+			!compilation.children &&
+			compilation.warningsCount > 0 &&
+			compilation.warnings
+		) {
+			const childWarnings =
+				compilation.warningsCount - compilation.warnings.length;
+			if (childWarnings > 0) {
+				return yellow(
+					`${childWarnings} ${plural(
+						childWarnings,
+						"WARNING",
+						"WARNINGS"
+					)} in child compilations${
+						compilation.children
+							? ""
+							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
+					}`
+				);
+			}
+		}
+	},
+	"compilation.errorsInChildren!": (_, { red, compilation }) => {
+		if (
+			!compilation.children &&
+			compilation.errorsCount > 0 &&
+			compilation.errors
+		) {
+			const childErrors = compilation.errorsCount - compilation.errors.length;
+			if (childErrors > 0) {
+				return red(
+					`${childErrors} ${plural(
+						childErrors,
+						"ERROR",
+						"ERRORS"
+					)} in child compilations${
+						compilation.children
+							? ""
+							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
+					}`
+				);
+			}
+		}
+	},
+
+	"asset.type": type => type,
+	"asset.name": (name, { formatFilename, asset: { isOverSizeLimit } }) =>
+		formatFilename(name, isOverSizeLimit),
+	"asset.size": (
+		size,
+		{ asset: { isOverSizeLimit }, yellow, green, formatSize }
+	) => (isOverSizeLimit ? yellow(formatSize(size)) : formatSize(size)),
+	"asset.emitted": (emitted, { green, formatFlag }) =>
+		emitted ? green(formatFlag("emitted")) : undefined,
+	"asset.comparedForEmit": (comparedForEmit, { yellow, formatFlag }) =>
+		comparedForEmit ? yellow(formatFlag("compared for emit")) : undefined,
+	"asset.cached": (cached, { green, formatFlag }) =>
+		cached ? green(formatFlag("cached")) : undefined,
+	"asset.isOverSizeLimit": (isOverSizeLimit, { yellow, formatFlag }) =>
+		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
+
+	"asset.info.immutable": (immutable, { green, formatFlag }) =>
+		immutable ? green(formatFlag("immutable")) : undefined,
+	"asset.info.javascriptModule": (javascriptModule, { formatFlag }) =>
+		javascriptModule ? formatFlag("javascript module") : undefined,
+	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
+		sourceFilename
+			? formatFlag(
+					sourceFilename === true
+						? "from source file"
+						: `from: ${sourceFilename}`
+			  )
+			: undefined,
+	"asset.info.development": (development, { green, formatFlag }) =>
+		development ? green(formatFlag("dev")) : undefined,
+	"asset.info.hotModuleReplacement": (
+		hotModuleReplacement,
+		{ green, formatFlag }
+	) => (hotModuleReplacement ? green(formatFlag("hmr")) : undefined),
+	"asset.separator!": () => "\n",
+	"asset.filteredRelated": (filteredRelated, { asset: { related } }) =>
+		filteredRelated > 0
+			? `${moreCount(related, filteredRelated)} related ${plural(
+					filteredRelated,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+	"asset.filteredChildren": (filteredChildren, { asset: { children } }) =>
+		filteredChildren > 0
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+
+	assetChunk: (id, { formatChunkId }) => formatChunkId(id),
+
+	assetChunkName: name => name,
+	assetChunkIdHint: name => name,
+
+	"module.type": type => (type !== "module" ? type : undefined),
+	"module.id": (id, { formatModuleId }) =>
+		isValidId(id) ? formatModuleId(id) : undefined,
+	"module.name": (name, { bold }) => {
+		const [prefix, resource] = getModuleName(name);
+		return `${prefix || ""}${bold(resource || "")}`;
+	},
+	"module.identifier": identifier => undefined,
+	"module.layer": (layer, { formatLayer }) =>
+		layer ? formatLayer(layer) : undefined,
+	"module.sizes": printSizes,
+	"module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
+	"module.depth": (depth, { formatFlag }) =>
+		depth !== null ? formatFlag(`depth ${depth}`) : undefined,
+	"module.cacheable": (cacheable, { formatFlag, red }) =>
+		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
+	"module.orphan": (orphan, { formatFlag, yellow }) =>
+		orphan ? yellow(formatFlag("orphan")) : undefined,
+	"module.runtime": (runtime, { formatFlag, yellow }) =>
+		runtime ? yellow(formatFlag("runtime")) : undefined,
+	"module.optional": (optional, { formatFlag, yellow }) =>
+		optional ? yellow(formatFlag("optional")) : undefined,
+	"module.dependent": (dependent, { formatFlag, cyan }) =>
+		dependent ? cyan(formatFlag("dependent")) : undefined,
+	"module.built": (built, { formatFlag, yellow }) =>
+		built ? yellow(formatFlag("built")) : undefined,
+	"module.codeGenerated": (codeGenerated, { formatFlag, yellow }) =>
+		codeGenerated ? yellow(formatFlag("code generated")) : undefined,
+	"module.buildTimeExecuted": (buildTimeExecuted, { formatFlag, green }) =>
+		buildTimeExecuted ? green(formatFlag("build time executed")) : undefined,
+	"module.cached": (cached, { formatFlag, green }) =>
+		cached ? green(formatFlag("cached")) : undefined,
+	"module.assets": (assets, { formatFlag, magenta }) =>
+		assets && assets.length
+			? magenta(
+					formatFlag(
+						`${assets.length} ${plural(assets.length, "asset", "assets")}`
+					)
+			  )
+			: undefined,
+	"module.warnings": (warnings, { formatFlag, yellow }) =>
+		warnings === true
+			? yellow(formatFlag("warnings"))
+			: warnings
+			? yellow(
+					formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`)
+			  )
+			: undefined,
+	"module.errors": (errors, { formatFlag, red }) =>
+		errors === true
+			? red(formatFlag("errors"))
+			: errors
+			? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
+			: undefined,
+	"module.providedExports": (providedExports, { formatFlag, cyan }) => {
+		if (Array.isArray(providedExports)) {
+			if (providedExports.length === 0) return cyan(formatFlag("no exports"));
+			return cyan(formatFlag(`exports: ${providedExports.join(", ")}`));
+		}
+	},
+	"module.usedExports": (usedExports, { formatFlag, cyan, module }) => {
+		if (usedExports !== true) {
+			if (usedExports === null) return cyan(formatFlag("used exports unknown"));
+			if (usedExports === false) return cyan(formatFlag("module unused"));
+			if (Array.isArray(usedExports)) {
+				if (usedExports.length === 0)
+					return cyan(formatFlag("no exports used"));
+				const providedExportsCount = Array.isArray(module.providedExports)
+					? module.providedExports.length
+					: null;
+				if (
+					providedExportsCount !== null &&
+					providedExportsCount === usedExports.length
+				) {
+					return cyan(formatFlag("all exports used"));
+				} else {
+					return cyan(
+						formatFlag(`only some exports used: ${usedExports.join(", ")}`)
+					);
+				}
+			}
+		}
+	},
+	"module.optimizationBailout[]": (optimizationBailout, { yellow }) =>
+		yellow(optimizationBailout),
+	"module.issuerPath": (issuerPath, { module }) =>
+		module.profile ? undefined : "",
+	"module.profile": profile => undefined,
+	"module.filteredModules": (filteredModules, { module: { modules } }) =>
+		filteredModules > 0
+			? `${moreCount(modules, filteredModules)} nested ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"module.filteredReasons": (filteredReasons, { module: { reasons } }) =>
+		filteredReasons > 0
+			? `${moreCount(reasons, filteredReasons)} ${plural(
+					filteredReasons,
+					"reason",
+					"reasons"
+			  )}`
+			: undefined,
+	"module.filteredChildren": (filteredChildren, { module: { children } }) =>
+		filteredChildren > 0
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"module.separator!": () => "\n",
+
+	"moduleIssuer.id": (id, { formatModuleId }) => formatModuleId(id),
+	"moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value),
+
+	"moduleReason.type": type => type,
+	"moduleReason.userRequest": (userRequest, { cyan }) =>
+		cyan(getResourceName(userRequest)),
+	"moduleReason.moduleId": (moduleId, { formatModuleId }) =>
+		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
+	"moduleReason.module": (module, { magenta }) => magenta(module),
+	"moduleReason.loc": loc => loc,
+	"moduleReason.explanation": (explanation, { cyan }) => cyan(explanation),
+	"moduleReason.active": (active, { formatFlag }) =>
+		active ? undefined : formatFlag("inactive"),
+	"moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
+	"moduleReason.filteredChildren": (
+		filteredChildren,
+		{ moduleReason: { children } }
+	) =>
+		filteredChildren > 0
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"reason",
+					"reasons"
+			  )}`
+			: undefined,
+
+	"module.profile.total": (value, { formatTime }) => formatTime(value),
+	"module.profile.resolving": (value, { formatTime }) =>
+		`resolving: ${formatTime(value)}`,
+	"module.profile.restoring": (value, { formatTime }) =>
+		`restoring: ${formatTime(value)}`,
+	"module.profile.integration": (value, { formatTime }) =>
+		`integration: ${formatTime(value)}`,
+	"module.profile.building": (value, { formatTime }) =>
+		`building: ${formatTime(value)}`,
+	"module.profile.storing": (value, { formatTime }) =>
+		`storing: ${formatTime(value)}`,
+	"module.profile.additionalResolving": (value, { formatTime }) =>
+		value ? `additional resolving: ${formatTime(value)}` : undefined,
+	"module.profile.additionalIntegration": (value, { formatTime }) =>
+		value ? `additional integration: ${formatTime(value)}` : undefined,
+
+	"chunkGroup.kind!": (_, { chunkGroupKind }) => chunkGroupKind,
+	"chunkGroup.separator!": () => "\n",
+	"chunkGroup.name": (name, { bold }) => bold(name),
+	"chunkGroup.isOverSizeLimit": (isOverSizeLimit, { formatFlag, yellow }) =>
+		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
+	"chunkGroup.assetsSize": (size, { formatSize }) =>
+		size ? formatSize(size) : undefined,
+	"chunkGroup.auxiliaryAssetsSize": (size, { formatSize }) =>
+		size ? `(${formatSize(size)})` : undefined,
+	"chunkGroup.filteredAssets": (n, { chunkGroup: { assets } }) =>
+		n > 0
+			? `${moreCount(assets, n)} ${plural(n, "asset", "assets")}`
+			: undefined,
+	"chunkGroup.filteredAuxiliaryAssets": (
+		n,
+		{ chunkGroup: { auxiliaryAssets } }
+	) =>
+		n > 0
+			? `${moreCount(auxiliaryAssets, n)} auxiliary ${plural(
+					n,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
+	"chunkGroup.is!": () => "=",
+	"chunkGroupAsset.name": (asset, { green }) => green(asset),
+	"chunkGroupAsset.size": (size, { formatSize, chunkGroup }) =>
+		chunkGroup.assets.length > 1 ||
+		(chunkGroup.auxiliaryAssets && chunkGroup.auxiliaryAssets.length > 0)
+			? formatSize(size)
+			: undefined,
+	"chunkGroup.children": (children, context, printer) =>
+		Array.isArray(children)
+			? undefined
+			: printer.print(
+					context.type,
+					Object.keys(children).map(key => ({
+						type: key,
+						children: children[key]
+					})),
+					context
+			  ),
+	"chunkGroupChildGroup.type": type => `${type}:`,
+	"chunkGroupChild.assets[]": (file, { formatFilename }) =>
+		formatFilename(file),
+	"chunkGroupChild.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
+	"chunkGroupChild.name": name => (name ? `(name: ${name})` : undefined),
+
+	"chunk.id": (id, { formatChunkId }) => formatChunkId(id),
+	"chunk.files[]": (file, { formatFilename }) => formatFilename(file),
+	"chunk.names[]": name => name,
+	"chunk.idHints[]": name => name,
+	"chunk.runtime[]": name => name,
+	"chunk.sizes": (sizes, context) => printSizes(sizes, context),
+	"chunk.parents[]": (parents, context) =>
+		context.formatChunkId(parents, "parent"),
+	"chunk.siblings[]": (siblings, context) =>
+		context.formatChunkId(siblings, "sibling"),
+	"chunk.children[]": (children, context) =>
+		context.formatChunkId(children, "child"),
+	"chunk.childrenByOrder": (childrenByOrder, context, printer) =>
+		Array.isArray(childrenByOrder)
+			? undefined
+			: printer.print(
+					context.type,
+					Object.keys(childrenByOrder).map(key => ({
+						type: key,
+						children: childrenByOrder[key]
+					})),
+					context
+			  ),
+	"chunk.childrenByOrder[].type": type => `${type}:`,
+	"chunk.childrenByOrder[].children[]": (id, { formatChunkId }) =>
+		isValidId(id) ? formatChunkId(id) : undefined,
+	"chunk.entry": (entry, { formatFlag, yellow }) =>
+		entry ? yellow(formatFlag("entry")) : undefined,
+	"chunk.initial": (initial, { formatFlag, yellow }) =>
+		initial ? yellow(formatFlag("initial")) : undefined,
+	"chunk.rendered": (rendered, { formatFlag, green }) =>
+		rendered ? green(formatFlag("rendered")) : undefined,
+	"chunk.recorded": (recorded, { formatFlag, green }) =>
+		recorded ? green(formatFlag("recorded")) : undefined,
+	"chunk.reason": (reason, { yellow }) => (reason ? yellow(reason) : undefined),
+	"chunk.filteredModules": (filteredModules, { chunk: { modules } }) =>
+		filteredModules > 0
+			? `${moreCount(modules, filteredModules)} chunk ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
+			: undefined,
+	"chunk.separator!": () => "\n",
+
+	"chunkOrigin.request": request => request,
+	"chunkOrigin.moduleId": (moduleId, { formatModuleId }) =>
+		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
+	"chunkOrigin.moduleName": (moduleName, { bold }) => bold(moduleName),
+	"chunkOrigin.loc": loc => loc,
+
+	"error.compilerPath": (compilerPath, { bold }) =>
+		compilerPath ? bold(`(${compilerPath})`) : undefined,
+	"error.chunkId": (chunkId, { formatChunkId }) =>
+		isValidId(chunkId) ? formatChunkId(chunkId) : undefined,
+	"error.chunkEntry": (chunkEntry, { formatFlag }) =>
+		chunkEntry ? formatFlag("entry") : undefined,
+	"error.chunkInitial": (chunkInitial, { formatFlag }) =>
+		chunkInitial ? formatFlag("initial") : undefined,
+	"error.file": (file, { bold }) => bold(file),
+	"error.moduleName": (moduleName, { bold }) => {
+		return moduleName.includes("!")
+			? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})`
+			: `${bold(moduleName)}`;
+	},
+	"error.loc": (loc, { green }) => green(loc),
+	"error.message": (message, { bold, formatError }) =>
+		message.includes("\u001b[") ? message : bold(formatError(message)),
+	"error.details": (details, { formatError }) => formatError(details),
+	"error.stack": stack => stack,
+	"error.moduleTrace": moduleTrace => undefined,
+	"error.separator!": () => "\n",
+
+	"loggingEntry(error).loggingEntry.message": (message, { red }) =>
+		mapLines(message, x => `<e> ${red(x)}`),
+	"loggingEntry(warn).loggingEntry.message": (message, { yellow }) =>
+		mapLines(message, x => `<w> ${yellow(x)}`),
+	"loggingEntry(info).loggingEntry.message": (message, { green }) =>
+		mapLines(message, x => `<i> ${green(x)}`),
+	"loggingEntry(log).loggingEntry.message": (message, { bold }) =>
+		mapLines(message, x => `    ${bold(x)}`),
+	"loggingEntry(debug).loggingEntry.message": message =>
+		mapLines(message, x => `    ${x}`),
+	"loggingEntry(trace).loggingEntry.message": message =>
+		mapLines(message, x => `    ${x}`),
+	"loggingEntry(status).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `<s> ${magenta(x)}`),
+	"loggingEntry(profile).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `<p> ${magenta(x)}`),
+	"loggingEntry(profileEnd).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `</p> ${magenta(x)}`),
+	"loggingEntry(time).loggingEntry.message": (message, { magenta }) =>
+		mapLines(message, x => `<t> ${magenta(x)}`),
+	"loggingEntry(group).loggingEntry.message": (message, { cyan }) =>
+		mapLines(message, x => `<-> ${cyan(x)}`),
+	"loggingEntry(groupCollapsed).loggingEntry.message": (message, { cyan }) =>
+		mapLines(message, x => `<+> ${cyan(x)}`),
+	"loggingEntry(clear).loggingEntry": () => "    -------",
+	"loggingEntry(groupCollapsed).loggingEntry.children": () => "",
+	"loggingEntry.trace[]": trace =>
+		trace ? mapLines(trace, x => `| ${x}`) : undefined,
+
+	"moduleTraceItem.originName": originName => originName,
+
+	loggingGroup: loggingGroup =>
+		loggingGroup.entries.length === 0 ? "" : undefined,
+	"loggingGroup.debug": (flag, { red }) => (flag ? red("DEBUG") : undefined),
+	"loggingGroup.name": (name, { bold }) => bold(`LOG from ${name}`),
+	"loggingGroup.separator!": () => "\n",
+	"loggingGroup.filteredEntries": filteredEntries =>
+		filteredEntries > 0 ? `+ ${filteredEntries} hidden lines` : undefined,
+
+	"moduleTraceDependency.loc": loc => loc
+};
+
+/** @type {Record<string, string | Function>} */
+const ITEM_NAMES = {
+	"compilation.assets[]": "asset",
+	"compilation.modules[]": "module",
+	"compilation.chunks[]": "chunk",
+	"compilation.entrypoints[]": "chunkGroup",
+	"compilation.namedChunkGroups[]": "chunkGroup",
+	"compilation.errors[]": "error",
+	"compilation.warnings[]": "error",
+	"compilation.logging[]": "loggingGroup",
+	"compilation.children[]": "compilation",
+	"asset.related[]": "asset",
+	"asset.children[]": "asset",
+	"asset.chunks[]": "assetChunk",
+	"asset.auxiliaryChunks[]": "assetChunk",
+	"asset.chunkNames[]": "assetChunkName",
+	"asset.chunkIdHints[]": "assetChunkIdHint",
+	"asset.auxiliaryChunkNames[]": "assetChunkName",
+	"asset.auxiliaryChunkIdHints[]": "assetChunkIdHint",
+	"chunkGroup.assets[]": "chunkGroupAsset",
+	"chunkGroup.auxiliaryAssets[]": "chunkGroupAsset",
+	"chunkGroupChild.assets[]": "chunkGroupAsset",
+	"chunkGroupChild.auxiliaryAssets[]": "chunkGroupAsset",
+	"chunkGroup.children[]": "chunkGroupChildGroup",
+	"chunkGroupChildGroup.children[]": "chunkGroupChild",
+	"module.modules[]": "module",
+	"module.children[]": "module",
+	"module.reasons[]": "moduleReason",
+	"moduleReason.children[]": "moduleReason",
+	"module.issuerPath[]": "moduleIssuer",
+	"chunk.origins[]": "chunkOrigin",
+	"chunk.modules[]": "module",
+	"loggingGroup.entries[]": logEntry =>
+		`loggingEntry(${logEntry.type}).loggingEntry`,
+	"loggingEntry.children[]": logEntry =>
+		`loggingEntry(${logEntry.type}).loggingEntry`,
+	"error.moduleTrace[]": "moduleTraceItem",
+	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
+};
+
+const ERROR_PREFERRED_ORDER = [
+	"compilerPath",
+	"chunkId",
+	"chunkEntry",
+	"chunkInitial",
+	"file",
+	"separator!",
+	"moduleName",
+	"loc",
+	"separator!",
+	"message",
+	"separator!",
+	"details",
+	"separator!",
+	"stack",
+	"separator!",
+	"missing",
+	"separator!",
+	"moduleTrace"
+];
+
+/** @type {Record<string, string[]>} */
+const PREFERRED_ORDERS = {
+	compilation: [
+		"name",
+		"hash",
+		"version",
+		"time",
+		"builtAt",
+		"env",
+		"publicPath",
+		"assets",
+		"filteredAssets",
+		"entrypoints",
+		"namedChunkGroups",
+		"chunks",
+		"modules",
+		"filteredModules",
+		"children",
+		"logging",
+		"warnings",
+		"warningsInChildren!",
+		"filteredWarningDetailsCount",
+		"errors",
+		"errorsInChildren!",
+		"filteredErrorDetailsCount",
+		"summary!",
+		"needAdditionalPass"
+	],
+	asset: [
+		"type",
+		"name",
+		"size",
+		"chunks",
+		"auxiliaryChunks",
+		"emitted",
+		"comparedForEmit",
+		"cached",
+		"info",
+		"isOverSizeLimit",
+		"chunkNames",
+		"auxiliaryChunkNames",
+		"chunkIdHints",
+		"auxiliaryChunkIdHints",
+		"related",
+		"filteredRelated",
+		"children",
+		"filteredChildren"
+	],
+	"asset.info": [
+		"immutable",
+		"sourceFilename",
+		"javascriptModule",
+		"development",
+		"hotModuleReplacement"
+	],
+	chunkGroup: [
+		"kind!",
+		"name",
+		"isOverSizeLimit",
+		"assetsSize",
+		"auxiliaryAssetsSize",
+		"is!",
+		"assets",
+		"filteredAssets",
+		"auxiliaryAssets",
+		"filteredAuxiliaryAssets",
+		"separator!",
+		"children"
+	],
+	chunkGroupAsset: ["name", "size"],
+	chunkGroupChildGroup: ["type", "children"],
+	chunkGroupChild: ["assets", "chunks", "name"],
+	module: [
+		"type",
+		"name",
+		"identifier",
+		"id",
+		"layer",
+		"sizes",
+		"chunks",
+		"depth",
+		"cacheable",
+		"orphan",
+		"runtime",
+		"optional",
+		"dependent",
+		"built",
+		"codeGenerated",
+		"cached",
+		"assets",
+		"failed",
+		"warnings",
+		"errors",
+		"children",
+		"filteredChildren",
+		"providedExports",
+		"usedExports",
+		"optimizationBailout",
+		"reasons",
+		"filteredReasons",
+		"issuerPath",
+		"profile",
+		"modules",
+		"filteredModules"
+	],
+	moduleReason: [
+		"active",
+		"type",
+		"userRequest",
+		"moduleId",
+		"module",
+		"resolvedModule",
+		"loc",
+		"explanation",
+		"children",
+		"filteredChildren"
+	],
+	"module.profile": [
+		"total",
+		"separator!",
+		"resolving",
+		"restoring",
+		"integration",
+		"building",
+		"storing",
+		"additionalResolving",
+		"additionalIntegration"
+	],
+	chunk: [
+		"id",
+		"runtime",
+		"files",
+		"names",
+		"idHints",
+		"sizes",
+		"parents",
+		"siblings",
+		"children",
+		"childrenByOrder",
+		"entry",
+		"initial",
+		"rendered",
+		"recorded",
+		"reason",
+		"separator!",
+		"origins",
+		"separator!",
+		"modules",
+		"separator!",
+		"filteredModules"
+	],
+	chunkOrigin: ["request", "moduleId", "moduleName", "loc"],
+	error: ERROR_PREFERRED_ORDER,
+	warning: ERROR_PREFERRED_ORDER,
+	"chunk.childrenByOrder[]": ["type", "children"],
+	loggingGroup: [
+		"debug",
+		"name",
+		"separator!",
+		"entries",
+		"separator!",
+		"filteredEntries"
+	],
+	loggingEntry: ["message", "trace", "children"]
+};
+
+const itemsJoinOneLine = items => items.filter(Boolean).join(" ");
+const itemsJoinOneLineBrackets = items =>
+	items.length > 0 ? `(${items.filter(Boolean).join(" ")})` : undefined;
+const itemsJoinMoreSpacing = items => items.filter(Boolean).join("\n\n");
+const itemsJoinComma = items => items.filter(Boolean).join(", ");
+const itemsJoinCommaBrackets = items =>
+	items.length > 0 ? `(${items.filter(Boolean).join(", ")})` : undefined;
+const itemsJoinCommaBracketsWithName = name => items =>
+	items.length > 0
+		? `(${name}: ${items.filter(Boolean).join(", ")})`
+		: undefined;
+
+/** @type {Record<string, (items: string[]) => string>} */
+const SIMPLE_ITEMS_JOINER = {
+	"chunk.parents": itemsJoinOneLine,
+	"chunk.siblings": itemsJoinOneLine,
+	"chunk.children": itemsJoinOneLine,
+	"chunk.names": itemsJoinCommaBrackets,
+	"chunk.idHints": itemsJoinCommaBracketsWithName("id hint"),
+	"chunk.runtime": itemsJoinCommaBracketsWithName("runtime"),
+	"chunk.files": itemsJoinComma,
+	"chunk.childrenByOrder": itemsJoinOneLine,
+	"chunk.childrenByOrder[].children": itemsJoinOneLine,
+	"chunkGroup.assets": itemsJoinOneLine,
+	"chunkGroup.auxiliaryAssets": itemsJoinOneLineBrackets,
+	"chunkGroupChildGroup.children": itemsJoinComma,
+	"chunkGroupChild.assets": itemsJoinOneLine,
+	"chunkGroupChild.auxiliaryAssets": itemsJoinOneLineBrackets,
+	"asset.chunks": itemsJoinComma,
+	"asset.auxiliaryChunks": itemsJoinCommaBrackets,
+	"asset.chunkNames": itemsJoinCommaBracketsWithName("name"),
+	"asset.auxiliaryChunkNames": itemsJoinCommaBracketsWithName("auxiliary name"),
+	"asset.chunkIdHints": itemsJoinCommaBracketsWithName("id hint"),
+	"asset.auxiliaryChunkIdHints":
+		itemsJoinCommaBracketsWithName("auxiliary id hint"),
+	"module.chunks": itemsJoinOneLine,
+	"module.issuerPath": items =>
+		items
+			.filter(Boolean)
+			.map(item => `${item} ->`)
+			.join(" "),
+	"compilation.errors": itemsJoinMoreSpacing,
+	"compilation.warnings": itemsJoinMoreSpacing,
+	"compilation.logging": itemsJoinMoreSpacing,
+	"compilation.children": items => indent(itemsJoinMoreSpacing(items), "  "),
+	"moduleTraceItem.dependencies": itemsJoinOneLine,
+	"loggingEntry.children": items =>
+		indent(items.filter(Boolean).join("\n"), "  ", false)
+};
+
+const joinOneLine = items =>
+	items
+		.map(item => item.content)
+		.filter(Boolean)
+		.join(" ");
+
+const joinInBrackets = items => {
+	const res = [];
+	let mode = 0;
+	for (const item of items) {
+		if (item.element === "separator!") {
+			switch (mode) {
+				case 0:
+				case 1:
+					mode += 2;
+					break;
+				case 4:
+					res.push(")");
+					mode = 3;
+					break;
+			}
+		}
+		if (!item.content) continue;
+		switch (mode) {
+			case 0:
+				mode = 1;
+				break;
+			case 1:
+				res.push(" ");
+				break;
+			case 2:
+				res.push("(");
+				mode = 4;
+				break;
+			case 3:
+				res.push(" (");
+				mode = 4;
+				break;
+			case 4:
+				res.push(", ");
+				break;
 		}
+		res.push(item.content);
 	}
-	return result;
+	if (mode === 4) res.push(")");
+	return res.join("");
 };
 
-/**
- * @typedef {BufferSerializableType[]} DeserializedType
- * @typedef {true} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class FileMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {IntermediateFileSystem} fs filesystem
-	 * @param {string | Hash} hashFunction hash function to use
-	 */
-	constructor(fs, hashFunction = "md4") {
-		super();
-		this.fs = fs;
-		this._hashFunction = hashFunction;
-	}
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		const { filename, extension = "" } = context;
-		return new Promise((resolve, reject) => {
-			mkdirp(this.fs, dirname(this.fs, filename), err => {
-				if (err) return reject(err);
-
-				// It's important that we don't touch existing files during serialization
-				// because serialize may read existing files (when deserializing)
-				const allWrittenFiles = new Set();
-				const writeFile = async (name, content) => {
-					const file = name
-						? join(this.fs, filename, `../${name}${extension}`)
-						: filename;
-					await new Promise((resolve, reject) => {
-						let stream = this.fs.createWriteStream(file + "_");
-						let compression;
-						if (file.endsWith(".gz")) {
-							compression = createGzip({
-								chunkSize: COMPRESSION_CHUNK_SIZE,
-								level: zConstants.Z_BEST_SPEED
-							});
-						} else if (file.endsWith(".br")) {
-							compression = createBrotliCompress({
-								chunkSize: COMPRESSION_CHUNK_SIZE,
-								params: {
-									[zConstants.BROTLI_PARAM_MODE]: zConstants.BROTLI_MODE_TEXT,
-									[zConstants.BROTLI_PARAM_QUALITY]: 2,
-									[zConstants.BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING]: true,
-									[zConstants.BROTLI_PARAM_SIZE_HINT]: content.reduce(
-										(size, b) => size + b.length,
-										0
-									)
-								}
-							});
-						}
-						if (compression) {
-							pipeline(compression, stream, reject);
-							stream = compression;
-							stream.on("finish", () => resolve());
-						} else {
-							stream.on("error", err => reject(err));
-							stream.on("finish", () => resolve());
-						}
-						for (const b of content) stream.write(b);
-						stream.end();
-					});
-					if (name) allWrittenFiles.add(file);
-				};
-
-				resolve(
-					serialize(this, data, false, writeFile, this._hashFunction).then(
-						async ({ backgroundJob }) => {
-							await backgroundJob;
+const indent = (str, prefix, noPrefixInFirstLine) => {
+	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+	if (noPrefixInFirstLine) return rem;
+	const ind = str[0] === "\n" ? "" : prefix;
+	return ind + rem;
+};
 
-							// Rename the index file to disallow access during inconsistent file state
-							await new Promise(resolve =>
-								this.fs.rename(filename, filename + ".old", err => {
-									resolve();
-								})
-							);
+const joinExplicitNewLine = (items, indenter) => {
+	let firstInLine = true;
+	let first = true;
+	return items
+		.map(item => {
+			if (!item || !item.content) return;
+			let content = indent(item.content, first ? "" : indenter, !firstInLine);
+			if (firstInLine) {
+				content = content.replace(/^\n+/, "");
+			}
+			if (!content) return;
+			first = false;
+			const noJoiner = firstInLine || content.startsWith("\n");
+			firstInLine = content.endsWith("\n");
+			return noJoiner ? content : " " + content;
+		})
+		.filter(Boolean)
+		.join("")
+		.trim();
+};
 
-							// update all written files
-							await Promise.all(
-								Array.from(
-									allWrittenFiles,
-									file =>
-										new Promise((resolve, reject) => {
-											this.fs.rename(file + "_", file, err => {
-												if (err) return reject(err);
-												resolve();
-											});
-										})
-								)
-							);
+const joinError =
+	error =>
+	(items, { red, yellow }) =>
+		`${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(
+			items,
+			""
+		)}`;
 
-							// As final step automatically update the index file to have a consistent pack again
-							await new Promise(resolve => {
-								this.fs.rename(filename + "_", filename, err => {
-									if (err) return reject(err);
-									resolve();
-								});
-							});
-							return /** @type {true} */ (true);
+/** @type {Record<string, (items: ({ element: string, content: string })[], context: StatsPrinterContext) => string>} */
+const SIMPLE_ELEMENT_JOINERS = {
+	compilation: items => {
+		const result = [];
+		let lastNeedMore = false;
+		for (const item of items) {
+			if (!item.content) continue;
+			const needMoreSpace =
+				item.element === "warnings" ||
+				item.element === "filteredWarningDetailsCount" ||
+				item.element === "errors" ||
+				item.element === "filteredErrorDetailsCount" ||
+				item.element === "logging";
+			if (result.length !== 0) {
+				result.push(needMoreSpace || lastNeedMore ? "\n\n" : "\n");
+			}
+			result.push(item.content);
+			lastNeedMore = needMoreSpace;
+		}
+		if (lastNeedMore) result.push("\n");
+		return result.join("");
+	},
+	asset: items =>
+		joinExplicitNewLine(
+			items.map(item => {
+				if (
+					(item.element === "related" || item.element === "children") &&
+					item.content
+				) {
+					return {
+						...item,
+						content: `\n${item.content}\n`
+					};
+				}
+				return item;
+			}),
+			"  "
+		),
+	"asset.info": joinOneLine,
+	module: (items, { module }) => {
+		let hasName = false;
+		return joinExplicitNewLine(
+			items.map(item => {
+				switch (item.element) {
+					case "id":
+						if (module.id === module.name) {
+							if (hasName) return false;
+							if (item.content) hasName = true;
 						}
-					)
-				);
-			});
-		});
-	}
-
-	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
-	 */
-	deserialize(data, context) {
-		const { filename, extension = "" } = context;
-		const readFile = name =>
-			new Promise((resolve, reject) => {
-				const file = name
-					? join(this.fs, filename, `../${name}${extension}`)
-					: filename;
-				this.fs.stat(file, (err, stats) => {
-					if (err) {
-						reject(err);
-						return;
-					}
-					let remaining = /** @type {number} */ (stats.size);
-					let currentBuffer;
-					let currentBufferUsed;
-					const buf = [];
-					let decompression;
-					if (file.endsWith(".gz")) {
-						decompression = createGunzip({
-							chunkSize: DECOMPRESSION_CHUNK_SIZE
-						});
-					} else if (file.endsWith(".br")) {
-						decompression = createBrotliDecompress({
-							chunkSize: DECOMPRESSION_CHUNK_SIZE
-						});
-					}
-					if (decompression) {
-						let newResolve, newReject;
-						resolve(
-							Promise.all([
-								new Promise((rs, rj) => {
-									newResolve = rs;
-									newReject = rj;
-								}),
-								new Promise((resolve, reject) => {
-									decompression.on("data", chunk => buf.push(chunk));
-									decompression.on("end", () => resolve());
-									decompression.on("error", err => reject(err));
-								})
-							]).then(() => buf)
-						);
-						resolve = newResolve;
-						reject = newReject;
+						break;
+					case "name":
+						if (hasName) return false;
+						if (item.content) hasName = true;
+						break;
+					case "providedExports":
+					case "usedExports":
+					case "optimizationBailout":
+					case "reasons":
+					case "issuerPath":
+					case "profile":
+					case "children":
+					case "modules":
+						if (item.content) {
+							return {
+								...item,
+								content: `\n${item.content}\n`
+							};
+						}
+						break;
+				}
+				return item;
+			}),
+			"  "
+		);
+	},
+	chunk: items => {
+		let hasEntry = false;
+		return (
+			"chunk " +
+			joinExplicitNewLine(
+				items.filter(item => {
+					switch (item.element) {
+						case "entry":
+							if (item.content) hasEntry = true;
+							break;
+						case "initial":
+							if (hasEntry) return false;
+							break;
 					}
-					this.fs.open(file, "r", (err, fd) => {
-						if (err) {
-							reject(err);
-							return;
+					return true;
+				}),
+				"  "
+			)
+		);
+	},
+	"chunk.childrenByOrder[]": items => `(${joinOneLine(items)})`,
+	chunkGroup: items => joinExplicitNewLine(items, "  "),
+	chunkGroupAsset: joinOneLine,
+	chunkGroupChildGroup: joinOneLine,
+	chunkGroupChild: joinOneLine,
+	// moduleReason: (items, { moduleReason }) => {
+	// 	let hasName = false;
+	// 	return joinOneLine(
+	// 		items.filter(item => {
+	// 			switch (item.element) {
+	// 				case "moduleId":
+	// 					if (moduleReason.moduleId === moduleReason.module && item.content)
+	// 						hasName = true;
+	// 					break;
+	// 				case "module":
+	// 					if (hasName) return false;
+	// 					break;
+	// 				case "resolvedModule":
+	// 					return (
+	// 						moduleReason.module !== moduleReason.resolvedModule &&
+	// 						item.content
+	// 					);
+	// 			}
+	// 			return true;
+	// 		})
+	// 	);
+	// },
+	moduleReason: (items, { moduleReason }) => {
+		let hasName = false;
+		return joinExplicitNewLine(
+			items.map(item => {
+				switch (item.element) {
+					case "moduleId":
+						if (moduleReason.moduleId === moduleReason.module && item.content)
+							hasName = true;
+						break;
+					case "module":
+						if (hasName) return false;
+						break;
+					case "resolvedModule":
+						if (moduleReason.module === moduleReason.resolvedModule)
+							return false;
+						break;
+					case "children":
+						if (item.content) {
+							return {
+								...item,
+								content: `\n${item.content}\n`
+							};
 						}
-						const read = () => {
-							if (currentBuffer === undefined) {
-								currentBuffer = Buffer.allocUnsafeSlow(
-									Math.min(
-										constants.MAX_LENGTH,
-										remaining,
-										decompression ? DECOMPRESSION_CHUNK_SIZE : Infinity
-									)
-								);
-								currentBufferUsed = 0;
-							}
-							let readBuffer = currentBuffer;
-							let readOffset = currentBufferUsed;
-							let readLength = currentBuffer.length - currentBufferUsed;
-							// values passed to fs.read must be valid int32 values
-							if (readOffset > 0x7fffffff) {
-								readBuffer = currentBuffer.slice(readOffset);
-								readOffset = 0;
-							}
-							if (readLength > 0x7fffffff) {
-								readLength = 0x7fffffff;
-							}
-							this.fs.read(
-								fd,
-								readBuffer,
-								readOffset,
-								readLength,
-								null,
-								(err, bytesRead) => {
-									if (err) {
-										this.fs.close(fd, () => {
-											reject(err);
-										});
-										return;
-									}
-									currentBufferUsed += bytesRead;
-									remaining -= bytesRead;
-									if (currentBufferUsed === currentBuffer.length) {
-										if (decompression) {
-											decompression.write(currentBuffer);
-										} else {
-											buf.push(currentBuffer);
-										}
-										currentBuffer = undefined;
-										if (remaining === 0) {
-											if (decompression) {
-												decompression.end();
-											}
-											this.fs.close(fd, err => {
-												if (err) {
-													reject(err);
-													return;
-												}
-												resolve(buf);
-											});
-											return;
-										}
-									}
-									read();
-								}
-							);
-						};
-						read();
-					});
-				});
+						break;
+				}
+				return item;
+			}),
+			"  "
+		);
+	},
+	"module.profile": joinInBrackets,
+	moduleIssuer: joinOneLine,
+	chunkOrigin: items => "> " + joinOneLine(items),
+	"errors[].error": joinError(true),
+	"warnings[].error": joinError(false),
+	loggingGroup: items => joinExplicitNewLine(items, "").trimRight(),
+	moduleTraceItem: items => " @ " + joinOneLine(items),
+	moduleTraceDependency: joinOneLine
+};
+
+const AVAILABLE_COLORS = {
+	bold: "\u001b[1m",
+	yellow: "\u001b[1m\u001b[33m",
+	red: "\u001b[1m\u001b[31m",
+	green: "\u001b[1m\u001b[32m",
+	cyan: "\u001b[1m\u001b[36m",
+	magenta: "\u001b[1m\u001b[35m"
+};
+
+const AVAILABLE_FORMATS = {
+	formatChunkId: (id, { yellow }, direction) => {
+		switch (direction) {
+			case "parent":
+				return `<{${yellow(id)}}>`;
+			case "sibling":
+				return `={${yellow(id)}}=`;
+			case "child":
+				return `>{${yellow(id)}}<`;
+			default:
+				return `{${yellow(id)}}`;
+		}
+	},
+	formatModuleId: id => `[${id}]`,
+	formatFilename: (filename, { green, yellow }, oversize) =>
+		(oversize ? yellow : green)(filename),
+	formatFlag: flag => `[${flag}]`,
+	formatLayer: layer => `(in ${layer})`,
+	formatSize: (__webpack_require__(71070).formatSize),
+	formatDateTime: (dateTime, { bold }) => {
+		const d = new Date(dateTime);
+		const x = twoDigit;
+		const date = `${d.getFullYear()}-${x(d.getMonth() + 1)}-${x(d.getDate())}`;
+		const time = `${x(d.getHours())}:${x(d.getMinutes())}:${x(d.getSeconds())}`;
+		return `${date} ${bold(time)}`;
+	},
+	formatTime: (
+		time,
+		{ timeReference, bold, green, yellow, red },
+		boldQuantity
+	) => {
+		const unit = " ms";
+		if (timeReference && time !== timeReference) {
+			const times = [
+				timeReference / 2,
+				timeReference / 4,
+				timeReference / 8,
+				timeReference / 16
+			];
+			if (time < times[3]) return `${time}${unit}`;
+			else if (time < times[2]) return bold(`${time}${unit}`);
+			else if (time < times[1]) return green(`${time}${unit}`);
+			else if (time < times[0]) return yellow(`${time}${unit}`);
+			else return red(`${time}${unit}`);
+		} else {
+			return `${boldQuantity ? bold(time) : time}${unit}`;
+		}
+	},
+	formatError: (message, { green, yellow, red }) => {
+		if (message.includes("\u001b[")) return message;
+		const highlights = [
+			{ regExp: /(Did you mean .+)/g, format: green },
+			{
+				regExp: /(Set 'mode' option to 'development' or 'production')/g,
+				format: green
+			},
+			{ regExp: /(\(module has no exports\))/g, format: red },
+			{ regExp: /\(possible exports: (.+)\)/g, format: green },
+			{ regExp: /(?:^|\n)(.* doesn't exist)/g, format: red },
+			{ regExp: /('\w+' option has not been set)/g, format: red },
+			{
+				regExp: /(Emitted value instead of an instance of Error)/g,
+				format: yellow
+			},
+			{ regExp: /(Used? .+ instead)/gi, format: yellow },
+			{ regExp: /\b(deprecated|must|required)\b/g, format: yellow },
+			{
+				regExp: /\b(BREAKING CHANGE)\b/gi,
+				format: red
+			},
+			{
+				regExp:
+					/\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
+				format: red
+			}
+		];
+		for (const { regExp, format } of highlights) {
+			message = message.replace(regExp, (match, content) => {
+				return match.replace(content, format(content));
 			});
-		return deserialize(this, false, readFile);
+		}
+		return message;
 	}
-}
-
-module.exports = FileMiddleware;
-
-
-/***/ }),
-
-/***/ 86791:
-/***/ (function(module) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
+};
 
+const RESULT_MODIFIER = {
+	"module.modules": result => {
+		return indent(result, "| ");
+	}
+};
 
-class MapObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.size);
-		for (const key of obj.keys()) {
-			write(key);
-		}
-		for (const value of obj.values()) {
-			write(value);
+const createOrder = (array, preferredOrder) => {
+	const originalArray = array.slice();
+	const set = new Set(array);
+	const usedSet = new Set();
+	array.length = 0;
+	for (const element of preferredOrder) {
+		if (element.endsWith("!") || set.has(element)) {
+			array.push(element);
+			usedSet.add(element);
 		}
 	}
-	deserialize({ read }) {
-		let size = read();
-		const map = new Map();
-		const keys = [];
-		for (let i = 0; i < size; i++) {
-			keys.push(read());
-		}
-		for (let i = 0; i < size; i++) {
-			map.set(keys[i], read());
+	for (const element of originalArray) {
+		if (!usedSet.has(element)) {
+			array.push(element);
 		}
-		return map;
 	}
-}
-
-module.exports = MapObjectSerializer;
+	return array;
+};
 
+class DefaultStatsPrinterPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap("DefaultStatsPrinterPlugin", compilation => {
+			compilation.hooks.statsPrinter.tap(
+				"DefaultStatsPrinterPlugin",
+				(stats, options, context) => {
+					// Put colors into context
+					stats.hooks.print
+						.for("compilation")
+						.tap("DefaultStatsPrinterPlugin", (compilation, context) => {
+							for (const color of Object.keys(AVAILABLE_COLORS)) {
+								let start;
+								if (options.colors) {
+									if (
+										typeof options.colors === "object" &&
+										typeof options.colors[color] === "string"
+									) {
+										start = options.colors[color];
+									} else {
+										start = AVAILABLE_COLORS[color];
+									}
+								}
+								if (start) {
+									context[color] = str =>
+										`${start}${
+											typeof str === "string"
+												? str.replace(
+														/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
+														`$1${start}`
+												  )
+												: str
+										}\u001b[39m\u001b[22m`;
+								} else {
+									context[color] = str => str;
+								}
+							}
+							for (const format of Object.keys(AVAILABLE_FORMATS)) {
+								context[format] = (content, ...args) =>
+									AVAILABLE_FORMATS[format](content, context, ...args);
+							}
+							context.timeReference = compilation.time;
+						});
 
-/***/ }),
+					for (const key of Object.keys(SIMPLE_PRINTERS)) {
+						stats.hooks.print
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
+								SIMPLE_PRINTERS[key](obj, ctx, stats)
+							);
+					}
 
-/***/ 21048:
-/***/ (function(module) {
+					for (const key of Object.keys(PREFERRED_ORDERS)) {
+						const preferredOrder = PREFERRED_ORDERS[key];
+						stats.hooks.sortElements
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", (elements, context) => {
+								createOrder(elements, preferredOrder);
+							});
+					}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+					for (const key of Object.keys(ITEM_NAMES)) {
+						const itemName = ITEM_NAMES[key];
+						stats.hooks.getItemName
+							.for(key)
+							.tap(
+								"DefaultStatsPrinterPlugin",
+								typeof itemName === "string" ? () => itemName : itemName
+							);
+					}
 
+					for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
+						const joiner = SIMPLE_ITEMS_JOINER[key];
+						stats.hooks.printItems
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", joiner);
+					}
 
+					for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
+						const joiner = SIMPLE_ELEMENT_JOINERS[key];
+						stats.hooks.printElements
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", joiner);
+					}
 
-class NullPrototypeObjectSerializer {
-	serialize(obj, { write }) {
-		const keys = Object.keys(obj);
-		for (const key of keys) {
-			write(key);
-		}
-		write(null);
-		for (const key of keys) {
-			write(obj[key]);
-		}
-	}
-	deserialize({ read }) {
-		const obj = Object.create(null);
-		const keys = [];
-		let key = read();
-		while (key !== null) {
-			keys.push(key);
-			key = read();
-		}
-		for (const key of keys) {
-			obj[key] = read();
-		}
-		return obj;
+					for (const key of Object.keys(RESULT_MODIFIER)) {
+						const modifier = RESULT_MODIFIER[key];
+						stats.hooks.result
+							.for(key)
+							.tap("DefaultStatsPrinterPlugin", modifier);
+					}
+				}
+			);
+		});
 	}
 }
-
-module.exports = NullPrototypeObjectSerializer;
+module.exports = DefaultStatsPrinterPlugin;
 
 
 /***/ }),
 
-/***/ 34795:
-/***/ (function(module, exports, __webpack_require__) {
+/***/ 92629:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const createHash = __webpack_require__(49835);
-const ArraySerializer = __webpack_require__(41721);
-const DateObjectSerializer = __webpack_require__(93475);
-const ErrorObjectSerializer = __webpack_require__(79479);
-const MapObjectSerializer = __webpack_require__(86791);
-const NullPrototypeObjectSerializer = __webpack_require__(21048);
-const PlainObjectSerializer = __webpack_require__(33040);
-const RegExpObjectSerializer = __webpack_require__(57328);
-const SerializerMiddleware = __webpack_require__(83137);
-const SetObjectSerializer = __webpack_require__(79240);
-
-/** @typedef {typeof import("../util/Hash")} Hash */
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
-
-/** @typedef {new (...params: any[]) => any} Constructor */
-
-/*
-
-Format:
-
-File -> Section*
-Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
-
-ObjectSection -> ESCAPE (
-	number:relativeOffset (number > 0) |
-	string:request (string|null):export
-) Section:value* ESCAPE ESCAPE_END_OBJECT
-ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
-EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
-EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
-OtherSection -> any (except ESCAPE)
-
-Why using null as escape value?
-Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
-Technically any value can be used.
+const { HookMap, SyncBailHook, SyncWaterfallHook } = __webpack_require__(6967);
+const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
+const smartGrouping = __webpack_require__(15652);
 
-*/
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/**
- * @typedef {Object} ObjectSerializerContext
- * @property {function(any): void} write
- */
+/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
 
 /**
- * @typedef {Object} ObjectDeserializerContext
- * @property {function(): any} read
+ * @typedef {Object} KnownStatsFactoryContext
+ * @property {string} type
+ * @property {function(string): string=} makePathsRelative
+ * @property {Compilation=} compilation
+ * @property {Set<Module>=} rootModules
+ * @property {Map<string,Chunk[]>=} compilationFileToChunks
+ * @property {Map<string,Chunk[]>=} compilationAuxiliaryFileToChunks
+ * @property {RuntimeSpec=} runtime
+ * @property {function(Compilation): WebpackError[]=} cachedGetErrors
+ * @property {function(Compilation): WebpackError[]=} cachedGetWarnings
  */
 
-/**
- * @typedef {Object} ObjectSerializer
- * @property {function(any, ObjectSerializerContext): void} serialize
- * @property {function(ObjectDeserializerContext): any} deserialize
- */
+/** @typedef {KnownStatsFactoryContext & Record<string, any>} StatsFactoryContext */
 
-const setSetSize = (set, size) => {
-	let i = 0;
-	for (const item of set) {
-		if (i++ >= size) {
-			set.delete(item);
+class StatsFactory {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[Object, any, StatsFactoryContext]>>} */
+			extract: new HookMap(
+				() => new SyncBailHook(["object", "data", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
+			filter: new HookMap(
+				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
+			),
+			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
+			sort: new HookMap(() => new SyncBailHook(["comparators", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
+			filterSorted: new HookMap(
+				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
+			),
+			/** @type {HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext]>>} */
+			groupResults: new HookMap(
+				() => new SyncBailHook(["groupConfigs", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
+			sortResults: new HookMap(
+				() => new SyncBailHook(["comparators", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
+			filterResults: new HookMap(
+				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
+			),
+			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
+			merge: new HookMap(() => new SyncBailHook(["items", "context"])),
+			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
+			result: new HookMap(() => new SyncWaterfallHook(["result", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
+			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
+			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
+		});
+		const hooks = this.hooks;
+		this._caches =
+			/** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
+		for (const key of Object.keys(hooks)) {
+			this._caches[key] = new Map();
 		}
+		this._inCreate = false;
 	}
-};
 
-const setMapSize = (map, size) => {
-	let i = 0;
-	for (const item of map.keys()) {
-		if (i++ >= size) {
-			map.delete(item);
+	_getAllLevelHooks(hookMap, cache, type) {
+		const cacheEntry = cache.get(type);
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
+		const hooks = [];
+		const typeParts = type.split(".");
+		for (let i = 0; i < typeParts.length; i++) {
+			const hook = hookMap.get(typeParts.slice(i).join("."));
+			if (hook) {
+				hooks.push(hook);
+			}
 		}
+		cache.set(type, hooks);
+		return hooks;
 	}
-};
-
-/**
- * @param {Buffer} buffer buffer
- * @param {string | Hash} hashFunction hash function to use
- * @returns {string} hash
- */
-const toHash = (buffer, hashFunction) => {
-	const hash = createHash(hashFunction);
-	hash.update(buffer);
-	return /** @type {string} */ (hash.digest("latin1"));
-};
-
-const ESCAPE = null;
-const ESCAPE_ESCAPE_VALUE = null;
-const ESCAPE_END_OBJECT = true;
-const ESCAPE_UNDEFINED = false;
-
-const CURRENT_VERSION = 2;
 
-const serializers = new Map();
-const serializerInversed = new Map();
-
-const loadedRequests = new Set();
-
-const NOT_SERIALIZABLE = {};
-
-const jsTypes = new Map();
-jsTypes.set(Object, new PlainObjectSerializer());
-jsTypes.set(Array, new ArraySerializer());
-jsTypes.set(null, new NullPrototypeObjectSerializer());
-jsTypes.set(Map, new MapObjectSerializer());
-jsTypes.set(Set, new SetObjectSerializer());
-jsTypes.set(Date, new DateObjectSerializer());
-jsTypes.set(RegExp, new RegExpObjectSerializer());
-jsTypes.set(Error, new ErrorObjectSerializer(Error));
-jsTypes.set(EvalError, new ErrorObjectSerializer(EvalError));
-jsTypes.set(RangeError, new ErrorObjectSerializer(RangeError));
-jsTypes.set(ReferenceError, new ErrorObjectSerializer(ReferenceError));
-jsTypes.set(SyntaxError, new ErrorObjectSerializer(SyntaxError));
-jsTypes.set(TypeError, new ErrorObjectSerializer(TypeError));
+	_forEachLevel(hookMap, cache, type, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
+			const result = fn(hook);
+			if (result !== undefined) return result;
+		}
+	}
 
-// If in a sandboxed environment (e. g. jest), this escapes the sandbox and registers
-// real Object and Array types to. These types may occur in the wild too, e. g. when
-// using Structured Clone in postMessage.
-if (exports.constructor !== Object) {
-	const Obj = /** @type {typeof Object} */ (exports.constructor);
-	const Fn = /** @type {typeof Function} */ (Obj.constructor);
-	for (const [type, config] of Array.from(jsTypes)) {
-		if (type) {
-			const Type = new Fn(`return ${type.name};`)();
-			jsTypes.set(Type, config);
+	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
+			data = fn(hook, data);
 		}
+		return data;
 	}
-}
 
-{
-	let i = 1;
-	for (const [type, serializer] of jsTypes) {
-		serializers.set(type, {
-			request: "",
-			name: i++,
-			serializer
+	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
+		const hooks = this._getAllLevelHooks(hookMap, cache, type);
+		if (hooks.length === 0) return forceClone ? items.slice() : items;
+		let i = 0;
+		return items.filter((item, idx) => {
+			for (const hook of hooks) {
+				const r = fn(hook, item, idx, i);
+				if (r !== undefined) {
+					if (r) i++;
+					return r;
+				}
+			}
+			i++;
+			return true;
 		});
 	}
-}
 
-for (const { request, name, serializer } of serializers.values()) {
-	serializerInversed.set(`${request}/${name}`, serializer);
-}
-
-/** @type {Map<RegExp, (request: string) => boolean>} */
-const loaders = new Map();
-
-/**
- * @typedef {ComplexSerializableType[]} DeserializedType
- * @typedef {PrimitiveSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
- */
-class ObjectMiddleware extends SerializerMiddleware {
-	/**
-	 * @param {function(any): void} extendContext context extensions
-	 * @param {string | Hash} hashFunction hash function to use
-	 */
-	constructor(extendContext, hashFunction = "md4") {
-		super();
-		this.extendContext = extendContext;
-		this._hashFunction = hashFunction;
-	}
 	/**
-	 * @param {RegExp} regExp RegExp for which the request is tested
-	 * @param {function(string): boolean} loader loader to load the request, returns true when successful
-	 * @returns {void}
+	 * @param {string} type type
+	 * @param {any} data factory data
+	 * @param {Omit<StatsFactoryContext, "type">} baseContext context used as base
+	 * @returns {any} created object
 	 */
-	static registerLoader(regExp, loader) {
-		loaders.set(regExp, loader);
+	create(type, data, baseContext) {
+		if (this._inCreate) {
+			return this._create(type, data, baseContext);
+		} else {
+			try {
+				this._inCreate = true;
+				return this._create(type, data, baseContext);
+			} finally {
+				for (const key of Object.keys(this._caches)) this._caches[key].clear();
+				this._inCreate = false;
+			}
+		}
 	}
 
-	/**
-	 * @param {Constructor} Constructor the constructor
-	 * @param {string} request the request which will be required when deserializing
-	 * @param {string} name the name to make multiple serializer unique when sharing a request
-	 * @param {ObjectSerializer} serializer the serializer
-	 * @returns {void}
-	 */
-	static register(Constructor, request, name, serializer) {
-		const key = request + "/" + name;
+	_create(type, data, baseContext) {
+		const context = {
+			...baseContext,
+			type,
+			[type]: data
+		};
+		if (Array.isArray(data)) {
+			// run filter on unsorted items
+			const items = this._forEachLevelFilter(
+				this.hooks.filter,
+				this._caches.filter,
+				type,
+				data,
+				(h, r, idx, i) => h.call(r, context, idx, i),
+				true
+			);
 
-		if (serializers.has(Constructor)) {
-			throw new Error(
-				`ObjectMiddleware.register: serializer for ${Constructor.name} is already registered`
+			// sort items
+			const comparators = [];
+			this._forEachLevel(this.hooks.sort, this._caches.sort, type, h =>
+				h.call(comparators, context)
 			);
-		}
+			if (comparators.length > 0) {
+				items.sort(
+					// @ts-expect-error number of arguments is correct
+					concatComparators(...comparators, keepOriginalOrder(items))
+				);
+			}
 
-		if (serializerInversed.has(key)) {
-			throw new Error(
-				`ObjectMiddleware.register: serializer for ${key} is already registered`
+			// run filter on sorted items
+			const items2 = this._forEachLevelFilter(
+				this.hooks.filterSorted,
+				this._caches.filterSorted,
+				type,
+				items,
+				(h, r, idx, i) => h.call(r, context, idx, i),
+				false
 			);
-		}
 
-		serializers.set(Constructor, {
-			request,
-			name,
-			serializer
-		});
+			// for each item
+			let resultItems = items2.map((item, i) => {
+				const itemContext = {
+					...context,
+					_index: i
+				};
 
-		serializerInversed.set(key, serializer);
-	}
+				// run getItemName
+				const itemName = this._forEachLevel(
+					this.hooks.getItemName,
+					this._caches.getItemName,
+					`${type}[]`,
+					h => h.call(item, itemContext)
+				);
+				if (itemName) itemContext[itemName] = item;
+				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
 
-	/**
-	 * @param {Constructor} Constructor the constructor
-	 * @returns {void}
-	 */
-	static registerNotSerializable(Constructor) {
-		if (serializers.has(Constructor)) {
-			throw new Error(
-				`ObjectMiddleware.registerNotSerializable: serializer for ${Constructor.name} is already registered`
-			);
-		}
+				// run getItemFactory
+				const itemFactory =
+					this._forEachLevel(
+						this.hooks.getItemFactory,
+						this._caches.getItemFactory,
+						innerType,
+						h => h.call(item, itemContext)
+					) || this;
 
-		serializers.set(Constructor, NOT_SERIALIZABLE);
-	}
+				// run item factory
+				return itemFactory.create(innerType, item, itemContext);
+			});
 
-	static getSerializerFor(object) {
-		const proto = Object.getPrototypeOf(object);
-		let c;
-		if (proto === null) {
-			// Object created with Object.create(null)
-			c = null;
-		} else {
-			c = proto.constructor;
-			if (!c) {
-				throw new Error(
-					"Serialization of objects with prototype without valid constructor property not possible"
+			// sort result items
+			const comparators2 = [];
+			this._forEachLevel(
+				this.hooks.sortResults,
+				this._caches.sortResults,
+				type,
+				h => h.call(comparators2, context)
+			);
+			if (comparators2.length > 0) {
+				resultItems.sort(
+					// @ts-expect-error number of arguments is correct
+					concatComparators(...comparators2, keepOriginalOrder(resultItems))
 				);
 			}
-		}
-		const config = serializers.get(c);
 
-		if (!config) throw new Error(`No serializer registered for ${c.name}`);
-		if (config === NOT_SERIALIZABLE) throw NOT_SERIALIZABLE;
+			// group result items
+			const groupConfigs = [];
+			this._forEachLevel(
+				this.hooks.groupResults,
+				this._caches.groupResults,
+				type,
+				h => h.call(groupConfigs, context)
+			);
+			if (groupConfigs.length > 0) {
+				resultItems = smartGrouping(resultItems, groupConfigs);
+			}
 
-		return config;
-	}
+			// run filter on sorted result items
+			const finalResultItems = this._forEachLevelFilter(
+				this.hooks.filterResults,
+				this._caches.filterResults,
+				type,
+				resultItems,
+				(h, r, idx, i) => h.call(r, context, idx, i),
+				false
+			);
 
-	static getDeserializerFor(request, name) {
-		const key = request + "/" + name;
-		const serializer = serializerInversed.get(key);
+			// run merge on mapped items
+			let result = this._forEachLevel(
+				this.hooks.merge,
+				this._caches.merge,
+				type,
+				h => h.call(finalResultItems, context)
+			);
+			if (result === undefined) result = finalResultItems;
 
-		if (serializer === undefined) {
-			throw new Error(`No deserializer registered for ${key}`);
-		}
+			// run result on merged items
+			return this._forEachLevelWaterfall(
+				this.hooks.result,
+				this._caches.result,
+				type,
+				result,
+				(h, r) => h.call(r, context)
+			);
+		} else {
+			const object = {};
 
-		return serializer;
-	}
+			// run extract on value
+			this._forEachLevel(this.hooks.extract, this._caches.extract, type, h =>
+				h.call(object, data, context)
+			);
 
-	static _getDeserializerForWithoutError(request, name) {
-		const key = request + "/" + name;
-		const serializer = serializerInversed.get(key);
-		return serializer;
+			// run result on extracted object
+			return this._forEachLevelWaterfall(
+				this.hooks.result,
+				this._caches.result,
+				type,
+				object,
+				(h, r) => h.call(r, context)
+			);
+		}
 	}
+}
+module.exports = StatsFactory;
 
-	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
-	 */
-	serialize(data, context) {
-		/** @type {any[]} */
-		let result = [CURRENT_VERSION];
-		let currentPos = 0;
-		let referenceable = new Map();
-		const addReferenceable = item => {
-			referenceable.set(item, currentPos++);
-		};
-		let bufferDedupeMap = new Map();
-		const dedupeBuffer = buf => {
-			const len = buf.length;
-			const entry = bufferDedupeMap.get(len);
-			if (entry === undefined) {
-				bufferDedupeMap.set(len, buf);
-				return buf;
-			}
-			if (Buffer.isBuffer(entry)) {
-				if (len < 32) {
-					if (buf.equals(entry)) {
-						return entry;
-					}
-					bufferDedupeMap.set(len, [entry, buf]);
-					return buf;
-				} else {
-					const hash = toHash(entry, this._hashFunction);
-					const newMap = new Map();
-					newMap.set(hash, entry);
-					bufferDedupeMap.set(len, newMap);
-					const hashBuf = toHash(buf, this._hashFunction);
-					if (hash === hashBuf) {
-						return entry;
-					}
-					return buf;
-				}
-			} else if (Array.isArray(entry)) {
-				if (entry.length < 16) {
-					for (const item of entry) {
-						if (buf.equals(item)) {
-							return item;
-						}
-					}
-					entry.push(buf);
-					return buf;
-				} else {
-					const newMap = new Map();
-					const hash = toHash(buf, this._hashFunction);
-					let found;
-					for (const item of entry) {
-						const itemHash = toHash(item, this._hashFunction);
-						newMap.set(itemHash, item);
-						if (found === undefined && itemHash === hash) found = item;
-					}
-					bufferDedupeMap.set(len, newMap);
-					if (found === undefined) {
-						newMap.set(hash, buf);
-						return buf;
-					} else {
-						return found;
-					}
-				}
-			} else {
-				const hash = toHash(buf, this._hashFunction);
-				const item = entry.get(hash);
-				if (item !== undefined) {
-					return item;
-				}
-				entry.set(hash, buf);
-				return buf;
-			}
-		};
-		let currentPosTypeLookup = 0;
-		let objectTypeLookup = new Map();
-		const cycleStack = new Set();
-		const stackToString = item => {
-			const arr = Array.from(cycleStack);
-			arr.push(item);
-			return arr
-				.map(item => {
-					if (typeof item === "string") {
-						if (item.length > 100) {
-							return `String ${JSON.stringify(item.slice(0, 100)).slice(
-								0,
-								-1
-							)}..."`;
-						}
-						return `String ${JSON.stringify(item)}`;
-					}
-					try {
-						const { request, name } = ObjectMiddleware.getSerializerFor(item);
-						if (request) {
-							return `${request}${name ? `.${name}` : ""}`;
-						}
-					} catch (e) {
-						// ignore -> fallback
-					}
-					if (typeof item === "object" && item !== null) {
-						if (item.constructor) {
-							if (item.constructor === Object)
-								return `Object { ${Object.keys(item).join(", ")} }`;
-							if (item.constructor === Map) return `Map { ${item.size} items }`;
-							if (item.constructor === Array)
-								return `Array { ${item.length} items }`;
-							if (item.constructor === Set) return `Set { ${item.size} items }`;
-							if (item.constructor === RegExp) return item.toString();
-							return `${item.constructor.name}`;
-						}
-						return `Object [null prototype] { ${Object.keys(item).join(
-							", "
-						)} }`;
-					}
-					try {
-						return `${item}`;
-					} catch (e) {
-						return `(${e.message})`;
-					}
-				})
-				.join(" -> ");
-		};
-		let hasDebugInfoAttached;
-		let ctx = {
-			write(value, key) {
-				try {
-					process(value);
-				} catch (e) {
-					if (e !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined)
-							hasDebugInfoAttached = new WeakSet();
-						if (!hasDebugInfoAttached.has(e)) {
-							e.message += `\nwhile serializing ${stackToString(value)}`;
-							hasDebugInfoAttached.add(e);
-						}
-					}
-					throw e;
-				}
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			snapshot() {
-				return {
-					length: result.length,
-					cycleStackSize: cycleStack.size,
-					referenceableSize: referenceable.size,
-					currentPos,
-					objectTypeLookupSize: objectTypeLookup.size,
-					currentPosTypeLookup
-				};
-			},
-			rollback(snapshot) {
-				result.length = snapshot.length;
-				setSetSize(cycleStack, snapshot.cycleStackSize);
-				setMapSize(referenceable, snapshot.referenceableSize);
-				currentPos = snapshot.currentPos;
-				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
-				currentPosTypeLookup = snapshot.currentPosTypeLookup;
-			},
-			...context
-		};
-		this.extendContext(ctx);
-		const process = item => {
-			if (Buffer.isBuffer(item)) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
-					return;
-				}
-				const alreadyUsedBuffer = dedupeBuffer(item);
-				if (alreadyUsedBuffer !== item) {
-					const ref = referenceable.get(alreadyUsedBuffer);
-					if (ref !== undefined) {
-						referenceable.set(item, ref);
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-					item = alreadyUsedBuffer;
-				}
-				addReferenceable(item);
 
-				result.push(item);
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-			} else if (
-				typeof item === "object"
-				// We don't have to check for null as ESCAPE is null and this has been checked before
-			) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
-					return;
-				}
+/***/ }),
 
-				if (cycleStack.has(item)) {
-					throw new Error(
-						`This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize.`
-					);
-				}
+/***/ 30198:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				const { request, name, serializer } =
-					ObjectMiddleware.getSerializerFor(item);
-				const key = `${request}/${name}`;
-				const lastIndex = objectTypeLookup.get(key);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				if (lastIndex === undefined) {
-					objectTypeLookup.set(key, currentPosTypeLookup++);
 
-					result.push(ESCAPE, request, name);
-				} else {
-					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
-				}
 
-				cycleStack.add(item);
+const { HookMap, SyncWaterfallHook, SyncBailHook } = __webpack_require__(6967);
 
-				try {
-					serializer.serialize(item, ctx);
-				} finally {
-					cycleStack.delete(item);
-				}
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("tapable").Hook} Hook */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
 
-				result.push(ESCAPE, ESCAPE_END_OBJECT);
+/**
+ * @typedef {Object} PrintedElement
+ * @property {string} element
+ * @property {string} content
+ */
 
-				addReferenceable(item);
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-					addReferenceable(item);
-				}
+/**
+ * @typedef {Object} KnownStatsPrinterContext
+ * @property {string=} type
+ * @property {StatsCompilation=} compilation
+ * @property {StatsChunkGroup=} chunkGroup
+ * @property {StatsAsset=} asset
+ * @property {StatsModule=} module
+ * @property {StatsChunk=} chunk
+ * @property {StatsModuleReason=} moduleReason
+ * @property {(str: string) => string=} bold
+ * @property {(str: string) => string=} yellow
+ * @property {(str: string) => string=} red
+ * @property {(str: string) => string=} green
+ * @property {(str: string) => string=} magenta
+ * @property {(str: string) => string=} cyan
+ * @property {(file: string, oversize?: boolean) => string=} formatFilename
+ * @property {(id: string) => string=} formatModuleId
+ * @property {(id: string, direction?: "parent"|"child"|"sibling") => string=} formatChunkId
+ * @property {(size: number) => string=} formatSize
+ * @property {(dateTime: number) => string=} formatDateTime
+ * @property {(flag: string) => string=} formatFlag
+ * @property {(time: number, boldQuantity?: boolean) => string=} formatTime
+ * @property {string=} chunkGroupKind
+ */
 
-				if (item.length > 102400 && context.logger) {
-					context.logger.warn(
-						`Serializing big strings (${Math.round(
-							item.length / 1024
-						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
-					);
-				}
+/** @typedef {KnownStatsPrinterContext & Record<string, any>} StatsPrinterContext */
 
-				result.push(item);
-			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item))
-					throw new Error("Unexpected function " + item);
-				/** @type {SerializedType} */
-				const serializedData =
-					SerializerMiddleware.getLazySerializedValue(item);
-				if (serializedData !== undefined) {
-					if (typeof serializedData === "function") {
-						result.push(serializedData);
-					} else {
-						throw new Error("Not implemented");
-					}
-				} else if (SerializerMiddleware.isLazy(item, this)) {
-					throw new Error("Not implemented");
-				} else {
-					const data = SerializerMiddleware.serializeLazy(item, data =>
-						this.serialize([data], context)
-					);
-					SerializerMiddleware.setLazySerializedValue(item, data);
-					result.push(data);
-				}
-			} else if (item === undefined) {
-				result.push(ESCAPE, ESCAPE_UNDEFINED);
-			} else {
-				result.push(item);
-			}
-		};
+class StatsPrinter {
+	constructor() {
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], true>>} */
+			sortElements: new HookMap(
+				() => new SyncBailHook(["elements", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string>>} */
+			printElements: new HookMap(
+				() => new SyncBailHook(["printedElements", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>} */
+			sortItems: new HookMap(() => new SyncBailHook(["items", "context"])),
+			/** @type {HookMap<SyncBailHook<[any, StatsPrinterContext], string>>} */
+			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
+			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>} */
+			printItems: new HookMap(
+				() => new SyncBailHook(["printedItems", "context"])
+			),
+			/** @type {HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>} */
+			print: new HookMap(() => new SyncBailHook(["object", "context"])),
+			/** @type {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} */
+			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
+		});
+		/** @type {Map<HookMap<Hook>, Map<string, Hook[]>>} */
+		this._levelHookCache = new Map();
+		this._inPrint = false;
+	}
 
-		try {
-			for (const item of data) {
-				process(item);
+	/**
+	 * get all level hooks
+	 * @private
+	 * @template {Hook} T
+	 * @param {HookMap<T>} hookMap HookMap
+	 * @param {string} type type
+	 * @returns {T[]} hooks
+	 */
+	_getAllLevelHooks(hookMap, type) {
+		let cache = /** @type {Map<string, T[]>} */ (
+			this._levelHookCache.get(hookMap)
+		);
+		if (cache === undefined) {
+			cache = new Map();
+			this._levelHookCache.set(hookMap, cache);
+		}
+		const cacheEntry = cache.get(type);
+		if (cacheEntry !== undefined) {
+			return cacheEntry;
+		}
+		/** @type {T[]} */
+		const hooks = [];
+		const typeParts = type.split(".");
+		for (let i = 0; i < typeParts.length; i++) {
+			const hook = hookMap.get(typeParts.slice(i).join("."));
+			if (hook) {
+				hooks.push(hook);
 			}
-			return result;
-		} catch (e) {
-			if (e === NOT_SERIALIZABLE) return null;
-
-			throw e;
-		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.write" method so it will reference
-			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
-			data =
-				result =
-				referenceable =
-				bufferDedupeMap =
-				objectTypeLookup =
-				ctx =
-					undefined;
 		}
+		cache.set(type, hooks);
+		return hooks;
 	}
 
 	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * Run `fn` for each level
+	 * @private
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap HookMap
+	 * @param {string} type type
+	 * @param {(hook: SyncBailHook<T, R>) => R} fn function
+	 * @returns {R} result of `fn`
 	 */
-	deserialize(data, context) {
-		let currentDataPos = 0;
-		const read = () => {
-			if (currentDataPos >= data.length)
-				throw new Error("Unexpected end of stream");
+	_forEachLevel(hookMap, type, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, type)) {
+			const result = fn(hook);
+			if (result !== undefined) return result;
+		}
+	}
 
-			return data[currentDataPos++];
-		};
+	/**
+	 * Run `fn` for each level
+	 * @private
+	 * @template T
+	 * @param {HookMap<SyncWaterfallHook<T>>} hookMap HookMap
+	 * @param {string} type type
+	 * @param {AsArray<T>[0]} data data
+	 * @param {(hook: SyncWaterfallHook<T>, data: AsArray<T>[0]) => AsArray<T>[0]} fn function
+	 * @returns {AsArray<T>[0]} result of `fn`
+	 */
+	_forEachLevelWaterfall(hookMap, type, data, fn) {
+		for (const hook of this._getAllLevelHooks(hookMap, type)) {
+			data = fn(hook, data);
+		}
+		return data;
+	}
 
-		if (read() !== CURRENT_VERSION)
-			throw new Error("Version mismatch, serializer changed");
+	/**
+	 * @param {string} type The type
+	 * @param {Object} object Object to print
+	 * @param {Object=} baseContext The base context
+	 * @returns {string} printed result
+	 */
+	print(type, object, baseContext) {
+		if (this._inPrint) {
+			return this._print(type, object, baseContext);
+		} else {
+			try {
+				this._inPrint = true;
+				return this._print(type, object, baseContext);
+			} finally {
+				this._levelHookCache.clear();
+				this._inPrint = false;
+			}
+		}
+	}
 
-		let currentPos = 0;
-		let referenceable = [];
-		const addReferenceable = item => {
-			referenceable.push(item);
-			currentPos++;
-		};
-		let currentPosTypeLookup = 0;
-		let objectTypeLookup = [];
-		let result = [];
-		let ctx = {
-			read() {
-				return decodeValue();
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			...context
+	/**
+	 * @private
+	 * @param {string} type type
+	 * @param {Object} object object
+	 * @param {Object=} baseContext context
+	 * @returns {string} printed result
+	 */
+	_print(type, object, baseContext) {
+		const context = {
+			...baseContext,
+			type,
+			[type]: object
 		};
-		this.extendContext(ctx);
-		const decodeValue = () => {
-			const item = read();
-
-			if (item === ESCAPE) {
-				const nextItem = read();
 
-				if (nextItem === ESCAPE_ESCAPE_VALUE) {
-					return ESCAPE;
-				} else if (nextItem === ESCAPE_UNDEFINED) {
-					return undefined;
-				} else if (nextItem === ESCAPE_END_OBJECT) {
-					throw new Error(
-						`Unexpected end of object at position ${currentDataPos - 1}`
+		let printResult = this._forEachLevel(this.hooks.print, type, hook =>
+			hook.call(object, context)
+		);
+		if (printResult === undefined) {
+			if (Array.isArray(object)) {
+				const sortedItems = object.slice();
+				this._forEachLevel(this.hooks.sortItems, type, h =>
+					h.call(sortedItems, context)
+				);
+				const printedItems = sortedItems.map((item, i) => {
+					const itemContext = {
+						...context,
+						_index: i
+					};
+					const itemName = this._forEachLevel(
+						this.hooks.getItemName,
+						`${type}[]`,
+						h => h.call(item, itemContext)
 					);
-				} else {
-					const request = nextItem;
-					let serializer;
-
-					if (typeof request === "number") {
-						if (request < 0) {
-							// relative reference
-							return referenceable[currentPos + request];
-						}
-						serializer = objectTypeLookup[currentPosTypeLookup - request];
-					} else {
-						if (typeof request !== "string") {
-							throw new Error(
-								`Unexpected type (${typeof request}) of request ` +
-									`at position ${currentDataPos - 1}`
-							);
-						}
-						const name = read();
-
-						serializer = ObjectMiddleware._getDeserializerForWithoutError(
-							request,
-							name
-						);
-
-						if (serializer === undefined) {
-							if (request && !loadedRequests.has(request)) {
-								let loaded = false;
-								for (const [regExp, loader] of loaders) {
-									if (regExp.test(request)) {
-										if (loader(request)) {
-											loaded = true;
-											break;
-										}
-									}
-								}
-								if (!loaded) {
-									require(request);
-								}
-
-								loadedRequests.add(request);
-							}
-
-							serializer = ObjectMiddleware.getDeserializerFor(request, name);
-						}
+					if (itemName) itemContext[itemName] = item;
+					return this.print(
+						itemName ? `${type}[].${itemName}` : `${type}[]`,
+						item,
+						itemContext
+					);
+				});
+				printResult = this._forEachLevel(this.hooks.printItems, type, h =>
+					h.call(printedItems, context)
+				);
+				if (printResult === undefined) {
+					const result = printedItems.filter(Boolean);
+					if (result.length > 0) printResult = result.join("\n");
+				}
+			} else if (object !== null && typeof object === "object") {
+				const elements = Object.keys(object).filter(
+					key => object[key] !== undefined
+				);
+				this._forEachLevel(this.hooks.sortElements, type, h =>
+					h.call(elements, context)
+				);
+				const printedElements = elements.map(element => {
+					const content = this.print(`${type}.${element}`, object[element], {
+						...context,
+						_parent: object,
+						_element: element,
+						[element]: object[element]
+					});
+					return { element, content };
+				});
+				printResult = this._forEachLevel(this.hooks.printElements, type, h =>
+					h.call(printedElements, context)
+				);
+				if (printResult === undefined) {
+					const result = printedElements.map(e => e.content).filter(Boolean);
+					if (result.length > 0) printResult = result.join("\n");
+				}
+			}
+		}
 
-						objectTypeLookup.push(serializer);
-						currentPosTypeLookup++;
-					}
-					try {
-						const item = serializer.deserialize(ctx);
-						const end1 = read();
+		return this._forEachLevelWaterfall(
+			this.hooks.result,
+			type,
+			printResult,
+			(h, r) => h.call(r, context)
+		);
+	}
+}
+module.exports = StatsPrinter;
 
-						if (end1 !== ESCAPE) {
-							throw new Error("Expected end of object");
-						}
 
-						const end2 = read();
+/***/ }),
 
-						if (end2 !== ESCAPE_END_OBJECT) {
-							throw new Error("Expected end of object");
-						}
+/***/ 84953:
+/***/ (function(__unused_webpack_module, exports) {
 
-						addReferenceable(item);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						return item;
-					} catch (err) {
-						// As this is only for error handling, we omit creating a Map for
-						// faster access to this information, as this would affect performance
-						// in the good case
-						let serializerEntry;
-						for (const entry of serializers) {
-							if (entry[1].serializer === serializer) {
-								serializerEntry = entry;
-								break;
-							}
-						}
-						const name = !serializerEntry
-							? "unknown"
-							: !serializerEntry[1].request
-							? serializerEntry[0].name
-							: serializerEntry[1].name
-							? `${serializerEntry[1].request} ${serializerEntry[1].name}`
-							: serializerEntry[1].request;
-						err.message += `\n(during deserialization of ${name})`;
-						throw err;
-					}
-				}
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					addReferenceable(item);
-				}
 
-				return item;
-			} else if (Buffer.isBuffer(item)) {
-				addReferenceable(item);
 
-				return item;
-			} else if (typeof item === "function") {
-				return SerializerMiddleware.deserializeLazy(
-					item,
-					data => this.deserialize(data, context)[0]
-				);
-			} else {
-				return item;
-			}
-		};
+/**
+ * Compare two arrays or strings by performing strict equality check for each value.
+ * @template T [T=any]
+ * @param {ArrayLike<T>} a Array of values to be compared
+ * @param {ArrayLike<T>} b Array of values to be compared
+ * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
+ */
 
-		try {
-			while (currentDataPos < data.length) {
-				result.push(decodeValue());
-			}
-			return result;
-		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.read" method so it will reference
-			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
-			result = referenceable = data = objectTypeLookup = ctx = undefined;
-		}
+exports.equals = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] !== b[i]) return false;
 	}
-}
+	return true;
+};
 
-module.exports = ObjectMiddleware;
-module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
+/**
+ * Partition an array by calling a predicate function on each value.
+ * @template T [T=any]
+ * @param {Array<T>} arr Array of values to be partitioned
+ * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
+ * @returns {[Array<T>, Array<T>]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
+ */
+exports.groupBy = (arr = [], fn) => {
+	return arr.reduce(
+		/**
+		 * @param {[Array<T>, Array<T>]} groups An accumulator storing already partitioned values returned from previous call.
+		 * @param {T} value The value of the current element
+		 * @returns {[Array<T>, Array<T>]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
+		 */
+		(groups, value) => {
+			groups[fn(value) ? 0 : 1].push(value);
+			return groups;
+		},
+		[[], []]
+	);
+};
 
 
 /***/ }),
 
-/***/ 33040:
+/***/ 41792:
 /***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const cache = new WeakMap();
-
-class ObjectStructure {
-	constructor() {
-		this.keys = undefined;
-		this.children = undefined;
+/**
+ * @template T
+ */
+class ArrayQueue {
+	/**
+	 * @param {Iterable<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/** @private @type {T[]} */
+		this._list = items ? Array.from(items) : [];
+		/** @private @type {T[]} */
+		this._listReversed = [];
 	}
 
-	getKeys(keys) {
-		if (this.keys === undefined) this.keys = keys;
-		return this.keys;
+	/**
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this._list.length + this._listReversed.length;
 	}
 
-	key(key) {
-		if (this.children === undefined) this.children = new Map();
-		const child = this.children.get(key);
-		if (child !== undefined) return child;
-		const newChild = new ObjectStructure();
-		this.children.set(key, newChild);
-		return newChild;
+	/**
+	 * Empties the queue.
+	 */
+	clear() {
+		this._list.length = 0;
+		this._listReversed.length = 0;
 	}
-}
 
-const getCachedKeys = (keys, cacheAssoc) => {
-	let root = cache.get(cacheAssoc);
-	if (root === undefined) {
-		root = new ObjectStructure();
-		cache.set(cacheAssoc, root);
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
+	 */
+	enqueue(item) {
+		this._list.push(item);
 	}
-	let current = root;
-	for (const key of keys) {
-		current = current.key(key);
+
+	/**
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 */
+	dequeue() {
+		if (this._listReversed.length === 0) {
+			if (this._list.length === 0) return undefined;
+			if (this._list.length === 1) return this._list.pop();
+			if (this._list.length < 16) return this._list.shift();
+			const temp = this._listReversed;
+			this._listReversed = this._list;
+			this._listReversed.reverse();
+			this._list = temp;
+		}
+		return this._listReversed.pop();
 	}
-	return current.getKeys(keys);
-};
 
-class PlainObjectSerializer {
-	serialize(obj, { write }) {
-		const keys = Object.keys(obj);
-		if (keys.length > 128) {
-			// Objects with so many keys are unlikely to share structure
-			// with other objects
-			write(keys);
-			for (const key of keys) {
-				write(obj[key]);
-			}
-		} else if (keys.length > 1) {
-			write(getCachedKeys(keys, write));
-			for (const key of keys) {
-				write(obj[key]);
-			}
-		} else if (keys.length === 1) {
-			const key = keys[0];
-			write(key);
-			write(obj[key]);
+	/**
+	 * Finds and removes an item
+	 * @param {T} item the item
+	 * @returns {void}
+	 */
+	delete(item) {
+		const i = this._list.indexOf(item);
+		if (i >= 0) {
+			this._list.splice(i, 1);
 		} else {
-			write(null);
+			const i = this._listReversed.indexOf(item);
+			if (i >= 0) this._listReversed.splice(i, 1);
 		}
 	}
-	deserialize({ read }) {
-		const keys = read();
-		const obj = {};
-		if (Array.isArray(keys)) {
-			for (const key of keys) {
-				obj[key] = read();
+
+	[Symbol.iterator]() {
+		let i = -1;
+		let reversed = false;
+		return {
+			next: () => {
+				if (!reversed) {
+					i++;
+					if (i < this._list.length) {
+						return {
+							done: false,
+							value: this._list[i]
+						};
+					}
+					reversed = true;
+					i = this._listReversed.length;
+				}
+				i--;
+				if (i < 0) {
+					return {
+						done: true,
+						value: undefined
+					};
+				}
+				return {
+					done: false,
+					value: this._listReversed[i]
+				};
 			}
-		} else if (keys !== null) {
-			obj[keys] = read();
-		}
-		return obj;
+		};
 	}
 }
 
-module.exports = PlainObjectSerializer;
+module.exports = ArrayQueue;
 
 
 /***/ }),
 
-/***/ 57328:
-/***/ (function(module) {
+/***/ 12260:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-class RegExpObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.source);
-		write(obj.flags);
-	}
-	deserialize({ read }) {
-		return new RegExp(read(), read());
-	}
-}
-
-module.exports = RegExpObjectSerializer;
+const { SyncHook, AsyncSeriesHook } = __webpack_require__(6967);
+const { makeWebpackError } = __webpack_require__(11351);
+const WebpackError = __webpack_require__(53799);
+const ArrayQueue = __webpack_require__(41792);
 
+const QUEUED_STATE = 0;
+const PROCESSING_STATE = 1;
+const DONE_STATE = 2;
 
-/***/ }),
+let inHandleResult = 0;
 
-/***/ 53080:
-/***/ (function(module) {
+/**
+ * @template T
+ * @callback Callback
+ * @param {(WebpackError | null)=} err
+ * @param {T=} result
+ */
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
+/**
+ * @template T
+ * @template K
+ * @template R
+ */
+class AsyncQueueEntry {
+	/**
+	 * @param {T} item the item
+	 * @param {Callback<R>} callback the callback
+	 */
+	constructor(item, callback) {
+		this.item = item;
+		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
+		this.state = QUEUED_STATE;
+		this.callback = callback;
+		/** @type {Callback<R>[] | undefined} */
+		this.callbacks = undefined;
+		this.result = undefined;
+		/** @type {WebpackError | undefined} */
+		this.error = undefined;
+	}
+}
 
+/**
+ * @template T
+ * @template K
+ * @template R
+ */
+class AsyncQueue {
+	/**
+	 * @param {Object} options options object
+	 * @param {string=} options.name name of the queue
+	 * @param {number=} options.parallelism how many items should be processed at once
+	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
+	 * @param {function(T): K=} options.getKey extract key from item
+	 * @param {function(T, Callback<R>): void} options.processor async function to process items
+	 */
+	constructor({ name, parallelism, parent, processor, getKey }) {
+		this._name = name;
+		this._parallelism = parallelism || 1;
+		this._processor = processor;
+		this._getKey =
+			getKey || /** @type {(T) => K} */ (item => /** @type {any} */ (item));
+		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
+		this._entries = new Map();
+		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
+		this._queued = new ArrayQueue();
+		/** @type {AsyncQueue<any, any, any>[]} */
+		this._children = undefined;
+		this._activeTasks = 0;
+		this._willEnsureProcessing = false;
+		this._needProcessing = false;
+		this._stopped = false;
+		this._root = parent ? parent._root : this;
+		if (parent) {
+			if (this._root._children === undefined) {
+				this._root._children = [this];
+			} else {
+				this._root._children.push(this);
+			}
+		}
 
+		this.hooks = {
+			/** @type {AsyncSeriesHook<[T]>} */
+			beforeAdd: new AsyncSeriesHook(["item"]),
+			/** @type {SyncHook<[T]>} */
+			added: new SyncHook(["item"]),
+			/** @type {AsyncSeriesHook<[T]>} */
+			beforeStart: new AsyncSeriesHook(["item"]),
+			/** @type {SyncHook<[T]>} */
+			started: new SyncHook(["item"]),
+			/** @type {SyncHook<[T, Error, R]>} */
+			result: new SyncHook(["item", "error", "result"])
+		};
 
-class Serializer {
-	constructor(middlewares, context) {
-		this.serializeMiddlewares = middlewares.slice();
-		this.deserializeMiddlewares = middlewares.slice().reverse();
-		this.context = context;
+		this._ensureProcessing = this._ensureProcessing.bind(this);
 	}
 
-	serialize(obj, context) {
-		const ctx = { ...context, ...this.context };
-		let current = obj;
-		for (const middleware of this.serializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => data && middleware.serialize(data, ctx));
-			} else if (current) {
-				try {
-					current = middleware.serialize(current, ctx);
-				} catch (err) {
-					current = Promise.reject(err);
+	/**
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
+	 * @returns {void}
+	 */
+	add(item, callback) {
+		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
+		this.hooks.beforeAdd.callAsync(item, err => {
+			if (err) {
+				callback(
+					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeAdd`)
+				);
+				return;
+			}
+			const key = this._getKey(item);
+			const entry = this._entries.get(key);
+			if (entry !== undefined) {
+				if (entry.state === DONE_STATE) {
+					if (inHandleResult++ > 3) {
+						process.nextTick(() => callback(entry.error, entry.result));
+					} else {
+						callback(entry.error, entry.result);
+					}
+					inHandleResult--;
+				} else if (entry.callbacks === undefined) {
+					entry.callbacks = [callback];
+				} else {
+					entry.callbacks.push(callback);
 				}
-			} else break;
-		}
-		return current;
-	}
-
-	deserialize(value, context) {
-		const ctx = { ...context, ...this.context };
-		/** @type {any} */
-		let current = value;
-		for (const middleware of this.deserializeMiddlewares) {
-			if (current && typeof current.then === "function") {
-				current = current.then(data => middleware.deserialize(data, ctx));
+				return;
+			}
+			const newEntry = new AsyncQueueEntry(item, callback);
+			if (this._stopped) {
+				this.hooks.added.call(item);
+				this._root._activeTasks++;
+				process.nextTick(() =>
+					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
+				);
 			} else {
-				current = middleware.deserialize(current, ctx);
+				this._entries.set(key, newEntry);
+				this._queued.enqueue(newEntry);
+				const root = this._root;
+				root._needProcessing = true;
+				if (root._willEnsureProcessing === false) {
+					root._willEnsureProcessing = true;
+					setImmediate(root._ensureProcessing);
+				}
+				this.hooks.added.call(item);
 			}
-		}
-		return current;
+		});
 	}
-}
-
-module.exports = Serializer;
-
-
-/***/ }),
-
-/***/ 83137:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
 
+	/**
+	 * @param {T} item an item
+	 * @returns {void}
+	 */
+	invalidate(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		this._entries.delete(key);
+		if (entry.state === QUEUED_STATE) {
+			this._queued.delete(entry);
+		}
+	}
 
-const memoize = __webpack_require__(78676);
-
-const LAZY_TARGET = Symbol("lazy serialization target");
-const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
+	/**
+	 * Waits for an already started item
+	 * @param {T} item an item
+	 * @param {Callback<R>} callback callback function
+	 * @returns {void}
+	 */
+	waitFor(item, callback) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		if (entry === undefined) {
+			return callback(
+				new WebpackError(
+					"waitFor can only be called for an already started item"
+				)
+			);
+		}
+		if (entry.state === DONE_STATE) {
+			process.nextTick(() => callback(entry.error, entry.result));
+		} else if (entry.callbacks === undefined) {
+			entry.callbacks = [callback];
+		} else {
+			entry.callbacks.push(callback);
+		}
+	}
 
-/**
- * @template DeserializedType
- * @template SerializedType
- */
-class SerializerMiddleware {
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @returns {void}
 	 */
-	serialize(data, context) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	stop() {
+		this._stopped = true;
+		const queue = this._queued;
+		this._queued = new ArrayQueue();
+		const root = this._root;
+		for (const entry of queue) {
+			this._entries.delete(this._getKey(entry.item));
+			root._activeTasks++;
+			this._handleResult(entry, new WebpackError("Queue was stopped"));
+		}
 	}
 
-	/* istanbul ignore next */
 	/**
-	 * @abstract
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @returns {void}
 	 */
-	deserialize(data, context) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+	increaseParallelism() {
+		const root = this._root;
+		root._parallelism++;
+		/* istanbul ignore next */
+		if (root._willEnsureProcessing === false && root._needProcessing) {
+			root._willEnsureProcessing = true;
+			setImmediate(root._ensureProcessing);
+		}
 	}
 
 	/**
-	 * @param {any | function(): Promise<any> | any} value contained value or function to value
-	 * @param {SerializerMiddleware<any, any>} target target middleware
-	 * @param {object=} options lazy options
-	 * @param {any=} serializedValue serialized value
-	 * @returns {function(): Promise<any> | any} lazy function
+	 * @returns {void}
 	 */
-	static createLazy(value, target, options = {}, serializedValue) {
-		if (SerializerMiddleware.isLazy(value, target)) return value;
-		const fn = typeof value === "function" ? value : () => value;
-		fn[LAZY_TARGET] = target;
-		/** @type {any} */ (fn).options = options;
-		fn[LAZY_SERIALIZED_VALUE] = serializedValue;
-		return fn;
+	decreaseParallelism() {
+		const root = this._root;
+		root._parallelism--;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {SerializerMiddleware<any, any>=} target target middleware
-	 * @returns {boolean} true, when fn is a lazy function (optionally of that target)
+	 * @param {T} item an item
+	 * @returns {boolean} true, if the item is currently being processed
 	 */
-	static isLazy(fn, target) {
-		if (typeof fn !== "function") return false;
-		const t = fn[LAZY_TARGET];
-		return target ? t === target : !!t;
+	isProcessing(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		return entry !== undefined && entry.state === PROCESSING_STATE;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {object} options
+	 * @param {T} item an item
+	 * @returns {boolean} true, if the item is currently queued
 	 */
-	static getLazyOptions(fn) {
-		if (typeof fn !== "function") return undefined;
-		return /** @type {any} */ (fn).options;
+	isQueued(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		return entry !== undefined && entry.state === QUEUED_STATE;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @returns {any} serialized value
+	 * @param {T} item an item
+	 * @returns {boolean} true, if the item is currently queued
 	 */
-	static getLazySerializedValue(fn) {
-		if (typeof fn !== "function") return undefined;
-		return fn[LAZY_SERIALIZED_VALUE];
+	isDone(item) {
+		const key = this._getKey(item);
+		const entry = this._entries.get(key);
+		return entry !== undefined && entry.state === DONE_STATE;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} fn lazy function
-	 * @param {any} value serialized value
 	 * @returns {void}
 	 */
-	static setLazySerializedValue(fn, value) {
-		fn[LAZY_SERIALIZED_VALUE] = value;
+	_ensureProcessing() {
+		while (this._activeTasks < this._parallelism) {
+			const entry = this._queued.dequeue();
+			if (entry === undefined) break;
+			this._activeTasks++;
+			entry.state = PROCESSING_STATE;
+			this._startProcessing(entry);
+		}
+		this._willEnsureProcessing = false;
+		if (this._queued.length > 0) return;
+		if (this._children !== undefined) {
+			for (const child of this._children) {
+				while (this._activeTasks < this._parallelism) {
+					const entry = child._queued.dequeue();
+					if (entry === undefined) break;
+					this._activeTasks++;
+					entry.state = PROCESSING_STATE;
+					child._startProcessing(entry);
+				}
+				if (child._queued.length > 0) return;
+			}
+		}
+		if (!this._willEnsureProcessing) this._needProcessing = false;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} serialize serialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @returns {void}
 	 */
-	static serializeLazy(lazy, serialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => data && serialize(data));
+	_startProcessing(entry) {
+		this.hooks.beforeStart.callAsync(entry.item, err => {
+			if (err) {
+				this._handleResult(
+					entry,
+					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeStart`)
+				);
+				return;
 			}
-			return serialize(r);
+			let inCallback = false;
+			try {
+				this._processor(entry.item, (e, r) => {
+					inCallback = true;
+					this._handleResult(entry, e, r);
+				});
+			} catch (err) {
+				if (inCallback) throw err;
+				this._handleResult(entry, err, null);
+			}
+			this.hooks.started.call(entry.item);
 		});
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
-		lazy[LAZY_SERIALIZED_VALUE] = fn;
-		return fn;
 	}
 
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @param {function(any): Promise<any> | any} deserialize deserialize function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
+	 * @param {WebpackError=} err error, if any
+	 * @param {R=} result result, if any
+	 * @returns {void}
 	 */
-	static deserializeLazy(lazy, deserialize) {
-		const fn = memoize(() => {
-			const r = lazy();
-			if (r && typeof r.then === "function") {
-				return r.then(data => deserialize(data));
+	_handleResult(entry, err, result) {
+		this.hooks.result.callAsync(entry.item, err, result, hookError => {
+			const error = hookError
+				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
+				: err;
+
+			const callback = entry.callback;
+			const callbacks = entry.callbacks;
+			entry.state = DONE_STATE;
+			entry.callback = undefined;
+			entry.callbacks = undefined;
+			entry.result = result;
+			entry.error = error;
+
+			const root = this._root;
+			root._activeTasks--;
+			if (root._willEnsureProcessing === false && root._needProcessing) {
+				root._willEnsureProcessing = true;
+				setImmediate(root._ensureProcessing);
 			}
-			return deserialize(r);
+
+			if (inHandleResult++ > 3) {
+				process.nextTick(() => {
+					callback(error, result);
+					if (callbacks !== undefined) {
+						for (const callback of callbacks) {
+							callback(error, result);
+						}
+					}
+				});
+			} else {
+				callback(error, result);
+				if (callbacks !== undefined) {
+					for (const callback of callbacks) {
+						callback(error, result);
+					}
+				}
+			}
+			inHandleResult--;
 		});
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		/** @type {any} */ (fn).options = /** @type {any} */ (lazy).options;
-		fn[LAZY_SERIALIZED_VALUE] = lazy;
-		return fn;
 	}
 
+	clear() {
+		this._entries.clear();
+		this._queued.clear();
+		this._activeTasks = 0;
+		this._willEnsureProcessing = false;
+		this._needProcessing = false;
+		this._stopped = false;
+	}
+}
+
+module.exports = AsyncQueue;
+
+
+/***/ }),
+
+/***/ 36692:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+class Hash {
+	/* istanbul ignore next */
 	/**
-	 * @param {function(): Promise<any> | any} lazy lazy function
-	 * @returns {function(): Promise<any> | any} new lazy
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @abstract
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
 	 */
-	static unMemoizeLazy(lazy) {
-		if (!SerializerMiddleware.isLazy(lazy)) return lazy;
-		const fn = () => {
-			throw new Error(
-				"A lazy value that has been unmemorized can't be called again"
-			);
-		};
-		fn[LAZY_SERIALIZED_VALUE] = SerializerMiddleware.unMemoizeLazy(
-			lazy[LAZY_SERIALIZED_VALUE]
-		);
-		fn[LAZY_TARGET] = lazy[LAZY_TARGET];
-		fn.options = /** @type {any} */ (lazy).options;
-		return fn;
+	update(data, inputEncoding) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
+	}
+
+	/* istanbul ignore next */
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @abstract
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		const AbstractMethodError = __webpack_require__(77198);
+		throw new AbstractMethodError();
 	}
 }
 
-module.exports = SerializerMiddleware;
+module.exports = Hash;
 
 
 /***/ }),
 
-/***/ 79240:
-/***/ (function(module) {
+/***/ 39104:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-class SetObjectSerializer {
-	serialize(obj, { write }) {
-		write(obj.size);
-		for (const value of obj) {
-			write(value);
-		}
-	}
-	deserialize({ read }) {
-		let size = read();
-		const set = new Set();
-		for (let i = 0; i < size; i++) {
-			set.add(read());
-		}
-		return set;
+/**
+ * @template T
+ * @param {Iterable<T>} set a set
+ * @returns {T | undefined} last item
+ */
+const last = set => {
+	let last;
+	for (const item of set) last = item;
+	return last;
+};
+
+/**
+ * @template T
+ * @param {Iterable<T>} iterable iterable
+ * @param {function(T): boolean} filter predicate
+ * @returns {boolean} true, if some items match the filter predicate
+ */
+const someInIterable = (iterable, filter) => {
+	for (const item of iterable) {
+		if (filter(item)) return true;
 	}
-}
+	return false;
+};
 
-module.exports = SetObjectSerializer;
+/**
+ * @template T
+ * @param {Iterable<T>} iterable an iterable
+ * @returns {number} count of items
+ */
+const countIterable = iterable => {
+	let i = 0;
+	// eslint-disable-next-line no-unused-vars
+	for (const _ of iterable) i++;
+	return i;
+};
+
+exports.last = last;
+exports.someInIterable = someInIterable;
+exports.countIterable = countIterable;
 
 
 /***/ }),
 
-/***/ 65112:
+/***/ 48424:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const SerializerMiddleware = __webpack_require__(83137);
+const { first } = __webpack_require__(93347);
+const SortableSet = __webpack_require__(13098);
 
 /**
- * @typedef {any} DeserializedType
- * @typedef {any[]} SerializedType
- * @extends {SerializerMiddleware<any, any[]>}
+ * Multi layer bucket sorted set:
+ * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
+ * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET),
+ * Supports popping the first items according to defined order,
+ * Supports iterating all items without order,
+ * Supports updating an item in an efficient way,
+ * Supports size property, which is the number of items,
+ * Items are lazy partially sorted when needed
+ * @template T
+ * @template K
  */
-class SingleItemMiddleware extends SerializerMiddleware {
+class LazyBucketSortedSet {
 	/**
-	 * @param {DeserializedType} data data
-	 * @param {Object} context context object
-	 * @returns {SerializedType|Promise<SerializedType>} serialized data
+	 * @param {function(T): K} getKey function to get key from item
+	 * @param {function(K, K): number} comparator comparator to sort keys
+	 * @param  {...((function(T): any) | (function(any, any): number))} args more pairs of getKey and comparator plus optional final comparator for the last layer
 	 */
-	serialize(data, context) {
-		return [data];
+	constructor(getKey, comparator, ...args) {
+		this._getKey = getKey;
+		this._innerArgs = args;
+		this._leaf = args.length <= 1;
+		this._keys = new SortableSet(undefined, comparator);
+		/** @type {Map<K, LazyBucketSortedSet<T, any> | SortableSet<T>>} */
+		this._map = new Map();
+		this._unsortedItems = new Set();
+		this.size = 0;
 	}
 
 	/**
-	 * @param {SerializedType} data data
-	 * @param {Object} context context object
-	 * @returns {DeserializedType|Promise<DeserializedType>} deserialized data
+	 * @param {T} item an item
+	 * @returns {void}
 	 */
-	deserialize(data, context) {
-		return data[0];
+	add(item) {
+		this.size++;
+		this._unsortedItems.add(item);
 	}
-}
-
-module.exports = SingleItemMiddleware;
-
-
-/***/ }),
-
-/***/ 58831:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	/**
+	 * @param {K} key key of item
+	 * @param {T} item the item
+	 * @returns {void}
+	 */
+	_addInternal(key, item) {
+		let entry = this._map.get(key);
+		if (entry === undefined) {
+			entry = this._leaf
+				? new SortableSet(undefined, this._innerArgs[0])
+				: new /** @type {any} */ (LazyBucketSortedSet)(...this._innerArgs);
+			this._keys.add(key);
+			this._map.set(key, entry);
+		}
+		entry.add(item);
+	}
 
+	/**
+	 * @param {T} item an item
+	 * @returns {void}
+	 */
+	delete(item) {
+		this.size--;
+		if (this._unsortedItems.has(item)) {
+			this._unsortedItems.delete(item);
+			return;
+		}
+		const key = this._getKey(item);
+		const entry = this._map.get(key);
+		entry.delete(item);
+		if (entry.size === 0) {
+			this._deleteKey(key);
+		}
+	}
 
+	/**
+	 * @param {K} key key to be removed
+	 * @returns {void}
+	 */
+	_deleteKey(key) {
+		this._keys.delete(key);
+		this._map.delete(key);
+	}
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
+	/**
+	 * @returns {T | undefined} an item
+	 */
+	popFirst() {
+		if (this.size === 0) return undefined;
+		this.size--;
+		if (this._unsortedItems.size > 0) {
+			for (const item of this._unsortedItems) {
+				const key = this._getKey(item);
+				this._addInternal(key, item);
+			}
+			this._unsortedItems.clear();
+		}
+		this._keys.sort();
+		const key = first(this._keys);
+		const entry = this._map.get(key);
+		if (this._leaf) {
+			const leafEntry = /** @type {SortableSet<T>} */ (entry);
+			leafEntry.sort();
+			const item = first(leafEntry);
+			leafEntry.delete(item);
+			if (leafEntry.size === 0) {
+				this._deleteKey(key);
+			}
+			return item;
+		} else {
+			const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+			const item = nodeEntry.popFirst();
+			if (nodeEntry.size === 0) {
+				this._deleteKey(key);
+			}
+			return item;
+		}
+	}
 
-class ConsumeSharedFallbackDependency extends ModuleDependency {
-	constructor(request) {
-		super(request);
+	/**
+	 * @param {T} item to be updated item
+	 * @returns {function(true=): void} finish update
+	 */
+	startUpdate(item) {
+		if (this._unsortedItems.has(item)) {
+			return remove => {
+				if (remove) {
+					this._unsortedItems.delete(item);
+					this.size--;
+					return;
+				}
+			};
+		}
+		const key = this._getKey(item);
+		if (this._leaf) {
+			const oldEntry = /** @type {SortableSet<T>} */ (this._map.get(key));
+			return remove => {
+				if (remove) {
+					this.size--;
+					oldEntry.delete(item);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					return;
+				}
+				const newKey = this._getKey(item);
+				if (key === newKey) {
+					// This flags the sortable set as unordered
+					oldEntry.add(item);
+				} else {
+					oldEntry.delete(item);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					this._addInternal(newKey, item);
+				}
+			};
+		} else {
+			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
+				this._map.get(key)
+			);
+			const finishUpdate = oldEntry.startUpdate(item);
+			return remove => {
+				if (remove) {
+					this.size--;
+					finishUpdate(true);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					return;
+				}
+				const newKey = this._getKey(item);
+				if (key === newKey) {
+					finishUpdate();
+				} else {
+					finishUpdate(true);
+					if (oldEntry.size === 0) {
+						this._deleteKey(key);
+					}
+					this._addInternal(newKey, item);
+				}
+			};
+		}
 	}
 
-	get type() {
-		return "consume shared fallback";
+	/**
+	 * @param {Iterator<T>[]} iterators list of iterators to append to
+	 * @returns {void}
+	 */
+	_appendIterators(iterators) {
+		if (this._unsortedItems.size > 0)
+			iterators.push(this._unsortedItems[Symbol.iterator]());
+		for (const key of this._keys) {
+			const entry = this._map.get(key);
+			if (this._leaf) {
+				const leafEntry = /** @type {SortableSet<T>} */ (entry);
+				const iterator = leafEntry[Symbol.iterator]();
+				iterators.push(iterator);
+			} else {
+				const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
+				nodeEntry._appendIterators(iterators);
+			}
+		}
 	}
 
-	get category() {
-		return "esm";
+	/**
+	 * @returns {Iterator<T>} the iterator
+	 */
+	[Symbol.iterator]() {
+		const iterators = [];
+		this._appendIterators(iterators);
+		iterators.reverse();
+		let currentIterator = iterators.pop();
+		return {
+			next: () => {
+				const res = currentIterator.next();
+				if (res.done) {
+					if (iterators.length === 0) return res;
+					currentIterator = iterators.pop();
+					return currentIterator.next();
+				}
+				return res;
+			}
+		};
 	}
 }
 
-makeSerializable(
-	ConsumeSharedFallbackDependency,
-	"webpack/lib/sharing/ConsumeSharedFallbackDependency"
-);
-
-module.exports = ConsumeSharedFallbackDependency;
+module.exports = LazyBucketSortedSet;
 
 
 /***/ }),
 
-/***/ 62286:
+/***/ 38938:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -121656,256 +122034,213 @@ module.exports = ConsumeSharedFallbackDependency;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
 const makeSerializable = __webpack_require__(33032);
-const { rangeToString, stringifyHoley } = __webpack_require__(19702);
-const ConsumeSharedFallbackDependency = __webpack_require__(58831);
-
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
 
 /**
- * @typedef {Object} ConsumeOptions
- * @property {string=} import fallback request
- * @property {string=} importResolved resolved fallback request
- * @property {string} shareKey global share key
- * @property {string} shareScope share scope
- * @property {SemVerRange | false | undefined} requiredVersion version requirement
- * @property {string} packageName package name to determine required version automatically
- * @property {boolean} strictVersion don't use shared version even if version isn't valid
- * @property {boolean} singleton use single global version
- * @property {boolean} eager include the fallback module in a sync way
+ * @template T
+ * @param {Set<T>} targetSet set where items should be added
+ * @param {Set<Iterable<T>>} toMerge iterables to be merged
+ * @returns {void}
  */
+const merge = (targetSet, toMerge) => {
+	for (const set of toMerge) {
+		for (const item of set) {
+			targetSet.add(item);
+		}
+	}
+};
 
-const TYPES = new Set(["consume-shared"]);
+/**
+ * @template T
+ * @param {Set<Iterable<T>>} targetSet set where iterables should be added
+ * @param {Array<LazySet<T>>} toDeepMerge lazy sets to be flattened
+ * @returns {void}
+ */
+const flatten = (targetSet, toDeepMerge) => {
+	for (const set of toDeepMerge) {
+		if (set._set.size > 0) targetSet.add(set._set);
+		if (set._needMerge) {
+			for (const mergedSet of set._toMerge) {
+				targetSet.add(mergedSet);
+			}
+			flatten(targetSet, set._toDeepMerge);
+		}
+	}
+};
 
-class ConsumeSharedModule extends Module {
+/**
+ * Like Set but with an addAll method to eventually add items from another iterable.
+ * Access methods make sure that all delayed operations are executed.
+ * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
+ * @template T
+ */
+class LazySet {
 	/**
-	 * @param {string} context context
-	 * @param {ConsumeOptions} options consume options
+	 * @param {Iterable<T>=} iterable init iterable
 	 */
-	constructor(context, options) {
-		super("consume-shared-module", context);
-		this.options = options;
+	constructor(iterable) {
+		/** @type {Set<T>} */
+		this._set = new Set(iterable);
+		/** @type {Set<Iterable<T>>} */
+		this._toMerge = new Set();
+		/** @type {Array<LazySet<T>>} */
+		this._toDeepMerge = [];
+		this._needMerge = false;
+		this._deopt = false;
 	}
 
-	/**
-	 * @returns {string} a unique identifier of the module
-	 */
-	identifier() {
-		const {
-			shareKey,
-			shareScope,
-			importResolved,
-			requiredVersion,
-			strictVersion,
-			singleton,
-			eager
-		} = this.options;
-		return `consume-shared-module|${shareScope}|${shareKey}|${
-			requiredVersion && rangeToString(requiredVersion)
-		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
+	_flatten() {
+		flatten(this._toMerge, this._toDeepMerge);
+		this._toDeepMerge.length = 0;
+	}
+
+	_merge() {
+		this._flatten();
+		merge(this._set, this._toMerge);
+		this._toMerge.clear();
+		this._needMerge = false;
+	}
+
+	_isEmpty() {
+		return (
+			this._set.size === 0 &&
+			this._toMerge.size === 0 &&
+			this._toDeepMerge.length === 0
+		);
+	}
+
+	get size() {
+		if (this._needMerge) this._merge();
+		return this._set.size;
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {T} item an item
+	 * @returns {this} itself
 	 */
-	readableIdentifier(requestShortener) {
-		const {
-			shareKey,
-			shareScope,
-			importResolved,
-			requiredVersion,
-			strictVersion,
-			singleton,
-			eager
-		} = this.options;
-		return `consume shared module (${shareScope}) ${shareKey}@${
-			requiredVersion ? rangeToString(requiredVersion) : "*"
-		}${strictVersion ? " (strict)" : ""}${singleton ? " (singleton)" : ""}${
-			importResolved
-				? ` (fallback: ${requestShortener.shorten(importResolved)})`
-				: ""
-		}${eager ? " (eager)" : ""}`;
+	add(item) {
+		this._set.add(item);
+		return this;
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
+	 * @returns {this} itself
 	 */
-	libIdent(options) {
-		const { shareKey, shareScope, import: request } = this.options;
-		return `${
-			this.layer ? `(${this.layer})/` : ""
-		}webpack/sharing/consume/${shareScope}/${shareKey}${
-			request ? `/${request}` : ""
-		}`;
+	addAll(iterable) {
+		if (this._deopt) {
+			const _set = this._set;
+			for (const item of iterable) {
+				_set.add(item);
+			}
+		} else {
+			if (iterable instanceof LazySet) {
+				if (iterable._isEmpty()) return this;
+				this._toDeepMerge.push(iterable);
+				this._needMerge = true;
+				if (this._toDeepMerge.length > 100000) {
+					this._flatten();
+				}
+			} else {
+				this._toMerge.add(iterable);
+				this._needMerge = true;
+			}
+			if (this._toMerge.size > 100000) this._merge();
+		}
+		return this;
+	}
+
+	clear() {
+		this._set.clear();
+		this._toMerge.clear();
+		this._toDeepMerge.length = 0;
+		this._needMerge = false;
+		this._deopt = false;
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {T} value an item
+	 * @returns {boolean} true, if the value was in the Set before
 	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
+	delete(value) {
+		if (this._needMerge) this._merge();
+		return this._set.delete(value);
+	}
+
+	entries() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set.entries();
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
+	 * @param {function(T, T, Set<T>): void} callbackFn function called for each entry
+	 * @param {any} thisArg this argument for the callbackFn
 	 * @returns {void}
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {};
-		if (this.options.import) {
-			const dep = new ConsumeSharedFallbackDependency(this.options.import);
-			if (this.options.eager) {
-				this.addDependency(dep);
-			} else {
-				const block = new AsyncDependenciesBlock({});
-				block.addDependency(dep);
-				this.addBlock(block);
-			}
-		}
-		callback();
+	forEach(callbackFn, thisArg) {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		this._set.forEach(callbackFn, thisArg);
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @param {T} item an item
+	 * @returns {boolean} true, when the item is in the Set
 	 */
-	getSourceTypes() {
-		return TYPES;
+	has(item) {
+		if (this._needMerge) this._merge();
+		return this._set.has(item);
 	}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 42;
+	keys() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set.keys();
 	}
 
-	/**
-	 * @param {Hash} hash the hash used to track dependencies
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(JSON.stringify(this.options));
-		super.updateHash(hash, context);
+	values() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set.values();
 	}
 
-	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
-	 */
-	codeGeneration({ chunkGraph, moduleGraph, runtimeTemplate }) {
-		const runtimeRequirements = new Set([RuntimeGlobals.shareScopeMap]);
-		const {
-			shareScope,
-			shareKey,
-			strictVersion,
-			requiredVersion,
-			import: request,
-			singleton,
-			eager
-		} = this.options;
-		let fallbackCode;
-		if (request) {
-			if (eager) {
-				const dep = this.dependencies[0];
-				fallbackCode = runtimeTemplate.syncModuleFactory({
-					dependency: dep,
-					chunkGraph,
-					runtimeRequirements,
-					request: this.options.import
-				});
-			} else {
-				const block = this.blocks[0];
-				fallbackCode = runtimeTemplate.asyncModuleFactory({
-					block,
-					chunkGraph,
-					runtimeRequirements,
-					request: this.options.import
-				});
-			}
-		}
-		let fn = "load";
-		const args = [JSON.stringify(shareScope), JSON.stringify(shareKey)];
-		if (requiredVersion) {
-			if (strictVersion) {
-				fn += "Strict";
-			}
-			if (singleton) {
-				fn += "Singleton";
-			}
-			args.push(stringifyHoley(requiredVersion));
-			fn += "VersionCheck";
-		} else {
-			if (singleton) {
-				fn += "Singleton";
-			}
-		}
-		if (fallbackCode) {
-			fn += "Fallback";
-			args.push(fallbackCode);
-		}
-		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
-		const sources = new Map();
-		sources.set("consume-shared", new RawSource(code));
-		return {
-			runtimeRequirements,
-			sources
-		};
+	[Symbol.iterator]() {
+		this._deopt = true;
+		if (this._needMerge) this._merge();
+		return this._set[Symbol.iterator]();
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this.options);
-		super.serialize(context);
+	/* istanbul ignore next */
+	get [Symbol.toStringTag]() {
+		return "LazySet";
 	}
 
-	deserialize(context) {
-		const { read } = context;
-		this.options = read();
-		super.deserialize(context);
+	serialize({ write }) {
+		if (this._needMerge) this._merge();
+		write(this._set.size);
+		for (const item of this._set) write(item);
+	}
+
+	static deserialize({ read }) {
+		const count = read();
+		const items = [];
+		for (let i = 0; i < count; i++) {
+			items.push(read());
+		}
+		return new LazySet(items);
 	}
 }
 
-makeSerializable(
-	ConsumeSharedModule,
-	"webpack/lib/sharing/ConsumeSharedModule"
-);
+makeSerializable(LazySet, "webpack/lib/util/LazySet");
 
-module.exports = ConsumeSharedModule;
+module.exports = LazySet;
 
 
 /***/ }),
 
-/***/ 15046:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 82482:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -121915,324 +122250,94 @@ module.exports = ConsumeSharedModule;
 
 
 
-const ModuleNotFoundError = __webpack_require__(32882);
-const RuntimeGlobals = __webpack_require__(16475);
-const WebpackError = __webpack_require__(53799);
-const { parseOptions } = __webpack_require__(3083);
-const LazySet = __webpack_require__(38938);
-const createSchemaValidation = __webpack_require__(32540);
-const { parseRange } = __webpack_require__(19702);
-const ConsumeSharedFallbackDependency = __webpack_require__(58831);
-const ConsumeSharedModule = __webpack_require__(62286);
-const ConsumeSharedRuntimeModule = __webpack_require__(10394);
-const ProvideForSharedDependency = __webpack_require__(40017);
-const { resolveMatchedConfigs } = __webpack_require__(3591);
-const {
-	isRequiredVersion,
-	getDescriptionFile,
-	getRequiredVersionFromDescriptionFile
-} = __webpack_require__(84379);
-
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
-/** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
+/**
+ * @template K
+ * @template V
+ * @param {Map<K, V>} map a map
+ * @param {K} key the key
+ * @param {function(): V} computer compute value
+ * @returns {V} value
+ */
+exports.provide = (map, key, computer) => {
+	const value = map.get(key);
+	if (value !== undefined) return value;
+	const newValue = computer();
+	map.set(key, newValue);
+	return newValue;
+};
 
-const validate = createSchemaValidation(
-	__webpack_require__(6464),
-	() => __webpack_require__(16116),
-	{
-		name: "Consume Shared Plugin",
-		baseDataPath: "options"
-	}
-);
 
-/** @type {ResolveOptionsWithDependencyType} */
-const RESOLVE_OPTIONS = { dependencyType: "esm" };
-const PLUGIN_NAME = "ConsumeSharedPlugin";
+/***/ }),
 
-class ConsumeSharedPlugin {
-	/**
-	 * @param {ConsumeSharedPluginOptions} options options
-	 */
-	constructor(options) {
-		if (typeof options !== "string") {
-			validate(options);
-		}
+/***/ 50780:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-		/** @type {[string, ConsumeOptions][]} */
-		this._consumes = parseOptions(
-			options.consumes,
-			(item, key) => {
-				if (Array.isArray(item)) throw new Error("Unexpected array in options");
-				/** @type {ConsumeOptions} */
-				let result =
-					item === key || !isRequiredVersion(item)
-						? // item is a request/key
-						  {
-								import: key,
-								shareScope: options.shareScope || "default",
-								shareKey: key,
-								requiredVersion: undefined,
-								packageName: undefined,
-								strictVersion: false,
-								singleton: false,
-								eager: false
-						  }
-						: // key is a request/key
-						  // item is a version
-						  {
-								import: key,
-								shareScope: options.shareScope || "default",
-								shareKey: key,
-								requiredVersion: parseRange(item),
-								strictVersion: true,
-								packageName: undefined,
-								singleton: false,
-								eager: false
-						  };
-				return result;
-			},
-			(item, key) => ({
-				import: item.import === false ? undefined : item.import || key,
-				shareScope: item.shareScope || options.shareScope || "default",
-				shareKey: item.shareKey || key,
-				requiredVersion:
-					typeof item.requiredVersion === "string"
-						? parseRange(item.requiredVersion)
-						: item.requiredVersion,
-				strictVersion:
-					typeof item.strictVersion === "boolean"
-						? item.strictVersion
-						: item.import !== false && !item.singleton,
-				packageName: item.packageName,
-				singleton: !!item.singleton,
-				eager: !!item.eager
-			})
-		);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ConsumeSharedFallbackDependency,
-					normalModuleFactory
-				);
 
-				let unresolvedConsumes, resolvedConsumes, prefixedConsumes;
-				const promise = resolveMatchedConfigs(compilation, this._consumes).then(
-					({ resolved, unresolved, prefixed }) => {
-						resolvedConsumes = resolved;
-						unresolvedConsumes = unresolved;
-						prefixedConsumes = prefixed;
-					}
-				);
 
-				const resolver = compilation.resolverFactory.get(
-					"normal",
-					RESOLVE_OPTIONS
-				);
+const binarySearchBounds = __webpack_require__(92229);
 
-				/**
-				 * @param {string} context issuer directory
-				 * @param {string} request request
-				 * @param {ConsumeOptions} config options
-				 * @returns {Promise<ConsumeSharedModule>} create module
-				 */
-				const createConsumeSharedModule = (context, request, config) => {
-					const requiredVersionWarning = details => {
-						const error = new WebpackError(
-							`No required version specified and unable to automatically determine one. ${details}`
-						);
-						error.file = `shared module ${request}`;
-						compilation.warnings.push(error);
-					};
-					const directFallback =
-						config.import &&
-						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
-					return Promise.all([
-						new Promise(resolve => {
-							if (!config.import) return resolve();
-							const resolveContext = {
-								/** @type {LazySet<string>} */
-								fileDependencies: new LazySet(),
-								/** @type {LazySet<string>} */
-								contextDependencies: new LazySet(),
-								/** @type {LazySet<string>} */
-								missingDependencies: new LazySet()
-							};
-							resolver.resolve(
-								{},
-								directFallback ? compiler.context : context,
-								config.import,
-								resolveContext,
-								(err, result) => {
-									compilation.contextDependencies.addAll(
-										resolveContext.contextDependencies
-									);
-									compilation.fileDependencies.addAll(
-										resolveContext.fileDependencies
-									);
-									compilation.missingDependencies.addAll(
-										resolveContext.missingDependencies
-									);
-									if (err) {
-										compilation.errors.push(
-											new ModuleNotFoundError(null, err, {
-												name: `resolving fallback for shared module ${request}`
-											})
-										);
-										return resolve();
-									}
-									resolve(result);
-								}
-							);
-						}),
-						new Promise(resolve => {
-							if (config.requiredVersion !== undefined)
-								return resolve(config.requiredVersion);
-							let packageName = config.packageName;
-							if (packageName === undefined) {
-								if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
-									// For relative or absolute requests we don't automatically use a packageName.
-									// If wished one can specify one with the packageName option.
-									return resolve();
-								}
-								const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
-								if (!match) {
-									requiredVersionWarning(
-										"Unable to extract the package name from request."
-									);
-									return resolve();
-								}
-								packageName = match[0];
-							}
+class ParallelismFactorCalculator {
+	constructor() {
+		this._rangePoints = [];
+		this._rangeCallbacks = [];
+	}
 
-							getDescriptionFile(
-								compilation.inputFileSystem,
-								context,
-								["package.json"],
-								(err, result) => {
-									if (err) {
-										requiredVersionWarning(
-											`Unable to read description file: ${err}`
-										);
-										return resolve();
-									}
-									const { data, path: descriptionPath } = result;
-									if (!data) {
-										requiredVersionWarning(
-											`Unable to find description file in ${context}.`
-										);
-										return resolve();
-									}
-									const requiredVersion = getRequiredVersionFromDescriptionFile(
-										data,
-										packageName
-									);
-									if (typeof requiredVersion !== "string") {
-										requiredVersionWarning(
-											`Unable to find required version for "${packageName}" in description file (${descriptionPath}). It need to be in dependencies, devDependencies or peerDependencies.`
-										);
-										return resolve();
-									}
-									resolve(parseRange(requiredVersion));
-								}
-							);
-						})
-					]).then(([importResolved, requiredVersion]) => {
-						return new ConsumeSharedModule(
-							directFallback ? compiler.context : context,
-							{
-								...config,
-								importResolved,
-								import: importResolved ? config.import : undefined,
-								requiredVersion
-							}
-						);
-					});
-				};
+	range(start, end, callback) {
+		if (start === end) return callback(1);
+		this._rangePoints.push(start);
+		this._rangePoints.push(end);
+		this._rangeCallbacks.push(callback);
+	}
 
-				normalModuleFactory.hooks.factorize.tapPromise(
-					PLUGIN_NAME,
-					({ context, request, dependencies }) =>
-						// wait for resolving to be complete
-						promise.then(() => {
-							if (
-								dependencies[0] instanceof ConsumeSharedFallbackDependency ||
-								dependencies[0] instanceof ProvideForSharedDependency
-							) {
-								return;
-							}
-							const match = unresolvedConsumes.get(request);
-							if (match !== undefined) {
-								return createConsumeSharedModule(context, request, match);
-							}
-							for (const [prefix, options] of prefixedConsumes) {
-								if (request.startsWith(prefix)) {
-									const remainder = request.slice(prefix.length);
-									return createConsumeSharedModule(context, request, {
-										...options,
-										import: options.import
-											? options.import + remainder
-											: undefined,
-										shareKey: options.shareKey + remainder
-									});
-								}
-							}
-						})
-				);
-				normalModuleFactory.hooks.createModule.tapPromise(
-					PLUGIN_NAME,
-					({ resource }, { context, dependencies }) => {
-						if (
-							dependencies[0] instanceof ConsumeSharedFallbackDependency ||
-							dependencies[0] instanceof ProvideForSharedDependency
-						) {
-							return Promise.resolve();
-						}
-						const options = resolvedConsumes.get(resource);
-						if (options !== undefined) {
-							return createConsumeSharedModule(context, resource, options);
-						}
-						return Promise.resolve();
-					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					PLUGIN_NAME,
-					(chunk, set) => {
-						set.add(RuntimeGlobals.module);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-						set.add(RuntimeGlobals.shareScopeMap);
-						set.add(RuntimeGlobals.initializeSharing);
-						set.add(RuntimeGlobals.hasOwnProperty);
-						compilation.addRuntimeModule(
-							chunk,
-							new ConsumeSharedRuntimeModule(set)
-						);
-					}
-				);
-			}
+	calculate() {
+		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
+			a < b ? -1 : 1
 		);
+		const parallelism = segments.map(() => 0);
+		const rangeStartIndices = [];
+		for (let i = 0; i < this._rangePoints.length; i += 2) {
+			const start = this._rangePoints[i];
+			const end = this._rangePoints[i + 1];
+			let idx = binarySearchBounds.eq(segments, start);
+			rangeStartIndices.push(idx);
+			do {
+				parallelism[idx]++;
+				idx++;
+			} while (segments[idx] < end);
+		}
+		for (let i = 0; i < this._rangeCallbacks.length; i++) {
+			const start = this._rangePoints[i * 2];
+			const end = this._rangePoints[i * 2 + 1];
+			let idx = rangeStartIndices[i];
+			let sum = 0;
+			let totalDuration = 0;
+			let current = start;
+			do {
+				const p = parallelism[idx];
+				idx++;
+				const duration = segments[idx] - current;
+				totalDuration += duration;
+				current = segments[idx];
+				sum += p * duration;
+			} while (current < end);
+			this._rangeCallbacks[i](sum / totalDuration);
+		}
 	}
 }
 
-module.exports = ConsumeSharedPlugin;
+module.exports = ParallelismFactorCalculator;
 
 
 /***/ }),
 
-/***/ 10394:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 65930:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -122242,365 +122347,158 @@ module.exports = ConsumeSharedPlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const {
-	parseVersionRuntimeCode,
-	versionLtRuntimeCode,
-	rangeToStringRuntimeCode,
-	satisfyRuntimeCode
-} = __webpack_require__(19702);
+/**
+ * @template T
+ */
+class Queue {
+	/**
+	 * @param {Iterable<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/** @private @type {Set<T>} */
+		this._set = new Set(items);
+		/** @private @type {Iterator<T>} */
+		this._iterator = this._set[Symbol.iterator]();
+	}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
+	/**
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this._set.size;
+	}
 
-class ConsumeSharedRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements) {
-		super("consumes", RuntimeModule.STAGE_ATTACH);
-		this._runtimeRequirements = runtimeRequirements;
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
+	 * @returns {void}
+	 */
+	enqueue(item) {
+		this._set.add(item);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
 	 */
-	generate() {
-		const { compilation, chunkGraph } = this;
-		const { runtimeTemplate, codeGenerationResults } = compilation;
-		const chunkToModuleMapping = {};
-		/** @type {Map<string | number, Source>} */
-		const moduleIdToSourceMapping = new Map();
-		const initialConsumes = [];
-		/**
-		 *
-		 * @param {Iterable<Module>} modules modules
-		 * @param {Chunk} chunk the chunk
-		 * @param {(string | number)[]} list list of ids
-		 */
-		const addModules = (modules, chunk, list) => {
-			for (const m of modules) {
-				const module = /** @type {ConsumeSharedModule} */ (m);
-				const id = chunkGraph.getModuleId(module);
-				list.push(id);
-				moduleIdToSourceMapping.set(
-					id,
-					codeGenerationResults.getSource(
-						module,
-						chunk.runtime,
-						"consume-shared"
-					)
-				);
-			}
-		};
-		for (const chunk of this.chunk.getAllAsyncChunks()) {
-			const modules = chunkGraph.getChunkModulesIterableBySourceType(
-				chunk,
-				"consume-shared"
-			);
-			if (!modules) continue;
-			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
+	dequeue() {
+		const result = this._iterator.next();
+		if (result.done) return undefined;
+		this._set.delete(result.value);
+		return result.value;
+	}
+}
+
+module.exports = Queue;
+
+
+/***/ }),
+
+/***/ 93347:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/**
+ * intersect creates Set containing the intersection of elements between all sets
+ * @template T
+ * @param {Set<T>[]} sets an array of sets being checked for shared elements
+ * @returns {Set<T>} returns a new Set containing the intersecting items
+ */
+const intersect = sets => {
+	if (sets.length === 0) return new Set();
+	if (sets.length === 1) return new Set(sets[0]);
+	let minSize = Infinity;
+	let minIndex = -1;
+	for (let i = 0; i < sets.length; i++) {
+		const size = sets[i].size;
+		if (size < minSize) {
+			minIndex = i;
+			minSize = size;
 		}
-		for (const chunk of this.chunk.getAllInitialChunks()) {
-			const modules = chunkGraph.getChunkModulesIterableBySourceType(
-				chunk,
-				"consume-shared"
-			);
-			if (!modules) continue;
-			addModules(modules, chunk, initialConsumes);
+	}
+	const current = new Set(sets[minIndex]);
+	for (let i = 0; i < sets.length; i++) {
+		if (i === minIndex) continue;
+		const set = sets[i];
+		for (const item of current) {
+			if (!set.has(item)) {
+				current.delete(item);
+			}
 		}
-		if (moduleIdToSourceMapping.size === 0) return null;
-		return Template.asString([
-			parseVersionRuntimeCode(runtimeTemplate),
-			versionLtRuntimeCode(runtimeTemplate),
-			rangeToStringRuntimeCode(runtimeTemplate),
-			satisfyRuntimeCode(runtimeTemplate),
-			`var ensureExistence = ${runtimeTemplate.basicFunction("scopeName, key", [
-				`var scope = ${RuntimeGlobals.shareScopeMap}[scopeName];`,
-				`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) throw new Error("Shared module " + key + " doesn't exist in shared scope " + scopeName);`,
-				"return scope;"
-			])};`,
-			`var findVersion = ${runtimeTemplate.basicFunction("scope, key", [
-				"var versions = scope[key];",
-				`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-					"a, b",
-					["return !a || versionLt(a, b) ? b : a;"]
-				)}, 0);`,
-				"return key && versions[key]"
-			])};`,
-			`var findSingletonVersionKey = ${runtimeTemplate.basicFunction(
-				"scope, key",
-				[
-					"var versions = scope[key];",
-					`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-						"a, b",
-						["return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;"]
-					)}, 0);`
-				]
-			)};`,
-			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
-				"scope, key, version, requiredVersion",
-				[
-					`return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
-				]
-			)};`,
-			`var getSingleton = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var getSingletonVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));',
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var getStrictSingletonVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						"throw new Error(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));",
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var findValidVersion = ${runtimeTemplate.basicFunction(
-				"scope, key, requiredVersion",
-				[
-					"var versions = scope[key];",
-					`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-						"a, b",
-						[
-							"if (!satisfy(requiredVersion, b)) return a;",
-							"return !a || versionLt(a, b) ? b : a;"
-						]
-					)}, 0);`,
-					"return key && versions[key]"
-				]
-			)};`,
-			`var getInvalidVersionMessage = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var versions = scope[key];",
-					'return "No satisfying version (" + rangeToString(requiredVersion) + ") of shared module " + key + " found in shared scope " + scopeName + ".\\n" +',
-					`\t"Available versions: " + Object.keys(versions).map(${runtimeTemplate.basicFunction(
-						"key",
-						['return key + " from " + versions[key].from;']
-					)}).join(", ");`
-				]
-			)};`,
-			`var getValidVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var entry = findValidVersion(scope, key, requiredVersion);",
-					"if(entry) return get(entry);",
-					"throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
-				]
-			)};`,
-			`var warnInvalidVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					'typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));'
-				]
-			)};`,
-			`var get = ${runtimeTemplate.basicFunction("entry", [
-				"entry.loaded = 1;",
-				"return entry.get()"
-			])};`,
-			`var init = ${runtimeTemplate.returningFunction(
-				Template.asString([
-					"function(scopeName, a, b, c) {",
-					Template.indent([
-						`var promise = ${RuntimeGlobals.initializeSharing}(scopeName);`,
-						`if (promise && promise.then) return promise.then(fn.bind(fn, scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c));`,
-						`return fn(scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c);`
-					]),
-					"}"
-				]),
-				"fn"
-			)};`,
-			"",
-			`var load = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key",
-				[
-					"ensureExistence(scopeName, key);",
-					"return get(findVersion(scope, key));"
-				]
-			)});`,
-			`var loadFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, fallback",
-				[
-					`return scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) ? get(findVersion(scope, key)) : fallback();`
-				]
-			)});`,
-			`var loadVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
-				]
-			)});`,
-			`var loadSingleton = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getSingleton(scope, scopeName, key);"
-				]
-			)});`,
-			`var loadSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getValidVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getStrictSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
-				]
-			)});`,
-			`var loadSingletonFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getSingleton(scope, scopeName, key);"
-				]
-			)});`,
-			`var loadSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`var entry = scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) && findValidVersion(scope, key, version);`,
-					`return entry ? get(entry) : fallback();`
-				]
-			)});`,
-			`var loadStrictSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getStrictSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			"var installedModules = {};",
-			"var moduleToHandlerMapping = {",
-			Template.indent(
-				Array.from(
-					moduleIdToSourceMapping,
-					([key, source]) => `${JSON.stringify(key)}: ${source.source()}`
-				).join(",\n")
-			),
-			"};",
+	}
+	return current;
+};
 
-			initialConsumes.length > 0
-				? Template.asString([
-						`var initialConsumes = ${JSON.stringify(initialConsumes)};`,
-						`initialConsumes.forEach(${runtimeTemplate.basicFunction("id", [
-							`${
-								RuntimeGlobals.moduleFactories
-							}[id] = ${runtimeTemplate.basicFunction("module", [
-								"// Handle case when module is used sync",
-								"installedModules[id] = 0;",
-								`delete ${RuntimeGlobals.moduleCache}[id];`,
-								"var factory = moduleToHandlerMapping[id]();",
-								'if(typeof factory !== "function") throw new Error("Shared module is not available for eager consumption: " + id);',
-								`module.exports = factory();`
-							])}`
-						])});`
-				  ])
-				: "// no consumes in initial chunks",
-			this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
-				? Template.asString([
-						`var chunkMapping = ${JSON.stringify(
-							chunkToModuleMapping,
-							null,
-							"\t"
-						)};`,
-						`${
-							RuntimeGlobals.ensureChunkHandlers
-						}.consumes = ${runtimeTemplate.basicFunction("chunkId, promises", [
-							`if(${RuntimeGlobals.hasOwnProperty}(chunkMapping, chunkId)) {`,
-							Template.indent([
-								`chunkMapping[chunkId].forEach(${runtimeTemplate.basicFunction(
-									"id",
-									[
-										`if(${RuntimeGlobals.hasOwnProperty}(installedModules, id)) return promises.push(installedModules[id]);`,
-										`var onFactory = ${runtimeTemplate.basicFunction(
-											"factory",
-											[
-												"installedModules[id] = 0;",
-												`${
-													RuntimeGlobals.moduleFactories
-												}[id] = ${runtimeTemplate.basicFunction("module", [
-													`delete ${RuntimeGlobals.moduleCache}[id];`,
-													"module.exports = factory();"
-												])}`
-											]
-										)};`,
-										`var onError = ${runtimeTemplate.basicFunction("error", [
-											"delete installedModules[id];",
-											`${
-												RuntimeGlobals.moduleFactories
-											}[id] = ${runtimeTemplate.basicFunction("module", [
-												`delete ${RuntimeGlobals.moduleCache}[id];`,
-												"throw error;"
-											])}`
-										])};`,
-										"try {",
-										Template.indent([
-											"var promise = moduleToHandlerMapping[id]();",
-											"if(promise.then) {",
-											Template.indent(
-												"promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));"
-											),
-											"} else onFactory(promise);"
-										]),
-										"} catch(e) { onError(e); }"
-									]
-								)});`
-							]),
-							"}"
-						])}`
-				  ])
-				: "// no chunk loading of consumes"
-		]);
+/**
+ * Checks if a set is the subset of another set
+ * @template T
+ * @param {Set<T>} bigSet a Set which contains the original elements to compare against
+ * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
+ * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
+ */
+const isSubset = (bigSet, smallSet) => {
+	if (bigSet.size < smallSet.size) return false;
+	for (const item of smallSet) {
+		if (!bigSet.has(item)) return false;
 	}
-}
+	return true;
+};
 
-module.exports = ConsumeSharedRuntimeModule;
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @param {function(T): boolean} fn selector function
+ * @returns {T | undefined} found item
+ */
+const find = (set, fn) => {
+	for (const item of set) {
+		if (fn(item)) return item;
+	}
+};
+
+/**
+ * @template T
+ * @param {Set<T>} set a set
+ * @returns {T | undefined} first item
+ */
+const first = set => {
+	const entry = set.values().next();
+	return entry.done ? undefined : entry.value;
+};
+
+/**
+ * @template T
+ * @param {Set<T>} a first
+ * @param {Set<T>} b second
+ * @returns {Set<T>} combined set, may be identical to a or b
+ */
+const combine = (a, b) => {
+	if (b.size === 0) return a;
+	if (a.size === 0) return b;
+	const set = new Set(a);
+	for (const item of b) set.add(item);
+	return set;
+};
+
+exports.intersect = intersect;
+exports.isSubset = isSubset;
+exports.find = find;
+exports.first = first;
+exports.combine = combine;
 
 
 /***/ }),
 
-/***/ 40017:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 13098:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -122610,39 +122508,165 @@ module.exports = ConsumeSharedRuntimeModule;
 
 
 
-const ModuleDependency = __webpack_require__(80321);
-const makeSerializable = __webpack_require__(33032);
+const NONE = Symbol("not sorted");
 
-class ProvideForSharedDependency extends ModuleDependency {
+/**
+ * A subset of Set that offers sorting functionality
+ * @template T item type in set
+ * @extends {Set<T>}
+ */
+class SortableSet extends Set {
 	/**
-	 *
-	 * @param {string} request request string
+	 * Create a new sortable set
+	 * @param {Iterable<T>=} initialIterable The initial iterable value
+	 * @typedef {function(T, T): number} SortFunction
+	 * @param {SortFunction=} defaultSort Default sorting function
 	 */
-	constructor(request) {
-		super(request);
+	constructor(initialIterable, defaultSort) {
+		super(initialIterable);
+		/** @private @type {undefined | function(T, T): number}} */
+		this._sortFn = defaultSort;
+		/** @private @type {typeof NONE | undefined | function(T, T): number}} */
+		this._lastActiveSortFn = NONE;
+		/** @private @type {Map<Function, any> | undefined} */
+		this._cache = undefined;
+		/** @private @type {Map<Function, any> | undefined} */
+		this._cacheOrderIndependent = undefined;
 	}
 
-	get type() {
-		return "provide module for shared";
+	/**
+	 * @param {T} value value to add to set
+	 * @returns {this} returns itself
+	 */
+	add(value) {
+		this._lastActiveSortFn = NONE;
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		super.add(value);
+		return this;
 	}
 
-	get category() {
-		return "esm";
+	/**
+	 * @param {T} value value to delete
+	 * @returns {boolean} true if value existed in set, false otherwise
+	 */
+	delete(value) {
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		return super.delete(value);
 	}
-}
 
-makeSerializable(
-	ProvideForSharedDependency,
-	"webpack/lib/sharing/ProvideForSharedDependency"
-);
+	/**
+	 * @returns {void}
+	 */
+	clear() {
+		this._invalidateCache();
+		this._invalidateOrderedCache();
+		return super.clear();
+	}
 
-module.exports = ProvideForSharedDependency;
+	/**
+	 * Sort with a comparer function
+	 * @param {SortFunction} sortFn Sorting comparer function
+	 * @returns {void}
+	 */
+	sortWith(sortFn) {
+		if (this.size <= 1 || sortFn === this._lastActiveSortFn) {
+			// already sorted - nothing to do
+			return;
+		}
+
+		const sortedArray = Array.from(this).sort(sortFn);
+		super.clear();
+		for (let i = 0; i < sortedArray.length; i += 1) {
+			super.add(sortedArray[i]);
+		}
+		this._lastActiveSortFn = sortFn;
+		this._invalidateCache();
+	}
+
+	sort() {
+		this.sortWith(this._sortFn);
+		return this;
+	}
+
+	/**
+	 * Get data from cache
+	 * @template R
+	 * @param {function(SortableSet<T>): R} fn function to calculate value
+	 * @returns {R} returns result of fn(this), cached until set changes
+	 */
+	getFromCache(fn) {
+		if (this._cache === undefined) {
+			this._cache = new Map();
+		} else {
+			const result = this._cache.get(fn);
+			const data = /** @type {R} */ (result);
+			if (data !== undefined) {
+				return data;
+			}
+		}
+		const newData = fn(this);
+		this._cache.set(fn, newData);
+		return newData;
+	}
+
+	/**
+	 * Get data from cache (ignoring sorting)
+	 * @template R
+	 * @param {function(SortableSet<T>): R} fn function to calculate value
+	 * @returns {R} returns result of fn(this), cached until set changes
+	 */
+	getFromUnorderedCache(fn) {
+		if (this._cacheOrderIndependent === undefined) {
+			this._cacheOrderIndependent = new Map();
+		} else {
+			const result = this._cacheOrderIndependent.get(fn);
+			const data = /** @type {R} */ (result);
+			if (data !== undefined) {
+				return data;
+			}
+		}
+		const newData = fn(this);
+		this._cacheOrderIndependent.set(fn, newData);
+		return newData;
+	}
+
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_invalidateCache() {
+		if (this._cache !== undefined) {
+			this._cache.clear();
+		}
+	}
+
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_invalidateOrderedCache() {
+		if (this._cacheOrderIndependent !== undefined) {
+			this._cacheOrderIndependent.clear();
+		}
+	}
+
+	/**
+	 * @returns {T[]} the raw array
+	 */
+	toJSON() {
+		return Array.from(this);
+	}
+}
+
+module.exports = SortableSet;
 
 
 /***/ }),
 
-/***/ 1798:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 64985:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -122652,648 +122676,674 @@ module.exports = ProvideForSharedDependency;
 
 
 
-const Dependency = __webpack_require__(54912);
-const makeSerializable = __webpack_require__(33032);
-
-class ProvideSharedDependency extends Dependency {
-	constructor(shareScope, name, version, request, eager) {
-		super();
-		this.shareScope = shareScope;
-		this.name = name;
-		this.version = version;
-		this.request = request;
-		this.eager = eager;
+/**
+ * @template K
+ * @template V
+ */
+class StackedCacheMap {
+	constructor() {
+		/** @type {Map<K, V>} */
+		this.map = new Map();
+		/** @type {ReadonlyMap<K, V>[]} */
+		this.stack = [];
 	}
 
-	get type() {
-		return "provide shared module";
+	/**
+	 * @param {ReadonlyMap<K, V>} map map to add
+	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
+	 */
+	addAll(map, immutable) {
+		if (immutable) {
+			this.stack.push(map);
+
+			// largest map should go first
+			for (let i = this.stack.length - 1; i > 0; i--) {
+				const beforeLast = this.stack[i - 1];
+				if (beforeLast.size >= map.size) break;
+				this.stack[i] = beforeLast;
+				this.stack[i - 1] = map;
+			}
+		} else {
+			for (const [key, value] of map) {
+				this.map.set(key, value);
+			}
+		}
 	}
 
 	/**
-	 * @returns {string | null} an identifier to merge equal requests
+	 * @param {K} item the key of the element to add
+	 * @param {V} value the value of the element to add
+	 * @returns {void}
 	 */
-	getResourceIdentifier() {
-		return `provide module (${this.shareScope}) ${this.request} as ${
-			this.name
-		} @ ${this.version}${this.eager ? " (eager)" : ""}`;
+	set(item, value) {
+		this.map.set(item, value);
 	}
 
-	serialize(context) {
-		context.write(this.shareScope);
-		context.write(this.name);
-		context.write(this.request);
-		context.write(this.version);
-		context.write(this.eager);
-		super.serialize(context);
+	/**
+	 * @param {K} item the item to delete
+	 * @returns {void}
+	 */
+	delete(item) {
+		throw new Error("Items can't be deleted from a StackedCacheMap");
 	}
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new ProvideSharedDependency(
-			read(),
-			read(),
-			read(),
-			read(),
-			read()
+	/**
+	 * @param {K} item the item to test
+	 * @returns {boolean} true if the item exists in this set
+	 */
+	has(item) {
+		throw new Error(
+			"Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined"
 		);
-		this.shareScope = context.read();
-		obj.deserialize(context);
-		return obj;
 	}
-}
 
-makeSerializable(
-	ProvideSharedDependency,
-	"webpack/lib/sharing/ProvideSharedDependency"
-);
+	/**
+	 * @param {K} item the key of the element to return
+	 * @returns {V} the value of the element
+	 */
+	get(item) {
+		for (const map of this.stack) {
+			const value = map.get(item);
+			if (value !== undefined) return value;
+		}
+		return this.map.get(item);
+	}
 
-module.exports = ProvideSharedDependency;
+	clear() {
+		this.stack.length = 0;
+		this.map.clear();
+	}
+
+	get size() {
+		let size = this.map.size;
+		for (const map of this.stack) {
+			size += map.size;
+		}
+		return size;
+	}
+
+	[Symbol.iterator]() {
+		const iterators = this.stack.map(map => map[Symbol.iterator]());
+		let current = this.map[Symbol.iterator]();
+		return {
+			next() {
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = iterators.pop();
+					result = current.next();
+				}
+				return result;
+			}
+		};
+	}
+}
+
+module.exports = StackedCacheMap;
 
 
 /***/ }),
 
-/***/ 50821:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 58845:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const AsyncDependenciesBlock = __webpack_require__(47736);
-const Module = __webpack_require__(73208);
-const RuntimeGlobals = __webpack_require__(16475);
-const makeSerializable = __webpack_require__(33032);
-const ProvideForSharedDependency = __webpack_require__(40017);
+const TOMBSTONE = Symbol("tombstone");
+const UNDEFINED_MARKER = Symbol("undefined");
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/**
+ * @template T
+ * @typedef {T | undefined} Cell<T>
+ */
 
-const TYPES = new Set(["share-init"]);
+/**
+ * @template T
+ * @typedef {T | typeof TOMBSTONE | typeof UNDEFINED_MARKER} InternalCell<T>
+ */
 
-class ProvideSharedModule extends Module {
-	/**
-	 * @param {string} shareScope shared scope name
-	 * @param {string} name shared key
-	 * @param {string | false} version version
-	 * @param {string} request request to the provided module
-	 * @param {boolean} eager include the module in sync way
-	 */
-	constructor(shareScope, name, version, request, eager) {
-		super("provide-module");
-		this._shareScope = shareScope;
-		this._name = name;
-		this._version = version;
-		this._request = request;
-		this._eager = eager;
+/**
+ * @template K
+ * @template V
+ * @param {[K, InternalCell<V>]} pair the internal cell
+ * @returns {[K, Cell<V>]} its “safe” representation
+ */
+const extractPair = pair => {
+	const key = pair[0];
+	const val = pair[1];
+	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
+		return [key, undefined];
+	} else {
+		return /** @type {[K, Cell<V>]} */ (pair);
 	}
+};
 
+/**
+ * @template K
+ * @template V
+ */
+class StackedMap {
 	/**
-	 * @returns {string} a unique identifier of the module
+	 * @param {Map<K, InternalCell<V>>[]=} parentStack an optional parent
 	 */
-	identifier() {
-		return `provide module (${this._shareScope}) ${this._name}@${this._version} = ${this._request}`;
+	constructor(parentStack) {
+		/** @type {Map<K, InternalCell<V>>} */
+		this.map = new Map();
+		/** @type {Map<K, InternalCell<V>>[]} */
+		this.stack = parentStack === undefined ? [] : parentStack.slice();
+		this.stack.push(this.map);
 	}
 
 	/**
-	 * @param {RequestShortener} requestShortener the request shortener
-	 * @returns {string} a user readable identifier of the module
+	 * @param {K} item the key of the element to add
+	 * @param {V} value the value of the element to add
+	 * @returns {void}
 	 */
-	readableIdentifier(requestShortener) {
-		return `provide shared module (${this._shareScope}) ${this._name}@${
-			this._version
-		} = ${requestShortener.shorten(this._request)}`;
+	set(item, value) {
+		this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
 	}
 
 	/**
-	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @param {K} item the item to delete
+	 * @returns {void}
 	 */
-	libIdent(options) {
-		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
-			this._shareScope
-		}/${this._name}`;
+	delete(item) {
+		if (this.stack.length > 1) {
+			this.map.set(item, TOMBSTONE);
+		} else {
+			this.map.delete(item);
+		}
 	}
 
 	/**
-	 * @param {NeedBuildContext} context context info
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
-	 * @returns {void}
+	 * @param {K} item the item to test
+	 * @returns {boolean} true if the item exists in this set
 	 */
-	needBuild(context, callback) {
-		callback(null, !this.buildInfo);
+	has(item) {
+		const topValue = this.map.get(item);
+		if (topValue !== undefined) {
+			return topValue !== TOMBSTONE;
+		}
+		if (this.stack.length > 1) {
+			for (let i = this.stack.length - 2; i >= 0; i--) {
+				const value = this.stack[i].get(item);
+				if (value !== undefined) {
+					this.map.set(item, value);
+					return value !== TOMBSTONE;
+				}
+			}
+			this.map.set(item, TOMBSTONE);
+		}
+		return false;
 	}
 
 	/**
-	 * @param {WebpackOptions} options webpack options
-	 * @param {Compilation} compilation the compilation
-	 * @param {ResolverWithOptions} resolver the resolver
-	 * @param {InputFileSystem} fs the file system
-	 * @param {function(WebpackError=): void} callback callback function
-	 * @returns {void}
+	 * @param {K} item the key of the element to return
+	 * @returns {Cell<V>} the value of the element
 	 */
-	build(options, compilation, resolver, fs, callback) {
-		this.buildMeta = {};
-		this.buildInfo = {
-			strict: true
-		};
+	get(item) {
+		const topValue = this.map.get(item);
+		if (topValue !== undefined) {
+			return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
+				? undefined
+				: topValue;
+		}
+		if (this.stack.length > 1) {
+			for (let i = this.stack.length - 2; i >= 0; i--) {
+				const value = this.stack[i].get(item);
+				if (value !== undefined) {
+					this.map.set(item, value);
+					return value === TOMBSTONE || value === UNDEFINED_MARKER
+						? undefined
+						: value;
+				}
+			}
+			this.map.set(item, TOMBSTONE);
+		}
+		return undefined;
+	}
 
-		this.clearDependenciesAndBlocks();
-		const dep = new ProvideForSharedDependency(this._request);
-		if (this._eager) {
-			this.addDependency(dep);
-		} else {
-			const block = new AsyncDependenciesBlock({});
-			block.addDependency(dep);
-			this.addBlock(block);
+	_compress() {
+		if (this.stack.length === 1) return;
+		this.map = new Map();
+		for (const data of this.stack) {
+			for (const pair of data) {
+				if (pair[1] === TOMBSTONE) {
+					this.map.delete(pair[0]);
+				} else {
+					this.map.set(pair[0], pair[1]);
+				}
+			}
 		}
+		this.stack = [this.map];
+	}
+
+	asArray() {
+		this._compress();
+		return Array.from(this.map.keys());
+	}
+
+	asSet() {
+		this._compress();
+		return new Set(this.map.keys());
+	}
+
+	asPairArray() {
+		this._compress();
+		return Array.from(this.map.entries(), extractPair);
+	}
+
+	asMap() {
+		return new Map(this.asPairArray());
+	}
+
+	get size() {
+		this._compress();
+		return this.map.size;
+	}
+
+	createChild() {
+		return new StackedMap(this.stack);
+	}
+}
+
+module.exports = StackedMap;
 
-		callback();
-	}
 
-	/**
-	 * @param {string=} type the source type for which the size should be estimated
-	 * @returns {number} the estimated size of the module (must be non-zero)
-	 */
-	size(type) {
-		return 42;
-	}
+/***/ }),
 
-	/**
-	 * @returns {Set<string>} types available (do not mutate)
-	 */
-	getSourceTypes() {
-		return TYPES;
+/***/ 40293:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+class StringXor {
+	constructor() {
+		this._value = undefined;
 	}
 
 	/**
-	 * @param {CodeGenerationContext} context context for code generation
-	 * @returns {CodeGenerationResult} result
+	 * @param {string} str string
+	 * @returns {void}
 	 */
-	codeGeneration({ runtimeTemplate, moduleGraph, chunkGraph }) {
-		const runtimeRequirements = new Set([RuntimeGlobals.initializeSharing]);
-		const code = `register(${JSON.stringify(this._name)}, ${JSON.stringify(
-			this._version || "0"
-		)}, ${
-			this._eager
-				? runtimeTemplate.syncModuleFactory({
-						dependency: this.dependencies[0],
-						chunkGraph,
-						request: this._request,
-						runtimeRequirements
-				  })
-				: runtimeTemplate.asyncModuleFactory({
-						block: this.blocks[0],
-						chunkGraph,
-						request: this._request,
-						runtimeRequirements
-				  })
-		}${this._eager ? ", 1" : ""});`;
-		const sources = new Map();
-		const data = new Map();
-		data.set("share-init", [
-			{
-				shareScope: this._shareScope,
-				initStage: 10,
-				init: code
+	add(str) {
+		const len = str.length;
+		const value = this._value;
+		if (value === undefined) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			for (let i = 0; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
 			}
-		]);
-		return { sources, data, runtimeRequirements };
+			return;
+		}
+		const valueLen = value.length;
+		if (valueLen < len) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			let i;
+			for (i = 0; i < valueLen; i++) {
+				newValue[i] = value[i] ^ str.charCodeAt(i);
+			}
+			for (; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
+			}
+		} else {
+			for (let i = 0; i < len; i++) {
+				value[i] = value[i] ^ str.charCodeAt(i);
+			}
+		}
 	}
 
-	serialize(context) {
-		const { write } = context;
-		write(this._shareScope);
-		write(this._name);
-		write(this._version);
-		write(this._request);
-		write(this._eager);
-		super.serialize(context);
+	toString() {
+		const value = this._value;
+		return value === undefined ? "" : value.toString("latin1");
 	}
 
-	static deserialize(context) {
-		const { read } = context;
-		const obj = new ProvideSharedModule(read(), read(), read(), read(), read());
-		obj.deserialize(context);
-		return obj;
+	updateHash(hash) {
+		const value = this._value;
+		if (value !== undefined) hash.update(value);
 	}
 }
 
-makeSerializable(
-	ProvideSharedModule,
-	"webpack/lib/sharing/ProvideSharedModule"
-);
-
-module.exports = ProvideSharedModule;
+module.exports = StringXor;
 
 
 /***/ }),
 
-/***/ 39344:
+/***/ 38415:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const ModuleFactory = __webpack_require__(51010);
-const ProvideSharedModule = __webpack_require__(50821);
+const TupleSet = __webpack_require__(76455);
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
+/**
+ * @template {any[]} T
+ */
+class TupleQueue {
+	/**
+	 * @param {Iterable<T>=} items The initial elements.
+	 */
+	constructor(items) {
+		/** @private @type {TupleSet<T>} */
+		this._set = new TupleSet(items);
+		/** @private @type {Iterator<T>} */
+		this._iterator = this._set[Symbol.iterator]();
+	}
 
-class ProvideSharedModuleFactory extends ModuleFactory {
 	/**
-	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * Returns the number of elements in this queue.
+	 * @returns {number} The number of elements in this queue.
+	 */
+	get length() {
+		return this._set.size;
+	}
+
+	/**
+	 * Appends the specified element to this queue.
+	 * @param {T} item The element to add.
 	 * @returns {void}
 	 */
-	create(data, callback) {
-		const dep = /** @type {ProvideSharedDependency} */ (data.dependencies[0]);
-		callback(null, {
-			module: new ProvideSharedModule(
-				dep.shareScope,
-				dep.name,
-				dep.version,
-				dep.request,
-				dep.eager
-			)
-		});
+	enqueue(...item) {
+		this._set.add(...item);
+	}
+
+	/**
+	 * Retrieves and removes the head of this queue.
+	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 */
+	dequeue() {
+		const result = this._iterator.next();
+		if (result.done) {
+			if (this._set.size > 0) {
+				this._iterator = this._set[Symbol.iterator]();
+				const value = this._iterator.next().value;
+				this._set.delete(...value);
+				return value;
+			}
+			return undefined;
+		}
+		this._set.delete(...result.value);
+		return result.value;
 	}
 }
 
-module.exports = ProvideSharedModuleFactory;
+module.exports = TupleQueue;
 
 
 /***/ }),
 
-/***/ 31225:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 76455:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Tobias Koppers @sokra
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
-const { parseOptions } = __webpack_require__(3083);
-const createSchemaValidation = __webpack_require__(32540);
-const ProvideForSharedDependency = __webpack_require__(40017);
-const ProvideSharedDependency = __webpack_require__(1798);
-const ProvideSharedModuleFactory = __webpack_require__(39344);
+/**
+ * @template {any[]} T
+ */
+class TupleSet {
+	constructor(init) {
+		this._map = new Map();
+		this.size = 0;
+		if (init) {
+			for (const tuple of init) {
+				this.add(...tuple);
+			}
+		}
+	}
 
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
+	/**
+	 * @param  {T} args tuple
+	 * @returns {void}
+	 */
+	add(...args) {
+		let map = this._map;
+		for (let i = 0; i < args.length - 2; i++) {
+			const arg = args[i];
+			const innerMap = map.get(arg);
+			if (innerMap === undefined) {
+				map.set(arg, (map = new Map()));
+			} else {
+				map = innerMap;
+			}
+		}
 
-const validate = createSchemaValidation(
-	__webpack_require__(91924),
-	() => __webpack_require__(438),
-	{
-		name: "Provide Shared Plugin",
-		baseDataPath: "options"
+		const beforeLast = args[args.length - 2];
+		let set = map.get(beforeLast);
+		if (set === undefined) {
+			map.set(beforeLast, (set = new Set()));
+		}
+
+		const last = args[args.length - 1];
+		this.size -= set.size;
+		set.add(last);
+		this.size += set.size;
 	}
-);
 
-/**
- * @typedef {Object} ProvideOptions
- * @property {string} shareKey
- * @property {string} shareScope
- * @property {string | undefined | false} version
- * @property {boolean} eager
- */
+	/**
+	 * @param  {T} args tuple
+	 * @returns {boolean} true, if the tuple is in the Set
+	 */
+	has(...args) {
+		let map = this._map;
+		for (let i = 0; i < args.length - 2; i++) {
+			const arg = args[i];
+			map = map.get(arg);
+			if (map === undefined) {
+				return false;
+			}
+		}
 
-/** @typedef {Map<string, { config: ProvideOptions, version: string | undefined | false }>} ResolvedProvideMap */
+		const beforeLast = args[args.length - 2];
+		let set = map.get(beforeLast);
+		if (set === undefined) {
+			return false;
+		}
+
+		const last = args[args.length - 1];
+		return set.has(last);
+	}
 
-class ProvideSharedPlugin {
 	/**
-	 * @param {ProvideSharedPluginOptions} options options
+	 * @param {T} args tuple
+	 * @returns {void}
 	 */
-	constructor(options) {
-		validate(options);
+	delete(...args) {
+		let map = this._map;
+		for (let i = 0; i < args.length - 2; i++) {
+			const arg = args[i];
+			map = map.get(arg);
+			if (map === undefined) {
+				return;
+			}
+		}
 
-		/** @type {[string, ProvideOptions][]} */
-		this._provides = parseOptions(
-			options.provides,
-			item => {
-				if (Array.isArray(item))
-					throw new Error("Unexpected array of provides");
-				/** @type {ProvideOptions} */
-				const result = {
-					shareKey: item,
-					version: undefined,
-					shareScope: options.shareScope || "default",
-					eager: false
-				};
-				return result;
-			},
-			item => ({
-				shareKey: item.shareKey,
-				version: item.version,
-				shareScope: item.shareScope || options.shareScope || "default",
-				eager: !!item.eager
-			})
-		);
-		this._provides.sort(([a], [b]) => {
-			if (a < b) return -1;
-			if (b < a) return 1;
-			return 0;
-		});
+		const beforeLast = args[args.length - 2];
+		let set = map.get(beforeLast);
+		if (set === undefined) {
+			return;
+		}
+
+		const last = args[args.length - 1];
+		this.size -= set.size;
+		set.delete(last);
+		this.size += set.size;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @returns {Iterator<T>} iterator
 	 */
-	apply(compiler) {
-		/** @type {WeakMap<Compilation, ResolvedProvideMap>} */
-		const compilationData = new WeakMap();
+	[Symbol.iterator]() {
+		const iteratorStack = [];
+		const tuple = [];
+		let currentSetIterator = undefined;
 
-		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				/** @type {ResolvedProvideMap} */
-				const resolvedProvideMap = new Map();
-				/** @type {Map<string, ProvideOptions>} */
-				const matchProvides = new Map();
-				/** @type {Map<string, ProvideOptions>} */
-				const prefixMatchProvides = new Map();
-				for (const [request, config] of this._provides) {
-					if (/^(\/|[A-Za-z]:\\|\\\\|\.\.?(\/|$))/.test(request)) {
-						// relative request
-						resolvedProvideMap.set(request, {
-							config,
-							version: config.version
-						});
-					} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
-						// absolute path
-						resolvedProvideMap.set(request, {
-							config,
-							version: config.version
-						});
-					} else if (request.endsWith("/")) {
-						// module request prefix
-						prefixMatchProvides.set(request, config);
-					} else {
-						// module request
-						matchProvides.set(request, config);
-					}
-				}
-				compilationData.set(compilation, resolvedProvideMap);
-				const provideSharedModule = (
-					key,
-					config,
-					resource,
-					resourceResolveData
-				) => {
-					let version = config.version;
-					if (version === undefined) {
-						let details = "";
-						if (!resourceResolveData) {
-							details = `No resolve data provided from resolver.`;
-						} else {
-							const descriptionFileData =
-								resourceResolveData.descriptionFileData;
-							if (!descriptionFileData) {
-								details =
-									"No description file (usually package.json) found. Add description file with name and version, or manually specify version in shared config.";
-							} else if (!descriptionFileData.version) {
-								details =
-									"No version in description file (usually package.json). Add version to description file, or manually specify version in shared config.";
-							} else {
-								version = descriptionFileData.version;
-							}
-						}
-						if (!version) {
-							const error = new WebpackError(
-								`No version specified and unable to automatically determine one. ${details}`
-							);
-							error.file = `shared module ${key} -> ${resource}`;
-							compilation.warnings.push(error);
-						}
-					}
-					resolvedProvideMap.set(resource, {
-						config,
-						version
-					});
-				};
-				normalModuleFactory.hooks.module.tap(
-					"ProvideSharedPlugin",
-					(module, { resource, resourceResolveData }, resolveData) => {
-						if (resolvedProvideMap.has(resource)) {
-							return module;
-						}
-						const { request } = resolveData;
-						{
-							const config = matchProvides.get(request);
-							if (config !== undefined) {
-								provideSharedModule(
-									request,
-									config,
-									resource,
-									resourceResolveData
-								);
-								resolveData.cacheable = false;
-							}
-						}
-						for (const [prefix, config] of prefixMatchProvides) {
-							if (request.startsWith(prefix)) {
-								const remainder = request.slice(prefix.length);
-								provideSharedModule(
-									resource,
-									{
-										...config,
-										shareKey: config.shareKey + remainder
-									},
-									resource,
-									resourceResolveData
-								);
-								resolveData.cacheable = false;
-							}
-						}
-						return module;
-					}
-				);
+		const next = it => {
+			const result = it.next();
+			if (result.done) {
+				if (iteratorStack.length === 0) return false;
+				tuple.pop();
+				return next(iteratorStack.pop());
 			}
-		);
-		compiler.hooks.finishMake.tapPromise("ProvideSharedPlugin", compilation => {
-			const resolvedProvideMap = compilationData.get(compilation);
-			if (!resolvedProvideMap) return Promise.resolve();
-			return Promise.all(
-				Array.from(
-					resolvedProvideMap,
-					([resource, { config, version }]) =>
-						new Promise((resolve, reject) => {
-							compilation.addInclude(
-								compiler.context,
-								new ProvideSharedDependency(
-									config.shareScope,
-									config.shareKey,
-									version || false,
-									resource,
-									config.eager
-								),
-								{
-									name: undefined
-								},
-								err => {
-									if (err) return reject(err);
-									resolve();
-								}
-							);
-						})
-				)
-			).then(() => {});
-		});
+			const [key, value] = result.value;
+			iteratorStack.push(it);
+			tuple.push(key);
+			if (value instanceof Set) {
+				currentSetIterator = value[Symbol.iterator]();
+				return true;
+			} else {
+				return next(value[Symbol.iterator]());
+			}
+		};
 
-		compiler.hooks.compilation.tap(
-			"ProvideSharedPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					ProvideForSharedDependency,
-					normalModuleFactory
-				);
+		next(this._map[Symbol.iterator]());
 
-				compilation.dependencyFactories.set(
-					ProvideSharedDependency,
-					new ProvideSharedModuleFactory()
-				);
+		return {
+			next() {
+				while (currentSetIterator) {
+					const result = currentSetIterator.next();
+					if (result.done) {
+						tuple.pop();
+						if (!next(iteratorStack.pop())) {
+							currentSetIterator = undefined;
+						}
+					} else {
+						return {
+							done: false,
+							value: /** @type {T} */ (tuple.concat(result.value))
+						};
+					}
+				}
+				return { done: true, value: undefined };
 			}
-		);
+		};
 	}
 }
 
-module.exports = ProvideSharedPlugin;
+module.exports = TupleSet;
 
 
 /***/ }),
 
-/***/ 26335:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 54500:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra and Zackary Jackson @ScriptedAlchemy
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const { parseOptions } = __webpack_require__(3083);
-const ConsumeSharedPlugin = __webpack_require__(15046);
-const ProvideSharedPlugin = __webpack_require__(31225);
-const { isRequiredVersion } = __webpack_require__(84379);
+/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
+/** @typedef {(error: Error|null, result?: Buffer) => void} ErrorFirstCallback */
 
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvidesConfig} ProvidesConfig */
-/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharePluginOptions} SharePluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharedConfig} SharedConfig */
-/** @typedef {import("../Compiler")} Compiler */
+const backSlashCharCode = "\\".charCodeAt(0);
+const slashCharCode = "/".charCodeAt(0);
+const aLowerCaseCharCode = "a".charCodeAt(0);
+const zLowerCaseCharCode = "z".charCodeAt(0);
+const aUpperCaseCharCode = "A".charCodeAt(0);
+const zUpperCaseCharCode = "Z".charCodeAt(0);
+const _0CharCode = "0".charCodeAt(0);
+const _9CharCode = "9".charCodeAt(0);
+const plusCharCode = "+".charCodeAt(0);
+const hyphenCharCode = "-".charCodeAt(0);
+const colonCharCode = ":".charCodeAt(0);
+const hashCharCode = "#".charCodeAt(0);
+const queryCharCode = "?".charCodeAt(0);
+/**
+ * Get scheme if specifier is an absolute URL specifier
+ * e.g. Absolute specifiers like 'file:///user/webpack/index.js'
+ * https://tools.ietf.org/html/rfc3986#section-3.1
+ * @param {string} specifier specifier
+ * @returns {string|undefined} scheme if absolute URL specifier provided
+ */
+function getScheme(specifier) {
+	const start = specifier.charCodeAt(0);
 
-class SharePlugin {
-	/**
-	 * @param {SharePluginOptions} options options
-	 */
-	constructor(options) {
-		/** @type {[string, SharedConfig][]} */
-		const sharedOptions = parseOptions(
-			options.shared,
-			(item, key) => {
-				if (typeof item !== "string")
-					throw new Error("Unexpected array in shared");
-				/** @type {SharedConfig} */
-				const config =
-					item === key || !isRequiredVersion(item)
-						? {
-								import: item
-						  }
-						: {
-								import: key,
-								requiredVersion: item
-						  };
-				return config;
-			},
-			item => item
-		);
-		/** @type {Record<string, ConsumesConfig>[]} */
-		const consumes = sharedOptions.map(([key, options]) => ({
-			[key]: {
-				import: options.import,
-				shareKey: options.shareKey || key,
-				shareScope: options.shareScope,
-				requiredVersion: options.requiredVersion,
-				strictVersion: options.strictVersion,
-				singleton: options.singleton,
-				packageName: options.packageName,
-				eager: options.eager
-			}
-		}));
-		/** @type {Record<string, ProvidesConfig>[]} */
-		const provides = sharedOptions
-			.filter(([, options]) => options.import !== false)
-			.map(([key, options]) => ({
-				[options.import || key]: {
-					shareKey: options.shareKey || key,
-					shareScope: options.shareScope,
-					version: options.version,
-					eager: options.eager
-				}
-			}));
-		this._shareScope = options.shareScope;
-		this._consumes = consumes;
-		this._provides = provides;
+	// First char maybe only a letter
+	if (
+		(start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
+		(start < aUpperCaseCharCode || start > zUpperCaseCharCode)
+	) {
+		return undefined;
 	}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		new ConsumeSharedPlugin({
-			shareScope: this._shareScope,
-			consumes: this._consumes
-		}).apply(compiler);
-		new ProvideSharedPlugin({
-			shareScope: this._shareScope,
-			provides: this._provides
-		}).apply(compiler);
+	let i = 1;
+	let ch = specifier.charCodeAt(i);
+
+	while (
+		(ch >= aLowerCaseCharCode && ch <= zLowerCaseCharCode) ||
+		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
+		(ch >= _0CharCode && ch <= _9CharCode) ||
+		ch === plusCharCode ||
+		ch === hyphenCharCode
+	) {
+		if (++i === specifier.length) return undefined;
+		ch = specifier.charCodeAt(i);
+	}
+
+	// Scheme must end with colon
+	if (ch !== colonCharCode) return undefined;
+
+	// Check for Windows absolute path
+	// https://url.spec.whatwg.org/#url-miscellaneous
+	if (i === 1) {
+		const nextChar = i + 1 < specifier.length ? specifier.charCodeAt(i + 1) : 0;
+		if (
+			nextChar === 0 ||
+			nextChar === backSlashCharCode ||
+			nextChar === slashCharCode ||
+			nextChar === hashCharCode ||
+			nextChar === queryCharCode
+		) {
+			return undefined;
+		}
 	}
+
+	return specifier.slice(0, i).toLowerCase();
 }
 
-module.exports = SharePlugin;
+/**
+ * @param {string} specifier specifier
+ * @returns {string|null} protocol if absolute URL specifier provided
+ */
+function getProtocol(specifier) {
+	const scheme = getScheme(specifier);
+	return scheme === undefined ? undefined : scheme + ":";
+}
+
+exports.getScheme = getScheme;
+exports.getProtocol = getProtocol;
 
 
 /***/ }),
 
-/***/ 96066:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 28745:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -123303,146 +123353,270 @@ module.exports = SharePlugin;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const {
-	compareModulesByIdentifier,
-	compareStrings
-} = __webpack_require__(29579);
+const isWeakKey = thing => typeof thing === "object" && thing !== null;
 
-class ShareRuntimeModule extends RuntimeModule {
+/**
+ * @template {any[]} T
+ * @template V
+ */
+class WeakTupleMap {
 	constructor() {
-		super("sharing");
+		/** @private */
+		this.f = 0;
+		/** @private @type {any} */
+		this.v = undefined;
+		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+		this.m = undefined;
+		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+		this.w = undefined;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @param {[...T, V]} args tuple
+	 * @returns {void}
 	 */
-	generate() {
-		const { compilation, chunkGraph } = this;
-		const {
-			runtimeTemplate,
-			codeGenerationResults,
-			outputOptions: { uniqueName }
-		} = compilation;
-		/** @type {Map<string, Map<number, Set<string>>>} */
-		const initCodePerScope = new Map();
-		for (const chunk of this.chunk.getAllReferencedChunks()) {
-			const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
-				chunk,
-				"share-init",
-				compareModulesByIdentifier
-			);
-			if (!modules) continue;
-			for (const m of modules) {
-				const data = codeGenerationResults.getData(
-					m,
-					chunk.runtime,
-					"share-init"
-				);
-				if (!data) continue;
-				for (const item of data) {
-					const { shareScope, initStage, init } = item;
-					let stages = initCodePerScope.get(shareScope);
-					if (stages === undefined) {
-						initCodePerScope.set(shareScope, (stages = new Map()));
-					}
-					let list = stages.get(initStage || 0);
-					if (list === undefined) {
-						stages.set(initStage || 0, (list = new Set()));
-					}
-					list.add(init);
-				}
+	set(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length - 1; i++) {
+			node = node._get(args[i]);
+		}
+		node._setValue(args[args.length - 1]);
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {boolean} true, if the tuple is in the Set
+	 */
+	has(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length; i++) {
+			node = node._peek(args[i]);
+			if (node === undefined) return false;
+		}
+		return node._hasValue();
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {V} the value
+	 */
+	get(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length; i++) {
+			node = node._peek(args[i]);
+			if (node === undefined) return undefined;
+		}
+		return node._getValue();
+	}
+
+	/**
+	 * @param {[...T, function(): V]} args tuple
+	 * @returns {V} the value
+	 */
+	provide(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length - 1; i++) {
+			node = node._get(args[i]);
+		}
+		if (node._hasValue()) return node._getValue();
+		const fn = args[args.length - 1];
+		const newValue = fn(...args.slice(0, -1));
+		node._setValue(newValue);
+		return newValue;
+	}
+
+	/**
+	 * @param {T} args tuple
+	 * @returns {void}
+	 */
+	delete(...args) {
+		/** @type {WeakTupleMap<T, V>} */
+		let node = this;
+		for (let i = 0; i < args.length; i++) {
+			node = node._peek(args[i]);
+			if (node === undefined) return;
+		}
+		node._deleteValue();
+	}
+
+	/**
+	 * @returns {void}
+	 */
+	clear() {
+		this.f = 0;
+		this.v = undefined;
+		this.w = undefined;
+		this.m = undefined;
+	}
+
+	_getValue() {
+		return this.v;
+	}
+
+	_hasValue() {
+		return (this.f & 1) === 1;
+	}
+
+	_setValue(v) {
+		this.f |= 1;
+		this.v = v;
+	}
+
+	_deleteValue() {
+		this.f &= 6;
+		this.v = undefined;
+	}
+
+	_peek(thing) {
+		if (isWeakKey(thing)) {
+			if ((this.f & 4) !== 4) return undefined;
+			return this.w.get(thing);
+		} else {
+			if ((this.f & 2) !== 2) return undefined;
+			return this.m.get(thing);
+		}
+	}
+
+	_get(thing) {
+		if (isWeakKey(thing)) {
+			if ((this.f & 4) !== 4) {
+				const newMap = new WeakMap();
+				this.f |= 4;
+				const newNode = new WeakTupleMap();
+				(this.w = newMap).set(thing, newNode);
+				return newNode;
+			}
+			const entry = this.w.get(thing);
+			if (entry !== undefined) {
+				return entry;
+			}
+			const newNode = new WeakTupleMap();
+			this.w.set(thing, newNode);
+			return newNode;
+		} else {
+			if ((this.f & 2) !== 2) {
+				const newMap = new Map();
+				this.f |= 2;
+				const newNode = new WeakTupleMap();
+				(this.m = newMap).set(thing, newNode);
+				return newNode;
+			}
+			const entry = this.m.get(thing);
+			if (entry !== undefined) {
+				return entry;
 			}
+			const newNode = new WeakTupleMap();
+			this.m.set(thing, newNode);
+			return newNode;
 		}
-		return Template.asString([
-			`${RuntimeGlobals.shareScopeMap} = {};`,
-			"var initPromises = {};",
-			"var initTokens = {};",
-			`${RuntimeGlobals.initializeSharing} = ${runtimeTemplate.basicFunction(
-				"name, initScope",
-				[
-					"if(!initScope) initScope = [];",
-					"// handling circular init calls",
-					"var initToken = initTokens[name];",
-					"if(!initToken) initToken = initTokens[name] = {};",
-					"if(initScope.indexOf(initToken) >= 0) return;",
-					"initScope.push(initToken);",
-					"// only runs once",
-					"if(initPromises[name]) return initPromises[name];",
-					"// creates a new share scope if needed",
-					`if(!${RuntimeGlobals.hasOwnProperty}(${RuntimeGlobals.shareScopeMap}, name)) ${RuntimeGlobals.shareScopeMap}[name] = {};`,
-					"// runs all init snippets from all modules reachable",
-					`var scope = ${RuntimeGlobals.shareScopeMap}[name];`,
-					`var warn = ${runtimeTemplate.returningFunction(
-						'typeof console !== "undefined" && console.warn && console.warn(msg)',
-						"msg"
-					)};`,
-					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
-					`var register = ${runtimeTemplate.basicFunction(
-						"name, version, factory, eager",
-						[
-							"var versions = scope[name] = scope[name] || {};",
-							"var activeVersion = versions[version];",
-							"if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };"
-						]
-					)};`,
-					`var initExternal = ${runtimeTemplate.basicFunction("id", [
-						`var handleError = ${runtimeTemplate.expressionFunction(
-							'warn("Initialization of sharing external failed: " + err)',
-							"err"
-						)};`,
-						"try {",
-						Template.indent([
-							"var module = __webpack_require__(id);",
-							"if(!module) return;",
-							`var initFn = ${runtimeTemplate.returningFunction(
-								`module && module.init && module.init(${RuntimeGlobals.shareScopeMap}[name], initScope)`,
-								"module"
-							)}`,
-							"if(module.then) return promises.push(module.then(initFn, handleError));",
-							"var initResult = initFn(module);",
-							"if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));"
-						]),
-						"} catch(err) { handleError(err); }"
-					])}`,
-					"var promises = [];",
-					"switch(name) {",
-					...Array.from(initCodePerScope)
-						.sort(([a], [b]) => compareStrings(a, b))
-						.map(([name, stages]) =>
-							Template.indent([
-								`case ${JSON.stringify(name)}: {`,
-								Template.indent(
-									Array.from(stages)
-										.sort(([a], [b]) => a - b)
-										.map(([, initCode]) =>
-											Template.asString(Array.from(initCode))
-										)
-								),
-								"}",
-								"break;"
-							])
-						),
-					"}",
-					"if(!promises.length) return initPromises[name] = 1;",
-					`return initPromises[name] = Promise.all(promises).then(${runtimeTemplate.returningFunction(
-						"initPromises[name] = 1"
-					)});`
-				]
-			)};`
-		]);
 	}
 }
 
-module.exports = ShareRuntimeModule;
+module.exports = WeakTupleMap;
+
+
+/***/ }),
+
+/***/ 92229:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Mikola Lysenko @mikolalysenko
+*/
+
+
+
+/* cspell:disable-next-line */
+// Refactor: Peter Somogyvari @petermetz
+
+const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
+	const code = [
+		"function ",
+		funcName,
+		"(a,l,h,",
+		extraArgs.join(","),
+		"){",
+		earlyOut ? "" : "var i=",
+		reversed ? "l-1" : "h+1",
+		";while(l<=h){var m=(l+h)>>>1,x=a[m]"
+	];
+
+	if (earlyOut) {
+		if (predicate.indexOf("c") < 0) {
+			code.push(";if(x===y){return m}else if(x<=y){");
+		} else {
+			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
+		}
+	} else {
+		code.push(";if(", predicate, "){i=m;");
+	}
+	if (reversed) {
+		code.push("l=m+1}else{h=m-1}");
+	} else {
+		code.push("h=m-1}else{l=m+1}");
+	}
+	code.push("}");
+	if (earlyOut) {
+		code.push("return -1};");
+	} else {
+		code.push("return i};");
+	}
+	return code.join("");
+};
+
+const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
+	const arg1 = compileSearch(
+		"A",
+		"x" + predicate + "y",
+		reversed,
+		["y"],
+		earlyOut
+	);
+
+	const arg2 = compileSearch(
+		"P",
+		"c(x,y)" + predicate + "0",
+		reversed,
+		["y", "c"],
+		earlyOut
+	);
+
+	const fnHeader = "function dispatchBinarySearch";
+
+	const fnBody =
+		"(a,y,c,l,h){\
+if(typeof(c)==='function'){\
+return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
+}else{\
+return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
+}}\
+return dispatchBinarySearch";
+
+	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
+	const fnSource = fnArgList.join("");
+	const result = new Function(fnSource);
+	return result();
+};
+
+module.exports = {
+	ge: compileBoundsSearch(">=", false, "GE"),
+	gt: compileBoundsSearch(">", false, "GT"),
+	lt: compileBoundsSearch("<", true, "LT"),
+	le: compileBoundsSearch("<=", true, "LE"),
+	eq: compileBoundsSearch("-", true, "EQ", true)
+};
 
 
 /***/ }),
 
-/***/ 3591:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 60839:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -123452,194 +123626,573 @@ module.exports = ShareRuntimeModule;
 
 
 
-const ModuleNotFoundError = __webpack_require__(32882);
-const LazySet = __webpack_require__(38938);
-
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
+/** @type {WeakMap<object, WeakMap<object, object>>} */
+const mergeCache = new WeakMap();
+/** @type {WeakMap<object, Map<string, Map<string|number|boolean, object>>>} */
+const setPropertyCache = new WeakMap();
+const DELETE = Symbol("DELETE");
+const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 
 /**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
  * @template T
- * @typedef {Object} MatchedConfigs
- * @property {Map<string, T>} resolved
- * @property {Map<string, T>} unresolved
- * @property {Map<string, T>} prefixed
+ * @template O
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {T} first first object
+ * @param {O} second second object
+ * @returns {T & O | T | O} merged object of first and second object
  */
+const cachedCleverMerge = (first, second) => {
+	if (second === undefined) return first;
+	if (first === undefined) return second;
+	if (typeof second !== "object" || second === null) return second;
+	if (typeof first !== "object" || first === null) return first;
 
-/** @type {ResolveOptionsWithDependencyType} */
-const RESOLVE_OPTIONS = { dependencyType: "esm" };
+	let innerCache = mergeCache.get(first);
+	if (innerCache === undefined) {
+		innerCache = new WeakMap();
+		mergeCache.set(first, innerCache);
+	}
+	const prevMerge = innerCache.get(second);
+	if (prevMerge !== undefined) return prevMerge;
+	const newMerge = _cleverMerge(first, second, true);
+	innerCache.set(second, newMerge);
+	return newMerge;
+};
 
 /**
  * @template T
- * @param {Compilation} compilation the compilation
- * @param {[string, T][]} configs to be processed configs
- * @returns {Promise<MatchedConfigs<T>>} resolved matchers
+ * @param {Partial<T>} obj object
+ * @param {string} property property
+ * @param {string|number|boolean} value assignment value
+ * @returns {T} new object
  */
-exports.resolveMatchedConfigs = (compilation, configs) => {
-	/** @type {Map<string, T>} */
-	const resolved = new Map();
-	/** @type {Map<string, T>} */
-	const unresolved = new Map();
-	/** @type {Map<string, T>} */
-	const prefixed = new Map();
-	const resolveContext = {
-		/** @type {LazySet<string>} */
-		fileDependencies: new LazySet(),
-		/** @type {LazySet<string>} */
-		contextDependencies: new LazySet(),
-		/** @type {LazySet<string>} */
-		missingDependencies: new LazySet()
+const cachedSetProperty = (obj, property, value) => {
+	let mapByProperty = setPropertyCache.get(obj);
+
+	if (mapByProperty === undefined) {
+		mapByProperty = new Map();
+		setPropertyCache.set(obj, mapByProperty);
+	}
+
+	let mapByValue = mapByProperty.get(property);
+
+	if (mapByValue === undefined) {
+		mapByValue = new Map();
+		mapByProperty.set(property, mapByValue);
+	}
+
+	let result = mapByValue.get(value);
+
+	if (result) return result;
+
+	result = {
+		...obj,
+		[property]: value
 	};
-	const resolver = compilation.resolverFactory.get("normal", RESOLVE_OPTIONS);
-	const context = compilation.compiler.context;
+	mapByValue.set(value, result);
 
-	return Promise.all(
-		configs.map(([request, config]) => {
-			if (/^\.\.?(\/|$)/.test(request)) {
-				// relative request
-				return new Promise(resolve => {
-					resolver.resolve(
-						{},
-						context,
-						request,
-						resolveContext,
-						(err, result) => {
-							if (err || result === false) {
-								err = err || new Error(`Can't resolve ${request}`);
-								compilation.errors.push(
-									new ModuleNotFoundError(null, err, {
-										name: `shared module ${request}`
-									})
-								);
-								return resolve();
+	return result;
+};
+
+/**
+ * @typedef {Object} ObjectParsedPropertyEntry
+ * @property {any | undefined} base base value
+ * @property {string | undefined} byProperty the name of the selector property
+ * @property {Map<string, any>} byValues value depending on selector property, merged with base
+ */
+
+/**
+ * @typedef {Object} ParsedObject
+ * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
+ * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
+ */
+
+/** @type {WeakMap<object, ParsedObject>} */
+const parseCache = new WeakMap();
+
+/**
+ * @param {object} obj the object
+ * @returns {ParsedObject} parsed object
+ */
+const cachedParseObject = obj => {
+	const entry = parseCache.get(obj);
+	if (entry !== undefined) return entry;
+	const result = parseObject(obj);
+	parseCache.set(obj, result);
+	return result;
+};
+
+/**
+ * @param {object} obj the object
+ * @returns {ParsedObject} parsed object
+ */
+const parseObject = obj => {
+	const info = new Map();
+	let dynamicInfo;
+	const getInfo = p => {
+		const entry = info.get(p);
+		if (entry !== undefined) return entry;
+		const newEntry = {
+			base: undefined,
+			byProperty: undefined,
+			byValues: undefined
+		};
+		info.set(p, newEntry);
+		return newEntry;
+	};
+	for (const key of Object.keys(obj)) {
+		if (key.startsWith("by")) {
+			const byProperty = key;
+			const byObj = obj[byProperty];
+			if (typeof byObj === "object") {
+				for (const byValue of Object.keys(byObj)) {
+					const obj = byObj[byValue];
+					for (const key of Object.keys(obj)) {
+						const entry = getInfo(key);
+						if (entry.byProperty === undefined) {
+							entry.byProperty = byProperty;
+							entry.byValues = new Map();
+						} else if (entry.byProperty !== byProperty) {
+							throw new Error(
+								`${byProperty} and ${entry.byProperty} for a single property is not supported`
+							);
+						}
+						entry.byValues.set(byValue, obj[key]);
+						if (byValue === "default") {
+							for (const otherByValue of Object.keys(byObj)) {
+								if (!entry.byValues.has(otherByValue))
+									entry.byValues.set(otherByValue, undefined);
 							}
-							resolved.set(result, config);
-							resolve();
 						}
+					}
+				}
+			} else if (typeof byObj === "function") {
+				if (dynamicInfo === undefined) {
+					dynamicInfo = {
+						byProperty: key,
+						fn: byObj
+					};
+				} else {
+					throw new Error(
+						`${key} and ${dynamicInfo.byProperty} when both are functions is not supported`
 					);
-				});
-			} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
-				// absolute path
-				resolved.set(request, config);
-			} else if (request.endsWith("/")) {
-				// module request prefix
-				prefixed.set(request, config);
+				}
 			} else {
-				// module request
-				unresolved.set(request, config);
+				const entry = getInfo(key);
+				entry.base = obj[key];
 			}
-		})
-	).then(() => {
-		compilation.contextDependencies.addAll(resolveContext.contextDependencies);
-		compilation.fileDependencies.addAll(resolveContext.fileDependencies);
-		compilation.missingDependencies.addAll(resolveContext.missingDependencies);
-		return { resolved, unresolved, prefixed };
-	});
+		} else {
+			const entry = getInfo(key);
+			entry.base = obj[key];
+		}
+	}
+	return {
+		static: info,
+		dynamic: dynamicInfo
+	};
+};
+
+/**
+ * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
+ * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
+ * @returns {object} the object
+ */
+const serializeObject = (info, dynamicInfo) => {
+	const obj = {};
+	// Setup byProperty structure
+	for (const entry of info.values()) {
+		if (entry.byProperty !== undefined) {
+			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+			for (const byValue of entry.byValues.keys()) {
+				byObj[byValue] = byObj[byValue] || {};
+			}
+		}
+	}
+	for (const [key, entry] of info) {
+		if (entry.base !== undefined) {
+			obj[key] = entry.base;
+		}
+		// Fill byProperty structure
+		if (entry.byProperty !== undefined) {
+			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
+			for (const byValue of Object.keys(byObj)) {
+				const value = getFromByValues(entry.byValues, byValue);
+				if (value !== undefined) byObj[byValue][key] = value;
+			}
+		}
+	}
+	if (dynamicInfo !== undefined) {
+		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
+	}
+	return obj;
 };
 
+const VALUE_TYPE_UNDEFINED = 0;
+const VALUE_TYPE_ATOM = 1;
+const VALUE_TYPE_ARRAY_EXTEND = 2;
+const VALUE_TYPE_OBJECT = 3;
+const VALUE_TYPE_DELETE = 4;
 
-/***/ }),
+/**
+ * @param {any} value a single value
+ * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
+ */
+const getValueType = value => {
+	if (value === undefined) {
+		return VALUE_TYPE_UNDEFINED;
+	} else if (value === DELETE) {
+		return VALUE_TYPE_DELETE;
+	} else if (Array.isArray(value)) {
+		if (value.lastIndexOf("...") !== -1) return VALUE_TYPE_ARRAY_EXTEND;
+		return VALUE_TYPE_ATOM;
+	} else if (
+		typeof value === "object" &&
+		value !== null &&
+		(!value.constructor || value.constructor === Object)
+	) {
+		return VALUE_TYPE_OBJECT;
+	}
+	return VALUE_TYPE_ATOM;
+};
 
-/***/ 84379:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * Arrays might reference the old value with "...".
+ * Non-object values take preference over object values.
+ * @template T
+ * @template O
+ * @param {T} first first object
+ * @param {O} second second object
+ * @returns {T & O | T | O} merged object of first and second object
+ */
+const cleverMerge = (first, second) => {
+	if (second === undefined) return first;
+	if (first === undefined) return second;
+	if (typeof second !== "object" || second === null) return second;
+	if (typeof first !== "object" || first === null) return first;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	return _cleverMerge(first, second, false);
+};
 
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * @param {object} first first object
+ * @param {object} second second object
+ * @param {boolean} internalCaching should parsing of objects and nested merges be cached
+ * @returns {object} merged object of first and second object
+ */
+const _cleverMerge = (first, second, internalCaching = false) => {
+	const firstObject = internalCaching
+		? cachedParseObject(first)
+		: parseObject(first);
+	const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
 
+	// If the first argument has a dynamic part we modify the dynamic part to merge the second argument
+	if (firstDynamicInfo !== undefined) {
+		let { byProperty, fn } = firstDynamicInfo;
+		const fnInfo = fn[DYNAMIC_INFO];
+		if (fnInfo) {
+			second = internalCaching
+				? cachedCleverMerge(fnInfo[1], second)
+				: cleverMerge(fnInfo[1], second);
+			fn = fnInfo[0];
+		}
+		const newFn = (...args) => {
+			const fnResult = fn(...args);
+			return internalCaching
+				? cachedCleverMerge(fnResult, second)
+				: cleverMerge(fnResult, second);
+		};
+		newFn[DYNAMIC_INFO] = [fn, second];
+		return serializeObject(firstObject.static, { byProperty, fn: newFn });
+	}
 
-const { join, dirname, readJson } = __webpack_require__(17139);
+	// If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
+	const secondObject = internalCaching
+		? cachedParseObject(second)
+		: parseObject(second);
+	const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
+	/** @type {Map<string, ObjectParsedPropertyEntry>} */
+	const resultInfo = new Map();
+	for (const [key, firstEntry] of firstInfo) {
+		const secondEntry = secondInfo.get(key);
+		const entry =
+			secondEntry !== undefined
+				? mergeEntries(firstEntry, secondEntry, internalCaching)
+				: firstEntry;
+		resultInfo.set(key, entry);
+	}
+	for (const [key, secondEntry] of secondInfo) {
+		if (!firstInfo.has(key)) {
+			resultInfo.set(key, secondEntry);
+		}
+	}
+	return serializeObject(resultInfo, secondDynamicInfo);
+};
 
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/**
+ * @param {ObjectParsedPropertyEntry} firstEntry a
+ * @param {ObjectParsedPropertyEntry} secondEntry b
+ * @param {boolean} internalCaching should parsing of objects and nested merges be cached
+ * @returns {ObjectParsedPropertyEntry} new entry
+ */
+const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
+	switch (getValueType(secondEntry.base)) {
+		case VALUE_TYPE_ATOM:
+		case VALUE_TYPE_DELETE:
+			// No need to consider firstEntry at all
+			// second value override everything
+			// = second.base + second.byProperty
+			return secondEntry;
+		case VALUE_TYPE_UNDEFINED:
+			if (!firstEntry.byProperty) {
+				// = first.base + second.byProperty
+				return {
+					base: firstEntry.base,
+					byProperty: secondEntry.byProperty,
+					byValues: secondEntry.byValues
+				};
+			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
+				throw new Error(
+					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
+				);
+			} else {
+				// = first.base + (first.byProperty + second.byProperty)
+				// need to merge first and second byValues
+				const newByValues = new Map(firstEntry.byValues);
+				for (const [key, value] of secondEntry.byValues) {
+					const firstValue = getFromByValues(firstEntry.byValues, key);
+					newByValues.set(
+						key,
+						mergeSingleValue(firstValue, value, internalCaching)
+					);
+				}
+				return {
+					base: firstEntry.base,
+					byProperty: firstEntry.byProperty,
+					byValues: newByValues
+				};
+			}
+		default: {
+			if (!firstEntry.byProperty) {
+				// The simple case
+				// = (first.base + second.base) + second.byProperty
+				return {
+					base: mergeSingleValue(
+						firstEntry.base,
+						secondEntry.base,
+						internalCaching
+					),
+					byProperty: secondEntry.byProperty,
+					byValues: secondEntry.byValues
+				};
+			}
+			let newBase;
+			const intermediateByValues = new Map(firstEntry.byValues);
+			for (const [key, value] of intermediateByValues) {
+				intermediateByValues.set(
+					key,
+					mergeSingleValue(value, secondEntry.base, internalCaching)
+				);
+			}
+			if (
+				Array.from(firstEntry.byValues.values()).every(value => {
+					const type = getValueType(value);
+					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+				})
+			) {
+				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
+				newBase = mergeSingleValue(
+					firstEntry.base,
+					secondEntry.base,
+					internalCaching
+				);
+			} else {
+				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
+				newBase = firstEntry.base;
+				if (!intermediateByValues.has("default"))
+					intermediateByValues.set("default", secondEntry.base);
+			}
+			if (!secondEntry.byProperty) {
+				// = first.base + (first.byProperty + second.base)
+				return {
+					base: newBase,
+					byProperty: firstEntry.byProperty,
+					byValues: intermediateByValues
+				};
+			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
+				throw new Error(
+					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
+				);
+			}
+			const newByValues = new Map(intermediateByValues);
+			for (const [key, value] of secondEntry.byValues) {
+				const firstValue = getFromByValues(intermediateByValues, key);
+				newByValues.set(
+					key,
+					mergeSingleValue(firstValue, value, internalCaching)
+				);
+			}
+			return {
+				base: newBase,
+				byProperty: firstEntry.byProperty,
+				byValues: newByValues
+			};
+		}
+	}
+};
 
 /**
- * @param {string} str maybe required version
- * @returns {boolean} true, if it looks like a version
+ * @param {Map<string, any>} byValues all values
+ * @param {string} key value of the selector
+ * @returns {any | undefined} value
  */
-exports.isRequiredVersion = str => {
-	return /^([\d^=v<>~]|[*xX]$)/.test(str);
+const getFromByValues = (byValues, key) => {
+	if (key !== "default" && byValues.has(key)) {
+		return byValues.get(key);
+	}
+	return byValues.get("default");
 };
 
 /**
- *
- * @param {InputFileSystem} fs file system
- * @param {string} directory directory to start looking into
- * @param {string[]} descriptionFiles possible description filenames
- * @param {function((Error | null)=, {data: object, path: string}=): void} callback callback
+ * @param {any} a value
+ * @param {any} b value
+ * @param {boolean} internalCaching should parsing of objects and nested merges be cached
+ * @returns {any} value
  */
-const getDescriptionFile = (fs, directory, descriptionFiles, callback) => {
-	let i = 0;
-	const tryLoadCurrent = () => {
-		if (i >= descriptionFiles.length) {
-			const parentDirectory = dirname(fs, directory);
-			if (!parentDirectory || parentDirectory === directory) return callback();
-			return getDescriptionFile(
-				fs,
-				parentDirectory,
-				descriptionFiles,
-				callback
-			);
+const mergeSingleValue = (a, b, internalCaching) => {
+	const bType = getValueType(b);
+	const aType = getValueType(a);
+	switch (bType) {
+		case VALUE_TYPE_DELETE:
+		case VALUE_TYPE_ATOM:
+			return b;
+		case VALUE_TYPE_OBJECT: {
+			return aType !== VALUE_TYPE_OBJECT
+				? b
+				: internalCaching
+				? cachedCleverMerge(a, b)
+				: cleverMerge(a, b);
 		}
-		const filePath = join(fs, directory, descriptionFiles[i]);
-		readJson(fs, filePath, (err, data) => {
-			if (err) {
-				if ("code" in err && err.code === "ENOENT") {
-					i++;
-					return tryLoadCurrent();
+		case VALUE_TYPE_UNDEFINED:
+			return a;
+		case VALUE_TYPE_ARRAY_EXTEND:
+			switch (
+				aType !== VALUE_TYPE_ATOM
+					? aType
+					: Array.isArray(a)
+					? VALUE_TYPE_ARRAY_EXTEND
+					: VALUE_TYPE_OBJECT
+			) {
+				case VALUE_TYPE_UNDEFINED:
+					return b;
+				case VALUE_TYPE_DELETE:
+					return b.filter(item => item !== "...");
+				case VALUE_TYPE_ARRAY_EXTEND: {
+					const newArray = [];
+					for (const item of b) {
+						if (item === "...") {
+							for (const item of a) {
+								newArray.push(item);
+							}
+						} else {
+							newArray.push(item);
+						}
+					}
+					return newArray;
 				}
-				return callback(err);
-			}
-			if (!data || typeof data !== "object" || Array.isArray(data)) {
-				return callback(
-					new Error(`Description file ${filePath} is not an object`)
-				);
+				case VALUE_TYPE_OBJECT:
+					return b.map(item => (item === "..." ? a : item));
+				default:
+					throw new Error("Not implemented");
 			}
-			callback(null, { data, path: filePath });
-		});
-	};
-	tryLoadCurrent();
+		default:
+			throw new Error("Not implemented");
+	}
 };
-exports.getDescriptionFile = getDescriptionFile;
 
-exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
-	if (
-		data.optionalDependencies &&
-		typeof data.optionalDependencies === "object" &&
-		packageName in data.optionalDependencies
-	) {
-		return data.optionalDependencies[packageName];
-	}
-	if (
-		data.dependencies &&
-		typeof data.dependencies === "object" &&
-		packageName in data.dependencies
-	) {
-		return data.dependencies[packageName];
+/**
+ * @template T
+ * @param {T} obj the object
+ * @returns {T} the object without operations like "..." or DELETE
+ */
+const removeOperations = obj => {
+	const newObj = /** @type {T} */ ({});
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		const type = getValueType(value);
+		switch (type) {
+			case VALUE_TYPE_UNDEFINED:
+			case VALUE_TYPE_DELETE:
+				break;
+			case VALUE_TYPE_OBJECT:
+				newObj[key] = removeOperations(value);
+				break;
+			case VALUE_TYPE_ARRAY_EXTEND:
+				newObj[key] = value.filter(i => i !== "...");
+				break;
+			default:
+				newObj[key] = value;
+				break;
+		}
 	}
-	if (
-		data.peerDependencies &&
-		typeof data.peerDependencies === "object" &&
-		packageName in data.peerDependencies
-	) {
-		return data.peerDependencies[packageName];
+	return newObj;
+};
+
+/**
+ * @template T
+ * @template {string} P
+ * @param {T} obj the object
+ * @param {P} byProperty the by description
+ * @param  {...any} values values
+ * @returns {Omit<T, P>} object with merged byProperty
+ */
+const resolveByProperty = (obj, byProperty, ...values) => {
+	if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
+		return obj;
 	}
-	if (
-		data.devDependencies &&
-		typeof data.devDependencies === "object" &&
-		packageName in data.devDependencies
-	) {
-		return data.devDependencies[packageName];
+	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
+	const remaining = /** @type {T} */ (_remaining);
+	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
+		_byValue
+	);
+	if (typeof byValue === "object") {
+		const key = values[0];
+		if (key in byValue) {
+			return cachedCleverMerge(remaining, byValue[key]);
+		} else if ("default" in byValue) {
+			return cachedCleverMerge(remaining, byValue.default);
+		} else {
+			return /** @type {T} */ (remaining);
+		}
+	} else if (typeof byValue === "function") {
+		const result = byValue.apply(null, values);
+		return cachedCleverMerge(
+			remaining,
+			resolveByProperty(result, byProperty, ...values)
+		);
 	}
 };
 
+exports.cachedSetProperty = cachedSetProperty;
+exports.cachedCleverMerge = cachedCleverMerge;
+exports.cleverMerge = cleverMerge;
+exports.resolveByProperty = resolveByProperty;
+exports.removeOperations = removeOperations;
+exports.DELETE = DELETE;
+
 
 /***/ }),
 
-/***/ 71760:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 29579:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -123649,2403 +124202,1944 @@ exports.getRequiredVersionFromDescriptionFile = (data, packageName) => {
 
 
 
-const util = __webpack_require__(73837);
-const ModuleDependency = __webpack_require__(80321);
-const formatLocation = __webpack_require__(16734);
-const { LogType } = __webpack_require__(32597);
-const AggressiveSplittingPlugin = __webpack_require__(15543);
-const SizeLimitsPlugin = __webpack_require__(32557);
-const { countIterable } = __webpack_require__(39104);
-const {
-	compareLocations,
-	compareChunksById,
-	compareNumbers,
-	compareIds,
-	concatComparators,
-	compareSelect,
-	compareModulesByIdentifier
-} = __webpack_require__(29579);
-const { makePathsRelative, parseResource } = __webpack_require__(82186);
+const { compareRuntime } = __webpack_require__(17156);
 
-/** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../ChunkGroup").OriginRecord} OriginRecord */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").Asset} Asset */
-/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ModuleProfile")} ModuleProfile */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @template T @typedef {import("../util/comparators").Comparator<T>} Comparator<T> */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
-/** @typedef {import("./StatsFactory")} StatsFactory */
-/** @typedef {import("./StatsFactory").StatsFactoryContext} StatsFactoryContext */
-
-/** @typedef {KnownStatsCompilation & Record<string, any>} StatsCompilation */
-/**
- * @typedef {Object} KnownStatsCompilation
- * @property {any=} env
- * @property {string=} name
- * @property {string=} hash
- * @property {string=} version
- * @property {number=} time
- * @property {number=} builtAt
- * @property {boolean=} needAdditionalPass
- * @property {string=} publicPath
- * @property {string=} outputPath
- * @property {Record<string, string[]>=} assetsByChunkName
- * @property {StatsAsset[]=} assets
- * @property {number=} filteredAssets
- * @property {StatsChunk[]=} chunks
- * @property {StatsModule[]=} modules
- * @property {number=} filteredModules
- * @property {Record<string, StatsChunkGroup>=} entrypoints
- * @property {Record<string, StatsChunkGroup>=} namedChunkGroups
- * @property {StatsError[]=} errors
- * @property {number=} errorsCount
- * @property {StatsError[]=} warnings
- * @property {number=} warningsCount
- * @property {StatsCompilation[]=} children
- * @property {Record<string, StatsLogging>=} logging
- */
-
-/** @typedef {KnownStatsLogging & Record<string, any>} StatsLogging */
-/**
- * @typedef {Object} KnownStatsLogging
- * @property {StatsLoggingEntry[]} entries
- * @property {number} filteredEntries
- * @property {boolean} debug
- */
-
-/** @typedef {KnownStatsLoggingEntry & Record<string, any>} StatsLoggingEntry */
-/**
- * @typedef {Object} KnownStatsLoggingEntry
- * @property {string} type
- * @property {string} message
- * @property {string[]=} trace
- * @property {StatsLoggingEntry[]=} children
- * @property {any[]=} args
- * @property {number=} time
- */
-
-/** @typedef {KnownStatsAsset & Record<string, any>} StatsAsset */
-/**
- * @typedef {Object} KnownStatsAsset
- * @property {string} type
- * @property {string} name
- * @property {AssetInfo} info
- * @property {number} size
- * @property {boolean} emitted
- * @property {boolean} comparedForEmit
- * @property {boolean} cached
- * @property {StatsAsset[]=} related
- * @property {(string|number)[]=} chunkNames
- * @property {(string|number)[]=} chunkIdHints
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} auxiliaryChunkNames
- * @property {(string|number)[]=} auxiliaryChunks
- * @property {(string|number)[]=} auxiliaryChunkIdHints
- * @property {number=} filteredRelated
- * @property {boolean=} isOverSizeLimit
- */
-
-/** @typedef {KnownStatsChunkGroup & Record<string, any>} StatsChunkGroup */
-/**
- * @typedef {Object} KnownStatsChunkGroup
- * @property {string=} name
- * @property {(string|number)[]=} chunks
- * @property {({ name: string, size?: number })[]=} assets
- * @property {number=} filteredAssets
- * @property {number=} assetsSize
- * @property {({ name: string, size?: number })[]=} auxiliaryAssets
- * @property {number=} filteredAuxiliaryAssets
- * @property {number=} auxiliaryAssetsSize
- * @property {{ [x: string]: StatsChunkGroup[] }=} children
- * @property {{ [x: string]: string[] }=} childAssets
- * @property {boolean=} isOverSizeLimit
- */
-
-/** @typedef {KnownStatsModule & Record<string, any>} StatsModule */
-/**
- * @typedef {Object} KnownStatsModule
- * @property {string=} type
- * @property {string=} moduleType
- * @property {string=} layer
- * @property {string=} identifier
- * @property {string=} name
- * @property {string=} nameForCondition
- * @property {number=} index
- * @property {number=} preOrderIndex
- * @property {number=} index2
- * @property {number=} postOrderIndex
- * @property {number=} size
- * @property {{[x: string]: number}=} sizes
- * @property {boolean=} cacheable
- * @property {boolean=} built
- * @property {boolean=} codeGenerated
- * @property {boolean=} buildTimeExecuted
- * @property {boolean=} cached
- * @property {boolean=} optional
- * @property {boolean=} orphan
- * @property {string|number=} id
- * @property {string|number=} issuerId
- * @property {(string|number)[]=} chunks
- * @property {(string|number)[]=} assets
- * @property {boolean=} dependent
- * @property {string=} issuer
- * @property {string=} issuerName
- * @property {StatsModuleIssuer[]=} issuerPath
- * @property {boolean=} failed
- * @property {number=} errors
- * @property {number=} warnings
- * @property {StatsProfile=} profile
- * @property {StatsModuleReason[]=} reasons
- * @property {(boolean | string[])=} usedExports
- * @property {string[]=} providedExports
- * @property {string[]=} optimizationBailout
- * @property {number=} depth
- * @property {StatsModule[]=} modules
- * @property {number=} filteredModules
- * @property {ReturnType<Source["source"]>=} source
- */
-
-/** @typedef {KnownStatsProfile & Record<string, any>} StatsProfile */
-/**
- * @typedef {Object} KnownStatsProfile
- * @property {number} total
- * @property {number} resolving
- * @property {number} restoring
- * @property {number} building
- * @property {number} integration
- * @property {number} storing
- * @property {number} additionalResolving
- * @property {number} additionalIntegration
- * @property {number} factory
- * @property {number} dependencies
- */
-
-/** @typedef {KnownStatsModuleIssuer & Record<string, any>} StatsModuleIssuer */
-/**
- * @typedef {Object} KnownStatsModuleIssuer
- * @property {string=} identifier
- * @property {string=} name
- * @property {(string|number)=} id
- * @property {StatsProfile=} profile
- */
-
-/** @typedef {KnownStatsModuleReason & Record<string, any>} StatsModuleReason */
-/**
- * @typedef {Object} KnownStatsModuleReason
- * @property {string=} moduleIdentifier
- * @property {string=} module
- * @property {string=} moduleName
- * @property {string=} resolvedModuleIdentifier
- * @property {string=} resolvedModule
- * @property {string=} type
- * @property {boolean} active
- * @property {string=} explanation
- * @property {string=} userRequest
- * @property {string=} loc
- * @property {(string|number)=} moduleId
- * @property {(string|number)=} resolvedModuleId
- */
-
-/** @typedef {KnownStatsChunk & Record<string, any>} StatsChunk */
-/**
- * @typedef {Object} KnownStatsChunk
- * @property {boolean} rendered
- * @property {boolean} initial
- * @property {boolean} entry
- * @property {boolean} recorded
- * @property {string=} reason
- * @property {number} size
- * @property {Record<string, number>=} sizes
- * @property {string[]=} names
- * @property {string[]=} idHints
- * @property {string[]=} runtime
- * @property {string[]=} files
- * @property {string[]=} auxiliaryFiles
- * @property {string} hash
- * @property {Record<string, (string|number)[]>=} childrenByOrder
- * @property {(string|number)=} id
- * @property {(string|number)[]=} siblings
- * @property {(string|number)[]=} parents
- * @property {(string|number)[]=} children
- * @property {StatsModule[]=} modules
- * @property {number=} filteredModules
- * @property {StatsChunkOrigin[]=} origins
- */
-
-/** @typedef {KnownStatsChunkOrigin & Record<string, any>} StatsChunkOrigin */
-/**
- * @typedef {Object} KnownStatsChunkOrigin
- * @property {string=} module
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {string=} loc
- * @property {string=} request
- * @property {(string|number)=} moduleId
- */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-/** @typedef {KnownStatsModuleTraceItem & Record<string, any>} StatsModuleTraceItem */
-/**
- * @typedef {Object} KnownStatsModuleTraceItem
- * @property {string=} originIdentifier
- * @property {string=} originName
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {StatsModuleTraceDependency[]=} dependencies
- * @property {(string|number)=} originId
- * @property {(string|number)=} moduleId
- */
+/** @template T @typedef {function(T, T): -1|0|1} Comparator */
+/** @template TArg @template T @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator */
+/** @template TArg @template T @typedef {function(TArg): Comparator<T>} ParameterizedComparator */
 
-/** @typedef {KnownStatsModuleTraceDependency & Record<string, any>} StatsModuleTraceDependency */
 /**
- * @typedef {Object} KnownStatsModuleTraceDependency
- * @property {string=} loc
+ * @template T
+ * @param {RawParameterizedComparator<any, T>} fn comparator with argument
+ * @returns {ParameterizedComparator<any, T>} comparator
  */
+const createCachedParameterizedComparator = fn => {
+	/** @type {WeakMap<object, Comparator<T>>} */
+	const map = new WeakMap();
+	return arg => {
+		const cachedResult = map.get(arg);
+		if (cachedResult !== undefined) return cachedResult;
+		/**
+		 * @param {T} a first item
+		 * @param {T} b second item
+		 * @returns {-1|0|1} compare result
+		 */
+		const result = fn.bind(null, arg);
+		map.set(arg, result);
+		return result;
+	};
+};
 
-/** @typedef {KnownStatsError & Record<string, any>} StatsError */
 /**
- * @typedef {Object} KnownStatsError
- * @property {string} message
- * @property {string=} chunkName
- * @property {boolean=} chunkEntry
- * @property {boolean=} chunkInitial
- * @property {string=} file
- * @property {string=} moduleIdentifier
- * @property {string=} moduleName
- * @property {string=} loc
- * @property {string|number=} chunkId
- * @property {string|number=} moduleId
- * @property {StatsModuleTraceItem[]=} moduleTrace
- * @property {any=} details
- * @property {string=} stack
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {-1|0|1} compare result
  */
-
-/** @typedef {Asset & { type: string, related: PreprocessedAsset[] }} PreprocessedAsset */
+exports.compareChunksById = (a, b) => {
+	return compareIds(a.id, b.id);
+};
 
 /**
- * @template T
- * @template O
- * @typedef {Record<string, (object: O, data: T, context: StatsFactoryContext, options: NormalizedStatsOptions, factory: StatsFactory) => void>} ExtractorsByOption
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
  */
+exports.compareModulesByIdentifier = (a, b) => {
+	return compareIds(a.identifier(), b.identifier());
+};
 
 /**
- * @typedef {Object} SimpleExtractors
- * @property {ExtractorsByOption<Compilation, StatsCompilation>} compilation
- * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset
- * @property {ExtractorsByOption<PreprocessedAsset, StatsAsset>} asset$visible
- * @property {ExtractorsByOption<{ name: string, chunkGroup: ChunkGroup }, StatsChunkGroup>} chunkGroup
- * @property {ExtractorsByOption<Module, StatsModule>} module
- * @property {ExtractorsByOption<Module, StatsModule>} module$visible
- * @property {ExtractorsByOption<Module, StatsModuleIssuer>} moduleIssuer
- * @property {ExtractorsByOption<ModuleProfile, StatsProfile>} profile
- * @property {ExtractorsByOption<ModuleGraphConnection, StatsModuleReason>} moduleReason
- * @property {ExtractorsByOption<Chunk, StatsChunk>} chunk
- * @property {ExtractorsByOption<OriginRecord, StatsChunkOrigin>} chunkOrigin
- * @property {ExtractorsByOption<WebpackError, StatsError>} error
- * @property {ExtractorsByOption<WebpackError, StatsError>} warning
- * @property {ExtractorsByOption<{ origin: Module, module: Module }, StatsModuleTraceItem>} moduleTraceItem
- * @property {ExtractorsByOption<Dependency, StatsModuleTraceDependency>} moduleTraceDependency
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
  */
+const compareModulesById = (chunkGraph, a, b) => {
+	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+};
+/** @type {ParameterizedComparator<ChunkGraph, Module>} */
+exports.compareModulesById =
+	createCachedParameterizedComparator(compareModulesById);
 
 /**
- * @template T
- * @template I
- * @param {Iterable<T>} items items to select from
- * @param {function(T): Iterable<I>} selector selector function to select values from item
- * @returns {I[]} array of values
+ * @param {number} a number
+ * @param {number} b number
+ * @returns {-1|0|1} compare result
  */
-const uniqueArray = (items, selector) => {
-	/** @type {Set<I>} */
-	const set = new Set();
-	for (const item of items) {
-		for (const i of selector(item)) {
-			set.add(i);
+const compareNumbers = (a, b) => {
+	if (typeof a !== typeof b) {
+		return typeof a < typeof b ? -1 : 1;
+	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
+exports.compareNumbers = compareNumbers;
+
+/**
+ * @param {string} a string
+ * @param {string} b string
+ * @returns {-1|0|1} compare result
+ */
+const compareStringsNumeric = (a, b) => {
+	const partsA = a.split(/(\d+)/);
+	const partsB = b.split(/(\d+)/);
+	const len = Math.min(partsA.length, partsB.length);
+	for (let i = 0; i < len; i++) {
+		const pA = partsA[i];
+		const pB = partsB[i];
+		if (i % 2 === 0) {
+			if (pA.length > pB.length) {
+				if (pA.slice(0, pB.length) > pB) return 1;
+				return -1;
+			} else if (pB.length > pA.length) {
+				if (pB.slice(0, pA.length) > pA) return -1;
+				return 1;
+			} else {
+				if (pA < pB) return -1;
+				if (pA > pB) return 1;
+			}
+		} else {
+			const nA = +pA;
+			const nB = +pB;
+			if (nA < nB) return -1;
+			if (nA > nB) return 1;
 		}
 	}
-	return Array.from(set);
+	if (partsB.length < partsA.length) return 1;
+	if (partsB.length > partsA.length) return -1;
+	return 0;
 };
+exports.compareStringsNumeric = compareStringsNumeric;
 
 /**
- * @template T
- * @template I
- * @param {Iterable<T>} items items to select from
- * @param {function(T): Iterable<I>} selector selector function to select values from item
- * @param {Comparator<I>} comparator comparator function
- * @returns {I[]} array of values
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
  */
-const uniqueOrderedArray = (items, selector, comparator) => {
-	return uniqueArray(items, selector).sort(comparator);
+const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
+	const cmp = compareNumbers(
+		moduleGraph.getPostOrderIndex(a),
+		moduleGraph.getPostOrderIndex(b)
+	);
+	if (cmp !== 0) return cmp;
+	return compareIds(a.identifier(), b.identifier());
 };
+/** @type {ParameterizedComparator<ModuleGraph, Module>} */
+exports.compareModulesByPostOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPostOrderIndexOrIdentifier
+	);
 
-/** @template T @template R @typedef {{ [P in keyof T]: R }} MappedValues<T, R> */
+/**
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
+ */
+const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
+	const cmp = compareNumbers(
+		moduleGraph.getPreOrderIndex(a),
+		moduleGraph.getPreOrderIndex(b)
+	);
+	if (cmp !== 0) return cmp;
+	return compareIds(a.identifier(), b.identifier());
+};
+/** @type {ParameterizedComparator<ModuleGraph, Module>} */
+exports.compareModulesByPreOrderIndexOrIdentifier =
+	createCachedParameterizedComparator(
+		compareModulesByPreOrderIndexOrIdentifier
+	);
 
 /**
- * @template T
- * @template R
- * @param {T} obj object to be mapped
- * @param {function(T[keyof T], keyof T): R} fn mapping function
- * @returns {MappedValues<T, R>} mapped object
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1|0|1} compare result
  */
-const mapObject = (obj, fn) => {
-	const newObj = Object.create(null);
-	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(obj[key], /** @type {keyof T} */ (key));
-	}
-	return newObj;
+const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
+	const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+	if (cmp !== 0) return cmp;
+	return compareIds(a.identifier(), b.identifier());
 };
+/** @type {ParameterizedComparator<ChunkGraph, Module>} */
+exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
+	compareModulesByIdOrIdentifier
+);
 
 /**
- * @param {Compilation} compilation the compilation
- * @param {function(Compilation, string): any[]} getItems get items
- * @returns {number} total number
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Chunk} a chunk
+ * @param {Chunk} b chunk
+ * @returns {-1|0|1} compare result
  */
-const countWithChildren = (compilation, getItems) => {
-	let count = getItems(compilation, "").length;
-	for (const child of compilation.children) {
-		count += countWithChildren(child, (c, type) =>
-			getItems(c, `.children[].compilation${type}`)
-		);
-	}
-	return count;
+const compareChunks = (chunkGraph, a, b) => {
+	return chunkGraph.compareChunks(a, b);
 };
+/** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
+exports.compareChunks = createCachedParameterizedComparator(compareChunks);
 
-/** @type {ExtractorsByOption<WebpackError | string, StatsError>} */
-const EXTRACT_ERROR = {
-	_: (object, error, context, { requestShortener }) => {
-		// TODO webpack 6 disallow strings in the errors/warnings list
-		if (typeof error === "string") {
-			object.message = error;
-		} else {
-			if (error.chunk) {
-				object.chunkName = error.chunk.name;
-				object.chunkEntry = error.chunk.hasRuntime();
-				object.chunkInitial = error.chunk.canBeInitial();
-			}
-			if (error.file) {
-				object.file = error.file;
-			}
-			if (error.module) {
-				object.moduleIdentifier = error.module.identifier();
-				object.moduleName = error.module.readableIdentifier(requestShortener);
-			}
-			if (error.loc) {
-				object.loc = formatLocation(error.loc);
-			}
-			object.message = error.message;
-		}
-	},
-	ids: (object, error, { compilation: { chunkGraph } }) => {
-		if (typeof error !== "string") {
-			if (error.chunk) {
-				object.chunkId = error.chunk.id;
-			}
-			if (error.module) {
-				object.moduleId = chunkGraph.getModuleId(error.module);
-			}
-		}
-	},
-	moduleTrace: (object, error, context, options, factory) => {
-		if (typeof error !== "string" && error.module) {
-			const {
-				type,
-				compilation: { moduleGraph }
-			} = context;
-			/** @type {Set<Module>} */
-			const visitedModules = new Set();
-			const moduleTrace = [];
-			let current = error.module;
-			while (current) {
-				if (visitedModules.has(current)) break; // circular (technically impossible, but how knows)
-				visitedModules.add(current);
-				const origin = moduleGraph.getIssuer(current);
-				if (!origin) break;
-				moduleTrace.push({ origin, module: current });
-				current = origin;
-			}
-			object.moduleTrace = factory.create(
-				`${type}.moduleTrace`,
-				moduleTrace,
-				context
-			);
-		}
-	},
-	errorDetails: (
-		object,
-		error,
-		{ type, compilation, cachedGetErrors, cachedGetWarnings },
-		{ errorDetails }
-	) => {
-		if (
-			typeof error !== "string" &&
-			(errorDetails === true ||
-				(type.endsWith(".error") && cachedGetErrors(compilation).length < 3))
-		) {
-			object.details = error.details;
-		}
-	},
-	errorStack: (object, error) => {
-		if (typeof error !== "string") {
-			object.stack = error.stack;
-		}
+/**
+ * @param {string|number} a first id
+ * @param {string|number} b second id
+ * @returns {-1|0|1} compare result
+ */
+const compareIds = (a, b) => {
+	if (typeof a !== typeof b) {
+		return typeof a < typeof b ? -1 : 1;
 	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
 };
 
-/** @type {SimpleExtractors} */
-const SIMPLE_EXTRACTORS = {
-	compilation: {
-		_: (object, compilation, context, options) => {
-			if (!context.makePathsRelative) {
-				context.makePathsRelative = makePathsRelative.bindContextCache(
-					compilation.compiler.context,
-					compilation.compiler.root
-				);
-			}
-			if (!context.cachedGetErrors) {
-				const map = new WeakMap();
-				context.cachedGetErrors = compilation => {
-					return (
-						map.get(compilation) ||
-						(errors => (map.set(compilation, errors), errors))(
-							compilation.getErrors()
-						)
-					);
-				};
-			}
-			if (!context.cachedGetWarnings) {
-				const map = new WeakMap();
-				context.cachedGetWarnings = compilation => {
-					return (
-						map.get(compilation) ||
-						(warnings => (map.set(compilation, warnings), warnings))(
-							compilation.getWarnings()
-						)
-					);
-				};
-			}
-			if (compilation.name) {
-				object.name = compilation.name;
-			}
-			if (compilation.needAdditionalPass) {
-				object.needAdditionalPass = true;
-			}
+exports.compareIds = compareIds;
 
-			const { logging, loggingDebug, loggingTrace } = options;
-			if (logging || (loggingDebug && loggingDebug.length > 0)) {
-				const util = __webpack_require__(73837);
-				object.logging = {};
-				let acceptedTypes;
-				let collapsedGroups = false;
-				switch (logging) {
-					default:
-						acceptedTypes = new Set();
-						break;
-					case "error":
-						acceptedTypes = new Set([LogType.error]);
-						break;
-					case "warn":
-						acceptedTypes = new Set([LogType.error, LogType.warn]);
-						break;
-					case "info":
-						acceptedTypes = new Set([
-							LogType.error,
-							LogType.warn,
-							LogType.info
-						]);
-						break;
-					case "log":
-						acceptedTypes = new Set([
-							LogType.error,
-							LogType.warn,
-							LogType.info,
-							LogType.log,
-							LogType.group,
-							LogType.groupEnd,
-							LogType.groupCollapsed,
-							LogType.clear
-						]);
-						break;
-					case "verbose":
-						acceptedTypes = new Set([
-							LogType.error,
-							LogType.warn,
-							LogType.info,
-							LogType.log,
-							LogType.group,
-							LogType.groupEnd,
-							LogType.groupCollapsed,
-							LogType.profile,
-							LogType.profileEnd,
-							LogType.time,
-							LogType.status,
-							LogType.clear
-						]);
-						collapsedGroups = true;
-						break;
-				}
-				const cachedMakePathsRelative = makePathsRelative.bindContextCache(
-					options.context,
-					compilation.compiler.root
-				);
-				let depthInCollapsedGroup = 0;
-				for (const [origin, logEntries] of compilation.logging) {
-					const debugMode = loggingDebug.some(fn => fn(origin));
-					if (logging === false && !debugMode) continue;
-					/** @type {KnownStatsLoggingEntry[]} */
-					const groupStack = [];
-					/** @type {KnownStatsLoggingEntry[]} */
-					const rootList = [];
-					let currentList = rootList;
-					let processedLogEntries = 0;
-					for (const entry of logEntries) {
-						let type = entry.type;
-						if (!debugMode && !acceptedTypes.has(type)) continue;
+/**
+ * @param {string} a first string
+ * @param {string} b second string
+ * @returns {-1|0|1} compare result
+ */
+const compareStrings = (a, b) => {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+};
 
-						// Expand groups in verbose and debug modes
-						if (
-							type === LogType.groupCollapsed &&
-							(debugMode || collapsedGroups)
-						)
-							type = LogType.group;
+exports.compareStrings = compareStrings;
 
-						if (depthInCollapsedGroup === 0) {
-							processedLogEntries++;
-						}
+/**
+ * @param {ChunkGroup} a first chunk group
+ * @param {ChunkGroup} b second chunk group
+ * @returns {-1|0|1} compare result
+ */
+const compareChunkGroupsByIndex = (a, b) => {
+	return a.index < b.index ? -1 : 1;
+};
 
-						if (type === LogType.groupEnd) {
-							groupStack.pop();
-							if (groupStack.length > 0) {
-								currentList = groupStack[groupStack.length - 1].children;
-							} else {
-								currentList = rootList;
-							}
-							if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
-							continue;
-						}
-						let message = undefined;
-						if (entry.type === LogType.time) {
-							message = `${entry.args[0]}: ${
-								entry.args[1] * 1000 + entry.args[2] / 1000000
-							} ms`;
-						} else if (entry.args && entry.args.length > 0) {
-							message = util.format(entry.args[0], ...entry.args.slice(1));
-						}
-						/** @type {KnownStatsLoggingEntry} */
-						const newEntry = {
-							...entry,
-							type,
-							message,
-							trace: loggingTrace ? entry.trace : undefined,
-							children:
-								type === LogType.group || type === LogType.groupCollapsed
-									? []
-									: undefined
-						};
-						currentList.push(newEntry);
-						if (newEntry.children) {
-							groupStack.push(newEntry);
-							currentList = newEntry.children;
-							if (depthInCollapsedGroup > 0) {
-								depthInCollapsedGroup++;
-							} else if (type === LogType.groupCollapsed) {
-								depthInCollapsedGroup = 1;
-							}
-						}
-					}
-					let name = cachedMakePathsRelative(origin).replace(/\|/g, " ");
-					if (name in object.logging) {
-						let i = 1;
-						while (`${name}#${i}` in object.logging) {
-							i++;
-						}
-						name = `${name}#${i}`;
-					}
-					object.logging[name] = {
-						entries: rootList,
-						filteredEntries: logEntries.length - processedLogEntries,
-						debug: debugMode
-					};
-				}
-			}
-		},
-		hash: (object, compilation) => {
-			object.hash = compilation.hash;
-		},
-		version: object => {
-			object.version = (__webpack_require__(32702)/* .version */ .i8);
-		},
-		env: (object, compilation, context, { _env }) => {
-			object.env = _env;
-		},
-		timings: (object, compilation) => {
-			object.time = compilation.endTime - compilation.startTime;
-		},
-		builtAt: (object, compilation) => {
-			object.builtAt = compilation.endTime;
-		},
-		publicPath: (object, compilation) => {
-			object.publicPath = compilation.getPath(
-				compilation.outputOptions.publicPath
-			);
-		},
-		outputPath: (object, compilation) => {
-			object.outputPath = compilation.outputOptions.path;
-		},
-		assets: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			/** @type {Map<string, Chunk[]>} */
-			const compilationFileToChunks = new Map();
-			/** @type {Map<string, Chunk[]>} */
-			const compilationAuxiliaryFileToChunks = new Map();
-			for (const chunk of compilation.chunks) {
-				for (const file of chunk.files) {
-					let array = compilationFileToChunks.get(file);
-					if (array === undefined) {
-						array = [];
-						compilationFileToChunks.set(file, array);
-					}
-					array.push(chunk);
-				}
-				for (const file of chunk.auxiliaryFiles) {
-					let array = compilationAuxiliaryFileToChunks.get(file);
-					if (array === undefined) {
-						array = [];
-						compilationAuxiliaryFileToChunks.set(file, array);
-					}
-					array.push(chunk);
-				}
-			}
-			/** @type {Map<string, PreprocessedAsset>} */
-			const assetMap = new Map();
-			/** @type {Set<PreprocessedAsset>} */
-			const assets = new Set();
-			for (const asset of compilation.getAssets()) {
-				/** @type {PreprocessedAsset} */
-				const item = {
-					...asset,
-					type: "asset",
-					related: undefined
-				};
-				assets.add(item);
-				assetMap.set(asset.name, item);
-			}
-			for (const item of assetMap.values()) {
-				const related = item.info.related;
-				if (!related) continue;
-				for (const type of Object.keys(related)) {
-					const relatedEntry = related[type];
-					const deps = Array.isArray(relatedEntry)
-						? relatedEntry
-						: [relatedEntry];
-					for (const dep of deps) {
-						const depItem = assetMap.get(dep);
-						if (!depItem) continue;
-						assets.delete(depItem);
-						depItem.type = type;
-						item.related = item.related || [];
-						item.related.push(depItem);
-					}
-				}
-			}
+exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
 
-			object.assetsByChunkName = {};
-			for (const [file, chunks] of compilationFileToChunks) {
-				for (const chunk of chunks) {
-					const name = chunk.name;
-					if (!name) continue;
-					if (
-						!Object.prototype.hasOwnProperty.call(
-							object.assetsByChunkName,
-							name
-						)
-					) {
-						object.assetsByChunkName[name] = [];
-					}
-					object.assetsByChunkName[name].push(file);
-				}
-			}
+/**
+ * @template K1 {Object}
+ * @template K2
+ * @template T
+ */
+class TwoKeyWeakMap {
+	constructor() {
+		/** @private @type {WeakMap<any, WeakMap<any, T>>} */
+		this._map = new WeakMap();
+	}
 
-			const groupedAssets = factory.create(
-				`${type}.assets`,
-				Array.from(assets),
-				{
-					...context,
-					compilationFileToChunks,
-					compilationAuxiliaryFileToChunks
-				}
-			);
-			const limited = spaceLimited(groupedAssets, options.assetsSpace);
-			object.assets = limited.children;
-			object.filteredAssets = limited.filteredChildren;
-		},
-		chunks: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			object.chunks = factory.create(
-				`${type}.chunks`,
-				Array.from(compilation.chunks),
-				context
-			);
-		},
-		modules: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			const array = Array.from(compilation.modules);
-			const groupedModules = factory.create(`${type}.modules`, array, context);
-			const limited = spaceLimited(groupedModules, options.modulesSpace);
-			object.modules = limited.children;
-			object.filteredModules = limited.filteredChildren;
-		},
-		entrypoints: (
-			object,
-			compilation,
-			context,
-			{ entrypoints, chunkGroups, chunkGroupAuxiliary, chunkGroupChildren },
-			factory
-		) => {
-			const { type } = context;
-			const array = Array.from(compilation.entrypoints, ([key, value]) => ({
-				name: key,
-				chunkGroup: value
-			}));
-			if (entrypoints === "auto" && !chunkGroups) {
-				if (array.length > 5) return;
-				if (
-					!chunkGroupChildren &&
-					array.every(({ chunkGroup }) => {
-						if (chunkGroup.chunks.length !== 1) return false;
-						const chunk = chunkGroup.chunks[0];
-						return (
-							chunk.files.size === 1 &&
-							(!chunkGroupAuxiliary || chunk.auxiliaryFiles.size === 0)
-						);
-					})
-				) {
-					return;
-				}
+	/**
+	 * @param {K1} key1 first key
+	 * @param {K2} key2 second key
+	 * @returns {T | undefined} value
+	 */
+	get(key1, key2) {
+		const childMap = this._map.get(key1);
+		if (childMap === undefined) {
+			return undefined;
+		}
+		return childMap.get(key2);
+	}
+
+	/**
+	 * @param {K1} key1 first key
+	 * @param {K2} key2 second key
+	 * @param {T | undefined} value new value
+	 * @returns {void}
+	 */
+	set(key1, key2, value) {
+		let childMap = this._map.get(key1);
+		if (childMap === undefined) {
+			childMap = new WeakMap();
+			this._map.set(key1, childMap);
+		}
+		childMap.set(key2, value);
+	}
+}
+
+/** @type {TwoKeyWeakMap<Comparator<any>, Comparator<any>, Comparator<any>>}} */
+const concatComparatorsCache = new TwoKeyWeakMap();
+
+/**
+ * @template T
+ * @param {Comparator<T>} c1 comparator
+ * @param {Comparator<T>} c2 comparator
+ * @param {Comparator<T>[]} cRest comparators
+ * @returns {Comparator<T>} comparator
+ */
+const concatComparators = (c1, c2, ...cRest) => {
+	if (cRest.length > 0) {
+		const [c3, ...cRest2] = cRest;
+		return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
+	}
+	const cacheEntry = /** @type {Comparator<T>} */ (
+		concatComparatorsCache.get(c1, c2)
+	);
+	if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {T} a first value
+	 * @param {T} b second value
+	 * @returns {-1|0|1} compare result
+	 */
+	const result = (a, b) => {
+		const res = c1(a, b);
+		if (res !== 0) return res;
+		return c2(a, b);
+	};
+	concatComparatorsCache.set(c1, c2, result);
+	return result;
+};
+exports.concatComparators = concatComparators;
+
+/** @template A, B @typedef {(input: A) => B} Selector */
+
+/** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
+const compareSelectCache = new TwoKeyWeakMap();
+
+/**
+ * @template T
+ * @template R
+ * @param {Selector<T, R>} getter getter for value
+ * @param {Comparator<R>} comparator comparator
+ * @returns {Comparator<T>} comparator
+ */
+const compareSelect = (getter, comparator) => {
+	const cacheEntry = compareSelectCache.get(getter, comparator);
+	if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {T} a first value
+	 * @param {T} b second value
+	 * @returns {-1|0|1} compare result
+	 */
+	const result = (a, b) => {
+		const aValue = getter(a);
+		const bValue = getter(b);
+		if (aValue !== undefined && aValue !== null) {
+			if (bValue !== undefined && bValue !== null) {
+				return comparator(aValue, bValue);
 			}
-			object.entrypoints = factory.create(
-				`${type}.entrypoints`,
-				array,
-				context
-			);
-		},
-		chunkGroups: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			const array = Array.from(
-				compilation.namedChunkGroups,
-				([key, value]) => ({
-					name: key,
-					chunkGroup: value
-				})
-			);
-			object.namedChunkGroups = factory.create(
-				`${type}.namedChunkGroups`,
-				array,
-				context
-			);
-		},
-		errors: (object, compilation, context, options, factory) => {
-			const { type, cachedGetErrors } = context;
-			object.errors = factory.create(
-				`${type}.errors`,
-				cachedGetErrors(compilation),
-				context
-			);
-		},
-		errorsCount: (object, compilation, { cachedGetErrors }) => {
-			object.errorsCount = countWithChildren(compilation, c =>
-				cachedGetErrors(c)
-			);
-		},
-		warnings: (object, compilation, context, options, factory) => {
-			const { type, cachedGetWarnings } = context;
-			object.warnings = factory.create(
-				`${type}.warnings`,
-				cachedGetWarnings(compilation),
-				context
-			);
-		},
-		warningsCount: (
-			object,
-			compilation,
-			context,
-			{ warningsFilter },
-			factory
-		) => {
-			const { type, cachedGetWarnings } = context;
-			object.warningsCount = countWithChildren(compilation, (c, childType) => {
-				if (!warningsFilter && warningsFilter.length === 0)
-					return cachedGetWarnings(c);
-				return factory
-					.create(`${type}${childType}.warnings`, cachedGetWarnings(c), context)
-					.filter(warning => {
-						const warningString = Object.keys(warning)
-							.map(key => `${warning[key]}`)
-							.join("\n");
-						return !warningsFilter.some(filter =>
-							filter(warning, warningString)
-						);
-					});
-			});
-		},
-		errorDetails: (
-			object,
-			compilation,
-			{ cachedGetErrors, cachedGetWarnings },
-			{ errorDetails, errors, warnings }
-		) => {
-			if (errorDetails === "auto") {
-				if (warnings) {
-					const warnings = cachedGetWarnings(compilation);
-					object.filteredWarningDetailsCount = warnings
-						.map(e => typeof e !== "string" && e.details)
-						.filter(Boolean).length;
-				}
-				if (errors) {
-					const errors = cachedGetErrors(compilation);
-					if (errors.length >= 3) {
-						object.filteredErrorDetailsCount = errors
-							.map(e => typeof e !== "string" && e.details)
-							.filter(Boolean).length;
-					}
-				}
+			return -1;
+		} else {
+			if (bValue !== undefined && bValue !== null) {
+				return 1;
 			}
-		},
-		children: (object, compilation, context, options, factory) => {
-			const { type } = context;
-			object.children = factory.create(
-				`${type}.children`,
-				compilation.children,
-				context
-			);
+			return 0;
 		}
-	},
-	asset: {
-		_: (object, asset, context, options, factory) => {
-			const { compilation } = context;
-			object.type = asset.type;
-			object.name = asset.name;
-			object.size = asset.source.size();
-			object.emitted = compilation.emittedAssets.has(asset.name);
-			object.comparedForEmit = compilation.comparedForEmitAssets.has(
-				asset.name
-			);
-			const cached = !object.emitted && !object.comparedForEmit;
-			object.cached = cached;
-			object.info = asset.info;
-			if (!cached || options.cachedAssets) {
-				Object.assign(
-					object,
-					factory.create(`${context.type}$visible`, asset, context)
-				);
+	};
+	compareSelectCache.set(getter, comparator, result);
+	return result;
+};
+exports.compareSelect = compareSelect;
+
+/** @type {WeakMap<Comparator<any>, Comparator<Iterable<any>>>} */
+const compareIteratorsCache = new WeakMap();
+
+/**
+ * @template T
+ * @param {Comparator<T>} elementComparator comparator for elements
+ * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
+ */
+const compareIterables = elementComparator => {
+	const cacheEntry = compareIteratorsCache.get(elementComparator);
+	if (cacheEntry !== undefined) return cacheEntry;
+	/**
+	 * @param {Iterable<T>} a first value
+	 * @param {Iterable<T>} b second value
+	 * @returns {-1|0|1} compare result
+	 */
+	const result = (a, b) => {
+		const aI = a[Symbol.iterator]();
+		const bI = b[Symbol.iterator]();
+		// eslint-disable-next-line no-constant-condition
+		while (true) {
+			const aItem = aI.next();
+			const bItem = bI.next();
+			if (aItem.done) {
+				return bItem.done ? 0 : -1;
+			} else if (bItem.done) {
+				return 1;
 			}
+			const res = elementComparator(aItem.value, bItem.value);
+			if (res !== 0) return res;
 		}
-	},
-	asset$visible: {
-		_: (
-			object,
-			asset,
-			{ compilation, compilationFileToChunks, compilationAuxiliaryFileToChunks }
-		) => {
-			const chunks = compilationFileToChunks.get(asset.name) || [];
-			const auxiliaryChunks =
-				compilationAuxiliaryFileToChunks.get(asset.name) || [];
-			object.chunkNames = uniqueOrderedArray(
-				chunks,
-				c => (c.name ? [c.name] : []),
-				compareIds
-			);
-			object.chunkIdHints = uniqueOrderedArray(
-				chunks,
-				c => Array.from(c.idNameHints),
-				compareIds
-			);
-			object.auxiliaryChunkNames = uniqueOrderedArray(
-				auxiliaryChunks,
-				c => (c.name ? [c.name] : []),
-				compareIds
-			);
-			object.auxiliaryChunkIdHints = uniqueOrderedArray(
-				auxiliaryChunks,
-				c => Array.from(c.idNameHints),
-				compareIds
-			);
-			object.filteredRelated = asset.related ? asset.related.length : undefined;
-		},
-		relatedAssets: (object, asset, context, options, factory) => {
-			const { type } = context;
-			object.related = factory.create(
-				`${type.slice(0, -8)}.related`,
-				asset.related,
-				context
-			);
-			object.filteredRelated = asset.related
-				? asset.related.length - object.related.length
-				: undefined;
-		},
-		ids: (
-			object,
-			asset,
-			{ compilationFileToChunks, compilationAuxiliaryFileToChunks }
-		) => {
-			const chunks = compilationFileToChunks.get(asset.name) || [];
-			const auxiliaryChunks =
-				compilationAuxiliaryFileToChunks.get(asset.name) || [];
-			object.chunks = uniqueOrderedArray(chunks, c => c.ids, compareIds);
-			object.auxiliaryChunks = uniqueOrderedArray(
-				auxiliaryChunks,
-				c => c.ids,
-				compareIds
-			);
-		},
-		performance: (object, asset) => {
-			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(asset.source);
-		}
-	},
-	chunkGroup: {
-		_: (
-			object,
-			{ name, chunkGroup },
-			{ compilation, compilation: { moduleGraph, chunkGraph } },
-			{ ids, chunkGroupAuxiliary, chunkGroupChildren, chunkGroupMaxAssets }
-		) => {
-			const children =
-				chunkGroupChildren &&
-				chunkGroup.getChildrenByOrders(moduleGraph, chunkGraph);
+	};
+	compareIteratorsCache.set(elementComparator, result);
+	return result;
+};
+exports.compareIterables = compareIterables;
+
+// TODO this is no longer needed when minimum node.js version is >= 12
+// since these versions ship with a stable sort function
+/**
+ * @template T
+ * @param {Iterable<T>} iterable original ordered list
+ * @returns {Comparator<T>} comparator
+ */
+exports.keepOriginalOrder = iterable => {
+	/** @type {Map<T, number>} */
+	const map = new Map();
+	let i = 0;
+	for (const item of iterable) {
+		map.set(item, i++);
+	}
+	return (a, b) => compareNumbers(map.get(a), map.get(b));
+};
+
+/**
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {Comparator<Chunk>} comparator
+ */
+exports.compareChunksNatural = chunkGraph => {
+	const cmpFn = exports.compareModulesById(chunkGraph);
+	const cmpIterableFn = compareIterables(cmpFn);
+	return concatComparators(
+		compareSelect(chunk => chunk.name, compareIds),
+		compareSelect(chunk => chunk.runtime, compareRuntime),
+		compareSelect(
 			/**
-			 * @param {string} name Name
-			 * @returns {{ name: string, size: number }} Asset object
+			 * @param {Chunk} chunk a chunk
+			 * @returns {Iterable<Module>} modules
 			 */
-			const toAsset = name => {
-				const asset = compilation.getAsset(name);
-				return {
-					name,
-					size: asset ? asset.info.size : -1
-				};
-			};
-			/** @type {(total: number, asset: { size: number }) => number} */
-			const sizeReducer = (total, { size }) => total + size;
-			const assets = uniqueArray(chunkGroup.chunks, c => c.files).map(toAsset);
-			const auxiliaryAssets = uniqueOrderedArray(
-				chunkGroup.chunks,
-				c => c.auxiliaryFiles,
-				compareIds
-			).map(toAsset);
-			const assetsSize = assets.reduce(sizeReducer, 0);
-			const auxiliaryAssetsSize = auxiliaryAssets.reduce(sizeReducer, 0);
-			/** @type {KnownStatsChunkGroup} */
-			const statsChunkGroup = {
-				name,
-				chunks: ids ? chunkGroup.chunks.map(c => c.id) : undefined,
-				assets: assets.length <= chunkGroupMaxAssets ? assets : undefined,
-				filteredAssets:
-					assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
-				assetsSize,
-				auxiliaryAssets:
-					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
-						? auxiliaryAssets
-						: undefined,
-				filteredAuxiliaryAssets:
-					chunkGroupAuxiliary && auxiliaryAssets.length <= chunkGroupMaxAssets
-						? 0
-						: auxiliaryAssets.length,
-				auxiliaryAssetsSize,
-				children: children
-					? mapObject(children, groups =>
-							groups.map(group => {
-								const assets = uniqueArray(group.chunks, c => c.files).map(
-									toAsset
-								);
-								const auxiliaryAssets = uniqueOrderedArray(
-									group.chunks,
-									c => c.auxiliaryFiles,
-									compareIds
-								).map(toAsset);
+			chunk => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn),
+			cmpIterableFn
+		)
+	);
+};
+
+/**
+ * Compare two locations
+ * @param {DependencyLocation} a A location node
+ * @param {DependencyLocation} b A location node
+ * @returns {-1|0|1} sorting comparator value
+ */
+exports.compareLocations = (a, b) => {
+	let isObjectA = typeof a === "object" && a !== null;
+	let isObjectB = typeof b === "object" && b !== null;
+	if (!isObjectA || !isObjectB) {
+		if (isObjectA) return 1;
+		if (isObjectB) return -1;
+		return 0;
+	}
+	if ("start" in a) {
+		if ("start" in b) {
+			const ap = a.start;
+			const bp = b.start;
+			if (ap.line < bp.line) return -1;
+			if (ap.line > bp.line) return 1;
+			if (ap.column < bp.column) return -1;
+			if (ap.column > bp.column) return 1;
+		} else return -1;
+	} else if ("start" in b) return 1;
+	if ("name" in a) {
+		if ("name" in b) {
+			if (a.name < b.name) return -1;
+			if (a.name > b.name) return 1;
+		} else return -1;
+	} else if ("name" in b) return 1;
+	if ("index" in a) {
+		if ("index" in b) {
+			if (a.index < b.index) return -1;
+			if (a.index > b.index) return 1;
+		} else return -1;
+	} else if ("index" in b) return 1;
+	return 0;
+};
 
-								/** @type {KnownStatsChunkGroup} */
-								const childStatsChunkGroup = {
-									name: group.name,
-									chunks: ids ? group.chunks.map(c => c.id) : undefined,
-									assets:
-										assets.length <= chunkGroupMaxAssets ? assets : undefined,
-									filteredAssets:
-										assets.length <= chunkGroupMaxAssets ? 0 : assets.length,
-									auxiliaryAssets:
-										chunkGroupAuxiliary &&
-										auxiliaryAssets.length <= chunkGroupMaxAssets
-											? auxiliaryAssets
-											: undefined,
-									filteredAuxiliaryAssets:
-										chunkGroupAuxiliary &&
-										auxiliaryAssets.length <= chunkGroupMaxAssets
-											? 0
-											: auxiliaryAssets.length
-								};
 
-								return childStatsChunkGroup;
-							})
-					  )
-					: undefined,
-				childAssets: children
-					? mapObject(children, groups => {
-							/** @type {Set<string>} */
-							const set = new Set();
-							for (const group of groups) {
-								for (const chunk of group.chunks) {
-									for (const asset of chunk.files) {
-										set.add(asset);
-									}
-								}
-							}
-							return Array.from(set);
-					  })
-					: undefined
-			};
-			Object.assign(object, statsChunkGroup);
-		},
-		performance: (object, { chunkGroup }) => {
-			object.isOverSizeLimit = SizeLimitsPlugin.isOverSizeLimit(chunkGroup);
+/***/ }),
+
+/***/ 29404:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const quoteMeta = str => {
+	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+};
+
+const toSimpleString = str => {
+	if (`${+str}` === str) {
+		return str;
+	}
+	return JSON.stringify(str);
+};
+
+/**
+ * @param {Record<string|number, boolean>} map value map
+ * @returns {true|false|function(string): string} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+ */
+const compileBooleanMatcher = map => {
+	const positiveItems = Object.keys(map).filter(i => map[i]);
+	const negativeItems = Object.keys(map).filter(i => !map[i]);
+	if (positiveItems.length === 0) return false;
+	if (negativeItems.length === 0) return true;
+	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
+};
+
+/**
+ * @param {string[]} positiveItems positive items
+ * @param {string[]} negativeItems negative items
+ * @returns {function(string): string} a template function to determine the value at runtime
+ */
+const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
+	if (positiveItems.length === 0) return () => "false";
+	if (negativeItems.length === 0) return () => "true";
+	if (positiveItems.length === 1)
+		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
+	if (negativeItems.length === 1)
+		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
+	const positiveRegexp = itemsToRegexp(positiveItems);
+	const negativeRegexp = itemsToRegexp(negativeItems);
+	if (positiveRegexp.length <= negativeRegexp.length) {
+		return value => `/^${positiveRegexp}$/.test(${value})`;
+	} else {
+		return value => `!/^${negativeRegexp}$/.test(${value})`;
+	}
+};
+
+const popCommonItems = (itemsSet, getKey, condition) => {
+	const map = new Map();
+	for (const item of itemsSet) {
+		const key = getKey(item);
+		if (key) {
+			let list = map.get(key);
+			if (list === undefined) {
+				list = [];
+				map.set(key, list);
+			}
+			list.push(item);
 		}
-	},
-	module: {
-		_: (object, module, context, options, factory) => {
-			const { compilation, type } = context;
-			const built = compilation.builtModules.has(module);
-			const codeGenerated = compilation.codeGeneratedModules.has(module);
-			const buildTimeExecuted =
-				compilation.buildTimeExecutedModules.has(module);
-			/** @type {{[x: string]: number}} */
-			const sizes = {};
-			for (const sourceType of module.getSourceTypes()) {
-				sizes[sourceType] = module.size(sourceType);
+	}
+	const result = [];
+	for (const list of map.values()) {
+		if (condition(list)) {
+			for (const item of list) {
+				itemsSet.delete(item);
 			}
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				type: "module",
-				moduleType: module.type,
-				layer: module.layer,
-				size: module.size(),
-				sizes,
-				built,
-				codeGenerated,
-				buildTimeExecuted,
-				cached: !built && !codeGenerated
-			};
-			Object.assign(object, statsModule);
+			result.push(list);
+		}
+	}
+	return result;
+};
 
-			if (built || codeGenerated || options.cachedModules) {
-				Object.assign(
-					object,
-					factory.create(`${type}$visible`, module, context)
-				);
+const getCommonPrefix = items => {
+	let prefix = items[0];
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		for (let p = 0; p < prefix.length; p++) {
+			if (item[p] !== prefix[p]) {
+				prefix = prefix.slice(0, p);
+				break;
 			}
 		}
-	},
-	module$visible: {
-		_: (object, module, context, { requestShortener }, factory) => {
-			const { compilation, type, rootModules } = context;
-			const { moduleGraph } = compilation;
-			/** @type {Module[]} */
-			const path = [];
-			const issuer = moduleGraph.getIssuer(module);
-			let current = issuer;
-			while (current) {
-				path.push(current);
-				current = moduleGraph.getIssuer(current);
-			}
-			path.reverse();
-			const profile = moduleGraph.getProfile(module);
-			const errors = module.getErrors();
-			const errorsCount = errors !== undefined ? countIterable(errors) : 0;
-			const warnings = module.getWarnings();
-			const warningsCount =
-				warnings !== undefined ? countIterable(warnings) : 0;
-			/** @type {{[x: string]: number}} */
-			const sizes = {};
-			for (const sourceType of module.getSourceTypes()) {
-				sizes[sourceType] = module.size(sourceType);
+	}
+	return prefix;
+};
+
+const getCommonSuffix = items => {
+	let suffix = items[0];
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		for (let p = item.length - 1, s = suffix.length - 1; s >= 0; p--, s--) {
+			if (item[p] !== suffix[s]) {
+				suffix = suffix.slice(s + 1);
+				break;
 			}
-			/** @type {KnownStatsModule} */
-			const statsModule = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener),
-				nameForCondition: module.nameForCondition(),
-				index: moduleGraph.getPreOrderIndex(module),
-				preOrderIndex: moduleGraph.getPreOrderIndex(module),
-				index2: moduleGraph.getPostOrderIndex(module),
-				postOrderIndex: moduleGraph.getPostOrderIndex(module),
-				cacheable: module.buildInfo.cacheable,
-				optional: module.isOptional(moduleGraph),
-				orphan:
-					!type.endsWith("module.modules[].module$visible") &&
-					compilation.chunkGraph.getNumberOfModuleChunks(module) === 0,
-				dependent: rootModules ? !rootModules.has(module) : undefined,
-				issuer: issuer && issuer.identifier(),
-				issuerName: issuer && issuer.readableIdentifier(requestShortener),
-				issuerPath:
-					issuer &&
-					factory.create(`${type.slice(0, -8)}.issuerPath`, path, context),
-				failed: errorsCount > 0,
-				errors: errorsCount,
-				warnings: warningsCount
-			};
-			Object.assign(object, statsModule);
-			if (profile) {
-				object.profile = factory.create(
-					`${type.slice(0, -8)}.profile`,
-					profile,
-					context
-				);
+		}
+	}
+	return suffix;
+};
+
+const itemsToRegexp = itemsArr => {
+	if (itemsArr.length === 1) {
+		return quoteMeta(itemsArr[0]);
+	}
+	const finishedItems = [];
+
+	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
+	let countOfSingleCharItems = 0;
+	for (const item of itemsArr) {
+		if (item.length === 1) {
+			countOfSingleCharItems++;
+		}
+	}
+	// special case for only single char items
+	if (countOfSingleCharItems === itemsArr.length) {
+		return `[${quoteMeta(itemsArr.sort().join(""))}]`;
+	}
+	const items = new Set(itemsArr.sort());
+	if (countOfSingleCharItems > 2) {
+		let singleCharItems = "";
+		for (const item of items) {
+			if (item.length === 1) {
+				singleCharItems += item;
+				items.delete(item);
 			}
-		},
-		ids: (object, module, { compilation: { chunkGraph, moduleGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
-			const issuer = moduleGraph.getIssuer(module);
-			object.issuerId = issuer && chunkGraph.getModuleId(issuer);
-			object.chunks = Array.from(
-				chunkGraph.getOrderedModuleChunksIterable(module, compareChunksById),
-				chunk => chunk.id
-			);
-		},
-		moduleAssets: (object, module) => {
-			object.assets = module.buildInfo.assets
-				? Object.keys(module.buildInfo.assets)
-				: [];
-		},
-		reasons: (object, module, context, options, factory) => {
-			const {
-				type,
-				compilation: { moduleGraph }
-			} = context;
-			const groupsReasons = factory.create(
-				`${type.slice(0, -8)}.reasons`,
-				Array.from(moduleGraph.getIncomingConnections(module)),
-				context
-			);
-			const limited = spaceLimited(groupsReasons, options.reasonsSpace);
-			object.reasons = limited.children;
-			object.filteredReasons = limited.filteredChildren;
-		},
-		usedExports: (
-			object,
-			module,
-			{ runtime, compilation: { moduleGraph } }
-		) => {
-			const usedExports = moduleGraph.getUsedExports(module, runtime);
-			if (usedExports === null) {
-				object.usedExports = null;
-			} else if (typeof usedExports === "boolean") {
-				object.usedExports = usedExports;
-			} else {
-				object.usedExports = Array.from(usedExports);
+		}
+		finishedItems.push(`[${quoteMeta(singleCharItems)}]`);
+	}
+
+	// special case for 2 items with common prefix/suffix
+	if (finishedItems.length === 0 && items.size === 2) {
+		const prefix = getCommonPrefix(itemsArr);
+		const suffix = getCommonSuffix(
+			itemsArr.map(item => item.slice(prefix.length))
+		);
+		if (prefix.length > 0 || suffix.length > 0) {
+			return `${quoteMeta(prefix)}${itemsToRegexp(
+				itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined))
+			)}${quoteMeta(suffix)}`;
+		}
+	}
+
+	// special case for 2 items with common suffix
+	if (finishedItems.length === 0 && items.size === 2) {
+		const it = items[Symbol.iterator]();
+		const a = it.next().value;
+		const b = it.next().value;
+		if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
+			return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(
+				a.slice(-1)
+			)}`;
+		}
+	}
+
+	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
+	const prefixed = popCommonItems(
+		items,
+		item => (item.length >= 1 ? item[0] : false),
+		list => {
+			if (list.length >= 3) return true;
+			if (list.length <= 1) return false;
+			return list[0][1] === list[1][1];
+		}
+	);
+	for (const prefixedItems of prefixed) {
+		const prefix = getCommonPrefix(prefixedItems);
+		finishedItems.push(
+			`${quoteMeta(prefix)}${itemsToRegexp(
+				prefixedItems.map(i => i.slice(prefix.length))
+			)}`
+		);
+	}
+
+	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
+	const suffixed = popCommonItems(
+		items,
+		item => (item.length >= 1 ? item.slice(-1) : false),
+		list => {
+			if (list.length >= 3) return true;
+			if (list.length <= 1) return false;
+			return list[0].slice(-2) === list[1].slice(-2);
+		}
+	);
+	for (const suffixedItems of suffixed) {
+		const suffix = getCommonSuffix(suffixedItems);
+		finishedItems.push(
+			`${itemsToRegexp(
+				suffixedItems.map(i => i.slice(0, -suffix.length))
+			)}${quoteMeta(suffix)}`
+		);
+	}
+
+	// TODO further optimize regexp, i. e.
+	// use ranges: (1|2|3|4|a) => [1-4a]
+	const conditional = finishedItems.concat(Array.from(items, quoteMeta));
+	if (conditional.length === 1) return conditional[0];
+	return `(${conditional.join("|")})`;
+};
+
+compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
+compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
+module.exports = compileBooleanMatcher;
+
+
+/***/ }),
+
+/***/ 32540:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const memoize = __webpack_require__(78676);
+
+const getValidate = memoize(() => (__webpack_require__(38476).validate));
+
+const createSchemaValidation = (check, getSchema, options) => {
+	getSchema = memoize(getSchema);
+	return value => {
+		if (check && !check(value)) {
+			getValidate()(getSchema(), value, options);
+			if (check) {
+				(__webpack_require__(73837).deprecate)(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
 			}
-		},
-		providedExports: (object, module, { compilation: { moduleGraph } }) => {
-			const providedExports = moduleGraph.getProvidedExports(module);
-			object.providedExports = Array.isArray(providedExports)
-				? providedExports
-				: null;
-		},
-		optimizationBailout: (
-			object,
-			module,
-			{ compilation: { moduleGraph } },
-			{ requestShortener }
-		) => {
-			object.optimizationBailout = moduleGraph
-				.getOptimizationBailout(module)
-				.map(item => {
-					if (typeof item === "function") return item(requestShortener);
-					return item;
-				});
-		},
-		depth: (object, module, { compilation: { moduleGraph } }) => {
-			object.depth = moduleGraph.getDepth(module);
-		},
-		nestedModules: (object, module, context, options, factory) => {
-			const { type } = context;
-			const innerModules = /** @type {Module & { modules?: Module[] }} */ (
-				module
-			).modules;
-			if (Array.isArray(innerModules)) {
-				const groupedModules = factory.create(
-					`${type.slice(0, -8)}.modules`,
-					innerModules,
-					context
-				);
-				const limited = spaceLimited(
-					groupedModules,
-					options.nestedModulesSpace
-				);
-				object.modules = limited.children;
-				object.filteredModules = limited.filteredChildren;
+		}
+	};
+};
+
+module.exports = createSchemaValidation;
+
+
+/***/ }),
+
+/***/ 49835:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Hash = __webpack_require__(36692);
+
+const BULK_SIZE = 2000;
+
+// We are using an object instead of a Map as this will stay static during the runtime
+// so access to it can be optimized by v8
+const digestCaches = {};
+
+class BulkUpdateDecorator extends Hash {
+	/**
+	 * @param {Hash | function(): Hash} hashOrFactory function to create a hash
+	 * @param {string=} hashKey key for caching
+	 */
+	constructor(hashOrFactory, hashKey) {
+		super();
+		this.hashKey = hashKey;
+		if (typeof hashOrFactory === "function") {
+			this.hashFactory = hashOrFactory;
+			this.hash = undefined;
+		} else {
+			this.hashFactory = undefined;
+			this.hash = hashOrFactory;
+		}
+		this.buffer = "";
+	}
+
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (
+			inputEncoding !== undefined ||
+			typeof data !== "string" ||
+			data.length > BULK_SIZE
+		) {
+			if (this.hash === undefined) this.hash = this.hashFactory();
+			if (this.buffer.length > 0) {
+				this.hash.update(this.buffer);
+				this.buffer = "";
 			}
-		},
-		source: (object, module) => {
-			const originalSource = module.originalSource();
-			if (originalSource) {
-				object.source = originalSource.source();
+			this.hash.update(data, inputEncoding);
+		} else {
+			this.buffer += data;
+			if (this.buffer.length > BULK_SIZE) {
+				if (this.hash === undefined) this.hash = this.hashFactory();
+				this.hash.update(this.buffer);
+				this.buffer = "";
 			}
 		}
-	},
-	profile: {
-		_: (object, profile) => {
-			/** @type {KnownStatsProfile} */
-			const statsProfile = {
-				total:
-					profile.factory +
-					profile.restoring +
-					profile.integration +
-					profile.building +
-					profile.storing,
-				resolving: profile.factory,
-				restoring: profile.restoring,
-				building: profile.building,
-				integration: profile.integration,
-				storing: profile.storing,
-				additionalResolving: profile.additionalFactories,
-				additionalIntegration: profile.additionalIntegration,
-				// TODO remove this in webpack 6
-				factory: profile.factory,
-				// TODO remove this in webpack 6
-				dependencies: profile.additionalFactories
-			};
-			Object.assign(object, statsProfile);
-		}
-	},
-	moduleIssuer: {
-		_: (object, module, context, { requestShortener }, factory) => {
-			const { compilation, type } = context;
-			const { moduleGraph } = compilation;
-			const profile = moduleGraph.getProfile(module);
-			/** @type {KnownStatsModuleIssuer} */
-			const statsModuleIssuer = {
-				identifier: module.identifier(),
-				name: module.readableIdentifier(requestShortener)
-			};
-			Object.assign(object, statsModuleIssuer);
-			if (profile) {
-				object.profile = factory.create(`${type}.profile`, profile, context);
+		return this;
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		let digestCache;
+		const buffer = this.buffer;
+		if (this.hash === undefined) {
+			// short data for hash, we can use caching
+			const cacheKey = `${this.hashKey}-${encoding}`;
+			digestCache = digestCaches[cacheKey];
+			if (digestCache === undefined) {
+				digestCache = digestCaches[cacheKey] = new Map();
 			}
-		},
-		ids: (object, module, { compilation: { chunkGraph } }) => {
-			object.id = chunkGraph.getModuleId(module);
+			const cacheEntry = digestCache.get(buffer);
+			if (cacheEntry !== undefined) return cacheEntry;
+			this.hash = this.hashFactory();
 		}
-	},
-	moduleReason: {
-		_: (object, reason, { runtime }, { requestShortener }) => {
-			const dep = reason.dependency;
-			const moduleDep =
-				dep && dep instanceof ModuleDependency ? dep : undefined;
-			/** @type {KnownStatsModuleReason} */
-			const statsModuleReason = {
-				moduleIdentifier: reason.originModule
-					? reason.originModule.identifier()
-					: null,
-				module: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				moduleName: reason.originModule
-					? reason.originModule.readableIdentifier(requestShortener)
-					: null,
-				resolvedModuleIdentifier: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.identifier()
-					: null,
-				resolvedModule: reason.resolvedOriginModule
-					? reason.resolvedOriginModule.readableIdentifier(requestShortener)
-					: null,
-				type: reason.dependency ? reason.dependency.type : null,
-				active: reason.isActive(runtime),
-				explanation: reason.explanation,
-				userRequest: (moduleDep && moduleDep.userRequest) || null
-			};
-			Object.assign(object, statsModuleReason);
-			if (reason.dependency) {
-				const locInfo = formatLocation(reason.dependency.loc);
-				if (locInfo) {
-					object.loc = locInfo;
-				}
-			}
-		},
-		ids: (object, reason, { compilation: { chunkGraph } }) => {
-			object.moduleId = reason.originModule
-				? chunkGraph.getModuleId(reason.originModule)
-				: null;
-			object.resolvedModuleId = reason.resolvedOriginModule
-				? chunkGraph.getModuleId(reason.resolvedOriginModule)
-				: null;
+		if (buffer.length > 0) {
+			this.hash.update(buffer);
 		}
-	},
-	chunk: {
-		_: (object, chunk, { makePathsRelative, compilation: { chunkGraph } }) => {
-			const childIdByOrder = chunk.getChildIdsByOrders(chunkGraph);
+		const digestResult = this.hash.digest(encoding);
+		const result =
+			typeof digestResult === "string" ? digestResult : digestResult.toString();
+		if (digestCache !== undefined) {
+			digestCache.set(buffer, result);
+		}
+		return result;
+	}
+}
 
-			/** @type {KnownStatsChunk} */
-			const statsChunk = {
-				rendered: chunk.rendered,
-				initial: chunk.canBeInitial(),
-				entry: chunk.hasRuntime(),
-				recorded: AggressiveSplittingPlugin.wasChunkRecorded(chunk),
-				reason: chunk.chunkReason,
-				size: chunkGraph.getChunkModulesSize(chunk),
-				sizes: chunkGraph.getChunkModulesSizes(chunk),
-				names: chunk.name ? [chunk.name] : [],
-				idHints: Array.from(chunk.idNameHints),
-				runtime:
-					chunk.runtime === undefined
-						? undefined
-						: typeof chunk.runtime === "string"
-						? [makePathsRelative(chunk.runtime)]
-						: Array.from(chunk.runtime.sort(), makePathsRelative),
-				files: Array.from(chunk.files),
-				auxiliaryFiles: Array.from(chunk.auxiliaryFiles).sort(compareIds),
-				hash: chunk.renderedHash,
-				childrenByOrder: childIdByOrder
-			};
-			Object.assign(object, statsChunk);
-		},
-		ids: (object, chunk) => {
-			object.id = chunk.id;
-		},
-		chunkRelations: (object, chunk, { compilation: { chunkGraph } }) => {
-			/** @type {Set<string|number>} */
-			const parents = new Set();
-			/** @type {Set<string|number>} */
-			const children = new Set();
-			/** @type {Set<string|number>} */
-			const siblings = new Set();
+/* istanbul ignore next */
+class DebugHash extends Hash {
+	constructor() {
+		super();
+		this.string = "";
+	}
 
-			for (const chunkGroup of chunk.groupsIterable) {
-				for (const parentGroup of chunkGroup.parentsIterable) {
-					for (const chunk of parentGroup.chunks) {
-						parents.add(chunk.id);
-					}
-				}
-				for (const childGroup of chunkGroup.childrenIterable) {
-					for (const chunk of childGroup.chunks) {
-						children.add(chunk.id);
-					}
-				}
-				for (const sibling of chunkGroup.chunks) {
-					if (sibling !== chunk) siblings.add(sibling.id);
+	/**
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
+	 */
+	update(data, inputEncoding) {
+		if (typeof data !== "string") data = data.toString("utf-8");
+		if (data.startsWith("debug-digest-")) {
+			data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
+		}
+		this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
+		return this;
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		return "debug-digest-" + Buffer.from(this.string).toString("hex");
+	}
+}
+
+let crypto = undefined;
+let createXXHash64 = undefined;
+let createMd4 = undefined;
+let BatchedHash = undefined;
+
+/**
+ * Creates a hash by name or function
+ * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
+ * @returns {Hash} the hash
+ */
+module.exports = algorithm => {
+	if (typeof algorithm === "function") {
+		return new BulkUpdateDecorator(() => new algorithm());
+	}
+	switch (algorithm) {
+		// TODO add non-cryptographic algorithm here
+		case "debug":
+			return new DebugHash();
+		case "xxhash64":
+			if (createXXHash64 === undefined) {
+				createXXHash64 = __webpack_require__(35028);
+				if (BatchedHash === undefined) {
+					BatchedHash = __webpack_require__(59461);
 				}
 			}
-			object.siblings = Array.from(siblings).sort(compareIds);
-			object.parents = Array.from(parents).sort(compareIds);
-			object.children = Array.from(children).sort(compareIds);
-		},
-		chunkModules: (object, chunk, context, options, factory) => {
-			const {
-				type,
-				compilation: { chunkGraph }
-			} = context;
-			const array = chunkGraph.getChunkModules(chunk);
-			const groupedModules = factory.create(`${type}.modules`, array, {
-				...context,
-				runtime: chunk.runtime,
-				rootModules: new Set(chunkGraph.getChunkRootModules(chunk))
-			});
-			const limited = spaceLimited(groupedModules, options.chunkModulesSpace);
-			object.modules = limited.children;
-			object.filteredModules = limited.filteredChildren;
-		},
-		chunkOrigins: (object, chunk, context, options, factory) => {
-			const {
-				type,
-				compilation: { chunkGraph }
-			} = context;
-			/** @type {Set<string>} */
-			const originsKeySet = new Set();
-			const origins = [];
-			for (const g of chunk.groupsIterable) {
-				origins.push(...g.origins);
+			return new BatchedHash(createXXHash64());
+		case "md4":
+			if (createMd4 === undefined) {
+				createMd4 = __webpack_require__(86884);
+				if (BatchedHash === undefined) {
+					BatchedHash = __webpack_require__(59461);
+				}
 			}
-			const array = origins.filter(origin => {
-				const key = [
-					origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
-					formatLocation(origin.loc),
-					origin.request
-				].join();
-				if (originsKeySet.has(key)) return false;
-				originsKeySet.add(key);
-				return true;
-			});
-			object.origins = factory.create(`${type}.origins`, array, context);
-		}
-	},
-	chunkOrigin: {
-		_: (object, origin, context, { requestShortener }) => {
-			/** @type {KnownStatsChunkOrigin} */
-			const statsChunkOrigin = {
-				module: origin.module ? origin.module.identifier() : "",
-				moduleIdentifier: origin.module ? origin.module.identifier() : "",
-				moduleName: origin.module
-					? origin.module.readableIdentifier(requestShortener)
-					: "",
-				loc: formatLocation(origin.loc),
-				request: origin.request
-			};
-			Object.assign(object, statsChunkOrigin);
-		},
-		ids: (object, origin, { compilation: { chunkGraph } }) => {
-			object.moduleId = origin.module
-				? chunkGraph.getModuleId(origin.module)
-				: undefined;
+			return new BatchedHash(createMd4());
+		case "native-md4":
+			if (crypto === undefined) crypto = __webpack_require__(6113);
+			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+		default:
+			if (crypto === undefined) crypto = __webpack_require__(6113);
+			return new BulkUpdateDecorator(
+				() => crypto.createHash(algorithm),
+				algorithm
+			);
+	}
+};
+
+
+/***/ }),
+
+/***/ 64518:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const util = __webpack_require__(73837);
+
+/** @type {Map<string, Function>} */
+const deprecationCache = new Map();
+
+/**
+ * @typedef {Object} FakeHookMarker
+ * @property {true} _fakeHook it's a fake hook
+ */
+
+/** @template T @typedef {T & FakeHookMarker} FakeHook<T> */
+
+/**
+ * @param {string} message deprecation message
+ * @param {string} code deprecation code
+ * @returns {Function} function to trigger deprecation
+ */
+const createDeprecation = (message, code) => {
+	const cached = deprecationCache.get(message);
+	if (cached !== undefined) return cached;
+	const fn = util.deprecate(
+		() => {},
+		message,
+		"DEP_WEBPACK_DEPRECATION_" + code
+	);
+	deprecationCache.set(message, fn);
+	return fn;
+};
+
+const COPY_METHODS = [
+	"concat",
+	"entry",
+	"filter",
+	"find",
+	"findIndex",
+	"includes",
+	"indexOf",
+	"join",
+	"lastIndexOf",
+	"map",
+	"reduce",
+	"reduceRight",
+	"slice",
+	"some"
+];
+
+const DISABLED_METHODS = [
+	"copyWithin",
+	"entries",
+	"fill",
+	"keys",
+	"pop",
+	"reverse",
+	"shift",
+	"splice",
+	"sort",
+	"unshift"
+];
+
+/**
+ * @param {any} set new set
+ * @param {string} name property name
+ * @returns {void}
+ */
+exports.arrayToSetDeprecation = (set, name) => {
+	for (const method of COPY_METHODS) {
+		if (set[method]) continue;
+		const d = createDeprecation(
+			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
+			"ARRAY_TO_SET"
+		);
+		/**
+		 * @deprecated
+		 * @this {Set}
+		 * @returns {number} count
+		 */
+		set[method] = function () {
+			d();
+			const array = Array.from(this);
+			return Array.prototype[method].apply(array, arguments);
+		};
+	}
+	const dPush = createDeprecation(
+		`${name} was changed from Array to Set (using Array method 'push' is deprecated)`,
+		"ARRAY_TO_SET_PUSH"
+	);
+	const dLength = createDeprecation(
+		`${name} was changed from Array to Set (using Array property 'length' is deprecated)`,
+		"ARRAY_TO_SET_LENGTH"
+	);
+	const dIndexer = createDeprecation(
+		`${name} was changed from Array to Set (indexing Array is deprecated)`,
+		"ARRAY_TO_SET_INDEXER"
+	);
+	/**
+	 * @deprecated
+	 * @this {Set}
+	 * @returns {number} count
+	 */
+	set.push = function () {
+		dPush();
+		for (const item of Array.from(arguments)) {
+			this.add(item);
 		}
-	},
-	error: EXTRACT_ERROR,
-	warning: EXTRACT_ERROR,
-	moduleTraceItem: {
-		_: (object, { origin, module }, context, { requestShortener }, factory) => {
-			const {
-				type,
-				compilation: { moduleGraph }
-			} = context;
-			object.originIdentifier = origin.identifier();
-			object.originName = origin.readableIdentifier(requestShortener);
-			object.moduleIdentifier = module.identifier();
-			object.moduleName = module.readableIdentifier(requestShortener);
-			const dependencies = Array.from(
-				moduleGraph.getIncomingConnections(module)
-			)
-				.filter(c => c.resolvedOriginModule === origin && c.dependency)
-				.map(c => c.dependency);
-			object.dependencies = factory.create(
-				`${type}.dependencies`,
-				Array.from(new Set(dependencies)),
-				context
+		return this.size;
+	};
+	for (const method of DISABLED_METHODS) {
+		if (set[method]) continue;
+		set[method] = () => {
+			throw new Error(
+				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
 			);
+		};
+	}
+	const createIndexGetter = index => {
+		/**
+		 * @this {Set} a Set
+		 * @returns {any} the value at this location
+		 */
+		const fn = function () {
+			dIndexer();
+			let i = 0;
+			for (const item of this) {
+				if (i++ === index) return item;
+			}
+			return undefined;
+		};
+		return fn;
+	};
+	const defineIndexGetter = index => {
+		Object.defineProperty(set, index, {
+			get: createIndexGetter(index),
+			set(value) {
+				throw new Error(
+					`${name} was changed from Array to Set (indexing Array with write is not possible)`
+				);
+			}
+		});
+	};
+	defineIndexGetter(0);
+	let indexerDefined = 1;
+	Object.defineProperty(set, "length", {
+		get() {
+			dLength();
+			const length = this.size;
+			for (indexerDefined; indexerDefined < length + 1; indexerDefined++) {
+				defineIndexGetter(indexerDefined);
+			}
+			return length;
 		},
-		ids: (object, { origin, module }, { compilation: { chunkGraph } }) => {
-			object.originId = chunkGraph.getModuleId(origin);
-			object.moduleId = chunkGraph.getModuleId(module);
-		}
-	},
-	moduleTraceDependency: {
-		_: (object, dependency) => {
-			object.loc = formatLocation(dependency.loc);
+		set(value) {
+			throw new Error(
+				`${name} was changed from Array to Set (writing to Array property 'length' is not possible)`
+			);
 		}
-	}
+	});
+	set[Symbol.isConcatSpreadable] = true;
 };
 
-/** @type {Record<string, Record<string, (thing: any, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
-const FILTER = {
-	"module.reasons": {
-		"!orphanModules": (reason, { compilation: { chunkGraph } }) => {
-			if (
-				reason.originModule &&
-				chunkGraph.getNumberOfModuleChunks(reason.originModule) === 0
-			) {
-				return false;
+exports.createArrayToSetDeprecationSet = name => {
+	let initialized = false;
+	class SetDeprecatedArray extends Set {
+		constructor(items) {
+			super(items);
+			if (!initialized) {
+				initialized = true;
+				exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
 			}
 		}
 	}
+	return SetDeprecatedArray;
 };
 
-/** @type {Record<string, Record<string, (thing: Object, context: StatsFactoryContext, options: NormalizedStatsOptions) => boolean | undefined>>} */
-const FILTER_RESULTS = {
-	"compilation.warnings": {
-		warningsFilter: util.deprecate(
-			(warning, context, { warningsFilter }) => {
-				const warningString = Object.keys(warning)
-					.map(key => `${warning[key]}`)
-					.join("\n");
-				return !warningsFilter.some(filter => filter(warning, warningString));
-			},
-			"config.stats.warningsFilter is deprecated in favor of config.ignoreWarnings",
-			"DEP_WEBPACK_STATS_WARNINGS_FILTER"
+exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
+	const message = `${name} will be frozen in future, all modifications are deprecated.${
+		note && `\n${note}`
+	}`;
+	return new Proxy(obj, {
+		set: util.deprecate(
+			(target, property, value, receiver) =>
+				Reflect.set(target, property, value, receiver),
+			message,
+			code
+		),
+		defineProperty: util.deprecate(
+			(target, property, descriptor) =>
+				Reflect.defineProperty(target, property, descriptor),
+			message,
+			code
+		),
+		deleteProperty: util.deprecate(
+			(target, property) => Reflect.deleteProperty(target, property),
+			message,
+			code
+		),
+		setPrototypeOf: util.deprecate(
+			(target, proto) => Reflect.setPrototypeOf(target, proto),
+			message,
+			code
 		)
+	});
+};
+
+/**
+ * @template T
+ * @param {T} obj object
+ * @param {string} message deprecation message
+ * @param {string} code deprecation code
+ * @returns {T} object with property access deprecated
+ */
+const deprecateAllProperties = (obj, message, code) => {
+	const newObj = {};
+	const descriptors = Object.getOwnPropertyDescriptors(obj);
+	for (const name of Object.keys(descriptors)) {
+		const descriptor = descriptors[name];
+		if (typeof descriptor.value === "function") {
+			Object.defineProperty(newObj, name, {
+				...descriptor,
+				value: util.deprecate(descriptor.value, message, code)
+			});
+		} else if (descriptor.get || descriptor.set) {
+			Object.defineProperty(newObj, name, {
+				...descriptor,
+				get: descriptor.get && util.deprecate(descriptor.get, message, code),
+				set: descriptor.set && util.deprecate(descriptor.set, message, code)
+			});
+		} else {
+			let value = descriptor.value;
+			Object.defineProperty(newObj, name, {
+				configurable: descriptor.configurable,
+				enumerable: descriptor.enumerable,
+				get: util.deprecate(() => value, message, code),
+				set: descriptor.writable
+					? util.deprecate(v => (value = v), message, code)
+					: undefined
+			});
+		}
 	}
+	return /** @type {T} */ (newObj);
 };
+exports.deprecateAllProperties = deprecateAllProperties;
 
-/** @type {Record<string, (comparators: Function[], context: StatsFactoryContext) => void>} */
-const MODULES_SORTER = {
-	_: (comparators, { compilation: { moduleGraph } }) => {
-		comparators.push(
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {number} depth
-				 */
-				m => moduleGraph.getDepth(m),
-				compareNumbers
-			),
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {number} index
-				 */
-				m => moduleGraph.getPreOrderIndex(m),
-				compareNumbers
-			),
-			compareSelect(
-				/**
-				 * @param {Module} m module
-				 * @returns {string} identifier
-				 */
-				m => m.identifier(),
-				compareIds
-			)
-		);
+/**
+ * @template T
+ * @param {T} fakeHook fake hook implementation
+ * @param {string=} message deprecation message (not deprecated when unset)
+ * @param {string=} code deprecation code (not deprecated when unset)
+ * @returns {FakeHook<T>} fake hook which redirects
+ */
+exports.createFakeHook = (fakeHook, message, code) => {
+	if (message && code) {
+		fakeHook = deprecateAllProperties(fakeHook, message, code);
 	}
+	return Object.freeze(
+		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
+	);
 };
 
-/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext) => void>>} */
-const SORTERS = {
-	"compilation.chunks": {
-		_: comparators => {
-			comparators.push(compareSelect(c => c.id, compareIds));
-		}
-	},
-	"compilation.modules": MODULES_SORTER,
-	"chunk.rootModules": MODULES_SORTER,
-	"chunk.modules": MODULES_SORTER,
-	"module.modules": MODULES_SORTER,
-	"module.reasons": {
-		_: (comparators, { compilation: { chunkGraph } }) => {
-			comparators.push(
-				compareSelect(x => x.originModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect(x => x.resolvedOriginModule, compareModulesByIdentifier)
-			);
-			comparators.push(
-				compareSelect(
-					x => x.dependency,
-					concatComparators(
-						compareSelect(
-							/**
-							 * @param {Dependency} x dependency
-							 * @returns {DependencyLocation} location
-							 */
-							x => x.loc,
-							compareLocations
-						),
-						compareSelect(x => x.type, compareIds)
-					)
-				)
-			);
+
+/***/ }),
+
+/***/ 59836:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+// Simulations show these probabilities for a single change
+// 93.1% that one group is invalidated
+// 4.8% that two groups are invalidated
+// 1.1% that 3 groups are invalidated
+// 0.1% that 4 or more groups are invalidated
+//
+// And these for removing/adding 10 lexically adjacent files
+// 64.5% that one group is invalidated
+// 24.8% that two groups are invalidated
+// 7.8% that 3 groups are invalidated
+// 2.7% that 4 or more groups are invalidated
+//
+// And these for removing/adding 3 random files
+// 0% that one group is invalidated
+// 3.7% that two groups are invalidated
+// 80.8% that 3 groups are invalidated
+// 12.3% that 4 groups are invalidated
+// 3.2% that 5 or more groups are invalidated
+
+/**
+ *
+ * @param {string} a key
+ * @param {string} b key
+ * @returns {number} the similarity as number
+ */
+const similarity = (a, b) => {
+	const l = Math.min(a.length, b.length);
+	let dist = 0;
+	for (let i = 0; i < l; i++) {
+		const ca = a.charCodeAt(i);
+		const cb = b.charCodeAt(i);
+		dist += Math.max(0, 10 - Math.abs(ca - cb));
+	}
+	return dist;
+};
+
+/**
+ * @param {string} a key
+ * @param {string} b key
+ * @param {Set<string>} usedNames set of already used names
+ * @returns {string} the common part and a single char for the difference
+ */
+const getName = (a, b, usedNames) => {
+	const l = Math.min(a.length, b.length);
+	let i = 0;
+	while (i < l) {
+		if (a.charCodeAt(i) !== b.charCodeAt(i)) {
+			i++;
+			break;
 		}
-	},
-	"chunk.origins": {
-		_: (comparators, { compilation: { chunkGraph } }) => {
-			comparators.push(
-				compareSelect(
-					origin =>
-						origin.module ? chunkGraph.getModuleId(origin.module) : undefined,
-					compareIds
-				),
-				compareSelect(origin => formatLocation(origin.loc), compareIds),
-				compareSelect(origin => origin.request, compareIds)
-			);
+		i++;
+	}
+	while (i < l) {
+		const name = a.slice(0, i);
+		const lowerName = name.toLowerCase();
+		if (!usedNames.has(lowerName)) {
+			usedNames.add(lowerName);
+			return name;
 		}
+		i++;
 	}
+	// names always contain a hash, so this is always unique
+	// we don't need to check usedNames nor add it
+	return a;
 };
 
-const getItemSize = item => {
-	// Each item takes 1 line
-	// + the size of the children
-	// + 1 extra line when it has children and filteredChildren
-	return !item.children
-		? 1
-		: item.filteredChildren
-		? 2 + getTotalSize(item.children)
-		: 1 + getTotalSize(item.children);
+/**
+ * @param {Record<string, number>} total total size
+ * @param {Record<string, number>} size single size
+ * @returns {void}
+ */
+const addSizeTo = (total, size) => {
+	for (const key of Object.keys(size)) {
+		total[key] = (total[key] || 0) + size[key];
+	}
 };
 
-const getTotalSize = children => {
-	let size = 0;
-	for (const child of children) {
-		size += getItemSize(child);
+/**
+ * @param {Record<string, number>} total total size
+ * @param {Record<string, number>} size single size
+ * @returns {void}
+ */
+const subtractSizeFrom = (total, size) => {
+	for (const key of Object.keys(size)) {
+		total[key] -= size[key];
 	}
-	return size;
 };
 
-const getTotalItems = children => {
-	let count = 0;
-	for (const child of children) {
-		if (!child.children && !child.filteredChildren) {
-			count++;
-		} else {
-			if (child.children) count += getTotalItems(child.children);
-			if (child.filteredChildren) count += child.filteredChildren;
-		}
+/**
+ * @param {Iterable<Node>} nodes some nodes
+ * @returns {Record<string, number>} total size
+ */
+const sumSize = nodes => {
+	const sum = Object.create(null);
+	for (const node of nodes) {
+		addSizeTo(sum, node.size);
 	}
-	return count;
+	return sum;
 };
 
-const collapse = children => {
-	// After collapse each child must take exactly one line
-	const newChildren = [];
-	for (const child of children) {
-		if (child.children) {
-			let filteredChildren = child.filteredChildren || 0;
-			filteredChildren += getTotalItems(child.children);
-			newChildren.push({
-				...child,
-				children: undefined,
-				filteredChildren
-			});
-		} else {
-			newChildren.push(child);
+const isTooBig = (size, maxSize) => {
+	for (const key of Object.keys(size)) {
+		const s = size[key];
+		if (s === 0) continue;
+		const maxSizeValue = maxSize[key];
+		if (typeof maxSizeValue === "number") {
+			if (s > maxSizeValue) return true;
 		}
 	}
-	return newChildren;
+	return false;
 };
 
-const spaceLimited = (
-	itemsAndGroups,
-	max,
-	filteredChildrenLineReserved = false
-) => {
-	if (max < 1) {
-		return {
-			children: undefined,
-			filteredChildren: getTotalItems(itemsAndGroups)
-		};
+const isTooSmall = (size, minSize) => {
+	for (const key of Object.keys(size)) {
+		const s = size[key];
+		if (s === 0) continue;
+		const minSizeValue = minSize[key];
+		if (typeof minSizeValue === "number") {
+			if (s < minSizeValue) return true;
+		}
 	}
-	/** @type {any[] | undefined} */
-	let children = undefined;
-	/** @type {number | undefined} */
-	let filteredChildren = undefined;
-	// This are the groups, which take 1+ lines each
-	const groups = [];
-	// The sizes of the groups are stored in groupSizes
-	const groupSizes = [];
-	// This are the items, which take 1 line each
-	const items = [];
-	// The total of group sizes
-	let groupsSize = 0;
+	return false;
+};
 
-	for (const itemOrGroup of itemsAndGroups) {
-		// is item
-		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
-			items.push(itemOrGroup);
-		} else {
-			groups.push(itemOrGroup);
-			const size = getItemSize(itemOrGroup);
-			groupSizes.push(size);
-			groupsSize += size;
+const getTooSmallTypes = (size, minSize) => {
+	const types = new Set();
+	for (const key of Object.keys(size)) {
+		const s = size[key];
+		if (s === 0) continue;
+		const minSizeValue = minSize[key];
+		if (typeof minSizeValue === "number") {
+			if (s < minSizeValue) types.add(key);
 		}
 	}
+	return types;
+};
 
-	if (groupsSize + items.length <= max) {
-		// The total size in the current state fits into the max
-		// keep all
-		children = groups.length > 0 ? groups.concat(items) : items;
-	} else if (groups.length === 0) {
-		// slice items to max
-		// inner space marks that lines for filteredChildren already reserved
-		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
-		filteredChildren = items.length - limit;
-		items.length = limit;
-		children = items;
-	} else {
-		// limit is the size when all groups are collapsed
-		const limit =
-			groups.length +
-			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
-		if (limit < max) {
-			// calculate how much we are over the size limit
-			// this allows to approach the limit faster
-			let oversize;
-			// If each group would take 1 line the total would be below the maximum
-			// collapse some groups, keep items
-			while (
-				(oversize =
-					groupsSize +
-					items.length +
-					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
-					max) > 0
-			) {
-				// Find the maximum group and process only this one
-				const maxGroupSize = Math.max(...groupSizes);
-				if (maxGroupSize < items.length) {
-					filteredChildren = items.length;
-					items.length = 0;
-					continue;
-				}
-				for (let i = 0; i < groups.length; i++) {
-					if (groupSizes[i] === maxGroupSize) {
-						const group = groups[i];
-						// run this algorithm recursively and limit the size of the children to
-						// current size - oversize / number of groups
-						// So it should always end up being smaller
-						const headerSize = group.filteredChildren ? 2 : 1;
-						const limited = spaceLimited(
-							group.children,
-							maxGroupSize -
-								// we should use ceil to always feet in max
-								Math.ceil(oversize / groups.length) -
-								// we substitute size of group head
-								headerSize,
-							headerSize === 2
-						);
-						groups[i] = {
-							...group,
-							children: limited.children,
-							filteredChildren: limited.filteredChildren
-								? (group.filteredChildren || 0) + limited.filteredChildren
-								: group.filteredChildren
-						};
-						const newSize = getItemSize(groups[i]);
-						groupsSize -= maxGroupSize - newSize;
-						groupSizes[i] = newSize;
-						break;
-					}
+const getNumberOfMatchingSizeTypes = (size, types) => {
+	let i = 0;
+	for (const key of Object.keys(size)) {
+		if (size[key] !== 0 && types.has(key)) i++;
+	}
+	return i;
+};
+
+const selectiveSizeSum = (size, types) => {
+	let sum = 0;
+	for (const key of Object.keys(size)) {
+		if (size[key] !== 0 && types.has(key)) sum += size[key];
+	}
+	return sum;
+};
+
+/**
+ * @template T
+ */
+class Node {
+	/**
+	 * @param {T} item item
+	 * @param {string} key key
+	 * @param {Record<string, number>} size size
+	 */
+	constructor(item, key, size) {
+		this.item = item;
+		this.key = key;
+		this.size = size;
+	}
+}
+
+/**
+ * @template T
+ */
+class Group {
+	/**
+	 * @param {Node<T>[]} nodes nodes
+	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
+	 * @param {Record<string, number>=} size size of the group
+	 */
+	constructor(nodes, similarities, size) {
+		this.nodes = nodes;
+		this.similarities = similarities;
+		this.size = size || sumSize(nodes);
+		/** @type {string} */
+		this.key = undefined;
+	}
+
+	/**
+	 * @param {function(Node): boolean} filter filter function
+	 * @returns {Node[]} removed nodes
+	 */
+	popNodes(filter) {
+		const newNodes = [];
+		const newSimilarities = [];
+		const resultNodes = [];
+		let lastNode;
+		for (let i = 0; i < this.nodes.length; i++) {
+			const node = this.nodes[i];
+			if (filter(node)) {
+				resultNodes.push(node);
+			} else {
+				if (newNodes.length > 0) {
+					newSimilarities.push(
+						lastNode === this.nodes[i - 1]
+							? this.similarities[i - 1]
+							: similarity(lastNode.key, node.key)
+					);
 				}
+				newNodes.push(node);
+				lastNode = node;
 			}
-			children = groups.concat(items);
-		} else if (limit === max) {
-			// If we have only enough space to show one line per group and one line for the filtered items
-			// collapse all groups and items
-			children = collapse(groups);
-			filteredChildren = items.length;
-		} else {
-			// If we have no space
-			// collapse complete group
-			filteredChildren = getTotalItems(itemsAndGroups);
 		}
+		if (resultNodes.length === this.nodes.length) return undefined;
+		this.nodes = newNodes;
+		this.similarities = newSimilarities;
+		this.size = sumSize(newNodes);
+		return resultNodes;
 	}
+}
 
-	return {
-		children,
-		filteredChildren
-	};
-};
-
-const assetGroup = (children, assets) => {
-	let size = 0;
-	for (const asset of children) {
-		size += asset.size;
-	}
-	return {
-		size
-	};
-};
-
-const moduleGroup = (children, modules) => {
-	let size = 0;
-	const sizes = {};
-	for (const module of children) {
-		size += module.size;
-		for (const key of Object.keys(module.sizes)) {
-			sizes[key] = (sizes[key] || 0) + module.sizes[key];
+/**
+ * @param {Iterable<Node>} nodes nodes
+ * @returns {number[]} similarities
+ */
+const getSimilarities = nodes => {
+	// calculate similarities between lexically adjacent nodes
+	/** @type {number[]} */
+	const similarities = [];
+	let last = undefined;
+	for (const node of nodes) {
+		if (last !== undefined) {
+			similarities.push(similarity(last.key, node.key));
 		}
+		last = node;
 	}
-	return {
-		size,
-		sizes
-	};
+	return similarities;
 };
 
-const reasonGroup = (children, reasons) => {
-	let active = false;
-	for (const reason of children) {
-		active = active || reason.active;
+/**
+ * @template T
+ * @typedef {Object} GroupedItems<T>
+ * @property {string} key
+ * @property {T[]} items
+ * @property {Record<string, number>} size
+ */
+
+/**
+ * @template T
+ * @typedef {Object} Options
+ * @property {Record<string, number>} maxSize maximum size of a group
+ * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
+ * @property {Iterable<T>} items a list of items
+ * @property {function(T): Record<string, number>} getSize function to get size of an item
+ * @property {function(T): string} getKey function to get the key of an item
+ */
+
+/**
+ * @template T
+ * @param {Options<T>} options options object
+ * @returns {GroupedItems<T>[]} grouped items
+ */
+module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
+	/** @type {Group<T>[]} */
+	const result = [];
+
+	const nodes = Array.from(
+		items,
+		item => new Node(item, getKey(item), getSize(item))
+	);
+
+	/** @type {Node<T>[]} */
+	const initialNodes = [];
+
+	// lexically ordering of keys
+	nodes.sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+
+	// return nodes bigger than maxSize directly as group
+	// But make sure that minSize is not violated
+	for (const node of nodes) {
+		if (isTooBig(node.size, maxSize) && !isTooSmall(node.size, minSize)) {
+			result.push(new Group([node], []));
+		} else {
+			initialNodes.push(node);
+		}
 	}
-	return {
-		active
-	};
-};
 
-const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
-const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+	if (initialNodes.length > 0) {
+		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
 
-/** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
-const ASSETS_GROUPERS = {
-	_: (groupConfigs, context, options) => {
-		const groupByFlag = (name, exclude) => {
-			groupConfigs.push({
-				getKeys: asset => {
-					return asset[name] ? ["1"] : undefined;
-				},
-				getOptions: () => {
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, assets) => {
-					return exclude
-						? {
-								type: "assets by status",
-								[name]: !!key,
-								filteredChildren: assets.length,
-								...assetGroup(children, assets)
-						  }
-						: {
-								type: "assets by status",
-								[name]: !!key,
-								children,
-								...assetGroup(children, assets)
-						  };
+		const removeProblematicNodes = (group, consideredSize = group.size) => {
+			const problemTypes = getTooSmallTypes(consideredSize, minSize);
+			if (problemTypes.size > 0) {
+				// We hit an edge case where the working set is already smaller than minSize
+				// We merge problematic nodes with the smallest result node to keep minSize intact
+				const problemNodes = group.popNodes(
+					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
+				);
+				if (problemNodes === undefined) return false;
+				// Only merge it with result nodes that have the problematic size type
+				const possibleResultGroups = result.filter(
+					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
+				);
+				if (possibleResultGroups.length > 0) {
+					const bestGroup = possibleResultGroups.reduce((min, group) => {
+						const minMatches = getNumberOfMatchingSizeTypes(min, problemTypes);
+						const groupMatches = getNumberOfMatchingSizeTypes(
+							group,
+							problemTypes
+						);
+						if (minMatches !== groupMatches)
+							return minMatches < groupMatches ? group : min;
+						if (
+							selectiveSizeSum(min.size, problemTypes) >
+							selectiveSizeSum(group.size, problemTypes)
+						)
+							return group;
+						return min;
+					});
+					for (const node of problemNodes) bestGroup.nodes.push(node);
+					bestGroup.nodes.sort((a, b) => {
+						if (a.key < b.key) return -1;
+						if (a.key > b.key) return 1;
+						return 0;
+					});
+				} else {
+					// There are no other nodes with the same size types
+					// We create a new group and have to accept that it's smaller than minSize
+					result.push(new Group(problemNodes, null));
 				}
-			});
+				return true;
+			} else {
+				return false;
+			}
 		};
-		const {
-			groupAssetsByEmitStatus,
-			groupAssetsByPath,
-			groupAssetsByExtension
-		} = options;
-		if (groupAssetsByEmitStatus) {
-			groupByFlag("emitted");
-			groupByFlag("comparedForEmit");
-			groupByFlag("isOverSizeLimit");
-		}
-		if (groupAssetsByEmitStatus || !options.cachedAssets) {
-			groupByFlag("cached", !options.cachedAssets);
-		}
-		if (groupAssetsByPath || groupAssetsByExtension) {
-			groupConfigs.push({
-				getKeys: asset => {
-					const extensionMatch =
-						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
-					const extension = extensionMatch ? extensionMatch[1] : "";
-					const pathMatch =
-						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
-					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
-					const keys = [];
-					if (groupAssetsByPath) {
-						keys.push(".");
-						if (extension)
-							keys.push(
-								path.length
-									? `${path.join("/")}/*${extension}`
-									: `*${extension}`
-							);
-						while (path.length > 0) {
-							keys.push(path.join("/") + "/");
-							path.pop();
-						}
-					} else {
-						if (extension) keys.push(`*${extension}`);
-					}
-					return keys;
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: groupAssetsByPath ? "assets by path" : "assets by extension",
-						name: key,
-						children,
-						...assetGroup(children, assets)
-					};
-				}
-			});
-		}
-	},
-	groupAssetsByInfo: (groupConfigs, context, options) => {
-		const groupByAssetInfoFlag = name => {
-			groupConfigs.push({
-				getKeys: asset => {
-					return asset.info && asset.info[name] ? ["1"] : undefined;
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: "assets by info",
-						info: {
-							[name]: !!key
-						},
-						children,
-						...assetGroup(children, assets)
-					};
+
+		if (initialGroup.nodes.length > 0) {
+			const queue = [initialGroup];
+
+			while (queue.length) {
+				const group = queue.pop();
+				// only groups bigger than maxSize need to be splitted
+				if (!isTooBig(group.size, maxSize)) {
+					result.push(group);
+					continue;
 				}
-			});
-		};
-		groupByAssetInfoFlag("immutable");
-		groupByAssetInfoFlag("development");
-		groupByAssetInfoFlag("hotModuleReplacement");
-	},
-	groupAssetsByChunk: (groupConfigs, context, options) => {
-		const groupByNames = name => {
-			groupConfigs.push({
-				getKeys: asset => {
-					return asset[name];
-				},
-				createGroup: (key, children, assets) => {
-					return {
-						type: "assets by chunk",
-						[name]: [key],
-						children,
-						...assetGroup(children, assets)
-					};
+				// If the group is already too small
+				// we try to work only with the unproblematic nodes
+				if (removeProblematicNodes(group)) {
+					// This changed something, so we try this group again
+					queue.push(group);
+					continue;
 				}
-			});
-		};
-		groupByNames("chunkNames");
-		groupByNames("auxiliaryChunkNames");
-		groupByNames("chunkIdHints");
-		groupByNames("auxiliaryChunkIdHints");
-	},
-	excludeAssets: (groupConfigs, context, { excludeAssets }) => {
-		groupConfigs.push({
-			getKeys: asset => {
-				const ident = asset.name;
-				const excluded = excludeAssets.some(fn => fn(ident, asset));
-				if (excluded) return ["excluded"];
-			},
-			getOptions: () => ({
-				groupChildren: false,
-				force: true
-			}),
-			createGroup: (key, children, assets) => ({
-				type: "hidden assets",
-				filteredChildren: assets.length,
-				...assetGroup(children, assets)
-			})
-		});
-	}
-};
 
-/** @type {function("module" | "chunk" | "root-of-chunk" | "nested"): Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
-const MODULES_GROUPERS = type => ({
-	_: (groupConfigs, context, options) => {
-		const groupByFlag = (name, type, exclude) => {
-			groupConfigs.push({
-				getKeys: module => {
-					return module[name] ? ["1"] : undefined;
-				},
-				getOptions: () => {
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, modules) => {
-					return {
-						type,
-						[name]: !!key,
-						...(exclude ? { filteredChildren: modules.length } : { children }),
-						...moduleGroup(children, modules)
-					};
+				// find unsplittable area from left and right
+				// going minSize from left and right
+				// at least one node need to be included otherwise we get stuck
+				let left = 1;
+				let leftSize = Object.create(null);
+				addSizeTo(leftSize, group.nodes[0].size);
+				while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
+					addSizeTo(leftSize, group.nodes[left].size);
+					left++;
 				}
-			});
-		};
-		const {
-			groupModulesByCacheStatus,
-			groupModulesByLayer,
-			groupModulesByAttributes,
-			groupModulesByType,
-			groupModulesByPath,
-			groupModulesByExtension
-		} = options;
-		if (groupModulesByAttributes) {
-			groupByFlag("errors", "modules with errors");
-			groupByFlag("warnings", "modules with warnings");
-			groupByFlag("assets", "modules with assets");
-			groupByFlag("optional", "optional modules");
-		}
-		if (groupModulesByCacheStatus) {
-			groupByFlag("cacheable", "cacheable modules");
-			groupByFlag("built", "built modules");
-			groupByFlag("codeGenerated", "code generated modules");
-		}
-		if (groupModulesByCacheStatus || !options.cachedModules) {
-			groupByFlag("cached", "cached modules", !options.cachedModules);
-		}
-		if (groupModulesByAttributes || !options.orphanModules) {
-			groupByFlag("orphan", "orphan modules", !options.orphanModules);
-		}
-		if (groupModulesByAttributes || !options.dependentModules) {
-			groupByFlag("dependent", "dependent modules", !options.dependentModules);
-		}
-		if (groupModulesByType || !options.runtimeModules) {
-			groupConfigs.push({
-				getKeys: module => {
-					if (!module.moduleType) return;
-					if (groupModulesByType) {
-						return [module.moduleType.split("/", 1)[0]];
-					} else if (module.moduleType === "runtime") {
-						return ["runtime"];
-					}
-				},
-				getOptions: key => {
-					const exclude = key === "runtime" && !options.runtimeModules;
-					return {
-						groupChildren: !exclude,
-						force: exclude
-					};
-				},
-				createGroup: (key, children, modules) => {
-					const exclude = key === "runtime" && !options.runtimeModules;
-					return {
-						type: `${key} modules`,
-						moduleType: key,
-						...(exclude ? { filteredChildren: modules.length } : { children }),
-						...moduleGroup(children, modules)
-					};
+				let right = group.nodes.length - 2;
+				let rightSize = Object.create(null);
+				addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
+				while (right >= 0 && isTooSmall(rightSize, minSize)) {
+					addSizeTo(rightSize, group.nodes[right].size);
+					right--;
 				}
-			});
-		}
-		if (groupModulesByLayer) {
-			groupConfigs.push({
-				getKeys: module => {
-					return [module.layer];
-				},
-				createGroup: (key, children, modules) => {
-					return {
-						type: "modules by layer",
-						layer: key,
-						children,
-						...moduleGroup(children, modules)
-					};
+
+				//      left v   v right
+				// [ O O O ] O O O [ O O O ]
+				// ^^^^^^^^^ leftSize
+				//       rightSize ^^^^^^^^^
+				// leftSize > minSize
+				// rightSize > minSize
+
+				// Perfect split: [ O O O ] [ O O O ]
+				//                right === left - 1
+
+				if (left - 1 > right) {
+					// We try to remove some problematic nodes to "fix" that
+					let prevSize;
+					if (right < group.nodes.length - left) {
+						subtractSizeFrom(rightSize, group.nodes[right + 1].size);
+						prevSize = rightSize;
+					} else {
+						subtractSizeFrom(leftSize, group.nodes[left - 1].size);
+						prevSize = leftSize;
+					}
+					if (removeProblematicNodes(group, prevSize)) {
+						// This changed something, so we try this group again
+						queue.push(group);
+						continue;
+					}
+					// can't split group while holding minSize
+					// because minSize is preferred of maxSize we return
+					// the problematic nodes as result here even while it's too big
+					// To avoid this make sure maxSize > minSize * 3
+					result.push(group);
+					continue;
 				}
-			});
-		}
-		if (groupModulesByPath || groupModulesByExtension) {
-			groupConfigs.push({
-				getKeys: module => {
-					if (!module.name) return;
-					const resource = parseResource(module.name.split("!").pop()).path;
-					const dataUrl = /^data:[^,;]+/.exec(resource);
-					if (dataUrl) return [dataUrl[0]];
-					const extensionMatch =
-						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
-					const extension = extensionMatch ? extensionMatch[1] : "";
-					const pathMatch =
-						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
-					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
-					const keys = [];
-					if (groupModulesByPath) {
-						if (extension)
-							keys.push(
-								path.length
-									? `${path.join("/")}/*${extension}`
-									: `*${extension}`
-							);
-						while (path.length > 0) {
-							keys.push(path.join("/") + "/");
-							path.pop();
+				if (left <= right) {
+					// when there is a area between left and right
+					// we look for best split point
+					// we split at the minimum similarity
+					// here key space is separated the most
+					// But we also need to make sure to not create too small groups
+					let best = -1;
+					let bestSimilarity = Infinity;
+					let pos = left;
+					let rightSize = sumSize(group.nodes.slice(pos));
+
+					//       pos v   v right
+					// [ O O O ] O O O [ O O O ]
+					// ^^^^^^^^^ leftSize
+					// rightSize ^^^^^^^^^^^^^^^
+
+					while (pos <= right + 1) {
+						const similarity = group.similarities[pos - 1];
+						if (
+							similarity < bestSimilarity &&
+							!isTooSmall(leftSize, minSize) &&
+							!isTooSmall(rightSize, minSize)
+						) {
+							best = pos;
+							bestSimilarity = similarity;
 						}
-					} else {
-						if (extension) keys.push(`*${extension}`);
+						addSizeTo(leftSize, group.nodes[pos].size);
+						subtractSizeFrom(rightSize, group.nodes[pos].size);
+						pos++;
 					}
-					return keys;
-				},
-				createGroup: (key, children, modules) => {
-					const isDataUrl = key.startsWith("data:");
-					return {
-						type: isDataUrl
-							? "modules by mime type"
-							: groupModulesByPath
-							? "modules by path"
-							: "modules by extension",
-						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
-						children,
-						...moduleGroup(children, modules)
-					};
+					if (best < 0) {
+						// This can't happen
+						// but if that assumption is wrong
+						// fallback to a big group
+						result.push(group);
+						continue;
+					}
+					left = best;
+					right = best - 1;
 				}
-			});
-		}
-	},
-	excludeModules: (groupConfigs, context, { excludeModules }) => {
-		groupConfigs.push({
-			getKeys: module => {
-				const name = module.name;
-				if (name) {
-					const excluded = excludeModules.some(fn => fn(name, module, type));
-					if (excluded) return ["1"];
+
+				// create two new groups for left and right area
+				// and queue them up
+				const rightNodes = [group.nodes[right + 1]];
+				/** @type {number[]} */
+				const rightSimilarities = [];
+				for (let i = right + 2; i < group.nodes.length; i++) {
+					rightSimilarities.push(group.similarities[i - 1]);
+					rightNodes.push(group.nodes[i]);
 				}
-			},
-			getOptions: () => ({
-				groupChildren: false,
-				force: true
-			}),
-			createGroup: (key, children, modules) => ({
-				type: "hidden modules",
-				filteredChildren: children.length,
-				...moduleGroup(children, modules)
-			})
-		});
-	}
-});
+				queue.push(new Group(rightNodes, rightSimilarities));
 
-/** @type {Record<string, Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
-const RESULT_GROUPERS = {
-	"compilation.assets": ASSETS_GROUPERS,
-	"asset.related": ASSETS_GROUPERS,
-	"compilation.modules": MODULES_GROUPERS("module"),
-	"chunk.modules": MODULES_GROUPERS("chunk"),
-	"chunk.rootModules": MODULES_GROUPERS("root-of-chunk"),
-	"module.modules": MODULES_GROUPERS("nested"),
-	"module.reasons": {
-		groupReasonsByOrigin: groupConfigs => {
-			groupConfigs.push({
-				getKeys: reason => {
-					return [reason.module];
-				},
-				createGroup: (key, children, reasons) => {
-					return {
-						type: "from origin",
-						module: key,
-						children,
-						...reasonGroup(children, reasons)
-					};
+				const leftNodes = [group.nodes[0]];
+				/** @type {number[]} */
+				const leftSimilarities = [];
+				for (let i = 1; i < left; i++) {
+					leftSimilarities.push(group.similarities[i - 1]);
+					leftNodes.push(group.nodes[i]);
 				}
-			});
+				queue.push(new Group(leftNodes, leftSimilarities));
+			}
 		}
 	}
-};
 
-// remove a prefixed "!" that can be specified to reverse sort order
-const normalizeFieldKey = field => {
-	if (field[0] === "!") {
-		return field.substr(1);
-	}
-	return field;
-};
+	// lexically ordering
+	result.sort((a, b) => {
+		if (a.nodes[0].key < b.nodes[0].key) return -1;
+		if (a.nodes[0].key > b.nodes[0].key) return 1;
+		return 0;
+	});
 
-// if a field is prefixed by a "!" reverse sort order
-const sortOrderRegular = field => {
-	if (field[0] === "!") {
-		return false;
+	// give every group a name
+	const usedNames = new Set();
+	for (let i = 0; i < result.length; i++) {
+		const group = result[i];
+		if (group.nodes.length === 1) {
+			group.key = group.nodes[0].key;
+		} else {
+			const first = group.nodes[0];
+			const last = group.nodes[group.nodes.length - 1];
+			const name = getName(first.key, last.key, usedNames);
+			group.key = name;
+		}
 	}
-	return true;
+
+	// return the results
+	return result.map(group => {
+		/** @type {GroupedItems} */
+		return {
+			key: group.key,
+			items: group.nodes.map(node => node.item),
+			size: group.size
+		};
+	});
 };
 
+
+/***/ }),
+
+/***/ 11850:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Sam Chen @chenxsan
+*/
+
+
+
 /**
- * @param {string} field field name
- * @returns {function(Object, Object): number} comparators
+ * @param {string} urlAndGlobal the script request
+ * @returns {string[]} script url and its global variable
  */
-const sortByField = field => {
-	if (!field) {
-		/**
-		 * @param {any} a first
-		 * @param {any} b second
-		 * @returns {-1|0|1} zero
-		 */
-		const noSort = (a, b) => 0;
-		return noSort;
+module.exports = function extractUrlAndGlobal(urlAndGlobal) {
+	const index = urlAndGlobal.indexOf("@");
+	if (index <= 0 || index === urlAndGlobal.length - 1) {
+		throw new Error(`Invalid request "${urlAndGlobal}"`);
 	}
+	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
+};
 
-	const fieldKey = normalizeFieldKey(field);
 
-	let sortFn = compareSelect(m => m[fieldKey], compareIds);
+/***/ }),
 
-	// if a field is prefixed with a "!" the sort is reversed!
-	const sortIsRegular = sortOrderRegular(field);
+/***/ 6261:
+/***/ (function(module) {
 
-	if (!sortIsRegular) {
-		const oldSortFn = sortFn;
-		sortFn = (a, b) => oldSortFn(b, a);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	return sortFn;
-};
 
-const ASSET_SORTERS = {
-	/** @type {(comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void} */
-	assetsSort: (comparators, context, { assetsSort }) => {
-		comparators.push(sortByField(assetsSort));
-	},
-	_: comparators => {
-		comparators.push(compareSelect(a => a.name, compareIds));
-	}
-};
 
-/** @type {Record<string, Record<string, (comparators: Function[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>>} */
-const RESULT_SORTERS = {
-	"compilation.chunks": {
-		chunksSort: (comparators, context, { chunksSort }) => {
-			comparators.push(sortByField(chunksSort));
-		}
-	},
-	"compilation.modules": {
-		modulesSort: (comparators, context, { modulesSort }) => {
-			comparators.push(sortByField(modulesSort));
-		}
-	},
-	"chunk.modules": {
-		chunkModulesSort: (comparators, context, { chunkModulesSort }) => {
-			comparators.push(sortByField(chunkModulesSort));
-		}
-	},
-	"module.modules": {
-		nestedModulesSort: (comparators, context, { nestedModulesSort }) => {
-			comparators.push(sortByField(nestedModulesSort));
-		}
-	},
-	"compilation.assets": ASSET_SORTERS,
-	"asset.related": ASSET_SORTERS
-};
+const NO_MARKER = 0;
+const IN_PROGRESS_MARKER = 1;
+const DONE_MARKER = 2;
+const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
+const DONE_AND_ROOT_MARKER = 4;
 
 /**
- * @param {Record<string, Record<string, Function>>} config the config see above
- * @param {NormalizedStatsOptions} options stats options
- * @param {function(string, Function): void} fn handler function called for every active line in config
- * @returns {void}
+ * @template T
  */
-const iterateConfig = (config, options, fn) => {
-	for (const hookFor of Object.keys(config)) {
-		const subConfig = config[hookFor];
-		for (const option of Object.keys(subConfig)) {
-			if (option !== "_") {
-				if (option.startsWith("!")) {
-					if (options[option.slice(1)]) continue;
-				} else {
-					const value = options[option];
-					if (
-						value === false ||
-						value === undefined ||
-						(Array.isArray(value) && value.length === 0)
-					)
-						continue;
-				}
-			}
-			fn(hookFor, subConfig[option]);
-		}
+class Node {
+	/**
+	 * @param {T} item the value of the node
+	 */
+	constructor(item) {
+		this.item = item;
+		/** @type {Set<Node<T>>} */
+		this.dependencies = new Set();
+		this.marker = NO_MARKER;
+		/** @type {Cycle<T> | undefined} */
+		this.cycle = undefined;
+		this.incoming = 0;
 	}
-};
+}
 
-/** @type {Record<string, string>} */
-const ITEM_NAMES = {
-	"compilation.children[]": "compilation",
-	"compilation.modules[]": "module",
-	"compilation.entrypoints[]": "chunkGroup",
-	"compilation.namedChunkGroups[]": "chunkGroup",
-	"compilation.errors[]": "error",
-	"compilation.warnings[]": "warning",
-	"chunk.modules[]": "module",
-	"chunk.rootModules[]": "module",
-	"chunk.origins[]": "chunkOrigin",
-	"compilation.chunks[]": "chunk",
-	"compilation.assets[]": "asset",
-	"asset.related[]": "asset",
-	"module.issuerPath[]": "moduleIssuer",
-	"module.reasons[]": "moduleReason",
-	"module.modules[]": "module",
-	"module.children[]": "module",
-	"moduleTrace[]": "moduleTraceItem",
-	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
-};
+/**
+ * @template T
+ */
+class Cycle {
+	constructor() {
+		/** @type {Set<Node<T>>} */
+		this.nodes = new Set();
+	}
+}
 
 /**
- * @param {Object[]} items items to be merged
- * @returns {Object} an object
+ * @template T
+ * @typedef {Object} StackEntry
+ * @property {Node<T>} node
+ * @property {Node<T>[]} openEdges
  */
-const mergeToObject = items => {
-	const obj = Object.create(null);
+
+/**
+ * @template T
+ * @param {Iterable<T>} items list of items
+ * @param {function(T): Iterable<T>} getDependencies function to get dependencies of an item (items that are not in list are ignored)
+ * @returns {Iterable<T>} graph roots of the items
+ */
+module.exports = (items, getDependencies) => {
+	/** @type {Map<T, Node<T>>} */
+	const itemToNode = new Map();
 	for (const item of items) {
-		obj[item.name] = item;
+		const node = new Node(item);
+		itemToNode.set(item, node);
 	}
-	return obj;
-};
 
-/** @type {Record<string, (items: Object[]) => any>} */
-const MERGER = {
-	"compilation.entrypoints": mergeToObject,
-	"compilation.namedChunkGroups": mergeToObject
-};
+	// early exit when there is only a single item
+	if (itemToNode.size <= 1) return items;
 
-class DefaultStatsFactoryPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsFactoryPlugin", compilation => {
-			compilation.hooks.statsFactory.tap(
-				"DefaultStatsFactoryPlugin",
-				(stats, options, context) => {
-					iterateConfig(SIMPLE_EXTRACTORS, options, (hookFor, fn) => {
-						stats.hooks.extract
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (obj, data, ctx) =>
-								fn(obj, data, ctx, options, stats)
-							);
-					});
-					iterateConfig(FILTER, options, (hookFor, fn) => {
-						stats.hooks.filter
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
-								fn(item, ctx, options, idx, i)
-							);
-					});
-					iterateConfig(FILTER_RESULTS, options, (hookFor, fn) => {
-						stats.hooks.filterResults
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (item, ctx, idx, i) =>
-								fn(item, ctx, options, idx, i)
-							);
-					});
-					iterateConfig(SORTERS, options, (hookFor, fn) => {
-						stats.hooks.sort
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
-								fn(comparators, ctx, options)
-							);
-					});
-					iterateConfig(RESULT_SORTERS, options, (hookFor, fn) => {
-						stats.hooks.sortResults
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (comparators, ctx) =>
-								fn(comparators, ctx, options)
-							);
-					});
-					iterateConfig(RESULT_GROUPERS, options, (hookFor, fn) => {
-						stats.hooks.groupResults
-							.for(hookFor)
-							.tap("DefaultStatsFactoryPlugin", (groupConfigs, ctx) =>
-								fn(groupConfigs, ctx, options)
-							);
-					});
-					for (const key of Object.keys(ITEM_NAMES)) {
-						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap("DefaultStatsFactoryPlugin", () => itemName);
-					}
-					for (const key of Object.keys(MERGER)) {
-						const merger = MERGER[key];
-						stats.hooks.merge.for(key).tap("DefaultStatsFactoryPlugin", merger);
-					}
-					if (options.children) {
-						if (Array.isArray(options.children)) {
-							stats.hooks.getItemFactory
-								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", (comp, { _index: idx }) => {
-									if (idx < options.children.length) {
-										return compilation.createStatsFactory(
-											compilation.createStatsOptions(
-												options.children[idx],
-												context
-											)
-										);
+	// grab all the dependencies
+	for (const node of itemToNode.values()) {
+		for (const dep of getDependencies(node.item)) {
+			const depNode = itemToNode.get(dep);
+			if (depNode !== undefined) {
+				node.dependencies.add(depNode);
+			}
+		}
+	}
+
+	// Set of current root modules
+	// items will be removed if a new reference to it has been found
+	/** @type {Set<Node<T>>} */
+	const roots = new Set();
+
+	// Set of current cycles without references to it
+	// cycles will be removed if a new reference to it has been found
+	// that is not part of the cycle
+	/** @type {Set<Cycle<T>>} */
+	const rootCycles = new Set();
+
+	// For all non-marked nodes
+	for (const selectedNode of itemToNode.values()) {
+		if (selectedNode.marker === NO_MARKER) {
+			// deep-walk all referenced modules
+			// in a non-recursive way
+
+			// start by entering the selected node
+			selectedNode.marker = IN_PROGRESS_MARKER;
+
+			// keep a stack to avoid recursive walk
+			/** @type {StackEntry<T>[]} */
+			const stack = [
+				{
+					node: selectedNode,
+					openEdges: Array.from(selectedNode.dependencies)
+				}
+			];
+
+			// process the top item until stack is empty
+			while (stack.length > 0) {
+				const topOfStack = stack[stack.length - 1];
+
+				// Are there still edges unprocessed in the current node?
+				if (topOfStack.openEdges.length > 0) {
+					// Process one dependency
+					const dependency = topOfStack.openEdges.pop();
+					switch (dependency.marker) {
+						case NO_MARKER:
+							// dependency has not be visited yet
+							// mark it as in-progress and recurse
+							stack.push({
+								node: dependency,
+								openEdges: Array.from(dependency.dependencies)
+							});
+							dependency.marker = IN_PROGRESS_MARKER;
+							break;
+						case IN_PROGRESS_MARKER: {
+							// It's a in-progress cycle
+							let cycle = dependency.cycle;
+							if (!cycle) {
+								cycle = new Cycle();
+								cycle.nodes.add(dependency);
+								dependency.cycle = cycle;
+							}
+							// set cycle property for each node in the cycle
+							// if nodes are already part of a cycle
+							// we merge the cycles to a shared cycle
+							for (
+								let i = stack.length - 1;
+								stack[i].node !== dependency;
+								i--
+							) {
+								const node = stack[i].node;
+								if (node.cycle) {
+									if (node.cycle !== cycle) {
+										// merge cycles
+										for (const cycleNode of node.cycle.nodes) {
+											cycleNode.cycle = cycle;
+											cycle.nodes.add(cycleNode);
+										}
 									}
-								});
-						} else if (options.children !== true) {
-							const childFactory = compilation.createStatsFactory(
-								compilation.createStatsOptions(options.children, context)
-							);
-							stats.hooks.getItemFactory
-								.for("compilation.children[].compilation")
-								.tap("DefaultStatsFactoryPlugin", () => {
-									return childFactory;
-								});
+								} else {
+									node.cycle = cycle;
+									cycle.nodes.add(node);
+								}
+							}
+							// don't recurse into dependencies
+							// these are already on the stack
+							break;
 						}
+						case DONE_AND_ROOT_MARKER:
+							// This node has be visited yet and is currently a root node
+							// But as this is a new reference to the node
+							// it's not really a root
+							// so we have to convert it to a normal node
+							dependency.marker = DONE_MARKER;
+							roots.delete(dependency);
+							break;
+						case DONE_MAYBE_ROOT_CYCLE_MARKER:
+							// This node has be visited yet and
+							// is maybe currently part of a completed root cycle
+							// we found a new reference to the cycle
+							// so it's not really a root cycle
+							// remove the cycle from the root cycles
+							// and convert it to a normal node
+							rootCycles.delete(dependency.cycle);
+							dependency.marker = DONE_MARKER;
+							break;
+						// DONE_MARKER: nothing to do, don't recurse into dependencies
 					}
+				} else {
+					// All dependencies of the current node has been visited
+					// we leave the node
+					stack.pop();
+					topOfStack.node.marker = DONE_MARKER;
 				}
-			);
-		});
+			}
+			const cycle = selectedNode.cycle;
+			if (cycle) {
+				for (const node of cycle.nodes) {
+					node.marker = DONE_MAYBE_ROOT_CYCLE_MARKER;
+				}
+				rootCycles.add(cycle);
+			} else {
+				selectedNode.marker = DONE_AND_ROOT_MARKER;
+				roots.add(selectedNode);
+			}
+		}
 	}
-}
-module.exports = DefaultStatsFactoryPlugin;
+
+	// Extract roots from root cycles
+	// We take the nodes with most incoming edges
+	// inside of the cycle
+	for (const cycle of rootCycles) {
+		let max = 0;
+		/** @type {Set<Node<T>>} */
+		const cycleRoots = new Set();
+		const nodes = cycle.nodes;
+		for (const node of nodes) {
+			for (const dep of node.dependencies) {
+				if (nodes.has(dep)) {
+					dep.incoming++;
+					if (dep.incoming < max) continue;
+					if (dep.incoming > max) {
+						cycleRoots.clear();
+						max = dep.incoming;
+					}
+					cycleRoots.add(dep);
+				}
+			}
+		}
+		for (const cycleRoot of cycleRoots) {
+			roots.add(cycleRoot);
+		}
+	}
+
+	// When roots were found, return them
+	if (roots.size > 0) {
+		return Array.from(roots, r => r.item);
+	} else {
+		throw new Error("Implementation of findGraphRoots is broken");
+	}
+};
 
 
 /***/ }),
 
-/***/ 55442:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 17139:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -126055,330 +126149,417 @@ module.exports = DefaultStatsFactoryPlugin;
 
 
 
-const RequestShortener = __webpack_require__(73406);
+const path = __webpack_require__(71017);
 
-/** @typedef {import("../../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
-/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
+/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 
-const applyDefaults = (options, defaults) => {
-	for (const key of Object.keys(defaults)) {
-		if (typeof options[key] === "undefined") {
-			options[key] = defaults[key];
-		}
-	}
-};
+/**
+ * @typedef {Object} IStats
+ * @property {() => boolean} isFile
+ * @property {() => boolean} isDirectory
+ * @property {() => boolean} isBlockDevice
+ * @property {() => boolean} isCharacterDevice
+ * @property {() => boolean} isSymbolicLink
+ * @property {() => boolean} isFIFO
+ * @property {() => boolean} isSocket
+ * @property {number | bigint} dev
+ * @property {number | bigint} ino
+ * @property {number | bigint} mode
+ * @property {number | bigint} nlink
+ * @property {number | bigint} uid
+ * @property {number | bigint} gid
+ * @property {number | bigint} rdev
+ * @property {number | bigint} size
+ * @property {number | bigint} blksize
+ * @property {number | bigint} blocks
+ * @property {number | bigint} atimeMs
+ * @property {number | bigint} mtimeMs
+ * @property {number | bigint} ctimeMs
+ * @property {number | bigint} birthtimeMs
+ * @property {Date} atime
+ * @property {Date} mtime
+ * @property {Date} ctime
+ * @property {Date} birthtime
+ */
 
-const NAMED_PRESETS = {
-	verbose: {
-		hash: true,
-		builtAt: true,
-		relatedAssets: true,
-		entrypoints: true,
-		chunkGroups: true,
-		ids: true,
-		modules: false,
-		chunks: true,
-		chunkRelations: true,
-		chunkModules: true,
-		dependentModules: true,
-		chunkOrigins: true,
-		depth: true,
-		env: true,
-		reasons: true,
-		usedExports: true,
-		providedExports: true,
-		optimizationBailout: true,
-		errorDetails: true,
-		errorStack: true,
-		publicPath: true,
-		logging: "verbose",
-		orphanModules: true,
-		runtimeModules: true,
-		exclude: false,
-		modulesSpace: Infinity,
-		chunkModulesSpace: Infinity,
-		assetsSpace: Infinity,
-		reasonsSpace: Infinity,
-		children: true
-	},
-	detailed: {
-		hash: true,
-		builtAt: true,
-		relatedAssets: true,
-		entrypoints: true,
-		chunkGroups: true,
-		ids: true,
-		chunks: true,
-		chunkRelations: true,
-		chunkModules: false,
-		chunkOrigins: true,
-		depth: true,
-		usedExports: true,
-		providedExports: true,
-		optimizationBailout: true,
-		errorDetails: true,
-		publicPath: true,
-		logging: true,
-		runtimeModules: true,
-		exclude: false,
-		modulesSpace: 1000,
-		assetsSpace: 1000,
-		reasonsSpace: 1000
-	},
-	minimal: {
-		all: false,
-		version: true,
-		timings: true,
-		modules: true,
-		modulesSpace: 0,
-		assets: true,
-		assetsSpace: 0,
-		errors: true,
-		errorsCount: true,
-		warnings: true,
-		warningsCount: true,
-		logging: "warn"
-	},
-	"errors-only": {
-		all: false,
-		errors: true,
-		errorsCount: true,
-		moduleTrace: true,
-		logging: "error"
-	},
-	"errors-warnings": {
-		all: false,
-		errors: true,
-		errorsCount: true,
-		warnings: true,
-		warningsCount: true,
-		logging: "warn"
-	},
-	summary: {
-		all: false,
-		version: true,
-		errorsCount: true,
-		warningsCount: true
-	},
-	none: {
-		all: false
-	}
-};
+/**
+ * @typedef {Object} IDirent
+ * @property {() => boolean} isFile
+ * @property {() => boolean} isDirectory
+ * @property {() => boolean} isBlockDevice
+ * @property {() => boolean} isCharacterDevice
+ * @property {() => boolean} isSymbolicLink
+ * @property {() => boolean} isFIFO
+ * @property {() => boolean} isSocket
+ * @property {string | Buffer} name
+ */
 
-const NORMAL_ON = ({ all }) => all !== false;
-const NORMAL_OFF = ({ all }) => all === true;
-const ON_FOR_TO_STRING = ({ all }, { forToString }) =>
-	forToString ? all !== false : all === true;
-const OFF_FOR_TO_STRING = ({ all }, { forToString }) =>
-	forToString ? all === true : all !== false;
-const AUTO_FOR_TO_STRING = ({ all }, { forToString }) => {
-	if (all === false) return false;
-	if (all === true) return true;
-	if (forToString) return "auto";
-	return true;
-};
+/** @typedef {function((NodeJS.ErrnoException | null)=): void} Callback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer=): void} BufferCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer|string=): void} BufferOrStringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, string=): void} StringCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, number=): void} NumberCallback */
+/** @typedef {function((NodeJS.ErrnoException | null)=, IStats=): void} StatsCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
+/** @typedef {function((NodeJS.ErrnoException | Error | null)=, IStats|string=): void} LstatReadlinkAbsoluteCallback */
 
-/** @type {Record<string, (options: StatsOptions, context: CreateStatsOptionsContext, compilation: Compilation) => any>} */
-const DEFAULTS = {
-	context: (options, context, compilation) => compilation.compiler.context,
-	requestShortener: (options, context, compilation) =>
-		compilation.compiler.context === options.context
-			? compilation.requestShortener
-			: new RequestShortener(options.context, compilation.compiler.root),
-	performance: NORMAL_ON,
-	hash: OFF_FOR_TO_STRING,
-	env: NORMAL_OFF,
-	version: NORMAL_ON,
-	timings: NORMAL_ON,
-	builtAt: OFF_FOR_TO_STRING,
-	assets: NORMAL_ON,
-	entrypoints: AUTO_FOR_TO_STRING,
-	chunkGroups: OFF_FOR_TO_STRING,
-	chunkGroupAuxiliary: OFF_FOR_TO_STRING,
-	chunkGroupChildren: OFF_FOR_TO_STRING,
-	chunkGroupMaxAssets: (o, { forToString }) => (forToString ? 5 : Infinity),
-	chunks: OFF_FOR_TO_STRING,
-	chunkRelations: OFF_FOR_TO_STRING,
-	chunkModules: ({ all, modules }) => {
-		if (all === false) return false;
-		if (all === true) return true;
-		if (modules) return false;
-		return true;
-	},
-	dependentModules: OFF_FOR_TO_STRING,
-	chunkOrigins: OFF_FOR_TO_STRING,
-	ids: OFF_FOR_TO_STRING,
-	modules: ({ all, chunks, chunkModules }, { forToString }) => {
-		if (all === false) return false;
-		if (all === true) return true;
-		if (forToString && chunks && chunkModules) return false;
-		return true;
-	},
-	nestedModules: OFF_FOR_TO_STRING,
-	groupModulesByType: ON_FOR_TO_STRING,
-	groupModulesByCacheStatus: ON_FOR_TO_STRING,
-	groupModulesByLayer: ON_FOR_TO_STRING,
-	groupModulesByAttributes: ON_FOR_TO_STRING,
-	groupModulesByPath: ON_FOR_TO_STRING,
-	groupModulesByExtension: ON_FOR_TO_STRING,
-	modulesSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-	chunkModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
-	nestedModulesSpace: (o, { forToString }) => (forToString ? 10 : Infinity),
-	relatedAssets: OFF_FOR_TO_STRING,
-	groupAssetsByEmitStatus: ON_FOR_TO_STRING,
-	groupAssetsByInfo: ON_FOR_TO_STRING,
-	groupAssetsByPath: ON_FOR_TO_STRING,
-	groupAssetsByExtension: ON_FOR_TO_STRING,
-	groupAssetsByChunk: ON_FOR_TO_STRING,
-	assetsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-	orphanModules: OFF_FOR_TO_STRING,
-	runtimeModules: ({ all, runtime }, { forToString }) =>
-		runtime !== undefined
-			? runtime
-			: forToString
-			? all === true
-			: all !== false,
-	cachedModules: ({ all, cached }, { forToString }) =>
-		cached !== undefined ? cached : forToString ? all === true : all !== false,
-	moduleAssets: OFF_FOR_TO_STRING,
-	depth: OFF_FOR_TO_STRING,
-	cachedAssets: OFF_FOR_TO_STRING,
-	reasons: OFF_FOR_TO_STRING,
-	reasonsSpace: (o, { forToString }) => (forToString ? 15 : Infinity),
-	groupReasonsByOrigin: ON_FOR_TO_STRING,
-	usedExports: OFF_FOR_TO_STRING,
-	providedExports: OFF_FOR_TO_STRING,
-	optimizationBailout: OFF_FOR_TO_STRING,
-	children: OFF_FOR_TO_STRING,
-	source: NORMAL_OFF,
-	moduleTrace: NORMAL_ON,
-	errors: NORMAL_ON,
-	errorsCount: NORMAL_ON,
-	errorDetails: AUTO_FOR_TO_STRING,
-	errorStack: OFF_FOR_TO_STRING,
-	warnings: NORMAL_ON,
-	warningsCount: NORMAL_ON,
-	publicPath: OFF_FOR_TO_STRING,
-	logging: ({ all }, { forToString }) =>
-		forToString && all !== false ? "info" : false,
-	loggingDebug: () => [],
-	loggingTrace: OFF_FOR_TO_STRING,
-	excludeModules: () => [],
-	excludeAssets: () => [],
-	modulesSort: () => "depth",
-	chunkModulesSort: () => "name",
-	nestedModulesSort: () => false,
-	chunksSort: () => false,
-	assetsSort: () => "!size",
-	outputPath: OFF_FOR_TO_STRING,
-	colors: () => false
-};
+/**
+ * @typedef {Object} WatcherInfo
+ * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
+ * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} fileTimeInfoEntries get info about files
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} contextTimeInfoEntries get info about directories
+ */
 
-const normalizeFilter = item => {
-	if (typeof item === "string") {
-		const regExp = new RegExp(
-			`[\\\\/]${item.replace(
-				// eslint-disable-next-line no-useless-escape
-				/[-[\]{}()*+?.\\^$|]/g,
-				"\\$&"
-			)}([\\\\/]|$|!|\\?)`
+// TODO webpack 6 deprecate missing getInfo
+/**
+ * @typedef {Object} Watcher
+ * @property {function(): void} close closes the watcher and all underlying file watchers
+ * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
+ * @property {function(): Set<string>=} getAggregatedChanges get current aggregated changes that have not yet send to callback
+ * @property {function(): Set<string>=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
+ * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getFileTimeInfoEntries get info about files
+ * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getContextTimeInfoEntries get info about directories
+ * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
+ */
+
+/**
+ * @callback WatchMethod
+ * @param {Iterable<string>} files watched files
+ * @param {Iterable<string>} directories watched directories
+ * @param {Iterable<string>} missing watched exitance entries
+ * @param {number} startTime timestamp of start time
+ * @param {WatchOptions} options options object
+ * @param {function(Error=, Map<string, FileSystemInfoEntry | "ignore">, Map<string, FileSystemInfoEntry | "ignore">, Set<string>, Set<string>): void} callback aggregated callback
+ * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
+ * @returns {Watcher} a watcher
+ */
+
+// TODO webpack 6 make optional methods required
+
+/**
+ * @typedef {Object} OutputFileSystem
+ * @property {function(string, Buffer|string, Callback): void} writeFile
+ * @property {function(string, Callback): void} mkdir
+ * @property {function(string, DirentArrayCallback): void=} readdir
+ * @property {function(string, Callback): void=} rmdir
+ * @property {function(string, Callback): void=} unlink
+ * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
+ * @property {function(string, BufferOrStringCallback): void} readFile
+ * @property {(function(string, string): string)=} join
+ * @property {(function(string, string): string)=} relative
+ * @property {(function(string): string)=} dirname
+ */
+
+/**
+ * @typedef {Object} InputFileSystem
+ * @property {function(string, BufferOrStringCallback): void} readFile
+ * @property {(function(string, ReadJsonCallback): void)=} readJson
+ * @property {function(string, BufferOrStringCallback): void} readlink
+ * @property {function(string, DirentArrayCallback): void} readdir
+ * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
+ * @property {(function(string, BufferOrStringCallback): void)=} realpath
+ * @property {(function(string=): void)=} purge
+ * @property {(function(string, string): string)=} join
+ * @property {(function(string, string): string)=} relative
+ * @property {(function(string): string)=} dirname
+ */
+
+/**
+ * @typedef {Object} WatchFileSystem
+ * @property {WatchMethod} watch
+ */
+
+/**
+ * @typedef {Object} IntermediateFileSystemExtras
+ * @property {function(string): void} mkdirSync
+ * @property {function(string): NodeJS.WritableStream} createWriteStream
+ * @property {function(string, string, NumberCallback): void} open
+ * @property {function(number, Buffer, number, number, number, NumberCallback): void} read
+ * @property {function(number, Callback): void} close
+ * @property {function(string, string, Callback): void} rename
+ */
+
+/** @typedef {InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras} IntermediateFileSystem */
+
+/**
+ *
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} rootPath the root path
+ * @param {string} targetPath the target path
+ * @returns {string} location of targetPath relative to rootPath
+ */
+const relative = (fs, rootPath, targetPath) => {
+	if (fs && fs.relative) {
+		return fs.relative(rootPath, targetPath);
+	} else if (path.posix.isAbsolute(rootPath)) {
+		return path.posix.relative(rootPath, targetPath);
+	} else if (path.win32.isAbsolute(rootPath)) {
+		return path.win32.relative(rootPath, targetPath);
+	} else {
+		throw new Error(
+			`${rootPath} is neither a posix nor a windows path, and there is no 'relative' method defined in the file system`
 		);
-		return ident => regExp.test(ident);
-	}
-	if (item && typeof item === "object" && typeof item.test === "function") {
-		return ident => item.test(ident);
 	}
-	if (typeof item === "function") {
-		return item;
+};
+exports.relative = relative;
+
+/**
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} rootPath a path
+ * @param {string} filename a filename
+ * @returns {string} the joined path
+ */
+const join = (fs, rootPath, filename) => {
+	if (fs && fs.join) {
+		return fs.join(rootPath, filename);
+	} else if (path.posix.isAbsolute(rootPath)) {
+		return path.posix.join(rootPath, filename);
+	} else if (path.win32.isAbsolute(rootPath)) {
+		return path.win32.join(rootPath, filename);
+	} else {
+		throw new Error(
+			`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`
+		);
 	}
-	if (typeof item === "boolean") {
-		return () => item;
+};
+exports.join = join;
+
+/**
+ * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
+ * @param {string} absPath an absolute path
+ * @returns {string} the parent directory of the absolute path
+ */
+const dirname = (fs, absPath) => {
+	if (fs && fs.dirname) {
+		return fs.dirname(absPath);
+	} else if (path.posix.isAbsolute(absPath)) {
+		return path.posix.dirname(absPath);
+	} else if (path.win32.isAbsolute(absPath)) {
+		return path.win32.dirname(absPath);
+	} else {
+		throw new Error(
+			`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`
+		);
 	}
 };
+exports.dirname = dirname;
+
+/**
+ * @param {OutputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {function(Error=): void} callback callback function for the error
+ * @returns {void}
+ */
+const mkdirp = (fs, p, callback) => {
+	fs.mkdir(p, err => {
+		if (err) {
+			if (err.code === "ENOENT") {
+				const dir = dirname(fs, p);
+				if (dir === p) {
+					callback(err);
+					return;
+				}
+				mkdirp(fs, dir, err => {
+					if (err) {
+						callback(err);
+						return;
+					}
+					fs.mkdir(p, err => {
+						if (err) {
+							if (err.code === "EEXIST") {
+								callback();
+								return;
+							}
+							callback(err);
+							return;
+						}
+						callback();
+					});
+				});
+				return;
+			} else if (err.code === "EEXIST") {
+				callback();
+				return;
+			}
+			callback(err);
+			return;
+		}
+		callback();
+	});
+};
+exports.mkdirp = mkdirp;
 
-const NORMALIZER = {
-	excludeModules: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
-		}
-		return value.map(normalizeFilter);
-	},
-	excludeAssets: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
+/**
+ * @param {IntermediateFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @returns {void}
+ */
+const mkdirpSync = (fs, p) => {
+	try {
+		fs.mkdirSync(p);
+	} catch (err) {
+		if (err) {
+			if (err.code === "ENOENT") {
+				const dir = dirname(fs, p);
+				if (dir === p) {
+					throw err;
+				}
+				mkdirpSync(fs, dir);
+				fs.mkdirSync(p);
+				return;
+			} else if (err.code === "EEXIST") {
+				return;
+			}
+			throw err;
 		}
-		return value.map(normalizeFilter);
-	},
-	warningsFilter: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
+	}
+};
+exports.mkdirpSync = mkdirpSync;
+
+/**
+ * @param {InputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {ReadJsonCallback} callback callback
+ * @returns {void}
+ */
+const readJson = (fs, p, callback) => {
+	if ("readJson" in fs) return fs.readJson(p, callback);
+	fs.readFile(p, (err, buf) => {
+		if (err) return callback(err);
+		let data;
+		try {
+			data = JSON.parse(buf.toString("utf-8"));
+		} catch (e) {
+			return callback(e);
 		}
-		return value.map(filter => {
-			if (typeof filter === "string") {
-				return (warning, warningString) => warningString.includes(filter);
-			}
-			if (filter instanceof RegExp) {
-				return (warning, warningString) => filter.test(warningString);
-			}
-			if (typeof filter === "function") {
-				return filter;
+		return callback(null, data);
+	});
+};
+exports.readJson = readJson;
+
+/**
+ * @param {InputFileSystem} fs a file system
+ * @param {string} p an absolute path
+ * @param {ReadJsonCallback} callback callback
+ * @returns {void}
+ */
+const lstatReadlinkAbsolute = (fs, p, callback) => {
+	let i = 3;
+	const doReadLink = () => {
+		fs.readlink(p, (err, target) => {
+			if (err && --i > 0) {
+				// It might was just changed from symlink to file
+				// we retry 2 times to catch this case before throwing the error
+				return doStat();
 			}
-			throw new Error(
-				`Can only filter warnings with Strings or RegExps. (Given: ${filter})`
-			);
+			if (err || !target) return doStat();
+			const value = target.toString();
+			callback(null, join(fs, dirname(fs, p), value));
 		});
-	},
-	logging: value => {
-		if (value === true) value = "log";
-		return value;
-	},
-	loggingDebug: value => {
-		if (!Array.isArray(value)) {
-			value = value ? [value] : [];
+	};
+	const doStat = () => {
+		if ("lstat" in fs) {
+			return fs.lstat(p, (err, stats) => {
+				if (err) return callback(err);
+				if (stats.isSymbolicLink()) {
+					return doReadLink();
+				}
+				callback(null, stats);
+			});
+		} else {
+			return fs.stat(p, callback);
 		}
-		return value.map(normalizeFilter);
-	}
+	};
+	if ("lstat" in fs) return doStat();
+	doReadLink();
 };
+exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
+
+
+/***/ }),
+
+/***/ 59461:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const Hash = __webpack_require__(36692);
+const MAX_SHORT_STRING = (__webpack_require__(1842).MAX_SHORT_STRING);
+
+class BatchedHash extends Hash {
+	constructor(hash) {
+		super();
+		this.string = undefined;
+		this.encoding = undefined;
+		this.hash = hash;
+	}
 
-class DefaultStatsPresetPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
+	 * @param {string|Buffer} data data
+	 * @param {string=} inputEncoding data encoding
+	 * @returns {this} updated hash
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsPresetPlugin", compilation => {
-			for (const key of Object.keys(NAMED_PRESETS)) {
-				const defaults = NAMED_PRESETS[key];
-				compilation.hooks.statsPreset
-					.for(key)
-					.tap("DefaultStatsPresetPlugin", (options, context) => {
-						applyDefaults(options, defaults);
-					});
+	update(data, inputEncoding) {
+		if (this.string !== undefined) {
+			if (
+				typeof data === "string" &&
+				inputEncoding === this.encoding &&
+				this.string.length + data.length < MAX_SHORT_STRING
+			) {
+				this.string += data;
+				return this;
 			}
-			compilation.hooks.statsNormalize.tap(
-				"DefaultStatsPresetPlugin",
-				(options, context) => {
-					for (const key of Object.keys(DEFAULTS)) {
-						if (options[key] === undefined)
-							options[key] = DEFAULTS[key](options, context, compilation);
-					}
-					for (const key of Object.keys(NORMALIZER)) {
-						options[key] = NORMALIZER[key](options[key]);
-					}
-				}
-			);
-		});
+			this.hash.update(this.string, this.encoding);
+			this.string = undefined;
+		}
+		if (typeof data === "string") {
+			if (
+				data.length < MAX_SHORT_STRING &&
+				// base64 encoding is not valid since it may contain padding chars
+				(!inputEncoding || !inputEncoding.startsWith("ba"))
+			) {
+				this.string = data;
+				this.encoding = inputEncoding;
+			} else {
+				this.hash.update(data, inputEncoding);
+			}
+		} else {
+			this.hash.update(data);
+		}
+		return this;
+	}
+
+	/**
+	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+	 * @param {string=} encoding encoding of the return value
+	 * @returns {string|Buffer} digest
+	 */
+	digest(encoding) {
+		if (this.string !== undefined) {
+			this.hash.update(this.string, this.encoding);
+		}
+		return this.hash.digest(encoding);
 	}
 }
-module.exports = DefaultStatsPresetPlugin;
+
+module.exports = BatchedHash;
 
 
 /***/ }),
 
-/***/ 58692:
+/***/ 86884:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -126389,1685 +126570,1092 @@ module.exports = DefaultStatsPresetPlugin;
 
 
 
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("./StatsPrinter")} StatsPrinter */
-/** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
+const create = __webpack_require__(1842);
 
-const DATA_URI_CONTENT_LENGTH = 16;
+//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
+const md4 = new WebAssembly.Module(
+	Buffer.from(
+		// 2156 bytes
+		"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",
+		"base64"
+	)
+);
+//#endregion
 
-const plural = (n, singular, plural) => (n === 1 ? singular : plural);
+module.exports = create.bind(null, md4, [], 64, 32);
 
-/**
- * @param {Record<string, number>} sizes sizes by source type
- * @param {Object} options options
- * @param {(number) => string=} options.formatSize size formatter
- * @returns {string} text
- */
-const printSizes = (sizes, { formatSize = n => `${n}` }) => {
-	const keys = Object.keys(sizes);
-	if (keys.length > 1) {
-		return keys.map(key => `${formatSize(sizes[key])} (${key})`).join(" ");
-	} else if (keys.length === 1) {
-		return formatSize(sizes[keys[0]]);
-	}
-};
 
-const getResourceName = resource => {
-	const dataUrl = /^data:[^,]+,/.exec(resource);
-	if (!dataUrl) return resource;
+/***/ }),
 
-	const len = dataUrl[0].length + DATA_URI_CONTENT_LENGTH;
-	if (resource.length < len) return resource;
-	return `${resource.slice(
-		0,
-		Math.min(resource.length - /* '..'.length */ 2, len)
-	)}..`;
-};
+/***/ 1842:
+/***/ (function(module) {
 
-const getModuleName = name => {
-	const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
-	return [prefix, getResourceName(resource)];
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
 
-/**
- * @param {number} n a number
- * @returns {string} number as two digit string, leading 0
- */
-const twoDigit = n => (n >= 10 ? `${n}` : `0${n}`);
 
-const isValidId = id => {
-	return typeof id === "number" || id;
-};
+// 65536 is the size of a wasm memory page
+// 64 is the maximum chunk size for every possible wasm hash implementation
+// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
+// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
+const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 
-const moreCount = (list, count) => {
-	return list && list.length > 0 ? `+ ${count}` : `${count}`;
-};
+class WasmHash {
+	/**
+	 * @param {WebAssembly.Instance} instance wasm instance
+	 * @param {WebAssembly.Instance[]} instancesPool pool of instances
+	 * @param {number} chunkSize size of data chunks passed to wasm
+	 * @param {number} digestSize size of digest returned by wasm
+	 */
+	constructor(instance, instancesPool, chunkSize, digestSize) {
+		const exports = /** @type {any} */ (instance.exports);
+		exports.init();
+		this.exports = exports;
+		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+		this.buffered = 0;
+		this.instancesPool = instancesPool;
+		this.chunkSize = chunkSize;
+		this.digestSize = digestSize;
+	}
 
-/** @type {Record<string, (thing: any, context: StatsPrinterContext, printer: StatsPrinter) => string | void>} */
-const SIMPLE_PRINTERS = {
-	"compilation.summary!": (
-		_,
-		{
-			type,
-			bold,
-			green,
-			red,
-			yellow,
-			formatDateTime,
-			formatTime,
-			compilation: {
-				name,
-				hash,
-				version,
-				time,
-				builtAt,
-				errorsCount,
-				warningsCount
-			}
-		}
-	) => {
-		const root = type === "compilation.summary!";
-		const warningsMessage =
-			warningsCount > 0
-				? yellow(
-						`${warningsCount} ${plural(warningsCount, "warning", "warnings")}`
-				  )
-				: "";
-		const errorsMessage =
-			errorsCount > 0
-				? red(`${errorsCount} ${plural(errorsCount, "error", "errors")}`)
-				: "";
-		const timeMessage = root && time ? ` in ${formatTime(time)}` : "";
-		const hashMessage = hash ? ` (${hash})` : "";
-		const builtAtMessage =
-			root && builtAt ? `${formatDateTime(builtAt)}: ` : "";
-		const versionMessage = root && version ? `webpack ${version}` : "";
-		const nameMessage =
-			root && name
-				? bold(name)
-				: name
-				? `Child ${bold(name)}`
-				: root
-				? ""
-				: "Child";
-		const subjectMessage =
-			nameMessage && versionMessage
-				? `${nameMessage} (${versionMessage})`
-				: versionMessage || nameMessage || "webpack";
-		let statusMessage;
-		if (errorsMessage && warningsMessage) {
-			statusMessage = `compiled with ${errorsMessage} and ${warningsMessage}`;
-		} else if (errorsMessage) {
-			statusMessage = `compiled with ${errorsMessage}`;
-		} else if (warningsMessage) {
-			statusMessage = `compiled with ${warningsMessage}`;
-		} else if (errorsCount === 0 && warningsCount === 0) {
-			statusMessage = `compiled ${green("successfully")}`;
-		} else {
-			statusMessage = `compiled`;
-		}
-		if (
-			builtAtMessage ||
-			versionMessage ||
-			errorsMessage ||
-			warningsMessage ||
-			(errorsCount === 0 && warningsCount === 0) ||
-			timeMessage ||
-			hashMessage
-		)
-			return `${builtAtMessage}${subjectMessage} ${statusMessage}${timeMessage}${hashMessage}`;
-	},
-	"compilation.filteredWarningDetailsCount": count =>
-		count
-			? `${count} ${plural(
-					count,
-					"warning has",
-					"warnings have"
-			  )} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
-			: undefined,
-	"compilation.filteredErrorDetailsCount": (count, { yellow }) =>
-		count
-			? yellow(
-					`${count} ${plural(
-						count,
-						"error has",
-						"errors have"
-					)} detailed information that is not shown.\nUse 'stats.errorDetails: true' resp. '--stats-error-details' to show it.`
-			  )
-			: undefined,
-	"compilation.env": (env, { bold }) =>
-		env
-			? `Environment (--env): ${bold(JSON.stringify(env, null, 2))}`
-			: undefined,
-	"compilation.publicPath": (publicPath, { bold }) =>
-		`PublicPath: ${bold(publicPath || "(none)")}`,
-	"compilation.entrypoints": (entrypoints, context, printer) =>
-		Array.isArray(entrypoints)
-			? undefined
-			: printer.print(context.type, Object.values(entrypoints), {
-					...context,
-					chunkGroupKind: "Entrypoint"
-			  }),
-	"compilation.namedChunkGroups": (namedChunkGroups, context, printer) => {
-		if (!Array.isArray(namedChunkGroups)) {
-			const {
-				compilation: { entrypoints }
-			} = context;
-			let chunkGroups = Object.values(namedChunkGroups);
-			if (entrypoints) {
-				chunkGroups = chunkGroups.filter(
-					group =>
-						!Object.prototype.hasOwnProperty.call(entrypoints, group.name)
-				);
+	reset() {
+		this.buffered = 0;
+		this.exports.init();
+	}
+
+	/**
+	 * @param {Buffer | string} data data
+	 * @param {BufferEncoding=} encoding encoding
+	 * @returns {this} itself
+	 */
+	update(data, encoding) {
+		if (typeof data === "string") {
+			while (data.length > MAX_SHORT_STRING) {
+				this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
+				data = data.slice(MAX_SHORT_STRING);
 			}
-			return printer.print(context.type, chunkGroups, {
-				...context,
-				chunkGroupKind: "Chunk Group"
-			});
+			this._updateWithShortString(data, encoding);
+			return this;
 		}
-	},
-	"compilation.assetsByChunkName": () => "",
+		this._updateWithBuffer(data);
+		return this;
+	}
 
-	"compilation.filteredModules": (
-		filteredModules,
-		{ compilation: { modules } }
-	) =>
-		filteredModules > 0
-			? `${moreCount(modules, filteredModules)} ${plural(
-					filteredModules,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"compilation.filteredAssets": (filteredAssets, { compilation: { assets } }) =>
-		filteredAssets > 0
-			? `${moreCount(assets, filteredAssets)} ${plural(
-					filteredAssets,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
-	"compilation.logging": (logging, context, printer) =>
-		Array.isArray(logging)
-			? undefined
-			: printer.print(
-					context.type,
-					Object.entries(logging).map(([name, value]) => ({ ...value, name })),
-					context
-			  ),
-	"compilation.warningsInChildren!": (_, { yellow, compilation }) => {
-		if (
-			!compilation.children &&
-			compilation.warningsCount > 0 &&
-			compilation.warnings
-		) {
-			const childWarnings =
-				compilation.warningsCount - compilation.warnings.length;
-			if (childWarnings > 0) {
-				return yellow(
-					`${childWarnings} ${plural(
-						childWarnings,
-						"WARNING",
-						"WARNINGS"
-					)} in child compilations${
-						compilation.children
-							? ""
-							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
-					}`
-				);
+	/**
+	 * @param {string} data data
+	 * @param {BufferEncoding=} encoding encoding
+	 * @returns {void}
+	 */
+	_updateWithShortString(data, encoding) {
+		const { exports, buffered, mem, chunkSize } = this;
+		let endPos;
+		if (data.length < 70) {
+			if (!encoding || encoding === "utf-8" || encoding === "utf8") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					if (cc < 0x80) mem[endPos++] = cc;
+					else if (cc < 0x800) {
+						mem[endPos] = (cc >> 6) | 0xc0;
+						mem[endPos + 1] = (cc & 0x3f) | 0x80;
+						endPos += 2;
+					} else {
+						// bail-out for weird chars
+						endPos += mem.write(data.slice(i), endPos, encoding);
+						break;
+					}
+				}
+			} else if (encoding === "latin1") {
+				endPos = buffered;
+				for (let i = 0; i < data.length; i++) {
+					const cc = data.charCodeAt(i);
+					mem[endPos++] = cc;
+				}
+			} else {
+				endPos = buffered + mem.write(data, buffered, encoding);
 			}
+		} else {
+			endPos = buffered + mem.write(data, buffered, encoding);
 		}
-	},
-	"compilation.errorsInChildren!": (_, { red, compilation }) => {
-		if (
-			!compilation.children &&
-			compilation.errorsCount > 0 &&
-			compilation.errors
-		) {
-			const childErrors = compilation.errorsCount - compilation.errors.length;
-			if (childErrors > 0) {
-				return red(
-					`${childErrors} ${plural(
-						childErrors,
-						"ERROR",
-						"ERRORS"
-					)} in child compilations${
-						compilation.children
-							? ""
-							: " (Use 'stats.children: true' resp. '--stats-children' for more details)"
-					}`
-				);
+		if (endPos < chunkSize) {
+			this.buffered = endPos;
+		} else {
+			const l = endPos & ~(this.chunkSize - 1);
+			exports.update(l);
+			const newBuffered = endPos - l;
+			this.buffered = newBuffered;
+			if (newBuffered > 0) mem.copyWithin(0, l, endPos);
+		}
+	}
+
+	/**
+	 * @param {Buffer} data data
+	 * @returns {void}
+	 */
+	_updateWithBuffer(data) {
+		const { exports, buffered, mem } = this;
+		const length = data.length;
+		if (buffered + length < this.chunkSize) {
+			data.copy(mem, buffered, 0, length);
+			this.buffered += length;
+		} else {
+			const l = (buffered + length) & ~(this.chunkSize - 1);
+			if (l > 65536) {
+				let i = 65536 - buffered;
+				data.copy(mem, buffered, 0, i);
+				exports.update(65536);
+				const stop = l - buffered - 65536;
+				while (i < stop) {
+					data.copy(mem, 0, i, i + 65536);
+					exports.update(65536);
+					i += 65536;
+				}
+				data.copy(mem, 0, i, l - buffered);
+				exports.update(l - buffered - i);
+			} else {
+				data.copy(mem, buffered, 0, l - buffered);
+				exports.update(l);
 			}
+			const newBuffered = length + buffered - l;
+			this.buffered = newBuffered;
+			if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
 		}
-	},
+	}
 
-	"asset.type": type => type,
-	"asset.name": (name, { formatFilename, asset: { isOverSizeLimit } }) =>
-		formatFilename(name, isOverSizeLimit),
-	"asset.size": (
-		size,
-		{ asset: { isOverSizeLimit }, yellow, green, formatSize }
-	) => (isOverSizeLimit ? yellow(formatSize(size)) : formatSize(size)),
-	"asset.emitted": (emitted, { green, formatFlag }) =>
-		emitted ? green(formatFlag("emitted")) : undefined,
-	"asset.comparedForEmit": (comparedForEmit, { yellow, formatFlag }) =>
-		comparedForEmit ? yellow(formatFlag("compared for emit")) : undefined,
-	"asset.cached": (cached, { green, formatFlag }) =>
-		cached ? green(formatFlag("cached")) : undefined,
-	"asset.isOverSizeLimit": (isOverSizeLimit, { yellow, formatFlag }) =>
-		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
+	digest(type) {
+		const { exports, buffered, mem, digestSize } = this;
+		exports.final(buffered);
+		this.instancesPool.push(this);
+		const hex = mem.toString("latin1", 0, digestSize);
+		if (type === "hex") return hex;
+		if (type === "binary" || !type) return Buffer.from(hex, "hex");
+		return Buffer.from(hex, "hex").toString(type);
+	}
+}
 
-	"asset.info.immutable": (immutable, { green, formatFlag }) =>
-		immutable ? green(formatFlag("immutable")) : undefined,
-	"asset.info.javascriptModule": (javascriptModule, { formatFlag }) =>
-		javascriptModule ? formatFlag("javascript module") : undefined,
-	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
-		sourceFilename
-			? formatFlag(
-					sourceFilename === true
-						? "from source file"
-						: `from: ${sourceFilename}`
-			  )
-			: undefined,
-	"asset.info.development": (development, { green, formatFlag }) =>
-		development ? green(formatFlag("dev")) : undefined,
-	"asset.info.hotModuleReplacement": (
-		hotModuleReplacement,
-		{ green, formatFlag }
-	) => (hotModuleReplacement ? green(formatFlag("hmr")) : undefined),
-	"asset.separator!": () => "\n",
-	"asset.filteredRelated": (filteredRelated, { asset: { related } }) =>
-		filteredRelated > 0
-			? `${moreCount(related, filteredRelated)} related ${plural(
-					filteredRelated,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
-	"asset.filteredChildren": (filteredChildren, { asset: { children } }) =>
-		filteredChildren > 0
-			? `${moreCount(children, filteredChildren)} ${plural(
-					filteredChildren,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
+const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
+	if (instancesPool.length > 0) {
+		const old = instancesPool.pop();
+		old.reset();
+		return old;
+	} else {
+		return new WasmHash(
+			new WebAssembly.Instance(wasmModule),
+			instancesPool,
+			chunkSize,
+			digestSize
+		);
+	}
+};
 
-	assetChunk: (id, { formatChunkId }) => formatChunkId(id),
+module.exports = create;
+module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
 
-	assetChunkName: name => name,
-	assetChunkIdHint: name => name,
 
-	"module.type": type => (type !== "module" ? type : undefined),
-	"module.id": (id, { formatModuleId }) =>
-		isValidId(id) ? formatModuleId(id) : undefined,
-	"module.name": (name, { bold }) => {
-		const [prefix, resource] = getModuleName(name);
-		return `${prefix || ""}${bold(resource || "")}`;
-	},
-	"module.identifier": identifier => undefined,
-	"module.layer": (layer, { formatLayer }) =>
-		layer ? formatLayer(layer) : undefined,
-	"module.sizes": printSizes,
-	"module.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
-	"module.depth": (depth, { formatFlag }) =>
-		depth !== null ? formatFlag(`depth ${depth}`) : undefined,
-	"module.cacheable": (cacheable, { formatFlag, red }) =>
-		cacheable === false ? red(formatFlag("not cacheable")) : undefined,
-	"module.orphan": (orphan, { formatFlag, yellow }) =>
-		orphan ? yellow(formatFlag("orphan")) : undefined,
-	"module.runtime": (runtime, { formatFlag, yellow }) =>
-		runtime ? yellow(formatFlag("runtime")) : undefined,
-	"module.optional": (optional, { formatFlag, yellow }) =>
-		optional ? yellow(formatFlag("optional")) : undefined,
-	"module.dependent": (dependent, { formatFlag, cyan }) =>
-		dependent ? cyan(formatFlag("dependent")) : undefined,
-	"module.built": (built, { formatFlag, yellow }) =>
-		built ? yellow(formatFlag("built")) : undefined,
-	"module.codeGenerated": (codeGenerated, { formatFlag, yellow }) =>
-		codeGenerated ? yellow(formatFlag("code generated")) : undefined,
-	"module.buildTimeExecuted": (buildTimeExecuted, { formatFlag, green }) =>
-		buildTimeExecuted ? green(formatFlag("build time executed")) : undefined,
-	"module.cached": (cached, { formatFlag, green }) =>
-		cached ? green(formatFlag("cached")) : undefined,
-	"module.assets": (assets, { formatFlag, magenta }) =>
-		assets && assets.length
-			? magenta(
-					formatFlag(
-						`${assets.length} ${plural(assets.length, "asset", "assets")}`
-					)
-			  )
-			: undefined,
-	"module.warnings": (warnings, { formatFlag, yellow }) =>
-		warnings === true
-			? yellow(formatFlag("warnings"))
-			: warnings
-			? yellow(
-					formatFlag(`${warnings} ${plural(warnings, "warning", "warnings")}`)
-			  )
-			: undefined,
-	"module.errors": (errors, { formatFlag, red }) =>
-		errors === true
-			? red(formatFlag("errors"))
-			: errors
-			? red(formatFlag(`${errors} ${plural(errors, "error", "errors")}`))
-			: undefined,
-	"module.providedExports": (providedExports, { formatFlag, cyan }) => {
-		if (Array.isArray(providedExports)) {
-			if (providedExports.length === 0) return cyan(formatFlag("no exports"));
-			return cyan(formatFlag(`exports: ${providedExports.join(", ")}`));
+/***/ }),
+
+/***/ 35028:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const create = __webpack_require__(1842);
+
+//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
+const xxhash64 = new WebAssembly.Module(
+	Buffer.from(
+		// 1170 bytes
+		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrIIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqAYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEAgAiABNQIAQoeVr6+Ytt6bnn9+hUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAkIdiCAChUL5893xmfaZqxZ+IgJCIIggAoUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL",
+		"base64"
+	)
+);
+//#endregion
+
+module.exports = create.bind(null, xxhash64, [], 32, 16);
+
+
+/***/ }),
+
+/***/ 82186:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const path = __webpack_require__(71017);
+
+const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const SEGMENTS_SPLIT_REGEXP = /([|!])/;
+const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
+
+/**
+ * @typedef {Object} MakeRelativePathsCache
+ * @property {Map<string, Map<string, string>>=} relativePaths
+ */
+
+const relativePathToRequest = relativePath => {
+	if (relativePath === "") return "./.";
+	if (relativePath === "..") return "../.";
+	if (relativePath.startsWith("../")) return relativePath;
+	return `./${relativePath}`;
+};
+
+/**
+ * @param {string} context context for relative path
+ * @param {string} maybeAbsolutePath path to make relative
+ * @returns {string} relative path in request style
+ */
+const absoluteToRequest = (context, maybeAbsolutePath) => {
+	if (maybeAbsolutePath[0] === "/") {
+		if (
+			maybeAbsolutePath.length > 1 &&
+			maybeAbsolutePath[maybeAbsolutePath.length - 1] === "/"
+		) {
+			// this 'path' is actually a regexp generated by dynamic requires.
+			// Don't treat it as an absolute path.
+			return maybeAbsolutePath;
 		}
-	},
-	"module.usedExports": (usedExports, { formatFlag, cyan, module }) => {
-		if (usedExports !== true) {
-			if (usedExports === null) return cyan(formatFlag("used exports unknown"));
-			if (usedExports === false) return cyan(formatFlag("module unused"));
-			if (Array.isArray(usedExports)) {
-				if (usedExports.length === 0)
-					return cyan(formatFlag("no exports used"));
-				const providedExportsCount = Array.isArray(module.providedExports)
-					? module.providedExports.length
-					: null;
-				if (
-					providedExportsCount !== null &&
-					providedExportsCount === usedExports.length
-				) {
-					return cyan(formatFlag("all exports used"));
-				} else {
-					return cyan(
-						formatFlag(`only some exports used: ${usedExports.join(", ")}`)
-					);
-				}
-			}
+
+		const querySplitPos = maybeAbsolutePath.indexOf("?");
+		let resource =
+			querySplitPos === -1
+				? maybeAbsolutePath
+				: maybeAbsolutePath.slice(0, querySplitPos);
+		resource = relativePathToRequest(path.posix.relative(context, resource));
+		return querySplitPos === -1
+			? resource
+			: resource + maybeAbsolutePath.slice(querySplitPos);
+	}
+
+	if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
+		const querySplitPos = maybeAbsolutePath.indexOf("?");
+		let resource =
+			querySplitPos === -1
+				? maybeAbsolutePath
+				: maybeAbsolutePath.slice(0, querySplitPos);
+		resource = path.win32.relative(context, resource);
+		if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
+			resource = relativePathToRequest(
+				resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/")
+			);
 		}
-	},
-	"module.optimizationBailout[]": (optimizationBailout, { yellow }) =>
-		yellow(optimizationBailout),
-	"module.issuerPath": (issuerPath, { module }) =>
-		module.profile ? undefined : "",
-	"module.profile": profile => undefined,
-	"module.filteredModules": (filteredModules, { module: { modules } }) =>
-		filteredModules > 0
-			? `${moreCount(modules, filteredModules)} nested ${plural(
-					filteredModules,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"module.filteredReasons": (filteredReasons, { module: { reasons } }) =>
-		filteredReasons > 0
-			? `${moreCount(reasons, filteredReasons)} ${plural(
-					filteredReasons,
-					"reason",
-					"reasons"
-			  )}`
-			: undefined,
-	"module.filteredChildren": (filteredChildren, { module: { children } }) =>
-		filteredChildren > 0
-			? `${moreCount(children, filteredChildren)} ${plural(
-					filteredChildren,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"module.separator!": () => "\n",
+		return querySplitPos === -1
+			? resource
+			: resource + maybeAbsolutePath.slice(querySplitPos);
+	}
 
-	"moduleIssuer.id": (id, { formatModuleId }) => formatModuleId(id),
-	"moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value),
+	// not an absolute path
+	return maybeAbsolutePath;
+};
 
-	"moduleReason.type": type => type,
-	"moduleReason.userRequest": (userRequest, { cyan }) =>
-		cyan(getResourceName(userRequest)),
-	"moduleReason.moduleId": (moduleId, { formatModuleId }) =>
-		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
-	"moduleReason.module": (module, { magenta }) => magenta(module),
-	"moduleReason.loc": loc => loc,
-	"moduleReason.explanation": (explanation, { cyan }) => cyan(explanation),
-	"moduleReason.active": (active, { formatFlag }) =>
-		active ? undefined : formatFlag("inactive"),
-	"moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
-	"moduleReason.filteredChildren": (
-		filteredChildren,
-		{ moduleReason: { children } }
-	) =>
-		filteredChildren > 0
-			? `${moreCount(children, filteredChildren)} ${plural(
-					filteredChildren,
-					"reason",
-					"reasons"
-			  )}`
-			: undefined,
+/**
+ * @param {string} context context for relative path
+ * @param {string} relativePath path
+ * @returns {string} absolute path
+ */
+const requestToAbsolute = (context, relativePath) => {
+	if (relativePath.startsWith("./") || relativePath.startsWith("../"))
+		return path.join(context, relativePath);
+	return relativePath;
+};
 
-	"module.profile.total": (value, { formatTime }) => formatTime(value),
-	"module.profile.resolving": (value, { formatTime }) =>
-		`resolving: ${formatTime(value)}`,
-	"module.profile.restoring": (value, { formatTime }) =>
-		`restoring: ${formatTime(value)}`,
-	"module.profile.integration": (value, { formatTime }) =>
-		`integration: ${formatTime(value)}`,
-	"module.profile.building": (value, { formatTime }) =>
-		`building: ${formatTime(value)}`,
-	"module.profile.storing": (value, { formatTime }) =>
-		`storing: ${formatTime(value)}`,
-	"module.profile.additionalResolving": (value, { formatTime }) =>
-		value ? `additional resolving: ${formatTime(value)}` : undefined,
-	"module.profile.additionalIntegration": (value, { formatTime }) =>
-		value ? `additional integration: ${formatTime(value)}` : undefined,
+const makeCacheable = fn => {
+	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
+	const cache = new WeakMap();
 
-	"chunkGroup.kind!": (_, { chunkGroupKind }) => chunkGroupKind,
-	"chunkGroup.separator!": () => "\n",
-	"chunkGroup.name": (name, { bold }) => bold(name),
-	"chunkGroup.isOverSizeLimit": (isOverSizeLimit, { formatFlag, yellow }) =>
-		isOverSizeLimit ? yellow(formatFlag("big")) : undefined,
-	"chunkGroup.assetsSize": (size, { formatSize }) =>
-		size ? formatSize(size) : undefined,
-	"chunkGroup.auxiliaryAssetsSize": (size, { formatSize }) =>
-		size ? `(${formatSize(size)})` : undefined,
-	"chunkGroup.filteredAssets": (n, { chunkGroup: { assets } }) =>
-		n > 0
-			? `${moreCount(assets, n)} ${plural(n, "asset", "assets")}`
-			: undefined,
-	"chunkGroup.filteredAuxiliaryAssets": (
-		n,
-		{ chunkGroup: { auxiliaryAssets } }
-	) =>
-		n > 0
-			? `${moreCount(auxiliaryAssets, n)} auxiliary ${plural(
-					n,
-					"asset",
-					"assets"
-			  )}`
-			: undefined,
-	"chunkGroup.is!": () => "=",
-	"chunkGroupAsset.name": (asset, { green }) => green(asset),
-	"chunkGroupAsset.size": (size, { formatSize, chunkGroup }) =>
-		chunkGroup.assets.length > 1 ||
-		(chunkGroup.auxiliaryAssets && chunkGroup.auxiliaryAssets.length > 0)
-			? formatSize(size)
-			: undefined,
-	"chunkGroup.children": (children, context, printer) =>
-		Array.isArray(children)
-			? undefined
-			: printer.print(
-					context.type,
-					Object.keys(children).map(key => ({
-						type: key,
-						children: children[key]
-					})),
-					context
-			  ),
-	"chunkGroupChildGroup.type": type => `${type}:`,
-	"chunkGroupChild.assets[]": (file, { formatFilename }) =>
-		formatFilename(file),
-	"chunkGroupChild.chunks[]": (id, { formatChunkId }) => formatChunkId(id),
-	"chunkGroupChild.name": name => (name ? `(name: ${name})` : undefined),
+	/**
+	 * @param {string} context context used to create relative path
+	 * @param {string} identifier identifier used to create relative path
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {string} the returned relative path
+	 */
+	const cachedFn = (context, identifier, associatedObjectForCache) => {
+		if (!associatedObjectForCache) return fn(context, identifier);
+
+		let innerCache = cache.get(associatedObjectForCache);
+		if (innerCache === undefined) {
+			innerCache = new Map();
+			cache.set(associatedObjectForCache, innerCache);
+		}
+
+		let cachedResult;
+		let innerSubCache = innerCache.get(context);
+		if (innerSubCache === undefined) {
+			innerCache.set(context, (innerSubCache = new Map()));
+		} else {
+			cachedResult = innerSubCache.get(identifier);
+		}
+
+		if (cachedResult !== undefined) {
+			return cachedResult;
+		} else {
+			const result = fn(context, identifier);
+			innerSubCache.set(identifier, result);
+			return result;
+		}
+	};
 
-	"chunk.id": (id, { formatChunkId }) => formatChunkId(id),
-	"chunk.files[]": (file, { formatFilename }) => formatFilename(file),
-	"chunk.names[]": name => name,
-	"chunk.idHints[]": name => name,
-	"chunk.runtime[]": name => name,
-	"chunk.sizes": (sizes, context) => printSizes(sizes, context),
-	"chunk.parents[]": (parents, context) =>
-		context.formatChunkId(parents, "parent"),
-	"chunk.siblings[]": (siblings, context) =>
-		context.formatChunkId(siblings, "sibling"),
-	"chunk.children[]": (children, context) =>
-		context.formatChunkId(children, "child"),
-	"chunk.childrenByOrder": (childrenByOrder, context, printer) =>
-		Array.isArray(childrenByOrder)
-			? undefined
-			: printer.print(
-					context.type,
-					Object.keys(childrenByOrder).map(key => ({
-						type: key,
-						children: childrenByOrder[key]
-					})),
-					context
-			  ),
-	"chunk.childrenByOrder[].type": type => `${type}:`,
-	"chunk.childrenByOrder[].children[]": (id, { formatChunkId }) =>
-		isValidId(id) ? formatChunkId(id) : undefined,
-	"chunk.entry": (entry, { formatFlag, yellow }) =>
-		entry ? yellow(formatFlag("entry")) : undefined,
-	"chunk.initial": (initial, { formatFlag, yellow }) =>
-		initial ? yellow(formatFlag("initial")) : undefined,
-	"chunk.rendered": (rendered, { formatFlag, green }) =>
-		rendered ? green(formatFlag("rendered")) : undefined,
-	"chunk.recorded": (recorded, { formatFlag, green }) =>
-		recorded ? green(formatFlag("recorded")) : undefined,
-	"chunk.reason": (reason, { yellow }) => (reason ? yellow(reason) : undefined),
-	"chunk.filteredModules": (filteredModules, { chunk: { modules } }) =>
-		filteredModules > 0
-			? `${moreCount(modules, filteredModules)} chunk ${plural(
-					filteredModules,
-					"module",
-					"modules"
-			  )}`
-			: undefined,
-	"chunk.separator!": () => "\n",
+	/**
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {function(string, string): string} cached function
+	 */
+	cachedFn.bindCache = associatedObjectForCache => {
+		let innerCache;
+		if (associatedObjectForCache) {
+			innerCache = cache.get(associatedObjectForCache);
+			if (innerCache === undefined) {
+				innerCache = new Map();
+				cache.set(associatedObjectForCache, innerCache);
+			}
+		} else {
+			innerCache = new Map();
+		}
 
-	"chunkOrigin.request": request => request,
-	"chunkOrigin.moduleId": (moduleId, { formatModuleId }) =>
-		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
-	"chunkOrigin.moduleName": (moduleName, { bold }) => bold(moduleName),
-	"chunkOrigin.loc": loc => loc,
+		/**
+		 * @param {string} context context used to create relative path
+		 * @param {string} identifier identifier used to create relative path
+		 * @returns {string} the returned relative path
+		 */
+		const boundFn = (context, identifier) => {
+			let cachedResult;
+			let innerSubCache = innerCache.get(context);
+			if (innerSubCache === undefined) {
+				innerCache.set(context, (innerSubCache = new Map()));
+			} else {
+				cachedResult = innerSubCache.get(identifier);
+			}
 
-	"error.compilerPath": (compilerPath, { bold }) =>
-		compilerPath ? bold(`(${compilerPath})`) : undefined,
-	"error.chunkId": (chunkId, { formatChunkId }) =>
-		isValidId(chunkId) ? formatChunkId(chunkId) : undefined,
-	"error.chunkEntry": (chunkEntry, { formatFlag }) =>
-		chunkEntry ? formatFlag("entry") : undefined,
-	"error.chunkInitial": (chunkInitial, { formatFlag }) =>
-		chunkInitial ? formatFlag("initial") : undefined,
-	"error.file": (file, { bold }) => bold(file),
-	"error.moduleName": (moduleName, { bold }) => {
-		return moduleName.includes("!")
-			? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})`
-			: `${bold(moduleName)}`;
-	},
-	"error.loc": (loc, { green }) => green(loc),
-	"error.message": (message, { bold, formatError }) =>
-		message.includes("\u001b[") ? message : bold(formatError(message)),
-	"error.details": (details, { formatError }) => formatError(details),
-	"error.stack": stack => stack,
-	"error.moduleTrace": moduleTrace => undefined,
-	"error.separator!": () => "\n",
+			if (cachedResult !== undefined) {
+				return cachedResult;
+			} else {
+				const result = fn(context, identifier);
+				innerSubCache.set(identifier, result);
+				return result;
+			}
+		};
 
-	"loggingEntry(error).loggingEntry.message": (message, { red }) =>
-		mapLines(message, x => `<e> ${red(x)}`),
-	"loggingEntry(warn).loggingEntry.message": (message, { yellow }) =>
-		mapLines(message, x => `<w> ${yellow(x)}`),
-	"loggingEntry(info).loggingEntry.message": (message, { green }) =>
-		mapLines(message, x => `<i> ${green(x)}`),
-	"loggingEntry(log).loggingEntry.message": (message, { bold }) =>
-		mapLines(message, x => `    ${bold(x)}`),
-	"loggingEntry(debug).loggingEntry.message": message =>
-		mapLines(message, x => `    ${x}`),
-	"loggingEntry(trace).loggingEntry.message": message =>
-		mapLines(message, x => `    ${x}`),
-	"loggingEntry(status).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<s> ${magenta(x)}`),
-	"loggingEntry(profile).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<p> ${magenta(x)}`),
-	"loggingEntry(profileEnd).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `</p> ${magenta(x)}`),
-	"loggingEntry(time).loggingEntry.message": (message, { magenta }) =>
-		mapLines(message, x => `<t> ${magenta(x)}`),
-	"loggingEntry(group).loggingEntry.message": (message, { cyan }) =>
-		mapLines(message, x => `<-> ${cyan(x)}`),
-	"loggingEntry(groupCollapsed).loggingEntry.message": (message, { cyan }) =>
-		mapLines(message, x => `<+> ${cyan(x)}`),
-	"loggingEntry(clear).loggingEntry": () => "    -------",
-	"loggingEntry(groupCollapsed).loggingEntry.children": () => "",
-	"loggingEntry.trace[]": trace =>
-		trace ? mapLines(trace, x => `| ${x}`) : undefined,
+		return boundFn;
+	};
 
-	"moduleTraceItem.originName": originName => originName,
+	/**
+	 * @param {string} context context used to create relative path
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {function(string): string} cached function
+	 */
+	cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+		let innerSubCache;
+		if (associatedObjectForCache) {
+			let innerCache = cache.get(associatedObjectForCache);
+			if (innerCache === undefined) {
+				innerCache = new Map();
+				cache.set(associatedObjectForCache, innerCache);
+			}
 
-	loggingGroup: loggingGroup =>
-		loggingGroup.entries.length === 0 ? "" : undefined,
-	"loggingGroup.debug": (flag, { red }) => (flag ? red("DEBUG") : undefined),
-	"loggingGroup.name": (name, { bold }) => bold(`LOG from ${name}`),
-	"loggingGroup.separator!": () => "\n",
-	"loggingGroup.filteredEntries": filteredEntries =>
-		filteredEntries > 0 ? `+ ${filteredEntries} hidden lines` : undefined,
+			innerSubCache = innerCache.get(context);
+			if (innerSubCache === undefined) {
+				innerCache.set(context, (innerSubCache = new Map()));
+			}
+		} else {
+			innerSubCache = new Map();
+		}
 
-	"moduleTraceDependency.loc": loc => loc
+		/**
+		 * @param {string} identifier identifier used to create relative path
+		 * @returns {string} the returned relative path
+		 */
+		const boundFn = identifier => {
+			const cachedResult = innerSubCache.get(identifier);
+			if (cachedResult !== undefined) {
+				return cachedResult;
+			} else {
+				const result = fn(context, identifier);
+				innerSubCache.set(identifier, result);
+				return result;
+			}
+		};
+
+		return boundFn;
+	};
+
+	return cachedFn;
 };
 
-/** @type {Record<string, string | Function>} */
-const ITEM_NAMES = {
-	"compilation.assets[]": "asset",
-	"compilation.modules[]": "module",
-	"compilation.chunks[]": "chunk",
-	"compilation.entrypoints[]": "chunkGroup",
-	"compilation.namedChunkGroups[]": "chunkGroup",
-	"compilation.errors[]": "error",
-	"compilation.warnings[]": "error",
-	"compilation.logging[]": "loggingGroup",
-	"compilation.children[]": "compilation",
-	"asset.related[]": "asset",
-	"asset.children[]": "asset",
-	"asset.chunks[]": "assetChunk",
-	"asset.auxiliaryChunks[]": "assetChunk",
-	"asset.chunkNames[]": "assetChunkName",
-	"asset.chunkIdHints[]": "assetChunkIdHint",
-	"asset.auxiliaryChunkNames[]": "assetChunkName",
-	"asset.auxiliaryChunkIdHints[]": "assetChunkIdHint",
-	"chunkGroup.assets[]": "chunkGroupAsset",
-	"chunkGroup.auxiliaryAssets[]": "chunkGroupAsset",
-	"chunkGroupChild.assets[]": "chunkGroupAsset",
-	"chunkGroupChild.auxiliaryAssets[]": "chunkGroupAsset",
-	"chunkGroup.children[]": "chunkGroupChildGroup",
-	"chunkGroupChildGroup.children[]": "chunkGroupChild",
-	"module.modules[]": "module",
-	"module.children[]": "module",
-	"module.reasons[]": "moduleReason",
-	"moduleReason.children[]": "moduleReason",
-	"module.issuerPath[]": "moduleIssuer",
-	"chunk.origins[]": "chunkOrigin",
-	"chunk.modules[]": "module",
-	"loggingGroup.entries[]": logEntry =>
-		`loggingEntry(${logEntry.type}).loggingEntry`,
-	"loggingEntry.children[]": logEntry =>
-		`loggingEntry(${logEntry.type}).loggingEntry`,
-	"error.moduleTrace[]": "moduleTraceItem",
-	"moduleTraceItem.dependencies[]": "moduleTraceDependency"
+/**
+ *
+ * @param {string} context context for relative path
+ * @param {string} identifier identifier for path
+ * @returns {string} a converted relative path
+ */
+const _makePathsRelative = (context, identifier) => {
+	return identifier
+		.split(SEGMENTS_SPLIT_REGEXP)
+		.map(str => absoluteToRequest(context, str))
+		.join("");
 };
 
-const ERROR_PREFERRED_ORDER = [
-	"compilerPath",
-	"chunkId",
-	"chunkEntry",
-	"chunkInitial",
-	"file",
-	"separator!",
-	"moduleName",
-	"loc",
-	"separator!",
-	"message",
-	"separator!",
-	"details",
-	"separator!",
-	"stack",
-	"separator!",
-	"missing",
-	"separator!",
-	"moduleTrace"
-];
+exports.makePathsRelative = makeCacheable(_makePathsRelative);
 
-/** @type {Record<string, string[]>} */
-const PREFERRED_ORDERS = {
-	compilation: [
-		"name",
-		"hash",
-		"version",
-		"time",
-		"builtAt",
-		"env",
-		"publicPath",
-		"assets",
-		"filteredAssets",
-		"entrypoints",
-		"namedChunkGroups",
-		"chunks",
-		"modules",
-		"filteredModules",
-		"children",
-		"logging",
-		"warnings",
-		"warningsInChildren!",
-		"filteredWarningDetailsCount",
-		"errors",
-		"errorsInChildren!",
-		"filteredErrorDetailsCount",
-		"summary!",
-		"needAdditionalPass"
-	],
-	asset: [
-		"type",
-		"name",
-		"size",
-		"chunks",
-		"auxiliaryChunks",
-		"emitted",
-		"comparedForEmit",
-		"cached",
-		"info",
-		"isOverSizeLimit",
-		"chunkNames",
-		"auxiliaryChunkNames",
-		"chunkIdHints",
-		"auxiliaryChunkIdHints",
-		"related",
-		"filteredRelated",
-		"children",
-		"filteredChildren"
-	],
-	"asset.info": [
-		"immutable",
-		"sourceFilename",
-		"javascriptModule",
-		"development",
-		"hotModuleReplacement"
-	],
-	chunkGroup: [
-		"kind!",
-		"name",
-		"isOverSizeLimit",
-		"assetsSize",
-		"auxiliaryAssetsSize",
-		"is!",
-		"assets",
-		"filteredAssets",
-		"auxiliaryAssets",
-		"filteredAuxiliaryAssets",
-		"separator!",
-		"children"
-	],
-	chunkGroupAsset: ["name", "size"],
-	chunkGroupChildGroup: ["type", "children"],
-	chunkGroupChild: ["assets", "chunks", "name"],
-	module: [
-		"type",
-		"name",
-		"identifier",
-		"id",
-		"layer",
-		"sizes",
-		"chunks",
-		"depth",
-		"cacheable",
-		"orphan",
-		"runtime",
-		"optional",
-		"dependent",
-		"built",
-		"codeGenerated",
-		"cached",
-		"assets",
-		"failed",
-		"warnings",
-		"errors",
-		"children",
-		"filteredChildren",
-		"providedExports",
-		"usedExports",
-		"optimizationBailout",
-		"reasons",
-		"filteredReasons",
-		"issuerPath",
-		"profile",
-		"modules",
-		"filteredModules"
-	],
-	moduleReason: [
-		"active",
-		"type",
-		"userRequest",
-		"moduleId",
-		"module",
-		"resolvedModule",
-		"loc",
-		"explanation",
-		"children",
-		"filteredChildren"
-	],
-	"module.profile": [
-		"total",
-		"separator!",
-		"resolving",
-		"restoring",
-		"integration",
-		"building",
-		"storing",
-		"additionalResolving",
-		"additionalIntegration"
-	],
-	chunk: [
-		"id",
-		"runtime",
-		"files",
-		"names",
-		"idHints",
-		"sizes",
-		"parents",
-		"siblings",
-		"children",
-		"childrenByOrder",
-		"entry",
-		"initial",
-		"rendered",
-		"recorded",
-		"reason",
-		"separator!",
-		"origins",
-		"separator!",
-		"modules",
-		"separator!",
-		"filteredModules"
-	],
-	chunkOrigin: ["request", "moduleId", "moduleName", "loc"],
-	error: ERROR_PREFERRED_ORDER,
-	warning: ERROR_PREFERRED_ORDER,
-	"chunk.childrenByOrder[]": ["type", "children"],
-	loggingGroup: [
-		"debug",
-		"name",
-		"separator!",
-		"entries",
-		"separator!",
-		"filteredEntries"
-	],
-	loggingEntry: ["message", "trace", "children"]
+/**
+ *
+ * @param {string} context context for relative path
+ * @param {string} identifier identifier for path
+ * @returns {string} a converted relative path
+ */
+const _makePathsAbsolute = (context, identifier) => {
+	return identifier
+		.split(SEGMENTS_SPLIT_REGEXP)
+		.map(str => requestToAbsolute(context, str))
+		.join("");
 };
 
-const itemsJoinOneLine = items => items.filter(Boolean).join(" ");
-const itemsJoinOneLineBrackets = items =>
-	items.length > 0 ? `(${items.filter(Boolean).join(" ")})` : undefined;
-const itemsJoinMoreSpacing = items => items.filter(Boolean).join("\n\n");
-const itemsJoinComma = items => items.filter(Boolean).join(", ");
-const itemsJoinCommaBrackets = items =>
-	items.length > 0 ? `(${items.filter(Boolean).join(", ")})` : undefined;
-const itemsJoinCommaBracketsWithName = name => items =>
-	items.length > 0
-		? `(${name}: ${items.filter(Boolean).join(", ")})`
-		: undefined;
+exports.makePathsAbsolute = makeCacheable(_makePathsAbsolute);
 
-/** @type {Record<string, (items: string[]) => string>} */
-const SIMPLE_ITEMS_JOINER = {
-	"chunk.parents": itemsJoinOneLine,
-	"chunk.siblings": itemsJoinOneLine,
-	"chunk.children": itemsJoinOneLine,
-	"chunk.names": itemsJoinCommaBrackets,
-	"chunk.idHints": itemsJoinCommaBracketsWithName("id hint"),
-	"chunk.runtime": itemsJoinCommaBracketsWithName("runtime"),
-	"chunk.files": itemsJoinComma,
-	"chunk.childrenByOrder": itemsJoinOneLine,
-	"chunk.childrenByOrder[].children": itemsJoinOneLine,
-	"chunkGroup.assets": itemsJoinOneLine,
-	"chunkGroup.auxiliaryAssets": itemsJoinOneLineBrackets,
-	"chunkGroupChildGroup.children": itemsJoinComma,
-	"chunkGroupChild.assets": itemsJoinOneLine,
-	"chunkGroupChild.auxiliaryAssets": itemsJoinOneLineBrackets,
-	"asset.chunks": itemsJoinComma,
-	"asset.auxiliaryChunks": itemsJoinCommaBrackets,
-	"asset.chunkNames": itemsJoinCommaBracketsWithName("name"),
-	"asset.auxiliaryChunkNames": itemsJoinCommaBracketsWithName("auxiliary name"),
-	"asset.chunkIdHints": itemsJoinCommaBracketsWithName("id hint"),
-	"asset.auxiliaryChunkIdHints":
-		itemsJoinCommaBracketsWithName("auxiliary id hint"),
-	"module.chunks": itemsJoinOneLine,
-	"module.issuerPath": items =>
-		items
-			.filter(Boolean)
-			.map(item => `${item} ->`)
-			.join(" "),
-	"compilation.errors": itemsJoinMoreSpacing,
-	"compilation.warnings": itemsJoinMoreSpacing,
-	"compilation.logging": itemsJoinMoreSpacing,
-	"compilation.children": items => indent(itemsJoinMoreSpacing(items), "  "),
-	"moduleTraceItem.dependencies": itemsJoinOneLine,
-	"loggingEntry.children": items =>
-		indent(items.filter(Boolean).join("\n"), "  ", false)
+/**
+ * @param {string} context absolute context path
+ * @param {string} request any request string may containing absolute paths, query string, etc.
+ * @returns {string} a new request string avoiding absolute paths when possible
+ */
+const _contextify = (context, request) => {
+	return request
+		.split("!")
+		.map(r => absoluteToRequest(context, r))
+		.join("!");
+};
+
+const contextify = makeCacheable(_contextify);
+exports.contextify = contextify;
+
+/**
+ * @param {string} context absolute context path
+ * @param {string} request any request string
+ * @returns {string} a new request string using absolute paths when possible
+ */
+const _absolutify = (context, request) => {
+	return request
+		.split("!")
+		.map(r => requestToAbsolute(context, r))
+		.join("!");
+};
+
+const absolutify = makeCacheable(_absolutify);
+exports.absolutify = absolutify;
+
+const PATH_QUERY_FRAGMENT_REGEXP =
+	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+
+/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
+
+/**
+ * @param {string} str the path with query and fragment
+ * @returns {ParsedResource} parsed parts
+ */
+const _parseResource = str => {
+	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+	return {
+		resource: str,
+		path: match[1].replace(/\0(.)/g, "$1"),
+		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		fragment: match[3] || ""
+	};
 };
+exports.parseResource = (realFn => {
+	/** @type {WeakMap<object, Map<string, ParsedResource>>} */
+	const cache = new WeakMap();
 
-const joinOneLine = items =>
-	items
-		.map(item => item.content)
-		.filter(Boolean)
-		.join(" ");
+	const getCache = associatedObjectForCache => {
+		const entry = cache.get(associatedObjectForCache);
+		if (entry !== undefined) return entry;
+		/** @type {Map<string, ParsedResource>} */
+		const map = new Map();
+		cache.set(associatedObjectForCache, map);
+		return map;
+	};
 
-const joinInBrackets = items => {
-	const res = [];
-	let mode = 0;
-	for (const item of items) {
-		if (item.element === "separator!") {
-			switch (mode) {
-				case 0:
-				case 1:
-					mode += 2;
-					break;
-				case 4:
-					res.push(")");
-					mode = 3;
-					break;
+	/**
+	 * @param {string} str the path with query and fragment
+	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+	 * @returns {ParsedResource} parsed parts
+	 */
+	const fn = (str, associatedObjectForCache) => {
+		if (!associatedObjectForCache) return realFn(str);
+		const cache = getCache(associatedObjectForCache);
+		const entry = cache.get(str);
+		if (entry !== undefined) return entry;
+		const result = realFn(str);
+		cache.set(str, result);
+		return result;
+	};
+
+	fn.bindCache = associatedObjectForCache => {
+		const cache = getCache(associatedObjectForCache);
+		return str => {
+			const entry = cache.get(str);
+			if (entry !== undefined) return entry;
+			const result = realFn(str);
+			cache.set(str, result);
+			return result;
+		};
+	};
+
+	return fn;
+})(_parseResource);
+
+/**
+ * @param {string} filename the filename which should be undone
+ * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param {boolean} enforceRelative true returns ./ for empty paths
+ * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
+ */
+exports.getUndoPath = (filename, outputPath, enforceRelative) => {
+	let depth = -1;
+	let append = "";
+	outputPath = outputPath.replace(/[\\/]$/, "");
+	for (const part of filename.split(/[/\\]+/)) {
+		if (part === "..") {
+			if (depth > -1) {
+				depth--;
+			} else {
+				const i = outputPath.lastIndexOf("/");
+				const j = outputPath.lastIndexOf("\\");
+				const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+				if (pos < 0) return outputPath + "/";
+				append = outputPath.slice(pos + 1) + "/" + append;
+				outputPath = outputPath.slice(0, pos);
 			}
+		} else if (part !== ".") {
+			depth++;
 		}
-		if (!item.content) continue;
-		switch (mode) {
-			case 0:
-				mode = 1;
-				break;
-			case 1:
-				res.push(" ");
-				break;
-			case 2:
-				res.push("(");
-				mode = 4;
-				break;
-			case 3:
-				res.push(" (");
-				mode = 4;
-				break;
-			case 4:
-				res.push(", ");
-				break;
-		}
-		res.push(item.content);
 	}
-	if (mode === 4) res.push(")");
-	return res.join("");
+	return depth > 0
+		? `${"../".repeat(depth)}${append}`
+		: enforceRelative
+		? `./${append}`
+		: append;
 };
 
-const indent = (str, prefix, noPrefixInFirstLine) => {
-	const rem = str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
-	if (noPrefixInFirstLine) return rem;
-	const ind = str[0] === "\n" ? "" : prefix;
-	return ind + rem;
-};
 
-const joinExplicitNewLine = (items, indenter) => {
-	let firstInLine = true;
-	let first = true;
-	return items
-		.map(item => {
-			if (!item || !item.content) return;
-			let content = indent(item.content, first ? "" : indenter, !firstInLine);
-			if (firstInLine) {
-				content = content.replace(/^\n+/, "");
-			}
-			if (!content) return;
-			first = false;
-			const noJoiner = firstInLine || content.startsWith("\n");
-			firstInLine = content.endsWith("\n");
-			return noJoiner ? content : " " + content;
-		})
-		.filter(Boolean)
-		.join("")
-		.trim();
-};
+/***/ }),
 
-const joinError =
-	error =>
-	(items, { red, yellow }) =>
-		`${error ? red("ERROR") : yellow("WARNING")} in ${joinExplicitNewLine(
-			items,
-			""
-		)}`;
+/***/ 53023:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/** @type {Record<string, (items: ({ element: string, content: string })[], context: StatsPrinterContext) => string>} */
-const SIMPLE_ELEMENT_JOINERS = {
-	compilation: items => {
-		const result = [];
-		let lastNeedMore = false;
-		for (const item of items) {
-			if (!item.content) continue;
-			const needMoreSpace =
-				item.element === "warnings" ||
-				item.element === "filteredWarningDetailsCount" ||
-				item.element === "errors" ||
-				item.element === "filteredErrorDetailsCount" ||
-				item.element === "logging";
-			if (result.length !== 0) {
-				result.push(needMoreSpace || lastNeedMore ? "\n\n" : "\n");
-			}
-			result.push(item.content);
-			lastNeedMore = needMoreSpace;
-		}
-		if (lastNeedMore) result.push("\n");
-		return result.join("");
-	},
-	asset: items =>
-		joinExplicitNewLine(
-			items.map(item => {
-				if (
-					(item.element === "related" || item.element === "children") &&
-					item.content
-				) {
-					return {
-						...item,
-						content: `\n${item.content}\n`
-					};
-				}
-				return item;
-			}),
-			"  "
-		),
-	"asset.info": joinOneLine,
-	module: (items, { module }) => {
-		let hasName = false;
-		return joinExplicitNewLine(
-			items.map(item => {
-				switch (item.element) {
-					case "id":
-						if (module.id === module.name) {
-							if (hasName) return false;
-							if (item.content) hasName = true;
-						}
-						break;
-					case "name":
-						if (hasName) return false;
-						if (item.content) hasName = true;
-						break;
-					case "providedExports":
-					case "usedExports":
-					case "optimizationBailout":
-					case "reasons":
-					case "issuerPath":
-					case "profile":
-					case "children":
-					case "modules":
-						if (item.content) {
-							return {
-								...item,
-								content: `\n${item.content}\n`
-							};
-						}
-						break;
-				}
-				return item;
-			}),
-			"  "
-		);
-	},
-	chunk: items => {
-		let hasEntry = false;
-		return (
-			"chunk " +
-			joinExplicitNewLine(
-				items.filter(item => {
-					switch (item.element) {
-						case "entry":
-							if (item.content) hasEntry = true;
-							break;
-						case "initial":
-							if (hasEntry) return false;
-							break;
-					}
-					return true;
-				}),
-				"  "
-			)
-		);
-	},
-	"chunk.childrenByOrder[]": items => `(${joinOneLine(items)})`,
-	chunkGroup: items => joinExplicitNewLine(items, "  "),
-	chunkGroupAsset: joinOneLine,
-	chunkGroupChildGroup: joinOneLine,
-	chunkGroupChild: joinOneLine,
-	// moduleReason: (items, { moduleReason }) => {
-	// 	let hasName = false;
-	// 	return joinOneLine(
-	// 		items.filter(item => {
-	// 			switch (item.element) {
-	// 				case "moduleId":
-	// 					if (moduleReason.moduleId === moduleReason.module && item.content)
-	// 						hasName = true;
-	// 					break;
-	// 				case "module":
-	// 					if (hasName) return false;
-	// 					break;
-	// 				case "resolvedModule":
-	// 					return (
-	// 						moduleReason.module !== moduleReason.resolvedModule &&
-	// 						item.content
-	// 					);
-	// 			}
-	// 			return true;
-	// 		})
-	// 	);
-	// },
-	moduleReason: (items, { moduleReason }) => {
-		let hasName = false;
-		return joinExplicitNewLine(
-			items.map(item => {
-				switch (item.element) {
-					case "moduleId":
-						if (moduleReason.moduleId === moduleReason.module && item.content)
-							hasName = true;
-						break;
-					case "module":
-						if (hasName) return false;
-						break;
-					case "resolvedModule":
-						if (moduleReason.module === moduleReason.resolvedModule)
-							return false;
-						break;
-					case "children":
-						if (item.content) {
-							return {
-								...item,
-								content: `\n${item.content}\n`
-							};
-						}
-						break;
-				}
-				return item;
-			}),
-			"  "
-		);
-	},
-	"module.profile": joinInBrackets,
-	moduleIssuer: joinOneLine,
-	chunkOrigin: items => "> " + joinOneLine(items),
-	"errors[].error": joinError(true),
-	"warnings[].error": joinError(false),
-	loggingGroup: items => joinExplicitNewLine(items, "").trimRight(),
-	moduleTraceItem: items => " @ " + joinOneLine(items),
-	moduleTraceDependency: joinOneLine
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-const AVAILABLE_COLORS = {
-	bold: "\u001b[1m",
-	yellow: "\u001b[1m\u001b[33m",
-	red: "\u001b[1m\u001b[31m",
-	green: "\u001b[1m\u001b[32m",
-	cyan: "\u001b[1m\u001b[36m",
-	magenta: "\u001b[1m\u001b[35m"
-};
 
-const AVAILABLE_FORMATS = {
-	formatChunkId: (id, { yellow }, direction) => {
-		switch (direction) {
-			case "parent":
-				return `<{${yellow(id)}}>`;
-			case "sibling":
-				return `={${yellow(id)}}=`;
-			case "child":
-				return `>{${yellow(id)}}<`;
-			default:
-				return `{${yellow(id)}}`;
-		}
-	},
-	formatModuleId: id => `[${id}]`,
-	formatFilename: (filename, { green, yellow }, oversize) =>
-		(oversize ? yellow : green)(filename),
-	formatFlag: flag => `[${flag}]`,
-	formatLayer: layer => `(in ${layer})`,
-	formatSize: (__webpack_require__(71070).formatSize),
-	formatDateTime: (dateTime, { bold }) => {
-		const d = new Date(dateTime);
-		const x = twoDigit;
-		const date = `${d.getFullYear()}-${x(d.getMonth() + 1)}-${x(d.getDate())}`;
-		const time = `${x(d.getHours())}:${x(d.getMinutes())}:${x(d.getSeconds())}`;
-		return `${date} ${bold(time)}`;
-	},
-	formatTime: (
-		time,
-		{ timeReference, bold, green, yellow, red },
-		boldQuantity
-	) => {
-		const unit = " ms";
-		if (timeReference && time !== timeReference) {
-			const times = [
-				timeReference / 2,
-				timeReference / 4,
-				timeReference / 8,
-				timeReference / 16
-			];
-			if (time < times[3]) return `${time}${unit}`;
-			else if (time < times[2]) return bold(`${time}${unit}`);
-			else if (time < times[1]) return green(`${time}${unit}`);
-			else if (time < times[0]) return yellow(`${time}${unit}`);
-			else return red(`${time}${unit}`);
-		} else {
-			return `${boldQuantity ? bold(time) : time}${unit}`;
-		}
-	},
-	formatError: (message, { green, yellow, red }) => {
-		if (message.includes("\u001b[")) return message;
-		const highlights = [
-			{ regExp: /(Did you mean .+)/g, format: green },
-			{
-				regExp: /(Set 'mode' option to 'development' or 'production')/g,
-				format: green
-			},
-			{ regExp: /(\(module has no exports\))/g, format: red },
-			{ regExp: /\(possible exports: (.+)\)/g, format: green },
-			{ regExp: /(?:^|\n)(.* doesn't exist)/g, format: red },
-			{ regExp: /('\w+' option has not been set)/g, format: red },
-			{
-				regExp: /(Emitted value instead of an instance of Error)/g,
-				format: yellow
-			},
-			{ regExp: /(Used? .+ instead)/gi, format: yellow },
-			{ regExp: /\b(deprecated|must|required)\b/g, format: yellow },
-			{
-				regExp: /\b(BREAKING CHANGE)\b/gi,
-				format: red
-			},
-			{
-				regExp:
-					/\b(error|failed|unexpected|invalid|not found|not supported|not available|not possible|not implemented|doesn't support|conflict|conflicting|not existing|duplicate)\b/gi,
-				format: red
-			}
-		];
-		for (const { regExp, format } of highlights) {
-			message = message.replace(regExp, (match, content) => {
-				return match.replace(content, format(content));
-			});
-		}
-		return message;
+
+// We need to include a list of requires here
+// to allow webpack to be bundled with only static requires
+// We could use a dynamic require(`../${request}`) but this
+// would include too many modules and not every tool is able
+// to process this
+module.exports = {
+	AsyncDependenciesBlock: () => __webpack_require__(47736),
+	CommentCompilationWarning: () => __webpack_require__(98427),
+	ContextModule: () => __webpack_require__(76729),
+	"cache/PackFileCacheStrategy": () =>
+		__webpack_require__(86180),
+	"cache/ResolverCachePlugin": () => __webpack_require__(97347),
+	"container/ContainerEntryDependency": () =>
+		__webpack_require__(64813),
+	"container/ContainerEntryModule": () =>
+		__webpack_require__(80580),
+	"container/ContainerExposedDependency": () =>
+		__webpack_require__(72374),
+	"container/FallbackDependency": () =>
+		__webpack_require__(57764),
+	"container/FallbackItemDependency": () =>
+		__webpack_require__(29593),
+	"container/FallbackModule": () => __webpack_require__(82886),
+	"container/RemoteModule": () => __webpack_require__(62916),
+	"container/RemoteToExternalDependency": () =>
+		__webpack_require__(14389),
+	"dependencies/AMDDefineDependency": () =>
+		__webpack_require__(96816),
+	"dependencies/AMDRequireArrayDependency": () =>
+		__webpack_require__(33516),
+	"dependencies/AMDRequireContextDependency": () =>
+		__webpack_require__(96123),
+	"dependencies/AMDRequireDependenciesBlock": () =>
+		__webpack_require__(76932),
+	"dependencies/AMDRequireDependency": () =>
+		__webpack_require__(43911),
+	"dependencies/AMDRequireItemDependency": () =>
+		__webpack_require__(71806),
+	"dependencies/CachedConstDependency": () =>
+		__webpack_require__(57403),
+	"dependencies/CreateScriptUrlDependency": () =>
+		__webpack_require__(79062),
+	"dependencies/CommonJsRequireContextDependency": () =>
+		__webpack_require__(23962),
+	"dependencies/CommonJsExportRequireDependency": () =>
+		__webpack_require__(62892),
+	"dependencies/CommonJsExportsDependency": () =>
+		__webpack_require__(45598),
+	"dependencies/CommonJsFullRequireDependency": () =>
+		__webpack_require__(59440),
+	"dependencies/CommonJsRequireDependency": () =>
+		__webpack_require__(21264),
+	"dependencies/CommonJsSelfReferenceDependency": () =>
+		__webpack_require__(52225),
+	"dependencies/ConstDependency": () =>
+		__webpack_require__(76911),
+	"dependencies/ContextDependency": () =>
+		__webpack_require__(88101),
+	"dependencies/ContextElementDependency": () =>
+		__webpack_require__(58477),
+	"dependencies/CriticalDependencyWarning": () =>
+		__webpack_require__(15427),
+	"dependencies/CssImportDependency": () =>
+		__webpack_require__(90542),
+	"dependencies/CssLocalIdentifierDependency": () =>
+		__webpack_require__(92328),
+	"dependencies/CssSelfLocalIdentifierDependency": () =>
+		__webpack_require__(29094),
+	"dependencies/CssExportDependency": () =>
+		__webpack_require__(76760),
+	"dependencies/CssUrlDependency": () =>
+		__webpack_require__(70749),
+	"dependencies/DelegatedSourceDependency": () =>
+		__webpack_require__(22914),
+	"dependencies/DllEntryDependency": () =>
+		__webpack_require__(95666),
+	"dependencies/EntryDependency": () =>
+		__webpack_require__(3979),
+	"dependencies/ExportsInfoDependency": () =>
+		__webpack_require__(78988),
+	"dependencies/HarmonyAcceptDependency": () =>
+		__webpack_require__(23624),
+	"dependencies/HarmonyAcceptImportDependency": () =>
+		__webpack_require__(99843),
+	"dependencies/HarmonyCompatibilityDependency": () =>
+		__webpack_require__(72906),
+	"dependencies/HarmonyExportExpressionDependency": () =>
+		__webpack_require__(51340),
+	"dependencies/HarmonyExportHeaderDependency": () =>
+		__webpack_require__(38873),
+	"dependencies/HarmonyExportImportedSpecifierDependency": () =>
+		__webpack_require__(67157),
+	"dependencies/HarmonyExportSpecifierDependency": () =>
+		__webpack_require__(48567),
+	"dependencies/HarmonyImportSideEffectDependency": () =>
+		__webpack_require__(73132),
+	"dependencies/HarmonyImportSpecifierDependency": () =>
+		__webpack_require__(14077),
+	"dependencies/ImportContextDependency": () =>
+		__webpack_require__(1902),
+	"dependencies/ImportDependency": () =>
+		__webpack_require__(89376),
+	"dependencies/ImportEagerDependency": () =>
+		__webpack_require__(50718),
+	"dependencies/ImportWeakDependency": () =>
+		__webpack_require__(82483),
+	"dependencies/JsonExportsDependency": () =>
+		__webpack_require__(750),
+	"dependencies/LocalModule": () => __webpack_require__(5826),
+	"dependencies/LocalModuleDependency": () =>
+		__webpack_require__(52805),
+	"dependencies/ModuleDecoratorDependency": () =>
+		__webpack_require__(88488),
+	"dependencies/ModuleHotAcceptDependency": () =>
+		__webpack_require__(47511),
+	"dependencies/ModuleHotDeclineDependency": () =>
+		__webpack_require__(86301),
+	"dependencies/ImportMetaHotAcceptDependency": () =>
+		__webpack_require__(51274),
+	"dependencies/ImportMetaHotDeclineDependency": () =>
+		__webpack_require__(53141),
+	"dependencies/ProvidedDependency": () =>
+		__webpack_require__(95770),
+	"dependencies/PureExpressionDependency": () =>
+		__webpack_require__(55799),
+	"dependencies/RequireContextDependency": () =>
+		__webpack_require__(46917),
+	"dependencies/RequireEnsureDependenciesBlock": () =>
+		__webpack_require__(27153),
+	"dependencies/RequireEnsureDependency": () =>
+		__webpack_require__(27223),
+	"dependencies/RequireEnsureItemDependency": () =>
+		__webpack_require__(50329),
+	"dependencies/RequireHeaderDependency": () =>
+		__webpack_require__(89183),
+	"dependencies/RequireIncludeDependency": () =>
+		__webpack_require__(71284),
+	"dependencies/RequireIncludeDependencyParserPlugin": () =>
+		__webpack_require__(35768),
+	"dependencies/RequireResolveContextDependency": () =>
+		__webpack_require__(55627),
+	"dependencies/RequireResolveDependency": () =>
+		__webpack_require__(68582),
+	"dependencies/RequireResolveHeaderDependency": () =>
+		__webpack_require__(9880),
+	"dependencies/RuntimeRequirementsDependency": () =>
+		__webpack_require__(24187),
+	"dependencies/StaticExportsDependency": () =>
+		__webpack_require__(91418),
+	"dependencies/SystemPlugin": () => __webpack_require__(97981),
+	"dependencies/UnsupportedDependency": () =>
+		__webpack_require__(51669),
+	"dependencies/URLDependency": () => __webpack_require__(58612),
+	"dependencies/WebAssemblyExportImportedDependency": () =>
+		__webpack_require__(52204),
+	"dependencies/WebAssemblyImportDependency": () =>
+		__webpack_require__(5239),
+	"dependencies/WebpackIsIncludedDependency": () =>
+		__webpack_require__(26505),
+	"dependencies/WorkerDependency": () =>
+		__webpack_require__(1466),
+	"json/JsonData": () => __webpack_require__(90490),
+	"optimize/ConcatenatedModule": () =>
+		__webpack_require__(97198),
+	DelegatedModule: () => __webpack_require__(28623),
+	DependenciesBlock: () => __webpack_require__(71040),
+	DllModule: () => __webpack_require__(28280),
+	ExternalModule: () => __webpack_require__(73071),
+	FileSystemInfo: () => __webpack_require__(79453),
+	InitFragment: () => __webpack_require__(55870),
+	InvalidDependenciesModuleWarning: () =>
+		__webpack_require__(68257),
+	Module: () => __webpack_require__(73208),
+	ModuleBuildError: () => __webpack_require__(21305),
+	ModuleDependencyWarning: () => __webpack_require__(29656),
+	ModuleError: () => __webpack_require__(23744),
+	ModuleGraph: () => __webpack_require__(99988),
+	ModuleParseError: () => __webpack_require__(58443),
+	ModuleWarning: () => __webpack_require__(11234),
+	NormalModule: () => __webpack_require__(39),
+	RawDataUrlModule: () => __webpack_require__(19684),
+	RawModule: () => __webpack_require__(84929),
+	"sharing/ConsumeSharedModule": () =>
+		__webpack_require__(62286),
+	"sharing/ConsumeSharedFallbackDependency": () =>
+		__webpack_require__(58831),
+	"sharing/ProvideSharedModule": () =>
+		__webpack_require__(50821),
+	"sharing/ProvideSharedDependency": () =>
+		__webpack_require__(1798),
+	"sharing/ProvideForSharedDependency": () =>
+		__webpack_require__(40017),
+	UnsupportedFeatureWarning: () => __webpack_require__(42495),
+	"util/LazySet": () => __webpack_require__(38938),
+	UnhandledSchemeError: () => __webpack_require__(68099),
+	NodeStuffInWebError: () => __webpack_require__(6325),
+	WebpackError: () => __webpack_require__(53799),
+
+	"util/registerExternalSerializer": () => {
+		// already registered
 	}
 };
 
-const RESULT_MODIFIER = {
-	"module.modules": result => {
-		return indent(result, "| ");
-	}
-};
 
-const createOrder = (array, preferredOrder) => {
-	const originalArray = array.slice();
-	const set = new Set(array);
-	const usedSet = new Set();
-	array.length = 0;
-	for (const element of preferredOrder) {
-		if (element.endsWith("!") || set.has(element)) {
-			array.push(element);
-			usedSet.add(element);
-		}
-	}
-	for (const element of originalArray) {
-		if (!usedSet.has(element)) {
-			array.push(element);
-		}
-	}
-	return array;
-};
+/***/ }),
 
-class DefaultStatsPrinterPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("DefaultStatsPrinterPlugin", compilation => {
-			compilation.hooks.statsPrinter.tap(
-				"DefaultStatsPrinterPlugin",
-				(stats, options, context) => {
-					// Put colors into context
-					stats.hooks.print
-						.for("compilation")
-						.tap("DefaultStatsPrinterPlugin", (compilation, context) => {
-							for (const color of Object.keys(AVAILABLE_COLORS)) {
-								let start;
-								if (options.colors) {
-									if (
-										typeof options.colors === "object" &&
-										typeof options.colors[color] === "string"
-									) {
-										start = options.colors[color];
-									} else {
-										start = AVAILABLE_COLORS[color];
-									}
-								}
-								if (start) {
-									context[color] = str =>
-										`${start}${
-											typeof str === "string"
-												? str.replace(
-														/((\u001b\[39m|\u001b\[22m|\u001b\[0m)+)/g,
-														`$1${start}`
-												  )
-												: str
-										}\u001b[39m\u001b[22m`;
-								} else {
-									context[color] = str => str;
-								}
-							}
-							for (const format of Object.keys(AVAILABLE_FORMATS)) {
-								context[format] = (content, ...args) =>
-									AVAILABLE_FORMATS[format](content, context, ...args);
-							}
-							context.timeReference = compilation.time;
-						});
+/***/ 33032:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-					for (const key of Object.keys(SIMPLE_PRINTERS)) {
-						stats.hooks.print
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (obj, ctx) =>
-								SIMPLE_PRINTERS[key](obj, ctx, stats)
-							);
-					}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-					for (const key of Object.keys(PREFERRED_ORDERS)) {
-						const preferredOrder = PREFERRED_ORDERS[key];
-						stats.hooks.sortElements
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", (elements, context) => {
-								createOrder(elements, preferredOrder);
-							});
-					}
 
-					for (const key of Object.keys(ITEM_NAMES)) {
-						const itemName = ITEM_NAMES[key];
-						stats.hooks.getItemName
-							.for(key)
-							.tap(
-								"DefaultStatsPrinterPlugin",
-								typeof itemName === "string" ? () => itemName : itemName
-							);
-					}
 
-					for (const key of Object.keys(SIMPLE_ITEMS_JOINER)) {
-						const joiner = SIMPLE_ITEMS_JOINER[key];
-						stats.hooks.printItems
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", joiner);
-					}
+const { register } = __webpack_require__(8282);
 
-					for (const key of Object.keys(SIMPLE_ELEMENT_JOINERS)) {
-						const joiner = SIMPLE_ELEMENT_JOINERS[key];
-						stats.hooks.printElements
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", joiner);
-					}
+class ClassSerializer {
+	constructor(Constructor) {
+		this.Constructor = Constructor;
+	}
 
-					for (const key of Object.keys(RESULT_MODIFIER)) {
-						const modifier = RESULT_MODIFIER[key];
-						stats.hooks.result
-							.for(key)
-							.tap("DefaultStatsPrinterPlugin", modifier);
-					}
-				}
-			);
-		});
+	serialize(obj, context) {
+		obj.serialize(context);
+	}
+
+	deserialize(context) {
+		if (typeof this.Constructor.deserialize === "function") {
+			return this.Constructor.deserialize(context);
+		}
+		const obj = new this.Constructor();
+		obj.deserialize(context);
+		return obj;
 	}
 }
-module.exports = DefaultStatsPrinterPlugin;
+
+module.exports = (Constructor, request, name = null) => {
+	register(Constructor, request, name, new ClassSerializer(Constructor));
+};
 
 
 /***/ }),
 
-/***/ 92629:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 78676:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { HookMap, SyncBailHook, SyncWaterfallHook } = __webpack_require__(41242);
-const { concatComparators, keepOriginalOrder } = __webpack_require__(29579);
-const smartGrouping = __webpack_require__(15652);
-
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-
-/** @typedef {import("../util/smartGrouping").GroupConfig<any, object>} GroupConfig */
+/** @template T @typedef {function(): T} FunctionReturning */
 
 /**
- * @typedef {Object} KnownStatsFactoryContext
- * @property {string} type
- * @property {function(string): string=} makePathsRelative
- * @property {Compilation=} compilation
- * @property {Set<Module>=} rootModules
- * @property {Map<string,Chunk[]>=} compilationFileToChunks
- * @property {Map<string,Chunk[]>=} compilationAuxiliaryFileToChunks
- * @property {RuntimeSpec=} runtime
- * @property {function(Compilation): WebpackError[]=} cachedGetErrors
- * @property {function(Compilation): WebpackError[]=} cachedGetWarnings
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
  */
+const memoize = fn => {
+	let cache = false;
+	/** @type {T} */
+	let result = undefined;
+	return () => {
+		if (cache) {
+			return result;
+		} else {
+			result = fn();
+			cache = true;
+			// Allow to clean up memory for fn
+			// and all dependent resources
+			fn = undefined;
+			return result;
+		}
+	};
+};
 
-/** @typedef {KnownStatsFactoryContext & Record<string, any>} StatsFactoryContext */
+module.exports = memoize;
 
-class StatsFactory {
-	constructor() {
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[Object, any, StatsFactoryContext]>>} */
-			extract: new HookMap(
-				() => new SyncBailHook(["object", "data", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
-			filter: new HookMap(
-				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
-			),
-			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
-			sort: new HookMap(() => new SyncBailHook(["comparators", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
-			filterSorted: new HookMap(
-				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
-			),
-			/** @type {HookMap<SyncBailHook<[GroupConfig[], StatsFactoryContext]>>} */
-			groupResults: new HookMap(
-				() => new SyncBailHook(["groupConfigs", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[(function(any, any): number)[], StatsFactoryContext]>>} */
-			sortResults: new HookMap(
-				() => new SyncBailHook(["comparators", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext, number, number]>>} */
-			filterResults: new HookMap(
-				() => new SyncBailHook(["item", "context", "index", "unfilteredIndex"])
-			),
-			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
-			merge: new HookMap(() => new SyncBailHook(["items", "context"])),
-			/** @type {HookMap<SyncBailHook<[any[], StatsFactoryContext]>>} */
-			result: new HookMap(() => new SyncWaterfallHook(["result", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
-			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsFactoryContext]>>} */
-			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
-		});
-		const hooks = this.hooks;
-		this._caches =
-			/** @type {Record<keyof typeof hooks, Map<string, SyncBailHook<[any[], StatsFactoryContext]>[]>>} */ ({});
-		for (const key of Object.keys(hooks)) {
-			this._caches[key] = new Map();
-		}
-		this._inCreate = false;
-	}
 
-	_getAllLevelHooks(hookMap, cache, type) {
-		const cacheEntry = cache.get(type);
-		if (cacheEntry !== undefined) {
-			return cacheEntry;
+/***/ }),
+
+/***/ 70002:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const SAFE_LIMIT = 0x80000000;
+const SAFE_PART = SAFE_LIMIT - 1;
+const COUNT = 4;
+const arr = [0, 0, 0, 0, 0];
+const primes = [3, 7, 17, 19];
+
+module.exports = (str, range) => {
+	arr.fill(0);
+	for (let i = 0; i < str.length; i++) {
+		const c = str.charCodeAt(i);
+		for (let j = 0; j < COUNT; j++) {
+			const p = (j + COUNT - 1) % COUNT;
+			arr[j] = (arr[j] + c * primes[j] + arr[p]) & SAFE_PART;
 		}
-		const hooks = [];
-		const typeParts = type.split(".");
-		for (let i = 0; i < typeParts.length; i++) {
-			const hook = hookMap.get(typeParts.slice(i).join("."));
-			if (hook) {
-				hooks.push(hook);
-			}
+		for (let j = 0; j < COUNT; j++) {
+			const q = arr[j] % COUNT;
+			arr[j] = arr[j] ^ (arr[q] >> 1);
 		}
-		cache.set(type, hooks);
-		return hooks;
 	}
-
-	_forEachLevel(hookMap, cache, type, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-			const result = fn(hook);
-			if (result !== undefined) return result;
+	if (range <= SAFE_PART) {
+		let sum = 0;
+		for (let j = 0; j < COUNT; j++) {
+			sum = (sum + arr[j]) % range;
 		}
-	}
-
-	_forEachLevelWaterfall(hookMap, cache, type, data, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, cache, type)) {
-			data = fn(hook, data);
+		return sum;
+	} else {
+		let sum1 = 0;
+		let sum2 = 0;
+		const rangeExt = Math.floor(range / SAFE_LIMIT);
+		for (let j = 0; j < COUNT; j += 2) {
+			sum1 = (sum1 + arr[j]) & SAFE_PART;
 		}
-		return data;
+		for (let j = 1; j < COUNT; j += 2) {
+			sum2 = (sum2 + arr[j]) % rangeExt;
+		}
+		return (sum2 * SAFE_LIMIT + sum1) % range;
 	}
+};
 
-	_forEachLevelFilter(hookMap, cache, type, items, fn, forceClone) {
-		const hooks = this._getAllLevelHooks(hookMap, cache, type);
-		if (hooks.length === 0) return forceClone ? items.slice() : items;
-		let i = 0;
-		return items.filter((item, idx) => {
-			for (const hook of hooks) {
-				const r = fn(hook, item, idx, i);
-				if (r !== undefined) {
-					if (r) i++;
-					return r;
-				}
-			}
-			i++;
-			return true;
-		});
-	}
 
-	/**
-	 * @param {string} type type
-	 * @param {any} data factory data
-	 * @param {Omit<StatsFactoryContext, "type">} baseContext context used as base
-	 * @returns {any} created object
-	 */
-	create(type, data, baseContext) {
-		if (this._inCreate) {
-			return this._create(type, data, baseContext);
-		} else {
-			try {
-				this._inCreate = true;
-				return this._create(type, data, baseContext);
-			} finally {
-				for (const key of Object.keys(this._caches)) this._caches[key].clear();
-				this._inCreate = false;
-			}
-		}
-	}
+/***/ }),
 
-	_create(type, data, baseContext) {
-		const context = {
-			...baseContext,
-			type,
-			[type]: data
-		};
-		if (Array.isArray(data)) {
-			// run filter on unsorted items
-			const items = this._forEachLevelFilter(
-				this.hooks.filter,
-				this._caches.filter,
-				type,
-				data,
-				(h, r, idx, i) => h.call(r, context, idx, i),
-				true
-			);
+/***/ 42791:
+/***/ (function(module) {
 
-			// sort items
-			const comparators = [];
-			this._forEachLevel(this.hooks.sort, this._caches.sort, type, h =>
-				h.call(comparators, context)
-			);
-			if (comparators.length > 0) {
-				items.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators, keepOriginalOrder(items))
-				);
-			}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			// run filter on sorted items
-			const items2 = this._forEachLevelFilter(
-				this.hooks.filterSorted,
-				this._caches.filterSorted,
-				type,
-				items,
-				(h, r, idx, i) => h.call(r, context, idx, i),
-				false
-			);
 
-			// for each item
-			let resultItems = items2.map((item, i) => {
-				const itemContext = {
-					...context,
-					_index: i
-				};
 
-				// run getItemName
-				const itemName = this._forEachLevel(
-					this.hooks.getItemName,
-					this._caches.getItemName,
-					`${type}[]`,
-					h => h.call(item, itemContext)
-				);
-				if (itemName) itemContext[itemName] = item;
-				const innerType = itemName ? `${type}[].${itemName}` : `${type}[]`;
+/**
+ * @template T
+ * @template {Error} E
+ * @param {Iterable<T>} items initial items
+ * @param {number} concurrency number of items running in parallel
+ * @param {function(T, function(T): void, function(E=): void): void} processor worker which pushes more items
+ * @param {function(E=): void} callback all items processed
+ * @returns {void}
+ */
+const processAsyncTree = (items, concurrency, processor, callback) => {
+	const queue = Array.from(items);
+	if (queue.length === 0) return callback();
+	let processing = 0;
+	let finished = false;
+	let processScheduled = true;
+
+	const push = item => {
+		queue.push(item);
+		if (!processScheduled && processing < concurrency) {
+			processScheduled = true;
+			process.nextTick(processQueue);
+		}
+	};
+
+	const processorCallback = err => {
+		processing--;
+		if (err && !finished) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (!processScheduled) {
+			processScheduled = true;
+			process.nextTick(processQueue);
+		}
+	};
+
+	const processQueue = () => {
+		if (finished) return;
+		while (processing < concurrency && queue.length > 0) {
+			processing++;
+			const item = queue.pop();
+			processor(item, push, processorCallback);
+		}
+		processScheduled = false;
+		if (queue.length === 0 && processing === 0 && !finished) {
+			finished = true;
+			callback();
+		}
+	};
 
-				// run getItemFactory
-				const itemFactory =
-					this._forEachLevel(
-						this.hooks.getItemFactory,
-						this._caches.getItemFactory,
-						innerType,
-						h => h.call(item, itemContext)
-					) || this;
+	processQueue();
+};
 
-				// run item factory
-				return itemFactory.create(innerType, item, itemContext);
-			});
+module.exports = processAsyncTree;
 
-			// sort result items
-			const comparators2 = [];
-			this._forEachLevel(
-				this.hooks.sortResults,
-				this._caches.sortResults,
-				type,
-				h => h.call(comparators2, context)
-			);
-			if (comparators2.length > 0) {
-				resultItems.sort(
-					// @ts-expect-error number of arguments is correct
-					concatComparators(...comparators2, keepOriginalOrder(resultItems))
-				);
-			}
 
-			// group result items
-			const groupConfigs = [];
-			this._forEachLevel(
-				this.hooks.groupResults,
-				this._caches.groupResults,
-				type,
-				h => h.call(groupConfigs, context)
-			);
-			if (groupConfigs.length > 0) {
-				resultItems = smartGrouping(resultItems, groupConfigs);
-			}
+/***/ }),
 
-			// run filter on sorted result items
-			const finalResultItems = this._forEachLevelFilter(
-				this.hooks.filterResults,
-				this._caches.filterResults,
-				type,
-				resultItems,
-				(h, r, idx, i) => h.call(r, context, idx, i),
-				false
-			);
+/***/ 54190:
+/***/ (function(module) {
 
-			// run merge on mapped items
-			let result = this._forEachLevel(
-				this.hooks.merge,
-				this._caches.merge,
-				type,
-				h => h.call(finalResultItems, context)
-			);
-			if (result === undefined) result = finalResultItems;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-			// run result on merged items
-			return this._forEachLevelWaterfall(
-				this.hooks.result,
-				this._caches.result,
-				type,
-				result,
-				(h, r) => h.call(r, context)
-			);
-		} else {
-			const object = {};
 
-			// run extract on value
-			this._forEachLevel(this.hooks.extract, this._caches.extract, type, h =>
-				h.call(object, data, context)
-			);
 
-			// run result on extracted object
-			return this._forEachLevelWaterfall(
-				this.hooks.result,
-				this._caches.result,
-				type,
-				object,
-				(h, r) => h.call(r, context)
-			);
+const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
+const RESERVED_IDENTIFIER = new Set([
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"enum",
+	// strict mode
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield",
+	"yield",
+	// module code
+	"await",
+	// skip future reserved keywords defined under ES1 till ES3
+	// additional
+	"null",
+	"true",
+	"false"
+]);
+
+const propertyAccess = (properties, start = 0) => {
+	let str = "";
+	for (let i = start; i < properties.length; i++) {
+		const p = properties[i];
+		if (`${+p}` === p) {
+			str += `[${p}]`;
+		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
+			str += `.${p}`;
+		} else {
+			str += `[${JSON.stringify(p)}]`;
 		}
 	}
-}
-module.exports = StatsFactory;
+	return str;
+};
+
+module.exports = propertyAccess;
 
 
 /***/ }),
 
-/***/ 30198:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 26611:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -128077,254 +127665,342 @@ module.exports = StatsFactory;
 
 
 
-const { HookMap, SyncWaterfallHook, SyncBailHook } = __webpack_require__(41242);
+const { register } = __webpack_require__(8282);
 
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
-/** @typedef {import("tapable").Hook} Hook */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModule} StatsModule */
-/** @typedef {import("./DefaultStatsFactoryPlugin").StatsModuleReason} StatsModuleReason */
+const Position = /** @type {TODO} */ (__webpack_require__(31988).Position);
+const SourceLocation = (__webpack_require__(31988).SourceLocation);
+const ValidationError = (__webpack_require__(54983)/* ["default"] */ .Z);
+const {
+	CachedSource,
+	ConcatSource,
+	OriginalSource,
+	PrefixSource,
+	RawSource,
+	ReplaceSource,
+	SourceMapSource
+} = __webpack_require__(51255);
 
-/**
- * @typedef {Object} PrintedElement
- * @property {string} element
- * @property {string} content
- */
+/** @typedef {import("acorn").Position} Position */
+/** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
+/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
 
-/**
- * @typedef {Object} KnownStatsPrinterContext
- * @property {string=} type
- * @property {StatsCompilation=} compilation
- * @property {StatsChunkGroup=} chunkGroup
- * @property {StatsAsset=} asset
- * @property {StatsModule=} module
- * @property {StatsChunk=} chunk
- * @property {StatsModuleReason=} moduleReason
- * @property {(str: string) => string=} bold
- * @property {(str: string) => string=} yellow
- * @property {(str: string) => string=} red
- * @property {(str: string) => string=} green
- * @property {(str: string) => string=} magenta
- * @property {(str: string) => string=} cyan
- * @property {(file: string, oversize?: boolean) => string=} formatFilename
- * @property {(id: string) => string=} formatModuleId
- * @property {(id: string, direction?: "parent"|"child"|"sibling") => string=} formatChunkId
- * @property {(size: number) => string=} formatSize
- * @property {(dateTime: number) => string=} formatDateTime
- * @property {(flag: string) => string=} formatFlag
- * @property {(time: number, boldQuantity?: boolean) => string=} formatTime
- * @property {string=} chunkGroupKind
- */
+/** @typedef {ObjectSerializerContext & { writeLazy?: (any) => void }} WebpackObjectSerializerContext */
 
-/** @typedef {KnownStatsPrinterContext & Record<string, any>} StatsPrinterContext */
+const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 
-class StatsPrinter {
-	constructor() {
-		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], true>>} */
-			sortElements: new HookMap(
-				() => new SyncBailHook(["elements", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[PrintedElement[], StatsPrinterContext], string>>} */
-			printElements: new HookMap(
-				() => new SyncBailHook(["printedElements", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[any[], StatsPrinterContext], true>>} */
-			sortItems: new HookMap(() => new SyncBailHook(["items", "context"])),
-			/** @type {HookMap<SyncBailHook<[any, StatsPrinterContext], string>>} */
-			getItemName: new HookMap(() => new SyncBailHook(["item", "context"])),
-			/** @type {HookMap<SyncBailHook<[string[], StatsPrinterContext], string>>} */
-			printItems: new HookMap(
-				() => new SyncBailHook(["printedItems", "context"])
-			),
-			/** @type {HookMap<SyncBailHook<[{}, StatsPrinterContext], string>>} */
-			print: new HookMap(() => new SyncBailHook(["object", "context"])),
-			/** @type {HookMap<SyncWaterfallHook<[string, StatsPrinterContext]>>} */
-			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
-		});
-		/** @type {Map<HookMap<Hook>, Map<string, Hook[]>>} */
-		this._levelHookCache = new Map();
-		this._inPrint = false;
-	}
+register(
+	CachedSource,
+	CURRENT_MODULE,
+	"webpack-sources/CachedSource",
+	new (class CachedSourceSerializer {
+		/**
+		 * @param {CachedSource} source the cached source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write, writeLazy }) {
+			if (writeLazy) {
+				writeLazy(source.originalLazy());
+			} else {
+				write(source.original());
+			}
+			write(source.getCachedData());
+		}
 
-	/**
-	 * get all level hooks
-	 * @private
-	 * @template {Hook} T
-	 * @param {HookMap<T>} hookMap HookMap
-	 * @param {string} type type
-	 * @returns {T[]} hooks
-	 */
-	_getAllLevelHooks(hookMap, type) {
-		let cache = /** @type {Map<string, T[]>} */ (
-			this._levelHookCache.get(hookMap)
-		);
-		if (cache === undefined) {
-			cache = new Map();
-			this._levelHookCache.set(hookMap, cache);
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {CachedSource} cached source
+		 */
+		deserialize({ read }) {
+			const source = read();
+			const cachedData = read();
+			return new CachedSource(source, cachedData);
 		}
-		const cacheEntry = cache.get(type);
-		if (cacheEntry !== undefined) {
-			return cacheEntry;
+	})()
+);
+
+register(
+	RawSource,
+	CURRENT_MODULE,
+	"webpack-sources/RawSource",
+	new (class RawSourceSerializer {
+		/**
+		 * @param {RawSource} source the raw source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.buffer());
+			write(!source.isBuffer());
 		}
-		/** @type {T[]} */
-		const hooks = [];
-		const typeParts = type.split(".");
-		for (let i = 0; i < typeParts.length; i++) {
-			const hook = hookMap.get(typeParts.slice(i).join("."));
-			if (hook) {
-				hooks.push(hook);
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {RawSource} raw source
+		 */
+		deserialize({ read }) {
+			const source = read();
+			const convertToString = read();
+			return new RawSource(source, convertToString);
+		}
+	})()
+);
+
+register(
+	ConcatSource,
+	CURRENT_MODULE,
+	"webpack-sources/ConcatSource",
+	new (class ConcatSourceSerializer {
+		/**
+		 * @param {ConcatSource} source the concat source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.getChildren());
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {ConcatSource} concat source
+		 */
+		deserialize({ read }) {
+			const source = new ConcatSource();
+			source.addAllSkipOptimizing(read());
+			return source;
+		}
+	})()
+);
+
+register(
+	PrefixSource,
+	CURRENT_MODULE,
+	"webpack-sources/PrefixSource",
+	new (class PrefixSourceSerializer {
+		/**
+		 * @param {PrefixSource} source the prefix source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.getPrefix());
+			write(source.original());
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {PrefixSource} prefix source
+		 */
+		deserialize({ read }) {
+			return new PrefixSource(read(), read());
+		}
+	})()
+);
+
+register(
+	ReplaceSource,
+	CURRENT_MODULE,
+	"webpack-sources/ReplaceSource",
+	new (class ReplaceSourceSerializer {
+		/**
+		 * @param {ReplaceSource} source the replace source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.original());
+			write(source.getName());
+			const replacements = source.getReplacements();
+			write(replacements.length);
+			for (const repl of replacements) {
+				write(repl.start);
+				write(repl.end);
+			}
+			for (const repl of replacements) {
+				write(repl.content);
+				write(repl.name);
+			}
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {ReplaceSource} replace source
+		 */
+		deserialize({ read }) {
+			const source = new ReplaceSource(read(), read());
+			const len = read();
+			const startEndBuffer = [];
+			for (let i = 0; i < len; i++) {
+				startEndBuffer.push(read(), read());
+			}
+			let j = 0;
+			for (let i = 0; i < len; i++) {
+				source.replace(
+					startEndBuffer[j++],
+					startEndBuffer[j++],
+					read(),
+					read()
+				);
 			}
+			return source;
+		}
+	})()
+);
+
+register(
+	OriginalSource,
+	CURRENT_MODULE,
+	"webpack-sources/OriginalSource",
+	new (class OriginalSourceSerializer {
+		/**
+		 * @param {OriginalSource} source the original source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.buffer());
+			write(source.getName());
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {OriginalSource} original source
+		 */
+		deserialize({ read }) {
+			const buffer = read();
+			const name = read();
+			return new OriginalSource(buffer, name);
+		}
+	})()
+);
+
+register(
+	SourceLocation,
+	CURRENT_MODULE,
+	"acorn/SourceLocation",
+	new (class SourceLocationSerializer {
+		/**
+		 * @param {SourceLocation} loc the location to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(loc, { write }) {
+			write(loc.start.line);
+			write(loc.start.column);
+			write(loc.end.line);
+			write(loc.end.column);
+		}
+
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {RealDependencyLocation} location
+		 */
+		deserialize({ read }) {
+			return {
+				start: {
+					line: read(),
+					column: read()
+				},
+				end: {
+					line: read(),
+					column: read()
+				}
+			};
 		}
-		cache.set(type, hooks);
-		return hooks;
-	}
+	})()
+);
 
-	/**
-	 * Run `fn` for each level
-	 * @private
-	 * @template T
-	 * @template R
-	 * @param {HookMap<SyncBailHook<T, R>>} hookMap HookMap
-	 * @param {string} type type
-	 * @param {(hook: SyncBailHook<T, R>) => R} fn function
-	 * @returns {R} result of `fn`
-	 */
-	_forEachLevel(hookMap, type, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, type)) {
-			const result = fn(hook);
-			if (result !== undefined) return result;
+register(
+	Position,
+	CURRENT_MODULE,
+	"acorn/Position",
+	new (class PositionSerializer {
+		/**
+		 * @param {Position} pos the position to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(pos, { write }) {
+			write(pos.line);
+			write(pos.column);
 		}
-	}
 
-	/**
-	 * Run `fn` for each level
-	 * @private
-	 * @template T
-	 * @param {HookMap<SyncWaterfallHook<T>>} hookMap HookMap
-	 * @param {string} type type
-	 * @param {AsArray<T>[0]} data data
-	 * @param {(hook: SyncWaterfallHook<T>, data: AsArray<T>[0]) => AsArray<T>[0]} fn function
-	 * @returns {AsArray<T>[0]} result of `fn`
-	 */
-	_forEachLevelWaterfall(hookMap, type, data, fn) {
-		for (const hook of this._getAllLevelHooks(hookMap, type)) {
-			data = fn(hook, data);
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {SourcePosition} position
+		 */
+		deserialize({ read }) {
+			return {
+				line: read(),
+				column: read()
+			};
 		}
-		return data;
-	}
+	})()
+);
 
-	/**
-	 * @param {string} type The type
-	 * @param {Object} object Object to print
-	 * @param {Object=} baseContext The base context
-	 * @returns {string} printed result
-	 */
-	print(type, object, baseContext) {
-		if (this._inPrint) {
-			return this._print(type, object, baseContext);
-		} else {
-			try {
-				this._inPrint = true;
-				return this._print(type, object, baseContext);
-			} finally {
-				this._levelHookCache.clear();
-				this._inPrint = false;
-			}
+register(
+	SourceMapSource,
+	CURRENT_MODULE,
+	"webpack-sources/SourceMapSource",
+	new (class SourceMapSourceSerializer {
+		/**
+		 * @param {SourceMapSource} source the source map source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(source, { write }) {
+			write(source.getArgsAsBuffers());
 		}
-	}
 
-	/**
-	 * @private
-	 * @param {string} type type
-	 * @param {Object} object object
-	 * @param {Object=} baseContext context
-	 * @returns {string} printed result
-	 */
-	_print(type, object, baseContext) {
-		const context = {
-			...baseContext,
-			type,
-			[type]: object
-		};
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {SourceMapSource} source source map source
+		 */
+		deserialize({ read }) {
+			// @ts-expect-error
+			return new SourceMapSource(...read());
+		}
+	})()
+);
 
-		let printResult = this._forEachLevel(this.hooks.print, type, hook =>
-			hook.call(object, context)
-		);
-		if (printResult === undefined) {
-			if (Array.isArray(object)) {
-				const sortedItems = object.slice();
-				this._forEachLevel(this.hooks.sortItems, type, h =>
-					h.call(sortedItems, context)
-				);
-				const printedItems = sortedItems.map((item, i) => {
-					const itemContext = {
-						...context,
-						_index: i
-					};
-					const itemName = this._forEachLevel(
-						this.hooks.getItemName,
-						`${type}[]`,
-						h => h.call(item, itemContext)
-					);
-					if (itemName) itemContext[itemName] = item;
-					return this.print(
-						itemName ? `${type}[].${itemName}` : `${type}[]`,
-						item,
-						itemContext
-					);
-				});
-				printResult = this._forEachLevel(this.hooks.printItems, type, h =>
-					h.call(printedItems, context)
-				);
-				if (printResult === undefined) {
-					const result = printedItems.filter(Boolean);
-					if (result.length > 0) printResult = result.join("\n");
-				}
-			} else if (object !== null && typeof object === "object") {
-				const elements = Object.keys(object).filter(
-					key => object[key] !== undefined
-				);
-				this._forEachLevel(this.hooks.sortElements, type, h =>
-					h.call(elements, context)
-				);
-				const printedElements = elements.map(element => {
-					const content = this.print(`${type}.${element}`, object[element], {
-						...context,
-						_parent: object,
-						_element: element,
-						[element]: object[element]
-					});
-					return { element, content };
-				});
-				printResult = this._forEachLevel(this.hooks.printElements, type, h =>
-					h.call(printedElements, context)
-				);
-				if (printResult === undefined) {
-					const result = printedElements.map(e => e.content).filter(Boolean);
-					if (result.length > 0) printResult = result.join("\n");
-				}
-			}
+register(
+	ValidationError,
+	CURRENT_MODULE,
+	"schema-utils/ValidationError",
+	new (class ValidationErrorSerializer {
+		// TODO error should be ValidationError, but this fails the type checks
+		/**
+		 * @param {TODO} error the source map source to be serialized
+		 * @param {WebpackObjectSerializerContext} context context
+		 * @returns {void}
+		 */
+		serialize(error, { write }) {
+			write(error.errors);
+			write(error.schema);
+			write({
+				name: error.headerName,
+				baseDataPath: error.baseDataPath,
+				postFormatter: error.postFormatter
+			});
 		}
 
-		return this._forEachLevelWaterfall(
-			this.hooks.result,
-			type,
-			printResult,
-			(h, r) => h.call(r, context)
-		);
-	}
-}
-module.exports = StatsPrinter;
+		/**
+		 * @param {ObjectDeserializerContext} context context
+		 * @returns {TODO} error
+		 */
+		deserialize({ read }) {
+			return new ValidationError(read(), read(), read());
+		}
+	})()
+);
 
 
 /***/ }),
 
-/***/ 84953:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 17156:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -128334,549 +128010,628 @@ module.exports = StatsPrinter;
 
 
 
+const SortableSet = __webpack_require__(13098);
+
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+
+/** @typedef {string | SortableSet<string> | undefined} RuntimeSpec */
+/** @typedef {RuntimeSpec | boolean} RuntimeCondition */
+
 /**
- * Compare two arrays or strings by performing strict equality check for each value.
- * @template T [T=any]
- * @param {ArrayLike<T>} a Array of values to be compared
- * @param {ArrayLike<T>} b Array of values to be compared
- * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
+ * @param {Compilation} compilation the compilation
+ * @param {string} name name of the entry
+ * @param {EntryOptions=} options optionally already received entry options
+ * @returns {RuntimeSpec} runtime
  */
-
-exports.equals = (a, b) => {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) {
-		if (a[i] !== b[i]) return false;
+exports.getEntryRuntime = (compilation, name, options) => {
+	let dependOn;
+	let runtime;
+	if (options) {
+		({ dependOn, runtime } = options);
+	} else {
+		const entry = compilation.entries.get(name);
+		if (!entry) return name;
+		({ dependOn, runtime } = entry.options);
+	}
+	if (dependOn) {
+		/** @type {RuntimeSpec} */
+		let result = undefined;
+		const queue = new Set(dependOn);
+		for (const name of queue) {
+			const dep = compilation.entries.get(name);
+			if (!dep) continue;
+			const { dependOn, runtime } = dep.options;
+			if (dependOn) {
+				for (const name of dependOn) {
+					queue.add(name);
+				}
+			} else {
+				result = mergeRuntimeOwned(result, runtime || name);
+			}
+		}
+		return result || name;
+	} else {
+		return runtime || name;
 	}
-	return true;
 };
 
 /**
- * Partition an array by calling a predicate function on each value.
- * @template T [T=any]
- * @param {Array<T>} arr Array of values to be partitioned
- * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
- * @returns {[Array<T>, Array<T>]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
+ * @param {RuntimeSpec} runtime runtime
+ * @param {function(string): void} fn functor
+ * @param {boolean} deterministicOrder enforce a deterministic order
+ * @returns {void}
  */
-exports.groupBy = (arr = [], fn) => {
-	return arr.reduce(
-		/**
-		 * @param {[Array<T>, Array<T>]} groups An accumulator storing already partitioned values returned from previous call.
-		 * @param {T} value The value of the current element
-		 * @returns {[Array<T>, Array<T>]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
-		 */
-		(groups, value) => {
-			groups[fn(value) ? 0 : 1].push(value);
-			return groups;
-		},
-		[[], []]
-	);
+exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
+	if (runtime === undefined) {
+		fn(undefined);
+	} else if (typeof runtime === "string") {
+		fn(runtime);
+	} else {
+		if (deterministicOrder) runtime.sort();
+		for (const r of runtime) {
+			fn(r);
+		}
+	}
 };
 
+const getRuntimesKey = set => {
+	set.sort();
+	return Array.from(set).join("\n");
+};
 
-/***/ }),
+/**
+ * @param {RuntimeSpec} runtime runtime(s)
+ * @returns {string} key of runtimes
+ */
+const getRuntimeKey = runtime => {
+	if (runtime === undefined) return "*";
+	if (typeof runtime === "string") return runtime;
+	return runtime.getFromUnorderedCache(getRuntimesKey);
+};
+exports.getRuntimeKey = getRuntimeKey;
 
-/***/ 41792:
-/***/ (function(module) {
+/**
+ * @param {string} key key of runtimes
+ * @returns {RuntimeSpec} runtime(s)
+ */
+const keyToRuntime = key => {
+	if (key === "*") return undefined;
+	const items = key.split("\n");
+	if (items.length === 1) return items[0];
+	return new SortableSet(items);
+};
+exports.keyToRuntime = keyToRuntime;
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+const getRuntimesString = set => {
+	set.sort();
+	return Array.from(set).join("+");
+};
 
+/**
+ * @param {RuntimeSpec} runtime runtime(s)
+ * @returns {string} readable version
+ */
+const runtimeToString = runtime => {
+	if (runtime === undefined) return "*";
+	if (typeof runtime === "string") return runtime;
+	return runtime.getFromUnorderedCache(getRuntimesString);
+};
+exports.runtimeToString = runtimeToString;
 
+/**
+ * @param {RuntimeCondition} runtimeCondition runtime condition
+ * @returns {string} readable version
+ */
+exports.runtimeConditionToString = runtimeCondition => {
+	if (runtimeCondition === true) return "true";
+	if (runtimeCondition === false) return "false";
+	return runtimeToString(runtimeCondition);
+};
 
 /**
- * @template T
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {boolean} true, when they are equal
  */
-class ArrayQueue {
-	/**
-	 * @param {Iterable<T>=} items The initial elements.
-	 */
-	constructor(items) {
-		/** @private @type {T[]} */
-		this._list = items ? Array.from(items) : [];
-		/** @private @type {T[]} */
-		this._listReversed = [];
+const runtimeEqual = (a, b) => {
+	if (a === b) {
+		return true;
+	} else if (
+		a === undefined ||
+		b === undefined ||
+		typeof a === "string" ||
+		typeof b === "string"
+	) {
+		return false;
+	} else if (a.size !== b.size) {
+		return false;
+	} else {
+		a.sort();
+		b.sort();
+		const aIt = a[Symbol.iterator]();
+		const bIt = b[Symbol.iterator]();
+		for (;;) {
+			const aV = aIt.next();
+			if (aV.done) return true;
+			const bV = bIt.next();
+			if (aV.value !== bV.value) return false;
+		}
 	}
+};
+exports.runtimeEqual = runtimeEqual;
 
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this._list.length + this._listReversed.length;
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {-1|0|1} compare
+ */
+exports.compareRuntime = (a, b) => {
+	if (a === b) {
+		return 0;
+	} else if (a === undefined) {
+		return -1;
+	} else if (b === undefined) {
+		return 1;
+	} else {
+		const aKey = getRuntimeKey(a);
+		const bKey = getRuntimeKey(b);
+		if (aKey < bKey) return -1;
+		if (aKey > bKey) return 1;
+		return 0;
 	}
+};
 
-	/**
-	 * Empties the queue.
-	 */
-	clear() {
-		this._list.length = 0;
-		this._listReversed.length = 0;
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} merged
+ */
+const mergeRuntime = (a, b) => {
+	if (a === undefined) {
+		return b;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return a;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			const set = new SortableSet();
+			set.add(a);
+			set.add(b);
+			return set;
+		} else if (b.has(a)) {
+			return b;
+		} else {
+			const set = new SortableSet(b);
+			set.add(a);
+			return set;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (a.has(b)) return a;
+			const set = new SortableSet(a);
+			set.add(b);
+			return set;
+		} else {
+			const set = new SortableSet(a);
+			for (const item of b) set.add(item);
+			if (set.size === a.size) return a;
+			return set;
+		}
 	}
+};
+exports.mergeRuntime = mergeRuntime;
 
-	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
-	 */
-	enqueue(item) {
-		this._list.push(item);
+/**
+ * @param {RuntimeCondition} a first
+ * @param {RuntimeCondition} b second
+ * @param {RuntimeSpec} runtime full runtime
+ * @returns {RuntimeCondition} result
+ */
+exports.mergeRuntimeCondition = (a, b, runtime) => {
+	if (a === false) return b;
+	if (b === false) return a;
+	if (a === true || b === true) return true;
+	const merged = mergeRuntime(a, b);
+	if (merged === undefined) return undefined;
+	if (typeof merged === "string") {
+		if (typeof runtime === "string" && merged === runtime) return true;
+		return merged;
+	}
+	if (typeof runtime === "string" || runtime === undefined) return merged;
+	if (merged.size === runtime.size) return true;
+	return merged;
+};
+
+/**
+ * @param {RuntimeSpec | true} a first
+ * @param {RuntimeSpec | true} b second
+ * @param {RuntimeSpec} runtime full runtime
+ * @returns {RuntimeSpec | true} result
+ */
+exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
+	if (a === true || b === true) return true;
+	const merged = mergeRuntime(a, b);
+	if (merged === undefined) return undefined;
+	if (typeof merged === "string") {
+		if (typeof runtime === "string" && merged === runtime) return true;
+		return merged;
 	}
+	if (typeof runtime === "string" || runtime === undefined) return merged;
+	if (merged.size === runtime.size) return true;
+	return merged;
+};
 
-	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
-	 */
-	dequeue() {
-		if (this._listReversed.length === 0) {
-			if (this._list.length === 0) return undefined;
-			if (this._list.length === 1) return this._list.pop();
-			if (this._list.length < 16) return this._list.shift();
-			const temp = this._listReversed;
-			this._listReversed = this._list;
-			this._listReversed.reverse();
-			this._list = temp;
+/**
+ * @param {RuntimeSpec} a first (may be modified)
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} merged
+ */
+const mergeRuntimeOwned = (a, b) => {
+	if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return a;
+	} else if (a === undefined) {
+		if (typeof b === "string") {
+			return b;
+		} else {
+			return new SortableSet(b);
+		}
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			const set = new SortableSet();
+			set.add(a);
+			set.add(b);
+			return set;
+		} else {
+			const set = new SortableSet(b);
+			set.add(a);
+			return set;
+		}
+	} else {
+		if (typeof b === "string") {
+			a.add(b);
+			return a;
+		} else {
+			for (const item of b) a.add(item);
+			return a;
 		}
-		return this._listReversed.pop();
 	}
+};
+exports.mergeRuntimeOwned = mergeRuntimeOwned;
 
-	/**
-	 * Finds and removes an item
-	 * @param {T} item the item
-	 * @returns {void}
-	 */
-	delete(item) {
-		const i = this._list.indexOf(item);
-		if (i >= 0) {
-			this._list.splice(i, 1);
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} merged
+ */
+exports.intersectRuntime = (a, b) => {
+	if (a === undefined) {
+		return b;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return a;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			return undefined;
+		} else if (b.has(a)) {
+			return a;
 		} else {
-			const i = this._listReversed.indexOf(item);
-			if (i >= 0) this._listReversed.splice(i, 1);
+			return undefined;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (a.has(b)) return b;
+			return undefined;
+		} else {
+			const set = new SortableSet();
+			for (const item of b) {
+				if (a.has(item)) set.add(item);
+			}
+			if (set.size === 0) return undefined;
+			if (set.size === 1) for (const item of set) return item;
+			return set;
 		}
 	}
+};
 
-	[Symbol.iterator]() {
-		let i = -1;
-		let reversed = false;
-		return {
-			next: () => {
-				if (!reversed) {
-					i++;
-					if (i < this._list.length) {
-						return {
-							done: false,
-							value: this._list[i]
-						};
-					}
-					reversed = true;
-					i = this._listReversed.length;
-				}
-				i--;
-				if (i < 0) {
-					return {
-						done: true,
-						value: undefined
-					};
+/**
+ * @param {RuntimeSpec} a first
+ * @param {RuntimeSpec} b second
+ * @returns {RuntimeSpec} result
+ */
+const subtractRuntime = (a, b) => {
+	if (a === undefined) {
+		return undefined;
+	} else if (b === undefined) {
+		return a;
+	} else if (a === b) {
+		return undefined;
+	} else if (typeof a === "string") {
+		if (typeof b === "string") {
+			return a;
+		} else if (b.has(a)) {
+			return undefined;
+		} else {
+			return a;
+		}
+	} else {
+		if (typeof b === "string") {
+			if (!a.has(b)) return a;
+			if (a.size === 2) {
+				for (const item of a) {
+					if (item !== b) return item;
 				}
-				return {
-					done: false,
-					value: this._listReversed[i]
-				};
 			}
-		};
+			const set = new SortableSet(a);
+			set.delete(b);
+		} else {
+			const set = new SortableSet();
+			for (const item of a) {
+				if (!b.has(item)) set.add(item);
+			}
+			if (set.size === 0) return undefined;
+			if (set.size === 1) for (const item of set) return item;
+			return set;
+		}
 	}
-}
-
-module.exports = ArrayQueue;
-
-
-/***/ }),
-
-/***/ 12260:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const { SyncHook, AsyncSeriesHook } = __webpack_require__(41242);
-const { makeWebpackError } = __webpack_require__(11351);
-const WebpackError = __webpack_require__(53799);
-const ArrayQueue = __webpack_require__(41792);
-
-const QUEUED_STATE = 0;
-const PROCESSING_STATE = 1;
-const DONE_STATE = 2;
-
-let inHandleResult = 0;
+};
+exports.subtractRuntime = subtractRuntime;
 
 /**
- * @template T
- * @callback Callback
- * @param {(WebpackError | null)=} err
- * @param {T=} result
+ * @param {RuntimeCondition} a first
+ * @param {RuntimeCondition} b second
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {RuntimeCondition} result
  */
+exports.subtractRuntimeCondition = (a, b, runtime) => {
+	if (b === true) return false;
+	if (b === false) return a;
+	if (a === false) return false;
+	const result = subtractRuntime(a === true ? runtime : a, b);
+	return result === undefined ? false : result;
+};
 
 /**
- * @template T
- * @template K
- * @template R
+ * @param {RuntimeSpec} runtime runtime
+ * @param {function(RuntimeSpec): boolean} filter filter function
+ * @returns {boolean | RuntimeSpec} true/false if filter is constant for all runtimes, otherwise runtimes that are active
  */
-class AsyncQueueEntry {
-	/**
-	 * @param {T} item the item
-	 * @param {Callback<R>} callback the callback
-	 */
-	constructor(item, callback) {
-		this.item = item;
-		/** @type {typeof QUEUED_STATE | typeof PROCESSING_STATE | typeof DONE_STATE} */
-		this.state = QUEUED_STATE;
-		this.callback = callback;
-		/** @type {Callback<R>[] | undefined} */
-		this.callbacks = undefined;
-		this.result = undefined;
-		/** @type {WebpackError | undefined} */
-		this.error = undefined;
+exports.filterRuntime = (runtime, filter) => {
+	if (runtime === undefined) return filter(undefined);
+	if (typeof runtime === "string") return filter(runtime);
+	let some = false;
+	let every = true;
+	let result = undefined;
+	for (const r of runtime) {
+		const v = filter(r);
+		if (v) {
+			some = true;
+			result = mergeRuntimeOwned(result, r);
+		} else {
+			every = false;
+		}
 	}
-}
+	if (!some) return false;
+	if (every) return true;
+	return result;
+};
 
 /**
  * @template T
- * @template K
- * @template R
  */
-class AsyncQueue {
+class RuntimeSpecMap {
 	/**
-	 * @param {Object} options options object
-	 * @param {string=} options.name name of the queue
-	 * @param {number=} options.parallelism how many items should be processed at once
-	 * @param {AsyncQueue<any, any, any>=} options.parent parent queue, which will have priority over this queue and with shared parallelism
-	 * @param {function(T): K=} options.getKey extract key from item
-	 * @param {function(T, Callback<R>): void} options.processor async function to process items
+	 * @param {RuntimeSpecMap<T>=} clone copy form this
 	 */
-	constructor({ name, parallelism, parent, processor, getKey }) {
-		this._name = name;
-		this._parallelism = parallelism || 1;
-		this._processor = processor;
-		this._getKey =
-			getKey || /** @type {(T) => K} */ (item => /** @type {any} */ (item));
-		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
-		this._entries = new Map();
-		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
-		this._queued = new ArrayQueue();
-		/** @type {AsyncQueue<any, any, any>[]} */
-		this._children = undefined;
-		this._activeTasks = 0;
-		this._willEnsureProcessing = false;
-		this._needProcessing = false;
-		this._stopped = false;
-		this._root = parent ? parent._root : this;
-		if (parent) {
-			if (this._root._children === undefined) {
-				this._root._children = [this];
-			} else {
-				this._root._children.push(this);
-			}
-		}
-
-		this.hooks = {
-			/** @type {AsyncSeriesHook<[T]>} */
-			beforeAdd: new AsyncSeriesHook(["item"]),
-			/** @type {SyncHook<[T]>} */
-			added: new SyncHook(["item"]),
-			/** @type {AsyncSeriesHook<[T]>} */
-			beforeStart: new AsyncSeriesHook(["item"]),
-			/** @type {SyncHook<[T]>} */
-			started: new SyncHook(["item"]),
-			/** @type {SyncHook<[T, Error, R]>} */
-			result: new SyncHook(["item", "error", "result"])
-		};
-
-		this._ensureProcessing = this._ensureProcessing.bind(this);
+	constructor(clone) {
+		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
+		/** @type {RuntimeSpec} */
+		this._singleRuntime = clone ? clone._singleRuntime : undefined;
+		/** @type {T} */
+		this._singleValue = clone ? clone._singleValue : undefined;
+		/** @type {Map<string, T> | undefined} */
+		this._map = clone && clone._map ? new Map(clone._map) : undefined;
 	}
 
 	/**
-	 * @param {T} item an item
-	 * @param {Callback<R>} callback callback function
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @returns {T} value
 	 */
-	add(item, callback) {
-		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
-		this.hooks.beforeAdd.callAsync(item, err => {
-			if (err) {
-				callback(
-					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeAdd`)
-				);
-				return;
-			}
-			const key = this._getKey(item);
-			const entry = this._entries.get(key);
-			if (entry !== undefined) {
-				if (entry.state === DONE_STATE) {
-					if (inHandleResult++ > 3) {
-						process.nextTick(() => callback(entry.error, entry.result));
-					} else {
-						callback(entry.error, entry.result);
-					}
-					inHandleResult--;
-				} else if (entry.callbacks === undefined) {
-					entry.callbacks = [callback];
-				} else {
-					entry.callbacks.push(callback);
-				}
-				return;
-			}
-			const newEntry = new AsyncQueueEntry(item, callback);
-			if (this._stopped) {
-				this.hooks.added.call(item);
-				this._root._activeTasks++;
-				process.nextTick(() =>
-					this._handleResult(newEntry, new WebpackError("Queue was stopped"))
-				);
-			} else {
-				this._entries.set(key, newEntry);
-				this._queued.enqueue(newEntry);
-				const root = this._root;
-				root._needProcessing = true;
-				if (root._willEnsureProcessing === false) {
-					root._willEnsureProcessing = true;
-					setImmediate(root._ensureProcessing);
-				}
-				this.hooks.added.call(item);
-			}
-		});
+	get(runtime) {
+		switch (this._mode) {
+			case 0:
+				return undefined;
+			case 1:
+				return runtimeEqual(this._singleRuntime, runtime)
+					? this._singleValue
+					: undefined;
+			default:
+				return this._map.get(getRuntimeKey(runtime));
+		}
 	}
 
 	/**
-	 * @param {T} item an item
-	 * @returns {void}
+	 * @param {RuntimeSpec} runtime the runtimes
+	 * @returns {boolean} true, when the runtime is stored
 	 */
-	invalidate(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		this._entries.delete(key);
-		if (entry.state === QUEUED_STATE) {
-			this._queued.delete(entry);
+	has(runtime) {
+		switch (this._mode) {
+			case 0:
+				return false;
+			case 1:
+				return runtimeEqual(this._singleRuntime, runtime);
+			default:
+				return this._map.has(getRuntimeKey(runtime));
 		}
 	}
 
-	/**
-	 * Waits for an already started item
-	 * @param {T} item an item
-	 * @param {Callback<R>} callback callback function
-	 * @returns {void}
-	 */
-	waitFor(item, callback) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		if (entry === undefined) {
-			return callback(
-				new WebpackError(
-					"waitFor can only be called for an already started item"
-				)
-			);
+	set(runtime, value) {
+		switch (this._mode) {
+			case 0:
+				this._mode = 1;
+				this._singleRuntime = runtime;
+				this._singleValue = value;
+				break;
+			case 1:
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._singleValue = value;
+					break;
+				}
+				this._mode = 2;
+				this._map = new Map();
+				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._singleRuntime = undefined;
+				this._singleValue = undefined;
+			/* falls through */
+			default:
+				this._map.set(getRuntimeKey(runtime), value);
 		}
-		if (entry.state === DONE_STATE) {
-			process.nextTick(() => callback(entry.error, entry.result));
-		} else if (entry.callbacks === undefined) {
-			entry.callbacks = [callback];
-		} else {
-			entry.callbacks.push(callback);
+	}
+
+	provide(runtime, computer) {
+		switch (this._mode) {
+			case 0:
+				this._mode = 1;
+				this._singleRuntime = runtime;
+				return (this._singleValue = computer());
+			case 1: {
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					return this._singleValue;
+				}
+				this._mode = 2;
+				this._map = new Map();
+				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+				this._singleRuntime = undefined;
+				this._singleValue = undefined;
+				const newValue = computer();
+				this._map.set(getRuntimeKey(runtime), newValue);
+				return newValue;
+			}
+			default: {
+				const key = getRuntimeKey(runtime);
+				const value = this._map.get(key);
+				if (value !== undefined) return value;
+				const newValue = computer();
+				this._map.set(key, newValue);
+				return newValue;
+			}
 		}
 	}
 
-	/**
-	 * @returns {void}
-	 */
-	stop() {
-		this._stopped = true;
-		const queue = this._queued;
-		this._queued = new ArrayQueue();
-		const root = this._root;
-		for (const entry of queue) {
-			this._entries.delete(this._getKey(entry.item));
-			root._activeTasks++;
-			this._handleResult(entry, new WebpackError("Queue was stopped"));
+	delete(runtime) {
+		switch (this._mode) {
+			case 0:
+				return;
+			case 1:
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._mode = 0;
+					this._singleRuntime = undefined;
+					this._singleValue = undefined;
+				}
+				return;
+			default:
+				this._map.delete(getRuntimeKey(runtime));
 		}
 	}
 
-	/**
-	 * @returns {void}
-	 */
-	increaseParallelism() {
-		const root = this._root;
-		root._parallelism++;
-		/* istanbul ignore next */
-		if (root._willEnsureProcessing === false && root._needProcessing) {
-			root._willEnsureProcessing = true;
-			setImmediate(root._ensureProcessing);
+	update(runtime, fn) {
+		switch (this._mode) {
+			case 0:
+				throw new Error("runtime passed to update must exist");
+			case 1: {
+				if (runtimeEqual(this._singleRuntime, runtime)) {
+					this._singleValue = fn(this._singleValue);
+					break;
+				}
+				const newValue = fn(undefined);
+				if (newValue !== undefined) {
+					this._mode = 2;
+					this._map = new Map();
+					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
+					this._singleRuntime = undefined;
+					this._singleValue = undefined;
+					this._map.set(getRuntimeKey(runtime), newValue);
+				}
+				break;
+			}
+			default: {
+				const key = getRuntimeKey(runtime);
+				const oldValue = this._map.get(key);
+				const newValue = fn(oldValue);
+				if (newValue !== oldValue) this._map.set(key, newValue);
+			}
 		}
 	}
 
-	/**
-	 * @returns {void}
-	 */
-	decreaseParallelism() {
-		const root = this._root;
-		root._parallelism--;
+	keys() {
+		switch (this._mode) {
+			case 0:
+				return [];
+			case 1:
+				return [this._singleRuntime];
+			default:
+				return Array.from(this._map.keys(), keyToRuntime);
+		}
 	}
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, if the item is currently being processed
-	 */
-	isProcessing(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		return entry !== undefined && entry.state === PROCESSING_STATE;
+	values() {
+		switch (this._mode) {
+			case 0:
+				return [][Symbol.iterator]();
+			case 1:
+				return [this._singleValue][Symbol.iterator]();
+			default:
+				return this._map.values();
+		}
 	}
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, if the item is currently queued
-	 */
-	isQueued(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		return entry !== undefined && entry.state === QUEUED_STATE;
+	get size() {
+		if (this._mode <= 1) return this._mode;
+		return this._map.size;
 	}
+}
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, if the item is currently queued
-	 */
-	isDone(item) {
-		const key = this._getKey(item);
-		const entry = this._entries.get(key);
-		return entry !== undefined && entry.state === DONE_STATE;
-	}
+exports.RuntimeSpecMap = RuntimeSpecMap;
 
-	/**
-	 * @returns {void}
-	 */
-	_ensureProcessing() {
-		while (this._activeTasks < this._parallelism) {
-			const entry = this._queued.dequeue();
-			if (entry === undefined) break;
-			this._activeTasks++;
-			entry.state = PROCESSING_STATE;
-			this._startProcessing(entry);
-		}
-		this._willEnsureProcessing = false;
-		if (this._queued.length > 0) return;
-		if (this._children !== undefined) {
-			for (const child of this._children) {
-				while (this._activeTasks < this._parallelism) {
-					const entry = child._queued.dequeue();
-					if (entry === undefined) break;
-					this._activeTasks++;
-					entry.state = PROCESSING_STATE;
-					child._startProcessing(entry);
-				}
-				if (child._queued.length > 0) return;
+class RuntimeSpecSet {
+	constructor(iterable) {
+		/** @type {Map<string, RuntimeSpec>} */
+		this._map = new Map();
+		if (iterable) {
+			for (const item of iterable) {
+				this.add(item);
 			}
 		}
-		if (!this._willEnsureProcessing) this._needProcessing = false;
 	}
 
-	/**
-	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
-	 * @returns {void}
-	 */
-	_startProcessing(entry) {
-		this.hooks.beforeStart.callAsync(entry.item, err => {
-			if (err) {
-				this._handleResult(
-					entry,
-					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeStart`)
-				);
-				return;
-			}
-			let inCallback = false;
-			try {
-				this._processor(entry.item, (e, r) => {
-					inCallback = true;
-					this._handleResult(entry, e, r);
-				});
-			} catch (err) {
-				if (inCallback) throw err;
-				this._handleResult(entry, err, null);
-			}
-			this.hooks.started.call(entry.item);
-		});
+	add(runtime) {
+		this._map.set(getRuntimeKey(runtime), runtime);
 	}
 
-	/**
-	 * @param {AsyncQueueEntry<T, K, R>} entry the entry
-	 * @param {WebpackError=} err error, if any
-	 * @param {R=} result result, if any
-	 * @returns {void}
-	 */
-	_handleResult(entry, err, result) {
-		this.hooks.result.callAsync(entry.item, err, result, hookError => {
-			const error = hookError
-				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
-				: err;
-
-			const callback = entry.callback;
-			const callbacks = entry.callbacks;
-			entry.state = DONE_STATE;
-			entry.callback = undefined;
-			entry.callbacks = undefined;
-			entry.result = result;
-			entry.error = error;
-
-			const root = this._root;
-			root._activeTasks--;
-			if (root._willEnsureProcessing === false && root._needProcessing) {
-				root._willEnsureProcessing = true;
-				setImmediate(root._ensureProcessing);
-			}
+	has(runtime) {
+		return this._map.has(getRuntimeKey(runtime));
+	}
 
-			if (inHandleResult++ > 3) {
-				process.nextTick(() => {
-					callback(error, result);
-					if (callbacks !== undefined) {
-						for (const callback of callbacks) {
-							callback(error, result);
-						}
-					}
-				});
-			} else {
-				callback(error, result);
-				if (callbacks !== undefined) {
-					for (const callback of callbacks) {
-						callback(error, result);
-					}
-				}
-			}
-			inHandleResult--;
-		});
+	[Symbol.iterator]() {
+		return this._map.values();
 	}
 
-	clear() {
-		this._entries.clear();
-		this._queued.clear();
-		this._activeTasks = 0;
-		this._willEnsureProcessing = false;
-		this._needProcessing = false;
-		this._stopped = false;
+	get size() {
+		return this._map.size;
 	}
 }
 
-module.exports = AsyncQueue;
+exports.RuntimeSpecSet = RuntimeSpecSet;
 
 
 /***/ }),
 
-/***/ 36692:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 19702:
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 /*
@@ -128886,338 +128641,618 @@ module.exports = AsyncQueue;
 
 
 
-class Hash {
-	/* istanbul ignore next */
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @abstract
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+
+/**
+ * @param {string} str version string
+ * @returns {(string|number|undefined|[])[]} parsed version
+ */
+const parseVersion = str => {
+	var splitAndConvert = function (str) {
+		return str.split(".").map(function (item) {
+			// eslint-disable-next-line eqeqeq
+			return +item == item ? +item : item;
+		});
+	};
+	var match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
+	/** @type {(string|number|undefined|[])[]} */
+	var ver = match[1] ? splitAndConvert(match[1]) : [];
+	if (match[2]) {
+		ver.length++;
+		ver.push.apply(ver, splitAndConvert(match[2]));
+	}
+	if (match[3]) {
+		ver.push([]);
+		ver.push.apply(ver, splitAndConvert(match[3]));
 	}
+	return ver;
+};
+exports.parseVersion = parseVersion;
 
-	/* istanbul ignore next */
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @abstract
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
-	 */
-	digest(encoding) {
-		const AbstractMethodError = __webpack_require__(77198);
-		throw new AbstractMethodError();
+/* eslint-disable eqeqeq */
+/**
+ * @param {string} a version
+ * @param {string} b version
+ * @returns {boolean} true, iff a < b
+ */
+const versionLt = (a, b) => {
+	// @ts-expect-error
+	a = parseVersion(a);
+	// @ts-expect-error
+	b = parseVersion(b);
+	var i = 0;
+	for (;;) {
+		// a       b  EOA     object  undefined  number  string
+		// EOA        a == b  a < b   b < a      a < b   a < b
+		// object     b < a   (0)     b < a      a < b   a < b
+		// undefined  a < b   a < b   (0)        a < b   a < b
+		// number     b < a   b < a   b < a      (1)     a < b
+		// string     b < a   b < a   b < a      b < a   (1)
+		// EOA end of array
+		// (0) continue on
+		// (1) compare them via "<"
+
+		// Handles first row in table
+		if (i >= a.length) return i < b.length && (typeof b[i])[0] != "u";
+
+		var aValue = a[i];
+		var aType = (typeof aValue)[0];
+
+		// Handles first column in table
+		if (i >= b.length) return aType == "u";
+
+		var bValue = b[i];
+		var bType = (typeof bValue)[0];
+
+		if (aType == bType) {
+			if (aType != "o" && aType != "u" && aValue != bValue) {
+				return aValue < bValue;
+			}
+			i++;
+		} else {
+			// Handles remaining cases
+			if (aType == "o" && bType == "n") return true;
+			return bType == "s" || aType == "u";
+		}
 	}
-}
+};
+/* eslint-enable eqeqeq */
+exports.versionLt = versionLt;
+
+/**
+ * @param {string} str range string
+ * @returns {SemVerRange} parsed range
+ */
+exports.parseRange = str => {
+	const splitAndConvert = str => {
+		return str.split(".").map(item => (`${+item}` === item ? +item : item));
+	};
+	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
+	const parsePartial = str => {
+		const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
+		/** @type {(string|number|undefined|[])[]} */
+		const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
+		if (match[2]) {
+			ver.length++;
+			ver.push.apply(ver, splitAndConvert(match[2]));
+		}
+
+		// remove trailing any matchers
+		let last = ver[ver.length - 1];
+		while (
+			ver.length &&
+			(last === undefined || /^[*xX]$/.test(/** @type {string} */ (last)))
+		) {
+			ver.pop();
+			last = ver[ver.length - 1];
+		}
+
+		return ver;
+	};
+	const toFixed = range => {
+		if (range.length === 1) {
+			// Special case for "*" is "x.x.x" instead of "="
+			return [0];
+		} else if (range.length === 2) {
+			// Special case for "1" is "1.x.x" instead of "=1"
+			return [1, ...range.slice(1)];
+		} else if (range.length === 3) {
+			// Special case for "1.2" is "1.2.x" instead of "=1.2"
+			return [2, ...range.slice(1)];
+		} else {
+			return [range.length, ...range.slice(1)];
+		}
+	};
+	const negate = range => {
+		return [-range[0] - 1, ...range.slice(1)];
+	};
+	const parseSimple = str => {
+		// simple     ::= primitive | partial | tilde | caret
+		// primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+		// tilde      ::= '~' partial
+		// caret      ::= '^' partial
+		const match = /^(\^|~|<=|<|>=|>|=|v|!)/.exec(str);
+		const start = match ? match[0] : "";
+		const remainder = parsePartial(str.slice(start.length));
+		switch (start) {
+			case "^":
+				if (remainder.length > 1 && remainder[1] === 0) {
+					if (remainder.length > 2 && remainder[2] === 0) {
+						return [3, ...remainder.slice(1)];
+					}
+					return [2, ...remainder.slice(1)];
+				}
+				return [1, ...remainder.slice(1)];
+			case "~":
+				return [2, ...remainder.slice(1)];
+			case ">=":
+				return remainder;
+			case "=":
+			case "v":
+			case "":
+				return toFixed(remainder);
+			case "<":
+				return negate(remainder);
+			case ">": {
+				// and( >=, not( = ) ) => >=, =, not, and
+				const fixed = toFixed(remainder);
+				// eslint-disable-next-line no-sparse-arrays
+				return [, fixed, 0, remainder, 2];
+			}
+			case "<=":
+				// or( <, = ) => <, =, or
+				// eslint-disable-next-line no-sparse-arrays
+				return [, toFixed(remainder), negate(remainder), 1];
+			case "!": {
+				// not =
+				const fixed = toFixed(remainder);
+				// eslint-disable-next-line no-sparse-arrays
+				return [, fixed, 0];
+			}
+			default:
+				throw new Error("Unexpected start value");
+		}
+	};
+	const combine = (items, fn) => {
+		if (items.length === 1) return items[0];
+		const arr = [];
+		for (const item of items.slice().reverse()) {
+			if (0 in item) {
+				arr.push(item);
+			} else {
+				arr.push(...item.slice(1));
+			}
+		}
+		// eslint-disable-next-line no-sparse-arrays
+		return [, ...arr, ...items.slice(1).map(() => fn)];
+	};
+	const parseRange = str => {
+		// range      ::= hyphen | simple ( ' ' simple ) * | ''
+		// hyphen     ::= partial ' - ' partial
+		const items = str.split(" - ");
+		if (items.length === 1) {
+			const items = str.trim().split(/\s+/g).map(parseSimple);
+			return combine(items, 2);
+		}
+		const a = parsePartial(items[0]);
+		const b = parsePartial(items[1]);
+		// >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
+		// eslint-disable-next-line no-sparse-arrays
+		return [, toFixed(b), negate(b), 1, a, 2];
+	};
+	const parseLogicalOr = str => {
+		// range-set  ::= range ( logical-or range ) *
+		// logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+		const items = str.split(/\s*\|\|\s*/).map(parseRange);
+		return combine(items, 1);
+	};
+	return parseLogicalOr(str);
+};
+
+/* eslint-disable eqeqeq */
+const rangeToString = range => {
+	var fixCount = range[0];
+	var str = "";
+	if (range.length === 1) {
+		return "*";
+	} else if (fixCount + 0.5) {
+		str +=
+			fixCount == 0
+				? ">="
+				: fixCount == -1
+				? "<"
+				: fixCount == 1
+				? "^"
+				: fixCount == 2
+				? "~"
+				: fixCount > 0
+				? "="
+				: "!=";
+		var needDot = 1;
+		// eslint-disable-next-line no-redeclare
+		for (var i = 1; i < range.length; i++) {
+			var item = range[i];
+			var t = (typeof item)[0];
+			needDot--;
+			str +=
+				t == "u"
+					? // undefined: prerelease marker, add an "-"
+					  "-"
+					: // number or string: add the item, set flag to add an "." between two of them
+					  (needDot > 0 ? "." : "") + ((needDot = 2), item);
+		}
+		return str;
+	} else {
+		var stack = [];
+		// eslint-disable-next-line no-redeclare
+		for (var i = 1; i < range.length; i++) {
+			// eslint-disable-next-line no-redeclare
+			var item = range[i];
+			stack.push(
+				item === 0
+					? "not(" + pop() + ")"
+					: item === 1
+					? "(" + pop() + " || " + pop() + ")"
+					: item === 2
+					? stack.pop() + " " + stack.pop()
+					: rangeToString(item)
+			);
+		}
+		return pop();
+	}
+	function pop() {
+		return stack.pop().replace(/^\((.+)\)$/, "$1");
+	}
+};
+/* eslint-enable eqeqeq */
+exports.rangeToString = rangeToString;
+
+/* eslint-disable eqeqeq */
+/**
+ * @param {SemVerRange} range version range
+ * @param {string} version the version
+ * @returns {boolean} if version satisfy the range
+ */
+const satisfy = (range, version) => {
+	if (0 in range) {
+		// @ts-expect-error
+		version = parseVersion(version);
+		var fixCount = range[0];
+		// when negated is set it swill set for < instead of >=
+		var negated = fixCount < 0;
+		if (negated) fixCount = -fixCount - 1;
+		for (var i = 0, j = 1, isEqual = true; ; j++, i++) {
+			// cspell:word nequal nequ
+
+			// when isEqual = true:
+			// range         version: EOA/object  undefined  number    string
+			// EOA                    equal       block      big-ver   big-ver
+			// undefined              bigger      next       big-ver   big-ver
+			// number                 smaller     block      cmp       big-cmp
+			// fixed number           smaller     block      cmp-fix   differ
+			// string                 smaller     block      differ    cmp
+			// fixed string           smaller     block      small-cmp cmp-fix
+
+			// when isEqual = false:
+			// range         version: EOA/object  undefined  number    string
+			// EOA                    nequal      block      next-ver  next-ver
+			// undefined              nequal      block      next-ver  next-ver
+			// number                 nequal      block      next      next
+			// fixed number           nequal      block      next      next   (this never happens)
+			// string                 nequal      block      next      next
+			// fixed string           nequal      block      next      next   (this never happens)
+
+			// EOA end of array
+			// equal (version is equal range):
+			//   when !negated: return true,
+			//   when negated: return false
+			// bigger (version is bigger as range):
+			//   when fixed: return false,
+			//   when !negated: return true,
+			//   when negated: return false,
+			// smaller (version is smaller as range):
+			//   when !negated: return false,
+			//   when negated: return true
+			// nequal (version is not equal range (> resp <)): return true
+			// block (version is in different prerelease area): return false
+			// differ (version is different from fixed range (string vs. number)): return false
+			// next: continues to the next items
+			// next-ver: when fixed: return false, continues to the next item only for the version, sets isEqual=false
+			// big-ver: when fixed || negated: return false, continues to the next item only for the version, sets isEqual=false
+			// next-nequ: continues to the next items, sets isEqual=false
+			// cmp (negated === false): version < range => return false, version > range => next-nequ, else => next
+			// cmp (negated === true): version > range => return false, version < range => next-nequ, else => next
+			// cmp-fix: version == range => next, else => return false
+			// big-cmp: when negated => return false, else => next-nequ
+			// small-cmp: when negated => next-nequ, else => return false
 
-module.exports = Hash;
+			var rangeType = j < range.length ? (typeof range[j])[0] : "";
 
+			var versionValue;
+			var versionType;
 
-/***/ }),
+			// Handles first column in both tables (end of version or object)
+			if (
+				i >= version.length ||
+				((versionValue = version[i]),
+				(versionType = (typeof versionValue)[0]) == "o")
+			) {
+				// Handles nequal
+				if (!isEqual) return true;
+				// Handles bigger
+				if (rangeType == "u") return j > fixCount && !negated;
+				// Handles equal and smaller: (range === EOA) XOR negated
+				return (rangeType == "") != negated; // equal + smaller
+			}
 
-/***/ 39104:
-/***/ (function(__unused_webpack_module, exports) {
+			// Handles second column in both tables (version = undefined)
+			if (versionType == "u") {
+				if (!isEqual || rangeType != "u") {
+					return false;
+				}
+			}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+			// switch between first and second table
+			else if (isEqual) {
+				// Handle diagonal
+				if (rangeType == versionType) {
+					if (j <= fixCount) {
+						// Handles "cmp-fix" cases
+						if (versionValue != range[j]) {
+							return false;
+						}
+					} else {
+						// Handles "cmp" cases
+						if (negated ? versionValue > range[j] : versionValue < range[j]) {
+							return false;
+						}
+						if (versionValue != range[j]) isEqual = false;
+					}
+				}
 
+				// Handle big-ver
+				else if (rangeType != "s" && rangeType != "n") {
+					if (negated || j <= fixCount) return false;
+					isEqual = false;
+					j--;
+				}
 
+				// Handle differ, big-cmp and small-cmp
+				else if (j <= fixCount || versionType < rangeType != negated) {
+					return false;
+				} else {
+					isEqual = false;
+				}
+			} else {
+				// Handles all "next-ver" cases in the second table
+				if (rangeType != "s" && rangeType != "n") {
+					isEqual = false;
+					j--;
+				}
 
-/**
- * @template T
- * @param {Iterable<T>} set a set
- * @returns {T | undefined} last item
- */
-const last = set => {
-	let last;
-	for (const item of set) last = item;
-	return last;
+				// next is applied by default
+			}
+		}
+	}
+	/** @type {(boolean | number)[]} */
+	var stack = [];
+	var p = stack.pop.bind(stack);
+	// eslint-disable-next-line no-redeclare
+	for (var i = 1; i < range.length; i++) {
+		var item = /** @type {SemVerRange | 0 | 1 | 2} */ (range[i]);
+		stack.push(
+			item == 1
+				? p() | p()
+				: item == 2
+				? p() & p()
+				: item
+				? satisfy(item, version)
+				: !p()
+		);
+	}
+	return !!p();
 };
+/* eslint-enable eqeqeq */
+exports.satisfy = satisfy;
 
-/**
- * @template T
- * @param {Iterable<T>} iterable iterable
- * @param {function(T): boolean} filter predicate
- * @returns {boolean} true, if some items match the filter predicate
- */
-const someInIterable = (iterable, filter) => {
-	for (const item of iterable) {
-		if (filter(item)) return true;
+exports.stringifyHoley = json => {
+	switch (typeof json) {
+		case "undefined":
+			return "";
+		case "object":
+			if (Array.isArray(json)) {
+				let str = "[";
+				for (let i = 0; i < json.length; i++) {
+					if (i !== 0) str += ",";
+					str += this.stringifyHoley(json[i]);
+				}
+				str += "]";
+				return str;
+			} else {
+				return JSON.stringify(json);
+			}
+		default:
+			return JSON.stringify(json);
 	}
-	return false;
 };
 
-/**
- * @template T
- * @param {Iterable<T>} iterable an iterable
- * @returns {number} count of items
- */
-const countIterable = iterable => {
-	let i = 0;
-	// eslint-disable-next-line no-unused-vars
-	for (const _ of iterable) i++;
-	return i;
-};
+//#region runtime code: parseVersion
+exports.parseVersionRuntimeCode = runtimeTemplate =>
+	`var parseVersion = ${runtimeTemplate.basicFunction("str", [
+		"// see webpack/lib/util/semver.js for original code",
+		`var p=${
+			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
+		}{return p.split(".").map((${
+			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
+		}{return+p==p?+p:p}))},n=/^([^-+]+)?(?:-([^+]+))?(?:\\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;`
+	])}`;
+//#endregion
 
-exports.last = last;
-exports.someInIterable = someInIterable;
-exports.countIterable = countIterable;
+//#region runtime code: versionLt
+exports.versionLtRuntimeCode = runtimeTemplate =>
+	`var versionLt = ${runtimeTemplate.basicFunction("a, b", [
+		"// see webpack/lib/util/semver.js for original code",
+		'a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}'
+	])}`;
+//#endregion
+
+//#region runtime code: rangeToString
+exports.rangeToStringRuntimeCode = runtimeTemplate =>
+	`var rangeToString = ${runtimeTemplate.basicFunction("range", [
+		"// see webpack/lib/util/semver.js for original code",
+		'var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\\((.+)\\)$/,"$1")}'
+	])}`;
+//#endregion
+
+//#region runtime code: satisfy
+exports.satisfyRuntimeCode = runtimeTemplate =>
+	`var satisfy = ${runtimeTemplate.basicFunction("range, version", [
+		"// see webpack/lib/util/semver.js for original code",
+		'if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1;a=!1}else"s"!=g&&"n"!=g&&(a=!1,i--)}}var t=[],o=t.pop.bind(t);for(n=1;n<range.length;n++){var u=range[n];t.push(1==u?o()|o():2==u?o()&o():u?satisfy(u,version):!o())}return!!o();'
+	])}`;
+//#endregion
 
 
 /***/ }),
 
-/***/ 48424:
+/***/ 8282:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const { first } = __webpack_require__(93347);
-const SortableSet = __webpack_require__(13098);
-
-/**
- * Multi layer bucket sorted set:
- * Supports adding non-existing items (DO NOT ADD ITEM TWICE),
- * Supports removing exiting items (DO NOT REMOVE ITEM NOT IN SET),
- * Supports popping the first items according to defined order,
- * Supports iterating all items without order,
- * Supports updating an item in an efficient way,
- * Supports size property, which is the number of items,
- * Items are lazy partially sorted when needed
- * @template T
- * @template K
- */
-class LazyBucketSortedSet {
-	/**
-	 * @param {function(T): K} getKey function to get key from item
-	 * @param {function(K, K): number} comparator comparator to sort keys
-	 * @param  {...((function(T): any) | (function(any, any): number))} args more pairs of getKey and comparator plus optional final comparator for the last layer
-	 */
-	constructor(getKey, comparator, ...args) {
-		this._getKey = getKey;
-		this._innerArgs = args;
-		this._leaf = args.length <= 1;
-		this._keys = new SortableSet(undefined, comparator);
-		/** @type {Map<K, LazyBucketSortedSet<T, any> | SortableSet<T>>} */
-		this._map = new Map();
-		this._unsortedItems = new Set();
-		this.size = 0;
-	}
-
-	/**
-	 * @param {T} item an item
-	 * @returns {void}
-	 */
-	add(item) {
-		this.size++;
-		this._unsortedItems.add(item);
-	}
+const memoize = __webpack_require__(78676);
 
-	/**
-	 * @param {K} key key of item
-	 * @param {T} item the item
-	 * @returns {void}
-	 */
-	_addInternal(key, item) {
-		let entry = this._map.get(key);
-		if (entry === undefined) {
-			entry = this._leaf
-				? new SortableSet(undefined, this._innerArgs[0])
-				: new /** @type {any} */ (LazyBucketSortedSet)(...this._innerArgs);
-			this._keys.add(key);
-			this._map.set(key, entry);
-		}
-		entry.add(item);
-	}
+/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
+/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/Serializer")} Serializer */
 
-	/**
-	 * @param {T} item an item
-	 * @returns {void}
-	 */
-	delete(item) {
-		this.size--;
-		if (this._unsortedItems.has(item)) {
-			this._unsortedItems.delete(item);
-			return;
-		}
-		const key = this._getKey(item);
-		const entry = this._map.get(key);
-		entry.delete(item);
-		if (entry.size === 0) {
-			this._deleteKey(key);
-		}
-	}
+const getBinaryMiddleware = memoize(() =>
+	__webpack_require__(97059)
+);
+const getObjectMiddleware = memoize(() =>
+	__webpack_require__(34795)
+);
+const getSingleItemMiddleware = memoize(() =>
+	__webpack_require__(65112)
+);
+const getSerializer = memoize(() => __webpack_require__(53080));
+const getSerializerMiddleware = memoize(() =>
+	__webpack_require__(83137)
+);
 
-	/**
-	 * @param {K} key key to be removed
-	 * @returns {void}
-	 */
-	_deleteKey(key) {
-		this._keys.delete(key);
-		this._map.delete(key);
-	}
+const getBinaryMiddlewareInstance = memoize(
+	() => new (getBinaryMiddleware())()
+);
 
-	/**
-	 * @returns {T | undefined} an item
-	 */
-	popFirst() {
-		if (this.size === 0) return undefined;
-		this.size--;
-		if (this._unsortedItems.size > 0) {
-			for (const item of this._unsortedItems) {
-				const key = this._getKey(item);
-				this._addInternal(key, item);
-			}
-			this._unsortedItems.clear();
-		}
-		this._keys.sort();
-		const key = first(this._keys);
-		const entry = this._map.get(key);
-		if (this._leaf) {
-			const leafEntry = /** @type {SortableSet<T>} */ (entry);
-			leafEntry.sort();
-			const item = first(leafEntry);
-			leafEntry.delete(item);
-			if (leafEntry.size === 0) {
-				this._deleteKey(key);
-			}
-			return item;
-		} else {
-			const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
-			const item = nodeEntry.popFirst();
-			if (nodeEntry.size === 0) {
-				this._deleteKey(key);
-			}
-			return item;
-		}
-	}
+const registerSerializers = memoize(() => {
+	__webpack_require__(26611);
 
-	/**
-	 * @param {T} item to be updated item
-	 * @returns {function(true=): void} finish update
-	 */
-	startUpdate(item) {
-		if (this._unsortedItems.has(item)) {
-			return remove => {
-				if (remove) {
-					this._unsortedItems.delete(item);
-					this.size--;
-					return;
-				}
-			};
-		}
-		const key = this._getKey(item);
-		if (this._leaf) {
-			const oldEntry = /** @type {SortableSet<T>} */ (this._map.get(key));
-			return remove => {
-				if (remove) {
-					this.size--;
-					oldEntry.delete(item);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					return;
-				}
-				const newKey = this._getKey(item);
-				if (key === newKey) {
-					// This flags the sortable set as unordered
-					oldEntry.add(item);
-				} else {
-					oldEntry.delete(item);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					this._addInternal(newKey, item);
-				}
-			};
+	// Load internal paths with a relative require
+	// This allows bundling all internal serializers
+	const internalSerializables = __webpack_require__(53023);
+	getObjectMiddleware().registerLoader(/^webpack\/lib\//, req => {
+		const loader = internalSerializables[req.slice("webpack/lib/".length)];
+		if (loader) {
+			loader();
 		} else {
-			const oldEntry = /** @type {LazyBucketSortedSet<T, any>} */ (
-				this._map.get(key)
-			);
-			const finishUpdate = oldEntry.startUpdate(item);
-			return remove => {
-				if (remove) {
-					this.size--;
-					finishUpdate(true);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					return;
-				}
-				const newKey = this._getKey(item);
-				if (key === newKey) {
-					finishUpdate();
-				} else {
-					finishUpdate(true);
-					if (oldEntry.size === 0) {
-						this._deleteKey(key);
-					}
-					this._addInternal(newKey, item);
-				}
-			};
+			console.warn(`${req} not found in internalSerializables`);
 		}
-	}
+		return true;
+	});
+});
 
-	/**
-	 * @param {Iterator<T>[]} iterators list of iterators to append to
-	 * @returns {void}
-	 */
-	_appendIterators(iterators) {
-		if (this._unsortedItems.size > 0)
-			iterators.push(this._unsortedItems[Symbol.iterator]());
-		for (const key of this._keys) {
-			const entry = this._map.get(key);
-			if (this._leaf) {
-				const leafEntry = /** @type {SortableSet<T>} */ (entry);
-				const iterator = leafEntry[Symbol.iterator]();
-				iterators.push(iterator);
-			} else {
-				const nodeEntry = /** @type {LazyBucketSortedSet<T, any>} */ (entry);
-				nodeEntry._appendIterators(iterators);
-			}
-		}
-	}
+/** @type {Serializer} */
+let buffersSerializer;
 
-	/**
-	 * @returns {Iterator<T>} the iterator
-	 */
-	[Symbol.iterator]() {
-		const iterators = [];
-		this._appendIterators(iterators);
-		iterators.reverse();
-		let currentIterator = iterators.pop();
-		return {
-			next: () => {
-				const res = currentIterator.next();
-				if (res.done) {
-					if (iterators.length === 0) return res;
-					currentIterator = iterators.pop();
-					return currentIterator.next();
+// Expose serialization API
+module.exports = {
+	get register() {
+		return getObjectMiddleware().register;
+	},
+	get registerLoader() {
+		return getObjectMiddleware().registerLoader;
+	},
+	get registerNotSerializable() {
+		return getObjectMiddleware().registerNotSerializable;
+	},
+	get NOT_SERIALIZABLE() {
+		return getObjectMiddleware().NOT_SERIALIZABLE;
+	},
+	/** @type {MEASURE_START_OPERATION} */
+	get MEASURE_START_OPERATION() {
+		return getBinaryMiddleware().MEASURE_START_OPERATION;
+	},
+	/** @type {MEASURE_END_OPERATION} */
+	get MEASURE_END_OPERATION() {
+		return getBinaryMiddleware().MEASURE_END_OPERATION;
+	},
+	get buffersSerializer() {
+		if (buffersSerializer !== undefined) return buffersSerializer;
+		registerSerializers();
+		const Serializer = getSerializer();
+		const binaryMiddleware = getBinaryMiddlewareInstance();
+		const SerializerMiddleware = getSerializerMiddleware();
+		const SingleItemMiddleware = getSingleItemMiddleware();
+		return (buffersSerializer = new Serializer([
+			new SingleItemMiddleware(),
+			new (getObjectMiddleware())(context => {
+				if (context.write) {
+					context.writeLazy = value => {
+						context.write(
+							SerializerMiddleware.createLazy(value, binaryMiddleware)
+						);
+					};
 				}
-				return res;
-			}
-		};
+			}, "md4"),
+			binaryMiddleware
+		]));
+	},
+	createFileSerializer: (fs, hashFunction) => {
+		registerSerializers();
+		const Serializer = getSerializer();
+		const FileMiddleware = __webpack_require__(65321);
+		const fileMiddleware = new FileMiddleware(fs, hashFunction);
+		const binaryMiddleware = getBinaryMiddlewareInstance();
+		const SerializerMiddleware = getSerializerMiddleware();
+		const SingleItemMiddleware = getSingleItemMiddleware();
+		return new Serializer([
+			new SingleItemMiddleware(),
+			new (getObjectMiddleware())(context => {
+				if (context.write) {
+					context.writeLazy = value => {
+						context.write(
+							SerializerMiddleware.createLazy(value, binaryMiddleware)
+						);
+					};
+					context.writeSeparate = (value, options) => {
+						const lazy = SerializerMiddleware.createLazy(
+							value,
+							fileMiddleware,
+							options
+						);
+						context.write(lazy);
+						return lazy;
+					};
+				}
+			}, hashFunction),
+			binaryMiddleware,
+			fileMiddleware
+		]);
 	}
-}
-
-module.exports = LazyBucketSortedSet;
+};
 
 
 /***/ }),
 
-/***/ 38938:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 15652:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -129227,242 +129262,462 @@ module.exports = LazyBucketSortedSet;
 
 
 
-const makeSerializable = __webpack_require__(33032);
+/**
+ * @typedef {Object} GroupOptions
+ * @property {boolean=} groupChildren
+ * @property {boolean=} force
+ * @property {number=} targetGroupCount
+ */
 
 /**
  * @template T
- * @param {Set<T>} targetSet set where items should be added
- * @param {Set<Iterable<T>>} toMerge iterables to be merged
- * @returns {void}
+ * @template R
+ * @typedef {Object} GroupConfig
+ * @property {function(T): string[]} getKeys
+ * @property {function(string, (R | T)[], T[]): R} createGroup
+ * @property {function(string, T[]): GroupOptions=} getOptions
  */
-const merge = (targetSet, toMerge) => {
-	for (const set of toMerge) {
-		for (const item of set) {
-			targetSet.add(item);
-		}
-	}
-};
 
 /**
  * @template T
- * @param {Set<Iterable<T>>} targetSet set where iterables should be added
- * @param {Array<LazySet<T>>} toDeepMerge lazy sets to be flattened
- * @returns {void}
+ * @template R
+ * @typedef {Object} ItemWithGroups
+ * @property {T} item
+ * @property {Set<Group<T, R>>} groups
  */
-const flatten = (targetSet, toDeepMerge) => {
-	for (const set of toDeepMerge) {
-		if (set._set.size > 0) targetSet.add(set._set);
-		if (set._needMerge) {
-			for (const mergedSet of set._toMerge) {
-				targetSet.add(mergedSet);
-			}
-			flatten(targetSet, set._toDeepMerge);
-		}
-	}
-};
 
 /**
- * Like Set but with an addAll method to eventually add items from another iterable.
- * Access methods make sure that all delayed operations are executed.
- * Iteration methods deopts to normal Set performance until clear is called again (because of the chance of modifications during iteration).
  * @template T
+ * @template R
+ * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
  */
-class LazySet {
-	/**
-	 * @param {Iterable<T>=} iterable init iterable
-	 */
-	constructor(iterable) {
-		/** @type {Set<T>} */
-		this._set = new Set(iterable);
-		/** @type {Set<Iterable<T>>} */
-		this._toMerge = new Set();
-		/** @type {Array<LazySet<T>>} */
-		this._toDeepMerge = [];
-		this._needMerge = false;
-		this._deopt = false;
-	}
-
-	_flatten() {
-		flatten(this._toMerge, this._toDeepMerge);
-		this._toDeepMerge.length = 0;
-	}
-
-	_merge() {
-		this._flatten();
-		merge(this._set, this._toMerge);
-		this._toMerge.clear();
-		this._needMerge = false;
-	}
-
-	_isEmpty() {
-		return (
-			this._set.size === 0 &&
-			this._toMerge.size === 0 &&
-			this._toDeepMerge.length === 0
-		);
-	}
 
-	get size() {
-		if (this._needMerge) this._merge();
-		return this._set.size;
+/**
+ * @template T
+ * @template R
+ * @param {T[]} items the list of items
+ * @param {GroupConfig<T, R>[]} groupConfigs configuration
+ * @returns {(R | T)[]} grouped items
+ */
+const smartGrouping = (items, groupConfigs) => {
+	/** @type {Set<ItemWithGroups<T, R>>} */
+	const itemsWithGroups = new Set();
+	/** @type {Map<string, Group<T, R>>} */
+	const allGroups = new Map();
+	for (const item of items) {
+		/** @type {Set<Group<T, R>>} */
+		const groups = new Set();
+		for (let i = 0; i < groupConfigs.length; i++) {
+			const groupConfig = groupConfigs[i];
+			const keys = groupConfig.getKeys(item);
+			if (keys) {
+				for (const name of keys) {
+					const key = `${i}:${name}`;
+					let group = allGroups.get(key);
+					if (group === undefined) {
+						allGroups.set(
+							key,
+							(group = {
+								config: groupConfig,
+								name,
+								alreadyGrouped: false,
+								items: undefined
+							})
+						);
+					}
+					groups.add(group);
+				}
+			}
+		}
+		itemsWithGroups.add({
+			item,
+			groups
+		});
 	}
-
 	/**
-	 * @param {T} item an item
-	 * @returns {this} itself
+	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
+	 * @returns {(T | R)[]} groups items
 	 */
-	add(item) {
-		this._set.add(item);
-		return this;
-	}
+	const runGrouping = itemsWithGroups => {
+		const totalSize = itemsWithGroups.size;
+		for (const entry of itemsWithGroups) {
+			for (const group of entry.groups) {
+				if (group.alreadyGrouped) continue;
+				const items = group.items;
+				if (items === undefined) {
+					group.items = new Set([entry]);
+				} else {
+					items.add(entry);
+				}
+			}
+		}
+		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
+		const groupMap = new Map();
+		for (const group of allGroups.values()) {
+			if (group.items) {
+				const items = group.items;
+				group.items = undefined;
+				groupMap.set(group, {
+					items,
+					options: undefined,
+					used: false
+				});
+			}
+		}
+		/** @type {(T | R)[]} */
+		const results = [];
+		for (;;) {
+			/** @type {Group<T, R>} */
+			let bestGroup = undefined;
+			let bestGroupSize = -1;
+			let bestGroupItems = undefined;
+			let bestGroupOptions = undefined;
+			for (const [group, state] of groupMap) {
+				const { items, used } = state;
+				let options = state.options;
+				if (options === undefined) {
+					const groupConfig = group.config;
+					state.options = options =
+						(groupConfig.getOptions &&
+							groupConfig.getOptions(
+								group.name,
+								Array.from(items, ({ item }) => item)
+							)) ||
+						false;
+				}
 
-	/**
-	 * @param {Iterable<T> | LazySet<T>} iterable a immutable iterable or another immutable LazySet which will eventually be merged into the Set
-	 * @returns {this} itself
-	 */
-	addAll(iterable) {
-		if (this._deopt) {
-			const _set = this._set;
-			for (const item of iterable) {
-				_set.add(item);
+				const force = options && options.force;
+				if (!force) {
+					if (bestGroupOptions && bestGroupOptions.force) continue;
+					if (used) continue;
+					if (items.size <= 1 || totalSize - items.size <= 1) {
+						continue;
+					}
+				}
+				const targetGroupCount = (options && options.targetGroupCount) || 4;
+				let sizeValue = force
+					? items.size
+					: Math.min(
+							items.size,
+							(totalSize * 2) / targetGroupCount +
+								itemsWithGroups.size -
+								items.size
+					  );
+				if (
+					sizeValue > bestGroupSize ||
+					(force && (!bestGroupOptions || !bestGroupOptions.force))
+				) {
+					bestGroup = group;
+					bestGroupSize = sizeValue;
+					bestGroupItems = items;
+					bestGroupOptions = options;
+				}
 			}
-		} else {
-			if (iterable instanceof LazySet) {
-				if (iterable._isEmpty()) return this;
-				this._toDeepMerge.push(iterable);
-				this._needMerge = true;
-				if (this._toDeepMerge.length > 100000) {
-					this._flatten();
+			if (bestGroup === undefined) {
+				break;
+			}
+			const items = new Set(bestGroupItems);
+			const options = bestGroupOptions;
+
+			const groupChildren = !options || options.groupChildren !== false;
+
+			for (const item of items) {
+				itemsWithGroups.delete(item);
+				// Remove all groups that items have from the map to not select them again
+				for (const group of item.groups) {
+					const state = groupMap.get(group);
+					if (state !== undefined) {
+						state.items.delete(item);
+						if (state.items.size === 0) {
+							groupMap.delete(group);
+						} else {
+							state.options = undefined;
+							if (groupChildren) {
+								state.used = true;
+							}
+						}
+					}
 				}
-			} else {
-				this._toMerge.add(iterable);
-				this._needMerge = true;
 			}
-			if (this._toMerge.size > 100000) this._merge();
+			groupMap.delete(bestGroup);
+
+			const key = bestGroup.name;
+			const groupConfig = bestGroup.config;
+
+			const allItems = Array.from(items, ({ item }) => item);
+
+			bestGroup.alreadyGrouped = true;
+			const children = groupChildren ? runGrouping(items) : allItems;
+			bestGroup.alreadyGrouped = false;
+
+			results.push(groupConfig.createGroup(key, children, allItems));
 		}
-		return this;
-	}
+		for (const { item } of itemsWithGroups) {
+			results.push(item);
+		}
+		return results;
+	};
+	return runGrouping(itemsWithGroups);
+};
 
-	clear() {
-		this._set.clear();
-		this._toMerge.clear();
-		this._toDeepMerge.length = 0;
-		this._needMerge = false;
-		this._deopt = false;
-	}
+module.exports = smartGrouping;
 
-	/**
-	 * @param {T} value an item
-	 * @returns {boolean} true, if the value was in the Set before
-	 */
-	delete(value) {
-		if (this._needMerge) this._merge();
-		return this._set.delete(value);
-	}
 
-	entries() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set.entries();
-	}
+/***/ }),
 
-	/**
-	 * @param {function(T, T, Set<T>): void} callbackFn function called for each entry
-	 * @param {any} thisArg this argument for the callbackFn
-	 * @returns {void}
-	 */
-	forEach(callbackFn, thisArg) {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		this._set.forEach(callbackFn, thisArg);
-	}
+/***/ 41245:
+/***/ (function(__unused_webpack_module, exports) {
 
-	/**
-	 * @param {T} item an item
-	 * @returns {boolean} true, when the item is in the Set
-	 */
-	has(item) {
-		if (this._needMerge) this._merge();
-		return this._set.has(item);
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	keys() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set.keys();
-	}
 
-	values() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set.values();
-	}
 
-	[Symbol.iterator]() {
-		this._deopt = true;
-		if (this._needMerge) this._merge();
-		return this._set[Symbol.iterator]();
-	}
+/** @typedef {import("webpack-sources").Source} Source */
 
-	/* istanbul ignore next */
-	get [Symbol.toStringTag]() {
-		return "LazySet";
-	}
+/** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
+const equalityCache = new WeakMap();
 
-	serialize({ write }) {
-		if (this._needMerge) this._merge();
-		write(this._set.size);
-		for (const item of this._set) write(item);
-	}
+/**
+ * @param {Source} a a source
+ * @param {Source} b another source
+ * @returns {boolean} true, when both sources are equal
+ */
+const _isSourceEqual = (a, b) => {
+	// prefer .buffer(), it's called anyway during emit
+	/** @type {Buffer|string} */
+	let aSource = typeof a.buffer === "function" ? a.buffer() : a.source();
+	/** @type {Buffer|string} */
+	let bSource = typeof b.buffer === "function" ? b.buffer() : b.source();
+	if (aSource === bSource) return true;
+	if (typeof aSource === "string" && typeof bSource === "string") return false;
+	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf-8");
+	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf-8");
+	return aSource.equals(bSource);
+};
 
-	static deserialize({ read }) {
-		const count = read();
-		const items = [];
-		for (let i = 0; i < count; i++) {
-			items.push(read());
-		}
-		return new LazySet(items);
+/**
+ * @param {Source} a a source
+ * @param {Source} b another source
+ * @returns {boolean} true, when both sources are equal
+ */
+const isSourceEqual = (a, b) => {
+	if (a === b) return true;
+	const cache1 = equalityCache.get(a);
+	if (cache1 !== undefined) {
+		const result = cache1.get(b);
+		if (result !== undefined) return result;
 	}
-}
+	const result = _isSourceEqual(a, b);
+	if (cache1 !== undefined) {
+		cache1.set(b, result);
+	} else {
+		const map = new WeakMap();
+		map.set(b, result);
+		equalityCache.set(a, map);
+	}
+	const cache2 = equalityCache.get(b);
+	if (cache2 !== undefined) {
+		cache2.set(a, result);
+	} else {
+		const map = new WeakMap();
+		map.set(a, result);
+		equalityCache.set(b, map);
+	}
+	return result;
+};
+exports.isSourceEqual = isSourceEqual;
 
-makeSerializable(LazySet, "webpack/lib/util/LazySet");
 
-module.exports = LazySet;
+/***/ }),
 
+/***/ 12047:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/***/ }),
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { validate } = __webpack_require__(38476);
+
+/* cSpell:disable */
+const DID_YOU_MEAN = {
+	rules: "module.rules",
+	loaders: "module.rules or module.rules.*.use",
+	query: "module.rules.*.options (BREAKING CHANGE since webpack 5)",
+	noParse: "module.noParse",
+	filename: "output.filename or module.rules.*.generator.filename",
+	file: "output.filename",
+	chunkFilename: "output.chunkFilename",
+	chunkfilename: "output.chunkFilename",
+	ecmaVersion:
+		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	ecmaversion:
+		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	ecma: "output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
+	path: "output.path",
+	pathinfo: "output.pathinfo",
+	pathInfo: "output.pathinfo",
+	jsonpFunction: "output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
+	chunkCallbackName:
+		"output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
+	jsonpScriptType: "output.scriptType (BREAKING CHANGE since webpack 5)",
+	hotUpdateFunction: "output.hotUpdateGlobal (BREAKING CHANGE since webpack 5)",
+	splitChunks: "optimization.splitChunks",
+	immutablePaths: "snapshot.immutablePaths",
+	managedPaths: "snapshot.managedPaths",
+	maxModules: "stats.modulesSpace (BREAKING CHANGE since webpack 5)",
+	hashedModuleIds:
+		'optimization.moduleIds: "hashed" (BREAKING CHANGE since webpack 5)',
+	namedChunks:
+		'optimization.chunkIds: "named" (BREAKING CHANGE since webpack 5)',
+	namedModules:
+		'optimization.moduleIds: "named" (BREAKING CHANGE since webpack 5)',
+	occurrenceOrder:
+		'optimization.chunkIds: "size" and optimization.moduleIds: "size" (BREAKING CHANGE since webpack 5)',
+	automaticNamePrefix:
+		"optimization.splitChunks.[cacheGroups.*].idHint (BREAKING CHANGE since webpack 5)",
+	noEmitOnErrors:
+		"optimization.emitOnErrors (BREAKING CHANGE since webpack 5: logic is inverted to avoid negative flags)",
+	Buffer:
+		"to use the ProvidePlugin to process the Buffer variable to modules as polyfill\n" +
+		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
+		"Note: if you are using 'node.Buffer: false', you can just remove that as this is the default behavior now.\n" +
+		"To provide a polyfill to modules use:\n" +
+		'new ProvidePlugin({ Buffer: ["buffer", "Buffer"] }) and npm install buffer.',
+	process:
+		"to use the ProvidePlugin to process the process variable to modules as polyfill\n" +
+		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
+		"Note: if you are using 'node.process: false', you can just remove that as this is the default behavior now.\n" +
+		"To provide a polyfill to modules use:\n" +
+		'new ProvidePlugin({ process: "process" }) and npm install buffer.'
+};
+
+const REMOVED = {
+	concord:
+		"BREAKING CHANGE: resolve.concord has been removed and is no longer available.",
+	devtoolLineToLine:
+		"BREAKING CHANGE: output.devtoolLineToLine has been removed and is no longer available."
+};
+/* cSpell:enable */
+
+/**
+ * @param {Parameters<typeof validate>[0]} schema a json schema
+ * @param {Parameters<typeof validate>[1]} options the options that should be validated
+ * @param {Parameters<typeof validate>[2]=} validationConfiguration configuration for generating errors
+ * @returns {void}
+ */
+const validateSchema = (schema, options, validationConfiguration) => {
+	validate(
+		schema,
+		options,
+		validationConfiguration || {
+			name: "Webpack",
+			postFormatter: (formattedError, error) => {
+				const children = error.children;
+				if (
+					children &&
+					children.some(
+						child =>
+							child.keyword === "absolutePath" &&
+							child.dataPath === ".output.filename"
+					)
+				) {
+					return `${formattedError}\nPlease use output.path to specify absolute path and output.filename for the file name.`;
+				}
+
+				if (
+					children &&
+					children.some(
+						child =>
+							child.keyword === "pattern" && child.dataPath === ".devtool"
+					)
+				) {
+					return (
+						`${formattedError}\n` +
+						"BREAKING CHANGE since webpack 5: The devtool option is more strict.\n" +
+						"Please strictly follow the order of the keywords in the pattern."
+					);
+				}
 
-/***/ 82482:
-/***/ (function(__unused_webpack_module, exports) {
+				if (error.keyword === "additionalProperties") {
+					const params =
+						/** @type {import("ajv").AdditionalPropertiesParams} */ (
+							error.params
+						);
+					if (
+						Object.prototype.hasOwnProperty.call(
+							DID_YOU_MEAN,
+							params.additionalProperty
+						)
+					) {
+						return `${formattedError}\nDid you mean ${
+							DID_YOU_MEAN[params.additionalProperty]
+						}?`;
+					}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+					if (
+						Object.prototype.hasOwnProperty.call(
+							REMOVED,
+							params.additionalProperty
+						)
+					) {
+						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
+					}
 
+					if (!error.dataPath) {
+						if (params.additionalProperty === "debug") {
+							return (
+								`${formattedError}\n` +
+								"The 'debug' property was removed in webpack 2.0.0.\n" +
+								"Loaders should be updated to allow passing this option via loader options in module.rules.\n" +
+								"Until loaders are updated one can use the LoaderOptionsPlugin to switch loaders into debug mode:\n" +
+								"plugins: [\n" +
+								"  new webpack.LoaderOptionsPlugin({\n" +
+								"    debug: true\n" +
+								"  })\n" +
+								"]"
+							);
+						}
 
+						if (params.additionalProperty) {
+							return (
+								`${formattedError}\n` +
+								"For typos: please correct them.\n" +
+								"For loader options: webpack >= v2.0.0 no longer allows custom properties in configuration.\n" +
+								"  Loaders should be updated to allow passing options via loader options in module.rules.\n" +
+								"  Until loaders are updated one can use the LoaderOptionsPlugin to pass these options to the loader:\n" +
+								"  plugins: [\n" +
+								"    new webpack.LoaderOptionsPlugin({\n" +
+								"      // test: /\\.xxx$/, // may apply this only for some modules\n" +
+								"      options: {\n" +
+								`        ${params.additionalProperty}: …\n` +
+								"      }\n" +
+								"    })\n" +
+								"  ]"
+							);
+						}
+					}
+				}
 
-/**
- * @template K
- * @template V
- * @param {Map<K, V>} map a map
- * @param {K} key the key
- * @param {function(): V} computer compute value
- * @returns {V} value
- */
-exports.provide = (map, key, computer) => {
-	const value = map.get(key);
-	if (value !== undefined) return value;
-	const newValue = computer();
-	map.set(key, newValue);
-	return newValue;
+				return formattedError;
+			}
+		}
+	);
 };
+module.exports = validateSchema;
 
 
 /***/ }),
 
-/***/ 50780:
+/***/ 5434:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -129473,64 +129728,83 @@ exports.provide = (map, key, computer) => {
 
 
 
-const binarySearchBounds = __webpack_require__(92229);
-
-class ParallelismFactorCalculator {
-	constructor() {
-		this._rangePoints = [];
-		this._rangeCallbacks = [];
-	}
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
 
-	range(start, end, callback) {
-		if (start === end) return callback(1);
-		this._rangePoints.push(start);
-		this._rangePoints.push(end);
-		this._rangeCallbacks.push(callback);
+class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
+	constructor({ generateLoadBinaryCode, supportsStreaming }) {
+		super("wasm loading", RuntimeModule.STAGE_NORMAL);
+		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		this.supportsStreaming = supportsStreaming;
 	}
 
-	calculate() {
-		const segments = Array.from(new Set(this._rangePoints)).sort((a, b) =>
-			a < b ? -1 : 1
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunk } = this;
+		const { outputOptions, runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.instantiateWasm;
+		const wasmModuleSrcPath = compilation.getPath(
+			JSON.stringify(outputOptions.webassemblyModuleFilename),
+			{
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+				module: {
+					id: '" + wasmModuleId + "',
+					hash: `" + wasmModuleHash + "`,
+					hashWithLength(length) {
+						return `" + wasmModuleHash.slice(0, ${length}) + "`;
+					}
+				},
+				runtime: chunk.runtime
+			}
 		);
-		const parallelism = segments.map(() => 0);
-		const rangeStartIndices = [];
-		for (let i = 0; i < this._rangePoints.length; i += 2) {
-			const start = this._rangePoints[i];
-			const end = this._rangePoints[i + 1];
-			let idx = binarySearchBounds.eq(segments, start);
-			rangeStartIndices.push(idx);
-			do {
-				parallelism[idx]++;
-				idx++;
-			} while (segments[idx] < end);
-		}
-		for (let i = 0; i < this._rangeCallbacks.length; i++) {
-			const start = this._rangePoints[i * 2];
-			const end = this._rangePoints[i * 2 + 1];
-			let idx = rangeStartIndices[i];
-			let sum = 0;
-			let totalDuration = 0;
-			let current = start;
-			do {
-				const p = parallelism[idx];
-				idx++;
-				const duration = segments[idx] - current;
-				totalDuration += duration;
-				current = segments[idx];
-				sum += p * duration;
-			} while (current < end);
-			this._rangeCallbacks[i](sum / totalDuration);
-		}
+		return `${fn} = ${runtimeTemplate.basicFunction(
+			"exports, wasmModuleId, wasmModuleHash, importsObj",
+			[
+				`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
+				this.supportsStreaming
+					? Template.asString([
+							"if (typeof WebAssembly.instantiateStreaming === 'function') {",
+							Template.indent([
+								"return WebAssembly.instantiateStreaming(req, importsObj)",
+								Template.indent([
+									`.then(${runtimeTemplate.returningFunction(
+										"Object.assign(exports, res.instance.exports)",
+										"res"
+									)});`
+								])
+							]),
+							"}"
+					  ])
+					: "// no support for streaming compilation",
+				"return req",
+				Template.indent([
+					`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
+					`.then(${runtimeTemplate.returningFunction(
+						"WebAssembly.instantiate(bytes, importsObj)",
+						"bytes"
+					)})`,
+					`.then(${runtimeTemplate.returningFunction(
+						"Object.assign(exports, res.instance.exports)",
+						"res"
+					)});`
+				])
+			]
+		)};`;
 	}
 }
 
-module.exports = ParallelismFactorCalculator;
+module.exports = AsyncWasmLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 65930:
-/***/ (function(module) {
+/***/ 58461:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -129540,56 +129814,58 @@ module.exports = ParallelismFactorCalculator;
 
 
 
-/**
- * @template T
- */
-class Queue {
-	/**
-	 * @param {Iterable<T>=} items The initial elements.
-	 */
-	constructor(items) {
-		/** @private @type {Set<T>} */
-		this._set = new Set(items);
-		/** @private @type {Iterator<T>} */
-		this._iterator = this._set[Symbol.iterator]();
+const Generator = __webpack_require__(93401);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+
+const TYPES = new Set(["webassembly"]);
+
+class AsyncWebAssemblyGenerator extends Generator {
+	constructor(options) {
+		super();
+		this.options = options;
 	}
 
 	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	get length() {
-		return this._set.size;
+	getTypes(module) {
+		return TYPES;
 	}
 
 	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	enqueue(item) {
-		this._set.add(item);
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 0;
+		}
+		return originalSource.size();
 	}
 
 	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	dequeue() {
-		const result = this._iterator.next();
-		if (result.done) return undefined;
-		this._set.delete(result.value);
-		return result.value;
+	generate(module, generateContext) {
+		return module.originalSource();
 	}
 }
 
-module.exports = Queue;
+module.exports = AsyncWebAssemblyGenerator;
 
 
 /***/ }),
 
-/***/ 93347:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 95614:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -129599,99 +129875,199 @@ module.exports = Queue;
 
 
 
-/**
- * intersect creates Set containing the intersection of elements between all sets
- * @template T
- * @param {Set<T>[]} sets an array of sets being checked for shared elements
- * @returns {Set<T>} returns a new Set containing the intersecting items
- */
-const intersect = sets => {
-	if (sets.length === 0) return new Set();
-	if (sets.length === 1) return new Set(sets[0]);
-	let minSize = Infinity;
-	let minIndex = -1;
-	for (let i = 0; i < sets.length; i++) {
-		const size = sets[i].size;
-		if (size < minSize) {
-			minIndex = i;
-			minSize = size;
-		}
-	}
-	const current = new Set(sets[minIndex]);
-	for (let i = 0; i < sets.length; i++) {
-		if (i === minIndex) continue;
-		const set = sets[i];
-		for (const item of current) {
-			if (!set.has(item)) {
-				current.delete(item);
-			}
-		}
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+const TYPES = new Set(["webassembly"]);
+
+class AsyncWebAssemblyJavascriptGenerator extends Generator {
+	constructor(filenameTemplate) {
+		super();
+		this.filenameTemplate = filenameTemplate;
 	}
-	return current;
-};
 
-/**
- * Checks if a set is the subset of another set
- * @template T
- * @param {Set<T>} bigSet a Set which contains the original elements to compare against
- * @param {Set<T>} smallSet the set whose elements might be contained inside of bigSet
- * @returns {boolean} returns true if smallSet contains all elements inside of the bigSet
- */
-const isSubset = (bigSet, smallSet) => {
-	if (bigSet.size < smallSet.size) return false;
-	for (const item of smallSet) {
-		if (!bigSet.has(item)) return false;
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
 	}
-	return true;
-};
 
-/**
- * @template T
- * @param {Set<T>} set a set
- * @param {function(T): boolean} fn selector function
- * @returns {T | undefined} found item
- */
-const find = (set, fn) => {
-	for (const item of set) {
-		if (fn(item)) return item;
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 40 + module.dependencies.length * 10;
 	}
-};
 
-/**
- * @template T
- * @param {Set<T>} set a set
- * @returns {T | undefined} first item
- */
-const first = set => {
-	const entry = set.values().next();
-	return entry.done ? undefined : entry.value;
-};
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtime
+		} = generateContext;
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
+		/** @type {InitFragment[]} */
+		const initFragments = [];
+		/** @type {Map<Module, { request: string, importVar: string }>} */
+		const depModules = new Map();
+		/** @type {Map<string, WebAssemblyImportDependency[]>} */
+		const wasmDepsByRequest = new Map();
+		for (const dep of module.dependencies) {
+			if (dep instanceof WebAssemblyImportDependency) {
+				const module = moduleGraph.getModule(dep);
+				if (!depModules.has(module)) {
+					depModules.set(module, {
+						request: dep.request,
+						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
+					});
+				}
+				let list = wasmDepsByRequest.get(dep.request);
+				if (list === undefined) {
+					list = [];
+					wasmDepsByRequest.set(dep.request, list);
+				}
+				list.push(dep);
+			}
+		}
 
-/**
- * @template T
- * @param {Set<T>} a first
- * @param {Set<T>} b second
- * @returns {Set<T>} combined set, may be identical to a or b
- */
-const combine = (a, b) => {
-	if (b.size === 0) return a;
-	if (a.size === 0) return b;
-	const set = new Set(a);
-	for (const item of b) set.add(item);
-	return set;
-};
+		const promises = [];
+
+		const importStatements = Array.from(
+			depModules,
+			([importedModule, { request, importVar }]) => {
+				if (moduleGraph.isAsync(importedModule)) {
+					promises.push(importVar);
+				}
+				return runtimeTemplate.importStatement({
+					update: false,
+					module: importedModule,
+					chunkGraph,
+					request,
+					originModule: module,
+					importVar,
+					runtimeRequirements
+				});
+			}
+		);
+		const importsCode = importStatements.map(([x]) => x).join("");
+		const importsCompatCode = importStatements.map(([_, x]) => x).join("");
+
+		const importObjRequestItems = Array.from(
+			wasmDepsByRequest,
+			([request, deps]) => {
+				const exportItems = deps.map(dep => {
+					const importedModule = moduleGraph.getModule(dep);
+					const importVar = depModules.get(importedModule).importVar;
+					return `${JSON.stringify(
+						dep.name
+					)}: ${runtimeTemplate.exportFromImport({
+						moduleGraph,
+						module: importedModule,
+						request,
+						exportName: dep.name,
+						originModule: module,
+						asiSafe: true,
+						isCall: false,
+						callContext: false,
+						defaultInterop: true,
+						importVar,
+						initFragments,
+						runtime,
+						runtimeRequirements
+					})}`;
+				});
+				return Template.asString([
+					`${JSON.stringify(request)}: {`,
+					Template.indent(exportItems.join(",\n")),
+					"}"
+				]);
+			}
+		);
+
+		const importsObj =
+			importObjRequestItems.length > 0
+				? Template.asString([
+						"{",
+						Template.indent(importObjRequestItems.join(",\n")),
+						"}"
+				  ])
+				: undefined;
+
+		const instantiateCall =
+			`${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
+				module.moduleArgument
+			}.id, ${JSON.stringify(
+				chunkGraph.getRenderedModuleHash(module, runtime)
+			)}` + (importsObj ? `, ${importsObj})` : `)`);
+
+		if (promises.length > 0)
+			runtimeRequirements.add(RuntimeGlobals.asyncModule);
+
+		const source = new RawSource(
+			promises.length > 0
+				? Template.asString([
+						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
+							`[${promises.join(", ")}]`,
+							`${importsCompatCode}return ${instantiateCall};`
+						)}`,
+						`${RuntimeGlobals.asyncModule}(${
+							module.moduleArgument
+						}, async ${runtimeTemplate.basicFunction(
+							"__webpack_handle_async_dependencies__, __webpack_async_result__",
+							[
+								"try {",
+								importsCode,
+								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
+									", "
+								)}]);`,
+								`var [${promises.join(
+									", "
+								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
+								`${importsCompatCode}await ${instantiateCall};`,
+								"__webpack_async_result__();",
+								"} catch(e) { __webpack_async_result__(e); }"
+							]
+						)}, 1);`
+				  ])
+				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
+		);
 
-exports.intersect = intersect;
-exports.isSubset = isSubset;
-exports.find = find;
-exports.first = first;
-exports.combine = combine;
+		return InitFragment.addToSource(source, initFragments, generateContext);
+	}
+}
+
+module.exports = AsyncWebAssemblyJavascriptGenerator;
 
 
 /***/ }),
 
-/***/ 13098:
-/***/ (function(module) {
+/***/ 7538:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -129701,165 +130077,203 @@ exports.combine = combine;
 
 
 
-const NONE = Symbol("not sorted");
+const { SyncWaterfallHook } = __webpack_require__(6967);
+const Compilation = __webpack_require__(85720);
+const Generator = __webpack_require__(93401);
+const { tryRunOrWebpackError } = __webpack_require__(11351);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
+
+const getAsyncWebAssemblyGenerator = memoize(() =>
+	__webpack_require__(58461)
+);
+const getAsyncWebAssemblyJavascriptGenerator = memoize(() =>
+	__webpack_require__(95614)
+);
+const getAsyncWebAssemblyParser = memoize(() =>
+	__webpack_require__(96305)
+);
 
 /**
- * A subset of Set that offers sorting functionality
- * @template T item type in set
- * @extends {Set<T>}
+ * @typedef {Object} WebAssemblyRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
  */
-class SortableSet extends Set {
-	/**
-	 * Create a new sortable set
-	 * @param {Iterable<T>=} initialIterable The initial iterable value
-	 * @typedef {function(T, T): number} SortFunction
-	 * @param {SortFunction=} defaultSort Default sorting function
-	 */
-	constructor(initialIterable, defaultSort) {
-		super(initialIterable);
-		/** @private @type {undefined | function(T, T): number}} */
-		this._sortFn = defaultSort;
-		/** @private @type {typeof NONE | undefined | function(T, T): number}} */
-		this._lastActiveSortFn = NONE;
-		/** @private @type {Map<Function, any> | undefined} */
-		this._cache = undefined;
-		/** @private @type {Map<Function, any> | undefined} */
-		this._cacheOrderIndependent = undefined;
-	}
 
-	/**
-	 * @param {T} value value to add to set
-	 * @returns {this} returns itself
-	 */
-	add(value) {
-		this._lastActiveSortFn = NONE;
-		this._invalidateCache();
-		this._invalidateOrderedCache();
-		super.add(value);
-		return this;
-	}
+/**
+ * @typedef {Object} CompilationHooks
+ * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
+ */
+
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
 
+class AsyncWebAssemblyModulesPlugin {
 	/**
-	 * @param {T} value value to delete
-	 * @returns {boolean} true if value existed in set, false otherwise
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
 	 */
-	delete(value) {
-		this._invalidateCache();
-		this._invalidateOrderedCache();
-		return super.delete(value);
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				renderModuleContent: new SyncWaterfallHook([
+					"source",
+					"module",
+					"renderContext"
+				])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
 	}
 
-	/**
-	 * @returns {void}
-	 */
-	clear() {
-		this._invalidateCache();
-		this._invalidateOrderedCache();
-		return super.clear();
+	constructor(options) {
+		this.options = options;
 	}
 
 	/**
-	 * Sort with a comparer function
-	 * @param {SortFunction} sortFn Sorting comparer function
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	sortWith(sortFn) {
-		if (this.size <= 1 || sortFn === this._lastActiveSortFn) {
-			// already sorted - nothing to do
-			return;
-		}
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"AsyncWebAssemblyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				const hooks =
+					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
+				compilation.dependencyFactories.set(
+					WebAssemblyImportDependency,
+					normalModuleFactory
+				);
 
-		const sortedArray = Array.from(this).sort(sortFn);
-		super.clear();
-		for (let i = 0; i < sortedArray.length; i += 1) {
-			super.add(sortedArray[i]);
-		}
-		this._lastActiveSortFn = sortFn;
-		this._invalidateCache();
-	}
+				normalModuleFactory.hooks.createParser
+					.for("webassembly/async")
+					.tap("AsyncWebAssemblyModulesPlugin", () => {
+						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
 
-	sort() {
-		this.sortWith(this._sortFn);
-		return this;
-	}
+						return new AsyncWebAssemblyParser();
+					});
+				normalModuleFactory.hooks.createGenerator
+					.for("webassembly/async")
+					.tap("AsyncWebAssemblyModulesPlugin", () => {
+						const AsyncWebAssemblyJavascriptGenerator =
+							getAsyncWebAssemblyJavascriptGenerator();
+						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
 
-	/**
-	 * Get data from cache
-	 * @template R
-	 * @param {function(SortableSet<T>): R} fn function to calculate value
-	 * @returns {R} returns result of fn(this), cached until set changes
-	 */
-	getFromCache(fn) {
-		if (this._cache === undefined) {
-			this._cache = new Map();
-		} else {
-			const result = this._cache.get(fn);
-			const data = /** @type {R} */ (result);
-			if (data !== undefined) {
-				return data;
-			}
-		}
-		const newData = fn(this);
-		this._cache.set(fn, newData);
-		return newData;
-	}
+						return Generator.byType({
+							javascript: new AsyncWebAssemblyJavascriptGenerator(
+								compilation.outputOptions.webassemblyModuleFilename
+							),
+							webassembly: new AsyncWebAssemblyGenerator(this.options)
+						});
+					});
 
-	/**
-	 * Get data from cache (ignoring sorting)
-	 * @template R
-	 * @param {function(SortableSet<T>): R} fn function to calculate value
-	 * @returns {R} returns result of fn(this), cached until set changes
-	 */
-	getFromUnorderedCache(fn) {
-		if (this._cacheOrderIndependent === undefined) {
-			this._cacheOrderIndependent = new Map();
-		} else {
-			const result = this._cacheOrderIndependent.get(fn);
-			const data = /** @type {R} */ (result);
-			if (data !== undefined) {
-				return data;
-			}
-		}
-		const newData = fn(this);
-		this._cacheOrderIndependent.set(fn, newData);
-		return newData;
-	}
+				compilation.hooks.renderManifest.tap(
+					"WebAssemblyModulesPlugin",
+					(result, options) => {
+						const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
+						const {
+							chunk,
+							outputOptions,
+							dependencyTemplates,
+							codeGenerationResults
+						} = options;
 
-	/**
-	 * @private
-	 * @returns {void}
-	 */
-	_invalidateCache() {
-		if (this._cache !== undefined) {
-			this._cache.clear();
-		}
-	}
+						for (const module of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesByIdentifier
+						)) {
+							if (module.type === "webassembly/async") {
+								const filenameTemplate =
+									outputOptions.webassemblyModuleFilename;
 
-	/**
-	 * @private
-	 * @returns {void}
-	 */
-	_invalidateOrderedCache() {
-		if (this._cacheOrderIndependent !== undefined) {
-			this._cacheOrderIndependent.clear();
-		}
+								result.push({
+									render: () =>
+										this.renderModule(
+											module,
+											{
+												chunk,
+												dependencyTemplates,
+												runtimeTemplate,
+												moduleGraph,
+												chunkGraph,
+												codeGenerationResults
+											},
+											hooks
+										),
+									filenameTemplate,
+									pathOptions: {
+										module,
+										runtime: chunk.runtime,
+										chunkGraph
+									},
+									auxiliary: true,
+									identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
+										module
+									)}`,
+									hash: chunkGraph.getModuleHash(module, chunk.runtime)
+								});
+							}
+						}
+
+						return result;
+					}
+				);
+			}
+		);
 	}
 
-	/**
-	 * @returns {T[]} the raw array
-	 */
-	toJSON() {
-		return Array.from(this);
+	renderModule(module, renderContext, hooks) {
+		const { codeGenerationResults, chunk } = renderContext;
+		try {
+			const moduleSource = codeGenerationResults.getSource(
+				module,
+				chunk.runtime,
+				"webassembly"
+			);
+			return tryRunOrWebpackError(
+				() =>
+					hooks.renderModuleContent.call(moduleSource, module, renderContext),
+				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
+			);
+		} catch (e) {
+			e.module = module;
+			throw e;
+		}
 	}
 }
 
-module.exports = SortableSet;
+module.exports = AsyncWebAssemblyModulesPlugin;
 
 
 /***/ }),
 
-/***/ 64985:
-/***/ (function(module) {
+/***/ 96305:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -129869,289 +130283,484 @@ module.exports = SortableSet;
 
 
 
-/**
- * @template K
- * @template V
- */
-class StackedCacheMap {
-	constructor() {
-		/** @type {Map<K, V>} */
-		this.map = new Map();
-		/** @type {ReadonlyMap<K, V>[]} */
-		this.stack = [];
-	}
-
-	/**
-	 * @param {ReadonlyMap<K, V>} map map to add
-	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
-	 */
-	addAll(map, immutable) {
-		if (immutable) {
-			this.stack.push(map);
+const t = __webpack_require__(51826);
+const { decode } = __webpack_require__(73726);
+const Parser = __webpack_require__(11715);
+const StaticExportsDependency = __webpack_require__(91418);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-			// largest map should go first
-			for (let i = this.stack.length - 1; i > 0; i--) {
-				const beforeLast = this.stack[i - 1];
-				if (beforeLast.size >= map.size) break;
-				this.stack[i] = beforeLast;
-				this.stack[i - 1] = map;
-			}
-		} else {
-			for (const [key, value] of map) {
-				this.map.set(key, value);
-			}
-		}
-	}
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-	/**
-	 * @param {K} item the key of the element to add
-	 * @param {V} value the value of the element to add
-	 * @returns {void}
-	 */
-	set(item, value) {
-		this.map.set(item, value);
-	}
+const decoderOpts = {
+	ignoreCodeSection: true,
+	ignoreDataSection: true,
 
-	/**
-	 * @param {K} item the item to delete
-	 * @returns {void}
-	 */
-	delete(item) {
-		throw new Error("Items can't be deleted from a StackedCacheMap");
-	}
+	// this will avoid having to lookup with identifiers in the ModuleContext
+	ignoreCustomNameSection: true
+};
 
-	/**
-	 * @param {K} item the item to test
-	 * @returns {boolean} true if the item exists in this set
-	 */
-	has(item) {
-		throw new Error(
-			"Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined"
-		);
+class WebAssemblyParser extends Parser {
+	constructor(options) {
+		super();
+		this.hooks = Object.freeze({});
+		this.options = options;
 	}
 
 	/**
-	 * @param {K} item the key of the element to return
-	 * @returns {V} the value of the element
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
 	 */
-	get(item) {
-		for (const map of this.stack) {
-			const value = map.get(item);
-			if (value !== undefined) return value;
+	parse(source, state) {
+		if (!Buffer.isBuffer(source)) {
+			throw new Error("WebAssemblyParser input must be a Buffer");
 		}
-		return this.map.get(item);
-	}
 
-	clear() {
-		this.stack.length = 0;
-		this.map.clear();
-	}
+		// flag it as async module
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "namespace";
+		state.module.buildMeta.async = true;
 
-	get size() {
-		let size = this.map.size;
-		for (const map of this.stack) {
-			size += map.size;
-		}
-		return size;
-	}
+		// parse it
+		const program = decode(source, decoderOpts);
+		const module = program.body[0];
 
-	[Symbol.iterator]() {
-		const iterators = this.stack.map(map => map[Symbol.iterator]());
-		let current = this.map[Symbol.iterator]();
-		return {
-			next() {
-				let result = current.next();
-				while (result.done && iterators.length > 0) {
-					current = iterators.pop();
-					result = current.next();
-				}
-				return result;
+		const exports = [];
+		t.traverse(module, {
+			ModuleExport({ node }) {
+				exports.push(node.name);
+			},
+
+			ModuleImport({ node }) {
+				const dep = new WebAssemblyImportDependency(
+					node.module,
+					node.name,
+					node.descr,
+					false
+				);
+
+				state.module.addDependency(dep);
 			}
-		};
+		});
+
+		state.module.addDependency(new StaticExportsDependency(exports, false));
+
+		return state;
 	}
 }
 
-module.exports = StackedCacheMap;
+module.exports = WebAssemblyParser;
 
 
 /***/ }),
 
-/***/ 58845:
-/***/ (function(module) {
+/***/ 78455:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const TOMBSTONE = Symbol("tombstone");
-const UNDEFINED_MARKER = Symbol("undefined");
+const WebpackError = __webpack_require__(53799);
 
-/**
- * @template T
- * @typedef {T | undefined} Cell<T>
- */
+module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
+	/** @param {string} message Error message */
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedWebAssemblyFeatureError";
+		this.hideStack = true;
+	}
+};
 
-/**
- * @template T
- * @typedef {T | typeof TOMBSTONE | typeof UNDEFINED_MARKER} InternalCell<T>
- */
 
-/**
- * @template K
- * @template V
- * @param {[K, InternalCell<V>]} pair the internal cell
- * @returns {[K, Cell<V>]} its “safe” representation
- */
-const extractPair = pair => {
-	const key = pair[0];
-	const val = pair[1];
-	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {
-		return [key, undefined];
-	} else {
-		return /** @type {[K, Cell<V>]} */ (pair);
+/***/ }),
+
+/***/ 87394:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const WebAssemblyUtils = __webpack_require__(18650);
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+// TODO webpack 6 remove the whole folder
+
+// Get all wasm modules
+const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
+	const wasmModules = chunk.getAllAsyncChunks();
+	const array = [];
+	for (const chunk of wasmModules) {
+		for (const m of chunkGraph.getOrderedChunkModulesIterable(
+			chunk,
+			compareModulesByIdentifier
+		)) {
+			if (m.type.startsWith("webassembly")) {
+				array.push(m);
+			}
+		}
 	}
+
+	return array;
 };
 
 /**
- * @template K
- * @template V
+ * generates the import object function for a module
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} module the module
+ * @param {boolean} mangle mangle imports
+ * @param {string[]} declarations array where declarations are pushed to
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {string} source code
  */
-class StackedMap {
-	/**
-	 * @param {Map<K, InternalCell<V>>[]=} parentStack an optional parent
-	 */
-	constructor(parentStack) {
-		/** @type {Map<K, InternalCell<V>>} */
-		this.map = new Map();
-		/** @type {Map<K, InternalCell<V>>[]} */
-		this.stack = parentStack === undefined ? [] : parentStack.slice();
-		this.stack.push(this.map);
-	}
+const generateImportObject = (
+	chunkGraph,
+	module,
+	mangle,
+	declarations,
+	runtime
+) => {
+	const moduleGraph = chunkGraph.moduleGraph;
+	const waitForInstances = new Map();
+	const properties = [];
+	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
+		moduleGraph,
+		module,
+		mangle
+	);
+	for (const usedDep of usedWasmDependencies) {
+		const dep = usedDep.dependency;
+		const importedModule = moduleGraph.getModule(dep);
+		const exportName = dep.name;
+		const usedName =
+			importedModule &&
+			moduleGraph
+				.getExportsInfo(importedModule)
+				.getUsedName(exportName, runtime);
+		const description = dep.description;
+		const direct = dep.onlyDirectImport;
 
-	/**
-	 * @param {K} item the key of the element to add
-	 * @param {V} value the value of the element to add
-	 * @returns {void}
-	 */
-	set(item, value) {
-		this.map.set(item, value === undefined ? UNDEFINED_MARKER : value);
-	}
+		const module = usedDep.module;
+		const name = usedDep.name;
 
-	/**
-	 * @param {K} item the item to delete
-	 * @returns {void}
-	 */
-	delete(item) {
-		if (this.stack.length > 1) {
-			this.map.set(item, TOMBSTONE);
+		if (direct) {
+			const instanceVar = `m${waitForInstances.size}`;
+			waitForInstances.set(instanceVar, chunkGraph.getModuleId(importedModule));
+			properties.push({
+				module,
+				name,
+				value: `${instanceVar}[${JSON.stringify(usedName)}]`
+			});
 		} else {
-			this.map.delete(item);
-		}
-	}
+			const params = description.signature.params.map(
+				(param, k) => "p" + k + param.valtype
+			);
 
-	/**
-	 * @param {K} item the item to test
-	 * @returns {boolean} true if the item exists in this set
-	 */
-	has(item) {
-		const topValue = this.map.get(item);
-		if (topValue !== undefined) {
-			return topValue !== TOMBSTONE;
-		}
-		if (this.stack.length > 1) {
-			for (let i = this.stack.length - 2; i >= 0; i--) {
-				const value = this.stack[i].get(item);
-				if (value !== undefined) {
-					this.map.set(item, value);
-					return value !== TOMBSTONE;
-				}
-			}
-			this.map.set(item, TOMBSTONE);
-		}
-		return false;
-	}
+			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
+				chunkGraph.getModuleId(importedModule)
+			)}]`;
+			const modExports = `${mod}.exports`;
 
-	/**
-	 * @param {K} item the key of the element to return
-	 * @returns {Cell<V>} the value of the element
-	 */
-	get(item) {
-		const topValue = this.map.get(item);
-		if (topValue !== undefined) {
-			return topValue === TOMBSTONE || topValue === UNDEFINED_MARKER
-				? undefined
-				: topValue;
-		}
-		if (this.stack.length > 1) {
-			for (let i = this.stack.length - 2; i >= 0; i--) {
-				const value = this.stack[i].get(item);
-				if (value !== undefined) {
-					this.map.set(item, value);
-					return value === TOMBSTONE || value === UNDEFINED_MARKER
-						? undefined
-						: value;
-				}
-			}
-			this.map.set(item, TOMBSTONE);
+			const cache = `wasmImportedFuncCache${declarations.length}`;
+			declarations.push(`var ${cache};`);
+
+			properties.push({
+				module,
+				name,
+				value: Template.asString([
+					(importedModule.type.startsWith("webassembly")
+						? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
+						: "") + `function(${params}) {`,
+					Template.indent([
+						`if(${cache} === undefined) ${cache} = ${modExports};`,
+						`return ${cache}[${JSON.stringify(usedName)}](${params});`
+					]),
+					"}"
+				])
+			});
 		}
-		return undefined;
 	}
 
-	_compress() {
-		if (this.stack.length === 1) return;
-		this.map = new Map();
-		for (const data of this.stack) {
-			for (const pair of data) {
-				if (pair[1] === TOMBSTONE) {
-					this.map.delete(pair[0]);
-				} else {
-					this.map.set(pair[0], pair[1]);
-				}
+	let importObject;
+	if (mangle) {
+		importObject = [
+			"return {",
+			Template.indent([
+				properties.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
+			]),
+			"};"
+		];
+	} else {
+		const propertiesByModule = new Map();
+		for (const p of properties) {
+			let list = propertiesByModule.get(p.module);
+			if (list === undefined) {
+				propertiesByModule.set(p.module, (list = []));
 			}
+			list.push(p);
 		}
-		this.stack = [this.map];
-	}
-
-	asArray() {
-		this._compress();
-		return Array.from(this.map.keys());
+		importObject = [
+			"return {",
+			Template.indent([
+				Array.from(propertiesByModule, ([module, list]) => {
+					return Template.asString([
+						`${JSON.stringify(module)}: {`,
+						Template.indent([
+							list.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
+						]),
+						"}"
+					]);
+				}).join(",\n")
+			]),
+			"};"
+		];
 	}
 
-	asSet() {
-		this._compress();
-		return new Set(this.map.keys());
+	const moduleIdStringified = JSON.stringify(chunkGraph.getModuleId(module));
+	if (waitForInstances.size === 1) {
+		const moduleId = Array.from(waitForInstances.values())[0];
+		const promise = `installedWasmModules[${JSON.stringify(moduleId)}]`;
+		const variable = Array.from(waitForInstances.keys())[0];
+		return Template.asString([
+			`${moduleIdStringified}: function() {`,
+			Template.indent([
+				`return promiseResolve().then(function() { return ${promise}; }).then(function(${variable}) {`,
+				Template.indent(importObject),
+				"});"
+			]),
+			"},"
+		]);
+	} else if (waitForInstances.size > 0) {
+		const promises = Array.from(
+			waitForInstances.values(),
+			id => `installedWasmModules[${JSON.stringify(id)}]`
+		).join(", ");
+		const variables = Array.from(
+			waitForInstances.keys(),
+			(name, i) => `${name} = array[${i}]`
+		).join(", ");
+		return Template.asString([
+			`${moduleIdStringified}: function() {`,
+			Template.indent([
+				`return promiseResolve().then(function() { return Promise.all([${promises}]); }).then(function(array) {`,
+				Template.indent([`var ${variables};`, ...importObject]),
+				"});"
+			]),
+			"},"
+		]);
+	} else {
+		return Template.asString([
+			`${moduleIdStringified}: function() {`,
+			Template.indent(importObject),
+			"},"
+		]);
 	}
+};
 
-	asPairArray() {
-		this._compress();
-		return Array.from(this.map.entries(), extractPair);
+class WasmChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor({
+		generateLoadBinaryCode,
+		supportsStreaming,
+		mangleImports,
+		runtimeRequirements
+	}) {
+		super("wasm chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.generateLoadBinaryCode = generateLoadBinaryCode;
+		this.supportsStreaming = supportsStreaming;
+		this.mangleImports = mangleImports;
+		this._runtimeRequirements = runtimeRequirements;
 	}
 
-	asMap() {
-		return new Map(this.asPairArray());
-	}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, compilation, chunk, mangleImports } = this;
+		const { moduleGraph, outputOptions } = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withHmr = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
+		const declarations = [];
+		const importObjects = wasmModules.map(module => {
+			return generateImportObject(
+				chunkGraph,
+				module,
+				this.mangleImports,
+				declarations,
+				chunk.runtime
+			);
+		});
+		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
+			m.type.startsWith("webassembly")
+		);
+		const createImportObject = content =>
+			mangleImports
+				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
+				: content;
+		const wasmModuleSrcPath = compilation.getPath(
+			JSON.stringify(outputOptions.webassemblyModuleFilename),
+			{
+				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+				hashWithLength: length =>
+					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
+				module: {
+					id: '" + wasmModuleId + "',
+					hash: `" + ${JSON.stringify(
+						chunkGraph.getChunkModuleRenderedHashMap(chunk, m =>
+							m.type.startsWith("webassembly")
+						)
+					)}[chunkId][wasmModuleId] + "`,
+					hashWithLength(length) {
+						return `" + ${JSON.stringify(
+							chunkGraph.getChunkModuleRenderedHashMap(
+								chunk,
+								m => m.type.startsWith("webassembly"),
+								length
+							)
+						)}[chunkId][wasmModuleId] + "`;
+					}
+				},
+				runtime: chunk.runtime
+			}
+		);
 
-	get size() {
-		this._compress();
-		return this.map.size;
-	}
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_wasm`
+			: undefined;
 
-	createChild() {
-		return new StackedMap(this.stack);
+		return Template.asString([
+			"// object to store loaded and loading wasm modules",
+			`var installedWasmModules = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{};`,
+			"",
+			// This function is used to delay reading the installed wasm module promises
+			// by a microtask. Sorting them doesn't help because there are edge cases where
+			// sorting is not possible (modules splitted into different chunks).
+			// So we not even trying and solve this by a microtask delay.
+			"function promiseResolve() { return Promise.resolve(); }",
+			"",
+			Template.asString(declarations),
+			"var wasmImportObjects = {",
+			Template.indent(importObjects),
+			"};",
+			"",
+			`var wasmModuleMap = ${JSON.stringify(
+				chunkModuleIdMap,
+				undefined,
+				"\t"
+			)};`,
+			"",
+			"// object with all WebAssembly.instance exports",
+			`${RuntimeGlobals.wasmInstances} = {};`,
+			"",
+			"// Fetch + compile chunk loading for webassembly",
+			`${fn}.wasm = function(chunkId, promises) {`,
+			Template.indent([
+				"",
+				`var wasmModules = wasmModuleMap[chunkId] || [];`,
+				"",
+				"wasmModules.forEach(function(wasmModuleId, idx) {",
+				Template.indent([
+					"var installedWasmModuleData = installedWasmModules[wasmModuleId];",
+					"",
+					'// a Promise means "currently loading" or "already loaded".',
+					"if(installedWasmModuleData)",
+					Template.indent(["promises.push(installedWasmModuleData);"]),
+					"else {",
+					Template.indent([
+						`var importObject = wasmImportObjects[wasmModuleId]();`,
+						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
+						"var promise;",
+						this.supportsStreaming
+							? Template.asString([
+									"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
+									Template.indent([
+										"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
+										Template.indent([
+											`return WebAssembly.instantiate(items[0], ${createImportObject(
+												"items[1]"
+											)});`
+										]),
+										"});"
+									]),
+									"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
+									Template.indent([
+										`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
+											"importObject"
+										)});`
+									])
+							  ])
+							: Template.asString([
+									"if(importObject && typeof importObject.then === 'function') {",
+									Template.indent([
+										"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
+										"promise = Promise.all([",
+										Template.indent([
+											"bytesPromise.then(function(bytes) { return WebAssembly.compile(bytes); }),",
+											"importObject"
+										]),
+										"]).then(function(items) {",
+										Template.indent([
+											`return WebAssembly.instantiate(items[0], ${createImportObject(
+												"items[1]"
+											)});`
+										]),
+										"});"
+									])
+							  ]),
+						"} else {",
+						Template.indent([
+							"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
+							"promise = bytesPromise.then(function(bytes) {",
+							Template.indent([
+								`return WebAssembly.instantiate(bytes, ${createImportObject(
+									"importObject"
+								)});`
+							]),
+							"});"
+						]),
+						"}",
+						"promises.push(installedWasmModules[wasmModuleId] = promise.then(function(res) {",
+						Template.indent([
+							`return ${RuntimeGlobals.wasmInstances}[wasmModuleId] = (res.instance || res).exports;`
+						]),
+						"}));"
+					]),
+					"}"
+				]),
+				"});"
+			]),
+			"};"
+		]);
 	}
 }
 
-module.exports = StackedMap;
+module.exports = WasmChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 40293:
-/***/ (function(module) {
+/***/ 19810:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -130161,59 +130770,86 @@ module.exports = StackedMap;
 
 
 
-class StringXor {
-	constructor() {
-		this._value = undefined;
-	}
+const formatLocation = __webpack_require__(16734);
+const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
+
+/** @typedef {import("../Compiler")} Compiler */
 
+class WasmFinalizeExportsPlugin {
 	/**
-	 * @param {string} str string
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
-	add(str) {
-		const len = str.length;
-		const value = this._value;
-		if (value === undefined) {
-			const newValue = (this._value = Buffer.allocUnsafe(len));
-			for (let i = 0; i < len; i++) {
-				newValue[i] = str.charCodeAt(i);
-			}
-			return;
-		}
-		const valueLen = value.length;
-		if (valueLen < len) {
-			const newValue = (this._value = Buffer.allocUnsafe(len));
-			let i;
-			for (i = 0; i < valueLen; i++) {
-				newValue[i] = value[i] ^ str.charCodeAt(i);
-			}
-			for (; i < len; i++) {
-				newValue[i] = str.charCodeAt(i);
-			}
-		} else {
-			for (let i = 0; i < len; i++) {
-				value[i] = value[i] ^ str.charCodeAt(i);
-			}
-		}
-	}
+	apply(compiler) {
+		compiler.hooks.compilation.tap("WasmFinalizeExportsPlugin", compilation => {
+			compilation.hooks.finishModules.tap(
+				"WasmFinalizeExportsPlugin",
+				modules => {
+					for (const module of modules) {
+						// 1. if a WebAssembly module
+						if (module.type.startsWith("webassembly") === true) {
+							const jsIncompatibleExports =
+								module.buildMeta.jsIncompatibleExports;
 
-	toString() {
-		const value = this._value;
-		return value === undefined ? "" : value.toString("latin1");
-	}
+							if (jsIncompatibleExports === undefined) {
+								continue;
+							}
+
+							for (const connection of compilation.moduleGraph.getIncomingConnections(
+								module
+							)) {
+								// 2. is active and referenced by a non-WebAssembly module
+								if (
+									connection.isTargetActive(undefined) &&
+									connection.originModule.type.startsWith("webassembly") ===
+										false
+								) {
+									const referencedExports =
+										compilation.getDependencyReferencedExports(
+											connection.dependency,
+											undefined
+										);
 
-	updateHash(hash) {
-		const value = this._value;
-		if (value !== undefined) hash.update(value);
+									for (const info of referencedExports) {
+										const names = Array.isArray(info) ? info : info.name;
+										if (names.length === 0) continue;
+										const name = names[0];
+										if (typeof name === "object") continue;
+										// 3. and uses a func with an incompatible JS signature
+										if (
+											Object.prototype.hasOwnProperty.call(
+												jsIncompatibleExports,
+												name
+											)
+										) {
+											// 4. error
+											const error = new UnsupportedWebAssemblyFeatureError(
+												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
+													`It's used from ${connection.originModule.readableIdentifier(
+														compilation.requestShortener
+													)} at ${formatLocation(connection.dependency.loc)}.`
+											);
+											error.module = module;
+											compilation.errors.push(error);
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			);
+		});
 	}
 }
 
-module.exports = StringXor;
+module.exports = WasmFinalizeExportsPlugin;
 
 
 /***/ }),
 
-/***/ 38415:
+/***/ 47012:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -130224,1168 +130860,844 @@ module.exports = StringXor;
 
 
 
-const TupleSet = __webpack_require__(76455);
-
-/**
- * @template {any[]} T
- */
-class TupleQueue {
-	/**
-	 * @param {Iterable<T>=} items The initial elements.
-	 */
-	constructor(items) {
-		/** @private @type {TupleSet<T>} */
-		this._set = new TupleSet(items);
-		/** @private @type {Iterator<T>} */
-		this._iterator = this._set[Symbol.iterator]();
-	}
-
-	/**
-	 * Returns the number of elements in this queue.
-	 * @returns {number} The number of elements in this queue.
-	 */
-	get length() {
-		return this._set.size;
-	}
+const { RawSource } = __webpack_require__(51255);
+const Generator = __webpack_require__(93401);
+const WebAssemblyUtils = __webpack_require__(18650);
 
-	/**
-	 * Appends the specified element to this queue.
-	 * @param {T} item The element to add.
-	 * @returns {void}
-	 */
-	enqueue(...item) {
-		this._set.add(...item);
-	}
+const t = __webpack_require__(51826);
+const { moduleContextFromModuleAST } = __webpack_require__(51826);
+const { editWithAST, addWithAST } = __webpack_require__(87362);
+const { decode } = __webpack_require__(73726);
 
-	/**
-	 * Retrieves and removes the head of this queue.
-	 * @returns {T | undefined} The head of the queue of `undefined` if this queue is empty.
-	 */
-	dequeue() {
-		const result = this._iterator.next();
-		if (result.done) {
-			if (this._set.size > 0) {
-				this._iterator = this._set[Symbol.iterator]();
-				const value = this._iterator.next().value;
-				this._set.delete(...value);
-				return value;
-			}
-			return undefined;
-		}
-		this._set.delete(...result.value);
-		return result.value;
-	}
-}
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
 
-module.exports = TupleQueue;
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
 
+/**
+ * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
+ */
 
-/***/ }),
+/**
+ * @template T
+ * @param {Function[]} fns transforms
+ * @returns {Function} composed transform
+ */
+const compose = (...fns) => {
+	return fns.reduce(
+		(prevFn, nextFn) => {
+			return value => nextFn(prevFn(value));
+		},
+		value => value
+	);
+};
 
-/***/ 76455:
-/***/ (function(module) {
+/**
+ * Removes the start instruction
+ *
+ * @param {Object} state unused state
+ * @returns {ArrayBufferTransform} transform
+ */
+const removeStartFunc = state => bin => {
+	return editWithAST(state.ast, bin, {
+		Start(path) {
+			path.remove();
+		}
+	});
+};
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+/**
+ * Get imported globals
+ *
+ * @param {Object} ast Module's AST
+ * @returns {Array<t.ModuleImport>} - nodes
+ */
+const getImportedGlobals = ast => {
+	const importedGlobals = [];
 
+	t.traverse(ast, {
+		ModuleImport({ node }) {
+			if (t.isGlobalType(node.descr)) {
+				importedGlobals.push(node);
+			}
+		}
+	});
 
+	return importedGlobals;
+};
 
 /**
- * @template {any[]} T
+ * Get the count for imported func
+ *
+ * @param {Object} ast Module's AST
+ * @returns {Number} - count
  */
-class TupleSet {
-	constructor(init) {
-		this._map = new Map();
-		this.size = 0;
-		if (init) {
-			for (const tuple of init) {
-				this.add(...tuple);
-			}
-		}
-	}
+const getCountImportedFunc = ast => {
+	let count = 0;
 
-	/**
-	 * @param  {T} args tuple
-	 * @returns {void}
-	 */
-	add(...args) {
-		let map = this._map;
-		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			const innerMap = map.get(arg);
-			if (innerMap === undefined) {
-				map.set(arg, (map = new Map()));
-			} else {
-				map = innerMap;
+	t.traverse(ast, {
+		ModuleImport({ node }) {
+			if (t.isFuncImportDescr(node.descr)) {
+				count++;
 			}
 		}
+	});
 
-		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
-		if (set === undefined) {
-			map.set(beforeLast, (set = new Set()));
-		}
+	return count;
+};
 
-		const last = args[args.length - 1];
-		this.size -= set.size;
-		set.add(last);
-		this.size += set.size;
+/**
+ * Get next type index
+ *
+ * @param {Object} ast Module's AST
+ * @returns {t.Index} - index
+ */
+const getNextTypeIndex = ast => {
+	const typeSectionMetadata = t.getSectionMetadata(ast, "type");
+
+	if (typeSectionMetadata === undefined) {
+		return t.indexLiteral(0);
 	}
 
-	/**
-	 * @param  {T} args tuple
-	 * @returns {boolean} true, if the tuple is in the Set
-	 */
-	has(...args) {
-		let map = this._map;
-		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = map.get(arg);
-			if (map === undefined) {
-				return false;
-			}
-		}
+	return t.indexLiteral(typeSectionMetadata.vectorOfSize.value);
+};
 
-		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
-		if (set === undefined) {
-			return false;
-		}
+/**
+ * Get next func index
+ *
+ * The Func section metadata provide informations for implemented funcs
+ * in order to have the correct index we shift the index by number of external
+ * functions.
+ *
+ * @param {Object} ast Module's AST
+ * @param {Number} countImportedFunc number of imported funcs
+ * @returns {t.Index} - index
+ */
+const getNextFuncIndex = (ast, countImportedFunc) => {
+	const funcSectionMetadata = t.getSectionMetadata(ast, "func");
 
-		const last = args[args.length - 1];
-		return set.has(last);
+	if (funcSectionMetadata === undefined) {
+		return t.indexLiteral(0 + countImportedFunc);
 	}
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {void}
-	 */
-	delete(...args) {
-		let map = this._map;
-		for (let i = 0; i < args.length - 2; i++) {
-			const arg = args[i];
-			map = map.get(arg);
-			if (map === undefined) {
-				return;
-			}
-		}
+	const vectorOfSize = funcSectionMetadata.vectorOfSize.value;
 
-		const beforeLast = args[args.length - 2];
-		let set = map.get(beforeLast);
-		if (set === undefined) {
-			return;
-		}
+	return t.indexLiteral(vectorOfSize + countImportedFunc);
+};
 
-		const last = args[args.length - 1];
-		this.size -= set.size;
-		set.delete(last);
-		this.size += set.size;
+/**
+ * Creates an init instruction for a global type
+ * @param {t.GlobalType} globalType the global type
+ * @returns {t.Instruction} init expression
+ */
+const createDefaultInitForGlobal = globalType => {
+	if (globalType.valtype[0] === "i") {
+		// create NumberLiteral global initializer
+		return t.objectInstruction("const", globalType.valtype, [
+			t.numberLiteralFromRaw(66)
+		]);
+	} else if (globalType.valtype[0] === "f") {
+		// create FloatLiteral global initializer
+		return t.objectInstruction("const", globalType.valtype, [
+			t.floatLiteral(66, false, false, "66")
+		]);
+	} else {
+		throw new Error("unknown type: " + globalType.valtype);
 	}
+};
 
-	/**
-	 * @returns {Iterator<T>} iterator
-	 */
-	[Symbol.iterator]() {
-		const iteratorStack = [];
-		const tuple = [];
-		let currentSetIterator = undefined;
+/**
+ * Rewrite the import globals:
+ * - removes the ModuleImport instruction
+ * - injects at the same offset a mutable global of the same type
+ *
+ * Since the imported globals are before the other global declarations, our
+ * indices will be preserved.
+ *
+ * Note that globals will become mutable.
+ *
+ * @param {Object} state unused state
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteImportedGlobals = state => bin => {
+	const additionalInitCode = state.additionalInitCode;
+	const newGlobals = [];
 
-		const next = it => {
-			const result = it.next();
-			if (result.done) {
-				if (iteratorStack.length === 0) return false;
-				tuple.pop();
-				return next(iteratorStack.pop());
-			}
-			const [key, value] = result.value;
-			iteratorStack.push(it);
-			tuple.push(key);
-			if (value instanceof Set) {
-				currentSetIterator = value[Symbol.iterator]();
-				return true;
-			} else {
-				return next(value[Symbol.iterator]());
-			}
-		};
+	bin = editWithAST(state.ast, bin, {
+		ModuleImport(path) {
+			if (t.isGlobalType(path.node.descr)) {
+				const globalType = path.node.descr;
 
-		next(this._map[Symbol.iterator]());
+				globalType.mutability = "var";
 
-		return {
-			next() {
-				while (currentSetIterator) {
-					const result = currentSetIterator.next();
-					if (result.done) {
-						tuple.pop();
-						if (!next(iteratorStack.pop())) {
-							currentSetIterator = undefined;
-						}
-					} else {
-						return {
-							done: false,
-							value: /** @type {T} */ (tuple.concat(result.value))
-						};
-					}
-				}
-				return { done: true, value: undefined };
+				const init = [
+					createDefaultInitForGlobal(globalType),
+					t.instruction("end")
+				];
+
+				newGlobals.push(t.global(globalType, init));
+
+				path.remove();
 			}
-		};
-	}
-}
+		},
 
-module.exports = TupleSet;
+		// in order to preserve non-imported global's order we need to re-inject
+		// those as well
+		Global(path) {
+			const { node } = path;
+			const [init] = node.init;
 
+			if (init.id === "get_global") {
+				node.globalType.mutability = "var";
 
-/***/ }),
+				const initialGlobalIdx = init.args[0];
 
-/***/ 54500:
-/***/ (function(__unused_webpack_module, exports) {
+				node.init = [
+					createDefaultInitForGlobal(node.globalType),
+					t.instruction("end")
+				];
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Ivan Kopeykin @vankop
-*/
+				additionalInitCode.push(
+					/**
+					 * get_global in global initializer only works for imported globals.
+					 * They have the same indices as the init params, so use the
+					 * same index.
+					 */
+					t.instruction("get_local", [initialGlobalIdx]),
+					t.instruction("set_global", [t.indexLiteral(newGlobals.length)])
+				);
+			}
 
+			newGlobals.push(node);
 
+			path.remove();
+		}
+	});
 
-/** @typedef {import("./fs").InputFileSystem} InputFileSystem */
-/** @typedef {(error: Error|null, result?: Buffer) => void} ErrorFirstCallback */
+	// Add global declaration instructions
+	return addWithAST(state.ast, bin, newGlobals);
+};
 
-const backSlashCharCode = "\\".charCodeAt(0);
-const slashCharCode = "/".charCodeAt(0);
-const aLowerCaseCharCode = "a".charCodeAt(0);
-const zLowerCaseCharCode = "z".charCodeAt(0);
-const aUpperCaseCharCode = "A".charCodeAt(0);
-const zUpperCaseCharCode = "Z".charCodeAt(0);
-const _0CharCode = "0".charCodeAt(0);
-const _9CharCode = "9".charCodeAt(0);
-const plusCharCode = "+".charCodeAt(0);
-const hyphenCharCode = "-".charCodeAt(0);
-const colonCharCode = ":".charCodeAt(0);
-const hashCharCode = "#".charCodeAt(0);
-const queryCharCode = "?".charCodeAt(0);
 /**
- * Get scheme if specifier is an absolute URL specifier
- * e.g. Absolute specifiers like 'file:///user/webpack/index.js'
- * https://tools.ietf.org/html/rfc3986#section-3.1
- * @param {string} specifier specifier
- * @returns {string|undefined} scheme if absolute URL specifier provided
+ * Rewrite the export names
+ * @param {Object} state state
+ * @param {Object} state.ast Module's ast
+ * @param {Module} state.module Module
+ * @param {ModuleGraph} state.moduleGraph module graph
+ * @param {Set<string>} state.externalExports Module
+ * @param {RuntimeSpec} state.runtime runtime
+ * @returns {ArrayBufferTransform} transform
  */
-function getScheme(specifier) {
-	const start = specifier.charCodeAt(0);
+const rewriteExportNames =
+	({ ast, moduleGraph, module, externalExports, runtime }) =>
+	bin => {
+		return editWithAST(ast, bin, {
+			ModuleExport(path) {
+				const isExternal = externalExports.has(path.node.name);
+				if (isExternal) {
+					path.remove();
+					return;
+				}
+				const usedName = moduleGraph
+					.getExportsInfo(module)
+					.getUsedName(path.node.name, runtime);
+				if (!usedName) {
+					path.remove();
+					return;
+				}
+				path.node.name = usedName;
+			}
+		});
+	};
 
-	// First char maybe only a letter
-	if (
-		(start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
-		(start < aUpperCaseCharCode || start > zUpperCaseCharCode)
-	) {
-		return undefined;
-	}
+/**
+ * Mangle import names and modules
+ * @param {Object} state state
+ * @param {Object} state.ast Module's ast
+ * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteImports =
+	({ ast, usedDependencyMap }) =>
+	bin => {
+		return editWithAST(ast, bin, {
+			ModuleImport(path) {
+				const result = usedDependencyMap.get(
+					path.node.module + ":" + path.node.name
+				);
+
+				if (result !== undefined) {
+					path.node.module = result.module;
+					path.node.name = result.name;
+				}
+			}
+		});
+	};
+
+/**
+ * Add an init function.
+ *
+ * The init function fills the globals given input arguments.
+ *
+ * @param {Object} state transformation state
+ * @param {Object} state.ast Module's ast
+ * @param {t.Identifier} state.initFuncId identifier of the init function
+ * @param {t.Index} state.startAtFuncOffset index of the start function
+ * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
+ * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
+ * @param {t.Index} state.nextFuncIndex index of the next function
+ * @param {t.Index} state.nextTypeIndex index of the next type
+ * @returns {ArrayBufferTransform} transform
+ */
+const addInitFunction =
+	({
+		ast,
+		initFuncId,
+		startAtFuncOffset,
+		importedGlobals,
+		additionalInitCode,
+		nextFuncIndex,
+		nextTypeIndex
+	}) =>
+	bin => {
+		const funcParams = importedGlobals.map(importedGlobal => {
+			// used for debugging
+			const id = t.identifier(
+				`${importedGlobal.module}.${importedGlobal.name}`
+			);
 
-	let i = 1;
-	let ch = specifier.charCodeAt(i);
+			return t.funcParam(importedGlobal.descr.valtype, id);
+		});
 
-	while (
-		(ch >= aLowerCaseCharCode && ch <= zLowerCaseCharCode) ||
-		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
-		(ch >= _0CharCode && ch <= _9CharCode) ||
-		ch === plusCharCode ||
-		ch === hyphenCharCode
-	) {
-		if (++i === specifier.length) return undefined;
-		ch = specifier.charCodeAt(i);
-	}
+		const funcBody = [];
+		importedGlobals.forEach((importedGlobal, index) => {
+			const args = [t.indexLiteral(index)];
+			const body = [
+				t.instruction("get_local", args),
+				t.instruction("set_global", args)
+			];
 
-	// Scheme must end with colon
-	if (ch !== colonCharCode) return undefined;
+			funcBody.push(...body);
+		});
 
-	// Check for Windows absolute path
-	// https://url.spec.whatwg.org/#url-miscellaneous
-	if (i === 1) {
-		const nextChar = i + 1 < specifier.length ? specifier.charCodeAt(i + 1) : 0;
-		if (
-			nextChar === 0 ||
-			nextChar === backSlashCharCode ||
-			nextChar === slashCharCode ||
-			nextChar === hashCharCode ||
-			nextChar === queryCharCode
-		) {
-			return undefined;
+		if (typeof startAtFuncOffset === "number") {
+			funcBody.push(
+				t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset))
+			);
 		}
-	}
-
-	return specifier.slice(0, i).toLowerCase();
-}
-
-/**
- * @param {string} specifier specifier
- * @returns {string|null} protocol if absolute URL specifier provided
- */
-function getProtocol(specifier) {
-	const scheme = getScheme(specifier);
-	return scheme === undefined ? undefined : scheme + ":";
-}
 
-exports.getScheme = getScheme;
-exports.getProtocol = getProtocol;
+		for (const instr of additionalInitCode) {
+			funcBody.push(instr);
+		}
 
+		funcBody.push(t.instruction("end"));
 
-/***/ }),
+		const funcResults = [];
 
-/***/ 28745:
-/***/ (function(module) {
+		// Code section
+		const funcSignature = t.signature(funcParams, funcResults);
+		const func = t.func(initFuncId, funcSignature, funcBody);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		// Type section
+		const functype = t.typeInstruction(undefined, funcSignature);
 
+		// Func section
+		const funcindex = t.indexInFuncSection(nextTypeIndex);
 
+		// Export section
+		const moduleExport = t.moduleExport(
+			initFuncId.value,
+			t.moduleExportDescr("Func", nextFuncIndex)
+		);
 
-const isWeakKey = thing => typeof thing === "object" && thing !== null;
+		return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
+	};
 
 /**
- * @template {any[]} T
- * @template V
+ * Extract mangle mappings from module
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Module} module current module
+ * @param {boolean} mangle mangle imports
+ * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
  */
-class WeakTupleMap {
-	constructor() {
-		/** @private */
-		this.f = 0;
-		/** @private @type {any} */
-		this.v = undefined;
-		/** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
-		this.m = undefined;
-		/** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
-		this.w = undefined;
-	}
-
-	/**
-	 * @param {[...T, V]} args tuple
-	 * @returns {void}
-	 */
-	set(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
-		}
-		node._setValue(args[args.length - 1]);
+const getUsedDependencyMap = (moduleGraph, module, mangle) => {
+	/** @type {Map<string, UsedWasmDependency>} */
+	const map = new Map();
+	for (const usedDep of WebAssemblyUtils.getUsedDependencies(
+		moduleGraph,
+		module,
+		mangle
+	)) {
+		const dep = usedDep.dependency;
+		const request = dep.request;
+		const exportName = dep.name;
+		map.set(request + ":" + exportName, usedDep);
 	}
+	return map;
+};
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {boolean} true, if the tuple is in the Set
-	 */
-	has(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
-			if (node === undefined) return false;
-		}
-		return node._hasValue();
-	}
+const TYPES = new Set(["webassembly"]);
 
-	/**
-	 * @param {T} args tuple
-	 * @returns {V} the value
-	 */
-	get(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
-			if (node === undefined) return undefined;
-		}
-		return node._getValue();
+class WebAssemblyGenerator extends Generator {
+	constructor(options) {
+		super();
+		this.options = options;
 	}
 
 	/**
-	 * @param {[...T, function(): V]} args tuple
-	 * @returns {V} the value
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
 	 */
-	provide(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length - 1; i++) {
-			node = node._get(args[i]);
-		}
-		if (node._hasValue()) return node._getValue();
-		const fn = args[args.length - 1];
-		const newValue = fn(...args.slice(0, -1));
-		node._setValue(newValue);
-		return newValue;
+	getTypes(module) {
+		return TYPES;
 	}
 
 	/**
-	 * @param {T} args tuple
-	 * @returns {void}
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
 	 */
-	delete(...args) {
-		/** @type {WeakTupleMap<T, V>} */
-		let node = this;
-		for (let i = 0; i < args.length; i++) {
-			node = node._peek(args[i]);
-			if (node === undefined) return;
+	getSize(module, type) {
+		const originalSource = module.originalSource();
+		if (!originalSource) {
+			return 0;
 		}
-		node._deleteValue();
+		return originalSource.size();
 	}
 
 	/**
-	 * @returns {void}
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
 	 */
-	clear() {
-		this.f = 0;
-		this.v = undefined;
-		this.w = undefined;
-		this.m = undefined;
-	}
-
-	_getValue() {
-		return this.v;
-	}
-
-	_hasValue() {
-		return (this.f & 1) === 1;
-	}
+	generate(module, { moduleGraph, runtime }) {
+		const bin = module.originalSource().source();
 
-	_setValue(v) {
-		this.f |= 1;
-		this.v = v;
-	}
+		const initFuncId = t.identifier("");
 
-	_deleteValue() {
-		this.f &= 6;
-		this.v = undefined;
-	}
+		// parse it
+		const ast = decode(bin, {
+			ignoreDataSection: true,
+			ignoreCodeSection: true,
+			ignoreCustomNameSection: true
+		});
 
-	_peek(thing) {
-		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) return undefined;
-			return this.w.get(thing);
-		} else {
-			if ((this.f & 2) !== 2) return undefined;
-			return this.m.get(thing);
-		}
-	}
+		const moduleContext = moduleContextFromModuleAST(ast.body[0]);
 
-	_get(thing) {
-		if (isWeakKey(thing)) {
-			if ((this.f & 4) !== 4) {
-				const newMap = new WeakMap();
-				this.f |= 4;
-				const newNode = new WeakTupleMap();
-				(this.w = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry = this.w.get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
-			const newNode = new WeakTupleMap();
-			this.w.set(thing, newNode);
-			return newNode;
-		} else {
-			if ((this.f & 2) !== 2) {
-				const newMap = new Map();
-				this.f |= 2;
-				const newNode = new WeakTupleMap();
-				(this.m = newMap).set(thing, newNode);
-				return newNode;
-			}
-			const entry = this.m.get(thing);
-			if (entry !== undefined) {
-				return entry;
-			}
-			const newNode = new WeakTupleMap();
-			this.m.set(thing, newNode);
-			return newNode;
-		}
-	}
-}
+		const importedGlobals = getImportedGlobals(ast);
+		const countImportedFunc = getCountImportedFunc(ast);
+		const startAtFuncOffset = moduleContext.getStart();
+		const nextFuncIndex = getNextFuncIndex(ast, countImportedFunc);
+		const nextTypeIndex = getNextTypeIndex(ast);
 
-module.exports = WeakTupleMap;
+		const usedDependencyMap = getUsedDependencyMap(
+			moduleGraph,
+			module,
+			this.options.mangleImports
+		);
+		const externalExports = new Set(
+			module.dependencies
+				.filter(d => d instanceof WebAssemblyExportImportedDependency)
+				.map(d => {
+					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (
+						d
+					);
+					return wasmDep.exportName;
+				})
+		);
 
+		/** @type {t.Instruction[]} */
+		const additionalInitCode = [];
 
-/***/ }),
+		const transform = compose(
+			rewriteExportNames({
+				ast,
+				moduleGraph,
+				module,
+				externalExports,
+				runtime
+			}),
 
-/***/ 92229:
-/***/ (function(module) {
+			removeStartFunc({ ast }),
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Mikola Lysenko @mikolalysenko
-*/
+			rewriteImportedGlobals({ ast, additionalInitCode }),
 
+			rewriteImports({
+				ast,
+				usedDependencyMap
+			}),
 
+			addInitFunction({
+				ast,
+				initFuncId,
+				importedGlobals,
+				additionalInitCode,
+				startAtFuncOffset,
+				nextFuncIndex,
+				nextTypeIndex
+			})
+		);
 
-/* cspell:disable-next-line */
-// Refactor: Peter Somogyvari @petermetz
+		const newBin = transform(bin);
 
-const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
-	const code = [
-		"function ",
-		funcName,
-		"(a,l,h,",
-		extraArgs.join(","),
-		"){",
-		earlyOut ? "" : "var i=",
-		reversed ? "l-1" : "h+1",
-		";while(l<=h){var m=(l+h)>>>1,x=a[m]"
-	];
+		const newBuf = Buffer.from(newBin);
 
-	if (earlyOut) {
-		if (predicate.indexOf("c") < 0) {
-			code.push(";if(x===y){return m}else if(x<=y){");
-		} else {
-			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
-		}
-	} else {
-		code.push(";if(", predicate, "){i=m;");
-	}
-	if (reversed) {
-		code.push("l=m+1}else{h=m-1}");
-	} else {
-		code.push("h=m-1}else{l=m+1}");
-	}
-	code.push("}");
-	if (earlyOut) {
-		code.push("return -1};");
-	} else {
-		code.push("return i};");
+		return new RawSource(newBuf);
 	}
-	return code.join("");
-};
-
-const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
-	const arg1 = compileSearch(
-		"A",
-		"x" + predicate + "y",
-		reversed,
-		["y"],
-		earlyOut
-	);
-
-	const arg2 = compileSearch(
-		"P",
-		"c(x,y)" + predicate + "0",
-		reversed,
-		["y", "c"],
-		earlyOut
-	);
-
-	const fnHeader = "function dispatchBinarySearch";
-
-	const fnBody =
-		"(a,y,c,l,h){\
-if(typeof(c)==='function'){\
-return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
-}else{\
-return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
-}}\
-return dispatchBinarySearch";
-
-	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
-	const fnSource = fnArgList.join("");
-	const result = new Function(fnSource);
-	return result();
-};
+}
 
-module.exports = {
-	ge: compileBoundsSearch(">=", false, "GE"),
-	gt: compileBoundsSearch(">", false, "GT"),
-	lt: compileBoundsSearch("<", true, "LT"),
-	le: compileBoundsSearch("<=", true, "LE"),
-	eq: compileBoundsSearch("-", true, "EQ", true)
-};
+module.exports = WebAssemblyGenerator;
 
 
 /***/ }),
 
-/***/ 60839:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 47342:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-/** @type {WeakMap<object, WeakMap<object, object>>} */
-const mergeCache = new WeakMap();
-/** @type {WeakMap<object, Map<string, Map<string|number|boolean, object>>>} */
-const setPropertyCache = new WeakMap();
-const DELETE = Symbol("DELETE");
-const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
-
-/**
- * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
- * @template T
- * @template O
- * @example
- * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
- * cachedCleverMerge({a: 1}, {a: 2})
- * {a: 2}
- *  // when same arguments passed, gets the result from WeakMap and returns it.
- * cachedCleverMerge({a: 1}, {a: 2})
- * {a: 2}
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
- */
-const cachedCleverMerge = (first, second) => {
-	if (second === undefined) return first;
-	if (first === undefined) return second;
-	if (typeof second !== "object" || second === null) return second;
-	if (typeof first !== "object" || first === null) return first;
-
-	let innerCache = mergeCache.get(first);
-	if (innerCache === undefined) {
-		innerCache = new WeakMap();
-		mergeCache.set(first, innerCache);
-	}
-	const prevMerge = innerCache.get(second);
-	if (prevMerge !== undefined) return prevMerge;
-	const newMerge = _cleverMerge(first, second, true);
-	innerCache.set(second, newMerge);
-	return newMerge;
-};
-
-/**
- * @template T
- * @param {Partial<T>} obj object
- * @param {string} property property
- * @param {string|number|boolean} value assignment value
- * @returns {T} new object
- */
-const cachedSetProperty = (obj, property, value) => {
-	let mapByProperty = setPropertyCache.get(obj);
-
-	if (mapByProperty === undefined) {
-		mapByProperty = new Map();
-		setPropertyCache.set(obj, mapByProperty);
-	}
-
-	let mapByValue = mapByProperty.get(property);
-
-	if (mapByValue === undefined) {
-		mapByValue = new Map();
-		mapByProperty.set(property, mapByValue);
-	}
-
-	let result = mapByValue.get(value);
-
-	if (result) return result;
-
-	result = {
-		...obj,
-		[property]: value
-	};
-	mapByValue.set(value, result);
-
-	return result;
-};
-
-/**
- * @typedef {Object} ObjectParsedPropertyEntry
- * @property {any | undefined} base base value
- * @property {string | undefined} byProperty the name of the selector property
- * @property {Map<string, any>} byValues value depending on selector property, merged with base
- */
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-/**
- * @typedef {Object} ParsedObject
- * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
- * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
- */
 
-/** @type {WeakMap<object, ParsedObject>} */
-const parseCache = new WeakMap();
 
-/**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
- */
-const cachedParseObject = obj => {
-	const entry = parseCache.get(obj);
-	if (entry !== undefined) return entry;
-	const result = parseObject(obj);
-	parseCache.set(obj, result);
-	return result;
-};
+const WebpackError = __webpack_require__(53799);
+
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RequestShortener")} RequestShortener */
 
 /**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
+ * @param {Module} module module to get chains from
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {RequestShortener} requestShortener to make readable identifiers
+ * @returns {string[]} all chains to the module
  */
-const parseObject = obj => {
-	const info = new Map();
-	let dynamicInfo;
-	const getInfo = p => {
-		const entry = info.get(p);
-		if (entry !== undefined) return entry;
-		const newEntry = {
-			base: undefined,
-			byProperty: undefined,
-			byValues: undefined
-		};
-		info.set(p, newEntry);
-		return newEntry;
-	};
-	for (const key of Object.keys(obj)) {
-		if (key.startsWith("by")) {
-			const byProperty = key;
-			const byObj = obj[byProperty];
-			if (typeof byObj === "object") {
-				for (const byValue of Object.keys(byObj)) {
-					const obj = byObj[byValue];
-					for (const key of Object.keys(obj)) {
-						const entry = getInfo(key);
-						if (entry.byProperty === undefined) {
-							entry.byProperty = byProperty;
-							entry.byValues = new Map();
-						} else if (entry.byProperty !== byProperty) {
-							throw new Error(
-								`${byProperty} and ${entry.byProperty} for a single property is not supported`
-							);
-						}
-						entry.byValues.set(byValue, obj[key]);
-						if (byValue === "default") {
-							for (const otherByValue of Object.keys(byObj)) {
-								if (!entry.byValues.has(otherByValue))
-									entry.byValues.set(otherByValue, undefined);
-							}
-						}
-					}
-				}
-			} else if (typeof byObj === "function") {
-				if (dynamicInfo === undefined) {
-					dynamicInfo = {
-						byProperty: key,
-						fn: byObj
-					};
-				} else {
-					throw new Error(
-						`${key} and ${dynamicInfo.byProperty} when both are functions is not supported`
-					);
+const getInitialModuleChains = (
+	module,
+	moduleGraph,
+	chunkGraph,
+	requestShortener
+) => {
+	const queue = [
+		{ head: module, message: module.readableIdentifier(requestShortener) }
+	];
+	/** @type {Set<string>} */
+	const results = new Set();
+	/** @type {Set<string>} */
+	const incompleteResults = new Set();
+	/** @type {Set<Module>} */
+	const visitedModules = new Set();
+
+	for (const chain of queue) {
+		const { head, message } = chain;
+		let final = true;
+		/** @type {Set<Module>} */
+		const alreadyReferencedModules = new Set();
+		for (const connection of moduleGraph.getIncomingConnections(head)) {
+			const newHead = connection.originModule;
+			if (newHead) {
+				if (!chunkGraph.getModuleChunks(newHead).some(c => c.canBeInitial()))
+					continue;
+				final = false;
+				if (alreadyReferencedModules.has(newHead)) continue;
+				alreadyReferencedModules.add(newHead);
+				const moduleName = newHead.readableIdentifier(requestShortener);
+				const detail = connection.explanation
+					? ` (${connection.explanation})`
+					: "";
+				const newMessage = `${moduleName}${detail} --> ${message}`;
+				if (visitedModules.has(newHead)) {
+					incompleteResults.add(`... --> ${newMessage}`);
+					continue;
 				}
+				visitedModules.add(newHead);
+				queue.push({
+					head: newHead,
+					message: newMessage
+				});
 			} else {
-				const entry = getInfo(key);
-				entry.base = obj[key];
-			}
-		} else {
-			const entry = getInfo(key);
-			entry.base = obj[key];
-		}
-	}
-	return {
-		static: info,
-		dynamic: dynamicInfo
-	};
-};
-
-/**
- * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
- * @returns {object} the object
- */
-const serializeObject = (info, dynamicInfo) => {
-	const obj = {};
-	// Setup byProperty structure
-	for (const entry of info.values()) {
-		if (entry.byProperty !== undefined) {
-			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
-			for (const byValue of entry.byValues.keys()) {
-				byObj[byValue] = byObj[byValue] || {};
+				final = false;
+				const newMessage = connection.explanation
+					? `(${connection.explanation}) --> ${message}`
+					: message;
+				results.add(newMessage);
 			}
 		}
-	}
-	for (const [key, entry] of info) {
-		if (entry.base !== undefined) {
-			obj[key] = entry.base;
-		}
-		// Fill byProperty structure
-		if (entry.byProperty !== undefined) {
-			const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
-			for (const byValue of Object.keys(byObj)) {
-				const value = getFromByValues(entry.byValues, byValue);
-				if (value !== undefined) byObj[byValue][key] = value;
-			}
+		if (final) {
+			results.add(message);
 		}
 	}
-	if (dynamicInfo !== undefined) {
-		obj[dynamicInfo.byProperty] = dynamicInfo.fn;
+	for (const result of incompleteResults) {
+		results.add(result);
 	}
-	return obj;
+	return Array.from(results);
 };
 
-const VALUE_TYPE_UNDEFINED = 0;
-const VALUE_TYPE_ATOM = 1;
-const VALUE_TYPE_ARRAY_EXTEND = 2;
-const VALUE_TYPE_OBJECT = 3;
-const VALUE_TYPE_DELETE = 4;
+module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
+	/**
+	 * @param {Module} module WASM module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RequestShortener} requestShortener request shortener
+	 */
+	constructor(module, moduleGraph, chunkGraph, requestShortener) {
+		const moduleChains = getInitialModuleChains(
+			module,
+			moduleGraph,
+			chunkGraph,
+			requestShortener
+		);
+		const message = `WebAssembly module is included in initial chunk.
+This is not allowed, because WebAssembly download and compilation must happen asynchronous.
+Add an async split point (i. e. import()) somewhere between your entrypoint and the WebAssembly module:
+${moduleChains.map(s => `* ${s}`).join("\n")}`;
 
-/**
- * @param {any} value a single value
- * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
- */
-const getValueType = value => {
-	if (value === undefined) {
-		return VALUE_TYPE_UNDEFINED;
-	} else if (value === DELETE) {
-		return VALUE_TYPE_DELETE;
-	} else if (Array.isArray(value)) {
-		if (value.lastIndexOf("...") !== -1) return VALUE_TYPE_ARRAY_EXTEND;
-		return VALUE_TYPE_ATOM;
-	} else if (
-		typeof value === "object" &&
-		value !== null &&
-		(!value.constructor || value.constructor === Object)
-	) {
-		return VALUE_TYPE_OBJECT;
+		super(message);
+		this.name = "WebAssemblyInInitialChunkError";
+		this.hideStack = true;
+		this.module = module;
 	}
-	return VALUE_TYPE_ATOM;
 };
 
-/**
- * Merges two objects. Objects are deeply clever merged.
- * Arrays might reference the old value with "...".
- * Non-object values take preference over object values.
- * @template T
- * @template O
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
- */
-const cleverMerge = (first, second) => {
-	if (second === undefined) return first;
-	if (first === undefined) return second;
-	if (typeof second !== "object" || second === null) return second;
-	if (typeof first !== "object" || first === null) return first;
 
-	return _cleverMerge(first, second, false);
-};
+/***/ }),
 
-/**
- * Merges two objects. Objects are deeply clever merged.
- * @param {object} first first object
- * @param {object} second second object
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {object} merged object of first and second object
- */
-const _cleverMerge = (first, second, internalCaching = false) => {
-	const firstObject = internalCaching
-		? cachedParseObject(first)
-		: parseObject(first);
-	const { static: firstInfo, dynamic: firstDynamicInfo } = firstObject;
+/***/ 46545:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	// If the first argument has a dynamic part we modify the dynamic part to merge the second argument
-	if (firstDynamicInfo !== undefined) {
-		let { byProperty, fn } = firstDynamicInfo;
-		const fnInfo = fn[DYNAMIC_INFO];
-		if (fnInfo) {
-			second = internalCaching
-				? cachedCleverMerge(fnInfo[1], second)
-				: cleverMerge(fnInfo[1], second);
-			fn = fnInfo[0];
-		}
-		const newFn = (...args) => {
-			const fnResult = fn(...args);
-			return internalCaching
-				? cachedCleverMerge(fnResult, second)
-				: cleverMerge(fnResult, second);
-		};
-		newFn[DYNAMIC_INFO] = [fn, second];
-		return serializeObject(firstObject.static, { byProperty, fn: newFn });
-	}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	// If the first part is static only, we merge the static parts and keep the dynamic part of the second argument
-	const secondObject = internalCaching
-		? cachedParseObject(second)
-		: parseObject(second);
-	const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
-	/** @type {Map<string, ObjectParsedPropertyEntry>} */
-	const resultInfo = new Map();
-	for (const [key, firstEntry] of firstInfo) {
-		const secondEntry = secondInfo.get(key);
-		const entry =
-			secondEntry !== undefined
-				? mergeEntries(firstEntry, secondEntry, internalCaching)
-				: firstEntry;
-		resultInfo.set(key, entry);
-	}
-	for (const [key, secondEntry] of secondInfo) {
-		if (!firstInfo.has(key)) {
-			resultInfo.set(key, secondEntry);
-		}
-	}
-	return serializeObject(resultInfo, secondDynamicInfo);
-};
 
-/**
- * @param {ObjectParsedPropertyEntry} firstEntry a
- * @param {ObjectParsedPropertyEntry} secondEntry b
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry} new entry
- */
-const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
-	switch (getValueType(secondEntry.base)) {
-		case VALUE_TYPE_ATOM:
-		case VALUE_TYPE_DELETE:
-			// No need to consider firstEntry at all
-			// second value override everything
-			// = second.base + second.byProperty
-			return secondEntry;
-		case VALUE_TYPE_UNDEFINED:
-			if (!firstEntry.byProperty) {
-				// = first.base + second.byProperty
-				return {
-					base: firstEntry.base,
-					byProperty: secondEntry.byProperty,
-					byValues: secondEntry.byValues
-				};
-			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
-				throw new Error(
-					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
-				);
-			} else {
-				// = first.base + (first.byProperty + second.byProperty)
-				// need to merge first and second byValues
-				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of secondEntry.byValues) {
-					const firstValue = getFromByValues(firstEntry.byValues, key);
-					newByValues.set(
-						key,
-						mergeSingleValue(firstValue, value, internalCaching)
-					);
-				}
-				return {
-					base: firstEntry.base,
-					byProperty: firstEntry.byProperty,
-					byValues: newByValues
-				};
-			}
-		default: {
-			if (!firstEntry.byProperty) {
-				// The simple case
-				// = (first.base + second.base) + second.byProperty
-				return {
-					base: mergeSingleValue(
-						firstEntry.base,
-						secondEntry.base,
-						internalCaching
-					),
-					byProperty: secondEntry.byProperty,
-					byValues: secondEntry.byValues
-				};
-			}
-			let newBase;
-			const intermediateByValues = new Map(firstEntry.byValues);
-			for (const [key, value] of intermediateByValues) {
-				intermediateByValues.set(
-					key,
-					mergeSingleValue(value, secondEntry.base, internalCaching)
-				);
-			}
-			if (
-				Array.from(firstEntry.byValues.values()).every(value => {
-					const type = getValueType(value);
-					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-				})
-			) {
-				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
-				newBase = mergeSingleValue(
-					firstEntry.base,
-					secondEntry.base,
-					internalCaching
-				);
-			} else {
-				// = first.base + ((first.byProperty (+default) + second.base) + second.byProperty)
-				newBase = firstEntry.base;
-				if (!intermediateByValues.has("default"))
-					intermediateByValues.set("default", secondEntry.base);
-			}
-			if (!secondEntry.byProperty) {
-				// = first.base + (first.byProperty + second.base)
-				return {
-					base: newBase,
-					byProperty: firstEntry.byProperty,
-					byValues: intermediateByValues
-				};
-			} else if (firstEntry.byProperty !== secondEntry.byProperty) {
-				throw new Error(
-					`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`
-				);
-			}
-			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of secondEntry.byValues) {
-				const firstValue = getFromByValues(intermediateByValues, key);
-				newByValues.set(
-					key,
-					mergeSingleValue(firstValue, value, internalCaching)
-				);
-			}
-			return {
-				base: newBase,
-				byProperty: firstEntry.byProperty,
-				byValues: newByValues
-			};
-		}
+
+const { RawSource } = __webpack_require__(51255);
+const { UsageState } = __webpack_require__(63686);
+const Generator = __webpack_require__(93401);
+const InitFragment = __webpack_require__(55870);
+const RuntimeGlobals = __webpack_require__(16475);
+const Template = __webpack_require__(1626);
+const ModuleDependency = __webpack_require__(80321);
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+const TYPES = new Set(["webassembly"]);
+
+class WebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module fresh module
+	 * @returns {Set<string>} available types (do not mutate)
+	 */
+	getTypes(module) {
+		return TYPES;
 	}
-};
 
-/**
- * @param {Map<string, any>} byValues all values
- * @param {string} key value of the selector
- * @returns {any | undefined} value
- */
-const getFromByValues = (byValues, key) => {
-	if (key !== "default" && byValues.has(key)) {
-		return byValues.get(key);
+	/**
+	 * @param {NormalModule} module the module
+	 * @param {string=} type source type
+	 * @returns {number} estimate size of the module
+	 */
+	getSize(module, type) {
+		return 95 + module.dependencies.length * 5;
 	}
-	return byValues.get("default");
-};
 
-/**
- * @param {any} a value
- * @param {any} b value
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {any} value
- */
-const mergeSingleValue = (a, b, internalCaching) => {
-	const bType = getValueType(b);
-	const aType = getValueType(a);
-	switch (bType) {
-		case VALUE_TYPE_DELETE:
-		case VALUE_TYPE_ATOM:
-			return b;
-		case VALUE_TYPE_OBJECT: {
-			return aType !== VALUE_TYPE_OBJECT
-				? b
-				: internalCaching
-				? cachedCleverMerge(a, b)
-				: cleverMerge(a, b);
-		}
-		case VALUE_TYPE_UNDEFINED:
-			return a;
-		case VALUE_TYPE_ARRAY_EXTEND:
-			switch (
-				aType !== VALUE_TYPE_ATOM
-					? aType
-					: Array.isArray(a)
-					? VALUE_TYPE_ARRAY_EXTEND
-					: VALUE_TYPE_OBJECT
-			) {
-				case VALUE_TYPE_UNDEFINED:
-					return b;
-				case VALUE_TYPE_DELETE:
-					return b.filter(item => item !== "...");
-				case VALUE_TYPE_ARRAY_EXTEND: {
-					const newArray = [];
-					for (const item of b) {
-						if (item === "...") {
-							for (const item of a) {
-								newArray.push(item);
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source} generated code
+	 */
+	generate(module, generateContext) {
+		const {
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime
+		} = generateContext;
+		/** @type {InitFragment[]} */
+		const initFragments = [];
+
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+
+		let needExportsCopy = false;
+		const importedModules = new Map();
+		const initParams = [];
+		let index = 0;
+		for (const dep of module.dependencies) {
+			const moduleDep =
+				dep && dep instanceof ModuleDependency ? dep : undefined;
+			if (moduleGraph.getModule(dep)) {
+				let importData = importedModules.get(moduleGraph.getModule(dep));
+				if (importData === undefined) {
+					importedModules.set(
+						moduleGraph.getModule(dep),
+						(importData = {
+							importVar: `m${index}`,
+							index,
+							request: (moduleDep && moduleDep.userRequest) || undefined,
+							names: new Set(),
+							reexports: []
+						})
+					);
+					index++;
+				}
+				if (dep instanceof WebAssemblyImportDependency) {
+					importData.names.add(dep.name);
+					if (dep.description.type === "GlobalType") {
+						const exportName = dep.name;
+						const importedModule = moduleGraph.getModule(dep);
+
+						if (importedModule) {
+							const usedName = moduleGraph
+								.getExportsInfo(importedModule)
+								.getUsedName(exportName, runtime);
+							if (usedName) {
+								initParams.push(
+									runtimeTemplate.exportFromImport({
+										moduleGraph,
+										module: importedModule,
+										request: dep.request,
+										importVar: importData.importVar,
+										originModule: module,
+										exportName: dep.name,
+										asiSafe: true,
+										isCall: false,
+										callContext: null,
+										defaultInterop: true,
+										initFragments,
+										runtime,
+										runtimeRequirements
+									})
+								);
 							}
-						} else {
-							newArray.push(item);
 						}
 					}
-					return newArray;
 				}
-				case VALUE_TYPE_OBJECT:
-					return b.map(item => (item === "..." ? a : item));
-				default:
-					throw new Error("Not implemented");
+				if (dep instanceof WebAssemblyExportImportedDependency) {
+					importData.names.add(dep.name);
+					const usedName = moduleGraph
+						.getExportsInfo(module)
+						.getUsedName(dep.exportName, runtime);
+					if (usedName) {
+						runtimeRequirements.add(RuntimeGlobals.exports);
+						const exportProp = `${module.exportsArgument}[${JSON.stringify(
+							usedName
+						)}]`;
+						const defineStatement = Template.asString([
+							`${exportProp} = ${runtimeTemplate.exportFromImport({
+								moduleGraph,
+								module: moduleGraph.getModule(dep),
+								request: dep.request,
+								importVar: importData.importVar,
+								originModule: module,
+								exportName: dep.name,
+								asiSafe: true,
+								isCall: false,
+								callContext: null,
+								defaultInterop: true,
+								initFragments,
+								runtime,
+								runtimeRequirements
+							})};`,
+							`if(WebAssembly.Global) ${exportProp} = ` +
+								`new WebAssembly.Global({ value: ${JSON.stringify(
+									dep.valueType
+								)} }, ${exportProp});`
+						]);
+						importData.reexports.push(defineStatement);
+						needExportsCopy = true;
+					}
+				}
 			}
-		default:
-			throw new Error("Not implemented");
-	}
-};
-
-/**
- * @template T
- * @param {T} obj the object
- * @returns {T} the object without operations like "..." or DELETE
- */
-const removeOperations = obj => {
-	const newObj = /** @type {T} */ ({});
-	for (const key of Object.keys(obj)) {
-		const value = obj[key];
-		const type = getValueType(value);
-		switch (type) {
-			case VALUE_TYPE_UNDEFINED:
-			case VALUE_TYPE_DELETE:
-				break;
-			case VALUE_TYPE_OBJECT:
-				newObj[key] = removeOperations(value);
-				break;
-			case VALUE_TYPE_ARRAY_EXTEND:
-				newObj[key] = value.filter(i => i !== "...");
-				break;
-			default:
-				newObj[key] = value;
-				break;
 		}
-	}
-	return newObj;
-};
+		const importsCode = Template.asString(
+			Array.from(
+				importedModules,
+				([module, { importVar, request, reexports }]) => {
+					const importStatement = runtimeTemplate.importStatement({
+						module,
+						chunkGraph,
+						request,
+						importVar,
+						originModule: module,
+						runtimeRequirements
+					});
+					return importStatement[0] + importStatement[1] + reexports.join("\n");
+				}
+			)
+		);
 
-/**
- * @template T
- * @template {string} P
- * @param {T} obj the object
- * @param {P} byProperty the by description
- * @param  {...any} values values
- * @returns {Omit<T, P>} object with merged byProperty
- */
-const resolveByProperty = (obj, byProperty, ...values) => {
-	if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
-		return obj;
-	}
-	const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
-	const remaining = /** @type {T} */ (_remaining);
-	const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (
-		_byValue
-	);
-	if (typeof byValue === "object") {
-		const key = values[0];
-		if (key in byValue) {
-			return cachedCleverMerge(remaining, byValue[key]);
-		} else if ("default" in byValue) {
-			return cachedCleverMerge(remaining, byValue.default);
-		} else {
-			return /** @type {T} */ (remaining);
+		const copyAllExports =
+			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused &&
+			!needExportsCopy;
+
+		// need these globals
+		runtimeRequirements.add(RuntimeGlobals.module);
+		runtimeRequirements.add(RuntimeGlobals.moduleId);
+		runtimeRequirements.add(RuntimeGlobals.wasmInstances);
+		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
+			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+			runtimeRequirements.add(RuntimeGlobals.exports);
 		}
-	} else if (typeof byValue === "function") {
-		const result = byValue.apply(null, values);
-		return cachedCleverMerge(
-			remaining,
-			resolveByProperty(result, byProperty, ...values)
+		if (!copyAllExports) {
+			runtimeRequirements.add(RuntimeGlobals.exports);
+		}
+
+		// create source
+		const source = new RawSource(
+			[
+				'"use strict";',
+				"// Instantiate WebAssembly module",
+				`var wasmExports = ${RuntimeGlobals.wasmInstances}[${module.moduleArgument}.id];`,
+
+				exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused
+					? `${RuntimeGlobals.makeNamespaceObject}(${module.exportsArgument});`
+					: "",
+
+				// this must be before import for circular dependencies
+				"// export exports from WebAssembly module",
+				copyAllExports
+					? `${module.moduleArgument}.exports = wasmExports;`
+					: "for(var name in wasmExports) " +
+					  `if(name) ` +
+					  `${module.exportsArgument}[name] = wasmExports[name];`,
+				"// exec imports from WebAssembly module (for esm order)",
+				importsCode,
+				"",
+				"// exec wasm module",
+				`wasmExports[""](${initParams.join(", ")})`
+			].join("\n")
 		);
+		return InitFragment.addToSource(source, initFragments, generateContext);
 	}
-};
+}
 
-exports.cachedSetProperty = cachedSetProperty;
-exports.cachedCleverMerge = cachedCleverMerge;
-exports.cleverMerge = cleverMerge;
-exports.resolveByProperty = resolveByProperty;
-exports.removeOperations = removeOperations;
-exports.DELETE = DELETE;
+module.exports = WebAssemblyJavascriptGenerator;
 
 
 /***/ }),
 
-/***/ 29579:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 53639:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -131395,464 +131707,347 @@ exports.DELETE = DELETE;
 
 
 
-const { compareRuntime } = __webpack_require__(17156);
+const Generator = __webpack_require__(93401);
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+const { compareModulesByIdentifier } = __webpack_require__(29579);
+const memoize = __webpack_require__(78676);
+const WebAssemblyInInitialChunkError = __webpack_require__(47342);
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleTemplate")} ModuleTemplate */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
-/** @template T @typedef {function(T, T): -1|0|1} Comparator */
-/** @template TArg @template T @typedef {function(TArg, T, T): -1|0|1} RawParameterizedComparator */
-/** @template TArg @template T @typedef {function(TArg): Comparator<T>} ParameterizedComparator */
+const getWebAssemblyGenerator = memoize(() =>
+	__webpack_require__(47012)
+);
+const getWebAssemblyJavascriptGenerator = memoize(() =>
+	__webpack_require__(46545)
+);
+const getWebAssemblyParser = memoize(() => __webpack_require__(57059));
 
-/**
- * @template T
- * @param {RawParameterizedComparator<any, T>} fn comparator with argument
- * @returns {ParameterizedComparator<any, T>} comparator
- */
-const createCachedParameterizedComparator = fn => {
-	/** @type {WeakMap<object, Comparator<T>>} */
-	const map = new WeakMap();
-	return arg => {
-		const cachedResult = map.get(arg);
-		if (cachedResult !== undefined) return cachedResult;
-		/**
-		 * @param {T} a first item
-		 * @param {T} b second item
-		 * @returns {-1|0|1} compare result
-		 */
-		const result = fn.bind(null, arg);
-		map.set(arg, result);
-		return result;
-	};
-};
+class WebAssemblyModulesPlugin {
+	constructor(options) {
+		this.options = options;
+	}
 
-/**
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {-1|0|1} compare result
- */
-exports.compareChunksById = (a, b) => {
-	return compareIds(a.id, b.id);
-};
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WebAssemblyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebAssemblyImportDependency,
+					normalModuleFactory
+				);
 
-/**
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-exports.compareModulesByIdentifier = (a, b) => {
-	return compareIds(a.identifier(), b.identifier());
-};
+				compilation.dependencyFactories.set(
+					WebAssemblyExportImportedDependency,
+					normalModuleFactory
+				);
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesById = (chunkGraph, a, b) => {
-	return compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
-};
-/** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesById =
-	createCachedParameterizedComparator(compareModulesById);
+				normalModuleFactory.hooks.createParser
+					.for("webassembly/sync")
+					.tap("WebAssemblyModulesPlugin", () => {
+						const WebAssemblyParser = getWebAssemblyParser();
 
-/**
- * @param {number} a number
- * @param {number} b number
- * @returns {-1|0|1} compare result
- */
-const compareNumbers = (a, b) => {
-	if (typeof a !== typeof b) {
-		return typeof a < typeof b ? -1 : 1;
-	}
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
-};
-exports.compareNumbers = compareNumbers;
+						return new WebAssemblyParser();
+					});
 
-/**
- * @param {string} a string
- * @param {string} b string
- * @returns {-1|0|1} compare result
- */
-const compareStringsNumeric = (a, b) => {
-	const partsA = a.split(/(\d+)/);
-	const partsB = b.split(/(\d+)/);
-	const len = Math.min(partsA.length, partsB.length);
-	for (let i = 0; i < len; i++) {
-		const pA = partsA[i];
-		const pB = partsB[i];
-		if (i % 2 === 0) {
-			if (pA.length > pB.length) {
-				if (pA.slice(0, pB.length) > pB) return 1;
-				return -1;
-			} else if (pB.length > pA.length) {
-				if (pB.slice(0, pA.length) > pA) return -1;
-				return 1;
-			} else {
-				if (pA < pB) return -1;
-				if (pA > pB) return 1;
+				normalModuleFactory.hooks.createGenerator
+					.for("webassembly/sync")
+					.tap("WebAssemblyModulesPlugin", () => {
+						const WebAssemblyJavascriptGenerator =
+							getWebAssemblyJavascriptGenerator();
+						const WebAssemblyGenerator = getWebAssemblyGenerator();
+
+						return Generator.byType({
+							javascript: new WebAssemblyJavascriptGenerator(),
+							webassembly: new WebAssemblyGenerator(this.options)
+						});
+					});
+
+				compilation.hooks.renderManifest.tap(
+					"WebAssemblyModulesPlugin",
+					(result, options) => {
+						const { chunkGraph } = compilation;
+						const { chunk, outputOptions, codeGenerationResults } = options;
+
+						for (const module of chunkGraph.getOrderedChunkModulesIterable(
+							chunk,
+							compareModulesByIdentifier
+						)) {
+							if (module.type === "webassembly/sync") {
+								const filenameTemplate =
+									outputOptions.webassemblyModuleFilename;
+
+								result.push({
+									render: () =>
+										codeGenerationResults.getSource(
+											module,
+											chunk.runtime,
+											"webassembly"
+										),
+									filenameTemplate,
+									pathOptions: {
+										module,
+										runtime: chunk.runtime,
+										chunkGraph
+									},
+									auxiliary: true,
+									identifier: `webassemblyModule${chunkGraph.getModuleId(
+										module
+									)}`,
+									hash: chunkGraph.getModuleHash(module, chunk.runtime)
+								});
+							}
+						}
+
+						return result;
+					}
+				);
+
+				compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
+					const chunkGraph = compilation.chunkGraph;
+					const initialWasmModules = new Set();
+					for (const chunk of compilation.chunks) {
+						if (chunk.canBeInitial()) {
+							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+								if (module.type === "webassembly/sync") {
+									initialWasmModules.add(module);
+								}
+							}
+						}
+					}
+					for (const module of initialWasmModules) {
+						compilation.errors.push(
+							new WebAssemblyInInitialChunkError(
+								module,
+								compilation.moduleGraph,
+								compilation.chunkGraph,
+								compilation.requestShortener
+							)
+						);
+					}
+				});
 			}
-		} else {
-			const nA = +pA;
-			const nB = +pB;
-			if (nA < nB) return -1;
-			if (nA > nB) return 1;
-		}
+		);
 	}
-	if (partsB.length < partsA.length) return 1;
-	if (partsB.length > partsA.length) return -1;
-	return 0;
-};
-exports.compareStringsNumeric = compareStringsNumeric;
+}
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesByPostOrderIndexOrIdentifier = (moduleGraph, a, b) => {
-	const cmp = compareNumbers(
-		moduleGraph.getPostOrderIndex(a),
-		moduleGraph.getPostOrderIndex(b)
-	);
-	if (cmp !== 0) return cmp;
-	return compareIds(a.identifier(), b.identifier());
-};
-/** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPostOrderIndexOrIdentifier =
-	createCachedParameterizedComparator(
-		compareModulesByPostOrderIndexOrIdentifier
-	);
+module.exports = WebAssemblyModulesPlugin;
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesByPreOrderIndexOrIdentifier = (moduleGraph, a, b) => {
-	const cmp = compareNumbers(
-		moduleGraph.getPreOrderIndex(a),
-		moduleGraph.getPreOrderIndex(b)
-	);
-	if (cmp !== 0) return cmp;
-	return compareIds(a.identifier(), b.identifier());
-};
-/** @type {ParameterizedComparator<ModuleGraph, Module>} */
-exports.compareModulesByPreOrderIndexOrIdentifier =
-	createCachedParameterizedComparator(
-		compareModulesByPreOrderIndexOrIdentifier
-	);
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Module} a module
- * @param {Module} b module
- * @returns {-1|0|1} compare result
- */
-const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
-	const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
-	if (cmp !== 0) return cmp;
-	return compareIds(a.identifier(), b.identifier());
-};
-/** @type {ParameterizedComparator<ChunkGraph, Module>} */
-exports.compareModulesByIdOrIdentifier = createCachedParameterizedComparator(
-	compareModulesByIdOrIdentifier
-);
+/***/ }),
+
+/***/ 57059:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Chunk} a chunk
- * @param {Chunk} b chunk
- * @returns {-1|0|1} compare result
- */
-const compareChunks = (chunkGraph, a, b) => {
-	return chunkGraph.compareChunks(a, b);
-};
-/** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
-exports.compareChunks = createCachedParameterizedComparator(compareChunks);
+
+
+const t = __webpack_require__(51826);
+const { moduleContextFromModuleAST } = __webpack_require__(51826);
+const { decode } = __webpack_require__(73726);
+const Parser = __webpack_require__(11715);
+const StaticExportsDependency = __webpack_require__(91418);
+const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+const WebAssemblyImportDependency = __webpack_require__(5239);
+
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+
+const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
 
 /**
- * @param {string|number} a first id
- * @param {string|number} b second id
- * @returns {-1|0|1} compare result
+ * @param {t.Signature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
  */
-const compareIds = (a, b) => {
-	if (typeof a !== typeof b) {
-		return typeof a < typeof b ? -1 : 1;
+const getJsIncompatibleType = signature => {
+	for (const param of signature.params) {
+		if (!JS_COMPAT_TYPES.has(param.valtype)) {
+			return `${param.valtype} as parameter`;
+		}
 	}
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
+	for (const type of signature.results) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
 };
 
-exports.compareIds = compareIds;
-
 /**
- * @param {string} a first string
- * @param {string} b second string
- * @returns {-1|0|1} compare result
+ * TODO why are there two different Signature types?
+ * @param {t.FuncSignature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
  */
-const compareStrings = (a, b) => {
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
+const getJsIncompatibleTypeOfFuncSignature = signature => {
+	for (const param of signature.args) {
+		if (!JS_COMPAT_TYPES.has(param)) {
+			return `${param} as parameter`;
+		}
+	}
+	for (const type of signature.result) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
 };
 
-exports.compareStrings = compareStrings;
+const decoderOpts = {
+	ignoreCodeSection: true,
+	ignoreDataSection: true,
 
-/**
- * @param {ChunkGroup} a first chunk group
- * @param {ChunkGroup} b second chunk group
- * @returns {-1|0|1} compare result
- */
-const compareChunkGroupsByIndex = (a, b) => {
-	return a.index < b.index ? -1 : 1;
+	// this will avoid having to lookup with identifiers in the ModuleContext
+	ignoreCustomNameSection: true
 };
 
-exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
-
-/**
- * @template K1 {Object}
- * @template K2
- * @template T
- */
-class TwoKeyWeakMap {
-	constructor() {
-		/** @private @type {WeakMap<any, WeakMap<any, T>>} */
-		this._map = new WeakMap();
+class WebAssemblyParser extends Parser {
+	constructor(options) {
+		super();
+		this.hooks = Object.freeze({});
+		this.options = options;
 	}
 
 	/**
-	 * @param {K1} key1 first key
-	 * @param {K2} key2 second key
-	 * @returns {T | undefined} value
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
 	 */
-	get(key1, key2) {
-		const childMap = this._map.get(key1);
-		if (childMap === undefined) {
-			return undefined;
+	parse(source, state) {
+		if (!Buffer.isBuffer(source)) {
+			throw new Error("WebAssemblyParser input must be a Buffer");
 		}
-		return childMap.get(key2);
-	}
 
-	/**
-	 * @param {K1} key1 first key
-	 * @param {K2} key2 second key
-	 * @param {T | undefined} value new value
-	 * @returns {void}
-	 */
-	set(key1, key2, value) {
-		let childMap = this._map.get(key1);
-		if (childMap === undefined) {
-			childMap = new WeakMap();
-			this._map.set(key1, childMap);
-		}
-		childMap.set(key2, value);
-	}
-}
+		// flag it as ESM
+		state.module.buildInfo.strict = true;
+		state.module.buildMeta.exportsType = "namespace";
 
-/** @type {TwoKeyWeakMap<Comparator<any>, Comparator<any>, Comparator<any>>}} */
-const concatComparatorsCache = new TwoKeyWeakMap();
+		// parse it
+		const program = decode(source, decoderOpts);
+		const module = program.body[0];
 
-/**
- * @template T
- * @param {Comparator<T>} c1 comparator
- * @param {Comparator<T>} c2 comparator
- * @param {Comparator<T>[]} cRest comparators
- * @returns {Comparator<T>} comparator
- */
-const concatComparators = (c1, c2, ...cRest) => {
-	if (cRest.length > 0) {
-		const [c3, ...cRest2] = cRest;
-		return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
-	}
-	const cacheEntry = /** @type {Comparator<T>} */ (
-		concatComparatorsCache.get(c1, c2)
-	);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {T} a first value
-	 * @param {T} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const res = c1(a, b);
-		if (res !== 0) return res;
-		return c2(a, b);
-	};
-	concatComparatorsCache.set(c1, c2, result);
-	return result;
-};
-exports.concatComparators = concatComparators;
+		const moduleContext = moduleContextFromModuleAST(module);
 
-/** @template A, B @typedef {(input: A) => B} Selector */
+		// extract imports and exports
+		const exports = [];
+		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
+			undefined);
 
-/** @type {TwoKeyWeakMap<Selector<any, any>, Comparator<any>, Comparator<any>>}} */
-const compareSelectCache = new TwoKeyWeakMap();
+		const importedGlobals = [];
+		t.traverse(module, {
+			ModuleExport({ node }) {
+				const descriptor = node.descr;
 
-/**
- * @template T
- * @template R
- * @param {Selector<T, R>} getter getter for value
- * @param {Comparator<R>} comparator comparator
- * @returns {Comparator<T>} comparator
- */
-const compareSelect = (getter, comparator) => {
-	const cacheEntry = compareSelectCache.get(getter, comparator);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {T} a first value
-	 * @param {T} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const aValue = getter(a);
-		const bValue = getter(b);
-		if (aValue !== undefined && aValue !== null) {
-			if (bValue !== undefined && bValue !== null) {
-				return comparator(aValue, bValue);
-			}
-			return -1;
-		} else {
-			if (bValue !== undefined && bValue !== null) {
-				return 1;
-			}
-			return 0;
-		}
-	};
-	compareSelectCache.set(getter, comparator, result);
-	return result;
-};
-exports.compareSelect = compareSelect;
+				if (descriptor.exportType === "Func") {
+					const funcIdx = descriptor.id.value;
 
-/** @type {WeakMap<Comparator<any>, Comparator<Iterable<any>>>} */
-const compareIteratorsCache = new WeakMap();
+					/** @type {t.FuncSignature} */
+					const funcSignature = moduleContext.getFunction(funcIdx);
 
-/**
- * @template T
- * @param {Comparator<T>} elementComparator comparator for elements
- * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
- */
-const compareIterables = elementComparator => {
-	const cacheEntry = compareIteratorsCache.get(elementComparator);
-	if (cacheEntry !== undefined) return cacheEntry;
-	/**
-	 * @param {Iterable<T>} a first value
-	 * @param {Iterable<T>} b second value
-	 * @returns {-1|0|1} compare result
-	 */
-	const result = (a, b) => {
-		const aI = a[Symbol.iterator]();
-		const bI = b[Symbol.iterator]();
-		// eslint-disable-next-line no-constant-condition
-		while (true) {
-			const aItem = aI.next();
-			const bItem = bI.next();
-			if (aItem.done) {
-				return bItem.done ? 0 : -1;
-			} else if (bItem.done) {
-				return 1;
-			}
-			const res = elementComparator(aItem.value, bItem.value);
-			if (res !== 0) return res;
-		}
-	};
-	compareIteratorsCache.set(elementComparator, result);
-	return result;
-};
-exports.compareIterables = compareIterables;
+					const incompatibleType =
+						getJsIncompatibleTypeOfFuncSignature(funcSignature);
 
-// TODO this is no longer needed when minimum node.js version is >= 12
-// since these versions ship with a stable sort function
-/**
- * @template T
- * @param {Iterable<T>} iterable original ordered list
- * @returns {Comparator<T>} comparator
- */
-exports.keepOriginalOrder = iterable => {
-	/** @type {Map<T, number>} */
-	const map = new Map();
-	let i = 0;
-	for (const item of iterable) {
-		map.set(item, i++);
-	}
-	return (a, b) => compareNumbers(map.get(a), map.get(b));
-};
+					if (incompatibleType) {
+						if (jsIncompatibleExports === undefined) {
+							jsIncompatibleExports =
+								state.module.buildMeta.jsIncompatibleExports = {};
+						}
+						jsIncompatibleExports[node.name] = incompatibleType;
+					}
+				}
 
-/**
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @returns {Comparator<Chunk>} comparator
- */
-exports.compareChunksNatural = chunkGraph => {
-	const cmpFn = exports.compareModulesById(chunkGraph);
-	const cmpIterableFn = compareIterables(cmpFn);
-	return concatComparators(
-		compareSelect(chunk => chunk.name, compareIds),
-		compareSelect(chunk => chunk.runtime, compareRuntime),
-		compareSelect(
-			/**
-			 * @param {Chunk} chunk a chunk
-			 * @returns {Iterable<Module>} modules
-			 */
-			chunk => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn),
-			cmpIterableFn
-		)
-	);
-};
+				exports.push(node.name);
 
-/**
- * Compare two locations
- * @param {DependencyLocation} a A location node
- * @param {DependencyLocation} b A location node
- * @returns {-1|0|1} sorting comparator value
- */
-exports.compareLocations = (a, b) => {
-	let isObjectA = typeof a === "object" && a !== null;
-	let isObjectB = typeof b === "object" && b !== null;
-	if (!isObjectA || !isObjectB) {
-		if (isObjectA) return 1;
-		if (isObjectB) return -1;
-		return 0;
+				if (node.descr && node.descr.exportType === "Global") {
+					const refNode = importedGlobals[node.descr.id.value];
+					if (refNode) {
+						const dep = new WebAssemblyExportImportedDependency(
+							node.name,
+							refNode.module,
+							refNode.name,
+							refNode.descr.valtype
+						);
+
+						state.module.addDependency(dep);
+					}
+				}
+			},
+
+			Global({ node }) {
+				const init = node.init[0];
+
+				let importNode = null;
+
+				if (init.id === "get_global") {
+					const globalIdx = init.args[0].value;
+
+					if (globalIdx < importedGlobals.length) {
+						importNode = importedGlobals[globalIdx];
+					}
+				}
+
+				importedGlobals.push(importNode);
+			},
+
+			ModuleImport({ node }) {
+				/** @type {false | string} */
+				let onlyDirectImport = false;
+
+				if (t.isMemory(node.descr) === true) {
+					onlyDirectImport = "Memory";
+				} else if (t.isTable(node.descr) === true) {
+					onlyDirectImport = "Table";
+				} else if (t.isFuncImportDescr(node.descr) === true) {
+					const incompatibleType = getJsIncompatibleType(node.descr.signature);
+					if (incompatibleType) {
+						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
+					}
+				} else if (t.isGlobalType(node.descr) === true) {
+					const type = node.descr.valtype;
+					if (!JS_COMPAT_TYPES.has(type)) {
+						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
+					}
+				}
+
+				const dep = new WebAssemblyImportDependency(
+					node.module,
+					node.name,
+					node.descr,
+					onlyDirectImport
+				);
+
+				state.module.addDependency(dep);
+
+				if (t.isGlobalType(node.descr)) {
+					importedGlobals.push(node);
+				}
+			}
+		});
+
+		state.module.addDependency(new StaticExportsDependency(exports, false));
+
+		return state;
 	}
-	if ("start" in a) {
-		if ("start" in b) {
-			const ap = a.start;
-			const bp = b.start;
-			if (ap.line < bp.line) return -1;
-			if (ap.line > bp.line) return 1;
-			if (ap.column < bp.column) return -1;
-			if (ap.column > bp.column) return 1;
-		} else return -1;
-	} else if ("start" in b) return 1;
-	if ("name" in a) {
-		if ("name" in b) {
-			if (a.name < b.name) return -1;
-			if (a.name > b.name) return 1;
-		} else return -1;
-	} else if ("name" in b) return 1;
-	if ("index" in a) {
-		if ("index" in b) {
-			if (a.index < b.index) return -1;
-			if (a.index > b.index) return 1;
-		} else return -1;
-	} else if ("index" in b) return 1;
-	return 0;
-};
+}
+
+module.exports = WebAssemblyParser;
 
 
 /***/ }),
 
-/***/ 29404:
-/***/ (function(module) {
+/***/ 18650:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -131862,210 +132057,195 @@ exports.compareLocations = (a, b) => {
 
 
 
-const quoteMeta = str => {
-	return str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
-};
+const Template = __webpack_require__(1626);
+const WebAssemblyImportDependency = __webpack_require__(5239);
 
-const toSimpleString = str => {
-	if (`${+str}` === str) {
-		return str;
-	}
-	return JSON.stringify(str);
-};
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 
-/**
- * @param {Record<string|number, boolean>} map value map
- * @returns {true|false|function(string): string} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+/** @typedef {Object} UsedWasmDependency
+ * @property {WebAssemblyImportDependency} dependency the dependency
+ * @property {string} name the export name
+ * @property {string} module the module name
  */
-const compileBooleanMatcher = map => {
-	const positiveItems = Object.keys(map).filter(i => map[i]);
-	const negativeItems = Object.keys(map).filter(i => !map[i]);
-	if (positiveItems.length === 0) return false;
-	if (negativeItems.length === 0) return true;
-	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
-};
+
+const MANGLED_MODULE = "a";
 
 /**
- * @param {string[]} positiveItems positive items
- * @param {string[]} negativeItems negative items
- * @returns {function(string): string} a template function to determine the value at runtime
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the module
+ * @param {boolean} mangle mangle module and export names
+ * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
  */
-const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
-	if (positiveItems.length === 0) return () => "false";
-	if (negativeItems.length === 0) return () => "true";
-	if (positiveItems.length === 1)
-		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
-	if (negativeItems.length === 1)
-		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
-	const positiveRegexp = itemsToRegexp(positiveItems);
-	const negativeRegexp = itemsToRegexp(negativeItems);
-	if (positiveRegexp.length <= negativeRegexp.length) {
-		return value => `/^${positiveRegexp}$/.test(${value})`;
-	} else {
-		return value => `!/^${negativeRegexp}$/.test(${value})`;
-	}
-};
-
-const popCommonItems = (itemsSet, getKey, condition) => {
-	const map = new Map();
-	for (const item of itemsSet) {
-		const key = getKey(item);
-		if (key) {
-			let list = map.get(key);
-			if (list === undefined) {
-				list = [];
-				map.set(key, list);
-			}
-			list.push(item);
-		}
-	}
-	const result = [];
-	for (const list of map.values()) {
-		if (condition(list)) {
-			for (const item of list) {
-				itemsSet.delete(item);
+const getUsedDependencies = (moduleGraph, module, mangle) => {
+	/** @type {UsedWasmDependency[]} */
+	const array = [];
+	let importIndex = 0;
+	for (const dep of module.dependencies) {
+		if (dep instanceof WebAssemblyImportDependency) {
+			if (
+				dep.description.type === "GlobalType" ||
+				moduleGraph.getModule(dep) === null
+			) {
+				continue;
 			}
-			result.push(list);
-		}
-	}
-	return result;
-};
 
-const getCommonPrefix = items => {
-	let prefix = items[0];
-	for (let i = 1; i < items.length; i++) {
-		const item = items[i];
-		for (let p = 0; p < prefix.length; p++) {
-			if (item[p] !== prefix[p]) {
-				prefix = prefix.slice(0, p);
-				break;
+			const exportName = dep.name;
+			// TODO add the following 3 lines when removing of ModuleExport is possible
+			// const importedModule = moduleGraph.getModule(dep);
+			// const usedName = importedModule && moduleGraph.getExportsInfo(importedModule).getUsedName(exportName, runtime);
+			// if (usedName !== false) {
+			if (mangle) {
+				array.push({
+					dependency: dep,
+					name: Template.numberToIdentifier(importIndex++),
+					module: MANGLED_MODULE
+				});
+			} else {
+				array.push({
+					dependency: dep,
+					name: exportName,
+					module: dep.request
+				});
 			}
 		}
 	}
-	return prefix;
+	return array;
 };
 
-const getCommonSuffix = items => {
-	let suffix = items[0];
-	for (let i = 1; i < items.length; i++) {
-		const item = items[i];
-		for (let p = item.length - 1, s = suffix.length - 1; s >= 0; p--, s--) {
-			if (item[p] !== suffix[s]) {
-				suffix = suffix.slice(s + 1);
-				break;
-			}
-		}
+exports.getUsedDependencies = getUsedDependencies;
+exports.MANGLED_MODULE = MANGLED_MODULE;
+
+
+/***/ }),
+
+/***/ 78613:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
+/** @typedef {import("../Compiler")} Compiler */
+
+/** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
+const enabledTypes = new WeakMap();
+
+const getEnabledTypes = compiler => {
+	let set = enabledTypes.get(compiler);
+	if (set === undefined) {
+		set = new Set();
+		enabledTypes.set(compiler, set);
 	}
-	return suffix;
+	return set;
 };
 
-const itemsToRegexp = itemsArr => {
-	if (itemsArr.length === 1) {
-		return quoteMeta(itemsArr[0]);
+class EnableWasmLoadingPlugin {
+	/**
+	 * @param {WasmLoadingType} type library type that should be available
+	 */
+	constructor(type) {
+		this.type = type;
 	}
-	const finishedItems = [];
 
-	// merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
-	let countOfSingleCharItems = 0;
-	for (const item of itemsArr) {
-		if (item.length === 1) {
-			countOfSingleCharItems++;
-		}
-	}
-	// special case for only single char items
-	if (countOfSingleCharItems === itemsArr.length) {
-		return `[${quoteMeta(itemsArr.sort().join(""))}]`;
-	}
-	const items = new Set(itemsArr.sort());
-	if (countOfSingleCharItems > 2) {
-		let singleCharItems = "";
-		for (const item of items) {
-			if (item.length === 1) {
-				singleCharItems += item;
-				items.delete(item);
-			}
-		}
-		finishedItems.push(`[${quoteMeta(singleCharItems)}]`);
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {WasmLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static setEnabled(compiler, type) {
+		getEnabledTypes(compiler).add(type);
 	}
 
-	// special case for 2 items with common prefix/suffix
-	if (finishedItems.length === 0 && items.size === 2) {
-		const prefix = getCommonPrefix(itemsArr);
-		const suffix = getCommonSuffix(
-			itemsArr.map(item => item.slice(prefix.length))
-		);
-		if (prefix.length > 0 || suffix.length > 0) {
-			return `${quoteMeta(prefix)}${itemsToRegexp(
-				itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined))
-			)}${quoteMeta(suffix)}`;
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @param {WasmLoadingType} type type of library
+	 * @returns {void}
+	 */
+	static checkEnabled(compiler, type) {
+		if (!getEnabledTypes(compiler).has(type)) {
+			throw new Error(
+				`Library type "${type}" is not enabled. ` +
+					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
+					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
+					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
+					"These types are enabled: " +
+					Array.from(getEnabledTypes(compiler)).join(", ")
+			);
 		}
 	}
 
-	// special case for 2 items with common suffix
-	if (finishedItems.length === 0 && items.size === 2) {
-		const it = items[Symbol.iterator]();
-		const a = it.next().value;
-		const b = it.next().value;
-		if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
-			return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(
-				a.slice(-1)
-			)}`;
-		}
-	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const { type } = this;
 
-	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
-	const prefixed = popCommonItems(
-		items,
-		item => (item.length >= 1 ? item[0] : false),
-		list => {
-			if (list.length >= 3) return true;
-			if (list.length <= 1) return false;
-			return list[0][1] === list[1][1];
-		}
-	);
-	for (const prefixedItems of prefixed) {
-		const prefix = getCommonPrefix(prefixedItems);
-		finishedItems.push(
-			`${quoteMeta(prefix)}${itemsToRegexp(
-				prefixedItems.map(i => i.slice(prefix.length))
-			)}`
-		);
-	}
+		// Only enable once
+		const enabled = getEnabledTypes(compiler);
+		if (enabled.has(type)) return;
+		enabled.add(type);
 
-	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
-	const suffixed = popCommonItems(
-		items,
-		item => (item.length >= 1 ? item.slice(-1) : false),
-		list => {
-			if (list.length >= 3) return true;
-			if (list.length <= 1) return false;
-			return list[0].slice(-2) === list[1].slice(-2);
+		if (typeof type === "string") {
+			switch (type) {
+				case "fetch": {
+					// TODO webpack 6 remove FetchCompileWasmPlugin
+					const FetchCompileWasmPlugin = __webpack_require__(35537);
+					const FetchCompileAsyncWasmPlugin = __webpack_require__(8437);
+					new FetchCompileWasmPlugin({
+						mangleImports: compiler.options.optimization.mangleWasmImports
+					}).apply(compiler);
+					new FetchCompileAsyncWasmPlugin().apply(compiler);
+					break;
+				}
+				case "async-node": {
+					// TODO webpack 6 remove ReadFileCompileWasmPlugin
+					const ReadFileCompileWasmPlugin = __webpack_require__(98939);
+					// @ts-expect-error typescript bug for duplicate require
+					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
+					new ReadFileCompileWasmPlugin({
+						mangleImports: compiler.options.optimization.mangleWasmImports
+					}).apply(compiler);
+					new ReadFileCompileAsyncWasmPlugin({ type }).apply(compiler);
+					break;
+				}
+				case "async-node-module": {
+					// @ts-expect-error typescript bug for duplicate require
+					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
+					new ReadFileCompileAsyncWasmPlugin({ type, import: true }).apply(
+						compiler
+					);
+					break;
+				}
+				case "universal":
+					throw new Error(
+						"Universal WebAssembly Loading is not implemented yet"
+					);
+				default:
+					throw new Error(`Unsupported wasm loading type ${type}.
+Plugins which provide custom wasm loading types must call EnableWasmLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
+			}
+		} else {
+			// TODO support plugin instances here
+			// apply them to the compiler
 		}
-	);
-	for (const suffixedItems of suffixed) {
-		const suffix = getCommonSuffix(suffixedItems);
-		finishedItems.push(
-			`${itemsToRegexp(
-				suffixedItems.map(i => i.slice(0, -suffix.length))
-			)}${quoteMeta(suffix)}`
-		);
 	}
+}
 
-	// TODO further optimize regexp, i. e.
-	// use ranges: (1|2|3|4|a) => [1-4a]
-	const conditional = finishedItems.concat(Array.from(items, quoteMeta));
-	if (conditional.length === 1) return conditional[0];
-	return `(${conditional.join("|")})`;
-};
-
-compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
-compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
-module.exports = compileBooleanMatcher;
+module.exports = EnableWasmLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 32540:
+/***/ 8437:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -132076,32 +132256,66 @@ module.exports = compileBooleanMatcher;
 
 
 
-const memoize = __webpack_require__(78676);
+const RuntimeGlobals = __webpack_require__(16475);
+const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
 
-const getValidate = memoize(() => (__webpack_require__(38476).validate));
+/** @typedef {import("../Compiler")} Compiler */
 
-const createSchemaValidation = (check, getSchema, options) => {
-	getSchema = memoize(getSchema);
-	return value => {
-		if (check && !check(value)) {
-			getValidate()(getSchema(), value, options);
-			if (check) {
-				(__webpack_require__(73837).deprecate)(
-					() => {},
-					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
-					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
-				)();
+class FetchCompileAsyncWasmPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"FetchCompileAsyncWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === "fetch";
+				};
+				const generateLoadBinaryCode = path =>
+					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.instantiateWasm)
+					.tap("FetchCompileAsyncWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/async"
+							)
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.publicPath);
+						compilation.addRuntimeModule(
+							chunk,
+							new AsyncWasmLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: true
+							})
+						);
+					});
 			}
-		}
-	};
-};
+		);
+	}
+}
 
-module.exports = createSchemaValidation;
+module.exports = FetchCompileAsyncWasmPlugin;
 
 
 /***/ }),
 
-/***/ 49835:
+/***/ 35537:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -132112,448 +132326,623 @@ module.exports = createSchemaValidation;
 
 
 
-const Hash = __webpack_require__(36692);
+const RuntimeGlobals = __webpack_require__(16475);
+const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
 
-const BULK_SIZE = 2000;
+/** @typedef {import("../Compiler")} Compiler */
 
-// We are using an object instead of a Map as this will stay static during the runtime
-// so access to it can be optimized by v8
-const digestCaches = {};
+// TODO webpack 6 remove
 
-class BulkUpdateDecorator extends Hash {
-	/**
-	 * @param {Hash | function(): Hash} hashOrFactory function to create a hash
-	 * @param {string=} hashKey key for caching
-	 */
-	constructor(hashOrFactory, hashKey) {
-		super();
-		this.hashKey = hashKey;
-		if (typeof hashOrFactory === "function") {
-			this.hashFactory = hashOrFactory;
-			this.hash = undefined;
-		} else {
-			this.hashFactory = undefined;
-			this.hash = hashOrFactory;
-		}
-		this.buffer = "";
+class FetchCompileWasmPlugin {
+	constructor(options) {
+		this.options = options || {};
 	}
 
 	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	update(data, inputEncoding) {
-		if (
-			inputEncoding !== undefined ||
-			typeof data !== "string" ||
-			data.length > BULK_SIZE
-		) {
-			if (this.hash === undefined) this.hash = this.hashFactory();
-			if (this.buffer.length > 0) {
-				this.hash.update(this.buffer);
-				this.buffer = "";
-			}
-			this.hash.update(data, inputEncoding);
-		} else {
-			this.buffer += data;
-			if (this.buffer.length > BULK_SIZE) {
-				if (this.hash === undefined) this.hash = this.hashFactory();
-				this.hash.update(this.buffer);
-				this.buffer = "";
-			}
-		}
-		return this;
-	}
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"FetchCompileWasmPlugin",
+			compilation => {
+				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const wasmLoading =
+						options && options.wasmLoading !== undefined
+							? options.wasmLoading
+							: globalWasmLoading;
+					return wasmLoading === "fetch";
+				};
+				const generateLoadBinaryCode = path =>
+					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
-	 */
-	digest(encoding) {
-		let digestCache;
-		const buffer = this.buffer;
-		if (this.hash === undefined) {
-			// short data for hash, we can use caching
-			const cacheKey = `${this.hashKey}-${encoding}`;
-			digestCache = digestCaches[cacheKey];
-			if (digestCache === undefined) {
-				digestCache = digestCaches[cacheKey] = new Map();
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("FetchCompileWasmPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						const chunkGraph = compilation.chunkGraph;
+						if (
+							!chunkGraph.hasModuleInGraph(
+								chunk,
+								m => m.type === "webassembly/sync"
+							)
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.publicPath);
+						compilation.addRuntimeModule(
+							chunk,
+							new WasmChunkLoadingRuntimeModule({
+								generateLoadBinaryCode,
+								supportsStreaming: true,
+								mangleImports: this.options.mangleImports,
+								runtimeRequirements: set
+							})
+						);
+					});
 			}
-			const cacheEntry = digestCache.get(buffer);
-			if (cacheEntry !== undefined) return cacheEntry;
-			this.hash = this.hashFactory();
-		}
-		if (buffer.length > 0) {
-			this.hash.update(buffer);
-		}
-		const digestResult = this.hash.digest(encoding);
-		const result =
-			typeof digestResult === "string" ? digestResult : digestResult.toString();
-		if (digestCache !== undefined) {
-			digestCache.set(buffer, result);
-		}
-		return result;
+		);
 	}
 }
 
-/* istanbul ignore next */
-class DebugHash extends Hash {
-	constructor() {
-		super();
-		this.string = "";
-	}
+module.exports = FetchCompileWasmPlugin;
 
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (typeof data !== "string") data = data.toString("utf-8");
-		if (data.startsWith("debug-digest-")) {
-			data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
-		}
-		this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
-		return this;
-	}
 
+/***/ }),
+
+/***/ 83121:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class JsonpChunkLoadingPlugin {
 	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
 	 */
-	digest(encoding) {
-		return "debug-digest-" + Buffer.from(this.string).toString("hex");
-	}
-}
-
-let crypto = undefined;
-let createXXHash64 = undefined;
-let createMd4 = undefined;
-let BatchedHash = undefined;
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(
+			"JsonpChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === "jsonp";
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					compilation.addRuntimeModule(
+						chunk,
+						new JsonpChunkLoadingRuntimeModule(set)
+					);
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("JsonpChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.onChunksLoaded)
+					.tap("JsonpChunkLoadingPlugin", handler);
 
-/**
- * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
- * @returns {Hash} the hash
- */
-module.exports = algorithm => {
-	if (typeof algorithm === "function") {
-		return new BulkUpdateDecorator(() => new algorithm());
-	}
-	switch (algorithm) {
-		// TODO add non-cryptographic algorithm here
-		case "debug":
-			return new DebugHash();
-		case "xxhash64":
-			if (createXXHash64 === undefined) {
-				createXXHash64 = __webpack_require__(35028);
-				if (BatchedHash === undefined) {
-					BatchedHash = __webpack_require__(59461);
-				}
-			}
-			return new BatchedHash(createXXHash64());
-		case "md4":
-			if (createMd4 === undefined) {
-				createMd4 = __webpack_require__(86884);
-				if (BatchedHash === undefined) {
-					BatchedHash = __webpack_require__(59461);
-				}
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.loadScript);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.loadScript);
+						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.hmrModuleData);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getUpdateManifestFilename);
+					});
 			}
-			return new BatchedHash(createMd4());
-		case "native-md4":
-			if (crypto === undefined) crypto = __webpack_require__(6113);
-			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
-		default:
-			if (crypto === undefined) crypto = __webpack_require__(6113);
-			return new BulkUpdateDecorator(
-				() => crypto.createHash(algorithm),
-				algorithm
-			);
+		);
 	}
-};
+}
+
+module.exports = JsonpChunkLoadingPlugin;
 
 
 /***/ }),
 
-/***/ 64518:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 84154:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
 */
 
 
 
-const util = __webpack_require__(73837);
-
-/** @type {Map<string, Function>} */
-const deprecationCache = new Map();
-
-/**
- * @typedef {Object} FakeHookMarker
- * @property {true} _fakeHook it's a fake hook
- */
+const { SyncWaterfallHook } = __webpack_require__(6967);
+const Compilation = __webpack_require__(85720);
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const chunkHasJs = (__webpack_require__(89464).chunkHasJs);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
 
-/** @template T @typedef {T & FakeHookMarker} FakeHook<T> */
+/** @typedef {import("../Chunk")} Chunk */
 
 /**
- * @param {string} message deprecation message
- * @param {string} code deprecation code
- * @returns {Function} function to trigger deprecation
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
  */
-const createDeprecation = (message, code) => {
-	const cached = deprecationCache.get(message);
-	if (cached !== undefined) return cached;
-	const fn = util.deprecate(
-		() => {},
-		message,
-		"DEP_WEBPACK_DEPRECATION_" + code
-	);
-	deprecationCache.set(message, fn);
-	return fn;
-};
-
-const COPY_METHODS = [
-	"concat",
-	"entry",
-	"filter",
-	"find",
-	"findIndex",
-	"includes",
-	"indexOf",
-	"join",
-	"lastIndexOf",
-	"map",
-	"reduce",
-	"reduceRight",
-	"slice",
-	"some"
-];
 
-const DISABLED_METHODS = [
-	"copyWithin",
-	"entries",
-	"fill",
-	"keys",
-	"pop",
-	"reverse",
-	"shift",
-	"splice",
-	"sort",
-	"unshift"
-];
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
 
-/**
- * @param {any} set new set
- * @param {string} name property name
- * @returns {void}
- */
-exports.arrayToSetDeprecation = (set, name) => {
-	for (const method of COPY_METHODS) {
-		if (set[method]) continue;
-		const d = createDeprecation(
-			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
-			"ARRAY_TO_SET"
-		);
-		/**
-		 * @deprecated
-		 * @this {Set}
-		 * @returns {number} count
-		 */
-		set[method] = function () {
-			d();
-			const array = Array.from(this);
-			return Array.prototype[method].apply(array, arguments);
-		};
-	}
-	const dPush = createDeprecation(
-		`${name} was changed from Array to Set (using Array method 'push' is deprecated)`,
-		"ARRAY_TO_SET_PUSH"
-	);
-	const dLength = createDeprecation(
-		`${name} was changed from Array to Set (using Array property 'length' is deprecated)`,
-		"ARRAY_TO_SET_LENGTH"
-	);
-	const dIndexer = createDeprecation(
-		`${name} was changed from Array to Set (indexing Array is deprecated)`,
-		"ARRAY_TO_SET_INDEXER"
-	);
+class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @deprecated
-	 * @this {Set}
-	 * @returns {number} count
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
 	 */
-	set.push = function () {
-		dPush();
-		for (const item of Array.from(arguments)) {
-			this.add(item);
-		}
-		return this.size;
-	};
-	for (const method of DISABLED_METHODS) {
-		if (set[method]) continue;
-		set[method] = () => {
-			throw new Error(
-				`${name} was changed from Array to Set (using Array method '${method}' is not possible)`
-			);
-		};
-	}
-	const createIndexGetter = index => {
-		/**
-		 * @this {Set} a Set
-		 * @returns {any} the value at this location
-		 */
-		const fn = function () {
-			dIndexer();
-			let i = 0;
-			for (const item of this) {
-				if (i++ === index) return item;
-			}
-			return undefined;
-		};
-		return fn;
-	};
-	const defineIndexGetter = index => {
-		Object.defineProperty(set, index, {
-			get: createIndexGetter(index),
-			set(value) {
-				throw new Error(
-					`${name} was changed from Array to Set (indexing Array with write is not possible)`
-				);
-			}
-		});
-	};
-	defineIndexGetter(0);
-	let indexerDefined = 1;
-	Object.defineProperty(set, "length", {
-		get() {
-			dLength();
-			const length = this.size;
-			for (indexerDefined; indexerDefined < length + 1; indexerDefined++) {
-				defineIndexGetter(indexerDefined);
-			}
-			return length;
-		},
-		set(value) {
-			throw new Error(
-				`${name} was changed from Array to Set (writing to Array property 'length' is not possible)`
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
 			);
 		}
-	});
-	set[Symbol.isConcatSpreadable] = true;
-};
-
-exports.createArrayToSetDeprecationSet = name => {
-	let initialized = false;
-	class SetDeprecatedArray extends Set {
-		constructor(items) {
-			super(items);
-			if (!initialized) {
-				initialized = true;
-				exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
-			}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
 		}
+		return hooks;
 	}
-	return SetDeprecatedArray;
-};
 
-exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
-	const message = `${name} will be frozen in future, all modifications are deprecated.${
-		note && `\n${note}`
-	}`;
-	return new Proxy(obj, {
-		set: util.deprecate(
-			(target, property, value, receiver) =>
-				Reflect.set(target, property, value, receiver),
-			message,
-			code
-		),
-		defineProperty: util.deprecate(
-			(target, property, descriptor) =>
-				Reflect.defineProperty(target, property, descriptor),
-			message,
-			code
-		),
-		deleteProperty: util.deprecate(
-			(target, property) => Reflect.deleteProperty(target, property),
-			message,
-			code
-		),
-		setPrototypeOf: util.deprecate(
-			(target, proto) => Reflect.setPrototypeOf(target, proto),
-			message,
-			code
-		)
-	});
-};
+	constructor(runtimeRequirements) {
+		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
+	}
 
-/**
- * @template T
- * @param {T} obj object
- * @param {string} message deprecation message
- * @param {string} code deprecation code
- * @returns {T} object with property access deprecated
- */
-const deprecateAllProperties = (obj, message, code) => {
-	const newObj = {};
-	const descriptors = Object.getOwnPropertyDescriptors(obj);
-	for (const name of Object.keys(descriptors)) {
-		const descriptor = descriptors[name];
-		if (typeof descriptor.value === "function") {
-			Object.defineProperty(newObj, name, {
-				...descriptor,
-				value: util.deprecate(descriptor.value, message, code)
-			});
-		} else if (descriptor.get || descriptor.set) {
-			Object.defineProperty(newObj, name, {
-				...descriptor,
-				get: descriptor.get && util.deprecate(descriptor.get, message, code),
-				set: descriptor.set && util.deprecate(descriptor.set, message, code)
-			});
-		} else {
-			let value = descriptor.value;
-			Object.defineProperty(newObj, name, {
-				configurable: descriptor.configurable,
-				enumerable: descriptor.enumerable,
-				get: util.deprecate(() => value, message, code),
-				set: descriptor.writable
-					? util.deprecate(v => (value = v), message, code)
-					: undefined
-			});
-		}
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { chunkGraph, compilation, chunk } = this;
+		const {
+			runtimeTemplate,
+			outputOptions: {
+				chunkLoadingGlobal,
+				hotUpdateGlobal,
+				crossOriginLoading,
+				scriptType
+			}
+		} = compilation;
+		const globalObject = runtimeTemplate.globalObject;
+		const { linkPreload, linkPrefetch } =
+			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this._runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withCallback = this._runtimeRequirements.has(
+			RuntimeGlobals.chunkCallback
+		);
+		const withOnChunkLoad = this._runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const withHmr = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this._runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const withPrefetch = this._runtimeRequirements.has(
+			RuntimeGlobals.prefetchChunkHandlers
+		);
+		const withPreload = this._runtimeRequirements.has(
+			RuntimeGlobals.preloadChunkHandlers
+		);
+		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
+			chunkLoadingGlobal
+		)}]`;
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp`
+			: undefined;
+
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.j = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? Template.indent([
+										"// JSONP chunk loading for javascript",
+										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										'if(installedChunkData !== 0) { // 0 means "already installed".',
+										Template.indent([
+											"",
+											'// a Promise means "currently loading".',
+											"if(installedChunkData) {",
+											Template.indent([
+												"promises.push(installedChunkData[2]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasJsMatcher === true
+													? "if(true) { // all chunks have JS"
+													: `if(${hasJsMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
+														"resolve, reject"
+													)});`,
+													"promises.push(installedChunkData[2] = promise);",
+													"",
+													"// start chunk loading",
+													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+													"// create error before stack unwound to get useful stacktrace later",
+													"var error = new Error();",
+													`var loadingEnded = ${runtimeTemplate.basicFunction(
+														"event",
+														[
+															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
+															Template.indent([
+																"installedChunkData = installedChunks[chunkId];",
+																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
+																"if(installedChunkData) {",
+																Template.indent([
+																	"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+																	"var realSrc = event && event.target && event.target.src;",
+																	"error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+																	"error.name = 'ChunkLoadError';",
+																	"error.type = errorType;",
+																	"error.request = realSrc;",
+																	"installedChunkData[1](error);"
+																]),
+																"}"
+															]),
+															"}"
+														]
+													)};`,
+													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ])
+								: Template.indent(["installedChunks[chunkId] = 0;"])
+						)};`
+				  ])
+				: "// no chunk on demand loading",
+			"",
+			withPrefetch && hasJsMatcher !== false
+				? `${
+						RuntimeGlobals.prefetchChunkHandlers
+				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
+						`if((!${
+							RuntimeGlobals.hasOwnProperty
+						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
+							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
+						}) {`,
+						Template.indent([
+							"installedChunks[chunkId] = null;",
+							linkPrefetch.call(
+								Template.asString([
+									"var link = document.createElement('link');",
+									crossOriginLoading
+										? `link.crossOrigin = ${JSON.stringify(
+												crossOriginLoading
+										  )};`
+										: "",
+									`if (${RuntimeGlobals.scriptNonce}) {`,
+									Template.indent(
+										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+									),
+									"}",
+									'link.rel = "prefetch";',
+									'link.as = "script";',
+									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`
+								]),
+								chunk
+							),
+							"document.head.appendChild(link);"
+						]),
+						"}"
+				  ])};`
+				: "// no prefetching",
+			"",
+			withPreload && hasJsMatcher !== false
+				? `${
+						RuntimeGlobals.preloadChunkHandlers
+				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
+						`if((!${
+							RuntimeGlobals.hasOwnProperty
+						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
+							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
+						}) {`,
+						Template.indent([
+							"installedChunks[chunkId] = null;",
+							linkPreload.call(
+								Template.asString([
+									"var link = document.createElement('link');",
+									scriptType
+										? `link.type = ${JSON.stringify(scriptType)};`
+										: "",
+									"link.charset = 'utf-8';",
+									`if (${RuntimeGlobals.scriptNonce}) {`,
+									Template.indent(
+										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
+									),
+									"}",
+									'link.rel = "preload";',
+									'link.as = "script";',
+									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+									crossOriginLoading
+										? Template.asString([
+												"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
+												Template.indent(
+													`link.crossOrigin = ${JSON.stringify(
+														crossOriginLoading
+													)};`
+												),
+												"}"
+										  ])
+										: ""
+								]),
+								chunk
+							),
+							"document.head.appendChild(link);"
+						]),
+						"}"
+				  ])};`
+				: "// no preloaded",
+			"",
+			withHmr
+				? Template.asString([
+						"var currentUpdatedModulesList;",
+						"var waitingUpdateResolves = {};",
+						"function loadUpdateChunk(chunkId) {",
+						Template.indent([
+							`return new Promise(${runtimeTemplate.basicFunction(
+								"resolve, reject",
+								[
+									"waitingUpdateResolves[chunkId] = resolve;",
+									"// start update chunk loading",
+									`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
+									"// create error before stack unwound to get useful stacktrace later",
+									"var error = new Error();",
+									`var loadingEnded = ${runtimeTemplate.basicFunction("event", [
+										"if(waitingUpdateResolves[chunkId]) {",
+										Template.indent([
+											"waitingUpdateResolves[chunkId] = undefined",
+											"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
+											"var realSrc = event && event.target && event.target.src;",
+											"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+											"error.name = 'ChunkLoadError';",
+											"error.type = errorType;",
+											"error.request = realSrc;",
+											"reject(error);"
+										]),
+										"}"
+									])};`,
+									`${RuntimeGlobals.loadScript}(url, loadingEnded);`
+								]
+							)});`
+						]),
+						"}",
+						"",
+						`${globalObject}[${JSON.stringify(
+							hotUpdateGlobal
+						)}] = ${runtimeTemplate.basicFunction(
+							"chunkId, moreModules, runtime",
+							[
+								"for(var moduleId in moreModules) {",
+								Template.indent([
+									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+									Template.indent([
+										"currentUpdate[moduleId] = moreModules[moduleId];",
+										"if(currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);"
+									]),
+									"}"
+								]),
+								"}",
+								"if(runtime) currentUpdateRuntime.push(runtime);",
+								"if(waitingUpdateResolves[chunkId]) {",
+								Template.indent([
+									"waitingUpdateResolves[chunkId]();",
+									"waitingUpdateResolves[chunkId] = undefined;"
+								]),
+								"}"
+							]
+						)};`,
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "jsonp")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${
+							RuntimeGlobals.hmrDownloadManifest
+						} = ${runtimeTemplate.basicFunction("", [
+							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
+							`return fetch(${RuntimeGlobals.publicPath} + ${
+								RuntimeGlobals.getUpdateManifestFilename
+							}()).then(${runtimeTemplate.basicFunction("response", [
+								"if(response.status === 404) return; // no update available",
+								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
+								"return response.json();"
+							])});`
+						])};`
+				  ])
+				: "// no HMR manifest",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.j = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded",
+			"",
+			withCallback || withLoading
+				? Template.asString([
+						"// install a JSONP callback for chunk loading",
+						`var webpackJsonpCallback = ${runtimeTemplate.basicFunction(
+							"parentChunkLoadingFunction, data",
+							[
+								runtimeTemplate.destructureArray(
+									["chunkIds", "moreModules", "runtime"],
+									"data"
+								),
+								'// add "moreModules" to the modules object,',
+								'// then flag all "chunkIds" as loaded and fire callback',
+								"var moduleId, chunkId, i = 0;",
+								`if(chunkIds.some(${runtimeTemplate.returningFunction(
+									"installedChunks[id] !== 0",
+									"id"
+								)})) {`,
+								Template.indent([
+									"for(moduleId in moreModules) {",
+									Template.indent([
+										`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+										Template.indent(
+											`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+										),
+										"}"
+									]),
+									"}",
+									"if(runtime) var result = runtime(__webpack_require__);"
+								]),
+								"}",
+								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",
+								"for(;i < chunkIds.length; i++) {",
+								Template.indent([
+									"chunkId = chunkIds[i];",
+									`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+									Template.indent("installedChunks[chunkId][0]();"),
+									"}",
+									"installedChunks[chunkId] = 0;"
+								]),
+								"}",
+								withOnChunkLoad
+									? `return ${RuntimeGlobals.onChunksLoaded}(result);`
+									: ""
+							]
+						)}`,
+						"",
+						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+						"chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));",
+						"chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));"
+				  ])
+				: "// no jsonp function"
+		]);
 	}
-	return /** @type {T} */ (newObj);
-};
-exports.deprecateAllProperties = deprecateAllProperties;
+}
 
-/**
- * @template T
- * @param {T} fakeHook fake hook implementation
- * @param {string=} message deprecation message (not deprecated when unset)
- * @param {string=} code deprecation code (not deprecated when unset)
- * @returns {FakeHook<T>} fake hook which redirects
- */
-exports.createFakeHook = (fakeHook, message, code) => {
-	if (message && code) {
-		fakeHook = deprecateAllProperties(fakeHook, message, code);
-	}
-	return Object.freeze(
-		Object.assign(fakeHook, { _fakeHook: /** @type {true} */ (true) })
-	);
-};
+module.exports = JsonpChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 59836:
-/***/ (function(module) {
+/***/ 4607:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -132563,539 +132952,593 @@ exports.createFakeHook = (fakeHook, message, code) => {
 
 
 
-// Simulations show these probabilities for a single change
-// 93.1% that one group is invalidated
-// 4.8% that two groups are invalidated
-// 1.1% that 3 groups are invalidated
-// 0.1% that 4 or more groups are invalidated
-//
-// And these for removing/adding 10 lexically adjacent files
-// 64.5% that one group is invalidated
-// 24.8% that two groups are invalidated
-// 7.8% that 3 groups are invalidated
-// 2.7% that 4 or more groups are invalidated
-//
-// And these for removing/adding 3 random files
-// 0% that one group is invalidated
-// 3.7% that two groups are invalidated
-// 80.8% that 3 groups are invalidated
-// 12.3% that 4 groups are invalidated
-// 3.2% that 5 or more groups are invalidated
+const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
 
-/**
- *
- * @param {string} a key
- * @param {string} b key
- * @returns {number} the similarity as number
- */
-const similarity = (a, b) => {
-	const l = Math.min(a.length, b.length);
-	let dist = 0;
-	for (let i = 0; i < l; i++) {
-		const ca = a.charCodeAt(i);
-		const cb = b.charCodeAt(i);
-		dist += Math.max(0, 10 - Math.abs(ca - cb));
-	}
-	return dist;
-};
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
 
-/**
- * @param {string} a key
- * @param {string} b key
- * @param {Set<string>} usedNames set of already used names
- * @returns {string} the common part and a single char for the difference
- */
-const getName = (a, b, usedNames) => {
-	const l = Math.min(a.length, b.length);
-	let i = 0;
-	while (i < l) {
-		if (a.charCodeAt(i) !== b.charCodeAt(i)) {
-			i++;
-			break;
-		}
-		i++;
-	}
-	while (i < l) {
-		const name = a.slice(0, i);
-		const lowerName = name.toLowerCase();
-		if (!usedNames.has(lowerName)) {
-			usedNames.add(lowerName);
-			return name;
-		}
-		i++;
+class JsonpTemplatePlugin {
+	/**
+	 * @deprecated use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpChunkLoadingRuntimeModule.JsonpCompilationPluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		return JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
 	}
-	// names always contain a hash, so this is always unique
-	// we don't need to check usedNames nor add it
-	return a;
-};
 
-/**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
- * @returns {void}
- */
-const addSizeTo = (total, size) => {
-	for (const key of Object.keys(size)) {
-		total[key] = (total[key] || 0) + size[key];
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.options.output.chunkLoading = "jsonp";
+		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin("jsonp").apply(compiler);
 	}
-};
+}
 
-/**
- * @param {Record<string, number>} total total size
- * @param {Record<string, number>} size single size
- * @returns {void}
- */
-const subtractSizeFrom = (total, size) => {
-	for (const key of Object.keys(size)) {
-		total[key] -= size[key];
-	}
-};
+module.exports = JsonpTemplatePlugin;
 
-/**
- * @param {Iterable<Node>} nodes some nodes
- * @returns {Record<string, number>} total size
- */
-const sumSize = nodes => {
-	const sum = Object.create(null);
-	for (const node of nodes) {
-		addSizeTo(sum, node.size);
-	}
-	return sum;
-};
 
-const isTooBig = (size, maxSize) => {
-	for (const key of Object.keys(size)) {
-		const s = size[key];
-		if (s === 0) continue;
-		const maxSizeValue = maxSize[key];
-		if (typeof maxSizeValue === "number") {
-			if (s > maxSizeValue) return true;
-		}
-	}
-	return false;
-};
+/***/ }),
 
-const isTooSmall = (size, minSize) => {
-	for (const key of Object.keys(size)) {
-		const s = size[key];
-		if (s === 0) continue;
-		const minSizeValue = minSize[key];
-		if (typeof minSizeValue === "number") {
-			if (s < minSizeValue) return true;
-		}
-	}
-	return false;
-};
+/***/ 36243:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-const getTooSmallTypes = (size, minSize) => {
-	const types = new Set();
-	for (const key of Object.keys(size)) {
-		const s = size[key];
-		if (s === 0) continue;
-		const minSizeValue = minSize[key];
-		if (typeof minSizeValue === "number") {
-			if (s < minSizeValue) types.add(key);
-		}
-	}
-	return types;
-};
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-const getNumberOfMatchingSizeTypes = (size, types) => {
-	let i = 0;
-	for (const key of Object.keys(size)) {
-		if (size[key] !== 0 && types.has(key)) i++;
-	}
-	return i;
-};
 
-const selectiveSizeSum = (size, types) => {
-	let sum = 0;
-	for (const key of Object.keys(size)) {
-		if (size[key] !== 0 && types.has(key)) sum += size[key];
-	}
-	return sum;
-};
+
+const util = __webpack_require__(73837);
+const webpackOptionsSchemaCheck = __webpack_require__(10382);
+const webpackOptionsSchema = __webpack_require__(73342);
+const Compiler = __webpack_require__(70845);
+const MultiCompiler = __webpack_require__(33370);
+const WebpackOptionsApply = __webpack_require__(88422);
+const {
+	applyWebpackOptionsDefaults,
+	applyWebpackOptionsBaseDefaults
+} = __webpack_require__(92988);
+const { getNormalizedWebpackOptions } = __webpack_require__(26693);
+const NodeEnvironmentPlugin = __webpack_require__(7553);
+const memoize = __webpack_require__(78676);
+
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("./Compiler").WatchOptions} WatchOptions */
+/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
+/** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./Stats")} Stats */
+
+const getValidateSchema = memoize(() => __webpack_require__(12047));
 
 /**
  * @template T
+ * @callback Callback
+ * @param {Error=} err
+ * @param {T=} stats
+ * @returns {void}
  */
-class Node {
-	/**
-	 * @param {T} item item
-	 * @param {string} key key
-	 * @param {Record<string, number>} size size
-	 */
-	constructor(item, key, size) {
-		this.item = item;
-		this.key = key;
-		this.size = size;
-	}
-}
 
 /**
- * @template T
+ * @param {ReadonlyArray<WebpackOptions>} childOptions options array
+ * @param {MultiCompilerOptions} options options
+ * @returns {MultiCompiler} a multi-compiler
  */
-class Group {
-	/**
-	 * @param {Node<T>[]} nodes nodes
-	 * @param {number[]} similarities similarities between the nodes (length = nodes.length - 1)
-	 * @param {Record<string, number>=} size size of the group
-	 */
-	constructor(nodes, similarities, size) {
-		this.nodes = nodes;
-		this.similarities = similarities;
-		this.size = size || sumSize(nodes);
-		/** @type {string} */
-		this.key = undefined;
-	}
-
-	/**
-	 * @param {function(Node): boolean} filter filter function
-	 * @returns {Node[]} removed nodes
-	 */
-	popNodes(filter) {
-		const newNodes = [];
-		const newSimilarities = [];
-		const resultNodes = [];
-		let lastNode;
-		for (let i = 0; i < this.nodes.length; i++) {
-			const node = this.nodes[i];
-			if (filter(node)) {
-				resultNodes.push(node);
-			} else {
-				if (newNodes.length > 0) {
-					newSimilarities.push(
-						lastNode === this.nodes[i - 1]
-							? this.similarities[i - 1]
-							: similarity(lastNode.key, node.key)
-					);
-				}
-				newNodes.push(node);
-				lastNode = node;
-			}
+const createMultiCompiler = (childOptions, options) => {
+	const compilers = childOptions.map(options => createCompiler(options));
+	const compiler = new MultiCompiler(compilers, options);
+	for (const childCompiler of compilers) {
+		if (childCompiler.options.dependencies) {
+			compiler.setDependencies(
+				childCompiler,
+				childCompiler.options.dependencies
+			);
 		}
-		if (resultNodes.length === this.nodes.length) return undefined;
-		this.nodes = newNodes;
-		this.similarities = newSimilarities;
-		this.size = sumSize(newNodes);
-		return resultNodes;
 	}
-}
+	return compiler;
+};
 
 /**
- * @param {Iterable<Node>} nodes nodes
- * @returns {number[]} similarities
+ * @param {WebpackOptions} rawOptions options object
+ * @returns {Compiler} a compiler
  */
-const getSimilarities = nodes => {
-	// calculate similarities between lexically adjacent nodes
-	/** @type {number[]} */
-	const similarities = [];
-	let last = undefined;
-	for (const node of nodes) {
-		if (last !== undefined) {
-			similarities.push(similarity(last.key, node.key));
+const createCompiler = rawOptions => {
+	const options = getNormalizedWebpackOptions(rawOptions);
+	applyWebpackOptionsBaseDefaults(options);
+	const compiler = new Compiler(options.context, options);
+	new NodeEnvironmentPlugin({
+		infrastructureLogging: options.infrastructureLogging
+	}).apply(compiler);
+	if (Array.isArray(options.plugins)) {
+		for (const plugin of options.plugins) {
+			if (typeof plugin === "function") {
+				plugin.call(compiler, compiler);
+			} else {
+				plugin.apply(compiler);
+			}
 		}
-		last = node;
 	}
-	return similarities;
+	applyWebpackOptionsDefaults(options);
+	compiler.hooks.environment.call();
+	compiler.hooks.afterEnvironment.call();
+	new WebpackOptionsApply().process(options, compiler);
+	compiler.hooks.initialize.call();
+	return compiler;
 };
 
 /**
- * @template T
- * @typedef {Object} GroupedItems<T>
- * @property {string} key
- * @property {T[]} items
- * @property {Record<string, number>} size
- */
-
-/**
- * @template T
- * @typedef {Object} Options
- * @property {Record<string, number>} maxSize maximum size of a group
- * @property {Record<string, number>} minSize minimum size of a group (preferred over maximum size)
- * @property {Iterable<T>} items a list of items
- * @property {function(T): Record<string, number>} getSize function to get size of an item
- * @property {function(T): string} getKey function to get the key of an item
+ * @callback WebpackFunctionSingle
+ * @param {WebpackOptions} options options object
+ * @param {Callback<Stats>=} callback callback
+ * @returns {Compiler} the compiler object
  */
 
 /**
- * @template T
- * @param {Options<T>} options options object
- * @returns {GroupedItems<T>[]} grouped items
+ * @callback WebpackFunctionMulti
+ * @param {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} options options objects
+ * @param {Callback<MultiStats>=} callback callback
+ * @returns {MultiCompiler} the multi compiler object
  */
-module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
-	/** @type {Group<T>[]} */
-	const result = [];
-
-	const nodes = Array.from(
-		items,
-		item => new Node(item, getKey(item), getSize(item))
-	);
-
-	/** @type {Node<T>[]} */
-	const initialNodes = [];
 
-	// lexically ordering of keys
-	nodes.sort((a, b) => {
-		if (a.key < b.key) return -1;
-		if (a.key > b.key) return 1;
-		return 0;
-	});
+const asArray = options =>
+	Array.isArray(options) ? Array.from(options) : [options];
 
-	// return nodes bigger than maxSize directly as group
-	// But make sure that minSize is not violated
-	for (const node of nodes) {
-		if (isTooBig(node.size, maxSize) && !isTooSmall(node.size, minSize)) {
-			result.push(new Group([node], []));
+const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
+	/**
+	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
+	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
+	 * @returns {Compiler | MultiCompiler}
+	 */
+	(options, callback) => {
+		const create = () => {
+			if (!asArray(options).every(webpackOptionsSchemaCheck)) {
+				getValidateSchema()(webpackOptionsSchema, options);
+				util.deprecate(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
+			}
+			/** @type {MultiCompiler|Compiler} */
+			let compiler;
+			let watch = false;
+			/** @type {WatchOptions|WatchOptions[]} */
+			let watchOptions;
+			if (Array.isArray(options)) {
+				/** @type {MultiCompiler} */
+				compiler = createMultiCompiler(
+					options,
+					/** @type {MultiCompilerOptions} */ (options)
+				);
+				watch = options.some(options => options.watch);
+				watchOptions = options.map(options => options.watchOptions || {});
+			} else {
+				const webpackOptions = /** @type {WebpackOptions} */ (options);
+				/** @type {Compiler} */
+				compiler = createCompiler(webpackOptions);
+				watch = webpackOptions.watch;
+				watchOptions = webpackOptions.watchOptions || {};
+			}
+			return { compiler, watch, watchOptions };
+		};
+		if (callback) {
+			try {
+				const { compiler, watch, watchOptions } = create();
+				if (watch) {
+					compiler.watch(watchOptions, callback);
+				} else {
+					compiler.run((err, stats) => {
+						compiler.close(err2 => {
+							callback(err || err2, stats);
+						});
+					});
+				}
+				return compiler;
+			} catch (err) {
+				process.nextTick(() => callback(err));
+				return null;
+			}
 		} else {
-			initialNodes.push(node);
+			const { compiler, watch } = create();
+			if (watch) {
+				util.deprecate(
+					() => {},
+					"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
+					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
+				)();
+			}
+			return compiler;
 		}
 	}
+);
 
-	if (initialNodes.length > 0) {
-		const initialGroup = new Group(initialNodes, getSimilarities(initialNodes));
+module.exports = webpack;
 
-		const removeProblematicNodes = (group, consideredSize = group.size) => {
-			const problemTypes = getTooSmallTypes(consideredSize, minSize);
-			if (problemTypes.size > 0) {
-				// We hit an edge case where the working set is already smaller than minSize
-				// We merge problematic nodes with the smallest result node to keep minSize intact
-				const problemNodes = group.popNodes(
-					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
-				);
-				if (problemNodes === undefined) return false;
-				// Only merge it with result nodes that have the problematic size type
-				const possibleResultGroups = result.filter(
-					n => getNumberOfMatchingSizeTypes(n.size, problemTypes) > 0
-				);
-				if (possibleResultGroups.length > 0) {
-					const bestGroup = possibleResultGroups.reduce((min, group) => {
-						const minMatches = getNumberOfMatchingSizeTypes(min, problemTypes);
-						const groupMatches = getNumberOfMatchingSizeTypes(
-							group,
-							problemTypes
-						);
-						if (minMatches !== groupMatches)
-							return minMatches < groupMatches ? group : min;
-						if (
-							selectiveSizeSum(min.size, problemTypes) >
-							selectiveSizeSum(group.size, problemTypes)
-						)
-							return group;
-						return min;
+
+/***/ }),
+
+/***/ 54182:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const RuntimeGlobals = __webpack_require__(16475);
+const StartupChunkDependenciesPlugin = __webpack_require__(22339);
+const ImportScriptsChunkLoadingRuntimeModule = __webpack_require__(96952);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class ImportScriptsChunkLoadingPlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		new StartupChunkDependenciesPlugin({
+			chunkLoading: "import-scripts",
+			asyncChunkLoading: true
+		}).apply(compiler);
+		compiler.hooks.thisCompilation.tap(
+			"ImportScriptsChunkLoadingPlugin",
+			compilation => {
+				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				const isEnabledForChunk = chunk => {
+					const options = chunk.getEntryOptions();
+					const chunkLoading =
+						options && options.chunkLoading !== undefined
+							? options.chunkLoading
+							: globalChunkLoading;
+					return chunkLoading === "import-scripts";
+				};
+				const onceForChunkSet = new WeakSet();
+				const handler = (chunk, set) => {
+					if (onceForChunkSet.has(chunk)) return;
+					onceForChunkSet.add(chunk);
+					if (!isEnabledForChunk(chunk)) return;
+					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					set.add(RuntimeGlobals.hasOwnProperty);
+					if (withCreateScriptUrl) {
+						set.add(RuntimeGlobals.createScriptUrl);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
+					);
+				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.baseURI)
+					.tap("ImportScriptsChunkLoadingPlugin", handler);
+
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.ensureChunkHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
 					});
-					for (const node of problemNodes) bestGroup.nodes.push(node);
-					bestGroup.nodes.sort((a, b) => {
-						if (a.key < b.key) return -1;
-						if (a.key > b.key) return 1;
-						return 0;
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
+					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+						set.add(RuntimeGlobals.moduleCache);
+						set.add(RuntimeGlobals.hmrModuleData);
+						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+					});
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hmrDownloadManifest)
+					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
+						if (!isEnabledForChunk(chunk)) return;
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getUpdateManifestFilename);
 					});
-				} else {
-					// There are no other nodes with the same size types
-					// We create a new group and have to accept that it's smaller than minSize
-					result.push(new Group(problemNodes, null));
-				}
-				return true;
-			} else {
-				return false;
 			}
-		};
+		);
+	}
+}
+module.exports = ImportScriptsChunkLoadingPlugin;
 
-		if (initialGroup.nodes.length > 0) {
-			const queue = [initialGroup];
 
-			while (queue.length) {
-				const group = queue.pop();
-				// only groups bigger than maxSize need to be splitted
-				if (!isTooBig(group.size, maxSize)) {
-					result.push(group);
-					continue;
-				}
-				// If the group is already too small
-				// we try to work only with the unproblematic nodes
-				if (removeProblematicNodes(group)) {
-					// This changed something, so we try this group again
-					queue.push(group);
-					continue;
-				}
+/***/ }),
 
-				// find unsplittable area from left and right
-				// going minSize from left and right
-				// at least one node need to be included otherwise we get stuck
-				let left = 1;
-				let leftSize = Object.create(null);
-				addSizeTo(leftSize, group.nodes[0].size);
-				while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
-					addSizeTo(leftSize, group.nodes[left].size);
-					left++;
-				}
-				let right = group.nodes.length - 2;
-				let rightSize = Object.create(null);
-				addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
-				while (right >= 0 && isTooSmall(rightSize, minSize)) {
-					addSizeTo(rightSize, group.nodes[right].size);
-					right--;
-				}
+/***/ 96952:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-				//      left v   v right
-				// [ O O O ] O O O [ O O O ]
-				// ^^^^^^^^^ leftSize
-				//       rightSize ^^^^^^^^^
-				// leftSize > minSize
-				// rightSize > minSize
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
 
-				// Perfect split: [ O O O ] [ O O O ]
-				//                right === left - 1
 
-				if (left - 1 > right) {
-					// We try to remove some problematic nodes to "fix" that
-					let prevSize;
-					if (right < group.nodes.length - left) {
-						subtractSizeFrom(rightSize, group.nodes[right + 1].size);
-						prevSize = rightSize;
-					} else {
-						subtractSizeFrom(leftSize, group.nodes[left - 1].size);
-						prevSize = leftSize;
-					}
-					if (removeProblematicNodes(group, prevSize)) {
-						// This changed something, so we try this group again
-						queue.push(group);
-						continue;
-					}
-					// can't split group while holding minSize
-					// because minSize is preferred of maxSize we return
-					// the problematic nodes as result here even while it's too big
-					// To avoid this make sure maxSize > minSize * 3
-					result.push(group);
-					continue;
-				}
-				if (left <= right) {
-					// when there is a area between left and right
-					// we look for best split point
-					// we split at the minimum similarity
-					// here key space is separated the most
-					// But we also need to make sure to not create too small groups
-					let best = -1;
-					let bestSimilarity = Infinity;
-					let pos = left;
-					let rightSize = sumSize(group.nodes.slice(pos));
 
-					//       pos v   v right
-					// [ O O O ] O O O [ O O O ]
-					// ^^^^^^^^^ leftSize
-					// rightSize ^^^^^^^^^^^^^^^
+const RuntimeGlobals = __webpack_require__(16475);
+const RuntimeModule = __webpack_require__(16963);
+const Template = __webpack_require__(1626);
+const {
+	getChunkFilenameTemplate,
+	chunkHasJs
+} = __webpack_require__(89464);
+const { getInitialChunkIds } = __webpack_require__(98124);
+const compileBooleanMatcher = __webpack_require__(29404);
+const { getUndoPath } = __webpack_require__(82186);
 
-					while (pos <= right + 1) {
-						const similarity = group.similarities[pos - 1];
-						if (
-							similarity < bestSimilarity &&
-							!isTooSmall(leftSize, minSize) &&
-							!isTooSmall(rightSize, minSize)
-						) {
-							best = pos;
-							bestSimilarity = similarity;
-						}
-						addSizeTo(leftSize, group.nodes[pos].size);
-						subtractSizeFrom(rightSize, group.nodes[pos].size);
-						pos++;
-					}
-					if (best < 0) {
-						// This can't happen
-						// but if that assumption is wrong
-						// fallback to a big group
-						result.push(group);
-						continue;
-					}
-					left = best;
-					right = best - 1;
-				}
+class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
+	constructor(runtimeRequirements, withCreateScriptUrl) {
+		super("importScripts chunk loading", RuntimeModule.STAGE_ATTACH);
+		this.runtimeRequirements = runtimeRequirements;
+		this._withCreateScriptUrl = withCreateScriptUrl;
+	}
 
-				// create two new groups for left and right area
-				// and queue them up
-				const rightNodes = [group.nodes[right + 1]];
-				/** @type {number[]} */
-				const rightSimilarities = [];
-				for (let i = right + 2; i < group.nodes.length; i++) {
-					rightSimilarities.push(group.similarities[i - 1]);
-					rightNodes.push(group.nodes[i]);
-				}
-				queue.push(new Group(rightNodes, rightSimilarities));
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const {
+			chunk,
+			chunkGraph,
+			compilation: {
+				runtimeTemplate,
+				outputOptions: { chunkLoadingGlobal, hotUpdateGlobal }
+			},
+			_withCreateScriptUrl: withCreateScriptUrl
+		} = this;
+		const globalObject = runtimeTemplate.globalObject;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withHmr = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHmrManifest = this.runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadManifest
+		);
+		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
+			chunkLoadingGlobal
+		)}]`;
+		const hasJsMatcher = compileBooleanMatcher(
+			chunkGraph.getChunkConditionMap(chunk, chunkHasJs)
+		);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-				const leftNodes = [group.nodes[0]];
-				/** @type {number[]} */
-				const leftSimilarities = [];
-				for (let i = 1; i < left; i++) {
-					leftSimilarities.push(group.similarities[i - 1]);
-					leftNodes.push(group.nodes[i]);
-				}
-				queue.push(new Group(leftNodes, leftSimilarities));
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
 			}
-		}
-	}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			false
+		);
 
-	// lexically ordering
-	result.sort((a, b) => {
-		if (a.nodes[0].key < b.nodes[0].key) return -1;
-		if (a.nodes[0].key > b.nodes[0].key) return 1;
-		return 0;
-	});
+		const stateExpression = withHmr
+			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_importScripts`
+			: undefined;
 
-	// give every group a name
-	const usedNames = new Set();
-	for (let i = 0; i < result.length; i++) {
-		const group = result[i];
-		if (group.nodes.length === 1) {
-			group.key = group.nodes[0].key;
-		} else {
-			const first = group.nodes[0];
-			const last = group.nodes[group.nodes.length - 1];
-			const name = getName(first.key, last.key, usedNames);
-			group.key = name;
-		}
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = self.location + ${JSON.stringify(
+							rootOutputDir ? "/../" + rootOutputDir : ""
+						)};`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded chunks",
+			'// "1" means "already loaded"',
+			`var installedChunks = ${
+				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
+			}{`,
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading
+				? Template.asString([
+						"// importScripts chunk loading",
+						`var installChunk = ${runtimeTemplate.basicFunction("data", [
+							runtimeTemplate.destructureArray(
+								["chunkIds", "moreModules", "runtime"],
+								"data"
+							),
+							"for(var moduleId in moreModules) {",
+							Template.indent([
+								`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+								Template.indent(
+									`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
+								),
+								"}"
+							]),
+							"}",
+							"if(runtime) runtime(__webpack_require__);",
+							"while(chunkIds.length)",
+							Template.indent("installedChunks[chunkIds.pop()] = 1;"),
+							"parentChunkLoadingFunction(data);"
+						])};`
+				  ])
+				: "// no chunk install function needed",
+			withLoading
+				? Template.asString([
+						`${fn}.i = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? [
+										'// "1" is the signal for "already loaded"',
+										"if(!installedChunks[chunkId]) {",
+										Template.indent([
+											hasJsMatcher === true
+												? "if(true) { // all chunks have JS"
+												: `if(${hasJsMatcher("chunkId")}) {`,
+											Template.indent(
+												`importScripts(${
+													withCreateScriptUrl
+														? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`
+														: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId)`
+												});`
+											),
+											"}"
+										]),
+										"}"
+								  ]
+								: "installedChunks[chunkId] = 1;"
+						)};`,
+						"",
+						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
+						"var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);",
+						"chunkLoadingGlobal.push = installChunk;"
+				  ])
+				: "// no chunk loading",
+			"",
+			withHmr
+				? Template.asString([
+						"function loadUpdateChunk(chunkId, updatedModulesList) {",
+						Template.indent([
+							"var success = false;",
+							`${globalObject}[${JSON.stringify(
+								hotUpdateGlobal
+							)}] = ${runtimeTemplate.basicFunction("_, moreModules, runtime", [
+								"for(var moduleId in moreModules) {",
+								Template.indent([
+									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
+									Template.indent([
+										"currentUpdate[moduleId] = moreModules[moduleId];",
+										"if(updatedModulesList) updatedModulesList.push(moduleId);"
+									]),
+									"}"
+								]),
+								"}",
+								"if(runtime) currentUpdateRuntime.push(runtime);",
+								"success = true;"
+							])};`,
+							"// start update chunk loading",
+							`importScripts(${
+								withCreateScriptUrl
+									? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId))`
+									: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId)`
+							});`,
+							'if(!success) throw new Error("Loading update chunk failed for unknown reason");'
+						]),
+						"}",
+						"",
+						Template.getFunctionContent(
+							require('./JavascriptHotModuleReplacement.runtime.js')
+						)
+							.replace(/\$key\$/g, "importScrips")
+							.replace(/\$installedChunks\$/g, "installedChunks")
+							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
+							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
+							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
+							.replace(
+								/\$ensureChunkHandlers\$/g,
+								RuntimeGlobals.ensureChunkHandlers
+							)
+							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
+							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
+							.replace(
+								/\$hmrDownloadUpdateHandlers\$/g,
+								RuntimeGlobals.hmrDownloadUpdateHandlers
+							)
+							.replace(
+								/\$hmrInvalidateModuleHandlers\$/g,
+								RuntimeGlobals.hmrInvalidateModuleHandlers
+							)
+				  ])
+				: "// no HMR",
+			"",
+			withHmrManifest
+				? Template.asString([
+						`${
+							RuntimeGlobals.hmrDownloadManifest
+						} = ${runtimeTemplate.basicFunction("", [
+							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
+							`return fetch(${RuntimeGlobals.publicPath} + ${
+								RuntimeGlobals.getUpdateManifestFilename
+							}()).then(${runtimeTemplate.basicFunction("response", [
+								"if(response.status === 404) return; // no update available",
+								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
+								"return response.json();"
+							])});`
+						])};`
+				  ])
+				: "// no HMR manifest"
+		]);
 	}
+}
 
-	// return the results
-	return result.map(group => {
-		/** @type {GroupedItems} */
-		return {
-			key: group.key,
-			items: group.nodes.map(node => node.item),
-			size: group.size
-		};
-	});
-};
+module.exports = ImportScriptsChunkLoadingRuntimeModule;
 
 
 /***/ }),
 
-/***/ 11850:
-/***/ (function(module) {
+/***/ 68693:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Sam Chen @chenxsan
+	Author Tobias Koppers @sokra
 */
 
 
 
-/**
- * @param {string} urlAndGlobal the script request
- * @returns {string[]} script url and its global variable
- */
-module.exports = function extractUrlAndGlobal(urlAndGlobal) {
-	const index = urlAndGlobal.indexOf("@");
-	if (index <= 0 || index === urlAndGlobal.length - 1) {
-		throw new Error(`Invalid request "${urlAndGlobal}"`);
+const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
+const EnableChunkLoadingPlugin = __webpack_require__(61291);
+
+/** @typedef {import("../Compiler")} Compiler */
+
+class WebWorkerTemplatePlugin {
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.options.output.chunkLoading = "import-scripts";
+		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
+		new EnableChunkLoadingPlugin("import-scripts").apply(compiler);
 	}
-	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
-};
+}
+module.exports = WebWorkerTemplatePlugin;
 
 
 /***/ }),
 
-/***/ 6261:
-/***/ (function(module) {
+/***/ 14819:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -133105,234 +133548,269 @@ module.exports = function extractUrlAndGlobal(urlAndGlobal) {
 
 
 
-const NO_MARKER = 0;
-const IN_PROGRESS_MARKER = 1;
-const DONE_MARKER = 2;
-const DONE_MAYBE_ROOT_CYCLE_MARKER = 3;
-const DONE_AND_ROOT_MARKER = 4;
+const DescriptionFileUtils = __webpack_require__(25424);
+const getInnerRequest = __webpack_require__(47956);
 
-/**
- * @template T
- */
-class Node {
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class AliasFieldPlugin {
 	/**
-	 * @param {T} item the value of the node
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | Array<string>} field field
+	 * @param {string | ResolveStepHook} target target
 	 */
-	constructor(item) {
-		this.item = item;
-		/** @type {Set<Node<T>>} */
-		this.dependencies = new Set();
-		this.marker = NO_MARKER;
-		/** @type {Cycle<T> | undefined} */
-		this.cycle = undefined;
-		this.incoming = 0;
-	}
-}
-
-/**
- * @template T
- */
-class Cycle {
-	constructor() {
-		/** @type {Set<Node<T>>} */
-		this.nodes = new Set();
+	constructor(source, field, target) {
+		this.source = source;
+		this.field = field;
+		this.target = target;
 	}
-}
 
-/**
- * @template T
- * @typedef {Object} StackEntry
- * @property {Node<T>} node
- * @property {Node<T>[]} openEdges
- */
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => {
+				if (!request.descriptionFileData) return callback();
+				const innerRequest = getInnerRequest(resolver, request);
+				if (!innerRequest) return callback();
+				const fieldData = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.field
+				);
+				if (fieldData === null || typeof fieldData !== "object") {
+					if (resolveContext.log)
+						resolveContext.log(
+							"Field '" +
+								this.field +
+								"' doesn't contain a valid alias configuration"
+						);
+					return callback();
+				}
+				const data1 = fieldData[innerRequest];
+				const data2 = fieldData[innerRequest.replace(/^\.\//, "")];
+				const data = typeof data1 !== "undefined" ? data1 : data2;
+				if (data === innerRequest) return callback();
+				if (data === undefined) return callback();
+				if (data === false) {
+					/** @type {ResolveRequest} */
+					const ignoreObj = {
+						...request,
+						path: false
+					};
+					return callback(null, ignoreObj);
+				}
+				const obj = {
+					...request,
+					path: request.descriptionFileRoot,
+					request: data,
+					fullySpecified: false
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"aliased from description file " +
+						request.descriptionFilePath +
+						" with mapping '" +
+						innerRequest +
+						"' to '" +
+						data +
+						"'",
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
 
-/**
- * @template T
- * @param {Iterable<T>} items list of items
- * @param {function(T): Iterable<T>} getDependencies function to get dependencies of an item (items that are not in list are ignored)
- * @returns {Iterable<T>} graph roots of the items
- */
-module.exports = (items, getDependencies) => {
-	/** @type {Map<T, Node<T>>} */
-	const itemToNode = new Map();
-	for (const item of items) {
-		const node = new Node(item);
-		itemToNode.set(item, node);
+						// Don't allow other aliasing or raw request
+						if (result === undefined) return callback(null, null);
+						callback(null, result);
+					}
+				);
+			});
 	}
+};
 
-	// early exit when there is only a single item
-	if (itemToNode.size <= 1) return items;
 
-	// grab all the dependencies
-	for (const node of itemToNode.values()) {
-		for (const dep of getDependencies(node.item)) {
-			const depNode = itemToNode.get(dep);
-			if (depNode !== undefined) {
-				node.dependencies.add(depNode);
-			}
-		}
-	}
+/***/ }),
 
-	// Set of current root modules
-	// items will be removed if a new reference to it has been found
-	/** @type {Set<Node<T>>} */
-	const roots = new Set();
+/***/ 63676:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-	// Set of current cycles without references to it
-	// cycles will be removed if a new reference to it has been found
-	// that is not part of the cycle
-	/** @type {Set<Cycle<T>>} */
-	const rootCycles = new Set();
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-	// For all non-marked nodes
-	for (const selectedNode of itemToNode.values()) {
-		if (selectedNode.marker === NO_MARKER) {
-			// deep-walk all referenced modules
-			// in a non-recursive way
 
-			// start by entering the selected node
-			selectedNode.marker = IN_PROGRESS_MARKER;
 
-			// keep a stack to avoid recursive walk
-			/** @type {StackEntry<T>[]} */
-			const stack = [
-				{
-					node: selectedNode,
-					openEdges: Array.from(selectedNode.dependencies)
-				}
-			];
+const forEachBail = __webpack_require__(78565);
 
-			// process the top item until stack is empty
-			while (stack.length > 0) {
-				const topOfStack = stack[stack.length - 1];
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{alias: string|Array<string>|false, name: string, onlyModule?: boolean}} AliasOption */
 
-				// Are there still edges unprocessed in the current node?
-				if (topOfStack.openEdges.length > 0) {
-					// Process one dependency
-					const dependency = topOfStack.openEdges.pop();
-					switch (dependency.marker) {
-						case NO_MARKER:
-							// dependency has not be visited yet
-							// mark it as in-progress and recurse
-							stack.push({
-								node: dependency,
-								openEdges: Array.from(dependency.dependencies)
-							});
-							dependency.marker = IN_PROGRESS_MARKER;
-							break;
-						case IN_PROGRESS_MARKER: {
-							// It's a in-progress cycle
-							let cycle = dependency.cycle;
-							if (!cycle) {
-								cycle = new Cycle();
-								cycle.nodes.add(dependency);
-								dependency.cycle = cycle;
-							}
-							// set cycle property for each node in the cycle
-							// if nodes are already part of a cycle
-							// we merge the cycles to a shared cycle
-							for (
-								let i = stack.length - 1;
-								stack[i].node !== dependency;
-								i--
-							) {
-								const node = stack[i].node;
-								if (node.cycle) {
-									if (node.cycle !== cycle) {
-										// merge cycles
-										for (const cycleNode of node.cycle.nodes) {
-											cycleNode.cycle = cycle;
-											cycle.nodes.add(cycleNode);
+module.exports = class AliasPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {AliasOption | Array<AliasOption>} options options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, options, target) {
+		this.source = source;
+		this.options = Array.isArray(options) ? options : [options];
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AliasPlugin", (request, resolveContext, callback) => {
+				const innerRequest = request.request || request.path;
+				if (!innerRequest) return callback();
+				forEachBail(
+					this.options,
+					(item, callback) => {
+						let shouldStop = false;
+						if (
+							innerRequest === item.name ||
+							(!item.onlyModule && innerRequest.startsWith(item.name + "/"))
+						) {
+							const remainingRequest = innerRequest.substr(item.name.length);
+							const resolveWithAlias = (alias, callback) => {
+								if (alias === false) {
+									const ignoreObj = {
+										...request,
+										path: false
+									};
+									return callback(null, ignoreObj);
+								}
+								if (
+									innerRequest !== alias &&
+									!innerRequest.startsWith(alias + "/")
+								) {
+									shouldStop = true;
+									const newRequestStr = alias + remainingRequest;
+									const obj = {
+										...request,
+										request: newRequestStr,
+										fullySpecified: false
+									};
+									return resolver.doResolve(
+										target,
+										obj,
+										"aliased with mapping '" +
+											item.name +
+											"': '" +
+											alias +
+											"' to '" +
+											newRequestStr +
+											"'",
+										resolveContext,
+										(err, result) => {
+											if (err) return callback(err);
+											if (result) return callback(null, result);
+											return callback();
 										}
-									}
-								} else {
-									node.cycle = cycle;
-									cycle.nodes.add(node);
+									);
 								}
-							}
-							// don't recurse into dependencies
-							// these are already on the stack
-							break;
-						}
-						case DONE_AND_ROOT_MARKER:
-							// This node has be visited yet and is currently a root node
-							// But as this is a new reference to the node
-							// it's not really a root
-							// so we have to convert it to a normal node
-							dependency.marker = DONE_MARKER;
-							roots.delete(dependency);
-							break;
-						case DONE_MAYBE_ROOT_CYCLE_MARKER:
-							// This node has be visited yet and
-							// is maybe currently part of a completed root cycle
-							// we found a new reference to the cycle
-							// so it's not really a root cycle
-							// remove the cycle from the root cycles
-							// and convert it to a normal node
-							rootCycles.delete(dependency.cycle);
-							dependency.marker = DONE_MARKER;
-							break;
-						// DONE_MARKER: nothing to do, don't recurse into dependencies
-					}
-				} else {
-					// All dependencies of the current node has been visited
-					// we leave the node
-					stack.pop();
-					topOfStack.node.marker = DONE_MARKER;
-				}
-			}
-			const cycle = selectedNode.cycle;
-			if (cycle) {
-				for (const node of cycle.nodes) {
-					node.marker = DONE_MAYBE_ROOT_CYCLE_MARKER;
-				}
-				rootCycles.add(cycle);
-			} else {
-				selectedNode.marker = DONE_AND_ROOT_MARKER;
-				roots.add(selectedNode);
-			}
-		}
+								return callback();
+							};
+							const stoppingCallback = (err, result) => {
+								if (err) return callback(err);
+
+								if (result) return callback(null, result);
+								// Don't allow other aliasing or raw request
+								if (shouldStop) return callback(null, null);
+								return callback();
+							};
+							if (Array.isArray(item.alias)) {
+								return forEachBail(
+									item.alias,
+									resolveWithAlias,
+									stoppingCallback
+								);
+							} else {
+								return resolveWithAlias(item.alias, stoppingCallback);
+							}
+						}
+						return callback();
+					},
+					callback
+				);
+			});
 	}
+};
 
-	// Extract roots from root cycles
-	// We take the nodes with most incoming edges
-	// inside of the cycle
-	for (const cycle of rootCycles) {
-		let max = 0;
-		/** @type {Set<Node<T>>} */
-		const cycleRoots = new Set();
-		const nodes = cycle.nodes;
-		for (const node of nodes) {
-			for (const dep of node.dependencies) {
-				if (nodes.has(dep)) {
-					dep.incoming++;
-					if (dep.incoming < max) continue;
-					if (dep.incoming > max) {
-						cycleRoots.clear();
-						max = dep.incoming;
-					}
-					cycleRoots.add(dep);
-				}
-			}
-		}
-		for (const cycleRoot of cycleRoots) {
-			roots.add(cycleRoot);
-		}
+
+/***/ }),
+
+/***/ 92088:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class AppendPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} appending appending
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, appending, target) {
+		this.source = source;
+		this.appending = appending;
+		this.target = target;
 	}
 
-	// When roots were found, return them
-	if (roots.size > 0) {
-		return Array.from(roots, r => r.item);
-	} else {
-		throw new Error("Implementation of findGraphRoots is broken");
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AppendPlugin", (request, resolveContext, callback) => {
+				const obj = {
+					...request,
+					path: request.path + this.appending,
+					relativePath:
+						request.relativePath && request.relativePath + this.appending
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					this.appending,
+					resolveContext,
+					callback
+				);
+			});
 	}
 };
 
 
 /***/ }),
 
-/***/ 17139:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 52788:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -133342,417 +133820,481 @@ module.exports = (items, getDependencies) => {
 
 
 
-const path = __webpack_require__(71017);
+const nextTick = (__webpack_require__(77282).nextTick);
 
-/** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
 
-/**
- * @typedef {Object} IStats
- * @property {() => boolean} isFile
- * @property {() => boolean} isDirectory
- * @property {() => boolean} isBlockDevice
- * @property {() => boolean} isCharacterDevice
- * @property {() => boolean} isSymbolicLink
- * @property {() => boolean} isFIFO
- * @property {() => boolean} isSocket
- * @property {number | bigint} dev
- * @property {number | bigint} ino
- * @property {number | bigint} mode
- * @property {number | bigint} nlink
- * @property {number | bigint} uid
- * @property {number | bigint} gid
- * @property {number | bigint} rdev
- * @property {number | bigint} size
- * @property {number | bigint} blksize
- * @property {number | bigint} blocks
- * @property {number | bigint} atimeMs
- * @property {number | bigint} mtimeMs
- * @property {number | bigint} ctimeMs
- * @property {number | bigint} birthtimeMs
- * @property {Date} atime
- * @property {Date} mtime
- * @property {Date} ctime
- * @property {Date} birthtime
- */
+const dirname = path => {
+	let idx = path.length - 1;
+	while (idx >= 0) {
+		const c = path.charCodeAt(idx);
+		// slash or backslash
+		if (c === 47 || c === 92) break;
+		idx--;
+	}
+	if (idx < 0) return "";
+	return path.slice(0, idx);
+};
 
-/**
- * @typedef {Object} IDirent
- * @property {() => boolean} isFile
- * @property {() => boolean} isDirectory
- * @property {() => boolean} isBlockDevice
- * @property {() => boolean} isCharacterDevice
- * @property {() => boolean} isSymbolicLink
- * @property {() => boolean} isFIFO
- * @property {() => boolean} isSocket
- * @property {string | Buffer} name
- */
+const runCallbacks = (callbacks, err, result) => {
+	if (callbacks.length === 1) {
+		callbacks[0](err, result);
+		callbacks.length = 0;
+		return;
+	}
+	let error;
+	for (const callback of callbacks) {
+		try {
+			callback(err, result);
+		} catch (e) {
+			if (!error) error = e;
+		}
+	}
+	callbacks.length = 0;
+	if (error) throw error;
+};
 
-/** @typedef {function((NodeJS.ErrnoException | null)=): void} Callback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer=): void} BufferCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, Buffer|string=): void} BufferOrStringCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, (string | Buffer)[] | IDirent[]=): void} DirentArrayCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, string=): void} StringCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, number=): void} NumberCallback */
-/** @typedef {function((NodeJS.ErrnoException | null)=, IStats=): void} StatsCallback */
-/** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
-/** @typedef {function((NodeJS.ErrnoException | Error | null)=, IStats|string=): void} LstatReadlinkAbsoluteCallback */
+class OperationMergerBackend {
+	/**
+	 * @param {any} provider async method
+	 * @param {any} syncProvider sync method
+	 * @param {any} providerContext call context for the provider methods
+	 */
+	constructor(provider, syncProvider, providerContext) {
+		this._provider = provider;
+		this._syncProvider = syncProvider;
+		this._providerContext = providerContext;
+		this._activeAsyncOperations = new Map();
 
-/**
- * @typedef {Object} WatcherInfo
- * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
- * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
- * @property {Map<string, FileSystemInfoEntry | "ignore">} fileTimeInfoEntries get info about files
- * @property {Map<string, FileSystemInfoEntry | "ignore">} contextTimeInfoEntries get info about directories
- */
+		this.provide = this._provider
+			? (path, options, callback) => {
+					if (typeof options === "function") {
+						callback = options;
+						options = undefined;
+					}
+					if (options) {
+						return this._provider.call(
+							this._providerContext,
+							path,
+							options,
+							callback
+						);
+					}
+					if (typeof path !== "string") {
+						callback(new TypeError("path must be a string"));
+						return;
+					}
+					let callbacks = this._activeAsyncOperations.get(path);
+					if (callbacks) {
+						callbacks.push(callback);
+						return;
+					}
+					this._activeAsyncOperations.set(path, (callbacks = [callback]));
+					provider(path, (err, result) => {
+						this._activeAsyncOperations.delete(path);
+						runCallbacks(callbacks, err, result);
+					});
+			  }
+			: null;
+		this.provideSync = this._syncProvider
+			? (path, options) => {
+					return this._syncProvider.call(this._providerContext, path, options);
+			  }
+			: null;
+	}
 
-// TODO webpack 6 deprecate missing getInfo
-/**
- * @typedef {Object} Watcher
- * @property {function(): void} close closes the watcher and all underlying file watchers
- * @property {function(): void} pause closes the watcher, but keeps underlying file watchers alive until the next watch call
- * @property {function(): Set<string>=} getAggregatedChanges get current aggregated changes that have not yet send to callback
- * @property {function(): Set<string>=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
- * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getFileTimeInfoEntries get info about files
- * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getContextTimeInfoEntries get info about directories
- * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
- */
+	purge() {}
+	purgeParent() {}
+}
 
-/**
- * @callback WatchMethod
- * @param {Iterable<string>} files watched files
- * @param {Iterable<string>} directories watched directories
- * @param {Iterable<string>} missing watched exitance entries
- * @param {number} startTime timestamp of start time
- * @param {WatchOptions} options options object
- * @param {function(Error=, Map<string, FileSystemInfoEntry | "ignore">, Map<string, FileSystemInfoEntry | "ignore">, Set<string>, Set<string>): void} callback aggregated callback
- * @param {function(string, number): void} callbackUndelayed callback when the first change was detected
- * @returns {Watcher} a watcher
- */
+/*
 
-// TODO webpack 6 make optional methods required
+IDLE:
+	insert data: goto SYNC
 
-/**
- * @typedef {Object} OutputFileSystem
- * @property {function(string, Buffer|string, Callback): void} writeFile
- * @property {function(string, Callback): void} mkdir
- * @property {function(string, DirentArrayCallback): void=} readdir
- * @property {function(string, Callback): void=} rmdir
- * @property {function(string, Callback): void=} unlink
- * @property {function(string, StatsCallback): void} stat
- * @property {function(string, StatsCallback): void=} lstat
- * @property {function(string, BufferOrStringCallback): void} readFile
- * @property {(function(string, string): string)=} join
- * @property {(function(string, string): string)=} relative
- * @property {(function(string): string)=} dirname
- */
+SYNC:
+	before provide: run ticks
+	event loop tick: goto ASYNC_ACTIVE
 
-/**
- * @typedef {Object} InputFileSystem
- * @property {function(string, BufferOrStringCallback): void} readFile
- * @property {(function(string, ReadJsonCallback): void)=} readJson
- * @property {function(string, BufferOrStringCallback): void} readlink
- * @property {function(string, DirentArrayCallback): void} readdir
- * @property {function(string, StatsCallback): void} stat
- * @property {function(string, StatsCallback): void=} lstat
- * @property {(function(string, BufferOrStringCallback): void)=} realpath
- * @property {(function(string=): void)=} purge
- * @property {(function(string, string): string)=} join
- * @property {(function(string, string): string)=} relative
- * @property {(function(string): string)=} dirname
- */
+ASYNC:
+	timeout: run tick, goto ASYNC_PASSIVE
 
-/**
- * @typedef {Object} WatchFileSystem
- * @property {WatchMethod} watch
- */
+ASYNC_PASSIVE:
+	before provide: run ticks
 
-/**
- * @typedef {Object} IntermediateFileSystemExtras
- * @property {function(string): void} mkdirSync
- * @property {function(string): NodeJS.WritableStream} createWriteStream
- * @property {function(string, string, NumberCallback): void} open
- * @property {function(number, Buffer, number, number, number, NumberCallback): void} read
- * @property {function(number, Callback): void} close
- * @property {function(string, string, Callback): void} rename
- */
+IDLE --[insert data]--> SYNC --[event loop tick]--> ASYNC_ACTIVE --[interval tick]-> ASYNC_PASSIVE
+                                                          ^                             |
+                                                          +---------[insert data]-------+
+*/
 
-/** @typedef {InputFileSystem & OutputFileSystem & IntermediateFileSystemExtras} IntermediateFileSystem */
+const STORAGE_MODE_IDLE = 0;
+const STORAGE_MODE_SYNC = 1;
+const STORAGE_MODE_ASYNC = 2;
 
-/**
- *
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
- * @param {string} rootPath the root path
- * @param {string} targetPath the target path
- * @returns {string} location of targetPath relative to rootPath
- */
-const relative = (fs, rootPath, targetPath) => {
-	if (fs && fs.relative) {
-		return fs.relative(rootPath, targetPath);
-	} else if (path.posix.isAbsolute(rootPath)) {
-		return path.posix.relative(rootPath, targetPath);
-	} else if (path.win32.isAbsolute(rootPath)) {
-		return path.win32.relative(rootPath, targetPath);
-	} else {
-		throw new Error(
-			`${rootPath} is neither a posix nor a windows path, and there is no 'relative' method defined in the file system`
-		);
+class CacheBackend {
+	/**
+	 * @param {number} duration max cache duration of items
+	 * @param {any} provider async method
+	 * @param {any} syncProvider sync method
+	 * @param {any} providerContext call context for the provider methods
+	 */
+	constructor(duration, provider, syncProvider, providerContext) {
+		this._duration = duration;
+		this._provider = provider;
+		this._syncProvider = syncProvider;
+		this._providerContext = providerContext;
+		/** @type {Map<string, (function(Error, any): void)[]>} */
+		this._activeAsyncOperations = new Map();
+		/** @type {Map<string, { err: Error, result: any, level: Set<string> }>} */
+		this._data = new Map();
+		/** @type {Set<string>[]} */
+		this._levels = [];
+		for (let i = 0; i < 10; i++) this._levels.push(new Set());
+		for (let i = 5000; i < duration; i += 500) this._levels.push(new Set());
+		this._currentLevel = 0;
+		this._tickInterval = Math.floor(duration / this._levels.length);
+		/** @type {STORAGE_MODE_IDLE | STORAGE_MODE_SYNC | STORAGE_MODE_ASYNC} */
+		this._mode = STORAGE_MODE_IDLE;
+
+		/** @type {NodeJS.Timeout | undefined} */
+		this._timeout = undefined;
+		/** @type {number | undefined} */
+		this._nextDecay = undefined;
+
+		this.provide = provider ? this.provide.bind(this) : null;
+		this.provideSync = syncProvider ? this.provideSync.bind(this) : null;
 	}
-};
-exports.relative = relative;
 
-/**
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
- * @param {string} rootPath a path
- * @param {string} filename a filename
- * @returns {string} the joined path
- */
-const join = (fs, rootPath, filename) => {
-	if (fs && fs.join) {
-		return fs.join(rootPath, filename);
-	} else if (path.posix.isAbsolute(rootPath)) {
-		return path.posix.join(rootPath, filename);
-	} else if (path.win32.isAbsolute(rootPath)) {
-		return path.win32.join(rootPath, filename);
-	} else {
-		throw new Error(
-			`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`
-		);
+	provide(path, options, callback) {
+		if (typeof options === "function") {
+			callback = options;
+			options = undefined;
+		}
+		if (typeof path !== "string") {
+			callback(new TypeError("path must be a string"));
+			return;
+		}
+		if (options) {
+			return this._provider.call(
+				this._providerContext,
+				path,
+				options,
+				callback
+			);
+		}
+
+		// When in sync mode we can move to async mode
+		if (this._mode === STORAGE_MODE_SYNC) {
+			this._enterAsyncMode();
+		}
+
+		// Check in cache
+		let cacheEntry = this._data.get(path);
+		if (cacheEntry !== undefined) {
+			if (cacheEntry.err) return nextTick(callback, cacheEntry.err);
+			return nextTick(callback, null, cacheEntry.result);
+		}
+
+		// Check if there is already the same operation running
+		let callbacks = this._activeAsyncOperations.get(path);
+		if (callbacks !== undefined) {
+			callbacks.push(callback);
+			return;
+		}
+		this._activeAsyncOperations.set(path, (callbacks = [callback]));
+
+		// Run the operation
+		this._provider.call(this._providerContext, path, (err, result) => {
+			this._activeAsyncOperations.delete(path);
+			this._storeResult(path, err, result);
+
+			// Enter async mode if not yet done
+			this._enterAsyncMode();
+
+			runCallbacks(callbacks, err, result);
+		});
 	}
-};
-exports.join = join;
 
-/**
- * @param {InputFileSystem|OutputFileSystem|undefined} fs a file system
- * @param {string} absPath an absolute path
- * @returns {string} the parent directory of the absolute path
- */
-const dirname = (fs, absPath) => {
-	if (fs && fs.dirname) {
-		return fs.dirname(absPath);
-	} else if (path.posix.isAbsolute(absPath)) {
-		return path.posix.dirname(absPath);
-	} else if (path.win32.isAbsolute(absPath)) {
-		return path.win32.dirname(absPath);
-	} else {
-		throw new Error(
-			`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`
-		);
+	provideSync(path, options) {
+		if (typeof path !== "string") {
+			throw new TypeError("path must be a string");
+		}
+		if (options) {
+			return this._syncProvider.call(this._providerContext, path, options);
+		}
+
+		// In sync mode we may have to decay some cache items
+		if (this._mode === STORAGE_MODE_SYNC) {
+			this._runDecays();
+		}
+
+		// Check in cache
+		let cacheEntry = this._data.get(path);
+		if (cacheEntry !== undefined) {
+			if (cacheEntry.err) throw cacheEntry.err;
+			return cacheEntry.result;
+		}
+
+		// Get all active async operations
+		// This sync operation will also complete them
+		const callbacks = this._activeAsyncOperations.get(path);
+		this._activeAsyncOperations.delete(path);
+
+		// Run the operation
+		// When in idle mode, we will enter sync mode
+		let result;
+		try {
+			result = this._syncProvider.call(this._providerContext, path);
+		} catch (err) {
+			this._storeResult(path, err, undefined);
+			this._enterSyncModeWhenIdle();
+			if (callbacks) runCallbacks(callbacks, err, undefined);
+			throw err;
+		}
+		this._storeResult(path, undefined, result);
+		this._enterSyncModeWhenIdle();
+		if (callbacks) runCallbacks(callbacks, undefined, result);
+		return result;
 	}
-};
-exports.dirname = dirname;
 
-/**
- * @param {OutputFileSystem} fs a file system
- * @param {string} p an absolute path
- * @param {function(Error=): void} callback callback function for the error
- * @returns {void}
- */
-const mkdirp = (fs, p, callback) => {
-	fs.mkdir(p, err => {
-		if (err) {
-			if (err.code === "ENOENT") {
-				const dir = dirname(fs, p);
-				if (dir === p) {
-					callback(err);
-					return;
+	purge(what) {
+		if (!what) {
+			if (this._mode !== STORAGE_MODE_IDLE) {
+				this._data.clear();
+				for (const level of this._levels) {
+					level.clear();
+				}
+				this._enterIdleMode();
+			}
+		} else if (typeof what === "string") {
+			for (let [key, data] of this._data) {
+				if (key.startsWith(what)) {
+					this._data.delete(key);
+					data.level.delete(key);
 				}
-				mkdirp(fs, dir, err => {
-					if (err) {
-						callback(err);
-						return;
+			}
+			if (this._data.size === 0) {
+				this._enterIdleMode();
+			}
+		} else {
+			for (let [key, data] of this._data) {
+				for (const item of what) {
+					if (key.startsWith(item)) {
+						this._data.delete(key);
+						data.level.delete(key);
+						break;
 					}
-					fs.mkdir(p, err => {
-						if (err) {
-							if (err.code === "EEXIST") {
-								callback();
-								return;
-							}
-							callback(err);
-							return;
-						}
-						callback();
-					});
-				});
-				return;
-			} else if (err.code === "EEXIST") {
-				callback();
-				return;
+				}
+			}
+			if (this._data.size === 0) {
+				this._enterIdleMode();
 			}
-			callback(err);
-			return;
 		}
-		callback();
-	});
-};
-exports.mkdirp = mkdirp;
+	}
 
-/**
- * @param {IntermediateFileSystem} fs a file system
- * @param {string} p an absolute path
- * @returns {void}
- */
-const mkdirpSync = (fs, p) => {
-	try {
-		fs.mkdirSync(p);
-	} catch (err) {
-		if (err) {
-			if (err.code === "ENOENT") {
-				const dir = dirname(fs, p);
-				if (dir === p) {
-					throw err;
-				}
-				mkdirpSync(fs, dir);
-				fs.mkdirSync(p);
-				return;
-			} else if (err.code === "EEXIST") {
-				return;
+	purgeParent(what) {
+		if (!what) {
+			this.purge();
+		} else if (typeof what === "string") {
+			this.purge(dirname(what));
+		} else {
+			const set = new Set();
+			for (const item of what) {
+				set.add(dirname(item));
 			}
-			throw err;
+			this.purge(set);
 		}
 	}
-};
-exports.mkdirpSync = mkdirpSync;
 
-/**
- * @param {InputFileSystem} fs a file system
- * @param {string} p an absolute path
- * @param {ReadJsonCallback} callback callback
- * @returns {void}
- */
-const readJson = (fs, p, callback) => {
-	if ("readJson" in fs) return fs.readJson(p, callback);
-	fs.readFile(p, (err, buf) => {
-		if (err) return callback(err);
-		let data;
-		try {
-			data = JSON.parse(buf.toString("utf-8"));
-		} catch (e) {
-			return callback(e);
-		}
-		return callback(null, data);
-	});
-};
-exports.readJson = readJson;
+	_storeResult(path, err, result) {
+		if (this._data.has(path)) return;
+		const level = this._levels[this._currentLevel];
+		this._data.set(path, { err, result, level });
+		level.add(path);
+	}
 
-/**
- * @param {InputFileSystem} fs a file system
- * @param {string} p an absolute path
- * @param {ReadJsonCallback} callback callback
- * @returns {void}
- */
-const lstatReadlinkAbsolute = (fs, p, callback) => {
-	let i = 3;
-	const doReadLink = () => {
-		fs.readlink(p, (err, target) => {
-			if (err && --i > 0) {
-				// It might was just changed from symlink to file
-				// we retry 2 times to catch this case before throwing the error
-				return doStat();
-			}
-			if (err || !target) return doStat();
-			const value = target.toString();
-			callback(null, join(fs, dirname(fs, p), value));
-		});
-	};
-	const doStat = () => {
-		if ("lstat" in fs) {
-			return fs.lstat(p, (err, stats) => {
-				if (err) return callback(err);
-				if (stats.isSymbolicLink()) {
-					return doReadLink();
-				}
-				callback(null, stats);
-			});
+	_decayLevel() {
+		const nextLevel = (this._currentLevel + 1) % this._levels.length;
+		const decay = this._levels[nextLevel];
+		this._currentLevel = nextLevel;
+		for (let item of decay) {
+			this._data.delete(item);
+		}
+		decay.clear();
+		if (this._data.size === 0) {
+			this._enterIdleMode();
 		} else {
-			return fs.stat(p, callback);
+			// @ts-ignore _nextDecay is always a number in sync mode
+			this._nextDecay += this._tickInterval;
 		}
-	};
-	if ("lstat" in fs) return doStat();
-	doReadLink();
-};
-exports.lstatReadlinkAbsolute = lstatReadlinkAbsolute;
+	}
 
+	_runDecays() {
+		while (
+			/** @type {number} */ (this._nextDecay) <= Date.now() &&
+			this._mode !== STORAGE_MODE_IDLE
+		) {
+			this._decayLevel();
+		}
+	}
 
-/***/ }),
+	_enterAsyncMode() {
+		let timeout = 0;
+		switch (this._mode) {
+			case STORAGE_MODE_ASYNC:
+				return;
+			case STORAGE_MODE_IDLE:
+				this._nextDecay = Date.now() + this._tickInterval;
+				timeout = this._tickInterval;
+				break;
+			case STORAGE_MODE_SYNC:
+				this._runDecays();
+				// @ts-ignore _runDecays may change the mode
+				if (this._mode === STORAGE_MODE_IDLE) return;
+				timeout = Math.max(
+					0,
+					/** @type {number} */ (this._nextDecay) - Date.now()
+				);
+				break;
+		}
+		this._mode = STORAGE_MODE_ASYNC;
+		const ref = setTimeout(() => {
+			this._mode = STORAGE_MODE_SYNC;
+			this._runDecays();
+		}, timeout);
+		if (ref.unref) ref.unref();
+		this._timeout = ref;
+	}
 
-/***/ 59461:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	_enterSyncModeWhenIdle() {
+		if (this._mode === STORAGE_MODE_IDLE) {
+			this._mode = STORAGE_MODE_SYNC;
+			this._nextDecay = Date.now() + this._tickInterval;
+		}
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	_enterIdleMode() {
+		this._mode = STORAGE_MODE_IDLE;
+		this._nextDecay = undefined;
+		if (this._timeout) clearTimeout(this._timeout);
+	}
+}
 
+const createBackend = (duration, provider, syncProvider, providerContext) => {
+	if (duration > 0) {
+		return new CacheBackend(duration, provider, syncProvider, providerContext);
+	}
+	return new OperationMergerBackend(provider, syncProvider, providerContext);
+};
 
+module.exports = class CachedInputFileSystem {
+	constructor(fileSystem, duration) {
+		this.fileSystem = fileSystem;
 
-const Hash = __webpack_require__(36692);
-const MAX_SHORT_STRING = (__webpack_require__(1842).MAX_SHORT_STRING);
+		this._lstatBackend = createBackend(
+			duration,
+			this.fileSystem.lstat,
+			this.fileSystem.lstatSync,
+			this.fileSystem
+		);
+		const lstat = this._lstatBackend.provide;
+		this.lstat = /** @type {FileSystem["lstat"]} */ (lstat);
+		const lstatSync = this._lstatBackend.provideSync;
+		this.lstatSync = /** @type {SyncFileSystem["lstatSync"]} */ (lstatSync);
 
-class BatchedHash extends Hash {
-	constructor(hash) {
-		super();
-		this.string = undefined;
-		this.encoding = undefined;
-		this.hash = hash;
-	}
+		this._statBackend = createBackend(
+			duration,
+			this.fileSystem.stat,
+			this.fileSystem.statSync,
+			this.fileSystem
+		);
+		const stat = this._statBackend.provide;
+		this.stat = /** @type {FileSystem["stat"]} */ (stat);
+		const statSync = this._statBackend.provideSync;
+		this.statSync = /** @type {SyncFileSystem["statSync"]} */ (statSync);
 
-	/**
-	 * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-	 * @param {string|Buffer} data data
-	 * @param {string=} inputEncoding data encoding
-	 * @returns {this} updated hash
-	 */
-	update(data, inputEncoding) {
-		if (this.string !== undefined) {
-			if (
-				typeof data === "string" &&
-				inputEncoding === this.encoding &&
-				this.string.length + data.length < MAX_SHORT_STRING
-			) {
-				this.string += data;
-				return this;
-			}
-			this.hash.update(this.string, this.encoding);
-			this.string = undefined;
-		}
-		if (typeof data === "string") {
-			if (
-				data.length < MAX_SHORT_STRING &&
-				// base64 encoding is not valid since it may contain padding chars
-				(!inputEncoding || !inputEncoding.startsWith("ba"))
-			) {
-				this.string = data;
-				this.encoding = inputEncoding;
-			} else {
-				this.hash.update(data, inputEncoding);
-			}
-		} else {
-			this.hash.update(data);
-		}
-		return this;
-	}
+		this._readdirBackend = createBackend(
+			duration,
+			this.fileSystem.readdir,
+			this.fileSystem.readdirSync,
+			this.fileSystem
+		);
+		const readdir = this._readdirBackend.provide;
+		this.readdir = /** @type {FileSystem["readdir"]} */ (readdir);
+		const readdirSync = this._readdirBackend.provideSync;
+		this.readdirSync = /** @type {SyncFileSystem["readdirSync"]} */ (readdirSync);
 
-	/**
-	 * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-	 * @param {string=} encoding encoding of the return value
-	 * @returns {string|Buffer} digest
-	 */
-	digest(encoding) {
-		if (this.string !== undefined) {
-			this.hash.update(this.string, this.encoding);
-		}
-		return this.hash.digest(encoding);
+		this._readFileBackend = createBackend(
+			duration,
+			this.fileSystem.readFile,
+			this.fileSystem.readFileSync,
+			this.fileSystem
+		);
+		const readFile = this._readFileBackend.provide;
+		this.readFile = /** @type {FileSystem["readFile"]} */ (readFile);
+		const readFileSync = this._readFileBackend.provideSync;
+		this.readFileSync = /** @type {SyncFileSystem["readFileSync"]} */ (readFileSync);
+
+		this._readJsonBackend = createBackend(
+			duration,
+			this.fileSystem.readJson ||
+				(this.readFile &&
+					((path, callback) => {
+						// @ts-ignore
+						this.readFile(path, (err, buffer) => {
+							if (err) return callback(err);
+							if (!buffer || buffer.length === 0)
+								return callback(new Error("No file content"));
+							let data;
+							try {
+								data = JSON.parse(buffer.toString("utf-8"));
+							} catch (e) {
+								return callback(e);
+							}
+							callback(null, data);
+						});
+					})),
+			this.fileSystem.readJsonSync ||
+				(this.readFileSync &&
+					(path => {
+						const buffer = this.readFileSync(path);
+						const data = JSON.parse(buffer.toString("utf-8"));
+						return data;
+					})),
+			this.fileSystem
+		);
+		const readJson = this._readJsonBackend.provide;
+		this.readJson = /** @type {FileSystem["readJson"]} */ (readJson);
+		const readJsonSync = this._readJsonBackend.provideSync;
+		this.readJsonSync = /** @type {SyncFileSystem["readJsonSync"]} */ (readJsonSync);
+
+		this._readlinkBackend = createBackend(
+			duration,
+			this.fileSystem.readlink,
+			this.fileSystem.readlinkSync,
+			this.fileSystem
+		);
+		const readlink = this._readlinkBackend.provide;
+		this.readlink = /** @type {FileSystem["readlink"]} */ (readlink);
+		const readlinkSync = this._readlinkBackend.provideSync;
+		this.readlinkSync = /** @type {SyncFileSystem["readlinkSync"]} */ (readlinkSync);
 	}
-}
 
-module.exports = BatchedHash;
+	purge(what) {
+		this._statBackend.purge(what);
+		this._lstatBackend.purge(what);
+		this._readdirBackend.purgeParent(what);
+		this._readFileBackend.purge(what);
+		this._readlinkBackend.purge(what);
+		this._readJsonBackend.purge(what);
+	}
+};
 
 
 /***/ }),
 
-/***/ 86884:
+/***/ 22254:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -133763,24 +134305,49 @@ module.exports = BatchedHash;
 
 
 
-const create = __webpack_require__(1842);
+const basename = (__webpack_require__(82918).basename);
 
-//#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
-const md4 = new WebAssembly.Module(
-	Buffer.from(
-		// 2156 bytes
-		"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",
-		"base64"
-	)
-);
-//#endregion
+/** @typedef {import("./Resolver")} Resolver */
 
-module.exports = create.bind(null, md4, [], 64, 32);
+module.exports = class CloneBasenamePlugin {
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("CloneBasenamePlugin", (request, resolveContext, callback) => {
+				const filename = basename(request.path);
+				const filePath = resolver.join(request.path, filename);
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, filename)
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"using path: " + filePath,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
 
 /***/ }),
 
-/***/ 1842:
+/***/ 6953:
 /***/ (function(module) {
 
 "use strict";
@@ -133791,167 +134358,63 @@ module.exports = create.bind(null, md4, [], 64, 32);
 
 
 
-// 65536 is the size of a wasm memory page
-// 64 is the maximum chunk size for every possible wasm hash implementation
-// 4 is the maximum number of bytes per char for string encoding (max is utf-8)
-// ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
-const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
-
-class WasmHash {
-	/**
-	 * @param {WebAssembly.Instance} instance wasm instance
-	 * @param {WebAssembly.Instance[]} instancesPool pool of instances
-	 * @param {number} chunkSize size of data chunks passed to wasm
-	 * @param {number} digestSize size of digest returned by wasm
-	 */
-	constructor(instance, instancesPool, chunkSize, digestSize) {
-		const exports = /** @type {any} */ (instance.exports);
-		exports.init();
-		this.exports = exports;
-		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
-		this.buffered = 0;
-		this.instancesPool = instancesPool;
-		this.chunkSize = chunkSize;
-		this.digestSize = digestSize;
-	}
-
-	reset() {
-		this.buffered = 0;
-		this.exports.init();
-	}
-
-	/**
-	 * @param {Buffer | string} data data
-	 * @param {BufferEncoding=} encoding encoding
-	 * @returns {this} itself
-	 */
-	update(data, encoding) {
-		if (typeof data === "string") {
-			while (data.length > MAX_SHORT_STRING) {
-				this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
-				data = data.slice(MAX_SHORT_STRING);
-			}
-			this._updateWithShortString(data, encoding);
-			return this;
-		}
-		this._updateWithBuffer(data);
-		return this;
-	}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
+module.exports = class ConditionalPlugin {
 	/**
-	 * @param {string} data data
-	 * @param {BufferEncoding=} encoding encoding
-	 * @returns {void}
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Partial<ResolveRequest>} test compare object
+	 * @param {string | null} message log message
+	 * @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches
+	 * @param {string | ResolveStepHook} target target
 	 */
-	_updateWithShortString(data, encoding) {
-		const { exports, buffered, mem, chunkSize } = this;
-		let endPos;
-		if (data.length < 70) {
-			if (!encoding || encoding === "utf-8" || encoding === "utf8") {
-				endPos = buffered;
-				for (let i = 0; i < data.length; i++) {
-					const cc = data.charCodeAt(i);
-					if (cc < 0x80) mem[endPos++] = cc;
-					else if (cc < 0x800) {
-						mem[endPos] = (cc >> 6) | 0xc0;
-						mem[endPos + 1] = (cc & 0x3f) | 0x80;
-						endPos += 2;
-					} else {
-						// bail-out for weird chars
-						endPos += mem.write(data.slice(i), endPos, encoding);
-						break;
-					}
-				}
-			} else if (encoding === "latin1") {
-				endPos = buffered;
-				for (let i = 0; i < data.length; i++) {
-					const cc = data.charCodeAt(i);
-					mem[endPos++] = cc;
-				}
-			} else {
-				endPos = buffered + mem.write(data, buffered, encoding);
-			}
-		} else {
-			endPos = buffered + mem.write(data, buffered, encoding);
-		}
-		if (endPos < chunkSize) {
-			this.buffered = endPos;
-		} else {
-			const l = endPos & ~(this.chunkSize - 1);
-			exports.update(l);
-			const newBuffered = endPos - l;
-			this.buffered = newBuffered;
-			if (newBuffered > 0) mem.copyWithin(0, l, endPos);
-		}
+	constructor(source, test, message, allowAlternatives, target) {
+		this.source = source;
+		this.test = test;
+		this.message = message;
+		this.allowAlternatives = allowAlternatives;
+		this.target = target;
 	}
 
 	/**
-	 * @param {Buffer} data data
+	 * @param {Resolver} resolver the resolver
 	 * @returns {void}
 	 */
-	_updateWithBuffer(data) {
-		const { exports, buffered, mem } = this;
-		const length = data.length;
-		if (buffered + length < this.chunkSize) {
-			data.copy(mem, buffered, 0, length);
-			this.buffered += length;
-		} else {
-			const l = (buffered + length) & ~(this.chunkSize - 1);
-			if (l > 65536) {
-				let i = 65536 - buffered;
-				data.copy(mem, buffered, 0, i);
-				exports.update(65536);
-				const stop = l - buffered - 65536;
-				while (i < stop) {
-					data.copy(mem, 0, i, i + 65536);
-					exports.update(65536);
-					i += 65536;
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const { test, message, allowAlternatives } = this;
+		const keys = Object.keys(test);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ConditionalPlugin", (request, resolveContext, callback) => {
+				for (const prop of keys) {
+					if (request[prop] !== test[prop]) return callback();
 				}
-				data.copy(mem, 0, i, l - buffered);
-				exports.update(l - buffered - i);
-			} else {
-				data.copy(mem, buffered, 0, l - buffered);
-				exports.update(l);
-			}
-			const newBuffered = length + buffered - l;
-			this.buffered = newBuffered;
-			if (newBuffered > 0) data.copy(mem, 0, length - newBuffered, length);
-		}
-	}
-
-	digest(type) {
-		const { exports, buffered, mem, digestSize } = this;
-		exports.final(buffered);
-		this.instancesPool.push(this);
-		const hex = mem.toString("latin1", 0, digestSize);
-		if (type === "hex") return hex;
-		if (type === "binary" || !type) return Buffer.from(hex, "hex");
-		return Buffer.from(hex, "hex").toString(type);
-	}
-}
+				resolver.doResolve(
+					target,
+					request,
+					message,
+					resolveContext,
+					allowAlternatives
+						? callback
+						: (err, result) => {
+								if (err) return callback(err);
 
-const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
-	if (instancesPool.length > 0) {
-		const old = instancesPool.pop();
-		old.reset();
-		return old;
-	} else {
-		return new WasmHash(
-			new WebAssembly.Instance(wasmModule),
-			instancesPool,
-			chunkSize,
-			digestSize
-		);
+								// Don't allow other alternatives
+								if (result === undefined) return callback(null, null);
+								callback(null, result);
+						  }
+				);
+			});
 	}
 };
 
-module.exports = create;
-module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
-
 
 /***/ }),
 
-/***/ 35028:
+/***/ 44112:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -133962,683 +134425,751 @@ module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
 
 
 
-const create = __webpack_require__(1842);
+const DescriptionFileUtils = __webpack_require__(25424);
 
-//#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1
-const xxhash64 = new WebAssembly.Module(
-	Buffer.from(
-		// 1170 bytes
-		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrIIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqAYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEAgAiABNQIAQoeVr6+Ytt6bnn9+hUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhAiABQQRqIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAkIdiCAChUL5893xmfaZqxZ+IgJCIIggAoUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL",
-		"base64"
-	)
-);
-//#endregion
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-module.exports = create.bind(null, xxhash64, [], 32, 16);
+module.exports = class DescriptionFilePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string[]} filenames filenames
+	 * @param {boolean} pathIsFile pathIsFile
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filenames, pathIsFile, target) {
+		this.source = source;
+		this.filenames = filenames;
+		this.pathIsFile = pathIsFile;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"DescriptionFilePlugin",
+				(request, resolveContext, callback) => {
+					const path = request.path;
+					if (!path) return callback();
+					const directory = this.pathIsFile
+						? DescriptionFileUtils.cdUp(path)
+						: path;
+					if (!directory) return callback();
+					DescriptionFileUtils.loadDescriptionFile(
+						resolver,
+						directory,
+						this.filenames,
+						request.descriptionFilePath
+							? {
+									path: request.descriptionFilePath,
+									content: request.descriptionFileData,
+									directory: /** @type {string} */ (request.descriptionFileRoot)
+							  }
+							: undefined,
+						resolveContext,
+						(err, result) => {
+							if (err) return callback(err);
+							if (!result) {
+								if (resolveContext.log)
+									resolveContext.log(
+										`No description file found in ${directory} or above`
+									);
+								return callback();
+							}
+							const relativePath =
+								"." + path.substr(result.directory.length).replace(/\\/g, "/");
+							const obj = {
+								...request,
+								descriptionFilePath: result.path,
+								descriptionFileData: result.content,
+								descriptionFileRoot: result.directory,
+								relativePath: relativePath
+							};
+							resolver.doResolve(
+								target,
+								obj,
+								"using description file: " +
+									result.path +
+									" (relative path: " +
+									relativePath +
+									")",
+								resolveContext,
+								(err, result) => {
+									if (err) return callback(err);
+
+									// Don't allow other processing
+									if (result === undefined) return callback(null, null);
+									callback(null, result);
+								}
+							);
+						}
+					);
+				}
+			);
+	}
+};
 
 
 /***/ }),
 
-/***/ 82186:
+/***/ 25424:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const path = __webpack_require__(71017);
+const forEachBail = __webpack_require__(78565);
 
-const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
-const SEGMENTS_SPLIT_REGEXP = /([|!])/;
-const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
 
 /**
- * @typedef {Object} MakeRelativePathsCache
- * @property {Map<string, Map<string, string>>=} relativePaths
+ * @typedef {Object} DescriptionFileInfo
+ * @property {any=} content
+ * @property {string} path
+ * @property {string} directory
  */
 
-const relativePathToRequest = relativePath => {
-	if (relativePath === "") return "./.";
-	if (relativePath === "..") return "../.";
-	if (relativePath.startsWith("../")) return relativePath;
-	return `./${relativePath}`;
-};
-
 /**
- * @param {string} context context for relative path
- * @param {string} maybeAbsolutePath path to make relative
- * @returns {string} relative path in request style
+ * @callback ErrorFirstCallback
+ * @param {Error|null=} error
+ * @param {DescriptionFileInfo=} result
  */
-const absoluteToRequest = (context, maybeAbsolutePath) => {
-	if (maybeAbsolutePath[0] === "/") {
-		if (
-			maybeAbsolutePath.length > 1 &&
-			maybeAbsolutePath[maybeAbsolutePath.length - 1] === "/"
-		) {
-			// this 'path' is actually a regexp generated by dynamic requires.
-			// Don't treat it as an absolute path.
-			return maybeAbsolutePath;
-		}
-
-		const querySplitPos = maybeAbsolutePath.indexOf("?");
-		let resource =
-			querySplitPos === -1
-				? maybeAbsolutePath
-				: maybeAbsolutePath.slice(0, querySplitPos);
-		resource = relativePathToRequest(path.posix.relative(context, resource));
-		return querySplitPos === -1
-			? resource
-			: resource + maybeAbsolutePath.slice(querySplitPos);
-	}
-
-	if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
-		const querySplitPos = maybeAbsolutePath.indexOf("?");
-		let resource =
-			querySplitPos === -1
-				? maybeAbsolutePath
-				: maybeAbsolutePath.slice(0, querySplitPos);
-		resource = path.win32.relative(context, resource);
-		if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
-			resource = relativePathToRequest(
-				resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/")
-			);
-		}
-		return querySplitPos === -1
-			? resource
-			: resource + maybeAbsolutePath.slice(querySplitPos);
-	}
-
-	// not an absolute path
-	return maybeAbsolutePath;
-};
 
 /**
- * @param {string} context context for relative path
- * @param {string} relativePath path
- * @returns {string} absolute path
+ * @param {Resolver} resolver resolver
+ * @param {string} directory directory
+ * @param {string[]} filenames filenames
+ * @param {DescriptionFileInfo|undefined} oldInfo oldInfo
+ * @param {ResolveContext} resolveContext resolveContext
+ * @param {ErrorFirstCallback} callback callback
  */
-const requestToAbsolute = (context, relativePath) => {
-	if (relativePath.startsWith("./") || relativePath.startsWith("../"))
-		return path.join(context, relativePath);
-	return relativePath;
-};
-
-const makeCacheable = fn => {
-	/** @type {WeakMap<object, Map<string, Map<string, string>>>} */
-	const cache = new WeakMap();
-
-	/**
-	 * @param {string} context context used to create relative path
-	 * @param {string} identifier identifier used to create relative path
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {string} the returned relative path
-	 */
-	const cachedFn = (context, identifier, associatedObjectForCache) => {
-		if (!associatedObjectForCache) return fn(context, identifier);
-
-		let innerCache = cache.get(associatedObjectForCache);
-		if (innerCache === undefined) {
-			innerCache = new Map();
-			cache.set(associatedObjectForCache, innerCache);
-		}
-
-		let cachedResult;
-		let innerSubCache = innerCache.get(context);
-		if (innerSubCache === undefined) {
-			innerCache.set(context, (innerSubCache = new Map()));
-		} else {
-			cachedResult = innerSubCache.get(identifier);
-		}
-
-		if (cachedResult !== undefined) {
-			return cachedResult;
-		} else {
-			const result = fn(context, identifier);
-			innerSubCache.set(identifier, result);
-			return result;
-		}
-	};
-
-	/**
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {function(string, string): string} cached function
-	 */
-	cachedFn.bindCache = associatedObjectForCache => {
-		let innerCache;
-		if (associatedObjectForCache) {
-			innerCache = cache.get(associatedObjectForCache);
-			if (innerCache === undefined) {
-				innerCache = new Map();
-				cache.set(associatedObjectForCache, innerCache);
-			}
-		} else {
-			innerCache = new Map();
+function loadDescriptionFile(
+	resolver,
+	directory,
+	filenames,
+	oldInfo,
+	resolveContext,
+	callback
+) {
+	(function findDescriptionFile() {
+		if (oldInfo && oldInfo.directory === directory) {
+			// We already have info for this directory and can reuse it
+			return callback(null, oldInfo);
 		}
+		forEachBail(
+			filenames,
+			(filename, callback) => {
+				const descriptionFilePath = resolver.join(directory, filename);
+				if (resolver.fileSystem.readJson) {
+					resolver.fileSystem.readJson(descriptionFilePath, (err, content) => {
+						if (err) {
+							if (typeof err.code !== "undefined") {
+								if (resolveContext.missingDependencies) {
+									resolveContext.missingDependencies.add(descriptionFilePath);
+								}
+								return callback();
+							}
+							if (resolveContext.fileDependencies) {
+								resolveContext.fileDependencies.add(descriptionFilePath);
+							}
+							return onJson(err);
+						}
+						if (resolveContext.fileDependencies) {
+							resolveContext.fileDependencies.add(descriptionFilePath);
+						}
+						onJson(null, content);
+					});
+				} else {
+					resolver.fileSystem.readFile(descriptionFilePath, (err, content) => {
+						if (err) {
+							if (resolveContext.missingDependencies) {
+								resolveContext.missingDependencies.add(descriptionFilePath);
+							}
+							return callback();
+						}
+						if (resolveContext.fileDependencies) {
+							resolveContext.fileDependencies.add(descriptionFilePath);
+						}
+						let json;
 
-		/**
-		 * @param {string} context context used to create relative path
-		 * @param {string} identifier identifier used to create relative path
-		 * @returns {string} the returned relative path
-		 */
-		const boundFn = (context, identifier) => {
-			let cachedResult;
-			let innerSubCache = innerCache.get(context);
-			if (innerSubCache === undefined) {
-				innerCache.set(context, (innerSubCache = new Map()));
-			} else {
-				cachedResult = innerSubCache.get(identifier);
-			}
-
-			if (cachedResult !== undefined) {
-				return cachedResult;
-			} else {
-				const result = fn(context, identifier);
-				innerSubCache.set(identifier, result);
-				return result;
-			}
-		};
-
-		return boundFn;
-	};
-
-	/**
-	 * @param {string} context context used to create relative path
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {function(string): string} cached function
-	 */
-	cachedFn.bindContextCache = (context, associatedObjectForCache) => {
-		let innerSubCache;
-		if (associatedObjectForCache) {
-			let innerCache = cache.get(associatedObjectForCache);
-			if (innerCache === undefined) {
-				innerCache = new Map();
-				cache.set(associatedObjectForCache, innerCache);
-			}
+						if (content) {
+							try {
+								json = JSON.parse(content.toString());
+							} catch (e) {
+								return onJson(e);
+							}
+						} else {
+							return onJson(new Error("No content in file"));
+						}
 
-			innerSubCache = innerCache.get(context);
-			if (innerSubCache === undefined) {
-				innerCache.set(context, (innerSubCache = new Map()));
-			}
-		} else {
-			innerSubCache = new Map();
-		}
+						onJson(null, json);
+					});
+				}
 
-		/**
-		 * @param {string} identifier identifier used to create relative path
-		 * @returns {string} the returned relative path
-		 */
-		const boundFn = identifier => {
-			const cachedResult = innerSubCache.get(identifier);
-			if (cachedResult !== undefined) {
-				return cachedResult;
-			} else {
-				const result = fn(context, identifier);
-				innerSubCache.set(identifier, result);
-				return result;
+				function onJson(err, content) {
+					if (err) {
+						if (resolveContext.log)
+							resolveContext.log(
+								descriptionFilePath + " (directory description file): " + err
+							);
+						else
+							err.message =
+								descriptionFilePath + " (directory description file): " + err;
+						return callback(err);
+					}
+					callback(null, {
+						content,
+						directory,
+						path: descriptionFilePath
+					});
+				}
+			},
+			(err, result) => {
+				if (err) return callback(err);
+				if (result) {
+					return callback(null, result);
+				} else {
+					const dir = cdUp(directory);
+					if (!dir) {
+						return callback();
+					} else {
+						directory = dir;
+						return findDescriptionFile();
+					}
+				}
 			}
-		};
-
-		return boundFn;
-	};
-
-	return cachedFn;
-};
-
-/**
- *
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */
-const _makePathsRelative = (context, identifier) => {
-	return identifier
-		.split(SEGMENTS_SPLIT_REGEXP)
-		.map(str => absoluteToRequest(context, str))
-		.join("");
-};
-
-exports.makePathsRelative = makeCacheable(_makePathsRelative);
+		);
+	})();
+}
 
 /**
- *
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
+ * @param {any} content content
+ * @param {string|string[]} field field
+ * @returns {object|string|number|boolean|undefined} field data
  */
-const _makePathsAbsolute = (context, identifier) => {
-	return identifier
-		.split(SEGMENTS_SPLIT_REGEXP)
-		.map(str => requestToAbsolute(context, str))
-		.join("");
-};
-
-exports.makePathsAbsolute = makeCacheable(_makePathsAbsolute);
+function getField(content, field) {
+	if (!content) return undefined;
+	if (Array.isArray(field)) {
+		let current = content;
+		for (let j = 0; j < field.length; j++) {
+			if (current === null || typeof current !== "object") {
+				current = null;
+				break;
+			}
+			current = current[field[j]];
+		}
+		return current;
+	} else {
+		return content[field];
+	}
+}
 
 /**
- * @param {string} context absolute context path
- * @param {string} request any request string may containing absolute paths, query string, etc.
- * @returns {string} a new request string avoiding absolute paths when possible
+ * @param {string} directory directory
+ * @returns {string|null} parent directory or null
  */
-const _contextify = (context, request) => {
-	return request
-		.split("!")
-		.map(r => absoluteToRequest(context, r))
-		.join("!");
-};
+function cdUp(directory) {
+	if (directory === "/") return null;
+	const i = directory.lastIndexOf("/"),
+		j = directory.lastIndexOf("\\");
+	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
+	if (p < 0) return null;
+	return directory.substr(0, p || 1);
+}
 
-const contextify = makeCacheable(_contextify);
-exports.contextify = contextify;
+exports.loadDescriptionFile = loadDescriptionFile;
+exports.getField = getField;
+exports.cdUp = cdUp;
 
-/**
- * @param {string} context absolute context path
- * @param {string} request any request string
- * @returns {string} a new request string using absolute paths when possible
- */
-const _absolutify = (context, request) => {
-	return request
-		.split("!")
-		.map(r => requestToAbsolute(context, r))
-		.join("!");
-};
 
-const absolutify = makeCacheable(_absolutify);
-exports.absolutify = absolutify;
+/***/ }),
 
-const PATH_QUERY_FRAGMENT_REGEXP =
-	/^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+/***/ 60895:
+/***/ (function(module) {
 
-/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * @param {string} str the path with query and fragment
- * @returns {ParsedResource} parsed parts
- */
-const _parseResource = str => {
-	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-	return {
-		resource: str,
-		path: match[1].replace(/\0(.)/g, "$1"),
-		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
-		fragment: match[3] || ""
-	};
-};
-exports.parseResource = (realFn => {
-	/** @type {WeakMap<object, Map<string, ParsedResource>>} */
-	const cache = new WeakMap();
 
-	const getCache = associatedObjectForCache => {
-		const entry = cache.get(associatedObjectForCache);
-		if (entry !== undefined) return entry;
-		/** @type {Map<string, ParsedResource>} */
-		const map = new Map();
-		cache.set(associatedObjectForCache, map);
-		return map;
-	};
 
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class DirectoryExistsPlugin {
 	/**
-	 * @param {string} str the path with query and fragment
-	 * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {ParsedResource} parsed parts
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
 	 */
-	const fn = (str, associatedObjectForCache) => {
-		if (!associatedObjectForCache) return realFn(str);
-		const cache = getCache(associatedObjectForCache);
-		const entry = cache.get(str);
-		if (entry !== undefined) return entry;
-		const result = realFn(str);
-		cache.set(str, result);
-		return result;
-	};
-
-	fn.bindCache = associatedObjectForCache => {
-		const cache = getCache(associatedObjectForCache);
-		return str => {
-			const entry = cache.get(str);
-			if (entry !== undefined) return entry;
-			const result = realFn(str);
-			cache.set(str, result);
-			return result;
-		};
-	};
-
-	return fn;
-})(_parseResource);
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-/**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
- */
-exports.getUndoPath = (filename, outputPath, enforceRelative) => {
-	let depth = -1;
-	let append = "";
-	outputPath = outputPath.replace(/[\\/]$/, "");
-	for (const part of filename.split(/[/\\]+/)) {
-		if (part === "..") {
-			if (depth > -1) {
-				depth--;
-			} else {
-				const i = outputPath.lastIndexOf("/");
-				const j = outputPath.lastIndexOf("\\");
-				const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
-				if (pos < 0) return outputPath + "/";
-				append = outputPath.slice(pos + 1) + "/" + append;
-				outputPath = outputPath.slice(0, pos);
-			}
-		} else if (part !== ".") {
-			depth++;
-		}
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"DirectoryExistsPlugin",
+				(request, resolveContext, callback) => {
+					const fs = resolver.fileSystem;
+					const directory = request.path;
+					if (!directory) return callback();
+					fs.stat(directory, (err, stat) => {
+						if (err || !stat) {
+							if (resolveContext.missingDependencies)
+								resolveContext.missingDependencies.add(directory);
+							if (resolveContext.log)
+								resolveContext.log(directory + " doesn't exist");
+							return callback();
+						}
+						if (!stat.isDirectory()) {
+							if (resolveContext.missingDependencies)
+								resolveContext.missingDependencies.add(directory);
+							if (resolveContext.log)
+								resolveContext.log(directory + " is not a directory");
+							return callback();
+						}
+						if (resolveContext.fileDependencies)
+							resolveContext.fileDependencies.add(directory);
+						resolver.doResolve(
+							target,
+							request,
+							`existing directory ${directory}`,
+							resolveContext,
+							callback
+						);
+					});
+				}
+			);
 	}
-	return depth > 0
-		? `${"../".repeat(depth)}${append}`
-		: enforceRelative
-		? `./${append}`
-		: append;
 };
 
 
 /***/ }),
 
-/***/ 53023:
+/***/ 83849:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-// We need to include a list of requires here
-// to allow webpack to be bundled with only static requires
-// We could use a dynamic require(`../${request}`) but this
-// would include too many modules and not every tool is able
-// to process this
-module.exports = {
-	AsyncDependenciesBlock: () => __webpack_require__(47736),
-	CommentCompilationWarning: () => __webpack_require__(98427),
-	ContextModule: () => __webpack_require__(76729),
-	"cache/PackFileCacheStrategy": () =>
-		__webpack_require__(86180),
-	"cache/ResolverCachePlugin": () => __webpack_require__(97347),
-	"container/ContainerEntryDependency": () =>
-		__webpack_require__(64813),
-	"container/ContainerEntryModule": () =>
-		__webpack_require__(80580),
-	"container/ContainerExposedDependency": () =>
-		__webpack_require__(72374),
-	"container/FallbackDependency": () =>
-		__webpack_require__(57764),
-	"container/FallbackItemDependency": () =>
-		__webpack_require__(29593),
-	"container/FallbackModule": () => __webpack_require__(82886),
-	"container/RemoteModule": () => __webpack_require__(62916),
-	"container/RemoteToExternalDependency": () =>
-		__webpack_require__(14389),
-	"dependencies/AMDDefineDependency": () =>
-		__webpack_require__(96816),
-	"dependencies/AMDRequireArrayDependency": () =>
-		__webpack_require__(33516),
-	"dependencies/AMDRequireContextDependency": () =>
-		__webpack_require__(96123),
-	"dependencies/AMDRequireDependenciesBlock": () =>
-		__webpack_require__(76932),
-	"dependencies/AMDRequireDependency": () =>
-		__webpack_require__(43911),
-	"dependencies/AMDRequireItemDependency": () =>
-		__webpack_require__(71806),
-	"dependencies/CachedConstDependency": () =>
-		__webpack_require__(57403),
-	"dependencies/CreateScriptUrlDependency": () =>
-		__webpack_require__(79062),
-	"dependencies/CommonJsRequireContextDependency": () =>
-		__webpack_require__(23962),
-	"dependencies/CommonJsExportRequireDependency": () =>
-		__webpack_require__(62892),
-	"dependencies/CommonJsExportsDependency": () =>
-		__webpack_require__(45598),
-	"dependencies/CommonJsFullRequireDependency": () =>
-		__webpack_require__(59440),
-	"dependencies/CommonJsRequireDependency": () =>
-		__webpack_require__(21264),
-	"dependencies/CommonJsSelfReferenceDependency": () =>
-		__webpack_require__(52225),
-	"dependencies/ConstDependency": () =>
-		__webpack_require__(76911),
-	"dependencies/ContextDependency": () =>
-		__webpack_require__(88101),
-	"dependencies/ContextElementDependency": () =>
-		__webpack_require__(58477),
-	"dependencies/CriticalDependencyWarning": () =>
-		__webpack_require__(15427),
-	"dependencies/CssImportDependency": () =>
-		__webpack_require__(90542),
-	"dependencies/CssLocalIdentifierDependency": () =>
-		__webpack_require__(92328),
-	"dependencies/CssSelfLocalIdentifierDependency": () =>
-		__webpack_require__(29094),
-	"dependencies/CssExportDependency": () =>
-		__webpack_require__(76760),
-	"dependencies/CssUrlDependency": () =>
-		__webpack_require__(70749),
-	"dependencies/DelegatedSourceDependency": () =>
-		__webpack_require__(22914),
-	"dependencies/DllEntryDependency": () =>
-		__webpack_require__(95666),
-	"dependencies/EntryDependency": () =>
-		__webpack_require__(3979),
-	"dependencies/ExportsInfoDependency": () =>
-		__webpack_require__(78988),
-	"dependencies/HarmonyAcceptDependency": () =>
-		__webpack_require__(23624),
-	"dependencies/HarmonyAcceptImportDependency": () =>
-		__webpack_require__(99843),
-	"dependencies/HarmonyCompatibilityDependency": () =>
-		__webpack_require__(72906),
-	"dependencies/HarmonyExportExpressionDependency": () =>
-		__webpack_require__(51340),
-	"dependencies/HarmonyExportHeaderDependency": () =>
-		__webpack_require__(38873),
-	"dependencies/HarmonyExportImportedSpecifierDependency": () =>
-		__webpack_require__(67157),
-	"dependencies/HarmonyExportSpecifierDependency": () =>
-		__webpack_require__(48567),
-	"dependencies/HarmonyImportSideEffectDependency": () =>
-		__webpack_require__(73132),
-	"dependencies/HarmonyImportSpecifierDependency": () =>
-		__webpack_require__(14077),
-	"dependencies/ImportContextDependency": () =>
-		__webpack_require__(1902),
-	"dependencies/ImportDependency": () =>
-		__webpack_require__(89376),
-	"dependencies/ImportEagerDependency": () =>
-		__webpack_require__(50718),
-	"dependencies/ImportWeakDependency": () =>
-		__webpack_require__(82483),
-	"dependencies/JsonExportsDependency": () =>
-		__webpack_require__(750),
-	"dependencies/LocalModule": () => __webpack_require__(5826),
-	"dependencies/LocalModuleDependency": () =>
-		__webpack_require__(52805),
-	"dependencies/ModuleDecoratorDependency": () =>
-		__webpack_require__(88488),
-	"dependencies/ModuleHotAcceptDependency": () =>
-		__webpack_require__(47511),
-	"dependencies/ModuleHotDeclineDependency": () =>
-		__webpack_require__(86301),
-	"dependencies/ImportMetaHotAcceptDependency": () =>
-		__webpack_require__(51274),
-	"dependencies/ImportMetaHotDeclineDependency": () =>
-		__webpack_require__(53141),
-	"dependencies/ProvidedDependency": () =>
-		__webpack_require__(95770),
-	"dependencies/PureExpressionDependency": () =>
-		__webpack_require__(55799),
-	"dependencies/RequireContextDependency": () =>
-		__webpack_require__(46917),
-	"dependencies/RequireEnsureDependenciesBlock": () =>
-		__webpack_require__(27153),
-	"dependencies/RequireEnsureDependency": () =>
-		__webpack_require__(27223),
-	"dependencies/RequireEnsureItemDependency": () =>
-		__webpack_require__(50329),
-	"dependencies/RequireHeaderDependency": () =>
-		__webpack_require__(89183),
-	"dependencies/RequireIncludeDependency": () =>
-		__webpack_require__(71284),
-	"dependencies/RequireIncludeDependencyParserPlugin": () =>
-		__webpack_require__(35768),
-	"dependencies/RequireResolveContextDependency": () =>
-		__webpack_require__(55627),
-	"dependencies/RequireResolveDependency": () =>
-		__webpack_require__(68582),
-	"dependencies/RequireResolveHeaderDependency": () =>
-		__webpack_require__(9880),
-	"dependencies/RuntimeRequirementsDependency": () =>
-		__webpack_require__(24187),
-	"dependencies/StaticExportsDependency": () =>
-		__webpack_require__(91418),
-	"dependencies/SystemPlugin": () => __webpack_require__(97981),
-	"dependencies/UnsupportedDependency": () =>
-		__webpack_require__(51669),
-	"dependencies/URLDependency": () => __webpack_require__(58612),
-	"dependencies/WebAssemblyExportImportedDependency": () =>
-		__webpack_require__(52204),
-	"dependencies/WebAssemblyImportDependency": () =>
-		__webpack_require__(5239),
-	"dependencies/WebpackIsIncludedDependency": () =>
-		__webpack_require__(26505),
-	"dependencies/WorkerDependency": () =>
-		__webpack_require__(1466),
-	"json/JsonData": () => __webpack_require__(90490),
-	"optimize/ConcatenatedModule": () =>
-		__webpack_require__(97198),
-	DelegatedModule: () => __webpack_require__(28623),
-	DependenciesBlock: () => __webpack_require__(71040),
-	DllModule: () => __webpack_require__(28280),
-	ExternalModule: () => __webpack_require__(73071),
-	FileSystemInfo: () => __webpack_require__(79453),
-	InitFragment: () => __webpack_require__(55870),
-	InvalidDependenciesModuleWarning: () =>
-		__webpack_require__(68257),
-	Module: () => __webpack_require__(73208),
-	ModuleBuildError: () => __webpack_require__(21305),
-	ModuleDependencyWarning: () => __webpack_require__(29656),
-	ModuleError: () => __webpack_require__(23744),
-	ModuleGraph: () => __webpack_require__(99988),
-	ModuleParseError: () => __webpack_require__(58443),
-	ModuleWarning: () => __webpack_require__(11234),
-	NormalModule: () => __webpack_require__(39),
-	RawDataUrlModule: () => __webpack_require__(19684),
-	RawModule: () => __webpack_require__(84929),
-	"sharing/ConsumeSharedModule": () =>
-		__webpack_require__(62286),
-	"sharing/ConsumeSharedFallbackDependency": () =>
-		__webpack_require__(58831),
-	"sharing/ProvideSharedModule": () =>
-		__webpack_require__(50821),
-	"sharing/ProvideSharedDependency": () =>
-		__webpack_require__(1798),
-	"sharing/ProvideForSharedDependency": () =>
-		__webpack_require__(40017),
-	UnsupportedFeatureWarning: () => __webpack_require__(42495),
-	"util/LazySet": () => __webpack_require__(38938),
-	UnhandledSchemeError: () => __webpack_require__(68099),
-	NodeStuffInWebError: () => __webpack_require__(6325),
-	WebpackError: () => __webpack_require__(53799),
+const path = __webpack_require__(71017);
+const DescriptionFileUtils = __webpack_require__(25424);
+const forEachBail = __webpack_require__(78565);
+const { processExportsField } = __webpack_require__(55863);
+const { parseIdentifier } = __webpack_require__(71053);
+const { checkExportsFieldTarget } = __webpack_require__(67079);
 
-	"util/registerExternalSerializer": () => {
-		// already registered
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./util/entrypoints").ExportsField} ExportsField */
+/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
+
+module.exports = class ExportsFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Set<string>} conditionNames condition names
+	 * @param {string | string[]} fieldNamePath name path
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, conditionNames, fieldNamePath, target) {
+		this.source = source;
+		this.target = target;
+		this.conditionNames = conditionNames;
+		this.fieldName = fieldNamePath;
+		/** @type {WeakMap<any, FieldProcessor>} */
+		this.fieldProcessorCache = new WeakMap();
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ExportsFieldPlugin", (request, resolveContext, callback) => {
+				// When there is no description file, abort
+				if (!request.descriptionFilePath) return callback();
+				if (
+					// When the description file is inherited from parent, abort
+					// (There is no description file inside of this package)
+					request.relativePath !== "." ||
+					request.request === undefined
+				)
+					return callback();
+
+				const remainingRequest =
+					request.query || request.fragment
+						? (request.request === "." ? "./" : request.request) +
+						  request.query +
+						  request.fragment
+						: request.request;
+				/** @type {ExportsField|null} */
+				const exportsField = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.fieldName
+				);
+				if (!exportsField) return callback();
+
+				if (request.directory) {
+					return callback(
+						new Error(
+							`Resolving to directories is not possible with the exports field (request was ${remainingRequest}/)`
+						)
+					);
+				}
+
+				let paths;
+
+				try {
+					// We attach the cache to the description file instead of the exportsField value
+					// because we use a WeakMap and the exportsField could be a string too.
+					// Description file is always an object when exports field can be accessed.
+					let fieldProcessor = this.fieldProcessorCache.get(
+						request.descriptionFileData
+					);
+					if (fieldProcessor === undefined) {
+						fieldProcessor = processExportsField(exportsField);
+						this.fieldProcessorCache.set(
+							request.descriptionFileData,
+							fieldProcessor
+						);
+					}
+					paths = fieldProcessor(remainingRequest, this.conditionNames);
+				} catch (err) {
+					if (resolveContext.log) {
+						resolveContext.log(
+							`Exports field in ${request.descriptionFilePath} can't be processed: ${err}`
+						);
+					}
+					return callback(err);
+				}
+
+				if (paths.length === 0) {
+					return callback(
+						new Error(
+							`Package path ${remainingRequest} is not exported from package ${request.descriptionFileRoot} (see exports field in ${request.descriptionFilePath})`
+						)
+					);
+				}
+
+				forEachBail(
+					paths,
+					(p, callback) => {
+						const parsedIdentifier = parseIdentifier(p);
+
+						if (!parsedIdentifier) return callback();
+
+						const [relativePath, query, fragment] = parsedIdentifier;
+
+						const error = checkExportsFieldTarget(relativePath);
+
+						if (error) {
+							return callback(error);
+						}
+
+						const obj = {
+							...request,
+							request: undefined,
+							path: path.join(
+								/** @type {string} */ (request.descriptionFileRoot),
+								relativePath
+							),
+							relativePath,
+							query,
+							fragment
+						};
+
+						resolver.doResolve(
+							target,
+							obj,
+							"using exports field: " + p,
+							resolveContext,
+							callback
+						);
+					},
+					(err, result) => callback(err, result || null)
+				);
+			});
 	}
 };
 
 
 /***/ }),
 
-/***/ 33032:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 50295:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const { register } = __webpack_require__(8282);
-
-class ClassSerializer {
-	constructor(Constructor) {
-		this.Constructor = Constructor;
-	}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-	serialize(obj, context) {
-		obj.serialize(context);
+module.exports = class FileExistsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
 	}
 
-	deserialize(context) {
-		if (typeof this.Constructor.deserialize === "function") {
-			return this.Constructor.deserialize(context);
-		}
-		const obj = new this.Constructor();
-		obj.deserialize(context);
-		return obj;
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const fs = resolver.fileSystem;
+		resolver
+			.getHook(this.source)
+			.tapAsync("FileExistsPlugin", (request, resolveContext, callback) => {
+				const file = request.path;
+				if (!file) return callback();
+				fs.stat(file, (err, stat) => {
+					if (err || !stat) {
+						if (resolveContext.missingDependencies)
+							resolveContext.missingDependencies.add(file);
+						if (resolveContext.log) resolveContext.log(file + " doesn't exist");
+						return callback();
+					}
+					if (!stat.isFile()) {
+						if (resolveContext.missingDependencies)
+							resolveContext.missingDependencies.add(file);
+						if (resolveContext.log) resolveContext.log(file + " is not a file");
+						return callback();
+					}
+					if (resolveContext.fileDependencies)
+						resolveContext.fileDependencies.add(file);
+					resolver.doResolve(
+						target,
+						request,
+						"existing file: " + file,
+						resolveContext,
+						callback
+					);
+				});
+			});
 	}
-}
-
-module.exports = (Constructor, request, name = null) => {
-	register(Constructor, request, name, new ClassSerializer(Constructor));
 };
 
 
 /***/ }),
 
-/***/ 78676:
-/***/ (function(module) {
+/***/ 7317:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-/** @template T @typedef {function(): T} FunctionReturning */
+const path = __webpack_require__(71017);
+const DescriptionFileUtils = __webpack_require__(25424);
+const forEachBail = __webpack_require__(78565);
+const { processImportsField } = __webpack_require__(55863);
+const { parseIdentifier } = __webpack_require__(71053);
 
-/**
- * @template T
- * @param {FunctionReturning<T>} fn memorized function
- * @returns {FunctionReturning<T>} new function
- */
-const memoize = fn => {
-	let cache = false;
-	/** @type {T} */
-	let result = undefined;
-	return () => {
-		if (cache) {
-			return result;
-		} else {
-			result = fn();
-			cache = true;
-			// Allow to clean up memory for fn
-			// and all dependent resources
-			fn = undefined;
-			return result;
-		}
-	};
-};
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./util/entrypoints").FieldProcessor} FieldProcessor */
+/** @typedef {import("./util/entrypoints").ImportsField} ImportsField */
 
-module.exports = memoize;
+const dotCode = ".".charCodeAt(0);
+
+module.exports = class ImportsFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Set<string>} conditionNames condition names
+	 * @param {string | string[]} fieldNamePath name path
+	 * @param {string | ResolveStepHook} targetFile target file
+	 * @param {string | ResolveStepHook} targetPackage target package
+	 */
+	constructor(
+		source,
+		conditionNames,
+		fieldNamePath,
+		targetFile,
+		targetPackage
+	) {
+		this.source = source;
+		this.targetFile = targetFile;
+		this.targetPackage = targetPackage;
+		this.conditionNames = conditionNames;
+		this.fieldName = fieldNamePath;
+		/** @type {WeakMap<any, FieldProcessor>} */
+		this.fieldProcessorCache = new WeakMap();
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const targetFile = resolver.ensureHook(this.targetFile);
+		const targetPackage = resolver.ensureHook(this.targetPackage);
+
+		resolver
+			.getHook(this.source)
+			.tapAsync("ImportsFieldPlugin", (request, resolveContext, callback) => {
+				// When there is no description file, abort
+				if (!request.descriptionFilePath || request.request === undefined) {
+					return callback();
+				}
+
+				const remainingRequest =
+					request.request + request.query + request.fragment;
+				/** @type {ImportsField|null} */
+				const importsField = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.fieldName
+				);
+				if (!importsField) return callback();
+
+				if (request.directory) {
+					return callback(
+						new Error(
+							`Resolving to directories is not possible with the imports field (request was ${remainingRequest}/)`
+						)
+					);
+				}
+
+				let paths;
+
+				try {
+					// We attach the cache to the description file instead of the importsField value
+					// because we use a WeakMap and the importsField could be a string too.
+					// Description file is always an object when exports field can be accessed.
+					let fieldProcessor = this.fieldProcessorCache.get(
+						request.descriptionFileData
+					);
+					if (fieldProcessor === undefined) {
+						fieldProcessor = processImportsField(importsField);
+						this.fieldProcessorCache.set(
+							request.descriptionFileData,
+							fieldProcessor
+						);
+					}
+					paths = fieldProcessor(remainingRequest, this.conditionNames);
+				} catch (err) {
+					if (resolveContext.log) {
+						resolveContext.log(
+							`Imports field in ${request.descriptionFilePath} can't be processed: ${err}`
+						);
+					}
+					return callback(err);
+				}
+
+				if (paths.length === 0) {
+					return callback(
+						new Error(
+							`Package import ${remainingRequest} is not imported from package ${request.descriptionFileRoot} (see imports field in ${request.descriptionFilePath})`
+						)
+					);
+				}
+
+				forEachBail(
+					paths,
+					(p, callback) => {
+						const parsedIdentifier = parseIdentifier(p);
+
+						if (!parsedIdentifier) return callback();
+
+						const [path_, query, fragment] = parsedIdentifier;
+
+						switch (path_.charCodeAt(0)) {
+							// should be relative
+							case dotCode: {
+								const obj = {
+									...request,
+									request: undefined,
+									path: path.join(
+										/** @type {string} */ (request.descriptionFileRoot),
+										path_
+									),
+									relativePath: path_,
+									query,
+									fragment
+								};
+
+								resolver.doResolve(
+									targetFile,
+									obj,
+									"using imports field: " + p,
+									resolveContext,
+									callback
+								);
+								break;
+							}
+
+							// package resolving
+							default: {
+								const obj = {
+									...request,
+									request: path_,
+									relativePath: path_,
+									fullySpecified: true,
+									query,
+									fragment
+								};
+
+								resolver.doResolve(
+									targetPackage,
+									obj,
+									"using imports field: " + p,
+									resolveContext,
+									callback
+								);
+							}
+						}
+					},
+					(err, result) => callback(err, result || null)
+				);
+			});
+	}
+};
 
 
 /***/ }),
 
-/***/ 70002:
+/***/ 35949:
 /***/ (function(module) {
 
 "use strict";
@@ -134649,49 +135180,68 @@ module.exports = memoize;
 
 
 
-const SAFE_LIMIT = 0x80000000;
-const SAFE_PART = SAFE_LIMIT - 1;
-const COUNT = 4;
-const arr = [0, 0, 0, 0, 0];
-const primes = [3, 7, 17, 19];
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-module.exports = (str, range) => {
-	arr.fill(0);
-	for (let i = 0; i < str.length; i++) {
-		const c = str.charCodeAt(i);
-		for (let j = 0; j < COUNT; j++) {
-			const p = (j + COUNT - 1) % COUNT;
-			arr[j] = (arr[j] + c * primes[j] + arr[p]) & SAFE_PART;
-		}
-		for (let j = 0; j < COUNT; j++) {
-			const q = arr[j] % COUNT;
-			arr[j] = arr[j] ^ (arr[q] >> 1);
-		}
+const namespaceStartCharCode = "@".charCodeAt(0);
+
+module.exports = class JoinRequestPartPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
 	}
-	if (range <= SAFE_PART) {
-		let sum = 0;
-		for (let j = 0; j < COUNT; j++) {
-			sum = (sum + arr[j]) % range;
-		}
-		return sum;
-	} else {
-		let sum1 = 0;
-		let sum2 = 0;
-		const rangeExt = Math.floor(range / SAFE_LIMIT);
-		for (let j = 0; j < COUNT; j += 2) {
-			sum1 = (sum1 + arr[j]) & SAFE_PART;
-		}
-		for (let j = 1; j < COUNT; j += 2) {
-			sum2 = (sum2 + arr[j]) % rangeExt;
-		}
-		return (sum2 * SAFE_LIMIT + sum1) % range;
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"JoinRequestPartPlugin",
+				(request, resolveContext, callback) => {
+					const req = request.request || "";
+					let i = req.indexOf("/", 3);
+
+					if (i >= 0 && req.charCodeAt(2) === namespaceStartCharCode) {
+						i = req.indexOf("/", i + 1);
+					}
+
+					let moduleName, remainingRequest, fullySpecified;
+					if (i < 0) {
+						moduleName = req;
+						remainingRequest = ".";
+						fullySpecified = false;
+					} else {
+						moduleName = req.slice(0, i);
+						remainingRequest = "." + req.slice(i);
+						fullySpecified = request.fullySpecified;
+					}
+					const obj = {
+						...request,
+						path: resolver.join(request.path, moduleName),
+						relativePath:
+							request.relativePath &&
+							resolver.join(request.relativePath, moduleName),
+						request: remainingRequest,
+						fullySpecified
+					};
+					resolver.doResolve(target, obj, null, resolveContext, callback);
+				}
+			);
 	}
 };
 
 
 /***/ }),
 
-/***/ 42791:
+/***/ 5190:
 /***/ (function(module) {
 
 "use strict";
@@ -134702,66 +135252,45 @@ module.exports = (str, range) => {
 
 
 
-/**
- * @template T
- * @template {Error} E
- * @param {Iterable<T>} items initial items
- * @param {number} concurrency number of items running in parallel
- * @param {function(T, function(T): void, function(E=): void): void} processor worker which pushes more items
- * @param {function(E=): void} callback all items processed
- * @returns {void}
- */
-const processAsyncTree = (items, concurrency, processor, callback) => {
-	const queue = Array.from(items);
-	if (queue.length === 0) return callback();
-	let processing = 0;
-	let finished = false;
-	let processScheduled = true;
-
-	const push = item => {
-		queue.push(item);
-		if (!processScheduled && processing < concurrency) {
-			processScheduled = true;
-			process.nextTick(processQueue);
-		}
-	};
-
-	const processorCallback = err => {
-		processing--;
-		if (err && !finished) {
-			finished = true;
-			callback(err);
-			return;
-		}
-		if (!processScheduled) {
-			processScheduled = true;
-			process.nextTick(processQueue);
-		}
-	};
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-	const processQueue = () => {
-		if (finished) return;
-		while (processing < concurrency && queue.length > 0) {
-			processing++;
-			const item = queue.pop();
-			processor(item, push, processorCallback);
-		}
-		processScheduled = false;
-		if (queue.length === 0 && processing === 0 && !finished) {
-			finished = true;
-			callback();
-		}
-	};
+module.exports = class JoinRequestPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-	processQueue();
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("JoinRequestPlugin", (request, resolveContext, callback) => {
+				const obj = {
+					...request,
+					path: resolver.join(request.path, request.request),
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, request.request),
+					request: undefined
+				};
+				resolver.doResolve(target, obj, null, resolveContext, callback);
+			});
+	}
 };
 
-module.exports = processAsyncTree;
-
 
 /***/ }),
 
-/***/ 54190:
+/***/ 5049:
 /***/ (function(module) {
 
 "use strict";
@@ -134772,83 +135301,55 @@ module.exports = processAsyncTree;
 
 
 
-const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
-const RESERVED_IDENTIFIER = new Set([
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"export",
-	"extends",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"import",
-	"in",
-	"instanceof",
-	"new",
-	"return",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"while",
-	"with",
-	"enum",
-	// strict mode
-	"implements",
-	"interface",
-	"let",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"static",
-	"yield",
-	"yield",
-	// module code
-	"await",
-	// skip future reserved keywords defined under ES1 till ES3
-	// additional
-	"null",
-	"true",
-	"false"
-]);
+/** @typedef {import("./Resolver")} Resolver */
 
-const propertyAccess = (properties, start = 0) => {
-	let str = "";
-	for (let i = start; i < properties.length; i++) {
-		const p = properties[i];
-		if (`${+p}` === p) {
-			str += `[${p}]`;
-		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
-			str += `.${p}`;
-		} else {
-			str += `[${JSON.stringify(p)}]`;
-		}
+module.exports = class LogInfoPlugin {
+	constructor(source) {
+		this.source = source;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const source = this.source;
+		resolver
+			.getHook(this.source)
+			.tapAsync("LogInfoPlugin", (request, resolveContext, callback) => {
+				if (!resolveContext.log) return callback();
+				const log = resolveContext.log;
+				const prefix = "[" + source + "] ";
+				if (request.path)
+					log(prefix + "Resolving in directory: " + request.path);
+				if (request.request)
+					log(prefix + "Resolving request: " + request.request);
+				if (request.module) log(prefix + "Request is an module request.");
+				if (request.directory) log(prefix + "Request is a directory request.");
+				if (request.query)
+					log(prefix + "Resolving request query: " + request.query);
+				if (request.fragment)
+					log(prefix + "Resolving request fragment: " + request.fragment);
+				if (request.descriptionFilePath)
+					log(
+						prefix + "Has description data from " + request.descriptionFilePath
+					);
+				if (request.relativePath)
+					log(
+						prefix +
+							"Relative path from description file is: " +
+							request.relativePath
+					);
+				callback();
+			});
 	}
-	return str;
 };
 
-module.exports = propertyAccess;
-
 
 /***/ }),
 
-/***/ 26611:
-/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+/***/ 47450:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -134858,342 +135359,229 @@ module.exports = propertyAccess;
 
 
 
-const { register } = __webpack_require__(8282);
+const path = __webpack_require__(71017);
+const DescriptionFileUtils = __webpack_require__(25424);
 
-const Position = /** @type {TODO} */ (__webpack_require__(31988).Position);
-const SourceLocation = (__webpack_require__(31988).SourceLocation);
-const ValidationError = (__webpack_require__(54983)/* ["default"] */ .Z);
-const {
-	CachedSource,
-	ConcatSource,
-	OriginalSource,
-	PrefixSource,
-	RawSource,
-	ReplaceSource,
-	SourceMapSource
-} = __webpack_require__(51255);
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{name: string|Array<string>, forceRelative: boolean}} MainFieldOptions */
 
-/** @typedef {import("acorn").Position} Position */
-/** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
-/** @typedef {import("./serialization").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization").ObjectSerializerContext} ObjectSerializerContext */
+const alreadyTriedMainField = Symbol("alreadyTriedMainField");
 
-/** @typedef {ObjectSerializerContext & { writeLazy?: (any) => void }} WebpackObjectSerializerContext */
+module.exports = class MainFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {MainFieldOptions} options options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, options, target) {
+		this.source = source;
+		this.options = options;
+		this.target = target;
+	}
 
-const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("MainFieldPlugin", (request, resolveContext, callback) => {
+				if (
+					request.path !== request.descriptionFileRoot ||
+					request[alreadyTriedMainField] === request.descriptionFilePath ||
+					!request.descriptionFilePath
+				)
+					return callback();
+				const filename = path.basename(request.descriptionFilePath);
+				let mainModule = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.options.name
+				);
 
-register(
-	CachedSource,
-	CURRENT_MODULE,
-	"webpack-sources/CachedSource",
-	new (class CachedSourceSerializer {
-		/**
-		 * @param {CachedSource} source the cached source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write, writeLazy }) {
-			if (writeLazy) {
-				writeLazy(source.originalLazy());
-			} else {
-				write(source.original());
-			}
-			write(source.getCachedData());
-		}
+				if (
+					!mainModule ||
+					typeof mainModule !== "string" ||
+					mainModule === "." ||
+					mainModule === "./"
+				) {
+					return callback();
+				}
+				if (this.options.forceRelative && !/^\.\.?\//.test(mainModule))
+					mainModule = "./" + mainModule;
+				const obj = {
+					...request,
+					request: mainModule,
+					module: false,
+					directory: mainModule.endsWith("/"),
+					[alreadyTriedMainField]: request.descriptionFilePath
+				};
+				return resolver.doResolve(
+					target,
+					obj,
+					"use " +
+						mainModule +
+						" from " +
+						this.options.name +
+						" in " +
+						filename,
+					resolveContext,
+					callback
+				);
+			});
+	}
+};
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {CachedSource} cached source
-		 */
-		deserialize({ read }) {
-			const source = read();
-			const cachedData = read();
-			return new CachedSource(source, cachedData);
-		}
-	})()
-);
 
-register(
-	RawSource,
-	CURRENT_MODULE,
-	"webpack-sources/RawSource",
-	new (class RawSourceSerializer {
-		/**
-		 * @param {RawSource} source the raw source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.buffer());
-			write(!source.isBuffer());
-		}
+/***/ }),
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {RawSource} raw source
-		 */
-		deserialize({ read }) {
-			const source = read();
-			const convertToString = read();
-			return new RawSource(source, convertToString);
-		}
-	})()
-);
+/***/ 48506:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-register(
-	ConcatSource,
-	CURRENT_MODULE,
-	"webpack-sources/ConcatSource",
-	new (class ConcatSourceSerializer {
-		/**
-		 * @param {ConcatSource} source the concat source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.getChildren());
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {ConcatSource} concat source
-		 */
-		deserialize({ read }) {
-			const source = new ConcatSource();
-			source.addAllSkipOptimizing(read());
-			return source;
-		}
-	})()
-);
 
-register(
-	PrefixSource,
-	CURRENT_MODULE,
-	"webpack-sources/PrefixSource",
-	new (class PrefixSourceSerializer {
-		/**
-		 * @param {PrefixSource} source the prefix source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.getPrefix());
-			write(source.original());
-		}
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {PrefixSource} prefix source
-		 */
-		deserialize({ read }) {
-			return new PrefixSource(read(), read());
-		}
-	})()
-);
+const forEachBail = __webpack_require__(78565);
+const getPaths = __webpack_require__(82918);
 
-register(
-	ReplaceSource,
-	CURRENT_MODULE,
-	"webpack-sources/ReplaceSource",
-	new (class ReplaceSourceSerializer {
-		/**
-		 * @param {ReplaceSource} source the replace source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.original());
-			write(source.getName());
-			const replacements = source.getReplacements();
-			write(replacements.length);
-			for (const repl of replacements) {
-				write(repl.start);
-				write(repl.end);
-			}
-			for (const repl of replacements) {
-				write(repl.content);
-				write(repl.name);
-			}
-		}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {ReplaceSource} replace source
-		 */
-		deserialize({ read }) {
-			const source = new ReplaceSource(read(), read());
-			const len = read();
-			const startEndBuffer = [];
-			for (let i = 0; i < len; i++) {
-				startEndBuffer.push(read(), read());
-			}
-			let j = 0;
-			for (let i = 0; i < len; i++) {
-				source.replace(
-					startEndBuffer[j++],
-					startEndBuffer[j++],
-					read(),
-					read()
-				);
-			}
-			return source;
-		}
-	})()
-);
+module.exports = class ModulesInHierachicDirectoriesPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | Array<string>} directories directories
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, directories, target) {
+		this.source = source;
+		this.directories = /** @type {Array<string>} */ ([]).concat(directories);
+		this.target = target;
+	}
 
-register(
-	OriginalSource,
-	CURRENT_MODULE,
-	"webpack-sources/OriginalSource",
-	new (class OriginalSourceSerializer {
-		/**
-		 * @param {OriginalSource} source the original source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.buffer());
-			write(source.getName());
-		}
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync(
+				"ModulesInHierachicDirectoriesPlugin",
+				(request, resolveContext, callback) => {
+					const fs = resolver.fileSystem;
+					const addrs = getPaths(request.path)
+						.paths.map(p => {
+							return this.directories.map(d => resolver.join(p, d));
+						})
+						.reduce((array, p) => {
+							array.push.apply(array, p);
+							return array;
+						}, []);
+					forEachBail(
+						addrs,
+						(addr, callback) => {
+							fs.stat(addr, (err, stat) => {
+								if (!err && stat && stat.isDirectory()) {
+									const obj = {
+										...request,
+										path: addr,
+										request: "./" + request.request,
+										module: false
+									};
+									const message = "looking for modules in " + addr;
+									return resolver.doResolve(
+										target,
+										obj,
+										message,
+										resolveContext,
+										callback
+									);
+								}
+								if (resolveContext.log)
+									resolveContext.log(
+										addr + " doesn't exist or is not a directory"
+									);
+								if (resolveContext.missingDependencies)
+									resolveContext.missingDependencies.add(addr);
+								return callback();
+							});
+						},
+						callback
+					);
+				}
+			);
+	}
+};
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {OriginalSource} original source
-		 */
-		deserialize({ read }) {
-			const buffer = read();
-			const name = read();
-			return new OriginalSource(buffer, name);
-		}
-	})()
-);
 
-register(
-	SourceLocation,
-	CURRENT_MODULE,
-	"acorn/SourceLocation",
-	new (class SourceLocationSerializer {
-		/**
-		 * @param {SourceLocation} loc the location to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(loc, { write }) {
-			write(loc.start.line);
-			write(loc.start.column);
-			write(loc.end.line);
-			write(loc.end.column);
-		}
+/***/ }),
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {RealDependencyLocation} location
-		 */
-		deserialize({ read }) {
-			return {
-				start: {
-					line: read(),
-					column: read()
-				},
-				end: {
-					line: read(),
-					column: read()
-				}
-			};
-		}
-	})()
-);
+/***/ 88138:
+/***/ (function(module) {
 
-register(
-	Position,
-	CURRENT_MODULE,
-	"acorn/Position",
-	new (class PositionSerializer {
-		/**
-		 * @param {Position} pos the position to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(pos, { write }) {
-			write(pos.line);
-			write(pos.column);
-		}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {SourcePosition} position
-		 */
-		deserialize({ read }) {
-			return {
-				line: read(),
-				column: read()
-			};
-		}
-	})()
-);
 
-register(
-	SourceMapSource,
-	CURRENT_MODULE,
-	"webpack-sources/SourceMapSource",
-	new (class SourceMapSourceSerializer {
-		/**
-		 * @param {SourceMapSource} source the source map source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(source, { write }) {
-			write(source.getArgsAsBuffers());
-		}
 
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {SourceMapSource} source source map source
-		 */
-		deserialize({ read }) {
-			// @ts-expect-error
-			return new SourceMapSource(...read());
-		}
-	})()
-);
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-register(
-	ValidationError,
-	CURRENT_MODULE,
-	"schema-utils/ValidationError",
-	new (class ValidationErrorSerializer {
-		// TODO error should be ValidationError, but this fails the type checks
-		/**
-		 * @param {TODO} error the source map source to be serialized
-		 * @param {WebpackObjectSerializerContext} context context
-		 * @returns {void}
-		 */
-		serialize(error, { write }) {
-			write(error.errors);
-			write(error.schema);
-			write({
-				name: error.headerName,
-				baseDataPath: error.baseDataPath,
-				postFormatter: error.postFormatter
+module.exports = class ModulesInRootPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} path path
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, path, target) {
+		this.source = source;
+		this.path = path;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ModulesInRootPlugin", (request, resolveContext, callback) => {
+				const obj = {
+					...request,
+					path: this.path,
+					request: "./" + request.request,
+					module: false
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"looking for modules in " + this.path,
+					resolveContext,
+					callback
+				);
 			});
-		}
-
-		/**
-		 * @param {ObjectDeserializerContext} context context
-		 * @returns {TODO} error
-		 */
-		deserialize({ read }) {
-			return new ValidationError(read(), read(), read());
-		}
-	})()
-);
+	}
+};
 
 
 /***/ }),
 
-/***/ 17156:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 40777:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -135203,628 +135591,714 @@ register(
 
 
 
-const SortableSet = __webpack_require__(13098);
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+module.exports = class NextPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-/** @typedef {string | SortableSet<string> | undefined} RuntimeSpec */
-/** @typedef {RuntimeSpec | boolean} RuntimeCondition */
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("NextPlugin", (request, resolveContext, callback) => {
+				resolver.doResolve(target, request, null, resolveContext, callback);
+			});
+	}
+};
 
-/**
- * @param {Compilation} compilation the compilation
- * @param {string} name name of the entry
- * @param {EntryOptions=} options optionally already received entry options
- * @returns {RuntimeSpec} runtime
- */
-exports.getEntryRuntime = (compilation, name, options) => {
-	let dependOn;
-	let runtime;
-	if (options) {
-		({ dependOn, runtime } = options);
-	} else {
-		const entry = compilation.entries.get(name);
-		if (!entry) return name;
-		({ dependOn, runtime } = entry.options);
+
+/***/ }),
+
+/***/ 97849:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class ParsePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Partial<ResolveRequest>} requestOptions request options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, requestOptions, target) {
+		this.source = source;
+		this.requestOptions = requestOptions;
+		this.target = target;
 	}
-	if (dependOn) {
-		/** @type {RuntimeSpec} */
-		let result = undefined;
-		const queue = new Set(dependOn);
-		for (const name of queue) {
-			const dep = compilation.entries.get(name);
-			if (!dep) continue;
-			const { dependOn, runtime } = dep.options;
-			if (dependOn) {
-				for (const name of dependOn) {
-					queue.add(name);
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("ParsePlugin", (request, resolveContext, callback) => {
+				const parsed = resolver.parse(/** @type {string} */ (request.request));
+				const obj = { ...request, ...parsed, ...this.requestOptions };
+				if (request.query && !parsed.query) {
+					obj.query = request.query;
 				}
-			} else {
-				result = mergeRuntimeOwned(result, runtime || name);
-			}
-		}
-		return result || name;
-	} else {
-		return runtime || name;
+				if (request.fragment && !parsed.fragment) {
+					obj.fragment = request.fragment;
+				}
+				if (parsed && resolveContext.log) {
+					if (parsed.module) resolveContext.log("Parsed request is a module");
+					if (parsed.directory)
+						resolveContext.log("Parsed request is a directory");
+				}
+				// There is an edge-case where a request with # can be a path or a fragment -> try both
+				if (obj.request && !obj.query && obj.fragment) {
+					const directory = obj.fragment.endsWith("/");
+					const alternative = {
+						...obj,
+						directory,
+						request:
+							obj.request +
+							(obj.directory ? "/" : "") +
+							(directory ? obj.fragment.slice(0, -1) : obj.fragment),
+						fragment: ""
+					};
+					resolver.doResolve(
+						target,
+						alternative,
+						null,
+						resolveContext,
+						(err, result) => {
+							if (err) return callback(err);
+							if (result) return callback(null, result);
+							resolver.doResolve(target, obj, null, resolveContext, callback);
+						}
+					);
+					return;
+				}
+				resolver.doResolve(target, obj, null, resolveContext, callback);
+			});
 	}
 };
 
-/**
- * @param {RuntimeSpec} runtime runtime
- * @param {function(string): void} fn functor
- * @param {boolean} deterministicOrder enforce a deterministic order
- * @returns {void}
- */
-exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
-	if (runtime === undefined) {
-		fn(undefined);
-	} else if (typeof runtime === "string") {
-		fn(runtime);
-	} else {
-		if (deterministicOrder) runtime.sort();
-		for (const r of runtime) {
-			fn(r);
-		}
-	}
-};
 
-const getRuntimesKey = set => {
-	set.sort();
-	return Array.from(set).join("\n");
-};
+/***/ }),
 
-/**
- * @param {RuntimeSpec} runtime runtime(s)
- * @returns {string} key of runtimes
- */
-const getRuntimeKey = runtime => {
-	if (runtime === undefined) return "*";
-	if (typeof runtime === "string") return runtime;
-	return runtime.getFromUnorderedCache(getRuntimesKey);
-};
-exports.getRuntimeKey = getRuntimeKey;
+/***/ 44222:
+/***/ (function(module) {
 
-/**
- * @param {string} key key of runtimes
- * @returns {RuntimeSpec} runtime(s)
- */
-const keyToRuntime = key => {
-	if (key === "*") return undefined;
-	const items = key.split("\n");
-	if (items.length === 1) return items[0];
-	return new SortableSet(items);
-};
-exports.keyToRuntime = keyToRuntime;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Maël Nison @arcanis
+*/
 
-const getRuntimesString = set => {
-	set.sort();
-	return Array.from(set).join("+");
-};
 
-/**
- * @param {RuntimeSpec} runtime runtime(s)
- * @returns {string} readable version
- */
-const runtimeToString = runtime => {
-	if (runtime === undefined) return "*";
-	if (typeof runtime === "string") return runtime;
-	return runtime.getFromUnorderedCache(getRuntimesString);
-};
-exports.runtimeToString = runtimeToString;
 
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 /**
- * @param {RuntimeCondition} runtimeCondition runtime condition
- * @returns {string} readable version
+ * @typedef {Object} PnpApiImpl
+ * @property {function(string, string, object): string} resolveToUnqualified
  */
-exports.runtimeConditionToString = runtimeCondition => {
-	if (runtimeCondition === true) return "true";
-	if (runtimeCondition === false) return "false";
-	return runtimeToString(runtimeCondition);
-};
 
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {boolean} true, when they are equal
- */
-const runtimeEqual = (a, b) => {
-	if (a === b) {
-		return true;
-	} else if (
-		a === undefined ||
-		b === undefined ||
-		typeof a === "string" ||
-		typeof b === "string"
-	) {
-		return false;
-	} else if (a.size !== b.size) {
-		return false;
-	} else {
-		a.sort();
-		b.sort();
-		const aIt = a[Symbol.iterator]();
-		const bIt = b[Symbol.iterator]();
-		for (;;) {
-			const aV = aIt.next();
-			if (aV.done) return true;
-			const bV = bIt.next();
-			if (aV.value !== bV.value) return false;
-		}
+module.exports = class PnpPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {PnpApiImpl} pnpApi pnpApi
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, pnpApi, target) {
+		this.source = source;
+		this.pnpApi = pnpApi;
+		this.target = target;
 	}
-};
-exports.runtimeEqual = runtimeEqual;
 
-/**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {-1|0|1} compare
- */
-exports.compareRuntime = (a, b) => {
-	if (a === b) {
-		return 0;
-	} else if (a === undefined) {
-		return -1;
-	} else if (b === undefined) {
-		return 1;
-	} else {
-		const aKey = getRuntimeKey(a);
-		const bKey = getRuntimeKey(b);
-		if (aKey < bKey) return -1;
-		if (aKey > bKey) return 1;
-		return 0;
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("PnpPlugin", (request, resolveContext, callback) => {
+				const req = request.request;
+				if (!req) return callback();
+
+				// The trailing slash indicates to PnP that this value is a folder rather than a file
+				const issuer = `${request.path}/`;
+
+				const packageMatch = /^(@[^/]+\/)?[^/]+/.exec(req);
+				if (!packageMatch) return callback();
+
+				const packageName = packageMatch[0];
+				const innerRequest = `.${req.slice(packageName.length)}`;
+
+				let resolution;
+				let apiResolution;
+				try {
+					resolution = this.pnpApi.resolveToUnqualified(packageName, issuer, {
+						considerBuiltins: false
+					});
+					if (resolveContext.fileDependencies) {
+						apiResolution = this.pnpApi.resolveToUnqualified("pnpapi", issuer, {
+							considerBuiltins: false
+						});
+					}
+				} catch (error) {
+					if (
+						error.code === "MODULE_NOT_FOUND" &&
+						error.pnpCode === "UNDECLARED_DEPENDENCY"
+					) {
+						// This is not a PnP managed dependency.
+						// Try to continue resolving with our alternatives
+						if (resolveContext.log) {
+							resolveContext.log(`request is not managed by the pnpapi`);
+							for (const line of error.message.split("\n").filter(Boolean))
+								resolveContext.log(`  ${line}`);
+						}
+						return callback();
+					}
+					return callback(error);
+				}
+
+				if (resolution === packageName) return callback();
+
+				if (apiResolution && resolveContext.fileDependencies) {
+					resolveContext.fileDependencies.add(apiResolution);
+				}
+
+				const obj = {
+					...request,
+					path: resolution,
+					request: innerRequest,
+					ignoreSymlinks: true,
+					fullySpecified: request.fullySpecified && innerRequest !== "."
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					`resolved by pnp to ${resolution}`,
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
+						if (result) return callback(null, result);
+						// Skip alternatives
+						return callback(null, null);
+					}
+				);
+			});
 	}
 };
 
+
+/***/ }),
+
+/***/ 55516:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+const { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } = __webpack_require__(6967);
+const createInnerContext = __webpack_require__(81218);
+const { parseIdentifier } = __webpack_require__(71053);
+const {
+	normalize,
+	cachedJoin: join,
+	getType,
+	PathType
+} = __webpack_require__(67079);
+
+/** @typedef {import("./ResolverFactory").ResolveOptions} ResolveOptions */
+
 /**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} merged
+ * @typedef {Object} FileSystemStats
+ * @property {function(): boolean} isDirectory
+ * @property {function(): boolean} isFile
  */
-const mergeRuntime = (a, b) => {
-	if (a === undefined) {
-		return b;
-	} else if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return a;
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			const set = new SortableSet();
-			set.add(a);
-			set.add(b);
-			return set;
-		} else if (b.has(a)) {
-			return b;
-		} else {
-			const set = new SortableSet(b);
-			set.add(a);
-			return set;
-		}
-	} else {
-		if (typeof b === "string") {
-			if (a.has(b)) return a;
-			const set = new SortableSet(a);
-			set.add(b);
-			return set;
-		} else {
-			const set = new SortableSet(a);
-			for (const item of b) set.add(item);
-			if (set.size === a.size) return a;
-			return set;
-		}
-	}
-};
-exports.mergeRuntime = mergeRuntime;
 
 /**
- * @param {RuntimeCondition} a first
- * @param {RuntimeCondition} b second
- * @param {RuntimeSpec} runtime full runtime
- * @returns {RuntimeCondition} result
+ * @typedef {Object} FileSystemDirent
+ * @property {Buffer | string} name
+ * @property {function(): boolean} isDirectory
+ * @property {function(): boolean} isFile
  */
-exports.mergeRuntimeCondition = (a, b, runtime) => {
-	if (a === false) return b;
-	if (b === false) return a;
-	if (a === true || b === true) return true;
-	const merged = mergeRuntime(a, b);
-	if (merged === undefined) return undefined;
-	if (typeof merged === "string") {
-		if (typeof runtime === "string" && merged === runtime) return true;
-		return merged;
-	}
-	if (typeof runtime === "string" || runtime === undefined) return merged;
-	if (merged.size === runtime.size) return true;
-	return merged;
-};
 
 /**
- * @param {RuntimeSpec | true} a first
- * @param {RuntimeSpec | true} b second
- * @param {RuntimeSpec} runtime full runtime
- * @returns {RuntimeSpec | true} result
+ * @typedef {Object} PossibleFileSystemError
+ * @property {string=} code
+ * @property {number=} errno
+ * @property {string=} path
+ * @property {string=} syscall
  */
-exports.mergeRuntimeConditionNonFalse = (a, b, runtime) => {
-	if (a === true || b === true) return true;
-	const merged = mergeRuntime(a, b);
-	if (merged === undefined) return undefined;
-	if (typeof merged === "string") {
-		if (typeof runtime === "string" && merged === runtime) return true;
-		return merged;
-	}
-	if (typeof runtime === "string" || runtime === undefined) return merged;
-	if (merged.size === runtime.size) return true;
-	return merged;
-};
 
 /**
- * @param {RuntimeSpec} a first (may be modified)
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} merged
- */
-const mergeRuntimeOwned = (a, b) => {
-	if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return a;
-	} else if (a === undefined) {
-		if (typeof b === "string") {
-			return b;
-		} else {
-			return new SortableSet(b);
-		}
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			const set = new SortableSet();
-			set.add(a);
-			set.add(b);
-			return set;
-		} else {
-			const set = new SortableSet(b);
-			set.add(a);
-			return set;
-		}
-	} else {
-		if (typeof b === "string") {
-			a.add(b);
-			return a;
-		} else {
-			for (const item of b) a.add(item);
-			return a;
-		}
-	}
-};
-exports.mergeRuntimeOwned = mergeRuntimeOwned;
+ * @template T
+ * @callback FileSystemCallback
+ * @param {PossibleFileSystemError & Error | null | undefined} err
+ * @param {T=} result
+ */
 
 /**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} merged
+ * @typedef {Object} FileSystem
+ * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readFile
+ * @property {(function(string, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void) & function(string, object, FileSystemCallback<(Buffer | string)[] | FileSystemDirent[]>): void} readdir
+ * @property {((function(string, FileSystemCallback<object>): void) & function(string, object, FileSystemCallback<object>): void)=} readJson
+ * @property {(function(string, FileSystemCallback<Buffer | string>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} readlink
+ * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void=} lstat
+ * @property {(function(string, FileSystemCallback<FileSystemStats>): void) & function(string, object, FileSystemCallback<Buffer | string>): void} stat
  */
-exports.intersectRuntime = (a, b) => {
-	if (a === undefined) {
-		return b;
-	} else if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return a;
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			return undefined;
-		} else if (b.has(a)) {
-			return a;
-		} else {
-			return undefined;
-		}
-	} else {
-		if (typeof b === "string") {
-			if (a.has(b)) return b;
-			return undefined;
-		} else {
-			const set = new SortableSet();
-			for (const item of b) {
-				if (a.has(item)) set.add(item);
-			}
-			if (set.size === 0) return undefined;
-			if (set.size === 1) for (const item of set) return item;
-			return set;
-		}
-	}
-};
 
 /**
- * @param {RuntimeSpec} a first
- * @param {RuntimeSpec} b second
- * @returns {RuntimeSpec} result
+ * @typedef {Object} SyncFileSystem
+ * @property {function(string, object=): Buffer | string} readFileSync
+ * @property {function(string, object=): (Buffer | string)[] | FileSystemDirent[]} readdirSync
+ * @property {(function(string, object=): object)=} readJsonSync
+ * @property {function(string, object=): Buffer | string} readlinkSync
+ * @property {function(string, object=): FileSystemStats=} lstatSync
+ * @property {function(string, object=): FileSystemStats} statSync
  */
-const subtractRuntime = (a, b) => {
-	if (a === undefined) {
-		return undefined;
-	} else if (b === undefined) {
-		return a;
-	} else if (a === b) {
-		return undefined;
-	} else if (typeof a === "string") {
-		if (typeof b === "string") {
-			return a;
-		} else if (b.has(a)) {
-			return undefined;
-		} else {
-			return a;
-		}
-	} else {
-		if (typeof b === "string") {
-			if (!a.has(b)) return a;
-			if (a.size === 2) {
-				for (const item of a) {
-					if (item !== b) return item;
-				}
-			}
-			const set = new SortableSet(a);
-			set.delete(b);
-		} else {
-			const set = new SortableSet();
-			for (const item of a) {
-				if (!b.has(item)) set.add(item);
-			}
-			if (set.size === 0) return undefined;
-			if (set.size === 1) for (const item of set) return item;
-			return set;
-		}
-	}
-};
-exports.subtractRuntime = subtractRuntime;
 
 /**
- * @param {RuntimeCondition} a first
- * @param {RuntimeCondition} b second
- * @param {RuntimeSpec} runtime runtime
- * @returns {RuntimeCondition} result
+ * @typedef {Object} ParsedIdentifier
+ * @property {string} request
+ * @property {string} query
+ * @property {string} fragment
+ * @property {boolean} directory
+ * @property {boolean} module
+ * @property {boolean} file
+ * @property {boolean} internal
  */
-exports.subtractRuntimeCondition = (a, b, runtime) => {
-	if (b === true) return false;
-	if (b === false) return a;
-	if (a === false) return false;
-	const result = subtractRuntime(a === true ? runtime : a, b);
-	return result === undefined ? false : result;
-};
 
 /**
- * @param {RuntimeSpec} runtime runtime
- * @param {function(RuntimeSpec): boolean} filter filter function
- * @returns {boolean | RuntimeSpec} true/false if filter is constant for all runtimes, otherwise runtimes that are active
+ * @typedef {Object} BaseResolveRequest
+ * @property {string | false} path
+ * @property {string=} descriptionFilePath
+ * @property {string=} descriptionFileRoot
+ * @property {object=} descriptionFileData
+ * @property {string=} relativePath
+ * @property {boolean=} ignoreSymlinks
+ * @property {boolean=} fullySpecified
  */
-exports.filterRuntime = (runtime, filter) => {
-	if (runtime === undefined) return filter(undefined);
-	if (typeof runtime === "string") return filter(runtime);
-	let some = false;
-	let every = true;
-	let result = undefined;
-	for (const r of runtime) {
-		const v = filter(r);
-		if (v) {
-			some = true;
-			result = mergeRuntimeOwned(result, r);
-		} else {
-			every = false;
-		}
-	}
-	if (!some) return false;
-	if (every) return true;
-	return result;
-};
+
+/** @typedef {BaseResolveRequest & Partial<ParsedIdentifier>} ResolveRequest */
 
 /**
- * @template T
+ * String with special formatting
+ * @typedef {string} StackEntry
  */
-class RuntimeSpecMap {
+
+/** @template T @typedef {{ add: (T) => void }} WriteOnlySet */
+
+/**
+ * Resolve context
+ * @typedef {Object} ResolveContext
+ * @property {WriteOnlySet<string>=} contextDependencies
+ * @property {WriteOnlySet<string>=} fileDependencies files that was found on file system
+ * @property {WriteOnlySet<string>=} missingDependencies dependencies that was not found on file system
+ * @property {Set<StackEntry>=} stack set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`,
+ * @property {(function(string): void)=} log log function
+ */
+
+/** @typedef {AsyncSeriesBailHook<[ResolveRequest, ResolveContext], ResolveRequest | null>} ResolveStepHook */
+
+/**
+ * @param {string} str input string
+ * @returns {string} in camel case
+ */
+function toCamelCase(str) {
+	return str.replace(/-([a-z])/g, str => str.substr(1).toUpperCase());
+}
+
+class Resolver {
 	/**
-	 * @param {RuntimeSpecMap<T>=} clone copy form this
+	 * @param {ResolveStepHook} hook hook
+	 * @param {ResolveRequest} request request
+	 * @returns {StackEntry} stack entry
 	 */
-	constructor(clone) {
-		this._mode = clone ? clone._mode : 0; // 0 = empty, 1 = single entry, 2 = map
-		/** @type {RuntimeSpec} */
-		this._singleRuntime = clone ? clone._singleRuntime : undefined;
-		/** @type {T} */
-		this._singleValue = clone ? clone._singleValue : undefined;
-		/** @type {Map<string, T> | undefined} */
-		this._map = clone && clone._map ? new Map(clone._map) : undefined;
+	static createStackEntry(hook, request) {
+		return (
+			hook.name +
+			": (" +
+			request.path +
+			") " +
+			(request.request || "") +
+			(request.query || "") +
+			(request.fragment || "") +
+			(request.directory ? " directory" : "") +
+			(request.module ? " module" : "")
+		);
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {T} value
+	 * @param {FileSystem} fileSystem a filesystem
+	 * @param {ResolveOptions} options options
 	 */
-	get(runtime) {
-		switch (this._mode) {
-			case 0:
-				return undefined;
-			case 1:
-				return runtimeEqual(this._singleRuntime, runtime)
-					? this._singleValue
-					: undefined;
-			default:
-				return this._map.get(getRuntimeKey(runtime));
-		}
+	constructor(fileSystem, options) {
+		this.fileSystem = fileSystem;
+		this.options = options;
+		this.hooks = {
+			/** @type {SyncHook<[ResolveStepHook, ResolveRequest], void>} */
+			resolveStep: new SyncHook(["hook", "request"], "resolveStep"),
+			/** @type {SyncHook<[ResolveRequest, Error]>} */
+			noResolve: new SyncHook(["request", "error"], "noResolve"),
+			/** @type {ResolveStepHook} */
+			resolve: new AsyncSeriesBailHook(
+				["request", "resolveContext"],
+				"resolve"
+			),
+			/** @type {AsyncSeriesHook<[ResolveRequest, ResolveContext]>} */
+			result: new AsyncSeriesHook(["result", "resolveContext"], "result")
+		};
 	}
 
 	/**
-	 * @param {RuntimeSpec} runtime the runtimes
-	 * @returns {boolean} true, when the runtime is stored
+	 * @param {string | ResolveStepHook} name hook name or hook itself
+	 * @returns {ResolveStepHook} the hook
 	 */
-	has(runtime) {
-		switch (this._mode) {
-			case 0:
-				return false;
-			case 1:
-				return runtimeEqual(this._singleRuntime, runtime);
-			default:
-				return this._map.has(getRuntimeKey(runtime));
+	ensureHook(name) {
+		if (typeof name !== "string") {
+			return name;
 		}
-	}
-
-	set(runtime, value) {
-		switch (this._mode) {
-			case 0:
-				this._mode = 1;
-				this._singleRuntime = runtime;
-				this._singleValue = value;
-				break;
-			case 1:
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					this._singleValue = value;
-					break;
-				}
-				this._mode = 2;
-				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
-				this._singleRuntime = undefined;
-				this._singleValue = undefined;
-			/* falls through */
-			default:
-				this._map.set(getRuntimeKey(runtime), value);
+		name = toCamelCase(name);
+		if (/^before/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.ensureHook(
+				name[6].toLowerCase() + name.substr(7)
+			).withOptions({
+				stage: -10
+			}));
+		}
+		if (/^after/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.ensureHook(
+				name[5].toLowerCase() + name.substr(6)
+			).withOptions({
+				stage: 10
+			}));
+		}
+		const hook = this.hooks[name];
+		if (!hook) {
+			return (this.hooks[name] = new AsyncSeriesBailHook(
+				["request", "resolveContext"],
+				name
+			));
 		}
+		return hook;
 	}
 
-	provide(runtime, computer) {
-		switch (this._mode) {
-			case 0:
-				this._mode = 1;
-				this._singleRuntime = runtime;
-				return (this._singleValue = computer());
-			case 1: {
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					return this._singleValue;
-				}
-				this._mode = 2;
-				this._map = new Map();
-				this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
-				this._singleRuntime = undefined;
-				this._singleValue = undefined;
-				const newValue = computer();
-				this._map.set(getRuntimeKey(runtime), newValue);
-				return newValue;
-			}
-			default: {
-				const key = getRuntimeKey(runtime);
-				const value = this._map.get(key);
-				if (value !== undefined) return value;
-				const newValue = computer();
-				this._map.set(key, newValue);
-				return newValue;
-			}
+	/**
+	 * @param {string | ResolveStepHook} name hook name or hook itself
+	 * @returns {ResolveStepHook} the hook
+	 */
+	getHook(name) {
+		if (typeof name !== "string") {
+			return name;
+		}
+		name = toCamelCase(name);
+		if (/^before/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.getHook(
+				name[6].toLowerCase() + name.substr(7)
+			).withOptions({
+				stage: -10
+			}));
+		}
+		if (/^after/.test(name)) {
+			return /** @type {ResolveStepHook} */ (this.getHook(
+				name[5].toLowerCase() + name.substr(6)
+			).withOptions({
+				stage: 10
+			}));
+		}
+		const hook = this.hooks[name];
+		if (!hook) {
+			throw new Error(`Hook ${name} doesn't exist`);
 		}
+		return hook;
 	}
 
-	delete(runtime) {
-		switch (this._mode) {
-			case 0:
-				return;
-			case 1:
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					this._mode = 0;
-					this._singleRuntime = undefined;
-					this._singleValue = undefined;
-				}
-				return;
-			default:
-				this._map.delete(getRuntimeKey(runtime));
+	/**
+	 * @param {object} context context information object
+	 * @param {string} path context path
+	 * @param {string} request request string
+	 * @returns {string | false} result
+	 */
+	resolveSync(context, path, request) {
+		/** @type {Error | null | undefined} */
+		let err = undefined;
+		/** @type {string | false | undefined} */
+		let result = undefined;
+		let sync = false;
+		this.resolve(context, path, request, {}, (e, r) => {
+			err = e;
+			result = r;
+			sync = true;
+		});
+		if (!sync) {
+			throw new Error(
+				"Cannot 'resolveSync' because the fileSystem is not sync. Use 'resolve'!"
+			);
 		}
+		if (err) throw err;
+		if (result === undefined) throw new Error("No result");
+		return result;
 	}
 
-	update(runtime, fn) {
-		switch (this._mode) {
-			case 0:
-				throw new Error("runtime passed to update must exist");
-			case 1: {
-				if (runtimeEqual(this._singleRuntime, runtime)) {
-					this._singleValue = fn(this._singleValue);
-					break;
-				}
-				const newValue = fn(undefined);
-				if (newValue !== undefined) {
-					this._mode = 2;
-					this._map = new Map();
-					this._map.set(getRuntimeKey(this._singleRuntime), this._singleValue);
-					this._singleRuntime = undefined;
-					this._singleValue = undefined;
-					this._map.set(getRuntimeKey(runtime), newValue);
+	/**
+	 * @param {object} context context information object
+	 * @param {string} path context path
+	 * @param {string} request request string
+	 * @param {ResolveContext} resolveContext resolve context
+	 * @param {function(Error | null, (string|false)=, ResolveRequest=): void} callback callback function
+	 * @returns {void}
+	 */
+	resolve(context, path, request, resolveContext, callback) {
+		if (!context || typeof context !== "object")
+			return callback(new Error("context argument is not an object"));
+		if (typeof path !== "string")
+			return callback(new Error("path argument is not a string"));
+		if (typeof request !== "string")
+			return callback(new Error("path argument is not a string"));
+		if (!resolveContext)
+			return callback(new Error("resolveContext argument is not set"));
+
+		const obj = {
+			context: context,
+			path: path,
+			request: request
+		};
+
+		const message = `resolve '${request}' in '${path}'`;
+
+		const finishResolved = result => {
+			return callback(
+				null,
+				result.path === false
+					? false
+					: `${result.path.replace(/#/g, "\0#")}${
+							result.query ? result.query.replace(/#/g, "\0#") : ""
+					  }${result.fragment || ""}`,
+				result
+			);
+		};
+
+		const finishWithoutResolve = log => {
+			/**
+			 * @type {Error & {details?: string}}
+			 */
+			const error = new Error("Can't " + message);
+			error.details = log.join("\n");
+			this.hooks.noResolve.call(obj, error);
+			return callback(error);
+		};
+
+		if (resolveContext.log) {
+			// We need log anyway to capture it in case of an error
+			const parentLog = resolveContext.log;
+			const log = [];
+			return this.doResolve(
+				this.hooks.resolve,
+				obj,
+				message,
+				{
+					log: msg => {
+						parentLog(msg);
+						log.push(msg);
+					},
+					fileDependencies: resolveContext.fileDependencies,
+					contextDependencies: resolveContext.contextDependencies,
+					missingDependencies: resolveContext.missingDependencies,
+					stack: resolveContext.stack
+				},
+				(err, result) => {
+					if (err) return callback(err);
+
+					if (result) return finishResolved(result);
+
+					return finishWithoutResolve(log);
 				}
-				break;
-			}
-			default: {
-				const key = getRuntimeKey(runtime);
-				const oldValue = this._map.get(key);
-				const newValue = fn(oldValue);
-				if (newValue !== oldValue) this._map.set(key, newValue);
-			}
+			);
+		} else {
+			// Try to resolve assuming there is no error
+			// We don't log stuff in this case
+			return this.doResolve(
+				this.hooks.resolve,
+				obj,
+				message,
+				{
+					log: undefined,
+					fileDependencies: resolveContext.fileDependencies,
+					contextDependencies: resolveContext.contextDependencies,
+					missingDependencies: resolveContext.missingDependencies,
+					stack: resolveContext.stack
+				},
+				(err, result) => {
+					if (err) return callback(err);
+
+					if (result) return finishResolved(result);
+
+					// log is missing for the error details
+					// so we redo the resolving for the log info
+					// this is more expensive to the success case
+					// is assumed by default
+
+					const log = [];
+
+					return this.doResolve(
+						this.hooks.resolve,
+						obj,
+						message,
+						{
+							log: msg => log.push(msg),
+							stack: resolveContext.stack
+						},
+						(err, result) => {
+							if (err) return callback(err);
+
+							return finishWithoutResolve(log);
+						}
+					);
+				}
+			);
 		}
 	}
 
-	keys() {
-		switch (this._mode) {
-			case 0:
-				return [];
-			case 1:
-				return [this._singleRuntime];
-			default:
-				return Array.from(this._map.keys(), keyToRuntime);
+	doResolve(hook, request, message, resolveContext, callback) {
+		const stackEntry = Resolver.createStackEntry(hook, request);
+
+		let newStack;
+		if (resolveContext.stack) {
+			newStack = new Set(resolveContext.stack);
+			if (resolveContext.stack.has(stackEntry)) {
+				/**
+				 * Prevent recursion
+				 * @type {Error & {recursion?: boolean}}
+				 */
+				const recursionError = new Error(
+					"Recursion in resolving\nStack:\n  " +
+						Array.from(newStack).join("\n  ")
+				);
+				recursionError.recursion = true;
+				if (resolveContext.log)
+					resolveContext.log("abort resolving because of recursion");
+				return callback(recursionError);
+			}
+			newStack.add(stackEntry);
+		} else {
+			newStack = new Set([stackEntry]);
 		}
-	}
+		this.hooks.resolveStep.call(hook, request);
 
-	values() {
-		switch (this._mode) {
-			case 0:
-				return [][Symbol.iterator]();
-			case 1:
-				return [this._singleValue][Symbol.iterator]();
-			default:
-				return this._map.values();
+		if (hook.isUsed()) {
+			const innerContext = createInnerContext(
+				{
+					log: resolveContext.log,
+					fileDependencies: resolveContext.fileDependencies,
+					contextDependencies: resolveContext.contextDependencies,
+					missingDependencies: resolveContext.missingDependencies,
+					stack: newStack
+				},
+				message
+			);
+			return hook.callAsync(request, innerContext, (err, result) => {
+				if (err) return callback(err);
+				if (result) return callback(null, result);
+				callback();
+			});
+		} else {
+			callback();
 		}
 	}
 
-	get size() {
-		if (this._mode <= 1) return this._mode;
-		return this._map.size;
-	}
-}
+	/**
+	 * @param {string} identifier identifier
+	 * @returns {ParsedIdentifier} parsed identifier
+	 */
+	parse(identifier) {
+		const part = {
+			request: "",
+			query: "",
+			fragment: "",
+			module: false,
+			directory: false,
+			file: false,
+			internal: false
+		};
 
-exports.RuntimeSpecMap = RuntimeSpecMap;
+		const parsedIdentifier = parseIdentifier(identifier);
 
-class RuntimeSpecSet {
-	constructor(iterable) {
-		/** @type {Map<string, RuntimeSpec>} */
-		this._map = new Map();
-		if (iterable) {
-			for (const item of iterable) {
-				this.add(item);
+		if (!parsedIdentifier) return part;
+
+		[part.request, part.query, part.fragment] = parsedIdentifier;
+
+		if (part.request.length > 0) {
+			part.internal = this.isPrivate(identifier);
+			part.module = this.isModule(part.request);
+			part.directory = this.isDirectory(part.request);
+			if (part.directory) {
+				part.request = part.request.substr(0, part.request.length - 1);
 			}
 		}
+
+		return part;
 	}
 
-	add(runtime) {
-		this._map.set(getRuntimeKey(runtime), runtime);
+	isModule(path) {
+		return getType(path) === PathType.Normal;
 	}
 
-	has(runtime) {
-		return this._map.has(getRuntimeKey(runtime));
+	isPrivate(path) {
+		return getType(path) === PathType.Internal;
 	}
 
-	[Symbol.iterator]() {
-		return this._map.values();
+	/**
+	 * @param {string} path a path
+	 * @returns {boolean} true, if the path is a directory path
+	 */
+	isDirectory(path) {
+		return path.endsWith("/");
 	}
 
-	get size() {
-		return this._map.size;
+	join(path, request) {
+		return join(path, request);
+	}
+
+	normalize(path) {
+		return normalize(path);
 	}
 }
 
-exports.RuntimeSpecSet = RuntimeSpecSet;
+module.exports = Resolver;
 
 
 /***/ }),
 
-/***/ 19702:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 47716:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -135834,617 +136308,729 @@ exports.RuntimeSpecSet = RuntimeSpecSet;
 
 
 
-/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+const versions = (__webpack_require__(77282).versions);
+const Resolver = __webpack_require__(55516);
+const { getType, PathType } = __webpack_require__(67079);
+
+const SyncAsyncFileSystemDecorator = __webpack_require__(87474);
+
+const AliasFieldPlugin = __webpack_require__(14819);
+const AliasPlugin = __webpack_require__(63676);
+const AppendPlugin = __webpack_require__(92088);
+const ConditionalPlugin = __webpack_require__(6953);
+const DescriptionFilePlugin = __webpack_require__(44112);
+const DirectoryExistsPlugin = __webpack_require__(60895);
+const ExportsFieldPlugin = __webpack_require__(83849);
+const FileExistsPlugin = __webpack_require__(50295);
+const ImportsFieldPlugin = __webpack_require__(7317);
+const JoinRequestPartPlugin = __webpack_require__(35949);
+const JoinRequestPlugin = __webpack_require__(5190);
+const MainFieldPlugin = __webpack_require__(47450);
+const ModulesInHierachicDirectoriesPlugin = __webpack_require__(48506);
+const ModulesInRootPlugin = __webpack_require__(88138);
+const NextPlugin = __webpack_require__(40777);
+const ParsePlugin = __webpack_require__(97849);
+const PnpPlugin = __webpack_require__(44222);
+const RestrictionsPlugin = __webpack_require__(36400);
+const ResultPlugin = __webpack_require__(13965);
+const RootsPlugin = __webpack_require__(66737);
+const SelfReferencePlugin = __webpack_require__(52232);
+const SymlinkPlugin = __webpack_require__(58885);
+const TryNextPlugin = __webpack_require__(99324);
+const UnsafeCachePlugin = __webpack_require__(41606);
+const UseFilePlugin = __webpack_require__(96972);
+
+/** @typedef {import("./AliasPlugin").AliasOption} AliasOptionEntry */
+/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
+
+/** @typedef {string|string[]|false} AliasOptionNewRequest */
+/** @typedef {{[k: string]: AliasOptionNewRequest}} AliasOptions */
+/** @typedef {{apply: function(Resolver): void} | function(this: Resolver, Resolver): void} Plugin */
 
 /**
- * @param {string} str version string
- * @returns {(string|number|undefined|[])[]} parsed version
+ * @typedef {Object} UserResolveOptions
+ * @property {(AliasOptions | AliasOptionEntry[])=} alias A list of module alias configurations or an object which maps key to value
+ * @property {(AliasOptions | AliasOptionEntry[])=} fallback A list of module alias configurations or an object which maps key to value, applied only after modules option
+ * @property {(string | string[])[]=} aliasFields A list of alias fields in description files
+ * @property {(function(ResolveRequest): boolean)=} cachePredicate A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
+ * @property {boolean=} cacheWithContext Whether or not the unsafeCache should include request context as part of the cache key.
+ * @property {string[]=} descriptionFiles A list of description files to read from
+ * @property {string[]=} conditionNames A list of exports field condition names.
+ * @property {boolean=} enforceExtension Enforce that a extension from extensions must be used
+ * @property {(string | string[])[]=} exportsFields A list of exports fields in description files
+ * @property {(string | string[])[]=} importsFields A list of imports fields in description files
+ * @property {string[]=} extensions A list of extensions which should be tried for files
+ * @property {FileSystem} fileSystem The file system which should be used
+ * @property {(object | boolean)=} unsafeCache Use this cache object to unsafely cache the successful requests
+ * @property {boolean=} symlinks Resolve symlinks to their symlinked location
+ * @property {Resolver=} resolver A prepared Resolver to which the plugins are attached
+ * @property {string[] | string=} modules A list of directories to resolve modules from, can be absolute path or folder name
+ * @property {(string | string[] | {name: string | string[], forceRelative: boolean})[]=} mainFields A list of main fields in description files
+ * @property {string[]=} mainFiles  A list of main files in directories
+ * @property {Plugin[]=} plugins A list of additional resolve plugins which should be applied
+ * @property {PnpApi | null=} pnpApi A PnP API that should be used - null is "never", undefined is "auto"
+ * @property {string[]=} roots A list of root paths
+ * @property {boolean=} fullySpecified The request is already fully specified and no extensions or directories are resolved for it
+ * @property {boolean=} resolveToContext Resolve to a context instead of a file
+ * @property {(string|RegExp)[]=} restrictions A list of resolve restrictions
+ * @property {boolean=} useSyncFileSystemCalls Use only the sync constiants of the file system calls
+ * @property {boolean=} preferRelative Prefer to resolve module requests as relative requests before falling back to modules
+ * @property {boolean=} preferAbsolute Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
  */
-const parseVersion = str => {
-	var splitAndConvert = function (str) {
-		return str.split(".").map(function (item) {
-			// eslint-disable-next-line eqeqeq
-			return +item == item ? +item : item;
-		});
-	};
-	var match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-	/** @type {(string|number|undefined|[])[]} */
-	var ver = match[1] ? splitAndConvert(match[1]) : [];
-	if (match[2]) {
-		ver.length++;
-		ver.push.apply(ver, splitAndConvert(match[2]));
+
+/**
+ * @typedef {Object} ResolveOptions
+ * @property {AliasOptionEntry[]} alias
+ * @property {AliasOptionEntry[]} fallback
+ * @property {Set<string | string[]>} aliasFields
+ * @property {(function(ResolveRequest): boolean)} cachePredicate
+ * @property {boolean} cacheWithContext
+ * @property {Set<string>} conditionNames A list of exports field condition names.
+ * @property {string[]} descriptionFiles
+ * @property {boolean} enforceExtension
+ * @property {Set<string | string[]>} exportsFields
+ * @property {Set<string | string[]>} importsFields
+ * @property {Set<string>} extensions
+ * @property {FileSystem} fileSystem
+ * @property {object | false} unsafeCache
+ * @property {boolean} symlinks
+ * @property {Resolver=} resolver
+ * @property {Array<string | string[]>} modules
+ * @property {{name: string[], forceRelative: boolean}[]} mainFields
+ * @property {Set<string>} mainFiles
+ * @property {Plugin[]} plugins
+ * @property {PnpApi | null} pnpApi
+ * @property {Set<string>} roots
+ * @property {boolean} fullySpecified
+ * @property {boolean} resolveToContext
+ * @property {Set<string|RegExp>} restrictions
+ * @property {boolean} preferRelative
+ * @property {boolean} preferAbsolute
+ */
+
+/**
+ * @param {PnpApi | null=} option option
+ * @returns {PnpApi | null} processed option
+ */
+function processPnpApiOption(option) {
+	if (
+		option === undefined &&
+		/** @type {NodeJS.ProcessVersions & {pnp: string}} */ versions.pnp
+	) {
+		// @ts-ignore
+		return __webpack_require__(35125); // eslint-disable-line node/no-missing-require
 	}
-	if (match[3]) {
-		ver.push([]);
-		ver.push.apply(ver, splitAndConvert(match[3]));
+
+	return option || null;
+}
+
+/**
+ * @param {AliasOptions | AliasOptionEntry[] | undefined} alias alias
+ * @returns {AliasOptionEntry[]} normalized aliases
+ */
+function normalizeAlias(alias) {
+	return typeof alias === "object" && !Array.isArray(alias) && alias !== null
+		? Object.keys(alias).map(key => {
+				/** @type {AliasOptionEntry} */
+				const obj = { name: key, onlyModule: false, alias: alias[key] };
+
+				if (/\$$/.test(key)) {
+					obj.onlyModule = true;
+					obj.name = key.substr(0, key.length - 1);
+				}
+
+				return obj;
+		  })
+		: /** @type {Array<AliasOptionEntry>} */ (alias) || [];
+}
+
+/**
+ * @param {UserResolveOptions} options input options
+ * @returns {ResolveOptions} output options
+ */
+function createOptions(options) {
+	const mainFieldsSet = new Set(options.mainFields || ["main"]);
+	const mainFields = [];
+
+	for (const item of mainFieldsSet) {
+		if (typeof item === "string") {
+			mainFields.push({
+				name: [item],
+				forceRelative: true
+			});
+		} else if (Array.isArray(item)) {
+			mainFields.push({
+				name: item,
+				forceRelative: true
+			});
+		} else {
+			mainFields.push({
+				name: Array.isArray(item.name) ? item.name : [item.name],
+				forceRelative: item.forceRelative
+			});
+		}
 	}
-	return ver;
-};
-exports.parseVersion = parseVersion;
 
-/* eslint-disable eqeqeq */
+	return {
+		alias: normalizeAlias(options.alias),
+		fallback: normalizeAlias(options.fallback),
+		aliasFields: new Set(options.aliasFields),
+		cachePredicate:
+			options.cachePredicate ||
+			function () {
+				return true;
+			},
+		cacheWithContext:
+			typeof options.cacheWithContext !== "undefined"
+				? options.cacheWithContext
+				: true,
+		exportsFields: new Set(options.exportsFields || ["exports"]),
+		importsFields: new Set(options.importsFields || ["imports"]),
+		conditionNames: new Set(options.conditionNames),
+		descriptionFiles: Array.from(
+			new Set(options.descriptionFiles || ["package.json"])
+		),
+		enforceExtension:
+			options.enforceExtension === undefined
+				? options.extensions && options.extensions.includes("")
+					? true
+					: false
+				: options.enforceExtension,
+		extensions: new Set(options.extensions || [".js", ".json", ".node"]),
+		fileSystem: options.useSyncFileSystemCalls
+			? new SyncAsyncFileSystemDecorator(
+					/** @type {SyncFileSystem} */ (
+						/** @type {unknown} */ (options.fileSystem)
+					)
+			  )
+			: options.fileSystem,
+		unsafeCache:
+			options.unsafeCache && typeof options.unsafeCache !== "object"
+				? {}
+				: options.unsafeCache || false,
+		symlinks: typeof options.symlinks !== "undefined" ? options.symlinks : true,
+		resolver: options.resolver,
+		modules: mergeFilteredToArray(
+			Array.isArray(options.modules)
+				? options.modules
+				: options.modules
+				? [options.modules]
+				: ["node_modules"],
+			item => {
+				const type = getType(item);
+				return type === PathType.Normal || type === PathType.Relative;
+			}
+		),
+		mainFields,
+		mainFiles: new Set(options.mainFiles || ["index"]),
+		plugins: options.plugins || [],
+		pnpApi: processPnpApiOption(options.pnpApi),
+		roots: new Set(options.roots || undefined),
+		fullySpecified: options.fullySpecified || false,
+		resolveToContext: options.resolveToContext || false,
+		preferRelative: options.preferRelative || false,
+		preferAbsolute: options.preferAbsolute || false,
+		restrictions: new Set(options.restrictions)
+	};
+}
+
 /**
- * @param {string} a version
- * @param {string} b version
- * @returns {boolean} true, iff a < b
+ * @param {UserResolveOptions} options resolve options
+ * @returns {Resolver} created resolver
  */
-const versionLt = (a, b) => {
-	// @ts-expect-error
-	a = parseVersion(a);
-	// @ts-expect-error
-	b = parseVersion(b);
-	var i = 0;
-	for (;;) {
-		// a       b  EOA     object  undefined  number  string
-		// EOA        a == b  a < b   b < a      a < b   a < b
-		// object     b < a   (0)     b < a      a < b   a < b
-		// undefined  a < b   a < b   (0)        a < b   a < b
-		// number     b < a   b < a   b < a      (1)     a < b
-		// string     b < a   b < a   b < a      b < a   (1)
-		// EOA end of array
-		// (0) continue on
-		// (1) compare them via "<"
+exports.createResolver = function (options) {
+	const normalizedOptions = createOptions(options);
 
-		// Handles first row in table
-		if (i >= a.length) return i < b.length && (typeof b[i])[0] != "u";
+	const {
+		alias,
+		fallback,
+		aliasFields,
+		cachePredicate,
+		cacheWithContext,
+		conditionNames,
+		descriptionFiles,
+		enforceExtension,
+		exportsFields,
+		importsFields,
+		extensions,
+		fileSystem,
+		fullySpecified,
+		mainFields,
+		mainFiles,
+		modules,
+		plugins: userPlugins,
+		pnpApi,
+		resolveToContext,
+		preferRelative,
+		preferAbsolute,
+		symlinks,
+		unsafeCache,
+		resolver: customResolver,
+		restrictions,
+		roots
+	} = normalizedOptions;
 
-		var aValue = a[i];
-		var aType = (typeof aValue)[0];
+	const plugins = userPlugins.slice();
 
-		// Handles first column in table
-		if (i >= b.length) return aType == "u";
+	const resolver = customResolver
+		? customResolver
+		: new Resolver(fileSystem, normalizedOptions);
+
+	//// pipeline ////
+
+	resolver.ensureHook("resolve");
+	resolver.ensureHook("internalResolve");
+	resolver.ensureHook("newInteralResolve");
+	resolver.ensureHook("parsedResolve");
+	resolver.ensureHook("describedResolve");
+	resolver.ensureHook("internal");
+	resolver.ensureHook("rawModule");
+	resolver.ensureHook("module");
+	resolver.ensureHook("resolveAsModule");
+	resolver.ensureHook("undescribedResolveInPackage");
+	resolver.ensureHook("resolveInPackage");
+	resolver.ensureHook("resolveInExistingDirectory");
+	resolver.ensureHook("relative");
+	resolver.ensureHook("describedRelative");
+	resolver.ensureHook("directory");
+	resolver.ensureHook("undescribedExistingDirectory");
+	resolver.ensureHook("existingDirectory");
+	resolver.ensureHook("undescribedRawFile");
+	resolver.ensureHook("rawFile");
+	resolver.ensureHook("file");
+	resolver.ensureHook("finalFile");
+	resolver.ensureHook("existingFile");
+	resolver.ensureHook("resolved");
+
+	// resolve
+	for (const { source, resolveOptions } of [
+		{ source: "resolve", resolveOptions: { fullySpecified } },
+		{ source: "internal-resolve", resolveOptions: { fullySpecified: false } }
+	]) {
+		if (unsafeCache) {
+			plugins.push(
+				new UnsafeCachePlugin(
+					source,
+					cachePredicate,
+					unsafeCache,
+					cacheWithContext,
+					`new-${source}`
+				)
+			);
+			plugins.push(
+				new ParsePlugin(`new-${source}`, resolveOptions, "parsed-resolve")
+			);
+		} else {
+			plugins.push(new ParsePlugin(source, resolveOptions, "parsed-resolve"));
+		}
+	}
+
+	// parsed-resolve
+	plugins.push(
+		new DescriptionFilePlugin(
+			"parsed-resolve",
+			descriptionFiles,
+			false,
+			"described-resolve"
+		)
+	);
+	plugins.push(new NextPlugin("after-parsed-resolve", "described-resolve"));
+
+	// described-resolve
+	plugins.push(new NextPlugin("described-resolve", "normal-resolve"));
+	if (fallback.length > 0) {
+		plugins.push(
+			new AliasPlugin("described-resolve", fallback, "internal-resolve")
+		);
+	}
+
+	// normal-resolve
+	if (alias.length > 0)
+		plugins.push(new AliasPlugin("normal-resolve", alias, "internal-resolve"));
+	aliasFields.forEach(item => {
+		plugins.push(
+			new AliasFieldPlugin("normal-resolve", item, "internal-resolve")
+		);
+	});
+	if (preferRelative) {
+		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+	}
+	plugins.push(
+		new ConditionalPlugin(
+			"after-normal-resolve",
+			{ module: true },
+			"resolve as module",
+			false,
+			"raw-module"
+		)
+	);
+	plugins.push(
+		new ConditionalPlugin(
+			"after-normal-resolve",
+			{ internal: true },
+			"resolve as internal import",
+			false,
+			"internal"
+		)
+	);
+	if (preferAbsolute) {
+		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+	}
+	if (roots.size > 0) {
+		plugins.push(new RootsPlugin("after-normal-resolve", roots, "relative"));
+	}
+	if (!preferRelative && !preferAbsolute) {
+		plugins.push(new JoinRequestPlugin("after-normal-resolve", "relative"));
+	}
 
-		var bValue = b[i];
-		var bType = (typeof bValue)[0];
+	// internal
+	importsFields.forEach(importsField => {
+		plugins.push(
+			new ImportsFieldPlugin(
+				"internal",
+				conditionNames,
+				importsField,
+				"relative",
+				"internal-resolve"
+			)
+		);
+	});
 
-		if (aType == bType) {
-			if (aType != "o" && aType != "u" && aValue != bValue) {
-				return aValue < bValue;
+	// raw-module
+	exportsFields.forEach(exportsField => {
+		plugins.push(
+			new SelfReferencePlugin("raw-module", exportsField, "resolve-as-module")
+		);
+	});
+	modules.forEach(item => {
+		if (Array.isArray(item)) {
+			if (item.includes("node_modules") && pnpApi) {
+				plugins.push(
+					new ModulesInHierachicDirectoriesPlugin(
+						"raw-module",
+						item.filter(i => i !== "node_modules"),
+						"module"
+					)
+				);
+				plugins.push(
+					new PnpPlugin("raw-module", pnpApi, "undescribed-resolve-in-package")
+				);
+			} else {
+				plugins.push(
+					new ModulesInHierachicDirectoriesPlugin("raw-module", item, "module")
+				);
 			}
-			i++;
 		} else {
-			// Handles remaining cases
-			if (aType == "o" && bType == "n") return true;
-			return bType == "s" || aType == "u";
+			plugins.push(new ModulesInRootPlugin("raw-module", item, "module"));
 		}
-	}
-};
-/* eslint-enable eqeqeq */
-exports.versionLt = versionLt;
+	});
 
-/**
- * @param {string} str range string
- * @returns {SemVerRange} parsed range
- */
-exports.parseRange = str => {
-	const splitAndConvert = str => {
-		return str.split(".").map(item => (`${+item}` === item ? +item : item));
-	};
-	// see https://docs.npmjs.com/misc/semver#range-grammar for grammar
-	const parsePartial = str => {
-		const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
-		/** @type {(string|number|undefined|[])[]} */
-		const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
-		if (match[2]) {
-			ver.length++;
-			ver.push.apply(ver, splitAndConvert(match[2]));
-		}
+	// module
+	plugins.push(new JoinRequestPartPlugin("module", "resolve-as-module"));
 
-		// remove trailing any matchers
-		let last = ver[ver.length - 1];
-		while (
-			ver.length &&
-			(last === undefined || /^[*xX]$/.test(/** @type {string} */ (last)))
-		) {
-			ver.pop();
-			last = ver[ver.length - 1];
-		}
+	// resolve-as-module
+	if (!resolveToContext) {
+		plugins.push(
+			new ConditionalPlugin(
+				"resolve-as-module",
+				{ directory: false, request: "." },
+				"single file module",
+				true,
+				"undescribed-raw-file"
+			)
+		);
+	}
+	plugins.push(
+		new DirectoryExistsPlugin(
+			"resolve-as-module",
+			"undescribed-resolve-in-package"
+		)
+	);
 
-		return ver;
-	};
-	const toFixed = range => {
-		if (range.length === 1) {
-			// Special case for "*" is "x.x.x" instead of "="
-			return [0];
-		} else if (range.length === 2) {
-			// Special case for "1" is "1.x.x" instead of "=1"
-			return [1, ...range.slice(1)];
-		} else if (range.length === 3) {
-			// Special case for "1.2" is "1.2.x" instead of "=1.2"
-			return [2, ...range.slice(1)];
-		} else {
-			return [range.length, ...range.slice(1)];
-		}
-	};
-	const negate = range => {
-		return [-range[0] - 1, ...range.slice(1)];
-	};
-	const parseSimple = str => {
-		// simple     ::= primitive | partial | tilde | caret
-		// primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
-		// tilde      ::= '~' partial
-		// caret      ::= '^' partial
-		const match = /^(\^|~|<=|<|>=|>|=|v|!)/.exec(str);
-		const start = match ? match[0] : "";
-		const remainder = parsePartial(str.slice(start.length));
-		switch (start) {
-			case "^":
-				if (remainder.length > 1 && remainder[1] === 0) {
-					if (remainder.length > 2 && remainder[2] === 0) {
-						return [3, ...remainder.slice(1)];
-					}
-					return [2, ...remainder.slice(1)];
-				}
-				return [1, ...remainder.slice(1)];
-			case "~":
-				return [2, ...remainder.slice(1)];
-			case ">=":
-				return remainder;
-			case "=":
-			case "v":
-			case "":
-				return toFixed(remainder);
-			case "<":
-				return negate(remainder);
-			case ">": {
-				// and( >=, not( = ) ) => >=, =, not, and
-				const fixed = toFixed(remainder);
-				// eslint-disable-next-line no-sparse-arrays
-				return [, fixed, 0, remainder, 2];
-			}
-			case "<=":
-				// or( <, = ) => <, =, or
-				// eslint-disable-next-line no-sparse-arrays
-				return [, toFixed(remainder), negate(remainder), 1];
-			case "!": {
-				// not =
-				const fixed = toFixed(remainder);
-				// eslint-disable-next-line no-sparse-arrays
-				return [, fixed, 0];
-			}
-			default:
-				throw new Error("Unexpected start value");
-		}
-	};
-	const combine = (items, fn) => {
-		if (items.length === 1) return items[0];
-		const arr = [];
-		for (const item of items.slice().reverse()) {
-			if (0 in item) {
-				arr.push(item);
-			} else {
-				arr.push(...item.slice(1));
-			}
-		}
-		// eslint-disable-next-line no-sparse-arrays
-		return [, ...arr, ...items.slice(1).map(() => fn)];
-	};
-	const parseRange = str => {
-		// range      ::= hyphen | simple ( ' ' simple ) * | ''
-		// hyphen     ::= partial ' - ' partial
-		const items = str.split(" - ");
-		if (items.length === 1) {
-			const items = str.trim().split(/\s+/g).map(parseSimple);
-			return combine(items, 2);
-		}
-		const a = parsePartial(items[0]);
-		const b = parsePartial(items[1]);
-		// >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
-		// eslint-disable-next-line no-sparse-arrays
-		return [, toFixed(b), negate(b), 1, a, 2];
-	};
-	const parseLogicalOr = str => {
-		// range-set  ::= range ( logical-or range ) *
-		// logical-or ::= ( ' ' ) * '||' ( ' ' ) *
-		const items = str.split(/\s*\|\|\s*/).map(parseRange);
-		return combine(items, 1);
-	};
-	return parseLogicalOr(str);
-};
+	// undescribed-resolve-in-package
+	plugins.push(
+		new DescriptionFilePlugin(
+			"undescribed-resolve-in-package",
+			descriptionFiles,
+			false,
+			"resolve-in-package"
+		)
+	);
+	plugins.push(
+		new NextPlugin("after-undescribed-resolve-in-package", "resolve-in-package")
+	);
 
-/* eslint-disable eqeqeq */
-const rangeToString = range => {
-	var fixCount = range[0];
-	var str = "";
-	if (range.length === 1) {
-		return "*";
-	} else if (fixCount + 0.5) {
-		str +=
-			fixCount == 0
-				? ">="
-				: fixCount == -1
-				? "<"
-				: fixCount == 1
-				? "^"
-				: fixCount == 2
-				? "~"
-				: fixCount > 0
-				? "="
-				: "!=";
-		var needDot = 1;
-		// eslint-disable-next-line no-redeclare
-		for (var i = 1; i < range.length; i++) {
-			var item = range[i];
-			var t = (typeof item)[0];
-			needDot--;
-			str +=
-				t == "u"
-					? // undefined: prerelease marker, add an "-"
-					  "-"
-					: // number or string: add the item, set flag to add an "." between two of them
-					  (needDot > 0 ? "." : "") + ((needDot = 2), item);
-		}
-		return str;
-	} else {
-		var stack = [];
-		// eslint-disable-next-line no-redeclare
-		for (var i = 1; i < range.length; i++) {
-			// eslint-disable-next-line no-redeclare
-			var item = range[i];
-			stack.push(
-				item === 0
-					? "not(" + pop() + ")"
-					: item === 1
-					? "(" + pop() + " || " + pop() + ")"
-					: item === 2
-					? stack.pop() + " " + stack.pop()
-					: rangeToString(item)
-			);
-		}
-		return pop();
-	}
-	function pop() {
-		return stack.pop().replace(/^\((.+)\)$/, "$1");
-	}
-};
-/* eslint-enable eqeqeq */
-exports.rangeToString = rangeToString;
+	// resolve-in-package
+	exportsFields.forEach(exportsField => {
+		plugins.push(
+			new ExportsFieldPlugin(
+				"resolve-in-package",
+				conditionNames,
+				exportsField,
+				"relative"
+			)
+		);
+	});
+	plugins.push(
+		new NextPlugin("resolve-in-package", "resolve-in-existing-directory")
+	);
 
-/* eslint-disable eqeqeq */
-/**
- * @param {SemVerRange} range version range
- * @param {string} version the version
- * @returns {boolean} if version satisfy the range
- */
-const satisfy = (range, version) => {
-	if (0 in range) {
-		// @ts-expect-error
-		version = parseVersion(version);
-		var fixCount = range[0];
-		// when negated is set it swill set for < instead of >=
-		var negated = fixCount < 0;
-		if (negated) fixCount = -fixCount - 1;
-		for (var i = 0, j = 1, isEqual = true; ; j++, i++) {
-			// cspell:word nequal nequ
+	// resolve-in-existing-directory
+	plugins.push(
+		new JoinRequestPlugin("resolve-in-existing-directory", "relative")
+	);
 
-			// when isEqual = true:
-			// range         version: EOA/object  undefined  number    string
-			// EOA                    equal       block      big-ver   big-ver
-			// undefined              bigger      next       big-ver   big-ver
-			// number                 smaller     block      cmp       big-cmp
-			// fixed number           smaller     block      cmp-fix   differ
-			// string                 smaller     block      differ    cmp
-			// fixed string           smaller     block      small-cmp cmp-fix
+	// relative
+	plugins.push(
+		new DescriptionFilePlugin(
+			"relative",
+			descriptionFiles,
+			true,
+			"described-relative"
+		)
+	);
+	plugins.push(new NextPlugin("after-relative", "described-relative"));
 
-			// when isEqual = false:
-			// range         version: EOA/object  undefined  number    string
-			// EOA                    nequal      block      next-ver  next-ver
-			// undefined              nequal      block      next-ver  next-ver
-			// number                 nequal      block      next      next
-			// fixed number           nequal      block      next      next   (this never happens)
-			// string                 nequal      block      next      next
-			// fixed string           nequal      block      next      next   (this never happens)
+	// described-relative
+	if (resolveToContext) {
+		plugins.push(new NextPlugin("described-relative", "directory"));
+	} else {
+		plugins.push(
+			new ConditionalPlugin(
+				"described-relative",
+				{ directory: false },
+				null,
+				true,
+				"raw-file"
+			)
+		);
+		plugins.push(
+			new ConditionalPlugin(
+				"described-relative",
+				{ fullySpecified: false },
+				"as directory",
+				true,
+				"directory"
+			)
+		);
+	}
 
-			// EOA end of array
-			// equal (version is equal range):
-			//   when !negated: return true,
-			//   when negated: return false
-			// bigger (version is bigger as range):
-			//   when fixed: return false,
-			//   when !negated: return true,
-			//   when negated: return false,
-			// smaller (version is smaller as range):
-			//   when !negated: return false,
-			//   when negated: return true
-			// nequal (version is not equal range (> resp <)): return true
-			// block (version is in different prerelease area): return false
-			// differ (version is different from fixed range (string vs. number)): return false
-			// next: continues to the next items
-			// next-ver: when fixed: return false, continues to the next item only for the version, sets isEqual=false
-			// big-ver: when fixed || negated: return false, continues to the next item only for the version, sets isEqual=false
-			// next-nequ: continues to the next items, sets isEqual=false
-			// cmp (negated === false): version < range => return false, version > range => next-nequ, else => next
-			// cmp (negated === true): version > range => return false, version < range => next-nequ, else => next
-			// cmp-fix: version == range => next, else => return false
-			// big-cmp: when negated => return false, else => next-nequ
-			// small-cmp: when negated => next-nequ, else => return false
+	// directory
+	plugins.push(
+		new DirectoryExistsPlugin("directory", "undescribed-existing-directory")
+	);
 
-			var rangeType = j < range.length ? (typeof range[j])[0] : "";
+	if (resolveToContext) {
+		// undescribed-existing-directory
+		plugins.push(new NextPlugin("undescribed-existing-directory", "resolved"));
+	} else {
+		// undescribed-existing-directory
+		plugins.push(
+			new DescriptionFilePlugin(
+				"undescribed-existing-directory",
+				descriptionFiles,
+				false,
+				"existing-directory"
+			)
+		);
+		mainFiles.forEach(item => {
+			plugins.push(
+				new UseFilePlugin(
+					"undescribed-existing-directory",
+					item,
+					"undescribed-raw-file"
+				)
+			);
+		});
 
-			var versionValue;
-			var versionType;
+		// described-existing-directory
+		mainFields.forEach(item => {
+			plugins.push(
+				new MainFieldPlugin(
+					"existing-directory",
+					item,
+					"resolve-in-existing-directory"
+				)
+			);
+		});
+		mainFiles.forEach(item => {
+			plugins.push(
+				new UseFilePlugin("existing-directory", item, "undescribed-raw-file")
+			);
+		});
 
-			// Handles first column in both tables (end of version or object)
-			if (
-				i >= version.length ||
-				((versionValue = version[i]),
-				(versionType = (typeof versionValue)[0]) == "o")
-			) {
-				// Handles nequal
-				if (!isEqual) return true;
-				// Handles bigger
-				if (rangeType == "u") return j > fixCount && !negated;
-				// Handles equal and smaller: (range === EOA) XOR negated
-				return (rangeType == "") != negated; // equal + smaller
-			}
+		// undescribed-raw-file
+		plugins.push(
+			new DescriptionFilePlugin(
+				"undescribed-raw-file",
+				descriptionFiles,
+				true,
+				"raw-file"
+			)
+		);
+		plugins.push(new NextPlugin("after-undescribed-raw-file", "raw-file"));
 
-			// Handles second column in both tables (version = undefined)
-			if (versionType == "u") {
-				if (!isEqual || rangeType != "u") {
-					return false;
-				}
-			}
+		// raw-file
+		plugins.push(
+			new ConditionalPlugin(
+				"raw-file",
+				{ fullySpecified: true },
+				null,
+				false,
+				"file"
+			)
+		);
+		if (!enforceExtension) {
+			plugins.push(new TryNextPlugin("raw-file", "no extension", "file"));
+		}
+		extensions.forEach(item => {
+			plugins.push(new AppendPlugin("raw-file", item, "file"));
+		});
 
-			// switch between first and second table
-			else if (isEqual) {
-				// Handle diagonal
-				if (rangeType == versionType) {
-					if (j <= fixCount) {
-						// Handles "cmp-fix" cases
-						if (versionValue != range[j]) {
-							return false;
-						}
-					} else {
-						// Handles "cmp" cases
-						if (negated ? versionValue > range[j] : versionValue < range[j]) {
-							return false;
-						}
-						if (versionValue != range[j]) isEqual = false;
-					}
-				}
+		// file
+		if (alias.length > 0)
+			plugins.push(new AliasPlugin("file", alias, "internal-resolve"));
+		aliasFields.forEach(item => {
+			plugins.push(new AliasFieldPlugin("file", item, "internal-resolve"));
+		});
+		plugins.push(new NextPlugin("file", "final-file"));
 
-				// Handle big-ver
-				else if (rangeType != "s" && rangeType != "n") {
-					if (negated || j <= fixCount) return false;
-					isEqual = false;
-					j--;
-				}
+		// final-file
+		plugins.push(new FileExistsPlugin("final-file", "existing-file"));
 
-				// Handle differ, big-cmp and small-cmp
-				else if (j <= fixCount || versionType < rangeType != negated) {
-					return false;
-				} else {
-					isEqual = false;
-				}
-			} else {
-				// Handles all "next-ver" cases in the second table
-				if (rangeType != "s" && rangeType != "n") {
-					isEqual = false;
-					j--;
-				}
+		// existing-file
+		if (symlinks)
+			plugins.push(new SymlinkPlugin("existing-file", "existing-file"));
+		plugins.push(new NextPlugin("existing-file", "resolved"));
+	}
 
-				// next is applied by default
-			}
-		}
+	// resolved
+	if (restrictions.size > 0) {
+		plugins.push(new RestrictionsPlugin(resolver.hooks.resolved, restrictions));
 	}
-	/** @type {(boolean | number)[]} */
-	var stack = [];
-	var p = stack.pop.bind(stack);
-	// eslint-disable-next-line no-redeclare
-	for (var i = 1; i < range.length; i++) {
-		var item = /** @type {SemVerRange | 0 | 1 | 2} */ (range[i]);
-		stack.push(
-			item == 1
-				? p() | p()
-				: item == 2
-				? p() & p()
-				: item
-				? satisfy(item, version)
-				: !p()
-		);
+	plugins.push(new ResultPlugin(resolver.hooks.resolved));
+
+	//// RESOLVER ////
+
+	for (const plugin of plugins) {
+		if (typeof plugin === "function") {
+			plugin.call(resolver, resolver);
+		} else {
+			plugin.apply(resolver);
+		}
 	}
-	return !!p();
+
+	return resolver;
 };
-/* eslint-enable eqeqeq */
-exports.satisfy = satisfy;
 
-exports.stringifyHoley = json => {
-	switch (typeof json) {
-		case "undefined":
-			return "";
-		case "object":
-			if (Array.isArray(json)) {
-				let str = "[";
-				for (let i = 0; i < json.length; i++) {
-					if (i !== 0) str += ",";
-					str += this.stringifyHoley(json[i]);
-				}
-				str += "]";
-				return str;
+/**
+ * Merging filtered elements
+ * @param {string[]} array source array
+ * @param {function(string): boolean} filter predicate
+ * @returns {Array<string | string[]>} merge result
+ */
+function mergeFilteredToArray(array, filter) {
+	/** @type {Array<string | string[]>} */
+	const result = [];
+	const set = new Set(array);
+
+	for (const item of set) {
+		if (filter(item)) {
+			const lastElement =
+				result.length > 0 ? result[result.length - 1] : undefined;
+			if (Array.isArray(lastElement)) {
+				lastElement.push(item);
 			} else {
-				return JSON.stringify(json);
+				result.push([item]);
 			}
-		default:
-			return JSON.stringify(json);
+		} else {
+			result.push(item);
+		}
 	}
-};
-
-//#region runtime code: parseVersion
-exports.parseVersionRuntimeCode = runtimeTemplate =>
-	`var parseVersion = ${runtimeTemplate.basicFunction("str", [
-		"// see webpack/lib/util/semver.js for original code",
-		`var p=${
-			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
-		}{return p.split(".").map((${
-			runtimeTemplate.supportsArrowFunction() ? "p=>" : "function(p)"
-		}{return+p==p?+p:p}))},n=/^([^-+]+)?(?:-([^+]+))?(?:\\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;`
-	])}`;
-//#endregion
-
-//#region runtime code: versionLt
-exports.versionLtRuntimeCode = runtimeTemplate =>
-	`var versionLt = ${runtimeTemplate.basicFunction("a, b", [
-		"// see webpack/lib/util/semver.js for original code",
-		'a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}'
-	])}`;
-//#endregion
 
-//#region runtime code: rangeToString
-exports.rangeToStringRuntimeCode = runtimeTemplate =>
-	`var rangeToString = ${runtimeTemplate.basicFunction("range", [
-		"// see webpack/lib/util/semver.js for original code",
-		'var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\\((.+)\\)$/,"$1")}'
-	])}`;
-//#endregion
-
-//#region runtime code: satisfy
-exports.satisfyRuntimeCode = runtimeTemplate =>
-	`var satisfy = ${runtimeTemplate.basicFunction("range, version", [
-		"// see webpack/lib/util/semver.js for original code",
-		'if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1;a=!1}else"s"!=g&&"n"!=g&&(a=!1,i--)}}var t=[],o=t.pop.bind(t);for(n=1;n<range.length;n++){var u=range[n];t.push(1==u?o()|o():2==u?o()&o():u?satisfy(u,version):!o())}return!!o();'
-	])}`;
-//#endregion
+	return result;
+}
 
 
 /***/ }),
 
-/***/ 8282:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 36400:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../serialization/Serializer")} Serializer */
-
-const getBinaryMiddleware = memoize(() =>
-	__webpack_require__(97059)
-);
-const getObjectMiddleware = memoize(() =>
-	__webpack_require__(34795)
-);
-const getSingleItemMiddleware = memoize(() =>
-	__webpack_require__(65112)
-);
-const getSerializer = memoize(() => __webpack_require__(53080));
-const getSerializerMiddleware = memoize(() =>
-	__webpack_require__(83137)
-);
-
-const getBinaryMiddlewareInstance = memoize(
-	() => new (getBinaryMiddleware())()
-);
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-const registerSerializers = memoize(() => {
-	__webpack_require__(26611);
+const slashCode = "/".charCodeAt(0);
+const backslashCode = "\\".charCodeAt(0);
 
-	// Load internal paths with a relative require
-	// This allows bundling all internal serializers
-	const internalSerializables = __webpack_require__(53023);
-	getObjectMiddleware().registerLoader(/^webpack\/lib\//, req => {
-		const loader = internalSerializables[req.slice("webpack/lib/".length)];
-		if (loader) {
-			loader();
-		} else {
-			console.warn(`${req} not found in internalSerializables`);
-		}
-		return true;
-	});
-});
+const isInside = (path, parent) => {
+	if (!path.startsWith(parent)) return false;
+	if (path.length === parent.length) return true;
+	const charCode = path.charCodeAt(parent.length);
+	return charCode === slashCode || charCode === backslashCode;
+};
 
-/** @type {Serializer} */
-let buffersSerializer;
+module.exports = class RestrictionsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {Set<string | RegExp>} restrictions restrictions
+	 */
+	constructor(source, restrictions) {
+		this.source = source;
+		this.restrictions = restrictions;
+	}
 
-// Expose serialization API
-module.exports = {
-	get register() {
-		return getObjectMiddleware().register;
-	},
-	get registerLoader() {
-		return getObjectMiddleware().registerLoader;
-	},
-	get registerNotSerializable() {
-		return getObjectMiddleware().registerNotSerializable;
-	},
-	get NOT_SERIALIZABLE() {
-		return getObjectMiddleware().NOT_SERIALIZABLE;
-	},
-	/** @type {MEASURE_START_OPERATION} */
-	get MEASURE_START_OPERATION() {
-		return getBinaryMiddleware().MEASURE_START_OPERATION;
-	},
-	/** @type {MEASURE_END_OPERATION} */
-	get MEASURE_END_OPERATION() {
-		return getBinaryMiddleware().MEASURE_END_OPERATION;
-	},
-	get buffersSerializer() {
-		if (buffersSerializer !== undefined) return buffersSerializer;
-		registerSerializers();
-		const Serializer = getSerializer();
-		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
-		const SingleItemMiddleware = getSingleItemMiddleware();
-		return (buffersSerializer = new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if (context.write) {
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-				}
-			}, "md4"),
-			binaryMiddleware
-		]));
-	},
-	createFileSerializer: (fs, hashFunction) => {
-		registerSerializers();
-		const Serializer = getSerializer();
-		const FileMiddleware = __webpack_require__(65321);
-		const fileMiddleware = new FileMiddleware(fs, hashFunction);
-		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
-		const SingleItemMiddleware = getSingleItemMiddleware();
-		return new Serializer([
-			new SingleItemMiddleware(),
-			new (getObjectMiddleware())(context => {
-				if (context.write) {
-					context.writeLazy = value => {
-						context.write(
-							SerializerMiddleware.createLazy(value, binaryMiddleware)
-						);
-					};
-					context.writeSeparate = (value, options) => {
-						const lazy = SerializerMiddleware.createLazy(
-							value,
-							fileMiddleware,
-							options
-						);
-						context.write(lazy);
-						return lazy;
-					};
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		resolver
+			.getHook(this.source)
+			.tapAsync("RestrictionsPlugin", (request, resolveContext, callback) => {
+				if (typeof request.path === "string") {
+					const path = request.path;
+					for (const rule of this.restrictions) {
+						if (typeof rule === "string") {
+							if (!isInside(path, rule)) {
+								if (resolveContext.log) {
+									resolveContext.log(
+										`${path} is not inside of the restriction ${rule}`
+									);
+								}
+								return callback(null, null);
+							}
+						} else if (!rule.test(path)) {
+							if (resolveContext.log) {
+								resolveContext.log(
+									`${path} doesn't match the restriction ${rule}`
+								);
+							}
+							return callback(null, null);
+						}
+					}
 				}
-			}, hashFunction),
-			binaryMiddleware,
-			fileMiddleware
-		]);
+
+				callback();
+			});
 	}
 };
 
 
 /***/ }),
 
-/***/ 15652:
+/***/ 13965:
 /***/ (function(module) {
 
 "use strict";
@@ -136455,211 +137041,112 @@ module.exports = {
 
 
 
-/**
- * @typedef {Object} GroupOptions
- * @property {boolean=} groupChildren
- * @property {boolean=} force
- * @property {number=} targetGroupCount
- */
-
-/**
- * @template T
- * @template R
- * @typedef {Object} GroupConfig
- * @property {function(T): string[]} getKeys
- * @property {function(string, (R | T)[], T[]): R} createGroup
- * @property {function(string, T[]): GroupOptions=} getOptions
- */
-
-/**
- * @template T
- * @template R
- * @typedef {Object} ItemWithGroups
- * @property {T} item
- * @property {Set<Group<T, R>>} groups
- */
-
-/**
- * @template T
- * @template R
- * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
- */
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-/**
- * @template T
- * @template R
- * @param {T[]} items the list of items
- * @param {GroupConfig<T, R>[]} groupConfigs configuration
- * @returns {(R | T)[]} grouped items
- */
-const smartGrouping = (items, groupConfigs) => {
-	/** @type {Set<ItemWithGroups<T, R>>} */
-	const itemsWithGroups = new Set();
-	/** @type {Map<string, Group<T, R>>} */
-	const allGroups = new Map();
-	for (const item of items) {
-		/** @type {Set<Group<T, R>>} */
-		const groups = new Set();
-		for (let i = 0; i < groupConfigs.length; i++) {
-			const groupConfig = groupConfigs[i];
-			const keys = groupConfig.getKeys(item);
-			if (keys) {
-				for (const name of keys) {
-					const key = `${i}:${name}`;
-					let group = allGroups.get(key);
-					if (group === undefined) {
-						allGroups.set(
-							key,
-							(group = {
-								config: groupConfig,
-								name,
-								alreadyGrouped: false,
-								items: undefined
-							})
-						);
-					}
-					groups.add(group);
-				}
-			}
-		}
-		itemsWithGroups.add({
-			item,
-			groups
-		});
+module.exports = class ResultPlugin {
+	/**
+	 * @param {ResolveStepHook} source source
+	 */
+	constructor(source) {
+		this.source = source;
 	}
+
 	/**
-	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
-	 * @returns {(T | R)[]} groups items
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
 	 */
-	const runGrouping = itemsWithGroups => {
-		const totalSize = itemsWithGroups.size;
-		for (const entry of itemsWithGroups) {
-			for (const group of entry.groups) {
-				if (group.alreadyGrouped) continue;
-				const items = group.items;
-				if (items === undefined) {
-					group.items = new Set([entry]);
-				} else {
-					items.add(entry);
-				}
-			}
-		}
-		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
-		const groupMap = new Map();
-		for (const group of allGroups.values()) {
-			if (group.items) {
-				const items = group.items;
-				group.items = undefined;
-				groupMap.set(group, {
-					items,
-					options: undefined,
-					used: false
+	apply(resolver) {
+		this.source.tapAsync(
+			"ResultPlugin",
+			(request, resolverContext, callback) => {
+				const obj = { ...request };
+				if (resolverContext.log)
+					resolverContext.log("reporting result " + obj.path);
+				resolver.hooks.result.callAsync(obj, resolverContext, err => {
+					if (err) return callback(err);
+					callback(null, obj);
 				});
 			}
-		}
-		/** @type {(T | R)[]} */
-		const results = [];
-		for (;;) {
-			/** @type {Group<T, R>} */
-			let bestGroup = undefined;
-			let bestGroupSize = -1;
-			let bestGroupItems = undefined;
-			let bestGroupOptions = undefined;
-			for (const [group, state] of groupMap) {
-				const { items, used } = state;
-				let options = state.options;
-				if (options === undefined) {
-					const groupConfig = group.config;
-					state.options = options =
-						(groupConfig.getOptions &&
-							groupConfig.getOptions(
-								group.name,
-								Array.from(items, ({ item }) => item)
-							)) ||
-						false;
-				}
+		);
+	}
+};
 
-				const force = options && options.force;
-				if (!force) {
-					if (bestGroupOptions && bestGroupOptions.force) continue;
-					if (used) continue;
-					if (items.size <= 1 || totalSize - items.size <= 1) {
-						continue;
-					}
-				}
-				const targetGroupCount = (options && options.targetGroupCount) || 4;
-				let sizeValue = force
-					? items.size
-					: Math.min(
-							items.size,
-							(totalSize * 2) / targetGroupCount +
-								itemsWithGroups.size -
-								items.size
-					  );
-				if (
-					sizeValue > bestGroupSize ||
-					(force && (!bestGroupOptions || !bestGroupOptions.force))
-				) {
-					bestGroup = group;
-					bestGroupSize = sizeValue;
-					bestGroupItems = items;
-					bestGroupOptions = options;
-				}
-			}
-			if (bestGroup === undefined) {
-				break;
-			}
-			const items = new Set(bestGroupItems);
-			const options = bestGroupOptions;
 
-			const groupChildren = !options || options.groupChildren !== false;
+/***/ }),
 
-			for (const item of items) {
-				itemsWithGroups.delete(item);
-				// Remove all groups that items have from the map to not select them again
-				for (const group of item.groups) {
-					const state = groupMap.get(group);
-					if (state !== undefined) {
-						state.items.delete(item);
-						if (state.items.size === 0) {
-							groupMap.delete(group);
-						} else {
-							state.options = undefined;
-							if (groupChildren) {
-								state.used = true;
-							}
-						}
-					}
-				}
-			}
-			groupMap.delete(bestGroup);
+/***/ 66737:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-			const key = bestGroup.name;
-			const groupConfig = bestGroup.config;
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
 
-			const allItems = Array.from(items, ({ item }) => item);
 
-			bestGroup.alreadyGrouped = true;
-			const children = groupChildren ? runGrouping(items) : allItems;
-			bestGroup.alreadyGrouped = false;
 
-			results.push(groupConfig.createGroup(key, children, allItems));
-		}
-		for (const { item } of itemsWithGroups) {
-			results.push(item);
-		}
-		return results;
-	};
-	return runGrouping(itemsWithGroups);
-};
+const forEachBail = __webpack_require__(78565);
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+class RootsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source hook
+	 * @param {Set<string>} roots roots
+	 * @param {string | ResolveStepHook} target target hook
+	 */
+	constructor(source, roots, target) {
+		this.roots = Array.from(roots);
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+
+		resolver
+			.getHook(this.source)
+			.tapAsync("RootsPlugin", (request, resolveContext, callback) => {
+				const req = request.request;
+				if (!req) return callback();
+				if (!req.startsWith("/")) return callback();
 
-module.exports = smartGrouping;
+				forEachBail(
+					this.roots,
+					(root, callback) => {
+						const path = resolver.join(root, req.slice(1));
+						const obj = {
+							...request,
+							path,
+							relativePath: request.relativePath && path
+						};
+						resolver.doResolve(
+							target,
+							obj,
+							`root path ${root}`,
+							resolveContext,
+							callback
+						);
+					},
+					callback
+				);
+			});
+	}
+}
+
+module.exports = RootsPlugin;
 
 
 /***/ }),
 
-/***/ 41245:
-/***/ (function(__unused_webpack_module, exports) {
+/***/ 52232:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
@@ -136669,65 +137156,84 @@ module.exports = smartGrouping;
 
 
 
-/** @typedef {import("webpack-sources").Source} Source */
+const DescriptionFileUtils = __webpack_require__(25424);
 
-/** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
-const equalityCache = new WeakMap();
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-/**
- * @param {Source} a a source
- * @param {Source} b another source
- * @returns {boolean} true, when both sources are equal
- */
-const _isSourceEqual = (a, b) => {
-	// prefer .buffer(), it's called anyway during emit
-	/** @type {Buffer|string} */
-	let aSource = typeof a.buffer === "function" ? a.buffer() : a.source();
-	/** @type {Buffer|string} */
-	let bSource = typeof b.buffer === "function" ? b.buffer() : b.source();
-	if (aSource === bSource) return true;
-	if (typeof aSource === "string" && typeof bSource === "string") return false;
-	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf-8");
-	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf-8");
-	return aSource.equals(bSource);
-};
+const slashCode = "/".charCodeAt(0);
 
-/**
- * @param {Source} a a source
- * @param {Source} b another source
- * @returns {boolean} true, when both sources are equal
- */
-const isSourceEqual = (a, b) => {
-	if (a === b) return true;
-	const cache1 = equalityCache.get(a);
-	if (cache1 !== undefined) {
-		const result = cache1.get(b);
-		if (result !== undefined) return result;
-	}
-	const result = _isSourceEqual(a, b);
-	if (cache1 !== undefined) {
-		cache1.set(b, result);
-	} else {
-		const map = new WeakMap();
-		map.set(b, result);
-		equalityCache.set(a, map);
+module.exports = class SelfReferencePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | string[]} fieldNamePath name path
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, fieldNamePath, target) {
+		this.source = source;
+		this.target = target;
+		this.fieldName = fieldNamePath;
 	}
-	const cache2 = equalityCache.get(b);
-	if (cache2 !== undefined) {
-		cache2.set(a, result);
-	} else {
-		const map = new WeakMap();
-		map.set(a, result);
-		equalityCache.set(b, map);
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("SelfReferencePlugin", (request, resolveContext, callback) => {
+				if (!request.descriptionFilePath) return callback();
+
+				const req = request.request;
+				if (!req) return callback();
+
+				// Feature is only enabled when an exports field is present
+				const exportsField = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.fieldName
+				);
+				if (!exportsField) return callback();
+
+				const name = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					"name"
+				);
+				if (typeof name !== "string") return callback();
+
+				if (
+					req.startsWith(name) &&
+					(req.length === name.length ||
+						req.charCodeAt(name.length) === slashCode)
+				) {
+					const remainingRequest = `.${req.slice(name.length)}`;
+
+					const obj = {
+						...request,
+						request: remainingRequest,
+						path: /** @type {string} */ (request.descriptionFileRoot),
+						relativePath: "."
+					};
+
+					resolver.doResolve(
+						target,
+						obj,
+						"self reference",
+						resolveContext,
+						callback
+					);
+				} else {
+					return callback();
+				}
+			});
 	}
-	return result;
 };
-exports.isSourceEqual = isSourceEqual;
 
 
 /***/ }),
 
-/***/ 12047:
+/***/ 58885:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -136738,180 +137244,93 @@ exports.isSourceEqual = isSourceEqual;
 
 
 
-const { validate } = __webpack_require__(38476);
-
-/* cSpell:disable */
-const DID_YOU_MEAN = {
-	rules: "module.rules",
-	loaders: "module.rules or module.rules.*.use",
-	query: "module.rules.*.options (BREAKING CHANGE since webpack 5)",
-	noParse: "module.noParse",
-	filename: "output.filename or module.rules.*.generator.filename",
-	file: "output.filename",
-	chunkFilename: "output.chunkFilename",
-	chunkfilename: "output.chunkFilename",
-	ecmaVersion:
-		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	ecmaversion:
-		"output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	ecma: "output.environment (output.ecmaVersion was a temporary configuration option during webpack 5 beta)",
-	path: "output.path",
-	pathinfo: "output.pathinfo",
-	pathInfo: "output.pathinfo",
-	jsonpFunction: "output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
-	chunkCallbackName:
-		"output.chunkLoadingGlobal (BREAKING CHANGE since webpack 5)",
-	jsonpScriptType: "output.scriptType (BREAKING CHANGE since webpack 5)",
-	hotUpdateFunction: "output.hotUpdateGlobal (BREAKING CHANGE since webpack 5)",
-	splitChunks: "optimization.splitChunks",
-	immutablePaths: "snapshot.immutablePaths",
-	managedPaths: "snapshot.managedPaths",
-	maxModules: "stats.modulesSpace (BREAKING CHANGE since webpack 5)",
-	hashedModuleIds:
-		'optimization.moduleIds: "hashed" (BREAKING CHANGE since webpack 5)',
-	namedChunks:
-		'optimization.chunkIds: "named" (BREAKING CHANGE since webpack 5)',
-	namedModules:
-		'optimization.moduleIds: "named" (BREAKING CHANGE since webpack 5)',
-	occurrenceOrder:
-		'optimization.chunkIds: "size" and optimization.moduleIds: "size" (BREAKING CHANGE since webpack 5)',
-	automaticNamePrefix:
-		"optimization.splitChunks.[cacheGroups.*].idHint (BREAKING CHANGE since webpack 5)",
-	noEmitOnErrors:
-		"optimization.emitOnErrors (BREAKING CHANGE since webpack 5: logic is inverted to avoid negative flags)",
-	Buffer:
-		"to use the ProvidePlugin to process the Buffer variable to modules as polyfill\n" +
-		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
-		"Note: if you are using 'node.Buffer: false', you can just remove that as this is the default behavior now.\n" +
-		"To provide a polyfill to modules use:\n" +
-		'new ProvidePlugin({ Buffer: ["buffer", "Buffer"] }) and npm install buffer.',
-	process:
-		"to use the ProvidePlugin to process the process variable to modules as polyfill\n" +
-		"BREAKING CHANGE: webpack 5 no longer provided Node.js polyfills by default.\n" +
-		"Note: if you are using 'node.process: false', you can just remove that as this is the default behavior now.\n" +
-		"To provide a polyfill to modules use:\n" +
-		'new ProvidePlugin({ process: "process" }) and npm install buffer.'
-};
+const forEachBail = __webpack_require__(78565);
+const getPaths = __webpack_require__(82918);
+const { getType, PathType } = __webpack_require__(67079);
 
-const REMOVED = {
-	concord:
-		"BREAKING CHANGE: resolve.concord has been removed and is no longer available.",
-	devtoolLineToLine:
-		"BREAKING CHANGE: output.devtoolLineToLine has been removed and is no longer available."
-};
-/* cSpell:enable */
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-/**
- * @param {Parameters<typeof validate>[0]} schema a json schema
- * @param {Parameters<typeof validate>[1]} options the options that should be validated
- * @param {Parameters<typeof validate>[2]=} validationConfiguration configuration for generating errors
- * @returns {void}
- */
-const validateSchema = (schema, options, validationConfiguration) => {
-	validate(
-		schema,
-		options,
-		validationConfiguration || {
-			name: "Webpack",
-			postFormatter: (formattedError, error) => {
-				const children = error.children;
-				if (
-					children &&
-					children.some(
-						child =>
-							child.keyword === "absolutePath" &&
-							child.dataPath === ".output.filename"
-					)
-				) {
-					return `${formattedError}\nPlease use output.path to specify absolute path and output.filename for the file name.`;
-				}
+module.exports = class SymlinkPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
 
-				if (
-					children &&
-					children.some(
-						child =>
-							child.keyword === "pattern" && child.dataPath === ".devtool"
-					)
-				) {
-					return (
-						`${formattedError}\n` +
-						"BREAKING CHANGE since webpack 5: The devtool option is more strict.\n" +
-						"Please strictly follow the order of the keywords in the pattern."
-					);
-				}
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const fs = resolver.fileSystem;
+		resolver
+			.getHook(this.source)
+			.tapAsync("SymlinkPlugin", (request, resolveContext, callback) => {
+				if (request.ignoreSymlinks) return callback();
+				const pathsResult = getPaths(request.path);
+				const pathSeqments = pathsResult.seqments;
+				const paths = pathsResult.paths;
 
-				if (error.keyword === "additionalProperties") {
-					const params =
-						/** @type {import("ajv").AdditionalPropertiesParams} */ (
-							error.params
+				let containsSymlink = false;
+				let idx = -1;
+				forEachBail(
+					paths,
+					(path, callback) => {
+						idx++;
+						if (resolveContext.fileDependencies)
+							resolveContext.fileDependencies.add(path);
+						fs.readlink(path, (err, result) => {
+							if (!err && result) {
+								pathSeqments[idx] = result;
+								containsSymlink = true;
+								// Shortcut when absolute symlink found
+								const resultType = getType(result.toString());
+								if (
+									resultType === PathType.AbsoluteWin ||
+									resultType === PathType.AbsolutePosix
+								) {
+									return callback(null, idx);
+								}
+							}
+							callback();
+						});
+					},
+					(err, idx) => {
+						if (!containsSymlink) return callback();
+						const resultSeqments =
+							typeof idx === "number"
+								? pathSeqments.slice(0, idx + 1)
+								: pathSeqments.slice();
+						const result = resultSeqments.reduceRight((a, b) => {
+							return resolver.join(a, b);
+						});
+						const obj = {
+							...request,
+							path: result
+						};
+						resolver.doResolve(
+							target,
+							obj,
+							"resolved symlink to " + result,
+							resolveContext,
+							callback
 						);
-					if (
-						Object.prototype.hasOwnProperty.call(
-							DID_YOU_MEAN,
-							params.additionalProperty
-						)
-					) {
-						return `${formattedError}\nDid you mean ${
-							DID_YOU_MEAN[params.additionalProperty]
-						}?`;
-					}
-
-					if (
-						Object.prototype.hasOwnProperty.call(
-							REMOVED,
-							params.additionalProperty
-						)
-					) {
-						return `${formattedError}\n${REMOVED[params.additionalProperty]}?`;
-					}
-
-					if (!error.dataPath) {
-						if (params.additionalProperty === "debug") {
-							return (
-								`${formattedError}\n` +
-								"The 'debug' property was removed in webpack 2.0.0.\n" +
-								"Loaders should be updated to allow passing this option via loader options in module.rules.\n" +
-								"Until loaders are updated one can use the LoaderOptionsPlugin to switch loaders into debug mode:\n" +
-								"plugins: [\n" +
-								"  new webpack.LoaderOptionsPlugin({\n" +
-								"    debug: true\n" +
-								"  })\n" +
-								"]"
-							);
-						}
-
-						if (params.additionalProperty) {
-							return (
-								`${formattedError}\n` +
-								"For typos: please correct them.\n" +
-								"For loader options: webpack >= v2.0.0 no longer allows custom properties in configuration.\n" +
-								"  Loaders should be updated to allow passing options via loader options in module.rules.\n" +
-								"  Until loaders are updated one can use the LoaderOptionsPlugin to pass these options to the loader:\n" +
-								"  plugins: [\n" +
-								"    new webpack.LoaderOptionsPlugin({\n" +
-								"      // test: /\\.xxx$/, // may apply this only for some modules\n" +
-								"      options: {\n" +
-								`        ${params.additionalProperty}: …\n` +
-								"      }\n" +
-								"    })\n" +
-								"  ]"
-							);
-						}
 					}
-				}
-
-				return formattedError;
-			}
-		}
-	);
+				);
+			});
+	}
 };
-module.exports = validateSchema;
 
 
 /***/ }),
 
-/***/ 5434:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 87474:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -136921,83 +137340,100 @@ module.exports = validateSchema;
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").SyncFileSystem} SyncFileSystem */
 
-class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
-	constructor({ generateLoadBinaryCode, supportsStreaming }) {
-		super("wasm loading", RuntimeModule.STAGE_NORMAL);
-		this.generateLoadBinaryCode = generateLoadBinaryCode;
-		this.supportsStreaming = supportsStreaming;
-	}
+/**
+ * @param {SyncFileSystem} fs file system implementation
+ * @constructor
+ */
+function SyncAsyncFileSystemDecorator(fs) {
+	this.fs = fs;
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { compilation, chunk } = this;
-		const { outputOptions, runtimeTemplate } = compilation;
-		const fn = RuntimeGlobals.instantiateWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: `" + wasmModuleHash + "`,
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
+	this.lstat = undefined;
+	this.lstatSync = undefined;
+	const lstatSync = fs.lstatSync;
+	if (lstatSync) {
+		this.lstat = (arg, options, callback) => {
+			let result;
+			try {
+				result = lstatSync.call(fs, arg);
+			} catch (e) {
+				return (callback || options)(e);
 			}
-		);
-		return `${fn} = ${runtimeTemplate.basicFunction(
-			"exports, wasmModuleId, wasmModuleHash, importsObj",
-			[
-				`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
-				this.supportsStreaming
-					? Template.asString([
-							"if (typeof WebAssembly.instantiateStreaming === 'function') {",
-							Template.indent([
-								"return WebAssembly.instantiateStreaming(req, importsObj)",
-								Template.indent([
-									`.then(${runtimeTemplate.returningFunction(
-										"Object.assign(exports, res.instance.exports)",
-										"res"
-									)});`
-								])
-							]),
-							"}"
-					  ])
-					: "// no support for streaming compilation",
-				"return req",
-				Template.indent([
-					`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"WebAssembly.instantiate(bytes, importsObj)",
-						"bytes"
-					)})`,
-					`.then(${runtimeTemplate.returningFunction(
-						"Object.assign(exports, res.instance.exports)",
-						"res"
-					)});`
-				])
-			]
-		)};`;
+			(callback || options)(null, result);
+		};
+		this.lstatSync = (arg, options) => lstatSync.call(fs, arg, options);
+	}
+
+	this.stat = (arg, options, callback) => {
+		let result;
+		try {
+			result = callback ? fs.statSync(arg, options) : fs.statSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.statSync = (arg, options) => fs.statSync(arg, options);
+
+	this.readdir = (arg, options, callback) => {
+		let result;
+		try {
+			result = fs.readdirSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.readdirSync = (arg, options) => fs.readdirSync(arg, options);
+
+	this.readFile = (arg, options, callback) => {
+		let result;
+		try {
+			result = fs.readFileSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.readFileSync = (arg, options) => fs.readFileSync(arg, options);
+
+	this.readlink = (arg, options, callback) => {
+		let result;
+		try {
+			result = fs.readlinkSync(arg);
+		} catch (e) {
+			return (callback || options)(e);
+		}
+		(callback || options)(null, result);
+	};
+	this.readlinkSync = (arg, options) => fs.readlinkSync(arg, options);
+
+	this.readJson = undefined;
+	this.readJsonSync = undefined;
+	const readJsonSync = fs.readJsonSync;
+	if (readJsonSync) {
+		this.readJson = (arg, options, callback) => {
+			let result;
+			try {
+				result = readJsonSync.call(fs, arg);
+			} catch (e) {
+				return (callback || options)(e);
+			}
+			(callback || options)(null, result);
+		};
+
+		this.readJsonSync = (arg, options) => readJsonSync.call(fs, arg, options);
 	}
 }
-
-module.exports = AsyncWasmLoadingRuntimeModule;
+module.exports = SyncAsyncFileSystemDecorator;
 
 
 /***/ }),
 
-/***/ 58461:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 99324:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -137007,58 +137443,46 @@ module.exports = AsyncWasmLoadingRuntimeModule;
 
 
 
-const Generator = __webpack_require__(93401);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-
-const TYPES = new Set(["webassembly"]);
-
-class AsyncWebAssemblyGenerator extends Generator {
-	constructor(options) {
-		super();
-		this.options = options;
-	}
-
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
+module.exports = class TryNextPlugin {
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} message message
+	 * @param {string | ResolveStepHook} target target
 	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 0;
-		}
-		return originalSource.size();
+	constructor(source, message, target) {
+		this.source = source;
+		this.message = message;
+		this.target = target;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
 	 */
-	generate(module, generateContext) {
-		return module.originalSource();
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("TryNextPlugin", (request, resolveContext, callback) => {
+				resolver.doResolve(
+					target,
+					request,
+					this.message,
+					resolveContext,
+					callback
+				);
+			});
 	}
-}
-
-module.exports = AsyncWebAssemblyGenerator;
+};
 
 
 /***/ }),
 
-/***/ 95614:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 41606:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -137068,199 +137492,72 @@ module.exports = AsyncWebAssemblyGenerator;
 
 
 
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const WebAssemblyImportDependency = __webpack_require__(5239);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-
-const TYPES = new Set(["webassembly"]);
-
-class AsyncWebAssemblyJavascriptGenerator extends Generator {
-	constructor(filenameTemplate) {
-		super();
-		this.filenameTemplate = filenameTemplate;
-	}
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {{[k: string]: any}} Cache */
 
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
-	}
+function getCacheId(request, withContext) {
+	return JSON.stringify({
+		context: withContext ? request.context : "",
+		path: request.path,
+		query: request.query,
+		fragment: request.fragment,
+		request: request.request
+	});
+}
 
+module.exports = class UnsafeCachePlugin {
 	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
+	 * @param {string | ResolveStepHook} source source
+	 * @param {function(ResolveRequest): boolean} filterPredicate filterPredicate
+	 * @param {Cache} cache cache
+	 * @param {boolean} withContext withContext
+	 * @param {string | ResolveStepHook} target target
 	 */
-	getSize(module, type) {
-		return 40 + module.dependencies.length * 10;
+	constructor(source, filterPredicate, cache, withContext, target) {
+		this.source = source;
+		this.filterPredicate = filterPredicate;
+		this.withContext = withContext;
+		this.cache = cache;
+		this.target = target;
 	}
 
 	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
 	 */
-	generate(module, generateContext) {
-		const {
-			runtimeTemplate,
-			chunkGraph,
-			moduleGraph,
-			runtimeRequirements,
-			runtime
-		} = generateContext;
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.exports);
-		runtimeRequirements.add(RuntimeGlobals.instantiateWasm);
-		/** @type {InitFragment[]} */
-		const initFragments = [];
-		/** @type {Map<Module, { request: string, importVar: string }>} */
-		const depModules = new Map();
-		/** @type {Map<string, WebAssemblyImportDependency[]>} */
-		const wasmDepsByRequest = new Map();
-		for (const dep of module.dependencies) {
-			if (dep instanceof WebAssemblyImportDependency) {
-				const module = moduleGraph.getModule(dep);
-				if (!depModules.has(module)) {
-					depModules.set(module, {
-						request: dep.request,
-						importVar: `WEBPACK_IMPORTED_MODULE_${depModules.size}`
-					});
-				}
-				let list = wasmDepsByRequest.get(dep.request);
-				if (list === undefined) {
-					list = [];
-					wasmDepsByRequest.set(dep.request, list);
-				}
-				list.push(dep);
-			}
-		}
-
-		const promises = [];
-
-		const importStatements = Array.from(
-			depModules,
-			([importedModule, { request, importVar }]) => {
-				if (moduleGraph.isAsync(importedModule)) {
-					promises.push(importVar);
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
+				if (!this.filterPredicate(request)) return callback();
+				const cacheId = getCacheId(request, this.withContext);
+				const cacheEntry = this.cache[cacheId];
+				if (cacheEntry) {
+					return callback(null, cacheEntry);
 				}
-				return runtimeTemplate.importStatement({
-					update: false,
-					module: importedModule,
-					chunkGraph,
+				resolver.doResolve(
+					target,
 					request,
-					originModule: module,
-					importVar,
-					runtimeRequirements
-				});
-			}
-		);
-		const importsCode = importStatements.map(([x]) => x).join("");
-		const importsCompatCode = importStatements.map(([_, x]) => x).join("");
-
-		const importObjRequestItems = Array.from(
-			wasmDepsByRequest,
-			([request, deps]) => {
-				const exportItems = deps.map(dep => {
-					const importedModule = moduleGraph.getModule(dep);
-					const importVar = depModules.get(importedModule).importVar;
-					return `${JSON.stringify(
-						dep.name
-					)}: ${runtimeTemplate.exportFromImport({
-						moduleGraph,
-						module: importedModule,
-						request,
-						exportName: dep.name,
-						originModule: module,
-						asiSafe: true,
-						isCall: false,
-						callContext: false,
-						defaultInterop: true,
-						importVar,
-						initFragments,
-						runtime,
-						runtimeRequirements
-					})}`;
-				});
-				return Template.asString([
-					`${JSON.stringify(request)}: {`,
-					Template.indent(exportItems.join(",\n")),
-					"}"
-				]);
-			}
-		);
-
-		const importsObj =
-			importObjRequestItems.length > 0
-				? Template.asString([
-						"{",
-						Template.indent(importObjRequestItems.join(",\n")),
-						"}"
-				  ])
-				: undefined;
-
-		const instantiateCall =
-			`${RuntimeGlobals.instantiateWasm}(${module.exportsArgument}, ${
-				module.moduleArgument
-			}.id, ${JSON.stringify(
-				chunkGraph.getRenderedModuleHash(module, runtime)
-			)}` + (importsObj ? `, ${importsObj})` : `)`);
-
-		if (promises.length > 0)
-			runtimeRequirements.add(RuntimeGlobals.asyncModule);
-
-		const source = new RawSource(
-			promises.length > 0
-				? Template.asString([
-						`var __webpack_instantiate__ = ${runtimeTemplate.basicFunction(
-							`[${promises.join(", ")}]`,
-							`${importsCompatCode}return ${instantiateCall};`
-						)}`,
-						`${RuntimeGlobals.asyncModule}(${
-							module.moduleArgument
-						}, async ${runtimeTemplate.basicFunction(
-							"__webpack_handle_async_dependencies__, __webpack_async_result__",
-							[
-								"try {",
-								importsCode,
-								`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${promises.join(
-									", "
-								)}]);`,
-								`var [${promises.join(
-									", "
-								)}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;`,
-								`${importsCompatCode}await ${instantiateCall};`,
-								"__webpack_async_result__();",
-								"} catch(e) { __webpack_async_result__(e); }"
-							]
-						)}, 1);`
-				  ])
-				: `${importsCode}${importsCompatCode}module.exports = ${instantiateCall};`
-		);
-
-		return InitFragment.addToSource(source, initFragments, generateContext);
+					null,
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
+						if (result) return callback(null, (this.cache[cacheId] = result));
+						callback();
+					}
+				);
+			});
 	}
-}
-
-module.exports = AsyncWebAssemblyJavascriptGenerator;
+};
 
 
 /***/ }),
 
-/***/ 7538:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 96972:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -137270,203 +137567,98 @@ module.exports = AsyncWebAssemblyJavascriptGenerator;
 
 
 
-const { SyncWaterfallHook } = __webpack_require__(41242);
-const Compilation = __webpack_require__(85720);
-const Generator = __webpack_require__(93401);
-const { tryRunOrWebpackError } = __webpack_require__(11351);
-const WebAssemblyImportDependency = __webpack_require__(5239);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const memoize = __webpack_require__(78676);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("../Template").RenderManifestOptions} RenderManifestOptions */
-
-const getAsyncWebAssemblyGenerator = memoize(() =>
-	__webpack_require__(58461)
-);
-const getAsyncWebAssemblyJavascriptGenerator = memoize(() =>
-	__webpack_require__(95614)
-);
-const getAsyncWebAssemblyParser = memoize(() =>
-	__webpack_require__(96305)
-);
-
-/**
- * @typedef {Object} WebAssemblyRenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- * @property {CodeGenerationResults} codeGenerationResults results of code generation
- */
-
-/**
- * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, WebAssemblyRenderContext]>} renderModuleContent
- */
-
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
 
-class AsyncWebAssemblyModulesPlugin {
+module.exports = class UseFilePlugin {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CompilationHooks} the attached hooks
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} filename filename
+	 * @param {string | ResolveStepHook} target target
 	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				renderModuleContent: new SyncWaterfallHook([
-					"source",
-					"module",
-					"renderContext"
-				])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	constructor(options) {
-		this.options = options;
+	constructor(source, filename, target) {
+		this.source = source;
+		this.filename = filename;
+		this.target = target;
 	}
 
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
+	 * @param {Resolver} resolver the resolver
 	 * @returns {void}
 	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"AsyncWebAssemblyModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				const hooks =
-					AsyncWebAssemblyModulesPlugin.getCompilationHooks(compilation);
-				compilation.dependencyFactories.set(
-					WebAssemblyImportDependency,
-					normalModuleFactory
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
+				const filePath = resolver.join(request.path, this.filename);
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, this.filename)
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					"using path: " + filePath,
+					resolveContext,
+					callback
 				);
+			});
+	}
+};
 
-				normalModuleFactory.hooks.createParser
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
-						const AsyncWebAssemblyParser = getAsyncWebAssemblyParser();
-
-						return new AsyncWebAssemblyParser();
-					});
-				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/async")
-					.tap("AsyncWebAssemblyModulesPlugin", () => {
-						const AsyncWebAssemblyJavascriptGenerator =
-							getAsyncWebAssemblyJavascriptGenerator();
-						const AsyncWebAssemblyGenerator = getAsyncWebAssemblyGenerator();
-
-						return Generator.byType({
-							javascript: new AsyncWebAssemblyJavascriptGenerator(
-								compilation.outputOptions.webassemblyModuleFilename
-							),
-							webassembly: new AsyncWebAssemblyGenerator(this.options)
-						});
-					});
 
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { moduleGraph, chunkGraph, runtimeTemplate } = compilation;
-						const {
-							chunk,
-							outputOptions,
-							dependencyTemplates,
-							codeGenerationResults
-						} = options;
+/***/ }),
 
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === "webassembly/async") {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
+/***/ 81218:
+/***/ (function(module) {
 
-								result.push({
-									render: () =>
-										this.renderModule(
-											module,
-											{
-												chunk,
-												dependencyTemplates,
-												runtimeTemplate,
-												moduleGraph,
-												chunkGraph,
-												codeGenerationResults
-											},
-											hooks
-										),
-									filenameTemplate,
-									pathOptions: {
-										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyAsyncModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
-						}
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-						return result;
-					}
-				);
-			}
-		);
-	}
 
-	renderModule(module, renderContext, hooks) {
-		const { codeGenerationResults, chunk } = renderContext;
-		try {
-			const moduleSource = codeGenerationResults.getSource(
-				module,
-				chunk.runtime,
-				"webassembly"
-			);
-			return tryRunOrWebpackError(
-				() =>
-					hooks.renderModuleContent.call(moduleSource, module, renderContext),
-				"AsyncWebAssemblyModulesPlugin.getCompilationHooks().renderModuleContent"
-			);
-		} catch (e) {
-			e.module = module;
-			throw e;
+
+module.exports = function createInnerContext(
+	options,
+	message,
+	messageOptional
+) {
+	let messageReported = false;
+	let innerLog = undefined;
+	if (options.log) {
+		if (message) {
+			innerLog = msg => {
+				if (!messageReported) {
+					options.log(message);
+					messageReported = true;
+				}
+				options.log("  " + msg);
+			};
+		} else {
+			innerLog = options.log;
 		}
 	}
-}
-
-module.exports = AsyncWebAssemblyModulesPlugin;
+	const childContext = {
+		log: innerLog,
+		fileDependencies: options.fileDependencies,
+		contextDependencies: options.contextDependencies,
+		missingDependencies: options.missingDependencies,
+		stack: options.stack
+	};
+	return childContext;
+};
 
 
 /***/ }),
 
-/***/ 96305:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 78565:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -137476,1843 +137668,1901 @@ module.exports = AsyncWebAssemblyModulesPlugin;
 
 
 
-const t = __webpack_require__(51826);
-const { decode } = __webpack_require__(73726);
-const Parser = __webpack_require__(11715);
-const StaticExportsDependency = __webpack_require__(91418);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+module.exports = function forEachBail(array, iterator, callback) {
+	if (array.length === 0) return callback();
 
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+	let i = 0;
+	const next = () => {
+		let loop = undefined;
+		iterator(array[i++], (err, result) => {
+			if (err || result !== undefined || i >= array.length) {
+				return callback(err, result);
+			}
+			if (loop === false) while (next());
+			loop = true;
+		});
+		if (!loop) loop = false;
+		return loop;
+	};
+	while (next());
+};
 
-const decoderOpts = {
-	ignoreCodeSection: true,
-	ignoreDataSection: true,
 
-	// this will avoid having to lookup with identifiers in the ModuleContext
-	ignoreCustomNameSection: true
-};
+/***/ }),
 
-class WebAssemblyParser extends Parser {
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
-	}
+/***/ 47956:
+/***/ (function(module) {
 
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (!Buffer.isBuffer(source)) {
-			throw new Error("WebAssemblyParser input must be a Buffer");
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+
+module.exports = function getInnerRequest(resolver, request) {
+	if (
+		typeof request.__innerRequest === "string" &&
+		request.__innerRequest_request === request.request &&
+		request.__innerRequest_relativePath === request.relativePath
+	)
+		return request.__innerRequest;
+	let innerRequest;
+	if (request.request) {
+		innerRequest = request.request;
+		if (/^\.\.?(?:\/|$)/.test(innerRequest) && request.relativePath) {
+			innerRequest = resolver.join(request.relativePath, innerRequest);
 		}
+	} else {
+		innerRequest = request.relativePath;
+	}
+	request.__innerRequest_request = request.request;
+	request.__innerRequest_relativePath = request.relativePath;
+	return (request.__innerRequest = innerRequest);
+};
 
-		// flag it as async module
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
-		state.module.buildMeta.async = true;
 
-		// parse it
-		const program = decode(source, decoderOpts);
-		const module = program.body[0];
+/***/ }),
 
-		const exports = [];
-		t.traverse(module, {
-			ModuleExport({ node }) {
-				exports.push(node.name);
-			},
+/***/ 82918:
+/***/ (function(module) {
 
-			ModuleImport({ node }) {
-				const dep = new WebAssemblyImportDependency(
-					node.module,
-					node.name,
-					node.descr,
-					false
-				);
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-				state.module.addDependency(dep);
-			}
-		});
 
-		state.module.addDependency(new StaticExportsDependency(exports, false));
 
-		return state;
+module.exports = function getPaths(path) {
+	const parts = path.split(/(.*?[\\/]+)/);
+	const paths = [path];
+	const seqments = [parts[parts.length - 1]];
+	let part = parts[parts.length - 1];
+	path = path.substr(0, path.length - part.length - 1);
+	for (let i = parts.length - 2; i > 2; i -= 2) {
+		paths.push(path);
+		part = parts[i];
+		path = path.substr(0, path.length - part.length) || "/";
+		seqments.push(part.substr(0, part.length - 1));
 	}
-}
+	part = parts[1];
+	seqments.push(part);
+	paths.push(part);
+	return {
+		paths: paths,
+		seqments: seqments
+	};
+};
 
-module.exports = WebAssemblyParser;
+module.exports.basename = function basename(path) {
+	const i = path.lastIndexOf("/"),
+		j = path.lastIndexOf("\\");
+	const p = i < 0 ? j : j < 0 ? i : i < j ? j : i;
+	if (p < 0) return null;
+	const s = path.substr(p + 1);
+	return s;
+};
 
 
 /***/ }),
 
-/***/ 78455:
+/***/ 9256:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
 
-const WebpackError = __webpack_require__(53799);
+const fs = __webpack_require__(90552);
+const CachedInputFileSystem = __webpack_require__(52788);
+const ResolverFactory = __webpack_require__(47716);
 
-module.exports = class UnsupportedWebAssemblyFeatureError extends WebpackError {
-	/** @param {string} message Error message */
-	constructor(message) {
-		super(message);
-		this.name = "UnsupportedWebAssemblyFeatureError";
-		this.hideStack = true;
+/** @typedef {import("./PnpPlugin").PnpApiImpl} PnpApi */
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./ResolverFactory").Plugin} Plugin */
+/** @typedef {import("./ResolverFactory").UserResolveOptions} ResolveOptions */
+
+const nodeFileSystem = new CachedInputFileSystem(fs, 4000);
+
+const nodeContext = {
+	environments: ["node+es3+es5+process+native"]
+};
+
+const asyncResolver = ResolverFactory.createResolver({
+	conditionNames: ["node"],
+	extensions: [".js", ".json", ".node"],
+	fileSystem: nodeFileSystem
+});
+function resolve(context, path, request, resolveContext, callback) {
+	if (typeof context === "string") {
+		callback = resolveContext;
+		resolveContext = request;
+		request = path;
+		path = context;
+		context = nodeContext;
+	}
+	if (typeof callback !== "function") {
+		callback = resolveContext;
+	}
+	asyncResolver.resolve(context, path, request, resolveContext, callback);
+}
+
+const syncResolver = ResolverFactory.createResolver({
+	conditionNames: ["node"],
+	extensions: [".js", ".json", ".node"],
+	useSyncFileSystemCalls: true,
+	fileSystem: nodeFileSystem
+});
+function resolveSync(context, path, request) {
+	if (typeof context === "string") {
+		request = path;
+		path = context;
+		context = nodeContext;
 	}
+	return syncResolver.resolveSync(context, path, request);
+}
+
+function create(options) {
+	options = {
+		fileSystem: nodeFileSystem,
+		...options
+	};
+	const resolver = ResolverFactory.createResolver(options);
+	return function (context, path, request, resolveContext, callback) {
+		if (typeof context === "string") {
+			callback = resolveContext;
+			resolveContext = request;
+			request = path;
+			path = context;
+			context = nodeContext;
+		}
+		if (typeof callback !== "function") {
+			callback = resolveContext;
+		}
+		resolver.resolve(context, path, request, resolveContext, callback);
+	};
+}
+
+function createSync(options) {
+	options = {
+		useSyncFileSystemCalls: true,
+		fileSystem: nodeFileSystem,
+		...options
+	};
+	const resolver = ResolverFactory.createResolver(options);
+	return function (context, path, request) {
+		if (typeof context === "string") {
+			request = path;
+			path = context;
+			context = nodeContext;
+		}
+		return resolver.resolveSync(context, path, request);
+	};
+}
+
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	Object.defineProperties(obj, descriptors);
+	return /** @type {A & B} */ (Object.freeze(obj));
 };
 
+module.exports = mergeExports(resolve, {
+	get sync() {
+		return resolveSync;
+	},
+	create: mergeExports(create, {
+		get sync() {
+			return createSync;
+		}
+	}),
+	ResolverFactory,
+	CachedInputFileSystem,
+	get CloneBasenamePlugin() {
+		return __webpack_require__(22254);
+	},
+	get LogInfoPlugin() {
+		return __webpack_require__(5049);
+	},
+	get forEachBail() {
+		return __webpack_require__(78565);
+	}
+});
+
 
 /***/ }),
 
-/***/ 87394:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 55863:
+/***/ (function(module) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
 */
 
 
 
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const WebAssemblyUtils = __webpack_require__(18650);
+/** @typedef {string|(string|ConditionalMapping)[]} DirectMapping */
+/** @typedef {{[k: string]: MappingValue}} ConditionalMapping */
+/** @typedef {ConditionalMapping|DirectMapping|null} MappingValue */
+/** @typedef {Record<string, MappingValue>|ConditionalMapping|DirectMapping} ExportsField */
+/** @typedef {Record<string, MappingValue>} ImportsField */
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/**
+ * @typedef {Object} PathTreeNode
+ * @property {Map<string, PathTreeNode>|null} children
+ * @property {MappingValue} folder
+ * @property {Map<string, MappingValue>|null} wildcards
+ * @property {Map<string, MappingValue>} files
+ */
 
-// TODO webpack 6 remove the whole folder
+/**
+ * Processing exports/imports field
+ * @callback FieldProcessor
+ * @param {string} request request
+ * @param {Set<string>} conditionNames condition names
+ * @returns {string[]} resolved paths
+ */
 
-// Get all wasm modules
-const getAllWasmModules = (moduleGraph, chunkGraph, chunk) => {
-	const wasmModules = chunk.getAllAsyncChunks();
-	const array = [];
-	for (const chunk of wasmModules) {
-		for (const m of chunkGraph.getOrderedChunkModulesIterable(
-			chunk,
-			compareModulesByIdentifier
-		)) {
-			if (m.type.startsWith("webassembly")) {
-				array.push(m);
-			}
-		}
-	}
+/*
+Example exports field:
+{
+  ".": "./main.js",
+  "./feature": {
+    "browser": "./feature-browser.js",
+    "default": "./feature.js"
+  }
+}
+Terminology:
 
-	return array;
+Enhanced-resolve name keys ("." and "./feature") as exports field keys.
+
+If value is string or string[], mapping is called as a direct mapping
+and value called as a direct export.
+
+If value is key-value object, mapping is called as a conditional mapping
+and value called as a conditional export.
+
+Key in conditional mapping is called condition name.
+
+Conditional mapping nested in another conditional mapping is called nested mapping.
+
+----------
+
+Example imports field:
+{
+  "#a": "./main.js",
+  "#moment": {
+    "browser": "./moment/index.js",
+    "default": "moment"
+  },
+  "#moment/": {
+    "browser": "./moment/",
+    "default": "moment/"
+  }
+}
+Terminology:
+
+Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys.
+
+If value is string or string[], mapping is called as a direct mapping
+and value called as a direct export.
+
+If value is key-value object, mapping is called as a conditional mapping
+and value called as a conditional export.
+
+Key in conditional mapping is called condition name.
+
+Conditional mapping nested in another conditional mapping is called nested mapping.
+
+*/
+
+const slashCode = "/".charCodeAt(0);
+const dotCode = ".".charCodeAt(0);
+const hashCode = "#".charCodeAt(0);
+
+/**
+ * @param {ExportsField} exportsField the exports field
+ * @returns {FieldProcessor} process callback
+ */
+module.exports.processExportsField = function processExportsField(
+	exportsField
+) {
+	return createFieldProcessor(
+		buildExportsFieldPathTree(exportsField),
+		assertExportsFieldRequest,
+		assertExportTarget
+	);
 };
 
 /**
- * generates the import object function for a module
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {Module} module the module
- * @param {boolean} mangle mangle imports
- * @param {string[]} declarations array where declarations are pushed to
- * @param {RuntimeSpec} runtime the runtime
- * @returns {string} source code
+ * @param {ImportsField} importsField the exports field
+ * @returns {FieldProcessor} process callback
  */
-const generateImportObject = (
-	chunkGraph,
-	module,
-	mangle,
-	declarations,
-	runtime
-) => {
-	const moduleGraph = chunkGraph.moduleGraph;
-	const waitForInstances = new Map();
-	const properties = [];
-	const usedWasmDependencies = WebAssemblyUtils.getUsedDependencies(
-		moduleGraph,
-		module,
-		mangle
+module.exports.processImportsField = function processImportsField(
+	importsField
+) {
+	return createFieldProcessor(
+		buildImportsFieldPathTree(importsField),
+		assertImportsFieldRequest,
+		assertImportTarget
 	);
-	for (const usedDep of usedWasmDependencies) {
-		const dep = usedDep.dependency;
-		const importedModule = moduleGraph.getModule(dep);
-		const exportName = dep.name;
-		const usedName =
-			importedModule &&
-			moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(exportName, runtime);
-		const description = dep.description;
-		const direct = dep.onlyDirectImport;
+};
 
-		const module = usedDep.module;
-		const name = usedDep.name;
+/**
+ * @param {PathTreeNode} treeRoot root
+ * @param {(s: string) => string} assertRequest assertRequest
+ * @param {(s: string, f: boolean) => void} assertTarget assertTarget
+ * @returns {FieldProcessor} field processor
+ */
+function createFieldProcessor(treeRoot, assertRequest, assertTarget) {
+	return function fieldProcessor(request, conditionNames) {
+		request = assertRequest(request);
 
-		if (direct) {
-			const instanceVar = `m${waitForInstances.size}`;
-			waitForInstances.set(instanceVar, chunkGraph.getModuleId(importedModule));
-			properties.push({
-				module,
-				name,
-				value: `${instanceVar}[${JSON.stringify(usedName)}]`
-			});
-		} else {
-			const params = description.signature.params.map(
-				(param, k) => "p" + k + param.valtype
+		const match = findMatch(request, treeRoot);
+
+		if (match === null) return [];
+
+		const [mapping, remainRequestIndex] = match;
+
+		/** @type {DirectMapping|null} */
+		let direct = null;
+
+		if (isConditionalMapping(mapping)) {
+			direct = conditionalMapping(
+				/** @type {ConditionalMapping} */ (mapping),
+				conditionNames
 			);
 
-			const mod = `${RuntimeGlobals.moduleCache}[${JSON.stringify(
-				chunkGraph.getModuleId(importedModule)
-			)}]`;
-			const modExports = `${mod}.exports`;
+			// matching not found
+			if (direct === null) return [];
+		} else {
+			direct = /** @type {DirectMapping} */ (mapping);
+		}
+
+		const remainingRequest =
+			remainRequestIndex === request.length + 1
+				? undefined
+				: remainRequestIndex < 0
+				? request.slice(-remainRequestIndex - 1)
+				: request.slice(remainRequestIndex);
 
-			const cache = `wasmImportedFuncCache${declarations.length}`;
-			declarations.push(`var ${cache};`);
+		return directMapping(
+			remainingRequest,
+			remainRequestIndex < 0,
+			direct,
+			conditionNames,
+			assertTarget
+		);
+	};
+}
 
-			properties.push({
-				module,
-				name,
-				value: Template.asString([
-					(importedModule.type.startsWith("webassembly")
-						? `${mod} ? ${modExports}[${JSON.stringify(usedName)}] : `
-						: "") + `function(${params}) {`,
-					Template.indent([
-						`if(${cache} === undefined) ${cache} = ${modExports};`,
-						`return ${cache}[${JSON.stringify(usedName)}](${params});`
-					]),
-					"}"
-				])
-			});
-		}
+/**
+ * @param {string} request request
+ * @returns {string} updated request
+ */
+function assertExportsFieldRequest(request) {
+	if (request.charCodeAt(0) !== dotCode) {
+		throw new Error('Request should be relative path and start with "."');
 	}
-
-	let importObject;
-	if (mangle) {
-		importObject = [
-			"return {",
-			Template.indent([
-				properties.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
-			]),
-			"};"
-		];
-	} else {
-		const propertiesByModule = new Map();
-		for (const p of properties) {
-			let list = propertiesByModule.get(p.module);
-			if (list === undefined) {
-				propertiesByModule.set(p.module, (list = []));
-			}
-			list.push(p);
-		}
-		importObject = [
-			"return {",
-			Template.indent([
-				Array.from(propertiesByModule, ([module, list]) => {
-					return Template.asString([
-						`${JSON.stringify(module)}: {`,
-						Template.indent([
-							list.map(p => `${JSON.stringify(p.name)}: ${p.value}`).join(",\n")
-						]),
-						"}"
-					]);
-				}).join(",\n")
-			]),
-			"};"
-		];
+	if (request.length === 1) return "";
+	if (request.charCodeAt(1) !== slashCode) {
+		throw new Error('Request should be relative path and start with "./"');
 	}
-
-	const moduleIdStringified = JSON.stringify(chunkGraph.getModuleId(module));
-	if (waitForInstances.size === 1) {
-		const moduleId = Array.from(waitForInstances.values())[0];
-		const promise = `installedWasmModules[${JSON.stringify(moduleId)}]`;
-		const variable = Array.from(waitForInstances.keys())[0];
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent([
-				`return promiseResolve().then(function() { return ${promise}; }).then(function(${variable}) {`,
-				Template.indent(importObject),
-				"});"
-			]),
-			"},"
-		]);
-	} else if (waitForInstances.size > 0) {
-		const promises = Array.from(
-			waitForInstances.values(),
-			id => `installedWasmModules[${JSON.stringify(id)}]`
-		).join(", ");
-		const variables = Array.from(
-			waitForInstances.keys(),
-			(name, i) => `${name} = array[${i}]`
-		).join(", ");
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent([
-				`return promiseResolve().then(function() { return Promise.all([${promises}]); }).then(function(array) {`,
-				Template.indent([`var ${variables};`, ...importObject]),
-				"});"
-			]),
-			"},"
-		]);
-	} else {
-		return Template.asString([
-			`${moduleIdStringified}: function() {`,
-			Template.indent(importObject),
-			"},"
-		]);
+	if (request.charCodeAt(request.length - 1) === slashCode) {
+		throw new Error("Only requesting file allowed");
 	}
-};
 
-class WasmChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor({
-		generateLoadBinaryCode,
-		supportsStreaming,
-		mangleImports,
-		runtimeRequirements
-	}) {
-		super("wasm chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.generateLoadBinaryCode = generateLoadBinaryCode;
-		this.supportsStreaming = supportsStreaming;
-		this.mangleImports = mangleImports;
-		this._runtimeRequirements = runtimeRequirements;
+	return request.slice(2);
+}
+
+/**
+ * @param {string} request request
+ * @returns {string} updated request
+ */
+function assertImportsFieldRequest(request) {
+	if (request.charCodeAt(0) !== hashCode) {
+		throw new Error('Request should start with "#"');
+	}
+	if (request.length === 1) {
+		throw new Error("Request should have at least 2 characters");
+	}
+	if (request.charCodeAt(1) === slashCode) {
+		throw new Error('Request should not start with "#/"');
+	}
+	if (request.charCodeAt(request.length - 1) === slashCode) {
+		throw new Error("Only requesting file allowed");
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, compilation, chunk, mangleImports } = this;
-		const { moduleGraph, outputOptions } = compilation;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withHmr = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const wasmModules = getAllWasmModules(moduleGraph, chunkGraph, chunk);
-		const declarations = [];
-		const importObjects = wasmModules.map(module => {
-			return generateImportObject(
-				chunkGraph,
-				module,
-				this.mangleImports,
-				declarations,
-				chunk.runtime
-			);
-		});
-		const chunkModuleIdMap = chunkGraph.getChunkModuleIdMap(chunk, m =>
-			m.type.startsWith("webassembly")
-		);
-		const createImportObject = content =>
-			mangleImports
-				? `{ ${JSON.stringify(WebAssemblyUtils.MANGLED_MODULE)}: ${content} }`
-				: content;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: length =>
-					`" + ${RuntimeGlobals.getFullHash}}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: `" + ${JSON.stringify(
-						chunkGraph.getChunkModuleRenderedHashMap(chunk, m =>
-							m.type.startsWith("webassembly")
-						)
-					)}[chunkId][wasmModuleId] + "`,
-					hashWithLength(length) {
-						return `" + ${JSON.stringify(
-							chunkGraph.getChunkModuleRenderedHashMap(
-								chunk,
-								m => m.type.startsWith("webassembly"),
-								length
-							)
-						)}[chunkId][wasmModuleId] + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
+	return request.slice(1);
+}
+
+/**
+ * @param {string} exp export target
+ * @param {boolean} expectFolder is folder expected
+ */
+function assertExportTarget(exp, expectFolder) {
+	if (
+		exp.charCodeAt(0) === slashCode ||
+		(exp.charCodeAt(0) === dotCode && exp.charCodeAt(1) !== slashCode)
+	) {
+		throw new Error(
+			`Export should be relative path and start with "./", got ${JSON.stringify(
+				exp
+			)}.`
 		);
+	}
 
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_wasm`
-			: undefined;
+	const isFolder = exp.charCodeAt(exp.length - 1) === slashCode;
 
-		return Template.asString([
-			"// object to store loaded and loading wasm modules",
-			`var installedWasmModules = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{};`,
-			"",
-			// This function is used to delay reading the installed wasm module promises
-			// by a microtask. Sorting them doesn't help because there are edge cases where
-			// sorting is not possible (modules splitted into different chunks).
-			// So we not even trying and solve this by a microtask delay.
-			"function promiseResolve() { return Promise.resolve(); }",
-			"",
-			Template.asString(declarations),
-			"var wasmImportObjects = {",
-			Template.indent(importObjects),
-			"};",
-			"",
-			`var wasmModuleMap = ${JSON.stringify(
-				chunkModuleIdMap,
-				undefined,
-				"\t"
-			)};`,
-			"",
-			"// object with all WebAssembly.instance exports",
-			`${RuntimeGlobals.wasmInstances} = {};`,
-			"",
-			"// Fetch + compile chunk loading for webassembly",
-			`${fn}.wasm = function(chunkId, promises) {`,
-			Template.indent([
-				"",
-				`var wasmModules = wasmModuleMap[chunkId] || [];`,
-				"",
-				"wasmModules.forEach(function(wasmModuleId, idx) {",
-				Template.indent([
-					"var installedWasmModuleData = installedWasmModules[wasmModuleId];",
-					"",
-					'// a Promise means "currently loading" or "already loaded".',
-					"if(installedWasmModuleData)",
-					Template.indent(["promises.push(installedWasmModuleData);"]),
-					"else {",
-					Template.indent([
-						`var importObject = wasmImportObjects[wasmModuleId]();`,
-						`var req = ${this.generateLoadBinaryCode(wasmModuleSrcPath)};`,
-						"var promise;",
-						this.supportsStreaming
-							? Template.asString([
-									"if(importObject && typeof importObject.then === 'function' && typeof WebAssembly.compileStreaming === 'function') {",
-									Template.indent([
-										"promise = Promise.all([WebAssembly.compileStreaming(req), importObject]).then(function(items) {",
-										Template.indent([
-											`return WebAssembly.instantiate(items[0], ${createImportObject(
-												"items[1]"
-											)});`
-										]),
-										"});"
-									]),
-									"} else if(typeof WebAssembly.instantiateStreaming === 'function') {",
-									Template.indent([
-										`promise = WebAssembly.instantiateStreaming(req, ${createImportObject(
-											"importObject"
-										)});`
-									])
-							  ])
-							: Template.asString([
-									"if(importObject && typeof importObject.then === 'function') {",
-									Template.indent([
-										"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
-										"promise = Promise.all([",
-										Template.indent([
-											"bytesPromise.then(function(bytes) { return WebAssembly.compile(bytes); }),",
-											"importObject"
-										]),
-										"]).then(function(items) {",
-										Template.indent([
-											`return WebAssembly.instantiate(items[0], ${createImportObject(
-												"items[1]"
-											)});`
-										]),
-										"});"
-									])
-							  ]),
-						"} else {",
-						Template.indent([
-							"var bytesPromise = req.then(function(x) { return x.arrayBuffer(); });",
-							"promise = bytesPromise.then(function(bytes) {",
-							Template.indent([
-								`return WebAssembly.instantiate(bytes, ${createImportObject(
-									"importObject"
-								)});`
-							]),
-							"});"
-						]),
-						"}",
-						"promises.push(installedWasmModules[wasmModuleId] = promise.then(function(res) {",
-						Template.indent([
-							`return ${RuntimeGlobals.wasmInstances}[wasmModuleId] = (res.instance || res).exports;`
-						]),
-						"}));"
-					]),
-					"}"
-				]),
-				"});"
-			]),
-			"};"
-		]);
+	if (isFolder !== expectFolder) {
+		throw new Error(
+			expectFolder
+				? `Expecting folder to folder mapping. ${JSON.stringify(
+						exp
+				  )} should end with "/"`
+				: `Expecting file to file mapping. ${JSON.stringify(
+						exp
+				  )} should not end with "/"`
+		);
 	}
 }
 
-module.exports = WasmChunkLoadingRuntimeModule;
+/**
+ * @param {string} imp import target
+ * @param {boolean} expectFolder is folder expected
+ */
+function assertImportTarget(imp, expectFolder) {
+	const isFolder = imp.charCodeAt(imp.length - 1) === slashCode;
 
+	if (isFolder !== expectFolder) {
+		throw new Error(
+			expectFolder
+				? `Expecting folder to folder mapping. ${JSON.stringify(
+						imp
+				  )} should end with "/"`
+				: `Expecting file to file mapping. ${JSON.stringify(
+						imp
+				  )} should not end with "/"`
+		);
+	}
+}
 
-/***/ }),
+/**
+ * Trying to match request to field
+ * @param {string} request request
+ * @param {PathTreeNode} treeRoot path tree root
+ * @returns {[MappingValue, number]|null} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings
+ */
+function findMatch(request, treeRoot) {
+	if (request.length === 0) {
+		const value = treeRoot.files.get("");
 
-/***/ 19810:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		return value ? [value, 1] : null;
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	if (
+		treeRoot.children === null &&
+		treeRoot.folder === null &&
+		treeRoot.wildcards === null
+	) {
+		const value = treeRoot.files.get(request);
 
+		return value ? [value, request.length + 1] : null;
+	}
 
+	let node = treeRoot;
+	let lastNonSlashIndex = 0;
+	let slashIndex = request.indexOf("/", 0);
 
-const formatLocation = __webpack_require__(16734);
-const UnsupportedWebAssemblyFeatureError = __webpack_require__(78455);
+	/** @type {[MappingValue, number]|null} */
+	let lastFolderMatch = null;
 
-/** @typedef {import("../Compiler")} Compiler */
+	const applyFolderMapping = () => {
+		const folderMapping = node.folder;
+		if (folderMapping) {
+			if (lastFolderMatch) {
+				lastFolderMatch[0] = folderMapping;
+				lastFolderMatch[1] = -lastNonSlashIndex - 1;
+			} else {
+				lastFolderMatch = [folderMapping, -lastNonSlashIndex - 1];
+			}
+		}
+	};
 
-class WasmFinalizeExportsPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap("WasmFinalizeExportsPlugin", compilation => {
-			compilation.hooks.finishModules.tap(
-				"WasmFinalizeExportsPlugin",
-				modules => {
-					for (const module of modules) {
-						// 1. if a WebAssembly module
-						if (module.type.startsWith("webassembly") === true) {
-							const jsIncompatibleExports =
-								module.buildMeta.jsIncompatibleExports;
+	const applyWildcardMappings = (wildcardMappings, remainingRequest) => {
+		if (wildcardMappings) {
+			for (const [key, target] of wildcardMappings) {
+				if (remainingRequest.startsWith(key)) {
+					if (!lastFolderMatch) {
+						lastFolderMatch = [target, lastNonSlashIndex + key.length];
+					} else if (lastFolderMatch[1] < lastNonSlashIndex + key.length) {
+						lastFolderMatch[0] = target;
+						lastFolderMatch[1] = lastNonSlashIndex + key.length;
+					}
+				}
+			}
+		}
+	};
 
-							if (jsIncompatibleExports === undefined) {
-								continue;
-							}
+	while (slashIndex !== -1) {
+		applyFolderMapping();
 
-							for (const connection of compilation.moduleGraph.getIncomingConnections(
-								module
-							)) {
-								// 2. is active and referenced by a non-WebAssembly module
-								if (
-									connection.isTargetActive(undefined) &&
-									connection.originModule.type.startsWith("webassembly") ===
-										false
-								) {
-									const referencedExports =
-										compilation.getDependencyReferencedExports(
-											connection.dependency,
-											undefined
-										);
+		const wildcardMappings = node.wildcards;
 
-									for (const info of referencedExports) {
-										const names = Array.isArray(info) ? info : info.name;
-										if (names.length === 0) continue;
-										const name = names[0];
-										if (typeof name === "object") continue;
-										// 3. and uses a func with an incompatible JS signature
-										if (
-											Object.prototype.hasOwnProperty.call(
-												jsIncompatibleExports,
-												name
-											)
-										) {
-											// 4. error
-											const error = new UnsupportedWebAssemblyFeatureError(
-												`Export "${name}" with ${jsIncompatibleExports[name]} can only be used for direct wasm to wasm dependencies\n` +
-													`It's used from ${connection.originModule.readableIdentifier(
-														compilation.requestShortener
-													)} at ${formatLocation(connection.dependency.loc)}.`
-											);
-											error.module = module;
-											compilation.errors.push(error);
-										}
-									}
-								}
-							}
-						}
-					}
-				}
-			);
-		});
-	}
-}
+		if (!wildcardMappings && node.children === null) return lastFolderMatch;
 
-module.exports = WasmFinalizeExportsPlugin;
+		const folder = request.slice(lastNonSlashIndex, slashIndex);
 
+		applyWildcardMappings(wildcardMappings, folder);
 
-/***/ }),
+		if (node.children === null) return lastFolderMatch;
 
-/***/ 47012:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+		const newNode = node.children.get(folder);
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+		if (!newNode) {
+			return lastFolderMatch;
+		}
+
+		node = newNode;
+		lastNonSlashIndex = slashIndex + 1;
+		slashIndex = request.indexOf("/", lastNonSlashIndex);
+	}
 
+	const remainingRequest =
+		lastNonSlashIndex > 0 ? request.slice(lastNonSlashIndex) : request;
 
+	const value = node.files.get(remainingRequest);
 
-const { RawSource } = __webpack_require__(51255);
-const Generator = __webpack_require__(93401);
-const WebAssemblyUtils = __webpack_require__(18650);
+	if (value) {
+		return [value, request.length + 1];
+	}
 
-const t = __webpack_require__(51826);
-const { moduleContextFromModuleAST } = __webpack_require__(51826);
-const { editWithAST, addWithAST } = __webpack_require__(87362);
-const { decode } = __webpack_require__(73726);
+	applyFolderMapping();
 
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
+	applyWildcardMappings(node.wildcards, remainingRequest);
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
+	return lastFolderMatch;
+}
 
 /**
- * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
+ * @param {ConditionalMapping|DirectMapping|null} mapping mapping
+ * @returns {boolean} is conditional mapping
  */
+function isConditionalMapping(mapping) {
+	return (
+		mapping !== null && typeof mapping === "object" && !Array.isArray(mapping)
+	);
+}
 
 /**
- * @template T
- * @param {Function[]} fns transforms
- * @returns {Function} composed transform
+ * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
+ * @param {boolean} subpathMapping true, for subpath mappings
+ * @param {DirectMapping|null} mappingTarget direct export
+ * @param {Set<string>} conditionNames condition names
+ * @param {(d: string, f: boolean) => void} assert asserting direct value
+ * @returns {string[]} mapping result
  */
-const compose = (...fns) => {
-	return fns.reduce(
-		(prevFn, nextFn) => {
-			return value => nextFn(prevFn(value));
-		},
-		value => value
-	);
-};
+function directMapping(
+	remainingRequest,
+	subpathMapping,
+	mappingTarget,
+	conditionNames,
+	assert
+) {
+	if (mappingTarget === null) return [];
+
+	if (typeof mappingTarget === "string") {
+		return [
+			targetMapping(remainingRequest, subpathMapping, mappingTarget, assert)
+		];
+	}
+
+	const targets = [];
+
+	for (const exp of mappingTarget) {
+		if (typeof exp === "string") {
+			targets.push(
+				targetMapping(remainingRequest, subpathMapping, exp, assert)
+			);
+			continue;
+		}
+
+		const mapping = conditionalMapping(exp, conditionNames);
+		if (!mapping) continue;
+		const innerExports = directMapping(
+			remainingRequest,
+			subpathMapping,
+			mapping,
+			conditionNames,
+			assert
+		);
+		for (const innerExport of innerExports) {
+			targets.push(innerExport);
+		}
+	}
+
+	return targets;
+}
 
 /**
- * Removes the start instruction
- *
- * @param {Object} state unused state
- * @returns {ArrayBufferTransform} transform
+ * @param {string|undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
+ * @param {boolean} subpathMapping true, for subpath mappings
+ * @param {string} mappingTarget direct export
+ * @param {(d: string, f: boolean) => void} assert asserting direct value
+ * @returns {string} mapping result
  */
-const removeStartFunc = state => bin => {
-	return editWithAST(state.ast, bin, {
-		Start(path) {
-			path.remove();
-		}
-	});
-};
+function targetMapping(
+	remainingRequest,
+	subpathMapping,
+	mappingTarget,
+	assert
+) {
+	if (remainingRequest === undefined) {
+		assert(mappingTarget, false);
+		return mappingTarget;
+	}
+	if (subpathMapping) {
+		assert(mappingTarget, true);
+		return mappingTarget + remainingRequest;
+	}
+	assert(mappingTarget, false);
+	return mappingTarget.replace(/\*/g, remainingRequest.replace(/\$/g, "$$"));
+}
 
 /**
- * Get imported globals
- *
- * @param {Object} ast Module's AST
- * @returns {Array<t.ModuleImport>} - nodes
+ * @param {ConditionalMapping} conditionalMapping_ conditional mapping
+ * @param {Set<string>} conditionNames condition names
+ * @returns {DirectMapping|null} direct mapping if found
  */
-const getImportedGlobals = ast => {
-	const importedGlobals = [];
+function conditionalMapping(conditionalMapping_, conditionNames) {
+	/** @type {[ConditionalMapping, string[], number][]} */
+	let lookup = [[conditionalMapping_, Object.keys(conditionalMapping_), 0]];
 
-	t.traverse(ast, {
-		ModuleImport({ node }) {
-			if (t.isGlobalType(node.descr)) {
-				importedGlobals.push(node);
-			}
-		}
-	});
+	loop: while (lookup.length > 0) {
+		const [mapping, conditions, j] = lookup[lookup.length - 1];
+		const last = conditions.length - 1;
 
-	return importedGlobals;
-};
+		for (let i = j; i < conditions.length; i++) {
+			const condition = conditions[i];
 
-/**
- * Get the count for imported func
- *
- * @param {Object} ast Module's AST
- * @returns {Number} - count
- */
-const getCountImportedFunc = ast => {
-	let count = 0;
+			// assert default. Could be last only
+			if (i !== last) {
+				if (condition === "default") {
+					throw new Error("Default condition should be last one");
+				}
+			} else if (condition === "default") {
+				const innerMapping = mapping[condition];
+				// is nested
+				if (isConditionalMapping(innerMapping)) {
+					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
+					lookup[lookup.length - 1][2] = i + 1;
+					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
+					continue loop;
+				}
 
-	t.traverse(ast, {
-		ModuleImport({ node }) {
-			if (t.isFuncImportDescr(node.descr)) {
-				count++;
+				return /** @type {DirectMapping} */ (innerMapping);
 			}
-		}
-	});
 
-	return count;
-};
+			if (conditionNames.has(condition)) {
+				const innerMapping = mapping[condition];
+				// is nested
+				if (isConditionalMapping(innerMapping)) {
+					const conditionalMapping = /** @type {ConditionalMapping} */ (innerMapping);
+					lookup[lookup.length - 1][2] = i + 1;
+					lookup.push([conditionalMapping, Object.keys(conditionalMapping), 0]);
+					continue loop;
+				}
 
-/**
- * Get next type index
- *
- * @param {Object} ast Module's AST
- * @returns {t.Index} - index
- */
-const getNextTypeIndex = ast => {
-	const typeSectionMetadata = t.getSectionMetadata(ast, "type");
+				return /** @type {DirectMapping} */ (innerMapping);
+			}
+		}
 
-	if (typeSectionMetadata === undefined) {
-		return t.indexLiteral(0);
+		lookup.pop();
 	}
 
-	return t.indexLiteral(typeSectionMetadata.vectorOfSize.value);
-};
+	return null;
+}
 
 /**
- * Get next func index
- *
- * The Func section metadata provide informations for implemented funcs
- * in order to have the correct index we shift the index by number of external
- * functions.
- *
- * @param {Object} ast Module's AST
- * @param {Number} countImportedFunc number of imported funcs
- * @returns {t.Index} - index
+ * Internal helper to create path tree node
+ * to ensure that each node gets the same hidden class
+ * @returns {PathTreeNode} node
  */
-const getNextFuncIndex = (ast, countImportedFunc) => {
-	const funcSectionMetadata = t.getSectionMetadata(ast, "func");
+function createNode() {
+	return {
+		children: null,
+		folder: null,
+		wildcards: null,
+		files: new Map()
+	};
+}
 
-	if (funcSectionMetadata === undefined) {
-		return t.indexLiteral(0 + countImportedFunc);
+/**
+ * Internal helper for building path tree
+ * @param {PathTreeNode} root root
+ * @param {string} path path
+ * @param {MappingValue} target target
+ */
+function walkPath(root, path, target) {
+	if (path.length === 0) {
+		root.folder = target;
+		return;
 	}
 
-	const vectorOfSize = funcSectionMetadata.vectorOfSize.value;
+	let node = root;
+	// Typical path tree can looks like
+	// root
+	// - files: ["a.js", "b.js"]
+	// - children:
+	//    node1:
+	//    - files: ["a.js", "b.js"]
+	let lastNonSlashIndex = 0;
+	let slashIndex = path.indexOf("/", 0);
 
-	return t.indexLiteral(vectorOfSize + countImportedFunc);
-};
+	while (slashIndex !== -1) {
+		const folder = path.slice(lastNonSlashIndex, slashIndex);
+		let newNode;
 
-/**
- * Creates an init instruction for a global type
- * @param {t.GlobalType} globalType the global type
- * @returns {t.Instruction} init expression
- */
-const createDefaultInitForGlobal = globalType => {
-	if (globalType.valtype[0] === "i") {
-		// create NumberLiteral global initializer
-		return t.objectInstruction("const", globalType.valtype, [
-			t.numberLiteralFromRaw(66)
-		]);
-	} else if (globalType.valtype[0] === "f") {
-		// create FloatLiteral global initializer
-		return t.objectInstruction("const", globalType.valtype, [
-			t.floatLiteral(66, false, false, "66")
-		]);
+		if (node.children === null) {
+			newNode = createNode();
+			node.children = new Map();
+			node.children.set(folder, newNode);
+		} else {
+			newNode = node.children.get(folder);
+
+			if (!newNode) {
+				newNode = createNode();
+				node.children.set(folder, newNode);
+			}
+		}
+
+		node = newNode;
+		lastNonSlashIndex = slashIndex + 1;
+		slashIndex = path.indexOf("/", lastNonSlashIndex);
+	}
+
+	if (lastNonSlashIndex >= path.length) {
+		node.folder = target;
 	} else {
-		throw new Error("unknown type: " + globalType.valtype);
+		const file = lastNonSlashIndex > 0 ? path.slice(lastNonSlashIndex) : path;
+		if (file.endsWith("*")) {
+			if (node.wildcards === null) node.wildcards = new Map();
+			node.wildcards.set(file.slice(0, -1), target);
+		} else {
+			node.files.set(file, target);
+		}
 	}
-};
+}
 
 /**
- * Rewrite the import globals:
- * - removes the ModuleImport instruction
- * - injects at the same offset a mutable global of the same type
- *
- * Since the imported globals are before the other global declarations, our
- * indices will be preserved.
- *
- * Note that globals will become mutable.
- *
- * @param {Object} state unused state
- * @returns {ArrayBufferTransform} transform
+ * @param {ExportsField} field exports field
+ * @returns {PathTreeNode} tree root
  */
-const rewriteImportedGlobals = state => bin => {
-	const additionalInitCode = state.additionalInitCode;
-	const newGlobals = [];
+function buildExportsFieldPathTree(field) {
+	const root = createNode();
 
-	bin = editWithAST(state.ast, bin, {
-		ModuleImport(path) {
-			if (t.isGlobalType(path.node.descr)) {
-				const globalType = path.node.descr;
+	// handle syntax sugar, if exports field is direct mapping for "."
+	if (typeof field === "string") {
+		root.files.set("", field);
 
-				globalType.mutability = "var";
+		return root;
+	} else if (Array.isArray(field)) {
+		root.files.set("", field.slice());
 
-				const init = [
-					createDefaultInitForGlobal(globalType),
-					t.instruction("end")
-				];
+		return root;
+	}
 
-				newGlobals.push(t.global(globalType, init));
+	const keys = Object.keys(field);
 
-				path.remove();
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+
+		if (key.charCodeAt(0) !== dotCode) {
+			// handle syntax sugar, if exports field is conditional mapping for "."
+			if (i === 0) {
+				while (i < keys.length) {
+					const charCode = keys[i].charCodeAt(0);
+					if (charCode === dotCode || charCode === slashCode) {
+						throw new Error(
+							`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
+								key
+							)})`
+						);
+					}
+					i++;
+				}
+
+				root.files.set("", field);
+				return root;
 			}
-		},
 
-		// in order to preserve non-imported global's order we need to re-inject
-		// those as well
-		Global(path) {
-			const { node } = path;
-			const [init] = node.init;
+			throw new Error(
+				`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-			if (init.id === "get_global") {
-				node.globalType.mutability = "var";
+		if (key.length === 1) {
+			root.files.set("", field[key]);
+			continue;
+		}
 
-				const initialGlobalIdx = init.args[0];
+		if (key.charCodeAt(1) !== slashCode) {
+			throw new Error(
+				`Exports field key should be relative path and start with "./" (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-				node.init = [
-					createDefaultInitForGlobal(node.globalType),
-					t.instruction("end")
-				];
+		walkPath(root, key.slice(2), field[key]);
+	}
 
-				additionalInitCode.push(
-					/**
-					 * get_global in global initializer only works for imported globals.
-					 * They have the same indices as the init params, so use the
-					 * same index.
-					 */
-					t.instruction("get_local", [initialGlobalIdx]),
-					t.instruction("set_global", [t.indexLiteral(newGlobals.length)])
-				);
-			}
+	return root;
+}
 
-			newGlobals.push(node);
+/**
+ * @param {ImportsField} field imports field
+ * @returns {PathTreeNode} root
+ */
+function buildImportsFieldPathTree(field) {
+	const root = createNode();
 
-			path.remove();
+	const keys = Object.keys(field);
+
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+
+		if (key.charCodeAt(0) !== hashCode) {
+			throw new Error(
+				`Imports field key should start with "#" (key: ${JSON.stringify(key)})`
+			);
 		}
-	});
 
-	// Add global declaration instructions
-	return addWithAST(state.ast, bin, newGlobals);
-};
+		if (key.length === 1) {
+			throw new Error(
+				`Imports field key should have at least 2 characters (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-/**
- * Rewrite the export names
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
- * @param {Module} state.module Module
- * @param {ModuleGraph} state.moduleGraph module graph
- * @param {Set<string>} state.externalExports Module
- * @param {RuntimeSpec} state.runtime runtime
- * @returns {ArrayBufferTransform} transform
- */
-const rewriteExportNames =
-	({ ast, moduleGraph, module, externalExports, runtime }) =>
-	bin => {
-		return editWithAST(ast, bin, {
-			ModuleExport(path) {
-				const isExternal = externalExports.has(path.node.name);
-				if (isExternal) {
-					path.remove();
-					return;
-				}
-				const usedName = moduleGraph
-					.getExportsInfo(module)
-					.getUsedName(path.node.name, runtime);
-				if (!usedName) {
-					path.remove();
-					return;
-				}
-				path.node.name = usedName;
-			}
-		});
-	};
+		if (key.charCodeAt(1) === slashCode) {
+			throw new Error(
+				`Imports field key should not start with "#/" (key: ${JSON.stringify(
+					key
+				)})`
+			);
+		}
 
-/**
- * Mangle import names and modules
- * @param {Object} state state
- * @param {Object} state.ast Module's ast
- * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
- * @returns {ArrayBufferTransform} transform
- */
-const rewriteImports =
-	({ ast, usedDependencyMap }) =>
-	bin => {
-		return editWithAST(ast, bin, {
-			ModuleImport(path) {
-				const result = usedDependencyMap.get(
-					path.node.module + ":" + path.node.name
-				);
+		walkPath(root, key.slice(1), field[key]);
+	}
 
-				if (result !== undefined) {
-					path.node.module = result.module;
-					path.node.name = result.name;
-				}
-			}
-		});
-	};
+	return root;
+}
+
+
+/***/ }),
+
+/***/ 71053:
+/***/ (function(module) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+
+
+const PATH_QUERY_FRAGMENT_REGEXP = /^(#?(?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
 /**
- * Add an init function.
- *
- * The init function fills the globals given input arguments.
- *
- * @param {Object} state transformation state
- * @param {Object} state.ast Module's ast
- * @param {t.Identifier} state.initFuncId identifier of the init function
- * @param {t.Index} state.startAtFuncOffset index of the start function
- * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
- * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
- * @param {t.Index} state.nextFuncIndex index of the next function
- * @param {t.Index} state.nextTypeIndex index of the next type
- * @returns {ArrayBufferTransform} transform
+ * @param {string} identifier identifier
+ * @returns {[string, string, string]|null} parsed identifier
  */
-const addInitFunction =
-	({
-		ast,
-		initFuncId,
-		startAtFuncOffset,
-		importedGlobals,
-		additionalInitCode,
-		nextFuncIndex,
-		nextTypeIndex
-	}) =>
-	bin => {
-		const funcParams = importedGlobals.map(importedGlobal => {
-			// used for debugging
-			const id = t.identifier(
-				`${importedGlobal.module}.${importedGlobal.name}`
-			);
+function parseIdentifier(identifier) {
+	const match = PATH_QUERY_FRAGMENT_REGEXP.exec(identifier);
 
-			return t.funcParam(importedGlobal.descr.valtype, id);
-		});
+	if (!match) return null;
 
-		const funcBody = [];
-		importedGlobals.forEach((importedGlobal, index) => {
-			const args = [t.indexLiteral(index)];
-			const body = [
-				t.instruction("get_local", args),
-				t.instruction("set_global", args)
-			];
+	return [
+		match[1].replace(/\0(.)/g, "$1"),
+		match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		match[3] || ""
+	];
+}
 
-			funcBody.push(...body);
-		});
+module.exports.parseIdentifier = parseIdentifier;
 
-		if (typeof startAtFuncOffset === "number") {
-			funcBody.push(
-				t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset))
-			);
-		}
 
-		for (const instr of additionalInitCode) {
-			funcBody.push(instr);
-		}
+/***/ }),
 
-		funcBody.push(t.instruction("end"));
+/***/ 67079:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-		const funcResults = [];
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-		// Code section
-		const funcSignature = t.signature(funcParams, funcResults);
-		const func = t.func(initFuncId, funcSignature, funcBody);
 
-		// Type section
-		const functype = t.typeInstruction(undefined, funcSignature);
 
-		// Func section
-		const funcindex = t.indexInFuncSection(nextTypeIndex);
+const path = __webpack_require__(71017);
 
-		// Export section
-		const moduleExport = t.moduleExport(
-			initFuncId.value,
-			t.moduleExportDescr("Func", nextFuncIndex)
-		);
+const CHAR_HASH = "#".charCodeAt(0);
+const CHAR_SLASH = "/".charCodeAt(0);
+const CHAR_BACKSLASH = "\\".charCodeAt(0);
+const CHAR_A = "A".charCodeAt(0);
+const CHAR_Z = "Z".charCodeAt(0);
+const CHAR_LOWER_A = "a".charCodeAt(0);
+const CHAR_LOWER_Z = "z".charCodeAt(0);
+const CHAR_DOT = ".".charCodeAt(0);
+const CHAR_COLON = ":".charCodeAt(0);
 
-		return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
-	};
+const posixNormalize = path.posix.normalize;
+const winNormalize = path.win32.normalize;
 
 /**
- * Extract mangle mappings from module
- * @param {ModuleGraph} moduleGraph module graph
- * @param {Module} module current module
- * @param {boolean} mangle mangle imports
- * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
+ * @enum {number}
  */
-const getUsedDependencyMap = (moduleGraph, module, mangle) => {
-	/** @type {Map<string, UsedWasmDependency>} */
-	const map = new Map();
-	for (const usedDep of WebAssemblyUtils.getUsedDependencies(
-		moduleGraph,
-		module,
-		mangle
-	)) {
-		const dep = usedDep.dependency;
-		const request = dep.request;
-		const exportName = dep.name;
-		map.set(request + ":" + exportName, usedDep);
+const PathType = Object.freeze({
+	Empty: 0,
+	Normal: 1,
+	Relative: 2,
+	AbsoluteWin: 3,
+	AbsolutePosix: 4,
+	Internal: 5
+});
+exports.PathType = PathType;
+
+/**
+ * @param {string} p a path
+ * @returns {PathType} type of path
+ */
+const getType = p => {
+	switch (p.length) {
+		case 0:
+			return PathType.Empty;
+		case 1: {
+			const c0 = p.charCodeAt(0);
+			switch (c0) {
+				case CHAR_DOT:
+					return PathType.Relative;
+				case CHAR_SLASH:
+					return PathType.AbsolutePosix;
+				case CHAR_HASH:
+					return PathType.Internal;
+			}
+			return PathType.Normal;
+		}
+		case 2: {
+			const c0 = p.charCodeAt(0);
+			switch (c0) {
+				case CHAR_DOT: {
+					const c1 = p.charCodeAt(1);
+					switch (c1) {
+						case CHAR_DOT:
+						case CHAR_SLASH:
+							return PathType.Relative;
+					}
+					return PathType.Normal;
+				}
+				case CHAR_SLASH:
+					return PathType.AbsolutePosix;
+				case CHAR_HASH:
+					return PathType.Internal;
+			}
+			const c1 = p.charCodeAt(1);
+			if (c1 === CHAR_COLON) {
+				if (
+					(c0 >= CHAR_A && c0 <= CHAR_Z) ||
+					(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z)
+				) {
+					return PathType.AbsoluteWin;
+				}
+			}
+			return PathType.Normal;
+		}
 	}
-	return map;
+	const c0 = p.charCodeAt(0);
+	switch (c0) {
+		case CHAR_DOT: {
+			const c1 = p.charCodeAt(1);
+			switch (c1) {
+				case CHAR_SLASH:
+					return PathType.Relative;
+				case CHAR_DOT: {
+					const c2 = p.charCodeAt(2);
+					if (c2 === CHAR_SLASH) return PathType.Relative;
+					return PathType.Normal;
+				}
+			}
+			return PathType.Normal;
+		}
+		case CHAR_SLASH:
+			return PathType.AbsolutePosix;
+		case CHAR_HASH:
+			return PathType.Internal;
+	}
+	const c1 = p.charCodeAt(1);
+	if (c1 === CHAR_COLON) {
+		const c2 = p.charCodeAt(2);
+		if (
+			(c2 === CHAR_BACKSLASH || c2 === CHAR_SLASH) &&
+			((c0 >= CHAR_A && c0 <= CHAR_Z) ||
+				(c0 >= CHAR_LOWER_A && c0 <= CHAR_LOWER_Z))
+		) {
+			return PathType.AbsoluteWin;
+		}
+	}
+	return PathType.Normal;
 };
+exports.getType = getType;
 
-const TYPES = new Set(["webassembly"]);
-
-class WebAssemblyGenerator extends Generator {
-	constructor(options) {
-		super();
-		this.options = options;
+/**
+ * @param {string} p a path
+ * @returns {string} the normalized path
+ */
+const normalize = p => {
+	switch (getType(p)) {
+		case PathType.Empty:
+			return p;
+		case PathType.AbsoluteWin:
+			return winNormalize(p);
+		case PathType.Relative: {
+			const r = posixNormalize(p);
+			return getType(r) === PathType.Relative ? r : `./${r}`;
+		}
 	}
+	return posixNormalize(p);
+};
+exports.normalize = normalize;
 
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
+/**
+ * @param {string} rootPath the root path
+ * @param {string | undefined} request the request path
+ * @returns {string} the joined path
+ */
+const join = (rootPath, request) => {
+	if (!request) return normalize(rootPath);
+	const requestType = getType(request);
+	switch (requestType) {
+		case PathType.AbsolutePosix:
+			return posixNormalize(request);
+		case PathType.AbsoluteWin:
+			return winNormalize(request);
 	}
-
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		const originalSource = module.originalSource();
-		if (!originalSource) {
-			return 0;
+	switch (getType(rootPath)) {
+		case PathType.Normal:
+		case PathType.Relative:
+		case PathType.AbsolutePosix:
+			return posixNormalize(`${rootPath}/${request}`);
+		case PathType.AbsoluteWin:
+			return winNormalize(`${rootPath}\\${request}`);
+	}
+	switch (requestType) {
+		case PathType.Empty:
+			return rootPath;
+		case PathType.Relative: {
+			const r = posixNormalize(rootPath);
+			return getType(r) === PathType.Relative ? r : `./${r}`;
 		}
-		return originalSource.size();
 	}
+	return posixNormalize(rootPath);
+};
+exports.join = join;
 
-	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(module, { moduleGraph, runtime }) {
-		const bin = module.originalSource().source();
-
-		const initFuncId = t.identifier("");
+const joinCache = new Map();
 
-		// parse it
-		const ast = decode(bin, {
-			ignoreDataSection: true,
-			ignoreCodeSection: true,
-			ignoreCustomNameSection: true
-		});
+/**
+ * @param {string} rootPath the root path
+ * @param {string | undefined} request the request path
+ * @returns {string} the joined path
+ */
+const cachedJoin = (rootPath, request) => {
+	let cacheEntry;
+	let cache = joinCache.get(rootPath);
+	if (cache === undefined) {
+		joinCache.set(rootPath, (cache = new Map()));
+	} else {
+		cacheEntry = cache.get(request);
+		if (cacheEntry !== undefined) return cacheEntry;
+	}
+	cacheEntry = join(rootPath, request);
+	cache.set(request, cacheEntry);
+	return cacheEntry;
+};
+exports.cachedJoin = cachedJoin;
 
-		const moduleContext = moduleContextFromModuleAST(ast.body[0]);
+const checkExportsFieldTarget = relativePath => {
+	let lastNonSlashIndex = 2;
+	let slashIndex = relativePath.indexOf("/", 2);
+	let cd = 0;
 
-		const importedGlobals = getImportedGlobals(ast);
-		const countImportedFunc = getCountImportedFunc(ast);
-		const startAtFuncOffset = moduleContext.getStart();
-		const nextFuncIndex = getNextFuncIndex(ast, countImportedFunc);
-		const nextTypeIndex = getNextTypeIndex(ast);
+	while (slashIndex !== -1) {
+		const folder = relativePath.slice(lastNonSlashIndex, slashIndex);
 
-		const usedDependencyMap = getUsedDependencyMap(
-			moduleGraph,
-			module,
-			this.options.mangleImports
-		);
-		const externalExports = new Set(
-			module.dependencies
-				.filter(d => d instanceof WebAssemblyExportImportedDependency)
-				.map(d => {
-					const wasmDep = /** @type {WebAssemblyExportImportedDependency} */ (
-						d
+		switch (folder) {
+			case "..": {
+				cd--;
+				if (cd < 0)
+					return new Error(
+						`Trying to access out of package scope. Requesting ${relativePath}`
 					);
-					return wasmDep.exportName;
-				})
-		);
-
-		/** @type {t.Instruction[]} */
-		const additionalInitCode = [];
-
-		const transform = compose(
-			rewriteExportNames({
-				ast,
-				moduleGraph,
-				module,
-				externalExports,
-				runtime
-			}),
+				break;
+			}
+			default:
+				cd++;
+				break;
+		}
 
-			removeStartFunc({ ast }),
+		lastNonSlashIndex = slashIndex + 1;
+		slashIndex = relativePath.indexOf("/", lastNonSlashIndex);
+	}
+};
+exports.checkExportsFieldTarget = checkExportsFieldTarget;
 
-			rewriteImportedGlobals({ ast, additionalInitCode }),
 
-			rewriteImports({
-				ast,
-				usedDependencyMap
-			}),
+/***/ }),
 
-			addInitFunction({
-				ast,
-				initFuncId,
-				importedGlobals,
-				additionalInitCode,
-				startAtFuncOffset,
-				nextFuncIndex,
-				nextTypeIndex
-			})
-		);
+/***/ 39102:
+/***/ (function(module) {
 
-		const newBin = transform(bin);
+"use strict";
 
-		const newBuf = Buffer.from(newBin);
 
-		return new RawSource(newBuf);
+class LoadingLoaderError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LoaderRunnerError";
+		Error.captureStackTrace(this, this.constructor);
 	}
 }
 
-module.exports = WebAssemblyGenerator;
+module.exports = LoadingLoaderError;
 
 
 /***/ }),
 
-/***/ 47342:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 8255:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-"use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
+var fs = __webpack_require__(57147);
+var readFile = fs.readFile.bind(fs);
+var loadLoader = __webpack_require__(44690);
 
+function utf8BufferToString(buf) {
+	var str = buf.toString("utf-8");
+	if(str.charCodeAt(0) === 0xFEFF) {
+		return str.substr(1);
+	} else {
+		return str;
+	}
+}
 
-
-const WebpackError = __webpack_require__(53799);
-
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RequestShortener")} RequestShortener */
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 
 /**
- * @param {Module} module module to get chains from
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {RequestShortener} requestShortener to make readable identifiers
- * @returns {string[]} all chains to the module
+ * @param {string} str the path with query and fragment
+ * @returns {{ path: string, query: string, fragment: string }} parsed parts
  */
-const getInitialModuleChains = (
-	module,
-	moduleGraph,
-	chunkGraph,
-	requestShortener
-) => {
-	const queue = [
-		{ head: module, message: module.readableIdentifier(requestShortener) }
-	];
-	/** @type {Set<string>} */
-	const results = new Set();
-	/** @type {Set<string>} */
-	const incompleteResults = new Set();
-	/** @type {Set<Module>} */
-	const visitedModules = new Set();
+function parsePathQueryFragment(str) {
+	var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+	return {
+		path: match[1].replace(/\0(.)/g, "$1"),
+		query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+		fragment: match[3] || ""
+	};
+}
 
-	for (const chain of queue) {
-		const { head, message } = chain;
-		let final = true;
-		/** @type {Set<Module>} */
-		const alreadyReferencedModules = new Set();
-		for (const connection of moduleGraph.getIncomingConnections(head)) {
-			const newHead = connection.originModule;
-			if (newHead) {
-				if (!chunkGraph.getModuleChunks(newHead).some(c => c.canBeInitial()))
-					continue;
-				final = false;
-				if (alreadyReferencedModules.has(newHead)) continue;
-				alreadyReferencedModules.add(newHead);
-				const moduleName = newHead.readableIdentifier(requestShortener);
-				const detail = connection.explanation
-					? ` (${connection.explanation})`
-					: "";
-				const newMessage = `${moduleName}${detail} --> ${message}`;
-				if (visitedModules.has(newHead)) {
-					incompleteResults.add(`... --> ${newMessage}`);
-					continue;
-				}
-				visitedModules.add(newHead);
-				queue.push({
-					head: newHead,
-					message: newMessage
-				});
+function dirname(path) {
+	if(path === "/") return "/";
+	var i = path.lastIndexOf("/");
+	var j = path.lastIndexOf("\\");
+	var i2 = path.indexOf("/");
+	var j2 = path.indexOf("\\");
+	var idx = i > j ? i : j;
+	var idx2 = i > j ? i2 : j2;
+	if(idx < 0) return path;
+	if(idx === idx2) return path.substr(0, idx + 1);
+	return path.substr(0, idx);
+}
+
+function createLoaderObject(loader) {
+	var obj = {
+		path: null,
+		query: null,
+		fragment: null,
+		options: null,
+		ident: null,
+		normal: null,
+		pitch: null,
+		raw: null,
+		data: null,
+		pitchExecuted: false,
+		normalExecuted: false
+	};
+	Object.defineProperty(obj, "request", {
+		enumerable: true,
+		get: function() {
+			return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
+		},
+		set: function(value) {
+			if(typeof value === "string") {
+				var splittedRequest = parsePathQueryFragment(value);
+				obj.path = splittedRequest.path;
+				obj.query = splittedRequest.query;
+				obj.fragment = splittedRequest.fragment;
+				obj.options = undefined;
+				obj.ident = undefined;
 			} else {
-				final = false;
-				const newMessage = connection.explanation
-					? `(${connection.explanation}) --> ${message}`
-					: message;
-				results.add(newMessage);
+				if(!value.loader)
+					throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
+				obj.path = value.loader;
+				obj.fragment = value.fragment || "";
+				obj.type = value.type;
+				obj.options = value.options;
+				obj.ident = value.ident;
+				if(obj.options === null)
+					obj.query = "";
+				else if(obj.options === undefined)
+					obj.query = "";
+				else if(typeof obj.options === "string")
+					obj.query = "?" + obj.options;
+				else if(obj.ident)
+					obj.query = "??" + obj.ident;
+				else if(typeof obj.options === "object" && obj.options.ident)
+					obj.query = "??" + obj.options.ident;
+				else
+					obj.query = "?" + JSON.stringify(obj.options);
 			}
 		}
-		if (final) {
-			results.add(message);
-		}
+	});
+	obj.request = loader;
+	if(Object.preventExtensions) {
+		Object.preventExtensions(obj);
 	}
-	for (const result of incompleteResults) {
-		results.add(result);
+	return obj;
+}
+
+function runSyncOrAsync(fn, context, args, callback) {
+	var isSync = true;
+	var isDone = false;
+	var isError = false; // internal error
+	var reportedError = false;
+	context.async = function async() {
+		if(isDone) {
+			if(reportedError) return; // ignore
+			throw new Error("async(): The callback was already called.");
+		}
+		isSync = false;
+		return innerCallback;
+	};
+	var innerCallback = context.callback = function() {
+		if(isDone) {
+			if(reportedError) return; // ignore
+			throw new Error("callback(): The callback was already called.");
+		}
+		isDone = true;
+		isSync = false;
+		try {
+			callback.apply(null, arguments);
+		} catch(e) {
+			isError = true;
+			throw e;
+		}
+	};
+	try {
+		var result = (function LOADER_EXECUTION() {
+			return fn.apply(context, args);
+		}());
+		if(isSync) {
+			isDone = true;
+			if(result === undefined)
+				return callback();
+			if(result && typeof result === "object" && typeof result.then === "function") {
+				return result.then(function(r) {
+					callback(null, r);
+				}, callback);
+			}
+			return callback(null, result);
+		}
+	} catch(e) {
+		if(isError) throw e;
+		if(isDone) {
+			// loader is already "done", so we cannot use the callback function
+			// for better debugging we print the error on the console
+			if(typeof e === "object" && e.stack) console.error(e.stack);
+			else console.error(e);
+			return;
+		}
+		isDone = true;
+		reportedError = true;
+		callback(e);
 	}
-	return Array.from(results);
-};
 
-module.exports = class WebAssemblyInInitialChunkError extends WebpackError {
-	/**
-	 * @param {Module} module WASM module
-	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {RequestShortener} requestShortener request shortener
-	 */
-	constructor(module, moduleGraph, chunkGraph, requestShortener) {
-		const moduleChains = getInitialModuleChains(
-			module,
-			moduleGraph,
-			chunkGraph,
-			requestShortener
-		);
-		const message = `WebAssembly module is included in initial chunk.
-This is not allowed, because WebAssembly download and compilation must happen asynchronous.
-Add an async split point (i. e. import()) somewhere between your entrypoint and the WebAssembly module:
-${moduleChains.map(s => `* ${s}`).join("\n")}`;
+}
 
-		super(message);
-		this.name = "WebAssemblyInInitialChunkError";
-		this.hideStack = true;
-		this.module = module;
-	}
-};
+function convertArgs(args, raw) {
+	if(!raw && Buffer.isBuffer(args[0]))
+		args[0] = utf8BufferToString(args[0]);
+	else if(raw && typeof args[0] === "string")
+		args[0] = Buffer.from(args[0], "utf-8");
+}
 
+function iteratePitchingLoaders(options, loaderContext, callback) {
+	// abort after last loader
+	if(loaderContext.loaderIndex >= loaderContext.loaders.length)
+		return processResource(options, loaderContext, callback);
 
-/***/ }),
+	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
 
-/***/ 46545:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	// iterate
+	if(currentLoaderObject.pitchExecuted) {
+		loaderContext.loaderIndex++;
+		return iteratePitchingLoaders(options, loaderContext, callback);
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	// load loader module
+	loadLoader(currentLoaderObject, function(err) {
+		if(err) {
+			loaderContext.cacheable(false);
+			return callback(err);
+		}
+		var fn = currentLoaderObject.pitch;
+		currentLoaderObject.pitchExecuted = true;
+		if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
 
+		runSyncOrAsync(
+			fn,
+			loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
+			function(err) {
+				if(err) return callback(err);
+				var args = Array.prototype.slice.call(arguments, 1);
+				// Determine whether to continue the pitching process based on
+				// argument values (as opposed to argument presence) in order
+				// to support synchronous and asynchronous usages.
+				var hasArg = args.some(function(value) {
+					return value !== undefined;
+				});
+				if(hasArg) {
+					loaderContext.loaderIndex--;
+					iterateNormalLoaders(options, loaderContext, args, callback);
+				} else {
+					iteratePitchingLoaders(options, loaderContext, callback);
+				}
+			}
+		);
+	});
+}
 
+function processResource(options, loaderContext, callback) {
+	// set loader index to last loader
+	loaderContext.loaderIndex = loaderContext.loaders.length - 1;
 
-const { RawSource } = __webpack_require__(51255);
-const { UsageState } = __webpack_require__(63686);
-const Generator = __webpack_require__(93401);
-const InitFragment = __webpack_require__(55870);
-const RuntimeGlobals = __webpack_require__(16475);
-const Template = __webpack_require__(39722);
-const ModuleDependency = __webpack_require__(80321);
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+	var resourcePath = loaderContext.resourcePath;
+	if(resourcePath) {
+		options.processResource(loaderContext, resourcePath, function(err, buffer) {
+			if(err) return callback(err);
+			options.resourceBuffer = buffer;
+			iterateNormalLoaders(options, loaderContext, [buffer], callback);
+		});
+	} else {
+		iterateNormalLoaders(options, loaderContext, [null], callback);
+	}
+}
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+function iterateNormalLoaders(options, loaderContext, args, callback) {
+	if(loaderContext.loaderIndex < 0)
+		return callback(null, args);
 
-const TYPES = new Set(["webassembly"]);
+	var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
 
-class WebAssemblyJavascriptGenerator extends Generator {
-	/**
-	 * @param {NormalModule} module fresh module
-	 * @returns {Set<string>} available types (do not mutate)
-	 */
-	getTypes(module) {
-		return TYPES;
+	// iterate
+	if(currentLoaderObject.normalExecuted) {
+		loaderContext.loaderIndex--;
+		return iterateNormalLoaders(options, loaderContext, args, callback);
 	}
 
-	/**
-	 * @param {NormalModule} module the module
-	 * @param {string=} type source type
-	 * @returns {number} estimate size of the module
-	 */
-	getSize(module, type) {
-		return 95 + module.dependencies.length * 5;
+	var fn = currentLoaderObject.normal;
+	currentLoaderObject.normalExecuted = true;
+	if(!fn) {
+		return iterateNormalLoaders(options, loaderContext, args, callback);
 	}
 
-	/**
-	 * @param {NormalModule} module module for which the code should be generated
-	 * @param {GenerateContext} generateContext context for generate
-	 * @returns {Source} generated code
-	 */
-	generate(module, generateContext) {
-		const {
-			runtimeTemplate,
-			moduleGraph,
-			chunkGraph,
-			runtimeRequirements,
-			runtime
-		} = generateContext;
-		/** @type {InitFragment[]} */
-		const initFragments = [];
+	convertArgs(args, currentLoaderObject.raw);
 
-		const exportsInfo = moduleGraph.getExportsInfo(module);
+	runSyncOrAsync(fn, loaderContext, args, function(err) {
+		if(err) return callback(err);
 
-		let needExportsCopy = false;
-		const importedModules = new Map();
-		const initParams = [];
-		let index = 0;
-		for (const dep of module.dependencies) {
-			const moduleDep =
-				dep && dep instanceof ModuleDependency ? dep : undefined;
-			if (moduleGraph.getModule(dep)) {
-				let importData = importedModules.get(moduleGraph.getModule(dep));
-				if (importData === undefined) {
-					importedModules.set(
-						moduleGraph.getModule(dep),
-						(importData = {
-							importVar: `m${index}`,
-							index,
-							request: (moduleDep && moduleDep.userRequest) || undefined,
-							names: new Set(),
-							reexports: []
-						})
-					);
-					index++;
-				}
-				if (dep instanceof WebAssemblyImportDependency) {
-					importData.names.add(dep.name);
-					if (dep.description.type === "GlobalType") {
-						const exportName = dep.name;
-						const importedModule = moduleGraph.getModule(dep);
+		var args = Array.prototype.slice.call(arguments, 1);
+		iterateNormalLoaders(options, loaderContext, args, callback);
+	});
+}
 
-						if (importedModule) {
-							const usedName = moduleGraph
-								.getExportsInfo(importedModule)
-								.getUsedName(exportName, runtime);
-							if (usedName) {
-								initParams.push(
-									runtimeTemplate.exportFromImport({
-										moduleGraph,
-										module: importedModule,
-										request: dep.request,
-										importVar: importData.importVar,
-										originModule: module,
-										exportName: dep.name,
-										asiSafe: true,
-										isCall: false,
-										callContext: null,
-										defaultInterop: true,
-										initFragments,
-										runtime,
-										runtimeRequirements
-									})
-								);
-							}
-						}
-					}
-				}
-				if (dep instanceof WebAssemblyExportImportedDependency) {
-					importData.names.add(dep.name);
-					const usedName = moduleGraph
-						.getExportsInfo(module)
-						.getUsedName(dep.exportName, runtime);
-					if (usedName) {
-						runtimeRequirements.add(RuntimeGlobals.exports);
-						const exportProp = `${module.exportsArgument}[${JSON.stringify(
-							usedName
-						)}]`;
-						const defineStatement = Template.asString([
-							`${exportProp} = ${runtimeTemplate.exportFromImport({
-								moduleGraph,
-								module: moduleGraph.getModule(dep),
-								request: dep.request,
-								importVar: importData.importVar,
-								originModule: module,
-								exportName: dep.name,
-								asiSafe: true,
-								isCall: false,
-								callContext: null,
-								defaultInterop: true,
-								initFragments,
-								runtime,
-								runtimeRequirements
-							})};`,
-							`if(WebAssembly.Global) ${exportProp} = ` +
-								`new WebAssembly.Global({ value: ${JSON.stringify(
-									dep.valueType
-								)} }, ${exportProp});`
-						]);
-						importData.reexports.push(defineStatement);
-						needExportsCopy = true;
-					}
-				}
-			}
-		}
-		const importsCode = Template.asString(
-			Array.from(
-				importedModules,
-				([module, { importVar, request, reexports }]) => {
-					const importStatement = runtimeTemplate.importStatement({
-						module,
-						chunkGraph,
-						request,
-						importVar,
-						originModule: module,
-						runtimeRequirements
-					});
-					return importStatement[0] + importStatement[1] + reexports.join("\n");
-				}
-			)
-		);
+exports.getContext = function getContext(resource) {
+	var path = parsePathQueryFragment(resource).path;
+	return dirname(path);
+};
 
-		const copyAllExports =
-			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused &&
-			!needExportsCopy;
+exports.runLoaders = function runLoaders(options, callback) {
+	// read options
+	var resource = options.resource || "";
+	var loaders = options.loaders || [];
+	var loaderContext = options.context || {};
+	var processResource = options.processResource || ((readResource, context, resource, callback) => {
+		context.addDependency(resource);
+		readResource(resource, callback);
+	}).bind(null, options.readResource || readFile);
 
-		// need these globals
-		runtimeRequirements.add(RuntimeGlobals.module);
-		runtimeRequirements.add(RuntimeGlobals.moduleId);
-		runtimeRequirements.add(RuntimeGlobals.wasmInstances);
-		if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused) {
-			runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
-			runtimeRequirements.add(RuntimeGlobals.exports);
-		}
-		if (!copyAllExports) {
-			runtimeRequirements.add(RuntimeGlobals.exports);
-		}
+	//
+	var splittedResource = resource && parsePathQueryFragment(resource);
+	var resourcePath = splittedResource ? splittedResource.path : undefined;
+	var resourceQuery = splittedResource ? splittedResource.query : undefined;
+	var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+	var contextDirectory = resourcePath ? dirname(resourcePath) : null;
 
-		// create source
-		const source = new RawSource(
-			[
-				'"use strict";',
-				"// Instantiate WebAssembly module",
-				`var wasmExports = ${RuntimeGlobals.wasmInstances}[${module.moduleArgument}.id];`,
+	// execution state
+	var requestCacheable = true;
+	var fileDependencies = [];
+	var contextDependencies = [];
+	var missingDependencies = [];
 
-				exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused
-					? `${RuntimeGlobals.makeNamespaceObject}(${module.exportsArgument});`
-					: "",
+	// prepare loader objects
+	loaders = loaders.map(createLoaderObject);
 
-				// this must be before import for circular dependencies
-				"// export exports from WebAssembly module",
-				copyAllExports
-					? `${module.moduleArgument}.exports = wasmExports;`
-					: "for(var name in wasmExports) " +
-					  `if(name) ` +
-					  `${module.exportsArgument}[name] = wasmExports[name];`,
-				"// exec imports from WebAssembly module (for esm order)",
-				importsCode,
-				"",
-				"// exec wasm module",
-				`wasmExports[""](${initParams.join(", ")})`
-			].join("\n")
-		);
-		return InitFragment.addToSource(source, initFragments, generateContext);
+	loaderContext.context = contextDirectory;
+	loaderContext.loaderIndex = 0;
+	loaderContext.loaders = loaders;
+	loaderContext.resourcePath = resourcePath;
+	loaderContext.resourceQuery = resourceQuery;
+	loaderContext.resourceFragment = resourceFragment;
+	loaderContext.async = null;
+	loaderContext.callback = null;
+	loaderContext.cacheable = function cacheable(flag) {
+		if(flag === false) {
+			requestCacheable = false;
+		}
+	};
+	loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
+		fileDependencies.push(file);
+	};
+	loaderContext.addContextDependency = function addContextDependency(context) {
+		contextDependencies.push(context);
+	};
+	loaderContext.addMissingDependency = function addMissingDependency(context) {
+		missingDependencies.push(context);
+	};
+	loaderContext.getDependencies = function getDependencies() {
+		return fileDependencies.slice();
+	};
+	loaderContext.getContextDependencies = function getContextDependencies() {
+		return contextDependencies.slice();
+	};
+	loaderContext.getMissingDependencies = function getMissingDependencies() {
+		return missingDependencies.slice();
+	};
+	loaderContext.clearDependencies = function clearDependencies() {
+		fileDependencies.length = 0;
+		contextDependencies.length = 0;
+		missingDependencies.length = 0;
+		requestCacheable = true;
+	};
+	Object.defineProperty(loaderContext, "resource", {
+		enumerable: true,
+		get: function() {
+			if(loaderContext.resourcePath === undefined)
+				return undefined;
+			return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
+		},
+		set: function(value) {
+			var splittedResource = value && parsePathQueryFragment(value);
+			loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
+			loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
+			loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+		}
+	});
+	Object.defineProperty(loaderContext, "request", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "remainingRequest", {
+		enumerable: true,
+		get: function() {
+			if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
+				return "";
+			return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "currentRequest", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
+				return o.request;
+			}).concat(loaderContext.resource || "").join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "previousRequest", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
+				return o.request;
+			}).join("!");
+		}
+	});
+	Object.defineProperty(loaderContext, "query", {
+		enumerable: true,
+		get: function() {
+			var entry = loaderContext.loaders[loaderContext.loaderIndex];
+			return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
+		}
+	});
+	Object.defineProperty(loaderContext, "data", {
+		enumerable: true,
+		get: function() {
+			return loaderContext.loaders[loaderContext.loaderIndex].data;
+		}
+	});
+
+	// finish loader context
+	if(Object.preventExtensions) {
+		Object.preventExtensions(loaderContext);
 	}
-}
 
-module.exports = WebAssemblyJavascriptGenerator;
+	var processOptions = {
+		resourceBuffer: null,
+		processResource: processResource
+	};
+	iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
+		if(err) {
+			return callback(err, {
+				cacheable: requestCacheable,
+				fileDependencies: fileDependencies,
+				contextDependencies: contextDependencies,
+				missingDependencies: missingDependencies
+			});
+		}
+		callback(null, {
+			result: result,
+			resourceBuffer: processOptions.resourceBuffer,
+			cacheable: requestCacheable,
+			fileDependencies: fileDependencies,
+			contextDependencies: contextDependencies,
+			missingDependencies: missingDependencies
+		});
+	});
+};
 
 
 /***/ }),
 
-/***/ 53639:
+/***/ 44690:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-
-
-const Generator = __webpack_require__(93401);
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-const WebAssemblyImportDependency = __webpack_require__(5239);
-const { compareModulesByIdentifier } = __webpack_require__(29579);
-const memoize = __webpack_require__(78676);
-const WebAssemblyInInitialChunkError = __webpack_require__(47342);
-
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
-
-const getWebAssemblyGenerator = memoize(() =>
-	__webpack_require__(47012)
-);
-const getWebAssemblyJavascriptGenerator = memoize(() =>
-	__webpack_require__(46545)
-);
-const getWebAssemblyParser = memoize(() => __webpack_require__(57059));
+var LoaderLoadingError = __webpack_require__(39102);
+var url;
 
-class WebAssemblyModulesPlugin {
-	constructor(options) {
-		this.options = options;
+module.exports = function loadLoader(loader, callback) {
+	if(loader.type === "module") {
+		try {
+			if(url === undefined) url = __webpack_require__(57310);
+			var loaderUrl = url.pathToFileURL(loader.path);
+			var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
+			modulePromise.then(function(module) {
+				handleResult(loader, module, callback);
+			}, callback);
+			return;
+		} catch(e) {
+			callback(e);
+		}
+	} else {
+		try {
+			var module = require(loader.path);
+		} catch(e) {
+			// it is possible for node to choke on a require if the FD descriptor
+			// limit has been reached. give it a chance to recover.
+			if(e instanceof Error && e.code === "EMFILE") {
+				var retry = loadLoader.bind(null, loader, callback);
+				if(typeof setImmediate === "function") {
+					// node >= 0.9.0
+					return setImmediate(retry);
+				} else {
+					// node < 0.9.0
+					return process.nextTick(retry);
+				}
+			}
+			return callback(e);
+		}
+		return handleResult(loader, module, callback);
 	}
+};
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WebAssemblyModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WebAssemblyImportDependency,
-					normalModuleFactory
-				);
-
-				compilation.dependencyFactories.set(
-					WebAssemblyExportImportedDependency,
-					normalModuleFactory
-				);
-
-				normalModuleFactory.hooks.createParser
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
-						const WebAssemblyParser = getWebAssemblyParser();
-
-						return new WebAssemblyParser();
-					});
-
-				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
-						const WebAssemblyJavascriptGenerator =
-							getWebAssemblyJavascriptGenerator();
-						const WebAssemblyGenerator = getWebAssemblyGenerator();
-
-						return Generator.byType({
-							javascript: new WebAssemblyJavascriptGenerator(),
-							webassembly: new WebAssemblyGenerator(this.options)
-						});
-					});
-
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { chunkGraph } = compilation;
-						const { chunk, outputOptions, codeGenerationResults } = options;
-
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === "webassembly/sync") {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
-
-								result.push({
-									render: () =>
-										codeGenerationResults.getSource(
-											module,
-											chunk.runtime,
-											"webassembly"
-										),
-									filenameTemplate,
-									pathOptions: {
-										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
-						}
-
-						return result;
-					}
-				);
-
-				compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
-					const chunkGraph = compilation.chunkGraph;
-					const initialWasmModules = new Set();
-					for (const chunk of compilation.chunks) {
-						if (chunk.canBeInitial()) {
-							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								if (module.type === "webassembly/sync") {
-									initialWasmModules.add(module);
-								}
-							}
-						}
-					}
-					for (const module of initialWasmModules) {
-						compilation.errors.push(
-							new WebAssemblyInInitialChunkError(
-								module,
-								compilation.moduleGraph,
-								compilation.chunkGraph,
-								compilation.requestShortener
-							)
-						);
-					}
-				});
-			}
-		);
+function handleResult(loader, module, callback) {
+	if(typeof module !== "function" && typeof module !== "object") {
+		return callback(new LoaderLoadingError(
+			"Module '" + loader.path + "' is not a loader (export function or es6 module)"
+		));
+	}
+	loader.normal = typeof module === "function" ? module : module.default;
+	loader.pitch = module.pitch;
+	loader.raw = module.raw;
+	if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
+		return callback(new LoaderLoadingError(
+			"Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
+		));
 	}
+	callback();
 }
 
-module.exports = WebAssemblyModulesPlugin;
-
 
 /***/ }),
 
-/***/ 57059:
+/***/ 50569:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
 
+/**
+ * Module exports.
+ */
 
-const t = __webpack_require__(51826);
-const { moduleContextFromModuleAST } = __webpack_require__(51826);
-const { decode } = __webpack_require__(73726);
-const Parser = __webpack_require__(11715);
-const StaticExportsDependency = __webpack_require__(91418);
-const WebAssemblyExportImportedDependency = __webpack_require__(52204);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+module.exports = __webpack_require__(58750)
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
-const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
+/***/ }),
 
-/**
- * @param {t.Signature} signature the func signature
- * @returns {null | string} the type incompatible with js types
- */
-const getJsIncompatibleType = signature => {
-	for (const param of signature.params) {
-		if (!JS_COMPAT_TYPES.has(param.valtype)) {
-			return `${param.valtype} as parameter`;
-		}
-	}
-	for (const type of signature.results) {
-		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
-	}
-	return null;
-};
+/***/ 78585:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
-/**
- * TODO why are there two different Signature types?
- * @param {t.FuncSignature} signature the func signature
- * @returns {null | string} the type incompatible with js types
+"use strict";
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
  */
-const getJsIncompatibleTypeOfFuncSignature = signature => {
-	for (const param of signature.args) {
-		if (!JS_COMPAT_TYPES.has(param)) {
-			return `${param} as parameter`;
-		}
-	}
-	for (const type of signature.result) {
-		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
-	}
-	return null;
-};
 
-const decoderOpts = {
-	ignoreCodeSection: true,
-	ignoreDataSection: true,
-
-	// this will avoid having to lookup with identifiers in the ModuleContext
-	ignoreCustomNameSection: true
-};
 
-class WebAssemblyParser extends Parser {
-	constructor(options) {
-		super();
-		this.hooks = Object.freeze({});
-		this.options = options;
-	}
 
-	/**
-	 * @param {string | Buffer | PreparsedAst} source the source to parse
-	 * @param {ParserState} state the parser state
-	 * @returns {ParserState} the parser state
-	 */
-	parse(source, state) {
-		if (!Buffer.isBuffer(source)) {
-			throw new Error("WebAssemblyParser input must be a Buffer");
-		}
+/**
+ * Module dependencies.
+ * @private
+ */
 
-		// flag it as ESM
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
+var db = __webpack_require__(50569)
+var extname = (__webpack_require__(71017).extname)
 
-		// parse it
-		const program = decode(source, decoderOpts);
-		const module = program.body[0];
+/**
+ * Module variables.
+ * @private
+ */
 
-		const moduleContext = moduleContextFromModuleAST(module);
+var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
+var TEXT_TYPE_REGEXP = /^text\//i
 
-		// extract imports and exports
-		const exports = [];
-		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
-			undefined);
+/**
+ * Module exports.
+ * @public
+ */
 
-		const importedGlobals = [];
-		t.traverse(module, {
-			ModuleExport({ node }) {
-				const descriptor = node.descr;
+exports.charset = charset
+exports.charsets = { lookup: charset }
+exports.contentType = contentType
+exports.extension = extension
+exports.extensions = Object.create(null)
+exports.lookup = lookup
+exports.types = Object.create(null)
 
-				if (descriptor.exportType === "Func") {
-					const funcIdx = descriptor.id.value;
+// Populate the extensions/types maps
+populateMaps(exports.extensions, exports.types)
 
-					/** @type {t.FuncSignature} */
-					const funcSignature = moduleContext.getFunction(funcIdx);
+/**
+ * Get the default charset for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
 
-					const incompatibleType =
-						getJsIncompatibleTypeOfFuncSignature(funcSignature);
+function charset (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
 
-					if (incompatibleType) {
-						if (jsIncompatibleExports === undefined) {
-							jsIncompatibleExports =
-								state.module.buildMeta.jsIncompatibleExports = {};
-						}
-						jsIncompatibleExports[node.name] = incompatibleType;
-					}
-				}
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+  var mime = match && db[match[1].toLowerCase()]
 
-				exports.push(node.name);
+  if (mime && mime.charset) {
+    return mime.charset
+  }
 
-				if (node.descr && node.descr.exportType === "Global") {
-					const refNode = importedGlobals[node.descr.id.value];
-					if (refNode) {
-						const dep = new WebAssemblyExportImportedDependency(
-							node.name,
-							refNode.module,
-							refNode.name,
-							refNode.descr.valtype
-						);
+  // default text/* to utf-8
+  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+    return 'UTF-8'
+  }
 
-						state.module.addDependency(dep);
-					}
-				}
-			},
+  return false
+}
 
-			Global({ node }) {
-				const init = node.init[0];
+/**
+ * Create a full Content-Type header given a MIME type or extension.
+ *
+ * @param {string} str
+ * @return {boolean|string}
+ */
 
-				let importNode = null;
+function contentType (str) {
+  // TODO: should this even be in this module?
+  if (!str || typeof str !== 'string') {
+    return false
+  }
 
-				if (init.id === "get_global") {
-					const globalIdx = init.args[0].value;
+  var mime = str.indexOf('/') === -1
+    ? exports.lookup(str)
+    : str
 
-					if (globalIdx < importedGlobals.length) {
-						importNode = importedGlobals[globalIdx];
-					}
-				}
+  if (!mime) {
+    return false
+  }
 
-				importedGlobals.push(importNode);
-			},
+  // TODO: use content-type or other module
+  if (mime.indexOf('charset') === -1) {
+    var charset = exports.charset(mime)
+    if (charset) mime += '; charset=' + charset.toLowerCase()
+  }
 
-			ModuleImport({ node }) {
-				/** @type {false | string} */
-				let onlyDirectImport = false;
+  return mime
+}
 
-				if (t.isMemory(node.descr) === true) {
-					onlyDirectImport = "Memory";
-				} else if (t.isTable(node.descr) === true) {
-					onlyDirectImport = "Table";
-				} else if (t.isFuncImportDescr(node.descr) === true) {
-					const incompatibleType = getJsIncompatibleType(node.descr.signature);
-					if (incompatibleType) {
-						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
-					}
-				} else if (t.isGlobalType(node.descr) === true) {
-					const type = node.descr.valtype;
-					if (!JS_COMPAT_TYPES.has(type)) {
-						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
-					}
-				}
+/**
+ * Get the default extension for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
 
-				const dep = new WebAssemblyImportDependency(
-					node.module,
-					node.name,
-					node.descr,
-					onlyDirectImport
-				);
+function extension (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
 
-				state.module.addDependency(dep);
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
 
-				if (t.isGlobalType(node.descr)) {
-					importedGlobals.push(node);
-				}
-			}
-		});
+  // get extensions
+  var exts = match && exports.extensions[match[1].toLowerCase()]
 
-		state.module.addDependency(new StaticExportsDependency(exports, false));
+  if (!exts || !exts.length) {
+    return false
+  }
 
-		return state;
-	}
+  return exts[0]
 }
 
-module.exports = WebAssemblyParser;
+/**
+ * Lookup the MIME type for a file path/extension.
+ *
+ * @param {string} path
+ * @return {boolean|string}
+ */
 
+function lookup (path) {
+  if (!path || typeof path !== 'string') {
+    return false
+  }
 
-/***/ }),
+  // get the extension ("ext" or ".ext" or full path)
+  var extension = extname('x.' + path)
+    .toLowerCase()
+    .substr(1)
 
-/***/ 18650:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+  if (!extension) {
+    return false
+  }
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+  return exports.types[extension] || false
+}
 
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
 
+function populateMaps (extensions, types) {
+  // source preference (least -> most)
+  var preference = ['nginx', 'apache', undefined, 'iana']
 
-const Template = __webpack_require__(39722);
-const WebAssemblyImportDependency = __webpack_require__(5239);
+  Object.keys(db).forEach(function forEachMimeType (type) {
+    var mime = db[type]
+    var exts = mime.extensions
 
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+    if (!exts || !exts.length) {
+      return
+    }
 
-/** @typedef {Object} UsedWasmDependency
- * @property {WebAssemblyImportDependency} dependency the dependency
- * @property {string} name the export name
- * @property {string} module the module name
- */
+    // mime -> extensions
+    extensions[type] = exts
 
-const MANGLED_MODULE = "a";
+    // extension -> mime
+    for (var i = 0; i < exts.length; i++) {
+      var extension = exts[i]
 
-/**
- * @param {ModuleGraph} moduleGraph the module graph
- * @param {Module} module the module
- * @param {boolean} mangle mangle module and export names
- * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
- */
-const getUsedDependencies = (moduleGraph, module, mangle) => {
-	/** @type {UsedWasmDependency[]} */
-	const array = [];
-	let importIndex = 0;
-	for (const dep of module.dependencies) {
-		if (dep instanceof WebAssemblyImportDependency) {
-			if (
-				dep.description.type === "GlobalType" ||
-				moduleGraph.getModule(dep) === null
-			) {
-				continue;
-			}
+      if (types[extension]) {
+        var from = preference.indexOf(db[types[extension]].source)
+        var to = preference.indexOf(mime.source)
 
-			const exportName = dep.name;
-			// TODO add the following 3 lines when removing of ModuleExport is possible
-			// const importedModule = moduleGraph.getModule(dep);
-			// const usedName = importedModule && moduleGraph.getExportsInfo(importedModule).getUsedName(exportName, runtime);
-			// if (usedName !== false) {
-			if (mangle) {
-				array.push({
-					dependency: dep,
-					name: Template.numberToIdentifier(importIndex++),
-					module: MANGLED_MODULE
-				});
-			} else {
-				array.push({
-					dependency: dep,
-					name: exportName,
-					module: dep.request
-				});
-			}
-		}
-	}
-	return array;
-};
+        if (types[extension] !== 'application/octet-stream' &&
+          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+          // skip the remapping
+          continue
+        }
+      }
 
-exports.getUsedDependencies = getUsedDependencies;
-exports.MANGLED_MODULE = MANGLED_MODULE;
+      // set the extension -> mime
+      types[extension] = type
+    }
+  })
+}
 
 
 /***/ }),
 
-/***/ 78613:
+/***/ 76297:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139322,123 +139572,90 @@ exports.MANGLED_MODULE = MANGLED_MODULE;
 */
 
 
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
-/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
-/** @typedef {import("../Compiler")} Compiler */
-
-/** @type {WeakMap<Compiler, Set<WasmLoadingType>>} */
-const enabledTypes = new WeakMap();
-
-const getEnabledTypes = compiler => {
-	let set = enabledTypes.get(compiler);
-	if (set === undefined) {
-		set = new Set();
-		enabledTypes.set(compiler, set);
-	}
-	return set;
-};
-
-class EnableWasmLoadingPlugin {
-	/**
-	 * @param {WasmLoadingType} type library type that should be available
-	 */
-	constructor(type) {
-		this.type = type;
-	}
-
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {WasmLoadingType} type type of library
-	 * @returns {void}
-	 */
-	static setEnabled(compiler, type) {
-		getEnabledTypes(compiler).add(type);
-	}
-
-	/**
-	 * @param {Compiler} compiler the compiler instance
-	 * @param {WasmLoadingType} type type of library
-	 * @returns {void}
-	 */
-	static checkEnabled(compiler, type) {
-		if (!getEnabledTypes(compiler).has(type)) {
-			throw new Error(
-				`Library type "${type}" is not enabled. ` +
-					"EnableWasmLoadingPlugin need to be used to enable this type of wasm loading. " +
-					'This usually happens through the "output.enabledWasmLoadingTypes" option. ' +
-					'If you are using a function as entry which sets "wasmLoading", you need to add all potential library types to "output.enabledWasmLoadingTypes". ' +
-					"These types are enabled: " +
-					Array.from(getEnabledTypes(compiler)).join(", ")
-			);
-		}
+class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		let code = "";
+		code += `var _results = new Array(${this.options.taps.length});\n`;
+		code += "var _checkDone = function() {\n";
+		code += "for(var i = 0; i < _results.length; i++) {\n";
+		code += "var item = _results[i];\n";
+		code += "if(item === undefined) return false;\n";
+		code += "if(item.result !== undefined) {\n";
+		code += onResult("item.result");
+		code += "return true;\n";
+		code += "}\n";
+		code += "if(item.error) {\n";
+		code += onError("item.error");
+		code += "return true;\n";
+		code += "}\n";
+		code += "}\n";
+		code += "return false;\n";
+		code += "}\n";
+		code += this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && ((_results.length = ${i +
+					1}), (_results[${i}] = { error: ${err} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onResult: (i, result, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i +
+					1}), (_results[${i}] = { result: ${result} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onTap: (i, run, done, doneBreak) => {
+				let code = "";
+				if (i > 0) {
+					code += `if(${i} >= _results.length) {\n`;
+					code += done();
+					code += "} else {\n";
+				}
+				code += run();
+				if (i > 0) code += "}\n";
+				return code;
+			},
+			onDone
+		});
+		return code;
 	}
+}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		const { type } = this;
+const factory = new AsyncParallelBailHookCodeFactory();
 
-		// Only enable once
-		const enabled = getEnabledTypes(compiler);
-		if (enabled.has(type)) return;
-		enabled.add(type);
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-		if (typeof type === "string") {
-			switch (type) {
-				case "fetch": {
-					// TODO webpack 6 remove FetchCompileWasmPlugin
-					const FetchCompileWasmPlugin = __webpack_require__(35537);
-					const FetchCompileAsyncWasmPlugin = __webpack_require__(8437);
-					new FetchCompileWasmPlugin({
-						mangleImports: compiler.options.optimization.mangleWasmImports
-					}).apply(compiler);
-					new FetchCompileAsyncWasmPlugin().apply(compiler);
-					break;
-				}
-				case "async-node": {
-					// TODO webpack 6 remove ReadFileCompileWasmPlugin
-					const ReadFileCompileWasmPlugin = __webpack_require__(98939);
-					// @ts-expect-error typescript bug for duplicate require
-					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
-					new ReadFileCompileWasmPlugin({
-						mangleImports: compiler.options.optimization.mangleWasmImports
-					}).apply(compiler);
-					new ReadFileCompileAsyncWasmPlugin({ type }).apply(compiler);
-					break;
-				}
-				case "async-node-module": {
-					// @ts-expect-error typescript bug for duplicate require
-					const ReadFileCompileAsyncWasmPlugin = __webpack_require__(73163);
-					new ReadFileCompileAsyncWasmPlugin({ type, import: true }).apply(
-						compiler
-					);
-					break;
-				}
-				case "universal":
-					throw new Error(
-						"Universal WebAssembly Loading is not implemented yet"
-					);
-				default:
-					throw new Error(`Unsupported wasm loading type ${type}.
-Plugins which provide custom wasm loading types must call EnableWasmLoadingPlugin.setEnabled(compiler, type) to disable this error.`);
-			}
-		} else {
-			// TODO support plugin instances here
-			// apply them to the compiler
-		}
-	}
+function AsyncParallelBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncParallelBailHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
 }
 
-module.exports = EnableWasmLoadingPlugin;
+AsyncParallelBailHook.prototype = null;
+
+module.exports = AsyncParallelBailHook;
 
 
 /***/ }),
 
-/***/ 8437:
+/***/ 45874:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139448,67 +139665,42 @@ module.exports = EnableWasmLoadingPlugin;
 */
 
 
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const AsyncWasmLoadingRuntimeModule = __webpack_require__(5434);
+class AsyncParallelHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
+	}
+}
 
-/** @typedef {import("../Compiler")} Compiler */
+const factory = new AsyncParallelHookCodeFactory();
 
-class FetchCompileAsyncWasmPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileAsyncWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.instantiateWasm)
-					.tap("FetchCompileAsyncWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/async"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
-							chunk,
-							new AsyncWasmLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true
-							})
-						);
-					});
-			}
-		);
-	}
+function AsyncParallelHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncParallelHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
 }
 
-module.exports = FetchCompileAsyncWasmPlugin;
+AsyncParallelHook.prototype = null;
+
+module.exports = AsyncParallelHook;
 
 
 /***/ }),
 
-/***/ 35537:
+/***/ 13633:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139518,76 +139710,47 @@ module.exports = FetchCompileAsyncWasmPlugin;
 */
 
 
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const WasmChunkLoadingRuntimeModule = __webpack_require__(87394);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-// TODO webpack 6 remove
-
-class FetchCompileWasmPlugin {
-	constructor(options) {
-		this.options = options || {};
+class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)}\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone
+		});
 	}
+}
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+const factory = new AsyncSeriesBailHookCodeFactory();
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("FetchCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
-							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
-	}
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function AsyncSeriesBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesBailHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
 }
 
-module.exports = FetchCompileWasmPlugin;
+AsyncSeriesBailHook.prototype = null;
+
+module.exports = AsyncSeriesBailHook;
 
 
 /***/ }),
 
-/***/ 83121:
+/***/ 40436:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -139597,544 +139760,142 @@ module.exports = FetchCompileWasmPlugin;
 */
 
 
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-const RuntimeGlobals = __webpack_require__(16475);
-const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
-
-/** @typedef {import("../Compiler")} Compiler */
-
-class JsonpChunkLoadingPlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"JsonpChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === "jsonp";
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					compilation.addRuntimeModule(
-						chunk,
-						new JsonpChunkLoadingRuntimeModule(set)
-					);
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("JsonpChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("JsonpChunkLoadingPlugin", handler);
-
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.loadScript);
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.loadScript);
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("JsonpChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
-			}
-		);
+class AsyncSeriesHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
 	}
 }
 
-module.exports = JsonpChunkLoadingPlugin;
+const factory = new AsyncSeriesHookCodeFactory();
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function AsyncSeriesHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
+
+AsyncSeriesHook.prototype = null;
+
+module.exports = AsyncSeriesHook;
 
 
 /***/ }),
 
-/***/ 84154:
+/***/ 34656:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
 */
 
 
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-const { SyncWaterfallHook } = __webpack_require__(41242);
-const Compilation = __webpack_require__(85720);
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const chunkHasJs = (__webpack_require__(89464).chunkHasJs);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
+class AsyncSeriesLoopHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsLooping({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
+	}
+}
 
-/** @typedef {import("../Chunk")} Chunk */
+const factory = new AsyncSeriesLoopHookCodeFactory();
 
-/**
- * @typedef {Object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
- */
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
+function AsyncSeriesLoopHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesLoopHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
 
-class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
+AsyncSeriesLoopHook.prototype = null;
 
-	constructor(runtimeRequirements) {
-		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
-		this._runtimeRequirements = runtimeRequirements;
-	}
+module.exports = AsyncSeriesLoopHook;
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const { chunkGraph, compilation, chunk } = this;
-		const {
-			runtimeTemplate,
-			outputOptions: {
-				chunkLoadingGlobal,
-				hotUpdateGlobal,
-				crossOriginLoading,
-				scriptType
-			}
-		} = compilation;
-		const globalObject = runtimeTemplate.globalObject;
-		const { linkPreload, linkPrefetch } =
-			JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withLoading = this._runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withCallback = this._runtimeRequirements.has(
-			RuntimeGlobals.chunkCallback
-		);
-		const withOnChunkLoad = this._runtimeRequirements.has(
-			RuntimeGlobals.onChunksLoaded
-		);
-		const withHmr = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this._runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const withPrefetch = this._runtimeRequirements.has(
-			RuntimeGlobals.prefetchChunkHandlers
-		);
-		const withPreload = this._runtimeRequirements.has(
-			RuntimeGlobals.preloadChunkHandlers
-		);
-		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
-			chunkLoadingGlobal
-		)}]`;
-		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
-		const hasJsMatcher = compileBooleanMatcher(conditionMap);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_jsonp`
-			: undefined;
+/***/ }),
 
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = document.baseURI || self.location.href;`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withLoading
-				? Template.asString([
-						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? Template.indent([
-										"// JSONP chunk loading for javascript",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[2]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasJsMatcher === true
-													? "if(true) { // all chunks have JS"
-													: `if(${hasJsMatcher("chunkId")}) {`,
-												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
-														"resolve, reject"
-													)});`,
-													"promises.push(installedChunkData[2] = promise);",
-													"",
-													"// start chunk loading",
-													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
-													"// create error before stack unwound to get useful stacktrace later",
-													"var error = new Error();",
-													`var loadingEnded = ${runtimeTemplate.basicFunction(
-														"event",
-														[
-															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
-															Template.indent([
-																"installedChunkData = installedChunks[chunkId];",
-																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
-																"if(installedChunkData) {",
-																Template.indent([
-																	"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-																	"var realSrc = event && event.target && event.target.src;",
-																	"error.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-																	"error.name = 'ChunkLoadError';",
-																	"error.type = errorType;",
-																	"error.request = realSrc;",
-																	"installedChunkData[1](error);"
-																]),
-																"}"
-															]),
-															"}"
-														]
-													)};`,
-													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
-												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ])
-								: Template.indent(["installedChunks[chunkId] = 0;"])
-						)};`
-				  ])
-				: "// no chunk on demand loading",
-			"",
-			withPrefetch && hasJsMatcher !== false
-				? `${
-						RuntimeGlobals.prefetchChunkHandlers
-				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
-						`if((!${
-							RuntimeGlobals.hasOwnProperty
-						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
-							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
-						}) {`,
-						Template.indent([
-							"installedChunks[chunkId] = null;",
-							linkPrefetch.call(
-								Template.asString([
-									"var link = document.createElement('link');",
-									crossOriginLoading
-										? `link.crossOrigin = ${JSON.stringify(
-												crossOriginLoading
-										  )};`
-										: "",
-									`if (${RuntimeGlobals.scriptNonce}) {`,
-									Template.indent(
-										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
-									),
-									"}",
-									'link.rel = "prefetch";',
-									'link.as = "script";',
-									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`
-								]),
-								chunk
-							),
-							"document.head.appendChild(link);"
-						]),
-						"}"
-				  ])};`
-				: "// no prefetching",
-			"",
-			withPreload && hasJsMatcher !== false
-				? `${
-						RuntimeGlobals.preloadChunkHandlers
-				  }.j = ${runtimeTemplate.basicFunction("chunkId", [
-						`if((!${
-							RuntimeGlobals.hasOwnProperty
-						}(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && ${
-							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
-						}) {`,
-						Template.indent([
-							"installedChunks[chunkId] = null;",
-							linkPreload.call(
-								Template.asString([
-									"var link = document.createElement('link');",
-									scriptType
-										? `link.type = ${JSON.stringify(scriptType)};`
-										: "",
-									"link.charset = 'utf-8';",
-									`if (${RuntimeGlobals.scriptNonce}) {`,
-									Template.indent(
-										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
-									),
-									"}",
-									'link.rel = "preload";',
-									'link.as = "script";',
-									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
-									crossOriginLoading
-										? Template.asString([
-												"if (link.href.indexOf(window.location.origin + '/') !== 0) {",
-												Template.indent(
-													`link.crossOrigin = ${JSON.stringify(
-														crossOriginLoading
-													)};`
-												),
-												"}"
-										  ])
-										: ""
-								]),
-								chunk
-							),
-							"document.head.appendChild(link);"
-						]),
-						"}"
-				  ])};`
-				: "// no preloaded",
-			"",
-			withHmr
-				? Template.asString([
-						"var currentUpdatedModulesList;",
-						"var waitingUpdateResolves = {};",
-						"function loadUpdateChunk(chunkId) {",
-						Template.indent([
-							`return new Promise(${runtimeTemplate.basicFunction(
-								"resolve, reject",
-								[
-									"waitingUpdateResolves[chunkId] = resolve;",
-									"// start update chunk loading",
-									`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
-									"// create error before stack unwound to get useful stacktrace later",
-									"var error = new Error();",
-									`var loadingEnded = ${runtimeTemplate.basicFunction("event", [
-										"if(waitingUpdateResolves[chunkId]) {",
-										Template.indent([
-											"waitingUpdateResolves[chunkId] = undefined",
-											"var errorType = event && (event.type === 'load' ? 'missing' : event.type);",
-											"var realSrc = event && event.target && event.target.src;",
-											"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-											"error.name = 'ChunkLoadError';",
-											"error.type = errorType;",
-											"error.request = realSrc;",
-											"reject(error);"
-										]),
-										"}"
-									])};`,
-									`${RuntimeGlobals.loadScript}(url, loadingEnded);`
-								]
-							)});`
-						]),
-						"}",
-						"",
-						`${globalObject}[${JSON.stringify(
-							hotUpdateGlobal
-						)}] = ${runtimeTemplate.basicFunction(
-							"chunkId, moreModules, runtime",
-							[
-								"for(var moduleId in moreModules) {",
-								Template.indent([
-									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-									Template.indent([
-										"currentUpdate[moduleId] = moreModules[moduleId];",
-										"if(currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);"
-									]),
-									"}"
-								]),
-								"}",
-								"if(runtime) currentUpdateRuntime.push(runtime);",
-								"if(waitingUpdateResolves[chunkId]) {",
-								Template.indent([
-									"waitingUpdateResolves[chunkId]();",
-									"waitingUpdateResolves[chunkId] = undefined;"
-								]),
-								"}"
-							]
-						)};`,
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "jsonp")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${
-							RuntimeGlobals.hmrDownloadManifest
-						} = ${runtimeTemplate.basicFunction("", [
-							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
-							`return fetch(${RuntimeGlobals.publicPath} + ${
-								RuntimeGlobals.getUpdateManifestFilename
-							}()).then(${runtimeTemplate.basicFunction("response", [
-								"if(response.status === 404) return; // no update available",
-								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
-								"return response.json();"
-							])});`
-						])};`
-				  ])
-				: "// no HMR manifest",
-			"",
-			withOnChunkLoad
-				? `${
-						RuntimeGlobals.onChunksLoaded
-				  }.j = ${runtimeTemplate.returningFunction(
-						"installedChunks[chunkId] === 0",
-						"chunkId"
-				  )};`
-				: "// no on chunks loaded",
-			"",
-			withCallback || withLoading
-				? Template.asString([
-						"// install a JSONP callback for chunk loading",
-						`var webpackJsonpCallback = ${runtimeTemplate.basicFunction(
-							"parentChunkLoadingFunction, data",
-							[
-								runtimeTemplate.destructureArray(
-									["chunkIds", "moreModules", "runtime"],
-									"data"
-								),
-								'// add "moreModules" to the modules object,',
-								'// then flag all "chunkIds" as loaded and fire callback',
-								"var moduleId, chunkId, i = 0;",
-								`if(chunkIds.some(${runtimeTemplate.returningFunction(
-									"installedChunks[id] !== 0",
-									"id"
-								)})) {`,
-								Template.indent([
-									"for(moduleId in moreModules) {",
-									Template.indent([
-										`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-										Template.indent(
-											`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-										),
-										"}"
-									]),
-									"}",
-									"if(runtime) var result = runtime(__webpack_require__);"
-								]),
-								"}",
-								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",
-								"for(;i < chunkIds.length; i++) {",
-								Template.indent([
-									"chunkId = chunkIds[i];",
-									`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
-									Template.indent("installedChunks[chunkId][0]();"),
-									"}",
-									"installedChunks[chunkId] = 0;"
-								]),
-								"}",
-								withOnChunkLoad
-									? `return ${RuntimeGlobals.onChunksLoaded}(result);`
-									: ""
-							]
-						)}`,
-						"",
-						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
-						"chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));",
-						"chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));"
-				  ])
-				: "// no jsonp function"
-		]);
+/***/ 47794:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
+
+class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0])
+		});
 	}
 }
 
-module.exports = JsonpChunkLoadingRuntimeModule;
+const factory = new AsyncSeriesWaterfallHookCodeFactory();
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function AsyncSeriesWaterfallHook(args = [], name = undefined) {
+	if (args.length < 1)
+		throw new Error("Waterfall hooks must have at least one argument");
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncSeriesWaterfallHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
+
+AsyncSeriesWaterfallHook.prototype = null;
+
+module.exports = AsyncSeriesWaterfallHook;
 
 
 /***/ }),
 
-/***/ 4607:
+/***/ 72258:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -140144,223 +139905,181 @@ module.exports = JsonpChunkLoadingRuntimeModule;
 */
 
 
+const util = __webpack_require__(73837);
 
-const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
-const JsonpChunkLoadingRuntimeModule = __webpack_require__(84154);
+const deprecateContext = util.deprecate(() => {},
+"Hook.context is deprecated and will be removed");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
+const CALL_DELEGATE = function(...args) {
+	this.call = this._createCall("sync");
+	return this.call(...args);
+};
+const CALL_ASYNC_DELEGATE = function(...args) {
+	this.callAsync = this._createCall("async");
+	return this.callAsync(...args);
+};
+const PROMISE_DELEGATE = function(...args) {
+	this.promise = this._createCall("promise");
+	return this.promise(...args);
+};
 
-class JsonpTemplatePlugin {
-	/**
-	 * @deprecated use JsonpChunkLoadingRuntimeModule.getCompilationHooks instead
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpChunkLoadingRuntimeModule.JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		return JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation);
-	}
+class Hook {
+	constructor(args = [], name = undefined) {
+		this._args = args;
+		this.name = name;
+		this.taps = [];
+		this.interceptors = [];
+		this._call = CALL_DELEGATE;
+		this.call = CALL_DELEGATE;
+		this._callAsync = CALL_ASYNC_DELEGATE;
+		this.callAsync = CALL_ASYNC_DELEGATE;
+		this._promise = PROMISE_DELEGATE;
+		this.promise = PROMISE_DELEGATE;
+		this._x = undefined;
 
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.options.output.chunkLoading = "jsonp";
-		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
-		new EnableChunkLoadingPlugin("jsonp").apply(compiler);
+		this.compile = this.compile;
+		this.tap = this.tap;
+		this.tapAsync = this.tapAsync;
+		this.tapPromise = this.tapPromise;
 	}
-}
 
-module.exports = JsonpTemplatePlugin;
-
-
-/***/ }),
+	compile(options) {
+		throw new Error("Abstract: should be overridden");
+	}
 
-/***/ 36243:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+	_createCall(type) {
+		return this.compile({
+			taps: this.taps,
+			interceptors: this.interceptors,
+			args: this._args,
+			type: type
+		});
+	}
 
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
+	_tap(type, options, fn) {
+		if (typeof options === "string") {
+			options = {
+				name: options.trim()
+			};
+		} else if (typeof options !== "object" || options === null) {
+			throw new Error("Invalid tap options");
+		}
+		if (typeof options.name !== "string" || options.name === "") {
+			throw new Error("Missing name for tap");
+		}
+		if (typeof options.context !== "undefined") {
+			deprecateContext();
+		}
+		options = Object.assign({ type, fn }, options);
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
 
+	tap(options, fn) {
+		this._tap("sync", options, fn);
+	}
 
+	tapAsync(options, fn) {
+		this._tap("async", options, fn);
+	}
 
-const util = __webpack_require__(73837);
-const webpackOptionsSchemaCheck = __webpack_require__(10382);
-const webpackOptionsSchema = __webpack_require__(73342);
-const Compiler = __webpack_require__(70845);
-const MultiCompiler = __webpack_require__(33370);
-const WebpackOptionsApply = __webpack_require__(88422);
-const {
-	applyWebpackOptionsDefaults,
-	applyWebpackOptionsBaseDefaults
-} = __webpack_require__(92988);
-const { getNormalizedWebpackOptions } = __webpack_require__(26693);
-const NodeEnvironmentPlugin = __webpack_require__(7553);
-const memoize = __webpack_require__(78676);
+	tapPromise(options, fn) {
+		this._tap("promise", options, fn);
+	}
 
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
-/** @typedef {import("./Compiler").WatchOptions} WatchOptions */
-/** @typedef {import("./MultiCompiler").MultiCompilerOptions} MultiCompilerOptions */
-/** @typedef {import("./MultiStats")} MultiStats */
-/** @typedef {import("./Stats")} Stats */
+	_runRegisterInterceptors(options) {
+		for (const interceptor of this.interceptors) {
+			if (interceptor.register) {
+				const newOptions = interceptor.register(options);
+				if (newOptions !== undefined) {
+					options = newOptions;
+				}
+			}
+		}
+		return options;
+	}
 
-const getValidateSchema = memoize(() => __webpack_require__(12047));
+	withOptions(options) {
+		const mergeOptions = opt =>
+			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
 
-/**
- * @template T
- * @callback Callback
- * @param {Error=} err
- * @param {T=} stats
- * @returns {void}
- */
+		return {
+			name: this.name,
+			tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
+			tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
+			tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
+			intercept: interceptor => this.intercept(interceptor),
+			isUsed: () => this.isUsed(),
+			withOptions: opt => this.withOptions(mergeOptions(opt))
+		};
+	}
 
-/**
- * @param {ReadonlyArray<WebpackOptions>} childOptions options array
- * @param {MultiCompilerOptions} options options
- * @returns {MultiCompiler} a multi-compiler
- */
-const createMultiCompiler = (childOptions, options) => {
-	const compilers = childOptions.map(options => createCompiler(options));
-	const compiler = new MultiCompiler(compilers, options);
-	for (const childCompiler of compilers) {
-		if (childCompiler.options.dependencies) {
-			compiler.setDependencies(
-				childCompiler,
-				childCompiler.options.dependencies
-			);
-		}
+	isUsed() {
+		return this.taps.length > 0 || this.interceptors.length > 0;
 	}
-	return compiler;
-};
 
-/**
- * @param {WebpackOptions} rawOptions options object
- * @returns {Compiler} a compiler
- */
-const createCompiler = rawOptions => {
-	const options = getNormalizedWebpackOptions(rawOptions);
-	applyWebpackOptionsBaseDefaults(options);
-	const compiler = new Compiler(options.context, options);
-	new NodeEnvironmentPlugin({
-		infrastructureLogging: options.infrastructureLogging
-	}).apply(compiler);
-	if (Array.isArray(options.plugins)) {
-		for (const plugin of options.plugins) {
-			if (typeof plugin === "function") {
-				plugin.call(compiler, compiler);
-			} else {
-				plugin.apply(compiler);
+	intercept(interceptor) {
+		this._resetCompilation();
+		this.interceptors.push(Object.assign({}, interceptor));
+		if (interceptor.register) {
+			for (let i = 0; i < this.taps.length; i++) {
+				this.taps[i] = interceptor.register(this.taps[i]);
 			}
 		}
 	}
-	applyWebpackOptionsDefaults(options);
-	compiler.hooks.environment.call();
-	compiler.hooks.afterEnvironment.call();
-	new WebpackOptionsApply().process(options, compiler);
-	compiler.hooks.initialize.call();
-	return compiler;
-};
-
-/**
- * @callback WebpackFunctionSingle
- * @param {WebpackOptions} options options object
- * @param {Callback<Stats>=} callback callback
- * @returns {Compiler} the compiler object
- */
-
-/**
- * @callback WebpackFunctionMulti
- * @param {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} options options objects
- * @param {Callback<MultiStats>=} callback callback
- * @returns {MultiCompiler} the multi compiler object
- */
 
-const asArray = options =>
-	Array.isArray(options) ? Array.from(options) : [options];
+	_resetCompilation() {
+		this.call = this._call;
+		this.callAsync = this._callAsync;
+		this.promise = this._promise;
+	}
 
-const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
-	/**
-	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
-	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
-	 * @returns {Compiler | MultiCompiler}
-	 */
-	(options, callback) => {
-		const create = () => {
-			if (!asArray(options).every(webpackOptionsSchemaCheck)) {
-				getValidateSchema()(webpackOptionsSchema, options);
-				util.deprecate(
-					() => {},
-					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
-					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
-				)();
-			}
-			/** @type {MultiCompiler|Compiler} */
-			let compiler;
-			let watch = false;
-			/** @type {WatchOptions|WatchOptions[]} */
-			let watchOptions;
-			if (Array.isArray(options)) {
-				/** @type {MultiCompiler} */
-				compiler = createMultiCompiler(
-					options,
-					/** @type {MultiCompilerOptions} */ (options)
-				);
-				watch = options.some(options => options.watch);
-				watchOptions = options.map(options => options.watchOptions || {});
-			} else {
-				const webpackOptions = /** @type {WebpackOptions} */ (options);
-				/** @type {Compiler} */
-				compiler = createCompiler(webpackOptions);
-				watch = webpackOptions.watch;
-				watchOptions = webpackOptions.watchOptions || {};
-			}
-			return { compiler, watch, watchOptions };
-		};
-		if (callback) {
-			try {
-				const { compiler, watch, watchOptions } = create();
-				if (watch) {
-					compiler.watch(watchOptions, callback);
-				} else {
-					compiler.run((err, stats) => {
-						compiler.close(err2 => {
-							callback(err || err2, stats);
-						});
-					});
+	_insert(item) {
+		this._resetCompilation();
+		let before;
+		if (typeof item.before === "string") {
+			before = new Set([item.before]);
+		} else if (Array.isArray(item.before)) {
+			before = new Set(item.before);
+		}
+		let stage = 0;
+		if (typeof item.stage === "number") {
+			stage = item.stage;
+		}
+		let i = this.taps.length;
+		while (i > 0) {
+			i--;
+			const x = this.taps[i];
+			this.taps[i + 1] = x;
+			const xStage = x.stage || 0;
+			if (before) {
+				if (before.has(x.name)) {
+					before.delete(x.name);
+					continue;
+				}
+				if (before.size > 0) {
+					continue;
 				}
-				return compiler;
-			} catch (err) {
-				process.nextTick(() => callback(err));
-				return null;
 			}
-		} else {
-			const { compiler, watch } = create();
-			if (watch) {
-				util.deprecate(
-					() => {},
-					"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
-					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
-				)();
+			if (xStage > stage) {
+				continue;
 			}
-			return compiler;
+			i++;
+			break;
 		}
+		this.taps[i] = item;
 	}
-);
+}
 
-module.exports = webpack;
+Object.setPrototypeOf(Hook.prototype, null);
+
+module.exports = Hook;
 
 
 /***/ }),
 
-/***/ 54182:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+/***/ 177:
+/***/ (function(module) {
 
 "use strict";
 /*
@@ -140369,335 +140088,473 @@ module.exports = webpack;
 */
 
 
+class HookCodeFactory {
+	constructor(config) {
+		this.config = config;
+		this.options = undefined;
+		this._args = undefined;
+	}
 
-const RuntimeGlobals = __webpack_require__(16475);
-const StartupChunkDependenciesPlugin = __webpack_require__(22339);
-const ImportScriptsChunkLoadingRuntimeModule = __webpack_require__(96952);
+	create(options) {
+		this.init(options);
+		let fn;
+		switch (this.options.type) {
+			case "sync":
+				fn = new Function(
+					this.args(),
+					'"use strict";\n' +
+						this.header() +
+						this.contentWithInterceptors({
+							onError: err => `throw ${err};\n`,
+							onResult: result => `return ${result};\n`,
+							resultReturns: true,
+							onDone: () => "",
+							rethrowIfPossible: true
+						})
+				);
+				break;
+			case "async":
+				fn = new Function(
+					this.args({
+						after: "_callback"
+					}),
+					'"use strict";\n' +
+						this.header() +
+						this.contentWithInterceptors({
+							onError: err => `_callback(${err});\n`,
+							onResult: result => `_callback(null, ${result});\n`,
+							onDone: () => "_callback();\n"
+						})
+				);
+				break;
+			case "promise":
+				let errorHelperUsed = false;
+				const content = this.contentWithInterceptors({
+					onError: err => {
+						errorHelperUsed = true;
+						return `_error(${err});\n`;
+					},
+					onResult: result => `_resolve(${result});\n`,
+					onDone: () => "_resolve();\n"
+				});
+				let code = "";
+				code += '"use strict";\n';
+				code += this.header();
+				code += "return new Promise((function(_resolve, _reject) {\n";
+				if (errorHelperUsed) {
+					code += "var _sync = true;\n";
+					code += "function _error(_err) {\n";
+					code += "if(_sync)\n";
+					code +=
+						"_resolve(Promise.resolve().then((function() { throw _err; })));\n";
+					code += "else\n";
+					code += "_reject(_err);\n";
+					code += "};\n";
+				}
+				code += content;
+				if (errorHelperUsed) {
+					code += "_sync = false;\n";
+				}
+				code += "}));\n";
+				fn = new Function(this.args(), code);
+				break;
+		}
+		this.deinit();
+		return fn;
+	}
 
-/** @typedef {import("../Compiler")} Compiler */
+	setup(instance, options) {
+		instance._x = options.taps.map(t => t.fn);
+	}
 
-class ImportScriptsChunkLoadingPlugin {
 	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
+	 * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
 	 */
-	apply(compiler) {
-		new StartupChunkDependenciesPlugin({
-			chunkLoading: "import-scripts",
-			asyncChunkLoading: true
-		}).apply(compiler);
-		compiler.hooks.thisCompilation.tap(
-			"ImportScriptsChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === "import-scripts";
-				};
-				const onceForChunkSet = new WeakSet();
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
-					if (!isEnabledForChunk(chunk)) return;
-					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
-					if (withCreateScriptUrl) {
-						set.add(RuntimeGlobals.createScriptUrl);
-					}
-					compilation.addRuntimeModule(
-						chunk,
-						new ImportScriptsChunkLoadingRuntimeModule(set, withCreateScriptUrl)
-					);
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("ImportScriptsChunkLoadingPlugin", handler);
+	init(options) {
+		this.options = options;
+		this._args = options.args.slice();
+	}
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.hmrModuleData);
-						set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.hmrDownloadManifest)
-					.tap("ImportScriptsChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-						set.add(RuntimeGlobals.getUpdateManifestFilename);
-					});
+	deinit() {
+		this.options = undefined;
+		this._args = undefined;
+	}
+
+	contentWithInterceptors(options) {
+		if (this.options.interceptors.length > 0) {
+			const onError = options.onError;
+			const onResult = options.onResult;
+			const onDone = options.onDone;
+			let code = "";
+			for (let i = 0; i < this.options.interceptors.length; i++) {
+				const interceptor = this.options.interceptors[i];
+				if (interceptor.call) {
+					code += `${this.getInterceptor(i)}.call(${this.args({
+						before: interceptor.context ? "_context" : undefined
+					})});\n`;
+				}
 			}
-		);
+			code += this.content(
+				Object.assign(options, {
+					onError:
+						onError &&
+						(err => {
+							let code = "";
+							for (let i = 0; i < this.options.interceptors.length; i++) {
+								const interceptor = this.options.interceptors[i];
+								if (interceptor.error) {
+									code += `${this.getInterceptor(i)}.error(${err});\n`;
+								}
+							}
+							code += onError(err);
+							return code;
+						}),
+					onResult:
+						onResult &&
+						(result => {
+							let code = "";
+							for (let i = 0; i < this.options.interceptors.length; i++) {
+								const interceptor = this.options.interceptors[i];
+								if (interceptor.result) {
+									code += `${this.getInterceptor(i)}.result(${result});\n`;
+								}
+							}
+							code += onResult(result);
+							return code;
+						}),
+					onDone:
+						onDone &&
+						(() => {
+							let code = "";
+							for (let i = 0; i < this.options.interceptors.length; i++) {
+								const interceptor = this.options.interceptors[i];
+								if (interceptor.done) {
+									code += `${this.getInterceptor(i)}.done();\n`;
+								}
+							}
+							code += onDone();
+							return code;
+						})
+				})
+			);
+			return code;
+		} else {
+			return this.content(options);
+		}
 	}
-}
-module.exports = ImportScriptsChunkLoadingPlugin;
 
+	header() {
+		let code = "";
+		if (this.needContext()) {
+			code += "var _context = {};\n";
+		} else {
+			code += "var _context;\n";
+		}
+		code += "var _x = this._x;\n";
+		if (this.options.interceptors.length > 0) {
+			code += "var _taps = this.taps;\n";
+			code += "var _interceptors = this.interceptors;\n";
+		}
+		return code;
+	}
 
-/***/ }),
-
-/***/ 96952:
-/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
-
-"use strict";
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/
-
-
-
-const RuntimeGlobals = __webpack_require__(16475);
-const RuntimeModule = __webpack_require__(16963);
-const Template = __webpack_require__(39722);
-const {
-	getChunkFilenameTemplate,
-	chunkHasJs
-} = __webpack_require__(89464);
-const { getInitialChunkIds } = __webpack_require__(98124);
-const compileBooleanMatcher = __webpack_require__(29404);
-const { getUndoPath } = __webpack_require__(82186);
-
-class ImportScriptsChunkLoadingRuntimeModule extends RuntimeModule {
-	constructor(runtimeRequirements, withCreateScriptUrl) {
-		super("importScripts chunk loading", RuntimeModule.STAGE_ATTACH);
-		this.runtimeRequirements = runtimeRequirements;
-		this._withCreateScriptUrl = withCreateScriptUrl;
+	needContext() {
+		for (const tap of this.options.taps) if (tap.context) return true;
+		return false;
 	}
 
-	/**
-	 * @returns {string} runtime code
-	 */
-	generate() {
-		const {
-			chunk,
-			chunkGraph,
-			compilation: {
-				runtimeTemplate,
-				outputOptions: { chunkLoadingGlobal, hotUpdateGlobal }
-			},
-			_withCreateScriptUrl: withCreateScriptUrl
-		} = this;
-		const globalObject = runtimeTemplate.globalObject;
-		const fn = RuntimeGlobals.ensureChunkHandlers;
-		const withBaseURI = this.runtimeRequirements.has(RuntimeGlobals.baseURI);
-		const withLoading = this.runtimeRequirements.has(
-			RuntimeGlobals.ensureChunkHandlers
-		);
-		const withHmr = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadUpdateHandlers
-		);
-		const withHmrManifest = this.runtimeRequirements.has(
-			RuntimeGlobals.hmrDownloadManifest
-		);
-		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
-			chunkLoadingGlobal
-		)}]`;
-		const hasJsMatcher = compileBooleanMatcher(
-			chunkGraph.getChunkConditionMap(chunk, chunkHasJs)
-		);
-		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
+	callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
+		let code = "";
+		let hasTapCached = false;
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.tap) {
+				if (!hasTapCached) {
+					code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};\n`;
+					hasTapCached = true;
+				}
+				code += `${this.getInterceptor(i)}.tap(${
+					interceptor.context ? "_context, " : ""
+				}_tap${tapIndex});\n`;
+			}
+		}
+		code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};\n`;
+		const tap = this.options.taps[tapIndex];
+		switch (tap.type) {
+			case "sync":
+				if (!rethrowIfPossible) {
+					code += `var _hasError${tapIndex} = false;\n`;
+					code += "try {\n";
+				}
+				if (onResult) {
+					code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
+						before: tap.context ? "_context" : undefined
+					})});\n`;
+				} else {
+					code += `_fn${tapIndex}(${this.args({
+						before: tap.context ? "_context" : undefined
+					})});\n`;
+				}
+				if (!rethrowIfPossible) {
+					code += "} catch(_err) {\n";
+					code += `_hasError${tapIndex} = true;\n`;
+					code += onError("_err");
+					code += "}\n";
+					code += `if(!_hasError${tapIndex}) {\n`;
+				}
+				if (onResult) {
+					code += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					code += onDone();
+				}
+				if (!rethrowIfPossible) {
+					code += "}\n";
+				}
+				break;
+			case "async":
+				let cbCode = "";
+				if (onResult)
+					cbCode += `(function(_err${tapIndex}, _result${tapIndex}) {\n`;
+				else cbCode += `(function(_err${tapIndex}) {\n`;
+				cbCode += `if(_err${tapIndex}) {\n`;
+				cbCode += onError(`_err${tapIndex}`);
+				cbCode += "} else {\n";
+				if (onResult) {
+					cbCode += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					cbCode += onDone();
+				}
+				cbCode += "}\n";
+				cbCode += "})";
+				code += `_fn${tapIndex}(${this.args({
+					before: tap.context ? "_context" : undefined,
+					after: cbCode
+				})});\n`;
+				break;
+			case "promise":
+				code += `var _hasResult${tapIndex} = false;\n`;
+				code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
+					before: tap.context ? "_context" : undefined
+				})});\n`;
+				code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)\n`;
+				code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');\n`;
+				code += `_promise${tapIndex}.then((function(_result${tapIndex}) {\n`;
+				code += `_hasResult${tapIndex} = true;\n`;
+				if (onResult) {
+					code += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					code += onDone();
+				}
+				code += `}), function(_err${tapIndex}) {\n`;
+				code += `if(_hasResult${tapIndex}) throw _err${tapIndex};\n`;
+				code += onError(`_err${tapIndex}`);
+				code += "});\n";
+				break;
+		}
+		return code;
+	}
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
+	callTapsSeries({
+		onError,
+		onResult,
+		resultReturns,
+		onDone,
+		doneReturns,
+		rethrowIfPossible
+	}) {
+		if (this.options.taps.length === 0) return onDone();
+		const firstAsync = this.options.taps.findIndex(t => t.type !== "sync");
+		const somethingReturns = resultReturns || doneReturns;
+		let code = "";
+		let current = onDone;
+		let unrollCounter = 0;
+		for (let j = this.options.taps.length - 1; j >= 0; j--) {
+			const i = j;
+			const unroll =
+				current !== onDone &&
+				(this.options.taps[i].type !== "sync" || unrollCounter++ > 20);
+			if (unroll) {
+				unrollCounter = 0;
+				code += `function _next${i}() {\n`;
+				code += current();
+				code += `}\n`;
+				current = () => `${somethingReturns ? "return " : ""}_next${i}();\n`;
 			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			this.compilation.outputOptions.path,
-			false
-		);
+			const done = current;
+			const doneBreak = skipDone => {
+				if (skipDone) return "";
+				return onDone();
+			};
+			const content = this.callTap(i, {
+				onError: error => onError(i, error, done, doneBreak),
+				onResult:
+					onResult &&
+					(result => {
+						return onResult(i, result, done, doneBreak);
+					}),
+				onDone: !onResult && done,
+				rethrowIfPossible:
+					rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
+			});
+			current = () => content;
+		}
+		code += current();
+		return code;
+	}
 
-		const stateExpression = withHmr
-			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_importScripts`
-			: undefined;
+	callTapsLooping({ onError, onDone, rethrowIfPossible }) {
+		if (this.options.taps.length === 0) return onDone();
+		const syncOnly = this.options.taps.every(t => t.type === "sync");
+		let code = "";
+		if (!syncOnly) {
+			code += "var _looper = (function() {\n";
+			code += "var _loopAsync = false;\n";
+		}
+		code += "var _loop;\n";
+		code += "do {\n";
+		code += "_loop = false;\n";
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.loop) {
+				code += `${this.getInterceptor(i)}.loop(${this.args({
+					before: interceptor.context ? "_context" : undefined
+				})});\n`;
+			}
+		}
+		code += this.callTapsSeries({
+			onError,
+			onResult: (i, result, next, doneBreak) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += "_loop = true;\n";
+				if (!syncOnly) code += "if(_loopAsync) _looper();\n";
+				code += doneBreak(true);
+				code += `} else {\n`;
+				code += next();
+				code += `}\n`;
+				return code;
+			},
+			onDone:
+				onDone &&
+				(() => {
+					let code = "";
+					code += "if(!_loop) {\n";
+					code += onDone();
+					code += "}\n";
+					return code;
+				}),
+			rethrowIfPossible: rethrowIfPossible && syncOnly
+		});
+		code += "} while(_loop);\n";
+		if (!syncOnly) {
+			code += "_loopAsync = true;\n";
+			code += "});\n";
+			code += "_looper();\n";
+		}
+		return code;
+	}
 
-		return Template.asString([
-			withBaseURI
-				? Template.asString([
-						`${RuntimeGlobals.baseURI} = self.location + ${JSON.stringify(
-							rootOutputDir ? "/../" + rootOutputDir : ""
-						)};`
-				  ])
-				: "// no baseURI",
-			"",
-			"// object to store loaded chunks",
-			'// "1" means "already loaded"',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 1`).join(
-					",\n"
-				)
-			),
-			"};",
-			"",
-			withLoading
-				? Template.asString([
-						"// importScripts chunk loading",
-						`var installChunk = ${runtimeTemplate.basicFunction("data", [
-							runtimeTemplate.destructureArray(
-								["chunkIds", "moreModules", "runtime"],
-								"data"
-							),
-							"for(var moduleId in moreModules) {",
-							Template.indent([
-								`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-								Template.indent(
-									`${RuntimeGlobals.moduleFactories}[moduleId] = moreModules[moduleId];`
-								),
-								"}"
-							]),
-							"}",
-							"if(runtime) runtime(__webpack_require__);",
-							"while(chunkIds.length)",
-							Template.indent("installedChunks[chunkIds.pop()] = 1;"),
-							"parentChunkLoadingFunction(data);"
-						])};`
-				  ])
-				: "// no chunk install function needed",
-			withLoading
-				? Template.asString([
-						`${fn}.i = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasJsMatcher !== false
-								? [
-										'// "1" is the signal for "already loaded"',
-										"if(!installedChunks[chunkId]) {",
-										Template.indent([
-											hasJsMatcher === true
-												? "if(true) { // all chunks have JS"
-												: `if(${hasJsMatcher("chunkId")}) {`,
-											Template.indent(
-												`importScripts(${
-													withCreateScriptUrl
-														? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`
-														: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId)`
-												});`
-											),
-											"}"
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 1;"
-						)};`,
-						"",
-						`var chunkLoadingGlobal = ${chunkLoadingGlobalExpr} = ${chunkLoadingGlobalExpr} || [];`,
-						"var parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);",
-						"chunkLoadingGlobal.push = installChunk;"
-				  ])
-				: "// no chunk loading",
-			"",
-			withHmr
-				? Template.asString([
-						"function loadUpdateChunk(chunkId, updatedModulesList) {",
-						Template.indent([
-							"var success = false;",
-							`${globalObject}[${JSON.stringify(
-								hotUpdateGlobal
-							)}] = ${runtimeTemplate.basicFunction("_, moreModules, runtime", [
-								"for(var moduleId in moreModules) {",
-								Template.indent([
-									`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
-									Template.indent([
-										"currentUpdate[moduleId] = moreModules[moduleId];",
-										"if(updatedModulesList) updatedModulesList.push(moduleId);"
-									]),
-									"}"
-								]),
-								"}",
-								"if(runtime) currentUpdateRuntime.push(runtime);",
-								"success = true;"
-							])};`,
-							"// start update chunk loading",
-							`importScripts(${
-								withCreateScriptUrl
-									? `${RuntimeGlobals.createScriptUrl}(${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId))`
-									: `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId)`
-							});`,
-							'if(!success) throw new Error("Loading update chunk failed for unknown reason");'
-						]),
-						"}",
-						"",
-						Template.getFunctionContent(
-							require('./JavascriptHotModuleReplacement.runtime.js')
-						)
-							.replace(/\$key\$/g, "importScrips")
-							.replace(/\$installedChunks\$/g, "installedChunks")
-							.replace(/\$loadUpdateChunk\$/g, "loadUpdateChunk")
-							.replace(/\$moduleCache\$/g, RuntimeGlobals.moduleCache)
-							.replace(/\$moduleFactories\$/g, RuntimeGlobals.moduleFactories)
-							.replace(
-								/\$ensureChunkHandlers\$/g,
-								RuntimeGlobals.ensureChunkHandlers
-							)
-							.replace(/\$hasOwnProperty\$/g, RuntimeGlobals.hasOwnProperty)
-							.replace(/\$hmrModuleData\$/g, RuntimeGlobals.hmrModuleData)
-							.replace(
-								/\$hmrDownloadUpdateHandlers\$/g,
-								RuntimeGlobals.hmrDownloadUpdateHandlers
-							)
-							.replace(
-								/\$hmrInvalidateModuleHandlers\$/g,
-								RuntimeGlobals.hmrInvalidateModuleHandlers
-							)
-				  ])
-				: "// no HMR",
-			"",
-			withHmrManifest
-				? Template.asString([
-						`${
-							RuntimeGlobals.hmrDownloadManifest
-						} = ${runtimeTemplate.basicFunction("", [
-							'if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");',
-							`return fetch(${RuntimeGlobals.publicPath} + ${
-								RuntimeGlobals.getUpdateManifestFilename
-							}()).then(${runtimeTemplate.basicFunction("response", [
-								"if(response.status === 404) return; // no update available",
-								'if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);',
-								"return response.json();"
-							])});`
-						])};`
-				  ])
-				: "// no HMR manifest"
-		]);
+	callTapsParallel({
+		onError,
+		onResult,
+		onDone,
+		rethrowIfPossible,
+		onTap = (i, run) => run()
+	}) {
+		if (this.options.taps.length <= 1) {
+			return this.callTapsSeries({
+				onError,
+				onResult,
+				onDone,
+				rethrowIfPossible
+			});
+		}
+		let code = "";
+		code += "do {\n";
+		code += `var _counter = ${this.options.taps.length};\n`;
+		if (onDone) {
+			code += "var _done = (function() {\n";
+			code += onDone();
+			code += "});\n";
+		}
+		for (let i = 0; i < this.options.taps.length; i++) {
+			const done = () => {
+				if (onDone) return "if(--_counter === 0) _done();\n";
+				else return "--_counter;";
+			};
+			const doneBreak = skipDone => {
+				if (skipDone || !onDone) return "_counter = 0;\n";
+				else return "_counter = 0;\n_done();\n";
+			};
+			code += "if(_counter <= 0) break;\n";
+			code += onTap(
+				i,
+				() =>
+					this.callTap(i, {
+						onError: error => {
+							let code = "";
+							code += "if(_counter > 0) {\n";
+							code += onError(i, error, done, doneBreak);
+							code += "}\n";
+							return code;
+						},
+						onResult:
+							onResult &&
+							(result => {
+								let code = "";
+								code += "if(_counter > 0) {\n";
+								code += onResult(i, result, done, doneBreak);
+								code += "}\n";
+								return code;
+							}),
+						onDone:
+							!onResult &&
+							(() => {
+								return done();
+							}),
+						rethrowIfPossible
+					}),
+				done,
+				doneBreak
+			);
+		}
+		code += "} while(false);\n";
+		return code;
+	}
+
+	args({ before, after } = {}) {
+		let allArgs = this._args;
+		if (before) allArgs = [before].concat(allArgs);
+		if (after) allArgs = allArgs.concat(after);
+		if (allArgs.length === 0) {
+			return "";
+		} else {
+			return allArgs.join(", ");
+		}
+	}
+
+	getTapFn(idx) {
+		return `_x[${idx}]`;
+	}
+
+	getTap(idx) {
+		return `_taps[${idx}]`;
+	}
+
+	getInterceptor(idx) {
+		return `_interceptors[${idx}]`;
 	}
 }
 
-module.exports = ImportScriptsChunkLoadingRuntimeModule;
+module.exports = HookCodeFactory;
 
 
 /***/ }),
 
-/***/ 68693:
+/***/ 5504:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -140707,240 +140564,383 @@ module.exports = ImportScriptsChunkLoadingRuntimeModule;
 */
 
 
+const util = __webpack_require__(73837);
 
-const ArrayPushCallbackChunkFormatPlugin = __webpack_require__(18535);
-const EnableChunkLoadingPlugin = __webpack_require__(61291);
+const defaultFactory = (key, hook) => hook;
 
-/** @typedef {import("../Compiler")} Compiler */
+class HookMap {
+	constructor(factory, name = undefined) {
+		this._map = new Map();
+		this.name = name;
+		this._factory = factory;
+		this._interceptors = [];
+	}
 
-class WebWorkerTemplatePlugin {
-	/**
-	 * Apply the plugin
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.options.output.chunkLoading = "import-scripts";
-		new ArrayPushCallbackChunkFormatPlugin().apply(compiler);
-		new EnableChunkLoadingPlugin("import-scripts").apply(compiler);
+	get(key) {
+		return this._map.get(key);
+	}
+
+	for(key) {
+		const hook = this.get(key);
+		if (hook !== undefined) {
+			return hook;
+		}
+		let newHook = this._factory(key);
+		const interceptors = this._interceptors;
+		for (let i = 0; i < interceptors.length; i++) {
+			newHook = interceptors[i].factory(key, newHook);
+		}
+		this._map.set(key, newHook);
+		return newHook;
+	}
+
+	intercept(interceptor) {
+		this._interceptors.push(
+			Object.assign(
+				{
+					factory: defaultFactory
+				},
+				interceptor
+			)
+		);
 	}
 }
-module.exports = WebWorkerTemplatePlugin;
+
+HookMap.prototype.tap = util.deprecate(function(key, options, fn) {
+	return this.for(key).tap(options, fn);
+}, "HookMap#tap(key,…) is deprecated. Use HookMap#for(key).tap(…) instead.");
+
+HookMap.prototype.tapAsync = util.deprecate(function(key, options, fn) {
+	return this.for(key).tapAsync(options, fn);
+}, "HookMap#tapAsync(key,…) is deprecated. Use HookMap#for(key).tapAsync(…) instead.");
+
+HookMap.prototype.tapPromise = util.deprecate(function(key, options, fn) {
+	return this.for(key).tapPromise(options, fn);
+}, "HookMap#tapPromise(key,…) is deprecated. Use HookMap#for(key).tapPromise(…) instead.");
+
+module.exports = HookMap;
 
 
 /***/ }),
 
-/***/ 50569:
+/***/ 1081:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-/*!
- * mime-db
- * Copyright(c) 2014 Jonathan Ong
- * MIT Licensed
- */
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-/**
- * Module exports.
- */
 
-module.exports = __webpack_require__(58750)
+const Hook = __webpack_require__(72258);
+
+class MultiHook {
+	constructor(hooks, name = undefined) {
+		this.hooks = hooks;
+		this.name = name;
+	}
+
+	tap(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tap(options, fn);
+		}
+	}
+
+	tapAsync(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapAsync(options, fn);
+		}
+	}
+
+	tapPromise(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapPromise(options, fn);
+		}
+	}
+
+	isUsed() {
+		for (const hook of this.hooks) {
+			if (hook.isUsed()) return true;
+		}
+		return false;
+	}
+
+	intercept(interceptor) {
+		for (const hook of this.hooks) {
+			hook.intercept(interceptor);
+		}
+	}
+
+	withOptions(options) {
+		return new MultiHook(
+			this.hooks.map(h => h.withOptions(options)),
+			this.name
+		);
+	}
+}
+
+module.exports = MultiHook;
 
 
 /***/ }),
 
-/***/ 78585:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+/***/ 79106:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
-/*!
- * mime-types
- * Copyright(c) 2014 Jonathan Ong
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
 
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-/**
- * Module dependencies.
- * @private
- */
+class SyncBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)};\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
 
-var db = __webpack_require__(50569)
-var extname = (__webpack_require__(71017).extname)
+const factory = new SyncBailHookCodeFactory();
 
-/**
- * Module variables.
- * @private
- */
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncBailHook");
+};
 
-var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
-var TEXT_TYPE_REGEXP = /^text\//i
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncBailHook");
+};
 
-/**
- * Module exports.
- * @public
- */
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-exports.charset = charset
-exports.charsets = { lookup: charset }
-exports.contentType = contentType
-exports.extension = extension
-exports.extensions = Object.create(null)
-exports.lookup = lookup
-exports.types = Object.create(null)
+function SyncBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncBailHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
 
-// Populate the extensions/types maps
-populateMaps(exports.extensions, exports.types)
+SyncBailHook.prototype = null;
 
-/**
- * Get the default charset for a MIME type.
- *
- * @param {string} type
- * @return {boolean|string}
- */
+module.exports = SyncBailHook;
 
-function charset (type) {
-  if (!type || typeof type !== 'string') {
-    return false
-  }
 
-  // TODO: use media-typer
-  var match = EXTRACT_TYPE_REGEXP.exec(type)
-  var mime = match && db[match[1].toLowerCase()]
+/***/ }),
 
-  if (mime && mime.charset) {
-    return mime.charset
-  }
+/***/ 10533:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-  // default text/* to utf-8
-  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
-    return 'UTF-8'
-  }
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-  return false
-}
 
-/**
- * Create a full Content-Type header given a MIME type or extension.
- *
- * @param {string} str
- * @return {boolean|string}
- */
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-function contentType (str) {
-  // TODO: should this even be in this module?
-  if (!str || typeof str !== 'string') {
-    return false
-  }
+class SyncHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
 
-  var mime = str.indexOf('/') === -1
-    ? exports.lookup(str)
-    : str
+const factory = new SyncHookCodeFactory();
 
-  if (!mime) {
-    return false
-  }
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncHook");
+};
 
-  // TODO: use content-type or other module
-  if (mime.indexOf('charset') === -1) {
-    var charset = exports.charset(mime)
-    if (charset) mime += '; charset=' + charset.toLowerCase()
-  }
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncHook");
+};
 
-  return mime
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function SyncHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
 }
 
-/**
- * Get the default extension for a MIME type.
- *
- * @param {string} type
- * @return {boolean|string}
- */
+SyncHook.prototype = null;
 
-function extension (type) {
-  if (!type || typeof type !== 'string') {
-    return false
-  }
+module.exports = SyncHook;
 
-  // TODO: use media-typer
-  var match = EXTRACT_TYPE_REGEXP.exec(type)
 
-  // get extensions
-  var exts = match && exports.extensions[match[1].toLowerCase()]
+/***/ }),
 
-  if (!exts || !exts.length) {
-    return false
-  }
+/***/ 95854:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-  return exts[0]
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
+
+class SyncLoopHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsLooping({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
+	}
 }
 
-/**
- * Lookup the MIME type for a file path/extension.
- *
- * @param {string} path
- * @return {boolean|string}
- */
+const factory = new SyncLoopHookCodeFactory();
 
-function lookup (path) {
-  if (!path || typeof path !== 'string') {
-    return false
-  }
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncLoopHook");
+};
 
-  // get the extension ("ext" or ".ext" or full path)
-  var extension = extname('x.' + path)
-    .toLowerCase()
-    .substr(1)
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncLoopHook");
+};
 
-  if (!extension) {
-    return false
-  }
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
 
-  return exports.types[extension] || false
+function SyncLoopHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncLoopHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
 }
 
-/**
- * Populate the extensions and types maps.
- * @private
- */
+SyncLoopHook.prototype = null;
 
-function populateMaps (extensions, types) {
-  // source preference (least -> most)
-  var preference = ['nginx', 'apache', undefined, 'iana']
+module.exports = SyncLoopHook;
 
-  Object.keys(db).forEach(function forEachMimeType (type) {
-    var mime = db[type]
-    var exts = mime.extensions
 
-    if (!exts || !exts.length) {
-      return
-    }
+/***/ }),
 
-    // mime -> extensions
-    extensions[type] = exts
+/***/ 60176:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-    // extension -> mime
-    for (var i = 0; i < exts.length; i++) {
-      var extension = exts[i]
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
 
-      if (types[extension]) {
-        var from = preference.indexOf(db[types[extension]].source)
-        var to = preference.indexOf(mime.source)
 
-        if (types[extension] !== 'application/octet-stream' &&
-          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
-          // skip the remapping
-          continue
-        }
-      }
+const Hook = __webpack_require__(72258);
+const HookCodeFactory = __webpack_require__(177);
 
-      // set the extension -> mime
-      types[extension] = type
-    }
-  })
+class SyncWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0]),
+			doneReturns: resultReturns,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncWaterfallHookCodeFactory();
+
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncWaterfallHook");
+};
+
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncWaterfallHook");
+};
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function SyncWaterfallHook(args = [], name = undefined) {
+	if (args.length < 1)
+		throw new Error("Waterfall hooks must have at least one argument");
+	const hook = new Hook(args, name);
+	hook.constructor = SyncWaterfallHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
 }
 
+SyncWaterfallHook.prototype = null;
+
+module.exports = SyncWaterfallHook;
+
+
+/***/ }),
+
+/***/ 6967:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+
+exports.__esModule = true;
+exports.SyncHook = __webpack_require__(10533);
+exports.SyncBailHook = __webpack_require__(79106);
+exports.SyncWaterfallHook = __webpack_require__(60176);
+exports.SyncLoopHook = __webpack_require__(95854);
+exports.AsyncParallelHook = __webpack_require__(45874);
+exports.AsyncParallelBailHook = __webpack_require__(76297);
+exports.AsyncSeriesHook = __webpack_require__(40436);
+exports.AsyncSeriesBailHook = __webpack_require__(13633);
+exports.AsyncSeriesLoopHook = __webpack_require__(34656);
+exports.AsyncSeriesWaterfallHook = __webpack_require__(47794);
+exports.HookMap = __webpack_require__(5504);
+exports.MultiHook = __webpack_require__(1081);
+
 
 /***/ }),
 
diff --git a/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts b/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
index b8c8a00bbdc8d..fc4b7cf5459f9 100644
--- a/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
+++ b/packages/react-refresh-utils/internal/ReactRefreshModule.runtime.ts
@@ -5,7 +5,7 @@ declare const self: Window & RefreshRuntimeGlobals
 type Dictionary = { [key: string]: unknown }
 declare const __webpack_module__: {
   id: string
-  __proto__: { exports: unknown }
+  exports: unknown
   hot: {
     accept: () => void
     dispose: (onDispose: (data: Dictionary) => void) => void
@@ -28,7 +28,7 @@ export default function () {
       '$RefreshHelpers$' in self
     ) {
       // @ts-ignore __webpack_module__ is global
-      var currentExports = __webpack_module__.__proto__.exports
+      var currentExports = __webpack_module__.exports
       // @ts-ignore __webpack_module__ is global
       var prevExports = __webpack_module__.hot.data?.prevExports ?? null
 
@@ -49,7 +49,8 @@ export default function () {
         })
         // Unconditionally accept an update to this module, we'll check if it's
         // still a Refresh Boundary later.
-        __webpack_module__.hot.accept()
+        // @ts-ignore importMeta is replaced in the loader
+        global.importMeta.webpackHot.accept()
 
         // This field is set when the previous version of this module was a
         // Refresh Boundary, letting us know we need to check for invalidation or
diff --git a/packages/react-refresh-utils/loader.ts b/packages/react-refresh-utils/loader.ts
index c44198429f665..db004beba9911 100644
--- a/packages/react-refresh-utils/loader.ts
+++ b/packages/react-refresh-utils/loader.ts
@@ -2,10 +2,12 @@ import type { LoaderDefinition } from 'webpack'
 import RefreshModuleRuntime from './internal/ReactRefreshModule.runtime'
 
 let refreshModuleRuntime = RefreshModuleRuntime.toString()
-refreshModuleRuntime = refreshModuleRuntime.slice(
-  refreshModuleRuntime.indexOf('{') + 1,
-  refreshModuleRuntime.lastIndexOf('}')
-)
+refreshModuleRuntime = refreshModuleRuntime
+  .slice(
+    refreshModuleRuntime.indexOf('{') + 1,
+    refreshModuleRuntime.lastIndexOf('}')
+  )
+  .replace('global.importMeta', 'import.meta')
 
 const ReactRefreshLoader: LoaderDefinition = function ReactRefreshLoader(
   source,

From 9da70cf3c1380f7c3ac84a7239b0f443a4bda84c Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Tue, 15 Feb 2022 14:03:21 +0100
Subject: [PATCH 7/8] Revert changes to webpack-config

---
 packages/next/build/webpack-config.ts | 29 +++++++++------------------
 1 file changed, 9 insertions(+), 20 deletions(-)

diff --git a/packages/next/build/webpack-config.ts b/packages/next/build/webpack-config.ts
index d84778ead0e3c..20c86444faa5a 100644
--- a/packages/next/build/webpack-config.ts
+++ b/packages/next/build/webpack-config.ts
@@ -1265,26 +1265,15 @@ export default async function getBaseWebpackConfig(
               use: getBabelOrSwcLoader(true),
             },
             {
-              rules: [
-                hasReactRefresh && {
-                  ...codeCondition,
-                  exclude: (excludePath: string) => {
-                    // Unlike the normal code condition react-refresh-utils should only be applied to first-party code
-                    // Because of this Next.js internals are excluded as well in this condition
-                    if (babelIncludeRegexes.some((r) => r.test(excludePath))) {
-                      return true
-                    }
-                    return codeCondition.exclude(excludePath)
-                  },
-                  use: require.resolve(
-                    'next/dist/compiled/@next/react-refresh-utils/loader'
-                  ),
-                },
-                {
-                  ...codeCondition,
-                  use: defaultLoaders.babel,
-                },
-              ].filter(Boolean),
+              ...codeCondition,
+              use: hasReactRefresh
+                ? [
+                    require.resolve(
+                      'next/dist/compiled/@next/react-refresh-utils/loader'
+                    ),
+                    defaultLoaders.babel,
+                  ]
+                : defaultLoaders.babel,
             },
           ],
         },

From 3c000c7005d9308361b6fafcf07077bee52f6612 Mon Sep 17 00:00:00 2001
From: Tim Neutkens <tim@timneutkens.nl>
Date: Tue, 15 Feb 2022 15:44:53 +0100
Subject: [PATCH 8/8] Fix issue with `.cjs` files not having import.meta

---
 packages/react-refresh-utils/loader.ts | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/packages/react-refresh-utils/loader.ts b/packages/react-refresh-utils/loader.ts
index db004beba9911..85a321aaa51f0 100644
--- a/packages/react-refresh-utils/loader.ts
+++ b/packages/react-refresh-utils/loader.ts
@@ -7,13 +7,28 @@ refreshModuleRuntime = refreshModuleRuntime
     refreshModuleRuntime.indexOf('{') + 1,
     refreshModuleRuntime.lastIndexOf('}')
   )
+  // Given that the import above executes the module we need to make sure it does not crash on `import.meta` not being allowed.
   .replace('global.importMeta', 'import.meta')
 
+let commonJsrefreshModuleRuntime = refreshModuleRuntime.replace(
+  'import.meta.webpackHot',
+  'module.hot'
+)
+
 const ReactRefreshLoader: LoaderDefinition = function ReactRefreshLoader(
   source,
   inputSourceMap
 ) {
-  this.callback(null, `${source}\n\n;${refreshModuleRuntime}`, inputSourceMap)
+  this.callback(
+    null,
+    `${source}\n\n;${
+      // Account for commonjs not supporting `import.meta
+      this.resourcePath.endsWith('.cjs')
+        ? commonJsrefreshModuleRuntime
+        : refreshModuleRuntime
+    }`,
+    inputSourceMap
+  )
 }
 
 export default ReactRefreshLoader